diff --git a/.github/scripts/build_javadocs.sh b/.github/scripts/build_javadocs.sh
index 97d81e29d47..3783b69812b 100755
--- a/.github/scripts/build_javadocs.sh
+++ b/.github/scripts/build_javadocs.sh
@@ -207,7 +207,8 @@ java/util/concurrent/TimeoutException.java"
 python3 "$ROOT_DIR/scripts/check-backend-jdk-surface.py"
 {
   find "$BACKEND_STAGE" -name "*.java" | grep -v '/com/codename1/impl/'
-  find "$ROOT_DIR/Ports/CLDC11/src" -name "*.java"
+  # The class library's internal com.codename1.impl.JdkHost lives there too.
+  find "$ROOT_DIR/Ports/CLDC11/src" -name "*.java" | grep -v '/com/codename1/impl/'
   echo "$BACKEND_PROMOTED_JDK" | while IFS= read -r promoted; do
     echo "$ROOT_DIR/vm/JavaAPI/src/$promoted"
   done
diff --git a/.github/workflows/ant.yml b/.github/workflows/ant.yml
index 70e9cf4e3ac..8c0445710b3 100644
--- a/.github/workflows/ant.yml
+++ b/.github/workflows/ant.yml
@@ -22,7 +22,9 @@ jobs:
   build-linux-jdk8:
 
     runs-on: ubuntu-24.04
-    # Includes archetype integration tests and backend packaging after the Ant build.
+    # Includes archetype integration tests and backend packaging after the Ant
+    # build, and the Swing and JavaFX compatibility modules in the reactor it
+    # builds and tests.
     timeout-minutes: 75
 
     steps:
diff --git a/.github/workflows/desktop-compat-benchmarks.yml b/.github/workflows/desktop-compat-benchmarks.yml
new file mode 100644
index 00000000000..c7d00ce9704
--- /dev/null
+++ b/.github/workflows/desktop-compat-benchmarks.yml
@@ -0,0 +1,293 @@
+name: Desktop compatibility benchmarks
+
+# The two in-tree desktop samples (scripts/desktop-compat-samples) built as what
+# their developer ships today -- jar, jlink runtime image, jpackage application
+# image -- and as native Codename One executables, then measured side by side:
+# distributable size, memory, start-up and idle CPU.
+#
+# This is a measurement, not a gate: a job fails when the harness breaks, never
+# because a number moved. Each leg uploads benchmarks-<os>.json and the same
+# figures as a markdown table. scripts/desktop-compat-benchmarks/README.md says
+# what every column means and how it was taken.
+#
+#   linux     the reference leg: the same install script, driver and input
+#             scripts as the container the committed numbers came from
+#   macos     sizes, and the runtime figures run-macos-bench.sh takes (start-up
+#             to first window, idle memory and CPU; no scripted input)
+#   windows   sizes, and the same reduced runtime figures through
+#             win-measure.ps1. NOTHING on this leg has run outside CI: nobody
+#             had a Windows machine when it was written.
+#
+# Shared runners are noisy and have few cores. Compare the columns of one run
+# with each other, not one run with another.
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [ master ]
+    paths:
+      - 'scripts/desktop-compat-benchmarks/**'
+      - '.github/workflows/desktop-compat-benchmarks.yml'
+  push:
+    branches: [ master ]
+    paths:
+      - 'scripts/desktop-compat-benchmarks/**'
+      - '.github/workflows/desktop-compat-benchmarks.yml'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  # The modules a native build of an imported desktop project resolves, plus
+  # everything they depend on (-am). The port module is added per leg.
+  BENCH_MODULES: parparvm,swing-compat,javafx-compat,fxml-compiler,codenameone-maven-plugin,cn1app-archetype
+
+jobs:
+  linux:
+    name: Linux (x64, Xvfb)
+    runs-on: ubuntu-latest
+    timeout-minutes: 240
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up JDK 8
+        uses: actions/setup-java@v5
+        with:
+          java-version: '8'
+          distribution: 'temurin'
+          cache: 'maven'
+      - run: echo "JDK_8_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      # The same script the benchmark container is built from: the GTK stack,
+      # Xvfb and a window manager, JDK 17 and 21, zig, the OpenJFX jmods.
+      - name: Install the toolchain and the measuring tools
+        run: sudo bash scripts/desktop-compat-benchmarks/install-linux-deps.sh /opt/bench/tools
+      - name: Build Codename One (JDK 8)
+        env:
+          RETRY_ONLY_MATCHING: transient
+          RETRY_ATTEMPTS: '5'
+          RETRY_DELAY_SECONDS: '60'
+        run: |
+          cd maven
+          JAVA_HOME="$JDK_8_HOME" bash ../scripts/ci/retry.sh xvfb-run -a mvn -B \
+            -pl "linux,$BENCH_MODULES" -am -Plocal-dev-javase -DskipTests \
+            -Darchetype.test.skip=true -Dmaven.javadoc.skip=true install
+      - name: Build and measure the samples
+        env:
+          BENCH_JAVAFX_JMODS: /opt/bench/tools/javafx-jmods
+          CN1_CC: /opt/bench/tools/cn1-zig-cc
+          BENCH_XVFB: '1'
+          BENCH_IMAGE_NAME: GitHub-hosted ubuntu-latest runner
+          BENCH_COMMIT: ${{ github.sha }}
+        run: |
+          ARCH="$(dpkg --print-architecture)"
+          export JAVA17_HOME="/usr/lib/jvm/java-17-openjdk-$ARCH"
+          export BENCH_JDK21_HOME="/usr/lib/jvm/java-21-openjdk-$ARCH"
+          export PATH="/opt/bench/tools/zig:$PATH"
+          bash scripts/desktop-compat-benchmarks/bench-samples.sh \
+            --work "$RUNNER_TEMP/bench" --out "$GITHUB_WORKSPACE/benchmark-results"
+          cat benchmark-results/benchmarks-linux.md >> "$GITHUB_STEP_SUMMARY"
+      - name: Upload the results
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: benchmarks-linux
+          path: benchmark-results/
+          if-no-files-found: warn
+      - name: Upload the logs and screenshots
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: benchmarks-linux-logs
+          path: ${{ runner.temp }}/bench/*/logs/
+          if-no-files-found: ignore
+
+  macos:
+    name: macOS (arm64)
+    runs-on: macos-latest
+    timeout-minutes: 240
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+      - run: echo "BENCH_JDK21_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - run: echo "JAVA17_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      # Zulu: Temurin publishes no JDK 8 for Apple silicon.
+      - name: Set up JDK 8
+        uses: actions/setup-java@v5
+        with:
+          java-version: '8'
+          distribution: 'zulu'
+          cache: 'maven'
+      - run: echo "JDK_8_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      - name: Build Codename One (JDK 8)
+        env:
+          RETRY_ONLY_MATCHING: transient
+          RETRY_ATTEMPTS: '5'
+          RETRY_DELAY_SECONDS: '60'
+        run: |
+          cd maven
+          JAVA_HOME="$JDK_8_HOME" bash ../scripts/ci/retry.sh mvn -B \
+            -pl "mac,ios,$BENCH_MODULES" -am -Plocal-dev-javase -DskipTests \
+            -Darchetype.test.skip=true -Dmaven.javadoc.skip=true -Djava.awt.headless=true install
+      - name: OpenJFX jmods
+        run: |
+          bash scripts/desktop-compat-benchmarks/javafx-jmods.sh "$BENCH_JDK21_HOME" "$RUNNER_TEMP/javafx-jmods"
+          echo "BENCH_JAVAFX_JMODS=$RUNNER_TEMP/javafx-jmods" >> "$GITHUB_ENV"
+      - name: Build the samples (sizes)
+        env:
+          BENCH_COMMIT: ${{ github.sha }}
+        run: |
+          bash scripts/desktop-compat-benchmarks/bench-samples.sh --stage build \
+            --work "$RUNNER_TEMP/bench" --out "$GITHUB_WORKSPACE/benchmark-results"
+      # The runner has a logged-in desktop session, which is what this needs:
+      # it opens each application's window in turn.
+      - name: Measure the samples (start-up, idle memory and CPU)
+        run: |
+          for NAME in swing-gallery javafx-gallery; do
+            bash scripts/desktop-compat-benchmarks/run-macos-bench.sh --work "$RUNNER_TEMP/bench" --name "$NAME" \
+              || echo "::warning::run-macos-bench.sh failed for $NAME"
+          done
+          python3 scripts/desktop-compat-benchmarks/benchutil.py collect benchmark-results/benchmarks-macos.json \
+            "$RUNNER_TEMP"/bench/*/result.json
+          python3 scripts/desktop-compat-benchmarks/report.py --out benchmark-results/benchmarks-macos.md \
+            "$RUNNER_TEMP"/bench/*/result.json
+          cat benchmark-results/benchmarks-macos.md >> "$GITHUB_STEP_SUMMARY"
+      - name: Upload the results
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: benchmarks-macos
+          path: benchmark-results/
+          if-no-files-found: warn
+      - name: Upload the logs
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: benchmarks-macos-logs
+          path: ${{ runner.temp }}/bench/*/logs/
+          if-no-files-found: ignore
+
+  windows:
+    name: Windows (x64)
+    runs-on: windows-latest
+    timeout-minutes: 240
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v6
+      # clang-cl uses the MSVC headers, CRT and linker, so the MSVC developer
+      # environment has to be on PATH for the cmake the builder spawns.
+      - name: Set up the MSVC developer environment
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: amd64
+      - name: Install Ninja
+        run: |
+          python -m pip install --upgrade ninja
+          ninja --version
+          clang-cl --version
+      - name: Set up JDK 21
+        uses: actions/setup-java@v5
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+      - run: echo "BENCH_JDK21_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      - name: Set up JDK 17
+        uses: actions/setup-java@v5
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - run: echo "JAVA17_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      - name: Set up JDK 8
+        uses: actions/setup-java@v5
+        with:
+          java-version: '8'
+          distribution: 'temurin'
+          cache: 'maven'
+      - run: echo "JDK_8_HOME=$JAVA_HOME" >> "$GITHUB_ENV"
+      # The scripts call python3; the runner's interpreter is "python".
+      - name: Provide python3
+        run: |
+          mkdir -p "$RUNNER_TEMP/bin"
+          printf '#!/bin/sh\nexec python "$@"\n' > "$RUNNER_TEMP/bin/python3"
+          chmod +x "$RUNNER_TEMP/bin/python3"
+          echo "$RUNNER_TEMP/bin" >> "$GITHUB_PATH"
+      - name: Build Codename One (JDK 8)
+        env:
+          RETRY_ONLY_MATCHING: transient
+          RETRY_ATTEMPTS: '5'
+          RETRY_DELAY_SECONDS: '60'
+        run: |
+          cd maven
+          JAVA_HOME="$JDK_8_HOME" bash ../scripts/ci/retry.sh mvn -B \
+            -pl "windows,$BENCH_MODULES" -am -Plocal-dev-javase -DskipTests \
+            -Darchetype.test.skip=true -Dmaven.javadoc.skip=true install
+      - name: OpenJFX jmods
+        run: |
+          bash scripts/desktop-compat-benchmarks/javafx-jmods.sh "$BENCH_JDK21_HOME" "$RUNNER_TEMP/javafx-jmods"
+          echo "BENCH_JAVAFX_JMODS=$RUNNER_TEMP/javafx-jmods" >> "$GITHUB_ENV"
+      - name: Build the samples (sizes)
+        env:
+          BENCH_COMMIT: ${{ github.sha }}
+        run: |
+          bash scripts/desktop-compat-benchmarks/bench-samples.sh --stage build \
+            --work "$RUNNER_TEMP/bench" --out "$GITHUB_WORKSPACE/benchmark-results"
+      - name: Measure the samples (start-up, idle memory and CPU)
+        shell: pwsh
+        run: |
+          $bench = Join-Path $env:RUNNER_TEMP 'bench'
+          foreach ($name in 'swing-gallery', 'javafx-gallery') {
+            $dir = Join-Path $bench $name
+            $parts = Join-Path $dir 'parts'
+            $java = Join-Path $dir 'baseline\runtime\bin\java.exe'
+            $baseline = Join-Path $parts 'baseline.json'
+            if ((Test-Path $java) -and (Test-Path $baseline)) {
+              $main = (Get-Content $baseline -Raw | ConvertFrom-Json).main_class
+              $cp = (Join-Path $dir 'baseline\app') + '\*'
+              & scripts/desktop-compat-benchmarks/win-measure.ps1 -Label jvm_default `
+                -Out (Join-Path $parts 'run.jvm_default.json') -Exe $java -Arguments '-cp', $cp, $main
+              & scripts/desktop-compat-benchmarks/win-measure.ps1 -Label jvm_tuned `
+                -Out (Join-Path $parts 'run.jvm_tuned.json') -Exe $java `
+                -Arguments '-XX:+UseSerialGC', '-Xss256k', '-XX:TieredStopAtLevel=1', '-Xmx64m', '-cp', $cp, $main
+            } else {
+              Write-Host "::warning::no baseline runtime image for $name"
+            }
+            $marker = Join-Path $dir 'cn1\executable.txt'
+            if (Test-Path $marker) {
+              $exe = Join-Path $dir ('cn1\dist\' + (Get-Content $marker -Raw).Trim())
+              & scripts/desktop-compat-benchmarks/win-measure.ps1 -Label cn1_native `
+                -Out (Join-Path $parts 'run.cn1_native.json') -Exe $exe
+            } else {
+              Write-Host "::warning::no native Codename One build for $name"
+            }
+            python scripts/desktop-compat-benchmarks/benchutil.py assemble $parts (Join-Path $dir 'result.json')
+          }
+          $results = @(Get-ChildItem -Path $bench -Filter result.json -Recurse -Depth 1 | ForEach-Object { $_.FullName })
+          python scripts/desktop-compat-benchmarks/benchutil.py collect benchmark-results/benchmarks-windows.json @results
+          python scripts/desktop-compat-benchmarks/report.py --out benchmark-results/benchmarks-windows.md @results
+          Get-Content benchmark-results/benchmarks-windows.md | Add-Content $env:GITHUB_STEP_SUMMARY
+      - name: Upload the results
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: benchmarks-windows
+          path: benchmark-results/
+          if-no-files-found: warn
+      - name: Upload the logs
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: benchmarks-windows-logs
+          path: ${{ runner.temp }}/bench/*/logs/
+          if-no-files-found: ignore
diff --git a/.github/workflows/desktop-compat.yml b/.github/workflows/desktop-compat.yml
new file mode 100644
index 00000000000..7e57f60999e
--- /dev/null
+++ b/.github/workflows/desktop-compat.yml
@@ -0,0 +1,146 @@
+name: Desktop compatibility
+
+# Swing and JavaFX applications built as Codename One applications: the
+# relocated toolkits (maven/swing-compat, maven/javafx-compat), the headless
+# harness their tests run on (maven/compat-testing) and the build steps that
+# relocate and package them (build-engine, the Maven and Gradle plugins). The
+# JDK API they run on is the device's class library (vm/JavaAPI,
+# Ports/CLDC11), under the JDK's own names.
+#
+#   unit tests                    the runtimes against the JDK's own behaviour,
+#                                 the remapper, the importer, and the sample
+#                                 loaded remapped and painted headless
+#   desktop-compat-test.sh        every sample under scripts/desktop-compat-samples
+#                                 imported unmodified, built by Maven and Gradle,
+#                                 checked for unrelocated toolkit references,
+#                                 staged for iOS, Android, JavaScript and the
+#                                 desktop with identical uploads from both
+#                                 tools, and built once in a project that also
+#                                 holds an Android application
+#   desktop-compat-realport       the two galleries that script staged, run on
+#                                 the real JavaSE port under xvfb and driven
+#                                 with the display server's pointer and keys;
+#                                 fails on anything thrown and on a click, a
+#                                 drag or a key that changes no pixel
+on:
+  pull_request:
+    branches: [ master ]
+    paths:
+      - 'maven/swing-compat/**'
+      - 'maven/javafx-compat/**'
+      - 'maven/fxml-compiler/**'
+      - 'maven/compat-testing/**'
+      - 'maven/build-engine/**'
+      - 'maven/codenameone-maven-plugin/**'
+      - 'maven/codenameone-gradle-plugin/**'
+      - 'maven/project-model/**'
+      - 'maven/cn1app-archetype/**'
+      - 'maven/pom.xml'
+      - 'maven/integration-tests/desktop-compat-test.sh'
+      - 'maven/integration-tests/desktop-compat-realport/**'
+      - 'maven/integration-tests/inc/**'
+      - 'scripts/desktop-compat-samples/**'
+      # The script builds one project holding both layers from this sample.
+      - 'scripts/android-compat-samples/gallery/**'
+      - '.github/workflows/desktop-compat.yml'
+  push:
+    branches: [ master ]
+    paths:
+      - 'maven/swing-compat/**'
+      - 'maven/javafx-compat/**'
+      - 'maven/fxml-compiler/**'
+      - 'maven/compat-testing/**'
+      - 'maven/build-engine/**'
+      - 'maven/codenameone-maven-plugin/**'
+      - 'maven/codenameone-gradle-plugin/**'
+      - 'maven/project-model/**'
+      - 'maven/cn1app-archetype/**'
+      - 'maven/pom.xml'
+      - 'maven/integration-tests/desktop-compat-test.sh'
+      - 'maven/integration-tests/desktop-compat-realport/**'
+      - 'maven/integration-tests/inc/**'
+      - 'scripts/desktop-compat-samples/**'
+      - 'scripts/android-compat-samples/gallery/**'
+      - '.github/workflows/desktop-compat.yml'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  desktop-compat:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+    env:
+      CN1_GRADLE_REQUIRED: '1'
+    steps:
+      - uses: actions/checkout@v6
+      # Installed FIRST so the JDK 8 below is the one JAVA_HOME names.
+      - name: Set up JDK 17 for Gradle
+        uses: actions/setup-java@v5
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - run: echo "GRADLE_JAVA_HOME=$JAVA_HOME" >> $GITHUB_ENV
+      - name: Set up JDK 8
+        uses: actions/setup-java@v5
+        with:
+          java-version: '8'
+          distribution: 'temurin'
+          cache: 'maven'
+      # xvfb for the CSS compiler, which opens an AWT frame. Nothing in the
+      # compatibility layers opens a window: their tests run on the headless
+      # implementation in maven/compat-testing.
+      - name: Install xvfb
+        run: bash scripts/ci/apt-get-install.sh xvfb
+      - name: Build Codename One Maven artifacts (includes archetypes and both plugins)
+        env:
+          RETRY_ONLY_MATCHING: transient
+          RETRY_ATTEMPTS: '5'
+          RETRY_DELAY_SECONDS: '60'
+        run: |
+          cd maven
+          bash ../scripts/ci/retry.sh xvfb-run -a mvn install -Plocal-dev-javase -DskipTests -Darchetype.test.skip=true -Dmaven.javadoc.skip=true
+      # A module added to the layer (an FXML compiler, say) joins this list.
+      - name: Unit tests
+        working-directory: maven
+        run: xvfb-run -a mvn -B -Plocal-dev-javase -pl compat-testing,swing-compat,javafx-compat,fxml-compiler,build-engine test
+      # The JavaFX sample has to stay what it claims to be: a JavaFX project
+      # that builds on its own, against OpenJFX, with nothing of the layer on
+      # its class path. Everything else here compiles it against the layer,
+      # which would also accept a sample written to the layer's shape. JDK 17
+      # because OpenJFX 17 is; the Swing sample needs no such step, the JDK
+      # that compiles it in the unit tests is the toolkit.
+      - name: The JavaFX sample compiles against OpenJFX
+        env:
+          RETRY_ONLY_MATCHING: transient
+          RETRY_ATTEMPTS: '5'
+          RETRY_DELAY_SECONDS: '60'
+        run: JAVA_HOME="$GRADLE_JAVA_HOME" bash scripts/ci/retry.sh mvn -B -f scripts/desktop-compat-samples/javafx-gallery/pom.xml compile
+      - name: Refresh archetype catalog
+        run: |
+          cd maven
+          xvfb-run -a mvn archetype:update-local-catalog -Plocal-dev-javase
+          xvfb-run -a mvn archetype:crawl -Plocal-dev-javase
+      - name: Desktop samples, imported and built by Maven and Gradle
+        working-directory: maven/integration-tests
+        run: xvfb-run -a bash desktop-compat-test.sh
+      # The galleries the step above staged, on the real port, under the
+      # display server's own pointer and keys. The unit tests fire events at
+      # the node they are meant for; this is the only place a dead button or a
+      # key the port never delivers can fail. It runs on GRADLE_JAVA_HOME,
+      # the JDK 17: the port needs 11 or newer at run time. The screen is
+      # named because xvfb-run's default is smaller than the application.
+      - name: The galleries on the real JavaSE port, under real input
+        working-directory: maven/integration-tests
+        run: xvfb-run -a -s "-screen 0 1400x1000x24" bash desktop-compat-realport/run.sh
+      - name: Upload the test projects' logs
+        if: failure()
+        uses: actions/upload-artifact@v7
+        with:
+          name: desktop-compat-logs
+          path: |
+            maven/integration-tests/build/desktop-compat/**/*.log
+            maven/integration-tests/build/desktop-compat-realport/**/realport.log
+            maven/integration-tests/build/desktop-compat-realport/**/frames/*.png
+          if-no-files-found: ignore
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index d639ad5005b..feac4ff776f 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -394,7 +394,7 @@ jobs:
             -Dcn1.binaries="${CN1_BINARIES}" \
             -Pcompile-android \
             -DbackendAnalysis \
-            -pl android,ios,project-model,build-engine,codenameone-maven-plugin,codenameone-gradle-plugin,backend,backend-test,backend-parparvm,javac,android-res-compiler,android-compat -am verify
+            -pl android,ios,project-model,build-engine,codenameone-maven-plugin,codenameone-gradle-plugin,backend,backend-test,backend-parparvm,javac,android-res-compiler,android-compat,swing-compat,javafx-compat,fxml-compiler -am verify
       - name: Type-check the SQLCipher-backed database package
         if: ${{ matrix.java-version == 8 }}
         env:
@@ -612,7 +612,7 @@ jobs:
       - name: Generate static analysis HTML summaries
         if: ${{ !cancelled() && matrix.java-version == 8 }}
         env:
-          QUALITY_REPORT_TARGET_DIRS: maven/core-unittests/target:maven/android/target:maven/ios/target:vm/ByteCodeTranslator/target:maven/codenameone-maven-plugin/target:maven/build-engine/target:maven/project-model/target:maven/codenameone-gradle-plugin/target:maven/build-hint-catalog/target:maven/build-hint-tools/target:maven/backend/target:maven/backend-test/target:maven/backend-parparvm/target:maven/javac/target:maven/android-res-compiler/target:maven/android-compat/target
+          QUALITY_REPORT_TARGET_DIRS: maven/core-unittests/target:maven/android/target:maven/ios/target:vm/ByteCodeTranslator/target:maven/codenameone-maven-plugin/target:maven/build-engine/target:maven/project-model/target:maven/codenameone-gradle-plugin/target:maven/build-hint-catalog/target:maven/build-hint-tools/target:maven/backend/target:maven/backend-test/target:maven/backend-parparvm/target:maven/javac/target:maven/android-res-compiler/target:maven/android-compat/target:maven/swing-compat/target:maven/javafx-compat/target:maven/fxml-compiler/target
           QUALITY_REPORT_SERVER_URL: ${{ github.server_url }}
           QUALITY_REPORT_REPOSITORY: ${{ github.repository }}
           QUALITY_REPORT_REF: ${{ github.event.pull_request.head.sha || github.sha }}
@@ -634,6 +634,9 @@ jobs:
             "build-engine:maven/build-engine/target" \
             "android-res-compiler:maven/android-res-compiler/target" \
             "android-compat:maven/android-compat/target" \
+            "swing-compat:maven/swing-compat/target" \
+            "javafx-compat:maven/javafx-compat/target" \
+            "fxml-compiler:maven/fxml-compiler/target" \
             "project-model:maven/project-model/target" \
             "gradle-plugin:maven/codenameone-gradle-plugin/target" \
             "backend:maven/backend/target" \
@@ -764,11 +767,11 @@ jobs:
       - name: Generate quality report summary
         if: ${{ !cancelled() && matrix.java-version == 8 }}
         env:
-          QUALITY_REPORT_TARGET_DIRS: maven/core-unittests/target:maven/android/target:maven/ios/target:vm/ByteCodeTranslator/target:maven/codenameone-maven-plugin/target:maven/build-engine/target:maven/project-model/target:maven/codenameone-gradle-plugin/target:maven/build-hint-catalog/target:maven/build-hint-tools/target:maven/backend/target:maven/backend-test/target:maven/backend-parparvm/target:maven/javac/target:maven/android-res-compiler/target:maven/android-compat/target
+          QUALITY_REPORT_TARGET_DIRS: maven/core-unittests/target:maven/android/target:maven/ios/target:vm/ByteCodeTranslator/target:maven/codenameone-maven-plugin/target:maven/build-engine/target:maven/project-model/target:maven/codenameone-gradle-plugin/target:maven/build-hint-catalog/target:maven/build-hint-tools/target:maven/backend/target:maven/backend-test/target:maven/backend-parparvm/target:maven/javac/target:maven/android-res-compiler/target:maven/android-compat/target:maven/swing-compat/target:maven/javafx-compat/target:maven/fxml-compiler/target
           # Every project listed here must produce a SpotBugs report and that
           # report must be empty. A missing report fails the gate too, so a
           # SpotBugs run that silently stops running is not mistaken for clean.
-          QUALITY_REPORT_REQUIRED_SPOTBUGS: core-unittests:android:ios:ByteCodeTranslator:codenameone-maven-plugin:build-engine:project-model:codenameone-gradle-plugin:build-hint-catalog:build-hint-tools:backend:backend-test:javac:android-res-compiler:android-compat
+          QUALITY_REPORT_REQUIRED_SPOTBUGS: core-unittests:android:ios:ByteCodeTranslator:codenameone-maven-plugin:build-engine:project-model:codenameone-gradle-plugin:build-hint-catalog:build-hint-tools:backend:backend-test:javac:android-res-compiler:android-compat:swing-compat:javafx-compat:fxml-compiler
           # PMD and Checkstyle run on the core and on the backend runtime, and each
           # must produce its report: without one, the forbidden-rule gate below it
           # has nothing to read and passes.
diff --git a/CLAUDE.md b/CLAUDE.md
index fc26e59b1ab..a6834f96f6d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -351,7 +351,9 @@ recognized and never reported. Note the rule is about the *cast*: a
 
 The scope is what a translation actually sees -- `maven/core`, `maven/ios`,
 `vm/JavaAPI` and `maven/android-compat`, whose runtime an application with
-Android sources ships relocated inside its own classes. **The Android port is not covered**, and adding it back would be a
+Android sources ships relocated inside its own classes, and
+`maven/swing-compat` and `maven/javafx-compat`, which are relocated into an
+application with desktop sources the same way. **The Android port is not covered**, and adding it back would be a
 mistake: ART implements `CHECKCAST` to spec, so a `catch (Throwable)` around a
 `(NotificationManager) getSystemService(...)` there is live, correct code, and
 `Ports/Android` is never translated. That is the same reason `Ports/CLDC11` is
@@ -797,13 +799,24 @@ An Android Studio module's `src/main` dropped into `common/src/main/android`
   (views are peers, layouts run Android's measure/layout). Apps compile against
   it under the real names; its own framework resources live in
   `src/main/framework-res`.
-- **The remap step** (`build-engine/.../AndroidRemapper`, goal `remap-android`)
-  relocates `android/`, `androidx/` and `com/google/android/material/` to
+- **The remap step** (goal `remap-compat`; `remap-android` is the same goal
+  under its old name, kept so existing poms need no edit) relocates `android/`,
+  `androidx/` and `com/google/android/material/` to
   `com/codename1/androidcompat/...`, copies the relocated runtime into the app's
-  classes, maps the JDK classes CLDC lacks (`java.io.File`, the file streams,
-  `BufferedReader`, `PrintWriter`, `Closeable`) to `com.codename1.androidcompat.jdk`,
-  and generates the `android:onClick`, fragment-factory and WebView JS-bridge
-  dispatchers from the compiled classes.
+  classes, and generates the `android:onClick`, fragment-factory and WebView
+  JS-bridge dispatchers from the compiled classes. The JDK API keeps its
+  names: the device's class library (`vm/JavaAPI`, mirrored by
+  `Ports/CLDC11`) carries it, and JavaSE and Android run the real JDK. Only
+  `Relocation.JDK_SHIMS` moves anything of `java.*` -- `java.util.regex` to
+  `com.codename1.util.regex`, `ProcessBuilder`/`Process` to
+  `com.codename1.io` -- and every layer shares that table.
+- **The remap is one pass over every layer**, split in `build-engine`:
+  `CompatLayers` declares each layer (artifact, source prefixes, target
+  package), `Relocation` holds the package and JDK-shim tables,
+  `ClassRelocator` rewrites a class against all active layers at once,
+  `CompatRemapper` drives the step and calls `AndroidRemapper` for what is
+  Android's own. The archetype binds `remap-compat` and then
+  `bytecode-compliance` in `process-classes`, in that order.
 
 Traps that have already cost a fix:
 
@@ -828,6 +841,180 @@ Traps that have already cost a fix:
   (`.github/workflows/android-compat.yml`); it fails if any shipped class still
   names `android/`.
 
+### Desktop compatibility: Swing and JavaFX apps as Codename One apps
+
+A desktop project's `src/main` dropped into `common/src/main/desktop` (or
+imported with `cn1:import-desktop-project`) builds unmodified, for every target:
+
+- **`maven/swing-compat`** is `java.awt`, `javax.swing`, `java.beans`,
+  `javax.imageio` and a SwingX subset (`org.jdesktop`) written over Codename
+  One. **It is authored already relocated**, under
+  `com.codename1.desktopcompat.java.awt...`, because the JDK owns `java.awt` and
+  no module can declare it. Applications therefore compile against the *JDK's*
+  Swing, and the remap points them at this one.
+- **`maven/javafx-compat`** is the `javafx.*` subset. Nothing owns that name, so
+  it is authored under the real names like `android-compat`, applications
+  compile against its jar, and the remap moves it to `com/codename1/fxcompat/`.
+  Its internals live in `com/codename1/fxcompat/runtime/`, which the remap maps
+  to `com/codename1/fxcompat/rt/`.
+- **There is no JDK module.** A JDK class a device lacks is added to
+  `vm/JavaAPI` and `Ports/CLDC11` under its real name, never shimmed in a
+  layer. `CompatRewrites` redirects the few *members* a device cannot have
+  as written -- resource and class-loader lookups, bundles and services to
+  `com.codename1.impl.compat.Resources`, the default uncaught-exception
+  handler, `String`'s regex members, `Runtime.exec`, the `Math` functions
+  CLDC lacks -- for the desktop layers only.
+- **`maven/fxml-compiler`** turns each `.fxml` into
+  `com.codename1.generated.fxml.Fxml_<name>` (in the remap step, after javac)
+  and each `.css` into a `.cn1css` table (from `prepare-desktop-sources`);
+  `FxmlDispatchGenerator` then runs in the remap, on the compiled classes, to
+  widen and reach the controllers' private `@FXML` members. The CSS value
+  classes are compiled twice: `fxcompat/runtime/css` is copied into the compiler
+  under `com.codename1.fxml.css`, so build and device share one parser.
+- **`maven/compat-testing`** is the headless implementation and
+  `MainThreadRule` both layers' tests run on.
+
+What holds it together:
+
+- **Unsupported API is a build error, and that is the coverage gate.**
+  `bytecode-compliance` runs *after* the remap, so a member the layer lacks is
+  a reference to something that does not exist; `BytecodeCompliance` reports it
+  under the original name with the source line. What it cannot see: an
+  application *override* of a method the layer's type lacks passes, and is
+  simply never called.
+- **The API shape is tested, not trusted.** `ApiShapeTest` compares every
+  public class of `swing-compat` with the JDK class (SwingX with the real
+  `swingx-all`), and `NoJdkDesktopReferenceTest` fails if a shipped class names
+  the real `java/awt`. In `javafx-compat`, `ApiNamingTest` requires every
+  public member that is not JavaFX API to be named `cn1...`/`CN1_...` and listed
+  in `src/test/resources/cn1-hooks.txt`. A new hook means a new line there.
+- **Coordinates are logical pixels, 1/96 inch**, scaled by the display density
+  (Display property `desktopcompat.scale` overrides; both layers read it) and
+  snapped edge by edge. Never hand a Swing or JavaFX coordinate to Codename One
+  unscaled.
+- **The application's own main class starts the desktop app**, as editable
+  source in `common/src/main/java`. `cn1:import-desktop-project`
+  (`DesktopProjectImporter`) writes it: a Swing app's extends
+  `DesktopLifecycle` and calls its `main` in `runMain`, a JavaFX app's extends
+  `FxLifecycle` and `new`s the `Application` in `createApplication` -- no
+  reflection, no generated class, no properties file. An entry class the main
+  class cannot name (not public) is reached through a `CN1DesktopLauncher` in
+  its own package. The remap renames every static `main(String[])` and its
+  call sites to `cn1DesktopMain`, the main class's call included.
+  `main`/`start` run on the EDT, which is the Swing EDT and the JavaFX
+  application thread.
+- **Registries are generated over placeholders.**
+  `com.codename1.generated.compat.CompatRegistry` (resources, bundle classes
+  and service providers; `ApplicationRegistry` writes it, and the lifecycles
+  and the library-mode entry points call its `cn1Install()`) and the FXML
+  dispatch class ship as empty placeholders with the right shape and are
+  replaced per application; a new method on one needs the generator and the
+  placeholder changed together. On JavaSE and Android the ports install
+  `CompatResourceSupport` from `init`, so the real JDK's `URL`,
+  `ResourceBundle` and `ServiceLoader` read the flattened bundle and the
+  registry's providers.
+- A desktop layer is active only when its jar is present **and** the compiled
+  classes name its API, so a Swing app does not ship the JavaFX runtime.
+  Compile- and runtime-scope dependency jars that name a layer are unpacked and relocated as
+  application code (`CompatLibraries`).
+
+- **Library mode: desktop sources inside a Codename One app.** A main class
+  that extends neither lifecycle -- `-Dcn1.desktop.library=true` on the
+  import, or a main class that starts an Android application -- leaves the
+  desktop classes shipping relocated as a library. Extending the lifecycle is
+  what installs the exit hook: there closing the last window exits, otherwise
+  `SwingInterop.asComponent` / `FxInterop.asComponent` wrap a component, a
+  parent or a scene as a `com.codename1.ui.Component`, and a `JFrame` or
+  `Stage` shown is a form over the host's -- closing the last one returns
+  there and never exits. Both `asComponent`
+  parameters are `Object` **on purpose**: the remap copies the relocated
+  runtime into `target/classes`, which shadows the jar on the next non-clean
+  compile, so a non-relocated public class naming a toolkit type in a
+  signature stops compiling against application source. `hellocodenameone`
+  is the library-mode project (`common/src/main/desktop`, the
+  `DesktopCompat*` screenshot tests); `DesktopCompatScenesTest` in
+  `build-engine` runs the same scenes headless from the remapped classes.
+
+`swing-compat`, `javafx-compat` and `fxml-compiler` are in the
+SpotBugs zero-findings gate, each with its own `spotbugs-exclude.xml`.
+
+Traps that have already cost a fix:
+
+- **SpotBugs XML uses single-quoted attributes.** Grepping the report for
+  `type="` finds nothing and reads as zero findings. Match either quote, or
+  count `<BugInstance`.
+- **`-DskipTests verify` analyses stale classes** if the module was not
+  recompiled; delete `target/spotbugsXml.xml` or build clean before believing it.
+- **A test must never reach the real `Display.exitApplication()`.** It kills
+  the `invokeAndBlock` pool and every later test in the JVM hangs. Install
+  `WindowHosts.setExitHook` / `StageHosts.setExitHook` in any test that closes
+  a last window or calls `System.exit`/`Platform.exit`.
+- **Click count is static state**, kept per button and place.
+  `KernelTestBase` calls `EventBridge.resetClickCount()` in cleanup; a test
+  class outside it that clicks must do the same or it hands a double click to
+  the next test.
+- **Revealing a rectangle must not re-enter layout.** `JViewport.doLayout`
+  showed the caret, showing a rectangle validated the viewport, and the
+  viewport -- still invalid, mid-layout -- laid itself out again: a stack
+  overflow. `Container.validateTree` and `JViewport.doLayout` refuse to start a
+  pass that is already under way; keep that guard on any new reveal path.
+- **A wheel event must scroll exactly once.** The root peer hands Codename
+  One's wheel event to the `MouseWheelListener`s before anything scrolls, and
+  the content then scrolled as well. The Codename One event is consumed when a
+  listener received it or the pane has wheel scrolling off.
+- **A JavaFX node repainted alone punches a hole in the sibling under it.**
+  Codename One repaints a component over its *parents'* backgrounds and
+  takes siblings not to overlap, so a progress indicator over the veil of a
+  `StackPane` redrew itself on a square of bare scene. `Node.repaint` walks
+  up to the parent while the node lies over an earlier sibling. A capture
+  taken while such a scene animates can also catch a half-painted frame;
+  shoot it at a different moment before reading it as a bug.
+- **A reflecting `LinearGradient` is not handed to `LinearGradientPaint`.**
+  The JavaSE port drew the reflected half first, so the stops read
+  backwards. Gradients that cycle, radial ones with a focus and every
+  gradient stroke go through `GradientRaster`, per pixel, and
+  `GradientAndImageTest` holds them to values computed from the JavaFX
+  definition.
+- **A port's file system throws for any path that is not an absolute
+  `file:/` one**, and a test harness must not be kinder. `new
+  Image("file:resources/logo.png")` reached `FileSystemStorage` as written
+  and killed an application in `start` in the simulator, while every test
+  and every capture passed: `HeadlessImplementation` resolved the relative
+  path, and the capture harness had called
+  `JavaSEPort.setExposeFilesystem(true)`, which switches the check off.
+  `HeadlessImplementation.checkPath` now throws what `JavaSEPort.unfile`
+  throws; a `file:` URL goes through `ResourceUrls.openFile`, and a JavaFX
+  loader records an error instead of letting a port exception out.
+- **`Class.getSuperclass()` is not on the device** -- absent from
+  `Ports/CLDC11`, though `vm/JavaAPI` has it, so the simulator and iOS pass and
+  the compliance check does not. `JTable` finds a renderer by assignability,
+  walking registered classes, never by walking up a hierarchy.
+- **The shimmed `NumberFormat` cannot extend the device's `java.text.Format`**,
+  which is not the JDK's class. Code holding one as a `Format` is a build error
+  by design; do not "fix" it by widening the shim.
+- **FXML compiles after javac, not in `generate-sources`**: a document may
+  name the application's own classes (a custom control), so `remap-compat`
+  compiles the documents against the compiled application first and then
+  relocates. Nothing in the application references a generated `Fxml_*` class
+  by name -- only the generated registry does -- which is what makes the late
+  compile possible. CSS still compiles in `prepare-desktop-sources`.
+- **`maven/integration-tests/desktop-compat-test.sh`** imports
+  `scripts/desktop-compat-samples/*` (and skips when there are none), builds
+  with Maven and Gradle, and fails if
+  any shipped class still names `java/awt`, `javax/swing`, `java/beans`,
+  `org/jdesktop` or `javafx`.
+- **`maven/integration-tests/desktop-compat-realport/run.sh`** runs a staged
+  application on the real JavaSE port and plays a script of real input
+  (`java.awt.Robot`) against it. It fails on anything thrown and on a click,
+  drag or key that changes no pixel outside what was already moving. The unit
+  tests fire events at the node they are meant for, so they cannot see a
+  control that is dead, or scrolls its text, or loses a key, under a real
+  port. With no arguments it runs `<sample>.txt` beside it against what
+  `desktop-compat-test.sh` staged (`desktop-compat.yml` does, under
+  `xvfb-run`). It opens a window: run it under xvfb or in a container. The
+  port turns Space and Enter into the same key code, and drops every
+  Ctrl/Alt/Meta combination before the form sees it.
+
 ### Integration Tests
 
 Located in `maven/integration-tests/`:
diff --git a/CodenameOne/src/com/codename1/annotations/LinkOnly.java b/CodenameOne/src/com/codename1/annotations/LinkOnly.java
new file mode 100644
index 00000000000..50e3acdd2f2
--- /dev/null
+++ b/CodenameOne/src/com/codename1/annotations/LinkOnly.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/// Marks a class of a compatibility layer that exists so that a library
+/// naming it LINKS, and that does nothing useful when it is reached.
+///
+/// A third-party library written against a desktop toolkit is bundled with
+/// the application whole, and almost every one of them has corners no device
+/// can serve: a layout manager that can save itself through
+/// `java.beans.XMLEncoder`, which is reflection from end to end, or that asks
+/// whether a component is one of AWT's heavyweight widgets. The library's
+/// classes name those types, so the types have to exist or nothing that
+/// translates the application ahead of time can build it -- although the
+/// application never takes those paths.
+///
+/// What the build does with the mark (`BytecodeCompliance`): a reference from
+/// a bundled library is accepted, and a reference from the application's own
+/// classes is reported exactly as if the class did not exist. The layer's
+/// contract with a developer is therefore unchanged -- API they call is API
+/// that works -- while a library gets to link.
+///
+/// A marked class says in its own documentation what each member does when it
+/// is reached after all; where that cannot be an honest answer it throws
+/// `UnsupportedOperationException` naming the API.
+///
+/// Retained in the class file and no further: the build reads it there, and
+/// nothing reads it on a device.
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.TYPE)
+public @interface LinkOnly {
+}
diff --git a/CodenameOne/src/com/codename1/impl/CoreJdkHost.java b/CodenameOne/src/com/codename1/impl/CoreJdkHost.java
new file mode 100644
index 00000000000..e96d31876f4
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/CoreJdkHost.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import com.codename1.io.ConnectionRequest;
+import com.codename1.io.FileSystemStorage;
+import com.codename1.io.Log;
+import com.codename1.io.NetworkManager;
+import com.codename1.io.Preferences;
+import com.codename1.l10n.L10NManager;
+import com.codename1.security.Hash;
+import com.codename1.ui.Display;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/// The [JdkHost] of a Codename One application: the Java class library's
+/// file system, preferences, network, log and event thread, served by
+/// `FileSystemStorage`, `Preferences`, `NetworkManager`, `Log` and `Display`.
+///
+/// Internal. The ParparVM ports (iOS and macOS, Windows, Linux, JavaScript)
+/// install it from their `init` through [CoreJdkHostInstaller]. On Java SE and
+/// Android the real JDK runs and nothing installs it. `JdkHost` itself is part
+/// of the class library, not of the core: the core compiles against it, and
+/// the Java SE and Android ports carry a copy so this class always has its
+/// superclass.
+///
+/// Paths are `FileSystemStorage` paths, or plain absolute paths, which are
+/// taken as `file://` paths: `java.io.File` hands a path over as the
+/// application wrote it. Nothing here runs before the display is initialized
+/// except what checks for it.
+public class CoreJdkHost extends JdkHost {
+
+    private static FileSystemStorage fs() {
+        return FileSystemStorage.getInstance();
+    }
+
+    /// `path` as a `FileSystemStorage` path: `/x` and a drive path `C:/x`
+    /// gain the `file://` scheme; anything with a scheme is left alone.
+    static String storage(String path) {
+        if (path.startsWith("/")) {
+            return "file://" + path;
+        }
+        if (path.length() >= 3 && path.charAt(1) == ':' && path.charAt(2) == '/'
+                && ((path.charAt(0) >= 'A' && path.charAt(0) <= 'Z')
+                || (path.charAt(0) >= 'a' && path.charAt(0) <= 'z'))) {
+            return "file:///" + path;
+        }
+        return path;
+    }
+
+    @Override
+    public FileStat fileStat(String path) {
+        path = storage(path);
+        FileSystemStorage fs = fs();
+        if (!fs.exists(path)) {
+            return null;
+        }
+        boolean directory = fs.isDirectory(path);
+        return new FileStat(directory, directory ? 0L : fs.getLength(path), fs.getLastModified(path));
+    }
+
+    @Override
+    public String[] fileList(String path) throws IOException {
+        path = storage(path);
+        FileSystemStorage fs = fs();
+        if (!fs.exists(path) || !fs.isDirectory(path)) {
+            return null;
+        }
+        return fs.listFiles(path);
+    }
+
+    @Override
+    public InputStream fileRead(String path) throws IOException {
+        path = storage(path);
+        FileSystemStorage fs = fs();
+        if (!fs.exists(path) || fs.isDirectory(path)) {
+            throw new FileNotFoundException(path);
+        }
+        return fs.openInputStream(path);
+    }
+
+    @Override
+    public OutputStream fileWrite(String path, boolean append) throws IOException {
+        path = storage(path);
+        FileSystemStorage fs = fs();
+        if (fs.exists(path) && fs.isDirectory(path)) {
+            throw new FileNotFoundException(path + " (Is a directory)");
+        }
+        if (append && fs.exists(path)) {
+            long length = fs.getLength(path);
+            if (length > Integer.MAX_VALUE) {
+                // The storage API takes the offset as an int. Narrowed, it
+                // wraps, and the write would land inside the file.
+                throw new IOException(path + " (Too large to append to)");
+            }
+            return fs.openOutputStream(path, (int) length);
+        }
+        return fs.openOutputStream(path);
+    }
+
+    @Override
+    public boolean fileMkdir(String path) {
+        path = storage(path);
+        FileSystemStorage fs = fs();
+        if (fs.exists(path)) {
+            return false;
+        }
+        // mkdir(2) creates one level; a storage that creates the missing
+        // parents too would make File.mkdir answer true where the JDK does not.
+        String parent = parentOf(path);
+        if (parent != null && !(fs.exists(parent) && fs.isDirectory(parent))) {
+            return false;
+        }
+        fs.mkdir(path);
+        return fs.exists(path) && fs.isDirectory(path);
+    }
+
+    @Override
+    public boolean fileDelete(String path) {
+        path = storage(path);
+        FileSystemStorage fs = fs();
+        if (!fs.exists(path)) {
+            return false;
+        }
+        if (fs.isDirectory(path)) {
+            // The JDK deletes only an empty directory; some storages delete
+            // the whole tree.
+            String[] entries;
+            try {
+                entries = fs.listFiles(path);
+            } catch (IOException e) {
+                return false;
+            }
+            if (entries != null && entries.length > 0) {
+                return false;
+            }
+        }
+        fs.delete(path);
+        return !fs.exists(path);
+    }
+
+    /// Renames within one directory, which is all `FileSystemStorage` can do;
+    /// a move to another directory answers false and the caller copies.
+    @Override
+    public boolean fileRename(String from, String to) {
+        from = storage(from);
+        to = storage(to);
+        FileSystemStorage fs = fs();
+        int fromSlash = lastSeparator(from);
+        int toSlash = lastSeparator(to);
+        if (fromSlash < 0 || toSlash < 0 || fs.exists(to) || !fs.exists(from)
+                || !from.substring(0, fromSlash).equals(to.substring(0, toSlash))) {
+            return false;
+        }
+        fs.rename(from, to.substring(toSlash + 1));
+        return fs.exists(to) && !fs.exists(from);
+    }
+
+    /// The parent of the storage path `path`, or null at a root.
+    private static String parentOf(String path) {
+        String p = path;
+        while (p.length() > 1 && p.endsWith("/")) {
+            p = p.substring(0, p.length() - 1);
+        }
+        int slash = lastSeparator(p);
+        if (slash <= 0) {
+            return null;
+        }
+        String parent = p.substring(0, slash);
+        // "file://" itself is no directory: the parent of /x is the root.
+        return parent.endsWith(":/") || parent.endsWith(":") ? parent + "/" : parent;
+    }
+
+    private static int lastSeparator(String path) {
+        int slash = path.lastIndexOf('/');
+        char sep = fs().getFileSystemSeparator();
+        return sep == '/' ? slash : Math.max(slash, path.lastIndexOf(sep));
+    }
+
+    @Override
+    public String appHome() {
+        return fs().getAppHomePath();
+    }
+
+    @Override
+    public String cachesDir() {
+        FileSystemStorage fs = fs();
+        return fs.hasCachesDir() ? fs.getCachesDir() : null;
+    }
+
+    @Override
+    public String[] fileRoots() {
+        return fs().getRoots();
+    }
+
+    @Override
+    public long fileTotalSpace(String path) {
+        String root = rootOf(storage(path));
+        return root == null ? 0L : fs().getRootSizeBytes(root);
+    }
+
+    @Override
+    public long fileUsableSpace(String path) {
+        String root = rootOf(storage(path));
+        return root == null ? 0L : fs().getRootAvailableSpace(root);
+    }
+
+    /// The longest root `path` lies under, else the first root, else null.
+    private static String rootOf(String path) {
+        String[] roots = fs().getRoots();
+        if (roots == null || roots.length == 0) {
+            return null;
+        }
+        String best = null;
+        for (String r : roots) {
+            if (r != null && path.startsWith(r) && (best == null || r.length() > best.length())) {
+                best = r;
+            }
+        }
+        return best != null ? best : roots[0];
+    }
+
+    @Override
+    public boolean fileTest(String path, int what) {
+        if (what == FILE_HIDDEN) {
+            String p = storage(path);
+            FileSystemStorage fs = fs();
+            return fs.exists(p) && fs.isHidden(p);
+        }
+        return super.fileTest(path, what);
+    }
+
+    @Override
+    public String preference(String key) {
+        return Preferences.get(key, (String) null);
+    }
+
+    @Override
+    public void setPreference(String key, String value) {
+        Preferences.set(key, value);
+    }
+
+    @Override
+    public void deletePreference(String key) {
+        Preferences.delete(key);
+    }
+
+    @Override
+    public InputStream openUrl(String url) throws IOException {
+        ConnectionRequest request = new ConnectionRequest();
+        request.setUrl(url);
+        request.setPost(false);
+        // Failures reach the caller as exceptions, not the user as the
+        // default error dialog.
+        request.setFailSilently(true);
+        NetworkManager.getInstance().addToQueueAndWait(request);
+        int code = request.getResponseCode();
+        if (code == 404 || code == 410) {
+            throw new FileNotFoundException(url);
+        }
+        if (code >= 400) {
+            throw new IOException("Server returned HTTP response code: " + code + " for URL: " + url);
+        }
+        byte[] data = request.getResponseData();
+        if (data == null) {
+            throw new IOException("No response from " + url);
+        }
+        return new ByteArrayInputStream(data);
+    }
+
+    /// The levels of [JdkHost] are those of `Log`.
+    @Override
+    public void log(int level, String message, Throwable thrown) {
+        if (message != null) {
+            Log.p(message, Math.max(Log.DEBUG, Math.min(Log.ERROR, level)));
+        }
+        if (thrown != null) {
+            Log.e(thrown);
+        }
+    }
+
+    /// `os.name` is the platform name; anything else is the display property
+    /// of that name.
+    @Override
+    public String property(String key) {
+        if (!Display.isInitialized()) {
+            return null;
+        }
+        if ("os.name".equals(key)) {
+            return Display.getInstance().getPlatformName();
+        }
+        return Display.getInstance().getProperty(key, null);
+    }
+
+    /// Closes the application the way the platform does; the status has
+    /// nowhere to go.
+    @Override
+    public void exit(int status) {
+        if (Display.isInitialized()) {
+            Display.getInstance().exitApplication();
+        }
+    }
+
+    /// Hands what an event dispatch thread task throws to the default
+    /// uncaught exception handler, when one is set, instead of the
+    /// platform's error handling; see
+    /// [com.codename1.impl.compat.UncaughtExceptions].
+    @Override
+    public void watchUncaughtExceptions() {
+        com.codename1.impl.compat.UncaughtExceptions.watch();
+    }
+
+    @Override
+    public boolean isUiThread() {
+        return Display.isInitialized() && Display.getInstance().isEdt();
+    }
+
+    /// On the event dispatch thread the task runs through `invokeAndBlock`,
+    /// so the UI keeps serving events while it blocks.
+    @Override
+    public void blockUi(Runnable task) {
+        if (isUiThread()) {
+            Display.getInstance().invokeAndBlock(task);
+        } else {
+            task.run();
+        }
+    }
+
+    /// Through `com.codename1.impl.compat.Resources`, which knows the flat
+    /// name a nested resource ships under and the index the generated
+    /// registry recorded.
+    @Override
+    public InputStream resource(String name) {
+        return com.codename1.impl.compat.Resources.open(name);
+    }
+
+    /// Derived from what `L10NManager` formats, since it exposes the
+    /// separators only through formatting.
+    @Override
+    public String[] localeNumberSymbols() {
+        if (!Display.isInitialized()) {
+            return null;
+        }
+        L10NManager l10n = L10NManager.getInstance();
+        char decimal = firstSeparator(l10n.format(1.5, 1));
+        char grouping = firstSeparator(l10n.format(1234567.0, 0));
+        return new String[] {
+            decimal == 0 ? null : String.valueOf(decimal),
+            grouping == 0 || grouping == decimal ? null : String.valueOf(grouping),
+            emptyToNull(l10n.getCurrencySymbol())
+        };
+    }
+
+    /// `null` for a null or empty string. A port's `L10NManager` may answer
+    /// either when it knows no currency symbol.
+    private static String emptyToNull(String s) {
+        return s == null || s.length() == 0 ? null : s;
+    }
+
+    /// The first character of `text` that sits between two ASCII digits, or 0.
+    private static char firstSeparator(String text) {
+        if (text == null) {
+            return 0;
+        }
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                boolean between = i > 0 && i + 1 < text.length()
+                        && text.charAt(i + 1) >= '0' && text.charAt(i + 1) <= '9';
+                return between ? c : 0;
+            }
+        }
+        return 0;
+    }
+
+    @Override
+    public void randomBytes(byte[] out) {
+        com.codename1.security.SecureRandom.fill(out);
+    }
+
+    @Override
+    public Digest digest(String algorithm) {
+        if (!Hash.MD5.equalsIgnoreCase(algorithm) && !Hash.SHA1.equalsIgnoreCase(algorithm)
+                && !Hash.SHA224.equalsIgnoreCase(algorithm) && !Hash.SHA256.equalsIgnoreCase(algorithm)
+                && !Hash.SHA384.equalsIgnoreCase(algorithm) && !Hash.SHA512.equalsIgnoreCase(algorithm)) {
+            return null;
+        }
+        try {
+            return new HashDigest(Hash.create(algorithm));
+        } catch (com.codename1.security.CryptoException e) {
+            // A port without this digest; the class library reports the
+            // algorithm as unavailable.
+            return null;
+        }
+    }
+
+    /// A core `Hash` as a [JdkHost.Digest].
+    private static final class HashDigest implements Digest {
+        private final Hash hash;
+
+        HashDigest(Hash hash) {
+            this.hash = hash;
+        }
+
+        @Override
+        public void update(byte[] data, int offset, int length) {
+            hash.update(data, offset, length);
+        }
+
+        @Override
+        public byte[] digest() {
+            return hash.digest();
+        }
+
+        @Override
+        public void reset() {
+            hash.reset();
+        }
+
+        @Override
+        public int length() {
+            return hash.digestLength();
+        }
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/CoreJdkHostInstaller.java b/CodenameOne/src/com/codename1/impl/CoreJdkHostInstaller.java
new file mode 100644
index 00000000000..46bd3068572
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/CoreJdkHostInstaller.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+/// Installs [CoreJdkHost] as the class library's [JdkHost].
+///
+/// Internal. The ParparVM ports call [#install] first thing in their `init`.
+/// It is a class of its own so that a port names neither `JdkHost` nor
+/// `CoreJdkHost`: compiling a call to a static method of `CoreJdkHost` would
+/// need its superclass on the port's class path, and the Java SE based tools
+/// that load `Display` or the implementation class never load either.
+public final class CoreJdkHostInstaller {
+    private CoreJdkHostInstaller() {
+    }
+
+    /// Makes [CoreJdkHost] the host the class library uses.
+    public static void install() {
+        JdkHost.install(new CoreJdkHost());
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/CompatRegistryBase.java b/CodenameOne/src/com/codename1/impl/compat/CompatRegistryBase.java
new file mode 100644
index 00000000000..938566d533c
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/CompatRegistryBase.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// What the build knows about one application's classes: the superclass of
+/// the registry it generates for every application built from desktop or
+/// Android sources, `com.codename1.generated.compat.CompatRegistry`.
+///
+/// A device creates no class from its name and reads no `META-INF/services`
+/// directory, so the class library's `java.util.ResourceBundle` and
+/// `java.util.ServiceLoader` ask the installed [JdkHost.Registry] instead.
+/// The generated subclass records, while it installs:
+///
+/// - every resource the application ships, in [Resources]'s index;
+/// - every class the application may need created by name -- its resource
+///   bundle classes and its service providers -- under a number its
+///   [#cn1Create(int)] turns into a `new` and its [#cn1Type(int)] into a
+///   class constant;
+/// - the providers of every service, in the order `ServiceLoader` offers
+///   them.
+///
+/// It then makes itself the registry `JdkHost` serves. The generated
+/// `cn1Install()` does all of that once, however often it is called.
+public abstract class CompatRegistryBase implements JdkHost.Registry {
+
+    private final Map<String, Integer> classes = new HashMap<String, Integer>();
+    private final Map<String, List<String>> providers = new HashMap<String, List<String>>();
+
+    /// For the generated subclass.
+    protected CompatRegistryBase() {
+    }
+
+    /// Whether a generated registry is installed already.
+    public static boolean cn1Installed() {
+        return JdkHost.getRegistry() instanceof CompatRegistryBase;
+    }
+
+    /// Records that the application has the class `className`, as
+    /// `Class.getName()` answers it, created and typed under `id`.
+    public final void cn1Class(String className, int id) {
+        classes.put(className, Integer.valueOf(id));
+    }
+
+    /// Records that `className` provides `service`, both as
+    /// `Class.getName()` answers them. A provider recorded twice for one
+    /// service is kept once, where it was first recorded.
+    public final void cn1Provider(String service, String className) {
+        List<String> list = providers.get(service);
+        if (list == null) {
+            list = new ArrayList<String>();
+            providers.put(service, list);
+        }
+        if (!list.contains(className)) {
+            list.add(className);
+        }
+    }
+
+    /// Makes this the registry `JdkHost` serves.
+    public final void cn1Activate() {
+        JdkHost.setRegistry(this);
+    }
+
+    /// A new instance of the class recorded under `id`, or null.
+    protected abstract Object cn1Create(int id);
+
+    /// The class recorded under `id`, or null.
+    protected abstract Class<?> cn1Type(int id);
+
+    @Override
+    public final String[] providers(String service) {
+        List<String> list = providers.get(service);
+        if (list == null) {
+            return null;
+        }
+        return list.toArray(new String[list.size()]);
+    }
+
+    @Override
+    public final Object newInstance(String className) {
+        Integer id = classes.get(className);
+        return id == null ? null : cn1Create(id.intValue());
+    }
+
+    @Override
+    public final Class<?> type(String className) {
+        Integer id = classes.get(className);
+        return id == null ? null : cn1Type(id.intValue());
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/ResourceNames.java b/CodenameOne/src/com/codename1/impl/compat/ResourceNames.java
new file mode 100644
index 00000000000..987f3d2785e
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/ResourceNames.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat;
+
+/// How a classpath resource is named once it ships: the one definition the
+/// build and the runtime share.
+///
+/// A desktop application keeps its resources in package directories
+/// (`com/example/img/logo.png`) and asks for them by that path. A Codename
+/// One application bundle is flat: every resource sits at its root. The build
+/// therefore ships each nested resource under a flat name, and the runtime
+/// turns the path an application asks for into that same name. Both call
+/// [#flatName(String)], so they cannot disagree; the build engine reads it
+/// from the core for that reason.
+///
+/// #### The rule
+///
+/// - A path with no directory -- `logo.png` -- keeps its name.
+/// - In any other path every `_` becomes `_u` and every `/` becomes `__`:
+///   `com/example/img/my_logo.png` ships as
+///   `com__example__img__my_ulogo.png`.
+///
+/// `_` is an escape character there, so two different nested paths never
+/// share a flat name, and the original path can be read back from it. The
+/// file extension is the end of the last segment and is never touched, which
+/// matters because a Codename One build treats some extensions specially. A
+/// nested path can still produce the name of a file that is at the root on
+/// its own account; the build reports that as an error rather than letting
+/// one replace the other.
+///
+/// This class depends on nothing but `java.lang`, and must stay that way.
+public final class ResourceNames {
+
+    private ResourceNames() {
+    }
+
+    /// The resource path, absolute and without its leading slash, that
+    /// `Class.getResource(name)` means for a class called `className`: a name
+    /// starting with `/` is absolute, any other is relative to the class's
+    /// package. `.` and `..` segments are resolved. Answers null for a path
+    /// that climbs above the root or names nothing.
+    ///
+    /// #### Parameters
+    ///
+    /// - `className`: the class's name in either form, `com.example.Main` or
+    ///   `com/example/Main`; null for the absolute lookup a class loader does
+    ///
+    /// - `name`: the name as the application passed it
+    public static String resolve(String className, String name) {
+        if (name == null) {
+            return null;
+        }
+        if (name.startsWith("/")) {
+            return normalize(name);
+        }
+        if (className == null) {
+            return normalize(name);
+        }
+        String cls = className.replace('.', '/');
+        int slash = cls.lastIndexOf('/');
+        return normalize(slash < 0 ? name : cls.substring(0, slash + 1) + name);
+    }
+
+    /// `path` with leading slashes dropped, empty and `.` segments removed
+    /// and `..` segments resolved; null when it climbs above the root or is
+    /// empty once resolved.
+    public static String normalize(String path) {
+        if (path == null) {
+            return null;
+        }
+        int n = path.length();
+        StringBuilder out = new StringBuilder(n);
+        int i = 0;
+        while (i < n) {
+            int end = path.indexOf('/', i);
+            if (end < 0) {
+                end = n;
+            }
+            int len = end - i;
+            if (len == 0 || (len == 1 && path.charAt(i) == '.')) {
+                // An empty segment or the directory itself: nothing to add.
+                i = end + 1;
+                continue;
+            }
+            if (len == 2 && path.charAt(i) == '.' && path.charAt(i + 1) == '.') {
+                if (out.length() == 0) {
+                    return null;
+                }
+                int cut = out.length() - 1;
+                while (cut >= 0 && out.charAt(cut) != '/') {
+                    cut--;
+                }
+                out.setLength(cut < 0 ? 0 : cut);
+                i = end + 1;
+                continue;
+            }
+            if (out.length() > 0) {
+                out.append('/');
+            }
+            out.append(path.substring(i, end));
+            i = end + 1;
+        }
+        return out.length() == 0 ? null : out.toString();
+    }
+
+    /// The name `path` ships under at the root of the application bundle.
+    /// `path` is a normalized resource path ([#normalize(String)]); see the
+    /// class description for the rule.
+    public static String flatName(String path) {
+        if (path.indexOf('/') < 0) {
+            return path;
+        }
+        int n = path.length();
+        StringBuilder out = new StringBuilder(n + 16);
+        for (int i = 0; i < n; i++) {
+            char c = path.charAt(i);
+            if (c == '/') {
+                out.append("__");
+            } else if (c == '_') {
+                out.append("_u");
+            } else {
+                out.append(c);
+            }
+        }
+        return out.toString();
+    }
+
+    /// The nested path a flat name was made from, the inverse of
+    /// [#flatName(String)]; null when `flat` is not the flat name of any
+    /// nested path, which includes every name of a file that was at the root
+    /// all along.
+    public static String nestedPath(String flat) {
+        int n = flat.length();
+        StringBuilder out = new StringBuilder(n);
+        boolean nested = false;
+        for (int i = 0; i < n; i++) {
+            char c = flat.charAt(i);
+            if (c != '_') {
+                out.append(c);
+                continue;
+            }
+            if (i + 1 >= n) {
+                return null;
+            }
+            char next = flat.charAt(++i);
+            if (next == '_') {
+                out.append('/');
+                nested = true;
+            } else if (next == 'u') {
+                out.append('_');
+            } else {
+                return null;
+            }
+        }
+        return nested ? out.toString() : null;
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/Resources.java b/CodenameOne/src/com/codename1/impl/compat/Resources.java
new file mode 100644
index 00000000000..977676664ce
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/Resources.java
@@ -0,0 +1,564 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat;
+
+import com.codename1.impl.JdkHost;
+import com.codename1.ui.Display;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+import java.util.ServiceLoader;
+import java.util.Set;
+
+/// Classpath resources for an application built from desktop or Android
+/// sources: what `Class.getResource`, `Class.getResourceAsStream` and the
+/// `ClassLoader` lookups do on a desktop. `com.codename1.impl.CoreJdkHost`
+/// reads application resources through [#open(String)] as well, so the class
+/// library's `java.util.ResourceBundle`, `java.util.ServiceLoader` and
+/// `cn1res:` URLs find what the build shipped.
+///
+/// Nothing calls these methods by name. The build's remap step rewrites an
+/// application's calls so that they arrive here: `getClass().getResource(n)`
+/// becomes `Resources.getResource(getClass(), n)`, and so on for each method
+/// below that takes the original receiver as its first parameter.
+///
+/// #### How a resource is found
+///
+/// A device has no classpath and no directories: every resource of the
+/// application sits at the root of its bundle. The build ships each nested
+/// resource under the flat name [ResourceNames#flatName(String)] gives its
+/// path, and records the paths in an index (the registry generated with the
+/// application, `com.codename1.generated.compat.CompatRegistry`, which calls
+/// [#cn1BeginIndex()] and [#cn1AddResource(String)]). A lookup resolves
+/// the name the way the JDK does -- relative to the class's package unless it
+/// starts with `/`, with `.` and `..` resolved -- answers null when the index
+/// has no such path, and otherwise reads the flat name. Nothing is opened to
+/// find out whether a nested resource exists.
+///
+/// A name with no directory is not flattened, so the build's index may not
+/// know it (a file from the ordinary Codename One resource directory is one
+/// the desktop sources never listed). Such a name is looked for in the
+/// bundle.
+///
+/// Where no build step ran -- this module's own tests, a layer's tests -- no
+/// index is installed, and a resource is read under the path that was asked
+/// for, then under its flat name.
+///
+/// #### URLs
+///
+/// `getResource` answers a [URL] in the `cn1res:` scheme whose path is the
+/// resource's ORIGINAL absolute path: `cn1res:/com/example/img/logo.png`.
+/// `openStream()` reads it through this class, and `toString()`,
+/// `toExternalForm()`, `getPath()` and `getFile()` are the same on every
+/// platform and every run, so code that passes `url.toExternalForm()` to an
+/// image or stylesheet loader keeps working: the loader opens the string as a
+/// URL again, or hands its path to [#open(String)].
+///
+/// The device's own `java.net.URL` knows the scheme. A port that runs on a
+/// real JDK, whose `URL` does not, installs a [UrlFactory] that attaches a
+/// handler reading through [#openUrlPath(String)].
+///
+/// #### Bundles and services on a real JDK
+///
+/// The JDK's `ResourceBundle` and `ServiceLoader` look a nested name up
+/// through a class loader, which cannot see a resource the build flattened.
+/// A port on a real JDK therefore installs, with
+/// [#cn1SetClassLoader(ClassLoader)], a loader that falls back to this
+/// class, and the build sends an application's `ResourceBundle.getBundle`
+/// and `ServiceLoader.load` calls to the methods here that pass it. Where
+/// none is installed -- a device, whose class library reads the generated
+/// registry -- those methods are the calls they stand in for.
+///
+/// #### Class names
+///
+/// A relative name is resolved against `Class.getName()`. A build that
+/// renames classes after the remap step (an obfuscator) changes that name,
+/// so relative lookups need the application's classes kept under their
+/// names; absolute names are unaffected.
+public final class Resources {
+
+    /// The paths the build shipped, or null when no build step recorded any.
+    private static Set<String> index;
+
+    private static Provider provider;
+
+    private static ClassLoader contextLoader;
+
+    private static UrlFactory urlFactory;
+
+    private static ClassLoader portLoader;
+
+    private Resources() {
+    }
+
+    /// Where the bytes of a flat resource name come from. The default reads
+    /// the application bundle; a test installs its own with
+    /// [#cn1SetProvider(Provider)].
+    public interface Provider {
+        /// The resource shipped as `flatName` (no leading slash), or null
+        /// when the bundle has none.
+        InputStream open(String flatName) throws IOException;
+    }
+
+    /// Replaces the source of resource bytes; null restores the default.
+    public static void cn1SetProvider(Provider p) {
+        provider = p;
+    }
+
+    /// Makes the `cn1res:` URLs [#getResource(Class, String)] answers, for a
+    /// port whose `java.net.URL` does not know the scheme.
+    public interface UrlFactory {
+        /// The `cn1res:` URL of `encodedPath`, an absolute path that is
+        /// already percent-encoded; [Resources#openUrlPath(String)] reads it.
+        URL create(String encodedPath) throws IOException;
+    }
+
+    /// Installs the port's URL factory; null restores the default
+    /// `new URL("cn1res", null, path)`.
+    public static void cn1SetUrlFactory(UrlFactory factory) {
+        urlFactory = factory;
+    }
+
+    /// Installs the class loader a port on a real JDK resolves flattened
+    /// resources through; see the class description. Null removes it.
+    public static void cn1SetClassLoader(ClassLoader loader) {
+        portLoader = loader;
+    }
+
+    /// The loader [#cn1SetClassLoader(ClassLoader)] installed, or null.
+    public static ClassLoader cn1ClassLoader() {
+        return portLoader;
+    }
+
+    /// Opens the resource a `cn1res:` URL names by `encodedPath`, its
+    /// percent-encoded path: what such a URL's stream reads.
+    public static InputStream openUrlPath(String encodedPath) {
+        String path = decode(encodedPath);
+        return path == null ? null : open(path);
+    }
+
+    /// `ResourceBundle.getBundle(baseName)`, through the port's loader when
+    /// one is installed.
+    public static ResourceBundle getBundle(String baseName) {
+        return getBundle(baseName, Locale.getDefault());
+    }
+
+    /// `ResourceBundle.getBundle(baseName, locale)`, through the port's
+    /// loader when one is installed.
+    public static ResourceBundle getBundle(String baseName, Locale locale) {
+        ClassLoader loader = portLoader;
+        if (loader == null) {
+            return ResourceBundle.getBundle(baseName, locale);
+        }
+        return ResourceBundle.getBundle(baseName, locale, loader);
+    }
+
+    /// The folder of the services files `ServiceLoader` reads on a JDK.
+    public static final String SERVICES = "META-INF/services/";
+
+    /// For a port on a real JDK, whose `ServiceLoader` reads services files
+    /// through the installed loader: the services file to read for `service`
+    /// (dotted, as `Class.getName()` answers it), listing what the generated
+    /// registry lists -- the application's providers, then each bundled
+    /// library's, and only those that ship, as on a device. Empty when the
+    /// registry lists none; null when no generated registry is installed, and
+    /// the files on the class path are all there is.
+    public static String cn1ServicesFile(String service) {
+        if (!CompatRegistryBase.cn1Installed()) {
+            return null;
+        }
+        String[] providers = JdkHost.getRegistry().providers(service);
+        StringBuilder out = new StringBuilder();
+        if (providers != null) {
+            for (String provider : providers) {
+                out.append(provider).append('\n');
+            }
+        }
+        return out.toString();
+    }
+
+    /// `ServiceLoader.load(service)`, through the port's loader when one is
+    /// installed.
+    public static <S> ServiceLoader<S> load(Class<S> service) {
+        ClassLoader loader = portLoader;
+        if (loader == null) {
+            return ServiceLoader.load(service);
+        }
+        return ServiceLoader.load(service, loader);
+    }
+
+    /// Starts an index: from here on a nested path exists only if
+    /// [#cn1AddResource(String)] named it. The generated registry calls
+    /// this once, then adds every path.
+    public static void cn1BeginIndex() {
+        index = new HashSet<String>();
+    }
+
+    /// Records that the build shipped the resource at `path`, an absolute
+    /// path without its leading slash. Only after [#cn1BeginIndex()]: a path
+    /// added to no index would be one forgotten in silence.
+    public static void cn1AddResource(String path) {
+        Set<String> current = index;
+        if (current == null) {
+            throw new IllegalStateException("cn1BeginIndex() has not been called");
+        }
+        current.add(path);
+    }
+
+    /// Every path the build recorded, in no particular order; empty when
+    /// no build step recorded any. A loader that has to find a resource by
+    /// what is IN it -- a font by the name it gives itself -- reads these.
+    public static String[] cn1ResourcePaths() {
+        Set<String> current = index;
+        if (current == null) {
+            return new String[0];
+        }
+        String[] out = new String[current.size()];
+        int i = 0;
+        for (String path : current) {
+            out[i++] = path;
+        }
+        return out;
+    }
+
+    /// Forgets the index, as if no build step had run. For tests.
+    public static void cn1ClearIndex() {
+        index = null;
+    }
+
+    /// `Class.getResourceAsStream(name)` for `cls`.
+    public static InputStream getResourceAsStream(Class<?> cls, String name) {
+        return open(ResourceNames.resolve(cls.getName(), requireName(name)));
+    }
+
+    /// `Class.getResource(name)` for `cls`.
+    public static URL getResource(Class<?> cls, String name) {
+        return url(ResourceNames.resolve(cls.getName(), requireName(name)));
+    }
+
+    /// `ClassLoader.getResourceAsStream(name)`. An application has one
+    /// loader, so `loader` only has to be non-null. As on a desktop, a class
+    /// loader's names are absolute and written WITHOUT a leading slash; one
+    /// that has it finds nothing.
+    public static InputStream getResourceAsStream(ClassLoader loader, String name) {
+        requireLoader(loader);
+        return getSystemResourceAsStream(name);
+    }
+
+    /// `ClassLoader.getResource(name)`; see
+    /// [#getResourceAsStream(ClassLoader, String)].
+    public static URL getResource(ClassLoader loader, String name) {
+        requireLoader(loader);
+        return getSystemResource(name);
+    }
+
+    /// `ClassLoader.getResources(name)`: the one resource of that name, or
+    /// none.
+    public static Enumeration<URL> getResources(ClassLoader loader, String name) {
+        requireLoader(loader);
+        return getSystemResources(name);
+    }
+
+    /// `ClassLoader.getSystemResourceAsStream(name)`.
+    public static InputStream getSystemResourceAsStream(String name) {
+        return requireName(name).startsWith("/") ? null : open(ResourceNames.normalize(name));
+    }
+
+    /// `ClassLoader.getSystemResource(name)`.
+    public static URL getSystemResource(String name) {
+        return requireName(name).startsWith("/") ? null : url(ResourceNames.normalize(name));
+    }
+
+    /// `ClassLoader.getSystemResources(name)`.
+    public static Enumeration<URL> getSystemResources(String name) {
+        List<URL> found = new ArrayList<URL>(1);
+        URL url = getSystemResource(name);
+        if (url != null) {
+            found.add(url);
+        }
+        return new UrlEnumeration(found);
+    }
+
+    /// `Thread.getContextClassLoader()`: the application's one class loader,
+    /// or whatever [#setContextClassLoader(Thread, ClassLoader)] was last
+    /// given. It is good for the resource lookups above and for nothing
+    /// else; the build rejects any other use of a class loader.
+    public static ClassLoader getContextClassLoader(Thread thread) {
+        if (thread == null) {
+            throw new NullPointerException();
+        }
+        if (contextLoader != null) {
+            return contextLoader;
+        }
+        return portLoader != null ? portLoader : ClassLoader.getSystemClassLoader();
+    }
+
+    /// `loader.loadClass(name)`: the class of that name when the generated
+    /// registry knows it -- the application's resource bundle classes and
+    /// service providers, the classes it may need by name. Anything else
+    /// throws `ClassNotFoundException`, as a desktop does for a class that is
+    /// absent, which is how desktop code probing for an optional class reads
+    /// it. No class is looked up by its string name: a device loads nothing
+    /// at run time, and an obfuscated Android or JavaScript build has renamed
+    /// it, so the answer is the registry's on every port alike.
+    public static Class<?> loadClass(ClassLoader loader, String name) throws ClassNotFoundException {
+        if (loader == null || name == null) {
+            throw new NullPointerException();
+        }
+        JdkHost.Registry registry = JdkHost.getRegistry();
+        Class<?> type = registry == null ? null : registry.type(name);
+        if (type == null) {
+            throw new ClassNotFoundException(name);
+        }
+        return type;
+    }
+
+    /// `Thread.setContextClassLoader(loader)`. There is one loader, so this
+    /// only remembers the object for [#getContextClassLoader(Thread)] to
+    /// hand back, for every thread alike.
+    public static void setContextClassLoader(Thread thread, ClassLoader loader) {
+        if (thread == null) {
+            throw new NullPointerException();
+        }
+        contextLoader = loader;
+    }
+
+    /// Whether the application ships a resource at `path`, an absolute path
+    /// with or without its leading slash.
+    public static boolean exists(String path) {
+        String p = ResourceNames.normalize(path);
+        if (p == null) {
+            return false;
+        }
+        if (index != null && (index.contains(p) || p.indexOf('/') >= 0)) {
+            return index.contains(p);
+        }
+        // Closed just below; PMD does not follow a close inside a catch.
+        InputStream in = read(p); //NOPMD CloseResource
+        if (in == null) {
+            return false;
+        }
+        try {
+            in.close();
+        } catch (IOException e) {
+            // It was there to be opened, which is all that was asked.
+        }
+        return true;
+    }
+
+    /// Opens the resource at `path`, an absolute path with or without its
+    /// leading slash, as the application named it on a desktop
+    /// (`/com/example/img/logo.png`). Answers null when there is none. This
+    /// is what a `cn1res:` URL reads, and what a loader that was handed such
+    /// a URL's path should call.
+    public static InputStream open(String path) {
+        String p = ResourceNames.normalize(path);
+        if (p == null) {
+            return null;
+        }
+        if (index != null && p.indexOf('/') >= 0 && !index.contains(p)) {
+            return null;
+        }
+        return read(p);
+    }
+
+    private static InputStream read(String p) {
+        boolean nested = p.indexOf('/') >= 0;
+        if (index == null && nested && provider == null) {
+            // Nothing was flattened by a build: the resource may still be
+            // where the application's own build put it.
+            InputStream direct = Resources.class.getResourceAsStream("/" + p);
+            if (direct != null) {
+                return direct;
+            }
+        }
+        String flat = ResourceNames.flatName(p);
+        if (provider != null) {
+            try {
+                return provider.open(flat);
+            } catch (IOException e) {
+                // A resource that cannot be read is one that is not there.
+                return null;
+            }
+        }
+        if (Display.isInitialized()) {
+            return Display.getInstance().getResourceAsStream(Resources.class, "/" + flat);
+        }
+        return Resources.class.getResourceAsStream("/" + flat);
+    }
+
+    private static URL url(String p) {
+        if (p == null || !exists(p)) {
+            return null;
+        }
+        String encoded = "/" + encode(p);
+        UrlFactory factory = urlFactory;
+        try {
+            if (factory != null) {
+                return factory.create(encoded);
+            }
+            return new URL("cn1res", null, encoded);
+        } catch (MalformedURLException e) {
+            // The device's URL knows cn1res, and a port that runs elsewhere
+            // installs a factory; a URL nobody can make is no resource.
+            return null;
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    /// The inverse of [#encode(String)]: UTF-8 percent escapes decoded,
+    /// anything else as it stands. Null for a malformed escape.
+    static String decode(String encoded) {
+        if (encoded == null || encoded.indexOf('%') < 0) {
+            return encoded;
+        }
+        int n = encoded.length();
+        byte[] bytes = new byte[n];
+        StringBuilder out = new StringBuilder(n);
+        int i = 0;
+        while (i < n) {
+            char c = encoded.charAt(i);
+            if (c != '%') {
+                out.append(c);
+                i++;
+                continue;
+            }
+            int count = 0;
+            while (i < n && encoded.charAt(i) == '%') {
+                if (i + 2 >= n) {
+                    return null;
+                }
+                int high = Character.digit(encoded.charAt(i + 1), 16);
+                int low = Character.digit(encoded.charAt(i + 2), 16);
+                if (high < 0 || low < 0) {
+                    return null;
+                }
+                bytes[count++] = (byte) ((high << 4) | low);
+                i += 3;
+            }
+            try {
+                out.append(new String(bytes, 0, count, "UTF-8"));
+            } catch (java.io.UnsupportedEncodingException e) {
+                return null;
+            }
+        }
+        return out.toString();
+    }
+
+    private static String requireName(String name) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        return name;
+    }
+
+    private static void requireLoader(ClassLoader loader) {
+        if (loader == null) {
+            throw new NullPointerException();
+        }
+    }
+
+    private static final String HEX = "0123456789ABCDEF";
+
+    /// Percent-encodes what would otherwise end a URL's path or be read as
+    /// an escape: everything but letters, digits and `/ - . _ ~ $ + ! ' ( )
+    /// , @ = & ;`, as UTF-8.
+    static String encode(String path) {
+        int n = path.length();
+        StringBuilder out = null;
+        for (int i = 0; i < n; i++) {
+            char c = path.charAt(i);
+            boolean plain = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+                    || "/-._~$+!'(),@=&;".indexOf(c) >= 0;
+            if (plain) {
+                if (out != null) {
+                    out.append(c);
+                }
+                continue;
+            }
+            if (out == null) {
+                out = new StringBuilder(n + 16);
+                out.append(path.substring(0, i));
+            }
+            int code = c;
+            if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) {
+                char low = path.charAt(i + 1);
+                if (low >= 0xdc00 && low <= 0xdfff) {
+                    code = 0x10000 + ((c - 0xd800) << 10) + (low - 0xdc00);
+                    i++;
+                }
+            }
+            if (code < 0x80) {
+                hex(out, code);
+            } else if (code < 0x800) {
+                hex(out, 0xc0 | (code >> 6));
+                hex(out, 0x80 | (code & 0x3f));
+            } else if (code < 0x10000) {
+                hex(out, 0xe0 | (code >> 12));
+                hex(out, 0x80 | ((code >> 6) & 0x3f));
+                hex(out, 0x80 | (code & 0x3f));
+            } else {
+                hex(out, 0xf0 | (code >> 18));
+                hex(out, 0x80 | ((code >> 12) & 0x3f));
+                hex(out, 0x80 | ((code >> 6) & 0x3f));
+                hex(out, 0x80 | (code & 0x3f));
+            }
+        }
+        return out == null ? path : out.toString();
+    }
+
+    private static void hex(StringBuilder out, int b) {
+        out.append('%').append(HEX.charAt((b >> 4) & 0xf)).append(HEX.charAt(b & 0xf));
+    }
+
+    private static final class UrlEnumeration implements Enumeration<URL> {
+        private final List<URL> urls;
+        private int next;
+
+        UrlEnumeration(List<URL> urls) {
+            this.urls = urls;
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return next < urls.size();
+        }
+
+        @Override
+        public URL nextElement() {
+            if (next >= urls.size()) {
+                throw new java.util.NoSuchElementException();
+            }
+            return urls.get(next++);
+        }
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/UncaughtExceptions.java b/CodenameOne/src/com/codename1/impl/compat/UncaughtExceptions.java
new file mode 100644
index 00000000000..e8af8292405
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/UncaughtExceptions.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat;
+
+import com.codename1.ui.Display;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+
+/// Makes the default uncaught exception handler an application sets see what
+/// its event dispatch thread tasks throw, as a desktop's does.
+///
+/// An exception escaping a task on the Codename One EDT never reaches a
+/// thread's uncaught handler: the platform's EDT error handling catches it
+/// first. So the first time a handler is installed after the display is
+/// up, an EDT error handler is registered that hands the throwable to the
+/// default handler as it stands when the error happens, and consumes it.
+///
+/// The build sends an application's `Thread.setDefaultUncaughtExceptionHandler`
+/// calls to [#setDefaultUncaughtExceptionHandler], so this happens on every
+/// platform, including the ones whose `Thread` is the JDK's. Only the
+/// application's own call registers the forwarder: a handler a platform
+/// installed for itself (Android has one that ends the process) does not.
+/// The device's class library calls [#watch()] from its own `Thread`, which
+/// shares the one registration.
+///
+/// Internal: the build and the class library call this; an application
+/// does not.
+public final class UncaughtExceptions {
+
+    private static boolean watched;
+
+    private UncaughtExceptions() {
+    }
+
+    /// `Thread.setDefaultUncaughtExceptionHandler(handler)`, and then
+    /// [#watch()] when `handler` is not null.
+    public static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) {
+        Thread.setDefaultUncaughtExceptionHandler(handler);
+        if (handler != null) {
+            watch();
+        }
+    }
+
+    /// Registers the forwarder, once, when the display is initialized. A
+    /// call before then does nothing, and a later one registers it.
+    public static void watch() {
+        if (watched || !Display.isInitialized()) {
+            return;
+        }
+        watched = true;
+        Display.getInstance().addEdtErrorHandler(new EdtErrorForwarder());
+    }
+
+    /// Forwards an event dispatch thread error to the default uncaught
+    /// exception handler, as it stands when the error happens.
+    private static final class EdtErrorForwarder implements ActionListener<ActionEvent> {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            Thread.UncaughtExceptionHandler handler = Thread.getDefaultUncaughtExceptionHandler();
+            Object source = evt.getSource();
+            if (handler != null && source instanceof Throwable) {
+                evt.consume();
+                handler.uncaughtException(Thread.currentThread(), (Throwable) source);
+            }
+        }
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/osgi/Bundle.java b/CodenameOne/src/com/codename1/impl/compat/osgi/Bundle.java
new file mode 100644
index 00000000000..dab3ecaa3a2
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/osgi/Bundle.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat.osgi;
+
+/// `org.osgi.framework.Bundle`, as the type [FrameworkUtil#getBundle(Class)]
+/// is declared to answer. Nothing implements it: see the package description.
+public interface Bundle {
+
+    /// The bundle's execution context.
+    BundleContext getBundleContext();
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/osgi/BundleContext.java b/CodenameOne/src/com/codename1/impl/compat/osgi/BundleContext.java
new file mode 100644
index 00000000000..bf4415b23fa
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/osgi/BundleContext.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat.osgi;
+
+/// `org.osgi.framework.BundleContext`, with the two members a library uses
+/// to fetch one service. Nothing implements it: see the package description.
+public interface BundleContext {
+
+    /// A reference to a service registered under `clazz`, or null.
+    <S> ServiceReference<S> getServiceReference(Class<S> clazz);
+
+    /// The service `reference` refers to, or null.
+    <S> S getService(ServiceReference<S> reference);
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/osgi/FrameworkUtil.java b/CodenameOne/src/com/codename1/impl/compat/osgi/FrameworkUtil.java
new file mode 100644
index 00000000000..bf0be867717
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/osgi/FrameworkUtil.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat.osgi;
+
+/// `org.osgi.framework.FrameworkUtil`, outside any framework: see the
+/// package description. Only [#getBundle(Class)] is here.
+public final class FrameworkUtil {
+
+    private FrameworkUtil() {
+    }
+
+    /// Null, for every class: no class of the application was loaded by an
+    /// OSGi bundle, which is how the real method says "not running in OSGi".
+    public static Bundle getBundle(Class<?> classFromBundle) {
+        return null;
+    }
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/osgi/ServiceReference.java b/CodenameOne/src/com/codename1/impl/compat/osgi/ServiceReference.java
new file mode 100644
index 00000000000..a55baaf6d82
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/osgi/ServiceReference.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.compat.osgi;
+
+/// `org.osgi.framework.ServiceReference`, as a type only. Nothing implements
+/// it: see the package description.
+public interface ServiceReference<S> {
+}
diff --git a/CodenameOne/src/com/codename1/impl/compat/osgi/package-info.java b/CodenameOne/src/com/codename1/impl/compat/osgi/package-info.java
new file mode 100644
index 00000000000..a3cbd21afdd
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/osgi/package-info.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The four OSGi types a library asks, to find out whether it is running in
+/// an OSGi framework: [FrameworkUtil], [Bundle], [BundleContext] and
+/// [ServiceReference], with only the members that question takes.
+///
+/// A library that supports OSGi and the plain class path names these types
+/// in the one method that probes for a framework, and its jar declares the
+/// OSGi API an optional dependency. The build's remap step points
+/// `org.osgi.framework` at this package, so that such a library links, and
+/// [FrameworkUtil#getBundle(Class)] answers what the real one answers for a
+/// class no framework loaded: null. The library then takes its class path
+/// route.
+///
+/// This is not an OSGi implementation and will not grow into one. No bundle,
+/// context or service reference is ever created; the three interfaces exist
+/// so that the probe's descriptors resolve.
+package com.codename1.impl.compat.osgi;
diff --git a/CodenameOne/src/com/codename1/impl/compat/package-info.java b/CodenameOne/src/com/codename1/impl/compat/package-info.java
new file mode 100644
index 00000000000..1625cf6433b
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/compat/package-info.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// What an application built from desktop or Android sources needs of the
+/// core at run time: the classpath resources it ships, under the flat names a
+/// device bundle gives them ([ResourceNames], [Resources]), and the
+/// superclass of the registry its build generates ([CompatRegistryBase]),
+/// through which the class library creates the resource bundles and service
+/// providers it has.
+///
+/// Internal: the build and generated code call these classes; an
+/// application does not.
+package com.codename1.impl.compat;
diff --git a/CodenameOne/src/com/codename1/impl/process/RuntimeExec.java b/CodenameOne/src/com/codename1/impl/process/RuntimeExec.java
new file mode 100644
index 00000000000..be97b4ad400
--- /dev/null
+++ b/CodenameOne/src/com/codename1/impl/process/RuntimeExec.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.process;
+
+import com.codename1.io.Process;
+import com.codename1.io.ProcessBuilder;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/// `Runtime.exec`, for desktop code relocated onto [ProcessBuilder].
+///
+/// The device runtime's `java.lang.Runtime` has no `exec`, so the build
+/// rewrites `runtime.exec(...)` into a call here that takes the receiver
+/// first, the way it rewrites every instance member the device lacks. Each
+/// method does what the JavaSE overload of the same parameters does: a
+/// command string is split at whitespace with no quoting (a shell is never
+/// implied), and an environment array, when not null, replaces the inherited
+/// environment entirely, and a null working directory inherits the parent's.
+/// @hidden
+public final class RuntimeExec {
+    private RuntimeExec() {
+    }
+
+    /// `Runtime.exec(String)`.
+    public static Process exec(Runtime runtime, String command) throws IOException {
+        return exec(runtime, command, null);
+    }
+
+    /// `Runtime.exec(String, String[])`.
+    public static Process exec(Runtime runtime, String command, String[] envp) throws IOException {
+        return exec(runtime, command, envp, null);
+    }
+
+    /// `Runtime.exec(String, String[], File)`.
+    public static Process exec(Runtime runtime, String command, String[] envp, File dir) throws IOException {
+        if (command == null) {
+            throw new NullPointerException("command");
+        }
+        if (command.length() == 0) {
+            throw new IllegalArgumentException("Empty command");
+        }
+        return exec(runtime, split(command), envp, dir);
+    }
+
+    /// `Runtime.exec(String[])`.
+    public static Process exec(Runtime runtime, String[] cmdarray) throws IOException {
+        return exec(runtime, cmdarray, null);
+    }
+
+    /// `Runtime.exec(String[], String[])`.
+    public static Process exec(Runtime runtime, String[] cmdarray, String[] envp) throws IOException {
+        return exec(runtime, cmdarray, envp, null);
+    }
+
+    /// `Runtime.exec(String[], String[], File)`.
+    public static Process exec(Runtime runtime, String[] cmdarray, String[] envp, File dir) throws IOException {
+        if (runtime == null) {
+            // What calling exec on a null Runtime throws.
+            throw new NullPointerException("runtime");
+        }
+        if (cmdarray == null) {
+            throw new NullPointerException("cmdarray");
+        }
+        if (cmdarray.length == 0) {
+            // JavaSE reads cmdarray[0] unguarded.
+            throw new IndexOutOfBoundsException("Empty command");
+        }
+        ProcessBuilder builder = new ProcessBuilder(cmdarray);
+        if (envp != null) {
+            Map<String, String> env = builder.environment();
+            env.clear();
+            for (String raw : envp) {
+                // As JavaSE: anything after a NUL is dropped and an entry with
+                // no '=' after its first character is skipped, not rejected.
+                int nul = raw.indexOf('\0');
+                String entry = nul >= 0 ? raw.substring(0, nul) : raw;
+                int split = entry.indexOf('=', 1);
+                if (split > 0) {
+                    env.put(entry.substring(0, split), entry.substring(split + 1));
+                }
+            }
+        }
+        builder.directory(dir);
+        return builder.start();
+    }
+
+    /// The words of `command`, as `java.util.StringTokenizer` splits it with
+    /// its default delimiters: space, tab, newline, carriage return, form feed.
+    static String[] split(String command) {
+        List<String> words = new ArrayList<String>();
+        int start = -1;
+        int n = command.length();
+        for (int i = 0; i < n; i++) {
+            if (isDelimiter(command.charAt(i))) {
+                if (start >= 0) {
+                    words.add(command.substring(start, i));
+                    start = -1;
+                }
+            } else if (start < 0) {
+                start = i;
+            }
+        }
+        if (start >= 0) {
+            words.add(command.substring(start));
+        }
+        return words.toArray(new String[words.size()]);
+    }
+
+    private static boolean isDelimiter(char c) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
+    }
+}
diff --git a/CodenameOne/src/com/codename1/io/Process.java b/CodenameOne/src/com/codename1/io/Process.java
index 59e26c53795..02b2b889577 100644
--- a/CodenameOne/src/com/codename1/io/Process.java
+++ b/CodenameOne/src/com/codename1/io/Process.java
@@ -32,6 +32,16 @@
 /// blocking stream I/O on the EDT. Interrupting a wait does not kill the child.
 /// Unlike JavaSE, this class is AutoCloseable: close forcibly terminates the direct
 /// child and closes its three streams. Descendants are not terminated.
+///
+/// Every member this class shares with `java.lang.Process` has the same name,
+/// parameters and modifiers, and no method is abstract here that is concrete
+/// there, so a desktop class compiled against `java.lang.Process` -- a caller
+/// or a subclass -- runs against this one once its class references are
+/// renamed. The JavaSE members with no counterpart are `toHandle()`,
+/// `onExit()`, `info()`, `children()`, `descendants()`,
+/// `supportsNormalTermination()` and the reader and writer accessors: their
+/// types (`ProcessHandle`, `CompletableFuture`, `BufferedReader`) are not part
+/// of the device runtime.
 @com.codename1.impl.SharedWithBackend
 public abstract class Process implements AutoCloseable {
     /// The child's stdin (the parent writes to it).
@@ -44,8 +54,17 @@ public abstract class Process implements AutoCloseable {
     public abstract int exitValue();
     /// Requests termination of the direct child. On Windows this is forcible.
     public abstract void destroy();
-    /// Forcibly terminates the direct child; completion is asynchronous.
-    public abstract Process destroyForcibly();
+    /// Forcibly terminates the direct child; completion is asynchronous. A
+    /// subclass with no forcible kill inherits [#destroy()], as in JavaSE.
+    public Process destroyForcibly() {
+        destroy();
+        return this;
+    }
+    /// The operating system's id for the child. A port that cannot name it
+    /// throws UnsupportedOperationException, which is also JavaSE's default.
+    public long pid() {
+        throw new UnsupportedOperationException(getClass().getName() + ".pid() not supported");
+    }
     /// Whether the direct child is still running.
     public boolean isAlive() {
         try {
diff --git a/CodenameOne/src/com/codename1/io/ProcessBuilder.java b/CodenameOne/src/com/codename1/io/ProcessBuilder.java
index c6ae14b674d..69fac7401ec 100644
--- a/CodenameOne/src/com/codename1/io/ProcessBuilder.java
+++ b/CodenameOne/src/com/codename1/io/ProcessBuilder.java
@@ -24,6 +24,7 @@
 
 import com.codename1.impl.ImplementationFactory;
 import com.codename1.impl.process.ProcessSupport;
+import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -31,7 +32,7 @@
 import java.util.Map;
 
 /// Creates desktop/backend subprocesses using JavaSE-style command lists and pipes.
-/// The working directory is an OS path String, not a Codename One file URL.
+/// The working directory is a `java.io.File`, as in JavaSE.
 /// Shell parsing is never implicit: invoke a shell explicitly if needed.
 /// Mobile/browser ports compile this API but start() throws
 /// UnsupportedOperationException. Support does not imply permission to run every
@@ -39,10 +40,18 @@
 ///
 /// File redirection and inheritIO are not provided in this initial subset. Use
 /// the streams and drain stdout/stderr concurrently, or merge them first.
+///
+/// The members shared with `java.lang.ProcessBuilder` have its names and
+/// parameter types, so desktop code compiled against the JavaSE class runs
+/// against this one once its class references are renamed. JavaSE members
+/// with no counterpart: `inheritIO()`, the `redirectInput`/`redirectOutput`/`redirectError`
+/// family with `ProcessBuilder.Redirect` (no port can attach a child's
+/// streams to anything but pipes), and `startPipeline(List)`, which needs
+/// those redirects.
 @com.codename1.impl.SharedWithBackend
 public final class ProcessBuilder {
     private List<String> command;
-    private String directory;
+    private File directory;
     private Map<String, String> environment;
     private boolean mergeError;
 
@@ -82,15 +91,12 @@ public ProcessBuilder command(String... command) {
         }
         return this;
     }
-    /// Null inherits the parent's working directory. Paths are native OS paths.
-    public ProcessBuilder directory(String directory) {
-        if (directory != null) {
-            checkString(directory);
-        }
+    /// Null inherits the parent's working directory.
+    public ProcessBuilder directory(File directory) {
         this.directory = directory;
         return this;
     }
-    public String directory() {
+    public File directory() {
         return directory;
     }
     /// A mutable copy of the inherited environment, initialized on first access.
@@ -143,7 +149,34 @@ public Process start() throws IOException {
                 }
             }
         }
-        return support.start(args, directory, env, mergeError);
+        String dir = null;
+        if (directory != null) {
+            dir = osPath(directory.getAbsolutePath());
+            checkString(dir);
+        }
+        return support.start(args, dir, env, mergeError);
+    }
+
+    /// The OS path of an absolute `File` path. On a port whose `java.io.File`
+    /// sits over `FileSystemStorage` that path can carry the `file:` scheme,
+    /// which a child process's working directory cannot.
+    static String osPath(String path) {
+        if (!path.startsWith("file:")) {
+            return path;
+        }
+        int i = 5;
+        while (i + 1 < path.length() && path.charAt(i) == '/' && path.charAt(i + 1) == '/') {
+            i++;
+        }
+        String p = path.substring(i);
+        // file:///C:/x names the drive path C:/x.
+        if (p.length() >= 4 && p.charAt(0) == '/' && p.charAt(2) == ':' && p.charAt(3) == '/') {
+            char d = p.charAt(1);
+            if ((d >= 'A' && d <= 'Z') || (d >= 'a' && d <= 'z')) {
+                return p.substring(1);
+            }
+        }
+        return p;
     }
     private static void checkString(String value) {
         if (value == null) {
diff --git a/CodenameOne/src/com/codename1/ui/Image.java b/CodenameOne/src/com/codename1/ui/Image.java
index e5824e00cf9..6a6f041a264 100644
--- a/CodenameOne/src/com/codename1/ui/Image.java
+++ b/CodenameOne/src/com/codename1/ui/Image.java
@@ -1469,6 +1469,13 @@ public Image modifyAlpha(byte alpha, int removeColor) {
     public Graphics getGraphics() {
         Graphics g = new Graphics(Display.impl.getNativeGraphics(image));
         rgbCache = null;    // the cache will become invalid
+        // So do the scaled copies. A port that cannot draw an image at a size
+        // draws scaled(w, h) instead, which is a copy this image keeps -- at
+        // the image's own size too. An image drawn on again after it had been
+        // shown once went on showing the copy made the first time: on the
+        // native Linux port a picture that was drawn in steps stayed as it was
+        // after the first one, until the collector happened to drop the copy.
+        scaleCache = null;
         return g;
     }
 
diff --git a/CodenameOne/src/com/codename1/ui/geom/GeneralPath.java b/CodenameOne/src/com/codename1/ui/geom/GeneralPath.java
index ee90cc09155..e0c43d89c6c 100644
--- a/CodenameOne/src/com/codename1/ui/geom/GeneralPath.java
+++ b/CodenameOne/src/com/codename1/ui/geom/GeneralPath.java
@@ -1971,8 +1971,23 @@ private static Shape intersection(Rectangle r, Shape s, GeneralPath out) {
                                 maxY = (float) (boundingRect.getY() + boundingRect.getHeight());
                             }
                             if (rect2D.contains(curve.x(0.5), curve.y(0.5))) {
-                                // It is fully inside, we can just add it to the out path
-                                curve.addToPath(out, false);
+                                // It is fully inside, we can just add it to the out path.
+                                // It CONTINUES the subpath: passing join == false here
+                                // made every curve open a subpath of its own, so a shape
+                                // with a curved corner came back as one sliver per corner
+                                // (the corner and the edge after it, closed across the
+                                // shape) and its inside was no longer inside. Every port
+                                // that narrows a shape clip with clipRect goes through
+                                // this, which is how a gradient filled through a rounded
+                                // rectangle was drawn as a hollow, skewed outline. The
+                                // segment before may have ended outside and been clamped
+                                // to the rectangle, in which case the outline first runs
+                                // from there to where the curve really starts.
+                                if (started && (Math.abs(prevX - origPrevX) > epsilon
+                                        || Math.abs(prevY - origPrevY) > epsilon)) {
+                                    out.lineTo((float) origPrevX, (float) origPrevY);
+                                }
+                                curve.addToPath(out, started);
                                 prevX = (float) curveEnd.getX();
                                 prevY = (float) curveEnd.getY();
                                 origPrevX = curveEnd.getX();
diff --git a/vm/JavaAPI/src/java/util/regex/MatchResult.java b/CodenameOne/src/com/codename1/util/regex/MatchResult.java
similarity index 77%
rename from vm/JavaAPI/src/java/util/regex/MatchResult.java
rename to CodenameOne/src/com/codename1/util/regex/MatchResult.java
index eb94ceec620..b2d71de20db 100644
--- a/vm/JavaAPI/src/java/util/regex/MatchResult.java
+++ b/CodenameOne/src/com/codename1/util/regex/MatchResult.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Codename One and/or its affiliates. All rights reserved.
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
@@ -20,14 +20,22 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package java.util.regex;
+package com.codename1.util.regex;
 
+/// What one match found: the same shape as `java.util.regex.MatchResult`.
 public interface MatchResult {
-   public int end();
-   public int end(int group);
-   public String group();
-   public String group(int group);
-   public int groupCount();
-   public int start();
-   public int start(int group);
+
+    int start();
+
+    int start(int group);
+
+    int end();
+
+    int end(int group);
+
+    String group();
+
+    String group(int group);
+
+    int groupCount();
 }
diff --git a/CodenameOne/src/com/codename1/util/regex/Matcher.java b/CodenameOne/src/com/codename1/util/regex/Matcher.java
new file mode 100644
index 00000000000..aea7c9ff9bd
--- /dev/null
+++ b/CodenameOne/src/com/codename1/util/regex/Matcher.java
@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.util.regex;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/// The same shape as `java.util.regex.Matcher`, over this package's [Pattern].
+///
+/// Everything a match is read through is here -- `matches`, `lookingAt`,
+/// `find`, groups by number and by name, regions, and the replacement
+/// methods with the JDK's `$1` and `${name}` syntax. `hitEnd`,
+/// `requireEnd` and the two bounds switches are not provided.
+public final class Matcher implements MatchResult {
+
+    private Pattern pattern;
+    CharSequence text;
+    int from;
+    int to;
+
+    /// The state the nodes of a pattern read and write while matching.
+    boolean requireEnd;
+    int matchEnd;
+    int endAt = -1;
+    int subEnd;
+    int oldLast = -1;
+    int[] starts;
+    int[] ends;
+    int[] opened;
+    int[] loopCount;
+    int[] loopStart;
+
+    private int first = -1;
+    private int last;
+    private int appendPosition;
+
+    Matcher(Pattern pattern, CharSequence text) {
+        if (text == null) {
+            throw new NullPointerException();
+        }
+        this.text = text;
+        use(pattern);
+        reset();
+    }
+
+    private void use(Pattern p) {
+        pattern = p;
+        starts = new int[p.groupCount + 1];
+        ends = new int[p.groupCount + 1];
+        opened = new int[p.groupCount + 1];
+        loopCount = new int[p.loopCount];
+        loopStart = new int[p.loopCount];
+    }
+
+    int[] saveGroups() {
+        int n = starts.length;
+        if (n == 1) {
+            return null;
+        }
+        int[] saved = new int[n * 2];
+        System.arraycopy(starts, 0, saved, 0, n);
+        System.arraycopy(ends, 0, saved, n, n);
+        return saved;
+    }
+
+    void restoreGroups(int[] saved) {
+        if (saved != null) {
+            int n = starts.length;
+            System.arraycopy(saved, 0, starts, 0, n);
+            System.arraycopy(saved, n, ends, 0, n);
+        }
+    }
+
+    private void clearGroups() {
+        for (int g = 0; g < starts.length; g++) {
+            starts[g] = -1;
+            ends[g] = -1;
+            opened[g] = -1;
+        }
+    }
+
+    public Pattern pattern() {
+        return pattern;
+    }
+
+    public Matcher usePattern(Pattern newPattern) {
+        if (newPattern == null) {
+            throw new IllegalArgumentException("Pattern cannot be null");
+        }
+        use(newPattern);
+        clearGroups();
+        first = -1;
+        return this;
+    }
+
+    public Matcher reset() {
+        first = -1;
+        last = 0;
+        oldLast = -1;
+        appendPosition = 0;
+        from = 0;
+        to = text.length();
+        clearGroups();
+        return this;
+    }
+
+    public Matcher reset(CharSequence input) {
+        if (input == null) {
+            throw new NullPointerException();
+        }
+        text = input;
+        return reset();
+    }
+
+    public Matcher region(int start, int end) {
+        if (start < 0 || start > text.length() || end < 0 || end > text.length() || start > end) {
+            throw new IndexOutOfBoundsException("start " + start + ", end " + end);
+        }
+        reset();
+        from = start;
+        to = end;
+        return this;
+    }
+
+    public int regionStart() {
+        return from;
+    }
+
+    public int regionEnd() {
+        return to;
+    }
+
+    private boolean attempt(int start, boolean whole) {
+        clearGroups();
+        requireEnd = whole;
+        endAt = -1;
+        if (oldLast < 0) {
+            oldLast = start;
+        }
+        boolean matched = pattern.root.match(this, start);
+        if (matched) {
+            first = start;
+            last = matchEnd;
+            starts[0] = start;
+            ends[0] = matchEnd;
+        } else {
+            first = -1;
+            clearGroups();
+        }
+        oldLast = last;
+        return matched;
+    }
+
+    public boolean matches() {
+        return attempt(from, true);
+    }
+
+    public boolean lookingAt() {
+        return attempt(from, false);
+    }
+
+    private boolean search(int start) {
+        if (oldLast < 0) {
+            oldLast = start;
+        }
+        requireEnd = false;
+        endAt = -1;
+        for (int i = start; i <= to; i++) {
+            clearGroups();
+            if (pattern.root.match(this, i)) {
+                first = i;
+                last = matchEnd;
+                starts[0] = i;
+                ends[0] = matchEnd;
+                oldLast = last;
+                return true;
+            }
+        }
+        first = -1;
+        clearGroups();
+        oldLast = last;
+        return false;
+    }
+
+    public boolean find() {
+        int next = last;
+        if (next == first) {
+            next++;
+        }
+        if (next < from) {
+            next = from;
+        }
+        if (next > to) {
+            first = -1;
+            clearGroups();
+            return false;
+        }
+        return search(next);
+    }
+
+    public boolean find(int start) {
+        if (start < 0 || start > text.length()) {
+            throw new IndexOutOfBoundsException("Illegal start index");
+        }
+        reset();
+        return search(start);
+    }
+
+    /// Whether the last match operation found something.
+    public boolean hasMatch() {
+        return first >= 0;
+    }
+
+    private void requireMatch() {
+        if (first < 0) {
+            throw new IllegalStateException("No match found");
+        }
+    }
+
+    private void requireGroup(int group) {
+        requireMatch();
+        if (group < 0 || group > pattern.groupCount) {
+            throw new IndexOutOfBoundsException("No group " + group);
+        }
+    }
+
+    private int named(String name) {
+        if (name == null) {
+            throw new NullPointerException("Null group name");
+        }
+        Integer group = pattern.names.get(name);
+        if (group == null) {
+            throw new IllegalArgumentException("No group with name <" + name + ">");
+        }
+        return group.intValue();
+    }
+
+    @Override
+    public int start() {
+        requireMatch();
+        return first;
+    }
+
+    @Override
+    public int start(int group) {
+        requireGroup(group);
+        return starts[group];
+    }
+
+    public int start(String name) {
+        requireMatch();
+        return starts[named(name)];
+    }
+
+    @Override
+    public int end() {
+        requireMatch();
+        return last;
+    }
+
+    @Override
+    public int end(int group) {
+        requireGroup(group);
+        return ends[group];
+    }
+
+    public int end(String name) {
+        requireMatch();
+        return ends[named(name)];
+    }
+
+    @Override
+    public String group() {
+        return group(0);
+    }
+
+    @Override
+    public String group(int group) {
+        requireGroup(group);
+        if (starts[group] < 0 || ends[group] < 0) {
+            return null;
+        }
+        return text.subSequence(starts[group], ends[group]).toString();
+    }
+
+    public String group(String name) {
+        requireMatch();
+        int group = named(name);
+        if (starts[group] < 0 || ends[group] < 0) {
+            return null;
+        }
+        return text.subSequence(starts[group], ends[group]).toString();
+    }
+
+    @Override
+    public int groupCount() {
+        return pattern.groupCount;
+    }
+
+    /// The match as it is now, unaffected by what this matcher does next.
+    public MatchResult toMatchResult() {
+        return new Snapshot(this);
+    }
+
+    private static final class Snapshot implements MatchResult {
+        private final int[] starts;
+        private final int[] ends;
+        private final String text;
+        private final boolean matched;
+
+        Snapshot(Matcher m) {
+            matched = m.first >= 0;
+            starts = new int[m.starts.length];
+            ends = new int[m.ends.length];
+            System.arraycopy(m.starts, 0, starts, 0, starts.length);
+            System.arraycopy(m.ends, 0, ends, 0, ends.length);
+            text = m.text.toString();
+        }
+
+        private void check(int group) {
+            if (!matched) {
+                throw new IllegalStateException("No match found");
+            }
+            if (group < 0 || group >= starts.length) {
+                throw new IndexOutOfBoundsException("No group " + group);
+            }
+        }
+
+        @Override
+        public int start() {
+            return start(0);
+        }
+
+        @Override
+        public int start(int group) {
+            check(group);
+            return starts[group];
+        }
+
+        @Override
+        public int end() {
+            return end(0);
+        }
+
+        @Override
+        public int end(int group) {
+            check(group);
+            return ends[group];
+        }
+
+        @Override
+        public String group() {
+            return group(0);
+        }
+
+        @Override
+        public String group(int group) {
+            check(group);
+            return starts[group] < 0 || ends[group] < 0 ? null : text.substring(starts[group], ends[group]);
+        }
+
+        @Override
+        public int groupCount() {
+            return starts.length - 1;
+        }
+    }
+
+    /// Each match from here on, as [#toMatchResult()] would answer it: from
+    /// after the last match found, or from the start of the region when
+    /// there is none. The matcher is not reset, so a match already consumed
+    /// is not answered again and a region stays in force.
+    ///
+    /// Lazy, as the JDK's is: each match is found only when the stream asks
+    /// for it, so `results().limit(1)` scans no further than the first.
+    public Stream<MatchResult> results() {
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Results(this),
+                Spliterator.ORDERED | Spliterator.NONNULL), false);
+    }
+
+    /// The matches of one [#results()].
+    private static final class Results implements Iterator<MatchResult> {
+        private final Matcher matcher;
+        private MatchResult next;
+        private boolean done;
+
+        Results(Matcher matcher) {
+            this.matcher = matcher;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (next == null && !done) {
+                if (matcher.find()) {
+                    next = matcher.toMatchResult();
+                } else {
+                    done = true;
+                }
+            }
+            return next != null;
+        }
+
+        @Override
+        public MatchResult next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            MatchResult out = next;
+            next = null;
+            return out;
+        }
+    }
+
+    /// A replacement in which `$` and backslash stand for themselves.
+    public static String quoteReplacement(String s) {
+        if (s.indexOf('\\') < 0 && s.indexOf('$') < 0) {
+            return s;
+        }
+        StringBuilder sb = new StringBuilder(s.length() + 8);
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == '\\' || c == '$') {
+                sb.append('\\');
+            }
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    private void expand(String replacement, StringBuilder out) {
+        int cursor = 0;
+        int length = replacement.length();
+        while (cursor < length) {
+            char c = replacement.charAt(cursor);
+            if (c == '\\') {
+                cursor++;
+                if (cursor == length) {
+                    throw new IllegalArgumentException("character to be escaped is missing");
+                }
+                out.append(replacement.charAt(cursor));
+                cursor++;
+            } else if (c == '$') {
+                cursor++;
+                if (cursor == length) {
+                    throw new IllegalArgumentException("Illegal group reference: group index is missing");
+                }
+                char next = replacement.charAt(cursor);
+                int group;
+                if (next == '{') {
+                    cursor++;
+                    int start = cursor;
+                    while (cursor < length) {
+                        char n = replacement.charAt(cursor);
+                        if (Pattern.asciiLetter(n) || n >= '0' && n <= '9') {
+                            cursor++;
+                        } else {
+                            break;
+                        }
+                    }
+                    if (cursor == start) {
+                        throw new IllegalArgumentException("named capturing group has 0 length name");
+                    }
+                    if (cursor == length || replacement.charAt(cursor) != '}') {
+                        throw new IllegalArgumentException("named capturing group is missing trailing '}'");
+                    }
+                    String name = replacement.substring(start, cursor);
+                    char lead = name.charAt(0);
+                    if (lead >= '0' && lead <= '9') {
+                        throw new IllegalArgumentException("capturing group name {" + name
+                                + "} starts with digit character");
+                    }
+                    Integer found = pattern.names.get(name);
+                    if (found == null) {
+                        throw new IllegalArgumentException("No group with name {" + name + "}");
+                    }
+                    group = found.intValue();
+                    cursor++;
+                } else {
+                    group = next - '0';
+                    if (group < 0 || group > 9) {
+                        throw new IllegalArgumentException("Illegal group reference");
+                    }
+                    cursor++;
+                    if (group > pattern.groupCount) {
+                        throw new IndexOutOfBoundsException("No group " + group);
+                    }
+                    while (cursor < length) {
+                        int digit = replacement.charAt(cursor) - '0';
+                        if (digit < 0 || digit > 9) {
+                            break;
+                        }
+                        int wider = group * 10 + digit;
+                        if (wider > pattern.groupCount) {
+                            break;
+                        }
+                        group = wider;
+                        cursor++;
+                    }
+                }
+                if (starts[group] >= 0 && ends[group] >= 0) {
+                    out.append(text.subSequence(starts[group], ends[group]).toString());
+                }
+            } else {
+                out.append(c);
+                cursor++;
+            }
+        }
+    }
+
+    public Matcher appendReplacement(StringBuilder sb, String replacement) {
+        requireMatch();
+        StringBuilder expanded = new StringBuilder();
+        expand(replacement, expanded);
+        sb.append(text.subSequence(appendPosition, first).toString());
+        sb.append(expanded.toString());
+        appendPosition = last;
+        return this;
+    }
+
+    public Matcher appendReplacement(StringBuffer sb, String replacement) {
+        requireMatch();
+        StringBuilder expanded = new StringBuilder();
+        expand(replacement, expanded);
+        sb.append(text.subSequence(appendPosition, first).toString());
+        sb.append(expanded.toString());
+        appendPosition = last;
+        return this;
+    }
+
+    public StringBuilder appendTail(StringBuilder sb) {
+        sb.append(text.subSequence(appendPosition, text.length()).toString());
+        return sb;
+    }
+
+    public StringBuffer appendTail(StringBuffer sb) {
+        sb.append(text.subSequence(appendPosition, text.length()).toString());
+        return sb;
+    }
+
+    public String replaceAll(String replacement) {
+        reset();
+        if (!find()) {
+            return text.toString();
+        }
+        StringBuilder sb = new StringBuilder();
+        do {
+            appendReplacement(sb, replacement);
+        } while (find());
+        return appendTail(sb).toString();
+    }
+
+    public String replaceAll(Function<MatchResult, String> replacer) {
+        if (replacer == null) {
+            throw new NullPointerException();
+        }
+        reset();
+        if (!find()) {
+            return text.toString();
+        }
+        StringBuilder sb = new StringBuilder();
+        do {
+            appendReplacement(sb, replacer.apply(this));
+        } while (find());
+        return appendTail(sb).toString();
+    }
+
+    public String replaceFirst(String replacement) {
+        if (replacement == null) {
+            throw new NullPointerException("replacement");
+        }
+        reset();
+        if (!find()) {
+            return text.toString();
+        }
+        StringBuilder sb = new StringBuilder();
+        appendReplacement(sb, replacement);
+        return appendTail(sb).toString();
+    }
+
+    public String replaceFirst(Function<MatchResult, String> replacer) {
+        if (replacer == null) {
+            throw new NullPointerException();
+        }
+        reset();
+        if (!find()) {
+            return text.toString();
+        }
+        StringBuilder sb = new StringBuilder();
+        appendReplacement(sb, replacer.apply(this));
+        return appendTail(sb).toString();
+    }
+
+    @Override
+    public String toString() {
+        return "java.util.regex.Matcher[pattern=" + pattern.pattern() + " region=" + from + "," + to
+                + " lastmatch=" + (first >= 0 ? group() : "") + "]";
+    }
+}
diff --git a/CodenameOne/src/com/codename1/util/regex/Pattern.java b/CodenameOne/src/com/codename1/util/regex/Pattern.java
new file mode 100644
index 00000000000..c6278cb896c
--- /dev/null
+++ b/CodenameOne/src/com/codename1/util/regex/Pattern.java
@@ -0,0 +1,1973 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.util.regex;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/// `java.util.regex.Pattern` for the Codename One runtime: a backtracking
+/// matcher written for this module, with the JDK's syntax and the JDK's
+/// answers for the constructs it has.
+///
+/// #### Supported
+///
+/// - Literals, `.`, and every escape for a character: `\t \n \r \f \a \e`,
+///   `\0nn`, `\xhh`, `\x{h...}`, backslash-u with four hex digits, `\cX`,
+///   and `\Q...\E`.
+/// - Character classes with ranges, negation, nested unions and `&&`
+///   intersections; `\d \D \w \W \s \S \h \H \v \V`; `\R`.
+/// - The POSIX classes (`\p{Alpha}`, `\p{Punct}`, ...), the `java...`
+///   classes, and the Unicode properties a device can answer: `L`, `Lu`,
+///   `Ll`, `N`/`Nd`, `IsAlphabetic`, `IsLetter`, `IsDigit`, `IsUppercase`,
+///   `IsLowercase`, `IsWhite_Space`.
+/// - Greedy, reluctant and possessive quantifiers.
+/// - Capturing, non-capturing and named groups, back references by number
+///   and by name, alternation, atomic groups.
+/// - Lookahead and bounded lookbehind, positive and negative.
+/// - `^ $ \A \z \Z \G \b \B`.
+/// - `CASE_INSENSITIVE`, `MULTILINE`, `DOTALL`, `COMMENTS`, `LITERAL`,
+///   `UNIX_LINES` and `UNICODE_CASE`, as arguments and inline (`(?i)`,
+///   `(?i:...)`, `(?-i)`).
+///
+/// #### Refused
+///
+/// These throw [PatternSyntaxException] (the flags an
+/// `UnsupportedOperationException`) naming the construct, when the pattern
+/// is compiled. Nothing is accepted and then matched differently.
+///
+/// - Unicode scripts, blocks and general categories other than the ones
+///   above (`\p{IsGreek}`, `\p{InArrows}`, `\p{Sc}`, ...).
+/// - `\X`, `\N{name}`, `\b{g}`.
+/// - `CANON_EQ` and `UNICODE_CHARACTER_CLASS` (`(?U)`).
+/// - A code point above U+FFFF inside a character class.
+///
+/// #### Differences
+///
+/// Text is matched one UTF-16 `char` at a time: `.` and a character class
+/// take half of a surrogate pair. Which characters are letters is what
+/// `isLetter` in this class answers, the scripts a device font is likely
+/// to have rather than all of Unicode. A group repeated many thousand times
+/// over a long text recurses once for each repetition, as the JDK's does,
+/// on a stack that is smaller on a device.
+public final class Pattern {
+
+    public static final int UNIX_LINES = 0x01;
+    public static final int CASE_INSENSITIVE = 0x02;
+    public static final int COMMENTS = 0x04;
+    public static final int MULTILINE = 0x08;
+    public static final int LITERAL = 0x10;
+    public static final int DOTALL = 0x20;
+    public static final int UNICODE_CASE = 0x40;
+    public static final int CANON_EQ = 0x80;
+    public static final int UNICODE_CHARACTER_CLASS = 0x100;
+
+    private static final int ALL_FLAGS = UNIX_LINES | CASE_INSENSITIVE | COMMENTS | MULTILINE | LITERAL
+            | DOTALL | UNICODE_CASE | CANON_EQ | UNICODE_CHARACTER_CLASS;
+
+    private final String regex;
+    private final int flags;
+    final Node root;
+    final int groupCount;
+    final int loopCount;
+    final Map<String, Integer> names;
+
+    private Pattern(String regex, int flags) {
+        if (regex == null) {
+            throw new NullPointerException();
+        }
+        // As in the JDK: a bit no flag constant names is a caller's mistake,
+        // not something to ignore.
+        if ((flags & ~ALL_FLAGS) != 0) {
+            throw new IllegalArgumentException("Unknown flag 0x" + Integer.toHexString(flags & ~ALL_FLAGS));
+        }
+        if ((flags & CANON_EQ) != 0) {
+            throw new UnsupportedOperationException("Pattern.CANON_EQ is not supported by the Codename One runtime");
+        }
+        if ((flags & UNICODE_CHARACTER_CLASS) != 0) {
+            throw new UnsupportedOperationException(
+                    "Pattern.UNICODE_CHARACTER_CLASS is not supported by the Codename One runtime");
+        }
+        this.regex = regex;
+        Parser parser = new Parser(regex, flags);
+        this.root = parser.compile();
+        // As in the JDK, flags() reports the top-level state the parse ended
+        // in: (?i) outside every group counts, (?i) inside one does not.
+        this.flags = parser.topLevelFlags();
+        this.groupCount = parser.groups;
+        this.loopCount = parser.loops;
+        this.names = parser.names;
+    }
+
+    public static Pattern compile(String regex) {
+        return new Pattern(regex, 0);
+    }
+
+    public static Pattern compile(String regex, int flags) {
+        return new Pattern(regex, flags);
+    }
+
+    public String pattern() {
+        return regex;
+    }
+
+    @Override
+    public String toString() {
+        return regex;
+    }
+
+    public int flags() {
+        return flags;
+    }
+
+    public Matcher matcher(CharSequence input) {
+        return new Matcher(this, input);
+    }
+
+    public static boolean matches(String regex, CharSequence input) {
+        return compile(regex).matcher(input).matches();
+    }
+
+    public String[] split(CharSequence input) {
+        return split(input, 0);
+    }
+
+    /// Splits `input` around the matches of this pattern, by the JDK's
+    /// rules for `limit`.
+    public String[] split(CharSequence input, int limit) {
+        int index = 0;
+        boolean limited = limit > 0;
+        List<String> list = new ArrayList<String>();
+        Matcher m = matcher(input);
+        while (m.find()) {
+            if (!limited || list.size() < limit - 1) {
+                if (index == 0 && m.start() == 0 && m.end() == 0) {
+                    // No empty leading piece for a zero-width match at the start.
+                    continue;
+                }
+                list.add(input.subSequence(index, m.start()).toString());
+                index = m.end();
+            } else if (list.size() == limit - 1) {
+                list.add(input.subSequence(index, input.length()).toString());
+                index = m.end();
+            }
+        }
+        if (index == 0) {
+            return new String[] {input.toString()};
+        }
+        if (!limited || list.size() < limit) {
+            list.add(input.subSequence(index, input.length()).toString());
+        }
+        int size = list.size();
+        if (limit == 0) {
+            while (size > 0 && list.get(size - 1).length() == 0) {
+                size--;
+            }
+        }
+        String[] out = new String[size];
+        for (int i = 0; i < size; i++) {
+            out[i] = list.get(i);
+        }
+        return out;
+    }
+
+    /// The pieces [#split(CharSequence)] would answer, found one at a time
+    /// as the stream asks for them, as the JDK's are: the search starts on
+    /// the first request, so a `limit` stops it and a change to a mutable
+    /// input before then is seen.
+    public Stream<String> splitAsStream(final CharSequence input) {
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Pieces(this, input),
+                Spliterator.ORDERED | Spliterator.NONNULL), false);
+    }
+
+    /// The pieces of one [#splitAsStream(CharSequence)]. Empty pieces are
+    /// held back until a non-empty one follows them, because trailing ones
+    /// are dropped, as `split` drops them.
+    private static final class Pieces implements Iterator<String> {
+        private final Pattern pattern;
+        private final CharSequence input;
+        private Matcher matcher;
+        private int current;
+        private String pending;
+        private int empties;
+        private String next;
+
+        Pieces(Pattern pattern, CharSequence input) {
+            this.pattern = pattern;
+            this.input = input;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (next == null) {
+                next = advance();
+            }
+            return next != null;
+        }
+
+        @Override
+        public String next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            String out = next;
+            next = null;
+            return out;
+        }
+
+        private String advance() {
+            if (matcher == null) {
+                matcher = pattern.matcher(input);
+                // An empty input is one empty piece, as split answers.
+                if (input.length() == 0) {
+                    empties = 1;
+                }
+            }
+            while (true) {
+                if (empties > 0) {
+                    empties--;
+                    return "";
+                }
+                if (pending != null) {
+                    String out = pending;
+                    pending = null;
+                    return out;
+                }
+                if (current == input.length()) {
+                    return null;
+                }
+                while (pending == null && matcher.find()) {
+                    String piece = input.subSequence(current, matcher.start()).toString();
+                    current = matcher.end();
+                    if (piece.length() > 0) {
+                        pending = piece;
+                    } else if (current > 0) {
+                        // No empty leading piece for a zero-width match at the start.
+                        empties++;
+                    }
+                }
+                if (pending == null) {
+                    String last = input.subSequence(current, input.length()).toString();
+                    current = input.length();
+                    if (last.length() == 0) {
+                        // Only trailing empty pieces were owed: dropped.
+                        empties = 0;
+                        return null;
+                    }
+                    pending = last;
+                }
+            }
+        }
+    }
+
+    /// A pattern that matches `s` and nothing else.
+    public static String quote(String s) {
+        int slashE = s.indexOf("\\E");
+        if (slashE < 0) {
+            return "\\Q" + s + "\\E";
+        }
+        StringBuilder sb = new StringBuilder(s.length() * 2);
+        sb.append("\\Q");
+        int current = 0;
+        while (slashE >= 0) {
+            sb.append(s.substring(current, slashE));
+            current = slashE + 2;
+            sb.append("\\E\\\\E\\Q");
+            slashE = s.indexOf("\\E", current);
+        }
+        sb.append(s.substring(current));
+        sb.append("\\E");
+        return sb.toString();
+    }
+
+    public Predicate<String> asPredicate() {
+        return new Predicate<String>() {
+            @Override
+            public boolean test(String s) {
+                return matcher(s).find();
+            }
+        };
+    }
+
+    public Predicate<String> asMatchPredicate() {
+        return new Predicate<String>() {
+            @Override
+            public boolean test(String s) {
+                return matcher(s).matches();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------------
+    // Characters
+    // ------------------------------------------------------------------
+
+    static boolean lineTerminator(char c, boolean unix) {
+        if (c == '\n') {
+            return true;
+        }
+        return !unix && (c == '\r' || c == 0x85 || c == 0x2028 || c == 0x2029);
+    }
+
+    static boolean asciiLetter(char c) {
+        return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z';
+    }
+
+    /// A word character for `\b` and `\B`: the ASCII `[a-zA-Z0-9_]` that
+    /// `\w` matches. The JDK has defined the boundary this way since 19
+    /// (JDK-8264160); before, it took any Unicode letter or digit, so `\b`
+    /// fell inside a word `\w+` could not match. The Unicode reading comes
+    /// only with `UNICODE_CHARACTER_CLASS`, which this runtime refuses.
+    static boolean wordChar(char c) {
+        return c == '_' || asciiLetter(c) || c >= '0' && c <= '9';
+    }
+
+    static boolean isLetterOrDigit(char c) {
+        return isLetter(c) || Character.isDigit(c);
+    }
+
+    /// Whether `c` is a letter: the scripts a device font is likely to
+    /// have rather than all of Unicode. Written out here because
+    /// `Character.isLetter` is not available on every device runtime.
+    static boolean isLetter(char c) {
+        if (c < 0x80) {
+            return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z';
+        }
+        if (c < 0x100) {
+            return c == 0xaa || c == 0xb5 || c == 0xba || c >= 0xc0 && c != 0xd7 && c != 0xf7;
+        }
+        return c <= 0x24f // Latin Extended
+                || c >= 0x370 && c <= 0x3ff && c != 0x37e && c != 0x387 // Greek
+                || c >= 0x400 && c <= 0x481 || c >= 0x48a && c <= 0x52f // Cyrillic
+                || c >= 0x531 && c <= 0x556 || c >= 0x561 && c <= 0x587 // Armenian
+                || c >= 0x5d0 && c <= 0x5ea // Hebrew
+                || c >= 0x620 && c <= 0x64a || c >= 0x671 && c <= 0x6d3 // Arabic
+                || c >= 0x904 && c <= 0x939 // Devanagari
+                || c >= 0xe01 && c <= 0xe30 // Thai
+                || c >= 0x10a0 && c <= 0x10ff && c != 0x10fb // Georgian
+                || c >= 0x1e00 && c <= 0x1fff // Latin and Greek Extended Additional
+                || c >= 0x3041 && c <= 0x3096 || c >= 0x30a1 && c <= 0x30fa // Kana
+                || c >= 0x3400 && c <= 0x4dbf || c >= 0x4e00 && c <= 0x9fff // CJK
+                || c >= 0xac00 && c <= 0xd7a3; // Hangul
+    }
+
+    /// Whether `a` and `b` are the same character when case is ignored:
+    /// for ASCII letters only, or by the device's case tables.
+    static boolean sameIgnoringCase(char a, char b, boolean unicode) {
+        if (a == b) {
+            return true;
+        }
+        if (a < 0x80 && b < 0x80) {
+            return asciiLetter(a) && (a ^ 0x20) == b;
+        }
+        if (!unicode) {
+            return false;
+        }
+        char ua = Character.toUpperCase(a);
+        char ub = Character.toUpperCase(b);
+        return ua == ub || Character.toLowerCase(ua) == Character.toLowerCase(ub);
+    }
+
+    // ------------------------------------------------------------------
+    // The compiled form: a chain of nodes, each matching at a position and
+    // then asking the next one to match the rest.
+    // ------------------------------------------------------------------
+
+    abstract static class Node {
+        Node next;
+
+        abstract boolean match(Matcher m, int i);
+    }
+
+    /// The end of the whole pattern.
+    static final class Accept extends Node {
+        @Override
+        boolean match(Matcher m, int i) {
+            if (m.requireEnd && i != m.to) {
+                return false;
+            }
+            m.matchEnd = i;
+            return true;
+        }
+    }
+
+    /// The end of a pattern inside another: an atomic group or a lookaround.
+    static final class SubEnd extends Node {
+        @Override
+        boolean match(Matcher m, int i) {
+            if (m.endAt >= 0 && i != m.endAt) {
+                return false;
+            }
+            m.subEnd = i;
+            return true;
+        }
+    }
+
+    static final class Pass extends Node {
+        @Override
+        boolean match(Matcher m, int i) {
+            return next.match(m, i);
+        }
+    }
+
+    /// A node that takes exactly one character.
+    abstract static class Single extends Node {
+        abstract boolean is(char c);
+
+        @Override
+        boolean match(Matcher m, int i) {
+            return i < m.to && is(m.text.charAt(i)) && next.match(m, i + 1);
+        }
+    }
+
+    static final class Char extends Single {
+        final char c;
+
+        Char(char c) {
+            this.c = c;
+        }
+
+        @Override
+        boolean is(char ch) {
+            return ch == c;
+        }
+    }
+
+    static final class CharIgnoringCase extends Single {
+        final char c;
+        final boolean unicode;
+
+        CharIgnoringCase(char c, boolean unicode) {
+            this.c = c;
+            this.unicode = unicode;
+        }
+
+        @Override
+        boolean is(char ch) {
+            return sameIgnoringCase(ch, c, unicode);
+        }
+    }
+
+    static final class Any extends Single {
+        final boolean all;
+        final boolean unix;
+
+        Any(boolean all, boolean unix) {
+            this.all = all;
+            this.unix = unix;
+        }
+
+        @Override
+        boolean is(char c) {
+            return all || !lineTerminator(c, unix);
+        }
+    }
+
+    static final class InClass extends Single {
+        final CharSet set;
+
+        InClass(CharSet set) {
+            this.set = set;
+        }
+
+        @Override
+        boolean is(char c) {
+            return set.has(c);
+        }
+    }
+
+    /// A set of characters: ranges, the predicates a device answers, other
+    /// sets united with it, and one it is intersected with.
+    static final class CharSet {
+        static final int LETTER = 1;
+        static final int UPPER = 2;
+        static final int LOWER = 4;
+        static final int DIGIT = 8;
+        static final int WHITESPACE = 16;
+        static final int LETTER_OR_DIGIT = 32;
+        static final int TITLE = 64;
+
+        private char[] ranges = new char[8];
+        private int count;
+        private int kinds;
+        private final List<CharSet> united = new ArrayList<CharSet>();
+        CharSet and;
+        boolean negate;
+        /// 0 for exact, 1 to ignore the case of ASCII letters, 2 of any.
+        final int ignoreCase;
+
+        CharSet(int ignoreCase) {
+            this.ignoreCase = ignoreCase;
+        }
+
+        CharSet add(int lo, int hi) {
+            if (count + 2 > ranges.length) {
+                char[] grown = new char[ranges.length * 2];
+                System.arraycopy(ranges, 0, grown, 0, count);
+                ranges = grown;
+            }
+            ranges[count++] = (char) lo;
+            ranges[count++] = (char) hi;
+            return this;
+        }
+
+        CharSet add(int c) {
+            return add(c, c);
+        }
+
+        CharSet kind(int kind) {
+            kinds |= kind;
+            return this;
+        }
+
+        CharSet unite(CharSet other) {
+            united.add(other);
+            return this;
+        }
+
+        CharSet not() {
+            CharSet out = new CharSet(0);
+            out.united.add(this);
+            out.negate = true;
+            return out;
+        }
+
+        boolean isEmpty() {
+            return count == 0 && kinds == 0 && united.isEmpty();
+        }
+
+        private boolean inRanges(char c) {
+            for (int k = 0; k < count; k += 2) {
+                if (c >= ranges[k] && c <= ranges[k + 1]) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private boolean inKinds(char c) {
+            if (kinds == 0) {
+                return false;
+            }
+            return (kinds & LETTER) != 0 && isLetter(c)
+                    || (kinds & UPPER) != 0 && Character.isUpperCase(c)
+                    || (kinds & LOWER) != 0 && Character.isLowerCase(c)
+                    || (kinds & DIGIT) != 0 && Character.isDigit(c)
+                    || (kinds & WHITESPACE) != 0 && Character.isWhitespace(c)
+                    || (kinds & LETTER_OR_DIGIT) != 0 && isLetterOrDigit(c)
+                    || (kinds & TITLE) != 0 && Character.isTitleCase(c);
+        }
+
+        boolean has(char c) {
+            boolean in = inRanges(c) || inKinds(c);
+            if (!in && ignoreCase != 0 && count > 0) {
+                if (c < 0x80) {
+                    in = asciiLetter(c) && inRanges((char) (c ^ 0x20));
+                } else if (ignoreCase == 2) {
+                    in = inRanges(Character.toUpperCase(c)) || inRanges(Character.toLowerCase(c));
+                }
+            }
+            for (int k = 0; !in && k < united.size(); k++) {
+                in = united.get(k).has(c);
+            }
+            if (in && and != null) {
+                in = and.has(c);
+            }
+            return in != negate;
+        }
+    }
+
+    /// One character, repeated. Counted in a loop rather than by recursion,
+    /// so `.*` over a long text costs no stack.
+    static final class SingleLoop extends Node {
+        final Single atom;
+        final int min;
+        final int max;
+        final int mode;
+
+        SingleLoop(Single atom, int min, int max, int mode) {
+            this.atom = atom;
+            this.min = min;
+            this.max = max < 0 ? Integer.MAX_VALUE : max;
+            this.mode = mode;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            CharSequence text = m.text;
+            int to = m.to;
+            int n = 0;
+            int j = i;
+            if (mode == Parser.RELUCTANT) {
+                while (n < min) {
+                    if (j >= to || !atom.is(text.charAt(j))) {
+                        return false;
+                    }
+                    j++;
+                    n++;
+                }
+                while (true) {
+                    if (next.match(m, j)) {
+                        return true;
+                    }
+                    if (n >= max || j >= to || !atom.is(text.charAt(j))) {
+                        return false;
+                    }
+                    j++;
+                    n++;
+                }
+            }
+            while (n < max && j < to && atom.is(text.charAt(j))) {
+                j++;
+                n++;
+            }
+            if (n < min) {
+                return false;
+            }
+            if (mode == Parser.POSSESSIVE) {
+                return next.match(m, j);
+            }
+            while (true) {
+                if (next.match(m, j)) {
+                    return true;
+                }
+                if (n == min) {
+                    return false;
+                }
+                n--;
+                j--;
+            }
+        }
+    }
+
+    /// Anything else, repeated. The body ends in a [LoopTail] that comes
+    /// back here to decide between another round and the rest.
+    static final class Loop extends Node {
+        Node body;
+        final int id;
+        final int min;
+        final int max;
+        final boolean reluctant;
+
+        Loop(int id, int min, int max, boolean reluctant) {
+            this.id = id;
+            this.min = min;
+            this.max = max < 0 ? Integer.MAX_VALUE : max;
+            this.reluctant = reluctant;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            int count = m.loopCount[id];
+            int position = m.loopStart[id];
+            m.loopCount[id] = 0;
+            m.loopStart[id] = -1;
+            boolean matched = step(m, i);
+            m.loopCount[id] = count;
+            m.loopStart[id] = position;
+            return matched;
+        }
+
+        boolean step(Matcher m, int i) {
+            int count = m.loopCount[id];
+            if (count < min) {
+                return round(m, i, count);
+            }
+            if (reluctant) {
+                return next.match(m, i) || count < max && round(m, i, count);
+            }
+            return count < max && round(m, i, count) || next.match(m, i);
+        }
+
+        private boolean round(Matcher m, int i, int count) {
+            int position = m.loopStart[id];
+            if (count >= min && i == position) {
+                // The round before this one took nothing; another would
+                // take nothing for ever.
+                return false;
+            }
+            m.loopCount[id] = count + 1;
+            m.loopStart[id] = i;
+            boolean matched = body.match(m, i);
+            m.loopCount[id] = count;
+            m.loopStart[id] = position;
+            return matched;
+        }
+    }
+
+    static final class LoopTail extends Node {
+        final Loop loop;
+
+        LoopTail(Loop loop) {
+            this.loop = loop;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            return loop.step(m, i);
+        }
+    }
+
+    static final class Branch extends Node {
+        final Node[] alternatives;
+
+        Branch(Node[] alternatives) {
+            this.alternatives = alternatives;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            for (Node alternative : alternatives) {
+                if (alternative.match(m, i)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    static final class GroupOpen extends Node {
+        final int group;
+
+        GroupOpen(int group) {
+            this.group = group;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            int saved = m.opened[group];
+            m.opened[group] = i;
+            if (next.match(m, i)) {
+                return true;
+            }
+            m.opened[group] = saved;
+            return false;
+        }
+    }
+
+    static final class GroupClose extends Node {
+        final int group;
+
+        GroupClose(int group) {
+            this.group = group;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            int start = m.starts[group];
+            int end = m.ends[group];
+            m.starts[group] = m.opened[group];
+            m.ends[group] = i;
+            if (next.match(m, i)) {
+                return true;
+            }
+            m.starts[group] = start;
+            m.ends[group] = end;
+            return false;
+        }
+    }
+
+    static final class BackReference extends Node {
+        final int group;
+        final boolean ignoreCase;
+        final boolean unicode;
+
+        BackReference(int group, boolean ignoreCase, boolean unicode) {
+            this.group = group;
+            this.ignoreCase = ignoreCase;
+            this.unicode = unicode;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            if (group >= m.starts.length) {
+                // A reference to a group the pattern never defines.
+                return false;
+            }
+            int start = m.starts[group];
+            int end = m.ends[group];
+            if (start < 0) {
+                return false;
+            }
+            int length = end - start;
+            if (i + length > m.to) {
+                return false;
+            }
+            for (int k = 0; k < length; k++) {
+                char a = m.text.charAt(start + k);
+                char b = m.text.charAt(i + k);
+                if (a != b && !(ignoreCase && sameIgnoringCase(a, b, unicode))) {
+                    return false;
+                }
+            }
+            return next.match(m, i + length);
+        }
+    }
+
+    static final class Anchor extends Node {
+        static final int BEGIN = 0;
+        static final int LINE_START = 1;
+        static final int LINE_END = 2;
+        static final int END_OR_FINAL_TERMINATOR = 3;
+        static final int END = 4;
+        static final int LAST_MATCH = 5;
+        static final int WORD = 6;
+        static final int NOT_WORD = 7;
+
+        final int kind;
+        final boolean unix;
+
+        Anchor(int kind, boolean unix) {
+            this.kind = kind;
+            this.unix = unix;
+        }
+
+        private boolean lineEnd(Matcher m, int i, boolean multiline) {
+            CharSequence text = m.text;
+            int end = m.to;
+            if (unix) {
+                if (i < end) {
+                    if (text.charAt(i) != '\n') {
+                        return false;
+                    }
+                    return multiline || i == end - 1;
+                }
+                return true;
+            }
+            if (!multiline) {
+                if (i < end - 2) {
+                    return false;
+                }
+                if (i == end - 2 && (text.charAt(i) != '\r' || text.charAt(i + 1) != '\n')) {
+                    return false;
+                }
+            }
+            if (i < end) {
+                char c = text.charAt(i);
+                if (c == '\n') {
+                    // Never between the two characters of one line end.
+                    return !(i > 0 && text.charAt(i - 1) == '\r');
+                }
+                return c == '\r' || c == 0x85 || c == 0x2028 || c == 0x2029;
+            }
+            return true;
+        }
+
+        private boolean lineStart(Matcher m, int i) {
+            if (i == m.to) {
+                // Not at the end of the input, even after a line end.
+                return false;
+            }
+            if (i > m.from) {
+                char c = m.text.charAt(i - 1);
+                if (!lineTerminator(c, unix)) {
+                    return false;
+                }
+                if (c == '\r' && m.text.charAt(i) == '\n') {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            boolean here;
+            switch (kind) {
+                case BEGIN:
+                    here = i == m.from;
+                    break;
+                case LINE_START:
+                    here = lineStart(m, i);
+                    break;
+                case LINE_END:
+                    here = lineEnd(m, i, true);
+                    break;
+                case END_OR_FINAL_TERMINATOR:
+                    here = lineEnd(m, i, false);
+                    break;
+                case END:
+                    here = i == m.to;
+                    break;
+                case LAST_MATCH:
+                    here = i == m.oldLast;
+                    break;
+                default:
+                    boolean left = i > m.from && wordChar(m.text.charAt(i - 1));
+                    boolean right = i < m.to && wordChar(m.text.charAt(i));
+                    here = (left != right) == (kind == WORD);
+                    break;
+            }
+            return here && next.match(m, i);
+        }
+    }
+
+    /// `(?>X)`: what `X` took first is kept, whatever follows.
+    static final class Atomic extends Node {
+        final Node body;
+
+        Atomic(Node body) {
+            this.body = body;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            int[] groups = m.saveGroups();
+            int endAt = m.endAt;
+            m.endAt = -1;
+            boolean matched = body.match(m, i);
+            m.endAt = endAt;
+            if (!matched) {
+                return false;
+            }
+            if (next.match(m, m.subEnd)) {
+                return true;
+            }
+            m.restoreGroups(groups);
+            return false;
+        }
+    }
+
+    static final class Look extends Node {
+        final Node body;
+        final boolean behind;
+        final boolean negative;
+        final int min;
+        final int max;
+
+        Look(Node body, boolean behind, boolean negative, int min, int max) {
+            this.body = body;
+            this.behind = behind;
+            this.negative = negative;
+            this.min = min;
+            this.max = max;
+        }
+
+        @Override
+        boolean match(Matcher m, int i) {
+            int[] groups = m.saveGroups();
+            int endAt = m.endAt;
+            boolean found = false;
+            if (behind) {
+                int lowest = Math.max(m.from, i - max);
+                for (int j = i - min; !found && j >= lowest; j--) {
+                    m.endAt = i;
+                    found = body.match(m, j);
+                }
+            } else {
+                m.endAt = -1;
+                found = body.match(m, i);
+            }
+            m.endAt = endAt;
+            if (found == negative) {
+                if (found) {
+                    m.restoreGroups(groups);
+                }
+                return false;
+            }
+            if (negative) {
+                m.restoreGroups(groups);
+            }
+            if (next.match(m, i)) {
+                return true;
+            }
+            m.restoreGroups(groups);
+            return false;
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // The parser
+    // ------------------------------------------------------------------
+
+    /// A piece of the chain being built: where it starts, the node whose
+    /// `next` is still open, and how many characters it can take.
+    private static final class Piece {
+        Node first;
+        Node last;
+        int min;
+        /// -1 for no upper bound.
+        int max;
+        /// Whether there is one way only for this to match at a position.
+        boolean deterministic = true;
+
+        Piece(Node first, Node last, int min, int max) {
+            this.first = first;
+            this.last = last;
+            this.min = min;
+            this.max = max;
+        }
+
+        static Piece of(Node node, int length) {
+            return new Piece(node, node, length, length);
+        }
+
+        static Piece empty() {
+            return of(new Pass(), 0);
+        }
+
+        Piece unbounded() {
+            max = -1;
+            return this;
+        }
+
+        void then(Piece other) {
+            last.next = other.first;
+            last = other.last;
+            deterministic &= other.deterministic;
+            min = sum(min, other.min);
+            max = max < 0 || other.max < 0 ? -1 : sum(max, other.max);
+        }
+
+        private static int sum(int a, int b) {
+            long s = (long) a + b;
+            return s > 1000000000L ? 1000000000 : (int) s;
+        }
+    }
+
+    /// Pieces put one after another.
+    private static final class Seq {
+        private Piece all;
+
+        void then(Piece next) {
+            if (all == null) {
+                all = next;
+            } else {
+                all.then(next);
+            }
+        }
+
+        Piece piece() {
+            return all == null ? Piece.empty() : all;
+        }
+    }
+
+    private static final class Parser {
+        static final int GREEDY = 0;
+        static final int RELUCTANT = 1;
+        static final int POSSESSIVE = 2;
+
+        private final String p;
+        private int at;
+        private int flags;
+        int groups;
+        int loops;
+        final Map<String, Integer> names = new HashMap<String, Integer>();
+
+        Parser(String pattern, int flags) {
+            this.p = pattern;
+            this.flags = flags;
+        }
+
+        private PatternSyntaxException error(String description) {
+            return new PatternSyntaxException(description, p, Math.min(at, p.length()));
+        }
+
+        private PatternSyntaxException unsupported(String construct) {
+            return error(construct + " is not supported by the Codename One runtime");
+        }
+
+        private boolean has(int flag) {
+            return (flags & flag) != 0;
+        }
+
+        /// The flags in force after the whole pattern, which a group's own
+        /// inline flags never reach because the group restores them.
+        int topLevelFlags() {
+            return flags;
+        }
+
+        Node compile() {
+            Piece whole;
+            if (has(LITERAL)) {
+                Seq all = new Seq();
+                for (at = 0; at < p.length(); at++) {
+                    all.then(literal(p.charAt(at)));
+                }
+                whole = all.piece();
+            } else {
+                whole = alternatives();
+                if (at < p.length()) {
+                    throw error("Unmatched closing ')'");
+                }
+            }
+            whole.last.next = new Accept();
+            return whole.first;
+        }
+
+        private Piece literal(int c) {
+            if (c > 0xffff) {
+                // Two chars in the text, so two nodes here.
+                int v = c - 0x10000;
+                Piece pair = Piece.of(new Char((char) (0xd800 + (v >> 10))), 1);
+                pair.then(Piece.of(new Char((char) (0xdc00 + (v & 0x3ff))), 1));
+                return pair;
+            }
+            char ch = (char) c;
+            if (has(CASE_INSENSITIVE)) {
+                boolean unicode = has(UNICODE_CASE);
+                boolean cased = ch < 0x80 ? asciiLetter(ch)
+                        : unicode && (Character.toUpperCase(ch) != ch || Character.toLowerCase(ch) != ch);
+                if (cased) {
+                    return Piece.of(new CharIgnoringCase(ch, unicode), 1);
+                }
+            }
+            return Piece.of(new Char(ch), 1);
+        }
+
+        private CharSet newSet() {
+            return new CharSet(has(CASE_INSENSITIVE) ? has(UNICODE_CASE) ? 2 : 1 : 0);
+        }
+
+        private void skipComments() {
+            if (!has(COMMENTS)) {
+                return;
+            }
+            while (at < p.length()) {
+                char c = p.charAt(at);
+                if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == 0x0b) {
+                    at++;
+                } else if (c == '#') {
+                    while (at < p.length() && !lineTerminator(p.charAt(at), false)) {
+                        at++;
+                    }
+                } else {
+                    return;
+                }
+            }
+        }
+
+        /// `X|Y|Z`, up to a closing parenthesis or the end.
+        private Piece alternatives() {
+            List<Piece> all = new ArrayList<Piece>();
+            all.add(sequence());
+            while (at < p.length() && p.charAt(at) == '|') {
+                at++;
+                all.add(sequence());
+            }
+            if (all.size() == 1) {
+                return all.get(0);
+            }
+            // Alternatives of one character each are one character class,
+            // which repeats without recursion.
+            CharSet merged = new CharSet(0);
+            boolean mergeable = true;
+            for (Piece piece : all) {
+                Node n = piece.first;
+                if (piece.first != piece.last) { //NOPMD CompareObjectsWithEquals - one node, by identity
+                    mergeable = false;
+                } else if (n instanceof Char) {
+                    merged.add(((Char) n).c);
+                } else if (n instanceof InClass) {
+                    merged.unite(((InClass) n).set);
+                } else {
+                    mergeable = false;
+                }
+            }
+            if (mergeable) {
+                return Piece.of(new InClass(merged), 1);
+            }
+            Node[] heads = new Node[all.size()];
+            Pass join = new Pass();
+            int min = Integer.MAX_VALUE;
+            int max = 0;
+            for (int k = 0; k < heads.length; k++) {
+                Piece piece = all.get(k);
+                heads[k] = piece.first;
+                piece.last.next = join;
+                min = Math.min(min, piece.min);
+                max = max < 0 || piece.max < 0 ? -1 : Math.max(max, piece.max);
+            }
+            Piece branch = new Piece(new Branch(heads), join, min, max);
+            branch.deterministic = false;
+            return branch;
+        }
+
+        private Piece sequence() {
+            Seq out = new Seq();
+            while (true) {
+                skipComments();
+                if (at >= p.length()) {
+                    return out.piece();
+                }
+                char c = p.charAt(at);
+                if (c == '|' || c == ')') {
+                    return out.piece();
+                }
+                if (c == '\\' && at + 1 < p.length() && p.charAt(at + 1) == 'Q') {
+                    at += 2;
+                    int end = p.indexOf("\\E", at);
+                    if (end < 0) {
+                        end = p.length();
+                    }
+                    // A quantifier after the quotation applies to its last
+                    // character, so that one goes through the usual path.
+                    for (; at < end - 1; at++) {
+                        out.then(literal(p.charAt(at)));
+                    }
+                    if (at < end) {
+                        Piece last = literal(p.charAt(at));
+                        at = Math.min(end + 2, p.length());
+                        out.then(quantified(last));
+                    } else {
+                        at = Math.min(end + 2, p.length());
+                    }
+                    continue;
+                }
+                if (c == '\\' && at + 1 < p.length() && p.charAt(at + 1) == 'E') {
+                    at += 2;
+                    continue;
+                }
+                out.then(quantified(atom()));
+            }
+        }
+
+        private Piece atom() {
+            char c = p.charAt(at);
+            switch (c) {
+                case '(':
+                    return group();
+                case '[':
+                    at++;
+                    return Piece.of(new InClass(characterClass()), 1);
+                case '.':
+                    at++;
+                    return Piece.of(new Any(has(DOTALL), has(UNIX_LINES)), 1);
+                case '^':
+                    at++;
+                    return Piece.of(new Anchor(has(MULTILINE) ? Anchor.LINE_START : Anchor.BEGIN, has(UNIX_LINES)), 0);
+                case '$':
+                    at++;
+                    return Piece.of(new Anchor(has(MULTILINE) ? Anchor.LINE_END : Anchor.END_OR_FINAL_TERMINATOR,
+                            has(UNIX_LINES)), 0);
+                case '\\':
+                    at++;
+                    return escape();
+                case '*':
+                case '+':
+                case '?':
+                    throw error("Dangling meta character '" + c + "'");
+                case '{':
+                    throw error("Illegal repetition");
+                default:
+                    at++;
+                    if (c >= 0xd800 && c <= 0xdbff && at < p.length() && p.charAt(at) >= 0xdc00
+                            && p.charAt(at) <= 0xdfff) {
+                        // A code point written out is one atom, so a
+                        // quantifier after it repeats both halves.
+                        Piece pair = Piece.of(new Char(c), 1);
+                        pair.then(Piece.of(new Char(p.charAt(at++)), 1));
+                        return pair;
+                    }
+                    return literal(c);
+            }
+        }
+
+        private Piece quantified(Piece piece) {
+            skipComments();
+            if (at >= p.length()) {
+                return piece;
+            }
+            int min;
+            int max;
+            char c = p.charAt(at);
+            if (c == '*') {
+                min = 0;
+                max = -1;
+                at++;
+            } else if (c == '+') {
+                min = 1;
+                max = -1;
+                at++;
+            } else if (c == '?') {
+                min = 0;
+                max = 1;
+                at++;
+            } else if (c == '{') {
+                at++;
+                int start = at;
+                min = number();
+                if (at == start) {
+                    throw error("Illegal repetition");
+                }
+                max = min;
+                if (at < p.length() && p.charAt(at) == ',') {
+                    at++;
+                    if (at < p.length() && p.charAt(at) == '}') {
+                        max = -1;
+                    } else {
+                        int from = at;
+                        max = number();
+                        if (at == from) {
+                            throw error("Illegal repetition");
+                        }
+                        if (max < min) {
+                            throw error("Illegal repetition range");
+                        }
+                    }
+                }
+                if (at >= p.length() || p.charAt(at) != '}') {
+                    throw error("Unclosed counted closure");
+                }
+                at++;
+            } else {
+                return piece;
+            }
+            int mode = GREEDY;
+            if (at < p.length() && p.charAt(at) == '?') {
+                mode = RELUCTANT;
+                at++;
+            } else if (at < p.length() && p.charAt(at) == '+') {
+                mode = POSSESSIVE;
+                at++;
+            }
+            int lowest = (int) Math.min(1000000000L, (long) piece.min * min);
+            int highest = max < 0 || piece.max < 0 ? -1 : (int) Math.min(1000000000L, (long) piece.max * max);
+            if (max == 0) {
+                highest = 0;
+            }
+            Piece out;
+            if (min == 0 && piece.max == 0 && piece.deterministic && piece.first instanceof GroupOpen) {
+                // A group that can only be empty, repeated from zero times:
+                // the JDK takes no round of it, so the group stays unset.
+                out = Piece.empty();
+            } else if (piece.first == piece.last && piece.first instanceof Single) { //NOPMD CompareObjectsWithEquals
+                out = new Piece(null, null, lowest, highest);
+                out.first = new SingleLoop((Single) piece.first, min, max, mode);
+                out.last = out.first;
+            } else {
+                Loop loop = new Loop(loops++, min, max, mode == RELUCTANT);
+                loop.body = piece.first;
+                piece.last.next = new LoopTail(loop);
+                if (mode == POSSESSIVE) {
+                    loop.next = new SubEnd();
+                    Node atomic = new Atomic(loop);
+                    out = new Piece(atomic, atomic, lowest, highest);
+                } else {
+                    out = new Piece(loop, loop, lowest, highest);
+                }
+            }
+            out.deterministic = piece.deterministic && min == max;
+            skipComments();
+            if (at < p.length()) {
+                char after = p.charAt(at);
+                if (after == '*' || after == '+' || after == '?') {
+                    throw error("Dangling meta character '" + after + "'");
+                }
+                if (after == '{') {
+                    return quantified(out);
+                }
+            }
+            return out;
+        }
+
+        private int number() {
+            long n = 0;
+            while (at < p.length() && p.charAt(at) >= '0' && p.charAt(at) <= '9') {
+                n = n * 10 + (p.charAt(at) - '0');
+                if (n > Integer.MAX_VALUE) {
+                    throw error("Illegal repetition range");
+                }
+                at++;
+            }
+            return (int) n;
+        }
+
+        private Piece group() {
+            at++;
+            int saved = flags;
+            Piece out;
+            if (at < p.length() && p.charAt(at) == '?') {
+                at++;
+                if (at >= p.length()) {
+                    throw error("Unknown inline modifier");
+                }
+                char c = p.charAt(at);
+                if (c == ':') {
+                    at++;
+                    out = body();
+                } else if (c == '=' || c == '!') {
+                    at++;
+                    out = look(false, c == '!');
+                } else if (c == '>') {
+                    at++;
+                    Piece inner = body();
+                    inner.last.next = new SubEnd();
+                    Node atomic = new Atomic(inner.first);
+                    out = new Piece(atomic, atomic, inner.min, inner.max);
+                } else if (c == '<') {
+                    at++;
+                    if (at < p.length() && (p.charAt(at) == '=' || p.charAt(at) == '!')) {
+                        boolean negative = p.charAt(at) == '!';
+                        at++;
+                        out = look(true, negative);
+                    } else {
+                        String name = groupName('>');
+                        if (names.containsKey(name)) {
+                            throw error("Named capturing group <" + name + "> is already defined");
+                        }
+                        int group = ++groups;
+                        names.put(name, Integer.valueOf(group));
+                        out = capture(group);
+                    }
+                } else {
+                    // (?flags) for the rest of the enclosing group, or
+                    // (?flags:X) for X alone.
+                    inlineFlags();
+                    if (at >= p.length()) {
+                        throw error("Unknown inline modifier");
+                    }
+                    if (p.charAt(at) == ')') {
+                        at++;
+                        return Piece.empty();
+                    }
+                    if (p.charAt(at) != ':') {
+                        throw error("Unknown inline modifier");
+                    }
+                    at++;
+                    out = body();
+                }
+            } else {
+                out = capture(++groups);
+            }
+            flags = saved;
+            return out;
+        }
+
+        private Piece body() {
+            Piece inner = alternatives();
+            if (at >= p.length() || p.charAt(at) != ')') {
+                throw error("Unclosed group");
+            }
+            at++;
+            return inner;
+        }
+
+        private Piece capture(int group) {
+            Piece out = Piece.of(new GroupOpen(group), 0);
+            out.then(body());
+            out.then(Piece.of(new GroupClose(group), 0));
+            return out;
+        }
+
+        private Piece look(boolean behind, boolean negative) {
+            Piece inner = body();
+            if (behind && inner.max < 0) {
+                throw error("Look-behind group does not have an obvious maximum length");
+            }
+            inner.last.next = new SubEnd();
+            return Piece.of(new Look(inner.first, behind, negative, inner.min, inner.max), 0);
+        }
+
+        private String groupName(char close) {
+            int start = at;
+            while (at < p.length() && p.charAt(at) != close) {
+                char c = p.charAt(at);
+                boolean letter = asciiLetter(c);
+                if (!(letter || at > start && c >= '0' && c <= '9')) {
+                    throw error(at == start ? "capturing group name does not start with a Latin letter"
+                            : "named capturing group is missing trailing '" + close + "'");
+                }
+                at++;
+            }
+            if (at >= p.length()) {
+                throw error("named capturing group is missing trailing '" + close + "'");
+            }
+            if (at == start) {
+                throw error("named capturing group has 0 length name");
+            }
+            String name = p.substring(start, at);
+            at++;
+            return name;
+        }
+
+        private void inlineFlags() {
+            boolean on = true;
+            while (at < p.length()) {
+                char c = p.charAt(at);
+                int flag;
+                switch (c) {
+                    case 'i':
+                        flag = CASE_INSENSITIVE;
+                        break;
+                    case 'm':
+                        flag = MULTILINE;
+                        break;
+                    case 's':
+                        flag = DOTALL;
+                        break;
+                    case 'd':
+                        flag = UNIX_LINES;
+                        break;
+                    case 'u':
+                        flag = UNICODE_CASE;
+                        break;
+                    case 'x':
+                        flag = COMMENTS;
+                        break;
+                    case 'c':
+                        throw unsupported("The inline flag (?c), canonical equivalence,");
+                    case 'U':
+                        throw unsupported("The inline flag (?U), Unicode character classes,");
+                    case '-':
+                        if (!on) {
+                            return;
+                        }
+                        on = false;
+                        at++;
+                        continue;
+                    default:
+                        return;
+                }
+                flags = on ? flags | flag : flags & ~flag;
+                at++;
+            }
+        }
+
+        private int hex(int digits) {
+            if (at + digits > p.length()) {
+                throw error("Illegal hexadecimal escape sequence");
+            }
+            int v = 0;
+            for (int k = 0; k < digits; k++) {
+                int d = Character.digit(p.charAt(at++), 16);
+                if (d < 0) {
+                    throw error("Illegal hexadecimal escape sequence");
+                }
+                v = v * 16 + d;
+            }
+            return v;
+        }
+
+        /// The character an escape names, with `at` after the letter that
+        /// follows the backslash; -1 when the letter is not one of those.
+        private int escapedChar(char e) {
+            switch (e) {
+                case 't':
+                    return '\t';
+                case 'n':
+                    return '\n';
+                case 'r':
+                    return '\r';
+                case 'f':
+                    return '\f';
+                case 'a':
+                    return 7;
+                case 'e':
+                    return 0x1b;
+                case '0': {
+                    int v = 0;
+                    int digits = 0;
+                    while (at < p.length() && digits < 3 && p.charAt(at) >= '0' && p.charAt(at) <= '7') {
+                        int d = p.charAt(at) - '0';
+                        if (digits == 2 && v > 0x1f) {
+                            break;
+                        }
+                        v = v * 8 + d;
+                        digits++;
+                        at++;
+                    }
+                    if (digits == 0) {
+                        throw error("Illegal octal escape sequence");
+                    }
+                    return v;
+                }
+                case 'x':
+                    if (at < p.length() && p.charAt(at) == '{') {
+                        at++;
+                        int v = 0;
+                        int start = at;
+                        while (at < p.length() && p.charAt(at) != '}') {
+                            int d = Character.digit(p.charAt(at), 16);
+                            if (d < 0 || v > 0x10ffff) {
+                                throw error("Illegal hexadecimal escape sequence");
+                            }
+                            v = v * 16 + d;
+                            at++;
+                        }
+                        if (at >= p.length() || at == start || v > 0x10ffff) {
+                            throw error("Illegal hexadecimal escape sequence");
+                        }
+                        at++;
+                        return v;
+                    }
+                    return hex(2);
+                case 'u':
+                    if (at + 4 > p.length()) {
+                        throw error("Illegal Unicode escape sequence");
+                    }
+                    for (int k = 0; k < 4; k++) {
+                        if (Character.digit(p.charAt(at + k), 16) < 0) {
+                            throw error("Illegal Unicode escape sequence");
+                        }
+                    }
+                    return hex(4);
+                case 'c':
+                    if (at >= p.length()) {
+                        throw error("Illegal control escape sequence");
+                    }
+                    return p.charAt(at++) ^ 64;
+                default:
+                    return -1;
+            }
+        }
+
+        /// The class an escape names, or null.
+        private CharSet escapedClass(char e) {
+            switch (e) {
+                case 'd':
+                    return new CharSet(0).add('0', '9');
+                case 'D':
+                    return new CharSet(0).add('0', '9').not();
+                case 'w':
+                    return word();
+                case 'W':
+                    return word().not();
+                case 's':
+                    return new CharSet(0).add(' ').add('\t', '\r');
+                case 'S':
+                    return new CharSet(0).add(' ').add('\t', '\r').not();
+                case 'h':
+                    return horizontal();
+                case 'H':
+                    return horizontal().not();
+                case 'v':
+                    return vertical();
+                case 'V':
+                    return vertical().not();
+                case 'p':
+                case 'P': {
+                    CharSet set = property();
+                    return e == 'P' ? set.not() : set;
+                }
+                default:
+                    return null;
+            }
+        }
+
+        private static CharSet word() {
+            return new CharSet(0).add('a', 'z').add('A', 'Z').add('0', '9').add('_');
+        }
+
+        private static CharSet horizontal() {
+            return new CharSet(0).add(' ').add('\t').add(0xa0).add(0x1680).add(0x180e).add(0x2000, 0x200a)
+                    .add(0x202f).add(0x205f).add(0x3000);
+        }
+
+        private static CharSet vertical() {
+            return new CharSet(0).add('\n', '\r').add(0x85).add(0x2028, 0x2029);
+        }
+
+        private CharSet property() {
+            String name;
+            if (at < p.length() && p.charAt(at) == '{') {
+                int close = p.indexOf('}', at);
+                if (close < 0) {
+                    throw error("Unclosed character family");
+                }
+                name = p.substring(at + 1, close);
+                at = close + 1;
+            } else if (at < p.length()) {
+                name = String.valueOf(p.charAt(at++));
+            } else {
+                throw error("Illegal character family");
+            }
+            CharSet s = new CharSet(0);
+            // Under CASE_INSENSITIVE the case classes match either case, as
+            // they have on the JDK since 16 (JDK-8214245): the ASCII ones become
+            // the ASCII letters, the Unicode ones any cased letter.
+            boolean anyCase = has(CASE_INSENSITIVE);
+            if ("Lower".equals(name)) {
+                return anyCase ? s.add('a', 'z').add('A', 'Z') : s.add('a', 'z');
+            }
+            if ("Upper".equals(name)) {
+                return anyCase ? s.add('a', 'z').add('A', 'Z') : s.add('A', 'Z');
+            }
+            if ("ASCII".equals(name)) {
+                return s.add(0, 0x7f);
+            }
+            if ("Alpha".equals(name)) {
+                return s.add('a', 'z').add('A', 'Z');
+            }
+            if ("Digit".equals(name)) {
+                return s.add('0', '9');
+            }
+            if ("Alnum".equals(name)) {
+                return s.add('a', 'z').add('A', 'Z').add('0', '9');
+            }
+            if ("Punct".equals(name)) {
+                return s.add('!', '/').add(':', '@').add('[', '`').add('{', '~');
+            }
+            if ("Graph".equals(name)) {
+                return s.add('!', '~');
+            }
+            if ("Print".equals(name)) {
+                return s.add(' ', '~');
+            }
+            if ("Blank".equals(name)) {
+                return s.add(' ').add('\t');
+            }
+            if ("Cntrl".equals(name)) {
+                return s.add(0, 0x1f).add(0x7f);
+            }
+            if ("XDigit".equals(name)) {
+                return s.add('0', '9').add('a', 'f').add('A', 'F');
+            }
+            if ("Space".equals(name)) {
+                return s.add(' ').add('\t', '\r');
+            }
+            if ("javaLowerCase".equals(name) || "Ll".equals(name) || "IsLl".equals(name)
+                    || "IsLowercase".equals(name)) {
+                return anyCase ? s.kind(CharSet.LOWER | CharSet.UPPER | CharSet.TITLE) : s.kind(CharSet.LOWER);
+            }
+            if ("javaUpperCase".equals(name) || "Lu".equals(name) || "IsLu".equals(name)
+                    || "IsUppercase".equals(name)) {
+                return anyCase ? s.kind(CharSet.LOWER | CharSet.UPPER | CharSet.TITLE) : s.kind(CharSet.UPPER);
+            }
+            if ("javaWhitespace".equals(name) || "IsWhite_Space".equals(name) || "IsWhiteSpace".equals(name)) {
+                return s.kind(CharSet.WHITESPACE);
+            }
+            if ("javaLetter".equals(name) || "L".equals(name) || "IsL".equals(name) || "IsLetter".equals(name)
+                    || "IsAlphabetic".equals(name) || "javaAlphabetic".equals(name)) {
+                return s.kind(CharSet.LETTER);
+            }
+            if ("javaLetterOrDigit".equals(name)) {
+                return s.kind(CharSet.LETTER_OR_DIGIT);
+            }
+            if ("javaDigit".equals(name) || "N".equals(name) || "Nd".equals(name) || "IsN".equals(name)
+                    || "IsNd".equals(name) || "IsDigit".equals(name)) {
+                return s.kind(CharSet.DIGIT);
+            }
+            throw unsupported("The character property {" + name + "}");
+        }
+
+        private Piece escape() {
+            if (at >= p.length()) {
+                throw error("Unexpected internal error");
+            }
+            char e = p.charAt(at++);
+            boolean unix = has(UNIX_LINES);
+            switch (e) {
+                case 'A':
+                    return Piece.of(new Anchor(Anchor.BEGIN, unix), 0);
+                case 'z':
+                    return Piece.of(new Anchor(Anchor.END, unix), 0);
+                case 'Z':
+                    return Piece.of(new Anchor(Anchor.END_OR_FINAL_TERMINATOR, unix), 0);
+                case 'G':
+                    return Piece.of(new Anchor(Anchor.LAST_MATCH, unix), 0);
+                case 'b':
+                    if (at < p.length() && p.charAt(at) == '{') {
+                        throw unsupported("The boundary \\b{...}");
+                    }
+                    return Piece.of(new Anchor(Anchor.WORD, unix), 0);
+                case 'B':
+                    return Piece.of(new Anchor(Anchor.NOT_WORD, unix), 0);
+                case 'X':
+                    throw unsupported("The grapheme cluster \\X");
+                case 'N':
+                    throw unsupported("The named character \\N{...}");
+                case 'R': {
+                    // \r\n as one, or any single line end; atomic, so the
+                    // pair is never split to let what follows take the \n.
+                    Piece crlf = Piece.of(new Char('\r'), 1);
+                    crlf.then(Piece.of(new Char('\n'), 1));
+                    Piece one = Piece.of(new InClass(vertical()), 1);
+                    Pass join = new Pass();
+                    crlf.last.next = join;
+                    one.last.next = join;
+                    join.next = new SubEnd();
+                    Node atomic = new Atomic(new Branch(new Node[] {crlf.first, one.first}));
+                    return new Piece(atomic, atomic, 1, 2);
+                }
+                case 'k': {
+                    if (at >= p.length() || p.charAt(at) != '<') {
+                        throw error("\\k is not followed by '<' for named capturing group");
+                    }
+                    at++;
+                    String name = groupName('>');
+                    Integer group = names.get(name);
+                    if (group == null) {
+                        throw error("named capturing group <" + name + "> does not exist");
+                    }
+                    return Piece.of(new BackReference(group.intValue(), has(CASE_INSENSITIVE), has(UNICODE_CASE)), 0)
+                            .unbounded();
+                }
+                default:
+                    break;
+            }
+            if (e >= '1' && e <= '9') {
+                int group = e - '0';
+                while (at < p.length() && p.charAt(at) >= '0' && p.charAt(at) <= '9') {
+                    int more = group * 10 + (p.charAt(at) - '0');
+                    if (more > groups) {
+                        break;
+                    }
+                    group = more;
+                    at++;
+                }
+                return Piece.of(new BackReference(group, has(CASE_INSENSITIVE), has(UNICODE_CASE)), 0).unbounded();
+            }
+            CharSet set = escapedClass(e);
+            if (set != null) {
+                return Piece.of(new InClass(set), 1);
+            }
+            int c = escapedChar(e);
+            if (c >= 0) {
+                return literal(c);
+            }
+            if (asciiLetter(e)) {
+                at--;
+                throw error("Illegal/unsupported escape sequence");
+            }
+            return literal(e);
+        }
+
+        /// A class, with `at` after its opening bracket; consumes the
+        /// closing one.
+        private CharSet characterClass() {
+            boolean negate = false;
+            if (at < p.length() && p.charAt(at) == '^') {
+                negate = true;
+                at++;
+            }
+            CharSet set = classBody();
+            set.negate = negate;
+            return set;
+        }
+
+        private CharSet classBody() {
+            CharSet set = newSet();
+            boolean first = true;
+            while (true) {
+                if (has(COMMENTS)) {
+                    skipComments();
+                }
+                if (at >= p.length()) {
+                    throw error("Unclosed character class");
+                }
+                char c = p.charAt(at);
+                if (c == ']' && !first) {
+                    at++;
+                    return set;
+                }
+                first = false;
+                if (c == '[') {
+                    at++;
+                    set.unite(characterClass());
+                    continue;
+                }
+                if (c == '&' && at + 1 < p.length() && p.charAt(at + 1) == '&') {
+                    at += 2;
+                    if (at < p.length() && p.charAt(at) == ']') {
+                        // Nothing to intersect with.
+                        continue;
+                    }
+                    // Everything after && is the other operand, up to the
+                    // bracket that closes this class.
+                    CharSet right = classBody();
+                    if (set.isEmpty()) {
+                        return right;
+                    }
+                    set.and = right;
+                    return set;
+                }
+                int lo;
+                if (c == '\\') {
+                    at++;
+                    if (at >= p.length()) {
+                        throw error("Unclosed character class");
+                    }
+                    char e = p.charAt(at++);
+                    if (e == 'Q') {
+                        int end = p.indexOf("\\E", at);
+                        if (end < 0) {
+                            throw error("Unclosed character class");
+                        }
+                        for (; at < end; at++) {
+                            set.add(p.charAt(at));
+                        }
+                        at = end + 2;
+                        continue;
+                    }
+                    if (e == 'E') {
+                        continue;
+                    }
+                    CharSet named = escapedClass(e);
+                    if (named != null) {
+                        set.unite(named);
+                        continue;
+                    }
+                    lo = escapedChar(e);
+                    if (lo < 0) {
+                        if (asciiLetter(e) || e >= '0' && e <= '9') {
+                            at--;
+                            throw error("Illegal/unsupported escape sequence");
+                        }
+                        lo = e;
+                    }
+                } else {
+                    at++;
+                    lo = c;
+                }
+                int hi = lo;
+                if (at + 1 < p.length() && p.charAt(at) == '-' && p.charAt(at + 1) != ']'
+                        && p.charAt(at + 1) != '[') {
+                    at++;
+                    char h = p.charAt(at++);
+                    if (h == '\\') {
+                        if (at >= p.length()) {
+                            throw error("Unclosed character class");
+                        }
+                        char e = p.charAt(at++);
+                        hi = escapedChar(e);
+                        if (hi < 0) {
+                            if (asciiLetter(e)) {
+                                at--;
+                                throw error("Illegal character range");
+                            }
+                            hi = e;
+                        }
+                    } else {
+                        hi = h;
+                    }
+                    if (hi < lo) {
+                        throw error("Illegal character range");
+                    }
+                }
+                if (hi > 0xffff) {
+                    throw unsupported("A character above U+FFFF in a character class");
+                }
+                set.add(lo, hi);
+            }
+        }
+    }
+}
diff --git a/CodenameOne/src/com/codename1/util/regex/PatternSyntaxException.java b/CodenameOne/src/com/codename1/util/regex/PatternSyntaxException.java
new file mode 100644
index 00000000000..6319c57348d
--- /dev/null
+++ b/CodenameOne/src/com/codename1/util/regex/PatternSyntaxException.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.util.regex;
+
+/// The same shape as `java.util.regex.PatternSyntaxException`: a pattern that is not one, or
+/// that uses a construct this runtime does not have -- the description says
+/// which.
+public class PatternSyntaxException extends IllegalArgumentException {
+
+    private final String description;
+    private final String pattern;
+    private final int index;
+
+    public PatternSyntaxException(String description, String regex, int index) {
+        this.description = description;
+        this.pattern = regex;
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public String getPattern() {
+        return pattern;
+    }
+
+    @Override
+    public String getMessage() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(description);
+        if (index >= 0) {
+            sb.append(" near index ").append(index);
+        }
+        sb.append('\n').append(pattern);
+        if (index >= 0 && pattern != null && index < pattern.length()) {
+            sb.append('\n');
+            for (int i = 0; i < index; i++) {
+                sb.append(' ');
+            }
+            sb.append('^');
+        }
+        return sb.toString();
+    }
+}
diff --git a/CodenameOne/src/com/codename1/util/regex/StringRegex.java b/CodenameOne/src/com/codename1/util/regex/StringRegex.java
new file mode 100644
index 00000000000..784a2302ad4
--- /dev/null
+++ b/CodenameOne/src/com/codename1/util/regex/StringRegex.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.util.regex;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+/// The methods of `java.lang.String` that take a regular expression, over
+/// this package's [Pattern]: `matches`, `split`, `replaceAll` and
+/// `replaceFirst`, with the JDK's syntax. Each takes the string as its
+/// first argument, so `s.split(";")` becomes `StringRegex.split(s, ";")`.
+public final class StringRegex {
+
+    /// The pattern compiled last. Code that splits every line of a file by
+    /// the same expression compiles it once.
+    private static final AtomicReference<Pattern> LAST = new AtomicReference<Pattern>();
+
+    private StringRegex() {
+    }
+
+    private static Pattern pattern(String regex) {
+        Pattern last = LAST.get();
+        if (last != null && last.pattern().equals(regex)) {
+            return last;
+        }
+        Pattern compiled = Pattern.compile(regex);
+        LAST.set(compiled);
+        return compiled;
+    }
+
+    /// The character a separator is, when it is one plain character or one
+    /// escaped: -1 when it has to be compiled.
+    private static int plain(String regex) {
+        if (regex.length() == 1) {
+            char c = regex.charAt(0);
+            return ".$|()[{^?*+\\".indexOf(c) < 0 ? c : -1;
+        }
+        if (regex.length() == 2 && regex.charAt(0) == '\\') {
+            char c = regex.charAt(1);
+            boolean alnum = c >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z';
+            return alnum || c >= 0xd800 && c <= 0xdfff ? -1 : c;
+        }
+        return -1;
+    }
+
+    public static boolean matches(String s, String regex) {
+        return pattern(regex).matcher(s).matches();
+    }
+
+    public static String[] split(String s, String regex) {
+        return split(s, regex, 0);
+    }
+
+    public static String[] split(String s, String regex, int limit) {
+        int c = plain(regex);
+        if (c < 0) {
+            return pattern(regex).split(s, limit);
+        }
+        List<String> list = new ArrayList<String>();
+        int off = 0;
+        boolean limited = limit > 0;
+        int next = s.indexOf(c, off);
+        while (next >= 0 && (!limited || list.size() < limit - 1)) {
+            list.add(s.substring(off, next));
+            off = next + 1;
+            next = s.indexOf(c, off);
+        }
+        if (off == 0) {
+            return new String[] {s};
+        }
+        list.add(s.substring(off));
+        int size = list.size();
+        if (limit == 0) {
+            while (size > 0 && list.get(size - 1).length() == 0) {
+                size--;
+            }
+        }
+        String[] out = new String[size];
+        for (int i = 0; i < size; i++) {
+            out[i] = list.get(i);
+        }
+        return out;
+    }
+
+    public static String replaceAll(String s, String regex, String replacement) {
+        return pattern(regex).matcher(s).replaceAll(replacement);
+    }
+
+    public static String replaceFirst(String s, String regex, String replacement) {
+        return pattern(regex).matcher(s).replaceFirst(replacement);
+    }
+}
diff --git a/CodenameOne/src/com/codename1/util/regex/package-info.java b/CodenameOne/src/com/codename1/util/regex/package-info.java
index af29c46f25a..2eb4f175b50 100644
--- a/CodenameOne/src/com/codename1/util/regex/package-info.java
+++ b/CodenameOne/src/com/codename1/util/regex/package-info.java
@@ -1,8 +1,30 @@
-/* 
-    Document   : package
-    Created on : Oct 11, 2007, 10:38:26 AM
-    Author     : Shai Almog
-*/
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 
-/// A simple regular expression API that is portable across all platforms
+/// Regular expressions that are portable across all platforms.
+///
+/// [Pattern] and [Matcher] have the shape and the syntax of
+/// `java.util.regex`, and [StringRegex] holds the regular expression methods
+/// of `java.lang.String` over them. [RE] is the older, smaller evaluator with
+/// its own dialect.
 package com.codename1.util.regex;
diff --git a/NOTICE b/NOTICE
index dc50ab27df2..28a66ac3365 100644
--- a/NOTICE
+++ b/NOTICE
@@ -129,3 +129,37 @@ ASM is distributed under the BSD 3-Clause license:
   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   THE POSSIBILITY OF SUCH DAMAGE.
+
+================================================================================
+GroupLayout
+================================================================================
+
+The class com.codename1.desktopcompat.javax.swing.GroupLayout in
+maven/swing-compat is adapted from Codename One's own port of the group layout,
+CodenameOne/src/com/codename1/ui/layouts/GroupLayout.java, which is derived from
+the GroupLayout Oracle published for the Java platform. The adaptation gives the
+class the javax.swing API -- its method names, its Alignment enumeration and the
+LayoutStyle.ComponentPlacement gap types -- reads minimum and maximum sizes from
+the components, and retargets the layout at the Swing compatibility layer's own
+java.awt component classes. The original copyright and license notice is
+retained in the source file.
+
+The file is distributed under the GNU General Public License version 2 with the
+"Classpath" exception, the license of Codename One itself (see LICENSE):
+
+  Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+
+================================================================================
+FloatingDecimal digit generation
+================================================================================
+
+The class java.text.LegacyDoubleDigits, in vm/JavaAPI/src/java/text and
+Ports/CLDC11/src/java/text, is a rewrite of the digit generation in OpenJDK's
+sun.misc.FloatingDecimal (BinaryToASCIIBuffer.dtoa) and the FDBigInteger
+arithmetic it uses, reduced to what java.text.DecimalFormat needs so that the
+class formats a double with the digits the JDK's DecimalFormat produces. The
+file is distributed under the GNU General Public License version 2 with the
+"Classpath" exception, the license of Codename One itself (see LICENSE), and
+keeps OpenJDK's notice:
+
+  Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
diff --git a/Ports/Android/spotbugs-exclude.xml b/Ports/Android/spotbugs-exclude.xml
index 3174b422459..d866bfc9950 100644
--- a/Ports/Android/spotbugs-exclude.xml
+++ b/Ports/Android/spotbugs-exclude.xml
@@ -567,4 +567,32 @@
         <Method name="dismissKeyguard" />
         <Bug pattern="DE_MIGHT_IGNORE" />
     </Match>
-</FindBugsFilter>
\ No newline at end of file
+
+    <!--
+    JdkHost is the class library's service registry, copied byte for byte from
+    vm/JavaAPI so the core's CoreJdkHost always has its superclass. install and
+    setRegistry store the object they are handed by design: that object IS the
+    installed service. The copy may not diverge to defend against it.
+    -->
+    <Match>
+        <Class name="com.codename1.impl.JdkHost" />
+        <Or>
+            <Method name="install" />
+            <Method name="setRegistry" />
+            <Method name="getRegistry" />
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_STATIC_REP2" />
+            <Bug pattern="MS_EXPOSE_REP" />
+        </Or>
+    </Match>
+    <!-- CompatResourceSupport.install creates the flat resource loader that
+         resolves an application's flattened resources and services files.
+         ART has no SecurityManager, so AccessController.doPrivileged would
+         wrap the construction in a check that never runs. -->
+    <Match>
+        <Class name="com.codename1.impl.android.CompatResourceSupport" />
+        <Method name="install" />
+        <Bug pattern="DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED" />
+    </Match>
+</FindBugsFilter>
diff --git a/Ports/Android/src/com/codename1/impl/JdkHost.java b/Ports/Android/src/com/codename1/impl/JdkHost.java
new file mode 100644
index 00000000000..ae07bd506c4
--- /dev/null
+++ b/Ports/Android/src/com/codename1/impl/JdkHost.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+/// The services the Java class library asks of the platform it runs on.
+///
+/// Internal API. The `java.*` classes of the ParparVM runtime (`vm/JavaAPI`)
+/// need a file system, preferences, the network, a log and an event thread,
+/// and on a device those belong to Codename One, which the class library
+/// cannot name: it is translated alone for the translator itself, the backend
+/// and the VM tests. So the class library calls this class, and whoever runs
+/// it installs the implementation that fits:
+///
+/// - a Codename One application gets `com.codename1.impl.CoreJdkHost`, which
+///   delegates to `FileSystemStorage`, `Preferences`, `NetworkManager`, `Log`
+///   and `Display`. The ParparVM ports install it from their `init`.
+/// - a program translated without Codename One (the self-hosted translator,
+///   the backend, a VM test) gets `PosixJdkHost`, which reaches the POSIX file
+///   natives through `java.io.File`.
+/// - anything else gets the defaults below, which are plain Java and touch no
+///   native method, so an application target that never installs a host
+///   cannot link the file natives through this class.
+///
+/// On Java SE and Android the real JDK runs and nothing calls this class.
+/// Copies of it ship in those ports only so that `CoreJdkHost`, which is part
+/// of the core sources, always has its superclass.
+///
+/// The file is kept byte for byte identical in `vm/JavaAPI`, `Ports/CLDC11`,
+/// `Ports/JavaSE` and `Ports/Android`; `CldcJavaApiParityTest` holds them
+/// to that. It may use only API all four class libraries have.
+///
+/// Paths are in the host's own form: absolute, as [#appHome] answers them.
+/// Turning a relative path into one is the caller's job.
+public abstract class JdkHost {
+    /// [#log] level of a debug message.
+    public static final int LOG_DEBUG = 1;
+    /// [#log] level of an informational message.
+    public static final int LOG_INFO = 2;
+    /// [#log] level of a warning.
+    public static final int LOG_WARNING = 3;
+    /// [#log] level of an error.
+    public static final int LOG_ERROR = 4;
+
+    private static final JdkHost DEFAULTS = new Defaults();
+    private static JdkHost current;
+    private static Registry registry;
+    private static Map<String, String> memoryPreferences;
+
+    /// Subclasses are installed with [#install].
+    protected JdkHost() {
+    }
+
+    /// The installed host, or the plain Java defaults when none was installed.
+    public static JdkHost get() {
+        JdkHost h = current;
+        return h == null ? DEFAULTS : h;
+    }
+
+    /// Makes `host` the one [#get] answers; null restores the defaults.
+    /// Called once, while the program starts and before it starts a thread
+    /// of its own.
+    public static void install(JdkHost host) {
+        current = host;
+    }
+
+    /// Makes `r` the registry [#providers] and [#newInstance] read. An
+    /// application's generated start-up code installs it.
+    public static void setRegistry(Registry r) {
+        registry = r;
+    }
+
+    /// The registry [#setRegistry] installed, or null.
+    public static Registry getRegistry() {
+        return registry;
+    }
+
+    // ------------------------------------------------------------------
+    // Files
+
+    /// What is known of `path`, or null when nothing is there.
+    public FileStat fileStat(String path) {
+        return null;
+    }
+
+    /// The names of the entries of the directory `path`, or null when it is
+    /// not a directory.
+    public String[] fileList(String path) throws IOException {
+        return null;
+    }
+
+    /// Opens the file `path` for reading.
+    public InputStream fileRead(String path) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Opens the file `path` for writing, at its end when `append` is true
+    /// and from empty otherwise, creating it when it is not there.
+    public OutputStream fileWrite(String path, boolean append) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Creates the directory `path`; false when it was not created, also
+    /// when something was there already.
+    public boolean fileMkdir(String path) {
+        return false;
+    }
+
+    /// Deletes the file or empty directory `path`; false when it is still
+    /// there or never was.
+    public boolean fileDelete(String path) {
+        return false;
+    }
+
+    /// Moves `from` to `to`, which must not exist. False when it did not
+    /// happen; a host may refuse a move to another directory, and the
+    /// caller then copies.
+    public boolean fileRename(String from, String to) {
+        return false;
+    }
+
+    /// The application's home directory, where a relative path resolves.
+    public String appHome() {
+        return "/";
+    }
+
+    /// A directory for disposable files, or null when the platform has no
+    /// separate one and [#appHome] serves.
+    public String cachesDir() {
+        return null;
+    }
+
+    /// The roots of the file system.
+    public String[] fileRoots() {
+        return new String[] {appHome()};
+    }
+
+    /// The size in bytes of the volume holding `path`, or 0 when unknown.
+    public long fileTotalSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes still free for this program on the volume holding `path`,
+    /// or 0 when unknown.
+    public long fileUsableSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes free on the volume holding `path`, counting what only a
+    /// privileged user may use; [#fileUsableSpace] unless the host knows
+    /// better.
+    public long fileFreeSpace(String path) {
+        return fileUsableSpace(path);
+    }
+
+    /// [#fileTest]: something is at the path.
+    public static final int FILE_EXISTS = 1;
+    /// [#fileTest]: the path is a directory.
+    public static final int FILE_DIRECTORY = 2;
+    /// [#fileTest]: the path is a file that is not a directory.
+    public static final int FILE_REGULAR = 3;
+    /// [#fileTest] and [#fileSet]: the path may be read.
+    public static final int FILE_READABLE = 4;
+    /// [#fileTest] and [#fileSet]: the path may be written.
+    public static final int FILE_WRITABLE = 5;
+    /// [#fileTest] and [#fileSet]: the path may be executed, or for a
+    /// directory, entered.
+    public static final int FILE_EXECUTABLE = 6;
+    /// [#fileTest]: the path is hidden.
+    public static final int FILE_HIDDEN = 7;
+
+    /// Whether `path` has the property `what`, one of the `FILE_` constants.
+    ///
+    /// The defaults read [#fileStat]: a file system without permissions lets
+    /// everything that exists be read and written, a directory be entered and
+    /// nothing be run, and hides a name that starts with a dot.
+    public boolean fileTest(String path, int what) {
+        if (what == FILE_HIDDEN) {
+            int slash = path.lastIndexOf('/');
+            return path.startsWith(".", slash + 1);
+        }
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_DIRECTORY || what == FILE_EXECUTABLE) {
+            return st.isDirectory();
+        }
+        if (what == FILE_REGULAR) {
+            return !st.isDirectory();
+        }
+        return true;
+    }
+
+    /// Grants (`on`) or takes away the permission `what` on `path`, one of
+    /// [#FILE_READABLE], [#FILE_WRITABLE] and [#FILE_EXECUTABLE]; false when
+    /// the path is not left that way.
+    ///
+    /// The defaults change nothing, so they answer whether the path already is
+    /// as asked, by the rules of [#fileTest].
+    public boolean fileSet(String path, int what, boolean on) {
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_EXECUTABLE) {
+            return on == st.isDirectory();
+        }
+        return on;
+    }
+
+    /// The length in bytes of the file `path`; 0 for a directory or when
+    /// nothing is there.
+    public long fileLength(String path) {
+        FileStat st = fileStat(path);
+        return st == null || st.isDirectory() ? 0L : st.length();
+    }
+
+    /// When `path` was last modified, in milliseconds since the epoch; 0 when
+    /// nothing is there.
+    public long fileLastModified(String path) {
+        FileStat st = fileStat(path);
+        return st == null ? 0L : st.lastModified();
+    }
+
+    /// Creates the empty file `path` when nothing is there; false when
+    /// something was.
+    ///
+    /// The default checks and then creates, which is not atomic: two threads
+    /// racing on one path can both be answered true.
+    public boolean fileCreate(String path) throws IOException {
+        if (fileStat(path) != null) {
+            return false;
+        }
+        fileWrite(path, false).close();
+        return true;
+    }
+
+    /// Moves `from` over `to`, replacing the file there. False when it did not
+    /// happen, which is all the defaults answer; the caller then copies.
+    public boolean fileReplace(String from, String to) {
+        return false;
+    }
+
+    /// The absolute `path` with symbolic links, `.` and `..` resolved, or
+    /// null when the host cannot resolve links and the caller should resolve
+    /// the dots by itself.
+    public String fileCanonicalPath(String path) throws IOException {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Preferences
+
+    /// The stored preference `key`, or null. The defaults keep preferences
+    /// in memory, for this run only.
+    public String preference(String key) {
+        return memoryPreference(key, null, false);
+    }
+
+    /// Stores `value` under `key`.
+    public void setPreference(String key, String value) {
+        memoryPreference(key, value, true);
+    }
+
+    /// Removes the preference `key`.
+    public void deletePreference(String key) {
+        memoryPreference(key, null, true);
+    }
+
+    /// Reads `key` from the in-memory preferences, or, when `write` is true,
+    /// stores `value` there (null removes it). One lock: the class library
+    /// runs on several threads where a host leaves this to the defaults.
+    private static synchronized String memoryPreference(String key, String value, boolean write) {
+        if (memoryPreferences == null) {
+            memoryPreferences = new HashMap<String, String>();
+        }
+        if (!write) {
+            return memoryPreferences.get(key);
+        }
+        if (value == null) {
+            return memoryPreferences.remove(key);
+        }
+        return memoryPreferences.put(key, value);
+    }
+
+    // ------------------------------------------------------------------
+    // Network, log and process
+
+    /// Reads `url` with an HTTP GET. A missing resource (404, 410) throws
+    /// `java.io.FileNotFoundException`, any other failure an `IOException`.
+    public InputStream openUrl(String url) throws IOException {
+        throw new IOException("No network: " + url);
+    }
+
+    /// Logs `message` and `thrown`, either of which may be null, at `level`
+    /// ([#LOG_DEBUG] to [#LOG_ERROR]).
+    public void log(int level, String message, Throwable thrown) {
+        if (message != null) {
+            System.err.println(message);
+        }
+        if (thrown != null) {
+            thrown.printStackTrace();
+        }
+    }
+
+    /// The platform's answer for the system property `key`, or null. The
+    /// class library answers the properties it defines itself.
+    public String property(String key) {
+        return null;
+    }
+
+    /// Asks the platform to close the application, after the shutdown hooks
+    /// ran; `Runtime.exit` ends the process itself if this returns. The
+    /// defaults leave it to that.
+    public void exit(int status) {
+    }
+
+    /// Called when the program installs a default uncaught exception
+    /// handler, so that a host whose UI thread catches what its tasks throw
+    /// can hand that to `Thread.getDefaultUncaughtExceptionHandler()` too.
+    /// Called on every such install; the defaults do nothing.
+    public void watchUncaughtExceptions() {
+    }
+
+    // ------------------------------------------------------------------
+    // Threads
+
+    /// Whether the caller is the UI thread, which must not block.
+    public boolean isUiThread() {
+        return false;
+    }
+
+    /// Runs `task`, which blocks, where blocking is allowed: off the UI
+    /// thread while that thread keeps serving events, or right here.
+    public void blockUi(Runnable task) {
+        task.run();
+    }
+
+    // ------------------------------------------------------------------
+    // Resources, services and locale
+
+    /// Opens the application resource `name` (a path such as
+    /// `META-INF/services/x`, without a leading slash), or null.
+    public InputStream resource(String name) {
+        return null;
+    }
+
+    /// The class names of the providers of `service` the application
+    /// declares, from the [Registry]; empty when there is none.
+    public String[] providers(String service) {
+        Registry r = registry;
+        String[] names = r == null ? null : r.providers(service);
+        return names == null ? new String[0] : names;
+    }
+
+    /// A new instance of the application class `className`, made by the
+    /// [Registry] without reflection; null when it cannot make one.
+    public Object newInstance(String className) {
+        Registry r = registry;
+        return r == null ? null : r.newInstance(className);
+    }
+
+    /// The class of the application class `className`, as the [Registry]
+    /// knows it, so that its type can be tested without creating one; null
+    /// when it does not know the class.
+    public Class<?> type(String className) {
+        Registry r = registry;
+        return r == null ? null : r.type(className);
+    }
+
+    /// The decimal separator, grouping separator and currency symbol of the
+    /// device's locale, any of them null when unknown; or null when the
+    /// platform cannot tell.
+    public String[] localeNumberSymbols() {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Security
+
+    /// Fills `out` with cryptographically secure random bytes.
+    public void randomBytes(byte[] out) {
+        throw new UnsupportedOperationException("No secure random source");
+    }
+
+    /// A new digest for `algorithm` (`MD5`, `SHA-1`, `SHA-256` and the like),
+    /// or null when the platform has none.
+    public Digest digest(String algorithm) {
+        return null;
+    }
+
+    /// The attributes [#fileStat] reports.
+    public static final class FileStat {
+        private final boolean directory;
+        private final long length;
+        private final long lastModified;
+
+        /// A file or, when `directory` is true, a directory.
+        public FileStat(boolean directory, long length, long lastModified) {
+            this.directory = directory;
+            this.length = length;
+            this.lastModified = lastModified;
+        }
+
+        /// Whether it is a directory.
+        public boolean isDirectory() {
+            return directory;
+        }
+
+        /// The length in bytes of a file; 0 for a directory.
+        public long length() {
+            return length;
+        }
+
+        /// When it was last modified, in milliseconds since the epoch, or 0.
+        public long lastModified() {
+            return lastModified;
+        }
+    }
+
+    /// A running message digest, as [#digest] makes it.
+    public interface Digest {
+        /// Feeds `length` bytes of `data` from `offset`.
+        void update(byte[] data, int offset, int length);
+
+        /// Finishes the digest and resets it.
+        byte[] digest();
+
+        /// Discards what was fed.
+        void reset();
+
+        /// The length of the digest in bytes.
+        int length();
+    }
+
+    /// What an application declares for `java.util.ServiceLoader` and
+    /// `java.util.ResourceBundle`, generated with the application. Once one
+    /// is installed it is the whole answer: the class library creates no
+    /// class from its name and reads no services file.
+    public interface Registry {
+        /// The provider class names declared for `service`, or null.
+        String[] providers(String service);
+
+        /// A new instance of `className`, or null.
+        Object newInstance(String className);
+
+        /// The class `className`, or null when the registry does not know it.
+        Class<?> type(String className);
+    }
+
+    /// The host [#get] answers when none was installed.
+    private static final class Defaults extends JdkHost {
+    }
+}
diff --git a/Ports/Android/src/com/codename1/impl/android/AndroidImplementation.java b/Ports/Android/src/com/codename1/impl/android/AndroidImplementation.java
index adafaae440f..0dd3de1e955 100644
--- a/Ports/Android/src/com/codename1/impl/android/AndroidImplementation.java
+++ b/Ports/Android/src/com/codename1/impl/android/AndroidImplementation.java
@@ -1824,6 +1824,9 @@ public void setContext(Context c) {
 
     @Override
     public void init(Object m) {
+        // cn1res: URLs and flattened resources for applications built from
+        // desktop or Android sources, which ART cannot resolve on its own.
+        CompatResourceSupport.install();
         // NOTE:  Do not explicitly set the PlayServices instance to anything other than
         // an instance of the base PlayServices class.  The Build Server will automatically
         // swap this for the appropriate subclass depending on the playServicesVersion of 
diff --git a/Ports/Android/src/com/codename1/impl/android/CompatResourceSupport.java b/Ports/Android/src/com/codename1/impl/android/CompatResourceSupport.java
new file mode 100644
index 00000000000..364039cdc00
--- /dev/null
+++ b/Ports/Android/src/com/codename1/impl/android/CompatResourceSupport.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.android;
+
+import com.codename1.impl.compat.Resources;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.util.Collections;
+import java.util.Enumeration;
+
+/// What an application built from desktop or Android sources needs of the
+/// runtime this port runs on to find the resources its build flattened
+/// ([com.codename1.impl.compat.Resources]).
+///
+/// - The JDK's `URL` does not know the `cn1res:` scheme, so the URLs
+///   `Resources` answers are made here with a handler that reads them back
+///   through it.
+/// - The JDK's `ResourceBundle` and `ServiceLoader` look a nested name up
+///   through a class loader, so the loader installed here asks the
+///   application's own loader first and `Resources` after it.
+///
+/// The JavaSE port carries the same class for the same reasons.
+final class CompatResourceSupport {
+    private static final String SCHEME = "cn1res";
+
+    private CompatResourceSupport() {
+    }
+
+    /// Installs both into `Resources`. Idempotent.
+    static void install() {
+        Resources.cn1SetUrlFactory(new Factory());
+        if (Resources.cn1ClassLoader() == null) {
+            ClassLoader parent = Resources.class.getClassLoader();
+            Resources.cn1SetClassLoader(new FlatResourceLoader(parent));
+        }
+    }
+
+    private static URL create(String encodedPath) throws MalformedURLException {
+        return new URL(SCHEME, null, -1, encodedPath, Handler.INSTANCE);
+    }
+
+    private static final class Factory implements Resources.UrlFactory {
+        @Override
+        public URL create(String encodedPath) throws IOException {
+            return CompatResourceSupport.create(encodedPath);
+        }
+    }
+
+    private static final class Handler extends URLStreamHandler {
+        static final Handler INSTANCE = new Handler();
+
+        @Override
+        protected URLConnection openConnection(URL u) {
+            return new Connection(u);
+        }
+    }
+
+    private static final class Connection extends URLConnection {
+        Connection(URL url) {
+            super(url);
+        }
+
+        @Override
+        public void connect() {
+            connected = true;
+        }
+
+        @Override
+        public InputStream getInputStream() throws IOException {
+            InputStream in = Resources.openUrlPath(getURL().getPath());
+            if (in == null) {
+                throw new FileNotFoundException(getURL().toExternalForm());
+            }
+            return in;
+        }
+    }
+
+    /// The application's loader, then the resources the build flattened.
+    private static final class FlatResourceLoader extends ClassLoader {
+        FlatResourceLoader(ClassLoader parent) {
+            super(parent);
+        }
+
+        @Override
+        protected URL findResource(String name) {
+            if (name == null || name.startsWith("/") || !Resources.exists(name)) {
+                return null;
+            }
+            return Resources.getSystemResource(name);
+        }
+
+        @Override
+        protected Enumeration<URL> findResources(String name) {
+            URL url = findResource(name);
+            if (url == null) {
+                return Collections.<URL>emptyEnumeration();
+            }
+            return Collections.enumeration(Collections.singletonList(url));
+        }
+
+        /// A services file is the generated registry's list once one is
+        /// installed, and nothing else: the files the build flattened would
+        /// shadow one another, and would name providers that do not ship.
+        @Override
+        public Enumeration<URL> getResources(String name) throws IOException {
+            if (name != null && name.startsWith(Resources.SERVICES)) {
+                String file = Resources.cn1ServicesFile(name.substring(Resources.SERVICES.length()));
+                if (file != null) {
+                    URL url = new URL(SCHEME, null, -1, "/" + name, new TextHandler(file));
+                    return Collections.enumeration(Collections.singletonList(url));
+                }
+            }
+            return super.getResources(name);
+        }
+    }
+
+    /// Serves one text, as UTF-8, whatever the URL.
+    private static final class TextHandler extends URLStreamHandler {
+        private final String text;
+
+        TextHandler(String text) {
+            this.text = text;
+        }
+
+        @Override
+        protected URLConnection openConnection(URL u) {
+            return new URLConnection(u) {
+                @Override
+                public void connect() {
+                    connected = true;
+                }
+
+                @Override
+                public InputStream getInputStream() throws IOException {
+                    return new ByteArrayInputStream(text.getBytes("UTF-8"));
+                }
+            };
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/com/codename1/impl/JdkHost.java b/Ports/CLDC11/src/com/codename1/impl/JdkHost.java
new file mode 100644
index 00000000000..ae07bd506c4
--- /dev/null
+++ b/Ports/CLDC11/src/com/codename1/impl/JdkHost.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+/// The services the Java class library asks of the platform it runs on.
+///
+/// Internal API. The `java.*` classes of the ParparVM runtime (`vm/JavaAPI`)
+/// need a file system, preferences, the network, a log and an event thread,
+/// and on a device those belong to Codename One, which the class library
+/// cannot name: it is translated alone for the translator itself, the backend
+/// and the VM tests. So the class library calls this class, and whoever runs
+/// it installs the implementation that fits:
+///
+/// - a Codename One application gets `com.codename1.impl.CoreJdkHost`, which
+///   delegates to `FileSystemStorage`, `Preferences`, `NetworkManager`, `Log`
+///   and `Display`. The ParparVM ports install it from their `init`.
+/// - a program translated without Codename One (the self-hosted translator,
+///   the backend, a VM test) gets `PosixJdkHost`, which reaches the POSIX file
+///   natives through `java.io.File`.
+/// - anything else gets the defaults below, which are plain Java and touch no
+///   native method, so an application target that never installs a host
+///   cannot link the file natives through this class.
+///
+/// On Java SE and Android the real JDK runs and nothing calls this class.
+/// Copies of it ship in those ports only so that `CoreJdkHost`, which is part
+/// of the core sources, always has its superclass.
+///
+/// The file is kept byte for byte identical in `vm/JavaAPI`, `Ports/CLDC11`,
+/// `Ports/JavaSE` and `Ports/Android`; `CldcJavaApiParityTest` holds them
+/// to that. It may use only API all four class libraries have.
+///
+/// Paths are in the host's own form: absolute, as [#appHome] answers them.
+/// Turning a relative path into one is the caller's job.
+public abstract class JdkHost {
+    /// [#log] level of a debug message.
+    public static final int LOG_DEBUG = 1;
+    /// [#log] level of an informational message.
+    public static final int LOG_INFO = 2;
+    /// [#log] level of a warning.
+    public static final int LOG_WARNING = 3;
+    /// [#log] level of an error.
+    public static final int LOG_ERROR = 4;
+
+    private static final JdkHost DEFAULTS = new Defaults();
+    private static JdkHost current;
+    private static Registry registry;
+    private static Map<String, String> memoryPreferences;
+
+    /// Subclasses are installed with [#install].
+    protected JdkHost() {
+    }
+
+    /// The installed host, or the plain Java defaults when none was installed.
+    public static JdkHost get() {
+        JdkHost h = current;
+        return h == null ? DEFAULTS : h;
+    }
+
+    /// Makes `host` the one [#get] answers; null restores the defaults.
+    /// Called once, while the program starts and before it starts a thread
+    /// of its own.
+    public static void install(JdkHost host) {
+        current = host;
+    }
+
+    /// Makes `r` the registry [#providers] and [#newInstance] read. An
+    /// application's generated start-up code installs it.
+    public static void setRegistry(Registry r) {
+        registry = r;
+    }
+
+    /// The registry [#setRegistry] installed, or null.
+    public static Registry getRegistry() {
+        return registry;
+    }
+
+    // ------------------------------------------------------------------
+    // Files
+
+    /// What is known of `path`, or null when nothing is there.
+    public FileStat fileStat(String path) {
+        return null;
+    }
+
+    /// The names of the entries of the directory `path`, or null when it is
+    /// not a directory.
+    public String[] fileList(String path) throws IOException {
+        return null;
+    }
+
+    /// Opens the file `path` for reading.
+    public InputStream fileRead(String path) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Opens the file `path` for writing, at its end when `append` is true
+    /// and from empty otherwise, creating it when it is not there.
+    public OutputStream fileWrite(String path, boolean append) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Creates the directory `path`; false when it was not created, also
+    /// when something was there already.
+    public boolean fileMkdir(String path) {
+        return false;
+    }
+
+    /// Deletes the file or empty directory `path`; false when it is still
+    /// there or never was.
+    public boolean fileDelete(String path) {
+        return false;
+    }
+
+    /// Moves `from` to `to`, which must not exist. False when it did not
+    /// happen; a host may refuse a move to another directory, and the
+    /// caller then copies.
+    public boolean fileRename(String from, String to) {
+        return false;
+    }
+
+    /// The application's home directory, where a relative path resolves.
+    public String appHome() {
+        return "/";
+    }
+
+    /// A directory for disposable files, or null when the platform has no
+    /// separate one and [#appHome] serves.
+    public String cachesDir() {
+        return null;
+    }
+
+    /// The roots of the file system.
+    public String[] fileRoots() {
+        return new String[] {appHome()};
+    }
+
+    /// The size in bytes of the volume holding `path`, or 0 when unknown.
+    public long fileTotalSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes still free for this program on the volume holding `path`,
+    /// or 0 when unknown.
+    public long fileUsableSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes free on the volume holding `path`, counting what only a
+    /// privileged user may use; [#fileUsableSpace] unless the host knows
+    /// better.
+    public long fileFreeSpace(String path) {
+        return fileUsableSpace(path);
+    }
+
+    /// [#fileTest]: something is at the path.
+    public static final int FILE_EXISTS = 1;
+    /// [#fileTest]: the path is a directory.
+    public static final int FILE_DIRECTORY = 2;
+    /// [#fileTest]: the path is a file that is not a directory.
+    public static final int FILE_REGULAR = 3;
+    /// [#fileTest] and [#fileSet]: the path may be read.
+    public static final int FILE_READABLE = 4;
+    /// [#fileTest] and [#fileSet]: the path may be written.
+    public static final int FILE_WRITABLE = 5;
+    /// [#fileTest] and [#fileSet]: the path may be executed, or for a
+    /// directory, entered.
+    public static final int FILE_EXECUTABLE = 6;
+    /// [#fileTest]: the path is hidden.
+    public static final int FILE_HIDDEN = 7;
+
+    /// Whether `path` has the property `what`, one of the `FILE_` constants.
+    ///
+    /// The defaults read [#fileStat]: a file system without permissions lets
+    /// everything that exists be read and written, a directory be entered and
+    /// nothing be run, and hides a name that starts with a dot.
+    public boolean fileTest(String path, int what) {
+        if (what == FILE_HIDDEN) {
+            int slash = path.lastIndexOf('/');
+            return path.startsWith(".", slash + 1);
+        }
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_DIRECTORY || what == FILE_EXECUTABLE) {
+            return st.isDirectory();
+        }
+        if (what == FILE_REGULAR) {
+            return !st.isDirectory();
+        }
+        return true;
+    }
+
+    /// Grants (`on`) or takes away the permission `what` on `path`, one of
+    /// [#FILE_READABLE], [#FILE_WRITABLE] and [#FILE_EXECUTABLE]; false when
+    /// the path is not left that way.
+    ///
+    /// The defaults change nothing, so they answer whether the path already is
+    /// as asked, by the rules of [#fileTest].
+    public boolean fileSet(String path, int what, boolean on) {
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_EXECUTABLE) {
+            return on == st.isDirectory();
+        }
+        return on;
+    }
+
+    /// The length in bytes of the file `path`; 0 for a directory or when
+    /// nothing is there.
+    public long fileLength(String path) {
+        FileStat st = fileStat(path);
+        return st == null || st.isDirectory() ? 0L : st.length();
+    }
+
+    /// When `path` was last modified, in milliseconds since the epoch; 0 when
+    /// nothing is there.
+    public long fileLastModified(String path) {
+        FileStat st = fileStat(path);
+        return st == null ? 0L : st.lastModified();
+    }
+
+    /// Creates the empty file `path` when nothing is there; false when
+    /// something was.
+    ///
+    /// The default checks and then creates, which is not atomic: two threads
+    /// racing on one path can both be answered true.
+    public boolean fileCreate(String path) throws IOException {
+        if (fileStat(path) != null) {
+            return false;
+        }
+        fileWrite(path, false).close();
+        return true;
+    }
+
+    /// Moves `from` over `to`, replacing the file there. False when it did not
+    /// happen, which is all the defaults answer; the caller then copies.
+    public boolean fileReplace(String from, String to) {
+        return false;
+    }
+
+    /// The absolute `path` with symbolic links, `.` and `..` resolved, or
+    /// null when the host cannot resolve links and the caller should resolve
+    /// the dots by itself.
+    public String fileCanonicalPath(String path) throws IOException {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Preferences
+
+    /// The stored preference `key`, or null. The defaults keep preferences
+    /// in memory, for this run only.
+    public String preference(String key) {
+        return memoryPreference(key, null, false);
+    }
+
+    /// Stores `value` under `key`.
+    public void setPreference(String key, String value) {
+        memoryPreference(key, value, true);
+    }
+
+    /// Removes the preference `key`.
+    public void deletePreference(String key) {
+        memoryPreference(key, null, true);
+    }
+
+    /// Reads `key` from the in-memory preferences, or, when `write` is true,
+    /// stores `value` there (null removes it). One lock: the class library
+    /// runs on several threads where a host leaves this to the defaults.
+    private static synchronized String memoryPreference(String key, String value, boolean write) {
+        if (memoryPreferences == null) {
+            memoryPreferences = new HashMap<String, String>();
+        }
+        if (!write) {
+            return memoryPreferences.get(key);
+        }
+        if (value == null) {
+            return memoryPreferences.remove(key);
+        }
+        return memoryPreferences.put(key, value);
+    }
+
+    // ------------------------------------------------------------------
+    // Network, log and process
+
+    /// Reads `url` with an HTTP GET. A missing resource (404, 410) throws
+    /// `java.io.FileNotFoundException`, any other failure an `IOException`.
+    public InputStream openUrl(String url) throws IOException {
+        throw new IOException("No network: " + url);
+    }
+
+    /// Logs `message` and `thrown`, either of which may be null, at `level`
+    /// ([#LOG_DEBUG] to [#LOG_ERROR]).
+    public void log(int level, String message, Throwable thrown) {
+        if (message != null) {
+            System.err.println(message);
+        }
+        if (thrown != null) {
+            thrown.printStackTrace();
+        }
+    }
+
+    /// The platform's answer for the system property `key`, or null. The
+    /// class library answers the properties it defines itself.
+    public String property(String key) {
+        return null;
+    }
+
+    /// Asks the platform to close the application, after the shutdown hooks
+    /// ran; `Runtime.exit` ends the process itself if this returns. The
+    /// defaults leave it to that.
+    public void exit(int status) {
+    }
+
+    /// Called when the program installs a default uncaught exception
+    /// handler, so that a host whose UI thread catches what its tasks throw
+    /// can hand that to `Thread.getDefaultUncaughtExceptionHandler()` too.
+    /// Called on every such install; the defaults do nothing.
+    public void watchUncaughtExceptions() {
+    }
+
+    // ------------------------------------------------------------------
+    // Threads
+
+    /// Whether the caller is the UI thread, which must not block.
+    public boolean isUiThread() {
+        return false;
+    }
+
+    /// Runs `task`, which blocks, where blocking is allowed: off the UI
+    /// thread while that thread keeps serving events, or right here.
+    public void blockUi(Runnable task) {
+        task.run();
+    }
+
+    // ------------------------------------------------------------------
+    // Resources, services and locale
+
+    /// Opens the application resource `name` (a path such as
+    /// `META-INF/services/x`, without a leading slash), or null.
+    public InputStream resource(String name) {
+        return null;
+    }
+
+    /// The class names of the providers of `service` the application
+    /// declares, from the [Registry]; empty when there is none.
+    public String[] providers(String service) {
+        Registry r = registry;
+        String[] names = r == null ? null : r.providers(service);
+        return names == null ? new String[0] : names;
+    }
+
+    /// A new instance of the application class `className`, made by the
+    /// [Registry] without reflection; null when it cannot make one.
+    public Object newInstance(String className) {
+        Registry r = registry;
+        return r == null ? null : r.newInstance(className);
+    }
+
+    /// The class of the application class `className`, as the [Registry]
+    /// knows it, so that its type can be tested without creating one; null
+    /// when it does not know the class.
+    public Class<?> type(String className) {
+        Registry r = registry;
+        return r == null ? null : r.type(className);
+    }
+
+    /// The decimal separator, grouping separator and currency symbol of the
+    /// device's locale, any of them null when unknown; or null when the
+    /// platform cannot tell.
+    public String[] localeNumberSymbols() {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Security
+
+    /// Fills `out` with cryptographically secure random bytes.
+    public void randomBytes(byte[] out) {
+        throw new UnsupportedOperationException("No secure random source");
+    }
+
+    /// A new digest for `algorithm` (`MD5`, `SHA-1`, `SHA-256` and the like),
+    /// or null when the platform has none.
+    public Digest digest(String algorithm) {
+        return null;
+    }
+
+    /// The attributes [#fileStat] reports.
+    public static final class FileStat {
+        private final boolean directory;
+        private final long length;
+        private final long lastModified;
+
+        /// A file or, when `directory` is true, a directory.
+        public FileStat(boolean directory, long length, long lastModified) {
+            this.directory = directory;
+            this.length = length;
+            this.lastModified = lastModified;
+        }
+
+        /// Whether it is a directory.
+        public boolean isDirectory() {
+            return directory;
+        }
+
+        /// The length in bytes of a file; 0 for a directory.
+        public long length() {
+            return length;
+        }
+
+        /// When it was last modified, in milliseconds since the epoch, or 0.
+        public long lastModified() {
+            return lastModified;
+        }
+    }
+
+    /// A running message digest, as [#digest] makes it.
+    public interface Digest {
+        /// Feeds `length` bytes of `data` from `offset`.
+        void update(byte[] data, int offset, int length);
+
+        /// Finishes the digest and resets it.
+        byte[] digest();
+
+        /// Discards what was fed.
+        void reset();
+
+        /// The length of the digest in bytes.
+        int length();
+    }
+
+    /// What an application declares for `java.util.ServiceLoader` and
+    /// `java.util.ResourceBundle`, generated with the application. Once one
+    /// is installed it is the whole answer: the class library creates no
+    /// class from its name and reads no services file.
+    public interface Registry {
+        /// The provider class names declared for `service`, or null.
+        String[] providers(String service);
+
+        /// A new instance of `className`, or null.
+        Object newInstance(String className);
+
+        /// The class `className`, or null when the registry does not know it.
+        Class<?> type(String className);
+    }
+
+    /// The host [#get] answers when none was installed.
+    private static final class Defaults extends JdkHost {
+    }
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedInputStream.java b/Ports/CLDC11/src/java/io/BufferedInputStream.java
similarity index 68%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedInputStream.java
rename to Ports/CLDC11/src/java/io/BufferedInputStream.java
index c054bb0d052..6c7efca43ef 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedInputStream.java
+++ b/Ports/CLDC11/src/java/io/BufferedInputStream.java
@@ -20,26 +20,35 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import java.io.IOException;
-import java.io.InputStream;
-
-/// `java.io.BufferedInputStream` for the Codename One runtime, with mark and
-/// reset support.
+/// Reads from another stream through a buffer, so that many small reads
+/// become few large ones, and supports `mark` and `reset`.
+///
+/// Like most streams, it is for one thread at a time.
 public class BufferedInputStream extends FilterInputStream {
 
-    /// Null once the stream is closed, which every read checks.
+    /// The buffer; null once the stream is closed, which every read checks.
     protected byte[] buf;
+    /// How many bytes of [#buf] are valid.
     protected int count;
+    /// The index in [#buf] of the next byte to read.
     protected int pos;
+    /// The index in [#buf] of the mark, or -1 when there is none.
     protected int markpos = -1;
+    /// How far past the mark a read may go before the mark is dropped.
     protected int marklimit;
 
+    /// Buffers `in` with an 8192 byte buffer.
     public BufferedInputStream(InputStream in) {
         this(in, 8192);
     }
 
+    /// Buffers `in` with a buffer of `size` bytes.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
     public BufferedInputStream(InputStream in, int size) {
         super(in);
         if (size <= 0) {
@@ -54,6 +63,8 @@ private void ensureOpen() throws IOException {
         }
     }
 
+    /// Refills the buffer once it is consumed, keeping the bytes from a
+    /// valid mark on and growing the buffer up to the mark limit.
     private void fill() throws IOException {
         if (markpos < 0) {
             pos = 0;
@@ -67,7 +78,14 @@ private void fill() throws IOException {
                 markpos = -1;
                 pos = 0;
             } else {
-                byte[] grown = new byte[Math.min(buf.length * 2, Math.max(marklimit, buf.length + 1))];
+                int grownSize = buf.length * 2;
+                if (grownSize > marklimit) {
+                    grownSize = marklimit;
+                }
+                if (grownSize <= buf.length) {
+                    grownSize = buf.length + 1;
+                }
+                byte[] grown = new byte[grownSize];
                 System.arraycopy(buf, 0, grown, 0, pos);
                 buf = grown;
             }
@@ -91,12 +109,36 @@ public int read() throws IOException {
         return buf[pos++] & 0xff;
     }
 
+    /// Reads as the JDK does: on past the buffer while the stream underneath
+    /// has bytes available without blocking, so a small buffer does not make
+    /// every read a short one.
     @Override
     public int read(byte[] b, int off, int len) throws IOException {
         ensureOpen();
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
         if (len == 0) {
             return 0;
         }
+        int total = 0;
+        while (true) {
+            int n = readOnce(b, off + total, len - total);
+            if (n <= 0) {
+                return total == 0 ? n : total;
+            }
+            total += n;
+            if (total >= len) {
+                return total;
+            }
+            InputStream input = in;
+            if (input != null && input.available() <= 0) {
+                return total;
+            }
+        }
+    }
+
+    private int readOnce(byte[] b, int off, int len) throws IOException {
         int avail = count - pos;
         if (avail <= 0) {
             if (len >= buf.length && markpos < 0) {
@@ -108,7 +150,7 @@ public int read(byte[] b, int off, int len) throws IOException {
                 return -1;
             }
         }
-        int n = Math.min(avail, len);
+        int n = avail < len ? avail : len;
         System.arraycopy(buf, pos, b, off, n);
         pos += n;
         return n;
@@ -131,7 +173,7 @@ public long skip(long n) throws IOException {
                 return 0;
             }
         }
-        long skipped = Math.min(avail, n);
+        long skipped = avail < n ? avail : n;
         pos += (int) skipped;
         return skipped;
     }
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedOutputStream.java b/Ports/CLDC11/src/java/io/BufferedOutputStream.java
similarity index 85%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedOutputStream.java
rename to Ports/CLDC11/src/java/io/BufferedOutputStream.java
index 02494565279..7494991e8e4 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedOutputStream.java
+++ b/Ports/CLDC11/src/java/io/BufferedOutputStream.java
@@ -20,25 +20,31 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import java.io.IOException;
-import java.io.OutputStream;
-
-/// `java.io.BufferedOutputStream` for the Codename One runtime.
+/// Writes to another stream through a buffer, so that many small writes
+/// become few large ones.
 public class BufferedOutputStream extends FilterOutputStream {
 
+    /// The buffer.
     protected byte[] buf;
+    /// How many bytes of [#buf] are waiting to be written.
     protected int count;
     /// Set by [#close()]. The buffer and the underlying stream are kept, so
     /// without it a later write would land in the buffer and a second close
     /// could hand those bytes to a stream whose own close is a no-op.
     private boolean closed;
 
+    /// Buffers `out` with an 8192 byte buffer.
     public BufferedOutputStream(OutputStream out) {
         this(out, 8192);
     }
 
+    /// Buffers `out` with a buffer of `size` bytes.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
     public BufferedOutputStream(OutputStream out, int size) {
         super(out);
         if (size <= 0) {
@@ -72,6 +78,9 @@ public void write(int b) throws IOException {
     @Override
     public void write(byte[] b, int off, int len) throws IOException {
         ensureOpen();
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
         if (len >= buf.length) {
             flushBuffer();
             out.write(b, off, len);
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedReader.java b/Ports/CLDC11/src/java/io/BufferedReader.java
similarity index 72%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedReader.java
rename to Ports/CLDC11/src/java/io/BufferedReader.java
index dd5b62fdb4c..c3d0ccc494c 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedReader.java
+++ b/Ports/CLDC11/src/java/io/BufferedReader.java
@@ -20,21 +20,18 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import java.io.IOException;
-import java.io.Reader;
-
-/// `java.io.BufferedReader` for the Codename One runtime, which has no
-/// buffered reader. Android code is compiled against the JDK class and the
-/// build's remap step points it here, together with the compatibility
-/// runtime's own uses.
+/// Reads text from another reader through a buffer, and reads it a line at
+/// a time. A line ends at `\n`, `\r` or `\r\n`.
+///
+/// Like most readers, it is for one thread at a time.
 public class BufferedReader extends Reader {
 
-    private final Reader in;
     private static final int UNMARKED = -1;
     private static final int INVALIDATED = -2;
 
+    private final Reader in;
     /// Null once the reader is closed, which every operation checks.
     private char[] buf;
     private int pos;
@@ -45,11 +42,18 @@ public class BufferedReader extends Reader {
     private int readAheadLimit;
     private boolean markedSkipLf;
 
+    /// Buffers `in` with an 8192 character buffer.
     public BufferedReader(Reader in) {
         this(in, 8192);
     }
 
+    /// Buffers `in` with a buffer of `size` characters.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
     public BufferedReader(Reader in, int size) {
+        super(in);
         if (size <= 0) {
             throw new IllegalArgumentException("Buffer size <= 0");
         }
@@ -57,15 +61,15 @@ public BufferedReader(Reader in, int size) {
         this.buf = new char[size];
     }
 
-    /// Refills the buffer once it is consumed. A valid mark keeps the
-    /// characters from the mark on at the start of the buffer, growing it up
-    /// to the read-ahead limit; reading past that limit drops the mark.
     private void ensureOpen() throws IOException {
         if (buf == null) {
             throw new IOException("Stream closed");
         }
     }
 
+    /// Refills the buffer once it is consumed. A valid mark keeps the
+    /// characters from the mark on at the start of the buffer, growing it up
+    /// to the read-ahead limit; reading past that limit drops the mark.
     private boolean fill() throws IOException {
         int dst = 0;
         if (markedChar >= 0) {
@@ -117,6 +121,9 @@ public int read() throws IOException {
     @Override
     public int read(char[] cbuf, int off, int len) throws IOException {
         ensureOpen();
+        if (off < 0 || len < 0 || len > cbuf.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
         if (len == 0) {
             return 0;
         }
@@ -134,6 +141,11 @@ public int read(char[] cbuf, int off, int len) throws IOException {
         return n;
     }
 
+    /// Reads a line of text, without its terminator.
+    ///
+    /// #### Returns
+    ///
+    /// the line, or null at the end of the text
     public String readLine() throws IOException {
         ensureOpen();
         StringBuilder sb = null;
@@ -179,6 +191,9 @@ public boolean ready() throws IOException {
 
     @Override
     public long skip(long n) throws IOException {
+        if (n < 0) {
+            throw new IllegalArgumentException("skip value is negative");
+        }
         ensureOpen();
         long skipped = 0;
         while (skipped < n && read() >= 0) {
@@ -221,4 +236,59 @@ public void close() throws IOException {
         buf = null;
         in.close();
     }
+
+    /// The remaining lines, read as the stream asks for them. A read that
+    /// fails surfaces as an UncheckedIOException; closing the stream does
+    /// not close this reader, as in the JDK.
+    public java.util.stream.Stream<String> lines() {
+        return java.util.stream.StreamSupport.stream(
+                java.util.Spliterators.spliteratorUnknownSize(new LineIterator(this),
+                        java.util.Spliterator.ORDERED | java.util.Spliterator.NONNULL), false);
+    }
+
+    /// Reads one line ahead, so `hasNext` can answer without losing one.
+    private static final class LineIterator implements java.util.Iterator<String> {
+        private final BufferedReader reader;
+        private String next;
+        private boolean done;
+
+        LineIterator(BufferedReader reader) {
+            this.reader = reader;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (next != null) {
+                return true;
+            }
+            if (done) {
+                return false;
+            }
+            try {
+                next = reader.readLine();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+            if (next == null) {
+                done = true;
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        public String next() {
+            if (!hasNext()) {
+                throw new java.util.NoSuchElementException();
+            }
+            String line = next;
+            next = null;
+            return line;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
 }
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedWriter.java b/Ports/CLDC11/src/java/io/BufferedWriter.java
similarity index 85%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedWriter.java
rename to Ports/CLDC11/src/java/io/BufferedWriter.java
index 6402631b82f..89377b497b1 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/BufferedWriter.java
+++ b/Ports/CLDC11/src/java/io/BufferedWriter.java
@@ -20,12 +20,9 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import java.io.IOException;
-import java.io.Writer;
-
-/// `java.io.BufferedWriter` for the Codename One runtime; see [BufferedReader].
+/// Writes text to another writer through a buffer.
 public class BufferedWriter extends Writer {
 
     private final Writer out;
@@ -36,11 +33,21 @@ public class BufferedWriter extends Writer {
     /// could hand that data to a writer whose own close is a no-op.
     private boolean closed;
 
+    /// Buffers `out` with an 8192 character buffer.
     public BufferedWriter(Writer out) {
         this(out, 8192);
     }
 
+    /// Buffers `out` with a buffer of `size` characters.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
     public BufferedWriter(Writer out, int size) {
+        super(out);
+        if (size <= 0) {
+            throw new IllegalArgumentException("Buffer size <= 0");
+        }
         this.out = out;
         this.buf = new char[size];
     }
@@ -70,6 +77,9 @@ public void write(int c) throws IOException {
     @Override
     public void write(char[] cbuf, int off, int len) throws IOException {
         ensureOpen();
+        if (off < 0 || len < 0 || len > cbuf.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
         if (len >= buf.length) {
             flushBuffer();
             out.write(cbuf, off, len);
@@ -90,6 +100,7 @@ public void write(String s, int off, int len) throws IOException {
         write(c, 0, len);
     }
 
+    /// Writes a line separator, `\n`.
     public void newLine() throws IOException {
         write('\n');
     }
diff --git a/Ports/CLDC11/src/java/io/ByteArrayOutputStream.java b/Ports/CLDC11/src/java/io/ByteArrayOutputStream.java
index 59ca3736a2b..545490821d5 100644
--- a/Ports/CLDC11/src/java/io/ByteArrayOutputStream.java
+++ b/Ports/CLDC11/src/java/io/ByteArrayOutputStream.java
@@ -83,4 +83,16 @@ public void write(int b){
         return; //TODO codavaj!!
     }
 
+    @Deprecated
+    public String toString(int hibyte) {
+        return null;
+    }
+
+    /// The contents decoded with `charset`.
+    public synchronized String toString(java.nio.charset.Charset charset) {
+        return null;
+    }
+
+    public synchronized void writeTo(OutputStream out) throws IOException {
+    }
 }
diff --git a/Ports/CLDC11/src/java/io/Closeable.java b/Ports/CLDC11/src/java/io/Closeable.java
new file mode 100644
index 00000000000..529e9a57652
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/Closeable.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// A source or destination of data that holds something until it is closed:
+/// every stream, reader and writer.
+public interface Closeable extends AutoCloseable {
+    /// Closes this and releases what it holds. Closing it again has no effect.
+    @Override
+    void close() throws IOException;
+}
diff --git a/Ports/CLDC11/src/java/io/Externalizable.java b/Ports/CLDC11/src/java/io/Externalizable.java
new file mode 100644
index 00000000000..b4134541904
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/Externalizable.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// An object that writes and reads its own state through [ObjectOutput] and
+/// [ObjectInput].
+public interface Externalizable extends Serializable {
+
+    /// Restores this object's state from `in`.
+    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
+
+    /// Writes this object's state to `out`.
+    void writeExternal(ObjectOutput out) throws IOException;
+}
diff --git a/Ports/CLDC11/src/java/io/File.java b/Ports/CLDC11/src/java/io/File.java
new file mode 100644
index 00000000000..1fece0caed6
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/File.java
@@ -0,0 +1,763 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+import com.codename1.impl.JdkHost;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+/// A path in the file system, and the operations on the file or directory at
+/// it.
+///
+/// Every operation goes to the platform's file system through
+/// `com.codename1.impl.JdkHost`: on a device that is `FileSystemStorage`, in a
+/// program translated without Codename One it is the native file system.
+///
+/// #### Paths
+///
+/// A path is kept with duplicate separators collapsed and no trailing one,
+/// and a backslash is read as a separator. It is absolute when it starts with
+/// `/`, with a drive (`C:/`), or with the `file:` scheme Codename One names its
+/// files with. A relative path is resolved against the application's home
+/// directory, which in a program run from a shell is the working directory.
+///
+/// #### What differs from a desktop file system
+///
+/// - Where the file system has no permissions, every file that exists may be
+///   read and written, a directory may be entered and nothing may be run; the
+///   permission setters answer whether the file already is as asked.
+/// - [#setLastModified(long)] answers false: no platform lets it be set.
+/// - [#deleteOnExit()] does nothing.
+/// - Where the file system cannot resolve symbolic links,
+///   [#getCanonicalPath()] answers the absolute path with `.` and `..`
+///   resolved.
+public class File implements Serializable, Comparable<File> {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The separator of the names in a path.
+    public static final char separatorChar = '/';
+    /// [#separatorChar] as a string.
+    public static final String separator = "/";
+    /// The separator of the paths in a list of them.
+    public static final char pathSeparatorChar = ':';
+    /// [#pathSeparatorChar] as a string.
+    public static final String pathSeparator = ":";
+
+    private static final String SCHEME = "file:";
+
+    private final String path;
+
+    /// The file at `pathname`.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `pathname` is null
+    public File(String pathname) {
+        if (pathname == null) {
+            throw new NullPointerException();
+        }
+        this.path = normalize(pathname);
+    }
+
+    /// The file `child` in the directory `parent`. A null `parent` makes it
+    /// `new File(child)`, an empty one the root.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `child` is null
+    public File(String parent, String child) {
+        if (child == null) {
+            throw new NullPointerException();
+        }
+        if (parent == null) {
+            this.path = normalize(child);
+        } else if (parent.length() == 0) {
+            this.path = join(separator, child);
+        } else {
+            this.path = join(normalize(parent), child);
+        }
+    }
+
+    /// The file `child` in the directory `parent`. A null `parent` makes it
+    /// `new File(child)`, an empty one the root.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `child` is null
+    public File(File parent, String child) {
+        if (child == null) {
+            throw new NullPointerException();
+        }
+        if (parent == null) {
+            this.path = normalize(child);
+        } else if (parent.path.length() == 0) {
+            this.path = join(separator, child);
+        } else {
+            this.path = join(parent.path, child);
+        }
+    }
+
+    /// The file a `file:` URI names.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `uri` is not an absolute,
+    ///   hierarchical `file:` URI with a path and without an authority, a query
+    ///   or a fragment
+    public File(URI uri) {
+        if (!uri.isAbsolute()) {
+            throw new IllegalArgumentException("URI is not absolute");
+        }
+        if (uri.isOpaque()) {
+            throw new IllegalArgumentException("URI is not hierarchical");
+        }
+        if (!"file".equalsIgnoreCase(uri.getScheme())) {
+            throw new IllegalArgumentException("URI scheme is not \"file\"");
+        }
+        if (present(uri.getRawAuthority())) {
+            throw new IllegalArgumentException("URI has an authority component");
+        }
+        if (present(uri.getRawFragment())) {
+            throw new IllegalArgumentException("URI has a fragment component");
+        }
+        if (present(uri.getRawQuery())) {
+            throw new IllegalArgumentException("URI has a query component");
+        }
+        String p = uri.getPath();
+        if (p == null || p.length() == 0) {
+            throw new IllegalArgumentException("URI path component is empty");
+        }
+        this.path = normalize(p);
+    }
+
+    /// Whether a URI has the component. An empty one counts as none: the
+    /// runtime's `URI` answers an empty authority for `file:///x`, where the
+    /// JDK's answers null.
+    private static boolean present(String component) {
+        return component != null && component.length() > 0;
+    }
+
+    private static JdkHost host() {
+        return JdkHost.get();
+    }
+
+    /// How many leading characters of `p` are its root: the scheme and its
+    /// slashes, `/`, a drive with its separator, or none.
+    private static int rootLength(String p) {
+        if (p.startsWith(SCHEME)) {
+            int i = SCHEME.length();
+            while (i < p.length() && p.charAt(i) == '/') {
+                i++;
+            }
+            return i;
+        }
+        if (p.startsWith("/")) {
+            return 1;
+        }
+        if (p.length() >= 3 && p.charAt(1) == ':' && p.charAt(2) == '/' && isLetter(p.charAt(0))) {
+            return 3;
+        }
+        return 0;
+    }
+
+    private static boolean isLetter(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+    }
+
+    /// Reads a backslash as a separator, collapses duplicate separators
+    /// outside the scheme and drops a trailing one, as `java.io.File` does.
+    private static String normalize(String p) {
+        StringBuilder sb = new StringBuilder(p.length());
+        int start = 0;
+        if (p.startsWith("file://")) {
+            sb.append("file://");
+            start = 7;
+        }
+        char prev = 0;
+        for (int i = start; i < p.length(); i++) {
+            char c = p.charAt(i);
+            if (c == '\\') {
+                c = '/';
+            }
+            if (c == '/' && prev == '/') {
+                continue;
+            }
+            sb.append(c);
+            prev = c;
+        }
+        int min = start + 1;
+        while (sb.length() > min && sb.charAt(sb.length() - 1) == '/') {
+            sb.setLength(sb.length() - 1);
+        }
+        return sb.toString();
+    }
+
+    private static String join(String parent, String child) {
+        String c = normalize(child);
+        if (parent.length() == 0) {
+            return c;
+        }
+        if (c.startsWith("/")) {
+            c = c.substring(1);
+        }
+        if (c.length() == 0) {
+            return parent;
+        }
+        return parent.endsWith("/") ? parent + c : parent + "/" + c;
+    }
+
+    /// The path the host is asked about: this one when it is absolute, else
+    /// resolved against the application's home directory.
+    String hostPath() {
+        if (path.startsWith("file:/") || (rootLength(path) > 0 && !path.startsWith(SCHEME))) {
+            return path;
+        }
+        // A relative path, a "file:" with no slash after it included: a
+        // device's file system throws for anything but an absolute path.
+        String rel = path.startsWith(SCHEME) ? path.substring(SCHEME.length()) : path;
+        String home = host().appHome();
+        if (rel.length() == 0) {
+            return home;
+        }
+        return home.endsWith("/") ? home + rel : home + "/" + rel;
+    }
+
+    /// The last name of the path, or the whole path when it has one name.
+    public String getName() {
+        int i = path.lastIndexOf('/');
+        return i < 0 ? path : path.substring(i + 1);
+    }
+
+    /// The path as it was given, normalized.
+    public String getPath() {
+        return path;
+    }
+
+    /// The path resolved against the application's home directory when it is
+    /// relative.
+    public String getAbsolutePath() {
+        return hostPath();
+    }
+
+    /// The file at [#getAbsolutePath()].
+    public File getAbsoluteFile() {
+        return new File(getAbsolutePath());
+    }
+
+    /// The absolute path with symbolic links, `.` and `..` resolved. Code
+    /// checks a canonical path against a directory to reject a name like
+    /// `root/../outside`, so where the file system cannot resolve links the
+    /// dots are still resolved; a `..` at the root stays at the root.
+    public String getCanonicalPath() throws IOException {
+        String abs = hostPath();
+        String canonical = host().fileCanonicalPath(abs);
+        return canonical != null ? canonical : resolveDots(abs);
+    }
+
+    /// The file at [#getCanonicalPath()].
+    public File getCanonicalFile() throws IOException {
+        return new File(getCanonicalPath());
+    }
+
+    private static String resolveDots(String p) {
+        int start = rootLength(p);
+        ArrayList<String> segs = new ArrayList<String>();
+        int s = start;
+        for (int i = start; i <= p.length(); i++) {
+            if (i == p.length() || p.charAt(i) == '/') {
+                String seg = p.substring(s, i);
+                if (seg.equals("..")) {
+                    if (!segs.isEmpty()) {
+                        segs.remove(segs.size() - 1);
+                    }
+                } else if (seg.length() > 0 && !seg.equals(".")) {
+                    segs.add(seg);
+                }
+                s = i + 1;
+            }
+        }
+        StringBuilder sb = new StringBuilder(p.length());
+        sb.append(p.substring(0, start));
+        for (int i = 0; i < segs.size(); i++) {
+            if (i > 0) {
+                sb.append('/');
+            }
+            sb.append(segs.get(i));
+        }
+        return sb.toString();
+    }
+
+    /// The path without its last name, or null when it has no parent.
+    public String getParent() {
+        int i = path.lastIndexOf('/');
+        if (i < 0) {
+            return null;
+        }
+        int root = rootLength(path);
+        if (i < root) {
+            return path.length() > root ? path.substring(0, root) : null;
+        }
+        if (i == root - 1) {
+            return path.length() > root ? path.substring(0, root) : null;
+        }
+        return path.substring(0, i);
+    }
+
+    /// The file at [#getParent()], or null.
+    public File getParentFile() {
+        String p = getParent();
+        return p == null ? null : new File(p);
+    }
+
+    /// Whether the path is absolute.
+    public boolean isAbsolute() {
+        return rootLength(path) > 0;
+    }
+
+    /// Whether something is at the path.
+    public boolean exists() {
+        return host().fileTest(hostPath(), JdkHost.FILE_EXISTS);
+    }
+
+    /// Whether the path is a directory.
+    public boolean isDirectory() {
+        return host().fileTest(hostPath(), JdkHost.FILE_DIRECTORY);
+    }
+
+    /// Whether the path is a file that is not a directory.
+    public boolean isFile() {
+        return host().fileTest(hostPath(), JdkHost.FILE_REGULAR);
+    }
+
+    /// Whether the file is hidden; on most file systems, whether its name
+    /// starts with a dot.
+    public boolean isHidden() {
+        return host().fileTest(hostPath(), JdkHost.FILE_HIDDEN);
+    }
+
+    /// Whether the file may be read.
+    public boolean canRead() {
+        return host().fileTest(hostPath(), JdkHost.FILE_READABLE);
+    }
+
+    /// Whether the file may be written.
+    public boolean canWrite() {
+        return host().fileTest(hostPath(), JdkHost.FILE_WRITABLE);
+    }
+
+    /// Whether the file may be run, or the directory entered.
+    public boolean canExecute() {
+        return host().fileTest(hostPath(), JdkHost.FILE_EXECUTABLE);
+    }
+
+    /// Lets the file be read, or not; false when it is not left as asked.
+    public boolean setReadable(boolean readable, boolean ownerOnly) {
+        return host().fileSet(hostPath(), JdkHost.FILE_READABLE, readable);
+    }
+
+    /// Lets the file be read, or not; false when it is not left as asked.
+    public boolean setReadable(boolean readable) {
+        return setReadable(readable, true);
+    }
+
+    /// Lets the file be written, or not; false when it is not left as asked.
+    public boolean setWritable(boolean writable, boolean ownerOnly) {
+        return host().fileSet(hostPath(), JdkHost.FILE_WRITABLE, writable);
+    }
+
+    /// Lets the file be written, or not; false when it is not left as asked.
+    public boolean setWritable(boolean writable) {
+        return setWritable(writable, true);
+    }
+
+    /// Lets the file be run, or not; false when it is not left as asked.
+    public boolean setExecutable(boolean executable, boolean ownerOnly) {
+        return host().fileSet(hostPath(), JdkHost.FILE_EXECUTABLE, executable);
+    }
+
+    /// Lets the file be run, or not; false when it is not left as asked.
+    public boolean setExecutable(boolean executable) {
+        return setExecutable(executable, true);
+    }
+
+    /// Stops the file being written; false when it still can be.
+    public boolean setReadOnly() {
+        return host().fileSet(hostPath(), JdkHost.FILE_WRITABLE, false);
+    }
+
+    /// Answers false: no platform lets a file's time be set.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `time` is negative
+    public boolean setLastModified(long time) {
+        if (time < 0) {
+            throw new IllegalArgumentException("Negative time");
+        }
+        return false;
+    }
+
+    /// The length of the file in bytes; 0 for a directory or when nothing is
+    /// there.
+    public long length() {
+        return host().fileLength(hostPath());
+    }
+
+    /// When the file was last modified, in milliseconds since the epoch; 0
+    /// when nothing is there.
+    public long lastModified() {
+        return host().fileLastModified(hostPath());
+    }
+
+    /// The size of the volume holding the file, or 0 when unknown.
+    public long getTotalSpace() {
+        return host().fileTotalSpace(hostPath());
+    }
+
+    /// The bytes free on the volume holding the file, or 0 when unknown.
+    public long getFreeSpace() {
+        return host().fileFreeSpace(hostPath());
+    }
+
+    /// The bytes this program may still write on the volume holding the
+    /// file, or 0 when unknown.
+    public long getUsableSpace() {
+        return host().fileUsableSpace(hostPath());
+    }
+
+    /// Creates the file, empty, when nothing is at the path.
+    ///
+    /// #### Returns
+    ///
+    /// true when it was created, false when something was there
+    ///
+    /// #### Throws
+    ///
+    /// - `IOException`: when the directory it would be in does not exist, or
+    ///   the file could not be created
+    public boolean createNewFile() throws IOException {
+        File parent = getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new IOException("No such file or directory: " + getParent());
+        }
+        return host().fileCreate(hostPath());
+    }
+
+    /// Deletes the file, or the directory when it is empty.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was deleted
+    public boolean delete() {
+        return host().fileDelete(hostPath());
+    }
+
+    /// Does nothing: nothing is deleted when the program ends.
+    public void deleteOnExit() {
+    }
+
+    /// Creates the directory, in a parent that must exist.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was created
+    public boolean mkdir() {
+        return host().fileMkdir(hostPath());
+    }
+
+    /// Creates the directory and the parents it needs.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was created; false also when it already existed
+    public boolean mkdirs() {
+        if (exists()) {
+            return false;
+        }
+        if (mkdir()) {
+            return true;
+        }
+        File p = getParentFile();
+        return p != null && (p.mkdirs() || p.exists()) && mkdir();
+    }
+
+    /// Moves the file or directory to `dest`. A file replaces a file already
+    /// there. Where the platform cannot move a file in place, it is copied and
+    /// the original deleted; when the original will not go, the copy is taken
+    /// back unless it replaced something.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was moved
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `dest` is null
+    public boolean renameTo(File dest) {
+        if (dest == null) {
+            throw new NullPointerException();
+        }
+        JdkHost h = host();
+        String from = hostPath();
+        String to = dest.hostPath();
+        if (!h.fileTest(from, JdkHost.FILE_EXISTS)) {
+            return false;
+        }
+        // A file renamed onto itself is already where it was asked to be.
+        // The copy below would open the same file for reading and writing,
+        // truncating it, and then delete it.
+        if (resolveDots(from).equals(resolveDots(to))) {
+            return true;
+        }
+        boolean replacing = h.fileTest(to, JdkHost.FILE_EXISTS);
+        if (replacing ? h.fileReplace(from, to) : h.fileRename(from, to)) {
+            return true;
+        }
+        if (h.fileTest(from, JdkHost.FILE_DIRECTORY) || (replacing && h.fileTest(to, JdkHost.FILE_DIRECTORY))) {
+            return false;
+        }
+        try {
+            InputStream in = h.fileRead(from);
+            try {
+                OutputStream out = h.fileWrite(to, false);
+                try {
+                    byte[] buffer = new byte[8192];
+                    int n;
+                    while ((n = in.read(buffer, 0, buffer.length)) >= 0) {
+                        out.write(buffer, 0, n);
+                    }
+                } finally {
+                    out.close();
+                }
+            } finally {
+                in.close();
+            }
+        } catch (IOException e) {
+            return false;
+        }
+        // The move only happened if the source is gone. When it cannot be
+        // removed the rename fails, and a copy that created the destination
+        // is taken back so the file is left where it was; one that replaced
+        // an existing destination stays, as deleting it would lose both.
+        h.fileDelete(from);
+        if (h.fileTest(from, JdkHost.FILE_EXISTS)) {
+            if (!replacing) {
+                h.fileDelete(to);
+            }
+            return false;
+        }
+        return true;
+    }
+
+    /// The names of the entries of the directory, or null when this is not a
+    /// directory.
+    public String[] list() {
+        String[] names;
+        try {
+            names = host().fileList(hostPath());
+        } catch (IOException e) {
+            return null;
+        }
+        if (names == null) {
+            return null;
+        }
+        String[] out = new String[names.length];
+        for (int i = 0; i < names.length; i++) {
+            String n = names[i];
+            while (n.endsWith("/")) {
+                n = n.substring(0, n.length() - 1);
+            }
+            int slash = n.lastIndexOf('/');
+            out[i] = slash < 0 ? n : n.substring(slash + 1);
+        }
+        return out;
+    }
+
+    /// The names of the entries of the directory that `filter` accepts, or
+    /// null when this is not a directory. A null `filter` accepts all.
+    public String[] list(FilenameFilter filter) {
+        String[] names = list();
+        if (names == null || filter == null) {
+            return names;
+        }
+        List<String> out = new ArrayList<String>();
+        for (int i = 0; i < names.length; i++) {
+            if (filter.accept(this, names[i])) {
+                out.add(names[i]);
+            }
+        }
+        return out.toArray(new String[out.size()]);
+    }
+
+    /// The entries of the directory, or null when this is not a directory.
+    public File[] listFiles() {
+        return files(list());
+    }
+
+    /// The entries of the directory whose names `filter` accepts, or null when
+    /// this is not a directory. A null `filter` accepts all.
+    public File[] listFiles(FilenameFilter filter) {
+        return files(list(filter));
+    }
+
+    /// The entries of the directory that `filter` accepts, or null when this
+    /// is not a directory. A null `filter` accepts all.
+    public File[] listFiles(FileFilter filter) {
+        File[] all = listFiles();
+        if (all == null || filter == null) {
+            return all;
+        }
+        List<File> out = new ArrayList<File>();
+        for (int i = 0; i < all.length; i++) {
+            if (filter.accept(all[i])) {
+                out.add(all[i]);
+            }
+        }
+        return out.toArray(new File[out.size()]);
+    }
+
+    private File[] files(String[] names) {
+        if (names == null) {
+            return null;
+        }
+        File[] out = new File[names.length];
+        for (int i = 0; i < names.length; i++) {
+            out[i] = new File(this, names[i]);
+        }
+        return out;
+    }
+
+    /// Creates an empty file named `prefix`, a number and `suffix` in the
+    /// directory for disposable files.
+    public static File createTempFile(String prefix, String suffix) throws IOException {
+        return createTempFile(prefix, suffix, null);
+    }
+
+    /// Creates an empty file named `prefix`, a number and `suffix` (`.tmp`
+    /// when null) in `directory`, or in the directory for disposable files
+    /// when that is null. Nothing deletes it.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `prefix` is shorter than three
+    ///   characters
+    /// - `IOException`: when the file could not be created
+    public static File createTempFile(String prefix, String suffix, File directory) throws IOException {
+        if (prefix.length() < 3) {
+            throw new IllegalArgumentException("Prefix string too short");
+        }
+        File dir = directory;
+        if (dir == null) {
+            JdkHost h = host();
+            String caches = h.cachesDir();
+            dir = new File(caches != null ? caches : h.appHome());
+        }
+        String s = suffix == null ? ".tmp" : suffix;
+        long n = System.currentTimeMillis();
+        while (true) {
+            File f = new File(dir, prefix + n + s);
+            if (f.createNewFile()) {
+                return f;
+            }
+            if (!f.exists()) {
+                throw new IOException("Unable to create temporary file " + f.getPath());
+            }
+            n++;
+        }
+    }
+
+    /// The roots of the file system.
+    public static File[] listRoots() {
+        String[] roots = host().fileRoots();
+        File[] out = new File[roots == null ? 0 : roots.length];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = new File(roots[i]);
+        }
+        return out;
+    }
+
+    /// Compares the paths.
+    @Override
+    public int compareTo(File other) {
+        return path.compareTo(other.path);
+    }
+
+    /// Whether `o` is a file with the same path.
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof File && ((File) o).path.equals(path);
+    }
+
+    @Override
+    public int hashCode() {
+        return path.hashCode() ^ 1234321;
+    }
+
+    /// The path.
+    @Override
+    public String toString() {
+        return path;
+    }
+
+    /// This file as a `java.nio.file.Path`.
+    public Path toPath() {
+        return Paths.get(path);
+    }
+
+    /// The absolute path, without the scheme and with a single leading
+    /// separator, as a URI's path.
+    private String uriPath() {
+        String abs = getAbsolutePath();
+        if (abs.startsWith(SCHEME)) {
+            int at = SCHEME.length();
+            while (at + 1 < abs.length() && abs.charAt(at) == '/' && abs.charAt(at + 1) == '/') {
+                at++;
+            }
+            abs = abs.substring(at);
+        }
+        if (!abs.startsWith("/")) {
+            abs = "/" + abs;
+        }
+        return abs;
+    }
+
+    /// The `file:` URI of the absolute path, ending in a separator when the
+    /// file is a directory.
+    public URI toURI() {
+        String p = uriPath();
+        if (!p.endsWith("/") && isDirectory()) {
+            p = p + "/";
+        }
+        try {
+            return new URI("file", null, p, null, null);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException(e.getMessage());
+        }
+    }
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileFilter.java b/Ports/CLDC11/src/java/io/FileFilter.java
similarity index 91%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileFilter.java
rename to Ports/CLDC11/src/java/io/FileFilter.java
index 327b03d7df0..815ce200515 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileFilter.java
+++ b/Ports/CLDC11/src/java/io/FileFilter.java
@@ -20,9 +20,11 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-/// `java.io.FileFilter` for the Codename One runtime.
+/// Decides which files `File.listFiles(FileFilter)` answers.
 public interface FileFilter {
+
+    /// Whether `pathname` is wanted.
     boolean accept(File pathname);
 }
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileInputStream.java b/Ports/CLDC11/src/java/io/FileInputStream.java
similarity index 57%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileInputStream.java
rename to Ports/CLDC11/src/java/io/FileInputStream.java
index afc79341676..c775a53861b 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileInputStream.java
+++ b/Ports/CLDC11/src/java/io/FileInputStream.java
@@ -20,57 +20,99 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import com.codename1.io.FileSystemStorage;
+import com.codename1.impl.JdkHost;
 
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-
-/// `java.io.FileInputStream` for the Codename One runtime, reading through
-/// `FileSystemStorage`.
+/// Reads the bytes of a file, from the platform's file system through
+/// `com.codename1.impl.JdkHost`.
+///
+/// Like most streams, it is for one thread at a time; closing it twice, or
+/// from another thread, is safe.
 public class FileInputStream extends InputStream {
 
     private final InputStream in;
+    private boolean closed;
 
+    /// Opens the file at `name`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
     public FileInputStream(String name) throws FileNotFoundException {
         this(new File(name));
     }
 
+    /// Opens `file`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
     public FileInputStream(File file) throws FileNotFoundException {
-        if (!file.isFile()) {
-            throw new FileNotFoundException(file.getPath() + " (No such file or directory)");
+        if (file == null) {
+            throw new NullPointerException();
         }
         try {
-            in = FileSystemStorage.getInstance().openInputStream(file.storagePath());
+            in = JdkHost.get().fileRead(file.hostPath());
+        } catch (FileNotFoundException e) {
+            throw e;
         } catch (IOException e) {
             throw new FileNotFoundException(file.getPath() + " (" + e.getMessage() + ")");
         }
+        if (in == null) {
+            throw new FileNotFoundException(file.getPath());
+        }
+    }
+
+    private void checkOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
     }
 
     @Override
     public int read() throws IOException {
+        checkOpen();
         return in.read();
     }
 
+    @Override
+    public int read(byte[] b) throws IOException {
+        return read(b, 0, b.length);
+    }
+
     @Override
     public int read(byte[] b, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        checkOpen();
+        if (len == 0) {
+            return 0;
+        }
         return in.read(b, off, len);
     }
 
     @Override
     public long skip(long n) throws IOException {
-        return in.skip(n);
+        checkOpen();
+        return n <= 0 ? 0 : in.skip(n);
     }
 
     @Override
     public int available() throws IOException {
+        checkOpen();
         return in.available();
     }
 
     @Override
     public void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        closed = true;
         in.close();
     }
 }
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileOutputStream.java b/Ports/CLDC11/src/java/io/FileOutputStream.java
similarity index 54%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileOutputStream.java
rename to Ports/CLDC11/src/java/io/FileOutputStream.java
index 93ffcd3b620..675e607e40e 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileOutputStream.java
+++ b/Ports/CLDC11/src/java/io/FileOutputStream.java
@@ -20,71 +20,110 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import com.codename1.io.FileSystemStorage;
+import com.codename1.impl.JdkHost;
 
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.OutputStream;
-
-/// `java.io.FileOutputStream` for the Codename One runtime, writing through
-/// `FileSystemStorage`. Appending opens the storage stream at the file's
-/// current length.
+/// Writes the bytes of a file, to the platform's file system through
+/// `com.codename1.impl.JdkHost`. The file is created when it is not there.
+///
+/// Like most streams, it is for one thread at a time; closing it twice, or
+/// from another thread, is safe.
 public class FileOutputStream extends OutputStream {
 
     private final OutputStream out;
+    private boolean closed;
 
+    /// Opens the file at `name`, emptying it.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(String name) throws FileNotFoundException {
         this(new File(name), false);
     }
 
+    /// Opens the file at `name`, at its end when `append` is true and emptied
+    /// otherwise.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(String name, boolean append) throws FileNotFoundException {
         this(new File(name), append);
     }
 
+    /// Opens `file`, emptying it.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(File file) throws FileNotFoundException {
         this(file, false);
     }
 
+    /// Opens `file`, at its end when `append` is true and emptied otherwise.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(File file, boolean append) throws FileNotFoundException {
-        if (file.isDirectory()) {
-            throw new FileNotFoundException(file.getPath() + " (Is a directory)");
-        }
-        File parent = file.getParentFile();
-        if (parent != null && !parent.isDirectory()) {
-            throw new FileNotFoundException(file.getPath() + " (No such file or directory)");
+        if (file == null) {
+            throw new NullPointerException();
         }
         try {
-            FileSystemStorage fs = FileSystemStorage.getInstance();
-            String p = file.storagePath();
-            if (append && fs.exists(p)) {
-                out = fs.openOutputStream(p, (int) fs.getLength(p));
-            } else {
-                out = fs.openOutputStream(p);
-            }
+            out = JdkHost.get().fileWrite(file.hostPath(), append);
+        } catch (FileNotFoundException e) {
+            throw e;
         } catch (IOException e) {
             throw new FileNotFoundException(file.getPath() + " (" + e.getMessage() + ")");
         }
+        if (out == null) {
+            throw new FileNotFoundException(file.getPath());
+        }
+    }
+
+    private void checkOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
     }
 
     @Override
     public void write(int b) throws IOException {
+        checkOpen();
         out.write(b);
     }
 
+    @Override
+    public void write(byte[] b) throws IOException {
+        write(b, 0, b.length);
+    }
+
     @Override
     public void write(byte[] b, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        checkOpen();
+        if (len == 0) {
+            return;
+        }
         out.write(b, off, len);
     }
 
     @Override
     public void flush() throws IOException {
+        checkOpen();
         out.flush();
     }
 
     @Override
     public void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        closed = true;
         out.close();
     }
 }
diff --git a/Ports/CLDC11/src/java/io/FileReader.java b/Ports/CLDC11/src/java/io/FileReader.java
new file mode 100644
index 00000000000..ac492f1e623
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/FileReader.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+import java.nio.charset.Charset;
+
+/// Reads the text of a file, in UTF-8 unless a charset is given.
+public class FileReader extends InputStreamReader {
+
+    /// Opens the file at `fileName`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
+    public FileReader(String fileName) throws FileNotFoundException {
+        super(new FileInputStream(fileName));
+    }
+
+    /// Opens `file`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
+    public FileReader(File file) throws FileNotFoundException {
+        super(new FileInputStream(file));
+    }
+
+    /// Opens the file at `fileName`, reading `charset`.
+    public FileReader(String fileName, Charset charset) throws IOException {
+        super(new FileInputStream(fileName), charset.name());
+    }
+
+    /// Opens `file`, reading `charset`.
+    public FileReader(File file, Charset charset) throws IOException {
+        super(new FileInputStream(file), charset.name());
+    }
+}
diff --git a/Ports/CLDC11/src/java/io/FileWriter.java b/Ports/CLDC11/src/java/io/FileWriter.java
new file mode 100644
index 00000000000..e5415f4be95
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/FileWriter.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+import java.nio.charset.Charset;
+
+/// Writes text to a file, in UTF-8 unless a charset is given.
+public class FileWriter extends OutputStreamWriter {
+
+    /// Opens the file at `fileName`, emptying it.
+    public FileWriter(String fileName) throws IOException {
+        super(new FileOutputStream(fileName));
+    }
+
+    /// Opens the file at `fileName`, at its end when `append` is true.
+    public FileWriter(String fileName, boolean append) throws IOException {
+        super(new FileOutputStream(fileName, append));
+    }
+
+    /// Opens `file`, emptying it.
+    public FileWriter(File file) throws IOException {
+        super(new FileOutputStream(file));
+    }
+
+    /// Opens `file`, at its end when `append` is true.
+    public FileWriter(File file, boolean append) throws IOException {
+        super(new FileOutputStream(file, append));
+    }
+
+    /// Opens the file at `fileName`, emptying it, writing `charset`.
+    public FileWriter(String fileName, Charset charset) throws IOException {
+        super(new FileOutputStream(fileName), charset.name());
+    }
+
+    /// Opens the file at `fileName`, at its end when `append` is true,
+    /// writing `charset`.
+    public FileWriter(String fileName, Charset charset, boolean append) throws IOException {
+        super(new FileOutputStream(fileName, append), charset.name());
+    }
+
+    /// Opens `file`, emptying it, writing `charset`.
+    public FileWriter(File file, Charset charset) throws IOException {
+        super(new FileOutputStream(file), charset.name());
+    }
+
+    /// Opens `file`, at its end when `append` is true, writing `charset`.
+    public FileWriter(File file, Charset charset, boolean append) throws IOException {
+        super(new FileOutputStream(file, append), charset.name());
+    }
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilenameFilter.java b/Ports/CLDC11/src/java/io/FilenameFilter.java
similarity index 89%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilenameFilter.java
rename to Ports/CLDC11/src/java/io/FilenameFilter.java
index 2a9deb7efa7..6c2a83faae9 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilenameFilter.java
+++ b/Ports/CLDC11/src/java/io/FilenameFilter.java
@@ -20,9 +20,11 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-/// `java.io.FilenameFilter` for the Codename One runtime.
+/// Decides which names `File.list(FilenameFilter)` answers.
 public interface FilenameFilter {
+
+    /// Whether the entry `name` of the directory `dir` is wanted.
     boolean accept(File dir, String name);
 }
diff --git a/Ports/CLDC11/src/java/io/InputStream.java b/Ports/CLDC11/src/java/io/InputStream.java
index 998892d6f87..4c20a9e8eef 100644
--- a/Ports/CLDC11/src/java/io/InputStream.java
+++ b/Ports/CLDC11/src/java/io/InputStream.java
@@ -25,7 +25,7 @@
 /// This abstract class is the superclass of all classes representing an input stream of bytes.
 /// Applications that need to define a subclass of InputStream must always provide a method that returns the next byte of input.
 /// Since: JDK1.0, CLDC 1.0 See Also:ByteArrayInputStream, DataInputStream, read(), OutputStream
-public abstract class InputStream implements AutoCloseable {
+public abstract class InputStream implements Closeable {
     public InputStream(){
          //TODO codavaj!!
     }
@@ -96,4 +96,85 @@ public long skip(long n) throws java.io.IOException{
         return 0l; //TODO codavaj!!
     }
 
+    /// Reads everything left in this stream, until its end. The stream is
+    /// not closed.
+    ///
+    /// #### Returns
+    ///
+    /// the bytes read, an empty array when the stream was at its end
+    public byte[] readAllBytes() throws IOException {
+        return readNBytes(Integer.MAX_VALUE);
+    }
+
+    /// Reads up to `len` bytes, fewer only when the stream ends first.
+    ///
+    /// #### Parameters
+    ///
+    /// - `len`: the most bytes to read
+    ///
+    /// #### Returns
+    ///
+    /// the bytes read
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `len` is negative
+    public byte[] readNBytes(int len) throws IOException {
+        if (len < 0) {
+            throw new IllegalArgumentException("len < 0");
+        }
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] chunk = new byte[8192];
+        int left = len;
+        while (left > 0) {
+            int n = read(chunk, 0, left < chunk.length ? left : chunk.length);
+            if (n < 0) {
+                break;
+            }
+            out.write(chunk, 0, n);
+            left -= n;
+        }
+        return out.toByteArray();
+    }
+
+    /// Reads into `b` from `off` until `len` bytes arrived or the stream
+    /// ended, where a single `read` may stop short.
+    ///
+    /// #### Returns
+    ///
+    /// how many bytes were read, 0 at the end of the stream
+    public int readNBytes(byte[] b, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        int total = 0;
+        while (total < len) {
+            int n = read(b, off + total, len - total);
+            if (n < 0) {
+                break;
+            }
+            total += n;
+        }
+        return total;
+    }
+
+    /// Copies everything left in this stream to `out`, closing neither.
+    ///
+    /// #### Returns
+    ///
+    /// how many bytes were copied
+    public long transferTo(OutputStream out) throws IOException {
+        if (out == null) {
+            throw new NullPointerException("out");
+        }
+        byte[] chunk = new byte[8192];
+        long total = 0;
+        int n = read(chunk, 0, chunk.length);
+        while (n >= 0) {
+            out.write(chunk, 0, n);
+            total += n;
+            n = read(chunk, 0, chunk.length);
+        }
+        return total;
+    }
 }
diff --git a/Ports/CLDC11/src/java/io/InputStreamReader.java b/Ports/CLDC11/src/java/io/InputStreamReader.java
index 9769621f7bf..85ae2bce44c 100644
--- a/Ports/CLDC11/src/java/io/InputStreamReader.java
+++ b/Ports/CLDC11/src/java/io/InputStreamReader.java
@@ -79,4 +79,12 @@ public long skip(long n) throws java.io.IOException{
         return 0l; //TODO codavaj!!
     }
 
+    /// An InputStreamReader that decodes with `cs`.
+    public InputStreamReader(java.io.InputStream is, java.nio.charset.Charset cs) {
+    }
+
+    /// The historical name of the encoding: `UTF8`, `ASCII`, `ISO8859_1`.
+    public String getEncoding() {
+        return null;
+    }
 }
diff --git a/Ports/CLDC11/src/java/io/ObjectInput.java b/Ports/CLDC11/src/java/io/ObjectInput.java
new file mode 100644
index 00000000000..56644b2bc7f
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/ObjectInput.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Reads objects as well as primitive values. Codename One has no object
+/// serialization of its own; this type exists so code written against it
+/// compiles, and an implementation supplies the reading.
+public interface ObjectInput extends DataInput, AutoCloseable {
+
+    /// Reads the next object.
+    Object readObject() throws ClassNotFoundException, IOException;
+
+    /// Reads one byte, or -1 at the end of the input.
+    int read() throws IOException;
+
+    /// Reads into `b`, returning how many bytes were read or -1 at the end.
+    int read(byte[] b) throws IOException;
+
+    /// Reads into `b` from `off`, returning how many bytes were read or -1
+    /// at the end.
+    int read(byte[] b, int off, int len) throws IOException;
+
+    /// Skips up to `n` bytes, returning how many were skipped.
+    long skip(long n) throws IOException;
+
+    /// How many bytes can be read without blocking.
+    int available() throws IOException;
+
+    /// Closes the input.
+    @Override
+    void close() throws IOException;
+}
diff --git a/Ports/CLDC11/src/java/io/ObjectOutput.java b/Ports/CLDC11/src/java/io/ObjectOutput.java
new file mode 100644
index 00000000000..252854e3fe6
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/ObjectOutput.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Writes objects as well as primitive values. Codename One has no object
+/// serialization of its own; this type exists so code written against it
+/// compiles, and an implementation supplies the writing.
+public interface ObjectOutput extends DataOutput, AutoCloseable {
+
+    /// Writes `obj`.
+    void writeObject(Object obj) throws IOException;
+
+    /// Writes any buffered output.
+    void flush() throws IOException;
+
+    /// Closes the output.
+    @Override
+    void close() throws IOException;
+}
diff --git a/Ports/CLDC11/src/java/io/OutputStream.java b/Ports/CLDC11/src/java/io/OutputStream.java
index 68c5a269213..4f32b74a651 100644
--- a/Ports/CLDC11/src/java/io/OutputStream.java
+++ b/Ports/CLDC11/src/java/io/OutputStream.java
@@ -25,7 +25,7 @@
 /// This abstract class is the superclass of all classes representing an output stream of bytes. An output stream accepts output bytes and sends them to some sink.
 /// Applications that need to define a subclass of OutputStream must always provide at least a method that writes one byte of output.
 /// Since: JDK1.0, CLDC 1.0 See Also:ByteArrayOutputStream, DataOutputStream, InputStream, write(int)
-public abstract class OutputStream  implements AutoCloseable {
+public abstract class OutputStream implements Closeable, Flushable {
     public OutputStream(){
          //TODO codavaj!!
     }
diff --git a/Ports/CLDC11/src/java/io/OutputStreamWriter.java b/Ports/CLDC11/src/java/io/OutputStreamWriter.java
index 4e666f37c08..8815d30f195 100644
--- a/Ports/CLDC11/src/java/io/OutputStreamWriter.java
+++ b/Ports/CLDC11/src/java/io/OutputStreamWriter.java
@@ -64,4 +64,12 @@ public void write(java.lang.String str, int off, int len) throws java.io.IOExcep
         return; //TODO codavaj!!
     }
 
+    /// An OutputStreamWriter that encodes with `cs`.
+    public OutputStreamWriter(java.io.OutputStream os, java.nio.charset.Charset cs) {
+    }
+
+    /// The historical name of the encoding: `UTF8`, `ASCII`, `ISO8859_1`.
+    public String getEncoding() {
+        return null;
+    }
 }
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/PrintWriter.java b/Ports/CLDC11/src/java/io/PrintWriter.java
similarity index 68%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/PrintWriter.java
rename to Ports/CLDC11/src/java/io/PrintWriter.java
index 3d7a4ab82e7..189a18ea044 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/PrintWriter.java
+++ b/Ports/CLDC11/src/java/io/PrintWriter.java
@@ -20,16 +20,9 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.io;
 
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.UnsupportedEncodingException;
-import java.io.Writer;
-
-/// `java.io.PrintWriter` for the Codename One runtime. Like the JDK class it
-/// never throws: an I/O error is recorded and reported by `checkError`.
+/// Prints formatted text to a writer or a stream. It never throws: an I/O error is recorded and reported by `checkError`.
 public class PrintWriter extends Writer {
 
     protected Writer out;
@@ -53,12 +46,44 @@ public PrintWriter(OutputStream out, boolean autoFlush) {
         this(utf8(out), autoFlush);
     }
 
-    public PrintWriter(String fileName) throws java.io.FileNotFoundException {
-        this(utf8(new FileOutputStream(fileName)), false);
+    /// Writes to the file `fileName` in UTF-8, creating it or truncating it.
+    public PrintWriter(String fileName) throws FileNotFoundException {
+        this(new BufferedWriter(utf8(new FileOutputStream(fileName))), false);
+    }
+
+    /// Writes to the file `fileName` in the charset `csn`.
+    public PrintWriter(String fileName, String csn) throws FileNotFoundException, UnsupportedEncodingException {
+        this(encoded(new File(fileName), csn), false);
+    }
+
+    /// Writes to the file `fileName` in the charset `cs`.
+    public PrintWriter(String fileName, java.nio.charset.Charset cs) throws IOException {
+        this(encoded(new File(fileName), cs.name()), false);
+    }
+
+    /// Writes to `file` in UTF-8, creating it or truncating it.
+    public PrintWriter(File file) throws FileNotFoundException {
+        this(new BufferedWriter(utf8(new FileOutputStream(file))), false);
+    }
+
+    /// Writes to `file` in the charset `csn`.
+    public PrintWriter(File file, String csn) throws FileNotFoundException, UnsupportedEncodingException {
+        this(encoded(file, csn), false);
     }
 
-    public PrintWriter(File file) throws java.io.FileNotFoundException {
-        this(utf8(new FileOutputStream(file)), false);
+    /// Writes to `file` in the charset `cs`.
+    public PrintWriter(File file, java.nio.charset.Charset cs) throws IOException {
+        this(encoded(file, cs.name()), false);
+    }
+
+    /// Checks the charset before the file is opened, so an unknown name
+    /// leaves the file as it was, as the JDK does.
+    private static Writer encoded(File file, String csn) throws FileNotFoundException, UnsupportedEncodingException {
+        if (csn == null) {
+            throw new NullPointerException("charsetName");
+        }
+        "".getBytes(csn);
+        return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), csn));
     }
 
     private static Writer utf8(OutputStream out) {
@@ -261,4 +286,32 @@ public PrintWriter append(char c) {
         print(c);
         return this;
     }
+
+    /// Writes `format` filled in with `args`, as `String.format` does.
+    ///
+    /// #### Returns
+    ///
+    /// this writer
+    public PrintWriter printf(String format, Object... args) {
+        return format(format, args);
+    }
+
+    /// Writes `format` filled in with `args`, as `String.format` does.
+    ///
+    /// #### Returns
+    ///
+    /// this writer
+    public PrintWriter format(String format, Object... args) {
+        write(String.format(format, args));
+        if (autoFlush) {
+            flush();
+        }
+        return this;
+    }
+
+    public PrintWriter append(CharSequence csq, int start, int end) {
+        CharSequence cs = csq == null ? "null" : csq;
+        print(cs.subSequence(start, end).toString());
+        return this;
+    }
 }
diff --git a/Ports/CLDC11/src/java/io/Reader.java b/Ports/CLDC11/src/java/io/Reader.java
index 094f8088aba..7f61a332c68 100644
--- a/Ports/CLDC11/src/java/io/Reader.java
+++ b/Ports/CLDC11/src/java/io/Reader.java
@@ -24,7 +24,7 @@
 package java.io;
 /// Abstract class for reading character streams. The only methods that a subclass must implement are read(char[], int, int) and close(). Most subclasses, however, will override some of the methods defined here in order to provide higher efficiency, additional functionality, or both.
 /// Since: JDK1.1, CLDC 1.0 See Also:InputStreamReader, Writer
-public abstract class Reader  implements AutoCloseable {
+public abstract class Reader implements Closeable {
     /// The object used to synchronize operations on this stream. For efficiency, a character-stream object may use an object other than itself to protect critical sections. A subclass should therefore use the object in this field rather than this or a synchronized method.
     protected java.lang.Object lock;
 
@@ -81,4 +81,23 @@ public long skip(long n) throws java.io.IOException{
         return 0l; //TODO codavaj!!
     }
 
+    /// Copies everything left in this reader to `out`, closing neither.
+    ///
+    /// #### Returns
+    ///
+    /// how many characters were copied
+    public long transferTo(Writer out) throws IOException {
+        if (out == null) {
+            throw new NullPointerException("out");
+        }
+        char[] chunk = new char[8192];
+        long total = 0;
+        int n = read(chunk, 0, chunk.length);
+        while (n >= 0) {
+            out.write(chunk, 0, n);
+            total += n;
+            n = read(chunk, 0, chunk.length);
+        }
+        return total;
+    }
 }
diff --git a/Ports/CLDC11/src/java/io/UncheckedIOException.java b/Ports/CLDC11/src/java/io/UncheckedIOException.java
new file mode 100644
index 00000000000..71864bc40b2
--- /dev/null
+++ b/Ports/CLDC11/src/java/io/UncheckedIOException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// `java.io.UncheckedIOException`: an
+/// `IOException` carried through code that cannot declare it, as a lambda or
+/// a constructor that loads a resource does.
+public class UncheckedIOException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Wraps an exception with a message of its own.
+    public UncheckedIOException(String message, IOException cause) {
+        super(message, required(cause));
+    }
+
+    /// Wraps an exception, taking its description as the message.
+    public UncheckedIOException(IOException cause) {
+        super(required(cause).toString(), cause);
+    }
+
+    private static IOException required(IOException cause) {
+        if (cause == null) {
+            throw new NullPointerException();
+        }
+        return cause;
+    }
+
+    /// Returns the exception this one carries.
+    @Override
+    public IOException getCause() {
+        Throwable cause = super.getCause();
+        return cause instanceof IOException ? (IOException) cause : null;
+    }
+}
diff --git a/Ports/CLDC11/src/java/io/Writer.java b/Ports/CLDC11/src/java/io/Writer.java
index 99b31b10fbb..43063a2b5cc 100644
--- a/Ports/CLDC11/src/java/io/Writer.java
+++ b/Ports/CLDC11/src/java/io/Writer.java
@@ -24,7 +24,7 @@
 package java.io;
 /// Abstract class for writing to character streams. The only methods that a subclass must implement are write(char[], int, int), flush(), and close(). Most subclasses, however, will override some of the methods defined here in order to provide higher efficiency, additional functionality, or both.
 /// Since: JDK1.1, CLDC 1.0 See Also:OutputStreamWriter, Reader
-public abstract class Writer implements AutoCloseable {
+public abstract class Writer implements Appendable, Closeable, Flushable {
     /// The object used to synchronize operations on this stream. For efficiency, a character-stream object may use an object other than itself to protect critical sections. A subclass should therefore use the object in this field rather than this or a synchronized method.
     protected java.lang.Object lock;
 
@@ -39,6 +39,21 @@ protected Writer(java.lang.Object lock){
          //TODO codavaj!!
     }
 
+    /// Writes `csq`, or "null" when it is null.
+    public Writer append(CharSequence csq) throws IOException {
+        return this;
+    }
+
+    /// Writes `c`.
+    public Writer append(char c) throws IOException {
+        return this;
+    }
+
+    /// Writes the characters of `csq` from `start` up to `end`.
+    public Writer append(CharSequence csq, int start, int end) throws IOException {
+        return this;
+    }
+
     /// Close the stream, flushing it first. Once a stream has been closed, further write() or flush() invocations will cause an IOException to be thrown. Closing a previously-closed stream, however, has no effect.
     public abstract void close() throws java.io.IOException;
 
diff --git a/Ports/CLDC11/src/java/lang/Boolean.java b/Ports/CLDC11/src/java/lang/Boolean.java
index b06e8237fc0..55523ffa128 100644
--- a/Ports/CLDC11/src/java/lang/Boolean.java
+++ b/Ports/CLDC11/src/java/lang/Boolean.java
@@ -24,7 +24,7 @@
 package java.lang;
 /// The Boolean class wraps a value of the primitive type boolean in an object. An object of type Boolean contains a single field whose type is boolean.
 /// Since: JDK1.0, CLDC 1.0
-public final class Boolean{
+public final class Boolean implements Comparable<Boolean> {
     /// The Boolean object corresponding to the primitive value false.
     public static final java.lang.Boolean FALSE=null;
 
@@ -81,4 +81,46 @@ public static boolean parseBoolean(final String s) {
     public int compareTo(final Boolean b2) {
             return 0;
     }
+
+    public static final Class<Boolean> TYPE = null;
+
+    /// A Boolean of `parseBoolean(s)`.
+    @Deprecated
+    public Boolean(String s) {
+    }
+
+    /// `"true"` or `"false"`.
+    public static String toString(boolean b) {
+        return null;
+    }
+
+    /// 1231 for true, 1237 for false, as the JDK hashes them.
+    public static int hashCode(boolean value) {
+        return 0;
+    }
+
+    /// 0 when equal, otherwise positive when `x` is true.
+    public static int compare(boolean x, boolean y) {
+        return 0;
+    }
+
+    /// `a && b`.
+    public static boolean logicalAnd(boolean a, boolean b) {
+        return false;
+    }
+
+    /// `a || b`.
+    public static boolean logicalOr(boolean a, boolean b) {
+        return false;
+    }
+
+    /// `a ^ b`.
+    public static boolean logicalXor(boolean a, boolean b) {
+        return false;
+    }
+
+    /// Whether the system property `name` is `"true"`, ignoring case.
+    public static boolean getBoolean(String name) {
+        return false;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Byte.java b/Ports/CLDC11/src/java/lang/Byte.java
index 76bac16f985..597ae4a0489 100644
--- a/Ports/CLDC11/src/java/lang/Byte.java
+++ b/Ports/CLDC11/src/java/lang/Byte.java
@@ -105,11 +105,59 @@ public double doubleValue() {
         return 0.0;
     }
     
-    public int compare(byte b1, byte b2) {
+    public static int compare(byte b1, byte b2) {
         return b1 < b2 ? -1 : b1 > b2 ? 1 : 0;
     }
     
     public int compareTo(Byte b) {
         return compare(this, b);
     }
+
+    /// The size of a byte in bytes.
+    public static final int BYTES = 1;
+
+    /// A Byte of `parseByte(s)`.
+    @Deprecated
+    public Byte(String s) throws NumberFormatException {
+    }
+
+    /// The decimal string of `b`.
+    public static String toString(byte b) {
+        return null;
+    }
+
+    /// A Byte of `parseByte(s)`.
+    public static Byte valueOf(String s) throws NumberFormatException {
+        return null;
+    }
+
+    /// A Byte of `parseByte(s, radix)`.
+    public static Byte valueOf(String s, int radix) throws NumberFormatException {
+        return null;
+    }
+
+    /// Decodes a decimal, hexadecimal or octal byte, as `Integer.decode`.
+    public static Byte decode(String nm) throws NumberFormatException {
+        return null;
+    }
+
+    /// The value itself.
+    public static int hashCode(byte value) {
+        return 0;
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(byte x, byte y) {
+        return 0;
+    }
+
+    /// The value as an unsigned int.
+    public static int toUnsignedInt(byte x) {
+        return 0;
+    }
+
+    /// The value as an unsigned long.
+    public static long toUnsignedLong(byte x) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/CharSequence.java b/Ports/CLDC11/src/java/lang/CharSequence.java
index a84f1d9c02c..e7aef96a2b8 100644
--- a/Ports/CLDC11/src/java/lang/CharSequence.java
+++ b/Ports/CLDC11/src/java/lang/CharSequence.java
@@ -81,4 +81,26 @@ public interface CharSequence {
     ///
     /// a string based on this sequence.
     public String toString();
+
+    /// Whether the sequence has no characters.
+    default boolean isEmpty() {
+        return false;
+    }
+
+    /// The sequence's `char` values, zero-extended to `int`. Stubbed in
+    /// the CLDC11 subset; the implementation comes from the platform.
+    default java.util.stream.IntStream chars() {
+        return null;
+    }
+
+    /// The sequence's code points. Stubbed in the CLDC11 subset.
+    default java.util.stream.IntStream codePoints() {
+        return null;
+    }
+
+    /// Compares two sequences lexicographically, char by char, the shorter
+    /// first when one is a prefix of the other.
+    public static int compare(CharSequence cs1, CharSequence cs2) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Character.java b/Ports/CLDC11/src/java/lang/Character.java
index 00335b8a6db..8b118932737 100644
--- a/Ports/CLDC11/src/java/lang/Character.java
+++ b/Ports/CLDC11/src/java/lang/Character.java
@@ -26,7 +26,7 @@
 /// In addition, this class provides several methods for determining the type of a character and converting characters from uppercase to lowercase and vice versa.
 /// Character information is based on the Unicode Standard, version 3.0. However, in order to reduce footprint, by default the character property and case conversion operations in CLDC are available only for the ISO Latin-1 range of characters. Other Unicode character blocks can be supported as necessary.
 /// Since: JDK1.0, CLDC 1.0
-public final class Character{
+public final class Character implements Comparable<Character> {
     /// The maximum radix available for conversion to and from Strings.
     /// See Also:Integer.toString(int, int), Integer.valueOf(java.lang.String), Constant Field Values
     public static final int MAX_RADIX=36;
@@ -1167,4 +1167,325 @@ public static char toTitleCase(char c) {
         return (char) 0;
     }
 
+    public static final Class<Character> TYPE = char.class;
+
+    public static final byte UNASSIGNED = 0;
+
+    public static final byte UPPERCASE_LETTER = 1;
+
+    public static final byte LOWERCASE_LETTER = 2;
+
+    public static final byte TITLECASE_LETTER = 3;
+
+    public static final byte MODIFIER_LETTER = 4;
+
+    public static final byte OTHER_LETTER = 5;
+
+    public static final byte NON_SPACING_MARK = 6;
+
+    public static final byte ENCLOSING_MARK = 7;
+
+    public static final byte COMBINING_SPACING_MARK = 8;
+
+    public static final byte DECIMAL_DIGIT_NUMBER = 9;
+
+    public static final byte LETTER_NUMBER = 10;
+
+    public static final byte OTHER_NUMBER = 11;
+
+    public static final byte SPACE_SEPARATOR = 12;
+
+    public static final byte LINE_SEPARATOR = 13;
+
+    public static final byte PARAGRAPH_SEPARATOR = 14;
+
+    public static final byte CONTROL = 15;
+
+    public static final byte FORMAT = 16;
+
+    public static final byte PRIVATE_USE = 17;
+
+    public static final byte SURROGATE = 19;
+
+    public static final byte DASH_PUNCTUATION = 20;
+
+    public static final byte START_PUNCTUATION = 21;
+
+    public static final byte END_PUNCTUATION = 22;
+
+    public static final byte CONNECTOR_PUNCTUATION = 23;
+
+    public static final byte OTHER_PUNCTUATION = 24;
+
+    public static final byte MATH_SYMBOL = 25;
+
+    public static final byte CURRENCY_SYMBOL = 26;
+
+    public static final byte MODIFIER_SYMBOL = 27;
+
+    public static final byte OTHER_SYMBOL = 28;
+
+    public static final byte INITIAL_QUOTE_PUNCTUATION = 29;
+
+    public static final byte FINAL_QUOTE_PUNCTUATION = 30;
+
+    public static final byte DIRECTIONALITY_UNDEFINED = -1;
+
+    public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
+
+    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
+
+    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
+
+    public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
+
+    public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
+
+    public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
+
+    public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
+
+    public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
+
+    public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
+
+    public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
+
+    public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
+
+    public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
+
+    public static final byte DIRECTIONALITY_WHITESPACE = 12;
+
+    public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
+
+    public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
+
+    public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
+
+    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
+
+    public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
+
+    public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
+
+    public static int digit(int codePoint, int radix) {
+        return 0;
+    }
+
+    public static boolean isLetterOrDigit(char ch) {
+        return false;
+    }
+
+    public static boolean isLetterOrDigit(int codePoint) {
+        return false;
+    }
+
+    public static boolean isLetter(char ch) {
+        return false;
+    }
+
+    public static boolean isLetter(int codePoint) {
+        return false;
+    }
+
+    public static boolean isIdentifierIgnorable(char ch) {
+        return false;
+    }
+
+    public static boolean isIdentifierIgnorable(int codePoint) {
+        return false;
+    }
+
+    public static boolean isDigit(int codePoint) {
+        return false;
+    }
+
+    public static boolean isLowerCase(int codePoint) {
+        return false;
+    }
+
+    public static boolean isUpperCase(int codePoint) {
+        return false;
+    }
+
+    public static int toLowerCase(int codePoint) {
+        return 0;
+    }
+
+    public static int toUpperCase(int codePoint) {
+        return 0;
+    }
+
+    public static char highSurrogate(int codePoint) {
+        return 0;
+    }
+
+    public static char lowSurrogate(int codePoint) {
+        return 0;
+    }
+
+    /// Whether the code point is a Unicode space separator, line separator or
+    /// paragraph separator.
+    public static boolean isSpaceChar(int codePoint) {
+        return false;
+    }
+
+    public static byte getDirectionality(char ch) {
+        return 0;
+    }
+
+    public static int getType(char c) {
+        return 0;
+    }
+
+    public static boolean isBmpCodePoint(int codePoint) {
+        return false;
+    }
+
+    public static boolean isSurrogate(char ch) {
+        return false;
+    }
+
+    public static int getType(int codePoint) {
+        return 0;
+    }
+
+    public int compareTo(Character another) {
+        return 0;
+    }
+
+    /// The size of a char in bytes.
+    public static final int BYTES = 2;
+
+    /// A one-char string of `c`.
+    public static String toString(char c) {
+        return null;
+    }
+
+    /// The string of the code point: one char, or a surrogate pair.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if it is not a valid code point
+    public static String toString(int codePoint) {
+        return null;
+    }
+
+    /// The char itself, as the JDK hashes it.
+    public static int hashCode(char value) {
+        return 0;
+    }
+
+    /// `x - y`.
+    public static int compare(char x, char y) {
+        return 0;
+    }
+
+    /// Whether the char is an ISO control character: U+0000 to U+001F or
+    /// U+007F to U+009F.
+    public static boolean isISOControl(char ch) {
+        return false;
+    }
+
+    /// Whether the code point is an ISO control character.
+    public static boolean isISOControl(int codePoint) {
+        return false;
+    }
+
+    /// The char of `digit` in `radix`, a lower case letter from 10 on, or
+    /// U+0000 when either is out of range.
+    public static char forDigit(int digit, int radix) {
+        return 0;
+    }
+
+    /// The value of a digit, or of a Latin letter read as a digit of base
+    /// 36, or -1.
+    public static int getNumericValue(char ch) {
+        return 0;
+    }
+
+    /// The value of a digit, or of a Latin letter read as a digit of base
+    /// 36, or -1.
+    public static int getNumericValue(int codePoint) {
+        return 0;
+    }
+
+    /// Whether the code point is alphabetic. This runtime answers as for
+    /// `isLetter`.
+    public static boolean isAlphabetic(int codePoint) {
+        return false;
+    }
+
+    /// Whether the char has a category in this runtime's classification.
+    public static boolean isDefined(char ch) {
+        return false;
+    }
+
+    /// Whether the code point has a category in this runtime's
+    /// classification. Above Latin-1 that classification is partial, so an
+    /// assigned symbol it does not know answers false.
+    public static boolean isDefined(int codePoint) {
+        return false;
+    }
+
+    /// Whether the code point is a CJK ideograph.
+    public static boolean isIdeographic(int codePoint) {
+        return false;
+    }
+
+    /// Whether the char is a title case letter.
+    public static boolean isTitleCase(char ch) {
+        return false;
+    }
+
+    /// Whether the code point is a title case letter.
+    public static boolean isTitleCase(int codePoint) {
+        return false;
+    }
+
+    /// Whether the char is mirrored in right-to-left text: the ASCII
+    /// brackets and the guillemets.
+    public static boolean isMirrored(char ch) {
+        return false;
+    }
+
+    /// Whether the code point is mirrored in right-to-left text. This
+    /// runtime knows the ASCII brackets and the guillemets.
+    public static boolean isMirrored(int codePoint) {
+        return false;
+    }
+
+    /// As `isJavaIdentifierStart(char)`.
+    @Deprecated
+    public static boolean isJavaLetter(char ch) {
+        return false;
+    }
+
+    /// As `isJavaIdentifierPart(char)`.
+    @Deprecated
+    public static boolean isJavaLetterOrDigit(char ch) {
+        return false;
+    }
+
+    /// Whether the char may start a Unicode identifier.
+    public static boolean isUnicodeIdentifierStart(char ch) {
+        return false;
+    }
+
+    /// Whether the code point may start a Unicode identifier: a letter.
+    public static boolean isUnicodeIdentifierStart(int codePoint) {
+        return false;
+    }
+
+    /// Whether the char may continue a Unicode identifier.
+    public static boolean isUnicodeIdentifierPart(char ch) {
+        return false;
+    }
+
+    /// Whether the code point may continue a Unicode identifier: a letter, a
+    /// digit, connecting punctuation or an ignorable character.
+    public static boolean isUnicodeIdentifierPart(int codePoint) {
+        return false;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Class.java b/Ports/CLDC11/src/java/lang/Class.java
index ae8200a31c2..8c9ac59a227 100644
--- a/Ports/CLDC11/src/java/lang/Class.java
+++ b/Ports/CLDC11/src/java/lang/Class.java
@@ -260,4 +260,10 @@ public boolean isLocalClass() {
     public boolean isRecord() {
         return this != java.lang.Record.class && java.lang.Record.class.isAssignableFrom(this);
     }
+
+    /// The module this class is in: the unnamed module, for every class, as
+    /// for a class the JDK loaded from the class path.
+    public Module getModule() {
+        return Module.unnamed();
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Double.java b/Ports/CLDC11/src/java/lang/Double.java
index cf095463712..e454cf167da 100644
--- a/Ports/CLDC11/src/java/lang/Double.java
+++ b/Ports/CLDC11/src/java/lang/Double.java
@@ -206,6 +206,56 @@ public static int compare(double d1, double d2) {
     public int compareTo(Double d) {
         return compare(this, d);
     }
-    
-    
+
+    public static final int MAX_EXPONENT = 1023;
+
+    public static final int MIN_EXPONENT = -1022;
+
+    public static final int SIZE = 64;
+
+    public static long doubleToRawLongBits(double value) {
+        return 0;
+    }
+
+    public static double sum(double a, double b) {
+        return 0;
+    }
+
+    public static double max(double a, double b) {
+        return 0;
+    }
+
+    public static double min(double a, double b) {
+        return 0;
+    }
+
+    /// The size of a double in bytes.
+    public static final int BYTES = 8;
+
+    /// The bits of precision of a double's significand.
+    public static final int PRECISION = 53;
+
+    /// The smallest positive normal double, 2 to the power -1022.
+    public static final double MIN_NORMAL = 0x1.0p-1022;
+
+    /// A Double of `parseDouble(s)`.
+    @Deprecated
+    public Double(String s) throws NumberFormatException {
+    }
+
+    /// Whether `d` is neither infinite nor NaN.
+    public static boolean isFinite(double d) {
+        return false;
+    }
+
+    /// The hash the JDK gives `value`: its bits folded to an int.
+    public static int hashCode(double value) {
+        return 0;
+    }
+
+    /// The value as a hexadecimal floating point literal, as the JDK writes
+    /// it: `0x1.8p1` for 3.0, `0x0.0p0` for zero.
+    public static String toHexString(double d) {
+        return null;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Float.java b/Ports/CLDC11/src/java/lang/Float.java
index 723dcbf780e..5766d8efe86 100644
--- a/Ports/CLDC11/src/java/lang/Float.java
+++ b/Ports/CLDC11/src/java/lang/Float.java
@@ -192,4 +192,61 @@ public static int compare(float f1, float f2) {
     public int compareTo(Float f) {
         return compare(this, f);
     }
+
+    public static final Class<Float> TYPE = null;
+
+    public static int floatToRawIntBits(float value) {
+        return 0;
+    }
+
+    public static float sum(float a, float b) {
+        return 0;
+    }
+
+    public static float max(float a, float b) {
+        return 0;
+    }
+
+    public static float min(float a, float b) {
+        return 0;
+    }
+
+    /// The size of a float in bytes.
+    public static final int BYTES = 4;
+
+    /// The size of a float in bits.
+    public static final int SIZE = 32;
+
+    /// The bits of precision of a float's significand.
+    public static final int PRECISION = 24;
+
+    /// The largest exponent of a finite float.
+    public static final int MAX_EXPONENT = 127;
+
+    /// The smallest exponent of a normal float.
+    public static final int MIN_EXPONENT = -126;
+
+    /// The smallest positive normal float, 2 to the power -126.
+    public static final float MIN_NORMAL = 0x1.0p-126f;
+
+    /// A Float of `parseFloat(s)`.
+    @Deprecated
+    public Float(String s) throws NumberFormatException {
+    }
+
+    /// Whether `f` is neither infinite nor NaN.
+    public static boolean isFinite(float f) {
+        return false;
+    }
+
+    /// The hash the JDK gives `value`: its bits.
+    public static int hashCode(float value) {
+        return 0;
+    }
+
+    /// The value as a hexadecimal floating point literal, as the JDK writes
+    /// it.
+    public static String toHexString(float f) {
+        return null;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Integer.java b/Ports/CLDC11/src/java/lang/Integer.java
index 9cda08451cf..27d9bd25d5d 100644
--- a/Ports/CLDC11/src/java/lang/Integer.java
+++ b/Ports/CLDC11/src/java/lang/Integer.java
@@ -235,4 +235,155 @@ public static int numberOfLeadingZeros(int i) {
         }
         return 32 - n - 1;
     }
+
+    public static int rotateLeft(int i, int distance) {
+        return 0;
+    }
+
+    public static int sum(int a, int b) {
+        return 0;
+    }
+
+    public static int max(int a, int b) {
+        return 0;
+    }
+
+    public static int min(int a, int b) {
+        return 0;
+    }
+
+    /// The size of an int in bytes.
+    public static final int BYTES = 4;
+
+    /// The size of an int in bits.
+    public static final int SIZE = 32;
+
+    /// An Integer of `parseInt(s)`.
+    @Deprecated
+    public Integer(String s) throws NumberFormatException {
+    }
+
+    /// The value itself.
+    public static int hashCode(int value) {
+        return 0;
+    }
+
+    /// The number of one bits.
+    public static int bitCount(int i) {
+        return 0;
+    }
+
+    /// The highest one bit alone, or 0.
+    public static int highestOneBit(int i) {
+        return 0;
+    }
+
+    /// The lowest one bit alone, or 0.
+    public static int lowestOneBit(int i) {
+        return 0;
+    }
+
+    /// The number of zero bits below the lowest one bit; 32 for zero.
+    public static int numberOfTrailingZeros(int i) {
+        return 0;
+    }
+
+    /// The bits in reverse order.
+    public static int reverse(int i) {
+        return 0;
+    }
+
+    /// The bytes in reverse order.
+    public static int reverseBytes(int i) {
+        return 0;
+    }
+
+    /// The bits rotated right by `distance`.
+    public static int rotateRight(int i, int distance) {
+        return 0;
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(int x, int y) {
+        return 0;
+    }
+
+    /// The value as an unsigned long.
+    public static long toUnsignedLong(int x) {
+        return 0;
+    }
+
+    /// The unsigned quotient.
+    public static int divideUnsigned(int dividend, int divisor) {
+        return 0;
+    }
+
+    /// The unsigned remainder.
+    public static int remainderUnsigned(int dividend, int divisor) {
+        return 0;
+    }
+
+    /// The value as an unsigned decimal string.
+    public static String toUnsignedString(int i) {
+        return null;
+    }
+
+    /// The value as an unsigned string in `radix`.
+    public static String toUnsignedString(int i, int radix) {
+        return null;
+    }
+
+    /// Parses an unsigned decimal int.
+    public static int parseUnsignedInt(String s) throws NumberFormatException {
+        return 0;
+    }
+
+    /// Parses an unsigned int in `radix`.
+    public static int parseUnsignedInt(String s, int radix) throws NumberFormatException {
+        return 0;
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as a signed int.
+    public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        return 0;
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as an unsigned int.
+    public static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        return 0;
+    }
+
+    /// Decodes a decimal, `0x`, `0X`, `#` or leading-zero octal int, with an
+    /// optional sign.
+    public static Integer decode(String nm) throws NumberFormatException {
+        return null;
+    }
+
+    /// The system property `nm` as an Integer, or null.
+    public static Integer getInteger(String nm) {
+        return null;
+    }
+
+    /// The system property `nm` as an Integer, or `val`.
+    public static Integer getInteger(String nm, int val) {
+        return null;
+    }
+
+    /// The system property `nm` decoded as an Integer, or `val` when it is
+    /// unset or not a number.
+    public static Integer getInteger(String nm, Integer val) {
+        return null;
+    }
+
+    /// The bits of `i` selected by `mask`, packed to the low end.
+    public static int compress(int i, int mask) {
+        return 0;
+    }
+
+    /// The low bits of `i` spread to the positions of the one bits of `mask`.
+    public static int expand(int i, int mask) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Iterable.java b/Ports/CLDC11/src/java/lang/Iterable.java
index 4c19f8cea0f..7b47dda2fe0 100644
--- a/Ports/CLDC11/src/java/lang/Iterable.java
+++ b/Ports/CLDC11/src/java/lang/Iterable.java
@@ -39,4 +39,9 @@ public interface Iterable<T> {
     /// from the platform's JDK at runtime.
     default void forEach(Consumer<? super T> action) {
     }
+
+    /// The elements, as a [java.util.Spliterator] whose size is not known.
+    default java.util.Spliterator<T> spliterator() {
+        return java.util.Spliterators.spliteratorUnknownSize(iterator(), 0);
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Long.java b/Ports/CLDC11/src/java/lang/Long.java
index 442dd006c9c..5d00927a026 100644
--- a/Ports/CLDC11/src/java/lang/Long.java
+++ b/Ports/CLDC11/src/java/lang/Long.java
@@ -139,4 +139,185 @@ public static int compare(long l1, long l2) {
     public int compareTo(Long l) {
         return compare(this, l);
     }
+
+    public static int hashCode(long value) {
+        return 0;
+    }
+
+    public static long sum(long a, long b) {
+        return 0;
+    }
+
+    public static long max(long a, long b) {
+        return 0;
+    }
+
+    public static long min(long a, long b) {
+        return 0;
+    }
+
+    /// The size of a long in bytes.
+    public static final int BYTES = 8;
+
+    /// The size of a long in bits.
+    public static final int SIZE = 64;
+
+    /// A Long of `parseLong(s)`.
+    @Deprecated
+    public Long(String s) throws NumberFormatException {
+    }
+
+    /// A Long of `parseLong(s)`.
+    public static Long valueOf(String s) throws NumberFormatException {
+        return null;
+    }
+
+    /// A Long of `parseLong(s, radix)`.
+    public static Long valueOf(String s, int radix) throws NumberFormatException {
+        return null;
+    }
+
+    /// The number of one bits.
+    public static int bitCount(long i) {
+        return 0;
+    }
+
+    /// The highest one bit alone, or 0.
+    public static long highestOneBit(long i) {
+        return 0;
+    }
+
+    /// The lowest one bit alone, or 0.
+    public static long lowestOneBit(long i) {
+        return 0;
+    }
+
+    /// The number of zero bits above the highest one bit; 64 for zero.
+    public static int numberOfLeadingZeros(long i) {
+        return 0;
+    }
+
+    /// The number of zero bits below the lowest one bit; 64 for zero.
+    public static int numberOfTrailingZeros(long i) {
+        return 0;
+    }
+
+    /// The bits in reverse order.
+    public static long reverse(long i) {
+        return 0;
+    }
+
+    /// The bytes in reverse order.
+    public static long reverseBytes(long i) {
+        return 0;
+    }
+
+    /// The bits rotated left by `distance`.
+    public static long rotateLeft(long i, int distance) {
+        return 0;
+    }
+
+    /// The bits rotated right by `distance`.
+    public static long rotateRight(long i, int distance) {
+        return 0;
+    }
+
+    /// -1, 0 or 1 by the sign of `i`.
+    public static int signum(long i) {
+        return 0;
+    }
+
+    /// The value as unsigned hexadecimal digits.
+    public static String toHexString(long i) {
+        return null;
+    }
+
+    /// The value as unsigned octal digits.
+    public static String toOctalString(long i) {
+        return null;
+    }
+
+    /// The value as unsigned binary digits.
+    public static String toBinaryString(long i) {
+        return null;
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(long x, long y) {
+        return 0;
+    }
+
+    /// The unsigned quotient.
+    public static long divideUnsigned(long dividend, long divisor) {
+        return 0;
+    }
+
+    /// The unsigned remainder.
+    public static long remainderUnsigned(long dividend, long divisor) {
+        return 0;
+    }
+
+    /// The value as an unsigned decimal string.
+    public static String toUnsignedString(long i) {
+        return null;
+    }
+
+    /// The value as an unsigned string in `radix`.
+    public static String toUnsignedString(long i, int radix) {
+        return null;
+    }
+
+    /// Parses an unsigned decimal long.
+    public static long parseUnsignedLong(String s) throws NumberFormatException {
+        return 0;
+    }
+
+    /// Parses an unsigned long in `radix`.
+    public static long parseUnsignedLong(String s, int radix) throws NumberFormatException {
+        return 0;
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as a signed long.
+    public static long parseLong(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        return 0;
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as an unsigned long.
+    public static long parseUnsignedLong(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        return 0;
+    }
+
+    /// Decodes a decimal, `0x`, `0X`, `#` or leading-zero octal long, with an
+    /// optional sign.
+    public static Long decode(String nm) throws NumberFormatException {
+        return null;
+    }
+
+    /// The system property `nm` as a Long, or null.
+    public static Long getLong(String nm) {
+        return null;
+    }
+
+    /// The system property `nm` as a Long, or `val`.
+    public static Long getLong(String nm, long val) {
+        return null;
+    }
+
+    /// The system property `nm` decoded as a Long, or `val` when it is unset
+    /// or not a number.
+    public static Long getLong(String nm, Long val) {
+        return null;
+    }
+
+    /// The bits of `i` selected by `mask`, packed to the low end.
+    public static long compress(long i, long mask) {
+        return 0;
+    }
+
+    /// The low bits of `i` spread to the positions of the one bits of `mask`.
+    public static long expand(long i, long mask) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/MatchException.java b/Ports/CLDC11/src/java/lang/MatchException.java
new file mode 100644
index 00000000000..eb3e1aab5dd
--- /dev/null
+++ b/Ports/CLDC11/src/java/lang/MatchException.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang;
+
+/// `java.lang.MatchException`: what a `switch` over patterns throws when no
+/// case matched a value it was compiled to cover -- a sealed type or an enum
+/// that gained a member after the switch was compiled -- or when a record's
+/// accessor failed while a pattern took the record apart.
+///
+/// javac names it in the code of every exhaustive pattern switch, so the
+/// class has to exist on a device for such a switch to load at all.
+public final class MatchException extends RuntimeException {
+    /// A failed match, with what caused it or null.
+    public MatchException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/lang/Math.java b/Ports/CLDC11/src/java/lang/Math.java
index 8129b172ad8..6211893d782 100644
--- a/Ports/CLDC11/src/java/lang/Math.java
+++ b/Ports/CLDC11/src/java/lang/Math.java
@@ -231,6 +231,314 @@ public static double nextAfter(double start, double direction) {
     public static float nextAfter(float start, double direction) {
         return 0;
     }
- 
-    
+
+    /// Twice pi, the ratio of a circle's circumference to its radius.
+    public static final double TAU = 2.0 * PI;
+
+    /// A pseudo-random double in `[0, 1)`.
+    public static double random() {
+        return 0;
+    }
+
+    /// -1.0, 0.0 or 1.0 by the sign of `d`; a zero or NaN is returned as it is.
+    public static double signum(double d) {
+        return 0;
+    }
+
+    /// -1.0f, 0.0f or 1.0f by the sign of `f`; a zero or NaN is returned as it is.
+    public static float signum(float f) {
+        return 0;
+    }
+
+    /// `magnitude` with the sign bit of `sign`.
+    public static double copySign(double magnitude, double sign) {
+        return 0;
+    }
+
+    /// `magnitude` with the sign bit of `sign`.
+    public static float copySign(float magnitude, float sign) {
+        return 0;
+    }
+
+    /// The unbiased exponent of `d`: 1024 for NaN and the infinities, -1023
+    /// for zero and the subnormals.
+    public static int getExponent(double d) {
+        return 0;
+    }
+
+    /// The unbiased exponent of `f`: 128 for NaN and the infinities, -127 for
+    /// zero and the subnormals.
+    public static int getExponent(float f) {
+        return 0;
+    }
+
+    /// The distance from `d` to the next double of larger magnitude.
+    public static double ulp(double d) {
+        return 0;
+    }
+
+    /// The distance from `f` to the next float of larger magnitude.
+    public static float ulp(float f) {
+        return 0;
+    }
+
+    /// The double next to `d` towards positive infinity.
+    public static double nextUp(double d) {
+        return 0;
+    }
+
+    /// The float next to `f` towards positive infinity.
+    public static float nextUp(float f) {
+        return 0;
+    }
+
+    /// The float next to `f` towards negative infinity.
+    public static float nextDown(float f) {
+        return 0;
+    }
+
+    /// `d` times 2 to the power `scaleFactor`, rounded once.
+    public static double scalb(double d, int scaleFactor) {
+        return 0;
+    }
+
+    /// `f` times 2 to the power `scaleFactor`, rounded once.
+    public static float scalb(float f, int scaleFactor) {
+        return 0;
+    }
+
+    /// The square root of `x * x + y * y`, without overflow in between.
+    public static double hypot(double x, double y) {
+        return 0;
+    }
+
+    /// The cube root of `a`.
+    public static double cbrt(double a) {
+        return 0;
+    }
+
+    /// The whole number nearest `a`; a tie goes to the even one.
+    public static double rint(double a) {
+        return 0;
+    }
+
+    /// The hyperbolic sine of `x`.
+    public static double sinh(double x) {
+        return 0;
+    }
+
+    /// The hyperbolic cosine of `x`.
+    public static double cosh(double x) {
+        return 0;
+    }
+
+    /// The hyperbolic tangent of `x`.
+    public static double tanh(double x) {
+        return 0;
+    }
+
+    /// The largest int not greater than `x / y`.
+    public static int floorDiv(int x, int y) {
+        return 0;
+    }
+
+    /// The largest long not greater than `x / y`.
+    public static long floorDiv(long x, int y) {
+        return 0;
+    }
+
+    /// The largest long not greater than `x / y`.
+    public static long floorDiv(long x, long y) {
+        return 0;
+    }
+
+    /// `x - floorDiv(x, y) * y`: the remainder with the sign of `y`.
+    public static int floorMod(int x, int y) {
+        return 0;
+    }
+
+    /// `x - floorDiv(x, y) * y`: the remainder with the sign of `y`.
+    public static int floorMod(long x, int y) {
+        return 0;
+    }
+
+    /// `x - floorDiv(x, y) * y`: the remainder with the sign of `y`.
+    public static long floorMod(long x, long y) {
+        return 0;
+    }
+
+    /// The smallest int not less than `x / y`.
+    public static int ceilDiv(int x, int y) {
+        return 0;
+    }
+
+    /// The smallest long not less than `x / y`.
+    public static long ceilDiv(long x, int y) {
+        return 0;
+    }
+
+    /// The smallest long not less than `x / y`.
+    public static long ceilDiv(long x, long y) {
+        return 0;
+    }
+
+    /// `x - ceilDiv(x, y) * y`.
+    public static int ceilMod(int x, int y) {
+        return 0;
+    }
+
+    /// `x - ceilDiv(x, y) * y`.
+    public static int ceilMod(long x, int y) {
+        return 0;
+    }
+
+    /// `x - ceilDiv(x, y) * y`.
+    public static long ceilMod(long x, long y) {
+        return 0;
+    }
+
+    /// `x / y`, throwing on the one quotient that overflows.
+    public static int divideExact(int x, int y) {
+        return 0;
+    }
+
+    /// `x / y`, throwing on the one quotient that overflows.
+    public static long divideExact(long x, long y) {
+        return 0;
+    }
+
+    /// `floorDiv(x, y)`, throwing on the one quotient that overflows.
+    public static int floorDivExact(int x, int y) {
+        return 0;
+    }
+
+    /// `floorDiv(x, y)`, throwing on the one quotient that overflows.
+    public static long floorDivExact(long x, long y) {
+        return 0;
+    }
+
+    /// `ceilDiv(x, y)`, throwing on the one quotient that overflows.
+    public static int ceilDivExact(int x, int y) {
+        return 0;
+    }
+
+    /// `ceilDiv(x, y)`, throwing on the one quotient that overflows.
+    public static long ceilDivExact(long x, long y) {
+        return 0;
+    }
+
+    /// `x + y`, throwing when it overflows.
+    public static int addExact(int x, int y) {
+        return 0;
+    }
+
+    /// `x + y`, throwing when it overflows.
+    public static long addExact(long x, long y) {
+        return 0;
+    }
+
+    /// `x - y`, throwing when it overflows.
+    public static int subtractExact(int x, int y) {
+        return 0;
+    }
+
+    /// `x - y`, throwing when it overflows.
+    public static long subtractExact(long x, long y) {
+        return 0;
+    }
+
+    /// `x * y`, throwing when it overflows.
+    public static int multiplyExact(int x, int y) {
+        return 0;
+    }
+
+    /// `x * y`, throwing when it overflows.
+    public static long multiplyExact(long x, int y) {
+        return 0;
+    }
+
+    /// `x * y`, throwing when it overflows.
+    public static long multiplyExact(long x, long y) {
+        return 0;
+    }
+
+    /// The exact product of two ints.
+    public static long multiplyFull(int x, int y) {
+        return 0;
+    }
+
+    /// The high 64 bits of the 128-bit product of two signed longs.
+    public static long multiplyHigh(long x, long y) {
+        return 0;
+    }
+
+    /// The high 64 bits of the 128-bit product of two unsigned longs.
+    public static long unsignedMultiplyHigh(long x, long y) {
+        return 0;
+    }
+
+    /// `a + 1`, throwing when it overflows.
+    public static int incrementExact(int a) {
+        return 0;
+    }
+
+    /// `a + 1`, throwing when it overflows.
+    public static long incrementExact(long a) {
+        return 0;
+    }
+
+    /// `a - 1`, throwing when it overflows.
+    public static int decrementExact(int a) {
+        return 0;
+    }
+
+    /// `a - 1`, throwing when it overflows.
+    public static long decrementExact(long a) {
+        return 0;
+    }
+
+    /// `-a`, throwing when it overflows.
+    public static int negateExact(int a) {
+        return 0;
+    }
+
+    /// `-a`, throwing when it overflows.
+    public static long negateExact(long a) {
+        return 0;
+    }
+
+    /// The value as an int, throwing when it does not fit.
+    public static int toIntExact(long value) {
+        return 0;
+    }
+
+    /// The absolute value, throwing for `Integer.MIN_VALUE`, which has none.
+    public static int absExact(int a) {
+        return 0;
+    }
+
+    /// The absolute value, throwing for `Long.MIN_VALUE`, which has none.
+    public static long absExact(long a) {
+        return 0;
+    }
+
+    /// `value` clamped to `[min, max]`, as an int.
+    public static int clamp(long value, int min, int max) {
+        return 0;
+    }
+
+    /// `value` clamped to `[min, max]`.
+    public static long clamp(long value, long min, long max) {
+        return 0;
+    }
+
+    /// `value` clamped to `[min, max]`.
+    public static double clamp(double value, double min, double max) {
+        return 0;
+    }
+
+    /// `value` clamped to `[min, max]`.
+    public static float clamp(float value, float min, float max) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/Module.java b/Ports/CLDC11/src/java/lang/Module.java
new file mode 100644
index 00000000000..3ab4b321139
--- /dev/null
+++ b/Ports/CLDC11/src/java/lang/Module.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang;
+
+/// The module a class is in, as far as an application without modules has
+/// one: the single unnamed module every class of it is in.
+///
+/// [Class#getModule()] answers it for every class. It has no name, no layer
+/// and no descriptor, which is what the JDK answers for a class loaded from
+/// the class path, and what code that asks in order to choose between the
+/// module path and the class path needs to hear. Nothing else of the module
+/// system is here.
+public final class Module {
+
+    // Made by this class's own initializer, which only a getModule() call runs.
+    private static final Module UNNAMED = new Module();
+
+    private Module() {
+    }
+
+    /// The one module.
+    static Module unnamed() {
+        return UNNAMED;
+    }
+
+    /// False: the one module there is has no name.
+    public boolean isNamed() {
+        return false;
+    }
+
+    /// Null, as for every unnamed module.
+    public String getName() {
+        return null;
+    }
+
+    /// Null: an unnamed module is in no layer.
+    public ModuleLayer getLayer() {
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return "unnamed module @" + Integer.toHexString(hashCode());
+    }
+}
diff --git a/Ports/CLDC11/src/java/lang/ModuleLayer.java b/Ports/CLDC11/src/java/lang/ModuleLayer.java
new file mode 100644
index 00000000000..282fba9c41a
--- /dev/null
+++ b/Ports/CLDC11/src/java/lang/ModuleLayer.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang;
+
+/// `java.lang.ModuleLayer`, as a type only. An application without modules
+/// has no layer: [Module#getLayer()] answers null and nothing creates an
+/// instance of this class. It exists so that code which asks for a class's
+/// layer, and takes the class path route when there is none, links.
+public final class ModuleLayer {
+
+    private ModuleLayer() {
+    }
+}
diff --git a/Ports/CLDC11/src/java/lang/Runtime.java b/Ports/CLDC11/src/java/lang/Runtime.java
index 9f9571703db..1f33fd15bb9 100644
--- a/Ports/CLDC11/src/java/lang/Runtime.java
+++ b/Ports/CLDC11/src/java/lang/Runtime.java
@@ -26,6 +26,34 @@
 /// An application cannot create its own instance of this class.
 /// Since: JDK1.0, CLDC 1.0 See Also:getRuntime()
 public class Runtime{
+    private Runtime() {
+    }
+
+    /// Ends the process at once, without running the shutdown hooks.
+    public void halt(int status) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Registers a hook that `exit` runs before the application closes.
+    public void addShutdownHook(Thread hook) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Unregisters a hook; whether it was registered.
+    public boolean removeShutdownHook(Thread hook) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// The number of processors available to the program.
+    public int availableProcessors() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// The most memory the program may use.
+    public long maxMemory() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
     /// Terminates the currently running Java application. This method never returns normally.
     /// The argument serves as a status code; by convention, a nonzero status code indicates abnormal termination.
     public void exit(int status){
diff --git a/Ports/CLDC11/src/java/lang/Short.java b/Ports/CLDC11/src/java/lang/Short.java
index d2fd8c381a8..5b71ae296dd 100644
--- a/Ports/CLDC11/src/java/lang/Short.java
+++ b/Ports/CLDC11/src/java/lang/Short.java
@@ -110,4 +110,62 @@ public int compareTo(Short another) {
     public static int compare(short s1, short s2) {
         return s1 < s2 ? -1 : s1 > s2 ? 1 : 0;
     }
+
+    public static final Class<Short> TYPE = null;
+
+    /// The size of a short in bytes.
+    public static final int BYTES = 2;
+
+    /// The size of a short in bits.
+    public static final int SIZE = 16;
+
+    /// A Short of `parseShort(s)`.
+    @Deprecated
+    public Short(String s) throws NumberFormatException {
+    }
+
+    /// The decimal string of `s`.
+    public static String toString(short s) {
+        return null;
+    }
+
+    /// A Short of `parseShort(s)`.
+    public static Short valueOf(String s) throws NumberFormatException {
+        return null;
+    }
+
+    /// A Short of `parseShort(s, radix)`.
+    public static Short valueOf(String s, int radix) throws NumberFormatException {
+        return null;
+    }
+
+    /// Decodes a decimal, hexadecimal or octal short, as `Integer.decode`.
+    public static Short decode(String nm) throws NumberFormatException {
+        return null;
+    }
+
+    /// The value itself.
+    public static int hashCode(short value) {
+        return 0;
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(short x, short y) {
+        return 0;
+    }
+
+    /// The value as an unsigned int.
+    public static int toUnsignedInt(short x) {
+        return 0;
+    }
+
+    /// The value as an unsigned long.
+    public static long toUnsignedLong(short x) {
+        return 0;
+    }
+
+    /// The bytes in reverse order.
+    public static short reverseBytes(short i) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/StrictMath.java b/Ports/CLDC11/src/java/lang/StrictMath.java
new file mode 100644
index 00000000000..57309f6a248
--- /dev/null
+++ b/Ports/CLDC11/src/java/lang/StrictMath.java
@@ -0,0 +1,472 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package java.lang;
+
+/// The JDK's StrictMath. Every member answers exactly as the `Math` member
+/// of the same name: this runtime has one implementation of each function,
+/// so the results are the same on every platform it runs on, which is what
+/// StrictMath promises.
+public final class StrictMath {
+    private StrictMath() {
+    }
+
+    /// As `Math.E`.
+    public static final double E = Math.E;
+
+    /// As `Math.PI`.
+    public static final double PI = Math.PI;
+
+    /// As `Math.TAU`.
+    public static final double TAU = Math.TAU;
+
+    /// As `Math.abs`.
+    public static double abs(double a) {
+        return 0;
+    }
+
+    /// As `Math.abs`.
+    public static float abs(float a) {
+        return 0;
+    }
+
+    /// As `Math.abs`.
+    public static int abs(int a) {
+        return 0;
+    }
+
+    /// As `Math.abs`.
+    public static long abs(long a) {
+        return 0;
+    }
+
+    /// As `Math.ceil`.
+    public static double ceil(double a) {
+        return 0;
+    }
+
+    /// As `Math.cos`.
+    public static double cos(double a) {
+        return 0;
+    }
+
+    /// As `Math.floor`.
+    public static double floor(double a) {
+        return 0;
+    }
+
+    /// As `Math.max`.
+    public static double max(double a, double b) {
+        return 0;
+    }
+
+    /// As `Math.max`.
+    public static float max(float a, float b) {
+        return 0;
+    }
+
+    /// As `Math.max`.
+    public static int max(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.max`.
+    public static long max(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.min`.
+    public static double min(double a, double b) {
+        return 0;
+    }
+
+    /// As `Math.min`.
+    public static float min(float a, float b) {
+        return 0;
+    }
+
+    /// As `Math.min`.
+    public static int min(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.min`.
+    public static long min(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.sin`.
+    public static double sin(double a) {
+        return 0;
+    }
+
+    /// As `Math.sqrt`.
+    public static double sqrt(double a) {
+        return 0;
+    }
+
+    /// As `Math.tan`.
+    public static double tan(double a) {
+        return 0;
+    }
+
+    /// As `Math.toDegrees`.
+    public static double toDegrees(double a) {
+        return 0;
+    }
+
+    /// As `Math.toRadians`.
+    public static double toRadians(double a) {
+        return 0;
+    }
+
+    /// As `Math.round`.
+    public static long round(double a) {
+        return 0;
+    }
+
+    /// As `Math.round`.
+    public static int round(float a) {
+        return 0;
+    }
+
+    /// As `Math.nextDown`.
+    public static double nextDown(double a) {
+        return 0;
+    }
+
+    /// As `Math.nextAfter`.
+    public static double nextAfter(double a, double b) {
+        return 0;
+    }
+
+    /// As `Math.nextAfter`.
+    public static float nextAfter(float a, double b) {
+        return 0;
+    }
+
+    /// As `Math.random`.
+    public static double random() {
+        return 0;
+    }
+
+    /// As `Math.signum`.
+    public static double signum(double a) {
+        return 0;
+    }
+
+    /// As `Math.signum`.
+    public static float signum(float a) {
+        return 0;
+    }
+
+    /// As `Math.copySign`.
+    public static double copySign(double a, double b) {
+        return 0;
+    }
+
+    /// As `Math.copySign`.
+    public static float copySign(float a, float b) {
+        return 0;
+    }
+
+    /// As `Math.getExponent`.
+    public static int getExponent(double a) {
+        return 0;
+    }
+
+    /// As `Math.getExponent`.
+    public static int getExponent(float a) {
+        return 0;
+    }
+
+    /// As `Math.ulp`.
+    public static double ulp(double a) {
+        return 0;
+    }
+
+    /// As `Math.ulp`.
+    public static float ulp(float a) {
+        return 0;
+    }
+
+    /// As `Math.nextUp`.
+    public static double nextUp(double a) {
+        return 0;
+    }
+
+    /// As `Math.nextUp`.
+    public static float nextUp(float a) {
+        return 0;
+    }
+
+    /// As `Math.nextDown`.
+    public static float nextDown(float a) {
+        return 0;
+    }
+
+    /// As `Math.scalb`.
+    public static double scalb(double a, int b) {
+        return 0;
+    }
+
+    /// As `Math.scalb`.
+    public static float scalb(float a, int b) {
+        return 0;
+    }
+
+    /// As `Math.hypot`.
+    public static double hypot(double a, double b) {
+        return 0;
+    }
+
+    /// As `Math.cbrt`.
+    public static double cbrt(double a) {
+        return 0;
+    }
+
+    /// As `Math.rint`.
+    public static double rint(double a) {
+        return 0;
+    }
+
+    /// As `Math.sinh`.
+    public static double sinh(double a) {
+        return 0;
+    }
+
+    /// As `Math.cosh`.
+    public static double cosh(double a) {
+        return 0;
+    }
+
+    /// As `Math.tanh`.
+    public static double tanh(double a) {
+        return 0;
+    }
+
+    /// As `Math.floorDiv`.
+    public static int floorDiv(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.floorDiv`.
+    public static long floorDiv(long a, int b) {
+        return 0;
+    }
+
+    /// As `Math.floorDiv`.
+    public static long floorDiv(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.floorMod`.
+    public static int floorMod(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.floorMod`.
+    public static int floorMod(long a, int b) {
+        return 0;
+    }
+
+    /// As `Math.floorMod`.
+    public static long floorMod(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.ceilDiv`.
+    public static int ceilDiv(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.ceilDiv`.
+    public static long ceilDiv(long a, int b) {
+        return 0;
+    }
+
+    /// As `Math.ceilDiv`.
+    public static long ceilDiv(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.ceilMod`.
+    public static int ceilMod(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.ceilMod`.
+    public static int ceilMod(long a, int b) {
+        return 0;
+    }
+
+    /// As `Math.ceilMod`.
+    public static long ceilMod(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.divideExact`.
+    public static int divideExact(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.divideExact`.
+    public static long divideExact(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.floorDivExact`.
+    public static int floorDivExact(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.floorDivExact`.
+    public static long floorDivExact(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.ceilDivExact`.
+    public static int ceilDivExact(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.ceilDivExact`.
+    public static long ceilDivExact(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.addExact`.
+    public static int addExact(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.addExact`.
+    public static long addExact(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.subtractExact`.
+    public static int subtractExact(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.subtractExact`.
+    public static long subtractExact(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.multiplyExact`.
+    public static int multiplyExact(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.multiplyExact`.
+    public static long multiplyExact(long a, int b) {
+        return 0;
+    }
+
+    /// As `Math.multiplyExact`.
+    public static long multiplyExact(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.multiplyFull`.
+    public static long multiplyFull(int a, int b) {
+        return 0;
+    }
+
+    /// As `Math.multiplyHigh`.
+    public static long multiplyHigh(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.unsignedMultiplyHigh`.
+    public static long unsignedMultiplyHigh(long a, long b) {
+        return 0;
+    }
+
+    /// As `Math.incrementExact`.
+    public static int incrementExact(int a) {
+        return 0;
+    }
+
+    /// As `Math.incrementExact`.
+    public static long incrementExact(long a) {
+        return 0;
+    }
+
+    /// As `Math.decrementExact`.
+    public static int decrementExact(int a) {
+        return 0;
+    }
+
+    /// As `Math.decrementExact`.
+    public static long decrementExact(long a) {
+        return 0;
+    }
+
+    /// As `Math.negateExact`.
+    public static int negateExact(int a) {
+        return 0;
+    }
+
+    /// As `Math.negateExact`.
+    public static long negateExact(long a) {
+        return 0;
+    }
+
+    /// As `Math.toIntExact`.
+    public static int toIntExact(long a) {
+        return 0;
+    }
+
+    /// As `Math.absExact`.
+    public static int absExact(int a) {
+        return 0;
+    }
+
+    /// As `Math.absExact`.
+    public static long absExact(long a) {
+        return 0;
+    }
+
+    /// As `Math.clamp`.
+    public static int clamp(long a, int b, int c) {
+        return 0;
+    }
+
+    /// As `Math.clamp`.
+    public static long clamp(long a, long b, long c) {
+        return 0;
+    }
+
+    /// As `Math.clamp`.
+    public static double clamp(double a, double b, double c) {
+        return 0;
+    }
+
+    /// As `Math.clamp`.
+    public static float clamp(float a, float b, float c) {
+        return 0;
+    }
+}
diff --git a/Ports/CLDC11/src/java/lang/String.java b/Ports/CLDC11/src/java/lang/String.java
index 853d60a73fc..30e1bf8fb62 100644
--- a/Ports/CLDC11/src/java/lang/String.java
+++ b/Ports/CLDC11/src/java/lang/String.java
@@ -68,14 +68,10 @@ public String(byte[] bytes, int off, int len, java.lang.String enc) throws java.
     }
     
     /// Construct a new String by converting the specified array of bytes using the specified character encoding. The length of the new String is a function of the encoding, and hence may not be equal to the length of the byte array.
-    /// bytes - The bytes to be converted into charactersenc - The name of a supported character encoding
-    /// - If the named encoding is not supported
-    ///
-    /// #### Since
-    ///
-    /// 8.0
-    public String(byte[] bytes, java.nio.charset.Charset charset) throws java.io.UnsupportedEncodingException {
-        this(bytes, 0, bytes.length, charset.name());
+    /// Unlike the constructor taking a charset name, this throws no checked
+    /// exception.
+    public String(byte[] bytes, java.nio.charset.Charset charset) {
+        this(bytes, 0, bytes.length, charset);
     }
 
     /// Construct a new String by converting the specified array of bytes using the specified character encoding. The length of the new String is a function of the encoding, and hence may not be equal to the length of the byte array.
@@ -186,8 +182,9 @@ public byte[] getBytes(java.lang.String enc) throws java.io.UnsupportedEncodingE
     }
     
     /// Convert this String into bytes according to the specified character encoding, storing the result into a new byte array.
-    public byte[] getBytes(Charset charset) throws java.io.UnsupportedEncodingException {
-        return getBytes(charset.name());
+    /// Unlike `getBytes(String)`, this throws no checked exception.
+    public byte[] getBytes(Charset charset) {
+        return null;
     }
 
     /// Copies characters from this string into the destination character array.
@@ -425,7 +422,8 @@ public static java.lang.String valueOf(char c){
         return null; //TODO codavaj!!
     }
 
-    java.lang.String valueOf(char[] data){
+    /// Returns the string representation of the char array argument.
+    public static java.lang.String valueOf(char[] data){
         return null; //TODO codavaj!!
     }
 
@@ -519,4 +517,118 @@ public boolean regionMatches(int thisStart, String string, int start, int length
         return false;
     }
 
+    /// A string of the code points `codePoints[offset]` to
+    /// `codePoints[offset + count - 1]`.
+    public String(int[] codePoints, int offset, int count) {
+    }
+
+    /// Decodes `length` bytes of `bytes` from `offset` with `charset`.
+    public String(byte[] bytes, int offset, int length, java.nio.charset.Charset charset) {
+    }
+
+    /// The code point at `index`.
+    public int codePointAt(int index) {
+        return 0;
+    }
+
+    /// The code point that ends just before `index`.
+    public int codePointBefore(int index) {
+        return 0;
+    }
+
+    /// The number of code points between `beginIndex` and `endIndex`.
+    public int codePointCount(int beginIndex, int endIndex) {
+        return 0;
+    }
+
+    /// The index `codePointOffset` code points away from `index`.
+    public int offsetByCodePoints(int index, int codePointOffset) {
+        return 0;
+    }
+
+    /// The first index of `ch` in `[beginIndex, endIndex)`, or -1.
+    public int indexOf(int ch, int beginIndex, int endIndex) {
+        return -1;
+    }
+
+    /// The first index of `str` that lies wholly in `[beginIndex, endIndex)`, or -1.
+    public int indexOf(String str, int beginIndex, int endIndex) {
+        return -1;
+    }
+
+    /// The elements with `delimiter` between every two.
+    public static String join(CharSequence delimiter, CharSequence... elements) {
+        return null;
+    }
+
+    /// The elements with `delimiter` between every two.
+    public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {
+        return null;
+    }
+
+    /// As `format(String, Object...)`.
+    public static String format(java.util.Locale l, String format, Object... args) {
+        return null;
+    }
+
+    /// As `toLowerCase()`.
+    public java.lang.String toLowerCase(java.util.Locale locale) {
+        return null;
+    }
+
+    /// `String.format(this, args)`.
+    public String formatted(Object... args) {
+        return null;
+    }
+
+    /// Whether the string is empty or holds nothing but white space.
+    public boolean isBlank() {
+        return false;
+    }
+
+    /// The string without its leading and trailing white space.
+    public String strip() {
+        return null;
+    }
+
+    /// The string without its leading white space.
+    public String stripLeading() {
+        return null;
+    }
+
+    /// The string without its trailing white space.
+    public String stripTrailing() {
+        return null;
+    }
+
+    /// The string `count` times over.
+    public String repeat(int count) {
+        return null;
+    }
+
+    /// The lines of the string, without their terminators.
+    public java.util.stream.Stream<String> lines() {
+        return null;
+    }
+
+    /// Every line indented by `n` spaces, or outdented for a negative `n`.
+    public String indent(int n) {
+        return null;
+    }
+
+    /// The string with the indentation common to its lines removed.
+    public String stripIndent() {
+        return null;
+    }
+
+    /// The string with its escape sequences translated.
+    public String translateEscapes() {
+        return null;
+    }
+
+    /// `f.apply(this)`.
+    public <R> R transform(java.util.function.Function<? super String, ? extends R> f) {
+        return null;
+    }
+
 }
diff --git a/Ports/CLDC11/src/java/lang/StringBuffer.java b/Ports/CLDC11/src/java/lang/StringBuffer.java
index 38e02416a46..10342c3d1d7 100644
--- a/Ports/CLDC11/src/java/lang/StringBuffer.java
+++ b/Ports/CLDC11/src/java/lang/StringBuffer.java
@@ -31,7 +31,7 @@
 /// In general, if sb refers to an instance of a StringBuffer, then sb.append(x) has the same effect as sb.insert(sb.length(),x).
 /// Every string buffer has a capacity. As long as the length of the character sequence contained in the string buffer does not exceed the capacity, it is not necessary to allocate a new internal buffer array. If the internal buffer overflows, it is automatically made larger.
 /// Since: JDK1.0, CLDC 1.0 See Also:ByteArrayOutputStream, String
-public final class StringBuffer implements CharSequence {
+public final class StringBuffer implements CharSequence, Appendable, Comparable<StringBuffer> {
     /// Constructs a string buffer with no characters in it and an initial capacity of 16 characters.
     public StringBuffer(){
          //TODO codavaj!!
@@ -63,7 +63,7 @@ public java.lang.StringBuffer append(char c){
         return null; //TODO codavaj!!
     }
 
-    java.lang.StringBuffer append(char[] str){
+    public java.lang.StringBuffer append(char[] str){
         return null; //TODO codavaj!!
     }
 
@@ -158,7 +158,7 @@ public java.lang.StringBuffer insert(int offset, char c){
         return null; //TODO codavaj!!
     }
 
-    java.lang.StringBuffer insert(int offset, char[] str){
+    public java.lang.StringBuffer insert(int offset, char[] str){
         return null; //TODO codavaj!!
     }
 
@@ -239,9 +239,9 @@ public java.lang.String toString(){
         return null; //TODO codavaj!!
     }
 
-    	public StringBuffer StringBuffer(java.lang.CharSequence cs) {
-		return new StringBuffer(cs.toString());
-	}
+    /// A StringBuffer holding the characters of `cs`.
+    public StringBuffer(java.lang.CharSequence cs) {
+    }
 
 	public void trimToSize() {
 		// do nothing: according to the 1.5 javadoc,
@@ -273,5 +273,88 @@ public CharSequence subSequence(int start, int end) {
         return null;
     }
 
+    /// Appends the contents of `sb`, or `"null"`.
+    public synchronized StringBuffer append(StringBuffer sb) {
+        return null;
+    }
+
+    /// Inserts `len` chars of `str` from `offset` at `index`.
+    public synchronized StringBuffer insert(int index, char[] str, int offset, int len) {
+        return null;
+    }
+
+    /// Appends the code point, as one char or as a surrogate pair.
+    public synchronized StringBuffer appendCodePoint(int codePoint) {
+        return null;
+    }
+
+    /// The code point at `index`.
+    public synchronized int codePointAt(int index) {
+        return 0;
+    }
+
+    /// The code point that ends just before `index`.
+    public synchronized int codePointBefore(int index) {
+        return 0;
+    }
+
+    /// The number of code points between `beginIndex` and `endIndex`.
+    public synchronized int codePointCount(int beginIndex, int endIndex) {
+        return 0;
+    }
+
+    /// The index `codePointOffset` code points away from `index`.
+    public synchronized int offsetByCodePoints(int index, int codePointOffset) {
+        return 0;
+    }
+
+    /// The first index of `str`, or -1.
+    public synchronized int indexOf(String str) {
+        return 0;
+    }
+
+    /// The first index of `str` at or after `fromIndex`, or -1.
+    public synchronized int indexOf(String str, int fromIndex) {
+        return 0;
+    }
+
+    /// The last index of `str`, or -1.
+    public synchronized int lastIndexOf(String str) {
+        return 0;
+    }
+
+    /// The last index of `str` at or before `fromIndex`, or -1.
+    public synchronized int lastIndexOf(String str, int fromIndex) {
+        return 0;
+    }
+
+    /// Replaces the characters from `start` to `end` with `str`.
+    public synchronized StringBuffer replace(int start, int end, String str) {
+        return null;
+    }
+
+    /// The characters from `start` to the end.
+    public synchronized String substring(int start) {
+        return null;
+    }
 
+    /// The characters from `start` to `end`.
+    public synchronized String substring(int start, int end) {
+        return null;
+    }
+
+    /// Appends the code point `count` times.
+    public synchronized StringBuffer repeat(int codePoint, int count) {
+        return null;
+    }
+
+    /// Appends `cs` `count` times.
+    public synchronized StringBuffer repeat(CharSequence cs, int count) {
+        return null;
+    }
+
+    /// Compares the contents lexicographically.
+    public synchronized int compareTo(StringBuffer another) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/StringBuilder.java b/Ports/CLDC11/src/java/lang/StringBuilder.java
index f7d3ac90e1e..46130b048a2 100644
--- a/Ports/CLDC11/src/java/lang/StringBuilder.java
+++ b/Ports/CLDC11/src/java/lang/StringBuilder.java
@@ -31,7 +31,7 @@
 /// In general, if sb refers to an instance of a StringBuilder, then sb.append(x) has the same effect as sb.insert(sb.length(),x).
 /// Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal builder array. If the internal builder overflows, it is automatically made larger.
 /// Since: JDK1.0, CLDC 1.0 See Also:ByteArrayOutputStream, String
-public final class StringBuilder implements CharSequence {
+public final class StringBuilder implements CharSequence, Appendable, Comparable<StringBuilder> {
     /// Constructs a string builder with no characters in it and an initial capacity of 16 characters.
     public StringBuilder(){
          //TODO codavaj!!
@@ -171,7 +171,7 @@ public java.lang.StringBuilder insert(int offset, char c){
         return null; //TODO codavaj!!
     }
 
-    java.lang.StringBuilder insert(int offset, char[] str){
+    public java.lang.StringBuilder insert(int offset, char[] str){
         return null; //TODO codavaj!!
     }
 
@@ -286,5 +286,87 @@ public CharSequence subSequence(int start, int end) {
         return null;
     }
 
+    public StringBuilder insert(int index, char[] value, int offset, int length) {
+        return null;
+    }
+
+    /// The characters from `start` to the end, as a String.
+    public String substring(int start) {
+        return null;
+    }
+
+    /// The characters from `start` to `end`, as a String.
+    public String substring(int start, int end) {
+        return null;
+    }
+
+    /// Appends the code point, as one char or as a surrogate pair.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if it is not a valid code point
+    public StringBuilder appendCodePoint(int codePoint) {
+        return null;
+    }
+
+    /// The code point at `index`.
+    public int codePointAt(int index) {
+        return 0;
+    }
 
+    /// The code point that ends just before `index`.
+    public int codePointBefore(int index) {
+        return 0;
+    }
+
+    /// The number of code points between `beginIndex` and `endIndex`.
+    public int codePointCount(int beginIndex, int endIndex) {
+        return 0;
+    }
+
+    /// The index `codePointOffset` code points away from `index`.
+    public int offsetByCodePoints(int index, int codePointOffset) {
+        return 0;
+    }
+
+    /// The first index of `str`, or -1.
+    public int indexOf(String str) {
+        return 0;
+    }
+
+    /// The first index of `str` at or after `fromIndex`, or -1.
+    public int indexOf(String str, int fromIndex) {
+        return 0;
+    }
+
+    /// The last index of `str`, or -1.
+    public int lastIndexOf(String str) {
+        return 0;
+    }
+
+    /// The last index of `str` at or before `fromIndex`, or -1.
+    public int lastIndexOf(String str, int fromIndex) {
+        return 0;
+    }
+
+    /// Replaces the characters from `start` to `end` (clamped to the length)
+    /// with `str`.
+    public StringBuilder replace(int start, int end, String str) {
+        return null;
+    }
+
+    /// Appends the code point `count` times.
+    public StringBuilder repeat(int codePoint, int count) {
+        return null;
+    }
+
+    /// Appends `cs` (or `"null"`) `count` times.
+    public StringBuilder repeat(CharSequence cs, int count) {
+        return null;
+    }
+
+    /// Compares the contents lexicographically.
+    public int compareTo(StringBuilder another) {
+        return 0;
+    }
 }
diff --git a/Ports/CLDC11/src/java/lang/System.java b/Ports/CLDC11/src/java/lang/System.java
index 359682fac8c..9ceee404836 100644
--- a/Ports/CLDC11/src/java/lang/System.java
+++ b/Ports/CLDC11/src/java/lang/System.java
@@ -92,6 +92,22 @@ public static String clearProperty(String key) {
         throw new RuntimeException("Compile-time stub");
     }
 
+    /// The value of the environment variable `name`, or null when it is not
+    /// set.
+    public static String getenv(String name) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// The environment as a map; empty, since the runtime cannot list it.
+    public static java.util.Map<String, String> getenv() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// The line separator, a single line feed.
+    public static String lineSeparator() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
     /// Returns the same hashcode for the given object as would be returned by the default method hashCode(), whether or not the given object's class overrides hashCode(). The hashcode for the null reference is zero.
     public static int identityHashCode(java.lang.Object x){
         return 0; //TODO codavaj!!
diff --git a/Ports/CLDC11/src/java/lang/Thread.java b/Ports/CLDC11/src/java/lang/Thread.java
index d3eb877d8d7..2f87fe5ea7e 100644
--- a/Ports/CLDC11/src/java/lang/Thread.java
+++ b/Ports/CLDC11/src/java/lang/Thread.java
@@ -128,6 +128,63 @@ public final void join() throws java.lang.InterruptedException{
         return; //TODO codavaj!!
     }
 
+    /// Waits at most `millis` milliseconds for this thread to die; 0 waits
+    /// for as long as it takes.
+    public final synchronized void join(long millis) throws java.lang.InterruptedException {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Waits at most `millis` milliseconds plus `nanos` nanoseconds for this
+    /// thread to die.
+    public final synchronized void join(long millis, int nanos) throws java.lang.InterruptedException {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Sleeps for `millis` milliseconds plus `nanos` nanoseconds.
+    public static void sleep(long millis, int nanos) throws java.lang.InterruptedException {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Changes this thread's name.
+    public final void setName(String name) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// A number that identifies this thread for its lifetime.
+    public long getId() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Handles what a thread's run method throws.
+    public interface UncaughtExceptionHandler {
+        /// Called with the thread and what its run method threw.
+        void uncaughtException(Thread t, Throwable e);
+    }
+
+    /// Sets the handler for what this thread's run method throws; null
+    /// leaves it to the default handler.
+    public void setUncaughtExceptionHandler(UncaughtExceptionHandler handler) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// This thread's handler, or the default handler when it has none.
+    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// Sets the handler for what any thread without its own handler throws.
+    /// In a Codename One application it also receives what an event dispatch
+    /// thread task throws, which then no longer reaches the platform's own
+    /// error handling.
+    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler handler) {
+        throw new RuntimeException("Compile-time stub");
+    }
+
+    /// The handler `setDefaultUncaughtExceptionHandler` set, or null.
+    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
+        throw new RuntimeException("Compile-time stub");
+    }
+
     /// If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.
     /// Subclasses of Thread should override this method.
     public void run(){
diff --git a/Ports/CLDC11/src/java/lang/Throwable.java b/Ports/CLDC11/src/java/lang/Throwable.java
index f4b408fc18b..ee96e063edf 100644
--- a/Ports/CLDC11/src/java/lang/Throwable.java
+++ b/Ports/CLDC11/src/java/lang/Throwable.java
@@ -92,6 +92,10 @@ public void printStackTrace(java.io.PrintStream s){
         return; //TODO codavaj!!
     }
 
+    /// Prints this throwable and its backtrace to the given writer.
+    public void printStackTrace(java.io.PrintWriter s){
+    }
+
     /// Returns a short description of this Throwable object. If this Throwable object was
     /// with an error message string, then the result is the concatenation of three strings: The name of the actual class of this object ": " (a colon and a space) The result of the
     /// method for this object If this Throwable object was
diff --git a/Ports/CLDC11/src/java/lang/reflect/InvocationTargetException.java b/Ports/CLDC11/src/java/lang/reflect/InvocationTargetException.java
new file mode 100644
index 00000000000..77619898d8b
--- /dev/null
+++ b/Ports/CLDC11/src/java/lang/reflect/InvocationTargetException.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang.reflect;
+
+/// `java.lang.reflect.InvocationTargetException` for the Codename One
+/// runtime. A device has no reflective invocation, so nothing here throws
+/// it on its own account: it exists for the code that declares, catches or
+/// wraps it, `EventQueue.invokeAndWait` and `SwingUtilities.invokeAndWait`
+/// first among them.
+public class InvocationTargetException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    private final Throwable target;
+
+    protected InvocationTargetException() {
+        super((Throwable) null);
+        this.target = null;
+    }
+
+    public InvocationTargetException(Throwable target) {
+        super((Throwable) null);
+        this.target = target;
+    }
+
+    public InvocationTargetException(Throwable target, String s) {
+        super(s, null);
+        this.target = target;
+    }
+
+    public Throwable getTargetException() {
+        return target;
+    }
+
+    @Override
+    public Throwable getCause() {
+        return target;
+    }
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileReader.java b/Ports/CLDC11/src/java/net/MalformedURLException.java
similarity index 66%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileReader.java
rename to Ports/CLDC11/src/java/net/MalformedURLException.java
index 7a1eb72a7ee..26ebc362f97 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileReader.java
+++ b/Ports/CLDC11/src/java/net/MalformedURLException.java
@@ -20,21 +20,21 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.net;
 
-import java.io.FileNotFoundException;
-import java.io.InputStreamReader;
-import java.io.UnsupportedEncodingException;
+import java.io.IOException;
 
-/// `java.io.FileReader` for the Codename One runtime. Reads UTF-8, Android's
-/// default charset.
-public class FileReader extends InputStreamReader {
+/// A string
+/// could not be parsed as a URL, or names a protocol nothing handles.
+public class MalformedURLException extends IOException {
 
-    public FileReader(String fileName) throws FileNotFoundException, UnsupportedEncodingException {
-        super(new FileInputStream(fileName), "UTF-8");
+    private static final long serialVersionUID = 1L;
+
+    public MalformedURLException() {
+        super();
     }
 
-    public FileReader(File file) throws FileNotFoundException, UnsupportedEncodingException {
-        super(new FileInputStream(file), "UTF-8");
+    public MalformedURLException(String msg) {
+        super(msg);
     }
 }
diff --git a/Ports/CLDC11/src/java/net/URI.java b/Ports/CLDC11/src/java/net/URI.java
index ce424b8efd2..248417ebb81 100644
--- a/Ports/CLDC11/src/java/net/URI.java
+++ b/Ports/CLDC11/src/java/net/URI.java
@@ -443,6 +443,9 @@ protected void parseSchemeSpecificPart(String ssp, boolean encode) throws URISyn
 		if (ssp == null) {
 			throw new URISyntaxException(ssp, "Invalid scheme specific part");
 		}
+		if (scheme != null && ssp.length() == 0) {
+			throw new URISyntaxException(scheme + SCHEME_SEPARATOR, "Expected scheme-specific part");
+		}
 		if (scheme != null && ssp.charAt(0) != PATH_SEPARATOR) {
 			this.opaque = true;
 			this.schemeSpecificPart = ssp;
@@ -459,8 +462,15 @@ protected void parseSchemeSpecificPart(String ssp, boolean encode) throws URISyn
 			s = s.substring(0, index);
 		}
 
-		index = (s.startsWith(AUTHORITY_MARKER)) ? 2 : 0;
-		index = s.indexOf(PATH_SEPARATOR, index);
+		// Only a "//" opens an authority; without one the remainder is all
+		// path (see vm/JavaAPI's URI, which this mirrors).
+		if (!s.startsWith(AUTHORITY_MARKER)) {
+			if (s.length() > 0) {
+				setPath(s, encode);
+			}
+			return;
+		}
+		index = s.indexOf(PATH_SEPARATOR, AUTHORITY_MARKER.length());
 		if (index != -1) {
 			setPath(s.substring(index), encode);
 			s = s.substring(0, index);
diff --git a/Ports/CLDC11/src/java/net/URL.java b/Ports/CLDC11/src/java/net/URL.java
new file mode 100644
index 00000000000..7aa1ce27997
--- /dev/null
+++ b/Ports/CLDC11/src/java/net/URL.java
@@ -0,0 +1,736 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.net;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+/// A parsed URL, and a way to read what it points at.
+///
+/// Parsing follows the JDK class, including the resolution of a relative
+/// reference against a context URL. The protocols accepted are `http`,
+/// `https`, `file`, `ftp`, `jar`, `mailto` and `cn1res`; any other throws
+/// `MalformedURLException`, as an unknown protocol does on the JDK.
+///
+/// #### Reading
+///
+/// [#openStream()] reads:
+///
+/// - `file:` through `java.io.FileInputStream`.
+/// - `http:` and `https:` through the platform's network, which
+///   `com.codename1.impl.JdkHost` reaches (a Codename One `ConnectionRequest`
+///   in an application), run to completion before the stream is returned:
+///   the stream is over the whole downloaded body, so it suits configuration
+///   files and images, not endless or very large responses.
+/// - `cn1res:` from the application's packaged resources, through the same
+///   host.
+///
+/// #### The `cn1res` scheme
+///
+/// `cn1res:/images/logo.png` names the resource `/images/logo.png` of the
+/// application, the one `Class.getResourceAsStream("/images/logo.png")`
+/// opens. The scheme exists because the device has no `Class.getResource`:
+/// a later step of the build rewrites calls to `Class.getResource(String)` so
+/// that they return a URL of this scheme, and code that goes on to call
+/// `openStream()`, `toString()` or `toExternalForm()` on the result keeps
+/// working. A `cn1res` URL has no host; its path is the absolute resource
+/// name.
+///
+/// #### Differences from the JDK
+///
+/// - No `openConnection`, `getContent` or stream handler factories: the
+///   device has no `URLConnection`.
+/// - `equals` and `hashCode` compare host names as text, ignoring case, and
+///   never resolve them.
+public final class URL implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String protocol;
+    private final String host;
+    private final int port;
+    private final String authority;
+    private final String userInfo;
+    private final String path;
+    private final String query;
+    private final String ref;
+
+    public URL(String spec) throws MalformedURLException {
+        this(null, spec);
+    }
+
+    public URL(String protocol, String host, String file) throws MalformedURLException {
+        this(protocol, host, -1, file);
+    }
+
+    public URL(String protocol, String host, int port, String file) throws MalformedURLException {
+        String scheme = asciiLower(protocol);
+        if (!isKnownProtocol(scheme)) {
+            throw new MalformedURLException("unknown protocol: " + protocol);
+        }
+        this.protocol = scheme;
+        if (host != null) {
+            String h = host;
+            if (h.indexOf(':') >= 0 && !h.startsWith("[")) {
+                h = "[" + h + "]";
+            }
+            if (port < -1) {
+                throw new MalformedURLException("Invalid port number :" + port);
+            }
+            this.host = h;
+            this.port = port;
+            this.authority = port == -1 ? h : h + ":" + port;
+        } else {
+            this.host = null;
+            this.port = -1;
+            this.authority = null;
+        }
+        this.userInfo = null;
+        String rest = file;
+        int hash = rest.indexOf('#');
+        this.ref = hash < 0 ? null : rest.substring(hash + 1);
+        if (hash >= 0) {
+            rest = rest.substring(0, hash);
+        }
+        int question = rest.lastIndexOf('?');
+        if (question >= 0) {
+            this.query = rest.substring(question + 1);
+            this.path = rest.substring(0, question);
+        } else {
+            this.query = null;
+            this.path = rest;
+        }
+    }
+
+    /// Parses `spec`, resolving it against `context` when it is a relative
+    /// reference; `context` may be `null`.
+    public URL(URL context, String spec) throws MalformedURLException {
+        if (spec == null) {
+            throw new MalformedURLException("no protocol: null");
+        }
+        int limit = spec.length();
+        while (limit > 0 && spec.charAt(limit - 1) <= ' ') {
+            limit--;
+        }
+        int start = 0;
+        while (start < limit && spec.charAt(start) <= ' ') {
+            start++;
+        }
+        if (spec.regionMatches(true, start, "url:", 0, 4)) {
+            start += 4;
+        }
+        boolean isRef = start < spec.length() && spec.charAt(start) == '#';
+        String newProtocol = null;
+        for (int i = start; !isRef && i < limit; i++) {
+            char c = spec.charAt(i);
+            if (c == '/') {
+                break;
+            }
+            if (c == ':') {
+                String s = asciiLower(spec.substring(start, i));
+                if (isValidProtocol(s)) {
+                    newProtocol = s;
+                    start = i + 1;
+                }
+                break;
+            }
+        }
+
+        String p = newProtocol;
+        String h = null;
+        int prt = -1;
+        String auth = null;
+        String user = null;
+        String pth = null;
+        String qry = null;
+        String rf = null;
+        boolean isRelative = false;
+        if (context != null && (newProtocol == null || newProtocol.equals(context.protocol))) {
+            // A scheme repeated in front of a relative reference to a
+            // hierarchical URL is ignored.
+            if (context.path != null && context.path.startsWith("/")) {
+                newProtocol = null;
+            }
+            if (newProtocol == null) {
+                p = context.protocol;
+                auth = context.authority;
+                user = context.userInfo;
+                h = context.host;
+                prt = context.port;
+                pth = context.path;
+                isRelative = true;
+            }
+        }
+        if (p == null) {
+            throw new MalformedURLException("no protocol: " + spec);
+        }
+        if (!isKnownProtocol(p)) {
+            throw new MalformedURLException("unknown protocol: " + p);
+        }
+        int hash = spec.indexOf('#', start);
+        if (hash >= 0) {
+            rf = spec.substring(hash + 1, limit);
+            limit = hash;
+        }
+        if (isRelative && start == limit) {
+            // An empty reference is the context itself.
+            qry = context.query;
+            if (rf == null) {
+                rf = context.ref;
+            }
+        }
+
+        if ("jar".equals(p) || "mailto".equals(p)) {
+            // Not hierarchical: everything after the scheme is the file.
+            String file;
+            if ("mailto".equals(p)) {
+                file = spec.substring(start, limit);
+                if (file.trim().length() == 0) {
+                    throw new MalformedURLException("No email address");
+                }
+            } else if (hash == start && isRelative) {
+                file = context.getFile();
+            } else {
+                file = jarFile(isRelative ? context.getFile() : null, spec.substring(start, limit),
+                        newProtocol != null);
+            }
+            if ("mailto".equals(p)) {
+                // As in the JDK, an address has no fragment.
+                rf = null;
+            }
+            int question = file.lastIndexOf('?');
+            this.protocol = p;
+            this.host = "";
+            this.port = -1;
+            this.authority = null;
+            this.userInfo = null;
+            this.path = question < 0 ? file : file.substring(0, question);
+            this.query = question < 0 ? null : file.substring(question + 1);
+            this.ref = rf;
+            return;
+        }
+
+        // From here on: the authority, then the path and the query.
+        String s = spec;
+        boolean isRelPath = false;
+        boolean queryOnly = false;
+        if (start < limit) {
+            int queryStart = s.indexOf('?');
+            queryOnly = queryStart == start;
+            if (queryStart != -1 && queryStart < limit) {
+                qry = s.substring(queryStart + 1, limit);
+                limit = queryStart;
+                s = s.substring(0, queryStart);
+            }
+        }
+        boolean fourSlashes = start <= limit - 4 && s.charAt(start) == '/' && s.charAt(start + 1) == '/'
+                && s.charAt(start + 2) == '/' && s.charAt(start + 3) == '/';
+        if (!fourSlashes && start <= limit - 2 && s.charAt(start) == '/' && s.charAt(start + 1) == '/') {
+            start += 2;
+            int end = s.indexOf('/', start);
+            if (end < 0 || end > limit) {
+                end = s.indexOf('?', start);
+                if (end < 0 || end > limit) {
+                    end = limit;
+                }
+            }
+            auth = s.substring(start, end);
+            h = auth;
+            int at = auth.indexOf('@');
+            if (at != -1) {
+                if (at != auth.lastIndexOf('@')) {
+                    user = null;
+                    h = null;
+                } else {
+                    user = auth.substring(0, at);
+                    h = auth.substring(at + 1);
+                }
+            } else {
+                user = null;
+            }
+            prt = -1;
+            if (h != null) {
+                String portText = null;
+                if (h.length() > 0 && h.charAt(0) == '[') {
+                    int close = h.indexOf(']');
+                    if (close <= 2) {
+                        throw new MalformedURLException("Invalid authority field: " + auth);
+                    }
+                    if (h.length() > close + 1) {
+                        if (h.charAt(close + 1) != ':') {
+                            throw new MalformedURLException("Invalid authority field: " + auth);
+                        }
+                        portText = h.substring(close + 2);
+                    }
+                    h = h.substring(0, close + 1);
+                } else {
+                    int colon = h.indexOf(':');
+                    if (colon >= 0) {
+                        portText = h.substring(colon + 1);
+                        h = h.substring(0, colon);
+                    }
+                }
+                if (portText != null && portText.length() > 0) {
+                    prt = parsePort(portText);
+                }
+            } else {
+                h = "";
+            }
+            start = end;
+            if (auth.length() > 0) {
+                // With an authority, the path comes from the reference alone.
+                pth = "";
+            }
+        }
+        if (h == null) {
+            h = "";
+        }
+        if (start < limit) {
+            if (s.charAt(start) == '/') {
+                pth = s.substring(start, limit);
+            } else if (pth != null && pth.length() > 0) {
+                isRelPath = true;
+                int slash = pth.lastIndexOf('/');
+                String separator = slash == -1 && auth != null ? "/" : "";
+                pth = pth.substring(0, slash + 1) + separator + s.substring(start, limit);
+            } else {
+                String separator = auth != null ? "/" : "";
+                pth = separator + s.substring(start, limit);
+            }
+        } else if (queryOnly && pth != null) {
+            int slash = pth.lastIndexOf('/');
+            if (slash < 0) {
+                slash = 0;
+            }
+            pth = pth.substring(0, slash) + "/";
+        }
+        if (pth == null) {
+            pth = "";
+        }
+        if (isRelPath) {
+            pth = removeDots(pth);
+        }
+        this.protocol = p;
+        this.host = h;
+        this.port = prt;
+        this.authority = auth;
+        this.userInfo = user;
+        this.path = pth;
+        this.query = qry;
+        this.ref = rf;
+    }
+
+    /// The index of the `/` of the last `!/` in a `jar:` file, or -1.
+    private static int indexOfBangSlash(String file) {
+        int bang = file.lastIndexOf('!');
+        while (bang >= 0) {
+            if (bang != file.length() - 1 && file.charAt(bang + 1) == '/') {
+                return bang + 1;
+            }
+            bang = bang == 0 ? -1 : file.lastIndexOf('!', bang - 1);
+        }
+        return -1;
+    }
+
+    /// The file of a `jar:` URL: an archive's own URL, `!/`, and the entry.
+    /// A relative reference is resolved inside the archive, never out of it.
+    private static String jarFile(String contextFile, String part, boolean absolute)
+            throws MalformedURLException {
+        if (absolute) {
+            int bangSlash = indexOfBangSlash(part);
+            if (bangSlash < 0) {
+                throw new MalformedURLException("no !/ in spec");
+            }
+            try {
+                new URL(part.substring(0, bangSlash - 1));
+            } catch (MalformedURLException e) {
+                throw new MalformedURLException("invalid url: " + part + " (" + e.getMessage() + ")");
+            }
+            return part;
+        }
+        if (contextFile == null) {
+            throw new MalformedURLException("no !/ in spec");
+        }
+        String file = contextFile;
+        if (part.startsWith("/")) {
+            int bangSlash = indexOfBangSlash(file);
+            if (bangSlash < 0) {
+                throw new MalformedURLException("malformed context url: no !/");
+            }
+            file = file.substring(0, bangSlash);
+        } else if (!file.endsWith("/")) {
+            int lastSlash = file.lastIndexOf('/');
+            if (lastSlash < 0) {
+                throw new MalformedURLException("malformed context url");
+            }
+            file = file.substring(0, lastSlash + 1);
+        }
+        file = file + part;
+        int bangSlash = indexOfBangSlash(file);
+        if (bangSlash < 0) {
+            throw new MalformedURLException("no !/ in spec");
+        }
+        return file.substring(0, bangSlash) + canonizeEntry(file.substring(bangSlash));
+    }
+
+    /// Resolves `.` and `..` in the entry part of a `jar:` file.
+    private static String canonizeEntry(String entry) {
+        String file = entry;
+        int i = file.indexOf("/../");
+        while (i >= 0) {
+            int lim = i > 0 ? file.lastIndexOf('/', i - 1) : -1;
+            file = lim >= 0 ? file.substring(0, lim) + file.substring(i + 3) : file.substring(i + 3);
+            i = file.indexOf("/../");
+        }
+        i = file.indexOf("/./");
+        while (i >= 0) {
+            file = file.substring(0, i) + file.substring(i + 2);
+            i = file.indexOf("/./");
+        }
+        while (file.endsWith("/..")) {
+            i = file.indexOf("/..");
+            int lim = i > 0 ? file.lastIndexOf('/', i - 1) : -1;
+            file = lim >= 0 ? file.substring(0, lim + 1) : file.substring(0, i);
+        }
+        if (file.endsWith("/.")) {
+            file = file.substring(0, file.length() - 1);
+        }
+        return file;
+    }
+
+    /// A port as the JDK reads one: a decimal `int` with an optional sign,
+    /// of which -1, "no port", is the only negative accepted.
+    private static int parsePort(String text) throws MalformedURLException {
+        int from = 0;
+        boolean negative = false;
+        if (text.charAt(0) == '-' || text.charAt(0) == '+') {
+            negative = text.charAt(0) == '-';
+            from = 1;
+        }
+        long value = 0;
+        if (text.length() == from || text.length() - from > 10) {
+            throw new MalformedURLException("For input string: \"" + text + "\"");
+        }
+        for (int i = from; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                throw new MalformedURLException("For input string: \"" + text + "\"");
+            }
+            value = value * 10 + (c - '0');
+        }
+        if (negative) {
+            value = -value;
+        }
+        if (value > Integer.MAX_VALUE || value < Integer.MIN_VALUE) {
+            throw new MalformedURLException("For input string: \"" + text + "\"");
+        }
+        if (value < -1) {
+            throw new MalformedURLException("Invalid port number :" + value);
+        }
+        return (int) value;
+    }
+
+    /// Resolves the `.` and `..` segments a relative reference brought into
+    /// a path.
+    private static String removeDots(String in) {
+        String path = in;
+        int i = path.indexOf("/./");
+        while (i >= 0) {
+            path = path.substring(0, i) + path.substring(i + 2);
+            i = path.indexOf("/./");
+        }
+        i = path.indexOf("/../");
+        while (i >= 0) {
+            // "/a/b/../c" becomes "/a/c"; "/../../a" has nothing to cancel
+            // and stays.
+            int previous = i > 0 ? path.lastIndexOf('/', i - 1) : -1;
+            if (previous >= 0 && path.indexOf("/../", previous) != 0) {
+                path = path.substring(0, previous) + path.substring(i + 3);
+                i = path.indexOf("/../");
+            } else {
+                i = path.indexOf("/../", i + 3);
+            }
+        }
+        while (path.endsWith("/..")) {
+            i = path.indexOf("/..");
+            int previous = i > 0 ? path.lastIndexOf('/', i - 1) : -1;
+            if (previous < 0) {
+                break;
+            }
+            path = path.substring(0, previous + 1);
+        }
+        if (path.startsWith("./") && path.length() > 2) {
+            path = path.substring(2);
+        }
+        if (path.endsWith("/.")) {
+            path = path.substring(0, path.length() - 1);
+        }
+        return path;
+    }
+
+    /// Lower case for the ASCII letters only. A scheme is ASCII by
+    /// specification, and `String.toLowerCase()` follows the device's locale.
+    private static String asciiLower(String s) {
+        StringBuilder sb = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                if (sb == null) {
+                    sb = new StringBuilder(s);
+                }
+                sb.setCharAt(i, (char) (c + ('a' - 'A')));
+            }
+        }
+        return sb == null ? s : sb.toString();
+    }
+
+    private static boolean isAsciiLetter(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+    }
+
+    private static boolean isValidProtocol(String protocol) {
+        int len = protocol.length();
+        if (len < 1 || !isAsciiLetter(protocol.charAt(0))) {
+            return false;
+        }
+        for (int i = 1; i < len; i++) {
+            char c = protocol.charAt(i);
+            boolean digit = c >= '0' && c <= '9';
+            if (!isAsciiLetter(c) && !digit && c != '.' && c != '+' && c != '-') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean isKnownProtocol(String protocol) {
+        return "http".equals(protocol) || "https".equals(protocol) || "file".equals(protocol)
+                || "cn1res".equals(protocol) || "ftp".equals(protocol) || "jar".equals(protocol)
+                || "mailto".equals(protocol);
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public int getDefaultPort() {
+        if ("http".equals(protocol)) {
+            return 80;
+        }
+        if ("https".equals(protocol)) {
+            return 443;
+        }
+        if ("ftp".equals(protocol)) {
+            return 21;
+        }
+        return -1;
+    }
+
+    public String getAuthority() {
+        return authority;
+    }
+
+    public String getUserInfo() {
+        return userInfo;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public String getQuery() {
+        return query;
+    }
+
+    public String getRef() {
+        return ref;
+    }
+
+    public String getFile() {
+        return query == null ? path : path + "?" + query;
+    }
+
+    public String toExternalForm() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(protocol).append(':');
+        if (authority != null && authority.length() > 0) {
+            sb.append("//").append(authority);
+        }
+        if (path != null) {
+            sb.append(path);
+        }
+        if (query != null) {
+            sb.append('?').append(query);
+        }
+        if (ref != null) {
+            sb.append('#').append(ref);
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public String toString() {
+        return toExternalForm();
+    }
+
+    public URI toURI() throws URISyntaxException {
+        return new URI(toString());
+    }
+
+    private static boolean same(String a, String b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    private int effectivePort() {
+        return port != -1 ? port : getDefaultPort();
+    }
+
+    /// Whether the two URLs name the same resource, the fragment aside.
+    public boolean sameFile(URL other) {
+        if (other == null) {
+            return false;
+        }
+        boolean hostsEqual = host == null || other.host == null
+                ? host == null && other.host == null
+                : host.equalsIgnoreCase(other.host);
+        return protocol.equals(other.protocol) && same(getFile(), other.getFile())
+                && effectivePort() == other.effectivePort() && hostsEqual;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof URL)) {
+            return false;
+        }
+        URL other = (URL) obj;
+        return same(ref, other.ref) && sameFile(other);
+    }
+
+    @Override
+    public int hashCode() {
+        int h = protocol.hashCode();
+        if (host != null) {
+            h += asciiLower(host).hashCode();
+        }
+        String file = getFile();
+        if (file != null) {
+            h += file.hashCode();
+        }
+        h += effectivePort();
+        if (ref != null) {
+            h += ref.hashCode();
+        }
+        return h;
+    }
+
+    private static int hex(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    /// Replaces each `%XX` by the byte it stands for and reads the result
+    /// as UTF-8. A `%` not followed by two hex digits is kept.
+    private static String percentDecode(String s) throws IOException {
+        if (s.indexOf('%') < 0) {
+            return s;
+        }
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        int i = 0;
+        while (i < s.length()) {
+            if (s.charAt(i) == '%' && i + 2 < s.length() && hex(s.charAt(i + 1)) >= 0
+                    && hex(s.charAt(i + 2)) >= 0) {
+                bytes.write((hex(s.charAt(i + 1)) << 4) | hex(s.charAt(i + 2)));
+                i += 3;
+            } else {
+                // Up to the next escape in one piece, so that a surrogate
+                // pair is encoded as the one character it is.
+                int next = s.indexOf('%', i + 1);
+                if (next < 0) {
+                    next = s.length();
+                }
+                bytes.write(s.substring(i, next).getBytes("UTF-8"));
+                i = next;
+            }
+        }
+        return new String(bytes.toByteArray(), "UTF-8");
+    }
+
+    /// Opens the resource for reading; see the class description for what
+    /// each protocol reads.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: if the file or resource does not exist, or
+    ///   the server answers 404 or 410
+    ///
+    /// - `IOException`: if the request fails, the server answers another
+    ///   error status, or the protocol cannot be read on the device
+    public InputStream openStream() throws IOException {
+        if ("file".equals(protocol)) {
+            throw new RuntimeException("Compile-time stub");
+        }
+        if ("cn1res".equals(protocol)) {
+            // Through the host, which knows the flat name the build shipped
+            // the resource under; the path here is the one it had on a desktop.
+            String name = percentDecode(path);
+            InputStream in = JdkHost.get().resource(name.startsWith("/") ? name.substring(1) : name);
+            if (in == null) {
+                throw new FileNotFoundException(toExternalForm());
+            }
+            return in;
+        }
+        if ("http".equals(protocol) || "https".equals(protocol)) {
+            return openHttp();
+        }
+        throw new IOException("Cannot read the " + protocol + " protocol: " + toExternalForm());
+    }
+
+    private InputStream openHttp() throws IOException {
+        StringBuilder address = new StringBuilder();
+        address.append(protocol).append("://").append(authority == null ? "" : authority).append(path);
+        if (query != null) {
+            address.append('?').append(query);
+        }
+        return JdkHost.get().openUrl(address.toString());
+    }
+}
diff --git a/Ports/CLDC11/src/java/net/URLDecoder.java b/Ports/CLDC11/src/java/net/URLDecoder.java
new file mode 100644
index 00000000000..d65cea4ddc9
--- /dev/null
+++ b/Ports/CLDC11/src/java/net/URLDecoder.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.net;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+/// A string out of its
+/// `application/x-www-form-urlencoded` form. A plus is a space and a run of
+/// `%XX` is the bytes of some characters.
+public final class URLDecoder {
+
+    private URLDecoder() {
+    }
+
+    /// Decodes as UTF-8, where the JDK uses the platform's default.
+    public static String decode(String s) {
+        return decodeAs(s, "UTF-8");
+    }
+
+    public static String decode(String s, String enc) throws UnsupportedEncodingException {
+        if (enc == null) {
+            throw new NullPointerException("charsetName");
+        }
+        if (enc.length() == 0) {
+            throw new UnsupportedEncodingException("URLDecoder: empty string enc parameter");
+        }
+        return decodeAs(s, URLEncoder.charsetName(enc));
+    }
+
+    public static String decode(String s, Charset charset) {
+        return decodeAs(s, charset.name());
+    }
+
+    private static int hex(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    private static String decodeAs(String s, String charset) {
+        int n = s.length();
+        StringBuilder out = new StringBuilder(n);
+        byte[] bytes = null;
+        int i = 0;
+        while (i < n) {
+            char c = s.charAt(i);
+            if (c == '+') {
+                out.append(' ');
+                i++;
+            } else if (c == '%') {
+                if (bytes == null) {
+                    bytes = new byte[(n - i) / 3];
+                }
+                int count = 0;
+                while (i + 2 < n && c == '%') {
+                    int high = hex(s.charAt(i + 1));
+                    int low = hex(s.charAt(i + 2));
+                    if (high < 0 || low < 0) {
+                        throw new IllegalArgumentException(
+                                "URLDecoder: Illegal hex characters in escape (%) pattern - Error at index "
+                                + (high < 0 ? 0 : 1) + " in: \"" + s.substring(i + 1, i + 3) + "\"");
+                    }
+                    bytes[count++] = (byte) (high * 16 + low);
+                    i += 3;
+                    if (i < n) {
+                        c = s.charAt(i);
+                    }
+                }
+                if (i < n && c == '%') {
+                    throw new IllegalArgumentException("URLDecoder: Incomplete trailing escape (%) pattern");
+                }
+                try {
+                    out.append(new String(bytes, 0, count, charset));
+                } catch (UnsupportedEncodingException e) {
+                    throw new IllegalArgumentException(charset);
+                }
+            } else {
+                out.append(c);
+                i++;
+            }
+        }
+        return out.toString();
+    }
+}
diff --git a/Ports/CLDC11/src/java/net/URLEncoder.java b/Ports/CLDC11/src/java/net/URLEncoder.java
new file mode 100644
index 00000000000..3d65ea379b5
--- /dev/null
+++ b/Ports/CLDC11/src/java/net/URLEncoder.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.net;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+/// The `application/x-www-form-urlencoded` form of a
+/// string. Letters, digits and `.-*_` stay, a space is a plus, and every
+/// other character is the bytes of its encoding as `%XX`.
+public final class URLEncoder {
+    private static final String HEX = "0123456789ABCDEF";
+
+    private URLEncoder() {
+    }
+
+    static String charsetName(String enc) throws UnsupportedEncodingException {
+        if (enc == null) {
+            throw new NullPointerException("charsetName");
+        }
+        try {
+            return Charset.forName(enc).name();
+        } catch (IllegalArgumentException e) {
+            throw new UnsupportedEncodingException(enc);
+        }
+    }
+
+    private static boolean plain(char c) {
+        return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9'
+                || c == '.' || c == '-' || c == '*' || c == '_';
+    }
+
+    /// Encodes in UTF-8, where the JDK uses the platform's default.
+    public static String encode(String s) {
+        return encodeAs(s, "UTF-8");
+    }
+
+    public static String encode(String s, String enc) throws UnsupportedEncodingException {
+        return encodeAs(s, charsetName(enc));
+    }
+
+    public static String encode(String s, Charset charset) {
+        return encodeAs(s, charset.name());
+    }
+
+    private static String encodeAs(String s, String charset) {
+        int n = s.length();
+        StringBuilder out = new StringBuilder(n + 16);
+        int i = 0;
+        while (i < n) {
+            char c = s.charAt(i);
+            if (plain(c)) {
+                out.append(c);
+                i++;
+            } else if (c == ' ') {
+                out.append('+');
+                i++;
+            } else {
+                // The run of characters to escape is encoded as one piece,
+                // so the two halves of a surrogate pair stay together.
+                int start = i;
+                while (i < n && !plain(s.charAt(i)) && s.charAt(i) != ' ') {
+                    i++;
+                }
+                byte[] bytes;
+                try {
+                    bytes = s.substring(start, i).getBytes(charset);
+                } catch (UnsupportedEncodingException e) {
+                    throw new IllegalArgumentException(charset);
+                }
+                for (int b = 0; b < bytes.length; b++) {
+                    out.append('%').append(HEX.charAt((bytes[b] >> 4) & 0xF)).append(HEX.charAt(bytes[b] & 0xF));
+                }
+            }
+        }
+        return out.toString();
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/charset/Charset.java b/Ports/CLDC11/src/java/nio/charset/Charset.java
index c851a1c5eff..a10e1024f78 100644
--- a/Ports/CLDC11/src/java/nio/charset/Charset.java
+++ b/Ports/CLDC11/src/java/nio/charset/Charset.java
@@ -22,28 +22,192 @@
  */
 package java.nio.charset;
 
-/// Added this for Kotlin
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+/// A named character encoding. This runtime has the three charsets every
+/// Java platform must: UTF-8, US-ASCII and ISO-8859-1, under their canonical
+/// names and the JDK's aliases. Encoding and decoding go through the
+/// String constructors and `getBytes` that take a Charset, and the readers
+/// and writers of `java.io`.
 public class Charset implements Comparable<Charset> {
 
-    private String name;
+    private static final String[] UTF8_ALIASES = {"unicode-1-1-utf-8", "UTF8"};
+    private static final String[] USASCII_ALIASES = {
+        "iso-ir-6", "ANSI_X3.4-1986", "ISO_646.irv:1991", "ASCII", "iso_646.irv:1983", "ANSI_X3.4-1968",
+        "646", "default", "cp367", "csASCII", "us", "ISO646-US", "IBM367", "ascii7"
+    };
+    private static final String[] ISO88591_ALIASES = {
+        "819", "ISO8859-1", "l1", "ISO_8859-1:1987", "ISO_8859-1", "8859_1", "iso-ir-100", "latin1",
+        "cp819", "ISO8859_1", "IBM819", "ISO_8859_1", "IBM-819", "csISOLatin1"
+    };
+    private static final Charset UTF8 = new SimpleCharset("UTF-8", UTF8_ALIASES);
+    private static final Charset USASCII = new SimpleCharset("US-ASCII", USASCII_ALIASES);
+    private static final Charset ISO88591 = new SimpleCharset("ISO-8859-1", ISO88591_ALIASES);
+
+    private final String name;
+    private final String[] aliases;
+
     protected Charset(String canonicalName, String[] aliases) {
+        checkName(canonicalName);
         name = canonicalName;
+        this.aliases = aliases == null ? new String[0] : aliases;
     }
-    
-    public int compareTo(Charset another) {
-        return name.compareTo(another.name);
+
+    /// Compares canonical names, ignoring case.
+    public final int compareTo(Charset another) {
+        return name.compareToIgnoreCase(another.name);
     }
-    
+
+    /// The canonical name.
     public final String name() {
         return name;
     }
 
+    /// The canonical name.
     public String displayName() {
         return name;
     }
-    
-    public static Charset forName(String name) {
-        throw new UnsupportedOperationException("Charset.forName not implemented on this platform");
+
+    /// The canonical name, whatever the locale.
+    public String displayName(Locale locale) {
+        return name;
+    }
+
+    /// The aliases of the charset.
+    public final Set<String> aliases() {
+        HashSet<String> out = new HashSet<String>();
+        for (int i = 0; i < aliases.length; i++) {
+            out.add(aliases[i]);
+        }
+        return Collections.unmodifiableSet(out);
+    }
+
+    /// Whether the charset is registered with IANA; the three this runtime
+    /// has are.
+    public final boolean isRegistered() {
+        return true;
+    }
+
+    /// Whether the charset can encode; the three this runtime has can.
+    public boolean canEncode() {
+        return true;
+    }
+
+    /// Whether `obj` is a charset of the same canonical name.
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Charset)) {
+            return false;
+        }
+        return name.equals(((Charset) obj).name);
+    }
+
+    /// The hash of the canonical name.
+    public final int hashCode() {
+        return name.hashCode();
+    }
+
+    /// The canonical name.
+    public final String toString() {
+        return name;
+    }
+
+    /// UTF-8, the default charset of this runtime on every platform.
+    public static Charset defaultCharset() {
+        return UTF8;
+    }
+
+    /// Whether `charsetName` names a charset this runtime has.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalCharsetNameException`: if the name is not a legal charset name
+    /// - `IllegalArgumentException`: if it is null
+    public static boolean isSupported(String charsetName) {
+        return lookup(charsetName) != null;
+    }
+
+    /// The charset `charsetName` names, by canonical name or alias, in any
+    /// case.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalCharsetNameException`: if the name is not a legal charset name
+    /// - `UnsupportedCharsetException`: if this runtime has no such charset
+    /// - `IllegalArgumentException`: if it is null
+    public static Charset forName(String charsetName) {
+        Charset cs = lookup(charsetName);
+        if (cs == null) {
+            throw new UnsupportedCharsetException(charsetName);
+        }
+        return cs;
+    }
+
+    /// The charset `charsetName` names, or `fallback` when the name is
+    /// illegal or names a charset this runtime does not have.
+    public static Charset forName(String charsetName, Charset fallback) {
+        try {
+            Charset cs = lookup(charsetName);
+            return cs == null ? fallback : cs;
+        } catch (IllegalCharsetNameException e) {
+            return fallback;
+        }
+    }
+
+    private static Charset lookup(String charsetName) {
+        if (charsetName == null) {
+            throw new IllegalArgumentException("Null charset name");
+        }
+        checkName(charsetName);
+        if (matches(UTF8, charsetName)) {
+            return UTF8;
+        }
+        if (matches(ISO88591, charsetName)) {
+            return ISO88591;
+        }
+        if (matches(USASCII, charsetName)) {
+            return USASCII;
+        }
+        return null;
+    }
+
+    // Charset names are ASCII; equalsIgnoreCase folds them without the
+    // device's locale.
+    private static boolean matches(Charset cs, String charsetName) {
+        if (cs.name.equalsIgnoreCase(charsetName)) {
+            return true;
+        }
+        for (int i = 0; i < cs.aliases.length; i++) {
+            if (cs.aliases[i].equalsIgnoreCase(charsetName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void checkName(String s) {
+        int n = s.length();
+        if (n == 0) {
+            throw new IllegalCharsetNameException(s);
+        }
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            boolean ok = c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9'
+                    || i > 0 && (c == '-' || c == '+' || c == ':' || c == '_' || c == '.');
+            if (!ok) {
+                throw new IllegalCharsetNameException(s);
+            }
+        }
+    }
+
+    private static final class SimpleCharset extends Charset {
+        private SimpleCharset(String canonicalName, String[] aliases) {
+            super(canonicalName, aliases);
+        }
     }
-    
 }
diff --git a/Ports/CLDC11/src/java/nio/charset/IllegalCharsetNameException.java b/Ports/CLDC11/src/java/nio/charset/IllegalCharsetNameException.java
new file mode 100644
index 00000000000..34c7a73e179
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/charset/IllegalCharsetNameException.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package java.nio.charset;
+
+/// Thrown for a string that is not a legal charset name.
+public class IllegalCharsetNameException extends IllegalArgumentException {
+
+    private final String charsetName;
+
+    /// An exception naming `charsetName`.
+    public IllegalCharsetNameException(String charsetName) {
+        super(String.valueOf(charsetName));
+        this.charsetName = charsetName;
+    }
+
+    /// The charset name this exception is about.
+    public String getCharsetName() {
+        return charsetName;
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/charset/StandardCharsets.java b/Ports/CLDC11/src/java/nio/charset/StandardCharsets.java
index 8b094883b05..0d98f66ddc1 100644
--- a/Ports/CLDC11/src/java/nio/charset/StandardCharsets.java
+++ b/Ports/CLDC11/src/java/nio/charset/StandardCharsets.java
@@ -6,6 +6,19 @@
  * published by the Free Software Foundation.  Codename One designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
  */
 package java.nio.charset;
 
@@ -14,7 +27,7 @@ public final class StandardCharsets {
     private StandardCharsets() {
     }
 
-    public static final Charset UTF_8 = new Charset("UTF-8", new String[0]);
-    public static final Charset US_ASCII = new Charset("US-ASCII", new String[0]);
-    public static final Charset ISO_8859_1 = new Charset("ISO-8859-1", new String[0]);
+    public static final Charset UTF_8 = Charset.forName("UTF-8");
+    public static final Charset US_ASCII = Charset.forName("US-ASCII");
+    public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
 }
diff --git a/Ports/CLDC11/src/java/nio/charset/UnsupportedCharsetException.java b/Ports/CLDC11/src/java/nio/charset/UnsupportedCharsetException.java
new file mode 100644
index 00000000000..2b0016396df
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/charset/UnsupportedCharsetException.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package java.nio.charset;
+
+/// Thrown for a legal charset name this runtime has no charset for.
+public class UnsupportedCharsetException extends IllegalArgumentException {
+
+    private final String charsetName;
+
+    /// An exception naming `charsetName`.
+    public UnsupportedCharsetException(String charsetName) {
+        super(String.valueOf(charsetName));
+        this.charsetName = charsetName;
+    }
+
+    /// The charset name this exception is about.
+    public String getCharsetName() {
+        return charsetName;
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/AccessDeniedException.java b/Ports/CLDC11/src/java/nio/file/AccessDeniedException.java
new file mode 100644
index 00000000000..4982149cd2c
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/AccessDeniedException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The file system refused the operation.
+public class AccessDeniedException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public AccessDeniedException(String file) {
+        super(file);
+    }
+
+    public AccessDeniedException(String file, String other, String reason) {
+        super(file, other, reason);
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/CopyOption.java b/Ports/CLDC11/src/java/nio/file/CopyOption.java
new file mode 100644
index 00000000000..22912454d71
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/CopyOption.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is
+/// copied or moved. [StandardCopyOption] has the values.
+public interface CopyOption {
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileWriter.java b/Ports/CLDC11/src/java/nio/file/DirectoryIteratorException.java
similarity index 62%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileWriter.java
rename to Ports/CLDC11/src/java/nio/file/DirectoryIteratorException.java
index 351a499d050..e78d5f72b8c 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FileWriter.java
+++ b/Ports/CLDC11/src/java/nio/file/DirectoryIteratorException.java
@@ -20,28 +20,30 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package java.nio.file;
 
 import java.io.IOException;
-import java.io.OutputStreamWriter;
 
-/// `java.io.FileWriter` for the Codename One runtime. Writes UTF-8, Android's
-/// default charset.
-public class FileWriter extends OutputStreamWriter {
+/// An `IOException` met while iterating a directory, which an iterator
+/// cannot throw as it is.
+public final class DirectoryIteratorException extends RuntimeException {
+    private static final long serialVersionUID = 1L;
+    private final IOException cause;
 
-    public FileWriter(String fileName) throws IOException {
-        super(new FileOutputStream(fileName), "UTF-8");
+    public DirectoryIteratorException(IOException cause) {
+        super(text(cause));
+        this.cause = cause;
     }
 
-    public FileWriter(String fileName, boolean append) throws IOException {
-        super(new FileOutputStream(fileName, append), "UTF-8");
+    private static String text(IOException cause) {
+        if (cause == null) {
+            throw new NullPointerException();
+        }
+        return cause.toString();
     }
 
-    public FileWriter(File file) throws IOException {
-        super(new FileOutputStream(file), "UTF-8");
-    }
-
-    public FileWriter(File file, boolean append) throws IOException {
-        super(new FileOutputStream(file, append), "UTF-8");
+    @Override
+    public IOException getCause() {
+        return cause;
     }
 }
diff --git a/Ports/CLDC11/src/java/nio/file/DirectoryNotEmptyException.java b/Ports/CLDC11/src/java/nio/file/DirectoryNotEmptyException.java
new file mode 100644
index 00000000000..de3cc35e360
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/DirectoryNotEmptyException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// A directory that has entries cannot be deleted or replaced.
+public class DirectoryNotEmptyException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public DirectoryNotEmptyException(String file) {
+        super(file);
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/DirectoryStream.java b/Ports/CLDC11/src/java/nio/file/DirectoryStream.java
new file mode 100644
index 00000000000..51353de80d3
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/DirectoryStream.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+
+/// The entries
+/// of a directory, read when the stream was opened. It can be iterated once.
+public interface DirectoryStream<T> extends AutoCloseable, Iterable<T> {
+
+    /// Decides which entries a directory stream answers.
+    interface Filter<T> {
+        boolean accept(T entry) throws IOException;
+    }
+
+    @Override
+    void close() throws IOException;
+}
diff --git a/Ports/CLDC11/src/java/nio/file/FileAlreadyExistsException.java b/Ports/CLDC11/src/java/nio/file/FileAlreadyExistsException.java
new file mode 100644
index 00000000000..9c21b957266
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/FileAlreadyExistsException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// Something is already at the path.
+public class FileAlreadyExistsException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public FileAlreadyExistsException(String file) {
+        super(file);
+    }
+
+    public FileAlreadyExistsException(String file, String other, String reason) {
+        super(file, other, reason);
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/FileSystemException.java b/Ports/CLDC11/src/java/nio/file/FileSystemException.java
new file mode 100644
index 00000000000..d44771bb04a
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/FileSystemException.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+
+/// An operation on a file failed; names the file, the other file of a copy
+/// or move, and the reason.
+public class FileSystemException extends IOException {
+    private static final long serialVersionUID = 1L;
+    private final String file;
+    private final String other;
+    private final String reason;
+
+    public FileSystemException(String file) {
+        this(file, null, null);
+    }
+
+    public FileSystemException(String file, String other, String reason) {
+        super((String) null);
+        this.file = file;
+        this.other = other;
+        this.reason = reason;
+    }
+
+    public String getFile() {
+        return file;
+    }
+
+    public String getOtherFile() {
+        return other;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    @Override
+    public String getMessage() {
+        if (file == null && other == null) {
+            return reason;
+        }
+        StringBuilder sb = new StringBuilder();
+        if (file != null) {
+            sb.append(file);
+        }
+        if (other != null) {
+            sb.append(" -> ").append(other);
+        }
+        if (reason != null) {
+            sb.append(": ").append(reason);
+        }
+        return sb.toString();
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/FileVisitOption.java b/Ports/CLDC11/src/java/nio/file/FileVisitOption.java
new file mode 100644
index 00000000000..ebf4637b044
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/FileVisitOption.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// Accepted
+/// and without effect: symbolic links are never followed.
+public enum FileVisitOption {
+    FOLLOW_LINKS
+}
diff --git a/Ports/CLDC11/src/java/nio/file/FileVisitResult.java b/Ports/CLDC11/src/java/nio/file/FileVisitResult.java
new file mode 100644
index 00000000000..8b575a51b35
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/FileVisitResult.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// What a
+/// [FileVisitor] tells `Files.walkFileTree` to do next.
+public enum FileVisitResult {
+    CONTINUE,
+    TERMINATE,
+    SKIP_SUBTREE,
+    SKIP_SIBLINGS
+}
diff --git a/Ports/CLDC11/src/java/nio/file/FileVisitor.java b/Ports/CLDC11/src/java/nio/file/FileVisitor.java
new file mode 100644
index 00000000000..5ca1e9d5944
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/FileVisitor.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+import java.nio.file.attribute.BasicFileAttributes;
+
+/// What
+/// `Files.walkFileTree` calls for each directory and file it reaches.
+public interface FileVisitor<T> {
+
+    FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs) throws IOException;
+
+    FileVisitResult visitFile(T file, BasicFileAttributes attrs) throws IOException;
+
+    FileVisitResult visitFileFailed(T file, IOException exc) throws IOException;
+
+    FileVisitResult postVisitDirectory(T dir, IOException exc) throws IOException;
+}
diff --git a/Ports/CLDC11/src/java/nio/file/Files.java b/Ports/CLDC11/src/java/nio/file/Files.java
new file mode 100644
index 00000000000..f57e710cabe
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/Files.java
@@ -0,0 +1,1087 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.UncheckedIOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileAttribute;
+import java.nio.file.attribute.FileTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiPredicate;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/// Operations on files, directories and their contents, over `java.io.File`
+/// and the file streams, so over the platform's file system as
+/// `com.codename1.impl.JdkHost` provides it.
+///
+/// #### What differs from a desktop file system
+///
+/// - A directory's entries come back sorted by name. The JDK promises no
+///   order, and a device's file systems disagree with each other.
+/// - `newDirectoryStream` reads the entries when it is called, not as the
+///   result is consumed.
+/// - Nothing is a symbolic link, and a `LinkOption` changes nothing.
+/// - The device keeps one time per file. `getLastModifiedTime` answers it,
+///   and so do the creation and access times of [BasicFileAttributes].
+/// - A file is executable when it is a directory, which is all "executable"
+///   can mean where no program can be started.
+/// - A temporary file goes to the caches directory where the device has
+///   one, and to the application's home otherwise. Nothing deletes it.
+/// - Text is UTF-8 unless a `Charset` says otherwise; undecodable bytes are
+///   replaced rather than reported.
+///
+/// #### What is not provided
+///
+/// Channels (`newByteChannel`), POSIX permissions, owners, file stores, hard
+/// and symbolic links, `probeContentType`, `setLastModifiedTime` and the
+/// attribute views by name. A device has no equivalent, and a call to any of
+/// them is a build error.
+///
+/// `lines`, `list`, `walk` and `find` are lazy, as in the JDK: `lines` reads
+/// the file as the stream asks for lines, and `walk` lists a directory only
+/// when it is about to enter it, so `walk(root).limit(1)` lists nothing. A
+/// failure found that late surfaces as an `UncheckedIOException`. Close the
+/// stream `lines` answers (try-with-resources) to close the file.
+public final class Files {
+
+    private static final String LINE = "\n";
+
+    private Files() {
+    }
+
+    private static File file(Path path) {
+        if (path == null) {
+            throw new NullPointerException();
+        }
+        return path.toFile();
+    }
+
+    private static boolean has(Object[] options, Object option) {
+        if (options != null) {
+            for (Object o : options) {
+                if (o == null) {
+                    throw new NullPointerException();
+                }
+                if (o == option) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // ---- what is there ----
+
+    public static boolean exists(Path path, LinkOption... options) {
+        return file(path).exists();
+    }
+
+    public static boolean notExists(Path path, LinkOption... options) {
+        return !file(path).exists();
+    }
+
+    public static boolean isDirectory(Path path, LinkOption... options) {
+        return file(path).isDirectory();
+    }
+
+    public static boolean isRegularFile(Path path, LinkOption... options) {
+        return file(path).isFile();
+    }
+
+    public static boolean isSymbolicLink(Path path) {
+        file(path);
+        return false;
+    }
+
+    public static boolean isReadable(Path path) {
+        return file(path).exists();
+    }
+
+    public static boolean isWritable(Path path) {
+        return file(path).exists();
+    }
+
+    public static boolean isExecutable(Path path) {
+        return file(path).isDirectory();
+    }
+
+    public static boolean isHidden(Path path) throws IOException {
+        return file(path).isHidden();
+    }
+
+    public static boolean isSameFile(Path path, Path path2) throws IOException {
+        if (path.equals(path2)) {
+            return true;
+        }
+        return path.toRealPath().equals(path2.toRealPath());
+    }
+
+    private static File existing(Path path) throws IOException {
+        File f = file(path);
+        if (!f.exists()) {
+            throw new NoSuchFileException(path.toString());
+        }
+        return f;
+    }
+
+    public static long size(Path path) throws IOException {
+        return existing(path).length();
+    }
+
+    public static FileTime getLastModifiedTime(Path path, LinkOption... options) throws IOException {
+        return FileTime.fromMillis(existing(path).lastModified());
+    }
+
+    /// The attributes of `path`. `type` has to be `BasicFileAttributes.class`,
+    /// the one set a device has.
+    @SuppressWarnings("unchecked")
+    public static <A extends BasicFileAttributes> A readAttributes(Path path, Class<A> type, LinkOption... options)
+            throws IOException {
+        if (type != BasicFileAttributes.class) {
+            throw new UnsupportedOperationException("Only BasicFileAttributes can be read on a device");
+        }
+        return (A) attributes(existing(path));
+    }
+
+    private static BasicFileAttributes attributes(File f) {
+        final boolean directory = f.isDirectory();
+        final long size = f.length();
+        final FileTime time = FileTime.fromMillis(f.lastModified());
+        return new BasicFileAttributes() {
+            @Override
+            public FileTime lastModifiedTime() {
+                return time;
+            }
+
+            @Override
+            public FileTime lastAccessTime() {
+                return time;
+            }
+
+            @Override
+            public FileTime creationTime() {
+                return time;
+            }
+
+            @Override
+            public boolean isRegularFile() {
+                return !directory;
+            }
+
+            @Override
+            public boolean isDirectory() {
+                return directory;
+            }
+
+            @Override
+            public boolean isSymbolicLink() {
+                return false;
+            }
+
+            @Override
+            public boolean isOther() {
+                return false;
+            }
+
+            @Override
+            public long size() {
+                return size;
+            }
+
+            @Override
+            public Object fileKey() {
+                return null;
+            }
+        };
+    }
+
+    // ---- streams ----
+
+    public static InputStream newInputStream(Path path, OpenOption... options) throws IOException {
+        if (has(options, StandardOpenOption.WRITE) || has(options, StandardOpenOption.APPEND)) {
+            throw new UnsupportedOperationException("An input stream cannot be opened for writing");
+        }
+        File f = existing(path);
+        if (f.isDirectory()) {
+            throw new IOException(path + ": Is a directory");
+        }
+        return new FileInputStream(f);
+    }
+
+    public static OutputStream newOutputStream(Path path, OpenOption... options) throws IOException {
+        if (has(options, StandardOpenOption.READ)) {
+            throw new IllegalArgumentException("READ not allowed");
+        }
+        boolean none = options == null || options.length == 0;
+        boolean append = has(options, StandardOpenOption.APPEND);
+        if (append && has(options, StandardOpenOption.TRUNCATE_EXISTING)) {
+            throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
+        }
+        File f = file(path);
+        boolean exists = f.exists();
+        if (has(options, StandardOpenOption.CREATE_NEW)) {
+            if (exists) {
+                throw new FileAlreadyExistsException(path.toString());
+            }
+        } else if (!exists && !none && !has(options, StandardOpenOption.CREATE)) {
+            throw new NoSuchFileException(path.toString());
+        }
+        if (f.isDirectory()) {
+            throw new FileSystemException(path.toString(), null, "Is a directory");
+        }
+        File parent = f.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(path.toString());
+        }
+        // Without APPEND or TRUNCATE_EXISTING the JDK overwrites from the
+        // start and leaves a longer file's tail in place. A device stream
+        // replaces the file, so the tail is put back when there is one.
+        byte[] tail = null;
+        if (exists && !none && !append && !has(options, StandardOpenOption.TRUNCATE_EXISTING)) {
+            tail = readAllBytes(path);
+        }
+        // CREATE_NEW claims the path with the exclusive create before opening
+        // it: the check above alone lets two callers both pass and the later
+        // open erase what the first one wrote.
+        if (has(options, StandardOpenOption.CREATE_NEW) && !f.createNewFile()) {
+            throw new FileAlreadyExistsException(path.toString());
+        }
+        OutputStream out = new FileOutputStream(f, append);
+        return tail == null || tail.length == 0 ? out : new Overwrite(out, tail);
+    }
+
+    /// A stream that writes over the start of what a file held and keeps the
+    /// rest: what opening a file with `WRITE` alone means.
+    private static final class Overwrite extends OutputStream {
+        private final OutputStream out;
+        private final byte[] old;
+        private long written;
+        private boolean closed;
+
+        Overwrite(OutputStream out, byte[] old) {
+            this.out = out;
+            this.old = old;
+        }
+
+        @Override
+        public void write(int b) throws IOException {
+            out.write(b);
+            written++;
+        }
+
+        @Override
+        public void write(byte[] b, int off, int len) throws IOException {
+            out.write(b, off, len);
+            written += len;
+        }
+
+        @Override
+        public void flush() throws IOException {
+            out.flush();
+        }
+
+        @Override
+        public void close() throws IOException {
+            if (!closed) {
+                closed = true;
+                if (written < old.length) {
+                    out.write(old, (int) written, old.length - (int) written);
+                }
+                out.close();
+            }
+        }
+    }
+
+    public static BufferedReader newBufferedReader(Path path, Charset cs) throws IOException {
+        return new BufferedReader(new InputStreamReader(newInputStream(path), cs.name()));
+    }
+
+    public static BufferedReader newBufferedReader(Path path) throws IOException {
+        return newBufferedReader(path, StandardCharsets.UTF_8);
+    }
+
+    public static BufferedWriter newBufferedWriter(Path path, Charset cs, OpenOption... options) throws IOException {
+        return new BufferedWriter(new OutputStreamWriter(newOutputStream(path, options), cs.name()));
+    }
+
+    public static BufferedWriter newBufferedWriter(Path path, OpenOption... options) throws IOException {
+        return newBufferedWriter(path, StandardCharsets.UTF_8, options);
+    }
+
+    // ---- reading ----
+
+    public static byte[] readAllBytes(Path path) throws IOException {
+        InputStream in = newInputStream(path);
+        try {
+            // Read here rather than by InputStream.readAllBytes, which a Java 8
+            // class library lacks: the differential tests run this class over
+            // the JDK's own streams.
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            byte[] buf = new byte[8192];
+            int n;
+            while ((n = in.read(buf, 0, buf.length)) > 0) {
+                out.write(buf, 0, n);
+            }
+            return out.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    public static String readString(Path path) throws IOException {
+        return readString(path, StandardCharsets.UTF_8);
+    }
+
+    public static String readString(Path path, Charset cs) throws IOException {
+        return new String(readAllBytes(path), cs.name());
+    }
+
+    public static List<String> readAllLines(Path path) throws IOException {
+        return readAllLines(path, StandardCharsets.UTF_8);
+    }
+
+    /// The lines of the file. A line ends at `\n`, `\r` or `\r\n`, and a
+    /// file that ends with a terminator has no empty last line.
+    public static List<String> readAllLines(Path path, Charset cs) throws IOException {
+        String text = readString(path, cs);
+        List<String> lines = new ArrayList<String>();
+        int n = text.length();
+        int start = 0;
+        for (int i = 0; i < n; i++) {
+            char c = text.charAt(i);
+            if (c == '\n' || c == '\r') {
+                lines.add(text.substring(start, i));
+                if (c == '\r' && i + 1 < n && text.charAt(i + 1) == '\n') {
+                    i++;
+                }
+                start = i + 1;
+            }
+        }
+        if (start < n) {
+            lines.add(text.substring(start));
+        }
+        return lines;
+    }
+
+    // ---- writing ----
+
+    public static Path write(Path path, byte[] bytes, OpenOption... options) throws IOException {
+        if (bytes == null) {
+            throw new NullPointerException();
+        }
+        OutputStream out = newOutputStream(path, options);
+        try {
+            out.write(bytes, 0, bytes.length);
+        } finally {
+            out.close();
+        }
+        return path;
+    }
+
+    public static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)
+            throws IOException {
+        if (lines == null) {
+            throw new NullPointerException();
+        }
+        StringBuilder sb = new StringBuilder();
+        for (CharSequence line : lines) {
+            sb.append(line.toString()).append(LINE);
+        }
+        return write(path, sb.toString().getBytes(cs.name()), options);
+    }
+
+    public static Path write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options)
+            throws IOException {
+        return write(path, lines, StandardCharsets.UTF_8, options);
+    }
+
+    public static Path writeString(Path path, CharSequence csq, OpenOption... options) throws IOException {
+        return writeString(path, csq, StandardCharsets.UTF_8, options);
+    }
+
+    public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOption... options)
+            throws IOException {
+        if (csq == null) {
+            throw new NullPointerException();
+        }
+        return write(path, csq.toString().getBytes(cs.name()), options);
+    }
+
+    // ---- creating and deleting ----
+
+    public static Path createFile(Path path, FileAttribute<?>... attrs) throws IOException {
+        File f = file(path);
+        if (f.exists()) {
+            throw new FileAlreadyExistsException(path.toString());
+        }
+        File parent = f.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(path.toString());
+        }
+        // Claimed with the exclusive create, so of two callers racing for
+        // the path exactly one succeeds and nothing is truncated.
+        if (!f.createNewFile()) {
+            throw new FileAlreadyExistsException(path.toString());
+        }
+        return path;
+    }
+
+    public static Path createDirectory(Path dir, FileAttribute<?>... attrs) throws IOException {
+        File f = file(dir);
+        if (f.exists()) {
+            throw new FileAlreadyExistsException(dir.toString());
+        }
+        File parent = f.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(dir.toString());
+        }
+        if (!f.mkdir()) {
+            // mkdir is the atomic claim: a caller that lost the race for the
+            // name is told so, as createFile tells it.
+            if (f.exists()) {
+                throw new FileAlreadyExistsException(dir.toString());
+            }
+            throw new IOException("Could not create the directory " + dir);
+        }
+        return dir;
+    }
+
+    public static Path createDirectories(Path dir, FileAttribute<?>... attrs) throws IOException {
+        File f = file(dir);
+        if (f.isDirectory()) {
+            return dir;
+        }
+        if (f.exists()) {
+            throw new FileAlreadyExistsException(dir.toString());
+        }
+        f.mkdirs();
+        if (!f.isDirectory()) {
+            throw new IOException("Could not create the directory " + dir);
+        }
+        return dir;
+    }
+
+    private static Path temporaryDirectory() {
+        JdkHost h = JdkHost.get();
+        String caches = h.cachesDir();
+        return PathImpl.of(caches != null ? caches : h.appHome());
+    }
+
+    private static Path temporary(Path dir, String prefix, String suffix, boolean directory) throws IOException {
+        Path parent = dir == null ? temporaryDirectory() : dir;
+        String p = prefix == null ? "" : prefix;
+        long n = System.currentTimeMillis();
+        while (true) {
+            Path candidate = parent.resolve(p + n + suffix);
+            if (!file(candidate).exists()) {
+                // Another caller can claim the same name between the check and
+                // the create; the create is exclusive, so the loser moves on.
+                try {
+                    return directory ? createDirectory(candidate) : createFile(candidate);
+                } catch (FileAlreadyExistsException e) {
+                    // Taken meanwhile: try the next name.
+                }
+            }
+            n++;
+        }
+    }
+
+    public static Path createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>... attrs)
+            throws IOException {
+        if (dir == null) {
+            throw new NullPointerException();
+        }
+        return temporary(dir, prefix, suffix == null ? ".tmp" : suffix, false);
+    }
+
+    public static Path createTempFile(String prefix, String suffix, FileAttribute<?>... attrs) throws IOException {
+        return temporary(null, prefix, suffix == null ? ".tmp" : suffix, false);
+    }
+
+    public static Path createTempDirectory(Path dir, String prefix, FileAttribute<?>... attrs) throws IOException {
+        if (dir == null) {
+            throw new NullPointerException();
+        }
+        return temporary(dir, prefix, "", true);
+    }
+
+    public static Path createTempDirectory(String prefix, FileAttribute<?>... attrs) throws IOException {
+        return temporary(null, prefix, "", true);
+    }
+
+    public static void delete(Path path) throws IOException {
+        File f = existing(path);
+        if (f.isDirectory()) {
+            String[] entries = f.list();
+            if (entries != null && entries.length > 0) {
+                throw new DirectoryNotEmptyException(path.toString());
+            }
+        }
+        if (!f.delete()) {
+            throw new IOException("Could not delete " + path);
+        }
+    }
+
+    public static boolean deleteIfExists(Path path) throws IOException {
+        if (!file(path).exists()) {
+            return false;
+        }
+        delete(path);
+        return true;
+    }
+
+    // ---- copying and moving ----
+
+    /// Clears the way for a copy or a move to `target`, or says why not.
+    private static void replace(Path target, CopyOption[] options) throws IOException {
+        if (file(target).exists()) {
+            if (!has(options, StandardCopyOption.REPLACE_EXISTING)) {
+                throw new FileAlreadyExistsException(target.toString());
+            }
+            delete(target);
+        }
+    }
+
+    private static void transfer(File from, File to) throws IOException {
+        InputStream in = new FileInputStream(from);
+        try {
+            OutputStream out = new FileOutputStream(to, false);
+            try {
+                pump(in, out);
+            } finally {
+                out.close();
+            }
+        } finally {
+            in.close();
+        }
+    }
+
+    private static long pump(InputStream in, OutputStream out) throws IOException {
+        byte[] buffer = new byte[8192];
+        long total = 0;
+        int n;
+        while ((n = in.read(buffer, 0, buffer.length)) >= 0) {
+            out.write(buffer, 0, n);
+            total += n;
+        }
+        return total;
+    }
+
+    /// Copies a file, or creates an empty directory where `source` is one:
+    /// a directory's entries are not copied, as in the JDK.
+    public static Path copy(Path source, Path target, CopyOption... options) throws IOException {
+        File from = existing(source);
+        if (file(target).exists() && isSameFile(source, target)) {
+            return target;
+        }
+        replace(target, options);
+        if (from.isDirectory()) {
+            createDirectory(target);
+        } else {
+            File to = file(target);
+            File parent = to.getParentFile();
+            if (parent != null && !parent.isDirectory()) {
+                throw new NoSuchFileException(target.toString());
+            }
+            transfer(from, to);
+        }
+        return target;
+    }
+
+    public static long copy(InputStream in, Path target, CopyOption... options) throws IOException {
+        if (in == null) {
+            throw new NullPointerException();
+        }
+        replace(target, options);
+        OutputStream out = newOutputStream(target, StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);
+        try {
+            return pump(in, out);
+        } finally {
+            out.close();
+        }
+    }
+
+    public static long copy(Path source, OutputStream out) throws IOException {
+        if (out == null) {
+            throw new NullPointerException();
+        }
+        InputStream in = newInputStream(source);
+        try {
+            return pump(in, out);
+        } finally {
+            in.close();
+        }
+    }
+
+    private static void copyTree(File from, File to) throws IOException {
+        if (from.isDirectory()) {
+            if (!to.mkdir()) {
+                throw new IOException("Could not create the directory " + to.getPath());
+            }
+            String[] names = from.list();
+            if (names != null) {
+                for (String name : names) {
+                    copyTree(new File(from, name), new File(to, name));
+                }
+            }
+        } else {
+            transfer(from, to);
+        }
+    }
+
+    /// Deletes what a move has copied. An entry that will not go is an
+    /// error: answering normally would report a move that left the source,
+    /// or half of it, where it was.
+    private static void deleteTree(File f) throws IOException {
+        if (f.isDirectory()) {
+            String[] names = f.list();
+            if (names != null) {
+                for (String name : names) {
+                    deleteTree(new File(f, name));
+                }
+            }
+        }
+        if (!f.delete() && f.exists()) {
+            throw new IOException("Moved " + f.getPath() + " but could not delete the original");
+        }
+    }
+
+    /// Moves a file or a directory with everything in it. Where the device
+    /// cannot rename in place the tree is copied and the original deleted.
+    public static Path move(Path source, Path target, CopyOption... options) throws IOException {
+        File from = existing(source);
+        if (file(target).exists() && isSameFile(source, target)) {
+            return target;
+        }
+        replace(target, options);
+        File to = file(target);
+        File parent = to.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(target.toString());
+        }
+        if (!from.renameTo(to)) {
+            // No copy fallback for a regular file: File.renameTo already is
+            // one -- outside its directory it copies the bytes and deletes
+            // the original -- so a rename that failed is a copy or a delete
+            // that failed, and trying the same again would fail the same way.
+            if (!from.isDirectory()) {
+                throw new IOException("Could not move " + source + " to " + target);
+            }
+            copyTree(from, to);
+            deleteTree(from);
+        }
+        return target;
+    }
+
+    /// The position of the first byte two files differ in, or -1 when they
+    /// hold the same bytes. Both are read a block at a time, as the JDK
+    /// reads them, so two large files that differ early are not loaded
+    /// whole, and a file larger than an array can be compared at all.
+    public static long mismatch(Path path, Path path2) throws IOException {
+        if (isSameFile(path, path2)) {
+            return -1L;
+        }
+        InputStream a = newInputStream(path);
+        try {
+            InputStream b = newInputStream(path2);
+            try {
+                byte[] bufA = new byte[8192];
+                byte[] bufB = new byte[8192];
+                long at = 0;
+                while (true) {
+                    int na = fill(a, bufA);
+                    int nb = fill(b, bufB);
+                    int n = Math.min(na, nb);
+                    for (int i = 0; i < n; i++) {
+                        if (bufA[i] != bufB[i]) {
+                            return at + i;
+                        }
+                    }
+                    if (na != nb) {
+                        return at + n;
+                    }
+                    if (na < bufA.length) {
+                        return -1L;
+                    }
+                    at += n;
+                }
+            } finally {
+                b.close();
+            }
+        } finally {
+            a.close();
+        }
+    }
+
+    /// Reads into `buf` until it is full or the stream ends; how many bytes
+    /// were read. A stream may answer fewer than asked before its end.
+    private static int fill(InputStream in, byte[] buf) throws IOException {
+        int total = 0;
+        while (total < buf.length) {
+            int n = in.read(buf, total, buf.length - total);
+            if (n < 0) {
+                break;
+            }
+            total += n;
+        }
+        return total;
+    }
+
+    // ---- directories ----
+
+    private static List<Path> entries(Path dir) throws IOException {
+        File f = existing(dir);
+        if (!f.isDirectory()) {
+            throw new NotDirectoryException(dir.toString());
+        }
+        String[] names = f.list();
+        List<Path> out = new ArrayList<Path>();
+        if (names != null) {
+            Arrays.sort(names);
+            for (String name : names) {
+                out.add(dir.resolve(name));
+            }
+        }
+        return out;
+    }
+
+    /// The lines of `path` as UTF-8. See [#lines(Path, Charset)].
+    public static Stream<String> lines(Path path) throws IOException {
+        return lines(path, StandardCharsets.UTF_8);
+    }
+
+    /// The lines of `path`, read as the stream asks for them: `findFirst`
+    /// reads the start of a large file, not all of it. The file is opened
+    /// here, so a missing one throws now, and closing the stream closes it.
+    public static Stream<String> lines(Path path, Charset cs) throws IOException {
+        BufferedReader reader = newBufferedReader(path, cs);
+        return reader.lines().onClose(new CloseReader(reader));
+    }
+
+    /// The entries of `dir`, sorted by name.
+    public static Stream<Path> list(Path dir) throws IOException {
+        return lazy(entries(dir).iterator());
+    }
+
+    /// The paths under `start`, `start` first, depth first, to `maxDepth`
+    /// levels below it.
+    public static Stream<Path> walk(Path start, int maxDepth, FileVisitOption... options) throws IOException {
+        if (maxDepth < 0) {
+            throw new IllegalArgumentException("'maxDepth' is negative");
+        }
+        existing(start);
+        return lazy(new Walker(start, maxDepth));
+    }
+
+    /// The paths under `start`, at every depth. See
+    /// [#walk(Path, int, FileVisitOption...)].
+    public static Stream<Path> walk(Path start, FileVisitOption... options) throws IOException {
+        return walk(start, Integer.MAX_VALUE, options);
+    }
+
+    /// The paths [#walk(Path, int, FileVisitOption...)] would answer for
+    /// which `matcher` holds, given each path's attributes.
+    public static Stream<Path> find(Path start, int maxDepth, BiPredicate<Path, BasicFileAttributes> matcher,
+                                    FileVisitOption... options) throws IOException {
+        if (maxDepth < 0) {
+            throw new IllegalArgumentException("'maxDepth' is negative");
+        }
+        if (matcher == null) {
+            throw new NullPointerException();
+        }
+        existing(start);
+        return lazy(new Finder(new Walker(start, maxDepth), matcher));
+    }
+
+    private static <T> Stream<T> lazy(Iterator<T> it) {
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it,
+                Spliterator.ORDERED | Spliterator.NONNULL), false);
+    }
+
+    private static final class CloseReader implements Runnable {
+        private final BufferedReader reader;
+
+        CloseReader(BufferedReader reader) {
+            this.reader = reader;
+        }
+
+        @Override
+        public void run() {
+            try {
+                reader.close();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+    }
+
+    /// Depth first, discovering as it goes: a directory is listed when the
+    /// walk advances past it, never before, and a failure to list it
+    /// surfaces then.
+    private static final class Walker implements Iterator<Path> {
+        /// The entries still to visit, one iterator per open directory.
+        private final List<Iterator<Path>> levels = new ArrayList<Iterator<Path>>();
+        private final int maxDepth;
+        private Path pending;
+        private int pendingDepth;
+        /// The path answered last, entered on the next advance if it is a
+        /// directory within the depth limit.
+        private Path last;
+        private int lastDepth;
+
+        Walker(Path start, int maxDepth) {
+            this.maxDepth = maxDepth;
+            this.pending = start;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (pending != null) {
+                return true;
+            }
+            if (last != null && lastDepth < maxDepth && file(last).isDirectory()) {
+                try {
+                    levels.add(entries(last).iterator());
+                } catch (IOException e) {
+                    throw new UncheckedIOException(e);
+                }
+            }
+            last = null;
+            while (!levels.isEmpty()) {
+                Iterator<Path> top = levels.get(levels.size() - 1);
+                if (top.hasNext()) {
+                    pending = top.next();
+                    pendingDepth = levels.size();
+                    return true;
+                }
+                levels.remove(levels.size() - 1);
+            }
+            return false;
+        }
+
+        @Override
+        public Path next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            Path p = pending;
+            pending = null;
+            last = p;
+            lastDepth = pendingDepth;
+            return p;
+        }
+    }
+
+    private static final class Finder implements Iterator<Path> {
+        private final Iterator<Path> all;
+        private final BiPredicate<Path, BasicFileAttributes> matcher;
+        private Path next;
+
+        Finder(Iterator<Path> all, BiPredicate<Path, BasicFileAttributes> matcher) {
+            this.all = all;
+            this.matcher = matcher;
+        }
+
+        @Override
+        public boolean hasNext() {
+            while (next == null && all.hasNext()) {
+                Path p = all.next();
+                if (matcher.test(p, attributes(file(p)))) {
+                    next = p;
+                }
+            }
+            return next != null;
+        }
+
+        @Override
+        public Path next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            Path p = next;
+            next = null;
+            return p;
+        }
+    }
+
+    public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor) throws IOException {
+        return walkFileTree(start, null, Integer.MAX_VALUE, visitor);
+    }
+
+    public static Path walkFileTree(Path start, Set<FileVisitOption> options, int maxDepth,
+                                    FileVisitor<? super Path> visitor) throws IOException {
+        if (maxDepth < 0) {
+            throw new IllegalArgumentException("'maxDepth' is negative");
+        }
+        if (visitor == null) {
+            throw new NullPointerException();
+        }
+        visit(start, 0, maxDepth, visitor);
+        return start;
+    }
+
+    private static FileVisitResult checked(FileVisitResult result) {
+        if (result == null) {
+            throw new NullPointerException();
+        }
+        return result;
+    }
+
+    /// Visits `path` and what is under it. Answers `TERMINATE` to stop the
+    /// walk, `SKIP_SIBLINGS` to stop the directory it is an entry of, and
+    /// `CONTINUE` otherwise.
+    private static FileVisitResult visit(Path path, int depth, int maxDepth, FileVisitor<? super Path> visitor)
+            throws IOException {
+        File f = file(path);
+        if (!f.exists()) {
+            return checked(visitor.visitFileFailed(path, new NoSuchFileException(path.toString())));
+        }
+        BasicFileAttributes attrs = attributes(f);
+        if (!attrs.isDirectory() || depth >= maxDepth) {
+            return checked(visitor.visitFile(path, attrs));
+        }
+        FileVisitResult pre = checked(visitor.preVisitDirectory(path, attrs));
+        if (pre == FileVisitResult.SKIP_SUBTREE) {
+            return FileVisitResult.CONTINUE;
+        }
+        if (pre != FileVisitResult.CONTINUE) {
+            return pre;
+        }
+        for (Path entry : entries(path)) {
+            FileVisitResult result = visit(entry, depth + 1, maxDepth, visitor);
+            if (result == FileVisitResult.TERMINATE) {
+                return result;
+            }
+            if (result == FileVisitResult.SKIP_SIBLINGS) {
+                break;
+            }
+        }
+        FileVisitResult post = checked(visitor.postVisitDirectory(path, null));
+        return post == FileVisitResult.SKIP_SUBTREE ? FileVisitResult.CONTINUE : post;
+    }
+
+    public static DirectoryStream<Path> newDirectoryStream(Path dir) throws IOException {
+        return new Listing(entries(dir));
+    }
+
+    public static DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)
+            throws IOException {
+        if (filter == null) {
+            throw new NullPointerException();
+        }
+        List<Path> out = new ArrayList<Path>();
+        for (Path entry : entries(dir)) {
+            if (filter.accept(entry)) {
+                out.add(entry);
+            }
+        }
+        return new Listing(out);
+    }
+
+    /// The entries of `dir` whose names match `glob`: `*` and `?` for any
+    /// characters and any one, `[a-c]` and `[!a-c]` for a set of them,
+    /// `{one,two}` for alternatives, and a backslash to take the next
+    /// character literally.
+    public static DirectoryStream<Path> newDirectoryStream(Path dir, String glob) throws IOException {
+        if (glob == null) {
+            throw new NullPointerException();
+        }
+        List<Path> out = new ArrayList<Path>();
+        for (Path entry : entries(dir)) {
+            String name = entry.getFileName().toString();
+            if (Glob.matches(glob, 0, glob.length(), name, 0)) {
+                out.add(entry);
+            }
+        }
+        return new Listing(out);
+    }
+
+    private static final class Listing implements DirectoryStream<Path> {
+        private final List<Path> entries;
+        private boolean iterated;
+        private boolean closed;
+
+        Listing(List<Path> entries) {
+            this.entries = entries;
+        }
+
+        @Override
+        public Iterator<Path> iterator() {
+            if (closed) {
+                throw new IllegalStateException("Directory stream is closed");
+            }
+            if (iterated) {
+                throw new IllegalStateException("Iterator already obtained");
+            }
+            iterated = true;
+            final Iterator<Path> it = entries.iterator();
+            return new Iterator<Path>() {
+                @Override
+                public boolean hasNext() {
+                    return !closed && it.hasNext();
+                }
+
+                @Override
+                public Path next() {
+                    if (closed) {
+                        throw new NoSuchElementException();
+                    }
+                    return it.next();
+                }
+
+                @Override
+                public void remove() {
+                    throw new UnsupportedOperationException();
+                }
+            };
+        }
+
+        @Override
+        public void close() {
+            closed = true;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/Glob.java b/Ports/CLDC11/src/java/nio/file/Glob.java
new file mode 100644
index 00000000000..33b36151901
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/Glob.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The glob syntax of `Files.newDirectoryStream(dir, glob)`, matched against
+/// one file name.
+final class Glob {
+
+    private Glob() {
+    }
+
+    /// Whether `name` from `ni` on matches `glob` between `gi` and `gEnd`.
+    static boolean matches(String glob, int gi, int gEnd, String name, int ni) {
+        int n = name.length();
+        while (gi < gEnd) {
+            char g = glob.charAt(gi);
+            if (g == '*') {
+                while (gi < gEnd && glob.charAt(gi) == '*') {
+                    gi++;
+                }
+                if (gi == gEnd) {
+                    return true;
+                }
+                for (int k = ni; k <= n; k++) {
+                    if (matches(glob, gi, gEnd, name, k)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            if (g == '{') {
+                int close = closing(glob, gi, gEnd);
+                if (close < 0) {
+                    throw new IllegalArgumentException("Missing '}' in glob: " + glob);
+                }
+                String rest = glob.substring(close + 1, gEnd);
+                int start = gi + 1;
+                for (int i = start; i <= close; i++) {
+                    char c = glob.charAt(i);
+                    if (c == '\\') {
+                        i++;
+                    } else if (c == ',' || i == close) {
+                        String alternative = glob.substring(start, i) + rest;
+                        if (matches(alternative, 0, alternative.length(), name, ni)) {
+                            return true;
+                        }
+                        start = i + 1;
+                    }
+                }
+                return false;
+            }
+            if (ni >= n) {
+                return false;
+            }
+            char c = name.charAt(ni);
+            if (g == '?') {
+                gi++;
+            } else if (g == '[') {
+                int close = gi + 1;
+                boolean negate = close < gEnd && glob.charAt(close) == '!';
+                if (negate) {
+                    close++;
+                }
+                int first = close;
+                boolean found = false;
+                while (close < gEnd && (glob.charAt(close) != ']' || close == first)) {
+                    char lo = glob.charAt(close);
+                    char hi = lo;
+                    if (close + 2 < gEnd && glob.charAt(close + 1) == '-' && glob.charAt(close + 2) != ']') {
+                        hi = glob.charAt(close + 2);
+                        close += 2;
+                    }
+                    found = found || (c >= lo && c <= hi);
+                    close++;
+                }
+                if (close >= gEnd) {
+                    throw new IllegalArgumentException("Missing ']' in glob: " + glob);
+                }
+                if (found == negate) {
+                    return false;
+                }
+                gi = close + 1;
+            } else {
+                if (g == '\\') {
+                    gi++;
+                    if (gi >= gEnd) {
+                        throw new IllegalArgumentException("No character to escape in glob: " + glob);
+                    }
+                    g = glob.charAt(gi);
+                }
+                if (g != c) {
+                    return false;
+                }
+                gi++;
+            }
+            ni++;
+        }
+        return ni == n;
+    }
+
+    private static int closing(String glob, int open, int end) {
+        for (int i = open + 1; i < end; i++) {
+            char c = glob.charAt(i);
+            if (c == '\\') {
+                i++;
+            } else if (c == '}') {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/InvalidPathException.java b/Ports/CLDC11/src/java/nio/file/InvalidPathException.java
new file mode 100644
index 00000000000..b2f91cbc64c
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/InvalidPathException.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// A string that cannot be made a path.
+public class InvalidPathException extends IllegalArgumentException {
+    private static final long serialVersionUID = 1L;
+    private final String input;
+    private final String reason;
+    private final int index;
+
+    public InvalidPathException(String input, String reason, int index) {
+        super(reason);
+        if (input == null || reason == null) {
+            throw new NullPointerException();
+        }
+        if (index < -1) {
+            throw new IllegalArgumentException();
+        }
+        this.input = input;
+        this.reason = reason;
+        this.index = index;
+    }
+
+    public InvalidPathException(String input, String reason) {
+        this(input, reason, -1);
+    }
+
+    public String getInput() {
+        return input;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    @Override
+    public String getMessage() {
+        StringBuilder sb = new StringBuilder(reason);
+        if (index > -1) {
+            sb.append(" at index ").append(index);
+        }
+        return sb.append(": ").append(input).toString();
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/LinkOption.java b/Ports/CLDC11/src/java/nio/file/LinkOption.java
new file mode 100644
index 00000000000..b3e7d920389
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/LinkOption.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The device's
+/// file system is not asked about symbolic links, so the option is accepted
+/// wherever the JDK takes it and changes nothing.
+public enum LinkOption implements OpenOption, CopyOption {
+    NOFOLLOW_LINKS
+}
diff --git a/Ports/CLDC11/src/java/nio/file/NoSuchFileException.java b/Ports/CLDC11/src/java/nio/file/NoSuchFileException.java
new file mode 100644
index 00000000000..30cdb47343f
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/NoSuchFileException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// Nothing is at the path.
+public class NoSuchFileException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public NoSuchFileException(String file) {
+        super(file);
+    }
+
+    public NoSuchFileException(String file, String other, String reason) {
+        super(file, other, reason);
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/NotDirectoryException.java b/Ports/CLDC11/src/java/nio/file/NotDirectoryException.java
new file mode 100644
index 00000000000..cead4086d50
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/NotDirectoryException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The path is not a directory.
+public class NotDirectoryException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public NotDirectoryException(String file) {
+        super(file);
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/OpenOption.java b/Ports/CLDC11/src/java/nio/file/OpenOption.java
new file mode 100644
index 00000000000..02550233ff4
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/OpenOption.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is
+/// opened. [StandardOpenOption] has the values.
+public interface OpenOption {
+}
diff --git a/Ports/CLDC11/src/java/nio/file/Path.java b/Ports/CLDC11/src/java/nio/file/Path.java
new file mode 100644
index 00000000000..db53f9b0d1b
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/Path.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Iterator;
+
+/// A path in the platform's file system, the one `java.io.File` reaches.
+///
+/// #### What a path is here
+///
+/// A sequence of names separated by `/`, after an optional root. A backslash
+/// is read as a separator. The root is `/`, or -- because Codename One names
+/// its files `file:///...` and `java.io.File.getAbsolutePath()` answers that
+/// form -- the `file:` scheme with the slashes after it. A relative path is
+/// resolved against the application's home directory when it is used, which
+/// is also what [#toAbsolutePath()] answers.
+///
+/// The methods that only rearrange names (`resolve`, `relativize`,
+/// `normalize`, `getParent`, `startsWith`, ...) answer what the JDK answers
+/// on a Unix file system.
+///
+/// #### What is not provided
+///
+/// `getFileSystem()` and `register(...)`: there is one file system and it
+/// cannot be watched. [#toRealPath] is `File.getCanonicalPath()`: where the
+/// file system cannot resolve symbolic links it answers the absolute path
+/// with `.` and `..` resolved.
+public interface Path extends Comparable<Path>, Iterable<Path> {
+
+    /// The path `first`, with each of `more` appended as further names.
+    static Path of(String first, String... more) {
+        return PathImpl.of(first, more);
+    }
+
+    /// The path a `file:` URI names.
+    static Path of(URI uri) {
+        return PathImpl.of(uri);
+    }
+
+    boolean isAbsolute();
+
+    Path getRoot();
+
+    Path getFileName();
+
+    Path getParent();
+
+    int getNameCount();
+
+    Path getName(int index);
+
+    Path subpath(int beginIndex, int endIndex);
+
+    boolean startsWith(Path other);
+
+    boolean startsWith(String other);
+
+    boolean endsWith(Path other);
+
+    boolean endsWith(String other);
+
+    Path normalize();
+
+    Path resolve(Path other);
+
+    Path resolve(String other);
+
+    Path resolveSibling(Path other);
+
+    Path resolveSibling(String other);
+
+    Path relativize(Path other);
+
+    URI toUri();
+
+    Path toAbsolutePath();
+
+    /// The absolute path with `.` and `..` resolved, and symbolic links where
+    /// the file system can. Throws [NoSuchFileException] when nothing is there.
+    Path toRealPath(LinkOption... options) throws IOException;
+
+    File toFile();
+
+    @Override
+    Iterator<Path> iterator();
+
+    @Override
+    int compareTo(Path other);
+}
diff --git a/Ports/CLDC11/src/java/nio/file/PathImpl.java b/Ports/CLDC11/src/java/nio/file/PathImpl.java
new file mode 100644
index 00000000000..d229c310493
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/PathImpl.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/// The one implementation of [Path]: a normalized path string, split into a
+/// root and names when a method needs them.
+final class PathImpl implements Path {
+
+    private static final String[] NO_NAMES = new String[0];
+    private static final String SCHEME = "file:";
+
+    /// Separators collapsed, no trailing separator unless the path is a root.
+    private final String path;
+    private final int rootLength;
+    private String[] names;
+
+    private PathImpl(String path) {
+        this.path = path;
+        this.rootLength = rootLength(path);
+    }
+
+    static PathImpl of(String first, String[] more) {
+        if (first == null) {
+            throw new NullPointerException();
+        }
+        String joined = first;
+        if (more != null && more.length > 0) {
+            StringBuilder sb = new StringBuilder(first);
+            for (String m : more) {
+                if (m == null) {
+                    throw new NullPointerException();
+                }
+                if (m.length() > 0) {
+                    if (sb.length() > 0) {
+                        sb.append('/');
+                    }
+                    sb.append(m);
+                }
+            }
+            joined = sb.toString();
+        }
+        if (joined.indexOf('\0') >= 0) {
+            throw new InvalidPathException(joined, "Nul character not allowed");
+        }
+        return new PathImpl(clean(joined));
+    }
+
+    static PathImpl of(String path) {
+        return of(path, null);
+    }
+
+    static PathImpl of(URI uri) {
+        String scheme = uri.getScheme();
+        if (scheme == null || !"file".equalsIgnoreCase(scheme)) {
+            throw new IllegalArgumentException("URI scheme is not \"file\"");
+        }
+        // Only what names a file on this device is a path, as in the JDK:
+        // a host, a query or a fragment is not dropped, it is refused, so
+        // that file://server/share/x does not quietly become /share/x.
+        if (uri.isOpaque()) {
+            throw new IllegalArgumentException("URI is not hierarchical");
+        }
+        if (present(uri.getRawAuthority())) {
+            throw new IllegalArgumentException("URI has an authority component");
+        }
+        if (present(uri.getRawFragment())) {
+            throw new IllegalArgumentException("URI has a fragment component");
+        }
+        if (present(uri.getRawQuery())) {
+            throw new IllegalArgumentException("URI has a query component");
+        }
+        String p = uri.getPath();
+        if (p == null || p.length() == 0) {
+            throw new IllegalArgumentException("URI has no path component");
+        }
+        return of(p);
+    }
+
+    /// Whether a URI has the component. An empty one counts as none: the
+    /// device's `URI` answers an empty authority for `file:///x`, where the
+    /// JDK's answers null.
+    private static boolean present(String component) {
+        return component != null && component.length() > 0;
+    }
+
+    /// How many leading characters are the root: one for `/`, the scheme and
+    /// its slashes for a `file:` path, none for a relative path.
+    private static int rootLength(String p) {
+        if (p.startsWith(SCHEME)) {
+            int i = SCHEME.length();
+            while (i < p.length() && p.charAt(i) == '/') {
+                i++;
+            }
+            return i;
+        }
+        return p.startsWith("/") ? 1 : 0;
+    }
+
+    /// Collapses runs of separators and drops a trailing one, leaving the
+    /// slashes of a `file:` root as they were written.
+    private static String clean(String p) {
+        int root = 0;
+        StringBuilder sb = new StringBuilder(p.length());
+        if (p.startsWith(SCHEME)) {
+            root = rootLength(p);
+            sb.append(p.substring(0, root));
+        }
+        boolean separator = false;
+        for (int i = root; i < p.length(); i++) {
+            char c = p.charAt(i);
+            if (c == '\\') {
+                c = '/';
+            }
+            if (c == '/') {
+                if (sb.length() == 0) {
+                    sb.append('/');
+                    root = 1;
+                } else {
+                    separator = sb.length() > root;
+                }
+                continue;
+            }
+            if (separator) {
+                sb.append('/');
+                separator = false;
+            }
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    private String[] names() {
+        if (names == null) {
+            if (path.length() == rootLength) {
+                // The empty path is one empty name; a root has none.
+                names = rootLength == 0 ? new String[] {""} : NO_NAMES;
+            } else {
+                List<String> out = new ArrayList<String>();
+                int start = rootLength;
+                for (int i = rootLength; i <= path.length(); i++) {
+                    if (i == path.length() || path.charAt(i) == '/') {
+                        out.add(path.substring(start, i));
+                        start = i + 1;
+                    }
+                }
+                names = out.toArray(new String[out.size()]);
+            }
+        }
+        return names;
+    }
+
+    private boolean isEmpty() {
+        return path.length() == 0;
+    }
+
+    private String root() {
+        return path.substring(0, rootLength);
+    }
+
+    private static PathImpl build(String root, String[] names, int from, int to) {
+        StringBuilder sb = new StringBuilder(root);
+        for (int i = from; i < to; i++) {
+            if (i > from) {
+                sb.append('/');
+            }
+            sb.append(names[i]);
+        }
+        return new PathImpl(sb.toString());
+    }
+
+    private static PathImpl impl(Path other) {
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        if (other instanceof PathImpl) {
+            return (PathImpl) other;
+        }
+        return of(other.toString());
+    }
+
+    @Override
+    public boolean isAbsolute() {
+        return rootLength > 0;
+    }
+
+    @Override
+    public Path getRoot() {
+        return rootLength == 0 ? null : new PathImpl(root());
+    }
+
+    @Override
+    public Path getFileName() {
+        String[] n = names();
+        return n.length == 0 ? null : new PathImpl(n[n.length - 1]);
+    }
+
+    @Override
+    public Path getParent() {
+        String[] n = names();
+        if (n.length == 0) {
+            return null;
+        }
+        if (n.length == 1) {
+            return rootLength == 0 ? null : new PathImpl(root());
+        }
+        return build(root(), n, 0, n.length - 1);
+    }
+
+    @Override
+    public int getNameCount() {
+        return names().length;
+    }
+
+    @Override
+    public Path getName(int index) {
+        String[] n = names();
+        if (index < 0 || index >= n.length) {
+            throw new IllegalArgumentException();
+        }
+        return new PathImpl(n[index]);
+    }
+
+    @Override
+    public Path subpath(int beginIndex, int endIndex) {
+        String[] n = names();
+        if (beginIndex < 0 || beginIndex >= n.length || endIndex > n.length || beginIndex >= endIndex) {
+            throw new IllegalArgumentException();
+        }
+        return build("", n, beginIndex, endIndex);
+    }
+
+    @Override
+    public boolean startsWith(Path other) {
+        PathImpl o = impl(other);
+        if (!root().equals(o.root())) {
+            return false;
+        }
+        String[] a = names();
+        String[] b = o.names();
+        if (b.length > a.length) {
+            return false;
+        }
+        for (int i = 0; i < b.length; i++) {
+            if (!a[i].equals(b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean startsWith(String other) {
+        return startsWith(of(other));
+    }
+
+    @Override
+    public boolean endsWith(Path other) {
+        PathImpl o = impl(other);
+        if (o.rootLength > 0) {
+            return equals(o);
+        }
+        String[] a = names();
+        String[] b = o.names();
+        if (b.length > a.length) {
+            return false;
+        }
+        for (int i = 0; i < b.length; i++) {
+            if (!a[a.length - b.length + i].equals(b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean endsWith(String other) {
+        return endsWith(of(other));
+    }
+
+    @Override
+    public Path normalize() {
+        String[] n = names();
+        List<String> out = new ArrayList<String>(n.length);
+        for (String name : n) {
+            if (".".equals(name) || name.length() == 0) {
+                continue;
+            }
+            if ("..".equals(name)) {
+                int last = out.size() - 1;
+                if (last >= 0 && !"..".equals(out.get(last))) {
+                    out.remove(last);
+                    continue;
+                }
+                if (rootLength > 0) {
+                    // Above the root there is the root.
+                    continue;
+                }
+            }
+            out.add(name);
+        }
+        if (out.size() == n.length) {
+            return this;
+        }
+        return build(root(), out.toArray(new String[out.size()]), 0, out.size());
+    }
+
+    @Override
+    public Path resolve(Path other) {
+        PathImpl o = impl(other);
+        if (o.rootLength > 0 || isEmpty()) {
+            return o;
+        }
+        if (o.isEmpty()) {
+            return this;
+        }
+        return new PathImpl(path.length() == rootLength ? path + o.path : path + "/" + o.path);
+    }
+
+    @Override
+    public Path resolve(String other) {
+        return resolve(of(other));
+    }
+
+    @Override
+    public Path resolveSibling(Path other) {
+        PathImpl o = impl(other);
+        Path parent = getParent();
+        return parent == null ? o : parent.resolve(o);
+    }
+
+    @Override
+    public Path resolveSibling(String other) {
+        return resolveSibling(of(other));
+    }
+
+    private boolean hasDots() {
+        if (isEmpty()) {
+            return false;
+        }
+        for (String name : names()) {
+            if (".".equals(name) || "..".equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Path relativize(Path other) {
+        PathImpl o = impl(other);
+        if (!root().equals(o.root())) {
+            throw new IllegalArgumentException("'other' is different type of Path");
+        }
+        if (path.equals(o.path)) {
+            return new PathImpl("");
+        }
+        // A `.` or `..` anywhere has both sides normalized first, as the
+        // JDK has done since it stopped answering `../../b` for `a/..`
+        // against `b`: a name that cancels the one before it is no step
+        // away from anything. What is left of a `..` afterwards leads the
+        // path, cancels nothing, and is refused below.
+        PathImpl from = this;
+        if (!isEmpty() && (hasDots() || o.hasDots())) {
+            from = impl(normalize());
+            o = impl(o.normalize());
+        }
+        String[] a = from.isEmpty() ? NO_NAMES : from.names();
+        String[] b = o.isEmpty() ? NO_NAMES : o.names();
+        int common = 0;
+        while (common < a.length && common < b.length && a[common].equals(b[common])) {
+            common++;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = common; i < a.length; i++) {
+            if ("..".equals(a[i])) {
+                throw new IllegalArgumentException("Unable to compute relative path from " + this + " to " + other);
+            }
+            if (sb.length() > 0) {
+                sb.append('/');
+            }
+            sb.append("..");
+        }
+        for (int i = common; i < b.length; i++) {
+            if (sb.length() > 0) {
+                sb.append('/');
+            }
+            sb.append(b[i]);
+        }
+        return new PathImpl(sb.toString());
+    }
+
+    @Override
+    public URI toUri() {
+        // The storage path is "file://" and an absolute path, as typed: a
+        // space, '#' or '%' in a file's name is not legal in a URI as it
+        // stands. Handing the path over as a component has it escaped.
+        String storage = toFile().getAbsolutePath();
+        int at = storage.startsWith(SCHEME) ? SCHEME.length() : 0;
+        while (at + 1 < storage.length() && storage.charAt(at) == '/' && storage.charAt(at + 1) == '/') {
+            at++;
+        }
+        String uriPath = storage.substring(at);
+        // A directory's URI ends in '/', as the JDK's does, so that resolving
+        // a name against it lands inside the directory rather than beside it.
+        if (!uriPath.endsWith("/") && toFile().isDirectory()) {
+            uriPath = uriPath + "/";
+        }
+        try {
+            return new URI("file", null, uriPath, null, null);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException(e.getMessage());
+        }
+    }
+
+    @Override
+    public Path toAbsolutePath() {
+        return rootLength > 0 ? this : new PathImpl(clean(toFile().getAbsolutePath()));
+    }
+
+    @Override
+    public Path toRealPath(LinkOption... options) throws IOException {
+        File file = toFile();
+        if (!file.exists()) {
+            throw new NoSuchFileException(path);
+        }
+        return new PathImpl(clean(file.getCanonicalPath()));
+    }
+
+    @Override
+    public File toFile() {
+        return new File(path);
+    }
+
+    @Override
+    public Iterator<Path> iterator() {
+        return new Names(names());
+    }
+
+    /// The names of a path, each as a path of its own.
+    private static final class Names implements Iterator<Path> {
+        private final String[] n;
+        private int next;
+
+        Names(String[] n) {
+            this.n = n;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return next < n.length;
+        }
+
+        @Override
+        public Path next() {
+            if (next >= n.length) {
+                throw new NoSuchElementException();
+            }
+            return new PathImpl(n[next++]);
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override
+    public int compareTo(Path other) {
+        return path.compareTo(impl(other).path);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof PathImpl && ((PathImpl) o).path.equals(path);
+    }
+
+    @Override
+    public int hashCode() {
+        return path.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return path;
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/Paths.java b/Ports/CLDC11/src/java/nio/file/Paths.java
new file mode 100644
index 00000000000..afb6f8e9d12
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/Paths.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.net.URI;
+
+/// Makes paths; see [Path].
+public final class Paths {
+
+    private Paths() {
+    }
+
+    public static Path get(String first, String... more) {
+        return PathImpl.of(first, more);
+    }
+
+    public static Path get(URI uri) {
+        return PathImpl.of(uri);
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/SimpleFileVisitor.java b/Ports/CLDC11/src/java/nio/file/SimpleFileVisitor.java
new file mode 100644
index 00000000000..ac7e9451e32
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/SimpleFileVisitor.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+import java.nio.file.attribute.BasicFileAttributes;
+
+/// A
+/// [FileVisitor] that visits everything and rethrows what failed.
+public class SimpleFileVisitor<T> implements FileVisitor<T> {
+
+    protected SimpleFileVisitor() {
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs) throws IOException {
+        if (dir == null || attrs == null) {
+            throw new NullPointerException();
+        }
+        return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFile(T file, BasicFileAttributes attrs) throws IOException {
+        if (file == null || attrs == null) {
+            throw new NullPointerException();
+        }
+        return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(T file, IOException exc) throws IOException {
+        if (file == null) {
+            throw new NullPointerException();
+        }
+        throw exc;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(T dir, IOException exc) throws IOException {
+        if (dir == null) {
+            throw new NullPointerException();
+        }
+        if (exc != null) {
+            throw exc;
+        }
+        return FileVisitResult.CONTINUE;
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/StandardCopyOption.java b/Ports/CLDC11/src/java/nio/file/StandardCopyOption.java
new file mode 100644
index 00000000000..e7f564abb0e
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/StandardCopyOption.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is copied or moved.
+/// `REPLACE_EXISTING` is honoured; `COPY_ATTRIBUTES` and `ATOMIC_MOVE` are
+/// accepted and have no effect.
+public enum StandardCopyOption implements CopyOption {
+    REPLACE_EXISTING,
+    COPY_ATTRIBUTES,
+    ATOMIC_MOVE
+}
diff --git a/Ports/CLDC11/src/java/nio/file/StandardOpenOption.java b/Ports/CLDC11/src/java/nio/file/StandardOpenOption.java
new file mode 100644
index 00000000000..b86be1e717a
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/StandardOpenOption.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is opened.
+///
+/// `READ`, `WRITE`, `APPEND`, `TRUNCATE_EXISTING`, `CREATE` and `CREATE_NEW`
+/// mean what they mean in the JDK. `DELETE_ON_CLOSE`, `SPARSE`, `SYNC` and
+/// `DSYNC` are accepted and have no effect: a device writes a file when the
+/// stream is closed and has nothing to say about how.
+public enum StandardOpenOption implements OpenOption {
+    READ,
+    WRITE,
+    APPEND,
+    TRUNCATE_EXISTING,
+    CREATE,
+    CREATE_NEW,
+    DELETE_ON_CLOSE,
+    SPARSE,
+    SYNC,
+    DSYNC
+}
diff --git a/Ports/CLDC11/src/java/nio/file/attribute/BasicFileAttributes.java b/Ports/CLDC11/src/java/nio/file/attribute/BasicFileAttributes.java
new file mode 100644
index 00000000000..df3cab26b9b
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/attribute/BasicFileAttributes.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file.attribute;
+
+/// What the device's file system knows about a file.
+///
+/// The three times are all the time of the last modification, which is the
+/// only one the device records. Nothing is a symbolic link, and there is no
+/// file key.
+public interface BasicFileAttributes {
+
+    FileTime lastModifiedTime();
+
+    FileTime lastAccessTime();
+
+    FileTime creationTime();
+
+    boolean isRegularFile();
+
+    boolean isDirectory();
+
+    boolean isSymbolicLink();
+
+    boolean isOther();
+
+    long size();
+
+    Object fileKey();
+}
diff --git a/Ports/CLDC11/src/java/nio/file/attribute/FileAttribute.java b/Ports/CLDC11/src/java/nio/file/attribute/FileAttribute.java
new file mode 100644
index 00000000000..9ea9cdfd1fe
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/attribute/FileAttribute.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file.attribute;
+
+/// The
+/// methods that create a file take these and a device has none to set, so
+/// the type exists for the empty array every such call passes.
+public interface FileAttribute<T> {
+
+    String name();
+
+    T value();
+}
diff --git a/Ports/CLDC11/src/java/nio/file/attribute/FileTime.java b/Ports/CLDC11/src/java/nio/file/attribute/FileTime.java
new file mode 100644
index 00000000000..8924d06279d
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/attribute/FileTime.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file.attribute;
+
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+
+/// A file's
+/// time stamp, kept to the millisecond, which is as fine as the device's
+/// file system reports it.
+public final class FileTime implements Comparable<FileTime> {
+
+    private final long millis;
+
+    private FileTime(long millis) {
+        this.millis = millis;
+    }
+
+    public static FileTime fromMillis(long value) {
+        return new FileTime(value);
+    }
+
+    public static FileTime from(long value, TimeUnit unit) {
+        return new FileTime(unit.toMillis(value));
+    }
+
+    public static FileTime from(Instant instant) {
+        return new FileTime(instant.toEpochMilli());
+    }
+
+    public long toMillis() {
+        return millis;
+    }
+
+    public long to(TimeUnit unit) {
+        return unit.convert(millis, TimeUnit.MILLISECONDS);
+    }
+
+    public Instant toInstant() {
+        return Instant.ofEpochMilli(millis);
+    }
+
+    @Override
+    public int compareTo(FileTime other) {
+        return millis < other.millis ? -1 : millis == other.millis ? 0 : 1;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof FileTime && ((FileTime) o).millis == millis;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (millis ^ (millis >>> 32));
+    }
+
+    private static long floorDiv(long x, long y) {
+        long q = x / y;
+        return (x % y != 0 && (x < 0) != (y < 0)) ? q - 1 : q;
+    }
+
+    private static void pad(StringBuilder sb, long value, int width) {
+        String digits = Long.toString(value);
+        for (int i = digits.length(); i < width; i++) {
+            sb.append('0');
+        }
+        sb.append(digits);
+    }
+
+    /// The time in ISO 8601, in UTC, as the JDK writes it:
+    /// `2024-02-29T12:30:05.25Z`, the fraction left out when it is zero.
+    @Override
+    public String toString() {
+        long days = floorDiv(millis, 86400000L);
+        long ofDay = millis - floorDiv(millis, 86400000L) * 86400000L;
+        // Days since 1970-01-01 to a civil date, in the proleptic Gregorian
+        // calendar: eras of 400 years, counted from the first of March.
+        long z = days + 719468L;
+        long era = floorDiv(z, 146097L);
+        long doe = z - era * 146097L;
+        long yoe = (doe - doe / 1460L + doe / 36524L - doe / 146096L) / 365L;
+        long doy = doe - (365L * yoe + yoe / 4L - yoe / 100L);
+        long mp = (5L * doy + 2L) / 153L;
+        long day = doy - (153L * mp + 2L) / 5L + 1L;
+        long month = mp < 10 ? mp + 3 : mp - 9;
+        long year = yoe + era * 400L + (month <= 2 ? 1 : 0);
+        StringBuilder sb = new StringBuilder(30);
+        if (year < 0) {
+            sb.append('-');
+            pad(sb, -year, 4);
+        } else {
+            pad(sb, year, 4);
+        }
+        sb.append('-');
+        pad(sb, month, 2);
+        sb.append('-');
+        pad(sb, day, 2);
+        sb.append('T');
+        pad(sb, ofDay / 3600000L, 2);
+        sb.append(':');
+        pad(sb, ofDay / 60000L % 60L, 2);
+        sb.append(':');
+        pad(sb, ofDay / 1000L % 60L, 2);
+        long fraction = ofDay % 1000L;
+        if (fraction != 0) {
+            sb.append('.');
+            pad(sb, fraction, 3);
+            while (sb.charAt(sb.length() - 1) == '0') {
+                sb.setLength(sb.length() - 1);
+            }
+        }
+        return sb.append('Z').toString();
+    }
+}
diff --git a/Ports/CLDC11/src/java/nio/file/attribute/package-info.java b/Ports/CLDC11/src/java/nio/file/attribute/package-info.java
new file mode 100644
index 00000000000..465f850991f
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/attribute/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The attributes of a file: its type, size and time stamp.
+package java.nio.file.attribute;
diff --git a/Ports/CLDC11/src/java/nio/file/package-info.java b/Ports/CLDC11/src/java/nio/file/package-info.java
new file mode 100644
index 00000000000..17825f5ee4f
--- /dev/null
+++ b/Ports/CLDC11/src/java/nio/file/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Paths, and the operations on the files and directories they name, over
+/// the platform's file system as `java.io.File` reaches it.
+///
+/// `Files` reads, writes, copies, moves and walks; `Path` and `Paths` make
+/// and take apart paths. The methods of `Files` that answer a stream of
+/// lines or paths are not provided; `readAllLines`, `newDirectoryStream` and
+/// `walkFileTree` do the same work.
+package java.nio.file;
diff --git a/Ports/CLDC11/src/java/security/GeneralSecurityException.java b/Ports/CLDC11/src/java/security/GeneralSecurityException.java
new file mode 100644
index 00000000000..f5550cbc02a
--- /dev/null
+++ b/Ports/CLDC11/src/java/security/GeneralSecurityException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+/// `java.security.GeneralSecurityException`.
+public class GeneralSecurityException extends Exception {
+
+    public GeneralSecurityException() {
+    }
+
+    public GeneralSecurityException(String message) {
+        super(message);
+    }
+
+    public GeneralSecurityException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public GeneralSecurityException(Throwable cause) {
+        super(cause == null ? null : cause.toString(), cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/security/MessageDigest.java b/Ports/CLDC11/src/java/security/MessageDigest.java
new file mode 100644
index 00000000000..bb1dda4b26d
--- /dev/null
+++ b/Ports/CLDC11/src/java/security/MessageDigest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+import com.codename1.impl.JdkHost;
+
+/// A message digest over the platform's own, which
+/// `com.codename1.impl.JdkHost` reaches: MD5, SHA-1, SHA-224, SHA-256,
+/// SHA-384 and SHA-512 in a Codename One application. Any algorithm the
+/// platform lacks is a `NoSuchAlgorithmException`, as it is on a JDK without
+/// a provider for it.
+///
+/// There are no providers here: `getInstance` with a provider argument,
+/// `getProvider` and a subclass of this class are not offered.
+public final class MessageDigest {
+    private final String algorithm;
+    private final JdkHost.Digest hash;
+
+    private MessageDigest(String algorithm, JdkHost.Digest hash) {
+        this.algorithm = algorithm;
+        this.hash = hash;
+    }
+
+    public static MessageDigest getInstance(String algorithm) throws NoSuchAlgorithmException {
+        if (algorithm == null) {
+            throw new NullPointerException("null algorithm name");
+        }
+        String name = null;
+        if ("MD5".equalsIgnoreCase(algorithm)) {
+            name = "MD5";
+        } else if ("SHA-1".equalsIgnoreCase(algorithm) || "SHA1".equalsIgnoreCase(algorithm)
+                || "SHA".equalsIgnoreCase(algorithm)) {
+            name = "SHA-1";
+        } else if ("SHA-224".equalsIgnoreCase(algorithm) || "SHA224".equalsIgnoreCase(algorithm)) {
+            name = "SHA-224";
+        } else if ("SHA-256".equalsIgnoreCase(algorithm) || "SHA256".equalsIgnoreCase(algorithm)) {
+            name = "SHA-256";
+        } else if ("SHA-384".equalsIgnoreCase(algorithm) || "SHA384".equalsIgnoreCase(algorithm)) {
+            name = "SHA-384";
+        } else if ("SHA-512".equalsIgnoreCase(algorithm) || "SHA512".equalsIgnoreCase(algorithm)) {
+            name = "SHA-512";
+        }
+        JdkHost.Digest digest = name == null ? null : JdkHost.get().digest(name);
+        if (digest == null) {
+            throw new NoSuchAlgorithmException(algorithm + " MessageDigest not available");
+        }
+        return new MessageDigest(algorithm, digest);
+    }
+
+    public void update(byte input) {
+        hash.update(new byte[] {input}, 0, 1);
+    }
+
+    public void update(byte[] input) {
+        hash.update(input, 0, input.length);
+    }
+
+    public void update(byte[] input, int offset, int len) {
+        if (input == null) {
+            throw new IllegalArgumentException("No input buffer given");
+        }
+        if (offset < 0 || len < 0 || input.length - offset < len) {
+            throw new IllegalArgumentException("Input buffer too short");
+        }
+        hash.update(input, offset, len);
+    }
+
+    /// The digest of everything given so far; the next one starts empty.
+    public byte[] digest() {
+        byte[] out = hash.digest();
+        hash.reset();
+        return out;
+    }
+
+    public byte[] digest(byte[] input) {
+        update(input);
+        return digest();
+    }
+
+    public void reset() {
+        hash.reset();
+    }
+
+    public String getAlgorithm() {
+        return algorithm;
+    }
+
+    public int getDigestLength() {
+        return hash.length();
+    }
+
+    /// Whether two digests are the same, in a time that does not depend
+    /// on where they first differ.
+    public static boolean isEqual(byte[] a, byte[] b) {
+        if (a == b) {
+            return true;
+        }
+        if (a == null || b == null) {
+            return false;
+        }
+        if (b.length == 0) {
+            return a.length == 0;
+        }
+        int diff = a.length ^ b.length;
+        for (int i = 0; i < a.length; i++) {
+            diff |= a[i] ^ b[i % b.length];
+        }
+        return diff == 0;
+    }
+
+    @Override
+    public String toString() {
+        return algorithm + " Message Digest from the platform, <in progress>\n";
+    }
+}
diff --git a/Ports/CLDC11/src/java/security/NoSuchAlgorithmException.java b/Ports/CLDC11/src/java/security/NoSuchAlgorithmException.java
new file mode 100644
index 00000000000..ff0379e7a62
--- /dev/null
+++ b/Ports/CLDC11/src/java/security/NoSuchAlgorithmException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+/// `java.security.NoSuchAlgorithmException`.
+public class NoSuchAlgorithmException extends GeneralSecurityException {
+
+    public NoSuchAlgorithmException() {
+    }
+
+    public NoSuchAlgorithmException(String message) {
+        super(message);
+    }
+
+    public NoSuchAlgorithmException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public NoSuchAlgorithmException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/security/SecureRandom.java b/Ports/CLDC11/src/java/security/SecureRandom.java
new file mode 100644
index 00000000000..fbb1e83997b
--- /dev/null
+++ b/Ports/CLDC11/src/java/security/SecureRandom.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.Random;
+
+/// A cryptographically strong random number generator over the platform's
+/// own source of secure random bytes, which `com.codename1.impl.JdkHost`
+/// reaches: the one `com.codename1.security.SecureRandom` reads in a Codename
+/// One application, `/dev/urandom` for a program translated without it.
+///
+/// A seed adds nothing: the platform's generator seeds itself, and
+/// `setSeed` is accepted and ignored rather than made to weaken it.
+public class SecureRandom extends Random {
+    private static final long serialVersionUID = 1L;
+
+    public SecureRandom() {
+        super(0);
+    }
+
+    /// The seed is ignored; see the class description.
+    public SecureRandom(byte[] seed) {
+        super(0);
+    }
+
+    /// The platform's generator, which never blocks.
+    public static SecureRandom getInstanceStrong() {
+        return new SecureRandom();
+    }
+
+    @Override
+    public void setSeed(long seed) {
+        // Ignored: see the class description.
+    }
+
+    /// Ignored: see the class description.
+    public void setSeed(byte[] seed) {
+    }
+
+    public void nextBytes(byte[] bytes) {
+        JdkHost.get().randomBytes(bytes);
+    }
+
+    /// `numBytes` fresh random bytes, where the JDK answers seed material.
+    public byte[] generateSeed(int numBytes) {
+        if (numBytes < 0) {
+            throw new IllegalArgumentException("numBytes cannot be negative");
+        }
+        byte[] out = new byte[numBytes];
+        JdkHost.get().randomBytes(out);
+        return out;
+    }
+
+    @Override
+    protected int next(int bits) {
+        byte[] four = new byte[4];
+        JdkHost.get().randomBytes(four);
+        int value = (four[0] & 0xFF) << 24 | (four[1] & 0xFF) << 16 | (four[2] & 0xFF) << 8 | (four[3] & 0xFF);
+        return bits >= 32 ? value : value >>> (32 - bits);
+    }
+
+    public String getAlgorithm() {
+        return "NativePRNG";
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/ChoiceFormat.java b/Ports/CLDC11/src/java/text/ChoiceFormat.java
new file mode 100644
index 00000000000..f88312cacc5
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/ChoiceFormat.java
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Picks a string by the range a number falls in. It is what the `choice` element of a
+/// [MessageFormat] pattern uses to write plurals.
+///
+/// A pattern is a list of `limit#text` pairs separated by `|`, the limits
+/// ascending: `0#no files|1#one file|1<{0} files`. A number selects the last
+/// pair whose limit it reaches; `#` includes the limit itself and `<` starts
+/// just above it. A number below the first limit selects the first pair. A
+/// single quote makes the characters up to the next one literal, and two in a
+/// row stand for one quote.
+public class ChoiceFormat extends NumberFormat {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final char LESS_OR_EQUAL = (char) 0x2264;
+    private static final String INFINITY = String.valueOf((char) 0x221E);
+
+    private static final long SIGN_BIT = 0x8000000000000000L;
+    private static final long POSITIVE_INFINITY_BITS = 0x7FF0000000000000L;
+
+    private double[] choiceLimits = new double[0];
+    private String[] choiceFormats = new String[0];
+
+    public ChoiceFormat(String newPattern) {
+        parsePattern(newPattern);
+    }
+
+    public ChoiceFormat(double[] limits, String[] formats) {
+        store(limits, formats);
+    }
+
+    public void applyPattern(String newPattern) {
+        parsePattern(newPattern);
+    }
+
+    private void parsePattern(String newPattern) {
+        StringBuilder limitText = new StringBuilder();
+        StringBuilder formatText = new StringBuilder();
+        double[] limits = new double[8];
+        String[] formats = new String[8];
+        int count = 0;
+        boolean inFormat = false;
+        boolean inQuote = false;
+        double startValue = 0;
+        double oldStartValue = Double.NaN;
+        for (int i = 0; i < newPattern.length(); i++) {
+            char ch = newPattern.charAt(i);
+            StringBuilder current = inFormat ? formatText : limitText;
+            if (ch == '\'') {
+                if (i + 1 < newPattern.length() && newPattern.charAt(i + 1) == ch) {
+                    current.append(ch);
+                    i++;
+                } else {
+                    inQuote = !inQuote;
+                }
+            } else if (inQuote) {
+                current.append(ch);
+            } else if (ch == '<' || ch == '#' || ch == LESS_OR_EQUAL) {
+                if (limitText.length() == 0) {
+                    throw new IllegalArgumentException("A choice has no limit: " + newPattern);
+                }
+                startValue = parseLimit(limitText.toString().trim(), newPattern);
+                if (ch == '<' && !Double.isInfinite(startValue)) {
+                    startValue = nextDouble(startValue);
+                }
+                if (startValue <= oldStartValue) {
+                    throw new IllegalArgumentException("Choice limits are not ascending: " + newPattern);
+                }
+                limitText.setLength(0);
+                inFormat = true;
+            } else if (ch == '|') {
+                if (count == limits.length) {
+                    double[] moreLimits = new double[count * 2];
+                    String[] moreFormats = new String[count * 2];
+                    System.arraycopy(limits, 0, moreLimits, 0, count);
+                    System.arraycopy(formats, 0, moreFormats, 0, count);
+                    limits = moreLimits;
+                    formats = moreFormats;
+                }
+                limits[count] = startValue;
+                formats[count] = formatText.toString();
+                count++;
+                oldStartValue = startValue;
+                formatText.setLength(0);
+                inFormat = false;
+            } else {
+                current.append(ch);
+            }
+        }
+        if (inFormat) {
+            if (count == limits.length) {
+                double[] moreLimits = new double[count + 1];
+                String[] moreFormats = new String[count + 1];
+                System.arraycopy(limits, 0, moreLimits, 0, count);
+                System.arraycopy(formats, 0, moreFormats, 0, count);
+                limits = moreLimits;
+                formats = moreFormats;
+            }
+            limits[count] = startValue;
+            formats[count] = formatText.toString();
+            count++;
+        }
+        choiceLimits = new double[count];
+        System.arraycopy(limits, 0, choiceLimits, 0, count);
+        choiceFormats = new String[count];
+        System.arraycopy(formats, 0, choiceFormats, 0, count);
+    }
+
+    private static double parseLimit(String text, String pattern) {
+        if (text.equals(INFINITY)) {
+            return Double.POSITIVE_INFINITY;
+        }
+        if (text.equals("-" + INFINITY)) {
+            return Double.NEGATIVE_INFINITY;
+        }
+        try {
+            return Double.parseDouble(text);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("A choice limit is not a number: " + pattern);
+        }
+    }
+
+    private static double distanceToInteger(double value) {
+        return Math.abs(value - Math.floor(value + 0.5));
+    }
+
+    public String toPattern() {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < choiceLimits.length; i++) {
+            if (i != 0) {
+                result.append('|');
+            }
+            // Either "limit#" or "justBelow<" says the same thing; the one
+            // that is closer to a whole number is the one that was written.
+            double limit = choiceLimits[i];
+            double less = previousDouble(limit);
+            if (distanceToInteger(limit) < distanceToInteger(less)) {
+                appendLimit(result, limit);
+                result.append('#');
+            } else {
+                appendLimit(result, less);
+                result.append('<');
+            }
+            String text = choiceFormats[i];
+            boolean needQuote = text.indexOf('<') >= 0 || text.indexOf('#') >= 0
+                    || text.indexOf(LESS_OR_EQUAL) >= 0 || text.indexOf('|') >= 0;
+            if (needQuote) {
+                result.append('\'');
+            }
+            for (int k = 0; k < text.length(); k++) {
+                char c = text.charAt(k);
+                result.append(c);
+                if (c == '\'') {
+                    result.append(c);
+                }
+            }
+            if (needQuote) {
+                result.append('\'');
+            }
+        }
+        return result.toString();
+    }
+
+    private static void appendLimit(StringBuilder out, double limit) {
+        if (limit == Double.POSITIVE_INFINITY) {
+            out.append(INFINITY);
+        } else if (limit == Double.NEGATIVE_INFINITY) {
+            out.append('-').append(INFINITY);
+        } else {
+            out.append(Double.toString(limit));
+        }
+    }
+
+    public void setChoices(double[] limits, String[] formats) {
+        store(limits, formats);
+    }
+
+    private void store(double[] limits, String[] formats) {
+        if (limits.length != formats.length) {
+            throw new IllegalArgumentException("Array and limit arrays must be of the same length.");
+        }
+        choiceLimits = limits.clone();
+        choiceFormats = formats.clone();
+    }
+
+    public double[] getLimits() {
+        return choiceLimits.clone();
+    }
+
+    public Object[] getFormats() {
+        return choiceFormats.clone();
+    }
+
+    @Override
+    public StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition status) {
+        return format((double) number, toAppendTo, status);
+    }
+
+    @Override
+    public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition status) {
+        if (choiceFormats.length == 0) {
+            return toAppendTo;
+        }
+        int i = 0;
+        // Written so that not-a-number, which is below nothing, selects the
+        // first choice.
+        while (i < choiceLimits.length && number >= choiceLimits[i]) {
+            i++;
+        }
+        i--;
+        if (i < 0) {
+            i = 0;
+        }
+        return toAppendTo.append(choiceFormats[i]);
+    }
+
+    /// Finds the choice whose text starts at the position, the longest if
+    /// several do, and answers its limit as a `Double`. When none does, the
+    /// error index is set and the answer is not-a-number.
+    @Override
+    public Number parse(String text, ParsePosition status) {
+        int start = status.getIndex();
+        int furthest = start;
+        double bestNumber = Double.NaN;
+        for (int i = 0; i < choiceFormats.length; i++) {
+            String candidate = choiceFormats[i];
+            if (text.regionMatches(start, candidate, 0, candidate.length())) {
+                int end = start + candidate.length();
+                if (end > furthest) {
+                    furthest = end;
+                    bestNumber = choiceLimits[i];
+                    if (furthest == text.length()) {
+                        break;
+                    }
+                }
+            }
+        }
+        status.setIndex(furthest);
+        if (furthest == start) {
+            status.setErrorIndex(furthest);
+        }
+        return Double.valueOf(bestNumber);
+    }
+
+    public static final double nextDouble(double d) {
+        return nextDouble(d, true);
+    }
+
+    public static final double previousDouble(double d) {
+        return nextDouble(d, false);
+    }
+
+    /// The `double` next to `d`: the next greater when `positive`, else the
+    /// next smaller.
+    public static double nextDouble(double d, boolean positive) {
+        if (Double.isNaN(d)) {
+            return d;
+        }
+        if (d == 0.0) {
+            double smallest = Double.longBitsToDouble(1L);
+            return positive ? smallest : -smallest;
+        }
+        long bits = Double.doubleToLongBits(d);
+        long magnitude = bits & ~SIGN_BIT;
+        if ((bits > 0) == positive) {
+            if (magnitude != POSITIVE_INFINITY_BITS) {
+                magnitude += 1;
+            }
+        } else {
+            magnitude -= 1;
+        }
+        return Double.longBitsToDouble(magnitude | (bits & SIGN_BIT));
+    }
+
+    /// A copy of this format, built from copies of its arrays:
+    /// `Object.clone()` answers `null` on the device for anything but an
+    /// array.
+    @Override
+    public Object clone() {
+        ChoiceFormat copy = new ChoiceFormat(choiceLimits, choiceFormats);
+        copyNumberFormatTo(copy);
+        return copy;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = choiceLimits.length;
+        if (choiceFormats.length > 0) {
+            result ^= choiceFormats[choiceFormats.length - 1].hashCode();
+        }
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ChoiceFormat) || getClass() != obj.getClass()) {
+            return false;
+        }
+        ChoiceFormat other = (ChoiceFormat) obj;
+        if (choiceLimits.length != other.choiceLimits.length) {
+            return false;
+        }
+        for (int i = 0; i < choiceLimits.length; i++) {
+            if (Double.doubleToLongBits(choiceLimits[i]) != Double.doubleToLongBits(other.choiceLimits[i])
+                    || !choiceFormats[i].equals(other.choiceFormats[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/DateFormat.java b/Ports/CLDC11/src/java/text/DateFormat.java
index a67682db9f9..2ba03ff4789 100644
--- a/Ports/CLDC11/src/java/text/DateFormat.java
+++ b/Ports/CLDC11/src/java/text/DateFormat.java
@@ -64,20 +64,49 @@ public class DateFormat extends Format {
 	}
 
 
-	/// Format a given object.
+	/// Format a given object, a date or a number of milliseconds since the epoch.
+	///
+	/// #### Parameters
 	///
-	/// Parameter `obj`: object to be formatted.
+	/// - `obj`: object to be formatted.
+	///
+	/// - `toAppendTo`: buffer to which to append output.
+	///
+	/// - `fieldPosition`: not updated: no field is reported.
 	///
 	/// #### Returns
 	///
-	/// formatted object.
+	/// `toAppendTo`.
 	///
 	/// #### Throws
 	///
-	/// - `IllegalArgumentException`: of the source can not be formatted.
+	/// - `IllegalArgumentException`: if the source is neither a date nor a number.
 	@Override
-	public String format(Object obj) throws IllegalArgumentException {
-		return format(obj, new StringBuffer());
+	public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition fieldPosition) {
+		if (obj instanceof Date) {
+			return format((Date) obj, toAppendTo, fieldPosition);
+		}
+		if (obj instanceof Number) {
+			return format(new Date(((Number) obj).longValue()), toAppendTo, fieldPosition);
+		}
+		throw new IllegalArgumentException("Cannot format given Object as a Date");
+	}
+
+	/// Format a given date.
+	///
+	/// #### Parameters
+	///
+	/// - `date`: date to be formatted.
+	///
+	/// - `toAppendTo`: buffer to which to append output.
+	///
+	/// - `fieldPosition`: not updated: no field is reported.
+	///
+	/// #### Returns
+	///
+	/// `toAppendTo`.
+	public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition) {
+		return toAppendTo.append(format(date));
 	}
 
 	/// Format a given object.
@@ -127,16 +156,44 @@ String format(Date source, StringBuffer toAppendTo) {
 		return null;
 	}
 
-	/// NOT IMPLEMENTED - use SimpleDateFormat for parsing instead.
+	/// Parse a date from the beginning of the source. NOT IMPLEMENTED for the
+	/// style based formats - use SimpleDateFormat for parsing instead.
 	@Override
 	public Object parseObject(String source) throws ParseException {
-		// can't parse because we don't know the L10NManagers templates
-		throw new ParseException("Not implemented", 0);
+		return parse(source);
 	}
 
-	/// NOT IMPLEMENTED - use SimpleDateFormat for parsing instead.
+	/// Parse a date from the beginning of the source. NOT IMPLEMENTED for the
+	/// style based formats - use SimpleDateFormat for parsing instead.
 	public Date parse(String source) throws ParseException {
-		return (Date) parseObject(source);
+		return parseAt(source, 0, null);
+	}
+
+	/// Parse a date starting at a position. On success the index of the
+	/// position is moved past the date; on failure it is left alone, its
+	/// error index is set and null is returned.
+	public Date parse(String source, ParsePosition pos) {
+		int[] end = new int[1];
+		try {
+			Date result = parseAt(source, pos.getIndex(), end);
+			pos.setIndex(end[0]);
+			return result;
+		} catch (ParseException e) {
+			pos.setErrorIndex(e.getErrorOffset());
+			return null;
+		}
+	}
+
+	@Override
+	public Object parseObject(String source, ParsePosition pos) {
+		return parse(source, pos);
+	}
+
+	/// Parse a date at index start of source and, when end is not null, store
+	/// in end[0] the index just past it.
+	Date parseAt(String source, int start, int[] end) throws ParseException {
+		// can't parse because we don't know the L10NManagers templates
+		throw new ParseException("Not implemented", start);
 	}
 
 	/// Get a DateFormat instance with default style for date/time (SHORT/SHORT).
diff --git a/Ports/CLDC11/src/java/text/DecimalFormat.java b/Ports/CLDC11/src/java/text/DecimalFormat.java
new file mode 100644
index 00000000000..84c1769b1ce
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/DecimalFormat.java
@@ -0,0 +1,1463 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Formats and parses decimal numbers according to a pattern.
+///
+/// #### Pattern syntax
+///
+/// A pattern is a positive subpattern, optionally followed by `;` and a
+/// negative subpattern of which only the prefix and suffix are used. Each
+/// subpattern is a prefix, a number and a suffix. In the number:
+///
+/// - `0` is a digit that is always written, `#` a digit written only when
+///   it is significant.
+/// - `.` is the decimal separator and `,` the grouping separator; the
+///   distance from the last `,` to the end of the integer part is the group
+///   size.
+/// - `E` followed by one or more `0` selects scientific notation, with at
+///   least that many exponent digits. With more integer digit positions than
+///   `0`s among them (`##0.###E0`), the exponent is kept a multiple of the
+///   number of integer positions.
+///
+/// In a prefix or suffix, `%` multiplies the number by 100 and writes a
+/// percent sign, the per mille sign multiplies by 1000, the currency sign
+/// writes the currency symbol (doubled, the international currency code), and
+/// `-` writes the minus sign. A single quote makes the characters up to the
+/// next one literal, and two in a row stand for one quote.
+///
+/// The characters actually written -- separators, minus, percent, currency
+/// -- come from the format's [DecimalFormatSymbols].
+///
+/// #### Rounding
+///
+/// Rounding is half-even, the JDK default, and like the JDK it is decided by
+/// the exact binary value of a `double`: `0.125` is a true tie and formats as
+/// `0.12` under `0.00`, while `0.15`, which as a `double` lies just below the
+/// decimal `0.15`, formats as `0.1` under `0.0`.
+///
+/// The JDK departs from half-even in two places, and so does this class,
+/// because a last digit that differs from the desktop's is worse than either
+/// answer: a whole number rounds a tie up in scientific notation (`12345`
+/// under `0.###E0` is `1.235E4`), and `5E-4`, `5E-5` and so on round down
+/// when the 5 is the first digit dropped (`0.0005` under `0.000` is `0.000`).
+///
+/// #### Differences from the JDK
+///
+/// - No `setRoundingMode`, `setCurrency`, `setParseBigDecimal` or
+///   `formatToCharacterIterator`: the device has none of the types they name.
+/// - No localized patterns (`applyLocalizedPattern`, `toLocalizedPattern`).
+public class DecimalFormat extends NumberFormat {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The currency sign of a pattern. Not written as a character literal:
+    /// the sources are ASCII.
+    static final char CURRENCY_SIGN = (char) 0xA4;
+
+    private static final char PER_MILLE_SIGN = (char) 0x2030;
+    private static final char QUOTE = '\'';
+
+    /// A `double` has no more integer digits than this, nor fraction digits
+    /// than the next; the JDK caps the settings there for a `double` as well.
+    private static final int DOUBLE_INTEGER_DIGITS = 309;
+    private static final int DOUBLE_FRACTION_DIGITS = 340;
+
+    private DecimalFormatSymbols symbols;
+
+    // The affixes as the pattern gave them, in an internal form where a quote
+    // precedes each character to be replaced by a symbol and '' is a quote.
+    private String posPrefixPattern = "";
+    private String posSuffixPattern = "";
+    private String negPrefixPattern = "'-";
+    private String negSuffixPattern = "";
+
+    // The same affixes with the symbols filled in.
+    private String positivePrefix = "";
+    private String positiveSuffix = "";
+    private String negativePrefix = "-";
+    private String negativeSuffix = "";
+
+    private int multiplier = 1;
+    private int groupingSize = 3;
+    private boolean decimalSeparatorAlwaysShown;
+    private boolean useExponentialNotation;
+    private int minExponentDigits;
+    private boolean currencyFormat;
+
+    public DecimalFormat() {
+        this("#,##0.###", DecimalFormatSymbols.getInstance());
+    }
+
+    public DecimalFormat(String pattern) {
+        this(pattern, DecimalFormatSymbols.getInstance());
+    }
+
+    public DecimalFormat(String pattern, DecimalFormatSymbols symbols) {
+        if (symbols == null) {
+            throw new NullPointerException();
+        }
+        Object copy = symbols.clone();
+        this.symbols = copy instanceof DecimalFormatSymbols ? (DecimalFormatSymbols) copy : symbols;
+        parsePattern(pattern);
+    }
+
+    // ------------------------------------------------------------------
+    // Digits
+    // ------------------------------------------------------------------
+
+    /// A non-negative decimal number: `count` significant digits, with the
+    /// decimal point `decimalAt` digits from the left (so the value is
+    /// 0.d1d2... times ten to the `decimalAt`). No trailing zeros; zero is no
+    /// digits at all.
+    private static final class Digits {
+        /// The digits are the number: a tie goes to the even neighbour.
+        static final int TIE_EVEN = 0;
+        /// The digits are the shortest text of a `double`: a tie is settled
+        /// by where the `double` really lies, and is even only if it lies
+        /// exactly there.
+        static final int TIE_BY_VALUE = 1;
+        static final int TIE_UP = 2;
+        static final int TIE_DOWN = 3;
+
+        private char[] d = new char[24];
+        private int count;
+        private int decimalAt;
+
+        private void append(char c) {
+            if (count == d.length) {
+                char[] bigger = new char[d.length * 2];
+                System.arraycopy(d, 0, bigger, 0, count);
+                d = bigger;
+            }
+            d[count++] = c;
+        }
+
+        private void trim() {
+            while (count > 0 && d[count - 1] == '0') {
+                count--;
+            }
+            if (count == 0) {
+                decimalAt = 0;
+            }
+        }
+
+        /// Takes plain decimal digits, an integer.
+        void setInteger(String digits) {
+            count = 0;
+            int i = 0;
+            while (i < digits.length() && digits.charAt(i) == '0') {
+                i++;
+            }
+            decimalAt = digits.length() - i;
+            for (; i < digits.length(); i++) {
+                append(digits.charAt(i));
+            }
+            trim();
+        }
+
+        /// Takes the digits of a finite, non-negative `double` as the JDK's
+        /// `DecimalFormat` sees them. Those are NOT the shortest digits
+        /// `Double.toString` writes (`1.0E23` is `9.999999999999999E22`
+        /// here); see `LegacyDoubleDigits` for why.
+        void setDouble(double value) {
+            count = 0;
+            decimalAt = 0;
+            // Zero has no digits. So does NaN, which reaches here from an
+            // infinity times a multiplier of zero.
+            if (!(value > 0.0)) {
+                return;
+            }
+            LegacyDoubleDigits converted = new LegacyDoubleDigits(value);
+            for (int i = 0; i < converted.count; i++) {
+                append(converted.digits[converted.first + i]);
+            }
+            decimalAt = converted.decExponent;
+            trim();
+        }
+
+        /// Multiplies by a positive integer.
+        void multiply(int by) {
+            if (count == 0) {
+                return;
+            }
+            char[] out = new char[count + 11];
+            int at = out.length;
+            long carry = 0;
+            for (int i = count - 1; i >= 0; i--) {
+                long v = (long) (d[i] - '0') * by + carry;
+                out[--at] = (char) ('0' + (int) (v % 10));
+                carry = v / 10;
+            }
+            while (carry > 0) {
+                out[--at] = (char) ('0' + (int) (carry % 10));
+                carry = carry / 10;
+            }
+            int produced = out.length - at;
+            decimalAt += produced - count;
+            count = 0;
+            for (int i = at; i < out.length; i++) {
+                append(out[i]);
+            }
+            trim();
+        }
+
+        /// Keeps the first `keep` digits, rounding half-even. `tie` says how
+        /// digits that end in exactly a half are settled; `value` is the
+        /// `double` they were taken from, for [#TIE_BY_VALUE].
+        void round(int keep, int tie, double value) {
+            if (keep >= count) {
+                return;
+            }
+            if (keep < 0) {
+                count = 0;
+                decimalAt = 0;
+                return;
+            }
+            if (roundsUp(keep, tie, value)) {
+                int i = keep - 1;
+                while (i >= 0 && d[i] == '9') {
+                    i--;
+                }
+                if (i < 0) {
+                    d[0] = '1';
+                    count = 1;
+                    decimalAt++;
+                } else {
+                    d[i]++;
+                    count = i + 1;
+                }
+            } else {
+                count = keep;
+            }
+            trim();
+        }
+
+        private boolean roundsUp(int keep, int tie, double value) {
+            char next = d[keep];
+            if (next != '5') {
+                return next > '5';
+            }
+            if (keep + 1 < count) {
+                // Past the 5 there is something, and it is not zero.
+                return true;
+            }
+            // The digits end in exactly a half.
+            if (tie == TIE_UP) {
+                return true;
+            }
+            if (tie == TIE_DOWN) {
+                return false;
+            }
+            // A long is those digits. A double is only the nearest double to
+            // them, so the true value is compared against the half it
+            // appears to be.
+            int side = tie == TIE_EVEN ? 0 : compareToDigits(value);
+            if (side != 0) {
+                return side > 0;
+            }
+            return keep > 0 && ((d[keep - 1] - '0') & 1) == 1;
+        }
+
+        /// The sign of `value` minus the number these digits spell.
+        private int compareToDigits(double value) {
+            long bits = Double.doubleToLongBits(value);
+            int rawExponent = (int) ((bits >> 52) & 0x7ffL);
+            long mantissa = bits & 0xfffffffffffffL;
+            int binaryExponent;
+            if (rawExponent == 0) {
+                binaryExponent = -1074;
+            } else {
+                mantissa |= 1L << 52;
+                binaryExponent = rawExponent - 1075;
+            }
+            // value = mantissa * 2^binaryExponent, digits = n * 10^decimalExponent.
+            // Negative powers move to the other side, leaving integers.
+            Magnitude left = Magnitude.ofLong(mantissa);
+            Magnitude right = Magnitude.ofDigits(d, count);
+            int decimalExponent = decimalAt - count;
+            if (binaryExponent > 0) {
+                left.shiftLeft(binaryExponent);
+            } else if (binaryExponent < 0) {
+                right.shiftLeft(-binaryExponent);
+            }
+            if (decimalExponent > 0) {
+                right.multiplyByPowerOfTen(decimalExponent);
+            } else if (decimalExponent < 0) {
+                left.multiplyByPowerOfTen(-decimalExponent);
+            }
+            return left.compareTo(right);
+        }
+    }
+
+    /// A non-negative integer of any size, just enough of one to compare a
+    /// `double` with the decimal digits it was written as: the device has no
+    /// `java.math`. Little-endian limbs in base one billion, so a limb times
+    /// any factor up to two to the 30th plus a carry fits a `long`.
+    private static final class Magnitude {
+        private static final int BASE = 1000000000;
+        private static final int SHIFT_STEP = 30;
+
+        private int[] limbs = new int[4];
+        private int length;
+
+        static Magnitude ofLong(long value) {
+            Magnitude m = new Magnitude();
+            long v = value;
+            while (v > 0) {
+                m.push((int) (v % BASE));
+                v = v / BASE;
+            }
+            return m;
+        }
+
+        /// The integer the first `count` ASCII digits of `digits` spell.
+        static Magnitude ofDigits(char[] digits, int count) {
+            Magnitude m = new Magnitude();
+            int end = count;
+            while (end > 0) {
+                int start = Math.max(0, end - 9);
+                int limb = 0;
+                for (int i = start; i < end; i++) {
+                    limb = limb * 10 + (digits[i] - '0');
+                }
+                m.push(limb);
+                end = start;
+            }
+            m.normalize();
+            return m;
+        }
+
+        private void push(int limb) {
+            if (length == limbs.length) {
+                int[] bigger = new int[limbs.length * 2];
+                System.arraycopy(limbs, 0, bigger, 0, length);
+                limbs = bigger;
+            }
+            limbs[length++] = limb;
+        }
+
+        private void normalize() {
+            while (length > 0 && limbs[length - 1] == 0) {
+                length--;
+            }
+        }
+
+        /// Multiplies by a factor from 1 to two to the 30th.
+        private void multiplySmall(int factor) {
+            long carry = 0;
+            for (int i = 0; i < length; i++) {
+                long v = (long) limbs[i] * factor + carry;
+                limbs[i] = (int) (v % BASE);
+                carry = v / BASE;
+            }
+            while (carry > 0) {
+                push((int) (carry % BASE));
+                carry = carry / BASE;
+            }
+        }
+
+        void shiftLeft(int bits) {
+            int left = bits;
+            while (left >= SHIFT_STEP) {
+                multiplySmall(1 << SHIFT_STEP);
+                left -= SHIFT_STEP;
+            }
+            if (left > 0) {
+                multiplySmall(1 << left);
+            }
+        }
+
+        void multiplyByPowerOfTen(int exponent) {
+            int left = exponent;
+            while (left >= 9) {
+                multiplySmall(BASE);
+                left -= 9;
+            }
+            int factor = 1;
+            for (int i = 0; i < left; i++) {
+                factor *= 10;
+            }
+            if (factor > 1) {
+                multiplySmall(factor);
+            }
+        }
+
+        int compareTo(Magnitude other) {
+            if (length != other.length) {
+                return length < other.length ? -1 : 1;
+            }
+            for (int i = length - 1; i >= 0; i--) {
+                if (limbs[i] != other.limbs[i]) {
+                    return limbs[i] < other.limbs[i] ? -1 : 1;
+                }
+            }
+            return 0;
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Formatting
+    // ------------------------------------------------------------------
+
+    @Override
+    public StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition) {
+        fieldPosition.setBeginIndex(0);
+        fieldPosition.setEndIndex(0);
+        if (Double.isNaN(number)) {
+            int begin = result.length();
+            result.append(symbols.getNaN());
+            if (fieldPosition.getField() == INTEGER_FIELD) {
+                fieldPosition.setBeginIndex(begin);
+                fieldPosition.setEndIndex(result.length());
+            }
+            return result;
+        }
+        // The sign bit, so that negative zero is negative.
+        boolean negative = (Double.doubleToLongBits(number) < 0) ^ (multiplier < 0);
+        double value = number;
+        if (multiplier != 1) {
+            value = value * multiplier;
+        }
+        if (Double.isInfinite(value)) {
+            result.append(negative ? negativePrefix : positivePrefix);
+            int begin = result.length();
+            result.append(symbols.getInfinity());
+            if (fieldPosition.getField() == INTEGER_FIELD) {
+                fieldPosition.setBeginIndex(begin);
+                fieldPosition.setEndIndex(result.length());
+            }
+            result.append(negative ? negativeSuffix : positiveSuffix);
+            return result;
+        }
+        value = Math.abs(value);
+        int maxInt = Math.min(getMaximumIntegerDigits(), DOUBLE_INTEGER_DIGITS);
+        int minInt = Math.min(getMinimumIntegerDigits(), DOUBLE_INTEGER_DIGITS);
+        int maxFrac = Math.min(getMaximumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        int minFrac = Math.min(getMinimumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        Digits digits = new Digits();
+        digits.setDouble(value);
+        // Two places where the JDK does not round half-even, kept because
+        // output that differs from the desktop's in the last digit is worse
+        // than either answer. A whole number below two to the 63rd rounds a
+        // tie up (12345 under 0.###E0 is 1.235E4), and 5E-4, 5E-5, ... round
+        // down when the 5 is the first digit dropped (0.0005 under 0.000 is
+        // 0.000, though 0.005 under 0.00 is 0.01).
+        int tie = Digits.TIE_BY_VALUE;
+        if (value < 9.2E18 && (double) (long) value == value) {
+            tie = Digits.TIE_UP;
+        }
+        if (useExponentialNotation) {
+            digits.round(maxInt + maxFrac, tie, value);
+        } else {
+            int keep = digits.decimalAt + maxFrac;
+            if (keep == 0 && value < 1.0E-3 && !isCommonShape(maxInt, minInt, maxFrac, minFrac)) {
+                tie = Digits.TIE_DOWN;
+            }
+            digits.round(keep, tie, value);
+        }
+        return subformat(result, fieldPosition, digits, negative, false, maxInt, minInt, maxFrac, minFrac);
+    }
+
+    /// The shapes the JDK formats by a separate, exact route -- the default
+    /// number and currency patterns -- where neither exception applies.
+    private boolean isCommonShape(int maxInt, int minInt, int maxFrac, int minFrac) {
+        if (!isGroupingUsed() || groupingSize != 3 || multiplier != 1 || decimalSeparatorAlwaysShown
+                || minInt != 1 || maxInt < 10) {
+            return false;
+        }
+        return currencyFormat ? minFrac == 2 && maxFrac == 2 : minFrac == 0 && maxFrac == 3;
+    }
+
+    @Override
+    public StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition) {
+        fieldPosition.setBeginIndex(0);
+        fieldPosition.setEndIndex(0);
+        boolean negative = number < 0;
+        String text = Long.toString(number);
+        Digits digits = new Digits();
+        digits.setInteger(negative ? text.substring(1) : text);
+        if (multiplier != 1) {
+            if (multiplier == 0) {
+                digits.setInteger("0");
+            } else if (multiplier < 0) {
+                negative = !negative;
+                if (multiplier == Integer.MIN_VALUE) {
+                    digits.multiply(1 << 30);
+                    digits.multiply(2);
+                } else {
+                    digits.multiply(-multiplier);
+                }
+            } else {
+                digits.multiply(multiplier);
+            }
+        }
+        int maxInt = getMaximumIntegerDigits();
+        int minInt = getMinimumIntegerDigits();
+        int maxFrac = getMaximumFractionDigits();
+        int minFrac = getMinimumFractionDigits();
+        if (useExponentialNotation) {
+            int significant = maxInt + maxFrac;
+            if (significant > 0) {
+                digits.round(significant, Digits.TIE_EVEN, 0);
+            }
+        }
+        if (digits.count == 0) {
+            // An integer zero has no sign.
+            negative = false;
+        }
+        return subformat(result, fieldPosition, digits, negative, true, maxInt, minInt, maxFrac, minFrac);
+    }
+
+    private char digitChar(char asciiDigit) {
+        return (char) (asciiDigit - '0' + symbols.getZeroDigit());
+    }
+
+    private StringBuffer subformat(StringBuffer result, FieldPosition fieldPosition, Digits digits,
+                                   boolean negative, boolean isInteger,
+                                   int maxInt, int minInt, int maxFrac, int minFrac) {
+        char zero = symbols.getZeroDigit();
+        char decimal = currencyFormat ? symbols.getMonetaryDecimalSeparator() : symbols.getDecimalSeparator();
+        result.append(negative ? negativePrefix : positivePrefix);
+        int integerBegin = result.length();
+        int integerEnd = -1;
+        int fractionBegin = -1;
+        if (useExponentialNotation) {
+            // The exponent is what leaves the wanted number of integer
+            // digits; with more integer positions than required digits it is
+            // also kept a multiple of the number of positions.
+            int exponent = digits.decimalAt;
+            int repeat = maxInt;
+            int minimumIntegerDigits = minInt;
+            if (repeat > 1 && repeat > minInt) {
+                if (exponent >= 1) {
+                    exponent = ((exponent - 1) / repeat) * repeat;
+                } else {
+                    exponent = ((exponent - repeat) / repeat) * repeat;
+                }
+                minimumIntegerDigits = 1;
+            } else {
+                exponent -= minimumIntegerDigits;
+            }
+            int minimumDigits = minInt + minFrac;
+            if (minimumDigits < 0) {
+                minimumDigits = Integer.MAX_VALUE;
+            }
+            int integerDigits = digits.count == 0 ? minimumIntegerDigits : digits.decimalAt - exponent;
+            if (minimumDigits < integerDigits) {
+                minimumDigits = integerDigits;
+            }
+            int totalDigits = Math.max(digits.count, minimumDigits);
+            boolean wroteDecimal = false;
+            for (int i = 0; i < totalDigits; i++) {
+                if (i == integerDigits) {
+                    integerEnd = result.length();
+                    result.append(decimal);
+                    wroteDecimal = true;
+                    fractionBegin = result.length();
+                }
+                result.append(i < digits.count ? digitChar(digits.d[i]) : zero);
+            }
+            if (decimalSeparatorAlwaysShown && totalDigits == integerDigits) {
+                integerEnd = result.length();
+                result.append(decimal);
+                wroteDecimal = true;
+                fractionBegin = result.length();
+            }
+            if (integerEnd < 0) {
+                integerEnd = result.length();
+            }
+            if (!wroteDecimal) {
+                fractionBegin = result.length();
+            }
+            int fractionEnd = result.length();
+            result.append(symbols.getExponentSeparator());
+            if (digits.count == 0) {
+                exponent = 0;
+            }
+            if (exponent < 0) {
+                exponent = -exponent;
+                result.append(symbols.getMinusSign());
+            }
+            String exponentText = Integer.toString(exponent);
+            for (int i = exponentText.length(); i < minExponentDigits; i++) {
+                result.append(zero);
+            }
+            for (int i = 0; i < exponentText.length(); i++) {
+                result.append(digitChar(exponentText.charAt(i)));
+            }
+            setField(fieldPosition, integerBegin, integerEnd, fractionBegin, fractionEnd);
+        } else {
+            int count = minInt;
+            int digitIndex = 0;
+            if (digits.decimalAt > 0 && count < digits.decimalAt) {
+                count = digits.decimalAt;
+            }
+            // With fewer integer digits allowed than the number has, the
+            // least significant ones are the ones written: 1997 under a
+            // maximum of two is "97".
+            if (count > maxInt) {
+                count = maxInt;
+                digitIndex = digits.decimalAt - count;
+            }
+            boolean grouping = isGroupingUsed() && groupingSize > 0;
+            for (int i = count - 1; i >= 0; i--) {
+                if (i < digits.decimalAt && digitIndex < digits.count) {
+                    result.append(digitChar(digits.d[digitIndex++]));
+                } else {
+                    result.append(zero);
+                }
+                // groupingSize is checked positive just above.
+                if (grouping && i > 0 && i % groupingSize == 0) {
+                    result.append(symbols.getGroupingSeparator());
+                }
+            }
+            boolean fractionPresent = minFrac > 0 || (!isInteger && digitIndex < digits.count);
+            if (!fractionPresent && result.length() == integerBegin) {
+                result.append(zero);
+            }
+            integerEnd = result.length();
+            if (decimalSeparatorAlwaysShown || fractionPresent) {
+                result.append(decimal);
+            }
+            fractionBegin = result.length();
+            for (int i = 0; i < maxFrac; i++) {
+                if (i >= minFrac && (isInteger || digitIndex >= digits.count)) {
+                    break;
+                }
+                // Zeros between the decimal point and the first digit.
+                if (-1 - i > digits.decimalAt - 1) {
+                    result.append(zero);
+                    continue;
+                }
+                if (!isInteger && digitIndex < digits.count) {
+                    result.append(digitChar(digits.d[digitIndex++]));
+                } else {
+                    result.append(zero);
+                }
+            }
+            setField(fieldPosition, integerBegin, integerEnd, fractionBegin, result.length());
+        }
+        result.append(negative ? negativeSuffix : positiveSuffix);
+        return result;
+    }
+
+    private static void setField(FieldPosition fieldPosition, int integerBegin, int integerEnd,
+                                 int fractionBegin, int fractionEnd) {
+        if (fieldPosition.getField() == INTEGER_FIELD) {
+            fieldPosition.setBeginIndex(integerBegin);
+            fieldPosition.setEndIndex(integerEnd);
+        } else if (fieldPosition.getField() == FRACTION_FIELD) {
+            fieldPosition.setBeginIndex(fractionBegin);
+            fieldPosition.setEndIndex(fractionEnd);
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Parsing
+    // ------------------------------------------------------------------
+
+    private int digitValue(char c) {
+        int v = c - symbols.getZeroDigit();
+        if (v >= 0 && v <= 9) {
+            return v;
+        }
+        v = c - '0';
+        return v >= 0 && v <= 9 ? v : -1;
+    }
+
+    private static boolean matches(String text, int at, String part) {
+        return text.regionMatches(at, part, 0, part.length());
+    }
+
+    @Override
+    public Number parse(String text, ParsePosition pos) {
+        int start = pos.getIndex();
+        int position = start;
+        String nan = symbols.getNaN();
+        if (nan.length() > 0 && matches(text, position, nan)) {
+            pos.setIndex(position + nan.length());
+            return Double.valueOf(Double.NaN);
+        }
+        boolean gotPositive = matches(text, position, positivePrefix);
+        boolean gotNegative = matches(text, position, negativePrefix);
+        if (gotPositive && gotNegative) {
+            if (positivePrefix.length() > negativePrefix.length()) {
+                gotNegative = false;
+            } else if (positivePrefix.length() < negativePrefix.length()) {
+                gotPositive = false;
+            }
+        }
+        if (gotPositive) {
+            position += positivePrefix.length();
+        } else if (gotNegative) {
+            position += negativePrefix.length();
+        } else {
+            pos.setErrorIndex(position);
+            return null;
+        }
+
+        boolean infinite = false;
+        StringBuilder digits = new StringBuilder();
+        int decimalAt = 0;
+        String infinity = symbols.getInfinity();
+        if (infinity.length() > 0 && matches(text, position, infinity)) {
+            position += infinity.length();
+            infinite = true;
+        } else {
+            char decimal = currencyFormat ? symbols.getMonetaryDecimalSeparator() : symbols.getDecimalSeparator();
+            char grouping = symbols.getGroupingSeparator();
+            String exponentText = symbols.getExponentSeparator();
+            boolean sawDecimal = false;
+            boolean sawDigit = false;
+            int exponent = 0;
+            int digitCount = 0;
+            int backup = -1;
+            for (; position < text.length(); position++) {
+                char ch = text.charAt(position);
+                int digit = digitValue(ch);
+                if (digit >= 0) {
+                    backup = -1;
+                    sawDigit = true;
+                    if (digit == 0 && digits.length() == 0) {
+                        // Leading zeros carry no digits, but after the
+                        // decimal point they shift it.
+                        if (sawDecimal) {
+                            decimalAt--;
+                        }
+                    } else {
+                        digitCount++;
+                        digits.append((char) ('0' + digit));
+                    }
+                } else if (ch == decimal) {
+                    if (isParseIntegerOnly() || sawDecimal) {
+                        break;
+                    }
+                    decimalAt = digitCount;
+                    sawDecimal = true;
+                } else if (ch == grouping && isGroupingUsed()) {
+                    if (sawDecimal) {
+                        break;
+                    }
+                    // A grouping separator must be followed by a digit; if
+                    // it is not, the number ended before it.
+                    backup = position;
+                } else if (exponentText.length() > 0 && matches(text, position, exponentText)) {
+                    int at = position + exponentText.length();
+                    boolean negativeExponent = false;
+                    if (at < text.length() && text.charAt(at) == symbols.getMinusSign()) {
+                        negativeExponent = true;
+                        at++;
+                    }
+                    int exponentStart = at;
+                    long parsed = 0;
+                    while (at < text.length() && digitValue(text.charAt(at)) >= 0) {
+                        if (parsed < 100000000L) {
+                            parsed = parsed * 10 + digitValue(text.charAt(at));
+                        }
+                        at++;
+                    }
+                    if (at > exponentStart) {
+                        exponent = (int) (negativeExponent ? -parsed : parsed);
+                        position = at;
+                    }
+                    break;
+                } else {
+                    break;
+                }
+            }
+            if (backup != -1) {
+                position = backup;
+            }
+            if (!sawDecimal) {
+                decimalAt = digitCount;
+            }
+            decimalAt += exponent;
+            if (!sawDigit) {
+                // As in the JDK, a prefix with no number after it is reported
+                // at the start of the prefix.
+                pos.setErrorIndex(start);
+                return null;
+            }
+        }
+
+        if (gotPositive) {
+            gotPositive = matches(text, position, positiveSuffix);
+        }
+        if (gotNegative) {
+            gotNegative = matches(text, position, negativeSuffix);
+        }
+        if (gotPositive && gotNegative) {
+            if (positiveSuffix.length() > negativeSuffix.length()) {
+                gotNegative = false;
+            } else if (positiveSuffix.length() < negativeSuffix.length()) {
+                gotPositive = false;
+            }
+        }
+        if (gotPositive == gotNegative) {
+            pos.setErrorIndex(position);
+            return null;
+        }
+        position += gotPositive ? positiveSuffix.length() : negativeSuffix.length();
+        pos.setIndex(position);
+
+        if (infinite) {
+            boolean positiveResult = gotPositive == (multiplier >= 0);
+            return Double.valueOf(positiveResult ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY);
+        }
+        return toNumber(digits, decimalAt, gotPositive);
+    }
+
+    private static final String LONG_MIN_DIGITS = "9223372036854775808";
+
+    /// Whether these digits, an integer with `decimalAt` digits before the
+    /// point, fit a `long` of the given sign.
+    private static boolean fitsLong(StringBuilder digits, int decimalAt, boolean positive) {
+        int count = digits.length();
+        if (decimalAt < count || decimalAt > LONG_MIN_DIGITS.length()) {
+            return false;
+        }
+        if (decimalAt < LONG_MIN_DIGITS.length()) {
+            return true;
+        }
+        for (int i = 0; i < count; i++) {
+            char mine = digits.charAt(i);
+            char limit = LONG_MIN_DIGITS.charAt(i);
+            if (mine > limit) {
+                return false;
+            }
+            if (mine < limit) {
+                return true;
+            }
+        }
+        if (count < decimalAt) {
+            return true;
+        }
+        // Exactly the magnitude of Long.MIN_VALUE.
+        return !positive;
+    }
+
+    private Number toNumber(StringBuilder digits, int decimalAt, boolean positive) {
+        while (digits.length() > 0 && digits.charAt(digits.length() - 1) == '0') {
+            digits.setLength(digits.length() - 1);
+        }
+        boolean gotDouble;
+        long longResult = 0;
+        double doubleResult = 0.0;
+        if (digits.length() == 0) {
+            if (positive || isParseIntegerOnly()) {
+                gotDouble = false;
+            } else {
+                gotDouble = true;
+                doubleResult = -0.0;
+            }
+        } else if (fitsLong(digits, decimalAt, positive)) {
+            gotDouble = false;
+            StringBuilder sb = new StringBuilder();
+            if (!positive) {
+                sb.append('-');
+            }
+            sb.append(digits.toString());
+            for (int i = digits.length(); i < decimalAt; i++) {
+                sb.append('0');
+            }
+            longResult = Long.parseLong(sb.toString());
+        } else if (decimalAt > 309) {
+            // At least ten to the 309th, past Double.MAX_VALUE: the JDK
+            // answers an infinity. Settled here rather than handed to
+            // Double.parseDouble, which on some ports answers 0.0 for an
+            // exponent this large.
+            gotDouble = true;
+            doubleResult = positive ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+        } else if (decimalAt < -323) {
+            // Below ten to the -324th, under half of Double.MIN_VALUE: the
+            // JDK answers a zero of the parsed sign.
+            gotDouble = true;
+            doubleResult = positive ? 0.0 : -0.0;
+        } else {
+            gotDouble = true;
+            StringBuilder sb = new StringBuilder();
+            if (!positive) {
+                sb.append('-');
+            }
+            sb.append(digits.charAt(0)).append('.');
+            if (digits.length() > 1) {
+                sb.append(digits.toString().substring(1));
+            } else {
+                sb.append('0');
+            }
+            sb.append('E').append(decimalAt - 1);
+            doubleResult = Double.parseDouble(sb.toString());
+        }
+        // A multiplier of zero formats everything as zero; there is nothing
+        // to divide back by.
+        if (multiplier != 1 && multiplier != 0) {
+            if (gotDouble) {
+                doubleResult = doubleResult / multiplier;
+            } else if (longResult % multiplier == 0) {
+                longResult = longResult / multiplier;
+            } else {
+                doubleResult = (double) longResult / multiplier;
+                gotDouble = true;
+            }
+            if (gotDouble) {
+                long whole = (long) doubleResult;
+                boolean negativeZero = doubleResult == 0.0 && Double.doubleToLongBits(doubleResult) < 0;
+                if (doubleResult == (double) whole && !negativeZero) {
+                    gotDouble = false;
+                    longResult = whole;
+                } else if (isParseIntegerOnly()) {
+                    gotDouble = false;
+                    longResult = whole;
+                }
+            }
+        }
+        if (gotDouble) {
+            return Double.valueOf(doubleResult);
+        }
+        return Long.valueOf(longResult);
+    }
+
+    // ------------------------------------------------------------------
+    // Pattern
+    // ------------------------------------------------------------------
+
+    public void applyPattern(String pattern) {
+        parsePattern(pattern);
+    }
+
+    private static IllegalArgumentException malformed(String why, String pattern) {
+        return new IllegalArgumentException(why + " in pattern \"" + pattern + '"');
+    }
+
+    private static boolean isNumberChar(char ch) {
+        return ch == '#' || ch == '0' || ch == ',' || ch == '.';
+    }
+
+    private void parsePattern(String pattern) {
+        if (pattern == null) {
+            throw new NullPointerException();
+        }
+        int len = pattern.length();
+        boolean gotNegative = false;
+        boolean exponential = false;
+        boolean currency = false;
+        int exponentDigits = 0;
+        int newMultiplier = 1;
+        String newPosPrefix = "";
+        String newPosSuffix = "";
+        String newNegPrefix = "";
+        String newNegSuffix = "";
+        int digitLeftCount = 0;
+        int zeroDigitCount = 0;
+        int digitRightCount = 0;
+        int decimalPos = -1;
+        int groupingCount = -1;
+        int numberLength = 0;
+
+        int start = 0;
+        for (int part = 0; part < 2 && start < len; part++) {
+            boolean positive = part == 0;
+            StringBuilder prefix = new StringBuilder();
+            StringBuilder suffix = new StringBuilder();
+            StringBuilder affix = prefix;
+            int phase = 0;
+            boolean inQuote = false;
+            boolean sawSeparator = false;
+            int partMultiplier = 1;
+            int toSkip = numberLength;
+            int pos = start;
+            while (pos < len) {
+                char ch = pattern.charAt(pos);
+                if (phase == 1) {
+                    if (!positive) {
+                        // Only the affixes of the negative subpattern count;
+                        // its number is skipped, as long as the positive one.
+                        if (toSkip > 0) {
+                            toSkip--;
+                            pos++;
+                            continue;
+                        }
+                        phase = 2;
+                        affix = suffix;
+                        continue;
+                    }
+                    if (ch == '#') {
+                        if (zeroDigitCount > 0) {
+                            digitRightCount++;
+                        } else {
+                            digitLeftCount++;
+                        }
+                        if (groupingCount >= 0 && decimalPos < 0) {
+                            groupingCount++;
+                        }
+                    } else if (ch == '0') {
+                        if (digitRightCount > 0) {
+                            throw malformed("Unexpected '0'", pattern);
+                        }
+                        zeroDigitCount++;
+                        if (groupingCount >= 0 && decimalPos < 0) {
+                            groupingCount++;
+                        }
+                    } else if (ch == ',') {
+                        groupingCount = 0;
+                    } else if (ch == '.') {
+                        if (decimalPos >= 0) {
+                            throw malformed("Multiple decimal separators", pattern);
+                        }
+                        decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
+                    } else if (ch == 'E') {
+                        if (exponential) {
+                            throw malformed("Multiple exponential symbols", pattern);
+                        }
+                        exponential = true;
+                        exponentDigits = 0;
+                        while (pos + 1 < len && pattern.charAt(pos + 1) == '0') {
+                            exponentDigits++;
+                            numberLength++;
+                            pos++;
+                        }
+                        if (digitLeftCount + zeroDigitCount < 1 || exponentDigits < 1) {
+                            throw malformed("Malformed exponential pattern", pattern);
+                        }
+                        numberLength++;
+                        pos++;
+                        phase = 2;
+                        affix = suffix;
+                        continue;
+                    } else {
+                        phase = 2;
+                        affix = suffix;
+                        continue;
+                    }
+                    numberLength++;
+                    pos++;
+                    continue;
+                }
+                // A prefix or a suffix.
+                if (inQuote) {
+                    if (ch == QUOTE) {
+                        if (pos + 1 < len && pattern.charAt(pos + 1) == QUOTE) {
+                            pos++;
+                            affix.append("''");
+                        } else {
+                            inQuote = false;
+                        }
+                        pos++;
+                        continue;
+                    }
+                } else if (isNumberChar(ch)) {
+                    // In a suffix too: the JDK goes back to reading the
+                    // number, so "0.0x0" is "0.00x", and this does the same
+                    // rather than reject a pattern the desktop accepts.
+                    if (phase == 2 && !positive) {
+                        pos = len;
+                        continue;
+                    }
+                    phase = 1;
+                    continue;
+                } else if (ch == CURRENCY_SIGN) {
+                    boolean doubled = pos + 1 < len && pattern.charAt(pos + 1) == CURRENCY_SIGN;
+                    if (doubled) {
+                        pos++;
+                    }
+                    currency = true;
+                    affix.append(QUOTE).append(CURRENCY_SIGN);
+                    if (doubled) {
+                        affix.append(CURRENCY_SIGN);
+                    }
+                    pos++;
+                    continue;
+                } else if (ch == QUOTE) {
+                    if (pos + 1 < len && pattern.charAt(pos + 1) == QUOTE) {
+                        pos++;
+                        affix.append("''");
+                    } else {
+                        inQuote = true;
+                    }
+                    pos++;
+                    continue;
+                } else if (ch == ';') {
+                    if (phase == 0 || !positive) {
+                        throw malformed("Unquoted special character ';'", pattern);
+                    }
+                    sawSeparator = true;
+                    pos++;
+                    break;
+                } else if (ch == '%' || ch == PER_MILLE_SIGN) {
+                    if (partMultiplier != 1) {
+                        throw malformed("Too many percent/per mille characters", pattern);
+                    }
+                    partMultiplier = ch == '%' ? 100 : 1000;
+                    if (positive) {
+                        newMultiplier = partMultiplier;
+                    }
+                    affix.append(QUOTE).append(ch);
+                    pos++;
+                    continue;
+                } else if (ch == '-') {
+                    affix.append(QUOTE).append('-');
+                    pos++;
+                    continue;
+                }
+                affix.append(ch);
+                pos++;
+            }
+            if (inQuote) {
+                throw malformed("Unterminated quote", pattern);
+            }
+            if (positive) {
+                newPosPrefix = prefix.toString();
+                newPosSuffix = suffix.toString();
+            } else {
+                newNegPrefix = prefix.toString();
+                newNegSuffix = suffix.toString();
+                gotNegative = true;
+            }
+            // Without a separator the whole pattern is read again as the
+            // negative one. Its affixes then equal the positive ones, which
+            // is what selects the default minus sign below.
+            start = sawSeparator ? pos : 0;
+        }
+
+        if (len == 0) {
+            useExponentialNotation = false;
+            minExponentDigits = 0;
+            currencyFormat = false;
+            decimalSeparatorAlwaysShown = false;
+            setMinimumIntegerDigits(0);
+            setMaximumIntegerDigits(Integer.MAX_VALUE);
+            setMinimumFractionDigits(0);
+            setMaximumFractionDigits(Integer.MAX_VALUE);
+        } else {
+            if (zeroDigitCount == 0 && digitLeftCount > 0 && decimalPos >= 0) {
+                // "#.##", "#." and ".#" have one digit that is always
+                // written; it is the one next to the decimal point.
+                int n = decimalPos;
+                if (n == 0) {
+                    n++;
+                }
+                digitRightCount = digitLeftCount - n;
+                digitLeftCount = n - 1;
+                zeroDigitCount = 1;
+            }
+            if ((decimalPos < 0 && digitRightCount > 0)
+                    || (decimalPos >= 0
+                            && (decimalPos < digitLeftCount || decimalPos > digitLeftCount + zeroDigitCount))
+                    || groupingCount == 0) {
+                throw malformed("Malformed pattern", pattern);
+            }
+            int digitTotalCount = digitLeftCount + zeroDigitCount + digitRightCount;
+            if (decimalPos > digitTotalCount) {
+                decimalPos = digitTotalCount;
+            }
+            int effectiveDecimalPos = decimalPos >= 0 ? decimalPos : digitTotalCount;
+            useExponentialNotation = exponential;
+            minExponentDigits = exponentDigits;
+            // Reset first, so that neither setter is clamped by a previous
+            // pattern's limits.
+            setMinimumIntegerDigits(0);
+            setMinimumFractionDigits(0);
+            int minInt = effectiveDecimalPos - digitLeftCount;
+            setMaximumIntegerDigits(exponential ? digitLeftCount + minInt : Integer.MAX_VALUE);
+            setMinimumIntegerDigits(minInt);
+            setMaximumFractionDigits(decimalPos >= 0 ? digitTotalCount - decimalPos : 0);
+            setMinimumFractionDigits(decimalPos >= 0 ? digitLeftCount + zeroDigitCount - decimalPos : 0);
+            setGroupingUsed(groupingCount > 0);
+            groupingSize = groupingCount > 0 ? groupingCount : 0;
+            multiplier = newMultiplier;
+            currencyFormat = currency;
+            decimalSeparatorAlwaysShown = decimalPos == 0 || decimalPos == digitTotalCount;
+        }
+        posPrefixPattern = newPosPrefix;
+        posSuffixPattern = newPosSuffix;
+        // No negative subpattern, or one that says nothing new, means a
+        // minus sign in front of the positive one.
+        if (!gotNegative || (newNegPrefix.equals(newPosPrefix) && newNegSuffix.equals(newPosSuffix))) {
+            negPrefixPattern = "'-" + newPosPrefix;
+            negSuffixPattern = newPosSuffix;
+        } else {
+            negPrefixPattern = newNegPrefix;
+            negSuffixPattern = newNegSuffix;
+        }
+        expandAffixes();
+    }
+
+    private void expandAffixes() {
+        positivePrefix = expandAffix(posPrefixPattern);
+        positiveSuffix = expandAffix(posSuffixPattern);
+        negativePrefix = expandAffix(negPrefixPattern);
+        negativeSuffix = expandAffix(negSuffixPattern);
+    }
+
+    private String expandAffix(String internal) {
+        if (internal.indexOf(QUOTE) < 0) {
+            return internal;
+        }
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        while (i < internal.length()) {
+            char c = internal.charAt(i++);
+            if (c != QUOTE || i >= internal.length()) {
+                sb.append(c);
+                continue;
+            }
+            c = internal.charAt(i++);
+            if (c == CURRENCY_SIGN) {
+                if (i < internal.length() && internal.charAt(i) == CURRENCY_SIGN) {
+                    i++;
+                    sb.append(symbols.getInternationalCurrencySymbol());
+                } else {
+                    sb.append(symbols.getCurrencySymbol());
+                }
+            } else if (c == '%') {
+                sb.append(symbols.getPercent());
+            } else if (c == PER_MILLE_SIGN) {
+                sb.append(symbols.getPerMill());
+            } else if (c == '-') {
+                sb.append(symbols.getMinusSign());
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static String literalAffix(String literal) {
+        if (literal.indexOf(QUOTE) < 0) {
+            return literal;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < literal.length(); i++) {
+            char c = literal.charAt(i);
+            sb.append(c);
+            if (c == QUOTE) {
+                sb.append(QUOTE);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static boolean needsQuoting(char c) {
+        return isNumberChar(c) || c == ';' || c == '%' || c == PER_MILLE_SIGN || c == CURRENCY_SIGN
+                || c == '-';
+    }
+
+    private static void appendAffixPattern(StringBuilder out, String internal) {
+        int i = 0;
+        while (i < internal.length()) {
+            char c = internal.charAt(i++);
+            if (c == QUOTE && i < internal.length()) {
+                c = internal.charAt(i++);
+                if (c == QUOTE) {
+                    out.append("''");
+                } else {
+                    out.append(c);
+                    if (c == CURRENCY_SIGN && i < internal.length() && internal.charAt(i) == CURRENCY_SIGN) {
+                        out.append(CURRENCY_SIGN);
+                        i++;
+                    }
+                }
+            } else if (needsQuoting(c)) {
+                out.append(QUOTE).append(c).append(QUOTE);
+            } else {
+                out.append(c);
+            }
+        }
+    }
+
+    private void appendNumberPattern(StringBuilder out) {
+        int minInt = getMinimumIntegerDigits();
+        // Capped: an empty pattern allows any number of fraction digits, and
+        // spelling that out exhausts memory, as it does in the JDK.
+        int maxFrac = Math.min(getMaximumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        int minFrac = Math.min(getMinimumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        boolean grouping = isGroupingUsed() && groupingSize > 0;
+        int digitCount = useExponentialNotation
+                ? getMaximumIntegerDigits()
+                : Math.max(groupingSize, minInt) + 1;
+        for (int i = digitCount; i > 0; i--) {
+            // groupingSize is checked positive just above.
+            if (i != digitCount && grouping && i % groupingSize == 0) {
+                out.append(',');
+            }
+            out.append(i <= minInt ? '0' : '#');
+        }
+        if (maxFrac > 0 || decimalSeparatorAlwaysShown) {
+            out.append('.');
+        }
+        for (int i = 0; i < maxFrac; i++) {
+            out.append(i < minFrac ? '0' : '#');
+        }
+        if (useExponentialNotation) {
+            out.append('E');
+            for (int i = 0; i < minExponentDigits; i++) {
+                out.append('0');
+            }
+        }
+    }
+
+    /// A pattern that produces this format. It is equivalent to the pattern
+    /// that was applied, not necessarily the same text: `0.00` comes back as
+    /// `#0.00`.
+    public String toPattern() {
+        StringBuilder out = new StringBuilder();
+        appendAffixPattern(out, posPrefixPattern);
+        appendNumberPattern(out);
+        appendAffixPattern(out, posSuffixPattern);
+        boolean defaultNegative = negSuffixPattern.equals(posSuffixPattern)
+                && negPrefixPattern.equals("'-" + posPrefixPattern);
+        if (!defaultNegative) {
+            out.append(';');
+            appendAffixPattern(out, negPrefixPattern);
+            appendNumberPattern(out);
+            appendAffixPattern(out, negSuffixPattern);
+        }
+        return out.toString();
+    }
+
+    // ------------------------------------------------------------------
+    // Properties
+    // ------------------------------------------------------------------
+
+    /// A copy of the symbols in use; changing it changes nothing until it
+    /// is passed to [#setDecimalFormatSymbols(DecimalFormatSymbols)].
+    public DecimalFormatSymbols getDecimalFormatSymbols() {
+        Object copy = symbols.clone();
+        return copy instanceof DecimalFormatSymbols ? (DecimalFormatSymbols) copy : symbols;
+    }
+
+    public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols) {
+        Object copy = newSymbols.clone();
+        if (copy instanceof DecimalFormatSymbols) {
+            symbols = (DecimalFormatSymbols) copy;
+            expandAffixes();
+        }
+    }
+
+    public String getPositivePrefix() {
+        return positivePrefix;
+    }
+
+    public void setPositivePrefix(String newValue) {
+        positivePrefix = newValue;
+        posPrefixPattern = literalAffix(newValue);
+    }
+
+    public String getNegativePrefix() {
+        return negativePrefix;
+    }
+
+    public void setNegativePrefix(String newValue) {
+        negativePrefix = newValue;
+        negPrefixPattern = literalAffix(newValue);
+    }
+
+    public String getPositiveSuffix() {
+        return positiveSuffix;
+    }
+
+    public void setPositiveSuffix(String newValue) {
+        positiveSuffix = newValue;
+        posSuffixPattern = literalAffix(newValue);
+    }
+
+    public String getNegativeSuffix() {
+        return negativeSuffix;
+    }
+
+    public void setNegativeSuffix(String newValue) {
+        negativeSuffix = newValue;
+        negSuffixPattern = literalAffix(newValue);
+    }
+
+    public int getMultiplier() {
+        return multiplier;
+    }
+
+    public void setMultiplier(int newValue) {
+        multiplier = newValue;
+    }
+
+    public int getGroupingSize() {
+        return groupingSize;
+    }
+
+    public void setGroupingSize(int newValue) {
+        groupingSize = Math.max(0, newValue);
+    }
+
+    public boolean isDecimalSeparatorAlwaysShown() {
+        return decimalSeparatorAlwaysShown;
+    }
+
+    public void setDecimalSeparatorAlwaysShown(boolean newValue) {
+        decimalSeparatorAlwaysShown = newValue;
+    }
+
+    /// A copy of this format. Written out field by field: `Object.clone()`
+    /// answers `null` on the device for anything but an array.
+    @Override
+    public Object clone() {
+        DecimalFormat copy = new DecimalFormat("", symbols);
+        copyNumberFormatTo(copy);
+        copy.posPrefixPattern = posPrefixPattern;
+        copy.posSuffixPattern = posSuffixPattern;
+        copy.negPrefixPattern = negPrefixPattern;
+        copy.negSuffixPattern = negSuffixPattern;
+        copy.positivePrefix = positivePrefix;
+        copy.positiveSuffix = positiveSuffix;
+        copy.negativePrefix = negativePrefix;
+        copy.negativeSuffix = negativeSuffix;
+        copy.multiplier = multiplier;
+        copy.groupingSize = groupingSize;
+        copy.decimalSeparatorAlwaysShown = decimalSeparatorAlwaysShown;
+        copy.useExponentialNotation = useExponentialNotation;
+        copy.minExponentDigits = minExponentDigits;
+        copy.currencyFormat = currencyFormat;
+        return copy;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!super.equals(obj) || !(obj instanceof DecimalFormat)) {
+            return false;
+        }
+        DecimalFormat other = (DecimalFormat) obj;
+        return positivePrefix.equals(other.positivePrefix)
+                && positiveSuffix.equals(other.positiveSuffix)
+                && negativePrefix.equals(other.negativePrefix)
+                && negativeSuffix.equals(other.negativeSuffix)
+                && multiplier == other.multiplier
+                && groupingSize == other.groupingSize
+                && decimalSeparatorAlwaysShown == other.decimalSeparatorAlwaysShown
+                && useExponentialNotation == other.useExponentialNotation
+                && minExponentDigits == other.minExponentDigits
+                && symbols.equals(other.symbols);
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode() * 37 + positivePrefix.hashCode();
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/DecimalFormatSymbols.java b/Ports/CLDC11/src/java/text/DecimalFormatSymbols.java
new file mode 100644
index 00000000000..4941d026547
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/DecimalFormatSymbols.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.Locale;
+
+/// The characters a [DecimalFormat] writes and reads -- decimal and
+/// grouping separators, minus sign, percent, currency symbol and so on.
+///
+/// #### Where the symbols come from
+///
+/// The device library carries no locale data of its own. What it knows about
+/// the user's locale -- the decimal and grouping separators and the currency
+/// symbol -- it is told by the platform, which on a device reads them off
+/// numbers Codename One's `L10NManager` formatted. Everything the platform
+/// cannot tell (percent, per mille, the exponent separator, the infinity and
+/// not-a-number texts) is as in the US English locale.
+///
+/// A request that names `en_US` gets the US English symbols outright. Any
+/// other locale gets the device's symbols, since the device cannot format for
+/// a locale other than its own. Before Codename One is initialized, and where
+/// the platform answers nothing usable, the symbols are US English.
+public class DecimalFormatSymbols implements Cloneable, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private char zeroDigit = '0';
+    private char groupingSeparator = ',';
+    private char decimalSeparator = '.';
+    private char perMill = (char) 0x2030;
+    private char percent = '%';
+    private char digit = '#';
+    private char patternSeparator = ';';
+    private String infinity = String.valueOf((char) 0x221E);
+    private String nan = String.valueOf((char) 0xFFFD);
+    private char minusSign = '-';
+    private String currencySymbol = "$";
+    private String intlCurrencySymbol = "USD";
+    private char monetarySeparator = '.';
+    private String exponentSeparator = "E";
+
+    public DecimalFormatSymbols() {
+        this(Locale.getDefault());
+    }
+
+    public DecimalFormatSymbols(Locale locale) {
+        if (locale == null) {
+            throw new NullPointerException();
+        }
+        if (!isUsEnglish(locale)) {
+            readDeviceSymbols();
+        }
+    }
+
+    public static final DecimalFormatSymbols getInstance() {
+        return new DecimalFormatSymbols();
+    }
+
+    public static final DecimalFormatSymbols getInstance(Locale locale) {
+        return new DecimalFormatSymbols(locale);
+    }
+
+    private static boolean isUsEnglish(Locale locale) {
+        return "en".equals(locale.getLanguage()) && "US".equals(locale.getCountry());
+    }
+
+    private void readDeviceSymbols() {
+        String[] device;
+        try {
+            device = JdkHost.get().localeNumberSymbols();
+        } catch (RuntimeException e) {
+            // A port whose localization cannot answer leaves the US English
+            // symbols in place, which is the documented fallback.
+            return;
+        }
+        if (device == null || device.length < 3) {
+            return;
+        }
+        String decimal = device[0];
+        if (decimal != null && decimal.length() == 1) {
+            decimalSeparator = decimal.charAt(0);
+            monetarySeparator = decimalSeparator;
+        }
+        String grouping = device[1];
+        if (grouping != null && grouping.length() == 1 && grouping.charAt(0) != decimalSeparator) {
+            groupingSeparator = grouping.charAt(0);
+        } else if (decimalSeparator == ',') {
+            // A locale that writes a decimal comma and no grouping on this
+            // platform still must not group with the same character.
+            groupingSeparator = '.';
+        }
+        String currency = device[2];
+        if (currency != null && currency.length() > 0) {
+            currencySymbol = currency;
+            intlCurrencySymbol = currency;
+        }
+    }
+
+    public char getZeroDigit() {
+        return zeroDigit;
+    }
+
+    public void setZeroDigit(char zeroDigit) {
+        this.zeroDigit = zeroDigit;
+    }
+
+    public char getGroupingSeparator() {
+        return groupingSeparator;
+    }
+
+    public void setGroupingSeparator(char groupingSeparator) {
+        this.groupingSeparator = groupingSeparator;
+    }
+
+    public char getDecimalSeparator() {
+        return decimalSeparator;
+    }
+
+    public void setDecimalSeparator(char decimalSeparator) {
+        this.decimalSeparator = decimalSeparator;
+    }
+
+    public char getPerMill() {
+        return perMill;
+    }
+
+    public void setPerMill(char perMill) {
+        this.perMill = perMill;
+    }
+
+    public char getPercent() {
+        return percent;
+    }
+
+    public void setPercent(char percent) {
+        this.percent = percent;
+    }
+
+    public char getDigit() {
+        return digit;
+    }
+
+    public void setDigit(char digit) {
+        this.digit = digit;
+    }
+
+    public char getPatternSeparator() {
+        return patternSeparator;
+    }
+
+    public void setPatternSeparator(char patternSeparator) {
+        this.patternSeparator = patternSeparator;
+    }
+
+    public String getInfinity() {
+        return infinity;
+    }
+
+    public void setInfinity(String infinity) {
+        this.infinity = infinity;
+    }
+
+    public String getNaN() {
+        return nan;
+    }
+
+    public void setNaN(String nan) {
+        this.nan = nan;
+    }
+
+    public char getMinusSign() {
+        return minusSign;
+    }
+
+    public void setMinusSign(char minusSign) {
+        this.minusSign = minusSign;
+    }
+
+    public String getCurrencySymbol() {
+        return currencySymbol;
+    }
+
+    public void setCurrencySymbol(String currency) {
+        currencySymbol = currency;
+    }
+
+    public String getInternationalCurrencySymbol() {
+        return intlCurrencySymbol;
+    }
+
+    public void setInternationalCurrencySymbol(String currencyCode) {
+        intlCurrencySymbol = currencyCode;
+    }
+
+    public char getMonetaryDecimalSeparator() {
+        return monetarySeparator;
+    }
+
+    public void setMonetaryDecimalSeparator(char sep) {
+        monetarySeparator = sep;
+    }
+
+    public String getExponentSeparator() {
+        return exponentSeparator;
+    }
+
+    public void setExponentSeparator(String exp) {
+        if (exp == null) {
+            throw new NullPointerException();
+        }
+        exponentSeparator = exp;
+    }
+
+    /// A copy of these symbols. Written out field by field: `Object.clone()`
+    /// answers `null` on the device for anything but an array.
+    @Override
+    public Object clone() {
+        DecimalFormatSymbols copy = new DecimalFormatSymbols(new Locale("en", "US"));
+        copy.zeroDigit = zeroDigit;
+        copy.groupingSeparator = groupingSeparator;
+        copy.decimalSeparator = decimalSeparator;
+        copy.perMill = perMill;
+        copy.percent = percent;
+        copy.digit = digit;
+        copy.patternSeparator = patternSeparator;
+        copy.infinity = infinity;
+        copy.nan = nan;
+        copy.minusSign = minusSign;
+        copy.currencySymbol = currencySymbol;
+        copy.intlCurrencySymbol = intlCurrencySymbol;
+        copy.monetarySeparator = monetarySeparator;
+        copy.exponentSeparator = exponentSeparator;
+        return copy;
+    }
+
+    private static boolean same(String a, String b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof DecimalFormatSymbols)) {
+            return false;
+        }
+        DecimalFormatSymbols other = (DecimalFormatSymbols) obj;
+        return zeroDigit == other.zeroDigit
+                && groupingSeparator == other.groupingSeparator
+                && decimalSeparator == other.decimalSeparator
+                && percent == other.percent
+                && perMill == other.perMill
+                && digit == other.digit
+                && minusSign == other.minusSign
+                && patternSeparator == other.patternSeparator
+                && monetarySeparator == other.monetarySeparator
+                && same(infinity, other.infinity)
+                && same(nan, other.nan)
+                && same(currencySymbol, other.currencySymbol)
+                && same(intlCurrencySymbol, other.intlCurrencySymbol)
+                && same(exponentSeparator, other.exponentSeparator);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = zeroDigit;
+        result = result * 37 + groupingSeparator;
+        result = result * 37 + decimalSeparator;
+        return result;
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/FieldPosition.java b/Ports/CLDC11/src/java/text/FieldPosition.java
new file mode 100644
index 00000000000..aedd19d8be3
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/FieldPosition.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Names a field of formatted output and receives the range of characters that field took.
+/// `NumberFormat.INTEGER_FIELD` and `NumberFormat.FRACTION_FIELD` are the
+/// fields the number formats here report.
+public class FieldPosition {
+
+    private final int field;
+    private int beginIndex;
+    private int endIndex;
+
+    public FieldPosition(int field) {
+        this.field = field;
+    }
+
+    public int getField() {
+        return field;
+    }
+
+    public int getBeginIndex() {
+        return beginIndex;
+    }
+
+    public int getEndIndex() {
+        return endIndex;
+    }
+
+    public void setBeginIndex(int bi) {
+        beginIndex = bi;
+    }
+
+    public void setEndIndex(int ei) {
+        endIndex = ei;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof FieldPosition)) {
+            return false;
+        }
+        FieldPosition other = (FieldPosition) obj;
+        return field == other.field && beginIndex == other.beginIndex && endIndex == other.endIndex;
+    }
+
+    @Override
+    public int hashCode() {
+        return (field << 24) | (beginIndex << 16) | endIndex;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[field=" + field + ",attribute=null,beginIndex=" + beginIndex
+                + ",endIndex=" + endIndex + ']';
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/Format.java b/Ports/CLDC11/src/java/text/Format.java
index b2bc4c1bc94..e3838fef3d4 100644
--- a/Ports/CLDC11/src/java/text/Format.java
+++ b/Ports/CLDC11/src/java/text/Format.java
@@ -6,55 +6,76 @@
  * published by the Free Software Foundation.  Codename One designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
- *  
+ *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
- * 
+ *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- * 
- * Please contact Codename One through http://www.codenameone.com/ if you 
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
 package java.text;
 
-/// An abstract class for parsing and formatting localisation sensitive information, compatible with JDK 6.
+/// The base of the formats that turn locale sensitive values into text and
+/// back: [DateFormat], [NumberFormat] and [MessageFormat].
 ///
-/// #### See also
+/// A subclass implements [#format(Object, StringBuffer, FieldPosition)] and
+/// [#parseObject(String, ParsePosition)]; the one-argument forms are written
+/// over them, as in the JDK.
 ///
-/// - [http://docs.oracle.com/javase/6/docs/api/java/text/Format.html](http://docs.oracle.com/javase/6/docs/api/java/text/Format.html)
-public abstract class Format implements Cloneable {
-	/// Format an object.
-	///
-	/// #### Parameters
-	///
-	/// - `source`: object to be formatted to text.
-	///
-	/// #### Returns
-	///
-	/// formatted text.
-	///
-	/// #### Throws
-	///
-	/// - `IllegalArgumentException`: if the source can not be formatted.
-	public abstract String format(Object source) throws IllegalArgumentException;
+/// #### Differences from the JDK
+///
+/// - No `clone` here: `Object.clone()` answers `null` on the device for
+///   anything but an array, so every format of this package declares a
+///   `clone` that copies its own fields.
+/// - No `formatToCharacterIterator`: the device has no
+///   `AttributedCharacterIterator`.
+public abstract class Format implements Cloneable, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    protected Format() {
+    }
+
+    /// Formats an object to text.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if this format cannot format `obj`
+    public final String format(Object obj) {
+        return format(obj, new StringBuffer(), new FieldPosition(0)).toString();
+    }
+
+    /// Formats an object, appending the text to `toAppendTo`, and reports the
+    /// range the field `pos` names took.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if this format cannot format `obj`
+    public abstract StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos);
+
+    /// Parses an object from `source` starting at `pos`. On success the index
+    /// of `pos` is moved past what was read; on failure it is left alone, the
+    /// error index is set and `null` is returned.
+    public abstract Object parseObject(String source, ParsePosition pos);
 
-	/// Parse an string to an object.
-	///
-	/// #### Parameters
-	///
-	/// - `source`: document to be parsed.
-	///
-	/// #### Returns
-	///
-	/// parsed object.
-	///
-	/// #### Throws
-	///
-	/// - `ParseException`: if the source could not be parsed.
-	public abstract Object parseObject(String source) throws ParseException;
-}
\ No newline at end of file
+    /// Parses an object from the beginning of `source`.
+    ///
+    /// #### Throws
+    ///
+    /// - `ParseException`: if nothing at the beginning of `source` parses
+    public Object parseObject(String source) throws ParseException {
+        ParsePosition pos = new ParsePosition(0);
+        Object result = parseObject(source, pos);
+        if (pos.getIndex() == 0) {
+            throw new ParseException("Format.parseObject(String) failed", pos.getErrorIndex());
+        }
+        return result;
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/LegacyDoubleDigits.java b/Ports/CLDC11/src/java/text/LegacyDoubleDigits.java
new file mode 100644
index 00000000000..fa571f1d145
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/LegacyDoubleDigits.java
@@ -0,0 +1,547 @@
+/*
+ * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * Codename One note: this is a rewrite of the digit generation in OpenJDK's
+ * FloatingDecimal.BinaryToASCIIBuffer.dtoa (and the arithmetic it needs from
+ * FDBigInteger), reduced to what DecimalFormat uses and written against the
+ * JDK subset vm/JavaAPI and Ports/CLDC11 both provide. The decisions -- which
+ * path a value takes, the stopping tests, the rounding of the last digit --
+ * are OpenJDK's and are kept exactly, quirks included, because reproducing
+ * the JDK's output is the whole point of the class.
+ */
+package java.text;
+
+/// The decimal digits the JDK's `DecimalFormat` starts from when it formats a
+/// `double`.
+///
+/// That is NOT `Double.toString`. Since JDK-4511638 `Double.toString` writes
+/// the shortest string that round-trips, but `DecimalFormat` still takes its
+/// digits from the older `FloatingDecimal` conversion, which is not always the
+/// shortest: `1.0E23` comes out as `9.999999999999999E22`, and a value above
+/// two to the 53rd whose shortest form ends in zeros keeps its seventeenth
+/// digit (`7.2057594037927936E16`). Formatting from the shortest digits
+/// therefore disagrees with the desktop in the last digits of large numbers,
+/// so this class reproduces the old conversion.
+///
+/// The conversion picks one of three routes and the routes are NOT
+/// equivalent at their edges (`int` and `long` arithmetic use a strict
+/// stopping test where the big-integer route uses an inclusive one), so all
+/// three are kept rather than doing everything with big integers.
+final class LegacyDoubleDigits {
+    private static final int EXP_SHIFT = 52;
+    private static final long FRACT_HOB = 1L << EXP_SHIFT;
+    private static final long EXP_ONE = 1023L << EXP_SHIFT;
+    private static final long SIGNIF_BIT_MASK = FRACT_HOB - 1;
+    private static final int MAX_SMALL_BIN_EXP = 62;
+    private static final int MIN_SMALL_BIN_EXP = -(63 / 3);
+
+    private static final int[] SMALL_5_POW = new int[14];
+    private static final long[] LONG_5_POW = new long[27];
+
+    static {
+        SMALL_5_POW[0] = 1;
+        for (int i = 1; i < SMALL_5_POW.length; i++) {
+            SMALL_5_POW[i] = SMALL_5_POW[i - 1] * 5;
+        }
+        LONG_5_POW[0] = 1L;
+        for (int i = 1; i < LONG_5_POW.length; i++) {
+            LONG_5_POW[i] = LONG_5_POW[i - 1] * 5L;
+        }
+    }
+
+    /// Approximately `ceil(log2(5^i))`, as OpenJDK tabulates it; the route
+    /// choice depends on these exact values.
+    private static final int[] N_5_BITS = {
+        0, 3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31, 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59, 61
+    };
+
+    /// `insignificantDigits(1L << i)`: how many low decimal digits of an
+    /// integer value are below its precision.
+    private static final int[] INSIGNIFICANT_DIGITS_NUMBER = {
+        0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3,
+        4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7,
+        8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 11, 11, 11,
+        12, 12, 12, 12, 13, 13, 13, 14, 14, 14,
+        15, 15, 15, 15, 16, 16, 16, 17, 17, 17,
+        18, 18, 18, 19
+    };
+
+    /// The digits, `digits[first]` to `digits[first + count - 1]`.
+    final char[] digits = new char[24];
+    int first;
+    int count;
+    /// The position of the decimal point relative to the first digit:
+    /// the value is `0.d1d2d3... * 10^decExponent`.
+    int decExponent;
+
+    /// Converts a finite, strictly positive value.
+    LegacyDoubleDigits(double value) {
+        long bits = Double.doubleToLongBits(value);
+        long fractBits = bits & SIGNIF_BIT_MASK;
+        int binExp = (int) ((bits >> EXP_SHIFT) & 0x7ffL);
+        int nSignificantBits;
+        if (binExp == 0) {
+            // Subnormal: normalize so the high-order bit sits at EXP_SHIFT.
+            int leadingZeros = Long.numberOfLeadingZeros(fractBits);
+            int shift = leadingZeros - (63 - EXP_SHIFT);
+            fractBits <<= shift;
+            binExp = 1 - shift;
+            nSignificantBits = 64 - leadingZeros;
+        } else {
+            fractBits |= FRACT_HOB;
+            nSignificantBits = EXP_SHIFT + 1;
+        }
+        binExp -= 1023;
+        dtoa(binExp, fractBits, nSignificantBits);
+    }
+
+    private void developLongDigits(int decExp, long lvalue, int insignificantDigits) {
+        if (insignificantDigits != 0) {
+            // Drop the digits below the value's precision, rounding.
+            long pow10 = LONG_5_POW[insignificantDigits] << insignificantDigits;
+            long residue = lvalue % pow10;
+            lvalue /= pow10;
+            decExp += insignificantDigits;
+            if (residue >= (pow10 >> 1)) {
+                lvalue++;
+            }
+        }
+        int digitno = digits.length - 1;
+        int c = (int) (lvalue % 10L);
+        lvalue /= 10L;
+        while (c == 0) {
+            decExp++;
+            c = (int) (lvalue % 10L);
+            lvalue /= 10L;
+        }
+        while (lvalue != 0L) {
+            digits[digitno--] = (char) (c + '0');
+            decExp++;
+            c = (int) (lvalue % 10L);
+            lvalue /= 10L;
+        }
+        digits[digitno] = (char) (c + '0');
+        decExponent = decExp + 1;
+        first = digitno;
+        count = digits.length - digitno;
+    }
+
+    private void dtoa(int binExp, long fractBits, int nSignificantBits) {
+        final int tailZeros = Long.numberOfTrailingZeros(fractBits);
+        final int nFractBits = EXP_SHIFT + 1 - tailZeros;
+        int nTinyBits = Math.max(0, nFractBits - binExp - 1);
+        if (binExp <= MAX_SMALL_BIN_EXP && binExp >= MIN_SMALL_BIN_EXP
+                && nTinyBits < LONG_5_POW.length && nFractBits + N_5_BITS[nTinyBits] < 64
+                && nTinyBits == 0) {
+            // An integer that fits a long: its digits, less the ones below
+            // its precision.
+            int insignificant = 0;
+            if (binExp > nSignificantBits) {
+                int p2 = binExp - nSignificantBits - 1;
+                if (p2 > 1 && p2 < INSIGNIFICANT_DIGITS_NUMBER.length) {
+                    insignificant = INSIGNIFICANT_DIGITS_NUMBER[p2];
+                }
+            }
+            if (binExp >= EXP_SHIFT) {
+                fractBits <<= (binExp - EXP_SHIFT);
+            } else {
+                fractBits >>>= (EXP_SHIFT - binExp);
+            }
+            developLongDigits(0, fractBits, insignificant);
+            return;
+        }
+        // value = (B / S) * 10^decExp with 1 <= B / S < 10, and M is half an
+        // ULP scaled like B; digits are developed until the remainder is
+        // within M of either neighbour.
+        int decExp = estimateDecExp(fractBits, binExp);
+        int b5 = Math.max(0, -decExp);
+        int b2 = b5 + nTinyBits + binExp;
+        int s5 = Math.max(0, decExp);
+        int s2 = s5 + nTinyBits;
+        int m5 = b5;
+        int m2 = b2 - nSignificantBits;
+
+        fractBits >>>= tailZeros;
+        b2 -= nFractBits - 1;
+        int common2factor = Math.min(b2, s2);
+        b2 -= common2factor;
+        s2 -= common2factor;
+        m2 -= common2factor;
+        // Below an exact power of two the next smaller double is only half
+        // as far away.
+        if (nFractBits == 1) {
+            m2 -= 1;
+        }
+        if (m2 < 0) {
+            b2 -= m2;
+            s2 -= m2;
+            m2 = 0;
+        }
+
+        int ndigit = 0;
+        boolean low;
+        boolean high;
+        long lowDigitDifference;
+        int q;
+        int bBits = nFractBits + b2 + (b5 < N_5_BITS.length ? N_5_BITS[b5] : b5 * 3);
+        int tenSBits = s2 + 1 + (s5 + 1 < N_5_BITS.length ? N_5_BITS[s5 + 1] : (s5 + 1) * 3);
+        if (bBits < 64 && tenSBits < 64) {
+            if (bBits < 32 && tenSBits < 32) {
+                int b = ((int) fractBits * SMALL_5_POW[b5]) << b2;
+                int s = SMALL_5_POW[s5] << s2;
+                int m = SMALL_5_POW[m5] << m2;
+                int tens = s * 10;
+                q = b / s;
+                b = 10 * (b % s);
+                m *= 10;
+                low = b < m;
+                high = b + m > tens;
+                if (q == 0 && !high) {
+                    // The exponent estimate was one too high.
+                    decExp--;
+                } else {
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                // Java's E-form always shows a digit after the point, so
+                // outside the plain-notation range a second digit is forced.
+                if (decExp < -3 || decExp >= 8) {
+                    high = false;
+                    low = false;
+                }
+                while (!low && !high) {
+                    q = b / s;
+                    b = 10 * (b % s);
+                    m *= 10;
+                    if (m > 0) {
+                        low = b < m;
+                        high = b + m > tens;
+                    } else {
+                        // m overflowed, so it certainly exceeds both tests.
+                        low = true;
+                        high = true;
+                    }
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                lowDigitDifference = (b << 1) - tens;
+            } else {
+                long b = (fractBits * LONG_5_POW[b5]) << b2;
+                long s = LONG_5_POW[s5] << s2;
+                long m = LONG_5_POW[m5] << m2;
+                long tens = s * 10L;
+                q = (int) (b / s);
+                b = 10L * (b % s);
+                m *= 10L;
+                low = b < m;
+                high = b + m > tens;
+                if (q == 0 && !high) {
+                    decExp--;
+                } else {
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                if (decExp < -3 || decExp >= 8) {
+                    high = false;
+                    low = false;
+                }
+                while (!low && !high) {
+                    q = (int) (b / s);
+                    b = 10 * (b % s);
+                    m *= 10;
+                    if (m > 0L) {
+                        low = b < m;
+                        high = b + m > tens;
+                    } else {
+                        low = true;
+                        high = true;
+                    }
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                lowDigitDifference = (b << 1) - tens;
+            }
+        } else {
+            // OpenJDK normalizes these by a common power of two first to
+            // speed its division; that scales every comparison equally, so
+            // it is left out. Note the HIGH test here is inclusive (>=),
+            // unlike the int and long routes above.
+            Big sVal = Big.pow52(s5, s2);
+            Big bVal = Big.pow52(0, 0);
+            bVal.multiplyLong(fractBits);
+            bVal.multiplyPow5(b5);
+            bVal.shiftLeft(b2);
+            Big mVal = Big.pow52(m5 + 1, m2 + 1);
+            Big tenSVal = Big.pow52(s5 + 1, s2 + 1);
+            q = bVal.quoRemIteration(sVal);
+            low = bVal.compareTo(mVal) < 0;
+            high = tenSVal.compareToSum(bVal, mVal) <= 0;
+            if (q == 0 && !high) {
+                decExp--;
+            } else {
+                digits[ndigit++] = (char) ('0' + q);
+            }
+            if (decExp < -3 || decExp >= 8) {
+                high = false;
+                low = false;
+            }
+            while (!low && !high) {
+                q = bVal.quoRemIteration(sVal);
+                mVal.multiplySmall(10);
+                low = bVal.compareTo(mVal) < 0;
+                high = tenSVal.compareToSum(bVal, mVal) <= 0;
+                digits[ndigit++] = (char) ('0' + q);
+            }
+            if (high && low) {
+                bVal.shiftLeft(1);
+                lowDigitDifference = bVal.compareTo(tenSVal);
+            } else {
+                lowDigitDifference = 0L;
+            }
+        }
+        decExponent = decExp + 1;
+        first = 0;
+        count = ndigit;
+        // The last digit is rounded by the stopping condition.
+        if (high) {
+            if (low) {
+                if (lowDigitDifference == 0L) {
+                    if ((digits[first + count - 1] & 1) != 0) {
+                        roundup();
+                    }
+                } else if (lowDigitDifference > 0) {
+                    roundup();
+                }
+            } else {
+                roundup();
+            }
+        }
+    }
+
+    private void roundup() {
+        int i = first + count - 1;
+        int q = digits[i];
+        if (q == '9') {
+            while (q == '9' && i > first) {
+                digits[i] = '0';
+                q = digits[--i];
+            }
+            if (q == '9') {
+                decExponent += 1;
+                digits[first] = '1';
+                return;
+            }
+        }
+        digits[i] = (char) (q + 1);
+    }
+
+    /// Estimates `floor(log10(value))` from a linear approximation of
+    /// `log10` over the mantissa; it may come out one too high, which the
+    /// first digit corrects.
+    private static int estimateDecExp(long fractBits, int binExp) {
+        double d2 = Double.longBitsToDouble(EXP_ONE | (fractBits & SIGNIF_BIT_MASK));
+        double d = (d2 - 1.5D) * 0.289529654D + 0.176091259 + (double) binExp * 0.301029995663981;
+        long dBits = Double.doubleToLongBits(d);
+        int exponent = (int) ((dBits >> EXP_SHIFT) & 0x7ffL) - 1023;
+        boolean isNegative = dBits < 0;
+        if (exponent >= 0 && exponent < 52) {
+            long mask = SIGNIF_BIT_MASK >> exponent;
+            int r = (int) (((dBits & SIGNIF_BIT_MASK) | FRACT_HOB) >> (EXP_SHIFT - exponent));
+            return isNegative ? (((mask & dBits) == 0L) ? -r : -r - 1) : r;
+        } else if (exponent < 0) {
+            return ((dBits & ~(1L << 63)) == 0) ? 0 : (isNegative ? -1 : 0);
+        } else {
+            return (int) d;
+        }
+    }
+
+    /// A non-negative integer of any size: little-endian 32-bit words held
+    /// in an `int[]`, worked on through `long`s. Only the operations the
+    /// digit loop needs.
+    private static final class Big {
+        private static final long MASK = 0xffffffffL;
+        private int[] words = new int[8];
+        private int length;
+
+        static Big pow52(int p5, int p2) {
+            Big b = new Big();
+            b.words[0] = 1;
+            b.length = 1;
+            b.multiplyPow5(p5);
+            b.shiftLeft(p2);
+            return b;
+        }
+
+        private void ensure(int size) {
+            if (size > words.length) {
+                int[] bigger = new int[Math.max(size, words.length * 2)];
+                System.arraycopy(words, 0, bigger, 0, length);
+                words = bigger;
+            }
+        }
+
+        private void trim() {
+            while (length > 0 && words[length - 1] == 0) {
+                length--;
+            }
+        }
+
+        /// Multiplies by a non-negative factor below two to the 31st.
+        void multiplySmall(int factor) {
+            long carry = 0;
+            for (int i = 0; i < length; i++) {
+                long v = (words[i] & MASK) * factor + carry;
+                words[i] = (int) v;
+                carry = v >>> 32;
+            }
+            if (carry != 0) {
+                ensure(length + 1);
+                words[length++] = (int) carry;
+            }
+        }
+
+        /// Multiplies by a non-negative long.
+        void multiplyLong(long factor) {
+            int lowFactor = (int) (factor & 0x7fffffffL);
+            long high = factor >>> 31;
+            if (high == 0) {
+                multiplySmall(lowFactor);
+                return;
+            }
+            Big highPart = copy();
+            highPart.multiplyLong(high);
+            highPart.shiftLeft(31);
+            multiplySmall(lowFactor);
+            add(highPart);
+        }
+
+        void multiplyPow5(int p5) {
+            int left = p5;
+            while (left >= 13) {
+                multiplySmall(SMALL_5_POW[13]);
+                left -= 13;
+            }
+            if (left > 0) {
+                multiplySmall(SMALL_5_POW[left]);
+            }
+        }
+
+        void shiftLeft(int bits) {
+            if (length == 0 || bits == 0) {
+                return;
+            }
+            int wordShift = bits >>> 5;
+            int bitShift = bits & 31;
+            ensure(length + wordShift + 1);
+            if (bitShift == 0) {
+                // The extra top word is counted below; a word left over from
+                // an earlier, larger value must not survive in it.
+                words[length + wordShift] = 0;
+                for (int i = length - 1; i >= 0; i--) {
+                    words[i + wordShift] = words[i];
+                }
+            } else {
+                words[length + wordShift] = words[length - 1] >>> (32 - bitShift);
+                for (int i = length - 1; i > 0; i--) {
+                    words[i + wordShift] = (words[i] << bitShift) | (words[i - 1] >>> (32 - bitShift));
+                }
+                words[wordShift] = words[0] << bitShift;
+            }
+            for (int i = 0; i < wordShift; i++) {
+                words[i] = 0;
+            }
+            length += wordShift + 1;
+            trim();
+        }
+
+        private Big copy() {
+            Big c = new Big();
+            c.ensure(length);
+            System.arraycopy(words, 0, c.words, 0, length);
+            c.length = length;
+            return c;
+        }
+
+        void add(Big other) {
+            int size = Math.max(length, other.length);
+            ensure(size + 1);
+            long carry = 0;
+            for (int i = 0; i < size; i++) {
+                long a = i < length ? (words[i] & MASK) : 0L;
+                long b = i < other.length ? (other.words[i] & MASK) : 0L;
+                long v = a + b + carry;
+                words[i] = (int) v;
+                carry = v >>> 32;
+            }
+            length = size;
+            if (carry != 0) {
+                words[length++] = (int) carry;
+            }
+        }
+
+        /// Subtracts a value no greater than this one.
+        private void subtract(Big other) {
+            long borrow = 0;
+            for (int i = 0; i < length; i++) {
+                long b = i < other.length ? (other.words[i] & MASK) : 0L;
+                long v = (words[i] & MASK) - b - borrow;
+                words[i] = (int) v;
+                borrow = v < 0 ? 1 : 0;
+            }
+            trim();
+        }
+
+        int compareTo(Big other) {
+            if (length != other.length) {
+                return length < other.length ? -1 : 1;
+            }
+            for (int i = length - 1; i >= 0; i--) {
+                long a = words[i] & MASK;
+                long b = other.words[i] & MASK;
+                if (a != b) {
+                    return a < b ? -1 : 1;
+                }
+            }
+            return 0;
+        }
+
+        /// The sign of this minus `(x + y)`.
+        int compareToSum(Big x, Big y) {
+            Big sum = x.copy();
+            sum.add(y);
+            return compareTo(sum);
+        }
+
+        /// `q = this / s; this = 10 * (this % s)`, returning `q`. The
+        /// quotient is a single decimal digit, so repeated subtraction is
+        /// both exact and cheap.
+        int quoRemIteration(Big s) {
+            int q = 0;
+            while (compareTo(s) >= 0) {
+                subtract(s);
+                q++;
+            }
+            multiplySmall(10);
+            return q;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/MessageFormat.java b/Ports/CLDC11/src/java/text/MessageFormat.java
new file mode 100644
index 00000000000..66f627a0ca5
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/MessageFormat.java
@@ -0,0 +1,627 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/// Builds a message from a pattern and a list of arguments, and reads the
+/// arguments back out of a message.
+///
+/// #### Pattern syntax
+///
+/// Text is copied as it is, and each `{...}` element is replaced by an
+/// argument:
+///
+/// - `{0}`: the argument at that index. A `Number` is formatted with
+///   `NumberFormat.getInstance`, a `Date` with the short date and time
+///   format, a `String` is copied, anything else contributes `toString()`.
+/// - `{0,number}`, `{0,number,integer}`, `{0,number,percent}`,
+///   `{0,number,currency}`, or `{0,number,#,##0.00}` with a [DecimalFormat]
+///   pattern.
+/// - `{0,date}` and `{0,time}`, optionally followed by `short`, `medium`,
+///   `long` or `full`, or by a `SimpleDateFormat` pattern:
+///   `{0,date,yyyy-MM-dd}`. The device's own `java.text.DateFormat` does the
+///   formatting, so the named styles produce what the device produces.
+/// - `{0,choice,0#none|1#one|1<{0} items}` with a [ChoiceFormat] pattern.
+///   If the chosen text has elements of its own, they are formatted against
+///   the same arguments.
+///
+/// A single quote makes the characters up to the next one literal, which is
+/// how a `{` is written (`'{'`), and two quotes in a row stand for one. An
+/// apostrophe in a message must therefore be doubled: `it''s`.
+///
+/// An argument that is `null` is written as `null`, and an element whose
+/// index is past the end of the arguments is written back as it was, `{2}`.
+///
+/// #### Differences from the JDK
+///
+/// - `toPattern` returns the elements as they were written rather than a
+///   canonical rewrite of them.
+/// - Date and time elements ignore the locale passed to the constructor: the
+///   device formats dates for its own locale only.
+public class MessageFormat extends Format {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final int TYPE_NONE = 0;
+    private static final int TYPE_NUMBER = 1;
+    private static final int TYPE_DATE = 2;
+    private static final int TYPE_TIME = 3;
+    private static final int TYPE_CHOICE = 4;
+
+    private Locale locale;
+
+    /// The literal text before each element, and after the last one: always
+    /// one longer than the element arrays.
+    private String[] literals = new String[] {""};
+    private int[] argumentNumbers = new int[0];
+    private Format[] formats = new Format[0];
+    private String[] elementTexts = new String[0];
+
+    public MessageFormat(String pattern) {
+        this(pattern, Locale.getDefault());
+    }
+
+    public MessageFormat(String pattern, Locale locale) {
+        this.locale = locale;
+        parsePattern(pattern);
+    }
+
+    public void setLocale(Locale locale) {
+        this.locale = locale;
+    }
+
+    public Locale getLocale() {
+        return locale;
+    }
+
+    public void applyPattern(String pattern) {
+        parsePattern(pattern);
+    }
+
+    private void parsePattern(String pattern) {
+        List<String> newLiterals = new ArrayList<String>();
+        List<Integer> newNumbers = new ArrayList<Integer>();
+        List<Format> newFormats = new ArrayList<Format>();
+        List<String> newTexts = new ArrayList<String>();
+        StringBuilder raw = new StringBuilder();
+        // The parts of the element being read: index, type, style.
+        StringBuilder[] parts = new StringBuilder[3];
+        int part = -1;
+        boolean inQuote = false;
+        int braceDepth = 0;
+        for (int i = 0; i < pattern.length(); i++) {
+            char ch = pattern.charAt(i);
+            if (part < 0) {
+                if (ch == '\'') {
+                    if (i + 1 < pattern.length() && pattern.charAt(i + 1) == '\'') {
+                        raw.append(ch);
+                        i++;
+                    } else {
+                        inQuote = !inQuote;
+                    }
+                } else if (ch == '{' && !inQuote) {
+                    part = 0;
+                    parts[0] = new StringBuilder();
+                    parts[1] = null;
+                    parts[2] = null;
+                } else {
+                    raw.append(ch);
+                }
+                continue;
+            }
+            if (inQuote) {
+                // Inside an element the quotes are the sub-pattern's own.
+                parts[part].append(ch);
+                if (ch == '\'') {
+                    inQuote = false;
+                }
+                continue;
+            }
+            if (ch == ',') {
+                if (part < 2) {
+                    part++;
+                    parts[part] = new StringBuilder();
+                } else {
+                    parts[part].append(ch);
+                }
+            } else if (ch == '{') {
+                braceDepth++;
+                parts[part].append(ch);
+            } else if (ch == '}') {
+                if (braceDepth == 0) {
+                    newLiterals.add(raw.toString());
+                    raw.setLength(0);
+                    String type = parts[1] == null ? "" : parts[1].toString();
+                    String style = parts[2] == null ? "" : parts[2].toString();
+                    int number = parseArgumentNumber(parts[0].toString());
+                    newNumbers.add(Integer.valueOf(number));
+                    Format made = makeFormat(type, style);
+                    newFormats.add(made);
+                    newTexts.add(number + describe(typeOf(type), style, made));
+                    part = -1;
+                } else {
+                    braceDepth--;
+                    parts[part].append(ch);
+                }
+            } else if (ch == ' ') {
+                // Leading spaces of the type are not part of it.
+                if (part != 1 || parts[1].length() > 0) {
+                    parts[part].append(ch);
+                }
+            } else {
+                if (ch == '\'') {
+                    inQuote = true;
+                }
+                parts[part].append(ch);
+            }
+        }
+        // Only an element left open at depth zero is refused. A pattern that
+        // ends inside a NESTED brace ("{0,choice,0#{") is accepted by every
+        // JDK from 8 to 25 -- java.text.MessageFormat tests braceStack == 0
+        // at this point too -- so refusing it would reject what the desktop
+        // accepts. MessageFormatDifferentialTest.rejectsWhatTheJdkRejects
+        // holds both sides to it.
+        if (braceDepth == 0 && part >= 0) {
+            throw new IllegalArgumentException("Unmatched braces in the pattern.");
+        }
+        newLiterals.add(raw.toString());
+        int n = newNumbers.size();
+        literals = newLiterals.toArray(new String[newLiterals.size()]);
+        argumentNumbers = new int[n];
+        for (int i = 0; i < n; i++) {
+            argumentNumbers[i] = newNumbers.get(i).intValue();
+        }
+        formats = newFormats.toArray(new Format[n]);
+        elementTexts = newTexts.toArray(new String[n]);
+    }
+
+    private static int parseArgumentNumber(String text) {
+        boolean negative = text.startsWith("-");
+        int from = negative ? 1 : 0;
+        if (text.length() == from || text.length() - from > 9) {
+            throw new IllegalArgumentException("can't parse argument number: " + text);
+        }
+        int value = 0;
+        for (int i = from; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                throw new IllegalArgumentException("can't parse argument number: " + text);
+            }
+            value = value * 10 + (c - '0');
+        }
+        if (negative) {
+            throw new IllegalArgumentException("negative argument number: " + text);
+        }
+        return value;
+    }
+
+    private static int typeOf(String type) {
+        String t = type.trim();
+        if (t.length() == 0) {
+            return TYPE_NONE;
+        }
+        if (t.equalsIgnoreCase("number")) {
+            return TYPE_NUMBER;
+        }
+        if (t.equalsIgnoreCase("date")) {
+            return TYPE_DATE;
+        }
+        if (t.equalsIgnoreCase("time")) {
+            return TYPE_TIME;
+        }
+        if (t.equalsIgnoreCase("choice")) {
+            return TYPE_CHOICE;
+        }
+        throw new IllegalArgumentException("unknown format type: " + type);
+    }
+
+    /// The date style a keyword names, or -1 when the text is a pattern.
+    private static int dateStyle(String style) {
+        String s = style.trim();
+        if (s.length() == 0) {
+            return DateFormat.DEFAULT;
+        }
+        if (s.equalsIgnoreCase("short")) {
+            return DateFormat.SHORT;
+        }
+        if (s.equalsIgnoreCase("medium")) {
+            return DateFormat.DEFAULT;
+        }
+        if (s.equalsIgnoreCase("long")) {
+            return DateFormat.LONG;
+        }
+        if (s.equalsIgnoreCase("full")) {
+            return DateFormat.FULL;
+        }
+        return -1;
+    }
+
+    private Format makeFormat(String type, String style) {
+        int kind = typeOf(type);
+        String keyword = style.trim();
+        if (kind == TYPE_NUMBER) {
+            if (keyword.length() == 0) {
+                return NumberFormat.getInstance(locale);
+            }
+            if (keyword.equalsIgnoreCase("currency")) {
+                return NumberFormat.getCurrencyInstance(locale);
+            }
+            if (keyword.equalsIgnoreCase("percent")) {
+                return NumberFormat.getPercentInstance(locale);
+            }
+            if (keyword.equalsIgnoreCase("integer")) {
+                return NumberFormat.getIntegerInstance(locale);
+            }
+            return new DecimalFormat(style, DecimalFormatSymbols.getInstance(locale));
+        }
+        if (kind == TYPE_DATE) {
+            int dateStyle = dateStyle(style);
+            return dateStyle >= 0 ? DateFormat.getDateInstance(dateStyle) : new SimpleDateFormat(style);
+        }
+        if (kind == TYPE_TIME) {
+            int timeStyle = dateStyle(style);
+            return timeStyle >= 0 ? DateFormat.getTimeInstance(timeStyle) : new SimpleDateFormat(style);
+        }
+        if (kind == TYPE_CHOICE) {
+            try {
+                return new ChoiceFormat(style);
+            } catch (IllegalArgumentException e) {
+                throw new IllegalArgumentException("Choice Pattern incorrect: " + style);
+            }
+        }
+        return null;
+    }
+
+    /// The type and style of an element as `toPattern` writes them: not the
+    /// text that was read but, as in the JDK, a description of the format it
+    /// produced -- `{0, number, #.##}` comes back as `{0,number,#0.##}`.
+    private String describe(int kind, String style, Format made) {
+        if (kind == TYPE_NUMBER) {
+            if (made.equals(NumberFormat.getInstance(locale))) {
+                return ",number";
+            }
+            if (made.equals(NumberFormat.getCurrencyInstance(locale))) {
+                return ",number,currency";
+            }
+            if (made.equals(NumberFormat.getPercentInstance(locale))) {
+                return ",number,percent";
+            }
+            if (made.equals(NumberFormat.getIntegerInstance(locale))) {
+                return ",number,integer";
+            }
+            return made instanceof DecimalFormat ? ",number," + ((DecimalFormat) made).toPattern() : ",number";
+        }
+        if (kind == TYPE_CHOICE) {
+            return made instanceof ChoiceFormat ? ",choice," + ((ChoiceFormat) made).toPattern() : ",choice";
+        }
+        if (kind == TYPE_DATE || kind == TYPE_TIME) {
+            String name = kind == TYPE_DATE ? ",date" : ",time";
+            int dateStyle = dateStyle(style);
+            if (dateStyle == DateFormat.SHORT) {
+                return name + ",short";
+            }
+            if (dateStyle == DateFormat.LONG) {
+                return name + ",long";
+            }
+            if (dateStyle == DateFormat.FULL) {
+                return name + ",full";
+            }
+            // A pattern of either type is a date pattern to the JDK.
+            return dateStyle >= 0 ? name : ",date," + style;
+        }
+        return "";
+    }
+
+    private static void appendLiteral(StringBuilder out, String text) {
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == '\'') {
+                out.append("''");
+            } else if (c == '{') {
+                out.append("'{'");
+            } else {
+                out.append(c);
+            }
+        }
+    }
+
+    public String toPattern() {
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            appendLiteral(out, literals[i]);
+            out.append('{').append(elementTexts[i]).append('}');
+        }
+        appendLiteral(out, literals[argumentNumbers.length]);
+        return out.toString();
+    }
+
+    public static String format(String pattern, Object... arguments) {
+        return new MessageFormat(pattern).format(arguments);
+    }
+
+    /// Formats an array of arguments, which `arguments` must be.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `arguments` is not an `Object[]`, or
+    ///   an argument is not of the type its element formats
+    @Override
+    public final StringBuffer format(Object arguments, StringBuffer result, FieldPosition pos) {
+        if (arguments == null || arguments instanceof Object[]) {
+            return format((Object[]) arguments, result, pos);
+        }
+        throw new IllegalArgumentException("The arguments of a message are an Object[]");
+    }
+
+    public final StringBuffer format(Object[] arguments, StringBuffer result, FieldPosition pos) {
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            result.append(literals[i]);
+            int number = argumentNumbers[i];
+            if (arguments == null || number >= arguments.length) {
+                result.append('{').append(number).append('}');
+                continue;
+            }
+            Object argument = arguments[number];
+            Format format = formats[i];
+            if (argument == null) {
+                result.append("null");
+            } else if (format instanceof ChoiceFormat) {
+                String chosen = ((ChoiceFormat) format).format(argument);
+                if (chosen.indexOf('{') >= 0) {
+                    new MessageFormat(chosen, locale).format(arguments, result, pos);
+                } else {
+                    result.append(chosen);
+                }
+            } else if (format instanceof NumberFormat) {
+                result.append(((NumberFormat) format).format(argument));
+            } else if (format instanceof DateFormat) {
+                result.append(formatDate((DateFormat) format, argument));
+            } else if (format != null) {
+                result.append(format.format(argument));
+            } else if (argument instanceof Number) {
+                result.append(NumberFormat.getInstance(locale).format(argument));
+            } else if (argument instanceof Date) {
+                DateFormat dateTime = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
+                result.append(dateTime.format((Date) argument));
+            } else if (argument instanceof String) {
+                result.append((String) argument);
+            } else {
+                result.append(String.valueOf(argument.toString()));
+            }
+        }
+        result.append(literals[argumentNumbers.length]);
+        return result;
+    }
+
+    private static String formatDate(DateFormat format, Object argument) {
+        if (argument instanceof Date) {
+            return format.format((Date) argument);
+        }
+        if (argument instanceof Number) {
+            return format.format(new Date(((Number) argument).longValue()));
+        }
+        throw new IllegalArgumentException("Cannot format given Object as a Date");
+    }
+
+    /// The formats of the elements, in the order the elements appear in the
+    /// pattern; `null` for an element that has none.
+    public Format[] getFormats() {
+        Format[] copy = new Format[formats.length];
+        System.arraycopy(formats, 0, copy, 0, formats.length);
+        return copy;
+    }
+
+    /// The formats of the arguments, indexed by argument number; `null` for
+    /// an argument no element formats. Where several elements name the same
+    /// argument, the last one's format is the one returned.
+    public Format[] getFormatsByArgumentIndex() {
+        Format[] result = new Format[maximumArgumentNumber() + 1];
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            result[argumentNumbers[i]] = formats[i];
+        }
+        return result;
+    }
+
+    private int maximumArgumentNumber() {
+        int max = -1;
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            max = Math.max(max, argumentNumbers[i]);
+        }
+        return max;
+    }
+
+    /// Sets the format of the element at `formatElementIndex`, counted in
+    /// the order the elements appear in the pattern.
+    ///
+    /// #### Throws
+    ///
+    /// - `ArrayIndexOutOfBoundsException`: if there is no such element
+    public void setFormat(int formatElementIndex, Format newFormat) {
+        if (formatElementIndex < 0 || formatElementIndex >= formats.length) {
+            throw new ArrayIndexOutOfBoundsException(formatElementIndex);
+        }
+        formats[formatElementIndex] = newFormat;
+        elementTexts[formatElementIndex] = argumentNumbers[formatElementIndex] + describeFormat(newFormat);
+    }
+
+    /// Sets the formats of the elements in pattern order; extra formats are
+    /// ignored and elements past the end of `newFormats` are left alone.
+    public void setFormats(Format[] newFormats) {
+        int n = Math.min(newFormats.length, formats.length);
+        for (int i = 0; i < n; i++) {
+            setFormat(i, newFormats[i]);
+        }
+    }
+
+    /// Sets the format of every element that formats argument
+    /// `argumentIndex`.
+    public void setFormatByArgumentIndex(int argumentIndex, Format newFormat) {
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            if (argumentNumbers[i] == argumentIndex) {
+                setFormat(i, newFormat);
+            }
+        }
+    }
+
+    /// Sets the formats of the arguments, indexed by argument number.
+    public void setFormatsByArgumentIndex(Format[] newFormats) {
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            if (argumentNumbers[i] < newFormats.length) {
+                setFormat(i, newFormats[argumentNumbers[i]]);
+            }
+        }
+    }
+
+    /// How `toPattern` writes an element whose format was set rather than
+    /// read from the pattern: as the JDK does, by recognising the format.
+    private String describeFormat(Format f) {
+        if (f instanceof ChoiceFormat) {
+            return describe(TYPE_CHOICE, "", f);
+        }
+        if (f instanceof NumberFormat) {
+            return describe(TYPE_NUMBER, "", f);
+        }
+        if (f instanceof DateFormat) {
+            String[] names = {",short", "", ",long", ",full"};
+            int[] styles = {DateFormat.SHORT, DateFormat.MEDIUM, DateFormat.LONG, DateFormat.FULL};
+            for (int i = 0; i < styles.length; i++) {
+                if (f.equals(DateFormat.getDateInstance(styles[i]))) {
+                    return ",date" + names[i];
+                }
+                if (f.equals(DateFormat.getTimeInstance(styles[i]))) {
+                    return ",time" + names[i];
+                }
+            }
+            if (f instanceof SimpleDateFormat) {
+                return ",date," + ((SimpleDateFormat) f).toPattern();
+            }
+        }
+        return "";
+    }
+
+    /// Reads the arguments back out of `source`, starting at `pos`: the
+    /// literal text must match exactly, an element with a format is read by
+    /// that format, and an element without one takes the text up to the
+    /// literal that follows it. The result is indexed by argument number. On
+    /// failure `pos` is left alone, its error index is set, and `null` is
+    /// returned.
+    public Object[] parse(String source, ParsePosition pos) {
+        if (source == null) {
+            return new Object[0];
+        }
+        Object[] result = new Object[maximumArgumentNumber() + 1];
+        int at = pos.getIndex();
+        ParsePosition inner = new ParsePosition(0);
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            String literal = literals[i];
+            if (!source.regionMatches(at, literal, 0, literal.length())) {
+                pos.setErrorIndex(at);
+                return null;
+            }
+            at += literal.length();
+            Format format = formats[i];
+            if (format == null) {
+                // The text runs to the literal after this element; with
+                // none, to the end of the source.
+                String next = literals[i + 1];
+                int end = next.length() == 0 ? source.length() : source.indexOf(next, at);
+                if (end < 0) {
+                    pos.setErrorIndex(at);
+                    return null;
+                }
+                String value = source.substring(at, end);
+                if (!value.equals("{" + argumentNumbers[i] + "}")) {
+                    result[argumentNumbers[i]] = value;
+                }
+                at = end;
+            } else {
+                inner.setIndex(at);
+                Object value = format.parseObject(source, inner);
+                if (inner.getIndex() == at) {
+                    pos.setErrorIndex(at);
+                    return null;
+                }
+                result[argumentNumbers[i]] = value;
+                at = inner.getIndex();
+            }
+        }
+        String last = literals[argumentNumbers.length];
+        if (!source.regionMatches(at, last, 0, last.length())) {
+            pos.setErrorIndex(at);
+            return null;
+        }
+        pos.setIndex(at + last.length());
+        return result;
+    }
+
+    /// Reads the arguments back out of the beginning of `source`.
+    ///
+    /// #### Throws
+    ///
+    /// - `ParseException`: if `source` does not match the pattern
+    public Object[] parse(String source) throws ParseException {
+        ParsePosition pos = new ParsePosition(0);
+        Object[] result = parse(source, pos);
+        if (pos.getIndex() == 0) {
+            throw new ParseException("MessageFormat parse error!", pos.getErrorIndex());
+        }
+        return result;
+    }
+
+    @Override
+    public Object parseObject(String source, ParsePosition pos) {
+        return parse(source, pos);
+    }
+
+    /// A copy of this format, built by applying its pattern again:
+    /// `Object.clone()` answers `null` on the device for anything but an
+    /// array.
+    @Override
+    public Object clone() {
+        return new MessageFormat(toPattern(), locale);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass() || !(obj instanceof MessageFormat)) {
+            return false;
+        }
+        MessageFormat other = (MessageFormat) obj;
+        if (locale == null ? other.locale != null : !locale.equals(other.locale)) {
+            return false;
+        }
+        return toPattern().equals(other.toPattern());
+    }
+
+    @Override
+    public int hashCode() {
+        return toPattern().hashCode();
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/NumberFormat.java b/Ports/CLDC11/src/java/text/NumberFormat.java
new file mode 100644
index 00000000000..2ca8abdca38
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/NumberFormat.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+import java.util.Locale;
+
+/// The base of the number formats, and the factory for the usual ones.
+///
+/// The factory methods answer a [DecimalFormat] with these patterns:
+///
+/// - `getInstance` / `getNumberInstance`: `#,##0.###`
+/// - `getIntegerInstance`: `#,##0`, rounding to a whole number and parsing
+///   only the integer part
+/// - `getPercentInstance`: `#,##0%`
+/// - `getCurrencyInstance`: the currency symbol followed by `#,##0.00`, and a
+///   minus sign before the symbol for a negative amount
+///
+/// The separators and the currency symbol are those of
+/// [DecimalFormatSymbols]; read there how a locale is honoured.
+///
+/// #### Differences from the JDK
+///
+/// - Rounding is always half-even, the JDK's default. There is no
+///   `setRoundingMode`, as the device has no `java.math.RoundingMode`.
+/// - There is no `getCurrency`/`setCurrency`, as the device has no
+///   `java.util.Currency`.
+public abstract class NumberFormat extends Format {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Names the integer part of a formatted number to a [FieldPosition].
+    public static final int INTEGER_FIELD = 0;
+
+    /// Names the fraction part of a formatted number to a [FieldPosition].
+    public static final int FRACTION_FIELD = 1;
+
+    private boolean groupingUsed = true;
+    private int maximumIntegerDigits = 40;
+    private int minimumIntegerDigits = 1;
+    private int maximumFractionDigits = 3;
+    private int minimumFractionDigits;
+    private boolean parseIntegerOnly;
+
+    protected NumberFormat() {
+    }
+
+    public static final NumberFormat getInstance() {
+        return getNumberInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getInstance(Locale inLocale) {
+        return getNumberInstance(inLocale);
+    }
+
+    public static final NumberFormat getNumberInstance() {
+        return getNumberInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getNumberInstance(Locale inLocale) {
+        return new DecimalFormat("#,##0.###", DecimalFormatSymbols.getInstance(inLocale));
+    }
+
+    public static final NumberFormat getIntegerInstance() {
+        return getIntegerInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getIntegerInstance(Locale inLocale) {
+        DecimalFormat format = new DecimalFormat("#,##0", DecimalFormatSymbols.getInstance(inLocale));
+        format.setParseIntegerOnly(true);
+        return format;
+    }
+
+    public static final NumberFormat getPercentInstance() {
+        return getPercentInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getPercentInstance(Locale inLocale) {
+        return new DecimalFormat("#,##0%", DecimalFormatSymbols.getInstance(inLocale));
+    }
+
+    public static final NumberFormat getCurrencyInstance() {
+        return getCurrencyInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getCurrencyInstance(Locale inLocale) {
+        String pattern = DecimalFormat.CURRENCY_SIGN + "#,##0.00";
+        return new DecimalFormat(pattern, DecimalFormatSymbols.getInstance(inLocale));
+    }
+
+    /// Formats a `Number`: an integral type as a `long`, anything else as a
+    /// `double`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `number` is not a `Number`
+    @Override
+    public StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos) {
+        if (number instanceof Long || number instanceof Integer || number instanceof Short
+                || number instanceof Byte) {
+            return format(((Number) number).longValue(), toAppendTo, pos);
+        }
+        if (number instanceof Number) {
+            return format(((Number) number).doubleValue(), toAppendTo, pos);
+        }
+        throw new IllegalArgumentException("Cannot format given Object as a Number");
+    }
+
+    public final String format(double number) {
+        return format(number, new StringBuffer(), new FieldPosition(0)).toString();
+    }
+
+    public final String format(long number) {
+        return format(number, new StringBuffer(), new FieldPosition(0)).toString();
+    }
+
+    public abstract StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos);
+
+    public abstract StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos);
+
+    /// Parses a number starting at `parsePosition`, which is advanced past
+    /// what was read. On failure the position is left alone, its error index
+    /// is set, and `null` is returned. The result is a `Long` when the text is
+    /// a whole number that fits one, and a `Double` otherwise.
+    public abstract Number parse(String source, ParsePosition parsePosition);
+
+    public Number parse(String source) throws ParseException {
+        ParsePosition parsePosition = new ParsePosition(0);
+        Number result = parse(source, parsePosition);
+        if (parsePosition.getIndex() == 0) {
+            throw new ParseException("Unparseable number: \"" + source + "\"", parsePosition.getErrorIndex());
+        }
+        return result;
+    }
+
+    @Override
+    public final Object parseObject(String source, ParsePosition pos) {
+        return parse(source, pos);
+    }
+
+    public boolean isParseIntegerOnly() {
+        return parseIntegerOnly;
+    }
+
+    public void setParseIntegerOnly(boolean value) {
+        parseIntegerOnly = value;
+    }
+
+    public boolean isGroupingUsed() {
+        return groupingUsed;
+    }
+
+    public void setGroupingUsed(boolean newValue) {
+        groupingUsed = newValue;
+    }
+
+    public int getMaximumIntegerDigits() {
+        return maximumIntegerDigits;
+    }
+
+    public void setMaximumIntegerDigits(int newValue) {
+        maximumIntegerDigits = Math.max(0, newValue);
+        if (minimumIntegerDigits > maximumIntegerDigits) {
+            minimumIntegerDigits = maximumIntegerDigits;
+        }
+    }
+
+    public int getMinimumIntegerDigits() {
+        return minimumIntegerDigits;
+    }
+
+    public void setMinimumIntegerDigits(int newValue) {
+        minimumIntegerDigits = Math.max(0, newValue);
+        if (minimumIntegerDigits > maximumIntegerDigits) {
+            maximumIntegerDigits = minimumIntegerDigits;
+        }
+    }
+
+    public int getMaximumFractionDigits() {
+        return maximumFractionDigits;
+    }
+
+    public void setMaximumFractionDigits(int newValue) {
+        maximumFractionDigits = Math.max(0, newValue);
+        if (maximumFractionDigits < minimumFractionDigits) {
+            minimumFractionDigits = maximumFractionDigits;
+        }
+    }
+
+    public int getMinimumFractionDigits() {
+        return minimumFractionDigits;
+    }
+
+    public void setMinimumFractionDigits(int newValue) {
+        minimumFractionDigits = Math.max(0, newValue);
+        if (maximumFractionDigits < minimumFractionDigits) {
+            maximumFractionDigits = minimumFractionDigits;
+        }
+    }
+
+    /// Copies the settings this class holds into `target`, for the `clone`
+    /// of a subclass: `Object.clone()` answers `null` on the device.
+    final void copyNumberFormatTo(NumberFormat target) {
+        target.groupingUsed = groupingUsed;
+        target.maximumIntegerDigits = maximumIntegerDigits;
+        target.minimumIntegerDigits = minimumIntegerDigits;
+        target.maximumFractionDigits = maximumFractionDigits;
+        target.minimumFractionDigits = minimumFractionDigits;
+        target.parseIntegerOnly = parseIntegerOnly;
+    }
+
+    /// A copy of this format. Every subclass in this package implements it
+    /// by copying its fields.
+    @Override
+    public abstract Object clone();
+
+    @Override
+    public int hashCode() {
+        return maximumIntegerDigits * 37 + maximumFractionDigits;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        if (getClass() != obj.getClass() || !(obj instanceof NumberFormat)) {
+            return false;
+        }
+        NumberFormat other = (NumberFormat) obj;
+        return maximumIntegerDigits == other.maximumIntegerDigits
+                && minimumIntegerDigits == other.minimumIntegerDigits
+                && maximumFractionDigits == other.maximumFractionDigits
+                && minimumFractionDigits == other.minimumFractionDigits
+                && groupingUsed == other.groupingUsed
+                && parseIntegerOnly == other.parseIntegerOnly;
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/ParsePosition.java b/Ports/CLDC11/src/java/text/ParsePosition.java
new file mode 100644
index 00000000000..7f3327e3c36
--- /dev/null
+++ b/Ports/CLDC11/src/java/text/ParsePosition.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Where a parse starts, where it stopped, and where it failed.
+public class ParsePosition {
+
+    private int index;
+    private int errorIndex = -1;
+
+    public ParsePosition(int index) {
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public void setIndex(int index) {
+        this.index = index;
+    }
+
+    public void setErrorIndex(int ei) {
+        errorIndex = ei;
+    }
+
+    public int getErrorIndex() {
+        return errorIndex;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof ParsePosition)) {
+            return false;
+        }
+        ParsePosition other = (ParsePosition) obj;
+        return index == other.index && errorIndex == other.errorIndex;
+    }
+
+    @Override
+    public int hashCode() {
+        return (errorIndex << 16) | index;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[index=" + index + ",errorIndex=" + errorIndex + ']';
+    }
+}
diff --git a/Ports/CLDC11/src/java/text/SimpleDateFormat.java b/Ports/CLDC11/src/java/text/SimpleDateFormat.java
index 485b17502ed..810a35dd5b2 100644
--- a/Ports/CLDC11/src/java/text/SimpleDateFormat.java
+++ b/Ports/CLDC11/src/java/text/SimpleDateFormat.java
@@ -354,12 +354,20 @@ String leftPad(int v, int size) {
 	 */
 	@Override
 	public Date parse(String source) throws ParseException {
+		return parseAt(source, 0, null);
+	}
+
+	@Override
+	Date parseAt(String source, int start, int[] end) throws ParseException {
 		if (pattern == null) {
-			return super.parse(source);
+			return super.parseAt(source, start, end);
 		}
-		int startIndex = 0;
+		int startIndex = start;
 		// parse based on GMT timezone for handling offsets
 		Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone(GMT));
+		// A field the pattern does not parse takes its value from the epoch,
+		// 1970-01-01 00:00:00.000, as in the JDK -- never from the current time.
+		calendar.setTime(new Date(0L));
 		int tzMinutes = -1;
 		List<String> pattern = getPatternTokens();
 		for (int i = 0; i < pattern.size(); i++) {
@@ -452,6 +460,9 @@ public Date parse(String source) throws ParseException {
 				startIndex += s.length();
 			}
 		}
+		if (end != null) {
+			end[0] = startIndex;
+		}
 		TimeZone localTimezone = Calendar.getInstance().getTimeZone();
 		calendar.setTimeZone(localTimezone);
 		// If timezone offset not part of date, the date passed will be treated
@@ -616,7 +627,7 @@ String readNumber(String source, int ofs, String token, boolean adjacent) {
 			char ch = source.charAt(i);
 			if (isNumeric(ch) == false) {
 				// empty string would be invalid number
-				if (i == 0) {
+				if (i == ofs) {
 					return null;
 				}
 				return source.substring(ofs, i);
@@ -789,7 +800,7 @@ String readMonth(String source, int ofs, String token, boolean adjacent) {
 			if (adjacent) {
 				return source.substring(ofs, ofs + token.length());
 			}
-			if (isNumeric(source.charAt(0))) {
+			if (ofs < source.length() && isNumeric(source.charAt(ofs))) {
 				return readNumber(source, ofs, token, adjacent);
 			}
 		}
@@ -834,6 +845,9 @@ String readMonth(String source, int ofs, String token, boolean adjacent) {
 	///
 	/// - DateFormatSymbols
 	int parseMonth(String month, int offset) throws ParseException {
+		if (month == null) {
+			throwInvalid("month", offset);
+		}
 		if (month.length() < 3) {
 			return (parseNumber(month, offset, "month", 1, 12) - 1) + Calendar.JANUARY;
 		}
diff --git a/Ports/CLDC11/src/java/time/Clock.java b/Ports/CLDC11/src/java/time/Clock.java
index 85d04e71d48..c6e942aeecf 100644
--- a/Ports/CLDC11/src/java/time/Clock.java
+++ b/Ports/CLDC11/src/java/time/Clock.java
@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 public abstract class Clock {
@@ -5,6 +27,9 @@ public abstract class Clock {
 
     public abstract Instant instant();
 
+    /// This clock, reporting its instants in `zone`.
+    public abstract Clock withZone(ZoneId zone);
+
     public long millis() {
         return instant().toEpochMilli();
     }
@@ -17,10 +42,32 @@ public static Clock systemDefaultZone() {
         return new SystemClock(ZoneId.systemDefault());
     }
 
+    /// The system clock, seen in `zone`.
+    public static Clock system(ZoneId zone) {
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return new SystemClock(zone);
+    }
+
     public static Clock fixed(Instant fixedInstant, ZoneId zone) {
         return new FixedClock(fixedInstant, zone);
     }
 
+    /// A clock that reads `base` moved on by `offsetDuration`.
+    public static Clock offset(Clock base, Duration offsetDuration) {
+        if (base == null) {
+            throw new NullPointerException("baseClock");
+        }
+        if (offsetDuration == null) {
+            throw new NullPointerException("offsetDuration");
+        }
+        if (offsetDuration.isZero()) {
+            return base;
+        }
+        return new OffsetClock(base, offsetDuration);
+    }
+
     private static final class SystemClock extends Clock {
         private final ZoneId zone;
 
@@ -35,6 +82,22 @@ public ZoneId getZone() {
         public Instant instant() {
             return Instant.now();
         }
+
+        public Clock withZone(ZoneId zone) {
+            return zone.equals(this.zone) ? this : new SystemClock(zone);
+        }
+
+        public boolean equals(Object obj) {
+            return obj instanceof SystemClock && zone.equals(((SystemClock) obj).zone);
+        }
+
+        public int hashCode() {
+            return zone.hashCode() + 1;
+        }
+
+        public String toString() {
+            return "SystemClock[" + zone + "]";
+        }
     }
 
     private static final class FixedClock extends Clock {
@@ -53,5 +116,63 @@ public ZoneId getZone() {
         public Instant instant() {
             return instant;
         }
+
+        public Clock withZone(ZoneId zone) {
+            return zone.equals(this.zone) ? this : new FixedClock(instant, zone);
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof FixedClock)) {
+                return false;
+            }
+            FixedClock other = (FixedClock) obj;
+            return instant.equals(other.instant) && zone.equals(other.zone);
+        }
+
+        public int hashCode() {
+            return instant.hashCode() ^ zone.hashCode();
+        }
+
+        public String toString() {
+            return "FixedClock[" + instant + "," + zone + "]";
+        }
+    }
+
+    private static final class OffsetClock extends Clock {
+        private final Clock base;
+        private final Duration offset;
+
+        private OffsetClock(Clock base, Duration offset) {
+            this.base = base;
+            this.offset = offset;
+        }
+
+        public ZoneId getZone() {
+            return base.getZone();
+        }
+
+        public Instant instant() {
+            return base.instant().plus(offset);
+        }
+
+        public Clock withZone(ZoneId zone) {
+            return zone.equals(base.getZone()) ? this : new OffsetClock(base.withZone(zone), offset);
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof OffsetClock)) {
+                return false;
+            }
+            OffsetClock other = (OffsetClock) obj;
+            return base.equals(other.base) && offset.equals(other.offset);
+        }
+
+        public int hashCode() {
+            return base.hashCode() ^ offset.hashCode();
+        }
+
+        public String toString() {
+            return "OffsetClock[" + base + "," + offset + "]";
+        }
     }
 }
diff --git a/Ports/CLDC11/src/java/time/DateTimeSupport.java b/Ports/CLDC11/src/java/time/DateTimeSupport.java
index ff219a6e3f2..d3e4b356d15 100644
--- a/Ports/CLDC11/src/java/time/DateTimeSupport.java
+++ b/Ports/CLDC11/src/java/time/DateTimeSupport.java
@@ -1,225 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Date;
-import java.util.Locale;
 import java.util.TimeZone;
 
+/// Where `java.time` meets the platform's time zone rules.
 final class DateTimeSupport {
-    static final long MILLIS_PER_SECOND = 1000L;
-    static final long MILLIS_PER_DAY = 86400000L;
-    static final long SECONDS_PER_DAY = 86400L;
-    static final long NANOS_PER_SECOND = 1000000000L;
-    static final long NANOS_PER_MILLI = 1000000L;
-    static final long NANOS_PER_DAY = 86400000000000L;
-
-    private static final long DAYS_0000_TO_1970 = 719528L;
-
     private DateTimeSupport() {
     }
 
-    static int floorDiv(int x, int y) {
-        int r = x / y;
-        if ((x ^ y) < 0 && (r * y != x)) {
-            r--;
-        }
-        return r;
-    }
-
-    static long floorDiv(long x, long y) {
-        long r = x / y;
-        if ((x ^ y) < 0 && (r * y != x)) {
-            r--;
-        }
-        return r;
-    }
-
-    static int floorMod(int x, int y) {
-        return x - floorDiv(x, y) * y;
-    }
-
-    static long floorMod(long x, long y) {
-        return x - floorDiv(x, y) * y;
-    }
-
-    static boolean isLeapYear(int year) {
-        return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
-    }
-
-    static int lengthOfMonth(int year, int month) {
-        switch (month) {
-            case 2:
-                return isLeapYear(year) ? 29 : 28;
-            case 4:
-            case 6:
-            case 9:
-            case 11:
-                return 30;
-            default:
-                return 31;
-        }
-    }
-
-    static long toEpochDay(int year, int month, int dayOfMonth) {
-        long y = year;
-        long m = month;
-        long total = 365L * y;
-        if (y >= 0) {
-            total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;
-        } else {
-            total -= y / -4 - y / -100 + y / -400;
-        }
-        total += ((367 * m - 362) / 12);
-        total += dayOfMonth - 1;
-        if (m > 2) {
-            total--;
-            if (!isLeapYear(year)) {
-                total--;
-            }
-        }
-        return total - DAYS_0000_TO_1970;
-    }
-
-    static int[] epochDayToDate(long epochDay) {
-        long zeroDay = epochDay + DAYS_0000_TO_1970;
-        zeroDay -= 60;
-        long adjust = 0;
-        if (zeroDay < 0) {
-            long adjustCycles = (zeroDay + 1) / 146097 - 1;
-            adjust = adjustCycles * 400;
-            zeroDay += -adjustCycles * 146097;
-        }
-        long yearEst = (400 * zeroDay + 591) / 146097;
-        long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
-        if (doyEst < 0) {
-            yearEst--;
-            doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
-        }
-        yearEst += adjust;
-        int marchDoy0 = (int) doyEst;
-        int marchMonth0 = (marchDoy0 * 5 + 2) / 153;
-        int month = (marchMonth0 + 2) % 12 + 1;
-        int day = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;
-        yearEst += marchMonth0 / 10;
-        return new int[] { (int) yearEst, month, day };
-    }
-
-    static void checkDate(int year, int month, int day) {
-        if (month < 1 || month > 12) {
-            throw new IllegalArgumentException("Invalid month: " + month);
-        }
-        int maxDay = lengthOfMonth(year, month);
-        if (day < 1 || day > maxDay) {
-            throw new IllegalArgumentException("Invalid day: " + day);
-        }
-    }
-
-    static void checkTime(int hour, int minute, int second, int nano) {
-        if (hour < 0 || hour > 23) {
-            throw new IllegalArgumentException("Invalid hour: " + hour);
-        }
-        if (minute < 0 || minute > 59) {
-            throw new IllegalArgumentException("Invalid minute: " + minute);
-        }
-        if (second < 0 || second > 59) {
-            throw new IllegalArgumentException("Invalid second: " + second);
-        }
-        if (nano < 0 || nano >= NANOS_PER_SECOND) {
-            throw new IllegalArgumentException("Invalid nano: " + nano);
-        }
-    }
-
-    static long toEpochSecond(LocalDate date, LocalTime time, ZoneOffset offset) {
-        long days = date.toEpochDay();
-        long secs = days * SECONDS_PER_DAY + time.toSecondOfDay();
-        return secs - offset.getTotalSeconds();
-    }
-
-    static int millisOfSecond(int nano) {
-        return nano / 1000000;
-    }
-
-    static Calendar newCalendar(TimeZone tz) {
-        Calendar out = Calendar.getInstance(tz);
-        return out;
-    }
-
     static LocalDateTime localDateTimeFromInstant(Instant instant, ZoneId zone) {
         ZoneOffset offset = offsetFromInstant(instant, zone);
-        long localSecond = instant.getEpochSecond() + offset.getTotalSeconds();
-        long epochDay = floorDiv(localSecond, SECONDS_PER_DAY);
-        int secondOfDay = (int) floorMod(localSecond, SECONDS_PER_DAY);
-        LocalDate date = LocalDate.ofEpochDay(epochDay);
-        LocalTime time = LocalTime.ofNanoOfDay(secondOfDay * NANOS_PER_SECOND + instant.getNano());
-        return LocalDateTime.of(date, time);
+        return LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset);
     }
 
+    /// The offset `zone` has at `instant`.
     static ZoneOffset offsetFromInstant(Instant instant, ZoneId zone) {
+        ZoneOffset fixed = zone.fixedOffset();
+        if (fixed != null) {
+            // A fixed offset already is the answer; round-tripping it through
+            // the host time zone database can only lose or invert it.
+            return fixed;
+        }
         TimeZone tz = zone.toTimeZone();
-        Calendar cal = newCalendar(TimeZone.getTimeZone("GMT"));
-        cal.setTime(new Date(instant.toEpochMilli()));
-        int offsetMillis = tz.getOffset(
-                1,
-                cal.get(Calendar.YEAR),
-                cal.get(Calendar.MONTH),
-                cal.get(Calendar.DAY_OF_MONTH),
-                cal.get(Calendar.DAY_OF_WEEK),
-                ((cal.get(Calendar.HOUR_OF_DAY) * 60 + cal.get(Calendar.MINUTE)) * 60 + cal.get(Calendar.SECOND)) * 1000
-                        + cal.get(Calendar.MILLISECOND));
+        // Ask the zone for its offset at this instant rather than reading the
+        // fields back out of a Calendar. Calendar reconstructs the local time
+        // from a raw offset plus a fixed one-hour daylight guess, which loses
+        // the saving on the desktop ports (Europe/Berlin in June came back as
+        // UTC), while TimeZone.getOffset consults the platform's own rules.
+        // getOffset takes LOCAL STANDARD time fields, so the instant is
+        // turned into local standard time first by adding the raw offset.
+        // Worked in seconds, not milliseconds: the instants java.time accepts
+        // reach past what a long counts in milliseconds.
+        long localStandard = instant.getEpochSecond() + tz.getRawOffset() / 1000;
+        long epochDay = TimeArithmetic.floorDiv(localStandard, 86400L);
+        int millisOfDay = (int) TimeArithmetic.floorMod(localStandard, 86400L) * 1000
+                + instant.getNano() / 1000000;
+        LocalDate utcDate = LocalDate.ofEpochDay(epochDay);
+        // Calendar.SUNDAY is 1 and epoch day 0 was a Thursday.
+        int dayOfWeek = (int) TimeArithmetic.floorMod(epochDay + 4, 7) + 1;
+        // getOffset takes an era plus a year *of that era*, not a proleptic ISO
+        // year: ISO 0 is 1 BC, ISO -1 is 2 BC, hence 1 - isoYear.
+        int isoYear = utcDate.getYear();
+        int era = isoYear > 0 ? 1 /* GregorianCalendar.AD */ : 0 /* GregorianCalendar.BC */;
+        int yearOfEra = isoYear > 0 ? isoYear : 1 - isoYear;
+        int offsetMillis = tz.getOffset(era, yearOfEra,
+                utcDate.getMonthValue() - 1, utcDate.getDayOfMonth(), dayOfWeek, millisOfDay);
         return ZoneOffset.ofTotalSeconds(offsetMillis / 1000);
     }
-
-    static SimpleDateFormat newFormat(String pattern, ZoneId zone, Locale locale) {
-        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
-        return sdf;
-    }
-
-    static String formatPattern(String pattern, TemporalCarrier carrier, Locale locale) {
-        ZoneId zone = carrier.getZoneForFormatting();
-        SimpleDateFormat sdf = newFormat(pattern, zone, locale);
-        TimeZone original = TimeZone.getDefault();
-        try {
-            if (zone != null) {
-                TimeZone.setDefault(zone.toTimeZone());
-            }
-            return sdf.format(new Date(carrier.toInstant().toEpochMilli()));
-        } finally {
-            TimeZone.setDefault(original);
-        }
-    }
-
-    static ParsedPatternResult parsePattern(String text, String pattern, ZoneId defaultZone, Locale locale) {
-        TimeZone original = TimeZone.getDefault();
-        try {
-            if (defaultZone != null) {
-                TimeZone.setDefault(defaultZone.toTimeZone());
-            }
-            SimpleDateFormat sdf = newFormat(pattern, defaultZone, locale);
-            Date date = sdf.parse(text);
-            Instant instant = Instant.ofEpochMilli(date.getTime());
-            ZoneId zone = defaultZone == null ? ZoneOffset.UTC : defaultZone;
-            return new ParsedPatternResult(instant, zone);
-        } catch (ParseException err) {
-            throw new java.time.format.DateTimeParseException(err.getMessage(), text, 0);
-        } finally {
-            TimeZone.setDefault(original);
-        }
-    }
-
-    interface TemporalCarrier {
-        Instant toInstant();
-        ZoneId getZoneForFormatting();
-    }
-
-    static final class ParsedPatternResult {
-        public final Instant instant;
-        public final ZoneId zone;
-
-        ParsedPatternResult(Instant instant, ZoneId zone) {
-            this.instant = instant;
-            this.zone = zone;
-        }
-    }
 }
diff --git a/Ports/CLDC11/src/java/time/DayOfWeek.java b/Ports/CLDC11/src/java/time/DayOfWeek.java
new file mode 100644
index 00000000000..95ba8eaa2c7
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/DayOfWeek.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time;
+
+import java.time.temporal.TemporalAccessor;
+
+/// The seven days of the week, Monday first as ISO counts them.
+public enum DayOfWeek implements TemporalAccessor {
+    /// Monday, day 1.
+    MONDAY,
+    /// Tuesday, day 2.
+    TUESDAY,
+    /// Wednesday, day 3.
+    WEDNESDAY,
+    /// Thursday, day 4.
+    THURSDAY,
+    /// Friday, day 5.
+    FRIDAY,
+    /// Saturday, day 6.
+    SATURDAY,
+    /// Sunday, day 7.
+    SUNDAY;
+
+    private static final DayOfWeek[] ALL = values();
+
+    /// The day numbered `dayOfWeek`, 1 for Monday to 7 for Sunday.
+    public static DayOfWeek of(int dayOfWeek) {
+        if (dayOfWeek < 1 || dayOfWeek > 7) {
+            throw new DateTimeException("Invalid value for DayOfWeek: " + dayOfWeek);
+        }
+        return ALL[dayOfWeek - 1];
+    }
+
+    /// 1 for Monday to 7 for Sunday.
+    public int getValue() {
+        return ordinal() + 1;
+    }
+
+    /// The day `days` later, around the week.
+    public DayOfWeek plus(long days) {
+        int amount = (int) (days % 7);
+        return ALL[(ordinal() + amount + 7) % 7];
+    }
+
+    /// The day `days` earlier, around the week.
+    public DayOfWeek minus(long days) {
+        return plus(-(days % 7));
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/Duration.java b/Ports/CLDC11/src/java/time/Duration.java
index 9c56a302ff7..4b15161d750 100644
--- a/Ports/CLDC11/src/java/time/Duration.java
+++ b/Ports/CLDC11/src/java/time/Duration.java
@@ -23,8 +23,24 @@
 package java.time;
 
 import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// An amount of time in seconds and nanoseconds, such as 34.5 seconds.
+///
+/// Arithmetic is exact: a result longer than a `Duration` holds throws
+/// `ArithmeticException` rather than wrapping around, as the JDK's does.
+public final class Duration implements TemporalAmount, Comparable<Duration> {
+    /// A duration of zero.
+    public static final Duration ZERO = new Duration(0L, 0);
+
+    private static final long NANOS_PER_SECOND = TimeArithmetic.NANOS_PER_SECOND;
 
-public final class Duration implements Comparable<Duration> {
     private final long seconds;
     private final int nanos;
 
@@ -33,30 +49,105 @@ private Duration(long seconds, int nanos) {
         this.nanos = nanos;
     }
 
+    private static Duration create(long seconds, int nanos) {
+        if ((seconds | nanos) == 0) {
+            return ZERO;
+        }
+        return new Duration(seconds, nanos);
+    }
+
+    /// A duration of `days` standard 24 hour days.
     public static Duration ofDays(long days) {
-        return ofSeconds(days * 86400L);
+        return create(TimeArithmetic.multiplyExact(days, 86400L), 0);
     }
 
+    /// A duration of `hours` hours.
     public static Duration ofHours(long hours) {
-        return ofSeconds(hours * 3600L);
+        return create(TimeArithmetic.multiplyExact(hours, 3600L), 0);
     }
 
+    /// A duration of `minutes` minutes.
     public static Duration ofMinutes(long minutes) {
-        return ofSeconds(minutes * 60L);
+        return create(TimeArithmetic.multiplyExact(minutes, 60L), 0);
     }
 
+    /// A duration of `seconds` seconds.
     public static Duration ofSeconds(long seconds) {
-        return new Duration(seconds, 0);
+        return create(seconds, 0);
     }
 
+    /// A duration of `seconds` seconds adjusted by `nanoAdjustment`
+    /// nanoseconds, which may take it across any number of seconds.
     public static Duration ofSeconds(long seconds, long nanoAdjustment) {
-        long secs = seconds + DateTimeSupport.floorDiv(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        int nanos = (int) DateTimeSupport.floorMod(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        return new Duration(secs, nanos);
+        long secs = TimeArithmetic.addExact(seconds, TimeArithmetic.floorDiv(nanoAdjustment, NANOS_PER_SECOND));
+        int nos = (int) TimeArithmetic.floorMod(nanoAdjustment, NANOS_PER_SECOND);
+        return create(secs, nos);
     }
 
+    /// A duration of `millis` milliseconds.
     public static Duration ofMillis(long millis) {
-        return ofSeconds(DateTimeSupport.floorDiv(millis, 1000L), DateTimeSupport.floorMod(millis, 1000L) * 1000000L);
+        long secs = millis / 1000;
+        int mos = (int) (millis % 1000);
+        if (mos < 0) {
+            mos += 1000;
+            secs--;
+        }
+        return create(secs, mos * 1000000);
+    }
+
+    /// A duration of `nanos` nanoseconds.
+    public static Duration ofNanos(long nanos) {
+        long secs = nanos / NANOS_PER_SECOND;
+        int nos = (int) (nanos % NANOS_PER_SECOND);
+        if (nos < 0) {
+            nos += (int) NANOS_PER_SECOND;
+            secs--;
+        }
+        return create(secs, nos);
+    }
+
+    /// A duration of `amount` of `unit`. The unit must have an exact length:
+    /// a day or anything shorter.
+    public static Duration of(long amount, TemporalUnit unit) {
+        return ZERO.plus(amount, unit);
+    }
+
+    /// The duration `amount` adds up to. Every unit it is made of must have
+    /// an exact length.
+    public static Duration from(TemporalAmount amount) {
+        if (amount == null) {
+            throw new NullPointerException("amount");
+        }
+        Duration duration = ZERO;
+        List<TemporalUnit> units = amount.getUnits();
+        for (int i = 0; i < units.size(); i++) {
+            TemporalUnit unit = units.get(i);
+            duration = duration.plus(amount.get(unit), unit);
+        }
+        return duration;
+    }
+
+    /// The duration from one value to another of the same kind, negative
+    /// when `endExclusive` comes first.
+    public static Duration between(Temporal startInclusive, Temporal endExclusive) {
+        try {
+            return ofNanos(startInclusive.until(endExclusive, ChronoUnit.NANOS));
+        } catch (DateTimeException ex) {
+            return betweenInSeconds(startInclusive, endExclusive);
+        } catch (ArithmeticException ex) {
+            return betweenInSeconds(startInclusive, endExclusive);
+        }
+    }
+
+    private static Duration betweenInSeconds(Temporal startInclusive, Temporal endExclusive) {
+        long secs = startInclusive.until(endExclusive, ChronoUnit.SECONDS);
+        long nanoDiff = TimeArithmetic.nanoOfSecond(endExclusive) - TimeArithmetic.nanoOfSecond(startInclusive);
+        if (secs > 0 && nanoDiff < 0) {
+            secs++;
+        } else if (secs < 0 && nanoDiff > 0) {
+            secs--;
+        }
+        return ofSeconds(secs, nanoDiff);
     }
 
     public static Duration parse(CharSequence text) {
@@ -126,18 +217,18 @@ public static Duration parse(CharSequence text) {
                 throw invalidDuration(value);
             }
             if (unit == 'D' && !time && !foundDays && fractionStart < 0) {
-                seconds += amount * 86400L;
+                seconds = parsedSum(value, seconds, amount, 86400L);
                 foundDays = true;
             } else if (unit == 'H' && time && lastTimeUnit < 1 && fractionStart < 0) {
-                seconds += amount * 3600L;
+                seconds = parsedSum(value, seconds, amount, 3600L);
                 lastTimeUnit = 1;
                 foundTime = true;
             } else if (unit == 'M' && time && lastTimeUnit < 2 && fractionStart < 0) {
-                seconds += amount * 60L;
+                seconds = parsedSum(value, seconds, amount, 60L);
                 lastTimeUnit = 2;
                 foundTime = true;
             } else if (unit == 'S' && time && lastTimeUnit < 3) {
-                seconds += amount;
+                seconds = parsedSum(value, seconds, amount, 1L);
                 lastTimeUnit = 3;
                 foundTime = true;
                 if (fractionStart >= 0) {
@@ -161,46 +252,374 @@ public static Duration parse(CharSequence text) {
         if (!found || (time && !foundTime)) {
             throw invalidDuration(value);
         }
-        return ofSeconds(overallSign * seconds, overallSign * (long) nanos);
+        try {
+            return ofSeconds(TimeArithmetic.multiplyExact(overallSign, seconds), overallSign * (long) nanos);
+        } catch (ArithmeticException e) {
+            throw invalidDuration(value);
+        }
+    }
+
+    /// `seconds` plus `amount` units of `unitSeconds` each. A field too large
+    /// for a duration is refused as the JDK refuses it, rather than wrapping
+    /// around to an unrelated one.
+    private static long parsedSum(String value, long seconds, long amount, long unitSeconds) {
+        try {
+            return TimeArithmetic.addExact(seconds, TimeArithmetic.multiplyExact(amount, unitSeconds));
+        } catch (ArithmeticException e) {
+            throw invalidDuration(value);
+        }
     }
 
     private static DateTimeParseException invalidDuration(String value) {
         return new DateTimeParseException("Text cannot be parsed to a Duration", value, 0);
     }
 
+    /// The amount of `unit` held: the seconds or the nanoseconds.
+    @Override
+    public long get(TemporalUnit unit) {
+        if (unit == ChronoUnit.SECONDS) {
+            return seconds;
+        }
+        if (unit == ChronoUnit.NANOS) {
+            return nanos;
+        }
+        throw TimeArithmetic.unsupported(unit);
+    }
+
+    /// Seconds and nanoseconds, the two units a duration is made of.
+    @Override
+    public List<TemporalUnit> getUnits() {
+        List<TemporalUnit> units = new ArrayList<TemporalUnit>(2);
+        units.add(ChronoUnit.SECONDS);
+        units.add(ChronoUnit.NANOS);
+        return Collections.unmodifiableList(units);
+    }
+
+    @Override
+    public Temporal addTo(Temporal temporal) {
+        if (seconds != 0) {
+            temporal = temporal.plus(seconds, ChronoUnit.SECONDS);
+        }
+        if (nanos != 0) {
+            temporal = temporal.plus(nanos, ChronoUnit.NANOS);
+        }
+        return temporal;
+    }
+
+    @Override
+    public Temporal subtractFrom(Temporal temporal) {
+        if (seconds != 0) {
+            temporal = temporal.minus(seconds, ChronoUnit.SECONDS);
+        }
+        if (nanos != 0) {
+            temporal = temporal.minus(nanos, ChronoUnit.NANOS);
+        }
+        return temporal;
+    }
+
+    /// Whether this is zero long.
+    public boolean isZero() {
+        return (seconds | nanos) == 0;
+    }
+
+    /// Whether this is shorter than zero.
+    public boolean isNegative() {
+        return seconds < 0;
+    }
+
+    /// The whole seconds, rounded towards negative infinity.
     public long getSeconds() {
         return seconds;
     }
 
+    /// The nanoseconds within the second, 0 to 999,999,999.
     public int getNano() {
         return nanos;
     }
 
+    /// This duration with `seconds` whole seconds.
+    public Duration withSeconds(long seconds) {
+        return create(seconds, nanos);
+    }
+
+    /// This duration with `nanoOfSecond` nanoseconds within the second.
+    public Duration withNanos(int nanoOfSecond) {
+        if (nanoOfSecond < 0 || nanoOfSecond >= NANOS_PER_SECOND) {
+            throw new DateTimeException("Invalid value for NanoOfSecond: " + nanoOfSecond);
+        }
+        return create(seconds, nanoOfSecond);
+    }
+
+    public Duration plus(Duration duration) {
+        return plus(duration.getSeconds(), duration.getNano());
+    }
+
+    /// This duration plus `amountToAdd` of `unit`, which must have an exact
+    /// length.
+    public Duration plus(long amountToAdd, TemporalUnit unit) {
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        if (unit == ChronoUnit.DAYS) {
+            return plus(TimeArithmetic.multiplyExact(amountToAdd, 86400L), 0);
+        }
+        if (unit.isDurationEstimated()) {
+            throw new java.time.temporal.UnsupportedTemporalTypeException(
+                    "Unit must not have an estimated duration");
+        }
+        if (amountToAdd == 0) {
+            return this;
+        }
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plusSeconds((amountToAdd / (1000000L * 1000)) * 1000)
+                        .plusNanos((amountToAdd % (1000000L * 1000)) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusMillis(amountToAdd);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            return plusSeconds(TimeArithmetic.multiplyExact(TimeArithmetic.seconds(u), amountToAdd));
+        }
+        Duration duration = unit.getDuration().multipliedBy(amountToAdd);
+        return plusSeconds(duration.getSeconds()).plusNanos(duration.getNano());
+    }
+
+    public Duration plusDays(long daysToAdd) {
+        return plus(TimeArithmetic.multiplyExact(daysToAdd, 86400L), 0);
+    }
+
+    public Duration plusHours(long hoursToAdd) {
+        return plus(TimeArithmetic.multiplyExact(hoursToAdd, 3600L), 0);
+    }
+
+    public Duration plusMinutes(long minutesToAdd) {
+        return plus(TimeArithmetic.multiplyExact(minutesToAdd, 60L), 0);
+    }
+
+    public Duration plusSeconds(long secondsToAdd) {
+        return plus(secondsToAdd, 0);
+    }
+
+    public Duration plusMillis(long millisToAdd) {
+        return plus(millisToAdd / 1000, (millisToAdd % 1000) * 1000000);
+    }
+
+    public Duration plusNanos(long nanosToAdd) {
+        return plus(0, nanosToAdd);
+    }
+
+    private Duration plus(long secondsToAdd, long nanosToAdd) {
+        if ((secondsToAdd | nanosToAdd) == 0) {
+            return this;
+        }
+        long epochSec = TimeArithmetic.addExact(seconds, secondsToAdd);
+        epochSec = TimeArithmetic.addExact(epochSec, nanosToAdd / NANOS_PER_SECOND);
+        nanosToAdd = nanosToAdd % NANOS_PER_SECOND;
+        long nanoAdjustment = nanos + nanosToAdd;
+        return ofSeconds(epochSec, nanoAdjustment);
+    }
+
+    public Duration minus(Duration duration) {
+        long secsToSubtract = duration.getSeconds();
+        int nanosToSubtract = duration.getNano();
+        if (secsToSubtract == Long.MIN_VALUE) {
+            return plus(Long.MAX_VALUE, -nanosToSubtract).plus(1, 0);
+        }
+        return plus(-secsToSubtract, -nanosToSubtract);
+    }
+
+    public Duration minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    public Duration minusDays(long daysToSubtract) {
+        return daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract);
+    }
+
+    public Duration minusHours(long hoursToSubtract) {
+        return hoursToSubtract == Long.MIN_VALUE ? plusHours(Long.MAX_VALUE).plusHours(1)
+                : plusHours(-hoursToSubtract);
+    }
+
+    public Duration minusMinutes(long minutesToSubtract) {
+        return minutesToSubtract == Long.MIN_VALUE ? plusMinutes(Long.MAX_VALUE).plusMinutes(1)
+                : plusMinutes(-minutesToSubtract);
+    }
+
+    public Duration minusSeconds(long secondsToSubtract) {
+        return secondsToSubtract == Long.MIN_VALUE ? plusSeconds(Long.MAX_VALUE).plusSeconds(1)
+                : plusSeconds(-secondsToSubtract);
+    }
+
+    public Duration minusMillis(long millisToSubtract) {
+        return millisToSubtract == Long.MIN_VALUE ? plusMillis(Long.MAX_VALUE).plusMillis(1)
+                : plusMillis(-millisToSubtract);
+    }
+
+    public Duration minusNanos(long nanosToSubtract) {
+        return nanosToSubtract == Long.MIN_VALUE ? plusNanos(Long.MAX_VALUE).plusNanos(1)
+                : plusNanos(-nanosToSubtract);
+    }
+
+    /// This duration multiplied by `multiplicand`, or `ArithmeticException`
+    /// when the product is longer than a duration holds.
+    public Duration multipliedBy(long multiplicand) {
+        if (multiplicand == 1) {
+            return this;
+        }
+        // A negative duration borrows a second first, so its seconds and
+        // nanoseconds share a sign and neither partial product overflows while
+        // the whole fits; the factor is split at a billion so the nanosecond
+        // product fits a long.
+        long secs = seconds;
+        long nos = nanos;
+        if (secs < 0 && nos > 0) {
+            secs++;
+            nos -= NANOS_PER_SECOND;
+        }
+        long high = TimeArithmetic.floorDiv(multiplicand, NANOS_PER_SECOND);
+        long rest = nos * TimeArithmetic.floorMod(multiplicand, NANOS_PER_SECOND);
+        // The nanosecond terms are summed first: together they are the carry
+        // of nanos * factor, which is never larger than the factor, while the
+        // first alone can push a result that fits past the range.
+        long carry = TimeArithmetic.addExact(nos * high, TimeArithmetic.floorDiv(rest, NANOS_PER_SECOND));
+        long total = TimeArithmetic.addExact(TimeArithmetic.multiplyExact(secs, multiplicand), carry);
+        return ofSeconds(total, TimeArithmetic.floorMod(rest, NANOS_PER_SECOND));
+    }
+
+    /// This duration divided by `divisor`, the fraction of a nanosecond
+    /// dropped towards zero. Exact for anything shorter than 292 years; a
+    /// longer one throws `ArithmeticException`.
+    public Duration dividedBy(long divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("Cannot divide by zero");
+        }
+        if (divisor == 1) {
+            return this;
+        }
+        return ofNanos(toNanos() / divisor);
+    }
+
+    /// This duration with its sign reversed. The most negative duration has
+    /// no positive counterpart and throws `ArithmeticException`.
+    public Duration negated() {
+        return multipliedBy(-1);
+    }
+
+    /// This duration without its sign.
+    public Duration abs() {
+        return isNegative() ? negated() : this;
+    }
+
+    /// The whole days, of 24 hours.
+    public long toDays() {
+        return seconds / 86400L;
+    }
+
+    /// The whole hours.
+    public long toHours() {
+        return seconds / 3600L;
+    }
+
+    /// The whole minutes.
+    public long toMinutes() {
+        return seconds / 60L;
+    }
+
+    /// The whole seconds; the same as `getSeconds()`.
+    public long toSeconds() {
+        return seconds;
+    }
+
+    /// The whole milliseconds, or `ArithmeticException` past what a long
+    /// holds.
     public long toMillis() {
-        return seconds * 1000L + nanos / 1000000L;
+        long tempSeconds = seconds;
+        long tempNanos = nanos;
+        if (tempSeconds < 0) {
+            // A negative duration borrows a second first, so the most negative
+            // value a long holds is reached without an intermediate overflow.
+            tempSeconds = tempSeconds + 1;
+            tempNanos = tempNanos - NANOS_PER_SECOND;
+        }
+        long millis = TimeArithmetic.multiplyExact(tempSeconds, 1000L);
+        return TimeArithmetic.addExact(millis, tempNanos / 1000000L);
+    }
+
+    /// The whole nanoseconds, or `ArithmeticException` past what a long
+    /// holds (about 292 years).
+    public long toNanos() {
+        long tempSeconds = seconds;
+        long tempNanos = nanos;
+        if (tempSeconds < 0) {
+            tempSeconds = tempSeconds + 1;
+            tempNanos = tempNanos - NANOS_PER_SECOND;
+        }
+        long totalNanos = TimeArithmetic.multiplyExact(tempSeconds, NANOS_PER_SECOND);
+        return TimeArithmetic.addExact(totalNanos, tempNanos);
+    }
+
+    /// The whole days; the same as `toDays()`.
+    public long toDaysPart() {
+        return seconds / 86400L;
+    }
+
+    /// The hours left over after the whole days.
+    public int toHoursPart() {
+        return (int) (toHours() % 24);
+    }
+
+    /// The minutes left over after the whole hours.
+    public int toMinutesPart() {
+        return (int) (toMinutes() % 60);
+    }
+
+    /// The seconds left over after the whole minutes.
+    public int toSecondsPart() {
+        return (int) (seconds % 60);
     }
 
-    public Duration plus(Duration other) {
-        return ofSeconds(seconds + other.seconds, nanos + other.nanos);
+    /// The milliseconds within the second.
+    public int toMillisPart() {
+        return nanos / 1000000;
     }
 
-    public Duration minus(Duration other) {
-        return ofSeconds(seconds - other.seconds, nanos - other.nanos);
+    /// The nanoseconds within the second; the same as `getNano()`.
+    public int toNanosPart() {
+        return nanos;
     }
 
+    @Override
     public int compareTo(Duration other) {
         if (seconds != other.seconds) {
             return seconds < other.seconds ? -1 : 1;
         }
-        return nanos < other.nanos ? -1 : nanos > other.nanos ? 1 : 0;
+        return nanos - other.nanos;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof Duration && compareTo((Duration) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Duration)) {
+            return false;
+        }
+        Duration other = (Duration) obj;
+        return seconds == other.seconds && nanos == other.nanos;
     }
 
+    @Override
     public int hashCode() {
-        return (int) (seconds ^ (seconds >>> 32)) + nanos * 31;
+        return ((int) (seconds ^ (seconds >>> 32))) + (51 * nanos);
     }
 
     public String toString() {
diff --git a/Ports/CLDC11/src/java/time/Instant.java b/Ports/CLDC11/src/java/time/Instant.java
index 8ac4e01fdb2..1a58de06765 100644
--- a/Ports/CLDC11/src/java/time/Instant.java
+++ b/Ports/CLDC11/src/java/time/Instant.java
@@ -1,9 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+
+/// A moment on the time line, in seconds and nanoseconds from
+/// 1970-01-01T00:00:00Z.
+public final class Instant implements Temporal, Comparable<Instant> {
+    private static final long MIN_SECOND = -31557014167219200L;
+    private static final long MAX_SECOND = 31556889864403199L;
+
+    /// 1970-01-01T00:00:00Z.
+    public static final Instant EPOCH = new Instant(0L, 0);
+
+    /// The earliest instant, -1000000000-01-01T00:00Z.
+    public static final Instant MIN = new Instant(MIN_SECOND, 0);
+
+    /// The latest instant, 1000000000-12-31T23:59:59.999999999Z.
+    public static final Instant MAX = new Instant(MAX_SECOND, 999999999);
 
-public final class Instant implements Comparable<Instant>, TemporalAccessor {
     private final long epochSecond;
     private final int nano;
 
@@ -12,28 +52,67 @@ private Instant(long epochSecond, int nano) {
         this.nano = nano;
     }
 
+    private static Instant create(long seconds, int nanoOfSecond) {
+        if ((seconds | nanoOfSecond) == 0) {
+            return EPOCH;
+        }
+        if (seconds < MIN_SECOND || seconds > MAX_SECOND) {
+            throw TimeArithmetic.instantOutOfRange();
+        }
+        return new Instant(seconds, nanoOfSecond);
+    }
+
     public static Instant now() {
         return ofEpochMilli(System.currentTimeMillis());
     }
 
+    /// The moment now on `clock`.
+    public static Instant now(Clock clock) {
+        return clock.instant();
+    }
+
     public static Instant ofEpochMilli(long epochMilli) {
-        long secs = DateTimeSupport.floorDiv(epochMilli, 1000L);
-        int nanos = (int) (DateTimeSupport.floorMod(epochMilli, 1000L) * 1000000L);
-        return new Instant(secs, nanos);
+        long secs = TimeArithmetic.floorDiv(epochMilli, 1000L);
+        int mos = (int) TimeArithmetic.floorMod(epochMilli, 1000L);
+        return create(secs, mos * 1000000);
     }
 
     public static Instant ofEpochSecond(long epochSecond) {
-        return new Instant(epochSecond, 0);
+        return create(epochSecond, 0);
     }
 
     public static Instant ofEpochSecond(long epochSecond, long nanoAdjustment) {
-        long secs = epochSecond + DateTimeSupport.floorDiv(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        int nanos = (int) DateTimeSupport.floorMod(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        return new Instant(secs, nanos);
+        long secs = TimeArithmetic.addExact(epochSecond,
+                TimeArithmetic.floorDiv(nanoAdjustment, TimeArithmetic.NANOS_PER_SECOND));
+        int nos = (int) TimeArithmetic.floorMod(nanoAdjustment, TimeArithmetic.NANOS_PER_SECOND);
+        return create(secs, nos);
+    }
+
+    /// The moment `temporal` is.
+    public static Instant from(TemporalAccessor temporal) {
+        if (temporal instanceof Instant) {
+            return (Instant) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toInstant();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toInstant();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain Instant from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static Instant parse(CharSequence text) {
-        return (Instant) DateTimeFormatter.ISO_INSTANT.parse(text);
+        TemporalAccessor parsed = DateTimeFormatter.ISO_INSTANT.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public long getEpochSecond() {
@@ -44,50 +123,200 @@ public int getNano() {
         return nano;
     }
 
+    /// The milliseconds since the epoch, or `ArithmeticException` past what
+    /// a long holds.
     public long toEpochMilli() {
-        return epochSecond * 1000L + nano / 1000000L;
+        if (epochSecond < 0 && nano > 0) {
+            long millis = TimeArithmetic.multiplyExact(epochSecond + 1, 1000L);
+            long adjustment = nano / 1000000 - 1000;
+            return TimeArithmetic.addExact(millis, adjustment);
+        }
+        long millis = TimeArithmetic.multiplyExact(epochSecond, 1000L);
+        return TimeArithmetic.addExact(millis, nano / 1000000);
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit.isTimeBased() || unit == ChronoUnit.DAYS;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public Instant plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plus(amountToAdd / 1000000, (amountToAdd % 1000000) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusMillis(amountToAdd);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            if (u == ChronoUnit.MINUTES || u == ChronoUnit.HOURS || u == ChronoUnit.HALF_DAYS
+                    || u == ChronoUnit.DAYS) {
+                return plusSeconds(TimeArithmetic.multiplyExact(amountToAdd, TimeArithmetic.seconds(u)));
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public Instant minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public Instant plus(TemporalAmount amount) {
+        return (Instant) amount.addTo(this);
+    }
+
+    @Override
+    public Instant minus(TemporalAmount amount) {
+        return (Instant) amount.subtractFrom(this);
     }
 
     public Instant plusSeconds(long secondsToAdd) {
-        return ofEpochSecond(epochSecond + secondsToAdd, nano);
+        return plus(secondsToAdd, 0);
     }
 
     public Instant plusMillis(long millisToAdd) {
-        return ofEpochMilli(toEpochMilli() + millisToAdd);
+        return plus(millisToAdd / 1000, (millisToAdd % 1000) * 1000000);
+    }
+
+    public Instant plusNanos(long nanosToAdd) {
+        return plus(0, nanosToAdd);
+    }
+
+    private Instant plus(long secondsToAdd, long nanosToAdd) {
+        if ((secondsToAdd | nanosToAdd) == 0) {
+            return this;
+        }
+        long epochSec = TimeArithmetic.addExact(epochSecond, secondsToAdd);
+        epochSec = TimeArithmetic.addExact(epochSec, nanosToAdd / TimeArithmetic.NANOS_PER_SECOND);
+        nanosToAdd = nanosToAdd % TimeArithmetic.NANOS_PER_SECOND;
+        long nanoAdjustment = nano + nanosToAdd;
+        return ofEpochSecond(epochSec, nanoAdjustment);
     }
 
     public Instant minusSeconds(long secondsToSubtract) {
+        if (secondsToSubtract == Long.MIN_VALUE) {
+            return plusSeconds(Long.MAX_VALUE).plusSeconds(1);
+        }
         return plusSeconds(-secondsToSubtract);
     }
 
     public Instant minusMillis(long millisToSubtract) {
+        if (millisToSubtract == Long.MIN_VALUE) {
+            return plusMillis(Long.MAX_VALUE).plusMillis(1);
+        }
         return plusMillis(-millisToSubtract);
     }
 
+    public Instant minusNanos(long nanosToSubtract) {
+        if (nanosToSubtract == Long.MIN_VALUE) {
+            return plusNanos(Long.MAX_VALUE).plusNanos(1);
+        }
+        return plusNanos(-nanosToSubtract);
+    }
+
+    /// This moment with everything smaller than `unit` dropped. The unit has
+    /// to divide a day.
+    public Instant truncatedTo(TemporalUnit unit) {
+        if (unit == ChronoUnit.NANOS) {
+            return this;
+        }
+        long dur = TimeArithmetic.truncationNanos(unit);
+        long nod = (epochSecond % TimeArithmetic.SECONDS_PER_DAY) * TimeArithmetic.NANOS_PER_SECOND + nano;
+        long result = TimeArithmetic.floorDiv(nod, dur) * dur;
+        return plusNanos(result - nod);
+    }
+
+    /// The whole units of `unit` from this moment to `endExclusive`.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        Instant end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u.compareTo(ChronoUnit.DAYS) > 0) {
+                throw TimeArithmetic.unsupported(unit);
+            }
+            if (u == ChronoUnit.NANOS || u == ChronoUnit.MICROS) {
+                // Counted in nanoseconds first, as the JDK does: more than
+                // 292 years apart is an overflow in either unit.
+                long secsDiff = TimeArithmetic.subtractExact(end.epochSecond, epochSecond);
+                long nanos = TimeArithmetic.addExact(TimeArithmetic.multiplyExact(secsDiff,
+                        TimeArithmetic.NANOS_PER_SECOND), end.nano - nano);
+                return u == ChronoUnit.NANOS ? nanos : nanos / 1000;
+            }
+            if (u == ChronoUnit.MILLIS) {
+                // Between the two moments each cut to its millisecond.
+                return TimeArithmetic.subtractExact(end.toEpochMilli(), toEpochMilli());
+            }
+            return TimeArithmetic.timeUntil(epochSecond, nano, end.epochSecond, end.nano, u);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
+    /// This moment in `zone`.
+    public ZonedDateTime atZone(ZoneId zone) {
+        return ZonedDateTime.ofInstant(this, zone);
+    }
+
+    /// This moment at `offset`.
+    public OffsetDateTime atOffset(ZoneOffset offset) {
+        return OffsetDateTime.ofInstant(this, offset);
+    }
+
+    public boolean isAfter(Instant otherInstant) {
+        return compareTo(otherInstant) > 0;
+    }
+
+    public boolean isBefore(Instant otherInstant) {
+        return compareTo(otherInstant) < 0;
+    }
+
+    @Override
     public int compareTo(Instant other) {
         if (epochSecond != other.epochSecond) {
             return epochSecond < other.epochSecond ? -1 : 1;
         }
-        return nano < other.nano ? -1 : nano > other.nano ? 1 : 0;
+        return nano - other.nano;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof Instant && compareTo((Instant) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Instant)) {
+            return false;
+        }
+        Instant other = (Instant) obj;
+        return epochSecond == other.epochSecond && nano == other.nano;
     }
 
+    @Override
     public int hashCode() {
-        return (int) (epochSecond ^ (epochSecond >>> 32)) + nano * 51;
+        return ((int) (epochSecond ^ (epochSecond >>> 32))) + 51 * nano;
     }
 
+    @Override
     public String toString() {
         return DateTimeFormatter.ISO_INSTANT.format(this);
     }
-
-    Instant toInstant() {
-        return this;
-    }
-
-    ZoneId getZoneForFormatting() {
-        return ZoneOffset.UTC;
-    }
 }
diff --git a/Ports/CLDC11/src/java/time/LocalDate.java b/Ports/CLDC11/src/java/time/LocalDate.java
index 35440aaaa50..daffa6894c9 100644
--- a/Ports/CLDC11/src/java/time/LocalDate.java
+++ b/Ports/CLDC11/src/java/time/LocalDate.java
@@ -1,43 +1,200 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
+import java.time.chrono.ChronoLocalDate;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.util.stream.Stream;
+
+/// A date of the ISO calendar with no time and no zone, such as 2007-12-03.
+public final class LocalDate implements ChronoLocalDate {
+    /// -999999999-01-01, the earliest date.
+    public static final LocalDate MIN = new LocalDate(-999999999, 1, 1);
+    /// +999999999-12-31, the latest date.
+    public static final LocalDate MAX = new LocalDate(999999999, 12, 31);
+    /// 1970-01-01.
+    public static final LocalDate EPOCH = new LocalDate(1970, 1, 1);
+
+    private static final int YEAR_LIMIT = 999999999;
+    private static final long DAYS_PER_CYCLE = 146097L;
+    private static final long DAYS_0000_TO_1970 = (DAYS_PER_CYCLE * 5L) - (30L * 365L + 7L);
 
-public final class LocalDate implements Comparable<LocalDate>, TemporalAccessor {
     private final int year;
-    private final int month;
-    private final int dayOfMonth;
+    private final short month;
+    private final short day;
 
     private LocalDate(int year, int month, int dayOfMonth) {
-        DateTimeSupport.checkDate(year, month, dayOfMonth);
         this.year = year;
-        this.month = month;
-        this.dayOfMonth = dayOfMonth;
+        this.month = (short) month;
+        this.day = (short) dayOfMonth;
+    }
+
+    private static boolean leap(long year) {
+        return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
+    }
+
+    private static int monthLength(int year, int month) {
+        return Month.of(month).length(leap(year));
+    }
+
+    private static LocalDate create(int year, int month, int dayOfMonth) {
+        if (dayOfMonth > 28) {
+            int dom = monthLength(year, month);
+            if (dayOfMonth > dom) {
+                if (dayOfMonth == 29) {
+                    throw new DateTimeException("Invalid date 'February 29' as '" + year + "' is not a leap year");
+                }
+                throw new DateTimeException("Invalid date '" + Month.of(month).name() + " " + dayOfMonth + "'");
+            }
+        }
+        return new LocalDate(year, month, dayOfMonth);
+    }
+
+    /// The date, with the day brought back to the last one the month has.
+    private static LocalDate resolvePreviousValid(int year, int month, int day) {
+        int last = monthLength(year, month);
+        return new LocalDate(year, month, day > last ? last : day);
+    }
+
+    private static int checkYear(long year) {
+        return (int) TimeArithmetic.check("Year", -YEAR_LIMIT, YEAR_LIMIT, year);
     }
 
     public static LocalDate now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The date today in `zone`.
+    public static LocalDate now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static LocalDate now(Clock clock) {
-        return LocalDateTime.ofInstant(clock.instant(), clock.getZone()).toLocalDate();
+        return ofInstant(clock.instant(), clock.getZone());
     }
 
     public static LocalDate of(int year, int month, int dayOfMonth) {
-        return new LocalDate(year, month, dayOfMonth);
+        checkYear(year);
+        TimeArithmetic.check("MonthOfYear", 1, 12, month);
+        TimeArithmetic.check("DayOfMonth", 1, 31, dayOfMonth);
+        return create(year, month, dayOfMonth);
+    }
+
+    public static LocalDate of(int year, Month month, int dayOfMonth) {
+        if (month == null) {
+            throw new NullPointerException("month");
+        }
+        return of(year, month.getValue(), dayOfMonth);
+    }
+
+    /// The `dayOfYear`th day of `year`.
+    public static LocalDate ofYearDay(int year, int dayOfYear) {
+        checkYear(year);
+        TimeArithmetic.check("DayOfYear", 1, 366, dayOfYear);
+        boolean leap = leap(year);
+        if (dayOfYear == 366 && !leap) {
+            throw new DateTimeException("Invalid date 'DayOfYear 366' as '" + year + "' is not a leap year");
+        }
+        Month moy = Month.of((dayOfYear - 1) / 31 + 1);
+        int monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;
+        if (dayOfYear > monthEnd) {
+            moy = moy.plus(1);
+        }
+        int dom = dayOfYear - moy.firstDayOfYear(leap) + 1;
+        return new LocalDate(year, moy.getValue(), dom);
+    }
+
+    /// The date `instant` falls on in `zone`.
+    public static LocalDate ofInstant(Instant instant, ZoneId zone) {
+        return LocalDateTime.ofInstant(instant, zone).toLocalDate();
     }
 
     public static LocalDate ofEpochDay(long epochDay) {
-        int[] parts = DateTimeSupport.epochDayToDate(epochDay);
-        return of(parts[0], parts[1], parts[2]);
+        TimeArithmetic.check("EpochDay", -365243219162L, 365241780471L, epochDay);
+        long zeroDay = epochDay + DAYS_0000_TO_1970;
+        // find the march-based year
+        zeroDay -= 60;
+        long adjust = 0;
+        if (zeroDay < 0) {
+            long adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1;
+            adjust = adjustCycles * 400;
+            zeroDay += -adjustCycles * DAYS_PER_CYCLE;
+        }
+        long yearEst = (400 * zeroDay + 591) / DAYS_PER_CYCLE;
+        long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
+        if (doyEst < 0) {
+            yearEst--;
+            doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
+        }
+        yearEst += adjust;
+        int marchDoy0 = (int) doyEst;
+        int marchMonth0 = (marchDoy0 * 5 + 2) / 153;
+        int month = (marchMonth0 + 2) % 12 + 1;
+        int dom = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;
+        yearEst += marchMonth0 / 10;
+        return new LocalDate(checkYear(yearEst), month, dom);
+    }
+
+    /// The date of `temporal`.
+    public static LocalDate from(TemporalAccessor temporal) {
+        if (temporal instanceof LocalDate) {
+            return (LocalDate) temporal;
+        }
+        if (temporal instanceof LocalDateTime) {
+            return ((LocalDateTime) temporal).toLocalDate();
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toLocalDate();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toLocalDate();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain LocalDate from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static LocalDate parse(CharSequence text) {
-        return (LocalDate) DateTimeFormatter.ISO_LOCAL_DATE.parse(text);
+        return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);
     }
 
     public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) {
-        return (LocalDate) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public int getYear() {
@@ -48,43 +205,285 @@ public int getMonthValue() {
         return month;
     }
 
+    /// The month as a `Month`.
+    public Month getMonth() {
+        return Month.of(month);
+    }
+
     public int getDayOfMonth() {
-        return dayOfMonth;
+        return day;
+    }
+
+    /// The day of the year, 1 for January 1st.
+    public int getDayOfYear() {
+        return getMonth().firstDayOfYear(isLeapYear()) + day - 1;
+    }
+
+    /// The day of the week.
+    public DayOfWeek getDayOfWeek() {
+        int dow0 = (int) TimeArithmetic.floorMod(toEpochDay() + 3, 7);
+        return DayOfWeek.of(dow0 + 1);
     }
 
+    @Override
     public boolean isLeapYear() {
-        return DateTimeSupport.isLeapYear(year);
+        return leap(year);
     }
 
+    @Override
     public int lengthOfMonth() {
-        return DateTimeSupport.lengthOfMonth(year, month);
+        return monthLength(year, month);
     }
 
+    @Override
+    public int lengthOfYear() {
+        return isLeapYear() ? 366 : 365;
+    }
+
+    @Override
     public long toEpochDay() {
-        return DateTimeSupport.toEpochDay(year, month, dayOfMonth);
+        long y = year;
+        long m = month;
+        long total = 0;
+        total += 365 * y;
+        if (y >= 0) {
+            total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;
+        } else {
+            total -= y / -4 - y / -100 + y / -400;
+        }
+        total += ((367 * m - 362) / 12);
+        total += day - 1;
+        if (m > 2) {
+            total--;
+            if (!isLeapYear()) {
+                total--;
+            }
+        }
+        return total - DAYS_0000_TO_1970;
+    }
+
+    private long getProlepticMonth() {
+        return (year * 12L + month - 1);
+    }
+
+    public LocalDate withYear(int year) {
+        if (this.year == year) {
+            return this;
+        }
+        checkYear(year);
+        return resolvePreviousValid(year, month, day);
+    }
+
+    public LocalDate withMonth(int month) {
+        if (this.month == month) {
+            return this;
+        }
+        TimeArithmetic.check("MonthOfYear", 1, 12, month);
+        return resolvePreviousValid(year, month, day);
+    }
+
+    public LocalDate withDayOfMonth(int dayOfMonth) {
+        if (this.day == dayOfMonth) {
+            return this;
+        }
+        return of(year, month, dayOfMonth);
+    }
+
+    public LocalDate withDayOfYear(int dayOfYear) {
+        if (getDayOfYear() == dayOfYear) {
+            return this;
+        }
+        return ofYearDay(year, dayOfYear);
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit.isDateBased();
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public LocalDate plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.DAYS) {
+                return plusDays(amountToAdd);
+            }
+            if (u == ChronoUnit.WEEKS) {
+                return plusWeeks(amountToAdd);
+            }
+            if (u == ChronoUnit.MONTHS) {
+                return plusMonths(amountToAdd);
+            }
+            if (u == ChronoUnit.YEARS) {
+                return plusYears(amountToAdd);
+            }
+            if (u == ChronoUnit.DECADES) {
+                return plusYears(TimeArithmetic.multiplyExact(amountToAdd, 10));
+            }
+            if (u == ChronoUnit.CENTURIES) {
+                return plusYears(TimeArithmetic.multiplyExact(amountToAdd, 100));
+            }
+            if (u == ChronoUnit.MILLENNIA) {
+                return plusYears(TimeArithmetic.multiplyExact(amountToAdd, 1000));
+            }
+            if (u == ChronoUnit.ERAS) {
+                // The two eras of the ISO calendar: year 1 and later, and before.
+                long era = TimeArithmetic.addExact(year >= 1 ? 1 : 0, amountToAdd);
+                TimeArithmetic.check("Era", 0, 1, era);
+                return amountToAdd == 0 ? this : resolvePreviousValid(1 - year, month, day);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public LocalDate minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public LocalDate plus(TemporalAmount amount) {
+        return (LocalDate) amount.addTo(this);
+    }
+
+    @Override
+    public LocalDate minus(TemporalAmount amount) {
+        return (LocalDate) amount.subtractFrom(this);
     }
 
     public LocalDate plusDays(long daysToAdd) {
-        return ofEpochDay(toEpochDay() + daysToAdd);
+        if (daysToAdd == 0) {
+            return this;
+        }
+        return ofEpochDay(TimeArithmetic.addExact(toEpochDay(), daysToAdd));
+    }
+
+    public LocalDate plusWeeks(long weeksToAdd) {
+        return plusDays(TimeArithmetic.multiplyExact(weeksToAdd, 7));
     }
 
     public LocalDate plusMonths(long monthsToAdd) {
+        if (monthsToAdd == 0) {
+            return this;
+        }
         long monthCount = year * 12L + (month - 1);
         long calcMonths = monthCount + monthsToAdd;
-        int newYear = (int) DateTimeSupport.floorDiv(calcMonths, 12);
-        int newMonth = (int) DateTimeSupport.floorMod(calcMonths, 12) + 1;
-        int newDay = Math.min(dayOfMonth, DateTimeSupport.lengthOfMonth(newYear, newMonth));
-        return of(newYear, newMonth, newDay);
+        int newYear = checkYear(TimeArithmetic.floorDiv(calcMonths, 12));
+        int newMonth = (int) TimeArithmetic.floorMod(calcMonths, 12) + 1;
+        return resolvePreviousValid(newYear, newMonth, day);
     }
 
     public LocalDate plusYears(long yearsToAdd) {
-        int newYear = (int) (year + yearsToAdd);
-        int newDay = Math.min(dayOfMonth, DateTimeSupport.lengthOfMonth(newYear, month));
-        return of(newYear, month, newDay);
+        if (yearsToAdd == 0) {
+            return this;
+        }
+        int newYear = checkYear(year + yearsToAdd);
+        return resolvePreviousValid(newYear, month, day);
     }
 
     public LocalDate minusDays(long daysToSubtract) {
-        return plusDays(-daysToSubtract);
+        return daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract);
+    }
+
+    public LocalDate minusWeeks(long weeksToSubtract) {
+        return weeksToSubtract == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1)
+                : plusWeeks(-weeksToSubtract);
+    }
+
+    public LocalDate minusMonths(long monthsToSubtract) {
+        return monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1)
+                : plusMonths(-monthsToSubtract);
+    }
+
+    public LocalDate minusYears(long yearsToSubtract) {
+        return yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1)
+                : plusYears(-yearsToSubtract);
+    }
+
+    /// The whole units of `unit` from this date to the date of `endExclusive`.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        LocalDate end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.DAYS) {
+                return end.toEpochDay() - toEpochDay();
+            }
+            if (u == ChronoUnit.WEEKS) {
+                return (end.toEpochDay() - toEpochDay()) / 7;
+            }
+            if (u == ChronoUnit.MONTHS) {
+                return monthsUntil(end);
+            }
+            if (u == ChronoUnit.YEARS) {
+                return monthsUntil(end) / 12;
+            }
+            if (u == ChronoUnit.DECADES) {
+                return monthsUntil(end) / 120;
+            }
+            if (u == ChronoUnit.CENTURIES) {
+                return monthsUntil(end) / 1200;
+            }
+            if (u == ChronoUnit.MILLENNIA) {
+                return monthsUntil(end) / 12000;
+            }
+            if (u == ChronoUnit.ERAS) {
+                return (end.year >= 1 ? 1 : 0) - (year >= 1 ? 1 : 0);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
+    long monthsUntil(LocalDate end) {
+        long packed1 = getProlepticMonth() * 32L + day;
+        long packed2 = end.getProlepticMonth() * 32L + end.day;
+        return (packed2 - packed1) / 32;
+    }
+
+    /// The years, months and days from this date to `endDateExclusive`.
+    public Period until(ChronoLocalDate endDateExclusive) {
+        LocalDate end = from(endDateExclusive);
+        long totalMonths = end.getProlepticMonth() - getProlepticMonth();
+        int days = end.day - day;
+        if (totalMonths > 0 && days < 0) {
+            totalMonths--;
+            LocalDate calcDate = plusMonths(totalMonths);
+            days = (int) (end.toEpochDay() - calcDate.toEpochDay());
+        } else if (totalMonths < 0 && days > 0) {
+            totalMonths++;
+            days -= end.lengthOfMonth();
+        }
+        long years = totalMonths / 12;
+        int months = (int) (totalMonths % 12);
+        return Period.of(TimeArithmetic.toIntExact(years), months, days);
+    }
+
+    /// The dates from this one up to and not including `endExclusive`, a day
+    /// apart.
+    public Stream<LocalDate> datesUntil(LocalDate endExclusive) {
+        long end = endExclusive.toEpochDay();
+        long start = toEpochDay();
+        if (end < start) {
+            throw new IllegalArgumentException(endExclusive + " < " + this);
+        }
+        // Made in full: the class library has no lazy stream source yet.
+        LocalDate[] all = new LocalDate[TimeArithmetic.toIntExact(end - start)];
+        for (int i = 0; i < all.length; i++) {
+            all[i] = ofEpochDay(start + i);
+        }
+        return Stream.of(all);
     }
 
     public LocalDateTime atTime(int hour, int minute) {
@@ -103,6 +502,11 @@ public LocalDateTime atTime(LocalTime time) {
         return LocalDateTime.of(this, time);
     }
 
+    /// Midnight at the start of this date.
+    public LocalDateTime atStartOfDay() {
+        return LocalDateTime.of(this, LocalTime.MIDNIGHT);
+    }
+
     public ZonedDateTime atStartOfDay(ZoneId zone) {
         return ZonedDateTime.of(this, LocalTime.MIDNIGHT, zone);
     }
@@ -111,25 +515,82 @@ public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
-    public int compareTo(LocalDate other) {
-        if (year != other.year) {
-            return year < other.year ? -1 : 1;
+    private int compareTo0(LocalDate otherDate) {
+        int cmp = year - otherDate.year;
+        if (cmp == 0) {
+            cmp = month - otherDate.month;
+            if (cmp == 0) {
+                cmp = day - otherDate.day;
+            }
+        }
+        return cmp;
+    }
+
+    @Override
+    public int compareTo(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other);
+        }
+        long a = toEpochDay();
+        long b = other.toEpochDay();
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+
+    @Override
+    public boolean isAfter(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other) > 0;
         }
-        if (month != other.month) {
-            return month < other.month ? -1 : 1;
+        return toEpochDay() > other.toEpochDay();
+    }
+
+    @Override
+    public boolean isBefore(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other) < 0;
         }
-        return dayOfMonth < other.dayOfMonth ? -1 : dayOfMonth > other.dayOfMonth ? 1 : 0;
+        return toEpochDay() < other.toEpochDay();
     }
 
+    @Override
+    public boolean isEqual(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other) == 0;
+        }
+        return toEpochDay() == other.toEpochDay();
+    }
+
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof LocalDate && compareTo((LocalDate) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        return obj instanceof LocalDate && compareTo0((LocalDate) obj) == 0;
     }
 
+    @Override
     public int hashCode() {
-        return year * 37 + month * 13 + dayOfMonth;
+        return (year & 0xFFFFF800) ^ ((year << 11) + (month << 6) + day);
     }
 
+    /// The JDK's text, `uuuu-MM-dd`, with a sign on a year past 9999.
+    @Override
     public String toString() {
-        return DateTimeFormatter.ISO_LOCAL_DATE.format(this);
+        StringBuilder buf = new StringBuilder(12);
+        int absYear = year < 0 ? -year : year;
+        if (absYear < 1000) {
+            if (year < 0) {
+                buf.append('-');
+            }
+            String digits = Integer.toString(absYear + 10000);
+            buf.append(digits.substring(1));
+        } else {
+            if (year > 9999) {
+                buf.append('+');
+            }
+            buf.append(year);
+        }
+        return buf.append(month < 10 ? "-0" : "-").append((int) month).append(day < 10 ? "-0" : "-")
+                .append((int) day).toString();
     }
 }
diff --git a/Ports/CLDC11/src/java/time/LocalDateTime.java b/Ports/CLDC11/src/java/time/LocalDateTime.java
index d19cfed30d0..423c0384185 100644
--- a/Ports/CLDC11/src/java/time/LocalDateTime.java
+++ b/Ports/CLDC11/src/java/time/LocalDateTime.java
@@ -1,9 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
+import java.time.chrono.ChronoLocalDateTime;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+
+/// A date and a time of day with no zone, such as 2007-12-03T10:15:30.
+public final class LocalDateTime implements ChronoLocalDateTime<LocalDate> {
+    /// The earliest date and time.
+    public static final LocalDateTime MIN = new LocalDateTime(LocalDate.MIN, LocalTime.MIN);
+    /// The latest date and time.
+    public static final LocalDateTime MAX = new LocalDateTime(LocalDate.MAX, LocalTime.MAX);
+
+    private static final long NANOS_PER_SECOND = TimeArithmetic.NANOS_PER_SECOND;
+    private static final long NANOS_PER_MINUTE = 60L * NANOS_PER_SECOND;
+    private static final long NANOS_PER_HOUR = 60L * NANOS_PER_MINUTE;
+    private static final long NANOS_PER_DAY = TimeArithmetic.NANOS_PER_DAY;
 
-public final class LocalDateTime implements Comparable<LocalDateTime>, TemporalAccessor {
     private final LocalDate date;
     private final LocalTime time;
 
@@ -12,15 +50,33 @@ private LocalDateTime(LocalDate date, LocalTime time) {
         this.time = time;
     }
 
+    private LocalDateTime with(LocalDate newDate, LocalTime newTime) {
+        if (date == newDate && time == newTime) {
+            return this;
+        }
+        return new LocalDateTime(newDate, newTime);
+    }
+
     public static LocalDateTime now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The date and time now in `zone`.
+    public static LocalDateTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static LocalDateTime now(Clock clock) {
         return ofInstant(clock.instant(), clock.getZone());
     }
 
     public static LocalDateTime of(LocalDate date, LocalTime time) {
+        if (date == null) {
+            throw new NullPointerException("date");
+        }
+        if (time == null) {
+            throw new NullPointerException("time");
+        }
         return new LocalDateTime(date, time);
     }
 
@@ -36,22 +92,75 @@ public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, in
         return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute, second, nano));
     }
 
+    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute) {
+        return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute));
+    }
+
+    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second) {
+        return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute, second));
+    }
+
+    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second,
+            int nano) {
+        return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute, second, nano));
+    }
+
     public static LocalDateTime ofInstant(Instant instant, ZoneId zone) {
         return DateTimeSupport.localDateTimeFromInstant(instant, zone);
     }
 
+    /// The date and time `epochSecond` seconds and `nanoOfSecond` nanoseconds
+    /// after 1970-01-01T00:00 at `offset`.
+    public static LocalDateTime ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset) {
+        TimeArithmetic.check("NanoOfSecond", 0, 999999999, nanoOfSecond);
+        long localSecond = epochSecond + offset.getTotalSeconds();
+        long localEpochDay = TimeArithmetic.floorDiv(localSecond, TimeArithmetic.SECONDS_PER_DAY);
+        int secsOfDay = (int) TimeArithmetic.floorMod(localSecond, TimeArithmetic.SECONDS_PER_DAY);
+        LocalDate date = LocalDate.ofEpochDay(localEpochDay);
+        LocalTime time = LocalTime.ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + nanoOfSecond);
+        return new LocalDateTime(date, time);
+    }
+
+    /// The date and time of `temporal`.
+    public static LocalDateTime from(TemporalAccessor temporal) {
+        if (temporal instanceof LocalDateTime) {
+            return (LocalDateTime) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toLocalDateTime();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toLocalDateTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain LocalDateTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
+    }
+
     public static LocalDateTime parse(CharSequence text) {
-        return (LocalDateTime) DateTimeFormatter.ISO_LOCAL_DATE_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
     }
 
     public static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (LocalDateTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
+    @Override
     public LocalDate toLocalDate() {
         return date;
     }
 
+    @Override
     public LocalTime toLocalTime() {
         return time;
     }
@@ -64,10 +173,22 @@ public int getMonthValue() {
         return date.getMonthValue();
     }
 
+    public Month getMonth() {
+        return date.getMonth();
+    }
+
     public int getDayOfMonth() {
         return date.getDayOfMonth();
     }
 
+    public int getDayOfYear() {
+        return date.getDayOfYear();
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return date.getDayOfWeek();
+    }
+
     public int getHour() {
         return time.getHour();
     }
@@ -84,58 +205,332 @@ public int getNano() {
         return time.getNano();
     }
 
+    public LocalDateTime withYear(int year) {
+        return with(date.withYear(year), time);
+    }
+
+    public LocalDateTime withMonth(int month) {
+        return with(date.withMonth(month), time);
+    }
+
+    public LocalDateTime withDayOfMonth(int dayOfMonth) {
+        return with(date.withDayOfMonth(dayOfMonth), time);
+    }
+
+    public LocalDateTime withDayOfYear(int dayOfYear) {
+        return with(date.withDayOfYear(dayOfYear), time);
+    }
+
+    public LocalDateTime withHour(int hour) {
+        return with(date, time.withHour(hour));
+    }
+
+    public LocalDateTime withMinute(int minute) {
+        return with(date, time.withMinute(minute));
+    }
+
+    public LocalDateTime withSecond(int second) {
+        return with(date, time.withSecond(second));
+    }
+
+    public LocalDateTime withNano(int nanoOfSecond) {
+        return with(date, time.withNano(nanoOfSecond));
+    }
+
+    /// This value with everything smaller than `unit` set to zero. The unit
+    /// has to divide a day.
+    public LocalDateTime truncatedTo(TemporalUnit unit) {
+        return with(date, time.truncatedTo(unit));
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit != ChronoUnit.FOREVER;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public LocalDateTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plusDays(amountToAdd / 86400000000L).plusNanos((amountToAdd % 86400000000L) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusDays(amountToAdd / 86400000L).plusNanos((amountToAdd % 86400000L) * 1000000);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            if (u == ChronoUnit.MINUTES) {
+                return plusMinutes(amountToAdd);
+            }
+            if (u == ChronoUnit.HOURS) {
+                return plusHours(amountToAdd);
+            }
+            if (u == ChronoUnit.HALF_DAYS) {
+                // The JDK's own arithmetic, 256 half days to a step.
+                return plusDays(amountToAdd / 256).plusHours((amountToAdd % 256) * 12);
+            }
+            return with(date.plus(amountToAdd, unit), time);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public LocalDateTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public LocalDateTime plus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            Period periodToAdd = (Period) amount;
+            return with(date.plus(periodToAdd), time);
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToAdd");
+        }
+        return (LocalDateTime) amount.addTo(this);
+    }
+
+    @Override
+    public LocalDateTime minus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            Period periodToSubtract = (Period) amount;
+            return with(date.minus(periodToSubtract), time);
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToSubtract");
+        }
+        return (LocalDateTime) amount.subtractFrom(this);
+    }
+
+    public LocalDateTime plusYears(long years) {
+        return with(date.plusYears(years), time);
+    }
+
+    public LocalDateTime plusMonths(long months) {
+        return with(date.plusMonths(months), time);
+    }
+
+    public LocalDateTime plusWeeks(long weeks) {
+        return with(date.plusWeeks(weeks), time);
+    }
+
     public LocalDateTime plusDays(long days) {
-        return of(date.plusDays(days), time);
+        return with(date.plusDays(days), time);
     }
 
     public LocalDateTime plusHours(long hours) {
-        long totalNanos = time.toNanoOfDay() + hours * 3600L * DateTimeSupport.NANOS_PER_SECOND;
-        long dayAdjust = DateTimeSupport.floorDiv(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        long nanoOfDay = DateTimeSupport.floorMod(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        return of(date.plusDays(dayAdjust), LocalTime.ofNanoOfDay(nanoOfDay));
+        return plusWithOverflow(date, hours, 0, 0, 0, 1);
     }
 
     public LocalDateTime plusMinutes(long minutes) {
-        return plusHours(minutes / 60).plusSeconds((minutes % 60) * 60);
+        return plusWithOverflow(date, 0, minutes, 0, 0, 1);
     }
 
     public LocalDateTime plusSeconds(long seconds) {
-        long totalNanos = time.toNanoOfDay() + seconds * DateTimeSupport.NANOS_PER_SECOND;
-        long dayAdjust = DateTimeSupport.floorDiv(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        long nanoOfDay = DateTimeSupport.floorMod(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        return of(date.plusDays(dayAdjust), LocalTime.ofNanoOfDay(nanoOfDay));
+        return plusWithOverflow(date, 0, 0, seconds, 0, 1);
+    }
+
+    public LocalDateTime plusNanos(long nanos) {
+        return plusWithOverflow(date, 0, 0, 0, nanos, 1);
+    }
+
+    public LocalDateTime minusYears(long years) {
+        return years == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-years);
+    }
+
+    public LocalDateTime minusMonths(long months) {
+        return months == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-months);
+    }
+
+    public LocalDateTime minusWeeks(long weeks) {
+        return weeks == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1) : plusWeeks(-weeks);
     }
 
-    public Instant toInstant(ZoneOffset offset) {
-        return Instant.ofEpochSecond(DateTimeSupport.toEpochSecond(date, time, offset), time.getNano());
+    public LocalDateTime minusDays(long days) {
+        return days == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-days);
+    }
+
+    public LocalDateTime minusHours(long hours) {
+        return plusWithOverflow(date, hours, 0, 0, 0, -1);
+    }
+
+    public LocalDateTime minusMinutes(long minutes) {
+        return plusWithOverflow(date, 0, minutes, 0, 0, -1);
+    }
+
+    public LocalDateTime minusSeconds(long seconds) {
+        return plusWithOverflow(date, 0, 0, seconds, 0, -1);
+    }
+
+    public LocalDateTime minusNanos(long nanos) {
+        return plusWithOverflow(date, 0, 0, 0, nanos, -1);
+    }
+
+    /// The time added a unit at a time, each taken apart into whole days and
+    /// the rest first, so no step overflows while the result fits.
+    private LocalDateTime plusWithOverflow(LocalDate newDate, long hours, long minutes, long seconds, long nanos,
+            int sign) {
+        if ((hours | minutes | seconds | nanos) == 0) {
+            return with(newDate, time);
+        }
+        long totDays = nanos / NANOS_PER_DAY + seconds / 86400L + minutes / 1440L + hours / 24L;
+        totDays *= sign;
+        long totNanos = nanos % NANOS_PER_DAY + (seconds % 86400L) * NANOS_PER_SECOND
+                + (minutes % 1440L) * NANOS_PER_MINUTE + (hours % 24L) * NANOS_PER_HOUR;
+        long curNoD = time.toNanoOfDay();
+        totNanos = totNanos * sign + curNoD;
+        totDays += TimeArithmetic.floorDiv(totNanos, NANOS_PER_DAY);
+        long newNoD = TimeArithmetic.floorMod(totNanos, NANOS_PER_DAY);
+        LocalTime newTime = newNoD == curNoD ? time : LocalTime.ofNanoOfDay(newNoD);
+        return with(newDate.plusDays(totDays), newTime);
+    }
+
+    /// The whole units of `unit` from this value to `endExclusive`.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        LocalDateTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u.isTimeBased()) {
+                long amount = end.date.toEpochDay() - date.toEpochDay();
+                if (amount == 0) {
+                    return time.until(end.time, unit);
+                }
+                long timePart = end.time.toNanoOfDay() - time.toNanoOfDay();
+                if (amount > 0) {
+                    amount--;
+                    timePart += NANOS_PER_DAY;
+                } else {
+                    amount++;
+                    timePart -= NANOS_PER_DAY;
+                }
+                if (u == ChronoUnit.NANOS) {
+                    amount = TimeArithmetic.multiplyExact(amount, NANOS_PER_DAY);
+                } else if (u == ChronoUnit.MICROS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 86400000000L);
+                    timePart = timePart / 1000;
+                } else if (u == ChronoUnit.MILLIS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 86400000L);
+                    timePart = timePart / 1000000;
+                } else if (u == ChronoUnit.SECONDS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 86400L);
+                    timePart = timePart / NANOS_PER_SECOND;
+                } else if (u == ChronoUnit.MINUTES) {
+                    amount = TimeArithmetic.multiplyExact(amount, 1440L);
+                    timePart = timePart / NANOS_PER_MINUTE;
+                } else if (u == ChronoUnit.HOURS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 24L);
+                    timePart = timePart / NANOS_PER_HOUR;
+                } else {
+                    amount = TimeArithmetic.multiplyExact(amount, 2L);
+                    timePart = timePart / (NANOS_PER_HOUR * 12);
+                }
+                return TimeArithmetic.addExact(amount, timePart);
+            }
+            LocalDate endDate = end.date;
+            if (endDate.isAfter(date) && end.time.isBefore(time)) {
+                endDate = endDate.minusDays(1);
+            } else if (endDate.isBefore(date) && end.time.isAfter(time)) {
+                endDate = endDate.plusDays(1);
+            }
+            return date.until(endDate, unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
+    /// This date and time in `zone`.
+    public ZonedDateTime atZone(ZoneId zone) {
+        return ZonedDateTime.of(this, zone);
+    }
+
+    /// This date and time at `offset`.
+    public OffsetDateTime atOffset(ZoneOffset offset) {
+        return OffsetDateTime.of(this, offset);
     }
 
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
-    public int compareTo(LocalDateTime other) {
+    private int compareTo0(LocalDateTime other) {
         int cmp = date.compareTo(other.date);
-        return cmp != 0 ? cmp : time.compareTo(other.time);
+        if (cmp == 0) {
+            cmp = time.compareTo(other.time);
+        }
+        return cmp;
     }
 
-    public boolean equals(Object obj) {
-        return obj instanceof LocalDateTime && compareTo((LocalDateTime) obj) == 0;
+    @Override
+    public int compareTo(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other);
+        }
+        int cmp = toLocalDate().compareTo(other.toLocalDate());
+        if (cmp == 0) {
+            cmp = toLocalTime().compareTo(other.toLocalTime());
+        }
+        return cmp;
     }
 
-    public int hashCode() {
-        return date.hashCode() * 31 + time.hashCode();
+    @Override
+    public boolean isAfter(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other) > 0;
+        }
+        return compareTo(other) > 0;
     }
 
-    public String toString() {
-        return DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(this);
+    @Override
+    public boolean isBefore(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other) < 0;
+        }
+        return compareTo(other) < 0;
     }
 
-    Instant toInstant() {
-        return toInstant(ZoneOffset.UTC);
+    @Override
+    public boolean isEqual(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other) == 0;
+        }
+        return compareTo(other) == 0;
     }
 
-    ZoneId getZoneForFormatting() {
-        return ZoneOffset.UTC;
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof LocalDateTime)) {
+            return false;
+        }
+        LocalDateTime other = (LocalDateTime) obj;
+        return date.equals(other.date) && time.equals(other.time);
+    }
+
+    @Override
+    public int hashCode() {
+        return date.hashCode() ^ time.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return date.toString() + 'T' + time.toString();
     }
 }
diff --git a/Ports/CLDC11/src/java/time/LocalTime.java b/Ports/CLDC11/src/java/time/LocalTime.java
index 51d76969676..41bd7496b5d 100644
--- a/Ports/CLDC11/src/java/time/LocalTime.java
+++ b/Ports/CLDC11/src/java/time/LocalTime.java
@@ -1,10 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
 
-public final class LocalTime implements Comparable<LocalTime>, TemporalAccessor {
+/// A time of day with no date and no zone, such as 10:15:30.
+public final class LocalTime implements Temporal, Comparable<LocalTime> {
+    /// 00:00.
     public static final LocalTime MIDNIGHT = new LocalTime(0, 0, 0, 0);
+    /// 00:00, the earliest time of day.
+    public static final LocalTime MIN = MIDNIGHT;
+    /// 12:00.
+    public static final LocalTime NOON = new LocalTime(12, 0, 0, 0);
+    /// 23:59:59.999999999, the latest time of day.
+    public static final LocalTime MAX = new LocalTime(23, 59, 59, 999999999);
+
+    private static final long NANOS_PER_SECOND = TimeArithmetic.NANOS_PER_SECOND;
+    private static final long NANOS_PER_MINUTE = 60L * NANOS_PER_SECOND;
+    private static final long NANOS_PER_HOUR = 60L * NANOS_PER_MINUTE;
+    private static final long NANOS_PER_DAY = TimeArithmetic.NANOS_PER_DAY;
 
     private final int hour;
     private final int minute;
@@ -12,53 +51,103 @@ public final class LocalTime implements Comparable<LocalTime>, TemporalAccessor
     private final int nano;
 
     private LocalTime(int hour, int minute, int second, int nano) {
-        DateTimeSupport.checkTime(hour, minute, second, nano);
         this.hour = hour;
         this.minute = minute;
         this.second = second;
         this.nano = nano;
     }
 
+    private static LocalTime create(int hour, int minute, int second, int nano) {
+        if ((minute | second | nano) == 0 && hour == 0) {
+            return MIDNIGHT;
+        }
+        return new LocalTime(hour, minute, second, nano);
+    }
+
     public static LocalTime now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The time of day now in `zone`.
+    public static LocalTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static LocalTime now(Clock clock) {
         return LocalDateTime.ofInstant(clock.instant(), clock.getZone()).toLocalTime();
     }
 
     public static LocalTime of(int hour, int minute) {
-        return new LocalTime(hour, minute, 0, 0);
+        return of(hour, minute, 0, 0);
     }
 
     public static LocalTime of(int hour, int minute, int second) {
-        return new LocalTime(hour, minute, second, 0);
+        return of(hour, minute, second, 0);
     }
 
-    public static LocalTime of(int hour, int minute, int second, int nano) {
-        return new LocalTime(hour, minute, second, nano);
+    public static LocalTime of(int hour, int minute, int second, int nanoOfSecond) {
+        TimeArithmetic.check("HourOfDay", 0, 23, hour);
+        TimeArithmetic.check("MinuteOfHour", 0, 59, minute);
+        TimeArithmetic.check("SecondOfMinute", 0, 59, second);
+        TimeArithmetic.check("NanoOfSecond", 0, 999999999, nanoOfSecond);
+        return create(hour, minute, second, nanoOfSecond);
     }
 
     public static LocalTime ofSecondOfDay(long secondOfDay) {
+        TimeArithmetic.check("SecondOfDay", 0, 86399, secondOfDay);
         int hours = (int) (secondOfDay / 3600);
-        int minutes = (int) ((secondOfDay % 3600) / 60);
-        int seconds = (int) (secondOfDay % 60);
-        return of(hours, minutes, seconds);
+        secondOfDay -= hours * 3600L;
+        int minutes = (int) (secondOfDay / 60);
+        secondOfDay -= minutes * 60L;
+        return create(hours, minutes, (int) secondOfDay, 0);
     }
 
     public static LocalTime ofNanoOfDay(long nanoOfDay) {
-        long secondOfDay = nanoOfDay / DateTimeSupport.NANOS_PER_SECOND;
-        int nanos = (int) (nanoOfDay % DateTimeSupport.NANOS_PER_SECOND);
-        LocalTime base = ofSecondOfDay(secondOfDay);
-        return of(base.hour, base.minute, base.second, nanos);
+        TimeArithmetic.check("NanoOfDay", 0, NANOS_PER_DAY - 1, nanoOfDay);
+        int hours = (int) (nanoOfDay / NANOS_PER_HOUR);
+        nanoOfDay -= hours * NANOS_PER_HOUR;
+        int minutes = (int) (nanoOfDay / NANOS_PER_MINUTE);
+        nanoOfDay -= minutes * NANOS_PER_MINUTE;
+        int seconds = (int) (nanoOfDay / NANOS_PER_SECOND);
+        nanoOfDay -= seconds * NANOS_PER_SECOND;
+        return create(hours, minutes, seconds, (int) nanoOfDay);
+    }
+
+    /// The time of day of `temporal`.
+    public static LocalTime from(TemporalAccessor temporal) {
+        if (temporal instanceof LocalTime) {
+            return (LocalTime) temporal;
+        }
+        if (temporal instanceof LocalDateTime) {
+            return ((LocalDateTime) temporal).toLocalTime();
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toLocalTime();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toLocalTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain LocalTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static LocalTime parse(CharSequence text) {
-        return (LocalTime) DateTimeFormatter.ISO_LOCAL_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_LOCAL_TIME);
     }
 
     public static LocalTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (LocalTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public int getHour() {
@@ -82,50 +171,268 @@ public int toSecondOfDay() {
     }
 
     public long toNanoOfDay() {
-        return toSecondOfDay() * DateTimeSupport.NANOS_PER_SECOND + nano;
+        return hour * NANOS_PER_HOUR + minute * NANOS_PER_MINUTE + second * NANOS_PER_SECOND + nano;
+    }
+
+    /// This time of day on `date`.
+    public LocalDateTime atDate(LocalDate date) {
+        return LocalDateTime.of(date, this);
+    }
+
+    public LocalTime withHour(int hour) {
+        if (this.hour == hour) {
+            return this;
+        }
+        TimeArithmetic.check("HourOfDay", 0, 23, hour);
+        return create(hour, minute, second, nano);
+    }
+
+    public LocalTime withMinute(int minute) {
+        if (this.minute == minute) {
+            return this;
+        }
+        TimeArithmetic.check("MinuteOfHour", 0, 59, minute);
+        return create(hour, minute, second, nano);
+    }
+
+    public LocalTime withSecond(int second) {
+        if (this.second == second) {
+            return this;
+        }
+        TimeArithmetic.check("SecondOfMinute", 0, 59, second);
+        return create(hour, minute, second, nano);
+    }
+
+    public LocalTime withNano(int nanoOfSecond) {
+        if (this.nano == nanoOfSecond) {
+            return this;
+        }
+        TimeArithmetic.check("NanoOfSecond", 0, 999999999, nanoOfSecond);
+        return create(hour, minute, second, nanoOfSecond);
+    }
+
+    /// This time with everything smaller than `unit` set to zero. The unit
+    /// has to divide a day.
+    public LocalTime truncatedTo(TemporalUnit unit) {
+        if (unit == ChronoUnit.NANOS) {
+            return this;
+        }
+        long dur = TimeArithmetic.truncationNanos(unit);
+        long nod = toNanoOfDay();
+        return ofNanoOfDay((nod / dur) * dur);
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit.isTimeBased();
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public LocalTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plusNanos((amountToAdd % 86400000000L) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusNanos((amountToAdd % 86400000L) * 1000000);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            if (u == ChronoUnit.MINUTES) {
+                return plusMinutes(amountToAdd);
+            }
+            if (u == ChronoUnit.HOURS) {
+                return plusHours(amountToAdd);
+            }
+            if (u == ChronoUnit.HALF_DAYS) {
+                return plusHours((amountToAdd % 2) * 12);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public LocalTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public LocalTime plus(TemporalAmount amount) {
+        return (LocalTime) amount.addTo(this);
+    }
+
+    @Override
+    public LocalTime minus(TemporalAmount amount) {
+        return (LocalTime) amount.subtractFrom(this);
     }
 
     public LocalTime plusHours(long hoursToAdd) {
-        return ofNanoOfDay(DateTimeSupport.floorMod(toNanoOfDay() + hoursToAdd * 3600L * DateTimeSupport.NANOS_PER_SECOND,
-                DateTimeSupport.NANOS_PER_DAY));
+        if (hoursToAdd == 0) {
+            return this;
+        }
+        int newHour = ((int) (hoursToAdd % 24) + hour + 24) % 24;
+        return create(newHour, minute, second, nano);
     }
 
     public LocalTime plusMinutes(long minutesToAdd) {
-        return ofNanoOfDay(DateTimeSupport.floorMod(toNanoOfDay() + minutesToAdd * 60L * DateTimeSupport.NANOS_PER_SECOND,
-                DateTimeSupport.NANOS_PER_DAY));
+        if (minutesToAdd == 0) {
+            return this;
+        }
+        int mofd = hour * 60 + minute;
+        int newMofd = ((int) (minutesToAdd % 1440) + mofd + 1440) % 1440;
+        if (mofd == newMofd) {
+            return this;
+        }
+        return create(newMofd / 60, newMofd % 60, second, nano);
+    }
+
+    public LocalTime plusSeconds(long secondstoAdd) {
+        if (secondstoAdd == 0) {
+            return this;
+        }
+        int sofd = toSecondOfDay();
+        int newSofd = ((int) (secondstoAdd % 86400) + sofd + 86400) % 86400;
+        if (sofd == newSofd) {
+            return this;
+        }
+        return create(newSofd / 3600, (newSofd / 60) % 60, newSofd % 60, nano);
     }
 
-    public LocalTime plusSeconds(long secondsToAdd) {
-        return ofNanoOfDay(DateTimeSupport.floorMod(toNanoOfDay() + secondsToAdd * DateTimeSupport.NANOS_PER_SECOND,
-                DateTimeSupport.NANOS_PER_DAY));
+    public LocalTime plusNanos(long nanosToAdd) {
+        if (nanosToAdd == 0) {
+            return this;
+        }
+        long nofd = toNanoOfDay();
+        long newNofd = ((nanosToAdd % NANOS_PER_DAY) + nofd + NANOS_PER_DAY) % NANOS_PER_DAY;
+        if (nofd == newNofd) {
+            return this;
+        }
+        return ofNanoOfDay(newNofd);
+    }
+
+    public LocalTime minusHours(long hoursToSubtract) {
+        return plusHours(-(hoursToSubtract % 24));
+    }
+
+    public LocalTime minusMinutes(long minutesToSubtract) {
+        return plusMinutes(-(minutesToSubtract % 1440));
+    }
+
+    public LocalTime minusSeconds(long secondsToSubtract) {
+        return plusSeconds(-(secondsToSubtract % 86400));
+    }
+
+    public LocalTime minusNanos(long nanosToSubtract) {
+        return plusNanos(-(nanosToSubtract % NANOS_PER_DAY));
+    }
+
+    /// The whole units of `unit` from this time to `endExclusive`, within
+    /// one day.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        LocalTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            long nanosUntil = end.toNanoOfDay() - toNanoOfDay();
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return nanosUntil;
+            }
+            if (u == ChronoUnit.MICROS) {
+                return nanosUntil / 1000;
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return nanosUntil / 1000000;
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return nanosUntil / NANOS_PER_SECOND;
+            }
+            if (u == ChronoUnit.MINUTES) {
+                return nanosUntil / NANOS_PER_MINUTE;
+            }
+            if (u == ChronoUnit.HOURS) {
+                return nanosUntil / NANOS_PER_HOUR;
+            }
+            if (u == ChronoUnit.HALF_DAYS) {
+                return nanosUntil / (12 * NANOS_PER_HOUR);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
     }
 
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
+    public boolean isAfter(LocalTime other) {
+        return compareTo(other) > 0;
+    }
+
+    public boolean isBefore(LocalTime other) {
+        return compareTo(other) < 0;
+    }
+
+    @Override
     public int compareTo(LocalTime other) {
-        if (hour != other.hour) {
-            return hour < other.hour ? -1 : 1;
-        }
-        if (minute != other.minute) {
-            return minute < other.minute ? -1 : 1;
-        }
-        if (second != other.second) {
-            return second < other.second ? -1 : 1;
-        }
-        return nano < other.nano ? -1 : nano > other.nano ? 1 : 0;
+        long a = toNanoOfDay();
+        long b = other.toNanoOfDay();
+        return a < b ? -1 : a > b ? 1 : 0;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof LocalTime && compareTo((LocalTime) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof LocalTime)) {
+            return false;
+        }
+        LocalTime other = (LocalTime) obj;
+        return hour == other.hour && minute == other.minute && second == other.second && nano == other.nano;
     }
 
+    @Override
     public int hashCode() {
-        return hour * 3600 + minute * 60 + second + nano;
+        long nod = toNanoOfDay();
+        return (int) (nod ^ (nod >>> 32));
     }
 
+    /// The JDK's text: `HH:mm`, then `:ss` when there are seconds or a
+    /// fraction, then the fraction in as many groups of three digits as it
+    /// needs.
+    @Override
     public String toString() {
-        return DateTimeFormatter.ISO_LOCAL_TIME.format(this);
+        StringBuilder buf = new StringBuilder(18);
+        buf.append(hour < 10 ? "0" : "").append(hour).append(minute < 10 ? ":0" : ":").append(minute);
+        if (second > 0 || nano > 0) {
+            buf.append(second < 10 ? ":0" : ":").append(second);
+            if (nano > 0) {
+                buf.append('.');
+                if (nano % 1000000 == 0) {
+                    buf.append(Integer.toString((nano / 1000000) + 1000).substring(1));
+                } else if (nano % 1000 == 0) {
+                    buf.append(Integer.toString((nano / 1000) + 1000000).substring(1));
+                } else {
+                    buf.append(Integer.toString(nano + 1000000000).substring(1));
+                }
+            }
+        }
+        return buf.toString();
     }
 }
diff --git a/Ports/CLDC11/src/java/time/Month.java b/Ports/CLDC11/src/java/time/Month.java
new file mode 100644
index 00000000000..3d2ef98b516
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/Month.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time;
+
+import java.time.temporal.TemporalAccessor;
+
+/// The twelve months of the ISO calendar.
+public enum Month implements TemporalAccessor {
+    /// January, month 1.
+    JANUARY,
+    /// February, month 2.
+    FEBRUARY,
+    /// March, month 3.
+    MARCH,
+    /// April, month 4.
+    APRIL,
+    /// May, month 5.
+    MAY,
+    /// June, month 6.
+    JUNE,
+    /// July, month 7.
+    JULY,
+    /// August, month 8.
+    AUGUST,
+    /// September, month 9.
+    SEPTEMBER,
+    /// October, month 10.
+    OCTOBER,
+    /// November, month 11.
+    NOVEMBER,
+    /// December, month 12.
+    DECEMBER;
+
+    private static final Month[] ALL = values();
+
+    /// The month numbered `month`, 1 for January to 12 for December.
+    public static Month of(int month) {
+        if (month < 1 || month > 12) {
+            throw new DateTimeException("Invalid value for MonthOfYear: " + month);
+        }
+        return ALL[month - 1];
+    }
+
+    /// 1 for January to 12 for December.
+    public int getValue() {
+        return ordinal() + 1;
+    }
+
+    /// The month `months` later, around the year.
+    public Month plus(long months) {
+        int amount = (int) (months % 12);
+        return ALL[(ordinal() + amount + 12) % 12];
+    }
+
+    /// The month `months` earlier, around the year.
+    public Month minus(long months) {
+        return plus(-(months % 12));
+    }
+
+    /// The number of days of this month in a leap year or another.
+    public int length(boolean leapYear) {
+        // Not a switch: one over an enum compiles to a class that catches
+        // NoSuchFieldError, which a device does not have.
+        if (this == FEBRUARY) {
+            return leapYear ? 29 : 28;
+        }
+        if (this == APRIL || this == JUNE || this == SEPTEMBER || this == NOVEMBER) {
+            return 30;
+        }
+        return 31;
+    }
+
+    /// The fewest days this month can have.
+    public int minLength() {
+        return length(false);
+    }
+
+    /// The most days this month can have.
+    public int maxLength() {
+        return length(true);
+    }
+
+    /// The day of the year this month starts on, 1 for January.
+    public int firstDayOfYear(boolean leapYear) {
+        int day = 1;
+        for (int i = 0; i < ordinal(); i++) {
+            day += ALL[i].length(leapYear);
+        }
+        return day;
+    }
+
+    /// The first month of the quarter this month is in.
+    public Month firstMonthOfQuarter() {
+        return ALL[ordinal() / 3 * 3];
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/OffsetDateTime.java b/Ports/CLDC11/src/java/time/OffsetDateTime.java
index 5de661396cf..5e175e1f420 100644
--- a/Ports/CLDC11/src/java/time/OffsetDateTime.java
+++ b/Ports/CLDC11/src/java/time/OffsetDateTime.java
@@ -1,17 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+
+/// A date and time with a fixed offset from UTC, such as
+/// 2007-12-03T10:15:30+01:00.
+public final class OffsetDateTime implements Temporal, Comparable<OffsetDateTime> {
+    /// The earliest date and time, at the largest offset.
+    public static final OffsetDateTime MIN = new OffsetDateTime(LocalDateTime.MIN, ZoneOffset.MAX);
+
+    /// The latest date and time, at the smallest offset.
+    public static final OffsetDateTime MAX = new OffsetDateTime(LocalDateTime.MAX, ZoneOffset.MIN);
 
-public final class OffsetDateTime implements Comparable<OffsetDateTime>, TemporalAccessor {
     private final LocalDateTime dateTime;
     private final ZoneOffset offset;
 
     private OffsetDateTime(LocalDateTime dateTime, ZoneOffset offset) {
+        if (dateTime == null) {
+            throw new NullPointerException("dateTime");
+        }
+        if (offset == null) {
+            throw new NullPointerException("offset");
+        }
         this.dateTime = dateTime;
         this.offset = offset;
     }
 
+    public static OffsetDateTime now() {
+        return now(Clock.systemDefaultZone());
+    }
+
+    public static OffsetDateTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
+    public static OffsetDateTime now(Clock clock) {
+        return ofInstant(clock.instant(), clock.getZone());
+    }
+
     public static OffsetDateTime of(LocalDate date, LocalTime time, ZoneOffset offset) {
         return new OffsetDateTime(LocalDateTime.of(date, time), offset);
     }
@@ -20,24 +72,67 @@ public static OffsetDateTime of(LocalDateTime dateTime, ZoneOffset offset) {
         return new OffsetDateTime(dateTime, offset);
     }
 
+    public static OffsetDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second,
+            int nanoOfSecond, ZoneOffset offset) {
+        return new OffsetDateTime(LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond),
+                offset);
+    }
+
     public static OffsetDateTime ofInstant(Instant instant, ZoneId zone) {
+        if (instant == null) {
+            throw new NullPointerException("instant");
+        }
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
         ZoneOffset offset = DateTimeSupport.offsetFromInstant(instant, zone);
-        LocalDateTime local = LocalDateTime.ofInstant(instant, zone);
-        return new OffsetDateTime(local, offset);
+        return new OffsetDateTime(LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset),
+                offset);
+    }
+
+    /// The date, time and offset of `temporal`.
+    public static OffsetDateTime from(TemporalAccessor temporal) {
+        if (temporal instanceof OffsetDateTime) {
+            return (OffsetDateTime) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toOffsetDateTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain OffsetDateTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static OffsetDateTime parse(CharSequence text) {
-        return (OffsetDateTime) DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_OFFSET_DATE_TIME);
     }
 
     public static OffsetDateTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (OffsetDateTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public LocalDateTime toLocalDateTime() {
         return dateTime;
     }
 
+    public LocalDate toLocalDate() {
+        return dateTime.toLocalDate();
+    }
+
+    public LocalTime toLocalTime() {
+        return dateTime.toLocalTime();
+    }
+
     public ZoneOffset getOffset() {
         return offset;
     }
@@ -46,28 +141,285 @@ public Instant toInstant() {
         return dateTime.toInstant(offset);
     }
 
+    public long toEpochSecond() {
+        return dateTime.toEpochSecond(offset);
+    }
+
+    /// This date and time, as a moment in `offset`'s own zone.
+    public ZonedDateTime toZonedDateTime() {
+        return ZonedDateTime.of(dateTime, offset);
+    }
+
+    /// The same moment in `zone`.
+    public ZonedDateTime atZoneSameInstant(ZoneId zone) {
+        return ZonedDateTime.ofInstant(dateTime, offset, zone);
+    }
+
+    /// The same moment at another offset.
+    public OffsetDateTime withOffsetSameInstant(ZoneOffset offset) {
+        if (offset.equals(this.offset)) {
+            return this;
+        }
+        int difference = offset.getTotalSeconds() - this.offset.getTotalSeconds();
+        return new OffsetDateTime(dateTime.plusSeconds(difference), offset);
+    }
+
+    /// The same wall clock time at another offset.
+    public OffsetDateTime withOffsetSameLocal(ZoneOffset offset) {
+        return offset.equals(this.offset) ? this : new OffsetDateTime(dateTime, offset);
+    }
+
+    public int getYear() {
+        return dateTime.getYear();
+    }
+
+    public int getMonthValue() {
+        return dateTime.getMonthValue();
+    }
+
+    public Month getMonth() {
+        return dateTime.getMonth();
+    }
+
+    public int getDayOfMonth() {
+        return dateTime.getDayOfMonth();
+    }
+
+    public int getDayOfYear() {
+        return dateTime.getDayOfYear();
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return dateTime.getDayOfWeek();
+    }
+
+    public int getHour() {
+        return dateTime.getHour();
+    }
+
+    public int getMinute() {
+        return dateTime.getMinute();
+    }
+
+    public int getSecond() {
+        return dateTime.getSecond();
+    }
+
+    public int getNano() {
+        return dateTime.getNano();
+    }
+
+    private OffsetDateTime with(LocalDateTime newDateTime) {
+        return newDateTime == dateTime ? this : new OffsetDateTime(newDateTime, offset);
+    }
+
+    public OffsetDateTime withYear(int year) {
+        return with(dateTime.withYear(year));
+    }
+
+    public OffsetDateTime withMonth(int month) {
+        return with(dateTime.withMonth(month));
+    }
+
+    public OffsetDateTime withDayOfMonth(int dayOfMonth) {
+        return with(dateTime.withDayOfMonth(dayOfMonth));
+    }
+
+    public OffsetDateTime withDayOfYear(int dayOfYear) {
+        return with(dateTime.withDayOfYear(dayOfYear));
+    }
+
+    public OffsetDateTime withHour(int hour) {
+        return with(dateTime.withHour(hour));
+    }
+
+    public OffsetDateTime withMinute(int minute) {
+        return with(dateTime.withMinute(minute));
+    }
+
+    public OffsetDateTime withSecond(int second) {
+        return with(dateTime.withSecond(second));
+    }
+
+    public OffsetDateTime withNano(int nanoOfSecond) {
+        return with(dateTime.withNano(nanoOfSecond));
+    }
+
+    public OffsetDateTime truncatedTo(TemporalUnit unit) {
+        return with(dateTime.truncatedTo(unit));
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit != ChronoUnit.FOREVER;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public OffsetDateTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return with(dateTime.plus(amountToAdd, unit));
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public OffsetDateTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public OffsetDateTime plus(TemporalAmount amount) {
+        if (amount == null) {
+            throw new NullPointerException("amountToAdd");
+        }
+        return (OffsetDateTime) amount.addTo(this);
+    }
+
+    @Override
+    public OffsetDateTime minus(TemporalAmount amount) {
+        if (amount == null) {
+            throw new NullPointerException("amountToSubtract");
+        }
+        return (OffsetDateTime) amount.subtractFrom(this);
+    }
+
+    public OffsetDateTime plusYears(long years) {
+        return with(dateTime.plusYears(years));
+    }
+
+    public OffsetDateTime plusMonths(long months) {
+        return with(dateTime.plusMonths(months));
+    }
+
+    public OffsetDateTime plusWeeks(long weeks) {
+        return with(dateTime.plusWeeks(weeks));
+    }
+
+    public OffsetDateTime plusDays(long days) {
+        return with(dateTime.plusDays(days));
+    }
+
+    public OffsetDateTime plusHours(long hours) {
+        return with(dateTime.plusHours(hours));
+    }
+
+    public OffsetDateTime plusMinutes(long minutes) {
+        return with(dateTime.plusMinutes(minutes));
+    }
+
+    public OffsetDateTime plusSeconds(long seconds) {
+        return with(dateTime.plusSeconds(seconds));
+    }
+
+    public OffsetDateTime plusNanos(long nanos) {
+        return with(dateTime.plusNanos(nanos));
+    }
+
+    public OffsetDateTime minusYears(long years) {
+        return with(dateTime.minusYears(years));
+    }
+
+    public OffsetDateTime minusMonths(long months) {
+        return with(dateTime.minusMonths(months));
+    }
+
+    public OffsetDateTime minusWeeks(long weeks) {
+        return with(dateTime.minusWeeks(weeks));
+    }
+
+    public OffsetDateTime minusDays(long days) {
+        return with(dateTime.minusDays(days));
+    }
+
+    public OffsetDateTime minusHours(long hours) {
+        return with(dateTime.minusHours(hours));
+    }
+
+    public OffsetDateTime minusMinutes(long minutes) {
+        return with(dateTime.minusMinutes(minutes));
+    }
+
+    public OffsetDateTime minusSeconds(long seconds) {
+        return with(dateTime.minusSeconds(seconds));
+    }
+
+    public OffsetDateTime minusNanos(long nanos) {
+        return with(dateTime.minusNanos(nanos));
+    }
+
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        OffsetDateTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            end = end.withOffsetSameInstant(offset);
+            return dateTime.until(end.dateTime, unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
+    public boolean isAfter(OffsetDateTime other) {
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        return a > b || (a == b && getNano() > other.getNano());
+    }
+
+    public boolean isBefore(OffsetDateTime other) {
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        return a < b || (a == b && getNano() < other.getNano());
+    }
+
+    public boolean isEqual(OffsetDateTime other) {
+        return toEpochSecond() == other.toEpochSecond() && getNano() == other.getNano();
+    }
+
+    /// Orders by moment, and moments that are equal by wall clock time.
     public int compareTo(OffsetDateTime other) {
-        int cmp = toInstant().compareTo(other.toInstant());
-        return cmp != 0 ? cmp : dateTime.compareTo(other.dateTime);
+        if (offset.equals(other.offset)) {
+            return dateTime.compareTo(other.dateTime);
+        }
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        int cmp = a < b ? -1 : (a > b ? 1 : 0);
+        if (cmp == 0) {
+            cmp = getNano() - other.getNano();
+            if (cmp == 0) {
+                cmp = dateTime.compareTo(other.dateTime);
+            }
+        }
+        return cmp;
     }
 
     public boolean equals(Object obj) {
-        return obj instanceof OffsetDateTime && compareTo((OffsetDateTime) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OffsetDateTime)) {
+            return false;
+        }
+        OffsetDateTime other = (OffsetDateTime) obj;
+        return dateTime.equals(other.dateTime) && offset.equals(other.offset);
     }
 
     public int hashCode() {
-        return dateTime.hashCode() * 31 + offset.hashCode();
+        return dateTime.hashCode() ^ offset.hashCode();
     }
 
     public String toString() {
-        return DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(this);
-    }
-
-    ZoneId getZoneForFormatting() {
-        return offset;
+        return dateTime.toString() + offset.toString();
     }
 }
diff --git a/Ports/CLDC11/src/java/time/Period.java b/Ports/CLDC11/src/java/time/Period.java
index 3fab3574b7c..77b61b2ab6c 100644
--- a/Ports/CLDC11/src/java/time/Period.java
+++ b/Ports/CLDC11/src/java/time/Period.java
@@ -1,6 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
-public final class Period {
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.time.temporal.UnsupportedTemporalTypeException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// An amount of calendar time in years, months and days, such as
+/// "2 years, 3 months and 4 days". The three are kept apart and never
+/// converted into one another except by [#normalized].
+public final class Period implements TemporalAmount {
+    public static final Period ZERO = new Period(0, 0, 0);
+
     private final int years;
     private final int months;
     private final int days;
@@ -11,20 +47,157 @@ private Period(int years, int months, int days) {
         this.days = days;
     }
 
-    public static Period of(int years, int months, int days) {
+    private static Period create(int years, int months, int days) {
+        if ((years | months | days) == 0) {
+            return ZERO;
+        }
         return new Period(years, months, days);
     }
 
+    public static Period of(int years, int months, int days) {
+        return create(years, months, days);
+    }
+
     public static Period ofDays(int days) {
-        return new Period(0, 0, days);
+        return create(0, 0, days);
+    }
+
+    public static Period ofWeeks(int weeks) {
+        return create(0, 0, TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) weeks, 7L)));
     }
 
     public static Period ofMonths(int months) {
-        return new Period(0, months, 0);
+        return create(0, months, 0);
     }
 
     public static Period ofYears(int years) {
-        return new Period(years, 0, 0);
+        return create(years, 0, 0);
+    }
+
+    /// The years, months and days from `startDateInclusive` to
+    /// `endDateExclusive`.
+    public static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive) {
+        return startDateInclusive.until(endDateExclusive);
+    }
+
+    /// The period of `amount`, which must be in years, months and days.
+    public static Period from(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            return (Period) amount;
+        }
+        if (amount == null) {
+            throw new NullPointerException("amount");
+        }
+        int years = 0;
+        int months = 0;
+        int days = 0;
+        List<TemporalUnit> units = amount.getUnits();
+        for (int i = 0; i < units.size(); i++) {
+            TemporalUnit unit = units.get(i);
+            long value = amount.get(unit);
+            if (unit == ChronoUnit.YEARS) {
+                years = TimeArithmetic.toIntExact(value);
+            } else if (unit == ChronoUnit.MONTHS) {
+                months = TimeArithmetic.toIntExact(value);
+            } else if (unit == ChronoUnit.DAYS) {
+                days = TimeArithmetic.toIntExact(value);
+            } else {
+                throw new DateTimeException("Unit must be Years, Months or Days, but was " + unit);
+            }
+        }
+        return create(years, months, days);
+    }
+
+    /// Reads `PnYnMnWnD`: each section optional but at least one present,
+    /// each number signed, the letters in either case, and a leading sign
+    /// negating the whole. Weeks are added to the days.
+    public static Period parse(CharSequence text) {
+        if (text == null) {
+            throw new NullPointerException("text");
+        }
+        String s = text.toString();
+        int pos = 0;
+        boolean negate = false;
+        if (pos < s.length() && (s.charAt(pos) == '+' || s.charAt(pos) == '-')) {
+            negate = s.charAt(pos) == '-';
+            pos++;
+        }
+        if (pos >= s.length() || (s.charAt(pos) != 'P' && s.charAt(pos) != 'p')) {
+            throw unparsablePeriod(s, null);
+        }
+        pos++;
+        String order = "YMWD";
+        long[] values = new long[4];
+        int next = 0;
+        boolean any = false;
+        try {
+            while (pos < s.length()) {
+                int start = pos;
+                if (s.charAt(pos) == '+' || s.charAt(pos) == '-') {
+                    pos++;
+                }
+                int digits = pos;
+                while (pos < s.length() && s.charAt(pos) >= '0' && s.charAt(pos) <= '9') {
+                    pos++;
+                }
+                if (pos == digits || pos >= s.length()) {
+                    throw unparsablePeriod(s, null);
+                }
+                char letter = Character.toUpperCase(s.charAt(pos));
+                int slot = order.indexOf(letter, next);
+                if (slot < 0) {
+                    throw unparsablePeriod(s, null);
+                }
+                values[slot] = Integer.parseInt(s.substring(s.charAt(start) == '+' ? start + 1 : start, pos));
+                next = slot + 1;
+                any = true;
+                pos++;
+            }
+        } catch (NumberFormatException ex) {
+            throw unparsablePeriod(s, ex);
+        }
+        if (!any) {
+            throw unparsablePeriod(s, null);
+        }
+        if (negate) {
+            for (int i = 0; i < values.length; i++) {
+                if (values[i] == Integer.MIN_VALUE) {
+                    throw unparsablePeriod(s, new ArithmeticException("integer overflow"));
+                }
+                values[i] = -values[i];
+            }
+        }
+        // Weeks join the days outside the reading, so an overflow there is
+        // the arithmetic's own exception, as the JDK's is.
+        int days = TimeArithmetic.toIntExact(values[3] + TimeArithmetic.toIntExact(values[2] * 7));
+        return create((int) values[0], (int) values[1], days);
+    }
+
+    private static java.time.format.DateTimeParseException unparsablePeriod(String text, Throwable cause) {
+        return new java.time.format.DateTimeParseException("Text cannot be parsed to a Period", text, 0, cause);
+    }
+
+    @Override
+    public long get(TemporalUnit unit) {
+        if (unit == ChronoUnit.YEARS) {
+            return years;
+        }
+        if (unit == ChronoUnit.MONTHS) {
+            return months;
+        }
+        if (unit == ChronoUnit.DAYS) {
+            return days;
+        }
+        throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+    }
+
+    @Override
+    public List<TemporalUnit> getUnits() {
+        ArrayList<TemporalUnit> units = new ArrayList<TemporalUnit>(3);
+        units.add(ChronoUnit.YEARS);
+        units.add(ChronoUnit.MONTHS);
+        units.add(ChronoUnit.DAYS);
+        return Collections.unmodifiableList(units);
     }
 
     public int getYears() {
@@ -39,19 +212,166 @@ public int getDays() {
         return days;
     }
 
-    public LocalDate addTo(LocalDate date) {
-        return date.plusYears(years).plusMonths(months).plusDays(days);
+    public boolean isZero() {
+        return this == ZERO || (years | months | days) == 0;
+    }
+
+    public boolean isNegative() {
+        return years < 0 || months < 0 || days < 0;
+    }
+
+    public Period withYears(int years) {
+        return years == this.years ? this : create(years, months, days);
+    }
+
+    public Period withMonths(int months) {
+        return months == this.months ? this : create(years, months, days);
+    }
+
+    public Period withDays(int days) {
+        return days == this.days ? this : create(years, months, days);
+    }
+
+    /// This period plus `amountToAdd`, which must be in years, months and
+    /// days; each unit is added to its own.
+    public Period plus(TemporalAmount amountToAdd) {
+        Period other = from(amountToAdd);
+        return create(TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) years, (long) other.years)),
+                TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) months, (long) other.months)),
+                TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) days, (long) other.days)));
+    }
+
+    public Period minus(TemporalAmount amountToSubtract) {
+        Period other = from(amountToSubtract);
+        return create(TimeArithmetic.toIntExact(TimeArithmetic.subtractExact((long) years, (long) other.years)),
+                TimeArithmetic.toIntExact(TimeArithmetic.subtractExact((long) months, (long) other.months)),
+                TimeArithmetic.toIntExact(TimeArithmetic.subtractExact((long) days, (long) other.days)));
+    }
+
+    public Period plusYears(long yearsToAdd) {
+        return yearsToAdd == 0 ? this
+                : create(TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) years, yearsToAdd)), months, days);
+    }
+
+    public Period plusMonths(long monthsToAdd) {
+        return monthsToAdd == 0 ? this
+                : create(years, TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) months, monthsToAdd)), days);
+    }
+
+    public Period plusDays(long daysToAdd) {
+        return daysToAdd == 0 ? this
+                : create(years, months, TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) days, daysToAdd)));
+    }
+
+    public Period minusYears(long yearsToSubtract) {
+        return yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1)
+                : plusYears(-yearsToSubtract);
+    }
+
+    public Period minusMonths(long monthsToSubtract) {
+        return monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1)
+                : plusMonths(-monthsToSubtract);
+    }
+
+    public Period minusDays(long daysToSubtract) {
+        return daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1)
+                : plusDays(-daysToSubtract);
+    }
+
+    public Period multipliedBy(int scalar) {
+        if (this == ZERO || scalar == 1) {
+            return this;
+        }
+        return create(TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) years, (long) scalar)),
+                TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) months, (long) scalar)),
+                TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) days, (long) scalar)));
+    }
+
+    public Period negated() {
+        return multipliedBy(-1);
+    }
+
+    /// The years and months rebalanced so that the months lie within
+    /// -11 to 11 with the sign of the years; the days are left as they are.
+    public Period normalized() {
+        long totalMonths = toTotalMonths();
+        long splitYears = totalMonths / 12;
+        int splitMonths = (int) (totalMonths % 12);
+        if (splitYears == years && splitMonths == months) {
+            return this;
+        }
+        return create(TimeArithmetic.toIntExact(splitYears), splitMonths, days);
+    }
+
+    public long toTotalMonths() {
+        return years * 12L + months;
+    }
+
+    /// Adds the years and months together, then the days, as the JDK does:
+    /// a date at the end of a month stays valid in between.
+    @Override
+    public Temporal addTo(Temporal temporal) {
+        if (months == 0) {
+            if (years != 0) {
+                temporal = temporal.plus(years, ChronoUnit.YEARS);
+            }
+        } else {
+            long totalMonths = toTotalMonths();
+            if (totalMonths != 0) {
+                temporal = temporal.plus(totalMonths, ChronoUnit.MONTHS);
+            }
+        }
+        if (days != 0) {
+            temporal = temporal.plus(days, ChronoUnit.DAYS);
+        }
+        return temporal;
+    }
+
+    @Override
+    public Temporal subtractFrom(Temporal temporal) {
+        if (months == 0) {
+            if (years != 0) {
+                temporal = temporal.minus(years, ChronoUnit.YEARS);
+            }
+        } else {
+            long totalMonths = toTotalMonths();
+            if (totalMonths != 0) {
+                temporal = temporal.minus(totalMonths, ChronoUnit.MONTHS);
+            }
+        }
+        if (days != 0) {
+            temporal = temporal.minus(days, ChronoUnit.DAYS);
+        }
+        return temporal;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Period)) {
+            return false;
+        }
+        Period other = (Period) obj;
+        return years == other.years && months == other.months && days == other.days;
+    }
+
+    public int hashCode() {
+        return years + ((months << 8) | (months >>> 24)) + ((days << 16) | (days >>> 16));
     }
 
     public String toString() {
-        StringBuffer sb = new StringBuffer("P");
+        if (this == ZERO || (years | months | days) == 0) {
+            return "P0D";
+        }
+        StringBuilder sb = new StringBuilder("P");
         if (years != 0) {
             sb.append(years).append('Y');
         }
         if (months != 0) {
             sb.append(months).append('M');
         }
-        if (days != 0 || (years == 0 && months == 0)) {
+        if (days != 0) {
             sb.append(days).append('D');
         }
         return sb.toString();
diff --git a/Ports/CLDC11/src/java/time/TimeArithmetic.java b/Ports/CLDC11/src/java/time/TimeArithmetic.java
new file mode 100644
index 00000000000..ca3f529cbba
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/TimeArithmetic.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time;
+
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalUnit;
+import java.time.temporal.UnsupportedTemporalTypeException;
+
+/// Exact arithmetic and unit tables the date and time classes share. The
+/// exact operations throw `ArithmeticException("long overflow")` where the
+/// JDK's `Math.*Exact` do, rather than wrapping around.
+final class TimeArithmetic {
+    static final long NANOS_PER_SECOND = 1000000000L;
+    static final long SECONDS_PER_DAY = 86400L;
+    static final long NANOS_PER_DAY = SECONDS_PER_DAY * NANOS_PER_SECOND;
+
+    /// The whole seconds of each `ChronoUnit`, by ordinal; 0 below a second.
+    private static final long[] UNIT_SECONDS = {0L, 0L, 0L, 1L, 60L, 3600L, 43200L, 86400L, 604800L,
+        2629746L, 31556952L, 315569520L, 3155695200L, 31556952000L, 31556952000000000L, Long.MAX_VALUE};
+
+    /// The nanoseconds in one unit below a second, by ordinal; 0 above.
+    private static final long[] UNIT_NANOS = {1L, 1000L, 1000000L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
+        0L, 0L, 0L};
+
+    private TimeArithmetic() {
+    }
+
+    static long floorDiv(long a, long b) {
+        long q = a / b;
+        return (a % b != 0 && ((a < 0) != (b < 0))) ? q - 1 : q;
+    }
+
+    static long floorMod(long a, long b) {
+        return a - floorDiv(a, b) * b;
+    }
+
+    static long multiplyExact(long a, long b) {
+        long r = a * b;
+        long absA = a < 0 ? -a : a;
+        long absB = b < 0 ? -b : b;
+        // MIN_VALUE * -1 is tested before the division: ParparVM divides in
+        // C, where MIN_VALUE / -1 is undefined and traps (SIGFPE) on x86.
+        if (((absA | absB) >>> 31) != 0
+                && (a == Long.MIN_VALUE && b == -1 || b != 0 && r / b != a)) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    static long addExact(long a, long b) {
+        long r = a + b;
+        if (((a ^ r) & (b ^ r)) < 0) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    static long subtractExact(long a, long b) {
+        long r = a - b;
+        if (((a ^ b) & (a ^ r)) < 0) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    static int toIntExact(long value) {
+        if ((int) value != value) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return (int) value;
+    }
+
+    /// `unit` as a `ChronoUnit`, or the JDK's refusal of a unit it cannot add.
+    /// The length in nanoseconds of a unit to truncate a time to. Any unit
+    /// will do, a custom one included, as long as its duration divides a
+    /// standard day: that is the JDK's rule, and the reason it reads the
+    /// duration rather than requiring a [ChronoUnit].
+    static long truncationNanos(TemporalUnit unit) {
+        java.time.Duration length = unit.getDuration();
+        if (length.getSeconds() > SECONDS_PER_DAY) {
+            throw new UnsupportedTemporalTypeException("Unit is too large to be used for truncation");
+        }
+        long dur = length.toNanos();
+        if (dur <= 0 || NANOS_PER_DAY % dur != 0) {
+            throw new UnsupportedTemporalTypeException("Unit must divide into a standard day without remainder");
+        }
+        return dur;
+    }
+
+    static ChronoUnit chrono(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return (ChronoUnit) unit;
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        throw unsupported(unit);
+    }
+
+    static UnsupportedTemporalTypeException unsupported(Object unit) {
+        return new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+    }
+
+    /// The whole seconds in one `unit`, 0 for the units shorter than a second.
+    static long seconds(ChronoUnit unit) {
+        return UNIT_SECONDS[unit.ordinal()];
+    }
+
+    /// The nanoseconds in one `unit` shorter than a second, 0 for the others.
+    static long nanos(ChronoUnit unit) {
+        return UNIT_NANOS[unit.ordinal()];
+    }
+
+    /// The whole units between two moments given as seconds and nanoseconds,
+    /// the fraction dropped towards zero.
+    static long timeUntil(long s1, long n1, long s2, long n2, ChronoUnit unit) {
+        long seconds = s2 - s1;
+        long nanos = n2 - n1;
+        if (seconds > 0 && nanos < 0) {
+            seconds--;
+            nanos += NANOS_PER_SECOND;
+        } else if (seconds < 0 && nanos > 0) {
+            seconds++;
+            nanos -= NANOS_PER_SECOND;
+        }
+        long perNanos = nanos(unit);
+        if (perNanos != 0) {
+            return addExact(multiplyExact(seconds, NANOS_PER_SECOND / perNanos), nanos / perNanos);
+        }
+        return seconds / seconds(unit);
+    }
+
+    /// The nanosecond of the second of a value that has a time, 0 for one
+    /// that has none.
+    static int nanoOfSecond(Object value) {
+        if (value instanceof Instant) {
+            return ((Instant) value).getNano();
+        }
+        if (value instanceof LocalTime) {
+            return ((LocalTime) value).getNano();
+        }
+        if (value instanceof LocalDateTime) {
+            return ((LocalDateTime) value).getNano();
+        }
+        if (value instanceof ZonedDateTime) {
+            return ((ZonedDateTime) value).getNano();
+        }
+        if (value instanceof OffsetDateTime) {
+            return ((OffsetDateTime) value).toLocalDateTime().getNano();
+        }
+        return 0;
+    }
+
+    /// `value`, or the JDK's `DateTimeException` for a field outside
+    /// `min` to `max`.
+    static long check(String field, long min, long max, long value) {
+        if (value < min || value > max) {
+            throw new DateTimeException("Invalid value for " + field + " (valid values " + min + " - " + max
+                    + "): " + value);
+        }
+        return value;
+    }
+
+    static DateTimeException instantOutOfRange() {
+        return new DateTimeException("Instant exceeds minimum or maximum instant");
+    }
+
+    /// What `parse(text, formatter)` throws when the text was read but does
+    /// not make the value asked for.
+    static java.time.format.DateTimeParseException unparsable(CharSequence text, DateTimeException cause) {
+        return new java.time.format.DateTimeParseException("Text '" + text + "' could not be parsed: "
+                + cause.getMessage(), text, 0, cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/ZoneId.java b/Ports/CLDC11/src/java/time/ZoneId.java
index 31f638e1c78..958a9b6c2ea 100644
--- a/Ports/CLDC11/src/java/time/ZoneId.java
+++ b/Ports/CLDC11/src/java/time/ZoneId.java
@@ -1,51 +1,165 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.util.TimeZone;
 
+/// A time zone: either a fixed [ZoneOffset], or a region such as
+/// `Europe/Paris` whose offsets come from the platform's time zone rules.
+///
+/// As in the JDK, `ZoneId.of("UTC")` and `ZoneId.of("GMT")` are regions
+/// named that way, not [ZoneOffset#UTC] (whose id is `Z`), and
+/// `ZoneId.of("UTC+01:00")` keeps its prefix in its id.
 public class ZoneId {
     private final String id;
+    /// The offset of a region that never changes it (`UTC`, `GMT`, `UT`
+    /// and those followed by an offset), or null.
+    private final ZoneOffset fixed;
 
     ZoneId(String id) {
+        this(id, null);
+    }
+
+    private ZoneId(String id, ZoneOffset fixed) {
         this.id = id;
+        this.fixed = fixed;
     }
 
     public static ZoneId of(String zoneId) {
         if (zoneId == null) {
-            throw new NullPointerException();
-        }
-        if ("Z".equals(zoneId) || "UTC".equals(zoneId) || "GMT".equals(zoneId)) {
-            return ZoneOffset.UTC;
+            throw new NullPointerException("zoneId");
         }
-        if (zoneId.startsWith("+") || zoneId.startsWith("-")) {
+        if (zoneId.length() <= 1 || zoneId.startsWith("+") || zoneId.startsWith("-")) {
             return ZoneOffset.of(zoneId);
         }
-        if (zoneId.startsWith("UTC+") || zoneId.startsWith("UTC-")) {
-            return ZoneOffset.of(zoneId.substring(3));
+        if (zoneId.startsWith("UTC") || zoneId.startsWith("GMT")) {
+            return ofPrefixed(zoneId, 3);
         }
-        if (zoneId.startsWith("GMT+") || zoneId.startsWith("GMT-")) {
-            return ZoneOffset.of(zoneId.substring(3));
+        if (zoneId.startsWith("UT")) {
+            return ofPrefixed(zoneId, 2);
         }
-        return new ZoneId(zoneId);
+        for (int i = 0; i < zoneId.length(); i++) {
+            char c = zoneId.charAt(i);
+            boolean ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+                    || c == '~' || c == '/' || c == '.' || c == '_' || c == '+' || c == '-';
+            if (!ok) {
+                throw new DateTimeException("Invalid ID for region-based ZoneId, invalid format: " + zoneId);
+            }
+        }
+        // A well-formed region ID is accepted without checking it names a
+        // real region, where the JDK throws ZoneRulesException. That is
+        // deliberate: a device has no zone database to check against -- the
+        // rules come from the OS one lookup at a time, through TimeZone, and
+        // TimeZone.getAvailableIDs() answers only GMT and the default zone --
+        // so validating would mean a new native on every port for an error
+        // case. Its rules are whatever java.util.TimeZone.getTimeZone gives
+        // the same ID, which -- on the JDK as here -- does not throw for an
+        // unknown one either.
+        return new ZoneId(zoneId, null);
+    }
+
+    private static ZoneId ofPrefixed(String zoneId, int prefixLength) {
+        String prefix = zoneId.substring(0, prefixLength);
+        if (zoneId.length() == prefixLength) {
+            return new ZoneId(prefix, ZoneOffset.UTC);
+        }
+        char sign = zoneId.charAt(prefixLength);
+        if (sign != '+' && sign != '-') {
+            // GMT0 and the like: a region of its own.
+            return of0(zoneId);
+        }
+        ZoneOffset offset;
+        try {
+            offset = ZoneOffset.of(zoneId.substring(prefixLength));
+        } catch (DateTimeException ex) {
+            throw new DateTimeException("Invalid ID for offset-based ZoneId: " + zoneId);
+        }
+        if (offset.getTotalSeconds() == 0) {
+            return new ZoneId(prefix, ZoneOffset.UTC);
+        }
+        return new ZoneId(prefix + offset.getId(), offset);
+    }
+
+    private static ZoneId of0(String zoneId) {
+        return new ZoneId(zoneId, "GMT0".equals(zoneId) ? ZoneOffset.UTC : null);
     }
 
     public static ZoneId systemDefault() {
         return of(TimeZone.getDefault().getID());
     }
 
+    /// The zone `prefix` followed by `offset`: `UTC+01:00` for `UTC`,
+    /// just `UTC` for a zero offset.
+    public static ZoneId ofOffset(String prefix, ZoneOffset offset) {
+        if (prefix == null || offset == null) {
+            throw new NullPointerException();
+        }
+        if (prefix.length() == 0) {
+            return offset;
+        }
+        if (!prefix.equals("GMT") && !prefix.equals("UTC") && !prefix.equals("UT")) {
+            throw new IllegalArgumentException("prefix should be GMT, UTC or UT, is: " + prefix);
+        }
+        if (offset.getTotalSeconds() == 0) {
+            return new ZoneId(prefix, ZoneOffset.UTC);
+        }
+        return new ZoneId(prefix + offset.getId(), offset);
+    }
+
     public String getId() {
         return id;
     }
 
+    /// This zone as a [ZoneOffset] when its offset never changes, and
+    /// itself otherwise.
+    public ZoneId normalized() {
+        ZoneOffset f = fixedOffset();
+        return f != null ? f : this;
+    }
+
+    /// The offset this zone always has, or null for a region whose offset
+    /// changes.
+    ZoneOffset fixedOffset() {
+        return fixed;
+    }
+
+    /// The platform time zone with this zone's rules.
     TimeZone toTimeZone() {
-        if (this instanceof ZoneOffset) {
-            ZoneOffset offset = (ZoneOffset) this;
-            return TimeZone.getTimeZone(offset.getId().equals("Z") ? "GMT" : "GMT" + offset.getId());
+        ZoneOffset offset = fixedOffset();
+        if (offset != null) {
+            return TimeZone.getTimeZone(offset.getTotalSeconds() == 0 ? "GMT" : "GMT" + offset.getId());
         }
         return TimeZone.getTimeZone(id);
     }
 
     public boolean equals(Object obj) {
-        return obj instanceof ZoneId && id.equals(((ZoneId) obj).id);
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ZoneId) || obj instanceof ZoneOffset) {
+            return false;
+        }
+        return id.equals(((ZoneId) obj).id);
     }
 
     public int hashCode() {
diff --git a/Ports/CLDC11/src/java/time/ZoneOffset.java b/Ports/CLDC11/src/java/time/ZoneOffset.java
index c66eca48d06..4c10c59e4a5 100644
--- a/Ports/CLDC11/src/java/time/ZoneOffset.java
+++ b/Ports/CLDC11/src/java/time/ZoneOffset.java
@@ -1,7 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
-public final class ZoneOffset extends ZoneId {
+import java.time.temporal.TemporalAccessor;
+
+/// A fixed offset from UTC, between -18:00 and +18:00.
+public final class ZoneOffset extends ZoneId implements TemporalAccessor, Comparable<ZoneOffset> {
+    private static final int MAX_SECONDS = 18 * 3600;
+
     public static final ZoneOffset UTC = new ZoneOffset(0);
+    public static final ZoneOffset MIN = new ZoneOffset(-MAX_SECONDS);
+    public static final ZoneOffset MAX = new ZoneOffset(MAX_SECONDS);
 
     private final int totalSeconds;
 
@@ -10,83 +39,183 @@ private ZoneOffset(int totalSeconds) {
         this.totalSeconds = totalSeconds;
     }
 
+    /// Reads `Z`, `+h`, `+hh`, `+hh:mm`, `+hhmm`, `+hh:mm:ss` and
+    /// `+hhmmss`, with `-` in place of `+` for a negative offset.
     public static ZoneOffset of(String offsetId) {
         if (offsetId == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("offsetId");
         }
         if ("Z".equals(offsetId)) {
             return UTC;
         }
         String text = offsetId;
-        char sign = text.charAt(0);
-        if (sign != '+' && sign != '-') {
-            throw new IllegalArgumentException("Invalid offset: " + offsetId);
-        }
-        text = text.substring(1);
         int hours;
-        int minutes = 0;
-        if (text.indexOf(':') > 0) {
-            String[] parts = split(text, ':');
-            hours = Integer.parseInt(parts[0]);
-            minutes = Integer.parseInt(parts[1]);
-        } else if (text.length() == 2) {
-            hours = Integer.parseInt(text);
-        } else if (text.length() == 4) {
-            hours = Integer.parseInt(text.substring(0, 2));
-            minutes = Integer.parseInt(text.substring(2));
-        } else {
-            throw new IllegalArgumentException("Invalid offset: " + offsetId);
-        }
-        int total = hours * 3600 + minutes * 60;
-        if (sign == '-') {
-            total = -total;
-        }
-        return ofTotalSeconds(total);
+        int minutes;
+        int seconds;
+        switch (text.length()) {
+            case 2:
+                text = text.charAt(0) + "0" + text.charAt(1);
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = 0;
+                seconds = 0;
+                break;
+            case 3:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = 0;
+                seconds = 0;
+                break;
+            case 5:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 3, false);
+                seconds = 0;
+                break;
+            case 6:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 4, true);
+                seconds = 0;
+                break;
+            case 7:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 3, false);
+                seconds = parseNumber(offsetId, text, 5, false);
+                break;
+            case 9:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 4, true);
+                seconds = parseNumber(offsetId, text, 7, true);
+                break;
+            default:
+                throw new DateTimeException("Invalid ID for ZoneOffset, invalid format: " + offsetId);
+        }
+        char first = text.charAt(0);
+        if (first != '+' && first != '-') {
+            throw new DateTimeException("Invalid ID for ZoneOffset, plus/minus not found when expected: "
+                    + offsetId);
+        }
+        if (first == '-') {
+            return ofHoursMinutesSeconds(-hours, -minutes, -seconds);
+        }
+        return ofHoursMinutesSeconds(hours, minutes, seconds);
     }
 
-    private static String[] split(String value, char ch) {
-        int pos = value.indexOf(ch);
-        return new String[] { value.substring(0, pos), value.substring(pos + 1) };
+    private static int parseNumber(String offsetId, String text, int pos, boolean precededByColon) {
+        if (precededByColon && text.charAt(pos - 1) != ':') {
+            throw new DateTimeException("Invalid ID for ZoneOffset, colon not found when expected: " + offsetId);
+        }
+        char ch1 = text.charAt(pos);
+        char ch2 = text.charAt(pos + 1);
+        if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
+            throw new DateTimeException("Invalid ID for ZoneOffset, non numeric characters found: " + offsetId);
+        }
+        return (ch1 - 48) * 10 + (ch2 - 48);
     }
 
     public static ZoneOffset ofHours(int hours) {
-        return ofTotalSeconds(hours * 3600);
+        return ofHoursMinutesSeconds(hours, 0, 0);
     }
 
     public static ZoneOffset ofHoursMinutes(int hours, int minutes) {
-        int sign = hours < 0 || minutes < 0 ? -1 : 1;
-        return ofTotalSeconds(hours * 3600 + sign * Math.abs(minutes) * 60);
+        return ofHoursMinutesSeconds(hours, minutes, 0);
+    }
+
+    /// The offset of `hours`, `minutes` and `seconds`, which must all have
+    /// the same sign.
+    public static ZoneOffset ofHoursMinutesSeconds(int hours, int minutes, int seconds) {
+        if (hours < -18 || hours > 18) {
+            throw new DateTimeException("Zone offset hours not in valid range: value " + hours
+                    + " is not in the range -18 to 18");
+        }
+        if (hours > 0) {
+            if (minutes < 0 || seconds < 0) {
+                throw new DateTimeException("Zone offset minutes and seconds must be positive because hours is positive");
+            }
+        } else if (hours < 0) {
+            if (minutes > 0 || seconds > 0) {
+                throw new DateTimeException("Zone offset minutes and seconds must be negative because hours is negative");
+            }
+        } else if ((minutes > 0 && seconds < 0) || (minutes < 0 && seconds > 0)) {
+            throw new DateTimeException("Zone offset minutes and seconds must have the same sign");
+        }
+        if (minutes < -59 || minutes > 59) {
+            throw new DateTimeException("Zone offset minutes not in valid range: value " + minutes
+                    + " is not in the range -59 to 59");
+        }
+        if (seconds < -59 || seconds > 59) {
+            throw new DateTimeException("Zone offset seconds not in valid range: value " + seconds
+                    + " is not in the range -59 to 59");
+        }
+        if (Math.abs(hours) == 18 && (minutes | seconds) != 0) {
+            throw new DateTimeException("Zone offset not in valid range: -18:00 to +18:00");
+        }
+        return ofTotalSeconds(hours * 3600 + minutes * 60 + seconds);
     }
 
     public static ZoneOffset ofTotalSeconds(int totalSeconds) {
+        if (totalSeconds < -MAX_SECONDS || totalSeconds > MAX_SECONDS) {
+            throw new DateTimeException("Zone offset not in valid range: -18:00 to +18:00");
+        }
         if (totalSeconds == 0) {
             return UTC;
         }
         return new ZoneOffset(totalSeconds);
     }
 
+    /// The offset of `temporal`.
+    public static ZoneOffset from(TemporalAccessor temporal) {
+        if (temporal instanceof ZoneOffset) {
+            return (ZoneOffset) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).getOffset();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).getOffset();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain ZoneOffset from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
+    }
+
     public int getTotalSeconds() {
         return totalSeconds;
     }
 
+    @Override
+    ZoneOffset fixedOffset() {
+        return this;
+    }
+
+    /// Larger offsets sort first, as in the JDK: an offset further east is
+    /// an earlier moment for the same wall clock time.
+    public int compareTo(ZoneOffset other) {
+        return other.totalSeconds - totalSeconds;
+    }
+
+    public boolean equals(Object obj) {
+        return obj == this || (obj instanceof ZoneOffset && ((ZoneOffset) obj).totalSeconds == totalSeconds);
+    }
+
+    public int hashCode() {
+        return totalSeconds;
+    }
+
     private static String buildId(int totalSeconds) {
         if (totalSeconds == 0) {
             return "Z";
         }
         int abs = Math.abs(totalSeconds);
         int hours = abs / 3600;
-        int minutes = (abs % 3600) / 60;
-        StringBuffer sb = new StringBuffer();
+        int minutes = (abs / 60) % 60;
+        int seconds = abs % 60;
+        StringBuilder sb = new StringBuilder();
         sb.append(totalSeconds < 0 ? '-' : '+');
-        if (hours < 10) {
-            sb.append('0');
-        }
-        sb.append(hours);
-        sb.append(':');
-        if (minutes < 10) {
-            sb.append('0');
+        sb.append(hours < 10 ? "0" : "").append(hours);
+        sb.append(minutes < 10 ? ":0" : ":").append(minutes);
+        if (seconds != 0) {
+            sb.append(seconds < 10 ? ":0" : ":").append(seconds);
         }
-        sb.append(minutes);
         return sb.toString();
     }
 }
diff --git a/Ports/CLDC11/src/java/time/ZonedDateTime.java b/Ports/CLDC11/src/java/time/ZonedDateTime.java
index 7fe868a58bf..ec21defa796 100644
--- a/Ports/CLDC11/src/java/time/ZonedDateTime.java
+++ b/Ports/CLDC11/src/java/time/ZonedDateTime.java
@@ -1,94 +1,528 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
+import java.time.chrono.ChronoZonedDateTime;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
 
-public final class ZonedDateTime implements Comparable<ZonedDateTime>, TemporalAccessor {
+/// A date and a time of day in a time zone, such as
+/// `2007-12-03T10:15:30+01:00[Europe/Paris]`.
+///
+/// Adding a date-based amount moves the wall clock and keeps the offset where
+/// the zone allows it; adding a time-based amount moves the instant. Across a
+/// change of offset the two differ, as they do in the JDK.
+public final class ZonedDateTime implements ChronoZonedDateTime<LocalDate> {
     private final LocalDateTime dateTime;
     private final ZoneId zone;
     private final ZoneOffset offset;
 
-    private ZonedDateTime(LocalDateTime dateTime, ZoneId zone, ZoneOffset offset) {
+    private ZonedDateTime(LocalDateTime dateTime, ZoneOffset offset, ZoneId zone) {
         this.dateTime = dateTime;
-        this.zone = zone;
         this.offset = offset;
+        this.zone = zone;
     }
 
     public static ZonedDateTime now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The date and time now in `zone`.
+    public static ZonedDateTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static ZonedDateTime now(Clock clock) {
         return ofInstant(clock.instant(), clock.getZone());
     }
 
     public static ZonedDateTime of(LocalDate date, LocalTime time, ZoneId zone) {
-        LocalDateTime ldt = LocalDateTime.of(date, time);
-        Instant instant = ldt.toInstant(DateTimeSupport.offsetFromInstant(ldt.toInstant(ZoneOffset.UTC), zone));
-        return ofInstant(instant, zone);
+        return of(LocalDateTime.of(date, time), zone);
+    }
+
+    public static ZonedDateTime of(LocalDateTime localDateTime, ZoneId zone) {
+        return ofLocal(localDateTime, zone, null);
+    }
+
+    public static ZonedDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second,
+            int nanoOfSecond, ZoneId zone) {
+        return ofLocal(LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond), zone, null);
+    }
+
+    /// `localDateTime` in `zone`. A wall clock time the zone skips is moved
+    /// forward by the length of the gap; one it passes twice takes
+    /// `preferredOffset` when that is one of its two offsets, and the earlier
+    /// offset otherwise.
+    public static ZonedDateTime ofLocal(LocalDateTime localDateTime, ZoneId zone, ZoneOffset preferredOffset) {
+        if (localDateTime == null) {
+            throw new NullPointerException("localDateTime");
+        }
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        if (zone instanceof ZoneOffset) {
+            return new ZonedDateTime(localDateTime, (ZoneOffset) zone, zone);
+        }
+        long local = localDateTime.toEpochSecond(ZoneOffset.UTC);
+        // The offsets a day either side; a zone changes its offset far less
+        // often than that, so these are the offset before any transition
+        // touching this wall clock time and the offset after it.
+        ZoneOffset before = offsetAt(local - 86400L, zone);
+        ZoneOffset after = offsetAt(local + 86400L, zone);
+        boolean beforeValid = offsetAt(local - before.getTotalSeconds(), zone).equals(before);
+        boolean afterValid = offsetAt(local - after.getTotalSeconds(), zone).equals(after);
+        if (before.equals(after) || (beforeValid && !afterValid)) {
+            return new ZonedDateTime(localDateTime, before, zone);
+        }
+        if (afterValid && !beforeValid) {
+            return new ZonedDateTime(localDateTime, after, zone);
+        }
+        if (beforeValid) {
+            // An overlap: the wall clock time happens at both offsets.
+            ZoneOffset chosen = after.equals(preferredOffset) ? after : before;
+            return new ZonedDateTime(localDateTime, chosen, zone);
+        }
+        // A gap: the wall clock time never happens; move past it.
+        LocalDateTime shifted = localDateTime.plusSeconds(after.getTotalSeconds() - before.getTotalSeconds());
+        return new ZonedDateTime(shifted, after, zone);
+    }
+
+    /// The two offsets of the overlap this wall clock time falls in, earlier
+    /// first, or null when it falls in none.
+    private ZoneOffset[] overlap() {
+        if (zone instanceof ZoneOffset) {
+            return null;
+        }
+        long local = dateTime.toEpochSecond(ZoneOffset.UTC);
+        ZoneOffset before = offsetAt(local - 86400L, zone);
+        ZoneOffset after = offsetAt(local + 86400L, zone);
+        if (before.equals(after) || !offsetAt(local - before.getTotalSeconds(), zone).equals(before)
+                || !offsetAt(local - after.getTotalSeconds(), zone).equals(after)) {
+            return null;
+        }
+        return new ZoneOffset[] {before, after};
     }
 
-    public static ZonedDateTime of(LocalDateTime dateTime, ZoneId zone) {
-        Instant instant = dateTime.toInstant(DateTimeSupport.offsetFromInstant(dateTime.toInstant(ZoneOffset.UTC), zone));
-        return ofInstant(instant, zone);
+    /// At a wall clock time the zone passes twice, the first of the two
+    /// moments; otherwise this.
+    public ZonedDateTime withEarlierOffsetAtOverlap() {
+        ZoneOffset[] both = overlap();
+        return both == null || both[0].equals(offset) ? this : new ZonedDateTime(dateTime, both[0], zone);
+    }
+
+    /// At a wall clock time the zone passes twice, the second of the two
+    /// moments; otherwise this.
+    public ZonedDateTime withLaterOffsetAtOverlap() {
+        ZoneOffset[] both = overlap();
+        return both == null || both[1].equals(offset) ? this : new ZonedDateTime(dateTime, both[1], zone);
+    }
+
+    private static ZoneOffset offsetAt(long epochSecond, ZoneId zone) {
+        return DateTimeSupport.offsetFromInstant(Instant.ofEpochSecond(epochSecond), zone);
     }
 
     public static ZonedDateTime ofInstant(Instant instant, ZoneId zone) {
+        if (instant == null) {
+            throw new NullPointerException("instant");
+        }
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return create(instant.getEpochSecond(), instant.getNano(), zone);
+    }
+
+    /// The moment `localDateTime` is at `offset`, in `zone`.
+    public static ZonedDateTime ofInstant(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone) {
+        return create(localDateTime.toEpochSecond(offset), localDateTime.getNano(), zone);
+    }
+
+    private static ZonedDateTime create(long epochSecond, int nanoOfSecond, ZoneId zone) {
+        Instant instant = Instant.ofEpochSecond(epochSecond, nanoOfSecond);
         ZoneOffset offset = DateTimeSupport.offsetFromInstant(instant, zone);
-        LocalDateTime local = LocalDateTime.ofInstant(instant, zone);
-        return new ZonedDateTime(local, zone, offset);
+        LocalDateTime ldt = LocalDateTime.ofEpochSecond(epochSecond, nanoOfSecond, offset);
+        return new ZonedDateTime(ldt, offset, zone);
+    }
+
+    /// The date and time and zone of `temporal`.
+    public static ZonedDateTime from(TemporalAccessor temporal) {
+        if (temporal instanceof ZonedDateTime) {
+            return (ZonedDateTime) temporal;
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toZonedDateTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain ZonedDateTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static ZonedDateTime parse(CharSequence text) {
-        return (ZonedDateTime) DateTimeFormatter.ISO_ZONED_DATE_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_ZONED_DATE_TIME);
     }
 
     public static ZonedDateTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (ZonedDateTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
+    @Override
     public LocalDateTime toLocalDateTime() {
         return dateTime;
     }
 
+    @Override
+    public LocalDate toLocalDate() {
+        return dateTime.toLocalDate();
+    }
+
+    @Override
+    public LocalTime toLocalTime() {
+        return dateTime.toLocalTime();
+    }
+
+    @Override
     public ZoneId getZone() {
         return zone;
     }
 
+    @Override
     public ZoneOffset getOffset() {
         return offset;
     }
 
+    @Override
     public Instant toInstant() {
-        return dateTime.toInstant(offset);
+        return Instant.ofEpochSecond(toEpochSecond(), dateTime.getNano());
+    }
+
+    @Override
+    public long toEpochSecond() {
+        return dateTime.toEpochSecond(offset);
+    }
+
+    /// This date and time with its offset and no zone.
+    public OffsetDateTime toOffsetDateTime() {
+        return OffsetDateTime.of(dateTime, offset);
+    }
+
+    public int getYear() {
+        return dateTime.getYear();
+    }
+
+    public int getMonthValue() {
+        return dateTime.getMonthValue();
+    }
+
+    public Month getMonth() {
+        return dateTime.getMonth();
+    }
+
+    public int getDayOfMonth() {
+        return dateTime.getDayOfMonth();
+    }
+
+    public int getDayOfYear() {
+        return dateTime.getDayOfYear();
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return dateTime.getDayOfWeek();
+    }
+
+    public int getHour() {
+        return dateTime.getHour();
+    }
+
+    public int getMinute() {
+        return dateTime.getMinute();
+    }
+
+    public int getSecond() {
+        return dateTime.getSecond();
+    }
+
+    public int getNano() {
+        return dateTime.getNano();
+    }
+
+    /// The same moment in `zone`.
+    public ZonedDateTime withZoneSameInstant(ZoneId zone) {
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return this.zone.equals(zone) ? this : create(dateTime.toEpochSecond(offset), dateTime.getNano(), zone);
+    }
+
+    /// The same wall clock time in `zone`, keeping the offset if it can.
+    public ZonedDateTime withZoneSameLocal(ZoneId zone) {
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return this.zone.equals(zone) ? this : ofLocal(dateTime, zone, offset);
+    }
+
+    private ZonedDateTime resolveLocal(LocalDateTime newDateTime) {
+        return ofLocal(newDateTime, zone, offset);
+    }
+
+    private ZonedDateTime resolveInstant(LocalDateTime newDateTime) {
+        return ofInstant(newDateTime, offset, zone);
+    }
+
+    public ZonedDateTime withYear(int year) {
+        return resolveLocal(dateTime.withYear(year));
+    }
+
+    public ZonedDateTime withMonth(int month) {
+        return resolveLocal(dateTime.withMonth(month));
+    }
+
+    public ZonedDateTime withDayOfMonth(int dayOfMonth) {
+        return resolveLocal(dateTime.withDayOfMonth(dayOfMonth));
+    }
+
+    public ZonedDateTime withDayOfYear(int dayOfYear) {
+        return resolveLocal(dateTime.withDayOfYear(dayOfYear));
+    }
+
+    /// This date and time with its zone replaced by its current offset.
+    public ZonedDateTime withFixedOffsetZone() {
+        return zone.equals(offset) ? this : new ZonedDateTime(dateTime, offset, offset);
+    }
+
+    public ZonedDateTime withHour(int hour) {
+        return resolveLocal(dateTime.withHour(hour));
+    }
+
+    public ZonedDateTime withMinute(int minute) {
+        return resolveLocal(dateTime.withMinute(minute));
+    }
+
+    public ZonedDateTime withSecond(int second) {
+        return resolveLocal(dateTime.withSecond(second));
+    }
+
+    public ZonedDateTime withNano(int nanoOfSecond) {
+        return resolveLocal(dateTime.withNano(nanoOfSecond));
+    }
+
+    public ZonedDateTime truncatedTo(TemporalUnit unit) {
+        return resolveLocal(dateTime.truncatedTo(unit));
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit != ChronoUnit.FOREVER;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public ZonedDateTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            if (unit.isDateBased()) {
+                return resolveLocal(dateTime.plus(amountToAdd, unit));
+            }
+            return resolveInstant(dateTime.plus(amountToAdd, unit));
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public ZonedDateTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public ZonedDateTime plus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            return resolveLocal(dateTime.plus(amount));
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToAdd");
+        }
+        return (ZonedDateTime) amount.addTo(this);
+    }
+
+    @Override
+    public ZonedDateTime minus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            return resolveLocal(dateTime.minus(amount));
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToSubtract");
+        }
+        return (ZonedDateTime) amount.subtractFrom(this);
+    }
+
+    public ZonedDateTime plusYears(long years) {
+        return resolveLocal(dateTime.plusYears(years));
+    }
+
+    public ZonedDateTime plusMonths(long months) {
+        return resolveLocal(dateTime.plusMonths(months));
+    }
+
+    public ZonedDateTime plusWeeks(long weeks) {
+        return resolveLocal(dateTime.plusWeeks(weeks));
+    }
+
+    public ZonedDateTime plusDays(long days) {
+        return resolveLocal(dateTime.plusDays(days));
+    }
+
+    public ZonedDateTime plusHours(long hours) {
+        return resolveInstant(dateTime.plusHours(hours));
+    }
+
+    public ZonedDateTime plusMinutes(long minutes) {
+        return resolveInstant(dateTime.plusMinutes(minutes));
+    }
+
+    public ZonedDateTime plusSeconds(long seconds) {
+        return resolveInstant(dateTime.plusSeconds(seconds));
+    }
+
+    public ZonedDateTime plusNanos(long nanos) {
+        return resolveInstant(dateTime.plusNanos(nanos));
+    }
+
+    public ZonedDateTime minusYears(long years) {
+        return years == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-years);
+    }
+
+    public ZonedDateTime minusMonths(long months) {
+        return months == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-months);
+    }
+
+    public ZonedDateTime minusWeeks(long weeks) {
+        return weeks == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1) : plusWeeks(-weeks);
+    }
+
+    public ZonedDateTime minusDays(long days) {
+        return days == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-days);
+    }
+
+    public ZonedDateTime minusHours(long hours) {
+        return hours == Long.MIN_VALUE ? plusHours(Long.MAX_VALUE).plusHours(1) : plusHours(-hours);
+    }
+
+    public ZonedDateTime minusMinutes(long minutes) {
+        return minutes == Long.MIN_VALUE ? plusMinutes(Long.MAX_VALUE).plusMinutes(1) : plusMinutes(-minutes);
+    }
+
+    public ZonedDateTime minusSeconds(long seconds) {
+        return seconds == Long.MIN_VALUE ? plusSeconds(Long.MAX_VALUE).plusSeconds(1) : plusSeconds(-seconds);
+    }
+
+    public ZonedDateTime minusNanos(long nanos) {
+        return nanos == Long.MIN_VALUE ? plusNanos(Long.MAX_VALUE).plusNanos(1) : plusNanos(-nanos);
+    }
+
+    /// The whole units of `unit` from this value to `endExclusive`: date
+    /// units on the wall clock of this zone, time units on the time line.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        ZonedDateTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            if (unit.isDateBased()) {
+                end = end.withZoneSameInstant(zone);
+                return dateTime.until(end.dateTime, unit);
+            }
+            LocalDateTime endHere = LocalDateTime.ofEpochSecond(end.toEpochSecond(), end.getNano(), offset);
+            return dateTime.until(endHere, unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
     }
 
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
-    public int compareTo(ZonedDateTime other) {
-        int cmp = toInstant().compareTo(other.toInstant());
-        if (cmp != 0) {
-            return cmp;
+    @Override
+    public int compareTo(ChronoZonedDateTime<?> other) {
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        if (a != b) {
+            return a < b ? -1 : 1;
+        }
+        int cmp = toLocalTime().getNano() - other.toLocalTime().getNano();
+        if (cmp == 0) {
+            cmp = toLocalDateTime().compareTo(other.toLocalDateTime());
+            if (cmp == 0) {
+                cmp = getZone().getId().compareTo(other.getZone().getId());
+            }
         }
-        cmp = dateTime.compareTo(other.dateTime);
-        return cmp != 0 ? cmp : zone.getId().compareTo(other.zone.getId());
+        return cmp;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof ZonedDateTime && compareTo((ZonedDateTime) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ZonedDateTime)) {
+            return false;
+        }
+        ZonedDateTime other = (ZonedDateTime) obj;
+        return dateTime.equals(other.dateTime) && offset.equals(other.offset) && zone.equals(other.zone);
     }
 
+    @Override
     public int hashCode() {
-        return dateTime.hashCode() * 31 + zone.hashCode();
+        int z = zone.hashCode();
+        return dateTime.hashCode() ^ offset.hashCode() ^ ((z << 3) | (z >>> 29));
     }
 
+    /// The JDK's text: the date and time, the offset, and the zone in
+    /// brackets when it is a region rather than the offset itself.
+    @Override
     public String toString() {
-        return DateTimeFormatter.ISO_ZONED_DATE_TIME.format(this);
-    }
-
-    ZoneId getZoneForFormatting() {
-        return zone;
+        String str = dateTime.toString() + offset.toString();
+        if (!offset.equals(zone)) {
+            str += '[' + zone.toString() + ']';
+        }
+        return str;
     }
 }
diff --git a/Ports/CLDC11/src/java/time/chrono/ChronoLocalDate.java b/Ports/CLDC11/src/java/time/chrono/ChronoLocalDate.java
new file mode 100644
index 00000000000..1af4fd36deb
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/chrono/ChronoLocalDate.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.chrono;
+
+import java.time.temporal.Temporal;
+
+/// A date of a calendar. The ISO calendar's `LocalDate` is the one there is.
+public interface ChronoLocalDate extends Temporal, Comparable<ChronoLocalDate> {
+    /// The days since 1970-01-01.
+    long toEpochDay();
+
+    /// Whether the year of this date is a leap year.
+    boolean isLeapYear();
+
+    /// The days in the month of this date.
+    int lengthOfMonth();
+
+    /// The days in the year of this date.
+    default int lengthOfYear() {
+        return isLeapYear() ? 366 : 365;
+    }
+
+    /// Whether this date comes after `other`.
+    default boolean isAfter(ChronoLocalDate other) {
+        return toEpochDay() > other.toEpochDay();
+    }
+
+    /// Whether this date comes before `other`.
+    default boolean isBefore(ChronoLocalDate other) {
+        return toEpochDay() < other.toEpochDay();
+    }
+
+    /// Whether this date is the same day as `other`.
+    default boolean isEqual(ChronoLocalDate other) {
+        return toEpochDay() == other.toEpochDay();
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/chrono/ChronoLocalDateTime.java b/Ports/CLDC11/src/java/time/chrono/ChronoLocalDateTime.java
new file mode 100644
index 00000000000..0f6651198ac
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/chrono/ChronoLocalDateTime.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.chrono;
+
+import java.time.Instant;
+import java.time.LocalTime;
+import java.time.ZoneOffset;
+import java.time.temporal.Temporal;
+
+/// A date and a time of day of a calendar, with no zone.
+public interface ChronoLocalDateTime<D extends ChronoLocalDate>
+        extends Temporal, Comparable<ChronoLocalDateTime<?>> {
+    /// The date.
+    D toLocalDate();
+
+    /// The time of day.
+    LocalTime toLocalTime();
+
+    /// The seconds since 1970-01-01T00:00Z of this date and time at `offset`.
+    default long toEpochSecond(ZoneOffset offset) {
+        long epochDay = toLocalDate().toEpochDay();
+        long secs = epochDay * 86400L + toLocalTime().toSecondOfDay();
+        return secs - offset.getTotalSeconds();
+    }
+
+    /// The moment this date and time is at `offset`.
+    default Instant toInstant(ZoneOffset offset) {
+        return Instant.ofEpochSecond(toEpochSecond(offset), toLocalTime().getNano());
+    }
+
+    /// Whether this comes after `other` on the local time line.
+    default boolean isAfter(ChronoLocalDateTime<?> other) {
+        long thisDay = toLocalDate().toEpochDay();
+        long otherDay = other.toLocalDate().toEpochDay();
+        return thisDay > otherDay
+                || (thisDay == otherDay && toLocalTime().toNanoOfDay() > other.toLocalTime().toNanoOfDay());
+    }
+
+    /// Whether this comes before `other` on the local time line.
+    default boolean isBefore(ChronoLocalDateTime<?> other) {
+        long thisDay = toLocalDate().toEpochDay();
+        long otherDay = other.toLocalDate().toEpochDay();
+        return thisDay < otherDay
+                || (thisDay == otherDay && toLocalTime().toNanoOfDay() < other.toLocalTime().toNanoOfDay());
+    }
+
+    /// Whether this is the same date and time as `other`.
+    default boolean isEqual(ChronoLocalDateTime<?> other) {
+        return toLocalTime().toNanoOfDay() == other.toLocalTime().toNanoOfDay()
+                && toLocalDate().toEpochDay() == other.toLocalDate().toEpochDay();
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/chrono/ChronoZonedDateTime.java b/Ports/CLDC11/src/java/time/chrono/ChronoZonedDateTime.java
new file mode 100644
index 00000000000..3b875999605
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/chrono/ChronoZonedDateTime.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.chrono;
+
+import java.time.Instant;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.temporal.Temporal;
+
+/// A date and a time of day in a time zone.
+public interface ChronoZonedDateTime<D extends ChronoLocalDate>
+        extends Temporal, Comparable<ChronoZonedDateTime<?>> {
+    /// The date and time on the wall clock.
+    ChronoLocalDateTime<D> toLocalDateTime();
+
+    /// The offset from UTC.
+    ZoneOffset getOffset();
+
+    /// The zone.
+    ZoneId getZone();
+
+    /// The date.
+    default D toLocalDate() {
+        return toLocalDateTime().toLocalDate();
+    }
+
+    /// The time of day.
+    default LocalTime toLocalTime() {
+        return toLocalDateTime().toLocalTime();
+    }
+
+    /// The seconds since 1970-01-01T00:00Z.
+    default long toEpochSecond() {
+        return toLocalDateTime().toEpochSecond(getOffset());
+    }
+
+    /// The moment this is.
+    default Instant toInstant() {
+        return Instant.ofEpochSecond(toEpochSecond(), toLocalTime().getNano());
+    }
+
+    /// Whether this moment comes after `other`.
+    default boolean isAfter(ChronoZonedDateTime<?> other) {
+        long thisSecond = toEpochSecond();
+        long otherSecond = other.toEpochSecond();
+        return thisSecond > otherSecond
+                || (thisSecond == otherSecond && toLocalTime().getNano() > other.toLocalTime().getNano());
+    }
+
+    /// Whether this moment comes before `other`.
+    default boolean isBefore(ChronoZonedDateTime<?> other) {
+        long thisSecond = toEpochSecond();
+        long otherSecond = other.toEpochSecond();
+        return thisSecond < otherSecond
+                || (thisSecond == otherSecond && toLocalTime().getNano() < other.toLocalTime().getNano());
+    }
+
+    /// Whether this is the same moment as `other`.
+    default boolean isEqual(ChronoZonedDateTime<?> other) {
+        return toEpochSecond() == other.toEpochSecond()
+                && toLocalTime().getNano() == other.toLocalTime().getNano();
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/format/DateTimeFormatter.java b/Ports/CLDC11/src/java/time/format/DateTimeFormatter.java
index f7a25bd2d1c..fbf37066dab 100644
--- a/Ports/CLDC11/src/java/time/format/DateTimeFormatter.java
+++ b/Ports/CLDC11/src/java/time/format/DateTimeFormatter.java
@@ -22,8 +22,8 @@
  */
 package java.time.format;
 
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
+import java.time.DateTimeException;
+import java.time.DayOfWeek;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -33,305 +33,1599 @@
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.time.temporal.TemporalAccessor;
-import java.util.Date;
+import java.time.temporal.TemporalQuery;
+import java.time.temporal.UnsupportedTemporalTypeException;
+import java.util.ArrayList;
 import java.util.Locale;
-import java.util.TimeZone;
 
+/// Formats and parses dates and times: the ISO formats as constants, and
+/// any other through [#ofPattern(String)].
+///
+/// Patterns follow the JDK's letters and counts. Supported: `G` era, `u`
+/// year, `y` year of era, `M`/`L` month, `d` day of month, `D` day of
+/// year, `Q`/`q` quarter, `E` day of week, `a` AM/PM, `h`, `K`, `k`, `H`
+/// hours, `m` minutes, `s` seconds, `S` fraction of a second, `n` nano of
+/// second, `N` nano of day, `A` milli of day, `VV` zone id, `z` (the zone
+/// id), `O`, `X`, `x` and `Z` offsets, quoted text, and `[...]` optional
+/// sections. Text is English whatever the locale. The week-based letters
+/// (`Y`, `w`, `W`, `e`, `c`, `F`, `g`), `v`, `B` and `p` are refused.
+///
+/// A pattern parses as the JDK's smart resolver does: a day of month past
+/// the end of its month becomes the last day, an hour alone is that hour
+/// on the dot, and a two-digit year is one of 2000 to 2099. The ISO
+/// formats resolve strictly.
 public final class DateTimeFormatter {
-    private static final int TYPE_PATTERN = 0;
-    private static final int TYPE_ISO_LOCAL_DATE = 1;
-    private static final int TYPE_ISO_LOCAL_TIME = 2;
-    private static final int TYPE_ISO_LOCAL_DATE_TIME = 3;
-    private static final int TYPE_ISO_OFFSET_DATE_TIME = 4;
-    private static final int TYPE_ISO_ZONED_DATE_TIME = 5;
-    private static final int TYPE_ISO_INSTANT = 6;
-
-    public static final DateTimeFormatter ISO_LOCAL_DATE = new DateTimeFormatter(TYPE_ISO_LOCAL_DATE, null, null);
-    public static final DateTimeFormatter ISO_LOCAL_TIME = new DateTimeFormatter(TYPE_ISO_LOCAL_TIME, null, null);
-    public static final DateTimeFormatter ISO_LOCAL_DATE_TIME = new DateTimeFormatter(TYPE_ISO_LOCAL_DATE_TIME, null, null);
-    public static final DateTimeFormatter ISO_OFFSET_DATE_TIME = new DateTimeFormatter(TYPE_ISO_OFFSET_DATE_TIME, null, null);
-    public static final DateTimeFormatter ISO_ZONED_DATE_TIME = new DateTimeFormatter(TYPE_ISO_ZONED_DATE_TIME, null, null);
-    public static final DateTimeFormatter ISO_INSTANT = new DateTimeFormatter(TYPE_ISO_INSTANT, null, null);
-
-    private final int type;
+    private static final int KIND_PATTERN = 0;
+    private static final int KIND_LOCAL_DATE = 1;
+    private static final int KIND_LOCAL_TIME = 2;
+    private static final int KIND_LOCAL_DATE_TIME = 3;
+    private static final int KIND_OFFSET_DATE_TIME = 4;
+    private static final int KIND_ZONED_DATE_TIME = 5;
+    private static final int KIND_INSTANT = 6;
+
+    private static final long SECONDS_PER_10000_YEARS = 146097L * 25L * 86400L;
+    private static final long SECONDS_0000_TO_1970 = ((146097L * 5L) - (30L * 365L + 7L)) * 86400L;
+
+    public static final DateTimeFormatter ISO_LOCAL_DATE = new DateTimeFormatter(KIND_LOCAL_DATE, null, null,
+            null, null);
+    public static final DateTimeFormatter ISO_LOCAL_TIME = new DateTimeFormatter(KIND_LOCAL_TIME, null, null,
+            null, null);
+    public static final DateTimeFormatter ISO_LOCAL_DATE_TIME = new DateTimeFormatter(KIND_LOCAL_DATE_TIME, null,
+            null, null, null);
+    public static final DateTimeFormatter ISO_OFFSET_DATE_TIME = new DateTimeFormatter(KIND_OFFSET_DATE_TIME, null,
+            null, null, null);
+    public static final DateTimeFormatter ISO_ZONED_DATE_TIME = new DateTimeFormatter(KIND_ZONED_DATE_TIME, null,
+            null, null, null);
+    public static final DateTimeFormatter ISO_INSTANT = new DateTimeFormatter(KIND_INSTANT, null, null, null, null);
+
+    private final int kind;
     private final String pattern;
+    private final Token[] tokens;
     private final Locale locale;
+    private final ZoneId zone;
 
-    private DateTimeFormatter(int type, String pattern, Locale locale) {
-        this.type = type;
+    private DateTimeFormatter(int kind, String pattern, Token[] tokens, Locale locale, ZoneId zone) {
+        this.kind = kind;
         this.pattern = pattern;
+        this.tokens = tokens;
         this.locale = locale;
+        this.zone = zone;
     }
 
     public static DateTimeFormatter ofPattern(String pattern) {
-        return new DateTimeFormatter(TYPE_PATTERN, pattern, null);
+        return ofPattern(pattern, Locale.getDefault());
     }
 
     public static DateTimeFormatter ofPattern(String pattern, Locale locale) {
-        return new DateTimeFormatter(TYPE_PATTERN, pattern, locale);
+        if (pattern == null) {
+            throw new NullPointerException("pattern");
+        }
+        if (locale == null) {
+            throw new NullPointerException("locale");
+        }
+        return new DateTimeFormatter(KIND_PATTERN, pattern, compile(pattern), locale, null);
+    }
+
+    /// This formatter with `zone` overriding the zone of what it formats and
+    /// supplying one to what it parses; null removes the override.
+    public DateTimeFormatter withZone(ZoneId zone) {
+        if (zone == null ? this.zone == null : zone.equals(this.zone)) {
+            return this;
+        }
+        return new DateTimeFormatter(kind, pattern, tokens, locale, zone);
+    }
+
+    /// The zone given to [#withZone(ZoneId)], or null.
+    public ZoneId getZone() {
+        return zone;
+    }
+
+    public DateTimeFormatter withLocale(Locale locale) {
+        if (locale == null) {
+            throw new NullPointerException("locale");
+        }
+        if (locale.equals(this.locale)) {
+            return this;
+        }
+        return new DateTimeFormatter(kind, pattern, tokens, locale, zone);
+    }
+
+    public Locale getLocale() {
+        return locale == null ? Locale.getDefault() : locale;
     }
 
+    // ---- formatting ----
+
     public String format(TemporalAccessor temporal) {
         if (temporal == null) {
-            throw new NullPointerException();
-        }
-        switch (type) {
-            case TYPE_PATTERN:
-                return formatPattern(temporal);
-            case TYPE_ISO_LOCAL_DATE:
-                return formatLocalDate((LocalDate) temporal);
-            case TYPE_ISO_LOCAL_TIME:
-                return formatLocalTime((LocalTime) temporal);
-            case TYPE_ISO_LOCAL_DATE_TIME:
-                return formatLocalDate((LocalDateTime) temporal) + "T" + formatLocalTime(((LocalDateTime) temporal).toLocalTime());
-            case TYPE_ISO_OFFSET_DATE_TIME:
-                return formatLocalDateTime(((OffsetDateTime) temporal).toLocalDateTime()) + formatOffset(((OffsetDateTime) temporal).getOffset());
-            case TYPE_ISO_ZONED_DATE_TIME:
-                ZonedDateTime zdt = (ZonedDateTime) temporal;
-                return formatLocalDateTime(zdt.toLocalDateTime()) + formatOffset(zdt.getOffset()) + "[" + zdt.getZone().getId() + "]";
-            case TYPE_ISO_INSTANT:
-                return formatInstant((Instant) temporal);
+            throw new NullPointerException("temporal");
+        }
+        Fields f = Fields.of(temporal, zone);
+        StringBuilder out = new StringBuilder(32);
+        switch (kind) {
+            case KIND_PATTERN:
+                formatPattern(f, out);
+                break;
+            case KIND_LOCAL_DATE:
+                isoDate(f, out);
+                break;
+            case KIND_LOCAL_TIME:
+                isoTime(f, out);
+                break;
+            case KIND_LOCAL_DATE_TIME:
+                isoDate(f, out);
+                out.append('T');
+                isoTime(f, out);
+                break;
+            case KIND_OFFSET_DATE_TIME:
+                isoDate(f, out);
+                out.append('T');
+                isoTime(f, out);
+                out.append(f.offset("OffsetSeconds").getId());
+                break;
+            case KIND_ZONED_DATE_TIME:
+                isoDate(f, out);
+                out.append('T');
+                isoTime(f, out);
+                out.append(f.offset("OffsetSeconds").getId());
+                if (f.zone != null && !(f.zone instanceof ZoneOffset)) {
+                    out.append('[').append(f.zone.getId()).append(']');
+                }
+                break;
             default:
-                throw new IllegalStateException();
+                isoInstant(f, out);
+                break;
         }
+        return out.toString();
     }
 
-    public TemporalAccessor parse(CharSequence text) {
-        switch (type) {
-            case TYPE_ISO_LOCAL_DATE:
-                return parseLocalDate(text.toString());
-            case TYPE_ISO_LOCAL_TIME:
-                return parseLocalTime(text.toString());
-            case TYPE_ISO_LOCAL_DATE_TIME:
-                return parseLocalDateTime(text.toString());
-            case TYPE_ISO_OFFSET_DATE_TIME:
-                return parseOffsetDateTime(text.toString());
-            case TYPE_ISO_ZONED_DATE_TIME:
-                return parseZonedDateTime(text.toString());
-            case TYPE_ISO_INSTANT:
-                return parseInstant(text.toString());
-            case TYPE_PATTERN:
-                return parseLocalDateTime(text.toString());
-            default:
-                throw new IllegalStateException();
+    private static void isoDate(Fields f, StringBuilder out) {
+        LocalDate date = f.date("Year");
+        appendYear(date.getYear(), out);
+        out.append('-');
+        pad(out, date.getMonthValue(), 2);
+        out.append('-');
+        pad(out, date.getDayOfMonth(), 2);
+    }
+
+    /// A year as the ISO formats print it: at least four digits, a sign
+    /// when negative, and a `+` when more than four digits.
+    private static void appendYear(int year, StringBuilder out) {
+        if (year < 0) {
+            out.append('-');
+            pad(out, -(long) year, 4);
+        } else {
+            if (year > 9999) {
+                out.append('+');
+            }
+            pad(out, year, 4);
+        }
+    }
+
+    private static void isoTime(Fields f, StringBuilder out) {
+        LocalTime time = f.time("HourOfDay");
+        pad(out, time.getHour(), 2);
+        out.append(':');
+        pad(out, time.getMinute(), 2);
+        out.append(':');
+        pad(out, time.getSecond(), 2);
+        int nano = time.getNano();
+        if (nano != 0) {
+            String digits = String.valueOf(1000000000 + nano).substring(1);
+            int end = 9;
+            while (digits.charAt(end - 1) == '0') {
+                end--;
+            }
+            out.append('.').append(digits.substring(0, end));
         }
     }
 
-    LocalDate parseLocalDate(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return LocalDateTime.ofInstant(parsed.instant, ZoneOffset.UTC).toLocalDate();
+    private static void isoInstant(Fields f, StringBuilder out) {
+        if (f.epochSecond == null) {
+            throw new UnsupportedTemporalTypeException("Unsupported field: InstantSeconds");
         }
-        if (type != TYPE_ISO_LOCAL_DATE) {
-            throw new DateTimeParseException("Formatter does not produce LocalDate", text, 0);
+        // An instant reaches a year past what LocalDate holds, so the year
+        // is split off in whole 10000 year cycles first, as the JDK does.
+        long seconds = f.epochSecond.longValue();
+        long shifted = seconds + SECONDS_0000_TO_1970;
+        long cycles = shifted / SECONDS_PER_10000_YEARS;
+        if (shifted < 0 && cycles * SECONDS_PER_10000_YEARS != shifted) {
+            cycles--;
         }
-        return LocalDate.of(parseInt(text, 0, 4), parseInt(text, 5, 7), parseInt(text, 8, 10));
+        long within = seconds - cycles * SECONDS_PER_10000_YEARS;
+        LocalDateTime utc = LocalDateTime.ofEpochSecond(within, f.nano, ZoneOffset.UTC);
+        appendYear((int) (cycles * 10000 + utc.getYear()), out);
+        out.append('-');
+        pad(out, utc.getMonthValue(), 2);
+        out.append('-');
+        pad(out, utc.getDayOfMonth(), 2);
+        out.append('T');
+        pad(out, utc.getHour(), 2);
+        out.append(':');
+        pad(out, utc.getMinute(), 2);
+        out.append(':');
+        pad(out, utc.getSecond(), 2);
+        int nano = utc.getNano();
+        if (nano != 0) {
+            // Whole groups of three digits: millis, micros or nanos.
+            String digits = String.valueOf(1000000000 + nano).substring(1);
+            if (nano % 1000000 == 0) {
+                digits = digits.substring(0, 3);
+            } else if (nano % 1000 == 0) {
+                digits = digits.substring(0, 6);
+            }
+            out.append('.').append(digits);
+        }
+        out.append('Z');
     }
 
-    LocalTime parseLocalTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return LocalDateTime.ofInstant(parsed.instant, ZoneOffset.UTC).toLocalTime();
+    private void formatPattern(Fields f, StringBuilder out) {
+        ArrayList<Integer> starts = new ArrayList<Integer>();
+        int i = 0;
+        while (i < tokens.length) {
+            Token t = tokens[i];
+            if (t.kind == Token.OPTIONAL_START) {
+                starts.add(Integer.valueOf(out.length()));
+                i++;
+                continue;
+            }
+            if (t.kind == Token.OPTIONAL_END) {
+                starts.remove(starts.size() - 1);
+                i++;
+                continue;
+            }
+            if (t.kind == Token.LITERAL) {
+                out.append(t.text);
+                i++;
+                continue;
+            }
+            try {
+                formatField(t, f, out);
+                i++;
+            } catch (UnsupportedTemporalTypeException missing) {
+                if (starts.isEmpty()) {
+                    throw missing;
+                }
+                // A field an optional section needs is missing: drop the
+                // section, whatever of it was printed already included.
+                out.setLength(starts.remove(starts.size() - 1).intValue());
+                i = skipSection(i);
+            }
         }
-        if (type != TYPE_ISO_LOCAL_TIME) {
-            throw new DateTimeParseException("Formatter does not produce LocalTime", text, 0);
+    }
+
+    /// The index after the end of the optional section `i` is inside.
+    private int skipSection(int i) {
+        int depth = 1;
+        i++;
+        while (i < tokens.length && depth > 0) {
+            if (tokens[i].kind == Token.OPTIONAL_START) {
+                depth++;
+            } else if (tokens[i].kind == Token.OPTIONAL_END) {
+                depth--;
+            }
+            i++;
         }
-        int hour = parseInt(text, 0, 2);
-        int minute = parseInt(text, 3, 5);
-        int second = text.length() >= 8 ? parseInt(text, 6, 8) : 0;
-        int nano = 0;
-        int dot = text.indexOf('.');
-        if (dot > 0) {
-            String frac = text.substring(dot + 1);
-            while (frac.length() < 9) {
-                frac += "0";
+        return i;
+    }
+
+    private static void formatField(Token t, Fields f, StringBuilder out) {
+        int count = t.count;
+        switch (t.letter) {
+            case 'G': {
+                int year = f.date("Era").getYear();
+                text(out, count, year >= 1 ? ERA_FULL[1] : ERA_FULL[0], year >= 1 ? "AD" : "BC");
+                return;
+            }
+            case 'u':
+            case 'y': {
+                int year = f.date(t.letter == 'u' ? "Year" : "YearOfEra").getYear();
+                long value = t.letter == 'y' && year < 1 ? 1L - year : year;
+                if (count == 2) {
+                    pad(out, Math.abs(value) % 100, 2);
+                } else if (count < 4) {
+                    number(out, value, count, 19, SIGN_NORMAL, "Year");
+                } else {
+                    number(out, value, count, 19, SIGN_EXCEEDS_PAD, "Year");
+                }
+                return;
+            }
+            case 'M':
+            case 'L': {
+                int month = f.date("MonthOfYear").getMonthValue();
+                if (count >= 3) {
+                    text(out, count, MONTHS[month - 1], null);
+                } else {
+                    small(out, month, count);
+                }
+                return;
+            }
+            case 'Q':
+            case 'q': {
+                int quarter = (f.date("QuarterOfYear").getMonthValue() - 1) / 3 + 1;
+                if (count == 3) {
+                    out.append('Q').append(quarter);
+                } else if (count == 4) {
+                    out.append(QUARTERS[quarter - 1]).append(" quarter");
+                } else if (count == 5) {
+                    out.append(quarter);
+                } else {
+                    small(out, quarter, count);
+                }
+                return;
+            }
+            case 'd':
+                small(out, f.date("DayOfMonth").getDayOfMonth(), count);
+                return;
+            case 'D': {
+                int doy = f.date("DayOfYear").getDayOfYear();
+                if (count == 2) {
+                    number(out, doy, 2, 3, SIGN_NOT_NEGATIVE, "DayOfYear");
+                } else {
+                    small(out, doy, count);
+                }
+                return;
             }
-            if (frac.length() > 9) {
-                frac = frac.substring(0, 9);
+            case 'E': {
+                DayOfWeek dow = f.dayOfWeek();
+                text(out, count, DAYS[dow.getValue() - 1], null);
+                return;
             }
-            nano = Integer.parseInt(frac);
+            case 'a':
+                out.append(f.time("AmPmOfDay").getHour() < 12 ? "AM" : "PM");
+                return;
+            case 'h': {
+                int h = f.time("ClockHourOfAmPm").getHour() % 12;
+                small(out, h == 0 ? 12 : h, count);
+                return;
+            }
+            case 'K':
+                small(out, f.time("HourOfAmPm").getHour() % 12, count);
+                return;
+            case 'k': {
+                int h = f.time("ClockHourOfDay").getHour();
+                small(out, h == 0 ? 24 : h, count);
+                return;
+            }
+            case 'H':
+                small(out, f.time("HourOfDay").getHour(), count);
+                return;
+            case 'm':
+                small(out, f.time("MinuteOfHour").getMinute(), count);
+                return;
+            case 's':
+                small(out, f.time("SecondOfMinute").getSecond(), count);
+                return;
+            case 'S':
+                out.append(String.valueOf(1000000000 + f.nanoOfSecond()).substring(1, 1 + count));
+                return;
+            case 'n':
+                small(out, f.nanoOfSecond(), count);
+                return;
+            case 'N':
+                small(out, f.time("NanoOfDay").toNanoOfDay(), count);
+                return;
+            case 'A':
+                small(out, f.time("MilliOfDay").toNanoOfDay() / 1000000L, count);
+                return;
+            case 'V':
+            case 'z':
+                if (f.zone == null) {
+                    throw new UnsupportedTemporalTypeException("Unable to extract ZoneId from temporal");
+                }
+                out.append(f.zone.getId());
+                return;
+            case 'O':
+                localizedOffset(out, f.offset("OffsetSeconds").getTotalSeconds(), count == 4);
+                return;
+            case 'X':
+                offset(out, f.offset("OffsetSeconds").getTotalSeconds(), count == 1 ? 1 : count, "Z");
+                return;
+            case 'x':
+                offset(out, f.offset("OffsetSeconds").getTotalSeconds(), count, OFFSET_ZERO[count - 1]);
+                return;
+            case 'Z':
+                if (count == 4) {
+                    localizedOffset(out, f.offset("OffsetSeconds").getTotalSeconds(), true);
+                } else if (count == 5) {
+                    offset(out, f.offset("OffsetSeconds").getTotalSeconds(), 5, "Z");
+                } else {
+                    offset(out, f.offset("OffsetSeconds").getTotalSeconds(), 2, "+0000");
+                }
+                return;
+            default:
+                throw new IllegalStateException(String.valueOf(t.letter));
         }
-        return LocalTime.of(hour, minute, second, nano);
     }
 
-    LocalDateTime parseLocalDateTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return LocalDateTime.ofInstant(parsed.instant, ZoneOffset.UTC);
+    private static final String[] MONTHS = {"January", "February", "March", "April", "May", "June", "July",
+        "August", "September", "October", "November", "December"};
+    private static final String[] DAYS = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
+        "Sunday"};
+    private static final String[] ERA_FULL = {"Before Christ", "Anno Domini"};
+    private static final String[] QUARTERS = {"1st", "2nd", "3rd", "4th"};
+    private static final String[] OFFSET_ZERO = {"+00", "+0000", "+00:00", "+0000", "+00:00"};
+
+    private static final int SIGN_NORMAL = 0;
+    private static final int SIGN_NOT_NEGATIVE = 1;
+    private static final int SIGN_EXCEEDS_PAD = 2;
+
+    /// Text in the style the count asks for: short (1 to 3), full (4) or
+    /// narrow (5). `shortForm` stands in when the short form is not the
+    /// first three letters.
+    private static void text(StringBuilder out, int count, String full, String shortForm) {
+        if (count == 4) {
+            out.append(full);
+        } else if (count == 5) {
+            out.append(full.charAt(0));
+        } else {
+            out.append(shortForm != null ? shortForm : full.substring(0, 3));
         }
-        if (type != TYPE_ISO_LOCAL_DATE_TIME) {
-            throw new DateTimeParseException("Formatter does not produce LocalDateTime", text, 0);
+    }
+
+    /// A field of one letter (any width) or two (exactly two digits).
+    private static void small(StringBuilder out, long value, int count) {
+        if (count == 1) {
+            out.append(value);
+        } else {
+            pad(out, value, count);
         }
-        int t = text.indexOf('T');
-        return LocalDateTime.of((LocalDate) ISO_LOCAL_DATE.parse(text.substring(0, t)),
-                (LocalTime) ISO_LOCAL_TIME.parse(text.substring(t + 1)));
     }
 
-    OffsetDateTime parseOffsetDateTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return OffsetDateTime.ofInstant(parsed.instant, parsed.zone);
+    private static void number(StringBuilder out, long value, int minWidth, int maxWidth, int sign, String field) {
+        String digits = String.valueOf(Math.abs(value));
+        if (value == Long.MIN_VALUE || digits.length() > maxWidth) {
+            throw new DateTimeException("Field " + field + " cannot be printed as the value " + value
+                    + " exceeds the maximum print width of " + maxWidth);
         }
-        if (type != TYPE_ISO_OFFSET_DATE_TIME) {
-            throw new DateTimeParseException("Formatter does not produce OffsetDateTime", text, 0);
+        if (value < 0) {
+            if (sign == SIGN_NOT_NEGATIVE) {
+                throw new DateTimeException("Field " + field + " cannot be printed as the value " + value
+                        + " cannot be negative according to the SignStyle");
+            }
+            out.append('-');
+        } else if (sign == SIGN_EXCEEDS_PAD && minWidth < 19 && digits.length() > minWidth) {
+            out.append('+');
         }
-        int idx = Math.max(text.lastIndexOf('+'), text.lastIndexOf('-'));
-        if (text.endsWith("Z")) {
-            idx = text.length() - 1;
+        for (int i = digits.length(); i < minWidth; i++) {
+            out.append('0');
         }
-        LocalDateTime ldt = (LocalDateTime) ISO_LOCAL_DATE_TIME.parse(text.substring(0, idx));
-        ZoneOffset offset = text.endsWith("Z") ? ZoneOffset.UTC : ZoneOffset.of(text.substring(idx));
-        return OffsetDateTime.of(ldt, offset);
+        out.append(digits);
     }
 
-    ZonedDateTime parseZonedDateTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneId.systemDefault(), locale);
-            return ZonedDateTime.ofInstant(parsed.instant, parsed.zone);
+    private static void pad(StringBuilder out, long value, int width) {
+        String digits = String.valueOf(value);
+        for (int i = digits.length(); i < width; i++) {
+            out.append('0');
         }
-        if (type != TYPE_ISO_ZONED_DATE_TIME) {
-            throw new DateTimeParseException("Formatter does not produce ZonedDateTime", text, 0);
+        out.append(digits);
+    }
+
+    /// An offset as the `X`, `x` and `Z` letters print it. `style` is the
+    /// count of `X`: 1 `+HHmm`, 2 `+HHMM`, 3 `+HH:MM`, 4 `+HHMMss`, 5
+    /// `+HH:MM:ss`.
+    private static void offset(StringBuilder out, int total, int style, String zeroText) {
+        if (total == 0) {
+            out.append(zeroText);
+            return;
+        }
+        int abs = Math.abs(total);
+        int hours = abs / 3600;
+        int minutes = (abs / 60) % 60;
+        int seconds = abs % 60;
+        boolean colon = style == 3 || style == 5;
+        out.append(total < 0 ? '-' : '+');
+        pad(out, hours, 2);
+        if (style == 1 && minutes == 0) {
+            return;
+        }
+        if (colon) {
+            out.append(':');
         }
-        int zoneStart = text.indexOf('[');
-        int offsetIdx = Math.max(text.lastIndexOf('+'), text.lastIndexOf('-'));
-        if (text.indexOf('Z') > 0 && (offsetIdx < 0 || text.indexOf('Z') < zoneStart)) {
-            offsetIdx = text.indexOf('Z');
+        pad(out, minutes, 2);
+        if (style >= 4 && seconds != 0) {
+            if (colon) {
+                out.append(':');
+            }
+            pad(out, seconds, 2);
         }
-        LocalDateTime ldt = (LocalDateTime) ISO_LOCAL_DATE_TIME.parse(text.substring(0, offsetIdx));
-        ZoneOffset offset = text.charAt(offsetIdx) == 'Z' ? ZoneOffset.UTC : ZoneOffset.of(text.substring(offsetIdx, zoneStart));
-        ZoneId zone = ZoneId.of(text.substring(zoneStart + 1, text.length() - 1));
-        return ZonedDateTime.ofInstant(ldt.toInstant(offset), zone);
     }
 
-    Instant parseInstant(String text) {
-        if (type != TYPE_ISO_INSTANT) {
-            throw new DateTimeParseException("Formatter does not produce Instant", text, 0);
+    /// `GMT+8` (short) or `GMT+08:00` (full); `GMT` alone for zero.
+    private static void localizedOffset(StringBuilder out, int total, boolean full) {
+        out.append("GMT");
+        if (total == 0) {
+            return;
+        }
+        int abs = Math.abs(total);
+        int hours = abs / 3600;
+        int minutes = (abs / 60) % 60;
+        int seconds = abs % 60;
+        out.append(total < 0 ? '-' : '+');
+        if (full) {
+            pad(out, hours, 2);
+            out.append(':');
+            pad(out, minutes, 2);
+            if (seconds != 0) {
+                out.append(':');
+                pad(out, seconds, 2);
+            }
+        } else {
+            out.append(hours);
+            if (minutes != 0 || seconds != 0) {
+                out.append(':');
+                pad(out, minutes, 2);
+                if (seconds != 0) {
+                    out.append(':');
+                    pad(out, seconds, 2);
+                }
+            }
         }
-        OffsetDateTime odt = ISO_OFFSET_DATE_TIME.parseOffsetDateTime(text.endsWith("Z")
-                ? text.substring(0, text.length() - 1) + "+00:00"
-                : text);
-        return odt.toInstant();
     }
 
-    private String formatPattern(TemporalAccessor temporal) {
-        ZoneId zone;
-        Instant instant;
-        if (temporal instanceof Instant) {
-            instant = (Instant) temporal;
-            zone = ZoneOffset.UTC;
-        } else if (temporal instanceof LocalDateTime) {
-            instant = ((LocalDateTime) temporal).toInstant(ZoneOffset.UTC);
-            zone = ZoneOffset.UTC;
-        } else if (temporal instanceof OffsetDateTime) {
-            OffsetDateTime offsetDateTime = (OffsetDateTime) temporal;
-            instant = offsetDateTime.toInstant();
-            zone = offsetDateTime.getOffset();
-        } else if (temporal instanceof ZonedDateTime) {
-            ZonedDateTime zonedDateTime = (ZonedDateTime) temporal;
-            instant = zonedDateTime.toInstant();
-            zone = zonedDateTime.getZone();
-        } else {
-            throw new IllegalArgumentException("Unsupported temporal type");
+    // ---- parsing ----
+
+    public TemporalAccessor parse(CharSequence text) {
+        if (text == null) {
+            throw new NullPointerException("text");
+        }
+        String s = text.toString();
+        Parsed p = new Parsed(s);
+        switch (kind) {
+            case KIND_PATTERN:
+                parsePattern(p);
+                break;
+            case KIND_LOCAL_DATE:
+                parseIsoDate(p);
+                break;
+            case KIND_LOCAL_TIME:
+                parseIsoTime(p);
+                break;
+            case KIND_LOCAL_DATE_TIME:
+                parseIsoDateTime(p);
+                break;
+            case KIND_OFFSET_DATE_TIME:
+                parseIsoDateTime(p);
+                parseOffsetId(p);
+                break;
+            case KIND_ZONED_DATE_TIME:
+                parseIsoDateTime(p);
+                parseOffsetId(p);
+                if (p.pos < s.length() && s.charAt(p.pos) == '[') {
+                    p.pos++;
+                    parseZoneId(p);
+                    p.literal(']');
+                }
+                break;
+            default:
+                Instant instant = parseIsoInstant(p);
+                // With a zone of its own the formatter places the moment
+                // in it, so the result is a zoned date and time as well.
+                return zone == null ? instant : ZonedDateTime.ofInstant(instant, zone);
+        }
+        if (p.pos < s.length()) {
+            throw new DateTimeParseException("Text '" + s + "' could not be parsed, unparsed text found at index "
+                    + p.pos, s, p.pos);
         }
-        SimpleDateFormat sdf = newFormat(pattern, zone, locale);
-        TimeZone original = TimeZone.getDefault();
         try {
-            if (zone != null) {
-                TimeZone.setDefault(toTimeZone(zone));
+            return p.resolve(zone, kind != KIND_PATTERN);
+        } catch (DateTimeParseException ex) {
+            throw ex;
+        } catch (DateTimeException ex) {
+            throw new DateTimeParseException("Text '" + s + "' could not be parsed: " + ex.getMessage(), s, 0, ex);
+        }
+    }
+
+    /// Parses `text` and hands the result to `query`, as in
+    /// `formatter.parse(text, LocalDate::from)`.
+    public <T> T parse(CharSequence text, TemporalQuery<T> query) {
+        if (query == null) {
+            throw new NullPointerException("query");
+        }
+        TemporalAccessor parsed = parse(text);
+        try {
+            return query.queryFrom(parsed);
+        } catch (DateTimeParseException ex) {
+            throw ex;
+        } catch (RuntimeException ex) {
+            String s = text.toString();
+            throw new DateTimeParseException("Text '" + s + "' could not be parsed: " + ex.getMessage(), s, 0, ex);
+        }
+    }
+
+    private static void parseIsoDate(Parsed p) {
+        int start = p.pos;
+        boolean negative = false;
+        boolean signed = false;
+        if (p.pos < p.text.length() && (p.text.charAt(p.pos) == '+' || p.text.charAt(p.pos) == '-')) {
+            negative = p.text.charAt(p.pos) == '-';
+            signed = true;
+            p.pos++;
+        }
+        int digitsStart = p.pos;
+        long year = p.digits(4, 10);
+        if (p.pos - digitsStart > 4 && !signed) {
+            p.fail(start);
+        }
+        if (signed && !negative && p.pos - digitsStart <= 4) {
+            p.fail(start);
+        }
+        p.set(F_YEAR, negative ? -year : year);
+        p.literal('-');
+        p.set(F_MONTH, p.digits(2, 2));
+        p.literal('-');
+        p.set(F_DAY, p.digits(2, 2));
+    }
+
+    private static void parseIsoTime(Parsed p) {
+        p.set(F_HOUR, p.digits(2, 2));
+        p.literal(':');
+        p.set(F_MINUTE, p.digits(2, 2));
+        if (p.pos < p.text.length() && p.text.charAt(p.pos) == ':') {
+            p.pos++;
+            p.set(F_SECOND, p.digits(2, 2));
+            if (p.pos < p.text.length() && p.text.charAt(p.pos) == '.') {
+                p.pos++;
+                int from = p.pos;
+                long fraction = p.digits(0, 9);
+                int width = p.pos - from;
+                for (int i = width; i < 9; i++) {
+                    fraction *= 10;
+                }
+                p.set(F_NANO, fraction);
             }
-            return sdf.format(new Date(instant.toEpochMilli()));
-        } finally {
-            TimeZone.setDefault(original);
         }
     }
 
-    private static SimpleDateFormat newFormat(String pattern, ZoneId zone, Locale locale) {
-        return new SimpleDateFormat(pattern);
+    private static void parseIsoDateTime(Parsed p) {
+        parseIsoDate(p);
+        if (p.pos >= p.text.length() || (p.text.charAt(p.pos) != 'T' && p.text.charAt(p.pos) != 't')) {
+            p.fail(p.pos);
+        }
+        p.pos++;
+        parseIsoTime(p);
+    }
+
+    /// `Z`, or an offset of hours with optional minutes and seconds, with
+    /// or without colons.
+    private static void parseOffsetId(Parsed p) {
+        if (p.pos < p.text.length() && (p.text.charAt(p.pos) == 'Z' || p.text.charAt(p.pos) == 'z')) {
+            p.pos++;
+            p.offset = ZoneOffset.UTC;
+            return;
+        }
+        p.offset = ZoneOffset.ofTotalSeconds(p.offsetSeconds());
     }
 
-    private static ParsedPatternResult parsePattern(String text, String pattern, ZoneId defaultZone, Locale locale) {
-        TimeZone original = TimeZone.getDefault();
+    private static void parseZoneId(Parsed p) {
+        int start = p.pos;
+        while (p.pos < p.text.length()) {
+            char c = p.text.charAt(p.pos);
+            if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '~' || c == '/'
+                    || c == '.' || c == '_' || c == '+' || c == '-' || c == ':') {
+                p.pos++;
+            } else {
+                break;
+            }
+        }
+        if (p.pos == start) {
+            p.fail(start);
+        }
         try {
-            if (defaultZone != null) {
-                TimeZone.setDefault(toTimeZone(defaultZone));
+            p.zone = ZoneId.of(p.text.substring(start, p.pos));
+        } catch (DateTimeException ex) {
+            p.fail(start);
+        }
+    }
+
+    private Instant parseIsoInstant(Parsed p) {
+        parseIsoDate(p);
+        if (p.pos >= p.text.length() || (p.text.charAt(p.pos) != 'T' && p.text.charAt(p.pos) != 't')) {
+            p.fail(p.pos);
+        }
+        p.pos++;
+        p.set(F_HOUR, p.digits(2, 2));
+        p.literal(':');
+        p.set(F_MINUTE, p.digits(2, 2));
+        p.literal(':');
+        p.set(F_SECOND, p.digits(2, 2));
+        long nano = 0;
+        if (p.pos < p.text.length() && p.text.charAt(p.pos) == '.') {
+            p.pos++;
+            int from = p.pos;
+            nano = p.digits(0, 9);
+            for (int i = p.pos - from; i < 9; i++) {
+                nano *= 10;
             }
-            SimpleDateFormat sdf = newFormat(pattern, defaultZone, locale);
-            Date date = sdf.parse(text);
-            Instant instant = Instant.ofEpochMilli(date.getTime());
-            ZoneId zone = defaultZone == null ? ZoneOffset.UTC : defaultZone;
-            return new ParsedPatternResult(instant, zone);
-        } catch (ParseException err) {
-            throw new DateTimeParseException(err.getMessage(), text, 0);
-        } finally {
-            TimeZone.setDefault(original);
+        }
+        parseOffsetId(p);
+        if (p.pos < p.text.length()) {
+            throw new DateTimeParseException("Text '" + p.text + "' could not be parsed, unparsed text found at index "
+                    + p.pos, p.text, p.pos);
+        }
+        try {
+            int hour = (int) p.values[F_HOUR];
+            int second = (int) p.values[F_SECOND];
+            long dayAdjust = 0;
+            if (hour == 24 && p.values[F_MINUTE] == 0 && second == 0 && nano == 0) {
+                hour = 0;
+                dayAdjust = 1;
+            }
+            if (second == 60) {
+                // A leap second reads as the last second of its minute.
+                second = 59;
+            }
+            LocalDate date = LocalDate.of((int) p.values[F_YEAR], (int) p.values[F_MONTH], (int) p.values[F_DAY])
+                    .plusDays(dayAdjust);
+            LocalTime time = LocalTime.of(hour, (int) p.values[F_MINUTE], second, (int) nano);
+            return LocalDateTime.of(date, time).toInstant(p.offset);
+        } catch (DateTimeException ex) {
+            throw new DateTimeParseException("Text '" + p.text + "' could not be parsed: " + ex.getMessage(), p.text,
+                    0, ex);
         }
     }
 
-    private static final class ParsedPatternResult {
-        final Instant instant;
-        final ZoneId zone;
+    private void parsePattern(Parsed p) {
+        parseTokens(p, 0, tokens.length);
+    }
 
-        ParsedPatternResult(Instant instant, ZoneId zone) {
-            this.instant = instant;
-            this.zone = zone;
+    /// Parses tokens `from` to `to`; an optional section that fails is
+    /// undone and skipped.
+    private void parseTokens(Parsed p, int from, int to) {
+        int i = from;
+        while (i < to) {
+            Token t = tokens[i];
+            if (t.kind == Token.OPTIONAL_START) {
+                int end = skipSection(i) - 1;
+                Parsed saved = p.copy();
+                try {
+                    parseTokens(p, i + 1, end);
+                } catch (DateTimeParseException ex) {
+                    p.restore(saved);
+                }
+                i = end + 1;
+                continue;
+            }
+            if (t.kind == Token.OPTIONAL_END) {
+                i++;
+                continue;
+            }
+            if (t.kind == Token.LITERAL) {
+                for (int c = 0; c < t.text.length(); c++) {
+                    p.literal(t.text.charAt(c));
+                }
+                i++;
+                continue;
+            }
+            parseField(p, t, reserved(i + 1, to));
+            i++;
         }
     }
 
-    private static int parseInt(String text, int start, int end) {
-        return Integer.parseInt(text.substring(start, end));
+    /// The digits the fixed-width numbers directly after token `i` need,
+    /// which a variable-width number before them leaves for them.
+    private int reserved(int i, int to) {
+        int total = 0;
+        while (i < to && tokens[i].kind == Token.FIELD) {
+            int width = fixedWidth(tokens[i]);
+            if (width <= 0) {
+                break;
+            }
+            total += width;
+            i++;
+        }
+        return total;
     }
 
-    private static TimeZone toTimeZone(ZoneId zone) {
-        if (zone instanceof ZoneOffset) {
-            ZoneOffset offset = (ZoneOffset) zone;
-            return TimeZone.getTimeZone(offset.getId().equals("Z") ? "GMT" : "GMT" + offset.getId());
+    /// The width of a number that is always printed with exactly that many
+    /// digits, or 0.
+    private static int fixedWidth(Token t) {
+        switch (t.letter) {
+            case 'y':
+            case 'u':
+                return t.count == 2 ? 2 : 0;
+            case 'M':
+            case 'L':
+            case 'Q':
+            case 'q':
+                return t.count == 2 ? 2 : 0;
+            case 'd':
+            case 'H':
+            case 'h':
+            case 'K':
+            case 'k':
+            case 'm':
+            case 's':
+                return t.count == 2 ? 2 : 0;
+            case 'D':
+                return t.count == 3 ? 3 : 0;
+            case 'S':
+                return t.count;
+            default:
+                return 0;
         }
-        return TimeZone.getTimeZone(zone.getId());
     }
 
-    private static String pad(int value, int length) {
-        String s = String.valueOf(Math.abs(value));
-        StringBuffer out = new StringBuffer();
-        if (value < 0) {
-            out.append('-');
+    private static void parseField(Parsed p, Token t, int reserve) {
+        int count = t.count;
+        switch (t.letter) {
+            case 'G':
+                p.set(F_ERA, p.oneOf(count == 4 ? ERA_FULL : (count == 5 ? new String[] {"B", "A"}
+                        : new String[] {"BC", "AD"})));
+                return;
+            case 'u':
+            case 'y': {
+                int field = t.letter == 'u' ? F_YEAR : F_YEAR_OF_ERA;
+                if (count == 2) {
+                    p.set(field, 2000 + p.digits(2, 2));
+                } else {
+                    boolean negative = false;
+                    int start = p.pos;
+                    if (p.pos < p.text.length() && (p.text.charAt(p.pos) == '-'
+                            || (count >= 4 && p.text.charAt(p.pos) == '+'))) {
+                        negative = p.text.charAt(p.pos) == '-';
+                        p.pos++;
+                    }
+                    int digitsStart = p.pos;
+                    long value = p.digits(count, Math.max(count, 19 - reserve), reserve);
+                    if (count >= 4 && !negative && (p.pos - digitsStart > count) != (start != digitsStart)) {
+                        p.fail(start);
+                    }
+                    if (negative && t.letter == 'y') {
+                        p.fail(start);
+                    }
+                    p.set(field, negative ? -value : value);
+                }
+                return;
+            }
+            case 'M':
+            case 'L':
+                if (count >= 3) {
+                    p.set(F_MONTH, 1 + p.oneOf(styled(MONTHS, count)));
+                } else {
+                    p.set(F_MONTH, p.number(count, reserve));
+                }
+                return;
+            case 'Q':
+            case 'q':
+                if (count == 3) {
+                    p.literal('Q');
+                    p.set(F_QUARTER, p.digits(1, 1));
+                } else if (count == 4) {
+                    p.set(F_QUARTER, 1 + p.oneOf(new String[] {"1st quarter", "2nd quarter", "3rd quarter",
+                        "4th quarter"}));
+                } else if (count == 5) {
+                    p.set(F_QUARTER, p.digits(1, 1));
+                } else {
+                    p.set(F_QUARTER, p.number(count, reserve));
+                }
+                return;
+            case 'd':
+                p.set(F_DAY, p.number(count, reserve));
+                return;
+            case 'D':
+                p.set(F_DAY_OF_YEAR, count == 2 ? p.digits(2, 3, reserve) : p.number(count, reserve));
+                return;
+            case 'E':
+                p.set(F_DAY_OF_WEEK, 1 + p.oneOf(styled(DAYS, count)));
+                return;
+            case 'a':
+                p.set(F_AMPM, p.oneOf(new String[] {"AM", "PM"}));
+                return;
+            case 'h':
+                p.set(F_CLOCK_HOUR_AMPM, p.number(count, reserve));
+                return;
+            case 'K':
+                p.set(F_HOUR_AMPM, p.number(count, reserve));
+                return;
+            case 'k':
+                p.set(F_CLOCK_HOUR, p.number(count, reserve));
+                return;
+            case 'H':
+                p.set(F_HOUR, p.number(count, reserve));
+                return;
+            case 'm':
+                p.set(F_MINUTE, p.number(count, reserve));
+                return;
+            case 's':
+                p.set(F_SECOND, p.number(count, reserve));
+                return;
+            case 'S': {
+                long fraction = p.digits(count, count);
+                for (int i = count; i < 9; i++) {
+                    fraction *= 10;
+                }
+                p.set(F_NANO, fraction);
+                return;
+            }
+            case 'n':
+                p.set(F_NANO, p.number(count, reserve));
+                return;
+            case 'N':
+                p.set(F_NANO_OF_DAY, p.number(count, reserve));
+                return;
+            case 'A':
+                p.set(F_MILLI_OF_DAY, p.number(count, reserve));
+                return;
+            case 'V':
+            case 'z':
+                parseZoneId(p);
+                return;
+            case 'O': {
+                int start = p.pos;
+                p.literal('G');
+                p.literal('M');
+                p.literal('T');
+                if (p.pos < p.text.length() && (p.text.charAt(p.pos) == '+' || p.text.charAt(p.pos) == '-')) {
+                    boolean negative = p.text.charAt(p.pos) == '-';
+                    p.pos++;
+                    int hours = (int) p.digits(1, 2);
+                    int minutes = 0;
+                    int seconds = 0;
+                    if (p.pos < p.text.length() && p.text.charAt(p.pos) == ':') {
+                        p.pos++;
+                        minutes = (int) p.digits(2, 2);
+                        if (p.pos < p.text.length() && p.text.charAt(p.pos) == ':') {
+                            p.pos++;
+                            seconds = (int) p.digits(2, 2);
+                        }
+                    }
+                    int total = hours * 3600 + minutes * 60 + seconds;
+                    p.setOffset(negative ? -total : total, start);
+                } else {
+                    p.setOffset(0, start);
+                }
+                return;
+            }
+            case 'X':
+            case 'Z':
+                if ((t.letter == 'X' || count == 5) && p.pos < p.text.length() && p.text.charAt(p.pos) == 'Z') {
+                    p.pos++;
+                    p.offset = ZoneOffset.UTC;
+                    return;
+                }
+                p.setOffset(p.offsetSeconds(), p.pos);
+                return;
+            case 'x':
+                p.setOffset(p.offsetSeconds(), p.pos);
+                return;
+            default:
+                throw new IllegalStateException(String.valueOf(t.letter));
         }
-        for (int i = s.length(); i < length; i++) {
-            out.append('0');
+    }
+
+    /// The names of `full` in the style `count` asks for.
+    private static String[] styled(String[] full, int count) {
+        String[] out = new String[full.length];
+        for (int i = 0; i < full.length; i++) {
+            out[i] = count == 4 ? full[i] : (count == 5 ? full[i].substring(0, 1) : full[i].substring(0, 3));
         }
-        out.append(s);
-        return out.toString();
+        return out;
     }
 
-    private static String formatLocalDate(LocalDate date) {
-        return pad(date.getYear(), 4) + "-" + pad(date.getMonthValue(), 2) + "-" + pad(date.getDayOfMonth(), 2);
+    // ---- what was read, and what it makes ----
+
+    private static final int F_ERA = 0;
+    private static final int F_YEAR = 1;
+    private static final int F_YEAR_OF_ERA = 2;
+    private static final int F_MONTH = 3;
+    private static final int F_DAY = 4;
+    private static final int F_DAY_OF_YEAR = 5;
+    private static final int F_DAY_OF_WEEK = 6;
+    private static final int F_QUARTER = 7;
+    private static final int F_AMPM = 8;
+    private static final int F_HOUR = 9;
+    private static final int F_CLOCK_HOUR = 10;
+    private static final int F_HOUR_AMPM = 11;
+    private static final int F_CLOCK_HOUR_AMPM = 12;
+    private static final int F_MINUTE = 13;
+    private static final int F_SECOND = 14;
+    private static final int F_NANO = 15;
+    private static final int F_NANO_OF_DAY = 16;
+    private static final int F_MILLI_OF_DAY = 17;
+    private static final int FIELD_COUNT = 18;
+
+    private static final String[] FIELD_NAMES = {"Era", "Year", "YearOfEra", "MonthOfYear", "DayOfMonth",
+        "DayOfYear", "DayOfWeek", "QuarterOfYear", "AmPmOfDay", "HourOfDay", "ClockHourOfDay", "HourOfAmPm",
+        "ClockHourOfAmPm", "MinuteOfHour", "SecondOfMinute", "NanoOfSecond", "NanoOfDay", "MilliOfDay"};
+    private static final long[] FIELD_MIN = {0, -999999999L, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0};
+    private static final long[] FIELD_MAX = {1, 999999999L, 1000000000L, 12, 31, 366, 7, 4, 1, 23, 24, 11, 12, 59,
+        59, 999999999L, 86399999999999L, 86399999L};
+
+    /// The state of one parse: where it is in the text and every field and
+    /// offset read so far.
+    private static final class Parsed implements TemporalAccessor {
+        final String text;
+        int pos;
+        final long[] values = new long[FIELD_COUNT];
+        final boolean[] present = new boolean[FIELD_COUNT];
+        /// Whether the time read was 24:00, which ends the day it was read
+        /// with and so moves a date read beside it on by one.
+        private boolean endOfDay;
+        ZoneOffset offset;
+        ZoneId zone;
+
+        Parsed(String text) {
+            this.text = text;
+        }
+
+        Parsed copy() {
+            Parsed c = new Parsed(text);
+            c.pos = pos;
+            System.arraycopy(values, 0, c.values, 0, FIELD_COUNT);
+            System.arraycopy(present, 0, c.present, 0, FIELD_COUNT);
+            c.offset = offset;
+            c.zone = zone;
+            return c;
+        }
+
+        void restore(Parsed saved) {
+            pos = saved.pos;
+            System.arraycopy(saved.values, 0, values, 0, FIELD_COUNT);
+            System.arraycopy(saved.present, 0, present, 0, FIELD_COUNT);
+            offset = saved.offset;
+            zone = saved.zone;
+        }
+
+        void fail(int index) {
+            throw new DateTimeParseException("Text '" + text + "' could not be parsed at index " + index, text, index);
+        }
+
+        void set(int field, long value) {
+            if (present[field] && values[field] != value) {
+                throw new DateTimeParseException("Text '" + text + "' could not be parsed: Conflict found: "
+                        + FIELD_NAMES[field] + " " + values[field] + " differs from " + FIELD_NAMES[field] + " "
+                        + value, text, 0);
+            }
+            values[field] = value;
+            present[field] = true;
+        }
+
+        void setOffset(int seconds, int start) {
+            try {
+                offset = ZoneOffset.ofTotalSeconds(seconds);
+            } catch (DateTimeException ex) {
+                fail(start);
+            }
+        }
+
+        void literal(char c) {
+            if (pos >= text.length() || text.charAt(pos) != c) {
+                fail(pos);
+            }
+            pos++;
+        }
+
+        long digits(int min, int max) {
+            return digits(min, max, 0);
+        }
+
+        /// Between `min` and `max` digits, leaving `reserve` of them for
+        /// the fixed-width numbers that follow when there are more.
+        long digits(int min, int max, int reserve) {
+            int start = pos;
+            int end = start;
+            while (end < text.length() && end - start < max && text.charAt(end) >= '0' && text.charAt(end) <= '9') {
+                end++;
+            }
+            if (reserve > 0 && end - start - reserve >= min) {
+                end -= reserve;
+            }
+            if (end - start < min) {
+                fail(start);
+            }
+            long value = 0;
+            for (int i = start; i < end; i++) {
+                value = value * 10 + (text.charAt(i) - '0');
+                if (value < 0) {
+                    fail(start);
+                }
+            }
+            pos = end;
+            return value;
+        }
+
+        /// A number of one letter (one or more digits) or two (exactly two).
+        long number(int count, int reserve) {
+            return count == 1 ? digits(1, 19, reserve) : digits(count, count);
+        }
+
+        int oneOf(String[] names) {
+            int best = -1;
+            int bestLength = 0;
+            for (int i = 0; i < names.length; i++) {
+                String n = names[i];
+                if (n.length() > bestLength && text.regionMatches(pos, n, 0, n.length())) {
+                    best = i;
+                    bestLength = n.length();
+                }
+            }
+            if (best < 0) {
+                fail(pos);
+            }
+            pos += bestLength;
+            return best;
+        }
+
+        /// `+HH`, `+HHMM`, `+HH:MM`, `+HHMMss` or `+HH:MM:ss`.
+        int offsetSeconds() {
+            int start = pos;
+            if (pos >= text.length() || (text.charAt(pos) != '+' && text.charAt(pos) != '-')) {
+                fail(start);
+            }
+            boolean negative = text.charAt(pos) == '-';
+            pos++;
+            int hours = (int) digits(2, 2);
+            int minutes = 0;
+            int seconds = 0;
+            boolean colon = pos < text.length() && text.charAt(pos) == ':';
+            if (colon) {
+                pos++;
+            }
+            if (pos + 1 < text.length() && isDigit(pos) && isDigit(pos + 1)) {
+                minutes = (int) digits(2, 2);
+                if (colon ? pos < text.length() && text.charAt(pos) == ':' : true) {
+                    int mark = pos;
+                    if (colon) {
+                        pos++;
+                    }
+                    if (pos + 1 < text.length() && isDigit(pos) && isDigit(pos + 1)) {
+                        seconds = (int) digits(2, 2);
+                    } else {
+                        pos = mark;
+                    }
+                }
+            } else if (colon) {
+                fail(pos);
+            }
+            if (minutes > 59 || seconds > 59) {
+                fail(start);
+            }
+            int total = hours * 3600 + minutes * 60 + seconds;
+            if (total > 18 * 3600) {
+                fail(start);
+            }
+            return negative ? -total : total;
+        }
+
+        private boolean isDigit(int i) {
+            char c = text.charAt(i);
+            return c >= '0' && c <= '9';
+        }
+
+        private void check(int field, boolean strict) {
+            long v = values[field];
+            if (!strict) {
+                // The smart resolver takes 24:00 as the end of the day and
+                // a clock hour of 0 as midnight, as the JDK's does.
+                if (field == F_HOUR && v == 24) {
+                    return;
+                }
+                if ((field == F_CLOCK_HOUR || field == F_CLOCK_HOUR_AMPM) && v == 0) {
+                    return;
+                }
+            }
+            if (present[field] && (v < FIELD_MIN[field] || v > FIELD_MAX[field])) {
+                throw new DateTimeException("Invalid value for " + FIELD_NAMES[field] + " (valid values "
+                        + FIELD_MIN[field] + " - " + FIELD_MAX[field] + "): " + v);
+            }
+        }
+
+        /// The date, time, offset and zone that were read, as the class
+        /// they make: a zoned or offset date and time, a date and time, a
+        /// date, a time, or this when they make none of those.
+        TemporalAccessor resolve(ZoneId overrideZone, boolean strict) {
+            for (int f = 0; f < FIELD_COUNT; f++) {
+                check(f, strict);
+            }
+            LocalDate date = resolveDate(strict);
+            LocalTime time = resolveTime();
+            ZoneId z = zone != null ? zone : overrideZone;
+            if (date != null && time != null) {
+                LocalDateTime ldt = LocalDateTime.of(date, time);
+                if (endOfDay) {
+                    ldt = ldt.plusDays(1);
+                }
+                if (offset != null) {
+                    if (z == null) {
+                        return OffsetDateTime.of(ldt, offset);
+                    }
+                    return ZonedDateTime.ofInstant(ldt.toInstant(offset), z);
+                }
+                if (z != null) {
+                    return ZonedDateTime.of(ldt, z);
+                }
+                return ldt;
+            }
+            if (date != null) {
+                return date;
+            }
+            if (time != null) {
+                return time;
+            }
+            return this;
+        }
+
+        private LocalDate resolveDate(boolean strict) {
+            Long year = null;
+            if (present[F_YEAR]) {
+                year = Long.valueOf(values[F_YEAR]);
+            }
+            if (present[F_YEAR_OF_ERA]) {
+                long yoe = values[F_YEAR_OF_ERA];
+                long fromEra = !present[F_ERA] || values[F_ERA] == 1 ? yoe : 1 - yoe;
+                if (year != null && year.longValue() != fromEra) {
+                    throw new DateTimeException("Conflict found: Year " + year + " differs from Year " + fromEra);
+                }
+                year = Long.valueOf(fromEra);
+            } else if (present[F_ERA] && year != null && (year.longValue() >= 1 ? 1 : 0) != values[F_ERA]) {
+                throw new DateTimeException("Conflict found: Era " + values[F_ERA] + " differs from year " + year);
+            }
+            LocalDate date = null;
+            if (year != null && present[F_MONTH] && present[F_DAY]) {
+                int y = (int) year.longValue();
+                int m = (int) values[F_MONTH];
+                int d = (int) values[F_DAY];
+                if (!strict) {
+                    int length = LocalDate.of(y, m, 1).lengthOfMonth();
+                    if (d > length) {
+                        d = length;
+                    }
+                }
+                date = LocalDate.of(y, m, d);
+            } else if (year != null && present[F_DAY_OF_YEAR]) {
+                date = LocalDate.ofYearDay((int) year.longValue(), (int) values[F_DAY_OF_YEAR]);
+            }
+            if (date != null) {
+                if (present[F_DAY_OF_WEEK] && date.getDayOfWeek().getValue() != values[F_DAY_OF_WEEK]) {
+                    throw new DateTimeException("Conflict found: Field DayOfWeek " + date.getDayOfWeek().getValue()
+                            + " differs from DayOfWeek " + values[F_DAY_OF_WEEK] + " derived from " + date);
+                }
+                if (present[F_QUARTER] && (date.getMonthValue() - 1) / 3 + 1 != values[F_QUARTER]) {
+                    throw new DateTimeException("Conflict found: Field QuarterOfYear differs from " + date);
+                }
+            }
+            return date;
+        }
+
+        private LocalTime resolveTime() {
+            Long hour = null;
+            if (present[F_HOUR]) {
+                hour = Long.valueOf(values[F_HOUR]);
+            }
+            if (present[F_CLOCK_HOUR]) {
+                long h = values[F_CLOCK_HOUR] == 24 ? 0 : values[F_CLOCK_HOUR];
+                hour = conflict(hour, h);
+            }
+            if (present[F_AMPM]) {
+                if (present[F_CLOCK_HOUR_AMPM]) {
+                    long h = values[F_CLOCK_HOUR_AMPM] == 12 ? 0 : values[F_CLOCK_HOUR_AMPM];
+                    hour = conflict(hour, values[F_AMPM] * 12 + h);
+                }
+                if (present[F_HOUR_AMPM]) {
+                    hour = conflict(hour, values[F_AMPM] * 12 + values[F_HOUR_AMPM]);
+                }
+            }
+            if (hour == null) {
+                if (present[F_NANO_OF_DAY]) {
+                    return LocalTime.ofNanoOfDay(values[F_NANO_OF_DAY]);
+                }
+                if (present[F_MILLI_OF_DAY]) {
+                    return LocalTime.ofNanoOfDay(values[F_MILLI_OF_DAY] * 1000000L);
+                }
+                return null;
+            }
+            if (present[F_AMPM] && hour.longValue() / 12 != values[F_AMPM]) {
+                throw new DateTimeException("Conflict found: AmPmOfDay " + values[F_AMPM] + " differs from hour "
+                        + hour);
+            }
+            boolean minute = present[F_MINUTE];
+            boolean second = present[F_SECOND];
+            boolean nano = present[F_NANO];
+            if ((!minute && (second || nano)) || (minute && !second && nano)) {
+                return null;
+            }
+            if (hour.longValue() == 24) {
+                if ((minute && values[F_MINUTE] != 0) || (second && values[F_SECOND] != 0)
+                        || (nano && values[F_NANO] != 0)) {
+                    throw new DateTimeException("Invalid value for HourOfDay (valid values 0 - 23): 24");
+                }
+                endOfDay = true;
+                return LocalTime.MIDNIGHT;
+            }
+            return LocalTime.of((int) hour.longValue(), minute ? (int) values[F_MINUTE] : 0,
+                    second ? (int) values[F_SECOND] : 0, nano ? (int) values[F_NANO] : 0);
+        }
+
+        private static Long conflict(Long hour, long value) {
+            if (hour != null && hour.longValue() != value) {
+                throw new DateTimeException("Conflict found: HourOfDay " + hour + " differs from HourOfDay " + value);
+            }
+            return Long.valueOf(value);
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder("{");
+            boolean first = true;
+            for (int f = 0; f < FIELD_COUNT; f++) {
+                if (present[f]) {
+                    if (!first) {
+                        sb.append(", ");
+                    }
+                    sb.append(FIELD_NAMES[f]).append('=').append(values[f]);
+                    first = false;
+                }
+            }
+            sb.append("},ISO");
+            if (zone != null) {
+                sb.append(',').append(zone);
+            } else if (offset != null) {
+                sb.append(',').append(offset);
+            }
+            return sb.toString();
+        }
     }
 
-    private static String formatLocalTime(LocalTime time) {
-        String base = pad(time.getHour(), 2) + ":" + pad(time.getMinute(), 2) + ":" + pad(time.getSecond(), 2);
-        if (time.getNano() == 0) {
-            return base;
+    // ---- what a value to format has ----
+
+    /// The date, time, offset and zone a value carries, after the
+    /// formatter's override zone is applied.
+    private static final class Fields {
+        LocalDate date;
+        LocalTime time;
+        ZoneOffset offsetValue;
+        ZoneId zone;
+        Long epochSecond;
+        int nano;
+        DayOfWeek dayOfWeek;
+
+        static Fields of(TemporalAccessor temporal, ZoneId override) {
+            Fields f = new Fields();
+            if (override != null) {
+                Instant instant = null;
+                if (temporal instanceof Instant) {
+                    instant = (Instant) temporal;
+                } else if (temporal instanceof OffsetDateTime) {
+                    instant = ((OffsetDateTime) temporal).toInstant();
+                } else if (temporal instanceof ZonedDateTime && !((ZonedDateTime) temporal).getZone().equals(override)) {
+                    instant = ((ZonedDateTime) temporal).toInstant();
+                }
+                if (instant != null) {
+                    temporal = ZonedDateTime.ofInstant(instant, override);
+                }
+            }
+            if (temporal instanceof ZonedDateTime) {
+                ZonedDateTime z = (ZonedDateTime) temporal;
+                f.date = z.toLocalDate();
+                f.time = z.toLocalTime();
+                f.offsetValue = z.getOffset();
+                f.zone = z.getZone();
+                f.epochSecond = Long.valueOf(z.toEpochSecond());
+                f.nano = z.getNano();
+            } else if (temporal instanceof OffsetDateTime) {
+                OffsetDateTime o = (OffsetDateTime) temporal;
+                f.date = o.toLocalDate();
+                f.time = o.toLocalTime();
+                f.offsetValue = o.getOffset();
+                f.epochSecond = Long.valueOf(o.toEpochSecond());
+                f.nano = o.getNano();
+            } else if (temporal instanceof LocalDateTime) {
+                LocalDateTime l = (LocalDateTime) temporal;
+                f.date = l.toLocalDate();
+                f.time = l.toLocalTime();
+                f.nano = l.getNano();
+            } else if (temporal instanceof LocalDate) {
+                f.date = (LocalDate) temporal;
+            } else if (temporal instanceof LocalTime) {
+                f.time = (LocalTime) temporal;
+                f.nano = f.time.getNano();
+            } else if (temporal instanceof Instant) {
+                Instant i = (Instant) temporal;
+                f.epochSecond = Long.valueOf(i.getEpochSecond());
+                f.nano = i.getNano();
+            } else if (temporal instanceof DayOfWeek) {
+                f.dayOfWeek = (DayOfWeek) temporal;
+            } else if (temporal instanceof ZoneOffset) {
+                f.offsetValue = (ZoneOffset) temporal;
+            }
+            if (f.zone == null && override != null && !(temporal instanceof Instant)) {
+                f.zone = override;
+            }
+            return f;
+        }
+
+        LocalDate date(String field) {
+            if (date == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+            }
+            return date;
+        }
+
+        LocalTime time(String field) {
+            if (time == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+            }
+            return time;
         }
-        String frac = String.valueOf(1000000000L + time.getNano()).substring(1);
-        while (frac.endsWith("0")) {
-            frac = frac.substring(0, frac.length() - 1);
+
+        ZoneOffset offset(String field) {
+            if (offsetValue == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+            }
+            return offsetValue;
+        }
+
+        DayOfWeek dayOfWeek() {
+            if (dayOfWeek != null) {
+                return dayOfWeek;
+            }
+            return date("DayOfWeek").getDayOfWeek();
+        }
+
+        int nanoOfSecond() {
+            if (time == null && epochSecond == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: NanoOfSecond");
+            }
+            return nano;
         }
-        return base + "." + frac;
     }
 
-    private static String formatLocalDate(LocalDateTime dateTime) {
-        return formatLocalDate(dateTime.toLocalDate());
+    // ---- the pattern itself ----
+
+    private static final class Token {
+        static final int FIELD = 0;
+        static final int LITERAL = 1;
+        static final int OPTIONAL_START = 2;
+        static final int OPTIONAL_END = 3;
+
+        final int kind;
+        final char letter;
+        final int count;
+        final String text;
+
+        Token(int kind, char letter, int count, String text) {
+            this.kind = kind;
+            this.letter = letter;
+            this.count = count;
+            this.text = text;
+        }
     }
 
-    private static String formatLocalDateTime(LocalDateTime dateTime) {
-        return formatLocalDate(dateTime.toLocalDate()) + "T" + formatLocalTime(dateTime.toLocalTime());
+    private static final String SUPPORTED = "GuyMLQqdDEahKkHmsSnNAVzOXxZ";
+    private static final String KNOWN_UNSUPPORTED = "YwWecFgvBp";
+
+    private static Token[] compile(String pattern) {
+        ArrayList<Token> out = new ArrayList<Token>();
+        int depth = 0;
+        int i = 0;
+        while (i < pattern.length()) {
+            char c = pattern.charAt(i);
+            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
+                int start = i;
+                while (i < pattern.length() && pattern.charAt(i) == c) {
+                    i++;
+                }
+                int count = i - start;
+                if (KNOWN_UNSUPPORTED.indexOf(c) >= 0) {
+                    throw new IllegalArgumentException("Pattern letter not supported here: " + c);
+                }
+                if (SUPPORTED.indexOf(c) < 0) {
+                    throw new IllegalArgumentException("Unknown pattern letter: " + c);
+                }
+                validateCount(c, count);
+                out.add(new Token(Token.FIELD, c, count, null));
+            } else if (c == '\'') {
+                int start = i++;
+                StringBuilder lit = new StringBuilder();
+                boolean closed = false;
+                while (i < pattern.length()) {
+                    char q = pattern.charAt(i);
+                    if (q == '\'') {
+                        if (i + 1 < pattern.length() && pattern.charAt(i + 1) == '\'') {
+                            lit.append('\'');
+                            i += 2;
+                            continue;
+                        }
+                        closed = true;
+                        i++;
+                        break;
+                    }
+                    lit.append(q);
+                    i++;
+                }
+                if (!closed) {
+                    throw new IllegalArgumentException("Pattern ends with an incomplete string literal: " + pattern);
+                }
+                if (i - start == 2) {
+                    lit.append('\'');
+                }
+                out.add(new Token(Token.LITERAL, '\0', 0, lit.toString()));
+            } else if (c == '[') {
+                depth++;
+                out.add(new Token(Token.OPTIONAL_START, '\0', 0, null));
+                i++;
+            } else if (c == ']') {
+                if (depth == 0) {
+                    throw new IllegalArgumentException("Pattern invalid as it contains ] without previous [");
+                }
+                depth--;
+                out.add(new Token(Token.OPTIONAL_END, '\0', 0, null));
+                i++;
+            } else if (c == '{' || c == '}' || c == '#') {
+                throw new IllegalArgumentException("Pattern includes reserved character: '" + c + "'");
+            } else {
+                out.add(new Token(Token.LITERAL, '\0', 0, String.valueOf(c)));
+                i++;
+            }
+        }
+        while (depth-- > 0) {
+            out.add(new Token(Token.OPTIONAL_END, '\0', 0, null));
+        }
+        return out.toArray(new Token[out.size()]);
     }
 
-    private static String formatOffset(ZoneOffset offset) {
-        return offset.getId();
+    private static void validateCount(char c, int count) {
+        int max;
+        switch (c) {
+            case 'd':
+            case 'h':
+            case 'H':
+            case 'k':
+            case 'K':
+            case 'm':
+            case 's':
+                max = 2;
+                break;
+            case 'D':
+                max = 3;
+                break;
+            case 'a':
+                max = 1;
+                break;
+            case 'S':
+                max = 9;
+                break;
+            case 'z':
+                max = 4;
+                break;
+            case 'u':
+            case 'y':
+            case 'n':
+            case 'N':
+            case 'A':
+                max = 19;
+                break;
+            default:
+                max = 5;
+                break;
+        }
+        if (count > max) {
+            throw new IllegalArgumentException("Too many pattern letters: " + c);
+        }
+        if (c == 'V' && count != 2) {
+            throw new IllegalArgumentException("Pattern letter count must be 2: " + c);
+        }
+        if (c == 'O' && count != 1 && count != 4) {
+            throw new IllegalArgumentException("Pattern letter count must be 1 or 4: " + c);
+        }
     }
 
-    private static String formatInstant(Instant instant) {
-        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
-        return formatLocalDateTime(dateTime) + "Z";
+    public String toString() {
+        switch (kind) {
+            case KIND_LOCAL_DATE:
+                return "ISO_LOCAL_DATE";
+            case KIND_LOCAL_TIME:
+                return "ISO_LOCAL_TIME";
+            case KIND_LOCAL_DATE_TIME:
+                return "ISO_LOCAL_DATE_TIME";
+            case KIND_OFFSET_DATE_TIME:
+                return "ISO_OFFSET_DATE_TIME";
+            case KIND_ZONED_DATE_TIME:
+                return "ISO_ZONED_DATE_TIME";
+            case KIND_INSTANT:
+                return "ISO_INSTANT";
+            default:
+                return pattern;
+        }
     }
 }
diff --git a/Ports/CLDC11/src/java/time/temporal/ChronoUnit.java b/Ports/CLDC11/src/java/time/temporal/ChronoUnit.java
new file mode 100644
index 00000000000..9ad00f84c95
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/temporal/ChronoUnit.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.time.Duration;
+
+/// The units of the ISO calendar, with the JDK's order, names and lengths.
+public enum ChronoUnit implements TemporalUnit {
+    /// A nanosecond.
+    NANOS("Nanos", 0L, 1),
+    /// A microsecond.
+    MICROS("Micros", 0L, 1000),
+    /// A millisecond.
+    MILLIS("Millis", 0L, 1000000),
+    /// A second.
+    SECONDS("Seconds", 1L, 0),
+    /// A minute.
+    MINUTES("Minutes", 60L, 0),
+    /// An hour.
+    HOURS("Hours", 3600L, 0),
+    /// Twelve hours.
+    HALF_DAYS("HalfDays", 43200L, 0),
+    /// A day.
+    DAYS("Days", 86400L, 0),
+    /// Seven days.
+    WEEKS("Weeks", 7 * 86400L, 0),
+    /// A month, estimated as a twelfth of a year.
+    MONTHS("Months", 31556952L / 12, 0),
+    /// A year, estimated as 365.2425 days.
+    YEARS("Years", 31556952L, 0),
+    /// Ten years.
+    DECADES("Decades", 31556952L * 10L, 0),
+    /// A hundred years.
+    CENTURIES("Centuries", 31556952L * 100L, 0),
+    /// A thousand years.
+    MILLENNIA("Millennia", 31556952L * 1000L, 0),
+    /// An era, estimated as a billion years.
+    ERAS("Eras", 31556952L * 1000000000L, 0),
+    /// Forever: longer than any other unit.
+    FOREVER("Forever", Long.MAX_VALUE, 999999999);
+
+    private final String label;
+    private final long seconds;
+    private final int nanos;
+
+    ChronoUnit(String label, long seconds, int nanos) {
+        this.label = label;
+        this.seconds = seconds;
+        this.nanos = nanos;
+    }
+
+    @Override
+    public Duration getDuration() {
+        return Duration.ofSeconds(seconds, nanos);
+    }
+
+    @Override
+    public boolean isDurationEstimated() {
+        return compareTo(DAYS) >= 0;
+    }
+
+    @Override
+    public boolean isDateBased() {
+        return compareTo(DAYS) >= 0 && this != FOREVER;
+    }
+
+    @Override
+    public boolean isTimeBased() {
+        return compareTo(DAYS) < 0;
+    }
+
+    @Override
+    public boolean isSupportedBy(Temporal temporal) {
+        return temporal.isSupported(this);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <R extends Temporal> R addTo(R temporal, long amount) {
+        return (R) temporal.plus(amount, this);
+    }
+
+    @Override
+    public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) {
+        return temporal1Inclusive.until(temporal2Exclusive, this);
+    }
+
+    @Override
+    public String toString() {
+        return label;
+    }
+}
diff --git a/Ports/CLDC11/src/java/time/temporal/Temporal.java b/Ports/CLDC11/src/java/time/temporal/Temporal.java
new file mode 100644
index 00000000000..3691dd73012
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/temporal/Temporal.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+/// A date, a time or a moment that can be moved by an amount of time and
+/// measured against another of its kind.
+public interface Temporal extends TemporalAccessor {
+    /// Whether this value can add or subtract `unit`.
+    boolean isSupported(TemporalUnit unit);
+
+    /// This value moved forward by `amountToAdd` of `unit`.
+    Temporal plus(long amountToAdd, TemporalUnit unit);
+
+    /// This value moved back by `amountToSubtract` of `unit`.
+    default Temporal minus(long amountToSubtract, TemporalUnit unit) {
+        if (amountToSubtract == Long.MIN_VALUE) {
+            return plus(Long.MAX_VALUE, unit).plus(1, unit);
+        }
+        return plus(-amountToSubtract, unit);
+    }
+
+    /// This value moved forward by `amount`.
+    default Temporal plus(TemporalAmount amount) {
+        return amount.addTo(this);
+    }
+
+    /// This value moved back by `amount`.
+    default Temporal minus(TemporalAmount amount) {
+        return amount.subtractFrom(this);
+    }
+
+    /// The whole units of `unit` from this value to `endExclusive`.
+    long until(Temporal endExclusive, TemporalUnit unit);
+}
diff --git a/Ports/CLDC11/src/java/time/temporal/TemporalAccessor.java b/Ports/CLDC11/src/java/time/temporal/TemporalAccessor.java
index 93d35a217ec..6eb2ce641fa 100644
--- a/Ports/CLDC11/src/java/time/temporal/TemporalAccessor.java
+++ b/Ports/CLDC11/src/java/time/temporal/TemporalAccessor.java
@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time.temporal;
 
 public interface TemporalAccessor {
diff --git a/Ports/CLDC11/src/java/time/temporal/TemporalAmount.java b/Ports/CLDC11/src/java/time/temporal/TemporalAmount.java
new file mode 100644
index 00000000000..5feea4d1152
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/temporal/TemporalAmount.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.util.List;
+
+/// An amount of time, such as a `Duration` or a `Period`.
+public interface TemporalAmount {
+    /// The amount of `unit` this holds.
+    long get(TemporalUnit unit);
+
+    /// The units this amount is made of.
+    List<TemporalUnit> getUnits();
+
+    /// `temporal` moved forward by this amount.
+    Temporal addTo(Temporal temporal);
+
+    /// `temporal` moved back by this amount.
+    Temporal subtractFrom(Temporal temporal);
+}
diff --git a/Ports/CLDC11/src/java/time/temporal/TemporalQuery.java b/Ports/CLDC11/src/java/time/temporal/TemporalQuery.java
new file mode 100644
index 00000000000..5d11d5100ca
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/temporal/TemporalQuery.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+/// A question asked of a date or time, such as what
+/// `formatter.parse(text, LocalDate::from)` takes as its second argument.
+public interface TemporalQuery<R> {
+    /// The answer for `temporal`.
+    R queryFrom(TemporalAccessor temporal);
+}
diff --git a/Ports/CLDC11/src/java/time/temporal/TemporalUnit.java b/Ports/CLDC11/src/java/time/temporal/TemporalUnit.java
new file mode 100644
index 00000000000..4b894f379a0
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/temporal/TemporalUnit.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.time.Duration;
+
+/// A unit time is measured in. `ChronoUnit` holds the units of the ISO
+/// calendar.
+public interface TemporalUnit {
+    /// The length of one unit; an estimate for the units a calendar decides.
+    Duration getDuration();
+
+    /// Whether the length is an estimate.
+    boolean isDurationEstimated();
+
+    /// Whether this is a unit of a date: a day or longer.
+    boolean isDateBased();
+
+    /// Whether this is a unit of a time of day: shorter than a day.
+    boolean isTimeBased();
+
+    /// Whether `temporal` can add or subtract this unit.
+    default boolean isSupportedBy(Temporal temporal) {
+        return temporal.isSupported(this);
+    }
+
+    /// `temporal` moved by `amount` of this unit.
+    <R extends Temporal> R addTo(R temporal, long amount);
+
+    /// How many whole units lie between two values of the same kind.
+    long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive);
+}
diff --git a/Ports/CLDC11/src/java/time/temporal/UnsupportedTemporalTypeException.java b/Ports/CLDC11/src/java/time/temporal/UnsupportedTemporalTypeException.java
new file mode 100644
index 00000000000..b36e943c05b
--- /dev/null
+++ b/Ports/CLDC11/src/java/time/temporal/UnsupportedTemporalTypeException.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.time.DateTimeException;
+
+/// Thrown when a date or time is asked for a unit it does not have.
+public class UnsupportedTemporalTypeException extends DateTimeException {
+    /// An exception with `message`.
+    public UnsupportedTemporalTypeException(String message) {
+        super(message);
+    }
+
+    /// An exception with `message`, caused by `cause`.
+    public UnsupportedTemporalTypeException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Arrays.java b/Ports/CLDC11/src/java/util/Arrays.java
index b919f41fd68..b0eeac2bd5d 100644
--- a/Ports/CLDC11/src/java/util/Arrays.java
+++ b/Ports/CLDC11/src/java/util/Arrays.java
@@ -4293,4 +4293,59 @@ public static short[] copyOf(short[] original, int len) {
         return copyOfRange(original, 0, len);
     }
    
+
+    /// A sequential stream of the elements of `array`.
+    public static <T> java.util.stream.Stream<T> stream(T[] array) {
+        return java.util.stream.Stream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static <T> java.util.stream.Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.Stream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    /// A sequential stream of the elements of `array`.
+    public static java.util.stream.IntStream stream(int[] array) {
+        return java.util.stream.IntStream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static java.util.stream.IntStream stream(int[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.IntStream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    /// A sequential stream of the elements of `array`.
+    public static java.util.stream.LongStream stream(long[] array) {
+        return java.util.stream.LongStream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static java.util.stream.LongStream stream(long[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.LongStream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    /// A sequential stream of the elements of `array`.
+    public static java.util.stream.DoubleStream stream(double[] array) {
+        return java.util.stream.DoubleStream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static java.util.stream.DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.DoubleStream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    private static void checkStreamRange(int length, int startInclusive, int endExclusive) {
+        if (startInclusive < 0 || endExclusive > length || startInclusive > endExclusive) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + startInclusive + ") > fence(" + endExclusive + ")");
+        }
+    }
+
 }
diff --git a/Ports/CLDC11/src/java/util/Base64.java b/Ports/CLDC11/src/java/util/Base64.java
new file mode 100644
index 00000000000..3d7e81f62e6
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/Base64.java
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.Base64`: the basic, URL-safe and MIME encodings of RFC 4648
+/// and RFC 2045, by the JDK's rules for padding and for what a decoder
+/// refuses.
+public final class Base64 {
+    private static final String BASIC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    private static final String URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    private static final byte[] CRLF = {'\r', '\n'};
+
+    private Base64() {
+    }
+
+    public static Encoder getEncoder() {
+        return new Encoder(BASIC, 0, null, true);
+    }
+
+    public static Encoder getUrlEncoder() {
+        return new Encoder(URL, 0, null, true);
+    }
+
+    public static Encoder getMimeEncoder() {
+        return new Encoder(BASIC, 76, CRLF, true);
+    }
+
+    public static Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) {
+        if (lineSeparator == null) {
+            throw new NullPointerException();
+        }
+        for (int i = 0; i < lineSeparator.length; i++) {
+            int b = lineSeparator[i] & 0xFF;
+            // The padding character too, as on the JDK: a '=' between two
+            // groups reads as the end of the data.
+            if (b == '=' || BASIC.indexOf((char) b) >= 0) {
+                throw new IllegalArgumentException("Illegal base64 line separator character 0x"
+                        + Integer.toString(b, 16));
+            }
+        }
+        // Rounded down to a multiple of four, as whole groups make a line.
+        int length = lineLength & ~3;
+        if (length <= 0) {
+            return new Encoder(BASIC, 0, null, true);
+        }
+        byte[] separator = new byte[lineSeparator.length];
+        System.arraycopy(lineSeparator, 0, separator, 0, separator.length);
+        return new Encoder(BASIC, length, separator, true);
+    }
+
+    public static Decoder getDecoder() {
+        return new Decoder(BASIC, false);
+    }
+
+    public static Decoder getUrlDecoder() {
+        return new Decoder(URL, false);
+    }
+
+    public static Decoder getMimeDecoder() {
+        return new Decoder(BASIC, true);
+    }
+
+    /// `java.util.Base64.Encoder`.
+    public static final class Encoder {
+        private final String alphabet;
+        private final int lineLength;
+        private final byte[] separator;
+        private final boolean padding;
+
+        Encoder(String alphabet, int lineLength, byte[] separator, boolean padding) {
+            this.alphabet = alphabet;
+            this.lineLength = lineLength;
+            this.separator = separator;
+            this.padding = padding;
+        }
+
+        /// The same encoding without the `=` that fills the last group.
+        public Encoder withoutPadding() {
+            return padding ? new Encoder(alphabet, lineLength, separator, false) : this;
+        }
+
+        private int length(int n) {
+            int length = padding ? 4 * ((n + 2) / 3) : 4 * (n / 3) + (n % 3 == 0 ? 0 : n % 3 + 1);
+            if (lineLength > 0 && length > 0) {
+                length += (length - 1) / lineLength * separator.length;
+            }
+            return length;
+        }
+
+        public byte[] encode(byte[] src) {
+            byte[] out = new byte[length(src.length)];
+            write(src, out);
+            return out;
+        }
+
+        /// Encodes into `dst`, which must be large enough, and answers how
+        /// many bytes were written.
+        public int encode(byte[] src, byte[] dst) {
+            if (dst.length < length(src.length)) {
+                throw new IllegalArgumentException("Output byte array is too small for encoding all input bytes");
+            }
+            return write(src, dst);
+        }
+
+        public String encodeToString(byte[] src) {
+            byte[] out = encode(src);
+            char[] chars = new char[out.length];
+            for (int i = 0; i < out.length; i++) {
+                chars[i] = (char) (out[i] & 0xFF);
+            }
+            return new String(chars);
+        }
+
+        private int write(byte[] src, byte[] dst) {
+            int at = 0;
+            int onLine = 0;
+            int n = src.length;
+            for (int i = 0; i < n; i += 3) {
+                if (lineLength > 0 && onLine == lineLength) {
+                    for (int s = 0; s < separator.length; s++) {
+                        dst[at++] = separator[s];
+                    }
+                    onLine = 0;
+                }
+                int left = n - i;
+                int bits = (src[i] & 0xFF) << 16;
+                if (left > 1) {
+                    bits |= (src[i + 1] & 0xFF) << 8;
+                }
+                if (left > 2) {
+                    bits |= src[i + 2] & 0xFF;
+                }
+                dst[at++] = (byte) alphabet.charAt((bits >> 18) & 0x3F);
+                dst[at++] = (byte) alphabet.charAt((bits >> 12) & 0x3F);
+                if (left > 1) {
+                    dst[at++] = (byte) alphabet.charAt((bits >> 6) & 0x3F);
+                } else if (padding) {
+                    dst[at++] = '=';
+                }
+                if (left > 2) {
+                    dst[at++] = (byte) alphabet.charAt(bits & 0x3F);
+                } else if (padding) {
+                    dst[at++] = '=';
+                }
+                onLine += 4;
+            }
+            return at;
+        }
+    }
+
+    /// `java.util.Base64.Decoder`.
+    public static final class Decoder {
+        private final int[] values = new int[256];
+        private final boolean mime;
+
+        Decoder(String alphabet, boolean mime) {
+            this.mime = mime;
+            for (int i = 0; i < 256; i++) {
+                values[i] = -1;
+            }
+            for (int i = 0; i < alphabet.length(); i++) {
+                values[alphabet.charAt(i)] = i;
+            }
+            values['='] = -2;
+        }
+
+        public byte[] decode(String src) {
+            byte[] bytes = new byte[src.length()];
+            for (int i = 0; i < bytes.length; i++) {
+                char c = src.charAt(i);
+                bytes[i] = (byte) (c < 256 ? c : '?');
+            }
+            return decode(bytes);
+        }
+
+        public byte[] decode(byte[] src) {
+            byte[] out = new byte[src.length / 4 * 3 + 3];
+            int n = read(src, out);
+            byte[] exact = new byte[n];
+            System.arraycopy(out, 0, exact, 0, n);
+            return exact;
+        }
+
+        /// Decodes into `dst`, which must be large enough, and answers how
+        /// many bytes were written.
+        public int decode(byte[] src, byte[] dst) {
+            byte[] out = decode(src);
+            if (dst.length < out.length) {
+                throw new IllegalArgumentException("Output byte array is too small for decoding all input bytes");
+            }
+            System.arraycopy(out, 0, dst, 0, out.length);
+            return out.length;
+        }
+
+        private int read(byte[] src, byte[] dst) {
+            int at = 0;
+            int bits = 0;
+            int shift = 18;
+            int sp = 0;
+            int end = src.length;
+            while (sp < end) {
+                int b = values[src[sp++] & 0xFF];
+                if (b < 0) {
+                    if (b == -2) {
+                        // xx== or xxx=, and nothing else, ends the input.
+                        if (shift == 6 && (sp == end || src[sp++] != '=') || shift == 18) {
+                            throw new IllegalArgumentException("Input byte array has wrong 4-byte ending unit");
+                        }
+                        break;
+                    }
+                    if (mime) {
+                        continue;
+                    }
+                    throw new IllegalArgumentException("Illegal base64 character "
+                            + Integer.toString(src[sp - 1], 16));
+                }
+                bits |= b << shift;
+                shift -= 6;
+                if (shift < 0) {
+                    dst[at++] = (byte) (bits >> 16);
+                    dst[at++] = (byte) (bits >> 8);
+                    dst[at++] = (byte) bits;
+                    shift = 18;
+                    bits = 0;
+                }
+            }
+            if (shift == 6) {
+                dst[at++] = (byte) (bits >> 16);
+            } else if (shift == 0) {
+                dst[at++] = (byte) (bits >> 16);
+                dst[at++] = (byte) (bits >> 8);
+            } else if (shift == 12) {
+                throw new IllegalArgumentException("Last unit does not have enough valid bits");
+            }
+            while (sp < end) {
+                if (mime && values[src[sp++] & 0xFF] < 0) {
+                    continue;
+                }
+                throw new IllegalArgumentException("Input byte array has incorrect ending byte at " + sp);
+            }
+            return at;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Collection.java b/Ports/CLDC11/src/java/util/Collection.java
index ba29f40a84e..5fb0e8953f2 100644
--- a/Ports/CLDC11/src/java/util/Collection.java
+++ b/Ports/CLDC11/src/java/util/Collection.java
@@ -17,6 +17,7 @@
 
 package java.util;
 
+import java.util.function.IntFunction;
 import java.util.function.Predicate;
 
 
@@ -373,4 +374,28 @@ public interface Collection<E> extends java.lang.Iterable<E> {
     default boolean removeIf(Predicate<? super E> filter) {
         return false;
     }
+
+    /// A sequential stream of the elements, read when a terminal operation
+    /// asks for them, so elements added before then are seen.
+    default java.util.stream.Stream<E> stream() {
+        return java.util.stream.StreamSupport.stream(spliterator(), false);
+    }
+
+    /// The same as [#stream()]: streams here are sequential, which the JDK
+    /// allows a parallel stream to be.
+    default java.util.stream.Stream<E> parallelStream() {
+        return java.util.stream.StreamSupport.stream(spliterator(), true);
+    }
+
+    /// The elements, read from [#iterator()] when the first one is asked for.
+    @Override
+    default Spliterator<E> spliterator() {
+        return Spliterators.spliterator(this, 0);
+    }
+
+    /// The elements in an array `generator` makes, as `toArray(generator.apply(0))`.
+    default <T> T[] toArray(IntFunction<T[]> generator) {
+        return toArray(generator.apply(0));
+    }
+
 }
diff --git a/Ports/CLDC11/src/java/util/Collections.java b/Ports/CLDC11/src/java/util/Collections.java
index b8d36dcfb29..c91538197ba 100644
--- a/Ports/CLDC11/src/java/util/Collections.java
+++ b/Ports/CLDC11/src/java/util/Collections.java
@@ -2519,6 +2519,12 @@ public static final <T> List<T> emptyList() {
         return EMPTY_LIST;
     }
 
+    /// An empty, immutable `Iterator`.
+    @SuppressWarnings("unchecked")
+    public static final <T> Iterator<T> emptyIterator() {
+        return EMPTY_LIST.iterator();
+    }
+
     /// Returns a type-safe empty, immutable `Set`.
     ///
     /// #### Returns
diff --git a/Ports/CLDC11/src/java/util/Comparator.java b/Ports/CLDC11/src/java/util/Comparator.java
index 8a571fba418..3f0313d8567 100644
--- a/Ports/CLDC11/src/java/util/Comparator.java
+++ b/Ports/CLDC11/src/java/util/Comparator.java
@@ -78,4 +78,253 @@ public interface Comparator<T> {
     ///
     /// - Object#equals
     public boolean equals(Object object);
+
+    /// This ordering, reversed.
+    ///
+    /// @return the reversed comparator
+    default Comparator<T> reversed() {
+        final Comparator<T> self = this;
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                return self.compare(b, a);
+            }
+        };
+    }
+
+    /// This ordering, ties broken by `other`.
+    ///
+    /// @param other the tie breaker
+    /// @return the combined comparator
+    default Comparator<T> thenComparing(final Comparator<? super T> other) {
+        // Arguments are checked here, not when the comparator is first used, as on the JDK.
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        final Comparator<T> self = this;
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                int r = self.compare(a, b);
+                return r != 0 ? r : other.compare(a, b);
+            }
+        };
+    }
+
+    /// This ordering, ties broken by the natural order of a key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <U> the key type
+    /// @return the combined comparator
+    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
+            java.util.function.Function<? super T, ? extends U> keyExtractor) {
+        return thenComparing(Comparator.<T, U>comparing(keyExtractor));
+    }
+
+    /// Compares by the natural order of a key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @param <U> the key type
+    /// @return the comparator
+    static <T, U extends Comparable<? super U>> Comparator<T> comparing(
+            final java.util.function.Function<? super T, ? extends U> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                return keyExtractor.apply(a).compareTo(keyExtractor.apply(b));
+            }
+        };
+    }
+
+    /// Compares by a key, using the given comparator for the keys.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param keyComparator orders the keys
+    /// @param <T> the compared type
+    /// @param <U> the key type
+    /// @return the comparator
+    static <T, U> Comparator<T> comparing(final java.util.function.Function<? super T, ? extends U> keyExtractor,
+            final Comparator<? super U> keyComparator) {
+        if (keyExtractor == null || keyComparator == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                return keyComparator.compare(keyExtractor.apply(a), keyExtractor.apply(b));
+            }
+        };
+    }
+
+    /// The natural order of comparable values.
+    ///
+    /// @param <T> the compared type
+    /// @return the comparator
+    @SuppressWarnings("unchecked")
+    static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
+        return (Comparator<T>) NaturalOrder.INSTANCE;
+    }
+
+    /// The reverse of the natural order.
+    ///
+    /// @param <T> the compared type
+    /// @return the comparator
+    @SuppressWarnings("unchecked")
+    static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
+        // Not Collections.reverseOrder(): naming Collections here makes the translator
+        // load it, and with it classes (Collections.SetFromMap) whose presence the native
+        // collection traversal keys on, in every application.
+        return (Comparator<T>) NaturalOrder.INSTANCE.reversed();
+    }
+
+    /// This ordering, ties broken by a key in the order `keyComparator` gives.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param keyComparator orders the keys
+    /// @param <U> the key type
+    /// @return the combined comparator
+    default <U> Comparator<T> thenComparing(java.util.function.Function<? super T, ? extends U> keyExtractor,
+            Comparator<? super U> keyComparator) {
+        return thenComparing(Comparator.<T, U>comparing(keyExtractor, keyComparator));
+    }
+
+    /// This ordering, ties broken by an `int` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @return the combined comparator
+    default Comparator<T> thenComparingInt(java.util.function.ToIntFunction<? super T> keyExtractor) {
+        return thenComparing(Comparator.<T>comparingInt(keyExtractor));
+    }
+
+    /// This ordering, ties broken by a `long` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @return the combined comparator
+    default Comparator<T> thenComparingLong(java.util.function.ToLongFunction<? super T> keyExtractor) {
+        return thenComparing(Comparator.<T>comparingLong(keyExtractor));
+    }
+
+    /// This ordering, ties broken by a `double` key, compared as [Double#compare] does.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @return the combined comparator
+    default Comparator<T> thenComparingDouble(java.util.function.ToDoubleFunction<? super T> keyExtractor) {
+        return thenComparing(Comparator.<T>comparingDouble(keyExtractor));
+    }
+
+    /// Compares by an `int` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> comparingInt(final java.util.function.ToIntFunction<? super T> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                int x = keyExtractor.applyAsInt(a);
+                int y = keyExtractor.applyAsInt(b);
+                return x < y ? -1 : x == y ? 0 : 1;
+            }
+        };
+    }
+
+    /// Compares by a `long` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> comparingLong(final java.util.function.ToLongFunction<? super T> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                long x = keyExtractor.applyAsLong(a);
+                long y = keyExtractor.applyAsLong(b);
+                return x < y ? -1 : x == y ? 0 : 1;
+            }
+        };
+    }
+
+    /// Compares by a `double` key, as [Double#compare] does: NaN above
+    /// everything and `-0.0` below `0.0`.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> comparingDouble(final java.util.function.ToDoubleFunction<? super T> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                return Double.compare(keyExtractor.applyAsDouble(a), keyExtractor.applyAsDouble(b));
+            }
+        };
+    }
+
+    /// Orders null before every other value, and the rest by `comparator`;
+    /// with a null `comparator` the others are all equal.
+    ///
+    /// @param comparator orders the values that are not null, or null
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
+        return new NullOrder<T>(true, comparator);
+    }
+
+    /// Orders null after every other value, and the rest by `comparator`;
+    /// with a null `comparator` the others are all equal.
+    ///
+    /// @param comparator orders the values that are not null, or null
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
+        return new NullOrder<T>(false, comparator);
+    }
+}
+
+/// The order [Comparator#nullsFirst] and [Comparator#nullsLast] hand out. Its
+/// [#reversed] keeps null on the same side and reverses the rest, as the JDK's does.
+final class NullOrder<T> implements Comparator<T> {
+    private final boolean nullFirst;
+    private final Comparator<T> real;
+
+    @SuppressWarnings("unchecked")
+    NullOrder(boolean nullFirst, Comparator<? super T> real) {
+        this.nullFirst = nullFirst;
+        this.real = (Comparator<T>) real;
+    }
+
+    public int compare(T a, T b) {
+        if (a == null) {
+            return b == null ? 0 : nullFirst ? -1 : 1;
+        }
+        if (b == null) {
+            return nullFirst ? 1 : -1;
+        }
+        return real == null ? 0 : real.compare(a, b);
+    }
+
+    public Comparator<T> thenComparing(Comparator<? super T> other) {
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        return new NullOrder<T>(nullFirst, real == null ? other : real.thenComparing(other));
+    }
+
+    public Comparator<T> reversed() {
+        return new NullOrder<T>(!nullFirst, real == null ? null : real.reversed());
+    }
+}
+
+/// The natural ordering [Comparator#naturalOrder] hands out.
+final class NaturalOrder implements Comparator<Comparable<Object>> {
+    static final NaturalOrder INSTANCE = new NaturalOrder();
+
+    public int compare(Comparable<Object> a, Comparable<Object> b) {
+        return a.compareTo(b);
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/Date.java b/Ports/CLDC11/src/java/util/Date.java
index 9c70c039957..ec382eda8fb 100644
--- a/Ports/CLDC11/src/java/util/Date.java
+++ b/Ports/CLDC11/src/java/util/Date.java
@@ -70,4 +70,83 @@ public int compareTo(Date arg0) {
         return 0;
     }
 
+    /// This date as an [java.time.Instant].
+    public java.time.Instant toInstant() {
+        return java.time.Instant.ofEpochMilli(getTime());
+    }
+
+    /// The date of `instant`, which must fit in milliseconds since the
+    /// epoch.
+    public static Date from(java.time.Instant instant) {
+        try {
+            return new Date(instant.toEpochMilli());
+        } catch (ArithmeticException ex) {
+            throw new IllegalArgumentException(ex.toString());
+        }
+    }
+
+    /// Whether this date is after `when`.
+    public boolean after(Date when) {
+        return getTime() > when.getTime();
+    }
+
+    /// Whether this date is before `when`.
+    public boolean before(Date when) {
+        return getTime() < when.getTime();
+    }
+
+    private int field(int field) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(this);
+        return calendar.get(field);
+    }
+
+    /// The year less 1900, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.YEAR) - 1900`
+    public int getYear() {
+        return field(Calendar.YEAR) - 1900;
+    }
+
+    /// The month, 0 for January, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.MONTH)`
+    public int getMonth() {
+        return field(Calendar.MONTH);
+    }
+
+    /// The day of the month, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.DAY_OF_MONTH)`
+    public int getDate() {
+        return field(Calendar.DAY_OF_MONTH);
+    }
+
+    /// The day of the week, 0 for Sunday, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.DAY_OF_WEEK)`
+    public int getDay() {
+        return field(Calendar.DAY_OF_WEEK) - Calendar.SUNDAY;
+    }
+
+    /// The hour of the day, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.HOUR_OF_DAY)`
+    public int getHours() {
+        return field(Calendar.HOUR_OF_DAY);
+    }
+
+    /// The minute of the hour, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.MINUTE)`
+    public int getMinutes() {
+        return field(Calendar.MINUTE);
+    }
+
+    /// The second of the minute, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.SECOND)`
+    public int getSeconds() {
+        return field(Calendar.SECOND);
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/DoubleSum.java b/Ports/CLDC11/src/java/util/DoubleSum.java
new file mode 100644
index 00000000000..02920bd9cb8
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/DoubleSum.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// A running sum of `double` values that carries the rounding error of each
+/// addition along (Kahan summation), so that adding many small values to a
+/// large one does not lose them.
+final class DoubleSum {
+
+    private double sum;
+    private double compensation;
+    /// The plain sum, which is what says "infinite" when the compensated
+    /// one has turned into a NaN by subtracting two infinities.
+    private double simple;
+
+    void add(double value) {
+        simple += value;
+        double corrected = value - compensation;
+        double next = sum + corrected;
+        compensation = (next - sum) - corrected;
+        sum = next;
+    }
+
+    void add(DoubleSum other) {
+        double plain = simple + other.simple;
+        add(other.sum);
+        add(-other.compensation);
+        simple = plain;
+    }
+
+    double value() {
+        double out = sum - compensation;
+        if (Double.isNaN(out) && Double.isInfinite(simple)) {
+            return simple;
+        }
+        return out;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/DoubleSummaryStatistics.java b/Ports/CLDC11/src/java/util/DoubleSummaryStatistics.java
new file mode 100644
index 00000000000..4d219243bb2
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/DoubleSummaryStatistics.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.DoubleConsumer;
+
+/// The count,
+/// sum, minimum, maximum and average of the values it was given.
+public class DoubleSummaryStatistics implements DoubleConsumer {
+
+    private long count;
+    private final DoubleSum sum = new DoubleSum();
+    private double min = Double.POSITIVE_INFINITY;
+    private double max = Double.NEGATIVE_INFINITY;
+
+    public DoubleSummaryStatistics() {
+        // Nothing seen yet.
+    }
+
+    @Override
+    public void accept(double value) {
+        count++;
+        sum.add(value);
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+
+    public void combine(DoubleSummaryStatistics other) {
+        count += other.count;
+        sum.add(other.sum);
+        min = Math.min(min, other.min);
+        max = Math.max(max, other.max);
+    }
+
+    public final long getCount() {
+        return count;
+    }
+
+    public final double getSum() {
+        return sum.value();
+    }
+
+    public final double getMin() {
+        return min;
+    }
+
+    public final double getMax() {
+        return max;
+    }
+
+    public final double getAverage() {
+        return count > 0 ? (double) getSum() / count : 0.0d;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/EventObject.java b/Ports/CLDC11/src/java/util/EventObject.java
new file mode 100644
index 00000000000..48f852f5505
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/EventObject.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.EventObject`: the root of every
+/// listener event, carrying the object the event happened on.
+public class EventObject implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The object the event initially occurred on.
+    protected transient Object source;
+
+    public EventObject(Object source) {
+        if (source == null) {
+            throw new IllegalArgumentException("null source");
+        }
+        this.source = source;
+    }
+
+    public Object getSource() {
+        return source;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[source=" + source + "]";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/HexFormat.java b/Ports/CLDC11/src/java/util/HexFormat.java
new file mode 100644
index 00000000000..d0c73c05d3e
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/HexFormat.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.HexFormat`: bytes to hexadecimal text and back, with an
+/// optional delimiter between bytes and a prefix and suffix around each.
+public final class HexFormat {
+    private static final String LOWER = "0123456789abcdef";
+    private static final String UPPER = "0123456789ABCDEF";
+    private static final HexFormat PLAIN = new HexFormat("", "", "", false);
+
+    private final String delimiter;
+    private final String prefix;
+    private final String suffix;
+    private final boolean upper;
+
+    private HexFormat(String delimiter, String prefix, String suffix, boolean upper) {
+        if (delimiter == null || prefix == null || suffix == null) {
+            throw new NullPointerException();
+        }
+        this.delimiter = delimiter;
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.upper = upper;
+    }
+
+    /// Lowercase digits and nothing between or around the bytes.
+    public static HexFormat of() {
+        return PLAIN;
+    }
+
+    public static HexFormat ofDelimiter(String delimiter) {
+        return new HexFormat(delimiter, "", "", false);
+    }
+
+    public HexFormat withDelimiter(String delimiter) {
+        return new HexFormat(delimiter, prefix, suffix, upper);
+    }
+
+    public HexFormat withPrefix(String prefix) {
+        return new HexFormat(delimiter, prefix, suffix, upper);
+    }
+
+    public HexFormat withSuffix(String suffix) {
+        return new HexFormat(delimiter, prefix, suffix, upper);
+    }
+
+    public HexFormat withUpperCase() {
+        return new HexFormat(delimiter, prefix, suffix, true);
+    }
+
+    public HexFormat withLowerCase() {
+        return new HexFormat(delimiter, prefix, suffix, false);
+    }
+
+    public String delimiter() {
+        return delimiter;
+    }
+
+    public String prefix() {
+        return prefix;
+    }
+
+    public String suffix() {
+        return suffix;
+    }
+
+    public boolean isUpperCase() {
+        return upper;
+    }
+
+    public String formatHex(byte[] bytes) {
+        return formatHex(bytes, 0, bytes.length);
+    }
+
+    public String formatHex(byte[] bytes, int fromIndex, int toIndex) {
+        if (fromIndex < 0 || toIndex > bytes.length || fromIndex > toIndex) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + toIndex
+                    + ") out of bounds for length " + bytes.length);
+        }
+        String digits = upper ? UPPER : LOWER;
+        StringBuilder out = new StringBuilder();
+        for (int i = fromIndex; i < toIndex; i++) {
+            if (i > fromIndex) {
+                out.append(delimiter);
+            }
+            out.append(prefix).append(digits.charAt((bytes[i] >> 4) & 0xF)).append(digits.charAt(bytes[i] & 0xF))
+                    .append(suffix);
+        }
+        return out.toString();
+    }
+
+    public byte[] parseHex(CharSequence string) {
+        return parseHex(string, 0, string.length());
+    }
+
+    public byte[] parseHex(CharSequence string, int fromIndex, int toIndex) {
+        if (fromIndex < 0 || toIndex > string.length() || fromIndex > toIndex) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + toIndex
+                    + ") out of bounds for length " + string.length());
+        }
+        int length = toIndex - fromIndex;
+        if (length == 0) {
+            return new byte[0];
+        }
+        int each = prefix.length() + 2 + suffix.length();
+        int stride = each + delimiter.length();
+        if ((length - each) % stride != 0) {
+            throw new IllegalArgumentException("extra or missing delimiters "
+                    + "or values consisting of prefix, two hexadecimal digits, and suffix in the string");
+        }
+        byte[] out = new byte[(length - each) / stride + 1];
+        int at = fromIndex;
+        for (int i = 0; i < out.length; i++) {
+            if (i > 0) {
+                at = expect(string, at, delimiter, "delimiter");
+            }
+            at = expect(string, at, prefix, "prefix");
+            out[i] = (byte) (fromHexDigit(string.charAt(at)) * 16 + fromHexDigit(string.charAt(at + 1)));
+            at = expect(string, at + 2, suffix, "suffix");
+        }
+        return out;
+    }
+
+    private static int expect(CharSequence string, int at, String literal, String what) {
+        for (int i = 0; i < literal.length(); i++) {
+            if (string.charAt(at + i) != literal.charAt(i)) {
+                throw new IllegalArgumentException("found: \"" + string.subSequence(at, at + literal.length())
+                        + "\", expected: \"" + literal + "\", index: " + at + " ch: "
+                        + Integer.toHexString(string.charAt(at)));
+            }
+        }
+        return at + literal.length();
+    }
+
+    public char toLowHexDigit(int value) {
+        return (upper ? UPPER : LOWER).charAt(value & 0xF);
+    }
+
+    public char toHighHexDigit(int value) {
+        return (upper ? UPPER : LOWER).charAt((value >> 4) & 0xF);
+    }
+
+    public String toHexDigits(byte value) {
+        return toHexDigits(value, 2);
+    }
+
+    public String toHexDigits(char value) {
+        return toHexDigits(value, 4);
+    }
+
+    public String toHexDigits(short value) {
+        return toHexDigits(value, 4);
+    }
+
+    public String toHexDigits(int value) {
+        return toHexDigits(value, 8);
+    }
+
+    public String toHexDigits(long value) {
+        return toHexDigits(value, 16);
+    }
+
+    public String toHexDigits(long value, int digits) {
+        if (digits < 0 || digits > 16) {
+            throw new IllegalArgumentException("number of digits: " + digits);
+        }
+        char[] out = new char[digits];
+        long v = value;
+        for (int i = digits - 1; i >= 0; i--) {
+            out[i] = toLowHexDigit((int) v);
+            v >>>= 4;
+        }
+        return new String(out);
+    }
+
+    public static boolean isHexDigit(int ch) {
+        return ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'f' || ch >= 'A' && ch <= 'F';
+    }
+
+    public static int fromHexDigit(int ch) {
+        if (ch >= '0' && ch <= '9') {
+            return ch - '0';
+        }
+        if (ch >= 'a' && ch <= 'f') {
+            return ch - 'a' + 10;
+        }
+        if (ch >= 'A' && ch <= 'F') {
+            return ch - 'A' + 10;
+        }
+        throw new NumberFormatException("not a hexadecimal digit: \"" + (char) ch + "\" = " + ch);
+    }
+
+    public static int fromHexDigits(CharSequence string) {
+        int length = string.length();
+        if (length > 8) {
+            throw new IllegalArgumentException("string length greater than 8: " + length);
+        }
+        int value = 0;
+        for (int i = 0; i < length; i++) {
+            value = (value << 4) + fromHexDigit(string.charAt(i));
+        }
+        return value;
+    }
+
+    public static long fromHexDigitsToLong(CharSequence string) {
+        int length = string.length();
+        if (length > 16) {
+            throw new IllegalArgumentException("string length greater than 16: " + length);
+        }
+        long value = 0;
+        for (int i = 0; i < length; i++) {
+            value = (value << 4) + fromHexDigit(string.charAt(i));
+        }
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof HexFormat)) {
+            return false;
+        }
+        HexFormat other = (HexFormat) o;
+        return upper == other.upper && delimiter.equals(other.delimiter) && prefix.equals(other.prefix)
+                && suffix.equals(other.suffix);
+    }
+
+    @Override
+    public int hashCode() {
+        return (delimiter.hashCode() * 31 + prefix.hashCode()) * 31 + suffix.hashCode() + (upper ? 1 : 0);
+    }
+
+    @Override
+    public String toString() {
+        return "uppercase: " + upper + ", delimiter: \"" + delimiter + "\", prefix: \"" + prefix
+                + "\", suffix: \"" + suffix + "\"";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/ImmutableCollections.java b/Ports/CLDC11/src/java/util/ImmutableCollections.java
new file mode 100644
index 00000000000..a7e5309180e
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/ImmutableCollections.java
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
+/// What `List.of`, `Set.of`, `Map.of`, their `copyOf` forms and `Map.entry`
+/// answer: collections that reject null elements and every mutation, as the
+/// JDK's do. A set and a map iterate in no particular order, which the JDK
+/// leaves unspecified too; they are hashed rather than linked so an
+/// application that never calls them does not keep `LinkedHashMap`.
+final class ImmutableCollections {
+
+    private ImmutableCollections() {
+    }
+
+    /// A list of `elements`, which the caller hands over: nothing else may
+    /// hold the array.
+    static <E> List<E> list(Object[] elements) {
+        for (int i = 0; i < elements.length; i++) {
+            Objects.requireNonNull(elements[i]);
+        }
+        return new ImmutableList<E>(elements);
+    }
+
+    /// A set of `elements`. Two equal ones are an error when `strict`, as in
+    /// `Set.of`, and one element otherwise, as in `Set.copyOf`.
+    @SuppressWarnings("unchecked")
+    static <E> Set<E> set(Object[] elements, boolean strict) {
+        HashSet<E> all = new HashSet<E>();
+        for (int i = 0; i < elements.length; i++) {
+            if (!all.add((E) Objects.requireNonNull(elements[i])) && strict) {
+                throw new IllegalArgumentException("duplicate element: " + elements[i]);
+            }
+        }
+        return new ImmutableSet<E>(all);
+    }
+
+    /// A map of `keysAndValues`, alternating.
+    @SuppressWarnings("unchecked")
+    static <K, V> Map<K, V> map(Object[] keysAndValues) {
+        HashMap<K, V> all = new HashMap<K, V>();
+        for (int i = 0; i < keysAndValues.length; i += 2) {
+            K key = (K) Objects.requireNonNull(keysAndValues[i]);
+            V value = (V) Objects.requireNonNull(keysAndValues[i + 1]);
+            if (all.containsKey(key)) {
+                throw new IllegalArgumentException("duplicate key: " + key);
+            }
+            all.put(key, value);
+        }
+        return new ImmutableMap<K, V>(all);
+    }
+
+    /// A list of a copy of `elements`.
+    static <E> List<E> listCopy(Object[] elements) {
+        Object[] copy = new Object[elements.length];
+        System.arraycopy(elements, 0, copy, 0, elements.length);
+        return list(copy);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <E> List<E> listCopyOf(Collection<? extends E> collection) {
+        if (collection instanceof ImmutableList) {
+            return (List<E>) collection;
+        }
+        return list(collection.toArray());
+    }
+
+    @SuppressWarnings("unchecked")
+    static <E> Set<E> setCopyOf(Collection<? extends E> collection) {
+        if (collection instanceof ImmutableSet) {
+            return (Set<E>) collection;
+        }
+        return set(collection.toArray(), false);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V> Map<K, V> mapCopyOf(Map<? extends K, ? extends V> map) {
+        if (map instanceof ImmutableMap) {
+            return (Map<K, V>) map;
+        }
+        Object[] flat = new Object[map.size() * 2];
+        int at = 0;
+        for (Map.Entry<? extends K, ? extends V> e : map.entrySet()) {
+            flat[at++] = e.getKey();
+            flat[at++] = e.getValue();
+        }
+        return map(flat);
+    }
+
+    static <K, V> Map<K, V> mapOfEntries(Map.Entry<? extends K, ? extends V>[] entries) {
+        Object[] flat = new Object[entries.length * 2];
+        for (int i = 0; i < entries.length; i++) {
+            flat[i * 2] = entries[i].getKey();
+            flat[i * 2 + 1] = entries[i].getValue();
+        }
+        return map(flat);
+    }
+
+    private static UnsupportedOperationException immutable() {
+        return new UnsupportedOperationException();
+    }
+
+    static final class ImmutableEntry<K, V> implements Map.Entry<K, V> {
+
+        private final K key;
+        private final V value;
+
+        ImmutableEntry(K key, V value) {
+            this.key = Objects.requireNonNull(key);
+            this.value = Objects.requireNonNull(value);
+        }
+
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValue() {
+            return value;
+        }
+
+        @Override
+        public V setValue(V newValue) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+            return key.equals(other.getKey()) && value.equals(other.getValue());
+        }
+
+        @Override
+        public int hashCode() {
+            return key.hashCode() ^ value.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return key + "=" + value;
+        }
+    }
+
+    static final class ImmutableList<E> extends AbstractList<E> implements RandomAccess {
+
+        private final Object[] elements;
+
+        ImmutableList(Object[] elements) {
+            this.elements = elements;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public E get(int index) {
+            if (index < 0 || index >= elements.length) {
+                throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length "
+                        + elements.length);
+            }
+            return (E) elements[index];
+        }
+
+        @Override
+        public int size() {
+            return elements.length;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return indexOf(o) >= 0;
+        }
+
+        @Override
+        public int indexOf(Object o) {
+            Objects.requireNonNull(o);
+            for (int i = 0; i < elements.length; i++) {
+                if (o.equals(elements[i])) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        @Override
+        public int lastIndexOf(Object o) {
+            Objects.requireNonNull(o);
+            for (int i = elements.length - 1; i >= 0; i--) {
+                if (o.equals(elements[i])) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        @Override
+        public boolean add(E e) {
+            throw immutable();
+        }
+
+        @Override
+        public void add(int index, E e) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean addAll(int index, Collection<? extends E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public void clear() {
+            throw immutable();
+        }
+
+        @Override
+        public E remove(int index) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeIf(Predicate<? super E> filter) {
+            throw immutable();
+        }
+
+        @Override
+        public void replaceAll(UnaryOperator<E> operator) {
+            throw immutable();
+        }
+
+        @Override
+        public void sort(Comparator<? super E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public E set(int index, E e) {
+            throw immutable();
+        }
+    }
+
+    static final class ImmutableSet<E> extends AbstractSet<E> {
+
+        private final Set<E> elements;
+
+        ImmutableSet(Set<E> elements) {
+            this.elements = elements;
+        }
+
+        @Override
+        public Iterator<E> iterator() {
+            Iterator<E> it = elements.iterator();
+            return new Iterator<E>() {
+                @Override
+                public boolean hasNext() {
+                    return it.hasNext();
+                }
+
+                @Override
+                public E next() {
+                    return it.next();
+                }
+
+                @Override
+                public void remove() {
+                    throw immutable();
+                }
+            };
+        }
+
+        @Override
+        public int size() {
+            return elements.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return elements.contains(Objects.requireNonNull(o));
+        }
+
+        @Override
+        public boolean add(E e) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public void clear() {
+            throw immutable();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeIf(Predicate<? super E> filter) {
+            throw immutable();
+        }
+    }
+
+    static final class ImmutableMap<K, V> extends AbstractMap<K, V> {
+
+        private final Map<K, V> entries;
+        private final Set<Map.Entry<K, V>> entrySet;
+
+        ImmutableMap(HashMap<K, V> entries) {
+            this.entries = entries;
+            HashSet<Map.Entry<K, V>> all = new HashSet<Map.Entry<K, V>>();
+            for (Map.Entry<K, V> e : entries.entrySet()) {
+                all.add(new ImmutableEntry<K, V>(e.getKey(), e.getValue()));
+            }
+            this.entrySet = new ImmutableSet<Map.Entry<K, V>>(all);
+        }
+
+        @Override
+        public Set<Map.Entry<K, V>> entrySet() {
+            return entrySet;
+        }
+
+        @Override
+        public int size() {
+            return entries.size();
+        }
+
+        @Override
+        public V get(Object key) {
+            return entries.get(Objects.requireNonNull(key));
+        }
+
+        @Override
+        public boolean containsKey(Object key) {
+            return entries.containsKey(Objects.requireNonNull(key));
+        }
+
+        @Override
+        public boolean containsValue(Object value) {
+            return entries.containsValue(Objects.requireNonNull(value));
+        }
+
+        @Override
+        public V put(K key, V value) {
+            throw immutable();
+        }
+
+        @Override
+        public void putAll(Map<? extends K, ? extends V> map) {
+            throw immutable();
+        }
+
+        @Override
+        public V remove(Object key) {
+            throw immutable();
+        }
+
+        @Override
+        public void clear() {
+            throw immutable();
+        }
+
+        @Override
+        public V putIfAbsent(K key, V value) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean remove(Object key, Object value) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean replace(K key, V oldValue, V newValue) {
+            throw immutable();
+        }
+
+        @Override
+        public V replace(K key, V value) {
+            throw immutable();
+        }
+
+        @Override
+        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+            throw immutable();
+        }
+
+        @Override
+        public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+            throw immutable();
+        }
+
+        @Override
+        public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+            throw immutable();
+        }
+
+        @Override
+        public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+            throw immutable();
+        }
+
+        @Override
+        public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+            throw immutable();
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/IntSummaryStatistics.java b/Ports/CLDC11/src/java/util/IntSummaryStatistics.java
new file mode 100644
index 00000000000..377d6f95d71
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/IntSummaryStatistics.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.IntConsumer;
+
+/// The count,
+/// sum, minimum, maximum and average of the values it was given.
+public class IntSummaryStatistics implements IntConsumer {
+
+    private long count;
+    private long sum;
+    private int min = Integer.MAX_VALUE;
+    private int max = Integer.MIN_VALUE;
+
+    public IntSummaryStatistics() {
+        // Nothing seen yet.
+    }
+
+    @Override
+    public void accept(int value) {
+        count++;
+        sum += value;
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+
+    public void combine(IntSummaryStatistics other) {
+        count += other.count;
+        sum += other.sum;
+        min = Math.min(min, other.min);
+        max = Math.max(max, other.max);
+    }
+
+    public final long getCount() {
+        return count;
+    }
+
+    public final long getSum() {
+        return sum;
+    }
+
+    public final int getMin() {
+        return min;
+    }
+
+    public final int getMax() {
+        return max;
+    }
+
+    public final double getAverage() {
+        return count > 0 ? (double) getSum() / count : 0.0d;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Iterator.java b/Ports/CLDC11/src/java/util/Iterator.java
index 3726d017fbe..71f54878109 100644
--- a/Ports/CLDC11/src/java/util/Iterator.java
+++ b/Ports/CLDC11/src/java/util/Iterator.java
@@ -17,6 +17,8 @@
 
 package java.util;
 
+import java.util.function.Consumer;
+
 /// An `Iterator` is used to sequence over a collection of objects.
 /// Conceptually, an iterator is always positioned between two elements of a
 /// collection. A fresh iterator is always positioned in front of the first
@@ -56,17 +58,26 @@ public interface Iterator<E> {
     /// - #hasNext
     public E next();
 
-    /// Removes the last object returned by `next` from the collection.
-    /// This method can only be called once after `next` was called.
+    /// Removes the last element `next` answered from the collection being
+    /// iterated, which this iterator does not support unless it says otherwise.
     ///
     /// #### Throws
     ///
-    /// - `UnsupportedOperationException`: @throws UnsupportedOperationException
-    /// if removing is not supported by the collection being
-    /// iterated.
+    /// - `UnsupportedOperationException`: when removing is not supported
     ///
-    /// - `IllegalStateException`: @throws IllegalStateException
-    /// if `next` has not been called, or `remove` has
-    /// already been called after the last call to `next`.
-    public void remove();
+    /// - `IllegalStateException`: when `next` has not been called, or `remove`
+    ///   has already been called after the last call to `next`
+    default void remove() {
+        throw new UnsupportedOperationException("remove");
+    }
+
+    /// Hands each remaining element to `action`, in order.
+    default void forEachRemaining(Consumer<? super E> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        while (hasNext()) {
+            action.accept(next());
+        }
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/List.java b/Ports/CLDC11/src/java/util/List.java
index 9c6a02154aa..34ec3e47a0d 100644
--- a/Ports/CLDC11/src/java/util/List.java
+++ b/Ports/CLDC11/src/java/util/List.java
@@ -446,4 +446,107 @@ default void replaceAll(UnaryOperator<E> operator) {
     /// implementation comes from the platform's JDK at runtime.
     default void sort(Comparator<? super E> c) {
     }
+
+    /// Inserts `e` before the first element. Stubbed in the CLDC11
+    /// subset; the implementation comes from the platform at runtime.
+    default void addFirst(E e) {
+    }
+
+    /// Appends `e` after the last element. Stubbed in the CLDC11 subset.
+    default void addLast(E e) {
+    }
+
+    /// The first element. Stubbed in the CLDC11 subset.
+    default E getFirst() {
+        return null;
+    }
+
+    /// The last element. Stubbed in the CLDC11 subset.
+    default E getLast() {
+        return null;
+    }
+
+    /// Removes and answers the first element. Stubbed in the CLDC11 subset.
+    default E removeFirst() {
+        return null;
+    }
+
+    /// Removes and answers the last element. Stubbed in the CLDC11 subset.
+    default E removeLast() {
+        return null;
+    }
+
+    /// A view of this list in the opposite order. Stubbed in the CLDC11
+    /// subset.
+    default List<E> reversed() {
+        return null;
+    }
+
+    /// An unmodifiable list of no elements.
+    static <E> List<E> of() {
+        return ImmutableCollections.list(new Object[] {});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1) {
+        return ImmutableCollections.list(new Object[] {e1});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2) {
+        return ImmutableCollections.list(new Object[] {e1, e2});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9, e10});
+    }
+
+    /// An unmodifiable list of `elements`, none of which may be null.
+    @SafeVarargs
+    static <E> List<E> of(E... elements) {
+        return ImmutableCollections.listCopy(elements);
+    }
+
+    /// An unmodifiable list of the elements of `collection`, which may not hold
+    /// null; `collection` itself when it is already such a list.
+    static <E> List<E> copyOf(Collection<? extends E> collection) {
+        return ImmutableCollections.listCopyOf(collection);
+    }
+
 }
diff --git a/Ports/CLDC11/src/java/util/ListResourceBundle.java b/Ports/CLDC11/src/java/util/ListResourceBundle.java
new file mode 100644
index 00000000000..909ba5dbaa0
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/ListResourceBundle.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+
+/// A resource bundle whose content a subclass supplies as an array of key
+/// and value pairs.
+public abstract class ListResourceBundle extends ResourceBundle {
+
+    private Map<String, Object> lookup;
+
+    public ListResourceBundle() {
+        super();
+    }
+
+    /// The bundle's content: each element is a pair, the key (a `String`)
+    /// and its value.
+    protected abstract Object[][] getContents();
+
+    private Map<String, Object> lookup() {
+        if (lookup == null) {
+            Map<String, Object> built = new HashMap<String, Object>();
+            Object[][] contents = getContents();
+            for (int i = 0; i < contents.length; i++) {
+                Object key = contents[i][0];
+                Object value = contents[i][1];
+                if (!(key instanceof String) || value == null) {
+                    throw new NullPointerException();
+                }
+                built.put((String) key, value);
+            }
+            lookup = built;
+        }
+        return lookup;
+    }
+
+    public final Object handleGetObject(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        return lookup().get(key);
+    }
+
+    public Enumeration<String> getKeys() {
+        return new ResourceBundle.KeyEnumeration(keySet().iterator());
+    }
+
+    protected Set<String> handleKeySet() {
+        return lookup().keySet();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Locale.java b/Ports/CLDC11/src/java/util/Locale.java
index 82250dc9fce..e1a7fb5aaf5 100644
--- a/Ports/CLDC11/src/java/util/Locale.java
+++ b/Ports/CLDC11/src/java/util/Locale.java
@@ -22,13 +22,89 @@
  */
 package java.util;
 
+/// A language, a country and a variant, with the JDK's value semantics:
+/// two locales of the same codes are equal, hash alike and print alike
+/// (`en_US`). The codes are normalized as the JDK normalizes them -- the
+/// language to lower case, the country to upper case, with an ASCII fold, so
+/// a device set to Turkish cannot turn `IT` into a dotless `it`.
+///
+/// This runtime carries no locale data beyond the English names of the
+/// common languages and countries, so the `getDisplay*` methods answer in
+/// English whatever locale they are asked for, and fall back to the code.
+/// A script and extensions are not kept: `getScript` is always empty.
 public class Locale {
+    /// English.
+    public static final Locale ENGLISH = new Locale("en", "");
+    /// French.
+    public static final Locale FRENCH = new Locale("fr", "");
+    /// German.
+    public static final Locale GERMAN = new Locale("de", "");
+    /// Italian.
+    public static final Locale ITALIAN = new Locale("it", "");
+    /// Japanese.
+    public static final Locale JAPANESE = new Locale("ja", "");
+    /// Korean.
+    public static final Locale KOREAN = new Locale("ko", "");
+    /// Chinese.
+    public static final Locale CHINESE = new Locale("zh", "");
+    /// Chinese as written in China.
+    public static final Locale SIMPLIFIED_CHINESE = new Locale("zh", "CN");
+    /// Chinese as written in Taiwan.
+    public static final Locale TRADITIONAL_CHINESE = new Locale("zh", "TW");
+    /// French in France.
+    public static final Locale FRANCE = new Locale("fr", "FR");
+    /// German in Germany.
+    public static final Locale GERMANY = new Locale("de", "DE");
+    /// Italian in Italy.
+    public static final Locale ITALY = new Locale("it", "IT");
+    /// Japanese in Japan.
+    public static final Locale JAPAN = new Locale("ja", "JP");
+    /// Korean in Korea.
+    public static final Locale KOREA = new Locale("ko", "KR");
+    /// Chinese in China; the same locale as `SIMPLIFIED_CHINESE`.
+    public static final Locale CHINA = SIMPLIFIED_CHINESE;
+    /// Chinese in China; the same locale as `SIMPLIFIED_CHINESE`.
+    public static final Locale PRC = SIMPLIFIED_CHINESE;
+    /// Chinese in Taiwan; the same locale as `TRADITIONAL_CHINESE`.
+    public static final Locale TAIWAN = TRADITIONAL_CHINESE;
+    /// English in the United Kingdom.
+    public static final Locale UK = new Locale("en", "GB");
+    /// English in the United States.
+    public static final Locale US = new Locale("en", "US");
+    /// English in Canada.
+    public static final Locale CANADA = new Locale("en", "CA");
+    /// French in Canada.
+    public static final Locale CANADA_FRENCH = new Locale("fr", "CA");
+    /// The root locale: no language, country or variant.
+    public static final Locale ROOT = new Locale("", "");
+
     private static Locale defaultLocale;
     private String language;
     private String country;
-    public Locale(String language, String locale) {
-        this.language = language;
-        this.country = locale;
+    private String variant;
+
+    /// A locale of a language alone.
+    public Locale(String language) {
+        this(language, "", "");
+    }
+
+    /// A locale of a language and a country.
+    public Locale(String language, String country) {
+        this(language, country, "");
+    }
+
+    /// A locale of a language, a country and a variant.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: if any of them is null
+    public Locale(String language, String country, String variant) {
+        if (language == null || country == null || variant == null) {
+            throw new NullPointerException();
+        }
+        this.language = normalizeLanguage(language);
+        this.country = asciiUpper(country);
+        this.variant = variant;
     }
 
     Locale() {
@@ -45,6 +121,24 @@ public Locale(String language, String locale) {
         if (country == null) {
             country = "US";//getOSCountry();
         }
+        language = language == null ? "" : normalizeLanguage(language);
+        country = asciiUpper(country);
+        variant = "";
+    }
+
+    /// `new Locale(language)`.
+    public static Locale of(String language) {
+        return new Locale(language);
+    }
+
+    /// `new Locale(language, country)`.
+    public static Locale of(String language, String country) {
+        return new Locale(language, country);
+    }
+
+    /// `new Locale(language, country, variant)`.
+    public static Locale of(String language, String country, String variant) {
+        return new Locale(language, country, variant);
     }
 
     public static Locale getDefault() {
@@ -55,6 +149,9 @@ public static Locale getDefault() {
     }
 
     public static void setDefault(Locale l) {
+        if (l == null) {
+            throw new NullPointerException("Can't set default locale to NULL");
+        }
         defaultLocale = l;
     }
 
@@ -66,5 +163,377 @@ public String getCountry() {
         return country;
     }
 
+    /// The variant, or the empty string.
+    public String getVariant() {
+        return variant;
+    }
+
+    /// Always empty: this runtime does not keep a script.
+    public String getScript() {
+        return "";
+    }
+
+    /// Whether the locale carries extensions; never, here.
+    public boolean hasExtensions() {
+        return false;
+    }
+
+    /// The locale without extensions, which is the locale itself here.
+    public Locale stripExtensions() {
+        return this;
+    }
+
+    /// The locale an IETF BCP 47 language tag names: `fr`, `en-US`,
+    /// `zh-Hans-CN`. The first subtag is the language, a four letter subtag
+    /// after it a script (dropped), the next two letter or three digit subtag
+    /// the country and the subtags after it, five to eight characters or a
+    /// digit and three more, the variant. A single character subtag starts
+    /// the extensions, which are dropped. `und` and the empty tag are the
+    /// root locale.
+    public static Locale forLanguageTag(String languageTag) {
+        if (languageTag == null) {
+            throw new NullPointerException();
+        }
+        String language = "";
+        String country = "";
+        StringBuilder variant = null;
+        int n = languageTag.length();
+        int start = 0;
+        int index = 0;
+        for (int i = 0; i <= n; i++) {
+            if (i < n && languageTag.charAt(i) != '-' && languageTag.charAt(i) != '_') {
+                continue;
+            }
+            String part = languageTag.substring(start, i);
+            start = i + 1;
+            if (index == 0) {
+                if (!isLetters(part) || part.length() < 2 || part.length() > 8) {
+                    break;
+                }
+                language = "und".equals(asciiLower(part)) ? "" : part;
+            } else if (part.length() == 1 || part.length() == 0) {
+                // "x-lvariant-" carries a variant that is not well formed BCP 47,
+                // which is how toLanguageTag writes one; the JDK reads it back.
+                String rest = i < n ? languageTag.substring(i + 1) : "";
+                if (part.length() == 1 && (part.charAt(0) == 'x' || part.charAt(0) == 'X')
+                        && rest.length() > 9 && rest.regionMatches(true, 0, "lvariant", 0, 8)
+                        && (rest.charAt(8) == '-' || rest.charAt(8) == '_')) {
+                    String lvariant = rest.substring(9).replace('-', '_');
+                    if (variant == null) {
+                        variant = new StringBuilder(lvariant);
+                    } else {
+                        variant.append('_').append(lvariant);
+                    }
+                }
+                break;
+            } else if (index == 1 && part.length() == 4 && isLetters(part)) {
+                // a script
+                index++;
+                continue;
+            } else if (country.length() == 0 && variant == null
+                    && ((part.length() == 2 && isLetters(part)) || (part.length() == 3 && isDigits(part)))) {
+                country = part;
+            } else if (part.length() >= 5 && part.length() <= 8 && isAlphanumeric(part)
+                    || part.length() == 4 && part.charAt(0) >= '0' && part.charAt(0) <= '9' && isAlphanumeric(part)) {
+                if (variant == null) {
+                    variant = new StringBuilder(part);
+                } else {
+                    variant.append('_').append(part);
+                }
+            } else {
+                break;
+            }
+            index++;
+        }
+        return new Locale(language, country, variant == null ? "" : variant.toString());
+    }
+
+    /// The IETF BCP 47 tag of the locale: `en-US`, `fr`, or `und` for the
+    /// root.
+    public String toLanguageTag() {
+        StringBuilder out = new StringBuilder();
+        out.append(language.length() == 0 ? "und" : language);
+        if (country.length() > 0) {
+            out.append('-').append(country);
+        }
+        if (variant.length() > 0) {
+            String tagged = variant.replace('_', '-');
+            if (isWellFormedVariant(tagged)) {
+                out.append('-').append(tagged);
+            } else {
+                out.append("-x-lvariant-").append(tagged);
+            }
+        }
+        return out.toString();
+    }
+
+    private static boolean isWellFormedVariant(String tagged) {
+        int start = 0;
+        int n = tagged.length();
+        for (int i = 0; i <= n; i++) {
+            if (i < n && tagged.charAt(i) != '-') {
+                continue;
+            }
+            String part = tagged.substring(start, i);
+            start = i + 1;
+            boolean ok = part.length() >= 5 && part.length() <= 8 && isAlphanumeric(part)
+                    || part.length() == 4 && part.charAt(0) >= '0' && part.charAt(0) <= '9' && isAlphanumeric(part);
+            if (!ok) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Whether `obj` is a locale of the same language, country and variant.
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Locale)) {
+            return false;
+        }
+        Locale other = (Locale) obj;
+        return language.equals(other.language) && country.equals(other.country) && variant.equals(other.variant);
+    }
+
+    /// A hash of the language, country and variant.
+    public int hashCode() {
+        return (language.hashCode() * 31 + country.hashCode()) * 31 + variant.hashCode();
+    }
+
+    /// `en_US`, `fr`, `en_US_POSIX`, or the empty string for the root locale.
+    public String toString() {
+        boolean l = language.length() > 0;
+        boolean c = country.length() > 0;
+        boolean v = variant.length() > 0;
+        if (!c && !(l && v)) {
+            return language;
+        }
+        StringBuilder out = new StringBuilder(language);
+        out.append('_');
+        if (c) {
+            out.append(country);
+        }
+        if (v && (l || c)) {
+            out.append('_').append(variant);
+        }
+        return out.toString();
+    }
+
+    /// The English name of the language, or its code when this runtime has
+    /// no name for it.
+    public String getDisplayLanguage() {
+        return displayLanguage(language);
+    }
+
+    /// As `getDisplayLanguage()`: names are in English only.
+    public String getDisplayLanguage(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayLanguage();
+    }
+
+    /// The English name of the country, or its code when this runtime has no
+    /// name for it.
+    public String getDisplayCountry() {
+        return displayCountry(country);
+    }
+
+    /// As `getDisplayCountry()`: names are in English only.
+    public String getDisplayCountry(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayCountry();
+    }
 
+    /// The variant as it is.
+    public String getDisplayVariant() {
+        return variant;
+    }
+
+    /// As `getDisplayVariant()`.
+    public String getDisplayVariant(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayVariant();
+    }
+
+    /// Always empty: this runtime does not keep a script.
+    public String getDisplayScript() {
+        return "";
+    }
+
+    /// Always empty: this runtime does not keep a script.
+    public String getDisplayScript(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return "";
+    }
+
+    /// `English (United States)`: the language, then the country and the
+    /// variant in parentheses.
+    public String getDisplayName() {
+        String lang = getDisplayLanguage();
+        StringBuilder qualifiers = new StringBuilder();
+        if (country.length() > 0) {
+            qualifiers.append(getDisplayCountry());
+        }
+        if (variant.length() > 0) {
+            if (qualifiers.length() > 0) {
+                qualifiers.append(", ");
+            }
+            qualifiers.append(variant);
+        }
+        if (lang.length() == 0) {
+            return qualifiers.toString();
+        }
+        if (qualifiers.length() == 0) {
+            return lang;
+        }
+        return lang + " (" + qualifiers + ")";
+    }
+
+    /// As `getDisplayName()`: names are in English only.
+    public String getDisplayName(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayName();
+    }
+
+    /// The default locale and the locales this class has constants for.
+    public static Locale[] getAvailableLocales() {
+        return new Locale[] {
+            getDefault(), ENGLISH, FRENCH, GERMAN, ITALIAN, JAPANESE, KOREAN, CHINESE,
+            SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE, FRANCE, GERMANY, ITALY, JAPAN, KOREA, UK, US, CANADA,
+            CANADA_FRENCH
+        };
+    }
+
+    /// The English names, in a holder so that the tables are built the
+    /// first time a display name is asked for, not by every use of a
+    /// `Locale`.
+    private static final class Names {
+        private Names() {
+        }
+
+        private static final String[] LANGUAGE_NAMES = {
+            "ar", "Arabic", "bg", "Bulgarian", "ca", "Catalan", "cs", "Czech", "da", "Danish",
+            "de", "German", "el", "Greek", "en", "English", "es", "Spanish", "et", "Estonian",
+            "fa", "Persian", "fi", "Finnish", "fr", "French", "he", "Hebrew", "hi", "Hindi",
+            "hr", "Croatian", "hu", "Hungarian", "id", "Indonesian", "is", "Icelandic", "it", "Italian",
+            "ja", "Japanese", "ko", "Korean", "lt", "Lithuanian", "lv", "Latvian", "ms", "Malay",
+            "nl", "Dutch", "no", "Norwegian", "pl", "Polish", "pt", "Portuguese", "ro", "Romanian",
+            "ru", "Russian", "sk", "Slovak", "sl", "Slovenian", "sr", "Serbian", "sv", "Swedish",
+            "th", "Thai", "tr", "Turkish", "uk", "Ukrainian", "vi", "Vietnamese", "zh", "Chinese"
+        };
+
+        private static final String[] COUNTRY_NAMES = {
+            "AR", "Argentina", "AT", "Austria", "AU", "Australia", "BE", "Belgium", "BR", "Brazil",
+            "CA", "Canada", "CH", "Switzerland", "CN", "China", "CZ", "Czechia", "DE", "Germany",
+            "DK", "Denmark", "ES", "Spain", "FI", "Finland", "FR", "France", "GB", "United Kingdom",
+            "GR", "Greece", "HK", "Hong Kong SAR China", "IE", "Ireland", "IL", "Israel", "IN", "India",
+            "IT", "Italy", "JP", "Japan", "KR", "South Korea", "MX", "Mexico", "NL", "Netherlands",
+            "NO", "Norway", "NZ", "New Zealand", "PL", "Poland", "PT", "Portugal", "RU", "Russia",
+            "SE", "Sweden", "TR", "Turkey", "TW", "Taiwan", "UA", "Ukraine", "US", "United States",
+            "ZA", "South Africa"
+        };
+    }
+
+    private static String displayLanguage(String code) {
+        return lookup(Names.LANGUAGE_NAMES, code);
+    }
+
+    private static String displayCountry(String code) {
+        return lookup(Names.COUNTRY_NAMES, code);
+    }
+
+    private static String lookup(String[] table, String code) {
+        for (int i = 0; i < table.length; i += 2) {
+            if (table[i].equals(code)) {
+                return table[i + 1];
+            }
+        }
+        return code;
+    }
+
+    private static String normalizeLanguage(String language) {
+        String lower = asciiLower(language);
+        // The JDK answers the current ISO 639 code for the three it renamed.
+        if ("iw".equals(lower)) {
+            return "he";
+        }
+        if ("ji".equals(lower)) {
+            return "yi";
+        }
+        if ("in".equals(lower)) {
+            return "id";
+        }
+        return lower;
+    }
+
+    private static boolean isLetters(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
+                return false;
+            }
+        }
+        return s.length() > 0;
+    }
+
+    private static boolean isDigits(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c < '0' || c > '9') {
+                return false;
+            }
+        }
+        return s.length() > 0;
+    }
+
+    private static boolean isAlphanumeric(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))) {
+                return false;
+            }
+        }
+        return s.length() > 0;
+    }
+
+    // Language and country codes are ASCII, and String.toLowerCase folds by
+    // the device's locale: under Turkish "IT" would not become "it".
+    private static String asciiLower(String s) {
+        StringBuilder out = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                if (out == null) {
+                    out = new StringBuilder(s);
+                }
+                out.setCharAt(i, (char) (c + ('a' - 'A')));
+            }
+        }
+        return out == null ? s : out.toString();
+    }
+
+    private static String asciiUpper(String s) {
+        StringBuilder out = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'a' && c <= 'z') {
+                if (out == null) {
+                    out = new StringBuilder(s);
+                }
+                out.setCharAt(i, (char) (c - ('a' - 'A')));
+            }
+        }
+        return out == null ? s : out.toString();
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/LongSummaryStatistics.java b/Ports/CLDC11/src/java/util/LongSummaryStatistics.java
new file mode 100644
index 00000000000..ff3db599dc2
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/LongSummaryStatistics.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.LongConsumer;
+
+/// The count,
+/// sum, minimum, maximum and average of the values it was given.
+public class LongSummaryStatistics implements LongConsumer {
+
+    private long count;
+    private long sum;
+    private long min = Long.MAX_VALUE;
+    private long max = Long.MIN_VALUE;
+
+    public LongSummaryStatistics() {
+        // Nothing seen yet.
+    }
+
+    @Override
+    public void accept(long value) {
+        count++;
+        sum += value;
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+
+    public void accept(int value) {
+        accept((long) value);
+    }
+
+    public void combine(LongSummaryStatistics other) {
+        count += other.count;
+        sum += other.sum;
+        min = Math.min(min, other.min);
+        max = Math.max(max, other.max);
+    }
+
+    public final long getCount() {
+        return count;
+    }
+
+    public final long getSum() {
+        return sum;
+    }
+
+    public final long getMin() {
+        return min;
+    }
+
+    public final long getMax() {
+        return max;
+    }
+
+    public final double getAverage() {
+        return count > 0 ? (double) getSum() / count : 0.0d;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Map.java b/Ports/CLDC11/src/java/util/Map.java
index 3343f2f3594..2c9159e3300 100644
--- a/Ports/CLDC11/src/java/util/Map.java
+++ b/Ports/CLDC11/src/java/util/Map.java
@@ -89,7 +89,53 @@ public static interface Entry<K,V> {
         ///
         /// object the replaced value of this entry.
         public V setValue(V object);
-    };
+
+        /// Orders entries by the natural order of their keys.
+        static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K, V>> comparingByKey() {
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return a.getKey().compareTo(b.getKey());
+                }
+            };
+        }
+
+        /// Orders entries by the natural order of their values.
+        static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K, V>> comparingByValue() {
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return a.getValue().compareTo(b.getValue());
+                }
+            };
+        }
+
+        /// Orders entries by their keys, as `comparator` orders them.
+        static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(final Comparator<? super K> comparator) {
+            if (comparator == null) {
+                throw new NullPointerException();
+            }
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return comparator.compare(a.getKey(), b.getKey());
+                }
+            };
+        }
+
+        /// Orders entries by their values, as `comparator` orders them.
+        static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(final Comparator<? super V> comparator) {
+            if (comparator == null) {
+                throw new NullPointerException();
+            }
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return comparator.compare(a.getValue(), b.getValue());
+                }
+            };
+        }
+    }
 
     /// Removes all elements from this `Map`, leaving it empty.
     ///
@@ -373,4 +419,88 @@ default V merge(K key, V value,
             BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
         return null;
     }
+
+    /// An unmodifiable map of no mappings.
+    static <K, V> Map<K, V> of() {
+        return ImmutableCollections.map(new Object[0]);
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1) {
+        return ImmutableCollections.map(new Object[] {k1, v1});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9, k10, v10});
+    }
+
+    /// An unmodifiable map of the keys and values of `entries`, none of which
+    /// may be null, and no key given twice.
+    @SafeVarargs
+    static <K, V> Map<K, V> ofEntries(Map.Entry<? extends K, ? extends V>... entries) {
+        return ImmutableCollections.mapOfEntries(entries);
+    }
+
+    /// An unmodifiable entry of `key` and `value`, neither of which may be null.
+    static <K, V> Map.Entry<K, V> entry(K key, V value) {
+        return new ImmutableCollections.ImmutableEntry<K, V>(key, value);
+    }
+
+    /// An unmodifiable map of the mappings of `map`, which may not hold null;
+    /// `map` itself when it is already such a map.
+    static <K, V> Map<K, V> copyOf(Map<? extends K, ? extends V> map) {
+        return ImmutableCollections.mapCopyOf(map);
+    }
+
 }
diff --git a/Ports/CLDC11/src/java/util/MissingResourceException.java b/Ports/CLDC11/src/java/util/MissingResourceException.java
new file mode 100644
index 00000000000..3ee1805c22c
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/MissingResourceException.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// A resource bundle, or a key in one, could not be found.
+public class MissingResourceException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String className;
+    private final String key;
+
+    public MissingResourceException(String s, String className, String key) {
+        super(s);
+        this.className = className;
+        this.key = key;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    public String getKey() {
+        return key;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Objects.java b/Ports/CLDC11/src/java/util/Objects.java
index 3b692434b52..da20c332680 100644
--- a/Ports/CLDC11/src/java/util/Objects.java
+++ b/Ports/CLDC11/src/java/util/Objects.java
@@ -31,6 +31,9 @@
 ///
 /// This class consists of static utility methods for operating on objects. These utilities include null-safe or null-tolerant methods for computing the hash code of an object, returning a string for an object, and comparing two objects.
 public final class Objects {
+    private Objects() {
+    }
+
     /// Returns true if the arguments are equal to each other and false otherwise. Consequently, if both arguments are null, true is returned and if exactly one argument is null, false is returned. Otherwise, equality is determined by using the equals method of the first argument.
     ///
     /// #### Parameters
@@ -128,5 +131,74 @@ public static boolean deepEquals(Object a, Object b) {
     public static int hash(Object... values) {
         return Arrays.hashCode(values);
     }
+
+    /// Whether `obj` is null.
+    public static boolean isNull(Object obj) {
+        return false;
+    }
+
+    /// `obj`, or a NullPointerException whose message `messageSupplier`
+    /// makes, only when it is needed.
+    public static <T> T requireNonNull(T obj, java.util.function.Supplier<String> messageSupplier) {
+        return null;
+    }
+
+    /// `obj`, or `defaultObj` when `obj` is null.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: if both are null
+    public static <T> T requireNonNullElse(T obj, T defaultObj) {
+        return null;
+    }
+
+    /// `obj`, or what `supplier` gives when `obj` is null.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: if `obj` is null and the supplier is null or gives null
+    public static <T> T requireNonNullElseGet(T obj, java.util.function.Supplier<? extends T> supplier) {
+        return null;
+    }
+
+    /// `index`, if it lies in `[0, length)`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IndexOutOfBoundsException`: otherwise
+    public static int checkIndex(int index, int length) {
+        return 0;
+    }
+
+    /// `index`, if it lies in `[0, length)`.
+    public static long checkIndex(long index, long length) {
+        return 0;
+    }
+
+    /// `fromIndex`, if `[fromIndex, toIndex)` lies in `[0, length)`.
+    public static int checkFromToIndex(int fromIndex, int toIndex, int length) {
+        return 0;
+    }
+
+    /// `fromIndex`, if `[fromIndex, toIndex)` lies in `[0, length)`.
+    public static long checkFromToIndex(long fromIndex, long toIndex, long length) {
+        return 0;
+    }
+
+    /// `fromIndex`, if `[fromIndex, fromIndex + size)` lies in `[0, length)`.
+    public static int checkFromIndexSize(int fromIndex, int size, int length) {
+        return 0;
+    }
+
+    /// `fromIndex`, if `[fromIndex, fromIndex + size)` lies in `[0, length)`.
+    public static long checkFromIndexSize(long fromIndex, long size, long length) {
+        return 0;
+    }
+
+    /// What `Object.toString` would answer for `o`, even when its class
+    /// overrides it.
+    public static String toIdentityString(Object o) {
+        return null;
+    }
 }
 
diff --git a/Ports/CLDC11/src/java/util/Optional.java b/Ports/CLDC11/src/java/util/Optional.java
new file mode 100644
index 00000000000..6d733990170
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/Optional.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/// A container that may or may not hold a non-null value (the Java 8 API). The
+/// stream terminals that may find nothing answer one.
+public final class Optional<T> {
+    private static final Optional<?> EMPTY = new Optional<Object>(null);
+
+    private final T value;
+
+    private Optional(T value) {
+        this.value = value;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> Optional<T> empty() {
+        return (Optional<T>) EMPTY;
+    }
+
+    public static <T> Optional<T> of(T value) {
+        if (value == null) {
+            throw new NullPointerException();
+        }
+        return new Optional<T>(value);
+    }
+
+    public static <T> Optional<T> ofNullable(T value) {
+        return value == null ? Optional.<T>empty() : new Optional<T>(value);
+    }
+
+    public T get() {
+        if (value == null) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return value != null;
+    }
+
+    public boolean isEmpty() {
+        return value == null;
+    }
+
+    public void ifPresent(Consumer<? super T> action) {
+        if (value != null) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
+        if (value != null) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public Optional<T> filter(Predicate<? super T> predicate) {
+        if (predicate == null) {
+            throw new NullPointerException();
+        }
+        return value == null || predicate.test(value) ? this : Optional.<T>empty();
+    }
+
+    public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
+        if (mapper == null) {
+            throw new NullPointerException();
+        }
+        return value == null ? Optional.<U>empty() : Optional.<U>ofNullable(mapper.apply(value));
+    }
+
+    @SuppressWarnings("unchecked")
+    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
+        if (mapper == null) {
+            throw new NullPointerException();
+        }
+        if (value == null) {
+            return Optional.<U>empty();
+        }
+        Optional<U> r = (Optional<U>) mapper.apply(value);
+        if (r == null) {
+            throw new NullPointerException();
+        }
+        return r;
+    }
+
+    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
+        // Checked first, as the JDK does: a null supplier is an error whether or not it is needed.
+        if (supplier == null) {
+            throw new NullPointerException();
+        }
+        if (value != null) {
+            return this;
+        }
+        @SuppressWarnings("unchecked")
+        Optional<T> r = (Optional<T>) supplier.get();
+        if (r == null) {
+            throw new NullPointerException();
+        }
+        return r;
+    }
+
+    /// A stream of the value, or an empty stream when there is none.
+    public java.util.stream.Stream<T> stream() {
+        return value == null ? java.util.stream.Stream.<T>empty() : java.util.stream.Stream.of(value);
+    }
+
+    public T orElse(T other) {
+        return value != null ? value : other;
+    }
+
+    public T orElseGet(Supplier<? extends T> supplier) {
+        return value != null ? value : supplier.get();
+    }
+
+    public T orElseThrow() {
+        return get();
+    }
+
+    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (value == null) {
+            throw exceptionSupplier.get();
+        }
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Optional)) {
+            return false;
+        }
+        Object other = ((Optional<?>) obj).value;
+        return value == null ? other == null : value.equals(other);
+    }
+
+    @Override
+    public int hashCode() {
+        return value == null ? 0 : value.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return value == null ? "Optional.empty" : "Optional[" + value + "]";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/OptionalDouble.java b/Ports/CLDC11/src/java/util/OptionalDouble.java
new file mode 100644
index 00000000000..d69bfce021c
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/OptionalDouble.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.DoubleConsumer;
+import java.util.stream.DoubleStream;
+import java.util.function.DoubleSupplier;
+
+import java.util.function.Supplier;
+
+/// A container that
+/// holds one `double` or nothing.
+public final class OptionalDouble {
+
+    private static final OptionalDouble EMPTY = new OptionalDouble(false, 0d);
+
+    private final boolean present;
+    private final double value;
+
+    private OptionalDouble(boolean present, double value) {
+        this.present = present;
+        this.value = value;
+    }
+
+    public static OptionalDouble empty() {
+        return EMPTY;
+    }
+
+    public static OptionalDouble of(double value) {
+        return new OptionalDouble(true, value);
+    }
+
+    public double getAsDouble() {
+        if (!present) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return present;
+    }
+
+    public boolean isEmpty() {
+        return !present;
+    }
+
+    public void ifPresent(DoubleConsumer action) {
+        if (present) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(DoubleConsumer action, Runnable emptyAction) {
+        if (present) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public DoubleStream stream() {
+        return present ? DoubleStream.of(value) : DoubleStream.empty();
+    }
+
+    public double orElse(double other) {
+        return present ? value : other;
+    }
+
+    public double orElseGet(DoubleSupplier supplier) {
+        return present ? value : supplier.getAsDouble();
+    }
+
+    public double orElseThrow() {
+        return getAsDouble();
+    }
+
+    public <X extends Throwable> double orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (present) {
+            return value;
+        }
+        throw exceptionSupplier.get();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OptionalDouble)) {
+            return false;
+        }
+        OptionalDouble other = (OptionalDouble) obj;
+        if (present != other.present) {
+            return false;
+        }
+        return !present || Double.compare(value, other.value) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return present ? Double.valueOf(value).hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return present ? "OptionalDouble[" + value + "]" : "OptionalDouble.empty";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/OptionalInt.java b/Ports/CLDC11/src/java/util/OptionalInt.java
new file mode 100644
index 00000000000..910427fc02f
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/OptionalInt.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.IntConsumer;
+import java.util.stream.IntStream;
+import java.util.function.IntSupplier;
+
+import java.util.function.Supplier;
+
+/// A container that
+/// holds one `int` or nothing.
+public final class OptionalInt {
+
+    private static final OptionalInt EMPTY = new OptionalInt(false, 0);
+
+    private final boolean present;
+    private final int value;
+
+    private OptionalInt(boolean present, int value) {
+        this.present = present;
+        this.value = value;
+    }
+
+    public static OptionalInt empty() {
+        return EMPTY;
+    }
+
+    public static OptionalInt of(int value) {
+        return new OptionalInt(true, value);
+    }
+
+    public int getAsInt() {
+        if (!present) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return present;
+    }
+
+    public boolean isEmpty() {
+        return !present;
+    }
+
+    public void ifPresent(IntConsumer action) {
+        if (present) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(IntConsumer action, Runnable emptyAction) {
+        if (present) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public IntStream stream() {
+        return present ? IntStream.of(value) : IntStream.empty();
+    }
+
+    public int orElse(int other) {
+        return present ? value : other;
+    }
+
+    public int orElseGet(IntSupplier supplier) {
+        return present ? value : supplier.getAsInt();
+    }
+
+    public int orElseThrow() {
+        return getAsInt();
+    }
+
+    public <X extends Throwable> int orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (present) {
+            return value;
+        }
+        throw exceptionSupplier.get();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OptionalInt)) {
+            return false;
+        }
+        OptionalInt other = (OptionalInt) obj;
+        if (present != other.present) {
+            return false;
+        }
+        return !present || Integer.compare(value, other.value) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return present ? Integer.valueOf(value).hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return present ? "OptionalInt[" + value + "]" : "OptionalInt.empty";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/OptionalLong.java b/Ports/CLDC11/src/java/util/OptionalLong.java
new file mode 100644
index 00000000000..ab313afcf5a
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/OptionalLong.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.LongConsumer;
+import java.util.stream.LongStream;
+import java.util.function.LongSupplier;
+
+import java.util.function.Supplier;
+
+/// A container that
+/// holds one `long` or nothing.
+public final class OptionalLong {
+
+    private static final OptionalLong EMPTY = new OptionalLong(false, 0L);
+
+    private final boolean present;
+    private final long value;
+
+    private OptionalLong(boolean present, long value) {
+        this.present = present;
+        this.value = value;
+    }
+
+    public static OptionalLong empty() {
+        return EMPTY;
+    }
+
+    public static OptionalLong of(long value) {
+        return new OptionalLong(true, value);
+    }
+
+    public long getAsLong() {
+        if (!present) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return present;
+    }
+
+    public boolean isEmpty() {
+        return !present;
+    }
+
+    public void ifPresent(LongConsumer action) {
+        if (present) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(LongConsumer action, Runnable emptyAction) {
+        if (present) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public LongStream stream() {
+        return present ? LongStream.of(value) : LongStream.empty();
+    }
+
+    public long orElse(long other) {
+        return present ? value : other;
+    }
+
+    public long orElseGet(LongSupplier supplier) {
+        return present ? value : supplier.getAsLong();
+    }
+
+    public long orElseThrow() {
+        return getAsLong();
+    }
+
+    public <X extends Throwable> long orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (present) {
+            return value;
+        }
+        throw exceptionSupplier.get();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OptionalLong)) {
+            return false;
+        }
+        OptionalLong other = (OptionalLong) obj;
+        if (present != other.present) {
+            return false;
+        }
+        return !present || Long.compare(value, other.value) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return present ? Long.valueOf(value).hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return present ? "OptionalLong[" + value + "]" : "OptionalLong.empty";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/PrimitiveIterator.java b/Ports/CLDC11/src/java/util/PrimitiveIterator.java
new file mode 100644
index 00000000000..ed941198567
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/PrimitiveIterator.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.DoubleConsumer;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+
+import java.util.function.Consumer;
+
+/// An iterator
+/// that can hand out its elements unboxed.
+public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
+
+    void forEachRemaining(T_CONS action);
+
+    /// An iterator of `int` values.
+    interface OfInt extends PrimitiveIterator<Integer, IntConsumer> {
+
+        int nextInt();
+
+        @Override
+        default void forEachRemaining(IntConsumer action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(nextInt());
+            }
+        }
+
+        @Override
+        default Integer next() {
+            return Integer.valueOf(nextInt());
+        }
+
+        default void forEachRemaining(Consumer<? super Integer> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(Integer.valueOf(nextInt()));
+            }
+        }
+    }
+
+    /// An iterator of `long` values.
+    interface OfLong extends PrimitiveIterator<Long, LongConsumer> {
+
+        long nextLong();
+
+        @Override
+        default void forEachRemaining(LongConsumer action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(nextLong());
+            }
+        }
+
+        @Override
+        default Long next() {
+            return Long.valueOf(nextLong());
+        }
+
+        default void forEachRemaining(Consumer<? super Long> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(Long.valueOf(nextLong()));
+            }
+        }
+    }
+
+    /// An iterator of `double` values.
+    interface OfDouble extends PrimitiveIterator<Double, DoubleConsumer> {
+
+        double nextDouble();
+
+        @Override
+        default void forEachRemaining(DoubleConsumer action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(nextDouble());
+            }
+        }
+
+        @Override
+        default Double next() {
+            return Double.valueOf(nextDouble());
+        }
+
+        default void forEachRemaining(Consumer<? super Double> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(Double.valueOf(nextDouble()));
+            }
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Properties.java b/Ports/CLDC11/src/java/util/Properties.java
new file mode 100644
index 00000000000..f4e9b3ccceb
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/Properties.java
@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+
+/// String keys and values, a second table of defaults behind them, and the
+/// `.properties` text format.
+///
+/// The format is read as the JDK reads it: `#` and `!` comments, `=`, `:` or
+/// white space between key and value, a trailing backslash continuing a line
+/// (the next line's indentation dropped), and the escapes `\t`, `\n`, `\r`,
+/// `\f` and backslash-u followed by four hexadecimal digits; a backslash
+/// before any other character stands for that character. A stream is
+/// ISO 8859-1; a reader is whatever its characters are. [#store] writes text
+/// that [#load] reads back to the same table, escaping what the format
+/// requires and, on a stream, every character outside printable ASCII.
+///
+/// The XML form (`loadFromXML`, `storeToXML`) and `list` are not provided.
+public class Properties extends Hashtable<Object, Object> {
+
+    private static final long serialVersionUID = 4112578634029874840L;
+
+    private static final String HEX = "0123456789ABCDEF";
+
+    /// The table consulted for a key this one does not have, or null.
+    protected Properties defaults;
+
+    private static final int NONE = 0, SLASH = 1, UNICODE = 2, CONTINUE = 3,
+            KEY_DONE = 4, IGNORE = 5;
+
+    /// An empty table with no defaults.
+    public Properties() {
+    }
+
+    /// An empty table with `defaults` behind it.
+    public Properties(Properties defaults) {
+        this.defaults = defaults;
+    }
+
+    /// The value for `name` here, else in the defaults, else null. A value
+    /// that is not a `String` counts as absent, as in the JDK.
+    public String getProperty(String name) {
+        Object result = get(name);
+        if (result instanceof String) {
+            return (String) result;
+        }
+        return defaults == null ? null : defaults.getProperty(name);
+    }
+
+    /// The value for `name` as [#getProperty(String)] finds it, or
+    /// `defaultValue` when there is none.
+    public String getProperty(String name, String defaultValue) {
+        String property = getProperty(name);
+        return property == null ? defaultValue : property;
+    }
+
+    /// Maps `name` to `value` in this table, answering the value it replaced.
+    public Object setProperty(String name, String value) {
+        return put(name, value);
+    }
+
+    /// Reads ISO 8859-1 `.properties` text, adding to what is here. The
+    /// stream is left open.
+    public synchronized void load(InputStream in) throws IOException {
+        if (in == null) {
+            throw new NullPointerException("in == null");
+        }
+        load(new Latin1Reader(in));
+    }
+
+    /// Reads `.properties` text, adding to what is here. The reader is left
+    /// open.
+    @SuppressWarnings("fallthrough")
+    public synchronized void load(Reader in) throws IOException {
+        if (in == null) {
+            throw new NullPointerException("in == null");
+        }
+        int mode = NONE, unicode = 0, count = 0;
+        char nextChar, buf[] = new char[40];
+        int offset = 0, keyLength = -1, intVal;
+        boolean firstChar = true;
+
+        Reader br = in;
+
+        while (true) {
+            intVal = br.read();
+            if (intVal == -1) {
+                break;
+            }
+            nextChar = (char) intVal;
+
+            if (offset == buf.length) {
+                char[] newBuf = new char[buf.length * 2];
+                System.arraycopy(buf, 0, newBuf, 0, offset);
+                buf = newBuf;
+            }
+            if (mode == UNICODE) {
+                int digit = Character.digit(nextChar, 16);
+                if (digit >= 0) {
+                    unicode = (unicode << 4) + digit;
+                    if (++count < 4) {
+                        continue;
+                    }
+                } else if (count <= 4) {
+                    throw new IllegalArgumentException("Malformed \\uxxxx encoding.");
+                }
+                mode = NONE;
+                buf[offset++] = (char) unicode;
+                if (nextChar != '\n') {
+                    continue;
+                }
+            }
+            if (mode == SLASH) {
+                mode = NONE;
+                switch (nextChar) {
+                case '\r':
+                    mode = CONTINUE; // Look for a following \n
+                    continue;
+                case '\n':
+                    mode = IGNORE; // Ignore whitespace on the next line
+                    continue;
+                case 'f':
+                    nextChar = '\f';
+                    break;
+                case 'n':
+                    nextChar = '\n';
+                    break;
+                case 'r':
+                    nextChar = '\r';
+                    break;
+                case 't':
+                    nextChar = '\t';
+                    break;
+                case 'u':
+                    mode = UNICODE;
+                    unicode = count = 0;
+                    continue;
+                default:
+                    // Any other escaped character is that character, `\b`
+                    // included: the JDK has no backspace escape.
+                    break;
+                }
+            } else {
+                switch (nextChar) {
+                case '#':
+                case '!':
+                    if (firstChar) {
+                        while (true) {
+                            intVal = br.read();
+                            if (intVal == -1) {
+                                break;
+                            }
+                            nextChar = (char) intVal;
+                            if (nextChar == '\r' || nextChar == '\n') {
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                case '\n':
+                    if (mode == CONTINUE) { // Part of a \r\n sequence
+                        mode = IGNORE; // Ignore whitespace on the next line
+                        continue;
+                    }
+                    // fall into the next case
+                case '\r':
+                    mode = NONE;
+                    firstChar = true;
+                    if (offset > 0 || (offset == 0 && keyLength == 0)) {
+                        if (keyLength == -1) {
+                            keyLength = offset;
+                        }
+                        String temp = new String(buf, 0, offset);
+                        put(temp.substring(0, keyLength), temp.substring(keyLength));
+                    }
+                    keyLength = -1;
+                    offset = 0;
+                    continue;
+                case '\\':
+                    if (mode == KEY_DONE) {
+                        keyLength = offset;
+                    }
+                    mode = SLASH;
+                    continue;
+                case ':':
+                case '=':
+                    if (keyLength == -1) { // if parsing the key
+                        mode = NONE;
+                        keyLength = offset;
+                        continue;
+                    }
+                    break;
+                default:
+                    break;
+                }
+                if (nextChar == ' ' || nextChar == '\n' || nextChar == '\r' || nextChar == '\t'
+                        || nextChar == '\f') {
+                    if (mode == CONTINUE) {
+                        mode = IGNORE;
+                    }
+                    // if key length == 0 or value length == 0
+                    if (offset == 0 || offset == keyLength || mode == IGNORE) {
+                        continue;
+                    }
+                    if (keyLength == -1) { // if parsing the key
+                        mode = KEY_DONE;
+                        continue;
+                    }
+                }
+                if (mode == IGNORE || mode == CONTINUE) {
+                    mode = NONE;
+                }
+            }
+            firstChar = false;
+            if (mode == KEY_DONE) {
+                keyLength = offset;
+                mode = NONE;
+            }
+            buf[offset++] = nextChar;
+        }
+        if (mode == UNICODE && count <= 4) {
+            throw new IllegalArgumentException("Malformed \\uxxxx encoding.");
+        }
+        if (keyLength == -1 && offset > 0) {
+            keyLength = offset;
+        }
+        if (keyLength >= 0) {
+            String temp = new String(buf, 0, offset);
+            put(temp.substring(0, keyLength), temp.substring(keyLength));
+        }
+    }
+
+    /// Every key of this table and of its defaults.
+    public Enumeration<?> propertyNames() {
+        Hashtable<Object, Object> all = new Hashtable<Object, Object>();
+        collect(all, false);
+        return all.keys();
+    }
+
+    /// The keys, of this table and of its defaults, whose key and value are
+    /// both strings.
+    public Set<String> stringPropertyNames() {
+        Hashtable<Object, Object> all = new Hashtable<Object, Object>();
+        collect(all, true);
+        Set<String> names = new HashSet<String>();
+        for (Object key : all.keySet()) {
+            if (key instanceof String) {
+                names.add((String) key);
+            }
+        }
+        return Collections.unmodifiableSet(names);
+    }
+
+    /// Defaults first, so that this table's own entries replace them.
+    private void collect(Hashtable<Object, Object> into, boolean stringsOnly) {
+        if (defaults != null) {
+            defaults.collect(into, stringsOnly);
+        }
+        for (Map.Entry<Object, Object> e : entrySet()) {
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (stringsOnly && !(key instanceof String && value instanceof String)) {
+                continue;
+            }
+            into.put(key, value);
+        }
+    }
+
+    /// Writes this table as [#store(OutputStream, String)] does, ignoring any
+    /// `IOException`.
+    ///
+    /// #### Deprecated
+    ///
+    /// An error writing is lost; use [#store(OutputStream, String)].
+    @Deprecated
+    public void save(OutputStream out, String comments) {
+        try {
+            store(out, comments);
+        } catch (IOException e) {
+            // As documented: save reports nothing.
+        }
+    }
+
+    /// Writes this table (not its defaults) as ISO 8859-1 `.properties`
+    /// text: the comment lines, a line with the current date, then one
+    /// `key=value` line per entry. The stream is flushed and left open.
+    ///
+    /// #### Throws
+    ///
+    /// - `ClassCastException`: if a key or value is not a `String`
+    public void store(OutputStream out, String comments) throws IOException {
+        if (out == null) {
+            throw new NullPointerException();
+        }
+        String text = render(comments, true);
+        byte[] bytes = new byte[text.length()];
+        for (int i = 0; i < bytes.length; i++) {
+            // Everything outside ASCII was escaped by render.
+            bytes[i] = (byte) text.charAt(i);
+        }
+        out.write(bytes);
+        out.flush();
+    }
+
+    /// Writes this table as `.properties` text, leaving characters outside
+    /// ASCII as they are. The writer is flushed and left open.
+    ///
+    /// #### Throws
+    ///
+    /// - `ClassCastException`: if a key or value is not a `String`
+    public void store(Writer writer, String comments) throws IOException {
+        if (writer == null) {
+            throw new NullPointerException();
+        }
+        writer.write(render(comments, false));
+        writer.flush();
+    }
+
+    private synchronized String render(String comments, boolean escapeUnicode) {
+        StringBuilder out = new StringBuilder();
+        if (comments != null) {
+            writeComments(out, comments, escapeUnicode);
+        }
+        out.append('#').append(new Date().toString()).append('\n');
+        for (Map.Entry<Object, Object> e : entrySet()) {
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (!(key instanceof String) || !(value instanceof String)) {
+                // The JDK fails here with a ClassCastException, which a
+                // device cannot be relied on to raise from a cast.
+                throw new ClassCastException("Properties holds a key or value that is not a String");
+            }
+            escape(out, (String) key, true, escapeUnicode);
+            out.append('=');
+            escape(out, (String) value, false, escapeUnicode);
+            out.append('\n');
+        }
+        return out.toString();
+    }
+
+    /// Every line of `comments` as a comment line: a line that does not
+    /// start one already gets `#`.
+    private static void writeComments(StringBuilder out, String comments, boolean escapeUnicode) {
+        out.append('#');
+        int n = comments.length();
+        for (int i = 0; i < n; i++) {
+            char c = comments.charAt(i);
+            if (c == '\n' || c == '\r') {
+                if (c == '\r' && i + 1 < n && comments.charAt(i + 1) == '\n') {
+                    i++;
+                }
+                out.append('\n');
+                if (i + 1 >= n || (comments.charAt(i + 1) != '#' && comments.charAt(i + 1) != '!')) {
+                    out.append('#');
+                }
+            } else if (escapeUnicode && c > 0xff) {
+                unicode(out, c);
+            } else {
+                out.append(c);
+            }
+        }
+        out.append('\n');
+    }
+
+    private static void unicode(StringBuilder out, char c) {
+        out.append('\\').append('u');
+        out.append(HEX.charAt((c >> 12) & 0xf)).append(HEX.charAt((c >> 8) & 0xf));
+        out.append(HEX.charAt((c >> 4) & 0xf)).append(HEX.charAt(c & 0xf));
+    }
+
+    private static void escape(StringBuilder out, String s, boolean key, boolean escapeUnicode) {
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            switch (c) {
+                case ' ':
+                    // Only a leading space of a value would be dropped on
+                    // reading; in a key every space ends the key.
+                    if (key || i == 0) {
+                        out.append('\\');
+                    }
+                    out.append(' ');
+                    break;
+                case '\t':
+                    out.append("\\t");
+                    break;
+                case '\n':
+                    out.append("\\n");
+                    break;
+                case '\r':
+                    out.append("\\r");
+                    break;
+                case '\f':
+                    out.append("\\f");
+                    break;
+                case '=':
+                case ':':
+                case '#':
+                case '!':
+                case '\\':
+                    out.append('\\').append(c);
+                    break;
+                default:
+                    if (escapeUnicode && (c < 0x20 || c > 0x7e)) {
+                        unicode(out, c);
+                    } else {
+                        out.append(c);
+                    }
+            }
+        }
+    }
+
+    /// A stream's bytes as ISO 8859-1 characters, one for one.
+    private static final class Latin1Reader extends Reader {
+        private final InputStream in;
+
+        Latin1Reader(InputStream in) {
+            this.in = in;
+        }
+
+        @Override
+        public int read() throws IOException {
+            return in.read();
+        }
+
+        @Override
+        public int read(char[] cbuf, int off, int len) throws IOException {
+            int n = 0;
+            while (n < len) {
+                int b = in.read();
+                if (b < 0) {
+                    return n == 0 ? -1 : n;
+                }
+                cbuf[off + n++] = (char) b;
+            }
+            return n;
+        }
+
+        @Override
+        public void close() throws IOException {
+            // The caller's stream stays open.
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/PropertyResourceBundle.java b/Ports/CLDC11/src/java/util/PropertyResourceBundle.java
new file mode 100644
index 00000000000..d0931528d35
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/PropertyResourceBundle.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+
+/// A resource bundle read from a `.properties` file.
+///
+/// The parser implements the whole `java.util.Properties` text format: `#` and `!`
+/// comment lines, `=`, `:` or whitespace between key and value, a logical line
+/// continued by a trailing backslash, and the escapes -- tab, newline, form
+/// feed, carriage return, backslash-u followed by four hex digits, and a
+/// backslash before any other character standing for that character.
+///
+/// A stream is decoded as ISO-8859-1, one byte to one character, which is
+/// what the JDK did for as long as `.properties` files have carried
+/// backslash-u escapes for everything else. Pass a `Reader` to choose another
+/// encoding.
+public class PropertyResourceBundle extends ResourceBundle {
+
+    private final Map<String, Object> lookup = new HashMap<String, Object>();
+
+    public PropertyResourceBundle(InputStream stream) throws IOException {
+        StringBuilder text = new StringBuilder();
+        byte[] buffer = new byte[4096];
+        int n = stream.read(buffer);
+        while (n >= 0) {
+            for (int i = 0; i < n; i++) {
+                text.append((char) (buffer[i] & 0xff));
+            }
+            n = stream.read(buffer);
+        }
+        parse(text.toString(), lookup);
+    }
+
+    public PropertyResourceBundle(Reader reader) throws IOException {
+        StringBuilder text = new StringBuilder();
+        char[] buffer = new char[4096];
+        int n = reader.read(buffer, 0, buffer.length);
+        while (n >= 0) {
+            text.append(buffer, 0, n);
+            n = reader.read(buffer, 0, buffer.length);
+        }
+        parse(text.toString(), lookup);
+    }
+
+    public Object handleGetObject(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        return lookup.get(key);
+    }
+
+    public Enumeration<String> getKeys() {
+        return new ResourceBundle.KeyEnumeration(keySet().iterator());
+    }
+
+    protected Set<String> handleKeySet() {
+        return lookup.keySet();
+    }
+
+    private static boolean isBlank(char c) {
+        return c == ' ' || c == '\t' || c == '\f';
+    }
+
+    private static boolean isLineEnd(char c) {
+        return c == '\n' || c == '\r';
+    }
+
+    /// Reads `.properties` text into `out`, a later definition of a key
+    /// replacing an earlier one.
+    static void parse(String text, Map<String, ? super String> out) {
+        int n = text.length();
+        int i = 0;
+        StringBuilder line = new StringBuilder();
+        while (i < n) {
+            // Blank lines and the indentation of a logical line carry nothing.
+            while (i < n && (isBlank(text.charAt(i)) || isLineEnd(text.charAt(i)))) {
+                i++;
+            }
+            if (i >= n) {
+                break;
+            }
+            char c = text.charAt(i);
+            if (c == '#' || c == '!') {
+                // A comment runs to the end of its natural line and cannot be
+                // continued, whatever it ends with.
+                while (i < n && !isLineEnd(text.charAt(i))) {
+                    i++;
+                }
+                continue;
+            }
+            line.setLength(0);
+            boolean escaped = false;
+            // A line that is nothing but a continuation is no entry, unless
+            // the input ends in the middle of it: then the JDK defines the
+            // empty key, and so does this.
+            boolean cutShort = false;
+            while (i < n) {
+                c = text.charAt(i);
+                if (isLineEnd(c)) {
+                    if (!escaped) {
+                        break;
+                    }
+                    // An odd run of backslashes before the terminator joins
+                    // the next natural line, minus its indentation.
+                    line.setLength(line.length() - 1);
+                    i++;
+                    cutShort = i >= n;
+                    if (c == '\r' && i < n && text.charAt(i) == '\n') {
+                        i++;
+                    }
+                    while (i < n && isBlank(text.charAt(i))) {
+                        i++;
+                    }
+                    escaped = false;
+                    continue;
+                }
+                line.append(c);
+                escaped = c == '\\' && !escaped;
+                i++;
+            }
+            if (escaped) {
+                // A lone backslash at the end of the input escapes nothing.
+                line.setLength(line.length() - 1);
+                cutShort = true;
+            }
+            if (line.length() > 0 || cutShort) {
+                store(line, out);
+            }
+        }
+    }
+
+    private static void store(StringBuilder line, Map<String, ? super String> out) {
+        int len = line.length();
+        int keyLen = 0;
+        int valueStart = len;
+        boolean hasSeparator = false;
+        boolean escaped = false;
+        while (keyLen < len) {
+            char c = line.charAt(keyLen);
+            if ((c == '=' || c == ':') && !escaped) {
+                valueStart = keyLen + 1;
+                hasSeparator = true;
+                break;
+            }
+            if (isBlank(c) && !escaped) {
+                valueStart = keyLen + 1;
+                break;
+            }
+            escaped = c == '\\' && !escaped;
+            keyLen++;
+        }
+        // Whitespace may surround the one separator character.
+        while (valueStart < len) {
+            char c = line.charAt(valueStart);
+            if (!isBlank(c)) {
+                if (!hasSeparator && (c == '=' || c == ':')) {
+                    hasSeparator = true;
+                } else {
+                    break;
+                }
+            }
+            valueStart++;
+        }
+        out.put(unescape(line, 0, keyLen), unescape(line, valueStart, len));
+    }
+
+    private static int hexDigit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        throw new IllegalArgumentException("Malformed unicode escape in properties text");
+    }
+
+    private static String unescape(StringBuilder in, int from, int to) {
+        StringBuilder sb = new StringBuilder(to - from);
+        int i = from;
+        while (i < to) {
+            char c = in.charAt(i++);
+            if (c != '\\' || i >= to) {
+                if (c != '\\') {
+                    sb.append(c);
+                }
+                continue;
+            }
+            c = in.charAt(i++);
+            if (c == 'u') {
+                if (i + 4 > to) {
+                    throw new IllegalArgumentException("Malformed unicode escape in properties text");
+                }
+                int value = 0;
+                for (int k = 0; k < 4; k++) {
+                    value = (value << 4) | hexDigit(in.charAt(i++));
+                }
+                sb.append((char) value);
+            } else if (c == 't') {
+                sb.append('\t');
+            } else if (c == 'r') {
+                sb.append('\r');
+            } else if (c == 'n') {
+                sb.append('\n');
+            } else if (c == 'f') {
+                sb.append('\f');
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Random.java b/Ports/CLDC11/src/java/util/Random.java
index 5ba7aeb1de1..ee7b07a1251 100644
--- a/Ports/CLDC11/src/java/util/Random.java
+++ b/Ports/CLDC11/src/java/util/Random.java
@@ -94,9 +94,17 @@ public boolean nextBoolean() {
         return false;
     }
     
+    /// Fills `bytes` with random bytes. Four bytes come from each `nextInt()`,
+    /// low byte first, which is the algorithm the JDK documents: a seeded
+    /// generator must hand out the same bytes as on the JVM, and one `next(8)`
+    /// per byte does not.
     public void nextBytes(byte[] bytes) {
-        for (int i = 0; i < bytes.length; ++i) {
-            bytes[i] = (byte) next(8);
+        int len = bytes.length;
+        for (int i = 0; i < len;) {
+            int rnd = nextInt();
+            for (int n = Math.min(len - i, 4); n-- > 0; rnd >>= 8) {
+                bytes[i++] = (byte) rnd;
+            }
         }
     }
 
diff --git a/Ports/CLDC11/src/java/util/ResourceBundle.java b/Ports/CLDC11/src/java/util/ResourceBundle.java
new file mode 100644
index 00000000000..81cb4bf6549
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/ResourceBundle.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/// Locale specific strings and objects, looked up by key, with a chain of
+/// less specific bundles behind each one.
+///
+/// `getBundle("com.example.Messages", locale)` looks for three bundles, most
+/// specific first -- `Messages_<language>_<COUNTRY>`, `Messages_<language>`
+/// and `Messages` -- and chains the ones that exist, so a key missing from the
+/// first is answered by the next. When nothing more specific than the base
+/// bundle exists for the requested locale, the default locale is tried the
+/// same way before the base bundle is settled for. Finding none at all throws
+/// `MissingResourceException`.
+///
+/// Each of the three is first created as a class of that name extending
+/// `ResourceBundle`, then read as the resource
+/// `com/example/Messages_<suffix>.properties`. An application built by
+/// Codename One carries a registry, generated with it, that creates the bundle
+/// classes it has with `new`; no class is then created from its name, which a
+/// device cannot be relied on to do. Without a registry the class is looked up
+/// by name. The resource is read through the platform
+/// (`com.codename1.impl.JdkHost`), which knows where the build put it.
+///
+/// Bundles are cached for the life of the application, or until
+/// `clearCache()`. `ResourceBundle.Control`, and the lookups that take one,
+/// are not provided.
+public abstract class ResourceBundle {
+
+    /// Every bundle already loaded, by base name and suffix; MISSING for one known not to exist.
+    private static final Map<String, Object> CACHE = new HashMap<String, Object>();
+
+    private static final Object MISSING = new Object();
+
+    /// The bundle consulted for a key this one does not have, or null.
+    protected ResourceBundle parent;
+
+    private Locale locale;
+    private String baseName;
+
+    public ResourceBundle() {
+    }
+
+    public static final ResourceBundle getBundle(String baseName) {
+        return getBundle(baseName, Locale.getDefault());
+    }
+
+    /// Looks the bundle up as getBundle(String, Locale) does. The class loader
+    /// is not used: an application has one.
+    public static ResourceBundle getBundle(String baseName, Locale locale, ClassLoader loader) {
+        return getBundle(baseName, locale);
+    }
+
+    public static final ResourceBundle getBundle(String baseName, Locale locale) {
+        if (baseName == null || locale == null) {
+            throw new NullPointerException();
+        }
+        String name = baseName.replace('/', '.');
+        String language = nonNull(locale.getLanguage());
+        String country = nonNull(locale.getCountry());
+        ResourceBundle found;
+        synchronized (CACHE) {
+            found = findChain(name, language, country);
+            // A bundle found by the chain has had its locale set; one that
+            // has none is the base bundle, like one of the empty language.
+            Locale foundLocale = found == null ? null : found.locale;
+            if (foundLocale == null || nonNull(foundLocale.getLanguage()).length() == 0) {
+                // Nothing specific to the requested locale: the default
+                // locale's bundle is preferred to the base bundle.
+                Locale fallback = Locale.getDefault();
+                String fallbackLanguage = nonNull(fallback.getLanguage());
+                String fallbackCountry = nonNull(fallback.getCountry());
+                boolean requestedRoot = language.length() == 0;
+                boolean sameLocale = fallbackLanguage.equals(language) && fallbackCountry.equals(country);
+                if (!sameLocale && !(requestedRoot && found != null)) {
+                    ResourceBundle viaDefault = findChain(name, fallbackLanguage, fallbackCountry);
+                    if (viaDefault != null) {
+                        found = viaDefault;
+                    }
+                }
+            }
+        }
+        if (found == null) {
+            String localeName = localeSuffix(language, country);
+            throw new MissingResourceException(
+                    "Can't find bundle for base name " + baseName + ", locale "
+                            + (localeName.length() == 0 ? "" : localeName.substring(1)),
+                    baseName + localeName, "");
+        }
+        return found;
+    }
+
+    public static final void clearCache() {
+        synchronized (CACHE) {
+            CACHE.clear();
+        }
+    }
+
+    private static String nonNull(String s) {
+        return s == null ? "" : s;
+    }
+
+    private static String localeSuffix(String language, String country) {
+        if (language.length() == 0) {
+            return "";
+        }
+        return country.length() == 0 ? "_" + language : "_" + language + "_" + country;
+    }
+
+    /// The most specific bundle that exists for the locale, with the less
+    /// specific ones chained behind it, or null when not even the base bundle
+    /// exists.
+    private static ResourceBundle findChain(String baseName, String language, String country) {
+        ResourceBundle result = load(baseName, "", "", "", null);
+        if (language.length() > 0) {
+            ResourceBundle forLanguage = load(baseName, "_" + language, language, "", result);
+            if (forLanguage != null) {
+                result = forLanguage;
+            }
+            if (country.length() > 0) {
+                ResourceBundle forCountry =
+                        load(baseName, "_" + language + "_" + country, language, country, result);
+                if (forCountry != null) {
+                    result = forCountry;
+                }
+            }
+        }
+        return result;
+    }
+
+    private static ResourceBundle load(String baseName, String suffix, String language, String country,
+                                       ResourceBundle parent) {
+        String key = baseName + '\n' + suffix;
+        Object cached = CACHE.get(key);
+        if (cached instanceof ResourceBundle) {
+            return (ResourceBundle) cached;
+        }
+        if (cached != null) {
+            return null;
+        }
+        ResourceBundle bundle = create(baseName, suffix);
+        if (bundle == null) {
+            CACHE.put(key, MISSING);
+            return null;
+        }
+        if (bundle.parent == null) {
+            // The less specific bundle of a name is the same whichever locale
+            // led here, so the chain is fixed the first time it is built.
+            bundle.parent = parent;
+        }
+        bundle.locale = new Locale(language, country);
+        bundle.baseName = baseName;
+        CACHE.put(key, bundle);
+        return bundle;
+    }
+
+    private static ResourceBundle create(String baseName, String suffix) {
+        String name = baseName + suffix;
+        JdkHost host = JdkHost.get();
+        Object made = host.newInstance(name);
+        if (made instanceof ResourceBundle) {
+            return (ResourceBundle) made;
+        }
+        if (JdkHost.getRegistry() == null) {
+            // No registry was generated with the application, so nothing says
+            // which bundle classes it has: ask for the class by name.
+            ResourceBundle byName = createByName(name);
+            if (byName != null) {
+                return byName;
+            }
+        }
+        InputStream in = host.resource(baseName.replace('.', '/') + suffix + ".properties");
+        if (in == null) {
+            return null;
+        }
+        try {
+            return new PropertyResourceBundle(in);
+        } catch (IOException e) {
+            // A bundle that cannot be read is a bundle that is not there.
+            return null;
+        } finally {
+            try {
+                in.close();
+            } catch (IOException e) {
+                // Nothing to do about a failed close of a stream already read.
+            }
+        }
+    }
+
+    private static ResourceBundle createByName(String name) {
+        try {
+            Object instance = Class.forName(name).newInstance();
+            if (instance instanceof ResourceBundle) {
+                return (ResourceBundle) instance;
+            }
+        } catch (ClassNotFoundException e) {
+            // No class of this name: the bundle is a properties file, or absent.
+        } catch (InstantiationException e) {
+            // Not a class this lookup can create; the file may still be there.
+        } catch (IllegalAccessException e) {
+            // As above.
+        }
+        return null;
+    }
+
+    public final String getString(String key) {
+        Object value = getObject(key);
+        if (value instanceof String) {
+            return (String) value;
+        }
+        throw new ClassCastException("Resource " + key + " is not a String");
+    }
+
+    public final String[] getStringArray(String key) {
+        Object value = getObject(key);
+        if (value instanceof String[]) {
+            return (String[]) value;
+        }
+        throw new ClassCastException("Resource " + key + " is not a String array");
+    }
+
+    public final Object getObject(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        for (ResourceBundle b = this; b != null; b = b.parent) {
+            Object value = b.handleGetObject(key);
+            if (value != null) {
+                return value;
+            }
+        }
+        throw new MissingResourceException(
+                "Can't find resource for bundle " + getClass().getName() + ", key " + key,
+                getClass().getName(), key);
+    }
+
+    /// The locale this bundle was found for, which may be less specific than
+    /// the one asked for. The base bundle's has an empty language.
+    public Locale getLocale() {
+        return locale;
+    }
+
+    public String getBaseBundleName() {
+        return baseName;
+    }
+
+    protected void setParent(ResourceBundle parent) {
+        this.parent = parent;
+    }
+
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        for (ResourceBundle b = this; b != null; b = b.parent) {
+            if (b.handleKeySet().contains(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Every key of this bundle and of the bundles behind it.
+    public Set<String> keySet() {
+        Set<String> keys = new HashSet<String>();
+        for (ResourceBundle b = this; b != null; b = b.parent) {
+            keys.addAll(b.handleKeySet());
+        }
+        return keys;
+    }
+
+    /// The keys this bundle itself defines. The default derives them from
+    /// getKeys(); a subclass that has them at hand should override it.
+    protected Set<String> handleKeySet() {
+        Set<String> keys = new HashSet<String>();
+        Enumeration<String> all = getKeys();
+        while (all.hasMoreElements()) {
+            String key = all.nextElement();
+            if (handleGetObject(key) != null) {
+                keys.add(key);
+            }
+        }
+        return keys;
+    }
+
+    protected abstract Object handleGetObject(String key);
+
+    public abstract Enumeration<String> getKeys();
+
+    /// An Enumeration over an iterator, for the getKeys implementations.
+    static final class KeyEnumeration implements Enumeration<String> {
+        private final Iterator<String> it;
+
+        KeyEnumeration(Iterator<String> it) {
+            this.it = it;
+        }
+
+        public boolean hasMoreElements() {
+            return it.hasNext();
+        }
+
+        public String nextElement() {
+            return it.next();
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/ServiceConfigurationError.java b/Ports/CLDC11/src/java/util/ServiceConfigurationError.java
new file mode 100644
index 00000000000..2e0e66b2c3f
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/ServiceConfigurationError.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// What a [ServiceLoader] throws for a provider that cannot be had. The
+/// build leaves such a provider out with a warning, so an iteration never
+/// throws it here; [ServiceLoader.Provider#get()] does, for a provider whose
+/// class creates no instance of the service.
+public class ServiceConfigurationError extends Error {
+
+    private static final long serialVersionUID = 1L;
+
+    public ServiceConfigurationError(String msg) {
+        super(msg);
+    }
+
+    public ServiceConfigurationError(String msg, Throwable cause) {
+        super(msg);
+        initCause(cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/ServiceLoader.java b/Ports/CLDC11/src/java/util/ServiceLoader.java
new file mode 100644
index 00000000000..fb28c624e5c
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/ServiceLoader.java
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+/// The providers of a service, as the `META-INF/services` files of the
+/// application and of the libraries bundled with it list them.
+///
+/// #### Where the providers come from
+///
+/// A device discovers nothing at run time and creates no class from its
+/// name. The build reads every `META-INF/services/<service>` file the
+/// application ships and generates a registry with the application that
+/// names the providers of each service, in class path order, and creates each
+/// of them with `new` (`com.codename1.impl.JdkHost.Registry`). So the set of
+/// providers is fixed when the application is built. A listed class that the
+/// application does not ship, that is abstract or that has no public
+/// constructor without parameters is left out by the build with a warning;
+/// the JDK throws `ServiceConfigurationError` for such a provider when the
+/// iteration reaches it, and here it is simply not there.
+///
+/// Where no registry was generated -- a program translated without Codename
+/// One, a test -- the services file is read through the platform
+/// (`JdkHost.resource`), as the JDK reads it, and the classes are created
+/// from their names.
+///
+/// #### What is the same as the JDK
+///
+/// Providers are created lazily, one at a time as an iteration reaches them,
+/// and once per loader: a second `iterator()` answers the instances the first
+/// one created and goes on from where it stopped. [#reload()] forgets them.
+/// [#stream()] creates nothing until [Provider#get()] is called, which
+/// answers a new instance on every call.
+///
+/// #### What is not there
+///
+/// The class loader a loader is asked for selects nothing: an application
+/// has one. Module layers, and providers that are a static `provider()`
+/// method of a named module, are not provided.
+public final class ServiceLoader<S> implements Iterable<S> {
+
+    private final Class<S> service;
+
+    /// The provider class names of this service, or null until an iteration asks.
+    private List<String> entries;
+
+    /// The instances created so far, in order.
+    private final List<S> instances = new ArrayList<S>();
+
+    /// The index in [#entries] of the next provider to create.
+    private int next;
+
+    /// Counts the reloads, so that an iterator taken before one can tell.
+    private int generation;
+
+    /// Whether this is the loader of the installed providers, which has none.
+    private final boolean installed;
+
+    private ServiceLoader(Class<S> service, boolean installed) {
+        if (service == null) {
+            throw new NullPointerException("Service interface cannot be null");
+        }
+        this.service = service;
+        this.installed = installed;
+    }
+
+    /// One provider of a service, not yet created: what [#stream()] answers.
+    public interface Provider<S> extends Supplier<S> {
+        /// The provider's class.
+        Class<? extends S> type();
+
+        /// A new instance of the provider.
+        S get();
+    }
+
+    /// A loader of the providers of `service`. Nothing is looked up or
+    /// created until it is iterated.
+    public static <S> ServiceLoader<S> load(Class<S> service) {
+        return new ServiceLoader<S>(service, false);
+    }
+
+    /// As [#load(Class)]: an application has one class loader, so `loader`,
+    /// which may be null as in the JDK, selects nothing.
+    public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader) {
+        return new ServiceLoader<S>(service, false);
+    }
+
+    /// As [#load(Class)], for a layer that is not null. Nothing here hands
+    /// out a module layer -- [Module#getLayer()] answers null -- so code
+    /// reaches this only with the null the JDK refuses as well.
+    public static <S> ServiceLoader<S> load(ModuleLayer layer, Class<S> service) {
+        if (layer == null) {
+            throw new NullPointerException();
+        }
+        return new ServiceLoader<S>(service, false);
+    }
+
+    /// The providers installed in the platform: on a desktop, the ones the
+    /// platform class loader sees. An application's own providers are not
+    /// among those, and a device installs none, so the loader is empty.
+    public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
+        return new ServiceLoader<S>(service, true);
+    }
+
+    private List<String> entries() {
+        if (entries == null) {
+            entries = installed ? new ArrayList<String>() : lookup(service.getName());
+        }
+        return entries;
+    }
+
+    private static List<String> lookup(String name) {
+        List<String> out = new ArrayList<String>();
+        JdkHost host = JdkHost.get();
+        if (JdkHost.getRegistry() != null) {
+            // The build registered every provider the application has.
+            String[] registered = host.providers(name);
+            for (int i = 0; i < registered.length; i++) {
+                out.add(registered[i]);
+            }
+            return out;
+        }
+        String text = read(host.resource("META-INF/services/" + name));
+        if (text != null) {
+            providerNames(text, out);
+        }
+        return out;
+    }
+
+    /// The provider class names a services file lists, in order: each line
+    /// up to its first `#`, trimmed, when anything is left, and a name that
+    /// appears twice once. A line that is not a class name is left out; the
+    /// JDK refuses the whole file for one.
+    private static void providerNames(String text, List<String> out) {
+        int n = text.length();
+        int start = 0;
+        while (start <= n) {
+            int end = start;
+            while (end < n && text.charAt(end) != '\n' && text.charAt(end) != '\r') {
+                end++;
+            }
+            String line = text.substring(start, end);
+            int hash = line.indexOf('#');
+            if (hash >= 0) {
+                line = line.substring(0, hash);
+            }
+            line = line.trim();
+            if (line.length() > 0 && isClassName(line) && !out.contains(line)) {
+                out.add(line);
+            }
+            start = end + 1;
+        }
+    }
+
+    private static boolean isClassName(String name) {
+        int n = name.length();
+        for (int i = 0; i < n; i++) {
+            char c = name.charAt(i);
+            boolean letter = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c >= 0x80;
+            boolean digit = c >= '0' && c <= '9';
+            if (i == 0 ? !letter : !(letter || digit || c == '.')) {
+                return false;
+            }
+        }
+        return n > 0;
+    }
+
+    private static String read(InputStream in) {
+        if (in == null) {
+            return null;
+        }
+        try {
+            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+            byte[] buffer = new byte[1024];
+            for (int n = in.read(buffer); n >= 0; n = in.read(buffer)) {
+                bytes.write(buffer, 0, n);
+            }
+            return new String(bytes.toByteArray(), "UTF-8");
+        } catch (IOException e) {
+            // A file that cannot be read lists nothing.
+            return null;
+        } finally {
+            try {
+                in.close();
+            } catch (IOException e) {
+                // Nothing to do about a failed close of a stream already read.
+            }
+        }
+    }
+
+    /// The class of the provider `className`, or null when there is none.
+    private static Class<?> typeOf(String className) {
+        if (JdkHost.getRegistry() != null) {
+            return JdkHost.get().type(className);
+        }
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    /// A new instance of the provider `className`, or null when none can be made.
+    private static Object instantiate(String className) {
+        if (JdkHost.getRegistry() != null) {
+            return JdkHost.get().newInstance(className);
+        }
+        try {
+            return Class.forName(className).newInstance();
+        } catch (ClassNotFoundException e) {
+            return null;
+        } catch (InstantiationException e) {
+            return null;
+        } catch (IllegalAccessException e) {
+            return null;
+        }
+    }
+
+    /// The instance of `className` as this service's type, or null when it
+    /// could not be created or is not one. Tested rather than cast: a cast
+    /// that fails does not throw on every device.
+    @SuppressWarnings("unchecked")
+    private S create(String className) {
+        Object made = instantiate(className);
+        return service.isInstance(made) ? (S) made : null;
+    }
+
+    /// Whether a provider is left to create. Skips what cannot be one -- a
+    /// class that is not there, or is not of the service's type -- without
+    /// creating anything: `hasNext()` creates no provider in the JDK either.
+    private boolean more() {
+        List<String> all = entries();
+        while (next < all.size()) {
+            Class<?> type = typeOf(all.get(next));
+            if (type != null && service.isAssignableFrom(type)) {
+                return true;
+            }
+            next++;
+        }
+        return false;
+    }
+
+    /// The providers, each created when `next()` reaches it. The instances
+    /// an earlier iteration created come first, without being created again.
+    public Iterator<S> iterator() {
+        return new ProviderIterator<S>(this);
+    }
+
+    /// The iterator [#iterator()] answers. A named class: the class library
+    /// is translated without lambdas, and an anonymous one reads no better.
+    private static final class ProviderIterator<S> implements Iterator<S> {
+        private final ServiceLoader<S> loader;
+        private final int born;
+        private int index;
+
+        ProviderIterator(ServiceLoader<S> loader) {
+            this.loader = loader;
+            this.born = loader.generation;
+        }
+
+        /// After a reload this iterator's place means nothing: the instances
+        /// it walked are gone and the providers are counted from the start
+        /// again. Going on would create a provider it has already handed
+        /// out, so it refuses, as the JDK's does.
+        private void check() {
+            if (born != loader.generation) {
+                throw new ConcurrentModificationException();
+            }
+        }
+
+        public boolean hasNext() {
+            check();
+            return index < loader.instances.size() || loader.more();
+        }
+
+        public S next() {
+            check();
+            if (index < loader.instances.size()) {
+                return loader.instances.get(index++);
+            }
+            while (loader.more()) {
+                S made = loader.create(loader.entries().get(loader.next++));
+                if (made != null) {
+                    loader.instances.add(made);
+                    index = loader.instances.size();
+                    return made;
+                }
+            }
+            throw new NoSuchElementException();
+        }
+
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public void forEach(Consumer<? super S> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        Iterator<S> it = iterator();
+        while (it.hasNext()) {
+            action.accept(it.next());
+        }
+    }
+
+    /// The first provider, created if it has not been, or an empty optional
+    /// when the service has none.
+    public Optional<S> findFirst() {
+        Iterator<S> it = iterator();
+        return it.hasNext() ? Optional.<S>of(it.next()) : Optional.<S>empty();
+    }
+
+    /// The providers, none of them created: [Provider#get()] creates one,
+    /// anew on every call.
+    public Stream<Provider<S>> stream() {
+        List<Provider<S>> out = new ArrayList<Provider<S>>();
+        List<String> all = entries();
+        for (int i = 0; i < all.size(); i++) {
+            String className = all.get(i);
+            Class<?> type = typeOf(className);
+            if (type != null && service.isAssignableFrom(type)) {
+                out.add(new Lazy<S>(this, className, type));
+            }
+        }
+        return out.stream();
+    }
+
+    private static final class Lazy<S> implements Provider<S> {
+        private final ServiceLoader<S> loader;
+        private final String className;
+        private final Class<?> type;
+
+        Lazy(ServiceLoader<S> loader, String className, Class<?> type) {
+            this.loader = loader;
+            this.className = className;
+            this.type = type;
+        }
+
+        @SuppressWarnings("unchecked")
+        public Class<? extends S> type() {
+            return (Class<? extends S>) type;
+        }
+
+        public S get() {
+            S made = loader.create(className);
+            if (made == null) {
+                throw new ServiceConfigurationError(loader.service.getName() + ": Provider " + type.getName()
+                        + " could not be instantiated");
+            }
+            return made;
+        }
+    }
+
+    /// Forgets the providers created so far, so that the next iteration
+    /// creates them again.
+    public void reload() {
+        generation++;
+        instances.clear();
+        next = 0;
+        entries = null;
+    }
+
+    public String toString() {
+        return "java.util.ServiceLoader[" + service.getName() + "]";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Set.java b/Ports/CLDC11/src/java/util/Set.java
index bee049dc4ee..41d6db404d3 100644
--- a/Ports/CLDC11/src/java/util/Set.java
+++ b/Ports/CLDC11/src/java/util/Set.java
@@ -241,4 +241,72 @@ public interface Set<E> extends Collection<E> {
     ///
     /// - Collection#toArray(Object[])
     public <T> T[] toArray(T[] array);
+
+    /// An unmodifiable set of no elements.
+    static <E> Set<E> of() {
+        return ImmutableCollections.set(new Object[] {}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1) {
+        return ImmutableCollections.set(new Object[] {e1}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2) {
+        return ImmutableCollections.set(new Object[] {e1, e2}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9, e10}, true);
+    }
+
+    /// An unmodifiable set of `elements`, none of which may be null and no two equal.
+    @SafeVarargs
+    static <E> Set<E> of(E... elements) {
+        return ImmutableCollections.set(elements, true);
+    }
+
+    /// An unmodifiable set of the elements of `collection`, which may not hold
+    /// null; `collection` itself when it is already such a set.
+    static <E> Set<E> copyOf(Collection<? extends E> collection) {
+        return ImmutableCollections.setCopyOf(collection);
+    }
+
 }
diff --git a/Ports/CLDC11/src/java/util/Spliterator.java b/Ports/CLDC11/src/java/util/Spliterator.java
new file mode 100644
index 00000000000..fda97ba2f96
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/Spliterator.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.Consumer;
+
+/// A source of elements that hands them out one at a time, which is what
+/// `java.util.stream.StreamSupport` makes a stream of.
+///
+/// Streams here are sequential, so nothing splits one: `trySplit` may
+/// answer null, and the ones this library makes always do.
+public interface Spliterator<T> {
+
+    /// The elements have a defined encounter order.
+    int ORDERED = 0x00000010;
+
+    /// No two elements are equal.
+    int DISTINCT = 0x00000001;
+
+    /// The elements are in the order [#getComparator()] gives.
+    int SORTED = 0x00000004;
+
+    /// [#estimateSize()] is exact.
+    int SIZED = 0x00000040;
+
+    /// No element is null.
+    int NONNULL = 0x00000100;
+
+    /// The source cannot be changed.
+    int IMMUTABLE = 0x00000400;
+
+    /// The source may be changed safely while it is read.
+    int CONCURRENT = 0x00001000;
+
+    /// The parts a split makes are sized too.
+    int SUBSIZED = 0x00004000;
+
+    /// Hands the next element to `action` and answers true, or answers false
+    /// when there is none.
+    boolean tryAdvance(Consumer<? super T> action);
+
+    /// Hands every remaining element to `action`, in order.
+    default void forEachRemaining(Consumer<? super T> action) {
+        while (tryAdvance(action)) {
+            // each call handed one element on
+        }
+    }
+
+    /// A part of the elements to be read separately, or null when this
+    /// source does not split.
+    Spliterator<T> trySplit();
+
+    /// How many elements remain, `Long.MAX_VALUE` when that is not known.
+    long estimateSize();
+
+    /// [#estimateSize()] when the source is [#SIZED], -1 otherwise.
+    default long getExactSizeIfKnown() {
+        return (characteristics() & SIZED) == 0 ? -1L : estimateSize();
+    }
+
+    /// The characteristics of this source, as a set of the bits declared here.
+    int characteristics();
+
+    /// Whether every bit of `characteristics` is one of this source's.
+    default boolean hasCharacteristics(int characteristics) {
+        return (characteristics() & characteristics) == characteristics;
+    }
+
+    /// The order of a [#SORTED] source, null for the natural order.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalStateException`: when the source is not sorted
+    default Comparator<? super T> getComparator() {
+        throw new IllegalStateException();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/Spliterators.java b/Ports/CLDC11/src/java/util/Spliterators.java
new file mode 100644
index 00000000000..615052437f0
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/Spliterators.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.Consumer;
+
+/// Ways to make a [Spliterator] of a collection or an iterator, and an
+/// iterator of a spliterator.
+public final class Spliterators {
+
+    private Spliterators() {
+    }
+
+    /// A spliterator of no elements.
+    public static <T> Spliterator<T> emptySpliterator() {
+        return new IteratorSpliterator<T>(null, Collections.<T>emptyList().iterator(), 0,
+                Spliterator.SIZED | Spliterator.SUBSIZED);
+    }
+
+    /// The elements of `c`. Its iterator is asked for when the first element
+    /// is, not now, so elements added in between are seen, as the JDK's
+    /// collections do.
+    public static <T> Spliterator<T> spliterator(Collection<? extends T> c, int characteristics) {
+        if (c == null) {
+            throw new NullPointerException();
+        }
+        return new IteratorSpliterator<T>(c, null, -1, sized(characteristics));
+    }
+
+    /// The `size` elements of `iterator`.
+    public static <T> Spliterator<T> spliterator(Iterator<? extends T> iterator, long size, int characteristics) {
+        if (iterator == null) {
+            throw new NullPointerException();
+        }
+        return new IteratorSpliterator<T>(null, iterator, size, sized(characteristics));
+    }
+
+    /// The elements of `iterator`, however many there are.
+    public static <T> Spliterator<T> spliteratorUnknownSize(Iterator<? extends T> iterator, int characteristics) {
+        if (iterator == null) {
+            throw new NullPointerException();
+        }
+        return new IteratorSpliterator<T>(null, iterator, Long.MAX_VALUE,
+                characteristics & ~(Spliterator.SIZED | Spliterator.SUBSIZED));
+    }
+
+    private static int sized(int characteristics) {
+        return (characteristics & Spliterator.CONCURRENT) == 0
+                ? characteristics | Spliterator.SIZED | Spliterator.SUBSIZED : characteristics;
+    }
+
+    /// The elements of `spliterator`, as an iterator.
+    public static <T> Iterator<T> iterator(final Spliterator<? extends T> spliterator) {
+        if (spliterator == null) {
+            throw new NullPointerException();
+        }
+        return new Unspliterated<T>(spliterator);
+    }
+
+    /// What [#iterator(Spliterator)] answers: an element taken ahead to
+    /// answer `hasNext`.
+    private static final class Unspliterated<T> implements Iterator<T>, Consumer<T> {
+        private final Spliterator<? extends T> spliterator;
+        private boolean ready;
+        private T next;
+
+        Unspliterated(Spliterator<? extends T> spliterator) {
+            this.spliterator = spliterator;
+        }
+
+        @Override
+        public void accept(T t) {
+            ready = true;
+            next = t;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (!ready) {
+                spliterator.tryAdvance(this);
+            }
+            return ready;
+        }
+
+        @Override
+        public T next() {
+            if (!ready && !hasNext()) {
+                throw new NoSuchElementException();
+            }
+            ready = false;
+            T out = next;
+            next = null;
+            return out;
+        }
+    }
+
+    /// A spliterator over an iterator, or over the iterator a collection
+    /// gives when it is first read.
+    private static final class IteratorSpliterator<T> implements Spliterator<T> {
+        private final Collection<? extends T> collection;
+        private Iterator<? extends T> it;
+        private long size;
+        private final int characteristics;
+
+        IteratorSpliterator(Collection<? extends T> collection, Iterator<? extends T> it, long size,
+                            int characteristics) {
+            this.collection = collection;
+            this.it = it;
+            this.size = size;
+            this.characteristics = characteristics;
+        }
+
+        private Iterator<? extends T> open() {
+            if (it == null) {
+                it = collection.iterator();
+                size = collection.size();
+            }
+            return it;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super T> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            Iterator<? extends T> source = open();
+            if (!source.hasNext()) {
+                return false;
+            }
+            action.accept(source.next());
+            return true;
+        }
+
+        @Override
+        public void forEachRemaining(Consumer<? super T> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            Iterator<? extends T> source = open();
+            while (source.hasNext()) {
+                action.accept(source.next());
+            }
+        }
+
+        @Override
+        public Spliterator<T> trySplit() {
+            return null;
+        }
+
+        @Override
+        public long estimateSize() {
+            if (it == null) {
+                return collection.size();
+            }
+            return size;
+        }
+
+        @Override
+        public int characteristics() {
+            return characteristics;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/StringJoiner.java b/Ports/CLDC11/src/java/util/StringJoiner.java
new file mode 100644
index 00000000000..a889db758a5
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/StringJoiner.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.StringJoiner`: builds a sequence
+/// of strings separated by a delimiter, optionally between a prefix and a
+/// suffix.
+public final class StringJoiner {
+
+    private final String prefix;
+    private final String delimiter;
+    private final String suffix;
+    private StringBuilder value;
+    private String emptyValue;
+
+    public StringJoiner(CharSequence delimiter) {
+        this(delimiter, "", "");
+    }
+
+    public StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix) {
+        if (prefix == null) {
+            throw new NullPointerException("The prefix must not be null");
+        }
+        if (delimiter == null) {
+            throw new NullPointerException("The delimiter must not be null");
+        }
+        if (suffix == null) {
+            throw new NullPointerException("The suffix must not be null");
+        }
+        this.prefix = prefix.toString();
+        this.delimiter = delimiter.toString();
+        this.suffix = suffix.toString();
+        this.emptyValue = this.prefix + this.suffix;
+    }
+
+    public StringJoiner setEmptyValue(CharSequence emptyValue) {
+        if (emptyValue == null) {
+            throw new NullPointerException("The empty value must not be null");
+        }
+        this.emptyValue = emptyValue.toString();
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        if (value == null) {
+            return emptyValue;
+        }
+        if (suffix.length() == 0) {
+            return value.toString();
+        }
+        return value.toString() + suffix;
+    }
+
+    public StringJoiner add(CharSequence newElement) {
+        prepareBuilder().append(String.valueOf(newElement));
+        return this;
+    }
+
+    public StringJoiner merge(StringJoiner other) {
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        if (other.value != null) {
+            // Taken before the builder is prepared, so that merging a joiner
+            // into itself appends its content once.
+            String content = other.value.toString().substring(other.prefix.length());
+            prepareBuilder().append(content);
+        }
+        return this;
+    }
+
+    private StringBuilder prepareBuilder() {
+        if (value != null) {
+            value.append(delimiter);
+        } else {
+            value = new StringBuilder().append(prefix);
+        }
+        return value;
+    }
+
+    public int length() {
+        return value != null ? value.length() + suffix.length() : emptyValue.length();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/UUID.java b/Ports/CLDC11/src/java/util/UUID.java
new file mode 100644
index 00000000000..a59d7e85b51
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/UUID.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import com.codename1.impl.JdkHost;
+
+/// A 128 bit identifier: its canonical text form, random (version 4)
+/// generation and name based (version 3) generation.
+///
+/// [#randomUUID()] draws its bits from the platform's secure random source
+/// through `JdkHost`. Where the platform installed none it falls back to a
+/// `Random` seeded from the clock, which keeps identifiers unique for every
+/// practical purpose but NOT unpredictable; an application that uses one as
+/// a secret should check that its platform provides secure random bytes.
+///
+/// [#nameUUIDFromBytes(byte\[\])] needs an MD5 digest from the platform and
+/// throws `UnsupportedOperationException` where there is none. The time based
+/// accessors (`timestamp`, `clockSequence`, `node`) are not provided.
+public final class UUID implements Comparable<UUID>, java.io.Serializable {
+
+    private static final long serialVersionUID = -4856846361193249489L;
+
+    private static final String HEX = "0123456789abcdef";
+
+    /// Made the first time the host has no secure source; see the class
+    /// description.
+    private static Random fallback;
+
+    private final long mostSigBits;
+    private final long leastSigBits;
+
+    /// An identifier from its two halves.
+    public UUID(long mostSigBits, long leastSigBits) {
+        this.mostSigBits = mostSigBits;
+        this.leastSigBits = leastSigBits;
+    }
+
+    /// A new version 4 identifier; see the class description for where its
+    /// randomness comes from.
+    public static UUID randomUUID() {
+        byte[] bits = new byte[16];
+        try {
+            JdkHost.get().randomBytes(bits);
+        } catch (UnsupportedOperationException noSecureSource) {
+            insecureBytes(bits);
+        }
+        // Version 4 in the high nibble of the seventh byte, the IETF variant
+        // in the top two bits of the ninth.
+        bits[6] = (byte) ((bits[6] & 0x0f) | 0x40);
+        bits[8] = (byte) ((bits[8] & 0x3f) | 0x80);
+        return fromBytes(bits);
+    }
+
+    private static synchronized void insecureBytes(byte[] out) {
+        if (fallback == null) {
+            fallback = new Random(System.currentTimeMillis() ^ (System.nanoTime() << 21));
+        }
+        for (int i = 0; i < out.length; i++) {
+            out[i] = (byte) fallback.nextInt(256);
+        }
+    }
+
+    /// The version 3 identifier of `name`: its MD5 digest, with the version
+    /// and variant bits set.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedOperationException`: if the platform has no MD5 digest
+    public static UUID nameUUIDFromBytes(byte[] name) {
+        JdkHost.Digest md5 = JdkHost.get().digest("MD5");
+        if (md5 == null) {
+            throw new UnsupportedOperationException("MD5 not supported");
+        }
+        md5.update(name, 0, name.length);
+        byte[] bits = md5.digest();
+        bits[6] = (byte) ((bits[6] & 0x0f) | 0x30);
+        bits[8] = (byte) ((bits[8] & 0x3f) | 0x80);
+        return fromBytes(bits);
+    }
+
+    private static UUID fromBytes(byte[] bits) {
+        long most = 0;
+        long least = 0;
+        for (int i = 0; i < 8; i++) {
+            most = (most << 8) | (bits[i] & 0xff);
+        }
+        for (int i = 8; i < 16; i++) {
+            least = (least << 8) | (bits[i] & 0xff);
+        }
+        return new UUID(most, least);
+    }
+
+    /// Parses the text form [#toString()] writes: five groups of hexadecimal
+    /// digits separated by `-`. As in the JDK, a group may be shorter than
+    /// its full width, and one that is longer is not refused either: the
+    /// digits past its width are dropped, so `100000000-0-0-0-0` is the
+    /// nil UUID there and here. Only a group of more than sixteen digits,
+    /// which no `long` holds, is an error.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `name` is not in that form
+    public static UUID fromString(String name) {
+        long[] groups = new long[5];
+        int group = 0;
+        int digits = 0;
+        long value = 0;
+        int n = name.length();
+        for (int i = 0; i <= n; i++) {
+            char c = i < n ? name.charAt(i) : '-';
+            if (c == '-') {
+                if (digits == 0 || group > 4) {
+                    throw new IllegalArgumentException("Invalid UUID string: " + name);
+                }
+                groups[group++] = value;
+                value = 0;
+                digits = 0;
+                continue;
+            }
+            int d = hexDigit(c);
+            if (d < 0 || digits >= 16) {
+                throw new IllegalArgumentException("Invalid UUID string: " + name);
+            }
+            value = (value << 4) | d;
+            digits++;
+        }
+        if (group != 5) {
+            throw new IllegalArgumentException("Invalid UUID string: " + name);
+        }
+        long most = ((groups[0] & 0xffffffffL) << 32) | ((groups[1] & 0xffffL) << 16) | (groups[2] & 0xffffL);
+        long least = ((groups[3] & 0xffffL) << 48) | (groups[4] & 0xffffffffffffL);
+        return new UUID(most, least);
+    }
+
+    private static int hexDigit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    /// The most significant 64 bits.
+    public long getMostSignificantBits() {
+        return mostSigBits;
+    }
+
+    /// The least significant 64 bits.
+    public long getLeastSignificantBits() {
+        return leastSigBits;
+    }
+
+    /// The version number: 4 for one made by [#randomUUID()], 3 for one made
+    /// by [#nameUUIDFromBytes(byte\[\])].
+    public int version() {
+        return (int) ((mostSigBits >> 12) & 0x0f);
+    }
+
+    /// The variant number: 2 for the IETF layout every identifier made here
+    /// has.
+    public int variant() {
+        return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder out = new StringBuilder(36);
+        hex(out, mostSigBits >> 32, 8);
+        out.append('-');
+        hex(out, mostSigBits >> 16, 4);
+        out.append('-');
+        hex(out, mostSigBits, 4);
+        out.append('-');
+        hex(out, leastSigBits >> 48, 4);
+        out.append('-');
+        hex(out, leastSigBits, 12);
+        return out.toString();
+    }
+
+    private static void hex(StringBuilder out, long value, int digits) {
+        for (int shift = (digits - 1) * 4; shift >= 0; shift -= 4) {
+            out.append(HEX.charAt((int) ((value >> shift) & 0xf)));
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        long hilo = mostSigBits ^ leastSigBits;
+        return ((int) (hilo >> 32)) ^ (int) hilo;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof UUID)) {
+            return false;
+        }
+        UUID other = (UUID) obj;
+        return mostSigBits == other.mostSigBits && leastSigBits == other.leastSigBits;
+    }
+
+    /// Orders by the most significant half, then the least, each as a signed
+    /// number -- the order the JDK defines.
+    @Override
+    public int compareTo(UUID val) {
+        if (mostSigBits != val.mostSigBits) {
+            return mostSigBits < val.mostSigBits ? -1 : 1;
+        }
+        if (leastSigBits != val.leastSigBits) {
+            return leastSigBits < val.leastSigBits ? -1 : 1;
+        }
+        return 0;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/WeakHashMap.java b/Ports/CLDC11/src/java/util/WeakHashMap.java
new file mode 100644
index 00000000000..47b336dd589
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/WeakHashMap.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.lang.ref.WeakReference;
+
+/// `java.util.WeakHashMap`: a map that does not
+/// keep its keys alive. An entry disappears once nothing else refers to its
+/// key, which is what lets desktop code hang data off a component -- a layout
+/// manager's cached constraints, say -- without ever removing it.
+///
+/// Keys are held through the device's `WeakReference` and compared with
+/// `equals`, as the JDK's are. Entries whose key is gone are dropped by the
+/// next change to the map, by [#size()], and by reads too, in a sweep that
+/// runs once per roughly as many reads as the map has keys -- so a cache that
+/// is only ever read still lets go of its values, at an amortized constant
+/// cost per read. There is no reference queue on a device, so nothing is
+/// dropped in between, and [#size()] counts only the entries still alive.
+///
+/// [#entrySet()], [#keySet()] and [#values()] are snapshots taken when they
+/// are called: removing through them, or through their iterators, does not
+/// change the map. The JDK's are live views; code that edits a weak map
+/// through a view is rare enough that the simpler contract is kept.
+///
+/// Like every shared JDK class here it is not synchronized, and neither is
+/// the JDK's.
+public class WeakHashMap<K, V> extends AbstractMap<K, V> {
+
+    /// Stands in for the null key, which a weak reference cannot tell from a
+    /// key that was collected.
+    private static final Object NULL_KEY = new Object();
+
+    /// The entries by their key's hash code.
+    private final HashMap<Integer, List<Cell<V>>> buckets = new HashMap<Integer, List<Cell<V>>>();
+
+    /// Reads since the last sweep; see the class description.
+    private int readsSinceExpunge;
+
+    private static final class Cell<V> {
+        @SuppressWarnings("rawtypes")
+        private final WeakReference key;
+        private V value;
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        Cell(Object key, V value) {
+            this.key = new WeakReference(key);
+            this.value = value;
+        }
+    }
+
+    public WeakHashMap() {
+        // Nothing to size: the buckets grow as they are used.
+    }
+
+    public WeakHashMap(int initialCapacity) {
+        if (initialCapacity < 0) {
+            throw new IllegalArgumentException("Illegal Initial Capacity: " + initialCapacity);
+        }
+    }
+
+    public WeakHashMap(int initialCapacity, float loadFactor) {
+        this(initialCapacity);
+        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
+            throw new IllegalArgumentException("Illegal Load factor: " + loadFactor);
+        }
+    }
+
+    public WeakHashMap(Map<? extends K, ? extends V> m) {
+        putAll(m);
+    }
+
+    private static Object mask(Object key) {
+        return key == null ? NULL_KEY : key;
+    }
+
+    /// The cell of `key` (already masked), or null.
+    private Cell<V> find(Object key) {
+        List<Cell<V>> bucket = buckets.get(Integer.valueOf(key.hashCode()));
+        if (bucket == null) {
+            return null;
+        }
+        for (int i = 0; i < bucket.size(); i++) {
+            Cell<V> c = bucket.get(i);
+            Object k = c.key.get();
+            if (k == key || (k != null && k.equals(key))) {
+                return c;
+            }
+        }
+        return null;
+    }
+
+    /// Sweeps from a read once enough reads have passed to pay for it.
+    private void expungeFromRead() {
+        if (++readsSinceExpunge > buckets.size() + 16) {
+            expunge();
+        }
+    }
+
+    /// Drops every entry whose key has been collected.
+    private void expunge() {
+        readsSinceExpunge = 0;
+        Iterator<List<Cell<V>>> all = buckets.values().iterator();
+        while (all.hasNext()) {
+            List<Cell<V>> bucket = all.next();
+            for (int i = bucket.size() - 1; i >= 0; i--) {
+                if (bucket.get(i).key.get() == null) {
+                    bucket.remove(i);
+                }
+            }
+            if (bucket.isEmpty()) {
+                all.remove();
+            }
+        }
+    }
+
+    @Override
+    public int size() {
+        expunge();
+        int n = 0;
+        for (List<Cell<V>> bucket : buckets.values()) {
+            n += bucket.size();
+        }
+        return n;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        expungeFromRead();
+        return find(mask(key)) != null;
+    }
+
+    @Override
+    public V get(Object key) {
+        expungeFromRead();
+        Cell<V> c = find(mask(key));
+        return c == null ? null : c.value;
+    }
+
+    @Override
+    public V put(K key, V value) {
+        Object k = mask(key);
+        Cell<V> c = find(k);
+        if (c != null) {
+            V old = c.value;
+            c.value = value;
+            return old;
+        }
+        expunge();
+        Integer hash = Integer.valueOf(k.hashCode());
+        List<Cell<V>> bucket = buckets.get(hash);
+        if (bucket == null) {
+            bucket = new ArrayList<Cell<V>>(1);
+            buckets.put(hash, bucket);
+        }
+        bucket.add(new Cell<V>(k, value));
+        return null;
+    }
+
+    @Override
+    public V remove(Object key) {
+        Object k = mask(key);
+        Integer hash = Integer.valueOf(k.hashCode());
+        List<Cell<V>> bucket = buckets.get(hash);
+        if (bucket == null) {
+            return null;
+        }
+        for (int i = 0; i < bucket.size(); i++) {
+            Cell<V> c = bucket.get(i);
+            Object held = c.key.get();
+            if (held == k || (held != null && held.equals(k))) {
+                bucket.remove(i);
+                if (bucket.isEmpty()) {
+                    buckets.remove(hash);
+                }
+                return c.value;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void clear() {
+        buckets.clear();
+    }
+
+    /// A snapshot of the live entries; see the class comment.
+    @Override
+    @SuppressWarnings("unchecked")
+    public Set<Map.Entry<K, V>> entrySet() {
+        Set<Map.Entry<K, V>> out = new HashSet<Map.Entry<K, V>>();
+        for (List<Cell<V>> bucket : buckets.values()) {
+            for (int i = 0; i < bucket.size(); i++) {
+                Cell<V> c = bucket.get(i);
+                Object k = c.key.get();
+                if (k != null) {
+                    out.add(new AbstractMap.SimpleEntry<K, V>(k == NULL_KEY ? null : (K) k, c.value));
+                }
+            }
+        }
+        return out;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/AbstractExecutorService.java b/Ports/CLDC11/src/java/util/concurrent/AbstractExecutorService.java
new file mode 100644
index 00000000000..1553c7e7b25
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/AbstractExecutorService.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/// The [ExecutorService] methods that need nothing but `execute`: a
+/// subclass provides execution and the life cycle, and gets `submit`,
+/// `invokeAll` and `invokeAny` from here.
+public abstract class AbstractExecutorService implements ExecutorService {
+
+    public AbstractExecutorService() {
+    }
+
+    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
+        return new FutureTask<T>(runnable, value);
+    }
+
+    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
+        return new FutureTask<T>(callable);
+    }
+
+    public Future<?> submit(Runnable task) {
+        if (task == null) {
+            throw new NullPointerException();
+        }
+        RunnableFuture<Void> ftask = newTaskFor(task, null);
+        execute(ftask);
+        return ftask;
+    }
+
+    public <T> Future<T> submit(Runnable task, T result) {
+        if (task == null) {
+            throw new NullPointerException();
+        }
+        RunnableFuture<T> ftask = newTaskFor(task, result);
+        execute(ftask);
+        return ftask;
+    }
+
+    public <T> Future<T> submit(Callable<T> task) {
+        if (task == null) {
+            throw new NullPointerException();
+        }
+        RunnableFuture<T> ftask = newTaskFor(task);
+        execute(ftask);
+        return ftask;
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        if (tasks == null) {
+            throw new NullPointerException();
+        }
+        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        boolean done = false;
+        try {
+            for (Callable<T> t : tasks) {
+                RunnableFuture<T> f = newTaskFor(t);
+                futures.add(f);
+                execute(f);
+            }
+            for (int i = 0; i < futures.size(); i++) {
+                Future<T> f = futures.get(i);
+                if (!f.isDone()) {
+                    try {
+                        f.get();
+                    } catch (CancellationException ignore) {
+                        // The future reports it to whoever asks.
+                    } catch (ExecutionException ignore) {
+                        // The future reports it to whoever asks.
+                    }
+                }
+            }
+            done = true;
+            return futures;
+        } finally {
+            if (!done) {
+                cancelAll(futures);
+            }
+        }
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException {
+        if (tasks == null || unit == null) {
+            throw new NullPointerException();
+        }
+        long deadline = BlockingWait.deadline(unit.toMillis(timeout));
+        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        boolean done = false;
+        try {
+            for (Callable<T> t : tasks) {
+                futures.add(newTaskFor(t));
+            }
+            for (int i = 0; i < futures.size(); i++) {
+                if (System.currentTimeMillis() >= deadline) {
+                    return futures;
+                }
+                execute((Runnable) futures.get(i));
+            }
+            for (int i = 0; i < futures.size(); i++) {
+                Future<T> f = futures.get(i);
+                if (!f.isDone()) {
+                    long left = deadline - System.currentTimeMillis();
+                    if (left <= 0) {
+                        return futures;
+                    }
+                    try {
+                        f.get(left, TimeUnit.MILLISECONDS);
+                    } catch (CancellationException ignore) {
+                        // The future reports it to whoever asks.
+                    } catch (ExecutionException ignore) {
+                        // The future reports it to whoever asks.
+                    } catch (TimeoutException timedOut) {
+                        return futures;
+                    }
+                }
+            }
+            done = true;
+            return futures;
+        } finally {
+            if (!done) {
+                cancelAll(futures);
+            }
+        }
+    }
+
+    /// Cancels every future that is not done, the LAST first.
+    ///
+    /// The order matters. Workers take tasks in the order they were
+    /// submitted, so cancelling from the front frees a worker -- a task
+    /// cancelled before it started returns at once -- which then starts the
+    /// next task in line before this loop has reached it: a task the caller
+    /// was promised would not run, runs. Cancelling from the back means
+    /// every task behind the one being cancelled is already cancelled.
+    static <T> void cancelAll(List<Future<T>> futures) {
+        for (int i = futures.size() - 1; i >= 0; i--) {
+            futures.get(i).cancel(true);
+        }
+    }
+
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+        try {
+            return doInvokeAny(tasks, BlockingWait.FOREVER);
+        } catch (TimeoutException cannotHappen) {
+            throw new ExecutionException(cannotHappen);
+        }
+    }
+
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        return doInvokeAny(tasks, BlockingWait.deadline(unit.toMillis(timeout)));
+    }
+
+    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks, long deadline)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        if (tasks == null) {
+            throw new NullPointerException();
+        }
+        int n = tasks.size();
+        if (n == 0) {
+            throw new IllegalArgumentException();
+        }
+        Finished finished = new Finished();
+        List<Future<T>> futures = new ArrayList<Future<T>>(n);
+        try {
+            for (Callable<T> t : tasks) {
+                if (t == null) {
+                    throw new NullPointerException();
+                }
+                AnyTask<T> f = new AnyTask<T>(t, finished);
+                futures.add(f);
+                execute(f);
+            }
+            ExecutionException last = null;
+            for (int seen = 0; seen < n; seen++) {
+                Future<?> f = finished.next(deadline);
+                if (f == null) {
+                    throw new TimeoutException();
+                }
+                try {
+                    @SuppressWarnings("unchecked")
+                    T value = ((Future<T>) f).get();
+                    return value;
+                } catch (ExecutionException e) {
+                    last = e;
+                } catch (CancellationException e) {
+                    last = new ExecutionException(e);
+                }
+            }
+            throw last;
+        } finally {
+            cancelAll(futures);
+        }
+    }
+
+    /// The futures of an `invokeAny` in the order they completed.
+    private static final class Finished {
+        private final List<Future<?>> queue = new ArrayList<Future<?>>();
+
+        void add(Future<?> f) {
+            synchronized (this) {
+                queue.add(f);
+                notifyAll();
+            }
+        }
+
+        /// The next completed future, or null when none completed by `deadline`.
+        Future<?> next(long deadline) throws InterruptedException {
+            synchronized (this) {
+                if (!queue.isEmpty()) {
+                    return queue.remove(0);
+                }
+            }
+            new Wait(this, deadline).await();
+            synchronized (this) {
+                return queue.isEmpty() ? null : queue.remove(0);
+            }
+        }
+
+        boolean isEmpty() {
+            return queue.isEmpty();
+        }
+    }
+
+    private static final class Wait extends BlockingWait {
+        private final Finished finished;
+
+        Wait(Finished finished, long deadline) {
+            super(finished, deadline);
+            this.finished = finished;
+        }
+
+        boolean ready() {
+            return !finished.isEmpty();
+        }
+    }
+
+    private static final class AnyTask<T> extends FutureTask<T> {
+        private final Finished finished;
+
+        AnyTask(Callable<T> c, Finished finished) {
+            super(c);
+            this.finished = finished;
+        }
+
+        protected void done() {
+            finished.add(this);
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/AsyncPool.java b/Ports/CLDC11/src/java/util/concurrent/AsyncPool.java
new file mode 100644
index 00000000000..91dafb16352
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/AsyncPool.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// The threads the `...Async` methods of [CompletableFuture] run on when
+/// they are given no executor.
+///
+/// A cached pool of daemon threads: a task goes to an idle worker or to a
+/// new one, so a task that waits for another never holds that one up -- a
+/// bounded pool deadlocks the moment every worker waits on work still in its
+/// queue. A worker ends after a minute without work, and none keeps a
+/// program from ending, as with the JDK's common pool.
+final class AsyncPool {
+
+    private static final Object LOCK = new Object();
+    private static Executor pool;
+
+    private AsyncPool() {
+    }
+
+    /// The pool, made when it is first needed.
+    static Executor get() {
+        synchronized (LOCK) {
+            if (pool == null) {
+                pool = new Executors.Pool(Integer.MAX_VALUE, 60000L, new Executors.DefaultThreadFactory(true));
+            }
+            return pool;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/BlockingWait.java b/Ports/CLDC11/src/java/util/concurrent/BlockingWait.java
new file mode 100644
index 00000000000..735bc0d0336
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/BlockingWait.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import com.codename1.impl.JdkHost;
+
+/// A wait on a monitor until a condition holds or a deadline passes, for
+/// every blocking call in this package: `Future.get`, `awaitTermination`,
+/// `CountDownLatch.await` and the like.
+///
+/// The UI thread must never block. Called there, the wait runs through
+/// `JdkHost.blockUi`, which on a Codename One device is
+/// `Display.invokeAndBlock`: events keep being dispatched while it waits.
+/// Everywhere else -- a worker, the backend, a VM test -- it is a plain
+/// `Object.wait` on the caller's thread and is interruptible.
+///
+/// Whoever makes the condition true calls `notifyAll()` on the same monitor
+/// while holding it.
+abstract class BlockingWait implements Runnable {
+
+    /// A deadline that never comes.
+    static final long FOREVER = Long.MAX_VALUE;
+
+    private final Object monitor;
+    private final long deadline;
+    /// Set by [#run] when the wait was interrupted on the thread `blockUi`
+    /// lent it; read back by [#await] on the UI thread. Guarded by `this`.
+    private InterruptedException interrupted;
+
+    /// A wait on `monitor` until `deadline` ([#FOREVER], or a time from
+    /// [#deadline]).
+    BlockingWait(Object monitor, long deadline) {
+        this.monitor = monitor;
+        this.deadline = deadline;
+    }
+
+    /// The deadline `millis` from now, saturating at [#FOREVER]; a negative
+    /// duration is due now.
+    static long deadline(long millis) {
+        long now = System.currentTimeMillis();
+        if (millis <= 0) {
+            return now;
+        }
+        return millis >= FOREVER - now ? FOREVER : now + millis;
+    }
+
+    /// Whether the wait is over. Called holding the monitor.
+    abstract boolean ready();
+
+    /// Waits until [#ready] or the deadline, whichever is first. The caller
+    /// asks [#ready] again (or reads its own state) to learn which.
+    ///
+    /// A thread that is interrupted does not start to wait: the interrupt is
+    /// consumed by the `InterruptedException`, as in the JDK.
+    final void await() throws InterruptedException {
+        if (Thread.interrupted()) {
+            throw new InterruptedException();
+        }
+        JdkHost host = JdkHost.get();
+        if (!host.isUiThread()) {
+            block();
+            return;
+        }
+        host.blockUi(this);
+        InterruptedException e;
+        synchronized (this) {
+            e = interrupted;
+            interrupted = null;
+        }
+        if (e != null) {
+            throw e;
+        }
+    }
+
+    /// The wait, on the thread `JdkHost.blockUi` runs it on.
+    @Override
+    public final void run() {
+        try {
+            block();
+        } catch (InterruptedException e) {
+            synchronized (this) {
+                interrupted = e;
+            }
+        }
+    }
+
+    private void block() throws InterruptedException {
+        synchronized (monitor) {
+            while (!ready()) {
+                if (deadline == FOREVER) {
+                    monitor.wait();
+                } else {
+                    long left = deadline - System.currentTimeMillis();
+                    if (left <= 0) {
+                        return;
+                    }
+                    monitor.wait(left);
+                }
+            }
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/Callable.java b/Ports/CLDC11/src/java/util/concurrent/Callable.java
new file mode 100644
index 00000000000..12897a5c521
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/Callable.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// A task that answers a result and may throw.
+///
+/// @param <V> the type of the result
+public interface Callable<V> {
+
+    /// Computes the result.
+    V call() throws Exception;
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CancellationException.java b/Ports/CLDC11/src/java/util/concurrent/CancellationException.java
new file mode 100644
index 00000000000..75b1711bb75
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CancellationException.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *  
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Codename One through http://www.codenameone.com/ if you 
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Thrown by [Future#get] when the work was cancelled before it ran.
+public class CancellationException extends IllegalStateException {
+    /// An exception with no message.
+    public CancellationException() { }
+
+    /// An exception with `message`.
+    ///
+    /// @param message the detail message
+    public CancellationException(String message) { super(message); }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CompletableFuture.java b/Ports/CLDC11/src/java/util/concurrent/CompletableFuture.java
new file mode 100644
index 00000000000..eef231277bc
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CompletableFuture.java
@@ -0,0 +1,1144 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/// `java.util.concurrent.CompletableFuture` for the Codename One runtime.
+///
+/// A stage completes on the thread that completed the one before it, as in
+/// the JDK. The `...Async` methods without an executor run on a pool of
+/// daemon threads -- there is no fork-join pool here -- and never on the UI
+/// thread; a continuation that touches the user interface passes an executor
+/// that calls `Display.callSerially`, or calls it itself.
+///
+/// The class is safe to use from several threads at once: its state is
+/// kept in atomics, and every dependent action runs exactly once.
+///
+/// `get()` and `join()` on the UI thread wait through `JdkHost.blockUi`,
+/// which on a device is `Display.invokeAndBlock`: events keep being
+/// dispatched.
+///
+/// Exceptions travel as in the JDK: a stage that depends on a failed one
+/// fails with a [CompletionException] whose cause is the original; `get()`
+/// reports that cause in an [ExecutionException], `join()` throws the
+/// `CompletionException`, and both throw [CancellationException] after
+/// `cancel`.
+///
+/// Not provided: `obtrudeValue`, `obtrudeException`,
+/// `getNumberOfDependents`, `delayedExecutor` and `state()`.
+public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
+
+    /// A null result; null in [#result] is "not completed".
+    private static final Object NIL = new Object();
+
+    private static final class Failure {
+        final Throwable cause;
+
+        Failure(Throwable cause) {
+            this.cause = cause;
+        }
+    }
+
+    /// One action waiting for this future, in a stack of them.
+    private static final class Waiting {
+        final Runnable action;
+        Waiting next;
+
+        Waiting(Runnable action) {
+            this.action = action;
+        }
+    }
+
+    /// What the stack of waiting actions holds once they have been run.
+    private static final Waiting RELEASED = new Waiting(null);
+
+    private final AtomicReference<Object> result = new AtomicReference<Object>();
+    private final AtomicReference<Waiting> waiting = new AtomicReference<Waiting>();
+
+    public CompletableFuture() {
+    }
+
+    // ------------------------------------------------------------------
+    // Completion
+    // ------------------------------------------------------------------
+
+    private boolean completeRaw(Object outcome) {
+        if (!result.compareAndSet(null, outcome)) {
+            return false;
+        }
+        Waiting head = waiting.getAndSet(RELEASED);
+        // The stack is newest first; run in the order they were added.
+        Waiting ordered = null;
+        while (head != null && head != RELEASED) {
+            Waiting next = head.next;
+            head.next = ordered;
+            ordered = head;
+            head = next;
+        }
+        while (ordered != null) {
+            ordered.action.run();
+            ordered = ordered.next;
+        }
+        return true;
+    }
+
+    /// Runs `action` when this future is complete: now if it already is.
+    private void whenDone(Runnable action) {
+        Waiting w = new Waiting(action);
+        while (true) {
+            Waiting head = waiting.get();
+            if (head == RELEASED) {
+                action.run();
+                return;
+            }
+            w.next = head;
+            if (waiting.compareAndSet(head, w)) {
+                return;
+            }
+        }
+    }
+
+    private static CompletionException wrap(Throwable t) {
+        if (t instanceof CompletionException) {
+            return (CompletionException) t;
+        }
+        return new CompletionException(t);
+    }
+
+    private boolean fail(Throwable t) {
+        return completeRaw(new Failure(t));
+    }
+
+    /// Takes the outcome of a stage this one depends on.
+    private boolean relay(Object outcome) {
+        if (outcome instanceof Failure) {
+            return completeRaw(new Failure(wrap(((Failure) outcome).cause)));
+        }
+        return completeRaw(outcome);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <V> V value(Object outcome) {
+        return outcome == NIL ? null : (V) outcome;
+    }
+
+    private static Throwable failure(Object outcome) {
+        return outcome instanceof Failure ? ((Failure) outcome).cause : null;
+    }
+
+    public boolean complete(T value) {
+        return completeRaw(value == null ? NIL : value);
+    }
+
+    public boolean completeExceptionally(Throwable ex) {
+        if (ex == null) {
+            throw new NullPointerException();
+        }
+        return fail(ex);
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        boolean cancelled = result.get() == null && fail(new CancellationException());
+        return cancelled || isCancelled();
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return failure(result.get()) instanceof CancellationException;
+    }
+
+    @Override
+    public boolean isDone() {
+        return result.get() != null;
+    }
+
+    public boolean isCompletedExceptionally() {
+        return result.get() instanceof Failure;
+    }
+
+    // ------------------------------------------------------------------
+    // Reading the result
+    // ------------------------------------------------------------------
+
+    /// Waits for completion, for `millis` at most when that is not negative.
+    /// On the UI thread the wait goes through `JdkHost.blockUi`, so events
+    /// keep being dispatched; anywhere else it is interruptible.
+    private Object await(long millis) throws InterruptedException, TimeoutException {
+        Object outcome = result.get();
+        if (outcome != null) {
+            return outcome;
+        }
+        if (millis == 0) {
+            throw new TimeoutException();
+        }
+        final Signal signal = new Signal();
+        whenDone(signal);
+        new SignalWait(signal, millis < 0 ? BlockingWait.FOREVER : BlockingWait.deadline(millis)).await();
+        outcome = result.get();
+        if (outcome == null) {
+            throw new TimeoutException();
+        }
+        return outcome;
+    }
+
+    /// Raised when the future completes, for a thread waiting on it.
+    private static final class Signal implements Runnable {
+        private boolean raised;
+
+        public void run() {
+            synchronized (this) {
+                raised = true;
+                notifyAll();
+            }
+        }
+    }
+
+    private static final class SignalWait extends BlockingWait {
+        private final Signal signal;
+
+        SignalWait(Signal signal, long deadline) {
+            super(signal, deadline);
+            this.signal = signal;
+        }
+
+        boolean ready() {
+            return signal.raised;
+        }
+    }
+
+    private T reportGet(Object outcome) throws ExecutionException {
+        if (outcome instanceof Failure) {
+            Throwable t = ((Failure) outcome).cause;
+            if (t instanceof CancellationException) {
+                throw (CancellationException) t;
+            }
+            if (t instanceof CompletionException && t.getCause() != null) {
+                t = t.getCause();
+            }
+            throw new ExecutionException(t);
+        }
+        return CompletableFuture.<T>value(outcome);
+    }
+
+    private T reportJoin(Object outcome) {
+        if (outcome instanceof Failure) {
+            Throwable t = ((Failure) outcome).cause;
+            if (t instanceof CancellationException) {
+                throw (CancellationException) t;
+            }
+            throw wrap(t);
+        }
+        return CompletableFuture.<T>value(outcome);
+    }
+
+    @Override
+    public T get() throws InterruptedException, ExecutionException {
+        try {
+            return reportGet(await(-1));
+        } catch (TimeoutException cannotHappen) {
+            // A wait without a limit ends only once the future is done.
+            throw new IllegalStateException(cannotHappen.toString());
+        }
+    }
+
+    @Override
+    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        return reportGet(await(Math.max(0, unit.toMillis(timeout))));
+    }
+
+    /// The result, waiting for it; a failure is a [CompletionException].
+    public T join() {
+        Object outcome = result.get();
+        boolean interrupted = false;
+        while (outcome == null) {
+            try {
+                outcome = await(-1);
+            } catch (InterruptedException e) {
+                // join does not give up; it asks again, and hands the
+                // interrupt back to the thread once it is done.
+                interrupted = true;
+                outcome = result.get();
+            } catch (TimeoutException e) {
+                outcome = result.get();
+            }
+        }
+        if (interrupted) {
+            Thread.currentThread().interrupt();
+        }
+        return reportJoin(outcome);
+    }
+
+    public T getNow(T valueIfAbsent) {
+        Object outcome = result.get();
+        return outcome == null ? valueIfAbsent : reportJoin(outcome);
+    }
+
+    /// The result of a future that completed normally.
+    public T resultNow() {
+        Object outcome = result.get();
+        if (outcome == null) {
+            throw new IllegalStateException("Task has not completed");
+        }
+        if (outcome instanceof Failure) {
+            throw new IllegalStateException(isCancelled() ? "Task was cancelled"
+                    : "Task completed with exception");
+        }
+        return CompletableFuture.<T>value(outcome);
+    }
+
+    /// The exception of a future that failed.
+    public Throwable exceptionNow() {
+        Object outcome = result.get();
+        if (outcome == null) {
+            throw new IllegalStateException("Task has not completed");
+        }
+        if (!(outcome instanceof Failure)) {
+            throw new IllegalStateException("Task completed with a result");
+        }
+        if (isCancelled()) {
+            throw new IllegalStateException("Task was cancelled");
+        }
+        Throwable t = ((Failure) outcome).cause;
+        return t instanceof CompletionException && t.getCause() != null ? t.getCause() : t;
+    }
+
+    // ------------------------------------------------------------------
+    // Factories
+    // ------------------------------------------------------------------
+
+    /// The executor the `...Async` methods use when given none.
+    public Executor defaultExecutor() {
+        return pool();
+    }
+
+    private static Executor pool() {
+        return AsyncPool.get();
+    }
+
+    public <U> CompletableFuture<U> newIncompleteFuture() {
+        return new CompletableFuture<U>();
+    }
+
+    public static <U> CompletableFuture<U> completedFuture(U value) {
+        CompletableFuture<U> f = new CompletableFuture<U>();
+        f.complete(value);
+        return f;
+    }
+
+    public static <U> CompletableFuture<U> failedFuture(Throwable ex) {
+        if (ex == null) {
+            throw new NullPointerException();
+        }
+        CompletableFuture<U> f = new CompletableFuture<U>();
+        f.fail(ex);
+        return f;
+    }
+
+    public static <U> CompletionStage<U> completedStage(U value) {
+        return completedFuture(value);
+    }
+
+    public static <U> CompletionStage<U> failedStage(Throwable ex) {
+        return failedFuture(ex);
+    }
+
+    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
+        return supplyAsync(supplier, pool());
+    }
+
+    public static <U> CompletableFuture<U> supplyAsync(final Supplier<U> supplier, Executor executor) {
+        if (supplier == null || executor == null) {
+            throw new NullPointerException();
+        }
+        final CompletableFuture<U> f = new CompletableFuture<U>();
+        executor.execute(new Runnable() {
+            @Override
+            public void run() {
+                if (f.isDone()) {
+                    return;
+                }
+                U value;
+                try {
+                    value = supplier.get();
+                } catch (Throwable t) {
+                    f.fail(wrap(t));
+                    return;
+                }
+                f.complete(value);
+            }
+        });
+        return f;
+    }
+
+    public static CompletableFuture<Void> runAsync(Runnable runnable) {
+        return runAsync(runnable, pool());
+    }
+
+    public static CompletableFuture<Void> runAsync(final Runnable runnable, Executor executor) {
+        if (runnable == null) {
+            throw new NullPointerException();
+        }
+        return supplyAsync(new Supplier<Void>() {
+            @Override
+            public Void get() {
+                runnable.run();
+                return null;
+            }
+        }, executor);
+    }
+
+    public CompletableFuture<T> completeAsync(Supplier<? extends T> supplier) {
+        return completeAsync(supplier, pool());
+    }
+
+    public CompletableFuture<T> completeAsync(final Supplier<? extends T> supplier, Executor executor) {
+        if (supplier == null || executor == null) {
+            throw new NullPointerException();
+        }
+        executor.execute(new Runnable() {
+            @Override
+            public void run() {
+                if (isDone()) {
+                    return;
+                }
+                T value;
+                try {
+                    value = supplier.get();
+                } catch (Throwable t) {
+                    fail(wrap(t));
+                    return;
+                }
+                complete(value);
+            }
+        });
+        return this;
+    }
+
+    public static CompletableFuture<Void> allOf(final CompletableFuture<?>... futures) {
+        final CompletableFuture<Void> all = new CompletableFuture<Void>();
+        if (futures.length == 0) {
+            all.complete(null);
+            return all;
+        }
+        final AtomicInteger remaining = new AtomicInteger(futures.length);
+        Runnable one = new Runnable() {
+            @Override
+            public void run() {
+                if (remaining.decrementAndGet() != 0) {
+                    return;
+                }
+                for (CompletableFuture<?> f : futures) {
+                    Object outcome = f.result.get();
+                    if (outcome instanceof Failure) {
+                        all.relay(outcome);
+                        return;
+                    }
+                }
+                all.complete(null);
+            }
+        };
+        for (CompletableFuture<?> f : futures) {
+            f.whenDone(one);
+        }
+        return all;
+    }
+
+    public static CompletableFuture<Object> anyOf(CompletableFuture<?>... futures) {
+        final CompletableFuture<Object> any = new CompletableFuture<Object>();
+        for (final CompletableFuture<?> f : futures) {
+            f.whenDone(new Runnable() {
+                @Override
+                public void run() {
+                    any.relay(f.result.get());
+                }
+            });
+        }
+        return any;
+    }
+
+    // ------------------------------------------------------------------
+    // Time
+    // ------------------------------------------------------------------
+
+    /// Runs `action` after `millis`, unless this future completes first:
+    /// then the wait is given up, and holds neither a thread nor the
+    /// future. See [Delays].
+    private void later(long millis, Runnable action) {
+        final Delays.Handle wait = Delays.after(millis, action);
+        whenDone(new Runnable() {
+            @Override
+            public void run() {
+                wait.cancel();
+            }
+        });
+    }
+
+    /// Fails this future with a [TimeoutException] if it is not complete
+    /// when the time has passed.
+    public CompletableFuture<T> orTimeout(long timeout, TimeUnit unit) {
+        // The unit is required even when there is nothing left to time.
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (!isDone()) {
+            later(unit.toMillis(timeout), new Runnable() {
+                @Override
+                public void run() {
+                    fail(new TimeoutException());
+                }
+            });
+        }
+        return this;
+    }
+
+    public CompletableFuture<T> completeOnTimeout(final T value, long timeout, TimeUnit unit) {
+        // The unit is required even when there is nothing left to time.
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (!isDone()) {
+            later(unit.toMillis(timeout), new Runnable() {
+                @Override
+                public void run() {
+                    complete(value);
+                }
+            });
+        }
+        return this;
+    }
+
+    // ------------------------------------------------------------------
+    // Dependent stages
+    // ------------------------------------------------------------------
+
+    /// What a dependent stage does with the outcome of this one.
+    private interface Step<U> {
+        void run(Object outcome, CompletableFuture<U> stage) throws Throwable;
+    }
+
+    /// A new stage completed by `step` once this one is complete, on
+    /// `executor` when there is one and on the completing thread otherwise.
+    private <U> CompletableFuture<U> then(final Executor executor, final Step<U> step) {
+        final CompletableFuture<U> stage = newIncompleteFuture();
+        whenDone(new Runnable() {
+            @Override
+            public void run() {
+                final Object outcome = result.get();
+                Runnable body = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            step.run(outcome, stage);
+                        } catch (Throwable t) {
+                            stage.fail(wrap(t));
+                        }
+                    }
+                };
+                if (executor == null) {
+                    body.run();
+                    return;
+                }
+                try {
+                    executor.execute(body);
+                } catch (Throwable t) {
+                    stage.fail(wrap(t));
+                }
+            }
+        });
+        return stage;
+    }
+
+    private static Executor required(Executor executor) {
+        if (executor == null) {
+            throw new NullPointerException();
+        }
+        return executor;
+    }
+
+    private <U> CompletableFuture<U> apply(Executor executor, final Function<? super T, ? extends U> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<U>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<U> stage) {
+                if (outcome instanceof Failure) {
+                    stage.relay(outcome);
+                } else {
+                    stage.complete(fn.apply(CompletableFuture.<T>value(outcome)));
+                }
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn) {
+        return apply(null, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenApplyAsync(Function<? super T, ? extends U> fn) {
+        return apply(pool(), fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenApplyAsync(Function<? super T, ? extends U> fn, Executor executor) {
+        return apply(required(executor), fn);
+    }
+
+    private CompletableFuture<Void> accept(Executor executor, final Consumer<? super T> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return apply(executor, new Function<T, Void>() {
+            @Override
+            public Void apply(T value) {
+                action.accept(value);
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
+        return accept(null, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
+        return accept(pool(), action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor) {
+        return accept(required(executor), action);
+    }
+
+    private CompletableFuture<Void> run(Executor executor, final Runnable action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return apply(executor, new Function<T, Void>() {
+            @Override
+            public Void apply(T value) {
+                action.run();
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> thenRun(Runnable action) {
+        return run(null, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenRunAsync(Runnable action) {
+        return run(pool(), action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor) {
+        return run(required(executor), action);
+    }
+
+    private <U> CompletableFuture<U> compose(Executor executor,
+            final Function<? super T, ? extends CompletionStage<U>> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<U>() {
+            @Override
+            public void run(Object outcome, final CompletableFuture<U> stage) {
+                if (outcome instanceof Failure) {
+                    stage.relay(outcome);
+                    return;
+                }
+                final CompletableFuture<U> inner = fn.apply(CompletableFuture.<T>value(outcome))
+                        .toCompletableFuture();
+                inner.whenDone(new Runnable() {
+                    @Override
+                    public void run() {
+                        stage.relay(inner.result.get());
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) {
+        return compose(null, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) {
+        return compose(pool(), fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,
+            Executor executor) {
+        return compose(required(executor), fn);
+    }
+
+    private <U> CompletableFuture<U> handled(Executor executor,
+            final BiFunction<? super T, Throwable, ? extends U> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<U>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<U> stage) {
+                if (outcome instanceof Failure) {
+                    stage.complete(fn.apply(null, ((Failure) outcome).cause));
+                } else {
+                    stage.complete(fn.apply(CompletableFuture.<T>value(outcome), null));
+                }
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) {
+        return handled(null, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) {
+        return handled(pool(), fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,
+            Executor executor) {
+        return handled(required(executor), fn);
+    }
+
+    private CompletableFuture<T> completed(Executor executor, final BiConsumer<? super T, ? super Throwable> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<T>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<T> stage) throws Throwable {
+                if (outcome instanceof Failure) {
+                    try {
+                        action.accept(null, ((Failure) outcome).cause);
+                    } catch (Throwable t) {
+                        // The stage keeps the failure it was told about, and
+                        // since JDK 9 the action's own failure rides along as
+                        // a suppressed exception of it (JDK 8 dropped it).
+                        Throwable cause = ((Failure) outcome).cause;
+                        if (cause != null && cause != t) {
+                            cause.addSuppressed(t);
+                        }
+                        stage.relay(outcome);
+                        return;
+                    }
+                    stage.relay(outcome);
+                } else {
+                    action.accept(CompletableFuture.<T>value(outcome), null);
+                    stage.completeRaw(outcome);
+                }
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
+        return completed(null, action);
+    }
+
+    @Override
+    public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
+        return completed(pool(), action);
+    }
+
+    @Override
+    public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,
+            Executor executor) {
+        return completed(required(executor), action);
+    }
+
+    private CompletableFuture<T> recovered(Executor executor, final Function<Throwable, ? extends T> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<T>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<T> stage) {
+                if (outcome instanceof Failure) {
+                    stage.complete(fn.apply(((Failure) outcome).cause));
+                } else {
+                    stage.completeRaw(outcome);
+                }
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) {
+        return recovered(null, fn);
+    }
+
+    public CompletableFuture<T> exceptionallyAsync(Function<Throwable, ? extends T> fn) {
+        return recovered(pool(), fn);
+    }
+
+    public CompletableFuture<T> exceptionallyAsync(Function<Throwable, ? extends T> fn, Executor executor) {
+        return recovered(required(executor), fn);
+    }
+
+    public CompletableFuture<T> exceptionallyCompose(final Function<Throwable, ? extends CompletionStage<T>> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(null, new Step<T>() {
+            @Override
+            public void run(Object outcome, final CompletableFuture<T> stage) {
+                if (!(outcome instanceof Failure)) {
+                    stage.completeRaw(outcome);
+                    return;
+                }
+                final CompletableFuture<T> inner = fn.apply(((Failure) outcome).cause).toCompletableFuture();
+                inner.whenDone(new Runnable() {
+                    @Override
+                    public void run() {
+                        stage.relay(inner.result.get());
+                    }
+                });
+            }
+        });
+    }
+
+    private <U, V> CompletableFuture<V> both(final Executor executor, CompletionStage<? extends U> other,
+            final BiFunction<? super T, ? super U, ? extends V> fn) {
+        if (fn == null || other == null) {
+            throw new NullPointerException();
+        }
+        final CompletableFuture<? extends U> second = other.toCompletableFuture();
+        final CompletableFuture<V> stage = newIncompleteFuture();
+        final AtomicInteger remaining = new AtomicInteger(2);
+        Runnable one = new Runnable() {
+            @Override
+            public void run() {
+                if (remaining.decrementAndGet() != 0) {
+                    return;
+                }
+                final Object a = result.get();
+                final Object b = second.result.get();
+                if (a instanceof Failure) {
+                    stage.relay(a);
+                    return;
+                }
+                if (b instanceof Failure) {
+                    stage.relay(b);
+                    return;
+                }
+                Runnable body = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            stage.complete(fn.apply(CompletableFuture.<T>value(a), CompletableFuture.<U>value(b)));
+                        } catch (Throwable t) {
+                            stage.fail(wrap(t));
+                        }
+                    }
+                };
+                if (executor == null) {
+                    body.run();
+                    return;
+                }
+                try {
+                    executor.execute(body);
+                } catch (Throwable t) {
+                    stage.fail(wrap(t));
+                }
+            }
+        };
+        whenDone(one);
+        second.whenDone(one);
+        return stage;
+    }
+
+    @Override
+    public <U, V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn) {
+        return both(null, other, fn);
+    }
+
+    @Override
+    public <U, V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn) {
+        return both(pool(), other, fn);
+    }
+
+    @Override
+    public <U, V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn, Executor executor) {
+        return both(required(executor), other, fn);
+    }
+
+    private <U> CompletableFuture<Void> acceptBoth(Executor executor, CompletionStage<? extends U> other,
+            final BiConsumer<? super T, ? super U> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return both(executor, other, new BiFunction<T, U, Void>() {
+            @Override
+            public Void apply(T a, U b) {
+                action.accept(a, b);
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action) {
+        return acceptBoth(null, other, action);
+    }
+
+    @Override
+    public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action) {
+        return acceptBoth(pool(), other, action);
+    }
+
+    @Override
+    public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action, Executor executor) {
+        return acceptBoth(required(executor), other, action);
+    }
+
+    private CompletableFuture<Void> runBoth(Executor executor, CompletionStage<?> other, final Runnable action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return both(executor, other, new BiFunction<T, Object, Void>() {
+            @Override
+            public Void apply(T a, Object b) {
+                action.run();
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other, Runnable action) {
+        return runBoth(null, other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action) {
+        return runBoth(pool(), other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor) {
+        return runBoth(required(executor), other, action);
+    }
+
+    private <U> CompletableFuture<U> either(final Executor executor, CompletionStage<? extends T> other,
+            final Function<? super T, U> fn) {
+        if (fn == null || other == null) {
+            throw new NullPointerException();
+        }
+        final CompletableFuture<? extends T> second = other.toCompletableFuture();
+        final CompletableFuture<U> stage = newIncompleteFuture();
+        final AtomicBoolean taken = new AtomicBoolean();
+        final CompletableFuture<T> self = this;
+        Runnable first = new Runnable() {
+            @Override
+            public void run() {
+                if (!taken.compareAndSet(false, true)) {
+                    return;
+                }
+                Object mine = self.result.get();
+                final Object outcome = mine != null ? mine : second.result.get();
+                if (outcome instanceof Failure) {
+                    stage.relay(outcome);
+                    return;
+                }
+                Runnable body = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            stage.complete(fn.apply(CompletableFuture.<T>value(outcome)));
+                        } catch (Throwable t) {
+                            stage.fail(wrap(t));
+                        }
+                    }
+                };
+                if (executor == null) {
+                    body.run();
+                    return;
+                }
+                try {
+                    executor.execute(body);
+                } catch (Throwable t) {
+                    stage.fail(wrap(t));
+                }
+            }
+        };
+        whenDone(first);
+        second.whenDone(first);
+        return stage;
+    }
+
+    @Override
+    public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) {
+        return either(null, other, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,
+            Function<? super T, U> fn) {
+        return either(pool(), other, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn,
+            Executor executor) {
+        return either(required(executor), other, fn);
+    }
+
+    private CompletableFuture<Void> acceptFirst(Executor executor, CompletionStage<? extends T> other,
+            final Consumer<? super T> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return either(executor, other, new Function<T, Void>() {
+            @Override
+            public Void apply(T value) {
+                action.accept(value);
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) {
+        return acceptFirst(null, other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other,
+            Consumer<? super T> action) {
+        return acceptFirst(pool(), other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,
+            Executor executor) {
+        return acceptFirst(required(executor), other, action);
+    }
+
+    @SuppressWarnings("unchecked")
+    private CompletableFuture<Void> runFirst(Executor executor, CompletionStage<?> other, final Runnable action) {
+        if (action == null || other == null) {
+            throw new NullPointerException();
+        }
+        // Only that one of the two completed matters, not with what.
+        CompletableFuture<Object> mine = thenApply(new Function<T, Object>() {
+            @Override
+            public Object apply(T value) {
+                return value;
+            }
+        });
+        return mine.either(executor, (CompletionStage<Object>) other, new Function<Object, Void>() {
+            @Override
+            public Void apply(Object value) {
+                action.run();
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action) {
+        return runFirst(null, other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action) {
+        return runFirst(pool(), other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action,
+            Executor executor) {
+        return runFirst(required(executor), other, action);
+    }
+
+    @Override
+    public CompletableFuture<T> toCompletableFuture() {
+        return this;
+    }
+
+    /// A new future that completes as this one does.
+    public CompletableFuture<T> copy() {
+        return then(null, new Step<T>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<T> stage) {
+                stage.relay(outcome);
+            }
+        });
+    }
+
+    /// A stage that completes as this one does, and that completing does
+    /// not complete this one: a [#copy].
+    ///
+    /// **Not provided: the JDK's refusal.** There the stage answered is of
+    /// a class whose `complete`, `cancel`, `get` and the rest throw
+    /// `UnsupportedOperationException`, and whose `toCompletableFuture`
+    /// answers yet another copy. Here it is an ordinary future, as what
+    /// [#completedStage] and [#failedStage] answer is, so code that casts
+    /// the stage back to a `CompletableFuture`, or calls
+    /// `toCompletableFuture()` on it, and completes that, completes the
+    /// stage its dependents hang off instead of being refused. What the
+    /// method is called for holds either way: whoever is handed the stage
+    /// cannot complete, fail or cancel the future it was made from.
+    public CompletionStage<T> minimalCompletionStage() {
+        return copy();
+    }
+
+    @Override
+    public String toString() {
+        Object outcome = result.get();
+        String state = outcome == null ? "Not completed"
+                : outcome instanceof Failure ? "Completed exceptionally: " + ((Failure) outcome).cause
+                : "Completed normally";
+        return "CompletableFuture[" + state + "]";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CompletionException.java b/Ports/CLDC11/src/java/util/concurrent/CompletionException.java
new file mode 100644
index 00000000000..f5dcae15bd3
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CompletionException.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// `java.util.concurrent.CompletionException`: a stage failed, or the one
+/// it depended on did; the cause is the original exception.
+public class CompletionException extends RuntimeException {
+
+    protected CompletionException() {
+    }
+
+    protected CompletionException(String message) {
+        super(message);
+    }
+
+    public CompletionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public CompletionException(Throwable cause) {
+        super(cause == null ? null : cause.toString(), cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CompletionStage.java b/Ports/CLDC11/src/java/util/concurrent/CompletionStage.java
new file mode 100644
index 00000000000..2b8ac5588d7
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CompletionStage.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/// `java.util.concurrent.CompletionStage`: one step of a computation that
+/// others can be attached to. [CompletableFuture] is the implementation.
+public interface CompletionStage<T> {
+
+    <U> CompletionStage<U> thenApply(Function<? super T, ? extends U> fn);
+
+    <U> CompletionStage<U> thenApplyAsync(Function<? super T, ? extends U> fn);
+
+    <U> CompletionStage<U> thenApplyAsync(Function<? super T, ? extends U> fn, Executor executor);
+
+    CompletionStage<Void> thenAccept(Consumer<? super T> action);
+
+    CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
+
+    CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor);
+
+    CompletionStage<Void> thenRun(Runnable action);
+
+    CompletionStage<Void> thenRunAsync(Runnable action);
+
+    CompletionStage<Void> thenRunAsync(Runnable action, Executor executor);
+
+    <U, V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn);
+
+    <U, V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn);
+
+    <U, V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn, Executor executor);
+
+    <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action);
+
+    <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action);
+
+    <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action, Executor executor);
+
+    CompletionStage<Void> runAfterBoth(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor);
+
+    <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn);
+
+    <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn);
+
+    <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn,
+            Executor executor);
+
+    CompletionStage<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action);
+
+    CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action);
+
+    CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,
+            Executor executor);
+
+    CompletionStage<Void> runAfterEither(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor);
+
+    <U> CompletionStage<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn);
+
+    <U> CompletionStage<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn);
+
+    <U> CompletionStage<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,
+            Executor executor);
+
+    <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
+
+    <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
+
+    <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);
+
+    CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
+
+    CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
+
+    CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor);
+
+    CompletionStage<T> exceptionally(Function<Throwable, ? extends T> fn);
+
+    CompletableFuture<T> toCompletableFuture();
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ConcurrentHashMap.java b/Ports/CLDC11/src/java/util/concurrent/ConcurrentHashMap.java
new file mode 100644
index 00000000000..74d31511a89
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ConcurrentHashMap.java
@@ -0,0 +1,671 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.AbstractCollection;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/// `java.util.concurrent.ConcurrentHashMap` for the Codename One runtime,
+/// over a `HashMap`.
+///
+/// It is safe to use from several threads at once. Every operation holds
+/// the map's monitor, so the compound operations (`putIfAbsent`,
+/// `computeIfAbsent`, `compute`, `merge`, ...) are atomic, and a mapping
+/// function runs while the monitor is held: it must not touch the map. Two
+/// threads never read and write at the same moment, which a device's few
+/// threads rarely notice and which keeps the class small.
+///
+/// It also keeps from the JDK class:
+///
+/// - `null` keys and values are rejected with `NullPointerException`.
+/// - Iterators never throw `ConcurrentModificationException`. Each iterates
+///   over the entries present when it was created, so a loop may add to and
+///   remove from the map it is walking; `Iterator.remove` and
+///   `Map.Entry.setValue` write through to the map.
+///
+/// The bulk parallel operations (`forEach(long, ...)`, `search`, `reduce`)
+/// and `forEachKey`/`forEachValue` are not provided.
+public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final HashMap<K, V> map;
+
+    public ConcurrentHashMap() {
+        map = new HashMap<K, V>();
+    }
+
+    public ConcurrentHashMap(int initialCapacity) {
+        if (initialCapacity < 0) {
+            throw new IllegalArgumentException();
+        }
+        map = new HashMap<K, V>(initialCapacity);
+    }
+
+    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
+        this(initialCapacity, loadFactor, 1);
+    }
+
+    public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
+        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) {
+            throw new IllegalArgumentException();
+        }
+        map = new HashMap<K, V>(initialCapacity);
+    }
+
+    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
+        map = new HashMap<K, V>();
+        putAll(m);
+    }
+
+    private static void requireNonNull(Object o) {
+        if (o == null) {
+            throw new NullPointerException();
+        }
+    }
+
+    @Override
+    public synchronized int size() {
+        return map.size();
+    }
+
+    public synchronized long mappingCount() {
+        return map.size();
+    }
+
+    @Override
+    public synchronized boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public synchronized V get(Object key) {
+        requireNonNull(key);
+        return map.get(key);
+    }
+
+    @Override
+    public synchronized boolean containsKey(Object key) {
+        requireNonNull(key);
+        return map.containsKey(key);
+    }
+
+    @Override
+    public synchronized boolean containsValue(Object value) {
+        requireNonNull(value);
+        return map.containsValue(value);
+    }
+
+    public boolean contains(Object value) {
+        return containsValue(value);
+    }
+
+    @Override
+    public synchronized V put(K key, V value) {
+        requireNonNull(key);
+        requireNonNull(value);
+        return map.put(key, value);
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
+            put(e.getKey(), e.getValue());
+        }
+    }
+
+    @Override
+    public synchronized V remove(Object key) {
+        requireNonNull(key);
+        return map.remove(key);
+    }
+
+    @Override
+    public synchronized void clear() {
+        map.clear();
+    }
+
+    @Override
+    public V getOrDefault(Object key, V defaultValue) {
+        V v = get(key);
+        return v == null ? defaultValue : v;
+    }
+
+    @Override
+    public synchronized V putIfAbsent(K key, V value) {
+        requireNonNull(key);
+        requireNonNull(value);
+        V old = map.get(key);
+        if (old == null) {
+            map.put(key, value);
+        }
+        return old;
+    }
+
+    @Override
+    public synchronized boolean remove(Object key, Object value) {
+        requireNonNull(key);
+        if (value == null) {
+            return false;
+        }
+        V old = map.get(key);
+        if (old != null && old.equals(value)) {
+            map.remove(key);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public synchronized boolean replace(K key, V oldValue, V newValue) {
+        requireNonNull(key);
+        requireNonNull(oldValue);
+        requireNonNull(newValue);
+        V old = map.get(key);
+        if (old != null && old.equals(oldValue)) {
+            map.put(key, newValue);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public synchronized V replace(K key, V value) {
+        requireNonNull(key);
+        requireNonNull(value);
+        V old = map.get(key);
+        if (old != null) {
+            map.put(key, value);
+        }
+        return old;
+    }
+
+    @Override
+    public synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+        requireNonNull(key);
+        requireNonNull(mappingFunction);
+        V old = map.get(key);
+        if (old != null) {
+            return old;
+        }
+        V created = mappingFunction.apply(key);
+        if (created != null) {
+            map.put(key, created);
+        }
+        return created;
+    }
+
+    public synchronized V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        requireNonNull(key);
+        requireNonNull(remappingFunction);
+        V old = map.get(key);
+        if (old == null) {
+            return null;
+        }
+        V updated = remappingFunction.apply(key, old);
+        if (updated == null) {
+            map.remove(key);
+        } else {
+            map.put(key, updated);
+        }
+        return updated;
+    }
+
+    public synchronized V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        requireNonNull(key);
+        requireNonNull(remappingFunction);
+        V old = map.get(key);
+        V updated = remappingFunction.apply(key, old);
+        if (updated == null) {
+            if (old != null) {
+                map.remove(key);
+            }
+        } else {
+            map.put(key, updated);
+        }
+        return updated;
+    }
+
+    public synchronized V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+        requireNonNull(key);
+        requireNonNull(value);
+        requireNonNull(remappingFunction);
+        V old = map.get(key);
+        if (old == null) {
+            map.put(key, value);
+            return value;
+        }
+        V updated = remappingFunction.apply(old, value);
+        if (updated == null) {
+            map.remove(key);
+        } else {
+            map.put(key, updated);
+        }
+        return updated;
+    }
+
+    @Override
+    public void forEach(BiConsumer<? super K, ? super V> action) {
+        requireNonNull(action);
+        for (Map.Entry<K, V> e : snapshot()) {
+            action.accept(e.getKey(), e.getValue());
+        }
+    }
+
+    @Override
+    public synchronized void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+        requireNonNull(function);
+        for (Map.Entry<K, V> e : snapshot()) {
+            V updated = function.apply(e.getKey(), e.getValue());
+            requireNonNull(updated);
+            replace(e.getKey(), updated);
+        }
+    }
+
+    /// The entries present now, as entries that write through to this map.
+    /// Every iterator walks one of these, which is what lets a caller modify
+    /// the map while iterating it.
+    private synchronized List<Map.Entry<K, V>> snapshot() {
+        List<Map.Entry<K, V>> out = new ArrayList<Map.Entry<K, V>>(map.size());
+        for (Map.Entry<K, V> e : map.entrySet()) {
+            out.add(new WriteThroughEntry<K, V>(this, e.getKey(), e.getValue()));
+        }
+        return out;
+    }
+
+    /// The keys, as a view of this map. Compiled code names the JDK's return
+    /// type, `ConcurrentHashMap.KeySetView`, so that is what this returns.
+    @Override
+    public KeySetView<K, V> keySet() {
+        return new KeySetView<K, V>(this, null);
+    }
+
+    public KeySetView<K, V> keySet(V mappedValue) {
+        requireNonNull(mappedValue);
+        return new KeySetView<K, V>(this, mappedValue);
+    }
+
+    public static <K> KeySetView<K, Boolean> newKeySet() {
+        return new KeySetView<K, Boolean>(new ConcurrentHashMap<K, Boolean>(), Boolean.TRUE);
+    }
+
+    public static <K> KeySetView<K, Boolean> newKeySet(int initialCapacity) {
+        return new KeySetView<K, Boolean>(new ConcurrentHashMap<K, Boolean>(initialCapacity), Boolean.TRUE);
+    }
+
+    @Override
+    public Collection<V> values() {
+        return new ValuesView<K, V>(this);
+    }
+
+    @Override
+    public Set<Map.Entry<K, V>> entrySet() {
+        return new EntrySetView<K, V>(this);
+    }
+
+    public Enumeration<K> keys() {
+        return new IteratorEnumeration<K>(keySet().iterator());
+    }
+
+    public Enumeration<V> elements() {
+        return new IteratorEnumeration<V>(values().iterator());
+    }
+
+    private static final class WriteThroughEntry<K, V> implements Map.Entry<K, V> {
+        private final ConcurrentHashMap<K, V> owner;
+        private final K key;
+        private V value;
+
+        WriteThroughEntry(ConcurrentHashMap<K, V> owner, K key, V value) {
+            this.owner = owner;
+            this.key = key;
+            this.value = value;
+        }
+
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValue() {
+            return value;
+        }
+
+        @Override
+        public V setValue(V newValue) {
+            requireNonNull(newValue);
+            V old = value;
+            value = newValue;
+            owner.put(key, newValue);
+            return old;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+            Object otherKey = other.getKey();
+            Object otherValue = other.getValue();
+            return key.equals(otherKey) && value.equals(otherValue);
+        }
+
+        @Override
+        public int hashCode() {
+            return key.hashCode() ^ value.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return key + "=" + value;
+        }
+    }
+
+    /// Walks a snapshot of the entries; `remove` removes the key from the
+    /// live map.
+    private static final class SnapshotIterator<K, V> {
+        private final ConcurrentHashMap<K, V> owner;
+        private final List<Map.Entry<K, V>> entries;
+        private int next;
+        private Map.Entry<K, V> last;
+
+        SnapshotIterator(ConcurrentHashMap<K, V> owner) {
+            this.owner = owner;
+            this.entries = owner.snapshot();
+        }
+
+        boolean hasNext() {
+            return next < entries.size();
+        }
+
+        Map.Entry<K, V> nextEntry() {
+            if (next >= entries.size()) {
+                throw new NoSuchElementException();
+            }
+            last = entries.get(next++);
+            return last;
+        }
+
+        void remove() {
+            if (last == null) {
+                throw new IllegalStateException();
+            }
+            owner.remove(last.getKey());
+            last = null;
+        }
+    }
+
+    private static final class KeyIterator<K, V> implements Iterator<K> {
+        private final SnapshotIterator<K, V> it;
+
+        KeyIterator(ConcurrentHashMap<K, V> owner) {
+            it = new SnapshotIterator<K, V>(owner);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public K next() {
+            return it.nextEntry().getKey();
+        }
+
+        @Override
+        public void remove() {
+            it.remove();
+        }
+    }
+
+    private static final class ValueIterator<K, V> implements Iterator<V> {
+        private final SnapshotIterator<K, V> it;
+
+        ValueIterator(ConcurrentHashMap<K, V> owner) {
+            it = new SnapshotIterator<K, V>(owner);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public V next() {
+            return it.nextEntry().getValue();
+        }
+
+        @Override
+        public void remove() {
+            it.remove();
+        }
+    }
+
+    private static final class EntryIterator<K, V> implements Iterator<Map.Entry<K, V>> {
+        private final SnapshotIterator<K, V> it;
+
+        EntryIterator(ConcurrentHashMap<K, V> owner) {
+            it = new SnapshotIterator<K, V>(owner);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public Map.Entry<K, V> next() {
+            return it.nextEntry();
+        }
+
+        @Override
+        public void remove() {
+            it.remove();
+        }
+    }
+
+    private static final class IteratorEnumeration<T> implements Enumeration<T> {
+        private final Iterator<T> it;
+
+        IteratorEnumeration(Iterator<T> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return it.hasNext();
+        }
+
+        @Override
+        public T nextElement() {
+            return it.next();
+        }
+    }
+
+    private static final class ValuesView<K, V> extends AbstractCollection<V> {
+        private final ConcurrentHashMap<K, V> owner;
+
+        ValuesView(ConcurrentHashMap<K, V> owner) {
+            this.owner = owner;
+        }
+
+        @Override
+        public Iterator<V> iterator() {
+            return new ValueIterator<K, V>(owner);
+        }
+
+        @Override
+        public int size() {
+            return owner.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return o != null && owner.containsValue(o);
+        }
+
+        @Override
+        public void clear() {
+            owner.clear();
+        }
+    }
+
+    private static final class EntrySetView<K, V> extends AbstractSet<Map.Entry<K, V>> {
+        private final ConcurrentHashMap<K, V> owner;
+
+        EntrySetView(ConcurrentHashMap<K, V> owner) {
+            this.owner = owner;
+        }
+
+        @Override
+        public Iterator<Map.Entry<K, V>> iterator() {
+            return new EntryIterator<K, V>(owner);
+        }
+
+        @Override
+        public int size() {
+            return owner.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (key == null || value == null) {
+                return false;
+            }
+            Object mine = owner.get(key);
+            return mine != null && mine.equals(value);
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+            Object key = e.getKey();
+            Object value = e.getValue();
+            return key != null && value != null && owner.remove(key, value);
+        }
+
+        @Override
+        public void clear() {
+            owner.clear();
+        }
+    }
+
+    /// `java.util.concurrent.ConcurrentHashMap.KeySetView`: the keys of a
+    /// map as a set. A view created with a mapped value (`keySet(V)`,
+    /// `newKeySet()`) also accepts `add`, which maps the key to that value.
+    public static class KeySetView<K, V> extends AbstractSet<K> implements java.io.Serializable {
+
+        private static final long serialVersionUID = 1L;
+
+        private final ConcurrentHashMap<K, V> owner;
+        private final V value;
+
+        KeySetView(ConcurrentHashMap<K, V> owner, V value) {
+            this.owner = owner;
+            this.value = value;
+        }
+
+        /// The map this is a view of. It is the live map, as in the JDK:
+        /// the view exists to share it.
+        public ConcurrentHashMap<K, V> getMap() {
+            return owner;
+        }
+
+        public V getMappedValue() {
+            return value;
+        }
+
+        @Override
+        public Iterator<K> iterator() {
+            return new KeyIterator<K, V>(owner);
+        }
+
+        @Override
+        public int size() {
+            return owner.size();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return owner.isEmpty();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return owner.containsKey(o);
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            return owner.remove(o) != null;
+        }
+
+        @Override
+        public void clear() {
+            owner.clear();
+        }
+
+        @Override
+        public boolean add(K e) {
+            if (value == null) {
+                throw new UnsupportedOperationException();
+            }
+            return owner.putIfAbsent(e, value) == null;
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends K> c) {
+            boolean added = false;
+            for (K e : c) {
+                if (add(e)) {
+                    added = true;
+                }
+            }
+            return added;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ConcurrentMap.java b/Ports/CLDC11/src/java/util/concurrent/ConcurrentMap.java
new file mode 100644
index 00000000000..d16859b9d4f
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ConcurrentMap.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *  
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Codename One through http://www.codenameone.com/ if you 
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.Map;
+
+/// A map whose compound operations are atomic. The four methods it declares
+/// are default methods of `Map` as well; an implementation makes them atomic.
+public interface ConcurrentMap<K,V> extends Map<K,V> {
+    public V putIfAbsent(K key, V value);
+    public boolean remove(Object key, Object value);
+    public V replace(K key, V value);
+    public boolean replace(K key, V oldValue, V newValue);
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CopyOnWriteArrayList.java b/Ports/CLDC11/src/java/util/concurrent/CopyOnWriteArrayList.java
new file mode 100644
index 00000000000..dae26e4fbb0
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CopyOnWriteArrayList.java
@@ -0,0 +1,572 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.RandomAccess;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
+/// `java.util.concurrent.CopyOnWriteArrayList` for the Codename One runtime.
+///
+/// Every mutation replaces the backing array with a modified copy, and an
+/// iterator keeps the array that was current when it was created. That is the
+/// property listener lists rely on, and it matters on a single thread as much
+/// as across threads: a listener that removes itself, or adds another, while
+/// the list is being walked to deliver an event neither disturbs the walk nor
+/// throws `ConcurrentModificationException`.
+///
+/// It is safe to use from several threads at once: mutations are made one
+/// at a time under an internal lock, and reads take the current array.
+///
+/// Iterators are read only, as in the JDK: `remove`, `set` and `add` on one
+/// throw `UnsupportedOperationException`. `subList` differs from the JDK: it
+/// returns an unmodifiable copy of the range instead of a live view.
+public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final Object[] EMPTY = new Object[0];
+
+    private Object[] array;
+    /// Guards [#array]; every mutation runs whole under it, so two threads
+    /// never both copy the same array and lose one of their changes.
+    private final transient Object lock = new Object();
+
+    private Object[] getArray() {
+        synchronized (lock) {
+            return array;
+        }
+    }
+
+    private void setArray(Object[] a) {
+        synchronized (lock) {
+            array = a;
+        }
+    }
+
+    public CopyOnWriteArrayList() {
+        setArray(EMPTY);
+    }
+
+    public CopyOnWriteArrayList(Collection<? extends E> c) {
+        setArray(c.toArray());
+    }
+
+    public CopyOnWriteArrayList(E[] toCopyIn) {
+        Object[] copy = new Object[toCopyIn.length];
+        System.arraycopy(toCopyIn, 0, copy, 0, copy.length);
+        setArray(copy);
+    }
+
+    private CopyOnWriteArrayList(Object[] shared, boolean marker) {
+        setArray(shared);
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    private static int indexOf(Object o, Object[] elements, int from, int to) {
+        for (int i = from; i < to; i++) {
+            if (same(o, elements[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static int lastIndexOf(Object o, Object[] elements, int from) {
+        for (int i = from; i >= 0; i--) {
+            if (same(o, elements[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T element(Object[] elements, int index) {
+        return (T) elements[index];
+    }
+
+    @Override
+    public int size() {
+        return getArray().length;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return getArray().length == 0;
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        Object[] elements = getArray();
+        return indexOf(o, elements, 0, elements.length) >= 0;
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        Object[] elements = getArray();
+        return indexOf(o, elements, 0, elements.length);
+    }
+
+    public int indexOf(E e, int index) {
+        Object[] elements = getArray();
+        return indexOf(e, elements, index, elements.length);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        Object[] elements = getArray();
+        return lastIndexOf(o, elements, elements.length - 1);
+    }
+
+    public int lastIndexOf(E e, int index) {
+        return lastIndexOf(e, getArray(), index);
+    }
+
+    /// A list sharing this one's current array. Neither list ever writes to
+    /// an array it has published, so the two are independent from here on,
+    /// which is all a copy has to be.
+    @Override
+    public Object clone() {
+        return new CopyOnWriteArrayList<E>(getArray(), true);
+    }
+
+    @Override
+    public Object[] toArray() {
+        Object[] elements = getArray();
+        Object[] copy = new Object[elements.length];
+        System.arraycopy(elements, 0, copy, 0, elements.length);
+        return copy;
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        Object[] elements = getArray();
+        if (a.length < elements.length) {
+            // Only a collection can create an array of the caller's type
+            // without reflection.
+            return new ArrayList<Object>(Arrays.asList(elements)).toArray(a);
+        }
+        System.arraycopy(elements, 0, a, 0, elements.length);
+        if (a.length > elements.length) {
+            a[elements.length] = null;
+        }
+        return a;
+    }
+
+    @Override
+    public E get(int index) {
+        return element(getArray(), index);
+    }
+
+    @Override
+    public E set(int index, E element) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            E old = element(elements, index);
+            if (old != element) {
+                Object[] copy = new Object[elements.length];
+                System.arraycopy(elements, 0, copy, 0, elements.length);
+                copy[index] = element;
+                setArray(copy);
+            }
+            return old;
+        }
+    }
+
+    @Override
+    public boolean add(E e) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            Object[] copy = new Object[elements.length + 1];
+            System.arraycopy(elements, 0, copy, 0, elements.length);
+            copy[elements.length] = e;
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public void add(int index, E element) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            int len = elements.length;
+            if (index > len || index < 0) {
+                throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + len);
+            }
+            Object[] copy = new Object[len + 1];
+            System.arraycopy(elements, 0, copy, 0, index);
+            System.arraycopy(elements, index, copy, index + 1, len - index);
+            copy[index] = element;
+            setArray(copy);
+        }
+    }
+
+    @Override
+    public E remove(int index) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            int len = elements.length;
+            E old = element(elements, index);
+            Object[] copy = new Object[len - 1];
+            System.arraycopy(elements, 0, copy, 0, index);
+            System.arraycopy(elements, index + 1, copy, index, len - index - 1);
+            setArray(copy);
+            return old;
+        }
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            int index = indexOf(o, elements, 0, elements.length);
+            if (index < 0) {
+                return false;
+            }
+            remove(index);
+            return true;
+        }
+    }
+
+    public boolean addIfAbsent(E e) {
+        synchronized (lock) {
+            if (contains(e)) {
+                return false;
+            }
+            return add(e);
+        }
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        Object[] elements = getArray();
+        for (Object e : c) {
+            if (indexOf(e, elements, 0, elements.length) < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Keeps the elements for which membership in `c` equals `keep`.
+    private boolean filter(Collection<?> c, boolean keep) {
+        synchronized (lock) {
+            if (c == null) {
+                throw new NullPointerException();
+            }
+            Object[] elements = getArray();
+            Object[] kept = new Object[elements.length];
+            int n = 0;
+            for (int i = 0; i < elements.length; i++) {
+                if (c.contains(elements[i]) == keep) {
+                    kept[n++] = elements[i];
+                }
+            }
+            if (n == elements.length) {
+                return false;
+            }
+            Object[] copy = new Object[n];
+            System.arraycopy(kept, 0, copy, 0, n);
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        return filter(c, false);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return filter(c, true);
+    }
+
+    public int addAllAbsent(Collection<? extends E> c) {
+        synchronized (lock) {
+            int added = 0;
+            for (E e : c) {
+                if (addIfAbsent(e)) {
+                    added++;
+                }
+            }
+            return added;
+        }
+    }
+
+    @Override
+    public void clear() {
+        synchronized (lock) {
+            setArray(EMPTY);
+        }
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        synchronized (lock) {
+            return addAll(getArray().length, c);
+        }
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends E> c) {
+        synchronized (lock) {
+            Object[] incoming = c.toArray();
+            Object[] elements = getArray();
+            int len = elements.length;
+            if (index > len || index < 0) {
+                throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + len);
+            }
+            if (incoming.length == 0) {
+                return false;
+            }
+            Object[] copy = new Object[len + incoming.length];
+            System.arraycopy(elements, 0, copy, 0, index);
+            System.arraycopy(incoming, 0, copy, index, incoming.length);
+            System.arraycopy(elements, index, copy, index + incoming.length, len - index);
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public void forEach(Consumer<? super E> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        Object[] elements = getArray();
+        for (int i = 0; i < elements.length; i++) {
+            action.accept(CopyOnWriteArrayList.<E>element(elements, i));
+        }
+    }
+
+    @Override
+    public boolean removeIf(Predicate<? super E> filter) {
+        synchronized (lock) {
+            if (filter == null) {
+                throw new NullPointerException();
+            }
+            Object[] elements = getArray();
+            Object[] kept = new Object[elements.length];
+            int n = 0;
+            for (int i = 0; i < elements.length; i++) {
+                if (!filter.test(CopyOnWriteArrayList.<E>element(elements, i))) {
+                    kept[n++] = elements[i];
+                }
+            }
+            if (n == elements.length) {
+                return false;
+            }
+            Object[] copy = new Object[n];
+            System.arraycopy(kept, 0, copy, 0, n);
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public void replaceAll(UnaryOperator<E> operator) {
+        synchronized (lock) {
+            if (operator == null) {
+                throw new NullPointerException();
+            }
+            Object[] elements = getArray();
+            Object[] copy = new Object[elements.length];
+            for (int i = 0; i < elements.length; i++) {
+                copy[i] = operator.apply(CopyOnWriteArrayList.<E>element(elements, i));
+            }
+            setArray(copy);
+        }
+    }
+
+    @Override
+    public void sort(Comparator<? super E> c) {
+        synchronized (lock) {
+            Object[] copy = toArray();
+            if (c == null) {
+                Arrays.sort(copy);
+            } else {
+                sortWith(copy, c);
+            }
+            setArray(copy);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> void sortWith(Object[] elements, Comparator<? super T> c) {
+        // Every element was added as an E, which is what T stands for here.
+        Arrays.sort((T[]) elements, c);
+    }
+
+    @Override
+    public String toString() {
+        Object[] elements = getArray();
+        StringBuilder sb = new StringBuilder();
+        sb.append('[');
+        for (int i = 0; i < elements.length; i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(elements[i] == this ? "(this Collection)" : String.valueOf(elements[i]));
+        }
+        return sb.append(']').toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof List)) {
+            return false;
+        }
+        Object[] elements = getArray();
+        Iterator<?> it = ((List<?>) o).iterator();
+        for (int i = 0; i < elements.length; i++) {
+            if (!it.hasNext() || !same(elements[i], it.next())) {
+                return false;
+            }
+        }
+        return !it.hasNext();
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 1;
+        Object[] elements = getArray();
+        for (int i = 0; i < elements.length; i++) {
+            hash = 31 * hash + (elements[i] == null ? 0 : elements[i].hashCode());
+        }
+        return hash;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new SnapshotIterator<E>(getArray(), 0);
+    }
+
+    @Override
+    public ListIterator<E> listIterator() {
+        return new SnapshotIterator<E>(getArray(), 0);
+    }
+
+    @Override
+    public ListIterator<E> listIterator(int index) {
+        Object[] elements = getArray();
+        if (index < 0 || index > elements.length) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        return new SnapshotIterator<E>(elements, index);
+    }
+
+    /// An unmodifiable copy of the range. The JDK returns a live view; code
+    /// that writes through a sublist of a copy-on-write list gets an
+    /// `UnsupportedOperationException` here instead of a lost update.
+    @Override
+    public List<E> subList(int fromIndex, int toIndex) {
+        Object[] elements = getArray();
+        if (fromIndex < 0 || toIndex > elements.length || fromIndex > toIndex) {
+            throw new IndexOutOfBoundsException();
+        }
+        List<E> out = new ArrayList<E>(toIndex - fromIndex);
+        for (int i = fromIndex; i < toIndex; i++) {
+            out.add(CopyOnWriteArrayList.<E>element(elements, i));
+        }
+        return Collections.unmodifiableList(out);
+    }
+
+    private static final class SnapshotIterator<E> implements ListIterator<E> {
+        private final Object[] snapshot;
+        private int cursor;
+
+        SnapshotIterator(Object[] snapshot, int cursor) {
+            this.snapshot = snapshot;
+            this.cursor = cursor;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return cursor < snapshot.length;
+        }
+
+        @Override
+        public boolean hasPrevious() {
+            return cursor > 0;
+        }
+
+        @Override
+        public E next() {
+            if (cursor >= snapshot.length) {
+                throw new NoSuchElementException();
+            }
+            return element(snapshot, cursor++);
+        }
+
+        @Override
+        public E previous() {
+            if (cursor <= 0) {
+                throw new NoSuchElementException();
+            }
+            return element(snapshot, --cursor);
+        }
+
+        @Override
+        public int nextIndex() {
+            return cursor;
+        }
+
+        @Override
+        public int previousIndex() {
+            return cursor - 1;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void set(E e) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void add(E e) {
+            throw new UnsupportedOperationException();
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CopyOnWriteArraySet.java b/Ports/CLDC11/src/java/util/concurrent/CopyOnWriteArraySet.java
new file mode 100644
index 00000000000..6baaee33ec2
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CopyOnWriteArraySet.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.AbstractSet;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/// `java.util.concurrent.CopyOnWriteArraySet` for the Codename One runtime:
+/// a set kept in a [CopyOnWriteArrayList], in the order its elements were
+/// added.
+///
+/// Every mutation replaces the backing array with a modified copy, and an
+/// iterator keeps the array that was current when it was created, so a
+/// listener that removes itself while the set is being walked neither
+/// disturbs the walk nor throws `ConcurrentModificationException`. Iterators
+/// are read only, as in the JDK.
+///
+/// It is as safe to use from several threads at once as the list it is
+/// kept in.
+public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final CopyOnWriteArrayList<E> al;
+
+    public CopyOnWriteArraySet() {
+        al = new CopyOnWriteArrayList<E>();
+    }
+
+    public CopyOnWriteArraySet(Collection<? extends E> c) {
+        al = new CopyOnWriteArrayList<E>();
+        al.addAllAbsent(c);
+    }
+
+    @Override
+    public int size() {
+        return al.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return al.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return al.contains(o);
+    }
+
+    @Override
+    public Object[] toArray() {
+        return al.toArray();
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        return al.toArray(a);
+    }
+
+    @Override
+    public void clear() {
+        al.clear();
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return al.remove(o);
+    }
+
+    @Override
+    public boolean add(E e) {
+        return al.addIfAbsent(e);
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        return al.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        return al.addAllAbsent(c) > 0;
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        return al.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return al.retainAll(c);
+    }
+
+    /// The elements as they were when this was called, in the order they
+    /// were added. `remove` on the iterator throws
+    /// `UnsupportedOperationException`.
+    @Override
+    public Iterator<E> iterator() {
+        return al.iterator();
+    }
+
+    public boolean removeIf(Predicate<? super E> filter) {
+        return al.removeIf(filter);
+    }
+
+    @Override
+    public void forEach(Consumer<? super E> action) {
+        al.forEach(action);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/CountDownLatch.java b/Ports/CLDC11/src/java/util/concurrent/CountDownLatch.java
new file mode 100644
index 00000000000..7b16a74db90
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/CountDownLatch.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/// `java.util.concurrent.CountDownLatch`: threads wait until a count
+/// reaches zero. It is safe to use from any number of threads. Waiting on
+/// the UI thread goes through `JdkHost.blockUi`, which keeps events being
+/// dispatched.
+public class CountDownLatch {
+
+    private final AtomicLong count;
+    private final CompletableFuture<Boolean> open = new CompletableFuture<Boolean>();
+
+    public CountDownLatch(int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("count < 0");
+        }
+        this.count = new AtomicLong(count);
+        if (count == 0) {
+            open.complete(Boolean.TRUE);
+        }
+    }
+
+    public void countDown() {
+        while (true) {
+            long c = count.get();
+            if (c == 0) {
+                return;
+            }
+            if (count.compareAndSet(c, c - 1)) {
+                if (c == 1) {
+                    open.complete(Boolean.TRUE);
+                }
+                return;
+            }
+        }
+    }
+
+    public long getCount() {
+        return count.get();
+    }
+
+    public void await() throws InterruptedException {
+        try {
+            open.get();
+        } catch (ExecutionException e) {
+            // The latch is only ever opened; there is no failure to report.
+            return;
+        }
+    }
+
+    public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
+        try {
+            open.get(timeout, unit);
+            return true;
+        } catch (ExecutionException e) {
+            return true;
+        } catch (TimeoutException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "CountDownLatch[Count = " + count.get() + "]";
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/Delayed.java b/Ports/CLDC11/src/java/util/concurrent/Delayed.java
new file mode 100644
index 00000000000..b533f4b684d
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/Delayed.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Something that is due after a delay, ordered by when it is due.
+public interface Delayed extends Comparable<Delayed> {
+
+    /// How long until this is due in `unit`; zero or negative once it is.
+    long getDelay(TimeUnit unit);
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/Delays.java b/Ports/CLDC11/src/java/util/concurrent/Delays.java
new file mode 100644
index 00000000000..7ee508930a3
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/Delays.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// Runs an action after a delay, for everything in this package that
+/// waits: the timeouts of [CompletableFuture] and the work of a
+/// [ScheduledPool]. One thread serves them all, and it ends when nothing
+/// is waiting.
+///
+/// #### Why not `java.util.Timer`
+///
+/// A device's `Timer` starts a thread for every task it is given, which
+/// sleeps for the whole delay; a cancelled task is not looked at again
+/// until that sleep is over. A request that sets a long timeout on a
+/// future which then completes at once -- the ordinary case of a timeout --
+/// left a thread asleep until the deadline, one per request, and enough of
+/// them use up the threads a process may have. Here a cancelled wait is
+/// taken out of the queue at once and holds nothing.
+///
+/// An action runs on the waiting thread, so it must be short: hand real
+/// work to a pool, as [ScheduledPool] does.
+final class Delays {
+
+    /// One wait: [#cancel] it to give it up.
+    static final class Handle {
+        private final long due;
+        private Runnable action;
+
+        Handle(long due, Runnable action) {
+            this.due = due;
+            this.action = action;
+        }
+
+        /// Gives the wait up. Does nothing once the action has started.
+        void cancel() {
+            synchronized (LOCK) {
+                action = null;
+                // Woken so that a thread with nothing left to wait for ends
+                // now and not at a deadline nobody is waiting on.
+                if (QUEUE.remove(this)) {
+                    LOCK.notifyAll();
+                }
+            }
+        }
+    }
+
+    private static final Object LOCK = new Object();
+    /// Ordered by the time each is due; equal times in the order given.
+    private static final List<Handle> QUEUE = new ArrayList<Handle>();
+    private static boolean running;
+
+    private Delays() {
+    }
+
+    /// Runs `action` once `millis` have passed.
+    static Handle after(long millis, Runnable action) {
+        // A delay too long to add to the clock (Long.MAX_VALUE as "never",
+        // say) is due at the end of time rather than wrapping into the past.
+        long now = System.currentTimeMillis();
+        long due = millis > Long.MAX_VALUE - now ? Long.MAX_VALUE : now + Math.max(0, millis);
+        Handle handle = new Handle(due, action);
+        synchronized (LOCK) {
+            int at = QUEUE.size();
+            while (at > 0 && QUEUE.get(at - 1).due > handle.due) {
+                at--;
+            }
+            QUEUE.add(at, handle);
+            if (running) {
+                LOCK.notifyAll();
+            } else {
+                running = true;
+                Thread t = new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+                        serve();
+                    }
+                }, "cn1-delays");
+                // A wait nobody gives up (a timeout of Long.MAX_VALUE) must
+                // not keep a program from ending, as the JDK's own delay
+                // thread does not.
+                t.setDaemon(true);
+                t.start();
+            }
+        }
+        return handle;
+    }
+
+    /// How many waits are queued: what a test asks to see that a cancelled
+    /// one is gone.
+    static int pending() {
+        synchronized (LOCK) {
+            return QUEUE.size();
+        }
+    }
+
+    private static void serve() {
+        while (true) {
+            Runnable action = next();
+            if (action == null) {
+                return;
+            }
+            try {
+                action.run();
+            } catch (Throwable t) {
+                // One action that fails must not end the thread the others
+                // wait on.
+                JdkHost.get().log(JdkHost.LOG_ERROR, "Exception in a delayed action: " + t, t);
+            }
+        }
+    }
+
+    /// The next action that is due, waiting for it; null when the queue is
+    /// empty, with the thread marked as gone under the same lock a new wait
+    /// would start one under.
+    private static Runnable next() {
+        synchronized (LOCK) {
+            while (true) {
+                if (QUEUE.isEmpty()) {
+                    running = false;
+                    return null;
+                }
+                Handle first = QUEUE.get(0);
+                long wait = first.due - System.currentTimeMillis();
+                if (wait <= 0) {
+                    QUEUE.remove(0);
+                    Runnable action = first.action;
+                    first.action = null;
+                    if (action != null) {
+                        return action;
+                    }
+                    continue;
+                }
+                try {
+                    LOCK.wait(wait);
+                } catch (InterruptedException e) {
+                    // Nothing interrupts this thread to stop it: the queue
+                    // says when it is done.
+                    continue;
+                }
+            }
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ExecutionException.java b/Ports/CLDC11/src/java/util/concurrent/ExecutionException.java
new file mode 100644
index 00000000000..904d3dec7fd
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ExecutionException.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *  
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Codename One through http://www.codenameone.com/ if you 
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Thrown by [Future#get] when the work failed; the cause is what it threw.
+public class ExecutionException extends Exception {
+    /// An exception with no message or cause.
+    public ExecutionException() { }
+
+    /// An exception with `message`.
+    ///
+    /// @param message the detail message
+    public ExecutionException(String message) { super(message); }
+
+    /// An exception with `message` and the failure that caused it.
+    ///
+    /// @param message the detail message
+    /// @param cause what the work threw
+    public ExecutionException(String message, Throwable cause) { super(message, cause); }
+
+    /// An exception wrapping the failure that caused it.
+    ///
+    /// @param cause what the work threw
+    public ExecutionException(Throwable cause) { super(cause); }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/Executor.java b/Ports/CLDC11/src/java/util/concurrent/Executor.java
new file mode 100644
index 00000000000..eacd1807186
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/Executor.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Runs submitted tasks, on a thread of its choosing.
+public interface Executor {
+
+    /// Runs `command` at some time in the future.
+    void execute(Runnable command);
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ExecutorService.java b/Ports/CLDC11/src/java/util/concurrent/ExecutorService.java
new file mode 100644
index 00000000000..10696bd4dba
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ExecutorService.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.Collection;
+import java.util.List;
+
+/// An [Executor] that answers a [Future] for a submitted task and can be
+/// shut down. [Executors] creates the implementations;
+/// [AbstractExecutorService] provides everything but the execution itself.
+public interface ExecutorService extends Executor {
+
+    /// Stops accepting tasks. The ones already submitted still run.
+    void shutdown();
+
+    /// Stops accepting tasks, drops the ones that have not started and
+    /// answers them, and interrupts the ones that are running.
+    List<Runnable> shutdownNow();
+
+    boolean isShutdown();
+
+    /// Whether the service was shut down and every task it accepted has
+    /// finished or been dropped.
+    boolean isTerminated();
+
+    /// Waits until the service has terminated or the time is up, and answers
+    /// which of the two it was.
+    boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
+
+    <T> Future<T> submit(Callable<T> task);
+
+    <T> Future<T> submit(Runnable task, T result);
+
+    Future<?> submit(Runnable task);
+
+    /// Runs every task and answers their futures, all of them done.
+    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
+
+    /// Runs every task and answers their futures once all are done or the
+    /// time is up; the ones not done by then are cancelled.
+    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException;
+
+    /// The result of one of the tasks that completed without failing; the
+    /// others are cancelled.
+    <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
+
+    /// As [#invokeAny(Collection)], giving up with a [TimeoutException] when
+    /// no task has succeeded in time.
+    <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException;
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/Executors.java b/Ports/CLDC11/src/java/util/concurrent/Executors.java
new file mode 100644
index 00000000000..600d58c0ec5
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/Executors.java
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/// Factories for the executor services.
+///
+/// #### Where a task runs
+///
+/// On the pool's own threads, never on the UI thread. A task that touches
+/// the user interface hands that part back, the way desktop code does with
+/// `SwingUtilities.invokeLater` or `Platform.runLater`.
+///
+/// Workers are started when a task first needs one and share one queue: a
+/// task goes to whichever worker is free. A fixed pool keeps its workers
+/// until it is shut down; a cached pool starts one whenever none is free and
+/// lets one go after a minute without work, as the JDK's do. The overloads
+/// that take a [ThreadFactory] make their workers with it.
+///
+/// #### Waiting
+///
+/// `Future.get()` and `awaitTermination` on the UI thread wait through
+/// `JdkHost.blockUi`, so events keep being dispatched.
+///
+/// The work stealing pools are fixed pools.
+public class Executors {
+
+    /// How long a cached pool's idle worker waits for work before it ends.
+    private static final long CACHED_KEEP_ALIVE_MILLIS = 60000L;
+
+    /// How many workers a work stealing pool without a size has.
+    private static final int WORK_STEALING_WORKERS = 4;
+
+    private Executors() {
+    }
+
+    public static ExecutorService newFixedThreadPool(int nThreads) {
+        return newFixedThreadPool(nThreads, defaultThreadFactory());
+    }
+
+    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
+        if (nThreads <= 0) {
+            throw new IllegalArgumentException();
+        }
+        return new Pool(nThreads, 0, requireFactory(threadFactory));
+    }
+
+    public static ExecutorService newSingleThreadExecutor() {
+        return newSingleThreadExecutor(defaultThreadFactory());
+    }
+
+    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
+        return new Pool(1, 0, requireFactory(threadFactory));
+    }
+
+    public static ExecutorService newCachedThreadPool() {
+        return newCachedThreadPool(defaultThreadFactory());
+    }
+
+    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
+        return new Pool(Integer.MAX_VALUE, CACHED_KEEP_ALIVE_MILLIS, requireFactory(threadFactory));
+    }
+
+    /// A pool for work that splits itself up: here, a fixed pool.
+    public static ExecutorService newWorkStealingPool() {
+        return newFixedThreadPool(WORK_STEALING_WORKERS);
+    }
+
+    public static ExecutorService newWorkStealingPool(int parallelism) {
+        return newFixedThreadPool(parallelism);
+    }
+
+    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
+        return newScheduledThreadPool(corePoolSize, defaultThreadFactory());
+    }
+
+    /// Zero is accepted, as the JDK accepts it: a zero sized scheduled pool
+    /// still starts a worker for the first task it is given.
+    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {
+        if (corePoolSize < 0) {
+            throw new IllegalArgumentException();
+        }
+        return new ScheduledPool(new Pool(Math.max(1, corePoolSize), 0, requireFactory(threadFactory)));
+    }
+
+    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
+        return newScheduledThreadPool(1);
+    }
+
+    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
+        return newScheduledThreadPool(1, threadFactory);
+    }
+
+    /// The factory the executors use by default: non-daemon threads named
+    /// `pool-N-thread-M`.
+    public static ThreadFactory defaultThreadFactory() {
+        return new DefaultThreadFactory(false);
+    }
+
+    /// A `Callable` that runs `task` and answers `result`.
+    public static <T> Callable<T> callable(Runnable task, T result) {
+        if (task == null) {
+            throw new NullPointerException();
+        }
+        return new RunnableAdapter<T>(task, result);
+    }
+
+    public static Callable<Object> callable(Runnable task) {
+        return callable(task, null);
+    }
+
+    private static ThreadFactory requireFactory(ThreadFactory threadFactory) {
+        if (threadFactory == null) {
+            throw new NullPointerException();
+        }
+        return threadFactory;
+    }
+
+    static final class RunnableAdapter<T> implements Callable<T> {
+        private final Runnable task;
+        private final T result;
+
+        RunnableAdapter(Runnable task, T result) {
+            this.task = task;
+            this.result = result;
+        }
+
+        public T call() {
+            task.run();
+            return result;
+        }
+    }
+
+    static final class DefaultThreadFactory implements ThreadFactory {
+        private static final Object COUNT_LOCK = new Object();
+        private static int pools;
+
+        private final String prefix;
+        private final boolean daemon;
+        private int threads;
+
+        DefaultThreadFactory(boolean daemon) {
+            int n;
+            synchronized (COUNT_LOCK) {
+                n = ++pools;
+            }
+            this.prefix = "pool-" + n + "-thread-";
+            this.daemon = daemon;
+        }
+
+        public Thread newThread(Runnable r) {
+            int n;
+            synchronized (this) {
+                n = ++threads;
+            }
+            Thread t = new Thread(r, prefix + n);
+            if (daemon) {
+                t.setDaemon(true);
+            }
+            return t;
+        }
+    }
+
+    /// The thread pool every factory above hands out: workers started on
+    /// demand, up to `maxWorkers`, sharing one queue. Everything is guarded
+    /// by the queue's monitor; the backend submits from many threads at once.
+    static final class Pool extends AbstractExecutorService {
+        private final LinkedList<Runnable> queue = new LinkedList<Runnable>();
+        private final List<Thread> workers = new ArrayList<Thread>();
+        private final int maxWorkers;
+        /// How long an idle worker waits for work before ending; 0 is forever.
+        private final long keepAliveMillis;
+        private final ThreadFactory factory;
+        /// Workers waiting for work.
+        private int idle;
+        private boolean shutdown;
+        /// Set by shutdownNow: workers stop without draining the queue.
+        private boolean stop;
+
+        Pool(int maxWorkers, long keepAliveMillis, ThreadFactory factory) {
+            this.maxWorkers = maxWorkers;
+            this.keepAliveMillis = keepAliveMillis;
+            this.factory = factory;
+        }
+
+        public void execute(Runnable command) {
+            if (command == null) {
+                throw new NullPointerException();
+            }
+            Thread started = null;
+            synchronized (queue) {
+                if (shutdown) {
+                    throw new RejectedExecutionException("The executor has been shut down");
+                }
+                queue.add(command);
+                if (queue.size() > idle && workers.size() < maxWorkers) {
+                    Thread t = factory.newThread(new Worker());
+                    if (t == null) {
+                        if (workers.isEmpty()) {
+                            queue.removeLast();
+                            throw new RejectedExecutionException("The thread factory made no thread");
+                        }
+                    } else {
+                        workers.add(t);
+                        started = t;
+                    }
+                } else {
+                    queue.notify();
+                }
+            }
+            if (started != null) {
+                started.start();
+            }
+        }
+
+        public void shutdown() {
+            synchronized (queue) {
+                shutdown = true;
+                queue.notifyAll();
+            }
+        }
+
+        public List<Runnable> shutdownNow() {
+            List<Runnable> pending;
+            List<Thread> running;
+            synchronized (queue) {
+                shutdown = true;
+                stop = true;
+                pending = new ArrayList<Runnable>(queue);
+                queue.clear();
+                running = new ArrayList<Thread>(workers);
+                queue.notifyAll();
+            }
+            for (int i = 0; i < running.size(); i++) {
+                running.get(i).interrupt();
+            }
+            return pending;
+        }
+
+        public boolean isShutdown() {
+            synchronized (queue) {
+                return shutdown;
+            }
+        }
+
+        public boolean isTerminated() {
+            synchronized (queue) {
+                return terminated();
+            }
+        }
+
+        /// Called holding the queue's monitor.
+        boolean terminated() {
+            return shutdown && workers.isEmpty() && queue.isEmpty();
+        }
+
+        public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+            if (unit == null) {
+                throw new NullPointerException();
+            }
+            if (!isTerminated()) {
+                new Termination(this, BlockingWait.deadline(unit.toMillis(timeout))).await();
+            }
+            return isTerminated();
+        }
+
+        /// The next task for the calling worker, or null when it is to end;
+        /// a worker that ends is taken off the list here, under the lock.
+        Runnable next(Thread self) {
+            synchronized (queue) {
+                while (true) {
+                    if (stop || (queue.isEmpty() && shutdown)) {
+                        retire(self);
+                        return null;
+                    }
+                    if (!queue.isEmpty()) {
+                        return queue.removeFirst();
+                    }
+                    idle++;
+                    boolean timedOut = false;
+                    try {
+                        if (keepAliveMillis > 0) {
+                            long before = System.currentTimeMillis();
+                            queue.wait(keepAliveMillis);
+                            timedOut = System.currentTimeMillis() - before >= keepAliveMillis;
+                        } else {
+                            queue.wait();
+                        }
+                    } catch (InterruptedException e) {
+                        // shutdownNow interrupts; the flags above say what to do.
+                        timedOut = false;
+                    } finally {
+                        idle--;
+                    }
+                    if (timedOut && queue.isEmpty()) {
+                        retire(self);
+                        return null;
+                    }
+                }
+            }
+        }
+
+        private void retire(Thread self) {
+            workers.remove(self);
+            if (terminated()) {
+                queue.notifyAll();
+            }
+        }
+
+        /// Whether shutdownNow has been called; read by a worker between tasks.
+        boolean stopping() {
+            synchronized (queue) {
+                return stop;
+            }
+        }
+
+        final class Worker implements Runnable {
+            public void run() {
+                Thread self = Thread.currentThread();
+                while (true) {
+                    Runnable task = next(self);
+                    if (task == null) {
+                        return;
+                    }
+                    // An interrupt meant for the last task, or for an idle
+                    // wait, must not reach this one -- unless the pool is
+                    // stopping, which is what the interrupt then says.
+                    if (!stopping()) {
+                        Thread.interrupted();
+                    }
+                    try {
+                        task.run();
+                    } catch (Throwable t) {
+                        JdkHost.get().log(JdkHost.LOG_ERROR,
+                                "Exception in thread \"" + self.getName() + "\" " + t, t);
+                    }
+                }
+            }
+        }
+
+        private static final class Termination extends BlockingWait {
+            private final Pool pool;
+
+            Termination(Pool pool, long deadline) {
+                super(pool.queue, deadline);
+                this.pool = pool;
+            }
+
+            boolean ready() {
+                return pool.terminated();
+            }
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/Future.java b/Ports/CLDC11/src/java/util/concurrent/Future.java
new file mode 100644
index 00000000000..5367df903c5
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/Future.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *  
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Codename One through http://www.codenameone.com/ if you 
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// The result of work that finishes later -- on the backend, what an `@Async`
+/// method returns, completed when its body has run on its executor.
+///
+/// @param <V> the type of the result
+public interface Future<V> {
+    /// Stops the work if it has not started. Answers whether it was cancelled;
+    /// whether work already running is interrupted is up to the implementation
+    /// and to `mayInterruptIfRunning`.
+    ///
+    /// @param mayInterruptIfRunning whether a running task may be interrupted
+    /// @return true when this call cancelled it
+    boolean cancel(boolean mayInterruptIfRunning);
+
+    /// Whether [#cancel] cancelled the work before it ran.
+    ///
+    /// @return true when cancelled
+    boolean isCancelled();
+
+    /// Whether the work has finished: completed, failed or cancelled.
+    ///
+    /// @return true once it will not change again
+    boolean isDone();
+
+    /// Waits for the work to finish and returns its result.
+    ///
+    /// @return the result
+    /// @throws InterruptedException when the waiting thread is interrupted
+    /// @throws ExecutionException when the work threw; [Throwable#getCause] is
+    /// what it threw
+    /// @throws CancellationException when the work was cancelled
+    V get() throws InterruptedException, ExecutionException;
+
+    /// Waits up to `timeout` for the work to finish and returns its result.
+    ///
+    /// @param timeout how long to wait, in `unit`
+    /// @param unit the unit of `timeout`
+    /// @return the result
+    /// @throws InterruptedException when the waiting thread is interrupted
+    /// @throws ExecutionException when the work threw
+    /// @throws TimeoutException when it has not finished in time
+    /// @throws CancellationException when the work was cancelled
+    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/FutureTask.java b/Ports/CLDC11/src/java/util/concurrent/FutureTask.java
new file mode 100644
index 00000000000..853e074889c
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/FutureTask.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// A cancellable computation whose result is read through [Future].
+///
+/// The state lives under this object's monitor, so it may be run, cancelled
+/// and waited for from any number of threads. `get()` on the UI thread waits
+/// through `JdkHost.blockUi`, which keeps events being dispatched.
+///
+/// `cancel(true)` interrupts the thread running the task, as in the JDK.
+public class FutureTask<V> implements RunnableFuture<V> {
+    private static final int NEW = 0;
+    private static final int NORMAL = 1;
+    private static final int EXCEPTIONAL = 2;
+    private static final int CANCELLED = 3;
+
+    /// Null once the task has run, so that it does not hold what it captured.
+    private Callable<V> callable;
+    private int state;
+    private Object outcome;
+    /// The thread inside [#run], so that `cancel(true)` can interrupt it.
+    private Thread runner;
+
+    public FutureTask(Callable<V> callable) {
+        if (callable == null) {
+            throw new NullPointerException();
+        }
+        this.callable = callable;
+    }
+
+    public FutureTask(Runnable runnable, V result) {
+        if (runnable == null) {
+            throw new NullPointerException();
+        }
+        this.callable = Executors.callable(runnable, result);
+    }
+
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        synchronized (this) {
+            if (state != NEW) {
+                return false;
+            }
+            state = CANCELLED;
+            callable = null;
+            if (mayInterruptIfRunning && runner != null) {
+                runner.interrupt();
+            }
+            notifyAll();
+        }
+        done();
+        return true;
+    }
+
+    public boolean isCancelled() {
+        synchronized (this) {
+            return state == CANCELLED;
+        }
+    }
+
+    public boolean isDone() {
+        synchronized (this) {
+            return state != NEW;
+        }
+    }
+
+    /// Called once when the task becomes done, by whichever thread made it
+    /// so: completion, failure or cancellation. Does nothing here.
+    protected void done() {
+    }
+
+    /// Completes the future with `v`, unless it is already done.
+    protected void set(V v) {
+        if (finish(NORMAL, v)) {
+            done();
+        }
+    }
+
+    /// Fails the future with `t`, unless it is already done.
+    protected void setException(Throwable t) {
+        if (finish(EXCEPTIONAL, t)) {
+            done();
+        }
+    }
+
+    private boolean finish(int to, Object value) {
+        synchronized (this) {
+            if (state != NEW) {
+                return false;
+            }
+            state = to;
+            outcome = value;
+            callable = null;
+            notifyAll();
+            return true;
+        }
+    }
+
+    public V get() throws InterruptedException, ExecutionException {
+        if (!isDone()) {
+            new Wait(this, BlockingWait.FOREVER).await();
+        }
+        return report();
+    }
+
+    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (!isDone()) {
+            new Wait(this, BlockingWait.deadline(unit.toMillis(timeout))).await();
+            if (!isDone()) {
+                throw new TimeoutException();
+            }
+        }
+        return report();
+    }
+
+    @SuppressWarnings("unchecked")
+    private V report() throws ExecutionException {
+        int s;
+        Object o;
+        synchronized (this) {
+            s = state;
+            o = outcome;
+        }
+        if (s == CANCELLED) {
+            throw new CancellationException();
+        }
+        if (s == EXCEPTIONAL) {
+            throw new ExecutionException((Throwable) o);
+        }
+        return (V) o;
+    }
+
+    public void run() {
+        Callable<V> c = claim();
+        if (c == null) {
+            return;
+        }
+        V v;
+        try {
+            v = c.call();
+        } catch (Throwable t) {
+            release();
+            setException(t);
+            return;
+        }
+        release();
+        set(v);
+    }
+
+    /// Runs the task without setting a result, leaving the future ready to
+    /// run again: for work that repeats. False when the task failed, was
+    /// cancelled, or was not runnable.
+    protected boolean runAndReset() {
+        Callable<V> c = claim();
+        if (c == null) {
+            return false;
+        }
+        try {
+            c.call();
+        } catch (Throwable t) {
+            release();
+            setException(t);
+            return false;
+        }
+        release();
+        return !isDone();
+    }
+
+    /// The callable, with this thread recorded as its runner; null when the
+    /// task is done or another thread is running it.
+    private Callable<V> claim() {
+        synchronized (this) {
+            if (state != NEW || runner != null) {
+                return null;
+            }
+            runner = Thread.currentThread();
+            return callable;
+        }
+    }
+
+    /// Forgets the runner. A cancel(true) that arrived during the run has
+    /// interrupted this thread; that interrupt is meant for the task, so it
+    /// is consumed here rather than leaking into the next task the thread runs.
+    private void release() {
+        boolean cancelled;
+        synchronized (this) {
+            runner = null;
+            cancelled = state == CANCELLED;
+        }
+        if (cancelled) {
+            Thread.interrupted();
+        }
+    }
+
+    public String toString() {
+        String status;
+        synchronized (this) {
+            switch (state) {
+                case NORMAL:
+                    status = "[Completed normally]";
+                    break;
+                case EXCEPTIONAL:
+                    status = "[Completed exceptionally: " + outcome + "]";
+                    break;
+                case CANCELLED:
+                    status = "[Cancelled]";
+                    break;
+                default:
+                    status = "[Not completed]";
+                    break;
+            }
+        }
+        return super.toString() + status;
+    }
+
+    /// Waits for the task to be done.
+    private static final class Wait extends BlockingWait {
+        private final FutureTask<?> task;
+
+        Wait(FutureTask<?> task, long deadline) {
+            super(task, deadline);
+            this.task = task;
+        }
+
+        boolean ready() {
+            return task.state != NEW;
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/RejectedExecutionException.java b/Ports/CLDC11/src/java/util/concurrent/RejectedExecutionException.java
new file mode 100644
index 00000000000..044724fb498
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/RejectedExecutionException.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Thrown by an [Executor] that does not accept a task, typically because
+/// it has been shut down.
+public class RejectedExecutionException extends RuntimeException {
+
+    public RejectedExecutionException() {
+    }
+
+    public RejectedExecutionException(String message) {
+        super(message);
+    }
+
+    public RejectedExecutionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public RejectedExecutionException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/RunnableFuture.java b/Ports/CLDC11/src/java/util/concurrent/RunnableFuture.java
new file mode 100644
index 00000000000..70567ad1b59
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/RunnableFuture.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// A [Future] that is also the task computing it: running it completes it.
+public interface RunnableFuture<V> extends Runnable, Future<V> {
+
+    /// Computes the result and completes this future with it, unless it was
+    /// cancelled.
+    void run();
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ScheduledExecutorService.java b/Ports/CLDC11/src/java/util/concurrent/ScheduledExecutorService.java
new file mode 100644
index 00000000000..b4f01364311
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ScheduledExecutorService.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// `java.util.concurrent.ScheduledExecutorService`: an executor that also
+/// runs work after a delay, or again and again.
+///
+/// The work runs on the executor's threads, never on the UI thread.
+public interface ScheduledExecutorService extends ExecutorService {
+
+    ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
+
+    <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
+
+    ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
+
+    ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ScheduledFuture.java b/Ports/CLDC11/src/java/util/concurrent/ScheduledFuture.java
new file mode 100644
index 00000000000..29d60302da2
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ScheduledFuture.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// `java.util.concurrent.ScheduledFuture`: the result of work an executor
+/// was asked to run later.
+public interface ScheduledFuture<V> extends Delayed, Future<V> {
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ScheduledPool.java b/Ports/CLDC11/src/java/util/concurrent/ScheduledPool.java
new file mode 100644
index 00000000000..6ccdb525ba5
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ScheduledPool.java
@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+
+/// The [ScheduledExecutorService] that [Executors] hands out: a timer that
+/// passes each piece of work, when it is due, to an ordinary executor.
+///
+/// #### After `shutdown()`
+///
+/// As a JDK `ScheduledThreadPoolExecutor` with its default policies: work
+/// already scheduled to run once still runs when it is due, and its future
+/// completes; work that repeats is cancelled; nothing new is accepted. The
+/// executor is terminated once the last of the accepted work has run.
+/// `shutdownNow()` drops what has not started.
+///
+/// Not provided: the two policies themselves
+/// (`setExecuteExistingDelayedTasksAfterShutdownPolicy` and its periodic
+/// twin are methods of the JDK's class, not of the interface this is handed
+/// out as).
+final class ScheduledPool extends AbstractExecutorService implements ScheduledExecutorService {
+
+    private static final Scheduled<?>[] NONE = new Scheduled<?>[0];
+
+    private final ExecutorService pool;
+    private final AtomicBoolean shutdown = new AtomicBoolean();
+    /// Set once the pool has been told to stop and nothing waits any more.
+    private final AtomicBoolean stopped = new AtomicBoolean();
+    /// The scheduled work that has not completed, which is what an orderly
+    /// shutdown waits for (the work that runs once) or cancels (the work
+    /// that repeats). Replaced, never changed: this is read and written by
+    /// the timer's thread, the workers and the caller's.
+    private final AtomicReference<Scheduled<?>[]> live = new AtomicReference<Scheduled<?>[]>(NONE);
+
+    ScheduledPool(ExecutorService pool) {
+        this.pool = pool;
+    }
+
+    private final class Scheduled<V> implements Runnable, ScheduledFuture<V> {
+        private final Callable<V> work;
+        private final boolean periodic;
+        /// The gap to keep after a run ends, or zero for a fixed rate.
+        private final long delayAfter;
+        /// The period of a fixed rate, or zero.
+        private final long rate;
+        /// The wait this is in, in [Delays], or null: see [#arm].
+        private final AtomicReference<Delays.Handle> wait = new AtomicReference<Delays.Handle>();
+        private final AtomicLong due;
+        private final AtomicBoolean running = new AtomicBoolean();
+        /// A fixed rate's firings that have come and not yet run, counting
+        /// the one running now. See [#run].
+        private final AtomicInteger owed = new AtomicInteger();
+        private final CompletableFuture<V> outcome = new CompletableFuture<V>();
+
+        Scheduled(Callable<V> work, long dueAt, boolean periodic, long delayAfter, long rate) {
+            this.work = work;
+            this.periodic = periodic;
+            this.delayAfter = delayAfter;
+            this.rate = rate;
+            this.due = new AtomicLong(dueAt);
+        }
+
+        @Override
+        public void run() {
+            // Work that runs once and was accepted before a shutdown still
+            // runs; work that repeats does not.
+            if (outcome.isDone() || (periodic && shutdown.get()) || stopped.get()) {
+                disarm();
+                return;
+            }
+            if (rate > 0) {
+                // A fixed rate keeps its beat whatever a run takes.
+                due.set(due.get() + rate);
+                arm(due.get() - System.currentTimeMillis());
+                // A firing that comes while a run is under way is owed, not
+                // dropped: as with the JDK's scheduleAtFixedRate, an overrun
+                // makes the next runs start late and one after another,
+                // never at once. The worker already running takes it.
+                if (owed.getAndIncrement() > 0) {
+                    return;
+                }
+            } else if (!running.compareAndSet(false, true)) {
+                return;
+            }
+            try {
+                pool.execute(new Runnable() {
+                    @Override
+                    public void run() {
+                        once();
+                    }
+                });
+            } catch (RuntimeException e) {
+                running.set(false);
+                owed.set(0);
+                outcome.completeExceptionally(e);
+                disarm();
+            }
+        }
+
+        /// Waits `millis` and then runs. The handle is kept so that a
+        /// cancelled task leaves the queue at once.
+        void arm(long millis) {
+            Delays.Handle next = Delays.after(millis, this);
+            Delays.Handle before = wait.getAndSet(next);
+            if (before != null) {
+                before.cancel();
+            }
+            if (outcome.isDone() || stopped.get()) {
+                // Cancelled, or stopped, while this was being armed.
+                disarm();
+            }
+        }
+
+        void disarm() {
+            Delays.Handle before = wait.getAndSet(null);
+            if (before != null) {
+                before.cancel();
+            }
+        }
+
+        /// A fixed rate runs every firing it owes, in turn, on this worker.
+        private void once() {
+            if (rate == 0) {
+                step();
+                return;
+            }
+            do {
+                running.set(true);
+                if (!step()) {
+                    return;
+                }
+            } while (owed.decrementAndGet() > 0);
+        }
+
+        /// One run; false when the work is not to run again.
+        private boolean step() {
+            // Cancelled, or stopped, while it waited for a worker: a future
+            // that answers isCancelled() must never start its work after.
+            if (outcome.isDone() || (periodic && shutdown.get()) || stopped.get()) {
+                running.set(false);
+                disarm();
+                return false;
+            }
+            boolean rearm = false;
+            try {
+                V value;
+                try {
+                    value = work.call();
+                } catch (Throwable t) {
+                    // Work that fails is not run again.
+                    outcome.completeExceptionally(t);
+                    disarm();
+                    return false;
+                }
+                if (!periodic) {
+                    outcome.complete(value);
+                } else if (delayAfter > 0 && !outcome.isDone() && !shutdown.get()) {
+                    rearm = true;
+                }
+            } finally {
+                running.set(false);
+            }
+            if (rearm) {
+                // Only once the flag is down. Armed before it, a short delay
+                // let the timer fire while this run still held the flag: the
+                // next run saw a run in progress and returned, nothing armed
+                // another, and the task stopped for good with its future
+                // never completing.
+                again();
+            }
+            return !outcome.isDone();
+        }
+
+        private void again() {
+            due.set(System.currentTimeMillis() + delayAfter);
+            arm(delayAfter);
+        }
+
+        @Override
+        public long getDelay(TimeUnit unit) {
+            return unit.convert(due.get() - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+        }
+
+        @Override
+        public int compareTo(Delayed other) {
+            if (other == this) {
+                return 0;
+            }
+            long mine = getDelay(TimeUnit.MILLISECONDS);
+            long theirs = other.getDelay(TimeUnit.MILLISECONDS);
+            return mine < theirs ? -1 : (mine == theirs ? 0 : 1);
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            disarm();
+            return outcome.cancel(mayInterruptIfRunning);
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return outcome.isCancelled();
+        }
+
+        @Override
+        public boolean isDone() {
+            return outcome.isDone();
+        }
+
+        @Override
+        public V get() throws InterruptedException, ExecutionException {
+            return outcome.get();
+        }
+
+        @Override
+        public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+            return outcome.get(timeout, unit);
+        }
+    }
+
+    /// Keeps `task` until it completes, and runs it after `millis`.
+    private <V> Scheduled<V> accept(final Scheduled<V> task, long millis) {
+        checkOpen();
+        while (true) {
+            Scheduled<?>[] before = live.get();
+            Scheduled<?>[] after = new Scheduled<?>[before.length + 1];
+            System.arraycopy(before, 0, after, 0, before.length);
+            after[before.length] = task;
+            if (live.compareAndSet(before, after)) {
+                break;
+            }
+        }
+        task.outcome.whenComplete(new BiConsumer<V, Throwable>() {
+            @Override
+            public void accept(V value, Throwable failure) {
+                forget(task);
+            }
+        });
+        if (shutdown.get()) {
+            // A shutdown came in between: this one was not accepted.
+            task.cancel(false);
+            throw new RejectedExecutionException("The executor has been shut down");
+        }
+        task.arm(millis);
+        return task;
+    }
+
+    private void forget(Scheduled<?> task) {
+        while (true) {
+            Scheduled<?>[] before = live.get();
+            int at = -1;
+            for (int i = 0; i < before.length; i++) {
+                if (before[i] == task) {
+                    at = i;
+                }
+            }
+            if (at < 0) {
+                break;
+            }
+            Scheduled<?>[] after = new Scheduled<?>[before.length - 1];
+            System.arraycopy(before, 0, after, 0, at);
+            System.arraycopy(before, at + 1, after, at, after.length - at);
+            if (live.compareAndSet(before, after.length == 0 ? NONE : after)) {
+                break;
+            }
+        }
+        stopWhenIdle();
+    }
+
+    /// After a shutdown, stops the timer and the pool once nothing accepted
+    /// is left to run.
+    private void stopWhenIdle() {
+        if (shutdown.get() && live.get().length == 0 && stopped.compareAndSet(false, true)) {
+            pool.shutdown();
+        }
+    }
+
+    private void checkOpen() {
+        if (shutdown.get()) {
+            throw new RejectedExecutionException("The executor has been shut down");
+        }
+    }
+
+    @Override
+    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
+        if (callable == null || unit == null) {
+            throw new NullPointerException();
+        }
+        final long millis = Math.max(0, unit.toMillis(delay));
+        final Scheduled<V> task = new Scheduled<V>(callable, System.currentTimeMillis() + millis, false, 0, 0);
+        return accept(task, millis);
+    }
+
+    @Override
+    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+        return schedule(Executors.callable(command, null), delay, unit);
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (period <= 0) {
+            throw new IllegalArgumentException();
+        }
+        final long millis = Math.max(0, unit.toMillis(initialDelay));
+        final long every = Math.max(1, unit.toMillis(period));
+        final Scheduled<Object> task = new Scheduled<Object>(Executors.callable(command, null),
+                System.currentTimeMillis() + millis, true, 0, every);
+        return accept(task, millis);
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,
+            TimeUnit unit) {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (delay <= 0) {
+            throw new IllegalArgumentException();
+        }
+        final long millis = Math.max(0, unit.toMillis(initialDelay));
+        final Scheduled<Object> task = new Scheduled<Object>(Executors.callable(command, null),
+                System.currentTimeMillis() + millis, true, Math.max(1, unit.toMillis(delay)), 0);
+        return accept(task, millis);
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        // The pool itself stays open after a shutdown for as long as
+        // delayed work is due to be handed to it, so it cannot be the one
+        // to refuse.
+        checkOpen();
+        pool.execute(command);
+    }
+
+    @Override
+    public void shutdown() {
+        shutdown.set(true);
+        for (Scheduled<?> task : live.get()) {
+            if (task.periodic) {
+                task.cancel(false);
+            }
+        }
+        stopWhenIdle();
+    }
+
+    /// Nothing scheduled that has not started runs after this. The futures
+    /// of the dropped work stay as they are, neither done nor cancelled,
+    /// as the JDK leaves them.
+    ///
+    /// What is answered is all of it, as the contract of the interface
+    /// has it: the work the pool had been handed and had not begun, and
+    /// the work that was still waiting for its time, which the pool never
+    /// saw. The JDK answers its delayed tasks the same way, as the futures
+    /// `schedule` returned.
+    @Override
+    public List<Runnable> shutdownNow() {
+        shutdown.set(true);
+        stopped.set(true);
+        List<Runnable> dropped = new ArrayList<Runnable>(pool.shutdownNow());
+        // Taken out of `live` here: a dropped task's future never completes,
+        // so the forget() its completion would run never comes, and the
+        // pool would hold every dropped task (and what its work holds) for
+        // as long as the pool itself is reachable. Nothing reads `live`
+        // after this -- `stopped` is set, so stopWhenIdle() is done with it
+        // -- and a task still running forgets itself into an empty array.
+        for (Scheduled<?> task : live.getAndSet(NONE)) {
+            task.disarm();
+            if (!task.outcome.isDone() && !task.running.get()) {
+                dropped.add(task);
+            }
+        }
+        return dropped;
+    }
+
+    @Override
+    public boolean isShutdown() {
+        return shutdown.get();
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return pool.isTerminated();
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        return pool.awaitTermination(timeout, unit);
+    }
+
+    @Override
+    public <T> Future<T> submit(Callable<T> task) {
+        checkOpen();
+        return pool.submit(task);
+    }
+
+    @Override
+    public <T> Future<T> submit(Runnable task, T result) {
+        checkOpen();
+        return pool.submit(task, result);
+    }
+
+    @Override
+    public Future<?> submit(Runnable task) {
+        checkOpen();
+        return pool.submit(task);
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        checkOpen();
+        return pool.invokeAll(tasks);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/ThreadFactory.java b/Ports/CLDC11/src/java/util/concurrent/ThreadFactory.java
new file mode 100644
index 00000000000..2be3cd81893
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/ThreadFactory.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Makes the threads an executor runs its tasks on.
+public interface ThreadFactory {
+
+    /// A new, unstarted thread that runs `r`; null to refuse.
+    Thread newThread(Runnable r);
+}
diff --git a/Ports/CLDC11/src/java/util/concurrent/TimeoutException.java b/Ports/CLDC11/src/java/util/concurrent/TimeoutException.java
new file mode 100644
index 00000000000..69be4c33b8d
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/concurrent/TimeoutException.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *  
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Codename One through http://www.codenameone.com/ if you 
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Thrown by [Future#get(long, TimeUnit)] when the work has not finished in time.
+public class TimeoutException extends Exception {
+    /// An exception with no message.
+    public TimeoutException() { }
+
+    /// An exception with `message`.
+    ///
+    /// @param message the detail message
+    public TimeoutException(String message) { super(message); }
+}
diff --git a/Ports/CLDC11/src/java/util/function/BiConsumer.java b/Ports/CLDC11/src/java/util/function/BiConsumer.java
index f27cf084ac6..52c0356ef5b 100644
--- a/Ports/CLDC11/src/java/util/function/BiConsumer.java
+++ b/Ports/CLDC11/src/java/util/function/BiConsumer.java
@@ -1,5 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// An operation on two values that answers nothing.
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
 public interface BiConsumer<T, U> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the first input
+    /// @param u the second input
     void accept(T t, U u);
+
+    /// This operation followed by `after`, both given the same values. If
+    /// this operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default BiConsumer<T, U> andThen(final BiConsumer<? super T, ? super U> after) {
+        Objects.requireNonNull(after);
+        final BiConsumer<T, U> self = this;
+        return new BiConsumer<T, U>() {
+            public void accept(T t, U u) {
+                self.accept(t, u);
+                after.accept(t, u);
+            }
+        };
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/function/BiFunction.java b/Ports/CLDC11/src/java/util/function/BiFunction.java
index 92c2bccaf71..cdfa42856e3 100644
--- a/Ports/CLDC11/src/java/util/function/BiFunction.java
+++ b/Ports/CLDC11/src/java/util/function/BiFunction.java
@@ -1,5 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// A function of two arguments.
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+/// @param <R> the result type
+@FunctionalInterface
 public interface BiFunction<T, U, R> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
     R apply(T t, U u);
+
+    /// This function, then `after` on its result.
+    ///
+    /// @param after the function applied next
+    /// @param <V> the result type of `after`
+    /// @return the composed function
+    default <V> BiFunction<T, U, V> andThen(final Function<? super R, ? extends V> after) {
+        Objects.requireNonNull(after);
+        final BiFunction<T, U, R> self = this;
+        return new BiFunction<T, U, V>() {
+            public V apply(T t, U u) {
+                return after.apply(self.apply(t, u));
+            }
+        };
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/function/BiPredicate.java b/Ports/CLDC11/src/java/util/function/BiPredicate.java
new file mode 100644
index 00000000000..9f4585b89ad
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/BiPredicate.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of two arguments; the two-argument form of [Predicate].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface BiPredicate<T, U> {
+
+    /// Whether `t` and `u` pass.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return true when they pass
+    boolean test(T t, U u);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default BiPredicate<T, U> and(final BiPredicate<? super T, ? super U> other) {
+        Objects.requireNonNull(other);
+        final BiPredicate<T, U> self = this;
+        return new BiPredicate<T, U>() {
+            public boolean test(T t, U u) {
+                return self.test(t, u) && other.test(t, u);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default BiPredicate<T, U> negate() {
+        final BiPredicate<T, U> self = this;
+        return new BiPredicate<T, U>() {
+            public boolean test(T t, U u) {
+                return !self.test(t, u);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default BiPredicate<T, U> or(final BiPredicate<? super T, ? super U> other) {
+        Objects.requireNonNull(other);
+        final BiPredicate<T, U> self = this;
+        return new BiPredicate<T, U>() {
+            public boolean test(T t, U u) {
+                return self.test(t, u) || other.test(t, u);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/BinaryOperator.java b/Ports/CLDC11/src/java/util/function/BinaryOperator.java
index 6bb43e2efd4..2755a698c25 100644
--- a/Ports/CLDC11/src/java/util/function/BinaryOperator.java
+++ b/Ports/CLDC11/src/java/util/function/BinaryOperator.java
@@ -1,5 +1,61 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
-public interface BinaryOperator<T> {
-    T apply(T a, T b);
+import java.util.Comparator;
+import java.util.Objects;
+
+/// An operation on two values of one type that answers that type.
+///
+/// @param <T> the operand and result type
+@FunctionalInterface
+public interface BinaryOperator<T> extends BiFunction<T, T, T> {
+
+    /// The smaller of two values by `comparator`; the first on a tie.
+    ///
+    /// @param comparator the order
+    /// @param <T> the type
+    /// @return the operator
+    static <T> BinaryOperator<T> minBy(final Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return new BinaryOperator<T>() {
+            public T apply(T a, T b) {
+                return comparator.compare(a, b) <= 0 ? a : b;
+            }
+        };
+    }
+
+    /// The larger of two values by `comparator`; the first on a tie.
+    ///
+    /// @param comparator the order
+    /// @param <T> the type
+    /// @return the operator
+    static <T> BinaryOperator<T> maxBy(final Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return new BinaryOperator<T>() {
+            public T apply(T a, T b) {
+                return comparator.compare(a, b) >= 0 ? a : b;
+            }
+        };
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/function/BooleanSupplier.java b/Ports/CLDC11/src/java/util/function/BooleanSupplier.java
new file mode 100644
index 00000000000..43fc08737e8
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/BooleanSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `boolean` values; the `boolean` form of [Supplier].
+@FunctionalInterface
+public interface BooleanSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    boolean getAsBoolean();
+}
diff --git a/Ports/CLDC11/src/java/util/function/Consumer.java b/Ports/CLDC11/src/java/util/function/Consumer.java
index a000a2c474e..7ee4c4c190a 100644
--- a/Ports/CLDC11/src/java/util/function/Consumer.java
+++ b/Ports/CLDC11/src/java/util/function/Consumer.java
@@ -1,5 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// An operation on one value that answers nothing.
+///
+/// @param <T> the input type
+@FunctionalInterface
 public interface Consumer<T> {
+
+    /// Performs this operation on `t`.
+    ///
+    /// @param t the input
     void accept(T t);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default Consumer<T> andThen(final Consumer<? super T> after) {
+        Objects.requireNonNull(after);
+        final Consumer<T> self = this;
+        return new Consumer<T>() {
+            public void accept(T t) {
+                self.accept(t);
+                after.accept(t);
+            }
+        };
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/function/DoubleBinaryOperator.java b/Ports/CLDC11/src/java/util/function/DoubleBinaryOperator.java
new file mode 100644
index 00000000000..bfa1d4e0513
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleBinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on two `double` values that answers a `double`; the `double` form of [BinaryOperator].
+@FunctionalInterface
+public interface DoubleBinaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param left the first operand
+    /// @param right the second operand
+    /// @return the result
+    double applyAsDouble(double left, double right);
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoubleConsumer.java b/Ports/CLDC11/src/java/util/function/DoubleConsumer.java
new file mode 100644
index 00000000000..1d44bd4bd42
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleConsumer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `double` that answers nothing; the `double` form of [Consumer].
+@FunctionalInterface
+public interface DoubleConsumer {
+
+    /// Performs this operation on `value`.
+    ///
+    /// @param value the input
+    void accept(double value);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default DoubleConsumer andThen(final DoubleConsumer after) {
+        Objects.requireNonNull(after);
+        final DoubleConsumer self = this;
+        return new DoubleConsumer() {
+            public void accept(double value) {
+                self.accept(value);
+                after.accept(value);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoubleFunction.java b/Ports/CLDC11/src/java/util/function/DoubleFunction.java
new file mode 100644
index 00000000000..85cbd3632dc
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `double`; the `double` form of [Function].
+///
+/// @param <R> the result type
+@FunctionalInterface
+public interface DoubleFunction<R> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    R apply(double value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoublePredicate.java b/Ports/CLDC11/src/java/util/function/DoublePredicate.java
new file mode 100644
index 00000000000..125d220f3b6
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoublePredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of one `double`; the `double` form of [Predicate].
+@FunctionalInterface
+public interface DoublePredicate {
+
+    /// Whether `value` passes.
+    ///
+    /// @param value the input
+    /// @return true when it passes
+    boolean test(double value);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default DoublePredicate and(final DoublePredicate other) {
+        Objects.requireNonNull(other);
+        final DoublePredicate self = this;
+        return new DoublePredicate() {
+            public boolean test(double value) {
+                return self.test(value) && other.test(value);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default DoublePredicate negate() {
+        final DoublePredicate self = this;
+        return new DoublePredicate() {
+            public boolean test(double value) {
+                return !self.test(value);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default DoublePredicate or(final DoublePredicate other) {
+        Objects.requireNonNull(other);
+        final DoublePredicate self = this;
+        return new DoublePredicate() {
+            public boolean test(double value) {
+                return self.test(value) || other.test(value);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoubleSupplier.java b/Ports/CLDC11/src/java/util/function/DoubleSupplier.java
new file mode 100644
index 00000000000..de3fe0d5a37
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `double` values; the `double` form of [Supplier].
+@FunctionalInterface
+public interface DoubleSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    double getAsDouble();
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoubleToIntFunction.java b/Ports/CLDC11/src/java/util/function/DoubleToIntFunction.java
new file mode 100644
index 00000000000..fe3d5a98fad
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleToIntFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `double` that answers a `int`.
+@FunctionalInterface
+public interface DoubleToIntFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    int applyAsInt(double value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoubleToLongFunction.java b/Ports/CLDC11/src/java/util/function/DoubleToLongFunction.java
new file mode 100644
index 00000000000..949d967ce35
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleToLongFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `double` that answers a `long`.
+@FunctionalInterface
+public interface DoubleToLongFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    long applyAsLong(double value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/DoubleUnaryOperator.java b/Ports/CLDC11/src/java/util/function/DoubleUnaryOperator.java
new file mode 100644
index 00000000000..16e51536be4
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/DoubleUnaryOperator.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `double` that answers a `double`; the `double` form of [UnaryOperator].
+@FunctionalInterface
+public interface DoubleUnaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param operand the input
+    /// @return the result
+    double applyAsDouble(double operand);
+
+    /// `before`, then this operator on its result.
+    ///
+    /// @param before the operator applied first
+    /// @return the composed operator
+    default DoubleUnaryOperator compose(final DoubleUnaryOperator before) {
+        Objects.requireNonNull(before);
+        final DoubleUnaryOperator self = this;
+        return new DoubleUnaryOperator() {
+            public double applyAsDouble(double value) {
+                return self.applyAsDouble(before.applyAsDouble(value));
+            }
+        };
+    }
+
+    /// This operator, then `after` on its result.
+    ///
+    /// @param after the operator applied next
+    /// @return the composed operator
+    default DoubleUnaryOperator andThen(final DoubleUnaryOperator after) {
+        Objects.requireNonNull(after);
+        final DoubleUnaryOperator self = this;
+        return new DoubleUnaryOperator() {
+            public double applyAsDouble(double value) {
+                return after.applyAsDouble(self.applyAsDouble(value));
+            }
+        };
+    }
+
+    /// The operator that answers its operand.
+    ///
+    /// @return the identity operator
+    static DoubleUnaryOperator identity() {
+        return new DoubleUnaryOperator() {
+            public double applyAsDouble(double value) {
+                return value;
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/Function.java b/Ports/CLDC11/src/java/util/function/Function.java
index ad779d44781..1c16bc90b84 100644
--- a/Ports/CLDC11/src/java/util/function/Function.java
+++ b/Ports/CLDC11/src/java/util/function/Function.java
@@ -1,5 +1,81 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// A function of one argument.
+///
+/// @param <T> the input type
+/// @param <R> the result type
+@FunctionalInterface
 public interface Function<T, R> {
+
+    /// Applies this function.
+    ///
+    /// @param t the input
+    /// @return the result
     R apply(T t);
+
+    /// `before`, then this function on its result.
+    ///
+    /// @param before the function applied first
+    /// @param <V> the input type of `before`
+    /// @return the composed function
+    default <V> Function<V, R> compose(final Function<? super V, ? extends T> before) {
+        Objects.requireNonNull(before);
+        final Function<T, R> self = this;
+        return new Function<V, R>() {
+            public R apply(V v) {
+                return self.apply(before.apply(v));
+            }
+        };
+    }
+
+    /// This function, then `after` on its result.
+    ///
+    /// @param after the function applied next
+    /// @param <V> the result type of `after`
+    /// @return the composed function
+    default <V> Function<T, V> andThen(final Function<? super R, ? extends V> after) {
+        Objects.requireNonNull(after);
+        final Function<T, R> self = this;
+        return new Function<T, V>() {
+            public V apply(T t) {
+                return after.apply(self.apply(t));
+            }
+        };
+    }
+
+    /// The function that answers its argument.
+    ///
+    /// @param <T> the type
+    /// @return the identity function
+    static <T> Function<T, T> identity() {
+        return new Function<T, T>() {
+            public T apply(T t) {
+                return t;
+            }
+        };
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/function/IntBinaryOperator.java b/Ports/CLDC11/src/java/util/function/IntBinaryOperator.java
new file mode 100644
index 00000000000..dccd2f21f3c
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntBinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on two `int` values that answers a `int`; the `int` form of [BinaryOperator].
+@FunctionalInterface
+public interface IntBinaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param left the first operand
+    /// @param right the second operand
+    /// @return the result
+    int applyAsInt(int left, int right);
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntConsumer.java b/Ports/CLDC11/src/java/util/function/IntConsumer.java
new file mode 100644
index 00000000000..80a74ca841c
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntConsumer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `int` that answers nothing; the `int` form of [Consumer].
+@FunctionalInterface
+public interface IntConsumer {
+
+    /// Performs this operation on `value`.
+    ///
+    /// @param value the input
+    void accept(int value);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default IntConsumer andThen(final IntConsumer after) {
+        Objects.requireNonNull(after);
+        final IntConsumer self = this;
+        return new IntConsumer() {
+            public void accept(int value) {
+                self.accept(value);
+                after.accept(value);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntFunction.java b/Ports/CLDC11/src/java/util/function/IntFunction.java
new file mode 100644
index 00000000000..a148d448cb8
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `int`; the `int` form of [Function].
+///
+/// @param <R> the result type
+@FunctionalInterface
+public interface IntFunction<R> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    R apply(int value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntPredicate.java b/Ports/CLDC11/src/java/util/function/IntPredicate.java
new file mode 100644
index 00000000000..3c538be9255
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntPredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of one `int`; the `int` form of [Predicate].
+@FunctionalInterface
+public interface IntPredicate {
+
+    /// Whether `value` passes.
+    ///
+    /// @param value the input
+    /// @return true when it passes
+    boolean test(int value);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default IntPredicate and(final IntPredicate other) {
+        Objects.requireNonNull(other);
+        final IntPredicate self = this;
+        return new IntPredicate() {
+            public boolean test(int value) {
+                return self.test(value) && other.test(value);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default IntPredicate negate() {
+        final IntPredicate self = this;
+        return new IntPredicate() {
+            public boolean test(int value) {
+                return !self.test(value);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default IntPredicate or(final IntPredicate other) {
+        Objects.requireNonNull(other);
+        final IntPredicate self = this;
+        return new IntPredicate() {
+            public boolean test(int value) {
+                return self.test(value) || other.test(value);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntSupplier.java b/Ports/CLDC11/src/java/util/function/IntSupplier.java
new file mode 100644
index 00000000000..630ef2d22d6
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `int` values; the `int` form of [Supplier].
+@FunctionalInterface
+public interface IntSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    int getAsInt();
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntToDoubleFunction.java b/Ports/CLDC11/src/java/util/function/IntToDoubleFunction.java
new file mode 100644
index 00000000000..9a5f753bc75
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntToDoubleFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `int` that answers a `double`.
+@FunctionalInterface
+public interface IntToDoubleFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    double applyAsDouble(int value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntToLongFunction.java b/Ports/CLDC11/src/java/util/function/IntToLongFunction.java
new file mode 100644
index 00000000000..c31acba27c5
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntToLongFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `int` that answers a `long`.
+@FunctionalInterface
+public interface IntToLongFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    long applyAsLong(int value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/IntUnaryOperator.java b/Ports/CLDC11/src/java/util/function/IntUnaryOperator.java
new file mode 100644
index 00000000000..ce97b7a0b9e
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/IntUnaryOperator.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `int` that answers a `int`; the `int` form of [UnaryOperator].
+@FunctionalInterface
+public interface IntUnaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param operand the input
+    /// @return the result
+    int applyAsInt(int operand);
+
+    /// `before`, then this operator on its result.
+    ///
+    /// @param before the operator applied first
+    /// @return the composed operator
+    default IntUnaryOperator compose(final IntUnaryOperator before) {
+        Objects.requireNonNull(before);
+        final IntUnaryOperator self = this;
+        return new IntUnaryOperator() {
+            public int applyAsInt(int value) {
+                return self.applyAsInt(before.applyAsInt(value));
+            }
+        };
+    }
+
+    /// This operator, then `after` on its result.
+    ///
+    /// @param after the operator applied next
+    /// @return the composed operator
+    default IntUnaryOperator andThen(final IntUnaryOperator after) {
+        Objects.requireNonNull(after);
+        final IntUnaryOperator self = this;
+        return new IntUnaryOperator() {
+            public int applyAsInt(int value) {
+                return after.applyAsInt(self.applyAsInt(value));
+            }
+        };
+    }
+
+    /// The operator that answers its operand.
+    ///
+    /// @return the identity operator
+    static IntUnaryOperator identity() {
+        return new IntUnaryOperator() {
+            public int applyAsInt(int value) {
+                return value;
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongBinaryOperator.java b/Ports/CLDC11/src/java/util/function/LongBinaryOperator.java
new file mode 100644
index 00000000000..3b6faeacc4e
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongBinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on two `long` values that answers a `long`; the `long` form of [BinaryOperator].
+@FunctionalInterface
+public interface LongBinaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param left the first operand
+    /// @param right the second operand
+    /// @return the result
+    long applyAsLong(long left, long right);
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongConsumer.java b/Ports/CLDC11/src/java/util/function/LongConsumer.java
new file mode 100644
index 00000000000..cdb2b02e5d8
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongConsumer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `long` that answers nothing; the `long` form of [Consumer].
+@FunctionalInterface
+public interface LongConsumer {
+
+    /// Performs this operation on `value`.
+    ///
+    /// @param value the input
+    void accept(long value);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default LongConsumer andThen(final LongConsumer after) {
+        Objects.requireNonNull(after);
+        final LongConsumer self = this;
+        return new LongConsumer() {
+            public void accept(long value) {
+                self.accept(value);
+                after.accept(value);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongFunction.java b/Ports/CLDC11/src/java/util/function/LongFunction.java
new file mode 100644
index 00000000000..f1458845b13
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `long`; the `long` form of [Function].
+///
+/// @param <R> the result type
+@FunctionalInterface
+public interface LongFunction<R> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    R apply(long value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongPredicate.java b/Ports/CLDC11/src/java/util/function/LongPredicate.java
new file mode 100644
index 00000000000..f010b7bc72b
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongPredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of one `long`; the `long` form of [Predicate].
+@FunctionalInterface
+public interface LongPredicate {
+
+    /// Whether `value` passes.
+    ///
+    /// @param value the input
+    /// @return true when it passes
+    boolean test(long value);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default LongPredicate and(final LongPredicate other) {
+        Objects.requireNonNull(other);
+        final LongPredicate self = this;
+        return new LongPredicate() {
+            public boolean test(long value) {
+                return self.test(value) && other.test(value);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default LongPredicate negate() {
+        final LongPredicate self = this;
+        return new LongPredicate() {
+            public boolean test(long value) {
+                return !self.test(value);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default LongPredicate or(final LongPredicate other) {
+        Objects.requireNonNull(other);
+        final LongPredicate self = this;
+        return new LongPredicate() {
+            public boolean test(long value) {
+                return self.test(value) || other.test(value);
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongSupplier.java b/Ports/CLDC11/src/java/util/function/LongSupplier.java
new file mode 100644
index 00000000000..133d768e0fd
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `long` values; the `long` form of [Supplier].
+@FunctionalInterface
+public interface LongSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    long getAsLong();
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongToDoubleFunction.java b/Ports/CLDC11/src/java/util/function/LongToDoubleFunction.java
new file mode 100644
index 00000000000..ec0ad15bf49
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongToDoubleFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `long` that answers a `double`.
+@FunctionalInterface
+public interface LongToDoubleFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    double applyAsDouble(long value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongToIntFunction.java b/Ports/CLDC11/src/java/util/function/LongToIntFunction.java
new file mode 100644
index 00000000000..1ae1a3c9ce5
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongToIntFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `long` that answers a `int`.
+@FunctionalInterface
+public interface LongToIntFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    int applyAsInt(long value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/LongUnaryOperator.java b/Ports/CLDC11/src/java/util/function/LongUnaryOperator.java
new file mode 100644
index 00000000000..e70cbd9fa22
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/LongUnaryOperator.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `long` that answers a `long`; the `long` form of [UnaryOperator].
+@FunctionalInterface
+public interface LongUnaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param operand the input
+    /// @return the result
+    long applyAsLong(long operand);
+
+    /// `before`, then this operator on its result.
+    ///
+    /// @param before the operator applied first
+    /// @return the composed operator
+    default LongUnaryOperator compose(final LongUnaryOperator before) {
+        Objects.requireNonNull(before);
+        final LongUnaryOperator self = this;
+        return new LongUnaryOperator() {
+            public long applyAsLong(long value) {
+                return self.applyAsLong(before.applyAsLong(value));
+            }
+        };
+    }
+
+    /// This operator, then `after` on its result.
+    ///
+    /// @param after the operator applied next
+    /// @return the composed operator
+    default LongUnaryOperator andThen(final LongUnaryOperator after) {
+        Objects.requireNonNull(after);
+        final LongUnaryOperator self = this;
+        return new LongUnaryOperator() {
+            public long applyAsLong(long value) {
+                return after.applyAsLong(self.applyAsLong(value));
+            }
+        };
+    }
+
+    /// The operator that answers its operand.
+    ///
+    /// @return the identity operator
+    static LongUnaryOperator identity() {
+        return new LongUnaryOperator() {
+            public long applyAsLong(long value) {
+                return value;
+            }
+        };
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/function/ObjDoubleConsumer.java b/Ports/CLDC11/src/java/util/function/ObjDoubleConsumer.java
new file mode 100644
index 00000000000..9a90ee68e89
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ObjDoubleConsumer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on an object and a `double` that answers nothing; the `double` form of [BiConsumer].
+///
+/// @param <T> the object type
+@FunctionalInterface
+public interface ObjDoubleConsumer<T> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the object
+    /// @param value the `double`
+    void accept(T t, double value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ObjIntConsumer.java b/Ports/CLDC11/src/java/util/function/ObjIntConsumer.java
new file mode 100644
index 00000000000..d6a5fe85d0b
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ObjIntConsumer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on an object and a `int` that answers nothing; the `int` form of [BiConsumer].
+///
+/// @param <T> the object type
+@FunctionalInterface
+public interface ObjIntConsumer<T> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the object
+    /// @param value the `int`
+    void accept(T t, int value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ObjLongConsumer.java b/Ports/CLDC11/src/java/util/function/ObjLongConsumer.java
new file mode 100644
index 00000000000..6b4735ae72f
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ObjLongConsumer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on an object and a `long` that answers nothing; the `long` form of [BiConsumer].
+///
+/// @param <T> the object type
+@FunctionalInterface
+public interface ObjLongConsumer<T> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the object
+    /// @param value the `long`
+    void accept(T t, long value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/Predicate.java b/Ports/CLDC11/src/java/util/function/Predicate.java
index 4bb9d60f478..4c0067d26d4 100644
--- a/Ports/CLDC11/src/java/util/function/Predicate.java
+++ b/Ports/CLDC11/src/java/util/function/Predicate.java
@@ -1,5 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// A test of one value.
+///
+/// @param <T> the input type
+@FunctionalInterface
 public interface Predicate<T> {
+
+    /// Whether `t` passes.
+    ///
+    /// @param t the input
+    /// @return true when it passes
     boolean test(T t);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default Predicate<T> and(final Predicate<? super T> other) {
+        Objects.requireNonNull(other);
+        final Predicate<T> self = this;
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return self.test(t) && other.test(t);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default Predicate<T> negate() {
+        final Predicate<T> self = this;
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return !self.test(t);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default Predicate<T> or(final Predicate<? super T> other) {
+        Objects.requireNonNull(other);
+        final Predicate<T> self = this;
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return self.test(t) || other.test(t);
+            }
+        };
+    }
+
+    /// Passes for values equal to `targetRef` by [Object#equals], or for null
+    /// when `targetRef` is null.
+    ///
+    /// @param targetRef the value to compare with
+    /// @param <T> the input type
+    /// @return the test
+    static <T> Predicate<T> isEqual(final Object targetRef) {
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return targetRef == null ? t == null : targetRef.equals(t);
+            }
+        };
+    }
+
+    /// The negation of `target`.
+    ///
+    /// @param target the test to negate
+    /// @param <T> the input type
+    /// @return the negated test
+    @SuppressWarnings("unchecked")
+    static <T> Predicate<T> not(Predicate<? super T> target) {
+        Objects.requireNonNull(target);
+        return (Predicate<T>) target.negate();
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/function/Supplier.java b/Ports/CLDC11/src/java/util/function/Supplier.java
index e45d9f5aeef..499a06e4965 100644
--- a/Ports/CLDC11/src/java/util/function/Supplier.java
+++ b/Ports/CLDC11/src/java/util/function/Supplier.java
@@ -1,5 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+/// A source of values.
+///
+/// @param <T> the type supplied
+@FunctionalInterface
 public interface Supplier<T> {
+
+    /// A value.
+    ///
+    /// @return the value
     T get();
 }
diff --git a/Ports/CLDC11/src/java/util/function/ToDoubleBiFunction.java b/Ports/CLDC11/src/java/util/function/ToDoubleBiFunction.java
new file mode 100644
index 00000000000..bedef3df575
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ToDoubleBiFunction.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of two arguments that answers a `double`; the `double` form of [BiFunction].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface ToDoubleBiFunction<T, U> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
+    double applyAsDouble(T t, U u);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ToDoubleFunction.java b/Ports/CLDC11/src/java/util/function/ToDoubleFunction.java
new file mode 100644
index 00000000000..57d5d343ec1
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ToDoubleFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function that answers a `double`; the `double` form of [Function].
+///
+/// @param <T> the input type
+@FunctionalInterface
+public interface ToDoubleFunction<T> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    double applyAsDouble(T value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ToIntBiFunction.java b/Ports/CLDC11/src/java/util/function/ToIntBiFunction.java
new file mode 100644
index 00000000000..b9aa9c17d86
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ToIntBiFunction.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of two arguments that answers a `int`; the `int` form of [BiFunction].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface ToIntBiFunction<T, U> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
+    int applyAsInt(T t, U u);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ToIntFunction.java b/Ports/CLDC11/src/java/util/function/ToIntFunction.java
new file mode 100644
index 00000000000..8d03908f875
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ToIntFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function that answers a `int`; the `int` form of [Function].
+///
+/// @param <T> the input type
+@FunctionalInterface
+public interface ToIntFunction<T> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    int applyAsInt(T value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ToLongBiFunction.java b/Ports/CLDC11/src/java/util/function/ToLongBiFunction.java
new file mode 100644
index 00000000000..a751c610c2e
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ToLongBiFunction.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of two arguments that answers a `long`; the `long` form of [BiFunction].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface ToLongBiFunction<T, U> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
+    long applyAsLong(T t, U u);
+}
diff --git a/Ports/CLDC11/src/java/util/function/ToLongFunction.java b/Ports/CLDC11/src/java/util/function/ToLongFunction.java
new file mode 100644
index 00000000000..45dc0fedb37
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/function/ToLongFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function that answers a `long`; the `long` form of [Function].
+///
+/// @param <T> the input type
+@FunctionalInterface
+public interface ToLongFunction<T> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    long applyAsLong(T value);
+}
diff --git a/Ports/CLDC11/src/java/util/function/UnaryOperator.java b/Ports/CLDC11/src/java/util/function/UnaryOperator.java
index 0a15d04019a..e58ddc6cdb3 100644
--- a/Ports/CLDC11/src/java/util/function/UnaryOperator.java
+++ b/Ports/CLDC11/src/java/util/function/UnaryOperator.java
@@ -1,4 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+/// An operation on one value that answers the same type.
+///
+/// @param <T> the operand and result type
+@FunctionalInterface
 public interface UnaryOperator<T> extends Function<T, T> {
+
+    /// The operator that answers its operand.
+    ///
+    /// @param <T> the type
+    /// @return the identity operator
+    static <T> UnaryOperator<T> identity() {
+        return new UnaryOperator<T>() {
+            public T apply(T t) {
+                return t;
+            }
+        };
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/logging/Level.java b/Ports/CLDC11/src/java/util/logging/Level.java
new file mode 100644
index 00000000000..032099d8ad8
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/logging/Level.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.logging;
+
+/// A logging level: the standard
+/// levels, and room for an application's own -- the constructor is
+/// protected, as the JDK's is, so a class may extend this one to add them.
+///
+/// [Logger] writes through the platform log, which has four levels; see
+/// there for how these map onto them.
+public class Level implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    public static final Level OFF = new Level("OFF", Integer.MAX_VALUE);
+    public static final Level SEVERE = new Level("SEVERE", 1000);
+    public static final Level WARNING = new Level("WARNING", 900);
+    public static final Level INFO = new Level("INFO", 800);
+    public static final Level CONFIG = new Level("CONFIG", 700);
+    public static final Level FINE = new Level("FINE", 500);
+    public static final Level FINER = new Level("FINER", 400);
+    public static final Level FINEST = new Level("FINEST", 300);
+    public static final Level ALL = new Level("ALL", Integer.MIN_VALUE);
+
+    private final String name;
+    private final int value;
+    private final String resourceBundleName;
+
+    protected Level(String name, int value) {
+        this(name, value, null);
+    }
+
+    protected Level(String name, int value, String resourceBundleName) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.value = value;
+        this.resourceBundleName = resourceBundleName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /// The name: a device carries no translations of the level names.
+    public String getLocalizedName() {
+        return name;
+    }
+
+    public String getResourceBundleName() {
+        return resourceBundleName;
+    }
+
+    public final int intValue() {
+        return value;
+    }
+
+    private static Level[] standard() {
+        return new Level[] {OFF, SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST, ALL};
+    }
+
+    /// The standard level called `name`, in any case, or whose number
+    /// `name` spells. A number that belongs to no standard level makes a
+    /// level of its own, named by the number.
+    public static Level parse(String name) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        String trimmed = name.trim();
+        Level[] all = standard();
+        for (Level level : all) {
+            if (level.name.equalsIgnoreCase(trimmed)) {
+                return level;
+            }
+        }
+        int number;
+        try {
+            number = Integer.parseInt(trimmed);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Bad level \"" + name + "\"");
+        }
+        for (Level level : all) {
+            if (level.value == number) {
+                return level;
+            }
+        }
+        return new Level(trimmed, number);
+    }
+
+    @Override
+    public final String toString() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof Level && ((Level) other).value == value;
+    }
+
+    @Override
+    public int hashCode() {
+        return value;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/logging/Logger.java b/Ports/CLDC11/src/java/util/logging/Logger.java
new file mode 100644
index 00000000000..bbf1cbd401e
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/logging/Logger.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.logging;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/// A logger writing through the platform's log, which
+/// `com.codename1.impl.JdkHost` reaches: `com.codename1.io.Log` in a Codename
+/// One application, standard error elsewhere.
+///
+/// The platform log has four levels where the JDK has seven, so they fold:
+/// `SEVERE` is an error, `WARNING` a warning, `INFO` and `CONFIG` are
+/// information, and the three `FINE` levels are debug output. A record
+/// carries its logger's name in front of the message, and an attached
+/// exception is logged with it, which is what prints a stack trace on a
+/// device.
+///
+/// A logger with no level of its own logs `INFO` and above, the JDK's
+/// default; the platform log's own level may then filter once more. There are no
+/// handlers, filters, formatters or parents to configure: a call that would
+/// install one has no method here, and the build reports it.
+public class Logger {
+
+    public static final String GLOBAL_LOGGER_NAME = "global";
+
+    private static final Map<String, Logger> LOGGERS = new HashMap<String, Logger>();
+
+    private final String name;
+    private Level level;
+
+    protected Logger(String name, String resourceBundleName) {
+        this.name = name;
+    }
+
+    public static Logger getLogger(String name) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        synchronized (LOGGERS) {
+            Logger logger = LOGGERS.get(name);
+            if (logger == null) {
+                logger = new Logger(name, null);
+                LOGGERS.put(name, logger);
+            }
+            return logger;
+        }
+    }
+
+    /// The bundle is not consulted: messages are logged as they are given.
+    public static Logger getLogger(String name, String resourceBundleName) {
+        return getLogger(name);
+    }
+
+    public static Logger getGlobal() {
+        return getLogger(GLOBAL_LOGGER_NAME);
+    }
+
+    public static Logger getAnonymousLogger() {
+        return new Logger(null, null);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Level getLevel() {
+        return level;
+    }
+
+    public void setLevel(Level newLevel) {
+        this.level = newLevel;
+    }
+
+    public Logger getParent() {
+        return null;
+    }
+
+    public void setUseParentHandlers(boolean useParentHandlers) {
+        // There are no handlers; see the class description.
+    }
+
+    public boolean getUseParentHandlers() {
+        return false;
+    }
+
+    public boolean isLoggable(Level l) {
+        int floor = (level == null ? Level.INFO : level).intValue();
+        return l.intValue() >= floor && floor != Level.OFF.intValue();
+    }
+
+    private static int logLevel(Level l) {
+        int value = l.intValue();
+        if (value >= Level.SEVERE.intValue()) {
+            return JdkHost.LOG_ERROR;
+        }
+        if (value >= Level.WARNING.intValue()) {
+            return JdkHost.LOG_WARNING;
+        }
+        if (value >= Level.CONFIG.intValue()) {
+            return JdkHost.LOG_INFO;
+        }
+        return JdkHost.LOG_DEBUG;
+    }
+
+    public void log(Level l, String msg) {
+        if (isLoggable(l)) {
+            JdkHost.get().log(logLevel(l), name == null ? String.valueOf(msg) : name + ": " + msg, null);
+        }
+    }
+
+    public void log(Level l, Supplier<String> msgSupplier) {
+        if (isLoggable(l)) {
+            log(l, msgSupplier.get());
+        }
+    }
+
+    public void log(Level l, String msg, Object param1) {
+        log(l, msg, new Object[] {param1});
+    }
+
+    /// Logs `msg` with each `{n}` replaced by parameter `n`, as the JDK's
+    /// formatter does.
+    public void log(Level l, String msg, Object[] params) {
+        if (!isLoggable(l)) {
+            return;
+        }
+        String text = msg;
+        if (text != null && params != null && params.length > 0 && text.indexOf('{') >= 0) {
+            text = substitute(text, params);
+        }
+        log(l, text);
+    }
+
+    /// `msg` with each `{n}` for which there is a parameter replaced by it.
+    /// The JDK formats with `MessageFormat`; this covers the plain index
+    /// form, which is what a log message uses, and leaves anything else --
+    /// a format type, quoting, a brace with no parameter -- as written.
+    private static String substitute(String msg, Object[] params) {
+        StringBuilder out = new StringBuilder(msg.length() + 16);
+        int i = 0;
+        while (i < msg.length()) {
+            char c = msg.charAt(i);
+            if (c == '{') {
+                int close = msg.indexOf('}', i + 1);
+                int index = close < 0 ? -1 : index(msg, i + 1, close);
+                if (index >= 0 && index < params.length) {
+                    out.append(String.valueOf(params[index]));
+                    i = close + 1;
+                    continue;
+                }
+            }
+            out.append(c);
+            i++;
+        }
+        return out.toString();
+    }
+
+    /// The decimal number spelled from `start` to `end`, or -1.
+    private static int index(String text, int start, int end) {
+        if (start == end || end - start > 4) {
+            return -1;
+        }
+        int value = 0;
+        for (int i = start; i < end; i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                return -1;
+            }
+            value = value * 10 + (c - '0');
+        }
+        return value;
+    }
+
+    public void log(Level l, String msg, Throwable thrown) {
+        if (isLoggable(l)) {
+            JdkHost.get().log(logLevel(l), name == null ? String.valueOf(msg) : name + ": " + msg, thrown);
+        }
+    }
+
+    public void log(Level l, Throwable thrown, Supplier<String> msgSupplier) {
+        if (isLoggable(l)) {
+            log(l, msgSupplier.get(), thrown);
+        }
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg) {
+        log(l, msg);
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg, Object param1) {
+        log(l, msg, param1);
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg, Object[] params) {
+        log(l, msg, params);
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg, Throwable thrown) {
+        log(l, msg, thrown);
+    }
+
+    public void entering(String sourceClass, String sourceMethod) {
+        log(Level.FINER, "ENTRY " + sourceClass + "." + sourceMethod);
+    }
+
+    public void entering(String sourceClass, String sourceMethod, Object param1) {
+        log(Level.FINER, "ENTRY " + sourceClass + "." + sourceMethod + " " + param1);
+    }
+
+    public void exiting(String sourceClass, String sourceMethod) {
+        log(Level.FINER, "RETURN " + sourceClass + "." + sourceMethod);
+    }
+
+    public void exiting(String sourceClass, String sourceMethod, Object result) {
+        log(Level.FINER, "RETURN " + sourceClass + "." + sourceMethod + " " + result);
+    }
+
+    public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
+        log(Level.FINER, "THROW " + sourceClass + "." + sourceMethod, thrown);
+    }
+
+    public void severe(String msg) {
+        log(Level.SEVERE, msg);
+    }
+
+    public void warning(String msg) {
+        log(Level.WARNING, msg);
+    }
+
+    public void info(String msg) {
+        log(Level.INFO, msg);
+    }
+
+    public void config(String msg) {
+        log(Level.CONFIG, msg);
+    }
+
+    public void fine(String msg) {
+        log(Level.FINE, msg);
+    }
+
+    public void finer(String msg) {
+        log(Level.FINER, msg);
+    }
+
+    public void finest(String msg) {
+        log(Level.FINEST, msg);
+    }
+
+    public void severe(Supplier<String> msgSupplier) {
+        log(Level.SEVERE, msgSupplier);
+    }
+
+    public void warning(Supplier<String> msgSupplier) {
+        log(Level.WARNING, msgSupplier);
+    }
+
+    public void info(Supplier<String> msgSupplier) {
+        log(Level.INFO, msgSupplier);
+    }
+
+    public void config(Supplier<String> msgSupplier) {
+        log(Level.CONFIG, msgSupplier);
+    }
+
+    public void fine(Supplier<String> msgSupplier) {
+        log(Level.FINE, msgSupplier);
+    }
+
+    public void finer(Supplier<String> msgSupplier) {
+        log(Level.FINER, msgSupplier);
+    }
+
+    public void finest(Supplier<String> msgSupplier) {
+        log(Level.FINEST, msgSupplier);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/prefs/BackingStoreException.java b/Ports/CLDC11/src/java/util/prefs/BackingStoreException.java
new file mode 100644
index 00000000000..819fd8a4867
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/prefs/BackingStoreException.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.prefs;
+
+/// A failure of the store under the preferences.
+/// [Preferences] declares it where the JDK does and never throws it: the
+/// store it writes to does not fail that way.
+public class BackingStoreException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    public BackingStoreException(String s) {
+        super(s);
+    }
+
+    public BackingStoreException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/prefs/Preferences.java b/Ports/CLDC11/src/java/util/prefs/Preferences.java
new file mode 100644
index 00000000000..7f446fe2749
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/prefs/Preferences.java
@@ -0,0 +1,529 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.prefs;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// Preferences kept in the platform's preference store, which
+/// `com.codename1.impl.JdkHost` reaches: `com.codename1.io.Preferences` in a
+/// Codename One application, memory for this run elsewhere.
+///
+/// The store is one flat table of the application's own, so a node is a
+/// prefix: the value of `key` in the node `/com/acme` is stored under the
+/// node's path and the key. The user and the system trees are the same
+/// tree -- an application on a device has no machine-wide settings to write.
+/// Every value is stored as text, as the JDK stores it, so `getInt` of
+/// something written with `put` reads it back.
+///
+/// Each node keeps the list of its keys beside them, which is what `keys`
+/// and `clear` answer from; the store cannot be asked for it. A node also
+/// keeps the names of its children that hold a key, or have a descendant
+/// that does: that is what `childrenNames` answers and what `removeNode`
+/// walks to remove a whole subtree. A node that only ever was asked for,
+/// and never written to, is not listed.
+///
+/// Writes are saved as they are made. `flush` and `sync` do nothing, and
+/// there are no change listeners.
+public abstract class Preferences {
+
+    public static final int MAX_KEY_LENGTH = 80;
+    public static final int MAX_VALUE_LENGTH = 8192;
+    public static final int MAX_NAME_LENGTH = 80;
+
+    private final String path;
+
+    /// [#removalCount] as it stood when this instance was made: a removal
+    /// of this node, or of one above it, numbered higher happened to it.
+    private final long born;
+
+    /// For the JDK's shape; the nodes this class hands out are its own.
+    protected Preferences() {
+        this("/");
+    }
+
+    private Preferences(String path) {
+        this.path = path;
+        synchronized (STORE_LOCK) {
+            born = removalCount;
+        }
+    }
+
+    public static Preferences userRoot() {
+        return new Node("/");
+    }
+
+    public static Preferences systemRoot() {
+        return new Node("/");
+    }
+
+    public static Preferences userNodeForPackage(Class<?> c) {
+        return new Node(packagePath(c));
+    }
+
+    public static Preferences systemNodeForPackage(Class<?> c) {
+        return new Node(packagePath(c));
+    }
+
+    private static String packagePath(Class<?> c) {
+        if (c.isArray()) {
+            throw new IllegalArgumentException("Arrays have no associated preferences node.");
+        }
+        String name = c.getName();
+        int dot = name.lastIndexOf('.');
+        return dot < 0 ? "/<unnamed>" : "/" + name.substring(0, dot).replace('.', '/');
+    }
+
+    /// The node at `pathName`: absolute when it starts with a slash, else
+    /// below this one.
+    public Preferences node(String pathName) {
+        checkLive();
+        if (pathName.length() == 0) {
+            return this;
+        }
+        if (pathName.charAt(0) == '/') {
+            return new Node(pathName);
+        }
+        return new Node("/".equals(path) ? "/" + pathName : path + "/" + pathName);
+    }
+
+    public String name() {
+        return "/".equals(path) ? "" : path.substring(path.lastIndexOf('/') + 1);
+    }
+
+    public String absolutePath() {
+        return path;
+    }
+
+    public Preferences parent() {
+        checkLive();
+        if ("/".equals(path)) {
+            return null;
+        }
+        int slash = path.lastIndexOf('/');
+        return new Node(slash <= 0 ? "/" : path.substring(0, slash));
+    }
+
+    public boolean isUserNode() {
+        return true;
+    }
+
+    /// Where `key` of this node is kept in Codename One's flat store: the
+    /// node's path and the key, each escaped, around one line break.
+    ///
+    /// A key may hold a `/`, so joining the two with one aliased entries:
+    /// `node("a").put("b/c", ...)` and `node("a/b").put("c", ...)` both
+    /// wrote `/a/b/c`. A node name may hold anything but `/`, a line break
+    /// too, so both halves are escaped and the one raw line break left is
+    /// where they meet. The index ([#indexKey()]) ends in a second raw line
+    /// break, which no escaped key can be.
+    private String storeKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("Null key");
+        }
+        return escape(path) + '\n' + escape(key);
+    }
+
+    private String indexKey() {
+        return escape(path) + "\n\n";
+    }
+
+    /// Where the names of the node's children are kept: three raw line
+    /// breaks, which neither a key ([#storeKey]) nor the index can end in.
+    private String childrenKey() {
+        return childrenKey(path);
+    }
+
+    private static String childrenKey(String nodePath) {
+        return escape(nodePath) + "\n\n\n";
+    }
+
+    private static String parentPath(String nodePath) {
+        int slash = nodePath.lastIndexOf('/');
+        return slash <= 0 ? "/" : nodePath.substring(0, slash);
+    }
+
+    private static String escape(String text) {
+        if (text.indexOf('\\') < 0 && text.indexOf('\n') < 0) {
+            return text;
+        }
+        StringBuilder out = new StringBuilder(text.length() + 8);
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == '\\') {
+                out.append("\\\\");
+            } else if (c == '\n') {
+                out.append("\\n");
+            } else {
+                out.append(c);
+            }
+        }
+        return out.toString();
+    }
+
+    /// Guards every use of the store, from every node. Codename One's
+    /// Preferences, and the Storage under it, are written for its one
+    /// thread: two workers saving at once threw inside Storage, which logs
+    /// the failure and goes on, so a value could be lost without a word.
+    /// It also makes each read-modify-write of an index whole: two threads
+    /// adding different keys to one node each read the same index, and the
+    /// one that saved last dropped the other's key for good. Static, since
+    /// two instances can stand for one node.
+    private static final Object STORE_LOCK = new Object();
+
+    /// The nodes removed in this run, each with the number of its removal.
+    /// Nodes are not cached -- two calls to `node` hand out two instances
+    /// for one path -- so an instance cannot be told it was removed; it
+    /// asks here instead, for its path and every one above it.
+    private static final Map<String, Long> REMOVALS = new HashMap<String, Long>();
+
+    private static long removalCount;
+
+    /// Throws as the JDK does for any use of a removed node.
+    private void checkLive() {
+        synchronized (STORE_LOCK) {
+            if (isRemoved()) {
+                throw new IllegalStateException("Node has been removed.");
+            }
+        }
+    }
+
+    /// Called under [#STORE_LOCK].
+    private boolean isRemoved() {
+        if (REMOVALS.isEmpty()) {
+            return false;
+        }
+        String at = path;
+        while (true) {
+            Long when = REMOVALS.get(at);
+            if (when != null && when.longValue() > born) {
+                return true;
+            }
+            if ("/".equals(at)) {
+                return false;
+            }
+            at = parentPath(at);
+        }
+    }
+
+    /// The node's keys, one per line. A key may hold any character, a line
+    /// break too, so a backslash and a line break inside one are written as
+    /// `\\` and `\n`; see [#saveIndex].
+    private List<String> index() {
+        return readList(indexKey());
+    }
+
+    private void saveIndex(List<String> keys) {
+        saveList(indexKey(), keys);
+    }
+
+    private static List<String> readList(String storeKey) {
+        List<String> keys = new ArrayList<String>();
+        String all = stored(storeKey, "");
+        StringBuilder key = new StringBuilder();
+        for (int i = 0; i < all.length(); i++) {
+            char c = all.charAt(i);
+            if (c == '\\' && i + 1 < all.length()) {
+                i++;
+                key.append(all.charAt(i) == 'n' ? '\n' : all.charAt(i));
+            } else if (c == '\n') {
+                keys.add(key.toString());
+                key.setLength(0);
+            } else {
+                key.append(c);
+            }
+        }
+        if (key.length() > 0) {
+            keys.add(key.toString());
+        }
+        return keys;
+    }
+
+    private static void saveList(String storeKey, List<String> keys) {
+        if (keys.isEmpty()) {
+            JdkHost.get().deletePreference(storeKey);
+            return;
+        }
+        StringBuilder all = new StringBuilder();
+        for (String key : keys) {
+            for (int i = 0; i < key.length(); i++) {
+                char c = key.charAt(i);
+                if (c == '\\') {
+                    all.append("\\\\");
+                } else if (c == '\n') {
+                    all.append("\\n");
+                } else {
+                    all.append(c);
+                }
+            }
+            all.append('\n');
+        }
+        JdkHost.get().setPreference(storeKey, all.toString());
+    }
+
+    /// Lists this node with its parent, and so on up, so that removing an
+    /// ancestor finds it. Stops at the first one already listed: a node is
+    /// only ever listed after everything above it.
+    private void register() {
+        String at = path;
+        while (!"/".equals(at)) {
+            String parent = parentPath(at);
+            String name = at.substring(at.lastIndexOf('/') + 1);
+            String key = childrenKey(parent);
+            List<String> names = readList(key);
+            if (names.contains(name)) {
+                return;
+            }
+            names.add(name);
+            saveList(key, names);
+            at = parent;
+        }
+    }
+
+    /// Deletes every entry of `nodePath` and of every node listed below it.
+    private static void removeTree(String nodePath) {
+        for (String child : readList(childrenKey(nodePath))) {
+            removeTree("/".equals(nodePath) ? "/" + child : nodePath + "/" + child);
+        }
+        String prefix = escape(nodePath) + '\n';
+        for (String key : readList(prefix + '\n')) {
+            JdkHost.get().deletePreference(prefix + escape(key));
+        }
+        JdkHost.get().deletePreference(prefix + '\n');
+        JdkHost.get().deletePreference(childrenKey(nodePath));
+    }
+
+    public void put(String key, String value) {
+        if (value == null) {
+            throw new NullPointerException("Null value");
+        }
+        synchronized (STORE_LOCK) {
+            checkLive();
+            JdkHost.get().setPreference(storeKey(key), value);
+            List<String> keys = index();
+            if (!keys.contains(key)) {
+                keys.add(key);
+                saveIndex(keys);
+            }
+            register();
+        }
+    }
+
+    public String get(String key, String def) {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            return stored(storeKey(key), def);
+        }
+    }
+
+    public void remove(String key) {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            JdkHost.get().deletePreference(storeKey(key));
+            List<String> keys = index();
+            if (keys.remove(key)) {
+                saveIndex(keys);
+            }
+        }
+    }
+
+    public void clear() throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            for (String key : index()) {
+                JdkHost.get().deletePreference(storeKey(key));
+            }
+            saveIndex(new ArrayList<String>());
+        }
+    }
+
+    public String[] keys() throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            List<String> keys = index();
+            return keys.toArray(new String[keys.size()]);
+        }
+    }
+
+    /// The children that hold a key, or have a descendant that does; see
+    /// the class description.
+    public String[] childrenNames() throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            List<String> names = readList(childrenKey());
+            return names.toArray(new String[names.size()]);
+        }
+    }
+
+    /// As the JDK: `nodeExists("")` answers whether this node is still
+    /// there, and is the one question a removed node may still be asked.
+    public boolean nodeExists(String pathName) throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            if (pathName.length() == 0) {
+                return !isRemoved();
+            }
+            Preferences node = node(pathName);
+            return !node.index().isEmpty() || !readList(node.childrenKey()).isEmpty();
+        }
+    }
+
+    /// Removes this node and everything below it, as the JDK does: their
+    /// entries are deleted, this instance and every other one for the
+    /// removed nodes throw `IllegalStateException` from then on, and a node
+    /// asked for again by its path afterwards is a new, empty one. The root
+    /// cannot be removed.
+    public void removeNode() throws BackingStoreException {
+        if ("/".equals(path)) {
+            throw new UnsupportedOperationException("Can't remove the root!");
+        }
+        synchronized (STORE_LOCK) {
+            if (isRemoved()) {
+                throw new IllegalStateException("Node already removed.");
+            }
+            removeTree(path);
+            String parentKey = childrenKey(parentPath(path));
+            List<String> siblings = readList(parentKey);
+            if (siblings.remove(path.substring(path.lastIndexOf('/') + 1))) {
+                saveList(parentKey, siblings);
+            }
+            recordRemoval(path);
+        }
+    }
+
+    /// Called under [#STORE_LOCK].
+    private static void recordRemoval(String nodePath) {
+        removalCount++;
+        REMOVALS.put(nodePath, Long.valueOf(removalCount));
+    }
+
+    public void putInt(String key, int value) {
+        put(key, Integer.toString(value));
+    }
+
+    public int getInt(String key, int def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Integer.parseInt(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void putLong(String key, long value) {
+        put(key, Long.toString(value));
+    }
+
+    public long getLong(String key, long def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Long.parseLong(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void putBoolean(String key, boolean value) {
+        put(key, value ? "true" : "false");
+    }
+
+    public boolean getBoolean(String key, boolean def) {
+        String value = get(key, null);
+        if ("true".equalsIgnoreCase(value)) {
+            return true;
+        }
+        if ("false".equalsIgnoreCase(value)) {
+            return false;
+        }
+        return def;
+    }
+
+    public void putFloat(String key, float value) {
+        put(key, Float.toString(value));
+    }
+
+    public float getFloat(String key, float def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Float.parseFloat(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void putDouble(String key, double value) {
+        put(key, Double.toString(value));
+    }
+
+    public double getDouble(String key, double def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Double.parseDouble(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void flush() throws BackingStoreException {
+        // Saved as written; see the class description.
+    }
+
+    public void sync() throws BackingStoreException {
+        // Saved as written; see the class description. A removed node
+        // cannot be synced, as with the JDK (flushing one is allowed).
+        checkLive();
+    }
+
+    @Override
+    public String toString() {
+        return "User Preference Node: " + path;
+    }
+
+    /// The stored value of `storeKey`, or `def`.
+    private static String stored(String storeKey, String def) {
+        String value = JdkHost.get().preference(storeKey);
+        return value == null ? def : value;
+    }
+
+    /// The one concrete node.
+    private static final class Node extends Preferences {
+        Node(String path) {
+            super(path);
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/BaseStream.java b/Ports/CLDC11/src/java/util/stream/BaseStream.java
index 63e61583529..7310abdb7bb 100644
--- a/Ports/CLDC11/src/java/util/stream/BaseStream.java
+++ b/Ports/CLDC11/src/java/util/stream/BaseStream.java
@@ -24,14 +24,25 @@
 
 import java.util.Iterator;
 
+/// What the
+/// object stream and the three primitive ones have in common.
+///
+/// Streams here are sequential. `parallel()` exists because code calls it,
+/// and answers the stream it was called on.
 public interface BaseStream<T, S extends BaseStream<T, S>> extends AutoCloseable {
+
     Iterator<T> iterator();
 
+    boolean isParallel();
+
     S sequential();
 
     S parallel();
 
+    S unordered();
+
     S onClose(Runnable closeHandler);
 
+    @Override
     void close();
 }
diff --git a/Ports/CLDC11/src/java/util/stream/Collector.java b/Ports/CLDC11/src/java/util/stream/Collector.java
index 67a7519bb39..767b5541de6 100644
--- a/Ports/CLDC11/src/java/util/stream/Collector.java
+++ b/Ports/CLDC11/src/java/util/stream/Collector.java
@@ -1,11 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.stream;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+/// How [Stream#collect(Collector)] folds the elements of a stream into a
+/// result: a container to start from, a step per element, a way to merge two
+/// containers and a last step that turns the container into the result.
 public interface Collector<T, A, R> {
+
     Supplier<A> supplier();
 
     BiConsumer<A, T> accumulator();
@@ -13,4 +43,37 @@ public interface Collector<T, A, R> {
     BinaryOperator<A> combiner();
 
     Function<A, R> finisher();
+
+    Set<Characteristics> characteristics();
+
+    static <T, R> Collector<T, R, R> of(Supplier<R> supplier, BiConsumer<R, T> accumulator,
+                                        BinaryOperator<R> combiner, Characteristics... characteristics) {
+        if (supplier == null || accumulator == null || combiner == null || characteristics == null) {
+            throw new NullPointerException();
+        }
+        Set<Characteristics> all = new HashSet<Characteristics>(Arrays.asList(characteristics));
+        all.add(Characteristics.IDENTITY_FINISH);
+        return new Collectors.Of<T, R, R>(supplier, accumulator, combiner, Function.<R>identity(),
+                Collections.unmodifiableSet(all));
+    }
+
+    static <T, A, R> Collector<T, A, R> of(Supplier<A> supplier, BiConsumer<A, T> accumulator,
+                                           BinaryOperator<A> combiner, Function<A, R> finisher,
+                                           Characteristics... characteristics) {
+        if (supplier == null || accumulator == null || combiner == null || finisher == null
+                || characteristics == null) {
+            throw new NullPointerException();
+        }
+        Set<Characteristics> all = new HashSet<Characteristics>(Arrays.asList(characteristics));
+        return new Collectors.Of<T, A, R>(supplier, accumulator, combiner, finisher,
+                Collections.unmodifiableSet(all));
+    }
+
+    /// What a collector says about itself. Nothing here acts on them: a
+    /// sequential stream runs every collector the same way.
+    enum Characteristics {
+        CONCURRENT,
+        UNORDERED,
+        IDENTITY_FINISH
+    }
 }
diff --git a/Ports/CLDC11/src/java/util/stream/Collectors.java b/Ports/CLDC11/src/java/util/stream/Collectors.java
index d1a34e20db1..3ef7bb0e244 100644
--- a/Ports/CLDC11/src/java/util/stream/Collectors.java
+++ b/Ports/CLDC11/src/java/util/stream/Collectors.java
@@ -1,14 +1,785 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.stream;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IntSummaryStatistics;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+/// The common [Collector]s: into collections, maps, strings, groups and
+/// numbers.
+///
+/// The results are the JDK's: `groupingBy` answers a `HashMap` of
+/// `ArrayList`s unless told otherwise, `toMap` refuses a second value for a
+/// key unless given a function to merge them, and the unmodifiable variants
+/// refuse null.
+///
+/// Every function here is a class of its own, made only by the method that
+/// needs it, so an application carries the collectors it uses and no others.
 public final class Collectors {
+
     private Collectors() {
     }
 
-    public static <T> Collector<T, ?, java.util.List<T>> toList() {
-        return null;
+    /// A collector made of its four functions.
+    static final class Of<T, A, R> implements Collector<T, A, R> {
+
+        private final Supplier<A> supplier;
+        private final BiConsumer<A, T> accumulator;
+        private final BinaryOperator<A> combiner;
+        private final Function<A, R> finisher;
+        private final Set<Characteristics> characteristics;
+
+        Of(Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner, Function<A, R> finisher,
+           Set<Characteristics> characteristics) {
+            this.supplier = supplier;
+            this.accumulator = accumulator;
+            this.combiner = combiner;
+            this.finisher = finisher;
+            this.characteristics = characteristics;
+        }
+
+        @Override
+        public Supplier<A> supplier() {
+            return supplier;
+        }
+
+        @Override
+        public BiConsumer<A, T> accumulator() {
+            return accumulator;
+        }
+
+        @Override
+        public BinaryOperator<A> combiner() {
+            return combiner;
+        }
+
+        @Override
+        public Function<A, R> finisher() {
+            return finisher;
+        }
+
+        @Override
+        public Set<Characteristics> characteristics() {
+            return characteristics;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T, A, R> Collector<T, A, R> of(Supplier<A> supplier, BiConsumer<A, ? super T> accumulator,
+                                                   BinaryOperator<A> combiner, Function<A, R> finisher) {
+        return new Of<T, A, R>(supplier, (BiConsumer<A, T>) accumulator, combiner, finisher,
+                Collections.<Collector.Characteristics>emptySet());
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <A, R> Function<A, R> castingIdentity() {
+        return (Function<A, R>) Function.identity();
+    }
+
+    /// One value being folded, and whether any element reached it yet.
+    private static final class Box<T> {
+        T value;
+        boolean present;
+
+        Box(T value, boolean present) {
+            this.value = value;
+            this.present = present;
+        }
+    }
+
+    // ---- into collections ----
+
+    private static <T, C extends Collection<T>> BiConsumer<C, T> adder() {
+        return new BiConsumer<C, T>() {
+            @Override
+            public void accept(C c, T t) {
+                c.add(t);
+            }
+        };
+    }
+
+    private static <T, C extends Collection<T>> BinaryOperator<C> addAll() {
+        return new BinaryOperator<C>() {
+            @Override
+            public C apply(C a, C b) {
+                a.addAll(b);
+                return a;
+            }
+        };
+    }
+
+    private static <T> Supplier<List<T>> newArrayList() {
+        return new Supplier<List<T>>() {
+            @Override
+            public List<T> get() {
+                return new ArrayList<T>();
+            }
+        };
+    }
+
+    private static <T> Supplier<Set<T>> newHashSet() {
+        return new Supplier<Set<T>>() {
+            @Override
+            public Set<T> get() {
+                return new HashSet<T>();
+            }
+        };
+    }
+
+    public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
+        Objects.requireNonNull(collectionFactory);
+        return Collectors.<T, C, C>of(collectionFactory, Collectors.<T, C>adder(), Collectors.<T, C>addAll(),
+                Collectors.<C, C>castingIdentity());
+    }
+
+    public static <T> Collector<T, ?, List<T>> toList() {
+        return Collectors.<T, List<T>, List<T>>of(Collectors.<T>newArrayList(), Collectors.<T, List<T>>adder(),
+                Collectors.<T, List<T>>addAll(), Collectors.<List<T>, List<T>>castingIdentity());
+    }
+
+    public static <T> Collector<T, ?, List<T>> toUnmodifiableList() {
+        return Collectors.<T, List<T>, List<T>>of(Collectors.<T>newArrayList(), Collectors.<T, List<T>>adder(),
+                Collectors.<T, List<T>>addAll(), new Function<List<T>, List<T>>() {
+                    @Override
+                    public List<T> apply(List<T> c) {
+                        return List.copyOf(c);
+                    }
+                });
+    }
+
+    public static <T> Collector<T, ?, Set<T>> toSet() {
+        return Collectors.<T, Set<T>, Set<T>>of(Collectors.<T>newHashSet(), Collectors.<T, Set<T>>adder(),
+                Collectors.<T, Set<T>>addAll(), Collectors.<Set<T>, Set<T>>castingIdentity());
+    }
+
+    public static <T> Collector<T, ?, Set<T>> toUnmodifiableSet() {
+        return Collectors.<T, Set<T>, Set<T>>of(Collectors.<T>newHashSet(), Collectors.<T, Set<T>>adder(),
+                Collectors.<T, Set<T>>addAll(), new Function<Set<T>, Set<T>>() {
+                    @Override
+                    public Set<T> apply(Set<T> c) {
+                        return Set.copyOf(c);
+                    }
+                });
+    }
+
+    // ---- into a string ----
+
+    /// What `java.util.StringJoiner` does for [#joining(CharSequence,
+    /// CharSequence, CharSequence)].
+    private static final class Joiner {
+        private final String delimiter;
+        private final String prefix;
+        private final String suffix;
+        private StringBuilder value;
+
+        Joiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix) {
+            this.delimiter = delimiter.toString();
+            this.prefix = prefix.toString();
+            this.suffix = suffix.toString();
+        }
+
+        private StringBuilder next() {
+            if (value == null) {
+                value = new StringBuilder().append(prefix);
+            } else {
+                value.append(delimiter);
+            }
+            return value;
+        }
+
+        void add(CharSequence s) {
+            next().append(String.valueOf(s));
+        }
+
+        /// Adds what `other` holds, without its prefix and suffix, as one element.
+        void merge(Joiner other) {
+            if (other.value != null) {
+                next().append(other.value, other.prefix.length(), other.value.length());
+            }
+        }
+
+        @Override
+        public String toString() {
+            return value == null ? prefix + suffix : value.toString() + suffix;
+        }
     }
 
     public static Collector<CharSequence, ?, String> joining() {
-        return null;
+        return Collectors.<CharSequence, StringBuilder, String>of(new Supplier<StringBuilder>() {
+            @Override
+            public StringBuilder get() {
+                return new StringBuilder();
+            }
+        }, new BiConsumer<StringBuilder, CharSequence>() {
+            @Override
+            public void accept(StringBuilder sb, CharSequence s) {
+                sb.append(String.valueOf(s));
+            }
+        }, new BinaryOperator<StringBuilder>() {
+            @Override
+            public StringBuilder apply(StringBuilder a, StringBuilder b) {
+                return a.append(b.toString());
+            }
+        }, new Function<StringBuilder, String>() {
+            @Override
+            public String apply(StringBuilder sb) {
+                return sb.toString();
+            }
+        });
+    }
+
+    public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
+        return joining(delimiter, "", "");
+    }
+
+    public static Collector<CharSequence, ?, String> joining(final CharSequence delimiter,
+                                                             final CharSequence prefix, final CharSequence suffix) {
+        if (delimiter == null || prefix == null || suffix == null) {
+            throw new NullPointerException();
+        }
+        return Collectors.<CharSequence, Joiner, String>of(new Supplier<Joiner>() {
+            @Override
+            public Joiner get() {
+                return new Joiner(delimiter, prefix, suffix);
+            }
+        }, new BiConsumer<Joiner, CharSequence>() {
+            @Override
+            public void accept(Joiner j, CharSequence s) {
+                j.add(s);
+            }
+        }, new BinaryOperator<Joiner>() {
+            @Override
+            public Joiner apply(Joiner a, Joiner b) {
+                a.merge(b);
+                return a;
+            }
+        }, new Function<Joiner, String>() {
+            @Override
+            public String apply(Joiner j) {
+                return j.toString();
+            }
+        });
+    }
+
+    // ---- adapting another collector ----
+
+    public static <T, U, A, R> Collector<T, ?, R> mapping(final Function<? super T, ? extends U> mapper,
+                                                          Collector<? super U, A, R> downstream) {
+        Objects.requireNonNull(mapper);
+        final BiConsumer<A, ? super U> inner = downstream.accumulator();
+        return Collectors.<T, A, R>of(downstream.supplier(), new BiConsumer<A, T>() {
+            @Override
+            public void accept(A a, T t) {
+                inner.accept(a, mapper.apply(t));
+            }
+        }, downstream.combiner(), downstream.finisher());
+    }
+
+    public static <T, A, R> Collector<T, ?, R> filtering(final Predicate<? super T> predicate,
+                                                         Collector<? super T, A, R> downstream) {
+        Objects.requireNonNull(predicate);
+        final BiConsumer<A, ? super T> inner = downstream.accumulator();
+        return Collectors.<T, A, R>of(downstream.supplier(), new BiConsumer<A, T>() {
+            @Override
+            public void accept(A a, T t) {
+                if (predicate.test(t)) {
+                    inner.accept(a, t);
+                }
+            }
+        }, downstream.combiner(), downstream.finisher());
+    }
+
+    public static <T, U, A, R> Collector<T, ?, R> flatMapping(
+            final Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, A, R> downstream) {
+        Objects.requireNonNull(mapper);
+        final BiConsumer<A, ? super U> inner = downstream.accumulator();
+        return Collectors.<T, A, R>of(downstream.supplier(), new BiConsumer<A, T>() {
+            @Override
+            public void accept(A a, T t) {
+                Stream<? extends U> mapped = mapper.apply(t);
+                if (mapped != null) {
+                    try {
+                        Iterator<? extends U> it = mapped.iterator();
+                        while (it.hasNext()) {
+                            inner.accept(a, it.next());
+                        }
+                    } finally {
+                        mapped.close();
+                    }
+                }
+            }
+        }, downstream.combiner(), downstream.finisher());
+    }
+
+    public static <T, A, R, RR> Collector<T, A, RR> collectingAndThen(Collector<T, A, R> downstream,
+                                                                      final Function<R, RR> finisher) {
+        Objects.requireNonNull(finisher);
+        final Function<A, R> first = downstream.finisher();
+        return Collectors.<T, A, RR>of(downstream.supplier(), downstream.accumulator(), downstream.combiner(),
+                new Function<A, RR>() {
+                    @Override
+                    public RR apply(A a) {
+                        return finisher.apply(first.apply(a));
+                    }
+                });
+    }
+
+    // ---- numbers ----
+
+    /// Folds the `long` values `mapper` answers into a [LongSummaryStatistics];
+    /// `mapper` null counts the elements instead.
+    private static <T> Collector<T, LongSummaryStatistics, LongSummaryStatistics> longs(
+            final ToLongFunction<? super T> mapper) {
+        return Collectors.<T, LongSummaryStatistics, LongSummaryStatistics>of(
+                new Supplier<LongSummaryStatistics>() {
+                    @Override
+                    public LongSummaryStatistics get() {
+                        return new LongSummaryStatistics();
+                    }
+                }, new BiConsumer<LongSummaryStatistics, T>() {
+                    @Override
+                    public void accept(LongSummaryStatistics a, T t) {
+                        a.accept(mapper == null ? 1L : mapper.applyAsLong(t));
+                    }
+                }, new BinaryOperator<LongSummaryStatistics>() {
+                    @Override
+                    public LongSummaryStatistics apply(LongSummaryStatistics a, LongSummaryStatistics b) {
+                        a.combine(b);
+                        return a;
+                    }
+                }, Collectors.<LongSummaryStatistics, LongSummaryStatistics>castingIdentity());
+    }
+
+    private static <T> Collector<T, IntSummaryStatistics, IntSummaryStatistics> ints(
+            final ToIntFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, IntSummaryStatistics, IntSummaryStatistics>of(
+                new Supplier<IntSummaryStatistics>() {
+                    @Override
+                    public IntSummaryStatistics get() {
+                        return new IntSummaryStatistics();
+                    }
+                }, new BiConsumer<IntSummaryStatistics, T>() {
+                    @Override
+                    public void accept(IntSummaryStatistics a, T t) {
+                        a.accept(mapper.applyAsInt(t));
+                    }
+                }, new BinaryOperator<IntSummaryStatistics>() {
+                    @Override
+                    public IntSummaryStatistics apply(IntSummaryStatistics a, IntSummaryStatistics b) {
+                        a.combine(b);
+                        return a;
+                    }
+                }, Collectors.<IntSummaryStatistics, IntSummaryStatistics>castingIdentity());
+    }
+
+    private static <T> Collector<T, DoubleSummaryStatistics, DoubleSummaryStatistics> doubles(
+            final ToDoubleFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, DoubleSummaryStatistics, DoubleSummaryStatistics>of(
+                new Supplier<DoubleSummaryStatistics>() {
+                    @Override
+                    public DoubleSummaryStatistics get() {
+                        return new DoubleSummaryStatistics();
+                    }
+                }, new BiConsumer<DoubleSummaryStatistics, T>() {
+                    @Override
+                    public void accept(DoubleSummaryStatistics a, T t) {
+                        a.accept(mapper.applyAsDouble(t));
+                    }
+                }, new BinaryOperator<DoubleSummaryStatistics>() {
+                    @Override
+                    public DoubleSummaryStatistics apply(DoubleSummaryStatistics a, DoubleSummaryStatistics b) {
+                        a.combine(b);
+                        return a;
+                    }
+                }, Collectors.<DoubleSummaryStatistics, DoubleSummaryStatistics>castingIdentity());
+    }
+
+    /// Statistics a collector folds into, answering one of their figures.
+    private static final int SUM = 0;
+    private static final int AVERAGE = 1;
+    private static final int COUNT = 2;
+
+    private static <S, R> Function<S, R> figure(final int which) {
+        return new Function<S, R>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public R apply(S s) {
+                Object out;
+                if (s instanceof IntSummaryStatistics) {
+                    IntSummaryStatistics i = (IntSummaryStatistics) s;
+                    out = which == SUM ? (Object) Integer.valueOf((int) i.getSum()) : Double.valueOf(i.getAverage());
+                } else if (s instanceof LongSummaryStatistics) {
+                    LongSummaryStatistics l = (LongSummaryStatistics) s;
+                    out = which == AVERAGE ? (Object) Double.valueOf(l.getAverage())
+                            : Long.valueOf(which == SUM ? l.getSum() : l.getCount());
+                } else {
+                    DoubleSummaryStatistics d = (DoubleSummaryStatistics) s;
+                    out = Double.valueOf(which == SUM ? d.getSum() : d.getAverage());
+                }
+                return (R) out;
+            }
+        };
+    }
+
+    private static <T, S, R> Collector<T, S, R> finishing(Collector<T, S, S> folded, int which) {
+        return Collectors.<T, S, R>of(folded.supplier(), folded.accumulator(), folded.combiner(),
+                Collectors.<S, R>figure(which));
+    }
+
+    public static <T> Collector<T, ?, Long> counting() {
+        return Collectors.<T, LongSummaryStatistics, Long>finishing(Collectors.<T>longs(null), COUNT);
+    }
+
+    public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper) {
+        return Collectors.<T, IntSummaryStatistics, Integer>finishing(ints(mapper), SUM);
+    }
+
+    public static <T> Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, LongSummaryStatistics, Long>finishing(longs(mapper), SUM);
+    }
+
+    public static <T> Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper) {
+        return Collectors.<T, DoubleSummaryStatistics, Double>finishing(doubles(mapper), SUM);
+    }
+
+    public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper) {
+        return Collectors.<T, IntSummaryStatistics, Double>finishing(ints(mapper), AVERAGE);
+    }
+
+    public static <T> Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, LongSummaryStatistics, Double>finishing(longs(mapper), AVERAGE);
+    }
+
+    public static <T> Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper) {
+        return Collectors.<T, DoubleSummaryStatistics, Double>finishing(doubles(mapper), AVERAGE);
+    }
+
+    public static <T> Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper) {
+        return ints(mapper);
+    }
+
+    public static <T> Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return longs(mapper);
+    }
+
+    public static <T> Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(
+            ToDoubleFunction<? super T> mapper) {
+        return doubles(mapper);
+    }
+
+    // ---- reductions ----
+
+    public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op) {
+        return Collectors.<T, T>reducing(identity, Function.<T>identity(), op);
+    }
+
+    public static <T> Collector<T, ?, Optional<T>> reducing(final BinaryOperator<T> op) {
+        Objects.requireNonNull(op);
+        return Collectors.<T, Box<T>, Optional<T>>of(new Supplier<Box<T>>() {
+            @Override
+            public Box<T> get() {
+                return new Box<T>(null, false);
+            }
+        }, new BiConsumer<Box<T>, T>() {
+            @Override
+            public void accept(Box<T> a, T t) {
+                a.value = a.present ? op.apply(a.value, t) : t;
+                a.present = true;
+            }
+        }, new BinaryOperator<Box<T>>() {
+            @Override
+            public Box<T> apply(Box<T> a, Box<T> b) {
+                if (b.present) {
+                    a.value = a.present ? op.apply(a.value, b.value) : b.value;
+                    a.present = true;
+                }
+                return a;
+            }
+        }, new Function<Box<T>, Optional<T>>() {
+            @Override
+            public Optional<T> apply(Box<T> a) {
+                return Optional.ofNullable(a.value);
+            }
+        });
+    }
+
+    public static <T, U> Collector<T, ?, U> reducing(final U identity, final Function<? super T, ? extends U> mapper,
+                                                     final BinaryOperator<U> op) {
+        Objects.requireNonNull(mapper);
+        Objects.requireNonNull(op);
+        return Collectors.<T, Box<U>, U>of(new Supplier<Box<U>>() {
+            @Override
+            public Box<U> get() {
+                return new Box<U>(identity, true);
+            }
+        }, new BiConsumer<Box<U>, T>() {
+            @Override
+            public void accept(Box<U> a, T t) {
+                a.value = op.apply(a.value, mapper.apply(t));
+            }
+        }, new BinaryOperator<Box<U>>() {
+            @Override
+            public Box<U> apply(Box<U> a, Box<U> b) {
+                a.value = op.apply(a.value, b.value);
+                return a;
+            }
+        }, new Function<Box<U>, U>() {
+            @Override
+            public U apply(Box<U> a) {
+                return a.value;
+            }
+        });
+    }
+
+    public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator) {
+        return reducing(BinaryOperator.<T>minBy(comparator));
+    }
+
+    public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator) {
+        return reducing(BinaryOperator.<T>maxBy(comparator));
+    }
+
+    // ---- groups ----
+
+    public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier) {
+        return groupingBy(classifier, Collectors.<T>toList());
+    }
+
+    public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
+                                                                     Collector<? super T, A, D> downstream) {
+        return Collectors.<T, K, D, A, Map<K, D>>groupingBy(classifier, new Supplier<Map<K, D>>() {
+            @Override
+            public Map<K, D> get() {
+                return new HashMap<K, D>();
+            }
+        }, downstream);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(
+            final Function<? super T, ? extends K> classifier, final Supplier<M> mapFactory,
+            Collector<? super T, A, D> downstream) {
+        Objects.requireNonNull(classifier);
+        Objects.requireNonNull(mapFactory);
+        final Supplier<A> innerSupplier = downstream.supplier();
+        final BiConsumer<A, ? super T> innerAccumulator = downstream.accumulator();
+        final BinaryOperator<A> innerCombiner = downstream.combiner();
+        final Function<A, D> innerFinisher = downstream.finisher();
+        // While elements arrive the map holds each group's container, and
+        // the finisher puts the group's result in its place: one map, of
+        // the kind the caller asked for.
+        return Collectors.<T, Map<K, A>, M>of(new Supplier<Map<K, A>>() {
+            @Override
+            public Map<K, A> get() {
+                return (Map<K, A>) mapFactory.get();
+            }
+        }, new BiConsumer<Map<K, A>, T>() {
+            @Override
+            public void accept(Map<K, A> m, T t) {
+                K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
+                A container = m.get(key);
+                if (container == null) {
+                    container = innerSupplier.get();
+                    m.put(key, container);
+                }
+                innerAccumulator.accept(container, t);
+            }
+        }, new BinaryOperator<Map<K, A>>() {
+            @Override
+            public Map<K, A> apply(Map<K, A> a, Map<K, A> b) {
+                for (Map.Entry<K, A> e : b.entrySet()) {
+                    A mine = a.get(e.getKey());
+                    a.put(e.getKey(), mine == null ? e.getValue() : innerCombiner.apply(mine, e.getValue()));
+                }
+                return a;
+            }
+        }, new Function<Map<K, A>, M>() {
+            @Override
+            public M apply(Map<K, A> m) {
+                Map<K, Object> out = (Map<K, Object>) m;
+                for (K key : new ArrayList<K>(m.keySet())) {
+                    out.put(key, innerFinisher.apply(m.get(key)));
+                }
+                return (M) out;
+            }
+        });
+    }
+
+    public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
+        return partitioningBy(predicate, Collectors.<T>toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(final Predicate<? super T> predicate,
+                                                                            Collector<? super T, A, D> downstream) {
+        Objects.requireNonNull(predicate);
+        final Supplier<A> innerSupplier = downstream.supplier();
+        final BiConsumer<A, ? super T> innerAccumulator = downstream.accumulator();
+        final BinaryOperator<A> innerCombiner = downstream.combiner();
+        final Function<A, D> innerFinisher = downstream.finisher();
+        return Collectors.<T, Object[], Map<Boolean, D>>of(new Supplier<Object[]>() {
+            @Override
+            public Object[] get() {
+                return new Object[] {innerSupplier.get(), innerSupplier.get()};
+            }
+        }, new BiConsumer<Object[], T>() {
+            @Override
+            public void accept(Object[] a, T t) {
+                innerAccumulator.accept((A) a[predicate.test(t) ? 1 : 0], t);
+            }
+        }, new BinaryOperator<Object[]>() {
+            @Override
+            public Object[] apply(Object[] a, Object[] b) {
+                a[0] = innerCombiner.apply((A) a[0], (A) b[0]);
+                a[1] = innerCombiner.apply((A) a[1], (A) b[1]);
+                return a;
+            }
+        }, new Function<Object[], Map<Boolean, D>>() {
+            @Override
+            public Map<Boolean, D> apply(Object[] a) {
+                // Both keys are always there, false first.
+                Map<Boolean, D> out = new LinkedHashMap<Boolean, D>();
+                out.put(Boolean.FALSE, innerFinisher.apply((A) a[0]));
+                out.put(Boolean.TRUE, innerFinisher.apply((A) a[1]));
+                return out;
+            }
+        });
+    }
+
+    // ---- maps ----
+
+    /// Puts `value` under `key`; a second value for a key is an error when
+    /// `mergeFunction` is null and merged with the first otherwise, a merged
+    /// null removing the key.
+    static <K, U> void put(Map<K, U> map, K key, U value, BinaryOperator<U> mergeFunction) {
+        Objects.requireNonNull(value);
+        U old = map.get(key);
+        if (old == null) {
+            map.put(key, value);
+            return;
+        }
+        if (mergeFunction == null) {
+            throw new IllegalStateException("Duplicate key " + key + " (attempted merging values " + old + " and "
+                    + value + ")");
+        }
+        U merged = mergeFunction.apply(old, value);
+        if (merged == null) {
+            map.remove(key);
+        } else {
+            map.put(key, merged);
+        }
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper,
+                                                             Function<? super T, ? extends U> valueMapper) {
+        return Collectors.<T, K, U, Map<K, U>>toMap(keyMapper, valueMapper, null, Collectors.<K, U>newHashMap());
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper,
+                                                             Function<? super T, ? extends U> valueMapper,
+                                                             BinaryOperator<U> mergeFunction) {
+        Objects.requireNonNull(mergeFunction);
+        return Collectors.<T, K, U, Map<K, U>>toMap(keyMapper, valueMapper, mergeFunction,
+                Collectors.<K, U>newHashMap());
+    }
+
+    private static <K, U> Supplier<Map<K, U>> newHashMap() {
+        return new Supplier<Map<K, U>>() {
+            @Override
+            public Map<K, U> get() {
+                return new HashMap<K, U>();
+            }
+        };
+    }
+
+    public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
+            final Function<? super T, ? extends K> keyMapper, final Function<? super T, ? extends U> valueMapper,
+            final BinaryOperator<U> mergeFunction, Supplier<M> mapFactory) {
+        Objects.requireNonNull(keyMapper);
+        Objects.requireNonNull(valueMapper);
+        Objects.requireNonNull(mapFactory);
+        return Collectors.<T, M, M>of(mapFactory, new BiConsumer<M, T>() {
+            @Override
+            public void accept(M m, T t) {
+                put(m, keyMapper.apply(t), valueMapper.apply(t), mergeFunction);
+            }
+        }, new BinaryOperator<M>() {
+            @Override
+            public M apply(M a, M b) {
+                for (Map.Entry<K, U> e : b.entrySet()) {
+                    put(a, e.getKey(), e.getValue(), mergeFunction);
+                }
+                return a;
+            }
+        }, Collectors.<M, M>castingIdentity());
+    }
+
+    private static <K, U> Function<Map<K, U>, Map<K, U>> unmodifiableMap() {
+        return new Function<Map<K, U>, Map<K, U>>() {
+            @Override
+            public Map<K, U> apply(Map<K, U> m) {
+                return Map.copyOf(m);
+            }
+        };
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableMap(
+            Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {
+        return collectingAndThen(Collectors.<T, K, U>toMap(keyMapper, valueMapper),
+                Collectors.<K, U>unmodifiableMap());
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableMap(
+            Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
+            BinaryOperator<U> mergeFunction) {
+        return collectingAndThen(Collectors.<T, K, U>toMap(keyMapper, valueMapper, mergeFunction),
+                Collectors.<K, U>unmodifiableMap());
     }
 }
diff --git a/Ports/CLDC11/src/java/util/stream/DoublePipeline.java b/Ports/CLDC11/src/java/util/stream/DoublePipeline.java
new file mode 100644
index 00000000000..0d269c7688a
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/DoublePipeline.java
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.DoubleSummaryStatistics;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleSupplier;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.Function;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// The one implementation of [DoubleStream]: a view of a stream of boxed values,
+/// which does the work. Boxing costs little on ParparVM, where a boxed
+/// `double` from `valueOf` is usually an immediate rather than an object.
+final class DoublePipeline implements DoubleStream {
+
+    private final Stream<Double> boxed;
+
+    DoublePipeline(Stream<Double> boxed) {
+        this.boxed = boxed;
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static DoubleStream ofArray(final double[] values, final int from, final int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return new DoublePipeline(ObjPipeline.over(new PullIterator<Double>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(Double.valueOf(values[at++]));
+                return true;
+            }
+        }));
+    }
+
+    static DoubleStream iterate(double seed, DoublePredicate hasNext, DoubleUnaryOperator next) {
+        Objects.requireNonNull(next);
+        UnaryOperator<Double> step = Fn.<Double, Double>function(Fn.MAP, next);
+        if (hasNext == null) {
+            return new DoublePipeline(Stream.<Double>iterate(Double.valueOf(seed), step));
+        }
+        return new DoublePipeline(Stream.<Double>iterate(Double.valueOf(seed), Fn.<Double>predicate(hasNext), step));
+    }
+
+    @SuppressWarnings("unchecked")
+    static DoubleStream generate(DoubleSupplier s) {
+        Objects.requireNonNull(s);
+        return new DoublePipeline(Stream.<Double>generate((Supplier<Double>) new Fn(Fn.GET, s)));
+    }
+
+    /// Each primitive function this stream is handed, as the object function
+    /// the boxed stream underneath takes. One class for every operation keeps
+    /// an application that uses this stream from carrying a class per method.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final class Fn implements Predicate, UnaryOperator, Consumer, Supplier {
+        static final int TEST = 0;
+        static final int MAP = 1;
+        static final int TO_OBJ = 2;
+        static final int TO_INT = 3;
+        static final int TO_LONG = 4;
+        static final int FLAT = 5;
+        static final int BOX = 6;
+        static final int ACCEPT = 7;
+        static final int GET = 8;
+
+        private final int kind;
+        private final Object fn;
+
+        Fn(int kind, Object fn) {
+            this.kind = kind;
+            this.fn = fn;
+        }
+
+        static <T, R> UnaryOperator function(int kind, Object fn) {
+            return new Fn(kind, fn);
+        }
+
+        static <T> Predicate<T> predicate(DoublePredicate fn) {
+            return new Fn(TEST, fn);
+        }
+
+        static <T> Consumer<T> consumer(DoubleConsumer fn) {
+            return new Fn(ACCEPT, fn);
+        }
+
+        @Override
+        public boolean test(Object o) {
+            return ((DoublePredicate) fn).test(((Double) o).doubleValue());
+        }
+
+        @Override
+        public Object apply(Object o) {
+            if (kind == BOX) {
+                return o;
+            }
+            double v = ((Double) o).doubleValue();
+            switch (kind) {
+                case MAP:
+                    return Double.valueOf(((DoubleUnaryOperator) fn).applyAsDouble(v));
+                case TO_OBJ:
+                    return ((DoubleFunction) fn).apply(v);
+                case TO_INT:
+                    return Integer.valueOf(((DoubleToIntFunction) fn).applyAsInt(v));
+                case TO_LONG:
+                    return Long.valueOf(((DoubleToLongFunction) fn).applyAsLong(v));
+                default: {
+                    DoubleStream inner = (DoubleStream) ((DoubleFunction) fn).apply(v);
+                    return inner == null ? null : inner.boxed();
+                }
+            }
+        }
+
+        @Override
+        public void accept(Object o) {
+            ((DoubleConsumer) fn).accept(((Double) o).doubleValue());
+        }
+
+        @Override
+        public Object get() {
+            return Double.valueOf(((DoubleSupplier) fn).getAsDouble());
+        }
+    }
+
+    @Override
+    public DoubleStream filter(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new DoublePipeline(boxed.filter(Fn.<Double>predicate(predicate)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public DoubleStream map(DoubleUnaryOperator mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>map(Fn.<Double, Double>function(Fn.MAP, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
+        Objects.requireNonNull(mapper);
+        return boxed.<U>map(Fn.<Double, U>function(Fn.TO_OBJ, mapper));
+    }
+
+    @Override
+    public IntStream mapToInt(DoubleToIntFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>map(Fn.<Double, Integer>function(Fn.TO_INT, mapper)));
+    }
+
+    @Override
+    public LongStream mapToLong(DoubleToLongFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>map(Fn.<Double, Long>function(Fn.TO_LONG, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>flatMap(Fn.<Double, Stream<Double>>function(Fn.FLAT, mapper)));
+    }
+
+    @Override
+    public DoubleStream distinct() {
+        return new DoublePipeline(boxed.distinct());
+    }
+
+    @Override
+    public DoubleStream sorted() {
+        return new DoublePipeline(boxed.sorted());
+    }
+
+    @Override
+    public DoubleStream peek(DoubleConsumer action) {
+        Objects.requireNonNull(action);
+        return new DoublePipeline(boxed.peek(Fn.<Double>consumer(action)));
+    }
+
+    @Override
+    public DoubleStream limit(long maxSize) {
+        return new DoublePipeline(boxed.limit(maxSize));
+    }
+
+    @Override
+    public DoubleStream skip(long n) {
+        return new DoublePipeline(boxed.skip(n));
+    }
+
+    @Override
+    public DoubleStream takeWhile(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new DoublePipeline(boxed.takeWhile(Fn.<Double>predicate(predicate)));
+    }
+
+    @Override
+    public DoubleStream dropWhile(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new DoublePipeline(boxed.dropWhile(Fn.<Double>predicate(predicate)));
+    }
+
+    @Override
+    public void forEach(DoubleConsumer action) {
+        Objects.requireNonNull(action);
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next().doubleValue());
+            }
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(DoubleConsumer action) {
+        forEach(action);
+    }
+
+    @Override
+    public double[] toArray() {
+        List<Double> all = new ArrayList<Double>();
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            double[] out = new double[all.size()];
+            for (int i = 0; i < out.length; i++) {
+                out[i] = all.get(i).doubleValue();
+            }
+            return out;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public double reduce(double identity, DoubleBinaryOperator op) {
+        Objects.requireNonNull(op);
+        double result = identity;
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                result = op.applyAsDouble(result, it.next().doubleValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalDouble reduce(DoubleBinaryOperator op) {
+        Objects.requireNonNull(op);
+        Iterator<Double> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalDouble.empty();
+            }
+            double result = it.next().doubleValue();
+            while (it.hasNext()) {
+                result = op.applyAsDouble(result, it.next().doubleValue());
+            }
+            return OptionalDouble.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next().doubleValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public double sum() {
+        return summaryStatistics().getSum();
+    }
+
+    /// The smallest (`max` false) or largest value, as `Math.min` and
+    /// `Math.max` choose, which is what the JDK's reduction uses.
+    private OptionalDouble extreme(boolean max) {
+        Iterator<Double> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalDouble.empty();
+            }
+            double result = it.next().doubleValue();
+            while (it.hasNext()) {
+                double v = it.next().doubleValue();
+                result = max ? Math.max(result, v) : Math.min(result, v);
+            }
+            return OptionalDouble.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalDouble min() {
+        return extreme(false);
+    }
+
+    @Override
+    public OptionalDouble max() {
+        return extreme(true);
+    }
+
+    @Override
+    public long count() {
+        return boxed.count();
+    }
+
+    @Override
+    public OptionalDouble average() {
+        DoubleSummaryStatistics all = summaryStatistics();
+        return all.getCount() == 0 ? OptionalDouble.empty() : OptionalDouble.of(all.getAverage());
+    }
+
+    @Override
+    public DoubleSummaryStatistics summaryStatistics() {
+        DoubleSummaryStatistics all = new DoubleSummaryStatistics();
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.accept(it.next().doubleValue());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.anyMatch(Fn.<Double>predicate(predicate));
+    }
+
+    @Override
+    public boolean allMatch(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.allMatch(Fn.<Double>predicate(predicate));
+    }
+
+    @Override
+    public boolean noneMatch(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.noneMatch(Fn.<Double>predicate(predicate));
+    }
+
+    @Override
+    public OptionalDouble findFirst() {
+        // Through the boxed stream's own, which says that the rest is not
+        // going to be read: a mapped stream left part read is closed.
+        Optional<Double> first = boxed.findFirst();
+        return first.isPresent() ? OptionalDouble.of(first.get().doubleValue()) : OptionalDouble.empty();
+    }
+
+    @Override
+    public OptionalDouble findAny() {
+        return findFirst();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Stream<Double> boxed() {
+        // A stage of its own, so that this stream counts as used like any
+        // other that had an operation applied to it.
+        return boxed.map(Fn.<Double, Double>function(Fn.BOX, null));
+    }
+
+    @Override
+    public PrimitiveIterator.OfDouble iterator() {
+        return new Unboxing(boxed.iterator());
+    }
+
+    /// The elements of the boxed pipeline, one primitive at a time.
+    private static final class Unboxing implements PrimitiveIterator.OfDouble {
+        private final Iterator<Double> it;
+
+        Unboxing(Iterator<Double> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public double nextDouble() {
+            return it.next().doubleValue();
+        }
+    }
+
+    @Override
+    public boolean isParallel() {
+        return boxed.isParallel();
+    }
+
+    @Override
+    public DoubleStream sequential() {
+        boxed.sequential();
+        return this;
+    }
+
+    @Override
+    public DoubleStream parallel() {
+        boxed.parallel();
+        return this;
+    }
+
+    @Override
+    public DoubleStream unordered() {
+        return this;
+    }
+
+    @Override
+    public DoubleStream onClose(Runnable closeHandler) {
+        boxed.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        boxed.close();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/DoubleStream.java b/Ports/CLDC11/src/java/util/stream/DoubleStream.java
new file mode 100644
index 00000000000..907d9f74769
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/DoubleStream.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.DoubleSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleSupplier;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.Supplier;
+
+/// A sequence of `double` values to which operations are applied one stage at a
+/// time, evaluated lazily, one element at a time, when a terminal operation
+/// asks for them.
+///
+/// Streams here are sequential: `parallel()` answers the same stream, which
+/// the JDK allows a parallel stream to be.
+public interface DoubleStream extends BaseStream<Double, DoubleStream> {
+
+    /// Declared again with this type, as the JDK does: a call compiled
+    /// against the JDK names `DoubleStream.sequential()` answering `DoubleStream`,
+    /// and the method inherited from [BaseStream] answers its type
+    /// variable, which is another descriptor.
+    @Override
+    DoubleStream sequential();
+
+    /// Declared again with this type; see [#sequential()].
+    @Override
+    DoubleStream parallel();
+
+    DoubleStream filter(DoublePredicate predicate);
+
+    DoubleStream map(DoubleUnaryOperator mapper);
+
+    <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper);
+
+    IntStream mapToInt(DoubleToIntFunction mapper);
+
+    LongStream mapToLong(DoubleToLongFunction mapper);
+
+    DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper);
+
+    DoubleStream distinct();
+
+    DoubleStream sorted();
+
+    DoubleStream peek(DoubleConsumer action);
+
+    DoubleStream limit(long maxSize);
+
+    DoubleStream skip(long n);
+
+    DoubleStream takeWhile(DoublePredicate predicate);
+
+    DoubleStream dropWhile(DoublePredicate predicate);
+
+    void forEach(DoubleConsumer action);
+
+    void forEachOrdered(DoubleConsumer action);
+
+    double[] toArray();
+
+    double reduce(double identity, DoubleBinaryOperator op);
+
+    OptionalDouble reduce(DoubleBinaryOperator op);
+
+    <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+    double sum();
+
+    OptionalDouble min();
+
+    OptionalDouble max();
+
+    long count();
+
+    OptionalDouble average();
+
+    DoubleSummaryStatistics summaryStatistics();
+
+    boolean anyMatch(DoublePredicate predicate);
+
+    boolean allMatch(DoublePredicate predicate);
+
+    boolean noneMatch(DoublePredicate predicate);
+
+    OptionalDouble findFirst();
+
+    OptionalDouble findAny();
+
+    Stream<Double> boxed();
+
+    @Override
+    PrimitiveIterator.OfDouble iterator();
+
+    static DoubleStream empty() {
+        return DoublePipeline.ofArray(new double[0], 0, 0);
+    }
+
+    static DoubleStream of(double value) {
+        return DoublePipeline.ofArray(new double[] {value}, 0, 1);
+    }
+
+    static DoubleStream of(double... values) {
+        return DoublePipeline.ofArray(values, 0, values.length);
+    }
+
+    /// `seed`, then `f` applied to it, then `f` applied to that, without end.
+    static DoubleStream iterate(double seed, DoubleUnaryOperator f) {
+        return DoublePipeline.iterate(seed, null, f);
+    }
+
+    /// As [#iterate(double, DoubleUnaryOperator)], ending before the first value
+    /// `hasNext` refuses.
+    static DoubleStream iterate(double seed, DoublePredicate hasNext, DoubleUnaryOperator next) {
+        if (hasNext == null) {
+            throw new NullPointerException();
+        }
+        return DoublePipeline.iterate(seed, hasNext, next);
+    }
+
+    /// The values `s` answers, one call per element, without end.
+    static DoubleStream generate(DoubleSupplier s) {
+        return DoublePipeline.generate(s);
+    }
+
+    /// The elements of `a`, then those of `b`. Closing the result closes both.
+    static DoubleStream concat(DoubleStream a, DoubleStream b) {
+        return new DoublePipeline(Stream.concat(a.boxed(), b.boxed()));
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/IntPipeline.java b/Ports/CLDC11/src/java/util/stream/IntPipeline.java
new file mode 100644
index 00000000000..c0dec4cd833
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/IntPipeline.java
@@ -0,0 +1,536 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.IntSummaryStatistics;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// The one implementation of [IntStream]: a view of a stream of boxed values,
+/// which does the work. Boxing costs little on ParparVM, where a boxed
+/// `int` from `valueOf` is usually an immediate rather than an object.
+final class IntPipeline implements IntStream {
+
+    private final Stream<Integer> boxed;
+
+    IntPipeline(Stream<Integer> boxed) {
+        this.boxed = boxed;
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static IntStream ofArray(final int[] values, final int from, final int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return new IntPipeline(ObjPipeline.over(new PullIterator<Integer>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(Integer.valueOf(values[at++]));
+                return true;
+            }
+        }));
+    }
+
+    /// The values from `start` up to `end`, which is part of them when
+    /// `closed`. An empty stream when `start` is past `end`.
+    static IntStream ofRange(final int start, final int end, final boolean closed) {
+        return new IntPipeline(ObjPipeline.over(new PullIterator<Integer>() {
+            private int next = start;
+            /// Whether `next` is still to be handed out. Counting towards
+            /// `end` with a flag, not past it, is what keeps a closed range
+            /// that ends at the largest value from wrapping around.
+            private boolean more = closed ? start <= end : start < end;
+
+            @Override
+            boolean advance() {
+                if (!more) {
+                    return false;
+                }
+                emit(Integer.valueOf(next));
+                if (closed ? next < end : next < end - 1) {
+                    next++;
+                } else {
+                    more = false;
+                }
+                return true;
+            }
+        }));
+    }
+
+    static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator next) {
+        Objects.requireNonNull(next);
+        UnaryOperator<Integer> step = Fn.<Integer, Integer>function(Fn.MAP, next);
+        if (hasNext == null) {
+            return new IntPipeline(Stream.<Integer>iterate(Integer.valueOf(seed), step));
+        }
+        return new IntPipeline(Stream.<Integer>iterate(Integer.valueOf(seed), Fn.<Integer>predicate(hasNext), step));
+    }
+
+    @SuppressWarnings("unchecked")
+    static IntStream generate(IntSupplier s) {
+        Objects.requireNonNull(s);
+        return new IntPipeline(Stream.<Integer>generate((Supplier<Integer>) new Fn(Fn.GET, s)));
+    }
+
+    /// Each primitive function this stream is handed, as the object function
+    /// the boxed stream underneath takes. One class for every operation keeps
+    /// an application that uses this stream from carrying a class per method.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final class Fn implements Predicate, UnaryOperator, Consumer, Supplier {
+        static final int TEST = 0;
+        static final int MAP = 1;
+        static final int TO_OBJ = 2;
+        static final int TO_LONG = 3;
+        static final int TO_DOUBLE = 4;
+        static final int WIDEN_LONG = 5;
+        static final int WIDEN_DOUBLE = 6;
+        static final int FLAT = 7;
+        static final int BOX = 8;
+        static final int ACCEPT = 9;
+        static final int GET = 10;
+
+        private final int kind;
+        private final Object fn;
+
+        Fn(int kind, Object fn) {
+            this.kind = kind;
+            this.fn = fn;
+        }
+
+        static <T, R> UnaryOperator function(int kind, Object fn) {
+            return new Fn(kind, fn);
+        }
+
+        static <T> Predicate<T> predicate(IntPredicate fn) {
+            return new Fn(TEST, fn);
+        }
+
+        static <T> Consumer<T> consumer(IntConsumer fn) {
+            return new Fn(ACCEPT, fn);
+        }
+
+        @Override
+        public boolean test(Object o) {
+            return ((IntPredicate) fn).test(((Integer) o).intValue());
+        }
+
+        @Override
+        public Object apply(Object o) {
+            if (kind == BOX) {
+                return o;
+            }
+            int v = ((Integer) o).intValue();
+            switch (kind) {
+                case MAP:
+                    return Integer.valueOf(((IntUnaryOperator) fn).applyAsInt(v));
+                case TO_OBJ:
+                    return ((IntFunction) fn).apply(v);
+                case TO_LONG:
+                    return Long.valueOf(((IntToLongFunction) fn).applyAsLong(v));
+                case TO_DOUBLE:
+                    return Double.valueOf(((IntToDoubleFunction) fn).applyAsDouble(v));
+                case WIDEN_LONG:
+                    return Long.valueOf(v);
+                case WIDEN_DOUBLE:
+                    return Double.valueOf(v);
+                default: {
+                    IntStream inner = (IntStream) ((IntFunction) fn).apply(v);
+                    return inner == null ? null : inner.boxed();
+                }
+            }
+        }
+
+        @Override
+        public void accept(Object o) {
+            ((IntConsumer) fn).accept(((Integer) o).intValue());
+        }
+
+        @Override
+        public Object get() {
+            return Integer.valueOf(((IntSupplier) fn).getAsInt());
+        }
+    }
+
+    @Override
+    public IntStream filter(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new IntPipeline(boxed.filter(Fn.<Integer>predicate(predicate)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public IntStream map(IntUnaryOperator mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>map(Fn.<Integer, Integer>function(Fn.MAP, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
+        Objects.requireNonNull(mapper);
+        return boxed.<U>map(Fn.<Integer, U>function(Fn.TO_OBJ, mapper));
+    }
+
+    @Override
+    public LongStream mapToLong(IntToLongFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>map(Fn.<Integer, Long>function(Fn.TO_LONG, mapper)));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>map(Fn.<Integer, Double>function(Fn.TO_DOUBLE, mapper)));
+    }
+
+    @Override
+    public LongStream asLongStream() {
+        return new LongPipeline(boxed.<Long>map(Fn.<Integer, Long>function(Fn.WIDEN_LONG, null)));
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+        return new DoublePipeline(boxed.<Double>map(Fn.<Integer, Double>function(Fn.WIDEN_DOUBLE, null)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>flatMap(Fn.<Integer, Stream<Integer>>function(Fn.FLAT, mapper)));
+    }
+
+    @Override
+    public IntStream distinct() {
+        return new IntPipeline(boxed.distinct());
+    }
+
+    @Override
+    public IntStream sorted() {
+        return new IntPipeline(boxed.sorted());
+    }
+
+    @Override
+    public IntStream peek(IntConsumer action) {
+        Objects.requireNonNull(action);
+        return new IntPipeline(boxed.peek(Fn.<Integer>consumer(action)));
+    }
+
+    @Override
+    public IntStream limit(long maxSize) {
+        return new IntPipeline(boxed.limit(maxSize));
+    }
+
+    @Override
+    public IntStream skip(long n) {
+        return new IntPipeline(boxed.skip(n));
+    }
+
+    @Override
+    public IntStream takeWhile(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new IntPipeline(boxed.takeWhile(Fn.<Integer>predicate(predicate)));
+    }
+
+    @Override
+    public IntStream dropWhile(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new IntPipeline(boxed.dropWhile(Fn.<Integer>predicate(predicate)));
+    }
+
+    @Override
+    public void forEach(IntConsumer action) {
+        Objects.requireNonNull(action);
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next().intValue());
+            }
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(IntConsumer action) {
+        forEach(action);
+    }
+
+    @Override
+    public int[] toArray() {
+        List<Integer> all = new ArrayList<Integer>();
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            int[] out = new int[all.size()];
+            for (int i = 0; i < out.length; i++) {
+                out[i] = all.get(i).intValue();
+            }
+            return out;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public int reduce(int identity, IntBinaryOperator op) {
+        Objects.requireNonNull(op);
+        int result = identity;
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                result = op.applyAsInt(result, it.next().intValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalInt reduce(IntBinaryOperator op) {
+        Objects.requireNonNull(op);
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalInt.empty();
+            }
+            int result = it.next().intValue();
+            while (it.hasNext()) {
+                result = op.applyAsInt(result, it.next().intValue());
+            }
+            return OptionalInt.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next().intValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public int sum() {
+        int total = 0;
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                total += it.next().intValue();
+            }
+            return total;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    /// The smallest (`max` false) or largest value, as `Math.min` and
+    /// `Math.max` choose, which is what the JDK's reduction uses.
+    private OptionalInt extreme(boolean max) {
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalInt.empty();
+            }
+            int result = it.next().intValue();
+            while (it.hasNext()) {
+                int v = it.next().intValue();
+                result = max ? Math.max(result, v) : Math.min(result, v);
+            }
+            return OptionalInt.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalInt min() {
+        return extreme(false);
+    }
+
+    @Override
+    public OptionalInt max() {
+        return extreme(true);
+    }
+
+    @Override
+    public long count() {
+        return boxed.count();
+    }
+
+    @Override
+    public OptionalDouble average() {
+        IntSummaryStatistics all = summaryStatistics();
+        return all.getCount() == 0 ? OptionalDouble.empty() : OptionalDouble.of(all.getAverage());
+    }
+
+    @Override
+    public IntSummaryStatistics summaryStatistics() {
+        IntSummaryStatistics all = new IntSummaryStatistics();
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.accept(it.next().intValue());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.anyMatch(Fn.<Integer>predicate(predicate));
+    }
+
+    @Override
+    public boolean allMatch(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.allMatch(Fn.<Integer>predicate(predicate));
+    }
+
+    @Override
+    public boolean noneMatch(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.noneMatch(Fn.<Integer>predicate(predicate));
+    }
+
+    @Override
+    public OptionalInt findFirst() {
+        // Through the boxed stream's own, which says that the rest is not
+        // going to be read: a mapped stream left part read is closed.
+        Optional<Integer> first = boxed.findFirst();
+        return first.isPresent() ? OptionalInt.of(first.get().intValue()) : OptionalInt.empty();
+    }
+
+    @Override
+    public OptionalInt findAny() {
+        return findFirst();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Stream<Integer> boxed() {
+        // A stage of its own, so that this stream counts as used like any
+        // other that had an operation applied to it.
+        return boxed.map(Fn.<Integer, Integer>function(Fn.BOX, null));
+    }
+
+    @Override
+    public PrimitiveIterator.OfInt iterator() {
+        return new Unboxing(boxed.iterator());
+    }
+
+    /// The elements of the boxed pipeline, one primitive at a time.
+    private static final class Unboxing implements PrimitiveIterator.OfInt {
+        private final Iterator<Integer> it;
+
+        Unboxing(Iterator<Integer> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public int nextInt() {
+            return it.next().intValue();
+        }
+    }
+
+    @Override
+    public boolean isParallel() {
+        return boxed.isParallel();
+    }
+
+    @Override
+    public IntStream sequential() {
+        boxed.sequential();
+        return this;
+    }
+
+    @Override
+    public IntStream parallel() {
+        boxed.parallel();
+        return this;
+    }
+
+    @Override
+    public IntStream unordered() {
+        return this;
+    }
+
+    @Override
+    public IntStream onClose(Runnable closeHandler) {
+        boxed.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        boxed.close();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/IntStream.java b/Ports/CLDC11/src/java/util/stream/IntStream.java
new file mode 100644
index 00000000000..c5edbe6ad4f
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/IntStream.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.IntSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Supplier;
+
+/// A sequence of `int` values to which operations are applied one stage at a
+/// time, evaluated lazily, one element at a time, when a terminal operation
+/// asks for them.
+///
+/// Streams here are sequential: `parallel()` answers the same stream, which
+/// the JDK allows a parallel stream to be.
+public interface IntStream extends BaseStream<Integer, IntStream> {
+
+    /// Declared again with this type, as the JDK does: a call compiled
+    /// against the JDK names `IntStream.sequential()` answering `IntStream`,
+    /// and the method inherited from [BaseStream] answers its type
+    /// variable, which is another descriptor.
+    @Override
+    IntStream sequential();
+
+    /// Declared again with this type; see [#sequential()].
+    @Override
+    IntStream parallel();
+
+    IntStream filter(IntPredicate predicate);
+
+    IntStream map(IntUnaryOperator mapper);
+
+    <U> Stream<U> mapToObj(IntFunction<? extends U> mapper);
+
+    LongStream mapToLong(IntToLongFunction mapper);
+
+    DoubleStream mapToDouble(IntToDoubleFunction mapper);
+
+    IntStream flatMap(IntFunction<? extends IntStream> mapper);
+
+    IntStream distinct();
+
+    IntStream sorted();
+
+    IntStream peek(IntConsumer action);
+
+    IntStream limit(long maxSize);
+
+    IntStream skip(long n);
+
+    IntStream takeWhile(IntPredicate predicate);
+
+    IntStream dropWhile(IntPredicate predicate);
+
+    void forEach(IntConsumer action);
+
+    void forEachOrdered(IntConsumer action);
+
+    int[] toArray();
+
+    int reduce(int identity, IntBinaryOperator op);
+
+    OptionalInt reduce(IntBinaryOperator op);
+
+    <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+    int sum();
+
+    OptionalInt min();
+
+    OptionalInt max();
+
+    long count();
+
+    OptionalDouble average();
+
+    IntSummaryStatistics summaryStatistics();
+
+    boolean anyMatch(IntPredicate predicate);
+
+    boolean allMatch(IntPredicate predicate);
+
+    boolean noneMatch(IntPredicate predicate);
+
+    OptionalInt findFirst();
+
+    OptionalInt findAny();
+
+    LongStream asLongStream();
+
+    DoubleStream asDoubleStream();
+
+    Stream<Integer> boxed();
+
+    @Override
+    PrimitiveIterator.OfInt iterator();
+
+    static IntStream empty() {
+        return IntPipeline.ofArray(new int[0], 0, 0);
+    }
+
+    static IntStream of(int value) {
+        return IntPipeline.ofArray(new int[] {value}, 0, 1);
+    }
+
+    static IntStream of(int... values) {
+        return IntPipeline.ofArray(values, 0, values.length);
+    }
+
+    /// `seed`, then `f` applied to it, then `f` applied to that, without end.
+    static IntStream iterate(int seed, IntUnaryOperator f) {
+        return IntPipeline.iterate(seed, null, f);
+    }
+
+    /// As [#iterate(int, IntUnaryOperator)], ending before the first value
+    /// `hasNext` refuses.
+    static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator next) {
+        if (hasNext == null) {
+            throw new NullPointerException();
+        }
+        return IntPipeline.iterate(seed, hasNext, next);
+    }
+
+    /// The values `s` answers, one call per element, without end.
+    static IntStream generate(IntSupplier s) {
+        return IntPipeline.generate(s);
+    }
+
+    /// The values from `startInclusive` up to, not including, `endExclusive`,
+    /// in steps of one. Empty when `startInclusive` is not below `endExclusive`.
+    static IntStream range(int startInclusive, int endExclusive) {
+        return IntPipeline.ofRange(startInclusive, endExclusive, false);
+    }
+
+    /// The values from `startInclusive` up to and including `endInclusive`, in
+    /// steps of one. Empty when `startInclusive` is above `endInclusive`.
+    static IntStream rangeClosed(int startInclusive, int endInclusive) {
+        return IntPipeline.ofRange(startInclusive, endInclusive, true);
+    }
+
+    /// The elements of `a`, then those of `b`. Closing the result closes both.
+    static IntStream concat(IntStream a, IntStream b) {
+        return new IntPipeline(Stream.concat(a.boxed(), b.boxed()));
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/LongPipeline.java b/Ports/CLDC11/src/java/util/stream/LongPipeline.java
new file mode 100644
index 00000000000..b58c5921d4d
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/LongPipeline.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongSupplier;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjLongConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// The one implementation of [LongStream]: a view of a stream of boxed values,
+/// which does the work. Boxing costs little on ParparVM, where a boxed
+/// `long` from `valueOf` is usually an immediate rather than an object.
+final class LongPipeline implements LongStream {
+
+    private final Stream<Long> boxed;
+
+    LongPipeline(Stream<Long> boxed) {
+        this.boxed = boxed;
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static LongStream ofArray(final long[] values, final int from, final int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return new LongPipeline(ObjPipeline.over(new PullIterator<Long>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(Long.valueOf(values[at++]));
+                return true;
+            }
+        }));
+    }
+
+    /// The values from `start` up to `end`, which is part of them when
+    /// `closed`. An empty stream when `start` is past `end`.
+    static LongStream ofRange(final long start, final long end, final boolean closed) {
+        return new LongPipeline(ObjPipeline.over(new PullIterator<Long>() {
+            private long next = start;
+            /// Whether `next` is still to be handed out. Counting towards
+            /// `end` with a flag, not past it, is what keeps a closed range
+            /// that ends at the largest value from wrapping around.
+            private boolean more = closed ? start <= end : start < end;
+
+            @Override
+            boolean advance() {
+                if (!more) {
+                    return false;
+                }
+                emit(Long.valueOf(next));
+                if (closed ? next < end : next < end - 1) {
+                    next++;
+                } else {
+                    more = false;
+                }
+                return true;
+            }
+        }));
+    }
+
+    static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator next) {
+        Objects.requireNonNull(next);
+        UnaryOperator<Long> step = Fn.<Long, Long>function(Fn.MAP, next);
+        if (hasNext == null) {
+            return new LongPipeline(Stream.<Long>iterate(Long.valueOf(seed), step));
+        }
+        return new LongPipeline(Stream.<Long>iterate(Long.valueOf(seed), Fn.<Long>predicate(hasNext), step));
+    }
+
+    @SuppressWarnings("unchecked")
+    static LongStream generate(LongSupplier s) {
+        Objects.requireNonNull(s);
+        return new LongPipeline(Stream.<Long>generate((Supplier<Long>) new Fn(Fn.GET, s)));
+    }
+
+    /// Each primitive function this stream is handed, as the object function
+    /// the boxed stream underneath takes. One class for every operation keeps
+    /// an application that uses this stream from carrying a class per method.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final class Fn implements Predicate, UnaryOperator, Consumer, Supplier {
+        static final int TEST = 0;
+        static final int MAP = 1;
+        static final int TO_OBJ = 2;
+        static final int TO_INT = 3;
+        static final int TO_DOUBLE = 4;
+        static final int WIDEN_DOUBLE = 5;
+        static final int FLAT = 6;
+        static final int BOX = 7;
+        static final int ACCEPT = 8;
+        static final int GET = 9;
+
+        private final int kind;
+        private final Object fn;
+
+        Fn(int kind, Object fn) {
+            this.kind = kind;
+            this.fn = fn;
+        }
+
+        static <T, R> UnaryOperator function(int kind, Object fn) {
+            return new Fn(kind, fn);
+        }
+
+        static <T> Predicate<T> predicate(LongPredicate fn) {
+            return new Fn(TEST, fn);
+        }
+
+        static <T> Consumer<T> consumer(LongConsumer fn) {
+            return new Fn(ACCEPT, fn);
+        }
+
+        @Override
+        public boolean test(Object o) {
+            return ((LongPredicate) fn).test(((Long) o).longValue());
+        }
+
+        @Override
+        public Object apply(Object o) {
+            if (kind == BOX) {
+                return o;
+            }
+            long v = ((Long) o).longValue();
+            switch (kind) {
+                case MAP:
+                    return Long.valueOf(((LongUnaryOperator) fn).applyAsLong(v));
+                case TO_OBJ:
+                    return ((LongFunction) fn).apply(v);
+                case TO_INT:
+                    return Integer.valueOf(((LongToIntFunction) fn).applyAsInt(v));
+                case TO_DOUBLE:
+                    return Double.valueOf(((LongToDoubleFunction) fn).applyAsDouble(v));
+                case WIDEN_DOUBLE:
+                    return Double.valueOf(v);
+                default: {
+                    LongStream inner = (LongStream) ((LongFunction) fn).apply(v);
+                    return inner == null ? null : inner.boxed();
+                }
+            }
+        }
+
+        @Override
+        public void accept(Object o) {
+            ((LongConsumer) fn).accept(((Long) o).longValue());
+        }
+
+        @Override
+        public Object get() {
+            return Long.valueOf(((LongSupplier) fn).getAsLong());
+        }
+    }
+
+    @Override
+    public LongStream filter(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new LongPipeline(boxed.filter(Fn.<Long>predicate(predicate)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public LongStream map(LongUnaryOperator mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>map(Fn.<Long, Long>function(Fn.MAP, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
+        Objects.requireNonNull(mapper);
+        return boxed.<U>map(Fn.<Long, U>function(Fn.TO_OBJ, mapper));
+    }
+
+    @Override
+    public IntStream mapToInt(LongToIntFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>map(Fn.<Long, Integer>function(Fn.TO_INT, mapper)));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>map(Fn.<Long, Double>function(Fn.TO_DOUBLE, mapper)));
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+        return new DoublePipeline(boxed.<Double>map(Fn.<Long, Double>function(Fn.WIDEN_DOUBLE, null)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>flatMap(Fn.<Long, Stream<Long>>function(Fn.FLAT, mapper)));
+    }
+
+    @Override
+    public LongStream distinct() {
+        return new LongPipeline(boxed.distinct());
+    }
+
+    @Override
+    public LongStream sorted() {
+        return new LongPipeline(boxed.sorted());
+    }
+
+    @Override
+    public LongStream peek(LongConsumer action) {
+        Objects.requireNonNull(action);
+        return new LongPipeline(boxed.peek(Fn.<Long>consumer(action)));
+    }
+
+    @Override
+    public LongStream limit(long maxSize) {
+        return new LongPipeline(boxed.limit(maxSize));
+    }
+
+    @Override
+    public LongStream skip(long n) {
+        return new LongPipeline(boxed.skip(n));
+    }
+
+    @Override
+    public LongStream takeWhile(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new LongPipeline(boxed.takeWhile(Fn.<Long>predicate(predicate)));
+    }
+
+    @Override
+    public LongStream dropWhile(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new LongPipeline(boxed.dropWhile(Fn.<Long>predicate(predicate)));
+    }
+
+    @Override
+    public void forEach(LongConsumer action) {
+        Objects.requireNonNull(action);
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next().longValue());
+            }
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(LongConsumer action) {
+        forEach(action);
+    }
+
+    @Override
+    public long[] toArray() {
+        List<Long> all = new ArrayList<Long>();
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            long[] out = new long[all.size()];
+            for (int i = 0; i < out.length; i++) {
+                out[i] = all.get(i).longValue();
+            }
+            return out;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public long reduce(long identity, LongBinaryOperator op) {
+        Objects.requireNonNull(op);
+        long result = identity;
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                result = op.applyAsLong(result, it.next().longValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalLong reduce(LongBinaryOperator op) {
+        Objects.requireNonNull(op);
+        Iterator<Long> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalLong.empty();
+            }
+            long result = it.next().longValue();
+            while (it.hasNext()) {
+                result = op.applyAsLong(result, it.next().longValue());
+            }
+            return OptionalLong.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next().longValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public long sum() {
+        long total = 0;
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                total += it.next().longValue();
+            }
+            return total;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    /// The smallest (`max` false) or largest value, as `Math.min` and
+    /// `Math.max` choose, which is what the JDK's reduction uses.
+    private OptionalLong extreme(boolean max) {
+        Iterator<Long> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalLong.empty();
+            }
+            long result = it.next().longValue();
+            while (it.hasNext()) {
+                long v = it.next().longValue();
+                result = max ? Math.max(result, v) : Math.min(result, v);
+            }
+            return OptionalLong.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalLong min() {
+        return extreme(false);
+    }
+
+    @Override
+    public OptionalLong max() {
+        return extreme(true);
+    }
+
+    @Override
+    public long count() {
+        return boxed.count();
+    }
+
+    @Override
+    public OptionalDouble average() {
+        LongSummaryStatistics all = summaryStatistics();
+        return all.getCount() == 0 ? OptionalDouble.empty() : OptionalDouble.of(all.getAverage());
+    }
+
+    @Override
+    public LongSummaryStatistics summaryStatistics() {
+        LongSummaryStatistics all = new LongSummaryStatistics();
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.accept(it.next().longValue());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.anyMatch(Fn.<Long>predicate(predicate));
+    }
+
+    @Override
+    public boolean allMatch(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.allMatch(Fn.<Long>predicate(predicate));
+    }
+
+    @Override
+    public boolean noneMatch(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.noneMatch(Fn.<Long>predicate(predicate));
+    }
+
+    @Override
+    public OptionalLong findFirst() {
+        // Through the boxed stream's own, which says that the rest is not
+        // going to be read: a mapped stream left part read is closed.
+        Optional<Long> first = boxed.findFirst();
+        return first.isPresent() ? OptionalLong.of(first.get().longValue()) : OptionalLong.empty();
+    }
+
+    @Override
+    public OptionalLong findAny() {
+        return findFirst();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Stream<Long> boxed() {
+        // A stage of its own, so that this stream counts as used like any
+        // other that had an operation applied to it.
+        return boxed.map(Fn.<Long, Long>function(Fn.BOX, null));
+    }
+
+    @Override
+    public PrimitiveIterator.OfLong iterator() {
+        return new Unboxing(boxed.iterator());
+    }
+
+    /// The elements of the boxed pipeline, one primitive at a time.
+    private static final class Unboxing implements PrimitiveIterator.OfLong {
+        private final Iterator<Long> it;
+
+        Unboxing(Iterator<Long> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public long nextLong() {
+            return it.next().longValue();
+        }
+    }
+
+    @Override
+    public boolean isParallel() {
+        return boxed.isParallel();
+    }
+
+    @Override
+    public LongStream sequential() {
+        boxed.sequential();
+        return this;
+    }
+
+    @Override
+    public LongStream parallel() {
+        boxed.parallel();
+        return this;
+    }
+
+    @Override
+    public LongStream unordered() {
+        return this;
+    }
+
+    @Override
+    public LongStream onClose(Runnable closeHandler) {
+        boxed.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        boxed.close();
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/LongStream.java b/Ports/CLDC11/src/java/util/stream/LongStream.java
new file mode 100644
index 00000000000..6cef52daf12
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/LongStream.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.LongSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongSupplier;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjLongConsumer;
+import java.util.function.Supplier;
+
+/// A sequence of `long` values to which operations are applied one stage at a
+/// time, evaluated lazily, one element at a time, when a terminal operation
+/// asks for them.
+///
+/// Streams here are sequential: `parallel()` answers the same stream, which
+/// the JDK allows a parallel stream to be.
+public interface LongStream extends BaseStream<Long, LongStream> {
+
+    /// Declared again with this type, as the JDK does: a call compiled
+    /// against the JDK names `LongStream.sequential()` answering `LongStream`,
+    /// and the method inherited from [BaseStream] answers its type
+    /// variable, which is another descriptor.
+    @Override
+    LongStream sequential();
+
+    /// Declared again with this type; see [#sequential()].
+    @Override
+    LongStream parallel();
+
+    LongStream filter(LongPredicate predicate);
+
+    LongStream map(LongUnaryOperator mapper);
+
+    <U> Stream<U> mapToObj(LongFunction<? extends U> mapper);
+
+    IntStream mapToInt(LongToIntFunction mapper);
+
+    DoubleStream mapToDouble(LongToDoubleFunction mapper);
+
+    LongStream flatMap(LongFunction<? extends LongStream> mapper);
+
+    LongStream distinct();
+
+    LongStream sorted();
+
+    LongStream peek(LongConsumer action);
+
+    LongStream limit(long maxSize);
+
+    LongStream skip(long n);
+
+    LongStream takeWhile(LongPredicate predicate);
+
+    LongStream dropWhile(LongPredicate predicate);
+
+    void forEach(LongConsumer action);
+
+    void forEachOrdered(LongConsumer action);
+
+    long[] toArray();
+
+    long reduce(long identity, LongBinaryOperator op);
+
+    OptionalLong reduce(LongBinaryOperator op);
+
+    <R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+    long sum();
+
+    OptionalLong min();
+
+    OptionalLong max();
+
+    long count();
+
+    OptionalDouble average();
+
+    LongSummaryStatistics summaryStatistics();
+
+    boolean anyMatch(LongPredicate predicate);
+
+    boolean allMatch(LongPredicate predicate);
+
+    boolean noneMatch(LongPredicate predicate);
+
+    OptionalLong findFirst();
+
+    OptionalLong findAny();
+
+    DoubleStream asDoubleStream();
+
+    Stream<Long> boxed();
+
+    @Override
+    PrimitiveIterator.OfLong iterator();
+
+    static LongStream empty() {
+        return LongPipeline.ofArray(new long[0], 0, 0);
+    }
+
+    static LongStream of(long value) {
+        return LongPipeline.ofArray(new long[] {value}, 0, 1);
+    }
+
+    static LongStream of(long... values) {
+        return LongPipeline.ofArray(values, 0, values.length);
+    }
+
+    /// `seed`, then `f` applied to it, then `f` applied to that, without end.
+    static LongStream iterate(long seed, LongUnaryOperator f) {
+        return LongPipeline.iterate(seed, null, f);
+    }
+
+    /// As [#iterate(long, LongUnaryOperator)], ending before the first value
+    /// `hasNext` refuses.
+    static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator next) {
+        if (hasNext == null) {
+            throw new NullPointerException();
+        }
+        return LongPipeline.iterate(seed, hasNext, next);
+    }
+
+    /// The values `s` answers, one call per element, without end.
+    static LongStream generate(LongSupplier s) {
+        return LongPipeline.generate(s);
+    }
+
+    /// The values from `startInclusive` up to, not including, `endExclusive`,
+    /// in steps of one. Empty when `startInclusive` is not below `endExclusive`.
+    static LongStream range(long startInclusive, long endExclusive) {
+        return LongPipeline.ofRange(startInclusive, endExclusive, false);
+    }
+
+    /// The values from `startInclusive` up to and including `endInclusive`, in
+    /// steps of one. Empty when `startInclusive` is above `endInclusive`.
+    static LongStream rangeClosed(long startInclusive, long endInclusive) {
+        return LongPipeline.ofRange(startInclusive, endInclusive, true);
+    }
+
+    /// The elements of `a`, then those of `b`. Closing the result closes both.
+    static LongStream concat(LongStream a, LongStream b) {
+        return new LongPipeline(Stream.concat(a.boxed(), b.boxed()));
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/ObjPipeline.java b/Ports/CLDC11/src/java/util/stream/ObjPipeline.java
new file mode 100644
index 00000000000..0ccf2d1b428
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/ObjPipeline.java
@@ -0,0 +1,821 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.function.IntFunction;
+import java.util.Optional;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/// The one implementation of [Stream]: a stage holding the iterator that
+/// produces its elements. An intermediate operation wraps that iterator in
+/// another and answers a new stage; a terminal one drains it.
+///
+/// Nothing runs until a terminal operation pulls, and then one element at a
+/// time travels the whole chain before the next is asked for.
+final class ObjPipeline<T> implements Stream<T> {
+
+    private static final String USED = "stream has already been operated upon or closed";
+
+    private final Iterator<T> source;
+    private final StreamState state;
+    /// A stage takes one operation, like the JDK's.
+    private boolean used;
+
+    private ObjPipeline(Iterator<T> source, StreamState state) {
+        this.source = source;
+        this.state = state;
+    }
+
+    static <T> ObjPipeline<T> over(Iterator<T> source) {
+        return new ObjPipeline<T>(source, new StreamState());
+    }
+
+    /// A stream of what `source` holds when the terminal operation starts,
+    /// not when the stream was made: elements added in between are seen.
+    static <T> ObjPipeline<T> over(Iterable<? extends T> source) {
+        return over(new PullIterator<T>() {
+            private Iterator<? extends T> it;
+
+            @Override
+            boolean advance() {
+                if (it == null) {
+                    it = source.iterator();
+                }
+                if (!it.hasNext()) {
+                    return false;
+                }
+                emit(it.next());
+                return true;
+            }
+        });
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static <T> ObjPipeline<T> ofArray(T[] values, int from, int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return over(new PullIterator<T>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(values[at++]);
+                return true;
+            }
+        });
+    }
+
+    static <T> ObjPipeline<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
+        Iterator<? extends T> first = a.iterator();
+        Iterator<? extends T> second = b.iterator();
+        ObjPipeline<T> out = over(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                if (first.hasNext()) {
+                    emit(first.next());
+                    return true;
+                }
+                if (second.hasNext()) {
+                    emit(second.next());
+                    return true;
+                }
+                return false;
+            }
+        });
+        // Parallel when either input is, as the JDK's concatenation reports.
+        out.state.parallel = a.isParallel() || b.isParallel();
+        // Closing the concatenation closes both inputs, the second even
+        // when the first one's handler throws.
+        out.state.onClose(new Runnable() {
+            @Override
+            public void run() {
+                a.close();
+            }
+        });
+        out.state.onClose(new Runnable() {
+            @Override
+            public void run() {
+                b.close();
+            }
+        });
+        return out;
+    }
+
+    /// The iterator of this stage, which the caller now owns.
+    /// Rethrows `failure` from a terminal operation of a primitive stream
+    /// over `stream`, first closing what its pipeline still holds open -- the
+    /// inner stream of a `flatMap` -- as this class's own terminals do.
+    static RuntimeException fail(Stream<?> stream, Throwable failure) {
+        if (stream instanceof ObjPipeline) {
+            return ((ObjPipeline<?>) stream).state.fail(failure);
+        }
+        return StreamState.unchecked(failure);
+    }
+
+    private Iterator<T> take() {
+        // Closing any stage closes the pipeline, so a stage made before an
+        // earlier one was closed is refused as well as the closed one.
+        if (used || state.isClosed()) {
+            throw new IllegalStateException(USED);
+        }
+        used = true;
+        return source;
+    }
+
+    private <R> ObjPipeline<R> stage(Iterator<R> next) {
+        return new ObjPipeline<R>(next, state);
+    }
+
+    @Override
+    public Stream<T> filter(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                while (up.hasNext()) {
+                    T value = up.next();
+                    if (predicate.test(value)) {
+                        emit(value);
+                        return true;
+                    }
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
+        Objects.requireNonNull(mapper);
+        Iterator<T> up = take();
+        return stage(new PullIterator<R>() {
+            @Override
+            boolean advance() {
+                if (!up.hasNext()) {
+                    return false;
+                }
+                emit(mapper.apply(up.next()));
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        final ToIntFunction<? super T> f = mapper;
+        return new IntPipeline(this.<Integer>map(new Function<T, Integer>() {
+            @Override
+            public Integer apply(T v) {
+                return Integer.valueOf(f.applyAsInt(v));
+            }
+        }));
+    }
+
+    @Override
+    public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        final ToLongFunction<? super T> f = mapper;
+        return new LongPipeline(this.<Long>map(new Function<T, Long>() {
+            @Override
+            public Long apply(T v) {
+                return Long.valueOf(f.applyAsLong(v));
+            }
+        }));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        final ToDoubleFunction<? super T> f = mapper;
+        return new DoublePipeline(this.<Double>map(new Function<T, Double>() {
+            @Override
+            public Double apply(T v) {
+                return Double.valueOf(f.applyAsDouble(v));
+            }
+        }));
+    }
+
+    @Override
+    public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
+        Objects.requireNonNull(mapper);
+        FlatMapped<T, R> flat = new FlatMapped<T, R>(take(), mapper);
+        // The mapped stream being read when the pipeline stops asking is
+        // closed too, as the JDK closes it: see StreamState#onAbandon.
+        state.onAbandon(flat);
+        return stage(flat);
+    }
+
+    /// The elements of each stream a mapper answers, one mapped stream at a
+    /// time. A mapped stream is read lazily, so the one in hand can be left
+    /// part read: by a `limit` or a `takeWhile` after this stage, or by a
+    /// terminal operation that has its answer. Running this closes it.
+    private static final class FlatMapped<T, R> extends PullIterator<R> implements Runnable {
+        private final Iterator<T> up;
+        private final Function<? super T, ? extends Stream<? extends R>> mapper;
+        private Stream<? extends R> inner;
+        private Iterator<? extends R> it;
+
+        FlatMapped(Iterator<T> up, Function<? super T, ? extends Stream<? extends R>> mapper) {
+            this.up = up;
+            this.mapper = mapper;
+        }
+
+        @Override
+        boolean advance() {
+            while (true) {
+                if (it != null) {
+                    if (it.hasNext()) {
+                        emit(it.next());
+                        return true;
+                    }
+                    // A mapped stream is closed once its elements have
+                    // been taken.
+                    run();
+                }
+                if (!up.hasNext()) {
+                    return false;
+                }
+                Stream<? extends R> mapped = mapper.apply(up.next());
+                if (mapped != null) {
+                    inner = mapped;
+                    it = mapped.iterator();
+                }
+            }
+        }
+
+        @Override
+        public void run() {
+            Stream<? extends R> open = inner;
+            inner = null;
+            it = null;
+            if (open != null) {
+                open.close();
+            }
+        }
+    }
+
+    @Override
+    public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+        Objects.requireNonNull(mapper);
+        final Function<? super T, ? extends IntStream> f = mapper;
+        return new IntPipeline(this.<Integer>flatMap(new Function<T, Stream<Integer>>() {
+            @Override
+            public Stream<Integer> apply(T v) {
+                IntStream mapped = f.apply(v);
+                return mapped == null ? null : mapped.boxed();
+            }
+        }));
+    }
+
+    @Override
+    public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+        Objects.requireNonNull(mapper);
+        final Function<? super T, ? extends LongStream> f = mapper;
+        return new LongPipeline(this.<Long>flatMap(new Function<T, Stream<Long>>() {
+            @Override
+            public Stream<Long> apply(T v) {
+                LongStream mapped = f.apply(v);
+                return mapped == null ? null : mapped.boxed();
+            }
+        }));
+    }
+
+    @Override
+    public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+        Objects.requireNonNull(mapper);
+        final Function<? super T, ? extends DoubleStream> f = mapper;
+        return new DoublePipeline(this.<Double>flatMap(new Function<T, Stream<Double>>() {
+            @Override
+            public Stream<Double> apply(T v) {
+                DoubleStream mapped = f.apply(v);
+                return mapped == null ? null : mapped.boxed();
+            }
+        }));
+    }
+
+    @Override
+    public Stream<T> distinct() {
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private final Set<T> seen = new HashSet<T>();
+
+            @Override
+            boolean advance() {
+                while (up.hasNext()) {
+                    T value = up.next();
+                    if (seen.add(value)) {
+                        emit(value);
+                        return true;
+                    }
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> sorted() {
+        // The natural order of whatever the elements are; an element that is not
+        // Comparable fails in the comparison, as on the JDK.
+        @SuppressWarnings({"unchecked", "rawtypes"})
+        Comparator<? super T> natural = (Comparator) Comparator.naturalOrder();
+        return sorted(natural);
+    }
+
+    @Override
+    public Stream<T> sorted(Comparator<? super T> comparator) {
+        // The JDK refuses a null comparator here; only sorted() means the
+        // natural order, and it passes that order itself.
+        if (comparator == null) {
+            throw new NullPointerException();
+        }
+        final Comparator<? super T> order = comparator;
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private Iterator<T> it;
+
+            @Override
+            boolean advance() {
+                if (it == null) {
+                    // Sorting needs every element, so the first pull takes
+                    // the whole of what is upstream.
+                    List<T> all = new ArrayList<T>();
+                    while (up.hasNext()) {
+                        all.add(up.next());
+                    }
+                    Collections.sort(all, order);
+                    it = all.iterator();
+                }
+                if (!it.hasNext()) {
+                    return false;
+                }
+                emit(it.next());
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> peek(Consumer<? super T> action) {
+        Objects.requireNonNull(action);
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                if (!up.hasNext()) {
+                    return false;
+                }
+                T value = up.next();
+                action.accept(value);
+                emit(value);
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> limit(long maxSize) {
+        if (maxSize < 0) {
+            throw new IllegalArgumentException(Long.toString(maxSize));
+        }
+        Iterator<T> up = take();
+        int before = state.abandonable();
+        return stage(new PullIterator<T>() {
+            private long left = maxSize;
+
+            @Override
+            boolean advance() {
+                // Checked before asking upstream: the element after the
+                // last one wanted is never produced.
+                if (left <= 0) {
+                    // Nothing before this stage is asked again.
+                    state.abandon(before);
+                    return false;
+                }
+                if (!up.hasNext()) {
+                    return false;
+                }
+                left--;
+                emit(up.next());
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> skip(long n) {
+        if (n < 0) {
+            throw new IllegalArgumentException(Long.toString(n));
+        }
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private long left = n;
+
+            @Override
+            boolean advance() {
+                while (left > 0) {
+                    if (!up.hasNext()) {
+                        return false;
+                    }
+                    up.next();
+                    left--;
+                }
+                if (!up.hasNext()) {
+                    return false;
+                }
+                emit(up.next());
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> takeWhile(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> up = take();
+        int before = state.abandonable();
+        return stage(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                if (!up.hasNext()) {
+                    return false;
+                }
+                T value = up.next();
+                if (!predicate.test(value)) {
+                    state.abandon(before);
+                    return false;
+                }
+                emit(value);
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> dropWhile(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private boolean dropping = true;
+
+            @Override
+            boolean advance() {
+                while (up.hasNext()) {
+                    T value = up.next();
+                    if (dropping && predicate.test(value)) {
+                        continue;
+                    }
+                    dropping = false;
+                    emit(value);
+                    return true;
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+        Objects.requireNonNull(action);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next());
+            }
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(Consumer<? super T> action) {
+        forEach(action);
+    }
+
+    private List<T> drain() {
+        List<T> all = new ArrayList<T>();
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Object[] toArray() {
+        return drain().toArray();
+    }
+
+    @Override
+    public <A> A[] toArray(IntFunction<A[]> generator) {
+        Objects.requireNonNull(generator);
+        List<T> all = drain();
+        A[] out = generator.apply(all.size());
+        if (out.length != all.size()) {
+            throw new IllegalStateException("The generator answered an array of " + out.length + " for "
+                    + all.size() + " elements");
+        }
+        // Copied through an Object[] view: storing an element of the wrong
+        // type fails as an ArrayStoreException, like the JDK's.
+        Object[] target = out;
+        for (int i = 0; i < target.length; i++) {
+            target[i] = all.get(i);
+        }
+        return out;
+    }
+
+    @Override
+    public T reduce(T identity, BinaryOperator<T> accumulator) {
+        Objects.requireNonNull(accumulator);
+        T result = identity;
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                result = accumulator.apply(result, it.next());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> reduce(BinaryOperator<T> accumulator) {
+        Objects.requireNonNull(accumulator);
+        Iterator<T> it = take();
+        try {
+            if (!it.hasNext()) {
+                return Optional.empty();
+            }
+            T result = it.next();
+            while (it.hasNext()) {
+                result = accumulator.apply(result, it.next());
+            }
+            return Optional.of(result);
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        U result = identity;
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                result = accumulator.apply(result, it.next());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public <R, A> R collect(Collector<? super T, A, R> collector) {
+        Objects.requireNonNull(collector);
+        A container = collector.supplier().get();
+        BiConsumer<A, ? super T> accumulator = collector.accumulator();
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(container, it.next());
+            }
+            return collector.finisher().apply(container);
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> min(Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return reduce(BinaryOperator.<T>minBy(comparator));
+    }
+
+    @Override
+    public Optional<T> max(Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return reduce(BinaryOperator.<T>maxBy(comparator));
+    }
+
+    @Override
+    public long count() {
+        long n = 0;
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                it.next();
+                n++;
+            }
+            return n;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                if (predicate.test(it.next())) {
+                    state.abandon(state.abandonable());
+                    return true;
+                }
+            }
+            return false;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public boolean allMatch(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                if (!predicate.test(it.next())) {
+                    state.abandon(state.abandonable());
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public boolean noneMatch(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                if (predicate.test(it.next())) {
+                    state.abandon(state.abandonable());
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> findFirst() {
+        Iterator<T> it = take();
+        try {
+            if (!it.hasNext()) {
+                return Optional.empty();
+            }
+            Optional<T> first = Optional.of(it.next());
+            // The answer is in hand with the rest unread.
+            state.abandon(state.abandonable());
+            return first;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> findAny() {
+        return findFirst();
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return take();
+    }
+
+    @Override
+    public boolean isParallel() {
+        return state.parallel;
+    }
+
+    @Override
+    public Stream<T> sequential() {
+        state.parallel = false;
+        return this;
+    }
+
+    @Override
+    public Stream<T> parallel() {
+        state.parallel = true;
+        return this;
+    }
+
+    @Override
+    public Stream<T> unordered() {
+        return this;
+    }
+
+    @Override
+    public Stream<T> onClose(Runnable closeHandler) {
+        if (used || state.isClosed()) {
+            throw new IllegalStateException(USED);
+        }
+        state.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        used = true;
+        state.close();
+    }
+
+    /// What [Stream#builder] answers.
+    static final class ListBuilder<T> implements Stream.Builder<T> {
+
+        private List<T> elements = new ArrayList<T>();
+
+        @Override
+        public void accept(T t) {
+            if (elements == null) {
+                throw new IllegalStateException();
+            }
+            elements.add(t);
+        }
+
+        @Override
+        public Stream<T> build() {
+            if (elements == null) {
+                throw new IllegalStateException();
+            }
+            List<T> built = elements;
+            elements = null;
+            return over(built);
+        }
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/PullIterator.java b/Ports/CLDC11/src/java/util/stream/PullIterator.java
new file mode 100644
index 00000000000..2a8eed18320
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/PullIterator.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/// The iterator every stream stage is: it produces its next element only
+/// when asked whether there is one, which is what makes a pipeline lazy --
+/// `limit` stops asking the stage before it, and nothing further upstream
+/// runs.
+abstract class PullIterator<T> implements Iterator<T> {
+
+    private boolean ready;
+    private boolean done;
+    private T value;
+
+    /// Produces the next element by calling [#emit], or answers false when
+    /// there is none. Not called again once it answered false.
+    abstract boolean advance();
+
+    final void emit(T next) {
+        value = next;
+    }
+
+    @Override
+    public final boolean hasNext() {
+        if (!ready && !done) {
+            if (advance()) {
+                ready = true;
+            } else {
+                done = true;
+            }
+        }
+        return ready;
+    }
+
+    @Override
+    public final T next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        ready = false;
+        T out = value;
+        value = null;
+        return out;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/Stream.java b/Ports/CLDC11/src/java/util/stream/Stream.java
index 6d907368a8b..f6815ce98e9 100644
--- a/Ports/CLDC11/src/java/util/stream/Stream.java
+++ b/Ports/CLDC11/src/java/util/stream/Stream.java
@@ -22,31 +22,97 @@
  */
 package java.util.stream;
 
+import java.util.function.IntFunction;
+import java.util.Optional;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
-
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// A stream here is sequential and lazy: each stage pulls one element at a
+/// time from the one before it, and only when a terminal operation asks. So
+/// an infinite `iterate` or `generate` behind a `limit` ends, `findFirst`
+/// and the `anyMatch` family stop at the element that decides them, and the
+/// side effects of `peek` happen element by element, in encounter order.
+///
+/// What is not here: spliterators, and with them parallel evaluation.
+/// `parallel()` answers the stream it was called on.
 public interface Stream<T> extends BaseStream<T, Stream<T>> {
+
     Stream<T> filter(Predicate<? super T> predicate);
 
     <R> Stream<R> map(Function<? super T, ? extends R> mapper);
 
-    Stream<T> sorted();
+    IntStream mapToInt(ToIntFunction<? super T> mapper);
+
+    LongStream mapToLong(ToLongFunction<? super T> mapper);
+
+    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
+
+    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
+
+    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
+
+    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
+
+    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
 
     Stream<T> distinct();
 
+    Stream<T> sorted();
+
+    Stream<T> sorted(Comparator<? super T> comparator);
+
+    Stream<T> peek(Consumer<? super T> action);
+
     Stream<T> limit(long maxSize);
 
     Stream<T> skip(long n);
 
+    Stream<T> takeWhile(Predicate<? super T> predicate);
+
+    Stream<T> dropWhile(Predicate<? super T> predicate);
+
     void forEach(Consumer<? super T> action);
 
+    void forEachOrdered(Consumer<? super T> action);
+
     Object[] toArray();
 
+    <A> A[] toArray(IntFunction<A[]> generator);
+
     T reduce(T identity, BinaryOperator<T> accumulator);
 
-    <A, R> R collect(Collector<? super T, A, R> collector);
+    Optional<T> reduce(BinaryOperator<T> accumulator);
+
+    <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
+
+    <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
+
+    <R, A> R collect(Collector<? super T, A, R> collector);
+
+    /// An unmodifiable list of the elements, which may be null.
+    @SuppressWarnings("unchecked")
+    default List<T> toList() {
+        return (List<T>) Collections.unmodifiableList(new ArrayList<Object>(Arrays.asList(toArray())));
+    }
+
+    Optional<T> min(Comparator<? super T> comparator);
+
+    Optional<T> max(Comparator<? super T> comparator);
 
     long count();
 
@@ -56,15 +122,103 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
 
     boolean noneMatch(Predicate<? super T> predicate);
 
+    Optional<T> findFirst();
+
+    Optional<T> findAny();
+
+    static <T> Builder<T> builder() {
+        return new ObjPipeline.ListBuilder<T>();
+    }
+
     static <T> Stream<T> empty() {
-        return null;
+        return ObjPipeline.over(Collections.<T>emptyList());
     }
 
-    static <T> Stream<T> of(T value) {
-        return null;
+    static <T> Stream<T> of(T t) {
+        return ObjPipeline.over(Collections.singletonList(t));
     }
 
+    static <T> Stream<T> ofNullable(T t) {
+        return t == null ? Stream.<T>empty() : Stream.of(t);
+    }
+
+    @SafeVarargs
+    @SuppressWarnings("varargs")
     static <T> Stream<T> of(T... values) {
-        return null;
+        return ObjPipeline.ofArray(values, 0, values.length);
+    }
+
+    static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) {
+        if (f == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.over(new PullIterator<T>() {
+            private boolean started;
+            private T current;
+
+            @Override
+            boolean advance() {
+                current = started ? f.apply(current) : seed;
+                started = true;
+                emit(current);
+                return true;
+            }
+        });
+    }
+
+    static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+        if (hasNext == null || next == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.over(new PullIterator<T>() {
+            private boolean started;
+            private T current;
+
+            @Override
+            boolean advance() {
+                current = started ? next.apply(current) : seed;
+                started = true;
+                if (!hasNext.test(current)) {
+                    return false;
+                }
+                emit(current);
+                return true;
+            }
+        });
+    }
+
+    static <T> Stream<T> generate(Supplier<? extends T> s) {
+        if (s == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.over(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                emit(s.get());
+                return true;
+            }
+        });
+    }
+
+    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
+        if (a == null || b == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.concat(a, b);
+    }
+
+    /// `java.util.stream.Stream.Builder`: collects elements, then answers
+    /// them as a stream, once.
+    interface Builder<T> extends Consumer<T> {
+
+        @Override
+        void accept(T t);
+
+        default Builder<T> add(T t) {
+            accept(t);
+            return this;
+        }
+
+        Stream<T> build();
     }
 }
diff --git a/Ports/CLDC11/src/java/util/stream/StreamState.java b/Ports/CLDC11/src/java/util/stream/StreamState.java
new file mode 100644
index 00000000000..1be432ad226
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/StreamState.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// What the stages of one pipeline share: the handlers `onClose` registered,
+/// which `close()` on any stage runs, once.
+final class StreamState {
+
+    private List<Runnable> handlers;
+
+    /// What `parallel()` and `sequential()` last asked for, which
+    /// `isParallel()` reports. The pipeline runs sequentially either way,
+    /// which the JDK allows a parallel stream to do.
+    boolean parallel;
+    private boolean closed;
+
+    /// What closes a resource a stage holds while it is part read: the
+    /// mapped stream a `flatMap` is in the middle of. Kept in the order the
+    /// stages were added, which is the order the elements travel.
+    ///
+    /// The JDK closes a mapped stream whether or not all of it was wanted
+    /// (`flatMap(...).findFirst()` closes the one it took its answer from).
+    /// A pulled pipeline has to be told that nobody will ask again, and
+    /// three things know: a `limit` that has handed out its last element
+    /// and a `takeWhile` that met its first refusal, about the stages
+    /// before them, and a short-circuiting terminal operation or `close`,
+    /// about every stage.
+    ///
+    /// A terminal operation that ends by throwing releases them all too
+    /// ([#fail(Throwable)]). Not covered, and left to `close` as for any
+    /// stream holding a resource: an `iterator()` its caller stops reading.
+    private List<Runnable> abandoned;
+
+    void onAbandon(Runnable release) {
+        if (abandoned == null) {
+            abandoned = new ArrayList<Runnable>();
+        }
+        abandoned.add(release);
+    }
+
+    /// How many stages so far hold something to release: what a stage keeps
+    /// to say later that everything before it is no longer read.
+    int abandonable() {
+        return abandoned == null ? 0 : abandoned.size();
+    }
+
+    /// Releases what the first `count` such stages hold, the latest stage
+    /// first as the JDK's nested `flatMap`s close, even when one throws; the
+    /// first exception is thrown once all have run.
+    void abandon(int count) {
+        List<Runnable> held = abandoned;
+        if (held == null) {
+            return;
+        }
+        RuntimeException first = null;
+        for (int i = Math.min(count, held.size()) - 1; i >= 0; i--) {
+            Runnable release = held.get(i);
+            try {
+                release.run();
+            } catch (RuntimeException e) {
+                if (first == null) {
+                    first = e;
+                }
+            }
+        }
+        if (first != null) {
+            throw first;
+        }
+    }
+
+    void onClose(Runnable handler) {
+        if (handler == null) {
+            throw new NullPointerException();
+        }
+        if (handlers == null) {
+            handlers = new ArrayList<Runnable>();
+        }
+        handlers.add(handler);
+    }
+
+    /// Whether some stage of the pipeline was closed. The stages share this
+    /// state, so each of them can tell.
+    boolean isClosed() {
+        return closed;
+    }
+
+    /// Runs every handler, in the order they were added, even when one
+    /// throws, an Error included; the first failure is thrown once all have
+    /// run, with each later one added to it as suppressed, as the JDK's
+    /// stream does.
+    void close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        Throwable first = null;
+        try {
+            abandon(abandonable());
+        } catch (Throwable e) {
+            first = e;
+        }
+        if (handlers != null) {
+            for (int i = 0; i < handlers.size(); i++) {
+                // Read outside the try: the cast a generic get compiles to must
+                // not sit under a handler that would swallow its failure.
+                Runnable handler = handlers.get(i);
+                try {
+                    handler.run();
+                } catch (Throwable e) {
+                    first = suppress(first, e);
+                }
+            }
+        }
+        if (first != null) {
+            // Thrown as it is, a sneakily thrown checked exception included,
+            // which the JDK does not wrap either.
+            StreamState.<RuntimeException>rethrow(first);
+        }
+    }
+
+    /// What a terminal operation that ended by throwing `failure` calls:
+    /// every mapped stream still open is closed, the latest first, and what
+    /// closing one throws rides along as suppressed, as the JDK's
+    /// try-with-resources around each mapped stream does. Always throws
+    /// `failure`; declared to answer an exception so a caller can write
+    /// `throw state.fail(e)`.
+    RuntimeException fail(Throwable failure) {
+        List<Runnable> held = abandoned;
+        if (held != null) {
+            for (int i = held.size() - 1; i >= 0; i--) {
+                Runnable release = held.get(i);
+                try {
+                    release.run();
+                } catch (Throwable e) {
+                    suppress(failure, e);
+                }
+            }
+        }
+        StreamState.<RuntimeException>rethrow(failure);
+        return null;
+    }
+
+    /// Throws `t` unchanged, checked or not: the erased cast is to
+    /// `Throwable`, so nothing is checked at run time.
+    @SuppressWarnings("unchecked")
+    /// Throws `failure` as it is, checked or not.
+    static RuntimeException unchecked(Throwable failure) {
+        StreamState.<RuntimeException>rethrow(failure);
+        return null;
+    }
+
+    private static <E extends Throwable> void rethrow(Throwable t) throws E {
+        throw (E) t;
+    }
+
+    private static Throwable suppress(Throwable first, Throwable next) {
+        if (first == null) {
+            return next;
+        }
+        if (first != next) {
+            first.addSuppressed(next);
+        }
+        return first;
+    }
+}
diff --git a/Ports/CLDC11/src/java/util/stream/StreamSupport.java b/Ports/CLDC11/src/java/util/stream/StreamSupport.java
new file mode 100644
index 00000000000..3f1cfbd854d
--- /dev/null
+++ b/Ports/CLDC11/src/java/util/stream/StreamSupport.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/// Makes a [Stream] of a [Spliterator]: what `Collection.stream()` does, and
+/// how a library turns any `Iterable` into a stream
+/// (`StreamSupport.stream(iterable.spliterator(), false)`).
+///
+/// Streams here run sequentially; `parallel` is what `isParallel()`
+/// reports and changes nothing else, which the JDK allows.
+public final class StreamSupport {
+
+    private StreamSupport() {
+    }
+
+    /// The elements of `spliterator`, read when a terminal operation asks
+    /// for them.
+    public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
+        if (spliterator == null) {
+            throw new NullPointerException();
+        }
+        Stream<T> out = ObjPipeline.over(new Source<T>(spliterator, null));
+        return parallel ? out.parallel() : out;
+    }
+
+    /// The elements of the spliterator `supplier` answers when a terminal
+    /// operation first asks for one.
+    public static <T> Stream<T> stream(Supplier<? extends Spliterator<T>> supplier, int characteristics,
+                                       boolean parallel) {
+        if (supplier == null) {
+            throw new NullPointerException();
+        }
+        Stream<T> out = ObjPipeline.over(new Source<T>(null, supplier));
+        return parallel ? out.parallel() : out;
+    }
+
+    /// The first stage of such a stream: one `tryAdvance` per element.
+    private static final class Source<T> extends PullIterator<T> implements Consumer<T> {
+        private Spliterator<T> spliterator;
+        private final Supplier<? extends Spliterator<T>> supplier;
+
+        Source(Spliterator<T> spliterator, Supplier<? extends Spliterator<T>> supplier) {
+            this.spliterator = spliterator;
+            this.supplier = supplier;
+        }
+
+        @Override
+        public void accept(T t) {
+            emit(t);
+        }
+
+        @Override
+        boolean advance() {
+            if (spliterator == null) {
+                spliterator = supplier.get();
+            }
+            return spliterator.tryAdvance(this);
+        }
+    }
+}
diff --git a/Ports/JavaSE/src/com/codename1/impl/JdkHost.java b/Ports/JavaSE/src/com/codename1/impl/JdkHost.java
new file mode 100644
index 00000000000..ae07bd506c4
--- /dev/null
+++ b/Ports/JavaSE/src/com/codename1/impl/JdkHost.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+/// The services the Java class library asks of the platform it runs on.
+///
+/// Internal API. The `java.*` classes of the ParparVM runtime (`vm/JavaAPI`)
+/// need a file system, preferences, the network, a log and an event thread,
+/// and on a device those belong to Codename One, which the class library
+/// cannot name: it is translated alone for the translator itself, the backend
+/// and the VM tests. So the class library calls this class, and whoever runs
+/// it installs the implementation that fits:
+///
+/// - a Codename One application gets `com.codename1.impl.CoreJdkHost`, which
+///   delegates to `FileSystemStorage`, `Preferences`, `NetworkManager`, `Log`
+///   and `Display`. The ParparVM ports install it from their `init`.
+/// - a program translated without Codename One (the self-hosted translator,
+///   the backend, a VM test) gets `PosixJdkHost`, which reaches the POSIX file
+///   natives through `java.io.File`.
+/// - anything else gets the defaults below, which are plain Java and touch no
+///   native method, so an application target that never installs a host
+///   cannot link the file natives through this class.
+///
+/// On Java SE and Android the real JDK runs and nothing calls this class.
+/// Copies of it ship in those ports only so that `CoreJdkHost`, which is part
+/// of the core sources, always has its superclass.
+///
+/// The file is kept byte for byte identical in `vm/JavaAPI`, `Ports/CLDC11`,
+/// `Ports/JavaSE` and `Ports/Android`; `CldcJavaApiParityTest` holds them
+/// to that. It may use only API all four class libraries have.
+///
+/// Paths are in the host's own form: absolute, as [#appHome] answers them.
+/// Turning a relative path into one is the caller's job.
+public abstract class JdkHost {
+    /// [#log] level of a debug message.
+    public static final int LOG_DEBUG = 1;
+    /// [#log] level of an informational message.
+    public static final int LOG_INFO = 2;
+    /// [#log] level of a warning.
+    public static final int LOG_WARNING = 3;
+    /// [#log] level of an error.
+    public static final int LOG_ERROR = 4;
+
+    private static final JdkHost DEFAULTS = new Defaults();
+    private static JdkHost current;
+    private static Registry registry;
+    private static Map<String, String> memoryPreferences;
+
+    /// Subclasses are installed with [#install].
+    protected JdkHost() {
+    }
+
+    /// The installed host, or the plain Java defaults when none was installed.
+    public static JdkHost get() {
+        JdkHost h = current;
+        return h == null ? DEFAULTS : h;
+    }
+
+    /// Makes `host` the one [#get] answers; null restores the defaults.
+    /// Called once, while the program starts and before it starts a thread
+    /// of its own.
+    public static void install(JdkHost host) {
+        current = host;
+    }
+
+    /// Makes `r` the registry [#providers] and [#newInstance] read. An
+    /// application's generated start-up code installs it.
+    public static void setRegistry(Registry r) {
+        registry = r;
+    }
+
+    /// The registry [#setRegistry] installed, or null.
+    public static Registry getRegistry() {
+        return registry;
+    }
+
+    // ------------------------------------------------------------------
+    // Files
+
+    /// What is known of `path`, or null when nothing is there.
+    public FileStat fileStat(String path) {
+        return null;
+    }
+
+    /// The names of the entries of the directory `path`, or null when it is
+    /// not a directory.
+    public String[] fileList(String path) throws IOException {
+        return null;
+    }
+
+    /// Opens the file `path` for reading.
+    public InputStream fileRead(String path) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Opens the file `path` for writing, at its end when `append` is true
+    /// and from empty otherwise, creating it when it is not there.
+    public OutputStream fileWrite(String path, boolean append) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Creates the directory `path`; false when it was not created, also
+    /// when something was there already.
+    public boolean fileMkdir(String path) {
+        return false;
+    }
+
+    /// Deletes the file or empty directory `path`; false when it is still
+    /// there or never was.
+    public boolean fileDelete(String path) {
+        return false;
+    }
+
+    /// Moves `from` to `to`, which must not exist. False when it did not
+    /// happen; a host may refuse a move to another directory, and the
+    /// caller then copies.
+    public boolean fileRename(String from, String to) {
+        return false;
+    }
+
+    /// The application's home directory, where a relative path resolves.
+    public String appHome() {
+        return "/";
+    }
+
+    /// A directory for disposable files, or null when the platform has no
+    /// separate one and [#appHome] serves.
+    public String cachesDir() {
+        return null;
+    }
+
+    /// The roots of the file system.
+    public String[] fileRoots() {
+        return new String[] {appHome()};
+    }
+
+    /// The size in bytes of the volume holding `path`, or 0 when unknown.
+    public long fileTotalSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes still free for this program on the volume holding `path`,
+    /// or 0 when unknown.
+    public long fileUsableSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes free on the volume holding `path`, counting what only a
+    /// privileged user may use; [#fileUsableSpace] unless the host knows
+    /// better.
+    public long fileFreeSpace(String path) {
+        return fileUsableSpace(path);
+    }
+
+    /// [#fileTest]: something is at the path.
+    public static final int FILE_EXISTS = 1;
+    /// [#fileTest]: the path is a directory.
+    public static final int FILE_DIRECTORY = 2;
+    /// [#fileTest]: the path is a file that is not a directory.
+    public static final int FILE_REGULAR = 3;
+    /// [#fileTest] and [#fileSet]: the path may be read.
+    public static final int FILE_READABLE = 4;
+    /// [#fileTest] and [#fileSet]: the path may be written.
+    public static final int FILE_WRITABLE = 5;
+    /// [#fileTest] and [#fileSet]: the path may be executed, or for a
+    /// directory, entered.
+    public static final int FILE_EXECUTABLE = 6;
+    /// [#fileTest]: the path is hidden.
+    public static final int FILE_HIDDEN = 7;
+
+    /// Whether `path` has the property `what`, one of the `FILE_` constants.
+    ///
+    /// The defaults read [#fileStat]: a file system without permissions lets
+    /// everything that exists be read and written, a directory be entered and
+    /// nothing be run, and hides a name that starts with a dot.
+    public boolean fileTest(String path, int what) {
+        if (what == FILE_HIDDEN) {
+            int slash = path.lastIndexOf('/');
+            return path.startsWith(".", slash + 1);
+        }
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_DIRECTORY || what == FILE_EXECUTABLE) {
+            return st.isDirectory();
+        }
+        if (what == FILE_REGULAR) {
+            return !st.isDirectory();
+        }
+        return true;
+    }
+
+    /// Grants (`on`) or takes away the permission `what` on `path`, one of
+    /// [#FILE_READABLE], [#FILE_WRITABLE] and [#FILE_EXECUTABLE]; false when
+    /// the path is not left that way.
+    ///
+    /// The defaults change nothing, so they answer whether the path already is
+    /// as asked, by the rules of [#fileTest].
+    public boolean fileSet(String path, int what, boolean on) {
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_EXECUTABLE) {
+            return on == st.isDirectory();
+        }
+        return on;
+    }
+
+    /// The length in bytes of the file `path`; 0 for a directory or when
+    /// nothing is there.
+    public long fileLength(String path) {
+        FileStat st = fileStat(path);
+        return st == null || st.isDirectory() ? 0L : st.length();
+    }
+
+    /// When `path` was last modified, in milliseconds since the epoch; 0 when
+    /// nothing is there.
+    public long fileLastModified(String path) {
+        FileStat st = fileStat(path);
+        return st == null ? 0L : st.lastModified();
+    }
+
+    /// Creates the empty file `path` when nothing is there; false when
+    /// something was.
+    ///
+    /// The default checks and then creates, which is not atomic: two threads
+    /// racing on one path can both be answered true.
+    public boolean fileCreate(String path) throws IOException {
+        if (fileStat(path) != null) {
+            return false;
+        }
+        fileWrite(path, false).close();
+        return true;
+    }
+
+    /// Moves `from` over `to`, replacing the file there. False when it did not
+    /// happen, which is all the defaults answer; the caller then copies.
+    public boolean fileReplace(String from, String to) {
+        return false;
+    }
+
+    /// The absolute `path` with symbolic links, `.` and `..` resolved, or
+    /// null when the host cannot resolve links and the caller should resolve
+    /// the dots by itself.
+    public String fileCanonicalPath(String path) throws IOException {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Preferences
+
+    /// The stored preference `key`, or null. The defaults keep preferences
+    /// in memory, for this run only.
+    public String preference(String key) {
+        return memoryPreference(key, null, false);
+    }
+
+    /// Stores `value` under `key`.
+    public void setPreference(String key, String value) {
+        memoryPreference(key, value, true);
+    }
+
+    /// Removes the preference `key`.
+    public void deletePreference(String key) {
+        memoryPreference(key, null, true);
+    }
+
+    /// Reads `key` from the in-memory preferences, or, when `write` is true,
+    /// stores `value` there (null removes it). One lock: the class library
+    /// runs on several threads where a host leaves this to the defaults.
+    private static synchronized String memoryPreference(String key, String value, boolean write) {
+        if (memoryPreferences == null) {
+            memoryPreferences = new HashMap<String, String>();
+        }
+        if (!write) {
+            return memoryPreferences.get(key);
+        }
+        if (value == null) {
+            return memoryPreferences.remove(key);
+        }
+        return memoryPreferences.put(key, value);
+    }
+
+    // ------------------------------------------------------------------
+    // Network, log and process
+
+    /// Reads `url` with an HTTP GET. A missing resource (404, 410) throws
+    /// `java.io.FileNotFoundException`, any other failure an `IOException`.
+    public InputStream openUrl(String url) throws IOException {
+        throw new IOException("No network: " + url);
+    }
+
+    /// Logs `message` and `thrown`, either of which may be null, at `level`
+    /// ([#LOG_DEBUG] to [#LOG_ERROR]).
+    public void log(int level, String message, Throwable thrown) {
+        if (message != null) {
+            System.err.println(message);
+        }
+        if (thrown != null) {
+            thrown.printStackTrace();
+        }
+    }
+
+    /// The platform's answer for the system property `key`, or null. The
+    /// class library answers the properties it defines itself.
+    public String property(String key) {
+        return null;
+    }
+
+    /// Asks the platform to close the application, after the shutdown hooks
+    /// ran; `Runtime.exit` ends the process itself if this returns. The
+    /// defaults leave it to that.
+    public void exit(int status) {
+    }
+
+    /// Called when the program installs a default uncaught exception
+    /// handler, so that a host whose UI thread catches what its tasks throw
+    /// can hand that to `Thread.getDefaultUncaughtExceptionHandler()` too.
+    /// Called on every such install; the defaults do nothing.
+    public void watchUncaughtExceptions() {
+    }
+
+    // ------------------------------------------------------------------
+    // Threads
+
+    /// Whether the caller is the UI thread, which must not block.
+    public boolean isUiThread() {
+        return false;
+    }
+
+    /// Runs `task`, which blocks, where blocking is allowed: off the UI
+    /// thread while that thread keeps serving events, or right here.
+    public void blockUi(Runnable task) {
+        task.run();
+    }
+
+    // ------------------------------------------------------------------
+    // Resources, services and locale
+
+    /// Opens the application resource `name` (a path such as
+    /// `META-INF/services/x`, without a leading slash), or null.
+    public InputStream resource(String name) {
+        return null;
+    }
+
+    /// The class names of the providers of `service` the application
+    /// declares, from the [Registry]; empty when there is none.
+    public String[] providers(String service) {
+        Registry r = registry;
+        String[] names = r == null ? null : r.providers(service);
+        return names == null ? new String[0] : names;
+    }
+
+    /// A new instance of the application class `className`, made by the
+    /// [Registry] without reflection; null when it cannot make one.
+    public Object newInstance(String className) {
+        Registry r = registry;
+        return r == null ? null : r.newInstance(className);
+    }
+
+    /// The class of the application class `className`, as the [Registry]
+    /// knows it, so that its type can be tested without creating one; null
+    /// when it does not know the class.
+    public Class<?> type(String className) {
+        Registry r = registry;
+        return r == null ? null : r.type(className);
+    }
+
+    /// The decimal separator, grouping separator and currency symbol of the
+    /// device's locale, any of them null when unknown; or null when the
+    /// platform cannot tell.
+    public String[] localeNumberSymbols() {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Security
+
+    /// Fills `out` with cryptographically secure random bytes.
+    public void randomBytes(byte[] out) {
+        throw new UnsupportedOperationException("No secure random source");
+    }
+
+    /// A new digest for `algorithm` (`MD5`, `SHA-1`, `SHA-256` and the like),
+    /// or null when the platform has none.
+    public Digest digest(String algorithm) {
+        return null;
+    }
+
+    /// The attributes [#fileStat] reports.
+    public static final class FileStat {
+        private final boolean directory;
+        private final long length;
+        private final long lastModified;
+
+        /// A file or, when `directory` is true, a directory.
+        public FileStat(boolean directory, long length, long lastModified) {
+            this.directory = directory;
+            this.length = length;
+            this.lastModified = lastModified;
+        }
+
+        /// Whether it is a directory.
+        public boolean isDirectory() {
+            return directory;
+        }
+
+        /// The length in bytes of a file; 0 for a directory.
+        public long length() {
+            return length;
+        }
+
+        /// When it was last modified, in milliseconds since the epoch, or 0.
+        public long lastModified() {
+            return lastModified;
+        }
+    }
+
+    /// A running message digest, as [#digest] makes it.
+    public interface Digest {
+        /// Feeds `length` bytes of `data` from `offset`.
+        void update(byte[] data, int offset, int length);
+
+        /// Finishes the digest and resets it.
+        byte[] digest();
+
+        /// Discards what was fed.
+        void reset();
+
+        /// The length of the digest in bytes.
+        int length();
+    }
+
+    /// What an application declares for `java.util.ServiceLoader` and
+    /// `java.util.ResourceBundle`, generated with the application. Once one
+    /// is installed it is the whole answer: the class library creates no
+    /// class from its name and reads no services file.
+    public interface Registry {
+        /// The provider class names declared for `service`, or null.
+        String[] providers(String service);
+
+        /// A new instance of `className`, or null.
+        Object newInstance(String className);
+
+        /// The class `className`, or null when the registry does not know it.
+        Class<?> type(String className);
+    }
+
+    /// The host [#get] answers when none was installed.
+    private static final class Defaults extends JdkHost {
+    }
+}
diff --git a/Ports/JavaSE/src/com/codename1/impl/javase/CompatResourceSupport.java b/Ports/JavaSE/src/com/codename1/impl/javase/CompatResourceSupport.java
new file mode 100644
index 00000000000..3751795e5e8
--- /dev/null
+++ b/Ports/JavaSE/src/com/codename1/impl/javase/CompatResourceSupport.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.javase;
+
+import com.codename1.impl.compat.Resources;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.util.Collections;
+import java.util.Enumeration;
+
+/// What an application built from desktop sources needs of the JDK this port
+/// runs on to find the resources its build flattened
+/// ([com.codename1.impl.compat.Resources]).
+///
+/// - The JDK's `URL` does not know the `cn1res:` scheme, so the URLs
+///   `Resources` answers are made here with a handler that reads them back
+///   through it.
+/// - The JDK's `ResourceBundle` and `ServiceLoader` look a nested name up
+///   through a class loader, so the loader installed here asks the
+///   application's own loader first and `Resources` after it.
+///
+/// The Android port carries the same class for the same reasons.
+final class CompatResourceSupport {
+    private static final String SCHEME = "cn1res";
+
+    private CompatResourceSupport() {
+    }
+
+    /// Installs both into `Resources`. Idempotent.
+    static void install() {
+        Resources.cn1SetUrlFactory(new Factory());
+        if (Resources.cn1ClassLoader() == null) {
+            ClassLoader parent = Resources.class.getClassLoader();
+            Resources.cn1SetClassLoader(new FlatResourceLoader(parent));
+        }
+    }
+
+    private static URL create(String encodedPath) throws MalformedURLException {
+        return new URL(SCHEME, null, -1, encodedPath, Handler.INSTANCE);
+    }
+
+    private static final class Factory implements Resources.UrlFactory {
+        @Override
+        public URL create(String encodedPath) throws IOException {
+            return CompatResourceSupport.create(encodedPath);
+        }
+    }
+
+    private static final class Handler extends URLStreamHandler {
+        static final Handler INSTANCE = new Handler();
+
+        @Override
+        protected URLConnection openConnection(URL u) {
+            return new Connection(u);
+        }
+    }
+
+    private static final class Connection extends URLConnection {
+        Connection(URL url) {
+            super(url);
+        }
+
+        @Override
+        public void connect() {
+            connected = true;
+        }
+
+        @Override
+        public InputStream getInputStream() throws IOException {
+            InputStream in = Resources.openUrlPath(getURL().getPath());
+            if (in == null) {
+                throw new FileNotFoundException(getURL().toExternalForm());
+            }
+            return in;
+        }
+    }
+
+    /// The application's loader, then the resources the build flattened.
+    private static final class FlatResourceLoader extends ClassLoader {
+        FlatResourceLoader(ClassLoader parent) {
+            super(parent);
+        }
+
+        @Override
+        protected URL findResource(String name) {
+            if (name == null || name.startsWith("/") || !Resources.exists(name)) {
+                return null;
+            }
+            return Resources.getSystemResource(name);
+        }
+
+        @Override
+        protected Enumeration<URL> findResources(String name) {
+            URL url = findResource(name);
+            if (url == null) {
+                return Collections.<URL>emptyEnumeration();
+            }
+            return Collections.enumeration(Collections.singletonList(url));
+        }
+
+        /// A services file is the generated registry's list once one is
+        /// installed, and nothing else: the files the build flattened would
+        /// shadow one another, and would name providers that do not ship.
+        @Override
+        public Enumeration<URL> getResources(String name) throws IOException {
+            if (name != null && name.startsWith(Resources.SERVICES)) {
+                String file = Resources.cn1ServicesFile(name.substring(Resources.SERVICES.length()));
+                if (file != null) {
+                    URL url = new URL(SCHEME, null, -1, "/" + name, new TextHandler(file));
+                    return Collections.enumeration(Collections.singletonList(url));
+                }
+            }
+            return super.getResources(name);
+        }
+    }
+
+    /// Serves one text, as UTF-8, whatever the URL.
+    private static final class TextHandler extends URLStreamHandler {
+        private final String text;
+
+        TextHandler(String text) {
+            this.text = text;
+        }
+
+        @Override
+        protected URLConnection openConnection(URL u) {
+            return new URLConnection(u) {
+                @Override
+                public void connect() {
+                    connected = true;
+                }
+
+                @Override
+                public InputStream getInputStream() throws IOException {
+                    return new ByteArrayInputStream(text.getBytes("UTF-8"));
+                }
+            };
+        }
+    }
+}
diff --git a/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java b/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java
index 3f5bfb49eca..20054fa8453 100644
--- a/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java
+++ b/Ports/JavaSE/src/com/codename1/impl/javase/JavaSEPort.java
@@ -11306,6 +11306,9 @@ private static void installGeneratedSvgRegistry() {
     public void init(Object m) {
         inInit = true;
         installGeneratedSvgRegistry();
+        // cn1res: URLs and flattened resources for applications built from
+        // desktop sources, which this JDK cannot resolve on its own.
+        CompatResourceSupport.install();
 
         // Make the desktop stdio and loopback socket MCP transports available to
         // com.codename1.mcp.MCP.
@@ -12435,7 +12438,60 @@ public void run() {
         //}
         
         checkEDT();
-        
+
+        // The editor is a Swing component, so it is built, added and focused on the
+        // AWT event thread and nowhere else. Built here, on the Codename One EDT, it
+        // raced the AWT thread that was already painting it: setCaretPosition off the
+        // AWT thread makes DefaultCaret queue its repaint there, and that repaint read
+        // the text view while setFont on this thread was replacing it -- an
+        // intermittent NullPointerException under DefaultCaret.repaintNewCaret.
+        //
+        // The hop waits, as flushGraphics and requestFullScreen do, so the editor is
+        // in place and isEditingText() answers true by the time this method returns,
+        // exactly as before. Nothing in the body waits for this thread in return:
+        // what the editor sends back goes through callSerially.
+        //
+        // One line of the body is not Swing's: the field's own text is set from the
+        // editor's when editing starts with a key. That fires the application's
+        // listeners, so it is handed back and done here, on the thread they expect.
+        final String[] initialText = new String[1];
+        if (EventQueue.isDispatchThread()) {
+            editStringOnAwtThread(cmp, constraint, text, keyCode, initialText);
+        } else {
+            final String fText = text;
+            try {
+                EventQueue.invokeAndWait(new Runnable() {
+                    public void run() {
+                        editStringOnAwtThread(cmp, constraint, fText, keyCode, initialText);
+                    }
+                });
+            } catch (InterruptedException ex) {
+                Thread.currentThread().interrupt();
+                return;
+            } catch (java.lang.reflect.InvocationTargetException ex) {
+                Throwable cause = ex.getCause();
+                if (cause instanceof RuntimeException) {
+                    throw (RuntimeException) cause;
+                }
+                if (cause instanceof Error) {
+                    throw (Error) cause;
+                }
+                throw new RuntimeException(cause);
+            }
+        }
+        if (initialText[0] != null) {
+            ((com.codename1.ui.TextField) cmp).setText(initialText[0]);
+        }
+    }
+
+    /**
+     * The Swing half of editString: builds the native editor over the field and
+     * starts editing. Runs on the AWT event thread only.
+     *
+     * @param initialText receives the text the field itself is to be given, when
+     * editing starts with a key; the caller sets it on the Codename One EDT
+     */
+    private void editStringOnAwtThread(final Component cmp, final int constraint, String text, final int keyCode, String[] initialText) {
         class Repainter {
             JComponent jcmp;
             javax.swing.border.Border origBorder;
@@ -12646,7 +12702,7 @@ public void keyReleased(KeyEvent e) {
             setText(tf, text);
             setCaretPosition(tf, text.length());
             if(cmp instanceof com.codename1.ui.TextField) {
-                ((com.codename1.ui.TextField) cmp).setText(getText(tf));
+                initialText[0] = getText(tf);
             }
         } else {
             setText(tf, text);
diff --git a/Ports/JavaSE/src/com/codename1/impl/process/JavaSEProcessSupport.java b/Ports/JavaSE/src/com/codename1/impl/process/JavaSEProcessSupport.java
index 46b53629fab..9ae2e8f61a8 100644
--- a/Ports/JavaSE/src/com/codename1/impl/process/JavaSEProcessSupport.java
+++ b/Ports/JavaSE/src/com/codename1/impl/process/JavaSEProcessSupport.java
@@ -80,5 +80,29 @@ public Process destroyForcibly() {
             child.destroyForcibly();
             return this;
         }
+        @Override
+        public long pid() {
+            // Process.pid() is Java 9 API and this class compiles against
+            // Java 8. A Java 8 runtime has no id to give, and answers as
+            // JavaSE's own default does.
+            Object id;
+            try {
+                id = java.lang.Process.class.getMethod("pid").invoke(child);
+            } catch (NoSuchMethodException ex) {
+                throw new UnsupportedOperationException("pid() needs Java 9 or newer");
+            } catch (IllegalAccessException ex) {
+                throw new UnsupportedOperationException(ex.toString());
+            } catch (java.lang.reflect.InvocationTargetException ex) {
+                Throwable cause = ex.getCause();
+                if (cause instanceof RuntimeException) {
+                    throw (RuntimeException) cause;
+                }
+                throw new UnsupportedOperationException(String.valueOf(cause));
+            }
+            if (id instanceof Long) {
+                return ((Long) id).longValue();
+            }
+            throw new UnsupportedOperationException("pid() answered " + id);
+        }
     }
 }
diff --git a/Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/HTML5Implementation.java b/Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/HTML5Implementation.java
index abbf5bdddbb..6e5625746e4 100644
--- a/Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/HTML5Implementation.java
+++ b/Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/HTML5Implementation.java
@@ -5116,6 +5116,9 @@ public MouseEvent getLastMouseEvent() {
     
     @Override
     public void init(Object m) {
+        // The class library (vm/JavaAPI) reaches files, preferences, the
+        // network and the EDT through Codename One from here on.
+        com.codename1.impl.CoreJdkHostInstaller.install();
         //__init();
         if (m instanceof Runnable) {
             //((Runnable)m).run();
diff --git a/Ports/LinuxPort/nativeSources/cn1_linux_desktopwindow.c b/Ports/LinuxPort/nativeSources/cn1_linux_desktopwindow.c
index 95526c2f3ef..acc232e49ef 100644
--- a/Ports/LinuxPort/nativeSources/cn1_linux_desktopwindow.c
+++ b/Ports/LinuxPort/nativeSources/cn1_linux_desktopwindow.c
@@ -1181,6 +1181,136 @@ JAVA_BOOLEAN com_codename1_impl_linux_LinuxNative_mainWindowGetBounds___int_1ARR
     return JAVA_TRUE;
 }
 
+/*
+ * Resizing the application's own window.
+ *
+ * The main window opens at the size initDisplay is given and, until this existed,
+ * could only be resized by the user: Display.setWindowSize reached the default
+ * implementation, which does nothing, so an application that asked for a 350x550
+ * window drew into the 800x600 one it was born with.
+ *
+ * The size is the OUTER one, frame included, which is what the JavaSE port's
+ * setWindowSize (JFrame.setSize) and this port's secondary windows both mean. GTK
+ * resizes the client area, so the chrome has to be subtracted, and the chrome is
+ * not measurable until the window manager has reparented the window. The request
+ * is therefore kept pending and applied from configure-event, exactly as
+ * cn1DesktopApplyPendingOuterSize does for a secondary window.
+ */
+static int cn1MainOuterPending;
+static int cn1MainRequestedOuterW;
+static int cn1MainRequestedOuterH;
+static int cn1MainConfigureHooked;
+
+static void cn1MainApplyPendingOuterSize(GtkWidget* main) {
+    int chromeW;
+    int chromeH;
+    int clientW;
+    int clientH;
+    if (main == 0 || !cn1MainOuterPending) {
+        return;
+    }
+    if (!cn1DesktopChromeInsets(main, &chromeW, &chromeH)) {
+        return;
+    }
+    clientW = cn1MainRequestedOuterW - chromeW;
+    clientH = cn1MainRequestedOuterH - chromeH;
+    if (clientW < 1) {
+        clientW = 1;
+    }
+    if (clientH < 1) {
+        clientH = 1;
+    }
+    /* Cleared before the resize: the resize comes back through configure-event. */
+    cn1MainOuterPending = 0;
+    gtk_window_resize(GTK_WINDOW(main), clientW, clientH);
+}
+
+static gboolean cn1MainOnWindowConfigure(GtkWidget* widget, GdkEventConfigure* e, gpointer data) {
+    (void) e;
+    (void) data;
+    cn1MainApplyPendingOuterSize(widget);
+    return FALSE;
+}
+
+static void cn1MainWindowSetSizeOnMain(void* arg) {
+    CN1DesktopOp* op = (CN1DesktopOp*) arg;
+    GtkWidget* main = cn1LinuxWindowWidget();
+    if (main == 0) {
+        /* Headless: the surface size is the screenshot's, and is not ours to change. */
+        return;
+    }
+    if (!cn1MainConfigureHooked) {
+        cn1MainConfigureHooked = 1;
+        g_signal_connect(main, "configure-event", G_CALLBACK(cn1MainOnWindowConfigure), 0);
+    }
+    cn1MainRequestedOuterW = op->a > 0 ? op->a : 1;
+    cn1MainRequestedOuterH = op->b > 0 ? op->b : 1;
+    cn1MainOuterPending = 1;
+    cn1MainApplyPendingOuterSize(main);
+    if (cn1MainOuterPending) {
+        /* No frame to measure yet -- or never, with no window manager, where the
+         * client area is the outer size. Resize to the figure asked for and let
+         * configure-event correct it once there is chrome. */
+        gtk_window_resize(GTK_WINDOW(main), cn1MainRequestedOuterW, cn1MainRequestedOuterH);
+    }
+}
+
+JAVA_VOID com_codename1_impl_linux_LinuxNative_mainWindowSetSize___int_int(
+        CODENAME_ONE_THREAD_STATE, JAVA_INT width, JAVA_INT height) {
+    CN1DesktopOp op;
+    memset(&op, 0, sizeof(op));
+    op.a = width;
+    op.b = height;
+    cn1LinuxRunOnMainAndWait(cn1MainWindowSetSizeOnMain, &op);
+}
+
+/* The main window's outer rectangle: what mainWindowSetSize accepts, so that a
+ * size read back is the size that was set. mainWindowGetBounds answers the client
+ * area, which is what centring over a Form wants and is smaller by the chrome. */
+static void cn1MainWindowGetFrameOnMain(void* arg) {
+    CN1DesktopOp* op = (CN1DesktopOp*) arg;
+    GtkWidget* main = cn1LinuxWindowWidget();
+    int chromeW;
+    int chromeH;
+    op->a = 0;
+    if (main == 0) {
+        return;
+    }
+    gtk_window_get_position(GTK_WINDOW(main), &op->out[0], &op->out[1]);
+    gtk_window_get_size(GTK_WINDOW(main), &op->out[2], &op->out[3]);
+    if (cn1DesktopChromeInsets(main, &chromeW, &chromeH)) {
+        op->out[2] += chromeW;
+        op->out[3] += chromeH;
+    } else if (cn1MainOuterPending) {
+        op->out[2] = cn1MainRequestedOuterW;
+        op->out[3] = cn1MainRequestedOuterH;
+    }
+    op->a = 1;
+}
+
+JAVA_BOOLEAN com_codename1_impl_linux_LinuxNative_mainWindowGetFrame___int_1ARRAY_R_boolean(
+        CODENAME_ONE_THREAD_STATE, JAVA_OBJECT out) {
+    CN1DesktopOp op;
+    JAVA_INT* arr;
+    if (out == JAVA_NULL) {
+        return JAVA_FALSE;
+    }
+    if ((int) (*(JAVA_ARRAY) out).length < 4) {
+        return JAVA_FALSE;
+    }
+    memset(&op, 0, sizeof(op));
+    cn1LinuxRunOnMainAndWait(cn1MainWindowGetFrameOnMain, &op);
+    if (!op.a) {
+        return JAVA_FALSE;
+    }
+    arr = (JAVA_INT*) CN1_ARRAY_DATA(out);
+    arr[0] = op.out[0];
+    arr[1] = op.out[1];
+    arr[2] = op.out[2];
+    arr[3] = op.out[3];
+    return JAVA_TRUE;
+}
+
 JAVA_INT com_codename1_impl_linux_LinuxNative_desktopWindowGetWidth___int_R_int(
         CODENAME_ONE_THREAD_STATE, JAVA_INT slot) {
     CN1LinuxWindow* w = slotAt(slot);
diff --git a/Ports/LinuxPort/nativeSources/cn1_linux_edit.c b/Ports/LinuxPort/nativeSources/cn1_linux_edit.c
index 25b73c87035..5ec2fcdb305 100644
--- a/Ports/LinuxPort/nativeSources/cn1_linux_edit.c
+++ b/Ports/LinuxPort/nativeSources/cn1_linux_edit.c
@@ -44,6 +44,8 @@ typedef struct {
     GtkTextBuffer* buffer;  /* GtkTextView buffer, or NULL for single-line */
     int singleLine;
     volatile int done;
+    /* How the edit ended when Tab ended it: 1 forwards, 2 backwards, else 0. */
+    volatile int tab;
     char* text;             /* latest committed/changed text (heap) */
     /* The window whose overlay hosts this editor, so teardown removes it from the
      * same place it was added. */
@@ -102,6 +104,28 @@ static gboolean cn1EditFocusOut(GtkWidget* w, GdkEvent* ev, gpointer data) {
     return FALSE;
 }
 
+/*
+ * Tab in a single-line field ends the edit and is reported, so the port hands the
+ * key to the form and the focus moves on. Left to GTK it moved GTK's own focus:
+ * the entry is the only focusable widget of the window, so the edit ended on the
+ * focus-out and the focus of the form stayed where it was -- the next field was
+ * out of the keyboard's reach.
+ */
+static gboolean cn1EditKeyPress(GtkWidget* w, GdkEventKey* ev, gpointer data) {
+    CN1Edit* e = (CN1Edit*) data;
+    (void) w;
+    if ((ev->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)) != 0) {
+        return FALSE;
+    }
+    if (ev->keyval == GDK_KEY_Tab || ev->keyval == GDK_KEY_KP_Tab || ev->keyval == GDK_KEY_ISO_Left_Tab) {
+        cn1EditCaptureText(e);
+        e->tab = (ev->keyval == GDK_KEY_ISO_Left_Tab || (ev->state & GDK_SHIFT_MASK) != 0) ? 2 : 1;
+        e->done = 1;
+        return TRUE;
+    }
+    return FALSE;
+}
+
 static void cn1EditApplyStyle(GtkWidget* w, CN1Font* font, int fg, int bg) {
     if (font && font->desc) {
         gtk_widget_override_font(w, font->desc);
@@ -143,6 +167,7 @@ static void cn1EditCreateOnMain(void* p) {
         cn1EditApplyStyle(e->entry, req->font, req->fg, req->bg);
         g_signal_connect(e->entry, "changed", G_CALLBACK(cn1EditChanged), e);
         g_signal_connect(e->entry, "activate", G_CALLBACK(cn1EditActivate), e);
+        g_signal_connect(e->entry, "key-press-event", G_CALLBACK(cn1EditKeyPress), e);
         g_signal_connect(e->entry, "focus-out-event", G_CALLBACK(cn1EditFocusOut), e);
     } else {
         /* Use the GtkTextView directly as the overlay widget rather than wrapping it
@@ -171,7 +196,15 @@ static void cn1EditCreateOnMain(void* p) {
     g_object_ref_sink(e->container);
 
     cn1LinuxOverlayAdd(req->slot, e->container, req->x, req->y, req->w, req->h);
-    gtk_widget_grab_focus(e->container);
+    if (e->entry) {
+        /* An entry given the focus selects all of its text, so the first key typed
+         * replaced what the field held. The caret goes after the text instead, as
+         * it does in the field the editor stands in for. */
+        gtk_entry_grab_focus_without_selecting(GTK_ENTRY(e->entry));
+        gtk_editable_set_position(GTK_EDITABLE(e->entry), -1);
+    } else {
+        gtk_widget_grab_focus(e->container);
+    }
     req->result = e;
 }
 
@@ -202,6 +235,11 @@ JAVA_BOOLEAN com_codename1_impl_linux_LinuxNative_editIsDone___long_R_boolean(CO
     return (e && e->done) ? JAVA_TRUE : JAVA_FALSE;
 }
 
+JAVA_INT com_codename1_impl_linux_LinuxNative_editTabbed___long_R_int(CODENAME_ONE_THREAD_STATE, JAVA_LONG peer) {
+    CN1Edit* e = (CN1Edit*) (intptr_t) peer;
+    return e ? (JAVA_INT) e->tab : 0;
+}
+
 JAVA_OBJECT com_codename1_impl_linux_LinuxNative_editGetText___long_R_java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_LONG peer) {
     CN1Edit* e = (CN1Edit*) (intptr_t) peer;
     JAVA_OBJECT result;
diff --git a/Ports/LinuxPort/nativeSources/cn1_linux_image.c b/Ports/LinuxPort/nativeSources/cn1_linux_image.c
index 6b8eea1d168..cff7cd2feba 100644
--- a/Ports/LinuxPort/nativeSources/cn1_linux_image.c
+++ b/Ports/LinuxPort/nativeSources/cn1_linux_image.c
@@ -34,8 +34,15 @@
  */
 
 #include "cn1_linux_gfx.h"
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
+#ifdef __GLIBC__
+#include <malloc.h>
+#endif
 
 extern const char* stringToUTF8(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT str);
 extern JAVA_OBJECT allocArray(CODENAME_ONE_THREAD_STATE, int length, struct clazz* type, int primitiveSize, int dim);
@@ -44,11 +51,61 @@ int cn1LinuxSurfaceToPng(cairo_surface_t* surface, unsigned char** outData, int*
 
 #define CN1I(p) ((CN1Image*) (intptr_t) (p))
 
+/*
+ * How many images are alive and how many bytes their surfaces hold. An image is
+ * made on whatever thread asks for one and destroyed on the drawing thread, hence
+ * atomics. The numbers answer the question a resident-set figure cannot: whether
+ * memory is in pictures the port still holds, or somewhere else.
+ *
+ * CN1_LOG_IMAGES in the environment prints them to stderr, at most every 50 ms,
+ * as "[IMAGES] live=<count> bytes=<bytes> made=<count> freed=<count>" -- the same
+ * kind of switch as the collector's CN1_GC_LOG_CYCLES, and like it one cached
+ * getenv when it is off.
+ */
+static _Atomic long cn1ImagesLive = 0;
+static _Atomic long cn1ImageBytesLive = 0;
+static _Atomic long cn1ImagesMade = 0;
+static _Atomic long cn1ImagesFreed = 0;
+
+static void cn1LogImages(void) {
+    static _Atomic int logImages = -1;
+    static _Atomic long long lastLogged = 0;
+    struct timespec now;
+    long long millis;
+    int on = atomic_load_explicit(&logImages, memory_order_relaxed);
+    if (on < 0) {
+        on = getenv("CN1_LOG_IMAGES") ? 1 : 0;
+        atomic_store_explicit(&logImages, on, memory_order_relaxed);
+    }
+    if (!on) {
+        return;
+    }
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    millis = (long long) now.tv_sec * 1000 + now.tv_nsec / 1000000;
+    if (millis - atomic_load_explicit(&lastLogged, memory_order_relaxed) < 50) {
+        return;
+    }
+    atomic_store_explicit(&lastLogged, millis, memory_order_relaxed);
+    fprintf(stderr, "[IMAGES] live=%ld bytes=%ld made=%ld freed=%ld\n",
+            atomic_load_explicit(&cn1ImagesLive, memory_order_relaxed),
+            atomic_load_explicit(&cn1ImageBytesLive, memory_order_relaxed),
+            atomic_load_explicit(&cn1ImagesMade, memory_order_relaxed),
+            atomic_load_explicit(&cn1ImagesFreed, memory_order_relaxed));
+}
+
+static long cn1SurfaceBytes(cairo_surface_t* surface) {
+    return (long) cairo_image_surface_get_stride(surface) * cairo_image_surface_get_height(surface);
+}
+
 static CN1Image* cn1WrapSurface(cairo_surface_t* surface) {
     CN1Image* img = (CN1Image*) calloc(1, sizeof(CN1Image));
     img->surface = surface;
     img->width = cairo_image_surface_get_width(surface);
     img->height = cairo_image_surface_get_height(surface);
+    atomic_fetch_add_explicit(&cn1ImagesLive, 1, memory_order_relaxed);
+    atomic_fetch_add_explicit(&cn1ImageBytesLive, cn1SurfaceBytes(surface), memory_order_relaxed);
+    atomic_fetch_add_explicit(&cn1ImagesMade, 1, memory_order_relaxed);
+    cn1LogImages();
     return img;
 }
 
@@ -127,6 +184,10 @@ JAVA_LONG com_codename1_impl_linux_LinuxNative_createImageFromBytes___byte_1ARRA
     if (data == JAVA_NULL || length <= 0) {
         return 0;
     }
+    /* Never read outside the array, whatever the caller passed. */
+    if (offset < 0 || length > ((JAVA_ARRAY) data)->length - offset) {
+        return 0;
+    }
     bytes = (unsigned char*) CN1_ARRAY_DATA(data);
     stream = g_memory_input_stream_new_from_data(bytes + offset, length, 0);
     pix = gdk_pixbuf_new_from_stream(stream, 0, 0);
@@ -235,6 +296,98 @@ JAVA_LONG com_codename1_impl_linux_LinuxNative_getImageGraphics___long_R_long(CO
     return (JAVA_LONG) (intptr_t) g;
 }
 
+/*
+ * Disposal.
+ *
+ * An image handle's finalizer runs on the collector's thread while the event
+ * dispatch thread may be inside cairo with the very surface, so the finalizer only
+ * queues the pointer (releaseImage) and the drawing thread frees what is queued
+ * between frames (nextReleasedImage / disposeImage). Until these existed nothing
+ * in the port destroyed an image surface at all.
+ */
+/*
+ * Freeing is not giving back. glibc keeps what free() hands it for the next
+ * malloc, and a surface is 1.9 MB at 800x600 -- below the size it maps on its
+ * own once the threshold has adapted, so the pages stay in the process. An
+ * application that draws a picture per frame freed every one of them and was
+ * still measured at 340 MB resident with 58 MB in use; malloc_trim(0) took it to
+ * 188 MB. The pages are returned once this many bytes of surfaces were freed
+ * since the last time, which is about once per collection. Other C libraries
+ * have no such call and keep their own counsel.
+ */
+#define CN1_TRIM_AFTER_BYTES (32L * 1024 * 1024)
+static long cn1FreedSinceTrim = 0;
+
+static pthread_mutex_t cn1ReleasedLock = PTHREAD_MUTEX_INITIALIZER;
+static CN1Image** cn1Released = 0;
+static int cn1ReleasedCount = 0;
+static int cn1ReleasedCapacity = 0;
+
+JAVA_VOID com_codename1_impl_linux_LinuxNative_releaseImage___long(CODENAME_ONE_THREAD_STATE, JAVA_LONG image) {
+    CN1Image* img = CN1I(image);
+    if (!img) {
+        return;
+    }
+    pthread_mutex_lock(&cn1ReleasedLock);
+    if (cn1ReleasedCount == cn1ReleasedCapacity) {
+        int capacity = cn1ReleasedCapacity == 0 ? 64 : cn1ReleasedCapacity * 2;
+        CN1Image** grown = (CN1Image**) realloc(cn1Released, sizeof(CN1Image*) * (size_t) capacity);
+        if (grown == 0) {
+            /* Out of memory for the queue itself: the image stays allocated, which
+             * is what happened to every image before this queue existed. */
+            pthread_mutex_unlock(&cn1ReleasedLock);
+            return;
+        }
+        cn1Released = grown;
+        cn1ReleasedCapacity = capacity;
+    }
+    cn1Released[cn1ReleasedCount++] = img;
+    pthread_mutex_unlock(&cn1ReleasedLock);
+}
+
+JAVA_LONG com_codename1_impl_linux_LinuxNative_nextReleasedImage___R_long(CODENAME_ONE_THREAD_STATE) {
+    CN1Image* img = 0;
+    pthread_mutex_lock(&cn1ReleasedLock);
+    if (cn1ReleasedCount > 0) {
+        img = cn1Released[--cn1ReleasedCount];
+    }
+    pthread_mutex_unlock(&cn1ReleasedLock);
+    return (JAVA_LONG) (intptr_t) img;
+}
+
+JAVA_LONG com_codename1_impl_linux_LinuxNative_disposeImage___long_R_long(CODENAME_ONE_THREAD_STATE, JAVA_LONG image) {
+    CN1Image* img = CN1I(image);
+    CN1Graphics* g;
+    if (!img) {
+        return 0;
+    }
+    g = img->mutableGraphics;
+    if (g != 0) {
+        if (g->cr != 0) {
+            cairo_destroy(g->cr);
+        }
+        cn1LinuxFreeClipShape(g);
+        free(g);
+    }
+    if (img->surface != 0) {
+        long bytes = cn1SurfaceBytes(img->surface);
+        cn1FreedSinceTrim += bytes;
+        atomic_fetch_sub_explicit(&cn1ImageBytesLive, bytes, memory_order_relaxed);
+        cairo_surface_destroy(img->surface);
+    }
+    free(img);
+    atomic_fetch_sub_explicit(&cn1ImagesLive, 1, memory_order_relaxed);
+    atomic_fetch_add_explicit(&cn1ImagesFreed, 1, memory_order_relaxed);
+    cn1LogImages();
+#ifdef __GLIBC__
+    if (cn1FreedSinceTrim >= CN1_TRIM_AFTER_BYTES) {
+        cn1FreedSinceTrim = 0;
+        malloc_trim(0);
+    }
+#endif
+    return (JAVA_LONG) (intptr_t) g;
+}
+
 /* drawImage / drawImageScaled live here (image ownership unit). They blit the
  * CN1Image surface onto the target graphics honouring its clip, affine and
  * alpha. */
diff --git a/Ports/LinuxPort/nativeSources/cn1_linux_io.c b/Ports/LinuxPort/nativeSources/cn1_linux_io.c
index e703ba70f8b..4a0ea775634 100644
--- a/Ports/LinuxPort/nativeSources/cn1_linux_io.c
+++ b/Ports/LinuxPort/nativeSources/cn1_linux_io.c
@@ -467,6 +467,32 @@ JAVA_OBJECT com_codename1_impl_linux_LinuxNative_storageDir___R_java_lang_String
     return newStringFromCString(threadStateData, cn1StorageDir());
 }
 
+/*
+ * A moment written the way the user's locale writes a date (what == 0, strftime's %x)
+ * or a time of day (what == 1, %X), in the local time zone. An empty string when the
+ * moment cannot be broken down.
+ *
+ * The locale is the one GTK selected from the environment when it started
+ * (setlocale(LC_ALL, "")), so LC_TIME decides: 02/29/2024 for en_US, 29.02.2024 for
+ * de_DE, 02/29/24 with no locale set at all.
+ */
+JAVA_OBJECT com_codename1_impl_linux_LinuxNative_formatLocalTime___long_int_R_java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_LONG millis, JAVA_INT what) {
+    char buf[256];
+    struct tm parts;
+    time_t seconds = (time_t) (millis / 1000);
+    if (millis < 0 && millis % 1000 != 0) {
+        /* Division truncates towards zero; a moment before 1970 belongs to the second below. */
+        seconds--;
+    }
+    buf[0] = 0;
+    if (localtime_r(&seconds, &parts) != 0) {
+        if (strftime(buf, sizeof(buf), what == 1 ? "%X" : "%x", &parts) == 0) {
+            buf[0] = 0;
+        }
+    }
+    return newStringFromCString(threadStateData, buf);
+}
+
 JAVA_OBJECT com_codename1_impl_linux_LinuxNative_executableDir___R_java_lang_String(CODENAME_ONE_THREAD_STATE) {
     char buf[4096];
     ssize_t n = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
diff --git a/Ports/LinuxPort/nativeSources/cn1_linux_text.c b/Ports/LinuxPort/nativeSources/cn1_linux_text.c
index 1817e317cd9..cdd0629dd58 100644
--- a/Ports/LinuxPort/nativeSources/cn1_linux_text.c
+++ b/Ports/LinuxPort/nativeSources/cn1_linux_text.c
@@ -86,11 +86,66 @@ static CN1Font* cn1MakeFont(const char* family, int weight, int italic, int pixe
     pango_font_description_set_weight(f->desc, weight);
     pango_font_description_set_style(f->desc, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
     pango_font_description_set_absolute_size(f->desc, pixelSize * PANGO_SCALE);
+    /*
+     * A weight under regular is kept only when the family has a face near it.
+     * Pango answers with the nearest face it has, and for a family with no Light
+     * that is its ExtraLight when it has one (DejaVu Sans does): the titles and
+     * buttons a theme styles with native:MainLight came out as hairlines that read
+     * as disabled. Regular is what the other ports fall back to.
+     */
+    if (weight < PANGO_WEIGHT_NORMAL) {
+        PangoFont* loaded = pango_context_load_font(cn1LinuxPangoContext(), f->desc);
+        int near = 0;
+        if (loaded != 0) {
+            PangoFontDescription* actual = pango_font_describe(loaded);
+            if (actual != 0) {
+                int delta = (int) pango_font_description_get_weight(actual) - weight;
+                near = delta > -75 && delta < 75;
+                pango_font_description_free(actual);
+            }
+            g_object_unref(loaded);
+        }
+        if (!near) {
+            pango_font_description_set_weight(f->desc, PANGO_WEIGHT_NORMAL);
+        }
+    }
     f->pixelSize = pixelSize;
     cn1FontMetrics(f);
     return f;
 }
 
+/*
+ * The weight and the slant a "native:" face asks for. The names are Codename One's:
+ * Main or Italic, then Thin, Light, Regular, Bold or Black ("native:ItalicBold").
+ *
+ * Every one of them used to load as the regular upright face: the name was reduced
+ * to the family and the rest of it dropped. A label a theme styles with
+ * native:MainBold drew like the text around it, and text an application asked for
+ * in bold or italic -- which the Swing and JavaFX layers ask for under these names
+ * -- was neither. deriveTrueTypeFont copies the description it is handed, so a font
+ * derived from one of these keeps what is set here.
+ */
+static void cn1NativeFace(const char* face, int* weight, int* italic) {
+    const char* rest = face;
+    *weight = PANGO_WEIGHT_NORMAL;
+    *italic = 0;
+    if (strncmp(face, "Italic", 6) == 0) {
+        *italic = 1;
+        rest = face + 6;
+    } else if (strncmp(face, "Main", 4) == 0) {
+        rest = face + 4;
+    }
+    if (strcmp(rest, "Thin") == 0) {
+        *weight = PANGO_WEIGHT_THIN;
+    } else if (strcmp(rest, "Light") == 0) {
+        *weight = PANGO_WEIGHT_LIGHT;
+    } else if (strcmp(rest, "Bold") == 0) {
+        *weight = PANGO_WEIGHT_BOLD;
+    } else if (strcmp(rest, "Black") == 0) {
+        *weight = PANGO_WEIGHT_HEAVY;
+    }
+}
+
 JAVA_LONG com_codename1_impl_linux_LinuxNative_createFont___int_int_int_R_long(CODENAME_ONE_THREAD_STATE, JAVA_INT face, JAVA_INT style, JAVA_INT size) {
     const char* family = "Sans";
     int pixelSize = 18;
@@ -237,12 +292,15 @@ JAVA_INT com_codename1_impl_linux_LinuxNative_fontHeight___long_R_int(CODENAME_O
 JAVA_LONG com_codename1_impl_linux_LinuxNative_loadTrueTypeFont___java_lang_String_java_lang_String_R_long(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT fontName, JAVA_OBJECT fileName) {
     const char* name = fontName == JAVA_NULL ? "Sans" : stringToUTF8(threadStateData, fontName);
     const char* family = name;
+    int weight = PANGO_WEIGHT_NORMAL;
+    int italic = 0;
     (void) fileName;
-    /* "native:" scheme maps to the system UI family. */
+    /* "native:" scheme maps to the system UI family, in the weight and slant the name asks for. */
     if (strncmp(name, "native:", 7) == 0) {
+        cn1NativeFace(name + 7, &weight, &italic);
         family = "Sans";
     }
-    return (JAVA_LONG) (intptr_t) cn1MakeFont(family, PANGO_WEIGHT_NORMAL, 0, 18);
+    return (JAVA_LONG) (intptr_t) cn1MakeFont(family, weight, italic, 18);
 }
 
 JAVA_LONG com_codename1_impl_linux_LinuxNative_loadTrueTypeFontFromMemory___java_lang_String_byte_1ARRAY_R_long(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT fontName, JAVA_OBJECT data) {
@@ -260,10 +318,13 @@ JAVA_LONG com_codename1_impl_linux_LinuxNative_loadTrueTypeFontFromMemory___java
     FT_Face face = 0;
     family[0] = 0;
     if (data == JAVA_NULL || (len = (int) (*(JAVA_ARRAY) data).length) <= 0) {
+        int weight = PANGO_WEIGHT_NORMAL;
+        int italic = 0;
         if (strncmp(name, "native:", 7) == 0) {
+            cn1NativeFace(name + 7, &weight, &italic);
             name = "Sans";
         }
-        return (JAVA_LONG) (intptr_t) cn1MakeFont(name, PANGO_WEIGHT_NORMAL, 0, 18);
+        return (JAVA_LONG) (intptr_t) cn1MakeFont(name, weight, italic, 18);
     }
     bytes = (unsigned char*) CN1_ARRAY_DATA(data);
 
diff --git a/Ports/LinuxPort/nativeSources/cn1_linux_window.c b/Ports/LinuxPort/nativeSources/cn1_linux_window.c
index 6c1a7283e7e..b27dfd1bb1d 100644
--- a/Ports/LinuxPort/nativeSources/cn1_linux_window.c
+++ b/Ports/LinuxPort/nativeSources/cn1_linux_window.c
@@ -711,7 +711,13 @@ static gboolean cn1OnKey(GtkWidget* widget, GdkEventKey* e, gpointer data) {
      * is torn down GTK clears the toplevel focus to NULL, so CN1 keys resume. */
     if (cn1Window != 0) {
         GtkWidget* focus = gtk_window_get_focus(GTK_WINDOW(cn1Window));
-        if (focus != 0 && focus != cn1DrawingArea && focus != cn1TitleCanvas) {
+        /* The accessibility mirror is not a peer. Its widgets describe Codename One
+         * components to an assistive technology and have no way to hand text back,
+         * so a keystroke that arrives while one of them holds the GTK focus is still
+         * Codename One's. Forwarding it typed into an entry drawn at 1% opacity:
+         * the text went nowhere the user could see. */
+        if (focus != 0 && focus != cn1DrawingArea && focus != cn1TitleCanvas
+                && !(cn1AccessibilityFixed != 0 && gtk_widget_is_ancestor(focus, cn1AccessibilityFixed))) {
             return FALSE;
         }
     }
@@ -1731,9 +1737,45 @@ JAVA_VOID com_codename1_impl_linux_LinuxNative_accessibilityAction___long_java_l
     cn1LinuxRunOnMainAndWait(cn1A11yActionMain, action);
 }
 
+/* Takes a window and everything under it out of pointer delivery.
+ *
+ * The mirror is made of real GTK widgets -- entries, toggle buttons, scales -- laid
+ * exactly over the Codename One components they describe, and each of them owns
+ * GdkWindows that take pointer input. gtk_overlay_set_overlay_pass_through only
+ * covers the overlay child's own window: GDK says in so many words that a
+ * pass-through window "can still have a subwindow without pass through". So a
+ * click on a text field landed on the invisible GtkEntry above it, which took the
+ * GTK focus, and everything typed afterwards went into that entry instead of the
+ * application. An assistive technology drives these widgets through ATK actions,
+ * never through the pointer, so nothing is lost by letting the pointer through. */
+static void cn1A11yPassPointerThrough(GdkWindow* window) {
+    GList* item;
+    if (window == 0) {
+        return;
+    }
+    gdk_window_set_pass_through(window, TRUE);
+    for (item = gdk_window_peek_children(window); item; item = item->next) {
+        cn1A11yPassPointerThrough((GdkWindow*) item->data);
+    }
+}
+
 static void cn1A11yEndMain(void* pointer) {
     (void) pointer;
-    if (cn1AccessibilityFixed) gtk_widget_show_all(cn1AccessibilityFixed);
+    if (cn1AccessibilityFixed) {
+        gtk_widget_show_all(cn1AccessibilityFixed);
+        if (gtk_widget_get_realized(cn1AccessibilityFixed)) {
+            /* A GtkFixed has no window of its own: this is the child window the
+             * overlay made for it, and the mirror's windows are all below it. */
+            GdkWindow* mirror = gtk_widget_get_window(cn1AccessibilityFixed);
+            /* Never the window the drawing area lives in: passing THAT through
+             * would take the pointer away from the whole application. */
+            if (mirror != 0 && mirror != gtk_widget_get_window(cn1Overlay)
+                    && mirror != gtk_widget_get_window(cn1DrawingArea)
+                    && mirror != gtk_widget_get_window(cn1Window)) {
+                cn1A11yPassPointerThrough(mirror);
+            }
+        }
+    }
 }
 
 JAVA_VOID com_codename1_impl_linux_LinuxNative_accessibilityEnd___int(CODENAME_ONE_THREAD_STATE, JAVA_INT changeType) {
diff --git a/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxImplementation.java b/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxImplementation.java
index 04f40467d12..b483bad9063 100644
--- a/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxImplementation.java
+++ b/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxImplementation.java
@@ -53,6 +53,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Native Linux (GTK3, desktop) implementation of the Codename One platform
@@ -81,6 +82,9 @@ public class LinuxImplementation extends CodenameOneImplementation {
     /// editor and browser hosts. Matches CN1_MAIN_WINDOW_SLOT in cn1_linux_gfx.h.
     static final int MAIN_WINDOW_SLOT = -1;
 
+    /// The key code of Tab, the one `Form` moves the focus on.
+    private static final int KEY_CODE_TAB = 9;
+
 
     @Override
     public boolean isHighContrastEnabled() {
@@ -180,7 +184,109 @@ public static LinuxImplementation getInstance() {
     /* -------------------------------------------------------------- helpers */
 
     private static long peer(Object o) {
-        return o == null ? 0L : ((Long) o).longValue();
+        if (o instanceof Long) {
+            return ((Long) o).longValue();
+        }
+        if (o instanceof NativeImage) {
+            return ((NativeImage) o).peer;
+        }
+        if (o instanceof ImageGraphics) {
+            return ((ImageGraphics) o).peer;
+        }
+        return 0L;
+    }
+
+    /// The native half of an image: a Cairo surface, and the graphics context drawing
+    /// into it once one was asked for.
+    ///
+    /// An image used to be a boxed pointer, and nothing ever gave the surface back:
+    /// there was no native to do it. An application that made a picture per frame --
+    /// 800x600 is 1.9 MB -- grew by that much per frame for as long as it ran, with
+    /// the collector reclaiming every Java object on schedule. The handle is what
+    /// tells the port the image is gone.
+    ///
+    /// `finalize` runs on the collector's thread, where a surface the event dispatch
+    /// thread may be part way through blitting must not be destroyed. It only queues
+    /// the pointer; `#disposeReleasedImages()` frees it between frames.
+    static final class NativeImage {
+        final long peer;
+
+        NativeImage(long peer) {
+            this.peer = peer;
+        }
+
+        @Override
+        protected void finalize() {
+            if (peer != 0) {
+                LinuxNative.releaseImage(peer);
+            }
+        }
+    }
+
+    /// The graphics of a mutable image. It keeps the image: the context draws into
+    /// the image's surface and is freed with it, so the image must outlive every
+    /// graphics object still drawing there.
+    static final class ImageGraphics {
+        final long peer;
+        final Object image;
+
+        ImageGraphics(long peer, Object image) {
+            this.peer = peer;
+            this.image = image;
+        }
+    }
+
+    /// Surface bytes handed out since a collection was last asked for. A surface is
+    /// invisible to the collector -- the Java side of a 2 MB picture is 16 bytes --
+    /// so a program can allocate images for a long time without the heap ever
+    /// reaching the size that starts a cycle. Plain, not atomic: a lost update only
+    /// postpones the request by one image.
+    private static long imageBytesSinceGc;
+
+    private static final long IMAGE_BYTES_PER_GC = 32L * 1024 * 1024;
+
+    /// When an image was last made, and how long none must have been made before
+    /// an idle event dispatch thread asks for the collection that the count above
+    /// did not reach. An application that draws a picture per frame and then stops
+    /// leaves the images of its last frames behind, short of the count for good:
+    /// nothing allocates any more, so nothing ever starts a cycle. While images
+    /// are still being made the count is what asks.
+    private static long lastImageMillis;
+
+    private static final long IMAGE_QUIET_MILLIS = 500;
+
+    static Object wrapImage(long peer, int width, int height) {
+        if (peer != 0) {
+            if (width <= 0 || height <= 0) {
+                width = LinuxNative.imageWidth(peer);
+                height = LinuxNative.imageHeight(peer);
+            }
+            imageBytesSinceGc += 4L * width * height;
+            lastImageMillis = System.currentTimeMillis();
+            if (imageBytesSinceGc > IMAGE_BYTES_PER_GC) {
+                imageBytesSinceGc = 0;
+                System.gc();
+            }
+        }
+        return new NativeImage(peer);
+    }
+
+    /// Frees the images whose handles the collector finalized. Event dispatch thread
+    /// only, between frames: it is the one moment no native draw can be holding one.
+    /// The graphics context freed with an image takes its entries in the transform
+    /// and clip-stack tables with it; a context allocated later at the same address
+    /// would otherwise start life under a dead image's transform.
+    private void disposeReleasedImages() {
+        long image = LinuxNative.nextReleasedImage();
+        while (image != 0) {
+            long graphics = LinuxNative.disposeImage(image);
+            if (graphics != 0) {
+                Long key = Long.valueOf(graphics);
+                graphicsTransforms.remove(key);
+                clipStacks.remove(key);
+            }
+            image = LinuxNative.nextReleasedImage();
+        }
     }
 
     private String storagePath(String name) {
@@ -221,6 +327,9 @@ private static byte[] readFully(InputStream i) throws IOException {
 
     @Override
     public void init(Object m) {
+        // The class library (vm/JavaAPI) reaches files, preferences, the
+        // network and the EDT through Codename One from here on.
+        com.codename1.impl.CoreJdkHostInstaller.install();
         LinuxNative.initDisplay("Codename One", 800, 600);
         windowGraphicsPeer = LinuxNative.getWindowGraphics();
         windowGraphics = Long.valueOf(windowGraphicsPeer);
@@ -645,8 +754,64 @@ public int getDisplayHeight() {
         return LinuxNative.getDisplayHeight();
     }
 
+    /// Resizes the application window. The size is the outer one, frame included,
+    /// as on the JavaSE port; the display follows through the size-changed event
+    /// the window's new allocation produces, so nothing is laid out here.
+    ///
+    /// The window still OPENS at 800x600: it exists before any application code
+    /// runs, and that default is what every screenshot baseline was taken at.
+    @Override
+    public void setWindowSize(int width, int height) {
+        if (width > 0 && height > 0) {
+            LinuxNative.mainWindowSetSize(width, height);
+        }
+    }
+
+    @Override
+    public com.codename1.ui.geom.Rectangle getWindowBounds() {
+        int[] frame = new int[4];
+        if (!LinuxNative.mainWindowGetFrame(frame)) {
+            return super.getWindowBounds();
+        }
+        return new com.codename1.ui.geom.Rectangle(frame[0], frame[1], frame[2], frame[3]);
+    }
+
+    /// The monitor the application window is on, which is the desktop a
+    /// percentage of it is taken from.
+    @Override
+    public com.codename1.ui.geom.Dimension getDesktopSize() {
+        int[] bounds = new int[4];
+        if (!LinuxNative.mainWindowGetFrame(bounds)) {
+            return super.getDesktopSize();
+        }
+        LinuxNative.monitorBounds(LinuxNative.monitorForMainWindow(), false, bounds);
+        if (bounds[2] <= 0 || bounds[3] <= 0) {
+            return super.getDesktopSize();
+        }
+        return new com.codename1.ui.geom.Dimension(bounds[2], bounds[3]);
+    }
+
+    /// The hint is a size for the window the first form opens in. Here that window
+    /// already exists, so the hint is applied as it arrives and consumed, the way
+    /// the JavaSE port consumes it when it builds its frame.
+    @Override
+    public void setInitialWindowSizeHintPercent(com.codename1.ui.geom.Dimension hint) {
+        super.setInitialWindowSizeHintPercent(hint);
+        com.codename1.ui.geom.Dimension desktop = hint == null ? null : getDesktopSize();
+        if (desktop == null) {
+            return;
+        }
+        int width = Math.min(desktop.getWidth(),
+                Math.max(1, Math.round(desktop.getWidth() * (hint.getWidth() / 100f))));
+        int height = Math.min(desktop.getHeight(),
+                Math.max(1, Math.round(desktop.getHeight() * (hint.getHeight() / 100f))));
+        super.setInitialWindowSizeHintPercent(null);
+        setWindowSize(width, height);
+    }
+
     @Override
     public void flushGraphics() {
+        disposeReleasedImages();
         LinuxNative.flushGraphics(windowGraphicsPeer, 0, 0, getDisplayWidth(), getDisplayHeight());
     }
 
@@ -721,6 +886,8 @@ public void run() {
 
     @Override
     public void flushGraphics(int x, int y, int width, int height) {
+        // Most frames repaint a part of the window and come through here.
+        disposeReleasedImages();
         LinuxNative.flushGraphics(windowGraphicsPeer, x, y, width, height);
     }
 
@@ -764,11 +931,85 @@ public void screenshot(com.codename1.util.SuccessCallback<Image> callback) {
 
     @Override
     public void edtIdle(boolean enter) {
-        // Intentionally empty: the Win32 message pump and input dispatch run on the
+        // No pumping here: the message pump and input dispatch run on the
         // main thread (see runMainEventLoop), and the EDT is woken by the Display
         // lock notifications those dispatches trigger. The EDT therefore idles by
         // sleeping on the lock like every other Codename One platform -- it must
         // not pump or drain on its own (it is not the window's owning thread).
+        //
+        // What it does do on its way to sleep is free the images the collector
+        // let go of. A frame frees them too, but an application that computed a
+        // picture and then sat still painted no further frame: the images of
+        // its last collection stayed queued, 70 to 200 MB of them in one
+        // measured run, for as long as nothing was repainted.
+        if (enter) {
+            disposeReleasedImages();
+            if (imageBytesSinceGc > 0) {
+                long quiet = System.currentTimeMillis() - lastImageMillis;
+                if (quiet > IMAGE_QUIET_MILLIS) {
+                    // See lastImageMillis. Nothing is counted until an image is made.
+                    imageBytesSinceGc = 0;
+                    System.gc();
+                    releaseWakes = 2;
+                    wakeEdtIn(IMAGE_RELEASE_MILLIS);
+                } else {
+                    // Too soon to call it quiet, and this thread may not wake again
+                    // on its own: an application that stops moving stops for good.
+                    wakeEdtIn(IMAGE_QUIET_MILLIS - quiet + 1);
+                }
+            } else if (releaseWakes > 0) {
+                releaseWakes--;
+                if (releaseWakes > 0) {
+                    wakeEdtIn(4 * IMAGE_RELEASE_MILLIS);
+                }
+            }
+        }
+    }
+
+    /// How long after asking for the quiet collection this thread comes back to free
+    /// what it let go of, and how many times it still will: once soon, once later for
+    /// a cycle that took its time.
+    private static final long IMAGE_RELEASE_MILLIS = 250;
+
+    private int releaseWakes;
+
+    private static final AtomicBoolean WAKE_PENDING = new AtomicBoolean();
+
+    private static final Runnable NOTHING = new Runnable() {
+        @Override
+        public void run() {
+        }
+    };
+
+    /// Has the event dispatch thread pass through `edtIdle` once more, some time
+    /// from now. The quiet collection above is asked for by a thread on its way to
+    /// sleep, and the collector answers on its own thread a moment later: the images
+    /// it released sat in the queue until the next frame, which a still application
+    /// never paints. A Mandelbrot picture that had finished rendering held 115
+    /// surfaces, 220 MB, for as long as nobody touched the window; and when the
+    /// thread went to sleep less than `IMAGE_QUIET_MILLIS` after the last image,
+    /// the collection was never asked for at all.
+    ///
+    /// One wake-up is pending at a time, hence the atomic: the timer thread clears
+    /// it and this thread sets it.
+    private static void wakeEdtIn(final long millis) {
+        if (!WAKE_PENDING.compareAndSet(false, true)) {
+            return;
+        }
+        Thread t = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(millis);
+                } catch (InterruptedException ex) {
+                    // Woken early is still woken: the pass it asks for is harmless.
+                }
+                WAKE_PENDING.set(false);
+                Display.getInstance().callSerially(NOTHING);
+            }
+        }, "cn1-linux-image-release");
+        t.setDaemon(true);
+        t.start();
     }
 
     // High bits in the native key flag touch, pen, or eraser input (see cn1_linux.h);
@@ -882,10 +1123,10 @@ private void drainInput() {
                     dispatchPointerHover(windowId, x, y, key);
                     break;
                 case EVENT_KEY_PRESSED:
-                    windowKeyPressed(windowId, key);
+                    windowKeyPressed(windowId, keyCodeOf(key));
                     break;
                 case EVENT_KEY_RELEASED:
-                    windowKeyReleased(windowId, key);
+                    windowKeyReleased(windowId, keyCodeOf(key));
                     break;
                 case EVENT_SIZE_CHANGED:
                     if (windowId == 0) {
@@ -1185,7 +1426,7 @@ public Object getNativeGraphics() {
 
     @Override
     public Object getNativeGraphics(Object image) {
-        return Long.valueOf(LinuxNative.getImageGraphics(peer(image)));
+        return new ImageGraphics(LinuxNative.getImageGraphics(peer(image)), image);
     }
 
     /* ------------------------------------------------------------- transforms
@@ -1931,6 +2172,25 @@ public void drawImage(Object graphics, Object img, int x, int y) {
         LinuxNative.drawImage(peer(graphics), peer(img), x, y);
     }
 
+    /// Cairo scales an image as it draws it, and `drawImageScaled` has done so
+    /// since the port was written -- but nothing called it. Without this answer the
+    /// core scales for the port: `Image.scaled` makes a second surface of the size
+    /// asked for and keeps it in the image's scale cache for as long as the image
+    /// lives, one per size. An application that zooms a picture draws it at a new
+    /// size every frame, so every frame left a surface behind, each larger than the
+    /// last: a JavaFX canvas zooming an 800x600 snapshot was measured holding 156
+    /// surfaces, 1.8 GB, by the end of a one second animation, none of them garbage
+    /// until the snapshot itself was replaced.
+    @Override
+    public boolean isScaledImageDrawingSupported() {
+        return true;
+    }
+
+    @Override
+    public void drawImage(Object graphics, Object img, int x, int y, int w, int h) {
+        LinuxNative.drawImageScaled(peer(graphics), peer(img), x, y, w, h);
+    }
+
     @Override
     public void drawRGB(Object graphics, int[] rgbData, int offset, int x, int y, int w, int h, boolean processAlpha) {
         LinuxNative.drawRGB(peer(graphics), rgbData, offset, x, y, w, h, processAlpha);
@@ -2049,28 +2309,34 @@ public Object deriveTrueTypeFont(Object font, float size, int weight) {
 
     @Override
     public Object createImage(int[] rgb, int width, int height) {
-        return Long.valueOf(LinuxNative.createImageFromARGB(rgb, width, height));
+        return wrapImage(LinuxNative.createImageFromARGB(rgb, width, height), width, height);
     }
 
     @Override
     public Object createImage(String path) throws IOException {
-        return Long.valueOf(LinuxNative.createImageFromFile(stripFileUrl(path)));
+        return wrapImage(LinuxNative.createImageFromFile(stripFileUrl(path)), 0, 0);
     }
 
     @Override
     public Object createImage(InputStream i) throws IOException {
         byte[] data = readFully(i);
-        return Long.valueOf(LinuxNative.createImageFromBytes(data, 0, data.length));
+        return wrapImage(LinuxNative.createImageFromBytes(data, 0, data.length), 0, 0);
     }
 
     @Override
     public Object createImage(byte[] bytes, int offset, int len) {
-        return Long.valueOf(LinuxNative.createImageFromBytes(bytes, offset, len));
+        // The native decoder reads the range as it is given; a range past
+        // the array is refused here, as Java would, before it is read.
+        if (bytes != null && (offset < 0 || len < 0 || offset > bytes.length - len)) {
+            throw new ArrayIndexOutOfBoundsException("offset " + offset + ", length " + len
+                    + ", array " + bytes.length);
+        }
+        return wrapImage(LinuxNative.createImageFromBytes(bytes, offset, len), 0, 0);
     }
 
     @Override
     public Object createMutableImage(int width, int height, int fillColor) {
-        return Long.valueOf(LinuxNative.createMutableImage(width, height, fillColor));
+        return wrapImage(LinuxNative.createMutableImage(width, height, fillColor), width, height);
     }
 
     @Override
@@ -2085,7 +2351,7 @@ public int getImageHeight(Object i) {
 
     @Override
     public Object scale(Object nativeImage, int width, int height) {
-        return Long.valueOf(LinuxNative.scaleImage(peer(nativeImage), width, height));
+        return wrapImage(LinuxNative.scaleImage(peer(nativeImage), width, height), width, height);
     }
 
     @Override
@@ -2163,6 +2429,14 @@ public void editString(final Component cmp, int maxSize, int constraint, String
         // The editor goes into the overlay of the window the field lives in; without
         // the slot it appeared over the main window while the window being typed into
         // showed nothing.
+        // The key that started the edit is part of what was typed. The editor
+        // opens after it was pressed and never sees it, so it is added here;
+        // without it the first character typed into a field was lost.
+        if (initiatingKeycode >= ' ' && initiatingKeycode != 127 && initiatingKeycode <= 0xffff
+                && getGameAction(initiatingKeycode) == 0
+                && (maxSize <= 0 || text == null || text.length() < maxSize)) {
+            text = (text == null ? "" : text) + (char) initiatingKeycode;
+        }
         long peer = LinuxNative.editStringAt(x, y, w, h, text == null ? "" : text,
                 singleLine, maxSize, fontPeer, s.getFgColor(), s.getBgColor(), 0,
                 LinuxWindowManager.slotForComponent(cmp));
@@ -2186,7 +2460,21 @@ public void run() {
                         return;
                     }
                     if (LinuxNative.editIsDone(editPeer)) {
+                        // Tab ended it: the editor kept the key from the form, so
+                        // the form is given it now and moves its focus on. In the
+                        // main window only; a second window keeps what it did.
+                        int tabbed = LinuxNative.editTabbed(editPeer);
+                        boolean tab = tabbed != 0
+                                && LinuxWindowManager.slotForComponent(cmp) == MAIN_WINDOW_SLOT;
                         hideTextEditor();
+                        if (tab) {
+                            // The editor consumed the key, so the direction travels
+                            // with it: 2 is Shift-Tab. See #isShiftKeyDown.
+                            tabDirection = tabbed;
+                            tabDirectionUntil = System.currentTimeMillis() + 1000;
+                            keyPressed(KEY_CODE_TAB);
+                            keyReleased(KEY_CODE_TAB);
+                        }
                         return;
                     }
                     // Mirror the native control's text into the field as the user
@@ -2563,12 +2851,71 @@ public int getBackKeyCode() {
 
     @Override
     public int getGameAction(int keyCode) {
-        return 0;
+        switch (keyCode) {
+            case GAME_KEY_CODE_UP:
+                return Display.GAME_UP;
+            case GAME_KEY_CODE_DOWN:
+                return Display.GAME_DOWN;
+            case GAME_KEY_CODE_LEFT:
+                return Display.GAME_LEFT;
+            case GAME_KEY_CODE_RIGHT:
+                return Display.GAME_RIGHT;
+            default:
+                return 0;
+        }
     }
 
     @Override
     public int getKeyCode(int gameAction) {
-        return 0;
+        switch (gameAction) {
+            case Display.GAME_UP:
+                return GAME_KEY_CODE_UP;
+            case Display.GAME_DOWN:
+                return GAME_KEY_CODE_DOWN;
+            case Display.GAME_LEFT:
+                return GAME_KEY_CODE_LEFT;
+            case Display.GAME_RIGHT:
+                return GAME_KEY_CODE_RIGHT;
+            default:
+                return 0;
+        }
+    }
+
+    // The codes the arrow keys are handed to Codename One as. They are
+    // negative, as on the JavaSE port: a positive code is a character, and
+    // a form, a list and everything else that moves on an arrow asks
+    // getGameAction what a negative one means.
+    private static final int GAME_KEY_CODE_UP = -91;
+    private static final int GAME_KEY_CODE_DOWN = -92;
+    private static final int GAME_KEY_CODE_LEFT = -93;
+    private static final int GAME_KEY_CODE_RIGHT = -94;
+
+    /// The Codename One code of a key the window reported.
+    ///
+    /// The window hands over the character a key types, and for a key
+    /// that types none its GDK key value. The arrows are such keys, and
+    /// their values (0xff51 to 0xff54, and the keypad's 0xff96 to 0xff99)
+    /// were passed on as they came: getGameAction answered 0 for
+    /// everything, so no arrow key did anything in any application -- a
+    /// form did not move its focus, and a game played with the arrows did
+    /// not play -- while a text component read the value as a character.
+    static int keyCodeOf(int key) {
+        switch (key) {
+            case 0xff51:
+            case 0xff96:
+                return GAME_KEY_CODE_LEFT;
+            case 0xff52:
+            case 0xff97:
+                return GAME_KEY_CODE_UP;
+            case 0xff53:
+            case 0xff98:
+                return GAME_KEY_CODE_RIGHT;
+            case 0xff54:
+            case 0xff99:
+                return GAME_KEY_CODE_DOWN;
+            default:
+                return key;
+        }
     }
 
     /* ------------------------------------------------------------ network */
@@ -3289,6 +3636,17 @@ public boolean isDesktop() {
     /// JavaSEPort and the macOS port reported modifier state before this.
     @Override
     public boolean isShiftKeyDown() {
+        if (tabDirection != 0) {
+            // Answered once, for the Tab a native editor ended its edit with: the
+            // form asks this when it handles that key, and by then the modifiers
+            // the window recorded belong to whatever key came last -- a Tab
+            // released after Shift reads as a plain Tab and moved focus forwards.
+            int direction = tabDirection;
+            tabDirection = 0;
+            if (System.currentTimeMillis() <= tabDirectionUntil) {
+                return direction == 2;
+            }
+        }
         return (LinuxNative.currentModifiers() & 1) != 0;
     }
 
@@ -3308,6 +3666,12 @@ public boolean isAltKeyDown() {
         return (LinuxNative.currentModifiers() & 4) != 0;
     }
 
+    /// The direction of the Tab that ended a native edit -- 1 forward, 2 back
+    /// (Shift-Tab), 0 none -- for the one [#isShiftKeyDown] that asks about it,
+    /// and the time past which it is stale. Both on the EDT only.
+    private int tabDirection;
+    private long tabDirectionUntil;
+
     @Override
     public int[] getNativeWindowTitleBarInsets(com.codename1.ui.Component toolbar) {
         if (!(toolbar.getTopLevelContainer() instanceof com.codename1.ui.Form)
@@ -3741,6 +4105,27 @@ public String getLongMonthName(Date date) {
                     }
                     return LONG_MONTHS[m];
                 }
+
+                /*
+                 * The short date and the time of day are the locale's own. The
+                 * base class answers Date.toString() for both, which is neither
+                 * short nor a date alone: a date Picker -- and so a JavaFX
+                 * DatePicker or anything else that shows a day -- read
+                 * "February 29, 2024 12:00:00 PM" where every other port shows
+                 * 2/29/2024. An empty answer means the C library could not
+                 * write the moment, and the old text is better than none.
+                 */
+                @Override
+                public String formatDateShortStyle(Date d) {
+                    String s = LinuxNative.formatLocalTime(d.getTime(), 0);
+                    return s == null || s.length() == 0 ? super.formatDateShortStyle(d) : s;
+                }
+
+                @Override
+                public String formatTime(Date d) {
+                    String s = LinuxNative.formatLocalTime(d.getTime(), 1);
+                    return s == null || s.length() == 0 ? super.formatTime(d) : s;
+                }
             };
         }
         return l10n;
diff --git a/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxNative.java b/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxNative.java
index 361da314a11..a2f56d496c5 100644
--- a/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxNative.java
+++ b/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxNative.java
@@ -241,6 +241,15 @@ public static native int desktopWindowCreate(int windowId, String title, int x,
 
     public static native boolean mainWindowGetBounds(int[] out);
 
+    /// Resizes the application's MAIN window to an outer size, frame included.
+    /// A no-op when headless, where the surface is the size of the screenshot.
+    public static native void mainWindowSetSize(int width, int height);
+
+    /// Fills `out` with the main window's outer rectangle, the one
+    /// `#mainWindowSetSize(int, int)` sets; `#mainWindowGetBounds(int[])` answers
+    /// the client area. False when there is no window.
+    public static native boolean mainWindowGetFrame(int[] out);
+
     public static native int desktopWindowGetWidth(int slot);
 
     public static native int desktopWindowGetHeight(int slot);
@@ -488,6 +497,18 @@ public static native void accessibilityNode(long id, long parentId, String role,
 
     public static native long getImageGraphics(long image);
 
+    /// Queues an image for disposal. Safe from any thread: this is what an image
+    /// handle's finalizer calls, on the collector's thread. Nothing is freed here.
+    public static native void releaseImage(long image);
+
+    /// The next queued image, or 0 when the queue is empty.
+    public static native long nextReleasedImage();
+
+    /// Destroys an image's surface and the graphics context cached for it, and
+    /// returns that context's pointer (0 if it never had one) so the caller can
+    /// forget what it kept under it. Drawing thread only.
+    public static native long disposeImage(long image);
+
     /* ------------------------------------------------------- filesystem */
 
     /**
@@ -517,6 +538,9 @@ public static native long editStringAt(int x, int y, int w, int h, String text,
     /** True once the user has committed the native edit (Enter / focus loss). */
     public static native boolean editIsDone(long peer);
 
+    /** How Tab ended the native edit: 1 forwards, 2 backwards, 0 when it did not. */
+    public static native int editTabbed(long peer);
+
     /** The native EDIT control's current text. */
     public static native String editGetText(long peer);
 
@@ -530,6 +554,13 @@ public static native long editStringAt(int x, int y, int w, int h, String text,
     /** Why the most recent open failed, for the exception the port raises. */
     public static native String lastIoError();
 
+    /**
+     * A moment as the user's locale writes a date ({@code what == 0}) or a time
+     * of day ({@code what == 1}), in the local time zone; empty when it cannot
+     * be written.
+     */
+    public static native String formatLocalTime(long millis, int what);
+
     /* ---------------------------------------------------------- crypto */
 
     /** Fills {@code out} with fresh entropy; false when the platform RNG failed. */
diff --git a/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxWindowManager.java b/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxWindowManager.java
index 14468e52ca2..8864a9477d2 100644
--- a/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxWindowManager.java
+++ b/Ports/LinuxPort/src/com/codename1/impl/linux/LinuxWindowManager.java
@@ -463,7 +463,7 @@ public Object capture(Object peer) {
         if (img == 0) {
             return null;
         }
-        return Long.valueOf(img);
+        return LinuxImplementation.wrapImage(img, 0, 0);
     }
 
     @Override
diff --git a/Ports/WindowsPort/nativeSources/cn1_windows.h b/Ports/WindowsPort/nativeSources/cn1_windows.h
index 90216898f93..1050d7a39d8 100644
--- a/Ports/WindowsPort/nativeSources/cn1_windows.h
+++ b/Ports/WindowsPort/nativeSources/cn1_windows.h
@@ -179,6 +179,13 @@ typedef struct CN1Graphics {
     JAVA_BOOLEAN clipIsRect;
     void* clipGeom;                  /* ID2D1PathGeometry* when clip is a shape, else NULL */
     void* clipLayer;                 /* ID2D1Layer* pushed for a shape clip, else NULL     */
+    JAVA_BOOLEAN clipGeomHasRect;    /* a clipRect narrowed the shape clip: clipX/Y/W/H is
+                                      * then a rectangle the shape is ALSO cut to. False
+                                      * right after setClipShape, when clipX/Y/W/H is still
+                                      * the rectangle that was the clip before the shape
+                                      * and is not part of the clip at all */
+    JAVA_BOOLEAN clipRectPushed;     /* that rectangle was pushed under the shape's layer
+                                      * and cn1WinPopClip has to pop it as well */
     D2D1_MATRIX_3X2_F clipMaskTransform; /* world transform captured at setClipShape time;
                                       * applied to the (raw) clip geometry as the layer
                                       * maskTransform so a shape clip lands exactly where
diff --git a/Ports/WindowsPort/nativeSources/cn1_windows_graphics.cpp b/Ports/WindowsPort/nativeSources/cn1_windows_graphics.cpp
index 3c610c22797..b9569326b8f 100644
--- a/Ports/WindowsPort/nativeSources/cn1_windows_graphics.cpp
+++ b/Ports/WindowsPort/nativeSources/cn1_windows_graphics.cpp
@@ -84,6 +84,8 @@ CN1Graphics* cn1WinCreateGraphics(ID2D1RenderTarget* target) {
     g->clipIsRect = JAVA_TRUE;
     g->clipGeom = NULL;
     g->clipLayer = NULL;
+    g->clipGeomHasRect = JAVA_FALSE;
+    g->clipRectPushed = JAVA_FALSE;
     g->clipMaskTransform = D2D1::Matrix3x2F::Identity();
     g->font = cn1Win.defaultFont;
     g->inFrame = JAVA_FALSE;
@@ -179,6 +181,22 @@ extern "C" void cn1WinPushClip(CN1Graphics* g) {
      * the fill) -- so the clip stays fixed while the fill transforms within it. */
     if (!g->clipIsRect && g->clipGeom != NULL) {
         ID2D1Layer* layer = NULL;
+        /* A clipRect that came after the shape: the clip is the shape AND that
+         * rectangle (see clipRect below). The rectangle goes on first, under
+         * identity for the reason given at the end of this function, and the
+         * shape's layer inside it; cn1WinPopClip takes them off in reverse. */
+        if (g->clipGeomHasRect) {
+            D2D1_RECT_F rc;
+            D2D1_MATRIX_3X2_F idr = D2D1::Matrix3x2F::Identity();
+            rc.left = (FLOAT)g->clipX;
+            rc.top = (FLOAT)g->clipY;
+            rc.right = (FLOAT)(g->clipX + g->clipW);
+            rc.bottom = (FLOAT)(g->clipY + g->clipH);
+            ID2D1RenderTarget_SetTransform(g->target, &idr);
+            ID2D1RenderTarget_PushAxisAlignedClip(g->target, &rc, D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
+            ID2D1RenderTarget_SetTransform(g->target, &g->transform);
+            g->clipRectPushed = JAVA_TRUE;
+        }
         if (SUCCEEDED(ID2D1RenderTarget_CreateLayer(g->target, NULL, &layer)) && layer != NULL) {
             D2D1_LAYER_PARAMETERS lp;
             lp.contentBounds = D2D1::InfiniteRect();
@@ -253,6 +271,20 @@ extern "C" void cn1WinPopClip(CN1Graphics* g) {
         ID2D1RenderTarget_PopLayer(g->target);
         ID2D1Layer_Release((ID2D1Layer*) g->clipLayer);
         g->clipLayer = NULL;
+        if (g->clipRectPushed) {
+            ID2D1RenderTarget_PopAxisAlignedClip(g->target);
+            g->clipRectPushed = JAVA_FALSE;
+        }
+        return;
+    }
+    if (g->clipRectPushed) {
+        /* The shape's layer could not be made; its rectangle was still pushed. */
+        ID2D1RenderTarget_PopAxisAlignedClip(g->target);
+        g->clipRectPushed = JAVA_FALSE;
+        return;
+    }
+    if (!g->clipIsRect && g->clipGeom != NULL) {
+        /* A shape clip whose layer could not be made pushed nothing at all. */
         return;
     }
     ID2D1RenderTarget_PopAxisAlignedClip(g->target);
@@ -335,6 +367,7 @@ JAVA_VOID com_codename1_impl_windows_WindowsNative_setClip___long_int_int_int_in
     g->clipW = __cn1Arg4;
     g->clipH = __cn1Arg5;
     g->clipIsRect = JAVA_TRUE;
+    g->clipGeomHasRect = JAVA_FALSE;
     cn1WinReleaseClipGeom(g);
 }
 
@@ -375,12 +408,33 @@ JAVA_VOID com_codename1_impl_windows_WindowsNative_setClipShape___long_float_1AR
     g->clipGeom = cn1WinBuildPathGeometry(coords, types, __cn1Arg4, __cn1Arg5);
     g->clipMaskTransform = g->transform; /* freeze the world transform at setClip time */
     g->clipIsRect = (g->clipGeom == NULL) ? JAVA_TRUE : JAVA_FALSE;
-    /* Keep clipX/Y/W/H as the geometry's bounding box so getClip* stays sane. */
+    /* clipX/Y/W/H is left as it was: the rectangle that was the clip BEFORE the
+     * shape replaced it. It is what getClip* goes on answering, and it is not
+     * part of the clip until a clipRect says so. */
+    g->clipGeomHasRect = JAVA_FALSE;
 }
 
 JAVA_VOID com_codename1_impl_windows_WindowsNative_clipRect___long_int_int_int_int(CODENAME_ONE_THREAD_STATE, JAVA_LONG __cn1Arg1, JAVA_INT __cn1Arg2, JAVA_INT __cn1Arg3, JAVA_INT __cn1Arg4, JAVA_INT __cn1Arg5) {
     /* Intersect the requested rectangle with the current clip. */
     CN1Graphics* g = (CN1Graphics*)__cn1Arg1;
+    /* A shape clip is narrowed, not thrown away. This used to end in
+     * clipIsRect = JAVA_TRUE and a released geometry whatever the clip was, so
+     * "setClip(shape); clipRect(the clip that was there)" -- which is how
+     * Graphics.fillShape confines a Paint to the shape it fills, and how any
+     * caller narrows the clip to a shape without widening it -- left only the
+     * rectangle that had been the clip BEFORE the shape: a gradient meant for a
+     * small rounded rectangle covered everything from the panel's corner to the
+     * end of the gradient's band. The first clipRect after the shape supplies
+     * the rectangle outright, since clipX/Y/W/H still holds the replaced clip
+     * then; later ones intersect with it as they always did. */
+    if (!g->clipIsRect && g->clipGeom != NULL && !g->clipGeomHasRect) {
+        g->clipX = __cn1Arg2;
+        g->clipY = __cn1Arg3;
+        g->clipW = (__cn1Arg4 > 0) ? __cn1Arg4 : 0;
+        g->clipH = (__cn1Arg5 > 0) ? __cn1Arg5 : 0;
+        g->clipGeomHasRect = JAVA_TRUE;
+        return;
+    }
     JAVA_INT curRight = g->clipX + g->clipW;
     JAVA_INT curBottom = g->clipY + g->clipH;
     JAVA_INT reqRight = __cn1Arg2 + __cn1Arg4;
@@ -395,6 +449,9 @@ JAVA_VOID com_codename1_impl_windows_WindowsNative_clipRect___long_int_int_int_i
     g->clipY = newY;
     g->clipW = (newRight > newX) ? (newRight - newX) : 0;
     g->clipH = (newBottom > newY) ? (newBottom - newY) : 0;
+    if (!g->clipIsRect && g->clipGeom != NULL) {
+        return; /* the shape stays, cut to the narrower rectangle */
+    }
     g->clipIsRect = JAVA_TRUE;
     cn1WinReleaseClipGeom(g);
 }
diff --git a/Ports/WindowsPort/nativeSources/cn1_windows_text.c b/Ports/WindowsPort/nativeSources/cn1_windows_text.c
index 8bf6d5f91b5..c82bf1f18fe 100644
--- a/Ports/WindowsPort/nativeSources/cn1_windows_text.c
+++ b/Ports/WindowsPort/nativeSources/cn1_windows_text.c
@@ -324,13 +324,19 @@ JAVA_LONG com_codename1_impl_windows_WindowsNative_loadTrueTypeFontFromMemory___
 /*
  * deriveTrueTypeFont produces a new peer at the requested pixel size and weight,
  * reusing the base font's family. weight carries the CN1 STYLE_* bits.
+ *
+ * The base font's own bold and slant are kept. A "native:MainBold" font is
+ * bold by its name, and every caller that only wants another size of it asks
+ * with a plain weight: taking the weight alone gave back regular Segoe UI, so
+ * no sized native font was ever bold or italic.
  */
 JAVA_LONG com_codename1_impl_windows_WindowsNative_deriveTrueTypeFont___long_float_int_R_long(
         CODENAME_ONE_THREAD_STATE, JAVA_LONG __cn1Arg1, JAVA_FLOAT __cn1Arg2, JAVA_INT __cn1Arg3) {
     CN1Font* base = (CN1Font*) (intptr_t) __cn1Arg1;
     const wchar_t* family = (base != NULL && base->family != NULL) ? base->family : L"Segoe UI";
     float px = __cn1Arg2 > 0.0f ? __cn1Arg2 : 15.0f;
-    CN1Font* font = cn1WinMakeFont(family, px, 0, __cn1Arg3);
+    int style = __cn1Arg3 | (base != NULL ? base->style : 0);
+    CN1Font* font = cn1WinMakeFont(family, px, 0, style);
     return (JAVA_LONG) (intptr_t) font;
 }
 
diff --git a/Ports/WindowsPort/src/com/codename1/impl/windows/WindowsImplementation.java b/Ports/WindowsPort/src/com/codename1/impl/windows/WindowsImplementation.java
index 4c955bcac31..d4e3f32dc32 100644
--- a/Ports/WindowsPort/src/com/codename1/impl/windows/WindowsImplementation.java
+++ b/Ports/WindowsPort/src/com/codename1/impl/windows/WindowsImplementation.java
@@ -189,9 +189,18 @@ private String storagePath(String name) {
         return WindowsNative.storageDir() + getFileSystemSeparator() + name;
     }
 
+    /// The native path of a `file://` URL. This port writes `file://C:/x`,
+    /// but the standard form of the same URL is `file:///C:/x` -- which is
+    /// what `java.io.File` hands over for an absolute path -- and its leading
+    /// slash makes `/C:/x`, a name Windows refuses (error 123).
     private static String stripFileUrl(String path) {
         if (path.startsWith("file://")) {
-            return path.substring("file://".length());
+            String p = path.substring("file://".length());
+            if (p.length() > 2 && p.charAt(0) == '/' && p.charAt(2) == ':'
+                    && Character.isLetter(p.charAt(1))) {
+                return p.substring(1);
+            }
+            return p;
         }
         return path;
     }
@@ -223,6 +232,9 @@ private static byte[] readFully(InputStream i) throws IOException {
 
     @Override
     public void init(Object m) {
+        // The class library (vm/JavaAPI) reaches files, preferences, the
+        // network and the EDT through Codename One from here on.
+        com.codename1.impl.CoreJdkHostInstaller.install();
         WindowsNative.initDisplay("Codename One", 800, 600);
         windowGraphicsPeer = WindowsNative.getWindowGraphics();
         windowGraphics = Long.valueOf(windowGraphicsPeer);
diff --git a/Ports/iOSPort/src/com/codename1/impl/ios/IOSImplementation.java b/Ports/iOSPort/src/com/codename1/impl/ios/IOSImplementation.java
index e4a2a2abdf4..a702b0fe607 100644
--- a/Ports/iOSPort/src/com/codename1/impl/ios/IOSImplementation.java
+++ b/Ports/iOSPort/src/com/codename1/impl/ios/IOSImplementation.java
@@ -256,6 +256,9 @@ protected void initDefaultUserAgent() {
 
     
     public void init(Object m) {
+        // The class library (vm/JavaAPI) reaches files, preferences, the
+        // network and the EDT through Codename One from here on.
+        com.codename1.impl.CoreJdkHostInstaller.install();
         instance = this;
         // Set the metalRendering static gate as early as possible -- before
         // any NativeImage / NativeGraphics is constructed -- so mutable-image
diff --git a/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.properties b/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.properties
new file mode 100644
index 00000000000..49e7e44b0ba
--- /dev/null
+++ b/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.properties
@@ -0,0 +1,5 @@
+// Generated from docs/developer-guide source blocks. Edit the guide snippets here, not inline.
+
+// tag::desktop-interop-properties-003[]
+codename1.arg.desktop.themeMode=native
+// end::desktop-interop-properties-003[]
diff --git a/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.sh b/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.sh
new file mode 100644
index 00000000000..238c7dbd0e9
--- /dev/null
+++ b/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.sh
@@ -0,0 +1,66 @@
+// Generated from docs/developer-guide source blocks. Edit the guide snippets here, not inline.
+
+// tag::desktop-interop-bash-001[]
+mvn cn1:import-desktop-project -Dcn1.desktop.import=/path/to/MyDesktopApp
+// end::desktop-interop-bash-001[]
+
+// tag::desktop-interop-bash-002[]
+mvn cn1:import-desktop-project -Dcn1.desktop.import=/path/to/MyDesktopApp \
+    -Dcn1.desktop.module=app \
+    -Dcn1.desktop.mainClass=com.example.Main
+// end::desktop-interop-bash-002[]
+
+// tag::desktop-interop-bash-003[]
+mvn cn1:run
+mvn cn1:build -Dcodename1.platform=ios
+// end::desktop-interop-bash-003[]
+
+// tag::desktop-interop-bash-004[]
+./gradlew run            # the simulator
+./gradlew buildIos       # an iOS build on the build server
+./gradlew buildLinuxDevice
+// end::desktop-interop-bash-004[]
+
+// tag::desktop-interop-bash-005[]
+mvn cn1:run                                    # the simulator
+mvn cn1:buildIos                               # iOS, on the build server
+mvn cn1:buildAndroid                           # Android, on the build server
+mvn cn1:buildJavascript                        # the JavaScript port
+mvn package -Dcodename1.platform=ios -Dcodename1.buildTarget=ios-source          # an Xcode project
+mvn package -Dcodename1.platform=android -Dcodename1.buildTarget=android-source  # an Android Studio project
+// end::desktop-interop-bash-005[]
+
+// tag::desktop-interop-bash-006[]
+# Linux: a native executable, built on a Linux machine
+mvn package -Dcodename1.platform=linux -Dcodename1.buildTarget=local-linux-device
+
+# macOS: a native .app, built on a Mac with Xcode
+mvn package -Dcodename1.platform=ios -Dcodename1.buildTarget=local-mac-device
+
+# Windows: a native .exe, built on Windows or cross-compiled
+mvn package -Dcodename1.platform=win -Dcodename1.buildTarget=local-windows-device
+// end::desktop-interop-bash-006[]
+
+// tag::desktop-interop-bash-007[]
+mvn package -Dcn1.desktop.report=port.md       # Maven
+./gradlew build -Pcn1.desktop.report=port.md   # Gradle
+// end::desktop-interop-bash-007[]
+
+// tag::desktop-interop-bash-008[]
+# From a checkout of the Codename One sources, against a built application:
+xvfb-run -a maven/integration-tests/desktop-compat-realport/run.sh \
+    /path/to/MyApp/common /path/to/orders.txt /path/to/output
+// end::desktop-interop-bash-008[]
+
+// tag::desktop-interop-bash-009[]
+scripts/desktop-compat-benchmarks/bench.sh --app /path/to/MyDesktopApp --name myapp \
+    --kind swing --main com.example.Main --work /path/to/work
+scripts/desktop-compat-benchmarks/report.py /path/to/work/myapp/result.json
+// end::desktop-interop-bash-009[]
+
+// tag::desktop-interop-bash-010[]
+scripts/desktop-compat-benchmarks/mobile-size.sh --target ios \
+    --project /path/to/work/myapp/cn1/app --work /path/to/work/myapp-ios
+scripts/desktop-compat-benchmarks/mobile-size.sh --target android \
+    --project /path/to/work/myapp/cn1/app --work /path/to/work/myapp-android
+// end::desktop-interop-bash-010[]
diff --git a/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.xml b/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.xml
new file mode 100644
index 00000000000..fc6f11c2241
--- /dev/null
+++ b/docs/demos/common/src/main/snippets/developer-guide/desktop-interop.xml
@@ -0,0 +1,10 @@
+// Generated from docs/developer-guide source blocks. Edit the guide snippets here, not inline.
+
+// tag::desktop-interop-xml-001[]
+<dependency>
+    <groupId>com.example</groupId>
+    <artifactId>swing-widgets</artifactId>
+    <version>1.0</version>
+    <scope>compile</scope>
+</dependency>
+// end::desktop-interop-xml-001[]
diff --git a/docs/demos/desktop-interop/pom.xml b/docs/demos/desktop-interop/pom.xml
new file mode 100644
index 00000000000..6debdbe2051
--- /dev/null
+++ b/docs/demos/desktop-interop/pom.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>
+  <parent>
+    <groupId>com.codenameone.developerguide</groupId>
+    <artifactId>democode</artifactId>
+    <version>1.0-SNAPSHOT</version>
+  </parent>
+  <artifactId>desktopinteropsnippets</artifactId>
+  <name>desktopinteropsnippets</name>
+  <!--
+       Compiles the desktop interop chapter's snippets. The Swing ones use
+       java.awt and javax.swing, which a desktop application compiles against
+       in the JDK itself, and the JavaFX ones use the javafx.* API of the
+       compatibility runtime, so they compile here rather than in the common
+       module, which is an ordinary Codename One client.
+  -->
+  <dependencies>
+    <dependency>
+      <groupId>com.codenameone</groupId>
+      <artifactId>codenameone-core</artifactId>
+      <version>${cn1.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.codenameone</groupId>
+      <artifactId>codenameone-swing-compat</artifactId>
+      <version>${cn1.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.codenameone</groupId>
+      <artifactId>codenameone-javafx-compat</artifactId>
+      <version>${cn1.version}</version>
+      <scope>provided</scope>
+    </dependency>
+  </dependencies>
+</project>
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/CounterApp.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/CounterApp.java
new file mode 100644
index 00000000000..9b613d6d98d
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/CounterApp.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.javafx;
+
+// tag::desktopInteropJavaFxApp[]
+import javafx.application.Application;
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+
+public class CounterApp extends Application {
+    private final IntegerProperty count = new SimpleIntegerProperty();
+
+    @Override
+    public void start(Stage stage) {
+        Label label = new Label();
+        label.textProperty().bind(Bindings.concat("Pressed ", count.asString(), " times"));
+
+        Button press = new Button("Press");
+        press.setOnAction(e -> count.set(count.get() + 1));
+
+        VBox root = new VBox(12, label, press);
+        root.setAlignment(Pos.CENTER);
+        root.setPadding(new Insets(16));
+
+        stage.setTitle("Counter");
+        stage.setScene(new Scene(root, 320, 200));
+        stage.show();
+    }
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+}
+// end::desktopInteropJavaFxApp[]
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/EmbeddedChart.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/EmbeddedChart.java
new file mode 100644
index 00000000000..d6e76e857e8
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/EmbeddedChart.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.javafx;
+
+import com.codename1.fxcompat.FxInterop;
+import com.codename1.ui.Form;
+import com.codename1.ui.layouts.BorderLayout;
+
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+
+/// A Codename One screen that shows a JavaFX scene graph, and a stage opened
+/// from a Codename One application.
+public class EmbeddedChart {
+
+    public void show() {
+        // tag::desktopInteropEmbedFx[]
+        VBox root = new VBox(8, new Label("Orders this week"), new Button("Refresh"));
+        Scene scene = new Scene(root);
+        scene.getStylesheets().add("/com/example/orders.css");
+
+        Form form = new Form("Report", new BorderLayout());
+        form.add(BorderLayout.CENTER, FxInterop.asComponent(scene));
+        form.show();
+        // end::desktopInteropEmbedFx[]
+    }
+
+    public void openEditor(VBox editor) {
+        // tag::desktopInteropFxWindows[]
+        Stage stage = new Stage();
+        stage.setTitle("Edit order");
+        stage.setScene(new Scene(editor));
+        stage.show();   // closing it returns to the form that was showing
+        // end::desktopInteropFxWindows[]
+    }
+}
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterController.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterController.java
new file mode 100644
index 00000000000..e2cec28fa40
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterController.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.javafx;
+
+// tag::desktopInteropFxmlController[]
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextField;
+
+public class GreeterController {
+    @FXML
+    private Label status;
+
+    @FXML
+    private TextField name;
+
+    @FXML
+    private Button greet;
+
+    @FXML
+    private void initialize() {
+        greet.disableProperty().bind(name.textProperty().isEmpty());
+    }
+
+    @FXML
+    private void greet(ActionEvent event) {
+        status.setText("Hello, " + name.getText() + "!");
+    }
+}
+// end::desktopInteropFxmlController[]
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterFxApp.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterFxApp.java
new file mode 100644
index 00000000000..a268ef531bd
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterFxApp.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.javafx;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+
+/// A JavaFX application whose screen is an FXML document styled by a
+/// style sheet.
+public class GreeterFxApp extends Application {
+
+    // tag::desktopInteropFxmlLoad[]
+    @Override
+    public void start(Stage stage) throws Exception {
+        Parent root = FXMLLoader.load(getClass().getResource("greeter.fxml"));
+        Scene scene = new Scene(root);
+        scene.getStylesheets().add(getClass().getResource("greeter.css").toExternalForm());
+        stage.setTitle("Greeter");
+        stage.setScene(scene);
+        stage.show();
+    }
+    // end::desktopInteropFxmlLoad[]
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+}
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/BadgePanel.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/BadgePanel.java
new file mode 100644
index 00000000000..e49582dac07
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/BadgePanel.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+
+import javax.swing.JPanel;
+
+/// A panel that paints itself: a disc with the first letter of a name.
+// tag::desktopInteropSwingPaint[]
+public class BadgePanel extends JPanel {
+    private String initial = "?";
+
+    public void setInitial(String name) {
+        initial = name == null || name.length() == 0 ? "?" : name.substring(0, 1);
+        repaint();
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        return new Dimension(120, 120);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Graphics2D g2 = (Graphics2D) g;
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        int size = Math.min(getWidth(), getHeight()) - 16;
+        int x = (getWidth() - size) / 2;
+        int y = (getHeight() - size) / 2;
+        g2.setColor(new Color(0x2f6fed));
+        g2.fillOval(x, y, size, size);
+        g2.setColor(Color.WHITE);
+        g2.setFont(getFont().deriveFont(size / 2f));
+        FontMetrics metrics = g2.getFontMetrics();
+        g2.drawString(initial, (getWidth() - metrics.stringWidth(initial)) / 2,
+                (getHeight() - metrics.getHeight()) / 2 + metrics.getAscent());
+    }
+}
+// end::desktopInteropSwingPaint[]
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/CompactLayout.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/CompactLayout.java
new file mode 100644
index 00000000000..85cd58b62b4
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/CompactLayout.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+import javax.swing.JSplitPane;
+
+import com.codename1.ui.CN;
+
+/// Swing code that asks Codename One what kind of device it is running on.
+public class CompactLayout {
+
+    public void apply(JSplitPane split) {
+        // tag::desktopInteropCodenameOneApi[]
+        if (!CN.isDesktop() && !CN.isTablet()) {
+            // A phone: stack the two halves instead of placing them side by side.
+            split.setOrientation(JSplitPane.VERTICAL_SPLIT);
+        }
+        // end::desktopInteropCodenameOneApi[]
+    }
+}
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/DeviceSettings.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/DeviceSettings.java
new file mode 100644
index 00000000000..1b2f841d696
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/DeviceSettings.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+
+import com.codename1.ui.CN;
+
+/// A Swing entry point that adjusts how the layer maps it onto the device
+/// before it shows anything.
+public class DeviceSettings {
+
+    public static void main(String[] args) {
+        // tag::desktopInteropDisplayProperties[]
+        if (!CN.isDesktop()) {
+            // Fit a little more of a wide form on a phone.
+            CN.setProperty("desktopcompat.scale", "1.6");
+            // Keep the menu bar in the window instead of the overflow menu.
+            CN.setProperty("desktopcompat.menuBar", "window");
+        }
+        // A fixed width font the application ships among its resources.
+        CN.setProperty("desktopcompat.monospaced", "DejaVu Sans Mono|DejaVuSansMono.ttf");
+
+        JFrame frame = new JFrame("Orders");
+        // end::desktopInteropDisplayProperties[]
+        frame.add(new JLabel("Orders"));
+        frame.setVisible(true);
+    }
+}
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/EmbeddedReport.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/EmbeddedReport.java
new file mode 100644
index 00000000000..b26a8353b27
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/EmbeddedReport.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+import java.awt.BorderLayout;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+
+import com.codename1.desktopcompat.SwingInterop;
+import com.codename1.ui.Form;
+
+/// A Codename One screen that shows a Swing panel, and Swing windows opened
+/// from a Codename One application.
+public class EmbeddedReport {
+
+    public void show() {
+        // tag::desktopInteropEmbedSwing[]
+        JPanel report = new JPanel(new BorderLayout());
+        report.add(new JLabel("Orders this week"), BorderLayout.NORTH);
+        report.add(new JScrollPane(new JTable(new Object[][] {{"Mon", 12}, {"Tue", 9}},
+                new Object[] {"Day", "Orders"})), BorderLayout.CENTER);
+
+        Form form = new Form("Report", new com.codename1.ui.layouts.BorderLayout());
+        form.add(com.codename1.ui.layouts.BorderLayout.CENTER, SwingInterop.asComponent(report));
+        form.show();
+        // end::desktopInteropEmbedSwing[]
+    }
+
+    public boolean openEditor(JPanel editor) {
+        // tag::desktopInteropSwingWindows[]
+        JFrame frame = new JFrame("Edit order");
+        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        frame.setContentPane(editor);
+        frame.setVisible(true);   // closing it returns to the form that was showing
+
+        int answer = JOptionPane.showConfirmDialog(frame, "Save the order?", "Save",
+                JOptionPane.YES_NO_OPTION);
+        // end::desktopInteropSwingWindows[]
+        return answer == JOptionPane.YES_OPTION;
+    }
+}
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/ExternalTools.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/ExternalTools.java
new file mode 100644
index 00000000000..e5be50b9245
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/ExternalTools.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+import com.codename1.ui.CN;
+
+/// A feature the desktop application implemented by starting processes, moved
+/// behind an interface so that the user interface no longer knows how it is done.
+public class ExternalTools {
+
+    // tag::desktopInteropIsolate[]
+    /// What the screens ask for. They hold one of these and nothing else.
+    public interface Tools {
+        /// Whether the menu item that opens a terminal should be there at all.
+        boolean canOpenTerminal();
+
+        void openTerminal(String directory);
+
+        void showInFileManager(String path);
+    }
+
+    /// The implementation the Codename One build uses. The desktop project
+    /// keeps its own, written with ProcessBuilder, in a class this build
+    /// doesn't compile.
+    public static class DeviceTools implements Tools {
+        @Override
+        public boolean canOpenTerminal() {
+            return false;
+        }
+
+        @Override
+        public void openTerminal(String directory) {
+            throw new UnsupportedOperationException("No terminal on this device");
+        }
+
+        @Override
+        public void showInFileManager(String path) {
+            String url = path.startsWith("file:") ? path : "file://" + path;
+            Boolean can = CN.canExecute(url);
+            if (can == null || can.booleanValue()) {
+                CN.execute(url);
+            }
+        }
+    }
+    // end::desktopInteropIsolate[]
+}
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/GreeterApp.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/GreeterApp.java
new file mode 100644
index 00000000000..a6804cdfec4
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/GreeterApp.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+// tag::desktopInteropSwingApp[]
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.SwingUtilities;
+
+public class GreeterApp {
+
+    public static void main(String[] args) {
+        SwingUtilities.invokeLater(GreeterApp::showFrame);
+    }
+
+    private static void showFrame() {
+        JFrame frame = new JFrame("Greeter");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+        JTextField name = new JTextField(16);
+        JPanel form = new JPanel(new GridLayout(0, 2, 8, 8));
+        form.setBorder(BorderFactory.createEmptyBorder(12, 12, 12, 12));
+        form.add(new JLabel("Name"));
+        form.add(name);
+
+        BadgePanel badge = new BadgePanel();
+        JButton greet = new JButton("Greet");
+        greet.addActionListener(e -> {
+            badge.setInitial(name.getText());
+            JOptionPane.showMessageDialog(frame, "Hello, " + name.getText() + "!");
+        });
+
+        frame.getContentPane().add(form, BorderLayout.NORTH);
+        frame.getContentPane().add(badge, BorderLayout.CENTER);
+        frame.getContentPane().add(greet, BorderLayout.SOUTH);
+        frame.pack();
+        frame.setVisible(true);
+    }
+}
+// end::desktopInteropSwingApp[]
diff --git a/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/LoadNames.java b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/LoadNames.java
new file mode 100644
index 00000000000..9ba8ef48c61
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/LoadNames.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.developerguide.desktopinterop.swing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.DefaultListModel;
+import javax.swing.JLabel;
+import javax.swing.SwingWorker;
+
+/// Work off the event dispatch thread, with the results delivered on it.
+public class LoadNames {
+
+    public void load(DefaultListModel<String> model, JLabel status) {
+        // tag::desktopInteropSwingWorker[]
+        new SwingWorker<List<String>, String>() {
+            @Override
+            protected List<String> doInBackground() {
+                List<String> names = new ArrayList<String>();
+                for (String name : new String[] {"Ada", "Grace", "Linus"}) {
+                    names.add(name);
+                    publish(name);
+                }
+                return names;
+            }
+
+            @Override
+            protected void process(List<String> chunks) {
+                for (String name : chunks) {
+                    model.addElement(name);
+                }
+            }
+
+            @Override
+            protected void done() {
+                status.setText(model.getSize() + " names loaded");
+            }
+        }.execute();
+        // end::desktopInteropSwingWorker[]
+    }
+}
diff --git a/docs/demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.css b/docs/demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.css
new file mode 100644
index 00000000000..5ee5879dc74
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.css
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/* tag::desktopInteropFxCss[] */
+.root {
+    -app-accent: #2f6fed;
+}
+
+.card {
+    -fx-background-color: white;
+    -fx-border-color: -app-accent;
+    -fx-border-width: 2;
+    -fx-border-radius: 8;
+    -fx-background-radius: 8;
+}
+
+#status {
+    -fx-text-fill: -app-accent;
+    -fx-font-size: 18;
+    -fx-font-weight: bold;
+}
+
+.card > .button:hover {
+    -fx-opacity: 0.85;
+}
+/* end::desktopInteropFxCss[] */
diff --git a/docs/demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.fxml b/docs/demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.fxml
new file mode 100644
index 00000000000..ca37a8c2c23
--- /dev/null
+++ b/docs/demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.fxml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- tag::desktopInteropFxml[] -->
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.VBox?>
+
+<VBox xmlns:fx="http://javafx.com/fxml/1" spacing="12" styleClass="card"
+      fx:controller="com.codenameone.developerguide.desktopinterop.javafx.GreeterController">
+    <padding>
+        <Insets top="16" right="16" bottom="16" left="16"/>
+    </padding>
+    <Label fx:id="status" text="Who is there?"/>
+    <TextField fx:id="name" promptText="Name"/>
+    <Button fx:id="greet" text="Greet" onAction="#greet"/>
+</VBox>
+<!-- end::desktopInteropFxml[] -->
diff --git a/docs/demos/pom.xml b/docs/demos/pom.xml
index bb81a676d51..5184e7b5f67 100644
--- a/docs/demos/pom.xml
+++ b/docs/demos/pom.xml
@@ -19,6 +19,7 @@
 <module>common</module>
 <module>backend</module>
 <module>android-interop</module>
+<module>desktop-interop</module>
 </modules>
   <properties>
     <cn1.plugin.version>8.0-SNAPSHOT</cn1.plugin.version>
diff --git a/docs/developer-guide/Desktop-Interop.asciidoc b/docs/developer-guide/Desktop-Interop.asciidoc
new file mode 100644
index 00000000000..2a5f1265da4
--- /dev/null
+++ b/docs/developer-guide/Desktop-Interop.asciidoc
@@ -0,0 +1,1100 @@
+== Running Swing and JavaFX applications
+
+An existing desktop application written with Swing and AWT, with the SwingX
+component set, or with JavaFX can build and run as a Codename One
+application without changes to its Java code. The desktop sources go into a
+Codename One project, the build maps them onto Codename One's implementation
+of the `java.awt`, `javax.swing`, `org.jdesktop.swingx` and `javafx.*` APIs,
+and the result runs on every Codename One target: iOS, Android, the web, the
+native desktop ports and the simulator.
+
+No desktop Java runtime is involved. Buttons, text fields, check boxes,
+sliders and tabs are Codename One components that take the platform's
+theme, layout managers and layout panes run the rules they run on the
+desktop, and code that paints with `Graphics2D` or a JavaFX `Canvas` draws
+through Codename One's graphics.
+
+[[desktop-interop-motivation]]
+=== Motivation
+
+A Swing or JavaFX application that already works has three reasons to move.
+
+*It reaches every platform from one code base.* The same sources build for
+iPhone and iPad, Android phones and tablets, the browser, and native Linux,
+macOS and Windows. Nothing is rewritten per platform, and the desktop
+version keeps its windows, menus, and keyboard.
+
+*It ships as one native program.* A native desktop build is a single
+executable with no Java runtime to bundle, install, or update. It starts
+faster, holds less memory and downloads smaller than the same application
+with a trimmed Java runtime beside it. <<desktop-interop-benchmarks>>
+measures all three for eight applications, built both ways.
+
+*It gets the APIs desktop Java never had.* The desktop sources compile next
+to the Codename One API and can call it directly, as
+<<desktop-interop-codename-one-api>> shows. That fixes several of the oldest
+pain points of Swing and JavaFX development:
+
+[cols="1,2",options="header"]
+|===
+|What a desktop developer reaches for |What Codename One has
+
+|A camera, a microphone, the photo library
+|`Capture` takes photos, video and audio with the device's camera and
+microphone. See
+<<_capture_photos_video_audio>>.
+
+|An embedded browser without a heavyweight engine to ship
+|`BrowserComponent` is the platform's own web view, with a two-way bridge to
+JavaScript. See <<_browsercomponent_webbrowser>>.
+
+|A local database
+|SQLite on every platform through `Database`, and an annotation-driven ORM
+over it. See <<_sql>> and <<annotation-orm-section>>.
+
+|JSON without a reflection library
+|`@Mapped` classes and `Mappers` convert objects to JSON and XML with code
+generated at build time. See <<annotation-mapping-section>>.
+
+|REST clients and OpenAPI
+|`Rest` for ad hoc calls, typed `@RestClient` interfaces, and
+`cn1:generate-openapi` to generate a client from an OpenAPI (Swagger)
+specification. See <<_rest_api>> and
+<<_generate_openapi_client_generate_openapi>>.
+
+|A server in the same language
+|A Java backend that shares its contract and data classes with the app. See
+<<_server_side_backend>> and <<backend-web>>.
+
+|Styling without look-and-feel code
+|CSS compiled into a theme at build time, and applied live in the
+simulator as you save. See <<desktop-interop-behavior>> and <<_css>>.
+
+|AI agents that can work with the app
+|Over the Model Context Protocol (MCP), an agent reads and drives a
+development build's user interface, and a backend publishes tools for
+agents in production. See <<_mcp_headless_api>> and <<backend-mcp>>.
+|===
+
+Push notifications, biometrics, maps, in-app purchase and the rest of the
+guide are available in the same way.
+
+The layer implements the parts of each toolkit applications use, and the
+build tells you, file by file and line by line, about anything an
+application uses that it doesn't implement
+(<<desktop-interop-build-errors>>). New code can use either API: the two
+live in one project.
+
+[[desktop-interop-quick-start]]
+=== Quick start
+
+Create a Codename One application project (for example from
+https://start.codenameone.com[the initializr]), then import the desktop
+project into it:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-001,indent=0]
+----
+
+The goal accepts a Maven or a Gradle project. It copies the project's
+`src/main/java`, `src/main/kotlin` and `src/main/resources` into
+`common/src/main/desktop`, generates the Codename One main class that starts
+the application (<<desktop-interop-entry-point>>), and lists what becomes of
+each of the project's dependencies.
+
+Two more parameters settle the cases the goal can't decide for itself:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-002,indent=0]
+----
+
+`cn1.desktop.module` names the module to import when the project's root has
+no sources and more than one of its modules does. `cn1.desktop.mainClass`
+names the class the application starts through when the project leaves more
+than one candidate. In both cases the goal stops before it copies anything
+and lists the choices.
+
+After that, run and build as you would any Codename One application. The
+sources are the same for every target:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-005,indent=0]
+----
+
+The simulator is the quickest place to see the application, and its skins
+show it at the size and density of a phone or a tablet. Every target and
+its options are in the <<maven-project-workflow,Maven project workflow>>
+chapter.
+
+==== Gradle
+
+A Codename One project built with Gradle (see <<gradle-project-workflow>>)
+takes the same sources in the same place, `src/main/desktop`. When that
+directory exists the Codename One Gradle plugin adds the toolkit layers and
+runs the same build steps, with no configuration:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-004,indent=0]
+----
+
+==== Placing the sources by hand
+
+The directory mirrors a desktop project's `src/main`:
+
+----
+common/src/main/desktop/
+    java/        the desktop application's Java sources
+    kotlin/      Kotlin sources, if the application has any
+    resources/   images, .properties, .fxml and .css files
+----
+
+The `common` module's `desktop-compat` profile activates when
+`src/main/desktop` exists and adds the Swing and JavaFX layers. Only the
+layer the compiled classes use ships, so a Swing application doesn't carry
+the JavaFX runtime. A project created before the profile existed gets it
+from the import goal.
+
+[[desktop-interop-entry-point]]
+=== The entry point
+
+A ported application is an ordinary Codename One application with an
+ordinary main class: a `Lifecycle` subclass in `common/src/main/java`. The
+import goal generates it, and its start-up calls the Swing application's
+`main`, or launches the JavaFX `Application`, on the Codename One event
+dispatch thread (EDT). That thread is also the Swing event dispatch thread
+and the JavaFX application thread.
+
+The class is yours. Edit it to pass arguments, to set display properties
+before the first window opens (<<desktop-interop-settings>>), to show a
+Codename One screen first, or to start the desktop code only for some
+devices.
+
+=== How the build works
+
+Three ideas explain everything the build does:
+
+* *The application is compiled once, against the desktop API, and
+  relinked.* Swing code compiles against the JDK's own `java.awt` and
+  `javax.swing`, JavaFX code against a `javafx.*` API that ships with
+  Codename One, which is why the sources need no changes. The build then
+  points every reference at Codename One's implementation. No source is
+  translated and nothing is interpreted: each target compiles the result as
+  it compiles any Codename One application, to native code on iOS and the
+  desktop ports, to Android's bytecode on Android, to JavaScript in a
+  browser.
+* *Only what's used ships.* A layer is active only when the application's
+  classes name its API, and the native builds drop every class and method
+  nothing reaches.
+* *Nothing is found by reflection at run time.* FXML documents, style
+  sheets, resource lists, resource bundles and `ServiceLoader` providers are
+  compiled into code by the build. That's what makes the same application
+  run on iOS, and it's also why it starts fast everywhere.
+
+The JDK API that ordinary application code uses is available on every
+target: `java.io.File` and `java.nio.file`, regular expressions, the stream
+API, `java.time`, the executors and concurrent collections, `Optional`,
+`Properties`, `ResourceBundle`, `ServiceLoader`, logging and preferences.
+
+[[desktop-interop-build-errors]]
+=== Unsupported API is a build error
+
+The build checks every reference in the compiled application, so a class,
+method, constructor or field that a layer doesn't have stops the build. It
+never becomes a failure on a user's device. The message names the API the
+way the source spells it, with the source file and line:
+
+----
+Compliance check failed with 2 forbidden API references.
+See /projects/orders/common/target/codenameone/compliance_check.txt for the full report.
+First 2 violation(s):
+ - com/example/OrdersPanel#restyleTree()V -> javax.swing.JTree.getUI() is not supported by the Codename One Swing compatibility layer (com/example/OrdersPanel.class) at OrdersPanel.java:48
+ - com/example/NotesDialog#printNotes()V -> javax.swing.JTextArea.print() is not supported by the Codename One Swing compatibility layer (com/example/NotesDialog.class) at NotesDialog.java:31
+----
+
+A project with more than a handful of such references gets a summary that
+groups them by kind and by library, and points at the port report.
+
+[[desktop-interop-port-report]]
+==== The port report
+
+Every build of a project that uses a desktop layer writes
+`target/codenameone/desktop-port-report.md`, whether the check passes or
+fails. It says how many of the application's calls into Swing, AWT and
+JavaFX are supported, lists what to change source file by source file with
+a Codename One alternative where one exists, and says what became of each
+dependency. Set `cn1.desktop.report` to write it elsewhere:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-007,indent=0]
+----
+
+To find out how well an application fits before changing a line of it,
+import it, build it and read the summary at the top of that report.
+
+[[desktop-interop-porting]]
+=== Porting a large application
+
+A small application usually builds after the import. A large one usually
+needs some work, and widgets are seldom the reason: the user interface
+calls of a two-hundred-file Swing application, with FlatLaf for its look,
+an icon font library and a syntax-highlighting editor, built as written.
+The work is in the libraries and services around the user interface, and
+it goes in the order below.
+
+==== Classify the dependencies
+
+The import and every build put each dependency in one of a few classes, and
+the class decides what you do:
+
+[cols="1,2,2",options="header"]
+|===
+|Class |What it means |What to do
+
+|Provided by a layer
+|The layer implements this library's API itself: the JavaFX modules,
+SwingX, FlatLaf and RSyntaxTextArea.
+|Keep the dependency with the `provided` scope. The sources compile against
+the real jar and the layer ships in its place.
+
+|User interface library
+|A layout manager such as MigLayout, an icon library, a component set.
+|Keep it with the `compile` scope. Its classes are bundled, relocated and
+checked with the application.
+
+|Plain Java
+|A library that isn't about user interfaces.
+|Keep it with the `compile` scope. Only the classes the application reaches
+ship.
+
+|Codename One library, or resources only
+|A Codename One library, a font or an icon pack.
+|Nothing.
+|===
+
+A library that loads native code, or uses JNA, gets a warning, because
+that code has no counterpart on a phone.
+
+==== Use the Codename One equivalent
+
+Where Codename One has an equivalent, the port report names it next to the
+finding. The common ones:
+
+[cols="1,2",options="header"]
+|===
+|Desktop API |Use instead
+
+|`java.net.http`, `HttpURLConnection`
+|`Rest` or `ConnectionRequest`. For code written against `java.net.URL`,
+`com.codename1.io.URL` has the same shape, with `openConnection` and
+`openStream`. A REST API maps onto a typed `@RestClient` interface whose
+code is generated at build time, or onto one generated from its OpenAPI
+specification (<<_generate_openapi_client_generate_openapi>>).
+
+|`ProcessBuilder`, `Runtime.exec`
+|Supported on the desktop targets through Codename One's process API,
+`com.codename1.io.ProcessBuilder` and `Process`, which has the JavaSE shape
+(<<processes>>). Phones and the browser have no processes: to open a URL, a
+file or another application there, use `CN.execute(url)` after
+`CN.canExecute(url)`, or `Desktop.getDesktop().open(file)` and
+`browse(uri)` from Swing code.
+
+|`java.math.BigDecimal`, `BigInteger`
+|`com.codename1.util.BigDecimal` and `BigInteger`
+
+|`javax.crypto`
+|The ciphers, MACs and key generators of `com.codename1.security`
+
+|`java.sql`
+|`com.codename1.db.Database`, SQLite on every platform, or the ORM over it
+(<<annotation-orm-section>>)
+
+|Java serialization
+|`Externalizable` with `Storage`
+
+|Reflection over bean properties
+|`PropertyBusinessObject`. Codename One doesn't support reflection: it
+defeats ahead-of-time compilation and obfuscation, which both need to see
+every class and member the code uses. Avoid it in new code.
+
+|A JSON library that binds by reflection
+|`@Mapped` classes with `Mappers.toJson` and `Mappers.fromJson`. The mapping
+code is generated at build time and uses no reflection, so it's faster and
+smaller; see <<annotation-mapping-section>>. `JSONParser` reads JSON with no
+model class at all.
+
+|A file watch service
+|Poll on a background thread with `java.util.Timer`.
+
+|JNA, `System.loadLibrary`
+|A `NativeInterface` with an implementation for each platform
+
+|`Runtime.addShutdownHook`
+|The `stop` and `destroy` methods of the application's main class
+|===
+
+==== Isolate what a phone can't do
+
+What remains is functionality a phone can't provide in the same form. Put
+it behind an interface the application owns, keep the desktop
+implementation in the desktop project, and give the Codename One build an
+implementation that uses the Codename One API, a server, or nothing:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/ExternalTools.java[tag=desktopInteropIsolate,indent=0]
+----
+
+This is where most of a large port's time goes. An application whose
+screens call straight into its services needs that seam before the seam
+can get a second implementation. An application that already separates its
+screens from its services has it, and its port is mostly the first two
+steps.
+
+[[desktop-interop-behavior]]
+=== Styling and theming
+
+Codename One styles an application with CSS. A `theme.css` file in the
+project is compiled into a `.res` theme when the application is built, so
+the device reads a compact binary theme and never parses a style sheet. In
+the simulator the theme is rebuilt each time the file is saved, and the
+running application restyles at once. There is no look-and-feel class to
+write and no skin to subclass: every component has a UIID, and a CSS rule
+for that UIID styles it on every platform, with native themes for iOS,
+Android and the desktops underneath. The <<_css>> chapter covers the syntax
+and <<native-modern-themes>> the themes it builds on.
+
+This differs from both desktop toolkits. A Swing look and feel is Java
+code, UI delegates that paint each widget, chosen at run time. JavaFX
+reads its CSS at run time and applies it to skins. In Codename One the
+styling is data, settled at build time, and the same for every
+platform.
+
+A ported application uses this model in three ways.
+
+[[desktop-interop-theme]]
+==== Swing look and feel becomes a palette
+
+The standard widgets are Codename One components: a `JButton` is a Codename
+One button, a `JTextField` is the platform's text field with its own
+keyboard, selection and autocorrection, and the same holds for labels,
+check boxes, combo boxes, sliders, progress bars and tabs. They take the
+theme of the platform they run on.
+
+`UIManager.setLookAndFeel` accepts any look and feel, so the usual call at
+the top of `main` runs unchanged and selects a light or a dark palette:
+`FlatDarkLaf` and other dark themes select the dark one, `null` or the
+system look and feel follows the platform's own setting. Switching while
+windows are open restyles them at once. `UIManager` colors and fonts the
+application puts are kept and used, and the ones it reads answer from the
+palette.
+
+FlatLaf's entry points are part of the layer, so an application written
+against FlatLaf runs without the FlatLaf jar: `setup()`, the dark and light
+themes, the accent color, style classes and common client properties such
+as `JTextField.placeholderText`.
+
+On a desktop, the `desktop.themeMode` build hint chooses the theme the
+packaged application uses, and `native` selects the theme of the machine it
+runs on:
+
+[source,properties]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.properties[tag=desktop-interop-properties-003,indent=0]
+----
+
+The native macOS build reads `macos.themeMode` instead. Both are described
+under <<_desktop_themes>>.
+
+==== JavaFX style sheets compile with the application
+
+JavaFX style sheets under `src/main/desktop/resources` are compiled when
+the application is built, like the application's own CSS, into a compact
+table that the runtime applies. Type, class, id and pseudo-class selectors,
+the descendant and child relations, the cascade, inline `setStyle`,
+looked-up colors and `@font-face` work as in JavaFX:
+
+[source,text]
+----
+include::../demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.css[tag=desktopInteropFxCss,indent=0]
+----
+
+A property or selector the layer doesn't style is a build warning with the
+file and line, and the rule is left out, which is what JavaFX itself does
+with a property it doesn't know. Redefining a theme color such as
+`-fx-base` or `-fx-accent` recolors the controls the layer draws itself.
+
+==== Codename One CSS styles the whole application
+
+The application's `theme.css` styles the Codename One components that the
+Swing and JavaFX widgets are, so one rule changes a button, a text field or
+a dialog across the whole application on every platform. Use it for
+anything that should look the same across screens; use the desktop styling
+for what's particular to one screen.
+
+==== Custom painting
+
+A Swing component that overrides `paintComponent` paints as it does on the
+desktop, through a `Graphics2D` with shapes, strokes, paints, clipping and
+an affine transform:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/BadgePanel.java[tag=desktopInteropSwingPaint,indent=0]
+----
+
+In JavaFX, shapes, `Text`, paths, gradients, transforms and the shadow
+effects are drawn by the layer, and a `Canvas` replays its drawing calls
+when it paints, so it stays sharp at any display density.
+
+=== On a phone and on the desktop
+
+==== Logical pixels
+
+Desktop code sizes things in pixels and assumes about 96 of them to the
+inch. The layers treat every Swing and JavaFX coordinate as a _logical
+pixel_ of 1/96 inch and scale it to the display, so a 24 pixel row is the
+same physical height on a phone as on a desktop monitor. A phone is about
+400 logical pixels across, so a layout designed for a 1024 pixel window is
+much wider than the screen. Layout managers and panes that adapt to the
+available width keep working; fixed sizes and `null` layouts need the
+attention they would need in a small desktop window.
+
+A window whose content can't shrink to the display keeps its minimum size
+and the user pans across it with a drag. A `FlowLayout` row and a
+horizontal `JToolBar` wrap instead of being cut off. A JavaFX scene whose
+root is a layout pane reflows to the screen as it does when its window is
+resized.
+
+==== Windows, dialogs and menus
+
+The first `JFrame` or `Stage` fills the screen. On the desktop ports each
+further frame or stage is a real window with the size, position and title
+the application gave it. On a phone or tablet a further frame is a form
+shown over the one before it, with a back command, and a dialog floats over
+the current form.
+
+A modal dialog blocks its caller as it does on the desktop.
+`JOptionPane.showMessageDialog`, a modal `JDialog`, and `showAndWait()` on a
+JavaFX `Alert` all return after the user answers, while painting and input
+continue, so code written as a sequence of questions needs no
+restructuring:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/GreeterApp.java[tag=desktopInteropSwingApp,indent=0]
+----
+
+On the desktop a `JMenuBar` is drawn in the window. On a phone its items
+become commands in the form's overflow menu, and their accelerators become
+shortcuts.
+
+[[desktop-interop-input]]
+==== Mouse, touch and keyboard
+
+The same listeners run on every device:
+
+[cols="1,2,2",options="header"]
+|===
+|Input |On a desktop |On a phone or tablet
+
+|Press, drag, release
+|The mouse, with its buttons and modifiers.
+|A finger, as the primary button.
+
+|Secondary click
+|The secondary button. `JPopupMenu` and `ContextMenu` open on it.
+|A long press opens the same menus.
+
+|Hover and wheel
+|Follow the pointer and the wheel.
+|None. Scroll panes follow a drag.
+
+|Touch events
+|None.
+|JavaFX receives a `TouchEvent` before each mouse event, and a
+`SwipeEvent` for a quick drag.
+
+|Keys
+|The keyboard.
+|The on-screen keyboard, typing into the text component being edited.
+|===
+
+`CN.isDesktop()` answers which kind of device the application is on, so a
+feature that lives behind a hover or a key binding can offer a second way
+in on a phone.
+
+[[desktop-interop-settings]]
+==== Display properties
+
+Three display properties adjust how a desktop application maps onto a
+device. Set them with `CN.setProperty` before the first window opens, for
+example in the generated main class or at the top of `main`:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/DeviceSettings.java[tag=desktopInteropDisplayProperties,indent=0]
+----
+
+[cols="1,1,3",options="header"]
+|===
+|Property |Value |Effect
+
+|`desktopcompat.scale`
+|A number
+|The device pixels each logical pixel takes. Without it, the display's
+density against 96 dots per inch.
+
+|`desktopcompat.menuBar`
+|`window` or `commands`
+|Draw a `JMenuBar` in the frame on every device, or turn its items into
+commands on every device.
+
+|`desktopcompat.monospaced`
+|`Font Name\|file.ttf`
+|A fixed-width TrueType font the application ships, used for the
+`Monospaced` family.
+|===
+
+==== Threading
+
+The Swing event dispatch thread, the JavaFX application thread and the
+Codename One EDT are one thread. `SwingUtilities.invokeLater`,
+`Platform.runLater`, `javax.swing.Timer` and the JavaFX animation classes
+run there. Long work belongs on another thread, as on the desktop:
+`SwingWorker` and a JavaFX `Task` or `Service` run their work in the
+background and deliver results on the EDT:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/LoadNames.java[tag=desktopInteropSwingWorker,indent=0]
+----
+
+==== Resources and libraries
+
+`getClass().getResource(...)`, `getResourceAsStream(...)`,
+`ResourceBundle.getBundle` and `ServiceLoader` work: the build packages the
+files under `src/main/desktop/resources` and records where each one came
+from. `ImageIcon`, `ImageIO.read` and the JavaFX `Image` decode PNG and
+JPEG through the platform.
+
+A library written against Swing or JavaFX, such as MigLayout or a
+component set, goes in the `common` module with the `compile` scope:
+
+[source,xml]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.xml[tag=desktop-interop-xml-001,indent=0]
+----
+
+The build bundles it into the application and relinks it with the
+application's own classes, and the check for unsupported API covers it too.
+The layer itself supplies FlatLaf and RSyntaxTextArea; keep those two
+dependencies as they are.
+
+=== FXML
+
+FXML documents are compiled when the application is built, into classes
+that build the same node tree with plain constructors and setters. The
+application loads a document the way it does on the desktop:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterFxApp.java[tag=desktopInteropFxmlLoad,indent=0]
+----
+
+[source,xml]
+----
+include::../demos/desktop-interop/src/main/resources/com/codenameone/developerguide/desktopinterop/javafx/greeter.fxml[tag=desktopInteropFxml,indent=0]
+----
+
+The controller's `@FXML` fields and handlers can stay private, and
+`initialize()` runs after they're set. The build writes direct code for
+the assignments, so no reflection is involved:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/GreeterController.java[tag=desktopInteropFxmlController,indent=0]
+----
+
+Imports, `fx:include`, `fx:define`, `fx:root`, `%key` strings from a
+resource bundle, `@path` locations and `${...}` bindings to a property all
+work, and so does an application's own control used as an element. Because
+every class and property a document names is checked when it compiles, the
+build reports a typo with the file, line, and column, where the desktop
+would only find it when loading the document. A JavaFX application that builds its scene
+in code needs none of this:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/CounterApp.java[tag=desktopInteropJavaFxApp,indent=0]
+----
+
+=== Supported API
+
+The tables list the main classes of each area. The exact answer for an
+application is in its port report (<<desktop-interop-port-report>>), which
+counts the calls that are supported.
+
+==== Swing and AWT
+
+[cols="1,3",options="header"]
+|===
+|Area |Classes
+
+|Windows and dialogs
+|`JFrame`, `JDialog`, `JWindow`, `JOptionPane`, `JFileChooser`,
+`JColorChooser`, `ProgressMonitor`, `JRootPane` and `JLayeredPane`
+
+|Internal frames
+|`JDesktopPane` and `JInternalFrame`
+
+|Containers
+|`JPanel`, `JScrollPane`, `JSplitPane`, `JTabbedPane`, `JToolBar` and `Box`
+
+|Buttons and labels
+|`JLabel`, `JButton`, `JToggleButton`, `JCheckBox`, `JRadioButton`,
+`ButtonGroup` and `ImageIcon`, with simple HTML in their text
+
+|Text
+|`JTextField`, `JPasswordField`, `JFormattedTextField`, `JTextArea`,
+`JEditorPane`, `JTextPane` with styled documents, document filters and
+listeners, and `javax.swing.undo`
+
+|Lists and values
+|`JList`, `JComboBox`, `JSpinner`, `JSlider`, `JProgressBar` and
+`JSeparator`, with their models and renderers
+
+|Tables and trees
+|`JTable` with `javax.swing.table` and `TableRowSorter`; `JTree` with
+`javax.swing.tree`
+
+|Menus and actions
+|`JMenuBar`, `JMenu`, the menu items, `JPopupMenu`, `Action`, `KeyStroke`,
+`InputMap` and `ActionMap`
+
+|Layout managers
+|`BorderLayout`, `FlowLayout`, `GridLayout`, `GridBagLayout`, `CardLayout`,
+`BoxLayout`, `GroupLayout`, `SpringLayout` and `OverlayLayout`
+
+|Borders
+|Every class of `javax.swing.border`, and `BorderFactory`
+
+|Painting
+|`Graphics2D`, `Color`, `Font`, `BasicStroke`, `GradientPaint`,
+`AlphaComposite`, the shapes and `AffineTransform` of `java.awt.geom`,
+`BufferedImage` and `ImageIO`
+
+|Events
+|The listeners and events of `java.awt.event` and `javax.swing.event`, key
+bindings, focus traversal and `java.beans` property change support
+
+|Threading
+|`SwingUtilities`, `EventQueue`, `SwingWorker` and `javax.swing.Timer`
+
+|Services
+|`Toolkit`, `Desktop` (`browse`, `mail` and `open`), the text clipboard,
+`Cursor`, `UIManager`, dragging and dropping, and `Font.createFont` for a shipped
+font
+|===
+
+==== SwingX
+
+[cols="1,3",options="header"]
+|===
+|Area |Classes
+
+|Components
+|`JXTable`, `JXTreeTable`, `JXList`, `JXTree`, `JXDatePicker`,
+`JXMonthView`, `JXTaskPane`, `JXCollapsiblePane`, `JXTitledPanel`,
+`JXHeader`, `JXStatusBar`, `JXHyperlink`, `JXBusyLabel`, `JXSearchField`,
+`JXErrorPane` and the `JX` versions of the basic components
+
+|Rendering
+|Highlighters, the renderer providers, `StringValue` and `IconValue`, and
+painters
+
+|Other
+|`HorizontalLayout` and `VerticalLayout`, sort controllers, `RowFilters`,
+`TableColumnExt`, `PromptSupport` and `AbstractBean`
+|===
+
+==== JavaFX
+
+[cols="1,3",options="header"]
+|===
+|Area |Classes
+
+|Application and windows
+|`Application`, `Platform`, `HostServices`, `Stage`, `Screen` and
+`FileChooser`
+
+|Layout panes
+|`Pane`, `HBox`, `VBox`, `BorderPane`, `StackPane`, `GridPane`, `FlowPane`,
+`TilePane`, `AnchorPane` and `Region`
+
+|Controls
+|`Label`, the buttons, `TextField`, `TextArea`, `ComboBox`, `ChoiceBox`,
+`DatePicker`, `ColorPicker`, `Spinner`, `Slider`, `ProgressBar`,
+`ScrollPane`, `SplitPane`, `TabPane`, `TitledPane`, `Accordion`, `ToolBar`,
+`Pagination`, `ListView`, `TableView`, `TreeView` and `Tooltip`
+
+|Charts
+|`LineChart`, `AreaChart`, `BarChart`, `ScatterChart` and `PieChart`
+
+|Menus and dialogs
+|`MenuBar`, `ContextMenu`, `Alert`, `Dialog`, `ChoiceDialog` and
+`TextInputDialog`
+
+|Properties and collections
+|`javafx.beans.property`, `Bindings`, `ObservableList`, `FXCollections`,
+`FilteredList` and `SortedList`
+
+|Graphics
+|Shapes, paths, `SVGPath`, `Text`, `TextFlow`, gradients, `DropShadow` and
+`InnerShadow`, transforms, `Canvas`, `Image`, `WritableImage` and
+`Node.snapshot`
+
+|Animation
+|`Timeline`, `AnimationTimer` and the transitions
+
+|Concurrency
+|`Task`, `Service` and `Worker`
+
+|FXML and styling
+|`FXMLLoader`, `@FXML`, style classes, inline styles, `PseudoClass` and
+style sheets
+|===
+
+[[desktop-interop-codename-one-api]]
+=== Calling Codename One from desktop code
+
+The desktop sources compile in the `common` module, next to the Codename One
+API, so they can call it directly. That's how a ported application adapts
+to the device it runs on, and how it reaches the camera, the database,
+push notifications and the rest of <<desktop-interop-motivation>>:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/CompactLayout.java[tag=desktopInteropCodenameOneApi,indent=0]
+----
+
+Code that uses Codename One classes no longer compiles in the original
+desktop project. Keep such calls behind a small class of your own if the
+application must go on building for a desktop JVM too.
+
+[[desktop-interop-mixing]]
+=== Mixing with Codename One code
+
+A Codename One application can use Swing and JavaFX screens without handing
+them the whole application. Put the desktop sources in
+`common/src/main/desktop` as usual, and have the main class show Codename
+One forms instead of calling the desktop application's `main`.
+
+`SwingInterop.asComponent` wraps a Swing component in a Codename One
+component that you add to a form like any other:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/EmbeddedReport.java[tag=desktopInteropEmbedSwing,indent=0]
+----
+
+`FxInterop.asComponent` does the same for the root of a JavaFX scene graph,
+or for a `Scene` when the screen needs style sheets:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/EmbeddedChart.java[tag=desktopInteropEmbedFx,indent=0]
+----
+
+Both take an `Object` and throw an `IllegalArgumentException` for anything
+other than a Swing component, a JavaFX parent or a scene. Call them on the
+EDT.
+
+Frames, stages and modal dialogs work from Codename One code too. A frame
+or a stage opens as a form over the current one, and closing it returns
+there:
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/swing/EmbeddedReport.java[tag=desktopInteropSwingWindows,indent=0]
+----
+
+[source,java]
+----
+include::../demos/desktop-interop/src/main/java/com/codenameone/developerguide/desktopinterop/javafx/EmbeddedChart.java[tag=desktopInteropFxWindows,indent=0]
+----
+
+On the desktop ports these windows are real windows.
+`SwingInterop.setNativeWindows(false)` and
+`FxInterop.setNativeWindows(false)` keep them inside the application's own
+window instead, as on a phone.
+
+[[desktop-interop-testing]]
+=== Testing a ported application
+
+The application's logic is tested as any Codename One application's is,
+with `mvn cn1:test` or `./gradlew cn1Test`. Test classes aren't relinked, so
+a unit test exercises the classes that don't touch the toolkit: models,
+parsers and the services behind the interfaces of
+<<desktop-interop-porting>>. The tests that came with the desktop project
+stay there and keep running on the JVM.
+
+Then run the application in the simulator with a phone, a tablet and the
+desktop skin. Most of what a port gets wrong is visible there in a minute:
+a window that pans because it can't shrink, a table whose columns no longer
+fit, a feature reachable only from a hover or a key binding.
+
+To prove that the screens respond to a real pointer, the Codename One
+source tree carries a harness in
+`maven/integration-tests/desktop-compat-realport`. It starts a built
+application on the JavaSE port and plays a script of clicks, drags and keys
+with the display server's own input, and it fails when anything throws or
+when a step changes nothing on the screen. A script has one step on a line,
+and a position is a fraction of the application's area:
+
+----
+# Wait for the first screen, then keep a picture of it.
+sleep 4000
+shot start
+click 0.061 0.268
+type bc
+key TAB
+drag 0.536 0.573 0.640 0.573 400
+# Moving the pointer isn't expected to change anything.
+quiet move 0.5 0.5
+----
+
+Run it against the `common` module of a built application, under
+`xvfb-run` on a machine you're working on:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-008,indent=0]
+----
+
+`swing-gallery.txt` and `javafx-gallery.txt` beside the harness are
+complete scripts to start from.
+
+[[desktop-interop-native]]
+=== Native desktop builds
+
+The same project builds a native executable for Linux, macOS, and Windows.
+The application, the part of the layers it uses and the part of Codename
+One it uses are translated to C and compiled into one program with no Java
+runtime beside it:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-006,indent=0]
+----
+
+Each port has a chapter with its toolchain, build hints, signing and
+packaging: <<_building_a_native_linux_app>>,
+<<_native_macos_build_appkit>> and <<_building_a_native_windows_app>>. A
+ported application needs nothing beyond what those chapters ask of any
+application. On these ports a `JMenuBar` is drawn in its frame, the mouse,
+wheel and keyboard modifiers are reported, and every further `JFrame` and
+`Stage` is a real window (see <<_desktop_windows>>).
+
+[[desktop-interop-benchmarks]]
+==== Size, memory and start-up
+
+This section measures what the user downloads, how soon the window appears
+and how much memory the application holds, for the same sources built two
+ways:
+
+[cols="1,2,2",options="header"]
+|===
+| |On a JVM |Native build
+
+|Sources
+|The application's own, unmodified
+|The same, imported
+
+|Runtime
+|A `jlink` image of exactly the modules `jdeps` names, stripped and
+compressed
+|None
+
+|Toolkit
+|The JDK's Swing, or OpenJFX
+|Codename One's Swing or JavaFX layer over the native port
+|===
+
+The JVM runs in two configurations. _Default_ is the image as built, with
+its class data sharing archive. _Tuned_ is what a developer who cared about
+start-up and footprint would ship: the serial collector, a smaller thread
+stack, the first compiler tier only, an application class data sharing
+archive and the smallest heap the application runs in.
+
+Eight applications were measured: the `swing-gallery` and `javafx-gallery`
+samples in the Codename One source tree, the JDK's SwingSet2 and Notepad
+demos, and four small open-source applications. Every comparison is like
+for like. Both builds of an application ran on the same machine, and each
+size compares one architecture with the same architecture: on macOS the
+native application is measured with the arm64 slice of its executable
+only, the architecture of the `jlink` runtime it's compared with. In each
+ratio the JVM's figure is divided by the native build's, so a figure above
+1 favors the native build.
+
+*Size* is bytes on disk, and bytes as one zip at the highest deflate level,
+which is close to what a download costs. *Start-up* is the time from the
+start of the process to the first painted frame, the median of seven
+launches. *Memory* is summed over the process tree, ten seconds after the
+first frame and again after a short script of input. *CPU while idle* is
+the processor time of an application waiting for input.
+
+include::desktop-compat-benchmarks.adoc[]
+
+The Linux display is a software framebuffer for both builds, and start-up
+and memory were measured on Linux only. Figures move with what an
+application does at start-up, so measure your own.
+
+===== Measuring your own application
+
+The harness that produced the tables is in the Codename One source tree,
+under `scripts/desktop-compat-benchmarks`, and takes any Swing or JavaFX
+project. It builds the application both ways, measures both and writes one
+`result.json`, which `report.py` turns into tables:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-009,indent=0]
+----
+
+The `README.md` in that directory lists what it needs. The phone sizes come
+from a second script, run against the project the first one imported:
+
+[source,bash]
+----
+include::../demos/common/src/main/snippets/developer-guide/desktop-interop.sh[tag=desktop-interop-bash-010,indent=0]
+----
+
+[[desktop-interop-troubleshooting]]
+=== Troubleshooting
+
+Each entry is a symptom and what to do about it.
+
+==== Building
+
+[cols="2,3",options="header"]
+|===
+|Symptom |What to do
+
+|The build names API the Swing or JavaFX layer doesn't support.
+|Replace the call with one the layer has, or move the feature behind an
+interface (<<desktop-interop-porting>>). The full list is in
+`common/target/codenameone/compliance_check.txt`.
+
+|The message points at a library, not at your code.
+|If the application doesn't need that part of the library, exclude the
+library and replace what you used from it.
+
+|The build reports `java.awt` or `javax.swing` references and suggests
+enabling the layer.
+|The sources that use the toolkit are outside `src/main/desktop`. Move them
+to `common/src/main/desktop/java`.
+
+|The import stops because it can't choose an entry point.
+|Pass `-Dcn1.desktop.mainClass` to the import goal.
+
+|`src/main/desktop` exists but a runtime dependency is missing.
+|The `common/pom.xml` predates the desktop layers. Run the import goal,
+which adds the profile.
+
+|Kotlin sources under `src/main/desktop/kotlin` aren't compiled.
+|Create `common/src/main/kotlin`, whose presence switches on the Kotlin
+build. The import goal does this for you.
+
+|Two resources have the same name after packaging.
+|Rename one of them.
+
+|A style sheet warning says a property or selector is ignored.
+|Style that detail in the application's `theme.css`, or remove the rule.
+|===
+
+[[desktop-interop-jdk]]
+==== JDK API
+
+[cols="2,3",options="header"]
+|===
+|Symptom |What to do
+
+|`java.lang.reflect`, `Class.getMethod` or a similar call is a build error.
+|Replace reflection with code: `PropertyBusinessObject` for bean
+properties, `@Mapped` for JSON, an interface for plugins.
+
+|Code that loads classes by name with `Class.forName` fails on Android or
+in the browser.
+|Those builds are obfuscated and keep only the classes something
+references, so a name in a string finds nothing. Reference the class
+directly, or register it in code.
+
+|`ObjectOutputStream` or `ObjectInputStream` is a build error.
+|Use `Externalizable` with `Storage`, or `@Mapped` JSON.
+
+|`HttpURLConnection`, `java.net.http` or sockets are a build error.
+|Use `Rest`, `ConnectionRequest` or `com.codename1.io.URL`.
+
+|Starting a process throws `UnsupportedOperationException` on a phone.
+|Processes run on the desktop targets. Check `ProcessBuilder.isSupported()`
+and offer the feature where it answers `true` (<<processes>>).
+
+|`java.math`, `javax.crypto`, `java.sql` or `java.util.zip.ZipFile` is a
+build error.
+|Use the equivalents in <<desktop-interop-porting>>. The zip and GZIP
+streams work unchanged.
+
+|A relative path or a relative `file:` URL finds nothing.
+|A device has no working directory. Relative paths resolve inside the
+application's storage; ship read-only files as resources.
+
+|`System.getenv` answers `null`.
+|A device has no environment. Use display properties or build hints.
+
+|`Pattern.compile` throws for an advanced pattern.
+|Unicode script and block classes beyond the common ones and unbounded
+look-behind aren't supported. Simplify the pattern.
+
+|A `Locale` used as a map key isn't found.
+|Key the map by the locale's string form.
+|===
+
+==== Running
+
+[cols="2,3",options="header"]
+|===
+|Symptom |What to do
+
+|A method the application overrides is never called.
+|The layer's class doesn't call it, and the build can't see an override.
+Find another hook the layer does call, such as a renderer or a listener.
+
+|A keyboard shortcut does nothing.
+|Function keys and Home, End, Page Up, Page Down and Insert aren't reported,
+and a phone reports no modifiers. Give the action a menu item or a button
+too.
+
+|The window pans sideways on a phone.
+|Something in it has a minimum width larger than the display. Use a layout
+that wraps or stacks, put the wide part in a scroll pane, or lower
+`desktopcompat.scale`.
+
+|Text is wider or narrower than on the desktop.
+|Fonts are the platform's and measure differently. Let a layout manager
+size the component.
+
+|A JavaFX blur or glow isn't drawn.
+|Use `DropShadow` or `InnerShadow`, which are.
+
+|A JavaFX combo box can't be typed into.
+|`ComboBox` and `ChoiceBox` open the platform's picker. Use a `TextField`
+where the user types.
+
+|An image from a relative `file:` URL is missing.
+|Load it as a resource. `Image.isError()` says whether it was found.
+|===
diff --git a/docs/developer-guide/desktop-compat-benchmarks.adoc b/docs/developer-guide/desktop-compat-benchmarks.adoc
new file mode 100644
index 00000000000..f3d97bd6cc2
--- /dev/null
+++ b/docs/developer-guide/desktop-compat-benchmarks.adoc
@@ -0,0 +1,267 @@
+// Written by desktop-compat-benchmarks.py from measured results. Change the results and run it again;
+// an edit made here is lost. Desktop-Interop.asciidoc includes this file once, whole.
+
+image::img/desktop-compat-linux-size.svg["Bar chart of the installed size of each application on Linux: the native build beside the jlink image",scaledwidth=90%]
+
+image::img/desktop-compat-linux-size-zipped.svg["Bar chart of the zipped size of each application on Linux: the native build beside the jlink image",scaledwidth=90%]
+
+.Linux: the distributed application (MB)
+[cols="<3,<1,>1,>1,>1,>1,>1,>1,>1",options="header"]
+|===
+|Application |Toolkit |`jlink` image |`jlink` image, zipped |`jpackage` image, zipped |Native build |Native build, zipped |JVM image / native build |JVM zip / native zip
+
+|`swing-gallery` sample |Swing |56.3 |34.6 |34.8 |19.6 |7.2 |2.9x |4.8x
+
+|SwingSet2, the JDK demo |Swing |55.6 |34.1 |34.2 |20.5 |8.2 |2.7x |4.2x
+
+|Notepad, the JDK demo |Swing |54.3 |32.8 |32.9 |17.7 |6.5 |3.1x |5.0x
+
+|Falling-blocks game |Swing |54.1 |32.7 |32.8 |17.4 |6.4 |3.1x |5.1x
+
+|`javafx-gallery` sample |JavaFX |61.6 |39.1 |39.2 |19.4 |7.1 |3.2x |5.5x
+
+|Open-source 2048 game |JavaFX |61.6 |39.1 |39.3 |18.3 |6.7 |3.4x |5.8x
+
+|Address book |JavaFX |61.5 |39.1 |39.2 |17.8 |6.5 |3.5x |6.0x
+
+|Mandelbrot explorer |JavaFX |61.3 |38.9 |39.0 |17.7 |6.5 |3.5x |6.0x
+|===
+
+The `jlink` image is the application with the smallest Java runtime that runs it: the application's jars and the modules `jlink` found it to need. The native build is one executable file with nothing beside it. Both rely on the desktop libraries of the system, X11 and, for the native build and for JavaFX, GTK; neither column counts them.
+
+Against the `jlink` image as installed the native build is smaller in 8 applications, of the 8 measured. Its best result is 3.5x for Mandelbrot explorer (17.7 MB against 61.3 MB).
+
+Against the zipped `jlink` image the native build is smaller in 8 applications, of the 8 measured. Its best result is 6.0x for Mandelbrot explorer (6.5 MB against 38.9 MB).
+
+image::img/desktop-compat-macos-size.svg["Bar chart of the installed size of each application on macOS: the native application for arm64 beside the arm64 jlink image",scaledwidth=90%]
+
+.macOS: the distributed application (MB)
+[cols="<3,>1,>1,>1,>1,>1,>1,>1",options="header"]
+|===
+|Application |`jlink` image, arm64 |`jlink` image, zipped |Native `.app`, arm64 |Native `.app`, zipped |Universal `.app` |JVM image / native `.app` |JVM zip / native zip
+
+|`swing-gallery` sample |51.4 |32.5 |25.7 |8.7 |49.6 |2.0x |3.7x
+
+|SwingSet2, the JDK demo |50.7 |32.0 |26.4 |9.8 |49.5 |1.9x |3.3x
+
+|Notepad, the JDK demo |49.4 |30.7 |23.4 |8.0 |44.9 |2.1x |3.9x
+
+|Falling-blocks game |49.3 |30.6 |23.0 |7.8 |44.2 |2.1x |3.9x
+
+|`javafx-gallery` sample |57.1 |37.1 |25.5 |8.6 |49.2 |2.2x |4.3x
+
+|Open-source 2048 game |57.1 |37.1 |24.0 |8.1 |46.0 |2.4x |4.6x
+
+|Address book |57.0 |37.0 |23.4 |7.9 |45.0 |2.4x |4.7x
+
+|Mandelbrot explorer |56.8 |36.9 |23.2 |7.9 |44.6 |2.5x |4.7x
+|===
+
+Both sides are built for arm64: the `jlink` image holds the arm64 runtime, and the native `.app` is the bundle with the arm64 slice of its executable only. The builder's default output is universal, with an x86_64 slice beside it; its size is in the last size column.
+
+Against the `jlink` image as installed the native build is smaller in 8 applications, of the 8 measured. Its best result is 2.5x for Mandelbrot explorer (23.2 MB against 56.8 MB).
+
+Against the zipped `jlink` image the native build is smaller in 8 applications, of the 8 measured. Its best result is 4.7x for Mandelbrot explorer (7.9 MB against 36.9 MB).
+
+.iOS and Android: the distributed application (MB)
+[cols="<3,>2,>2,>2,>2,>2,>2",options="header"]
+|===
+|Application |iOS `.app` |iOS `.app`, zipped |iOS executable, stripped |Android APK |APK, unpacked |Of which dex
+
+|`swing-gallery` sample |28.1 |9.4 |18.2 |3.0 |5.8 |3.9
+
+|SwingSet2, the JDK demo |28.7 |10.5 |17.6 |4.4 |7.2 |3.8
+
+|Notepad, the JDK demo |25.6 |8.7 |16.3 |2.9 |5.5 |3.5
+
+|Falling-blocks game |25.1 |8.6 |16.1 |2.8 |5.3 |3.4
+
+|`javafx-gallery` sample |27.8 |9.3 |18.0 |3.1 |5.9 |4.0
+
+|Open-source 2048 game |26.1 |8.9 |16.7 |3.1 |6.0 |3.8
+
+|Address book |25.4 |8.6 |16.5 |3.0 |5.8 |3.9
+
+|Mandelbrot explorer |25.3 |8.6 |16.3 |2.9 |5.5 |3.6
+|===
+
+.How much of the toolkit layer an application keeps
+[cols="<3,<2,>1,>1,>1",options="header"]
+|===
+|Application |Toolkit |Classes in the layer |Classes in the native build |Kept
+
+|`swing-gallery` sample |Swing and AWT |1039 |737 |71%
+
+|SwingSet2, the JDK demo |Swing and AWT |1039 |587 |56%
+
+|Notepad, the JDK demo |Swing and AWT |1039 |566 |54%
+
+|Falling-blocks game |Swing and AWT |1039 |538 |52%
+
+|`javafx-gallery` sample |JavaFX |901 |688 |76%
+
+|Open-source 2048 game |JavaFX |894 |413 |46%
+
+|Address book |JavaFX |896 |461 |51%
+
+|Mandelbrot explorer |JavaFX |896 |442 |49%
+|===
+
+.Linux: warm start, from process start to the first painted frame (ms, median with the range)
+[cols="<3,>2,>2,>2,>2,>2",options="header"]
+|===
+|Application |JVM, default |JVM, tuned |Native build |Default / native |Tuned / native
+
+|`swing-gallery` sample |326 (316-336) |194 (193-195) |96 (40-104) |3.4x |2.0x
+
+|SwingSet2, the JDK demo |220 (205-221) |145 (144-157) |56 (54-84) |3.9x |2.6x
+
+|Notepad, the JDK demo |175 (170-187) |123 (107-134) |55 (54-77) |3.2x |2.2x
+
+|Falling-blocks game |102 (101-119) |70 (69-72) |74 (54-102) |1.4x |0.9x
+
+|`javafx-gallery` sample |603 (589-617) |408 (386-428) |100 (97-110) |6.0x |4.1x
+
+|Open-source 2048 game |307 (271-326) |190 (160-205) |77 (44-100) |4.0x |2.5x
+
+|Address book |407 (389-452) |238 (233-266) |74 (56-88) |5.5x |3.2x
+
+|Mandelbrot explorer |392 (373-424) |214 (202-231) |86 (76-94) |4.6x |2.5x
+|===
+
+Against the default JVM the native build is quicker in 8 applications, of the 8 measured. Its best result is 6.0x for `javafx-gallery` sample (100 ms against 603 ms).
+
+Against the tuned JVM the native build is quicker in 7 applications and slower in 1 application, of the 8 measured. Its best result is 4.1x for `javafx-gallery` sample (100 ms against 408 ms). Its worst is 0.9x for Falling-blocks game (74 ms against 70 ms).
+
+image::img/desktop-compat-linux-startup-cold.svg["Bar chart of the cold start of each application on Linux: the native build beside the default and the tuned JVM",scaledwidth=90%]
+
+.Linux: cold start, from process start to the first painted frame (ms, median with the range)
+[cols="<3,>2,>2,>2,>2,>2",options="header"]
+|===
+|Application |JVM, default |JVM, tuned |Native build |Default / native |Tuned / native
+
+|`swing-gallery` sample |364 (358-382) |216 (212-236) |108 (97-117) |3.4x |2.0x
+
+|SwingSet2, the JDK demo |245 (229-255) |168 (151-180) |90 (86-95) |2.7x |1.9x
+
+|Notepad, the JDK demo |199 (195-210) |137 (126-150) |90 (63-92) |2.2x |1.5x
+
+|Falling-blocks game |125 (124-140) |93 (91-99) |86 (65-90) |1.5x |1.1x
+
+|`javafx-gallery` sample |637 (631-654) |422 (415-432) |116 (109-120) |5.5x |3.6x
+
+|Open-source 2048 game |343 (308-355) |221 (206-226) |109 (107-128) |3.2x |2.0x
+
+|Address book |437 (428-477) |262 (258-269) |83 (63-88) |5.3x |3.2x
+
+|Mandelbrot explorer |423 (363-428) |238 (196-240) |92 (92-96) |4.6x |2.6x
+|===
+
+Against the default JVM the native build is quicker in 8 applications, of the 8 measured. Its best result is 5.5x for `javafx-gallery` sample (116 ms against 637 ms).
+
+Against the tuned JVM the native build is quicker in 8 applications, of the 8 measured. Its best result is 3.6x for `javafx-gallery` sample (116 ms against 422 ms).
+
+image::img/desktop-compat-linux-memory-idle.svg["Bar chart of the resident memory of each idle application on Linux: the native build beside the default and the tuned JVM",scaledwidth=90%]
+
+.Linux: memory 10 seconds after the first frame (MB, RSS / PSS)
+[cols="<3,>2,>2,>2,>2,>2",options="header"]
+|===
+|Application |JVM, default |JVM, tuned |Native build |Default RSS / native |Tuned RSS / native
+
+|`swing-gallery` sample |124.6 / 119.1 |84.2 / 78.6 |64.5 / 56.4 |1.9x |1.3x
+
+|SwingSet2, the JDK demo |130.1 / 126.0 |86.9 / 82.8 |89.8 / 81.3 |1.4x |1.0x
+
+|Notepad, the JDK demo |84.2 / 80.2 |62.2 / 58.2 |54.5 / 47.0 |1.5x |1.1x
+
+|Falling-blocks game |65.7 / 61.8 |52.6 / 48.6 |52.3 / 45.4 |1.3x |1.0x
+
+|`javafx-gallery` sample |285.9 / 258.1 |212.2 / 184.5 |91.7 / 83.3 |3.1x |2.3x
+
+|Open-source 2048 game |197.5 / 171.7 |152.4 / 126.6 |58.9 / 51.8 |3.4x |2.6x
+
+|Address book |233.6 / 207.4 |171.5 / 145.2 |55.6 / 48.3 |4.2x |3.1x
+
+|Mandelbrot explorer |263.0 / 236.0 |184.6 / 157.6 |120.1 / 112.3 |2.2x |1.5x
+|===
+
+Against the default JVM the native build is smaller in 8 applications, of the 8 measured. Its best result is 4.2x for Address book (55.6 MB against 233.6 MB).
+
+Against the tuned JVM the native build is smaller in 6 applications and within 5% of it in 2 applications, of the 8 measured. Its best result is 3.1x for Address book (55.6 MB against 171.5 MB).
+
+.Linux: memory after the scripted interaction (MB, RSS / PSS)
+[cols="<3,>2,>2,>2,>2,>2",options="header"]
+|===
+|Application |JVM, default |JVM, tuned |Native build |Default RSS / native |Tuned RSS / native
+
+|`swing-gallery` sample |118.4 / 112.9 |86.0 / 80.5 |90.8 / 81.8 |1.3x |0.9x
+
+|SwingSet2, the JDK demo |130.8 / 126.8 |87.0 / 83.0 |92.8 / 84.3 |1.4x |0.9x
+
+|Notepad, the JDK demo |91.0 / 87.0 |63.5 / 59.4 |58.2 / 50.6 |1.6x |1.1x
+
+|Falling-blocks game |68.3 / 64.4 |53.8 / 49.9 |54.3 / 47.4 |1.3x |1.0x
+
+|`javafx-gallery` sample |293.8 / 266.0 |213.3 / 185.5 |109.4 / 99.7 |2.7x |1.9x
+
+|Open-source 2048 game |208.3 / 182.4 |155.7 / 129.8 |100.0 / 93.0 |2.1x |1.6x
+
+|Address book |245.8 / 219.5 |172.6 / 146.3 |57.2 / 49.8 |4.3x |3.0x
+
+|Mandelbrot explorer |293.4 / 266.3 |197.6 / 170.6 |172.2 / 164.5 |1.7x |1.1x
+|===
+
+Against the default JVM the native build is smaller in 8 applications, of the 8 measured. Its best result is 4.3x for Address book (57.2 MB against 245.8 MB).
+
+Against the tuned JVM the native build is smaller in 5 applications, larger in 2 applications and within 5% of it in 1 application, of the 8 measured. Its best result is 3.0x for Address book (57.2 MB against 172.6 MB). Its worst is 0.9x for SwingSet2, the JDK demo (92.8 MB against 87.0 MB).
+
+.Linux: peak RSS over a whole session (MB)
+[cols="<3,>2,>2,>2,>2,>2,>2",options="header"]
+|===
+|Application |JVM, default |JVM, tuned |Native build |Default / native |Tuned / native |Tuned `-Xmx` (MB)
+
+|`swing-gallery` sample |128.5 |88.0 |90.1 |1.4x |1.0x |8
+
+|SwingSet2, the JDK demo |130.9 |87.2 |92.5 |1.4x |0.9x |24
+
+|Notepad, the JDK demo |92.9 |64.0 |57.7 |1.6x |1.1x |8
+
+|Falling-blocks game |70.3 |54.2 |53.9 |1.3x |1.0x |8
+
+|`javafx-gallery` sample |296.7 |215.8 |108.8 |2.7x |2.0x |48
+
+|Open-source 2048 game |211.5 |158.6 |125.5 |1.7x |1.3x |8
+
+|Address book |248.6 |175.3 |56.7 |4.4x |3.1x |48
+
+|Mandelbrot explorer |296.1 |200.2 |340.5 |0.9x |0.6x |48
+|===
+
+.Linux: CPU while idle (share of one core)
+[cols="<3,>2,>2,>2",options="header"]
+|===
+|Application |JVM, default |JVM, tuned |Native build
+
+|`swing-gallery` sample |0.0% |0.0% |0.2%
+
+|SwingSet2, the JDK demo |0.2% |0.0% |1.6%
+
+|Notepad, the JDK demo |0.2% |0.0% |0.0%
+
+|Falling-blocks game |1.0% |0.8% |0.6%
+
+|`javafx-gallery` sample |25.4% |27.1% |4.7%
+
+|Open-source 2048 game |3.9% |2.5% |4.8%
+
+|Address book |0.6% |0.4% |0.0%
+
+|Mandelbrot explorer |2.2% |1.8% |0.2%
+|===
+
+Of the 8 native builds, 5 idle at or under 1% of a core. Above it: SwingSet2, the JDK demo (1.6%), `javafx-gallery` sample (4.7%), Open-source 2048 game (4.8%).
+
+.Where the figures were measured
+* *Linux*: Ubuntu 24.04.5 LTS, aarch64, 4 CPUs, 7.7 GB of memory, in a container, hosted on Apple M4 Max. The display is a virtual framebuffer, Xvfb, of 1280 by 800 pixels. GTK 3.24.41. Each display has had one GTK program on it before the measured application starts, as a desktop session has: the first GTK program on a display loads a GL driver to choose its visuals, and no later one does. OpenJFX 23.0.2 for the JavaFX baselines.
+* *Tuned JVM flags*: `-XX:+UseSerialGC -Xss256k -XX:TieredStopAtLevel=1 -XX:SharedArchiveFile=app.jsa`, and the `-Xmx` of the table above.
+* *macOS, iOS and Android sizes*: macOS 26.6.2, Apple M4 Max, Xcode 27.0.
diff --git a/docs/developer-guide/desktop-compat-benchmarks.py b/docs/developer-guide/desktop-compat-benchmarks.py
new file mode 100644
index 00000000000..26da6c0b4f1
--- /dev/null
+++ b/docs/developer-guide/desktop-compat-benchmarks.py
@@ -0,0 +1,635 @@
+#!/usr/bin/env python3
+"""Render the measured tables and charts of the Swing and JavaFX chapter.
+
+  docs/developer-guide/desktop-compat-benchmarks.py \\
+      --linux DIR --macos DIR --mobile DIR \\
+      [--out docs/developer-guide/desktop-compat-benchmarks.adoc]
+
+DIR holds one directory for each application, as the harness in
+scripts/desktop-compat-benchmarks leaves them:
+
+  --linux, --macos   <application>/result.json            (bench.sh)
+  --mobile           <application>/*ios-size.json
+                     <application>/*android-size.json     (mobile-size.sh)
+
+Any of the three may be left out; its tables are then left out too.
+
+Everything the chapter says about a number is written here, from the results:
+the tables, the sentence under each that counts where the native build won and
+where it lost, and the description of the machine. Desktop-Interop.asciidoc
+includes the file once, whole, and quotes no figure of its own, so new results
+are published by running this again and committing what it writes: that file
+and the charts beside it, img/desktop-compat-*.svg, drawn from the same figures.
+
+Nothing is estimated. A cell with no measurement behind it is printed as "--",
+and the cells that were attempted and failed are listed with the harness's
+reason. A ratio is always the JVM figure divided by the native one: above 1 the
+native build is smaller or quicker, below 1 it is larger or slower, and both
+are counted the same way.
+
+An application is published under the description in LABELS, never under the
+directory name the harness gave it. A result with no entry there stops the run:
+add the line, with a description that names no third party.
+
+Python 3.9 compatible. The tables need the standard library only; the charts
+need matplotlib, and the same figures draw the same bytes. The arithmetic and the cell
+formats are scripts/desktop-compat-benchmarks/report.py's own.
+"""
+
+import argparse
+import glob
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "..", "..", "scripts", "desktop-compat-benchmarks"))
+from report import EMPTY, dig, megabytes, megabytes_kb, percent, timing  # noqa: E402
+
+# Directory name -> (what the chapter calls it, toolkit). The order here is the
+# order of the rows.
+LABELS = [
+    ("swing-gallery", "`swing-gallery` sample", "Swing"),
+    ("swingset2", "SwingSet2, the JDK demo", "Swing"),
+    ("notepad", "Notepad, the JDK demo", "Swing"),
+    ("tetris", "Falling-blocks game", "Swing"),
+    ("javafx-gallery", "`javafx-gallery` sample", "JavaFX"),
+    ("fx2048", "Open-source 2048 game", "JavaFX"),
+    ("address4", "Address book", "JavaFX"),
+    ("mandelbrot", "Mandelbrot explorer", "JavaFX"),
+]
+ORDER = dict((name, index) for index, (name, _label, _kind) in enumerate(LABELS))
+LABEL = dict((name, label) for name, label, _kind in LABELS)
+TOOLKIT = dict((name, kind) for name, _label, kind in LABELS)
+
+VARIANTS = (("jvm_default", "the default JVM"), ("jvm_tuned", "the tuned JVM"),
+            ("cn1_native", "the native build"))
+
+# The order the chapter discusses them in: what is distributed, start-up,
+# memory, idle CPU.
+ORDER_OF_TABLES = ("linux-size", "macos-size", "mobile-size", "linux-layers", "linux-startup-warm",
+                   "linux-startup-cold", "linux-memory-idle", "linux-memory-used", "linux-memory-peak",
+                   "linux-idle-cpu")
+
+# The harness's name for each toolkit layer -> what the chapter calls it.
+# Module names are an implementation detail that moves, so none is printed.
+# The JDK classes the harness also counts are left out: they are part of the
+# Codename One runtime, not of a toolkit layer.
+LAYER_NAMES = (("swing-compat", "Swing and AWT"), ("javafx-compat", "JavaFX"))
+
+# A native build idling above this share of one core is repainting or polling
+# with nothing to do; the harness draws the line at the same place.
+IDLE_CPU_LIMIT = 1.0
+
+
+def plain(label):
+    """A label as running text: without the backticks of a table cell."""
+    return label
+
+
+def name_of(result):
+    return dig(result, "app", "name")
+
+
+def load_results(directory):
+    results = []
+    if not directory:
+        return results
+    for path in sorted(glob.glob(os.path.join(directory, "*", "result.json"))):
+        with open(path) as handle:
+            results.append(json.load(handle))
+    check_names([name_of(r) for r in results], directory)
+    results.sort(key=lambda r: ORDER[name_of(r)])
+    return results
+
+
+def load_mobile(directory):
+    sizes = {}
+    if not directory:
+        return sizes
+    for app in sorted(os.listdir(directory)):
+        entry = {}
+        for target in ("ios", "android"):
+            found = sorted(glob.glob(os.path.join(directory, app, "*" + target + "-size.json")))
+            if found:
+                with open(found[-1]) as handle:
+                    entry[target] = json.load(handle)
+        if entry:
+            sizes[app] = entry
+    check_names(list(sizes), directory)
+    return sizes
+
+
+def check_names(names, where):
+    unknown = [n for n in names if n not in LABEL]
+    if unknown:
+        sys.exit("%s: no description for %s. Add a line to LABELS in %s; the description "
+                 "must not name a third party." % (where, ", ".join(sorted(unknown)), __file__))
+
+
+def value_ratio(baseline, candidate):
+    if baseline is None or candidate is None or candidate == 0:
+        return None
+    return float(baseline) / float(candidate)
+
+
+def show_ratio(value):
+    return EMPTY if value is None else "%.1fx" % value
+
+
+# The series of a chart, in the colours the comparison charts of the website
+# use: the native build, the default JVM, the tuned JVM.
+NATIVE_SERIES = ("Native build", "#55d4d0")
+DEFAULT_SERIES = ("JVM, default", "#f4ad55")
+TUNED_SERIES = ("JVM, tuned", "#9eafff")
+CHART_DIRECTORY = "img"
+CHARTS = []
+
+
+def chart(tag, title, alt, unit, labels, series, note):
+    """Queues a chart of horizontal bars, one group for each application, and
+    answers the line that places it. `series` is a list of
+    ((name, colour), values); a value that was not measured is None."""
+    rows = [(label, [values[i] for _s, values in series]) for i, label in enumerate(labels)]
+    rows = [row for row in rows if any(v is not None for v in row[1])]
+    if not rows:
+        return ""
+    CHARTS.append((tag, title, unit, rows, [s for s, _v in series], note))
+    return 'image::%s/desktop-compat-%s.svg["%s",scaledwidth=90%%]' % (CHART_DIRECTORY, tag, alt)
+
+
+def draw_charts(directory):
+    """Writes the queued charts. matplotlib is needed for this and for nothing
+    else, so it is imported here: the tables are written without it."""
+    if not CHARTS:
+        return
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    ground, ink, faint, rule = "#0b132b", "#eef2ff", "#c3cbe6", "#2a3350"
+    # The same bytes for the same figures: no date, and ids that do not
+    # change from one run to the next.
+    plt.rcParams.update({"font.family": "DejaVu Sans", "font.size": 11, "svg.fonttype": "path",
+                         "svg.hashsalt": "desktop-compat-benchmarks"})
+    if not os.path.isdir(directory):
+        os.makedirs(directory)
+    for tag, title, unit, rows, series, note in CHARTS:
+        step = 0.8 / len(series)
+        figure, axes = plt.subplots(figsize=(10, 1.5 + len(rows) * (0.34 * len(series) + 0.3)))
+        figure.patch.set_facecolor(ground)
+        axes.set_facecolor(ground)
+        most = max(v for _l, values in rows for v in values if v is not None)
+        for at, (_label, values) in enumerate(rows):
+            for index, value in enumerate(values):
+                y = at + (index - (len(series) - 1) / 2.0) * step
+                if value is None:
+                    axes.text(most * 0.012, y, "not measured", va="center", color=faint, fontsize=9)
+                    continue
+                axes.barh(y, value, height=step * 0.86, color=series[index][1],
+                          label=series[index][0] if at == 0 else None)
+                axes.text(value + most * 0.012, y, ("%.0f" if value >= 100 else "%.1f") % value,
+                          va="center", color=ink, fontsize=9)
+        axes.set_yticks(range(len(rows)))
+        axes.set_yticklabels([label.replace("`", "") for label, _v in rows], color=ink)
+        axes.invert_yaxis()
+        axes.set_xlim(0, most * 1.12)
+        axes.set_xlabel(unit, color=faint)
+        axes.tick_params(colors=faint, length=0)
+        axes.xaxis.grid(True, color=rule, linewidth=0.8)
+        axes.set_axisbelow(True)
+        for side in ("top", "right", "left"):
+            axes.spines[side].set_visible(False)
+        axes.spines["bottom"].set_color(rule)
+        axes.set_title(title + "\nLower is better", loc="left", color=ink, fontsize=15, pad=30)
+        # Above the bars, under the title: inside the plot it covers the longest bar.
+        legend = axes.legend(loc="lower left", bbox_to_anchor=(-0.01, 1.0), frameon=False, fontsize=10,
+                             ncol=len(series), columnspacing=1.4, handlelength=1.2)
+        for text in legend.get_texts():
+            text.set_color(ink)
+        figure.text(0.99, 0.01, note, ha="right", va="bottom", color=faint, fontsize=8)
+        figure.tight_layout(rect=(0, 0.03, 1, 1))
+        figure.savefig(os.path.join(directory, "desktop-compat-%s.svg" % tag), facecolor=ground,
+                       metadata={"Date": None})
+        plt.close(figure)
+
+
+class Table(object):
+    def __init__(self, tag, title, header, widths=None):
+        self.tag = tag
+        self.title = title
+        self.header = header
+        self.widths = widths
+        self.rows = []
+        self.after = []
+
+    pictures = ()
+
+    def add(self, *cells):
+        self.rows.append([str(cell) for cell in cells])
+
+    def say(self, paragraph):
+        if paragraph:
+            self.after.append(paragraph)
+
+    def show(self, line):
+        """Places a chart above the table; `line` is what [chart] answered."""
+        if line:
+            self.pictures = list(self.pictures) + [line]
+
+    def render(self):
+        widths = self.widths or ["<3"] + [">2"] * (len(self.header) - 1)
+        lines = []
+        for picture in self.pictures:
+            lines += [picture, ""]
+        lines += ["." + self.title, '[cols="%s",options="header"]' % ",".join(widths), "|==="]
+        lines.append(" ".join("|" + cell for cell in self.header))
+        for row in self.rows:
+            lines.append("")
+            lines.append(" ".join("|" + cell for cell in row))
+        lines.append("|===")
+        for paragraph in self.after:
+            lines += ["", paragraph]
+        lines.append("")
+        return "\n".join(lines)
+
+
+def count(number, singular, plural=None):
+    return "%d %s" % (number, singular if number == 1 else (plural or singular + "s"))
+
+
+def tally(pairs, better, worse, baseline):
+    """One sentence on (label, ratio, baseline text, native text) rows: how many
+    the native build won, how many it lost, and the two ends of the range."""
+    measured = [p for p in pairs if p[1] is not None]
+    if not measured:
+        return ""
+    won = [p for p in measured if p[1] > 1.0499]
+    lost = [p for p in measured if p[1] < 0.9501]
+    level = len(measured) - len(won) - len(lost)
+    parts = []
+    if won:
+        parts.append("%s in %s" % (better, count(len(won), "application")))
+    if lost:
+        parts.append("%s in %s" % (worse, count(len(lost), "application")))
+    if level:
+        parts.append("within 5%% of it in %s" % count(level, "application"))
+    out = "Against %s the native build is %s, of the %d measured." % (
+        baseline, ", ".join(parts[:-1]) + (" and " if len(parts) > 1 else "") + parts[-1], len(measured))
+    top = max(measured, key=lambda p: p[1])
+    bottom = min(measured, key=lambda p: p[1])
+    if won:
+        out += " Its best result is %s for %s (%s against %s)." % (
+            show_ratio(top[1]), plain(top[0]), top[3], top[2])
+    if lost:
+        out += " Its worst is %s for %s (%s against %s)." % (
+            show_ratio(bottom[1]), plain(bottom[0]), bottom[3], bottom[2])
+    return out
+
+
+def unmeasured(results):
+    lines = []
+    for result in results:
+        for variant, words in VARIANTS:
+            for error in dig(result, "run", variant, "errors") or []:
+                reason = str(error).split(": ")[-1].strip().rstrip(".")
+                lines.append("%s under %s (%s)" % (plain(LABEL[name_of(result)]), words, reason))
+    if not lines:
+        return ""
+    return "Not measured, and shown as `--`: " + "; ".join(lines) + "."
+
+
+def megabytes_of(value, unit=1048576.0):
+    return None if value is None else value / unit
+
+
+def where_measured(results):
+    """The line under a chart: what the figures were measured on."""
+    facts = (dig(results[0], "environment") or {}) if results else {}
+    parts = [str(facts[k]) for k in ("os", "machine") if usable(facts.get(k))]
+    if usable(facts.get("host_cpu")):
+        parts.append("in a container on " + str(facts["host_cpu"]).split("(")[0].strip())
+    elif usable(facts.get("cpu")) and not str(facts["cpu"]).startswith("0x"):
+        parts.append(str(facts["cpu"]))
+    return ", ".join(parts)
+
+
+def linux_tables(results):
+    tables = []
+    note = where_measured(results)
+    names = [LABEL[name_of(r)] for r in results]
+    missing = unmeasured(results)
+
+    size = Table("linux-size", "Linux: the distributed application (MB)",
+                 ["Application", "Toolkit", "`jlink` image", "`jlink` image, zipped", "`jpackage` image, zipped",
+                  "Native build", "Native build, zipped", "JVM image / native build", "JVM zip / native zip"],
+                 ["<3", "<1", ">1", ">1", ">1", ">1", ">1", ">1", ">1"])
+    pairs = []
+    installed = []
+    for result in results:
+        name = name_of(result)
+        jlink = dig(result, "size", "baseline_jlink", "zip_bytes")
+        native = dig(result, "size", "cn1_linux", "zip_bytes")
+        ratio = value_ratio(jlink, native)
+        pairs.append((LABEL[name], ratio, megabytes(jlink) + " MB", megabytes(native) + " MB"))
+        jlink_disk = dig(result, "size", "baseline_jlink", "bytes")
+        native_disk = dig(result, "size", "cn1_linux", "bytes")
+        disk_ratio = value_ratio(jlink_disk, native_disk)
+        installed.append((LABEL[name], disk_ratio, megabytes(jlink_disk) + " MB", megabytes(native_disk) + " MB"))
+        size.add(LABEL[name], TOOLKIT[name],
+                 megabytes(jlink_disk), megabytes(jlink),
+                 megabytes(dig(result, "size", "baseline_jpackage", "zip_bytes")),
+                 megabytes(native_disk), megabytes(native), show_ratio(disk_ratio), show_ratio(ratio))
+    for tag, key, title, alt in (
+            ("linux-size", "bytes", "Linux: the application as installed",
+             "Bar chart of the installed size of each application on Linux: the native build beside the jlink image"),
+            ("linux-size-zipped", "zip_bytes", "Linux: the application as downloaded, zipped",
+             "Bar chart of the zipped size of each application on Linux: the native build beside the jlink image")):
+        size.show(chart(tag, title, alt, "MB", names, [
+            (NATIVE_SERIES, [megabytes_of(dig(r, "size", "cn1_linux", key)) for r in results]),
+            (("JVM image, jlink", DEFAULT_SERIES[1]),
+             [megabytes_of(dig(r, "size", "baseline_jlink", key)) for r in results])], note))
+    size.say("The `jlink` image is the application with the smallest Java runtime that runs it: the "
+             "application's jars and the modules `jlink` found it to need. The native build is one "
+             "executable file with nothing beside it. Both rely on the desktop libraries of the system, "
+             "X11 and, for the native build and for JavaFX, GTK; neither column counts them.")
+    size.say(tally(installed, "smaller", "larger", "the `jlink` image as installed"))
+    size.say(tally(pairs, "smaller", "larger", "the zipped `jlink` image"))
+    tables.append(size)
+
+    measured = [r for r in results if dig(r, "run")]
+    if not measured:
+        return tables
+
+    idle_seconds = dig(measured[0], "run", "cn1_native", "idle_seconds") or 10
+    for section, tag, title in (
+            ("idle", "linux-memory-idle", "Linux: memory %g seconds after the first frame (MB, RSS / PSS)"
+             % idle_seconds),
+            ("after_script", "linux-memory-used",
+             "Linux: memory after the scripted interaction (MB, RSS / PSS)")):
+        table = Table(tag, title, ["Application", "JVM, default", "JVM, tuned", "Native build",
+                                   "Default RSS / native", "Tuned RSS / native"])
+        against_default, against_tuned = [], []
+        for result in measured:
+            label = LABEL[name_of(result)]
+            cells, rss = [], {}
+            for variant, _words in VARIANTS:
+                rss[variant] = dig(result, "run", variant, section, "rss_kb")
+                pss = dig(result, "run", variant, section, "pss_kb")
+                cells.append(EMPTY if rss[variant] is None
+                             else "%s / %s" % (megabytes_kb(rss[variant]), megabytes_kb(pss)))
+            native = megabytes_kb(rss["cn1_native"]) + " MB"
+            first = value_ratio(rss["jvm_default"], rss["cn1_native"])
+            second = value_ratio(rss["jvm_tuned"], rss["cn1_native"])
+            against_default.append((label, first, megabytes_kb(rss["jvm_default"]) + " MB", native))
+            against_tuned.append((label, second, megabytes_kb(rss["jvm_tuned"]) + " MB", native))
+            table.add(label, cells[0], cells[1], cells[2], show_ratio(first), show_ratio(second))
+        if section == "idle":
+            table.show(chart(tag, "Linux: memory %g seconds after the first frame" % idle_seconds,
+                             "Bar chart of the resident memory of each idle application on Linux: "
+                             "the native build beside the default and the tuned JVM", "MB of RSS",
+                             [LABEL[name_of(r)] for r in measured],
+                             [(series, [megabytes_of(dig(r, "run", variant, section, "rss_kb"), 1024.0)
+                                        for r in measured])
+                              for series, variant in ((NATIVE_SERIES, "cn1_native"),
+                                                      (DEFAULT_SERIES, "jvm_default"),
+                                                      (TUNED_SERIES, "jvm_tuned"))], note))
+        table.say(tally(against_default, "smaller", "larger", "the default JVM"))
+        table.say(tally(against_tuned, "smaller", "larger", "the tuned JVM"))
+        table.say(missing)
+        tables.append(table)
+
+    peak = Table("linux-memory-peak", "Linux: peak RSS over a whole session (MB)",
+                 ["Application", "JVM, default", "JVM, tuned", "Native build", "Default / native",
+                  "Tuned / native", "Tuned `-Xmx` (MB)"])
+    for result in measured:
+        native = dig(result, "run", "cn1_native", "peak_rss_kb")
+        default = dig(result, "run", "jvm_default", "peak_rss_kb")
+        tuned = dig(result, "run", "jvm_tuned", "peak_rss_kb")
+        peak.add(LABEL[name_of(result)], megabytes_kb(default), megabytes_kb(tuned), megabytes_kb(native),
+                 show_ratio(value_ratio(default, native)), show_ratio(value_ratio(tuned, native)),
+                 dig(result, "tuned", "xmx_mb") or EMPTY)
+    tables.append(peak)
+
+    for mode in ("warm", "cold"):
+        table = Table("linux-startup-" + mode,
+                      "Linux: %s start, from process start to the first painted frame "
+                      "(ms, median with the range)" % mode,
+                      ["Application", "JVM, default", "JVM, tuned", "Native build", "Default / native",
+                       "Tuned / native"])
+        against_default, against_tuned = [], []
+        for result in measured:
+            label = LABEL[name_of(result)]
+            times = dict((variant, dig(result, "run", variant, "startup_" + mode, "first_paint_ms"))
+                         for variant, _words in VARIANTS)
+            medians = dict((variant, dig(times[variant], "median")) for variant in times)
+
+            def text(variant):
+                return EMPTY if medians[variant] is None else "%.0f ms" % medians[variant]
+            first = value_ratio(medians["jvm_default"], medians["cn1_native"])
+            second = value_ratio(medians["jvm_tuned"], medians["cn1_native"])
+            against_default.append((label, first, text("jvm_default"), text("cn1_native")))
+            against_tuned.append((label, second, text("jvm_tuned"), text("cn1_native")))
+            table.add(label, timing(times["jvm_default"]), timing(times["jvm_tuned"]),
+                      timing(times["cn1_native"]), show_ratio(first), show_ratio(second))
+        if mode == "cold":
+            table.show(chart("linux-startup-cold", "Linux: cold start, to the first painted frame",
+                             "Bar chart of the cold start of each application on Linux: the native build "
+                             "beside the default and the tuned JVM", "ms, median",
+                             [LABEL[name_of(r)] for r in measured],
+                             [(series, [dig(r, "run", variant, "startup_cold", "first_paint_ms", "median")
+                                        for r in measured])
+                              for series, variant in ((NATIVE_SERIES, "cn1_native"),
+                                                      (DEFAULT_SERIES, "jvm_default"),
+                                                      (TUNED_SERIES, "jvm_tuned"))], note))
+        table.say(tally(against_default, "quicker", "slower", "the default JVM"))
+        table.say(tally(against_tuned, "quicker", "slower", "the tuned JVM"))
+        tables.append(table)
+
+    cpu = Table("linux-idle-cpu", "Linux: CPU while idle (share of one core)",
+                ["Application", "JVM, default", "JVM, tuned", "Native build"])
+    busy = []
+    for result in measured:
+        value = dig(result, "run", "cn1_native", "idle", "cpu_percent")
+        if value is not None and value > IDLE_CPU_LIMIT:
+            busy.append("%s (%s)" % (plain(LABEL[name_of(result)]), percent(value)))
+        cpu.add(LABEL[name_of(result)], percent(dig(result, "run", "jvm_default", "idle", "cpu_percent")),
+                percent(dig(result, "run", "jvm_tuned", "idle", "cpu_percent")), percent(value))
+    known = [r for r in measured if dig(r, "run", "cn1_native", "idle", "cpu_percent") is not None]
+    sentence = "Of the %d native builds, %d idle at or under %g%% of a core." % (
+        len(known), len(known) - len(busy), IDLE_CPU_LIMIT)
+    if busy:
+        sentence += " Above it: " + ", ".join(busy) + "."
+    cpu.say(sentence)
+    tables.append(cpu)
+
+    layers = Table("linux-layers", "How much of the toolkit layer an application keeps",
+                   ["Application", "Toolkit", "Classes in the layer", "Classes in the native build", "Kept"],
+                   ["<3", "<2", ">1", ">1", ">1"])
+    for result in results:
+        staged = dig(result, "layers", "staged_jar", "classes") or {}
+        translated = None
+        for key in sorted(dig(result, "layers") or {}):
+            if key.startswith("translated_"):
+                translated = dig(result, "layers", key)
+        for layer, shown in LAYER_NAMES:
+            if layer not in staged:
+                continue
+            kept = dig(translated, layer, "classes")
+            total = staged[layer]["classes"]
+            layers.add(LABEL[name_of(result)], shown, total, EMPTY if kept is None else kept,
+                       EMPTY if kept is None or not total else "%.0f%%" % (100.0 * kept / total))
+    if layers.rows:
+        tables.append(layers)
+    return tables
+
+
+def macos_tables(results):
+    """The comparison is made for one architecture on both sides. The `jlink`
+    image holds the runtime of the machine it was built on, so the native side
+    is the same bundle with only that slice of its universal executable
+    (size.cn1_macos_thin, which bench.sh records). A result without it is
+    compared as a universal bundle, and every label then says so: universal
+    against one architecture is not like for like, and must not read as if it
+    were."""
+    if not results:
+        return []
+    thin = all(dig(r, "size", "cn1_macos_thin", "bytes") is not None for r in results)
+    key = "cn1_macos_thin" if thin else "cn1_macos"
+    native_name = "Native `.app`, arm64" if thin else "Native `.app`, universal (x86_64 + arm64)"
+    table = Table("macos-size", "macOS: the distributed application (MB)",
+                  ["Application", "`jlink` image, arm64", "`jlink` image, zipped", native_name,
+                   "Native `.app`, zipped", "Universal `.app`", "JVM image / native `.app`",
+                   "JVM zip / native zip"],
+                  ["<3", ">1", ">1", ">1", ">1", ">1", ">1", ">1"])
+    pairs = []
+    installed = []
+    for result in results:
+        label = LABEL[name_of(result)]
+        jlink = dig(result, "size", "baseline_jlink", "zip_bytes")
+        native = dig(result, "size", key, "zip_bytes")
+        ratio = value_ratio(jlink, native)
+        pairs.append((label, ratio, megabytes(jlink) + " MB", megabytes(native) + " MB"))
+        jlink_disk = dig(result, "size", "baseline_jlink", "bytes")
+        native_disk = dig(result, "size", key, "bytes")
+        disk_ratio = value_ratio(jlink_disk, native_disk)
+        installed.append((label, disk_ratio, megabytes(jlink_disk) + " MB", megabytes(native_disk) + " MB"))
+        table.add(label, megabytes(jlink_disk), megabytes(jlink), megabytes(native_disk), megabytes(native),
+                  megabytes(dig(result, "size", "cn1_macos", "bytes")), show_ratio(disk_ratio), show_ratio(ratio))
+    series_name = "Native .app, arm64" if thin else "Native .app, universal (x86_64 + arm64)"
+    table.show(chart("macos-size", "macOS: the application as installed",
+                     "Bar chart of the installed size of each application on macOS: the native application "
+                     + ("for arm64" if thin else "as a universal binary") + " beside the arm64 jlink image",
+                     "MB", [LABEL[name_of(r)] for r in results], [
+                         ((series_name, NATIVE_SERIES[1]),
+                          [megabytes_of(dig(r, "size", key, "bytes")) for r in results]),
+                         (("JVM image, jlink, arm64", DEFAULT_SERIES[1]),
+                          [megabytes_of(dig(r, "size", "baseline_jlink", "bytes")) for r in results])],
+                     where_measured(results)))
+    if thin:
+        table.say("Both sides are built for arm64: the `jlink` image holds the arm64 runtime, and the native "
+                  "`.app` is the bundle with the arm64 slice of its executable only. The builder's default "
+                  "output is universal, with an x86_64 slice beside it; its size is in the last size column.")
+    else:
+        table.say("The native `.app` here is universal, with an x86_64 and an arm64 slice, while the `jlink` "
+                  "image holds the runtime of one architecture. The comparison favors the JVM.")
+    table.say(tally(installed, "smaller", "larger", "the `jlink` image as installed"))
+    table.say(tally(pairs, "smaller", "larger", "the zipped `jlink` image"))
+    return [table]
+
+
+def mobile_tables(sizes):
+    if not sizes:
+        return []
+    table = Table("mobile-size", "iOS and Android: the distributed application (MB)",
+                  ["Application", "iOS `.app`", "iOS `.app`, zipped", "iOS executable, stripped", "Android APK",
+                   "APK, unpacked", "Of which dex"])
+    for name in sorted(sizes, key=lambda n: ORDER[n]):
+        ios = sizes[name].get("ios") or {}
+        android = sizes[name].get("android") or {}
+        table.add(LABEL[name], megabytes(ios.get("bytes")), megabytes(ios.get("zip_bytes")),
+                  megabytes(ios.get("executable_stripped_bytes")), megabytes(android.get("apk_bytes")),
+                  megabytes(android.get("unpacked_bytes")), megabytes(android.get("dex_bytes")))
+    return [table]
+
+
+def usable(value):
+    """Whether an environment fact reads as a fact: a tool that printed a
+    warning or an error where its version should be is left out."""
+    text = str(value).lower()
+    return value not in (None, "") and "warning" not in text and "error" not in text
+
+
+def environment(linux, macos):
+    lines = [".Where the figures were measured"]
+    if linux:
+        facts = dig(linux[0], "environment") or {}
+        parts = []
+        if usable(facts.get("os")):
+            parts.append(str(facts["os"]))
+        if usable(facts.get("machine")):
+            parts.append(str(facts["machine"]))
+        if facts.get("cpus"):
+            parts.append("%s CPUs" % facts["cpus"])
+        if facts.get("ram_kb"):
+            parts.append("%.1f GB of memory" % (facts["ram_kb"] / 1048576.0))
+        where = "in a container" if facts.get("in_container") else "on the machine itself"
+        line = "* *Linux*: " + ", ".join(parts) + ", " + where
+        if usable(facts.get("host_cpu")):
+            line += ", hosted on " + str(facts["host_cpu"]).split("(")[0].strip()
+        line += "."
+        if usable(facts.get("screen")):
+            line += " The display is a virtual framebuffer, Xvfb, of %s pixels." % str(facts["screen"]).replace("x", " by ")
+        if usable(facts.get("gtk")):
+            line += " GTK %s." % facts["gtk"]
+        if any((session or {}).get("gtk_session") for r in linux
+               for session in (dig(r, "run", "cn1_native", "sessions") or [])):
+            line += (" Each display has had one GTK program on it before the measured application starts, "
+                     "as a desktop session has: the first GTK program on a display loads a GL driver to "
+                     "choose its visuals, and no later one does.")
+        if usable(facts.get("openjfx")):
+            line += " OpenJFX %s for the JavaFX baselines." % facts["openjfx"]
+        lines.append(line)
+        flags = sorted(set(dig(r, "tuned", "flags") for r in linux if dig(r, "tuned", "flags")))
+        if flags:
+            common = [f for f in flags[0].split() if not f.startswith("-Xmx")]
+            lines.append("* *Tuned JVM flags*: `%s`, and the `-Xmx` of the table above." % " ".join(common))
+    if macos:
+        facts = dig(macos[0], "environment") or {}
+        parts = [str(facts[k]) for k in ("os", "cpu") if usable(facts.get(k))]
+        if usable(facts.get("xcode")):
+            parts.append(str(facts["xcode"]).split(",")[0])
+        if parts:
+            lines.append("* *macOS, iOS and Android sizes*: " + ", ".join(parts) + ".")
+    lines.append("")
+    return "\n".join(lines) if len(lines) > 2 else ""
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--linux")
+    parser.add_argument("--macos")
+    parser.add_argument("--mobile")
+    parser.add_argument("--out", default=os.path.join(HERE, "desktop-compat-benchmarks.adoc"))
+    args = parser.parse_args()
+    if not (args.linux or args.macos or args.mobile):
+        parser.error("give at least one of --linux, --macos and --mobile")
+
+    linux = load_results(args.linux)
+    macos = load_results(args.macos)
+    mobile = load_mobile(args.mobile)
+
+    out = ["// Written by desktop-compat-benchmarks.py from measured results. Change the results and run it again;",
+           "// an edit made here is lost. Desktop-Interop.asciidoc includes this file once, whole.", ""]
+    tables = dict((t.tag, t) for t in linux_tables(linux) + macos_tables(macos) + mobile_tables(mobile))
+    for tag in ORDER_OF_TABLES:
+        if tag in tables:
+            out.append(tables[tag].render())
+    out.append(environment(linux, macos))
+    draw_charts(os.path.join(os.path.dirname(os.path.abspath(args.out)), CHART_DIRECTORY))
+    with open(args.out, "w") as handle:
+        handle.write("\n".join(out).rstrip("\n") + "\n")
+    sys.stderr.write("wrote %s\n" % args.out)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/developer-guide/developer-guide.asciidoc b/docs/developer-guide/developer-guide.asciidoc
index fd86060c6aa..23b93057244 100644
--- a/docs/developer-guide/developer-guide.asciidoc
+++ b/docs/developer-guide/developer-guide.asciidoc
@@ -251,6 +251,8 @@ include::Working-With-Javascript.asciidoc[]
 
 include::Android-Interop.asciidoc[]
 
+include::Desktop-Interop.asciidoc[]
+
 include::Working-with-Mac-OS-X.asciidoc[]
 
 include::Working-with-Mac-Catalyst.asciidoc[]
diff --git a/docs/developer-guide/img/desktop-compat-linux-memory-idle.svg b/docs/developer-guide/img/desktop-compat-linux-memory-idle.svg
new file mode 100644
index 00000000000..a7441b8452b
--- /dev/null
+++ b/docs/developer-guide/img/desktop-compat-linux-memory-idle.svg
@@ -0,0 +1,2116 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="720pt" height="868.32pt" viewBox="0 0 720 868.32" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 868.32 
+L 720 868.32 
+L 720 0 
+L 0 0 
+z
+" style="fill: #0b132b"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 155.78 800.8904 
+L 708.12 800.8904 
+L 708.12 73.02791 
+L 155.78 73.02791 
+z
+" style="fill: #0b132b"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <path d="M 155.78 800.8904 
+L 155.78 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_2"/>
+     <g id="text_1">
+      <!-- 0 -->
+      <g style="fill: #c3cbe6" transform="translate(152.280625 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-13" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-13"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <path d="M 242.035785 800.8904 
+L 242.035785 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_4"/>
+     <g id="text_2">
+      <!-- 50 -->
+      <g style="fill: #c3cbe6" transform="translate(235.037035 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-18" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-18"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <path d="M 328.291571 800.8904 
+L 328.291571 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_6"/>
+     <g id="text_3">
+      <!-- 100 -->
+      <g style="fill: #c3cbe6" transform="translate(317.793446 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-14" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <path d="M 414.547356 800.8904 
+L 414.547356 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_8"/>
+     <g id="text_4">
+      <!-- 150 -->
+      <g style="fill: #c3cbe6" transform="translate(404.049231 812.747822) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <path d="M 500.803142 800.8904 
+L 500.803142 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_10"/>
+     <g id="text_5">
+      <!-- 200 -->
+      <g style="fill: #c3cbe6" transform="translate(490.305017 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-15" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_11">
+      <path d="M 587.058927 800.8904 
+L 587.058927 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_12"/>
+     <g id="text_6">
+      <!-- 250 -->
+      <g style="fill: #c3cbe6" transform="translate(576.560802 812.747822) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_13">
+      <path d="M 673.314712 800.8904 
+L 673.314712 73.02791 
+" clip-path="url(#p4f30f1d0c9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_14"/>
+     <g id="text_7">
+      <!-- 300 -->
+      <g style="fill: #c3cbe6" transform="translate(662.816587 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-16" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-16"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_8">
+     <!-- MB of RSS -->
+     <g style="fill: #c3cbe6" transform="translate(403.828672 827.748681) scale(0.11 -0.11)">
+      <defs>
+       <path id="DejaVuSans-30" d="M 628 4666 
+L 1569 4666 
+L 2759 1491 
+L 3956 4666 
+L 4897 4666 
+L 4897 0 
+L 4281 0 
+L 4281 4097 
+L 3078 897 
+L 2444 897 
+L 1241 4097 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-25" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-3" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-52" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-49" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-35" d="M 2841 2188 
+Q 3044 2119 3236 1894 
+Q 3428 1669 3622 1275 
+L 4263 0 
+L 3584 0 
+L 2988 1197 
+Q 2756 1666 2539 1819 
+Q 2322 1972 1947 1972 
+L 1259 1972 
+L 1259 0 
+L 628 0 
+L 628 4666 
+L 2053 4666 
+Q 2853 4666 3247 4331 
+Q 3641 3997 3641 3322 
+Q 3641 2881 3436 2590 
+Q 3231 2300 2841 2188 
+z
+M 1259 4147 
+L 1259 2491 
+L 2053 2491 
+Q 2509 2491 2742 2702 
+Q 2975 2913 2975 3322 
+Q 2975 3731 2742 3939 
+Q 2509 4147 2053 4147 
+L 1259 4147 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-36" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-30"/>
+      <use xlink:href="#DejaVuSans-25" transform="translate(86.28125 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(154.890625 0)"/>
+      <use xlink:href="#DejaVuSans-52" transform="translate(186.671875 0)"/>
+      <use xlink:href="#DejaVuSans-49" transform="translate(247.859375 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(283.0625 0)"/>
+      <use xlink:href="#DejaVuSans-35" transform="translate(314.84375 0)"/>
+      <use xlink:href="#DejaVuSans-36" transform="translate(384.328125 0)"/>
+      <use xlink:href="#DejaVuSans-36" transform="translate(447.8125 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_15"/>
+     <g id="text_9">
+      <!-- swing-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(35.447969 142.796733) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-56" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5a" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4c" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-51" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4a" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-10" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-44" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4f" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-48" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-55" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5c" d="M 2059 -325 
+Q 1816 -950 1584 -1140 
+Q 1353 -1331 966 -1331 
+L 506 -1331 
+L 506 -850 
+L 844 -850 
+Q 1081 -850 1212 -737 
+Q 1344 -625 1503 -206 
+L 1606 56 
+L 191 3500 
+L 800 3500 
+L 1894 763 
+L 2988 3500 
+L 3597 3500 
+L 2059 -325 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-50" d="M 3328 2828 
+Q 3544 3216 3844 3400 
+Q 4144 3584 4550 3584 
+Q 5097 3584 5394 3201 
+Q 5691 2819 5691 2113 
+L 5691 0 
+L 5113 0 
+L 5113 2094 
+Q 5113 2597 4934 2840 
+Q 4756 3084 4391 3084 
+Q 3944 3084 3684 2787 
+Q 3425 2491 3425 1978 
+L 3425 0 
+L 2847 0 
+L 2847 2094 
+Q 2847 2600 2669 2842 
+Q 2491 3084 2119 3084 
+Q 1678 3084 1418 2786 
+Q 1159 2488 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1356 3278 1631 3431 
+Q 1906 3584 2284 3584 
+Q 2666 3584 2933 3390 
+Q 3200 3197 3328 2828 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-53" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-56"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(52.09375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(133.875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(161.65625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(225.03125 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(288.515625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(324.59375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(388.078125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(449.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(477.140625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(504.921875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(566.453125 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(607.5625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(666.75 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(698.53125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(750.625 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(811.90625 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(909.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(972.796875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1000.578125 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_16"/>
+     <g id="text_10">
+      <!-- SwingSet2, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(12.066094 228.037179) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-57" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-f" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4b" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 628 4666 
+L 1259 4666 
+L 1259 325 
+Q 1259 -519 939 -900 
+Q 619 -1281 -91 -1281 
+L -331 -1281 
+L -331 -750 
+L -134 -750 
+Q 284 -750 456 -515 
+Q 628 -281 628 325 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-27" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 628 4666 
+L 1259 4666 
+L 1259 2694 
+L 3353 4666 
+L 4166 4666 
+L 1850 2491 
+L 4331 0 
+L 3500 0 
+L 1259 2247 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-47" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(63.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(145.265625 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(173.046875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(236.421875 0)"/>
+       <use xlink:href="#DejaVuSans-36" transform="translate(299.90625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(363.390625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(424.921875 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(464.125 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(559.53125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(591.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(630.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(693.890625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(755.421875 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(787.203125 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(816.703125 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(893.703125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(959.28125 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(991.0625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1054.546875 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1116.078125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1213.484375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_17"/>
+     <g id="text_11">
+      <!-- Notepad, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(23.370313 313.277626) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 628 4666 
+L 1478 4666 
+L 3547 763 
+L 3547 4666 
+L 4159 4666 
+L 4159 0 
+L 3309 0 
+L 1241 3903 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(74.8125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(136 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(175.203125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(236.734375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(300.21875 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(361.5 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(424.984375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(456.765625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(488.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(591.125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(652.65625 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(684.4375 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(790.9375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(856.515625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(888.296875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(951.78125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1013.3125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1110.71875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_18"/>
+     <g id="text_12">
+      <!-- Falling-blocks game -->
+      <g style="fill: #c3cbe6" transform="translate(43.508906 398.518072) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-29" d="M 628 4666 
+L 3309 4666 
+L 3309 4134 
+L 1259 4134 
+L 1259 2759 
+L 3109 2759 
+L 3109 2228 
+L 1259 2228 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-45" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-46" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4e" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-29"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(48.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(109.625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(137.40625 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(165.1875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(192.96875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(256.34375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(319.828125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(355.90625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(419.390625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(447.171875 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(508.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(563.34375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(621.25 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(673.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(705.125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(768.609375 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(829.890625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(927.296875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_19"/>
+     <g id="text_13">
+      <!-- javafx-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(33.753281 483.758519) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-4d" d="M 603 3500 
+L 1178 3500 
+L 1178 -63 
+Q 1178 -731 923 -1031 
+Q 669 -1331 103 -1331 
+L -116 -1331 
+L -116 -844 
+L 38 -844 
+Q 366 -844 484 -692 
+Q 603 -541 603 -63 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-59" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5b" d="M 3513 3500 
+L 2247 1797 
+L 3578 0 
+L 2900 0 
+L 1881 1375 
+L 863 0 
+L 184 0 
+L 1544 1831 
+L 300 3500 
+L 978 3500 
+L 1906 2253 
+L 2834 3500 
+L 3513 3500 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4d"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(27.78125 0)"/>
+       <use xlink:href="#DejaVuSans-59" transform="translate(89.0625 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(148.25 0)"/>
+       <use xlink:href="#DejaVuSans-49" transform="translate(209.53125 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(244.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(303.921875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(340 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(403.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(464.765625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(492.546875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(520.328125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(581.859375 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(622.96875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(682.15625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(766.03125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(827.3125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(924.71875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(988.203125 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1015.984375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_20"/>
+     <g id="text_14">
+      <!-- Open-source 2048 game -->
+      <g style="fill: #c3cbe6" transform="translate(16.206562 568.998536) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 2522 4238 
+Q 1834 4238 1429 3725 
+Q 1025 3213 1025 2328 
+Q 1025 1447 1429 934 
+Q 1834 422 2522 422 
+Q 3209 422 3611 934 
+Q 4013 1447 4013 2328 
+Q 4013 3213 3611 3725 
+Q 3209 4238 2522 4238 
+z
+M 2522 4750 
+Q 3503 4750 4090 4092 
+Q 4678 3434 4678 2328 
+Q 4678 1225 4090 567 
+Q 3503 -91 2522 -91 
+Q 1538 -91 948 565 
+Q 359 1222 359 2328 
+Q 359 3434 948 4092 
+Q 1538 4750 2522 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-58" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-17" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-1b" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(78.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(142.203125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(203.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(267.109375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(303.1875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(355.28125 0)"/>
+       <use xlink:href="#DejaVuSans-58" transform="translate(416.46875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(479.84375 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(518.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(573.734375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(635.265625 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(667.046875 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(730.671875 0)"/>
+       <use xlink:href="#DejaVuSans-17" transform="translate(794.296875 0)"/>
+       <use xlink:href="#DejaVuSans-1b" transform="translate(857.921875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(921.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(953.328125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(1016.8125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1078.09375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1175.5 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_21"/>
+     <g id="text_15">
+      <!-- Address book -->
+      <g style="fill: #c3cbe6" transform="translate(78.162344 654.239412) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-24" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-24"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(66.65625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(130.140625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(193.625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(232.53125 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(294.0625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(346.15625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(398.25 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(430.03125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(493.515625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(554.703125 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(615.890625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_22"/>
+     <g id="text_16">
+      <!-- Mandelbrot explorer -->
+      <g style="fill: #c3cbe6" transform="translate(41.040781 739.479858) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(86.28125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(147.5625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(210.9375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(274.421875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(335.953125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(363.734375 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(427.21875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(466.125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(527.3125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(566.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(598.296875 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(658.078125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(717.265625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(780.75 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(808.53125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(869.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(908.625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(970.15625 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 155.78 106.112569 
+L 267.043224 106.112569 
+L 267.043224 125.661045 
+L 155.78 125.661045 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 155.78 128.843355 
+L 370.711897 128.843355 
+L 370.711897 148.39183 
+L 155.78 148.39183 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 155.78 151.57414 
+L 300.972746 151.57414 
+L 300.972746 171.122616 
+L 155.78 171.122616 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 155.78 191.353015 
+L 310.696738 191.353015 
+L 310.696738 210.901491 
+L 155.78 210.901491 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 155.78 214.083801 
+L 380.146123 214.083801 
+L 380.146123 233.632277 
+L 155.78 233.632277 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 155.78 236.814587 
+L 305.696598 236.814587 
+L 305.696598 256.363062 
+L 155.78 256.363062 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_9">
+    <path d="M 155.78 276.593462 
+L 249.744896 276.593462 
+L 249.744896 296.141937 
+L 155.78 296.141937 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 155.78 299.324247 
+L 301.053611 299.324247 
+L 301.053611 318.872723 
+L 155.78 318.872723 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 155.78 322.055033 
+L 263.114543 322.055033 
+L 263.114543 341.603509 
+L 155.78 341.603509 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_12">
+    <path d="M 155.78 361.833908 
+L 246.004899 361.833908 
+L 246.004899 381.382384 
+L 155.78 381.382384 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_13">
+    <path d="M 155.78 384.564694 
+L 269.085061 384.564694 
+L 269.085061 404.11317 
+L 155.78 404.11317 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_14">
+    <path d="M 155.78 407.29548 
+L 246.456394 407.29548 
+L 246.456394 426.843955 
+L 155.78 426.843955 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_15">
+    <path d="M 155.78 447.074355 
+L 313.98524 447.074355 
+L 313.98524 466.62283 
+L 155.78 466.62283 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 155.78 469.80514 
+L 648.940714 469.80514 
+L 648.940714 489.353616 
+L 155.78 489.353616 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 155.78 492.535926 
+L 521.814512 492.535926 
+L 521.814512 512.084402 
+L 155.78 512.084402 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 155.78 532.314801 
+L 257.339449 532.314801 
+L 257.339449 551.863277 
+L 155.78 551.863277 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_19">
+    <path d="M 155.78 555.045587 
+L 496.55774 555.045587 
+L 496.55774 574.594063 
+L 155.78 574.594063 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_20">
+    <path d="M 155.78 577.776373 
+L 418.745587 577.776373 
+L 418.745587 597.324848 
+L 155.78 597.324848 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_21">
+    <path d="M 155.78 617.555248 
+L 251.779994 617.555248 
+L 251.779994 637.103723 
+L 155.78 637.103723 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_22">
+    <path d="M 155.78 640.286033 
+L 558.85059 640.286033 
+L 558.85059 659.834509 
+L 155.78 659.834509 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_23">
+    <path d="M 155.78 663.016819 
+L 451.664299 663.016819 
+L 451.664299 682.565295 
+L 155.78 682.565295 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_24">
+    <path d="M 155.78 702.795694 
+L 362.901705 702.795694 
+L 362.901705 722.34417 
+L 155.78 722.34417 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_25">
+    <path d="M 155.78 725.52648 
+L 609.519125 725.52648 
+L 609.519125 745.074956 
+L 155.78 745.074956 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_26">
+    <path d="M 155.78 748.257266 
+L 474.286226 748.257266 
+L 474.286226 767.805741 
+L 155.78 767.805741 
+z
+" clip-path="url(#p4f30f1d0c9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_27">
+    <path d="M 155.78 800.8904 
+L 708.12 800.8904 
+" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_17">
+    <!-- 64.5 -->
+    <g style="fill: #eef2ff" transform="translate(272.961153 118.224697) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-19" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-11" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_18">
+    <!-- 125 -->
+    <g style="fill: #eef2ff" transform="translate(376.629825 140.955483) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_19">
+    <!-- 84.2 -->
+    <g style="fill: #eef2ff" transform="translate(306.890675 163.686269) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_20">
+    <!-- 89.8 -->
+    <g style="fill: #eef2ff" transform="translate(316.614667 203.465144) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1c" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_21">
+    <!-- 130 -->
+    <g style="fill: #eef2ff" transform="translate(386.064052 226.195929) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_22">
+    <!-- 86.9 -->
+    <g style="fill: #eef2ff" transform="translate(311.614527 248.926715) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_23">
+    <!-- 54.5 -->
+    <g style="fill: #eef2ff" transform="translate(255.662825 288.70559) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_24">
+    <!-- 84.2 -->
+    <g style="fill: #eef2ff" transform="translate(306.97154 311.436376) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_25">
+    <!-- 62.2 -->
+    <g style="fill: #eef2ff" transform="translate(269.032472 334.167162) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_26">
+    <!-- 52.3 -->
+    <g style="fill: #eef2ff" transform="translate(251.922828 373.946037) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_27">
+    <!-- 65.7 -->
+    <g style="fill: #eef2ff" transform="translate(275.002989 396.676822) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1a" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_28">
+    <!-- 52.6 -->
+    <g style="fill: #eef2ff" transform="translate(252.374323 419.407608) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_29">
+    <!-- 91.7 -->
+    <g style="fill: #eef2ff" transform="translate(319.903169 459.186483) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1c"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_30">
+    <!-- 286 -->
+    <g style="fill: #eef2ff" transform="translate(654.858643 481.917269) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_31">
+    <!-- 212 -->
+    <g style="fill: #eef2ff" transform="translate(527.73244 504.648055) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_32">
+    <!-- 58.9 -->
+    <g style="fill: #eef2ff" transform="translate(263.257377 544.42693) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_33">
+    <!-- 198 -->
+    <g style="fill: #eef2ff" transform="translate(502.475668 567.157715) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_34">
+    <!-- 152 -->
+    <g style="fill: #eef2ff" transform="translate(424.663516 589.888501) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_35">
+    <!-- 55.6 -->
+    <g style="fill: #eef2ff" transform="translate(257.697922 629.667376) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_36">
+    <!-- 234 -->
+    <g style="fill: #eef2ff" transform="translate(564.768518 652.398162) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_37">
+    <!-- 172 -->
+    <g style="fill: #eef2ff" transform="translate(457.582227 675.128948) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_38">
+    <!-- 120 -->
+    <g style="fill: #eef2ff" transform="translate(368.819633 714.907823) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_39">
+    <!-- 263 -->
+    <g style="fill: #eef2ff" transform="translate(615.437053 737.638608) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_40">
+    <!-- 185 -->
+    <g style="fill: #eef2ff" transform="translate(480.204155 760.369394) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_41">
+    <!-- Linux: memory 10 seconds after the first frame -->
+    <g style="fill: #eef2ff" transform="translate(155.78 25.023809) scale(0.15 -0.15)">
+     <defs>
+      <path id="DejaVuSans-2f" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-1d" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-13af" d="M 3431 3500 
+L 3431 0 
+L 2853 0 
+L 2853 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4316 967 4589 
+Q 1238 4863 1797 4863 
+L 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 3431 3500 
+z
+M 2853 4856 
+L 3431 4856 
+L 3431 4128 
+L 2853 4128 
+L 2853 4856 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(55.71875 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(83.5 0)"/>
+     <use xlink:href="#DejaVuSans-58" transform="translate(146.875 0)"/>
+     <use xlink:href="#DejaVuSans-5b" transform="translate(210.25 0)"/>
+     <use xlink:href="#DejaVuSans-1d" transform="translate(269.4375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(303.125 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(334.90625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(432.3125 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(493.84375 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(591.25 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(652.4375 0)"/>
+     <use xlink:href="#DejaVuSans-5c" transform="translate(693.546875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(752.734375 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(784.515625 0)"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(848.140625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(911.765625 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(943.546875 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(995.640625 0)"/>
+     <use xlink:href="#DejaVuSans-46" transform="translate(1057.171875 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(1112.15625 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1173.34375 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1236.71875 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1300.203125 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1352.296875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1384.078125 0)"/>
+     <use xlink:href="#DejaVuSans-49" transform="translate(1445.359375 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1478.8125 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1518.015625 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(1579.546875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1620.65625 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1652.4375 0)"/>
+     <use xlink:href="#DejaVuSans-4b" transform="translate(1691.640625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1755.015625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1816.546875 0)"/>
+     <use xlink:href="#DejaVuSans-13af" transform="translate(1848.328125 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(1911.3125 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1952.421875 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(2004.515625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(2043.71875 0)"/>
+     <use xlink:href="#DejaVuSans-49" transform="translate(2075.5 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(2110.703125 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(2151.8125 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(2213.09375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(2310.5 0)"/>
+    </g>
+    <!-- Lower is better -->
+    <g style="fill: #eef2ff" transform="translate(155.78 43.02791) scale(0.15 -0.15)">
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(53.96875 0)"/>
+     <use xlink:href="#DejaVuSans-5a" transform="translate(115.15625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(196.9375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(258.46875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(299.578125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(331.359375 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(359.140625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(411.234375 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(443.015625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(506.5 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(568.03125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(607.234375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(646.4375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(707.96875 0)"/>
+    </g>
+   </g>
+   <g id="legend_1">
+    <g id="patch_28">
+     <path d="M 159.2566 61.625566 
+L 171.2566 61.625566 
+L 171.2566 54.625566 
+L 159.2566 54.625566 
+z
+" style="fill: #55d4d0"/>
+    </g>
+    <g id="text_42">
+     <!-- Native build -->
+     <g style="fill: #eef2ff" transform="translate(179.2566 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-31"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(74.8125 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(136.09375 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(175.296875 0)"/>
+      <use xlink:href="#DejaVuSans-59" transform="translate(203.078125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(262.265625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(323.796875 0)"/>
+      <use xlink:href="#DejaVuSans-45" transform="translate(355.578125 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(419.0625 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(482.4375 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(510.21875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(538 0)"/>
+     </g>
+    </g>
+    <g id="patch_29">
+     <path d="M 253.405037 61.625566 
+L 265.405037 61.625566 
+L 265.405037 54.625566 
+L 253.405037 54.625566 
+z
+" style="fill: #f4ad55"/>
+    </g>
+    <g id="text_43">
+     <!-- JVM, default -->
+     <g style="fill: #eef2ff" transform="translate(273.405037 61.625566) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-39" d="M 1831 0 
+L 50 4666 
+L 709 4666 
+L 2188 738 
+L 3669 4666 
+L 4325 4666 
+L 2547 0 
+L 1831 0 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(247.75 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(311.234375 0)"/>
+      <use xlink:href="#DejaVuSans-49" transform="translate(372.765625 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(407.96875 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(469.25 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(532.625 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(560.40625 0)"/>
+     </g>
+    </g>
+    <g id="patch_30">
+     <path d="M 347.365975 61.625566 
+L 359.365975 61.625566 
+L 359.365975 54.625566 
+L 347.365975 54.625566 
+z
+" style="fill: #9eafff"/>
+    </g>
+    <g id="text_44">
+     <!-- JVM, tuned -->
+     <g style="fill: #eef2ff" transform="translate(367.365975 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(247.75 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(286.953125 0)"/>
+      <use xlink:href="#DejaVuSans-51" transform="translate(350.328125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(413.703125 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(475.234375 0)"/>
+     </g>
+    </g>
+   </g>
+  </g>
+  <g id="text_45">
+   <!-- Ubuntu 24.04.5 LTS, aarch64, in a container on Apple M4 Max -->
+   <g style="fill: #c3cbe6" transform="translate(465.21375 857.714925) scale(0.08 -0.08)">
+    <defs>
+     <path id="DejaVuSans-38" d="M 556 4666 
+L 1191 4666 
+L 1191 1831 
+Q 1191 1081 1462 751 
+Q 1734 422 2344 422 
+Q 2950 422 3222 751 
+Q 3494 1081 3494 1831 
+L 3494 4666 
+L 4128 4666 
+L 4128 1753 
+Q 4128 841 3676 375 
+Q 3225 -91 2344 -91 
+Q 1459 -91 1007 375 
+Q 556 841 556 1753 
+L 556 4666 
+z
+" transform="scale(0.015625)"/>
+     <path id="DejaVuSans-37" d="M -19 4666 
+L 3928 4666 
+L 3928 4134 
+L 2272 4134 
+L 2272 0 
+L 1638 0 
+L 1638 4134 
+L -19 4134 
+L -19 4666 
+z
+" transform="scale(0.015625)"/>
+    </defs>
+    <use xlink:href="#DejaVuSans-38"/>
+    <use xlink:href="#DejaVuSans-45" transform="translate(73.1875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(136.671875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(200.046875 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(263.421875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(302.625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(366 0)"/>
+    <use xlink:href="#DejaVuSans-15" transform="translate(397.78125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(461.40625 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(525.03125 0)"/>
+    <use xlink:href="#DejaVuSans-13" transform="translate(556.8125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(620.4375 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(684.0625 0)"/>
+    <use xlink:href="#DejaVuSans-18" transform="translate(715.84375 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(779.46875 0)"/>
+    <use xlink:href="#DejaVuSans-2f" transform="translate(811.25 0)"/>
+    <use xlink:href="#DejaVuSans-37" transform="translate(853.203125 0)"/>
+    <use xlink:href="#DejaVuSans-36" transform="translate(914.28125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(977.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1009.546875 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1041.328125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1102.609375 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(1163.890625 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1202.796875 0)"/>
+    <use xlink:href="#DejaVuSans-4b" transform="translate(1257.78125 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(1321.15625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(1384.78125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(1448.40625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1480.1875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(1511.96875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1539.75 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1603.125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1634.90625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1696.1875 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1727.96875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(1782.953125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1844.140625 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(1907.515625 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1946.71875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(2008 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2035.78125 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2099.15625 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(2160.6875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2201.796875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(2233.578125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2294.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2358.140625 0)"/>
+    <use xlink:href="#DejaVuSans-24" transform="translate(2389.921875 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2458.328125 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2521.8125 0)"/>
+    <use xlink:href="#DejaVuSans-4f" transform="translate(2585.296875 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2613.078125 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2674.609375 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2706.390625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(2792.671875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2856.296875 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2888.078125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(2974.359375 0)"/>
+    <use xlink:href="#DejaVuSans-5b" transform="translate(3035.640625 0)"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p4f30f1d0c9">
+   <rect x="155.78" y="73.02791" width="552.34" height="727.86249"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/developer-guide/img/desktop-compat-linux-size-zipped.svg b/docs/developer-guide/img/desktop-compat-linux-size-zipped.svg
new file mode 100644
index 00000000000..2622d7747b5
--- /dev/null
+++ b/docs/developer-guide/img/desktop-compat-linux-size-zipped.svg
@@ -0,0 +1,1938 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="720pt" height="672.48pt" viewBox="0 0 720 672.48" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 672.48 
+L 720 672.48 
+L 720 0 
+L 0 0 
+z
+" style="fill: #0b132b"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 155.78 610.9256 
+L 708.12 610.9256 
+L 708.12 73.02791 
+L 155.78 73.02791 
+z
+" style="fill: #0b132b"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <path d="M 155.78 610.9256 
+L 155.78 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_2"/>
+     <g id="text_1">
+      <!-- 0 -->
+      <g style="fill: #c3cbe6" transform="translate(152.280625 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-13" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-13"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <path d="M 218.817018 610.9256 
+L 218.817018 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_4"/>
+     <g id="text_2">
+      <!-- 5 -->
+      <g style="fill: #c3cbe6" transform="translate(215.317643 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-18" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-18"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <path d="M 281.854037 610.9256 
+L 281.854037 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_6"/>
+     <g id="text_3">
+      <!-- 10 -->
+      <g style="fill: #c3cbe6" transform="translate(274.855287 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-14" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <path d="M 344.891055 610.9256 
+L 344.891055 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_8"/>
+     <g id="text_4">
+      <!-- 15 -->
+      <g style="fill: #c3cbe6" transform="translate(337.892305 622.783022) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <path d="M 407.928073 610.9256 
+L 407.928073 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_10"/>
+     <g id="text_5">
+      <!-- 20 -->
+      <g style="fill: #c3cbe6" transform="translate(400.929323 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-15" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_11">
+      <path d="M 470.965092 610.9256 
+L 470.965092 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_12"/>
+     <g id="text_6">
+      <!-- 25 -->
+      <g style="fill: #c3cbe6" transform="translate(463.966342 622.783022) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_13">
+      <path d="M 534.00211 610.9256 
+L 534.00211 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_14"/>
+     <g id="text_7">
+      <!-- 30 -->
+      <g style="fill: #c3cbe6" transform="translate(527.00336 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-16" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-16"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_8">
+     <g id="line2d_15">
+      <path d="M 597.039128 610.9256 
+L 597.039128 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_16"/>
+     <g id="text_8">
+      <!-- 35 -->
+      <g style="fill: #c3cbe6" transform="translate(590.040378 622.783022) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-16"/>
+       <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_9">
+     <g id="line2d_17">
+      <path d="M 660.076146 610.9256 
+L 660.076146 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_18"/>
+     <g id="text_9">
+      <!-- 40 -->
+      <g style="fill: #c3cbe6" transform="translate(653.077396 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-17" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-17"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_10">
+     <!-- MB -->
+     <g style="fill: #c3cbe6" transform="translate(423.431016 637.783022) scale(0.11 -0.11)">
+      <defs>
+       <path id="DejaVuSans-30" d="M 628 4666 
+L 1569 4666 
+L 2759 1491 
+L 3956 4666 
+L 4897 4666 
+L 4897 0 
+L 4281 0 
+L 4281 4097 
+L 3078 897 
+L 2444 897 
+L 1241 4097 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-25" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-30"/>
+      <use xlink:href="#DejaVuSans-25" transform="translate(86.28125 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_19"/>
+     <g id="text_11">
+      <!-- swing-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(35.447969 125.147031) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-56" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5a" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4c" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-51" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4a" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-10" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-44" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4f" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-48" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-55" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5c" d="M 2059 -325 
+Q 1816 -950 1584 -1140 
+Q 1353 -1331 966 -1331 
+L 506 -1331 
+L 506 -850 
+L 844 -850 
+Q 1081 -850 1212 -737 
+Q 1344 -625 1503 -206 
+L 1606 56 
+L 191 3500 
+L 800 3500 
+L 1894 763 
+L 2988 3500 
+L 3597 3500 
+L 2059 -325 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-3" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-50" d="M 3328 2828 
+Q 3544 3216 3844 3400 
+Q 4144 3584 4550 3584 
+Q 5097 3584 5394 3201 
+Q 5691 2819 5691 2113 
+L 5691 0 
+L 5113 0 
+L 5113 2094 
+Q 5113 2597 4934 2840 
+Q 4756 3084 4391 3084 
+Q 3944 3084 3684 2787 
+Q 3425 2491 3425 1978 
+L 3425 0 
+L 2847 0 
+L 2847 2094 
+Q 2847 2600 2669 2842 
+Q 2491 3084 2119 3084 
+Q 1678 3084 1418 2786 
+Q 1159 2488 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1356 3278 1631 3431 
+Q 1906 3584 2284 3584 
+Q 2666 3584 2933 3390 
+Q 3200 3197 3328 2828 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-53" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-56"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(52.09375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(133.875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(161.65625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(225.03125 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(288.515625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(324.59375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(388.078125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(449.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(477.140625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(504.921875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(566.453125 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(607.5625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(666.75 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(698.53125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(750.625 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(811.90625 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(909.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(972.796875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1000.578125 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_20"/>
+     <g id="text_12">
+      <!-- SwingSet2, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(12.066094 188.292421) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-57" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-f" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4b" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 628 4666 
+L 1259 4666 
+L 1259 325 
+Q 1259 -519 939 -900 
+Q 619 -1281 -91 -1281 
+L -331 -1281 
+L -331 -750 
+L -134 -750 
+Q 284 -750 456 -515 
+Q 628 -281 628 325 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-27" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 628 4666 
+L 1259 4666 
+L 1259 2694 
+L 3353 4666 
+L 4166 4666 
+L 1850 2491 
+L 4331 0 
+L 3500 0 
+L 1259 2247 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-47" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-52" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(63.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(145.265625 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(173.046875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(236.421875 0)"/>
+       <use xlink:href="#DejaVuSans-36" transform="translate(299.90625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(363.390625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(424.921875 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(464.125 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(559.53125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(591.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(630.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(693.890625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(755.421875 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(787.203125 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(816.703125 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(893.703125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(959.28125 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(991.0625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1054.546875 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1116.078125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1213.484375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_21"/>
+     <g id="text_13">
+      <!-- Notepad, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(23.370313 251.437811) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 628 4666 
+L 1478 4666 
+L 3547 763 
+L 3547 4666 
+L 4159 4666 
+L 4159 0 
+L 3309 0 
+L 1241 3903 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(74.8125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(136 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(175.203125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(236.734375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(300.21875 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(361.5 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(424.984375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(456.765625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(488.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(591.125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(652.65625 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(684.4375 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(790.9375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(856.515625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(888.296875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(951.78125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1013.3125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1110.71875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_22"/>
+     <g id="text_14">
+      <!-- Falling-blocks game -->
+      <g style="fill: #c3cbe6" transform="translate(43.508906 314.583201) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-29" d="M 628 4666 
+L 3309 4666 
+L 3309 4134 
+L 1259 4134 
+L 1259 2759 
+L 3109 2759 
+L 3109 2228 
+L 1259 2228 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-45" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-46" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4e" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-29"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(48.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(109.625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(137.40625 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(165.1875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(192.96875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(256.34375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(319.828125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(355.90625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(419.390625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(447.171875 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(508.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(563.34375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(621.25 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(673.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(705.125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(768.609375 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(829.890625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(927.296875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_23"/>
+     <g id="text_15">
+      <!-- javafx-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(33.753281 377.728591) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-4d" d="M 603 3500 
+L 1178 3500 
+L 1178 -63 
+Q 1178 -731 923 -1031 
+Q 669 -1331 103 -1331 
+L -116 -1331 
+L -116 -844 
+L 38 -844 
+Q 366 -844 484 -692 
+Q 603 -541 603 -63 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-59" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-49" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5b" d="M 3513 3500 
+L 2247 1797 
+L 3578 0 
+L 2900 0 
+L 1881 1375 
+L 863 0 
+L 184 0 
+L 1544 1831 
+L 300 3500 
+L 978 3500 
+L 1906 2253 
+L 2834 3500 
+L 3513 3500 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4d"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(27.78125 0)"/>
+       <use xlink:href="#DejaVuSans-59" transform="translate(89.0625 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(148.25 0)"/>
+       <use xlink:href="#DejaVuSans-49" transform="translate(209.53125 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(244.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(303.921875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(340 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(403.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(464.765625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(492.546875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(520.328125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(581.859375 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(622.96875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(682.15625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(766.03125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(827.3125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(924.71875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(988.203125 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1015.984375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_24"/>
+     <g id="text_16">
+      <!-- Open-source 2048 game -->
+      <g style="fill: #c3cbe6" transform="translate(16.206562 440.873551) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 2522 4238 
+Q 1834 4238 1429 3725 
+Q 1025 3213 1025 2328 
+Q 1025 1447 1429 934 
+Q 1834 422 2522 422 
+Q 3209 422 3611 934 
+Q 4013 1447 4013 2328 
+Q 4013 3213 3611 3725 
+Q 3209 4238 2522 4238 
+z
+M 2522 4750 
+Q 3503 4750 4090 4092 
+Q 4678 3434 4678 2328 
+Q 4678 1225 4090 567 
+Q 3503 -91 2522 -91 
+Q 1538 -91 948 565 
+Q 359 1222 359 2328 
+Q 359 3434 948 4092 
+Q 1538 4750 2522 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-58" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-1b" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(78.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(142.203125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(203.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(267.109375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(303.1875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(355.28125 0)"/>
+       <use xlink:href="#DejaVuSans-58" transform="translate(416.46875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(479.84375 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(518.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(573.734375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(635.265625 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(667.046875 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(730.671875 0)"/>
+       <use xlink:href="#DejaVuSans-17" transform="translate(794.296875 0)"/>
+       <use xlink:href="#DejaVuSans-1b" transform="translate(857.921875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(921.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(953.328125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(1016.8125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1078.09375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1175.5 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_25"/>
+     <g id="text_17">
+      <!-- Address book -->
+      <g style="fill: #c3cbe6" transform="translate(78.162344 504.019371) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-24" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-24"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(66.65625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(130.140625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(193.625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(232.53125 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(294.0625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(346.15625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(398.25 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(430.03125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(493.515625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(554.703125 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(615.890625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_26"/>
+     <g id="text_18">
+      <!-- Mandelbrot explorer -->
+      <g style="fill: #c3cbe6" transform="translate(41.040781 567.164761) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(86.28125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(147.5625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(210.9375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(274.421875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(335.953125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(363.734375 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(427.21875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(466.125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(527.3125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(566.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(598.296875 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(658.078125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(717.265625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(780.75 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(808.53125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(869.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(908.625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(970.15625 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 155.78 97.477805 
+L 246.556009 97.477805 
+L 246.556009 119.199819 
+L 155.78 119.199819 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 155.78 122.735961 
+L 592.167288 122.735961 
+L 592.167288 144.457975 
+L 155.78 144.457975 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 155.78 160.623195 
+L 259.184117 160.623195 
+L 259.184117 182.345209 
+L 155.78 182.345209 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 155.78 185.881351 
+L 585.65123 185.881351 
+L 585.65123 207.603365 
+L 155.78 207.603365 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 155.78 223.768585 
+L 238.275595 223.768585 
+L 238.275595 245.490599 
+L 155.78 245.490599 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 155.78 249.026741 
+L 569.009821 249.026741 
+L 569.009821 270.748755 
+L 155.78 270.748755 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_9">
+    <path d="M 155.78 286.913975 
+L 236.668241 286.913975 
+L 236.668241 308.635989 
+L 155.78 308.635989 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 155.78 312.172131 
+L 567.544571 312.172131 
+L 567.544571 333.894145 
+L 155.78 333.894145 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 155.78 350.059365 
+L 244.724119 350.059365 
+L 244.724119 371.781379 
+L 155.78 371.781379 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_12">
+    <path d="M 155.78 375.317521 
+L 648.47612 375.317521 
+L 648.47612 397.039535 
+L 155.78 397.039535 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_13">
+    <path d="M 155.78 413.204755 
+L 240.564975 413.204755 
+L 240.564975 434.926769 
+L 155.78 434.926769 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_14">
+    <path d="M 155.78 438.462911 
+L 648.940714 438.462911 
+L 648.940714 460.184925 
+L 155.78 460.184925 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_15">
+    <path d="M 155.78 476.350145 
+L 238.201952 476.350145 
+L 238.201952 498.072159 
+L 155.78 498.072159 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 155.78 501.608301 
+L 648.10847 501.608301 
+L 648.10847 523.330315 
+L 155.78 523.330315 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 155.78 539.495535 
+L 237.739053 539.495535 
+L 237.739053 561.217549 
+L 155.78 561.217549 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 155.78 564.753691 
+L 646.49027 564.753691 
+L 646.49027 586.475705 
+L 155.78 586.475705 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_19">
+    <path d="M 155.78 610.9256 
+L 708.12 610.9256 
+" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_19">
+    <!-- 7.2 -->
+    <g style="fill: #eef2ff" transform="translate(252.473938 110.676703) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1a" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-11" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-1a"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_20">
+    <!-- 34.6 -->
+    <g style="fill: #eef2ff" transform="translate(598.085216 135.934859) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-19" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_21">
+    <!-- 8.2 -->
+    <g style="fill: #eef2ff" transform="translate(265.102046 173.822093) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_22">
+    <!-- 34.1 -->
+    <g style="fill: #eef2ff" transform="translate(591.569158 199.080249) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_23">
+    <!-- 6.5 -->
+    <g style="fill: #eef2ff" transform="translate(244.193524 236.967483) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_24">
+    <!-- 32.8 -->
+    <g style="fill: #eef2ff" transform="translate(574.92775 262.225639) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_25">
+    <!-- 6.4 -->
+    <g style="fill: #eef2ff" transform="translate(242.586169 300.112873) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_26">
+    <!-- 32.7 -->
+    <g style="fill: #eef2ff" transform="translate(573.462499 325.371029) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_27">
+    <!-- 7.1 -->
+    <g style="fill: #eef2ff" transform="translate(250.642047 363.258263) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1a"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_28">
+    <!-- 39.1 -->
+    <g style="fill: #eef2ff" transform="translate(654.394048 388.516419) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1c" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_29">
+    <!-- 6.7 -->
+    <g style="fill: #eef2ff" transform="translate(246.482903 426.403653) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_30">
+    <!-- 39.1 -->
+    <g style="fill: #eef2ff" transform="translate(654.858643 451.661809) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_31">
+    <!-- 6.5 -->
+    <g style="fill: #eef2ff" transform="translate(244.119881 489.549043) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_32">
+    <!-- 39.1 -->
+    <g style="fill: #eef2ff" transform="translate(654.026398 514.807199) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_33">
+    <!-- 6.5 -->
+    <g style="fill: #eef2ff" transform="translate(243.656982 552.694433) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(95.40625 0)"/>
+    </g>
+   </g>
+   <g id="text_34">
+    <!-- 38.9 -->
+    <g style="fill: #eef2ff" transform="translate(652.408199 577.952589) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_35">
+    <!-- Linux: the application as downloaded, zipped -->
+    <g style="fill: #eef2ff" transform="translate(155.78 25.023809) scale(0.15 -0.15)">
+     <defs>
+      <path id="DejaVuSans-2f" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-1d" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-5d" d="M 353 3500 
+L 3084 3500 
+L 3084 2975 
+L 922 459 
+L 3084 459 
+L 3084 0 
+L 275 0 
+L 275 525 
+L 2438 3041 
+L 353 3041 
+L 353 3500 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(55.71875 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(83.5 0)"/>
+     <use xlink:href="#DejaVuSans-58" transform="translate(146.875 0)"/>
+     <use xlink:href="#DejaVuSans-5b" transform="translate(210.25 0)"/>
+     <use xlink:href="#DejaVuSans-1d" transform="translate(269.4375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(303.125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(334.90625 0)"/>
+     <use xlink:href="#DejaVuSans-4b" transform="translate(374.109375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(437.484375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(499.015625 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(530.796875 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(592.078125 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(655.5625 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(719.046875 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(746.828125 0)"/>
+     <use xlink:href="#DejaVuSans-46" transform="translate(774.609375 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(829.59375 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(890.875 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(930.078125 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(957.859375 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1019.046875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1082.421875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1114.203125 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1175.484375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1227.578125 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1259.359375 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(1322.84375 0)"/>
+     <use xlink:href="#DejaVuSans-5a" transform="translate(1384.03125 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1465.8125 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(1529.1875 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(1556.96875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1618.15625 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1679.4375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1742.921875 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1804.453125 0)"/>
+     <use xlink:href="#DejaVuSans-f" transform="translate(1867.9375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1899.71875 0)"/>
+     <use xlink:href="#DejaVuSans-5d" transform="translate(1931.5 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(1983.984375 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(2011.765625 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(2075.25 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(2138.734375 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(2200.265625 0)"/>
+    </g>
+    <!-- Lower is better -->
+    <g style="fill: #eef2ff" transform="translate(155.78 43.02791) scale(0.15 -0.15)">
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(53.96875 0)"/>
+     <use xlink:href="#DejaVuSans-5a" transform="translate(115.15625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(196.9375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(258.46875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(299.578125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(331.359375 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(359.140625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(411.234375 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(443.015625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(506.5 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(568.03125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(607.234375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(646.4375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(707.96875 0)"/>
+    </g>
+   </g>
+   <g id="legend_1">
+    <g id="patch_20">
+     <path d="M 159.2566 61.625566 
+L 171.2566 61.625566 
+L 171.2566 54.625566 
+L 159.2566 54.625566 
+z
+" style="fill: #55d4d0"/>
+    </g>
+    <g id="text_36">
+     <!-- Native build -->
+     <g style="fill: #eef2ff" transform="translate(179.2566 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-31"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(74.8125 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(136.09375 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(175.296875 0)"/>
+      <use xlink:href="#DejaVuSans-59" transform="translate(203.078125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(262.265625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(323.796875 0)"/>
+      <use xlink:href="#DejaVuSans-45" transform="translate(355.578125 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(419.0625 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(482.4375 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(510.21875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(538 0)"/>
+     </g>
+    </g>
+    <g id="patch_21">
+     <path d="M 253.405037 61.625566 
+L 265.405037 61.625566 
+L 265.405037 54.625566 
+L 253.405037 54.625566 
+z
+" style="fill: #f4ad55"/>
+    </g>
+    <g id="text_37">
+     <!-- JVM image, jlink -->
+     <g style="fill: #eef2ff" transform="translate(273.405037 61.625566) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-39" d="M 1831 0 
+L 50 4666 
+L 709 4666 
+L 2188 738 
+L 3669 4666 
+L 4325 4666 
+L 2547 0 
+L 1831 0 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-50" transform="translate(243.75 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(341.15625 0)"/>
+      <use xlink:href="#DejaVuSans-4a" transform="translate(402.4375 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(465.921875 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(527.453125 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(559.234375 0)"/>
+      <use xlink:href="#DejaVuSans-4d" transform="translate(591.015625 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(618.796875 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(646.578125 0)"/>
+      <use xlink:href="#DejaVuSans-51" transform="translate(674.359375 0)"/>
+      <use xlink:href="#DejaVuSans-4e" transform="translate(737.734375 0)"/>
+     </g>
+    </g>
+   </g>
+  </g>
+  <g id="text_38">
+   <!-- Ubuntu 24.04.5 LTS, aarch64, in a container on Apple M4 Max -->
+   <g style="fill: #c3cbe6" transform="translate(465.21375 663.833325) scale(0.08 -0.08)">
+    <defs>
+     <path id="DejaVuSans-38" d="M 556 4666 
+L 1191 4666 
+L 1191 1831 
+Q 1191 1081 1462 751 
+Q 1734 422 2344 422 
+Q 2950 422 3222 751 
+Q 3494 1081 3494 1831 
+L 3494 4666 
+L 4128 4666 
+L 4128 1753 
+Q 4128 841 3676 375 
+Q 3225 -91 2344 -91 
+Q 1459 -91 1007 375 
+Q 556 841 556 1753 
+L 556 4666 
+z
+" transform="scale(0.015625)"/>
+     <path id="DejaVuSans-37" d="M -19 4666 
+L 3928 4666 
+L 3928 4134 
+L 2272 4134 
+L 2272 0 
+L 1638 0 
+L 1638 4134 
+L -19 4134 
+L -19 4666 
+z
+" transform="scale(0.015625)"/>
+    </defs>
+    <use xlink:href="#DejaVuSans-38"/>
+    <use xlink:href="#DejaVuSans-45" transform="translate(73.1875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(136.671875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(200.046875 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(263.421875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(302.625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(366 0)"/>
+    <use xlink:href="#DejaVuSans-15" transform="translate(397.78125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(461.40625 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(525.03125 0)"/>
+    <use xlink:href="#DejaVuSans-13" transform="translate(556.8125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(620.4375 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(684.0625 0)"/>
+    <use xlink:href="#DejaVuSans-18" transform="translate(715.84375 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(779.46875 0)"/>
+    <use xlink:href="#DejaVuSans-2f" transform="translate(811.25 0)"/>
+    <use xlink:href="#DejaVuSans-37" transform="translate(853.203125 0)"/>
+    <use xlink:href="#DejaVuSans-36" transform="translate(914.28125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(977.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1009.546875 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1041.328125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1102.609375 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(1163.890625 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1202.796875 0)"/>
+    <use xlink:href="#DejaVuSans-4b" transform="translate(1257.78125 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(1321.15625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(1384.78125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(1448.40625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1480.1875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(1511.96875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1539.75 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1603.125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1634.90625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1696.1875 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1727.96875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(1782.953125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1844.140625 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(1907.515625 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1946.71875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(2008 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2035.78125 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2099.15625 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(2160.6875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2201.796875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(2233.578125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2294.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2358.140625 0)"/>
+    <use xlink:href="#DejaVuSans-24" transform="translate(2389.921875 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2458.328125 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2521.8125 0)"/>
+    <use xlink:href="#DejaVuSans-4f" transform="translate(2585.296875 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2613.078125 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2674.609375 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2706.390625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(2792.671875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2856.296875 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2888.078125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(2974.359375 0)"/>
+    <use xlink:href="#DejaVuSans-5b" transform="translate(3035.640625 0)"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p95e3599853">
+   <rect x="155.78" y="73.02791" width="552.34" height="537.89769"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/developer-guide/img/desktop-compat-linux-size.svg b/docs/developer-guide/img/desktop-compat-linux-size.svg
new file mode 100644
index 00000000000..c4df259c6e8
--- /dev/null
+++ b/docs/developer-guide/img/desktop-compat-linux-size.svg
@@ -0,0 +1,1895 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="720pt" height="672.48pt" viewBox="0 0 720 672.48" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 672.48 
+L 720 672.48 
+L 720 0 
+L 0 0 
+z
+" style="fill: #0b132b"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 155.78 610.9256 
+L 708.12 610.9256 
+L 708.12 73.02791 
+L 155.78 73.02791 
+z
+" style="fill: #0b132b"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <path d="M 155.78 610.9256 
+L 155.78 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_2"/>
+     <g id="text_1">
+      <!-- 0 -->
+      <g style="fill: #c3cbe6" transform="translate(152.280625 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-13" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-13"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <path d="M 235.868838 610.9256 
+L 235.868838 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_4"/>
+     <g id="text_2">
+      <!-- 10 -->
+      <g style="fill: #c3cbe6" transform="translate(228.870088 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-14" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <path d="M 315.957676 610.9256 
+L 315.957676 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_6"/>
+     <g id="text_3">
+      <!-- 20 -->
+      <g style="fill: #c3cbe6" transform="translate(308.958926 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-15" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <path d="M 396.046515 610.9256 
+L 396.046515 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_8"/>
+     <g id="text_4">
+      <!-- 30 -->
+      <g style="fill: #c3cbe6" transform="translate(389.047765 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-16" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-16"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <path d="M 476.135353 610.9256 
+L 476.135353 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_10"/>
+     <g id="text_5">
+      <!-- 40 -->
+      <g style="fill: #c3cbe6" transform="translate(469.136603 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-17" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-17"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_11">
+      <path d="M 556.224191 610.9256 
+L 556.224191 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_12"/>
+     <g id="text_6">
+      <!-- 50 -->
+      <g style="fill: #c3cbe6" transform="translate(549.225441 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-18" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-18"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_13">
+      <path d="M 636.313029 610.9256 
+L 636.313029 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_14"/>
+     <g id="text_7">
+      <!-- 60 -->
+      <g style="fill: #c3cbe6" transform="translate(629.314279 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-19" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-19"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_8">
+     <!-- MB -->
+     <g style="fill: #c3cbe6" transform="translate(423.431016 637.783022) scale(0.11 -0.11)">
+      <defs>
+       <path id="DejaVuSans-30" d="M 628 4666 
+L 1569 4666 
+L 2759 1491 
+L 3956 4666 
+L 4897 4666 
+L 4897 0 
+L 4281 0 
+L 4281 4097 
+L 3078 897 
+L 2444 897 
+L 1241 4097 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-25" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-30"/>
+      <use xlink:href="#DejaVuSans-25" transform="translate(86.28125 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_15"/>
+     <g id="text_9">
+      <!-- swing-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(35.447969 125.147031) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-56" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5a" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4c" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-51" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4a" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-10" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-44" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4f" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-48" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-55" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5c" d="M 2059 -325 
+Q 1816 -950 1584 -1140 
+Q 1353 -1331 966 -1331 
+L 506 -1331 
+L 506 -850 
+L 844 -850 
+Q 1081 -850 1212 -737 
+Q 1344 -625 1503 -206 
+L 1606 56 
+L 191 3500 
+L 800 3500 
+L 1894 763 
+L 2988 3500 
+L 3597 3500 
+L 2059 -325 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-3" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-50" d="M 3328 2828 
+Q 3544 3216 3844 3400 
+Q 4144 3584 4550 3584 
+Q 5097 3584 5394 3201 
+Q 5691 2819 5691 2113 
+L 5691 0 
+L 5113 0 
+L 5113 2094 
+Q 5113 2597 4934 2840 
+Q 4756 3084 4391 3084 
+Q 3944 3084 3684 2787 
+Q 3425 2491 3425 1978 
+L 3425 0 
+L 2847 0 
+L 2847 2094 
+Q 2847 2600 2669 2842 
+Q 2491 3084 2119 3084 
+Q 1678 3084 1418 2786 
+Q 1159 2488 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1356 3278 1631 3431 
+Q 1906 3584 2284 3584 
+Q 2666 3584 2933 3390 
+Q 3200 3197 3328 2828 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-53" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-56"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(52.09375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(133.875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(161.65625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(225.03125 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(288.515625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(324.59375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(388.078125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(449.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(477.140625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(504.921875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(566.453125 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(607.5625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(666.75 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(698.53125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(750.625 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(811.90625 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(909.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(972.796875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1000.578125 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_16"/>
+     <g id="text_10">
+      <!-- SwingSet2, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(12.066094 188.292421) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-57" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-f" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4b" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 628 4666 
+L 1259 4666 
+L 1259 325 
+Q 1259 -519 939 -900 
+Q 619 -1281 -91 -1281 
+L -331 -1281 
+L -331 -750 
+L -134 -750 
+Q 284 -750 456 -515 
+Q 628 -281 628 325 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-27" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 628 4666 
+L 1259 4666 
+L 1259 2694 
+L 3353 4666 
+L 4166 4666 
+L 1850 2491 
+L 4331 0 
+L 3500 0 
+L 1259 2247 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-47" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-52" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(63.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(145.265625 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(173.046875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(236.421875 0)"/>
+       <use xlink:href="#DejaVuSans-36" transform="translate(299.90625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(363.390625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(424.921875 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(464.125 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(559.53125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(591.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(630.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(693.890625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(755.421875 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(787.203125 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(816.703125 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(893.703125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(959.28125 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(991.0625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1054.546875 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1116.078125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1213.484375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_17"/>
+     <g id="text_11">
+      <!-- Notepad, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(23.370313 251.437811) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 628 4666 
+L 1478 4666 
+L 3547 763 
+L 3547 4666 
+L 4159 4666 
+L 4159 0 
+L 3309 0 
+L 1241 3903 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(74.8125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(136 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(175.203125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(236.734375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(300.21875 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(361.5 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(424.984375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(456.765625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(488.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(591.125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(652.65625 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(684.4375 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(790.9375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(856.515625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(888.296875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(951.78125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1013.3125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1110.71875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_18"/>
+     <g id="text_12">
+      <!-- Falling-blocks game -->
+      <g style="fill: #c3cbe6" transform="translate(43.508906 314.583201) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-29" d="M 628 4666 
+L 3309 4666 
+L 3309 4134 
+L 1259 4134 
+L 1259 2759 
+L 3109 2759 
+L 3109 2228 
+L 1259 2228 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-45" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-46" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4e" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-29"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(48.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(109.625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(137.40625 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(165.1875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(192.96875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(256.34375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(319.828125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(355.90625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(419.390625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(447.171875 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(508.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(563.34375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(621.25 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(673.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(705.125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(768.609375 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(829.890625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(927.296875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_19"/>
+     <g id="text_13">
+      <!-- javafx-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(33.753281 377.728591) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-4d" d="M 603 3500 
+L 1178 3500 
+L 1178 -63 
+Q 1178 -731 923 -1031 
+Q 669 -1331 103 -1331 
+L -116 -1331 
+L -116 -844 
+L 38 -844 
+Q 366 -844 484 -692 
+Q 603 -541 603 -63 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-59" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-49" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5b" d="M 3513 3500 
+L 2247 1797 
+L 3578 0 
+L 2900 0 
+L 1881 1375 
+L 863 0 
+L 184 0 
+L 1544 1831 
+L 300 3500 
+L 978 3500 
+L 1906 2253 
+L 2834 3500 
+L 3513 3500 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4d"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(27.78125 0)"/>
+       <use xlink:href="#DejaVuSans-59" transform="translate(89.0625 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(148.25 0)"/>
+       <use xlink:href="#DejaVuSans-49" transform="translate(209.53125 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(244.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(303.921875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(340 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(403.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(464.765625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(492.546875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(520.328125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(581.859375 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(622.96875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(682.15625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(766.03125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(827.3125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(924.71875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(988.203125 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1015.984375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_20"/>
+     <g id="text_14">
+      <!-- Open-source 2048 game -->
+      <g style="fill: #c3cbe6" transform="translate(16.206562 440.873551) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 2522 4238 
+Q 1834 4238 1429 3725 
+Q 1025 3213 1025 2328 
+Q 1025 1447 1429 934 
+Q 1834 422 2522 422 
+Q 3209 422 3611 934 
+Q 4013 1447 4013 2328 
+Q 4013 3213 3611 3725 
+Q 3209 4238 2522 4238 
+z
+M 2522 4750 
+Q 3503 4750 4090 4092 
+Q 4678 3434 4678 2328 
+Q 4678 1225 4090 567 
+Q 3503 -91 2522 -91 
+Q 1538 -91 948 565 
+Q 359 1222 359 2328 
+Q 359 3434 948 4092 
+Q 1538 4750 2522 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-58" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-1b" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(78.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(142.203125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(203.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(267.109375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(303.1875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(355.28125 0)"/>
+       <use xlink:href="#DejaVuSans-58" transform="translate(416.46875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(479.84375 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(518.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(573.734375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(635.265625 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(667.046875 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(730.671875 0)"/>
+       <use xlink:href="#DejaVuSans-17" transform="translate(794.296875 0)"/>
+       <use xlink:href="#DejaVuSans-1b" transform="translate(857.921875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(921.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(953.328125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(1016.8125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1078.09375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1175.5 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_21"/>
+     <g id="text_15">
+      <!-- Address book -->
+      <g style="fill: #c3cbe6" transform="translate(78.162344 504.019371) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-24" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-24"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(66.65625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(130.140625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(193.625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(232.53125 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(294.0625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(346.15625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(398.25 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(430.03125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(493.515625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(554.703125 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(615.890625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_22"/>
+     <g id="text_16">
+      <!-- Mandelbrot explorer -->
+      <g style="fill: #c3cbe6" transform="translate(41.040781 567.164761) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(86.28125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(147.5625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(210.9375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(274.421875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(335.953125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(363.734375 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(427.21875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(466.125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(527.3125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(566.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(598.296875 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(658.078125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(717.265625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(780.75 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(808.53125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(869.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(908.625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(970.15625 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 155.78 97.477805 
+L 312.723987 97.477805 
+L 312.723987 119.199819 
+L 155.78 119.199819 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 155.78 122.735961 
+L 606.491834 122.735961 
+L 606.491834 144.457975 
+L 155.78 144.457975 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 155.78 160.623195 
+L 319.752169 160.623195 
+L 319.752169 182.345209 
+L 155.78 182.345209 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 155.78 185.881351 
+L 601.187228 185.881351 
+L 601.187228 207.603365 
+L 155.78 207.603365 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 155.78 223.768585 
+L 297.905731 223.768585 
+L 297.905731 245.490599 
+L 155.78 245.490599 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 155.78 249.026741 
+L 590.340273 249.026741 
+L 590.340273 270.748755 
+L 155.78 270.748755 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_9">
+    <path d="M 155.78 286.913975 
+L 295.110822 286.913975 
+L 295.110822 308.635989 
+L 155.78 308.635989 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 155.78 312.172131 
+L 589.35049 312.172131 
+L 589.35049 333.894145 
+L 155.78 333.894145 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 155.78 350.059365 
+L 310.797717 350.059365 
+L 310.797717 371.781379 
+L 155.78 371.781379 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_12">
+    <path d="M 155.78 375.317521 
+L 648.940714 375.317521 
+L 648.940714 397.039535 
+L 155.78 397.039535 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_13">
+    <path d="M 155.78 413.204755 
+L 302.561897 413.204755 
+L 302.561897 434.926769 
+L 155.78 434.926769 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_14">
+    <path d="M 155.78 438.462911 
+L 648.929105 438.462911 
+L 648.929105 460.184925 
+L 155.78 460.184925 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_15">
+    <path d="M 155.78 476.350145 
+L 298.24748 476.350145 
+L 298.24748 498.072159 
+L 155.78 498.072159 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 155.78 501.608301 
+L 648.695333 501.608301 
+L 648.695333 523.330315 
+L 155.78 523.330315 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 155.78 539.495535 
+L 297.758045 539.495535 
+L 297.758045 561.217549 
+L 155.78 561.217549 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 155.78 564.753691 
+L 647.112644 564.753691 
+L 647.112644 586.475705 
+L 155.78 586.475705 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_19">
+    <path d="M 155.78 610.9256 
+L 708.12 610.9256 
+" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_17">
+    <!-- 19.6 -->
+    <g style="fill: #eef2ff" transform="translate(318.641915 110.676703) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1c" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-11" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_18">
+    <!-- 56.3 -->
+    <g style="fill: #eef2ff" transform="translate(612.409762 135.934859) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_19">
+    <!-- 20.5 -->
+    <g style="fill: #eef2ff" transform="translate(325.670097 173.822093) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_20">
+    <!-- 55.6 -->
+    <g style="fill: #eef2ff" transform="translate(607.105157 199.080249) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_21">
+    <!-- 17.7 -->
+    <g style="fill: #eef2ff" transform="translate(303.82366 236.967483) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1a" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_22">
+    <!-- 54.3 -->
+    <g style="fill: #eef2ff" transform="translate(596.258202 262.225639) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_23">
+    <!-- 17.4 -->
+    <g style="fill: #eef2ff" transform="translate(301.02875 300.112873) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_24">
+    <!-- 54.1 -->
+    <g style="fill: #eef2ff" transform="translate(595.268419 325.371029) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_25">
+    <!-- 19.4 -->
+    <g style="fill: #eef2ff" transform="translate(316.715645 363.258263) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_26">
+    <!-- 61.6 -->
+    <g style="fill: #eef2ff" transform="translate(654.858643 388.516419) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_27">
+    <!-- 18.3 -->
+    <g style="fill: #eef2ff" transform="translate(308.479825 426.403653) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_28">
+    <!-- 61.6 -->
+    <g style="fill: #eef2ff" transform="translate(654.847033 451.661809) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_29">
+    <!-- 17.8 -->
+    <g style="fill: #eef2ff" transform="translate(304.165408 489.549043) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_30">
+    <!-- 61.5 -->
+    <g style="fill: #eef2ff" transform="translate(654.613261 514.807199) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_31">
+    <!-- 17.7 -->
+    <g style="fill: #eef2ff" transform="translate(303.675974 552.694433) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_32">
+    <!-- 61.3 -->
+    <g style="fill: #eef2ff" transform="translate(653.030573 577.952589) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_33">
+    <!-- Linux: the application as installed -->
+    <g style="fill: #eef2ff" transform="translate(155.78 25.023809) scale(0.15 -0.15)">
+     <defs>
+      <path id="DejaVuSans-2f" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-1d" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(55.71875 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(83.5 0)"/>
+     <use xlink:href="#DejaVuSans-58" transform="translate(146.875 0)"/>
+     <use xlink:href="#DejaVuSans-5b" transform="translate(210.25 0)"/>
+     <use xlink:href="#DejaVuSans-1d" transform="translate(269.4375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(303.125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(334.90625 0)"/>
+     <use xlink:href="#DejaVuSans-4b" transform="translate(374.109375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(437.484375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(499.015625 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(530.796875 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(592.078125 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(655.5625 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(719.046875 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(746.828125 0)"/>
+     <use xlink:href="#DejaVuSans-46" transform="translate(774.609375 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(829.59375 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(890.875 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(930.078125 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(957.859375 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1019.046875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1082.421875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1114.203125 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1175.484375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1227.578125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(1259.359375 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1287.140625 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1350.515625 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1402.609375 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1441.8125 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(1503.09375 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(1530.875 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1558.65625 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1620.1875 0)"/>
+    </g>
+    <!-- Lower is better -->
+    <g style="fill: #eef2ff" transform="translate(155.78 43.02791) scale(0.15 -0.15)">
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(53.96875 0)"/>
+     <use xlink:href="#DejaVuSans-5a" transform="translate(115.15625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(196.9375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(258.46875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(299.578125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(331.359375 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(359.140625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(411.234375 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(443.015625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(506.5 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(568.03125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(607.234375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(646.4375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(707.96875 0)"/>
+    </g>
+   </g>
+   <g id="legend_1">
+    <g id="patch_20">
+     <path d="M 159.2566 61.625566 
+L 171.2566 61.625566 
+L 171.2566 54.625566 
+L 159.2566 54.625566 
+z
+" style="fill: #55d4d0"/>
+    </g>
+    <g id="text_34">
+     <!-- Native build -->
+     <g style="fill: #eef2ff" transform="translate(179.2566 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-31"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(74.8125 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(136.09375 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(175.296875 0)"/>
+      <use xlink:href="#DejaVuSans-59" transform="translate(203.078125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(262.265625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(323.796875 0)"/>
+      <use xlink:href="#DejaVuSans-45" transform="translate(355.578125 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(419.0625 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(482.4375 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(510.21875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(538 0)"/>
+     </g>
+    </g>
+    <g id="patch_21">
+     <path d="M 253.405037 61.625566 
+L 265.405037 61.625566 
+L 265.405037 54.625566 
+L 253.405037 54.625566 
+z
+" style="fill: #f4ad55"/>
+    </g>
+    <g id="text_35">
+     <!-- JVM image, jlink -->
+     <g style="fill: #eef2ff" transform="translate(273.405037 61.625566) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-39" d="M 1831 0 
+L 50 4666 
+L 709 4666 
+L 2188 738 
+L 3669 4666 
+L 4325 4666 
+L 2547 0 
+L 1831 0 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-50" transform="translate(243.75 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(341.15625 0)"/>
+      <use xlink:href="#DejaVuSans-4a" transform="translate(402.4375 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(465.921875 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(527.453125 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(559.234375 0)"/>
+      <use xlink:href="#DejaVuSans-4d" transform="translate(591.015625 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(618.796875 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(646.578125 0)"/>
+      <use xlink:href="#DejaVuSans-51" transform="translate(674.359375 0)"/>
+      <use xlink:href="#DejaVuSans-4e" transform="translate(737.734375 0)"/>
+     </g>
+    </g>
+   </g>
+  </g>
+  <g id="text_36">
+   <!-- Ubuntu 24.04.5 LTS, aarch64, in a container on Apple M4 Max -->
+   <g style="fill: #c3cbe6" transform="translate(465.21375 663.833325) scale(0.08 -0.08)">
+    <defs>
+     <path id="DejaVuSans-38" d="M 556 4666 
+L 1191 4666 
+L 1191 1831 
+Q 1191 1081 1462 751 
+Q 1734 422 2344 422 
+Q 2950 422 3222 751 
+Q 3494 1081 3494 1831 
+L 3494 4666 
+L 4128 4666 
+L 4128 1753 
+Q 4128 841 3676 375 
+Q 3225 -91 2344 -91 
+Q 1459 -91 1007 375 
+Q 556 841 556 1753 
+L 556 4666 
+z
+" transform="scale(0.015625)"/>
+     <path id="DejaVuSans-37" d="M -19 4666 
+L 3928 4666 
+L 3928 4134 
+L 2272 4134 
+L 2272 0 
+L 1638 0 
+L 1638 4134 
+L -19 4134 
+L -19 4666 
+z
+" transform="scale(0.015625)"/>
+    </defs>
+    <use xlink:href="#DejaVuSans-38"/>
+    <use xlink:href="#DejaVuSans-45" transform="translate(73.1875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(136.671875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(200.046875 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(263.421875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(302.625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(366 0)"/>
+    <use xlink:href="#DejaVuSans-15" transform="translate(397.78125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(461.40625 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(525.03125 0)"/>
+    <use xlink:href="#DejaVuSans-13" transform="translate(556.8125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(620.4375 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(684.0625 0)"/>
+    <use xlink:href="#DejaVuSans-18" transform="translate(715.84375 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(779.46875 0)"/>
+    <use xlink:href="#DejaVuSans-2f" transform="translate(811.25 0)"/>
+    <use xlink:href="#DejaVuSans-37" transform="translate(853.203125 0)"/>
+    <use xlink:href="#DejaVuSans-36" transform="translate(914.28125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(977.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1009.546875 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1041.328125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1102.609375 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(1163.890625 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1202.796875 0)"/>
+    <use xlink:href="#DejaVuSans-4b" transform="translate(1257.78125 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(1321.15625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(1384.78125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(1448.40625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1480.1875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(1511.96875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1539.75 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1603.125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1634.90625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1696.1875 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1727.96875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(1782.953125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1844.140625 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(1907.515625 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1946.71875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(2008 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2035.78125 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2099.15625 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(2160.6875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2201.796875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(2233.578125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2294.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2358.140625 0)"/>
+    <use xlink:href="#DejaVuSans-24" transform="translate(2389.921875 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2458.328125 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2521.8125 0)"/>
+    <use xlink:href="#DejaVuSans-4f" transform="translate(2585.296875 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2613.078125 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2674.609375 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2706.390625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(2792.671875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2856.296875 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2888.078125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(2974.359375 0)"/>
+    <use xlink:href="#DejaVuSans-5b" transform="translate(3035.640625 0)"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p95e3599853">
+   <rect x="155.78" y="73.02791" width="552.34" height="537.89769"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/developer-guide/img/desktop-compat-linux-startup-cold.svg b/docs/developer-guide/img/desktop-compat-linux-startup-cold.svg
new file mode 100644
index 00000000000..8dd663e7273
--- /dev/null
+++ b/docs/developer-guide/img/desktop-compat-linux-startup-cold.svg
@@ -0,0 +1,2070 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="720pt" height="868.32pt" viewBox="0 0 720 868.32" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 868.32 
+L 720 868.32 
+L 720 0 
+L 0 0 
+z
+" style="fill: #0b132b"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 155.78 800.8904 
+L 707.573809 800.8904 
+L 707.573809 73.02791 
+L 155.78 73.02791 
+z
+" style="fill: #0b132b"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <path d="M 155.78 800.8904 
+L 155.78 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_2"/>
+     <g id="text_1">
+      <!-- 0 -->
+      <g style="fill: #c3cbe6" transform="translate(152.280625 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-13" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-13"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <path d="M 233.159149 800.8904 
+L 233.159149 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_4"/>
+     <g id="text_2">
+      <!-- 100 -->
+      <g style="fill: #c3cbe6" transform="translate(222.661024 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-14" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <path d="M 310.538299 800.8904 
+L 310.538299 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_6"/>
+     <g id="text_3">
+      <!-- 200 -->
+      <g style="fill: #c3cbe6" transform="translate(300.040174 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-15" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <path d="M 387.917448 800.8904 
+L 387.917448 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_8"/>
+     <g id="text_4">
+      <!-- 300 -->
+      <g style="fill: #c3cbe6" transform="translate(377.419323 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-16" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-16"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <path d="M 465.296597 800.8904 
+L 465.296597 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_10"/>
+     <g id="text_5">
+      <!-- 400 -->
+      <g style="fill: #c3cbe6" transform="translate(454.798472 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-17" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-17"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_11">
+      <path d="M 542.675746 800.8904 
+L 542.675746 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_12"/>
+     <g id="text_6">
+      <!-- 500 -->
+      <g style="fill: #c3cbe6" transform="translate(532.177621 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-18" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-18"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_13">
+      <path d="M 620.054896 800.8904 
+L 620.054896 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_14"/>
+     <g id="text_7">
+      <!-- 600 -->
+      <g style="fill: #c3cbe6" transform="translate(609.556771 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-19" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-19"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_8">
+     <g id="line2d_15">
+      <path d="M 697.434045 800.8904 
+L 697.434045 73.02791 
+" clip-path="url(#p1e947f75a9)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_16"/>
+     <g id="text_8">
+      <!-- 700 -->
+      <g style="fill: #c3cbe6" transform="translate(686.93592 812.747822) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-1a" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-1a"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(127.25 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_9">
+     <!-- ms, median -->
+     <g style="fill: #c3cbe6" transform="translate(399.341201 827.748681) scale(0.11 -0.11)">
+      <defs>
+       <path id="DejaVuSans-50" d="M 3328 2828 
+Q 3544 3216 3844 3400 
+Q 4144 3584 4550 3584 
+Q 5097 3584 5394 3201 
+Q 5691 2819 5691 2113 
+L 5691 0 
+L 5113 0 
+L 5113 2094 
+Q 5113 2597 4934 2840 
+Q 4756 3084 4391 3084 
+Q 3944 3084 3684 2787 
+Q 3425 2491 3425 1978 
+L 3425 0 
+L 2847 0 
+L 2847 2094 
+Q 2847 2600 2669 2842 
+Q 2491 3084 2119 3084 
+Q 1678 3084 1418 2786 
+Q 1159 2488 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1356 3278 1631 3431 
+Q 1906 3584 2284 3584 
+Q 2666 3584 2933 3390 
+Q 3200 3197 3328 2828 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-56" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-f" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-3" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-48" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-47" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-4c" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-44" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-51" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-50"/>
+      <use xlink:href="#DejaVuSans-56" transform="translate(97.40625 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(149.5 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(181.28125 0)"/>
+      <use xlink:href="#DejaVuSans-50" transform="translate(213.0625 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(310.46875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(372 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(435.484375 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(463.265625 0)"/>
+      <use xlink:href="#DejaVuSans-51" transform="translate(524.546875 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_17"/>
+     <g id="text_10">
+      <!-- swing-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(35.447969 142.796733) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-5a" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4a" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-10" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4f" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-55" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5c" d="M 2059 -325 
+Q 1816 -950 1584 -1140 
+Q 1353 -1331 966 -1331 
+L 506 -1331 
+L 506 -850 
+L 844 -850 
+Q 1081 -850 1212 -737 
+Q 1344 -625 1503 -206 
+L 1606 56 
+L 191 3500 
+L 800 3500 
+L 1894 763 
+L 2988 3500 
+L 3597 3500 
+L 2059 -325 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-53" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-56"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(52.09375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(133.875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(161.65625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(225.03125 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(288.515625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(324.59375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(388.078125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(449.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(477.140625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(504.921875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(566.453125 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(607.5625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(666.75 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(698.53125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(750.625 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(811.90625 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(909.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(972.796875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1000.578125 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_18"/>
+     <g id="text_11">
+      <!-- SwingSet2, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(12.066094 228.037179) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-57" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4b" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 628 4666 
+L 1259 4666 
+L 1259 325 
+Q 1259 -519 939 -900 
+Q 619 -1281 -91 -1281 
+L -331 -1281 
+L -331 -750 
+L -134 -750 
+Q 284 -750 456 -515 
+Q 628 -281 628 325 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-27" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 628 4666 
+L 1259 4666 
+L 1259 2694 
+L 3353 4666 
+L 4166 4666 
+L 1850 2491 
+L 4331 0 
+L 3500 0 
+L 1259 2247 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-52" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(63.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(145.265625 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(173.046875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(236.421875 0)"/>
+       <use xlink:href="#DejaVuSans-36" transform="translate(299.90625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(363.390625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(424.921875 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(464.125 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(559.53125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(591.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(630.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(693.890625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(755.421875 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(787.203125 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(816.703125 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(893.703125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(959.28125 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(991.0625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1054.546875 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1116.078125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1213.484375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_19"/>
+     <g id="text_12">
+      <!-- Notepad, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(23.370313 313.277626) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 628 4666 
+L 1478 4666 
+L 3547 763 
+L 3547 4666 
+L 4159 4666 
+L 4159 0 
+L 3309 0 
+L 1241 3903 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(74.8125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(136 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(175.203125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(236.734375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(300.21875 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(361.5 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(424.984375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(456.765625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(488.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(591.125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(652.65625 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(684.4375 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(790.9375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(856.515625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(888.296875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(951.78125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1013.3125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1110.71875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_20"/>
+     <g id="text_13">
+      <!-- Falling-blocks game -->
+      <g style="fill: #c3cbe6" transform="translate(43.508906 398.518072) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-29" d="M 628 4666 
+L 3309 4666 
+L 3309 4134 
+L 1259 4134 
+L 1259 2759 
+L 3109 2759 
+L 3109 2228 
+L 1259 2228 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-45" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-46" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4e" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-29"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(48.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(109.625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(137.40625 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(165.1875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(192.96875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(256.34375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(319.828125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(355.90625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(419.390625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(447.171875 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(508.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(563.34375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(621.25 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(673.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(705.125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(768.609375 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(829.890625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(927.296875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_21"/>
+     <g id="text_14">
+      <!-- javafx-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(33.753281 483.758519) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-4d" d="M 603 3500 
+L 1178 3500 
+L 1178 -63 
+Q 1178 -731 923 -1031 
+Q 669 -1331 103 -1331 
+L -116 -1331 
+L -116 -844 
+L 38 -844 
+Q 366 -844 484 -692 
+Q 603 -541 603 -63 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-59" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-49" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5b" d="M 3513 3500 
+L 2247 1797 
+L 3578 0 
+L 2900 0 
+L 1881 1375 
+L 863 0 
+L 184 0 
+L 1544 1831 
+L 300 3500 
+L 978 3500 
+L 1906 2253 
+L 2834 3500 
+L 3513 3500 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4d"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(27.78125 0)"/>
+       <use xlink:href="#DejaVuSans-59" transform="translate(89.0625 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(148.25 0)"/>
+       <use xlink:href="#DejaVuSans-49" transform="translate(209.53125 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(244.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(303.921875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(340 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(403.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(464.765625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(492.546875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(520.328125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(581.859375 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(622.96875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(682.15625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(766.03125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(827.3125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(924.71875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(988.203125 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1015.984375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_22"/>
+     <g id="text_15">
+      <!-- Open-source 2048 game -->
+      <g style="fill: #c3cbe6" transform="translate(16.206562 568.998536) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 2522 4238 
+Q 1834 4238 1429 3725 
+Q 1025 3213 1025 2328 
+Q 1025 1447 1429 934 
+Q 1834 422 2522 422 
+Q 3209 422 3611 934 
+Q 4013 1447 4013 2328 
+Q 4013 3213 3611 3725 
+Q 3209 4238 2522 4238 
+z
+M 2522 4750 
+Q 3503 4750 4090 4092 
+Q 4678 3434 4678 2328 
+Q 4678 1225 4090 567 
+Q 3503 -91 2522 -91 
+Q 1538 -91 948 565 
+Q 359 1222 359 2328 
+Q 359 3434 948 4092 
+Q 1538 4750 2522 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-58" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-1b" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(78.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(142.203125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(203.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(267.109375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(303.1875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(355.28125 0)"/>
+       <use xlink:href="#DejaVuSans-58" transform="translate(416.46875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(479.84375 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(518.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(573.734375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(635.265625 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(667.046875 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(730.671875 0)"/>
+       <use xlink:href="#DejaVuSans-17" transform="translate(794.296875 0)"/>
+       <use xlink:href="#DejaVuSans-1b" transform="translate(857.921875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(921.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(953.328125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(1016.8125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1078.09375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1175.5 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_23"/>
+     <g id="text_16">
+      <!-- Address book -->
+      <g style="fill: #c3cbe6" transform="translate(78.162344 654.239412) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-24" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-24"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(66.65625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(130.140625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(193.625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(232.53125 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(294.0625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(346.15625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(398.25 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(430.03125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(493.515625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(554.703125 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(615.890625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_24"/>
+     <g id="text_17">
+      <!-- Mandelbrot explorer -->
+      <g style="fill: #c3cbe6" transform="translate(41.040781 739.479858) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-30" d="M 628 4666 
+L 1569 4666 
+L 2759 1491 
+L 3956 4666 
+L 4897 4666 
+L 4897 0 
+L 4281 0 
+L 4281 4097 
+L 3078 897 
+L 2444 897 
+L 1241 4097 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(86.28125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(147.5625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(210.9375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(274.421875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(335.953125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(363.734375 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(427.21875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(466.125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(527.3125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(566.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(598.296875 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(658.078125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(717.265625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(780.75 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(808.53125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(869.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(908.625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(970.15625 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 155.78 106.112569 
+L 239.117344 106.112569 
+L 239.117344 125.661045 
+L 155.78 125.661045 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 155.78 128.843355 
+L 437.440103 128.843355 
+L 437.440103 148.39183 
+L 155.78 148.39183 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 155.78 151.57414 
+L 322.841583 151.57414 
+L 322.841583 171.122616 
+L 155.78 171.122616 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 155.78 191.353015 
+L 225.343855 191.353015 
+L 225.343855 210.901491 
+L 155.78 210.901491 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 155.78 214.083801 
+L 345.591053 214.083801 
+L 345.591053 233.632277 
+L 155.78 233.632277 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 155.78 236.814587 
+L 285.776971 236.814587 
+L 285.776971 256.363062 
+L 155.78 256.363062 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_9">
+    <path d="M 155.78 276.593462 
+L 225.343855 276.593462 
+L 225.343855 296.141937 
+L 155.78 296.141937 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 155.78 299.324247 
+L 309.764507 299.324247 
+L 309.764507 318.872723 
+L 155.78 318.872723 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 155.78 322.055033 
+L 261.712055 322.055033 
+L 261.712055 341.603509 
+L 155.78 341.603509 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_12">
+    <path d="M 155.78 361.833908 
+L 222.558206 361.833908 
+L 222.558206 381.382384 
+L 155.78 381.382384 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_13">
+    <path d="M 155.78 384.564694 
+L 252.736074 384.564694 
+L 252.736074 404.11317 
+L 155.78 404.11317 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_14">
+    <path d="M 155.78 407.29548 
+L 228.052125 407.29548 
+L 228.052125 426.843955 
+L 155.78 426.843955 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_15">
+    <path d="M 155.78 447.074355 
+L 245.84933 447.074355 
+L 245.84933 466.62283 
+L 155.78 466.62283 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 155.78 469.80514 
+L 648.453043 469.80514 
+L 648.453043 489.353616 
+L 155.78 489.353616 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 155.78 492.535926 
+L 482.087873 492.535926 
+L 482.087873 512.084402 
+L 155.78 512.084402 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 155.78 532.314801 
+L 239.813756 532.314801 
+L 239.813756 551.863277 
+L 155.78 551.863277 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_19">
+    <path d="M 155.78 555.045587 
+L 421.267861 555.045587 
+L 421.267861 574.594063 
+L 155.78 574.594063 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_20">
+    <path d="M 155.78 577.776373 
+L 326.865299 577.776373 
+L 326.865299 597.324848 
+L 155.78 597.324848 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_21">
+    <path d="M 155.78 617.555248 
+L 219.849936 617.555248 
+L 219.849936 637.103723 
+L 155.78 637.103723 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_22">
+    <path d="M 155.78 640.286033 
+L 493.694745 640.286033 
+L 493.694745 659.834509 
+L 155.78 659.834509 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_23">
+    <path d="M 155.78 663.016819 
+L 358.900267 663.016819 
+L 358.900267 682.565295 
+L 155.78 682.565295 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_24">
+    <path d="M 155.78 702.795694 
+L 227.123576 702.795694 
+L 227.123576 722.34417 
+L 155.78 722.34417 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_25">
+    <path d="M 155.78 725.52648 
+L 482.784285 725.52648 
+L 482.784285 745.074956 
+L 155.78 745.074956 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_26">
+    <path d="M 155.78 748.257266 
+L 339.710238 748.257266 
+L 339.710238 767.805741 
+L 155.78 767.805741 
+z
+" clip-path="url(#p1e947f75a9)" style="fill: #9eafff"/>
+   </g>
+   <g id="patch_27">
+    <path d="M 155.78 800.8904 
+L 707.573809 800.8904 
+" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_18">
+    <!-- 108 -->
+    <g style="fill: #eef2ff" transform="translate(245.02942 118.224697) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_19">
+    <!-- 364 -->
+    <g style="fill: #eef2ff" transform="translate(443.35218 140.955483) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_20">
+    <!-- 216 -->
+    <g style="fill: #eef2ff" transform="translate(328.75366 163.686269) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_21">
+    <!-- 89.9 -->
+    <g style="fill: #eef2ff" transform="translate(231.255932 203.465144) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1c" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-11" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_22">
+    <!-- 245 -->
+    <g style="fill: #eef2ff" transform="translate(351.50313 226.195929) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_23">
+    <!-- 168 -->
+    <g style="fill: #eef2ff" transform="translate(291.689047 248.926715) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_24">
+    <!-- 89.9 -->
+    <g style="fill: #eef2ff" transform="translate(231.255932 288.70559) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_25">
+    <!-- 199 -->
+    <g style="fill: #eef2ff" transform="translate(315.676584 311.436376) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_26">
+    <!-- 137 -->
+    <g style="fill: #eef2ff" transform="translate(267.624132 334.167162) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_27">
+    <!-- 86.3 -->
+    <g style="fill: #eef2ff" transform="translate(228.470282 373.946037) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_28">
+    <!-- 125 -->
+    <g style="fill: #eef2ff" transform="translate(258.648151 396.676822) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_29">
+    <!-- 93.4 -->
+    <g style="fill: #eef2ff" transform="translate(233.964202 419.407608) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1c"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_30">
+    <!-- 116 -->
+    <g style="fill: #eef2ff" transform="translate(251.761406 459.186483) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_31">
+    <!-- 637 -->
+    <g style="fill: #eef2ff" transform="translate(654.36512 481.917269) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-19"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_32">
+    <!-- 422 -->
+    <g style="fill: #eef2ff" transform="translate(487.999949 504.648055) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-17"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_33">
+    <!-- 109 -->
+    <g style="fill: #eef2ff" transform="translate(245.725833 544.42693) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-14"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_34">
+    <!-- 343 -->
+    <g style="fill: #eef2ff" transform="translate(427.179938 567.157715) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-16"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_35">
+    <!-- 221 -->
+    <g style="fill: #eef2ff" transform="translate(332.777376 589.888501) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_36">
+    <!-- 82.8 -->
+    <g style="fill: #eef2ff" transform="translate(225.762012 629.667376) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1b"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_37">
+    <!-- 437 -->
+    <g style="fill: #eef2ff" transform="translate(499.606821 652.398162) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-17"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_38">
+    <!-- 262 -->
+    <g style="fill: #eef2ff" transform="translate(364.812343 675.128948) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_39">
+    <!-- 92.2 -->
+    <g style="fill: #eef2ff" transform="translate(233.035652 714.907823) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-1c"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_40">
+    <!-- 423 -->
+    <g style="fill: #eef2ff" transform="translate(488.696361 737.638608) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-17"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_41">
+    <!-- 238 -->
+    <g style="fill: #eef2ff" transform="translate(345.622314 760.369394) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(127.25 0)"/>
+    </g>
+   </g>
+   <g id="text_42">
+    <!-- Linux: cold start, to the first painted frame -->
+    <g style="fill: #eef2ff" transform="translate(155.78 25.023809) scale(0.15 -0.15)">
+     <defs>
+      <path id="DejaVuSans-2f" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-1d" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-13af" d="M 3431 3500 
+L 3431 0 
+L 2853 0 
+L 2853 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4316 967 4589 
+Q 1238 4863 1797 4863 
+L 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 3431 3500 
+z
+M 2853 4856 
+L 3431 4856 
+L 3431 4128 
+L 2853 4128 
+L 2853 4856 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(55.71875 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(83.5 0)"/>
+     <use xlink:href="#DejaVuSans-58" transform="translate(146.875 0)"/>
+     <use xlink:href="#DejaVuSans-5b" transform="translate(210.25 0)"/>
+     <use xlink:href="#DejaVuSans-1d" transform="translate(269.4375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(303.125 0)"/>
+     <use xlink:href="#DejaVuSans-46" transform="translate(334.90625 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(389.890625 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(451.078125 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(478.859375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(542.34375 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(574.125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(626.21875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(665.421875 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(726.703125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(767.8125 0)"/>
+     <use xlink:href="#DejaVuSans-f" transform="translate(807.015625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(838.796875 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(870.578125 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(909.78125 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(970.96875 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1002.75 0)"/>
+     <use xlink:href="#DejaVuSans-4b" transform="translate(1041.953125 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1105.328125 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1166.859375 0)"/>
+     <use xlink:href="#DejaVuSans-13af" transform="translate(1198.640625 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(1261.625 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1302.734375 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1354.828125 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1394.03125 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(1425.8125 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1489.296875 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(1550.578125 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1578.359375 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1641.734375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1680.9375 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1742.46875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1805.953125 0)"/>
+     <use xlink:href="#DejaVuSans-49" transform="translate(1837.734375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(1872.9375 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1914.046875 0)"/>
+     <use xlink:href="#DejaVuSans-50" transform="translate(1975.328125 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(2072.734375 0)"/>
+    </g>
+    <!-- Lower is better -->
+    <g style="fill: #eef2ff" transform="translate(155.78 43.02791) scale(0.15 -0.15)">
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(53.96875 0)"/>
+     <use xlink:href="#DejaVuSans-5a" transform="translate(115.15625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(196.9375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(258.46875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(299.578125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(331.359375 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(359.140625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(411.234375 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(443.015625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(506.5 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(568.03125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(607.234375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(646.4375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(707.96875 0)"/>
+    </g>
+   </g>
+   <g id="legend_1">
+    <g id="patch_28">
+     <path d="M 159.262062 61.625566 
+L 171.262062 61.625566 
+L 171.262062 54.625566 
+L 159.262062 54.625566 
+z
+" style="fill: #55d4d0"/>
+    </g>
+    <g id="text_43">
+     <!-- Native build -->
+     <g style="fill: #eef2ff" transform="translate(179.262062 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-31"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(74.8125 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(136.09375 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(175.296875 0)"/>
+      <use xlink:href="#DejaVuSans-59" transform="translate(203.078125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(262.265625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(323.796875 0)"/>
+      <use xlink:href="#DejaVuSans-45" transform="translate(355.578125 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(419.0625 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(482.4375 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(510.21875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(538 0)"/>
+     </g>
+    </g>
+    <g id="patch_29">
+     <path d="M 253.410499 61.625566 
+L 265.410499 61.625566 
+L 265.410499 54.625566 
+L 253.410499 54.625566 
+z
+" style="fill: #f4ad55"/>
+    </g>
+    <g id="text_44">
+     <!-- JVM, default -->
+     <g style="fill: #eef2ff" transform="translate(273.410499 61.625566) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-39" d="M 1831 0 
+L 50 4666 
+L 709 4666 
+L 2188 738 
+L 3669 4666 
+L 4325 4666 
+L 2547 0 
+L 1831 0 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(247.75 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(311.234375 0)"/>
+      <use xlink:href="#DejaVuSans-49" transform="translate(372.765625 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(407.96875 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(469.25 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(532.625 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(560.40625 0)"/>
+     </g>
+    </g>
+    <g id="patch_30">
+     <path d="M 347.371437 61.625566 
+L 359.371437 61.625566 
+L 359.371437 54.625566 
+L 347.371437 54.625566 
+z
+" style="fill: #9eafff"/>
+    </g>
+    <g id="text_45">
+     <!-- JVM, tuned -->
+     <g style="fill: #eef2ff" transform="translate(367.371437 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(247.75 0)"/>
+      <use xlink:href="#DejaVuSans-58" transform="translate(286.953125 0)"/>
+      <use xlink:href="#DejaVuSans-51" transform="translate(350.328125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(413.703125 0)"/>
+      <use xlink:href="#DejaVuSans-47" transform="translate(475.234375 0)"/>
+     </g>
+    </g>
+   </g>
+  </g>
+  <g id="text_46">
+   <!-- Ubuntu 24.04.5 LTS, aarch64, in a container on Apple M4 Max -->
+   <g style="fill: #c3cbe6" transform="translate(465.21375 857.714925) scale(0.08 -0.08)">
+    <defs>
+     <path id="DejaVuSans-38" d="M 556 4666 
+L 1191 4666 
+L 1191 1831 
+Q 1191 1081 1462 751 
+Q 1734 422 2344 422 
+Q 2950 422 3222 751 
+Q 3494 1081 3494 1831 
+L 3494 4666 
+L 4128 4666 
+L 4128 1753 
+Q 4128 841 3676 375 
+Q 3225 -91 2344 -91 
+Q 1459 -91 1007 375 
+Q 556 841 556 1753 
+L 556 4666 
+z
+" transform="scale(0.015625)"/>
+     <path id="DejaVuSans-37" d="M -19 4666 
+L 3928 4666 
+L 3928 4134 
+L 2272 4134 
+L 2272 0 
+L 1638 0 
+L 1638 4134 
+L -19 4134 
+L -19 4666 
+z
+" transform="scale(0.015625)"/>
+    </defs>
+    <use xlink:href="#DejaVuSans-38"/>
+    <use xlink:href="#DejaVuSans-45" transform="translate(73.1875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(136.671875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(200.046875 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(263.421875 0)"/>
+    <use xlink:href="#DejaVuSans-58" transform="translate(302.625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(366 0)"/>
+    <use xlink:href="#DejaVuSans-15" transform="translate(397.78125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(461.40625 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(525.03125 0)"/>
+    <use xlink:href="#DejaVuSans-13" transform="translate(556.8125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(620.4375 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(684.0625 0)"/>
+    <use xlink:href="#DejaVuSans-18" transform="translate(715.84375 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(779.46875 0)"/>
+    <use xlink:href="#DejaVuSans-2f" transform="translate(811.25 0)"/>
+    <use xlink:href="#DejaVuSans-37" transform="translate(853.203125 0)"/>
+    <use xlink:href="#DejaVuSans-36" transform="translate(914.28125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(977.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1009.546875 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1041.328125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1102.609375 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(1163.890625 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1202.796875 0)"/>
+    <use xlink:href="#DejaVuSans-4b" transform="translate(1257.78125 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(1321.15625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(1384.78125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(1448.40625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1480.1875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(1511.96875 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1539.75 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1603.125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1634.90625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1696.1875 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(1727.96875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(1782.953125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(1844.140625 0)"/>
+    <use xlink:href="#DejaVuSans-57" transform="translate(1907.515625 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1946.71875 0)"/>
+    <use xlink:href="#DejaVuSans-4c" transform="translate(2008 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2035.78125 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2099.15625 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(2160.6875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2201.796875 0)"/>
+    <use xlink:href="#DejaVuSans-52" transform="translate(2233.578125 0)"/>
+    <use xlink:href="#DejaVuSans-51" transform="translate(2294.765625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2358.140625 0)"/>
+    <use xlink:href="#DejaVuSans-24" transform="translate(2389.921875 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2458.328125 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(2521.8125 0)"/>
+    <use xlink:href="#DejaVuSans-4f" transform="translate(2585.296875 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(2613.078125 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2674.609375 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2706.390625 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(2792.671875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(2856.296875 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(2888.078125 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(2974.359375 0)"/>
+    <use xlink:href="#DejaVuSans-5b" transform="translate(3035.640625 0)"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p1e947f75a9">
+   <rect x="155.78" y="73.02791" width="551.793809" height="727.86249"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/developer-guide/img/desktop-compat-macos-size.svg b/docs/developer-guide/img/desktop-compat-macos-size.svg
new file mode 100644
index 00000000000..4221d78b206
--- /dev/null
+++ b/docs/developer-guide/img/desktop-compat-macos-size.svg
@@ -0,0 +1,1854 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" width="720pt" height="672.48pt" viewBox="0 0 720 672.48" xmlns="http://www.w3.org/2000/svg" version="1.1">
+ <metadata>
+  <rdf:RDF xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+   <cc:Work>
+    <dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
+    <dc:format>image/svg+xml</dc:format>
+    <dc:creator>
+     <cc:Agent>
+      <dc:title>Matplotlib v3.11.2, https://matplotlib.org/</dc:title>
+     </cc:Agent>
+    </dc:creator>
+   </cc:Work>
+  </rdf:RDF>
+ </metadata>
+ <defs>
+  <style type="text/css">*{stroke-linejoin: round; stroke-linecap: butt}</style>
+ </defs>
+ <g id="figure_1">
+  <g id="patch_1">
+   <path d="M 0 672.48 
+L 720 672.48 
+L 720 0 
+L 0 0 
+z
+" style="fill: #0b132b"/>
+  </g>
+  <g id="axes_1">
+   <g id="patch_2">
+    <path d="M 155.78 610.9256 
+L 708.12 610.9256 
+L 708.12 73.02791 
+L 155.78 73.02791 
+z
+" style="fill: #0b132b"/>
+   </g>
+   <g id="matplotlib.axis_1">
+    <g id="xtick_1">
+     <g id="line2d_1">
+      <path d="M 155.78 610.9256 
+L 155.78 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_2"/>
+     <g id="text_1">
+      <!-- 0 -->
+      <g style="fill: #c3cbe6" transform="translate(152.280625 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-13" d="M 2034 4250 
+Q 1547 4250 1301 3770 
+Q 1056 3291 1056 2328 
+Q 1056 1369 1301 889 
+Q 1547 409 2034 409 
+Q 2525 409 2770 889 
+Q 3016 1369 3016 2328 
+Q 3016 3291 2770 3770 
+Q 2525 4250 2034 4250 
+z
+M 2034 4750 
+Q 2819 4750 3233 4129 
+Q 3647 3509 3647 2328 
+Q 3647 1150 3233 529 
+Q 2819 -91 2034 -91 
+Q 1250 -91 836 529 
+Q 422 1150 422 2328 
+Q 422 3509 836 4129 
+Q 1250 4750 2034 4750 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-13"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_2">
+     <g id="line2d_3">
+      <path d="M 242.201524 610.9256 
+L 242.201524 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_4"/>
+     <g id="text_2">
+      <!-- 10 -->
+      <g style="fill: #c3cbe6" transform="translate(235.202774 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-14" d="M 794 531 
+L 1825 531 
+L 1825 4091 
+L 703 3866 
+L 703 4441 
+L 1819 4666 
+L 2450 4666 
+L 2450 531 
+L 3481 531 
+L 3481 0 
+L 794 0 
+L 794 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-14"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_3">
+     <g id="line2d_5">
+      <path d="M 328.623048 610.9256 
+L 328.623048 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_6"/>
+     <g id="text_3">
+      <!-- 20 -->
+      <g style="fill: #c3cbe6" transform="translate(321.624298 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-15" d="M 1228 531 
+L 3431 531 
+L 3431 0 
+L 469 0 
+L 469 531 
+Q 828 903 1448 1529 
+Q 2069 2156 2228 2338 
+Q 2531 2678 2651 2914 
+Q 2772 3150 2772 3378 
+Q 2772 3750 2511 3984 
+Q 2250 4219 1831 4219 
+Q 1534 4219 1204 4116 
+Q 875 4013 500 3803 
+L 500 4441 
+Q 881 4594 1212 4672 
+Q 1544 4750 1819 4750 
+Q 2544 4750 2975 4387 
+Q 3406 4025 3406 3419 
+Q 3406 3131 3298 2873 
+Q 3191 2616 2906 2266 
+Q 2828 2175 2409 1742 
+Q 1991 1309 1228 531 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-15"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_4">
+     <g id="line2d_7">
+      <path d="M 415.044572 610.9256 
+L 415.044572 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_8"/>
+     <g id="text_4">
+      <!-- 30 -->
+      <g style="fill: #c3cbe6" transform="translate(408.045822 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-16" d="M 2597 2516 
+Q 3050 2419 3304 2112 
+Q 3559 1806 3559 1356 
+Q 3559 666 3084 287 
+Q 2609 -91 1734 -91 
+Q 1441 -91 1130 -33 
+Q 819 25 488 141 
+L 488 750 
+Q 750 597 1062 519 
+Q 1375 441 1716 441 
+Q 2309 441 2620 675 
+Q 2931 909 2931 1356 
+Q 2931 1769 2642 2001 
+Q 2353 2234 1838 2234 
+L 1294 2234 
+L 1294 2753 
+L 1863 2753 
+Q 2328 2753 2575 2939 
+Q 2822 3125 2822 3475 
+Q 2822 3834 2567 4026 
+Q 2313 4219 1838 4219 
+Q 1578 4219 1281 4162 
+Q 984 4106 628 3988 
+L 628 4550 
+Q 988 4650 1302 4700 
+Q 1616 4750 1894 4750 
+Q 2613 4750 3031 4423 
+Q 3450 4097 3450 3541 
+Q 3450 3153 3228 2886 
+Q 3006 2619 2597 2516 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-16"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_5">
+     <g id="line2d_9">
+      <path d="M 501.466096 610.9256 
+L 501.466096 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_10"/>
+     <g id="text_5">
+      <!-- 40 -->
+      <g style="fill: #c3cbe6" transform="translate(494.467346 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-17" d="M 2419 4116 
+L 825 1625 
+L 2419 1625 
+L 2419 4116 
+z
+M 2253 4666 
+L 3047 4666 
+L 3047 1625 
+L 3713 1625 
+L 3713 1100 
+L 3047 1100 
+L 3047 0 
+L 2419 0 
+L 2419 1100 
+L 313 1100 
+L 313 1709 
+L 2253 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-17"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_6">
+     <g id="line2d_11">
+      <path d="M 587.88762 610.9256 
+L 587.88762 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_12"/>
+     <g id="text_6">
+      <!-- 50 -->
+      <g style="fill: #c3cbe6" transform="translate(580.88887 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-18" d="M 691 4666 
+L 3169 4666 
+L 3169 4134 
+L 1269 4134 
+L 1269 2991 
+Q 1406 3038 1543 3061 
+Q 1681 3084 1819 3084 
+Q 2600 3084 3056 2656 
+Q 3513 2228 3513 1497 
+Q 3513 744 3044 326 
+Q 2575 -91 1722 -91 
+Q 1428 -91 1123 -41 
+Q 819 9 494 109 
+L 494 744 
+Q 775 591 1075 516 
+Q 1375 441 1709 441 
+Q 2250 441 2565 725 
+Q 2881 1009 2881 1497 
+Q 2881 1984 2565 2268 
+Q 2250 2553 1709 2553 
+Q 1456 2553 1204 2497 
+Q 953 2441 691 2322 
+L 691 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-18"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="xtick_7">
+     <g id="line2d_13">
+      <path d="M 674.309144 610.9256 
+L 674.309144 73.02791 
+" clip-path="url(#p95e3599853)" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linecap: square"/>
+     </g>
+     <g id="line2d_14"/>
+     <g id="text_7">
+      <!-- 60 -->
+      <g style="fill: #c3cbe6" transform="translate(667.310394 622.783022) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-19" d="M 2113 2584 
+Q 1688 2584 1439 2293 
+Q 1191 2003 1191 1497 
+Q 1191 994 1439 701 
+Q 1688 409 2113 409 
+Q 2538 409 2786 701 
+Q 3034 994 3034 1497 
+Q 3034 2003 2786 2293 
+Q 2538 2584 2113 2584 
+z
+M 3366 4563 
+L 3366 3988 
+Q 3128 4100 2886 4159 
+Q 2644 4219 2406 4219 
+Q 1781 4219 1451 3797 
+Q 1122 3375 1075 2522 
+Q 1259 2794 1537 2939 
+Q 1816 3084 2150 3084 
+Q 2853 3084 3261 2657 
+Q 3669 2231 3669 1497 
+Q 3669 778 3244 343 
+Q 2819 -91 2113 -91 
+Q 1303 -91 875 529 
+Q 447 1150 447 2328 
+Q 447 3434 972 4092 
+Q 1497 4750 2381 4750 
+Q 2619 4750 2861 4703 
+Q 3103 4656 3366 4563 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-19"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="text_8">
+     <!-- MB -->
+     <g style="fill: #c3cbe6" transform="translate(423.431016 637.783022) scale(0.11 -0.11)">
+      <defs>
+       <path id="DejaVuSans-30" d="M 628 4666 
+L 1569 4666 
+L 2759 1491 
+L 3956 4666 
+L 4897 4666 
+L 4897 0 
+L 4281 0 
+L 4281 4097 
+L 3078 897 
+L 2444 897 
+L 1241 4097 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       <path id="DejaVuSans-25" d="M 1259 2228 
+L 1259 519 
+L 2272 519 
+Q 2781 519 3026 730 
+Q 3272 941 3272 1375 
+Q 3272 1813 3026 2020 
+Q 2781 2228 2272 2228 
+L 1259 2228 
+z
+M 1259 4147 
+L 1259 2741 
+L 2194 2741 
+Q 2656 2741 2882 2914 
+Q 3109 3088 3109 3444 
+Q 3109 3797 2882 3972 
+Q 2656 4147 2194 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 2241 4666 
+Q 2963 4666 3353 4366 
+Q 3744 4066 3744 3513 
+Q 3744 3084 3544 2831 
+Q 3344 2578 2956 2516 
+Q 3422 2416 3680 2098 
+Q 3938 1781 3938 1306 
+Q 3938 681 3513 340 
+Q 3088 0 2303 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-30"/>
+      <use xlink:href="#DejaVuSans-25" transform="translate(86.28125 0)"/>
+     </g>
+    </g>
+   </g>
+   <g id="matplotlib.axis_2">
+    <g id="ytick_1">
+     <g id="line2d_15"/>
+     <g id="text_9">
+      <!-- swing-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(35.447969 125.147031) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-56" d="M 2834 3397 
+L 2834 2853 
+Q 2591 2978 2328 3040 
+Q 2066 3103 1784 3103 
+Q 1356 3103 1142 2972 
+Q 928 2841 928 2578 
+Q 928 2378 1081 2264 
+Q 1234 2150 1697 2047 
+L 1894 2003 
+Q 2506 1872 2764 1633 
+Q 3022 1394 3022 966 
+Q 3022 478 2636 193 
+Q 2250 -91 1575 -91 
+Q 1294 -91 989 -36 
+Q 684 19 347 128 
+L 347 722 
+Q 666 556 975 473 
+Q 1284 391 1588 391 
+Q 1994 391 2212 530 
+Q 2431 669 2431 922 
+Q 2431 1156 2273 1281 
+Q 2116 1406 1581 1522 
+L 1381 1569 
+Q 847 1681 609 1914 
+Q 372 2147 372 2553 
+Q 372 3047 722 3315 
+Q 1072 3584 1716 3584 
+Q 2034 3584 2315 3537 
+Q 2597 3491 2834 3397 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5a" d="M 269 3500 
+L 844 3500 
+L 1563 769 
+L 2278 3500 
+L 2956 3500 
+L 3675 769 
+L 4391 3500 
+L 4966 3500 
+L 4050 0 
+L 3372 0 
+L 2619 2869 
+L 1863 0 
+L 1184 0 
+L 269 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4c" d="M 603 3500 
+L 1178 3500 
+L 1178 0 
+L 603 0 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-51" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4a" d="M 2906 1791 
+Q 2906 2416 2648 2759 
+Q 2391 3103 1925 3103 
+Q 1463 3103 1205 2759 
+Q 947 2416 947 1791 
+Q 947 1169 1205 825 
+Q 1463 481 1925 481 
+Q 2391 481 2648 825 
+Q 2906 1169 2906 1791 
+z
+M 3481 434 
+Q 3481 -459 3084 -895 
+Q 2688 -1331 1869 -1331 
+Q 1566 -1331 1297 -1286 
+Q 1028 -1241 775 -1147 
+L 775 -588 
+Q 1028 -725 1275 -790 
+Q 1522 -856 1778 -856 
+Q 2344 -856 2625 -561 
+Q 2906 -266 2906 331 
+L 2906 616 
+Q 2728 306 2450 153 
+Q 2172 0 1784 0 
+Q 1141 0 747 490 
+Q 353 981 353 1791 
+Q 353 2603 747 3093 
+Q 1141 3584 1784 3584 
+Q 2172 3584 2450 3431 
+Q 2728 3278 2906 2969 
+L 2906 3500 
+L 3481 3500 
+L 3481 434 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-10" d="M 313 2009 
+L 1997 2009 
+L 1997 1497 
+L 313 1497 
+L 313 2009 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-44" d="M 2194 1759 
+Q 1497 1759 1228 1600 
+Q 959 1441 959 1056 
+Q 959 750 1161 570 
+Q 1363 391 1709 391 
+Q 2188 391 2477 730 
+Q 2766 1069 2766 1631 
+L 2766 1759 
+L 2194 1759 
+z
+M 3341 1997 
+L 3341 0 
+L 2766 0 
+L 2766 531 
+Q 2569 213 2275 61 
+Q 1981 -91 1556 -91 
+Q 1019 -91 701 211 
+Q 384 513 384 1019 
+Q 384 1609 779 1909 
+Q 1175 2209 1959 2209 
+L 2766 2209 
+L 2766 2266 
+Q 2766 2663 2505 2880 
+Q 2244 3097 1772 3097 
+Q 1472 3097 1187 3025 
+Q 903 2953 641 2809 
+L 641 3341 
+Q 956 3463 1253 3523 
+Q 1550 3584 1831 3584 
+Q 2591 3584 2966 3190 
+Q 3341 2797 3341 1997 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4f" d="M 603 4863 
+L 1178 4863 
+L 1178 0 
+L 603 0 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-48" d="M 3597 1894 
+L 3597 1613 
+L 953 1613 
+Q 991 1019 1311 708 
+Q 1631 397 2203 397 
+Q 2534 397 2845 478 
+Q 3156 559 3463 722 
+L 3463 178 
+Q 3153 47 2828 -22 
+Q 2503 -91 2169 -91 
+Q 1331 -91 842 396 
+Q 353 884 353 1716 
+Q 353 2575 817 3079 
+Q 1281 3584 2069 3584 
+Q 2775 3584 3186 3129 
+Q 3597 2675 3597 1894 
+z
+M 3022 2063 
+Q 3016 2534 2758 2815 
+Q 2500 3097 2075 3097 
+Q 1594 3097 1305 2825 
+Q 1016 2553 972 2059 
+L 3022 2063 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-55" d="M 2631 2963 
+Q 2534 3019 2420 3045 
+Q 2306 3072 2169 3072 
+Q 1681 3072 1420 2755 
+Q 1159 2438 1159 1844 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1341 3275 1631 3429 
+Q 1922 3584 2338 3584 
+Q 2397 3584 2469 3576 
+Q 2541 3569 2628 3553 
+L 2631 2963 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5c" d="M 2059 -325 
+Q 1816 -950 1584 -1140 
+Q 1353 -1331 966 -1331 
+L 506 -1331 
+L 506 -850 
+L 844 -850 
+Q 1081 -850 1212 -737 
+Q 1344 -625 1503 -206 
+L 1606 56 
+L 191 3500 
+L 800 3500 
+L 1894 763 
+L 2988 3500 
+L 3597 3500 
+L 2059 -325 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-3" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-50" d="M 3328 2828 
+Q 3544 3216 3844 3400 
+Q 4144 3584 4550 3584 
+Q 5097 3584 5394 3201 
+Q 5691 2819 5691 2113 
+L 5691 0 
+L 5113 0 
+L 5113 2094 
+Q 5113 2597 4934 2840 
+Q 4756 3084 4391 3084 
+Q 3944 3084 3684 2787 
+Q 3425 2491 3425 1978 
+L 3425 0 
+L 2847 0 
+L 2847 2094 
+Q 2847 2600 2669 2842 
+Q 2491 3084 2119 3084 
+Q 1678 3084 1418 2786 
+Q 1159 2488 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 3500 
+L 1159 3500 
+L 1159 2956 
+Q 1356 3278 1631 3431 
+Q 1906 3584 2284 3584 
+Q 2666 3584 2933 3390 
+Q 3200 3197 3328 2828 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-53" d="M 1159 525 
+L 1159 -1331 
+L 581 -1331 
+L 581 3500 
+L 1159 3500 
+L 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+z
+M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-56"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(52.09375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(133.875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(161.65625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(225.03125 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(288.515625 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(324.59375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(388.078125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(449.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(477.140625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(504.921875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(566.453125 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(607.5625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(666.75 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(698.53125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(750.625 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(811.90625 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(909.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(972.796875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1000.578125 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_2">
+     <g id="line2d_16"/>
+     <g id="text_10">
+      <!-- SwingSet2, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(12.066094 188.292421) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-36" d="M 3425 4513 
+L 3425 3897 
+Q 3066 4069 2747 4153 
+Q 2428 4238 2131 4238 
+Q 1616 4238 1336 4038 
+Q 1056 3838 1056 3469 
+Q 1056 3159 1242 3001 
+Q 1428 2844 1947 2747 
+L 2328 2669 
+Q 3034 2534 3370 2195 
+Q 3706 1856 3706 1288 
+Q 3706 609 3251 259 
+Q 2797 -91 1919 -91 
+Q 1588 -91 1214 -16 
+Q 841 59 441 206 
+L 441 856 
+Q 825 641 1194 531 
+Q 1563 422 1919 422 
+Q 2459 422 2753 634 
+Q 3047 847 3047 1241 
+Q 3047 1584 2836 1778 
+Q 2625 1972 2144 2069 
+L 1759 2144 
+Q 1053 2284 737 2584 
+Q 422 2884 422 3419 
+Q 422 4038 858 4394 
+Q 1294 4750 2059 4750 
+Q 2388 4750 2728 4690 
+Q 3069 4631 3425 4513 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-57" d="M 1172 4494 
+L 1172 3500 
+L 2356 3500 
+L 2356 3053 
+L 1172 3053 
+L 1172 1153 
+Q 1172 725 1289 603 
+Q 1406 481 1766 481 
+L 2356 481 
+L 2356 0 
+L 1766 0 
+Q 1100 0 847 248 
+Q 594 497 594 1153 
+L 594 3053 
+L 172 3053 
+L 172 3500 
+L 594 3500 
+L 594 4494 
+L 1172 4494 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-f" d="M 750 794 
+L 1409 794 
+L 1409 256 
+L 897 -744 
+L 494 -744 
+L 750 256 
+L 750 794 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4b" d="M 3513 2113 
+L 3513 0 
+L 2938 0 
+L 2938 2094 
+Q 2938 2591 2744 2837 
+Q 2550 3084 2163 3084 
+Q 1697 3084 1428 2787 
+Q 1159 2491 1159 1978 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2956 
+Q 1366 3272 1645 3428 
+Q 1925 3584 2291 3584 
+Q 2894 3584 3203 3211 
+Q 3513 2838 3513 2113 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2d" d="M 628 4666 
+L 1259 4666 
+L 1259 325 
+Q 1259 -519 939 -900 
+Q 619 -1281 -91 -1281 
+L -331 -1281 
+L -331 -750 
+L -134 -750 
+Q 284 -750 456 -515 
+Q 628 -281 628 325 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-27" d="M 1259 4147 
+L 1259 519 
+L 2022 519 
+Q 2988 519 3436 956 
+Q 3884 1394 3884 2338 
+Q 3884 3275 3436 3711 
+Q 2988 4147 2022 4147 
+L 1259 4147 
+z
+M 628 4666 
+L 1925 4666 
+Q 3281 4666 3915 4102 
+Q 4550 3538 4550 2338 
+Q 4550 1131 3912 565 
+Q 3275 0 1925 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-2e" d="M 628 4666 
+L 1259 4666 
+L 1259 2694 
+L 3353 4666 
+L 4166 4666 
+L 1850 2491 
+L 4331 0 
+L 3500 0 
+L 1259 2247 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-47" d="M 2906 2969 
+L 2906 4863 
+L 3481 4863 
+L 3481 0 
+L 2906 0 
+L 2906 525 
+Q 2725 213 2448 61 
+Q 2172 -91 1784 -91 
+Q 1150 -91 751 415 
+Q 353 922 353 1747 
+Q 353 2572 751 3078 
+Q 1150 3584 1784 3584 
+Q 2172 3584 2448 3432 
+Q 2725 3281 2906 2969 
+z
+M 947 1747 
+Q 947 1113 1208 752 
+Q 1469 391 1925 391 
+Q 2381 391 2643 752 
+Q 2906 1113 2906 1747 
+Q 2906 2381 2643 2742 
+Q 2381 3103 1925 3103 
+Q 1469 3103 1208 2742 
+Q 947 2381 947 1747 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-52" d="M 1959 3097 
+Q 1497 3097 1228 2736 
+Q 959 2375 959 1747 
+Q 959 1119 1226 758 
+Q 1494 397 1959 397 
+Q 2419 397 2687 759 
+Q 2956 1122 2956 1747 
+Q 2956 2369 2687 2733 
+Q 2419 3097 1959 3097 
+z
+M 1959 3584 
+Q 2709 3584 3137 3096 
+Q 3566 2609 3566 1747 
+Q 3566 888 3137 398 
+Q 2709 -91 1959 -91 
+Q 1206 -91 779 398 
+Q 353 888 353 1747 
+Q 353 2609 779 3096 
+Q 1206 3584 1959 3584 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-36"/>
+       <use xlink:href="#DejaVuSans-5a" transform="translate(63.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(145.265625 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(173.046875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(236.421875 0)"/>
+       <use xlink:href="#DejaVuSans-36" transform="translate(299.90625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(363.390625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(424.921875 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(464.125 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(559.53125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(591.3125 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(630.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(693.890625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(755.421875 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(787.203125 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(816.703125 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(893.703125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(959.28125 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(991.0625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1054.546875 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1116.078125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1213.484375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_3">
+     <g id="line2d_17"/>
+     <g id="text_11">
+      <!-- Notepad, the JDK demo -->
+      <g style="fill: #c3cbe6" transform="translate(23.370313 251.437811) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-31" d="M 628 4666 
+L 1478 4666 
+L 3547 763 
+L 3547 4666 
+L 4159 4666 
+L 4159 0 
+L 3309 0 
+L 1241 3903 
+L 1241 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-31"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(74.8125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(136 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(175.203125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(236.734375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(300.21875 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(361.5 0)"/>
+       <use xlink:href="#DejaVuSans-f" transform="translate(424.984375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(456.765625 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(488.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4b" transform="translate(527.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(591.125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(652.65625 0)"/>
+       <use xlink:href="#DejaVuSans-2d" transform="translate(684.4375 0)"/>
+       <use xlink:href="#DejaVuSans-27" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-2e" transform="translate(790.9375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(856.515625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(888.296875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(951.78125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1013.3125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(1110.71875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_4">
+     <g id="line2d_18"/>
+     <g id="text_12">
+      <!-- Falling-blocks game -->
+      <g style="fill: #c3cbe6" transform="translate(43.508906 314.583201) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-29" d="M 628 4666 
+L 3309 4666 
+L 3309 4134 
+L 1259 4134 
+L 1259 2759 
+L 3109 2759 
+L 3109 2228 
+L 1259 2228 
+L 1259 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-45" d="M 3116 1747 
+Q 3116 2381 2855 2742 
+Q 2594 3103 2138 3103 
+Q 1681 3103 1420 2742 
+Q 1159 2381 1159 1747 
+Q 1159 1113 1420 752 
+Q 1681 391 2138 391 
+Q 2594 391 2855 752 
+Q 3116 1113 3116 1747 
+z
+M 1159 2969 
+Q 1341 3281 1617 3432 
+Q 1894 3584 2278 3584 
+Q 2916 3584 3314 3078 
+Q 3713 2572 3713 1747 
+Q 3713 922 3314 415 
+Q 2916 -91 2278 -91 
+Q 1894 -91 1617 61 
+Q 1341 213 1159 525 
+L 1159 0 
+L 581 0 
+L 581 4863 
+L 1159 4863 
+L 1159 2969 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-46" d="M 3122 3366 
+L 3122 2828 
+Q 2878 2963 2633 3030 
+Q 2388 3097 2138 3097 
+Q 1578 3097 1268 2742 
+Q 959 2388 959 1747 
+Q 959 1106 1268 751 
+Q 1578 397 2138 397 
+Q 2388 397 2633 464 
+Q 2878 531 3122 666 
+L 3122 134 
+Q 2881 22 2623 -34 
+Q 2366 -91 2075 -91 
+Q 1284 -91 818 406 
+Q 353 903 353 1747 
+Q 353 2603 823 3093 
+Q 1294 3584 2113 3584 
+Q 2378 3584 2631 3529 
+Q 2884 3475 3122 3366 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-4e" d="M 581 4863 
+L 1159 4863 
+L 1159 1991 
+L 2875 3500 
+L 3609 3500 
+L 1753 1863 
+L 3688 0 
+L 2938 0 
+L 1159 1709 
+L 1159 0 
+L 581 0 
+L 581 4863 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-29"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(48.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(109.625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(137.40625 0)"/>
+       <use xlink:href="#DejaVuSans-4c" transform="translate(165.1875 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(192.96875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(256.34375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(319.828125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(355.90625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(419.390625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(447.171875 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(508.359375 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(563.34375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(621.25 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(673.34375 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(705.125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(768.609375 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(829.890625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(927.296875 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_5">
+     <g id="line2d_19"/>
+     <g id="text_13">
+      <!-- javafx-gallery sample -->
+      <g style="fill: #c3cbe6" transform="translate(33.753281 377.728591) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-4d" d="M 603 3500 
+L 1178 3500 
+L 1178 -63 
+Q 1178 -731 923 -1031 
+Q 669 -1331 103 -1331 
+L -116 -1331 
+L -116 -844 
+L 38 -844 
+Q 366 -844 484 -692 
+Q 603 -541 603 -63 
+L 603 3500 
+z
+M 603 4863 
+L 1178 4863 
+L 1178 4134 
+L 603 4134 
+L 603 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-59" d="M 191 3500 
+L 800 3500 
+L 1894 563 
+L 2988 3500 
+L 3597 3500 
+L 2284 0 
+L 1503 0 
+L 191 3500 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-49" d="M 2375 4863 
+L 2375 4384 
+L 1825 4384 
+Q 1516 4384 1395 4259 
+Q 1275 4134 1275 3809 
+L 1275 3500 
+L 2222 3500 
+L 2222 3053 
+L 1275 3053 
+L 1275 0 
+L 697 0 
+L 697 3053 
+L 147 3053 
+L 147 3500 
+L 697 3500 
+L 697 3744 
+Q 697 4328 969 4595 
+Q 1241 4863 1831 4863 
+L 2375 4863 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-5b" d="M 3513 3500 
+L 2247 1797 
+L 3578 0 
+L 2900 0 
+L 1881 1375 
+L 863 0 
+L 184 0 
+L 1544 1831 
+L 300 3500 
+L 978 3500 
+L 1906 2253 
+L 2834 3500 
+L 3513 3500 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-4d"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(27.78125 0)"/>
+       <use xlink:href="#DejaVuSans-59" transform="translate(89.0625 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(148.25 0)"/>
+       <use xlink:href="#DejaVuSans-49" transform="translate(209.53125 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(244.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(303.921875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(340 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(403.484375 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(464.765625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(492.546875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(520.328125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(581.859375 0)"/>
+       <use xlink:href="#DejaVuSans-5c" transform="translate(622.96875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(682.15625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(713.9375 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(766.03125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(827.3125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(924.71875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(988.203125 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1015.984375 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_6">
+     <g id="line2d_20"/>
+     <g id="text_14">
+      <!-- Open-source 2048 game -->
+      <g style="fill: #c3cbe6" transform="translate(16.206562 440.873551) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-32" d="M 2522 4238 
+Q 1834 4238 1429 3725 
+Q 1025 3213 1025 2328 
+Q 1025 1447 1429 934 
+Q 1834 422 2522 422 
+Q 3209 422 3611 934 
+Q 4013 1447 4013 2328 
+Q 4013 3213 3611 3725 
+Q 3209 4238 2522 4238 
+z
+M 2522 4750 
+Q 3503 4750 4090 4092 
+Q 4678 3434 4678 2328 
+Q 4678 1225 4090 567 
+Q 3503 -91 2522 -91 
+Q 1538 -91 948 565 
+Q 359 1222 359 2328 
+Q 359 3434 948 4092 
+Q 1538 4750 2522 4750 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-58" d="M 544 1381 
+L 544 3500 
+L 1119 3500 
+L 1119 1403 
+Q 1119 906 1312 657 
+Q 1506 409 1894 409 
+Q 2359 409 2629 706 
+Q 2900 1003 2900 1516 
+L 2900 3500 
+L 3475 3500 
+L 3475 0 
+L 2900 0 
+L 2900 538 
+Q 2691 219 2414 64 
+Q 2138 -91 1772 -91 
+Q 1169 -91 856 284 
+Q 544 659 544 1381 
+z
+M 1991 3584 
+L 1991 3584 
+z
+" transform="scale(0.015625)"/>
+        <path id="DejaVuSans-1b" d="M 2034 2216 
+Q 1584 2216 1326 1975 
+Q 1069 1734 1069 1313 
+Q 1069 891 1326 650 
+Q 1584 409 2034 409 
+Q 2484 409 2743 651 
+Q 3003 894 3003 1313 
+Q 3003 1734 2745 1975 
+Q 2488 2216 2034 2216 
+z
+M 1403 2484 
+Q 997 2584 770 2862 
+Q 544 3141 544 3541 
+Q 544 4100 942 4425 
+Q 1341 4750 2034 4750 
+Q 2731 4750 3128 4425 
+Q 3525 4100 3525 3541 
+Q 3525 3141 3298 2862 
+Q 3072 2584 2669 2484 
+Q 3125 2378 3379 2068 
+Q 3634 1759 3634 1313 
+Q 3634 634 3220 271 
+Q 2806 -91 2034 -91 
+Q 1263 -91 848 271 
+Q 434 634 434 1313 
+Q 434 1759 690 2068 
+Q 947 2378 1403 2484 
+z
+M 1172 3481 
+Q 1172 3119 1398 2916 
+Q 1625 2713 2034 2713 
+Q 2441 2713 2670 2916 
+Q 2900 3119 2900 3481 
+Q 2900 3844 2670 4047 
+Q 2441 4250 2034 4250 
+Q 1625 4250 1398 4047 
+Q 1172 3844 1172 3481 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-32"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(78.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(142.203125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(203.734375 0)"/>
+       <use xlink:href="#DejaVuSans-10" transform="translate(267.109375 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(303.1875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(355.28125 0)"/>
+       <use xlink:href="#DejaVuSans-58" transform="translate(416.46875 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(479.84375 0)"/>
+       <use xlink:href="#DejaVuSans-46" transform="translate(518.75 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(573.734375 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(635.265625 0)"/>
+       <use xlink:href="#DejaVuSans-15" transform="translate(667.046875 0)"/>
+       <use xlink:href="#DejaVuSans-13" transform="translate(730.671875 0)"/>
+       <use xlink:href="#DejaVuSans-17" transform="translate(794.296875 0)"/>
+       <use xlink:href="#DejaVuSans-1b" transform="translate(857.921875 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(921.546875 0)"/>
+       <use xlink:href="#DejaVuSans-4a" transform="translate(953.328125 0)"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(1016.8125 0)"/>
+       <use xlink:href="#DejaVuSans-50" transform="translate(1078.09375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(1175.5 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_7">
+     <g id="line2d_21"/>
+     <g id="text_15">
+      <!-- Address book -->
+      <g style="fill: #c3cbe6" transform="translate(78.162344 504.019371) scale(0.11 -0.11)">
+       <defs>
+        <path id="DejaVuSans-24" d="M 2188 4044 
+L 1331 1722 
+L 3047 1722 
+L 2188 4044 
+z
+M 1831 4666 
+L 2547 4666 
+L 4325 0 
+L 3669 0 
+L 3244 1197 
+L 1141 1197 
+L 716 0 
+L 50 0 
+L 1831 4666 
+z
+" transform="scale(0.015625)"/>
+       </defs>
+       <use xlink:href="#DejaVuSans-24"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(66.65625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(130.140625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(193.625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(232.53125 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(294.0625 0)"/>
+       <use xlink:href="#DejaVuSans-56" transform="translate(346.15625 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(398.25 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(430.03125 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(493.515625 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(554.703125 0)"/>
+       <use xlink:href="#DejaVuSans-4e" transform="translate(615.890625 0)"/>
+      </g>
+     </g>
+    </g>
+    <g id="ytick_8">
+     <g id="line2d_22"/>
+     <g id="text_16">
+      <!-- Mandelbrot explorer -->
+      <g style="fill: #c3cbe6" transform="translate(41.040781 567.164761) scale(0.11 -0.11)">
+       <use xlink:href="#DejaVuSans-30"/>
+       <use xlink:href="#DejaVuSans-44" transform="translate(86.28125 0)"/>
+       <use xlink:href="#DejaVuSans-51" transform="translate(147.5625 0)"/>
+       <use xlink:href="#DejaVuSans-47" transform="translate(210.9375 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(274.421875 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(335.953125 0)"/>
+       <use xlink:href="#DejaVuSans-45" transform="translate(363.734375 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(427.21875 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(466.125 0)"/>
+       <use xlink:href="#DejaVuSans-57" transform="translate(527.3125 0)"/>
+       <use xlink:href="#DejaVuSans-3" transform="translate(566.515625 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(598.296875 0)"/>
+       <use xlink:href="#DejaVuSans-5b" transform="translate(658.078125 0)"/>
+       <use xlink:href="#DejaVuSans-53" transform="translate(717.265625 0)"/>
+       <use xlink:href="#DejaVuSans-4f" transform="translate(780.75 0)"/>
+       <use xlink:href="#DejaVuSans-52" transform="translate(808.53125 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(869.71875 0)"/>
+       <use xlink:href="#DejaVuSans-48" transform="translate(908.625 0)"/>
+       <use xlink:href="#DejaVuSans-55" transform="translate(970.15625 0)"/>
+      </g>
+     </g>
+    </g>
+   </g>
+   <g id="patch_3">
+    <path d="M 155.78 97.477805 
+L 377.787751 97.477805 
+L 377.787751 119.199819 
+L 155.78 119.199819 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_4">
+    <path d="M 155.78 122.735961 
+L 600.07232 122.735961 
+L 600.07232 144.457975 
+L 155.78 144.457975 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_5">
+    <path d="M 155.78 160.623195 
+L 383.544195 160.623195 
+L 383.544195 182.345209 
+L 155.78 182.345209 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_6">
+    <path d="M 155.78 185.881351 
+L 594.358363 185.881351 
+L 594.358363 207.603365 
+L 155.78 207.603365 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_7">
+    <path d="M 155.78 223.768585 
+L 357.9955 223.768585 
+L 357.9955 245.490599 
+L 155.78 245.490599 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_8">
+    <path d="M 155.78 249.026741 
+L 582.653608 249.026741 
+L 582.653608 270.748755 
+L 155.78 270.748755 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_9">
+    <path d="M 155.78 286.913975 
+L 354.666976 286.913975 
+L 354.666976 308.635989 
+L 155.78 308.635989 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_10">
+    <path d="M 155.78 312.172131 
+L 581.585677 312.172131 
+L 581.585677 333.894145 
+L 155.78 333.894145 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_11">
+    <path d="M 155.78 350.059365 
+L 375.747667 350.059365 
+L 375.747667 371.781379 
+L 155.78 371.781379 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_12">
+    <path d="M 155.78 375.317521 
+L 648.940714 375.317521 
+L 648.940714 397.039535 
+L 155.78 397.039535 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_13">
+    <path d="M 155.78 413.204755 
+L 363.196232 413.204755 
+L 363.196232 434.926769 
+L 155.78 434.926769 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_14">
+    <path d="M 155.78 438.462911 
+L 648.934236 438.462911 
+L 648.934236 460.184925 
+L 155.78 460.184925 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_15">
+    <path d="M 155.78 476.350145 
+L 357.907313 476.350145 
+L 357.907313 498.072159 
+L 155.78 498.072159 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_16">
+    <path d="M 155.78 501.608301 
+L 648.675938 501.608301 
+L 648.675938 523.330315 
+L 155.78 523.330315 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_17">
+    <path d="M 155.78 539.495535 
+L 356.157826 539.495535 
+L 356.157826 561.217549 
+L 155.78 561.217549 
+z
+" clip-path="url(#p95e3599853)" style="fill: #55d4d0"/>
+   </g>
+   <g id="patch_18">
+    <path d="M 155.78 564.753691 
+L 646.976306 564.753691 
+L 646.976306 586.475705 
+L 155.78 586.475705 
+z
+" clip-path="url(#p95e3599853)" style="fill: #f4ad55"/>
+   </g>
+   <g id="patch_19">
+    <path d="M 155.78 610.9256 
+L 708.12 610.9256 
+" style="fill: none; stroke: #2a3350; stroke-width: 0.8; stroke-linejoin: miter; stroke-linecap: square"/>
+   </g>
+   <g id="text_17">
+    <!-- 25.7 -->
+    <g style="fill: #eef2ff" transform="translate(383.70568 110.676703) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-11" d="M 684 794 
+L 1344 794 
+L 1344 0 
+L 684 0 
+L 684 794 
+z
+" transform="scale(0.015625)"/>
+      <path id="DejaVuSans-1a" d="M 525 4666 
+L 3525 4666 
+L 3525 4397 
+L 1831 0 
+L 1172 0 
+L 2766 4134 
+L 525 4134 
+L 525 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_18">
+    <!-- 51.4 -->
+    <g style="fill: #eef2ff" transform="translate(605.990249 135.934859) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_19">
+    <!-- 26.4 -->
+    <g style="fill: #eef2ff" transform="translate(389.462123 173.822093) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_20">
+    <!-- 50.7 -->
+    <g style="fill: #eef2ff" transform="translate(600.276292 199.080249) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_21">
+    <!-- 23.4 -->
+    <g style="fill: #eef2ff" transform="translate(363.913429 236.967483) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_22">
+    <!-- 49.4 -->
+    <g style="fill: #eef2ff" transform="translate(588.571537 262.225639) scale(0.09 -0.09)">
+     <defs>
+      <path id="DejaVuSans-1c" d="M 703 97 
+L 703 672 
+Q 941 559 1184 500 
+Q 1428 441 1663 441 
+Q 2288 441 2617 861 
+Q 2947 1281 2994 2138 
+Q 2813 1869 2534 1725 
+Q 2256 1581 1919 1581 
+Q 1219 1581 811 2004 
+Q 403 2428 403 3163 
+Q 403 3881 828 4315 
+Q 1253 4750 1959 4750 
+Q 2769 4750 3195 4129 
+Q 3622 3509 3622 2328 
+Q 3622 1225 3098 567 
+Q 2575 -91 1691 -91 
+Q 1453 -91 1209 -44 
+Q 966 3 703 97 
+z
+M 1959 2075 
+Q 2384 2075 2632 2365 
+Q 2881 2656 2881 3163 
+Q 2881 3666 2632 3958 
+Q 2384 4250 1959 4250 
+Q 1534 4250 1286 3958 
+Q 1038 3666 1038 3163 
+Q 1038 2656 1286 2365 
+Q 1534 2075 1959 2075 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-17"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_23">
+    <!-- 23.0 -->
+    <g style="fill: #eef2ff" transform="translate(360.584904 300.112873) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_24">
+    <!-- 49.3 -->
+    <g style="fill: #eef2ff" transform="translate(587.503605 325.371029) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-17"/>
+     <use xlink:href="#DejaVuSans-1c" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_25">
+    <!-- 25.5 -->
+    <g style="fill: #eef2ff" transform="translate(381.665596 363.258263) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-18" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_26">
+    <!-- 57.1 -->
+    <g style="fill: #eef2ff" transform="translate(654.858643 388.516419) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_27">
+    <!-- 24.0 -->
+    <g style="fill: #eef2ff" transform="translate(369.11416 426.403653) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_28">
+    <!-- 57.1 -->
+    <g style="fill: #eef2ff" transform="translate(654.852165 451.661809) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-14" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_29">
+    <!-- 23.4 -->
+    <g style="fill: #eef2ff" transform="translate(363.825242 489.549043) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-17" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_30">
+    <!-- 57.0 -->
+    <g style="fill: #eef2ff" transform="translate(654.593867 514.807199) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-1a" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-13" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_31">
+    <!-- 23.2 -->
+    <g style="fill: #eef2ff" transform="translate(362.075755 552.694433) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-15"/>
+     <use xlink:href="#DejaVuSans-16" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-15" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_32">
+    <!-- 56.8 -->
+    <g style="fill: #eef2ff" transform="translate(652.894235 577.952589) scale(0.09 -0.09)">
+     <use xlink:href="#DejaVuSans-18"/>
+     <use xlink:href="#DejaVuSans-19" transform="translate(63.625 0)"/>
+     <use xlink:href="#DejaVuSans-11" transform="translate(127.25 0)"/>
+     <use xlink:href="#DejaVuSans-1b" transform="translate(159.03125 0)"/>
+    </g>
+   </g>
+   <g id="text_33">
+    <!-- macOS: the application as installed -->
+    <g style="fill: #eef2ff" transform="translate(155.78 25.023809) scale(0.15 -0.15)">
+     <defs>
+      <path id="DejaVuSans-1d" d="M 750 794 
+L 1409 794 
+L 1409 0 
+L 750 0 
+L 750 794 
+z
+M 750 3309 
+L 1409 3309 
+L 1409 2516 
+L 750 2516 
+L 750 3309 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-50"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(97.40625 0)"/>
+     <use xlink:href="#DejaVuSans-46" transform="translate(158.6875 0)"/>
+     <use xlink:href="#DejaVuSans-32" transform="translate(213.671875 0)"/>
+     <use xlink:href="#DejaVuSans-36" transform="translate(292.390625 0)"/>
+     <use xlink:href="#DejaVuSans-1d" transform="translate(355.875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(389.5625 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(421.34375 0)"/>
+     <use xlink:href="#DejaVuSans-4b" transform="translate(460.546875 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(523.921875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(585.453125 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(617.234375 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(678.515625 0)"/>
+     <use xlink:href="#DejaVuSans-53" transform="translate(742 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(805.484375 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(833.265625 0)"/>
+     <use xlink:href="#DejaVuSans-46" transform="translate(861.046875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(916.03125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(977.3125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(1016.515625 0)"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(1044.296875 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1105.484375 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1168.859375 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1200.640625 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1261.921875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(1314.015625 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(1345.796875 0)"/>
+     <use xlink:href="#DejaVuSans-51" transform="translate(1373.578125 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(1436.953125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(1489.046875 0)"/>
+     <use xlink:href="#DejaVuSans-44" transform="translate(1528.25 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(1589.53125 0)"/>
+     <use xlink:href="#DejaVuSans-4f" transform="translate(1617.3125 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(1645.09375 0)"/>
+     <use xlink:href="#DejaVuSans-47" transform="translate(1706.625 0)"/>
+    </g>
+    <!-- Lower is better -->
+    <g style="fill: #eef2ff" transform="translate(155.78 43.02791) scale(0.15 -0.15)">
+     <defs>
+      <path id="DejaVuSans-2f" d="M 628 4666 
+L 1259 4666 
+L 1259 531 
+L 3531 531 
+L 3531 0 
+L 628 0 
+L 628 4666 
+z
+" transform="scale(0.015625)"/>
+     </defs>
+     <use xlink:href="#DejaVuSans-2f"/>
+     <use xlink:href="#DejaVuSans-52" transform="translate(53.96875 0)"/>
+     <use xlink:href="#DejaVuSans-5a" transform="translate(115.15625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(196.9375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(258.46875 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(299.578125 0)"/>
+     <use xlink:href="#DejaVuSans-4c" transform="translate(331.359375 0)"/>
+     <use xlink:href="#DejaVuSans-56" transform="translate(359.140625 0)"/>
+     <use xlink:href="#DejaVuSans-3" transform="translate(411.234375 0)"/>
+     <use xlink:href="#DejaVuSans-45" transform="translate(443.015625 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(506.5 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(568.03125 0)"/>
+     <use xlink:href="#DejaVuSans-57" transform="translate(607.234375 0)"/>
+     <use xlink:href="#DejaVuSans-48" transform="translate(646.4375 0)"/>
+     <use xlink:href="#DejaVuSans-55" transform="translate(707.96875 0)"/>
+    </g>
+   </g>
+   <g id="legend_1">
+    <g id="patch_20">
+     <path d="M 159.2566 61.625566 
+L 171.2566 61.625566 
+L 171.2566 54.625566 
+L 159.2566 54.625566 
+z
+" style="fill: #55d4d0"/>
+    </g>
+    <g id="text_34">
+     <!-- Native .app, arm64 -->
+     <g style="fill: #eef2ff" transform="translate(179.2566 61.625566) scale(0.1 -0.1)">
+      <use xlink:href="#DejaVuSans-31"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(74.8125 0)"/>
+      <use xlink:href="#DejaVuSans-57" transform="translate(136.09375 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(175.296875 0)"/>
+      <use xlink:href="#DejaVuSans-59" transform="translate(203.078125 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(262.265625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(323.796875 0)"/>
+      <use xlink:href="#DejaVuSans-11" transform="translate(355.578125 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(387.359375 0)"/>
+      <use xlink:href="#DejaVuSans-53" transform="translate(448.640625 0)"/>
+      <use xlink:href="#DejaVuSans-53" transform="translate(512.125 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(575.609375 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(607.390625 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(639.171875 0)"/>
+      <use xlink:href="#DejaVuSans-55" transform="translate(700.453125 0)"/>
+      <use xlink:href="#DejaVuSans-50" transform="translate(739.8125 0)"/>
+      <use xlink:href="#DejaVuSans-19" transform="translate(837.21875 0)"/>
+      <use xlink:href="#DejaVuSans-17" transform="translate(900.84375 0)"/>
+     </g>
+    </g>
+    <g id="patch_21">
+     <path d="M 289.703475 61.625566 
+L 301.703475 61.625566 
+L 301.703475 54.625566 
+L 289.703475 54.625566 
+z
+" style="fill: #f4ad55"/>
+    </g>
+    <g id="text_35">
+     <!-- JVM image, jlink, arm64 -->
+     <g style="fill: #eef2ff" transform="translate(309.703475 61.625566) scale(0.1 -0.1)">
+      <defs>
+       <path id="DejaVuSans-39" d="M 1831 0 
+L 50 4666 
+L 709 4666 
+L 2188 738 
+L 3669 4666 
+L 4325 4666 
+L 2547 0 
+L 1831 0 
+z
+" transform="scale(0.015625)"/>
+      </defs>
+      <use xlink:href="#DejaVuSans-2d"/>
+      <use xlink:href="#DejaVuSans-39" transform="translate(29.5 0)"/>
+      <use xlink:href="#DejaVuSans-30" transform="translate(97.90625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(184.1875 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(215.96875 0)"/>
+      <use xlink:href="#DejaVuSans-50" transform="translate(243.75 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(341.15625 0)"/>
+      <use xlink:href="#DejaVuSans-4a" transform="translate(402.4375 0)"/>
+      <use xlink:href="#DejaVuSans-48" transform="translate(465.921875 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(527.453125 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(559.234375 0)"/>
+      <use xlink:href="#DejaVuSans-4d" transform="translate(591.015625 0)"/>
+      <use xlink:href="#DejaVuSans-4f" transform="translate(618.796875 0)"/>
+      <use xlink:href="#DejaVuSans-4c" transform="translate(646.578125 0)"/>
+      <use xlink:href="#DejaVuSans-51" transform="translate(674.359375 0)"/>
+      <use xlink:href="#DejaVuSans-4e" transform="translate(737.734375 0)"/>
+      <use xlink:href="#DejaVuSans-f" transform="translate(795.640625 0)"/>
+      <use xlink:href="#DejaVuSans-3" transform="translate(827.421875 0)"/>
+      <use xlink:href="#DejaVuSans-44" transform="translate(859.203125 0)"/>
+      <use xlink:href="#DejaVuSans-55" transform="translate(920.484375 0)"/>
+      <use xlink:href="#DejaVuSans-50" transform="translate(959.84375 0)"/>
+      <use xlink:href="#DejaVuSans-19" transform="translate(1057.25 0)"/>
+      <use xlink:href="#DejaVuSans-17" transform="translate(1120.875 0)"/>
+     </g>
+    </g>
+   </g>
+  </g>
+  <g id="text_36">
+   <!-- macOS 26.6.2, arm64, Apple M4 Max -->
+   <g style="fill: #c3cbe6" transform="translate(563.75625 663.833325) scale(0.08 -0.08)">
+    <use xlink:href="#DejaVuSans-50"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(97.40625 0)"/>
+    <use xlink:href="#DejaVuSans-46" transform="translate(158.6875 0)"/>
+    <use xlink:href="#DejaVuSans-32" transform="translate(213.671875 0)"/>
+    <use xlink:href="#DejaVuSans-36" transform="translate(292.390625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(355.875 0)"/>
+    <use xlink:href="#DejaVuSans-15" transform="translate(387.65625 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(451.28125 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(514.90625 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(546.6875 0)"/>
+    <use xlink:href="#DejaVuSans-11" transform="translate(610.3125 0)"/>
+    <use xlink:href="#DejaVuSans-15" transform="translate(642.09375 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(705.71875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(737.5 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(769.28125 0)"/>
+    <use xlink:href="#DejaVuSans-55" transform="translate(830.5625 0)"/>
+    <use xlink:href="#DejaVuSans-50" transform="translate(869.921875 0)"/>
+    <use xlink:href="#DejaVuSans-19" transform="translate(967.328125 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(1030.953125 0)"/>
+    <use xlink:href="#DejaVuSans-f" transform="translate(1094.578125 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1126.359375 0)"/>
+    <use xlink:href="#DejaVuSans-24" transform="translate(1158.140625 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(1226.546875 0)"/>
+    <use xlink:href="#DejaVuSans-53" transform="translate(1290.03125 0)"/>
+    <use xlink:href="#DejaVuSans-4f" transform="translate(1353.515625 0)"/>
+    <use xlink:href="#DejaVuSans-48" transform="translate(1381.296875 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1442.828125 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(1474.609375 0)"/>
+    <use xlink:href="#DejaVuSans-17" transform="translate(1560.890625 0)"/>
+    <use xlink:href="#DejaVuSans-3" transform="translate(1624.515625 0)"/>
+    <use xlink:href="#DejaVuSans-30" transform="translate(1656.296875 0)"/>
+    <use xlink:href="#DejaVuSans-44" transform="translate(1742.578125 0)"/>
+    <use xlink:href="#DejaVuSans-5b" transform="translate(1803.859375 0)"/>
+   </g>
+  </g>
+ </g>
+ <defs>
+  <clipPath id="p95e3599853">
+   <rect x="155.78" y="73.02791" width="552.34" height="537.89769"/>
+  </clipPath>
+ </defs>
+</svg>
diff --git a/docs/developer-guide/languagetool-accept.txt b/docs/developer-guide/languagetool-accept.txt
index c71b484ddbf..823f52b2c36 100644
--- a/docs/developer-guide/languagetool-accept.txt
+++ b/docs/developer-guide/languagetool-accept.txt
@@ -803,3 +803,9 @@ Toolchain
 # (performance.asciidoc).
 inlining
 inlined
+
+# -----------------------------------------------------------------------------
+# Desktop compatibility chapter (Desktop-Interop.asciidoc and its measured
+# tables): the SwingX component set and the CPU architecture of the test machine.
+SwingX
+aarch64
diff --git a/docs/website/data/port_status.json b/docs/website/data/port_status.json
index 72e56c8f368..58d033dde26 100644
--- a/docs/website/data/port_status.json
+++ b/docs/website/data/port_status.json
@@ -129,6 +129,13 @@
         "AndroidCompatKotlinScreenshotTest"
       ]
     },
+    {
+      "id": "desktop-compatibility",
+      "category": "Application runtime",
+      "name": "Swing and JavaFX applications (java.awt, javax.swing, SwingX and javafx.*)",
+      "description": "Runs unmodified Swing, SwingX and JavaFX code -- layout managers, the standard controls, tables, trees and lists with custom renderers, Graphics2D and Canvas painting, FXML with controllers and style sheets, and modal dialogs that block their caller -- through the desktop compatibility runtimes, embedded in a Codename One form.",
+      "tests": ["DesktopCompatSwingControlsScreenshotTest","DesktopCompatSwingTablesScreenshotTest","DesktopCompatSwingTreesScreenshotTest","DesktopCompatSwingPaintingScreenshotTest","DesktopCompatSwingContainersScreenshotTest","DesktopCompatSwingOptionPaneScreenshotTest","DesktopCompatSwingXScreenshotTest","DesktopCompatFxControlsScreenshotTest","DesktopCompatFxDataScreenshotTest","DesktopCompatFxShapesScreenshotTest","DesktopCompatFxFxmlScreenshotTest","DesktopCompatFxPanesScreenshotTest","DesktopCompatFxAlertScreenshotTest"]
+    },
     {
       "id": "ads",
       "category": "Application runtime",
@@ -1584,6 +1591,58 @@
     {
       "pattern": "AndroidCompatKotlin",
       "test": "AndroidCompatKotlinScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingControls",
+      "test": "DesktopCompatSwingControlsScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingTables",
+      "test": "DesktopCompatSwingTablesScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingTrees",
+      "test": "DesktopCompatSwingTreesScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingPainting",
+      "test": "DesktopCompatSwingPaintingScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingContainers",
+      "test": "DesktopCompatSwingContainersScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingOptionPane",
+      "test": "DesktopCompatSwingOptionPaneScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatSwingX",
+      "test": "DesktopCompatSwingXScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatFxControls",
+      "test": "DesktopCompatFxControlsScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatFxData",
+      "test": "DesktopCompatFxDataScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatFxShapes",
+      "test": "DesktopCompatFxShapesScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatFxFxml",
+      "test": "DesktopCompatFxFxmlScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatFxPanes",
+      "test": "DesktopCompatFxPanesScreenshotTest"
+    },
+    {
+      "pattern": "DesktopCompatFxAlert",
+      "test": "DesktopCompatFxAlertScreenshotTest"
     }
   ]
 }
diff --git a/maven/android-compat/pom.xml b/maven/android-compat/pom.xml
index 39bd17dddff..3a5e1d4b807 100644
--- a/maven/android-compat/pom.xml
+++ b/maven/android-compat/pom.xml
@@ -167,6 +167,13 @@
             <artifactId>junit</artifactId>
             <scope>test</scope>
         </dependency>
+        <!-- The headless Codename One implementation the tests run on. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-compat-testing</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
         <!-- A real SQLite engine for the android.database tests, behind a
              JDBC-backed Codename One Database. -->
         <dependency>
diff --git a/maven/android-compat/src/main/java/android/content/Context.java b/maven/android-compat/src/main/java/android/content/Context.java
index 670b4dee220..3cdb6585396 100644
--- a/maven/android-compat/src/main/java/android/content/Context.java
+++ b/maven/android-compat/src/main/java/android/content/Context.java
@@ -180,14 +180,24 @@ public int checkCallingOrSelfPermission(String permission) {
     // ------------------------------------------------------------ files
 
     /// The application's private directories live under the Codename One
-    /// application home, laid out like Android's data directory. `java.io.File`
-    /// here is the compatibility runtime's file class once the build has
-    /// relocated the code.
+    /// application home, laid out like Android's data directory.
     private static java.io.File appDir(String name) {
-        String home = com.codename1.io.FileSystemStorage.getInstance().getAppHomePath();
+        String home = appHome();
         return ensureDir(new java.io.File(home.endsWith("/") ? home + name : home + "/" + name));
     }
 
+    /// The application home as a native path. `FileSystemStorage` answers a
+    /// `file:` URL, and `java.io.File` is the platform's own class: on
+    /// Android and the simulator that is the JDK's, which takes the URL as a
+    /// relative file name and fails to open anything under it.
+    private static String appHome() {
+        return nativePath(com.codename1.io.FileSystemStorage.getInstance().getAppHomePath());
+    }
+
+    private static String nativePath(String path) {
+        return com.codename1.io.FileSystemStorage.getInstance().toNativePath(path);
+    }
+
     /// Creates `dir` when missing. Like Android's, the directory getters
     /// still answer it when that fails, and report the failure in the log.
     private static java.io.File ensureDir(java.io.File dir) {
@@ -198,7 +208,7 @@ private static java.io.File ensureDir(java.io.File dir) {
     }
 
     public java.io.File getDataDir() {
-        return new java.io.File(com.codename1.io.FileSystemStorage.getInstance().getAppHomePath());
+        return new java.io.File(appHome());
     }
 
     public java.io.File getFilesDir() {
@@ -218,7 +228,7 @@ public java.io.File getCacheDir() {
         if (fs.hasCachesDir()) {
             String caches = fs.getCachesDir();
             if (caches != null) {
-                return ensureDir(new java.io.File(caches));
+                return ensureDir(new java.io.File(nativePath(caches)));
             }
         }
         return appDir("cache");
@@ -286,14 +296,17 @@ private static void checkFileName(String name) {
     /// Where a named database lives: the platform's database path when it
     /// exposes one, otherwise the `databases` directory Android would use.
     public java.io.File getDatabasePath(String name) {
-        if (name.startsWith("/") || name.startsWith("file:")) {
+        if (name.startsWith("/")) {
             return new java.io.File(name);
         }
+        if (name.startsWith("file:")) {
+            return new java.io.File(nativePath(name));
+        }
         try {
             if (com.codename1.db.Database.isCustomPathSupported()) {
                 String p = com.codename1.db.Database.getDatabasePath(name);
                 if (p != null) {
-                    return new java.io.File(p);
+                    return new java.io.File(nativePath(p));
                 }
             }
         } catch (IllegalArgumentException e) {
diff --git a/maven/android-compat/src/main/java/android/net/Uri.java b/maven/android-compat/src/main/java/android/net/Uri.java
index a331daf7bdb..49f1bc8983f 100644
--- a/maven/android-compat/src/main/java/android/net/Uri.java
+++ b/maven/android-compat/src/main/java/android/net/Uri.java
@@ -53,10 +53,11 @@ public static Uri withAppendedPath(Uri baseUri, String pathSegment) {
     }
 
     public static Uri fromFile(Object file) {
-        // A shim directory (`getFilesDir()`) is already a `file:` path;
-        // prefixing another scheme gave `file://file:///...`.
-        String s = file instanceof com.codename1.androidcompat.jdk.File
-                ? ((com.codename1.androidcompat.jdk.File) file).storagePath() : String.valueOf(file);
+        // A device's java.io.File keeps the storage path it was made from
+        // (`getFilesDir()` is a `file:` path there), and a JDK's is a plain
+        // absolute path; both are handled below. Prefixing another scheme
+        // to the first gave `file://file:///...`.
+        String s = String.valueOf(file);
         // The path is percent-encoded (everything but `/`) as Android's
         // fromFile does: a raw `#` or `?` in a file name started a fragment
         // or query, so `getPath()` named another file. The authority a
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/File.java b/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/File.java
deleted file mode 100644
index 59b41be5c60..00000000000
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/File.java
+++ /dev/null
@@ -1,518 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import com.codename1.io.FileSystemStorage;
-import com.codename1.io.Util;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.util.ArrayList;
-import java.util.List;
-
-/// `java.io.File` for the Codename One runtime, over `FileSystemStorage`.
-/// Android code is compiled against the JDK class and the build's remap step
-/// points it here.
-///
-/// Paths map onto the application's sandbox: a `file:` path is used as it
-/// is, an absolute path (`/data/...`) becomes a `file://` path, and a
-/// relative path is resolved against the application home, the directory
-/// `Context.getDataDir()` answers and `getFilesDir()` is under.
-/// Serializable like the JDK class: Android code compiled against
-/// `java.io.File` passes one to `Intent.putExtra(String, Serializable)` and
-/// `Bundle.putSerializable`, and the remapped call still names that
-/// parameter type.
-public class File implements Comparable<File>, java.io.Serializable {
-
-    private static final long serialVersionUID = 1L;
-
-    public static final char separatorChar = '/';
-    public static final String separator = "/";
-    public static final char pathSeparatorChar = ':';
-    public static final String pathSeparator = ":";
-
-    private final String path;
-
-    public File(String pathname) {
-        if (pathname == null) {
-            throw new NullPointerException();
-        }
-        this.path = normalize(pathname);
-    }
-
-    public File(String parent, String child) {
-        if (child == null) {
-            throw new NullPointerException();
-        }
-        this.path = parent == null ? normalize(child) : join(normalize(parent), child);
-    }
-
-    public File(File parent, String child) {
-        if (child == null) {
-            throw new NullPointerException();
-        }
-        this.path = parent == null ? normalize(child) : join(parent.path, child);
-    }
-
-    private static String normalize(String p) {
-        // Collapse duplicate separators (outside the scheme) and drop a
-        // trailing one, as java.io.File does.
-        StringBuilder sb = new StringBuilder(p.length());
-        int start = 0;
-        if (p.startsWith("file://")) {
-            sb.append("file://");
-            start = 7;
-        }
-        char prev = 0;
-        for (int i = start; i < p.length(); i++) {
-            char c = p.charAt(i);
-            if (c == '\\') {
-                c = '/';
-            }
-            if (c == '/' && prev == '/') {
-                continue;
-            }
-            sb.append(c);
-            prev = c;
-        }
-        int min = start + 1;
-        while (sb.length() > min && sb.charAt(sb.length() - 1) == '/') {
-            sb.setLength(sb.length() - 1);
-        }
-        return sb.toString();
-    }
-
-    private static String join(String parent, String child) {
-        String c = normalize(child);
-        if (parent.length() == 0) {
-            return c;
-        }
-        if (c.startsWith("/")) {
-            c = c.substring(1);
-        }
-        return parent.endsWith("/") ? parent + c : parent + "/" + c;
-    }
-
-    /// The `FileSystemStorage` path for this file.
-    public String storagePath() {
-        if (path.startsWith("file:")) {
-            return path;
-        }
-        if (path.startsWith("/")) {
-            return "file://" + path;
-        }
-        String home = FileSystemStorage.getInstance().getAppHomePath();
-        if (!home.endsWith("/")) {
-            home = home + "/";
-        }
-        return home + path;
-    }
-
-    private static FileSystemStorage fs() {
-        return FileSystemStorage.getInstance();
-    }
-
-    public String getName() {
-        int i = path.lastIndexOf('/');
-        return i < 0 ? path : path.substring(i + 1);
-    }
-
-    public String getPath() {
-        return path;
-    }
-
-    public String getAbsolutePath() {
-        return storagePath();
-    }
-
-    public File getAbsoluteFile() {
-        return new File(getAbsolutePath());
-    }
-
-    /// The absolute path with `.` and `..` segments resolved, as the JDK
-    /// does: code checks a canonical path against a directory to reject a
-    /// name like `root/../outside`, and the native file system would resolve
-    /// the `..` the check never saw. A `..` at the root stays at the root.
-    /// Symbolic links are not followed.
-    public String getCanonicalPath() throws IOException {
-        return resolveDots(getAbsolutePath());
-    }
-
-    public File getCanonicalFile() throws IOException {
-        return new File(getCanonicalPath());
-    }
-
-    private static String resolveDots(String p) {
-        // The prefix is the scheme and the slashes that follow it (`file:///`
-        // or `file://` before an authority-less home such as `home/`).
-        int start = p.startsWith("file:") ? 5 : 0;
-        while (start < p.length() && p.charAt(start) == '/') {
-            start++;
-        }
-        ArrayList<String> segs = new ArrayList<String>();
-        int s = start;
-        for (int i = start; i <= p.length(); i++) {
-            if (i == p.length() || p.charAt(i) == '/') {
-                String seg = p.substring(s, i);
-                if (seg.equals("..")) {
-                    if (!segs.isEmpty()) {
-                        segs.remove(segs.size() - 1);
-                    }
-                } else if (seg.length() > 0 && !seg.equals(".")) {
-                    segs.add(seg);
-                }
-                s = i + 1;
-            }
-        }
-        StringBuilder sb = new StringBuilder(p.length());
-        sb.append(p.substring(0, start));
-        for (int i = 0; i < segs.size(); i++) {
-            if (i > 0) {
-                sb.append('/');
-            }
-            sb.append(segs.get(i));
-        }
-        return sb.toString();
-    }
-
-    public String getParent() {
-        int i = path.lastIndexOf('/');
-        if (i < 0) {
-            return null;
-        }
-        if (i == 0) {
-            return path.length() > 1 ? "/" : null;
-        }
-        String p = path.substring(0, i);
-        return p.equals("file:/") ? null : p;
-    }
-
-    public File getParentFile() {
-        String p = getParent();
-        return p == null ? null : new File(p);
-    }
-
-    public boolean isAbsolute() {
-        return path.startsWith("/") || path.startsWith("file:");
-    }
-
-    public boolean exists() {
-        return fs().exists(storagePath());
-    }
-
-    public boolean isDirectory() {
-        String p = storagePath();
-        return fs().exists(p) && fs().isDirectory(p);
-    }
-
-    public boolean isFile() {
-        String p = storagePath();
-        return fs().exists(p) && !fs().isDirectory(p);
-    }
-
-    public boolean isHidden() {
-        return getName().startsWith(".");
-    }
-
-    public boolean canRead() {
-        return exists();
-    }
-
-    public boolean canWrite() {
-        return exists();
-    }
-
-    public boolean canExecute() {
-        return false;
-    }
-
-    public boolean setReadable(boolean readable) {
-        return exists();
-    }
-
-    public boolean setWritable(boolean writable) {
-        return exists();
-    }
-
-    public boolean setReadOnly() {
-        return exists();
-    }
-
-    public boolean setLastModified(long time) {
-        return false;
-    }
-
-    public long length() {
-        String p = storagePath();
-        return fs().exists(p) && !fs().isDirectory(p) ? fs().getLength(p) : 0L;
-    }
-
-    public long lastModified() {
-        String p = storagePath();
-        return fs().exists(p) ? fs().getLastModified(p) : 0L;
-    }
-
-    public long getFreeSpace() {
-        return getUsableSpace();
-    }
-
-    public long getUsableSpace() {
-        String[] roots = fs().getRoots();
-        return roots == null || roots.length == 0 ? 0L : fs().getRootAvailableSpace(roots[0]);
-    }
-
-    public long getTotalSpace() {
-        String[] roots = fs().getRoots();
-        return roots == null || roots.length == 0 ? 0L : fs().getRootSizeBytes(roots[0]);
-    }
-
-    public boolean createNewFile() throws IOException {
-        if (exists()) {
-            return false;
-        }
-        File parent = getParentFile();
-        if (parent != null && !parent.exists()) {
-            throw new IOException("No such file or directory: " + getParent());
-        }
-        OutputStream out = fs().openOutputStream(storagePath());
-        out.close();
-        return true;
-    }
-
-    public boolean delete() {
-        String p = storagePath();
-        if (!fs().exists(p)) {
-            return false;
-        }
-        if (fs().isDirectory(p)) {
-            String[] children = list();
-            if (children != null && children.length > 0) {
-                return false;
-            }
-        }
-        fs().delete(p);
-        return !fs().exists(p);
-    }
-
-    public void deleteOnExit() {
-    }
-
-    public boolean mkdir() {
-        String p = storagePath();
-        if (fs().exists(p)) {
-            return false;
-        }
-        File parent = getParentFile();
-        if (parent != null && !parent.isDirectory()) {
-            return false;
-        }
-        fs().mkdir(p);
-        return fs().exists(p);
-    }
-
-    public boolean mkdirs() {
-        if (exists()) {
-            return false;
-        }
-        File parent = getParentFile();
-        if (parent != null && !parent.exists()) {
-            parent.mkdirs();
-        }
-        return mkdir();
-    }
-
-    /// Renames within a directory through the storage; elsewhere, copies and
-    /// deletes, which is what a move across file systems does on Android.
-    public boolean renameTo(File dest) {
-        if (!exists() || dest == null) {
-            return false;
-        }
-        // A file renamed onto itself is already where it was asked to be.
-        // The copy path below would open the same storage path for reading
-        // and writing, truncating it, and then delete it.
-        if (resolveDots(storagePath()).equals(resolveDots(dest.storagePath()))) {
-            return true;
-        }
-        String parent = getParent();
-        String destParent = dest.getParent();
-        if (parent != null && parent.equals(destParent) && !dest.exists()) {
-            fs().rename(storagePath(), dest.getName());
-            return dest.exists();
-        }
-        if (isDirectory()) {
-            return false;
-        }
-        boolean replacing = dest.exists();
-        try {
-            InputStream in = fs().openInputStream(storagePath());
-            OutputStream out = fs().openOutputStream(dest.storagePath());
-            Util.copy(in, out);
-        } catch (IOException e) {
-            return false;
-        }
-        // The move only happened if the source is gone. When it cannot be
-        // removed the rename fails, and a copy that created the destination
-        // is taken back so the file is left where it was; one that replaced
-        // an existing destination stays, as deleting it would lose both.
-        fs().delete(storagePath());
-        if (fs().exists(storagePath())) {
-            if (!replacing) {
-                fs().delete(dest.storagePath());
-            }
-            return false;
-        }
-        return true;
-    }
-
-    public String[] list() {
-        String p = storagePath();
-        if (!fs().exists(p) || !fs().isDirectory(p)) {
-            return null;
-        }
-        try {
-            String[] names = fs().listFiles(p);
-            if (names == null) {
-                return new String[0];
-            }
-            String[] out = new String[names.length];
-            for (int i = 0; i < names.length; i++) {
-                String n = names[i];
-                while (n.endsWith("/")) {
-                    n = n.substring(0, n.length() - 1);
-                }
-                int slash = n.lastIndexOf('/');
-                out[i] = slash < 0 ? n : n.substring(slash + 1);
-            }
-            return out;
-        } catch (IOException e) {
-            return null;
-        }
-    }
-
-    public String[] list(FilenameFilter filter) {
-        String[] names = list();
-        if (names == null || filter == null) {
-            return names;
-        }
-        List<String> out = new ArrayList<String>();
-        for (String n : names) {
-            if (filter.accept(this, n)) {
-                out.add(n);
-            }
-        }
-        return out.toArray(new String[out.size()]);
-    }
-
-    public File[] listFiles() {
-        String[] names = list();
-        if (names == null) {
-            return null;
-        }
-        File[] out = new File[names.length];
-        for (int i = 0; i < names.length; i++) {
-            out[i] = new File(this, names[i]);
-        }
-        return out;
-    }
-
-    public File[] listFiles(FilenameFilter filter) {
-        String[] names = list(filter);
-        if (names == null) {
-            return null;
-        }
-        File[] out = new File[names.length];
-        for (int i = 0; i < names.length; i++) {
-            out[i] = new File(this, names[i]);
-        }
-        return out;
-    }
-
-    public File[] listFiles(FileFilter filter) {
-        File[] all = listFiles();
-        if (all == null || filter == null) {
-            return all;
-        }
-        List<File> out = new ArrayList<File>();
-        for (File f : all) {
-            if (filter.accept(f)) {
-                out.add(f);
-            }
-        }
-        return out.toArray(new File[out.size()]);
-    }
-
-    public static File createTempFile(String prefix, String suffix) throws IOException {
-        return createTempFile(prefix, suffix, null);
-    }
-
-    public static File createTempFile(String prefix, String suffix, File directory) throws IOException {
-        if (prefix == null || prefix.length() < 3) {
-            throw new IllegalArgumentException("Prefix string too short");
-        }
-        File dir = directory;
-        if (dir == null) {
-            String caches = FileSystemStorage.getInstance().hasCachesDir()
-                    ? FileSystemStorage.getInstance().getCachesDir() : null;
-            dir = new File(caches != null ? caches : FileSystemStorage.getInstance().getAppHomePath());
-        }
-        String s = suffix == null ? ".tmp" : suffix;
-        long n = System.currentTimeMillis();
-        while (true) {
-            File f = new File(dir, prefix + n + s);
-            if (f.createNewFile()) {
-                return f;
-            }
-            n++;
-        }
-    }
-
-    public static File[] listRoots() {
-        String[] roots = FileSystemStorage.getInstance().getRoots();
-        File[] out = new File[roots == null ? 0 : roots.length];
-        for (int i = 0; i < out.length; i++) {
-            out[i] = new File(roots[i]);
-        }
-        return out;
-    }
-
-    @Override
-    public int compareTo(File other) {
-        return path.compareTo(other.path);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        return o instanceof File && ((File) o).path.equals(path);
-    }
-
-    @Override
-    public int hashCode() {
-        return path.hashCode() ^ 1234321;
-    }
-
-    @Override
-    public String toString() {
-        return path;
-    }
-}
diff --git a/maven/android-compat/src/test/java/android/animation/AnimatorMathTest.java b/maven/android-compat/src/test/java/android/animation/AnimatorMathTest.java
index 6b1103c4478..ce74d0d802f 100644
--- a/maven/android-compat/src/test/java/android/animation/AnimatorMathTest.java
+++ b/maven/android-compat/src/test/java/android/animation/AnimatorMathTest.java
@@ -29,7 +29,7 @@
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.LinearInterpolator;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/animation/AutoCancelReleaseTest.java b/maven/android-compat/src/test/java/android/animation/AutoCancelReleaseTest.java
index 64da6c7c1af..9d1a4b21603 100644
--- a/maven/android-compat/src/test/java/android/animation/AutoCancelReleaseTest.java
+++ b/maven/android-compat/src/test/java/android/animation/AutoCancelReleaseTest.java
@@ -22,7 +22,7 @@
  */
 package android.animation;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/animation/ObjectAnimatorSetPropertyTest.java b/maven/android-compat/src/test/java/android/animation/ObjectAnimatorSetPropertyTest.java
index 70662c4d5db..5113ff1165f 100644
--- a/maven/android-compat/src/test/java/android/animation/ObjectAnimatorSetPropertyTest.java
+++ b/maven/android-compat/src/test/java/android/animation/ObjectAnimatorSetPropertyTest.java
@@ -24,7 +24,7 @@
 
 import android.view.animation.LinearInterpolator;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/animation/ReverseRepeatedAnimatorTest.java b/maven/android-compat/src/test/java/android/animation/ReverseRepeatedAnimatorTest.java
index 6d91b01f83b..f47c5e0c6ab 100644
--- a/maven/android-compat/src/test/java/android/animation/ReverseRepeatedAnimatorTest.java
+++ b/maven/android-compat/src/test/java/android/animation/ReverseRepeatedAnimatorTest.java
@@ -25,7 +25,7 @@
 import android.view.animation.AnimationUtils;
 import android.view.animation.LinearInterpolator;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/app/ActivityBoundaryTest.java b/maven/android-compat/src/test/java/android/app/ActivityBoundaryTest.java
index 6a5cc08c9d1..5c475ba12bc 100644
--- a/maven/android-compat/src/test/java/android/app/ActivityBoundaryTest.java
+++ b/maven/android-compat/src/test/java/android/app/ActivityBoundaryTest.java
@@ -26,7 +26,7 @@
 import android.content.Intent;
 import android.os.Bundle;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.*;
 import static org.junit.Assert.*;
 
diff --git a/maven/android-compat/src/test/java/android/app/DialogDefaultTouchTest.java b/maven/android-compat/src/test/java/android/app/DialogDefaultTouchTest.java
index 13506dd3641..ff55d7420be 100644
--- a/maven/android-compat/src/test/java/android/app/DialogDefaultTouchTest.java
+++ b/maven/android-compat/src/test/java/android/app/DialogDefaultTouchTest.java
@@ -22,7 +22,7 @@
  */
 package android.app;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/app/FragmentLauncherRecreationTest.java b/maven/android-compat/src/test/java/android/app/FragmentLauncherRecreationTest.java
index 9d707687c4e..7d4558d1d84 100644
--- a/maven/android-compat/src/test/java/android/app/FragmentLauncherRecreationTest.java
+++ b/maven/android-compat/src/test/java/android/app/FragmentLauncherRecreationTest.java
@@ -37,7 +37,7 @@
 import androidx.fragment.app.FragmentActivity;
 import androidx.fragment.app.FragmentFactory;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/app/FragmentManagerTest.java b/maven/android-compat/src/test/java/android/app/FragmentManagerTest.java
index 41e5060bdfe..05fa932117d 100644
--- a/maven/android-compat/src/test/java/android/app/FragmentManagerTest.java
+++ b/maven/android-compat/src/test/java/android/app/FragmentManagerTest.java
@@ -29,7 +29,7 @@
 
 import com.codename1.androidcompat.runtime.MenuImpl;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/app/FragmentViewStateTest.java b/maven/android-compat/src/test/java/android/app/FragmentViewStateTest.java
index cec65c164d1..cfde8aa55eb 100644
--- a/maven/android-compat/src/test/java/android/app/FragmentViewStateTest.java
+++ b/maven/android-compat/src/test/java/android/app/FragmentViewStateTest.java
@@ -31,7 +31,7 @@
 import android.widget.FrameLayout;
 import android.widget.LinearLayout;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/app/PauseSelfFinishTest.java b/maven/android-compat/src/test/java/android/app/PauseSelfFinishTest.java
index 8b5c196f2c2..a64f0f1fa13 100644
--- a/maven/android-compat/src/test/java/android/app/PauseSelfFinishTest.java
+++ b/maven/android-compat/src/test/java/android/app/PauseSelfFinishTest.java
@@ -24,7 +24,7 @@
 import android.content.Context;
 import android.content.Intent;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/app/ResultAfterRelaunchTest.java b/maven/android-compat/src/test/java/android/app/ResultAfterRelaunchTest.java
index 730248fea1e..24716ab6c38 100644
--- a/maven/android-compat/src/test/java/android/app/ResultAfterRelaunchTest.java
+++ b/maven/android-compat/src/test/java/android/app/ResultAfterRelaunchTest.java
@@ -27,7 +27,7 @@
 
 import com.codename1.androidcompat.runtime.ResourceManager;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.HeadlessImplementation;
 import com.codename1.ui.Display;
 
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/app/ResumeConfigurationTest.java b/maven/android-compat/src/test/java/android/app/ResumeConfigurationTest.java
index 5cdae4a9955..2b71d4c582f 100644
--- a/maven/android-compat/src/test/java/android/app/ResumeConfigurationTest.java
+++ b/maven/android-compat/src/test/java/android/app/ResumeConfigurationTest.java
@@ -26,7 +26,7 @@
 import android.content.Intent;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.HeadlessImplementation;
 import com.codename1.ui.Display;
 
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/app/SupportFragmentsTest.java b/maven/android-compat/src/test/java/android/app/SupportFragmentsTest.java
index e19bd8f29ab..823bbbba545 100644
--- a/maven/android-compat/src/test/java/android/app/SupportFragmentsTest.java
+++ b/maven/android-compat/src/test/java/android/app/SupportFragmentsTest.java
@@ -36,7 +36,7 @@
 import androidx.lifecycle.ViewModel;
 import androidx.lifecycle.ViewModelProvider;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/app/WindowKeepScreenOnTest.java b/maven/android-compat/src/test/java/android/app/WindowKeepScreenOnTest.java
index b46827ee87e..ee29af997b6 100644
--- a/maven/android-compat/src/test/java/android/app/WindowKeepScreenOnTest.java
+++ b/maven/android-compat/src/test/java/android/app/WindowKeepScreenOnTest.java
@@ -25,8 +25,8 @@
 import android.content.Intent;
 import android.view.WindowManager;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/content/BroadcastFilterMatchTest.java b/maven/android-compat/src/test/java/android/content/BroadcastFilterMatchTest.java
index 956640fd142..2722df75f35 100644
--- a/maven/android-compat/src/test/java/android/content/BroadcastFilterMatchTest.java
+++ b/maven/android-compat/src/test/java/android/content/BroadcastFilterMatchTest.java
@@ -26,7 +26,7 @@
 import android.os.Bundle;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/content/ContentResolverFileUriTest.java b/maven/android-compat/src/test/java/android/content/ContentResolverFileUriTest.java
index a163eb2bf10..7d3f6ecb72b 100644
--- a/maven/android-compat/src/test/java/android/content/ContentResolverFileUriTest.java
+++ b/maven/android-compat/src/test/java/android/content/ContentResolverFileUriTest.java
@@ -25,8 +25,8 @@
 import android.net.Uri;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/content/ContentValuesTest.java b/maven/android-compat/src/test/java/android/content/ContentValuesTest.java
index 333ccdec458..0b788b61023 100644
--- a/maven/android-compat/src/test/java/android/content/ContentValuesTest.java
+++ b/maven/android-compat/src/test/java/android/content/ContentValuesTest.java
@@ -31,7 +31,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/content/ContextFileNameTest.java b/maven/android-compat/src/test/java/android/content/ContextFileNameTest.java
index edec7b76d71..1e0ab7cc6d6 100644
--- a/maven/android-compat/src/test/java/android/content/ContextFileNameTest.java
+++ b/maven/android-compat/src/test/java/android/content/ContextFileNameTest.java
@@ -23,7 +23,7 @@
 package android.content;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/content/IntentCloneFilterTest.java b/maven/android-compat/src/test/java/android/content/IntentCloneFilterTest.java
index b1575de4746..95f2e4b0e23 100644
--- a/maven/android-compat/src/test/java/android/content/IntentCloneFilterTest.java
+++ b/maven/android-compat/src/test/java/android/content/IntentCloneFilterTest.java
@@ -22,7 +22,7 @@
  */
 package android.content;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/content/IntentResolveActivityTest.java b/maven/android-compat/src/test/java/android/content/IntentResolveActivityTest.java
index a42c0b56bd9..1d1c2a4c721 100644
--- a/maven/android-compat/src/test/java/android/content/IntentResolveActivityTest.java
+++ b/maven/android-compat/src/test/java/android/content/IntentResolveActivityTest.java
@@ -26,7 +26,7 @@
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/database/CursorsTest.java b/maven/android-compat/src/test/java/android/database/CursorsTest.java
index 5447872cd79..fcdd9c0ee36 100644
--- a/maven/android-compat/src/test/java/android/database/CursorsTest.java
+++ b/maven/android-compat/src/test/java/android/database/CursorsTest.java
@@ -30,7 +30,7 @@
 
 import java.util.Arrays;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/database/sqlite/SQLiteDatabaseTest.java b/maven/android-compat/src/test/java/android/database/sqlite/SQLiteDatabaseTest.java
index 986eb66130c..7ece2c8fefb 100644
--- a/maven/android-compat/src/test/java/android/database/sqlite/SQLiteDatabaseTest.java
+++ b/maven/android-compat/src/test/java/android/database/sqlite/SQLiteDatabaseTest.java
@@ -39,7 +39,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/database/sqlite/SQLiteQueryBuilderTest.java b/maven/android-compat/src/test/java/android/database/sqlite/SQLiteQueryBuilderTest.java
index ee8cc23eae4..15a2d099ba1 100644
--- a/maven/android-compat/src/test/java/android/database/sqlite/SQLiteQueryBuilderTest.java
+++ b/maven/android-compat/src/test/java/android/database/sqlite/SQLiteQueryBuilderTest.java
@@ -28,7 +28,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapCompressFormatTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapCompressFormatTest.java
index 68e955fd7a7..aeba30331f0 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapCompressFormatTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapCompressFormatTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 import com.codename1.ui.util.ImageIO;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapDerivedDensityTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapDerivedDensityTest.java
index c220192f44d..7cf76dafcdf 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapDerivedDensityTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapDerivedDensityTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.After;
 import org.junit.Before;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapDisplayMetricsDensityTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapDisplayMetricsDensityTest.java
index 6d8fe12ff37..3cf77a10665 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapDisplayMetricsDensityTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapDisplayMetricsDensityTest.java
@@ -25,7 +25,7 @@
 import android.util.DisplayMetrics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryBoundsTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryBoundsTest.java
index 052df841c43..1b2c1af4307 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryBoundsTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryBoundsTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.After;
 import org.junit.Before;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryHeaderBoundsTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryHeaderBoundsTest.java
index eead128d5cf..eeea2455638 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryHeaderBoundsTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryHeaderBoundsTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.After;
 import org.junit.Before;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryMimeTypeTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryMimeTypeTest.java
index f500b92cc79..c8f19cbaa02 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryMimeTypeTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryMimeTypeTest.java
@@ -23,7 +23,7 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryUnscaledDensityTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryUnscaledDensityTest.java
index d8d830e2971..e13ec64adb6 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapFactoryUnscaledDensityTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapFactoryUnscaledDensityTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.After;
 import org.junit.Before;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapImmutableWriteTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapImmutableWriteTest.java
index 7d14e71f210..824f8f3fb60 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapImmutableWriteTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapImmutableWriteTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.After;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapMatrixTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapMatrixTest.java
index 2ef074d80b9..78483b0e4fa 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapMatrixTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapMatrixTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.After;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapMutableSnapshotTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapMutableSnapshotTest.java
index b9bb3828141..65640cd7c29 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapMutableSnapshotTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapMutableSnapshotTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.After;
diff --git a/maven/android-compat/src/test/java/android/graphics/BitmapPixelBoundsTest.java b/maven/android-compat/src/test/java/android/graphics/BitmapPixelBoundsTest.java
index eea0ac80ae6..f260fab4ece 100644
--- a/maven/android-compat/src/test/java/android/graphics/BitmapPixelBoundsTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/BitmapPixelBoundsTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.After;
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasBitmapPixelCacheTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasBitmapPixelCacheTest.java
index 75f6c6c614b..33f65fa6546 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasBitmapPixelCacheTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasBitmapPixelCacheTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.After;
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasClipPathTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasClipPathTest.java
index 3627afe5504..473ae646703 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasClipPathTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasClipPathTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 import com.codename1.ui.geom.Rectangle;
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasClipRestoreAndClearTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasClipRestoreAndClearTest.java
index 120b15654dd..9dff20fc1af 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasClipRestoreAndClearTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasClipRestoreAndClearTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasDrawPaintShaderTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasDrawPaintShaderTest.java
index 83a14a4809b..b9ac446b9cb 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasDrawPaintShaderTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasDrawPaintShaderTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasImmutableBitmapTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasImmutableBitmapTest.java
index 14303275337..201587bca27 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasImmutableBitmapTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasImmutableBitmapTest.java
@@ -23,7 +23,7 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasRecycledBitmapTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasRecycledBitmapTest.java
index 713eede7a93..2433e520485 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasRecycledBitmapTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasRecycledBitmapTest.java
@@ -23,7 +23,7 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasRotatedClipRectTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasRotatedClipRectTest.java
index fa774c77ba1..d3b1f76008a 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasRotatedClipRectTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasRotatedClipRectTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasSaveLayerTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasSaveLayerTest.java
index fec47a1c2b7..e46b658b8bc 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasSaveLayerTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasSaveLayerTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasSpacedSurrogateTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasSpacedSurrogateTest.java
index b089d7f646e..fea418263a0 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasSpacedSurrogateTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasSpacedSurrogateTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/CanvasTextScaleXTest.java b/maven/android-compat/src/test/java/android/graphics/CanvasTextScaleXTest.java
index fbca64f1e07..5e8b13e33ed 100644
--- a/maven/android-compat/src/test/java/android/graphics/CanvasTextScaleXTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/CanvasTextScaleXTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Graphics;
 import com.codename1.ui.Image;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/LetterSpacingMeasureTest.java b/maven/android-compat/src/test/java/android/graphics/LetterSpacingMeasureTest.java
index 30fef53d5f2..5d2aea4a718 100644
--- a/maven/android-compat/src/test/java/android/graphics/LetterSpacingMeasureTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/LetterSpacingMeasureTest.java
@@ -23,8 +23,8 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/graphics/LetterSpacingWidthsTest.java b/maven/android-compat/src/test/java/android/graphics/LetterSpacingWidthsTest.java
index 59c8c9b8594..8cf87a0486e 100644
--- a/maven/android-compat/src/test/java/android/graphics/LetterSpacingWidthsTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/LetterSpacingWidthsTest.java
@@ -23,7 +23,7 @@
 package android.graphics;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTargetDensityTest.java b/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTargetDensityTest.java
index 38b8affe473..ef3673a0520 100644
--- a/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTargetDensityTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTargetDensityTest.java
@@ -26,8 +26,8 @@
 import android.graphics.Bitmap;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTileModeTest.java b/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTileModeTest.java
index c9bd951fdd4..d93ec2d7a3a 100644
--- a/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTileModeTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/drawable/BitmapDrawableTileModeTest.java
@@ -30,8 +30,8 @@
 import android.graphics.Shader;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import java.util.ArrayList;
diff --git a/maven/android-compat/src/test/java/android/graphics/drawable/GradientDrawableOrientationTest.java b/maven/android-compat/src/test/java/android/graphics/drawable/GradientDrawableOrientationTest.java
index d8316b803e1..2fa89708efd 100644
--- a/maven/android-compat/src/test/java/android/graphics/drawable/GradientDrawableOrientationTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/drawable/GradientDrawableOrientationTest.java
@@ -25,8 +25,8 @@
 import android.graphics.Canvas;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 import com.codename1.ui.LinearGradient;
 
diff --git a/maven/android-compat/src/test/java/android/graphics/drawable/StateListTintModeTest.java b/maven/android-compat/src/test/java/android/graphics/drawable/StateListTintModeTest.java
index d3537db90f5..9581c195278 100644
--- a/maven/android-compat/src/test/java/android/graphics/drawable/StateListTintModeTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/drawable/StateListTintModeTest.java
@@ -26,7 +26,7 @@
 import android.graphics.PorterDuff;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/graphics/drawable/WrapperChildStateTest.java b/maven/android-compat/src/test/java/android/graphics/drawable/WrapperChildStateTest.java
index ff0b99b893d..09e47c251ca 100644
--- a/maven/android-compat/src/test/java/android/graphics/drawable/WrapperChildStateTest.java
+++ b/maven/android-compat/src/test/java/android/graphics/drawable/WrapperChildStateTest.java
@@ -29,7 +29,7 @@
 import android.graphics.Rect;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.Before;
diff --git a/maven/android-compat/src/test/java/android/net/UriFromFileTest.java b/maven/android-compat/src/test/java/android/net/UriFromFileTest.java
index 5007efeab78..8174d42b76b 100644
--- a/maven/android-compat/src/test/java/android/net/UriFromFileTest.java
+++ b/maven/android-compat/src/test/java/android/net/UriFromFileTest.java
@@ -22,8 +22,7 @@
  */
 package android.net;
 
-import com.codename1.androidcompat.jdk.File;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
@@ -32,21 +31,35 @@
 
 /// A context directory is already a `file:` path; `fromFile` prefixed a
 /// second scheme to it (`file://file:///...`).
+///
+/// A device's `java.io.File` keeps the storage path it was made from, which
+/// the JDK's running these tests would rewrite (`file:///a` becomes
+/// `file:/a`), so the files here are stand-ins that print their path as the
+/// device's does: `fromFile` reads nothing of a file but that.
 public class UriFromFileTest {
 
+    private static Object file(final String path) {
+        return new Object() {
+            @Override
+            public String toString() {
+                return path;
+            }
+        };
+    }
+
     @Rule
     public final MainThreadRule mainThread = new MainThreadRule();
 
     @Test
     public void keepsAnExistingFileScheme() {
-        Uri u = Uri.fromFile(new File("file:///data/files/report.pdf"));
+        Uri u = Uri.fromFile(file("file:///data/files/report.pdf"));
         assertEquals("file:///data/files/report.pdf", u.toString());
         assertEquals("/data/files/report.pdf", u.getPath());
     }
 
     @Test
     public void anAbsolutePathGainsTheScheme() {
-        assertEquals("file:///data/report.pdf", Uri.fromFile(new File("/data/report.pdf")).toString());
+        assertEquals("file:///data/report.pdf", Uri.fromFile(file("/data/report.pdf")).toString());
     }
 
     /// Reserved characters in a file name are percent-encoded, so the whole
@@ -54,12 +67,12 @@ public void anAbsolutePathGainsTheScheme() {
     /// `getPath()` answered `/data/a`.
     @Test
     public void encodesReservedCharactersInThePath() {
-        Uri u = Uri.fromFile(new File("/data/a#b?c d.txt"));
+        Uri u = Uri.fromFile(file("/data/a#b?c d.txt"));
         assertEquals("file:///data/a%23b%3Fc%20d.txt", u.toString());
         assertEquals("/data/a#b?c d.txt", u.getPath());
         assertEquals(null, u.getFragment());
 
-        Uri home = Uri.fromFile(new File("file://home/x#1.txt"));
+        Uri home = Uri.fromFile(file("file://home/x#1.txt"));
         assertEquals("file://home/x%231.txt", home.toString());
         assertEquals("home", home.getAuthority());
         assertEquals("/x#1.txt", home.getPath());
diff --git a/maven/android-compat/src/test/java/android/net/UriNormalizeSchemeTest.java b/maven/android-compat/src/test/java/android/net/UriNormalizeSchemeTest.java
index b6144d8b5f2..bb8225464bf 100644
--- a/maven/android-compat/src/test/java/android/net/UriNormalizeSchemeTest.java
+++ b/maven/android-compat/src/test/java/android/net/UriNormalizeSchemeTest.java
@@ -22,7 +22,7 @@
  */
 package android.net;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/os/BundleDeepCopyTest.java b/maven/android-compat/src/test/java/android/os/BundleDeepCopyTest.java
index 77a29ef9d69..aa334c90126 100644
--- a/maven/android-compat/src/test/java/android/os/BundleDeepCopyTest.java
+++ b/maven/android-compat/src/test/java/android/os/BundleDeepCopyTest.java
@@ -24,7 +24,7 @@
 
 import android.util.SparseArray;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import java.util.ArrayList;
 
diff --git a/maven/android-compat/src/test/java/android/os/BundleEmptyImmutableTest.java b/maven/android-compat/src/test/java/android/os/BundleEmptyImmutableTest.java
index 74f80640063..3fe553ed892 100644
--- a/maven/android-compat/src/test/java/android/os/BundleEmptyImmutableTest.java
+++ b/maven/android-compat/src/test/java/android/os/BundleEmptyImmutableTest.java
@@ -22,7 +22,7 @@
  */
 package android.os;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/os/HandlerFrontOfQueueTest.java b/maven/android-compat/src/test/java/android/os/HandlerFrontOfQueueTest.java
index b3c06ca1ad3..5829b007fe1 100644
--- a/maven/android-compat/src/test/java/android/os/HandlerFrontOfQueueTest.java
+++ b/maven/android-compat/src/test/java/android/os/HandlerFrontOfQueueTest.java
@@ -23,7 +23,7 @@
 package android.os;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/text/AllCapsSpansTest.java b/maven/android-compat/src/test/java/android/text/AllCapsSpansTest.java
index 4940fb4d5a2..4258445935d 100644
--- a/maven/android-compat/src/test/java/android/text/AllCapsSpansTest.java
+++ b/maven/android-compat/src/test/java/android/text/AllCapsSpansTest.java
@@ -22,7 +22,7 @@
  */
 package android.text;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/text/LengthFilterSurrogateTest.java b/maven/android-compat/src/test/java/android/text/LengthFilterSurrogateTest.java
index 4ddfa134989..99b4d08ceef 100644
--- a/maven/android-compat/src/test/java/android/text/LengthFilterSurrogateTest.java
+++ b/maven/android-compat/src/test/java/android/text/LengthFilterSurrogateTest.java
@@ -22,7 +22,7 @@
  */
 package android.text;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/text/TextUtilsCommaEllipsizeTest.java b/maven/android-compat/src/test/java/android/text/TextUtilsCommaEllipsizeTest.java
index 3262ee9d567..11a2423106b 100644
--- a/maven/android-compat/src/test/java/android/text/TextUtilsCommaEllipsizeTest.java
+++ b/maven/android-compat/src/test/java/android/text/TextUtilsCommaEllipsizeTest.java
@@ -23,7 +23,7 @@
 package android.text;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/text/TextUtilsEllipsizeSpansTest.java b/maven/android-compat/src/test/java/android/text/TextUtilsEllipsizeSpansTest.java
index c1725b37a0d..641a7dc43df 100644
--- a/maven/android-compat/src/test/java/android/text/TextUtilsEllipsizeSpansTest.java
+++ b/maven/android-compat/src/test/java/android/text/TextUtilsEllipsizeSpansTest.java
@@ -23,7 +23,7 @@
 package android.text;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/text/TextUtilsSplitRegexTest.java b/maven/android-compat/src/test/java/android/text/TextUtilsSplitRegexTest.java
index 93bec284971..c7ed5d3f22b 100644
--- a/maven/android-compat/src/test/java/android/text/TextUtilsSplitRegexTest.java
+++ b/maven/android-compat/src/test/java/android/text/TextUtilsSplitRegexTest.java
@@ -22,7 +22,7 @@
  */
 package android.text;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import java.util.Arrays;
 
diff --git a/maven/android-compat/src/test/java/android/view/AncestorChangeDispatchTest.java b/maven/android-compat/src/test/java/android/view/AncestorChangeDispatchTest.java
index 9cc1fd29164..613b1b9c997 100644
--- a/maven/android-compat/src/test/java/android/view/AncestorChangeDispatchTest.java
+++ b/maven/android-compat/src/test/java/android/view/AncestorChangeDispatchTest.java
@@ -25,7 +25,7 @@
 import android.widget.FrameLayout;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/BackgroundTintModeTest.java b/maven/android-compat/src/test/java/android/view/BackgroundTintModeTest.java
index edda59e4650..c946dd02a5a 100644
--- a/maven/android-compat/src/test/java/android/view/BackgroundTintModeTest.java
+++ b/maven/android-compat/src/test/java/android/view/BackgroundTintModeTest.java
@@ -27,7 +27,7 @@
 import android.graphics.drawable.ColorDrawable;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/DrawableLayoutDirectionTest.java b/maven/android-compat/src/test/java/android/view/DrawableLayoutDirectionTest.java
index e0014988756..0794ff31bcf 100644
--- a/maven/android-compat/src/test/java/android/view/DrawableLayoutDirectionTest.java
+++ b/maven/android-compat/src/test/java/android/view/DrawableLayoutDirectionTest.java
@@ -26,7 +26,7 @@
 import android.widget.FrameLayout;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/HiddenViewLosesFocusTest.java b/maven/android-compat/src/test/java/android/view/HiddenViewLosesFocusTest.java
index 93e81aeb78d..448047cc662 100644
--- a/maven/android-compat/src/test/java/android/view/HiddenViewLosesFocusTest.java
+++ b/maven/android-compat/src/test/java/android/view/HiddenViewLosesFocusTest.java
@@ -25,7 +25,7 @@
 import android.widget.FrameLayout;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/IncludeThemeTest.java b/maven/android-compat/src/test/java/android/view/IncludeThemeTest.java
index 9e333583934..52c5903b242 100644
--- a/maven/android-compat/src/test/java/android/view/IncludeThemeTest.java
+++ b/maven/android-compat/src/test/java/android/view/IncludeThemeTest.java
@@ -27,7 +27,7 @@
 import com.codename1.androidcompat.runtime.ResValue;
 import com.codename1.androidcompat.runtime.XmlNode;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/MergedIncludeFinishInflateTest.java b/maven/android-compat/src/test/java/android/view/MergedIncludeFinishInflateTest.java
index 20aff7b491f..9deba5b9f49 100644
--- a/maven/android-compat/src/test/java/android/view/MergedIncludeFinishInflateTest.java
+++ b/maven/android-compat/src/test/java/android/view/MergedIncludeFinishInflateTest.java
@@ -31,7 +31,7 @@
 import com.codename1.androidcompat.runtime.ResValue;
 import com.codename1.androidcompat.runtime.XmlNode;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/RemovedTouchTargetTest.java b/maven/android-compat/src/test/java/android/view/RemovedTouchTargetTest.java
index b8bfc05e767..0f3fbb09c40 100644
--- a/maven/android-compat/src/test/java/android/view/RemovedTouchTargetTest.java
+++ b/maven/android-compat/src/test/java/android/view/RemovedTouchTargetTest.java
@@ -26,7 +26,7 @@
 import android.widget.FrameLayout;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/maven/android-compat/src/test/java/android/view/TransformedChildTouchTest.java b/maven/android-compat/src/test/java/android/view/TransformedChildTouchTest.java
index c2276483cf5..f402a2acab4 100644
--- a/maven/android-compat/src/test/java/android/view/TransformedChildTouchTest.java
+++ b/maven/android-compat/src/test/java/android/view/TransformedChildTouchTest.java
@@ -26,7 +26,7 @@
 import android.widget.FrameLayout;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/ViewCallbacksTest.java b/maven/android-compat/src/test/java/android/view/ViewCallbacksTest.java
index 5cb6d4948db..1c0b9f6b0c2 100644
--- a/maven/android-compat/src/test/java/android/view/ViewCallbacksTest.java
+++ b/maven/android-compat/src/test/java/android/view/ViewCallbacksTest.java
@@ -33,7 +33,7 @@
 import com.codename1.androidcompat.runtime.ResValue;
 import com.codename1.androidcompat.runtime.XmlNode;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/view/ViewStubReferenceTest.java b/maven/android-compat/src/test/java/android/view/ViewStubReferenceTest.java
index 3f66e8167bd..dfbc02b1011 100644
--- a/maven/android-compat/src/test/java/android/view/ViewStubReferenceTest.java
+++ b/maven/android-compat/src/test/java/android/view/ViewStubReferenceTest.java
@@ -24,7 +24,7 @@
 import android.content.Context;
 import android.widget.FrameLayout;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/view/ViewTreeScrollTest.java b/maven/android-compat/src/test/java/android/view/ViewTreeScrollTest.java
index b505ee3f95f..32016b44d53 100644
--- a/maven/android-compat/src/test/java/android/view/ViewTreeScrollTest.java
+++ b/maven/android-compat/src/test/java/android/view/ViewTreeScrollTest.java
@@ -24,7 +24,7 @@
 
 import android.widget.FrameLayout;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/view/VisibleRectAndKeepScreenOnTest.java b/maven/android-compat/src/test/java/android/view/VisibleRectAndKeepScreenOnTest.java
index 71a2b8c5402..96c78ce69be 100644
--- a/maven/android-compat/src/test/java/android/view/VisibleRectAndKeepScreenOnTest.java
+++ b/maven/android-compat/src/test/java/android/view/VisibleRectAndKeepScreenOnTest.java
@@ -26,8 +26,8 @@
 import android.widget.FrameLayout;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/view/animation/AnimationCloneTest.java b/maven/android-compat/src/test/java/android/view/animation/AnimationCloneTest.java
index d79f0b3d46e..0d5eae6a73a 100644
--- a/maven/android-compat/src/test/java/android/view/animation/AnimationCloneTest.java
+++ b/maven/android-compat/src/test/java/android/view/animation/AnimationCloneTest.java
@@ -31,7 +31,7 @@
 import android.animation.TimeAnimator;
 import android.animation.ValueAnimator;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/view/animation/AnimationTimingTest.java b/maven/android-compat/src/test/java/android/view/animation/AnimationTimingTest.java
index a0ddab1878e..cb9287d85bb 100644
--- a/maven/android-compat/src/test/java/android/view/animation/AnimationTimingTest.java
+++ b/maven/android-compat/src/test/java/android/view/animation/AnimationTimingTest.java
@@ -28,7 +28,7 @@
 
 import android.graphics.Matrix;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/webkit/WebViewHistoryDistanceTest.java b/maven/android-compat/src/test/java/android/webkit/WebViewHistoryDistanceTest.java
index 8a18d872564..044c8da936a 100644
--- a/maven/android-compat/src/test/java/android/webkit/WebViewHistoryDistanceTest.java
+++ b/maven/android-compat/src/test/java/android/webkit/WebViewHistoryDistanceTest.java
@@ -25,7 +25,7 @@
 import android.content.Context;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/webkit/WebViewHistoryUrlTest.java b/maven/android-compat/src/test/java/android/webkit/WebViewHistoryUrlTest.java
index 64bd42d6839..8744080d191 100644
--- a/maven/android-compat/src/test/java/android/webkit/WebViewHistoryUrlTest.java
+++ b/maven/android-compat/src/test/java/android/webkit/WebViewHistoryUrlTest.java
@@ -23,7 +23,7 @@
 package android.webkit;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.BrowserComponent;
 import com.codename1.ui.events.ActionEvent;
 
diff --git a/maven/android-compat/src/test/java/android/widget/AbsListViewSelectionAndStackTest.java b/maven/android-compat/src/test/java/android/widget/AbsListViewSelectionAndStackTest.java
index 83110ec9734..eec691d1790 100644
--- a/maven/android-compat/src/test/java/android/widget/AbsListViewSelectionAndStackTest.java
+++ b/maven/android-compat/src/test/java/android/widget/AbsListViewSelectionAndStackTest.java
@@ -27,7 +27,7 @@
 import android.view.View;
 import android.view.ViewGroup;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import java.lang.reflect.Field;
diff --git a/maven/android-compat/src/test/java/android/widget/DatePickerRangeClampNotifiesTest.java b/maven/android-compat/src/test/java/android/widget/DatePickerRangeClampNotifiesTest.java
index 2cf1e43e3c8..b6cf77f6feb 100644
--- a/maven/android-compat/src/test/java/android/widget/DatePickerRangeClampNotifiesTest.java
+++ b/maven/android-compat/src/test/java/android/widget/DatePickerRangeClampNotifiesTest.java
@@ -23,7 +23,7 @@
 package android.widget;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/DatePickerSavedStateTest.java b/maven/android-compat/src/test/java/android/widget/DatePickerSavedStateTest.java
index 003f32de146..dfe338d87cb 100644
--- a/maven/android-compat/src/test/java/android/widget/DatePickerSavedStateTest.java
+++ b/maven/android-compat/src/test/java/android/widget/DatePickerSavedStateTest.java
@@ -24,7 +24,7 @@
 import android.os.Parcelable;
 import android.util.SparseArray;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/widget/EditTextEditableWatcherTest.java b/maven/android-compat/src/test/java/android/widget/EditTextEditableWatcherTest.java
index c7b6ca6a6da..38a884aaabc 100644
--- a/maven/android-compat/src/test/java/android/widget/EditTextEditableWatcherTest.java
+++ b/maven/android-compat/src/test/java/android/widget/EditTextEditableWatcherTest.java
@@ -26,7 +26,7 @@
 import android.text.TextWatcher;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/widget/EditTextSelectionTest.java b/maven/android-compat/src/test/java/android/widget/EditTextSelectionTest.java
index 8a8109aab77..ed0f131fb11 100644
--- a/maven/android-compat/src/test/java/android/widget/EditTextSelectionTest.java
+++ b/maven/android-compat/src/test/java/android/widget/EditTextSelectionTest.java
@@ -23,7 +23,7 @@
 package android.widget;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ForegroundGravityTest.java b/maven/android-compat/src/test/java/android/widget/ForegroundGravityTest.java
index d00dfccaffe..68abba59b85 100644
--- a/maven/android-compat/src/test/java/android/widget/ForegroundGravityTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ForegroundGravityTest.java
@@ -27,7 +27,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/FormWidgetSavedStateTest.java b/maven/android-compat/src/test/java/android/widget/FormWidgetSavedStateTest.java
index fbd0e3c8d21..4bfc88abf87 100644
--- a/maven/android-compat/src/test/java/android/widget/FormWidgetSavedStateTest.java
+++ b/maven/android-compat/src/test/java/android/widget/FormWidgetSavedStateTest.java
@@ -25,7 +25,7 @@
 import android.util.SparseArray;
 import android.view.View;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/widget/GridViewUniformSpacingTest.java b/maven/android-compat/src/test/java/android/widget/GridViewUniformSpacingTest.java
index 938fd356c4d..c51dd74c112 100644
--- a/maven/android-compat/src/test/java/android/widget/GridViewUniformSpacingTest.java
+++ b/maven/android-compat/src/test/java/android/widget/GridViewUniformSpacingTest.java
@@ -25,7 +25,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ImageViewClearColorModTest.java b/maven/android-compat/src/test/java/android/widget/ImageViewClearColorModTest.java
index f6372455b8b..9c4abb319f6 100644
--- a/maven/android-compat/src/test/java/android/widget/ImageViewClearColorModTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ImageViewClearColorModTest.java
@@ -31,7 +31,7 @@
 import android.graphics.drawable.Drawable;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/widget/ImageViewMeasureInputsRelayoutTest.java b/maven/android-compat/src/test/java/android/widget/ImageViewMeasureInputsRelayoutTest.java
index 1cafce39123..eafdf7f49c3 100644
--- a/maven/android-compat/src/test/java/android/widget/ImageViewMeasureInputsRelayoutTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ImageViewMeasureInputsRelayoutTest.java
@@ -25,7 +25,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/widget/LinearLayoutDividersTest.java b/maven/android-compat/src/test/java/android/widget/LinearLayoutDividersTest.java
index 72071b046e4..73a3237cc24 100644
--- a/maven/android-compat/src/test/java/android/widget/LinearLayoutDividersTest.java
+++ b/maven/android-compat/src/test/java/android/widget/LinearLayoutDividersTest.java
@@ -26,7 +26,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ListCheckedRowsAfterDataChangeTest.java b/maven/android-compat/src/test/java/android/widget/ListCheckedRowsAfterDataChangeTest.java
index 4997b0eb282..b756c613ea5 100644
--- a/maven/android-compat/src/test/java/android/widget/ListCheckedRowsAfterDataChangeTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ListCheckedRowsAfterDataChangeTest.java
@@ -26,7 +26,7 @@
 import android.view.ViewGroup;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ListViewDragOffClickTest.java b/maven/android-compat/src/test/java/android/widget/ListViewDragOffClickTest.java
index b1186cfce76..733f3e52a25 100644
--- a/maven/android-compat/src/test/java/android/widget/ListViewDragOffClickTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ListViewDragOffClickTest.java
@@ -27,7 +27,7 @@
 import android.view.ViewGroup;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ProgressBarIndeterminateDrawableTest.java b/maven/android-compat/src/test/java/android/widget/ProgressBarIndeterminateDrawableTest.java
index 381bcb0c029..611b6db643c 100644
--- a/maven/android-compat/src/test/java/android/widget/ProgressBarIndeterminateDrawableTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ProgressBarIndeterminateDrawableTest.java
@@ -29,7 +29,7 @@
 import android.graphics.drawable.Drawable;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.Image;
 
 import org.junit.Before;
diff --git a/maven/android-compat/src/test/java/android/widget/ProgressBarRangeClampTest.java b/maven/android-compat/src/test/java/android/widget/ProgressBarRangeClampTest.java
index fc6d8fad659..c4b2bce89e8 100644
--- a/maven/android-compat/src/test/java/android/widget/ProgressBarRangeClampTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ProgressBarRangeClampTest.java
@@ -23,7 +23,7 @@
 package android.widget;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ProgressDrawableOwnershipTest.java b/maven/android-compat/src/test/java/android/widget/ProgressDrawableOwnershipTest.java
index edd4aebd750..01f108c3ed5 100644
--- a/maven/android-compat/src/test/java/android/widget/ProgressDrawableOwnershipTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ProgressDrawableOwnershipTest.java
@@ -25,7 +25,7 @@
 import android.util.SparseArray;
 import android.view.View;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/widget/RadioGroupAndFilteredAdapterTest.java b/maven/android-compat/src/test/java/android/widget/RadioGroupAndFilteredAdapterTest.java
index 03291c5189a..5239c64a603 100644
--- a/maven/android-compat/src/test/java/android/widget/RadioGroupAndFilteredAdapterTest.java
+++ b/maven/android-compat/src/test/java/android/widget/RadioGroupAndFilteredAdapterTest.java
@@ -26,7 +26,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/RowStateNotSavedTest.java b/maven/android-compat/src/test/java/android/widget/RowStateNotSavedTest.java
index 9cfaeaae8aa..9daf60f95da 100644
--- a/maven/android-compat/src/test/java/android/widget/RowStateNotSavedTest.java
+++ b/maven/android-compat/src/test/java/android/widget/RowStateNotSavedTest.java
@@ -28,7 +28,7 @@
 import android.view.ViewGroup;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ScrollViewChildMarginsTest.java b/maven/android-compat/src/test/java/android/widget/ScrollViewChildMarginsTest.java
index e9dcc07e29a..d1fb853fdf7 100644
--- a/maven/android-compat/src/test/java/android/widget/ScrollViewChildMarginsTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ScrollViewChildMarginsTest.java
@@ -25,7 +25,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/SeekBarInScrollingContainerTest.java b/maven/android-compat/src/test/java/android/widget/SeekBarInScrollingContainerTest.java
index 2872b0e92ee..c15394abe5e 100644
--- a/maven/android-compat/src/test/java/android/widget/SeekBarInScrollingContainerTest.java
+++ b/maven/android-compat/src/test/java/android/widget/SeekBarInScrollingContainerTest.java
@@ -27,7 +27,7 @@
 import android.view.ViewGroup;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/SimpleAdapterBindingHooksTest.java b/maven/android-compat/src/test/java/android/widget/SimpleAdapterBindingHooksTest.java
index 8fb88ecd390..a3d5c4f06df 100644
--- a/maven/android-compat/src/test/java/android/widget/SimpleAdapterBindingHooksTest.java
+++ b/maven/android-compat/src/test/java/android/widget/SimpleAdapterBindingHooksTest.java
@@ -26,7 +26,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/SimpleAdapterFilterTest.java b/maven/android-compat/src/test/java/android/widget/SimpleAdapterFilterTest.java
index 607ff60ac7d..b39b3438dbc 100644
--- a/maven/android-compat/src/test/java/android/widget/SimpleAdapterFilterTest.java
+++ b/maven/android-compat/src/test/java/android/widget/SimpleAdapterFilterTest.java
@@ -23,7 +23,7 @@
 package android.widget;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.BeforeClass;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/widget/SpinnerSelectedRowIdTest.java b/maven/android-compat/src/test/java/android/widget/SpinnerSelectedRowIdTest.java
index d24b6cc0ff5..941328aea4e 100644
--- a/maven/android-compat/src/test/java/android/widget/SpinnerSelectedRowIdTest.java
+++ b/maven/android-compat/src/test/java/android/widget/SpinnerSelectedRowIdTest.java
@@ -26,7 +26,7 @@
 import android.view.ViewGroup;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewAppendSpansTest.java b/maven/android-compat/src/test/java/android/widget/TextViewAppendSpansTest.java
index 1a9d8f94cc0..bf142d9511c 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewAppendSpansTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewAppendSpansTest.java
@@ -24,7 +24,7 @@
 import android.text.SpannableString;
 import android.text.Spanned;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewDefaultAppearanceTest.java b/maven/android-compat/src/test/java/android/widget/TextViewDefaultAppearanceTest.java
index 1aabbd84ed6..54c1323080a 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewDefaultAppearanceTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewDefaultAppearanceTest.java
@@ -28,7 +28,7 @@
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewEllipsizeModeTest.java b/maven/android-compat/src/test/java/android/widget/TextViewEllipsizeModeTest.java
index c8a3e804664..28bb6628491 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewEllipsizeModeTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewEllipsizeModeTest.java
@@ -25,7 +25,7 @@
 import android.text.TextUtils;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewFilterAndWatcherTest.java b/maven/android-compat/src/test/java/android/widget/TextViewFilterAndWatcherTest.java
index a5b62cdd415..b5b4aedb07e 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewFilterAndWatcherTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewFilterAndWatcherTest.java
@@ -27,7 +27,7 @@
 import android.text.TextWatcher;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Before;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewNormalSnapshotTest.java b/maven/android-compat/src/test/java/android/widget/TextViewNormalSnapshotTest.java
index 2bc1c87ca39..41598d12959 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewNormalSnapshotTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewNormalSnapshotTest.java
@@ -28,7 +28,7 @@
 import android.text.style.ForegroundColorSpan;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewRelativeDrawablesTest.java b/maven/android-compat/src/test/java/android/widget/TextViewRelativeDrawablesTest.java
index 402c147a697..f25b2f2abb2 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewRelativeDrawablesTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewRelativeDrawablesTest.java
@@ -27,7 +27,7 @@
 import android.view.View;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewSpannableBufferTest.java b/maven/android-compat/src/test/java/android/widget/TextViewSpannableBufferTest.java
index 2fc10d10635..4baea4ced6a 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewSpannableBufferTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewSpannableBufferTest.java
@@ -27,7 +27,7 @@
 import android.text.style.ForegroundColorSpan;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/TextViewTransitionTest.java b/maven/android-compat/src/test/java/android/widget/TextViewTransitionTest.java
index 7c54e844bfa..63ba1cc2ba8 100644
--- a/maven/android-compat/src/test/java/android/widget/TextViewTransitionTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TextViewTransitionTest.java
@@ -25,7 +25,7 @@
 import android.graphics.drawable.ColorDrawable;
 import android.view.View;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/android/widget/TimePickerNullLegacyTimeTest.java b/maven/android-compat/src/test/java/android/widget/TimePickerNullLegacyTimeTest.java
index 1f77a6ba0ec..c701cd6e410 100644
--- a/maven/android-compat/src/test/java/android/widget/TimePickerNullLegacyTimeTest.java
+++ b/maven/android-compat/src/test/java/android/widget/TimePickerNullLegacyTimeTest.java
@@ -23,7 +23,7 @@
 package android.widget;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/android/widget/ViewAnimatorRemovalTest.java b/maven/android-compat/src/test/java/android/widget/ViewAnimatorRemovalTest.java
index c9af48d36c8..adec8146aa4 100644
--- a/maven/android-compat/src/test/java/android/widget/ViewAnimatorRemovalTest.java
+++ b/maven/android-compat/src/test/java/android/widget/ViewAnimatorRemovalTest.java
@@ -25,7 +25,7 @@
 import android.util.SparseArray;
 import android.view.View;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/androidx/activity/ComponentActivitySaveLifecycleTest.java b/maven/android-compat/src/test/java/androidx/activity/ComponentActivitySaveLifecycleTest.java
index 12c325a50ec..669ed1ebb72 100644
--- a/maven/android-compat/src/test/java/androidx/activity/ComponentActivitySaveLifecycleTest.java
+++ b/maven/android-compat/src/test/java/androidx/activity/ComponentActivitySaveLifecycleTest.java
@@ -26,7 +26,7 @@
 import androidx.lifecycle.Lifecycle;
 import androidx.lifecycle.LifecycleRegistry;
 import androidx.savedstate.SavedStateRegistry;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/androidx/activity/GalleryLauncherUnregisterTest.java b/maven/android-compat/src/test/java/androidx/activity/GalleryLauncherUnregisterTest.java
index bda78424041..e99fb353e08 100644
--- a/maven/android-compat/src/test/java/androidx/activity/GalleryLauncherUnregisterTest.java
+++ b/maven/android-compat/src/test/java/androidx/activity/GalleryLauncherUnregisterTest.java
@@ -31,8 +31,8 @@
 import androidx.activity.result.ActivityResultLauncher;
 import androidx.activity.result.contract.ActivityResultContracts;
 
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.ui.events.ActionEvent;
 import com.codename1.ui.events.ActionListener;
 
diff --git a/maven/android-compat/src/test/java/androidx/activity/GalleryResultAfterRecreateTest.java b/maven/android-compat/src/test/java/androidx/activity/GalleryResultAfterRecreateTest.java
index c69284c6e55..bbee6318884 100644
--- a/maven/android-compat/src/test/java/androidx/activity/GalleryResultAfterRecreateTest.java
+++ b/maven/android-compat/src/test/java/androidx/activity/GalleryResultAfterRecreateTest.java
@@ -32,7 +32,7 @@
 import android.content.Intent;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.HeadlessImplementation;
 import com.codename1.ui.Display;
 import com.codename1.ui.events.ActionEvent;
 import com.codename1.ui.events.ActionListener;
diff --git a/maven/android-compat/src/test/java/androidx/activity/OnBackPressedDispatcherTest.java b/maven/android-compat/src/test/java/androidx/activity/OnBackPressedDispatcherTest.java
index 0b38cce84a3..29902c060fd 100644
--- a/maven/android-compat/src/test/java/androidx/activity/OnBackPressedDispatcherTest.java
+++ b/maven/android-compat/src/test/java/androidx/activity/OnBackPressedDispatcherTest.java
@@ -29,7 +29,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/androidx/activity/SynchronousResultPostedTest.java b/maven/android-compat/src/test/java/androidx/activity/SynchronousResultPostedTest.java
index 7e7c3a566a0..0290750c1cb 100644
--- a/maven/android-compat/src/test/java/androidx/activity/SynchronousResultPostedTest.java
+++ b/maven/android-compat/src/test/java/androidx/activity/SynchronousResultPostedTest.java
@@ -34,7 +34,7 @@
 import androidx.activity.result.contract.ActivityResultContract;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.BeforeClass;
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/androidx/constraintlayout/widget/ConstraintLayoutTest.java b/maven/android-compat/src/test/java/androidx/constraintlayout/widget/ConstraintLayoutTest.java
index 88ad6e15c7a..cfce97e534f 100644
--- a/maven/android-compat/src/test/java/androidx/constraintlayout/widget/ConstraintLayoutTest.java
+++ b/maven/android-compat/src/test/java/androidx/constraintlayout/widget/ConstraintLayoutTest.java
@@ -29,7 +29,7 @@
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/androidx/lifecycle/LifecycleRegistryTest.java b/maven/android-compat/src/test/java/androidx/lifecycle/LifecycleRegistryTest.java
index 6a9ba8fddd5..899a7922145 100644
--- a/maven/android-compat/src/test/java/androidx/lifecycle/LifecycleRegistryTest.java
+++ b/maven/android-compat/src/test/java/androidx/lifecycle/LifecycleRegistryTest.java
@@ -27,7 +27,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/androidx/lifecycle/LiveDataTest.java b/maven/android-compat/src/test/java/androidx/lifecycle/LiveDataTest.java
index 42a1be26b3b..61dfb9b2c41 100644
--- a/maven/android-compat/src/test/java/androidx/lifecycle/LiveDataTest.java
+++ b/maven/android-compat/src/test/java/androidx/lifecycle/LiveDataTest.java
@@ -26,7 +26,7 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/androidx/lifecycle/MediatorReactivationTest.java b/maven/android-compat/src/test/java/androidx/lifecycle/MediatorReactivationTest.java
index af7572e5535..abed612750a 100644
--- a/maven/android-compat/src/test/java/androidx/lifecycle/MediatorReactivationTest.java
+++ b/maven/android-compat/src/test/java/androidx/lifecycle/MediatorReactivationTest.java
@@ -21,7 +21,7 @@
  * need additional information or have any questions.
  */
 package androidx.lifecycle;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import androidx.arch.core.util.Function;
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/androidx/recyclerview/widget/DiffUtilTest.java b/maven/android-compat/src/test/java/androidx/recyclerview/widget/DiffUtilTest.java
index 7ccb16d5321..bef48d00a33 100644
--- a/maven/android-compat/src/test/java/androidx/recyclerview/widget/DiffUtilTest.java
+++ b/maven/android-compat/src/test/java/androidx/recyclerview/widget/DiffUtilTest.java
@@ -25,7 +25,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/androidx/recyclerview/widget/GridRowSizeTest.java b/maven/android-compat/src/test/java/androidx/recyclerview/widget/GridRowSizeTest.java
index 4069effb9cc..ca8b5b26b2e 100644
--- a/maven/android-compat/src/test/java/androidx/recyclerview/widget/GridRowSizeTest.java
+++ b/maven/android-compat/src/test/java/androidx/recyclerview/widget/GridRowSizeTest.java
@@ -24,7 +24,7 @@
 import android.view.View;
 import android.view.ViewGroup;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedReaderMarkTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedReaderMarkTest.java
deleted file mode 100644
index 8dad31566a7..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedReaderMarkTest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import org.junit.Test;
-
-import java.io.IOException;
-import java.io.StringReader;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/// Code compiled against `java.io.BufferedReader` marks ahead before choosing
-/// how to parse; the remapped reader must honour `mark`/`reset` across
-/// buffer refills, as the JDK class does.
-public class BufferedReaderMarkTest {
-
-    @Test
-    public void resetReturnsToTheMarkAcrossRefills() throws IOException {
-        BufferedReader r = new BufferedReader(new StringReader("header\nabcdefghijklmnop\nrest"), 4);
-        assertTrue(r.markSupported());
-        assertEquals("header", r.readLine());
-        r.mark(64);
-        assertEquals("abcdefghijklmnop", r.readLine());
-        r.reset();
-        assertEquals('a', r.read());
-        assertEquals("bcdefghijklmnop", r.readLine());
-        assertEquals("rest", r.readLine());
-    }
-
-    @Test
-    public void markAfterCarriageReturnKeepsTheLineFeedSkip() throws IOException {
-        BufferedReader r = new BufferedReader(new StringReader("a\r\nb"), 2);
-        assertEquals("a", r.readLine());
-        r.mark(8);
-        assertEquals('b', r.read());
-        r.reset();
-        assertEquals('b', r.read());
-        assertEquals(-1, r.read());
-    }
-
-    @Test
-    public void readingPastTheLimitInvalidatesTheMark() throws IOException {
-        BufferedReader r = new BufferedReader(new StringReader("0123456789abcdef"), 4);
-        r.mark(2);
-        char[] c = new char[16];
-        int n = 0;
-        while (n < 10) {
-            n += r.read(c, n, 10 - n);
-        }
-        try {
-            r.reset();
-            fail("reset after reading past the read-ahead limit");
-        } catch (IOException expected) {
-            assertEquals("Mark invalid", expected.getMessage());
-        }
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedStreamsClosedTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedStreamsClosedTest.java
deleted file mode 100644
index f93466f1bc6..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedStreamsClosedTest.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import org.junit.Test;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.StringReader;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-/// A closed `BufferedReader` or `BufferedInputStream` throws rather than
-/// handing out the characters or bytes it had already buffered, and a closed
-/// `BufferedOutputStream` refuses writes, as the JDK classes do.
-public class BufferedStreamsClosedTest {
-
-    private interface Op {
-        void run() throws IOException;
-    }
-
-    private static void assertClosed(Op op) {
-        try {
-            op.run();
-            fail("expected IOException after close");
-        } catch (IOException e) {
-            assertEquals("Stream closed", e.getMessage());
-        }
-    }
-
-    @Test
-    public void closedReaderRejectsBufferedReads() throws IOException {
-        final BufferedReader r = new BufferedReader(new StringReader("first\nsecond\nthird"));
-        r.mark(100);
-        assertEquals("first", r.readLine());
-        r.close();
-        r.close();
-        assertClosed(new Op() { public void run() throws IOException { r.read(); } });
-        assertClosed(new Op() { public void run() throws IOException { r.read(new char[4], 0, 4); } });
-        assertClosed(new Op() { public void run() throws IOException { r.readLine(); } });
-        assertClosed(new Op() { public void run() throws IOException { r.ready(); } });
-        assertClosed(new Op() { public void run() throws IOException { r.skip(1); } });
-        assertClosed(new Op() { public void run() throws IOException { r.reset(); } });
-    }
-
-    @Test
-    public void closedStreamRejectsBufferedReads() throws IOException {
-        final BufferedInputStream in = new BufferedInputStream(new ByteArrayInputStream(new byte[] {1, 2, 3, 4}));
-        in.mark(10);
-        assertEquals(1, in.read());
-        in.close();
-        in.close();
-        assertClosed(new Op() { public void run() throws IOException { in.read(); } });
-        assertClosed(new Op() { public void run() throws IOException { in.read(new byte[4], 0, 4); } });
-        assertClosed(new Op() { public void run() throws IOException { in.skip(1); } });
-        assertClosed(new Op() { public void run() throws IOException { in.available(); } });
-        assertClosed(new Op() { public void run() throws IOException { in.reset(); } });
-    }
-
-    @Test
-    public void closedOutputStreamRejectsWrites() throws IOException {
-        // ByteArrayOutputStream's close is a no-op, so a buffered write after
-        // close would reach it on the next flush or close.
-        final ByteArrayOutputStream sink = new ByteArrayOutputStream();
-        final BufferedOutputStream out = new BufferedOutputStream(sink);
-        out.write(1);
-        out.close();
-        out.close();
-        assertEquals(1, sink.size());
-        assertClosed(new Op() { public void run() throws IOException { out.write(2); } });
-        assertClosed(new Op() { public void run() throws IOException { out.write(new byte[] {3, 4}, 0, 2); } });
-        assertClosed(new Op() { public void run() throws IOException { out.flush(); } });
-        out.close();
-        assertEquals(1, sink.size());
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedWriterClosedTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedWriterClosedTest.java
deleted file mode 100644
index 8f0be466350..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/BufferedWriterClosedTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import java.io.IOException;
-import java.io.Writer;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-/// A closed `BufferedWriter` used to accept writes into its buffer, and a
-/// second close handed them to the underlying writer. Writing or flushing
-/// after close now throws, and a second close does nothing.
-public class BufferedWriterClosedTest {
-
-    /// Records what reaches it; its close does nothing, like a writer over a
-    /// shared sink.
-    private static final class Sink extends Writer {
-        final StringBuilder text = new StringBuilder();
-        int closes;
-
-        @Override
-        public void write(char[] cbuf, int off, int len) {
-            text.append(cbuf, off, len);
-        }
-
-        @Override
-        public void flush() {
-        }
-
-        @Override
-        public void close() {
-            closes++;
-        }
-    }
-
-    @Test
-    public void writesAfterCloseAreRejected() throws IOException {
-        Sink sink = new Sink();
-        BufferedWriter w = new BufferedWriter(sink);
-        w.write("ab");
-        w.close();
-        try {
-            w.write('c');
-            fail("write after close");
-        } catch (IOException expected) {
-            assertEquals("Stream closed", expected.getMessage());
-        }
-        try {
-            w.write("cd");
-            fail("write after close");
-        } catch (IOException expected) {
-            assertEquals("Stream closed", expected.getMessage());
-        }
-        try {
-            w.flush();
-            fail("flush after close");
-        } catch (IOException expected) {
-            assertEquals("Stream closed", expected.getMessage());
-        }
-        w.close();
-        assertEquals("ab", sink.text.toString());
-        assertEquals(1, sink.closes);
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileRenameFailedDeleteTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileRenameFailedDeleteTest.java
deleted file mode 100644
index cc3daffd3c7..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileRenameFailedDeleteTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
-
-import org.junit.After;
-import org.junit.Rule;
-import org.junit.Test;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/// A move between directories copies and deletes. When the source cannot be
-/// deleted the rename used to report success with the file at both paths;
-/// it now fails and takes back the copy it made.
-public class FileRenameFailedDeleteTest {
-
-    private static final String SRC = "file:///data/a/src.txt";
-    private static final String DST = "file:///data/b/dst.txt";
-
-    @Rule
-    public final MainThreadRule mainThread = new MainThreadRule();
-
-    @After
-    public void reset() {
-        HeadlessImplementation.fileSystem = false;
-        HeadlessImplementation.UNDELETABLE.clear();
-        HeadlessImplementation.FILES.remove(SRC);
-        HeadlessImplementation.FILES.remove(DST);
-    }
-
-    private static void prepare() {
-        AndroidTestSupport.context();
-        HeadlessImplementation.fileSystem = true;
-        HeadlessImplementation.FILES.put(SRC, new byte[]{1, 2, 3});
-    }
-
-    @Test
-    public void aSourceThatCannotBeDeletedFailsTheRename() {
-        prepare();
-        HeadlessImplementation.UNDELETABLE.add(SRC);
-        assertFalse(new File(SRC).renameTo(new File(DST)));
-        assertTrue(HeadlessImplementation.FILES.containsKey(SRC));
-        assertFalse("the copy is taken back", HeadlessImplementation.FILES.containsKey(DST));
-    }
-
-    @Test
-    public void aMoveBetweenDirectoriesSucceeds() {
-        prepare();
-        assertTrue(new File(SRC).renameTo(new File(DST)));
-        assertFalse(HeadlessImplementation.FILES.containsKey(SRC));
-        assertArrayEquals(new byte[]{1, 2, 3}, HeadlessImplementation.FILES.get(DST));
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileRenameOntoItselfTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileRenameOntoItselfTest.java
deleted file mode 100644
index 3916d6599b0..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileRenameOntoItselfTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
-
-import org.junit.After;
-import org.junit.Rule;
-import org.junit.Test;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertTrue;
-
-/// Renaming a file onto itself used to take the copy path, which opened the
-/// same storage path for reading and writing -- truncating it -- and then
-/// deleted it. It now succeeds and leaves the file alone.
-public class FileRenameOntoItselfTest {
-
-    private static final String SRC = "file:///data/a/src.txt";
-
-    @Rule
-    public final MainThreadRule mainThread = new MainThreadRule();
-
-    @After
-    public void reset() {
-        HeadlessImplementation.fileSystem = false;
-        HeadlessImplementation.FILES.remove(SRC);
-    }
-
-    private static void prepare() {
-        AndroidTestSupport.context();
-        HeadlessImplementation.fileSystem = true;
-        HeadlessImplementation.FILES.put(SRC, new byte[]{1, 2, 3});
-    }
-
-    @Test
-    public void theSamePathKeepsTheFile() {
-        prepare();
-        assertTrue(new File(SRC).renameTo(new File(SRC)));
-        assertArrayEquals(new byte[]{1, 2, 3}, HeadlessImplementation.FILES.get(SRC));
-    }
-
-    @Test
-    public void aDifferentSpellingOfTheSamePathKeepsTheFile() {
-        prepare();
-        assertTrue(new File(SRC).renameTo(new File("file:///data/b/../a/src.txt")));
-        assertArrayEquals(new byte[]{1, 2, 3}, HeadlessImplementation.FILES.get(SRC));
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/PrintWriterClosedTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/PrintWriterClosedTest.java
deleted file mode 100644
index 89dfc59adad..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/PrintWriterClosedTest.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.jdk;
-
-import java.io.Writer;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/// A closed `PrintWriter` kept its delegate, so over a writer whose close is
-/// a no-op every later print still landed in it and `checkError` reported
-/// nothing. Like the JDK it now suppresses those writes and reports them.
-public class PrintWriterClosedTest {
-
-    /// Records what reaches it; its close does nothing, like a `StringWriter`.
-    private static final class Sink extends Writer {
-        final StringBuilder text = new StringBuilder();
-        int closes;
-
-        @Override
-        public void write(char[] cbuf, int off, int len) {
-            text.append(cbuf, off, len);
-        }
-
-        @Override
-        public void flush() {
-        }
-
-        @Override
-        public void close() {
-            closes++;
-        }
-    }
-
-    @Test
-    public void writesAfterCloseAreSuppressedAndReported() {
-        Sink sink = new Sink();
-        PrintWriter w = new PrintWriter(sink);
-        w.print("ab");
-        assertFalse(w.checkError());
-        w.close();
-        w.print("cd");
-        w.write('e');
-        w.write(new char[] {'f'});
-        w.println("g");
-        w.flush();
-        w.close();
-        assertEquals("ab", sink.text.toString());
-        assertEquals(1, sink.closes);
-        assertTrue(w.checkError());
-    }
-
-    @Test
-    public void closeAloneIsNotAnError() {
-        PrintWriter w = new PrintWriter(new Sink());
-        w.close();
-        assertFalse(w.checkError());
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/DrawableForDensityTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/DrawableForDensityTest.java
index b3dbf9f06a3..92c961845d6 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/DrawableForDensityTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/DrawableForDensityTest.java
@@ -27,8 +27,8 @@
 
 import com.codename1.android.rescompiler.ResourceCompiler;
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.HeadlessImplementation;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/FontCacheTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/FontCacheTest.java
index fcabdee781e..bb1891176c5 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/FontCacheTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/FontCacheTest.java
@@ -24,7 +24,7 @@
 
 import android.graphics.Typeface;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/LocaleQualifierTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/LocaleQualifierTest.java
index 2a247a9968a..54b7549f4f3 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/LocaleQualifierTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/LocaleQualifierTest.java
@@ -22,7 +22,7 @@
  */
 package com.codename1.androidcompat.runtime;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/MenuXmlOnClickTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/MenuXmlOnClickTest.java
index 6703130cfdf..3e31dbd416b 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/MenuXmlOnClickTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/MenuXmlOnClickTest.java
@@ -26,7 +26,7 @@
 import android.view.MenuItem;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResTableRoundTripTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResTableRoundTripTest.java
index d758d5342c1..127106b52a3 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResTableRoundTripTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResTableRoundTripTest.java
@@ -23,7 +23,7 @@
 package com.codename1.androidcompat.runtime;
 
 import com.codename1.android.rescompiler.ResourceCompiler;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResourceSelectionRegressionTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResourceSelectionRegressionTest.java
index e6c67d3e42d..5c0fdff3fb2 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResourceSelectionRegressionTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ResourceSelectionRegressionTest.java
@@ -23,7 +23,7 @@
 package com.codename1.androidcompat.runtime;
 import android.content.res.Resources;
 import android.util.TypedValue;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import static org.junit.Assert.*;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ScriptQualifierTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ScriptQualifierTest.java
index 21152d7a5ef..59084ec7086 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ScriptQualifierTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ScriptQualifierTest.java
@@ -22,7 +22,7 @@
  */
 package com.codename1.androidcompat.runtime;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ShareStreamTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ShareStreamTest.java
index c9a9001285b..d47a3278fdc 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ShareStreamTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/ShareStreamTest.java
@@ -27,7 +27,7 @@
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesApplyDeferredTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesApplyDeferredTest.java
index 0dea6c78e23..2c1e7069791 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesApplyDeferredTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesApplyDeferredTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.io.Storage;
 
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesClearListenerTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesClearListenerTest.java
index b9b2438837b..cb78a4f3d15 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesClearListenerTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesClearListenerTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import java.util.ArrayList;
 import java.util.Collections;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesCommitFailureTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesCommitFailureTest.java
index 322b2b04f71..890747c2db6 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesCommitFailureTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesCommitFailureTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import com.codename1.io.Storage;
 
 import org.junit.Rule;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditOrderTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditOrderTest.java
index e0b7569aa6d..f6cb9fe33ec 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditOrderTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditOrderTest.java
@@ -27,7 +27,7 @@
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditorReuseTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditorReuseTest.java
index bde5737819d..fe237cfd531 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditorReuseTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesEditorReuseTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesStringTypeTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesStringTypeTest.java
index ac94a949922..767da845f47 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesStringTypeTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesStringTypeTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import org.junit.Rule;
 import org.junit.Test;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesUnchangedValueTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesUnchangedValueTest.java
index c99130b29b2..89dcc828f03 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesUnchangedValueTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesUnchangedValueTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesWeakListenerTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesWeakListenerTest.java
index e75298e0e3c..c2de3a4fc7b 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesWeakListenerTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/SharedPreferencesWeakListenerTest.java
@@ -26,7 +26,7 @@
 import android.content.SharedPreferences;
 
 import com.codename1.androidcompat.testing.AndroidTestSupport;
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/XmlPullParserTest.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/XmlPullParserTest.java
index 7a65f7e296a..5abd15a6c9d 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/XmlPullParserTest.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/runtime/XmlPullParserTest.java
@@ -31,7 +31,7 @@
 import android.util.TypedValue;
 import android.util.Xml;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.xmlpull.v1.XmlPullParser;
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/AndroidTestSupport.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/AndroidTestSupport.java
index 23ba3150518..061826182ae 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/AndroidTestSupport.java
+++ b/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/AndroidTestSupport.java
@@ -30,6 +30,7 @@
 
 import com.codename1.androidcompat.runtime.AndroidApp;
 import com.codename1.androidcompat.runtime.AndroidRuntime;
+import com.codename1.compat.testing.HeadlessImplementation;
 
 /// The Android runtime started on [HeadlessImplementation] with an
 /// application that has no resources of its own, so tests can construct,
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/HeadlessImplementation.java b/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/HeadlessImplementation.java
deleted file mode 100644
index 80b53e49d78..00000000000
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/HeadlessImplementation.java
+++ /dev/null
@@ -1,724 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.androidcompat.testing;
-
-import com.codename1.impl.CodenameOneImplementation;
-import com.codename1.l10n.L10NManager;
-import com.codename1.ui.Display;
-
-import java.io.InputStream;
-
-/// A Codename One implementation with no screen, for tests that build and
-/// lay out Android views: a fixed 1080x1920 display at 320 dpi (density 2),
-/// resources from the class path, and monospaced font metrics. Drawing and
-/// everything else answer neutral values.
-public class HeadlessImplementation extends CodenameOneImplementation {
-
-    public static final int WIDTH = 1080;
-    public static final int HEIGHT = 1920;
-    public static final int DPI = 320;
-    static final int CHAR_WIDTH = 16;
-    static final int FONT_HEIGHT = 32;
-    private static final Object FONT = new Object();
-    private static final L10NManager L10N = new L10NManager("en", "US") {
-    };
-
-    /// Starts Codename One on this implementation once per test JVM (the
-    /// test ImplementationFactory creates it).
-    public static synchronized void install() {
-        if (!Display.isInitialized()) {
-            Display.init(null);
-        }
-    }
-
-    /// The listener of the last `openGallery` call, which the headless
-    /// implementation never answers itself. A test that reads it must reset
-    /// it.
-    public static com.codename1.ui.events.ActionListener gallery;
-
-    @Override
-    public void openGallery(com.codename1.ui.events.ActionListener response, int type) {
-        gallery = response;
-    }
-
-    /// The image encoder `ImageIO.getImageIO()` answers; none by default. A
-    /// test that sets it must reset it.
-    public static com.codename1.ui.util.ImageIO imageIO;
-
-    @Override
-    public com.codename1.ui.util.ImageIO getImageIO() {
-        return imageIO;
-    }
-
-    @Override
-    public InputStream getResourceAsStream(Class cls, String resource) {
-        Class c = cls == null ? HeadlessImplementation.class : cls;
-        return c.getResourceAsStream(resource.startsWith("/") ? resource : "/" + resource);
-    }
-
-    @Override
-    public int convertToPixels(int dipCount, boolean horizontal) {
-        return Math.round(dipCount * DPI / 25.4f);
-    }
-
-    @Override
-    public boolean isTrueTypeSupported() {
-        return true;
-    }
-
-    @Override
-    public boolean isNativeFontSchemeSupported() {
-        return true;
-    }
-
-    @Override
-    public Object loadTrueTypeFont(String fontName, String fileName) {
-        return FONT;
-    }
-
-    @Override
-    public Object deriveTrueTypeFont(Object font, float size, int weight) {
-        return FONT;
-    }
-
-    /// What [#isDarkMode()] answers; tests flip it to change the system theme.
-    public static boolean darkMode;
-
-    @Override
-    public Boolean isDarkMode() {
-        return Boolean.valueOf(darkMode);
-    }
-
-    /// Whether the last screen saver call kept the screen on.
-    public static boolean screenLocked;
-
-    @Override
-    public void lockScreen() {
-        screenLocked = true;
-    }
-
-    @Override
-    public void unlockScreen() {
-        screenLocked = false;
-    }
-
-    @Override
-    public void init(java.lang.Object a0) {
-        // Nothing to set up: there is no screen.
-    }
-
-    @Override
-    public int getDisplayWidth() {
-        return WIDTH;
-    }
-
-    @Override
-    public int getDisplayHeight() {
-        return HEIGHT;
-    }
-
-    @Override
-    public void editString(com.codename1.ui.Component a0, int a1, int a2, java.lang.String a3, int a4) {
-    }
-
-    @Override
-    public void flushGraphics(int a0, int a1, int a2, int a3) {
-    }
-
-    @Override
-    public void flushGraphics() {
-    }
-
-    @Override
-    public void getRGB(java.lang.Object a0, int[] a1, int a2, int a3, int a4, int a5, int a6) {
-        if (a0 instanceof int[][]) {
-            int[][] rows = (int[][]) a0;
-            for (int y = 0; y < a6; y++) {
-                System.arraycopy(rows[a4 + y], a3, a1, a2 + y * a5, a5);
-            }
-        }
-    }
-
-    /// When set, an image made from ARGB pixels keeps them (as an `int[][]`
-    /// of rows) and answers them to `getRGB`. Off by default; tests that
-    /// inspect pixels flip it.
-    public static boolean pixelImages;
-
-    @Override
-    public java.lang.Object createImage(int[] a0, int a1, int a2) {
-        if (pixelImages && a1 > 0 && a2 > 0) {
-            int[][] rows = new int[a2][a1];
-            for (int y = 0; y < a2; y++) {
-                System.arraycopy(a0, y * a1, rows[y], 0, a1);
-            }
-            return rows;
-        }
-        return new Object();
-    }
-
-    @Override
-    public java.lang.Object createImage(java.lang.String a0) throws java.io.IOException {
-        return new Object();
-    }
-
-    /// With [#pixelImages] set, an encoded image (a PNG resource) is decoded
-    /// to its pixels, so tests can check the size a drawable comes out at.
-    @Override
-    public java.lang.Object createImage(java.io.InputStream a0) throws java.io.IOException {
-        if (pixelImages) {
-            java.awt.image.BufferedImage img = javax.imageio.ImageIO.read(a0);
-            if (img != null) {
-                int w = img.getWidth();
-                int h = img.getHeight();
-                return createImage(img.getRGB(0, 0, w, h, null, 0, w), w, h);
-            }
-        }
-        return new Object();
-    }
-
-    @Override
-    public java.lang.Object createMutableImage(int a0, int a1, int a2) {
-        return new Object();
-    }
-
-    /// Counts encoded images handed to [#createImage(byte[], int, int)], so a
-    /// test can tell a header-only bounds probe from a full decode.
-    public static int encodedDecodes;
-
-    @Override
-    public java.lang.Object createImage(byte[] a0, int a1, int a2) {
-        encodedDecodes++;
-        if (pixelImages) {
-            try {
-                return createImage(new java.io.ByteArrayInputStream(a0, a1, a2));
-            } catch (java.io.IOException e) {
-                return new Object();
-            }
-        }
-        return new Object();
-    }
-
-    @Override
-    public int getImageWidth(java.lang.Object image) {
-        return image instanceof int[][] ? ((int[][]) image)[0].length : 0;
-    }
-
-    @Override
-    public int getImageHeight(java.lang.Object image) {
-        return image instanceof int[][] ? ((int[][]) image).length : 0;
-    }
-
-    @Override
-    public java.lang.Object scale(java.lang.Object a0, int a1, int a2) {
-        if (a0 instanceof int[][] && a1 > 0 && a2 > 0) {
-            // Nearest-neighbour, for the pixel images of pixelImages.
-            int[][] src = (int[][]) a0;
-            int[][] out = new int[a2][a1];
-            for (int y = 0; y < a2; y++) {
-                for (int x = 0; x < a1; x++) {
-                    out[y][x] = src[y * src.length / a2][x * src[0].length / a1];
-                }
-            }
-            return out;
-        }
-        return new Object();
-    }
-
-    @Override
-    public int getSoftkeyCount() {
-        return 0;
-    }
-
-    @Override
-    public int[] getSoftkeyCode(int a0) {
-        return null;
-    }
-
-    @Override
-    public int getClearKeyCode() {
-        return 0;
-    }
-
-    @Override
-    public int getBackspaceKeyCode() {
-        return 0;
-    }
-
-    @Override
-    public int getBackKeyCode() {
-        return 0;
-    }
-
-    @Override
-    public int getGameAction(int a0) {
-        return 0;
-    }
-
-    @Override
-    public int getKeyCode(int a0) {
-        return 0;
-    }
-
-    @Override
-    public boolean isTouchDevice() {
-        return true;
-    }
-
-    @Override
-    public int getColor(java.lang.Object a0) {
-        return 0;
-    }
-
-    @Override
-    public void setColor(java.lang.Object a0, int a1) {
-    }
-
-    /// When set, each graphics context keeps the alpha it was given, and
-    /// every `fillRect`, `drawImage` and `fillLinearGradient` is added to
-    /// [#draws] as {operation, native graphics, alpha}. A test that sets it
-    /// must reset it and clear [#draws].
-    public static boolean recordDraws;
-    public static final java.util.List<Object[]> draws = new java.util.ArrayList<Object[]>();
-    private static final java.util.Map<Object, Integer> ALPHAS = new java.util.IdentityHashMap<Object, Integer>();
-
-    private static void recordDraw(String op, Object graphics) {
-        if (recordDraws) {
-            draws.add(new Object[]{op, graphics, Integer.valueOf(alphaOf(graphics))});
-        }
-    }
-
-    private static int alphaOf(Object graphics) {
-        Integer a = ALPHAS.get(graphics);
-        return a == null ? 255 : a.intValue();
-    }
-
-    @Override
-    public void setAlpha(java.lang.Object a0, int a1) {
-        if (recordDraws) {
-            ALPHAS.put(a0, Integer.valueOf(a1));
-        }
-    }
-
-    @Override
-    public int getAlpha(java.lang.Object a0) {
-        return recordDraws ? alphaOf(a0) : 0;
-    }
-
-    /// With [#recordDraws], the arguments of every gradient fill:
-    /// {"fillLinearGradient", start, end, horizontal} or
-    /// {"fillGradient", the gradient}. A test that records clears it too.
-    public static final java.util.List<Object[]> gradients = new java.util.ArrayList<Object[]>();
-
-    @Override
-    public void fillGradient(Object graphics, com.codename1.ui.Gradient gradient, int x, int y, int width,
-                             int height) {
-        if (recordDraws) {
-            recordDraw("fillGradient", graphics);
-            gradients.add(new Object[]{"fillGradient", gradient});
-        } else {
-            super.fillGradient(graphics, gradient, x, y, width, height);
-        }
-    }
-
-    @Override
-    public void fillLinearGradient(Object graphics, int startColor, int endColor, int x, int y, int width,
-                                   int height, boolean horizontal) {
-        if (recordDraws) {
-            recordDraw("fillLinearGradient", graphics);
-            gradients.add(new Object[]{"fillLinearGradient", Integer.valueOf(startColor),
-                Integer.valueOf(endColor), Boolean.valueOf(horizontal)});
-        } else {
-            super.fillLinearGradient(graphics, startColor, endColor, x, y, width, height, horizontal);
-        }
-    }
-
-    @Override
-    public void setNativeFont(java.lang.Object a0, java.lang.Object a1) {
-    }
-
-    /// When set, every graphics context shares one tracked clip rectangle
-    /// and shape clips are supported: `setClip(Shape)` records the shape in
-    /// [#shapeClip] and clips to its bounds. Off by default, when the clip is
-    /// always the whole display; tests that check clipping flip it.
-    public static boolean trackClip;
-    /// The last shape passed to `setClip(Shape)` while [#trackClip] is set,
-    /// null once a rectangle replaces it.
-    public static com.codename1.ui.geom.Shape shapeClip;
-    private static int clipX;
-    private static int clipY;
-    private static int clipW = WIDTH;
-    private static int clipH = HEIGHT;
-
-    @Override
-    public int getClipX(java.lang.Object a0) {
-        return trackClip ? clipX : 0;
-    }
-
-    @Override
-    public int getClipY(java.lang.Object a0) {
-        return trackClip ? clipY : 0;
-    }
-
-    @Override
-    public int getClipWidth(java.lang.Object a0) {
-        return trackClip ? clipW : WIDTH;
-    }
-
-    @Override
-    public int getClipHeight(java.lang.Object a0) {
-        return trackClip ? clipH : HEIGHT;
-    }
-
-    @Override
-    public void setClip(java.lang.Object a0, int a1, int a2, int a3, int a4) {
-        clipX = a1;
-        clipY = a2;
-        clipW = a3;
-        clipH = a4;
-        shapeClip = null;
-    }
-
-    @Override
-    public void clipRect(java.lang.Object a0, int a1, int a2, int a3, int a4) {
-        int x2 = Math.min(clipX + clipW, a1 + a3);
-        int y2 = Math.min(clipY + clipH, a2 + a4);
-        clipX = Math.max(clipX, a1);
-        clipY = Math.max(clipY, a2);
-        clipW = Math.max(0, x2 - clipX);
-        clipH = Math.max(0, y2 - clipY);
-        shapeClip = null;
-    }
-
-    @Override
-    public boolean isShapeClipSupported(java.lang.Object graphics) {
-        return trackClip;
-    }
-
-    @Override
-    public void setClip(java.lang.Object graphics, com.codename1.ui.geom.Shape shape) {
-        if (trackClip) {
-            com.codename1.ui.geom.Rectangle b = shape.getBounds();
-            setClip(graphics, b.getX(), b.getY(), b.getWidth(), b.getHeight());
-            shapeClip = shape;
-        }
-    }
-
-    @Override
-    public void drawLine(java.lang.Object a0, int a1, int a2, int a3, int a4) {
-    }
-
-    @Override
-    public void fillRect(java.lang.Object a0, int a1, int a2, int a3, int a4) {
-        recordDraw("fillRect", a0);
-    }
-
-    /// The rectangles `clearRect` was asked to erase, as `{x, y, w, h}`.
-    /// Tests that check erasing clear it first.
-    public static final java.util.List<int[]> clearedRects = new java.util.ArrayList<int[]>();
-
-    @Override
-    public void clearRect(java.lang.Object graphics, int x, int y, int width, int height) {
-        clearedRects.add(new int[]{x, y, width, height});
-        if (graphics instanceof int[][]) {
-            // A pixel image's graphics (see getNativeGraphics) really erases.
-            int[][] rows = (int[][]) graphics;
-            for (int row = Math.max(0, y); row < Math.min(rows.length, y + height); row++) {
-                for (int col = Math.max(0, x); col < Math.min(rows[row].length, x + width); col++) {
-                    rows[row][col] = 0;
-                }
-            }
-        }
-    }
-
-    @Override
-    public void drawRect(java.lang.Object a0, int a1, int a2, int a3, int a4) {
-    }
-
-    @Override
-    public void drawRoundRect(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
-    }
-
-    @Override
-    public void fillRoundRect(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
-    }
-
-    @Override
-    public void fillArc(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
-    }
-
-    @Override
-    public void drawArc(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
-    }
-
-    @Override
-    public void drawString(java.lang.Object a0, java.lang.String a1, int a2, int a3) {
-        if (recordText) {
-            drawnText.add(new Object[]{a1, Integer.valueOf(a2), Integer.valueOf(a3)});
-        }
-    }
-
-    /// When set, every `drawString` (a `drawChar` arrives as one) is added
-    /// to [#drawnText] as {text, x, y}. A test that sets it must reset both.
-    public static boolean recordText;
-    public static final java.util.List<Object[]> drawnText = new java.util.ArrayList<Object[]>();
-
-    @Override
-    public void drawImage(java.lang.Object a0, java.lang.Object a1, int a2, int a3) {
-        recordDraw("drawImage", a0);
-    }
-
-    @Override
-    public void drawRGB(java.lang.Object a0, int[] a1, int a2, int a3, int a4, int a5, int a6, boolean a7) {
-    }
-
-    @Override
-    public java.lang.Object getNativeGraphics() {
-        return new Object();
-    }
-
-    @Override
-    public java.lang.Object getNativeGraphics(java.lang.Object a0) {
-        // With pixelImages, drawing into a pixel image draws into its rows;
-        // only clearRect writes pixels so far.
-        if (pixelImages && a0 instanceof int[][]) {
-            return a0;
-        }
-        return new Object();
-    }
-
-    /// When set, a run of characters measures 1px narrower per adjacent pair
-    /// than its characters one by one, as a kerning font (a browser canvas)
-    /// does. Off by default; tests that measure text flip it.
-    public static boolean kerning;
-
-    private static int kerned(int width, int len) {
-        return kerning && len > 1 ? width - (len - 1) : width;
-    }
-
-    @Override
-    public int charsWidth(java.lang.Object nativeFont, char[] ch, int offset, int len) {
-        return kerned(len * CHAR_WIDTH, len);
-    }
-
-    @Override
-    public int stringWidth(java.lang.Object nativeFont, java.lang.String text) {
-        return text == null ? 0 : kerned(text.length() * CHAR_WIDTH, text.length());
-    }
-
-    @Override
-    public int charWidth(java.lang.Object a0, char a1) {
-        return CHAR_WIDTH;
-    }
-
-    @Override
-    public int getHeight(java.lang.Object a0) {
-        return FONT_HEIGHT;
-    }
-
-    @Override
-    public java.lang.Object getDefaultFont() {
-        return FONT;
-    }
-
-    @Override
-    public java.lang.Object createFont(int a0, int a1, int a2) {
-        return FONT;
-    }
-
-    @Override
-    public java.lang.Object connect(java.lang.String a0, boolean a1, boolean a2) throws java.io.IOException {
-        return new Object();
-    }
-
-    @Override
-    public void setHeader(java.lang.Object a0, java.lang.String a1, java.lang.String a2) {
-    }
-
-    @Override
-    public int getContentLength(java.lang.Object a0) {
-        return 0;
-    }
-
-    /// In-memory file system: what was written through `openOutputStream`
-    /// with a String path, readable back through `openInputStream` under the
-    /// exact same path, so tests can see which path the runtime addressed.
-    public static final java.util.Map<String, byte[]> FILES = new java.util.HashMap<String, byte[]>();
-
-    @Override
-    public java.io.OutputStream openOutputStream(final java.lang.Object a0) throws java.io.IOException {
-        if (!(a0 instanceof String)) {
-            return null;
-        }
-        return new java.io.ByteArrayOutputStream() {
-            @Override
-            public void close() throws java.io.IOException {
-                super.close();
-                FILES.put((String) a0, toByteArray());
-            }
-        };
-    }
-
-    @Override
-    public java.io.OutputStream openOutputStream(java.lang.Object a0, int a1) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public java.io.InputStream openInputStream(java.lang.Object a0) throws java.io.IOException {
-        byte[] b = a0 instanceof String ? FILES.get(a0) : null;
-        return b == null ? null : new java.io.ByteArrayInputStream(b);
-    }
-
-    @Override
-    public void setPostRequest(java.lang.Object a0, boolean a1) {
-    }
-
-    @Override
-    public int getResponseCode(java.lang.Object a0) throws java.io.IOException {
-        return 0;
-    }
-
-    @Override
-    public java.lang.String getResponseMessage(java.lang.Object a0) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public java.lang.String getHeaderField(java.lang.String a0, java.lang.Object a1) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public java.lang.String[] getHeaderFieldNames(java.lang.Object a0) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public java.lang.String[] getHeaderFields(java.lang.String a0, java.lang.Object a1) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public void deleteStorageFile(java.lang.String a0) {
-    }
-
-    @Override
-    public java.io.OutputStream createStorageOutputStream(java.lang.String a0) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public java.io.InputStream createStorageInputStream(java.lang.String a0) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public boolean storageFileExists(java.lang.String a0) {
-        return false;
-    }
-
-    @Override
-    public java.lang.String[] listStorageEntries() {
-        return null;
-    }
-
-    @Override
-    public java.lang.String[] listFilesystemRoots() {
-        return null;
-    }
-
-    @Override
-    public java.lang.String[] listFiles(java.lang.String a0) throws java.io.IOException {
-        return null;
-    }
-
-    @Override
-    public long getRootSizeBytes(java.lang.String a0) {
-        return 0;
-    }
-
-    @Override
-    public long getRootAvailableSpace(java.lang.String a0) {
-        return 0;
-    }
-
-    @Override
-    public void mkdir(java.lang.String a0) {
-    }
-
-    @Override
-    public void deleteFile(java.lang.String a0) {
-        if (fileSystem && !UNDELETABLE.contains(a0)) {
-            FILES.remove(a0);
-        }
-    }
-
-    /// When set, [#FILES] answers `exists` and `deleteFile` removes from it,
-    /// except a path in [#UNDELETABLE], which a refused unlink leaves in
-    /// place. A test that sets it must reset it and clear both.
-    public static boolean fileSystem;
-    public static final java.util.Set<String> UNDELETABLE = new java.util.HashSet<String>();
-
-    @Override
-    public boolean isHidden(java.lang.String a0) {
-        return false;
-    }
-
-    @Override
-    public void setHidden(java.lang.String a0, boolean a1) {
-    }
-
-    @Override
-    public long getFileLength(java.lang.String a0) {
-        return 0;
-    }
-
-    @Override
-    public boolean isDirectory(java.lang.String a0) {
-        return false;
-    }
-
-    @Override
-    public boolean exists(java.lang.String a0) {
-        return fileSystem && FILES.containsKey(a0);
-    }
-
-    @Override
-    public void rename(java.lang.String a0, java.lang.String a1) {
-    }
-
-    @Override
-    public char getFileSystemSeparator() {
-        return '/';
-    }
-
-    @Override
-    public java.lang.String getPlatformName() {
-        return "headless";
-    }
-
-    @Override
-    public com.codename1.l10n.L10NManager getLocalizationManager() {
-        return L10N;
-    }
-}
diff --git a/maven/android-compat/src/test/java/com/google/android/material/MaterialComponentsTest.java b/maven/android-compat/src/test/java/com/google/android/material/MaterialComponentsTest.java
index 861278c55e6..3a9d7277830 100644
--- a/maven/android-compat/src/test/java/com/google/android/material/MaterialComponentsTest.java
+++ b/maven/android-compat/src/test/java/com/google/android/material/MaterialComponentsTest.java
@@ -53,7 +53,7 @@
 import com.google.android.material.textfield.TextInputLayout;
 import com.google.android.material.theme.MaterialComponentsViewInflater;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
+import com.codename1.compat.testing.MainThreadRule;
 import org.junit.Rule;
 import org.junit.Test;
 
diff --git a/maven/backend-parparvm/pom.xml b/maven/backend-parparvm/pom.xml
index 2d5449e254f..d08f5e9abee 100644
--- a/maven/backend-parparvm/pom.xml
+++ b/maven/backend-parparvm/pom.xml
@@ -41,6 +41,7 @@
         <backend.dir>${project.basedir}/../../vm/backend</backend.dir>
         <core.src.dir>${project.basedir}/../../CodenameOne/src</core.src.dir>
         <backend.shared.dir>${project.build.directory}/generated-sources/backend-shared</backend.shared.dir>
+        <javaapi.host.dir>${project.build.directory}/generated-sources/javaapi-host</javaapi.host.dir>
     </properties>
 
     <build>
@@ -60,6 +61,7 @@
                             <sources>
                                 <source>${backend.dir}/impl/parparvm</source>
                                 <source>${backend.shared.dir}</source>
+                                <source>${javaapi.host.dir}</source>
                             </sources>
                         </configuration>
                     </execution>
@@ -86,6 +88,23 @@
                                         <containsregexp expression="^@(com\.codename1\.impl\.)?SharedWithBackend\s*$"/>
                                     </fileset>
                                 </copy>
+                                <!-- The production FileIo installs the class
+                                     library's POSIX JdkHost. Both classes are
+                                     vm/JavaAPI's, which the JDK compiled here
+                                     does not have; analysed elsewhere.
+                                     PosixJdkHost reaches the natives through
+                                     java.io.PosixFileAccess, which no JDK has,
+                                     so it is stood in for by an empty
+                                     subclass: FileIo only constructs it. -->
+                                <delete dir="${javaapi.host.dir}"/>
+                                <copy todir="${javaapi.host.dir}">
+                                    <fileset dir="${project.basedir}/../../vm/JavaAPI/src"
+                                             includes="com/codename1/impl/JdkHost.java"/>
+                                </copy>
+                                <echo file="${javaapi.host.dir}/com/codename1/impl/PosixJdkHost.java">package com.codename1.impl;
+public class PosixJdkHost extends JdkHost {
+}
+</echo>
                             </target>
                         </configuration>
                     </execution>
@@ -105,6 +124,7 @@
                     <excludeRoots>
                         <excludeRoot>${backend.dir}/src</excludeRoot>
                         <excludeRoot>${backend.shared.dir}</excludeRoot>
+                        <excludeRoot>${javaapi.host.dir}</excludeRoot>
                     </excludeRoots>
                 </configuration>
                 <executions>
diff --git a/maven/build-engine/pom.xml b/maven/build-engine/pom.xml
index ea5960f5f4a..b2cec6ec222 100644
--- a/maven/build-engine/pom.xml
+++ b/maven/build-engine/pom.xml
@@ -121,6 +121,14 @@
             <artifactId>codenameone-android-res-compiler</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <!-- The FXML and style sheet compiler of the JavaFX layer: the build
+             plugins call it before javac, and CompatRemapper calls its
+             dispatch generator after relocation. -->
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>codenameone-fxml-compiler</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.ant</groupId>
             <artifactId>ant</artifactId>
@@ -274,6 +282,65 @@
             <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
+        <!-- The desktop layers' real runtimes: the sample tests compile a Swing
+             and a JavaFX application, with the main class the importer writes,
+             against them, remap it and start that main class headless. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-swing-compat</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-javafx-compat</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- SwingGallerySampleTest compiles scripts/desktop-compat-samples/swing-gallery
+             the way that project's own build does: against the real SwingX,
+             which the layer replaces, and the real MigLayout, which is bundled
+             and relocated with the application. -->
+        <dependency>
+            <groupId>org.swinglabs.swingx</groupId>
+            <artifactId>swingx-all</artifactId>
+            <version>1.6.5-1</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- IkonliFontIconTest: a library that finds its parts with
+             ServiceLoader and loads a font out of META-INF/resources, bundled
+             and relocated with an application the way a project's build
+             does it. -->
+        <dependency>
+            <groupId>org.kordamp.ikonli</groupId>
+            <artifactId>ikonli-swing</artifactId>
+            <version>12.4.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.kordamp.ikonli</groupId>
+            <artifactId>ikonli-fontawesome5-pack</artifactId>
+            <version>12.4.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.miglayout</groupId>
+            <artifactId>miglayout-swing</artifactId>
+            <version>5.3</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- The headless implementation that test runs the remapped sample on.
+             KEEP THIS LAST. The jar holds a com.codename1.impl.ImplementationFactory
+             of its own, which a class loader that finds it before the core's
+             starts Codename One on; the test builds such a loader from the jar
+             file. On this module's own test classpath the core comes first, so
+             every other test keeps the real factory. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-compat-testing</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
diff --git a/maven/build-engine/spotbugs-exclude.xml b/maven/build-engine/spotbugs-exclude.xml
index 25d77303053..31758705209 100644
--- a/maven/build-engine/spotbugs-exclude.xml
+++ b/maven/build-engine/spotbugs-exclude.xml
@@ -291,4 +291,22 @@
         <Class name="com.codename1.maven.AndroidProjectImporter$Result" />
         <Bug pattern="URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD" />
     </Match>
+    <!--
+    DesktopProjectImporter.Result, likewise: the Maven goal reports the
+    copied file count, the entry point and its kind, and whether the project
+    has Kotlin, and it lives in another module this analysis cannot see.
+    -->
+    <Match>
+        <Class name="com.codename1.maven.DesktopProjectImporter$Result" />
+        <Bug pattern="URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD" />
+    </Match>
+    <!--
+    DesktopProjectImporter.Library, for the same reason: the version and the
+    scope of an imported project's dependency are read by the Maven goal's
+    DesktopPomUpdater, which writes the dependency into the project's pom.
+    -->
+    <Match>
+        <Class name="com.codename1.maven.DesktopProjectImporter$Library" />
+        <Bug pattern="URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD" />
+    </Match>
 </FindBugsFilter>
diff --git a/maven/build-engine/src/main/java/com/codename1/builders/AndroidGradleBuilder.java b/maven/build-engine/src/main/java/com/codename1/builders/AndroidGradleBuilder.java
index c493544d905..e124f7cd169 100644
--- a/maven/build-engine/src/main/java/com/codename1/builders/AndroidGradleBuilder.java
+++ b/maven/build-engine/src/main/java/com/codename1/builders/AndroidGradleBuilder.java
@@ -84,6 +84,28 @@ public class AndroidGradleBuilder extends Executor {
     private static final String GRADLE_8_VERSION = "8.13";
     private static final String ANDROID_GRADLE_PLUGIN_8_VERSION = "8.13.2";
     private static final String DESUGAR_JDK_LIBS_VERSION = "2.1.5";
+    // The nio flavour of the desugared library: java.time, the streams and
+    // the rest of the default flavour, plus java.nio.file, which the Android
+    // port's java.io.File and Files users need below API 26.
+    private static final String DESUGAR_JDK_LIBS_ARTIFACT = "com.android.tools:desugar_jdk_libs_nio";
+    // Any flavour (desugar_jdk_libs, _minimal, _nio) the project already
+    // declares wins: two of them on one classpath fail the build.
+    private static final String DESUGAR_JDK_LIBS_PREFIX = "com.android.tools:desugar_jdk_libs";
+
+    /// The `coreLibraryDesugaring` dependency line the generated app module
+    /// declares, or "" when there is none to add: on the legacy
+    /// (`android.useGradle8=false`) scaffolding, which enables no desugaring
+    /// at all, and when the project's own dependencies already name a
+    /// desugared library.
+    static String coreLibraryDesugaringDependency(boolean useGradle8, String additionalDependencies,
+            String gradleDep) {
+        if (!useGradle8
+                || (additionalDependencies != null && additionalDependencies.contains(DESUGAR_JDK_LIBS_PREFIX))
+                || (gradleDep != null && gradleDep.contains(DESUGAR_JDK_LIBS_PREFIX))) {
+            return "";
+        }
+        return "    coreLibraryDesugaring '" + DESUGAR_JDK_LIBS_ARTIFACT + ":" + DESUGAR_JDK_LIBS_VERSION + "'\n";
+    }
     private static final String GRADLE_8_DISTRIBUTION_URL =
             "https://services.gradle.org/distributions/gradle-" + GRADLE_8_VERSION + "-bin.zip";
 
@@ -8091,14 +8113,8 @@ && watchModuleName(request) != null && legacyGplayServicesMode) {
                     "    }\n";
         }
 
-        String coreLibraryDesugaringDependency = "";
-        if (useGradle8
-                && !additionalDependencies.contains("com.android.tools:desugar_jdk_libs")
-                && !request.getArg("android.gradleDep", "").contains("com.android.tools:desugar_jdk_libs")) {
-            coreLibraryDesugaringDependency =
-                    "    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:" +
-                            DESUGAR_JDK_LIBS_VERSION + "'\n";
-        }
+        String coreLibraryDesugaringDependency = coreLibraryDesugaringDependency(useGradle8,
+                additionalDependencies, request.getArg("android.gradleDep", ""));
 
         String mavenCentral = "";
         if(request.getArg("android.includeMavenCentral", "false").equals("true")) {
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/AndroidProjectImporter.java b/maven/build-engine/src/main/java/com/codename1/maven/AndroidProjectImporter.java
index 5e1805480e3..06b2979b81f 100644
--- a/maven/build-engine/src/main/java/com/codename1/maven/AndroidProjectImporter.java
+++ b/maven/build-engine/src/main/java/com/codename1/maven/AndroidProjectImporter.java
@@ -29,13 +29,10 @@
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.TreeMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -128,18 +125,21 @@ public Result importProject(File source, String module, File commonDir, String m
         Result r = new Result();
         File target = new File(commonDir, "src/main/android");
         try {
-            Map<String, String> previous = readImportRecord(target);
-            Map<String, String> imported = new TreeMap<String, String>();
+            // The manifest's hash is recorded below, once the build script has
+            // been merged into it; it is always imported (a module without one
+            // is refused), so it is never stale either.
+            ImportedFiles files = new ImportedFiles(target, IMPORT_RECORD, "the Android project", log)
+                    .deferring(MANIFEST);
             for (String name : new String[] {"AndroidManifest.xml", "res", "assets", "java", "kotlin"}) {
                 File src = new File(main, name);
                 if (src.exists()) {
-                    r.copiedFiles += copy(src, new File(target, name), name, previous, imported);
+                    r.copiedFiles += files.copy(src, new File(target, name), name);
                 }
             }
             // A manifest the developer edited since the earlier import was kept
             // by copy() with its earlier record; it already carries the merge.
-            boolean manifestKept = imported.containsKey(MANIFEST);
-            removeStaleImports(target, previous, imported);
+            boolean manifestKept = files.has(MANIFEST);
+            files.removeStale();
             File moduleDir = main.getParentFile().getParentFile();
             File gradle = new File(moduleDir, "build.gradle.kts");
             if (!gradle.isFile()) {
@@ -173,9 +173,9 @@ public Result importProject(File source, String module, File commonDir, String m
                     log.info("Added the Gradle namespace and version to the copied manifest");
                 }
                 // Recorded as written, so a later import can tell a local edit.
-                imported.put(MANIFEST, sha256(manifest));
+                files.record(MANIFEST);
             }
-            writeImportRecord(target, imported);
+            files.write();
             if (mainPackage != null && mainClass != null) {
                 writeEntryPoint(new File(commonDir, "src/main/java"), mainPackage, mainClass);
             }
@@ -201,16 +201,7 @@ public Result importProject(File source, String module, File commonDir, String m
     }
 
     static boolean hasKotlin(File dir) {
-        File[] files = dir.listFiles();
-        if (files == null) {
-            return false;
-        }
-        for (File f : files) {
-            if (f.isDirectory() ? hasKotlin(f) : f.getName().endsWith(".kt")) {
-                return true;
-            }
-        }
-        return false;
+        return ImportedFiles.hasKotlin(dir);
     }
 
     /// Adds `name="value"` to the `<manifest>` element when it has no such
@@ -356,119 +347,7 @@ static void readGradle(String gradle, Result r) {
     /// The manifest's path in the import record.
     static final String MANIFEST = "AndroidManifest.xml";
 
-    /// Copies `src` to `dest`, recording each copied file's path (relative to
-    /// `src/main/android`, `/` separated) and content hash in `imported`. The
-    /// manifest's hash is left for the caller to record once it has merged the
-    /// build script into it.
-    ///
-    /// A file an earlier import wrote and the developer changed since (its
-    /// bytes no longer match `previous`) is kept, as [#removeStaleImports]
-    /// keeps one, and as an import keeps a customized entry point: it is
-    /// recorded with its earlier hash, so the next import still recognizes
-    /// the edit, and deleting it lets an import copy it afresh.
-    private int copy(File src, File dest, String path, Map<String, String> previous, Map<String, String> imported)
-            throws IOException {
-        if (src.isDirectory()) {
-            int n = 0;
-            File[] files = src.listFiles();
-            if (files != null) {
-                for (File f : files) {
-                    n += copy(f, new File(dest, f.getName()), path + "/" + f.getName(), previous, imported);
-                }
-            }
-            return n;
-        }
-        String recorded = previous.get(path);
-        if (recorded != null && dest.isFile() && !recorded.equals(sha256(dest))
-                && !java.util.Arrays.equals(Files.readAllBytes(src.toPath()), Files.readAllBytes(dest.toPath()))) {
-            log.warn("Kept " + dest + ": it was changed after the earlier import, so the Android project's copy "
-                    + "was not imported; delete it and import again to take that copy");
-            imported.put(path, recorded);
-            return 0;
-        }
-        dest.getParentFile().mkdirs();
-        Files.copy(src.toPath(), dest.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING);
-        if (!MANIFEST.equals(path)) {
-            imported.put(path, sha256(dest));
-        }
-        return 1;
-    }
-
-    /// Removes what an earlier import copied and this one did not, so a file
-    /// deleted or renamed upstream does not stay behind to be compiled or
-    /// packaged. Only a file listed in the earlier import's record is a
-    /// candidate, and only while it still holds exactly the bytes that import
-    /// wrote: a file the developer added, or edited after importing it, is
-    /// kept. Directories the removal empties go too.
-    private void removeStaleImports(File target, Map<String, String> previous, Map<String, String> imported)
-            throws IOException {
-        for (Map.Entry<String, String> e : previous.entrySet()) {
-            String path = e.getKey();
-            // The manifest is always imported (a module without one is refused);
-            // its record is written only after the merge, so it is not here yet.
-            if (imported.containsKey(path) || MANIFEST.equals(path) || path.contains("..")) {
-                continue;
-            }
-            File f = new File(target, path.replace('/', File.separatorChar));
-            if (!f.isFile()) {
-                continue;
-            }
-            if (!e.getValue().equals(sha256(f))) {
-                log.warn("Kept " + f + ": it is no longer in the Android project, but it was changed after "
-                        + "the earlier import");
-                continue;
-            }
-            Files.delete(f.toPath());
-            log.info("Removed " + f + ": it is no longer in the Android project");
-            File dir = f.getParentFile();
-            while (dir != null && !dir.equals(target)) {
-                String[] left = dir.list();
-                if (left == null || left.length > 0 || !dir.delete()) {
-                    break;
-                }
-                dir = dir.getParentFile();
-            }
-        }
-    }
-
     /// The record an import leaves in `src/main/android`: one
     /// `<sha-256> <path>` line per file it copied.
     static final String IMPORT_RECORD = ".android-import-files";
-
-    private static Map<String, String> readImportRecord(File target) throws IOException {
-        Map<String, String> out = new TreeMap<String, String>();
-        File f = new File(target, IMPORT_RECORD);
-        if (!f.isFile()) {
-            return out;
-        }
-        for (String line : Files.readAllLines(f.toPath(), Charset.forName("UTF-8"))) {
-            int sp = line.indexOf(' ');
-            if (sp > 0 && sp < line.length() - 1) {
-                out.put(line.substring(sp + 1), line.substring(0, sp));
-            }
-        }
-        return out;
-    }
-
-    private static void writeImportRecord(File target, Map<String, String> imported) throws IOException {
-        StringBuilder b = new StringBuilder();
-        for (Map.Entry<String, String> e : imported.entrySet()) {
-            b.append(e.getValue()).append(' ').append(e.getKey()).append('\n');
-        }
-        target.mkdirs();
-        Files.write(new File(target, IMPORT_RECORD).toPath(), b.toString().getBytes(Charset.forName("UTF-8")));
-    }
-
-    private static String sha256(File f) throws IOException {
-        try {
-            byte[] d = MessageDigest.getInstance("SHA-256").digest(Files.readAllBytes(f.toPath()));
-            StringBuilder b = new StringBuilder(d.length * 2);
-            for (byte x : d) {
-                b.append(Character.forDigit((x >> 4) & 0xf, 16)).append(Character.forDigit(x & 0xf, 16));
-            }
-            return b.toString();
-        } catch (NoSuchAlgorithmException e) {
-            throw new IOException("SHA-256 is unavailable", e);
-        }
-    }
 }
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/AndroidRemapper.java b/maven/build-engine/src/main/java/com/codename1/maven/AndroidRemapper.java
index 8ddd62b2e87..9392c729c67 100644
--- a/maven/build-engine/src/main/java/com/codename1/maven/AndroidRemapper.java
+++ b/maven/build-engine/src/main/java/com/codename1/maven/AndroidRemapper.java
@@ -30,27 +30,17 @@
 import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.commons.ClassRemapper;
-import org.objectweb.asm.commons.Remapper;
 
-import java.io.ByteArrayOutputStream;
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
 
 /// Relocates an application's compiled Android code onto the compatibility
 /// runtime, and ships the runtime with it.
@@ -101,12 +91,19 @@ public final class AndroidRemapper {
         "(L" + APPLICATION + ";L" + SAVED_STATE_HANDLE + ";)V", "(L" + SAVED_STATE_HANDLE + ";)V",
         "(L" + APPLICATION + ";)V", "()V"};
 
+    /// The Android layer's naming rules.
+    public static final Relocation RELOCATION = new Relocation("Android", AndroidResourceRunner.COMPAT_ARTIFACT,
+            TARGET, PREFIXES, Relocation.JDK_SHIMS, RUNTIME_PACKAGE, RUNTIME_TARGET);
+    private static final ClassRelocator ANDROID = new ClassRelocator(RELOCATION);
+
     private final File classesDir;
     private final File compatJar;
     private final File onClickNames;
     private final Log log;
     private boolean shipRuntime = true;
     private final List<File> handlerDirs = new ArrayList<File>();
+    private ClassRelocator relocator = ANDROID;
+    private List<String> applicationClasses = new ArrayList<String>();
 
     public AndroidRemapper(File classesDir, File compatJar, File onClickNames, Log log) {
         this.classesDir = classesDir;
@@ -135,158 +132,39 @@ public AndroidRemapper withHandlerDirectories(List<File> dirs) {
         return this;
     }
 
-    /// JDK classes Android code uses that the Codename One runtime lacks,
-    /// redirected to the compatibility runtime's implementations.
-    static final String[][] JDK_SHIMS = {
-        {"java/io/BufferedReader", "com/codename1/androidcompat/jdk/BufferedReader"},
-        {"java/io/BufferedWriter", "com/codename1/androidcompat/jdk/BufferedWriter"},
-        {"java/io/BufferedInputStream", "com/codename1/androidcompat/jdk/BufferedInputStream"},
-        {"java/io/BufferedOutputStream", "com/codename1/androidcompat/jdk/BufferedOutputStream"},
-        {"java/io/File", "com/codename1/androidcompat/jdk/File"},
-        {"java/io/FileFilter", "com/codename1/androidcompat/jdk/FileFilter"},
-        {"java/io/FilenameFilter", "com/codename1/androidcompat/jdk/FilenameFilter"},
-        {"java/io/FileInputStream", "com/codename1/androidcompat/jdk/FileInputStream"},
-        {"java/io/FileOutputStream", "com/codename1/androidcompat/jdk/FileOutputStream"},
-        {"java/io/FileReader", "com/codename1/androidcompat/jdk/FileReader"},
-        {"java/io/FileWriter", "com/codename1/androidcompat/jdk/FileWriter"},
-        {"java/io/FilterInputStream", "com/codename1/androidcompat/jdk/FilterInputStream"},
-        {"java/io/FilterOutputStream", "com/codename1/androidcompat/jdk/FilterOutputStream"},
-        {"java/io/PrintWriter", "com/codename1/androidcompat/jdk/PrintWriter"},
-        // Every Codename One stream, reader and writer is AutoCloseable, and
-        // close() is the interface's only method, so code holding a Closeable
-        // runs unchanged against it.
-        {"java/io/Closeable", "java/lang/AutoCloseable"},
-    };
+    /// Relocates by every active layer's rules at once, when the application
+    /// has more than Android sources; see [ClassRelocator].
+    public AndroidRemapper withRelocator(ClassRelocator composed) {
+        relocator = composed;
+        return this;
+    }
 
-    /// The relocated internal name, or `name` unchanged.
+    /// The relocated internal name by the Android layer's rules alone, or
+    /// `name` unchanged.
     public static String map(String name) {
-        if (name == null) {
-            return null;
-        }
-        for (String[] shim : JDK_SHIMS) {
-            if (shim[0].equals(name)) {
-                return shim[1];
-            }
-        }
-        if (name.startsWith(RUNTIME_PACKAGE)) {
-            return RUNTIME_TARGET + name.substring(RUNTIME_PACKAGE.length());
-        }
-        for (String p : PREFIXES) {
-            if (name.startsWith(p)) {
-                return TARGET + name;
-            }
-        }
-        return name;
+        return ANDROID.map(name);
     }
 
-    static final Remapper REMAPPER = new Remapper() {
-        @Override
-        public String map(String internalName) {
-            return AndroidRemapper.map(internalName);
-        }
-    };
-
     static byte[] remap(byte[] in) {
-        ClassReader cr = new ClassReader(in);
-        ClassWriter cw = new ClassWriter(0);
-        cr.accept(new ClassRemapper(new PostRemapFixes(cw), REMAPPER), 0);
-        return cw.toByteArray();
-    }
-
-    /// What the remapper itself does not cover: two source interfaces can map
-    /// to one target (`Closeable` and `AutoCloseable` both become
-    /// `AutoCloseable`), and a class file that names an interface twice is
-    /// rejected by the JVM; and Kotlin's metadata strings (below).
-    private static final class PostRemapFixes extends ClassVisitor {
-        private final Set<String> methods = new LinkedHashSet<String>();
-        private String className;
-
-        PostRemapFixes(ClassVisitor next) {
-            super(Opcodes.ASM9, next);
-        }
-
-        @Override
-        public void visit(int version, int access, String name, String signature, String superName,
-                          String[] interfaces) {
-            className = name;
-            String[] distinct = interfaces;
-            if (interfaces != null && interfaces.length > 1) {
-                Set<String> seen = new LinkedHashSet<String>(Arrays.asList(interfaces));
-                if (seen.size() != interfaces.length) {
-                    distinct = seen.toArray(new String[seen.size()]);
-                }
-            }
-            super.visit(version, access, name, signature, superName, distinct);
-        }
-
-        @Override
-        public MethodVisitor visitMethod(int access, String name, String descriptor,
-                                         String signature, String[] exceptions) {
-            if (!methods.add(name + descriptor)) {
-                throw new IllegalArgumentException("Android remapping collapses overloads in "
-                        + className + ": " + name + descriptor
-                        + ". Rename the overload or use one AutoCloseable signature.");
-            }
-            return super.visitMethod(access, name, descriptor, signature, exceptions);
-        }
-
-        /// Kotlin records the JVM descriptors of a class's members as plain
-        /// strings in `@kotlin.Metadata`'s `d2` array. The remapper never sees
-        /// those, so without this they would keep naming android/... types.
-        @Override
-        public org.objectweb.asm.AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
-            org.objectweb.asm.AnnotationVisitor av = super.visitAnnotation(descriptor, visible);
-            if (av == null || !"Lkotlin/Metadata;".equals(descriptor)) {
-                return av;
-            }
-            return new org.objectweb.asm.AnnotationVisitor(Opcodes.ASM9, av) {
-                @Override
-                public org.objectweb.asm.AnnotationVisitor visitArray(String name) {
-                    org.objectweb.asm.AnnotationVisitor array = super.visitArray(name);
-                    if (array == null || !"d2".equals(name)) {
-                        return array;
-                    }
-                    return new org.objectweb.asm.AnnotationVisitor(Opcodes.ASM9, array) {
-                        @Override
-                        public void visit(String n, Object value) {
-                            super.visit(n, value instanceof String ? mapMetadataString((String) value) : value);
-                        }
-                    };
-                }
-            };
-        }
+        return ANDROID.remap(in);
     }
 
-    /// A `kotlin.Metadata` string: a method or field descriptor, or a name
-    /// that is left alone.
-    static String mapMetadataString(String s) {
-        if (s.length() == 0) {
-            return s;
-        }
-        try {
-            if (s.charAt(0) == '(') {
-                return REMAPPER.mapMethodDesc(s);
-            }
-            if ((s.charAt(0) == 'L' && s.endsWith(";")) || s.charAt(0) == '[') {
-                return REMAPPER.mapDesc(s);
-            }
-        } catch (RuntimeException e) {
-            // Not a descriptor after all (a name that happens to start with
-            // L or a bracket): keep it as written.
-            return s;
-        }
-        return s;
+    /// The internal names of the application's classes as the last [#run]
+    /// left them, for a caller that goes on to generate for other layers.
+    List<String> applicationClasses() {
+        return applicationClasses;
     }
 
     public void run() throws BuildException {
         try {
             List<String> appClasses = new ArrayList<String>();
-            remapDirectory(classesDir, appClasses);
+            applicationClasses = appClasses;
+            relocator.remapDirectory(classesDir, appClasses, log);
             if (!shipRuntime) {
                 log.info("Relocated " + appClasses.size() + " application classes");
                 return;
             }
-            int runtime = extractRuntime();
+            int runtime = relocator.extractRuntime(compatJar, classesDir);
             int handlers = writeOnClickDispatch(appClasses);
             int fragments = writeFragmentFactory();
             int viewModels = writeViewModelFactory();
@@ -307,104 +185,6 @@ public void run() throws BuildException {
         }
     }
 
-    private void remapDirectory(File dir, List<String> out) throws IOException {
-        File[] files = dir.listFiles();
-        if (files == null) {
-            return;
-        }
-        for (File f : files) {
-            if (f.isDirectory()) {
-                String rel = relative(f) + "/";
-                // The relocated runtime is extracted, not application code.
-                if (rel.equals(TARGET) || rel.startsWith(TARGET)) {
-                    continue;
-                }
-                remapDirectory(f, out);
-            } else if (f.getName().endsWith(".class")) {
-                byte[] in = Files.readAllBytes(f.toPath());
-                byte[] remapped = remap(in);
-                String name = relative(f);
-                name = name.substring(0, name.length() - ".class".length());
-                String mapped = map(name);
-                if (!mapped.equals(name)) {
-                    // Application code inside android.* (a support shim
-                    // the app carries itself) moves with the rest.
-                    File dest = new File(classesDir, mapped + ".class");
-                    dest.getParentFile().mkdirs();
-                    write(dest, remapped);
-                    if (!f.delete()) {
-                        log.warn("Could not delete " + f);
-                    }
-                    out.add(mapped);
-                } else {
-                    if (!Arrays.equals(in, remapped)) {
-                        write(f, remapped);
-                    }
-                    out.add(name);
-                }
-            }
-        }
-    }
-
-    private String relative(File f) {
-        String base = classesDir.getAbsolutePath();
-        String p = f.getAbsolutePath();
-        return p.substring(base.length() + 1).replace(File.separatorChar, '/');
-    }
-
-    /// `dest` when it lies inside the classes directory. An entry name with
-    /// `..` (or an absolute one) would write elsewhere; the runtime jar never
-    /// has one, so meeting one means the artifact is not what it should be.
-    private File inside(File dest, String entry) throws IOException {
-        String root = classesDir.getCanonicalPath() + File.separator;
-        if (!dest.getCanonicalPath().startsWith(root)) {
-            throw new IOException(compatJar + " entry " + entry + " resolves outside " + classesDir);
-        }
-        return dest;
-    }
-
-    private int extractRuntime() throws IOException {
-        int count = 0;
-        ZipFile zip = new ZipFile(compatJar);
-        try {
-            Enumeration<? extends ZipEntry> en = zip.entries();
-            while (en.hasMoreElements()) {
-                ZipEntry e = en.nextElement();
-                String name = e.getName();
-                if (e.isDirectory() || name.startsWith("META-INF/")) {
-                    continue;
-                }
-                byte[] data = read(zip.getInputStream(e));
-                if (name.endsWith(".class")) {
-                    String cls = name.substring(0, name.length() - ".class".length());
-                    File dest = inside(new File(classesDir, map(cls) + ".class"), name);
-                    writeIfDifferent(dest, remap(data));
-                    count++;
-                } else {
-                    // Resource tables and assets are compared byte for byte
-                    // too: a rebuilt table routinely keeps its length while
-                    // its contents change, and a length check alone kept the
-                    // previous runtime's copy.
-                    writeIfDifferent(inside(new File(classesDir, name), name), data);
-                }
-            }
-        } finally {
-            zip.close();
-        }
-        return count;
-    }
-
-    /// Writes `data` to `dest` unless the file already holds exactly those
-    /// bytes, so an incremental build leaves unchanged outputs (and their
-    /// timestamps) alone.
-    private static void writeIfDifferent(File dest, byte[] data) throws IOException {
-        if (dest.isFile() && dest.length() == data.length && Arrays.equals(Files.readAllBytes(dest.toPath()), data)) {
-            return;
-        }
-        dest.getParentFile().mkdirs();
-        write(dest, data);
-    }
-
     /// Writes `OnClickDispatch.dispatch(Object, String, View)`: for each layout
     /// `android:onClick` name and each class declaring a public instance
     /// `name(View)` method, a type test and a direct call. Menu items'
@@ -442,14 +222,14 @@ private int writeOnClickDispatch(List<String> appClasses) throws IOException {
                 classFiles.add(new File(classesDir, cls + ".class"));
             }
             for (File dir : handlerDirs) {
-                collectClassFiles(dir, classFiles);
+                ClassRelocator.collectClassFiles(dir, classFiles);
             }
             for (final File f : classFiles) {
                 final ClassReader cr = new ClassReader(Files.readAllBytes(f.toPath()));
                 if ((cr.getAccess() & Opcodes.ACC_INTERFACE) != 0) {
                     continue;
                 }
-                final String cls = map(cr.getClassName());
+                final String cls = relocator.map(cr.getClassName());
                 final Set<String> wanted = names;
                 cr.accept(new ClassVisitor(Opcodes.ASM9) {
                     @Override
@@ -459,7 +239,7 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si
                         }
                         // Mapped first: a handler directory's classes may not
                         // be relocated yet (Gradle relocates Kotlin's after javac).
-                        String mapped = REMAPPER.mapMethodDesc(desc);
+                        String mapped = relocator.remapper().mapMethodDesc(desc);
                         if (mapped.equals(viewDesc) && wanted.contains(name)) {
                             handlers.add(new String[] {cls, name});
                         } else if ((mapped.equals(menuVoidDesc) || mapped.equals(menuBoolDesc))
@@ -534,7 +314,7 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si
         cw.visitEnd();
         File out = new File(classesDir, ON_CLICK_DISPATCH + ".class");
         out.getParentFile().mkdirs();
-        write(out, cw.toByteArray());
+        ClassRelocator.write(out, cw.toByteArray());
         for (String n : menuNames) {
             boolean found = false;
             for (String[] h : menuHandlers) {
@@ -575,16 +355,16 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si
     private int writeFragmentFactory() throws IOException {
         final Map<String, String> supers = new HashMap<String, String>();
         List<File> all = new ArrayList<File>();
-        collectClassFiles(classesDir, all);
+        ClassRelocator.collectClassFiles(classesDir, all);
         for (File dir : handlerDirs) {
-            collectClassFiles(dir, all);
+            ClassRelocator.collectClassFiles(dir, all);
         }
         final Map<String, Boolean> candidates = new HashMap<String, Boolean>();
         for (File f : all) {
             ClassReader cr = new ClassReader(Files.readAllBytes(f.toPath()));
-            final String cls = map(cr.getClassName());
+            final String cls = relocator.map(cr.getClassName());
             if (cr.getSuperName() != null) {
-                supers.put(cls, map(cr.getSuperName()));
+                supers.put(cls, relocator.map(cr.getSuperName()));
             }
             int access = cr.getAccess();
             if ((access & (Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT)) != 0 || (access & Opcodes.ACC_PUBLIC) == 0
@@ -644,7 +424,7 @@ public MethodVisitor visitMethod(int acc, String name, String desc, String sig,
         cw.visitEnd();
         File out = new File(classesDir, FRAGMENT_FACTORY + ".class");
         out.getParentFile().mkdirs();
-        write(out, cw.toByteArray());
+        ClassRelocator.write(out, cw.toByteArray());
         return fragments.size();
     }
 
@@ -660,16 +440,16 @@ public MethodVisitor visitMethod(int acc, String name, String desc, String sig,
     private int writeViewModelFactory() throws IOException {
         final Map<String, String> supers = new HashMap<String, String>();
         List<File> all = new ArrayList<File>();
-        collectClassFiles(classesDir, all);
+        ClassRelocator.collectClassFiles(classesDir, all);
         for (File dir : handlerDirs) {
-            collectClassFiles(dir, all);
+            ClassRelocator.collectClassFiles(dir, all);
         }
         final Map<String, List<String>> ctorOf = new HashMap<String, List<String>>();
         for (File f : all) {
             ClassReader cr = new ClassReader(Files.readAllBytes(f.toPath()));
-            final String cls = map(cr.getClassName());
+            final String cls = relocator.map(cr.getClassName());
             if (cr.getSuperName() != null) {
-                supers.put(cls, map(cr.getSuperName()));
+                supers.put(cls, relocator.map(cr.getSuperName()));
             }
             int access = cr.getAccess();
             if ((access & (Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT)) != 0 || (access & Opcodes.ACC_PUBLIC) == 0
@@ -681,7 +461,7 @@ private int writeViewModelFactory() throws IOException {
                 @Override
                 public MethodVisitor visitMethod(int acc, String name, String desc, String sig, String[] ex) {
                     if (name.equals("<init>") && (acc & Opcodes.ACC_PUBLIC) != 0) {
-                        ctors.add(REMAPPER.mapMethodDesc(desc));
+                        ctors.add(relocator.remapper().mapMethodDesc(desc));
                     }
                     return null;
                 }
@@ -760,7 +540,7 @@ public MethodVisitor visitMethod(int acc, String name, String desc, String sig,
         cw.visitEnd();
         File out = new File(classesDir, VIEW_MODEL_FACTORY + ".class");
         out.getParentFile().mkdirs();
-        write(out, cw.toByteArray());
+        ClassRelocator.write(out, cw.toByteArray());
         return models.size();
     }
 
@@ -802,7 +582,7 @@ private int writeJsInterfaceDispatch(List<String> appClasses) throws IOException
             classFiles.add(new File(classesDir, cls + ".class"));
         }
         for (File dir : handlerDirs) {
-            collectClassFiles(dir, classFiles);
+            ClassRelocator.collectClassFiles(dir, classFiles);
         }
         final List<String[]> methods = new ArrayList<String[]>();
         // Every scanned class's superclass, and the public instance methods
@@ -817,9 +597,9 @@ private int writeJsInterfaceDispatch(List<String> appClasses) throws IOException
             if ((cr.getAccess() & Opcodes.ACC_INTERFACE) != 0) {
                 continue;
             }
-            final String cls = map(cr.getClassName());
+            final String cls = relocator.map(cr.getClassName());
             if (cr.getSuperName() != null) {
-                supers.put(cls, map(cr.getSuperName()));
+                supers.put(cls, relocator.map(cr.getSuperName()));
             }
             final List<String> plain = new ArrayList<String>();
             unannotated.put(cls, plain);
@@ -837,7 +617,7 @@ public MethodVisitor visitMethod(final int access, final String name, final Stri
                         @Override
                         public void visitEnd() {
                             if (!annotated) {
-                                plain.add(name + REMAPPER.mapMethodDesc(desc));
+                                plain.add(name + relocator.remapper().mapMethodDesc(desc));
                             }
                         }
 
@@ -846,7 +626,7 @@ public org.objectweb.asm.AnnotationVisitor visitAnnotation(String annotation, bo
                             for (String a : JS_INTERFACE_ANNOTATIONS) {
                                 if (a.equals(annotation)) {
                                     annotated = true;
-                                    String mapped = REMAPPER.mapMethodDesc(desc);
+                                    String mapped = relocator.remapper().mapMethodDesc(desc);
                                     if (jsCallable(mapped)) {
                                         methods.add(new String[] {cls, name, mapped});
                                     } else {
@@ -994,7 +774,7 @@ public org.objectweb.asm.AnnotationVisitor visitAnnotation(String annotation, bo
         cw.visitEnd();
         File out = new File(classesDir, JS_INTERFACE_DISPATCH + ".class");
         out.getParentFile().mkdirs();
-        write(out, cw.toByteArray());
+        ClassRelocator.write(out, cw.toByteArray());
         return methods.size();
     }
 
@@ -1047,41 +827,4 @@ private static String jsConversion(org.objectweb.asm.Type t) {
                 return null;
         }
     }
-
-    private static void collectClassFiles(File dir, List<File> out) {
-        File[] files = dir.listFiles();
-        if (files == null) {
-            return;
-        }
-        for (File f : files) {
-            if (f.isDirectory()) {
-                collectClassFiles(f, out);
-            } else if (f.getName().endsWith(".class")) {
-                out.add(f);
-            }
-        }
-    }
-
-    private static byte[] read(InputStream in) throws IOException {
-        try {
-            ByteArrayOutputStream out = new ByteArrayOutputStream();
-            byte[] buf = new byte[16384];
-            int n;
-            while ((n = in.read(buf)) > 0) {
-                out.write(buf, 0, n);
-            }
-            return out.toByteArray();
-        } finally {
-            in.close();
-        }
-    }
-
-    private static void write(File f, byte[] data) throws IOException {
-        OutputStream out = new FileOutputStream(f);
-        try {
-            out.write(data);
-        } finally {
-            out.close();
-        }
-    }
 }
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/AppBuilder.java b/maven/build-engine/src/main/java/com/codename1/maven/AppBuilder.java
index e88921f49aa..aadf53f058a 100644
--- a/maven/build-engine/src/main/java/com/codename1/maven/AppBuilder.java
+++ b/maven/build-engine/src/main/java/com/codename1/maven/AppBuilder.java
@@ -1074,7 +1074,32 @@ public static boolean isStrippedFromStagedJar(String groupId, String artifactId,
         return scope != null && !"compile".equals(scope);
     }
 
+    /// The names of the jars some module of this build unpacked into its own
+    /// classes ([CompatLibraries]): libraries written against a desktop
+    /// toolkit, which ship relocated inside that module's jar. Merging the
+    /// jar itself as well would put the unrelocated classes back, under the
+    /// same names.
+    private Set<String> bundledLibraries() {
+        if (bundledLibraries == null) {
+            List<File> roots = new ArrayList<File>();
+            roots.add(host.outputDirectory());
+            for (BuildArtifact artifact : artifacts()) {
+                File jar = artifact.getFile();
+                if (jar != null) {
+                    roots.add(jar);
+                }
+            }
+            bundledLibraries = CompatLibraries.bundledJarNames(roots);
+        }
+        return bundledLibraries;
+    }
+
+    private Set<String> bundledLibraries;
+
     private boolean isStrippedFromStagedJar(BuildArtifact artifact) {
+        if (artifact.getFile() != null && bundledLibraries().contains(artifact.getFile().getName())) {
+            return true;
+        }
         return isStrippedAsDesktopRuntime(artifact)
                 || isStrippedFromStagedJar(artifact.getGroupId(), artifact.getArtifactId(), artifact.getScope(), buildTarget);
     }
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ApplicationRegistry.java b/maven/build-engine/src/main/java/com/codename1/maven/ApplicationRegistry.java
new file mode 100644
index 00000000000..241d2c74c88
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ApplicationRegistry.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/// Generates `com.codename1.generated.compat.CompatRegistry`, the registry
+/// the class library's `java.util.ResourceBundle` and `java.util.ServiceLoader`
+/// read through `com.codename1.impl.JdkHost` on a device.
+///
+/// It extends the core's `com.codename1.impl.compat.CompatRegistryBase`, and
+/// its static `cn1Install()` -- which does its work once, however often it is
+/// called -- records:
+///
+/// - every shipped resource path in `com.codename1.impl.compat.Resources`'s
+///   index;
+/// - every class the application may need created by name, its resource
+///   bundle classes and its service providers, each under a number that
+///   `cn1Create(int)` turns into a `new` and `cn1Type(int)` into a class
+///   constant, since a device creates nothing by name;
+/// - the providers of each service, in the order they were listed;
+///
+/// and then installs itself as the registry `JdkHost` serves.
+///
+/// The name is in a package of its own. The Swing and JavaFX runtime jars
+/// carry an empty placeholder of it, so that their lifecycles compile
+/// against `cn1Install()`, but the remap step never extracts that one
+/// (`ClassRelocator.generating`) and the runtime jars themselves are not
+/// shipped, so only the generated class ships: an Android build would
+/// otherwise see two classes of one name. The registrations sit in part classes beside it,
+/// `CompatRegistry$Part0` onwards, each with one static `install` method,
+/// because a method's code is limited to 64KB and an application has as many
+/// resources as it has.
+final class ApplicationRegistry {
+
+    /// The generated class, by internal name.
+    static final String NAME = "com/codename1/generated/compat/CompatRegistry";
+    static final String BASE = "com/codename1/impl/compat/CompatRegistryBase";
+    static final String RESOURCES = "com/codename1/impl/compat/Resources";
+    private static final String PART = "$Part";
+    /// How many registrations one part holds.
+    private static final int CHUNK = 1000;
+
+    private ApplicationRegistry() {
+    }
+
+    /// The registry and its parts, by internal name.
+    ///
+    /// #### Parameters
+    ///
+    /// - `resources`: the shipped resource paths, without a leading slash
+    ///
+    /// - `bundleClasses`: the application's resource bundle classes, dotted
+    ///
+    /// - `services`: each `{service, provider}`, the service dotted as
+    ///   `Class.getName()` answers it on the device and the provider an
+    ///   internal name, in the order `ServiceLoader` is to offer them
+    static Map<String, byte[]> generate(List<String> resources, List<String> bundleClasses,
+                                        List<String[]> services) {
+        // Every class created by name, numbered in order of first mention.
+        Map<String, Integer> ids = new LinkedHashMap<String, Integer>();
+        for (String bundle : bundleClasses) {
+            id(ids, bundle.replace('.', '/'));
+        }
+        for (String[] s : services) {
+            id(ids, s[1]);
+        }
+        List<String> classes = new ArrayList<String>(ids.keySet());
+
+        Map<String, byte[]> out = new TreeMap<String, byte[]>();
+        int total = resources.size() + classes.size() + services.size();
+        List<String> parts = new ArrayList<String>();
+        for (int from = 0; from < total; from += CHUNK) {
+            String part = NAME + PART + parts.size();
+            parts.add(part);
+            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            cw.visit(Opcodes.V1_5, Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, part, null, "java/lang/Object", null);
+            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_STATIC, "install", "(L" + NAME + ";)V", null, null);
+            mv.visitCode();
+            for (int i = from; i < total && i < from + CHUNK; i++) {
+                if (i < resources.size()) {
+                    mv.visitLdcInsn(resources.get(i));
+                    mv.visitMethodInsn(Opcodes.INVOKESTATIC, RESOURCES, "cn1AddResource", "(Ljava/lang/String;)V",
+                            false);
+                } else if (i < resources.size() + classes.size()) {
+                    int id = i - resources.size();
+                    mv.visitVarInsn(Opcodes.ALOAD, 0);
+                    mv.visitLdcInsn(classes.get(id).replace('/', '.'));
+                    mv.visitLdcInsn(Integer.valueOf(id));
+                    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, NAME, "cn1Class", "(Ljava/lang/String;I)V", false);
+                } else {
+                    String[] s = services.get(i - resources.size() - classes.size());
+                    mv.visitVarInsn(Opcodes.ALOAD, 0);
+                    mv.visitLdcInsn(s[0]);
+                    mv.visitLdcInsn(s[1].replace('/', '.'));
+                    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, NAME, "cn1Provider",
+                            "(Ljava/lang/String;Ljava/lang/String;)V", false);
+                }
+            }
+            mv.visitInsn(Opcodes.RETURN);
+            mv.visitMaxs(0, 0);
+            mv.visitEnd();
+            cw.visitEnd();
+            out.put(part, cw.toByteArray());
+        }
+
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, NAME, null, BASE, null);
+
+        MethodVisitor init = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+        init.visitCode();
+        init.visitVarInsn(Opcodes.ALOAD, 0);
+        init.visitMethodInsn(Opcodes.INVOKESPECIAL, BASE, "<init>", "()V", false);
+        init.visitInsn(Opcodes.RETURN);
+        init.visitMaxs(0, 0);
+        init.visitEnd();
+
+        MethodVisitor install = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "cn1Install", "()V", null,
+                null);
+        install.visitCode();
+        Label first = new Label();
+        install.visitMethodInsn(Opcodes.INVOKESTATIC, BASE, "cn1Installed", "()Z", false);
+        install.visitJumpInsn(Opcodes.IFEQ, first);
+        install.visitInsn(Opcodes.RETURN);
+        install.visitLabel(first);
+        install.visitTypeInsn(Opcodes.NEW, NAME);
+        install.visitInsn(Opcodes.DUP);
+        install.visitMethodInsn(Opcodes.INVOKESPECIAL, NAME, "<init>", "()V", false);
+        install.visitVarInsn(Opcodes.ASTORE, 0);
+        install.visitMethodInsn(Opcodes.INVOKESTATIC, RESOURCES, "cn1BeginIndex", "()V", false);
+        for (String part : parts) {
+            install.visitVarInsn(Opcodes.ALOAD, 0);
+            install.visitMethodInsn(Opcodes.INVOKESTATIC, part, "install", "(L" + NAME + ";)V", false);
+        }
+        install.visitVarInsn(Opcodes.ALOAD, 0);
+        install.visitMethodInsn(Opcodes.INVOKEVIRTUAL, NAME, "cn1Activate", "()V", false);
+        install.visitInsn(Opcodes.RETURN);
+        install.visitMaxs(0, 0);
+        install.visitEnd();
+
+        // What a class is, which is asked without creating one, and the
+        // class's new instance.
+        for (int half = 0; half < 2; half++) {
+            MethodVisitor mv = half == 0
+                    ? cw.visitMethod(Opcodes.ACC_PROTECTED, "cn1Create", "(I)Ljava/lang/Object;", null, null)
+                    : cw.visitMethod(Opcodes.ACC_PROTECTED, "cn1Type", "(I)Ljava/lang/Class;", null, null);
+            mv.visitCode();
+            Label absent = new Label();
+            if (!classes.isEmpty()) {
+                Label[] cases = new Label[classes.size()];
+                for (int i = 0; i < cases.length; i++) {
+                    cases[i] = new Label();
+                }
+                mv.visitVarInsn(Opcodes.ILOAD, 1);
+                mv.visitTableSwitchInsn(0, cases.length - 1, absent, cases);
+                for (int i = 0; i < cases.length; i++) {
+                    String type = classes.get(i);
+                    mv.visitLabel(cases[i]);
+                    if (half == 0) {
+                        mv.visitTypeInsn(Opcodes.NEW, type);
+                        mv.visitInsn(Opcodes.DUP);
+                        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, type, "<init>", "()V", false);
+                    } else {
+                        mv.visitLdcInsn(Type.getObjectType(type));
+                    }
+                    mv.visitInsn(Opcodes.ARETURN);
+                }
+            }
+            mv.visitLabel(absent);
+            mv.visitInsn(Opcodes.ACONST_NULL);
+            mv.visitInsn(Opcodes.ARETURN);
+            mv.visitMaxs(0, 0);
+            mv.visitEnd();
+        }
+
+        cw.visitEnd();
+        out.put(NAME, cw.toByteArray());
+        return out;
+    }
+
+    /// Removes the registry and its parts from a list of class names
+    /// collected from a classes directory an earlier build wrote into.
+    static void removeGenerated(List<String> internalNames) {
+        for (Iterator<String> it = internalNames.iterator(); it.hasNext();) {
+            if (isGenerated(it.next())) {
+                it.remove();
+            }
+        }
+    }
+
+    /// Whether `internalName` is the registry or one of its parts: written
+    /// by the build, never by the application.
+    static boolean isGenerated(String internalName) {
+        return internalName.equals(NAME) || internalName.startsWith(NAME + PART);
+    }
+
+    private static void id(Map<String, Integer> ids, String internalName) {
+        if (!ids.containsKey(internalName)) {
+            ids.put(internalName, Integer.valueOf(ids.size()));
+        }
+    }
+
+    /// Writes the registry's classes into `classesDir` and removes the parts
+    /// an earlier, larger registry left behind.
+    static void write(File classesDir, Map<String, byte[]> classes, Log log) throws IOException {
+        File dir = new File(classesDir, NAME + ".class").getParentFile();
+        String pkg = NAME.substring(0, NAME.lastIndexOf('/') + 1);
+        String prefix = NAME.substring(pkg.length()) + PART;
+        File[] existing = dir.listFiles();
+        if (existing != null) {
+            for (File f : existing) {
+                String name = f.getName();
+                if (name.startsWith(prefix) && name.endsWith(".class")
+                        && !classes.containsKey(pkg + name.substring(0, name.length() - 6))
+                        && !f.delete()) {
+                    log.warn("Could not delete " + f);
+                }
+            }
+        }
+        for (Map.Entry<String, byte[]> e : classes.entrySet()) {
+            ClassRelocator.writeIfDifferent(new File(classesDir, e.getKey() + ".class"), e.getValue());
+        }
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ArrayClassGenerator.java b/maven/build-engine/src/main/java/com/codename1/maven/ArrayClassGenerator.java
new file mode 100644
index 00000000000..8a3f1c84c63
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ArrayClassGenerator.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Collection;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+/// Makes the array class of every type an application names with a class
+/// literal exist on a device.
+///
+/// #### Why
+///
+/// ParparVM has an array class only for a type some bytecode creates an
+/// array of: an `anewarray`, or a class literal of the array type. A
+/// method that returns `FooListener[]` or casts to it does not count. So
+/// `listenerList.getListeners(FooListener.class)`, or any other
+/// `Array.newInstance(FooListener.class, n)`, threw "the component class
+/// has no registered array class" for a listener type the application
+/// defines and never makes an array of itself, while the desktop, the
+/// simulator and Android, which make array classes on demand, ran it.
+///
+/// A class handed to `Array.newInstance` at run time got into the program
+/// as a class literal, or as the component type of an array that already
+/// exists. The second kind has its array class. For the first kind this
+/// generates one class holding the literal of the array type of every
+/// class literal in the application's classes. The translator registers
+/// array types as it reads a class, so the generated class does its work
+/// by being among the classes; nothing calls it.
+///
+/// A class literal that is never turned into an array costs one array
+/// class that is not used.
+public final class ArrayClassGenerator {
+
+    /// The internal name of the generated class.
+    public static final String HOLDER = "com/codename1/generated/compat/ArrayClasses";
+
+    private final File classesDir;
+
+    /// Creates a generator over a directory of compiled classes.
+    public ArrayClassGenerator(File classesDir) {
+        this.classesDir = classesDir;
+    }
+
+    /// Reads the application's classes, given by internal name, and
+    /// writes the holder, or removes one a previous run left when there
+    /// is nothing to hold. Answers the number of array types held.
+    public int run(Collection<String> appClasses) throws IOException {
+        final Set<String> named = new TreeSet<String>();
+        for (String name : appClasses) {
+            File file = new File(classesDir, name + ".class");
+            if (HOLDER.equals(name) || !file.isFile()) {
+                continue;
+            }
+            collect(Files.readAllBytes(file.toPath()), named);
+        }
+        File dest = new File(classesDir, HOLDER + ".class");
+        if (named.isEmpty()) {
+            if (dest.isFile() && !dest.delete()) {
+                throw new IOException("Could not delete " + dest);
+            }
+            return 0;
+        }
+        ClassRelocator.writeIfDifferent(dest, holder(named));
+        return named.size();
+    }
+
+    /// Adds the internal name of every class a class literal in `bytes`
+    /// names to `named`. A literal of an array type has its array class
+    /// already.
+    static void collect(byte[] bytes, final Set<String> named) {
+        new ClassReader(bytes).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visitLdcInsn(Object value) {
+                        if (value instanceof Type && ((Type) value).getSort() == Type.OBJECT) {
+                            named.add(((Type) value).getInternalName());
+                        }
+                    }
+                };
+            }
+        }, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+    }
+
+    /// The holder: one static method that loads the class of the array
+    /// type of every name and drops it.
+    static byte[] holder(Collection<String> named) {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, HOLDER, null,
+                "java/lang/Object", null);
+        MethodVisitor init = cw.visitMethod(Opcodes.ACC_PRIVATE, "<init>", "()V", null, null);
+        init.visitCode();
+        init.visitVarInsn(Opcodes.ALOAD, 0);
+        init.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        init.visitInsn(Opcodes.RETURN);
+        init.visitMaxs(1, 1);
+        init.visitEnd();
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "types", "()V", null, null);
+        mv.visitCode();
+        for (String name : named) {
+            mv.visitLdcInsn(Type.getType("[L" + name + ";"));
+            mv.visitInsn(Opcodes.POP);
+        }
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(1, 0);
+        mv.visitEnd();
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/BytecodeCompliance.java b/maven/build-engine/src/main/java/com/codename1/maven/BytecodeCompliance.java
index 393a7480fa4..36a08ac9c7b 100644
--- a/maven/build-engine/src/main/java/com/codename1/maven/BytecodeCompliance.java
+++ b/maven/build-engine/src/main/java/com/codename1/maven/BytecodeCompliance.java
@@ -28,10 +28,14 @@
 import com.codename1.build.BuildFailureException;
 import com.codename1.build.Log;
 import com.codename1.build.ProjectHost;
+import org.objectweb.asm.AnnotationVisitor;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.ConstantDynamic;
 import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
@@ -99,6 +103,8 @@ public class BytecodeCompliance {
 
     private Set<String> pendingProjectClasses = Collections.emptySet();
 
+    private List<Relocation> activeLayers;
+
     /// A check of the project `host` describes.
     public BytecodeCompliance(ProjectHost host) {
         this.host = host;
@@ -128,6 +134,76 @@ public BytecodeCompliance pendingProjectClasses(Set<String> internalNames) {
         return this;
     }
 
+    /// The compatibility layers the checked classes were relocated by. Left
+    /// unset, [#execute] works them out from the project's dependencies
+    /// ([CompatLayers#active]), which is right for every build; a caller that
+    /// already knows them can say so. They decide two things: a reference
+    /// into a layer's packages is reported under the name the application was
+    /// compiled against, and it is looked for in more places (see
+    /// `ComplianceScanner`).
+    public BytecodeCompliance activeLayers(List<Relocation> layers) {
+        this.activeLayers = layers == null ? null : new ArrayList<Relocation>(layers);
+        return this;
+    }
+
+    /// The annotation that marks a layer class as there to be linked against
+    /// and nothing more (`com.codename1.annotations.LinkOnly`).
+    private static final String LINK_ONLY_DESCRIPTOR = "Lcom/codename1/annotations/LinkOnly;";
+
+    /// The jar each bundled library class came from, by internal name.
+    private Map<String, String> libraryOrigins = Collections.emptyMap();
+
+    /// The `invokedynamic` bootstrap classes a device implements: what a
+    /// lambda, a method reference and a string concatenation compile to.
+    private static final Set<String> SUPPORTED_BOOTSTRAPS = new HashSet<String>(Arrays.asList(
+            "java/lang/invoke/LambdaMetafactory", "java/lang/invoke/StringConcatFactory"));
+
+    /// The bootstrap classes the remap step rewrites into plain methods
+    /// before this check runs. None of them is supported by a device, so one
+    /// that is still in a class when it is checked was not rewritten, and is
+    /// reported: being on this list changes what the message says, never
+    /// whether there is one. `ObjectMethods` is what a record's generated
+    /// `equals`, `hashCode` and `toString` call.
+    static final Set<String> DESUGARED_BOOTSTRAPS = new HashSet<String>(Arrays.asList(
+            "java/lang/runtime/ObjectMethods"));
+
+    /// What the last scan counted, for the port report.
+    private ScanStats stats = new ScanStats();
+
+    /// Counts taken while the classes are scanned.
+    private static final class ScanStats {
+        /// The application's own classes, and the source files they came
+        /// from as paths from the source root.
+        private int applicationClasses;
+        private final Set<String> applicationFiles = new java.util.TreeSet<String>();
+        /// The application's references into a compatibility layer, and how
+        /// many of them are to API the layer lacks.
+        private int toolkitCallSites;
+        private int toolkitCallSitesMissing;
+        /// Class files newer than the device format, and the newest.
+        private int newerClassFiles;
+        private int newestClassVersion;
+    }
+
+    /// The property `name` as the command line gives it (`-Dname=value`),
+    /// else as the project declares it; null when neither does.
+    private String property(String name) {
+        String value = System.getProperty(name);
+        if (value == null || value.isEmpty()) {
+            java.util.Properties user = host.userProperties();
+            value = user == null ? null : user.getProperty(name);
+        }
+        if (value == null || value.isEmpty()) {
+            java.util.Properties project = host.projectProperties();
+            value = project == null ? null : project.getProperty(name);
+        }
+        return value == null || value.isEmpty() ? null : value;
+    }
+
+    private List<Relocation> layers() {
+        return activeLayers == null ? Collections.<Relocation>emptyList() : activeLayers;
+    }
+
     private boolean isPendingProjectClass(String owner) {
         if (pendingProjectClasses.isEmpty() || owner == null) {
             return false;
@@ -280,8 +356,13 @@ public void execute() throws BuildExecutionException {
         getLog().info("See https://www.codenameone.com/javadoc/ for supported Classes and Methods");
 
         if (!hasChangedSinceLastCheck()) {
-            getLog().info("Sources haven't changed since the last compliance check. Skipping check");
-            return;
+            // The port report is written by the check, so one that is asked
+            // for somewhere it has not been written yet is a reason to run.
+            File report = portReportTarget();
+            if (report == null || report.isFile()) {
+                getLog().info("Sources haven't changed since the last compliance check. Skipping check");
+                return;
+            }
         }
 
         beforeCheck();
@@ -292,7 +373,9 @@ public void execute() throws BuildExecutionException {
             return;
         }
 
+        stats = new ScanStats();
         int rewrittenClassCount = enforceMaxClassVersion(outputDir, MAX_CLASS_MAJOR_VERSION);
+        desugarBootstraps(outputDir);
         InvocationRewriteSummary invocationRewriteSummary = applyInvocationRewrites(outputDir);
         lastInvocationRewriteSummary = invocationRewriteSummary;
 
@@ -319,10 +402,39 @@ public void execute() throws BuildExecutionException {
 
         List<File> dependencyJars = getDependencyJarsForScanning();
         Map<String, ClassMetadata> allowedIndex = buildClassIndex(Arrays.asList(getJavaRuntimeJar(), getCodenameOneJar()));
+        // A library the remap step unpacked into the output directory is
+        // application code now: the relocated copy there is the one to
+        // index, not the jar it came from, whose classes still name the
+        // desktop toolkit.
+        Set<String> bundled = CompatLibraries.bundledJarNames(Collections.singletonList(outputDir));
+        if (!bundled.isEmpty()) {
+            List<File> kept = new ArrayList<File>();
+            for (File jar : dependencyJars) {
+                if (!bundled.contains(jar.getName())) {
+                    kept.add(jar);
+                }
+            }
+            dependencyJars = kept;
+        }
         Map<String, ClassMetadata> projectAndDependencyIndex = buildClassIndexWithOutput(outputDir, dependencyJars);
         projectAndDependencyIndex.putAll(buildClassIndex(siblingClassRoots));
+        if (activeLayers == null) {
+            activeLayers = CompatLayers.active(dependencyJars);
+        }
 
+        // Read before the scan, which asks it whose class it is looking at.
+        Map<String, String> origins = CompatLibraries.classOrigins(outputDir);
+        libraryOrigins = origins;
         List<Violation> violations = scanProjectClasses(outputDir, allowedIndex, projectAndDependencyIndex);
+        // The developer did not write a bundled library's classes: say
+        // which jar a finding is in.
+        if (!origins.isEmpty()) {
+            for (Violation v : violations) {
+                v.library = origins.get(v.sourceClass.replace('.', '/'));
+            }
+        }
+        ComplianceFindings findings = group(violations);
+        portReportFile = writePortReport(outputDir, findings, violations);
         if (!violations.isEmpty()) {
             writeComplianceReport(violations, outputDir, dependencyJars, rewrittenClassCount);
             logViolationSummary(violations);
@@ -333,6 +445,112 @@ public void execute() throws BuildExecutionException {
         getLog().info("Invocation rewrite summary: classes rewritten=" + invocationRewriteSummary.rewrittenClasses + ", callsites rewritten=" + invocationRewriteSummary.rewrittenCallsites);
     }
 
+    private Boolean desktopProject;
+
+    /// Whether the classes are a desktop application's: a Swing or JavaFX
+    /// layer is among the project's dependencies **and** its classes use
+    /// it. The jar alone says nothing -- every generated project has both --
+    /// so this asks what the remap step asks ([CompatLayers#active]).
+    private boolean isDesktopProject() {
+        if (desktopProject == null) {
+            boolean desktop = false;
+            if (activeLayers == null || activeLayers.contains(CompatLayers.SWING)
+                    || activeLayers.contains(CompatLayers.JAVAFX)) {
+                try {
+                    List<Relocation> used = CompatLayers.active(getDependencyJarsForScanning(),
+                            Collections.singletonList(new File(host.outputDirectory().getPath())));
+                    desktop = used.contains(CompatLayers.SWING) || used.contains(CompatLayers.JAVAFX);
+                } catch (IOException e) {
+                    getLog().debug("Could not tell whether this is a desktop application", e);
+                }
+            }
+            desktopProject = Boolean.valueOf(desktop);
+        }
+        return desktopProject.booleanValue();
+    }
+
+    /// The findings of `violations`, arranged for reading.
+    private static ComplianceFindings group(List<Violation> violations) {
+        ComplianceFindings findings = new ComplianceFindings();
+        for (Violation v : violations) {
+            if (v.language) {
+                findings.addLanguage(v.library, v.file(), v.line, v.api, v.suggestion);
+            } else {
+                findings.add(v.library, v.file(), v.line, v.owner, v.api == null ? v.referencedMember : v.api, v.key);
+            }
+        }
+        return findings;
+    }
+
+    /// The report file, or null when the classes are no desktop
+    /// application's.
+    private File portReportFile;
+    private File requestedPortReport;
+
+    /// Where the port report of a desktop application goes, for a plugin
+    /// that declares the choice as a parameter of its own; null leaves it to
+    /// the `cn1.desktop.report` property and then to the default,
+    /// `codenameone/desktop-port-report.md` in the build directory.
+    public BytecodeCompliance portReport(File file) {
+        this.requestedPortReport = file;
+        return this;
+    }
+
+    /// Where the port report goes: what a plugin asked for, else the
+    /// `cn1.desktop.report` property, else the default in the build
+    /// directory; a relative path is the project's. Null for a project that
+    /// is no desktop application.
+    private File portReportTarget() {
+        if (!isDesktopProject()) {
+            return null;
+        }
+        String named = property(DesktopPortReport.PROPERTY);
+        File file = requestedPortReport != null ? requestedPortReport : named != null ? new File(named)
+                : new File(host.buildDirectory(), DesktopPortReport.DEFAULT_PATH.replace('/', File.separatorChar));
+        if (!file.isAbsolute()) {
+            file = new File(host.baseDir(), file.getPath());
+        }
+        return file;
+    }
+
+    /// Writes the port report of a desktop application and answers the
+    /// file; null for any other project, which has nothing to port.
+    private File writePortReport(File outputDir, ComplianceFindings findings, List<Violation> violations)
+            throws BuildExecutionException {
+        File file = portReportTarget();
+        if (file == null) {
+            return null;
+        }
+        Map<String, Set<String>> classes = new HashMap<String, Set<String>>();
+        for (Violation v : violations) {
+            if (v.library != null) {
+                Set<String> set = classes.get(v.library);
+                if (set == null) {
+                    set = new HashSet<String>();
+                    classes.put(v.library, set);
+                }
+                set.add(v.sourceClass);
+            }
+        }
+        Map<String, Integer> classesWithFindings = new HashMap<String, Integer>();
+        for (Map.Entry<String, Set<String>> e : classes.entrySet()) {
+            classesWithFindings.put(e.getKey(), e.getValue().size());
+        }
+        String text = new DesktopPortReport(findings)
+                .application(stats.applicationClasses, stats.applicationFiles)
+                .toolkitCallSites(stats.toolkitCallSites, stats.toolkitCallSitesMissing)
+                .libraries(CompatLibraries.libraries(outputDir), classesWithFindings)
+                .newerClassFiles(stats.newerClassFiles, stats.newestClassVersion - 44)
+                .render();
+        try {
+            FileUtils.writeStringToFile(file, text, "UTF-8");
+        } catch (IOException ex) {
+            throw new BuildExecutionException("Failed to write the desktop port report " + file, ex);
+        }
+        getLog().info("Desktop port report: " + file.getAbsolutePath());
+        return file;
+    }
+
     /// Checks freshly compiled backend application/test classes against the native
     /// JavaAPI, not the client runtime or host JDK. Never skips or consults the
     /// client's success marker. Backend bytecode retains its configured version.
@@ -481,6 +699,7 @@ private void writeComplianceSuccess(String message, int rewrittenClassCount) thr
             StringBuilder content = new StringBuilder();
             content.append(message).append("\n");
             content.append("Rewritten class files to Java 17 major version: ").append(rewrittenClassCount).append("\n");
+            content.append(newerClassFilesNote());
             content.append("Rewritten JDK API callsites: ").append(lastInvocationRewriteSummary.rewrittenCallsites)
                     .append(" across ").append(lastInvocationRewriteSummary.rewrittenClasses).append(" class(es)").append("\n");
             FileUtils.writeStringToFile(complianceOutputFile, content.toString(), "UTF-8");
@@ -497,14 +716,24 @@ private void writeComplianceReport(List<Violation> violations, File outputDir, L
         report.append("Project: ").append(host.finalName()).append("\n");
         report.append("Output classes: ").append(outputDir.getAbsolutePath()).append("\n");
         report.append("Dependency jars scanned: ").append(dependencyJars.size()).append("\n");
-        report.append("Rewritten class files to Java 17 major version: ").append(rewrittenClassCount).append("\n\n");
+        report.append("Rewritten class files to Java 17 major version: ").append(rewrittenClassCount).append("\n");
+        report.append(newerClassFilesNote()).append("\n");
         report.append("Rewritten JDK API callsites: ").append(lastInvocationRewriteSummary.rewrittenCallsites)
                 .append(" across ").append(lastInvocationRewriteSummary.rewrittenClasses).append(" class(es)").append("\n\n");
-        report.append("Violations (").append(violations.size()).append(")\n");
-        report.append("========================================\n");
-        int i = 1;
-        for (Violation violation : violations) {
-            report.append(i++).append(") ").append(violation.render()).append("\n\n");
+        ComplianceFindings findings = group(violations);
+        report.append(findings.summary()).append("\n\n");
+        if (portReportFile != null) {
+            report.append("The port report, which lists the same findings by source file, is ")
+                    .append(portReportFile.getAbsolutePath()).append("\n\n");
+        }
+        report.append(findings.report());
+        if (violations.size() <= MAX_DETAILED_VIOLATIONS) {
+            report.append("Violations (").append(violations.size()).append(")\n");
+            report.append("========================================\n");
+            int i = 1;
+            for (Violation violation : violations) {
+                report.append(i++).append(") ").append(violation.render()).append("\n\n");
+            }
         }
 
         complianceOutputFile.getParentFile().mkdirs();
@@ -515,8 +744,16 @@ private void writeComplianceReport(List<Violation> violations, File outputDir, L
         }
     }
 
+    /// Up to this many violations are each spelled out, in the message and
+    /// in the file, the way a single one always was. Beyond it only the
+    /// grouped report is of any use: nobody reads the 3,000th entry.
+    private static final int MAX_LISTED_VIOLATIONS = 5;
+
+    /// Up to this many violations are each written out in full in the
+    /// compliance file, after the grouped report.
+    private static final int MAX_DETAILED_VIOLATIONS = 50;
+
     private String buildFailureSummary(List<Violation> violations) {
-        int maxInMessage = Math.min(5, violations.size());
         StringBuilder sb = new StringBuilder();
         sb.append("Compliance check failed with ").append(violations.size()).append(" forbidden API reference");
         if (violations.size() != 1) {
@@ -524,23 +761,43 @@ private String buildFailureSummary(List<Violation> violations) {
         }
         sb.append(".\n");
         sb.append("See ").append(complianceOutputFile.getAbsolutePath()).append(" for the full report.\n");
-        sb.append("First ").append(maxInMessage).append(" violation(s):");
-        for (int i = 0; i < maxInMessage; i++) {
-            Violation v = violations.get(i);
+        if (violations.size() > MAX_LISTED_VIOLATIONS) {
+            sb.append(group(violations).summary());
+            if (portReportFile != null) {
+                sb.append("\nWhat to change, file by file: ").append(portReportFile.getAbsolutePath());
+            }
+            return sb.toString();
+        }
+        sb.append("First ").append(violations.size()).append(" violation(s):");
+        for (Violation v : violations) {
             sb.append("\n - ").append(v.renderInline());
         }
         return sb.toString();
     }
 
     private void logViolationSummary(List<Violation> violations) {
-        int maxToLog = Math.min(5, violations.size());
         getLog().error("Bytecode compliance check found " + violations.size() + " violation(s).");
         getLog().error("Detailed report written to " + complianceOutputFile.getAbsolutePath());
-        for (int i = 0; i < maxToLog; i++) {
+        if (violations.size() > MAX_LISTED_VIOLATIONS) {
+            // The failure itself carries the grouped summary.
+            return;
+        }
+        for (int i = 0; i < violations.size(); i++) {
             getLog().error("[" + (i + 1) + "] " + violations.get(i).renderInline());
         }
     }
 
+    /// What became of class files newer than the device format, as a line
+    /// of the compliance file; empty when there were none.
+    private String newerClassFilesNote() {
+        if (stats.newerClassFiles == 0) {
+            return "";
+        }
+        return stats.newerClassFiles + " class file(s) were compiled for a Java newer than 17 (up to Java "
+                + (stats.newestClassVersion - 44) + ") and were rewritten to the Java 17 class format. "
+                + "What they call, by instruction or by invokedynamic, is checked like any other class's.\n";
+    }
+
 
     private int enforceMaxClassVersion(File outputDir, final int maxVersion) throws BuildExecutionException {
         List<File> classFiles = new ArrayList<File>();
@@ -554,18 +811,52 @@ private int enforceMaxClassVersion(File outputDir, final int maxVersion) throws
                     byte[] rewrittenBytes = rewriteClassVersion(originalBytes, maxVersion);
                     FileUtils.writeByteArrayToFile(classFile, rewrittenBytes);
                     rewritten++;
-                    getLog().info("Rewrote class major version " + versionInfo.majorVersion + " -> " + maxVersion + " for " + classFile.getAbsolutePath());
+                    stats.newestClassVersion = Math.max(stats.newestClassVersion, versionInfo.majorVersion);
+                    getLog().debug("Rewrote class major version " + versionInfo.majorVersion + " -> " + maxVersion + " for " + classFile.getAbsolutePath());
                 }
             } catch (IOException ex) {
                 throw new BuildExecutionException("Failed to enforce class version for " + classFile, ex);
             }
         }
+        stats.newerClassFiles = rewritten;
         if (rewritten > 0) {
-            getLog().info("Rewrote " + rewritten + " class file(s) to Java 17 major version " + maxVersion);
+            getLog().info("Rewrote " + rewritten + " class file(s) to Java 17 major version " + maxVersion
+                    + ": they were compiled for a newer Java (up to Java " + (stats.newestClassVersion - 44)
+                    + "). What they call, by instruction or by invokedynamic, is checked like any other class's");
         }
         return rewritten;
     }
 
+    /// Gives every record its `equals`, `hashCode` and `toString`, and every
+    /// pattern switch its test, as plain methods ([RecordDesugar]). A project
+    /// with a compatibility layer had this done by the remap step, and then
+    /// nothing here is rewritten; a plain application's classes come
+    /// straight from javac, and no translator implements the two bootstrap
+    /// classes they call. Whatever is left afterwards is what the scan
+    /// reports.
+    private void desugarBootstraps(File outputDir) throws BuildExecutionException {
+        List<File> classFiles = new ArrayList<File>();
+        collectClassFiles(outputDir, classFiles);
+        int rewritten = 0;
+        for (File classFile : classFiles) {
+            try {
+                byte[] originalBytes = FileUtils.readFileToByteArray(classFile);
+                byte[] rewrittenBytes = RecordDesugar.apply(originalBytes);
+                if (rewrittenBytes != originalBytes) {
+                    validateClass(rewrittenBytes, classFile, outputDir);
+                    FileUtils.writeByteArrayToFile(classFile, rewrittenBytes);
+                    rewritten++;
+                }
+            } catch (IOException ex) {
+                throw new BuildExecutionException("Failed to rewrite the record and switch methods of " + classFile,
+                        ex);
+            }
+        }
+        if (rewritten > 0) {
+            getLog().info("Generated the record and pattern-switch methods of " + rewritten + " class file(s)");
+        }
+    }
+
     private ClassVersionInfo readClassVersion(byte[] classBytes) {
         final ClassVersionInfo out = new ClassVersionInfo();
         ClassReader reader = new ClassReader(classBytes);
@@ -1060,7 +1351,7 @@ private void indexArchive(File archive, Map<String, ClassMetadata> index) throws
         InputStream fis = new BufferedInputStream(new FileInputStream(archive));
         try {
             indexArchiveStream(fis, archive.getAbsolutePath(), index,
-                    archive.getName().startsWith(AndroidResourceRunner.COMPAT_ARTIFACT + "-"));
+                    CompatLayers.EVERY.layerOf(archive) != null);
         } finally {
             fis.close();
         }
@@ -1070,7 +1361,7 @@ private void indexArchiveStream(InputStream archiveStream, String sourcePrefix,
         indexArchiveStream(archiveStream, sourcePrefix, index, false);
     }
 
-    /// `relocated`: the Android compatibility runtime, which the remap step
+    /// `relocated`: a compatibility layer's runtime, which the remap step
     /// ships relocated; its classes are indexed under those names too, so a
     /// pass checked before the runtime is copied in (Gradle's Kotlin pass)
     /// resolves the relocated references.
@@ -1090,15 +1381,21 @@ private void indexArchiveStream(InputStream archiveStream, String sourcePrefix,
                         continue;
                     }
                     ClassMetadata metadata = readClassMetadata(new ByteArrayInputStream(bytes), sourcePrefix + "!" + entryName);
-                    if (metadata != null) {
-                        index.putIfAbsent(metadata.name, metadata);
-                    }
+                    ClassMetadata moved = null;
                     if (relocated) {
-                        ClassMetadata moved = readClassMetadata(new ByteArrayInputStream(AndroidRemapper.remap(bytes)),
+                        moved = readClassMetadata(new ByteArrayInputStream(CompatLayers.EVERY.remap(bytes)),
                                 sourcePrefix + "!" + entryName);
-                        if (moved != null) {
-                            index.putIfAbsent(moved.name, moved);
-                        }
+                    }
+                    // A runtime authored under the names it ships with (the
+                    // Swing layer's) keeps its name through relocation. It is
+                    // then one class, not two, and the relocated reading is
+                    // the one to keep: its members name the classes the
+                    // device has, as the application's relocated calls do.
+                    if (metadata != null && (moved == null || !metadata.name.equals(moved.name))) {
+                        index.putIfAbsent(metadata.name, metadata);
+                    }
+                    if (moved != null) {
+                        index.putIfAbsent(moved.name, moved);
                     }
                 } else if (isClassArchiveName(entryName)) {
                     indexArchiveStream(new ByteArrayInputStream(bytes), sourcePrefix + "!" + entryName, index);
@@ -1159,6 +1456,14 @@ public void visit(int version, int access, String name, String signature, String
                     metadata.interfaces = interfaces == null ? Collections.<String>emptyList() : Arrays.asList(interfaces);
                 }
 
+                @Override
+                public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+                    if (LINK_ONLY_DESCRIPTOR.equals(descriptor)) {
+                        metadata.linkOnly = true;
+                    }
+                    return null;
+                }
+
                 @Override
                 public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
                     metadata.fields.add(memberKey(name, descriptor));
@@ -1302,15 +1607,63 @@ private static final class ClassMetadata {
         List<String> interfaces = Collections.emptyList();
         Set<String> methods = new HashSet<String>();
         Set<String> fields = new HashSet<String>();
-    }
-
+        /// Marked `@LinkOnly`: there for bundled libraries to link against,
+        /// and absent as far as the application's own classes go.
+        boolean linkOnly;
+    }
+
+    /// Reports every reference a class makes that the device could not link.
+    ///
+    /// A project with no compatibility layer is checked at its method, field
+    /// and type instructions, and each failing instruction is one violation.
+    ///
+    /// A reference into an ACTIVE layer's relocated packages is held to more,
+    /// because for the Swing layer this check is the only compiler there is:
+    /// the application compiled against the real JDK, so javac accepted every
+    /// call the JDK has, and nothing before this point knows which of them
+    /// the layer provides. Such a reference is therefore also looked for in
+    /// the superclass and interfaces, the types of declared fields and
+    /// methods, declared `throws`, `catch` types, class constants, array
+    /// types, and the three parts of an `invokedynamic` -- which is what every
+    /// lambda and method reference compiles to: the functional interface in
+    /// its descriptor, the bootstrap method types, and the method handle's
+    /// target. It is reported under the name the developer wrote
+    /// (`javax.swing.JTable.setAutoCreateRowSorter(boolean)`), once per source
+    /// line, with a missing class reported as the class rather than as each
+    /// of its members.
+    ///
+    /// None of the additional places is examined for any other reference, so
+    /// the result for a project with no layer is what it always was.
+    ///
+    /// #### What it cannot see
+    ///
+    /// An application class that overrides or implements a method the JDK
+    /// type declares but the layer's type does not -- `paintComponent` on a
+    /// component whose compat class never calls it, a listener method the
+    /// compat interface lacks -- passes. The override is an ordinary method
+    /// of the application's own class; nothing in the class file says which
+    /// inherited method it was written against, and telling would need the
+    /// JDK's own signatures to compare the layer with. The method is then
+    /// simply never called on a device. Only an explicit `super.method()`
+    /// call, which is a method instruction like any other, is caught.
     private final class ComplianceScanner extends ClassVisitor {
         private final File classFile;
         private final File outputDir;
         private final Map<String, ClassMetadata> allowedIndex;
         private final Map<String, ClassMetadata> projectAndDependencyIndex;
         private final List<Violation> violations;
+        private final List<Relocation> layers = layers();
+        private final ClassRelocator layerNames = new ClassRelocator(layers);
+        /// Layer symbols already reported for this class: `symbol` alone, and
+        /// `symbol@line` for each line it was reported at.
+        private final Set<String> reportedLayerSymbols = new HashSet<String>();
+        /// Layer symbols missing from a declaration, which has no line of its
+        /// own. Reported at the end, and only when no instruction reported
+        /// the same symbol with a line.
+        private final Map<String, DeclaredSymbol> declaredLayerSymbols = new LinkedHashMap<String, DeclaredSymbol>();
         private String className;
+        private String sourceFile;
+        private int currentLine;
 
         private ComplianceScanner(File classFile,
                                   File outputDir,
@@ -1328,15 +1681,57 @@ private ComplianceScanner(File classFile,
         @Override
         public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
             className = name;
+            if (isApplicationClass()) {
+                stats.applicationClasses++;
+            }
             if (backendCheck) {
                 if (superName != null) checkTypeReference(name, "<class>", superName);
                 if (interfaces != null) for (String iface : interfaces) checkTypeReference(name, "<class>", iface);
             }
+            if (layers.isEmpty()) {
+                return;
+            }
+            List<DeclaredSymbol> declared = new ArrayList<DeclaredSymbol>();
+            checkLayerType("(extends)", superName, declared);
+            if (interfaces != null) {
+                for (String iface : interfaces) {
+                    checkLayerType("(implements)", iface, declared);
+                }
+            }
+        }
+
+        @Override
+        public void visitSource(String source, String debug) {
+            sourceFile = source;
+            // A class the build generated names something that is no file.
+            if (isApplicationClass() && source != null && source.indexOf('.') > 0) {
+                stats.applicationFiles.add(packagePath(className) + source);
+            }
+        }
+
+        /// Whether the class being scanned is one the developer wrote:
+        /// neither a layer's runtime nor a library unpacked beside it.
+        private boolean isApplicationClass() {
+            return className != null && !CompatLayers.isExtractedRuntime(className)
+                    && !libraryOrigins.containsKey(className) && !ApplicationRegistry.isGenerated(className);
+        }
+
+        /// Counts one reference of the application into a layer.
+        private void countToolkit(String owner, boolean supported) {
+            if (layerOf(owner) != null && isApplicationClass()) {
+                stats.toolkitCallSites++;
+                if (!supported) {
+                    stats.toolkitCallSitesMissing++;
+                }
+            }
         }
 
         @Override
         public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
             if (backendCheck) checkDescriptor(name, descriptor);
+            if (!layers.isEmpty()) {
+                checkLayerDescriptor("(field " + name + ")", descriptor, new ArrayList<DeclaredSymbol>());
+            }
             return null;
         }
 
@@ -1364,36 +1759,31 @@ private void checkHandle(String member, org.objectweb.asm.Handle handle) {
         @Override
         public MethodVisitor visitMethod(int access, final String name, final String descriptor, String signature, String[] exceptions) {
             final String sourceMethod = name + descriptor;
+            currentLine = 0;
+            // What the method's own declaration is missing. It has no line, so
+            // it is given the method's first one when the code turns up.
+            final List<DeclaredSymbol> declared = new ArrayList<DeclaredSymbol>();
+            if (!layers.isEmpty()) {
+                checkLayerDescriptor(sourceMethod, descriptor, declared);
+                if (exceptions != null) {
+                    for (String thrown : exceptions) {
+                        checkLayerType(sourceMethod, thrown, declared);
+                    }
+                }
+            }
             if (backendCheck) {
                 checkDescriptor(sourceMethod, descriptor);
                 if (exceptions != null) for (String exception : exceptions) checkTypeReference(className, sourceMethod, exception);
             }
             return new MethodVisitor(Opcodes.ASM9) {
                 @Override
-                public void visitLdcInsn(Object value) {
-                    if (!backendCheck) return;
-                    if (value instanceof Type) checkDescriptor(sourceMethod, ((Type) value).getDescriptor());
-                    if (value instanceof org.objectweb.asm.Handle) checkHandle(sourceMethod, (org.objectweb.asm.Handle) value);
-                }
-
-                @Override
-                public void visitInvokeDynamicInsn(String name, String descriptor, org.objectweb.asm.Handle bootstrap, Object... args) {
-                    if (!backendCheck) return;
-                    checkDescriptor(sourceMethod, descriptor);
-                    for (Object arg : args) {
-                        if (arg instanceof org.objectweb.asm.Handle) checkHandle(sourceMethod, (org.objectweb.asm.Handle) arg);
-                        if (arg instanceof Type) checkDescriptor(sourceMethod, ((Type) arg).getDescriptor());
+                public void visitLineNumber(int line, Label start) {
+                    if (currentLine == 0) {
+                        for (DeclaredSymbol d : declared) {
+                            d.line = line;
+                        }
                     }
-                }
-
-                @Override
-                public void visitMultiANewArrayInsn(String descriptor, int dimensions) {
-                    if (backendCheck) checkDescriptor(sourceMethod, descriptor);
-                }
-
-                @Override
-                public void visitTryCatchBlock(org.objectweb.asm.Label start, org.objectweb.asm.Label end, org.objectweb.asm.Label handler, String type) {
-                    if (backendCheck && type != null) checkTypeReference(className, sourceMethod, type);
+                    currentLine = line;
                 }
 
                 @Override
@@ -1412,44 +1802,483 @@ public void visitFieldInsn(int opcode, String owner, String memberName, String m
                 public void visitTypeInsn(int opcode, String type) {
                     checkTypeReference(className, sourceMethod, type);
                 }
+
+                @Override
+                public void visitMultiANewArrayInsn(String arrayDescriptor, int dimensions) {
+                    if (backendCheck) checkDescriptor(sourceMethod, arrayDescriptor);
+                    if (!layers.isEmpty()) {
+                        checkLayerType(sourceMethod, arrayDescriptor, null);
+                    }
+                }
+
+                @Override
+                public void visitTryCatchBlock(Label start, Label end, Label handler, String type) {
+                    // Visited before the code it covers, so before any line:
+                    // it is a declaration of the method, like its throws.
+                    if (backendCheck && type != null) checkTypeReference(className, sourceMethod, type);
+                    if (!layers.isEmpty() && type != null) {
+                        checkLayerType(sourceMethod, type, declared);
+                    }
+                }
+
+                @Override
+                public void visitLdcInsn(Object value) {
+                    if (backendCheck) {
+                        // A backend's bootstraps and dynamic constants are
+                        // judged by checkBackendBootstraps before this scan.
+                        if (value instanceof Type) checkDescriptor(sourceMethod, ((Type) value).getDescriptor());
+                        if (value instanceof Handle) checkHandle(sourceMethod, (Handle) value);
+                        return;
+                    }
+                    if (value instanceof ConstantDynamic) {
+                        reportDynamicConstant(sourceMethod, (ConstantDynamic) value);
+                    }
+                    if (!layers.isEmpty()) {
+                        checkLayerConstant(sourceMethod, value);
+                    }
+                }
+
+                @Override
+                public void visitInvokeDynamicInsn(String indyName, String indyDescriptor, Handle bootstrap,
+                                                   Object... bootstrapArguments) {
+                    if (backendCheck) {
+                        checkDescriptor(sourceMethod, indyDescriptor);
+                        for (Object arg : bootstrapArguments) {
+                            if (arg instanceof Handle) checkHandle(sourceMethod, (Handle) arg);
+                            if (arg instanceof Type) checkDescriptor(sourceMethod, ((Type) arg).getDescriptor());
+                        }
+                        return;
+                    }
+                    // Every project, with a layer or without: the call is
+                    // made by the bootstrap method, and what that reaches is
+                    // named only in its static arguments.
+                    if (checkBootstrap(sourceMethod, bootstrap)) {
+                        for (Object argument : bootstrapArguments) {
+                            checkBootstrapArgument(sourceMethod, argument);
+                        }
+                    }
+                    if (layers.isEmpty()) {
+                        return;
+                    }
+                    int before = violations.size();
+                    checkLayerDescriptor(sourceMethod, indyDescriptor, null);
+                    for (Object argument : bootstrapArguments) {
+                        checkLayerConstant(sourceMethod, argument);
+                    }
+                    if (violations.size() == before) {
+                        // Only when every class it names exists: a missing
+                        // parameter type already explains a missing method.
+                        checkFunctionalInterfaceMethod(sourceMethod, indyName, indyDescriptor, bootstrap,
+                                bootstrapArguments);
+                    }
+                }
             };
         }
 
+        @Override
+        public void visitEnd() {
+            for (Map.Entry<String, DeclaredSymbol> e : declaredLayerSymbols.entrySet()) {
+                if (reportedLayerSymbols.add(e.getKey())) {
+                    DeclaredSymbol d = e.getValue();
+                    violations.add(new Violation(className, d.sourceMethod, d.message, null, relativePath(),
+                            sourceFile, d.line).names(d.owner, d.api, apiKey(d.api)));
+                }
+            }
+        }
+
+        /// An `invokedynamic` is a call to whatever its bootstrap method
+        /// builds at run time. A device builds nothing at run time: the
+        /// translators implement the bootstraps of [#SUPPORTED_BOOTSTRAPS]
+        /// by hand, and any other would pass every other check here and
+        /// then fail where it is first reached.
+        ///
+        /// Answers whether the bootstrap is one a device implements, which is
+        /// when its static arguments are worth reading.
+        private boolean checkBootstrap(String sourceMethod, Handle bootstrap) {
+            String owner = bootstrap.getOwner();
+            if (SUPPORTED_BOOTSTRAPS.contains(owner)) {
+                return true;
+            }
+            String name = owner.replace('/', '.');
+            String feature;
+            String advice;
+            if ("java/lang/runtime/ObjectMethods".equals(owner)) {
+                feature = "a record's generated equals, hashCode and toString (invokedynamic through " + name + ")";
+                advice = "A device cannot run them as compiled. Declare equals, hashCode and toString in the record "
+                        + "yourself, or make it a class.";
+            } else if ("java/lang/runtime/SwitchBootstraps".equals(owner)) {
+                feature = "a switch over patterns (invokedynamic through " + name + ")";
+                advice = "A device cannot run it as compiled. Compile for Java 17 (maven.compiler.release 17), or "
+                        + "write the switch as instanceof tests.";
+            } else {
+                feature = "invokedynamic through " + name + "." + bootstrap.getName();
+                advice = "A device cannot run it: only lambdas, method references and string concatenation are "
+                        + "compiled ahead of time.";
+            }
+            if (DESUGARED_BOOTSTRAPS.contains(owner)) {
+                advice += " The build normally rewrites this into plain methods; this class was not rewritten.";
+            }
+            reportLanguage(sourceMethod, "indy " + owner, feature, advice);
+            return false;
+        }
+
+        /// One finding for a feature of the language, once for each method
+        /// it is used in.
+        private void reportLanguage(String sourceMethod, String key, String feature, String advice) {
+            if (!reportedLayerSymbols.add(key + "@" + sourceMethod)) {
+                return;
+            }
+            Violation v = new Violation(className, sourceMethod, feature + " is not supported on a device", advice,
+                    relativePath(), sourceFile, currentLine);
+            v.language = true;
+            v.api = feature;
+            violations.add(v);
+        }
+
+        /// A constant computed by a bootstrap method the first time it is
+        /// loaded. No translator computes one, whatever the bootstrap.
+        private void reportDynamicConstant(String sourceMethod, ConstantDynamic constant) {
+            Handle bootstrap = constant.getBootstrapMethod();
+            String name = bootstrap.getOwner().replace('/', '.') + "." + bootstrap.getName();
+            reportLanguage(sourceMethod, "condy " + name, "a dynamic constant (computed by " + name + ")",
+                    "A device cannot compute a constant at run time. Compile for Java 17 "
+                            + "(maven.compiler.release 17) or write the value out.");
+        }
+
+        /// What a supported bootstrap is handed: the method a lambda or a
+        /// method reference runs is named here and in no instruction, so a
+        /// reference to API a device lacks would otherwise pass. A layer's own
+        /// classes are left to the wider scan, which reports them under the
+        /// name the application used.
+        private void checkBootstrapArgument(String sourceMethod, Object argument) {
+            if (argument instanceof ConstantDynamic) {
+                reportDynamicConstant(sourceMethod, (ConstantDynamic) argument);
+            } else if (argument instanceof Handle) {
+                Handle handle = (Handle) argument;
+                String owner = handle.getOwner();
+                if (layerOf(owner) != null || owner.equals(className)) {
+                    // A layer's member is checked with the layer's own
+                    // rules below, and a handle on this class is the body of
+                    // a lambda: a method of this file, read like the rest.
+                    return;
+                }
+                if (handle.getTag() >= Opcodes.H_INVOKEVIRTUAL) {
+                    checkMethodReference(className, sourceMethod, owner, handle.getName(), handle.getDesc());
+                } else {
+                    checkFieldReference(className, sourceMethod, owner, handle.getName(), handle.getDesc());
+                }
+            } else if (argument instanceof Type) {
+                Type type = (Type) argument;
+                if (type.getSort() == Type.METHOD) {
+                    for (Type parameter : type.getArgumentTypes()) {
+                        checkBootstrapType(sourceMethod, parameter);
+                    }
+                    checkBootstrapType(sourceMethod, type.getReturnType());
+                } else {
+                    checkBootstrapType(sourceMethod, type);
+                }
+            }
+        }
+
+        private void checkBootstrapType(String sourceMethod, Type type) {
+            Type element = type.getSort() == Type.ARRAY ? type.getElementType() : type;
+            if (element.getSort() == Type.OBJECT && layerOf(element.getInternalName()) == null) {
+                checkTypeReference(className, sourceMethod, element.getInternalName());
+            }
+        }
+
         private void checkMethodReference(String sourceClass, String sourceMethod, String owner, String memberName, String memberDescriptor) {
-            if (shouldAllowMethod(owner, memberName, memberDescriptor)) {
+            boolean allowed = shouldAllowMethod(owner, memberName, memberDescriptor);
+            countToolkit(owner, allowed);
+            if (allowed) {
+                return;
+            }
+            if (reportLayerMember(sourceMethod, owner, memberName, memberDescriptor, true)) {
                 return;
             }
-            addViolation(sourceClass, sourceMethod, owner + "#" + memberName + memberDescriptor);
+            addViolation(sourceClass, sourceMethod, owner, owner + "#" + memberName + memberDescriptor)
+                    .names(originalName(owner), javaMember(owner, memberName, memberDescriptor, true),
+                            lookupKey(owner, memberName));
         }
 
         private void checkFieldReference(String sourceClass, String sourceMethod, String owner, String memberName, String memberDescriptor) {
-            if (shouldAllowField(owner, memberName, memberDescriptor)) {
+            boolean allowed = shouldAllowField(owner, memberName, memberDescriptor);
+            countToolkit(owner, allowed);
+            if (allowed) {
+                return;
+            }
+            if (reportLayerMember(sourceMethod, owner, memberName, memberDescriptor, false)) {
                 return;
             }
-            addViolation(sourceClass, sourceMethod, owner + "#" + memberName + ":" + memberDescriptor);
+            addViolation(sourceClass, sourceMethod, owner, owner + "#" + memberName + ":" + memberDescriptor)
+                    .names(originalName(owner), javaMember(owner, memberName, memberDescriptor, false),
+                            lookupKey(owner, memberName));
+        }
+
+        /// `java.lang.Runtime.exec` for a member, and the class alone for a
+        /// constructor: what the alternatives table is looked up by.
+        private String lookupKey(String owner, String memberName) {
+            String name = javaName(owner);
+            return "<init>".equals(memberName) || "<clinit>".equals(memberName) ? name : name + "." + memberName;
         }
 
         private void checkTypeReference(String sourceClass, String sourceMethod, String owner) {
             if (isArrayDescriptor(owner)) {
+                // An array of a layer's class is still a reference to the
+                // class; of anything else it was never examined.
+                if (!layers.isEmpty()) {
+                    checkLayerType(sourceMethod, owner, null);
+                }
                 if (backendCheck) checkDescriptor(sourceMethod, owner);
                 return;
             }
             if (isInternalRewriteHelper(owner)) {
                 return;
             }
-            if (projectAndDependencyIndex.containsKey(owner) || allowedIndex.containsKey(owner)
-                    || isPendingProjectClass(owner)) {
+            boolean known = isKnownClass(owner);
+            countToolkit(owner, known);
+            if (known) {
+                return;
+            }
+            Relocation layer = layerOf(owner);
+            if (layer != null) {
+                reportLayerSymbol(sourceMethod, layer, owner, javaName(owner), null);
                 return;
             }
-            addViolation(sourceClass, sourceMethod, owner + " (type)");
+            addViolation(sourceClass, sourceMethod, owner, owner + " (type)")
+                    .names(originalName(owner), javaName(owner), javaName(owner));
         }
 
-        private void addViolation(String sourceClass, String sourceMethod, String referencedMember) {
+        private boolean isKnownClass(String internalName) {
+            ClassMetadata project = projectAndDependencyIndex.get(internalName);
+            if (project != null) {
+                return !project.linkOnly || linksAgainstLinkOnly();
+            }
+            return allowedIndex.containsKey(internalName) || isPendingProjectClass(internalName);
+        }
+
+        /// Whether the class being scanned may name a `@LinkOnly` class: a
+        /// layer's own runtime, which declares them, and a library that was
+        /// bundled whole, which is who they exist for. The application's own
+        /// classes may not -- to them such a class is API that does not work,
+        /// and it is reported like any other the layer lacks.
+        private boolean linksAgainstLinkOnly() {
+            return className != null
+                    && (CompatLayers.isExtractedRuntime(className) || libraryOrigins.containsKey(className));
+        }
+
+        private String relativePath() {
             String relativePath = classFile.getAbsolutePath().replace(outputDir.getAbsolutePath(), "");
             if (relativePath.startsWith(File.separator)) {
                 relativePath = relativePath.substring(1);
             }
-            violations.add(new Violation(sourceClass, sourceMethod, referencedMember, replacementFor(referencedMember), relativePath));
+            return relativePath;
+        }
+
+        private Violation addViolation(String sourceClass, String sourceMethod, String owner, String referencedMember) {
+            Violation v = new Violation(sourceClass, sourceMethod, referencedMember,
+                    replacementFor(referencedMember, owner, layers), relativePath(), sourceFile, currentLine);
+            violations.add(v);
+            return v;
+        }
+
+        /// The active layer whose relocated packages `internalName` is in, or
+        /// null: the references the wider scan applies to.
+        private Relocation layerOf(String internalName) {
+            if (internalName == null) {
+                return null;
+            }
+            for (Relocation layer : layers) {
+                if (layer.original(internalName) != null) {
+                    return layer;
+                }
+            }
+            return null;
+        }
+
+        /// Records that `api` is missing from `layer`. `declared` is non-null
+        /// for a reference made by a declaration rather than by an
+        /// instruction; such a reference is held in `declaredLayerSymbols`.
+        private void reportLayerSymbol(String sourceMethod, Relocation layer, String symbol, String api,
+                                       List<DeclaredSymbol> declared) {
+            String message = api + " is not supported by the Codename One " + layer.name() + " compatibility layer";
+            int member = symbol.indexOf('#');
+            String owner = originalName(member < 0 ? symbol : symbol.substring(0, member));
+            if (declared != null) {
+                if (!declaredLayerSymbols.containsKey(symbol)) {
+                    DeclaredSymbol d = new DeclaredSymbol(sourceMethod, message);
+                    d.owner = owner;
+                    d.api = api;
+                    declaredLayerSymbols.put(symbol, d);
+                    declared.add(d);
+                }
+                return;
+            }
+            if (!reportedLayerSymbols.add(symbol + "@" + currentLine)) {
+                return;
+            }
+            reportedLayerSymbols.add(symbol);
+            Violation v = new Violation(className, sourceMethod, message, null, relativePath(), sourceFile,
+                    currentLine);
+            violations.add(v.names(owner, api, apiKey(api)));
+        }
+
+        /// Reports an unresolved member whose owner is a layer's class, and
+        /// answers whether it was one. A class the layer lacks altogether is
+        /// reported as the class: its constructor and every method called on
+        /// it would otherwise each say the same thing.
+        private boolean reportLayerMember(String sourceMethod, String owner, String memberName, String memberDescriptor,
+                                          boolean method) {
+            Relocation layer = layerOf(owner);
+            if (layer == null) {
+                return false;
+            }
+            if (!isKnownClass(owner)) {
+                reportLayerSymbol(sourceMethod, layer, owner, javaName(owner), null);
+            } else {
+                reportLayerSymbol(sourceMethod, layer, owner + "#" + memberName + (method ? "" : ":") + memberDescriptor,
+                        javaMember(owner, memberName, memberDescriptor, method), null);
+            }
+            return true;
+        }
+
+        /// `type` is an internal name or an array descriptor.
+        private void checkLayerType(String sourceMethod, String type, List<DeclaredSymbol> declared) {
+            if (type == null) {
+                return;
+            }
+            String name = type;
+            if (isArrayDescriptor(type)) {
+                Type element = Type.getType(type).getElementType();
+                if (element.getSort() != Type.OBJECT) {
+                    return;
+                }
+                name = element.getInternalName();
+            }
+            Relocation layer = layerOf(name);
+            if (layer != null && !isKnownClass(name)) {
+                reportLayerSymbol(sourceMethod, layer, name, javaName(name), declared);
+            }
+        }
+
+        /// Every class a field or method descriptor names.
+        private void checkLayerDescriptor(String sourceMethod, String descriptor, List<DeclaredSymbol> declared) {
+            Type type = Type.getType(descriptor);
+            if (type.getSort() == Type.METHOD) {
+                for (Type argument : type.getArgumentTypes()) {
+                    checkLayerValueType(sourceMethod, argument, declared);
+                }
+                checkLayerValueType(sourceMethod, type.getReturnType(), declared);
+            } else {
+                checkLayerValueType(sourceMethod, type, declared);
+            }
+        }
+
+        private void checkLayerValueType(String sourceMethod, Type type, List<DeclaredSymbol> declared) {
+            Type element = type.getSort() == Type.ARRAY ? type.getElementType() : type;
+            if (element.getSort() == Type.OBJECT) {
+                checkLayerType(sourceMethod, element.getInternalName(), declared);
+            }
+        }
+
+        /// A constant-pool value an instruction loads: a class, a method type,
+        /// a method handle or a dynamic constant. Anything else names no class.
+        private void checkLayerConstant(String sourceMethod, Object value) {
+            if (value instanceof Type) {
+                checkLayerDescriptor(sourceMethod, ((Type) value).getDescriptor(), null);
+            } else if (value instanceof Handle) {
+                checkLayerHandle(sourceMethod, (Handle) value);
+            } else if (value instanceof ConstantDynamic) {
+                ConstantDynamic constant = (ConstantDynamic) value;
+                checkLayerDescriptor(sourceMethod, constant.getDescriptor(), null);
+                for (int i = 0; i < constant.getBootstrapMethodArgumentCount(); i++) {
+                    checkLayerConstant(sourceMethod, constant.getBootstrapMethodArgument(i));
+                }
+            }
+        }
+
+        /// A method handle is a call or field access spelled as a constant:
+        /// `JTable::setAutoCreateRowSorter` reaches the method through one and
+        /// through no method instruction.
+        private void checkLayerHandle(String sourceMethod, Handle handle) {
+            String owner = handle.getOwner();
+            boolean method = handle.getTag() >= Opcodes.H_INVOKEVIRTUAL;
+            if (!isArrayDescriptor(owner) && layerOf(owner) != null
+                    && !resolveMember(owner, memberKey(handle.getName(), handle.getDesc()), method)) {
+                reportLayerMember(sourceMethod, owner, handle.getName(), handle.getDesc(), method);
+            }
+            checkLayerDescriptor(sourceMethod, handle.getDesc(), null);
+        }
+
+        /// A lambda implements one method of the interface its `invokedynamic`
+        /// returns. The interface existing is not enough: the layer's version
+        /// has to declare that method, or the lambda can never be called.
+        private void checkFunctionalInterfaceMethod(String sourceMethod, String methodName, String indyDescriptor,
+                                                    Handle bootstrap, Object[] bootstrapArguments) {
+            if (!"java/lang/invoke/LambdaMetafactory".equals(bootstrap.getOwner()) || bootstrapArguments.length == 0
+                    || !(bootstrapArguments[0] instanceof Type)) {
+                return;
+            }
+            Type functional = Type.getReturnType(indyDescriptor);
+            Type implemented = (Type) bootstrapArguments[0];
+            if (functional.getSort() != Type.OBJECT || implemented.getSort() != Type.METHOD) {
+                return;
+            }
+            String owner = functional.getInternalName();
+            if (layerOf(owner) != null && isKnownClass(owner)
+                    && !resolveMember(owner, memberKey(methodName, implemented.getDescriptor()), true)) {
+                reportLayerMember(sourceMethod, owner, methodName, implemented.getDescriptor(), true);
+            }
+        }
+
+        /// `javax.swing.JTable` for the internal name the class ships under.
+        private String javaName(String internalName) {
+            return originalName(internalName).replace('/', '.').replace('$', '.');
+        }
+
+        /// `javax/swing/JTable` for the internal name the class ships
+        /// under: the name the application was compiled against.
+        private String originalName(String internalName) {
+            String original = layerNames.original(internalName);
+            for (String[] shim : Relocation.JDK_SHIMS) {
+                if (shim[1].equals(original)) {
+                    return shim[0];
+                }
+            }
+            return original;
+        }
+
+        private String javaTypeName(Type type) {
+            if (type.getSort() == Type.ARRAY) {
+                StringBuilder sb = new StringBuilder(javaTypeName(type.getElementType()));
+                for (int i = 0; i < type.getDimensions(); i++) {
+                    sb.append("[]");
+                }
+                return sb.toString();
+            }
+            return type.getSort() == Type.OBJECT ? javaName(type.getInternalName()) : type.getClassName();
+        }
+
+        /// The member as its documentation spells it:
+        /// `javax.swing.JTable.setAutoCreateRowSorter(boolean)`,
+        /// `new javax.swing.JTable(int, int)`, `javax.swing.JTable.AUTO_RESIZE_OFF`.
+        private String javaMember(String owner, String memberName, String memberDescriptor, boolean method) {
+            String ownerName = javaName(owner);
+            if (!method) {
+                return ownerName + "." + memberName;
+            }
+            StringBuilder sb = new StringBuilder();
+            if ("<init>".equals(memberName)) {
+                sb.append("new ").append(ownerName);
+            } else {
+                sb.append(ownerName).append('.').append(memberName);
+            }
+            sb.append('(');
+            Type[] arguments = Type.getArgumentTypes(memberDescriptor);
+            for (int i = 0; i < arguments.length; i++) {
+                sb.append(i == 0 ? "" : ", ").append(javaTypeName(arguments[i]));
+            }
+            return sb.append(')').toString();
         }
 
         private boolean shouldAllowMethod(String owner, String name, String descriptor) {
@@ -1519,41 +2348,135 @@ private static boolean isInternalRewriteHelper(String owner) {
         return JDK_API_REWRITE_HELPER_INTERNAL_NAME.equals(owner);
     }
 
-    private static String replacementFor(String referencedMember) {
+    /// The advice printed beside a violation, or null. `owner` is the class
+    /// the reference names. A class of a compatibility layer's API that
+    /// arrives here unrelocated belongs to a project that has not switched
+    /// the layer on; the wording for that is [CompatLayers#enableHint].
+    private static String replacementFor(String referencedMember, String owner, List<Relocation> active) {
         String direct = SUGGESTED_REPLACEMENTS.get(referencedMember);
         if (direct != null) {
             return direct;
         }
-        int hashPos = referencedMember.indexOf('#');
-        if (hashPos > 0) {
-            String ownerOnly = referencedMember.substring(0, hashPos);
-            if (ownerOnly.startsWith("java/awt/") || ownerOnly.startsWith("javax/swing/")) {
-                return "Codename One does not support AWT/Swing APIs. Use com.codename1.ui components for UI logic.";
+        if (owner != null) {
+            Relocation layer = CompatLayers.owning(owner);
+            if (layer != null && !active.contains(layer)) {
+                return CompatLayers.enableHint(layer);
             }
         }
         return null;
     }
 
+    /// `javax.swing.JTable.print` for the API `javax.swing.JTable.print()`,
+    /// and `javax.swing.JTable` for `new javax.swing.JTable(int, int)`: the
+    /// API without its parameters, which is what the alternatives table is
+    /// looked up by.
+    static String apiKey(String api) {
+        if (api == null) {
+            return null;
+        }
+        String key = api.startsWith("new ") ? api.substring("new ".length()) : api;
+        int paren = key.indexOf('(');
+        return paren < 0 ? key : key.substring(0, paren);
+    }
+
+    /// The path of `internalName`'s package, with the trailing slash.
+    private static String packagePath(String internalName) {
+        int slash = internalName.lastIndexOf('/');
+        return slash < 0 ? "" : internalName.substring(0, slash + 1);
+    }
+
+    /// A reference missing from a declaration, held back until the class has
+    /// been read; see `ComplianceScanner`.
+    private static final class DeclaredSymbol {
+        private final String sourceMethod;
+        private final String message;
+        private int line;
+        private String owner;
+        private String api;
+
+        private DeclaredSymbol(String sourceMethod, String message) {
+            this.sourceMethod = sourceMethod;
+            this.message = message;
+        }
+    }
+
     private static final class Violation {
         private final String sourceClass;
         private final String sourceMethod;
         private final String referencedMember;
         private final String suggestion;
         private final String sourcePath;
+        /// The source file the class was compiled from and the line of the
+        /// reference, when the class carries debug information: null and 0
+        /// otherwise, each on its own.
+        private final String sourceFile;
+        private final int line;
+        /// The bundled library jar the class came from, or null for a class
+        /// of the application's own.
+        private String library;
+        /// What the reference is to, for the grouped report: the class it
+        /// belongs to as the application was compiled against it (an
+        /// internal name), the API as its documentation spells it, and the
+        /// key the alternatives table is looked up by. All null for a
+        /// finding that names no API.
+        private String owner;
+        private String api;
+        private String key;
+        /// Whether the finding is a language feature rather than an API.
+        private boolean language;
+
+        private Violation names(String owner, String api, String key) {
+            this.owner = owner;
+            this.api = api;
+            this.key = key;
+            return this;
+        }
+
+        /// The source file from the source root, or the class file when the
+        /// class says nothing about its source.
+        private String file() {
+            if (sourceFile == null || sourceFile.isEmpty()) {
+                return sourcePath == null ? sourceClass : sourcePath.replace(File.separatorChar, '/');
+            }
+            return packagePath(sourceClass.replace('.', '/')) + sourceFile;
+        }
 
         private Violation(String sourceClass, String sourceMethod, String referencedMember, String suggestion, String sourcePath) {
+            this(sourceClass, sourceMethod, referencedMember, suggestion, sourcePath, null, 0);
+        }
+
+        private Violation(String sourceClass, String sourceMethod, String referencedMember, String suggestion, String sourcePath,
+                          String sourceFile, int line) {
             this.sourceClass = sourceClass;
             this.sourceMethod = sourceMethod;
             this.referencedMember = referencedMember;
             this.suggestion = suggestion;
             this.sourcePath = sourcePath;
+            this.sourceFile = sourceFile;
+            this.line = line;
+        }
+
+        /// `Foo.java:123`, `Foo.java` when only the file is known, else null.
+        private String location() {
+            if (sourceFile == null || sourceFile.isEmpty()) {
+                return null;
+            }
+            return line > 0 ? sourceFile + ":" + line : sourceFile;
         }
 
         private String render() {
             StringBuilder sb = new StringBuilder();
             sb.append("Source class: ").append(sourceClass).append("\n");
             sb.append("Source method: ").append(sourceMethod).append("\n");
+            String location = location();
+            if (location != null) {
+                sb.append("Source location: ").append(location).append("\n");
+            }
             sb.append("Source bytecode file: ").append(sourcePath).append("\n");
+            if (library != null) {
+                sb.append("Source library: ").append(library).append(" (").append(CompatLibraries.origin(library))
+                        .append(")\n");
+            }
             sb.append("Forbidden reference: ").append(referencedMember);
             if (suggestion != null && !suggestion.isEmpty()) {
                 sb.append("\nSuggested replacement: ").append(suggestion);
@@ -1566,6 +2489,13 @@ private String renderInline() {
             sb.append(sourceClass).append("#").append(sourceMethod)
                     .append(" -> ").append(referencedMember)
                     .append(" (").append(sourcePath).append(")");
+            if (library != null) {
+                sb.append(" ").append(CompatLibraries.origin(library));
+            }
+            String location = location();
+            if (location != null) {
+                sb.append(" at ").append(location);
+            }
             if (suggestion != null && !suggestion.isEmpty()) {
                 sb.append(" Suggestion: ").append(suggestion);
             }
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ClassRelocator.java b/maven/build-engine/src/main/java/com/codename1/maven/ClassRelocator.java
new file mode 100644
index 00000000000..484c28452f1
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ClassRelocator.java
@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/// Rewrites compiled classes by the rules of one or more [Relocation]s.
+///
+/// Several layers can be active in one application -- Android sources beside
+/// Swing ones -- and they are applied as ONE pass with the union of their
+/// rules. Running a pass per layer would have each walk the other's relocated
+/// runtime, and every layer redirects the same few JDK classes.
+public final class ClassRelocator {
+
+    private final List<Relocation> relocations;
+    /// Whether a desktop layer is among them, which is what switches on the
+    /// member rewrites of [CompatRewrites].
+    private final boolean desktop;
+    /// Entries of a runtime jar that are not copied, because the build
+    /// generates the class of that name itself.
+    private final Set<String> generated = new LinkedHashSet<String>();
+    private final Remapper remapper = new Remapper() {
+        @Override
+        public String map(String internalName) {
+            return ClassRelocator.this.map(internalName);
+        }
+    };
+
+    public ClassRelocator(List<Relocation> relocations) {
+        this.relocations = Collections.unmodifiableList(new ArrayList<Relocation>(relocations));
+        boolean anyDesktop = false;
+        for (Relocation r : this.relocations) {
+            anyDesktop = anyDesktop || r.isDesktop();
+        }
+        this.desktop = anyDesktop;
+    }
+
+    /// Whether one of the layers is a desktop one (Swing, JavaFX).
+    public boolean hasDesktopLayer() {
+        return desktop;
+    }
+
+    /// Declares that the build generates the class `internalName` itself, so
+    /// [#extractRuntime] leaves the placeholder a runtime jar carries under
+    /// that name out. Without this the extraction and the generator would
+    /// each overwrite the other's file on every run.
+    ClassRelocator generating(String internalName) {
+        generated.add(internalName + ".class");
+        return this;
+    }
+
+    public ClassRelocator(Relocation... relocations) {
+        this(Arrays.asList(relocations));
+    }
+
+    public List<Relocation> relocations() {
+        return relocations;
+    }
+
+    /// The relocated internal name, or `name` unchanged.
+    public String map(String name) {
+        if (name == null) {
+            return null;
+        }
+        for (Relocation r : relocations) {
+            String shim = r.shim(name);
+            if (shim != null) {
+                return shim;
+            }
+        }
+        for (Relocation r : relocations) {
+            String moved = r.relocate(name);
+            if (moved != null) {
+                return moved;
+            }
+        }
+        return name;
+    }
+
+    /// The name the application was compiled against, or `relocated`
+    /// unchanged when no layer produced it.
+    public String original(String relocated) {
+        for (Relocation r : relocations) {
+            String o = r.original(relocated);
+            if (o != null) {
+                return o;
+            }
+        }
+        return relocated;
+    }
+
+    /// The layer whose runtime `jar` is, or null.
+    public Relocation layerOf(File jar) {
+        for (Relocation r : relocations) {
+            if (r.isRuntimeJar(jar.getName())) {
+                return r;
+            }
+        }
+        return null;
+    }
+
+    public Remapper remapper() {
+        return remapper;
+    }
+
+    public byte[] remap(byte[] in) {
+        ClassReader cr = new ClassReader(in);
+        ClassWriter cw = new ClassWriter(0);
+        ClassVisitor chain = new ClassRemapper(new PostRemapFixes(cw), remapper);
+        if (desktop) {
+            // Ahead of the relocation: the rules name what an application
+            // is compiled against.
+            chain = CompatRewrites.visitor(new MainRenamer(chain));
+        }
+        // First of all, so that what it generates is rewritten and relocated
+        // like the code javac wrote.
+        cr.accept(new RecordDesugar(chain), 0);
+        return cw.toByteArray();
+    }
+
+    /// The name a desktop application's `main(String[])` ships under.
+    ///
+    /// Every desktop application declares a `main`, and often several: one per
+    /// launcher, one in a demo class of a library. ParparVM takes the class
+    /// holding a static `main` with one array argument to be THE entry point
+    /// of the program and refuses a second one outright
+    /// (`Multiple main classes: ...Stub and ...`), so an imported application
+    /// failed its translation for iOS, macOS, Windows and Linux before a line
+    /// of it was translated; only the JavaScript target, which names its main
+    /// class to the translator, built. Nothing on a device calls `main` by
+    /// that name -- the application's Codename One main class is what starts
+    /// it, by calling the desktop `main` from source -- so the method is
+    /// renamed here, together with every call of it (that one included), and
+    /// the name ParparVM reserves stays the stub's.
+    static final String DESKTOP_MAIN = "cn1DesktopMain";
+
+    /// The descriptor of a `main(String[])`.
+    static final String MAIN_DESCRIPTOR = "([Ljava/lang/String;)V";
+
+    /// Renames every static `main(String[])` to [#DESKTOP_MAIN], and every
+    /// static call or method reference that names one. Applied to each class
+    /// of a build with a desktop layer, so a declaration and its callers move
+    /// together; running it again over its own output changes nothing.
+    private static final class MainRenamer extends ClassVisitor {
+
+        MainRenamer(ClassVisitor next) {
+            super(Opcodes.ASM9, next);
+        }
+
+        private static String rename(String name, String descriptor) {
+            return "main".equals(name) && MAIN_DESCRIPTOR.equals(descriptor) ? DESKTOP_MAIN : name;
+        }
+
+        private static Object rename(Object argument) {
+            if (argument instanceof Handle) {
+                Handle h = (Handle) argument;
+                if (h.getTag() == Opcodes.H_INVOKESTATIC) {
+                    return new Handle(h.getTag(), h.getOwner(), rename(h.getName(), h.getDesc()), h.getDesc(),
+                            h.isInterface());
+                }
+            }
+            return argument;
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                                         String[] exceptions) {
+            String shipped = (access & Opcodes.ACC_STATIC) != 0 ? rename(name, descriptor) : name;
+            MethodVisitor mv = super.visitMethod(access, shipped, descriptor, signature, exceptions);
+            if (mv == null) {
+                return null;
+            }
+            return new MethodVisitor(Opcodes.ASM9, mv) {
+                @Override
+                public void visitMethodInsn(int opcode, String owner, String n, String d, boolean isInterface) {
+                    super.visitMethodInsn(opcode, owner, opcode == Opcodes.INVOKESTATIC ? rename(n, d) : n, d,
+                            isInterface);
+                }
+
+                @Override
+                public void visitInvokeDynamicInsn(String n, String d, Handle bootstrap, Object... arguments) {
+                    Object[] mapped = new Object[arguments.length];
+                    for (int i = 0; i < arguments.length; i++) {
+                        mapped[i] = rename(arguments[i]);
+                    }
+                    super.visitInvokeDynamicInsn(n, d, bootstrap, mapped);
+                }
+            };
+        }
+    }
+
+    /// What the remapper itself does not cover: two source interfaces can map
+    /// to one target (`Closeable` and `AutoCloseable` both become
+    /// `AutoCloseable`), and a class file that names an interface twice is
+    /// rejected by the JVM; and Kotlin's metadata strings (below).
+    private final class PostRemapFixes extends ClassVisitor {
+        private final Set<String> methods = new LinkedHashSet<String>();
+        private String className;
+
+        PostRemapFixes(ClassVisitor next) {
+            super(Opcodes.ASM9, next);
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName,
+                          String[] interfaces) {
+            className = name;
+            String[] distinct = interfaces;
+            if (interfaces != null && interfaces.length > 1) {
+                Set<String> seen = new LinkedHashSet<String>(Arrays.asList(interfaces));
+                if (seen.size() != interfaces.length) {
+                    distinct = seen.toArray(new String[seen.size()]);
+                }
+            }
+            super.visit(version, access, name, signature, superName, distinct);
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String name, String descriptor,
+                                         String signature, String[] exceptions) {
+            if (!methods.add(name + descriptor)) {
+                // The wording predates the other layers and is what an
+                // Android build has always printed; Closeable is the only
+                // rule in any layer that maps two names onto one.
+                throw new IllegalArgumentException("Android remapping collapses overloads in "
+                        + className + ": " + name + descriptor
+                        + ". Rename the overload or use one AutoCloseable signature.");
+            }
+            return super.visitMethod(access, name, descriptor, signature, exceptions);
+        }
+
+        /// Kotlin records the JVM descriptors of a class's members as plain
+        /// strings in `@kotlin.Metadata`'s `d2` array. The remapper never sees
+        /// those, so without this they would keep naming android/... types.
+        @Override
+        public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+            AnnotationVisitor av = super.visitAnnotation(descriptor, visible);
+            if (av == null || !"Lkotlin/Metadata;".equals(descriptor)) {
+                return av;
+            }
+            return new AnnotationVisitor(Opcodes.ASM9, av) {
+                @Override
+                public AnnotationVisitor visitArray(String name) {
+                    AnnotationVisitor array = super.visitArray(name);
+                    if (array == null || !"d2".equals(name)) {
+                        return array;
+                    }
+                    return new AnnotationVisitor(Opcodes.ASM9, array) {
+                        @Override
+                        public void visit(String n, Object value) {
+                            super.visit(n, value instanceof String ? mapMetadataString((String) value) : value);
+                        }
+                    };
+                }
+            };
+        }
+    }
+
+    /// A `kotlin.Metadata` string: a method or field descriptor, or a name
+    /// that is left alone.
+    String mapMetadataString(String s) {
+        if (s.length() == 0) {
+            return s;
+        }
+        try {
+            if (s.charAt(0) == '(') {
+                return remapper.mapMethodDesc(s);
+            }
+            if ((s.charAt(0) == 'L' && s.endsWith(";")) || s.charAt(0) == '[') {
+                return remapper.mapDesc(s);
+            }
+        } catch (RuntimeException e) {
+            // Not a descriptor after all (a name that happens to start with
+            // L or a bracket): keep it as written.
+            return s;
+        }
+        return s;
+    }
+
+    /// Relocates every class under `classesDir` in place, adding each one's
+    /// final internal name to `out`. Directories holding a runtime this
+    /// relocator already extracted are not application code and are skipped.
+    public void remapDirectory(File classesDir, List<String> out, Log log) throws IOException {
+        remapDirectory(classesDir, classesDir, out, log);
+    }
+
+    private void remapDirectory(File classesDir, File dir, List<String> out, Log log) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                if (isShipped(relative(classesDir, f) + "/")) {
+                    continue;
+                }
+                remapDirectory(classesDir, f, out, log);
+            } else if (f.getName().endsWith(".class")) {
+                byte[] in = Files.readAllBytes(f.toPath());
+                byte[] remapped = remap(in);
+                String name = relative(classesDir, f);
+                name = name.substring(0, name.length() - ".class".length());
+                String mapped = map(name);
+                if (!mapped.equals(name)) {
+                    // Application code inside a relocated package (a support
+                    // shim the app carries itself) moves with the rest.
+                    File dest = new File(classesDir, mapped + ".class");
+                    dest.getParentFile().mkdirs();
+                    write(dest, remapped);
+                    if (!f.delete()) {
+                        log.warn("Could not delete " + f);
+                    }
+                    out.add(mapped);
+                } else {
+                    if (!Arrays.equals(in, remapped)) {
+                        write(f, remapped);
+                    }
+                    out.add(name);
+                }
+            }
+        }
+    }
+
+    /// Whether `rel` (a directory, with its trailing slash) is where some
+    /// active layer's runtime was extracted.
+    private boolean isShipped(String rel) {
+        for (Relocation r : relocations) {
+            if (rel.startsWith(r.target())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String relative(File classesDir, File f) {
+        String base = classesDir.getAbsolutePath();
+        String p = f.getAbsolutePath();
+        return p.substring(base.length() + 1).replace(File.separatorChar, '/');
+    }
+
+    /// `dest` when it lies inside the classes directory. An entry name with
+    /// `..` (or an absolute one) would write elsewhere; a runtime jar never
+    /// has one, so meeting one means the artifact is not what it should be.
+    private static File inside(File classesDir, File jar, File dest, String entry) throws IOException {
+        String root = classesDir.getCanonicalPath() + File.separator;
+        if (!dest.getCanonicalPath().startsWith(root)) {
+            throw new IOException(jar + " entry " + entry + " resolves outside " + classesDir);
+        }
+        return dest;
+    }
+
+    /// Copies a runtime jar's classes into `classesDir`, relocated, and its
+    /// other entries as they are. Answers the number of classes.
+    ///
+    /// What an earlier build copied from this runtime and this one did not
+    /// -- a class a newer version of the runtime no longer has -- is
+    /// removed: see [#runtimeRecord].
+    public int extractRuntime(File jar, File classesDir) throws IOException {
+        int count = 0;
+        Map<String, String> copied = new TreeMap<String, String>();
+        ZipFile zip = new ZipFile(jar);
+        try {
+            Enumeration<? extends ZipEntry> en = zip.entries();
+            while (en.hasMoreElements()) {
+                ZipEntry e = en.nextElement();
+                String name = e.getName();
+                if (e.isDirectory() || name.startsWith("META-INF/") || generated.contains(name)) {
+                    continue;
+                }
+                byte[] data = read(zip.getInputStream(e));
+                String path = name;
+                if (name.endsWith(".class")) {
+                    String cls = name.substring(0, name.length() - ".class".length());
+                    path = map(cls) + ".class";
+                    data = remap(data);
+                    count++;
+                }
+                // Resource tables and assets are compared byte for byte
+                // too: a rebuilt table routinely keeps its length while
+                // its contents change, and a length check alone kept the
+                // previous runtime's copy.
+                writeIfDifferent(inside(classesDir, jar, new File(classesDir, path), name), data);
+                copied.put(path, checksum(data));
+            }
+        } finally {
+            zip.close();
+        }
+        forgetStale(jar, classesDir, copied);
+        return count;
+    }
+
+    /// Where the list of what [#extractRuntime] copied into `classesDir` is
+    /// kept: beside the directory, not inside it, since it describes a
+    /// build directory and is nothing an application ships.
+    ///
+    /// #### Why there is a list
+    ///
+    /// An incremental build copies a runtime over the copy the build before
+    /// it left, and a class the runtime has since dropped or renamed was
+    /// never among the entries to copy, so it stayed: dead weight at best,
+    /// and at worst a class that names a member the new runtime no longer
+    /// has, which fails the compliance check in a file nobody wrote. With
+    /// the list, what the last build copied from a runtime and this one did
+    /// not is deleted.
+    ///
+    /// A file is deleted only while it is still the bytes that were copied.
+    /// One that has changed is someone else's by now -- an application that
+    /// carries the class itself, a resource of its own under the same name
+    /// -- and is left.
+    ///
+    /// #### What it does not do
+    ///
+    /// It is kept per runtime, so a layer that is no longer active is not
+    /// cleaned out: its section is simply not visited. That is deliberate.
+    /// The classes the build generated for that layer (an entry point, the
+    /// compiled FXML documents, the dispatch tables) name its runtime, and
+    /// they are not in any list; deleting the runtime from under them
+    /// would turn a stale directory that still builds into one that fails.
+    /// Dropping a layer takes a clean build, as dropping any dependency
+    /// from a directory of compiled classes does.
+    static File runtimeRecord(File classesDir) {
+        File dir = classesDir.getAbsoluteFile();
+        return new File(dir.getParentFile(), dir.getName() + ".cn1-compat-runtime.txt");
+    }
+
+    private static final String RUNTIME = "runtime\t";
+
+    /// What names a runtime from one build to the next: its jar's file name
+    /// without the version, which is what changes when the runtime does.
+    static String runtimeKey(File jar) {
+        String name = jar.getName();
+        if (name.endsWith(".jar")) {
+            name = name.substring(0, name.length() - ".jar".length());
+        }
+        for (int i = 0; i + 1 < name.length(); i++) {
+            if (name.charAt(i) == '-' && name.charAt(i + 1) >= '0' && name.charAt(i + 1) <= '9') {
+                return name.substring(0, i);
+            }
+        }
+        return name;
+    }
+
+    private static String checksum(byte[] data) {
+        CRC32 crc = new CRC32();
+        crc.update(data, 0, data.length);
+        return data.length + ":" + Long.toHexString(crc.getValue());
+    }
+
+    /// Deletes what the record says the last build copied from `jar`'s
+    /// runtime and `copied` -- path to checksum, this build's -- does not
+    /// hold, and records `copied` in its place.
+    private static void forgetStale(File jar, File classesDir, Map<String, String> copied) throws IOException {
+        File record = runtimeRecord(classesDir);
+        String key = runtimeKey(jar);
+        // Every runtime's files, by the runtime's key, in the record's order.
+        Map<String, Map<String, String>> all = new LinkedHashMap<String, Map<String, String>>();
+        if (record.isFile()) {
+            Map<String, String> current = null;
+            for (String line : new String(Files.readAllBytes(record.toPath()), StandardCharsets.UTF_8).split("\n")) {
+                int tab = line.indexOf('\t');
+                if (line.startsWith(RUNTIME)) {
+                    current = new TreeMap<String, String>();
+                    all.put(line.substring(RUNTIME.length()), current);
+                } else if (current != null && tab > 0) {
+                    current.put(line.substring(0, tab), line.substring(tab + 1));
+                }
+            }
+        }
+        Map<String, String> before = all.get(key);
+        if (copied.equals(before)) {
+            return;
+        }
+        all.put(key, copied);
+        if (before != null) {
+            for (Map.Entry<String, String> old : before.entrySet()) {
+                if (!owned(all, old.getKey())) {
+                    deleteIfUnchanged(classesDir, old.getKey(), old.getValue());
+                }
+            }
+        }
+        StringBuilder text = new StringBuilder();
+        for (Map.Entry<String, Map<String, String>> runtime : all.entrySet()) {
+            text.append(RUNTIME).append(runtime.getKey()).append('\n');
+            for (Map.Entry<String, String> file : runtime.getValue().entrySet()) {
+                text.append(file.getKey()).append('\t').append(file.getValue()).append('\n');
+            }
+        }
+        writeIfDifferent(record, text.toString().getBytes(StandardCharsets.UTF_8));
+    }
+
+    /// Whether some runtime's current list holds `path`: two runtimes can
+    /// ship one file, and a class can move from one to the other.
+    private static boolean owned(Map<String, Map<String, String>> all, String path) {
+        for (Map<String, String> files : all.values()) {
+            if (files.containsKey(path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void deleteIfUnchanged(File classesDir, String path, String checksum) throws IOException {
+        File stale = new File(classesDir, path);
+        String root = classesDir.getCanonicalPath() + File.separator;
+        if (!stale.isFile() || !stale.getCanonicalPath().startsWith(root)
+                || !checksum.equals(checksum(Files.readAllBytes(stale.toPath())))) {
+            return;
+        }
+        if (!stale.delete()) {
+            throw new IOException("Could not delete " + stale);
+        }
+        // And the directories it leaves empty, up to the classes directory.
+        File dir = stale.getParentFile();
+        File top = classesDir.getCanonicalFile();
+        while (dir != null && !dir.getCanonicalFile().equals(top)) {
+            String[] left = dir.list();
+            if (left == null || left.length > 0 || !dir.delete()) {
+                break;
+            }
+            dir = dir.getParentFile();
+        }
+    }
+
+    /// Writes `data` to `dest` unless the file already holds exactly those
+    /// bytes, so an incremental build leaves unchanged outputs (and their
+    /// timestamps) alone.
+    static void writeIfDifferent(File dest, byte[] data) throws IOException {
+        if (dest.isFile() && dest.length() == data.length && Arrays.equals(Files.readAllBytes(dest.toPath()), data)) {
+            return;
+        }
+        dest.getParentFile().mkdirs();
+        write(dest, data);
+    }
+
+    static void collectClassFiles(File dir, List<File> out) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                collectClassFiles(f, out);
+            } else if (f.getName().endsWith(".class")) {
+                out.add(f);
+            }
+        }
+    }
+
+    static byte[] read(InputStream in) throws IOException {
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            byte[] buf = new byte[16384];
+            int n;
+            while ((n = in.read(buf)) > 0) {
+                out.write(buf, 0, n);
+            }
+            return out.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    static void write(File f, byte[] data) throws IOException {
+        OutputStream out = new FileOutputStream(f);
+        try {
+            out.write(data);
+        } finally {
+            out.close();
+        }
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/CompatLayers.java b/maven/build-engine/src/main/java/com/codename1/maven/CompatLayers.java
new file mode 100644
index 00000000000..8bfec102289
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/CompatLayers.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/// Every compatibility layer the build knows, and which of them an
+/// application has switched on.
+///
+/// A layer is switched on by its runtime jar being on the compile classpath:
+/// the project templates add that dependency when the layer's source directory
+/// exists, so nothing else has to be configured.
+///
+/// The two desktop layers share one source directory (`src/main/desktop`), so
+/// the templates add both of their jars and cannot know which of them the
+/// sources need. For those the jar is necessary but not sufficient: the
+/// application's compiled classes must also name the layer's API
+/// ([#active(Iterable, Iterable)]). A Swing application therefore does not
+/// ship the JavaFX runtime, and nothing has to be declared for that.
+public final class CompatLayers {
+
+    /// The Swing layer. `java.awt` and `javax.swing` belong to the JDK, so
+    /// unlike the other layers its runtime cannot be authored under the names
+    /// an application compiles against: the application compiles against the
+    /// JDK's own classes, and the runtime jar is written directly under the
+    /// names it ships with. It therefore has no bridge package to move, and
+    /// relocating its jar changes no class name.
+    public static final Relocation SWING = new Relocation("Swing", "codenameone-swing-compat",
+            "com/codename1/desktopcompat/",
+            new String[] {"java/awt/", "javax/swing/", "java/beans/", "javax/accessibility/", "javax/imageio/",
+                "org/jdesktop/", "com/formdev/flatlaf/", "org/fife/"},
+            Relocation.JDK_SHIMS, null, null);
+
+    /// The JavaFX layer, authored under `javafx.*` and relocated like the
+    /// Android one.
+    public static final Relocation JAVAFX = new Relocation("JavaFX", "codenameone-javafx-compat",
+            "com/codename1/fxcompat/", new String[] {"javafx/"}, Relocation.JDK_SHIMS,
+            "com/codename1/fxcompat/runtime/", "com/codename1/fxcompat/rt/");
+
+    /// Every layer, in the order their rules are tried.
+    public static final List<Relocation> ALL = Collections.unmodifiableList(
+            Arrays.asList(AndroidRemapper.RELOCATION, SWING, JAVAFX));
+
+    /// A relocator applying every layer's rules. Their packages are disjoint,
+    /// so it is correct for any class; what it cannot say is which layers an
+    /// application actually ships -- [#active] does.
+    public static final ClassRelocator EVERY = new ClassRelocator(ALL);
+
+    private CompatLayers() {
+    }
+
+    /// The layers whose runtime jar is among `classpath`.
+    public static List<Relocation> active(Iterable<File> classpath) {
+        List<Relocation> out = new ArrayList<Relocation>();
+        for (Relocation r : ALL) {
+            if (runtimeJar(r, classpath) != null) {
+                out.add(r);
+            }
+        }
+        return out;
+    }
+
+    /// Whether `layer` is switched on by its jar alone. The Android layer is:
+    /// its sources have a directory of their own, and the build compiles
+    /// resources and generates classes for it before any class exists to be
+    /// examined. The desktop layers also have to be used.
+    public static boolean activeByPresence(Relocation layer) {
+        return layer != SWING && layer != JAVAFX;
+    }
+
+    /// The layers an application ships: those whose runtime jar is among
+    /// `classpath` and which, unless the jar alone decides
+    /// ([#activeByPresence]), a class under one of `classDirs` refers to.
+    ///
+    /// A reference counts under the name the application was compiled against
+    /// (`javax/swing/JTable`) and under the name it has once relocated, so a
+    /// directory an earlier run already rewrote gives the same answer. The
+    /// runtimes a previous run extracted into a directory are not application
+    /// code and are not read.
+    public static List<Relocation> active(Iterable<File> classpath, Iterable<File> classDirs) throws IOException {
+        List<Relocation> present = active(classpath);
+        List<Relocation> undecided = new ArrayList<Relocation>();
+        for (Relocation r : present) {
+            if (!activeByPresence(r)) {
+                undecided.add(r);
+            }
+        }
+        if (undecided.isEmpty()) {
+            return present;
+        }
+        ReferenceScan scan = new ReferenceScan(undecided);
+        if (classDirs != null) {
+            for (File dir : classDirs) {
+                if (dir != null && dir.isDirectory()) {
+                    scan.directory(dir, "");
+                }
+            }
+        }
+        List<Relocation> out = new ArrayList<Relocation>();
+        for (Relocation r : present) {
+            if (activeByPresence(r) || scan.found.contains(r)) {
+                out.add(r);
+            }
+        }
+        return out;
+    }
+
+    /// Finds which of a set of layers some class refers to, stopping as soon
+    /// as every one of them has been seen.
+    private static final class ReferenceScan extends Remapper {
+        private final List<Relocation> wanted;
+        private final List<Relocation> found = new ArrayList<Relocation>();
+
+        ReferenceScan(List<Relocation> wanted) {
+            this.wanted = wanted;
+        }
+
+        @Override
+        public String map(String internalName) {
+            if (internalName != null) {
+                for (Relocation r : wanted) {
+                    if (!found.contains(r) && (r.owns(internalName) || r.original(internalName) != null)) {
+                        found.add(r);
+                    }
+                }
+            }
+            return internalName;
+        }
+
+        private boolean done() {
+            return found.size() == wanted.size();
+        }
+
+        /// `rel` is the directory's path inside the classes directory, with
+        /// its trailing slash, or empty for the classes directory itself.
+        void directory(File dir, String rel) throws IOException {
+            File[] files = dir.listFiles();
+            if (files == null) {
+                return;
+            }
+            for (File f : files) {
+                if (done()) {
+                    return;
+                }
+                if (f.isDirectory()) {
+                    String child = rel + f.getName() + "/";
+                    if (!isExtractedRuntime(child)) {
+                        directory(f, child);
+                    }
+                } else if (f.getName().endsWith(".class")) {
+                    // Every name a class file holds goes through the remapper:
+                    // supertypes, descriptors, signatures, annotations and
+                    // the instructions' operands alike.
+                    new ClassReader(Files.readAllBytes(f.toPath())).accept(
+                            new ClassRemapper(new ClassWriter(0), this), ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+                }
+            }
+        }
+    }
+
+    /// Whether a class of `jar` refers to one of `layers`: what makes a
+    /// dependency a library written against a desktop toolkit
+    /// ([CompatLibraries]).
+    static boolean jarRefersTo(File jar, List<Relocation> layers) throws IOException {
+        ReferenceScan scan = new ReferenceScan(layers);
+        java.util.zip.ZipFile zip = new java.util.zip.ZipFile(jar);
+        try {
+            java.util.Enumeration<? extends java.util.zip.ZipEntry> entries = zip.entries();
+            while (entries.hasMoreElements() && scan.found.isEmpty()) {
+                java.util.zip.ZipEntry e = entries.nextElement();
+                if (e.isDirectory() || !e.getName().endsWith(".class") || e.getName().startsWith("META-INF/")) {
+                    continue;
+                }
+                java.io.InputStream in = zip.getInputStream(e);
+                try {
+                    new ClassReader(in).accept(new ClassRemapper(new ClassWriter(0), scan),
+                            ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+                } catch (RuntimeException unreadable) {
+                    // A class file newer than this build reads names nothing
+                    // that can be relocated; the compliance check reports it
+                    // if it ever becomes part of the application.
+                    continue;
+                } finally {
+                    in.close();
+                }
+            }
+        } finally {
+            zip.close();
+        }
+        return !scan.found.isEmpty();
+    }
+
+    /// Whether `rel` (a directory inside a classes directory, with its
+    /// trailing slash) is where some layer's runtime is extracted.
+    static boolean isExtractedRuntime(String rel) {
+        for (Relocation r : ALL) {
+            if (rel.startsWith(r.target())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// `layer`'s runtime jar among `classpath`, or null.
+    public static File runtimeJar(Relocation layer, Iterable<File> classpath) {
+        File found = null;
+        for (File f : classpath) {
+            if (f != null && layer.isRuntimeJar(f.getName())) {
+                found = f;
+            }
+        }
+        return found;
+    }
+
+    /// The layer whose API `internalName` belongs to, as an application is
+    /// compiled against it (`javax/swing/JTable`), or null.
+    public static Relocation owning(String internalName) {
+        for (Relocation r : ALL) {
+            if (r.owns(internalName)) {
+                return r;
+            }
+        }
+        return null;
+    }
+
+    /// What a build tells a developer whose application uses `layer`'s API
+    /// without having switched the layer on, or null when the build has
+    /// nothing to suggest. The only place this wording lives.
+    public static String enableHint(Relocation layer) {
+        if (layer == SWING) {
+            return "Codename One runs AWT/Swing code through its Swing compatibility layer, which this project "
+                    + "has not enabled. Move the Swing sources to src/main/desktop to enable it, or use "
+                    + "com.codename1.ui components for UI logic.";
+        }
+        if (layer == JAVAFX) {
+            return "Codename One runs JavaFX code through its JavaFX compatibility layer, which this project "
+                    + "has not enabled. Move the JavaFX sources to src/main/desktop to enable it, or use "
+                    + "com.codename1.ui components for UI logic.";
+        }
+        return null;
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/CompatLibraries.java b/maven/build-engine/src/main/java/com/codename1/maven/CompatLibraries.java
new file mode 100644
index 00000000000..62e991c5a8c
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/CompatLibraries.java
@@ -0,0 +1,782 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+import com.codename1.impl.compat.ResourceNames;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/// The third-party libraries of a desktop application, as they ship on a
+/// device.
+///
+/// A device build has no class path: what the application uses of a library
+/// is part of the application. So before the classes directory is
+/// relocated, every dependency jar that is part of the application (Maven's
+/// `compile` scope, Gradle's `implementation`) is classified from its
+/// classes ([DependencyClassifier]) and handled by what it is:
+///
+/// - **a library a layer implements itself** (its classes live in packages
+///   the layer owns) is never unpacked. The layer's classes ship in its
+///   place, and the application's calls are relocated onto them.
+/// - **a library written against Swing or JavaFX** -- a layout manager, a
+///   component set -- is unpacked whole when the application uses it at all:
+///   its classes name `javax/swing/JPanel`, and what ships is the relocated
+///   runtime.
+/// - **a pure-Java library** is unpacked as far as the application reaches
+///   it and no further: the classes its own classes refer to, transitively,
+///   through every other library. One stray `java.beans` reference in a JSON
+///   library does not make its 800 classes application code. The reached
+///   classes are relocated like the application's -- their descriptors name
+///   `java.io.File`, which the application's relocated calls spell
+///   differently -- and checked like them, so a library that cannot work on
+///   a device fails the build instead of the device.
+/// - **a library the application never reaches** is left out altogether.
+///
+/// #### What comes with the classes
+///
+/// A library's resources come with it -- everything in the jar that is not
+/// a class, the jar's own `META-INF` apart, of which only
+/// `META-INF/resources/` is taken: that is a directory libraries load from
+/// by name (an icon pack keeps its fonts there). They are unpacked beside
+/// the classes and recorded, and the step that ships the application's own
+/// resources ([CompatResources]) ships them the same way, flattened and
+/// indexed, so a library's `getResource` finds its file on a device.
+///
+/// The providers a jar lists in `META-INF/services` for a service the
+/// application reaches are recorded too, in the file's order, for the
+/// generated registry that `ServiceLoader` reads on a device. The services
+/// files themselves are not unpacked: two jars routinely list providers for
+/// one service under one file name.
+///
+/// Three kinds of jar are not touched: one written against the Codename One
+/// API, the Kotlin runtime -- the build handles both by itself -- and a jar
+/// with no classes. A `provided` jar is never a candidate: it says the
+/// classes come from somewhere else.
+///
+/// #### The record
+///
+/// What was decided is written to [#RECORD] inside the classes directory:
+/// each jar, what it was classified as, and the files that came from it.
+/// Four things read it:
+///
+/// - the next run, which unpacks only what is new -- a class already there
+///   is relocated already, and unpacking it again would undo that -- and
+///   removes what the application no longer reaches;
+/// - the compliance check, to say which jar a class with an unsupported
+///   reference came from, since the developer did not write it;
+/// - the port report, for its table of dependencies;
+/// - the step that assembles the application, which must not merge a
+///   recorded jar: its classes are in the application already, relocated,
+///   or are not meant to be in it at all.
+///
+/// The record travels with the classes: a module that depends on this one
+/// finds it inside this one's jar.
+public final class CompatLibraries {
+
+    /// The record's path inside a classes directory or a jar.
+    public static final String RECORD = "META-INF/codenameone/compat-libraries.txt";
+
+    /// The size from which what a library adds to the application is worth
+    /// a warning.
+    static final long LARGE = 4L * 1024 * 1024;
+
+    private static final String JAR = "jar\t";
+    private static final String FILE = "file\t";
+    private static final String INFO = "info\t";
+    private static final String SERVICE = "service\t";
+    private static final String SUM = "sum\t";
+
+    /// The one directory of a jar's `META-INF` that holds what the library
+    /// loads by name.
+    private static final String META_RESOURCES = "META-INF/resources/";
+
+    private CompatLibraries() {
+    }
+
+    /// Classifies `candidates` against the desktop `layers`, unpacks into
+    /// `classesDir` what the application ships of each, and answers the jars
+    /// something was unpacked from. `skip` are jars that are never libraries
+    /// whatever they refer to: the layers' own runtimes.
+    static List<File> bundle(File classesDir, List<File> candidates, List<Relocation> layers, Set<File> skip,
+                             Log log) throws IOException {
+        List<File> bundled = new ArrayList<File>();
+        if (candidates == null || layers.isEmpty()) {
+            return bundled;
+        }
+        Map<String, Entry> before = read(classesDir);
+        if (candidates.isEmpty() && before.isEmpty()) {
+            return bundled;
+        }
+        boolean released = release(classesDir, before, log);
+        List<File> jars = new ArrayList<File>();
+        for (File jar : candidates) {
+            if (jar != null && !skip.contains(jar)) {
+                jars.add(jar);
+            }
+        }
+        List<DependencyClassifier.Library> libraries = DependencyClassifier.classify(jars, layers);
+        Set<String> unpackedBefore = new HashSet<String>();
+        for (Entry e : before.values()) {
+            unpackedBefore.addAll(e.files);
+        }
+        DependencyClassifier.reach(DependencyClassifier.applicationReferences(classesDir, unpackedBefore, layers),
+                libraries);
+        Map<String, Entry> after = new LinkedHashMap<String, Entry>();
+        for (DependencyClassifier.Library lib : libraries) {
+            if (!lib.managed()) {
+                continue;
+            }
+            File jar = lib.file();
+            String key = key(after, jar.getName());
+            Entry old = before.get(key);
+            Entry entry = new Entry(stamp(jar));
+            entry.describe(lib);
+            Set<String> shipped = lib.shipped();
+            if (!shipped.isEmpty()) {
+                for (Map.Entry<String, List<String>> service : lib.reachedServices().entrySet()) {
+                    for (String provider : service.getValue()) {
+                        entry.services.add(service.getKey() + "\t" + provider);
+                    }
+                }
+            }
+            boolean same = old != null && old.stamp.equals(entry.stamp);
+            Set<String> mine = old == null ? Collections.<String>emptySet() : old.files;
+            long[] written = new long[2];
+            if (!shipped.isEmpty()) {
+                unpack(jar, classesDir, mine, same ? mine : Collections.<String>emptySet(),
+                        lib.kind() == DependencyClassifier.Kind.UI_LIBRARY ? null : shipped, entry, written, log);
+                bundled.add(jar);
+            }
+            delete(classesDir, mine, entry.files);
+            after.put(key, entry);
+            if (entry.equals(old)) {
+                log.debug(jar.getName() + " is handled already and has not changed");
+                continue;
+            }
+            announce(lib, entry, written, layers, log);
+        }
+        // A jar that is no longer a dependency takes its classes with it.
+        for (Map.Entry<String, Entry> e : before.entrySet()) {
+            if (!after.containsKey(e.getKey())) {
+                delete(classesDir, e.getValue().files, allFiles(after));
+            }
+        }
+        if (released || !after.equals(before)) {
+            write(classesDir, after);
+        }
+        return bundled;
+    }
+
+    /// Takes out of the record every file that is no longer the bytes the
+    /// last build left there, and says whether there was one.
+    ///
+    /// The compiler runs before this step. A project that drops a library
+    /// and carries its classes itself -- the sources copied in where the jar
+    /// used to be -- has compiled a class to a path the record still calls
+    /// the library's, and deleting what a jar "takes with it" would delete
+    /// the application's own class: a build that works clean and loses a
+    /// class incrementally. A file the last build sealed and that has
+    /// changed since is therefore somebody else's by now, exactly as
+    /// [ClassRelocator#extractRuntime] treats a runtime class.
+    ///
+    /// A record with no checksum for a file -- one a build wrote and did not
+    /// live to seal -- says nothing about it, and the file stays the jar's.
+    private static boolean release(File classesDir, Map<String, Entry> before, Log log) throws IOException {
+        boolean released = false;
+        for (Entry e : before.values()) {
+            for (Map.Entry<String, String> sum : e.sums.entrySet()) {
+                File f = new File(classesDir, sum.getKey());
+                if (e.files.contains(sum.getKey()) && f.isFile()
+                        && !sum.getValue().equals(checksum(Files.readAllBytes(f.toPath())))) {
+                    log.debug(sum.getKey() + " has changed since it was unpacked: it is the application's own now");
+                    e.files.remove(sum.getKey());
+                    released = true;
+                }
+            }
+        }
+        return released;
+    }
+
+    /// Records what every unpacked file looks like once the step that
+    /// called [#bundle] is done with the directory: relocation rewrites the
+    /// classes after they are unpacked, so only then are they the bytes the
+    /// next build will find. See [#release], which reads this.
+    static void seal(File classesDir) throws IOException {
+        Map<String, Entry> entries = read(classesDir);
+        boolean changed = false;
+        for (Entry e : entries.values()) {
+            Map<String, String> sums = new TreeMap<String, String>();
+            for (String name : e.files) {
+                File f = new File(classesDir, name);
+                if (f.isFile()) {
+                    sums.put(name, checksum(Files.readAllBytes(f.toPath())));
+                }
+            }
+            if (!sums.equals(e.sums)) {
+                e.sums.clear();
+                e.sums.putAll(sums);
+                changed = true;
+            }
+        }
+        if (changed) {
+            write(classesDir, entries);
+        }
+    }
+
+    private static String checksum(byte[] data) {
+        CRC32 crc = new CRC32();
+        crc.update(data, 0, data.length);
+        return data.length + ":" + Long.toHexString(crc.getValue());
+    }
+
+    /// What the record calls a jar: its file name, which is what every
+    /// message and report calls it too. Two different jars of one name --
+    /// the same artifact id and version in two groups -- cannot both be
+    /// recorded under it, so the second is `name/2`, the third `name/3`, in
+    /// the order of the class path, which a build keeps from one run to the
+    /// next. A slash is in no file name, so the name is read back from the
+    /// key by [#jarName].
+    private static String key(Map<String, Entry> taken, String name) {
+        String key = name;
+        for (int n = 2; taken.containsKey(key); n++) {
+            key = name + "/" + n;
+        }
+        return key;
+    }
+
+    /// The file name of the jar recorded as `key`.
+    static String jarName(String key) {
+        int slash = key.indexOf('/');
+        return slash < 0 ? key : key.substring(0, slash);
+    }
+
+    private static Set<String> allFiles(Map<String, Entry> entries) {
+        Set<String> out = new HashSet<String>();
+        for (Entry e : entries.values()) {
+            out.addAll(e.files);
+        }
+        return out;
+    }
+
+    private static void delete(File classesDir, Set<String> files, Set<String> keep) throws IOException {
+        for (String stale : files) {
+            if (!keep.contains(stale)) {
+                File f = new File(classesDir, stale);
+                if (f.isFile() && !f.delete()) {
+                    throw new IOException("Could not delete " + f);
+                }
+            }
+        }
+    }
+
+    /// Says once, when it is decided or changes, what becomes of a library.
+    private static void announce(DependencyClassifier.Library lib, Entry entry, long[] written,
+                                 List<Relocation> layers, Log log) {
+        String jar = lib.jar();
+        if (lib.kind() == DependencyClassifier.Kind.LAYER_PROVIDED) {
+            log.info(jar + " is provided by the " + lib.layer() + " compatibility layer: the layer's classes ship "
+                    + "in its place");
+            return;
+        }
+        if (entry.files.isEmpty()) {
+            log.info(jar + " is not used by the application's classes and is left out of it");
+            return;
+        }
+        if (written[0] == 0) {
+            return;
+        }
+        if (lib.nativeCode() != null) {
+            log.warn(jar + " " + lib.nativeCode() + ", which cannot run on a device; the classes of it that the "
+                    + "application uses are checked like its own");
+        }
+        long kb = (lib.file().length() + 1023) / 1024;
+        if (lib.kind() == DependencyClassifier.Kind.UI_LIBRARY) {
+            String line = "Bundling " + jar + " with the application (" + written[0] + " classes, " + kb
+                    + " KB): it is written against " + names(layers) + " and is relocated with it";
+            if (lib.file().length() >= LARGE) {
+                log.warn(line + ". That is a large library to ship whole; every class of it goes into the"
+                        + " application");
+            } else {
+                log.info(line);
+            }
+            return;
+        }
+        String line = "Bundling " + written[0] + " of the " + lib.classCount() + " classes of " + jar
+                + " with the application: the ones it uses, relocated and checked with it";
+        if (written[1] >= LARGE) {
+            log.warn(line + ". That is " + ((written[1] + 1023) / 1024) + " KB of library code in the application");
+        } else {
+            log.info(line);
+        }
+    }
+
+    private static String names(List<Relocation> layers) {
+        StringBuilder out = new StringBuilder();
+        for (Relocation r : layers) {
+            out.append(out.length() == 0 ? "" : " or ").append(r.name());
+        }
+        return out.toString();
+    }
+
+    /// What says a jar is the build of it an earlier run unpacked: its
+    /// length, its time, and a checksum of what its directory lists -- every
+    /// entry's name, size and CRC. Length and time alone call a jar rebuilt
+    /// in place unchanged when a reproducible build, or a file system with
+    /// coarse times, gives the new one the same two numbers, and the stale
+    /// relocated classes then stay in the application. The directory is read
+    /// without inflating an entry.
+    private static String stamp(File jar) throws IOException {
+        CRC32 listing = new CRC32();
+        ZipFile zip = new ZipFile(jar);
+        try {
+            Enumeration<? extends ZipEntry> entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry e = entries.nextElement();
+                listing.update((e.getName() + "\n" + e.getSize() + "\n" + e.getCrc() + "\n")
+                        .getBytes(StandardCharsets.UTF_8));
+            }
+        } finally {
+            zip.close();
+        }
+        return jar.length() + "\t" + jar.lastModified() + "\t" + Long.toHexString(listing.getValue());
+    }
+
+    /// Unpacks `jar` -- all of it when `classes` is null, else those classes
+    /// and every resource -- leaving alone whatever the application has
+    /// under the same name: its own class wins, as it does on a classpath,
+    /// unless `mine` says an earlier run put the file there from this jar.
+    /// A file among `current` is one that run unpacked from this very build
+    /// of the jar; it is relocated by now and is kept as it is. `written`
+    /// receives the number of classes written and their size.
+    private static void unpack(File jar, File classesDir, Set<String> mine, Set<String> current,
+                               Set<String> classes, Entry entry, long[] written, Log log) throws IOException {
+        ZipFile zip = new ZipFile(jar);
+        try {
+            Enumeration<? extends ZipEntry> entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry e = entries.nextElement();
+                String name = e.getName();
+                // The manifest, signatures and the Java 9 variants of a
+                // multi-release jar describe the jar, not the application;
+                // a desktop's native libraries are nothing a device loads.
+                if (e.isDirectory() || (name.startsWith("META-INF/") && !name.startsWith(META_RESOURCES))
+                        || name.endsWith("module-info.class")
+                        || name.contains("..") || name.startsWith("/") || isNativeLibrary(name)) {
+                    continue;
+                }
+                boolean isClass = name.endsWith(".class");
+                if (isClass && classes != null
+                        && !classes.contains(name.substring(0, name.length() - ".class".length()))) {
+                    continue;
+                }
+                File out = new File(classesDir, name);
+                if (out.exists() && !mine.contains(name)) {
+                    log.debug(name + " of " + jar.getName() + " is the application's own; kept");
+                    continue;
+                }
+                entry.files.add(name);
+                // A resource the last run unpacked has since been shipped
+                // under its flat name, and its nested copy removed.
+                if (current.contains(name) && (out.isFile() || (!isClass && name.indexOf('/') >= 0
+                        && new File(classesDir, ResourceNames.flatName(name)).isFile()))) {
+                    continue;
+                }
+                File parent = out.getParentFile();
+                if (parent != null && !parent.isDirectory() && !parent.mkdirs()) {
+                    throw new IOException("Could not create " + parent);
+                }
+                InputStream in = zip.getInputStream(e);
+                try {
+                    byte[] bytes = readAll(in);
+                    Files.write(out.toPath(), bytes);
+                    if (isClass) {
+                        written[0]++;
+                        written[1] += bytes.length;
+                    }
+                } finally {
+                    in.close();
+                }
+            }
+        } finally {
+            zip.close();
+        }
+    }
+
+    private static boolean isNativeLibrary(String name) {
+        return name.endsWith(".so") || name.endsWith(".dll") || name.endsWith(".dylib") || name.endsWith(".jnilib");
+    }
+
+    private static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] buf = new byte[8192];
+        int n = in.read(buf);
+        while (n >= 0) {
+            out.write(buf, 0, n);
+            n = in.read(buf);
+        }
+        return out.toByteArray();
+    }
+
+    private static final class Entry {
+        private final String stamp;
+        private final Set<String> files = new TreeSet<String>();
+        /// The providers the jar lists for the services the application
+        /// reaches, each as `service`, a tab, `provider`, in the jar's order.
+        private final List<String> services = new ArrayList<String>();
+        /// The checksum each unpacked file had when the build that wrote
+        /// this was done with it; see [CompatLibraries#seal]. Not part of
+        /// what makes two entries equal: it describes the directory, not
+        /// what was decided about the jar.
+        private final Map<String, String> sums = new TreeMap<String, String>();
+        /// What the jar was classified as, by key: see [Library].
+        private final Map<String, String> info = new TreeMap<String, String>();
+
+        Entry(String stamp) {
+            this.stamp = stamp;
+        }
+
+        void describe(DependencyClassifier.Library lib) {
+            info.put("kind", lib.kind().name());
+            info.put("classes", String.valueOf(lib.classCount()));
+            info.put("toolkit", String.valueOf(lib.toolkitClassCount()));
+            info.put("reached", String.valueOf(lib.reached().size()));
+            if (lib.layer() != null) {
+                info.put("layer", lib.layer());
+            }
+            if (lib.nativeCode() != null) {
+                info.put("native", lib.nativeCode());
+            }
+            if (lib.mainPackage() != null) {
+                info.put("package", lib.mainPackage());
+            }
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o instanceof Entry && ((Entry) o).stamp.equals(stamp) && ((Entry) o).files.equals(files)
+                    && ((Entry) o).info.equals(info) && ((Entry) o).services.equals(services);
+        }
+
+        @Override
+        public int hashCode() {
+            return stamp.hashCode();
+        }
+    }
+
+    /// One recorded jar: what the build decided about it.
+    public static final class Library {
+        private final String jar;
+        private final Entry entry;
+
+        Library(String jar, Entry entry) {
+            this.jar = jar;
+            this.entry = entry;
+        }
+
+        /// The jar's file name.
+        public String jar() {
+            return jar;
+        }
+
+        /// What it was classified as; null for a record written before
+        /// jars were classified.
+        public DependencyClassifier.Kind kind() {
+            String kind = entry.info.get("kind");
+            for (DependencyClassifier.Kind k : DependencyClassifier.Kind.values()) {
+                if (k.name().equals(kind)) {
+                    return k;
+                }
+            }
+            return null;
+        }
+
+        /// How many classes the jar holds.
+        public int classCount() {
+            return number("classes");
+        }
+
+        /// How many of the jar's classes the application reaches.
+        public int reachedCount() {
+            return number("reached");
+        }
+
+        /// How many of its classes are in the application.
+        public int shippedCount() {
+            int n = 0;
+            for (String f : entry.files) {
+                if (f.endsWith(".class")) {
+                    n++;
+                }
+            }
+            return n;
+        }
+
+        /// The layer that stands in for the jar, or null.
+        public String layer() {
+            return entry.info.get("layer");
+        }
+
+        /// How the jar depends on native code, or null; see
+        /// [DependencyClassifier.Library#nativeCode].
+        public String nativeCode() {
+            return entry.info.get("native");
+        }
+
+        /// The package most of the jar's classes are in, dotted and at most
+        /// three parts deep, or null.
+        public String mainPackage() {
+            return entry.info.get("package");
+        }
+
+        private int number(String key) {
+            String value = entry.info.get(key);
+            if (value == null) {
+                return 0;
+            }
+            try {
+                return Integer.parseInt(value);
+            } catch (NumberFormatException e) {
+                return 0;
+            }
+        }
+    }
+
+    /// Every jar `classesDir`'s record holds, by file name in the order
+    /// recorded (a second jar of one file name as `name/2`); empty when
+    /// there is no record.
+    public static Map<String, Library> libraries(File classesDir) {
+        Map<String, Library> out = new LinkedHashMap<String, Library>();
+        try {
+            for (Map.Entry<String, Entry> e : read(classesDir).entrySet()) {
+                out.put(e.getKey(), new Library(e.getKey(), e.getValue()));
+            }
+        } catch (IOException e) {
+            return out;
+        }
+        return out;
+    }
+
+    private static Map<String, Entry> parse(String text) {
+        Map<String, Entry> out = new LinkedHashMap<String, Entry>();
+        Entry current = null;
+        for (String line : text.split("\n")) {
+            if (line.startsWith(JAR)) {
+                int tab = line.indexOf('\t', JAR.length());
+                if (tab > 0) {
+                    current = new Entry(line.substring(tab + 1));
+                    out.put(line.substring(JAR.length(), tab), current);
+                }
+            } else if (line.startsWith(FILE) && current != null) {
+                current.files.add(line.substring(FILE.length()));
+            } else if (line.startsWith(SERVICE) && current != null) {
+                current.services.add(line.substring(SERVICE.length()));
+            } else if (line.startsWith(SUM) && current != null) {
+                int tab = line.indexOf('\t', SUM.length());
+                if (tab > 0) {
+                    current.sums.put(line.substring(tab + 1), line.substring(SUM.length(), tab));
+                }
+            } else if (line.startsWith(INFO) && current != null) {
+                int eq = line.indexOf('=');
+                if (eq > INFO.length()) {
+                    current.info.put(line.substring(INFO.length(), eq), line.substring(eq + 1));
+                }
+            }
+        }
+        return out;
+    }
+
+    private static Map<String, Entry> read(File root) throws IOException {
+        if (root == null) {
+            return new LinkedHashMap<String, Entry>();
+        }
+        if (root.isDirectory()) {
+            File record = new File(root, RECORD);
+            return record.isFile() ? parse(new String(Files.readAllBytes(record.toPath()), StandardCharsets.UTF_8))
+                    : new LinkedHashMap<String, Entry>();
+        }
+        if (root.isFile() && root.getName().endsWith(".jar")) {
+            ZipFile zip = new ZipFile(root);
+            try {
+                ZipEntry e = zip.getEntry(RECORD);
+                if (e != null) {
+                    InputStream in = zip.getInputStream(e);
+                    try {
+                        return parse(new String(readAll(in), StandardCharsets.UTF_8));
+                    } finally {
+                        in.close();
+                    }
+                }
+            } finally {
+                zip.close();
+            }
+        }
+        return new LinkedHashMap<String, Entry>();
+    }
+
+    private static void write(File classesDir, Map<String, Entry> entries) throws IOException {
+        File record = new File(classesDir, RECORD);
+        if (entries.isEmpty()) {
+            if (record.isFile() && !record.delete()) {
+                throw new IOException("Could not delete " + record);
+            }
+            return;
+        }
+        StringBuilder text = new StringBuilder();
+        for (Map.Entry<String, Entry> e : entries.entrySet()) {
+            text.append(JAR).append(e.getKey()).append('\t').append(e.getValue().stamp).append('\n');
+            for (Map.Entry<String, String> i : e.getValue().info.entrySet()) {
+                text.append(INFO).append(i.getKey()).append('=').append(i.getValue()).append('\n');
+            }
+            for (String f : e.getValue().files) {
+                text.append(FILE).append(f).append('\n');
+            }
+            for (String s : e.getValue().services) {
+                text.append(SERVICE).append(s).append('\n');
+            }
+            for (Map.Entry<String, String> sum : e.getValue().sums.entrySet()) {
+                text.append(SUM).append(sum.getValue()).append('\t').append(sum.getKey()).append('\n');
+            }
+        }
+        File parent = record.getParentFile();
+        if (!parent.isDirectory() && !parent.mkdirs()) {
+            throw new IOException("Could not create " + parent);
+        }
+        Files.write(record.toPath(), text.toString().getBytes(StandardCharsets.UTF_8));
+    }
+
+    /// The file names of the jars recorded in any of `roots`, each a classes
+    /// directory or a jar built from one: the jars whose classes are in the
+    /// application already as far as they belong there, and which must not
+    /// be merged into it again. A root that cannot be read has recorded
+    /// nothing.
+    ///
+    /// A name stands for every recorded jar that has it, and each of them
+    /// is recorded: see [#key]. What a name cannot tell apart is a recorded
+    /// jar from one of the same name this step leaves alone -- a Codename
+    /// One library or a jar of resources, sharing an artifact id and a
+    /// version with a desktop library of another group. That one would be
+    /// kept out of the application with its namesake. The record travels
+    /// inside the module's jar to builds on other machines, so it can hold
+    /// no path, and the callers have a file and not always coordinates;
+    /// renaming one of the two artifacts is the way out.
+    public static Set<String> bundledJarNames(Iterable<File> roots) {
+        Set<String> out = new HashSet<String>();
+        if (roots != null) {
+            for (File root : roots) {
+                try {
+                    for (String key : read(root).keySet()) {
+                        out.add(jarName(key));
+                    }
+                } catch (IOException e) {
+                    // Not a readable jar: then not one this step produced.
+                    continue;
+                }
+            }
+        }
+        return out;
+    }
+
+    /// The jar each bundled class of `classesDir` came from, by the class's
+    /// internal name; empty when nothing was bundled.
+    public static Map<String, String> classOrigins(File classesDir) {
+        Map<String, String> out = new LinkedHashMap<String, String>();
+        Map<String, Entry> entries;
+        try {
+            entries = read(classesDir);
+        } catch (IOException e) {
+            return out;
+        }
+        for (Map.Entry<String, Entry> e : entries.entrySet()) {
+            for (String f : e.getValue().files) {
+                if (f.endsWith(".class")) {
+                    out.put(f.substring(0, f.length() - ".class".length()), e.getKey());
+                }
+            }
+        }
+        return out;
+    }
+
+    /// The resources the bundled libraries of `classesDir` brought with
+    /// them, by their path in the jar they came from, which is where they
+    /// were unpacked; empty when nothing was bundled.
+    static Set<String> resources(File classesDir) {
+        Set<String> out = new TreeSet<String>();
+        try {
+            for (Entry e : read(classesDir).values()) {
+                for (String f : e.files) {
+                    if (!f.endsWith(".class")) {
+                        out.add(f);
+                    }
+                }
+            }
+        } catch (IOException e) {
+            return out;
+        }
+        return out;
+    }
+
+    /// The service providers the bundled libraries of `classesDir` list,
+    /// for the services the application reaches: one `{jar, service,
+    /// provider}` each, the names dotted as a services file has them, in the
+    /// order of the record and of each file.
+    static List<String[]> services(File classesDir) {
+        List<String[]> out = new ArrayList<String[]>();
+        try {
+            for (Map.Entry<String, Entry> e : read(classesDir).entrySet()) {
+                for (String s : e.getValue().services) {
+                    int tab = s.indexOf('\t');
+                    if (tab > 0) {
+                        out.add(new String[] {e.getKey(), s.substring(0, tab), s.substring(tab + 1)});
+                    }
+                }
+            }
+        } catch (IOException e) {
+            return out;
+        }
+        return out;
+    }
+
+    /// What a build message adds after naming a class that came from `jar`.
+    public static String origin(String jar) {
+        return "in the library " + jar + ", which is bundled and relocated with the application";
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/CompatRemapper.java b/maven/build-engine/src/main/java/com/codename1/maven/CompatRemapper.java
new file mode 100644
index 00000000000..ee709071db4
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/CompatRemapper.java
@@ -0,0 +1,460 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+import com.codename1.builders.BuildException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// Relocates an application's compiled classes onto whichever compatibility
+/// layers it has switched on, and ships their runtimes with it.
+///
+/// The one entry point a build plugin needs: it works out the active layers
+/// from the compile classpath and the compiled classes
+/// ([CompatLayers#active(Iterable, Iterable)]), relocates by all of
+/// their rules in a single pass ([ClassRelocator]) and extracts each runtime
+/// jar exactly once. An application with no
+/// layer is left untouched, so the step can run unconditionally.
+///
+/// Only the layers that are active are applied, never [CompatLayers#EVERY]:
+/// an application without the Swing layer keeps its `java/awt/` references as
+/// written, and the compliance check then reports them with the instruction
+/// to enable the layer.
+///
+/// Running it again over the same directory changes nothing. The relocation
+/// rules only match names an application is compiled against, extracted
+/// runtimes are skipped by the directory walk, and every extracted file is
+/// compared before it is written.
+public final class CompatRemapper {
+
+    private final File classesDir;
+    private final List<File> classpath;
+    private final File onClickNames;
+    private final Log log;
+    /// Worked out on first use, from everything the caller configured by
+    /// then: the handler directories are examined too.
+    private List<Relocation> active;
+    private ClassRelocator relocator;
+    private final List<File> handlerDirs = new ArrayList<File>();
+    private boolean shipRuntime = true;
+    private File desktopDir;
+    private List<File> applicationLibraries;
+    /// Null until [#withResourceDirectories] is called; see
+    /// [#resourceDirectories()].
+    private List<File> resourceDirs;
+    private File fxmlSources;
+    /// Whether the run in progress has shipped the desktop resources yet:
+    /// two layers ask for it.
+    private boolean resourcesShipped;
+
+    /// `classesDir` is the application's output directory, rewritten in
+    /// place. `classpath` is its compile classpath, which decides the active
+    /// layers and supplies their jars. `onClickNames` is the Android resource
+    /// compiler's list of `android:onClick` names, or null when the
+    /// application has no Android sources.
+    public CompatRemapper(File classesDir, Iterable<File> classpath, File onClickNames, Log log) {
+        this.classesDir = classesDir;
+        this.classpath = new ArrayList<File>();
+        if (classpath != null) {
+            for (File f : classpath) {
+                if (f != null) {
+                    this.classpath.add(f);
+                }
+            }
+        }
+        this.onClickNames = onClickNames;
+        this.log = log;
+    }
+
+    /// Only relocates the classes, without copying in any runtime or
+    /// generating anything: for a second output directory of the same
+    /// application (Gradle's Kotlin classes), which the main pass covers.
+    public CompatRemapper relocateOnly() {
+        shipRuntime = false;
+        return this;
+    }
+
+    /// Further class directories of the same application, whose classes the
+    /// generators consider beside those of the classes directory.
+    public CompatRemapper withHandlerDirectories(List<File> dirs) {
+        if (dirs != null) {
+            for (File d : dirs) {
+                if (d != null && d.isDirectory() && !d.equals(classesDir)) {
+                    handlerDirs.add(d);
+                }
+            }
+        }
+        return this;
+    }
+
+    /// The module's desktop source directory (`src/main/desktop`, see
+    /// [DesktopSources]); null, or a directory that does not exist, for an
+    /// application that has none. Only its `resources` directory is read,
+    /// and only when [#withResourceDirectories] is not called.
+    ///
+    /// Nothing here starts the application: its Codename One main class is a
+    /// source file of the project, which `cn1:import-desktop-project` writes
+    /// ([DesktopProjectImporter]), and the remap relocates it like any other
+    /// class.
+    public CompatRemapper withDesktopSourceDirectory(File dir) {
+        this.desktopDir = dir;
+        return this;
+    }
+
+    /// The directories holding the files a desktop application loads by
+    /// name (`src/main/desktop/resources`, and wherever the build generates
+    /// more of them). The files in a directory are flattened to the root of
+    /// the classes directory and indexed for the runtime; see
+    /// [CompatResources]. A directory that does not exist is ignored.
+    ///
+    /// A caller that never calls this gets the `resources` directory of the
+    /// desktop source directory ([#withDesktopSourceDirectory]), which is
+    /// where a desktop application's resources are unless the build was told
+    /// otherwise.
+    public CompatRemapper withResourceDirectories(List<File> dirs) {
+        resourceDirs = new ArrayList<File>();
+        if (dirs != null) {
+            for (File d : dirs) {
+                if (d != null && !resourceDirs.contains(d)) {
+                    resourceDirs.add(d);
+                }
+            }
+        }
+        return this;
+    }
+
+    /// The directories [#withResourceDirectories] was given, or its default.
+    List<File> resourceDirectories() {
+        if (resourceDirs != null) {
+            return resourceDirs;
+        }
+        List<File> out = new ArrayList<File>();
+        if (desktopDir != null) {
+            out.add(DesktopSources.resourcesDir(desktopDir.getAbsoluteFile()));
+        }
+        return out;
+    }
+
+    /// The directory given to [#withDesktopSourceDirectory], or null.
+    File desktopSourceDirectory() {
+        return desktopDir;
+    }
+
+    /// The layers this application has switched on, in the order their rules
+    /// are tried; empty when it has none. A desktop layer counts only when the
+    /// classes directory, or one of the handler directories, refers to it.
+    public List<Relocation> activeLayers() throws BuildException {
+        if (active == null) {
+            bundleLibraries();
+            List<File> dirs = new ArrayList<File>();
+            dirs.add(classesDir);
+            dirs.addAll(handlerDirs);
+            try {
+                active = Collections.unmodifiableList(CompatLayers.active(classpath, dirs));
+            } catch (IOException e) {
+                throw new BuildException("Could not read the compiled classes: " + e.getMessage(), e);
+            }
+            relocator = new ClassRelocator(active);
+            if (relocator.hasDesktopLayer()) {
+                // Generated by shipDesktopResources; each desktop layer's jar
+                // holds an empty placeholder for its lifecycle to compile
+                // against, never copied.
+                relocator.generating(ApplicationRegistry.NAME);
+                // Generated by generateFxmlDispatch; the layer's own is an
+                // empty placeholder. Named as the runtime jar holds it, and
+                // harmless when no active layer ships it.
+                relocator.generating(com.codename1.fxml.FxmlDispatchGenerator.REGISTRY);
+                // Generated by generatePropertyAccess, over a placeholder
+                // in the same way.
+                relocator.generating(PropertyAccessGenerator.REGISTRY);
+            }
+        }
+        return active;
+    }
+
+    /// The dependency jars that are part of the application -- Maven's
+    /// `compile` scope, Gradle's `implementation` -- as opposed to the ones
+    /// something else provides. What the application uses of them is
+    /// unpacked into the classes directory and relocated with it: a library
+    /// written against a desktop layer whole, a pure-Java one by the classes
+    /// the application reaches. See [CompatLibraries], which classifies each
+    /// jar itself, so the whole list can be passed as it is.
+    public CompatRemapper withApplicationLibraries(List<File> jars) {
+        this.applicationLibraries = jars == null ? null : new ArrayList<File>(jars);
+        return this;
+    }
+
+    /// Unpacks the libraries written against a desktop layer, before the
+    /// classes directory is read for the layers it uses: a library's use of
+    /// Swing is the application's.
+    private void bundleLibraries() throws BuildException {
+        // An empty list is still a list: the last library an application
+        // dropped has classes here to take away.
+        if (!shipRuntime || applicationLibraries == null) {
+            return;
+        }
+        List<Relocation> desktop = new ArrayList<Relocation>();
+        java.util.Set<File> runtimes = new java.util.HashSet<File>();
+        for (Relocation layer : CompatLayers.active(classpath)) {
+            runtimes.add(CompatLayers.runtimeJar(layer, classpath));
+            if (layer.isDesktop()) {
+                desktop.add(layer);
+            }
+        }
+        try {
+            CompatLibraries.bundle(classesDir, applicationLibraries, desktop, runtimes, log);
+        } catch (IOException e) {
+            throw new BuildException("Could not bundle the application's libraries: " + e.getMessage(), e);
+        }
+    }
+
+    /// Whether `layer` is among the active ones.
+    public boolean isActive(Relocation layer) throws BuildException {
+        return activeLayers().contains(layer);
+    }
+
+    /// The relocator composed of every active layer's rules.
+    public ClassRelocator relocator() throws BuildException {
+        activeLayers();
+        return relocator;
+    }
+
+    /// Where the Java sources generated from the application's FXML
+    /// documents are kept for a reader (a stack trace names their lines).
+    /// Never a directory the application's own javac run compiles from.
+    /// Without one the sources are compiled from memory and kept nowhere.
+    public CompatRemapper withFxmlSourceDirectory(File dir) {
+        this.fxmlSources = dir;
+        return this;
+    }
+
+    /// Compiles the application's FXML documents into its classes directory:
+    /// [com.codename1.fxml.FxmlClassCompiler], which says why this is the
+    /// one moment for it -- after javac, so that a document can name a class
+    /// of the application (a custom control), and before anything here
+    /// relocates the classes its generated source is compiled against.
+    ///
+    /// Called first by a full [#run()], for an application with the JavaFX
+    /// layer's jar on its class path. A relocate-only run never compiles
+    /// documents: it is the second directory of an application whose main
+    /// pass did.
+    private void compileFxmlDocuments() throws BuildException {
+        if (CompatLayers.runtimeJar(CompatLayers.JAVAFX, classpath) == null) {
+            return;
+        }
+        com.codename1.fxml.FxmlClassCompiler compiler = new com.codename1.fxml.FxmlClassCompiler(
+                resourceDirectories(), classpath, handlerDirs, classesDir, fxmlSources,
+                new com.codename1.fxml.DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                        log.info(message);
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                        log.warn(message);
+                    }
+                });
+        List<String> errors;
+        try {
+            errors = compiler.run();
+        } catch (IOException e) {
+            throw new BuildException("Could not compile the application's FXML documents: " + e.getMessage(), e);
+        }
+        if (!errors.isEmpty()) {
+            StringBuilder all = new StringBuilder();
+            for (String error : errors) {
+                log.error(error);
+                all.append('\n').append(error);
+            }
+            throw new BuildException(errors.size() + " error(s) in the application's FXML documents:" + all);
+        }
+    }
+
+    /// Relocates and ships. Answers false, having done nothing, when the
+    /// application has no compatibility layer.
+    public boolean run() throws BuildException {
+        if (shipRuntime) {
+            // Before the layers are worked out: that unpacks the libraries
+            // into the classes directory, and what follows relocates it.
+            compileFxmlDocuments();
+        }
+        if (activeLayers().isEmpty()) {
+            log.debug("No compatibility layer on the classpath; nothing to relocate");
+            return false;
+        }
+        try {
+            resourcesShipped = false;
+            List<String> appClasses;
+            int runtime = 0;
+            boolean android = isActive(AndroidRemapper.RELOCATION);
+            if (android) {
+                // The Android step relocates the directory itself, with the
+                // composed rules, and extracts its own runtime before
+                // generating its dispatchers.
+                AndroidRemapper remapper = new AndroidRemapper(classesDir,
+                        CompatLayers.runtimeJar(AndroidRemapper.RELOCATION, classpath), onClickNames, log)
+                        .withRelocator(relocator)
+                        .withHandlerDirectories(handlerDirs);
+                if (!shipRuntime) {
+                    remapper.relocateOnly();
+                }
+                remapper.run();
+                appClasses = remapper.applicationClasses();
+            } else {
+                appClasses = new ArrayList<String>();
+                relocator.remapDirectory(classesDir, appClasses, log);
+            }
+            if (!shipRuntime) {
+                if (!android) {
+                    log.info("Relocated " + appClasses.size() + " application classes");
+                }
+                return true;
+            }
+            StringBuilder names = new StringBuilder();
+            for (Relocation layer : active) {
+                if (layer == AndroidRemapper.RELOCATION) {
+                    continue;
+                }
+                runtime += relocator.extractRuntime(CompatLayers.runtimeJar(layer, classpath), classesDir);
+                names.append(names.length() == 0 ? "" : ", ").append(layer.name());
+            }
+            // The registry an earlier run generated is not the application's:
+            // read as one, its class literals would change what this run
+            // generates from them, and a second run would not be a no-op.
+            ApplicationRegistry.removeGenerated(appClasses);
+            List<String> unmodifiable = Collections.unmodifiableList(appClasses);
+            if (isActive(CompatLayers.SWING)) {
+                generateSwingResources(unmodifiable);
+            }
+            if (isActive(CompatLayers.JAVAFX)) {
+                generateFxmlDispatch(unmodifiable);
+                generatePropertyAccess(unmodifiable);
+                generateJavaFxResources(unmodifiable);
+            }
+            if (relocator.hasDesktopLayer()) {
+                // A desktop application hands class literals to
+                // getListeners and Array.newInstance; see the generator
+                // for why that needs a class of its own on a device.
+                int arrays = new ArrayClassGenerator(classesDir).run(unmodifiable);
+                log.debug("Generated the array classes of " + arrays + " class literal(s)");
+            }
+            if (names.length() > 0) {
+                log.info("Relocated " + appClasses.size() + " application classes and " + runtime + " "
+                        + names + " runtime classes");
+            }
+            // Last, when nothing here writes to the directory any more.
+            CompatLibraries.seal(classesDir);
+            return true;
+        } catch (IOException e) {
+            throw new BuildException("Compatibility layer remapping failed: " + e.getMessage(), e);
+        }
+    }
+
+    /// Ships what a Swing application loads by name -- `Class.getResource`
+    /// images, `ResourceBundle` properties -- in the form the runtime looks
+    /// them up: [#shipDesktopResources()]. `appClasses` are the application's
+    /// relocated internal names. Called after every runtime is in place, on
+    /// a full (not relocate-only) run with the Swing layer active. Whatever
+    /// it writes must be written with [ClassRelocator#writeIfDifferent], to
+    /// keep a second run a no-op.
+    void generateSwingResources(List<String> appClasses) throws IOException {
+        shipDesktopResources();
+    }
+
+    /// Flattens the desktop resources and generates the registry the runtime
+    /// reads them through ([CompatResources]), once per run however many
+    /// desktop layers are active: the resources are the application's, not a
+    /// layer's.
+    ///
+    /// #### What starts it on the device
+    ///
+    /// The generated class is `com.codename1.generated.compat.CompatRegistry`
+    /// ([ApplicationRegistry]), and its static `cn1Install()` installs it.
+    /// The desktop lifecycles (`DesktopLifecycle`, `FxLifecycle`) call that
+    /// before the application's own code, and library mode calls it the
+    /// first time a desktop component is wrapped or a window shown.
+    private void shipDesktopResources() throws IOException {
+        if (resourcesShipped) {
+            return;
+        }
+        resourcesShipped = true;
+        try {
+            new CompatResources(classesDir, resourceDirectories(), handlerDirs, relocator, log).run();
+        } catch (BuildException e) {
+            // The hooks' contract is IOException; run() reports either as
+            // the build failure it is, with this message.
+            throw new IOException(e.getMessage(), e);
+        }
+    }
+
+    /// Generates what FXML resolves by name at run time on a desktop --
+    /// the compiled documents, controller classes, `fx:id` fields and
+    /// `onAction="#handler"` methods -- as direct calls, the way
+    /// [AndroidRemapper] generates the `android:onClick` dispatcher:
+    /// [com.codename1.fxml.FxmlDispatchGenerator]. It replaces the layer's
+    /// placeholder registry, which is why [#activeLayers()] keeps that
+    /// class from being copied out of the runtime jar. Same contract as
+    /// [#generateSwingResources], for the JavaFX layer.
+    void generateFxmlDispatch(List<String> appClasses) throws IOException {
+        com.codename1.fxml.FxmlDispatchGenerator generator = new com.codename1.fxml.FxmlDispatchGenerator(
+                classesDir, new com.codename1.fxml.FxmlDispatchGenerator.Names(
+                        relocator.map(com.codename1.fxml.FxmlDispatchGenerator.REGISTRY),
+                        relocator.map(com.codename1.fxml.FxmlDispatchGenerator.DISPATCH),
+                        relocator.map(com.codename1.fxml.FxmlDispatchGenerator.CONTEXT),
+                        relocator.map(com.codename1.fxml.FxmlDispatchGenerator.ANNOTATION)));
+        generator.run(appClasses);
+        if (generator.documents() > 0 || generator.controllers() > 0) {
+            log.info("Generated the FXML dispatcher for " + generator.documents() + " document(s) and "
+                    + generator.controllers() + " controller class(es)");
+        }
+    }
+
+    /// Generates what `PropertyValueFactory` resolves by name at run time
+    /// on a desktop -- the `xxxProperty()` and getter methods of the bean
+    /// classes -- as direct calls: [PropertyAccessGenerator]. It replaces
+    /// the layer's placeholder registry, which [#activeLayers()] keeps from
+    /// being copied out of the runtime jar. Same contract as
+    /// [#generateSwingResources], for the JavaFX layer.
+    void generatePropertyAccess(List<String> appClasses) throws IOException {
+        PropertyAccessGenerator generator = new PropertyAccessGenerator(classesDir,
+                relocator.map(PropertyAccessGenerator.REGISTRY), relocator.map(PropertyAccessGenerator.ACCESS),
+                relocator.map(PropertyAccessGenerator.FACTORY));
+        generator.run(appClasses);
+        if (generator.beans() > 0) {
+            log.info("Generated the property accessors of " + generator.beans() + " bean class(es)");
+        }
+    }
+
+    /// Ships the FXML documents, stylesheets and images a JavaFX application
+    /// loads by name: [#shipDesktopResources()]. Same contract as
+    /// [#generateSwingResources], for the JavaFX layer.
+    void generateJavaFxResources(List<String> appClasses) throws IOException {
+        shipDesktopResources();
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/CompatResources.java b/maven/build-engine/src/main/java/com/codename1/maven/CompatResources.java
new file mode 100644
index 00000000000..05d1b049cd1
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/CompatResources.java
@@ -0,0 +1,488 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+import com.codename1.builders.BuildException;
+import com.codename1.impl.compat.ResourceNames;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/// Ships what a desktop application loads by name -- the files it reads with
+/// `Class.getResource`, and its resource bundles -- in the form the runtime
+/// looks them up, and generates the class that tells the runtime what was
+/// shipped.
+///
+/// #### Flattening
+///
+/// A device bundle has no directories. Every file of the desktop resource
+/// directories that sits in a directory is written to the root of the
+/// classes directory under the flat name
+/// `com.codename1.impl.compat.ResourceNames.flatName` gives its path, and the
+/// nested copy the build tool put there is removed. A file already at the
+/// root keeps its name and is left alone.
+///
+/// The flat name is computed by that one method, which the runtime calls too
+/// when it turns the name an application asks for into the name to read:
+/// this module reads it from the core for exactly that reason. The
+/// alternatives were a second copy of the rule in this module -- two
+/// implementations that must agree character for character, with nothing
+/// but a test to say so -- or a mapping table generated into the application,
+/// which costs every shipped resource a second string for something a pure
+/// function answers.
+///
+/// A flat name that some OTHER file already has is a build error, never an
+/// overwrite: two different resources would answer to one name on the
+/// device and nothing would say which.
+///
+/// #### The registry
+///
+/// `com.codename1.generated.compat.CompatRegistry` is generated with the
+/// path of every shipped resource, every bundle that is a class and every
+/// service provider, the classes created with `new` since a device creates
+/// nothing by name; see [ApplicationRegistry]. A `.properties` bundle needs
+/// no entry of its own: the class library's `ResourceBundle` reads it as the
+/// resource it is. The desktop layers' jars carry an empty class of that name
+/// so that their lifecycles, which call its `cn1Install()`, compile; the
+/// generated one is the one that ships.
+///
+/// #### Bundled libraries
+///
+/// A library unpacked into the application ([CompatLibraries]) brought its
+/// resources with it, and they are shipped by the same rule: flattened and
+/// indexed, so the library's own `getResource` finds its file. Where the
+/// application has a resource of the same path, the application's is the
+/// one that ships, as it is the first on a desktop class path. A library's
+/// resource whose flat name is taken is left out with a warning rather than
+/// failing the build: the developer cannot rename a file inside a jar.
+///
+/// #### Service providers
+///
+/// Nothing on a device lists a directory of a class path or creates a class
+/// from its name, so `ServiceLoader` is answered from the registry as well.
+/// Every `META-INF/services/<service>` file among the application's
+/// resources, and every one a bundled library has for a service the
+/// application reaches, is read here -- by `ServiceProviderNames`, the rule
+/// the runtime's own `ServiceLoader` applies, so the two agree on what a line
+/// means --
+/// and each provider it lists is registered under the service's name with a
+/// number the registry's `cn1Create` turns into a `new`. The
+/// application's files come first, then the libraries' in the order they
+/// were bundled, each file in its own order; a provider listed twice for a
+/// service is registered once.
+///
+/// The names in a services file are the ones the source was written
+/// against. What ships is relocated, so both the service and the provider
+/// are mapped the way the classes were before anything is generated.
+///
+/// A listed provider that cannot be created -- the class is not among the
+/// shipped ones, or is abstract, or not public, or has no public constructor
+/// without parameters -- is left out with ONE warning naming the file and
+/// the class. It never fails the build: a library lists providers for
+/// environments the application is not in.
+///
+/// #### Running it again
+///
+/// The flat names written are listed in a file BESIDE the classes directory
+/// (it is not something to ship). The next run reads it to remove the flat
+/// copy of a resource that has since been deleted or renamed, and to tell
+/// its own earlier output from somebody else's file of the same name.
+final class CompatResources {
+
+    /// What a bundle class descends from, as the application names it: the
+    /// class library's own, which keeps the JDK's names.
+    private static final String[] BUNDLE_BASES = {
+        "java/util/ResourceBundle", "java/util/ListResourceBundle", "java/util/PropertyResourceBundle",
+    };
+    private static final String PROPERTIES_SUFFIX = ".properties";
+
+    private final File classesDir;
+    private final List<File> resourceDirs;
+    private final List<File> classDirs;
+    private final Log log;
+    private final ClassRelocator relocator;
+
+    /// `resourceDirs` are the desktop resource directories; `classDirs` the
+    /// further class directories of the application, searched for bundle
+    /// classes beside `classesDir`.
+    CompatResources(File classesDir, List<File> resourceDirs, List<File> classDirs, Log log) {
+        this(classesDir, resourceDirs, classDirs, null, log);
+    }
+
+    /// As above, with the rules the classes were relocated by: a services
+    /// file names its classes as the source did. Null when nothing was
+    /// relocated.
+    CompatResources(File classesDir, List<File> resourceDirs, List<File> classDirs, ClassRelocator relocator,
+                    Log log) {
+        this.classesDir = classesDir;
+        this.resourceDirs = resourceDirs;
+        this.classDirs = classDirs;
+        this.relocator = relocator;
+        this.log = log;
+    }
+
+    /// The file listing the flat names an earlier run wrote into
+    /// `classesDir`.
+    static File manifest(File classesDir) {
+        File abs = classesDir.getAbsoluteFile();
+        return new File(abs.getParentFile(), abs.getName() + ".cn1-compat-resources");
+    }
+
+    /// Flattens the resources and writes the registry.
+    void run() throws IOException, BuildException {
+        TreeMap<String, File> resources = new TreeMap<String, File>();
+        for (File dir : resourceDirs) {
+            if (dir != null && dir.isDirectory()) {
+                collect(dir, "", resources);
+            }
+        }
+        // The services files, read before flattening moves them.
+        List<String[]> listed = new ArrayList<String[]>();
+        for (Map.Entry<String, File> e : resources.entrySet()) {
+            String path = e.getKey();
+            if (path.startsWith(DependencyClassifier.SERVICES)
+                    && path.indexOf('/', DependencyClassifier.SERVICES.length()) < 0) {
+                File built = new File(classesDir, path);
+                String text = new String(Files.readAllBytes((built.isFile() ? built : e.getValue()).toPath()),
+                        "UTF-8");
+                String service = path.substring(DependencyClassifier.SERVICES.length());
+                for (String provider : ServiceProviderNames.of(text, null)) {
+                    listed.add(new String[] {path, service, provider});
+                }
+            }
+        }
+        for (String[] s : CompatLibraries.services(classesDir)) {
+            listed.add(new String[] {DependencyClassifier.SERVICES + s[1] + " of " + s[0], s[1], s[2]});
+        }
+
+        Set<String> fromLibraries = new TreeSet<String>();
+        for (String path : CompatLibraries.resources(classesDir)) {
+            if (resources.containsKey(path)) {
+                continue;
+            }
+            File nested = new File(classesDir, path);
+            File flat = new File(classesDir, ResourceNames.flatName(path));
+            if (nested.isFile() || flat.isFile()) {
+                resources.put(path, nested.isFile() ? nested : flat);
+                fromLibraries.add(path);
+            }
+        }
+        flatten(resources, fromLibraries);
+
+        int propertyBundles = 0;
+        for (String path : resources.keySet()) {
+            if (path.endsWith(PROPERTIES_SUFFIX)) {
+                propertyBundles++;
+            }
+        }
+        Map<String, Seen> seen = scanClasses();
+        List<String> bundleClasses = bundleClasses(seen);
+        List<String[]> services = services(listed, seen);
+        ApplicationRegistry.write(classesDir, ApplicationRegistry.generate(
+                new ArrayList<String>(resources.keySet()), bundleClasses, services), log);
+        log.debug("Shipped " + resources.size() + " desktop resources, " + propertyBundles
+                + " properties bundles, " + bundleClasses.size() + " bundle classes and " + services.size()
+                + " service providers");
+    }
+
+    /// The providers the registry creates, each as `{service, provider}`:
+    /// the service's shipped name dotted, as `Class.getName()` answers it on
+    /// the device, and the provider's shipped internal name. `listed` holds
+    /// `{where it was listed, service, provider}` with the names as written.
+    private List<String[]> services(List<String[]> listed, Map<String, Seen> seen) {
+        List<String[]> out = new ArrayList<String[]>();
+        Set<String> done = new TreeSet<String>();
+        for (String[] l : listed) {
+            String service = shipped(l[1]);
+            String provider = shipped(l[2]);
+            if (!done.add(service + " " + provider)) {
+                continue;
+            }
+            Seen s = seen.get(provider);
+            if (s == null) {
+                log.warn("The service provider " + l[2] + ", listed in " + l[0] + ", is not among the classes "
+                        + "the application ships. ServiceLoader will not offer it on a device.");
+            } else if (!s.creatable) {
+                log.warn("The service provider " + l[2] + ", listed in " + l[0] + ", cannot be created: it has "
+                        + "to be a public class that is not abstract, with a public constructor taking nothing. "
+                        + "ServiceLoader will not offer it on a device.");
+            } else {
+                out.add(new String[] {service.replace('/', '.'), provider});
+            }
+        }
+        return out;
+    }
+
+    /// The internal name the class a services file calls `dotted` ships
+    /// under. A nested class is written there with its dollar sign, so every
+    /// dot is a package separator.
+    private String shipped(String dotted) {
+        String name = dotted.replace('.', '/');
+        return relocator == null ? name : relocator.map(name);
+    }
+
+    /// Every file under `dir`, by its path from the resource root. Compiled
+    /// classes are not resources, and neither is what an operating system
+    /// leaves in a directory under a name starting with a dot.
+    private void collect(File dir, String rel, Map<String, File> out) throws BuildException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            String name = f.getName();
+            if (name.startsWith(".")) {
+                continue;
+            }
+            if (f.isDirectory()) {
+                collect(f, rel + name + "/", out);
+            } else if (!name.endsWith(".class")) {
+                String path = rel + name;
+                File first = out.get(path);
+                if (first != null) {
+                    throw new BuildException("The resource " + path + " exists twice, as " + first + " and as " + f
+                            + ". Only one of them can ship; remove or rename the other.");
+                }
+                out.put(path, f);
+            }
+        }
+    }
+
+    private void flatten(Map<String, File> resources, Set<String> fromLibraries)
+            throws IOException, BuildException {
+        List<String> leftOut = new ArrayList<String>();
+        try {
+            flatten(resources, fromLibraries, leftOut);
+        } finally {
+            for (String path : leftOut) {
+                resources.remove(path);
+            }
+        }
+    }
+
+    private void flatten(Map<String, File> resources, Set<String> fromLibraries, List<String> leftOut)
+            throws IOException, BuildException {
+        File manifest = manifest(classesDir);
+        Set<String> previous = new LinkedHashSet<String>();
+        if (manifest.isFile()) {
+            for (String line : new String(Files.readAllBytes(manifest.toPath()), "UTF-8").split("\n")) {
+                if (line.length() > 0) {
+                    previous.add(line);
+                }
+            }
+        }
+        Map<String, String> flatToPath = new HashMap<String, String>();
+        TreeSet<String> written = new TreeSet<String>();
+        for (Map.Entry<String, File> e : resources.entrySet()) {
+            String path = e.getKey();
+            if (path.indexOf('/') < 0) {
+                continue;
+            }
+            String flat = ResourceNames.flatName(path);
+            boolean library = fromLibraries.contains(path);
+            String taken = null;
+            if (resources.containsKey(flat)) {
+                taken = resources.get(flat).toString();
+            } else if (flatToPath.containsKey(flat)) {
+                taken = "the resource " + flatToPath.get(flat);
+            }
+            File nested = new File(classesDir, path);
+            // The build tool's copy, when there is one: it may have been
+            // filtered, and it is the bytes the developer's build produced.
+            byte[] data = taken != null ? null
+                    : Files.readAllBytes((nested.isFile() ? nested : e.getValue()).toPath());
+            File dest = new File(classesDir, flat);
+            if (taken == null && dest.exists() && !previous.contains(flat)
+                    && !(dest.isFile() && Arrays.equals(Files.readAllBytes(dest.toPath()), data))) {
+                taken = dest.toString();
+            }
+            if (taken != null) {
+                if (!library) {
+                    throw collision(path, flat, taken);
+                }
+                // Not the developer's to rename: it is inside a jar.
+                log.warn("The library resource " + path + " is not shipped: it would ship as " + flat
+                        + ", a name already taken by " + taken + ".");
+                leftOut.add(path);
+                continue;
+            }
+            flatToPath.put(flat, path);
+            ClassRelocator.writeIfDifferent(dest, data);
+            written.add(flat);
+            if (nested.isFile()) {
+                removeNested(nested);
+            }
+        }
+        for (String stale : previous) {
+            if (!written.contains(stale) && !resources.containsKey(stale)) {
+                File f = new File(classesDir, stale);
+                if (f.isFile() && !f.delete()) {
+                    log.warn("Could not delete " + f);
+                }
+            }
+        }
+        StringBuilder list = new StringBuilder();
+        for (String flat : written) {
+            list.append(flat).append('\n');
+        }
+        if (written.isEmpty()) {
+            if (manifest.isFile() && !manifest.delete()) {
+                log.warn("Could not delete " + manifest);
+            }
+        } else {
+            ClassRelocator.writeIfDifferent(manifest, list.toString().getBytes("UTF-8"));
+        }
+    }
+
+    private static BuildException collision(String path, String flat, String taken) {
+        return new BuildException("The resource " + path + " ships as " + flat + " -- a device bundle has no "
+                + "directories, so every nested resource is flattened to one name -- but that name is already "
+                + "taken by " + taken + ". Rename one of the two.");
+    }
+
+    /// Deletes the nested copy and every directory that leaves empty.
+    private void removeNested(File nested) {
+        if (!nested.delete()) {
+            log.warn("Could not delete " + nested);
+            return;
+        }
+        File root = classesDir.getAbsoluteFile();
+        File dir = nested.getAbsoluteFile().getParentFile();
+        while (dir != null && !dir.equals(root)) {
+            String[] left = dir.list();
+            if (left == null || left.length > 0 || !dir.delete()) {
+                return;
+            }
+            dir = dir.getParentFile();
+        }
+    }
+
+    /// What the scan keeps of one application class.
+    private static final class Seen {
+        String superName;
+        boolean creatable;
+    }
+
+    /// The application's bundle classes, as dotted names in order: public,
+    /// concrete, with a public constructor taking nothing, and descending
+    /// from `ResourceBundle`. Anything else `getBundle` could not have
+    /// created on a desktop either.
+    private static List<String> bundleClasses(Map<String, Seen> seen) {
+        List<String> out = new ArrayList<String>();
+        for (Map.Entry<String, Seen> e : seen.entrySet()) {
+            if (e.getValue().creatable && isBundle(e.getValue().superName, seen)) {
+                out.add(e.getKey().replace('/', '.'));
+            }
+        }
+        return out;
+    }
+
+    /// Every class the application ships that is not a layer's runtime, by
+    /// internal name.
+    private Map<String, Seen> scanClasses() throws IOException {
+        final Map<String, Seen> seen = new TreeMap<String, Seen>();
+        List<File> dirs = new ArrayList<File>();
+        dirs.add(classesDir);
+        dirs.addAll(classDirs);
+        for (File dir : dirs) {
+            scan(dir, "", seen);
+        }
+        return seen;
+    }
+
+    private static boolean isBundle(String superName, Map<String, Seen> seen) {
+        // Bounded, so that a malformed (circular) hierarchy ends.
+        for (int depth = 0; superName != null && depth < 64; depth++) {
+            for (String base : BUNDLE_BASES) {
+                if (base.equals(superName)) {
+                    return true;
+                }
+            }
+            Seen parent = seen.get(superName);
+            superName = parent == null ? null : parent.superName;
+        }
+        return false;
+    }
+
+    private static void scan(File dir, String rel, final Map<String, Seen> seen) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                String child = rel + f.getName() + "/";
+                if (!CompatLayers.isExtractedRuntime(child)) {
+                    scan(f, child, seen);
+                }
+            } else if (f.getName().endsWith(".class")) {
+                new ClassReader(Files.readAllBytes(f.toPath())).accept(new ClassVisitor(Opcodes.ASM9) {
+                    private Seen current;
+
+                    @Override
+                    public void visit(int version, int access, String name, String signature, String superName,
+                                      String[] interfaces) {
+                        current = new Seen();
+                        current.superName = superName;
+                        // Creatable so far; the constructor decides the rest.
+                        current.creatable = (access & Opcodes.ACC_PUBLIC) != 0
+                                && (access & (Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE)) == 0;
+                        seen.put(name, current);
+                        hasConstructor = false;
+                    }
+
+                    private boolean hasConstructor;
+
+                    @Override
+                    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                                                     String[] exceptions) {
+                        if ("<init>".equals(name) && "()V".equals(descriptor) && (access & Opcodes.ACC_PUBLIC) != 0) {
+                            hasConstructor = true;
+                        }
+                        return null;
+                    }
+
+                    @Override
+                    public void visitEnd() {
+                        current.creatable = current.creatable && hasConstructor;
+                    }
+                }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+            }
+        }
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/CompatRewrites.java b/maven/build-engine/src/main/java/com/codename1/maven/CompatRewrites.java
new file mode 100644
index 00000000000..9eba64cbec5
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/CompatRewrites.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/// Redirects the few members of JDK classes that the Codename One class
+/// library has no equivalent for, or that mean something else where there is
+/// no class path, to the static methods that stand in for them.
+///
+/// Everything else of `java.*` stays `java.*`: an application compiled
+/// against a JDK runs against the JDK on JavaSE and Android and against the
+/// class library (`vm/JavaAPI`) on the other targets, which carries the same
+/// API. What is left here:
+///
+/// - the resource lookups of `Class`, `ClassLoader` and `Thread`, which read
+///   the flattened resources through `com.codename1.impl.compat.Resources`,
+///   and `ResourceBundle.getBundle` and `ServiceLoader.load`, which have to
+///   reach them through the loader a port on a real JDK installs there;
+/// - the `String` members that take a regular expression, to
+///   `com.codename1.util.regex.StringRegex` (the device has no
+///   `java.util.regex`; a class that names one is relocated there by
+///   [Relocation#JDK_SHIMS]);
+/// - the transcendental functions of `Math` and `StrictMath`, to the
+///   framework's `MathUtil`, because the API an application builds against
+///   has none;
+/// - `Runtime.exec`, to `com.codename1.impl.process.RuntimeExec` over the
+///   framework's `ProcessBuilder`;
+/// - `Thread.setDefaultUncaughtExceptionHandler`, to
+///   `com.codename1.impl.compat.UncaughtExceptions`, which also hands the
+///   handler what event dispatch thread tasks throw.
+///
+/// An instance method becomes a static one taking the receiver first:
+/// `cls.getResource(name)` is `Resources.getResource(cls, name)`. A static
+/// method moves to the member of the same name. The same is done to a method
+/// reference, which a class file holds as a method handle among the
+/// arguments of an `invokedynamic`.
+///
+/// #### Where it runs
+///
+/// Inside [ClassRelocator#remap], BEFORE the names are relocated, so every
+/// rule is written in the names an application is compiled against. It runs
+/// only when a desktop layer is active: an application of the Android layer
+/// alone asks for resources by their flat names already. The Android runtime
+/// itself is not rewritten.
+///
+/// A rewritten class holds nothing a rule matches, so a second run over it
+/// changes nothing.
+///
+/// #### What is deliberately absent
+///
+/// Anything else of `ClassLoader` -- `defineClass`, a `URLClassLoader` -- has
+/// no rule and so reaches the compliance check as the build error it is: a
+/// device loads no classes at run time. `loadClass(String)` is the one
+/// exception, because all it does with the one loader there is, is what
+/// `Class.forName` does: answer a class the application already has.
+final class CompatRewrites {
+
+    private static final String RESOURCES = "com/codename1/impl/compat/Resources";
+    private static final String UNCAUGHT = "com/codename1/impl/compat/UncaughtExceptions";
+    private static final String REGEX = "com/codename1/util/regex/StringRegex";
+    private static final String RUNTIME_EXEC = "com/codename1/impl/process/RuntimeExec";
+    /// The framework's own math class: the API an application builds against
+    /// has no transcendental functions in `Math`, and this one has them under
+    /// the JDK's names.
+    private static final String MATH_UTIL = "com/codename1/util/MathUtil";
+    private static final String STRING = "Ljava/lang/String;";
+
+    /// Instance methods, as `owner.name descriptor`, to the class holding
+    /// the static method that takes the receiver as its first parameter. An
+    /// instance method is looked up here whether it is called on a class or
+    /// on an interface.
+    private static final Map<String, String> VIRTUAL = new HashMap<String, String>();
+    /// Static methods, as `owner.name descriptor`, to the class holding the
+    /// static method of the same name and descriptor.
+    private static final Map<String, String> STATIC = new HashMap<String, String>();
+
+    static {
+        String url = "(Ljava/lang/String;)Ljava/net/URL;";
+        String stream = "(Ljava/lang/String;)Ljava/io/InputStream;";
+        String urls = "(Ljava/lang/String;)Ljava/util/Enumeration;";
+        VIRTUAL.put("java/lang/Class.getResource" + url, RESOURCES);
+        VIRTUAL.put("java/lang/Class.getResourceAsStream" + stream, RESOURCES);
+        VIRTUAL.put("java/lang/ClassLoader.getResource" + url, RESOURCES);
+        VIRTUAL.put("java/lang/ClassLoader.getResourceAsStream" + stream, RESOURCES);
+        VIRTUAL.put("java/lang/ClassLoader.getResources" + urls, RESOURCES);
+        VIRTUAL.put("java/lang/ClassLoader.loadClass(Ljava/lang/String;)Ljava/lang/Class;", RESOURCES);
+        STATIC.put("java/lang/ClassLoader.getSystemResource" + url, RESOURCES);
+        STATIC.put("java/lang/ClassLoader.getSystemResourceAsStream" + stream, RESOURCES);
+        STATIC.put("java/lang/ClassLoader.getSystemResources" + urls, RESOURCES);
+        VIRTUAL.put("java/lang/Thread.getContextClassLoader()Ljava/lang/ClassLoader;", RESOURCES);
+        VIRTUAL.put("java/lang/Thread.setContextClassLoader(Ljava/lang/ClassLoader;)V", RESOURCES);
+
+        String bundle = "Ljava/util/ResourceBundle;";
+        STATIC.put("java/util/ResourceBundle.getBundle(" + STRING + ")" + bundle, RESOURCES);
+        STATIC.put("java/util/ResourceBundle.getBundle(" + STRING + "Ljava/util/Locale;)" + bundle, RESOURCES);
+        STATIC.put("java/util/ServiceLoader.load(Ljava/lang/Class;)Ljava/util/ServiceLoader;", RESOURCES);
+
+        STATIC.put("java/lang/Thread.setDefaultUncaughtExceptionHandler("
+                + "Ljava/lang/Thread$UncaughtExceptionHandler;)V", UNCAUGHT);
+
+        String str = "java/lang/String.";
+        VIRTUAL.put(str + "matches(" + STRING + ")Z", REGEX);
+        VIRTUAL.put(str + "split(" + STRING + ")[" + STRING, REGEX);
+        VIRTUAL.put(str + "split(" + STRING + "I)[" + STRING, REGEX);
+        VIRTUAL.put(str + "replaceAll(" + STRING + STRING + ")" + STRING, REGEX);
+        VIRTUAL.put(str + "replaceFirst(" + STRING + STRING + ")" + STRING, REGEX);
+
+        String strings = "[" + STRING;
+        String file = "Ljava/io/File;";
+        // RuntimeExec answers the framework's Process. The rewritten call
+        // still names java/lang/Process here; the row of Relocation.JDK_SHIMS
+        // that moves the class runs after this and moves the descriptor too.
+        for (String args : new String[] {STRING, STRING + strings, STRING + strings + file, strings,
+            strings + strings, strings + strings + file}) {
+            VIRTUAL.put("java/lang/Runtime.exec(" + args + ")Ljava/lang/Process;", RUNTIME_EXEC);
+        }
+
+        String math = "java/lang/Math.";
+        for (String fn : new String[] {"exp", "log", "log10", "asin", "acos", "atan"}) {
+            STATIC.put(math + fn + "(D)D", MATH_UTIL);
+        }
+        STATIC.put(math + "pow(DD)D", MATH_UTIL);
+        STATIC.put(math + "atan2(DD)D", MATH_UTIL);
+        // StrictMath is not on a device at all; its results are Math's here.
+        String[] keys = STATIC.keySet().toArray(new String[0]);
+        for (String key : keys) {
+            if (key.startsWith(math)) {
+                STATIC.put("java/lang/StrictMath." + key.substring(math.length()), STATIC.get(key));
+            }
+        }
+    }
+
+    private CompatRewrites() {
+    }
+
+    /// Whether the class named `internalName` is one whose calls are left as
+    /// they are: the Android runtime, which asks for resources by their flat
+    /// names already.
+    private static boolean exempt(String internalName) {
+        return internalName.startsWith(AndroidRemapper.RELOCATION.target());
+    }
+
+    /// A visitor that applies the rules to the class it is shown and passes
+    /// the result to `next`.
+    static ClassVisitor visitor(final ClassVisitor next) {
+        return new ClassVisitor(Opcodes.ASM9, next) {
+            private boolean exempt;
+
+            @Override
+            public void visit(int version, int access, String name, String signature, String superName,
+                              String[] interfaces) {
+                exempt = exempt(name);
+                super.visit(version, access, name, signature, superName, interfaces);
+            }
+
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                                             String[] exceptions) {
+                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
+                return mv == null || exempt ? mv : new Rewriter(mv);
+            }
+        };
+    }
+
+    /// The descriptor of the static method standing in for the instance
+    /// method `descriptor` of `owner`.
+    private static String receiverFirst(String owner, String descriptor) {
+        return "(L" + owner + ";" + descriptor.substring(1);
+    }
+
+    private static final class Rewriter extends MethodVisitor {
+        Rewriter(MethodVisitor next) {
+            super(Opcodes.ASM9, next);
+        }
+
+        @Override
+        public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
+            if (opcode == Opcodes.INVOKESTATIC) {
+                String target = STATIC.get(owner + "." + name + descriptor);
+                if (target != null) {
+                    super.visitMethodInsn(Opcodes.INVOKESTATIC, target, name, descriptor, false);
+                    return;
+                }
+            } else if (opcode == Opcodes.INVOKEVIRTUAL || opcode == Opcodes.INVOKEINTERFACE) {
+                String target = VIRTUAL.get(owner + "." + name + descriptor);
+                if (target != null) {
+                    super.visitMethodInsn(Opcodes.INVOKESTATIC, target, name, receiverFirst(owner, descriptor),
+                            false);
+                    return;
+                }
+            }
+            super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
+        }
+
+        @Override
+        public void visitInvokeDynamicInsn(String name, String descriptor, Handle bootstrap, Object... arguments) {
+            Object[] rewritten = arguments;
+            for (int i = 0; i < arguments.length; i++) {
+                if (arguments[i] instanceof Handle) {
+                    Handle moved = rewrite((Handle) arguments[i]);
+                    if (moved != arguments[i]) {
+                        if (rewritten == arguments) {
+                            rewritten = arguments.clone();
+                        }
+                        rewritten[i] = moved;
+                    }
+                }
+            }
+            super.visitInvokeDynamicInsn(name, descriptor, bootstrap, rewritten);
+        }
+
+        /// The handle a method reference should hold instead of `h`, or `h`.
+        /// A reference to an instance method takes its receiver as the
+        /// first argument either way, so the stand-in takes it the same way.
+        private static Handle rewrite(Handle h) {
+            if (h.getTag() == Opcodes.H_INVOKESTATIC) {
+                String target = STATIC.get(h.getOwner() + "." + h.getName() + h.getDesc());
+                if (target != null) {
+                    return new Handle(Opcodes.H_INVOKESTATIC, target, h.getName(), h.getDesc(), false);
+                }
+            } else if (h.getTag() == Opcodes.H_INVOKEVIRTUAL || h.getTag() == Opcodes.H_INVOKEINTERFACE) {
+                String target = VIRTUAL.get(h.getOwner() + "." + h.getName() + h.getDesc());
+                if (target != null) {
+                    return new Handle(Opcodes.H_INVOKESTATIC, target, h.getName(),
+                            receiverFirst(h.getOwner(), h.getDesc()), false);
+                }
+            }
+            return h;
+        }
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ComplianceAlternatives.java b/maven/build-engine/src/main/java/com/codename1/maven/ComplianceAlternatives.java
new file mode 100644
index 00000000000..4178cef7940
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ComplianceAlternatives.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// The nearest supported alternative to an API a device does not have.
+///
+/// The rows live in `compliance-alternatives.txt` beside this class, one per
+/// line, so that adding one is adding a line; the file's own header
+/// describes the format. A row names the classes and members its advice
+/// points at, and a test resolves every one of them against the built
+/// Codename One jars: advice cannot outlive what it recommends.
+public final class ComplianceAlternatives {
+
+    static final String RESOURCE = "compliance-alternatives.txt";
+
+    /// One row of the table.
+    public static final class Row {
+        private final String prefix;
+        private final List<String> references;
+        private final String advice;
+
+        Row(String prefix, List<String> references, String advice) {
+            this.prefix = prefix;
+            this.references = references;
+            this.advice = advice;
+        }
+
+        /// The API the row is about: a package ending in a dot, a class or
+        /// a member, as Java spells it.
+        public String prefix() {
+            return prefix;
+        }
+
+        /// What the advice names: `a.b.C` or `a.b.C#member`. Empty when the
+        /// row says there is no equivalent.
+        public List<String> references() {
+            return references;
+        }
+
+        /// What to tell the developer.
+        public String advice() {
+            return advice;
+        }
+    }
+
+    private static final List<Row> ROWS = load();
+
+    private ComplianceAlternatives() {
+    }
+
+    /// Every row, in the file's order.
+    public static List<Row> rows() {
+        return ROWS;
+    }
+
+    private static List<Row> load() {
+        InputStream in = ComplianceAlternatives.class.getResourceAsStream(RESOURCE);
+        if (in == null) {
+            throw new IllegalStateException(RESOURCE + " is missing beside " + ComplianceAlternatives.class.getName());
+        }
+        try {
+            try {
+                return parse(new String(DependencyClassifier.readAll(in), StandardCharsets.UTF_8));
+            } finally {
+                in.close();
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("Cannot read " + RESOURCE, e);
+        }
+    }
+
+    /// Reads a table. A line that is not a row -- three columns separated by
+    /// `|`, the first and the last not empty -- is an error, not a row to
+    /// skip: a typo would otherwise silently drop advice.
+    static List<Row> parse(String text) {
+        List<Row> rows = new ArrayList<Row>();
+        int number = 0;
+        for (String line : text.split("\n")) {
+            number++;
+            String trimmed = line.trim();
+            if (trimmed.isEmpty() || trimmed.charAt(0) == '#') {
+                continue;
+            }
+            int first = trimmed.indexOf('|');
+            int second = first < 0 ? -1 : trimmed.indexOf('|', first + 1);
+            if (second < 0) {
+                throw new IllegalArgumentException(RESOURCE + ":" + number + ": expected \"api | names | advice\"");
+            }
+            String prefix = trimmed.substring(0, first).trim();
+            String advice = trimmed.substring(second + 1).trim();
+            if (prefix.isEmpty() || advice.isEmpty()) {
+                throw new IllegalArgumentException(RESOURCE + ":" + number + ": the API and the advice are required");
+            }
+            List<String> references = new ArrayList<String>();
+            for (String r : trimmed.substring(first + 1, second).split(",")) {
+                if (!r.trim().isEmpty()) {
+                    references.add(r.trim());
+                }
+            }
+            rows.add(new Row(prefix, Collections.unmodifiableList(references), advice));
+        }
+        return Collections.unmodifiableList(rows);
+    }
+
+    /// The advice for `api`, or null. `api` is a class (`java.sql.Connection`)
+    /// or a member of one (`java.lang.Runtime.exec`), as Java spells it and
+    /// without a parameter list. The row with the longest matching prefix
+    /// wins, so a member's row beats its class's and a class's its package's.
+    public static String lookup(String api) {
+        Row row = row(api);
+        return row == null ? null : row.advice;
+    }
+
+    static Row row(String api) {
+        if (api == null) {
+            return null;
+        }
+        Row best = null;
+        for (Row row : ROWS) {
+            if (matches(row.prefix, api) && (best == null || row.prefix.length() > best.prefix.length())) {
+                best = row;
+            }
+        }
+        return best;
+    }
+
+    /// Whether `prefix` covers `api`: a package covers everything in it, a
+    /// class itself, its nested classes and its members, and a member every
+    /// member whose name starts with it (`Class.getDeclared` covers
+    /// `getDeclaredFields`).
+    private static boolean matches(String prefix, String api) {
+        if (!api.startsWith(prefix)) {
+            return false;
+        }
+        if (prefix.endsWith(".") || api.length() == prefix.length()) {
+            return true;
+        }
+        char next = api.charAt(prefix.length());
+        if (next == '.' || next == '$') {
+            return true;
+        }
+        // A member prefix: the last part starts in lower case.
+        int dot = prefix.lastIndexOf('.');
+        return dot >= 0 && dot + 1 < prefix.length() && Character.isLowerCase(prefix.charAt(dot + 1))
+                && api.indexOf('.', prefix.length()) < 0;
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ComplianceFindings.java b/maven/build-engine/src/main/java/com/codename1/maven/ComplianceFindings.java
new file mode 100644
index 00000000000..c9622e76983
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ComplianceFindings.java
@@ -0,0 +1,614 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/// What the compliance check found, arranged the way a developer reads it.
+///
+/// A check that fails on ten thousand references is not ten thousand
+/// problems. It is a few hundred missing APIs, most of them used by a
+/// library the developer did not write. So the findings are kept by where
+/// they are -- the application first, then each bundled library -- then by
+/// what kind of API is missing ([Category]), and each API once, with the
+/// places that use it.
+///
+/// Everything here is ordered and holds no absolute path, so the same
+/// classes give the same text on every machine.
+public final class ComplianceFindings {
+
+    /// What kind of API a finding is about.
+    public enum Category {
+        /// Swing, AWT or JavaFX API a compatibility layer does not have.
+        TOOLKIT("Swing, AWT and JavaFX API the compatibility layers lack"),
+        /// API of a UI library a compatibility layer stands in for.
+        UI_LIBRARY("UI library API the compatibility layers lack"),
+        /// JDK API a device does not have.
+        JDK("JDK API a device lacks"),
+        /// A Java language feature compiled to something a device cannot run.
+        LANGUAGE("Language features a device cannot run"),
+        /// A class of some other library that is not in the application.
+        LIBRARY("Other libraries"),
+        /// What fits none of these.
+        OTHER("Other findings");
+
+        private final String heading;
+
+        Category(String heading) {
+            this.heading = heading;
+        }
+
+        /// The category as a report heads it.
+        public String heading() {
+            return heading;
+        }
+    }
+
+    /// One place that uses a missing API.
+    public static final class Use implements Comparable<Use> {
+        private final String file;
+        private final int line;
+
+        Use(String file, int line) {
+            this.file = file;
+            this.line = line;
+        }
+
+        /// The source file, as a path from the source root
+        /// (`com/example/Orders.java`), or the class file when the class
+        /// has no debug information.
+        public String file() {
+            return file;
+        }
+
+        /// The line, or 0 when it is not known.
+        public int line() {
+            return line;
+        }
+
+        @Override
+        public int compareTo(Use o) {
+            int c = file.compareTo(o.file);
+            return c != 0 ? c : Integer.compare(line, o.line);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o instanceof Use && ((Use) o).file.equals(file) && ((Use) o).line == line;
+        }
+
+        @Override
+        public int hashCode() {
+            return file.hashCode() * 31 + line;
+        }
+    }
+
+    /// One missing API and everything that uses it.
+    public static final class Api {
+        private final String name;
+        private final Category category;
+        private final String family;
+        private final String alternative;
+        private final List<Use> uses = new ArrayList<Use>();
+
+        Api(String name, Category category, String family, String alternative) {
+            this.name = name;
+            this.category = category;
+            this.family = family;
+            this.alternative = alternative;
+        }
+
+        /// The API as its documentation spells it.
+        public String name() {
+            return name;
+        }
+
+        public Category category() {
+            return category;
+        }
+
+        /// The group within the category: "files", "networking", a library's
+        /// package.
+        public String family() {
+            return family;
+        }
+
+        /// The nearest supported alternative, or null.
+        public String alternative() {
+            return alternative;
+        }
+
+        /// How many references there are to it.
+        public int count() {
+            return uses.size();
+        }
+
+        /// The places that use it, ordered by file and line, each once.
+        public List<Use> uses() {
+            return new ArrayList<Use>(new TreeSet<Use>(uses));
+        }
+    }
+
+    /// The findings of one source: the application, or one library.
+    public static final class Source {
+        private final String library;
+        private final Map<String, Api> apis = new LinkedHashMap<String, Api>();
+        private int callSites;
+
+        Source(String library) {
+            this.library = library;
+        }
+
+        /// The library's jar, or null for the application's own classes.
+        public String library() {
+            return library;
+        }
+
+        /// How many references to a missing API the source makes.
+        public int callSites() {
+            return callSites;
+        }
+
+        /// How many different APIs those are.
+        public int apiCount() {
+            return apis.size();
+        }
+
+        /// The missing APIs of `category`, most used first.
+        public List<Api> apis(Category category) {
+            List<Api> out = new ArrayList<Api>();
+            for (Api a : apis.values()) {
+                if (a.category == category) {
+                    out.add(a);
+                }
+            }
+            Collections.sort(out, MOST_USED);
+            return out;
+        }
+
+        /// How many references the source makes to each family of
+        /// `category`, largest first.
+        public Map<String, Integer> families(Category category) {
+            Map<String, Integer> counts = new TreeMap<String, Integer>();
+            for (Api a : apis.values()) {
+                if (a.category == category) {
+                    Integer n = counts.get(a.family);
+                    counts.put(a.family, (n == null ? 0 : n) + a.count());
+                }
+            }
+            return byCount(counts);
+        }
+
+        /// The source files with a finding, each with its APIs.
+        public Map<String, List<Api>> byFile() {
+            Map<String, List<Api>> out = new TreeMap<String, List<Api>>();
+            for (Api a : apis.values()) {
+                Set<String> files = new TreeSet<String>();
+                for (Use u : a.uses) {
+                    files.add(u.file);
+                }
+                for (String f : files) {
+                    List<Api> list = out.get(f);
+                    if (list == null) {
+                        list = new ArrayList<Api>();
+                        out.put(f, list);
+                    }
+                    list.add(a);
+                }
+            }
+            for (List<Api> list : out.values()) {
+                Collections.sort(list, BY_NAME);
+            }
+            return out;
+        }
+
+        int callSites(Category category) {
+            int n = 0;
+            for (Api a : apis.values()) {
+                if (a.category == category) {
+                    n += a.count();
+                }
+            }
+            return n;
+        }
+    }
+
+    private static final Comparator<Api> BY_NAME = new Comparator<Api>() {
+        @Override
+        public int compare(Api a, Api b) {
+            return a.name.compareTo(b.name);
+        }
+    };
+
+    private static final Comparator<Api> MOST_USED = new Comparator<Api>() {
+        @Override
+        public int compare(Api a, Api b) {
+            return a.count() != b.count() ? Integer.compare(b.count(), a.count()) : a.name.compareTo(b.name);
+        }
+    };
+
+    private final Source application = new Source(null);
+    private final Map<String, Source> libraries = new TreeMap<String, Source>();
+    private int total;
+
+    /// Records one reference to a missing API.
+    ///
+    /// @param library the jar the referring class came from, or null for a
+    ///        class of the application's own
+    /// @param file the source file from the source root, or the class file
+    /// @param line the line, or 0
+    /// @param owner the class the API belongs to as the application was
+    ///        compiled against it, as an internal name
+    ///        (`javax/swing/JTable`); null when the finding names no class
+    /// @param api the API as its documentation spells it
+    /// @param key the API for the alternatives table: the owner and, for a
+    ///        member, its name (`java.lang.Runtime.exec`); null to use
+    ///        the owner
+    public void add(String library, String file, int line, String owner, String api, String key) {
+        Source source = application;
+        if (library != null) {
+            source = libraries.get(library);
+            if (source == null) {
+                source = new Source(library);
+                libraries.put(library, source);
+            }
+        }
+        Api entry = source.apis.get(api);
+        if (entry == null) {
+            Category category = categoryOf(owner);
+            String lookup = key != null ? key : owner == null ? null : owner.replace('/', '.').replace('$', '.');
+            entry = new Api(api, category, familyOf(category, owner), ComplianceAlternatives.lookup(lookup));
+            source.apis.put(api, entry);
+        }
+        entry.uses.add(new Use(file, line));
+        source.callSites++;
+        total++;
+    }
+
+    /// Records a finding that is a language feature rather than an API.
+    public void addLanguage(String library, String file, int line, String feature, String advice) {
+        Source source = application;
+        if (library != null) {
+            source = libraries.get(library);
+            if (source == null) {
+                source = new Source(library);
+                libraries.put(library, source);
+            }
+        }
+        Api entry = source.apis.get(feature);
+        if (entry == null) {
+            entry = new Api(feature, Category.LANGUAGE, "language", advice);
+            source.apis.put(feature, entry);
+        }
+        entry.uses.add(new Use(file, line));
+        source.callSites++;
+        total++;
+    }
+
+    /// Every reference recorded.
+    public int total() {
+        return total;
+    }
+
+    public boolean isEmpty() {
+        return total == 0;
+    }
+
+    /// The application's own findings.
+    public Source application() {
+        return application;
+    }
+
+    /// The libraries with findings, the one with the most first.
+    public List<Source> libraries() {
+        List<Source> out = new ArrayList<Source>(libraries.values());
+        Collections.sort(out, new Comparator<Source>() {
+            @Override
+            public int compare(Source a, Source b) {
+                return a.callSites != b.callSites ? Integer.compare(b.callSites, a.callSites)
+                        : a.library.compareTo(b.library);
+            }
+        });
+        return out;
+    }
+
+    /// The application, when it has findings, and then the libraries.
+    public List<Source> sources() {
+        List<Source> out = new ArrayList<Source>();
+        if (application.callSites > 0) {
+            out.add(application);
+        }
+        out.addAll(libraries());
+        return out;
+    }
+
+    /// How many different APIs are missing, over every source.
+    public int apiCount() {
+        Set<String> names = new TreeSet<String>(application.apis.keySet());
+        for (Source s : libraries.values()) {
+            names.addAll(s.apis.keySet());
+        }
+        return names.size();
+    }
+
+    private static final String[] TOOLKIT_ROOTS = {"java/", "javax/", "javafx/", "android/", "androidx/"};
+
+    private static final String[] JDK_ROOTS = {"java/", "javax/", "jdk/", "sun/", "com/sun/", "org/w3c/", "org/xml/",
+        "org/ietf/", "org/omg/"};
+
+    /// The kind of API `owner` is, by the class's name as the application
+    /// was compiled against it.
+    public static Category categoryOf(String owner) {
+        if (owner == null) {
+            return Category.OTHER;
+        }
+        if (CompatLayers.owning(owner) != null) {
+            for (String root : TOOLKIT_ROOTS) {
+                if (owner.startsWith(root)) {
+                    return Category.TOOLKIT;
+                }
+            }
+            return Category.UI_LIBRARY;
+        }
+        if (owner.startsWith("com/sun/jna/")) {
+            return Category.LIBRARY;
+        }
+        for (String root : JDK_ROOTS) {
+            if (owner.startsWith(root)) {
+                return Category.JDK;
+            }
+        }
+        return Category.LIBRARY;
+    }
+
+    /// The JDK's packages by what a developer would call them. The first
+    /// entry that the class's name starts with decides.
+    private static final String[][] JDK_FAMILIES = {
+        {"java/nio/file/", "files"},
+        {"java/nio/channels/", "channels and memory-mapped files"},
+        {"java/nio/", "NIO buffers and charsets"},
+        {"java/io/Object", "serialization"},
+        {"java/io/Serial", "serialization"},
+        {"java/io/Externalizable", "serialization"},
+        {"java/io/", "files and streams"},
+        {"java/util/regex/", "regular expressions"},
+        {"java/net/", "networking"},
+        {"javax/net/", "networking"},
+        {"java/lang/reflect/", "reflection"},
+        {"java/lang/invoke/", "reflection"},
+        {"java/lang/annotation/", "reflection"},
+        {"java/lang/Class", "reflection and class loading"},
+        {"java/lang/Module", "reflection and class loading"},
+        {"java/lang/Package", "reflection and class loading"},
+        {"java/util/ServiceLoader", "reflection and class loading"},
+        {"java/lang/Process", "processes"},
+        {"java/lang/Runtime", "processes and the runtime"},
+        {"java/lang/management/", "management"},
+        {"javax/management/", "management"},
+        {"java/lang/ref/", "references"},
+        {"java/lang/Thread", "threads"},
+        {"java/lang/", "java.lang"},
+        {"java/security/", "security and crypto"},
+        {"javax/crypto/", "security and crypto"},
+        {"javax/security/", "security and crypto"},
+        {"java/time/", "date and time"},
+        {"java/text/", "text formatting"},
+        {"java/util/concurrent/", "concurrency"},
+        {"java/util/stream/", "streams"},
+        {"java/util/function/", "functional interfaces"},
+        {"java/util/zip/", "archives"},
+        {"java/util/jar/", "archives"},
+        {"java/util/logging/", "logging"},
+        {"java/util/prefs/", "preferences"},
+        {"java/util/", "collections and utilities"},
+        {"java/sql/", "databases"},
+        {"javax/sql/", "databases"},
+        {"javax/xml/", "XML"},
+        {"org/w3c/", "XML"},
+        {"org/xml/", "XML"},
+        {"java/math/", "big numbers"},
+        {"java/beans/", "beans"},
+        {"sun/", "JDK internals"},
+        {"jdk/", "JDK internals"},
+        {"com/sun/", "JDK internals"},
+    };
+
+    /// The group `owner` belongs to within its category.
+    public static String familyOf(Category category, String owner) {
+        if (owner == null) {
+            return "other";
+        }
+        if (category == Category.JDK) {
+            for (String[] family : JDK_FAMILIES) {
+                if (owner.startsWith(family[0])) {
+                    return family[1];
+                }
+            }
+        }
+        return packageOf(owner, category == Category.JDK || category == Category.TOOLKIT ? 8 : 3);
+    }
+
+    /// The first `depth` parts of `owner`'s package, dotted.
+    private static String packageOf(String owner, int depth) {
+        int slash = owner.lastIndexOf('/');
+        if (slash < 0) {
+            return "(no package)";
+        }
+        String[] parts = owner.substring(0, slash).split("/");
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < parts.length && i < depth; i++) {
+            out.append(i == 0 ? "" : ".").append(parts[i]);
+        }
+        return out.toString();
+    }
+
+    static Map<String, Integer> byCount(Map<String, Integer> counts) {
+        List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>(counts.entrySet());
+        Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() {
+            @Override
+            public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b) {
+                int c = Integer.compare(b.getValue(), a.getValue());
+                return c != 0 ? c : a.getKey().compareTo(b.getKey());
+            }
+        });
+        Map<String, Integer> out = new LinkedHashMap<String, Integer>();
+        for (Map.Entry<String, Integer> e : entries) {
+            out.put(e.getKey(), e.getValue());
+        }
+        return out;
+    }
+
+    static String plural(int n, String one, String many) {
+        return n + " " + (n == 1 ? one : many);
+    }
+
+    private static String sourceName(Source s) {
+        return s.library == null ? "The application" : s.library;
+    }
+
+    /// The findings in a few lines, for the console: one line for the
+    /// application and one per category of it, then one line per library.
+    public String summary() {
+        StringBuilder out = new StringBuilder();
+        out.append(plural(total, "reference", "references")).append(" to ")
+                .append(plural(apiCount(), "API", "APIs")).append(" a device does not have:");
+        for (Source s : sources()) {
+            out.append("\n  ").append(sourceName(s)).append(": ").append(plural(s.callSites, "call site", "call sites"))
+                    .append(", ").append(plural(s.apiCount(), "API", "APIs"));
+            if (s.library != null) {
+                out.append(" -- ").append(top(allFamilies(s), 4));
+                continue;
+            }
+            for (Category c : Category.values()) {
+                List<Api> apis = s.apis(c);
+                if (apis.isEmpty()) {
+                    continue;
+                }
+                out.append("\n    ").append(c.heading()).append(": ").append(plural(apis.size(), "API", "APIs"))
+                        .append(", ").append(plural(s.callSites(c), "call site", "call sites")).append(" -- ");
+                if (c == Category.JDK || c == Category.LIBRARY) {
+                    out.append(top(s.families(c), 5));
+                } else {
+                    Map<String, Integer> most = new LinkedHashMap<String, Integer>();
+                    for (Api a : apis) {
+                        most.put(a.name, a.count());
+                    }
+                    out.append(top(most, 3));
+                }
+            }
+        }
+        return out.toString();
+    }
+
+    /// A library's references by family, over every category.
+    private static Map<String, Integer> allFamilies(Source s) {
+        Map<String, Integer> counts = new TreeMap<String, Integer>();
+        for (Api a : s.apis.values()) {
+            String family = a.category == Category.TOOLKIT ? "desktop toolkit" : a.family;
+            Integer n = counts.get(family);
+            counts.put(family, (n == null ? 0 : n) + a.count());
+        }
+        return byCount(counts);
+    }
+
+    private static String top(Map<String, Integer> counts, int max) {
+        StringBuilder out = new StringBuilder();
+        int i = 0;
+        for (Map.Entry<String, Integer> e : counts.entrySet()) {
+            if (i == max) {
+                out.append(", and ").append(counts.size() - max).append(" more");
+                break;
+            }
+            out.append(i == 0 ? "" : ", ").append(e.getKey()).append(' ').append(e.getValue());
+            i++;
+        }
+        return out.toString();
+    }
+
+    /// Every finding: each source, each category of it, each API once with
+    /// its number of uses, where they are and what to use instead.
+    public String report() {
+        StringBuilder out = new StringBuilder();
+        for (Source s : sources()) {
+            String title = sourceName(s) + ": " + plural(s.callSites, "call site", "call sites") + " of "
+                    + plural(s.apiCount(), "missing API", "missing APIs");
+            out.append(title).append('\n');
+            for (int i = 0; i < title.length(); i++) {
+                out.append('=');
+            }
+            out.append('\n');
+            for (Category c : Category.values()) {
+                List<Api> apis = s.apis(c);
+                if (apis.isEmpty()) {
+                    continue;
+                }
+                out.append('\n').append(c.heading()).append(" (").append(plural(apis.size(), "API", "APIs"))
+                        .append(", ").append(plural(s.callSites(c), "call site", "call sites")).append(")\n");
+                if (c == Category.JDK || c == Category.LIBRARY) {
+                    out.append("  by family: ").append(top(s.families(c), 12)).append('\n');
+                }
+                for (Api a : apis) {
+                    out.append("\n  ").append(a.count()).append(" x ").append(a.name).append('\n');
+                    out.append("      ").append(locations(a.uses(), 12)).append('\n');
+                    if (a.alternative != null) {
+                        out.append("      Instead: ").append(a.alternative).append('\n');
+                    }
+                }
+            }
+            out.append('\n');
+        }
+        return out.toString();
+    }
+
+    /// `a/B.java:3, 9; a/C.java:14`, at most `max` places.
+    static String locations(List<Use> uses, int max) {
+        StringBuilder out = new StringBuilder();
+        String file = null;
+        int shown = 0;
+        for (Use u : uses) {
+            if (shown == max) {
+                out.append("; and ").append(uses.size() - max).append(" more");
+                break;
+            }
+            if (!u.file.equals(file)) {
+                out.append(file == null ? "" : "; ").append(u.file);
+                if (u.line > 0) {
+                    out.append(':').append(u.line);
+                }
+                file = u.file;
+            } else if (u.line > 0) {
+                out.append(", ").append(u.line);
+            }
+            shown++;
+        }
+        return out.toString();
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/DependencyClassifier.java b/maven/build-engine/src/main/java/com/codename1/maven/DependencyClassifier.java
new file mode 100644
index 00000000000..bb3b9100a52
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/DependencyClassifier.java
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.TypePath;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/// Says what each dependency jar of a desktop application is to a device
+/// build, from the classes inside it.
+///
+/// One answer, used twice: `cn1:import-desktop-project` prints it so a
+/// developer knows what becomes of each library before building anything,
+/// and the remap step ([CompatLibraries]) acts on it. Nothing here knows a
+/// library by its name. A jar is read, and what its classes are called and
+/// what they refer to decides its [Kind].
+///
+/// #### Why the classes that ship are a closure
+///
+/// A device has no class path. Every class of the application is translated
+/// or dexed into it, so a library class nothing refers to is dead weight,
+/// and one that is referred to has to be relocated with the application --
+/// its descriptors name `java.util.regex.Pattern`, which the application's
+/// relocated calls now spell `com.codename1.util.regex.Pattern` -- and
+/// checked like the application's own code. [#reach] therefore walks from the application's
+/// classes through the libraries, and only what it reaches is unpacked.
+/// Classes found only by reflection are not reached: a device has none. A
+/// class named by a string constant (`Class.forName("a.b.C")`) is.
+///
+/// #### Service providers
+///
+/// A provider is named by no instruction either, only by a line of a
+/// `META-INF/services/<service>` file, and `ServiceLoader` does work on a
+/// device: the build generates the registry that creates each provider with
+/// `new`. So a jar's services files are read with its classes, and when the
+/// SERVICE is reached -- something the application ships names the
+/// interface, which it has to in order to load it -- every provider the
+/// libraries list for it is reached too, with whatever it refers to. A
+/// provider of a service nothing names stays out: nothing could ask for it.
+public final class DependencyClassifier {
+
+    /// What a dependency jar is to a device build.
+    public enum Kind {
+        /// Its classes live in packages a compatibility layer implements
+        /// itself. The layer's classes ship; the jar never does.
+        LAYER_PROVIDED("provided by a layer"),
+        /// Written against Swing or JavaFX in substance. Shipped whole and
+        /// relocated, since a toolkit library finds its own classes by name.
+        UI_LIBRARY("UI library"),
+        /// A pure-Java library with a few classes that name a desktop
+        /// toolkit. Only the classes the application reaches ship.
+        INCIDENTAL_TOOLKIT("pure Java, incidental toolkit use"),
+        /// Names no desktop toolkit. The classes the application reaches
+        /// ship, relocated like the application's, and checked.
+        PURE_JAVA("pure Java"),
+        /// Something the Codename One build handles on its own: a library
+        /// written against the Codename One API, or the Kotlin runtime.
+        PLATFORM("Codename One"),
+        /// A jar of resources.
+        NO_CLASSES("resources only");
+
+        private final String label;
+
+        Kind(String label) {
+            this.label = label;
+        }
+
+        /// What a report calls it.
+        public String label() {
+            return label;
+        }
+    }
+
+    /// The share of a jar's classes, in percent, that must name a desktop
+    /// toolkit for the jar to be a library written against it. Measured on
+    /// the 56 jars a real Swing application ships with: the toolkit
+    /// libraries sit at 25% and above (FlatLaf 83, RSyntaxTextArea 80, an
+    /// icon font's Swing binding 100, the ImageIO plugins 25 to 76), the
+    /// pure-Java ones with a stray `java.beans` or `java.awt` reference at
+    /// 6% and below (jackson-databind and commons-lang3 one class each, JNA
+    /// 2%). Nothing fell between.
+    static final int UI_SHARE_PERCENT = 20;
+
+    /// Packages the Codename One build ships a runtime for by itself.
+    private static final String[] PLATFORM_PACKAGES = {"kotlin/", "kotlinx/"};
+
+    private static final String CN1_PACKAGE = "com/codename1/";
+
+    /// Where a jar lists its service providers, one file per service.
+    static final String SERVICES = "META-INF/services/";
+
+    private DependencyClassifier() {
+    }
+
+    /// One class of a library: what it refers to.
+    static final class ClassInfo {
+        final String name;
+        final Set<String> references = new HashSet<String>();
+        /// String constants shaped like a class name, as written (`a.b.C`).
+        final Set<String> classNames = new HashSet<String>();
+
+        ClassInfo(String name) {
+            this.name = name;
+        }
+    }
+
+    /// A dependency jar, classified.
+    public static final class Library {
+        private final File file;
+        private final Map<String, ClassInfo> classes = new LinkedHashMap<String, ClassInfo>();
+        /// The jar's `META-INF/services` files: each service's class name,
+        /// as the file is named, to the provider class names it lists.
+        private final Map<String, List<String>> services = new LinkedHashMap<String, List<String>>();
+        private final Set<String> reachedServices = new TreeSet<String>();
+        private final Set<String> reached = new TreeSet<String>();
+        private Kind kind = Kind.NO_CLASSES;
+        private int toolkitClasses;
+        private int layerClasses;
+        private String layer;
+        private String platform;
+        private String nativeCode;
+        private boolean walked;
+
+        Library(File file) {
+            this.file = file;
+        }
+
+        /// The jar.
+        public File file() {
+            return file;
+        }
+
+        /// The jar's file name, which is what a build calls the library.
+        public String jar() {
+            return file.getName();
+        }
+
+        public Kind kind() {
+            return kind;
+        }
+
+        /// How many classes the jar holds.
+        public int classCount() {
+            return classes.size();
+        }
+
+        /// How many of them name a desktop toolkit.
+        public int toolkitClassCount() {
+            return toolkitClasses;
+        }
+
+        /// The layer that implements the jar's packages, for
+        /// [Kind#LAYER_PROVIDED]; else null.
+        public String layer() {
+            return layer;
+        }
+
+        /// What handles a [Kind#PLATFORM] jar; else null.
+        public String platform() {
+            return platform;
+        }
+
+        /// How the jar depends on native code -- "ships native libraries",
+        /// "loads native code", "calls native code through JNA" -- or null.
+        /// Such code cannot run on a device whatever else the jar does.
+        public String nativeCode() {
+            return nativeCode;
+        }
+
+        /// The internal names of the jar's classes that [#reach] found the
+        /// application to use. Empty until it has run.
+        public Set<String> reached() {
+            return reached;
+        }
+
+        /// The internal names of the classes that ship with the
+        /// application: every class of a toolkit library that is used at
+        /// all, the reached ones of a pure-Java library, none of a jar a
+        /// layer or the platform stands in for.
+        public Set<String> shipped() {
+            if (kind == Kind.UI_LIBRARY && !reached.isEmpty()) {
+                return new TreeSet<String>(classes.keySet());
+            }
+            if (kind == Kind.INCIDENTAL_TOOLKIT || kind == Kind.PURE_JAVA) {
+                return reached;
+            }
+            return new TreeSet<String>();
+        }
+
+        /// Whether the build unpacks the jar, or part of it, into the
+        /// application ([CompatLibraries]), rather than leaving it the
+        /// dependency it was.
+        public boolean managed() {
+            return kind != Kind.PLATFORM && kind != Kind.NO_CLASSES;
+        }
+
+        Set<String> classNames() {
+            return classes.keySet();
+        }
+
+        /// The services this jar lists providers for and the application
+        /// reaches, each with the provider class names its file lists, in
+        /// the file's order; names are dotted, as the file has them. Empty
+        /// until [#reach] has run.
+        public Map<String, List<String>> reachedServices() {
+            Map<String, List<String>> out = new LinkedHashMap<String, List<String>>();
+            for (Map.Entry<String, List<String>> e : services.entrySet()) {
+                if (reachedServices.contains(e.getKey())) {
+                    out.put(e.getKey(), e.getValue());
+                }
+            }
+            return out;
+        }
+
+        /// The package most of the jar's classes are in, dotted and at most
+        /// three parts deep (`com.fasterxml.jackson`); null for a jar
+        /// without classes. It is what names the library to a table of
+        /// advice, which a jar's file name does not do reliably.
+        public String mainPackage() {
+            Map<String, Integer> counts = new java.util.TreeMap<String, Integer>();
+            for (String c : classes.keySet()) {
+                int slash = c.lastIndexOf('/');
+                if (slash < 0) {
+                    continue;
+                }
+                String[] parts = c.substring(0, slash).split("/");
+                StringBuilder name = new StringBuilder();
+                for (int i = 0; i < parts.length && i < 3; i++) {
+                    name.append(i == 0 ? "" : ".").append(parts[i]);
+                }
+                Integer n = counts.get(name.toString());
+                counts.put(name.toString(), n == null ? 1 : n + 1);
+            }
+            String best = null;
+            int most = 0;
+            for (Map.Entry<String, Integer> e : counts.entrySet()) {
+                if (e.getValue() > most) {
+                    most = e.getValue();
+                    best = e.getKey();
+                }
+            }
+            return best;
+        }
+    }
+
+    /// Classifies `jars`, in order, against the desktop `layers`. A file
+    /// that is not a readable jar is left out, and a jar that is listed
+    /// twice is read once.
+    ///
+    /// Twice means the same jar, not the same file name. Two libraries of
+    /// different groups share a file name whenever they share an artifact
+    /// id and a version (`com.acme.ui:common:1.0` beside
+    /// `com.acme.data:common:1.0`), and the second is as much a dependency
+    /// as the first: left out here, none of its classes would be unpacked,
+    /// and the application would be assembled without them. So a later
+    /// file is a repeat only when it is the same file, or a copy of it
+    /// under the same name (a build that stages its dependencies hands the
+    /// repository's jar and the staged one).
+    public static List<Library> classify(Collection<File> jars, List<Relocation> layers) throws IOException {
+        List<Library> out = new ArrayList<Library>();
+        Map<String, List<File>> seen = new HashMap<String, List<File>>();
+        if (jars != null) {
+            for (File jar : jars) {
+                if (jar == null || !jar.isFile() || !jar.getName().endsWith(".jar")) {
+                    continue;
+                }
+                List<File> named = seen.get(jar.getName());
+                if (named == null) {
+                    named = new ArrayList<File>();
+                    seen.put(jar.getName(), named);
+                }
+                boolean repeat = false;
+                for (File earlier : named) {
+                    repeat = repeat || sameJar(earlier, jar);
+                }
+                if (!repeat) {
+                    named.add(jar);
+                    out.add(read(jar, layers));
+                }
+            }
+        }
+        return out;
+    }
+
+    /// Whether two files of one name are one jar: the same file, or the
+    /// same bytes.
+    private static boolean sameJar(File a, File b) throws IOException {
+        if (a.equals(b) || a.getCanonicalFile().equals(b.getCanonicalFile())) {
+            return true;
+        }
+        return a.length() == b.length()
+                && java.util.Arrays.equals(Files.readAllBytes(a.toPath()), Files.readAllBytes(b.toPath()));
+    }
+
+    private static Library read(File jar, List<Relocation> layers) throws IOException {
+        Library lib = new Library(jar);
+        int nativeFiles = 0;
+        boolean cn1 = false;
+        boolean jna = false;
+        boolean loads = false;
+        int platformClasses = 0;
+        int ownClasses = 0;
+        ZipFile zip = new ZipFile(jar);
+        try {
+            Enumeration<? extends ZipEntry> entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry e = entries.nextElement();
+                String name = e.getName();
+                if (e.isDirectory()) {
+                    continue;
+                }
+                if (isNativeLibrary(name)) {
+                    nativeFiles++;
+                    continue;
+                }
+                if (name.startsWith(SERVICES) && name.indexOf('/', SERVICES.length()) < 0
+                        && name.length() > SERVICES.length()) {
+                    InputStream in = zip.getInputStream(e);
+                    try {
+                        // Read as the runtime's ServiceLoader reads one: comments,
+                        // blank lines and repeats dropped, by the same rule.
+                        lib.services.put(name.substring(SERVICES.length()), ServiceProviderNames
+                                .of(new String(readAll(in), StandardCharsets.UTF_8), null));
+                    } finally {
+                        in.close();
+                    }
+                    continue;
+                }
+                if (!name.endsWith(".class") || name.startsWith("META-INF/") || name.endsWith("module-info.class")) {
+                    continue;
+                }
+                Scan scan = new Scan();
+                InputStream in = zip.getInputStream(e);
+                try {
+                    scan.read(readAll(in));
+                } catch (RuntimeException unreadable) {
+                    // A class file this build cannot read names nothing that
+                    // can be relocated; if the application reaches it, the
+                    // compliance check says so.
+                    continue;
+                } finally {
+                    in.close();
+                }
+                if (scan.info == null) {
+                    continue;
+                }
+                lib.classes.put(scan.info.name, scan.info);
+                loads |= scan.loadsNative;
+            }
+        } finally {
+            zip.close();
+        }
+        for (ClassInfo c : lib.classes.values()) {
+            Relocation owner = owning(c.name, layers);
+            if (owner != null) {
+                lib.layerClasses++;
+                lib.layer = owner.name();
+            }
+            for (String p : PLATFORM_PACKAGES) {
+                if (c.name.startsWith(p)) {
+                    platformClasses++;
+                }
+            }
+            if (c.name.startsWith(CN1_PACKAGE)) {
+                ownClasses++;
+            }
+            boolean toolkit = false;
+            for (String ref : c.references) {
+                if (ref.startsWith(CN1_PACKAGE) && !lib.classes.containsKey(ref)) {
+                    cn1 = true;
+                }
+                if (ref.startsWith("com/sun/jna/") && !lib.classes.containsKey(ref)) {
+                    jna = true;
+                }
+                if (!toolkit && !lib.classes.containsKey(ref) && owning(ref, layers) != null) {
+                    toolkit = true;
+                }
+            }
+            if (toolkit) {
+                lib.toolkitClasses++;
+            }
+        }
+        if (nativeFiles > 0) {
+            lib.nativeCode = "ships native libraries";
+        } else if (loads) {
+            lib.nativeCode = "loads native code";
+        } else if (jna) {
+            lib.nativeCode = "calls native code through JNA";
+        }
+        int total = lib.classes.size();
+        if (total == 0) {
+            lib.kind = Kind.NO_CLASSES;
+        } else if (lib.layerClasses * 2 > total) {
+            lib.kind = Kind.LAYER_PROVIDED;
+        } else if (platformClasses * 2 > total) {
+            lib.kind = Kind.PLATFORM;
+            lib.platform = "Kotlin runtime";
+        } else if (ownClasses * 2 > total) {
+            lib.kind = Kind.PLATFORM;
+            lib.platform = "Codename One";
+        } else if (cn1 && lib.toolkitClasses == 0) {
+            lib.kind = Kind.PLATFORM;
+            lib.platform = "Codename One library";
+        } else if (lib.toolkitClasses * 100 >= UI_SHARE_PERCENT * total) {
+            lib.kind = Kind.UI_LIBRARY;
+        } else if (lib.toolkitClasses > 0) {
+            lib.kind = Kind.INCIDENTAL_TOOLKIT;
+        } else {
+            lib.kind = Kind.PURE_JAVA;
+        }
+        if (lib.kind != Kind.LAYER_PROVIDED) {
+            lib.layer = null;
+        }
+        return lib;
+    }
+
+    private static boolean isNativeLibrary(String name) {
+        return name.endsWith(".so") || name.endsWith(".dll") || name.endsWith(".dylib") || name.endsWith(".jnilib");
+    }
+
+    private static Relocation owning(String internalName, List<Relocation> layers) {
+        for (Relocation r : layers) {
+            if (r.owns(internalName)) {
+                return r;
+            }
+        }
+        return null;
+    }
+
+    /// Marks, in each of `libraries`, the classes reachable from
+    /// `references` -- internal names, and class names as a string constant
+    /// spells them -- and answers how many classes that is.
+    ///
+    /// A jar found earlier in the list wins a class two of them hold, as on
+    /// a class path. A toolkit library that is reached at all ships whole,
+    /// so every class of it is walked. A jar a layer stands in for is not
+    /// walked: its classes do not ship, and what they refer to is not the
+    /// application's concern.
+    ///
+    /// A name that is reached and that a library lists providers for
+    /// (`META-INF/services/<name>`) reaches those providers, in every
+    /// library that lists some: see the class description.
+    public static int reach(Collection<String> references, List<Library> libraries) {
+        Map<String, Library> owner = new HashMap<String, Library>();
+        Map<String, List<Library>> listing = new HashMap<String, List<Library>>();
+        for (Library lib : libraries) {
+            for (String c : lib.classNames()) {
+                if (!owner.containsKey(c)) {
+                    owner.put(c, lib);
+                }
+            }
+            if (lib.kind == Kind.LAYER_PROVIDED || !lib.managed()) {
+                continue;
+            }
+            for (String service : lib.services.keySet()) {
+                String name = service.replace('.', '/');
+                List<Library> libs = listing.get(name);
+                if (libs == null) {
+                    libs = new ArrayList<Library>();
+                    listing.put(name, libs);
+                }
+                libs.add(lib);
+            }
+        }
+        Set<String> asked = new HashSet<String>();
+        Deque<String> queue = new ArrayDeque<String>();
+        for (String r : references) {
+            queue.add(r.indexOf('.') >= 0 ? r.replace('.', '/') : r);
+        }
+        int count = 0;
+        while (!queue.isEmpty()) {
+            String name = queue.removeFirst();
+            List<Library> providers = listing.get(name);
+            if (providers != null && asked.add(name)) {
+                for (Library listed : providers) {
+                    // A services file writes a nested class with its dollar
+                    // sign, so every dot of a name is a package separator.
+                    for (Map.Entry<String, List<String>> e : listed.services.entrySet()) {
+                        if (e.getKey().replace('.', '/').equals(name)) {
+                            listed.reachedServices.add(e.getKey());
+                            for (String provider : e.getValue()) {
+                                queue.add(provider.replace('.', '/'));
+                            }
+                        }
+                    }
+                }
+            }
+            Library lib = owner.get(name);
+            if (lib == null || !lib.reached.add(name)) {
+                continue;
+            }
+            count++;
+            if (lib.kind == Kind.LAYER_PROVIDED) {
+                continue;
+            }
+            if (lib.kind == Kind.UI_LIBRARY && !lib.walked) {
+                lib.walked = true;
+                for (ClassInfo c : lib.classes.values()) {
+                    enqueue(c, queue);
+                }
+            }
+            enqueue(lib.classes.get(name), queue);
+        }
+        return count;
+    }
+
+    private static void enqueue(ClassInfo c, Deque<String> queue) {
+        queue.addAll(c.references);
+        for (String s : c.classNames) {
+            queue.add(s.replace('.', '/'));
+        }
+    }
+
+    /// What the classes under `classesDir` refer to: the seeds of [#reach]
+    /// for a compiled application. `skip` are files, by their path inside
+    /// the directory, that are not the application's own -- a library an
+    /// earlier run unpacked. The runtimes an earlier run extracted are left
+    /// out as well. A name an earlier run relocated into one of `layers` is
+    /// answered as the application was compiled against it.
+    public static Set<String> applicationReferences(File classesDir, Set<String> skip, List<Relocation> layers)
+            throws IOException {
+        Set<String> out = new HashSet<String>();
+        collect(classesDir, "", skip, out);
+        Set<String> originals = new HashSet<String>();
+        for (String name : out) {
+            for (Relocation r : layers) {
+                String original = r.original(name);
+                if (original != null) {
+                    originals.add(original);
+                }
+            }
+        }
+        out.addAll(originals);
+        return out;
+    }
+
+    private static void collect(File dir, String rel, Set<String> skip, Set<String> out) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            String path = rel + f.getName();
+            if (f.isDirectory()) {
+                if (!CompatLayers.isExtractedRuntime(path + "/")) {
+                    collect(f, path + "/", skip, out);
+                }
+            } else if (path.endsWith(".class") && !skip.contains(path)) {
+                Scan scan = new Scan();
+                try {
+                    scan.read(Files.readAllBytes(f.toPath()));
+                } catch (RuntimeException unreadable) {
+                    continue;
+                }
+                if (scan.info != null) {
+                    out.addAll(scan.info.references);
+                    out.addAll(scan.info.classNames);
+                }
+            }
+        }
+    }
+
+    private static final Pattern IMPORT = Pattern.compile("(?m)^\\s*import\\s+(?:static\\s+)?(\\w+(?:\\.\\w+)*)(\\.\\*)?\\s*;?");
+
+    /// What the Java and Kotlin sources under `sourceDir` import: the seeds
+    /// of [#reach] for a project that has not been compiled, which is all an
+    /// import has. Each import is answered as written and, since nothing
+    /// says whether its last part is a class or a member, without it too;
+    /// `a.b.*` is answered as every class of `libraries` in that package.
+    public static Set<String> sourceReferences(File sourceDir, List<Library> libraries) throws IOException {
+        Set<String> imports = new TreeSet<String>();
+        Set<String> packages = new TreeSet<String>();
+        scanSources(sourceDir, imports, packages);
+        Set<String> out = new TreeSet<String>();
+        for (String i : imports) {
+            String name = i.replace('.', '/');
+            out.add(name);
+            int slash = name.lastIndexOf('/');
+            if (slash > 0) {
+                out.add(name.substring(0, slash));
+            }
+        }
+        for (Library lib : libraries) {
+            for (String c : lib.classNames()) {
+                int slash = c.lastIndexOf('/');
+                if (slash > 0 && packages.contains(c.substring(0, slash).replace('/', '.'))) {
+                    out.add(c);
+                }
+            }
+        }
+        return out;
+    }
+
+    private static void scanSources(File dir, Set<String> imports, Set<String> packages) throws IOException {
+        File[] files = dir == null ? null : dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                scanSources(f, imports, packages);
+            } else if (f.getName().endsWith(".java") || f.getName().endsWith(".kt")) {
+                Matcher m = IMPORT.matcher(new String(Files.readAllBytes(f.toPath()), StandardCharsets.UTF_8));
+                while (m.find()) {
+                    if (m.group(2) != null) {
+                        packages.add(m.group(1));
+                    }
+                    imports.add(m.group(1));
+                }
+            }
+        }
+    }
+
+    static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] buf = new byte[8192];
+        int n = in.read(buf);
+        while (n >= 0) {
+            out.write(buf, 0, n);
+            n = in.read(buf);
+        }
+        return out.toByteArray();
+    }
+
+    /// Reads one class file for what it refers to at run time: the names in
+    /// its supertypes, descriptors and instructions. Annotations, generic
+    /// signatures and the nesting attributes are left out -- none of them is
+    /// a class a device has to have for this one to work.
+    private static final class Scan extends Remapper {
+        private ClassInfo info;
+        private boolean loadsNative;
+
+        @Override
+        public String map(String internalName) {
+            if (info != null && internalName != null && !internalName.equals(info.name)) {
+                info.references.add(internalName);
+            }
+            return internalName;
+        }
+
+        @Override
+        public Object mapValue(Object value) {
+            if (value instanceof String && info != null && looksLikeClassName((String) value)) {
+                info.classNames.add((String) value);
+            }
+            return super.mapValue(value);
+        }
+
+        void read(byte[] bytes) {
+            ClassReader reader = new ClassReader(bytes);
+            info = new ClassInfo(reader.getClassName());
+            reader.accept(new RuntimeOnly(new ClassRemapper(new ClassWriter(0), this)),
+                    ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        }
+
+        /// Passes on what a class needs at run time and nothing else.
+        private final class RuntimeOnly extends ClassVisitor {
+            RuntimeOnly(ClassVisitor next) {
+                super(Opcodes.ASM9, next);
+            }
+
+            @Override
+            public void visit(int version, int access, String name, String signature, String superName,
+                              String[] interfaces) {
+                super.visit(version, access, name, null, superName, interfaces);
+            }
+
+            @Override
+            public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+                return null;
+            }
+
+            @Override
+            public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String descriptor,
+                                                         boolean visible) {
+                return null;
+            }
+
+            @Override
+            public void visitInnerClass(String name, String outerName, String innerName, int access) {
+                // Not a reference: a class lists every class nested in it.
+            }
+
+            @Override
+            public void visitOuterClass(String owner, String name, String descriptor) {
+                // As above.
+            }
+
+            @Override
+            public void visitNestHost(String nestHost) {
+                // As above.
+            }
+
+            @Override
+            public void visitNestMember(String nestMember) {
+                // As above.
+            }
+
+            @Override
+            public void visitPermittedSubclass(String permittedSubclass) {
+                // As above.
+            }
+
+            @Override
+            public FieldVisitor visitField(int access, String name, String descriptor, String signature,
+                                           Object value) {
+                final FieldVisitor next = super.visitField(access, name, descriptor, null, value);
+                return new FieldVisitor(Opcodes.ASM9, next) {
+                    @Override
+                    public AnnotationVisitor visitAnnotation(String d, boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String d,
+                                                                 boolean visible) {
+                        return null;
+                    }
+                };
+            }
+
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                                             String[] exceptions) {
+                // A declared exception is only ever a declaration.
+                final MethodVisitor next = super.visitMethod(access, name, descriptor, null, null);
+                return new MethodVisitor(Opcodes.ASM9, next) {
+                    @Override
+                    public AnnotationVisitor visitAnnotation(String d, boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitAnnotationDefault() {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String d,
+                                                                 boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitParameterAnnotation(int parameter, String d, boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitInsnAnnotation(int typeRef, TypePath typePath, String d,
+                                                                 boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitTryCatchAnnotation(int typeRef, TypePath typePath, String d,
+                                                                     boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, TypePath typePath,
+                                                                          Label[] start, Label[] end, int[] index,
+                                                                          String d, boolean visible) {
+                        return null;
+                    }
+
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String method, String d, boolean itf) {
+                        if (("java/lang/System".equals(owner) || "java/lang/Runtime".equals(owner))
+                                && ("loadLibrary".equals(method) || "load".equals(method))) {
+                            loadsNative = true;
+                        }
+                        super.visitMethodInsn(opcode, owner, method, d, itf);
+                    }
+                };
+            }
+        }
+    }
+
+    /// Whether `value` is shaped like a qualified class name: dotted
+    /// identifiers and nothing else. What it names is decided by whether a
+    /// library has such a class.
+    static boolean looksLikeClassName(String value) {
+        int length = value.length();
+        if (length < 3 || length > 200 || value.indexOf('.') <= 0) {
+            return false;
+        }
+        boolean start = true;
+        for (int i = 0; i < length; i++) {
+            char c = value.charAt(i);
+            if (c == '.') {
+                if (start) {
+                    return false;
+                }
+                start = true;
+            } else if (start ? Character.isJavaIdentifierStart(c) : Character.isJavaIdentifierPart(c)) {
+                start = false;
+            } else {
+                return false;
+            }
+        }
+        return !start;
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/DesktopImportReport.java b/maven/build-engine/src/main/java/com/codename1/maven/DesktopImportReport.java
new file mode 100644
index 00000000000..4e267ebeea3
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/DesktopImportReport.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+/// What an import says about the dependencies of the project it imported:
+/// one row for each jar, with what the build will do with it and what the
+/// developer should.
+///
+/// The rows come from [DependencyClassifier], which is what the build itself
+/// decides by ([CompatLibraries]), so an import cannot promise something the
+/// build then does differently. The one difference is the evidence: a build
+/// follows the references of the compiled application, an import has only
+/// the sources' `import` lines, so a class used by its full name alone is
+/// counted at build time and not here.
+public final class DesktopImportReport {
+
+    /// The newest Java release whose class files a Codename One build reads.
+    public static final int HIGHEST_JAVA = 17;
+
+    private DesktopImportReport() {
+    }
+
+    /// One dependency.
+    public static final class Row {
+        private final String dependency;
+        private final String kind;
+        private final String suggestion;
+
+        Row(String dependency, String kind, String suggestion) {
+            this.dependency = dependency;
+            this.kind = kind;
+            this.suggestion = suggestion;
+        }
+
+        /// The jar's file name.
+        public String dependency() {
+            return dependency;
+        }
+
+        /// What it was classified as ([DependencyClassifier.Kind#label]).
+        public String kind() {
+            return kind;
+        }
+
+        /// What to do about it, as one sentence or two.
+        public String suggestion() {
+            return suggestion;
+        }
+    }
+
+    /// [#rows(Collection, File, List)] against both desktop layers: an
+    /// import cannot know yet which of them the application will have.
+    public static List<Row> rows(Collection<File> jars, File sourceDir) throws IOException {
+        List<Relocation> layers = new ArrayList<Relocation>();
+        layers.add(CompatLayers.SWING);
+        layers.add(CompatLayers.JAVAFX);
+        return rows(jars, sourceDir, layers);
+    }
+
+    /// Classifies `jars` against the layers of `layers` and follows what the
+    /// sources under `sourceDir` import into them. Answers a row for each
+    /// jar that holds classes or resources, in the order given.
+    public static List<Row> rows(Collection<File> jars, File sourceDir, List<Relocation> layers) throws IOException {
+        List<DependencyClassifier.Library> libraries = DependencyClassifier.classify(jars, layers);
+        Set<String> seeds = DependencyClassifier.sourceReferences(sourceDir, libraries);
+        DependencyClassifier.reach(seeds, libraries);
+        List<Row> out = new ArrayList<Row>();
+        for (DependencyClassifier.Library lib : libraries) {
+            out.add(new Row(lib.jar(), lib.kind().label(), suggestion(lib)));
+        }
+        return out;
+    }
+
+    /// What to do about `lib`, once [DependencyClassifier#reach] has run.
+    static String suggestion(DependencyClassifier.Library lib) {
+        switch (lib.kind()) {
+            case LAYER_PROVIDED:
+                return "Keep it with scope provided: the sources compile against it and the " + lib.layer()
+                        + " layer's own classes ship in its place.";
+            case PLATFORM:
+                return "Nothing to do: the Codename One build handles it.";
+            case NO_CLASSES:
+                return "Nothing to do: it holds no classes.";
+            default:
+                break;
+        }
+        String instead = lib.mainPackage() == null ? null : ComplianceAlternatives.lookup(lib.mainPackage() + ".");
+        if (lib.reached().isEmpty()) {
+            return "The sources import nothing from it: the build leaves it out unless a class that ships uses it."
+                    + (lib.nativeCode() == null ? "" : " It " + lib.nativeCode() + ", which cannot run on a device.");
+        }
+        if (lib.nativeCode() != null) {
+            return "Replace it: it " + lib.nativeCode() + ", which cannot run on a device. "
+                    + (instead == null ? "Put what it does behind an interface with a device implementation."
+                    : instead);
+        }
+        StringBuilder out = new StringBuilder();
+        if (lib.kind() == DependencyClassifier.Kind.UI_LIBRARY) {
+            out.append("Keep it with scope compile: all ").append(lib.classCount())
+                    .append(" classes are bundled and relocated with the application.");
+        } else {
+            out.append("Keep it with scope compile: the classes the application uses are bundled (")
+                    .append(lib.reached().size()).append(" of ").append(lib.classCount())
+                    .append(" from the imports), relocated and checked.");
+        }
+        if (instead != null) {
+            out.append(" If the build reports it: ").append(instead);
+        } else {
+            out.append(" The build reports any API it uses that a device lacks.");
+        }
+        return out.toString();
+    }
+
+    /// The table as lines of text: a header, a rule, and for each row the
+    /// dependency and its class on one line with the suggestion indented
+    /// under it, since a suggestion is a sentence and a column is not.
+    public static List<String> table(List<Row> rows) {
+        int name = "Dependency".length();
+        for (Row r : rows) {
+            name = Math.max(name, r.dependency().length());
+        }
+        List<String> out = new ArrayList<String>();
+        out.add(pad("Dependency", name) + "  Class");
+        out.add(pad("", name).replace(' ', '-') + "  -----");
+        for (Row r : rows) {
+            out.add(pad(r.dependency(), name) + "  " + r.kind());
+            out.add("    " + r.suggestion());
+        }
+        return out;
+    }
+
+    private static String pad(String s, int width) {
+        StringBuilder out = new StringBuilder(s);
+        while (out.length() < width) {
+            out.append(' ');
+        }
+        return out.toString();
+    }
+
+    /// What to tell the developer about a project that declares Java
+    /// `level`; null when the build takes that level as it is, or the project
+    /// does not say (0).
+    public static String javaLevelWarning(int level) {
+        if (level <= HIGHEST_JAVA) {
+            return null;
+        }
+        return "The project is built for Java " + level + "; a Codename One application is compiled as Java "
+                + HIGHEST_JAVA + ". The imported sources are compiled with -source/-target " + HIGHEST_JAVA
+                + ", so a language feature newer than that is a compile error to rewrite, and API added to the JDK "
+                + "after " + HIGHEST_JAVA
+                + " is reported by the compliance check like any other a device lacks. A dependency whose class "
+                + "files are newer than Java " + HIGHEST_JAVA + " is rewritten to that level when it is bundled.";
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/DesktopPortReport.java b/maven/build-engine/src/main/java/com/codename1/maven/DesktopPortReport.java
new file mode 100644
index 00000000000..8cc64d8cc93
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/DesktopPortReport.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/// The port report of a Swing or JavaFX application: where it stands as a
+/// Codename One application, read top down.
+///
+/// The compliance check writes it on every run, pass or fail, to
+/// `codenameone/desktop-port-report.md` in the build directory
+/// (`-Dcn1.desktop.report=<file>` names another place). It says how much of
+/// the application builds as it is, what to change file by file with the
+/// nearest supported alternative, what became of each dependency, and what
+/// cannot run on a device at all.
+///
+/// The text is a function of the compiled classes: ordered, with no time
+/// and no absolute path in it, so it can be committed and compared.
+public final class DesktopPortReport {
+
+    /// The property that names the report file.
+    public static final String PROPERTY = "cn1.desktop.report";
+
+    /// The report's path inside the build directory.
+    public static final String DEFAULT_PATH = "codenameone/desktop-port-report.md";
+
+    /// The share of a library's shipped classes, in percent, that must use
+    /// API a device lacks before the report calls for replacing the library
+    /// rather than working around those classes.
+    static final int REPLACE_SHARE_PERCENT = 10;
+
+    private final ComplianceFindings findings;
+    private final Set<String> applicationFiles = new TreeSet<String>();
+    private final Map<String, CompatLibraries.Library> libraries = new TreeMap<String, CompatLibraries.Library>();
+    private final Map<String, Integer> libraryClassesWithFindings = new TreeMap<String, Integer>();
+    private int applicationClasses;
+    private int toolkitCallSites;
+    private int toolkitCallSitesMissing;
+    private int newerClassFiles;
+    private int newestJava;
+
+    /// A report of `findings`.
+    public DesktopPortReport(ComplianceFindings findings) {
+        this.findings = findings;
+    }
+
+    /// The application's own classes: how many, and the source files they
+    /// were compiled from, as paths from the source root.
+    public DesktopPortReport application(int classes, Collection<String> sourceFiles) {
+        applicationClasses = classes;
+        applicationFiles.addAll(sourceFiles);
+        return this;
+    }
+
+    /// How many references the application makes into a desktop toolkit,
+    /// and how many of those are to API the layers lack.
+    public DesktopPortReport toolkitCallSites(int all, int missing) {
+        toolkitCallSites = all;
+        toolkitCallSitesMissing = missing;
+        return this;
+    }
+
+    /// What the build decided about each dependency ([CompatLibraries]),
+    /// and for each library how many of its classes have a finding.
+    public DesktopPortReport libraries(Map<String, CompatLibraries.Library> recorded,
+                                       Map<String, Integer> classesWithFindings) {
+        libraries.putAll(recorded);
+        libraryClassesWithFindings.putAll(classesWithFindings);
+        return this;
+    }
+
+    /// How many class files were compiled for a Java newer than the device
+    /// format, and the newest Java among them.
+    public DesktopPortReport newerClassFiles(int count, int newestJavaVersion) {
+        newerClassFiles = count;
+        newestJava = newestJavaVersion;
+        return this;
+    }
+
+    private static int percent(int part, int whole) {
+        return whole == 0 ? 100 : (int) (part * 100L / whole);
+    }
+
+    /// What heads the APIs of a file that the alternatives table has no row
+    /// for.
+    static final String NO_ADVICE = "Not on a device, and no alternative is listed:";
+
+    /// The report, as Markdown.
+    public String render() {
+        ComplianceFindings.Source app = findings.application();
+        Map<String, List<ComplianceFindings.Api>> byFile = app.byFile();
+        List<String> unchanged = new ArrayList<String>();
+        for (String f : applicationFiles) {
+            if (!byFile.containsKey(f)) {
+                unchanged.add(f);
+            }
+        }
+        StringBuilder out = new StringBuilder();
+        out.append("# Desktop port report\n\n");
+        out.append("What it takes for this application to build and run as a Codename One application, from its "
+                + "compiled classes.\n\n");
+
+        out.append("## Summary\n\n");
+        out.append("- ").append(ComplianceFindings.plural(applicationClasses, "application class",
+                "application classes")).append(" from ").append(ComplianceFindings.plural(applicationFiles.size(),
+                "source file", "source files")).append(".\n");
+        if (toolkitCallSites > 0) {
+            int supported = toolkitCallSites - toolkitCallSitesMissing;
+            out.append("- ").append(supported).append(" of ").append(toolkitCallSites)
+                    .append(" call sites into Swing, AWT and JavaFX are supported (")
+                    .append(percent(supported, toolkitCallSites)).append("%).\n");
+        }
+        out.append("- ").append(ComplianceFindings.plural(unchanged.size(), "source file has", "source files have"))
+                .append(" no finding; ").append(byFile.size()).append(byFile.size() == 1 ? " has" : " have")
+                .append(" at least one.\n");
+        if (findings.isEmpty()) {
+            out.append("- The compliance check passes: every API the application and its libraries use is "
+                    + "available on a device.\n");
+        } else {
+            int inLibraries = findings.total() - app.callSites();
+            out.append("- The compliance check fails: ").append(ComplianceFindings.plural(findings.total(),
+                    "reference", "references")).append(" to ").append(ComplianceFindings.plural(findings.apiCount(),
+                    "API", "APIs")).append(" a device does not have (").append(app.callSites())
+                    .append(" in the application, ").append(inLibraries).append(" in its libraries).\n");
+        }
+        if (newerClassFiles > 0) {
+            out.append("- ").append(ComplianceFindings.plural(newerClassFiles, "class file was", "class files were"))
+                    .append(" compiled for a Java newer than 17 (up to Java ").append(newestJava)
+                    .append(") and rewritten to the Java 17 class format. The Java 18+ API they use is checked like "
+                            + "any other, and is listed below where a device lacks it.\n");
+        }
+        if (app.callSites() > 0) {
+            out.append("\n| In the application | Missing APIs | Call sites |\n|---|---:|---:|\n");
+            for (ComplianceFindings.Category c : ComplianceFindings.Category.values()) {
+                List<ComplianceFindings.Api> apis = app.apis(c);
+                if (!apis.isEmpty()) {
+                    out.append("| ").append(c.heading()).append(" | ").append(apis.size()).append(" | ")
+                            .append(app.callSites(c)).append(" |\n");
+                }
+            }
+        }
+
+        out.append("\n## What works unchanged\n\n");
+        if (unchanged.isEmpty()) {
+            out.append("No source file is free of findings.\n");
+        } else {
+            out.append(ComplianceFindings.plural(unchanged.size(), "source file uses", "source files use"))
+                    .append(" only API that is available on a device:\n\n");
+            for (String f : unchanged) {
+                out.append("- `").append(f).append("`\n");
+            }
+        }
+
+        out.append("\n## What to change\n\n");
+        if (byFile.isEmpty()) {
+            out.append("Nothing in the application's own sources.\n");
+        }
+        for (Map.Entry<String, List<ComplianceFindings.Api>> e : byFile.entrySet()) {
+            out.append("### `").append(e.getKey()).append("`\n\n");
+            // One entry for each thing to do: a class, its constructor and
+            // the method called on it are one change, and share their advice.
+            Map<String, List<ComplianceFindings.Api>> byAdvice = new java.util.LinkedHashMap<String,
+                    List<ComplianceFindings.Api>>();
+            for (ComplianceFindings.Api a : e.getValue()) {
+                String advice = a.alternative() == null ? NO_ADVICE : a.alternative();
+                List<ComplianceFindings.Api> list = byAdvice.get(advice);
+                if (list == null) {
+                    list = new ArrayList<ComplianceFindings.Api>();
+                    byAdvice.put(advice, list);
+                }
+                list.add(a);
+            }
+            for (Map.Entry<String, List<ComplianceFindings.Api>> advice : byAdvice.entrySet()) {
+                out.append("- ").append(advice.getKey()).append('\n');
+                for (ComplianceFindings.Api a : advice.getValue()) {
+                    out.append("  - ").append(lines(a, e.getKey())).append("`").append(a.name()).append("`\n");
+                }
+            }
+            out.append('\n');
+        }
+
+        out.append(byFile.isEmpty() ? "\n" : "").append("## Dependencies\n\n");
+        if (libraries.isEmpty()) {
+            out.append("The application ships no third-party library.\n");
+        } else {
+            out.append("| Dependency | What it is | Classes shipped | Verdict |\n|---|---|---:|---|\n");
+            for (CompatLibraries.Library lib : libraries.values()) {
+                out.append("| ").append(lib.jar()).append(" | ").append(lib.kind() == null ? "library"
+                        : lib.kind().label()).append(" | ").append(lib.shippedCount()).append(" of ")
+                        .append(lib.classCount()).append(" | ").append(verdict(lib)).append(" |\n");
+            }
+        }
+
+        out.append("\n## What cannot run on a device\n\n");
+        List<String> cannot = cannotRun(app);
+        if (cannot.isEmpty()) {
+            out.append("Nothing was found that has no counterpart on a device.\n");
+        }
+        for (String line : cannot) {
+            out.append("- ").append(line).append('\n');
+        }
+        return out.toString();
+    }
+
+    /// `line 3, 9: ` for the uses of `api` in `file`; empty without lines.
+    private static String lines(ComplianceFindings.Api api, String file) {
+        StringBuilder out = new StringBuilder();
+        for (ComplianceFindings.Use u : api.uses()) {
+            if (u.file().equals(file) && u.line() > 0) {
+                out.append(out.length() == 0 ? "" : ", ").append(u.line());
+            }
+        }
+        if (out.length() == 0) {
+            return "";
+        }
+        return (out.indexOf(",") < 0 ? "line " : "lines ") + out + ": ";
+    }
+
+    private ComplianceFindings.Source source(String jar) {
+        for (ComplianceFindings.Source s : findings.libraries()) {
+            if (jar.equals(s.library())) {
+                return s;
+            }
+        }
+        return null;
+    }
+
+    /// What the report says about one dependency.
+    String verdict(CompatLibraries.Library lib) {
+        if (lib.kind() == DependencyClassifier.Kind.LAYER_PROVIDED) {
+            return "Handled by the " + lib.layer() + " layer, whose own classes ship in its place.";
+        }
+        if (lib.shippedCount() == 0) {
+            return "Not used by the application's classes; left out.";
+        }
+        ComplianceFindings.Source s = source(lib.jar());
+        StringBuilder out = new StringBuilder();
+        if (lib.nativeCode() != null) {
+            out.append("Native code: cannot run on a device (it ").append(lib.nativeCode()).append("). ");
+        }
+        if (s == null) {
+            if (lib.nativeCode() != null) {
+                return out.append("Put what it does behind an interface with a device implementation.").toString();
+            }
+            return lib.kind() == DependencyClassifier.Kind.UI_LIBRARY
+                    ? "Works: bundled whole and relocated with the application."
+                    : "Works: the classes the application uses are relocated and pass the check.";
+        }
+        Integer classes = libraryClassesWithFindings.get(lib.jar());
+        int with = classes == null ? 0 : classes;
+        out.append(with).append(" of ").append(lib.shippedCount())
+                .append(" shipped classes use API a device lacks: ");
+        Map<String, Integer> families = new TreeMap<String, Integer>();
+        for (ComplianceFindings.Category c : ComplianceFindings.Category.values()) {
+            for (Map.Entry<String, Integer> f : s.families(c).entrySet()) {
+                String name = c == ComplianceFindings.Category.TOOLKIT ? "desktop toolkit" : f.getKey();
+                Integer n = families.get(name);
+                families.put(name, (n == null ? 0 : n) + f.getValue());
+            }
+        }
+        int i = 0;
+        for (Map.Entry<String, Integer> f : ComplianceFindings.byCount(families).entrySet()) {
+            if (i == 4) {
+                break;
+            }
+            out.append(i++ == 0 ? "" : ", ").append(f.getKey()).append(" (").append(f.getValue()).append(")");
+        }
+        out.append(". ");
+        String instead = lib.mainPackage() == null ? null : ComplianceAlternatives.lookup(lib.mainPackage() + ".");
+        if (lib.nativeCode() != null || with * 100 >= REPLACE_SHARE_PERCENT * lib.shippedCount()) {
+            out.append("Needs a device replacement");
+            return out.append(instead == null ? ", or an interface with a device implementation." : ": " + instead)
+                    .toString();
+        }
+        out.append("Close: those classes are what stands between it and a device");
+        return out.append(instead == null ? "." : ". " + instead).toString();
+    }
+
+    /// What has no counterpart on a device: libraries of native code, the
+    /// application's uses of API the alternatives table has nothing for,
+    /// and language features.
+    private List<String> cannotRun(ComplianceFindings.Source app) {
+        List<String> out = new ArrayList<String>();
+        for (CompatLibraries.Library lib : libraries.values()) {
+            if (lib.nativeCode() != null && lib.shippedCount() > 0) {
+                out.add(lib.jar() + " " + lib.nativeCode() + ". Native code written for a desktop does not run on a "
+                        + "device.");
+            }
+        }
+        // One entry per piece of advice: ProcessBuilder, its constructor
+        // and its start() are one thing a device cannot do, not three.
+        Map<String, List<ComplianceFindings.Api>> byAdvice = new java.util.LinkedHashMap<String,
+                List<ComplianceFindings.Api>>();
+        for (ComplianceFindings.Category c : ComplianceFindings.Category.values()) {
+            for (ComplianceFindings.Api a : app.apis(c)) {
+                String advice = a.alternative();
+                if (advice != null && (c == ComplianceFindings.Category.LANGUAGE || isNoEquivalent(advice))) {
+                    List<ComplianceFindings.Api> list = byAdvice.get(advice);
+                    if (list == null) {
+                        list = new ArrayList<ComplianceFindings.Api>();
+                        byAdvice.put(advice, list);
+                    }
+                    list.add(a);
+                }
+            }
+        }
+        for (Map.Entry<String, List<ComplianceFindings.Api>> e : byAdvice.entrySet()) {
+            Set<String> files = new TreeSet<String>();
+            int uses = 0;
+            StringBuilder names = new StringBuilder();
+            int named = 0;
+            for (ComplianceFindings.Api a : e.getValue()) {
+                uses += a.count();
+                for (ComplianceFindings.Use u : a.uses()) {
+                    files.add(u.file());
+                }
+                if (named < 3) {
+                    names.append(named++ == 0 ? "" : ", ").append('`').append(a.name()).append('`');
+                }
+            }
+            if (e.getValue().size() > named) {
+                names.append(" and ").append(e.getValue().size() - named).append(" more");
+            }
+            StringBuilder where = new StringBuilder();
+            int shown = 0;
+            for (String f : files) {
+                if (shown == 6) {
+                    where.append(" and ").append(files.size() - shown).append(" more");
+                    break;
+                }
+                where.append(shown++ == 0 ? "" : ", ").append('`').append(f).append('`');
+            }
+            out.add(names + " (" + ComplianceFindings.plural(uses, "use", "uses") + " in " + where + "). "
+                    + e.getKey());
+        }
+        return out;
+    }
+
+    /// Whether `advice` says a device has nothing for the API, as against
+    /// naming what to use instead.
+    static boolean isNoEquivalent(String advice) {
+        return advice.startsWith("No ") || advice.startsWith("A device cannot")
+                || advice.startsWith("Native code");
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/DesktopProjectImporter.java b/maven/build-engine/src/main/java/com/codename1/maven/DesktopProjectImporter.java
new file mode 100644
index 00000000000..ccb84ae1f6f
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/DesktopProjectImporter.java
@@ -0,0 +1,1320 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+import com.codename1.builders.BuildException;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/// Imports a Swing or JavaFX project (a Maven or Gradle project, or one
+/// module of it) into a Codename One application: copies its `src/main`
+/// sources and resources into `src/main/desktop`, writes the application's
+/// Codename One main class so that it starts the imported application, and
+/// reports what becomes of each of its dependencies.
+///
+/// #### The main class
+///
+/// The class `codename1.packageName` and `codename1.mainName` name is written
+/// as an ordinary source file in `src/main/java` ([#mainClassSource]). It
+/// is the application's own from then on, edited like any main class:
+///
+/// - for a Swing application it extends the Swing layer's `DesktopLifecycle`
+///   and its `runMain()` calls the desktop application's `main` with no
+///   arguments;
+/// - for a JavaFX one it extends the JavaFX layer's `FxLifecycle` and its
+///   `createApplication()` answers `new` of the `Application` subclass. The
+///   desktop `main` is not called: all a JavaFX `main` does is `launch`, and
+///   the lifecycle is what launches here.
+///
+/// Both are plain calls the compiler checks; nothing is looked up by name. A
+/// class the main class cannot reach from its package (a `main` class that is
+/// not public) is called through a small public launcher written beside it
+/// ([#LAUNCHER]). The source the main class replaces is kept as
+/// `<name>.java.pre-desktop-import`.
+///
+/// #### Library mode
+///
+/// Desktop sources need not BE the application. Imported with `library` set,
+/// or into a project whose main class starts an imported Android application
+/// (it extends `AndroidLifecycle`), nothing is written to the main class: the
+/// desktop classes ship relocated, and the application uses them as it uses
+/// any library (`SwingInterop.asComponent`, `FxInterop.asComponent`).
+///
+/// Nothing is asked. The entry point is found by reading the sources, and
+/// where they leave a choice the source project's own main-class setting
+/// decides it; when that does not either, the import stops before copying
+/// anything and lists the candidates.
+public final class DesktopProjectImporter {
+
+    /// The kind of an application started through a `main` method.
+    public static final String KIND_SWING = "swing";
+
+    /// The kind of an application started through its
+    /// `javafx.application.Application` subclass.
+    public static final String KIND_JAVAFX = "javafx";
+
+    /// The class written beside a desktop entry point the main class cannot
+    /// reach from its own package, to call it from inside that package.
+    static final String LAUNCHER = "CN1DesktopLauncher";
+
+    /// The first line of every source the import writes, which is how a later
+    /// import tells its own output from a class the developer wrote.
+    static final String WRITTEN_BY = "// Written by cn1:import-desktop-project.";
+
+    static final String SWING_LIFECYCLE = "com.codename1.desktopcompat.rt.DesktopLifecycle";
+    static final String FX_LIFECYCLE = "com.codename1.fxcompat.runtime.FxLifecycle";
+
+    /// The record an import leaves in `src/main/desktop`; see [ImportedFiles].
+    static final String IMPORT_RECORD = ".desktop-import-files";
+
+    private static final Charset UTF8 = Charset.forName("UTF-8");
+
+    /// Coordinates a desktop layer implements, by exact `group:artifact`.
+    static final Map<String, String> COVERED = new LinkedHashMap<String, String>();
+
+    /// Coordinates a desktop layer implements, by `group:artifact` prefix.
+    static final String[][] COVERED_PREFIXES = {
+        {"org.swinglabs.swingx:swingx-", "SwingX"},
+    };
+
+    static {
+        COVERED.put("org.openjfx:javafx-controls", "JavaFX controls");
+        COVERED.put("org.openjfx:javafx-fxml", "FXML");
+        COVERED.put("org.openjfx:javafx-graphics", "JavaFX graphics");
+        COVERED.put("org.openjfx:javafx-base", "JavaFX base");
+        COVERED.put("org.jetbrains.kotlin:kotlin-stdlib", "Kotlin standard library");
+        COVERED.put("org.jetbrains.kotlin:kotlin-stdlib-jdk7", "Kotlin standard library");
+        COVERED.put("org.jetbrains.kotlin:kotlin-stdlib-jdk8", "Kotlin standard library");
+    }
+
+    /// What an import says about a dependency no layer implements, when it
+    /// could not read the jar and say more ([DesktopImportReport]). Such a
+    /// library is application code: the build bundles the classes the
+    /// application uses and relocates them with it
+    /// ([CompatRemapper#withApplicationLibraries]).
+    public static final String BUNDLED_NOTE = "the classes the application uses are bundled and relocated; "
+            + "unsupported API they use will be reported at build time";
+
+    /// Whether `coordinate` (`group:artifact`) is a module of a toolkit a
+    /// layer stands in for. One the layer does not implement cannot be added
+    /// as a library: its classes are the toolkit's own.
+    public static boolean isToolkitModule(String coordinate) {
+        return coordinate.startsWith("org.openjfx:");
+    }
+
+    /// The suffix the main class source the import replaced is kept under.
+    static final String SET_ASIDE_SUFFIX = ".pre-desktop-import";
+
+    /// Dependencies that only matter to tests.
+    static final String[] IGNORED = {"junit:", "org.junit", "org.mockito", "org.testfx", "org.hamcrest",
+        "org.assertj"};
+
+    public static final class Result {
+        public final List<String> covered = new ArrayList<String>();
+        /// Dependencies no layer implements, by `group:artifact`. They are
+        /// not copied: add each to the application's own build, where it is
+        /// handled as [#BUNDLED_NOTE] says.
+        public final List<String> uncovered = new ArrayList<String>();
+        /// What the import could not read from the project's build, as
+        /// sentences.
+        public final List<String> unresolved = new ArrayList<String>();
+        /// The dependencies the application's own build has to declare for
+        /// the imported sources to compile, each with the scope it needs
+        /// there; see [Library]. A plugin adds them to the build it is
+        /// importing into.
+        public final List<Library> libraries = new ArrayList<Library>();
+        /// The application's main class (`codename1.packageName` and
+        /// `codename1.mainName`) when the import wrote it to start the
+        /// desktop application; null in library mode, when the import was
+        /// not told the project's main class, or when it kept a main class
+        /// the developer changed since an earlier import.
+        public String generatedMain;
+        /// The source file of [#generatedMain].
+        public File mainSource;
+        /// Where the main class source the import replaced was kept; null
+        /// when there was none, or an earlier import already kept it.
+        public File setAside;
+        /// True when the desktop sources were imported as a library: no main
+        /// class was written, and the application starts as it did.
+        public boolean library;
+        /// The `module-info.java` files that were left out, relative to
+        /// `src/main/desktop`. A Codename One application is not a module.
+        public final List<String> droppedModuleInfo = new ArrayList<String>();
+        /// The class the application starts through, as the desktop sources
+        /// declare it; null in library mode when none was chosen.
+        public String mainClass;
+        /// [#KIND_SWING] or [#KIND_JAVAFX]; null with [#mainClass].
+        public String kind;
+        public boolean kotlin;
+        public int copiedFiles;
+        /// The Java release the project's build compiles for, or 0 when its
+        /// build files do not say. See [DesktopImportReport#javaLevelWarning].
+        public int javaLevel;
+    }
+
+    /// A dependency of the imported project that the application's build has
+    /// to declare too.
+    ///
+    /// Nothing a layer authors under the toolkit's own names is one: the
+    /// JavaFX layer's jar already holds `javafx.*`. SwingX is different, and
+    /// for the reason Swing is -- the layer's classes live under the names
+    /// they ship with, so the sources can only be compiled against the real
+    /// library. It is therefore declared `provided`: there to compile
+    /// against, never bundled, with the layer's own classes shipping in its
+    /// place. A library no layer implements is application code and is
+    /// declared `compile`, which is what makes the build bundle and
+    /// relocate it ([CompatRemapper#withApplicationLibraries]).
+    public static final class Library {
+        public final String groupId;
+        public final String artifactId;
+        /// As the project's build spells it, with a property of the same
+        /// build file resolved; null when the build file does not say (a
+        /// managed version, a version catalog), and the dependency then has
+        /// to be added by hand.
+        public final String version;
+        /// True for `provided`, false for `compile`.
+        public final boolean provided;
+
+        Library(String groupId, String artifactId, String version, boolean provided) {
+            this.groupId = groupId;
+            this.artifactId = artifactId;
+            this.version = version;
+            this.provided = provided;
+        }
+
+        /// `group:artifact`.
+        public String coordinate() {
+            return groupId + ":" + artifactId;
+        }
+    }
+
+    /// A class the application could be started through.
+    static final class Candidate {
+        /// The binary name: `pkg.Outer$Nested`.
+        final String name;
+        boolean javafx;
+        /// False when the class, or a class it is nested in, is not public:
+        /// only its own package can name it.
+        boolean accessible = true;
+        /// True for a Kotlin `fun main()` without parameters, which Java
+        /// calls as `main()`: the `main(String[])` Kotlin adds beside it is
+        /// synthetic, and javac does not see it.
+        boolean noArgMain;
+
+        Candidate(String name) {
+            this.name = name;
+        }
+
+        String kind() {
+            return javafx ? KIND_JAVAFX : KIND_SWING;
+        }
+
+        /// The name source code uses for the class.
+        String sourceName() {
+            return name.replace('$', '.');
+        }
+
+        String packageName() {
+            int dot = name.lastIndexOf('.');
+            return dot < 0 ? "" : name.substring(0, dot);
+        }
+    }
+
+    private final Log log;
+
+    public DesktopProjectImporter(Log log) {
+        this.log = log;
+    }
+
+    private static boolean hasSources(File dir) {
+        return new File(dir, "src/main/java").isDirectory() || new File(dir, "src/main/kotlin").isDirectory();
+    }
+
+    /// The directory whose `src/main` is imported: `source/<module>` when a
+    /// module is named, else `source` itself, else the one directory directly
+    /// inside it that has sources.
+    public static File moduleDir(File source, String module) throws BuildException {
+        if (module != null && module.length() > 0) {
+            File m = new File(source, module);
+            if (!hasSources(m)) {
+                throw new BuildException("No src/main/java or src/main/kotlin under " + m);
+            }
+            return m;
+        }
+        if (hasSources(source)) {
+            return source;
+        }
+        List<File> found = new ArrayList<File>();
+        File[] children = source.listFiles();
+        if (children != null) {
+            Arrays.sort(children);
+            for (File c : children) {
+                if (c.isDirectory() && hasSources(c)) {
+                    found.add(c);
+                }
+            }
+        }
+        if (found.size() == 1) {
+            return found.get(0);
+        }
+        if (found.isEmpty()) {
+            throw new BuildException("No src/main/java or src/main/kotlin under " + source
+                    + " or the directories directly inside it");
+        }
+        StringBuilder names = new StringBuilder();
+        for (File f : found) {
+            names.append(names.length() == 0 ? "" : ", ").append(f.getName());
+        }
+        throw new BuildException(source + " has several modules with sources (" + names
+                + "); name the one to import with -Dcn1.desktop.module=");
+    }
+
+    /// Imports `source` (or its `module`) into the application whose common
+    /// module is `commonDir`. `mainClassOverride`, when not null, names the
+    /// entry point and no other is considered.
+    public Result importProject(File source, String module, File commonDir, String mainClassOverride)
+            throws BuildException {
+        return importProject(source, module, commonDir, mainClassOverride, null, null);
+    }
+
+    /// As [#importProject(File, String, File, String, String, String, boolean)]
+    /// for an application whose desktop sources are not a library.
+    public Result importProject(File source, String module, File commonDir, String mainClassOverride,
+                                String mainPackage, String mainName) throws BuildException {
+        return importProject(source, module, commonDir, mainClassOverride, mainPackage, mainName, false);
+    }
+
+    /// As [#importProject(File, String, File, String)], for an application
+    /// whose main class is `mainPackage`.`mainName` (its
+    /// `codename1.packageName` and `codename1.mainName`). That class is
+    /// written to start the imported application; see the class
+    /// documentation. With `library` set -- or when the main class starts an
+    /// imported Android application -- it is left alone and the desktop
+    /// sources are imported as a library.
+    public Result importProject(File source, String module, File commonDir, String mainClassOverride,
+                                String mainPackage, String mainName, boolean library) throws BuildException {
+        File moduleDir = moduleDir(source, module);
+        File main = new File(moduleDir, "src/main");
+        File target = new File(commonDir, "src/main/desktop");
+        Result r = new Result();
+        try {
+            String generated = mainName == null || mainName.trim().length() == 0 ? null
+                    : (mainPackage == null || mainPackage.trim().length() == 0 ? "" : mainPackage.trim() + ".")
+                    + mainName.trim();
+            if (!library && generated != null && startsAndroidApplication(commonDir, generated)) {
+                // A project starts ONE application, and this one already
+                // starts an Android application: the desktop classes are
+                // what its code can use.
+                log.info(generated + " starts the imported Android application and is kept; the desktop sources "
+                        + "are imported as a library");
+                library = true;
+            }
+            r.library = library;
+            // Decided from the source project, before anything is copied: an
+            // import that cannot tell how the application starts leaves the
+            // application as it found it.
+            Map<String, Candidate> candidates = new TreeMap<String, Candidate>();
+            scan(new File(main, "java"), candidates);
+            scan(new File(main, "kotlin"), candidates);
+            Candidate entry = library ? null
+                    : chooseEntry(candidates, mainClassOverride, declaredMainClasses(source, moduleDir));
+            if (generated != null && declares(main, generated)) {
+                throw new BuildException("Nothing was imported: the desktop project has a class named " + generated
+                        + ", which is the name of this application's main class (codename1.packageName and "
+                        + "codename1.mainName). A project has one class of a name, so the main class needs a name "
+                        + "the imported sources do not use: change codename1.mainName in "
+                        + "codenameone_settings.properties and import again.");
+            }
+            if (entry != null && generated != null && entry.packageName().length() == 0
+                    && generated.indexOf('.') > 0) {
+                throw new BuildException("Nothing was imported: " + entry.name + " is in the default package, and "
+                        + "the main class " + generated + " is not, so it cannot call it: Java has no way to name "
+                        + "a class of the default package from another. Move " + entry.name + " into a package.");
+            }
+
+            ImportedFiles files = new ImportedFiles(target, IMPORT_RECORD, "the desktop project", log)
+                    .skipping("module-info.java")
+                    // The application is packaged by the Codename One build,
+                    // which writes the manifest of whatever it produces.
+                    .skipping("MANIFEST.MF");
+            for (String name : new String[] {"java", "kotlin", "resources"}) {
+                File src = new File(main, name);
+                if (src.isDirectory()) {
+                    r.copiedFiles += files.copy(src, new File(target, name), name);
+                }
+            }
+            files.removeStale();
+            files.write();
+            for (String skipped : files.skipped()) {
+                if (skipped.endsWith("module-info.java")) {
+                    r.droppedModuleInfo.add(skipped);
+                    log.info("Left out " + skipped + ": a Codename One application is not a Java module");
+                }
+            }
+            if (entry != null) {
+                r.mainClass = entry.name;
+                r.kind = entry.kind();
+                if (generated != null) {
+                    writeMainClass(commonDir, generated, entry, r);
+                }
+            }
+            readDependencies(moduleDir, r);
+            r.javaLevel = javaLevel(source, moduleDir);
+            if (ImportedFiles.hasKotlin(target)) {
+                // The application's Kotlin build switches on when
+                // src/main/kotlin exists; it compiles the desktop sources too.
+                File kotlinDir = new File(commonDir, "src/main/kotlin");
+                if (!kotlinDir.isDirectory()) {
+                    if (!kotlinDir.mkdirs()) {
+                        throw new IOException("Cannot create " + kotlinDir);
+                    }
+                    Files.write(new File(kotlinDir, ".keep").toPath(), new byte[0]);
+                    log.info("The desktop sources include Kotlin: created " + kotlinDir
+                            + " so the application compiles Kotlin");
+                }
+                r.kotlin = true;
+            }
+        } catch (IOException e) {
+            throw new BuildException("Import failed: " + e.getMessage(), e);
+        }
+        return r;
+    }
+
+    /// Whether the sources under `main` declare the top-level class `name`.
+    ///
+    /// A Java class is the file of its name. A Kotlin file's name says
+    /// nothing: `MyApp.kt` of top-level functions compiles to `MyAppKt`, and
+    /// any file may declare `class MyApp`. So every Kotlin file is read for
+    /// its package and its top-level classes, objects and interfaces, and
+    /// for a `@file:JvmName` that gives its facade the name.
+    static boolean declares(File main, String name) throws IOException {
+        String path = name.replace('.', '/');
+        if (new File(main, "java/" + path + ".java").isFile()) {
+            return true;
+        }
+        int dot = name.lastIndexOf('.');
+        String pkg = dot < 0 ? "" : name.substring(0, dot);
+        String simple = name.substring(dot + 1);
+        Pattern type = Pattern.compile("(?m)^(?:(?:public|internal|private|open|final|abstract|sealed|data|enum"
+                + "|annotation|value|inline|expect|actual|fun)\\s+)*(?:class|object|interface)\\s+"
+                + Pattern.quote(simple) + "\\b");
+        for (String dir : new String[] {"kotlin", "java"}) {
+            List<File> files = new ArrayList<File>();
+            kotlinFiles(new File(main, dir), files);
+            for (File f : files) {
+                String raw = read(f);
+                Matcher named = KOTLIN_FILE_NAME.matcher(raw);
+                String text = code(raw);
+                Matcher p = PACKAGE.matcher(text);
+                if (!(p.find() ? p.group(1) : "").equals(pkg)) {
+                    continue;
+                }
+                if (type.matcher(text).find() || (named.find() && named.group(1).equals(simple))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static void kotlinFiles(File dir, List<File> out) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                kotlinFiles(f, out);
+            } else if (f.getName().endsWith(".kt")) {
+                out.add(f);
+            }
+        }
+    }
+
+    /// The source files the class `className` could have in the application:
+    /// Java, then Kotlin.
+    private static File[] mainSources(File commonDir, String className) {
+        String path = className.replace('.', '/');
+        return new File[] {new File(commonDir, "src/main/java/" + path + ".java"),
+            new File(commonDir, "src/main/kotlin/" + path + ".kt")};
+    }
+
+    /// Whether the application's main class is the one an Android import
+    /// wrote, or one like it: a class that starts an Android application.
+    private static boolean startsAndroidApplication(File commonDir, String className) throws IOException {
+        for (File f : mainSources(commonDir, className)) {
+            if (f.isFile() && code(read(f)).indexOf("AndroidLifecycle") >= 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The source of the main class `className` (`pkg.Name`) that starts
+    /// `entry`: what the import writes. `launcher` is true when the entry
+    /// point is called through [#LAUNCHER] in its own package.
+    static String mainClassSource(String className, Candidate entry, boolean launcher) {
+        int dot = className.lastIndexOf('.');
+        String pkg = dot < 0 ? "" : className.substring(0, dot);
+        String simple = className.substring(dot + 1);
+        String callee = launcher ? entry.packageName() + "." + LAUNCHER : entry.sourceName();
+        StringBuilder b = new StringBuilder();
+        b.append(WRITTEN_BY).append('\n');
+        if (pkg.length() > 0) {
+            b.append("package ").append(pkg).append(";\n\n");
+        }
+        if (entry.javafx) {
+            b.append("/// This application's Codename One main class. It starts the JavaFX application\n"
+                    + "/// ").append(entry.name).append(": on the event dispatch thread, which is the\n"
+                    + "/// JavaFX application thread, FxLifecycle creates it, then calls its init() and\n"
+                    + "/// start(Stage).\n");
+        } else {
+            b.append("/// This application's Codename One main class. It starts the Swing application\n"
+                    + "/// ").append(entry.name).append(" by calling its main method on the event\n"
+                    + "/// dispatch thread, which is the Swing event dispatch thread.\n");
+        }
+        b.append("///\n"
+                + "/// Edit it as any main class. Extending the lifecycle is what makes the desktop\n"
+                + "/// windows the application: closing the last one exits it. A main class that\n"
+                + "/// extends com.codename1.system.Lifecycle instead uses the desktop classes as a\n"
+                + "/// library, and closing the last window shows the form it was shown over.\n");
+        if (entry.javafx) {
+            b.append("public class ").append(simple).append(" extends ").append(FX_LIFECYCLE).append(" {\n"
+                    + "    @Override\n"
+                    + "    protected javafx.application.Application createApplication() {\n"
+                    + "        return ").append(launcher ? callee + ".create()" : "new " + callee + "()")
+                    .append(";\n    }\n}\n");
+        } else {
+            b.append("public class ").append(simple).append(" extends ").append(SWING_LIFECYCLE).append(" {\n"
+                    + "    @Override\n"
+                    + "    protected void runMain() throws Exception {\n"
+                    + "        ").append(launcher ? callee + ".launch()" : swingCall(callee, entry))
+                    .append(";\n    }\n}\n");
+        }
+        return b.toString();
+    }
+
+    private static String swingCall(String callee, Candidate entry) {
+        return callee + (entry.noArgMain ? ".main()" : ".main(new String[0])");
+    }
+
+    /// The source of [#LAUNCHER] in the package of `entry`: a public class
+    /// the main class can name, which calls an entry point only its own
+    /// package can.
+    static String launcherSource(Candidate entry) {
+        StringBuilder b = new StringBuilder();
+        b.append(WRITTEN_BY).append('\n')
+                .append("package ").append(entry.packageName()).append(";\n\n")
+                .append("/// Calls ").append(entry.name).append(", which is not public, for the application's\n"
+                        + "/// main class in another package.\n")
+                .append("public final class ").append(LAUNCHER).append(" {\n")
+                .append("    private ").append(LAUNCHER).append("() {\n    }\n\n");
+        if (entry.javafx) {
+            b.append("    public static javafx.application.Application create() {\n"
+                    + "        return new ").append(entry.sourceName()).append("();\n    }\n}\n");
+        } else {
+            b.append("    public static void launch() throws Exception {\n"
+                    + "        ").append(swingCall(entry.sourceName(), entry)).append(";\n    }\n}\n");
+        }
+        return b.toString();
+    }
+
+    /// Writes the application's main class, and the launcher beside the
+    /// entry point when the main class cannot name it.
+    ///
+    /// The source it replaces -- the one the project template wrote, say --
+    /// is kept as `<name>.java.pre-desktop-import`. A second import keeps
+    /// that first copy, and rewrites the main class only while it is what an
+    /// import wrote ([#WRITTEN_BY]): one the developer has edited since is
+    /// theirs, and is kept with a warning. A Kotlin source of the same class
+    /// is moved aside the same way, since a project has one class of a name.
+    private void writeMainClass(File commonDir, String className, Candidate entry, Result r) throws IOException {
+        int dot = className.lastIndexOf('.');
+        boolean launcher = !entry.accessible && !entry.packageName().equals(dot < 0 ? "" : className.substring(0, dot));
+        File[] sources = mainSources(commonDir, className);
+        File javaFile = sources[0];
+        File kotlinFile = sources[1];
+        byte[] text = mainClassSource(className, entry, launcher).getBytes(UTF8);
+        if (javaFile.isFile()) {
+            byte[] current = Files.readAllBytes(javaFile.toPath());
+            if (!Arrays.equals(current, text)) {
+                File backup = new File(javaFile.getPath() + SET_ASIDE_SUFFIX);
+                if (!backup.exists()) {
+                    Files.copy(javaFile.toPath(), backup.toPath());
+                    r.setAside = backup;
+                    log.info("Kept the previous " + javaFile.getName() + " as " + backup.getName());
+                } else if (!new String(current, UTF8).startsWith(WRITTEN_BY)) {
+                    // The backup holds the original already, and this file
+                    // is the developer's since: there is no slot to keep it.
+                    log.warn(javaFile.getName() + " was changed after an earlier import and was left as it is; "
+                            + "delete it and import again to have it written to start " + entry.name);
+                    return;
+                }
+            }
+        }
+        if (kotlinFile.isFile()) {
+            File backup = new File(kotlinFile.getPath() + SET_ASIDE_SUFFIX);
+            if (backup.exists()) {
+                throw new IOException(kotlinFile + " and " + backup + " both exist; delete one of them");
+            }
+            Files.move(kotlinFile.toPath(), backup.toPath());
+            r.setAside = r.setAside == null ? backup : r.setAside;
+            log.info("Moved " + kotlinFile.getName() + " aside as " + backup.getName() + ": " + className
+                    + " is now written in Java, to start the imported application");
+        }
+        File parent = javaFile.getParentFile();
+        if (!parent.isDirectory() && !parent.mkdirs()) {
+            throw new IOException("Cannot create " + parent);
+        }
+        Files.write(javaFile.toPath(), text);
+        if (launcher) {
+            File l = new File(commonDir, "src/main/java/" + entry.packageName().replace('.', '/') + "/" + LAUNCHER
+                    + ".java");
+            if (!l.getParentFile().isDirectory() && !l.getParentFile().mkdirs()) {
+                throw new IOException("Cannot create " + l.getParentFile());
+            }
+            Files.write(l.toPath(), launcherSource(entry).getBytes(UTF8));
+        }
+        r.generatedMain = className;
+        r.mainSource = javaFile;
+        log.info("Wrote " + className + " to start " + entry.name + " (" + entry.kind() + ")");
+    }
+
+    /// Picks the entry point.
+    ///
+    /// In order: the override; the only candidate; the candidate the source
+    /// project's build names as its main class. A build that names a plain
+    /// launcher class, in a project with exactly one
+    /// `javafx.application.Application` subclass, means that subclass: the
+    /// launcher only exists to call it, and the JavaFX layer starts the
+    /// application class itself.
+    Candidate chooseEntry(Map<String, Candidate> candidates, String override, List<String> declared)
+            throws BuildException {
+        if (override != null && override.length() > 0) {
+            Candidate c = candidates.get(override);
+            if (c == null) {
+                throw new BuildException("-Dcn1.desktop.mainClass=" + override + " names no class that extends "
+                        + "javafx.application.Application or declares public static void main(String[]). "
+                        + describe(candidates));
+            }
+            return c;
+        }
+        if (candidates.isEmpty()) {
+            throw new BuildException("Nothing was imported: no class extends javafx.application.Application or "
+                    + "declares public static void main(String[]), so there is nothing to start. To use the "
+                    + "classes from this application's own code instead, import them as a library "
+                    + "(-Dcn1.desktop.library=true).");
+        }
+        if (candidates.size() == 1) {
+            return candidates.values().iterator().next();
+        }
+        for (String name : declared) {
+            Candidate c = candidates.get(name);
+            if (c == null) {
+                continue;
+            }
+            if (!c.javafx) {
+                Candidate onlyApplication = null;
+                int applications = 0;
+                for (Candidate other : candidates.values()) {
+                    if (other.javafx) {
+                        onlyApplication = other;
+                        applications++;
+                    }
+                }
+                if (applications == 1) {
+                    log.info("The project's main class " + name + " is a launcher; the application starts through "
+                            + onlyApplication.name);
+                    return onlyApplication;
+                }
+            }
+            return c;
+        }
+        throw new BuildException("Nothing was imported: the project has several classes it could start through, "
+                + "and its build names none of them as the main class. " + describe(candidates)
+                + " Name one with -Dcn1.desktop.mainClass=");
+    }
+
+    private static String describe(Map<String, Candidate> candidates) {
+        if (candidates.isEmpty()) {
+            return "The sources have no such class.";
+        }
+        StringBuilder b = new StringBuilder("Candidates:");
+        for (Candidate c : candidates.values()) {
+            b.append("\n  ").append(c.name).append(" (").append(c.kind()).append(')');
+        }
+        b.append('\n');
+        return b.toString();
+    }
+
+    // ---- entry point detection -------------------------------------------
+
+    private static final Pattern NOISE = Pattern.compile(
+            "\"\"\".*?\"\"\"|\"(?:\\\\.|[^\"\\\\\\n])*\"|'(?:\\\\.|[^'\\\\\\n])*'|/\\*.*?\\*/|//[^\\n]*",
+            Pattern.DOTALL);
+    private static final Pattern PACKAGE = Pattern.compile("(?m)^\\s*package\\s+([\\w.]+)");
+    private static final Pattern FX_IMPORT = Pattern.compile(
+            "(?m)^\\s*import\\s+javafx\\.application\\.(?:Application|\\*)\\s*;?\\s*$");
+    private static final Pattern JAVA_EXTENDS = Pattern.compile(
+            "\\bclass\\s+(\\w+)\\s*(?:<[^{]*?>)?\\s*extends\\s+((?:javafx\\.application\\.)?Application)\\b");
+    private static final Pattern JAVA_MAIN = Pattern.compile(
+            "\\b(?:public\\s+static|static\\s+public)\\s+(?:final\\s+)?void\\s+main\\s*\\(\\s*(?:final\\s+)?String\\s*"
+            + "(?:\\[\\s*\\]\\s*\\w+|\\.\\.\\.\\s*\\w+|\\s+\\w+\\s*\\[\\s*\\])\\s*\\)");
+    private static final Pattern KOTLIN_EXTENDS = Pattern.compile(
+            "\\bclass\\s+(\\w+)[^{\\n]*?:[^{\\n]*?((?:javafx\\.application\\.)?Application)\\s*\\(");
+    // `public` may be spelled out between the annotation and `fun`.
+    private static final Pattern KOTLIN_STATIC_MAIN = Pattern.compile(
+            "@JvmStatic\\s+(?:public\\s+)?fun\\s+main\\s*\\(");
+    // At the start of a line, so top level; `public` is the default
+    // visibility spelled out and `suspend` still gets the static facade
+    // main. A private or internal one is not an entry point.
+    private static final Pattern KOTLIN_TOP_MAIN = Pattern.compile(
+            "(?m)^(?:(?:public|suspend)\\s+)*fun\\s+main\\s*\\(");
+    private static final Pattern KOTLIN_FILE_NAME = Pattern.compile("@file\\s*:\\s*JvmName\\s*\\(\\s*\"(\\w+)\"");
+
+    /// Source text with its comments and string literals blanked, so a class
+    /// name in a comment is not read as a declaration.
+    static String code(String source) {
+        return NOISE.matcher(source).replaceAll(" ");
+    }
+
+    private void scan(File dir, Map<String, Candidate> out) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        Arrays.sort(files);
+        for (File f : files) {
+            if (f.isDirectory()) {
+                scan(f, out);
+            } else if (f.getName().endsWith(".java") && !"module-info.java".equals(f.getName())) {
+                String name = f.getName().substring(0, f.getName().length() - ".java".length());
+                scanJava(name, new String(Files.readAllBytes(f.toPath()), UTF8), out);
+            } else if (f.getName().endsWith(".kt")) {
+                String name = f.getName().substring(0, f.getName().length() - ".kt".length());
+                scanKotlin(name, new String(Files.readAllBytes(f.toPath()), UTF8), out);
+            }
+        }
+    }
+
+    private static Candidate candidate(Map<String, Candidate> out, String name) {
+        Candidate c = out.get(name);
+        if (c == null) {
+            c = new Candidate(name);
+            out.put(name, c);
+        }
+        return c;
+    }
+
+    /// `fileClass` is the file's name without its extension, which is the
+    /// name of the public class a Java file declares.
+    static void scanJava(String fileClass, String source, Map<String, Candidate> out) {
+        String code = code(source);
+        Matcher pkg = PACKAGE.matcher(code);
+        String prefix = pkg.find() ? pkg.group(1) + "." : "";
+        boolean imported = FX_IMPORT.matcher(code).find();
+        Matcher ext = JAVA_EXTENDS.matcher(code);
+        while (ext.find()) {
+            if (ext.group(2).indexOf('.') < 0 && !imported) {
+                // Some other class called Application.
+                continue;
+            }
+            String cls = ext.group(1);
+            String binary = cls.equals(fileClass) ? cls : fileClass + "$" + cls;
+            Candidate c = candidate(out, prefix + binary);
+            c.javafx = true;
+            c.accessible = javaPublic(code, binary);
+        }
+        Matcher main = JAVA_MAIN.matcher(code);
+        while (main.find()) {
+            // The class is the one the method is written in: a static nested
+            // class compiles to Outer$Nested, and a file can hold a second
+            // top-level class. Recording the file's name for either leaves
+            // an entry the build then rejects for having no main.
+            String declared = declaration(code, main.start(), JAVA_DECLARATION);
+            String binary = declared == null ? fileClass : declared;
+            candidate(out, prefix + binary).accessible = javaPublic(code, binary);
+        }
+    }
+
+    /// Whether every class of the binary name `binary` (without its package,
+    /// `Outer$Nested`) is declared `public` in `code`, so that another
+    /// package can name it.
+    static boolean javaPublic(String code, String binary) {
+        for (String simple : binary.split("\\$")) {
+            Matcher m = Pattern.compile("(?<![\\w.])((?:[\\w-]+\\s+)*)(?:class|interface|enum|record)\\s+"
+                    + Pattern.quote(simple) + "\\b").matcher(code);
+            boolean found = false;
+            while (m.find()) {
+                found = true;
+                if (!PUBLIC.matcher(m.group(1)).find()) {
+                    return false;
+                }
+            }
+            if (!found) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static final Pattern PUBLIC = Pattern.compile("\\bpublic\\b");
+
+    /// A Java type declaration, in the two groups [#declaration] reads.
+    /// `X.class` is not one.
+    private static final Pattern JAVA_DECLARATION = Pattern.compile(
+            "(?<![.\\w])(class|interface|enum|record)\\s+(\\w+)");
+
+    private static final Pattern KOTLIN_DECLARATION = Pattern.compile(
+            "(?<!:)\\b(companion\\s+object|object|class|interface)\\b(?:\\s+(\\w+))?");
+
+    /// The binary name, without its package, of the class a `@JvmStatic`
+    /// function at `at` is a static method of: the `object` it is declared
+    /// in, or the class whose `companion object` it is declared in (the
+    /// static method is generated on the class, not on the companion).
+    /// Nested declarations are joined with `$`. Null when the function is
+    /// inside no declaration this can read, and the caller falls back on the
+    /// file's name.
+    ///
+    /// `code` has its comments and string literals blanked, so every brace
+    /// in it is a block's.
+    static String kotlinDeclaration(String code, int at) {
+        return declaration(code, at, KOTLIN_DECLARATION);
+    }
+
+    /// The same walk for either language. `declaration` matches a type
+    /// declaration with its kind in group 1 and its name in group 2.
+    private static String declaration(String code, int at, Pattern declaration) {
+        // What each open block is: a declaration's name, "" for a companion
+        // object, null for anything else (a function body, a lambda).
+        List<String> open = new ArrayList<String>();
+        int header = 0;
+        for (int i = 0; i < at; i++) {
+            char c = code.charAt(i);
+            if (c == '{') {
+                String name = null;
+                Matcher m = declaration.matcher(code.substring(header, i));
+                // The last one before the brace: a property or a function
+                // without a body can stand between two blocks. `X::class`
+                // is not a declaration.
+                while (m.find()) {
+                    name = m.group(1).startsWith("companion") ? "" : m.group(2);
+                }
+                open.add(name);
+                header = i + 1;
+            } else if (c == '}') {
+                if (!open.isEmpty()) {
+                    open.remove(open.size() - 1);
+                }
+                header = i + 1;
+            } else if (c == ';') {
+                header = i + 1;
+            }
+        }
+        StringBuilder out = new StringBuilder();
+        for (String name : open) {
+            if (name == null) {
+                // Inside a function: a local declaration, which has no
+                // name a launcher could use.
+                return null;
+            }
+            if (name.length() > 0) {
+                out.append(out.length() == 0 ? "" : "$").append(name);
+            }
+        }
+        return out.length() == 0 ? null : out.toString();
+    }
+
+    static void scanKotlin(String fileClass, String source, Map<String, Candidate> out) {
+        // The annotation's argument is a string literal, which code() blanks.
+        Matcher named = KOTLIN_FILE_NAME.matcher(source);
+        String code = code(source);
+        Matcher pkg = PACKAGE.matcher(code);
+        String prefix = pkg.find() ? pkg.group(1) + "." : "";
+        boolean imported = FX_IMPORT.matcher(code).find();
+        Matcher ext = KOTLIN_EXTENDS.matcher(code);
+        while (ext.find()) {
+            if (ext.group(2).indexOf('.') < 0 && !imported) {
+                continue;
+            }
+            // A nested class compiles to Outer$Nested, whatever the file
+            // is called; the walk answers null at the top level.
+            String outer = kotlinDeclaration(code, ext.start());
+            candidate(out, prefix + (outer == null ? "" : outer + "$") + ext.group(1)).javafx = true;
+        }
+        Matcher staticMain = KOTLIN_STATIC_MAIN.matcher(code);
+        while (staticMain.find()) {
+            // The class is the declaration the function is written in, which
+            // Kotlin does not tie to the file's name.
+            String declared = kotlinDeclaration(code, staticMain.start());
+            candidate(out, prefix + (declared == null ? fileClass : declared)).noArgMain =
+                    noParameters(code, staticMain.end());
+        }
+        Matcher topMain = KOTLIN_TOP_MAIN.matcher(code);
+        if (topMain.find()) {
+            // A top-level function compiles into the file's facade class.
+            String facade = named.find() ? named.group(1)
+                    : Character.toUpperCase(fileClass.charAt(0)) + fileClass.substring(1) + "Kt";
+            candidate(out, prefix + facade).noArgMain = noParameters(code, topMain.end());
+        }
+    }
+
+    /// Whether the parameter list opened just before `at` is empty.
+    private static boolean noParameters(String code, int at) {
+        for (int i = at; i < code.length(); i++) {
+            char c = code.charAt(i);
+            if (c == ')') {
+                return true;
+            }
+            if (!Character.isWhitespace(c)) {
+                return false;
+            }
+        }
+        return false;
+    }
+
+    // ---- the source project's build --------------------------------------
+
+    private static String read(File f) throws IOException {
+        return f.isFile() ? new String(Files.readAllBytes(f.toPath()), UTF8) : "";
+    }
+
+    /// The build files that describe the module: its own, then the ones of the
+    /// project it is a module of.
+    private static List<String> buildFiles(File source, File moduleDir, String... names) throws IOException {
+        List<String> out = new ArrayList<String>();
+        for (String name : names) {
+            String text = read(new File(moduleDir, name));
+            if (text.length() > 0) {
+                out.add(text);
+            }
+        }
+        if (!source.equals(moduleDir)) {
+            for (String name : names) {
+                String text = read(new File(source, name));
+                if (text.length() > 0) {
+                    out.add(text);
+                }
+            }
+        }
+        return out;
+    }
+
+    private static final Pattern POM_MAIN = Pattern.compile(
+            "<(exec\\.mainClass|mainClass|main\\.class|Main-Class)>\\s*([^<\\s]+)\\s*</\\1>");
+    private static final Pattern GRADLE_MAIN = Pattern.compile(
+            "\\bmainClass(?:Name)?\\s*(?:=|\\.set\\s*\\(|\\()?\\s*[\"']([^\"']+)[\"']");
+    private static final Pattern GRADLE_MANIFEST_MAIN = Pattern.compile(
+            "[\"']Main-Class[\"']\\s*(?::|to|,)\\s*[\"']([^\"']+)[\"']");
+    private static final Pattern MANIFEST_MAIN = Pattern.compile("(?m)^Main-Class:\\s*(\\S+)");
+
+    /// The main classes the source project's build names, most specific
+    /// first: `exec.mainClass` and `mainClass` in a pom, `mainClass` in a
+    /// Gradle `application` or `javafx` block, and a manifest's `Main-Class`.
+    static List<String> declaredMainClasses(File source, File moduleDir) throws IOException {
+        Set<String> out = new LinkedHashSet<String>();
+        for (String pom : buildFiles(source, moduleDir, "pom.xml")) {
+            Matcher m = POM_MAIN.matcher(pom);
+            while (m.find()) {
+                add(out, resolve(m.group(2), pom));
+            }
+        }
+        for (String gradle : buildFiles(source, moduleDir, "build.gradle.kts", "build.gradle")) {
+            Matcher m = GRADLE_MAIN.matcher(gradle);
+            while (m.find()) {
+                add(out, m.group(1));
+            }
+            m = GRADLE_MANIFEST_MAIN.matcher(gradle);
+            while (m.find()) {
+                add(out, m.group(1));
+            }
+        }
+        Matcher m = MANIFEST_MAIN.matcher(read(new File(moduleDir, "src/main/resources/META-INF/MANIFEST.MF")));
+        if (m.find()) {
+            add(out, m.group(1));
+        }
+        return new ArrayList<String>(out);
+    }
+
+    /// A pom value, with a `${property}` it consists of replaced by that
+    /// property's value where the same pom defines it.
+    private static String resolve(String value, String pom) {
+        if (value.startsWith("${") && value.endsWith("}")) {
+            String name = value.substring(2, value.length() - 1);
+            Matcher m = Pattern.compile("<" + Pattern.quote(name) + ">\\s*([^<\\s]+)\\s*</" + Pattern.quote(name) + ">")
+                    .matcher(pom);
+            return m.find() ? m.group(1) : null;
+        }
+        return value;
+    }
+
+    /// [#resolve] against `pom`, and when the property is not defined there,
+    /// against each of `poms` in turn: a property is inherited too.
+    private static String resolveIn(String value, String pom, List<String> poms) {
+        String v = resolve(value, pom);
+        for (int i = 0; v == null && i < poms.size(); i++) {
+            v = resolve(value, poms.get(i));
+        }
+        return v;
+    }
+
+    /// A compiler plugin's own configuration: it wins over the properties.
+    private static final Pattern POM_COMPILER = Pattern.compile(
+            "<artifactId>\\s*maven-compiler-plugin\\s*</artifactId>(.*?)</plugin>", Pattern.DOTALL);
+    private static final String[] POM_LEVEL_ELEMENTS = {"release", "source", "target"};
+    private static final String[] POM_LEVEL_PROPERTIES = {"maven.compiler.release", "maven.compiler.source",
+        "maven.compiler.target"};
+    private static final Pattern[] GRADLE_LEVELS = {
+        Pattern.compile("JavaLanguageVersion\\.of\\(\\s*(\\d+)\\s*\\)"),
+        Pattern.compile("jvmToolchain\\(\\s*(\\d+)\\s*\\)"),
+        Pattern.compile("(?:sourceCompatibility|targetCompatibility|options\\.release)\\s*(?:=|\\.set\\()?\\s*"
+                + "(?:JavaVersion\\.VERSION_|JavaVersion\\.toVersion\\(\\s*)?[\"']?(1[._]\\d|\\d+)"),
+    };
+
+    /// The Java release the build of `moduleDir` compiles for: what its own
+    /// build file says, else what the project it is a module of says, else 0.
+    ///
+    /// In a pom the compiler plugin's configuration is read before the
+    /// `maven.compiler.*` properties, as Maven does, and `release` before
+    /// `source` before `target`. A value spelled through a property is
+    /// resolved in the same file; one that cannot be is passed over.
+    static int javaLevel(File source, File moduleDir) throws IOException {
+        for (String pom : buildFiles(source, moduleDir, "pom.xml")) {
+            Matcher plugin = POM_COMPILER.matcher(pom);
+            while (plugin.find()) {
+                for (String name : POM_LEVEL_ELEMENTS) {
+                    int level = level(element(plugin.group(1), name), pom);
+                    if (level > 0) {
+                        return level;
+                    }
+                }
+            }
+            for (String name : POM_LEVEL_PROPERTIES) {
+                int level = level(element(pom, name), pom);
+                if (level > 0) {
+                    return level;
+                }
+            }
+        }
+        for (String gradle : buildFiles(source, moduleDir, "build.gradle.kts", "build.gradle")) {
+            for (Pattern p : GRADLE_LEVELS) {
+                Matcher m = p.matcher(gradle);
+                if (m.find()) {
+                    int level = level(m.group(1), "");
+                    if (level > 0) {
+                        return level;
+                    }
+                }
+            }
+        }
+        return 0;
+    }
+
+    /// `17`, `1.8` or `1_8` as a release number; 0 for anything else.
+    private static int level(String value, String pom) {
+        String v = value == null ? null : resolve(value, pom);
+        if (v == null) {
+            return 0;
+        }
+        if (v.startsWith("1.") || v.startsWith("1_")) {
+            v = v.substring(2);
+        }
+        if (v.length() == 0 || v.length() > 3) {
+            return 0;
+        }
+        for (int i = 0; i < v.length(); i++) {
+            if (v.charAt(i) < '0' || v.charAt(i) > '9') {
+                return 0;
+            }
+        }
+        return Integer.parseInt(v);
+    }
+
+    private static void add(Set<String> out, String name) {
+        if (name == null || name.indexOf("${") >= 0) {
+            // A property this build file does not define.
+            return;
+        }
+        // A modular build writes module/class.
+        int slash = name.lastIndexOf('/');
+        out.add(slash < 0 ? name : name.substring(slash + 1));
+    }
+
+    private static final Pattern POM_DEPENDENCY = Pattern.compile("<dependency>(.*?)</dependency>", Pattern.DOTALL);
+    private static final Pattern GRADLE_DEPENDENCY = Pattern.compile(
+            "(implementation|api|compileOnly|runtimeOnly)\\s*\\(?\\s*[\"']([^\"':]+:[^\"':]+)(?::([^\"':@]*)[^\"']*)?[\"']");
+    private static final Pattern GRADLE_FX_MODULES = Pattern.compile("\\bmodules\\s*(?:=|\\()([^\\n]*)");
+    private static final Pattern GRADLE_FX_MODULE = Pattern.compile("[\"']javafx\\.(\\w+)[\"']");
+
+    private static String element(String xml, String name) {
+        Matcher m = Pattern.compile("<" + name + ">\\s*([^<\\s]+)\\s*</" + name + ">").matcher(xml);
+        return m.find() ? m.group(1) : null;
+    }
+
+    /// The dependencies of the project in `moduleDir` that the application
+    /// importing it has to declare: what [Result#libraries] of an import of
+    /// it holds, for a plugin that edits the application's build before
+    /// anything is copied.
+    public static List<Library> librariesOf(File moduleDir) throws BuildException {
+        Result r = new Result();
+        try {
+            readDependencies(moduleDir, r);
+        } catch (IOException e) {
+            throw new BuildException("Could not read the build of " + moduleDir + ": " + e.getMessage(), e);
+        }
+        return r.libraries;
+    }
+
+    private static final Pattern POM_PARENT = Pattern.compile("<parent>(.*?)</parent>", Pattern.DOTALL);
+    private static final Pattern POM_NO_RELATIVE_PATH = Pattern.compile(
+            "<relativePath\\s*/>|<relativePath>\\s*</relativePath>");
+    /// How many parents up a module's POM is followed: deeper than any real
+    /// build, and an end to two POMs that name each other.
+    private static final int MAX_PARENTS = 12;
+
+    /// The POM of the module in `moduleDir`, then its parent's, then that
+    /// one's, as far as they are files of the source tree: a parent is read
+    /// from where the module says it is (`relativePath`, `../pom.xml` when
+    /// it says nothing), and only when the POM found there is the one the
+    /// module names.
+    ///
+    /// A parent that is not in the tree -- one resolved from a repository,
+    /// as `spring-boot-starter-parent` is -- is not fetched: an import reads
+    /// the files it was given and does not run Maven. It is named in
+    /// [Result#unresolved], since what it declares for its modules is then
+    /// unknown here. Neither are profiles activated or imported BOMs
+    /// expanded; this is the dependencies a POM spells out, not the
+    /// effective model.
+    static List<String> pomChain(File moduleDir, Result r) throws IOException {
+        // Read without their comments: a dependency, a parent or a property
+        // kept commented out is not part of the project, and the patterns
+        // here would match it all the same.
+        List<String> chain = new ArrayList<String>();
+        File dir = moduleDir.getAbsoluteFile();
+        String pom = withoutXmlComments(read(new File(dir, "pom.xml")));
+        if (pom.length() == 0) {
+            return chain;
+        }
+        chain.add(pom);
+        for (int depth = 0; depth < MAX_PARENTS; depth++) {
+            Matcher parent = POM_PARENT.matcher(pom);
+            if (!parent.find()) {
+                break;
+            }
+            String named = element(parent.group(1), "groupId") + ":" + element(parent.group(1), "artifactId");
+            String relative = element(parent.group(1), "relativePath");
+            File file = null;
+            // An empty relativePath is how a POM says its parent is not on disk.
+            if (!POM_NO_RELATIVE_PATH.matcher(parent.group(1)).find()) {
+                file = new File(dir, relative == null ? "../pom.xml" : relative);
+                if (file.isDirectory()) {
+                    file = new File(file, "pom.xml");
+                }
+            }
+            String text = file == null ? "" : withoutXmlComments(read(file));
+            // Maven takes the file only when it is the POM asked for, by
+            // all three coordinates: a POM of the right artifact id in
+            // another group, or at another version, is some other project's,
+            // and Maven resolves the parent from a repository instead.
+            if (text.length() == 0 || !isPom(text, parent.group(1))) {
+                r.unresolved.add("the parent POM " + named + " is not among the project's files; dependencies it "
+                        + "declares for its modules were not read: add the ones the application needs to its "
+                        + "build by hand");
+                break;
+            }
+            chain.add(text);
+            pom = text;
+            dir = file.getAbsoluteFile().getParentFile();
+        }
+        return chain;
+    }
+
+    /// Whether the POM `text` is the one the `<parent>` element `asked`
+    /// names. A POM that leaves out its group id or version has its own
+    /// parent's. A coordinate written with a property on either side
+    /// (`${revision}`) is not compared: resolving it is the effective
+    /// model's work, which an import does not do.
+    private static boolean isPom(String text, String asked) {
+        Matcher up = POM_PARENT.matcher(text);
+        String inherited = up.find() ? up.group(1) : "";
+        String artifact = projectElement(text, "artifactId");
+        if (artifact == null || !artifact.equals(element(asked, "artifactId"))) {
+            return false;
+        }
+        for (String name : new String[] {"groupId", "version"}) {
+            String own = projectElement(text, name);
+            if (own == null) {
+                own = element(inherited, name);
+            }
+            String wanted = element(asked, name);
+            if (own != null && wanted != null && own.indexOf("${") < 0 && wanted.indexOf("${") < 0
+                    && !own.equals(wanted)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static final Pattern XML_TAG = Pattern.compile("<(/?)([\\w.:-]+)[^<>]*?(/?)>");
+
+    /// The text of the element `name` that is a child of the document's
+    /// root, or null. [#element] takes the first one anywhere, which for a
+    /// POM that inherits its group id is a dependency's.
+    static String projectElement(String xml, String name) {
+        Matcher m = XML_TAG.matcher(xml);
+        int depth = 0;
+        while (m.find()) {
+            if (m.group(3).length() > 0) {
+                continue;
+            }
+            if (m.group(1).length() > 0) {
+                depth--;
+                continue;
+            }
+            if (depth == 1 && name.equals(m.group(2))) {
+                int end = xml.indexOf('<', m.end());
+                String value = end < 0 ? "" : xml.substring(m.end(), end).trim();
+                return value.length() == 0 ? null : value;
+            }
+            depth++;
+        }
+        return null;
+    }
+
+    private static final Pattern XML_COMMENT = Pattern.compile("(?s)<!--.*?-->");
+
+    static String withoutXmlComments(String xml) {
+        return xml.indexOf("<!--") < 0 ? xml : XML_COMMENT.matcher(xml).replaceAll(" ");
+    }
+
+    static void readDependencies(File moduleDir, Result r) throws IOException {
+        Set<String> coords = new LinkedHashSet<String>();
+        Map<String, String> versions = new java.util.HashMap<String, String>();
+        // What the desktop host supplies (Maven's provided scope, Gradle's
+        // compileOnly): compiled against and never shipped, so it is
+        // declared provided here too rather than bundled into the app.
+        // Declared both ways, the shipped declaration wins.
+        Set<String> provided = new java.util.HashSet<String>();
+        Set<String> shipped = new java.util.HashSet<String>();
+        boolean catalog = false;
+        // The module's own POM, then its parents': Maven hands a parent's
+        // <dependencies> down to every module, so they are this module's as
+        // much as the ones it spells out. (Its dependencyManagement is not:
+        // that only says which version a module would get if it asked.)
+        List<String> poms = pomChain(moduleDir, r);
+        for (String text : poms) {
+            // Managed versions and plugin dependencies are not the module's.
+            String pom = text.replaceAll("(?s)<dependencyManagement>.*?</dependencyManagement>", " ")
+                    .replaceAll("(?s)<build>.*?</build>", " ");
+            Matcher dep = POM_DEPENDENCY.matcher(pom);
+            while (dep.find()) {
+                String group = element(dep.group(1), "groupId");
+                String artifact = element(dep.group(1), "artifactId");
+                String scope = element(dep.group(1), "scope");
+                if (group != null && artifact != null && !"test".equals(scope)
+                        && !coords.contains(group + ":" + artifact)) {
+                    // The nearest declaration wins, as it does in Maven.
+                    coords.add(group + ":" + artifact);
+                    ("provided".equals(scope) ? provided : shipped).add(group + ":" + artifact);
+                    String version = element(dep.group(1), "version");
+                    version = version == null ? null : resolveIn(version, pom, poms);
+                    if (version != null && version.indexOf("${") < 0) {
+                        versions.put(group + ":" + artifact, version);
+                    }
+                }
+            }
+        }
+        for (String name : new String[] {"build.gradle.kts", "build.gradle"}) {
+            String gradle = read(new File(moduleDir, name));
+            Matcher g = GRADLE_DEPENDENCY.matcher(gradle);
+            while (g.find()) {
+                coords.add(g.group(2));
+                ("compileOnly".equals(g.group(1)) ? provided : shipped).add(g.group(2));
+                String version = g.group(3);
+                if (version != null && version.length() > 0 && version.indexOf('$') < 0) {
+                    versions.put(g.group(2), version);
+                }
+            }
+            // The JavaFX Gradle plugin's javafx { modules = [...] }.
+            Matcher modules = GRADLE_FX_MODULES.matcher(gradle);
+            while (modules.find()) {
+                Matcher module = GRADLE_FX_MODULE.matcher(modules.group(1));
+                while (module.find()) {
+                    coords.add("org.openjfx:javafx-" + module.group(1));
+                }
+            }
+            catalog |= gradle.contains("libs.");
+        }
+        for (String coord : coords) {
+            boolean ignored = false;
+            for (String i : IGNORED) {
+                if (coord.startsWith(i)) {
+                    ignored = true;
+                }
+            }
+            if (ignored) {
+                continue;
+            }
+            String covered = COVERED.get(coord);
+            // Covered by a prefix: implemented by a layer under the names it
+            // ships with, so still needed to compile against.
+            boolean compiledAgainst = false;
+            if (covered == null) {
+                for (String[] prefix : COVERED_PREFIXES) {
+                    if (coord.startsWith(prefix[0])) {
+                        covered = prefix[1];
+                        compiledAgainst = true;
+                    }
+                }
+            }
+            if (covered != null) {
+                r.covered.add(coord + " (" + covered + ")");
+            } else {
+                r.uncovered.add(coord);
+            }
+            if (compiledAgainst || (covered == null && !isToolkitModule(coord))) {
+                int colon = coord.indexOf(':');
+                r.libraries.add(new Library(coord.substring(0, colon), coord.substring(colon + 1), versions.get(coord),
+                        compiledAgainst || (provided.contains(coord) && !shipped.contains(coord))));
+            }
+        }
+        if (catalog) {
+            r.unresolved.add("dependencies declared through a version catalog (libs.*) were not resolved; "
+                    + "add the ones the application needs to its build by hand");
+        }
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/DesktopSources.java b/maven/build-engine/src/main/java/com/codename1/maven/DesktopSources.java
new file mode 100644
index 00000000000..3e22897781e
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/DesktopSources.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.builders.BuildException;
+
+import java.io.File;
+import java.io.IOException;
+
+/// The desktop sources of an application module: `src/main/desktop`, holding
+/// a Swing or JavaFX application as its own build laid it out.
+///
+/// ```
+/// src/main/desktop/java       Java sources
+/// src/main/desktop/kotlin     Kotlin sources (optional)
+/// src/main/desktop/resources  classpath resources: .fxml, .css, .properties, images
+/// ```
+///
+/// Nothing in the directory says how the application starts. That is the
+/// project's Codename One main class, an ordinary source file in
+/// `src/main/java` that `cn1:import-desktop-project` writes
+/// ([DesktopProjectImporter]): it extends the Swing or JavaFX lifecycle and
+/// calls the desktop application from source. A project whose main class
+/// does neither uses the desktop sources as a library.
+///
+/// The directory existing is what switches the desktop layers on: the project
+/// templates add both runtime jars when it does, and the remap step ships
+/// whichever of them the compiled sources use
+/// ([CompatLayers#active(Iterable, Iterable)]). Both build plugins read the
+/// layout from here, so they cannot disagree on it.
+public final class DesktopSources {
+
+    private DesktopSources() {
+    }
+
+    /// Whether the module has desktop sources, which is what enables the
+    /// desktop layers.
+    public static boolean isDesktopProject(File desktopDir) {
+        return desktopDir != null && desktopDir.isDirectory();
+    }
+
+    public static File javaDir(File desktopDir) {
+        return new File(desktopDir, "java");
+    }
+
+    public static File kotlinDir(File desktopDir) {
+        return new File(desktopDir, "kotlin");
+    }
+
+    public static File resourcesDir(File desktopDir) {
+        return new File(desktopDir, "resources");
+    }
+
+    /// The desktop layers whose API the sources under `desktopDir` name, as
+    /// text: `""`, `"Swing"`, `"JavaFX"` or `"Swing,JavaFX"`.
+    ///
+    /// This is not what decides which runtime ships -- the compiled classes
+    /// do ([CompatLayers#active(Iterable, Iterable)]). It is a cheap value
+    /// that changes when that decision may have: Gradle makes it an input of
+    /// the task that takes the decision, so that the task runs again.
+    public static String toolkitsNamedIn(File desktopDir) {
+        boolean[] named = new boolean[DESKTOP_LAYERS.length];
+        try {
+            scan(javaDir(desktopDir), named);
+            scan(kotlinDir(desktopDir), named);
+        } catch (IOException e) {
+            throw new java.io.UncheckedIOException(e);
+        }
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < named.length; i++) {
+            if (named[i]) {
+                out.append(out.length() == 0 ? "" : ",").append(DESKTOP_LAYERS[i].name());
+            }
+        }
+        return out.toString();
+    }
+
+    private static final Relocation[] DESKTOP_LAYERS = {CompatLayers.SWING, CompatLayers.JAVAFX};
+
+    private static void scan(File dir, boolean[] named) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                scan(f, named);
+            } else if (f.getName().endsWith(".java") || f.getName().endsWith(".kt")) {
+                String text = new String(java.nio.file.Files.readAllBytes(f.toPath()), "UTF-8");
+                for (int i = 0; i < named.length; i++) {
+                    named[i] = named[i] || DESKTOP_LAYERS[i].namedInSource(text);
+                }
+            }
+        }
+    }
+
+    /// Fails when the module has desktop sources but neither desktop runtime
+    /// among its dependencies: the sources could compile (Swing code compiles
+    /// against the JDK itself) and would then reach the compliance check as
+    /// plain unsupported API. `artifactIds` are the module's resolved
+    /// dependencies.
+    public static void requireRuntime(File desktopDir, Iterable<String> artifactIds) throws BuildException {
+        if (!isDesktopProject(desktopDir)) {
+            return;
+        }
+        for (String id : artifactIds) {
+            if (CompatLayers.SWING.artifactId().equals(id) || CompatLayers.JAVAFX.artifactId().equals(id)) {
+                return;
+            }
+        }
+        throw new BuildException("src/main/desktop exists but neither the " + CompatLayers.SWING.artifactId()
+                + " nor the " + CompatLayers.JAVAFX.artifactId()
+                + " dependency is present; add both to the common module (scope provided).");
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ImportedFiles.java b/maven/build-engine/src/main/java/com/codename1/maven/ImportedFiles.java
new file mode 100644
index 00000000000..5f2a1d75d1d
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ImportedFiles.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.Log;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/// The files an import copied into an application, and the record that lets
+/// the next import of the same project tell its own copies from the
+/// developer's work.
+///
+/// An import leaves one `<sha-256> <path>` line per file it copied in a record
+/// file inside the directory it copied into. Importing again then updates
+/// only what is still exactly as the earlier import wrote it: a file the
+/// developer changed since is kept, a file that left the source project is
+/// removed, and a file the developer added was never in the record at all.
+/// Both project importers ([AndroidProjectImporter], [DesktopProjectImporter])
+/// copy through this, so they behave the same on a repeated import.
+final class ImportedFiles {
+
+    private final File target;
+    private final String recordName;
+    private final String sourceName;
+    private final Log log;
+    private final Map<String, String> previous;
+    private final Map<String, String> imported = new TreeMap<String, String>();
+    private final List<String> skipNames = new ArrayList<String>();
+    private final List<String> skipped = new ArrayList<String>();
+    private String deferred;
+
+    /// `target` is the directory copied into, `recordName` the record file's
+    /// name inside it, and `sourceName` what a message calls the project
+    /// imported from ("the Android project").
+    ImportedFiles(File target, String recordName, String sourceName, Log log) throws IOException {
+        this.target = target;
+        this.recordName = recordName;
+        this.sourceName = sourceName;
+        this.log = log;
+        this.previous = read(new File(target, recordName));
+    }
+
+    /// Names a path whose hash [#copy] leaves unrecorded, because the caller
+    /// rewrites the file after copying it and records it itself ([#record]).
+    /// Such a file is always part of an import, so it is never stale either.
+    ImportedFiles deferring(String path) {
+        this.deferred = path;
+        return this;
+    }
+
+    /// Files with this name are not copied; each one met is listed in
+    /// [#skipped].
+    ImportedFiles skipping(String fileName) {
+        skipNames.add(fileName);
+        return this;
+    }
+
+    /// The paths, relative to the target, of the files [#skipping] left out.
+    List<String> skipped() {
+        return skipped;
+    }
+
+    /// Whether this import recorded `path`, by copying it or by keeping the
+    /// developer's edited version of it.
+    boolean has(String path) {
+        return imported.containsKey(path);
+    }
+
+    /// Records `path` as holding the bytes it has now.
+    void record(String path) throws IOException {
+        imported.put(path, sha256(new File(target, path.replace('/', File.separatorChar))));
+    }
+
+    /// Copies `src` to `dest`, recording each copied file's path (relative to
+    /// the target, `/` separated) and content hash. Answers the number of
+    /// files copied.
+    ///
+    /// A file an earlier import wrote and the developer changed since (its
+    /// bytes no longer match the earlier record) is kept, and so is a file no
+    /// import wrote that differs from the copy on offer. The first is kept as
+    /// [#removeStale] keeps one: it is recorded with its earlier hash, so the
+    /// next import still recognizes the edit, and deleting it lets an import
+    /// copy it afresh.
+    int copy(File src, File dest, String path) throws IOException {
+        if (src.isDirectory()) {
+            int n = 0;
+            File[] files = src.listFiles();
+            if (files != null) {
+                java.util.Arrays.sort(files);
+                for (File f : files) {
+                    n += copy(f, new File(dest, f.getName()), path + "/" + f.getName());
+                }
+            }
+            return n;
+        }
+        if (skipNames.contains(src.getName())) {
+            skipped.add(path);
+            return 0;
+        }
+        String recorded = previous.get(path);
+        if (recorded != null && dest.isFile() && !recorded.equals(sha256(dest))
+                && !java.util.Arrays.equals(Files.readAllBytes(src.toPath()), Files.readAllBytes(dest.toPath()))) {
+            log.warn("Kept " + dest + ": it was changed after the earlier import, so " + sourceName + "'s copy "
+                    + "was not imported; delete it and import again to take that copy");
+            imported.put(path, recorded);
+            return 0;
+        }
+        if (recorded == null && dest.isFile()
+                && !java.util.Arrays.equals(Files.readAllBytes(src.toPath()), Files.readAllBytes(dest.toPath()))) {
+            // No import wrote this file, so it is the developer's: one that
+            // was in the tree before the first import, or one added at a path
+            // the imported project grew later. It is left out of the record,
+            // which keeps removeStale from ever taking it for an import's.
+            log.warn("Kept " + dest + ": it was not written by an import, so " + sourceName + "'s copy "
+                    + "was not imported; delete it and import again to take that copy");
+            return 0;
+        }
+        File parent = dest.getParentFile();
+        if (parent != null && !parent.isDirectory() && !parent.mkdirs()) {
+            throw new IOException("Cannot create " + parent);
+        }
+        Files.copy(src.toPath(), dest.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING);
+        if (!path.equals(deferred)) {
+            imported.put(path, sha256(dest));
+        }
+        return 1;
+    }
+
+    /// Removes what an earlier import copied and this one did not, so a file
+    /// deleted or renamed upstream does not stay behind to be compiled or
+    /// packaged. Only a file listed in the earlier import's record is a
+    /// candidate, and only while it still holds exactly the bytes that import
+    /// wrote: a file the developer added, or edited after importing it, is
+    /// kept. Directories the removal empties go too.
+    void removeStale() throws IOException {
+        for (Map.Entry<String, String> e : previous.entrySet()) {
+            String path = e.getKey();
+            if (imported.containsKey(path) || path.equals(deferred) || path.contains("..")) {
+                continue;
+            }
+            File f = new File(target, path.replace('/', File.separatorChar));
+            if (!f.isFile()) {
+                continue;
+            }
+            if (!e.getValue().equals(sha256(f))) {
+                log.warn("Kept " + f + ": it is no longer in " + sourceName + ", but it was changed after "
+                        + "the earlier import");
+                continue;
+            }
+            Files.delete(f.toPath());
+            log.info("Removed " + f + ": it is no longer in " + sourceName);
+            File dir = f.getParentFile();
+            while (dir != null && !dir.equals(target)) {
+                String[] left = dir.list();
+                if (left == null || left.length > 0 || !dir.delete()) {
+                    break;
+                }
+                dir = dir.getParentFile();
+            }
+        }
+    }
+
+    /// Writes the record of this import.
+    void write() throws IOException {
+        StringBuilder b = new StringBuilder();
+        for (Map.Entry<String, String> e : imported.entrySet()) {
+            b.append(e.getValue()).append(' ').append(e.getKey()).append('\n');
+        }
+        if (!target.isDirectory() && !target.mkdirs()) {
+            throw new IOException("Cannot create " + target);
+        }
+        Files.write(new File(target, recordName).toPath(), b.toString().getBytes(Charset.forName("UTF-8")));
+    }
+
+    private static Map<String, String> read(File f) throws IOException {
+        Map<String, String> out = new TreeMap<String, String>();
+        if (!f.isFile()) {
+            return out;
+        }
+        for (String line : Files.readAllLines(f.toPath(), Charset.forName("UTF-8"))) {
+            int sp = line.indexOf(' ');
+            if (sp > 0 && sp < line.length() - 1) {
+                out.put(line.substring(sp + 1), line.substring(0, sp));
+            }
+        }
+        return out;
+    }
+
+    static String sha256(File f) throws IOException {
+        try {
+            byte[] d = MessageDigest.getInstance("SHA-256").digest(Files.readAllBytes(f.toPath()));
+            StringBuilder b = new StringBuilder(d.length * 2);
+            for (byte x : d) {
+                b.append(Character.forDigit((x >> 4) & 0xf, 16)).append(Character.forDigit(x & 0xf, 16));
+            }
+            return b.toString();
+        } catch (NoSuchAlgorithmException e) {
+            throw new IOException("SHA-256 is unavailable", e);
+        }
+    }
+
+    /// Whether any file under `dir` is Kotlin source.
+    static boolean hasKotlin(File dir) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return false;
+        }
+        for (File f : files) {
+            if (f.isDirectory() ? hasKotlin(f) : f.getName().endsWith(".kt")) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/PropertyAccessGenerator.java b/maven/build-engine/src/main/java/com/codename1/maven/PropertyAccessGenerator.java
new file mode 100644
index 00000000000..3a0512a25be
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/PropertyAccessGenerator.java
@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+/// Generates, from the compiled classes of an application, what JavaFX's
+/// `PropertyValueFactory` does by reflection on a desktop: calling the
+/// `xxxProperty()`, `getXxx()` or `isXxx()` method of a row's item by the
+/// name of the property.
+///
+/// #### Which classes
+///
+/// Bytecode does not say what a `TableView<S>` holds, so the bean classes
+/// are found by what they look like. A class gets accessors when it is
+/// public, is not an interface, and either
+///
+/// - has, itself or through a class of the application it extends, at
+///   least one public `xxxProperty()` method that takes no argument and
+///   returns an object; or
+/// - has an accessor for a property name the application hands to a
+///   `PropertyValueFactory` constructor as a string constant -- which is
+///   what reaches a plain bean with getters only.
+///
+/// A class that is not public is left alone, as JavaFX itself refuses it.
+///
+/// #### What is generated
+///
+/// A subclass of the runtime's `PropertyAccess` under the fixed name the
+/// runtime instantiates, in place of the layer's empty placeholder. Its
+/// `call(bean, method)` finds the bean's class with `instanceof` -- the
+/// most derived class first -- and hands over to one small class per bean,
+/// `<registry>$P<n>`, whose method is a chain of string comparisons ending
+/// in a direct call. A primitive result is returned in its wrapper. The
+/// cast in a part follows the registry's `instanceof`: a failed cast does
+/// not throw on every Codename One port, so nothing relies on one.
+///
+/// The names are parameters because the application sees the runtime
+/// relocated and a test may not.
+public final class PropertyAccessGenerator {
+
+    /// The internal name of the runtime's accessor, before relocation.
+    public static final String ACCESS = "com/codename1/fxcompat/runtime/PropertyAccess";
+    /// The internal name of the runtime's placeholder, before relocation.
+    public static final String REGISTRY = "com/codename1/fxcompat/runtime/PropertyRegistry";
+    /// The internal name of the factory whose constructor names the
+    /// properties, before relocation.
+    public static final String FACTORY = "javafx/scene/control/cell/PropertyValueFactory";
+
+    private static final String PART = "$P";
+    private static final String CALL = "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;";
+    private static final String SUFFIX = "Property";
+
+    private static final class Scanned {
+        String name;
+        String superName;
+        int access;
+        /// Public instance methods without arguments that return a value:
+        /// name to descriptor.
+        final Map<String, String> accessors = new TreeMap<String, String>();
+    }
+
+    private static final class Bean {
+        final Scanned type;
+        final int depth;
+        final Map<String, String> accessors;
+
+        Bean(Scanned type, int depth, Map<String, String> accessors) {
+            this.type = type;
+            this.depth = depth;
+            this.accessors = accessors;
+        }
+    }
+
+    /// A subclass is asked before the class it extends, so the first
+    /// `instanceof` that matches is the nearest class.
+    private static final Comparator<Bean> MOST_DERIVED_FIRST = new Comparator<Bean>() {
+        @Override
+        public int compare(Bean a, Bean b) {
+            return a.depth != b.depth ? b.depth - a.depth : a.type.name.compareTo(b.type.name);
+        }
+    };
+
+    private final File classesDir;
+    private final String registry;
+    private final String access;
+    private final String factory;
+    private int beans;
+
+    /// Creates a generator over a directory of compiled classes.
+    ///
+    /// #### Parameters
+    ///
+    /// - `classesDir`: the directory the classes are in and the registry
+    ///   is written to
+    ///
+    /// - `registry`: the internal name of the class to generate
+    ///
+    /// - `access`: the internal name of the runtime's `PropertyAccess`
+    ///
+    /// - `factory`: the internal name of `PropertyValueFactory`, as the
+    ///   classes in the directory name it
+    public PropertyAccessGenerator(File classesDir, String registry, String access, String factory) {
+        this.classesDir = classesDir;
+        this.registry = registry;
+        this.access = access;
+        this.factory = factory;
+    }
+
+    /// How many bean classes the last run generated accessors for.
+    public int beans() {
+        return beans;
+    }
+
+    /// Generates the registry for the given classes of the application --
+    /// internal names, as they are in the directory. A second run over its
+    /// own output changes no file.
+    public void run(Collection<String> appClasses) throws IOException {
+        Map<String, Scanned> all = new TreeMap<String, Scanned>();
+        Set<String> named = new HashSet<String>();
+        for (String name : appClasses) {
+            File f = new File(classesDir, name + ".class");
+            if (f.isFile() && !name.equals(registry) && !name.startsWith(registry + PART)) {
+                Scanned s = scan(Files.readAllBytes(f.toPath()), named);
+                all.put(s.name, s);
+            }
+        }
+        // What a constant name may be asked as: the three accessor names.
+        Set<String> wanted = new HashSet<String>();
+        for (String property : named) {
+            if (property.length() > 0) {
+                String capital = Character.toUpperCase(property.charAt(0)) + property.substring(1);
+                wanted.add(property + SUFFIX);
+                wanted.add("get" + capital);
+                wanted.add("is" + capital);
+            }
+        }
+        List<Bean> found = new ArrayList<Bean>();
+        for (Scanned s : all.values()) {
+            if ((s.access & Opcodes.ACC_PUBLIC) == 0 || (s.access & Opcodes.ACC_INTERFACE) != 0) {
+                continue;
+            }
+            Map<String, String> accessors = new TreeMap<String, String>();
+            int depth = 0;
+            // The nearest declaration wins; a chain that loops ends.
+            for (Scanned at = s; at != null && depth < 1000; at = all.get(at.superName)) {
+                for (Map.Entry<String, String> e : at.accessors.entrySet()) {
+                    if (!accessors.containsKey(e.getKey())) {
+                        accessors.put(e.getKey(), e.getValue());
+                    }
+                }
+                depth++;
+            }
+            boolean bean = false;
+            for (Map.Entry<String, String> e : accessors.entrySet()) {
+                String n = e.getKey();
+                boolean property = n.length() > SUFFIX.length() && n.endsWith(SUFFIX)
+                        && e.getValue().startsWith("()L");
+                if (property || wanted.contains(n)) {
+                    bean = true;
+                    break;
+                }
+            }
+            if (bean) {
+                found.add(new Bean(s, depth, accessors));
+            }
+        }
+        Collections.sort(found, MOST_DERIVED_FIRST);
+        for (int i = 0; i < found.size(); i++) {
+            writeIfDifferent(new File(classesDir, registry + PART + i + ".class"),
+                    part(registry + PART + i, found.get(i)));
+        }
+        deleteStaleParts(found.size());
+        writeIfDifferent(new File(classesDir, registry + ".class"), registry(found));
+        beans = found.size();
+    }
+
+    private static boolean isAccessor(String name) {
+        return (name.length() > SUFFIX.length() && name.endsWith(SUFFIX))
+                || (name.length() > 3 && name.startsWith("get")) || (name.length() > 2 && name.startsWith("is"));
+    }
+
+    /// Reads what the generator needs from one class, and adds to `named`
+    /// every string constant the class hands to the factory's constructor.
+    private Scanned scan(byte[] bytes, final Set<String> named) {
+        final Scanned s = new Scanned();
+        new ClassReader(bytes).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public void visit(int version, int access, String name, String signature, String superName,
+                    String[] interfaces) {
+                s.name = name;
+                s.superName = superName;
+                s.access = access;
+            }
+
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                int skip = Opcodes.ACC_STATIC | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_BRIDGE;
+                if ((access & Opcodes.ACC_PUBLIC) != 0 && (access & skip) == 0 && descriptor.startsWith("()")
+                        && !descriptor.endsWith(")V") && isAccessor(name)) {
+                    s.accessors.put(name, descriptor);
+                }
+                return new MethodVisitor(Opcodes.ASM9) {
+                    private String constant;
+
+                    @Override
+                    public void visitLdcInsn(Object value) {
+                        constant = value instanceof String ? (String) value : null;
+                    }
+
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String method, String desc,
+                            boolean isInterface) {
+                        if (constant != null && opcode == Opcodes.INVOKESPECIAL && "<init>".equals(method)
+                                && owner.equals(factory)) {
+                            named.add(constant);
+                        }
+                        constant = null;
+                    }
+
+                    @Override
+                    public void visitInsn(int opcode) {
+                        constant = null;
+                    }
+
+                    @Override
+                    public void visitVarInsn(int opcode, int var) {
+                        constant = null;
+                    }
+
+                    @Override
+                    public void visitFieldInsn(int opcode, String owner, String field, String desc) {
+                        constant = null;
+                    }
+
+                    @Override
+                    public void visitJumpInsn(int opcode, Label label) {
+                        constant = null;
+                    }
+                };
+            }
+        }, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return s;
+    }
+
+    private void deleteStaleParts(int count) throws IOException {
+        File dir = new File(classesDir, registry + ".class").getParentFile();
+        String prefix = registry.substring(registry.lastIndexOf('/') + 1) + PART;
+        File[] files = dir == null ? null : dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            String n = f.getName();
+            if (!n.startsWith(prefix) || !n.endsWith(".class")) {
+                continue;
+            }
+            boolean stale;
+            try {
+                stale = Integer.parseInt(n.substring(prefix.length(), n.length() - 6)) >= count;
+            } catch (NumberFormatException e) {
+                stale = false;
+            }
+            if (stale && !f.delete()) {
+                throw new IOException("Could not delete the stale " + f);
+            }
+        }
+    }
+
+    private static void writeIfDifferent(File f, byte[] bytes) throws IOException {
+        if (f.isFile() && Arrays.equals(Files.readAllBytes(f.toPath()), bytes)) {
+            return;
+        }
+        File dir = f.getParentFile();
+        if (dir != null && !dir.isDirectory() && !dir.mkdirs() && !dir.isDirectory()) {
+            throw new IOException("Could not create " + dir);
+        }
+        Files.write(f.toPath(), bytes);
+    }
+
+    /// `static Object call(Object bean, String method)` for one bean.
+    private byte[] part(String name, Bean bean) {
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_5, Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, name, null, "java/lang/Object", null);
+        MethodVisitor init = cw.visitMethod(Opcodes.ACC_PRIVATE, "<init>", "()V", null, null);
+        init.visitCode();
+        init.visitVarInsn(Opcodes.ALOAD, 0);
+        init.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        init.visitInsn(Opcodes.RETURN);
+        init.visitMaxs(0, 0);
+        init.visitEnd();
+
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_STATIC, "call", CALL, null, null);
+        mv.visitCode();
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitTypeInsn(Opcodes.CHECKCAST, bean.type.name);
+        mv.visitVarInsn(Opcodes.ASTORE, 2);
+        for (Map.Entry<String, String> e : bean.accessors.entrySet()) {
+            Label next = new Label();
+            mv.visitLdcInsn(e.getKey());
+            mv.visitVarInsn(Opcodes.ALOAD, 1);
+            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z", false);
+            mv.visitJumpInsn(Opcodes.IFEQ, next);
+            mv.visitVarInsn(Opcodes.ALOAD, 2);
+            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, bean.type.name, e.getKey(), e.getValue(), false);
+            box(mv, Type.getReturnType(e.getValue()));
+            mv.visitInsn(Opcodes.ARETURN);
+            mv.visitLabel(next);
+        }
+        mv.visitFieldInsn(Opcodes.GETSTATIC, access, "NONE", "Ljava/lang/Object;");
+        mv.visitInsn(Opcodes.ARETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    private static void box(MethodVisitor mv, Type type) {
+        String wrapper;
+        switch (type.getSort()) {
+            case Type.BOOLEAN:
+                wrapper = "java/lang/Boolean";
+                break;
+            case Type.BYTE:
+                wrapper = "java/lang/Byte";
+                break;
+            case Type.CHAR:
+                wrapper = "java/lang/Character";
+                break;
+            case Type.SHORT:
+                wrapper = "java/lang/Short";
+                break;
+            case Type.INT:
+                wrapper = "java/lang/Integer";
+                break;
+            case Type.LONG:
+                wrapper = "java/lang/Long";
+                break;
+            case Type.FLOAT:
+                wrapper = "java/lang/Float";
+                break;
+            case Type.DOUBLE:
+                wrapper = "java/lang/Double";
+                break;
+            default:
+                return;
+        }
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC, wrapper, "valueOf", "(" + type.getDescriptor() + ")L" + wrapper
+                + ";", false);
+    }
+
+    private byte[] registry(List<Bean> found) {
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, registry, null, access,
+                null);
+        MethodVisitor init = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+        init.visitCode();
+        init.visitVarInsn(Opcodes.ALOAD, 0);
+        init.visitMethodInsn(Opcodes.INVOKESPECIAL, access, "<init>", "()V", false);
+        init.visitInsn(Opcodes.RETURN);
+        init.visitMaxs(0, 0);
+        init.visitEnd();
+
+        MethodVisitor call = cw.visitMethod(Opcodes.ACC_PUBLIC, "call", CALL, null, null);
+        call.visitCode();
+        MethodVisitor knows = cw.visitMethod(Opcodes.ACC_PUBLIC, "knows", "(Ljava/lang/Object;)Z", null, null);
+        knows.visitCode();
+        for (int i = 0; i < found.size(); i++) {
+            String type = found.get(i).type.name;
+            Label next = new Label();
+            call.visitVarInsn(Opcodes.ALOAD, 1);
+            call.visitTypeInsn(Opcodes.INSTANCEOF, type);
+            call.visitJumpInsn(Opcodes.IFEQ, next);
+            call.visitVarInsn(Opcodes.ALOAD, 1);
+            call.visitVarInsn(Opcodes.ALOAD, 2);
+            call.visitMethodInsn(Opcodes.INVOKESTATIC, registry + PART + i, "call", CALL, false);
+            call.visitInsn(Opcodes.ARETURN);
+            call.visitLabel(next);
+
+            Label other = new Label();
+            knows.visitVarInsn(Opcodes.ALOAD, 1);
+            knows.visitTypeInsn(Opcodes.INSTANCEOF, type);
+            knows.visitJumpInsn(Opcodes.IFEQ, other);
+            knows.visitInsn(Opcodes.ICONST_1);
+            knows.visitInsn(Opcodes.IRETURN);
+            knows.visitLabel(other);
+        }
+        call.visitFieldInsn(Opcodes.GETSTATIC, access, "NONE", "Ljava/lang/Object;");
+        call.visitInsn(Opcodes.ARETURN);
+        call.visitMaxs(0, 0);
+        call.visitEnd();
+        knows.visitInsn(Opcodes.ICONST_0);
+        knows.visitInsn(Opcodes.IRETURN);
+        knows.visitMaxs(0, 0);
+        knows.visitEnd();
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/RecordDesugar.java b/maven/build-engine/src/main/java/com/codename1/maven/RecordDesugar.java
new file mode 100644
index 00000000000..d046a43be01
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/RecordDesugar.java
@@ -0,0 +1,579 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.ConstantDynamic;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// Replaces the two `invokedynamic` families javac emits for records and
+/// pattern switches with plain methods of the class itself.
+///
+/// A record's `equals`, `hashCode` and `toString` are one `invokedynamic`
+/// each, bootstrapped by `java.lang.runtime.ObjectMethods`; a `switch` over
+/// types or over an enum with patterns is one bootstrapped by
+/// `java.lang.runtime.SwitchBootstraps`. Neither bootstrap class exists on a
+/// device, and both build their answer from method handles, which do not
+/// exist there either. Everything they need is in the call site's static
+/// arguments, though, so each site becomes a call of a private static
+/// synthetic method generated here with the site's own descriptor.
+///
+/// The results are the JDK's: `equals` compares primitives by value (floats
+/// and doubles by their bits, as `Float.compare` does) and references with
+/// `Objects.equals`; `hashCode` is `31 * h + hash(component)` from zero;
+/// `toString` is `Name[a=1, b=x]`.
+///
+/// A switch label this cannot express -- a primitive type, a constant of a
+/// shape javac does not write today -- leaves its call site as it was, which
+/// the compliance check then reports.
+final class RecordDesugar extends ClassVisitor {
+    private static final String OBJECT_METHODS = "java/lang/runtime/ObjectMethods";
+    private static final String SWITCHES = "java/lang/runtime/SwitchBootstraps";
+    private static final String BUILDER = "java/lang/StringBuilder";
+
+    private final List<Site> sites = new ArrayList<Site>();
+    private String className;
+    private String simpleName;
+    private boolean isInterface;
+
+    RecordDesugar(ClassVisitor next) {
+        super(Opcodes.ASM9, next);
+    }
+
+    /// Rewrites one class file on its own, for a project no layer's remap
+    /// went over: a plain application's record needs the same methods. The
+    /// answer is `in` itself when the class has no such call site, which is
+    /// every class the remap already rewrote, so running both does the work
+    /// once.
+    static byte[] apply(byte[] in) {
+        if (!namesRuntimePackage(in)) {
+            return in;
+        }
+        ClassReader reader = new ClassReader(in);
+        ClassWriter writer = new ClassWriter(0);
+        RecordDesugar desugar = new RecordDesugar(writer);
+        reader.accept(desugar, 0);
+        return desugar.sites.isEmpty() ? in : writer.toByteArray();
+    }
+
+    /// Whether the bytes hold the name of the package both bootstrap
+    /// classes are in; nearly no class does, and those are not parsed.
+    private static boolean namesRuntimePackage(byte[] in) {
+        byte[] name = RUNTIME_PACKAGE;
+        int last = in.length - name.length;
+        for (int i = 0; i <= last; i++) {
+            int j = 0;
+            while (j < name.length && in[i + j] == name[j]) {
+                j++;
+            }
+            if (j == name.length) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static final byte[] RUNTIME_PACKAGE = {'j', 'a', 'v', 'a', '/', 'l', 'a', 'n', 'g', '/', 'r', 'u', 'n',
+        't', 'i', 'm', 'e', '/'};
+
+    /// One replaced call site and the method that stands in for it.
+    private static final class Site {
+        final String method;
+        final String kind;
+        final String descriptor;
+        final Object[] arguments;
+
+        Site(String method, String kind, String descriptor, Object[] arguments) {
+            this.method = method;
+            this.kind = kind;
+            this.descriptor = descriptor;
+            this.arguments = arguments;
+        }
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName,
+            String[] interfaces) {
+        className = name;
+        simpleName = name.substring(name.lastIndexOf('/') + 1);
+        isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public void visitInnerClass(String name, String outerName, String innerName, int access) {
+        if (name.equals(className) && innerName != null) {
+            // What Class.getSimpleName answers for a nested or local record.
+            simpleName = innerName;
+        }
+        super.visitInnerClass(name, outerName, innerName, access);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+            String[] exceptions) {
+        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
+        if (mv == null) {
+            return null;
+        }
+        return new MethodVisitor(Opcodes.ASM9, mv) {
+            @Override
+            public void visitInvokeDynamicInsn(String name, String descriptor, Handle bootstrap,
+                    Object... arguments) {
+                String kind = kind(name, descriptor, bootstrap, arguments);
+                if (kind == null) {
+                    super.visitInvokeDynamicInsn(name, descriptor, bootstrap, arguments);
+                    return;
+                }
+                String method = "cn1$" + kind + "$" + sites.size();
+                sites.add(new Site(method, kind, descriptor, arguments));
+                super.visitMethodInsn(Opcodes.INVOKESTATIC, className, method, descriptor, isInterface);
+            }
+        };
+    }
+
+    @Override
+    public void visitEnd() {
+        for (Site site : sites) {
+            MethodVisitor mv = super.visitMethod(
+                    Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_SYNTHETIC,
+                    site.method, site.descriptor, null, null);
+            if (mv == null) {
+                continue;
+            }
+            mv.visitCode();
+            if ("equals".equals(site.kind)) {
+                recordEquals(mv, site);
+            } else if ("hashCode".equals(site.kind)) {
+                recordHashCode(mv, site);
+            } else if ("toString".equals(site.kind)) {
+                recordToString(mv, site);
+            } else if ("typeSwitch".equals(site.kind)) {
+                typeSwitch(mv, site);
+            } else {
+                enumSwitch(mv, site);
+            }
+            mv.visitEnd();
+        }
+        super.visitEnd();
+    }
+
+    /// Which of the five this call site is, or null for one that is left
+    /// alone.
+    private String kind(String name, String descriptor, Handle bootstrap, Object[] arguments) {
+        if (isInterface) {
+            // A private static method of an interface is legal, but no
+            // record is an interface and javac puts no switch in one's
+            // abstract methods; a default method's switch is reported.
+            return null;
+        }
+        String owner = bootstrap.getOwner();
+        Type[] parameters = Type.getArgumentTypes(descriptor);
+        Type result = Type.getReturnType(descriptor);
+        if (OBJECT_METHODS.equals(owner) && "bootstrap".equals(bootstrap.getName())) {
+            if (arguments.length < 2 || !(arguments[0] instanceof Type) || !(arguments[1] instanceof String)) {
+                return null;
+            }
+            for (int i = 2; i < arguments.length; i++) {
+                if (!(arguments[i] instanceof Handle) || ((Handle) arguments[i]).getTag() != Opcodes.H_GETFIELD) {
+                    return null;
+                }
+            }
+            if ("equals".equals(name) && parameters.length == 2 && result.getSort() == Type.BOOLEAN) {
+                return "equals";
+            }
+            if ("hashCode".equals(name) && parameters.length == 1 && result.getSort() == Type.INT) {
+                return "hashCode";
+            }
+            if ("toString".equals(name) && parameters.length == 1 && result.getSort() == Type.OBJECT) {
+                return "toString";
+            }
+            return null;
+        }
+        if (!SWITCHES.equals(owner) || parameters.length != 2 || parameters[1].getSort() != Type.INT
+                || result.getSort() != Type.INT || !reference(parameters[0])) {
+            return null;
+        }
+        if ("typeSwitch".equals(bootstrap.getName())) {
+            for (Object label : arguments) {
+                boolean type = label instanceof Type && reference((Type) label);
+                if (!type && !(label instanceof String) && !(label instanceof Integer)
+                        && enumConstant(label) == null) {
+                    return null;
+                }
+            }
+            return "typeSwitch";
+        }
+        if ("enumSwitch".equals(bootstrap.getName())) {
+            for (Object label : arguments) {
+                boolean type = label instanceof Type && reference((Type) label);
+                if (!type && !(label instanceof String)) {
+                    return null;
+                }
+            }
+            return "enumSwitch";
+        }
+        return null;
+    }
+
+    /// The enum's internal name and the constant's name when `label` is a
+    /// constant of a sealed hierarchy's enum, which javac writes as a
+    /// dynamic constant: `EnumDesc.of(ClassDesc.of("p.E"), "NAME")`, each
+    /// call made through `ConstantBootstraps.invoke`. Null for anything
+    /// else, including the same idea spelled another way.
+    private static String[] enumConstant(Object label) {
+        Object[] outer = invoked(label, "java/lang/Enum$EnumDesc", "of", 2);
+        if (outer == null || !(outer[1] instanceof String)) {
+            return null;
+        }
+        Object[] inner = invoked(outer[0], "java/lang/constant/ClassDesc", "of", 1);
+        if (inner == null || !(inner[0] instanceof String)) {
+            return null;
+        }
+        return new String[] {((String) inner[0]).replace('.', '/'), (String) outer[1]};
+    }
+
+    /// The arguments of `owner.name(...)` when `constant` is that call made
+    /// by `ConstantBootstraps.invoke` with `count` arguments, else null.
+    private static Object[] invoked(Object constant, String owner, String name, int count) {
+        if (!(constant instanceof ConstantDynamic)) {
+            return null;
+        }
+        ConstantDynamic dynamic = (ConstantDynamic) constant;
+        Handle bootstrap = dynamic.getBootstrapMethod();
+        if (!"java/lang/invoke/ConstantBootstraps".equals(bootstrap.getOwner())
+                || !"invoke".equals(bootstrap.getName())
+                || dynamic.getBootstrapMethodArgumentCount() != count + 1) {
+            return null;
+        }
+        Object called = dynamic.getBootstrapMethodArgument(0);
+        if (!(called instanceof Handle)) {
+            return null;
+        }
+        Handle handle = (Handle) called;
+        if (handle.getTag() != Opcodes.H_INVOKESTATIC || !owner.equals(handle.getOwner())
+                || !name.equals(handle.getName())) {
+            return null;
+        }
+        Object[] arguments = new Object[count];
+        for (int i = 0; i < count; i++) {
+            arguments[i] = dynamic.getBootstrapMethodArgument(i + 1);
+        }
+        return arguments;
+    }
+
+    private static boolean reference(Type type) {
+        return type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY;
+    }
+
+    private static Handle component(Site site, int index) {
+        Object handle = site.arguments[index + 2];
+        // Checked by kind() before the site was recorded.
+        return handle instanceof Handle ? (Handle) handle : null;
+    }
+
+    private static int components(Site site) {
+        return site.arguments.length - 2;
+    }
+
+    private static void field(MethodVisitor mv, Handle handle) {
+        mv.visitFieldInsn(Opcodes.GETFIELD, handle.getOwner(), handle.getName(), handle.getDesc());
+    }
+
+    /// `(LR;Ljava/lang/Object;)Z`. The other record is cast again for every
+    /// component rather than kept in a local, so that every jump to the
+    /// "different" exit arrives with the same two locals and an empty stack.
+    private void recordEquals(MethodVisitor mv, Site site) {
+        Type record = Type.getArgumentTypes(site.descriptor)[0];
+        String name = record.getInternalName();
+        Label different = new Label();
+        mv.visitVarInsn(Opcodes.ALOAD, 1);
+        mv.visitTypeInsn(Opcodes.INSTANCEOF, name);
+        mv.visitJumpInsn(Opcodes.IFEQ, different);
+        for (int i = 0; i < components(site); i++) {
+            Handle handle = component(site, i);
+            if (handle == null) {
+                continue;
+            }
+            int sort = Type.getType(handle.getDesc()).getSort();
+            mv.visitVarInsn(Opcodes.ALOAD, 0);
+            field(mv, handle);
+            bits(mv, sort);
+            mv.visitVarInsn(Opcodes.ALOAD, 1);
+            mv.visitTypeInsn(Opcodes.CHECKCAST, name);
+            field(mv, handle);
+            bits(mv, sort);
+            if (sort == Type.LONG || sort == Type.DOUBLE) {
+                mv.visitInsn(Opcodes.LCMP);
+                mv.visitJumpInsn(Opcodes.IFNE, different);
+            } else if (sort == Type.OBJECT || sort == Type.ARRAY) {
+                mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/util/Objects", "equals",
+                        "(Ljava/lang/Object;Ljava/lang/Object;)Z", false);
+                mv.visitJumpInsn(Opcodes.IFEQ, different);
+            } else {
+                mv.visitJumpInsn(Opcodes.IF_ICMPNE, different);
+            }
+        }
+        mv.visitInsn(Opcodes.ICONST_1);
+        mv.visitInsn(Opcodes.IRETURN);
+        mv.visitLabel(different);
+        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+        mv.visitInsn(Opcodes.ICONST_0);
+        mv.visitInsn(Opcodes.IRETURN);
+        mv.visitMaxs(4, 2);
+    }
+
+    /// A float or a double on the stack becomes the bits two equal values
+    /// share, which is how the JDK compares a record's: a NaN equals a NaN
+    /// and the two zeros differ.
+    private static void bits(MethodVisitor mv, int sort) {
+        if (sort == Type.FLOAT) {
+            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Float", "floatToIntBits", "(F)I", false);
+        } else if (sort == Type.DOUBLE) {
+            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Double", "doubleToLongBits", "(D)J", false);
+        }
+    }
+
+    /// `(LR;)I`, with no branch in it.
+    private void recordHashCode(MethodVisitor mv, Site site) {
+        mv.visitInsn(Opcodes.ICONST_0);
+        for (int i = 0; i < components(site); i++) {
+            Handle handle = component(site, i);
+            if (handle == null) {
+                continue;
+            }
+            int sort = Type.getType(handle.getDesc()).getSort();
+            mv.visitIntInsn(Opcodes.BIPUSH, 31);
+            mv.visitInsn(Opcodes.IMUL);
+            if (sort == Type.BOOLEAN) {
+                // Boolean.hashCode: 1231 for true and 1237 for false.
+                mv.visitIntInsn(Opcodes.SIPUSH, 1237);
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                field(mv, handle);
+                mv.visitIntInsn(Opcodes.BIPUSH, 6);
+                mv.visitInsn(Opcodes.IMUL);
+                mv.visitInsn(Opcodes.ISUB);
+            } else {
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                field(mv, handle);
+                bits(mv, sort);
+                if (sort == Type.LONG || sort == Type.DOUBLE) {
+                    mv.visitInsn(Opcodes.DUP2);
+                    mv.visitIntInsn(Opcodes.BIPUSH, 32);
+                    mv.visitInsn(Opcodes.LUSHR);
+                    mv.visitInsn(Opcodes.LXOR);
+                    mv.visitInsn(Opcodes.L2I);
+                } else if (sort == Type.OBJECT || sort == Type.ARRAY) {
+                    mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/util/Objects", "hashCode",
+                            "(Ljava/lang/Object;)I", false);
+                }
+            }
+            mv.visitInsn(Opcodes.IADD);
+        }
+        mv.visitInsn(Opcodes.IRETURN);
+        mv.visitMaxs(6, 1);
+    }
+
+    /// `(LR;)Ljava/lang/String;`
+    private void recordToString(MethodVisitor mv, Site site) {
+        Object joined = site.arguments[1];
+        String text = joined instanceof String ? (String) joined : "";
+        String[] names = text.length() == 0 ? new String[0] : text.split(";");
+        mv.visitTypeInsn(Opcodes.NEW, BUILDER);
+        mv.visitInsn(Opcodes.DUP);
+        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, BUILDER, "<init>", "()V", false);
+        append(mv, simpleName + "[");
+        for (int i = 0; i < components(site); i++) {
+            Handle handle = component(site, i);
+            if (handle == null) {
+                continue;
+            }
+            String label = i < names.length ? names[i] : handle.getName();
+            append(mv, (i == 0 ? "" : ", ") + label + "=");
+            mv.visitVarInsn(Opcodes.ALOAD, 0);
+            field(mv, handle);
+            int sort = Type.getType(handle.getDesc()).getSort();
+            String type;
+            if (sort == Type.BOOLEAN) {
+                type = "Z";
+            } else if (sort == Type.CHAR) {
+                type = "C";
+            } else if (sort == Type.LONG) {
+                type = "J";
+            } else if (sort == Type.FLOAT) {
+                type = "F";
+            } else if (sort == Type.DOUBLE) {
+                type = "D";
+            } else if (sort == Type.OBJECT || sort == Type.ARRAY) {
+                type = "Ljava/lang/Object;";
+            } else {
+                type = "I";
+            }
+            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BUILDER, "append", "(" + type + ")L" + BUILDER + ";", false);
+        }
+        append(mv, "]");
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BUILDER, "toString", "()Ljava/lang/String;", false);
+        mv.visitInsn(Opcodes.ARETURN);
+        mv.visitMaxs(3, 1);
+    }
+
+    private static void append(MethodVisitor mv, String text) {
+        mv.visitLdcInsn(text);
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BUILDER, "append",
+                "(Ljava/lang/String;)L" + BUILDER + ";", false);
+    }
+
+    /// `(LT;I)I`: the index of the first label at or after the second
+    /// argument that the first one matches, the number of labels when none
+    /// does, and -1 for null. Every jump lands with the same two locals and
+    /// an empty stack.
+    private void typeSwitch(MethodVisitor mv, Site site) {
+        Label start = nullCheck(mv);
+        Label next = start;
+        for (int i = 0; i < site.arguments.length; i++) {
+            Object label = site.arguments[i];
+            if (label instanceof Integer) {
+                // A constant matches the Integer and the Character of that
+                // value, as the JDK's does.
+                next = constant(mv, next, i, ((Integer) label).intValue(), "java/lang/Integer", "intValue", "()I");
+                next = constant(mv, next, i, ((Integer) label).intValue(), "java/lang/Character", "charValue",
+                        "()C");
+                continue;
+            }
+            Label after = begin(mv, next, i);
+            String[] constant = enumConstant(label);
+            if (constant != null) {
+                // An enum has one instance of each constant, so being of the
+                // enum's type and having the name is being that constant.
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitTypeInsn(Opcodes.INSTANCEOF, constant[0]);
+                mv.visitJumpInsn(Opcodes.IFEQ, after);
+                mv.visitLdcInsn(constant[1]);
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Enum");
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Enum", "name", "()Ljava/lang/String;", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z",
+                        false);
+            } else if (label instanceof Type) {
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitTypeInsn(Opcodes.INSTANCEOF, ((Type) label).getInternalName());
+            } else {
+                mv.visitLdcInsn(label);
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z",
+                        false);
+            }
+            mv.visitJumpInsn(Opcodes.IFEQ, after);
+            mv.visitLdcInsn(Integer.valueOf(i));
+            mv.visitInsn(Opcodes.IRETURN);
+            next = after;
+        }
+        end(mv, next, site.arguments.length);
+    }
+
+    /// `(LE;I)I`, where a label is the name of a constant or a type.
+    private void enumSwitch(MethodVisitor mv, Site site) {
+        Label start = nullCheck(mv);
+        Label next = start;
+        for (int i = 0; i < site.arguments.length; i++) {
+            Object label = site.arguments[i];
+            Label after = begin(mv, next, i);
+            if (label instanceof Type) {
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitTypeInsn(Opcodes.INSTANCEOF, ((Type) label).getInternalName());
+                mv.visitJumpInsn(Opcodes.IFEQ, after);
+            } else {
+                // The selector's static type may be an interface the enum
+                // implements, so it is asked whether it is an enum first.
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitTypeInsn(Opcodes.INSTANCEOF, "java/lang/Enum");
+                mv.visitJumpInsn(Opcodes.IFEQ, after);
+                mv.visitLdcInsn(label);
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+                mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Enum");
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Enum", "name", "()Ljava/lang/String;", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z",
+                        false);
+                mv.visitJumpInsn(Opcodes.IFEQ, after);
+            }
+            mv.visitLdcInsn(Integer.valueOf(i));
+            mv.visitInsn(Opcodes.IRETURN);
+            next = after;
+        }
+        end(mv, next, site.arguments.length);
+    }
+
+    private static Label nullCheck(MethodVisitor mv) {
+        Label start = new Label();
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitJumpInsn(Opcodes.IFNONNULL, start);
+        mv.visitInsn(Opcodes.ICONST_M1);
+        mv.visitInsn(Opcodes.IRETURN);
+        return start;
+    }
+
+    /// Opens the test of label `index` at `here`, skipping it when the
+    /// switch restarts after it; answers where a failed test continues.
+    private static Label begin(MethodVisitor mv, Label here, int index) {
+        Label after = new Label();
+        mv.visitLabel(here);
+        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+        mv.visitVarInsn(Opcodes.ILOAD, 1);
+        mv.visitLdcInsn(Integer.valueOf(index));
+        mv.visitJumpInsn(Opcodes.IF_ICMPGT, after);
+        return after;
+    }
+
+    private static Label constant(MethodVisitor mv, Label here, int index, int value, String box, String unbox,
+            String descriptor) {
+        Label after = begin(mv, here, index);
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitTypeInsn(Opcodes.INSTANCEOF, box);
+        mv.visitJumpInsn(Opcodes.IFEQ, after);
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitTypeInsn(Opcodes.CHECKCAST, box);
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, box, unbox, descriptor, false);
+        mv.visitLdcInsn(Integer.valueOf(value));
+        mv.visitJumpInsn(Opcodes.IF_ICMPNE, after);
+        mv.visitLdcInsn(Integer.valueOf(index));
+        mv.visitInsn(Opcodes.IRETURN);
+        return after;
+    }
+
+    private static void end(MethodVisitor mv, Label here, int count) {
+        mv.visitLabel(here);
+        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
+        mv.visitLdcInsn(Integer.valueOf(count));
+        mv.visitInsn(Opcodes.IRETURN);
+        mv.visitMaxs(2, 2);
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/Relocation.java b/maven/build-engine/src/main/java/com/codename1/maven/Relocation.java
new file mode 100644
index 00000000000..20f2465bf24
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/Relocation.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+/// One compatibility layer's naming rules: which packages an application
+/// compiles against, and where they live once the application ships.
+///
+/// A layer exists because its API names cannot ship as they are -- `android.*`
+/// would collide with the real framework on an Android build, and `java.awt`
+/// belongs to the JDK and can be defined by nobody else. The application keeps
+/// its sources and compiles against the original names; [ClassRelocator]
+/// rewrites the compiled classes by these rules.
+public final class Relocation {
+
+    /// Where `org.osgi.framework`'s "not in a framework" answer lives: core,
+    /// because every layer shares [#JDK_SHIMS] and the core jar ships with
+    /// every application.
+    static final String OSGI_PACKAGE = "com/codename1/impl/compat/osgi/";
+
+    /// The few JDK classes that ship under another name, shared by every
+    /// layer.
+    ///
+    /// Everything else of `java.*` keeps its name: the device's class library
+    /// (`vm/JavaAPI`) carries the JDK API an application is compiled against,
+    /// and on JavaSE and Android the JDK itself answers. What is here is what
+    /// a device cannot have under the JDK's name, or what the framework
+    /// already implements under its own.
+    static final String[][] JDK_SHIMS = {
+        // java.util.regex: the framework's matcher, with the JDK's syntax.
+        // What it lacks it refuses by name when a pattern is compiled.
+        {"java/util/regex/Pattern", "com/codename1/util/regex/Pattern"},
+        {"java/util/regex/Matcher", "com/codename1/util/regex/Matcher"},
+        {"java/util/regex/MatchResult", "com/codename1/util/regex/MatchResult"},
+        {"java/util/regex/PatternSyntaxException", "com/codename1/util/regex/PatternSyntaxException"},
+        // Processes, over the framework's own classes of the same shape;
+        // Runtime.exec is a CompatRewrites rule onto them.
+        {"java/lang/ProcessBuilder", "com/codename1/io/ProcessBuilder"},
+        {"java/lang/Process", "com/codename1/io/Process"},
+        // "Not running in OSGi", for a library that asks before it takes its
+        // class path route. These four types and no more: nothing here is an
+        // OSGi framework.
+        {"org/osgi/framework/FrameworkUtil", OSGI_PACKAGE + "FrameworkUtil"},
+        {"org/osgi/framework/Bundle", OSGI_PACKAGE + "Bundle"},
+        {"org/osgi/framework/BundleContext", OSGI_PACKAGE + "BundleContext"},
+        {"org/osgi/framework/ServiceReference", OSGI_PACKAGE + "ServiceReference"},
+    };
+
+    private final String name;
+    private final String artifactId;
+    private final String target;
+    private final String[] prefixes;
+    private final String[][] shims;
+    private final String runtimePackage;
+    private final String runtimeTarget;
+
+    /// `prefixes` are prepended with `target`, not replaced by it, so
+    /// `android/view/View` becomes `<target>android/view/View`. `shims` are
+    /// exact names, tried before any prefix. `runtimePackage`, when the layer
+    /// has one, is its bridge package inside a jar that is authored under the
+    /// original names: it moves to `runtimeTarget` so the copy that ships
+    /// never shares a name with the jar's unrelocated original.
+    public Relocation(String name, String artifactId, String target, String[] prefixes, String[][] shims,
+                      String runtimePackage, String runtimeTarget) {
+        this.name = name;
+        this.artifactId = artifactId;
+        this.target = target;
+        this.prefixes = prefixes.clone();
+        this.shims = new String[shims.length][];
+        for (int i = 0; i < shims.length; i++) {
+            this.shims[i] = shims[i].clone();
+        }
+        this.runtimePackage = runtimePackage;
+        this.runtimeTarget = runtimeTarget;
+    }
+
+    /// What a build message calls the layer ("Android", "Swing").
+    public String name() {
+        return name;
+    }
+
+    /// The artifact whose jar holds the layer's runtime.
+    public String artifactId() {
+        return artifactId;
+    }
+
+    /// The package everything relocated by this layer ends up under.
+    public String target() {
+        return target;
+    }
+
+    /// Whether `jarName` is a build of this layer's runtime artifact.
+    public boolean isRuntimeJar(String jarName) {
+        return jarName.startsWith(artifactId + "-") && jarName.endsWith(".jar");
+    }
+
+    /// Whether this is a desktop layer: one whose applications are compiled
+    /// against a full JDK, and so name members of JDK classes that the device
+    /// has under the same name with fewer members ([CompatRewrites]).
+    boolean isDesktop() {
+        return !AndroidResourceRunner.COMPAT_ARTIFACT.equals(artifactId);
+    }
+
+    /// The name `internalName` ships under when it is one of this layer's
+    /// exact shims, else null.
+    String shim(String internalName) {
+        for (String[] shim : shims) {
+            if (shim[0].equals(internalName)) {
+                return shim[1];
+            }
+        }
+        return null;
+    }
+
+    /// The relocated name when `internalName` falls under this layer's bridge
+    /// package or one of its prefixes, else null.
+    String relocate(String internalName) {
+        if (runtimePackage != null && internalName.startsWith(runtimePackage)) {
+            return runtimeTarget + internalName.substring(runtimePackage.length());
+        }
+        for (String p : prefixes) {
+            if (internalName.startsWith(p)) {
+                return target + internalName;
+            }
+        }
+        return null;
+    }
+
+    /// Whether `internalName`, as an application is compiled against it, is
+    /// part of the API this layer provides. Unlike [#relocate] this leaves the
+    /// bridge package out: that one is the layer's own, never an API name.
+    boolean owns(String internalName) {
+        for (String p : prefixes) {
+            if (internalName.startsWith(p)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Whether `source`, the text of a Java or Kotlin file, spells one of
+    /// this layer's packages (`javax.swing.`), in an import or anywhere else.
+    boolean namedInSource(String source) {
+        for (String p : prefixes) {
+            if (source.indexOf(p.replace('/', '.')) >= 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The name the application was compiled against, when `relocated` is one
+    /// this layer produced from a prefix, else null. Build messages use it:
+    /// a developer knows `javax.swing.JTable`, not where it ships.
+    String original(String relocated) {
+        if (relocated.startsWith(target)) {
+            String rest = relocated.substring(target.length());
+            for (String p : prefixes) {
+                if (rest.startsWith(p)) {
+                    return rest;
+                }
+            }
+        }
+        return null;
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/ServiceProviderNames.java b/maven/build-engine/src/main/java/com/codename1/maven/ServiceProviderNames.java
new file mode 100644
index 00000000000..386551f9c71
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/ServiceProviderNames.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// How the build reads a `META-INF/services` file: the rule the class
+/// library's `java.util.ServiceLoader` applies to one it reads at run time
+/// where no registry was generated, so that the two agree on what a line
+/// means.
+final class ServiceProviderNames {
+
+    private ServiceProviderNames() {
+    }
+
+    /// The provider class names a services file lists, in order: each line
+    /// up to its first `#`, trimmed, when anything is left, and a name that
+    /// appears twice once.
+    ///
+    /// A line that is not a class name -- it has a space or a tab inside, or
+    /// a character no Java identifier has -- is left out, and added to
+    /// `illegal` when that is not null. The JDK refuses the whole file for
+    /// one.
+    static List<String> of(String text, List<String> illegal) {
+        List<String> out = new ArrayList<String>();
+        int n = text.length();
+        int start = 0;
+        while (start <= n) {
+            int end = start;
+            while (end < n && text.charAt(end) != '\n' && text.charAt(end) != '\r') {
+                end++;
+            }
+            String line = text.substring(start, end);
+            int hash = line.indexOf('#');
+            if (hash >= 0) {
+                line = line.substring(0, hash);
+            }
+            line = line.trim();
+            if (line.length() > 0) {
+                if (!isClassName(line)) {
+                    if (illegal != null) {
+                        illegal.add(line);
+                    }
+                } else if (!out.contains(line)) {
+                    out.add(line);
+                }
+            }
+            start = end + 1;
+        }
+        return out;
+    }
+
+    private static boolean isClassName(String name) {
+        int n = name.length();
+        for (int i = 0; i < n; i++) {
+            char c = name.charAt(i);
+            boolean letter = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c >= 0x80;
+            boolean digit = c >= '0' && c <= '9';
+            if (i == 0 ? !letter : !(letter || digit || c == '.')) {
+                return false;
+            }
+        }
+        return n > 0;
+    }
+}
diff --git a/maven/build-engine/src/main/java/com/codename1/maven/UnrelocatedTypes.java b/maven/build-engine/src/main/java/com/codename1/maven/UnrelocatedTypes.java
new file mode 100644
index 00000000000..c7903b2cced
--- /dev/null
+++ b/maven/build-engine/src/main/java/com/codename1/maven/UnrelocatedTypes.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/// Lists the classes that still refer to a TYPE under one of a set of
+/// packages: what the compatibility layers' integration tests ask of a
+/// classes directory once the remap step has run over it.
+///
+/// A search of the class file's bytes cannot answer that. A relocated class
+/// keeps every string the application wrote, and an application is entitled
+/// to the text `"javax/swing/JTable"` -- in a message, a resource path, a
+/// key. What must not survive is a reference the device would have to
+/// resolve, so this reads each class the way the relocation does and looks
+/// only at type names: supertypes, the descriptors and generic signatures
+/// of fields and methods, the operands of instructions, the types of
+/// annotations, method handles and constant class literals. String
+/// constants and annotation values are never looked at.
+///
+/// #### As a program
+///
+/// ```
+/// java -cp <build-engine and ASM> com.codename1.maven.UnrelocatedTypes \
+///      <classes directory or jar> <package> [<package> ...]
+/// ```
+///
+/// A package is slash-separated, without a trailing slash (`javax/swing`).
+/// Each class that names a type under one prints as a line -- its path, a
+/// tab, and the first few such types -- and the exit status is 1; it is 0
+/// when there is none and 2 when the arguments make no sense.
+public final class UnrelocatedTypes {
+
+    /// How many type names a line gives before it stops.
+    private static final int SHOWN = 3;
+
+    private UnrelocatedTypes() {
+    }
+
+    public static void main(String[] args) {
+        System.exit(run(args, System.out, System.err));
+    }
+
+    /// What [#main] does, answering the exit status instead of exiting.
+    static int run(String[] args, PrintStream out, PrintStream err) {
+        if (args.length < 2) {
+            err.println("usage: UnrelocatedTypes <classes directory or jar> <package> [<package> ...]");
+            return 2;
+        }
+        File root = new File(args[0]);
+        if (!root.exists()) {
+            err.println(root + " does not exist");
+            return 2;
+        }
+        List<String> packages = new ArrayList<String>();
+        for (String p : Arrays.asList(args).subList(1, args.length)) {
+            String trimmed = p.endsWith("/") ? p.substring(0, p.length() - 1) : p;
+            if (trimmed.length() > 0) {
+                packages.add(trimmed + "/");
+            }
+        }
+        try {
+            Map<String, Set<String>> found = scan(root, packages);
+            for (Map.Entry<String, Set<String>> e : found.entrySet()) {
+                StringBuilder line = new StringBuilder(e.getKey()).append('\t');
+                int n = 0;
+                for (String type : e.getValue()) {
+                    if (n == SHOWN) {
+                        line.append(", ...");
+                        break;
+                    }
+                    line.append(n == 0 ? "" : ", ").append(type);
+                    n++;
+                }
+                out.println(line);
+            }
+            return found.isEmpty() ? 0 : 1;
+        } catch (IOException e) {
+            err.println("Could not read " + root + ": " + e.getMessage());
+            return 2;
+        }
+    }
+
+    /// The classes under `root` -- a directory, or a jar -- that name a type
+    /// whose internal name starts with one of `prefixes` (each ending in a
+    /// slash), by their path, with the types each one names.
+    public static Map<String, Set<String>> scan(File root, List<String> prefixes) throws IOException {
+        Map<String, Set<String>> out = new TreeMap<String, Set<String>>();
+        if (root.isDirectory()) {
+            directory(root, "", prefixes, out);
+        } else {
+            ZipFile zip = new ZipFile(root);
+            try {
+                Enumeration<? extends ZipEntry> entries = zip.entries();
+                while (entries.hasMoreElements()) {
+                    ZipEntry e = entries.nextElement();
+                    if (!e.isDirectory() && e.getName().endsWith(".class")) {
+                        InputStream in = zip.getInputStream(e);
+                        try {
+                            record(e.getName(), types(readAll(in), prefixes), out);
+                        } finally {
+                            in.close();
+                        }
+                    }
+                }
+            } finally {
+                zip.close();
+            }
+        }
+        return out;
+    }
+
+    private static void directory(File dir, String rel, List<String> prefixes, Map<String, Set<String>> out)
+            throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                directory(f, rel + f.getName() + "/", prefixes, out);
+            } else if (f.getName().endsWith(".class")) {
+                record(rel + f.getName(), types(Files.readAllBytes(f.toPath()), prefixes), out);
+            }
+        }
+    }
+
+    private static void record(String path, Set<String> types, Map<String, Set<String>> out) {
+        if (!types.isEmpty()) {
+            out.put(path, types);
+        }
+    }
+
+    /// The types under `prefixes` the class `bytes` refers to.
+    static Set<String> types(byte[] bytes, final List<String> prefixes) {
+        final Set<String> found = new TreeSet<String>();
+        Remapper collector = new Remapper() {
+            @Override
+            public String map(String internalName) {
+                if (internalName != null) {
+                    for (String p : prefixes) {
+                        if (internalName.startsWith(p)) {
+                            found.add(internalName);
+                            break;
+                        }
+                    }
+                }
+                return internalName;
+            }
+        };
+        // Debug information is read too: a local variable's type is a name
+        // the relocation is expected to have moved with the rest.
+        new ClassReader(bytes).accept(new ClassRemapper(new ClassWriter(0), collector), ClassReader.SKIP_FRAMES);
+        return found.isEmpty() ? Collections.<String>emptySet() : found;
+    }
+
+    private static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] buf = new byte[8192];
+        int n = in.read(buf);
+        while (n >= 0) {
+            out.write(buf, 0, n);
+            n = in.read(buf);
+        }
+        return out.toByteArray();
+    }
+}
diff --git a/maven/build-engine/src/main/resources/com/codename1/maven/compliance-alternatives.txt b/maven/build-engine/src/main/resources/com/codename1/maven/compliance-alternatives.txt
new file mode 100644
index 00000000000..89d8c2f357d
--- /dev/null
+++ b/maven/build-engine/src/main/resources/com/codename1/maven/compliance-alternatives.txt
@@ -0,0 +1,152 @@
+# The nearest supported alternative to an API a device does not have.
+#
+# One row per line:   API prefix | what to use, by name | what to say
+#
+# - The prefix is the API as Java spells it: a package ending in a dot
+#   (java.sql.), a class (java.lang.ProcessBuilder) or a member
+#   (java.lang.Runtime.exec). The longest prefix that matches wins.
+# - The second column lists the classes and members the advice names, comma
+#   separated, a member as Class#member. ComplianceAlternativesTest fails
+#   when one of them is not in codenameone-core, java-runtime or a
+#   compatibility layer, so a row cannot point at something that is gone.
+#   It is empty for a row that says there is no equivalent.
+# - Adding a row is adding a line.
+
+# Processes
+java.lang.ProcessBuilder | com.codename1.ui.CN#execute, com.codename1.ui.CN#canExecute | A device cannot start a process. To open a URL, a file or another application use CN.execute(url), after CN.canExecute(url); anything else belongs behind an interface with a desktop-only implementation.
+java.lang.Process | com.codename1.ui.CN#execute | A device cannot start a process. Use CN.execute(url) to hand a URL or a file to the system, or put the feature behind an interface with a desktop-only implementation.
+java.lang.Runtime.exec | com.codename1.ui.CN#execute, com.codename1.ui.CN#canExecute | A device cannot start a process. To open a URL, a file or another application use CN.execute(url), after CN.canExecute(url).
+java.lang.Runtime.addShutdownHook | com.codename1.system.Lifecycle#stop, com.codename1.system.Lifecycle#destroy | An application is stopped by the system, not by a JVM exit. Save state in the Lifecycle's stop() and destroy().
+java.lang.ProcessHandle | | No equivalent: a device application sees no other process.
+
+# Networking
+java.net.http. | com.codename1.io.rest.Rest, com.codename1.io.ConnectionRequest | Use Rest (Rest.get(url).getAsJsonMap()) for a request and its response, or ConnectionRequest for full control; both run on the network thread and call back on the EDT.
+java.net.HttpURLConnection | com.codename1.io.rest.Rest, com.codename1.io.ConnectionRequest | Use Rest for a request and its response, or ConnectionRequest for full control.
+java.net.URLConnection | com.codename1.io.ConnectionRequest | Use ConnectionRequest, which reads the response in readResponse(InputStream).
+javax.net.ssl. | com.codename1.io.ConnectionRequest | HTTPS is handled by the platform: use ConnectionRequest or Rest with an https URL. To pin a certificate override ConnectionRequest.checkSSLCertificates.
+java.net.Socket | com.codename1.io.Socket#connect, com.codename1.io.WebSocket | Use com.codename1.io.Socket.connect(host, port, SocketConnection), or WebSocket for a message stream to a server.
+java.net.ServerSocket | com.codename1.io.Socket#listen | Use com.codename1.io.Socket.listen(port, SocketConnection class) where Socket.isServerSocketSupported(); a phone is rarely reachable from outside.
+java.net.DatagramSocket | | No equivalent: there are no datagram sockets on a device. Use a WebSocket or an HTTP request.
+java.net.InetAddress | com.codename1.io.Socket#getHostOrIP | Host names are resolved by the connection that uses them. Socket.getHostOrIP() answers the device's own.
+java.net.URLEncoder | com.codename1.io.Util#encodeUrl | Use Util.encodeUrl(String).
+java.net.URLDecoder | com.codename1.io.Util#decode | Use Util.decode(String, String, boolean).
+java.net.NetworkInterface | com.codename1.io.NetworkManager#isAPSupported | Use NetworkManager for what the platform tells an application about its connection.
+java.nio.channels. | com.codename1.io.Socket, com.codename1.io.FileSystemStorage | There are no channels on a device. Use streams: FileSystemStorage for files, com.codename1.io.Socket for a connection.
+
+# Files
+java.nio.file.WatchService | com.codename1.ui.util.UITimer | No equivalent: a device does not report file changes. Poll what you need with a UITimer, or refresh when the application resumes.
+java.nio.file.WatchKey | com.codename1.ui.util.UITimer | No equivalent: a device does not report file changes. Poll what you need with a UITimer.
+java.nio.file.WatchEvent | com.codename1.ui.util.UITimer | No equivalent: a device does not report file changes. Poll what you need with a UITimer.
+java.nio.file.FileVisitor | com.codename1.io.FileSystemStorage#listFiles | Walk the tree yourself with FileSystemStorage.listFiles(dir) and isDirectory(path).
+java.nio.file.SimpleFileVisitor | com.codename1.io.FileSystemStorage#listFiles | Walk the tree yourself with FileSystemStorage.listFiles(dir) and isDirectory(path).
+java.nio.file.attribute. | com.codename1.io.FileSystemStorage#getLastModified, com.codename1.io.FileSystemStorage#getLength | A device file has a length and a modification time and no permissions, owners or links: FileSystemStorage.getLength(path), getLastModified(path).
+java.nio.file. | com.codename1.io.FileSystemStorage, com.codename1.io.Storage | Use java.io.File and its streams, which the build maps onto the application's own directory, or FileSystemStorage directly; Storage for small named entries.
+java.io.File.toPath | com.codename1.io.FileSystemStorage | java.nio.file.Path is not on a device. Stay with java.io.File and its streams, which the build maps onto the application's own directory.
+java.math. | com.codename1.util.BigInteger, com.codename1.util.BigDecimal | Use com.codename1.util.BigInteger and com.codename1.util.BigDecimal.
+java.nio.MappedByteBuffer | com.codename1.io.FileSystemStorage#openInputStream | No memory-mapped files on a device. Read through FileSystemStorage.openInputStream(path).
+java.io.RandomAccessFile | com.codename1.io.FileSystemStorage#openInputStream, com.codename1.io.FileSystemStorage#openOutputStream | No random access to a file on a device. Read and write whole streams with FileSystemStorage.
+java.io.Console | | No equivalent: a device application has no console.
+java.awt.Desktop | com.codename1.ui.CN#execute | Use CN.execute(url) to open a URL or a file with whatever the device has for it.
+
+# Reflection, class loading, serialization
+java.lang.reflect.Proxy | | No equivalent: a device cannot create a class at run time. Write the implementing class.
+java.lang.reflect. | com.codename1.properties.PropertyBusinessObject | No reflection on a device: every class is compiled ahead of time and unused members are removed. Call the member directly, or describe the object's fields with PropertyBusinessObject.
+java.lang.invoke.MethodHandle | | No method handles on a device beyond what a lambda compiles to. Call the method directly or pass a lambda.
+java.lang.Class.forName | | A device cannot find a class by a name computed at run time. Name the class in code (a switch over the names you expect, each with its own "new").
+java.lang.Class.getDeclared | com.codename1.properties.PropertyBusinessObject | No reflection on a device. Call the member directly, or describe the object's fields with PropertyBusinessObject.
+java.lang.Class.getMethod | com.codename1.properties.PropertyBusinessObject | No reflection on a device. Call the method directly.
+java.lang.Class.getField | com.codename1.properties.PropertyBusinessObject | No reflection on a device. Read the field directly.
+java.lang.Class.getConstructor | | No reflection on a device. Write "new" for the class you mean.
+java.lang.Class.newInstance | | No reflection on a device. Write "new" for the class you mean.
+java.lang.Class.getResource | com.codename1.ui.CN#getResourceAsStream | A device has streams, not resource URLs. Use Class.getResourceAsStream(name) or CN.getResourceAsStream("/name"); resources live in the root of the application, without directories.
+java.lang.ClassLoader | com.codename1.ui.CN#getResourceAsStream | There is one class loader and it loads nothing at run time. For a resource use CN.getResourceAsStream("/name").
+java.util.ServiceLoader | | ServiceLoader finds the providers that the META-INF/services files of the application and its bundled libraries list, fixed when the application is built. This member of it has no equivalent: create the implementation you ship by name.
+java.lang.Module | | No modules on a device: every class is in the one unnamed module, which has no name, layer or descriptor. Module.isNamed(), getName() and getLayer() answer that; nothing else of the module system exists.
+java.lang.ModuleLayer | | No modules on a device: there is no module layer, and Module.getLayer() answers null.
+org.osgi. | | No OSGi framework on a device. FrameworkUtil.getBundle(Class) answers null, as it does outside a framework; take the code path your library uses on a plain class path.
+java.io.ObjectOutputStream | com.codename1.io.Externalizable, com.codename1.io.Storage#writeObject, com.codename1.io.Util#register | No Java serialization on a device. Implement com.codename1.io.Externalizable, register the class with Util.register, and store it with Storage.writeObject; or write JSON.
+java.io.ObjectInputStream | com.codename1.io.Externalizable, com.codename1.io.Storage#readObject, com.codename1.io.Util#register | No Java serialization on a device. Implement com.codename1.io.Externalizable, register the class with Util.register, and read it with Storage.readObject; or parse JSON with JSONParser.
+java.beans.XMLEncoder | com.codename1.io.Externalizable, com.codename1.io.JSONParser | No long-term persistence on a device. Store the state yourself: Externalizable, or JSON.
+java.beans.XMLDecoder | com.codename1.io.Externalizable, com.codename1.io.JSONParser | No long-term persistence on a device. Store the state yourself: Externalizable, or JSON.
+java.beans.Introspector | com.codename1.properties.PropertyBusinessObject | No introspection on a device. Describe the object's fields with PropertyBusinessObject.
+
+# Crypto
+javax.crypto. | com.codename1.security.Cipher, com.codename1.security.Hmac, com.codename1.security.KeyGenerator | Use com.codename1.security: Cipher for AES, Hmac, KeyGenerator, SecureRandom.
+java.security.MessageDigest | com.codename1.security.Hash#sha256 | Use com.codename1.security.Hash (Hash.sha256(bytes), sha1, md5).
+java.security.SecureRandom | com.codename1.security.SecureRandom | Use com.codename1.security.SecureRandom.
+java.security.KeyStore | com.codename1.security.SecureStorage | Keep a secret in com.codename1.security.SecureStorage, which is the platform's key store.
+java.security.Signature | com.codename1.security.Signature | Use com.codename1.security.Signature.
+java.security. | com.codename1.security.Hash, com.codename1.security.Cipher | Use com.codename1.security, which has the digests, ciphers, keys and signatures a device provides.
+java.util.Base64 | com.codename1.util.Base64#encodeNoNewline, com.codename1.util.Base64#decode | Use com.codename1.util.Base64.
+
+# Data
+java.sql. | com.codename1.db.Database, com.codename1.ui.Display#openOrCreate | No JDBC on a device. Use the device's SQLite through Display.getInstance().openOrCreate(name), which answers a com.codename1.db.Database; a server database belongs behind a web service.
+javax.sql. | com.codename1.db.Database | No JDBC on a device. Use com.codename1.db.Database for local data.
+java.util.prefs. | com.codename1.io.Preferences#set, com.codename1.io.Preferences#get | Use com.codename1.io.Preferences (Preferences.set(key, value), Preferences.get(key, default)).
+java.util.logging. | com.codename1.io.Log#p | Use com.codename1.io.Log (Log.p(message), Log.e(throwable)).
+java.lang.System.Logger | com.codename1.io.Log#p | Use com.codename1.io.Log.
+javax.xml. | com.codename1.xml.XMLParser, com.codename1.xml.Element | Use com.codename1.xml.XMLParser, which answers a tree of Element.
+org.w3c.dom. | com.codename1.xml.XMLParser, com.codename1.xml.Element | Use com.codename1.xml.XMLParser, which answers a tree of Element.
+org.xml.sax. | com.codename1.xml.XMLParser | Use com.codename1.xml.XMLParser.
+java.util.zip.ZipFile | java.util.zip.ZipInputStream | No random access to a zip archive on a device. Read the entries in order with java.util.zip.ZipInputStream.
+java.util.zip. | java.util.zip.ZipInputStream, java.util.zip.ZipOutputStream, java.util.zip.GZIPInputStream, java.util.zip.GZIPOutputStream | A device has the streaming half of java.util.zip: the zip and GZIP streams, Inflater, Deflater and the checksums.
+java.util.jar. | | No equivalent: an application is not a jar on a device.
+java.text.SimpleDateFormat | com.codename1.l10n.SimpleDateFormat | Use com.codename1.l10n.SimpleDateFormat.
+java.text.MessageFormat | com.codename1.util.StringUtil#replaceAll | No MessageFormat on a device. Build the text with StringBuilder or StringUtil.replaceAll.
+java.util.regex. | com.codename1.util.regex.RE | The device's regular expressions cover the common syntax. For what they refuse use com.codename1.util.regex.RE, or simplify the expression.
+java.lang.management. | | No equivalent: a device has no JMX.
+javax.management. | | No equivalent: a device has no JMX.
+javax.naming. | | No equivalent: a device has no naming service.
+java.rmi. | com.codename1.io.rest.Rest | No RMI on a device. Call the server through a web service (Rest).
+javax.script. | com.codename1.ui.BrowserComponent#execute | No script engines on a device. JavaScript runs inside a BrowserComponent (execute, executeAndReturnString).
+javax.tools. | | No equivalent: a device cannot compile Java.
+java.lang.instrument. | | No equivalent: a device has no agents.
+
+# Threads and timing
+java.lang.Thread.sleep | com.codename1.ui.CN#invokeAndBlock, com.codename1.ui.util.UITimer#timer | Never on the event dispatch thread, which is the whole UI. Use UITimer.timer(ms, repeat, form, runnable) to do something later, or CN.invokeAndBlock for a wait that keeps the UI alive.
+java.util.concurrent.ForkJoinPool | com.codename1.util.EasyThread, com.codename1.ui.CN#scheduleBackgroundTask | Use CN.scheduleBackgroundTask(runnable) or an EasyThread, and return to the UI with CN.callSerially.
+java.util.concurrent.CompletableFuture | com.codename1.util.AsyncResource, com.codename1.ui.CN#callSerially | Use com.codename1.util.AsyncResource for a result that arrives later, and CN.callSerially to return to the UI.
+java.util.concurrent.Executor | com.codename1.util.EasyThread, com.codename1.ui.CN#scheduleBackgroundTask | Use CN.scheduleBackgroundTask(runnable) or an EasyThread, and return to the UI with CN.callSerially.
+java.util.concurrent.ScheduledExecutorService | com.codename1.ui.util.UITimer#timer, com.codename1.ui.CN#setTimeout | Use UITimer.timer or CN.setTimeout(ms, runnable).
+
+# Desktop-only AWT and Swing
+java.awt.Robot | com.codename1.testing.TestUtils | No equivalent in an application: a device does not let one synthesize input or read the screen. In a test use com.codename1.testing.TestUtils.
+java.awt.SystemTray | com.codename1.notifications.LocalNotification, com.codename1.ui.Display#scheduleLocalNotification | A device has no tray. What a tray icon announces is a LocalNotification (Display.scheduleLocalNotification).
+java.awt.TrayIcon | com.codename1.notifications.LocalNotification, com.codename1.ui.Display#scheduleLocalNotification | A device has no tray. What a tray icon announces is a LocalNotification (Display.scheduleLocalNotification).
+java.awt.Taskbar | com.codename1.ui.Display#setBadgeNumber | A device has no task bar. A count on the application's icon is Display.setBadgeNumber(n).
+java.awt.print. | com.codename1.ui.Display#print, com.codename1.ui.Display#isPrintingSupported | The Swing layer does not print. Write the document to a file (a PDF or an image) and hand it to Display.print(path, mimeType, listener) where Display.isPrintingSupported().
+javax.print. | com.codename1.ui.Display#print, com.codename1.ui.Display#isPrintingSupported | Write the document to a file and hand it to Display.print(path, mimeType, listener) where Display.isPrintingSupported().
+java.awt.PrintJob | com.codename1.ui.Display#print | Write the document to a file and hand it to Display.print(path, mimeType, listener).
+java.awt.dnd. | com.codename1.ui.Component#setDraggable, com.codename1.ui.Component#setDropTarget, com.codename1.ui.Component#addDropListener | The Swing layer does not drag data, and nothing is dragged between applications on a device. Inside the application use Codename One's own Component.setDraggable, setDropTarget and addDropListener, or offer the action in a menu.
+javax.swing.TransferHandler | com.codename1.ui.Display#copyToClipboard, com.codename1.ui.Component#setDraggable | The Swing layer does not drag data. Use the clipboard (Display.copyToClipboard) or Codename One's own Component.setDraggable and setDropTarget.
+javax.swing.JEditorPane | com.codename1.ui.BrowserComponent#setPage | A JEditorPane shows plain text or simple HTML that the user cannot edit. For a full HTML page use a BrowserComponent (setPage(html, baseUrl)).
+javax.swing.text.html. | com.codename1.ui.BrowserComponent#setPage | The Swing layer has no editor kits: a JEditorPane shows plain text or simple HTML. For a full HTML page use a BrowserComponent (setPage(html, baseUrl)).
+javax.swing.text.StyledDocument | | No styled documents in the Swing layer: a text component holds plain text, or simple HTML it shows and does not edit.
+javax.swing.text.StyledEditorKit | | No editor kits in the Swing layer: a text component holds plain text, or simple HTML it shows and does not edit.
+javax.swing.undo. | | No javax.swing.undo in the Swing layer. Keep the history yourself: a list of the edits and their inverses.
+java.awt.image.Raster | com.codename1.ui.Image#getRGB | No rasters or color models in the Swing layer. Read and write pixels as ARGB ints: BufferedImage.getRGB and setRGB.
+java.awt.image.WritableRaster | com.codename1.ui.Image#getRGB | No rasters or color models in the Swing layer. Read and write pixels as ARGB ints: BufferedImage.getRGB and setRGB.
+java.awt.im. | | No equivalent: the device's own keyboard does the input method's work.
+java.awt.datatransfer. | com.codename1.ui.Display#copyToClipboard, com.codename1.ui.Display#getPasteDataFromClipboard | Use Display.copyToClipboard(Object) and Display.getPasteDataFromClipboard().
+java.awt.GraphicsEnvironment | com.codename1.ui.CN#getDisplayWidth, com.codename1.ui.CN#getDisplayHeight | A device has one screen: CN.getDisplayWidth(), CN.getDisplayHeight().
+java.awt.GraphicsDevice | com.codename1.ui.CN#getDisplayWidth, com.codename1.ui.CN#getDisplayHeight | A device has one screen, and the application fills it: CN.getDisplayWidth(), CN.getDisplayHeight().
+javax.swing.text.rtf. | | No equivalent: there is no RTF on a device.
+javax.swing.plaf. | | Look-and-feel delegates are not part of the Swing layer: a component is drawn by the layer's own theme. Style through the UIManager keys and client properties the layer honors.
+javax.sound. | com.codename1.media.MediaManager#createMedia | Use com.codename1.media.MediaManager.createMedia(uri, isVideo).
+java.applet. | | No equivalent: there are no applets.
+javax.accessibility. | com.codename1.ui.Component#setAccessibilityText | Describe a component to the platform's screen reader with Component.setAccessibilityText.
+com.sun.jna. | com.codename1.system.NativeInterface | Native code a desktop loads cannot run on a device. A device's native code is written per platform behind a com.codename1.system.NativeInterface.
+java.lang.System.loadLibrary | com.codename1.system.NativeInterface | Native code a desktop loads cannot run on a device. A device's native code is written per platform behind a com.codename1.system.NativeInterface.
+java.lang.System.load | com.codename1.system.NativeInterface | Native code a desktop loads cannot run on a device. A device's native code is written per platform behind a com.codename1.system.NativeInterface.
+
+# Well-known libraries with a Codename One counterpart
+com.fasterxml.jackson. | com.codename1.io.JSONParser, com.codename1.io.rest.Rest | Jackson binds through reflection, which a device lacks. Parse with com.codename1.io.JSONParser (a Map), or let Rest answer the Map directly.
+com.google.gson. | com.codename1.io.JSONParser | Gson binds through reflection, which a device lacks. Parse with com.codename1.io.JSONParser.
+org.json. | com.codename1.io.JSONParser | Parse with com.codename1.io.JSONParser.
+org.slf4j. | com.codename1.io.Log#p | Use com.codename1.io.Log.
+org.apache.logging. | com.codename1.io.Log#p | Use com.codename1.io.Log.
+ch.qos.logback. | com.codename1.io.Log#p | Use com.codename1.io.Log.
+org.apache.commons.logging. | com.codename1.io.Log#p | Use com.codename1.io.Log.
+org.apache.http. | com.codename1.io.rest.Rest, com.codename1.io.ConnectionRequest | Use Rest or ConnectionRequest.
+okhttp3. | com.codename1.io.rest.Rest, com.codename1.io.ConnectionRequest | Use Rest or ConnectionRequest.
+org.sqlite. | com.codename1.db.Database | Use the device's own SQLite through com.codename1.db.Database.
diff --git a/maven/build-engine/src/test/java/com/codename1/builders/AndroidDesugaringDependencyTest.java b/maven/build-engine/src/test/java/com/codename1/builders/AndroidDesugaringDependencyTest.java
new file mode 100644
index 00000000000..5ec7ec5f0c0
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/builders/AndroidDesugaringDependencyTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided by
+ * Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.builders;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class AndroidDesugaringDependencyTest {
+
+    @Test
+    void theGradle8BuildDesugarsWithTheNioFlavour() {
+        assertEquals("    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs_nio:2.1.5'\n",
+                AndroidGradleBuilder.coreLibraryDesugaringDependency(true, "", ""));
+        assertEquals("    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs_nio:2.1.5'\n",
+                AndroidGradleBuilder.coreLibraryDesugaringDependency(true, null, null));
+    }
+
+    @Test
+    void theLegacyBuildHasNoDesugaring() {
+        assertEquals("", AndroidGradleBuilder.coreLibraryDesugaringDependency(false, "", ""));
+    }
+
+    @Test
+    void aDesugaredLibraryTheProjectDeclaresWins() {
+        String[] declared = {
+            "    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4'\n",
+            "    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs_minimal:2.1.5'\n",
+            "    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs_nio:2.1.5'\n",
+        };
+        for (String dep : declared) {
+            assertEquals("", AndroidGradleBuilder.coreLibraryDesugaringDependency(true, dep, ""), dep);
+            assertEquals("", AndroidGradleBuilder.coreLibraryDesugaringDependency(true, "", dep), dep);
+        }
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/AndroidRemapperTest.java b/maven/build-engine/src/test/java/com/codename1/maven/AndroidRemapperTest.java
index 555cbf85646..2ad994136e5 100644
--- a/maven/build-engine/src/test/java/com/codename1/maven/AndroidRemapperTest.java
+++ b/maven/build-engine/src/test/java/com/codename1/maven/AndroidRemapperTest.java
@@ -143,7 +143,7 @@ public void relocatesApplicationAndRuntimeAndWritesTheDispatcher() throws Except
         List<String> app = refs(Files.readAllBytes(new File(classes, "com/x/Main.class").toPath()));
         assertTrue(app.toString(), app.contains("com/codename1/androidcompat/android/app/Activity"));
         assertTrue(app.toString(), app.contains("(Lcom/codename1/androidcompat/android/view/View;)V"));
-        assertTrue(app.toString(), app.contains("com/codename1/androidcompat/jdk/BufferedReader"));
+        assertTrue(app.toString(), app.contains("java/io/BufferedReader"));
         for (String r : app) {
             assertFalse(r, r != null && (r.startsWith("android/") || r.contains("Landroid/")));
         }
@@ -461,10 +461,11 @@ public void importerReadsGradleBuilds() {
         assertEquals("com.squareup.retrofit2:retrofit", r.uncovered.get(0));
     }
 
-    /// The java.io classes the Codename One runtime lacks go to the shims,
-    /// Closeable becomes AutoCloseable, and a class that named both keeps one.
+    /// The device's class library has java.io under the JDK's names, so a
+    /// class naming it -- `Closeable` beside `AutoCloseable` included -- is
+    /// left as it was compiled.
     @Test
-    public void mapsJavaIoShimsAndKeepsInterfacesDistinct() {
+    public void javaIoKeepsItsNamesAndInterfacesStayDistinct() {
         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
         cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "com/x/Res", null, "java/lang/Object",
                 new String[] {"java/io/Closeable", "java/lang/AutoCloseable"});
@@ -485,11 +486,10 @@ public void visit(int v, int a, String name, String sig, String sup, String[] in
                 itf.add(interfaces);
             }
         }, 0);
-        assertEquals(1, itf.get(0).length);
-        assertEquals("java/lang/AutoCloseable", itf.get(0)[0]);
+        assertArrayEquals(new String[] {"java/io/Closeable", "java/lang/AutoCloseable"}, itf.get(0));
         List<String> r = refs(out);
-        assertTrue(r.toString(), r.contains("(Lcom/codename1/androidcompat/jdk/File;)Ljava/io/InputStream;"));
-        assertTrue(r.toString(), r.contains("com/codename1/androidcompat/jdk/FileInputStream"));
+        assertTrue(r.toString(), r.contains("(Ljava/io/File;)Ljava/io/InputStream;"));
+        assertTrue(r.toString(), r.contains("java/io/FileInputStream"));
     }
 
     /// A public class `name` extending `superName` with public constructors
@@ -674,7 +674,9 @@ public void descriptorCollisionsAreRejectedBeforeWritingAClass() {
         for (String name : new String[]{"accept", "<init>"}) {
             ClassWriter cw = new ClassWriter(0);
             cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "example/Overloaded", null, "java/lang/Object", null);
-            for (String type : new String[]{"java/io/Closeable", "java/lang/AutoCloseable"}) {
+            // The device's regular expressions are the framework's, so a
+            // class overloading on both names collapses once relocated.
+            for (String type : new String[]{"java/util/regex/Pattern", "com/codename1/util/regex/Pattern"}) {
                 MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, name, "(L" + type + ";)V", null, null);
                 mv.visitCode(); mv.visitInsn(Opcodes.RETURN); mv.visitMaxs(0, 2); mv.visitEnd();
             }
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/ApplicationRegistryTest.java b/maven/build-engine/src/test/java/com/codename1/maven/ApplicationRegistryTest.java
new file mode 100644
index 00000000000..2309f9f783a
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/ApplicationRegistryTest.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.impl.JdkHost;
+import com.codename1.impl.compat.Resources;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The registry the class library's `ResourceBundle` and `ServiceLoader`
+/// read through `JdkHost`: generated, defined, installed and asked, over the
+/// core's real `CompatRegistryBase` and `Resources`.
+public class ApplicationRegistryTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private final List<String> warned = new ArrayList<String>();
+
+    private final com.codename1.build.Log log = new com.codename1.build.Log() {
+        public void debug(CharSequence c) { }
+        public void debug(CharSequence c, Throwable e) { }
+        public void debug(Throwable e) { }
+        public void info(CharSequence c) { }
+        public void info(CharSequence c, Throwable e) { }
+        public void info(Throwable e) { }
+        public void warn(CharSequence c) { warned.add(c.toString()); }
+        public void warn(CharSequence c, Throwable e) { }
+        public void warn(Throwable e) { }
+        public void error(CharSequence c) { }
+        public void error(CharSequence c, Throwable e) { }
+        public void error(Throwable e) { }
+        public boolean isDebugEnabled() { return false; }
+        public boolean isInfoEnabled() { return true; }
+        public boolean isWarnEnabled() { return true; }
+        public boolean isErrorEnabled() { return true; }
+    };
+
+    @After
+    public void reset() {
+        JdkHost.setRegistry(null);
+        Resources.cn1ClearIndex();
+    }
+
+    /// Defines the generated classes and nothing else; everything they name
+    /// resolves from this test's class path. The generated classes come
+    /// first: the layers' jars on that class path carry the placeholder of
+    /// the same name.
+    private static final class Loader extends ClassLoader {
+        private final Map<String, byte[]> classes;
+
+        Loader(Map<String, byte[]> classes) {
+            super(ApplicationRegistryTest.class.getClassLoader());
+            this.classes = classes;
+        }
+
+        @Override
+        protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+            byte[] b = classes.get(name.replace('.', '/'));
+            if (b == null) {
+                return super.loadClass(name, resolve);
+            }
+            Class<?> c = findLoadedClass(name);
+            if (c == null) {
+                c = defineClass(name, b, 0, b.length);
+            }
+            if (resolve) {
+                resolveClass(c);
+            }
+            return c;
+        }
+    }
+
+    private static void install(Map<String, byte[]> classes) throws Exception {
+        new Loader(classes).loadClass(ApplicationRegistry.NAME.replace('/', '.')).getMethod("cn1Install")
+                .invoke(null);
+    }
+
+    @Test
+    public void installingAnswersForEveryClassProviderAndResource() throws Exception {
+        List<String[]> services = new ArrayList<String[]>();
+        services.add(new String[] {"java.lang.CharSequence", "java/lang/StringBuilder"});
+        services.add(new String[] {"java.lang.CharSequence", "java/lang/StringBuffer"});
+        // A bundle class that is also a provider gets one number.
+        services.add(new String[] {"java.lang.Object", "java/util/ArrayList"});
+        services.add(new String[] {"java.lang.CharSequence", "java/lang/StringBuilder"});
+        Map<String, byte[]> classes = ApplicationRegistry.generate(Arrays.asList("a/b.txt", "c.properties"),
+                Collections.singletonList("java.util.ArrayList"), services);
+        assertNull(JdkHost.getRegistry());
+        install(classes);
+
+        JdkHost.Registry r = JdkHost.getRegistry();
+        assertTrue(r instanceof com.codename1.impl.compat.CompatRegistryBase);
+        assertArrayEquals(new String[] {"java.lang.StringBuilder", "java.lang.StringBuffer"},
+                r.providers("java.lang.CharSequence"));
+        assertArrayEquals(new String[] {"java.util.ArrayList"}, r.providers("java.lang.Object"));
+        assertNull(r.providers("java.lang.Runnable"));
+
+        assertTrue(r.newInstance("java.lang.StringBuilder") instanceof StringBuilder);
+        assertTrue(r.newInstance("java.lang.StringBuffer") instanceof StringBuffer);
+        assertTrue(r.newInstance("java.util.ArrayList") instanceof ArrayList);
+        assertNotSame(r.newInstance("java.util.ArrayList"), r.newInstance("java.util.ArrayList"));
+        assertNull(r.newInstance("java.util.HashMap"));
+        assertSame(StringBuffer.class, r.type("java.lang.StringBuffer"));
+        assertSame(ArrayList.class, r.type("java.util.ArrayList"));
+        assertNull(r.type("java.util.HashMap"));
+
+        // The host serves what the registry answers.
+        assertArrayEquals(new String[] {"java.util.ArrayList"}, JdkHost.get().providers("java.lang.Object"));
+        assertSame(ArrayList.class, JdkHost.get().type("java.util.ArrayList"));
+
+        assertEquals(Arrays.asList("a/b.txt", "c.properties"), sorted(Resources.cn1ResourcePaths()));
+
+        // A second install, from a second definition, keeps the first.
+        install(ApplicationRegistry.generate(Collections.singletonList("other.txt"),
+                Collections.<String>emptyList(), new ArrayList<String[]>()));
+        assertSame(r, JdkHost.getRegistry());
+        assertEquals(Arrays.asList("a/b.txt", "c.properties"), sorted(Resources.cn1ResourcePaths()));
+    }
+
+    @Test
+    public void anEmptyApplicationInstallsAnEmptyRegistry() throws Exception {
+        Map<String, byte[]> classes = ApplicationRegistry.generate(Collections.<String>emptyList(),
+                Collections.<String>emptyList(), new ArrayList<String[]>());
+        assertEquals(Collections.singleton(ApplicationRegistry.NAME), classes.keySet());
+        install(classes);
+        JdkHost.Registry r = JdkHost.getRegistry();
+        assertNull(r.providers("java.lang.Runnable"));
+        assertNull(r.newInstance("java.lang.Object"));
+        assertNull(r.type("java.lang.Object"));
+        assertEquals(0, Resources.cn1ResourcePaths().length);
+    }
+
+    @Test
+    public void registrationsSpreadOverPartsAndStalePartsAreRemoved() throws Exception {
+        List<String> resources = new ArrayList<String>();
+        for (int i = 0; i < 2500; i++) {
+            resources.add("r/" + i + ".txt");
+        }
+        Map<String, byte[]> big = ApplicationRegistry.generate(resources, Collections.<String>emptyList(),
+                new ArrayList<String[]>());
+        assertTrue(big.containsKey(ApplicationRegistry.NAME + "$Part2"));
+        assertFalse(big.containsKey(ApplicationRegistry.NAME + "$Part3"));
+        install(big);
+        assertEquals(new java.util.TreeSet<String>(resources), new java.util.TreeSet<String>(sorted(Resources.cn1ResourcePaths())));
+
+        File dir = tmp.newFolder();
+        ApplicationRegistry.write(dir, big, log);
+        File generated = new File(dir, ApplicationRegistry.NAME + ".class").getParentFile();
+        assertEquals(4, generated.list().length);
+        Map<String, byte[]> small = ApplicationRegistry.generate(resources.subList(0, 10),
+                Collections.<String>emptyList(), new ArrayList<String[]>());
+        ApplicationRegistry.write(dir, small, log);
+        assertEquals(Arrays.asList("CompatRegistry$Part0.class", "CompatRegistry.class"),
+                sorted(generated.list()));
+        assertEquals(Collections.<String>emptyList(), warned);
+    }
+
+    private static List<String> sorted(String[] names) {
+        List<String> out = new ArrayList<String>(Arrays.asList(names));
+        Collections.sort(out);
+        return out;
+    }
+
+    /// The build reads a services file by the rule the runtime reads one.
+    @Test
+    public void servicesFilesAreReadAsTheCompatRuntimeReadsThem() {
+        String text = "# header\r\n\n  org.a.One   # first\norg.a.Two\r\norg.a.One\nnot a name\n\t\n"
+                + "9bad\norg.a.$Three\n#org.a.Four\norg.a.Five#x";
+        List<String> illegal = new ArrayList<String>();
+        assertEquals(Arrays.asList("org.a.One", "org.a.Two", "org.a.$Three", "org.a.Five"),
+                ServiceProviderNames.of(text, illegal));
+        assertEquals(Arrays.asList("org.a.One", "org.a.Two", "org.a.$Three", "org.a.Five"),
+                ServiceProviderNames.of(text, null));
+        assertEquals(Arrays.asList("not a name", "9bad"), illegal);
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/ArrayClassGeneratorTest.java b/maven/build-engine/src/test/java/com/codename1/maven/ArrayClassGeneratorTest.java
new file mode 100644
index 00000000000..f226848d61b
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/ArrayClassGeneratorTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+/// The array class of a type an application only names with a class
+/// literal: ParparVM has none unless some bytecode names the array type,
+/// so the remap generates a class that does.
+public class ArrayClassGeneratorTest {
+
+    /// A listener type of the application's own, handed to a method that
+    /// makes an array of it by reflection, and never made an array of by
+    /// the application: a method that returns `Listener[]` and a cast to
+    /// it are not enough for a device.
+    private static final String SOURCE = "package q;\n"
+            + "public class Model {\n"
+            + "    public interface Listener extends java.util.EventListener { }\n"
+            + "    public static class Other { }\n"
+            + "    public Listener[] listeners() {\n"
+            + "        return (Listener[]) java.lang.reflect.Array.newInstance(Listener.class, 0);\n"
+            + "    }\n"
+            + "    public Object made() { return new Other[0]; }\n"
+            + "    public Class<?> already() { return String[].class; }\n"
+            + "}\n";
+
+    @Rule
+    public final TemporaryFolder tmp = new TemporaryFolder();
+
+    private static List<String> arrayLiterals(byte[] cls) {
+        final List<String> out = new ArrayList<String>();
+        new ClassReader(cls).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visitLdcInsn(Object value) {
+                        if (value instanceof Type && ((Type) value).getSort() == Type.ARRAY) {
+                            out.add(((Type) value).getDescriptor());
+                        }
+                    }
+                };
+            }
+        }, 0);
+        return out;
+    }
+
+    @Test
+    public void aClassLiteralGetsItsArrayClass() throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compile(tmp.newFolder(), classes, "q/Model.java", SOURCE);
+        List<String> app = Arrays.asList("q/Model", "q/Model$Listener", "q/Model$Other");
+        // The application's own classes name the array of neither type
+        // with a literal; that is the case a device threw for.
+        assertFalse(arrayLiterals(Files.readAllBytes(new File(classes, "q/Model.class").toPath()))
+                .contains("[Lq/Model$Listener;"));
+
+        assertEquals(1, new ArrayClassGenerator(classes).run(app));
+        File holder = new File(classes, ArrayClassGenerator.HOLDER + ".class");
+        byte[] first = Files.readAllBytes(holder.toPath());
+        assertEquals(Arrays.asList("[Lq/Model$Listener;"), arrayLiterals(first));
+
+        // It is a class a device can load: it verifies and runs.
+        CompatFixtures.Defining loader = new CompatFixtures.Defining(new java.net.URLClassLoader(
+                new java.net.URL[] {classes.toURI().toURL()}, null));
+        loader.define(first).getMethod("types").invoke(null);
+
+        // A second run, which finds the holder among the classes, writes
+        // the same bytes.
+        List<String> again = new ArrayList<String>(app);
+        again.add(ArrayClassGenerator.HOLDER);
+        assertEquals(1, new ArrayClassGenerator(classes).run(again));
+        assertArrayEquals(first, Files.readAllBytes(holder.toPath()));
+    }
+
+    @Test
+    public void withoutAClassLiteralThereIsNoHolder() throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compile(tmp.newFolder(), classes, "q/Plain.java",
+                "package q;\npublic class Plain { public int one() { return 1; } }\n");
+        File holder = new File(classes, ArrayClassGenerator.HOLDER + ".class");
+        holder.getParentFile().mkdirs();
+        Files.write(holder.toPath(), new byte[] {1});
+        assertEquals(0, new ArrayClassGenerator(classes).run(Arrays.asList("q/Plain")));
+        assertFalse(holder.exists());
+        assertTrue(new File(classes, "q/Plain.class").isFile());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatFixtures.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatFixtures.java
new file mode 100644
index 00000000000..b58b3c09da6
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatFixtures.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// What the compatibility layer tests share: compiling a fixture the way an
+/// application is compiled -- by javac, against the JDK -- and reading back
+/// which members a class file refers to.
+final class CompatFixtures {
+
+    /// The `cn1res:` URLs the JavaSE and Android ports make for
+    /// [com.codename1.impl.compat.Resources] on a JDK whose `URL` does not
+    /// know the scheme: their stream reads back through `Resources`. A test
+    /// installs it with `Resources.cn1SetUrlFactory` and removes it after.
+    static com.codename1.impl.compat.Resources.UrlFactory cn1resUrls() {
+        final java.net.URLStreamHandler handler = new java.net.URLStreamHandler() {
+            @Override
+            protected java.net.URLConnection openConnection(java.net.URL u) {
+                return new java.net.URLConnection(u) {
+                    @Override
+                    public void connect() {
+                        connected = true;
+                    }
+
+                    @Override
+                    public java.io.InputStream getInputStream() throws IOException {
+                        java.io.InputStream in = com.codename1.impl.compat.Resources.openUrlPath(getURL().getPath());
+                        if (in == null) {
+                            throw new java.io.FileNotFoundException(getURL().toExternalForm());
+                        }
+                        return in;
+                    }
+                };
+            }
+        };
+        return new com.codename1.impl.compat.Resources.UrlFactory() {
+            @Override
+            public java.net.URL create(String encodedPath) throws IOException {
+                return new java.net.URL("cn1res", null, -1, encodedPath, handler);
+            }
+        };
+    }
+
+    private CompatFixtures() {
+    }
+
+    /// Compiles Java sources into `classesDir`. `nameThenSource` alternates
+    /// a path (`p/Foo.java`) and the file's text.
+    static void compile(File sourceDir, File classesDir, String... nameThenSource) throws IOException {
+        compileAgainst(null, sourceDir, classesDir, nameThenSource);
+    }
+
+    /// As [#compile], with `classpath` as the compile classpath: the jars a
+    /// fixture names beyond the JDK. Null leaves the compiler's default.
+    static void compileAgainst(List<File> classpath, File sourceDir, File classesDir, String... nameThenSource)
+            throws IOException {
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+        assertNotNull("These tests need a JDK, not a JRE", javac);
+        List<String> args = new ArrayList<String>();
+        if (classpath != null) {
+            StringBuilder cp = new StringBuilder();
+            for (File f : classpath) {
+                cp.append(cp.length() == 0 ? "" : File.pathSeparator).append(f.getAbsolutePath());
+            }
+            args.add("-cp");
+            args.add(cp.toString());
+        }
+        args.add("-d");
+        args.add(classesDir.getAbsolutePath());
+        args.add("-g");
+        args.add("-nowarn");
+        args.add("-encoding");
+        args.add("UTF-8");
+        for (int i = 0; i < nameThenSource.length; i += 2) {
+            File f = new File(sourceDir, nameThenSource[i]);
+            assertTrue(f.getParentFile().isDirectory() || f.getParentFile().mkdirs());
+            Files.write(f.toPath(), nameThenSource[i + 1].getBytes("UTF-8"));
+            args.add(f.getAbsolutePath());
+        }
+        assertTrue(classesDir.isDirectory() || classesDir.mkdirs());
+        ByteArrayOutputStream errors = new ByteArrayOutputStream();
+        int result = javac.run(null, null, errors, args.toArray(new String[args.size()]));
+        assertEquals(new String(errors.toByteArray(), "UTF-8"), 0, result);
+    }
+
+    /// Every method and field a class's code refers to, as `owner.name`, a
+    /// method reference's target included.
+    static Set<String> members(byte[] cls) {
+        final Set<String> out = new TreeSet<String>();
+        new ClassReader(cls).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                                             String[] exceptions) {
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String n, String d, boolean itf) {
+                        out.add(owner + "." + n);
+                    }
+
+                    @Override
+                    public void visitFieldInsn(int opcode, String owner, String n, String d) {
+                        out.add(owner + "." + n);
+                    }
+
+                    @Override
+                    public void visitInvokeDynamicInsn(String n, String d, Handle bootstrap, Object... arguments) {
+                        for (Object argument : arguments) {
+                            if (argument instanceof Handle) {
+                                out.add(((Handle) argument).getOwner() + "." + ((Handle) argument).getName());
+                            }
+                        }
+                    }
+                };
+            }
+        }, 0);
+        return out;
+    }
+
+    /// A loader that defines the given classes itself, ahead of its parent:
+    /// a relocated fixture, or a generated class that has the name of one
+    /// the parent already holds.
+    static final class Defining extends ClassLoader {
+        Defining(ClassLoader parent) {
+            super(parent);
+        }
+
+        Class<?> define(byte[] cls) {
+            return defineClass(null, cls, 0, cls.length);
+        }
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatLayerComplianceTest.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatLayerComplianceTest.java
new file mode 100644
index 00000000000..f8110c06253
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatLayerComplianceTest.java
@@ -0,0 +1,655 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+import com.codename1.build.BuildFailureException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The compliance check as the compiler of a compatibility layer: an API the
+/// layer lacks is reported under the name the developer wrote and with the
+/// line it is on, wherever in the class file the reference sits -- and a
+/// project with no layer is checked exactly as before.
+public class CompatLayerComplianceTest {
+
+    private static final String SWING = CompatRemapperTest.SWING;
+    private static final String NOT_SUPPORTED = " is not supported by the Codename One Swing compatibility layer";
+    private static final Handle METAFACTORY = new Handle(Opcodes.H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory",
+            "metafactory", "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;"
+            + "Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)"
+            + "Ljava/lang/invoke/CallSite;", false);
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    /// The code of one method, written against the names an application is
+    /// compiled against.
+    private interface Body {
+        void emit(MethodVisitor mv);
+    }
+
+    private static void line(MethodVisitor mv, int line) {
+        Label label = new Label();
+        mv.visitLabel(label);
+        mv.visitLineNumber(line, label);
+    }
+
+    private static void pushDefault(MethodVisitor mv, Type type) {
+        switch (type.getSort()) {
+            case Type.OBJECT:
+            case Type.ARRAY:
+                mv.visitInsn(Opcodes.ACONST_NULL);
+                break;
+            case Type.LONG:
+                mv.visitInsn(Opcodes.LCONST_0);
+                break;
+            case Type.FLOAT:
+                mv.visitInsn(Opcodes.FCONST_0);
+                break;
+            case Type.DOUBLE:
+                mv.visitInsn(Opcodes.DCONST_0);
+                break;
+            default:
+                mv.visitInsn(Opcodes.ICONST_0);
+        }
+    }
+
+    /// A call with its operands pushed and its result dropped, so the method
+    /// stays well formed: the check analyses every method's stack. A
+    /// constructor call expects the `NEW` before it.
+    private static void call(MethodVisitor mv, int opcode, String owner, String name, String descriptor) {
+        if (opcode != Opcodes.INVOKESTATIC && !"<init>".equals(name)) {
+            mv.visitInsn(Opcodes.ACONST_NULL);
+        }
+        for (Type argument : Type.getArgumentTypes(descriptor)) {
+            pushDefault(mv, argument);
+        }
+        mv.visitMethodInsn(opcode, owner, name, descriptor, false);
+        if (Type.getReturnType(descriptor).getSort() != Type.VOID) {
+            mv.visitInsn(Opcodes.POP);
+        }
+    }
+
+    private static void getStatic(MethodVisitor mv, String owner, String name, String descriptor) {
+        mv.visitFieldInsn(Opcodes.GETSTATIC, owner, name, descriptor);
+        mv.visitInsn(Opcodes.POP);
+    }
+
+    private static void ldc(MethodVisitor mv, Object constant) {
+        mv.visitLdcInsn(constant);
+        mv.visitInsn(Opcodes.POP);
+    }
+
+    private static void typeInsn(MethodVisitor mv, int opcode, String type) {
+        mv.visitInsn(opcode == Opcodes.ANEWARRAY ? Opcodes.ICONST_0 : Opcodes.ACONST_NULL);
+        mv.visitTypeInsn(opcode, type);
+        mv.visitInsn(Opcodes.POP);
+    }
+
+    private static void multiArray(MethodVisitor mv, String descriptor) {
+        mv.visitInsn(Opcodes.ICONST_0);
+        mv.visitInsn(Opcodes.ICONST_0);
+        mv.visitMultiANewArrayInsn(descriptor, 2);
+        mv.visitInsn(Opcodes.POP);
+    }
+
+    private static void lambda(MethodVisitor mv, String name, String descriptor, Object... bootstrapArguments) {
+        for (Type argument : Type.getArgumentTypes(descriptor)) {
+            pushDefault(mv, argument);
+        }
+        mv.visitInvokeDynamicInsn(name, descriptor, METAFACTORY, bootstrapArguments);
+        mv.visitInsn(Opcodes.POP);
+    }
+
+    /// A `try` around one instruction, catching `type` (null: a `finally`).
+    private static void tryCatch(MethodVisitor mv, String type) {
+        Label start = new Label();
+        Label end = new Label();
+        Label handler = new Label();
+        Label after = new Label();
+        mv.visitTryCatchBlock(start, end, handler, type);
+        mv.visitLabel(start);
+        mv.visitInsn(Opcodes.NOP);
+        mv.visitLabel(end);
+        mv.visitJumpInsn(Opcodes.GOTO, after);
+        mv.visitLabel(handler);
+        mv.visitInsn(Opcodes.POP);
+        mv.visitLabel(after);
+    }
+
+    private static ClassWriter appClass(String superName, String... interfaces) {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "com/x/Main", null, superName, interfaces);
+        cw.visitSource("Main.java", null);
+        return cw;
+    }
+
+    private static void method(ClassWriter cw, String name, String descriptor, String[] thrown, Body body) {
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, name, descriptor, null, thrown);
+        mv.visitCode();
+        body.emit(mv);
+        if (Type.getReturnType(descriptor).getSort() == Type.VOID) {
+            mv.visitInsn(Opcodes.RETURN);
+        } else {
+            mv.visitInsn(Opcodes.ACONST_NULL);
+            mv.visitInsn(Opcodes.ARETURN);
+        }
+        mv.visitMaxs(16, 16);
+        mv.visitEnd();
+    }
+
+    private static byte[] appWith(Body body) {
+        ClassWriter cw = appClass("java/lang/Object");
+        method(cw, "run", "()V", null, body);
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    private static byte[] apiClass(String name, boolean iface, String superName, String[] fields, String... methods) {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | (iface ? Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT : 0), name,
+                null, superName, null);
+        for (int i = 0; fields != null && i < fields.length; i += 2) {
+            cw.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, fields[i], fields[i + 1], null, null).visitEnd();
+        }
+        for (int i = 0; i < methods.length; i += 2) {
+            cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, methods[i], methods[i + 1], null, null)
+                    .visitEnd();
+        }
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    /// A tiny Swing runtime, authored the way the real one is: under the names
+    /// it ships with, and against the JDK classes its sources name.
+    private File swingJar() throws Exception {
+        String table = SWING + "javax/swing/JTable";
+        String listener = SWING + "java/awt/event/ActionListener";
+        String event = SWING + "java/awt/event/ActionEvent";
+        String component = SWING + "javax/swing/JComponent";
+        return CompatRemapperTest.jar(new File(tmp.getRoot(), "codenameone-swing-compat-1.jar"),
+                table + ".class", apiClass(table, false, component, new String[] {"AUTO_RESIZE_OFF", "I"},
+                        "<init>", "()V", "setRowHeight", "(I)V", "setFile", "(Ljava/util/regex/Pattern;)V"),
+                component + ".class", apiClass(component, false, "java/lang/Object", null, "<init>", "()V",
+                        "repaint", "()V"),
+                listener + ".class", apiClass(listener, true, "java/lang/Object", null,
+                        "actionPerformed", "(L" + event + ";)V"),
+                event + ".class", apiClass(event, false, "java/lang/Object", null));
+    }
+
+    private File allowedDir() throws Exception {
+        File dir = new File(tmp.getRoot(), "allowed");
+        if (!dir.isDirectory()) {
+            assertTrue(new File(dir, "java/lang").mkdirs());
+            Files.write(new File(dir, "java/lang/Object.class").toPath(),
+                    apiClass("java/lang/Object", false, null, null, "<init>", "()V"));
+            Files.write(new File(dir, "java/lang/Runnable.class").toPath(),
+                    apiClass("java/lang/Runnable", true, "java/lang/Object", null, "run", "()V"));
+        }
+        return dir;
+    }
+
+    /// Scans `app` as the Swing layer's build does: relocated, against the
+    /// runtime jar, with the layer active.
+    private List<?> scanWithSwing(byte[] app) throws Exception {
+        return scan(new ClassRelocator(CompatLayers.SWING).remap(app), Collections.singletonList(CompatLayers.SWING),
+                Collections.singletonList(swingJar()));
+    }
+
+    private List<?> scan(byte[] app, List<Relocation> layers, List<File> dependencies) throws Exception {
+        File classes = tmp.newFolder();
+        assertTrue(new File(classes, "com/x").mkdirs());
+        Files.write(new File(classes, "com/x/Main.class").toPath(), app);
+        BytecodeCompliance check = new BytecodeCompliance(TestProjectHost.empty()).activeLayers(layers);
+        Map<String, ?> allowed = buildClassIndex(check, Collections.singletonList(allowedDir()));
+        Map<String, ?> project = buildClassIndex(check, dependencies);
+        Method scan = BytecodeCompliance.class.getDeclaredMethod("scanProjectClasses", File.class, Map.class,
+                Map.class);
+        scan.setAccessible(true);
+        return (List<?>) scan.invoke(check, classes, allowed, project);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, ?> buildClassIndex(BytecodeCompliance check, List<File> roots) throws Exception {
+        Method method = BytecodeCompliance.class.getDeclaredMethod("buildClassIndex", List.class);
+        method.setAccessible(true);
+        return (Map<String, ?>) method.invoke(check, roots);
+    }
+
+    private static Object field(Object target, String name) throws Exception {
+        Field field = target.getClass().getDeclaredField(name);
+        field.setAccessible(true);
+        return field.get(target);
+    }
+
+    private static String render(Object violation, String method) throws Exception {
+        Method m = violation.getClass().getDeclaredMethod(method);
+        m.setAccessible(true);
+        return (String) m.invoke(violation);
+    }
+
+    /// Each violation as `reference @line`.
+    private static List<String> summary(List<?> violations) throws Exception {
+        List<String> out = new ArrayList<String>();
+        for (Object v : violations) {
+            out.add(field(v, "referencedMember") + " @" + field(v, "line"));
+        }
+        return out;
+    }
+
+    private static String unsupported(String api, int line) {
+        return api + NOT_SUPPORTED + " @" + line;
+    }
+
+    @Test
+    public void aSupportedReferencePassesAtEverySite() throws Exception {
+        ClassWriter cw = appClass("javax/swing/JComponent", "java/awt/event/ActionListener");
+        cw.visitField(Opcodes.ACC_PRIVATE, "table", "Ljavax/swing/JTable;", null, null).visitEnd();
+        method(cw, "lambda$run$0", "(Ljava/awt/event/ActionEvent;)V", null, mv -> line(mv, 5));
+        method(cw, "run", "([Ljavax/swing/JTable;)Ljavax/swing/JComponent;", null, mv -> {
+            line(mv, 10);
+            tryCatch(mv, "java/lang/Object");
+            mv.visitTypeInsn(Opcodes.NEW, "javax/swing/JTable");
+            call(mv, Opcodes.INVOKESPECIAL, "javax/swing/JTable", "<init>", "()V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "setRowHeight", "(I)V");
+            // Inherited from the layer's own superclass.
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "repaint", "()V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "setFile", "(Ljava/util/regex/Pattern;)V");
+            getStatic(mv, "javax/swing/JTable", "AUTO_RESIZE_OFF", "I");
+            line(mv, 11);
+            lambda(mv, "actionPerformed", "()Ljava/awt/event/ActionListener;",
+                    Type.getMethodType("(Ljava/awt/event/ActionEvent;)V"),
+                    new Handle(Opcodes.H_INVOKESTATIC, "com/x/Main", "lambda$run$0", "(Ljava/awt/event/ActionEvent;)V",
+                            false),
+                    Type.getMethodType("(Ljava/awt/event/ActionEvent;)V"));
+            lambda(mv, "run", "(Ljavax/swing/JTable;)Ljava/lang/Runnable;",
+                    Type.getMethodType("()V"),
+                    new Handle(Opcodes.H_INVOKEVIRTUAL, "javax/swing/JTable", "repaint", "()V", false),
+                    Type.getMethodType("()V"));
+            ldc(mv, Type.getObjectType("javax/swing/JTable"));
+            typeInsn(mv, Opcodes.CHECKCAST, "[Ljavax/swing/JTable;");
+            multiArray(mv, "[[Ljavax/swing/JComponent;");
+        });
+        cw.visitEnd();
+
+        List<?> violations = scanWithSwing(cw.toByteArray());
+        assertTrue(summary(violations).toString(), violations.isEmpty());
+    }
+
+    @Test
+    public void aMissingMemberIsNamedAsTheDeveloperWroteItWithItsLine() throws Exception {
+        List<?> violations = scanWithSwing(appWith(mv -> {
+            line(mv, 12);
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "setAutoCreateRowSorter", "(Z)V");
+            line(mv, 13);
+            mv.visitTypeInsn(Opcodes.NEW, "javax/swing/JTable");
+            call(mv, Opcodes.INVOKESPECIAL, "javax/swing/JTable", "<init>",
+                    "(I[Ljava/lang/String;Ljava/io/File;)V");
+            line(mv, 14);
+            getStatic(mv, "javax/swing/JTable", "AUTO_RESIZE_ALL_COLUMNS", "I");
+            line(mv, 15);
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "add",
+                    "(Ljavax/swing/JComponent;)Ljavax/swing/JComponent;");
+        }));
+
+        assertEquals(Arrays.asList(
+                unsupported("javax.swing.JTable.setAutoCreateRowSorter(boolean)", 12),
+                unsupported("new javax.swing.JTable(int, java.lang.String[], java.io.File)", 13),
+                unsupported("javax.swing.JTable.AUTO_RESIZE_ALL_COLUMNS", 14),
+                unsupported("javax.swing.JTable.add(javax.swing.JComponent)", 15)), summary(violations));
+        Object first = violations.get(0);
+        assertEquals("Main.java", field(first, "sourceFile"));
+        assertEquals("com/x/Main", field(first, "sourceClass"));
+        assertEquals("run()V", field(first, "sourceMethod"));
+        assertNull(field(first, "suggestion"));
+        String inline = render(first, "renderInline");
+        assertTrue(inline, inline.contains("javax.swing.JTable.setAutoCreateRowSorter(boolean)" + NOT_SUPPORTED));
+        assertTrue(inline, inline.endsWith(" at Main.java:12"));
+        assertTrue(render(first, "render"), render(first, "render").contains("Source location: Main.java:12\n"));
+    }
+
+    /// `new JTree()` is a type instruction and a constructor call, and every
+    /// method called on it is another instruction; a class the layer lacks is
+    /// one finding per line it is used on.
+    @Test
+    public void aMissingClassIsReportedOncePerLine() throws Exception {
+        List<?> violations = scanWithSwing(appWith(mv -> {
+            line(mv, 20);
+            mv.visitTypeInsn(Opcodes.NEW, "javax/swing/JTree");
+            call(mv, Opcodes.INVOKESPECIAL, "javax/swing/JTree", "<init>", "()V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTree", "expandRow", "(I)V");
+            getStatic(mv, "javax/swing/JTree", "ROOT", "I");
+            line(mv, 21);
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTree", "expandRow", "(I)V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "selectAll", "()V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "selectAll", "()V");
+        }));
+
+        assertEquals(Arrays.asList(unsupported("javax.swing.JTree", 20), unsupported("javax.swing.JTree", 21),
+                unsupported("javax.swing.JTable.selectAll()", 21)), summary(violations));
+    }
+
+    @Test
+    public void declarationsAreScanned() throws Exception {
+        ClassWriter cw = appClass("javax/swing/JTree", "javax/swing/Missing1", "java/awt/event/ActionListener");
+        cw.visitField(Opcodes.ACC_PRIVATE, "a", "[Ljavax/swing/Missing2;", null, null).visitEnd();
+        cw.visitField(Opcodes.ACC_PRIVATE, "b", "Ljavax/swing/JTable;", null, null).visitEnd();
+        method(cw, "run", "(I[[Ljavax/swing/Missing3;Ljavax/swing/JTable;)Ljavax/swing/Missing4;",
+                new String[] {"javax/swing/Missing5", "java/lang/Missing"}, mv -> {
+                    line(mv, 40);
+                    tryCatch(mv, "javax/swing/Missing6");
+                    tryCatch(mv, null);
+                    line(mv, 41);
+                    mv.visitInsn(Opcodes.NOP);
+                });
+        cw.visitEnd();
+
+        assertEquals(Arrays.asList(
+                unsupported("javax.swing.JTree", 0),
+                unsupported("javax.swing.Missing1", 0),
+                unsupported("javax.swing.Missing2", 0),
+                unsupported("javax.swing.Missing3", 40),
+                unsupported("javax.swing.Missing4", 40),
+                unsupported("javax.swing.Missing5", 40),
+                unsupported("javax.swing.Missing6", 40)), summary(scanWithSwing(cw.toByteArray())));
+        Object superclass = scanWithSwing(cw.toByteArray()).get(0);
+        assertEquals("(extends)", field(superclass, "sourceMethod"));
+        assertTrue(render(superclass, "renderInline"), render(superclass, "renderInline").endsWith(" at Main.java"));
+    }
+
+    /// A class missing from a method's signature and used in its body is one
+    /// problem; the report is the one that has a line.
+    @Test
+    public void aDeclarationIsNotReportedBesideTheInstructionThatUsesIt() throws Exception {
+        ClassWriter cw = appClass("java/lang/Object");
+        cw.visitField(Opcodes.ACC_PRIVATE, "tree", "Ljavax/swing/JTree;", null, null).visitEnd();
+        method(cw, "run", "(Ljavax/swing/JTree;)V", null, mv -> {
+            line(mv, 50);
+            mv.visitInsn(Opcodes.NOP);
+            line(mv, 51);
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTree", "expandRow", "(I)V");
+        });
+        cw.visitEnd();
+
+        assertEquals(Collections.singletonList(unsupported("javax.swing.JTree", 51)),
+                summary(scanWithSwing(cw.toByteArray())));
+    }
+
+    @Test
+    public void typeInstructionsAndClassConstantsAreScanned() throws Exception {
+        List<?> violations = scanWithSwing(appWith(mv -> {
+            line(mv, 60);
+            ldc(mv, Type.getObjectType("javax/swing/Missing1"));
+            line(mv, 61);
+            ldc(mv, Type.getType("[Ljavax/swing/Missing2;"));
+            line(mv, 62);
+            typeInsn(mv, Opcodes.INSTANCEOF, "[Ljavax/swing/Missing3;");
+            line(mv, 63);
+            typeInsn(mv, Opcodes.CHECKCAST, "javax/swing/Missing4");
+            line(mv, 64);
+            typeInsn(mv, Opcodes.ANEWARRAY, "javax/swing/Missing5");
+            line(mv, 65);
+            multiArray(mv, "[[Ljavax/swing/Missing6;");
+            line(mv, 66);
+            ldc(mv, "javax/swing/NotAReference");
+            ldc(mv, Type.getType("[I"));
+            multiArray(mv, "[[I");
+        }));
+
+        assertEquals(Arrays.asList(
+                unsupported("javax.swing.Missing1", 60),
+                unsupported("javax.swing.Missing2", 61),
+                unsupported("javax.swing.Missing3", 62),
+                unsupported("javax.swing.Missing4", 63),
+                unsupported("javax.swing.Missing5", 64),
+                unsupported("javax.swing.Missing6", 65)), summary(violations));
+    }
+
+    /// Every lambda and method reference is an `invokedynamic`: no method
+    /// instruction names the listener interface or the referenced method.
+    @Test
+    public void lambdasAndMethodReferencesAreScanned() throws Exception {
+        final Handle body = new Handle(Opcodes.H_INVOKESTATIC, "com/x/Main", "lambda$run$0", "()V", false);
+        List<?> violations = scanWithSwing(appWith(mv -> {
+            // A listener interface the layer lacks.
+            line(mv, 70);
+            lambda(mv, "mouseClicked", "()Ljava/awt/event/MouseListener;",
+                    Type.getMethodType("()V"), body, Type.getMethodType("()V"));
+            // An interface it has, implemented with an event class it lacks.
+            line(mv, 71);
+            lambda(mv, "actionPerformed", "()Ljava/awt/event/ActionListener;",
+                    Type.getMethodType("(Ljava/awt/event/KeyEvent;)V"), body, Type.getMethodType("()V"));
+            // An interface it has, without the method the lambda implements.
+            line(mv, 72);
+            lambda(mv, "actionCancelled", "()Ljava/awt/event/ActionListener;",
+                    Type.getMethodType("(Ljava/awt/event/ActionEvent;)V"), body, Type.getMethodType("()V"));
+            // table::setAutoCreateRowSorter
+            line(mv, 73);
+            lambda(mv, "run", "(Ljavax/swing/JTable;)Ljava/lang/Runnable;",
+                    Type.getMethodType("()V"),
+                    new Handle(Opcodes.H_INVOKEVIRTUAL, "javax/swing/JTable", "setAutoCreateRowSorter", "(Z)V", false),
+                    Type.getMethodType("()V"));
+            // JTree::new
+            line(mv, 74);
+            lambda(mv, "run", "()Ljava/lang/Runnable;", Type.getMethodType("()V"),
+                    new Handle(Opcodes.H_NEWINVOKESPECIAL, "javax/swing/JTree", "<init>", "()V", false),
+                    Type.getMethodType("()V"));
+            // A field read through a handle, and a handle loaded as a constant.
+            line(mv, 75);
+            ldc(mv, new Handle(Opcodes.H_GETSTATIC, "javax/swing/JTable", "AUTO_RESIZE_LAST_COLUMN", "I",
+                    false));
+            line(mv, 76);
+            ldc(mv, Type.getMethodType("(Ljavax/swing/JList;)V"));
+        }));
+
+        assertEquals(Arrays.asList(
+                unsupported("java.awt.event.MouseListener", 70),
+                unsupported("java.awt.event.KeyEvent", 71),
+                unsupported("java.awt.event.ActionListener.actionCancelled(java.awt.event.ActionEvent)", 72),
+                unsupported("javax.swing.JTable.setAutoCreateRowSorter(boolean)", 73),
+                unsupported("javax.swing.JTree", 74),
+                unsupported("javax.swing.JTable.AUTO_RESIZE_LAST_COLUMN", 75),
+                unsupported("javax.swing.JList", 76)), summary(violations));
+    }
+
+    /// The same application with no layer switched on: only method, field
+    /// and type instructions are examined, each failing one is reported, in
+    /// the form the check has always used -- and it says how to get the layer.
+    @Test
+    public void aProjectWithNoLayerIsCheckedAsBefore() throws Exception {
+        ClassWriter cw = appClass("javax/swing/JTree", "javax/swing/Missing1");
+        cw.visitField(Opcodes.ACC_PRIVATE, "a", "Ljavax/swing/Missing2;", null, null).visitEnd();
+        method(cw, "run", "(Ljavax/swing/Missing3;)V", new String[] {"javax/swing/Missing4"}, mv -> {
+            line(mv, 80);
+            tryCatch(mv, "javax/swing/Missing5");
+            mv.visitTypeInsn(Opcodes.NEW, "javax/swing/JTable");
+            call(mv, Opcodes.INVOKESPECIAL, "javax/swing/JTable", "<init>", "()V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "setRowHeight", "(I)V");
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "setRowHeight", "(I)V");
+            line(mv, 81);
+            getStatic(mv, "java/awt/Color", "RED", "Ljava/awt/Color;");
+            ldc(mv, Type.getObjectType("javax/swing/Missing6"));
+            typeInsn(mv, Opcodes.CHECKCAST, "[Ljavax/swing/Missing7;");
+            multiArray(mv, "[[Ljavax/swing/Missing8;");
+            lambda(mv, "actionPerformed", "()Ljava/awt/event/ActionListener;",
+                    Type.getMethodType("(Ljava/awt/event/ActionEvent;)V"),
+                    new Handle(Opcodes.H_INVOKEVIRTUAL, "javax/swing/JTable", "repaint", "()V", false),
+                    Type.getMethodType("(Ljava/awt/event/ActionEvent;)V"));
+            call(mv, Opcodes.INVOKESTATIC, "javafx/application/Platform", "exit", "()V");
+            call(mv, Opcodes.INVOKESTATIC, "com/vendor/Sdk", "start", "()V");
+        });
+        cw.visitEnd();
+
+        List<?> violations = scan(cw.toByteArray(), Collections.<Relocation>emptyList(),
+                Collections.<File>emptyList());
+        assertEquals(Arrays.asList(
+                "javax/swing/JTable (type) @80",
+                "javax/swing/JTable#<init>()V @80",
+                "javax/swing/JTable#setRowHeight(I)V @80",
+                "javax/swing/JTable#setRowHeight(I)V @80",
+                "java/awt/Color#RED:Ljava/awt/Color; @81",
+                // What the lambda and the method reference name only in
+                // their bootstrap arguments.
+                "java/awt/event/ActionEvent (type) @81",
+                "javax/swing/JTable#repaint()V @81",
+                "java/awt/event/ActionEvent (type) @81",
+                "javafx/application/Platform#exit()V @81",
+                "com/vendor/Sdk#start()V @81"), summary(violations));
+        for (int i = 0; i < 8; i++) {
+            assertEquals(CompatLayers.enableHint(CompatLayers.SWING), field(violations.get(i), "suggestion"));
+        }
+        assertTrue(CompatLayers.enableHint(CompatLayers.SWING).contains("src/main/desktop"));
+        assertEquals(CompatLayers.enableHint(CompatLayers.JAVAFX), field(violations.get(8), "suggestion"));
+        assertNull(field(violations.get(9), "suggestion"));
+        // A class compiled without debug information says nothing new.
+        Object bare = newViolation("a/B", "m()V", "c/D#e()V", null, "a/B.class");
+        assertEquals("a/B#m()V -> c/D#e()V (a/B.class)", render(bare, "renderInline"));
+        assertEquals("Source class: a/B\nSource method: m()V\nSource bytecode file: a/B.class\n"
+                + "Forbidden reference: c/D#e()V", render(bare, "render"));
+    }
+
+    private static Object newViolation(String sourceClass, String sourceMethod, String referencedMember,
+                                       String suggestion, String sourcePath) throws Exception {
+        java.lang.reflect.Constructor<?> ctor = Class.forName("com.codename1.maven.BytecodeCompliance$Violation")
+                .getDeclaredConstructor(String.class, String.class, String.class, String.class, String.class);
+        ctor.setAccessible(true);
+        return ctor.newInstance(sourceClass, sourceMethod, referencedMember, suggestion, sourcePath);
+    }
+
+    /// With a layer active, a reference outside its packages is still checked
+    /// only where it always was, and a raw `java/awt/` name -- a class the
+    /// relocation never saw -- gets no advice to enable what is enabled.
+    @Test
+    public void anActiveLayerWidensTheScanOnlyForItsOwnPackages() throws Exception {
+        ClassWriter cw = appClass("com/vendor/Base", "com/vendor/Listener");
+        cw.visitField(Opcodes.ACC_PRIVATE, "a", "Lcom/vendor/Thing;", null, null).visitEnd();
+        method(cw, "run", "(Lcom/vendor/Thing;)V", new String[] {"com/vendor/Failure"}, mv -> {
+            line(mv, 90);
+            ldc(mv, Type.getObjectType("com/vendor/Thing"));
+            typeInsn(mv, Opcodes.CHECKCAST, "[Lcom/vendor/Thing;");
+            multiArray(mv, "[[Lcom/vendor/Thing;");
+            lambda(mv, "run", "()Lcom/vendor/Listener;", Type.getMethodType("()V"),
+                    new Handle(Opcodes.H_INVOKESTATIC, "com/vendor/Sdk", "start", "()V", false),
+                    Type.getMethodType("()V"));
+            call(mv, Opcodes.INVOKESTATIC, "com/vendor/Sdk", "start", "()V");
+            call(mv, Opcodes.INVOKESTATIC, "com/vendor/Sdk", "start", "()V");
+        });
+        cw.visitEnd();
+        // Three: the two calls, and the method reference, which reaches the
+        // same method through a handle and through no instruction.
+        assertEquals(Arrays.asList("com/vendor/Sdk#start()V @90", "com/vendor/Sdk#start()V @90",
+                        "com/vendor/Sdk#start()V @90"),
+                summary(scanWithSwing(cw.toByteArray())));
+
+        List<?> raw = scan(appWith(mv -> mv.visitTypeInsn(Opcodes.NEW, "java/awt/Color")),
+                Collections.singletonList(CompatLayers.SWING), Collections.singletonList(swingJar()));
+        assertEquals(Collections.singletonList("java/awt/Color (type) @0"), summary(raw));
+        assertNull(field(raw.get(0), "suggestion"));
+    }
+
+    /// The Swing jar is authored under the names it ships with, so indexing it
+    /// "under its relocated names too" must not produce a second entry -- and
+    /// the one entry has to be the relocated reading, whose members name the
+    /// JDK classes the device has.
+    @Test
+    public void aRuntimeAuthoredUnderItsFinalNamesIsIndexedOnce() throws Exception {
+        BytecodeCompliance check = new BytecodeCompliance(TestProjectHost.empty());
+        Map<String, ?> swing = buildClassIndex(check, Collections.singletonList(swingJar()));
+        assertEquals(4, swing.size());
+        Set<?> methods = (Set<?>) field(swing.get(SWING + "javax/swing/JTable"), "methods");
+        assertTrue(methods.toString(), methods.contains("setFile(Lcom/codename1/util/regex/Pattern;)V"));
+        assertFalse(methods.toString(), methods.contains("setFile(Ljava/util/regex/Pattern;)V"));
+
+        // A runtime authored under the API's own names is indexed under both.
+        File fx = CompatRemapperTest.jar(new File(tmp.getRoot(), "codenameone-javafx-compat-1.jar"),
+                "javafx/stage/Stage.class", apiClass("javafx/stage/Stage", false, "java/lang/Object", null),
+                "com/codename1/fxcompat/runtime/FxApp.class",
+                apiClass("com/codename1/fxcompat/runtime/FxApp", false, "java/lang/Object", null));
+        Map<String, ?> javafx = buildClassIndex(check, Collections.singletonList(fx));
+        assertEquals(javafx.keySet().toString(), 4, javafx.size());
+        assertTrue(javafx.containsKey("javafx/stage/Stage"));
+        assertTrue(javafx.containsKey("com/codename1/fxcompat/javafx/stage/Stage"));
+        assertTrue(javafx.containsKey("com/codename1/fxcompat/rt/FxApp"));
+    }
+
+    /// The whole check, as a build runs it: the active layers come from the
+    /// project's dependencies, and the failure names the API and the line.
+    @Test
+    public void theBuildFailsNamingTheUnsupportedApi() throws Exception {
+        File classes = tmp.newFolder("classes");
+        assertTrue(new File(classes, "com/x").mkdirs());
+        byte[] app = appWith(mv -> {
+            line(mv, 12);
+            call(mv, Opcodes.INVOKEVIRTUAL, "javax/swing/JTable", "setAutoCreateRowSorter", "(Z)V");
+        });
+        Files.write(new File(classes, "com/x/Main.class").toPath(),
+                new ClassRelocator(CompatLayers.SWING).remap(app));
+        File runtime = CompatRemapperTest.jar(new File(tmp.getRoot(), "java-runtime-1.jar"),
+                "java/lang/Object.class", apiClass("java/lang/Object", false, null, null, "<init>", "()V"));
+        File core = CompatRemapperTest.jar(new File(tmp.getRoot(), "codenameone-core-1.jar"),
+                "com/codename1/ui/CN.class", apiClass("com/codename1/ui/CN", false, "java/lang/Object", null));
+        TestProjectHost host = TestProjectHost.empty();
+        host.buildDir = tmp.newFolder("build");
+        host.outputDir = classes;
+        host.artifacts.add(new BuildArtifact("com.codenameone", "java-runtime", "1", null, "jar", "provided", runtime,
+                null));
+        host.artifacts.add(new BuildArtifact("com.codenameone", "codenameone-core", "1", null, "jar", "provided", core,
+                null));
+        host.artifacts.add(new BuildArtifact("com.codenameone", "codenameone-swing-compat", "1", null, "jar",
+                "compile", swingJar(), null));
+
+        try {
+            new BytecodeCompliance(host).execute();
+            fail("An unsupported Swing method must fail the build");
+        } catch (BuildFailureException expected) {
+            String message = expected.getMessage();
+            assertTrue(message, message.contains("javax.swing.JTable.setAutoCreateRowSorter(boolean)" + NOT_SUPPORTED));
+            assertTrue(message, message.contains("at Main.java:12"));
+        }
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatLibrariesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatLibrariesTest.java
new file mode 100644
index 00000000000..38e2b26a698
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatLibrariesTest.java
@@ -0,0 +1,551 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassReader;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// A desktop application's dependency jar that is itself written against
+/// Swing: it has to be relocated with the application, and what it uses
+/// beyond the device has to be reported as the library's.
+public class CompatLibrariesTest {
+
+    private static final String MAIN = "package com.acme.swingapp;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) { new org.fancy.FancyPanel().add(new javax.swing.JLabel()); }\n"
+            + "}\n";
+
+    private static final String PANEL = "package org.fancy;\n"
+            + "public class FancyPanel extends javax.swing.JPanel {\n"
+            + "    public String title() { return \"fancy panel\".replaceAll(\" \", \"-\"); }\n"
+            + "}\n";
+
+    /// As [#PANEL], and asking for the JVM's management beans: nothing a
+    /// device has.
+    private static final String BAD_PANEL = "package org.fancy;\n"
+            + "public class FancyPanel extends javax.swing.JPanel {\n"
+            + "    public Object launch() { return java.lang.management.ManagementFactory.getRuntimeMXBean(); }\n"
+            + "}\n";
+
+    /// As [#PANEL], with the corners a real Swing library has: it can save
+    /// itself through long-term persistence, keeps a weak cache, and asks
+    /// whether a component is one of AWT's heavyweight widgets.
+    private static final String PERSISTENT_PANEL = "package org.fancy;\n"
+            + "public class FancyPanel extends javax.swing.JPanel\n"
+            + "        implements java.io.Externalizable, java.beans.ExceptionListener {\n"
+            + "    private final java.util.WeakHashMap<Object, String> cache = new java.util.WeakHashMap<Object, String>();\n"
+            + "    public boolean heavy(java.awt.Component c) {\n"
+            + "        return c instanceof java.awt.Label || c instanceof java.awt.TextComponent\n"
+            + "                || c instanceof java.awt.ScrollPane && ((java.awt.ScrollPane) c).getComponent(0) != null;\n"
+            + "    }\n"
+            + "    public void save(java.io.OutputStream out) {\n"
+            + "        java.beans.XMLEncoder e = new java.beans.XMLEncoder(out);\n"
+            + "        e.setExceptionListener(this);\n"
+            + "        e.writeObject(this);\n"
+            + "        e.close();\n"
+            + "    }\n"
+            + "    public boolean designing() throws Exception {\n"
+            + "        java.beans.Introspector.getBeanInfo(FancyPanel.class, java.beans.Introspector.IGNORE_ALL_BEANINFO)\n"
+            + "                .getBeanDescriptor().setValue(\"k\", \"v\");\n"
+            + "        return java.beans.Beans.isDesignTime()\n"
+            + "                || getClass().getClassLoader().loadClass(\"org.fancy.FancyPanel\") == null;\n"
+            + "    }\n"
+            + "    public void exceptionThrown(Exception x) { cache.put(x, \"x\"); }\n"
+            + "    public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException { out.writeInt(1); }\n"
+            + "    public void readExternal(java.io.ObjectInput in) throws java.io.IOException { in.readInt(); }\n"
+            + "}\n";
+
+    /// An application that reaches for long-term persistence itself.
+    private static final String PERSISTENT_MAIN = "package com.acme.swingapp;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) {\n"
+            + "        new java.beans.XMLEncoder(new java.io.ByteArrayOutputStream()).close();\n"
+            + "        System.out.println(new javax.swing.JLabel() instanceof java.awt.Component);\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String PLAIN = "package org.plain;\n"
+            + "public class Words {\n"
+            + "    public static int count(String s) { return s.length(); }\n"
+            + "}\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+    private final List<String> logged = new ArrayList<String>();
+
+    private final com.codename1.build.Log log = new com.codename1.build.Log() {
+        public void debug(CharSequence c) { }
+        public void debug(CharSequence c, Throwable e) { }
+        public void debug(Throwable e) { }
+        public void info(CharSequence c) { logged.add("info: " + c); }
+        public void info(CharSequence c, Throwable e) { }
+        public void info(Throwable e) { }
+        public void warn(CharSequence c) { logged.add("warn: " + c); }
+        public void warn(CharSequence c, Throwable e) { }
+        public void warn(Throwable e) { }
+        public void error(CharSequence c) { }
+        public void error(CharSequence c, Throwable e) { }
+        public void error(Throwable e) { }
+        public boolean isDebugEnabled() { return false; }
+        public boolean isInfoEnabled() { return true; }
+        public boolean isWarnEnabled() { return true; }
+        public boolean isErrorEnabled() { return true; }
+    };
+
+    private List<File> runtimes() throws Exception {
+        if (scratch == null) {
+            scratch = tmp.newFolder("jars");
+        }
+        return new ArrayList<File>(Arrays.asList(RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch)));
+    }
+
+    /// Compiles one class against the layers and packs it as `name`, with a
+    /// manifest and a resource beside it as a published jar has.
+    private File library(String name, String path, String source) throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, path, source);
+        String cls = path.replace(".java", ".class");
+        return CompatRemapperTest.jar(new File(tmp.newFolder(), name),
+                "META-INF/MANIFEST.MF", "Manifest-Version: 1.0\n".getBytes("UTF-8"),
+                cls, Files.readAllBytes(new File(classes, cls).toPath()),
+                cls.substring(0, cls.lastIndexOf('/')) + "/notes.properties", "a=b\n".getBytes("UTF-8"));
+    }
+
+    private File application(File... libraries) throws Exception {
+        return application(MAIN, libraries);
+    }
+
+    private File application(String main, File... libraries) throws Exception {
+        List<File> cp = runtimes();
+        cp.addAll(Arrays.asList(libraries));
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(cp, tmp.newFolder(), classes, "com/acme/swingapp/Main.java", main);
+        return classes;
+    }
+
+    private CompatRemapper remapper(File classes, List<File> shipped, File... onClasspath) throws Exception {
+        List<File> cp = runtimes();
+        cp.addAll(Arrays.asList(onClasspath));
+        File desktop = tmp.newFolder();
+        return new CompatRemapper(classes, cp, null, log).withDesktopSourceDirectory(desktop)
+                .withApplicationLibraries(shipped);
+    }
+
+    private static String superName(File cls) throws Exception {
+        return new ClassReader(Files.readAllBytes(cls.toPath())).getSuperName();
+    }
+
+    private TestProjectHost host(File classes, File... compileJars) throws Exception {
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        for (File jar : compileJars) {
+            host.artifacts.add(new BuildArtifact("org.example", jar.getName().replace(".jar", ""), "1", null, "jar",
+                    "compile", jar, null));
+        }
+        return host;
+    }
+
+    @Test
+    public void aLibraryWrittenAgainstSwingIsRelocatedWithTheApplication() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", PANEL);
+        File plain = library("plain-lib-1.0.jar", "org/plain/Words.java", PLAIN);
+        File classes = application(fancy, plain);
+        assertTrue(remapper(classes, Arrays.asList(fancy, plain), fancy, plain).run());
+
+        File panel = new File(classes, "org/fancy/FancyPanel.class");
+        assertEquals("com/codename1/desktopcompat/javax/swing/JPanel", superName(panel));
+        // Under the one name a device can find it by: a bundle has no directories.
+        assertTrue("A library's resources come with it", new File(classes, "org__fancy__notes.properties").isFile());
+        assertFalse(new File(classes, "org/fancy/notes.properties").exists());
+        assertFalse("The jar's manifest is not the application's",
+                new File(classes, "META-INF/MANIFEST.MF").exists());
+        // What moves is redirected in the library as in the application.
+        assertTrue(CompatFixtures.members(Files.readAllBytes(panel.toPath()))
+                .contains("com/codename1/util/regex/StringRegex.replaceAll"));
+        assertFalse("A library the application never reaches ships nothing",
+                new File(classes, "org/plain/Words.class").exists());
+        assertFalse(new File(classes, "org/plain/notes.properties").exists());
+        assertFalse(new File(classes, "org__plain__notes.properties").exists());
+        assertTrue(logged.toString(), logged.toString().contains(
+                "info: Bundling fancy-lib-1.0.jar with the application (1 classes, 1 KB): it is written against"));
+        assertTrue(logged.toString(), logged.toString().contains(
+                "info: plain-lib-1.0.jar is not used by the application's classes and is left out of it"));
+
+        // Both are the step's to ship or leave out, so neither is merged
+        // whole into the application afterwards.
+        assertEquals(new java.util.HashSet<String>(Arrays.asList("fancy-lib-1.0.jar", "plain-lib-1.0.jar")),
+                CompatLibraries.bundledJarNames(Collections.singletonList(classes)));
+        CompatLibraries.Library left = CompatLibraries.libraries(classes).get("plain-lib-1.0.jar");
+        assertEquals(DependencyClassifier.Kind.PURE_JAVA, left.kind());
+        assertEquals(1, left.classCount());
+        assertEquals(0, left.shippedCount());
+        assertEquals(DependencyClassifier.Kind.UI_LIBRARY, CompatLibraries.libraries(classes)
+                .get("fancy-lib-1.0.jar").kind());
+        assertEquals(Collections.singletonMap("org/fancy/FancyPanel", "fancy-lib-1.0.jar"),
+                CompatLibraries.classOrigins(classes));
+        // The relocated copy is the one the check reads, although the jar is
+        // still among the project's dependencies.
+        new BytecodeCompliance(host(classes, fancy, plain)).execute();
+
+        // The record is found in a jar built from the classes as well: that
+        // is where the module assembling the application looks for it.
+        File built = CompatRemapperTest.jar(new File(tmp.newFolder(), "common-1.0.jar"), CompatLibraries.RECORD,
+                Files.readAllBytes(new File(classes, CompatLibraries.RECORD).toPath()));
+        assertEquals(new java.util.HashSet<String>(Arrays.asList("fancy-lib-1.0.jar", "plain-lib-1.0.jar")),
+                CompatLibraries.bundledJarNames(Arrays.asList(built, plain, new File("no-such.jar"))));
+    }
+
+    /// An application that counts words, through a library of plain Java.
+    private static final String WORDY_MAIN = "package com.acme.swingapp;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) {\n"
+            + "        new javax.swing.JLabel(String.valueOf(org.plain.Words.count(\"a b\")));\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String WORDS = "package org.plain;\n"
+            + "public class Words {\n"
+            + "    public static int count(String s) { return Splitter.split(s).length; }\n"
+            + "}\n";
+
+    private static final String SPLITTER = "package org.plain;\n"
+            + "class Splitter {\n"
+            + "    static String[] split(String s) { return (s + \" \" + s).split(\" \"); }\n"
+            + "}\n";
+
+    /// The part of the library the application has no use for, and which no
+    /// device could run.
+    private static final String SHELL = "package org.plain;\n"
+            + "public class Shell {\n"
+            + "    public Object run() { return java.lang.management.ManagementFactory.getRuntimeMXBean(); }\n"
+            + "}\n";
+
+    private File plainLibrary(Object... extra) throws Exception {
+        File out = tmp.newFolder();
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), out, "org/plain/Words.java", WORDS,
+                "org/plain/Splitter.java", SPLITTER, "org/plain/Shell.java", SHELL);
+        List<Object> entries = new ArrayList<Object>();
+        for (String name : new String[] {"Words", "Splitter", "Shell"}) {
+            entries.add("org/plain/" + name + ".class");
+            entries.add(Files.readAllBytes(new File(out, "org/plain/" + name + ".class").toPath()));
+        }
+        entries.add("org/plain/words.properties");
+        entries.add("a=b\n".getBytes("UTF-8"));
+        entries.add("module-info.class");
+        entries.add(new byte[] {1});
+        entries.addAll(Arrays.asList(extra));
+        return CompatRemapperTest.jar(new File(tmp.newFolder(), "plain-lib-1.0.jar"), entries.toArray());
+    }
+
+    @Test
+    public void ofAPureJavaLibraryOnlyWhatTheApplicationReachesShips() throws Exception {
+        File plain = plainLibrary();
+        File classes = application(WORDY_MAIN, plain);
+        assertTrue(remapper(classes, Collections.singletonList(plain), plain).run());
+
+        assertTrue(new File(classes, "org/plain/Words.class").isFile());
+        assertTrue("What a reached class uses is reached", new File(classes, "org/plain/Splitter.class").isFile());
+        assertFalse("Nothing leads to it", new File(classes, "org/plain/Shell.class").exists());
+        assertTrue(new File(classes, "org__plain__words.properties").isFile());
+        assertFalse(new File(classes, "module-info.class").exists());
+        // A pure-Java library is relocated for the JDK members that move.
+        assertTrue(CompatFixtures.members(Files.readAllBytes(new File(classes, "org/plain/Splitter.class").toPath()))
+                .contains("com/codename1/util/regex/StringRegex.split"));
+        assertTrue(logged.toString(), logged.toString().contains(
+                "info: Bundling 2 of the 3 classes of plain-lib-1.0.jar with the application"));
+        CompatLibraries.Library lib = CompatLibraries.libraries(classes).get("plain-lib-1.0.jar");
+        assertEquals(DependencyClassifier.Kind.PURE_JAVA, lib.kind());
+        assertEquals(3, lib.classCount());
+        assertEquals(2, lib.shippedCount());
+        assertEquals("org.plain", lib.mainPackage());
+        assertEquals("plain-lib-1.0.jar", CompatLibraries.classOrigins(classes).get("org/plain/Words"));
+        // The class that starts a process did not ship, so it is no finding.
+        new BytecodeCompliance(host(classes, plain)).execute();
+    }
+
+    @Test
+    public void aLibraryNoLongerDeclaredTakesItsClassesWithIt() throws Exception {
+        File plain = plainLibrary();
+        File classes = application(WORDY_MAIN, plain);
+        assertTrue(remapper(classes, Collections.singletonList(plain), plain).run());
+        assertTrue(new File(classes, "org/plain/Words.class").isFile());
+
+        assertTrue(remapper(classes, Collections.<File>emptyList(), plain).run());
+        assertFalse(new File(classes, "org/plain/Words.class").exists());
+        assertFalse(new File(classes, "org/plain/words.properties").exists());
+        assertTrue(CompatLibraries.bundledJarNames(Collections.singletonList(classes)).isEmpty());
+    }
+
+    /// The sources of a library copied into the project where its jar used
+    /// to be: the compiler has written the application's class to a path
+    /// the record still calls the library's.
+    @Test
+    public void aDroppedLibraryLeavesTheClassTheApplicationTookOver() throws Exception {
+        File plain = plainLibrary();
+        File classes = application(WORDY_MAIN, plain);
+        assertTrue(remapper(classes, Collections.singletonList(plain), plain).run());
+
+        String own = "package org.plain;\npublic class Words {\n"
+                + "    public static String mine() { return \"the application's\"; }\n}\n";
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, "org/plain/Words.java", own);
+        assertTrue(remapper(classes, Collections.<File>emptyList(), plain).run());
+        File words = new File(classes, "org/plain/Words.class");
+        assertTrue("the application's class went with the library", words.isFile());
+        assertTrue(CompatFixtures.members(Files.readAllBytes(words.toPath())).toString(),
+                new String(Files.readAllBytes(words.toPath()), "ISO-8859-1").contains("mine"));
+        // What the library alone had is still taken away.
+        assertFalse(new File(classes, "org/plain/words.properties").exists());
+    }
+
+    /// The same class taken over while the jar is still a dependency: the
+    /// library's copy must not be written back over it.
+    @Test
+    public void aKeptLibraryDoesNotOverwriteTheClassTheApplicationTookOver() throws Exception {
+        File plain = plainLibrary();
+        File classes = application(WORDY_MAIN, plain);
+        assertTrue(remapper(classes, Collections.singletonList(plain), plain).run());
+
+        String own = "package org.plain;\npublic class Words {\n"
+                + "    public static String mine() { return \"the application's\"; }\n}\n";
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, "org/plain/Words.java", own);
+        for (int run = 0; run < 2; run++) {
+            assertTrue(remapper(classes, Collections.singletonList(plain), plain).run());
+            assertTrue("run " + run, new String(Files.readAllBytes(new File(classes, "org/plain/Words.class")
+                    .toPath()), "ISO-8859-1").contains("mine"));
+            assertFalse("run " + run, CompatLibraries.classOrigins(classes).containsKey("org/plain/Words"));
+        }
+    }
+
+    @Test
+    public void nativeCodeIsNamedAndItsBinariesStayBehind() throws Exception {
+        File plain = plainLibrary("linux-x86-64/libwords.so", new byte[] {127, 'E', 'L', 'F'});
+        File classes = application(WORDY_MAIN, plain);
+        assertTrue(remapper(classes, Collections.singletonList(plain), plain).run());
+        assertFalse(new File(classes, "linux-x86-64/libwords.so").exists());
+        assertTrue(new File(classes, "org/plain/Words.class").isFile());
+        assertEquals("ships native libraries", CompatLibraries.libraries(classes).get("plain-lib-1.0.jar")
+                .nativeCode());
+        assertTrue(logged.toString(), logged.toString().contains("warn: plain-lib-1.0.jar ships native libraries"));
+    }
+
+    @Test
+    public void aSecondRunLeavesAnUnchangedLibraryAlone() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", PANEL);
+        File classes = application(fancy);
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy).run());
+        File panel = new File(classes, "org/fancy/FancyPanel.class");
+        byte[] relocated = Files.readAllBytes(panel.toPath());
+        assertTrue(panel.setLastModified(1000000L));
+        logged.clear();
+
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy).run());
+        assertEquals(1000000L, panel.lastModified());
+        assertTrue(Arrays.equals(relocated, Files.readAllBytes(panel.toPath())));
+        assertFalse(logged.toString(), logged.toString().contains("Bundling"));
+
+        // A new build of the library replaces the copy an earlier run made.
+        File newer = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", BAD_PANEL);
+        assertTrue(remapper(classes, Collections.singletonList(newer), newer).run());
+        assertTrue(logged.toString(), logged.toString().contains("Bundling fancy-lib-1.0.jar"));
+        assertTrue(CompatFixtures.members(Files.readAllBytes(panel.toPath())).toString(),
+                CompatFixtures.members(Files.readAllBytes(panel.toPath())).contains("java/lang/management/ManagementFactory.getRuntimeMXBean"));
+        assertEquals("com/codename1/desktopcompat/javax/swing/JPanel", superName(panel));
+    }
+
+    @Test
+    public void aProvidedLibraryIsNotBundled() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", PANEL);
+        File classes = application(fancy);
+        // On the classpath, and not among what the application ships.
+        assertTrue(remapper(classes, Collections.<File>emptyList(), fancy).run());
+        assertFalse(new File(classes, "org/fancy/FancyPanel.class").exists());
+        assertFalse(new File(classes, CompatLibraries.RECORD).exists());
+        assertTrue(CompatLibraries.bundledJarNames(Collections.singletonList(classes)).isEmpty());
+    }
+
+    @Test
+    public void theApplicationsOwnClassWinsOverTheLibrarys() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", BAD_PANEL);
+        File classes = application(fancy);
+        // The application ships a patched copy of the library's class.
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, "org/fancy/FancyPanel.java", PANEL);
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy).run());
+        assertFalse(CompatFixtures.members(Files.readAllBytes(new File(classes, "org/fancy/FancyPanel.class")
+                .toPath())).contains("java/lang/management/ManagementFactory.getRuntimeMXBean"));
+        assertTrue(CompatLibraries.classOrigins(classes).isEmpty());
+        new BytecodeCompliance(host(classes, fancy)).execute();
+    }
+
+    /// MigLayout is the library this stands for: every class of it loads,
+    /// and the paths that save a layout as XML are never taken on a device.
+    @Test
+    public void aLibraryLinksAgainstApiNoDeviceCanServe() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", PERSISTENT_PANEL);
+        File classes = application(fancy);
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy).run());
+        byte[] panel = Files.readAllBytes(new File(classes, "org/fancy/FancyPanel.class").toPath());
+        assertTrue(CompatFixtures.members(panel).toString(),
+                CompatFixtures.members(panel).contains("com/codename1/impl/compat/Resources.loadClass"));
+        assertTrue(CompatFixtures.members(panel).toString(),
+                CompatFixtures.members(panel).contains("java/io/ObjectOutput.writeInt"));
+        // No finding: the library names link-only classes, and it may.
+        new BytecodeCompliance(host(classes, fancy)).execute();
+    }
+
+    /// The same classes are no API of the layer as far as the developer's
+    /// own code goes: there they would be calls that compile and then fail.
+    @Test
+    public void theApplicationItselfMayNotUseLinkOnlyApi() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", PERSISTENT_PANEL);
+        File classes = application(PERSISTENT_MAIN, fancy);
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy).run());
+        try {
+            new BytecodeCompliance(host(classes, fancy)).execute();
+            fail("java.beans.XMLEncoder cannot work on a device");
+        } catch (Exception e) {
+            String message = e.getMessage();
+            assertTrue(message, message.contains(
+                    "java.beans.XMLEncoder is not supported by the Codename One Swing compatibility layer"));
+            assertFalse("The library's own use is not a finding: " + message, message.contains("fancy-lib-1.0.jar"));
+            assertFalse(message, message.contains("java.awt.Component is not supported"));
+        }
+    }
+
+    @Test
+    public void whatALibraryUsesBeyondTheDeviceIsReportedAsTheLibrarys() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", BAD_PANEL);
+        File classes = application(fancy);
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy).run());
+        try {
+            new BytecodeCompliance(host(classes, fancy)).execute();
+            fail("ManagementFactory is not on a device");
+        } catch (Exception e) {
+            String message = e.getMessage();
+            assertTrue(message, message.contains("java/lang/management/ManagementFactory"));
+            assertTrue(message, message.contains("org/fancy/FancyPanel") || message.contains("org.fancy.FancyPanel"));
+            assertTrue(message, message.contains(
+                    "in the library fancy-lib-1.0.jar, which is bundled and relocated with the application"));
+        }
+    }
+
+    @Test
+    public void aLargeLibraryIsWarnedAbout() throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", PANEL);
+        File big = new File(tmp.newFolder(), "big-lib-2.jar");
+        CompatRemapperTest.jar(big, "org/fancy/FancyPanel.class", readEntry(fancy, "org/fancy/FancyPanel.class"),
+                "org/fancy/blob.bin", noise((int) CompatLibraries.LARGE + 4096));
+        File classes = application(fancy);
+        assertTrue(remapper(classes, Collections.singletonList(big), big).run());
+        assertTrue(logged.toString(), logged.toString().contains("warn: Bundling big-lib-2.jar"));
+        assertTrue(logged.toString(), logged.toString().contains("large library"));
+    }
+
+    private static byte[] readEntry(File jar, String name) throws Exception {
+        java.util.zip.ZipFile zip = new java.util.zip.ZipFile(jar);
+        try {
+            java.io.InputStream in = zip.getInputStream(zip.getEntry(name));
+            java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
+            int b = in.read();
+            while (b >= 0) {
+                out.write(b);
+                b = in.read();
+            }
+            return out.toByteArray();
+        } finally {
+            zip.close();
+        }
+    }
+
+    /// Bytes a zip cannot shrink, so the jar is as large as its entry.
+    private static byte[] noise(int length) {
+        byte[] out = new byte[length];
+        new java.util.Random(7).nextBytes(out);
+        return out;
+    }
+
+    /// An application that uses a library of each of two groups.
+    private static final String TWO_GROUPS_MAIN = "package com.acme.swingapp;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) {\n"
+            + "        new org.fancy.FancyPanel().add(new javax.swing.JLabel(\n"
+            + "                String.valueOf(org.plain.Words.count(\"a b\"))));\n"
+            + "    }\n"
+            + "}\n";
+
+    /// `org.fancy:common:1.0` and `org.plain:common:1.0` are both
+    /// `common-1.0.jar`. Both are the application's, and both ship.
+    @Test
+    public void twoLibrariesOfOneFileNameBothShip() throws Exception {
+        File fancy = library("common-1.0.jar", "org/fancy/FancyPanel.java", PANEL);
+        File plain = library("common-1.0.jar", "org/plain/Words.java", PLAIN);
+        File classes = application(TWO_GROUPS_MAIN, fancy, plain);
+        assertTrue(remapper(classes, Arrays.asList(fancy, plain), fancy, plain).run());
+
+        assertTrue(new File(classes, "org/fancy/FancyPanel.class").isFile());
+        assertTrue("The second jar of the name was left out", new File(classes, "org/plain/Words.class").isFile());
+        // Both are the step's, so neither is merged whole afterwards; one
+        // name stands for the two.
+        assertEquals(Collections.singleton("common-1.0.jar"),
+                CompatLibraries.bundledJarNames(Collections.singletonList(classes)));
+        assertEquals(new java.util.ArrayList<String>(Arrays.asList("common-1.0.jar", "common-1.0.jar/2")),
+                new java.util.ArrayList<String>(CompatLibraries.libraries(classes).keySet()));
+        java.util.Map<String, String> origins = CompatLibraries.classOrigins(classes);
+        assertEquals("common-1.0.jar", origins.get("org/fancy/FancyPanel"));
+        assertEquals("common-1.0.jar/2", origins.get("org/plain/Words"));
+        new BytecodeCompliance(host(classes, fancy, plain)).execute();
+
+        // The next build finds each under its own entry: nothing is
+        // unpacked again, and nothing is taken away.
+        byte[] record = Files.readAllBytes(new File(classes, CompatLibraries.RECORD).toPath());
+        logged.clear();
+        assertTrue(remapper(classes, Arrays.asList(fancy, plain), fancy, plain).run());
+        assertTrue(new File(classes, "org/fancy/FancyPanel.class").isFile());
+        assertTrue(new File(classes, "org/plain/Words.class").isFile());
+        assertArrayEquals(record, Files.readAllBytes(new File(classes, CompatLibraries.RECORD).toPath()));
+        assertFalse(logged.toString(), logged.toString().contains("Bundling"));
+
+        // And one of the two dropped takes only its own classes.
+        assertTrue(remapper(classes, Collections.singletonList(fancy), fancy, plain).run());
+        assertTrue(new File(classes, "org/fancy/FancyPanel.class").isFile());
+        assertFalse(new File(classes, "org/plain/Words.class").exists());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatRemapperTest.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatRemapperTest.java
new file mode 100644
index 00000000000..5c03161dac1
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatRemapperTest.java
@@ -0,0 +1,568 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The remap entry point for any set of compatibility layers: which layers a
+/// classpath switches on, that they are applied as one pass, and that a
+/// second run finds nothing left to do.
+public class CompatRemapperTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    static final com.codename1.build.Log LOG = new com.codename1.build.Log() {
+        public void debug(CharSequence c) { }
+        public void debug(CharSequence c, Throwable e) { }
+        public void debug(Throwable e) { }
+        public void info(CharSequence c) { }
+        public void info(CharSequence c, Throwable e) { }
+        public void info(Throwable e) { }
+        public void warn(CharSequence c) { }
+        public void warn(CharSequence c, Throwable e) { }
+        public void warn(Throwable e) { }
+        public void error(CharSequence c) { }
+        public void error(CharSequence c, Throwable e) { }
+        public void error(Throwable e) { }
+        public boolean isDebugEnabled() { return false; }
+        public boolean isInfoEnabled() { return false; }
+        public boolean isWarnEnabled() { return false; }
+        public boolean isErrorEnabled() { return false; }
+    };
+
+    static final String SWING = "com/codename1/desktopcompat/";
+    static final String FX = "com/codename1/fxcompat/";
+
+    /// A class with no members, as a runtime jar would hold it.
+    static byte[] emptyClass(String name, String superName) {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, superName, null);
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    static File jar(File file, Object... nameThenBytes) throws IOException {
+        ZipOutputStream z = new ZipOutputStream(new FileOutputStream(file));
+        try {
+            for (int i = 0; i < nameThenBytes.length; i += 2) {
+                z.putNextEntry(new ZipEntry((String) nameThenBytes[i]));
+                z.write((byte[]) nameThenBytes[i + 1]);
+                z.closeEntry();
+            }
+        } finally {
+            z.close();
+        }
+        return file;
+    }
+
+    /// An application class that touches every layer: it extends a Swing
+    /// frame, holds a JavaFX stage, has an `android:onClick` handler, opens a
+    /// `java.io.File`, which keeps its name, and a
+    /// `java.util.regex.Pattern`, which moves to the framework's.
+    private static byte[] appClass() {
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "com/x/Main", null, "javax/swing/JFrame", null);
+        FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, "stage", "Ljavafx/stage/Stage;", null, null);
+        fv.visitEnd();
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "tapped", "(Landroid/view/View;)V", null, null);
+        mv.visitCode();
+        mv.visitTypeInsn(Opcodes.NEW, "java/io/File");
+        mv.visitInsn(Opcodes.POP);
+        mv.visitTypeInsn(Opcodes.NEW, "java/util/regex/Pattern");
+        mv.visitInsn(Opcodes.POP);
+        mv.visitTypeInsn(Opcodes.NEW, "java/awt/Color");
+        mv.visitInsn(Opcodes.POP);
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    /// Every class name, descriptor and type instruction of `cls`.
+    private static List<String> refs(byte[] cls) {
+        final List<String> out = new ArrayList<String>();
+        new ClassReader(cls).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public void visit(int v, int a, String name, String sig, String sup, String[] itf) {
+                out.add(name);
+                out.add(sup);
+            }
+
+            @Override
+            public FieldVisitor visitField(int a, String n, String d, String s, Object value) {
+                out.add(d);
+                return null;
+            }
+
+            @Override
+            public MethodVisitor visitMethod(int a, String n, String d, String s, String[] e) {
+                out.add(d);
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visitTypeInsn(int op, String type) {
+                        out.add(type);
+                    }
+                };
+            }
+        }, 0);
+        return out;
+    }
+
+    private File swingJar() throws IOException {
+        // Authored under the names it ships with; one class uses a JDK class
+        // the device has under another name, which is redirected as it is
+        // extracted.
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, SWING + "javax/swing/JFileChooser", null, "java/lang/Object", null);
+        cw.visitField(Opcodes.ACC_PRIVATE, "selected", "Ljava/util/regex/Pattern;", null, null).visitEnd();
+        cw.visitEnd();
+        return jar(new File(tmp.getRoot(), "codenameone-swing-compat-1.jar"),
+                SWING + "javax/swing/JFrame.class", emptyClass(SWING + "javax/swing/JFrame", "java/lang/Object"),
+                SWING + "java/awt/Color.class", emptyClass(SWING + "java/awt/Color", "java/lang/Object"),
+                SWING + "javax/swing/JFileChooser.class", cw.toByteArray(),
+                SWING + "rt/SwingApp.class", emptyClass(SWING + "rt/SwingApp", "java/lang/Object"),
+                "cn1_swing_defaults.bin", new byte[] {4, 5, 6},
+                "META-INF/MANIFEST.MF", new byte[] {1});
+    }
+
+    private File javafxJar() throws IOException {
+        return jar(new File(tmp.getRoot(), "codenameone-javafx-compat-1.jar"),
+                "javafx/stage/Stage.class", emptyClass("javafx/stage/Stage", "java/lang/Object"),
+                FX + "runtime/FxApp.class", emptyClass(FX + "runtime/FxApp", "javafx/stage/Stage"));
+    }
+
+    private File androidJar() throws IOException {
+        return jar(new File(tmp.getRoot(), "codenameone-android-compat-1.jar"),
+                "android/view/View.class", emptyClass("android/view/View", "java/lang/Object"),
+                "com/codename1/androidcompat/runtime/AndroidApp.class",
+                emptyClass("com/codename1/androidcompat/runtime/AndroidApp", "java/lang/Object"));
+    }
+
+    private File classesWithApp(String folder) throws IOException {
+        File classes = tmp.newFolder(folder);
+        assertTrue(new File(classes, "com/x").mkdirs());
+        Files.write(new File(classes, "com/x/Main.class").toPath(), appClass());
+        return classes;
+    }
+
+    /// Every file under `dir`, by relative path, with its bytes.
+    private static Map<String, byte[]> snapshot(File dir) throws IOException {
+        Map<String, byte[]> out = new TreeMap<String, byte[]>();
+        snapshot(dir, dir, out);
+        return out;
+    }
+
+    private static void snapshot(File root, File dir, Map<String, byte[]> out) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                snapshot(root, f, out);
+            } else {
+                out.put(root.toURI().relativize(f.toURI()).getPath(), Files.readAllBytes(f.toPath()));
+            }
+        }
+    }
+
+    private static void assertSameTree(Map<String, byte[]> expected, Map<String, byte[]> actual) {
+        assertEquals(expected.keySet(), actual.keySet());
+        for (Map.Entry<String, byte[]> e : expected.entrySet()) {
+            assertArrayEquals(e.getKey(), e.getValue(), actual.get(e.getKey()));
+        }
+    }
+
+    @Test
+    public void theLayersAreRegisteredWithTheirOwnPackages() {
+        assertEquals(Arrays.asList(AndroidRemapper.RELOCATION, CompatLayers.SWING, CompatLayers.JAVAFX),
+                CompatLayers.ALL);
+        ClassRelocator every = CompatLayers.EVERY;
+        assertEquals(SWING + "java/awt/Color", every.map("java/awt/Color"));
+        assertEquals(SWING + "javax/swing/JTable", every.map("javax/swing/JTable"));
+        assertEquals(SWING + "java/beans/PropertyChangeListener", every.map("java/beans/PropertyChangeListener"));
+        assertEquals(SWING + "javax/accessibility/Accessible", every.map("javax/accessibility/Accessible"));
+        assertEquals(SWING + "javax/imageio/ImageIO", every.map("javax/imageio/ImageIO"));
+        assertEquals(SWING + "org/jdesktop/layout/GroupLayout", every.map("org/jdesktop/layout/GroupLayout"));
+        assertEquals(FX + "javafx/stage/Stage", every.map("javafx/stage/Stage"));
+        assertEquals(FX + "rt/FxApp", every.map(FX + "runtime/FxApp"));
+        assertEquals("com/codename1/util/regex/Pattern", every.map("java/util/regex/Pattern"));
+        // The device's class library has the rest of the JDK under its name.
+        assertEquals("java/io/File", every.map("java/io/File"));
+        // The names the Swing runtime is authored under are final already.
+        assertEquals(SWING + "javax/swing/JTable", every.map(SWING + "javax/swing/JTable"));
+        assertEquals(SWING + "rt/SwingApp", every.map(SWING + "rt/SwingApp"));
+        // And back, for build messages.
+        assertEquals("javax/swing/JTable", every.original(SWING + "javax/swing/JTable"));
+        assertEquals("javafx/stage/Stage", every.original(FX + "javafx/stage/Stage"));
+        assertEquals(SWING + "rt/SwingApp", every.original(SWING + "rt/SwingApp"));
+        assertSame(CompatLayers.SWING, CompatLayers.owning("javax/swing/JTable"));
+        assertSame(CompatLayers.JAVAFX, CompatLayers.owning("javafx/stage/Stage"));
+        assertEquals(null, CompatLayers.owning("java/util/List"));
+        assertEquals(null, CompatLayers.owning(SWING + "javax/swing/JTable"));
+    }
+
+    @Test
+    public void relocatesSwingReferencesOntoARuntimeAuthoredUnderItsFinalNames() throws Exception {
+        File classes = classesWithApp("classes");
+        List<File> classpath = Arrays.asList(swingJar(), new File(tmp.getRoot(), "other-1.jar"));
+
+        CompatRemapper remapper = new CompatRemapper(classes, classpath, null, LOG);
+        assertEquals(Collections.singletonList(CompatLayers.SWING), remapper.activeLayers());
+        assertTrue(remapper.run());
+
+        List<String> app = refs(Files.readAllBytes(new File(classes, "com/x/Main.class").toPath()));
+        assertTrue(app.toString(), app.contains(SWING + "javax/swing/JFrame"));
+        assertTrue(app.toString(), app.contains(SWING + "java/awt/Color"));
+        assertTrue(app.toString(), app.contains("com/codename1/util/regex/Pattern"));
+        assertTrue(app.toString(), app.contains("java/io/File"));
+        // Layers that are not active leave their names alone.
+        assertTrue(app.toString(), app.contains("Ljavafx/stage/Stage;"));
+        assertTrue(app.toString(), app.contains("(Landroid/view/View;)V"));
+
+        assertTrue(new File(classes, SWING + "javax/swing/JFrame.class").isFile());
+        assertTrue(new File(classes, SWING + "rt/SwingApp.class").isFile());
+        assertTrue(new File(classes, "cn1_swing_defaults.bin").isFile());
+        // Nothing of the JDK is extracted: the framework has what moved.
+        assertFalse(new File(classes, "com/codename1/util").exists());
+        assertFalse(new File(classes, "javax").exists());
+        assertFalse(new File(classes, "META-INF").exists());
+        // No Android step ran.
+        assertFalse(new File(classes, AndroidRemapper.ON_CLICK_DISPATCH + ".class").exists());
+        // The runtime's own use of a JDK class that moves is redirected.
+        List<String> chooser = refs(Files.readAllBytes(
+                new File(classes, SWING + "javax/swing/JFileChooser.class").toPath()));
+        assertTrue(chooser.toString(), chooser.contains("Lcom/codename1/util/regex/Pattern;"));
+    }
+
+    @Test
+    public void appliesAndroidSwingAndJavaFxAsOnePass() throws Exception {
+        File classes = classesWithApp("classes");
+        File onClick = tmp.newFile("onclick.txt");
+        Files.write(onClick.toPath(), "tapped\n".getBytes("UTF-8"));
+        List<File> classpath = Arrays.asList(androidJar(), swingJar(), javafxJar());
+
+        CompatRemapper remapper = new CompatRemapper(classes, classpath, onClick, LOG);
+        assertEquals(CompatLayers.ALL, remapper.activeLayers());
+        assertEquals(3, remapper.relocator().relocations().size());
+        assertTrue(remapper.run());
+
+        List<String> app = refs(Files.readAllBytes(new File(classes, "com/x/Main.class").toPath()));
+        assertTrue(app.toString(), app.contains(SWING + "javax/swing/JFrame"));
+        assertTrue(app.toString(), app.contains("L" + FX + "javafx/stage/Stage;"));
+        assertTrue(app.toString(), app.contains("(Lcom/codename1/androidcompat/android/view/View;)V"));
+        assertTrue(app.toString(), app.contains("com/codename1/util/regex/Pattern"));
+        assertTrue(app.toString(), app.contains("java/io/File"));
+
+        assertTrue(new File(classes, "com/codename1/androidcompat/android/view/View.class").isFile());
+        assertTrue(new File(classes, "com/codename1/androidcompat/rt/AndroidApp.class").isFile());
+        assertTrue(new File(classes, SWING + "javax/swing/JFrame.class").isFile());
+        assertTrue(new File(classes, FX + "javafx/stage/Stage.class").isFile());
+        assertTrue(new File(classes, FX + "rt/FxApp.class").isFile());
+        assertFalse(new File(classes, FX + "runtime").exists());
+        assertFalse(new File(classes, "javafx").exists());
+        assertFalse(new File(classes, "android").exists());
+        // Nothing of the JDK is extracted: the framework has what moved.
+        assertFalse(new File(classes, "com/codename1/util").exists());
+        // The JavaFX runtime's reference to its own API moved with it.
+        assertTrue(refs(Files.readAllBytes(new File(classes, FX + "rt/FxApp.class").toPath()))
+                .contains(FX + "javafx/stage/Stage"));
+        // The Android generators ran, over the composed relocation.
+        byte[] dispatch = Files.readAllBytes(new File(classes, AndroidRemapper.ON_CLICK_DISPATCH + ".class").toPath());
+        final boolean[] callsHandler = new boolean[1];
+        new ClassReader(dispatch).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public MethodVisitor visitMethod(int a, String n, String d, String s, String[] e) {
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visitMethodInsn(int op, String owner, String name, String desc, boolean itf) {
+                        callsHandler[0] |= owner.equals("com/x/Main") && name.equals("tapped");
+                    }
+                };
+            }
+        }, 0);
+        assertTrue(callsHandler[0]);
+    }
+
+    @Test
+    public void aSecondRunChangesNothing() throws Exception {
+        File swingOnly = classesWithApp("swing");
+        List<File> swingClasspath = Arrays.asList(swingJar());
+        assertTrue(new CompatRemapper(swingOnly, swingClasspath, null, LOG).run());
+        Map<String, byte[]> first = snapshot(swingOnly);
+        assertTrue(new CompatRemapper(swingOnly, swingClasspath, null, LOG).run());
+        assertSameTree(first, snapshot(swingOnly));
+
+        File all = classesWithApp("all");
+        File onClick = tmp.newFile("onclick.txt");
+        Files.write(onClick.toPath(), "tapped\n".getBytes("UTF-8"));
+        List<File> classpath = Arrays.asList(androidJar(), swingJar(), javafxJar());
+        assertTrue(new CompatRemapper(all, classpath, onClick, LOG).run());
+        first = snapshot(all);
+        assertTrue(new CompatRemapper(all, classpath, onClick, LOG).run());
+        assertSameTree(first, snapshot(all));
+        assertTrue(new CompatRemapper(all, classpath, onClick, LOG).relocateOnly().run());
+        assertSameTree(first, snapshot(all));
+    }
+
+    @Test
+    public void withoutALayerNothingIsTouched() throws Exception {
+        File classes = classesWithApp("classes");
+        Map<String, byte[]> before = snapshot(classes);
+
+        CompatRemapper remapper = new CompatRemapper(classes,
+                Arrays.asList(new File(tmp.getRoot(), "codenameone-core-1.jar")), null, LOG);
+        assertTrue(remapper.activeLayers().isEmpty());
+        assertFalse(remapper.run());
+        assertSameTree(before, snapshot(classes));
+
+        assertFalse(new CompatRemapper(classes, null, null, LOG).run());
+        assertSameTree(before, snapshot(classes));
+    }
+
+    /// An application that has not switched the Swing layer on keeps its
+    /// `java/awt/` references, whatever other layer it uses: the compliance
+    /// check is what tells its developer about them.
+    @Test
+    public void anInactiveLayersNamesAreLeftForTheComplianceCheck() throws Exception {
+        File classes = classesWithApp("classes");
+        assertTrue(new CompatRemapper(classes, Arrays.asList(androidJar()), null, LOG).run());
+
+        List<String> app = refs(Files.readAllBytes(new File(classes, "com/x/Main.class").toPath()));
+        assertTrue(app.toString(), app.contains("javax/swing/JFrame"));
+        assertTrue(app.toString(), app.contains("java/awt/Color"));
+        assertTrue(app.toString(), app.contains("Ljavafx/stage/Stage;"));
+        assertTrue(app.toString(), app.contains("(Lcom/codename1/androidcompat/android/view/View;)V"));
+    }
+
+    /// With only Android active the generic entry point is the Android step
+    /// and nothing else: the same files with the same bytes.
+    @Test
+    public void androidAloneIsExactlyTheAndroidStep() throws Exception {
+        File onClick = tmp.newFile("onclick.txt");
+        Files.write(onClick.toPath(), "tapped\nmissing\n".getBytes("UTF-8"));
+        File android = androidJar();
+
+        File direct = classesWithApp("direct");
+        new AndroidRemapper(direct, android, onClick, LOG).run();
+        File generic = classesWithApp("generic");
+        assertTrue(new CompatRemapper(generic, Collections.singletonList(android), onClick, LOG).run());
+
+        assertSameTree(snapshot(direct), snapshot(generic));
+    }
+
+    /// An application class that uses Swing and nothing else.
+    private static byte[] swingOnlyClass(String name) {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "javax/swing/JFrame", null);
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    /// The templates put both desktop jars on the classpath of a project with
+    /// desktop sources. A Swing application must not pay for the JavaFX
+    /// runtime: a desktop layer ships only when the classes refer to it.
+    @Test
+    public void aDesktopLayerShipsOnlyWhenTheClassesUseIt() throws Exception {
+        File classes = tmp.newFolder("classes");
+        assertTrue(new File(classes, "com/x").mkdirs());
+        Files.write(new File(classes, "com/x/Main.class").toPath(), swingOnlyClass("com/x/Main"));
+        List<File> classpath = Arrays.asList(swingJar(), javafxJar());
+
+        CompatRemapper remapper = new CompatRemapper(classes, classpath, null, LOG);
+        assertEquals(Collections.singletonList(CompatLayers.SWING), remapper.activeLayers());
+        assertTrue(remapper.run());
+        assertTrue(new File(classes, SWING + "javax/swing/JFrame.class").isFile());
+        assertFalse(new File(classes, FX).exists());
+
+        // Read back from the relocated classes, the answer is the same, and
+        // the extracted Swing runtime is not mistaken for application code.
+        Map<String, byte[]> first = snapshot(classes);
+        CompatRemapper again = new CompatRemapper(classes, classpath, null, LOG);
+        assertEquals(Collections.singletonList(CompatLayers.SWING), again.activeLayers());
+        assertTrue(again.run());
+        assertSameTree(first, snapshot(classes));
+    }
+
+    /// With both jars present and neither used, nothing is active and the
+    /// classes are left alone.
+    @Test
+    public void unusedDesktopJarsSwitchNothingOn() throws Exception {
+        File classes = tmp.newFolder("classes");
+        assertTrue(new File(classes, "com/x").mkdirs());
+        Files.write(new File(classes, "com/x/Plain.class").toPath(), emptyClass("com/x/Plain", "java/lang/Object"));
+        Map<String, byte[]> before = snapshot(classes);
+
+        CompatRemapper remapper = new CompatRemapper(classes, Arrays.asList(swingJar(), javafxJar()),
+                null, LOG);
+        assertTrue(remapper.activeLayers().isEmpty());
+        assertFalse(remapper.run());
+        assertSameTree(before, snapshot(classes));
+    }
+
+    /// Kotlin's classes are a directory of their own, relocated separately;
+    /// a layer only they use still has to ship with the main pass.
+    @Test
+    public void aLayerUsedOnlyByAHandlerDirectoryStillShips() throws Exception {
+        File classes = tmp.newFolder("classes");
+        assertTrue(new File(classes, "com/x").mkdirs());
+        Files.write(new File(classes, "com/x/Main.class").toPath(), swingOnlyClass("com/x/Main"));
+        File kotlin = tmp.newFolder("kotlin");
+        assertTrue(new File(kotlin, "com/x").mkdirs());
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "com/x/View", null, "java/lang/Object", null);
+        cw.visitField(Opcodes.ACC_PRIVATE, "stage", "Ljavafx/stage/Stage;", null, null).visitEnd();
+        cw.visitEnd();
+        Files.write(new File(kotlin, "com/x/View.class").toPath(), cw.toByteArray());
+        List<File> classpath = Arrays.asList(swingJar(), javafxJar());
+
+        CompatRemapper remapper = new CompatRemapper(classes, classpath, null, LOG)
+                .withHandlerDirectories(Collections.singletonList(kotlin));
+        assertEquals(Arrays.asList(CompatLayers.SWING, CompatLayers.JAVAFX), remapper.activeLayers());
+        assertTrue(remapper.run());
+        assertTrue(new File(classes, FX + "javafx/stage/Stage.class").isFile());
+
+        // The Kotlin directory, on its own, is relocated by what it uses.
+        CompatRemapper kotlinPass = new CompatRemapper(kotlin, classpath, null, LOG).relocateOnly();
+        assertEquals(Collections.singletonList(CompatLayers.JAVAFX), kotlinPass.activeLayers());
+        assertTrue(kotlinPass.run());
+        assertTrue(refs(Files.readAllBytes(new File(kotlin, "com/x/View.class").toPath()))
+                .contains("L" + FX + "javafx/stage/Stage;"));
+    }
+
+    /// The Android layer keeps its rule: its jar alone switches it on.
+    @Test
+    public void theAndroidLayerIsActiveByItsJarAlone() throws Exception {
+        File classes = tmp.newFolder("classes");
+        assertTrue(new File(classes, "com/x").mkdirs());
+        Files.write(new File(classes, "com/x/Plain.class").toPath(), emptyClass("com/x/Plain", "java/lang/Object"));
+        assertTrue(CompatLayers.activeByPresence(AndroidRemapper.RELOCATION));
+        assertFalse(CompatLayers.activeByPresence(CompatLayers.SWING));
+        assertFalse(CompatLayers.activeByPresence(CompatLayers.JAVAFX));
+        assertEquals(Collections.singletonList(AndroidRemapper.RELOCATION),
+                CompatLayers.active(Arrays.asList(androidJar(), swingJar(), javafxJar()),
+                        Collections.singletonList(classes)));
+    }
+
+    @Test
+    public void theDesktopSourceDirectorySuppliesTheDefaultResources() throws Exception {
+        File desktop = new File(tmp.getRoot(), "desktop");
+        CompatRemapper remapper = new CompatRemapper(tmp.newFolder("classes"), null, null, LOG)
+                .withDesktopSourceDirectory(desktop);
+        assertEquals(desktop, remapper.desktopSourceDirectory());
+        assertEquals(java.util.Collections.singletonList(DesktopSources.resourcesDir(desktop.getAbsoluteFile())),
+                remapper.resourceDirectories());
+    }
+
+    @Test
+    public void relocateOnlyShipsNoRuntime() throws Exception {
+        File classes = classesWithApp("classes");
+        assertTrue(new CompatRemapper(classes, Arrays.asList(swingJar(), javafxJar()), null, LOG)
+                .relocateOnly().run());
+
+        List<String> app = refs(Files.readAllBytes(new File(classes, "com/x/Main.class").toPath()));
+        assertTrue(app.toString(), app.contains(SWING + "javax/swing/JFrame"));
+        assertTrue(app.toString(), app.contains("L" + FX + "javafx/stage/Stage;"));
+        assertEquals(Collections.singleton("com/x/Main.class"), snapshot(classes).keySet());
+    }
+
+    /// A class a newer runtime no longer has does not outlive it in a
+    /// directory an earlier build extracted the older one into.
+    @Test
+    public void aRuntimeEntryThatIsGoneIsRemovedByTheNextBuild() throws Exception {
+        File classes = tmp.newFolder("classes");
+        byte[] kept = DependencyClassifierTest.cls("org/rt/Kept", DependencyClassifierTest.uses());
+        byte[] gone = DependencyClassifierTest.cls("org/rt/old/Gone", DependencyClassifierTest.uses("org/rt/Kept"));
+        byte[] carried = DependencyClassifierTest.cls("org/rt/Carried", DependencyClassifierTest.uses());
+        File first = jar(new File(tmp.newFolder(), "some-runtime-1.0.jar"), "org/rt/Kept.class", kept,
+                "org/rt/old/Gone.class", gone, "org/rt/Carried.class", carried,
+                "tables/old.bin", new byte[] {1, 2, 3}, "tables/kept.bin", new byte[] {4});
+        File other = jar(new File(tmp.newFolder(), "other-runtime-1.0.jar"), "org/other/Thing.class",
+                DependencyClassifierTest.cls("org/other/Thing", DependencyClassifierTest.uses()));
+        ClassRelocator relocator = new ClassRelocator(CompatLayers.SWING);
+        assertEquals(3, relocator.extractRuntime(first, classes));
+        assertEquals(1, relocator.extractRuntime(other, classes));
+        assertTrue(new File(classes, "org/rt/old/Gone.class").isFile());
+        assertTrue(new File(classes, "tables/old.bin").isFile());
+        // Kept beside the directory: nothing an application ships.
+        assertTrue(ClassRelocator.runtimeRecord(classes).isFile());
+        assertFalse(ClassRelocator.runtimeRecord(classes).getCanonicalPath()
+                .startsWith(classes.getCanonicalPath() + File.separator));
+
+        // The same runtime again changes nothing.
+        long stamp = ClassRelocator.runtimeRecord(classes).lastModified();
+        byte[] record = Files.readAllBytes(ClassRelocator.runtimeRecord(classes).toPath());
+        assertEquals(3, relocator.extractRuntime(first, classes));
+        assertArrayEquals(record, Files.readAllBytes(ClassRelocator.runtimeRecord(classes).toPath()));
+        assertEquals(stamp, ClassRelocator.runtimeRecord(classes).lastModified());
+
+        // The application has since taken one of the classes for its own.
+        byte[] own = DependencyClassifierTest.cls("org/rt/Carried", DependencyClassifierTest.uses("org/rt/Kept"));
+        Files.write(new File(classes, "org/rt/Carried.class").toPath(), own);
+
+        File second = jar(new File(tmp.newFolder(), "some-runtime-1.1.jar"), "org/rt/Kept.class", kept,
+                "org/rt/New.class", DependencyClassifierTest.cls("org/rt/New", DependencyClassifierTest.uses()),
+                "tables/kept.bin", new byte[] {4});
+        assertEquals("some-runtime", ClassRelocator.runtimeKey(second));
+        assertEquals(2, new ClassRelocator(CompatLayers.SWING).extractRuntime(second, classes));
+        assertTrue(new File(classes, "org/rt/Kept.class").isFile());
+        assertTrue(new File(classes, "org/rt/New.class").isFile());
+        assertTrue(new File(classes, "tables/kept.bin").isFile());
+        assertFalse("A class the runtime dropped is still there", new File(classes, "org/rt/old/Gone.class").exists());
+        assertFalse("and so is its directory", new File(classes, "org/rt/old").exists());
+        assertFalse(new File(classes, "tables/old.bin").exists());
+        assertArrayEquals("A file that is no longer what was extracted is not this step's to delete", own,
+                Files.readAllBytes(new File(classes, "org/rt/Carried.class").toPath()));
+        // Another runtime's classes are its own.
+        assertTrue(new File(classes, "org/other/Thing.class").isFile());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatResourcesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatResourcesTest.java
new file mode 100644
index 00000000000..ded46b078fb
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatResourcesTest.java
@@ -0,0 +1,587 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+import com.codename1.build.BuildFailureException;
+import com.codename1.builders.BuildException;
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.impl.compat.Resources;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Desktop resources through the build: flattened, indexed and registered,
+/// and -- in the last test -- looked up by a javac-compiled application
+/// that has been relocated, has passed the compliance check against the real
+/// device library, and runs against a bundle that holds flat names only.
+public class CompatResourcesTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private Locale saved;
+
+    @Before
+    public void useUsLocale() {
+        saved = Locale.getDefault();
+        Locale.setDefault(Locale.US);
+    }
+
+    @After
+    public void restore() {
+        Locale.setDefault(saved);
+        Resources.cn1SetProvider(null);
+        Resources.cn1ClearIndex();
+    }
+
+    private static File write(File root, String path, String text) throws IOException {
+        File f = new File(root, path);
+        assertTrue(f.getParentFile().isDirectory() || f.getParentFile().mkdirs());
+        Files.write(f.toPath(), text.getBytes("UTF-8"));
+        return f;
+    }
+
+    private static String text(File f) throws IOException {
+        return new String(Files.readAllBytes(f.toPath()), "UTF-8");
+    }
+
+    /// Every file under `dir` by its path, as text of its bytes.
+    private static Map<String, byte[]> snapshot(File dir) throws IOException {
+        Map<String, byte[]> out = new TreeMap<String, byte[]>();
+        snapshot(dir, "", out);
+        return out;
+    }
+
+    private static void snapshot(File dir, String rel, Map<String, byte[]> out) throws IOException {
+        File[] files = dir.listFiles();
+        assertNotNull(files);
+        for (File f : files) {
+            if (f.isDirectory()) {
+                snapshot(f, rel + f.getName() + "/", out);
+            } else {
+                out.put(rel + f.getName(), Files.readAllBytes(f.toPath()));
+            }
+        }
+    }
+
+    private static void assertSameTree(Map<String, byte[]> expected, Map<String, byte[]> actual) {
+        assertEquals(expected.keySet(), actual.keySet());
+        for (Map.Entry<String, byte[]> e : expected.entrySet()) {
+            assertArrayEquals(e.getKey(), e.getValue(), actual.get(e.getKey()));
+        }
+    }
+
+    private void ship(File classes, File resources) throws Exception {
+        new CompatResources(classes, Collections.singletonList(resources), Collections.<File>emptyList(),
+                CompatRemapperTest.LOG).run();
+    }
+
+    // ------------------------------------------------------------------
+    // Flattening
+    // ------------------------------------------------------------------
+
+    @Test
+    public void nestedResourcesMoveToTheirFlatNames() throws Exception {
+        File classes = tmp.newFolder("classes");
+        File resources = tmp.newFolder("resources");
+        write(resources, "com/acme/img/my_logo.png", "LOGO");
+        write(resources, "com/acme/Messages.properties", "a=source");
+        write(resources, "root.txt", "ROOT");
+        write(resources, "com/acme/.DS_Store", "junk");
+        // What a build tool's resources step left: copies, one of them
+        // filtered, beside the application's classes.
+        write(classes, "com/acme/img/my_logo.png", "LOGO");
+        write(classes, "com/acme/Messages.properties", "a=filtered");
+        write(classes, "root.txt", "ROOT");
+        Files.write(write(classes, "com/acme/Main.class", "").toPath(),
+                CompatRemapperTest.emptyClass("com/acme/Main", "java/lang/Object"));
+
+        ship(classes, resources);
+
+        assertEquals("com__acme__img__my_ulogo.png", ResourceNames.flatName("com/acme/img/my_logo.png"));
+        assertEquals("LOGO", text(new File(classes, "com__acme__img__my_ulogo.png")));
+        // The build tool's copy is the one that ships.
+        assertEquals("a=filtered", text(new File(classes, "com__acme__Messages.properties")));
+        assertEquals("ROOT", text(new File(classes, "root.txt")));
+        assertFalse(new File(classes, "com/acme/img").exists());
+        assertFalse(new File(classes, "com/acme/Messages.properties").exists());
+        assertTrue("A directory still holding classes stays", new File(classes, "com/acme/Main.class").isFile());
+        assertFalse(new File(classes, "com__acme__.DS_Store").exists());
+        assertEquals("com__acme__Messages.properties\ncom__acme__img__my_ulogo.png\n",
+                text(CompatResources.manifest(classes)));
+        assertFalse("The list of flat names is not shipped",
+                CompatResources.manifest(classes).getAbsolutePath().startsWith(classes.getAbsolutePath() + File.separator));
+    }
+
+    /// Gradle keeps resources out of the classes directory, so there is no
+    /// nested copy to take: the source file is.
+    @Test
+    public void aResourceWithNoCopyInTheClassesDirectoryIsTakenFromItsSource() throws Exception {
+        File classes = tmp.newFolder("classes");
+        File resources = tmp.newFolder("resources");
+        write(resources, "x/y.txt", "why");
+        ship(classes, resources);
+        assertEquals("why", text(new File(classes, "x__y.txt")));
+    }
+
+    @Test
+    public void aSecondRunChangesNothingAndADeletedResourceLosesItsFlatCopy() throws Exception {
+        File classes = tmp.newFolder("classes");
+        File resources = tmp.newFolder("resources");
+        write(resources, "x/y.txt", "why");
+        File doomed = write(resources, "x/gone.txt", "gone");
+        ship(classes, resources);
+        Map<String, byte[]> first = snapshot(classes);
+        long stamp = new File(classes, "x__y.txt").lastModified();
+        assertTrue(first.containsKey("x__gone.txt"));
+
+        ship(classes, resources);
+        assertSameTree(first, snapshot(classes));
+        assertEquals(stamp, new File(classes, "x__y.txt").lastModified());
+
+        assertTrue(doomed.delete());
+        ship(classes, resources);
+        assertFalse(new File(classes, "x__gone.txt").exists());
+        assertEquals("x__y.txt\n", text(CompatResources.manifest(classes)));
+
+        assertTrue(new File(resources, "x/y.txt").delete());
+        ship(classes, resources);
+        assertFalse(new File(classes, "x__y.txt").exists());
+        assertFalse(CompatResources.manifest(classes).exists());
+    }
+
+    @Test
+    public void aFlatNameTakenByARootResourceFailsTheBuild() throws Exception {
+        File classes = tmp.newFolder("classes");
+        File resources = tmp.newFolder("resources");
+        write(resources, "img/a.png", "nested");
+        write(resources, "img__a.png", "root");
+        try {
+            ship(classes, resources);
+            fail("Two resources would ship under one name");
+        } catch (BuildException expected) {
+            String message = expected.getMessage();
+            assertTrue(message, message.contains("The resource img/a.png ships as img__a.png"));
+            assertTrue(message, message.contains("already taken by"));
+            assertTrue(message, message.contains(new File(resources, "img__a.png").toString()));
+            assertTrue(message, message.contains("Rename one of the two"));
+        }
+    }
+
+    /// A file some other step put at the root -- from the ordinary resource
+    /// directory, say -- is not ours to overwrite.
+    @Test
+    public void aFlatNameTakenByAnotherFileAtTheRootFailsTheBuild() throws Exception {
+        File classes = tmp.newFolder("classes");
+        File resources = tmp.newFolder("resources");
+        write(resources, "img/a.png", "nested");
+        File foreign = write(classes, "img__a.png", "somebody else's");
+        try {
+            ship(classes, resources);
+            fail("A file of another origin would be overwritten");
+        } catch (BuildException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains(foreign.toString()));
+        }
+        assertEquals("somebody else's", text(foreign));
+
+        // The same bytes are the same resource, whoever put them there.
+        write(classes, "img__a.png", "nested");
+        ship(classes, resources);
+        assertEquals("nested", text(foreign));
+    }
+
+    @Test
+    public void theSameResourceInTwoDirectoriesFailsTheBuild() throws Exception {
+        File classes = tmp.newFolder("classes");
+        File one = tmp.newFolder("one");
+        File two = tmp.newFolder("two");
+        write(one, "x/y.txt", "1");
+        write(two, "x/y.txt", "2");
+        try {
+            new CompatResources(classes, Arrays.asList(one, two, new File(tmp.getRoot(), "absent")),
+                    Collections.<File>emptyList(), CompatRemapperTest.LOG).run();
+            fail("Only one of the two can ship");
+        } catch (BuildException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("The resource x/y.txt exists twice"));
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // End to end
+    // ------------------------------------------------------------------
+
+    private static final String FOO = "package p;\n"
+            + "import java.io.InputStream;\n"
+            + "import java.net.URL;\n"
+            + "import java.util.HashMap;\n"
+            + "import java.util.Locale;\n"
+            + "import java.util.Map;\n"
+            + "import java.util.Properties;\n"
+            + "import java.util.ResourceBundle;\n"
+            + "public class Foo {\n"
+            + "    javax.swing.JLabel label;\n"
+            + "    public String image() throws Exception {\n"
+            + "        URL url = getClass().getResource(\"img/a.png\");\n"
+            + "        return url.toExternalForm() + \"=\" + read(url.openStream());\n"
+            + "    }\n"
+            + "    public static String text() throws Exception {\n"
+            + "        return read(Foo.class.getResourceAsStream(\"/x/y.txt\"));\n"
+            + "    }\n"
+            + "    public static String root() throws Exception {\n"
+            + "        return read(Foo.class.getResourceAsStream(\"/root.txt\"));\n"
+            + "    }\n"
+            + "    public static String missing() {\n"
+            + "        return Foo.class.getResource(\"/x/none.txt\") + \",\" + Foo.class.getResourceAsStream(\"none.png\");\n"
+            + "    }\n"
+            + "    public static String bundle() {\n"
+            + "        return ResourceBundle.getBundle(\"p.Messages\").getString(\"greeting\");\n"
+            + "    }\n"
+            + "    public static String french() {\n"
+            + "        ResourceBundle b = ResourceBundle.getBundle(\"p.Messages\", Locale.FRENCH);\n"
+            + "        return b.getString(\"greeting\") + \",\" + b.getString(\"bye\");\n"
+            + "    }\n"
+            + "    public static String listed() {\n"
+            + "        return ResourceBundle.getBundle(\"p.Labels\").getString(\"ok\");\n"
+            + "    }\n"
+            + "    public static String settings() throws Exception {\n"
+            + "        Properties p = new Properties();\n"
+            + "        InputStream in = Foo.class.getResourceAsStream(\"Messages.properties\");\n"
+            + "        p.load(in);\n"
+            + "        in.close();\n"
+            + "        return p.getProperty(\"bye\") + \",\" + p.getProperty(\"absent\", \"default\");\n"
+            + "    }\n"
+            + "    public static int compute() {\n"
+            + "        Map<String, Integer> m = new HashMap<>();\n"
+            + "        m.computeIfAbsent(\"a\", k -> k.length() + 6);\n"
+            + "        m.computeIfAbsent(\"a\", k -> 100);\n"
+            + "        return m.get(\"a\");\n"
+            + "    }\n"
+            + "    static String read(InputStream in) throws Exception {\n"
+            + "        StringBuilder sb = new StringBuilder();\n"
+            + "        for (int c = in.read(); c >= 0; c = in.read()) {\n"
+            + "            sb.append((char) c);\n"
+            + "        }\n"
+            + "        in.close();\n"
+            + "        return sb.toString();\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String LABELS = "package p;\n"
+            + "import java.util.ListResourceBundle;\n"
+            + "public class Labels extends ListResourceBundle {\n"
+            + "    protected Object[][] getContents() {\n"
+            + "        return new Object[][] {{\"ok\", \"OK\"}};\n"
+            + "    }\n"
+            + "}\n";
+
+    /// A use of a class loader that nothing stands in for: one made at run
+    /// time, to load classes the application was not built with.
+    private static final String LOADS = "package p;\n"
+            + "public class Loads {\n"
+            + "    javax.swing.JLabel label;\n"
+            + "    public static Class<?> load() throws Exception {\n"
+            + "        return new java.net.URLClassLoader(new java.net.URL[0]).loadClass(\"p.Plugin\");\n"
+            + "    }\n"
+            + "}\n";
+
+    /// Asking the application's own loader for one of its classes, which is
+    /// how desktop code finds out whether an optional class is present.
+    private static final String ASKS = "package p;\n"
+            + "public class Asks {\n"
+            + "    javax.swing.JLabel label;\n"
+            + "    public static boolean has(String name) {\n"
+            + "        try {\n"
+            + "            return Asks.class.getClassLoader().loadClass(name) != null;\n"
+            + "        } catch (ClassNotFoundException e) {\n"
+            + "            return false;\n"
+            + "        }\n"
+            + "    }\n"
+            + "}\n";
+
+    /// The jar or class directory on the test classpath that holds `marker`
+    /// and belongs to `artifactId`, as a jar named the way a build finds it.
+    private File artifact(String artifactId, String marker) throws IOException {
+        for (String entry : System.getProperty("java.class.path").split(File.pathSeparator)) {
+            File f = new File(entry);
+            if (f.isFile() && f.getName().startsWith(artifactId + "-") && f.getName().endsWith(".jar")) {
+                return f;
+            }
+            if (f.isDirectory() && new File(f, marker).isFile()) {
+                // A reactor build has the module's classes, not its jar.
+                File jar = new File(tmp.getRoot(), artifactId + "-1.jar");
+                if (!jar.isFile()) {
+                    ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(jar));
+                    try {
+                        for (Map.Entry<String, byte[]> e : snapshot(f).entrySet()) {
+                            zip.putNextEntry(new ZipEntry(e.getKey()));
+                            zip.write(e.getValue());
+                            zip.closeEntry();
+                        }
+                    } finally {
+                        zip.close();
+                    }
+                }
+                return jar;
+            }
+        }
+        fail(artifactId + " is not on the test classpath: " + System.getProperty("java.class.path"));
+        return null;
+    }
+
+    private File swingJar() throws IOException {
+        String label = CompatRemapperTest.SWING + "javax/swing/JLabel";
+        return CompatRemapperTest.jar(new File(tmp.getRoot(), "codenameone-swing-compat-1.jar"),
+                label + ".class", CompatRemapperTest.emptyClass(label, "java/lang/Object"));
+    }
+
+    /// The compliance check as a build runs it, against the real device
+    /// library and the real core.
+    private void checkCompliance(File classes, File swing) throws Exception {
+        TestProjectHost host = TestProjectHost.empty();
+        host.log = CompatRemapperTest.LOG;
+        host.buildDir = tmp.newFolder();
+        host.outputDir = classes;
+        host.artifacts.add(new BuildArtifact("com.codenameone", "java-runtime", "1", null, "jar", "provided",
+                artifact("java-runtime", "java/lang/Object.class"), null));
+        host.artifacts.add(new BuildArtifact("com.codenameone", "codenameone-core", "1", null, "jar", "provided",
+                artifact("codenameone-core", "com/codename1/ui/Display.class"), null));
+        host.artifacts.add(new BuildArtifact("com.codenameone", "codenameone-swing-compat", "1", null, "jar",
+                "compile", swing, null));
+        new BytecodeCompliance(host).execute();
+    }
+
+    /// Installs into `resources` (the `Resources` class `loader` defined)
+    /// what the JavaSE and Android ports install on a real JDK: `cn1res:`
+    /// URLs whose stream reads through `Resources.openUrlPath`, and a loader
+    /// that answers a nested name the build flattened from the index.
+    private static void installJdkSupport(ClassLoader loader, final Class<?> resources) throws Exception {
+        final Method openUrlPath = resources.getMethod("openUrlPath", String.class);
+        final Method exists = resources.getMethod("exists", String.class);
+        final Method systemResource = resources.getMethod("getSystemResource", String.class);
+        final URLStreamHandler handler = new URLStreamHandler() {
+            @Override
+            protected URLConnection openConnection(URL u) {
+                return new URLConnection(u) {
+                    @Override
+                    public void connect() {
+                        connected = true;
+                    }
+
+                    @Override
+                    public java.io.InputStream getInputStream() throws IOException {
+                        try {
+                            java.io.InputStream in = (java.io.InputStream) openUrlPath.invoke(null, getURL().getPath());
+                            if (in == null) {
+                                throw new java.io.FileNotFoundException(getURL().toExternalForm());
+                            }
+                            return in;
+                        } catch (ReflectiveOperationException e) {
+                            throw new IOException(e);
+                        }
+                    }
+                };
+            }
+        };
+        Class<?> factoryType = loader.loadClass("com.codename1.impl.compat.Resources$UrlFactory");
+        Object factory = Proxy.newProxyInstance(loader, new Class<?>[] {factoryType}, new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                if (!"create".equals(method.getName())) {
+                    return method.invoke(this, args);
+                }
+                return new URL("cn1res", null, -1, (String) args[0], handler);
+            }
+        });
+        resources.getMethod("cn1SetUrlFactory", factoryType).invoke(null, factory);
+        ClassLoader flat = new ClassLoader(loader) {
+            @Override
+            protected URL findResource(String name) {
+                try {
+                    return Boolean.TRUE.equals(exists.invoke(null, name)) ? (URL) systemResource.invoke(null, name)
+                            : null;
+                } catch (ReflectiveOperationException e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+        };
+        resources.getMethod("cn1SetClassLoader", ClassLoader.class).invoke(null, flat);
+    }
+
+    @Test
+    public void aDesktopApplicationFindsItsResourcesInAFlatBundle() throws Exception {
+        File classes = tmp.newFolder("classes");
+        CompatFixtures.compile(tmp.newFolder("src"), classes, "p/Foo.java", FOO, "p/Labels.java", LABELS);
+        File desktop = tmp.newFolder("desktop");
+        File resources = DesktopSources.resourcesDir(desktop);
+        String[][] files = {
+            {"p/img/a.png", "PNG"},
+            {"x/y.txt", "why"},
+            {"root.txt", "ROOT"},
+            {"p/Messages.properties", "greeting=Hello\nbye=Good\\\n    bye\n"},
+            {"p/Messages_fr.properties", "greeting=Bonjour\n"},
+        };
+        for (String[] file : files) {
+            write(resources, file[0], file[1]);
+            // As Maven's resources step leaves them, beside the classes.
+            write(classes, file[0], file[1]);
+        }
+        File swing = swingJar();
+        List<File> classpath = Collections.singletonList(swing);
+
+        assertTrue(new CompatRemapper(classes, classpath, null, CompatRemapperTest.LOG)
+                .withDesktopSourceDirectory(desktop).run());
+
+        // Flat, and only flat.
+        for (String flat : new String[] {"p__img__a.png", "x__y.txt", "root.txt", "p__Messages.properties",
+            "p__Messages_ufr.properties"}) {
+            assertTrue(flat, new File(classes, flat).isFile());
+        }
+        assertFalse(new File(classes, "p/img").exists());
+        assertFalse(new File(classes, "x").exists());
+        assertFalse(new File(classes, "p/Messages.properties").exists());
+        assertTrue(new File(classes, ApplicationRegistry.NAME + ".class").isFile());
+
+        // A second run is a no-op, the registry included.
+        Map<String, byte[]> first = snapshot(classes);
+        assertTrue(new CompatRemapper(classes, classpath, null, CompatRemapperTest.LOG)
+                .withDesktopSourceDirectory(desktop).run());
+        assertSameTree(first, snapshot(classes));
+
+        // Everything that ships exists on the device.
+        checkCompliance(classes, swing);
+
+        // The device bundle: the files at the root of the classes
+        // directory and nothing else. The application's loader sees the
+        // classes and the core, and the JDK is the class library -- as on
+        // the JavaSE and Android ports, which install what a real JDK needs
+        // to read a flat bundle: a URL handler for `cn1res:` and a loader
+        // that falls back to the index. `installJdkSupport` is the same.
+        final File bundle = tmp.newFolder("bundle");
+        for (File f : classes.listFiles()) {
+            if (f.isFile()) {
+                Files.copy(f.toPath(), new File(bundle, f.getName()).toPath());
+            }
+        }
+        final List<String> asked = new ArrayList<String>();
+        URLClassLoader loader = new URLClassLoader(new URL[] {classes.toURI().toURL(),
+            artifact("codenameone-core", "com/codename1/ui/Display.class").toURI().toURL(),
+            RealCompatJars.jdkHost(tmp.newFolder()).toURI().toURL()}, null);
+        try {
+            Class<?> provider = loader.loadClass("com.codename1.impl.compat.Resources$Provider");
+            Object flat = Proxy.newProxyInstance(loader, new Class<?>[] {provider}, new InvocationHandler() {
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                    if (!"open".equals(method.getName())) {
+                        return method.invoke(this, args);
+                    }
+                    asked.add((String) args[0]);
+                    File f = new File(bundle, (String) args[0]);
+                    return f.isFile() ? new FileInputStream(f) : null;
+                }
+            });
+            Class<?> resourcesClass = loader.loadClass("com.codename1.impl.compat.Resources");
+            resourcesClass.getMethod("cn1SetProvider", provider).invoke(null, flat);
+            installJdkSupport(loader, resourcesClass);
+            // What the application's lifecycle does first.
+            loader.loadClass(ApplicationRegistry.NAME.replace('/', '.')).getMethod("cn1Install").invoke(null);
+
+            Class<?> foo = loader.loadClass("p.Foo");
+            Object instance = foo.getConstructor().newInstance();
+            assertEquals("cn1res:/p/img/a.png=PNG", foo.getMethod("image").invoke(instance));
+            assertEquals("why", foo.getMethod("text").invoke(null));
+            assertEquals("ROOT", foo.getMethod("root").invoke(null));
+            assertEquals(Arrays.asList("p__img__a.png", "x__y.txt", "root.txt"), asked);
+            asked.clear();
+            assertEquals("null,null", foo.getMethod("missing").invoke(null));
+            assertTrue("Absence comes from the index: " + asked, asked.isEmpty());
+
+            assertEquals("Hello", foo.getMethod("bundle").invoke(null));
+            assertEquals("Bonjour,Goodbye", foo.getMethod("french").invoke(null));
+            assertEquals("OK", foo.getMethod("listed").invoke(null));
+            assertEquals("Goodbye,default", foo.getMethod("settings").invoke(null));
+            assertEquals(Integer.valueOf(7), foo.getMethod("compute").invoke(null));
+        } finally {
+            loader.close();
+        }
+    }
+
+    @Test
+    public void loadingClassesTheApplicationWasNotBuiltWithIsStillABuildError() throws Exception {
+        File classes = tmp.newFolder("classes");
+        CompatFixtures.compile(tmp.newFolder("src"), classes, "p/Loads.java", LOADS);
+        File swing = swingJar();
+        assertTrue(new CompatRemapper(classes, Collections.singletonList(swing), null, CompatRemapperTest.LOG).run());
+        try {
+            checkCompliance(classes, swing);
+            fail("A device loads no classes at run time");
+        } catch (BuildFailureException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("URLClassLoader"));
+        }
+    }
+
+    /// `loadClass` on the loader the application already has is
+    /// `Class.forName`, which a device does have.
+    @Test
+    public void askingTheApplicationsLoaderForAClassIsNot() throws Exception {
+        File classes = tmp.newFolder("classes");
+        CompatFixtures.compile(tmp.newFolder("src"), classes, "p/Asks.java", ASKS);
+        File swing = swingJar();
+        assertTrue(new CompatRemapper(classes, Collections.singletonList(swing), null, CompatRemapperTest.LOG).run());
+        assertTrue(CompatFixtures.members(Files.readAllBytes(new File(classes, "p/Asks.class").toPath()))
+                .contains("com/codename1/impl/compat/Resources.loadClass"));
+        checkCompliance(classes, swing);
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatRewritesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatRewritesTest.java
new file mode 100644
index 00000000000..281bb8e3dc5
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatRewritesTest.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.impl.compat.Resources;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.Set;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/// The member rewrites: a class javac compiled against the JDK is relocated
+/// and then RUN, so a rule that produced a call the JVM rejects, or one that
+/// lands on the wrong method, fails here rather than on a device.
+public class CompatRewritesTest {
+
+    private static final String SOURCE = "package q;\n"
+            + "import java.io.InputStream;\n"
+            + "import java.util.ArrayList;\n"
+            + "import java.util.List;\n"
+            + "import java.util.Locale;\n"
+            + "import java.util.Objects;\n"
+            + "import java.util.function.BiFunction;\n"
+            + "import java.util.function.DoubleUnaryOperator;\n"
+            + "import java.util.function.Predicate;\n"
+            + "public class R {\n"
+            + "    public static Object[] run() throws Exception {\n"
+            + "        List<Object> out = new ArrayList<>();\n"
+            + "        out.add(Objects.isNull(null));\n"
+            + "        Predicate<Object> isNull = Objects::isNull;\n"
+            + "        out.add(isNull.test(\"x\"));\n"
+            + "        Locale fr = new Locale(\"fr\", \"FR\");\n"
+            + "        out.add(fr.toLanguageTag());\n"
+            + "        out.add(String.valueOf(R.class.getResource(\"data/r.txt\")));\n"
+            + "        out.add(read(R.class.getResourceAsStream(\"/q/data/r.txt\")));\n"
+            + "        ClassLoader loader = Thread.currentThread().getContextClassLoader();\n"
+            + "        out.add(String.valueOf(loader.getResource(\"q/data/r.txt\")));\n"
+            + "        out.add(read(loader.getResourceAsStream(\"q/data/r.txt\")));\n"
+            + "        out.add(String.valueOf(ClassLoader.getSystemResource(\"q/none.txt\")));\n"
+            + "        out.add(R.class.getClassLoader().getResources(\"q/data/r.txt\").hasMoreElements());\n"
+            + "        out.add(\"a1b22c\".matches(\"[a-c0-9]+\"));\n"
+            + "        out.add(String.join(\"|\", \"a,b,,c\".split(\",\")));\n"
+            + "        out.add(\"a,b,c\".split(\",\", 2).length);\n"
+            + "        out.add(\"x1y22\".replaceAll(\"[0-9]+\", \"#\"));\n"
+            + "        out.add(\"x1y22\".replaceFirst(\"[0-9]+\", \"#\"));\n"
+            + "        BiFunction<String, String, Boolean> matches = String::matches;\n"
+            + "        out.add(matches.apply(\"abc\", \"a.c\"));\n"
+            + "        out.add(Math.round(Math.pow(2, 10)));\n"
+            + "        out.add(Math.round(StrictMath.exp(0) * 1000));\n"
+            + "        DoubleUnaryOperator log = Math::log10;\n"
+            + "        out.add(Math.round(log.applyAsDouble(1000)));\n"
+            + "        return out.toArray();\n"
+            + "    }\n"
+            + "    static String read(InputStream in) throws Exception {\n"
+            + "        StringBuilder sb = new StringBuilder();\n"
+            + "        for (int c = in.read(); c >= 0; c = in.read()) {\n"
+            + "            sb.append((char) c);\n"
+            + "        }\n"
+            + "        in.close();\n"
+            + "        return sb.toString();\n"
+            + "    }\n"
+            + "    static Class<?> load(ClassLoader loader) throws Exception {\n"
+            + "        return loader.loadClass(\"q.Other\");\n"
+            + "    }\n"
+            + "    static Object bundle() {\n"
+            + "        return java.util.ResourceBundle.getBundle(\"q.Texts\", Locale.ROOT);\n"
+            + "    }\n"
+            + "    static Object services() {\n"
+            + "        return java.util.ServiceLoader.load(Runnable.class);\n"
+            + "    }\n"
+            + "    static void handler() {\n"
+            + "        Thread.setDefaultUncaughtExceptionHandler(null);\n"
+            + "    }\n"
+            + "    static Object exec() throws Exception {\n"
+            + "        return Runtime.getRuntime().exec(new String[] {\"true\"});\n"
+            + "    }\n"
+            + "}\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    @After
+    public void restore() {
+        Resources.cn1SetProvider(null);
+        Resources.cn1SetUrlFactory(null);
+        Resources.cn1ClearIndex();
+    }
+
+    private byte[] compiled() throws IOException {
+        File classes = tmp.newFolder();
+        CompatFixtures.compile(tmp.newFolder(), classes, "q/R.java", SOURCE);
+        return Files.readAllBytes(new File(classes, "q/R.class").toPath());
+    }
+
+    /// Running the class links it, so the JVM verifies every rewritten call
+    /// -- `Runtime.exec`'s among them, whose stand-in answers the
+    /// framework's `Process` that `java.lang.Process` is relocated to.
+    @Test
+    public void aRewrittenClassRunsAndReachesTheStandIns() throws Exception {
+        byte[] relocated = new ClassRelocator(CompatLayers.SWING).remap(compiled());
+
+        Resources.cn1SetUrlFactory(CompatFixtures.cn1resUrls());
+        Resources.cn1BeginIndex();
+        Resources.cn1AddResource("q/data/r.txt");
+        Resources.cn1SetProvider(new Resources.Provider() {
+            @Override
+            public InputStream open(String flatName) throws IOException {
+                return "q__data__r.txt".equals(flatName) ? new ByteArrayInputStream("DATA".getBytes("UTF-8")) : null;
+            }
+        });
+        Class<?> r = new CompatFixtures.Defining(getClass().getClassLoader()).define(relocated);
+        Object[] out = (Object[]) r.getMethod("run").invoke(null);
+
+        assertEquals(Arrays.asList(
+                Boolean.TRUE, Boolean.FALSE, "fr-FR",
+                "cn1res:/q/data/r.txt", "DATA", "cn1res:/q/data/r.txt", "DATA", "null", Boolean.TRUE,
+                Boolean.TRUE, "a|b||c", Integer.valueOf(2), "x#y#", "x#y22", Boolean.TRUE,
+                Long.valueOf(1024), Long.valueOf(1000), Long.valueOf(3)),
+                Arrays.asList(out));
+    }
+
+    @Test
+    public void everyRuleIsAppliedAndNothingElseIsTouched() throws Exception {
+        byte[] original = compiled();
+        Set<String> before = CompatFixtures.members(original);
+        ClassRelocator swing = new ClassRelocator(CompatLayers.SWING);
+        byte[] relocated = swing.remap(original);
+        Set<String> after = CompatFixtures.members(relocated);
+
+        for (String gone : new String[] {"java/lang/Class.getResource", "java/lang/Class.getResourceAsStream",
+            "java/lang/ClassLoader.getResource", "java/lang/ClassLoader.getResourceAsStream",
+            "java/lang/ClassLoader.getResources", "java/lang/ClassLoader.getSystemResource",
+            "java/lang/ClassLoader.loadClass", "java/lang/Thread.getContextClassLoader",
+            "java/lang/String.matches", "java/lang/String.split", "java/lang/String.replaceAll",
+            "java/lang/String.replaceFirst", "java/lang/Math.pow", "java/lang/StrictMath.exp",
+            "java/lang/Math.log10", "java/util/ResourceBundle.getBundle", "java/util/ServiceLoader.load",
+            "java/lang/Thread.setDefaultUncaughtExceptionHandler", "java/lang/Runtime.exec"}) {
+            assertTrue("The fixture does not use " + gone, before.contains(gone));
+            assertFalse(gone + " survived: " + after, after.contains(gone));
+        }
+        String resources = "com/codename1/impl/compat/Resources.";
+        for (String there : new String[] {resources + "getResource", resources + "getResourceAsStream",
+            resources + "getResources", resources + "getSystemResource", resources + "getContextClassLoader",
+            resources + "getBundle", resources + "load",
+            "com/codename1/impl/compat/UncaughtExceptions.setDefaultUncaughtExceptionHandler",
+            "com/codename1/util/regex/StringRegex.matches", "com/codename1/util/regex/StringRegex.split",
+            "com/codename1/util/MathUtil.pow", "com/codename1/util/MathUtil.exp",
+            "com/codename1/util/MathUtil.log10", "com/codename1/impl/process/RuntimeExec.exec",
+            // Left exactly as written: the device's class library has them
+            // under the JDK's names.
+            "java/util/Objects.isNull", "java/util/Locale.<init>", "java/util/Locale.toLanguageTag",
+            "java/lang/Math.round", "java/lang/Class.getClassLoader", "java/lang/String.join",
+            // Asking the one loader for a class by name is Class.forName.
+            resources + "loadClass"}) {
+            assertTrue(there + " is missing: " + after, after.contains(there));
+        }
+        // A second pass finds nothing left to do.
+        assertArrayEquals(relocated, swing.remap(relocated));
+    }
+
+    /// The Android layer's applications were never compiled against these
+    /// members, and its build must not start referring to classes only a
+    /// desktop layer needs.
+    @Test
+    public void theAndroidLayerAloneRewritesNoMember() throws Exception {
+        Set<String> after = CompatFixtures.members(new ClassRelocator(AndroidRemapper.RELOCATION).remap(compiled()));
+        assertTrue(after.toString(), after.contains("java/lang/Class.getResource"));
+        assertTrue(after.toString(), after.contains("java/lang/String.split"));
+        for (String member : after) {
+            assertFalse(member, member.startsWith("com/codename1/impl/compat/"));
+        }
+        // With a desktop layer beside it, the rules apply.
+        Set<String> mixed = CompatFixtures.members(
+                new ClassRelocator(AndroidRemapper.RELOCATION, CompatLayers.JAVAFX).remap(compiled()));
+        assertFalse(mixed.toString(), mixed.contains("java/lang/Class.getResource"));
+    }
+
+    /// The Android layer's runtime asks for resources by their flat names
+    /// already, and a rule applied to it would change what it reads.
+    @Test
+    public void theAndroidRuntimeIsNotRewritten() {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, AndroidRemapper.RELOCATION.target() + "android/Probe", null,
+                "java/lang/Object", null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "open",
+                "(Ljava/lang/Class;)Ljava/io/InputStream;", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitLdcInsn("/x");
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "getResourceAsStream",
+                "(Ljava/lang/String;)Ljava/io/InputStream;", false);
+        mv.visitInsn(Opcodes.ARETURN);
+        mv.visitMaxs(2, 1);
+        mv.visitEnd();
+        cw.visitEnd();
+        Set<String> after = CompatFixtures.members(
+                new ClassRelocator(AndroidRemapper.RELOCATION, CompatLayers.SWING).remap(cw.toByteArray()));
+        assertEquals(after.toString(), 1, after.size());
+        assertTrue(after.contains("java/lang/Class.getResourceAsStream"));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/CompatStreamRewritesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/CompatStreamRewritesTest.java
new file mode 100644
index 00000000000..72ae57c1aa4
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/CompatStreamRewritesTest.java
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Streams through the remap: an application javac compiled against
+/// `java.util.stream` keeps every stream call as written, since the device's
+/// class library has the package under the JDK's name. It is run as it is
+/// and again after the remap -- the regular expressions it uses then on the
+/// framework's matcher -- and has to answer the same, and the compliance check
+/// runs over the remapped build in between, so every stream member it calls
+/// is held to what a device has.
+public class CompatStreamRewritesTest {
+
+    private static final String[] FIXTURE = {
+        "s/Bag.java",
+            "package s;\n"
+            + "import java.util.ArrayList;\n"
+            + "public class Bag<T> extends ArrayList<T> {\n"
+            + "}\n",
+        "s/Items.java",
+            "package s;\n"
+            + "import java.util.List;\n"
+            + "public interface Items<T> extends List<T> {\n"
+            + "}\n",
+        "s/ItemList.java",
+            "package s;\n"
+            + "import java.util.ArrayList;\n"
+            + "public class ItemList<T> extends ArrayList<T> implements Items<T> {\n"
+            + "}\n",
+        "s/Loud.java",
+            "package s;\n"
+            + "import java.util.ArrayList;\n"
+            + "import java.util.stream.Stream;\n"
+            + "public class Loud<T> extends ArrayList<T> {\n"
+            + "    public int calls;\n"
+            + "    @Override\n"
+            + "    public Stream<T> stream() {\n"
+            + "        calls++;\n"
+            + "        return super.stream().skip(1);\n"
+            + "    }\n"
+            + "}\n",
+        "s/Repo.java",
+            "package s;\n"
+            + "import java.util.stream.Stream;\n"
+            + "class Repo {\n"
+            + "    Stream<String> stream() {\n"
+            + "        return Stream.of(\"r1\", \"r2\");\n"
+            + "    }\n"
+            + "    protected Stream<String> parallelStream() {\n"
+            + "        return Stream.of(\"p1\");\n"
+            + "    }\n"
+            + "}\n",
+        "s/Source.java",
+            "package s;\n"
+            + "import java.util.stream.Stream;\n"
+            + "interface Source {\n"
+            + "    Stream<String> stream();\n"
+            + "}\n",
+        "s/Ui.java",
+            "package s;\n"
+            + "public class Ui {\n"
+            + "    public static Object label() {\n"
+            + "        return new javax.swing.JLabel(\"streams\");\n"
+            + "    }\n"
+            + "}\n",
+        "s/S.java",
+            "package s;\n"
+            + "import java.util.ArrayList;\n"
+            + "import java.util.Arrays;\n"
+            + "import java.util.Collection;\n"
+            + "import java.util.Comparator;\n"
+            + "import java.util.IntSummaryStatistics;\n"
+            + "import java.util.Iterator;\n"
+            + "import java.util.LinkedHashMap;\n"
+            + "import java.util.List;\n"
+            + "import java.util.Map;\n"
+            + "import java.util.Optional;\n"
+            + "import java.util.TreeMap;\n"
+            + "import java.util.function.Function;\n"
+            + "import java.util.function.Predicate;\n"
+            + "import java.util.function.Supplier;\n"
+            + "import java.util.stream.Collectors;\n"
+            + "import java.util.stream.IntStream;\n"
+            + "import java.util.stream.Stream;\n"
+            + "public class S {\n"
+            + "    public static Object[] run() {\n"
+            + "        List<Object> out = new ArrayList<>();\n"
+            + "        List<String> words = new ArrayList<>(Arrays.asList(\"pear\", \"apple\", \"fig\", \"banana\", \"apple\"));\n"
+            + "        out.add(words.stream().filter(w -> w.length() > 3).map(String::toUpperCase).collect(Collectors.toList()));\n"
+            + "        out.add(words.stream().collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.counting()))\n"
+            + "                .toString());\n"
+            + "        out.add(words.stream().mapToInt(String::length).sum());\n"
+            + "        Comparator<String> byLength = Comparator.comparingInt(String::length);\n"
+            + "        out.add(words.parallelStream().sorted(byLength.thenComparing(Comparator.<String>naturalOrder()))\n"
+            + "                .collect(Collectors.joining(\",\")));\n"
+            + "        out.add(words.stream().sorted(Comparator.<String>naturalOrder().reversed()).findFirst().get());\n"
+            + "        out.add(words.stream().max(byLength.thenComparing(Function.<String>identity())).get());\n"
+            + "        out.add(words.stream().sorted(Comparator.comparing(String::length, Comparator.<Integer>reverseOrder()))\n"
+            + "                .collect(Collectors.toList()));\n"
+            + "\n"
+            + "        out.add(Arrays.stream(new String[] {\"b\", \"a\"}).sorted().collect(Collectors.toList()));\n"
+            + "        out.add(Arrays.stream(new int[] {3, 4, 5}).map(n -> n * n).boxed().collect(Collectors.toList()));\n"
+            + "        out.add(Arrays.stream(new int[] {3, 4, 5}, 1, 3).sum());\n"
+            + "        out.add(Arrays.stream(new long[] {3L, 4L}).max().getAsLong());\n"
+            + "        out.add(Arrays.stream(new double[] {1.5, 2.5}).average().getAsDouble());\n"
+            + "        out.add(IntStream.rangeClosed(1, 5).mapToObj(Integer::toString).collect(Collectors.joining(\"+\")));\n"
+            + "        out.add(IntStream.range(0, 10).filter(n -> n % 3 == 0).boxed().collect(Collectors.toList()));\n"
+            + "        out.add(Stream.of(\"x\", \"y\").map(s -> s + s).collect(Collectors.toList()));\n"
+            + "        out.add(Stream.iterate(1, n -> n * 2).limit(6).reduce(0, Integer::sum));\n"
+            + "\n"
+            + "        // The method references: unbound on two interfaces, and bound.\n"
+            + "        Function<Collection<String>, Stream<String>> ofCollection = Collection::stream;\n"
+            + "        out.add(ofCollection.apply(words).count());\n"
+            + "        Function<List<String>, Stream<String>> ofList = List::stream;\n"
+            + "        out.add(ofList.apply(words).skip(3).findFirst().get());\n"
+            + "        Supplier<Stream<String>> bound = words::stream;\n"
+            + "        out.add(bound.get().distinct().count());\n"
+            + "        out.add(Stream.of(words, words).flatMap(Collection::stream).count());\n"
+            + "\n"
+            + "        // A class of the application's own that inherits stream().\n"
+            + "        Bag<String> bag = new Bag<>();\n"
+            + "        bag.addAll(words);\n"
+            + "        out.add(bag.stream().map(String::length).collect(Collectors.toList()));\n"
+            + "        out.add(bag.parallelStream().count());\n"
+            + "        Function<Bag<String>, Stream<String>> ofBag = Bag::stream;\n"
+            + "        out.add(ofBag.apply(bag).limit(2).collect(Collectors.toList()));\n"
+            + "        Items<String> items = new ItemList<>();\n"
+            + "        items.addAll(words);\n"
+            + "        out.add(items.stream().anyMatch(\"fig\"::equals));\n"
+            + "\n"
+            + "        // One that overrides it: reached through its own type and through\n"
+            + "        // List, and not by parallelStream(), which it left alone.\n"
+            + "        Loud<String> loud = new Loud<>();\n"
+            + "        loud.addAll(words);\n"
+            + "        out.add(loud.stream().collect(Collectors.toList()));\n"
+            + "        List<String> asList = loud;\n"
+            + "        out.add(asList.stream().collect(Collectors.toList()));\n"
+            + "        out.add(asList.parallelStream().collect(Collectors.toList()));\n"
+            + "        Collection<String> asCollection = loud;\n"
+            + "        out.add(asCollection.stream().count());\n"
+            + "        out.add(loud.calls);\n"
+            + "\n"
+            + "        // And classes that have a stream() without being collections.\n"
+            + "        Repo repo = new Repo();\n"
+            + "        out.add(repo.stream().collect(Collectors.joining(\"/\")));\n"
+            + "        out.add(repo.parallelStream().collect(Collectors.joining(\"/\")));\n"
+            + "        Source source = () -> Stream.of(\"lambda\");\n"
+            + "        out.add(source.stream().findFirst().get());\n"
+            + "\n"
+            + "        out.add(\"a,b;c\".split(\";\")[0]);\n"
+            + "        out.add(Arrays.asList(\"a1b22c333d\".split(\"[0-9]+\", 3)));\n"
+            + "        out.add(Arrays.asList(\" a  b \".split(\" \")));\n"
+            + "        Predicate<String> isShort = w -> w.length() < 4;\n"
+            + "        out.add(words.stream().filter(isShort.negate().and(w -> w.startsWith(\"a\")).or(w -> w.equals(\"fig\"))).count());\n"
+            + "        out.add(\"hello\".chars().filter(c -> c == 'l').count());\n"
+            + "        out.add(new StringBuilder(\"abc\").chars().sum());\n"
+            + "        out.add(words.stream().collect(Collectors.toMap(w -> w, String::length, Integer::sum, LinkedHashMap::new))\n"
+            + "                .toString());\n"
+            + "        Map<String, Integer> map = new TreeMap<>();\n"
+            + "        map.put(\"b\", 1);\n"
+            + "        map.put(\"a\", 2);\n"
+            + "        out.add(map.entrySet().stream().sorted(Map.Entry.comparingByValue()).map(Map.Entry::getKey)\n"
+            + "                .collect(Collectors.toList()));\n"
+            + "        out.add(map.keySet().stream().collect(Collectors.joining()));\n"
+            + "        out.add(map.values().stream().mapToInt(Integer::intValue).max().getAsInt());\n"
+            + "        out.add(words.stream().mapToDouble(String::length).average().getAsDouble());\n"
+            + "        Optional<String> longest = words.stream().max(byLength);\n"
+            + "        out.add(longest.map(String::length).orElse(-1));\n"
+            + "        Iterator<String> it = words.iterator();\n"
+            + "        it.next();\n"
+            + "        List<String> rest = new ArrayList<>();\n"
+            + "        it.forEachRemaining(rest::add);\n"
+            + "        out.add(rest);\n"
+            + "        out.add(words.stream().toArray(String[]::new).length);\n"
+            + "        IntSummaryStatistics stats = words.stream().mapToInt(String::length).summaryStatistics();\n"
+            + "        out.add(stats.getMax() + \"/\" + stats.getMin() + \"/\" + stats.getCount());\n"
+            + "        out.add(words.stream().collect(Collectors.partitioningBy(w -> w.length() > 4)).toString());\n"
+            + "        try {\n"
+            + "            words.stream().collect(Collectors.toMap(w -> w, String::length));\n"
+            + "            out.add(\"no exception\");\n"
+            + "        } catch (IllegalStateException e) {\n"
+            + "            out.add(\"duplicate\");\n"
+            + "        }\n"
+            + "        return out.toArray();\n"
+            + "    }\n"
+            + "}\n"
+    };
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    /// The fixture as javac wrote it.
+    private File compile() throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compile(tmp.newFolder(), classes, FIXTURE);
+        return classes;
+    }
+
+    /// The fixture remapped as a build remaps it -- the runtime extracted
+    /// beside it -- and passed by the compliance check.
+    private File remapped(File compiled) throws Exception {
+        scratch = tmp.newFolder("jars");
+        File classes = tmp.newFolder("classes");
+        SwingGallerySampleTest.copy(compiled, classes);
+        List<File> cp = new ArrayList<File>(Arrays.asList(RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch)));
+        assertTrue(new CompatRemapper(classes, cp, null, CompatRemapperTest.LOG).run());
+        // Throws on a single finding: a stream member the device's class
+        // library lacks is one.
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+        return classes;
+    }
+
+    private static Object[] run(ClassLoader loader) throws Exception {
+        try {
+            return (Object[]) loader.loadClass("s.S").getMethod("run").invoke(null);
+        } catch (InvocationTargetException e) {
+            throw e.getCause() instanceof Exception ? (Exception) e.getCause() : e;
+        }
+    }
+
+    private static byte[] read(File classes, String name) throws Exception {
+        return Files.readAllBytes(new File(classes, name).toPath());
+    }
+
+    @Test
+    public void aStreamingApplicationAnswersTheSameOnceRemapped() throws Exception {
+        File compiled = compile();
+        Object[] theirs;
+        URLClassLoader jdk = new URLClassLoader(new URL[] {compiled.toURI().toURL()},
+                ClassLoader.getSystemClassLoader().getParent());
+        try {
+            theirs = run(jdk);
+        } finally {
+            jdk.close();
+        }
+
+        File classes = remapped(compiled);
+        // The device's class library has java.util.stream under its own
+        // name, so the remap leaves every stream call as javac wrote it.
+        Set<String> members = CompatFixtures.members(read(classes, "s/S.class"));
+        assertTrue(members.toString(), members.contains("java/util/stream/Collectors.toList"));
+        assertTrue(members.toString(), members.contains("java/util/List.stream"));
+        // Nothing of this JVM's classpath but the JDK: the application, the
+        // runtime the remap put beside it, and the framework.
+        Object[] mine;
+        URLClassLoader device = new URLClassLoader(
+                new URL[] {classes.toURI().toURL(), RealCompatJars.core(scratch).toURI().toURL(),
+                    RealCompatJars.jdkHost(scratch).toURI().toURL()},
+                ClassLoader.getSystemClassLoader().getParent());
+        try {
+            mine = run(device);
+        } finally {
+            device.close();
+        }
+        assertEquals(Arrays.asList(theirs), Arrays.asList(mine));
+        assertEquals(49, mine.length);
+        // The override ran for its own type, for List and for Collection,
+        // and not for parallelStream().
+        assertEquals(Arrays.asList("apple", "fig", "banana", "apple"), mine[24]);
+        assertEquals(mine[24], mine[25]);
+        assertEquals(Arrays.asList("pear", "apple", "fig", "banana", "apple"), mine[26]);
+        assertEquals(Integer.valueOf(3), mine[28]);
+        assertEquals("r1/r2", mine[29]);
+        assertEquals("p1", mine[30]);
+        assertEquals("lambda", mine[31]);
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/ComplianceAlternativesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/ComplianceAlternativesTest.java
new file mode 100644
index 00000000000..56b6945fda8
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/ComplianceAlternativesTest.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The table of nearest alternatives: every class and member a row names
+/// has to exist in what an application is built against, and a lookup has to
+/// find the most specific row.
+public class ComplianceAlternativesTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    /// The public members of each public class of the jars an application
+    /// is built against, by the class's dotted name.
+    private Map<String, Set<String>> api() throws Exception {
+        File scratch = tmp.newFolder();
+        Map<String, Set<String>> out = new HashMap<String, Set<String>>();
+        for (File jar : new File[] {RealCompatJars.core(scratch), RealCompatJars.jar("java-runtime", scratch),
+            RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch)}) {
+            ZipFile zip = new ZipFile(jar);
+            try {
+                java.util.Enumeration<? extends ZipEntry> entries = zip.entries();
+                while (entries.hasMoreElements()) {
+                    ZipEntry e = entries.nextElement();
+                    if (!e.getName().endsWith(".class")) {
+                        continue;
+                    }
+                    final Set<String> members = new HashSet<String>();
+                    final boolean[] visible = new boolean[1];
+                    InputStream in = zip.getInputStream(e);
+                    try {
+                        new ClassReader(DependencyClassifier.readAll(in)).accept(new ClassVisitor(Opcodes.ASM9) {
+                            @Override
+                            public void visit(int version, int access, String name, String signature,
+                                              String superName, String[] interfaces) {
+                                visible[0] = (access & Opcodes.ACC_PUBLIC) != 0;
+                            }
+
+                            @Override
+                            public MethodVisitor visitMethod(int access, String name, String descriptor,
+                                                             String signature, String[] exceptions) {
+                                if ((access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) != 0) {
+                                    members.add(name);
+                                }
+                                return null;
+                            }
+
+                            @Override
+                            public FieldVisitor visitField(int access, String name, String descriptor,
+                                                           String signature, Object value) {
+                                if ((access & Opcodes.ACC_PUBLIC) != 0) {
+                                    members.add(name);
+                                }
+                                return null;
+                            }
+                        }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+                    } finally {
+                        in.close();
+                    }
+                    if (visible[0]) {
+                        String name = e.getName().substring(0, e.getName().length() - ".class".length());
+                        out.put(name.replace('/', '.').replace('$', '.'), members);
+                    }
+                }
+            } finally {
+                zip.close();
+            }
+        }
+        return out;
+    }
+
+    @Test
+    public void everyRowNamesSomethingThatExists() throws Exception {
+        Map<String, Set<String>> api = api();
+        List<String> missing = new ArrayList<String>();
+        assertTrue("The table was read", ComplianceAlternatives.rows().size() > 50);
+        for (ComplianceAlternatives.Row row : ComplianceAlternatives.rows()) {
+            for (String reference : row.references()) {
+                int hash = reference.indexOf('#');
+                String cls = hash < 0 ? reference : reference.substring(0, hash);
+                Set<String> members = api.get(cls);
+                if (members == null) {
+                    missing.add(row.prefix() + " names the class " + cls + ", which is not there");
+                } else if (hash >= 0 && !members.contains(reference.substring(hash + 1))) {
+                    missing.add(row.prefix() + " names " + reference + ", and " + cls + " has no such member");
+                }
+            }
+        }
+        assertTrue(missing.toString().replace(", ", "\n"), missing.isEmpty());
+    }
+
+    /// Advice is prose, and prose can name a class its row does not list.
+    /// Every `com.codename1...` name in the text has to be among the row's
+    /// references, so that the check above covers it.
+    @Test
+    public void adviceNamesOnlyWhatTheRowLists() {
+        java.util.regex.Pattern name = java.util.regex.Pattern.compile("com\\.codename1(\\.[a-z0-9]+)*\\.[A-Z]\\w*");
+        for (ComplianceAlternatives.Row row : ComplianceAlternatives.rows()) {
+            java.util.regex.Matcher m = name.matcher(row.advice());
+            while (m.find()) {
+                boolean listed = false;
+                for (String reference : row.references()) {
+                    listed |= reference.equals(m.group()) || reference.startsWith(m.group() + "#");
+                }
+                assertTrue(row.prefix() + " advises " + m.group() + " without listing it", listed);
+            }
+        }
+    }
+
+    @Test
+    public void aRowCoversThePrefixAndNothingBesideIt() {
+        // A package covers everything in it.
+        assertTrue(ComplianceAlternatives.lookup("java.sql.Connection.prepareStatement").contains("Database"));
+        // A class covers itself, its members and its nested classes...
+        assertTrue(ComplianceAlternatives.lookup("java.lang.ProcessBuilder").contains("CN.execute"));
+        assertTrue(ComplianceAlternatives.lookup("java.lang.ProcessBuilder.start").contains("CN.execute"));
+        assertTrue(ComplianceAlternatives.lookup("java.lang.ProcessBuilder.Redirect").contains("CN.execute"));
+        // ...and not a class whose name merely starts the same way.
+        assertEquals("java.lang.ProcessHandle", ComplianceAlternatives.row("java.lang.ProcessHandle").prefix());
+        assertNull(ComplianceAlternatives.lookup("java.lang.Processor"));
+        // A member covers the members that start with it, and no other.
+        assertNotNull(ComplianceAlternatives.lookup("java.lang.Class.getDeclaredFields"));
+        assertNull(ComplianceAlternatives.lookup("java.lang.Class.getName"));
+        assertNull(ComplianceAlternatives.lookup("java.lang.Runtime.availableProcessors"));
+        assertNull(ComplianceAlternatives.lookup("java.lang.String.length"));
+        assertNull(ComplianceAlternatives.lookup(null));
+    }
+
+    @Test
+    public void theMostSpecificRowWins() {
+        assertEquals("java.nio.file.WatchService", ComplianceAlternatives.row("java.nio.file.WatchService.take")
+                .prefix());
+        assertEquals("java.nio.file.", ComplianceAlternatives.row("java.nio.file.Files.readString").prefix());
+        assertEquals("java.security.MessageDigest", ComplianceAlternatives.row("java.security.MessageDigest.digest")
+                .prefix());
+        assertEquals("java.security.", ComplianceAlternatives.row("java.security.KeyFactory").prefix());
+    }
+
+    /// What the package asks the table to cover at the least.
+    @Test
+    public void theGapsADesktopApplicationHitsAllHaveARow() {
+        for (String api : new String[] {"java.lang.ProcessBuilder", "java.lang.Runtime.exec",
+            "java.net.http.HttpClient", "java.net.HttpURLConnection", "java.net.Socket",
+            "java.nio.file.WatchService", "java.lang.reflect.Method.invoke", "java.io.ObjectOutputStream",
+            "javax.crypto.Cipher", "java.security.MessageDigest", "java.sql.DriverManager",
+            "java.util.prefs.Preferences", "java.lang.Thread.sleep", "java.awt.Robot", "java.awt.SystemTray",
+            "java.awt.Taskbar", "java.awt.print.PrinterJob", "java.awt.dnd.DropTarget", "javax.swing.JEditorPane",
+            "java.lang.Class.getResource", "com.fasterxml.jackson.databind.ObjectMapper"}) {
+            assertNotNull(api, ComplianceAlternatives.lookup(api));
+        }
+    }
+
+    @Test
+    public void aLineThatIsNoRowIsAnError() {
+        assertEquals(1, ComplianceAlternatives.parse("# note\n\na.b. | | No equivalent.\n").size());
+        try {
+            ComplianceAlternatives.parse("a.b. | No equivalent.\n");
+            fail("Two columns are not a row");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains(":1:"));
+        }
+        try {
+            ComplianceAlternatives.parse("a.b. | x.Y |\n");
+            fail("A row without advice says nothing");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("required"));
+        }
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/ComplianceFindingsTest.java b/maven/build-engine/src/test/java/com/codename1/maven/ComplianceFindingsTest.java
new file mode 100644
index 00000000000..a476cfb23e6
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/ComplianceFindingsTest.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/// How the compliance check's findings are grouped: by where they are, by
+/// what kind of API they are about, and each API once.
+public class ComplianceFindingsTest {
+
+    private static ComplianceFindings sample() {
+        ComplianceFindings f = new ComplianceFindings();
+        // The application: one JDK API used three times in two files...
+        f.add(null, "com/acme/Git.java", 40, "java/lang/ProcessBuilder", "java.lang.ProcessBuilder.start()",
+                "java.lang.ProcessBuilder.start");
+        f.add(null, "com/acme/Git.java", 12, "java/lang/ProcessBuilder", "java.lang.ProcessBuilder.start()",
+                "java.lang.ProcessBuilder.start");
+        f.add(null, "com/acme/Diff.java", 7, "java/lang/ProcessBuilder", "java.lang.ProcessBuilder.start()",
+                "java.lang.ProcessBuilder.start");
+        // ...a second of another family, a toolkit class and a record.
+        f.add(null, "com/acme/Git.java", 50, "java/nio/file/Files", "java.nio.file.Files.readString(Path)",
+                "java.nio.file.Files.readString");
+        f.add(null, "com/acme/Main.java", 9, "java/awt/Robot", "java.awt.Robot", null);
+        f.addLanguage(null, "com/acme/Point.java", 0, "records (java.lang.runtime.ObjectMethods)", "Write a class.");
+        // Two libraries, the smaller one first.
+        f.add("small-1.jar", "org/small/A.class", 0, "java/net/Socket", "java.net.Socket", null);
+        f.add("big-2.jar", "org/big/A.class", 3, "java/net/Socket", "java.net.Socket", null);
+        f.add("big-2.jar", "org/big/B.class", 0, "java/lang/reflect/Method", "java.lang.reflect.Method.invoke()",
+                "java.lang.reflect.Method.invoke");
+        f.add("big-2.jar", "org/big/B.class", 0, "org/missing/Thing", "org.missing.Thing", null);
+        return f;
+    }
+
+    @Test
+    public void everyApiIsListedOnceWithItsUses() {
+        ComplianceFindings f = sample();
+        assertEquals(10, f.total());
+        // java.net.Socket is one API although two libraries use it.
+        assertEquals(7, f.apiCount());
+        ComplianceFindings.Source app = f.application();
+        assertNull(app.library());
+        assertEquals(6, app.callSites());
+        assertEquals(4, app.apiCount());
+
+        List<ComplianceFindings.Api> jdk = app.apis(ComplianceFindings.Category.JDK);
+        assertEquals(2, jdk.size());
+        // The most used first.
+        ComplianceFindings.Api start = jdk.get(0);
+        assertEquals("java.lang.ProcessBuilder.start()", start.name());
+        assertEquals(3, start.count());
+        assertEquals("processes", start.family());
+        assertNotNull(start.alternative());
+        assertEquals("com/acme/Diff.java:7; com/acme/Git.java:12, 40", ComplianceFindings.locations(start.uses(), 12));
+        assertEquals("com/acme/Diff.java:7; com/acme/Git.java:12; and 1 more",
+                ComplianceFindings.locations(start.uses(), 2));
+        assertEquals("files", jdk.get(1).family());
+
+        assertEquals(1, app.apis(ComplianceFindings.Category.TOOLKIT).size());
+        assertEquals(1, app.apis(ComplianceFindings.Category.LANGUAGE).size());
+        assertEquals("Write a class.", app.apis(ComplianceFindings.Category.LANGUAGE).get(0).alternative());
+        assertTrue(app.apis(ComplianceFindings.Category.LIBRARY).isEmpty());
+        assertEquals(4, app.callSites(ComplianceFindings.Category.JDK));
+        // What to change, by the file it is in.
+        assertEquals("[com/acme/Diff.java, com/acme/Git.java, com/acme/Main.java, com/acme/Point.java]",
+                app.byFile().keySet().toString());
+        assertEquals(2, app.byFile().get("com/acme/Git.java").size());
+    }
+
+    @Test
+    public void theApplicationComesFirstAndThenTheLibrariesByFindings() {
+        ComplianceFindings f = sample();
+        assertEquals(3, f.sources().size());
+        assertNull(f.sources().get(0).library());
+        assertEquals("big-2.jar", f.libraries().get(0).library());
+        assertEquals("small-1.jar", f.libraries().get(1).library());
+        assertEquals(1, f.libraries().get(0).apis(ComplianceFindings.Category.LIBRARY).size());
+
+        // A source without findings is not listed.
+        ComplianceFindings onlyLibrary = new ComplianceFindings();
+        assertTrue(onlyLibrary.isEmpty());
+        onlyLibrary.add("small-1.jar", "org/small/A.class", 0, "java/net/Socket", "java.net.Socket", null);
+        assertEquals(1, onlyLibrary.sources().size());
+    }
+
+    @Test
+    public void aClassIsFiledByWhatItIs() {
+        assertEquals(ComplianceFindings.Category.TOOLKIT, ComplianceFindings.categoryOf("javax/swing/JTable"));
+        assertEquals(ComplianceFindings.Category.TOOLKIT, ComplianceFindings.categoryOf("javafx/scene/web/WebView"));
+        assertEquals(ComplianceFindings.Category.UI_LIBRARY, ComplianceFindings.categoryOf("org/jdesktop/swingx/JXTable"));
+        assertEquals(ComplianceFindings.Category.JDK, ComplianceFindings.categoryOf("java/sql/Connection"));
+        assertEquals(ComplianceFindings.Category.JDK, ComplianceFindings.categoryOf("sun/misc/Unsafe"));
+        assertEquals(ComplianceFindings.Category.LIBRARY, ComplianceFindings.categoryOf("com/sun/jna/Native"));
+        assertEquals(ComplianceFindings.Category.LIBRARY, ComplianceFindings.categoryOf("org/slf4j/Logger"));
+        assertEquals(ComplianceFindings.Category.OTHER, ComplianceFindings.categoryOf(null));
+
+        assertEquals("serialization", ComplianceFindings.familyOf(ComplianceFindings.Category.JDK,
+                "java/io/ObjectOutputStream"));
+        assertEquals("files and streams", ComplianceFindings.familyOf(ComplianceFindings.Category.JDK,
+                "java/io/FileChannel"));
+        assertEquals("security and crypto", ComplianceFindings.familyOf(ComplianceFindings.Category.JDK,
+                "javax/crypto/Cipher"));
+        assertEquals("org.slf4j", ComplianceFindings.familyOf(ComplianceFindings.Category.LIBRARY,
+                "org/slf4j/Logger"));
+        assertEquals("org.apache.commons", ComplianceFindings.familyOf(ComplianceFindings.Category.LIBRARY,
+                "org/apache/commons/io/FileUtils"));
+    }
+
+    @Test
+    public void theConsoleGetsOneLineForEachSourceAndCategory() {
+        assertEquals("10 references to 7 APIs a device does not have:\n"
+                + "  The application: 6 call sites, 4 APIs\n"
+                + "    Swing, AWT and JavaFX API the compatibility layers lack: 1 API, 1 call site -- java.awt.Robot 1\n"
+                + "    JDK API a device lacks: 2 APIs, 4 call sites -- processes 3, files 1\n"
+                + "    Language features a device cannot run: 1 API, 1 call site -- "
+                + "records (java.lang.runtime.ObjectMethods) 1\n"
+                + "  big-2.jar: 3 call sites, 3 APIs -- networking 1, org.missing 1, reflection 1\n"
+                + "  small-1.jar: 1 call site, 1 API -- networking 1", sample().summary());
+    }
+
+    @Test
+    public void theFileNamesEachApiOnceWithWhereAndWhatInstead() {
+        String report = sample().report();
+        assertTrue(report, report.startsWith("The application: 6 call sites of 4 missing APIs\n"
+                + "==============================================="));
+        assertTrue(report, report.contains("\nJDK API a device lacks (2 APIs, 4 call sites)\n"
+                + "  by family: processes 3, files 1\n"
+                + "\n"
+                + "  3 x java.lang.ProcessBuilder.start()\n"
+                + "      com/acme/Diff.java:7; com/acme/Git.java:12, 40\n"
+                + "      Instead: "));
+        assertTrue(report, report.contains("\nbig-2.jar: 3 call sites of 3 missing APIs\n"));
+        assertTrue(report, report.contains("  1 x org.missing.Thing\n      org/big/B.class\n"));
+        assertEquals("Each API of a source is listed once", report.indexOf("x java.lang.ProcessBuilder.start()"),
+                report.lastIndexOf("x java.lang.ProcessBuilder.start()"));
+        assertTrue("The application comes before any library",
+                report.indexOf("The application:") < report.indexOf("big-2.jar:"));
+        assertTrue(report.indexOf("big-2.jar:") < report.indexOf("small-1.jar:"));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/DependencyClassifierTest.java b/maven/build-engine/src/test/java/com/codename1/maven/DependencyClassifierTest.java
new file mode 100644
index 00000000000..a6b129f3844
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/DependencyClassifierTest.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.TreeSet;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/// What a dependency jar is taken for, from its classes alone, and which of
+/// its classes an application reaches.
+public class DependencyClassifierTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private static final List<Relocation> LAYERS = Arrays.asList(CompatLayers.SWING, CompatLayers.JAVAFX);
+
+    /// A class `name` that calls a static method of each of `uses` and holds
+    /// each of `strings` as a constant.
+    static byte[] cls(String name, String[] uses, String... strings) {
+        return cls(Opcodes.V1_8, name, uses, strings);
+    }
+
+    static byte[] cls(int version, String name, String[] uses, String... strings) {
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(version, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "run", "()V", null, null);
+        mv.visitCode();
+        for (String use : uses) {
+            mv.visitMethodInsn(Opcodes.INVOKESTATIC, use, "run", "()V", false);
+        }
+        for (String s : strings) {
+            mv.visitLdcInsn(s);
+            mv.visitInsn(Opcodes.POP);
+        }
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    static String[] uses(String... names) {
+        return names;
+    }
+
+    /// A jar of `count` classes `prefix0`..., the first `toolkit` of which
+    /// name `javax/swing/JPanel`.
+    private File jar(String name, String prefix, int count, int toolkit, Object... extra) throws Exception {
+        List<Object> entries = new ArrayList<Object>();
+        for (int i = 0; i < count; i++) {
+            entries.add(prefix + i + ".class");
+            entries.add(cls(prefix + i, i < toolkit ? uses("javax/swing/JPanel") : uses()));
+        }
+        entries.addAll(Arrays.asList(extra));
+        return CompatRemapperTest.jar(new File(tmp.newFolder(), name), entries.toArray());
+    }
+
+    private DependencyClassifier.Library one(File jar) throws Exception {
+        List<DependencyClassifier.Library> out = DependencyClassifier.classify(Collections.singletonList(jar), LAYERS);
+        assertEquals(1, out.size());
+        return out.get(0);
+    }
+
+    @Test
+    public void theShareOfToolkitClassesDecidesWhatALibraryIs() throws Exception {
+        DependencyClassifier.Library pure = one(jar("pure.jar", "org/pure/C", 10, 0));
+        assertEquals(DependencyClassifier.Kind.PURE_JAVA, pure.kind());
+        assertEquals(10, pure.classCount());
+        assertEquals(0, pure.toolkitClassCount());
+        assertEquals("org.pure", pure.mainPackage());
+
+        DependencyClassifier.Library incidental = one(jar("incidental.jar", "org/inc/C", 10, 1));
+        assertEquals(DependencyClassifier.Kind.INCIDENTAL_TOOLKIT, incidental.kind());
+        assertEquals(1, incidental.toolkitClassCount());
+
+        // The threshold itself is a toolkit library; one class under it is not.
+        assertEquals(DependencyClassifier.Kind.UI_LIBRARY, one(jar("ui.jar", "org/ui/C", 10, 2)).kind());
+        assertEquals(DependencyClassifier.Kind.INCIDENTAL_TOOLKIT, one(jar("almost.jar", "org/ui/C", 11, 2)).kind());
+    }
+
+    @Test
+    public void aJarOfALayersOwnPackagesIsProvidedByTheLayer() throws Exception {
+        DependencyClassifier.Library fx = one(jar("javafx-controls.jar", "javafx/scene/control/C", 4, 0));
+        assertEquals(DependencyClassifier.Kind.LAYER_PROVIDED, fx.kind());
+        assertEquals(CompatLayers.JAVAFX.name(), fx.layer());
+        assertFalse("Nothing of it ever ships", fx.shipped().contains("javafx/scene/control/C0"));
+        // A pure-Java library names no layer.
+        assertNull(one(jar("pure.jar", "org/pure/C", 2, 0)).layer());
+    }
+
+    @Test
+    public void whatTheBuildHandlesItselfIsThePlatforms() throws Exception {
+        DependencyClassifier.Library kotlin = one(jar("kotlin-stdlib.jar", "kotlin/C", 3, 0));
+        assertEquals(DependencyClassifier.Kind.PLATFORM, kotlin.kind());
+        assertEquals("Kotlin runtime", kotlin.platform());
+        assertFalse(kotlin.managed());
+
+        DependencyClassifier.Library core = one(jar("codenameone-core.jar", "com/codename1/ui/C", 3, 0));
+        assertEquals(DependencyClassifier.Kind.PLATFORM, core.kind());
+
+        File cn1lib = CompatRemapperTest.jar(new File(tmp.newFolder(), "some-cn1lib.jar"), "org/lib/Maps.class",
+                cls("org/lib/Maps", uses("com/codename1/ui/Display")));
+        assertEquals("Codename One library", one(cn1lib).platform());
+
+        File resources = CompatRemapperTest.jar(new File(tmp.newFolder(), "icons.jar"), "icons/a.png", new byte[] {1},
+                "META-INF/versions/9/module-info.class", new byte[] {1});
+        assertEquals(DependencyClassifier.Kind.NO_CLASSES, one(resources).kind());
+        assertFalse(one(resources).managed());
+    }
+
+    @Test
+    public void nativeCodeIsFoundThreeWays() throws Exception {
+        assertEquals("ships native libraries", one(jar("a.jar", "org/a/C", 2, 0, "win32-x86-64/a.dll",
+                new byte[] {1})).nativeCode());
+        assertEquals("calls native code through JNA", one(CompatRemapperTest.jar(new File(tmp.newFolder(), "b.jar"),
+                "org/b/C.class", cls("org/b/C", uses("com/sun/jna/Native")))).nativeCode());
+        assertNull(one(jar("c.jar", "org/c/C", 2, 0)).nativeCode());
+
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "org/d/C", null, "java/lang/Object", null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
+        mv.visitCode();
+        mv.visitLdcInsn("d");
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "loadLibrary", "(Ljava/lang/String;)V", false);
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+        assertEquals("loads native code", one(CompatRemapperTest.jar(new File(tmp.newFolder(), "d.jar"),
+                "org/d/C.class", cw.toByteArray())).nativeCode());
+    }
+
+    @Test
+    public void onlyWhatIsReachedShipsOfAPureJavaLibrary() throws Exception {
+        File pure = CompatRemapperTest.jar(new File(tmp.newFolder(), "pure.jar"),
+                "org/pure/A.class", cls("org/pure/A", uses("org/pure/B")),
+                "org/pure/B.class", cls("org/pure/B", uses(), "org.pure.ByName", "not a class name"),
+                "org/pure/ByName.class", cls("org/pure/ByName", uses("org/other/X")),
+                "org/pure/Unused.class", cls("org/pure/Unused", uses("org/pure/A")));
+        File other = CompatRemapperTest.jar(new File(tmp.newFolder(), "other.jar"),
+                "org/other/X.class", cls("org/other/X", uses()),
+                "org/other/Y.class", cls("org/other/Y", uses()));
+        File ui = jar("ui.jar", "org/ui/C", 5, 5);
+        File never = jar("never.jar", "org/never/C", 3, 0);
+        List<DependencyClassifier.Library> libs = DependencyClassifier.classify(Arrays.asList(pure, other, ui, never),
+                LAYERS);
+
+        // Four classes by reference and the one the toolkit library was entered through.
+        assertEquals(5, DependencyClassifier.reach(Arrays.asList("org/pure/A", "org.ui.C3", "java/lang/String"),
+                libs));
+        // A is used, B through A, ByName through the string B loads it by, and
+        // through ByName a class of another jar.
+        assertEquals(new TreeSet<String>(Arrays.asList("org/pure/A", "org/pure/B", "org/pure/ByName")),
+                libs.get(0).shipped());
+        assertEquals(Collections.singleton("org/other/X"), libs.get(1).shipped());
+        // A toolkit library that is reached at all ships whole.
+        assertEquals(5, libs.get(2).shipped().size());
+        assertTrue(libs.get(3).shipped().isEmpty());
+        assertTrue(libs.get(3).managed());
+    }
+
+    @Test
+    public void theFirstJarOnTheClassPathOwnsAClassTwoHold() throws Exception {
+        File first = CompatRemapperTest.jar(new File(tmp.newFolder(), "first.jar"), "org/dup/A.class",
+                cls("org/dup/A", uses()));
+        File second = CompatRemapperTest.jar(new File(tmp.newFolder(), "second.jar"), "org/dup/A.class",
+                cls("org/dup/A", uses()));
+        List<DependencyClassifier.Library> libs = DependencyClassifier.classify(Arrays.asList(first, second, first,
+                new File("no-such.jar")), LAYERS);
+        assertEquals("A jar is read once, and a missing one not at all", 2, libs.size());
+        DependencyClassifier.reach(Collections.singleton("org/dup/A"), libs);
+        assertEquals(1, libs.get(0).shipped().size());
+        assertTrue(libs.get(1).shipped().isEmpty());
+    }
+
+    @Test
+    public void anApplicationsClassesAndSourcesBothSeedTheWalk() throws Exception {
+        File pure = CompatRemapperTest.jar(new File(tmp.newFolder(), "pure.jar"),
+                "org/pure/A.class", cls("org/pure/A", uses()),
+                "org/pure/util/B.class", cls("org/pure/util/B", uses()),
+                "org/pure/util/C.class", cls("org/pure/util/C", uses()),
+                "org/pure/D.class", cls("org/pure/D", uses()));
+        File classes = tmp.newFolder();
+        File main = new File(classes, "com/acme/Main.class");
+        assertTrue(main.getParentFile().mkdirs());
+        Files.write(main.toPath(), cls("com/acme/Main", uses("org/pure/A")));
+        File unpacked = new File(classes, "org/pure/D.class");
+        assertTrue(unpacked.getParentFile().mkdirs());
+        Files.write(unpacked.toPath(), cls("org/pure/D", uses("org/pure/util/B")));
+
+        // What an earlier run unpacked is not the application speaking.
+        java.util.Set<String> refs = DependencyClassifier.applicationReferences(classes,
+                Collections.singleton("org/pure/D.class"), LAYERS);
+        assertTrue(refs.toString(), refs.contains("org/pure/A"));
+        assertFalse(refs.toString(), refs.contains("org/pure/util/B"));
+
+        File sources = tmp.newFolder();
+        Files.write(new File(sources, "Main.java").toPath(), ("package com.acme;\n"
+                + "import org.pure.A;\n"
+                + "import static org.pure.D.run;\n"
+                + "import org.pure.util.*;\n"
+                + "class Main { }\n").getBytes("UTF-8"));
+        List<DependencyClassifier.Library> libs = DependencyClassifier.classify(Collections.singletonList(pure),
+                LAYERS);
+        DependencyClassifier.reach(DependencyClassifier.sourceReferences(sources, libs), libs);
+        assertEquals(new TreeSet<String>(Arrays.asList("org/pure/A", "org/pure/D", "org/pure/util/B",
+                "org/pure/util/C")), libs.get(0).shipped());
+    }
+
+    /// Two libraries share a file name when they share an artifact id and a
+    /// version; they are still two libraries.
+    @Test
+    public void twoJarsOfOneFileNameAreTwoLibraries() throws Exception {
+        File ui = CompatRemapperTest.jar(new File(tmp.newFolder(), "common-1.0.jar"), "com/acme/ui/A.class",
+                cls("com/acme/ui/A", uses()));
+        File data = CompatRemapperTest.jar(new File(tmp.newFolder(), "common-1.0.jar"), "com/acme/data/B.class",
+                cls("com/acme/data/B", uses()));
+        // The same jar again: as it is, and as a build that stages its
+        // dependencies copies it.
+        File staged = new File(tmp.newFolder(), "common-1.0.jar");
+        Files.copy(ui.toPath(), staged.toPath());
+        List<DependencyClassifier.Library> libs = DependencyClassifier.classify(Arrays.asList(ui, data, ui, staged,
+                data), LAYERS);
+        assertEquals(2, libs.size());
+        DependencyClassifier.reach(new java.util.HashSet<String>(Arrays.asList("com/acme/ui/A", "com/acme/data/B")),
+                libs);
+        assertEquals(Collections.singleton("com/acme/ui/A"), libs.get(0).shipped());
+        assertEquals("The second jar's classes ship too", Collections.singleton("com/acme/data/B"),
+                libs.get(1).shipped());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/DesktopCompatScenesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/DesktopCompatScenesTest.java
new file mode 100644
index 00000000000..699c7ddc322
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/DesktopCompatScenesTest.java
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.fxml.DesktopResourceCompiler;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// The desktop compatibility screens of the screenshot suite
+/// (`scripts/hellocodenameone/common/src/main/desktop`), taken through what
+/// that application's build does to them and then SHOWN, without a device.
+///
+/// The screens are Swing, SwingX and JavaFX code in an application whose
+/// main class is a plain Codename One one that extends neither desktop
+/// lifecycle: library mode. Here the FXML document and the style sheet are
+/// compiled, the sources are compiled by javac against the JDK's Swing, the
+/// real SwingX jar and the layers' jars, the remap relocates them and leaves
+/// the main class as javac wrote it, and the compliance check has to find
+/// nothing. The result is
+/// loaded into a class loader that holds nothing but those classes, the
+/// framework and the headless implementation. There every scene builder the
+/// device tests call is called, its component is put in a form of the
+/// application and painted once, and the two modal dialogs are painted
+/// while open and answered from a timer, as the device tests answer them.
+///
+/// What a device adds to this is pixels, which is what the screenshot
+/// tests are for; an exception, a scene that draws nothing or a blocking
+/// call that returns the wrong answer is caught here.
+public class DesktopCompatScenesTest {
+
+    private static final String PACKAGE = "com.codenameone.examples.hellocodenameone.desktop.";
+    private static final String HOST_MAIN = "com.acme.host.HostApp";
+
+    /// Scenes class, builder method, and one string the scene draws.
+    private static final String[][] SCENES = {
+        {"SwingScenes", "controls", "Remember me"},
+        {"SwingScenes", "tables", "Jupiter"},
+        {"SwingScenes", "trees", "Jupiter  -  95 moons"},
+        {"SwingScenes", "painting", "Graphics2D"},
+        {"SwingScenes", "containers", "Owner: Ada Lovelace"},
+        {"SwingScenes", "swingx", "File tasks"},
+        {"FxScenes", "controls", "Remember me"},
+        {"FxScenes", "data", "Jupiter  -  95 moons"},
+        {"FxScenes", "shapes", "Canvas"},
+        {"FxScenes", "fxml", "Loaded by the controller"},
+        {"FxScenes", "panes", "Tile 7"},
+    };
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    /// The desktop source directory of the screenshot application, found
+    /// from this module's.
+    private static File desktop() {
+        File at = new File("").getAbsoluteFile();
+        for (int depth = 0; at != null && depth < 6; depth++) {
+            File candidate = new File(at, "scripts/hellocodenameone/common/src/main/desktop");
+            if (candidate.isDirectory()) {
+                return candidate;
+            }
+            at = at.getParentFile();
+        }
+        throw new AssertionError("scripts/hellocodenameone/common/src/main/desktop was not found above "
+                + new File("").getAbsolutePath());
+    }
+
+    private static void sources(File dir, String rel, List<String> out) throws Exception {
+        File[] files = dir.listFiles();
+        assertNotNull(dir.toString(), files);
+        Arrays.sort(files);
+        for (File f : files) {
+            if (f.isDirectory()) {
+                sources(f, rel + f.getName() + "/", out);
+            } else if (f.getName().endsWith(".java")) {
+                out.add(rel + f.getName());
+                out.add(new String(Files.readAllBytes(f.toPath()), "UTF-8"));
+            }
+        }
+    }
+
+    private static void copy(File from, File to) throws Exception {
+        File[] files = from.listFiles();
+        assertNotNull(from.toString(), files);
+        for (File f : files) {
+            File target = new File(to, f.getName());
+            if (f.isDirectory()) {
+                assertTrue(target.isDirectory() || target.mkdirs());
+                copy(f, target);
+            } else {
+                Files.write(target.toPath(), Files.readAllBytes(f.toPath()));
+            }
+        }
+    }
+
+    /// Compiles and remaps the screens; answers the classes directory.
+    private File build() throws Exception {
+        scratch = tmp.newFolder("jars");
+        File swingx = RealCompatJars.jar("swingx-all", scratch);
+        List<File> jars = new ArrayList<File>(Arrays.asList(RealCompatJars.swing(scratch),
+                RealCompatJars.javafx(scratch), RealCompatJars.core(scratch)));
+
+        // prepare-desktop-sources: the style sheet becomes a table. The FXML
+        // document is only recorded here; the remap below compiles it,
+        // against the compiled screens.
+        File resources = new File(desktop(), "resources");
+        File javaOut = tmp.newFolder();
+        File resourcesOut = tmp.newFolder();
+        final List<String> warnings = new ArrayList<String>();
+        List<String> errors = new DesktopResourceCompiler(Collections.singletonList(resources), javaOut,
+                resourcesOut, new DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                        warnings.add(message);
+                    }
+                }).run();
+        assertTrue(errors.toString(), errors.isEmpty());
+        assertTrue("The style sheet and the document use only what the layer has: " + warnings,
+                warnings.isEmpty());
+
+        // javac: the screens, what was generated from the document, and the
+        // main class the application has of its own.
+        List<String> all = new ArrayList<String>(Arrays.asList("com/acme/host/HostApp.java",
+                "package com.acme.host;\npublic class HostApp {\n    public void init(Object context) { }\n"
+                + "    public void start() { }\n    public void stop() { }\n    public void destroy() { }\n}\n"));
+        sources(new File(desktop(), "java"), "", all);
+        sources(javaOut, "", all);
+        File classes = tmp.newFolder("classes");
+        List<File> compile = new ArrayList<File>(jars);
+        compile.add(swingx);
+        CompatFixtures.compileAgainst(compile, tmp.newFolder(), classes, all.toArray(new String[all.size()]));
+        copy(resources, classes);
+        copy(resourcesOut, classes);
+
+        // The remap. Nothing in it depends on whether the application is a
+        // desktop one or uses the screens as a library; its main class says.
+        List<File> cp = new ArrayList<File>(jars);
+        cp.add(swingx);
+        assertTrue(new CompatRemapper(classes, cp, null, CompatRemapperTest.LOG)
+                .withResourceDirectories(Arrays.asList(resources, resourcesOut))
+                .withApplicationLibraries(Collections.<File>emptyList()).run());
+        assertTrue(new File(classes, "com/codename1/desktopcompat/SwingInterop.class").isFile());
+        assertTrue(new File(classes, "com/codename1/fxcompat/FxInterop.class").isFile());
+
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        host.artifacts.add(new com.codename1.build.BuildArtifact("org.swinglabs.swingx", "swingx-all", "1", null,
+                "jar", "provided", swingx, null));
+        // Throws on a single finding, in the screens or in either runtime.
+        new BytecodeCompliance(host).execute();
+        return classes;
+    }
+
+    private static Object call(Object target, String name, Object... args) throws Exception {
+        return invoke(target.getClass(), target, name, args);
+    }
+
+    private static Object invoke(Class<?> type, Object target, String name, Object... args) throws Exception {
+        for (Method m : type.getMethods()) {
+            if (m.getName().equals(name) && m.getParameterTypes().length == args.length) {
+                m.setAccessible(true);
+                try {
+                    return m.invoke(target, args);
+                } catch (IllegalArgumentException e) {
+                    // An overload with as many parameters of other types.
+                    continue;
+                } catch (InvocationTargetException e) {
+                    Throwable cause = e.getCause();
+                    if (cause instanceof Exception) {
+                        throw (Exception) cause;
+                    }
+                    throw e;
+                }
+            }
+        }
+        throw new AssertionError(type.getName() + " has no public " + name + " with " + args.length + " arguments");
+    }
+
+    private interface ThrowingRunnable {
+        void run() throws Exception;
+    }
+
+    /// Runs `work` on the event dispatch thread and rethrows what it threw.
+    private static void onEdt(Object display, final ThrowingRunnable work) throws Exception {
+        final Throwable[] failure = new Throwable[1];
+        call(display, "callSeriallyAndWait", new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    work.run();
+                } catch (Throwable t) {
+                    failure[0] = t;
+                }
+            }
+        });
+        if (failure[0] instanceof Error) {
+            throw (Error) failure[0];
+        }
+        if (failure[0] != null) {
+            throw new Exception("On the event dispatch thread: " + failure[0], failure[0]);
+        }
+    }
+
+    /// Paints `form` into an image the size of the display and answers every
+    /// string that was drawn.
+    private static List<String> paint(ClassLoader loader, Object form) throws Exception {
+        Class<?> headless = loader.loadClass("com.codename1.compat.testing.HeadlessImplementation");
+        List<?> drawn = (List<?>) headless.getField("drawnText").get(null);
+        Object target = invoke(loader.loadClass("com.codename1.ui.Image"), null, "createImage", 1080, 1920);
+        drawn.clear();
+        headless.getField("recordText").setBoolean(null, true);
+        try {
+            call(form, "paintComponent", call(target, "getGraphics"));
+        } finally {
+            headless.getField("recordText").setBoolean(null, false);
+        }
+        List<String> text = new ArrayList<String>();
+        for (Object entry : drawn) {
+            text.add(String.valueOf(((Object[]) entry)[0]));
+        }
+        drawn.clear();
+        return text;
+    }
+
+    @Test
+    public void everySceneOfTheScreenshotSuiteShowsHeadless() throws Exception {
+        File classes = build();
+        // Nothing of this JVM's classpath but the JDK: the remapped classes,
+        // the headless implementation ahead of the framework, the framework.
+        URL[] urls = {
+            classes.toURI().toURL(),
+            RealCompatJars.jar("codenameone-compat-testing", scratch).toURI().toURL(),
+            RealCompatJars.core(scratch).toURI().toURL(),
+            RealCompatJars.jdkHost(scratch).toURI().toURL(),
+        };
+        final URLClassLoader loader = new URLClassLoader(urls, ClassLoader.getSystemClassLoader().getParent());
+        try {
+            run(loader);
+        } finally {
+            loader.close();
+        }
+    }
+
+    private void run(final ClassLoader loader) throws Exception {
+        final Class<?> headless = loader.loadClass("com.codename1.compat.testing.HeadlessImplementation");
+        // The headless implementation decodes an image only when asked to.
+        headless.getField("pixelImages").setBoolean(null, true);
+        invoke(headless, null, "install");
+        assertEquals("The remap left the application's own main class as it was", "java.lang.Object",
+                loader.loadClass(HOST_MAIN).getSuperclass().getName());
+        final Class<?> displayClass = loader.loadClass("com.codename1.ui.Display");
+        final Object display = invoke(displayClass, null, "getInstance");
+        final Class<?> formClass = loader.loadClass("com.codename1.ui.Form");
+        final Class<?> componentClass = loader.loadClass("com.codename1.ui.Component");
+
+        // An exception inside an event or a repaint never reaches the code
+        // that posted it; the framework hands it to these.
+        final List<String> errors = Collections.synchronizedList(new ArrayList<String>());
+        Class<?> listener = loader.loadClass("com.codename1.ui.events.ActionListener");
+        Object handler = Proxy.newProxyInstance(loader, new Class<?>[] {listener}, new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                if ("actionPerformed".equals(method.getName()) && args != null && args.length == 1) {
+                    Object source = DesktopCompatScenesTest.call(args[0], "getSource");
+                    java.io.StringWriter trace = new java.io.StringWriter();
+                    if (source instanceof Throwable) {
+                        ((Throwable) source).printStackTrace(new java.io.PrintWriter(trace, true));
+                    }
+                    errors.add(source + "\n" + trace);
+                    DesktopCompatScenesTest.call(args[0], "consume");
+                    return null;
+                }
+                if ("equals".equals(method.getName())) {
+                    return proxy == args[0];
+                }
+                if ("hashCode".equals(method.getName())) {
+                    return System.identityHashCode(proxy);
+                }
+                return "edt errors";
+            }
+        });
+        call(display, "addEdtErrorHandler", handler);
+
+        final List<String> shown = new ArrayList<String>();
+        for (final String[] scene : SCENES) {
+            onEdt(display, new ThrowingRunnable() {
+                @Override
+                public void run() throws Exception {
+                    Object component = invoke(loader.loadClass(PACKAGE + scene[0]), null, scene[1]);
+                    assertTrue(scene[0] + "." + scene[1] + " answers a Codename One component",
+                            componentClass.isInstance(component));
+                    Object form = formClass.getConstructor(String.class).newInstance(scene[1]);
+                    call(form, "setLayout",
+                            loader.loadClass("com.codename1.ui.layouts.BorderLayout").getConstructor().newInstance());
+                    call(form, "addComponent", "Center", component);
+                    call(form, "show");
+                    call(form, "revalidate");
+                    assertTrue("The scene was given room", ((Integer) call(component, "getWidth")).intValue() > 0
+                            && ((Integer) call(component, "getHeight")).intValue() > 0);
+                    List<String> text = paint(loader, form);
+                    assertTrue(scene[0] + "." + scene[1] + " paints " + scene[2] + ": " + text,
+                            text.contains(scene[2]));
+                    shown.add(scene[0] + "." + scene[1]);
+                }
+            });
+            // Whatever building and painting it posted.
+            onEdt(display, new ThrowingRunnable() {
+                @Override
+                public void run() {
+                }
+            });
+        }
+        assertEquals(SCENES.length, shown.size());
+
+        assertEquals("yes", dialog(loader, display, "SwingScenes", new Asker() {
+            @Override
+            public String ask(Class<?> scenes) throws Exception {
+                return (String) invoke(scenes, null, "answerName", invoke(scenes, null, "confirm"));
+            }
+        }, errors));
+        assertEquals("ok", dialog(loader, display, "FxScenes", new Asker() {
+            @Override
+            public String ask(Class<?> scenes) throws Exception {
+                return (String) invoke(scenes, null, "confirm");
+            }
+        }, errors));
+        assertTrue("Nothing may be thrown on the event dispatch thread: " + errors, errors.isEmpty());
+    }
+
+    private interface Asker {
+        String ask(Class<?> scenes) throws Exception;
+    }
+
+    /// Asks the question of a scenes class on the event dispatch thread,
+    /// as a device test does: the call blocks while a timer waits for the
+    /// dialog to be up, paints the form it is on and presses its button.
+    private String dialog(final ClassLoader loader, final Object display, String name, final Asker asker,
+            final List<String> errors) throws Exception {
+        final Class<?> scenes = loader.loadClass(PACKAGE + name);
+        final Class<?> formClass = loader.loadClass("com.codename1.ui.Form");
+        final String[] answer = new String[1];
+        final List<String> log = Collections.synchronizedList(new ArrayList<String>());
+        onEdt(display, new ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                final Object host = formClass.getConstructor(String.class).newInstance("Host");
+                call(host, "show");
+                final Runnable[] poll = new Runnable[1];
+                final int[] tries = new int[1];
+                poll[0] = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            boolean up = Boolean.TRUE.equals(invoke(scenes, null, "confirmShowing"));
+                            Object current = call(display, "getCurrent");
+                            if ((!up || current == host) && ++tries[0] < 100) {
+                                call(display, "setTimeout", 50, poll[0]);
+                                return;
+                            }
+                            log.add("showing=" + up + " overTheHost=" + (current != host));
+                            if (up && current != null) {
+                                log.add("painted=" + paint(loader, current).contains("Delete the selected planet?"));
+                            }
+                            log.add("answered=" + invoke(scenes, null, "answerConfirm"));
+                        } catch (Throwable t) {
+                            errors.add("While answering: " + t);
+                        }
+                    }
+                };
+                call(display, "setTimeout", 50, poll[0]);
+                answer[0] = asker.ask(scenes);
+                assertTrue("The application's form is back once the dialog closed",
+                        call(display, "getCurrent") == host);
+            }
+        });
+        assertEquals(name + ": the dialog was up over the application's form, painted its question and was answered",
+                "[showing=true overTheHost=true, painted=true, answered=true]", log.toString());
+        return answer[0];
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/DesktopImportReportTest.java b/maven/build-engine/src/test/java/com/codename1/maven/DesktopImportReportTest.java
new file mode 100644
index 00000000000..b13f2db94ac
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/DesktopImportReportTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+
+import static com.codename1.maven.DependencyClassifierTest.cls;
+import static com.codename1.maven.DependencyClassifierTest.uses;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/// What an import tells the developer about the project's dependencies and
+/// about the Java level it was written for.
+public class DesktopImportReportTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File jar(String name, Object... entries) throws Exception {
+        return CompatRemapperTest.jar(new File(tmp.newFolder(), name), entries);
+    }
+
+    @Test
+    public void everyDependencyGetsItsClassAndWhatToDo() throws Exception {
+        File sources = tmp.newFolder();
+        Files.write(new File(sources, "Main.java").toPath(), ("package com.acme;\n"
+                + "import org.look.Theme;\n"
+                + "import org.words.Words;\n"
+                + "import org.pipes.Pipe;\n"
+                + "import com.fasterxml.jackson.databind.ObjectMapper;\n"
+                + "class Main { }\n").getBytes("UTF-8"));
+        List<DesktopImportReport.Row> rows = DesktopImportReport.rows(Arrays.asList(
+                jar("fx-controls-1.jar", "javafx/scene/control/Button.class",
+                        cls("javafx/scene/control/Button", uses())),
+                jar("look-1.jar", "org/look/Theme.class", cls("org/look/Theme", uses("javax/swing/JPanel")),
+                        "org/look/Icons.class", cls("org/look/Icons", uses("javax/swing/Icon"))),
+                jar("words-1.jar", "org/words/Words.class", cls("org/words/Words", uses()),
+                        "org/words/Extra.class", cls("org/words/Extra", uses())),
+                jar("pipes-1.jar", "org/pipes/Pipe.class", cls("org/pipes/Pipe", uses()),
+                        "native/libpipes.dylib", new byte[] {1}),
+                jar("jackson-databind-1.jar", "com/fasterxml/jackson/databind/ObjectMapper.class",
+                        cls("com/fasterxml/jackson/databind/ObjectMapper", uses())),
+                jar("unused-1.jar", "org/unused/U.class", cls("org/unused/U", uses())),
+                jar("kotlin-stdlib-1.jar", "kotlin/Unit.class", cls("kotlin/Unit", uses())),
+                jar("icons-1.jar", "icons/a.png", new byte[] {1})), sources);
+
+        assertEquals(8, rows.size());
+        assertEquals("fx-controls-1.jar", rows.get(0).dependency());
+        assertEquals("provided by a layer", rows.get(0).kind());
+        assertEquals("Keep it with scope provided: the sources compile against it and the JavaFX layer's own "
+                + "classes ship in its place.", rows.get(0).suggestion());
+
+        assertEquals("UI library", rows.get(1).kind());
+        assertEquals("Keep it with scope compile: all 2 classes are bundled and relocated with the application. "
+                + "The build reports any API it uses that a device lacks.", rows.get(1).suggestion());
+
+        assertEquals("pure Java", rows.get(2).kind());
+        assertEquals("Keep it with scope compile: the classes the application uses are bundled (1 of 2 from the "
+                + "imports), relocated and checked. The build reports any API it uses that a device lacks.",
+                rows.get(2).suggestion());
+
+        assertEquals("Replace it: it ships native libraries, which cannot run on a device. Put what it does behind "
+                + "an interface with a device implementation.", rows.get(3).suggestion());
+
+        // A library the alternatives table knows is told what to use instead.
+        assertTrue(rows.get(4).suggestion(), rows.get(4).suggestion().contains(" If the build reports it: "
+                + ComplianceAlternatives.lookup("com.fasterxml.jackson.")));
+
+        assertEquals("The sources import nothing from it: the build leaves it out unless a class that ships uses "
+                + "it.", rows.get(5).suggestion());
+        assertEquals("Codename One", rows.get(6).kind());
+        assertEquals("Nothing to do: the Codename One build handles it.", rows.get(6).suggestion());
+        assertEquals("resources only", rows.get(7).kind());
+
+        List<String> table = DesktopImportReport.table(rows);
+        assertEquals(2 + 2 * rows.size(), table.size());
+        assertEquals("Dependency              Class", table.get(0));
+        assertEquals("----------------------  -----", table.get(1));
+        assertEquals("look-1.jar              UI library", table.get(4));
+        assertTrue(table.get(5), table.get(5).startsWith("    Keep it with scope compile: all 2 classes"));
+    }
+
+    @Test
+    public void aProjectNewerThanTheBuildIsToldWhatThatCosts() {
+        assertNull(DesktopImportReport.javaLevelWarning(0));
+        assertNull(DesktopImportReport.javaLevelWarning(8));
+        assertNull(DesktopImportReport.javaLevelWarning(17));
+        String warning = DesktopImportReport.javaLevelWarning(21);
+        assertTrue(warning, warning.startsWith("The project is built for Java 21; a Codename One application is "
+                + "compiled as Java 17."));
+        assertTrue(warning, warning.contains("-source/-target 17"));
+        assertTrue(warning, warning.contains("compile error"));
+        assertTrue(warning, warning.contains("compliance check"));
+    }
+
+    private int level(String name, String build) throws Exception {
+        File dir = tmp.newFolder();
+        Files.write(new File(dir, name).toPath(), build.getBytes("UTF-8"));
+        return DesktopProjectImporter.javaLevel(dir, dir);
+    }
+
+    @Test
+    public void theJavaLevelIsReadFromTheProjectsBuild() throws Exception {
+        // The compiler plugin's own configuration wins over the properties.
+        assertEquals(21, level("pom.xml", "<project><properties>"
+                + "<maven.compiler.source>25</maven.compiler.source></properties><build><plugins><plugin>"
+                + "<artifactId>maven-compiler-plugin</artifactId><configuration><source>21</source>"
+                + "<target>21</target></configuration></plugin></plugins></build></project>"));
+        assertEquals(25, level("pom.xml", "<project><properties>"
+                + "<maven.compiler.source>25</maven.compiler.source></properties></project>"));
+        // release before source, and a property resolved in the same file.
+        assertEquals(17, level("pom.xml", "<project><properties><java.version>17</java.version></properties>"
+                + "<build><plugins><plugin><artifactId>maven-compiler-plugin</artifactId><configuration>"
+                + "<source>11</source><release>${java.version}</release></configuration></plugin></plugins>"
+                + "</build></project>"));
+        assertEquals(8, level("pom.xml", "<project><properties>"
+                + "<maven.compiler.target>1.8</maven.compiler.target></properties></project>"));
+        assertEquals(0, level("pom.xml", "<project><properties>"
+                + "<maven.compiler.release>${elsewhere}</maven.compiler.release></properties></project>"));
+        assertEquals(0, level("pom.xml", "<project/>"));
+
+        assertEquals(21, level("build.gradle", "java {\n  toolchain {\n"
+                + "    languageVersion = JavaLanguageVersion.of(21)\n  }\n}\n"));
+        assertEquals(21, level("build.gradle.kts", "kotlin {\n  jvmToolchain(21)\n}\n"));
+        assertEquals(19, level("build.gradle", "sourceCompatibility = JavaVersion.VERSION_19\n"));
+        assertEquals(8, level("build.gradle", "sourceCompatibility = JavaVersion.VERSION_1_8\n"));
+        assertEquals(11, level("build.gradle", "sourceCompatibility = '11'\n"));
+        assertEquals(0, level("build.gradle", "dependencies { }\n"));
+    }
+
+    @Test
+    public void aModuleInheritsTheLevelOfTheProjectItIsIn() throws Exception {
+        File root = tmp.newFolder();
+        File module = new File(root, "app");
+        assertTrue(module.mkdirs());
+        Files.write(new File(root, "pom.xml").toPath(), ("<project><properties>"
+                + "<maven.compiler.release>21</maven.compiler.release></properties></project>").getBytes("UTF-8"));
+        Files.write(new File(module, "pom.xml").toPath(), "<project/>".getBytes("UTF-8"));
+        assertEquals(21, DesktopProjectImporter.javaLevel(root, module));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/DesktopPortReportTest.java b/maven/build-engine/src/test/java/com/codename1/maven/DesktopPortReportTest.java
new file mode 100644
index 00000000000..bd61d52f925
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/DesktopPortReportTest.java
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+import com.codename1.build.BuildFailureException;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The port report of a desktop application, end to end: a small Swing
+/// application with two libraries is relocated and checked, and what the
+/// check writes is compared with the report kept beside this test.
+public class DesktopPortReportTest {
+
+    private static final String MAIN = "package com.acme.port;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) {\n"
+            + "        javax.swing.JFrame f = new javax.swing.JFrame(\"Port\");\n"
+            + "        f.add(new org.fancy.FancyPanel());\n"
+            + "        f.add(new javax.swing.JLabel(String.valueOf(org.plain.Words.count(new Clean().title()))));\n"
+            + "        f.setVisible(true);\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String CLEAN = "package com.acme.port;\n"
+            + "public class Clean {\n"
+            + "    String title() { return \"ok\"; }\n"
+            + "}\n";
+
+    private static final String GIT = "package com.acme.port;\n"
+            + "public class Git {\n"
+            + "    public Object status() {\n"
+            + "        return java.lang.management.ManagementFactory.getRuntimeMXBean().getName();\n"
+            + "    }\n"
+            + "    public Object log() {\n"
+            + "        return java.lang.management.ManagementFactory.getRuntimeMXBean().getName();\n"
+            + "    }\n"
+            + "    public java.sql.Connection index() throws java.sql.SQLException {\n"
+            + "        return java.sql.DriverManager.getConnection(\"jdbc:index\");\n"
+            + "    }\n"
+            + "    public java.net.Socket remote() throws java.io.IOException {\n"
+            + "        return new java.net.Socket(\"example.com\", 9418);\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String TRAY = "package com.acme.port;\n"
+            + "public class Tray {\n"
+            + "    void show() throws Exception {\n"
+            + "        java.awt.SystemTray.getSystemTray();\n"
+            + "        new java.awt.Robot().delay(1);\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String PANEL = "package org.fancy;\n"
+            + "public class FancyPanel extends javax.swing.JPanel {\n"
+            + "    public String title() { return \"fancy\"; }\n"
+            + "}\n";
+
+    /// As [#PANEL], and asking for the JVM's management beans: nothing a
+    /// device has. (A process is not the example any more: `ProcessBuilder`
+    /// is relocated to `com.codename1.io`, which desktop ports implement.)
+    private static final String BAD_PANEL = "package org.fancy;\n"
+            + "public class FancyPanel extends javax.swing.JPanel {\n"
+            + "    public Object launch() { return java.lang.management.ManagementFactory.getRuntimeMXBean(); }\n"
+            + "}\n";
+
+    private static final String WORDS = "package org.plain;\n"
+            + "public class Words {\n"
+            + "    public static int count(String s) { return s.length(); }\n"
+            + "}\n";
+
+    private static final String UNUSED = "package org.unused;\n"
+            + "public class Unused {\n"
+            + "}\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    private List<File> runtimes() throws Exception {
+        if (scratch == null) {
+            scratch = tmp.newFolder("jars");
+        }
+        return new ArrayList<File>(Arrays.asList(RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch)));
+    }
+
+    private File library(String name, String path, String source) throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, path, source);
+        String cls = path.replace(".java", ".class");
+        return CompatRemapperTest.jar(new File(tmp.newFolder(), name), cls,
+                Files.readAllBytes(new File(classes, cls).toPath()));
+    }
+
+    /// The application, relocated; `sources` are what it is made of beside
+    /// its main class.
+    private TestProjectHost application(String... sources) throws Exception {
+        return applicationWith(PANEL, sources);
+    }
+
+    private TestProjectHost applicationWith(String panel, String... sources) throws Exception {
+        File fancy = library("fancy-lib-1.0.jar", "org/fancy/FancyPanel.java", panel);
+        File plain = library("plain-lib-1.0.jar", "org/plain/Words.java", WORDS);
+        File unused = library("unused-lib-1.0.jar", "org/unused/Unused.java", UNUSED);
+        List<File> cp = runtimes();
+        cp.addAll(Arrays.asList(fancy, plain, unused));
+        File classes = tmp.newFolder();
+        List<String> all = new ArrayList<String>(Arrays.asList("com/acme/port/Main.java", MAIN,
+                "com/acme/port/Clean.java", CLEAN));
+        all.addAll(Arrays.asList(sources));
+        CompatFixtures.compileAgainst(cp, tmp.newFolder(), classes, all.toArray(new String[0]));
+        File desktop = tmp.newFolder();
+        assertTrue(new CompatRemapper(classes, cp, null, CompatRemapperTest.LOG).withDesktopSourceDirectory(desktop)
+                .withApplicationLibraries(Arrays.asList(fancy, plain, unused))
+                .run());
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        host.projectDir = tmp.newFolder();
+        for (File jar : new File[] {fancy, plain, unused}) {
+            host.artifacts.add(new BuildArtifact("org.example", jar.getName().replace(".jar", ""), "1", null, "jar",
+                    "compile", jar, null));
+        }
+        return host;
+    }
+
+    private static String read(File f) throws Exception {
+        return new String(Files.readAllBytes(f.toPath()), "UTF-8");
+    }
+
+    private static File defaultReport(TestProjectHost host) {
+        return new File(host.buildDir, "codenameone/desktop-port-report.md");
+    }
+
+    private static String golden(String name) throws Exception {
+        InputStream in = DesktopPortReportTest.class.getResourceAsStream(name);
+        assertNotNull(name + " is kept beside this test", in);
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            out.write(DependencyClassifier.readAll(in));
+            return out.toString("UTF-8");
+        } finally {
+            in.close();
+        }
+    }
+
+    /// Compares with the kept report, leaving what was written where a
+    /// developer can read it and, if it is right, keep it.
+    private static void assertGolden(String name, String actual) throws Exception {
+        File out = new File("target/port-report-actual/" + name);
+        out.getParentFile().mkdirs();
+        Files.write(out.toPath(), actual.getBytes("UTF-8"));
+        assertEquals("The report differs from src/test/resources/com/codename1/maven/" + name + "; what was written "
+                + "is in " + out, golden(name), actual);
+    }
+
+    @Test
+    public void anApplicationThatPassesGetsAReportToo() throws Exception {
+        TestProjectHost host = application();
+        new BytecodeCompliance(host).execute();
+        String report = read(defaultReport(host));
+        assertGolden("desktop-port-report-clean.md", report);
+        assertTrue(report, report.contains("- The compliance check passes: "));
+    }
+
+    @Test
+    public void theReportSaysWhatToChangeFileByFile() throws Exception {
+        TestProjectHost host = applicationWith(BAD_PANEL, "com/acme/port/Git.java", GIT, "com/acme/port/Tray.java",
+                TRAY);
+        String message;
+        try {
+            new BytecodeCompliance(host).execute();
+            fail("The application asks for JMX beans");
+            return;
+        } catch (BuildFailureException expected) {
+            message = expected.getMessage();
+        }
+        File file = defaultReport(host);
+        String report = read(file);
+        assertGolden("desktop-port-report.md", report);
+        // More findings than fit a console: the failure summarizes them and
+        // says where the rest is.
+        assertTrue(message, message.contains("What to change, file by file: " + file.getAbsolutePath()));
+        assertTrue(message, message.contains("  The application: "));
+        assertTrue(message, message.contains("\n  fancy-lib-1.0.jar: 1 call site, 1 API -- management 1"));
+        String check = read(new File(host.buildDir, "codenameone/compliance_check.txt"));
+        assertTrue(check, check.contains("The port report, which lists the same findings by source file, is "
+                + file.getAbsolutePath()));
+
+        // The same application is the same report: nothing in it depends on
+        // where or when it was built.
+        TestProjectHost again = applicationWith(BAD_PANEL, "com/acme/port/Git.java", GIT, "com/acme/port/Tray.java",
+                TRAY);
+        try {
+            new BytecodeCompliance(again).execute();
+            fail();
+        } catch (BuildFailureException expected) {
+            assertEquals(report, read(defaultReport(again)));
+        }
+    }
+
+    @Test
+    public void theReportGoesWhereItIsAskedFor() throws Exception {
+        TestProjectHost host = application();
+        // A relative path is the project's, as a build file would mean it.
+        host.userProperties.setProperty(DesktopPortReport.PROPERTY, "docs/port.md");
+        new BytecodeCompliance(host).execute();
+        assertTrue(new File(host.projectDir, "docs/port.md").isFile());
+        assertFalse(defaultReport(host).exists());
+        // What a plugin was given as a parameter wins over the property.
+        File chosen = new File(tmp.newFolder(), "chosen.md");
+        new BytecodeCompliance(host).portReport(chosen).execute();
+        assertTrue(chosen.isFile());
+        assertEquals(read(new File(host.projectDir, "docs/port.md")), read(chosen));
+    }
+
+    /// A class with one method whose body is an `invokedynamic` through
+    /// `owner`.
+    private static byte[] indy(int version, String name, String owner, String bootstrap) {
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(version, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", null);
+        cw.visitSource(name.substring(name.lastIndexOf('/') + 1) + ".java", null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "toString", "()Ljava/lang/String;", null, null);
+        mv.visitCode();
+        org.objectweb.asm.Label start = new org.objectweb.asm.Label();
+        mv.visitLabel(start);
+        mv.visitLineNumber(42, start);
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitInvokeDynamicInsn("toString", "(L" + name + ";)Ljava/lang/String;", new Handle(Opcodes.H_INVOKESTATIC,
+                owner, bootstrap, "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;"
+                + "Ljava/lang/invoke/TypeDescriptor;Ljava/lang/Class;Ljava/lang/String;"
+                + "[Ljava/lang/invoke/MethodHandle;)Ljava/lang/Object;", false), org.objectweb.asm.Type.getObjectType(name),
+                "");
+        mv.visitInsn(Opcodes.ARETURN);
+        mv.visitMaxs(1, 1);
+        mv.visitEnd();
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    private static void put(File classes, String name, byte[] bytes) throws Exception {
+        File f = new File(classes, name + ".class");
+        f.getParentFile().mkdirs();
+        Files.write(f.toPath(), bytes);
+    }
+
+    @Test
+    public void whatInvokedynamicCannotBeBuiltAheadOfTimeIsAFinding() throws Exception {
+        TestProjectHost host = application();
+        // Not the bootstrap method javac calls, so not one the build rewrites.
+        put(host.outputDir, "com/acme/port/Point", indy(Opcodes.V17, "com/acme/port/Point",
+                "java/lang/runtime/ObjectMethods", "another"));
+        put(host.outputDir, "com/acme/port/Odd", indy(Opcodes.V17, "com/acme/port/Odd", "org/odd/Bootstraps",
+                "make"));
+        try {
+            new BytecodeCompliance(host).execute();
+            fail("Neither bootstrap exists on a device");
+        } catch (BuildFailureException expected) {
+            String message = expected.getMessage();
+            assertTrue(message, message.contains("a record's generated equals, hashCode and toString "
+                    + "(invokedynamic through java.lang.runtime.ObjectMethods) is not supported on a device"));
+            assertTrue(message, message.contains("this class was not rewritten"));
+            assertTrue(message, message.contains("invokedynamic through org.odd.Bootstraps.make is not supported "
+                    + "on a device"));
+        }
+        String report = read(defaultReport(host));
+        assertTrue(report, report.contains("## What cannot run on a device"));
+        assertTrue(report, report.contains("java.lang.runtime.ObjectMethods"));
+    }
+
+    /// A record of a project that uses no layer is given its methods by the
+    /// check itself, since no remap went over it.
+    @Test
+    public void aPlainProjectsRecordIsRewrittenToo() throws Exception {
+        File classes = tmp.newFolder();
+        put(classes, "com/acme/plain/Point", indy(Opcodes.V17, "com/acme/plain/Point",
+                "java/lang/runtime/ObjectMethods", "bootstrap"));
+        scratch = tmp.newFolder("jars");
+        // Both layers are among its dependencies, as they are in every
+        // generated project, and none of its classes uses either.
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        new BytecodeCompliance(host).execute();
+        assertFalse("Nothing to port, so no port report", defaultReport(host).exists());
+        final boolean[] dynamic = new boolean[1];
+        new org.objectweb.asm.ClassReader(Files.readAllBytes(new File(classes, "com/acme/plain/Point.class").toPath()))
+                .accept(new org.objectweb.asm.ClassVisitor(Opcodes.ASM9) {
+                    @Override
+                    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                            String[] exceptions) {
+                        return new MethodVisitor(Opcodes.ASM9) {
+                            @Override
+                            public void visitInvokeDynamicInsn(String name, String descriptor, Handle bootstrap,
+                                    Object... arguments) {
+                                dynamic[0] = true;
+                            }
+                        };
+                    }
+                }, 0);
+        assertFalse("The record's toString is a plain method now", dynamic[0]);
+    }
+
+    /// A bootstrap nobody implements fails every project, with a layer or
+    /// without, and the failure says where it is.
+    @Test
+    public void anUnknownBootstrapFailsAPlainProjectAndSaysWhere() throws Exception {
+        File classes = tmp.newFolder();
+        put(classes, "com/acme/plain/Odd", indy(Opcodes.V17, "com/acme/plain/Odd", "org/odd/Bootstraps", "make"));
+        scratch = tmp.newFolder("jars");
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        try {
+            new BytecodeCompliance(host).execute();
+            fail("org.odd.Bootstraps exists on no device");
+        } catch (BuildFailureException expected) {
+            String message = expected.getMessage();
+            assertTrue(message, message.contains("invokedynamic through org.odd.Bootstraps.make is not supported "
+                    + "on a device"));
+            assertTrue(message, message.contains("com/acme/plain/Odd"));
+            assertTrue(message, message.contains("toString"));
+            assertTrue(message, message.contains("Odd.java:42"));
+        }
+    }
+
+    @Test
+    public void aClassFileNewerThanTheBuildIsRewrittenAndCheckedLikeAnyOther() throws Exception {
+        TestProjectHost host = application();
+        // Java 21 class files: one that is fine, one that calls an API Java
+        // 21 added.
+        put(host.outputDir, "com/acme/port/Fine", DependencyClassifierTest.cls(Opcodes.V21, "com/acme/port/Fine",
+                DependencyClassifierTest.uses()));
+        ClassWriter cw = new ClassWriter(0);
+        cw.visit(Opcodes.V21, Opcodes.ACC_PUBLIC, "com/acme/port/Newer", null, "java/lang/Object", null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "emoji", "(I)Z", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(Opcodes.ILOAD, 0);
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/Character", "isEmoji", "(I)Z", false);
+        mv.visitInsn(Opcodes.IRETURN);
+        mv.visitMaxs(1, 1);
+        mv.visitEnd();
+        cw.visitEnd();
+        put(host.outputDir, "com/acme/port/Newer", cw.toByteArray());
+        try {
+            new BytecodeCompliance(host).execute();
+            fail("Character.isEmoji(int) is Java 21's");
+        } catch (BuildFailureException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("isEmoji"));
+        }
+        byte[] rewritten = Files.readAllBytes(new File(host.outputDir, "com/acme/port/Newer.class").toPath());
+        assertEquals("The class file is Java 17's now", Opcodes.V17, rewritten[7] & 0xff);
+        String check = read(new File(host.buildDir, "codenameone/compliance_check.txt"));
+        assertTrue(check, check.contains("Rewritten class files to Java 17 major version: 2"));
+        assertTrue(check, check.contains("2 class file(s) were compiled for a Java newer than 17 (up to Java 21) and "
+                + "were rewritten to the Java 17 class format. What they call, by instruction or by invokedynamic, is checked like any other class's."));
+        assertTrue(read(defaultReport(host)), read(defaultReport(host)).contains("Java 21"));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/DesktopProjectImporterTest.java b/maven/build-engine/src/test/java/com/codename1/maven/DesktopProjectImporterTest.java
new file mode 100644
index 00000000000..5c078aaef80
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/DesktopProjectImporterTest.java
@@ -0,0 +1,934 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.builders.BuildException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// cn1:import-desktop-project over small Maven and Gradle desktop projects:
+/// what is copied where, how the entry point is found, the main class that
+/// is written to start it, what a second import does, and how the project's
+/// dependencies are reported.
+public class DesktopProjectImporterTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private final List<String> logged = new ArrayList<String>();
+
+    private final com.codename1.build.Log log = new com.codename1.build.Log() {
+        public void debug(CharSequence c) { }
+        public void debug(CharSequence c, Throwable e) { }
+        public void debug(Throwable e) { }
+        public void info(CharSequence c) { logged.add("info: " + c); }
+        public void info(CharSequence c, Throwable e) { }
+        public void info(Throwable e) { }
+        public void warn(CharSequence c) { logged.add("warn: " + c); }
+        public void warn(CharSequence c, Throwable e) { }
+        public void warn(Throwable e) { }
+        public void error(CharSequence c) { }
+        public void error(CharSequence c, Throwable e) { }
+        public void error(Throwable e) { }
+        public boolean isDebugEnabled() { return false; }
+        public boolean isInfoEnabled() { return true; }
+        public boolean isWarnEnabled() { return true; }
+        public boolean isErrorEnabled() { return true; }
+    };
+
+    private static File write(File root, String path, String text) throws IOException {
+        File f = new File(root, path);
+        assertTrue(f.getParentFile().isDirectory() || f.getParentFile().mkdirs());
+        Files.write(f.toPath(), text.getBytes("UTF-8"));
+        return f;
+    }
+
+    private static String read(File f) throws IOException {
+        return new String(Files.readAllBytes(f.toPath()), "UTF-8");
+    }
+
+    private static final String FX_APP = "package com.acme.fx;\n\n"
+            + "import javafx.application.Application;\n"
+            + "import javafx.stage.Stage;\n\n"
+            + "// class Decoy extends Application\n"
+            + "public class App extends Application {\n"
+            + "    @Override\n    public void start(Stage stage) {\n        stage.show();\n    }\n\n"
+            + "    public static void main(String[] args) {\n        launch(args);\n    }\n}\n";
+
+    private static final String SWING_MAIN = "package com.acme.swing;\n\n"
+            + "import javax.swing.JFrame;\n\n"
+            + "public class Main {\n"
+            + "    public static void main(final String... args) {\n"
+            + "        new JFrame(\"class Other extends Application\").setVisible(true);\n    }\n}\n";
+
+    /// A JavaFX Maven project with a module descriptor, FXML and a manifest.
+    private File javafxMavenProject() throws IOException {
+        File p = tmp.newFolder("fxproject");
+        write(p, "pom.xml", "<project>\n  <properties>\n    <main.class>com.acme.fx.App</main.class>\n  </properties>\n"
+                + "  <dependencyManagement><dependencies><dependency>\n"
+                + "    <groupId>managed</groupId><artifactId>only</artifactId>\n"
+                + "  </dependency></dependencies></dependencyManagement>\n"
+                + "  <dependencies>\n"
+                + "    <dependency><groupId>org.openjfx</groupId><artifactId>javafx-controls</artifactId>"
+                + "<version>21</version></dependency>\n"
+                + "    <dependency>\n      <groupId>org.openjfx</groupId>\n      <artifactId>javafx-fxml</artifactId>\n"
+                + "    </dependency>\n"
+                + "    <dependency><groupId>org.openjfx</groupId><artifactId>javafx-web</artifactId></dependency>\n"
+                + "    <dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId></dependency>\n"
+                + "    <dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId>"
+                + "<scope>test</scope></dependency>\n"
+                + "    <dependency><groupId>org.example</groupId><artifactId>testkit</artifactId>"
+                + "<scope>test</scope></dependency>\n"
+                + "  </dependencies>\n"
+                + "  <build><plugins><plugin><artifactId>javafx-maven-plugin</artifactId>\n"
+                + "    <dependencies><dependency><groupId>plugin</groupId><artifactId>dep</artifactId></dependency>"
+                + "</dependencies>\n"
+                + "    <configuration><mainClass>${main.class}</mainClass></configuration>\n"
+                + "  </plugin></plugins></build>\n</project>\n");
+        write(p, "src/main/java/module-info.java", "module com.acme.fx {\n    requires javafx.controls;\n}\n");
+        write(p, "src/main/java/com/acme/fx/App.java", FX_APP);
+        write(p, "src/main/java/com/acme/fx/Model.java", "package com.acme.fx;\n\npublic class Model {\n}\n");
+        write(p, "src/main/resources/com/acme/fx/main.fxml", "<VBox xmlns:fx=\"http://javafx.com/fxml\"/>\n");
+        write(p, "src/main/resources/style.css", ".root { }\n");
+        write(p, "src/main/resources/META-INF/MANIFEST.MF", "Main-Class: com.acme.fx.App\n");
+        write(p, "src/test/java/com/acme/fx/AppTest.java", "package com.acme.fx;\n\nclass AppTest {\n}\n");
+        return p;
+    }
+
+    private File common() throws IOException {
+        File common = new File(tmp.getRoot(), "app/common");
+        if (!common.isDirectory()) {
+            assertTrue(common.mkdirs());
+        }
+        return common;
+    }
+
+    private static Map<String, String> tree(File dir) throws IOException {
+        Map<String, String> out = new TreeMap<String, String>();
+        tree(dir, dir, out);
+        return out;
+    }
+
+    private static void tree(File root, File dir, Map<String, String> out) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                tree(root, f, out);
+            } else {
+                out.put(root.toURI().relativize(f.toURI()).getPath(), read(f));
+            }
+        }
+    }
+
+    @Test
+    public void importsAJavaFxMavenProject() throws Exception {
+        File source = javafxMavenProject();
+        File common = common();
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common, null);
+
+        File desktop = new File(common, "src/main/desktop");
+        assertEquals(FX_APP, read(new File(desktop, "java/com/acme/fx/App.java")));
+        assertTrue(new File(desktop, "java/com/acme/fx/Model.java").isFile());
+        assertTrue(new File(desktop, "resources/com/acme/fx/main.fxml").isFile());
+        assertTrue(new File(desktop, "resources/style.css").isFile());
+        assertEquals(4, r.copiedFiles);
+        // Not a module, and packaged by the Codename One build.
+        assertFalse(new File(desktop, "java/module-info.java").exists());
+        assertEquals(Collections.singletonList("java/module-info.java"), r.droppedModuleInfo);
+        assertFalse(new File(desktop, "resources/META-INF").exists());
+        // Tests are not the application.
+        assertFalse(tree(desktop).toString(), tree(desktop).toString().contains("AppTest"));
+
+        assertEquals("com.acme.fx.App", r.mainClass);
+        assertEquals("javafx", r.kind);
+        // Not told the application's main class, so none is written; and
+        // nothing in the desktop directory says how the application starts.
+        assertNull(r.generatedMain);
+        assertFalse(new File(common, "src/main/java").exists());
+        assertEquals(new java.util.TreeSet<String>(Arrays.asList("java", "resources",
+                DesktopProjectImporter.IMPORT_RECORD)),
+                new java.util.TreeSet<String>(Arrays.asList(desktop.list())));
+
+        assertEquals(Arrays.asList("org.openjfx:javafx-controls (JavaFX controls)", "org.openjfx:javafx-fxml (FXML)"),
+                r.covered);
+        // Reported, and nothing of theirs copied: no jar, no pom entry.
+        assertEquals(Arrays.asList("org.openjfx:javafx-web", "com.google.code.gson:gson"), r.uncovered);
+        assertFalse(r.kotlin);
+        assertFalse(new File(common, "src/main/kotlin").exists());
+        assertFalse(new File(common, "pom.xml").exists());
+    }
+
+    @Test
+    public void importsASwingGradleModule() throws Exception {
+        File source = tmp.newFolder("swingproject");
+        write(source, "settings.gradle", "include 'app'\n");
+        write(source, "app/build.gradle", "plugins { id 'application' }\n"
+                + "application {\n    mainClass = 'com.acme.swing.Main'\n}\n"
+                + "dependencies {\n"
+                + "    implementation 'org.swinglabs.swingx:swingx-core:1.6.5-1'\n"
+                + "    implementation(\"com.miglayout:miglayout-swing:11.3\")\n"
+                + "    implementation 'com.formdev:flatlaf:3.4'\n"
+                + "    testImplementation 'junit:junit:4.13.2'\n}\n");
+        write(source, "app/src/main/java/com/acme/swing/Main.java", SWING_MAIN);
+        write(source, "app/src/main/resources/messages.properties", "title=Hello\n");
+        File common = common();
+
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common, null);
+        File desktop = new File(common, "src/main/desktop");
+        assertEquals(SWING_MAIN, read(new File(desktop, "java/com/acme/swing/Main.java")));
+        assertEquals("title=Hello\n", read(new File(desktop, "resources/messages.properties")));
+        assertEquals("com.acme.swing.Main", r.mainClass);
+        assertEquals("swing", r.kind);
+        assertEquals(Collections.singletonList("org.swinglabs.swingx:swingx-core (SwingX)"), r.covered);
+        // MiG Layout is a library written against Swing, not part of a layer:
+        // the build relocates it with the application.
+        assertEquals(Arrays.asList("com.miglayout:miglayout-swing", "com.formdev:flatlaf"), r.uncovered);
+        // The sources are compiled against all three, so the project that
+        // receives them has to declare all three: SwingX to compile against
+        // only, since the layer has its own, and the others to ship.
+        StringBuilder libraries = new StringBuilder();
+        for (DesktopProjectImporter.Library lib : r.libraries) {
+            libraries.append(lib.coordinate()).append(':').append(lib.version)
+                    .append(lib.provided ? " provided\n" : " compile\n");
+        }
+        assertEquals("org.swinglabs.swingx:swingx-core:1.6.5-1 provided\n"
+                + "com.miglayout:miglayout-swing:11.3 compile\n"
+                + "com.formdev:flatlaf:3.4 compile\n", libraries.toString());
+        assertEquals(3, DesktopProjectImporter.librariesOf(new File(source, "app")).size());
+        assertFalse(DesktopProjectImporter.isToolkitModule("com.miglayout:miglayout-swing"));
+        assertTrue(DesktopProjectImporter.BUNDLED_NOTE.contains("bundled and relocated"));
+        assertEquals(source.getName(), DesktopProjectImporter.moduleDir(source, null).getParentFile().getName());
+        assertEquals("Swing", DesktopSources.toolkitsNamedIn(desktop));
+    }
+
+    /// A Maven project's dependencies, with a version held in a property and
+    /// one that only the parent's dependency management knows.
+    @Test
+    public void aMavenProjectsLibrariesAreReadWithTheirVersions() throws Exception {
+        File source = tmp.newFolder("mavenlibs");
+        write(source, "pom.xml", "<project>\n<properties><mig.version>5.3</mig.version></properties>\n"
+                + "<dependencyManagement><dependencies><dependency><groupId>org.managed</groupId>"
+                + "<artifactId>bom</artifactId><version>1</version></dependency></dependencies>"
+                + "</dependencyManagement>\n"
+                + "<dependencies>\n"
+                + "<dependency><groupId>com.miglayout</groupId><artifactId>miglayout-swing</artifactId>"
+                + "<version>${mig.version}</version></dependency>\n"
+                + "<dependency><groupId>org.swinglabs.swingx</groupId><artifactId>swingx-all</artifactId>"
+                + "<version>1.6.5-1</version></dependency>\n"
+                + "<dependency><groupId>org.example</groupId><artifactId>managed</artifactId></dependency>\n"
+                + "<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version>"
+                + "<scope>test</scope></dependency>\n"
+                + "</dependencies>\n</project>\n");
+        StringBuilder libraries = new StringBuilder();
+        for (DesktopProjectImporter.Library lib : DesktopProjectImporter.librariesOf(source)) {
+            libraries.append(lib.coordinate()).append(':').append(lib.version)
+                    .append(lib.provided ? " provided\n" : " compile\n");
+        }
+        assertEquals("com.miglayout:miglayout-swing:5.3 compile\n"
+                + "org.swinglabs.swingx:swingx-all:1.6.5-1 provided\n"
+                + "org.example:managed:null compile\n", libraries.toString());
+    }
+
+    /// What the desktop host supplies -- Maven's provided scope, Gradle's
+    /// compileOnly -- stays provided, so it is never bundled into the app;
+    /// declared both ways, it ships.
+    @Test
+    public void hostSuppliedLibrariesStayProvided() throws Exception {
+        File maven = tmp.newFolder("providedmaven");
+        write(maven, "pom.xml", "<project>\n<dependencies>\n"
+                + "<dependency><groupId>org.host</groupId><artifactId>api</artifactId><version>2</version>"
+                + "<scope>provided</scope></dependency>\n"
+                + "<dependency><groupId>org.app</groupId><artifactId>lib</artifactId><version>3</version>"
+                + "</dependency>\n"
+                + "</dependencies>\n</project>\n");
+        assertEquals("org.host:api:2 provided\norg.app:lib:3 compile\n", described(maven));
+        File gradle = tmp.newFolder("providedgradle");
+        write(gradle, "build.gradle", "dependencies {\n"
+                + "    compileOnly 'org.host:api:2'\n"
+                + "    implementation(\"org.app:lib:3\")\n"
+                + "    compileOnly 'org.both:lib:4'\n"
+                + "    runtimeOnly 'org.both:lib:4'\n"
+                + "}\n");
+        assertEquals("org.host:api:2 provided\norg.app:lib:3 compile\norg.both:lib:4 compile\n",
+                described(gradle));
+    }
+
+    private static String described(File moduleDir) throws Exception {
+        StringBuilder libraries = new StringBuilder();
+        for (DesktopProjectImporter.Library lib : DesktopProjectImporter.librariesOf(moduleDir)) {
+            libraries.append(lib.coordinate()).append(':').append(lib.version)
+                    .append(lib.provided ? " provided\n" : " compile\n");
+        }
+        return libraries.toString();
+    }
+
+    private File swingProject(String folder) throws IOException {
+        File source = tmp.newFolder(folder);
+        write(source, "src/main/java/com/acme/swing/Main.java", SWING_MAIN);
+        return source;
+    }
+
+    /// The application's main class is written to start the Swing
+    /// application, and the one the project template wrote is kept beside it.
+    @Test
+    public void theTemplatesMainClassIsRewrittenToStartTheApplication() throws Exception {
+        File common = common();
+        String template = "package com.acme;\npublic class MyApp extends com.codename1.system.Lifecycle {\n}\n";
+        File main = write(common, "src/main/java/com/acme/MyApp.java", template);
+
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(swingProject("rewrite"),
+                null, common, null, "com.acme", "MyApp");
+        assertEquals("com.acme.MyApp", r.generatedMain);
+        assertEquals(main, r.mainSource);
+        assertFalse(r.library);
+        String written = read(main);
+        assertEquals(DesktopProjectImporter.mainClassSource("com.acme.MyApp",
+                new DesktopProjectImporter.Candidate("com.acme.swing.Main"), false), written);
+        assertTrue(written, written.startsWith(DesktopProjectImporter.WRITTEN_BY + "\npackage com.acme;\n"));
+        assertTrue(written, written.contains("public class MyApp extends "
+                + "com.codename1.desktopcompat.rt.DesktopLifecycle {\n"));
+        assertTrue(written, written.contains("    protected void runMain() throws Exception {\n"
+                + "        com.acme.swing.Main.main(new String[0]);\n    }\n"));
+        File aside = new File(main.getPath() + DesktopProjectImporter.SET_ASIDE_SUFFIX);
+        assertEquals(aside, r.setAside);
+        assertEquals(template, read(aside));
+
+        // Importing again writes the same class, and keeps the first copy.
+        r = new DesktopProjectImporter(log).importProject(swingProject("rewrite2"), null, common, null, "com.acme",
+                "MyApp");
+        assertEquals("com.acme.MyApp", r.generatedMain);
+        assertNull(r.setAside);
+        assertEquals(written, read(main));
+        assertEquals(template, read(aside));
+
+        // A main class the developer has changed since is theirs.
+        String own = "package com.acme;\npublic class MyApp extends com.codename1.desktopcompat.rt.DesktopLifecycle {\n"
+                + "    protected void runMain() { com.acme.swing.Main.main(new String[] {\"-x\"}); }\n}\n";
+        write(common, "src/main/java/com/acme/MyApp.java", own);
+        logged.clear();
+        r = new DesktopProjectImporter(log).importProject(swingProject("rewrite3"), null, common, null, "com.acme",
+                "MyApp");
+        assertEquals(own, read(main));
+        assertNull(r.generatedMain);
+        assertEquals(template, read(aside));
+        assertTrue(logged.toString(), logged.toString().contains("warn: MyApp.java was changed after an earlier"));
+    }
+
+    /// A JavaFX application's main class creates the Application subclass.
+    @Test
+    public void aJavaFxApplicationIsCreatedByTheMainClass() throws Exception {
+        File common = common();
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(javafxMavenProject(), null,
+                common, null, "com.acme", "MyApp");
+        File main = new File(common, "src/main/java/com/acme/MyApp.java");
+        assertEquals(main, r.mainSource);
+        assertNull("there was nothing to keep", r.setAside);
+        String written = read(main);
+        assertTrue(written, written.contains("public class MyApp extends com.codename1.fxcompat.runtime.FxLifecycle {\n"
+                + "    @Override\n    protected javafx.application.Application createApplication() {\n"
+                + "        return new com.acme.fx.App();\n    }\n}\n"));
+        // The desktop main is not what starts a JavaFX application.
+        assertFalse(written, written.contains("main("));
+    }
+
+    /// A main class that is not public is reached through a launcher in its
+    /// own package; a Kotlin main without parameters is called as one.
+    @Test
+    public void whatTheMainClassCannotNameIsCalledThroughALauncher() throws Exception {
+        File source = tmp.newFolder("hidden");
+        write(source, "src/main/java/com/acme/swing/Hidden.java", "package com.acme.swing;\n\nclass Hidden {\n"
+                + "    public static void main(String[] args) {\n    }\n}\n");
+        File common = common();
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common, null,
+                "com.acme", "MyApp");
+        assertEquals("com.acme.swing.Hidden", r.mainClass);
+        String main = read(r.mainSource);
+        assertTrue(main, main.contains("        com.acme.swing." + DesktopProjectImporter.LAUNCHER + ".launch();\n"));
+        String launcher = read(new File(common, "src/main/java/com/acme/swing/" + DesktopProjectImporter.LAUNCHER
+                + ".java"));
+        assertTrue(launcher, launcher.contains("public static void launch() throws Exception {\n"
+                + "        com.acme.swing.Hidden.main(new String[0]);\n"));
+
+        Map<String, DesktopProjectImporter.Candidate> out = new TreeMap<String, DesktopProjectImporter.Candidate>();
+        DesktopProjectImporter.scanKotlin("App", "package k\n\nfun main() {\n}\n", out);
+        DesktopProjectImporter.Candidate kotlin = out.get("k.AppKt");
+        assertTrue(kotlin.noArgMain);
+        assertTrue(DesktopProjectImporter.mainClassSource("a.B", kotlin, false), DesktopProjectImporter
+                .mainClassSource("a.B", kotlin, false).contains("        k.AppKt.main();\n"));
+        assertFalse(DesktopProjectImporter.javaPublic("package a;\nfinal class X {\n}\n", "X"));
+        assertTrue(DesktopProjectImporter.javaPublic("package a;\n@Deprecated public final class X {\n"
+                + "    public static class Y {\n    }\n}\n", "X$Y"));
+        assertFalse(DesktopProjectImporter.javaPublic("package a;\npublic class X {\n    static class Y {\n"
+                + "    }\n}\n", "X$Y"));
+    }
+
+    /// Imported as a library, the sources are copied and the application's
+    /// main class is left alone; a project with nothing to start is fine.
+    @Test
+    public void aLibraryImportLeavesTheMainClassAlone() throws Exception {
+        File common = common();
+        String template = "package com.acme;\npublic class MyApp extends com.codename1.system.Lifecycle {\n}\n";
+        File main = write(common, "src/main/java/com/acme/MyApp.java", template);
+        File source = tmp.newFolder("screens");
+        write(source, "src/main/java/com/acme/screens/Screen.java", "package com.acme.screens;\n\n"
+                + "public class Screen extends javax.swing.JPanel {\n}\n");
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common, null,
+                "com.acme", "MyApp", true);
+        assertTrue(r.library);
+        assertNull(r.generatedMain);
+        assertNull(r.mainClass);
+        assertEquals(template, read(main));
+        assertTrue(new File(common, "src/main/desktop/java/com/acme/screens/Screen.java").isFile());
+    }
+
+    /// A project whose main class starts an imported Android application
+    /// starts that one: the desktop sources are its library.
+    @Test
+    public void anAndroidMainClassMakesTheDesktopSourcesALibrary() throws Exception {
+        File common = common();
+        String android = "package com.acme;\n\npublic class MyApp extends "
+                + "com.codename1.androidcompat.runtime.AndroidLifecycle {\n"
+                + "    public MyApp() {\n        super(new com.codename1.generated.android.AndroidAppImpl());\n"
+                + "    }\n}\n";
+        File main = write(common, "src/main/java/com/acme/MyApp.java", android);
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(swingProject("both"), null,
+                common, null, "com.acme", "MyApp");
+        assertTrue(r.library);
+        assertNull(r.generatedMain);
+        assertEquals(android, read(main));
+        assertFalse(new File(main.getPath() + DesktopProjectImporter.SET_ASIDE_SUFFIX).exists());
+        assertTrue(new File(common, "src/main/desktop/java/com/acme/swing/Main.java").isFile());
+    }
+
+    /// The main class cannot share a name with a class of the imported
+    /// application: nothing is copied, and the message says what to change.
+    @Test
+    public void anImportedClassNamedLikeTheMainClassStopsTheImport() throws Exception {
+        File common = common();
+        try {
+            new DesktopProjectImporter(log).importProject(swingProject("clash"), null, common, null, "com.acme.swing",
+                    "Main");
+            fail("The import must stop");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("Nothing was imported"));
+            assertTrue(e.getMessage(), e.getMessage().contains("codename1.mainName"));
+        }
+        assertFalse(new File(common, "src/main/desktop").exists());
+    }
+
+    /// A launcher beside the Application subclass is how a JavaFX project is
+    /// made runnable from a plain jar. The build names the launcher; the
+    /// application is the subclass.
+    @Test
+    public void aLauncherNamedByTheBuildMeansTheApplicationClass() throws Exception {
+        File source = tmp.newFolder("launcher");
+        write(source, "build.gradle.kts", "plugins { application; id(\"org.openjfx.javafxplugin\") }\n"
+                + "javafx {\n    modules = listOf(\"javafx.controls\", \"javafx.media\")\n}\n"
+                + "application {\n    mainClass.set(\"com.acme.fx.Launcher\")\n}\n"
+                + "dependencies {\n    implementation(libs.commons.lang)\n}\n");
+        write(source, "src/main/java/com/acme/fx/App.java", FX_APP);
+        write(source, "src/main/java/com/acme/fx/Launcher.java", "package com.acme.fx;\n\npublic class Launcher {\n"
+                + "    public static void main(String[] args) {\n        App.main(args);\n    }\n}\n");
+
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common(), null);
+        assertEquals("com.acme.fx.App", r.mainClass);
+        assertEquals("javafx", r.kind);
+        assertEquals(Collections.singletonList("org.openjfx:javafx-controls (JavaFX controls)"), r.covered);
+        assertEquals(Collections.singletonList("org.openjfx:javafx-media"), r.uncovered);
+        assertTrue(DesktopProjectImporter.isToolkitModule(r.uncovered.get(0)));
+        assertEquals(1, r.unresolved.size());
+        assertTrue(r.unresolved.get(0), r.unresolved.get(0).contains("version catalog"));
+        assertEquals("JavaFX", DesktopSources.toolkitsNamedIn(new File(common(), "src/main/desktop")));
+    }
+
+    @Test
+    public void severalEntryPointsAndNoMainClassSettingFailBeforeCopying() throws Exception {
+        File source = tmp.newFolder("two");
+        write(source, "pom.xml", "<project/>\n");
+        write(source, "src/main/java/com/acme/swing/Main.java", SWING_MAIN);
+        write(source, "src/main/java/com/acme/swing/Tool.java", "package com.acme.swing;\n\npublic class Tool {\n"
+                + "    static public void main(String args[]) {\n    }\n}\n");
+        File common = common();
+        try {
+            new DesktopProjectImporter(log).importProject(source, null, common, null);
+            fail("two main classes and nothing to choose by");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("com.acme.swing.Main (swing)"));
+            assertTrue(e.getMessage(), e.getMessage().contains("com.acme.swing.Tool (swing)"));
+            assertTrue(e.getMessage(), e.getMessage().contains("-Dcn1.desktop.mainClass="));
+        }
+        assertFalse("nothing is imported", new File(common, "src").exists());
+
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log)
+                .importProject(source, null, common, "com.acme.swing.Tool");
+        assertEquals("com.acme.swing.Tool", r.mainClass);
+
+        try {
+            new DesktopProjectImporter(log).importProject(source, null, common, "com.acme.swing.Missing");
+            fail("the override names no entry point");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("com.acme.swing.Missing"));
+            assertTrue(e.getMessage(), e.getMessage().contains("com.acme.swing.Main"));
+        }
+    }
+
+    @Test
+    public void theBuildsMainClassDecidesBetweenSeveral() throws Exception {
+        File source = tmp.newFolder("two");
+        write(source, "pom.xml", "<project><properties><exec.mainClass>com.acme.swing/com.acme.swing.Tool"
+                + "</exec.mainClass></properties></project>\n");
+        write(source, "src/main/java/com/acme/swing/Main.java", SWING_MAIN);
+        write(source, "src/main/java/com/acme/swing/Tool.java", "package com.acme.swing;\n\npublic class Tool {\n"
+                + "    public static void main(String[] args) {\n    }\n}\n");
+        assertEquals(Collections.singletonList("com.acme.swing.Tool"),
+                DesktopProjectImporter.declaredMainClasses(source, source));
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common(), null);
+        assertEquals("com.acme.swing.Tool", r.mainClass);
+        assertEquals("swing", r.kind);
+    }
+
+    @Test
+    public void aProjectWithNothingToStartIsRefused() throws Exception {
+        File source = tmp.newFolder("library");
+        write(source, "src/main/java/com/acme/Util.java", "package com.acme;\n\npublic class Util {\n}\n");
+        try {
+            new DesktopProjectImporter(log).importProject(source, null, common(), null);
+            fail("no entry point");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("javafx.application.Application"));
+        }
+        assertFalse(new File(common(), "src").exists());
+    }
+
+    @Test
+    public void namesTheModulesWhenSeveralHaveSources() throws Exception {
+        File source = tmp.newFolder("multi");
+        write(source, "ui/src/main/java/com/acme/swing/Main.java", SWING_MAIN);
+        write(source, "core/src/main/java/com/acme/Core.java", "package com.acme;\n\npublic class Core {\n}\n");
+        try {
+            DesktopProjectImporter.moduleDir(source, null);
+            fail("ambiguous");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("core, ui"));
+            assertTrue(e.getMessage(), e.getMessage().contains("-Dcn1.desktop.module="));
+        }
+        assertEquals(new File(source, "ui"), DesktopProjectImporter.moduleDir(source, "ui"));
+        try {
+            DesktopProjectImporter.moduleDir(source, "missing");
+            fail("no such module");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("missing"));
+        }
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, "ui", common(), null);
+        assertEquals("com.acme.swing.Main", r.mainClass);
+        assertFalse(new File(common(), "src/main/desktop/java/com/acme/Core.java").exists());
+    }
+
+    /// A file that was in the tree before any import is the developer's: an
+    /// import does not write over it, and never takes it for its own.
+    @Test
+    public void aFileNoImportWroteIsNotOverwritten() throws Exception {
+        File source = javafxMavenProject();
+        File common = common();
+        File desktop = new File(common, "src/main/desktop");
+        File mine = write(desktop, "java/com/acme/fx/Model.java",
+                "package com.acme.fx;\n\npublic class Model {\n    int mine;\n}\n");
+        new DesktopProjectImporter(log).importProject(source, null, common, null);
+        assertTrue(read(mine).contains("int mine;"));
+        assertTrue(logged.toString(), logged.toString().contains("Kept " + mine));
+
+        // Not on the record, so a later import leaves it too, and one from
+        // a project that dropped the path does not remove it.
+        assertTrue(new File(source, "src/main/java/com/acme/fx/Model.java").delete());
+        new DesktopProjectImporter(log).importProject(source, null, common, null);
+        assertTrue(read(mine).contains("int mine;"));
+    }
+
+    /// Importing again updates what the first import wrote and nothing else:
+    /// the developer's edits and additions stay, and a file that left the
+    /// source project is removed.
+    @Test
+    public void aSecondImportUpdatesOnlyUntouchedFiles() throws Exception {
+        File source = javafxMavenProject();
+        File common = common();
+        new DesktopProjectImporter(log).importProject(source, null, common, null);
+        File desktop = new File(common, "src/main/desktop");
+        Map<String, String> first = tree(desktop);
+
+        // Unchanged source, unchanged result.
+        DesktopProjectImporter.Result again = new DesktopProjectImporter(log).importProject(source, null, common, null);
+        assertEquals(first, tree(desktop));
+        assertEquals("com.acme.fx.App", again.mainClass);
+
+        File edited = new File(desktop, "java/com/acme/fx/Model.java");
+        Files.write(edited.toPath(), "package com.acme.fx;\n\npublic class Model {\n    int mine;\n}\n".getBytes("UTF-8"));
+        File added = write(desktop, "java/com/acme/fx/Mine.java", "package com.acme.fx;\n\nclass Mine {\n}\n");
+        write(source, "src/main/java/com/acme/fx/Model.java", "package com.acme.fx;\n\npublic class Model {\n"
+                + "    int upstream;\n}\n");
+        write(source, "src/main/resources/style.css", ".root { -fx-font-size: 12; }\n");
+        assertTrue(new File(source, "src/main/resources/com/acme/fx/main.fxml").delete());
+        write(source, "src/main/resources/com/acme/fx/other.fxml", "<HBox/>\n");
+
+        logged.clear();
+        new DesktopProjectImporter(log).importProject(source, null, common, null);
+        assertTrue("the developer's edit is kept", read(edited).contains("int mine;"));
+        assertTrue(logged.toString(), logged.toString().contains("Kept " + edited));
+        assertTrue("the developer's own file is kept", added.isFile());
+        assertEquals(".root { -fx-font-size: 12; }\n", read(new File(desktop, "resources/style.css")));
+        assertFalse("removed upstream, untouched here", new File(desktop, "resources/com/acme/fx/main.fxml").exists());
+        assertTrue(new File(desktop, "resources/com/acme/fx/other.fxml").isFile());
+
+        // Deleting the kept file takes the project's copy on the next import.
+        assertTrue(edited.delete());
+        new DesktopProjectImporter(log).importProject(source, null, common, null);
+        assertTrue(read(edited).contains("int upstream;"));
+    }
+
+    @Test
+    public void kotlinSourcesSwitchTheKotlinBuildOn() throws Exception {
+        File source = tmp.newFolder("kt");
+        write(source, "src/main/kotlin/com/acme/kt/App.kt", "package com.acme.kt\n\n"
+                + "import javafx.application.Application\nimport javafx.stage.Stage\n\n"
+                + "class App : Application() {\n    override fun start(stage: Stage) {\n        stage.show()\n    }\n}\n");
+        write(source, "src/main/kotlin/com/acme/kt/main.kt", "package com.acme.kt\n\n"
+                + "fun main(args: Array<String>) {\n    Application.launch(App::class.java, *args)\n}\n");
+        write(source, "build.gradle.kts", "application {\n    mainClass.set(\"com.acme.kt.MainKt\")\n}\n"
+                + "dependencies {\n    implementation(\"org.jetbrains.kotlin:kotlin-stdlib:2.0.0\")\n}\n");
+        File common = common();
+        DesktopProjectImporter.Result r = new DesktopProjectImporter(log).importProject(source, null, common, null);
+        assertTrue(r.kotlin);
+        assertTrue(new File(common, "src/main/kotlin/.keep").isFile());
+        assertTrue(new File(common, "src/main/desktop/kotlin/com/acme/kt/App.kt").isFile());
+        // The facade class is a launcher; the application is the subclass.
+        assertEquals("com.acme.kt.App", r.mainClass);
+        assertEquals("javafx", r.kind);
+        assertEquals(Collections.singletonList("org.jetbrains.kotlin:kotlin-stdlib (Kotlin standard library)"),
+                r.covered);
+    }
+
+    @Test
+    public void findsEntryPointsInSourceText() {
+        Map<String, DesktopProjectImporter.Candidate> out = new TreeMap<String, DesktopProjectImporter.Candidate>();
+        DesktopProjectImporter.scanJava("App", FX_APP, out);
+        assertEquals(Collections.singleton("com.acme.fx.App"), out.keySet());
+        assertTrue(out.get("com.acme.fx.App").javafx);
+
+        // Another class called Application is not JavaFX's.
+        out.clear();
+        DesktopProjectImporter.scanJava("Server", "package a;\nimport org.other.Application;\n"
+                + "public class Server extends Application {\n}\n", out);
+        assertTrue(out.toString(), out.isEmpty());
+
+        out.clear();
+        DesktopProjectImporter.scanJava("Outer", "import javafx.application.*;\n"
+                + "public class Outer {\n    public static class Inner extends Application {\n    }\n"
+                + "    void main(String[] a) {\n    }\n}\n", out);
+        assertEquals(Collections.singleton("Outer$Inner"), out.keySet());
+
+        // The class a main is written in, not the one the file is named for.
+        out.clear();
+        DesktopProjectImporter.scanJava("Outer", "package a;\npublic class Outer {\n    int[] sizes = {1, 2};\n"
+                + "    static class Launcher {\n        public static void main(String[] args) {\n        }\n    }\n}\n",
+                out);
+        assertEquals(Collections.singleton("a.Outer$Launcher"), out.keySet());
+        out.clear();
+        DesktopProjectImporter.scanJava("Model", "package a;\npublic class Model {\n    Class<?> c = Model.class;\n}\n"
+                + "class Start {\n    public static void main(String... args) {\n    }\n}\n", out);
+        assertEquals(Collections.singleton("a.Start"), out.keySet());
+        out.clear();
+        DesktopProjectImporter.scanJava("Plain", "package a;\npublic class Plain {\n"
+                + "    public static void main(String[] args) {\n    }\n}\n", out);
+        assertEquals(Collections.singleton("a.Plain"), out.keySet());
+
+        out.clear();
+        DesktopProjectImporter.scanJava("Q", "package q;\npublic class Q extends javafx.application.Application {\n}\n",
+                out);
+        assertTrue(out.get("q.Q").javafx);
+
+        out.clear();
+        DesktopProjectImporter.scanKotlin("Tool", "@file:JvmName(\"Start\")\npackage k\n\nfun main() {\n}\n", out);
+        assertEquals(Collections.singleton("k.Start"), out.keySet());
+        assertFalse(out.get("k.Start").javafx);
+
+        out.clear();
+        DesktopProjectImporter.scanKotlin("Boot", "package k\n\nobject Boot {\n    @JvmStatic fun main(a: Array<String>) {\n"
+                + "    }\n}\n", out);
+        assertEquals(Collections.singleton("k.Boot"), out.keySet());
+        assertNull(out.get("k.BootKt"));
+    }
+
+    @Test
+    public void desktopSourcesWithoutARuntimeAreRefused() throws Exception {
+        File desktop = tmp.newFolder("desktop");
+        try {
+            DesktopSources.requireRuntime(desktop, Arrays.asList("codenameone-core", "java-runtime"));
+            fail("neither runtime is a dependency");
+        } catch (BuildException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("codenameone-swing-compat"));
+            assertTrue(e.getMessage(), e.getMessage().contains("codenameone-javafx-compat"));
+        }
+        DesktopSources.requireRuntime(desktop, Arrays.asList("codenameone-core", "codenameone-javafx-compat"));
+        DesktopSources.requireRuntime(desktop, Collections.singletonList("codenameone-swing-compat"));
+        // No desktop sources, nothing to require.
+        DesktopSources.requireRuntime(new File(desktop, "missing"), Collections.<String>emptyList());
+        assertFalse(DesktopSources.isDesktopProject(new File(desktop, "missing")));
+        assertTrue(DesktopSources.isDesktopProject(desktop));
+        assertEquals("", DesktopSources.toolkitsNamedIn(desktop));
+    }
+
+    private static String libraries(File module) throws Exception {
+        StringBuilder libraries = new StringBuilder();
+        for (DesktopProjectImporter.Library lib : DesktopProjectImporter.librariesOf(module)) {
+            libraries.append(lib.coordinate()).append(':').append(lib.version)
+                    .append(lib.provided ? " provided\n" : " compile\n");
+        }
+        return libraries.toString();
+    }
+
+    /// Maven hands a parent's `<dependencies>` down to every module: they
+    /// are the module's although its own POM does not spell them out.
+    @Test
+    public void aParentsDependenciesAreItsModules() throws Exception {
+        File source = tmp.newFolder("inherited");
+        write(source, "pom.xml", "<project>\n<groupId>com.acme</groupId><artifactId>root</artifactId>\n"
+                + "<properties><gson.version>2.10</gson.version><mig.version>11.3</mig.version></properties>\n"
+                + "<dependencyManagement><dependencies><dependency><groupId>org.managed</groupId>"
+                + "<artifactId>only-managed</artifactId><version>1</version></dependency></dependencies>"
+                + "</dependencyManagement>\n"
+                + "<dependencies>\n"
+                + "<dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId>"
+                + "<version>${gson.version}</version></dependency>\n"
+                + "<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version>"
+                + "<scope>test</scope></dependency>\n"
+                + "</dependencies>\n</project>\n");
+        write(source, "ui/pom.xml", "<project>\n<parent><groupId>com.acme</groupId><artifactId>root</artifactId>"
+                + "<version>1</version></parent>\n<artifactId>ui-parent</artifactId>\n"
+                + "<dependencies>\n"
+                + "<dependency><groupId>com.formdev</groupId><artifactId>flatlaf</artifactId>"
+                + "<version>3.4</version></dependency>\n"
+                + "<dependency><groupId>com.miglayout</groupId><artifactId>miglayout-swing</artifactId>"
+                + "<version>5.0</version></dependency>\n"
+                + "</dependencies>\n</project>\n");
+        write(source, "ui/app/pom.xml", "<project>\n<parent><groupId>com.acme</groupId>"
+                + "<artifactId>ui-parent</artifactId><version>1</version></parent>\n<artifactId>app</artifactId>\n"
+                + "<dependencies>\n"
+                + "<dependency><groupId>com.miglayout</groupId><artifactId>miglayout-swing</artifactId>"
+                + "<version>${mig.version}</version></dependency>\n"
+                + "</dependencies>\n</project>\n");
+        // The module's own first, then each parent's; what the module says
+        // itself wins, and a property is inherited like a dependency.
+        assertEquals("com.miglayout:miglayout-swing:11.3 compile\n"
+                + "com.formdev:flatlaf:3.4 compile\n"
+                + "com.google.code.gson:gson:2.10 compile\n", libraries(new File(source, "ui/app")));
+        DesktopProjectImporter.Result all = new DesktopProjectImporter.Result();
+        DesktopProjectImporter.readDependencies(new File(source, "ui/app"), all);
+        assertTrue(all.unresolved.toString(), all.unresolved.isEmpty());
+
+        // A dependency kept commented out is not one of the project's.
+        write(source, "commented/pom.xml", "<project>\n<dependencies>\n"
+                + "<!-- <dependency><groupId>org.old</groupId><artifactId>gone</artifactId>"
+                + "<version>1.0</version></dependency> -->\n"
+                + "<dependency><groupId>com.formdev</groupId><artifactId>flatlaf</artifactId>"
+                + "<version>3.4</version></dependency>\n<!--\n<dependency>\n<groupId>org.old</groupId>\n"
+                + "<artifactId>other</artifactId>\n</dependency>\n-->\n</dependencies>\n</project>\n");
+        assertEquals("com.formdev:flatlaf:3.4 compile\n", libraries(new File(source, "commented")));
+
+        // A parent named somewhere else in the tree.
+        write(source, "elsewhere/pom.xml", "<project>\n<parent><groupId>com.acme</groupId>"
+                + "<artifactId>ui-parent</artifactId><version>1</version>"
+                + "<relativePath>../ui</relativePath></parent>\n<artifactId>other</artifactId>\n</project>\n");
+        assertEquals("com.formdev:flatlaf:3.4 compile\n"
+                + "com.miglayout:miglayout-swing:5.0 compile\n"
+                + "com.google.code.gson:gson:2.10 compile\n", libraries(new File(source, "elsewhere")));
+
+        // A parent that is not a file of the project is not fetched, and
+        // the import says that it does not know what it declares: one that
+        // is said to be in a repository, and one that is simply not there.
+        for (String relative : new String[] {"<relativePath/>", ""}) {
+            File lone = tmp.newFolder();
+            write(lone, "module/pom.xml", "<project>\n<parent><groupId>org.springframework.boot</groupId>"
+                    + "<artifactId>spring-boot-starter-parent</artifactId><version>3</version>" + relative
+                    + "</parent>\n<artifactId>module</artifactId>\n"
+                    + "<dependencies>\n<dependency><groupId>com.formdev</groupId><artifactId>flatlaf</artifactId>"
+                    + "<version>3.4</version></dependency>\n</dependencies>\n</project>\n");
+            // The directory above holds a POM, of some other project.
+            write(lone, "pom.xml", "<project><artifactId>unrelated</artifactId><dependencies><dependency>"
+                    + "<groupId>org.stray</groupId><artifactId>stray</artifactId><version>1</version></dependency>"
+                    + "</dependencies></project>\n");
+            DesktopProjectImporter.Result r = new DesktopProjectImporter.Result();
+            DesktopProjectImporter.readDependencies(new File(lone, "module"), r);
+            assertEquals(Collections.singletonList("com.formdev:flatlaf"), r.uncovered);
+            assertEquals(1, r.unresolved.size());
+            assertTrue(r.unresolved.get(0), r.unresolved.get(0).startsWith(
+                    "the parent POM org.springframework.boot:spring-boot-starter-parent is not among"));
+        }
+    }
+
+    /// A file of the parent's artifact id where the parent is looked for is
+    /// the parent only when its group and version are the ones asked for;
+    /// Maven goes to a repository for any other, and so nothing of that
+    /// file is the module's.
+    @Test
+    public void aLocalPomOfAnotherGroupOrVersionIsNotTheParent() throws Exception {
+        String[][] cases = {
+            // what the file above declares, and whether it is the parent
+            {"<groupId>com.acme</groupId><artifactId>root</artifactId><version>1</version>", "yes"},
+            {"<groupId>org.other</groupId><artifactId>root</artifactId><version>1</version>", "no"},
+            {"<groupId>com.acme</groupId><artifactId>root</artifactId><version>2</version>", "no"},
+            // Group and version inherited from a parent of its own; the
+            // group id of its dependency is not the project's.
+            {"<parent><groupId>com.acme</groupId><artifactId>top</artifactId><version>1</version>"
+                    + "<relativePath/></parent><artifactId>root</artifactId>", "yes"},
+            {"<parent><groupId>org.other</groupId><artifactId>top</artifactId><version>1</version>"
+                    + "<relativePath/></parent><artifactId>root</artifactId>", "no"},
+            {"<groupId>com.acme</groupId><artifactId>root</artifactId><version>${revision}</version>", "yes"},
+        };
+        for (String[] c : cases) {
+            File source = tmp.newFolder();
+            write(source, "pom.xml", "<project>\n" + c[0] + "\n<dependencies>\n<dependency>"
+                    + "<groupId>com.miglayout</groupId><artifactId>miglayout-swing</artifactId>"
+                    + "<version>5.0</version></dependency>\n</dependencies>\n</project>\n");
+            write(source, "app/pom.xml", "<project>\n<parent><groupId>com.acme</groupId>"
+                    + "<artifactId>root</artifactId><version>1</version></parent>\n<artifactId>app</artifactId>\n"
+                    + "</project>\n");
+            DesktopProjectImporter.Result r = new DesktopProjectImporter.Result();
+            DesktopProjectImporter.readDependencies(new File(source, "app"), r);
+            boolean parent = "yes".equals(c[1]);
+            // The file's own parent, `top`, is nowhere and is reported too.
+            assertEquals(c[0], !parent, r.unresolved.toString().contains("the parent POM com.acme:root "));
+            assertEquals(c[0], parent, !r.libraries.isEmpty());
+        }
+    }
+
+    /// `public` spelled out after `@JvmStatic` is the same entry point.
+    @Test
+    public void aKotlinJvmStaticMainMayBePublic() {
+        Map<String, DesktopProjectImporter.Candidate> out =
+                new java.util.LinkedHashMap<String, DesktopProjectImporter.Candidate>();
+        DesktopProjectImporter.scanKotlin("Boot", "package k\n\nobject Boot {\n    @JvmStatic public fun main("
+                + "a: Array<String>) {\n    }\n}\n", out);
+        assertEquals(Collections.singleton("k.Boot"), out.keySet());
+    }
+
+    /// Whether the generated main class's name is taken is a question of
+    /// what the Kotlin sources declare, not of what their files are called.
+    @Test
+    public void aKotlinClassIsFoundByItsDeclaration() throws Exception {
+        File main = tmp.newFolder();
+        write(main, "kotlin/com/foo/MyApp.kt", "package com.foo\n\nfun helper() = 1\n");
+        assertFalse(DesktopProjectImporter.declares(main, "com.foo.MyApp"));
+        write(main, "kotlin/com/foo/Other.kt", "package com.foo\n\n// class MyApp\ndata class MyApp(val a: Int)\n");
+        assertTrue(DesktopProjectImporter.declares(main, "com.foo.MyApp"));
+        assertFalse(DesktopProjectImporter.declares(main, "com.bar.MyApp"));
+        File named = tmp.newFolder();
+        write(named, "kotlin/x/Start.kt", "@file:JvmName(\"Launcher\")\npackage x\n\nfun main() {}\n");
+        assertTrue(DesktopProjectImporter.declares(named, "x.Launcher"));
+        File nested = tmp.newFolder();
+        write(nested, "kotlin/x/A.kt", "package x\n\nclass A {\n    class MyApp\n}\n");
+        assertFalse(DesktopProjectImporter.declares(nested, "x.MyApp"));
+        File java = tmp.newFolder();
+        write(java, "java/x/MyApp.java", "package x; class MyApp {}\n");
+        assertTrue(DesktopProjectImporter.declares(java, "x.MyApp"));
+    }
+
+    /// `public` is Kotlin's default visibility written out, and a
+    /// `suspend` main gets the same static facade method.
+    @Test
+    public void aKotlinTopLevelMainMayCarryModifiers() {
+        Map<String, DesktopProjectImporter.Candidate> out =
+                new java.util.LinkedHashMap<String, DesktopProjectImporter.Candidate>();
+        for (String main : new String[] {"public fun main() {\n}\n", "suspend fun main() {\n}\n",
+            "public suspend fun main(args: Array<String>) {\n}\n"}) {
+            out.clear();
+            DesktopProjectImporter.scanKotlin("Tool", "package k\n\n" + main, out);
+            assertEquals(main, Collections.singleton("k.ToolKt"), out.keySet());
+        }
+        for (String main : new String[] {"private fun main() {\n}\n",
+            "class A {\n    public fun main() {\n    }\n}\n"}) {
+            out.clear();
+            DesktopProjectImporter.scanKotlin("Tool", "package k\n\n" + main, out);
+            assertTrue(main, out.isEmpty());
+        }
+    }
+
+    /// A Kotlin `@JvmStatic main` is a static method of the class it is
+    /// declared in, whatever the file is called.
+    @Test
+    public void aKotlinEntryClassIsTheDeclarationNotTheFile() {
+        Map<String, DesktopProjectImporter.Candidate> out =
+                new TreeMap<String, DesktopProjectImporter.Candidate>();
+        DesktopProjectImporter.scanKotlin("Launcher", "package k\n\n// object Wrong {\n"
+                + "private val log = java.util.logging.Logger.getLogger(App::class.java.name)\n\n"
+                + "object App {\n    val title = \"object Title {\"\n"
+                + "    fun describe(): String { return title }\n"
+                + "    @JvmStatic fun main(a: Array<String>) {\n    }\n}\n", out);
+        assertEquals(Collections.singleton("k.App"), out.keySet());
+
+        // The static method of a companion object is on the class.
+        out.clear();
+        DesktopProjectImporter.scanKotlin("Start", "package k\n\nclass Tool(val name: String) : Runnable {\n"
+                + "    override fun run() { println(name) }\n"
+                + "    companion object {\n        @JvmStatic\n        fun main(a: Array<String>) {\n        }\n"
+                + "    }\n}\n", out);
+        assertEquals(Collections.singleton("k.Tool"), out.keySet());
+
+        out.clear();
+        DesktopProjectImporter.scanKotlin("Start", "class Outer {\n    object Inner {\n"
+                + "        @JvmStatic fun main(a: Array<String>) {\n        }\n    }\n}\n", out);
+        assertEquals(Collections.singleton("Outer$Inner"), out.keySet());
+
+        // A JavaFX application nested in another class is Outer$Nested.
+        out.clear();
+        DesktopProjectImporter.scanKotlin("Start", "package k\n\nimport javafx.application.Application\n\n"
+                + "class Host {\n    fun other() { }\n    class App : Application() {\n"
+                + "        override fun start(s: javafx.stage.Stage) { }\n    }\n}\n"
+                + "class Top : Application() {\n}\n", out);
+        assertEquals(new java.util.TreeSet<String>(java.util.Arrays.asList("k.Host$App", "k.Top")),
+                new java.util.TreeSet<String>(out.keySet()));
+
+        // In no declaration this can read: the file's name, as before.
+        out.clear();
+        DesktopProjectImporter.scanKotlin("Odd", "package k\n@JvmStatic fun main(a: Array<String>) {\n}\n", out);
+        assertTrue(out.keySet().toString(), out.containsKey("k.Odd"));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/FxmlRemapTest.java b/maven/build-engine/src/test/java/com/codename1/maven/FxmlRemapTest.java
new file mode 100644
index 00000000000..42bfdfa57b8
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/FxmlRemapTest.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.fxml.DesktopResourceCompiler;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// FXML and style sheets through the whole of a build: the resource
+/// compiler writes Java source and a binary table, javac compiles them with
+/// a fixture application against the layers' real runtime jars, and the
+/// remap relocates everything, ships the WHOLE JavaFX runtime and generates
+/// the dispatcher. The result has to pass the compliance check with no
+/// finding at all, as a project's build would run it next, and the
+/// dispatcher has to reach the controller's private members.
+public class FxmlRemapTest {
+
+    private static final String APP = "package com.acme.fx;\n"
+            + "import javafx.application.Application;\n"
+            + "import javafx.fxml.FXMLLoader;\n"
+            + "import javafx.scene.Parent;\n"
+            + "import javafx.scene.Scene;\n"
+            + "import javafx.stage.Stage;\n"
+            + "public class Shop extends Application {\n"
+            + "    public void start(Stage stage) throws Exception {\n"
+            + "        Parent root = FXMLLoader.load(getClass().getResource(\"/ui/shop.fxml\"));\n"
+            + "        Scene scene = new Scene(root, 300, 200);\n"
+            + "        scene.getStylesheets().add(getClass().getResource(\"/ui/shop.css\").toExternalForm());\n"
+            + "        stage.setScene(scene);\n"
+            + "        stage.show();\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String BASE = "package com.acme.fx;\n"
+            + "import javafx.fxml.FXML;\n"
+            + "import javafx.scene.control.Label;\n"
+            + "public class BaseController {\n"
+            + "    @FXML private Label status;\n"
+            + "    Label status() { return status; }\n"
+            + "}\n";
+
+    private static final String CONTROLLER = "package com.acme.fx;\n"
+            + "import javafx.event.ActionEvent;\n"
+            + "import javafx.fxml.FXML;\n"
+            + "import javafx.scene.control.Button;\n"
+            + "import javafx.scene.control.TextField;\n"
+            + "import javafx.scene.layout.HBox;\n"
+            + "public class ShopController extends BaseController {\n"
+            + "    @FXML private TextField name;\n"
+            + "    @FXML private Button buy;\n"
+            + "    @FXML private HBox footer;\n"
+            + "    @FXML private FooterController footerController;\n"
+            + "    private int bought;\n"
+            + "    private boolean ready;\n"
+            + "    private ShopController() { }\n"
+            + "    @FXML private void initialize() { ready = name != null && status() != null && footer != null; }\n"
+            + "    @FXML private void onBuy(ActionEvent e) { bought++; }\n"
+            + "    @FXML private void onClear() { bought = 0; }\n"
+            + "}\n";
+
+    private static final String FOOTER = "package com.acme.fx;\n"
+            + "public class FooterController implements javafx.fxml.Initializable {\n"
+            + "    @javafx.fxml.FXML private javafx.scene.control.Label note;\n"
+            + "    boolean initialized;\n"
+            + "    public void initialize(java.net.URL location, java.util.ResourceBundle resources) {\n"
+            + "        initialized = note != null;\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String SHOP_FXML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+            + "<?import javafx.geometry.Insets?>\n"
+            + "<?import javafx.scene.control.*?>\n"
+            + "<?import javafx.scene.layout.*?>\n"
+            + "<VBox xmlns:fx=\"http://javafx.com/fxml/1\" fx:controller=\"com.acme.fx.ShopController\""
+            + " spacing=\"8\" alignment=\"CENTER\" styleClass=\"shop\" stylesheets=\"@shop.css\">\n"
+            + "  <padding><Insets top=\"4\" right=\"4\" bottom=\"4\" left=\"4\"/></padding>\n"
+            + "  <fx:define><ToggleGroup fx:id=\"group\"/></fx:define>\n"
+            + "  <TextField fx:id=\"name\" promptText=\"who\"/>\n"
+            + "  <Label fx:id=\"status\" text=\"${name.text}\" VBox.vgrow=\"ALWAYS\"/>\n"
+            + "  <RadioButton text=\"a\" toggleGroup=\"$group\"/>\n"
+            + "  <Button fx:id=\"buy\" text=\"Buy\" onAction=\"#onBuy\"/>\n"
+            + "  <Button text=\"Clear\" onAction=\"#onClear\"/>\n"
+            + "  <fx:include fx:id=\"footer\" source=\"footer.fxml\"/>\n"
+            + "</VBox>\n";
+
+    private static final String FOOTER_FXML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+            + "<?import javafx.scene.control.Label?>\n"
+            + "<?import javafx.scene.layout.HBox?>\n"
+            + "<HBox xmlns:fx=\"http://javafx.com/fxml/1\" fx:controller=\"com.acme.fx.FooterController\">\n"
+            + "  <Label fx:id=\"note\" text=\"note\"/>\n"
+            + "</HBox>\n";
+
+    private static final String SHOP_CSS = ".root { -brand: #336699; -fx-font-size: 14px; }\n"
+            + ".shop > .button:hover { -fx-text-fill: derive(-brand, 20%); -fx-padding: 0.5em 1em; }\n"
+            + ".label { -fx-text-fill: -brand;"
+            + " -fx-background-color: linear-gradient(to bottom, white, -brand); }\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    private List<File> classpath() throws Exception {
+        if (scratch == null) {
+            scratch = tmp.newFolder("jars");
+        }
+        return Arrays.asList(RealCompatJars.javafx(scratch), RealCompatJars.core(scratch));
+    }
+
+    private static void write(File f, String text) throws Exception {
+        f.getParentFile().mkdirs();
+        Files.write(f.toPath(), text.getBytes("UTF-8"));
+    }
+
+    private static void sources(File dir, String prefix, List<String> into) throws Exception {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                sources(f, prefix + f.getName() + "/", into);
+            } else if (f.getName().endsWith(".java")) {
+                into.add(prefix + f.getName());
+                into.add(new String(Files.readAllBytes(f.toPath()), "UTF-8"));
+            }
+        }
+    }
+
+    /// The desktop resources of the last [#build()], and what the resource
+    /// compiler made of them.
+    private File resources;
+    private File resourcesOut;
+
+    /// What `prepare-desktop-sources`, javac and `process-resources` leave
+    /// in a project's classes directory, before the remap -- which compiles
+    /// the documents first.
+    private File build() throws Exception {
+        resources = tmp.newFolder();
+        write(new File(resources, "ui/shop.fxml"), SHOP_FXML);
+        write(new File(resources, "ui/footer.fxml"), FOOTER_FXML);
+        write(new File(resources, "ui/shop.css"), SHOP_CSS);
+        File javaOut = tmp.newFolder();
+        resourcesOut = tmp.newFolder();
+        final List<String> warnings = new ArrayList<String>();
+        List<String> errors = new DesktopResourceCompiler(Collections.singletonList(resources), javaOut,
+                resourcesOut, new DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                        warnings.add(message);
+                    }
+                }).run();
+        assertTrue(errors.toString(), errors.isEmpty());
+        assertTrue(warnings.toString(), warnings.isEmpty());
+
+        List<String> all = new ArrayList<String>(Arrays.asList("com/acme/fx/Shop.java", APP,
+                "com/acme/fx/BaseController.java", BASE, "com/acme/fx/ShopController.java", CONTROLLER,
+                "com/acme/fx/FooterController.java", FOOTER));
+        sources(javaOut, "", all);
+        assertEquals("The documents are not sources yet; one source stands for them", 8 + 2, all.size());
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(classpath(), tmp.newFolder(), classes, all.toArray(new String[0]));
+        // The resource roots, as the build copies them beside the classes.
+        for (File root : new File[] {resources, resourcesOut}) {
+            copy(root, classes);
+        }
+        return classes;
+    }
+
+    private static void copy(File from, File to) throws Exception {
+        File[] files = from.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            File target = new File(to, f.getName());
+            if (f.isDirectory()) {
+                target.mkdirs();
+                copy(f, target);
+            } else {
+                Files.copy(f.toPath(), target.toPath());
+            }
+        }
+    }
+
+    private CompatRemapper remapper(File classes) throws Exception {
+        File desktop = tmp.newFolder();
+        return new CompatRemapper(classes, classpath(), null, CompatRemapperTest.LOG)
+                .withResourceDirectories(Arrays.asList(resources, resourcesOut))
+                .withDesktopSourceDirectory(desktop);
+    }
+
+    private static Object field(Object target, Class<?> owner, String name) throws Exception {
+        java.lang.reflect.Field f = owner.getDeclaredField(name);
+        f.setAccessible(true);
+        return f.get(target);
+    }
+
+    @Test
+    public void theWholeRuntimeWithCompiledDocumentsAndSheetsIsCompliant() throws Exception {
+        File classes = build();
+        assertTrue(remapper(classes).run());
+
+        // The whole runtime shipped, relocated, with the generated registry
+        // in place of the layer's placeholder.
+        assertTrue(new File(classes, "com/codename1/fxcompat/rt/CssEngine.class").isFile());
+        assertTrue(new File(classes, "com/codename1/fxcompat/javafx/fxml/FXMLLoader.class").isFile());
+        assertFalse(new File(classes, "javafx").exists());
+        File registry = new File(classes, "com/codename1/fxcompat/rt/FxmlRegistry.class");
+        assertTrue(registry.isFile());
+        Set<String> members = CompatFixtures.members(Files.readAllBytes(registry.toPath()));
+        assertTrue(members.toString(), members.contains("com/codename1/generated/fxml/Fxml_ui__shop.load"));
+        assertTrue(members.toString(), members.contains("com/codename1/generated/fxml/Fxml_ui__footer.load"));
+        assertTrue(members.toString(), members.contains("com/acme/fx/ShopController.<init>"));
+        // The compiled sheet ships under its flat name.
+        assertTrue(new File(classes, "ui_shop.css.cn1css").isFile()
+                || new File(classes, com.codename1.impl.compat.ResourceNames.flatName("ui/shop.css") + ".cn1css")
+                        .isFile());
+
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+    }
+
+    @Test
+    public void theGeneratedDispatcherReachesPrivateMembersOfTheRelocatedController() throws Exception {
+        File classes = build();
+        assertTrue(remapper(classes).run());
+        URLClassLoader loader = new URLClassLoader(new URL[] {classes.toURI().toURL()},
+                FxmlRemapTest.class.getClassLoader());
+        try {
+            Class<?> dispatchType = loader.loadClass("com.codename1.fxcompat.rt.FxmlDispatch");
+            Object dispatch = loader.loadClass("com.codename1.fxcompat.rt.FxmlRegistry").newInstance();
+            assertTrue(dispatchType.isInstance(dispatch));
+            Method has = dispatchType.getMethod("has", String.class);
+            assertEquals(Boolean.TRUE, has.invoke(dispatch, "ui/shop.fxml"));
+            assertEquals(Boolean.TRUE, has.invoke(dispatch, "ui/footer.fxml"));
+            assertEquals(Boolean.FALSE, has.invoke(dispatch, "ui/other.fxml"));
+
+            // The controller's constructor is private in the source.
+            Object controller = dispatchType.getMethod("create", String.class)
+                    .invoke(dispatch, "com.acme.fx.ShopController");
+            assertNotNull(controller);
+            Class<?> type = controller.getClass();
+            assertEquals("com.acme.fx.ShopController", type.getName());
+
+            Method inject = dispatchType.getMethod("inject", Object.class, String.class, Object.class);
+            Object footerController = dispatchType.getMethod("create", String.class)
+                    .invoke(dispatch, "com.acme.fx.FooterController");
+            assertEquals(Boolean.TRUE, inject.invoke(dispatch, controller, "footerController", footerController));
+            assertSame(footerController, field(controller, type, "footerController"));
+            assertEquals(Boolean.FALSE, inject.invoke(dispatch, controller, "nothing", footerController));
+            // A private field of the superclass, and one of no class.
+            try {
+                inject.invoke(dispatch, controller, "status", footerController);
+                org.junit.Assert.fail("A controller is not a Label");
+            } catch (java.lang.reflect.InvocationTargetException e) {
+                assertTrue(String.valueOf(e.getCause()), e.getCause() instanceof IllegalArgumentException);
+                assertTrue(e.getCause().getMessage(), e.getCause().getMessage().contains("status"));
+            }
+
+            Method invoke = dispatchType.getMethod("invoke", Object.class, String.class, Object.class);
+            Object event = loader.loadClass("com.codename1.fxcompat.javafx.event.ActionEvent").newInstance();
+            assertEquals(Boolean.TRUE, invoke.invoke(dispatch, controller, "onBuy", event));
+            assertEquals(Boolean.TRUE, invoke.invoke(dispatch, controller, "onBuy", event));
+            assertEquals(2, field(controller, type, "bought"));
+            assertEquals(Boolean.TRUE, invoke.invoke(dispatch, controller, "onClear", event));
+            assertEquals(0, field(controller, type, "bought"));
+            assertEquals(Boolean.FALSE, invoke.invoke(dispatch, controller, "onNothing", event));
+
+            assertEquals(Boolean.TRUE, dispatchType.getMethod("init", Object.class).invoke(dispatch, controller));
+            assertEquals(Boolean.FALSE, field(controller, type, "ready"));
+        } finally {
+            loader.close();
+        }
+    }
+
+    @Test
+    public void aSecondRunChangesNothing() throws Exception {
+        File classes = build();
+        assertTrue(remapper(classes).run());
+        File registry = new File(classes, "com/codename1/fxcompat/rt/FxmlRegistry.class");
+        File controller = new File(classes, "com/acme/fx/ShopController.class");
+        byte[] first = Files.readAllBytes(registry.toPath());
+        byte[] widened = Files.readAllBytes(controller.toPath());
+        long stamp = registry.lastModified();
+        assertTrue(remapper(classes).run());
+        assertTrue(Arrays.equals(first, Files.readAllBytes(registry.toPath())));
+        assertTrue(Arrays.equals(widened, Files.readAllBytes(controller.toPath())));
+        assertEquals(stamp, registry.lastModified());
+    }
+
+    @Test
+    public void anApplicationWithoutDocumentsStillGetsARegistry() throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(classpath(), tmp.newFolder(), classes, "com/acme/fx/Shop.java",
+                "package com.acme.fx;\npublic class Shop extends javafx.application.Application {\n"
+                        + "    public void start(javafx.stage.Stage stage) { }\n}\n");
+        assertTrue(remapper(classes).run());
+        // FxmlDispatch names the registry, so it has to be there to link.
+        assertTrue(new File(classes, "com/codename1/fxcompat/rt/FxmlRegistry.class").isFile());
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/IkonliFontIconTest.java b/maven/build-engine/src/test/java/com/codename1/maven/IkonliFontIconTest.java
new file mode 100644
index 00000000000..024c1154c64
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/IkonliFontIconTest.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+import org.junit.Assume;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/// A real library that finds its parts with `ServiceLoader`: Ikonli's Swing
+/// icons, with the Font Awesome pack, the way an application depends on
+/// them.
+///
+/// `FontIcon.of(FontAwesomeSolid.CODE_BRANCH, ...)` asks a resolver for the
+/// handler of that icon -- the handlers are service providers the pack lists
+/// in `META-INF/services`, named by no class -- and the handler for its
+/// font, a file under the pack's `META-INF/resources`. Here an application
+/// that does exactly that is compiled, remapped with the three jars bundled,
+/// held to the compliance check, and run with nothing on its class path but
+/// the remapped classes, the headless implementation and the framework: the
+/// icon has to come out with a size, which it has only if the handler and
+/// the font were both found through what the build shipped.
+///
+/// The jars are compiled for a newer JVM than the one this module's tests
+/// may run on, so the fixture is compiled and run by the JDK `JAVA17_HOME`
+/// (or `JAVA21_HOME`) names; the test is skipped where there is none.
+public class IkonliFontIconTest {
+
+    private static final String MAIN = "package com.acme.icons;\n"
+            + "import org.kordamp.ikonli.fontawesome5.FontAwesomeSolid;\n"
+            + "import org.kordamp.ikonli.swing.FontIcon;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) {\n"
+            + "        new javax.swing.JLabel(\"Branch\", FontIcon.of(FontAwesomeSolid.CODE_BRANCH, 16,\n"
+            + "                java.awt.Color.RED), javax.swing.JLabel.LEFT);\n"
+            + "    }\n"
+            + "    public static String probe() {\n"
+            + "        FontIcon icon = FontIcon.of(FontAwesomeSolid.CODE_BRANCH, 16, java.awt.Color.RED);\n"
+            + "        return icon.getIconWidth() + \"x\" + icon.getIconHeight() + \" \" + icon.getIkon().getDescription();\n"
+            + "    }\n"
+            + "}\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+    private final List<String> logged = new ArrayList<String>();
+
+    private final com.codename1.build.Log log = new com.codename1.build.Log() {
+        public void debug(CharSequence c) { }
+        public void debug(CharSequence c, Throwable e) { }
+        public void debug(Throwable e) { }
+        public void info(CharSequence c) { }
+        public void info(CharSequence c, Throwable e) { }
+        public void info(Throwable e) { }
+        public void warn(CharSequence c) { logged.add("warn: " + c); }
+        public void warn(CharSequence c, Throwable e) { }
+        public void warn(Throwable e) { }
+        public void error(CharSequence c) { }
+        public void error(CharSequence c, Throwable e) { }
+        public void error(Throwable e) { }
+        public boolean isDebugEnabled() { return false; }
+        public boolean isInfoEnabled() { return true; }
+        public boolean isWarnEnabled() { return true; }
+        public boolean isErrorEnabled() { return true; }
+    };
+
+    private static File jdk() {
+        String v = System.getProperty("java.specification.version");
+        if (!v.startsWith("1.") && Integer.parseInt(v) >= 11) {
+            return new File(System.getProperty("java.home"));
+        }
+        for (String name : new String[] {"JAVA17_HOME", "JAVA21_HOME", "JAVA25_HOME"}) {
+            String home = System.getenv(name);
+            if (home != null && new File(home, "bin/javac").isFile()) {
+                return new File(home);
+            }
+        }
+        return null;
+    }
+
+    private static String path(List<File> files) {
+        StringBuilder cp = new StringBuilder();
+        for (File f : files) {
+            cp.append(cp.length() == 0 ? "" : File.pathSeparator).append(f.getAbsolutePath());
+        }
+        return cp.toString();
+    }
+
+    private static String[] fork(String... args) throws Exception {
+        ProcessBuilder pb = new ProcessBuilder(args);
+        pb.redirectErrorStream(true);
+        final Process p = pb.start();
+        // A fork that never ends is a failure of this test, not of the build.
+        Thread watchdog = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(120000L);
+                    p.destroyForcibly();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }, "ikonli-probe-watchdog");
+        watchdog.setDaemon(true);
+        watchdog.start();
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            InputStream in = p.getInputStream();
+            byte[] buffer = new byte[8192];
+            for (int n = in.read(buffer); n >= 0; n = in.read(buffer)) {
+                out.write(buffer, 0, n);
+            }
+            return new String[] {String.valueOf(p.waitFor()), new String(out.toByteArray(), "UTF-8")};
+        } finally {
+            watchdog.interrupt();
+        }
+    }
+
+    @Test
+    public void anIconIsResolvedThroughTheShippedProvidersAndFont() throws Exception {
+        File jdk = jdk();
+        Assume.assumeTrue("needs a JDK 11 or newer (JAVA17_HOME)", jdk != null);
+        File scratch = tmp.newFolder("jars");
+        List<File> ikonli = Arrays.asList(RealCompatJars.jar("ikonli-swing", scratch),
+                RealCompatJars.jar("ikonli-core", scratch), RealCompatJars.jar("ikonli-fontawesome5-pack", scratch));
+        List<File> runtimes = Arrays.asList(RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch));
+
+        // javac, as the application's build runs it: against the JDK's
+        // Swing and the three jars.
+        File src = new File(tmp.newFolder(), "com/acme/icons/Main.java");
+        assertTrue(src.getParentFile().mkdirs());
+        Files.write(src.toPath(), MAIN.getBytes("UTF-8"));
+        File classes = tmp.newFolder("classes");
+        String[] compiled = fork(new File(jdk, "bin/javac").getAbsolutePath(), "--release", "11", "-nowarn", "-g",
+                "-cp", path(ikonli), "-d", classes.getAbsolutePath(), src.getAbsolutePath());
+        assertEquals(compiled[1], "0", compiled[0]);
+
+        List<File> cp = new ArrayList<File>(runtimes);
+        cp.addAll(ikonli);
+        File desktop = tmp.newFolder();
+        assertTrue(new CompatRemapper(classes, cp, null, log).withDesktopSourceDirectory(desktop)
+                .withResourceDirectories(Collections.<File>emptyList())
+                .withApplicationLibraries(ikonli).run());
+
+        // The handlers are reached through the services file alone, and the
+        // font is where the runtime looks for it.
+        assertTrue(new File(classes, "org/kordamp/ikonli/fontawesome5/FontAwesomeSolidIkonHandler.class").isFile());
+        assertTrue(new File(classes, "META-INF__resources__fontawesome5__5.15.3__fonts__fa-solid-900.ttf").isFile());
+        assertFalse(new File(classes, "META-INF/resources").exists());
+        assertFalse(new File(classes, "META-INF/services").exists());
+        assertTrue("Every provider the packs list can be created: " + logged, logged.isEmpty());
+
+        // Throws on a single finding, in the application or the three jars.
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        for (File jar : ikonli) {
+            host.artifacts.add(new BuildArtifact("org.kordamp.ikonli", jar.getName().replace(".jar", ""), "1", null,
+                    "jar", "compile", jar, null));
+        }
+        new BytecodeCompliance(host).execute();
+
+        // Run: the probe's own class, then nothing but what a device has.
+        File probe = new File(RemappedProbeMain.class.getProtectionDomain().getCodeSource().getLocation().toURI());
+        String[] ran = fork(new File(jdk, "bin/java").getAbsolutePath(), "-Djava.awt.headless=true", "-cp",
+                path(Arrays.asList(classes, RealCompatJars.jar("codenameone-compat-testing", scratch),
+                        RealCompatJars.core(scratch), probe)),
+                RemappedProbeMain.class.getName(), "com.acme.icons.Main", "probe");
+        assertEquals(ran[1], "0", ran[0]);
+        String result = null;
+        for (String line : ran[1].split("\n")) {
+            if (line.startsWith("RESULT:")) {
+                result = line.substring("RESULT:".length()).trim();
+            }
+        }
+        assertTrue(ran[1], result != null && result.endsWith(" fas-code-branch"));
+        String size = result.substring(0, result.indexOf(' '));
+        int width = Integer.parseInt(size.substring(0, size.indexOf('x')));
+        int height = Integer.parseInt(size.substring(size.indexOf('x') + 1));
+        assertTrue("The icon has the size of its glyph: " + result, width > 0 && height > 0);
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/JavaFxGallerySampleTest.java b/maven/build-engine/src/test/java/com/codename1/maven/JavaFxGallerySampleTest.java
new file mode 100644
index 00000000000..1c3c86f2e4b
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/JavaFxGallerySampleTest.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.fxml.DesktopResourceCompiler;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// The JavaFX gallery sample
+/// (`scripts/desktop-compat-samples/javafx-gallery`), taken through what a
+/// project's build does to it and then RUN.
+///
+/// The steps are the build's own, in its order: the resource compiler turns
+/// the style sheets into their compiled form and stands one marker source in
+/// for the FXML documents, javac compiles the application, and the remap
+/// step compiles the documents against the application's classes -- one of
+/// them is a custom control another document uses -- before it relocates
+/// everything onto the layer. The compliance check then has to find nothing,
+/// and the result is loaded into a class loader that holds nothing but those
+/// classes, the framework and the headless implementation the layers' own
+/// tests use.
+///
+/// The sample itself is compiled against the real OpenJFX by its own
+/// `mvn compile`, which the desktop compatibility workflow runs; here it is
+/// compiled against the layer, as an imported project is.
+///
+/// No window is opened anywhere: the display is a 1080 by 1920 buffer.
+public class JavaFxGallerySampleTest {
+
+    private static final String MAIN = "com.acme.fxgallery.GalleryMain";
+
+    private static final String FX = "com.codename1.fxcompat.javafx.";
+
+    /// The tabs in their order, and one string each draws that no other does.
+    ///
+    /// The headless display is a phone's width, narrower than the row of
+    /// buttons on the first tab, so that row shrinks and its buttons end in
+    /// three points as they do in JavaFX; the string looked for there is a
+    /// check box on a row of its own.
+    private static final String[][] TABS = {
+        {"Controls", "Send me the newsletter"},
+        {"Data", "Filter by name"},
+        {"Layouts", "GridPane form"},
+        {"Bindings", "Clicked 0 times"},
+        {"FXML", "Enter a name and press Greet"},
+        {"Shapes", "Redraw canvas"},
+        {"Animation", "0 frames"},
+        {"Dialogs", "Second window"},
+        {"Tasks", "Tick from a thread"},
+    };
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    /// The sample's directory, found from this module's.
+    private static File sample() {
+        File at = new File("").getAbsoluteFile();
+        for (int depth = 0; at != null && depth < 6; depth++) {
+            File candidate = new File(at, "scripts/desktop-compat-samples/javafx-gallery");
+            if (candidate.isDirectory()) {
+                return candidate;
+            }
+            at = at.getParentFile();
+        }
+        throw new AssertionError("scripts/desktop-compat-samples/javafx-gallery was not found above "
+                + new File("").getAbsolutePath());
+    }
+
+    /// Compiles and remaps the sample; answers the classes directory.
+    private File build() throws Exception {
+        scratch = tmp.newFolder("jars");
+        List<File> cp = Arrays.asList(RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch));
+
+        // prepare-desktop-sources.
+        File resources = new File(sample(), "src/main/resources");
+        File javaOut = tmp.newFolder();
+        File resourcesOut = tmp.newFolder();
+        final List<String> warnings = new ArrayList<String>();
+        DesktopResourceCompiler.Log log = new DesktopResourceCompiler.Log() {
+            @Override
+            public void info(String message) {
+            }
+
+            @Override
+            public void warn(String message) {
+                warnings.add(message);
+            }
+        };
+        List<String> errors = new DesktopResourceCompiler(Collections.singletonList(resources), javaOut,
+                resourcesOut, log).run();
+        assertTrue(errors.toString(), errors.isEmpty());
+        assertTrue("The sample's style sheets and documents compile without a warning: " + warnings,
+                warnings.isEmpty());
+
+        // javac. The importer drops the module descriptor.
+        List<String> all = new ArrayList<String>();
+        SwingGallerySampleTest.sources(new File(sample(), "src/main/java"), "", all);
+        int descriptor = all.indexOf("module-info.java");
+        assertTrue("The sample is a modular project", descriptor >= 0);
+        all.remove(descriptor);
+        all.remove(descriptor);
+        SwingGallerySampleTest.sources(javaOut, "", all);
+        // The main class cn1:import-desktop-project writes into the
+        // application's src/main/java, word for word.
+        DesktopProjectImporter.Candidate entry = new DesktopProjectImporter.Candidate(
+                "com.example.fxgallery.GalleryApp");
+        entry.javafx = true;
+        all.add(MAIN.replace('.', '/') + ".java");
+        all.add(DesktopProjectImporter.mainClassSource(MAIN, entry, false));
+        File classes = tmp.newFolder("classes");
+        CompatFixtures.compileAgainst(cp, tmp.newFolder(), classes, all.toArray(new String[all.size()]));
+
+        // process-resources.
+        SwingGallerySampleTest.copy(resources, classes);
+        SwingGallerySampleTest.copy(resourcesOut, classes);
+
+        // remap-compat, which compiles the documents first.
+        assertTrue(new CompatRemapper(classes, cp, null, CompatRemapperTest.LOG)
+                .withResourceDirectories(Arrays.asList(resources, resourcesOut)).run());
+
+        // Throws on a single finding, in the application, in the classes
+        // compiled from its documents or in the runtime the remap extracted.
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+        return classes;
+    }
+
+    @Test
+    public void theSampleRunsHeadless() throws Exception {
+        File classes = build();
+        // The three documents, the custom control's among them, are classes.
+        assertTrue(new File(classes, "com/codename1/generated/fxml/Fxml_com__example__fxgallery__fxml__profile.class")
+                .isFile());
+        assertTrue(new File(classes, "com/codename1/generated/fxml/Fxml_com__example__fxgallery__fxml__address.class")
+                .isFile());
+        assertTrue(new File(classes,
+                "com/codename1/generated/fxml/Fxml_com__example__fxgallery__control__status_mbadge.class").isFile());
+        assertFalse(new File(classes, "javafx").exists());
+        assertFalse(new File(classes, "com/example/fxgallery/images/logo.png").exists());
+
+        URL[] urls = {
+            classes.toURI().toURL(),
+            RealCompatJars.jar("codenameone-compat-testing", scratch).toURI().toURL(),
+            RealCompatJars.core(scratch).toURI().toURL(),
+            RealCompatJars.jdkHost(scratch).toURI().toURL(),
+        };
+        final URLClassLoader loader = new URLClassLoader(urls, ClassLoader.getSystemClassLoader().getParent());
+        try {
+            run(loader);
+        } finally {
+            loader.close();
+        }
+    }
+
+    private static Object call(Object target, String name, Object... args) throws Exception {
+        return SwingGallerySampleTest.invoke(target.getClass(), target, name, args);
+    }
+
+    /// Lets what the last step posted -- a pulse, a `runLater` -- go through
+    /// the queue.
+    private static void drain(Object display) throws Exception {
+        for (int i = 0; i < 3; i++) {
+            SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+                @Override
+                public void run() {
+                }
+            });
+        }
+    }
+
+    private void run(final ClassLoader loader) throws Exception {
+        final Class<?> headless = loader.loadClass("com.codename1.compat.testing.HeadlessImplementation");
+        // The sample decodes a PNG it ships for the window's icon.
+        headless.getField("pixelImages").setBoolean(null, true);
+        SwingGallerySampleTest.invoke(headless, null, "install");
+        final Class<?> displayClass = loader.loadClass("com.codename1.ui.Display");
+        final Object display = SwingGallerySampleTest.invoke(displayClass, null, "getInstance");
+
+        // An exception inside an event or a repaint never reaches the code
+        // that posted it; the framework hands it to these.
+        final List<String> errors = Collections.synchronizedList(new ArrayList<String>());
+        Class<?> listener = loader.loadClass("com.codename1.ui.events.ActionListener");
+        Object handler = Proxy.newProxyInstance(loader, new Class<?>[] {listener}, new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                if ("actionPerformed".equals(method.getName()) && args != null && args.length == 1) {
+                    Object source = call(args[0], "getSource");
+                    java.io.StringWriter trace = new java.io.StringWriter();
+                    if (source instanceof Throwable) {
+                        ((Throwable) source).printStackTrace(new java.io.PrintWriter(trace, true));
+                    }
+                    errors.add(source + "\n" + trace);
+                    call(args[0], "consume");
+                    return null;
+                }
+                if ("equals".equals(method.getName())) {
+                    return proxy == args[0];
+                }
+                if ("hashCode".equals(method.getName())) {
+                    return System.identityHashCode(proxy);
+                }
+                return "edt errors";
+            }
+        });
+        call(display, "addEdtErrorHandler", handler);
+
+        final Object lifecycle = loader.loadClass(MAIN).getConstructor().newInstance();
+        assertTrue(lifecycle.getClass().getSuperclass().getName(),
+                lifecycle.getClass().getSuperclass().getName().endsWith(".FxLifecycle"));
+        SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                call(lifecycle, "init", new Object[] {null});
+                call(lifecycle, "start");
+            }
+        });
+        drain(display);
+
+        final Object[] form = new Object[1];
+        final Object[] scene = new Object[1];
+        final Object[] tabPane = new Object[1];
+        SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                List<?> windows = (List<?>) SwingGallerySampleTest.invoke(
+                        loader.loadClass(FX + "stage.Window"), null, "getWindows");
+                assertEquals("The application shows one stage; " + errors, 1, windows.size());
+                Object stage = windows.get(0);
+                assertEquals("JavaFX Gallery", call(stage, "getTitle"));
+                assertEquals("The window's icon was decoded from the application's resources",
+                        1, ((List<?>) call(stage, "getIcons")).size());
+                form[0] = call(display, "getCurrent");
+                assertNotNull("A form is showing; " + errors, form[0]);
+                assertTrue(loader.loadClass("com.codename1.ui.Form").isInstance(form[0]));
+                scene[0] = call(stage, "getScene");
+                tabPane[0] = call(call(scene[0], "getRoot"), "getCenter");
+                assertEquals(FX + "scene.control.TabPane", tabPane[0].getClass().getName());
+                assertEquals(TABS.length, ((List<?>) call(tabPane[0], "getTabs")).size());
+            }
+        });
+
+        final List<String> painted = new ArrayList<String>();
+        for (int i = 0; i < TABS.length; i++) {
+            final int index = i;
+            SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+                @Override
+                public void run() throws Exception {
+                    Object tab = ((List<?>) call(tabPane[0], "getTabs")).get(index);
+                    assertEquals(TABS[index][0], call(tab, "getText"));
+                    Object selection = call(tabPane[0], "getSelectionModel");
+                    // select(int) refuses a Tab; select(T) is the one left.
+                    call(selection, "select", tab);
+                    assertEquals(Integer.valueOf(index), call(selection, "getSelectedIndex"));
+                }
+            });
+            // The pulse that lays the tab out and styles it.
+            drain(display);
+            SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+                @Override
+                public void run() throws Exception {
+                    call(form[0], "revalidate");
+                    List<String> text = SwingGallerySampleTest.paint(loader, form[0]);
+                    assertTrue(TABS[index][0] + " paints " + TABS[index][1] + ": " + text + errors,
+                            text.contains(TABS[index][1]));
+                    if (index > 0) {
+                        // The application's own listener on the selection.
+                        assertEquals("Showing " + TABS[index][0], call(call(scene[0], "lookup", "#status"), "getText"));
+                    }
+                    painted.add(TABS[index][0]);
+                }
+            });
+        }
+        assertEquals(TABS.length, painted.size());
+
+        // The FXML tab: the document's controller, the included document's
+        // and the custom control, through the button's handler.
+        SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                Object tab = ((List<?>) call(tabPane[0], "getTabs")).get(4);
+                call(call(tabPane[0], "getSelectionModel"), "select", tab);
+            }
+        });
+        drain(display);
+        SwingGallerySampleTest.onEdt(display, new SwingGallerySampleTest.ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                Object name = call(scene[0], "lookup", "#nameField");
+                Object greet = call(scene[0], "lookup", "#greetButton");
+                Object greeting = call(scene[0], "lookup", "#greeting");
+                Object badge = call(scene[0], "lookup", "#badge");
+                assertNotNull("fx:id is the node's id where the document sets none", name);
+                assertNotNull(greet);
+                assertNotNull(greeting);
+                assertNotNull(badge);
+                assertEquals("com.example.fxgallery.control.StatusBadge", badge.getClass().getName());
+                // From the resource bundle, by the controller's initialize().
+                assertEquals("Enter a name and press Greet", call(greeting, "getText"));
+                assertEquals("The button is bound to the empty name field", Boolean.TRUE, call(greet, "isDisabled"));
+                call(name, "setText", "Ada");
+                assertEquals(Boolean.FALSE, call(greet, "isDisabled"));
+                call(greet, "fire");
+                String said = (String) call(greeting, "getText");
+                assertEquals("Greeted 1", call(badge, "getText"));
+                assertTrue(said, said.startsWith("Hello, Ada (Developer, free) from "));
+                assertEquals(1, call(badge, "getLevel"));
+
+                // Style sheets: the scene's, looked up through .root, and
+                // the one the document names.
+                Object status = call(scene[0], "lookup", "#status");
+                assertEquals("0x0d47a1ff", String.valueOf(call(status, "getTextFill")));
+                assertEquals(15.0, ((Double) call(call(greeting, "getFont"), "getSize")).doubleValue(), 0.01);
+            }
+        });
+        drain(display);
+        assertTrue("Nothing may be thrown on the event dispatch thread: " + errors, errors.isEmpty());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/JdkShimsRemapTest.java b/maven/build-engine/src/test/java/com/codename1/maven/JdkShimsRemapTest.java
new file mode 100644
index 00000000000..ce7e71dbbd3
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/JdkShimsRemapTest.java
@@ -0,0 +1,749 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+/// The remap step and the JDK, end to end: source written against the JDK is
+/// compiled, run, relocated by the remap step and run again, and has to
+/// answer the same.
+///
+/// What a device's class library has under the JDK's name -- nearly all of
+/// it -- keeps its name, and a case says so with [RemapDifferential#keeps].
+/// What is moved -- regular expressions to the framework's matcher, resource
+/// and service lookups to `com.codename1.impl.compat.Resources` -- has to be
+/// named by no remapped class, so the second run really is the stand-in's.
+public class JdkShimsRemapTest {
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private RemapDifferential java8() throws Exception {
+        return new RemapDifferential(tmp.newFolder(), 8);
+    }
+
+    @Test
+    public void textIsEncodedAndDecodedByCharset() throws Exception {
+        RemapDifferential d = java8();
+        d.same(""
+                + "byte[] utf = \"caf\\u00e9 \\u20ac\".getBytes(StandardCharsets.UTF_8);\n"
+                + "out.add(utf);\n"
+                + "out.add(new String(utf, StandardCharsets.UTF_8));\n"
+                + "out.add(new String(utf, 0, 3, StandardCharsets.US_ASCII));\n"
+                + "out.add(new String(utf, 1, 4, StandardCharsets.ISO_8859_1).length());\n"
+                + "out.add(StandardCharsets.UTF_8.name());\n"
+                + "out.add(StandardCharsets.ISO_8859_1.toString());\n"
+                + "out.add(Charset.forName(\"utf-8\").name());\n"
+                + "out.add(Charset.forName(\"UTF8\") == StandardCharsets.UTF_8);\n"
+                + "out.add(Charset.forName(\"latin1\").name());\n"
+                + "out.add(Charset.forName(\"ascii\").name());\n"
+                + "out.add(Charset.isSupported(\"UTF-8\"));\n"
+                + "out.add(Charset.defaultCharset() != null);\n"
+                + "Reader r = new InputStreamReader(new ByteArrayInputStream(utf), StandardCharsets.UTF_8);\n"
+                + "StringBuilder sb = new StringBuilder();\n"
+                + "for (int c = r.read(); c >= 0; c = r.read()) { sb.append((char) c); }\n"
+                + "out.add(sb.toString());\n"
+                + "ByteArrayOutputStream bytes = new ByteArrayOutputStream();\n"
+                + "Writer w = new OutputStreamWriter(bytes, StandardCharsets.UTF_8);\n"
+                + "w.write(\"na\\u00efve\");\n"
+                + "w.close();\n"
+                + "out.add(bytes.toByteArray());\n"
+                + "out.add(bytes.toString(\"UTF-8\"));\n", 14);
+        d.keeps("java/nio/charset/Charset", "forName");
+    }
+
+    /// On a JDK that has `findFirst` and `stream`, which is also the one
+    /// whose iterations share what either created. The providers come from
+    /// a services file with the comments, blank lines and repeats the format
+    /// allows. `ServiceLoader.load` goes through `Resources`, which with no
+    /// port loader installed is the JDK's own call; the device's registry is
+    /// `ServiceProvidersTest`'s.
+    @Test
+    public void serviceProvidersAreLoadedInFileOrderAndLazily() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 17);
+        org.junit.Assume.assumeTrue("needs a JDK 17 (JAVA17_HOME)", d.available());
+        d.source("Shape", "public interface Shape { String name(); }\n")
+                .source("Lonely", "public interface Lonely { }\n")
+                .source("Made", "public class Made { public static final List<String> LOG = new ArrayList<>(); }\n")
+                .source("Circle", "public class Circle implements Shape {\n"
+                        + "    public Circle() { Made.LOG.add(\"circle\"); }\n"
+                        + "    public String name() { return \"circle\"; }\n}\n")
+                .source("Square", "public class Square implements Shape {\n"
+                        + "    public Square() { Made.LOG.add(\"square\"); }\n"
+                        + "    public String name() { return \"square\"; }\n}\n")
+                .resource("META-INF/services/q.Shape",
+                        "# shapes\n\n  q.Square   # first\nq.Circle\n\t\nq.Square\n");
+        d.same(""
+                + "ServiceLoader<Shape> l = ServiceLoader.load(Shape.class);\n"
+                + "out.add(l.toString());\n"
+                + "out.add(new ArrayList<>(Made.LOG));\n"
+                + "Iterator<Shape> it = l.iterator();\n"
+                + "out.add(it.hasNext() + \" \" + Made.LOG);\n"
+                + "out.add(it.next().name() + \" \" + Made.LOG);\n"
+                + "Iterator<Shape> other = l.iterator();\n"
+                + "out.add(other.next().name() + \" \" + Made.LOG);\n"
+                + "out.add(other.next().name() + \" \" + Made.LOG);\n"
+                + "out.add(it.next().name() + \" \" + Made.LOG);\n"
+                + "out.add(it.hasNext() + \" \" + other.hasNext());\n"
+                + "try { it.next(); out.add(\"no\"); } catch (NoSuchElementException e) { out.add(\"ended\"); }\n"
+                + "List<String> names = new ArrayList<>();\n"
+                + "l.forEach(s -> names.add(s.name()));\n"
+                + "out.add(names + \" \" + Made.LOG);\n"
+                + "out.add(l.findFirst().get().name());\n"
+                + "out.add(l.findFirst().get() == l.iterator().next());\n"
+                + "out.add(ServiceLoader.load(Lonely.class).findFirst().isPresent());\n"
+                + "out.add(ServiceLoader.load(Lonely.class).iterator().hasNext());\n"
+                + "out.add(l.stream().map(p -> p.type().getName()).collect(Collectors.toList()) + \" \" + Made.LOG);\n"
+                + "out.add(l.stream().map(p -> p.get().name()).collect(Collectors.toList()));\n"
+                + "l.reload();\n"
+                + "Made.LOG.clear();\n"
+                + "out.add(l.iterator().next().name() + \" \" + Made.LOG);\n"
+                + "out.add(ServiceLoader.load(Shape.class, Shape.class.getClassLoader()).iterator().next().name());\n"
+                + "out.add(ServiceLoader.loadInstalled(Shape.class).iterator().hasNext());\n"
+                + "try { ServiceLoader.load(null); out.add(\"no\"); } catch (NullPointerException e) { out.add(\"npe\"); }\n",
+                18);
+        d.keeps("java/util/ServiceLoader", "com/codename1/impl/compat/Resources");
+    }
+
+    @Test
+    public void aClassIsInTheUnnamedModule() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 17);
+        org.junit.Assume.assumeTrue("needs a JDK 17 (JAVA17_HOME)", d.available());
+        d.source("Here", "public class Here { }\n");
+        d.same(""
+                + "Module m = Here.class.getModule();\n"
+                + "out.add(m.isNamed());\n"
+                + "out.add(m.getName());\n"
+                + "out.add(m.getLayer() == null);\n"
+                + "out.add(m == D.class.getModule());\n"
+                + "ModuleLayer none = m.getLayer();\n"
+                + "out.add(none);\n"
+                + "try { ServiceLoader.load(none, Here.class); out.add(\"no\"); }"
+                + " catch (NullPointerException e) { out.add(\"npe\"); }\n",
+                6);
+        d.keeps("java/lang/Module", "java/lang/ModuleLayer");
+    }
+
+    @Test
+    public void aCopyOnWriteSetIteratesOverWhatItHeldWhenAsked() throws Exception {
+        RemapDifferential d = java8();
+        d.same(""
+                + "CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>(Arrays.asList(\"b\", \"a\", \"b\"));\n"
+                + "out.add(set.toString() + set.size());\n"
+                + "out.add(set.add(\"a\") + \" \" + set.add(\"c\"));\n"
+                + "List<String> seen = new ArrayList<>();\n"
+                + "for (String s : set) { seen.add(s); set.add(s + s); set.remove(\"c\"); }\n"
+                + "out.add(seen);\n"
+                + "out.add(set);\n"
+                + "Iterator<String> it = set.iterator();\n"
+                + "it.next();\n"
+                + "try { it.remove(); out.add(\"no\"); } catch (UnsupportedOperationException e) { out.add(\"fixed\"); }\n"
+                + "out.add(set.contains(\"aa\") + \" \" + set.containsAll(Arrays.asList(\"a\", \"bb\")));\n"
+                + "out.add(set.addAll(Arrays.asList(\"a\", \"z\", \"z\")) + \" \" + set);\n"
+                + "out.add(set.removeAll(Arrays.asList(\"z\", \"q\")) + \" \" + set);\n"
+                + "out.add(set.retainAll(Arrays.asList(\"a\", \"b\")) + \" \" + set);\n"
+                + "out.add(set.removeIf(s -> s.equals(\"a\")) + \" \" + set);\n"
+                + "out.add(set.equals(new HashSet<>(Arrays.asList(\"b\"))) + \" \" + (set.hashCode() == \"b\".hashCode()));\n"
+                + "out.add(set.toArray());\n"
+                + "out.add(set.toArray(new String[0]));\n"
+                + "set.clear();\n"
+                + "out.add(set.isEmpty());\n"
+                + "out.add(new CopyOnWriteArraySet<Integer>().iterator().hasNext());\n",
+                13);
+        d.keeps("java/util/concurrent/CopyOnWriteArraySet");
+    }
+
+    /// The four OSGi types a library asks about before taking its class
+    /// path route are answered "not in a framework", and nothing else of
+    /// OSGi is mapped.
+    @Test
+    public void aLibraryThatAsksIsToldItIsNotInAnOsgiFramework() {
+        ClassRelocator relocator = new ClassRelocator(CompatLayers.SWING);
+        org.junit.Assert.assertEquals("com/codename1/impl/compat/osgi/FrameworkUtil", relocator.map("org/osgi/framework/FrameworkUtil"));
+        org.junit.Assert.assertEquals("com/codename1/impl/compat/osgi/Bundle", relocator.map("org/osgi/framework/Bundle"));
+        org.junit.Assert.assertEquals("com/codename1/impl/compat/osgi/BundleContext", relocator.map("org/osgi/framework/BundleContext"));
+        org.junit.Assert.assertEquals("com/codename1/impl/compat/osgi/ServiceReference",
+                relocator.map("org/osgi/framework/ServiceReference"));
+        org.junit.Assert.assertEquals("org/osgi/framework/BundleActivator", relocator.map("org/osgi/framework/BundleActivator"));
+        org.junit.Assert.assertNull(com.codename1.impl.compat.osgi.FrameworkUtil.getBundle(String.class));
+    }
+
+    @Test
+    public void regularExpressionsAreTheJdks() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 8);
+        d.same(""
+                + "Pattern p = Pattern.compile(\"(?<key>[a-z]+)=(\\\\d+)\", Pattern.CASE_INSENSITIVE);\n"
+                + "Matcher m = p.matcher(\"Alpha=1, beta=22; GAMMA=333\");\n"
+                + "while (m.find()) {\n"
+                + "    out.add(m.group(\"key\") + \":\" + m.group(2) + \"@\" + m.start() + \"-\" + m.end());\n"
+                + "}\n"
+                + "out.add(m.replaceAll(\"$2=${key}\"));\n"
+                + "out.add(p.split(\"x a=1 y b=2 z\"));\n"
+                + "out.add(\"a1b22c\".split(\"\\\\d+\"));\n"
+                + "out.add(\"a,b,,\".split(\",\"));\n"
+                + "out.add(\"a,b,,\".split(\",\", -1));\n"
+                + "out.add(\"2024-02-29\".matches(\"\\\\d{4}-\\\\d{2}-\\\\d{2}\"));\n"
+                + "out.add(\"  trim  me \".replaceAll(\"^\\\\s+|\\\\s+$\", \"\"));\n"
+                + "out.add(\"camelCaseName\".replaceAll(\"(?<=[a-z])(?=[A-Z])\", \"_\"));\n"
+                + "out.add(\"a.b.c\".replaceFirst(\"\\\\.\", \"/\"));\n"
+                + "out.add(Pattern.matches(\"[\\\\w.]+@[\\\\w.]+\", \"me@example.com\"));\n"
+                + "out.add(Pattern.quote(\"a.b\"));\n"
+                + "out.add(Matcher.quoteReplacement(\"$1\"));\n"
+                + "try {\n"
+                + "    Pattern.compile(\"(unclosed\");\n"
+                + "} catch (PatternSyntaxException e) {\n"
+                + "    out.add(e.getIndex() + \"|\" + e.getPattern() + \"|\" + e.getDescription());\n"
+                + "}\n"
+                + "MatchResult r = Pattern.compile(\"b+\").matcher(\"abbbc\");\n"
+                + "out.add(((Matcher) r).find() ? r.group() + r.start() + r.end() + r.groupCount() : \"none\");\n"
+                + "out.add(Pattern.compile(\"\\\\s*,\\\\s*\").splitAsStream(\"a , b,c\").collect(Collectors.toList()));\n"
+                + "out.add(Pattern.compile(\"^\\\\d+$\").asPredicate().test(\"123\"));\n"
+                + "StringBuffer sb = new StringBuffer();\n"
+                + "Matcher d2 = Pattern.compile(\"\\\\d\").matcher(\"a1b2\");\n"
+                + "while (d2.find()) {\n"
+                + "    d2.appendReplacement(sb, \"<\" + d2.group() + \">\");\n"
+                + "}\n"
+                + "out.add(d2.appendTail(sb).toString());\n", 20, "java/util/regex/");
+        d.keeps("com/codename1/util/regex/Pattern", "com/codename1/util/regex/StringRegex");
+    }
+
+    @Test
+    public void futuresLatchesAndScheduledWorkCompleteAsInTheJdk() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 8);
+        d.same(""
+                + "CompletableFuture<Integer> one = CompletableFuture.supplyAsync(() -> 1);\n"
+                + "out.add(one.get());\n"
+                + "out.add(one.thenApply(x -> x + 1).thenApply(x -> x * 10).join());\n"
+                + "out.add(CompletableFuture.completedFuture(\"a\").thenCombine(CompletableFuture.supplyAsync(() -> \"b\"), (a, b) -> a + b).get());\n"
+                + "out.add(CompletableFuture.supplyAsync(() -> 2).thenCompose(x -> CompletableFuture.supplyAsync(() -> x * 3)).get(5, TimeUnit.SECONDS));\n"
+                + "List<String> seen = new ArrayList<>();\n"
+                + "CompletableFuture<Void> accepted = CompletableFuture.completedFuture(\"v\").thenAccept(seen::add).thenRun(() -> seen.add(\"ran\"));\n"
+                + "accepted.join();\n"
+                + "out.add(seen);\n"
+                + "CompletableFuture<String> failed = CompletableFuture.supplyAsync(() -> { throw new IllegalStateException(\"boom\"); });\n"
+                + "try {\n"
+                + "    failed.get();\n"
+                + "} catch (ExecutionException e) {\n"
+                + "    out.add(\"get: \" + e.getCause().getClass().getSimpleName() + \" \" + e.getCause().getMessage());\n"
+                + "}\n"
+                + "try {\n"
+                + "    failed.join();\n"
+                + "} catch (CompletionException e) {\n"
+                + "    out.add(\"join: \" + e.getCause().getClass().getSimpleName());\n"
+                + "}\n"
+                + "out.add(failed.isCompletedExceptionally() + \" \" + failed.isDone() + \" \" + failed.isCancelled());\n"
+                + "out.add(failed.exceptionally(t -> \"recovered \" + t.getClass().getSimpleName() + \"/\" + t.getCause().getMessage()).join());\n"
+                + "out.add(failed.handle((v, t) -> v == null ? \"handled \" + (t != null) : v).join());\n"
+                + "CompletableFuture<String> dependent = failed.thenApply(s -> s + \"!\");\n"
+                + "try {\n"
+                + "    dependent.join();\n"
+                + "} catch (CompletionException e) {\n"
+                + "    out.add(\"dependent: \" + e.getCause().getMessage());\n"
+                + "}\n"
+                + "out.add(dependent.exceptionally(t -> t.getClass().getSimpleName()).join());\n"
+                + "List<String> log = new ArrayList<>();\n"
+                + "out.add(CompletableFuture.completedFuture(5).whenComplete((v, t) -> log.add(v + \"/\" + t)).join());\n"
+                + "try {\n"
+                + "    failed.whenComplete((v, t) -> log.add(v + \"/\" + (t != null))).join();\n"
+                + "} catch (CompletionException e) {\n"
+                + "    log.add(\"still failed\");\n"
+                + "}\n"
+                + "out.add(log);\n"
+                + "CompletableFuture<String> manual = new CompletableFuture<>();\n"
+                + "out.add(manual.isDone() + \" \" + manual.getNow(\"absent\"));\n"
+                + "CompletableFuture<Integer> length = manual.thenApply(String::length);\n"
+                + "out.add(manual.complete(\"done\") + \" \" + manual.complete(\"again\") + \" \" + manual.get() + \" \" + length.get());\n"
+                + "CompletableFuture<String> raw = new CompletableFuture<>();\n"
+                + "raw.completeExceptionally(new java.io.IOException(\"io\"));\n"
+                + "try {\n"
+                + "    raw.join();\n"
+                + "} catch (CompletionException e) {\n"
+                + "    out.add(\"raw join: \" + e.getCause().getClass().getSimpleName());\n"
+                + "}\n"
+                + "out.add(raw.exceptionally(t -> t.getClass().getSimpleName()).join());\n"
+                + "try {\n"
+                + "    raw.get();\n"
+                + "} catch (ExecutionException e) {\n"
+                + "    out.add(\"raw get: \" + e.getCause().getMessage());\n"
+                + "}\n"
+                + "CompletableFuture<String> cancelled = new CompletableFuture<>();\n"
+                + "out.add(cancelled.cancel(true) + \" \" + cancelled.isCancelled() + \" \" + cancelled.isCompletedExceptionally());\n"
+                + "try {\n"
+                + "    cancelled.get();\n"
+                + "} catch (CancellationException e) {\n"
+                + "    out.add(\"cancelled get\");\n"
+                + "}\n"
+                + "try {\n"
+                + "    cancelled.join();\n"
+                + "} catch (CancellationException e) {\n"
+                + "    out.add(\"cancelled join\");\n"
+                + "}\n"
+                + "try {\n"
+                + "    cancelled.thenApply(s -> s).join();\n"
+                + "} catch (CompletionException e) {\n"
+                + "    out.add(\"after cancel: \" + e.getCause().getClass().getSimpleName());\n"
+                + "}\n"
+                + "CompletableFuture<Integer> a = CompletableFuture.supplyAsync(() -> 10);\n"
+                + "CompletableFuture<Integer> b = CompletableFuture.supplyAsync(() -> 20);\n"
+                + "CompletableFuture<Integer> c = new CompletableFuture<>();\n"
+                + "CompletableFuture<Void> all = CompletableFuture.allOf(a, b, c);\n"
+                + "out.add(all.isDone());\n"
+                + "c.complete(30);\n"
+                + "all.get(5, TimeUnit.SECONDS);\n"
+                + "out.add(a.join() + b.join() + c.join());\n"
+                + "out.add(CompletableFuture.allOf().isDone());\n"
+                + "out.add(CompletableFuture.anyOf(new CompletableFuture<String>(), CompletableFuture.completedFuture(\"first\")).join());\n"
+                + "try {\n"
+                + "    CompletableFuture.allOf(a, raw).join();\n"
+                + "} catch (CompletionException e) {\n"
+                + "    out.add(\"allOf failed: \" + e.getCause().getMessage());\n"
+                + "}\n"
+                + "out.add(new CompletableFuture<String>().applyToEither(CompletableFuture.completedFuture(\"right\"), s -> s + \"!\").join());\n"
+                + "List<String> both = new ArrayList<>();\n"
+                + "a.thenAcceptBoth(b, (x, y) -> both.add(\"\" + (x + y))).join();\n"
+                + "a.runAfterBoth(b, () -> both.add(\"both\")).join();\n"
+                + "a.acceptEither(new CompletableFuture<Integer>(), x -> both.add(\"either \" + x)).join();\n"
+                + "a.runAfterEither(new CompletableFuture<Object>(), () -> both.add(\"ran either\")).join();\n"
+                + "out.add(both);\n"
+                + "CompletableFuture<String> never = new CompletableFuture<>();\n"
+                + "try {\n"
+                + "    never.get(50, TimeUnit.MILLISECONDS);\n"
+                + "} catch (TimeoutException e) {\n"
+                + "    out.add(\"timed out\");\n"
+                + "}\n"
+                + "Executor direct = Runnable::run;\n"
+                + "out.add(CompletableFuture.supplyAsync(() -> \"on executor\", direct).thenApplyAsync(String::toUpperCase, direct).join());\n"
+                + "out.add(CompletableFuture.runAsync(() -> seen.add(\"async\")).thenApply(v -> seen.size()).get());\n"
+                + "CompletionStage<String> stage = CompletableFuture.completedFuture(\"stage\");\n"
+                + "out.add(stage.thenApply(s -> s + \"d\").toCompletableFuture().join());\n"
+                + "CountDownLatch latch = new CountDownLatch(3);\n"
+                + "ExecutorService pool = Executors.newFixedThreadPool(2);\n"
+                + "AtomicInteger sum = new AtomicInteger();\n"
+                + "for (int i = 1; i <= 3; i++) {\n"
+                + "    final int n = i;\n"
+                + "    pool.execute(() -> { sum.addAndGet(n); latch.countDown(); });\n"
+                + "}\n"
+                + "out.add(latch.await(5, TimeUnit.SECONDS) + \" \" + sum.get() + \" \" + latch.getCount());\n"
+                + "out.add(new CountDownLatch(1).await(20, TimeUnit.MILLISECONDS));\n"
+                + "Future<String> submitted = pool.submit(() -> \"submitted\");\n"
+                + "out.add(submitted.get());\n"
+                + "pool.shutdown();\n"
+                + "out.add(pool.awaitTermination(5, TimeUnit.SECONDS));\n"
+                + "ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor();\n"
+                + "ScheduledFuture<String> later = timer.schedule(() -> \"later\", 30, TimeUnit.MILLISECONDS);\n"
+                + "out.add(later.get(5, TimeUnit.SECONDS) + \" \" + later.isDone());\n"
+                + "AtomicInteger ticks = new AtomicInteger();\n"
+                + "CountDownLatch three = new CountDownLatch(3);\n"
+                + "ScheduledFuture<?> repeating = timer.scheduleAtFixedRate(() -> { ticks.incrementAndGet(); three.countDown(); }, 0, 10, TimeUnit.MILLISECONDS);\n"
+                + "out.add(three.await(5, TimeUnit.SECONDS));\n"
+                + "out.add(repeating.cancel(false) + \" \" + repeating.isCancelled() + \" \" + (ticks.get() >= 3));\n"
+                + "CountDownLatch two = new CountDownLatch(2);\n"
+                + "ScheduledFuture<?> delayed = timer.scheduleWithFixedDelay(two::countDown, 5, 5, TimeUnit.MILLISECONDS);\n"
+                + "out.add(two.await(5, TimeUnit.SECONDS));\n"
+                + "delayed.cancel(false);\n"
+                + "ScheduledFuture<?> dropped = timer.schedule(() -> { }, 1, TimeUnit.HOURS);\n"
+                + "out.add(dropped.cancel(false) + \" \" + dropped.isDone());\n"
+                + "timer.shutdownNow();\n"
+                + "out.add(timer.isShutdown());\n"
+                + "ExecutorService named = Executors.newSingleThreadExecutor(r -> new Thread(r, \"named\"));\n"
+                + "out.add(named.submit(() -> 7).get());\n"
+                + "named.shutdown();\n"
+                + "out.add(Executors.newCachedThreadPool(Executors.defaultThreadFactory()).submit(() -> 8).get());\n", 45);
+        d.keeps("java/util/concurrent/CompletableFuture", "java/util/concurrent/ScheduledExecutorService",
+                "java/util/concurrent/TimeUnit");
+    }
+
+    @Test
+    public void datesTimesAndDurationsAreTheJdks() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 17);
+        org.junit.Assume.assumeTrue("needs a JDK 17", d.available());
+        d.same(""
+                + "ZoneId utc = ZoneId.of(\"UTC\");\n"
+                + "LocalDate d = LocalDate.of(2024, 2, 29);\n"
+                + "out.add(d.getDayOfWeek() + \" \" + d.getMonth() + \" \" + d.getDayOfYear() + \" \" + d.lengthOfYear());\n"
+                + "out.add(d.getDayOfWeek().getValue() + \" \" + d.getDayOfWeek().plus(3) + \" \" + DayOfWeek.of(7) + \" \" + DayOfWeek.valueOf(\"FRIDAY\").minus(9));\n"
+                + "out.add(d.getMonth().getValue() + \" \" + d.getMonth().plus(11) + \" \" + Month.of(12).maxLength() + \" \" + Month.FEBRUARY.length(false));\n"
+                + "out.add(Arrays.asList(DayOfWeek.values()));\n"
+                + "out.add(d.atStartOfDay());\n"
+                + "out.add(d.withDayOfMonth(1) + \" \" + d.withMonth(4) + \" \" + d.withYear(2023) + \" \" + d.withDayOfYear(366));\n"
+                + "out.add(d.plus(1, ChronoUnit.MONTHS) + \" \" + d.minus(1, ChronoUnit.YEARS) + \" \" + d.plus(3, ChronoUnit.WEEKS) + \" \" + d.plus(2, ChronoUnit.DECADES));\n"
+                + "out.add(d.plus(Period.of(1, 1, 1)) + \" \" + d.minus(Period.ofMonths(1)));\n"
+                + "out.add(d.datesUntil(LocalDate.of(2024, 3, 3)).map(LocalDate::toString).collect(Collectors.joining(\",\")));\n"
+                + "out.add(d.datesUntil(d).count());\n"
+                + "try {\n"
+                + "    d.datesUntil(d.minusDays(1));\n"
+                + "    out.add(\"no failure\");\n"
+                + "} catch (IllegalArgumentException e) {\n"
+                + "    out.add(\"backwards\");\n"
+                + "}\n"
+                + "LocalDate e = LocalDate.of(2026, 10, 9);\n"
+                + "for (ChronoUnit u : ChronoUnit.values()) {\n"
+                + "    try {\n"
+                + "        out.add(u + \" \" + u.between(d, e) + \" \" + d.until(e, u) + \" \" + u.isDateBased() + \" \" + u.isTimeBased() + \" \" + u.getDuration());\n"
+                + "    } catch (DateTimeException x) {\n"
+                + "        out.add(u + \" unsupported for dates\");\n"
+                + "    }\n"
+                + "}\n"
+                + "out.add(ChronoUnit.DAYS.between(e, d) + \" \" + ChronoUnit.valueOf(\"HOURS\") + \" \" + ChronoUnit.HOURS.name());\n"
+                + "out.add(LocalDate.of(2024, Month.MARCH, 31).plusMonths(1) + \" \" + LocalDate.ofInstant(Instant.ofEpochSecond(86400L * 366), utc));\n"
+                + "LocalDateTime t = LocalDateTime.of(2024, 3, 31, 23, 59, 58, 123456789);\n"
+                + "out.add(t.getDayOfWeek() + \" \" + t.getMonth() + \" \" + t.getDayOfYear());\n"
+                + "out.add(t.minusDays(31) + \" \" + t.minusHours(25) + \" \" + t.minusMinutes(61) + \" \" + t.minusSeconds(59) + \" \" + t.plusNanos(999999999999L));\n"
+                + "out.add(t.plusWeeks(1) + \" \" + t.minusWeeks(1) + \" \" + t.plusMonths(11) + \" \" + t.minusMonths(1) + \" \" + t.plusYears(4) + \" \" + t.minusYears(1));\n"
+                + "out.add(t.withHour(1) + \" \" + t.withMinute(2) + \" \" + t.withSecond(3) + \" \" + t.withNano(4));\n"
+                + "out.add(t.truncatedTo(ChronoUnit.HOURS) + \" \" + t.truncatedTo(ChronoUnit.DAYS) + \" \" + t.truncatedTo(ChronoUnit.MILLIS));\n"
+                + "out.add(t.plus(90, ChronoUnit.MINUTES) + \" \" + t.minus(2, ChronoUnit.HALF_DAYS) + \" \" + t.plus(Duration.ofHours(49)) + \" \" + t.minus(Period.ofDays(31)));\n"
+                + "LocalDateTime later = LocalDateTime.of(2026, 10, 9, 8, 0);\n"
+                + "out.add(t.isBefore(later) + \" \" + t.isAfter(later) + \" \" + t.isEqual(t) + \" \" + t.toEpochSecond(ZoneOffset.UTC));\n"
+                + "out.add(ChronoUnit.HOURS.between(t, later) + \" \" + ChronoUnit.MONTHS.between(t, later) + \" \" + t.until(later, ChronoUnit.MILLIS) + \" \" + ChronoUnit.MINUTES.between(later, t));\n"
+                + "Instant i = Instant.ofEpochSecond(1700000000L, 5);\n"
+                + "ZonedDateTime z = i.atZone(utc);\n"
+                + "out.add(z.toLocalDate() + \" \" + z.toLocalTime() + \" \" + z.toEpochSecond() + \" \" + z.toLocalDateTime());\n"
+                + "out.add(z.getYear() + \" \" + z.getMonthValue() + \" \" + z.getMonth() + \" \" + z.getDayOfMonth() + \" \" + z.getDayOfYear() + \" \" + z.getDayOfWeek() + \" \" + z.getHour() + \" \" + z.getMinute() + \" \" + z.getSecond() + \" \" + z.getNano());\n"
+                + "out.add(z.plusDays(1).toInstant() + \" \" + z.minusWeeks(1).toInstant() + \" \" + z.plusMonths(3).toInstant() + \" \" + z.minusYears(1).toInstant() + \" \" + z.plusHours(30).toInstant() + \" \" + z.minusMinutes(1).toInstant() + \" \" + z.plusSeconds(1).toInstant());\n"
+                + "out.add(z.isBefore(z.plusSeconds(1)) + \" \" + z.isAfter(z.plusSeconds(1)) + \" \" + z.isEqual(z.withZoneSameInstant(utc)) + \" \" + ChronoUnit.DAYS.between(z, z.plusHours(49)));\n"
+                + "out.add(t.atZone(utc).toInstant());\n"
+                + "out.add(i.isBefore(i.plusNanos(1)) + \" \" + i.isAfter(i.minusNanos(1)) + \" \" + i.plus(Duration.ofMillis(1500)) + \" \" + i.minus(Duration.ofDays(1)) + \" \" + i.plus(3, ChronoUnit.HOURS) + \" \" + i.minus(250, ChronoUnit.MILLIS));\n"
+                + "out.add(ChronoUnit.SECONDS.between(i, i.plusMillis(2500)) + \" \" + i.until(i.minusSeconds(90), ChronoUnit.MINUTES) + \" \" + Duration.between(i, i.plusMillis(2500)) + \" \" + Duration.between(t, later));\n"
+                + "Duration du = Duration.ofSeconds(90061, 123456789);\n"
+                + "out.add(du.toDays() + \" \" + du.toHours() + \" \" + du.toMinutes() + \" \" + du.toSeconds() + \" \" + du.toNanos() + \" \" + du.toDaysPart() + \" \" + du.toHoursPart() + \" \" + du.toMinutesPart() + \" \" + du.toSecondsPart() + \" \" + du.toMillisPart() + \" \" + du.toNanosPart());\n"
+                + "out.add(du.isZero() + \" \" + du.isNegative() + \" \" + Duration.ZERO.isZero() + \" \" + du.negated() + \" \" + du.negated().abs() + \" \" + du.negated().isNegative());\n"
+                + "out.add(du.plusDays(1) + \" \" + du.plusHours(1) + \" \" + du.plusMinutes(1) + \" \" + du.plusSeconds(1) + \" \" + du.plusMillis(1) + \" \" + du.plusNanos(1));\n"
+                + "out.add(du.minusDays(1) + \" \" + du.minusHours(1) + \" \" + du.minusMinutes(1) + \" \" + du.minusSeconds(1) + \" \" + du.minusMillis(1) + \" \" + du.minusNanos(1));\n"
+                + "out.add(du.multipliedBy(3) + \" \" + du.dividedBy(7) + \" \" + Duration.ofNanos(-1) + \" \" + Duration.of(90, ChronoUnit.MINUTES) + \" \" + Duration.of(5, ChronoUnit.MICROS));\n"
+                + "Date date = new Date(1700000000123L);\n"
+                + "out.add(date.toInstant() + \" \" + Date.from(i).getTime() + \" \" + date.after(new Date(0)) + \" \" + date.before(new Date(0)));\n"
+                + "out.add((date.getYear() + 1900) + \" \" + date.getMonth() + \" \" + (date.getDate() > 0) + \" \" + (date.getDay() >= 0) + \" \" + (date.getHours() < 24) + \" \" + date.getMinutes() + \" \" + date.getSeconds());\n", 50);
+        d.keeps("java/time/DayOfWeek", "java/time/Month", "java/time/temporal/ChronoUnit");
+    }
+
+    @Test
+    public void codingDigestsAndStreamMembersAreTheJdks() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 17);
+        org.junit.Assume.assumeTrue("needs a JDK 17", d.available());
+        d.same(""
+                + "byte[] data = \"Hello, \\u0142\\u00f3d\\u017a! ~?>\".getBytes(StandardCharsets.UTF_8);\n"
+                + "String b64 = Base64.getEncoder().encodeToString(data);\n"
+                + "out.add(b64 + \" \" + Base64.getUrlEncoder().withoutPadding().encodeToString(data) + \" \" + Base64.getMimeEncoder().encodeToString(new byte[100]).length());\n"
+                + "out.add(new String(Base64.getDecoder().decode(b64), StandardCharsets.UTF_8) + \" \" + Base64.getUrlDecoder().decode(\"_-8\").length + \" \" + Base64.getMimeDecoder().decode(\"QU\\r\\nJD\").length);\n"
+                + "Base64.Encoder encoder = Base64.getEncoder();\n"
+                + "Base64.Decoder decoder = Base64.getDecoder();\n"
+                + "out.add(Arrays.toString(decoder.decode(encoder.encode(new byte[] {1, 2, 3, 4}))));\n"
+                + "try {\n"
+                + "    decoder.decode(\"a*b\");\n"
+                + "    out.add(\"decoded\");\n"
+                + "} catch (IllegalArgumentException e) {\n"
+                + "    out.add(\"illegal base64\");\n"
+                + "}\n"
+                + "out.add(URLEncoder.encode(\"a b&c=\\u00e9/\\ud83d\\ude00\", StandardCharsets.UTF_8) + \" \" + URLEncoder.encode(\"x y\", \"UTF-8\"));\n"
+                + "out.add(URLDecoder.decode(\"a+b%26c%3D%C3%A9%2F%F0%9F%98%80\", StandardCharsets.UTF_8) + \" \" + URLDecoder.decode(\"x+y%21\", \"UTF-8\"));\n"
+                + "try {\n"
+                + "    URLDecoder.decode(\"%zz\", StandardCharsets.UTF_8);\n"
+                + "    out.add(\"decoded\");\n"
+                + "} catch (IllegalArgumentException e) {\n"
+                + "    out.add(\"illegal escape\");\n"
+                + "}\n"
+                + "HexFormat hex = HexFormat.of();\n"
+                + "out.add(hex.formatHex(data) + \" \" + hex.withUpperCase().formatHex(data, 0, 3) + \" \" + HexFormat.ofDelimiter(\":\").formatHex(new byte[] {0, 127, -128, -1}));\n"
+                + "out.add(Arrays.toString(hex.parseHex(\"00ff7f80\")) + \" \" + Arrays.toString(HexFormat.ofDelimiter(\", \").withPrefix(\"#\").parseHex(\"#0a, #FF\")));\n"
+                + "out.add(hex.toHexDigits((byte) 10) + \" \" + hex.toHexDigits('a') + \" \" + hex.toHexDigits((short) -2) + \" \" + hex.toHexDigits(255) + \" \" + hex.toHexDigits(-1L) + \" \" + hex.toHexDigits(0xabcdefL, 5));\n"
+                + "out.add(HexFormat.isHexDigit('g') + \" \" + HexFormat.fromHexDigit('F') + \" \" + HexFormat.fromHexDigits(\"7fffffff\") + \" \" + HexFormat.fromHexDigitsToLong(\"ffffffffffffffff\") + \" \" + hex.toLowHexDigit(0x1f) + hex.toHighHexDigit(0x1f));\n"
+                + "out.add(hex.withDelimiter(\"-\").withSuffix(\"h\") + \" \" + hex.equals(HexFormat.of()) + \" \" + hex.isUpperCase() + hex.delimiter() + hex.prefix() + hex.suffix());\n"
+                + "for (String bad : new String[] {\"0\", \"0g\", \"00:11\", \"zz\"}) {\n"
+                + "    try {\n"
+                + "        out.add(Arrays.toString(hex.parseHex(bad)));\n"
+                + "    } catch (IllegalArgumentException e) {\n"
+                + "        out.add(\"bad hex \" + bad);\n"
+                + "    }\n"
+                + "}\n"
+                + "for (String name : new String[] {\"MD5\", \"SHA-1\", \"SHA-256\", \"SHA-512\", \"WHIRLPOOL\"}) {\n"
+                + "    try {\n"
+                + "        MessageDigest md = MessageDigest.getInstance(name);\n"
+                + "        md.update(data, 0, 5);\n"
+                + "        md.update(data, 5, data.length - 5);\n"
+                + "        out.add(md.getAlgorithm() + \" \" + md.getDigestLength() + \" \" + hex.formatHex(md.digest()) + \" \" + hex.formatHex(md.digest(new byte[0])));\n"
+                + "    } catch (NoSuchAlgorithmException e) {\n"
+                + "        out.add(\"no \" + name);\n"
+                + "    } catch (GeneralSecurityException e) {\n"
+                + "        out.add(\"other\");\n"
+                + "    }\n"
+                + "}\n"
+                + "out.add(MessageDigest.isEqual(new byte[] {1, 2}, new byte[] {1, 2}) + \" \" + MessageDigest.isEqual(new byte[] {1, 2}, new byte[] {1, 3}));\n"
+                // Constructed and typed only: the bytes come from the port, and the
+                // headless implementation these tests run on has no source of them.
+                + "SecureRandom random = new SecureRandom();\n"
+                + "out.add((random instanceof Random) + \" \" + (random.getAlgorithm() != null));\n"
+                + "InputStream in = new ByteArrayInputStream(data);\n"
+                + "out.add(in.readNBytes(5).length + \" \" + in.readNBytes(new byte[8], 2, 3) + \" \" + in.readAllBytes().length + \" \" + in.readAllBytes().length);\n"
+                + "ByteArrayOutputStream copy = new ByteArrayOutputStream();\n"
+                + "ByteArrayInputStream source = new ByteArrayInputStream(data);\n"
+                + "out.add(source.transferTo(copy) + \" \" + copy.toString(StandardCharsets.UTF_8));\n"
+                + "StringWriter written = new StringWriter();\n"
+                + "out.add(new StringReader(\"copied text\").transferTo(written) + \" \" + written);\n"
+                + "BufferedReader reader = new BufferedReader(new StringReader(\"one\\ntwo\\r\\n\\nfour\"));\n"
+                + "out.add(reader.lines().map(String::toUpperCase).collect(Collectors.toList()));\n"
+                + "StringBuilder sb = new StringBuilder();\n"
+                + "out.add(sb.isEmpty() + \" \" + sb.appendCodePoint(0x1F600).appendCodePoint('x').length() + \" \" + sb.isEmpty() + \" \" + new StringBuffer().appendCodePoint(65) + \" \" + new StringBuffer().isEmpty());\n"
+                + "out.add(Arrays.toString(\"a\\ud83d\\ude00b\".codePoints().toArray()) + \" \" + sb.codePoints().count() + \" \" + Character.toString(0x1F600).length() + \" \" + Character.toString(66));\n"
+                + "CharSequence seq = \"\";\n"
+                + "out.add(seq.isEmpty() + \" \" + \"x\".isEmpty());\n", 30);
+        d.keeps("java/util/Base64", "java/util/HexFormat", "java/security/", "java/net/URL");
+    }
+
+    @Test
+    public void aListHasAFirstAndALastElement() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 21);
+        org.junit.Assume.assumeTrue("needs a JDK 21", d.available());
+        d.same(""
+                + "List<String> list = new ArrayList<>(List.of(\"a\", \"b\", \"c\"));\n"
+                + "out.add(list.getFirst() + list.getLast());\n"
+                + "List<String> back = list.reversed();\n"
+                + "out.add(back);\n"
+                + "back.add(\"z\");\n"
+                + "out.add(list + \" \" + back);\n"
+                + "out.add(list.removeFirst() + list.removeLast());\n"
+                + "list.addFirst(\"0\");\n"
+                + "list.addLast(\"9\");\n"
+                + "out.add(list + \" \" + back + \" \" + back.getFirst());\n"
+                + "ArrayList<Integer> numbers = new ArrayList<>(List.of(1, 2, 3));\n"
+                + "out.add(numbers.getFirst() + numbers.getLast() + numbers.reversed().get(0));\n"
+                + "try {\n"
+                + "    new ArrayList<String>().getFirst();\n"
+                + "    out.add(\"no failure\");\n"
+                + "} catch (NoSuchElementException e) {\n"
+                + "    out.add(\"empty\");\n"
+                + "}\n"
+                + "LinkedList<String> linked = new LinkedList<>(list);\n"
+                + "out.add(linked.getFirst() + linked.getLast());\n", 8);
+    }
+
+    @Test
+    public void aRecordsEqualsHashCodeAndToStringAreTheJdks() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 17);
+        org.junit.Assume.assumeTrue("needs a JDK 17", d.available());
+        d.source("Point", ""
+                + "public record Point(int x, int y) { }\n");
+        d.source("All", ""
+                + "public record All(boolean flag, byte b, char c, short s, int i, long l, float f, double d, String text, int[] array, Point point, List<Integer> list) { }\n");
+        d.source("Empty", ""
+                + "public record Empty() { }\n");
+        d.source("Outer", ""
+                + "public class Outer {\n"
+                + "    public record Inner(String name, long value) { }\n"
+                + "}\n");
+        d.source("Pair", ""
+                + "public record Pair<A, B>(A first, B second) {\n"
+                + "    public Pair<B, A> swapped() { return new Pair<>(second, first); }\n"
+                + "}\n");
+        d.source("Custom", ""
+                + "public record Custom(String name) {\n"
+                + "    public Custom {\n"
+                + "        if (name == null) { throw new IllegalArgumentException(\"name\"); }\n"
+                + "    }\n"
+                + "    @Override public String toString() { return \"custom \" + name; }\n"
+                + "    @Override public boolean equals(Object o) { return o instanceof Custom; }\n"
+                + "    @Override public int hashCode() { return 7; }\n"
+                + "}\n");
+        d.same(""
+                + "Point p = new Point(3, -4);\n"
+                + "out.add(p + \" \" + p.hashCode() + \" \" + p.equals(new Point(3, -4)) + \" \" + p.equals(new Point(3, 4)) + \" \" + p.equals(null) + \" \" + p.equals(\"x\") + \" \" + p.x() + p.y());\n"
+                + "All a = new All(true, (byte) -7, 'q', (short) 300, 123456789, 9876543210123L, 1.5f, -2.25, \"text\", new int[] {1}, p, null);\n"
+                + "All b = new All(true, (byte) -7, 'q', (short) 300, 123456789, 9876543210123L, 1.5f, -2.25, \"text\", a.array(), new Point(3, -4), null);\n"
+                + "out.add(a.equals(b) + \" \" + (a.hashCode() == b.hashCode()) + \" \" + a.equals(a));\n"
+                + "String shown = a.toString();\n"
+                + "out.add(shown.substring(0, shown.indexOf(\"array=\")) + shown.substring(shown.indexOf(\", point=\")));\n"
+                + "All none = new All(false, (byte) 0, 'a', (short) 0, 0, 0L, 0f, 0.0, null, null, null, null);\n"
+                + "out.add(none.hashCode() + \" \" + new All(true, (byte) 0, 'a', (short) 0, 0, 0L, 0f, 0.0, null, null, null, null).hashCode());\n"
+                + "out.add(new All(false, (byte) 1, 'b', (short) 2, 3, 4L, 0f, 0.0, \"s\", null, p, List.of(1, 2)).hashCode());\n"
+                + "Object[] variants = {\n"
+                + "    new All(false, (byte) 1, 'a', (short) 0, 0, 0L, 0f, 0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'b', (short) 0, 0, 0L, 0f, 0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 1, 0, 0L, 0f, 0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 1, 0L, 0f, 0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 1L << 40, 0f, 0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 0L, -0f, 0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 0L, 0f, -0.0, null, null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 0L, 0f, 0.0, \"\", null, null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 0L, 0f, 0.0, null, new int[0], null, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 0L, 0f, 0.0, null, null, p, null),\n"
+                + "    new All(false, (byte) 0, 'a', (short) 0, 0, 0L, 0f, 0.0, null, null, null, List.of()),\n"
+                + "};\n"
+                + "StringBuilder differs = new StringBuilder();\n"
+                + "for (Object v : variants) {\n"
+                + "    differs.append(none.equals(v) ? 'e' : 'd').append(v.equals(none) ? 'e' : 'd').append(v.equals(v) ? 'e' : 'd');\n"
+                + "}\n"
+                + "out.add(differs);\n"
+                + "for (int i = 0; i < 8; i++) {\n"
+                + "    out.add(variants[i].hashCode() + \" \" + variants[i]);\n"
+                + "}\n"
+                + "All nan = new All(false, (byte) 0, 'a', (short) 0, 0, 0L, Float.NaN, Double.NaN, null, null, null, null);\n"
+                + "All nan2 = new All(false, (byte) 0, 'a', (short) 0, 0, 0L, Float.NaN, Double.NaN, null, null, null, null);\n"
+                + "out.add(nan.equals(nan2) + \" \" + nan.hashCode() + \" \" + (nan.hashCode() == nan2.hashCode()));\n"
+                + "out.add(new Empty() + \" \" + new Empty().hashCode() + \" \" + new Empty().equals(new Empty()) + \" \" + new Empty().equals(p));\n"
+                + "out.add(new Outer.Inner(\"in\", 2L) + \" \" + new Outer.Inner(\"in\", 2L).equals(new Outer.Inner(\"in\", 2L)) + \" \" + new Outer.Inner(\"in\", 2L).hashCode());\n"
+                + "record Local(String name, List<Point> points) { }\n"
+                + "Local local = new Local(\"l\", List.of(p, new Point(0, 0)));\n"
+                + "out.add(local + \" \" + local.equals(new Local(\"l\", List.of(new Point(3, -4), new Point(0, 0)))) + \" \" + local.hashCode());\n"
+                + "Pair<String, Integer> pair = new Pair<>(\"k\", 5);\n"
+                + "out.add(pair + \" \" + pair.swapped() + \" \" + pair.equals(pair.swapped().swapped()) + \" \" + pair.hashCode());\n"
+                + "Map<Point, String> byPoint = new HashMap<>();\n"
+                + "byPoint.put(new Point(1, 2), \"one-two\");\n"
+                + "out.add(byPoint.get(new Point(1, 2)) + \" \" + byPoint.get(new Point(2, 1)) + \" \" + new HashSet<>(List.of(new Point(1, 1), new Point(1, 1 + 0), new Point(2, 2))).size());\n"
+                + "out.add(new Custom(\"x\").toString() + \" \" + new Custom(\"x\").equals(new Custom(\"y\")) + \" \" + new Custom(\"x\").hashCode());\n"
+                + "out.add((Object) p instanceof Record);\n", 20, "java/lang/runtime/ObjectMethods");
+    }
+
+    @Test
+    public void aSwitchOverPatternsChoosesTheJdksCase() throws Exception {
+        RemapDifferential d = new RemapDifferential(tmp.newFolder(), 21);
+        org.junit.Assume.assumeTrue("needs a JDK 21", d.available());
+        d.source("Shape", ""
+                + "public sealed interface Shape permits Circle, Square, Named { }\n");
+        d.source("Circle", ""
+                + "public record Circle(int radius) implements Shape { }\n");
+        d.source("Square", ""
+                + "public record Square(int side) implements Shape { }\n");
+        d.source("Named", ""
+                + "public record Named(String name, Shape shape) implements Shape { }\n");
+        d.source("Level", ""
+                + "public sealed interface Level permits Tone, Fixed { }\n");
+        d.source("Fixed", ""
+                + "public record Fixed(int value) implements Level { }\n");
+        d.source("Tone", ""
+                + "public enum Tone implements Level { LOW, MID, HIGH }\n");
+        d.source("Shapes", ""
+                + "public class Shapes {\n"
+                + "    public static String describe(Object o) {\n"
+                + "        return switch (o) {\n"
+                + "            case null -> \"null\";\n"
+                + "            case String s when s.isEmpty() -> \"empty string\";\n"
+                + "            case String s -> \"string \" + s;\n"
+                + "            case Integer i when i > 6 -> \"big \" + i;\n"
+                + "            case Integer i -> \"int \" + i;\n"
+                + "            case Character c -> \"char \" + c;\n"
+                + "            case Long l -> \"long \" + l;\n"
+                + "            case int[] array -> \"ints \" + array.length;\n"
+                + "            case Circle c -> \"circle \" + c.radius();\n"
+                + "            case Named(String name, Circle(int radius)) -> \"named circle \" + name + radius;\n"
+                + "            case Shape s -> \"shape \" + s;\n"
+                + "            case Tone t when t == Tone.HIGH -> \"high\";\n"
+                + "            case Tone t -> \"tone \" + t;\n"
+                + "            case List<?> list -> \"list \" + list.size();\n"
+                + "            case CharSequence cs -> \"chars \" + cs.length();\n"
+                + "            default -> \"other \" + o;\n"
+                + "        };\n"
+                + "    }\n"
+                + "    public static int area(Shape s) {\n"
+                + "        return switch (s) {\n"
+                + "            case Circle c -> 3 * c.radius() * c.radius();\n"
+                + "            case Square q -> q.side() * q.side();\n"
+                + "            case Named n -> area(n.shape());\n"
+                + "        };\n"
+                + "    }\n"
+                + "    public static String guarded(Shape s) {\n"
+                + "        if (s instanceof Named(String name, Named(String inner, Shape shape))) {\n"
+                + "            return name + \"/\" + inner + \"/\" + shape;\n"
+                + "        }\n"
+                + "        if (s instanceof Named(var name, var shape) && shape instanceof Square(int side)) {\n"
+                + "            return name + \" square \" + side;\n"
+                + "        }\n"
+                + "        return \"plain\";\n"
+                + "    }\n"
+                + "    public static String tone(Tone t) {\n"
+                + "        return switch (t) {\n"
+                + "            case LOW -> \"low\";\n"
+                + "            case Tone x when x.ordinal() == 1 -> \"middle\";\n"
+                + "            case HIGH -> \"high\";\n"
+                + "            case Tone x -> \"rest \" + x;\n"
+                + "        };\n"
+                + "    }\n"
+                + "    public static int level(Tone t) {\n"
+                + "        switch (t) {\n"
+                + "            case LOW: return 1;\n"
+                + "            case MID: return 2;\n"
+                + "            default: return 3;\n"
+                + "        }\n"
+                + "    }\n"
+                + "    public static String sealedLevel(Level l) {\n"
+                + "        return switch (l) {\n"
+                + "            case Tone.LOW -> \"LOW\";\n"
+                + "            case Tone.MID -> \"MID\";\n"
+                + "            case Tone t -> \"tone \" + t;\n"
+                + "            case Fixed f -> \"fixed \" + f.value();\n"
+                + "        };\n"
+                + "    }\n"
+                + "    public static String boxed(Integer i) {\n"
+                + "        return switch (i) {\n"
+                + "            case 0 -> \"zero\";\n"
+                + "            case 1 -> \"one\";\n"
+                + "            case Integer n when n > 50 -> \"large\";\n"
+                + "            case Integer n -> \"n\" + n;\n"
+                + "        };\n"
+                + "    }\n"
+                + "    public static String text(String s) {\n"
+                + "        return switch (s) {\n"
+                + "            case \"a\" -> \"A\";\n"
+                + "            case String t when t.length() == 2 -> \"two\";\n"
+                + "            case \"ccc\" -> \"C\";\n"
+                + "            case String t -> \"any \" + t;\n"
+                + "        };\n"
+                + "    }\n"
+                + "    public static String nullable(String s) {\n"
+                + "        return switch (s) {\n"
+                + "            case null -> \"nothing\";\n"
+                + "            case String t -> \"something\";\n"
+                + "        };\n"
+                + "    }\n"
+                + "}\n");
+        d.same(""
+                + "Object[] values = {null, \"text\", \"\", 5, 7, -1, 'c', 3L, 2.5, new int[] {1, 2}, new Circle(2), new Square(3), new Named(\"n\", new Circle(1)), Tone.LOW, Tone.HIGH, List.of(1), new StringBuilder(\"sb\")};\n"
+                + "for (Object v : values) {\n"
+                + "    out.add(Shapes.describe(v));\n"
+                + "}\n"
+                + "for (Shape s : new Shape[] {new Circle(1), new Square(2), new Named(\"a\", new Square(1)), new Named(\"b\", new Named(\"c\", new Circle(5)))}) {\n"
+                + "    out.add(Shapes.area(s) + \" \" + Shapes.guarded(s));\n"
+                + "}\n"
+                + "for (Tone t : Tone.values()) {\n"
+                + "    out.add(Shapes.tone(t) + \" \" + Shapes.level(t));\n"
+                + "}\n"
+                + "for (Level l : new Level[] {Tone.LOW, Tone.MID, Tone.HIGH, new Fixed(4)}) {\n"
+                + "    out.add(Shapes.sealedLevel(l));\n"
+                + "}\n"
+                + "for (Integer i : new Integer[] {0, 1, 2, 100, -5}) {\n"
+                + "    out.add(Shapes.boxed(i));\n"
+                + "}\n"
+                + "for (String s : new String[] {\"a\", \"bb\", \"ccc\", \"none\"}) {\n"
+                + "    out.add(Shapes.text(s));\n"
+                + "}\n"
+                + "try {\n"
+                + "    Shapes.tone(null);\n"
+                + "    out.add(\"no failure\");\n"
+                + "} catch (NullPointerException e) {\n"
+                + "    out.add(\"null selector\");\n"
+                + "}\n"
+                + "out.add(Shapes.nullable(null) + \" \" + Shapes.nullable(\"s\"));\n", 35, "java/lang/runtime/SwitchBootstraps", "java/lang/runtime/ObjectMethods");
+        d.keeps("java/lang/MatchException");
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/PropertyAccessRemapTest.java b/maven/build-engine/src/test/java/com/codename1/maven/PropertyAccessRemapTest.java
new file mode 100644
index 00000000000..dcff766c73d
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/PropertyAccessRemapTest.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+/// The remap generates what `PropertyValueFactory` needs in place of
+/// reflection: the accessors of the application's bean classes, called by
+/// name through the relocated `PropertyRegistry`.
+public class PropertyAccessRemapTest {
+
+    private static final String APP = "package com.acme.fx;\n"
+            + "import javafx.scene.control.TableColumn;\n"
+            + "import javafx.scene.control.cell.PropertyValueFactory;\n"
+            + "public class Shop extends javafx.application.Application {\n"
+            + "    public void start(javafx.stage.Stage stage) {\n"
+            + "        TableColumn<Plain, String> c = new TableColumn<Plain, String>(\"Label\");\n"
+            + "        c.setCellValueFactory(new PropertyValueFactory<Plain, String>(\"label\"));\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String PERSON = "package com.acme.fx;\n"
+            + "import javafx.beans.property.SimpleStringProperty;\n"
+            + "import javafx.beans.property.StringProperty;\n"
+            + "public class Person {\n"
+            + "    private final StringProperty name = new SimpleStringProperty(this, \"name\", \"Ann\");\n"
+            + "    public StringProperty nameProperty() { return name; }\n"
+            + "    public String getName() { return name.get(); }\n"
+            + "    public int getAge() { return 41; }\n"
+            + "    public boolean isActive() { return true; }\n"
+            + "    public String getWith(int argument) { return \"no\"; }\n"
+            + "    String getHidden() { return \"no\"; }\n"
+            + "    public static String getShared() { return \"no\"; }\n"
+            + "}\n";
+
+    private static final String EMPLOYEE = "package com.acme.fx;\n"
+            + "public class Employee extends Person {\n"
+            + "    public String getName() { return \"Employee \" + super.getName(); }\n"
+            + "    public double getSalary() { return 2.5; }\n"
+            + "}\n";
+
+    /// Getters only: reached because the application names `label` as a
+    /// constant where it creates the factory.
+    private static final String PLAIN = "package com.acme.fx;\n"
+            + "public class Plain {\n"
+            + "    public String getLabel() { return \"plain\"; }\n"
+            + "}\n";
+
+    /// Getters only and no name the application asks for.
+    private static final String OTHER = "package com.acme.fx;\n"
+            + "public class Other {\n"
+            + "    public String getTitle() { return \"other\"; }\n"
+            + "}\n";
+
+    /// A property method, but the class is not public.
+    private static final String HIDDEN = "package com.acme.fx;\n"
+            + "class Hidden {\n"
+            + "    public javafx.beans.property.StringProperty nameProperty() { return null; }\n"
+            + "}\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    private List<File> classpath() throws Exception {
+        if (scratch == null) {
+            scratch = tmp.newFolder("jars");
+        }
+        return Arrays.asList(RealCompatJars.javafx(scratch), RealCompatJars.core(scratch));
+    }
+
+    private File build() throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(classpath(), tmp.newFolder(), classes, "com/acme/fx/Shop.java", APP,
+                "com/acme/fx/Person.java", PERSON, "com/acme/fx/Employee.java", EMPLOYEE, "com/acme/fx/Plain.java",
+                PLAIN, "com/acme/fx/Other.java", OTHER, "com/acme/fx/Hidden.java", HIDDEN);
+        return classes;
+    }
+
+    private CompatRemapper remapper(File classes) throws Exception {
+        File desktop = tmp.newFolder();
+        return new CompatRemapper(classes, classpath(), null, CompatRemapperTest.LOG)
+                .withDesktopSourceDirectory(desktop);
+    }
+
+    @Test
+    public void theGeneratedRegistryCallsTheAccessorsOfTheBeans() throws Exception {
+        File classes = build();
+        assertTrue(remapper(classes).run());
+        URLClassLoader loader = new URLClassLoader(new URL[] {classes.toURI().toURL()},
+                PropertyAccessRemapTest.class.getClassLoader());
+        try {
+            Class<?> accessType = loader.loadClass("com.codename1.fxcompat.rt.PropertyAccess");
+            Object access = loader.loadClass("com.codename1.fxcompat.rt.PropertyRegistry").newInstance();
+            assertTrue(accessType.isInstance(access));
+            Object none = accessType.getField("NONE").get(null);
+            Method call = accessType.getMethod("call", Object.class, String.class);
+            Method knows = accessType.getMethod("knows", Object.class);
+
+            Object person = loader.loadClass("com.acme.fx.Person").newInstance();
+            Object property = call.invoke(access, person, "nameProperty");
+            assertNotNull(property);
+            assertEquals("com.codename1.fxcompat.javafx.beans.property.SimpleStringProperty",
+                    property.getClass().getName());
+            assertEquals("Ann", call.invoke(access, person, "getName"));
+            assertEquals("a primitive comes back in its wrapper", Integer.valueOf(41),
+                    call.invoke(access, person, "getAge"));
+            assertEquals(Boolean.TRUE, call.invoke(access, person, "isActive"));
+            assertSame("a method with an argument is no accessor", none, call.invoke(access, person, "getWith"));
+            assertSame(none, call.invoke(access, person, "getHidden"));
+            assertSame(none, call.invoke(access, person, "getShared"));
+            assertSame(none, call.invoke(access, person, "getNothing"));
+            assertEquals(Boolean.TRUE, knows.invoke(access, person));
+
+            // The subclass is asked first, and has what it inherits.
+            Object employee = loader.loadClass("com.acme.fx.Employee").newInstance();
+            assertEquals("Employee Ann", call.invoke(access, employee, "getName"));
+            assertEquals(Double.valueOf(2.5), call.invoke(access, employee, "getSalary"));
+            assertSame(property.getClass(), call.invoke(access, employee, "nameProperty").getClass());
+            assertSame(none, call.invoke(access, person, "getSalary"));
+
+            Object plain = loader.loadClass("com.acme.fx.Plain").newInstance();
+            assertEquals("a bean of getters is reached by the constant name", "plain",
+                    call.invoke(access, plain, "getLabel"));
+            Object other = loader.loadClass("com.acme.fx.Other").newInstance();
+            assertSame(none, call.invoke(access, other, "getTitle"));
+            assertEquals(Boolean.FALSE, knows.invoke(access, other));
+            assertEquals(Boolean.FALSE, knows.invoke(access, "a string"));
+
+            // The factory itself, relocated, over the generated registry.
+            Class<?> factoryType = loader.loadClass(
+                    "com.codename1.fxcompat.javafx.scene.control.cell.PropertyValueFactory");
+            Method valueOf = factoryType.getDeclaredMethod("cn1ValueOf", Object.class, String.class);
+            valueOf.setAccessible(true);
+            assertSame(property, valueOf.invoke(null, person, "name"));
+            Object age = valueOf.invoke(null, person, "age");
+            assertEquals(Integer.valueOf(41), age.getClass().getMethod("getValue").invoke(age));
+            try {
+                valueOf.invoke(null, person, "nmae");
+                org.junit.Assert.fail("Person has no such property");
+            } catch (java.lang.reflect.InvocationTargetException e) {
+                String message = String.valueOf(e.getCause().getMessage());
+                assertTrue(message, e.getCause() instanceof IllegalStateException);
+                assertTrue(message, message.contains("com.acme.fx.Person") && message.contains("nmae"));
+            }
+            try {
+                valueOf.invoke(null, other, "title");
+                org.junit.Assert.fail("Nothing was generated for Other");
+            } catch (java.lang.reflect.InvocationTargetException e) {
+                String message = String.valueOf(e.getCause().getMessage());
+                assertTrue(message, message.contains("com.acme.fx.Other") && message.contains("title"));
+            }
+        } finally {
+            loader.close();
+        }
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+    }
+
+    @Test
+    public void aClassThatIsNotPublicGetsNoAccessorsAndASecondRunChangesNothing() throws Exception {
+        File classes = build();
+        assertTrue(remapper(classes).run());
+        File dir = new File(classes, "com/codename1/fxcompat/rt");
+        File registry = new File(dir, "PropertyRegistry.class");
+        assertTrue(registry.isFile());
+        // Employee, Person and Plain; not Other, not Hidden.
+        assertTrue(new File(dir, "PropertyRegistry$P2.class").isFile());
+        assertFalse(new File(dir, "PropertyRegistry$P3.class").exists());
+        String text = new String(Files.readAllBytes(registry.toPath()), "ISO-8859-1");
+        assertFalse(text.contains("com/acme/fx/Hidden"));
+        assertFalse(text.contains("com/acme/fx/Other"));
+
+        byte[] first = Files.readAllBytes(registry.toPath());
+        long stamp = registry.lastModified();
+        assertTrue(remapper(classes).run());
+        assertTrue(Arrays.equals(first, Files.readAllBytes(registry.toPath())));
+        assertEquals(stamp, registry.lastModified());
+        assertFalse(new File(dir, "PropertyRegistry$P3.class").exists());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/RealCompatJars.java b/maven/build-engine/src/test/java/com/codename1/maven/RealCompatJars.java
new file mode 100644
index 00000000000..658b88f9950
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/RealCompatJars.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarOutputStream;
+
+/// The jars a desktop application is really built against -- the layers'
+/// runtimes, the framework and the device's class library -- as this module's test classpath holds them.
+///
+/// A test that compiles a fixture against these and remaps it sees what a
+/// project's build sees, where the other tests use a runtime of three
+/// classes written with ASM.
+final class RealCompatJars {
+
+    private RealCompatJars() {
+    }
+
+    private static List<File> testClasspath() {
+        List<File> out = new ArrayList<File>();
+        // Surefire starts the tests from a jar whose manifest holds the
+        // classpath, and says what that classpath is in a property.
+        for (String property : new String[] {"surefire.test.class.path", "java.class.path"}) {
+            String value = System.getProperty(property);
+            if (value != null) {
+                for (String entry : value.split(File.pathSeparator)) {
+                    if (entry.length() > 0) {
+                        out.add(new File(entry));
+                    }
+                }
+            }
+        }
+        return out;
+    }
+
+    /// The jar of `artifactId`. A reactor build that stops before `package`
+    /// has the module's classes directory on the classpath instead; that is
+    /// packed into `scratch` under the name a build would give it, since the
+    /// remap step knows a runtime by its jar's name.
+    static File jar(String artifactId, File scratch) throws IOException {
+        for (File f : testClasspath()) {
+            if (f.isFile() && f.getName().startsWith(artifactId + "-") && f.getName().endsWith(".jar")
+                    && Character.isDigit(f.getName().charAt(artifactId.length() + 1))) {
+                return f;
+            }
+        }
+        for (File f : testClasspath()) {
+            // .../maven/<module>/target/classes
+            File module = f.getParentFile() == null ? null : f.getParentFile().getParentFile();
+            String moduleName = artifactId.startsWith("codenameone-")
+                    ? artifactId.substring("codenameone-".length()) : artifactId;
+            if (f.isDirectory() && "classes".equals(f.getName()) && module != null
+                    && module.getName().equals(moduleName)) {
+                File out = new File(scratch, artifactId + "-0.jar");
+                if (!out.isFile()) {
+                    JarOutputStream jar = new JarOutputStream(new FileOutputStream(out));
+                    try {
+                        pack(f, "", jar);
+                    } finally {
+                        jar.close();
+                    }
+                }
+                return out;
+            }
+        }
+        throw new AssertionError(artifactId + " is not on the test classpath: " + testClasspath());
+    }
+
+    private static void pack(File dir, String rel, JarOutputStream jar) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                pack(f, rel + f.getName() + "/", jar);
+            } else {
+                jar.putNextEntry(new JarEntry(rel + f.getName()));
+                jar.write(Files.readAllBytes(f.toPath()));
+                jar.closeEntry();
+            }
+        }
+    }
+
+    static File swing(File scratch) throws IOException {
+        return jar(CompatLayers.SWING.artifactId(), scratch);
+    }
+
+    static File javafx(File scratch) throws IOException {
+        return jar(CompatLayers.JAVAFX.artifactId(), scratch);
+    }
+
+    static File core(File scratch) throws IOException {
+        return jar("codenameone-core", scratch);
+    }
+
+    /// `com.codename1.impl.JdkHost` alone, out of the device's class library:
+    /// what the JavaSE and Android ports carry a copy of, and the generated
+    /// registry implements an interface of. A loader that runs an application
+    /// on this JVM with the framework but no port puts it beside the core,
+    /// where the rest of the class library is the JDK's own.
+    static File jdkHost(File scratch) throws IOException {
+        File out = new File(scratch, "jdk-host-0.jar");
+        if (out.isFile()) {
+            return out;
+        }
+        java.util.zip.ZipFile runtime = new java.util.zip.ZipFile(jar("java-runtime", scratch));
+        try {
+            JarOutputStream host = new JarOutputStream(new FileOutputStream(out));
+            try {
+                java.util.Enumeration<? extends java.util.zip.ZipEntry> entries = runtime.entries();
+                while (entries.hasMoreElements()) {
+                    java.util.zip.ZipEntry e = entries.nextElement();
+                    String name = e.getName();
+                    if (name.startsWith("com/codename1/impl/JdkHost") && name.endsWith(".class")) {
+                        host.putNextEntry(new JarEntry(name));
+                        java.io.InputStream in = runtime.getInputStream(e);
+                        try {
+                            byte[] buf = new byte[8192];
+                            for (int n = in.read(buf); n > 0; n = in.read(buf)) {
+                                host.write(buf, 0, n);
+                            }
+                        } finally {
+                            in.close();
+                        }
+                        host.closeEntry();
+                    }
+                }
+            } finally {
+                host.close();
+            }
+        } finally {
+            runtime.close();
+        }
+        return out;
+    }
+
+    /// A project host whose dependencies are the real jars, scoped as the
+    /// project templates scope them, for running the compliance check over
+    /// `classes`.
+    static TestProjectHost host(File classes, File buildDir, File scratch) throws IOException {
+        TestProjectHost host = TestProjectHost.empty();
+        host.buildDir = buildDir;
+        host.outputDir = classes;
+        host.log = CompatRemapperTest.LOG;
+        add(host, "java-runtime", "provided", jar("java-runtime", scratch));
+        add(host, "codenameone-core", "provided", core(scratch));
+        add(host, CompatLayers.SWING.artifactId(), "provided", swing(scratch));
+        add(host, CompatLayers.JAVAFX.artifactId(), "provided", javafx(scratch));
+        return host;
+    }
+
+    private static void add(TestProjectHost host, String artifactId, String scope, File jar) {
+        host.artifacts.add(new BuildArtifact("com.codenameone", artifactId, "1", null, "jar", scope, jar, null));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/RemapDifferential.java b/maven/build-engine/src/test/java/com/codename1/maven/RemapDifferential.java
new file mode 100644
index 00000000000..6d9862705ec
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/RemapDifferential.java
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// Runs one piece of Java twice -- as javac compiled it against the JDK, and
+/// after the remap step pointed it at the stand-ins a device has -- and
+/// answers both sets of results for a test to compare.
+///
+/// Most of the JDK keeps its name through the remap, since the device's class
+/// library carries it; for those, [#keeps(String...)] says the remapped
+/// classes still name it and the two runs are the JDK's both times.
+///
+/// The piece is the body of a method that adds what it computed to a list
+/// named `out`. Source that needs a newer language level than the JVM running
+/// the tests is compiled and run by the JDK that `JAVA17_HOME` names; with
+/// neither, [#available] says so and the test is skipped.
+final class RemapDifferential {
+
+    private static final String IMPORTS = "import java.io.*;\n"
+            + "import java.nio.charset.*;\n"
+            + "import java.util.*;\n"
+            + "import java.util.concurrent.*;\n"
+            + "import java.util.concurrent.atomic.*;\n"
+            + "import java.util.function.*;\n"
+            + "import java.util.regex.*;\n"
+            + "import java.util.stream.*;\n"
+            + "import java.time.*;\n"
+            + "import java.time.format.*;\n"
+            + "import java.time.temporal.*;\n"
+            + "import java.net.URLDecoder;\n"
+            + "import java.net.URLEncoder;\n"
+            + "import java.security.*;\n";
+
+    private final File work;
+    private final int release;
+    private final List<String> sources = new ArrayList<String>();
+    private final List<String> resources = new ArrayList<String>();
+
+    /// `release` is the language level the source needs: 8, 17 or 21.
+    RemapDifferential(File work, int release) {
+        this.work = work;
+        this.release = release;
+    }
+
+    /// The class path of this test, with the headless implementation ahead
+    /// of everything: its `ImplementationFactory` has to be found before the
+    /// simulator's, which would open a window.
+    private static String testClassPath() {
+        String path = System.getProperty("surefire.test.class.path");
+        if (path == null || path.length() == 0) {
+            path = System.getProperty("java.class.path");
+        }
+        StringBuilder first = new StringBuilder();
+        StringBuilder rest = new StringBuilder();
+        for (String entry : path.split(File.pathSeparator)) {
+            StringBuilder to = entry.contains("compat-testing") ? first : rest;
+            to.append(entry).append(File.pathSeparator);
+        }
+        return first.append(rest).toString();
+    }
+
+    private static int running() {
+        String v = System.getProperty("java.specification.version");
+        return v.startsWith("1.") ? Integer.parseInt(v.substring(2)) : Integer.parseInt(v);
+    }
+
+    private File otherJdk() {
+        String[] names = release > 17 ? new String[] {"JAVA21_HOME", "JAVA25_HOME"}
+                : new String[] {"JAVA17_HOME", "JAVA21_HOME", "JAVA25_HOME"};
+        for (String name : names) {
+            String home = System.getenv(name);
+            if (home != null && new File(home, "bin/javac").isFile()) {
+                return new File(home);
+            }
+        }
+        return null;
+    }
+
+    /// Whether a JDK that can compile and run this language level is here.
+    boolean available() {
+        return running() >= release || otherJdk() != null;
+    }
+
+    /// A further source file of package `q`, beside the body.
+    RemapDifferential source(String name, String text) {
+        sources.add("q/" + name + ".java");
+        sources.add("package q;\n" + IMPORTS + text);
+        return this;
+    }
+
+    /// A file on the class path of both runs, beside the classes: a
+    /// `META-INF/services` file, say. Both runs are then forked, since a
+    /// loader that only defines the fixture's classes offers no resources.
+    RemapDifferential resource(String path, String text) {
+        resources.add(path);
+        resources.add(text);
+        return this;
+    }
+
+    /// The results of `body` on the JDK, then after the remap.
+    String[][] run(String body) throws Exception {
+        sources.add("q/D.java");
+        sources.add("package q;\n" + IMPORTS
+                + "public class D {\n"
+                + "    public static List<Object> run() throws Exception {\n"
+                + "        List<Object> out = new ArrayList<>();\n"
+                + body
+                + "        return out;\n"
+                + "    }\n"
+                + "    static String text(Object o) {\n"
+                + "        if (o instanceof Object[]) { return Arrays.deepToString((Object[]) o); }\n"
+                + "        if (o instanceof byte[]) { return Arrays.toString((byte[]) o); }\n"
+                + "        if (o instanceof int[]) { return Arrays.toString((int[]) o); }\n"
+                + "        if (o instanceof long[]) { return Arrays.toString((long[]) o); }\n"
+                + "        if (o instanceof char[]) { return Arrays.toString((char[]) o); }\n"
+                + "        return String.valueOf(o);\n"
+                + "    }\n"
+                + "    public static String[] texts() throws Exception {\n"
+                + "        List<Object> all = run();\n"
+                + "        String[] t = new String[all.size()];\n"
+                + "        for (int i = 0; i < t.length; i++) { t[i] = text(all.get(i)); }\n"
+                + "        return t;\n"
+                + "    }\n"
+                + "    public static void main(String[] args) throws Exception {\n"
+                + "        StringBuilder sb = new StringBuilder();\n"
+                + "        for (String s : texts()) {\n"
+                + "            for (int i = 0; i < s.length(); i++) {\n"
+                + "                char c = s.charAt(i);\n"
+                + "                if (c == '\\\\') { sb.append(\"\\\\\\\\\"); }\n"
+                + "                else if (c == '\\n') { sb.append(\"\\\\n\"); }\n"
+                + "                else if (c == '\\r') { sb.append(\"\\\\r\"); }\n"
+                + "                else if (c < ' ' || c > '~') { sb.append(\"\\\\x\").append((int) c).append(';'); }\n"
+                + "                else { sb.append(c); }\n"
+                + "            }\n"
+                + "            sb.append('\\n');\n"
+                + "        }\n"
+                + "        System.out.print(sb);\n"
+                + "    }\n"
+                + "}\n");
+        File src = new File(work, "src");
+        File original = new File(work, "original");
+        File remapped = new File(work, "remapped");
+        assertTrue(original.mkdirs() && remapped.mkdirs());
+        List<String> files = new ArrayList<String>();
+        for (int i = 0; i < sources.size(); i += 2) {
+            File f = new File(src, sources.get(i));
+            assertTrue(f.getParentFile().isDirectory() || f.getParentFile().mkdirs());
+            Files.write(f.toPath(), sources.get(i + 1).getBytes("UTF-8"));
+            files.add(f.getAbsolutePath());
+        }
+        boolean inProcess = running() >= release;
+        File jdk = inProcess ? null : otherJdk();
+        compile(jdk, original, files);
+        for (int i = 0; i < resources.size(); i += 2) {
+            for (File root : new File[] {original, remapped}) {
+                File f = new File(root, resources.get(i));
+                assertTrue(f.getParentFile().isDirectory() || f.getParentFile().mkdirs());
+                Files.write(f.toPath(), resources.get(i + 1).getBytes("UTF-8"));
+            }
+        }
+        if (jdk == null && !resources.isEmpty()) {
+            // The JDK running the tests, in a process of its own.
+            File home = new File(System.getProperty("java.home"));
+            jdk = new File(home, "bin/java").isFile() ? home : home.getParentFile();
+            // Compiled above already, in this process.
+        }
+
+        ClassRelocator relocator = new ClassRelocator(CompatLayers.SWING);
+        File[] classes = new File(original, "q").listFiles();
+        assertNotNull(classes);
+        assertTrue(new File(remapped, "q").isDirectory() || new File(remapped, "q").mkdirs());
+        for (File c : classes) {
+            byte[] out = relocator.remap(Files.readAllBytes(c.toPath()));
+            Files.write(new File(remapped, "q/" + c.getName()).toPath(), out);
+        }
+        return new String[][] {execute(jdk, original, false), execute(jdk, remapped, true)};
+    }
+
+    /// Runs `body` both ways and requires the same results, of which there
+    /// have to be at least `atLeast`.
+    void same(String body, int atLeast, String... gone) throws Exception {
+        String[][] both = run(body);
+        // What the remap was to replace is named by no class any more, so
+        // the second run cannot have been the JDK's own classes again.
+        File[] classes = new File(work, "remapped/q").listFiles();
+        assertNotNull(classes);
+        for (File c : classes) {
+            String constants = new String(Files.readAllBytes(c.toPath()), "ISO-8859-1");
+            for (String name : gone) {
+                assertTrue(c.getName() + " still names " + name, constants.indexOf(name) < 0);
+            }
+        }
+        assertEquals(Arrays.asList(both[0]).toString().replace(", ", ",\n "),
+                Arrays.asList(both[1]).toString().replace(", ", ",\n "));
+        assertTrue("only " + both[0].length + " results", both[0].length >= atLeast);
+    }
+
+    /// Requires every remapped class file together to still name each of
+    /// `names`: what the device's class library has under the JDK's name, and
+    /// the remap step therefore leaves alone. Called after [#same].
+    void keeps(String... names) throws Exception {
+        File[] classes = new File(work, "remapped/q").listFiles();
+        assertNotNull(classes);
+        StringBuilder all = new StringBuilder();
+        for (File c : classes) {
+            all.append(new String(Files.readAllBytes(c.toPath()), "ISO-8859-1"));
+        }
+        for (String name : names) {
+            assertTrue("The remapped classes no longer name " + name, all.indexOf(name) >= 0);
+        }
+    }
+
+    private void compile(File jdk, File classes, List<String> files) throws Exception {
+        List<String> args = new ArrayList<String>();
+        args.add("-d");
+        args.add(classes.getAbsolutePath());
+        args.add("-g");
+        args.add("-nowarn");
+        args.add("-encoding");
+        args.add("UTF-8");
+        if (jdk == null) {
+            if (running() > 8) {
+                args.add("--release");
+                args.add(String.valueOf(release));
+            }
+            args.addAll(files);
+            JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+            assertNotNull("These tests need a JDK, not a JRE", javac);
+            ByteArrayOutputStream errors = new ByteArrayOutputStream();
+            int result = javac.run(null, null, errors, args.toArray(new String[args.size()]));
+            assertEquals(new String(errors.toByteArray(), "UTF-8"), 0, result);
+            return;
+        }
+        args.add(0, new File(jdk, "bin/javac").getAbsolutePath());
+        args.add("--release");
+        args.add(String.valueOf(release));
+        args.addAll(files);
+        String[] result = fork(args);
+        assertEquals(result[1], "0", result[0]);
+    }
+
+    private String[] execute(File jdk, File classes, boolean device) throws Exception {
+        if (jdk == null) {
+            if (device) {
+                // What the stand-ins run on: Codename One, with no display.
+                com.codename1.compat.testing.HeadlessImplementation.install();
+            }
+            // Only the fixture's own classes are defined here; everything
+            // else, the stand-ins included, is the test's class path.
+            Loader loader = new Loader(getClass().getClassLoader(), classes);
+            try {
+                return (String[]) loader.loadClass("q.D").getMethod("texts").invoke(null);
+            } catch (InvocationTargetException e) {
+                Throwable cause = e.getCause();
+                if (cause instanceof Exception) {
+                    throw (Exception) cause;
+                }
+                throw e;
+            }
+        }
+        List<String> args = new ArrayList<String>();
+        args.add(new File(jdk, "bin/java").getAbsolutePath());
+        args.add("-Djava.awt.headless=true");
+        args.add("-cp");
+        args.add(classes.getAbsolutePath() + File.pathSeparator + testClassPath());
+        // Started through a class the remap never saw: every call in the
+        // fixture is redirected, the one that would end the process included.
+        args.add(RemapDifferentialMain.class.getName());
+        args.add(device ? "device" : "jdk");
+        String[] result = fork(args);
+        assertEquals(result[1], "0", result[0]);
+        String text = result[1];
+        if (text.length() == 0) {
+            return new String[0];
+        }
+        return text.substring(0, text.length() - 1).split("\n", -1);
+    }
+
+    private static final long FORK_TIMEOUT = 120000L;
+
+    private String[] fork(List<String> args) throws Exception {
+        ProcessBuilder pb = new ProcessBuilder(args);
+        pb.redirectErrorStream(true);
+        final Process p = pb.start();
+        // A fork that never ends is a failure of this test, not of the build
+        // that waits for it.
+        Thread watchdog = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(FORK_TIMEOUT);
+                    p.destroyForcibly();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }, "remap-differential-watchdog");
+        watchdog.setDaemon(true);
+        watchdog.start();
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            InputStream in = p.getInputStream();
+            byte[] buffer = new byte[8192];
+            for (int n = in.read(buffer); n >= 0; n = in.read(buffer)) {
+                out.write(buffer, 0, n);
+            }
+            return new String[] {String.valueOf(p.waitFor()), new String(out.toByteArray(), "UTF-8")};
+        } finally {
+            watchdog.interrupt();
+        }
+    }
+
+    private static final class Loader extends ClassLoader {
+        private final File classes;
+
+        Loader(ClassLoader parent, File classes) {
+            super(parent);
+            this.classes = classes;
+        }
+
+        @Override
+        protected Class<?> findClass(String name) throws ClassNotFoundException {
+            File f = new File(classes, name.replace('.', '/') + ".class");
+            if (!f.isFile()) {
+                throw new ClassNotFoundException(name);
+            }
+            try {
+                byte[] b = Files.readAllBytes(f.toPath());
+                return defineClass(name, b, 0, b.length);
+            } catch (IOException e) {
+                throw new ClassNotFoundException(name, e);
+            }
+        }
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/RemapDifferentialMain.java b/maven/build-engine/src/test/java/com/codename1/maven/RemapDifferentialMain.java
new file mode 100644
index 00000000000..f8b9cd9c002
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/RemapDifferentialMain.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+/// What a forked [RemapDifferential] run starts. It is not part of the fixture
+/// and so is never remapped: installing the headless implementation and ending
+/// the process are both calls the remap would have redirected, and Codename
+/// One's event thread keeps a virtual machine alive after `main` returns.
+public final class RemapDifferentialMain {
+    private RemapDifferentialMain() {
+    }
+
+    public static void main(String[] args) {
+        int result = 0;
+        try {
+            if (args.length > 0 && "device".equals(args[0])) {
+                Class.forName("com.codename1.compat.testing.HeadlessImplementation")
+                        .getMethod("install").invoke(null);
+            }
+            // The relocation ships a desktop application's main under
+            // another name (ClassRelocator.DESKTOP_MAIN), so the remapped
+            // arm finds it there and the JDK arm under its own.
+            java.lang.reflect.Method entry = null;
+            for (java.lang.reflect.Method m : Class.forName("q.D").getMethods()) {
+                if (m.getParameterTypes().length == 1 && m.getParameterTypes()[0] == String[].class
+                        && ("main".equals(m.getName()) || "cn1DesktopMain".equals(m.getName()))) {
+                    entry = m;
+                }
+            }
+            if (entry == null) {
+                throw new NoSuchMethodException("q.D has no main(String[])");
+            }
+            entry.invoke(null, (Object) new String[0]);
+        } catch (Throwable t) {
+            t.printStackTrace(System.out);
+            result = 1;
+        }
+        System.out.flush();
+        Runtime.getRuntime().halt(result);
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/RemappedProbeMain.java b/maven/build-engine/src/test/java/com/codename1/maven/RemappedProbeMain.java
new file mode 100644
index 00000000000..8471f098e62
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/RemappedProbeMain.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.lang.reflect.Method;
+
+/// What a forked test starts to run remapped classes that need a newer JVM
+/// than the one running the tests: installs the headless implementation,
+/// calls the static method named by the two arguments on Codename One's
+/// event dispatch thread, and prints `RESULT:` and what it answered.
+///
+/// It reaches everything by name, so the class path of the fork decides
+/// what it runs: the remapped classes, the headless implementation and the
+/// framework. It ends the process itself, since the event dispatch thread
+/// keeps a virtual machine alive after `main` returns.
+public final class RemappedProbeMain {
+    private RemappedProbeMain() {
+    }
+
+    public static void main(final String[] args) {
+        int result = 0;
+        try {
+            Class.forName("com.codename1.compat.testing.HeadlessImplementation").getMethod("install").invoke(null);
+            // What a lifecycle or the generated main class does first: hand
+            // the application's generated registry (resources, bundles,
+            // service providers) to the class library.
+            Class<?> registry;
+            try {
+                registry = Class.forName(ApplicationRegistry.NAME.replace('/', '.'));
+            } catch (ClassNotFoundException none) {
+                registry = null;
+            }
+            if (registry != null) {
+                registry.getMethod("cn1Install").invoke(null);
+            }
+            Class<?> displayClass = Class.forName("com.codename1.ui.Display");
+            Object display = displayClass.getMethod("getInstance").invoke(null);
+            final Object[] answer = new Object[1];
+            final Throwable[] failure = new Throwable[1];
+            Method wait = displayClass.getMethod("callSeriallyAndWait", Runnable.class);
+            wait.invoke(display, new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        answer[0] = Class.forName(args[0]).getMethod(args[1]).invoke(null);
+                    } catch (Throwable t) {
+                        failure[0] = t;
+                    }
+                }
+            });
+            if (failure[0] != null) {
+                Throwable t = failure[0].getCause() == null ? failure[0] : failure[0].getCause();
+                t.printStackTrace(System.out);
+                result = 1;
+            } else {
+                System.out.println("RESULT:" + answer[0]);
+            }
+        } catch (Throwable t) {
+            t.printStackTrace(System.out);
+            result = 1;
+        }
+        System.out.flush();
+        Runtime.getRuntime().halt(result);
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/ServiceProvidersTest.java b/maven/build-engine/src/test/java/com/codename1/maven/ServiceProvidersTest.java
new file mode 100644
index 00000000000..cf81943cb11
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/ServiceProvidersTest.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/// `ServiceLoader` on a device, end to end: an application and a library
+/// jar that list providers in `META-INF/services` are compiled by javac,
+/// remapped, checked for compliance, and then RUN from the remapped classes
+/// alone -- no services file is on that class path, so every provider the
+/// application sees came from the registry the build generated.
+public class ServiceProvidersTest {
+
+    private static final String CODEC = "package org.codecs;\n"
+            + "public interface Codec { String name(); }\n";
+
+    private static final String UNUSED = "package org.codecs;\n"
+            + "public interface Unused { }\n";
+
+    /// What the application calls; the only class of the library it names.
+    private static final String CODECS = "package org.codecs;\n"
+            + "public class Codecs {\n"
+            + "    public static final java.util.List<String> MADE = new java.util.ArrayList<String>();\n"
+            + "    public static String all() {\n"
+            + "        StringBuilder sb = new StringBuilder();\n"
+            + "        java.util.Iterator<Codec> it = java.util.ServiceLoader.load(Codec.class).iterator();\n"
+            + "        sb.append(it.hasNext()).append(MADE);\n"
+            + "        while (it.hasNext()) {\n"
+            + "            sb.append(' ').append(it.next().name()).append(MADE.size());\n"
+            + "        }\n"
+            + "        return sb.toString();\n"
+            + "    }\n"
+            + "    public static String resource(String name) throws java.io.IOException {\n"
+            + "        java.io.InputStream in = Codecs.class.getResourceAsStream(name);\n"
+            + "        if (in == null) { return \"none\"; }\n"
+            + "        StringBuilder sb = new StringBuilder();\n"
+            + "        for (int c = in.read(); c >= 0; c = in.read()) { sb.append((char) c); }\n"
+            + "        in.close();\n"
+            + "        return sb.toString();\n"
+            + "    }\n"
+            + "}\n";
+
+    private static String provider(String pkg, String name, String modifiers, String constructor, String answer) {
+        return "package " + pkg + ";\n"
+                + "public " + modifiers + "class " + name + " implements org.codecs.Codec {\n"
+                + "    " + constructor + " " + name + "() { org.codecs.Codecs.MADE.add(\"" + answer + "\"); }\n"
+                + "    public String name() { return \"" + answer + "\"; }\n"
+                + "}\n";
+    }
+
+    private static final String MAIN = "package com.acme.swingapp;\n"
+            + "public class Main {\n"
+            + "    public static void main(String[] args) { new javax.swing.JLabel(\"x\"); }\n"
+            + "    public static String report() throws Exception {\n"
+            + "        int listeners = 0;\n"
+            + "        for (java.awt.event.ActionListener l\n"
+            + "                : java.util.ServiceLoader.load(java.awt.event.ActionListener.class)) {\n"
+            + "            listeners += l instanceof Clicker ? 1 : 100;\n"
+            + "        }\n"
+            + "        return org.codecs.Codecs.all() + \"|\" + listeners + \"|\"\n"
+            + "                + org.codecs.Codecs.resource(\"table.txt\") + \"|\"\n"
+            + "                + org.codecs.Codecs.resource(\"/META-INF/resources/codecs/glyphs.txt\") + \"|\"\n"
+            + "                + java.util.ServiceLoader.load(Runnable.class).iterator().hasNext();\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String CLICKER = "package com.acme.swingapp;\n"
+            + "public class Clicker implements java.awt.event.ActionListener {\n"
+            + "    public void actionPerformed(java.awt.event.ActionEvent e) { }\n"
+            + "}\n";
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+    private final List<String> logged = new ArrayList<String>();
+
+    private final com.codename1.build.Log log = new com.codename1.build.Log() {
+        public void debug(CharSequence c) { }
+        public void debug(CharSequence c, Throwable e) { }
+        public void debug(Throwable e) { }
+        public void info(CharSequence c) { }
+        public void info(CharSequence c, Throwable e) { }
+        public void info(Throwable e) { }
+        public void warn(CharSequence c) { logged.add("warn: " + c); }
+        public void warn(CharSequence c, Throwable e) { }
+        public void warn(Throwable e) { }
+        public void error(CharSequence c) { }
+        public void error(CharSequence c, Throwable e) { }
+        public void error(Throwable e) { }
+        public boolean isDebugEnabled() { return false; }
+        public boolean isInfoEnabled() { return true; }
+        public boolean isWarnEnabled() { return true; }
+        public boolean isErrorEnabled() { return true; }
+    };
+
+    private List<File> runtimes() throws Exception {
+        if (scratch == null) {
+            scratch = tmp.newFolder("jars");
+        }
+        return new ArrayList<File>(Arrays.asList(RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch)));
+    }
+
+    /// The library: a service, the class that loads it, and providers of
+    /// which two can be created, one is abstract, one has no public
+    /// constructor and one is listed but not in the jar.
+    private File library() throws Exception {
+        File out = tmp.newFolder();
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), out,
+                "org/codecs/Codec.java", CODEC, "org/codecs/Unused.java", UNUSED, "org/codecs/Codecs.java", CODECS,
+                "org/codecs/impl/Hex.java", provider("org.codecs.impl", "Hex", "", "public", "hex"),
+                "org/codecs/impl/Base64.java", provider("org.codecs.impl", "Base64", "", "public", "base64"),
+                "org/codecs/impl/Half.java", provider("org.codecs.impl", "Half", "abstract ", "public", "half"),
+                "org/codecs/impl/Hidden.java", provider("org.codecs.impl", "Hidden", "", "", "hidden"),
+                "org/codecs/impl/Spare.java", provider("org.codecs.impl", "Spare", "", "public", "spare"));
+        List<Object> entries = new ArrayList<Object>();
+        for (String name : new String[] {"Codec", "Unused", "Codecs", "impl/Hex", "impl/Base64", "impl/Half",
+            "impl/Hidden", "impl/Spare"}) {
+            entries.add("org/codecs/" + name + ".class");
+            entries.add(Files.readAllBytes(new File(out, "org/codecs/" + name + ".class").toPath()));
+        }
+        entries.add("META-INF/services/org.codecs.Codec");
+        entries.add(("# the codecs of this library\n\n  org.codecs.impl.Hex   # the first\n"
+                + "org.codecs.impl.Gone\norg.codecs.impl.Half\n\t\norg.codecs.impl.Base64\n"
+                + "org.codecs.impl.Hidden\norg.codecs.impl.Hex\n").getBytes("UTF-8"));
+        // A service nothing names: its provider is not reached and not missed.
+        entries.add("META-INF/services/org.codecs.Unused");
+        entries.add("org.codecs.impl.Spare\norg.codecs.impl.AlsoGone\n".getBytes("UTF-8"));
+        entries.add("org/codecs/table.txt");
+        entries.add("0123".getBytes("UTF-8"));
+        entries.add("META-INF/resources/codecs/glyphs.txt");
+        entries.add("glyphs".getBytes("UTF-8"));
+        entries.add("META-INF/MANIFEST.MF");
+        entries.add("Manifest-Version: 1.0\n".getBytes("UTF-8"));
+        return CompatRemapperTest.jar(new File(tmp.newFolder(), "codecs-1.0.jar"), entries.toArray());
+    }
+
+    private CompatRemapper remapper(File classes, File resources, File lib) throws Exception {
+        List<File> cp = runtimes();
+        cp.add(lib);
+        File desktop = tmp.newFolder();
+        return new CompatRemapper(classes, cp, null, log).withDesktopSourceDirectory(desktop)
+                .withResourceDirectories(Collections.singletonList(resources))
+                .withApplicationLibraries(Collections.singletonList(lib));
+    }
+
+    /// Calls the application's `report()` in a loader that holds the
+    /// remapped classes, the headless implementation and the framework,
+    /// and nothing of this JVM's class path.
+    private String report(File classes) throws Exception {
+        URL[] urls = {
+            classes.toURI().toURL(),
+            RealCompatJars.jar("codenameone-compat-testing", scratch).toURI().toURL(),
+            RealCompatJars.core(scratch).toURI().toURL(),
+            RealCompatJars.jdkHost(scratch).toURI().toURL(),
+        };
+        URLClassLoader loader = new URLClassLoader(urls, ClassLoader.getSystemClassLoader().getParent());
+        try {
+            loader.loadClass("com.codename1.compat.testing.HeadlessImplementation").getMethod("install").invoke(null);
+            // What the application's lifecycle does first.
+            loader.loadClass(ApplicationRegistry.NAME.replace('/', '.')).getMethod("cn1Install").invoke(null);
+            return (String) loader.loadClass("com.acme.swingapp.Main").getMethod("report").invoke(null);
+        } catch (InvocationTargetException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof Exception) {
+                throw (Exception) cause;
+            }
+            throw e;
+        } finally {
+            loader.close();
+        }
+    }
+
+    @Test
+    public void theProvidersAServicesFileListsAreCreatedByTheGeneratedRegistry() throws Exception {
+        File lib = library();
+        List<File> cp = runtimes();
+        cp.add(lib);
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(cp, tmp.newFolder(), classes, "com/acme/swingapp/Main.java", MAIN,
+                "com/acme/swingapp/Clicker.java", CLICKER,
+                "com/acme/swingapp/Rot13.java", provider("com.acme.swingapp", "Rot13", "", "public", "rot13"));
+        // The application's own services files, as its build copies them.
+        File resources = tmp.newFolder();
+        String[][] own = {
+            {"META-INF/services/org.codecs.Codec", "com.acme.swingapp.Rot13\n"},
+            // A service the remap moves: the file names the JDK's interface.
+            {"META-INF/services/java.awt.event.ActionListener", "com.acme.swingapp.Clicker\n"},
+        };
+        for (String[] file : own) {
+            for (File root : new File[] {resources, classes}) {
+                File f = new File(root, file[0]);
+                assertTrue(f.getParentFile().isDirectory() || f.getParentFile().mkdirs());
+                Files.write(f.toPath(), file[1].getBytes("UTF-8"));
+            }
+        }
+
+        assertTrue(remapper(classes, resources, lib).run());
+
+        // A provider is named by no instruction: the services file of a
+        // service the application reaches is what reaches it.
+        assertTrue(new File(classes, "org/codecs/impl/Hex.class").isFile());
+        assertTrue(new File(classes, "org/codecs/impl/Base64.class").isFile());
+        assertFalse("A provider of a service nothing names stays out",
+                new File(classes, "org/codecs/impl/Spare.class").exists());
+        assertFalse("No services file is left for a class path search a device does not have",
+                new File(classes, "META-INF/services").exists());
+        assertTrue("A library's resources ship under their flat names",
+                new File(classes, "org__codecs__table.txt").isFile());
+        assertTrue(new File(classes, "META-INF__resources__codecs__glyphs.txt").isFile());
+        assertFalse(new File(classes, "org/codecs/table.txt").exists());
+
+        // One warning for each listed provider that cannot be created,
+        // naming the file and the class, and the build went on.
+        List<String> warnings = new ArrayList<String>();
+        for (String line : logged) {
+            if (line.contains("service provider")) {
+                warnings.add(line);
+            }
+        }
+        assertEquals(warnings.toString(), 3, warnings.size());
+        assertEquals("warn: The service provider org.codecs.impl.Gone, listed in META-INF/services/org.codecs.Codec"
+                + " of codecs-1.0.jar, is not among the classes the application ships. ServiceLoader will not"
+                + " offer it on a device.", warnings.get(0));
+        assertTrue(warnings.get(1), warnings.get(1).startsWith("warn: The service provider org.codecs.impl.Half, "
+                + "listed in META-INF/services/org.codecs.Codec of codecs-1.0.jar, cannot be created"));
+        assertTrue(warnings.get(2), warnings.get(2).startsWith("warn: The service provider org.codecs.impl.Hidden,"));
+
+        // Nothing the registry or the providers name is missing on a device.
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        host.artifacts.add(new BuildArtifact("org.example", "codecs", "1", null, "jar", "compile", lib, null));
+        new BytecodeCompliance(host).execute();
+
+        // The application's file first, then the library's in its order;
+        // hasNext() created nothing and each next() created one provider.
+        // The moved service found its provider under the name it ships by.
+        String expected = "true[] rot131 hex2 base643|1|0123|glyphs|false";
+        assertEquals(expected, report(classes));
+
+        // A second build over the same directory changes nothing.
+        byte[] registry = Files.readAllBytes(new File(classes, ApplicationRegistry.NAME + ".class").toPath());
+        logged.clear();
+        assertTrue(remapper(classes, resources, lib).run());
+        assertArrayEquals(registry,
+                Files.readAllBytes(new File(classes, ApplicationRegistry.NAME + ".class").toPath()));
+        assertTrue(new File(classes, "org__codecs__table.txt").isFile());
+        assertFalse(new File(classes, "org/codecs/table.txt").exists());
+        assertEquals(expected, report(classes));
+    }
+
+    /// A services file that lists nothing that ships is three warnings'
+    /// worth of nothing: the build succeeds and the loader is empty.
+    @Test
+    public void aListedProviderThatIsAbsentIsAWarningNotAFailure() throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, "com/acme/swingapp/Main.java",
+                "package com.acme.swingapp;\n"
+                + "public class Main {\n"
+                + "    public static void main(String[] args) { new javax.swing.JLabel(\"x\"); }\n"
+                + "    public static String report() {\n"
+                + "        return String.valueOf(java.util.ServiceLoader.load(Runnable.class).iterator().hasNext());\n"
+                + "    }\n"
+                + "}\n");
+        File resources = tmp.newFolder();
+        for (File root : new File[] {resources, classes}) {
+            File f = new File(root, "META-INF/services/java.lang.Runnable");
+            assertTrue(f.getParentFile().mkdirs());
+            Files.write(f.toPath(), "com.acme.swingapp.Nowhere # never written\n".getBytes("UTF-8"));
+        }
+        List<File> cp = runtimes();
+        File desktop = tmp.newFolder();
+        assertTrue(new CompatRemapper(classes, cp, null, log).withDesktopSourceDirectory(desktop)
+                .withResourceDirectories(Collections.singletonList(resources))
+                .withApplicationLibraries(Collections.<File>emptyList()).run());
+        assertEquals(Collections.singletonList("warn: The service provider com.acme.swingapp.Nowhere, listed in "
+                + "META-INF/services/java.lang.Runnable, is not among the classes the application ships. "
+                + "ServiceLoader will not offer it on a device."), logged);
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+        assertEquals("false", report(classes));
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/SwingGallerySampleTest.java b/maven/build-engine/src/test/java/com/codename1/maven/SwingGallerySampleTest.java
new file mode 100644
index 00000000000..e31f62db0fa
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/SwingGallerySampleTest.java
@@ -0,0 +1,463 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import com.codename1.build.BuildArtifact;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Properties;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// The Swing gallery sample (`scripts/desktop-compat-samples/swing-gallery`),
+/// taken through what a project's build does to it and then RUN.
+///
+/// The sample is an ordinary desktop project: it is compiled here by javac
+/// against the JDK's own Swing and the real SwingX and MigLayout jars,
+/// exactly as its own `mvn compile` does. The remap step then relocates it
+/// and MigLayout onto the layer, the compliance check has to find nothing,
+/// and the result is loaded into a class loader that holds nothing but those
+/// classes, the framework and the headless implementation the layers' own
+/// tests use. There the main class the importer writes is started on the event
+/// dispatch thread, and every tab is selected and painted into an image.
+///
+/// No window is opened anywhere: the display is a 1080 by 1920 buffer.
+public class SwingGallerySampleTest {
+
+    private static final String MAIN = "com.acme.gallery.GalleryMain";
+
+    /// One string each tab draws and no other tab does, in tab order.
+    private static final String[] SHOWN = {"Click me", "North", "Jupiter  -  95 moons", "Clear drawing",
+        "Custom dialog", "Find primes", "Toggle busy", "/icons/star.png: 32 x 32"};
+
+    /// The same for the tabs of the Layouts tab, by their titles.
+    private static final Properties INNER = new Properties();
+
+    static {
+        INNER.setProperty("Border", "North");
+        INNER.setProperty("GridBag", "First name:");
+        INNER.setProperty("Group", "Connect");
+        INNER.setProperty("Box", "Far right");
+        INNER.setProperty("Card", "The first card");
+        INNER.setProperty("Mig", "Street:");
+    }
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File scratch;
+
+    /// The sample's directory, found from this module's.
+    private static File sample() {
+        File at = new File("").getAbsoluteFile();
+        for (int depth = 0; at != null && depth < 6; depth++) {
+            File candidate = new File(at, "scripts/desktop-compat-samples/swing-gallery");
+            if (candidate.isDirectory()) {
+                return candidate;
+            }
+            at = at.getParentFile();
+        }
+        throw new AssertionError("scripts/desktop-compat-samples/swing-gallery was not found above "
+                + new File("").getAbsolutePath());
+    }
+
+    static void sources(File dir, String rel, List<String> out) throws Exception {
+        File[] files = dir.listFiles();
+        assertNotNull(dir.toString(), files);
+        Arrays.sort(files);
+        for (File f : files) {
+            if (f.isDirectory()) {
+                sources(f, rel + f.getName() + "/", out);
+            } else if (f.getName().endsWith(".java")) {
+                out.add(rel + f.getName());
+                out.add(new String(Files.readAllBytes(f.toPath()), "UTF-8"));
+            }
+        }
+    }
+
+    static void copy(File from, File to) throws Exception {
+        File[] files = from.listFiles();
+        assertNotNull(from.toString(), files);
+        for (File f : files) {
+            File target = new File(to, f.getName());
+            if (f.isDirectory()) {
+                assertTrue(target.isDirectory() || target.mkdirs());
+                copy(f, target);
+            } else {
+                Files.write(target.toPath(), Files.readAllBytes(f.toPath()));
+            }
+        }
+    }
+
+    private List<File> runtimes() throws Exception {
+        if (scratch == null) {
+            scratch = tmp.newFolder("jars");
+        }
+        return new ArrayList<File>(Arrays.asList(RealCompatJars.swing(scratch), RealCompatJars.javafx(scratch),
+                RealCompatJars.core(scratch)));
+    }
+
+    /// Compiles and remaps the sample; answers the classes directory.
+    private File build() throws Exception {
+        List<File> jars = runtimes();
+        File swingx = RealCompatJars.jar("swingx-all", scratch);
+        File migCore = RealCompatJars.jar("miglayout-core", scratch);
+        File migSwing = RealCompatJars.jar("miglayout-swing", scratch);
+        List<File> libraries = Arrays.asList(migCore, migSwing);
+
+        File classes = tmp.newFolder("classes");
+        List<String> sources = new ArrayList<String>();
+        sources(new File(sample(), "src/main/java"), "", sources);
+        // The main class cn1:import-desktop-project writes into the
+        // application's src/main/java, word for word.
+        sources.add(MAIN.replace('.', '/') + ".java");
+        sources.add(DesktopProjectImporter.mainClassSource(MAIN,
+                new DesktopProjectImporter.Candidate("com.example.gallery.GalleryApp"), false));
+        // The JDK's Swing and the two libraries; of the layer only what the
+        // main class extends, which is under the names it ships with.
+        List<File> compile = new ArrayList<File>(jars);
+        compile.addAll(Arrays.asList(swingx, migCore, migSwing));
+        CompatFixtures.compileAgainst(compile, tmp.newFolder(), classes, sources.toArray(new String[sources.size()]));
+
+        // The build tool's resources step, which runs before the remap.
+        File resources = new File(sample(), "src/main/resources");
+        copy(resources, classes);
+
+        List<File> cp = new ArrayList<File>(jars);
+        cp.add(swingx);
+        cp.addAll(libraries);
+        assertTrue(new CompatRemapper(classes, cp, null, CompatRemapperTest.LOG)
+                .withResourceDirectories(Collections.singletonList(resources))
+                .withApplicationLibraries(libraries).run());
+
+        // SwingX is provided -- the layer has its own -- and MigLayout ships.
+        TestProjectHost host = RealCompatJars.host(classes, tmp.newFolder(), scratch);
+        host.artifacts.add(new BuildArtifact("org.swinglabs.swingx", "swingx-all", "1", null, "jar", "provided",
+                swingx, null));
+        host.artifacts.add(new BuildArtifact("com.miglayout", "miglayout-core", "1", null, "jar", "compile",
+                migCore, null));
+        host.artifacts.add(new BuildArtifact("com.miglayout", "miglayout-swing", "1", null, "jar", "compile",
+                migSwing, null));
+        // Throws on a single finding, in the application, in MigLayout or in
+        // the runtime the remap extracted.
+        new BytecodeCompliance(host).execute();
+        return classes;
+    }
+
+    /// The whole Swing runtime, as it ships with the smallest application
+    /// there is: every class of the jar has to be something a device can
+    /// link, whether or not this application reaches it.
+    @Test
+    public void theWholeSwingRuntimeIsCompliant() throws Exception {
+        File classes = tmp.newFolder("trivial");
+        CompatFixtures.compileAgainst(runtimes(), tmp.newFolder(), classes, "com/acme/tiny/Main.java",
+                "package com.acme.tiny;\npublic class Main {\n"
+                + "    public static void main(String[] args) { new javax.swing.JFrame(\"tiny\").setVisible(true); }\n"
+                + "}\n");
+        assertTrue(new CompatRemapper(classes, runtimes(), null, CompatRemapperTest.LOG).run());
+
+        int shipped = 0;
+        for (File jar : new File[] {RealCompatJars.swing(scratch)}) {
+            ZipFile zip = new ZipFile(jar);
+            try {
+                Enumeration<? extends ZipEntry> entries = zip.entries();
+                while (entries.hasMoreElements()) {
+                    String name = entries.nextElement().getName();
+                    if (name.endsWith(".class") && !name.startsWith("META-INF/")) {
+                        assertTrue(name + " of " + jar.getName() + " did not ship",
+                                new File(classes, name).isFile());
+                        shipped++;
+                    }
+                }
+            } finally {
+                zip.close();
+            }
+        }
+        assertTrue("The runtime is more than " + shipped + " classes", shipped > 500);
+        // Zero findings: execute() throws on the first.
+        new BytecodeCompliance(RealCompatJars.host(classes, tmp.newFolder(), scratch)).execute();
+    }
+
+    @Test
+    public void theSampleRunsHeadless() throws Exception {
+        File classes = build();
+        assertTrue(new File(classes, "net/miginfocom/swing/MigLayout.class").isFile());
+        assertTrue(new File(classes, "icons__star.png").isFile());
+        assertFalse(new File(classes, "icons/star.png").exists());
+
+        // Nothing of this JVM's classpath but the JDK: the remapped classes,
+        // the headless implementation ahead of the framework (it supplies the
+        // ImplementationFactory the framework starts on), and the framework.
+        URL[] urls = {
+            classes.toURI().toURL(),
+            RealCompatJars.jar("codenameone-compat-testing", scratch).toURI().toURL(),
+            RealCompatJars.core(scratch).toURI().toURL(),
+            RealCompatJars.jdkHost(scratch).toURI().toURL(),
+        };
+        final URLClassLoader loader = new URLClassLoader(urls, ClassLoader.getSystemClassLoader().getParent());
+        try {
+            run(loader);
+        } finally {
+            loader.close();
+        }
+    }
+
+    static Object call(Object target, String name, Object... args) throws Exception {
+        return invoke(target.getClass(), target, name, args);
+    }
+
+    static Object invoke(Class<?> type, Object target, String name, Object... args) throws Exception {
+        for (Method m : type.getMethods()) {
+            if (m.getName().equals(name) && m.getParameterTypes().length == args.length) {
+                m.setAccessible(true);
+                try {
+                    return m.invoke(target, args);
+                } catch (IllegalArgumentException e) {
+                    // An overload with as many parameters of other types.
+                    continue;
+                } catch (InvocationTargetException e) {
+                    Throwable cause = e.getCause();
+                    if (cause instanceof Exception) {
+                        throw (Exception) cause;
+                    }
+                    throw e;
+                }
+            }
+        }
+        throw new AssertionError(type.getName() + " has no public " + name + " with " + args.length + " arguments");
+    }
+
+    /// Runs `work` on the event dispatch thread and rethrows what it threw.
+    static void onEdt(Object display, final ThrowingRunnable work) throws Exception {
+        final Throwable[] failure = new Throwable[1];
+        call(display, "callSeriallyAndWait", new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    work.run();
+                } catch (Throwable t) {
+                    failure[0] = t;
+                }
+            }
+        });
+        if (failure[0] instanceof Error) {
+            throw (Error) failure[0];
+        }
+        if (failure[0] != null) {
+            throw new Exception("On the event dispatch thread: " + failure[0], failure[0]);
+        }
+    }
+
+    /// Paints `form` into an image the size of the display and answers every
+    /// string that was drawn.
+    static List<String> paint(ClassLoader loader, Object form) throws Exception {
+        Class<?> headless = loader.loadClass("com.codename1.compat.testing.HeadlessImplementation");
+        // Every string a paint draws, as {text, x, y}, while recordText is set.
+        List<?> drawn = (List<?>) headless.getField("drawnText").get(null);
+        Object target = invoke(loader.loadClass("com.codename1.ui.Image"), null, "createImage", 1080, 1920);
+        drawn.clear();
+        headless.getField("recordText").setBoolean(null, true);
+        try {
+            call(form, "paintComponent", call(target, "getGraphics"));
+        } finally {
+            headless.getField("recordText").setBoolean(null, false);
+        }
+        List<String> text = new ArrayList<String>();
+        for (Object entry : drawn) {
+            text.add(String.valueOf(((Object[]) entry)[0]));
+        }
+        drawn.clear();
+        return text;
+    }
+
+    /// The first tabbed pane inside `component`, or null.
+    private static Object nestedTabs(Object component) throws Exception {
+        if (component == null) {
+            return null;
+        }
+        if (component.getClass().getName().endsWith(".JTabbedPane")) {
+            return component;
+        }
+        Class<?> container = component.getClass().getClassLoader()
+                .loadClass("com.codename1.desktopcompat.java.awt.Container");
+        if (!container.isInstance(component)) {
+            return null;
+        }
+        int n = ((Integer) call(component, "getComponentCount")).intValue();
+        for (int i = 0; i < n; i++) {
+            Object found = nestedTabs(call(component, "getComponent", i));
+            if (found != null) {
+                return found;
+            }
+        }
+        return null;
+    }
+
+    interface ThrowingRunnable {
+        void run() throws Exception;
+    }
+
+    private void run(final ClassLoader loader) throws Exception {
+        final Class<?> headless = loader.loadClass("com.codename1.compat.testing.HeadlessImplementation");
+        // The headless implementation decodes an image only when asked to;
+        // the sample reads the size of a PNG it ships.
+        headless.getField("pixelImages").setBoolean(null, true);
+        invoke(headless, null, "install");
+        final Class<?> displayClass = loader.loadClass("com.codename1.ui.Display");
+        final Object display = invoke(displayClass, null, "getInstance");
+
+        // An exception inside an event or a repaint never reaches the code
+        // that posted it; the framework hands it to these.
+        final List<String> errors = Collections.synchronizedList(new ArrayList<String>());
+        Class<?> listener = loader.loadClass("com.codename1.ui.events.ActionListener");
+        Object handler = Proxy.newProxyInstance(loader, new Class<?>[] {listener}, new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                if ("actionPerformed".equals(method.getName()) && args != null && args.length == 1) {
+                    Object source = SwingGallerySampleTest.call(args[0], "getSource");
+                    java.io.StringWriter trace = new java.io.StringWriter();
+                    if (source instanceof Throwable) {
+                        ((Throwable) source).printStackTrace(new java.io.PrintWriter(trace, true));
+                    }
+                    errors.add(source + "\n" + trace);
+                    SwingGallerySampleTest.call(args[0], "consume");
+                    return null;
+                }
+                if ("equals".equals(method.getName())) {
+                    return proxy == args[0];
+                }
+                if ("hashCode".equals(method.getName())) {
+                    return System.identityHashCode(proxy);
+                }
+                return "edt errors";
+            }
+        });
+        call(display, "addEdtErrorHandler", handler);
+
+        final Object lifecycle = loader.loadClass(MAIN).getConstructor().newInstance();
+        assertEquals("com.codename1.desktopcompat.rt.DesktopLifecycle",
+                lifecycle.getClass().getSuperclass().getName());
+        onEdt(display, new ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                call(lifecycle, "init", new Object[] {null});
+                call(lifecycle, "start");
+            }
+        });
+        // main() posts the frame with invokeLater; let that, and whatever it
+        // posts in turn, go through the queue.
+        for (int i = 0; i < 3; i++) {
+            onEdt(display, new ThrowingRunnable() {
+                @Override
+                public void run() {
+                }
+            });
+        }
+
+        final Properties messages = new Properties();
+        InputStream in = new FileInputStream(new File(sample(), "src/main/resources/messages.properties"));
+        try {
+            messages.load(in);
+        } finally {
+            in.close();
+        }
+        final String[] keys = {"tab.controls", "tab.layouts", "tab.data", "tab.painting", "tab.dialogs",
+            "tab.worker", "tab.swingx", "tab.resources"};
+        final List<String> painted = new ArrayList<String>();
+        onEdt(display, new ThrowingRunnable() {
+            @Override
+            public void run() throws Exception {
+                Object[] frames = (Object[]) invoke(
+                        loader.loadClass("com.codename1.desktopcompat.java.awt.Frame"), null, "getFrames");
+                assertEquals("The application shows one frame; " + errors, 1, frames.length);
+                Object frame = frames[0];
+                assertEquals(messages.getProperty("app.title"), call(frame, "getTitle"));
+                Object form = call(frame, "cn1Form");
+                assertTrue(loader.loadClass("com.codename1.ui.Form").isInstance(form));
+                assertTrue("The frame's form is the one showing", form == call(display, "getCurrent"));
+
+                Object tabs = call(call(frame, "getContentPane"), "getComponent", 0);
+                assertEquals("com.codename1.desktopcompat.javax.swing.JTabbedPane", tabs.getClass().getName());
+                assertEquals(keys.length, call(tabs, "getTabCount"));
+                for (int i = 0; i < keys.length; i++) {
+                    assertEquals(messages.getProperty(keys[i]), call(tabs, "getTitleAt", i));
+                    call(tabs, "setSelectedIndex", i);
+                    assertEquals(i, call(tabs, "getSelectedIndex"));
+                    call(form, "revalidate");
+                    List<String> text = paint(loader, form);
+                    assertTrue(keys[i] + " paints " + SHOWN[i] + ": " + text, text.contains(SHOWN[i]));
+                    // A tab that holds tabs of its own: each of those too.
+                    Object inner = nestedTabs(call(tabs, "getComponentAt", i));
+                    if (inner != null) {
+                        int count = ((Integer) call(inner, "getTabCount")).intValue();
+                        for (int t = 0; t < count; t++) {
+                            call(inner, "setSelectedIndex", t);
+                            call(form, "revalidate");
+                            List<String> innerText = paint(loader, form);
+                            String title = (String) call(inner, "getTitleAt", t);
+                            String expected = INNER.getProperty(title);
+                            assertNotNull("An inner tab this test does not know: " + title, expected);
+                            assertTrue(title + " paints " + expected + ": " + innerText,
+                                    innerText.contains(expected));
+                            painted.add(keys[i] + "/" + title);
+                        }
+                    }
+                    painted.add(keys[i]);
+                }
+            }
+        });
+        // Whatever selecting and painting posted.
+        onEdt(display, new ThrowingRunnable() {
+            @Override
+            public void run() {
+            }
+        });
+        assertEquals(Arrays.asList("tab.controls", "tab.layouts/Border", "tab.layouts/GridBag", "tab.layouts/Group",
+                "tab.layouts/Box", "tab.layouts/Card", "tab.layouts/Mig", "tab.layouts", "tab.data", "tab.painting",
+                "tab.dialogs", "tab.worker", "tab.swingx", "tab.resources"), painted);
+        assertTrue("Nothing may be thrown on the event dispatch thread: " + errors, errors.isEmpty());
+    }
+}
diff --git a/maven/build-engine/src/test/java/com/codename1/maven/UnrelocatedTypesTest.java b/maven/build-engine/src/test/java/com/codename1/maven/UnrelocatedTypesTest.java
new file mode 100644
index 00000000000..5aa4dddb4ce
--- /dev/null
+++ b/maven/build-engine/src/test/java/com/codename1/maven/UnrelocatedTypesTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.PrintStream;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/// The check the integration tests run over a remapped classes directory:
+/// a type left under a toolkit's package is reported, text that merely
+/// spells one is not.
+public class UnrelocatedTypesTest {
+
+    /// Spells Swing's names every way a string can, and names no Swing type.
+    private static final String WORDS = "package com.acme;\n"
+            + "@Deprecated\n"
+            + "public class Words {\n"
+            + "    public static final String PATH = \"javax/swing/JTable\";\n"
+            + "    String descriptor() { return \"Ljavax/swing/JTable;\" + \"(Ljava/awt/Color;)V\"; }\n"
+            + "    String dotted() { return \"javax.swing.JTable\".concat(\" javax/swing/plaf/basic/icon.png\"); }\n"
+            + "    Object resource() { return Words.class.getResource(\"/javax/swing/x.properties\"); }\n"
+            + "}\n";
+
+    private static final String FIELD = "package com.acme;\n"
+            + "public class Holder { javax.swing.JTable table; }\n";
+
+    private static final String SIGNATURE = "package com.acme;\n"
+            + "public class Generic { java.util.List<java.awt.Color> colors() { return null; } }\n";
+
+    private static final String BODY = "package com.acme;\n"
+            + "public class Body {\n"
+            + "    Object make() { return new javax.swing.JLabel(\"x\"); }\n"
+            + "    Class<?> literal() { return java.awt.Point[].class; }\n"
+            + "}\n";
+
+    private static final List<String> SWING = Arrays.asList("javax/swing/", "java/awt/");
+
+    @Rule
+    public TemporaryFolder tmp = new TemporaryFolder();
+
+    private File compile(String... nameThenSource) throws Exception {
+        File classes = tmp.newFolder();
+        CompatFixtures.compile(tmp.newFolder(), classes, nameThenSource);
+        return classes;
+    }
+
+    @Test
+    public void textThatSpellsAToolkitNameIsNotAReference() throws Exception {
+        File classes = compile("com/acme/Words.java", WORDS);
+        // The bytes are there, which is what a search of the file trips on.
+        assertTrue(new String(Files.readAllBytes(new File(classes, "com/acme/Words.class").toPath()), "ISO-8859-1")
+                .contains("Ljavax/swing/JTable;"));
+        assertTrue(UnrelocatedTypes.scan(classes, SWING).isEmpty());
+    }
+
+    @Test
+    public void aTypeIsFoundWhereverAClassNamesIt() throws Exception {
+        File classes = compile("com/acme/Words.java", WORDS, "com/acme/Holder.java", FIELD,
+                "com/acme/Generic.java", SIGNATURE, "com/acme/Body.java", BODY);
+        Map<String, Set<String>> found = UnrelocatedTypes.scan(classes, SWING);
+        assertEquals(Arrays.asList("com/acme/Body.class", "com/acme/Generic.class", "com/acme/Holder.class"),
+                new java.util.ArrayList<String>(found.keySet()));
+        assertEquals("[javax/swing/JTable]", found.get("com/acme/Holder.class").toString());
+        // Only in the generic signature: the erased descriptor is List.
+        assertEquals("[java/awt/Color]", found.get("com/acme/Generic.class").toString());
+        assertEquals("[java/awt/Point, javax/swing/JLabel]", found.get("com/acme/Body.class").toString());
+        // A package is matched whole: java/awt is not java/awtx.
+        assertTrue(UnrelocatedTypes.scan(classes, Arrays.asList("javax/swi/", "java/aw/")).isEmpty());
+    }
+
+    @Test
+    public void theProgramPrintsOneLineAClassAndAnswersByItsStatus() throws Exception {
+        File classes = compile("com/acme/Words.java", WORDS, "com/acme/Holder.java", FIELD);
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        ByteArrayOutputStream err = new ByteArrayOutputStream();
+        assertEquals(1, UnrelocatedTypes.run(new String[] {classes.getPath(), "javax/swing", "java/awt/"},
+                new PrintStream(out, true, "UTF-8"), new PrintStream(err, true, "UTF-8")));
+        assertEquals("com/acme/Holder.class\tjavax/swing/JTable\n", out.toString("UTF-8").replace("\r", ""));
+
+        // A jar is read as the directory is.
+        File jar = CompatRemapperTest.jar(new File(tmp.newFolder(), "app.jar"),
+                "com/acme/Holder.class", Files.readAllBytes(new File(classes, "com/acme/Holder.class").toPath()),
+                "com/acme/Words.class", Files.readAllBytes(new File(classes, "com/acme/Words.class").toPath()),
+                "notes.txt", "javax/swing/JTable".getBytes("UTF-8"));
+        out.reset();
+        assertEquals(1, UnrelocatedTypes.run(new String[] {jar.getPath(), "javax/swing"},
+                new PrintStream(out, true, "UTF-8"), new PrintStream(err, true, "UTF-8")));
+        assertEquals("com/acme/Holder.class\tjavax/swing/JTable\n", out.toString("UTF-8").replace("\r", ""));
+
+        out.reset();
+        assertEquals(0, UnrelocatedTypes.run(new String[] {classes.getPath(), "javafx"},
+                new PrintStream(out, true, "UTF-8"), new PrintStream(err, true, "UTF-8")));
+        assertEquals("", out.toString("UTF-8"));
+        assertEquals(2, UnrelocatedTypes.run(new String[] {classes.getPath()},
+                new PrintStream(out, true, "UTF-8"), new PrintStream(err, true, "UTF-8")));
+        assertEquals(2, UnrelocatedTypes.run(new String[] {new File(classes, "none").getPath(), "javafx"},
+                new PrintStream(out, true, "UTF-8"), new PrintStream(err, true, "UTF-8")));
+    }
+}
diff --git a/maven/build-engine/src/test/resources/com/codename1/maven/desktop-port-report-clean.md b/maven/build-engine/src/test/resources/com/codename1/maven/desktop-port-report-clean.md
new file mode 100644
index 00000000000..2a9b1480bff
--- /dev/null
+++ b/maven/build-engine/src/test/resources/com/codename1/maven/desktop-port-report-clean.md
@@ -0,0 +1,33 @@
+# Desktop port report
+
+What it takes for this application to build and run as a Codename One application, from its compiled classes.
+
+## Summary
+
+- 2 application classes from 2 source files.
+- 7 of 7 call sites into Swing, AWT and JavaFX are supported (100%).
+- 2 source files have no finding; 0 have at least one.
+- The compliance check passes: every API the application and its libraries use is available on a device.
+
+## What works unchanged
+
+2 source files use only API that is available on a device:
+
+- `com/acme/port/Clean.java`
+- `com/acme/port/Main.java`
+
+## What to change
+
+Nothing in the application's own sources.
+
+## Dependencies
+
+| Dependency | What it is | Classes shipped | Verdict |
+|---|---|---:|---|
+| fancy-lib-1.0.jar | UI library | 1 of 1 | Works: bundled whole and relocated with the application. |
+| plain-lib-1.0.jar | pure Java | 1 of 1 | Works: the classes the application uses are relocated and pass the check. |
+| unused-lib-1.0.jar | pure Java | 0 of 1 | Not used by the application's classes; left out. |
+
+## What cannot run on a device
+
+Nothing was found that has no counterpart on a device.
diff --git a/maven/build-engine/src/test/resources/com/codename1/maven/desktop-port-report.md b/maven/build-engine/src/test/resources/com/codename1/maven/desktop-port-report.md
new file mode 100644
index 00000000000..b9771c5a383
--- /dev/null
+++ b/maven/build-engine/src/test/resources/com/codename1/maven/desktop-port-report.md
@@ -0,0 +1,56 @@
+# Desktop port report
+
+What it takes for this application to build and run as a Codename One application, from its compiled classes.
+
+## Summary
+
+- 4 application classes from 4 source files.
+- 7 of 11 call sites into Swing, AWT and JavaFX are supported (63%).
+- 2 source files have no finding; 2 have at least one.
+- The compliance check fails: 10 references to 7 APIs a device does not have (9 in the application, 1 in its libraries).
+
+| In the application | Missing APIs | Call sites |
+|---|---:|---:|
+| Swing, AWT and JavaFX API the compatibility layers lack | 2 | 2 |
+| JDK API a device lacks | 5 | 7 |
+
+## What works unchanged
+
+2 source files use only API that is available on a device:
+
+- `com/acme/port/Clean.java`
+- `com/acme/port/Main.java`
+
+## What to change
+
+### `com/acme/port/Git.java`
+
+- No equivalent: a device has no JMX.
+  - lines 4, 7: `java.lang.management.ManagementFactory.getRuntimeMXBean()`
+  - lines 4, 7: `java.lang.management.RuntimeMXBean.getName()`
+- Use com.codename1.io.Socket.connect(host, port, SocketConnection), or WebSocket for a message stream to a server.
+  - line 13: `java.net.Socket`
+  - line 13: `new java.net.Socket(java.lang.String, int)`
+- No JDBC on a device. Use the device's SQLite through Display.getInstance().openOrCreate(name), which answers a com.codename1.db.Database; a server database belongs behind a web service.
+  - line 10: `java.sql.DriverManager.getConnection(java.lang.String)`
+
+### `com/acme/port/Tray.java`
+
+- No equivalent in an application: a device does not let one synthesize input or read the screen. In a test use com.codename1.testing.TestUtils.
+  - line 5: `java.awt.Robot`
+- A device has no tray. What a tray icon announces is a LocalNotification (Display.scheduleLocalNotification).
+  - line 4: `java.awt.SystemTray`
+
+## Dependencies
+
+| Dependency | What it is | Classes shipped | Verdict |
+|---|---|---:|---|
+| fancy-lib-1.0.jar | UI library | 1 of 1 | 1 of 1 shipped classes use API a device lacks: management (1). Needs a device replacement, or an interface with a device implementation. |
+| plain-lib-1.0.jar | pure Java | 1 of 1 | Works: the classes the application uses are relocated and pass the check. |
+| unused-lib-1.0.jar | pure Java | 0 of 1 | Not used by the application's classes; left out. |
+
+## What cannot run on a device
+
+- `java.awt.Robot` (1 use in `com/acme/port/Tray.java`). No equivalent in an application: a device does not let one synthesize input or read the screen. In a test use com.codename1.testing.TestUtils.
+- `java.lang.management.ManagementFactory.getRuntimeMXBean()`, `java.lang.management.RuntimeMXBean.getName()` (4 uses in `com/acme/port/Git.java`). No equivalent: a device has no JMX.
+- `java.sql.DriverManager.getConnection(java.lang.String)` (1 use in `com/acme/port/Git.java`). No JDBC on a device. Use the device's SQLite through Display.getInstance().openOrCreate(name), which answers a com.codename1.db.Database; a server database belongs behind a web service.
diff --git a/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml b/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml
index eba76774886..5edfc3141ea 100644
--- a/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml
+++ b/maven/cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml
@@ -96,7 +96,7 @@
         <!-- Android compatibility: an Android application's AndroidManifest.xml,
              res/, assets/ and java/ placed in src/main/android build and run
              unchanged on every Codename One target. The compile-android-res
-             and remap-android goals below are no-ops without this directory. -->
+             and remap-compat goals below are no-ops without this directory. -->
         <profile>
             <id>android-compat</id>
             <activation>
@@ -112,6 +112,32 @@
                 </dependency>
             </dependencies>
         </profile>
+        <!-- Swing and JavaFX compatibility: a desktop application's java/,
+             kotlin/ and resources/ placed in src/main/desktop build and run
+             unchanged on every Codename One target. Both runtimes are on the
+             compile classpath; the remap-compat goal ships only the one the
+             sources actually use. The prepare-desktop-sources and remap-compat
+             goals below are no-ops without this directory. -->
+        <profile>
+            <id>desktop-compat</id>
+            <activation>
+                <file>
+                    <exists>${basedir}/src/main/desktop</exists>
+                </file>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>com.codenameone</groupId>
+                    <artifactId>codenameone-swing-compat</artifactId>
+                    <scope>provided</scope>
+                </dependency>
+                <dependency>
+                    <groupId>com.codenameone</groupId>
+                    <artifactId>codenameone-javafx-compat</artifactId>
+                    <scope>provided</scope>
+                </dependency>
+            </dependencies>
+        </profile>
         <!-- A profile to add kotlin support.  Activated if the src/main/kotlin
             directory exists -->
         <profile>
@@ -194,6 +220,10 @@
                                         <sourceDir>${project.basedir}/src/main/android/kotlin</sourceDir>
                                         <sourceDir>${project.basedir}/src/main/android/java</sourceDir>
                                         <sourceDir>${project.build.directory}/generated-sources/android</sourceDir>
+                                        <!-- Desktop sources (src/main/desktop): a Swing or JavaFX
+                                             application's Kotlin, and the Java it refers to. -->
+                                        <sourceDir>${project.basedir}/src/main/desktop/kotlin</sourceDir>
+                                        <sourceDir>${project.basedir}/src/main/desktop/java</sourceDir>
                                     </sourceDirs>
                                     <args>
                                         <arg>-no-reflect</arg>
@@ -403,6 +433,15 @@
                             <goal>compile-android-res</goal>
                         </goals>
                     </execution>
+                    <execution>
+                        <!-- Desktop sources (src/main/desktop): adds its java/
+                             and resources/ to the build. -->
+                        <id>prepare-desktop-sources</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>prepare-desktop-sources</goal>
+                        </goals>
+                    </execution>
                     <execution>
                         <id>generate-gui-sources</id>
                         <phase>process-sources</phase>
@@ -414,9 +453,10 @@
                         <id>cn1-process-classes</id>
                         <phase>process-classes</phase>
                         <goals>
-                            <!-- Relocates Android code onto the compatibility
-                                 runtime; must precede bytecode-compliance. -->
-                            <goal>remap-android</goal>
+                            <!-- Relocates Android, Swing and JavaFX code onto
+                                 the compatibility runtimes; must precede
+                                 bytecode-compliance. -->
+                            <goal>remap-compat</goal>
                             <goal>bytecode-compliance</goal>
                             <goal>css</goal>
                             <!-- Scans the project's compiled bytecode for
diff --git a/maven/cn1app-archetype/src/main/resources/archetype-resources/pom.xml b/maven/cn1app-archetype/src/main/resources/archetype-resources/pom.xml
index 09fc9a7006f..23926c0b864 100644
--- a/maven/cn1app-archetype/src/main/resources/archetype-resources/pom.xml
+++ b/maven/cn1app-archetype/src/main/resources/archetype-resources/pom.xml
@@ -66,6 +66,18 @@
                 <version>${cn1.version}</version>
                 <scope>provided</scope>
             </dependency>
+            <dependency>
+                <groupId>com.codenameone</groupId>
+                <artifactId>codenameone-swing-compat</artifactId>
+                <version>${cn1.version}</version>
+                <scope>provided</scope>
+            </dependency>
+            <dependency>
+                <groupId>com.codenameone</groupId>
+                <artifactId>codenameone-javafx-compat</artifactId>
+                <version>${cn1.version}</version>
+                <scope>provided</scope>
+            </dependency>
             <!--
               Optional desktop media binaries. BrowserComponent receives JCEF
               Maven transitively from codenameone-javase and downloads the native
diff --git a/maven/codenameone-gradle-plugin/spotbugs-exclude.xml b/maven/codenameone-gradle-plugin/spotbugs-exclude.xml
index 34455e20379..6ccba87df72 100644
--- a/maven/codenameone-gradle-plugin/spotbugs-exclude.xml
+++ b/maven/codenameone-gradle-plugin/spotbugs-exclude.xml
@@ -18,12 +18,31 @@
         <Or>
             <Class name="com.codename1.gradle.tasks.ComplianceAction"/>
             <Class name="com.codename1.gradle.tasks.ProcessAnnotationsAction"/>
-            <Class name="com.codename1.gradle.tasks.RemapAndroidAction"/>
+            <Class name="com.codename1.gradle.tasks.RemapCompatAction"/>
         </Or>
         <Method name="&lt;init&gt;"/>
         <Bug pattern="EI_EXPOSE_REP2"/>
         <Field name="compileClasspath"/>
     </Match>
+    <!-- javac's source files, the same kind of lazy, deliberately shared
+         FileCollection: whether the module has any Java source is only known
+         when the action runs, after the source generators have. -->
+    <Match>
+        <Class name="com.codename1.gradle.tasks.RemapCompatAction"/>
+        <Method name="shippingWhenEmpty"/>
+        <Bug pattern="EI_EXPOSE_REP2"/>
+        <Field name="shipWhenEmpty"/>
+    </Match>
+    <!-- The runtime classpath, the jars the application ships: lazy and shared
+         for the same reason. Resolving it when the action is configured would
+         resolve the configuration before the build script has finished
+         declaring its dependencies. -->
+    <Match>
+        <Class name="com.codename1.gradle.tasks.RemapCompatAction"/>
+        <Method name="withApplicationLibraries"/>
+        <Bug pattern="EI_EXPOSE_REP2"/>
+        <Field name="libraries"/>
+    </Match>
     <!-- The same lazy, deliberately shared FileCollections: the test compile's
          classpath, the main source set's class directories, and the other test
          compiler's output and sources, resolved only when the test pass runs. -->
@@ -53,10 +72,10 @@
                 <Method name="&lt;init&gt;"/>
                 <Field name="classesDirs"/>
             </And>
-            <!-- The directories RemapAndroidAction scans for onClick handlers: the
+            <!-- The directories RemapCompatAction scans for onClick handlers and layer references: the
                  same source-set view, Kotlin's output included once it exists. -->
             <And>
-                <Class name="com.codename1.gradle.tasks.RemapAndroidAction"/>
+                <Class name="com.codename1.gradle.tasks.RemapCompatAction"/>
                 <Method name="&lt;init&gt;"/>
                 <Field name="handlerDirs"/>
             </And>
diff --git a/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/AppSupport.java b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/AppSupport.java
index b5ffaa83345..59d51b92b29 100644
--- a/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/AppSupport.java
+++ b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/AppSupport.java
@@ -93,6 +93,17 @@ static void apply(final Project project, final ProjectLayout layout, final Coden
             // step copies the runtime itself into the application's classes.
             addFramework(project, "compileOnly", version, "codenameone-android-compat");
         }
+        // Swing and JavaFX compatibility: src/main/desktop existing is what
+        // enables the layers. Both jars, because the directory does not say
+        // which toolkit its sources use; the remap step ships only the
+        // runtime the compiled classes refer to. Swing code compiles against
+        // the JDK's own java.awt and javax.swing, JavaFX code against the
+        // javafx.* API in codenameone-javafx-compat.
+        final File desktopDir = layout.desktopSourceDir();
+        final boolean desktopProject = com.codename1.maven.DesktopSources.isDesktopProject(desktopDir);
+        if (desktopProject) {
+            addFramework(project, "compileOnly", version, "codenameone-swing-compat", "codenameone-javafx-compat");
+        }
         addFramework(project, "testImplementation", version, "codenameone-core", "codenameone-javase");
         Configuration framework = resolvable(project, "cn1Framework", "codenameone-core and java-runtime, for local builds");
         framework.setTransitive(false);
@@ -161,6 +172,54 @@ static void apply(final Project project, final ProjectLayout layout, final Coden
         main.getResources().srcDir(androidRes.flatMap(
                 com.codename1.gradle.tasks.CompileAndroidResTask::getResourcesDirectory));
 
+        // The desktop sources, laid out like a desktop project's src/main.
+        // Declared always, like the Android directories: Gradle is happy with
+        // a directory that does not exist.
+        //
+        // The build-time style sheet compile step of the JavaFX layer,
+        // registered the way compileAndroidRes is above. Its outputs are
+        // source and resource roots of `main`, so compileJava and
+        // processResources depend on it without being told. The FXML
+        // documents are not compiled by it but by compileJava's
+        // cn1RemapCompat action, once the application's classes exist; the
+        // one source this task writes holds their digest, so a changed
+        // document reruns compileJava. The Maven build's counterpart, with
+        // the full contract, is
+        // PrepareDesktopSourcesMojo.compileDesktopResources.
+        final File desktopResources = com.codename1.maven.DesktopSources.resourcesDir(desktopDir).getAbsoluteFile();
+        TaskProvider<com.codename1.gradle.tasks.CompileDesktopResourcesTask> desktopRes = project.getTasks().register(
+                "compileDesktopResources", com.codename1.gradle.tasks.CompileDesktopResourcesTask.class, t -> {
+                    common(t, project, layout, ext, userProperties);
+                    t.setDescription("Compiles the FXML documents and style sheets of src/main/desktop/resources");
+                    t.getSources().from(project.fileTree(desktopResources,
+                            tree -> tree.include("**/*.fxml", "**/*.css")));
+                    t.getResourcesRoot().set(desktopResources);
+                    t.getCompileClasspath().from(project.getConfigurations().getByName("compileClasspath"));
+                    t.getOutputDirectory().set(new File(layout.buildDir(), "generated/sources/cn1-desktop"));
+                    t.getResourcesDirectory().set(new File(layout.buildDir(), "generated/resources/cn1-desktop"));
+                });
+        main.getJava().srcDir(desktopRes.flatMap(
+                com.codename1.gradle.tasks.CompileDesktopResourcesTask::getOutputDirectory));
+        main.getResources().srcDir(desktopRes.flatMap(
+                com.codename1.gradle.tasks.CompileDesktopResourcesTask::getResourcesDirectory));
+        main.getJava().srcDir(com.codename1.maven.DesktopSources.javaDir(desktopDir));
+        main.getResources().srcDir(desktopResources);
+        // A device bundle has no directories, so the relocation step ships a
+        // nested desktop resource under a flat name, written into the classes
+        // directory from the source file. Maven's resources land in that same
+        // directory and the step removes the nested copy there; Gradle's land
+        // in a directory of their own, which the step never sees, so the
+        // nested copy shipped a second time under a name nothing reads. It is
+        // left out here instead: a directory of the desktop resource root is
+        // not copied, and the files at the root, which keep their names, are.
+        // The filter is the source set's, so it holds for whatever reads the
+        // resources; it matches nothing outside that one root.
+        main.getResources().exclude(new NestedDesktopResources(desktopResources));
+        // The same holds for what compileDesktopResources generates: a compiled
+        // style sheet sits beside the path of its source, and ships flat too.
+        main.getResources().exclude(new NestedDesktopResources(
+                new File(layout.buildDir(), "generated/resources/cn1-desktop").getAbsoluteFile()));
+
         TaskProvider<Cn1CssTask> css = project.getTasks().register("cn1Css", Cn1CssTask.class, t -> {
             common(t, project, layout, ext, userProperties);
             t.setDescription("Compiles src/main/css into theme.res");
@@ -202,21 +261,45 @@ static void apply(final Project project, final ProjectLayout layout, final Coden
         if (skip != null) {
             complianceProperties.put("skipComplianceCheck", String.valueOf(skip));
         }
+        // Where a desktop application's port report goes, as Maven's
+        // -Dcn1.desktop.report names it; given with -P or -D.
+        Object report = project.findProperty(com.codename1.maven.DesktopPortReport.PROPERTY);
+        if (report == null) {
+            report = project.getProviders().systemProperty(com.codename1.maven.DesktopPortReport.PROPERTY)
+                    .getOrNull();
+        }
+        if (report != null) {
+            complianceProperties.put(com.codename1.maven.DesktopPortReport.PROPERTY, String.valueOf(report));
+        }
         // The two post-compile steps depend on more than the sources: hot reload
         // compiles with -PskipComplianceCheck=true, and the codename1.* overrides
         // reach the annotation processors. As inputs, a change in either reruns the
         // compile -- otherwise a native build after a hot-reload compile found
         // compileJava up to date and uploaded classes nobody had checked.
         final String skipInput = String.valueOf(skip);
+        // The same for where the port report goes: asked for somewhere new,
+        // it has to be written there, which only a compile that runs does.
+        final String reportInput = String.valueOf(report);
         project.getTasks().named(main.getCompileJavaTaskName(), JavaCompile.class, compile -> {
-            if (androidProject) {
+            if (androidProject || desktopProject) {
                 // Relocation rewrites this task's output descriptors. A source edit
                 // must compile all Java sources against the original Android API,
                 // never against unchanged, relocated classes from the last build.
                 // Unchanged builds still use Gradle's task up-to-date checks.
                 compile.getOptions().setIncremental(false);
             }
+            if (desktopProject) {
+                // Which desktop runtime ships is read from the compiled classes,
+                // Kotlin's included, by an action of this task -- and a Kotlin
+                // edit that leaves its ABI alone leaves this task up to date.
+                // The toolkits the sources name are therefore an input: the
+                // first Kotlin line to use JavaFX reruns this task, and the
+                // action ships the runtime.
+                compile.getInputs().property("cn1DesktopToolkits", project.provider(
+                        () -> com.codename1.maven.DesktopSources.toolkitsNamedIn(desktopDir)));
+            }
             compile.getInputs().property("cn1SkipComplianceCheck", skipInput);
+            compile.getInputs().property("cn1DesktopReport", reportInput);
             processingInputs(compile, layout, userProperties);
             Provider<List<String>> roots = project.provider(() -> sourceRoots(main, layout));
             // Compliance first (it caps and rewrites classes in place), then the
@@ -224,12 +307,21 @@ static void apply(final Project project, final ProjectLayout layout, final Coden
             // poms bind process-classes in.
             // Kotlin's classes (compiled first, into a directory of their own) are
             // the Java pass's siblings, so Java calling Kotlin resolves.
-            // Android code is relocated onto the compatibility runtime before
-            // the compliance check sees it, as remap-android precedes
-            // bytecode-compliance in the Maven build.
-            compile.doLast("cn1RemapAndroid", new com.codename1.gradle.tasks.RemapAndroidAction(
+            // Android, Swing and JavaFX code is relocated onto the
+            // compatibility runtimes before the compliance check sees it, as
+            // remap-compat precedes bytecode-compliance in the Maven build.
+            // For Swing no other order works: its names resolve against
+            // nothing until they are relocated.
+            compile.doLast("cn1RemapCompat", new com.codename1.gradle.tasks.RemapCompatAction(
                     compile.getDestinationDirectory().getAsFile().get(), main.getCompileClasspath(),
-                    onClickNamesFile(androidState), false, main.getOutput().getClassesDirs()));
+                    onClickNamesFile(androidState), false, main.getOutput().getClassesDirs())
+                    .withDesktopSourceDirectory(desktopDir)
+                    // The FXML documents are compiled by this action, first:
+                    // after javac, so that a document can name a class of
+                    // the application, and before the relocation.
+                    .withFxmlSourceDirectory(new File(layout.buildDir(), "generated/cn1-fxml"))
+                    .withApplicationLibraries(desktopProject ? main.getRuntimeClasspath().filter(
+                            f -> f.getName().endsWith(".jar")) : null));
             compile.doLast("cn1Compliance", new com.codename1.gradle.tasks.ComplianceAction(layout.rootDir(),
                     layout.projectDir(), compile.getDestinationDirectory().getAsFile(), project.getName(),
                     main.getCompileClasspath(), compileArtifacts, complianceProperties)
@@ -268,6 +360,8 @@ static void apply(final Project project, final ProjectLayout layout, final Coden
             Object kotlinSources = ((org.gradle.api.plugins.ExtensionAware) main).getExtensions().findByName("kotlin");
             if (kotlinSources instanceof org.gradle.api.file.SourceDirectorySet) {
                 ((org.gradle.api.file.SourceDirectorySet) kotlinSources).srcDir(new File(androidDir, "kotlin"));
+                ((org.gradle.api.file.SourceDirectorySet) kotlinSources).srcDir(
+                        com.codename1.maven.DesktopSources.kotlinDir(desktopDir));
             }
             // Kotlin's classes are relocated after javac rather than right after
             // Kotlin compiles: they are javac's classpath, and Java calling a
@@ -281,24 +375,56 @@ static void apply(final Project project, final ProjectLayout layout, final Coden
             // SourceSet, so the action must not reach the classpath through one.
             final org.gradle.api.file.FileCollection compileClasspath = main.getCompileClasspath();
             final File onClickNames = onClickNamesFile(androidState);
+            // A module with desktop sources may have no Java source at all,
+            // and then javac's pass, which ships the runtimes, never runs:
+            // Kotlin's directory ships them instead. An Android module always
+            // has Java (its generated R classes), so nothing changes for it.
+            final org.gradle.api.file.FileCollection javaSources = desktopProject ? main.getJava().getAsFileTree() : null;
+            // That pass is then the whole of javac's, so it is handed what
+            // javac's is: the jars the application ships, which are unpacked
+            // and relocated with it, and the directory its FXML is compiled
+            // into. Left out, a Kotlin-only application shipped classes
+            // naming a library that was never bundled. Both are ignored
+            // while this action only relocates.
+            final org.gradle.api.file.FileCollection shippedJars = !desktopProject ? null
+                    : main.getRuntimeClasspath().filter(f -> f.getName().endsWith(".jar"));
+            final File fxmlSources = new File(layout.buildDir(), "generated/cn1-fxml");
+            // The Swing layer's classes exist only under their relocated
+            // names, so Kotlin's classes cannot be checked as Kotlin wrote
+            // them (see the compileKotlin actions below): for a module with
+            // desktop sources the check runs here instead, after relocation.
+            final com.codename1.gradle.tasks.ComplianceAction kotlinCompliance = !desktopProject ? null
+                    : new com.codename1.gradle.tasks.ComplianceAction(layout.rootDir(), layout.projectDir(),
+                            kotlinDir, project.getName(), compileClasspath, compileArtifacts, complianceProperties)
+                            .withBuildDirectory(project.getLayout().getBuildDirectory().getAsFile())
+                            .withSiblingClasses(main.getOutput().getClassesDirs());
             registerKotlinRelocation(project.getTasks(), main.getCompileJavaTaskName(), main.getClassesTaskName(),
-                    t -> new com.codename1.gradle.tasks.RemapAndroidAction(
-                            kotlinDir.get(), compileClasspath, onClickNames, true, null).execute(t));
+                    kotlinRelocation(t -> new com.codename1.gradle.tasks.RemapCompatAction(
+                            kotlinDir.get(), compileClasspath, onClickNames, true, null)
+                            .withDesktopSourceDirectory(desktopDir)
+                            .withFxmlSourceDirectory(fxmlSources).withApplicationLibraries(shippedJars)
+                            .shippingWhenEmpty(javaSources).execute(t),
+                            kotlinCompliance));
         });
         project.getPluginManager().withPlugin("org.jetbrains.kotlin.jvm", kotlin ->
                 project.getTasks().named("compileKotlin").configure(compile -> {
                     compile.getInputs().property("cn1SkipComplianceCheck", skipInput);
+                    compile.getInputs().property("cn1DesktopReport", reportInput);
                     processingInputs(compile, layout, userProperties);
                     Provider<File> kotlinClasses = kotlinDestinationProvider(compile, layout);
                     Provider<List<String>> roots = project.provider(() -> sourceRoots(main, layout));
                     // Kotlin's classes are relocated after javac (see below), not
                     // here; this check accepts their unrelocated names, which the
-                    // compatibility jar provides.
-                    compile.doLast("cn1Compliance", new com.codename1.gradle.tasks.ComplianceAction(
-                            layout.rootDir(), layout.projectDir(), kotlinClasses, project.getName(),
-                            main.getCompileClasspath(), compileArtifacts, complianceProperties)
-                            .withBuildDirectory(project.getLayout().getBuildDirectory().getAsFile())
-                            .withPendingJavaSources(main.getJava().getSrcDirs()));
+                    // compatibility jar provides. The Swing jar provides none --
+                    // it is written under the relocated names -- so a module with
+                    // desktop sources is checked by the relocation task instead.
+                    if (!desktopProject) {
+                        compile.doLast("cn1Compliance", new com.codename1.gradle.tasks.ComplianceAction(
+                                layout.rootDir(), layout.projectDir(), kotlinClasses, project.getName(),
+                                main.getCompileClasspath(), compileArtifacts, complianceProperties)
+                                .withBuildDirectory(project.getLayout().getBuildDirectory().getAsFile())
+                                .withPendingJavaSources(main.getJava().getSrcDirs()));
+                    }
                     compile.doLast("processCn1Annotations", new ProcessAnnotationsAction(kotlinClasses,
                             stubsDir(layout),
                             layout.projectDir(), layout.settingsFile(), roots, "UTF-8", userProperties,
@@ -720,7 +846,7 @@ static Configuration resolvable(Project project, String name, String description
     static TaskProvider<org.gradle.api.Task> registerKotlinRelocation(org.gradle.api.tasks.TaskContainer tasks,
             String compileJavaName, String classesName, org.gradle.api.Action<? super org.gradle.api.Task> remap) {
         TaskProvider<org.gradle.api.Task> relocate = tasks.register("cn1RemapAndroidKotlin", t -> {
-            t.setDescription("Relocates Android references in Kotlin's classes onto the compatibility runtime");
+            t.setDescription("Relocates Kotlin's classes onto the compatibility runtimes");
             t.dependsOn("compileKotlin");
             t.mustRunAfter(compileJavaName);
             t.doLast(remap);
@@ -730,6 +856,21 @@ static TaskProvider<org.gradle.api.Task> registerKotlinRelocation(org.gradle.api
         return relocate;
     }
 
+    /// What the Kotlin relocation task does: relocates Kotlin's classes, then,
+    /// when `compliance` is given, checks them. In that order, which is the
+    /// only one the Swing layer allows -- its API exists nowhere under the
+    /// names an application is compiled against.
+    static org.gradle.api.Action<org.gradle.api.Task> kotlinRelocation(
+            final org.gradle.api.Action<? super org.gradle.api.Task> remap,
+            final org.gradle.api.Action<? super org.gradle.api.Task> compliance) {
+        return t -> {
+            remap.execute(t);
+            if (compliance != null) {
+                compliance.execute(t);
+            }
+        };
+    }
+
     static Provider<File> kotlinDestinationProvider(final org.gradle.api.Task compile, final ProjectLayout layout) {
         try {
             Object dir = compile.getClass().getMethod("getDestinationDirectory").invoke(compile);
@@ -902,4 +1043,27 @@ public Iterable<String> asArguments() {
         }
     }
 
+    /// Matches the directories directly inside the desktop resource root, so
+    /// that the main resources leave everything nested in it alone: those
+    /// resources ship under flat names the relocation step writes. A class of
+    /// its own rather than a lambda so that the configuration cache can store
+    /// it.
+    static final class NestedDesktopResources
+            implements org.gradle.api.specs.Spec<org.gradle.api.file.FileTreeElement>, java.io.Serializable {
+        private static final long serialVersionUID = 1L;
+        private final File root;
+
+        NestedDesktopResources(File root) {
+            this.root = root;
+        }
+
+        @Override
+        public boolean isSatisfiedBy(org.gradle.api.file.FileTreeElement element) {
+            if (!element.isDirectory()) {
+                return false;
+            }
+            File parent = element.getFile().getAbsoluteFile().getParentFile();
+            return root.equals(parent);
+        }
+    }
 }
diff --git a/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/CompileDesktopResourcesTask.java b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/CompileDesktopResourcesTask.java
new file mode 100644
index 00000000000..548f7fac89d
--- /dev/null
+++ b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/CompileDesktopResourcesTask.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.gradle.tasks;
+
+import com.codename1.fxml.DesktopResourceCompiler;
+import com.codename1.maven.CompatLayers;
+import org.gradle.api.GradleException;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.tasks.CacheableTask;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.InputFiles;
+import org.gradle.api.tasks.Internal;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.PathSensitive;
+import org.gradle.api.tasks.PathSensitivity;
+import org.gradle.api.tasks.SkipWhenEmpty;
+import org.gradle.api.tasks.TaskAction;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// Compiles the style sheets of `src/main/desktop/resources` for the JavaFX
+/// compatibility layer, each into the binary table the layer's style engine
+/// reads, and writes the one Java source that stands for its FXML documents.
+/// The same [DesktopResourceCompiler] as the Maven plugin's
+/// `prepare-desktop-sources` goal.
+///
+/// The documents themselves are compiled by an action of `compileJava`
+/// (`cn1RemapCompat`, see [RemapCompatAction]), once javac has compiled the
+/// application: a document may name one of its classes, a custom control.
+/// The source written here is an input of `compileJava` and holds a digest
+/// of the documents, so editing only a document reruns that task and its
+/// actions.
+///
+/// A document or a sheet the compiler rejects fails the task with every
+/// error it found, each as `file:line:column: message`; what it only warns
+/// about is logged.
+@CacheableTask
+public abstract class CompileDesktopResourcesTask extends Cn1Task {
+
+    /// The `**/*.fxml` and `**/*.css` files under the desktop resources.
+    /// The task is skipped when there are none.
+    ///
+    /// Skipped is not "left as it was": when the last source goes, Gradle
+    /// itself deletes what the task wrote on its previous run into the two
+    /// output directories before reporting `NO-SOURCE`, so no stale
+    /// `FxmlDocuments.java` or `.cn1css` is left for the build to pick up.
+    /// The compiler's own cleanup is for the Maven goal, which has no such
+    /// bookkeeping.
+    @InputFiles
+    @SkipWhenEmpty
+    @PathSensitive(PathSensitivity.RELATIVE)
+    public abstract ConfigurableFileCollection getSources();
+
+    /// The directory the sources are in, which their resource paths are
+    /// relative to. Not an input of its own: [#getSources()] is what is
+    /// read from it.
+    @Internal
+    public abstract DirectoryProperty getResourcesRoot();
+
+    /// The application's compile class path, where the classes the
+    /// documents name are read from.
+    @Classpath
+    public abstract ConfigurableFileCollection getCompileClasspath();
+
+    /// The generated Java sources.
+    @OutputDirectory
+    public abstract DirectoryProperty getOutputDirectory();
+
+    /// The compiled style sheets.
+    @OutputDirectory
+    public abstract DirectoryProperty getResourcesDirectory();
+
+    @TaskAction
+    public void compile() {
+        List<File> classpath = new ArrayList<File>(getCompileClasspath().getFiles());
+        File root = getResourcesRoot().get().getAsFile();
+        DesktopResourceCompiler compiler = new DesktopResourceCompiler(Collections.singletonList(root),
+                getOutputDirectory().get().getAsFile(), getResourcesDirectory().get().getAsFile(),
+                new DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                        getLogger().lifecycle(message);
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                        getLogger().warn(message);
+                    }
+                });
+        List<String> errors;
+        try {
+            if (CompatLayers.runtimeJar(CompatLayers.JAVAFX, classpath) == null) {
+                getLogger().debug("The JavaFX layer is not on the class path; no FXML or style sheet is compiled");
+                // What an earlier build compiled names the JavaFX API and
+                // is still on the source path; it has to go with the layer.
+                compiler.clear();
+                return;
+            }
+            errors = compiler.run();
+        } catch (IOException ex) {
+            throw new GradleException("Could not compile the FXML documents and style sheets of " + root + ": "
+                    + ex.getMessage(), ex);
+        }
+        if (!errors.isEmpty()) {
+            StringBuilder all = new StringBuilder();
+            for (String error : errors) {
+                all.append('\n').append(error);
+            }
+            throw new GradleException(errors.size() + " error(s) in the FXML documents and style sheets of " + root
+                    + ":" + all);
+        }
+    }
+}
diff --git a/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/RemapAndroidAction.java b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/RemapAndroidAction.java
deleted file mode 100644
index 1d6ed0e5c4b..00000000000
--- a/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/RemapAndroidAction.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.gradle.tasks;
-
-import com.codename1.build.Log;
-import com.codename1.builders.BuildException;
-import com.codename1.gradle.GradleLog;
-import com.codename1.maven.AndroidRemapper;
-import org.gradle.api.Action;
-import org.gradle.api.GradleException;
-import org.gradle.api.Task;
-import org.gradle.api.file.FileCollection;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-/// Relocates Android code in a compiled class directory onto the
-/// compatibility runtime; see [AndroidRemapper]. Attached to the compile task
-/// before the compliance check, as the Maven build binds `remap-android`
-/// before `bytecode-compliance`.
-public class RemapAndroidAction implements Action<Task> {
-
-    private final File classesDir;
-    private final FileCollection compileClasspath;
-    private final File onClickNames;
-    private final boolean relocateOnly;
-    private final FileCollection handlerDirs;
-
-    public RemapAndroidAction(File classesDir, FileCollection compileClasspath, File onClickNames,
-                              boolean relocateOnly, FileCollection handlerDirs) {
-        this.classesDir = classesDir;
-        this.compileClasspath = compileClasspath;
-        this.onClickNames = onClickNames;
-        this.relocateOnly = relocateOnly;
-        this.handlerDirs = handlerDirs;
-    }
-
-    @Override
-    public void execute(Task task) {
-        File jar = null;
-        for (File f : compileClasspath.getFiles()) {
-            if (f.getName().startsWith(com.codename1.maven.AndroidResourceRunner.COMPAT_ARTIFACT + "-")
-                    && f.getName().endsWith(".jar")) {
-                jar = f;
-            }
-        }
-        if (jar == null || !classesDir.isDirectory()) {
-            return;
-        }
-        Log log = new GradleLog(task.getLogger());
-        AndroidRemapper r = new AndroidRemapper(classesDir, jar, onClickNames, log);
-        if (relocateOnly) {
-            r.relocateOnly();
-        } else if (handlerDirs != null) {
-            List<File> dirs = new ArrayList<File>(handlerDirs.getFiles());
-            r.withHandlerDirectories(dirs);
-        }
-        try {
-            r.run();
-        } catch (BuildException ex) {
-            throw new GradleException(ex.getMessage(), ex.getCause() == null ? ex : ex.getCause());
-        }
-    }
-}
diff --git a/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/RemapCompatAction.java b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/RemapCompatAction.java
new file mode 100644
index 00000000000..81a973828d1
--- /dev/null
+++ b/maven/codenameone-gradle-plugin/src/main/java/com/codename1/gradle/tasks/RemapCompatAction.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.gradle.tasks;
+
+import com.codename1.build.Log;
+import com.codename1.builders.BuildException;
+import com.codename1.gradle.GradleLog;
+import com.codename1.maven.CompatLayers;
+import com.codename1.maven.CompatRemapper;
+import org.gradle.api.Action;
+import org.gradle.api.GradleException;
+import org.gradle.api.Task;
+import org.gradle.api.file.FileCollection;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+/// Relocates a compiled class directory onto whichever compatibility layers
+/// the application has switched on -- Android, Swing, JavaFX -- and ships
+/// their runtimes; see [CompatRemapper]. Attached to the compile task before
+/// the compliance check, as the Maven build binds `remap-compat` before
+/// `bytecode-compliance`.
+///
+/// For an application with only Android sources it does what the Android
+/// step alone does, file for file; `CompatRemapperTest` holds that.
+public class RemapCompatAction implements Action<Task> {
+
+    private final File classesDir;
+    private final FileCollection compileClasspath;
+    private final File onClickNames;
+    private final boolean relocateOnly;
+    private final FileCollection handlerDirs;
+    private File desktopDir;
+    private FileCollection shipWhenEmpty;
+    private FileCollection libraries;
+    private File fxmlSources;
+
+    public RemapCompatAction(File classesDir, FileCollection compileClasspath, File onClickNames,
+                             boolean relocateOnly, FileCollection handlerDirs) {
+        this.classesDir = classesDir;
+        this.compileClasspath = compileClasspath;
+        this.onClickNames = onClickNames;
+        this.relocateOnly = relocateOnly;
+        this.handlerDirs = handlerDirs;
+    }
+
+    /// The module's desktop source directory (`src/main/desktop`), whose
+    /// `resources` the desktop runtime indexes. The application's main
+    /// class is a source file of the project and is relocated like any other
+    /// class; nothing here generates one.
+    public RemapCompatAction withDesktopSourceDirectory(File dir) {
+        this.desktopDir = dir;
+        return this;
+    }
+
+    /// The jars the application ships (`runtimeClasspath`), as opposed to
+    /// those it is only compiled against (`compileOnly`). The ones written
+    /// against Swing or JavaFX are unpacked into the classes directory and
+    /// relocated with the application.
+    public RemapCompatAction withApplicationLibraries(FileCollection jars) {
+        this.libraries = jars;
+        return this;
+    }
+
+    /// Where the Java generated from the application's FXML documents is
+    /// kept. The documents are compiled by this action, before it relocates
+    /// anything: javac has just compiled the application, so a document can
+    /// name one of its classes, and Kotlin's classes -- compiled earlier, into
+    /// a directory among the handler directories -- are still as Kotlin
+    /// wrote them. See [com.codename1.fxml.FxmlClassCompiler].
+    public RemapCompatAction withFxmlSourceDirectory(File dir) {
+        this.fxmlSources = dir;
+        return this;
+    }
+
+    /// Makes a relocate-only action a full one when `javaSources` turns out
+    /// to be empty. Kotlin's directory is relocated only, because javac's
+    /// pass ships the runtimes and generates what has to be generated -- but
+    /// `compileJava` does nothing at all for a module with no Java source,
+    /// and then this directory is the only one there is to ship them in.
+    public RemapCompatAction shippingWhenEmpty(FileCollection javaSources) {
+        this.shipWhenEmpty = javaSources;
+        return this;
+    }
+
+    @Override
+    public void execute(Task task) {
+        Set<File> classpath = compileClasspath.getFiles();
+        // By the jars alone, as the first test: with none there is nothing to
+        // read the classes for.
+        if (CompatLayers.active(classpath).isEmpty() || !classesDir.isDirectory()) {
+            return;
+        }
+        Log log = new GradleLog(task.getLogger());
+        CompatRemapper r = new CompatRemapper(classesDir, classpath, onClickNames, log)
+                .withDesktopSourceDirectory(desktopDir)
+                .withFxmlSourceDirectory(fxmlSources);
+        if (libraries != null) {
+            List<File> jars = new ArrayList<File>();
+            for (File f : libraries.getFiles()) {
+                if (f.isFile() && f.getName().endsWith(".jar")) {
+                    jars.add(f);
+                }
+            }
+            r.withApplicationLibraries(jars);
+        }
+        if (relocateOnly && !(shipWhenEmpty != null && shipWhenEmpty.isEmpty())) {
+            r.relocateOnly();
+        } else if (handlerDirs != null) {
+            List<File> dirs = new ArrayList<File>(handlerDirs.getFiles());
+            r.withHandlerDirectories(dirs);
+        }
+        try {
+            r.run();
+        } catch (BuildException ex) {
+            throw new GradleException(ex.getMessage(), ex.getCause() == null ? ex : ex.getCause());
+        }
+    }
+}
diff --git a/maven/codenameone-gradle-plugin/src/test/java/com/codename1/gradle/KotlinRelocationWiringTest.java b/maven/codenameone-gradle-plugin/src/test/java/com/codename1/gradle/KotlinRelocationWiringTest.java
index fe6a89cd941..183c6cbf6db 100644
--- a/maven/codenameone-gradle-plugin/src/test/java/com/codename1/gradle/KotlinRelocationWiringTest.java
+++ b/maven/codenameone-gradle-plugin/src/test/java/com/codename1/gradle/KotlinRelocationWiringTest.java
@@ -158,4 +158,38 @@ void kotlinIsRelocatedByATaskThatDoesNotDependOnJavacRunning() {
         assertTrue(recorded.get("classes").dependsOn.contains(relocate),
                 "every Codename One task depends on classes, so it waits for relocation");
     }
+
+    /// The Swing runtime is written under the names it ships with, so
+    /// Kotlin's classes can only be checked once they are relocated. The
+    /// relocation task then does both, in that order, and a module that
+    /// checks Kotlin where it is compiled passes no check here at all.
+    @Test
+    void complianceFollowsRelocationInTheSameTask() {
+        final List<String> ran = new ArrayList<String>();
+        Action<Task> remap = t -> ran.add("remap");
+        Action<Task> compliance = t -> ran.add("compliance");
+
+        AppSupport.kotlinRelocation(remap, compliance).execute(task("cn1RemapAndroidKotlin"));
+        assertEquals(Arrays.asList("remap", "compliance"), ran);
+
+        ran.clear();
+        AppSupport.kotlinRelocation(remap, null).execute(task("cn1RemapAndroidKotlin"));
+        assertEquals(Arrays.asList("remap"), ran);
+    }
+
+    /// A failed relocation leaves classes the check would misreport.
+    @Test
+    void aFailedRelocationSkipsTheCheck() {
+        final List<String> ran = new ArrayList<String>();
+        Action<Task> remap = t -> {
+            throw new IllegalStateException("remap");
+        };
+        Action<Task> compliance = t -> ran.add("compliance");
+        try {
+            AppSupport.kotlinRelocation(remap, compliance).execute(task("cn1RemapAndroidKotlin"));
+            throw new AssertionError("the failure must reach Gradle");
+        } catch (IllegalStateException expected) {
+            assertTrue(ran.isEmpty());
+        }
+    }
 }
diff --git a/maven/codenameone-maven-plugin/pom.xml b/maven/codenameone-maven-plugin/pom.xml
index a1ada47b0ab..0dac23abcd9 100644
--- a/maven/codenameone-maven-plugin/pom.xml
+++ b/maven/codenameone-maven-plugin/pom.xml
@@ -290,6 +290,22 @@
             <scope>provided</scope>
             <optional>true</optional>
         </dependency>
+        <!-- The same for the desktop layers: remap-compat ships these
+             runtimes inside an application with src/main/desktop. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-swing-compat</artifactId>
+            <version>${project.version}</version>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-javafx-compat</artifactId>
+            <version>${project.version}</version>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
 
         <dependency>
             <groupId>com.codenameone</groupId>
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/AndroidPomUpdater.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/AndroidPomUpdater.java
index 27a576ea4aa..0b418ff680a 100644
--- a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/AndroidPomUpdater.java
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/AndroidPomUpdater.java
@@ -22,17 +22,16 @@
  */
 package com.codename1.maven;
 
-import java.util.ArrayList;
 import java.util.List;
 
 /// Wires Android compatibility into an existing application's common
 /// `pom.xml`, the way a new project from the archetype already is: the
-/// runtime dependency, `compile-android-res`, and `remap-android` ahead of
+/// runtime dependency, `compile-android-res`, and the remap goal ahead of
 /// `bytecode-compliance` (which must see the relocated classes).
 ///
 /// The pom is edited as text, at anchors every archetype-generated common pom
-/// has; a pom without them is reported with the snippets to add by hand
-/// rather than guessed at.
+/// has ([PomWiring]); a pom without them is reported with the snippets to add
+/// by hand rather than guessed at.
 final class AndroidPomUpdater {
 
     static final String PROFILE = "        <!-- Android compatibility, added by cn1:import-android-project. -->\n"
@@ -61,64 +60,33 @@ final class AndroidPomUpdater {
             + "                        </goals>\n"
             + "                    </execution>\n";
 
-    static final String REMAP_GOAL = "<goal>remap-android</goal>";
-    private static final String COMPLIANCE_GOAL = "<goal>bytecode-compliance</goal>";
-    private static final String PLUGIN = "<artifactId>codenameone-maven-plugin</artifactId>";
+    /// The goal a pom without one receives; one that binds the goal under its
+    /// earlier name, `remap-android`, is already wired.
+    static final String REMAP_GOAL = PomWiring.REMAP_GOAL;
 
     /// The updated pom, or the same text when it is already wired.
     final String pom;
     /// What could not be added automatically, each with the XML to add.
-    final List<String> manual = new ArrayList<String>();
-    boolean changed;
+    final List<String> manual;
+    final boolean changed;
 
     AndroidPomUpdater(String pom, boolean kotlin) {
-        String p = pom;
-        if (p.indexOf("<artifactId>codenameone-android-compat</artifactId>") < 0) {
-            int profiles = p.lastIndexOf("</profiles>");
-            if (profiles < 0) {
-                manual.add("the codenameone-android-compat dependency (scope provided), e.g. as this profile:\n" + PROFILE);
-            } else {
-                int lineStart = p.lastIndexOf('\n', profiles) + 1;
-                p = p.substring(0, lineStart) + PROFILE + p.substring(lineStart);
-                changed = true;
-            }
+        PomWiring w = new PomWiring(pom);
+        if (!w.has("<artifactId>codenameone-android-compat</artifactId>")) {
+            w.addProfile("the codenameone-android-compat dependency (scope provided), e.g. as this profile:\n"
+                    + PROFILE, PROFILE);
         }
-        if (p.indexOf("<goal>compile-android-res</goal>") < 0) {
-            int plugin = p.indexOf(PLUGIN);
-            // Only this plugin's own executions block: a later plugin's would
-            // otherwise receive a goal it does not have.
-            int pluginEnd = plugin < 0 ? -1 : p.indexOf("</plugin>", plugin);
-            int executions = pluginEnd < 0 ? -1 : p.indexOf("<executions>", plugin);
-            if (executions > pluginEnd) {
-                executions = -1;
-            }
-            if (executions < 0) {
-                manual.add("an execution of compile-android-res in the codenameone-maven-plugin:\n" + EXECUTION);
-            } else {
-                int at = executions + "<executions>".length();
-                p = p.substring(0, at) + "\n" + EXECUTION.substring(0, EXECUTION.length() - 1) + p.substring(at);
-                changed = true;
-            }
-        }
-        if (p.indexOf(REMAP_GOAL) < 0) {
-            int compliance = p.indexOf(COMPLIANCE_GOAL);
-            if (compliance < 0 || p.indexOf(COMPLIANCE_GOAL, compliance + 1) >= 0) {
-                manual.add("the remap-android goal, in the process-classes execution, before bytecode-compliance:\n"
-                        + "    " + REMAP_GOAL + "\n");
-            } else {
-                int lineStart = p.lastIndexOf('\n', compliance) + 1;
-                String indent = p.substring(lineStart, compliance);
-                p = p.substring(0, compliance) + REMAP_GOAL + "\n" + indent + p.substring(compliance);
-                changed = true;
-            }
-        }
-        if (kotlin && p.indexOf("src/main/android/java</sourceDir>") < 0) {
-            manual.add("the Android source directories in the Kotlin profile's compile execution, which must also "
+        w.addExecution("compile-android-res", EXECUTION);
+        w.addRemapGoal();
+        if (kotlin && !w.has("src/main/android/java</sourceDir>")) {
+            w.manual.add("the Android source directories in the Kotlin profile's compile execution, which must also "
                     + "run in the process-resources phase so it precedes javac:\n"
                     + "    <sourceDir>${project.basedir}/src/main/android/kotlin</sourceDir>\n"
                     + "    <sourceDir>${project.basedir}/src/main/android/java</sourceDir>\n"
                     + "    <sourceDir>${project.build.directory}/generated-sources/android</sourceDir>\n");
         }
-        this.pom = p;
+        this.pom = w.pom;
+        this.manual = w.manual;
+        this.changed = w.changed;
     }
 }
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/BytecodeComplianceMojo.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/BytecodeComplianceMojo.java
index 68370a32e01..f128a278362 100644
--- a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/BytecodeComplianceMojo.java
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/BytecodeComplianceMojo.java
@@ -26,6 +26,7 @@
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
 import org.apache.maven.plugins.annotations.ResolutionScope;
 
 import java.io.IOException;
@@ -37,6 +38,13 @@
 @Mojo(name = "bytecode-compliance", defaultPhase = LifecyclePhase.PROCESS_CLASSES, requiresDependencyResolution = ResolutionScope.TEST)
 public class BytecodeComplianceMojo extends AbstractCN1Mojo {
 
+    /// Where the port report of a desktop application is written: what works
+    /// unchanged, what to change by source file, and what becomes of each
+    /// dependency. Written whether the check passes or fails; the default is
+    /// `target/codenameone/desktop-port-report.md`.
+    @Parameter(property = "cn1.desktop.report")
+    private java.io.File desktopReport;
+
     @Override
     protected void executeImpl() throws MojoExecutionException, MojoFailureException {
         if (!isCN1ProjectDir()) {
@@ -54,6 +62,7 @@ protected void beforeCheck() {
                 copyKotlinIncrementalCompileOutputToOutputDir();
             }
         };
+        check.portReport(desktopReport);
         try {
             check.execute();
         } catch (com.codename1.build.BuildFailureException ex) {
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/DesktopPomUpdater.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/DesktopPomUpdater.java
new file mode 100644
index 00000000000..49146cacc2f
--- /dev/null
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/DesktopPomUpdater.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// Wires the desktop compatibility layers into an existing application's
+/// common `pom.xml`, the way a new project from the archetype already is: the
+/// two runtime dependencies, `prepare-desktop-sources`, and the remap goal
+/// ahead of `bytecode-compliance` (which must see the relocated classes).
+///
+/// Edited as text at the anchors every archetype-generated common pom has,
+/// exactly as [AndroidPomUpdater] does and through the same code
+/// ([PomWiring]); a pom without them is reported with the snippets to add by
+/// hand rather than guessed at.
+final class DesktopPomUpdater {
+
+    static final String PROFILE = "        <!-- Swing and JavaFX compatibility, added by cn1:import-desktop-project. -->\n"
+            + "        <profile>\n"
+            + "            <id>desktop-compat</id>\n"
+            + "            <activation>\n"
+            + "                <file>\n"
+            + "                    <exists>${basedir}/src/main/desktop</exists>\n"
+            + "                </file>\n"
+            + "            </activation>\n"
+            + "            <dependencies>\n"
+            + "                <dependency>\n"
+            + "                    <groupId>com.codenameone</groupId>\n"
+            + "                    <artifactId>codenameone-swing-compat</artifactId>\n"
+            + "                    <version>${cn1.version}</version>\n"
+            + "                    <scope>provided</scope>\n"
+            + "                </dependency>\n"
+            + "                <dependency>\n"
+            + "                    <groupId>com.codenameone</groupId>\n"
+            + "                    <artifactId>codenameone-javafx-compat</artifactId>\n"
+            + "                    <version>${cn1.version}</version>\n"
+            + "                    <scope>provided</scope>\n"
+            + "                </dependency>\n"
+            + "            </dependencies>\n"
+            + "        </profile>\n";
+
+    static final String EXECUTION = "                    <execution>\n"
+            + "                        <id>prepare-desktop-sources</id>\n"
+            + "                        <phase>generate-sources</phase>\n"
+            + "                        <goals>\n"
+            + "                            <goal>prepare-desktop-sources</goal>\n"
+            + "                        </goals>\n"
+            + "                    </execution>\n";
+
+    /// The updated pom, or the same text when it is already wired.
+    final String pom;
+    /// What could not be added automatically, each with the XML to add.
+    final List<String> manual;
+    final boolean changed;
+
+    /// The libraries this update declared, as `group:artifact:version (scope)`.
+    final List<String> addedLibraries = new ArrayList<String>();
+
+    DesktopPomUpdater(String pom, boolean kotlin) {
+        this(pom, kotlin, null);
+    }
+
+    /// As [#DesktopPomUpdater(String, boolean)], also declaring `libraries`:
+    /// the dependencies of the imported project its sources are compiled
+    /// against ([DesktopProjectImporter.Library]). One whose version the
+    /// project's build does not spell out is left for the developer, since a
+    /// guessed version is worse than a compile error naming the package.
+    DesktopPomUpdater(String pom, boolean kotlin, List<DesktopProjectImporter.Library> libraries) {
+        PomWiring w = new PomWiring(pom);
+        if (libraries != null) {
+            for (DesktopProjectImporter.Library lib : libraries) {
+                if (lib.version == null) {
+                    continue;
+                }
+                String scope = lib.provided ? "provided" : "compile";
+                String note = lib.provided
+                        ? "compiled against; the Swing compatibility layer ships its own implementation"
+                        : "bundled and relocated with the application";
+                String xml = "        <!-- From the imported desktop project: " + note + ". -->\n"
+                        + "        <dependency>\n"
+                        + "            <groupId>" + lib.groupId + "</groupId>\n"
+                        + "            <artifactId>" + lib.artifactId + "</artifactId>\n"
+                        + "            <version>" + lib.version + "</version>\n"
+                        + "            <scope>" + scope + "</scope>\n"
+                        + "        </dependency>\n";
+                if (w.addDependency(lib.groupId, lib.artifactId, xml)) {
+                    addedLibraries.add(lib.coordinate() + ":" + lib.version + " (" + scope + ")");
+                }
+            }
+        }
+        // Either jar says the profile is there; a pom carrying only one was
+        // edited by hand and is left as its author wrote it.
+        if (!w.has("<artifactId>codenameone-swing-compat</artifactId>")
+                && !w.has("<artifactId>codenameone-javafx-compat</artifactId>")) {
+            w.addProfile("the codenameone-swing-compat and codenameone-javafx-compat dependencies (scope provided), "
+                    + "e.g. as this profile:\n" + PROFILE, PROFILE);
+        }
+        w.addExecution("prepare-desktop-sources", EXECUTION);
+        w.addRemapGoal();
+        if (kotlin && !w.has("src/main/desktop/java</sourceDir>")) {
+            w.manual.add("the desktop source directories in the Kotlin profile's compile execution, which must also "
+                    + "run in the process-resources phase so it precedes javac:\n"
+                    + "    <sourceDir>${project.basedir}/src/main/desktop/kotlin</sourceDir>\n"
+                    + "    <sourceDir>${project.basedir}/src/main/desktop/java</sourceDir>\n");
+        }
+        this.pom = w.pom;
+        this.manual = w.manual;
+        this.changed = w.changed;
+    }
+}
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/ImportDesktopProjectMojo.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/ImportDesktopProjectMojo.java
new file mode 100644
index 00000000000..768acea8fb1
--- /dev/null
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/ImportDesktopProjectMojo.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+
+import java.io.File;
+
+/// Imports a Swing or JavaFX project into this Codename One application.
+///
+/// ```
+/// mvn cn1:import-desktop-project -Dcn1.desktop.import=/path/to/MyDesktopApp
+///     [-Dcn1.desktop.module=app] [-Dcn1.desktop.mainClass=com.example.Main]
+///     [-Dcn1.desktop.library=true]
+/// ```
+///
+/// Copies the project's (or the named module's) `src/main/java`,
+/// `src/main/kotlin` and `src/main/resources` into
+/// `common/src/main/desktop`, writes the application's Codename One main
+/// class (`codename1.packageName`.`codename1.mainName`, in
+/// `common/src/main/java`) so that it starts the imported application, and
+/// lists what becomes of the project's dependencies. The main class is an
+/// ordinary source file, the application's own from then on. With
+/// `cn1.desktop.library` the main class is left alone and the desktop
+/// classes are a library the application's own code uses. Build and run as
+/// usual afterwards.
+/// See [DesktopProjectImporter].
+@Mojo(name = "import-desktop-project", requiresProject = true, aggregator = true)
+public class ImportDesktopProjectMojo extends AbstractCN1Mojo {
+
+    /// A Maven or Gradle desktop project, or one module of it.
+    @Parameter(property = "cn1.desktop.import", required = true)
+    private File source;
+
+    /// The module to import, for a project whose root has no sources and
+    /// more than one module that does.
+    @Parameter(property = "cn1.desktop.module")
+    private String module;
+
+    /// The class the application starts through, when the sources and the
+    /// project's build leave more than one to choose from.
+    @Parameter(property = "cn1.desktop.mainClass")
+    private String mainClass;
+
+    /// Imports the sources as a library: the application's main class is not
+    /// written, and the application starts as it did.
+    @Parameter(property = "cn1.desktop.library", defaultValue = "false")
+    private boolean library;
+
+    @Override
+    protected void executeImpl() throws MojoExecutionException, MojoFailureException {
+        File common = getCN1ProjectDir();
+        if (common == null) {
+            throw new MojoExecutionException("Run this from a Codename One application project");
+        }
+        DesktopProjectImporter.Result r;
+        String declared;
+        // The POM is wired first, since a POM that cannot be wired is a
+        // reason to import nothing. An import that then fails -- several
+        // entry points and none chosen -- has imported nothing either, so
+        // the POM goes back to what it was.
+        File pomFile = new File(common, "pom.xml");
+        byte[] original = readOrNull(pomFile);
+        boolean imported = false;
+        try {
+            declared = wireDesktopCompat(common, DesktopProjectImporter.moduleDir(source, module));
+            r = new DesktopProjectImporter(MavenLog.of(getLog())).importProject(source, module, common, mainClass,
+                    properties == null ? null : properties.getProperty("codename1.packageName"),
+                    properties == null ? null : properties.getProperty("codename1.mainName"), library);
+            imported = true;
+        } catch (com.codename1.builders.BuildException e) {
+            throw new MojoFailureException(e.getMessage(), e);
+        } finally {
+            if (!imported) {
+                restore(pomFile, original);
+            }
+        }
+        getLog().info("Imported " + r.copiedFiles + " files into " + new File(common, "src/main/desktop"));
+        if (r.mainClass != null) {
+            getLog().info("The application starts through " + r.mainClass + " (" + r.kind + ")");
+        }
+        for (String dropped : r.droppedModuleInfo) {
+            getLog().info("  left out: " + dropped + " (a Codename One application is not a Java module)");
+        }
+        for (String c : r.covered) {
+            getLog().info("  supported: " + c);
+        }
+        if (r.generatedMain != null) {
+            getLog().info("Wrote this application's main class, " + r.generatedMain + " (" + r.mainSource
+                    + "), to start it on every target" + (r.setAside == null ? ""
+                    : "; the previous source is kept as " + r.setAside.getName()));
+        } else if (r.library) {
+            getLog().info("Imported as a library: the application's main class was left as it is");
+        }
+        for (String u : r.uncovered) {
+            if (DesktopProjectImporter.isToolkitModule(u)) {
+                getLog().warn("  NOT implemented by the desktop compatibility layers: " + u
+                        + ". Code that uses it is reported at build time.");
+                continue;
+            }
+            if (declares(declared, u)) {
+                // The table below says what becomes of it.
+                continue;
+            }
+            getLog().warn("  not part of the desktop compatibility layers: " + u + ". Add it to the common "
+                    + "module's dependencies (scope compile); it is then "
+                    + DesktopProjectImporter.BUNDLED_NOTE + ".");
+        }
+        for (DesktopProjectImporter.Library lib : r.libraries) {
+            if (lib.provided && !declares(declared, lib.coordinate())) {
+                getLog().warn("  " + lib.coordinate() + " is what the imported sources are compiled against, and "
+                        + "the project's build does not spell out its version. Add it to the common module's "
+                        + "dependencies (scope provided).");
+            }
+        }
+        for (String u : r.unresolved) {
+            getLog().warn("  " + u);
+        }
+        reportDependencies(r, common);
+        String level = DesktopImportReport.javaLevelWarning(r.javaLevel);
+        if (level != null) {
+            getLog().warn(level);
+        }
+    }
+
+    private static byte[] readOrNull(File file) {
+        try {
+            return file.isFile() ? java.nio.file.Files.readAllBytes(file.toPath()) : null;
+        } catch (java.io.IOException e) {
+            return null;
+        }
+    }
+
+    /// Writes `original` back to `file` if the file has changed since it
+    /// was read.
+    private void restore(File file, byte[] original) {
+        if (original == null) {
+            return;
+        }
+        try {
+            if (!java.util.Arrays.equals(original, java.nio.file.Files.readAllBytes(file.toPath()))) {
+                java.nio.file.Files.write(file.toPath(), original);
+                getLog().info("Restored " + file + ": nothing was imported");
+            }
+        } catch (java.io.IOException e) {
+            getLog().warn("Could not restore " + file + ": " + e.getMessage());
+        }
+    }
+
+    /// Prints what the build will do with each jar the project depends on,
+    /// its own dependencies included: [DesktopImportReport]. A dependency
+    /// whose jar cannot be had -- no version in the build file, or nothing to
+    /// download it from -- is named and left to the build, which classifies
+    /// it the same way.
+    private void reportDependencies(DesktopProjectImporter.Result r, File common) {
+        java.util.Set<File> jars = new java.util.LinkedHashSet<File>();
+        for (DesktopProjectImporter.Library lib : r.libraries) {
+            if (lib.version == null) {
+                continue;
+            }
+            int before = jars.size();
+            try {
+                org.apache.maven.artifact.Artifact artifact = repositorySystem.createArtifact(lib.groupId,
+                        lib.artifactId, lib.version, "jar");
+                org.apache.maven.artifact.resolver.ArtifactResolutionResult result = repositorySystem.resolve(
+                        new org.apache.maven.artifact.resolver.ArtifactResolutionRequest()
+                                .setOffline(offline)
+                                .setLocalRepository(localRepository)
+                                .setRemoteRepositories(
+                                        new java.util.ArrayList<org.apache.maven.artifact.repository.ArtifactRepository>(
+                                                remoteRepositories))
+                                .setResolveTransitively(true)
+                                .setArtifact(artifact));
+                addJar(jars, artifact);
+                if (result != null && result.getArtifacts() != null) {
+                    java.util.List<org.apache.maven.artifact.Artifact> resolved =
+                            new java.util.ArrayList<org.apache.maven.artifact.Artifact>(result.getArtifacts());
+                    java.util.Collections.sort(resolved);
+                    for (org.apache.maven.artifact.Artifact a : resolved) {
+                        if (!"test".equals(a.getScope())) {
+                            addJar(jars, a);
+                        }
+                    }
+                }
+            } catch (RuntimeException e) {
+                getLog().debug("Could not resolve " + lib.coordinate(), e);
+            }
+            if (jars.size() == before) {
+                getLog().info("  " + lib.coordinate() + " could not be read here; at build time "
+                        + DesktopProjectImporter.BUNDLED_NOTE + ".");
+            }
+        }
+        if (jars.isEmpty()) {
+            return;
+        }
+        try {
+            java.util.List<DesktopImportReport.Row> rows = DesktopImportReport.rows(jars,
+                    new File(common, "src/main/desktop"));
+            getLog().info("What the build does with the project's dependencies (" + rows.size() + " jars, "
+                    + "their own dependencies included):");
+            for (String line : DesktopImportReport.table(rows)) {
+                getLog().info("  " + line);
+            }
+        } catch (java.io.IOException e) {
+            getLog().warn("Could not read the project's dependencies: " + e.getMessage());
+        }
+    }
+
+    private static void addJar(java.util.Set<File> jars, org.apache.maven.artifact.Artifact a) {
+        File f = a.getFile();
+        if (f != null && f.isFile() && f.getName().endsWith(".jar")) {
+            jars.add(f);
+        }
+    }
+
+    /// A project generated before the desktop layers existed has none of
+    /// their wiring, and the imported sources would not build. Adds it to the
+    /// common pom, or stops before copying anything, naming what to add.
+    ///
+    /// The libraries the project is compiled against are declared in the same
+    /// edit ([DesktopProjectImporter.Library]): an import that leaves sources
+    /// which cannot compile has not imported the project. Answers the pom as
+    /// it is afterwards.
+    private String wireDesktopCompat(File common, File moduleDir)
+            throws MojoExecutionException, MojoFailureException, com.codename1.builders.BuildException {
+        File pomFile = new File(common, "pom.xml");
+        String pom;
+        try {
+            pom = new String(java.nio.file.Files.readAllBytes(pomFile.toPath()), "UTF-8");
+        } catch (java.io.IOException e) {
+            throw new MojoExecutionException("Cannot read " + pomFile, e);
+        }
+        DesktopPomUpdater u = new DesktopPomUpdater(pom, hasKotlin(new File(moduleDir, "src/main")),
+                DesktopProjectImporter.librariesOf(moduleDir));
+        if (!u.manual.isEmpty()) {
+            StringBuilder sb = new StringBuilder("Nothing was imported: " + pomFile
+                    + " needs the desktop compatibility layers wired in by hand. Add:\n");
+            for (String m : u.manual) {
+                sb.append("\n- ").append(m);
+            }
+            throw new MojoFailureException(sb.toString());
+        }
+        if (u.changed) {
+            try {
+                java.nio.file.Files.write(pomFile.toPath(), u.pom.getBytes("UTF-8"));
+            } catch (java.io.IOException e) {
+                throw new MojoExecutionException("Cannot write " + pomFile, e);
+            }
+            getLog().info("Updated " + pomFile + " for the desktop compatibility layers");
+            for (String lib : u.addedLibraries) {
+                getLog().info("  added the dependency " + lib);
+            }
+        }
+        return u.pom;
+    }
+
+    /// Whether `pom` declares `coordinate` (`group:artifact`), by its
+    /// artifact: the same test the update itself applies.
+    private static boolean declares(String pom, String coordinate) {
+        return pom.indexOf("<artifactId>" + coordinate.substring(coordinate.indexOf(':') + 1) + "</artifactId>") >= 0;
+    }
+
+    private static boolean hasKotlin(File dir) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return false;
+        }
+        for (File f : files) {
+            if (f.isDirectory() ? hasKotlin(f) : f.getName().endsWith(".kt")) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/PomWiring.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/PomWiring.java
new file mode 100644
index 00000000000..ab2c1bb5339
--- /dev/null
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/PomWiring.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// The text edits that wire a compatibility layer into an application's
+/// common `pom.xml`, shared by [AndroidPomUpdater] and [DesktopPomUpdater].
+///
+/// The pom is edited as text, at anchors every archetype-generated common pom
+/// has, so its comments and formatting survive; where an anchor is missing
+/// nothing is guessed, and the snippet to add by hand is recorded instead.
+final class PomWiring {
+
+    /// The goal that relocates every active layer, and the name it had while
+    /// Android was the only one. Either in a pom means the step is bound.
+    static final String REMAP_GOAL = "<goal>remap-compat</goal>";
+    static final String LEGACY_REMAP_GOAL = "<goal>remap-android</goal>";
+    private static final String COMPLIANCE_GOAL = "<goal>bytecode-compliance</goal>";
+    private static final String PLUGIN = "<artifactId>codenameone-maven-plugin</artifactId>";
+
+    /// The pom as edited so far.
+    String pom;
+    /// What could not be added automatically, each with the XML to add.
+    final List<String> manual = new ArrayList<String>();
+    boolean changed;
+
+    PomWiring(String pom) {
+        this.pom = pom;
+    }
+
+    boolean has(String text) {
+        return pom.indexOf(text) >= 0;
+    }
+
+    /// Adds `profile` as the last of the pom's profiles; `manualText` is what
+    /// to report when the pom has no `<profiles>` to add it to.
+    void addProfile(String manualText, String profile) {
+        int profiles = pom.lastIndexOf("</profiles>");
+        if (profiles < 0) {
+            manual.add(manualText);
+        } else {
+            int lineStart = pom.lastIndexOf('\n', profiles) + 1;
+            pom = pom.substring(0, lineStart) + profile + pom.substring(lineStart);
+            changed = true;
+        }
+    }
+
+    /// Adds `dependency` as the last of the module's own dependencies, unless
+    /// that list holds `groupId:artifactId` already; answers whether it was
+    /// added. The module's own are the `<dependencies>` that precede every
+    /// section which may hold another list -- managed versions, the build's
+    /// plugins, the profiles -- which is where an archetype-generated common
+    /// pom has them.
+    ///
+    /// Only that list counts. The same artifact under
+    /// `<dependencyManagement>`, as a plugin's dependency, or under another
+    /// group does not put it on the module's compile class path, and taking
+    /// it for present left the imported sources without their library and
+    /// reported nothing to do.
+    boolean addDependency(String groupId, String artifactId, String dependency) {
+        int limit = pom.length();
+        for (String section : new String[] {"<dependencyManagement>", "<build>", "<profiles>"}) {
+            int at = pom.indexOf(section);
+            if (at >= 0 && at < limit) {
+                limit = at;
+            }
+        }
+        int open = pom.indexOf("<dependencies>");
+        int close = open < 0 ? -1 : pom.indexOf("</dependencies>", open);
+        if (open < 0 || open > limit || close < 0 || close > limit) {
+            manual.add("the dependency the imported sources are compiled against, in the module's own "
+                    + "<dependencies>:\n" + dependency);
+            return false;
+        }
+        String group = "<groupId>" + groupId + "</groupId>";
+        String artifact = "<artifactId>" + artifactId + "</artifactId>";
+        int at = open;
+        while (true) {
+            int start = pom.indexOf("<dependency>", at);
+            int end = start < 0 || start > close ? -1 : pom.indexOf("</dependency>", start);
+            if (end < 0 || end > close) {
+                break;
+            }
+            String declared = pom.substring(start, end);
+            if (declared.indexOf(group) >= 0 && declared.indexOf(artifact) >= 0) {
+                return false;
+            }
+            at = end;
+        }
+        int lineStart = pom.lastIndexOf('\n', close) + 1;
+        pom = pom.substring(0, lineStart) + dependency + pom.substring(lineStart);
+        changed = true;
+        return true;
+    }
+
+    /// Adds `execution` to the Codename One plugin's executions unless some
+    /// execution already runs `goal`.
+    void addExecution(String goal, String execution) {
+        if (has("<goal>" + goal + "</goal>")) {
+            return;
+        }
+        int plugin = pom.indexOf(PLUGIN);
+        // Only this plugin's own executions block: a later plugin's would
+        // otherwise receive a goal it does not have.
+        int pluginEnd = plugin < 0 ? -1 : pom.indexOf("</plugin>", plugin);
+        int executions = pluginEnd < 0 ? -1 : pom.indexOf("<executions>", plugin);
+        if (executions > pluginEnd) {
+            executions = -1;
+        }
+        if (executions < 0) {
+            manual.add("an execution of " + goal + " in the codenameone-maven-plugin:\n" + execution);
+        } else {
+            int at = executions + "<executions>".length();
+            pom = pom.substring(0, at) + "\n" + execution.substring(0, execution.length() - 1) + pom.substring(at);
+            changed = true;
+        }
+    }
+
+    /// Binds the remap goal immediately before `bytecode-compliance`, unless
+    /// the pom already binds it under either of its names.
+    void addRemapGoal() {
+        if (has(REMAP_GOAL) || has(LEGACY_REMAP_GOAL)) {
+            return;
+        }
+        int compliance = pom.indexOf(COMPLIANCE_GOAL);
+        if (compliance < 0 || pom.indexOf(COMPLIANCE_GOAL, compliance + 1) >= 0) {
+            manual.add("the remap-compat goal, in the process-classes execution, before bytecode-compliance:\n"
+                    + "    " + REMAP_GOAL + "\n");
+        } else {
+            int lineStart = pom.lastIndexOf('\n', compliance) + 1;
+            String indent = pom.substring(lineStart, compliance);
+            pom = pom.substring(0, compliance) + REMAP_GOAL + "\n" + indent + pom.substring(compliance);
+            changed = true;
+        }
+    }
+}
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/PrepareDesktopSourcesMojo.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/PrepareDesktopSourcesMojo.java
new file mode 100644
index 00000000000..8f32963bc54
--- /dev/null
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/PrepareDesktopSourcesMojo.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.model.Resource;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.plugins.annotations.ResolutionScope;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/// Brings the desktop sources of an application module into its build:
+/// `src/main/desktop`, holding a Swing or JavaFX application as its own
+/// project laid it out (see [DesktopSources]).
+///
+/// Adds `src/main/desktop/java` as a compile source root and
+/// `src/main/desktop/resources` as a resource root, so the sources compile
+/// unchanged -- Swing code against the JDK's own `java.awt` and `javax.swing`,
+/// JavaFX code against `codenameone-javafx-compat` -- and the resources reach
+/// the classes directory under the names the code loads them by. A silent
+/// no-op for a project without `src/main/desktop`. See `remap-compat` for the
+/// step that follows compilation.
+@Mojo(name = "prepare-desktop-sources", defaultPhase = LifecyclePhase.GENERATE_SOURCES,
+        requiresDependencyResolution = ResolutionScope.COMPILE)
+public class PrepareDesktopSourcesMojo extends AbstractCN1Mojo {
+
+    @Parameter(property = "cn1.desktop.sourceDir", defaultValue = "${project.basedir}/src/main/desktop")
+    private File desktopSourceDir;
+
+    /// Where a build-time compile step writes Java sources; a compile source
+    /// root once it exists.
+    @Parameter(property = "cn1.desktop.outputDir", defaultValue = "${project.build.directory}/generated-sources/desktop")
+    private File desktopOutputDir;
+
+    /// Where a build-time compile step writes classpath resources; a resource
+    /// root once it exists.
+    @Parameter(property = "cn1.desktop.resourcesOutputDir",
+            defaultValue = "${project.build.directory}/generated-resources/desktop")
+    private File desktopResourcesOutputDir;
+
+    @Override
+    protected void executeImpl() throws MojoExecutionException, MojoFailureException {
+        if (!DesktopSources.isDesktopProject(desktopSourceDir)) {
+            return;
+        }
+        List<String> artifactIds = new ArrayList<String>();
+        List<File> classpath = new ArrayList<File>();
+        for (Artifact a : project.getArtifacts()) {
+            artifactIds.add(a.getArtifactId());
+            if (a.getFile() != null) {
+                classpath.add(a.getFile());
+            }
+        }
+        try {
+            DesktopSources.requireRuntime(desktopSourceDir, artifactIds);
+        } catch (com.codename1.builders.BuildException ex) {
+            throw new MojoFailureException(ex.getMessage(), ex);
+        }
+        // The last build relocated the classes in the output directory, and
+        // javac compiles against that directory: a Kotlin class the
+        // incremental compiler does not recompile would be seen relocated, so
+        // the Java code calling it would not compile. Its unrelocated original
+        // is in Kotlin's own output tree; put it back before anything compiles.
+        copyKotlinIncrementalCompileOutputToOutputDir(true);
+        File javaDir = DesktopSources.javaDir(desktopSourceDir);
+        if (javaDir.isDirectory()) {
+            registerSourceRoot(javaDir);
+        }
+        File resourcesDir = DesktopSources.resourcesDir(desktopSourceDir);
+        if (resourcesDir.isDirectory()) {
+            registerResourceRoot(resourcesDir);
+        }
+        compileDesktopResources(desktopSourceDir, resourcesDir, classpath, desktopOutputDir, desktopResourcesOutputDir);
+        if (desktopOutputDir.isDirectory()) {
+            registerSourceRoot(desktopOutputDir);
+        }
+        if (desktopResourcesOutputDir.isDirectory()) {
+            registerResourceRoot(desktopResourcesOutputDir);
+        }
+    }
+
+    /// The build-time style sheet compile step of the JavaFX layer, and the
+    /// first half of its FXML one: [com.codename1.fxml.DesktopResourceCompiler].
+    ///
+    /// A device has no XML parser to spare and no reflection, so what a
+    /// desktop JavaFX runtime does when it loads an `.fxml` document or a
+    /// stylesheet -- parse it, look the controller class and its `fx:id`
+    /// fields and `#handler` methods up by name -- has to happen while
+    /// building, the way `compile-android-res` turns Android's XML into
+    /// generated classes and a binary table. The compiler itself lives in its
+    /// own module; this method is the one place the Maven build calls it.
+    ///
+    /// Called once per build, in `generate-sources`, only for a project with
+    /// desktop sources, after its source and resource roots are registered
+    /// and before anything compiles.
+    ///
+    /// - `desktopDir`: `src/main/desktop`.
+    /// - `resourcesDir`: `src/main/desktop/resources`, the documents to
+    ///   compile (`**/*.fxml`, `**/*.css`); it may not exist.
+    /// - `classpath`: the module's resolved compile classpath, which holds
+    ///   `codenameone-javafx-compat` when the JavaFX layer is available.
+    /// - `javaOut`: where the generated Java source is written. The
+    ///   directory is registered as a source root right after this returns,
+    ///   if it exists.
+    /// - `resourcesOut`: where the compiled style sheets are written;
+    ///   registered as a resource root the same way.
+    ///
+    /// #### Where the FXML documents are compiled
+    ///
+    /// Not here. A document may name a class of the application -- a custom
+    /// control is one -- and in `generate-sources` no such class exists. The
+    /// documents are compiled in `process-classes`, by `remap-compat` as the
+    /// first thing it does: after javac (and Kotlin, which this lifecycle
+    /// compiles earlier still), and before the relocation, because the Java
+    /// generated from a document names the JavaFX API as an application does
+    /// and is compiled, by a second in-process javac run, against the
+    /// application's classes as javac left them.
+    ///
+    /// This step writes the one source that keeps that sound,
+    /// `FxmlDocuments.java`: it holds a digest of the documents, so editing
+    /// only a document changes a source and the compiler plugin recompiles
+    /// the module instead of leaving last build's relocated classes in place.
+    ///
+    /// Neither directory is touched when its inputs have not changed, so an
+    /// unchanged build recompiles nothing.
+    ///
+    /// A document that is not well formed or a sheet the compiler rejects
+    /// fails the build with every error it found, each as
+    /// `file:line:column: message`; what it only warns about -- a style
+    /// property this layer does not have -- is logged.
+    ///
+    /// The Gradle build runs the same compiler as a task with declared inputs
+    /// and outputs; see `CompileDesktopResourcesTask` in the Gradle plugin.
+    protected void compileDesktopResources(File desktopDir, File resourcesDir, List<File> classpath, File javaOut,
+                                           File resourcesOut) throws MojoExecutionException, MojoFailureException {
+        com.codename1.fxml.DesktopResourceCompiler compiler = new com.codename1.fxml.DesktopResourceCompiler(
+                java.util.Collections.singletonList(resourcesDir), javaOut, resourcesOut,
+                new com.codename1.fxml.DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                        getLog().info(message);
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                        getLog().warn(message);
+                    }
+                });
+        List<String> errors;
+        try {
+            if (CompatLayers.runtimeJar(CompatLayers.JAVAFX, classpath) == null) {
+                getLog().debug("The JavaFX layer is not on the class path; no FXML or style sheet is compiled");
+                // What an earlier build compiled names the JavaFX API and
+                // is still on the source path; it has to go with the layer.
+                compiler.clear();
+                return;
+            }
+            errors = compiler.run();
+        } catch (java.io.IOException e) {
+            throw new MojoExecutionException("Could not compile the FXML documents and style sheets of "
+                    + resourcesDir + ": " + e.getMessage(), e);
+        }
+        if (!errors.isEmpty()) {
+            StringBuilder all = new StringBuilder();
+            for (String error : errors) {
+                getLog().error(error);
+                all.append(all.length() == 0 ? "" : "\n").append(error);
+            }
+            throw new MojoFailureException(errors.size() + " error(s) in the FXML documents and style sheets of "
+                    + resourcesDir + ":\n" + all);
+        }
+    }
+
+    private void registerResourceRoot(File dir) {
+        String path = dir.getAbsolutePath();
+        for (Resource r : project.getResources()) {
+            if (r.getDirectory() != null && new File(r.getDirectory()).getAbsolutePath().equals(path)) {
+                return;
+            }
+        }
+        Resource r = new Resource();
+        r.setDirectory(path);
+        project.addResource(r);
+        getLog().debug("Added resource root " + path);
+    }
+}
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapAndroidMojo.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapAndroidMojo.java
index 6ad50d6c2ce..e06a8b899c7 100644
--- a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapAndroidMojo.java
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapAndroidMojo.java
@@ -22,41 +22,15 @@
  */
 package com.codename1.maven;
 
-import org.apache.maven.plugin.MojoExecutionException;
-import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
 import org.apache.maven.plugins.annotations.ResolutionScope;
 
-import java.io.File;
-
-/// Relocates the compiled Android code onto the compatibility runtime and
-/// ships the runtime with the application; see [AndroidRemapper]. Must run in
-/// `process-classes` before `bytecode-compliance`, which then checks the
-/// relocated runtime along with the application. A no-op for a project that
-/// does not depend on `codenameone-android-compat`.
+/// The name `remap-compat` had when Android was the only compatibility layer.
+/// It is the same goal: the poms of existing projects bind `remap-android`,
+/// and through it they relocate every layer the project switches on, without
+/// being edited. See [RemapCompatMojo].
 @Mojo(name = "remap-android", defaultPhase = LifecyclePhase.PROCESS_CLASSES,
-        requiresDependencyResolution = ResolutionScope.COMPILE)
-public class RemapAndroidMojo extends AbstractCN1Mojo {
-
-    @Override
-    protected void executeImpl() throws MojoExecutionException, MojoFailureException {
-        File jar = CompileAndroidResMojo.compatJar(project.getArtifacts());
-        if (jar == null) {
-            return;
-        }
-        File classes = new File(project.getBuild().getOutputDirectory());
-        if (!classes.isDirectory()) {
-            return;
-        }
-        // Freshly compiled Kotlin (incremental compilation keeps its own
-        // output tree) must be in place before it is relocated.
-        copyKotlinIncrementalCompileOutputToOutputDir();
-        File onClick = AndroidResourceRunner.onClickNamesFile(new File(project.getBuild().getDirectory()));
-        try {
-            new AndroidRemapper(classes, jar, onClick, MavenLog.of(getLog())).run();
-        } catch (com.codename1.builders.BuildException ex) {
-            throw new MojoFailureException(ex.getMessage(), ex);
-        }
-    }
+        requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME)
+public class RemapAndroidMojo extends RemapCompatMojo {
 }
diff --git a/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapCompatMojo.java b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapCompatMojo.java
new file mode 100644
index 00000000000..8bb07967ac1
--- /dev/null
+++ b/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/RemapCompatMojo.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.plugins.annotations.ResolutionScope;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/// Relocates the compiled application onto whichever compatibility layers it
+/// has switched on -- Android, Swing, JavaFX, in any mix -- and ships their
+/// runtimes with it; see [CompatRemapper]. Must run in `process-classes`
+/// before `bytecode-compliance`, which then checks the relocated runtimes
+/// along with the application. For the Swing layer that order is the only one
+/// that works at all: its application code is compiled against the JDK's own
+/// `javax.swing`, and nothing the check could resolve those names against
+/// exists until they have been relocated.
+///
+/// A no-op for a project that depends on none of the layers' runtimes, so it
+/// is bound unconditionally.
+@Mojo(name = "remap-compat", defaultPhase = LifecyclePhase.PROCESS_CLASSES,
+        requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME)
+public class RemapCompatMojo extends AbstractCN1Mojo {
+
+    @Parameter(property = "cn1.desktop.sourceDir", defaultValue = "${project.basedir}/src/main/desktop")
+    private File desktopSourceDir;
+
+    /// Where `prepare-desktop-sources` writes the resources it generates
+    /// from the desktop sources; they are flattened and indexed with the
+    /// application's own.
+    @Parameter(property = "cn1.desktop.resourcesOutputDir",
+            defaultValue = "${project.build.directory}/generated-resources/desktop")
+    private File desktopResourcesOutputDir;
+
+    @Override
+    protected void executeImpl() throws MojoExecutionException, MojoFailureException {
+        List<File> classpath = new ArrayList<File>();
+        // What the application ships, as opposed to what it is only compiled
+        // against: of these, the ones written against Swing or JavaFX are
+        // relocated with it. A provided jar never is.
+        List<File> libraries = new ArrayList<File>();
+        for (Artifact artifact : project.getArtifacts()) {
+            if (artifact.getFile() != null) {
+                classpath.add(artifact.getFile());
+                if (ships(artifact.getScope(), artifact.getType(), artifact.getGroupId())) {
+                    libraries.add(artifact.getFile());
+                }
+            }
+        }
+        // By the jars alone: whether a desktop layer is also used can only be
+        // read from the classes, and Kotlin's are not all in place yet.
+        if (CompatLayers.active(classpath).isEmpty()) {
+            return;
+        }
+        File classes = new File(project.getBuild().getOutputDirectory());
+        if (!classes.isDirectory()) {
+            return;
+        }
+        // Freshly compiled Kotlin (incremental compilation keeps its own
+        // output tree) must be in place before it is relocated.
+        copyKotlinIncrementalCompileOutputToOutputDir();
+        File onClick = AndroidResourceRunner.onClickNamesFile(new File(project.getBuild().getDirectory()));
+        List<File> desktopResources = new ArrayList<File>();
+        if (desktopSourceDir != null) {
+            desktopResources.add(DesktopSources.resourcesDir(desktopSourceDir));
+        }
+        desktopResources.add(desktopResourcesOutputDir);
+        try {
+            new CompatRemapper(classes, classpath, onClick, MavenLog.of(getLog()))
+                    .withResourceDirectories(desktopResources)
+                    // The documents are compiled here, after javac, so that
+                    // one can name a class of the application; see
+                    // PrepareDesktopSourcesMojo.compileDesktopResources.
+                    .withFxmlSourceDirectory(new File(project.getBuild().getDirectory(), "generated-fxml"))
+                    .withApplicationLibraries(libraries)
+                    .run();
+        } catch (com.codename1.builders.BuildException ex) {
+            throw new MojoFailureException(ex.getMessage(), ex);
+        }
+    }
+
+    /// Whether a dependency is a library the application ships, and so one
+    /// to relocate when it is written against Swing or JavaFX. A `runtime`
+    /// one is shipped exactly as a `compile` one is -- the application just
+    /// does not name it in source, which is how a Swing library reached
+    /// through another one is usually declared. Left as it was, its
+    /// `javax.swing` references reached the device unrelocated. The Gradle
+    /// build takes the runtime classpath for the same reason.
+    static boolean ships(String scope, String type, String groupId) {
+        return (Artifact.SCOPE_COMPILE.equals(scope) || Artifact.SCOPE_RUNTIME.equals(scope))
+                && "jar".equals(type) && !"com.codenameone".equals(groupId);
+    }
+}
diff --git a/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/AndroidPomUpdaterTest.java b/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/AndroidPomUpdaterTest.java
index d064d697fb6..e758637219e 100644
--- a/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/AndroidPomUpdaterTest.java
+++ b/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/AndroidPomUpdaterTest.java
@@ -50,7 +50,7 @@ public void wiresALegacyArchetypePom() throws Exception {
         assertTrue(u.pom.contains("<goal>compile-android-res</goal>"));
         int remap = u.pom.indexOf(AndroidPomUpdater.REMAP_GOAL);
         int compliance = u.pom.indexOf("<goal>bytecode-compliance</goal>");
-        assertTrue(remap > 0 && remap < compliance, "remap-android must precede bytecode-compliance");
+        assertTrue(remap > 0 && remap < compliance, "remap-compat must precede bytecode-compliance");
         assertTrue(u.pom.indexOf("<profile>") >= 0 && u.pom.lastIndexOf("</profiles>") > u.pom.indexOf("<id>android-compat</id>"));
         // Wired once: a second import changes nothing.
         AndroidPomUpdater again = new AndroidPomUpdater(u.pom, false);
@@ -67,6 +67,19 @@ public void leavesTheCurrentArchetypeAlone() throws Exception {
         assertEquals(current, u.pom);
     }
 
+    /// A project generated while the goal was called remap-android is wired:
+    /// that goal relocates every layer, and its pom is not edited.
+    @Test
+    public void acceptsTheGoalUnderItsEarlierName() throws Exception {
+        String current = read("../cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml");
+        String earlier = current.replace("<goal>remap-compat</goal>", "<goal>remap-android</goal>");
+        assertTrue(earlier.contains("<goal>remap-android</goal>"));
+        AndroidPomUpdater u = new AndroidPomUpdater(earlier, true);
+        assertFalse(u.changed);
+        assertTrue(u.manual.isEmpty(), u.manual.toString());
+        assertEquals(earlier, u.pom);
+    }
+
     @Test
     public void neverWiresTheGoalIntoALaterPlugin() {
         String pom = "<project><build><plugins>\n"
diff --git a/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/DesktopPomUpdaterTest.java b/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/DesktopPomUpdaterTest.java
new file mode 100644
index 00000000000..a1e4ea841ef
--- /dev/null
+++ b/maven/codenameone-maven-plugin/src/test/java/com/codename1/maven/DesktopPomUpdaterTest.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.maven;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.nio.file.Files;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/// cn1:import-desktop-project in a project generated before the desktop
+/// layers existed: its common pom has neither runtime dependency and none of
+/// the goals, and the imported sources would not build.
+public class DesktopPomUpdaterTest {
+
+    private static String read(String path) throws Exception {
+        return new String(Files.readAllBytes(new File(path).toPath()), "UTF-8");
+    }
+
+    @Test
+    public void wiresALegacyArchetypePom() throws Exception {
+        String legacy = read("src/test/resources/android-pom/legacy-common-pom.xml");
+        DesktopPomUpdater u = new DesktopPomUpdater(legacy, false);
+        assertTrue(u.manual.isEmpty(), u.manual.toString());
+        assertTrue(u.changed);
+        assertTrue(u.pom.contains("<artifactId>codenameone-swing-compat</artifactId>"));
+        assertTrue(u.pom.contains("<artifactId>codenameone-javafx-compat</artifactId>"));
+        assertTrue(u.pom.contains("<exists>${basedir}/src/main/desktop</exists>"));
+        assertTrue(u.pom.contains("<goal>prepare-desktop-sources</goal>"));
+        int remap = u.pom.indexOf(PomWiring.REMAP_GOAL);
+        int compliance = u.pom.indexOf("<goal>bytecode-compliance</goal>");
+        assertTrue(remap > 0 && remap < compliance, "remap-compat must precede bytecode-compliance");
+        assertTrue(u.pom.lastIndexOf("</profiles>") > u.pom.indexOf("<id>desktop-compat</id>"));
+        // Wired once: a second import changes nothing.
+        DesktopPomUpdater again = new DesktopPomUpdater(u.pom, false);
+        assertFalse(again.changed);
+        assertTrue(again.manual.isEmpty());
+        assertEquals(u.pom, again.pom);
+    }
+
+    @Test
+    public void leavesTheCurrentArchetypeAlone() throws Exception {
+        String current = read("../cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml");
+        DesktopPomUpdater u = new DesktopPomUpdater(current, true);
+        assertFalse(u.changed);
+        assertTrue(u.manual.isEmpty(), u.manual.toString());
+        assertEquals(current, u.pom);
+    }
+
+    /// A project that already imported an Android application binds the
+    /// remap goal under its earlier name. That goal relocates every layer, so
+    /// it is kept, and only the desktop wiring is added.
+    @Test
+    public void addsTheDesktopLayersToAProjectWiredForAndroid() throws Exception {
+        String legacy = read("src/test/resources/android-pom/legacy-common-pom.xml");
+        String android = new AndroidPomUpdater(legacy, false).pom
+                .replace(PomWiring.REMAP_GOAL, PomWiring.LEGACY_REMAP_GOAL);
+        DesktopPomUpdater u = new DesktopPomUpdater(android, false);
+        assertTrue(u.manual.isEmpty(), u.manual.toString());
+        assertTrue(u.changed);
+        assertFalse(u.pom.contains(PomWiring.REMAP_GOAL), "the goal is bound once, under the name it already has");
+        assertTrue(u.pom.contains(PomWiring.LEGACY_REMAP_GOAL));
+        assertTrue(u.pom.contains("<id>android-compat</id>"));
+        assertTrue(u.pom.contains("<id>desktop-compat</id>"));
+        assertTrue(u.pom.contains("<goal>compile-android-res</goal>"));
+        assertTrue(u.pom.contains("<goal>prepare-desktop-sources</goal>"));
+    }
+
+    /// The imported sources are compiled against the libraries the desktop
+    /// project declared, so the pom that receives them has to declare them:
+    /// in the module's own dependencies, once, and never a version nobody
+    /// stated.
+    @Test
+    public void declaresTheImportedProjectsLibraries() throws Exception {
+        String current = read("../cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml");
+        File project = Files.createTempDirectory("desktop-libs").toFile();
+        Files.write(new File(project, "pom.xml").toPath(), ("<project><dependencies>\n"
+                + "<dependency><groupId>com.miglayout</groupId><artifactId>miglayout-swing</artifactId>"
+                + "<version>5.3</version></dependency>\n"
+                + "<dependency><groupId>org.swinglabs.swingx</groupId><artifactId>swingx-all</artifactId>"
+                + "<version>1.6.5-1</version></dependency>\n"
+                + "<dependency><groupId>org.example</groupId><artifactId>managed</artifactId></dependency>\n"
+                + "</dependencies></project>\n").getBytes("UTF-8"));
+        java.util.List<com.codename1.maven.DesktopProjectImporter.Library> libraries =
+                com.codename1.maven.DesktopProjectImporter.librariesOf(project);
+        DesktopPomUpdater u = new DesktopPomUpdater(current, false, libraries);
+        assertTrue(u.changed);
+        assertEquals(java.util.Arrays.asList("com.miglayout:miglayout-swing:5.3 (compile)",
+                "org.swinglabs.swingx:swingx-all:1.6.5-1 (provided)"), u.addedLibraries);
+        int mig = u.pom.indexOf("<artifactId>miglayout-swing</artifactId>");
+        int swingx = u.pom.indexOf("<artifactId>swingx-all</artifactId>");
+        assertTrue(mig > 0 && swingx > 0);
+        assertTrue(u.pom.substring(mig, mig + 200).contains("<scope>compile</scope>"), u.pom.substring(mig, mig + 200));
+        assertTrue(u.pom.substring(swingx, swingx + 200).contains("<scope>provided</scope>"));
+        assertFalse(u.pom.contains("<artifactId>managed</artifactId>"), "no version was stated for it");
+        // In the module's dependencies: not under dependencyManagement, a
+        // plugin or a profile, where it would compile nothing.
+        int build = u.pom.indexOf("<build>");
+        assertTrue(build < 0 || mig < build, "declared before <build>");
+        assertTrue(mig < u.pom.indexOf("<profiles>"));
+
+        DesktopPomUpdater again = new DesktopPomUpdater(u.pom, false, libraries);
+        assertFalse(again.changed);
+        assertTrue(again.addedLibraries.isEmpty(), again.addedLibraries.toString());
+        assertEquals(u.pom, again.pom);
+
+        // The same artifact somewhere that compiles nothing for the module
+        // -- here another group's artifact of that name, in a profile -- is
+        // not the module's dependency.
+        String elsewhere = current.replace("<profiles>", "<profiles>\n<profile><id>other</id><dependencies>"
+                + "<dependency><groupId>org.other</groupId><artifactId>miglayout-swing</artifactId>"
+                + "<version>1</version></dependency></dependencies></profile>");
+        assertTrue(elsewhere.length() > current.length());
+        DesktopPomUpdater third = new DesktopPomUpdater(elsewhere, false, libraries);
+        assertTrue(third.addedLibraries.contains("com.miglayout:miglayout-swing:5.3 (compile)"),
+                third.addedLibraries.toString());
+    }
+
+    @Test
+    public void neverWiresTheGoalIntoALaterPlugin() {
+        String pom = "<project><build><plugins>\n"
+                + "    <plugin>\n"
+                + "        <groupId>com.codenameone</groupId>\n"
+                + "        <artifactId>codenameone-maven-plugin</artifactId>\n"
+                + "    </plugin>\n"
+                + "    <plugin>\n"
+                + "        <artifactId>maven-antrun-plugin</artifactId>\n"
+                + "        <executions>\n"
+                + "        </executions>\n"
+                + "    </plugin>\n"
+                + "</plugins></build></project>\n";
+        DesktopPomUpdater u = new DesktopPomUpdater(pom, false);
+        assertFalse(u.pom.contains("<goal>prepare-desktop-sources</goal>"), u.pom);
+        boolean named = false;
+        for (String m : u.manual) {
+            named |= m.contains("prepare-desktop-sources");
+        }
+        assertTrue(named, u.manual.toString());
+    }
+
+    @Test
+    public void namesWhatAPomWithoutTheAnchorsNeeds() {
+        DesktopPomUpdater u = new DesktopPomUpdater("<project><build/></project>", true);
+        assertFalse(u.changed);
+        assertEquals(4, u.manual.size(), u.manual.toString());
+        assertTrue(u.manual.get(0).contains("codenameone-swing-compat"), u.manual.get(0));
+        assertTrue(u.manual.get(0).contains("codenameone-javafx-compat"), u.manual.get(0));
+        assertTrue(u.manual.get(3).contains("src/main/desktop/kotlin"), u.manual.get(3));
+    }
+
+    /// A Kotlin project wired before the desktop layers has the Android
+    /// source directories in its Kotlin execution and not the desktop ones.
+    @Test
+    public void asksForTheKotlinSourceDirectoriesOnlyWhenThereIsKotlin() throws Exception {
+        String current = read("../cn1app-archetype/src/main/resources/archetype-resources/common/pom.xml");
+        String earlier = current.replace("<sourceDir>${project.basedir}/src/main/desktop/java</sourceDir>", "");
+        assertTrue(new DesktopPomUpdater(earlier, false).manual.isEmpty());
+        DesktopPomUpdater u = new DesktopPomUpdater(earlier, true);
+        assertEquals(1, u.manual.size(), u.manual.toString());
+        assertFalse(u.changed);
+    }
+}
diff --git a/maven/compat-testing/pom.xml b/maven/compat-testing/pom.xml
new file mode 100644
index 00000000000..7cddabd8923
--- /dev/null
+++ b/maven/compat-testing/pom.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+
+    <parent>
+        <groupId>com.codenameone</groupId>
+        <artifactId>codenameone</artifactId>
+        <version>8.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>codenameone-compat-testing</artifactId>
+    <version>8.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>codenameone-compat-testing</name>
+    <description>
+        Test support shared by the compatibility layers: a headless Codename
+        One implementation with fixed metrics, the factory that selects it, and
+        a JUnit rule that runs a test on the EDT. A test-scope dependency only;
+        an ordinary module rather than a test-jar so a build that skips test
+        compilation still resolves it.
+    </description>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <!-- com.codename1.impl.JdkHost belongs to the class library, not
+                 to core: every port carries it (vm/JavaAPI, Ports/CLDC11,
+                 Ports/JavaSE, Ports/Android). The headless implementation
+                 stands in for a port on a desktop JDK, so it compiles the
+                 JavaSE port's copy rather than keeping a fifth one. -->
+            <plugin>
+                <artifactId>maven-resources-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>copy-jdk-host</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>copy-resources</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/generated-sources/jdk-host/com/codename1/impl</outputDirectory>
+                            <resources>
+                                <resource>
+                                    <directory>${project.basedir}/../../Ports/JavaSE/src/com/codename1/impl</directory>
+                                    <includes>
+                                        <include>JdkHost.java</include>
+                                    </includes>
+                                </resource>
+                            </resources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>add-jdk-host</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>add-source</goal>
+                        </goals>
+                        <configuration>
+                            <sources>
+                                <source>${project.build.directory}/generated-sources/jdk-host</source>
+                            </sources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <!-- The rule is main code here; the parent manages junit as test. -->
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/maven/compat-testing/src/main/java/com/codename1/compat/testing/HeadlessImplementation.java b/maven/compat-testing/src/main/java/com/codename1/compat/testing/HeadlessImplementation.java
new file mode 100644
index 00000000000..632734cd736
--- /dev/null
+++ b/maven/compat-testing/src/main/java/com/codename1/compat/testing/HeadlessImplementation.java
@@ -0,0 +1,1522 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.compat.testing;
+
+import com.codename1.impl.CodenameOneImplementation;
+import com.codename1.l10n.L10NManager;
+import com.codename1.ui.Display;
+
+import java.io.InputStream;
+
+/// A Codename One implementation with no screen, for tests that build and
+/// lay out Android views: a fixed 1080x1920 display at 320 dpi (density 2),
+/// resources from the class path, and monospaced font metrics. Drawing and
+/// everything else answer neutral values.
+public class HeadlessImplementation extends CodenameOneImplementation {
+
+    public static final int WIDTH = 1080;
+    public static final int HEIGHT = 1920;
+    public static final int DPI = 320;
+    public static final int CHAR_WIDTH = 16;
+    public static final int FONT_HEIGHT = 32;
+    private static final Object FONT = new Object();
+    private static final L10NManager L10N = new L10NManager("en", "US") {
+    };
+
+    /// Starts Codename One on this implementation once per test JVM.
+    ///
+    /// The factory is set here and not left to the class path. A module whose
+    /// tests also carry a port, as the build engine's carry the JavaSE port,
+    /// has two classes named `ImplementationFactory`, and which of them the
+    /// loader finds first is the order of the class path: with the port's
+    /// first, a test asking for no screen opened a window, and failed where
+    /// there is no display to open it on.
+    public static synchronized void install() {
+        if (!Display.isInitialized()) {
+            com.codename1.impl.ImplementationFactory.setInstance(new HeadlessFactory());
+            Display.init(null);
+        }
+    }
+
+    private static final class HeadlessFactory extends com.codename1.impl.ImplementationFactory {
+        @Override
+        public Object createImplementation() {
+            return new HeadlessImplementation();
+        }
+    }
+
+    /// The listener of the last `openGallery` call, which the headless
+    /// implementation never answers itself. A test that reads it must reset
+    /// it.
+    public static com.codename1.ui.events.ActionListener gallery;
+
+    @Override
+    public void openGallery(com.codename1.ui.events.ActionListener response, int type) {
+        gallery = response;
+    }
+
+    /// The image encoder `ImageIO.getImageIO()` answers; none by default. A
+    /// test that sets it must reset it.
+    public static com.codename1.ui.util.ImageIO imageIO;
+
+    @Override
+    public com.codename1.ui.util.ImageIO getImageIO() {
+        return imageIO;
+    }
+
+    @Override
+    public InputStream getResourceAsStream(Class cls, String resource) {
+        Class c = cls == null ? HeadlessImplementation.class : cls;
+        return c.getResourceAsStream(resource.startsWith("/") ? resource : "/" + resource);
+    }
+
+    @Override
+    public int convertToPixels(int dipCount, boolean horizontal) {
+        return Math.round(dipCount * DPI / 25.4f);
+    }
+
+    @Override
+    public boolean isTrueTypeSupported() {
+        return true;
+    }
+
+    @Override
+    public boolean isNativeFontSchemeSupported() {
+        return true;
+    }
+
+    @Override
+    public Object loadTrueTypeFont(String fontName, String fileName) {
+        return FONT;
+    }
+
+    @Override
+    public Object deriveTrueTypeFont(Object font, float size, int weight) {
+        return FONT;
+    }
+
+    /// What [#isDarkMode()] answers; tests flip it to change the system theme.
+    public static boolean darkMode;
+
+    @Override
+    public Boolean isDarkMode() {
+        return Boolean.valueOf(darkMode);
+    }
+
+    /// Whether the last screen saver call kept the screen on.
+    public static boolean screenLocked;
+
+    @Override
+    public void lockScreen() {
+        screenLocked = true;
+    }
+
+    @Override
+    public void unlockScreen() {
+        screenLocked = false;
+    }
+
+    @Override
+    public void init(java.lang.Object a0) {
+        // No screen to set up; what the real ports install for the JDK's
+        // resource lookups is installed the same way.
+        JdkResourceSupport.install();
+    }
+
+    @Override
+    public int getDisplayWidth() {
+        return WIDTH;
+    }
+
+    @Override
+    public int getDisplayHeight() {
+        return HEIGHT;
+    }
+
+    @Override
+    public void editString(com.codename1.ui.Component a0, int a1, int a2, java.lang.String a3, int a4) {
+    }
+
+    @Override
+    public void flushGraphics(int a0, int a1, int a2, int a3) {
+    }
+
+    @Override
+    public void flushGraphics() {
+    }
+
+    @Override
+    public void getRGB(java.lang.Object a0, int[] a1, int a2, int a3, int a4, int a5, int a6) {
+        if (a0 instanceof int[][]) {
+            int[][] rows = (int[][]) a0;
+            for (int y = 0; y < a6; y++) {
+                System.arraycopy(rows[a4 + y], a3, a1, a2 + y * a5, a5);
+            }
+        }
+    }
+
+    /// When set, an image made from ARGB pixels keeps them (as an `int[][]`
+    /// of rows) and answers them to `getRGB`. Off by default; tests that
+    /// inspect pixels flip it.
+    public static boolean pixelImages;
+
+    /// How many images were made from pixels or made to be drawn on: the
+    /// ones that are memory of the platform on a device. A test that
+    /// counts sets it to zero first.
+    public static int imagesMade;
+
+    /// How many of those were made to be drawn on.
+    public static int mutableImagesMade;
+
+    @Override
+    public java.lang.Object createImage(int[] a0, int a1, int a2) {
+        imagesMade++;
+        if (pixelImages && a1 > 0 && a2 > 0) {
+            int[][] rows = new int[a2][a1];
+            for (int y = 0; y < a2; y++) {
+                System.arraycopy(a0, y * a1, rows[y], 0, a1);
+            }
+            return rows;
+        }
+        return new Object();
+    }
+
+    @Override
+    public java.lang.Object createImage(java.lang.String a0) throws java.io.IOException {
+        return new Object();
+    }
+
+    /// With [#pixelImages] set, an encoded image (a PNG resource) is decoded
+    /// to its pixels, so tests can check the size a drawable comes out at.
+    @Override
+    public java.lang.Object createImage(java.io.InputStream a0) throws java.io.IOException {
+        if (pixelImages) {
+            java.awt.image.BufferedImage img = javax.imageio.ImageIO.read(a0);
+            if (img != null) {
+                int w = img.getWidth();
+                int h = img.getHeight();
+                return createImage(img.getRGB(0, 0, w, h, null, 0, w), w, h);
+            }
+        }
+        return new Object();
+    }
+
+    @Override
+    public java.lang.Object createMutableImage(int a0, int a1, int a2) {
+        imagesMade++;
+        mutableImagesMade++;
+        if (rasterImages && a0 > 0 && a1 > 0) {
+            int[][] rows = new int[a1][a0];
+            for (int y = 0; y < a1; y++) {
+                java.util.Arrays.fill(rows[y], a2);
+            }
+            return rows;
+        }
+        return new Object();
+    }
+
+    // ------------------------------------------------------------ raster
+
+    /// When set, a mutable image keeps its pixels (as an `int[][]` of
+    /// rows) and what is drawn into it is rasterized: rectangles, lines,
+    /// polygons and ellipses in the current color and alpha, inside the
+    /// clip, and pixel images copied. A rounded rectangle is drawn square,
+    /// an arc as its whole ellipse, and a string as a solid box of the size
+    /// it measures -- enough to assert where something was painted and in
+    /// which color, which is all it is for. Sets nothing else: a test that
+    /// flips it resets it, and wants [#trackClip] for clipping to count.
+    public static boolean rasterImages;
+    private static final java.util.Map<Object, Integer> COLORS = new java.util.IdentityHashMap<Object, Integer>();
+    private static final java.util.Map<Object, Integer> RASTER_ALPHAS =
+            new java.util.IdentityHashMap<Object, Integer>();
+
+    /// Forgets the color and alpha kept for every raster graphics.
+    public static void resetRaster() {
+        COLORS.clear();
+        RASTER_ALPHAS.clear();
+    }
+
+    private static boolean raster(Object graphics) {
+        return rasterImages && graphics instanceof int[][];
+    }
+
+    private static int blend(int under, int rgb, int alpha) {
+        if (alpha >= 255) {
+            return 0xff000000 | rgb;
+        }
+        if (alpha <= 0) {
+            return under;
+        }
+        int ua = under >>> 24;
+        int r = (((rgb >> 16) & 0xff) * alpha + ((under >> 16) & 0xff) * (255 - alpha)) / 255;
+        int g = (((rgb >> 8) & 0xff) * alpha + ((under >> 8) & 0xff) * (255 - alpha)) / 255;
+        int b = ((rgb & 0xff) * alpha + (under & 0xff) * (255 - alpha)) / 255;
+        return (Math.max(ua, alpha) << 24) | (r << 16) | (g << 8) | b;
+    }
+
+    private static void span(Object graphics, int x, int y, int w, int h) {
+        int[][] rows = (int[][]) graphics;
+        Integer c = COLORS.get(graphics);
+        Integer a = RASTER_ALPHAS.get(graphics);
+        int rgb = c == null ? 0 : c.intValue() & 0xffffff;
+        int alpha = a == null ? 255 : a.intValue();
+        int x1 = Math.max(0, x);
+        int y1 = Math.max(0, y);
+        int x2 = Math.min(rows[0].length, x + w);
+        int y2 = Math.min(rows.length, y + h);
+        if (trackClip) {
+            x1 = Math.max(x1, clipX);
+            y1 = Math.max(y1, clipY);
+            x2 = Math.min(x2, clipX + clipW);
+            y2 = Math.min(y2, clipY + clipH);
+        }
+        for (int row = y1; row < y2; row++) {
+            int[] line = rows[row];
+            for (int col = x1; col < x2; col++) {
+                line[col] = blend(line[col], rgb, alpha);
+            }
+        }
+    }
+
+    private static void line(Object graphics, int x1, int y1, int x2, int y2) {
+        int dx = Math.abs(x2 - x1);
+        int dy = Math.abs(y2 - y1);
+        int steps = Math.max(dx, dy);
+        if (steps == 0) {
+            span(graphics, x1, y1, 1, 1);
+            return;
+        }
+        if (dy == 0) {
+            span(graphics, Math.min(x1, x2), y1, dx + 1, 1);
+            return;
+        }
+        if (dx == 0) {
+            span(graphics, x1, Math.min(y1, y2), 1, dy + 1);
+            return;
+        }
+        for (int i = 0; i <= steps; i++) {
+            span(graphics, x1 + (x2 - x1) * i / steps, y1 + (y2 - y1) * i / steps, 1, 1);
+        }
+    }
+
+    private static void ellipse(Object graphics, int x, int y, int w, int h) {
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        double rx = w / 2.0;
+        double ry = h / 2.0;
+        for (int row = 0; row < h; row++) {
+            double t = (row + 0.5 - ry) / ry;
+            int half = (int) Math.round(rx * Math.sqrt(Math.max(0, 1 - t * t)));
+            if (half > 0) {
+                span(graphics, (int) Math.round(x + rx - half), y + row, half * 2, 1);
+            }
+        }
+    }
+
+    @Override
+    public void fillPolygon(Object graphics, int[] xPoints, int[] yPoints, int nPoints) {
+        if (!raster(graphics) || nPoints < 3) {
+            return;
+        }
+        int top = Integer.MAX_VALUE;
+        int bottom = Integer.MIN_VALUE;
+        for (int i = 0; i < nPoints; i++) {
+            top = Math.min(top, yPoints[i]);
+            bottom = Math.max(bottom, yPoints[i]);
+        }
+        for (int row = top; row <= bottom; row++) {
+            int left = Integer.MAX_VALUE;
+            int right = Integer.MIN_VALUE;
+            for (int i = 0; i < nPoints; i++) {
+                int j = (i + 1) % nPoints;
+                int ya = yPoints[i];
+                int yb = yPoints[j];
+                if (ya == yb) {
+                    if (ya == row) {
+                        left = Math.min(left, Math.min(xPoints[i], xPoints[j]));
+                        right = Math.max(right, Math.max(xPoints[i], xPoints[j]));
+                    }
+                    continue;
+                }
+                if (row < Math.min(ya, yb) || row > Math.max(ya, yb)) {
+                    continue;
+                }
+                int at = xPoints[i] + (xPoints[j] - xPoints[i]) * (row - ya) / (yb - ya);
+                left = Math.min(left, at);
+                right = Math.max(right, at);
+            }
+            if (left <= right) {
+                span(graphics, left, row, right - left + 1, 1);
+            }
+        }
+    }
+
+    @Override
+    public void drawPolygon(Object graphics, int[] xPoints, int[] yPoints, int nPoints) {
+        if (!raster(graphics)) {
+            return;
+        }
+        for (int i = 0; i < nPoints; i++) {
+            int j = (i + 1) % nPoints;
+            line(graphics, xPoints[i], yPoints[i], xPoints[j], yPoints[j]);
+        }
+    }
+
+    // ------------------------------------------------------------ shapes
+
+    /// When set, the graphics of a raster image (see [#rasterImages]) draws
+    /// shapes: `isShapeSupported` answers true for it, `fillShape` colours
+    /// every pixel whose middle is inside the path by its winding rule, and
+    /// `drawShape` draws the outline one pixel wide. Curves are cut into
+    /// straight pieces. Off by default, when no graphics has shapes and code
+    /// under test takes the path of a port without them.
+    ///
+    /// What it deliberately does NOT do is clip to a shape. `setClip(Shape)`
+    /// stays what it was -- the bounds of the shape with [#trackClip] and
+    /// nothing at all without -- because a rectangle put on top of a shape
+    /// clip with `clipRect` is exactly what real ports have got wrong: one
+    /// forgot the shape and kept the rectangle that was the clip before it,
+    /// two more rebuilt a shape with a curved corner as slivers along its
+    /// edges. Code that confines a fill to a shape that way -- which is what
+    /// `Graphics.fillShape` does for a `Paint` -- therefore paints outside
+    /// the shape here, and a test that looks at a pixel between a rounded
+    /// corner and the corner of its bounds sees it.
+    public static boolean shapes;
+
+    @Override
+    public boolean isShapeSupported(Object graphics) {
+        return shapes && raster(graphics);
+    }
+
+    /// The path as closed or open runs of points, `{x0, y0, x1, y1, ...}`
+    /// each, its curves cut into [#CURVE_PIECES] straight pieces.
+    private static java.util.List<float[]> flatten(com.codename1.ui.geom.Shape shape, boolean close) {
+        java.util.List<float[]> out = new java.util.ArrayList<float[]>();
+        java.util.List<Float> run = new java.util.ArrayList<Float>();
+        com.codename1.ui.geom.PathIterator it = shape.getPathIterator();
+        float[] k = new float[6];
+        float startX = 0;
+        float startY = 0;
+        float lastX = 0;
+        float lastY = 0;
+        while (!it.isDone()) {
+            int type = it.currentSegment(k);
+            if (type == com.codename1.ui.geom.PathIterator.SEG_MOVETO) {
+                endRun(out, run, close, startX, startY);
+                startX = k[0];
+                startY = k[1];
+                lastX = k[0];
+                lastY = k[1];
+                run.add(Float.valueOf(lastX));
+                run.add(Float.valueOf(lastY));
+            } else if (type == com.codename1.ui.geom.PathIterator.SEG_LINETO) {
+                lastX = k[0];
+                lastY = k[1];
+                run.add(Float.valueOf(lastX));
+                run.add(Float.valueOf(lastY));
+            } else if (type == com.codename1.ui.geom.PathIterator.SEG_QUADTO) {
+                for (int i = 1; i <= CURVE_PIECES; i++) {
+                    float t = i / (float) CURVE_PIECES;
+                    float u = 1 - t;
+                    run.add(Float.valueOf(u * u * lastX + 2 * u * t * k[0] + t * t * k[2]));
+                    run.add(Float.valueOf(u * u * lastY + 2 * u * t * k[1] + t * t * k[3]));
+                }
+                lastX = k[2];
+                lastY = k[3];
+            } else if (type == com.codename1.ui.geom.PathIterator.SEG_CUBICTO) {
+                for (int i = 1; i <= CURVE_PIECES; i++) {
+                    float t = i / (float) CURVE_PIECES;
+                    float u = 1 - t;
+                    run.add(Float.valueOf(u * u * u * lastX + 3 * u * u * t * k[0] + 3 * u * t * t * k[2]
+                            + t * t * t * k[4]));
+                    run.add(Float.valueOf(u * u * u * lastY + 3 * u * u * t * k[1] + 3 * u * t * t * k[3]
+                            + t * t * t * k[5]));
+                }
+                lastX = k[4];
+                lastY = k[5];
+            } else {
+                run.add(Float.valueOf(startX));
+                run.add(Float.valueOf(startY));
+                lastX = startX;
+                lastY = startY;
+            }
+            it.next();
+        }
+        endRun(out, run, close, startX, startY);
+        return out;
+    }
+
+    private static final int CURVE_PIECES = 16;
+
+    private static void endRun(java.util.List<float[]> out, java.util.List<Float> run, boolean close, float startX,
+                               float startY) {
+        if (run.size() >= 4) {
+            if (close) {
+                // A fill closes every run, whether the path said so or not.
+                run.add(Float.valueOf(startX));
+                run.add(Float.valueOf(startY));
+            }
+            float[] pts = new float[run.size()];
+            for (int i = 0; i < pts.length; i++) {
+                pts[i] = run.get(i).floatValue();
+            }
+            out.add(pts);
+        }
+        run.clear();
+    }
+
+    @Override
+    public void fillShape(Object graphics, com.codename1.ui.geom.Shape shape) {
+        if (!isShapeSupported(graphics) || shape == null) {
+            return;
+        }
+        int[][] rows = (int[][]) graphics;
+        java.util.List<float[]> runs = flatten(shape, true);
+        boolean evenOdd = shape.getPathIterator().getWindingRule()
+                == com.codename1.ui.geom.PathIterator.WIND_EVEN_ODD;
+        for (int row = 0; row < rows.length; row++) {
+            float y = row + 0.5f;
+            // Where the outline crosses the middle of this row of pixels,
+            // and which way it was going.
+            java.util.List<float[]> crossings = new java.util.ArrayList<float[]>();
+            for (float[] pts : runs) {
+                for (int i = 0; i + 3 < pts.length; i += 2) {
+                    float ya = pts[i + 1];
+                    float yb = pts[i + 3];
+                    if ((ya <= y) == (yb <= y)) {
+                        continue;
+                    }
+                    float x = pts[i] + (pts[i + 2] - pts[i]) * (y - ya) / (yb - ya);
+                    crossings.add(new float[] {x, yb > ya ? 1 : -1});
+                }
+            }
+            java.util.Collections.sort(crossings, new java.util.Comparator<float[]>() {
+                @Override
+                public int compare(float[] a, float[] b) {
+                    return Float.compare(a[0], b[0]);
+                }
+            });
+            int winding = 0;
+            for (int i = 0; i + 1 < crossings.size(); i++) {
+                winding += (int) crossings.get(i)[1];
+                boolean inside = evenOdd ? (i % 2) == 0 : winding != 0;
+                if (inside) {
+                    int from = (int) Math.ceil(crossings.get(i)[0] - 0.5f);
+                    int to = (int) Math.ceil(crossings.get(i + 1)[0] - 0.5f);
+                    if (to > from) {
+                        span(graphics, from, row, to - from, 1);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void drawShape(Object graphics, com.codename1.ui.geom.Shape shape, com.codename1.ui.Stroke stroke) {
+        if (!isShapeSupported(graphics) || shape == null) {
+            return;
+        }
+        for (float[] pts : flatten(shape, false)) {
+            for (int i = 0; i + 3 < pts.length; i += 2) {
+                line(graphics, (int) Math.floor(pts[i]), (int) Math.floor(pts[i + 1]), (int) Math.floor(pts[i + 2]),
+                        (int) Math.floor(pts[i + 3]));
+            }
+        }
+    }
+
+    /// Counts encoded images handed to [#createImage(byte[], int, int)], so a
+    /// test can tell a header-only bounds probe from a full decode.
+    public static int encodedDecodes;
+
+    @Override
+    public java.lang.Object createImage(byte[] a0, int a1, int a2) {
+        encodedDecodes++;
+        if (pixelImages) {
+            try {
+                return createImage(new java.io.ByteArrayInputStream(a0, a1, a2));
+            } catch (java.io.IOException e) {
+                return new Object();
+            }
+        }
+        return new Object();
+    }
+
+    @Override
+    public int getImageWidth(java.lang.Object image) {
+        return image instanceof int[][] ? ((int[][]) image)[0].length : 0;
+    }
+
+    @Override
+    public int getImageHeight(java.lang.Object image) {
+        return image instanceof int[][] ? ((int[][]) image).length : 0;
+    }
+
+    @Override
+    public java.lang.Object scale(java.lang.Object a0, int a1, int a2) {
+        if (a0 instanceof int[][] && a1 > 0 && a2 > 0) {
+            // Nearest-neighbour, for the pixel images of pixelImages.
+            int[][] src = (int[][]) a0;
+            int[][] out = new int[a2][a1];
+            for (int y = 0; y < a2; y++) {
+                for (int x = 0; x < a1; x++) {
+                    out[y][x] = src[y * src.length / a2][x * src[0].length / a1];
+                }
+            }
+            return out;
+        }
+        return new Object();
+    }
+
+    @Override
+    public int getSoftkeyCount() {
+        return 0;
+    }
+
+    @Override
+    public int[] getSoftkeyCode(int a0) {
+        return null;
+    }
+
+    @Override
+    public int getClearKeyCode() {
+        return 0;
+    }
+
+    @Override
+    public int getBackspaceKeyCode() {
+        return 0;
+    }
+
+    @Override
+    public int getBackKeyCode() {
+        return 0;
+    }
+
+    /// The key codes of the arrows and of fire, which are those of the
+    /// desktop port. With no code for them a test could not press an
+    /// arrow at all: every game action answered the same key, zero, and
+    /// zero is no key.
+    private static final int KEY_FIRE = -90;
+    private static final int KEY_UP = -91;
+    private static final int KEY_DOWN = -92;
+    private static final int KEY_LEFT = -93;
+    private static final int KEY_RIGHT = -94;
+
+    @Override
+    public int getGameAction(int a0) {
+        switch (a0) {
+            case KEY_FIRE:
+                return Display.GAME_FIRE;
+            case KEY_UP:
+                return Display.GAME_UP;
+            case KEY_DOWN:
+                return Display.GAME_DOWN;
+            case KEY_LEFT:
+                return Display.GAME_LEFT;
+            case KEY_RIGHT:
+                return Display.GAME_RIGHT;
+            default:
+                return 0;
+        }
+    }
+
+    @Override
+    public int getKeyCode(int a0) {
+        switch (a0) {
+            case Display.GAME_FIRE:
+                return KEY_FIRE;
+            case Display.GAME_UP:
+                return KEY_UP;
+            case Display.GAME_DOWN:
+                return KEY_DOWN;
+            case Display.GAME_LEFT:
+                return KEY_LEFT;
+            case Display.GAME_RIGHT:
+                return KEY_RIGHT;
+            default:
+                return 0;
+        }
+    }
+
+    private static boolean desktop;
+
+    /// Makes the implementation answer that it is a desktop, as the port
+    /// an application runs on at a desk does, or not. A form of a desktop
+    /// moves the focus itself on Tab and acts on Escape, which a test of
+    /// the keyboard has to run with; a test that asked for it turns it
+    /// off again when it is done.
+    public static void setDesktop(boolean value) {
+        desktop = value;
+    }
+
+    @Override
+    public boolean isDesktop() {
+        return desktop;
+    }
+
+    /// Whether the title of the form showing belongs on the window of the
+    /// operating system, as it does on a desktop port in its `native`
+    /// title bar mode. A test that sets it must reset it.
+    public static boolean nativeTitle;
+
+    /// The title last pushed to the window of the operating system, or
+    /// null. Only [#refreshNativeTitle] writes it, as on a real port: a
+    /// title that nothing asked to push stays where it was.
+    public static String windowTitle;
+
+    /// The size last asked of the application's window as `{width,
+    /// height}`, or null.
+    public static int[] windowSize;
+
+    @Override
+    public boolean isNativeTitle() {
+        return desktop && nativeTitle;
+    }
+
+    @Override
+    public void refreshNativeTitle() {
+        com.codename1.ui.Form f = getCurrentForm();
+        if (isNativeTitle() && f != null && !(f instanceof com.codename1.ui.Dialog)) {
+            windowTitle = f.getTitle() == null ? "" : f.getTitle();
+        }
+    }
+
+    /// The size of the desktop the window is on as `{width, height}`, or
+    /// null for a port that has none to report, which is every port that
+    /// is not at a desk. A test that sets it must reset it.
+    public static int[] desktopSize;
+
+    @Override
+    public com.codename1.ui.geom.Dimension getDesktopSize() {
+        return desktop && desktopSize != null
+                ? new com.codename1.ui.geom.Dimension(desktopSize[0], desktopSize[1]) : null;
+    }
+
+    /// What the frame of the window adds to the display as `{width,
+    /// height}`, or null: the window of a desktop is larger than what is
+    /// drawn in it by its borders and its title bar. A test that sets it
+    /// must reset it.
+    public static int[] windowFrame;
+
+    @Override
+    public com.codename1.ui.geom.Rectangle getWindowBounds() {
+        if (!desktop || windowFrame == null) {
+            return null;
+        }
+        return new com.codename1.ui.geom.Rectangle(0, 0, WIDTH + windowFrame[0], HEIGHT + windowFrame[1]);
+    }
+
+    @Override
+    public void setWindowSize(int width, int height) {
+        if (desktop) {
+            windowSize = new int[] {width, height};
+        }
+    }
+
+    @Override
+    public boolean isTouchDevice() {
+        return true;
+    }
+
+    @Override
+    public int getColor(java.lang.Object a0) {
+        Integer c = rasterImages ? COLORS.get(a0) : null;
+        return c == null ? 0 : c.intValue();
+    }
+
+    @Override
+    public void setColor(java.lang.Object a0, int a1) {
+        if (raster(a0)) {
+            COLORS.put(a0, Integer.valueOf(a1));
+        }
+    }
+
+    /// When set, each graphics context keeps the alpha it was given, and
+    /// every `fillRect`, `drawImage` and `fillLinearGradient` is added to
+    /// [#draws] as {operation, native graphics, alpha}. A test that sets it
+    /// must reset it and clear [#draws].
+    public static boolean recordDraws;
+    public static final java.util.List<Object[]> draws = new java.util.ArrayList<Object[]>();
+    private static final java.util.Map<Object, Integer> ALPHAS = new java.util.IdentityHashMap<Object, Integer>();
+
+    private static void recordDraw(String op, Object graphics) {
+        if (recordDraws) {
+            draws.add(new Object[]{op, graphics, Integer.valueOf(alphaOf(graphics))});
+        }
+    }
+
+    private static int alphaOf(Object graphics) {
+        Integer a = ALPHAS.get(graphics);
+        return a == null ? 255 : a.intValue();
+    }
+
+    @Override
+    public void setAlpha(java.lang.Object a0, int a1) {
+        if (raster(a0)) {
+            RASTER_ALPHAS.put(a0, Integer.valueOf(a1));
+        }
+        if (recordDraws) {
+            ALPHAS.put(a0, Integer.valueOf(a1));
+        }
+    }
+
+    @Override
+    public int getAlpha(java.lang.Object a0) {
+        if (raster(a0)) {
+            Integer a = RASTER_ALPHAS.get(a0);
+            return a == null ? 255 : a.intValue();
+        }
+        return recordDraws ? alphaOf(a0) : 0;
+    }
+
+    /// With [#recordDraws], the arguments of every gradient fill:
+    /// {"fillLinearGradient", start, end, horizontal} or
+    /// {"fillGradient", the gradient}. A test that records clears it too.
+    public static final java.util.List<Object[]> gradients = new java.util.ArrayList<Object[]>();
+
+    @Override
+    public void fillGradient(Object graphics, com.codename1.ui.Gradient gradient, int x, int y, int width,
+                             int height) {
+        if (recordDraws) {
+            recordDraw("fillGradient", graphics);
+            gradients.add(new Object[]{"fillGradient", gradient});
+        } else {
+            super.fillGradient(graphics, gradient, x, y, width, height);
+        }
+    }
+
+    @Override
+    public void fillLinearGradient(Object graphics, int startColor, int endColor, int x, int y, int width,
+                                   int height, boolean horizontal) {
+        if (recordDraws) {
+            recordDraw("fillLinearGradient", graphics);
+            gradients.add(new Object[]{"fillLinearGradient", Integer.valueOf(startColor),
+                Integer.valueOf(endColor), Boolean.valueOf(horizontal)});
+        } else {
+            super.fillLinearGradient(graphics, startColor, endColor, x, y, width, height, horizontal);
+        }
+    }
+
+    @Override
+    public void setNativeFont(java.lang.Object a0, java.lang.Object a1) {
+    }
+
+    /// When set, every graphics context shares one tracked clip rectangle
+    /// and shape clips are supported: `setClip(Shape)` records the shape in
+    /// [#shapeClip] and clips to its bounds. Off by default, when the clip is
+    /// always the whole display; tests that check clipping flip it.
+    public static boolean trackClip;
+    /// The last shape passed to `setClip(Shape)` while [#trackClip] is set,
+    /// null once a rectangle replaces it.
+    public static com.codename1.ui.geom.Shape shapeClip;
+    private static int clipX;
+    private static int clipY;
+    private static int clipW = WIDTH;
+    private static int clipH = HEIGHT;
+
+    @Override
+    public int getClipX(java.lang.Object a0) {
+        own(a0);
+        return trackClip ? clipX : 0;
+    }
+
+    @Override
+    public int getClipY(java.lang.Object a0) {
+        own(a0);
+        return trackClip ? clipY : 0;
+    }
+
+    @Override
+    public int getClipWidth(java.lang.Object a0) {
+        own(a0);
+        return trackClip ? clipW : WIDTH;
+    }
+
+    @Override
+    public int getClipHeight(java.lang.Object a0) {
+        own(a0);
+        return trackClip ? clipH : HEIGHT;
+    }
+
+    @Override
+    public void setClip(java.lang.Object a0, int a1, int a2, int a3, int a4) {
+        own(a0);
+        clipX = a1;
+        clipY = a2;
+        clipW = a3;
+        clipH = a4;
+        shapeClip = null;
+    }
+
+    /// When set, the implementation is a port with affine transforms whose
+    /// clip stays in the coordinates of the screen, which is how the native
+    /// Linux port behaves: `setClip` and the clip getters carry the same
+    /// numbers whatever matrix is installed, and `clipRect` under a matrix
+    /// REPLACES the clip with the bounds of the transformed rectangle. Wants
+    /// [#trackClip]. What is drawn is clipped but not moved by the matrix:
+    /// the mode is for testing what gets painted, not where it lands.
+    public static boolean screenSpaceClip;
+    private static double[] matrix = {1, 0, 0, 1, 0, 0};
+
+    private static double[] lastMatrix = matrix;
+
+    /// Where a point handed to the port lands under the matrix installed
+    /// last, on whichever graphics that was, in [#screenSpaceClip] mode.
+    public static double[] onScreen(double x, double y) {
+        double[] m = lastMatrix;
+        return new double[] {m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]};
+    }
+
+    private static double[] affine(Object nativeTransform) {
+        return (double[]) nativeTransform;
+    }
+
+    private static boolean plain(double[] m) {
+        return m[0] == 1 && m[1] == 0 && m[2] == 0 && m[3] == 1 && m[4] == 0 && m[5] == 0;
+    }
+
+    @Override
+    public boolean isTransformSupported() {
+        return screenSpaceClip;
+    }
+
+    @Override
+    public boolean isTransformSupported(Object graphics) {
+        return screenSpaceClip;
+    }
+
+    @Override
+    public Object makeTransformIdentity() {
+        return new double[] {1, 0, 0, 1, 0, 0};
+    }
+
+    @Override
+    public void setTransformIdentity(Object t) {
+        setTransformAffine(t, 1, 0, 0, 1, 0, 0);
+    }
+
+    @Override
+    public Object makeTransformAffine(double m00, double m10, double m01, double m11, double m02, double m12) {
+        return new double[] {m00, m10, m01, m11, m02, m12};
+    }
+
+    @Override
+    public void setTransformAffine(Object t, double m00, double m10, double m01, double m11, double m02,
+                                   double m12) {
+        double[] m = affine(t);
+        m[0] = m00;
+        m[1] = m10;
+        m[2] = m01;
+        m[3] = m11;
+        m[4] = m02;
+        m[5] = m12;
+    }
+
+    @Override
+    public Object makeTransformTranslation(float x, float y, float z) {
+        return new double[] {1, 0, 0, 1, x, y};
+    }
+
+    @Override
+    public void setTransformTranslation(Object t, float x, float y, float z) {
+        setTransformAffine(t, 1, 0, 0, 1, x, y);
+    }
+
+    @Override
+    public Object makeTransformScale(float x, float y, float z) {
+        return new double[] {x, 0, 0, y, 0, 0};
+    }
+
+    @Override
+    public void setTransformScale(Object t, float x, float y, float z) {
+        setTransformAffine(t, x, 0, 0, y, 0, 0);
+    }
+
+    @Override
+    public void transformTranslate(Object t, float x, float y, float z) {
+        concatenateTransform(t, new double[] {1, 0, 0, 1, x, y});
+    }
+
+    @Override
+    public void transformScale(Object t, float x, float y, float z) {
+        concatenateTransform(t, new double[] {x, 0, 0, y, 0, 0});
+    }
+
+    @Override
+    public Object makeTransformInverse(Object t) {
+        double[] m = affine(t);
+        double det = m[0] * m[3] - m[1] * m[2];
+        if (det == 0) {
+            return null;
+        }
+        return new double[] {m[3] / det, -m[1] / det, -m[2] / det, m[0] / det,
+            (m[2] * m[5] - m[3] * m[4]) / det, (m[1] * m[4] - m[0] * m[5]) / det};
+    }
+
+    @Override
+    public void setTransformInverse(Object t) throws com.codename1.ui.Transform.NotInvertibleException {
+        Object inverse = makeTransformInverse(t);
+        if (inverse == null) {
+            throw new com.codename1.ui.Transform.NotInvertibleException();
+        }
+        copyTransform(inverse, t);
+    }
+
+    @Override
+    public void copyTransform(Object src, Object dest) {
+        System.arraycopy(affine(src), 0, affine(dest), 0, 6);
+    }
+
+    @Override
+    public void concatenateTransform(Object t1, Object t2) {
+        double[] a = affine(t1);
+        double[] b = affine(t2);
+        setTransformAffine(t1, a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1],
+                a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3],
+                a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]);
+    }
+
+    @Override
+    public boolean transformNativeEqualsImpl(Object t1, Object t2) {
+        return t1 != null && t2 != null && java.util.Arrays.equals(affine(t1), affine(t2));
+    }
+
+    @Override
+    public void transformPoint(Object t, float[] in, float[] out) {
+        double[] m = affine(t);
+        float x = in[0];
+        float y = in[1];
+        out[0] = (float) (m[0] * x + m[2] * y + m[4]);
+        out[1] = (float) (m[1] * x + m[3] * y + m[5]);
+    }
+
+    @Override
+    public void setTransform(Object graphics, com.codename1.ui.Transform transform) {
+        if (graphics instanceof Offscreen) {
+            ((Offscreen) graphics).matrix = transform == null ? new double[] {1, 0, 0, 1, 0, 0}
+                    : affine(transform.getNativeTransform()).clone();
+            lastMatrix = ((Offscreen) graphics).matrix;
+            return;
+        }
+        if (transform == null) {
+            matrix = new double[] {1, 0, 0, 1, 0, 0};
+        } else {
+            matrix = affine(transform.getNativeTransform()).clone();
+        }
+        lastMatrix = matrix;
+    }
+
+    @Override
+    public com.codename1.ui.Transform getTransform(Object graphics) {
+        double[] m = screenSpaceClip ? matrixOf(graphics) : new double[] {1, 0, 0, 1, 0, 0};
+        return com.codename1.ui.Transform.makeAffine(m[0], m[1], m[2], m[3], m[4], m[5]);
+    }
+
+    @Override
+    public void getTransform(Object graphics, com.codename1.ui.Transform t) {
+        t.setTransform(getTransform(graphics));
+    }
+
+    @Override
+    public void clipRect(java.lang.Object a0, int a1, int a2, int a3, int a4) {
+        own(a0);
+        if (screenSpaceClip && !plain(matrixOf(a0))) {
+            double[] m = matrixOf(a0);
+            double minX = Double.MAX_VALUE;
+            double minY = Double.MAX_VALUE;
+            double maxX = -Double.MAX_VALUE;
+            double maxY = -Double.MAX_VALUE;
+            for (int i = 0; i < 4; i++) {
+                double x = a1 + ((i & 1) == 0 ? 0 : a3);
+                double y = a2 + ((i & 2) == 0 ? 0 : a4);
+                double sx = m[0] * x + m[2] * y + m[4];
+                double sy = m[1] * x + m[3] * y + m[5];
+                minX = Math.min(minX, sx);
+                minY = Math.min(minY, sy);
+                maxX = Math.max(maxX, sx);
+                maxY = Math.max(maxY, sy);
+            }
+            clipX = (int) Math.floor(minX);
+            clipY = (int) Math.floor(minY);
+            clipW = (int) Math.ceil(maxX) - clipX;
+            clipH = (int) Math.ceil(maxY) - clipY;
+            shapeClip = null;
+            return;
+        }
+        int x2 = Math.min(clipX + clipW, a1 + a3);
+        int y2 = Math.min(clipY + clipH, a2 + a4);
+        clipX = Math.max(clipX, a1);
+        clipY = Math.max(clipY, a2);
+        clipW = Math.max(0, x2 - clipX);
+        clipH = Math.max(0, y2 - clipY);
+        shapeClip = null;
+    }
+
+    @Override
+    public boolean isShapeClipSupported(java.lang.Object graphics) {
+        return trackClip;
+    }
+
+    @Override
+    public void setClip(java.lang.Object graphics, com.codename1.ui.geom.Shape shape) {
+        if (trackClip) {
+            com.codename1.ui.geom.Rectangle b = shape.getBounds();
+            if (screenSpaceClip && !plain(matrixOf(graphics))) {
+                // The native Linux port: the shape goes through the matrix
+                // and its bounds on the screen become the clip.
+                clipRect(graphics, b.getX(), b.getY(), b.getWidth(), b.getHeight());
+            } else {
+                setClip(graphics, b.getX(), b.getY(), b.getWidth(), b.getHeight());
+            }
+            shapeClip = shape;
+        }
+    }
+
+    @Override
+    public void drawLine(java.lang.Object a0, int a1, int a2, int a3, int a4) {
+        if (raster(a0)) {
+            line(a0, a1, a2, a3, a4);
+        }
+    }
+
+    @Override
+    public void fillRect(java.lang.Object a0, int a1, int a2, int a3, int a4) {
+        if (raster(a0)) {
+            span(a0, a1, a2, a3, a4);
+        }
+        recordDraw("fillRect", a0);
+    }
+
+    /// The rectangles `clearRect` was asked to erase, as `{x, y, w, h}`.
+    /// Tests that check erasing clear it first.
+    public static final java.util.List<int[]> clearedRects = new java.util.ArrayList<int[]>();
+
+    @Override
+    public void clearRect(java.lang.Object graphics, int x, int y, int width, int height) {
+        clearedRects.add(new int[]{x, y, width, height});
+        if (graphics instanceof int[][]) {
+            // A pixel image's graphics (see getNativeGraphics) really erases.
+            int[][] rows = (int[][]) graphics;
+            for (int row = Math.max(0, y); row < Math.min(rows.length, y + height); row++) {
+                for (int col = Math.max(0, x); col < Math.min(rows[row].length, x + width); col++) {
+                    rows[row][col] = 0;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void drawRect(java.lang.Object a0, int a1, int a2, int a3, int a4) {
+        if (raster(a0)) {
+            line(a0, a1, a2, a1 + a3, a2);
+            line(a0, a1, a2 + a4, a1 + a3, a2 + a4);
+            line(a0, a1, a2, a1, a2 + a4);
+            line(a0, a1 + a3, a2, a1 + a3, a2 + a4);
+        }
+    }
+
+    @Override
+    public void drawRoundRect(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
+        drawRect(a0, a1, a2, a3, a4);
+    }
+
+    @Override
+    public void fillRoundRect(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
+        if (raster(a0)) {
+            span(a0, a1, a2, a3, a4);
+        }
+    }
+
+    @Override
+    public void fillArc(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
+        if (raster(a0)) {
+            ellipse(a0, a1, a2, a3, a4);
+        }
+    }
+
+    @Override
+    public void drawArc(java.lang.Object a0, int a1, int a2, int a3, int a4, int a5, int a6) {
+    }
+
+    @Override
+    public void drawString(java.lang.Object a0, java.lang.String a1, int a2, int a3) {
+        if (raster(a0) && a1 != null) {
+            span(a0, a2, a3, a1.length() * CHAR_WIDTH + textOverhang, FONT_HEIGHT);
+        }
+        if (recordText) {
+            own(a0);
+            // Whether the place the text starts at is inside the clip, which
+            // is in the coordinates the graphics draws to once its matrix
+            // has been applied.
+            double[] m = screenSpaceClip ? matrixOf(a0) : new double[] {1, 0, 0, 1, 0, 0};
+            double sx = m[0] * (a2 + 1) + m[2] * (a3 + 1) + m[4];
+            double sy = m[1] * (a2 + 1) + m[3] * (a3 + 1) + m[5];
+            boolean seen = sx >= clipX && sx < clipX + clipW && sy >= clipY && sy < clipY + clipH;
+            drawnText.add(new Object[]{a1, Integer.valueOf(a2), Integer.valueOf(a3), Boolean.valueOf(seen)});
+        }
+    }
+
+    /// How many pixels the box a string is rasterized as reaches past the
+    /// width the string measures, as the last letter of an italic does on
+    /// a real port, where a text clipped to its measured width loses that
+    /// much of it. 0 by default; a test that sets it puts it back.
+    public static int textOverhang;
+
+    /// When set, every `drawString` (a `drawChar` arrives as one) is added
+    /// to [#drawnText] as {text, x, y, inside}, the last being whether the
+    /// text starts inside the clip in force, which only means something
+    /// with [#trackClip]. A test that sets it must reset both.
+    public static boolean recordText;
+    public static final java.util.List<Object[]> drawnText = new java.util.ArrayList<Object[]>();
+
+    @Override
+    public void drawImage(java.lang.Object a0, java.lang.Object a1, int a2, int a3) {
+        if (raster(a0) && a1 instanceof int[][]) {
+            int[][] src = (int[][]) a1;
+            int[][] rows = (int[][]) a0;
+            for (int y = 0; y < src.length; y++) {
+                int row = a3 + y;
+                if (row < 0 || row >= rows.length || (trackClip && (row < clipY || row >= clipY + clipH))) {
+                    continue;
+                }
+                for (int x = 0; x < src[y].length; x++) {
+                    int col = a2 + x;
+                    if (col < 0 || col >= rows[row].length || (trackClip && (col < clipX || col >= clipX + clipW))) {
+                        continue;
+                    }
+                    rows[row][col] = blend(rows[row][col], src[y][x] & 0xffffff, src[y][x] >>> 24);
+                }
+            }
+        }
+        recordDraw("drawImage", a0);
+    }
+
+    @Override
+    public void drawRGB(java.lang.Object a0, int[] a1, int a2, int a3, int a4, int a5, int a6, boolean a7) {
+    }
+
+    @Override
+    public java.lang.Object getNativeGraphics() {
+        return new Object();
+    }
+
+    @Override
+    public java.lang.Object getNativeGraphics(java.lang.Object a0) {
+        // With pixelImages, drawing into a pixel image draws into its rows;
+        // only clearRect writes pixels so far.
+        if ((pixelImages || rasterImages) && a0 instanceof int[][]) {
+            return a0;
+        }
+        return new Offscreen();
+    }
+
+    /// The graphics of an image without pixels. It keeps the matrix
+    /// installed on it, as a port does: what is on the graphics of one
+    /// image, or on the screen's, is not on that of another.
+    private static final class Offscreen {
+        private double[] matrix = {1, 0, 0, 1, 0, 0};
+        private int[] clip = {0, 0, 1 << 20, 1 << 20};
+    }
+
+    private static Offscreen clipOwner;
+
+    /// In [#screenSpaceClip] mode the clip is that of the graphics it was
+    /// set on, as it is on a port: a picture painted in the middle of a
+    /// frame starts with the whole of itself, not with what the screen was
+    /// clipped to. The one tracked rectangle is handed from graphics to
+    /// graphics as each is used.
+    private static void own(Object graphics) {
+        if (!screenSpaceClip || !(graphics instanceof Offscreen) || graphics == clipOwner) {
+            return;
+        }
+        if (clipOwner != null) {
+            clipOwner.clip = new int[] {clipX, clipY, clipW, clipH};
+        }
+        clipOwner = (Offscreen) graphics;
+        clipX = clipOwner.clip[0];
+        clipY = clipOwner.clip[1];
+        clipW = clipOwner.clip[2];
+        clipH = clipOwner.clip[3];
+        shapeClip = null;
+    }
+
+    /// The matrix in force on a graphics, in [#screenSpaceClip] mode.
+    private static double[] matrixOf(Object graphics) {
+        if (graphics instanceof Offscreen) {
+            return ((Offscreen) graphics).matrix;
+        }
+        return matrix;
+    }
+
+    /// When set, a run of characters measures 1px narrower per adjacent pair
+    /// than its characters one by one, as a kerning font (a browser canvas)
+    /// does. Off by default; tests that measure text flip it.
+    public static boolean kerning;
+
+    private static int kerned(int width, int len) {
+        return kerning && len > 1 ? width - (len - 1) : width;
+    }
+
+    @Override
+    public int charsWidth(java.lang.Object nativeFont, char[] ch, int offset, int len) {
+        return kerned(len * CHAR_WIDTH, len);
+    }
+
+    @Override
+    public int stringWidth(java.lang.Object nativeFont, java.lang.String text) {
+        return text == null ? 0 : kerned(text.length() * CHAR_WIDTH, text.length());
+    }
+
+    @Override
+    public int charWidth(java.lang.Object a0, char a1) {
+        return CHAR_WIDTH;
+    }
+
+    @Override
+    public int getHeight(java.lang.Object a0) {
+        return FONT_HEIGHT;
+    }
+
+    @Override
+    public java.lang.Object getDefaultFont() {
+        return FONT;
+    }
+
+    /// The face of the system font asked for last, -1 before any was:
+    /// every font here is the same one, so this is all a test can tell a
+    /// fixed width font by.
+    public static int lastFontFace = -1;
+
+    @Override
+    public java.lang.Object createFont(int a0, int a1, int a2) {
+        lastFontFace = a0;
+        return FONT;
+    }
+
+    @Override
+    public java.lang.Object connect(java.lang.String a0, boolean a1, boolean a2) throws java.io.IOException {
+        return new Object();
+    }
+
+    @Override
+    public void setHeader(java.lang.Object a0, java.lang.String a1, java.lang.String a2) {
+    }
+
+    @Override
+    public int getContentLength(java.lang.Object a0) {
+        return 0;
+    }
+
+    /// In-memory file system: what was written through `openOutputStream`
+    /// with a String path, readable back through `openInputStream` under the
+    /// exact same path, so tests can see which path the runtime addressed.
+    public static final java.util.Map<String, byte[]> FILES = new java.util.HashMap<String, byte[]>();
+
+    /// Refuses what a real port's file system refuses: a path that is not
+    /// an absolute `file:/` one. The simulator throws exactly this for a
+    /// relative path or a bare `file:name`, so code that hands one over
+    /// must fail here too rather than pass a test and die on a device.
+    private static void checkPath(java.lang.Object path) {
+        if (path instanceof String && !((String) path).startsWith("file:/")) {
+            throw new IllegalArgumentException(path + " is not a valid path, use "
+                    + "FileSystemStorage.getInstance().getAppHomePath() to get a valid dir path to read/write files");
+        }
+    }
+
+    @Override
+    public java.io.OutputStream openOutputStream(final java.lang.Object a0) throws java.io.IOException {
+        checkPath(a0);
+        if (!(a0 instanceof String)) {
+            return null;
+        }
+        return new java.io.ByteArrayOutputStream() {
+            @Override
+            public void close() throws java.io.IOException {
+                super.close();
+                FILES.put((String) a0, toByteArray());
+            }
+        };
+    }
+
+    @Override
+    public java.io.OutputStream openOutputStream(java.lang.Object a0, int a1) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public java.io.InputStream openInputStream(java.lang.Object a0) throws java.io.IOException {
+        checkPath(a0);
+        byte[] b = a0 instanceof String ? FILES.get(a0) : null;
+        return b == null ? null : new java.io.ByteArrayInputStream(b);
+    }
+
+    @Override
+    public void setPostRequest(java.lang.Object a0, boolean a1) {
+    }
+
+    @Override
+    public int getResponseCode(java.lang.Object a0) throws java.io.IOException {
+        return 0;
+    }
+
+    @Override
+    public java.lang.String getResponseMessage(java.lang.Object a0) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public java.lang.String getHeaderField(java.lang.String a0, java.lang.Object a1) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public java.lang.String[] getHeaderFieldNames(java.lang.Object a0) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public java.lang.String[] getHeaderFields(java.lang.String a0, java.lang.Object a1) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public void deleteStorageFile(java.lang.String a0) {
+    }
+
+    @Override
+    public java.io.OutputStream createStorageOutputStream(java.lang.String a0) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public java.io.InputStream createStorageInputStream(java.lang.String a0) throws java.io.IOException {
+        return null;
+    }
+
+    @Override
+    public boolean storageFileExists(java.lang.String a0) {
+        return false;
+    }
+
+    @Override
+    public java.lang.String[] listStorageEntries() {
+        return null;
+    }
+
+    @Override
+    public java.lang.String[] listFilesystemRoots() {
+        return new java.lang.String[] {"file:///"};
+    }
+
+    /// A fixed home under the one root, so a relative path an application
+    /// opens resolves instead of failing on a root list that is not there.
+    /// Nothing exists in it until a test writes it: see [#FILES].
+    @Override
+    public java.lang.String getAppHomePath() {
+        return "file:///home/";
+    }
+
+    @Override
+    public java.lang.String[] listFiles(java.lang.String a0) throws java.io.IOException {
+        checkPath(a0);
+        return null;
+    }
+
+    @Override
+    public long getRootSizeBytes(java.lang.String a0) {
+        return 0;
+    }
+
+    @Override
+    public long getRootAvailableSpace(java.lang.String a0) {
+        return 0;
+    }
+
+    @Override
+    public void mkdir(java.lang.String a0) {
+        checkPath(a0);
+    }
+
+    @Override
+    public void deleteFile(java.lang.String a0) {
+        checkPath(a0);
+        if (fileSystem && !UNDELETABLE.contains(a0)) {
+            FILES.remove(a0);
+        }
+    }
+
+    /// When set, [#FILES] answers `exists` and `deleteFile` removes from it,
+    /// except a path in [#UNDELETABLE], which a refused unlink leaves in
+    /// place. A test that sets it must reset it and clear both.
+    public static boolean fileSystem;
+    public static final java.util.Set<String> UNDELETABLE = new java.util.HashSet<String>();
+
+    @Override
+    public boolean isHidden(java.lang.String a0) {
+        checkPath(a0);
+        return false;
+    }
+
+    @Override
+    public void setHidden(java.lang.String a0, boolean a1) {
+    }
+
+    @Override
+    public long getFileLength(java.lang.String a0) {
+        checkPath(a0);
+        return 0;
+    }
+
+    @Override
+    public boolean isDirectory(java.lang.String a0) {
+        checkPath(a0);
+        return false;
+    }
+
+    @Override
+    public boolean exists(java.lang.String a0) {
+        checkPath(a0);
+        return fileSystem && FILES.containsKey(a0);
+    }
+
+    @Override
+    public void rename(java.lang.String a0, java.lang.String a1) {
+        checkPath(a0);
+    }
+
+    @Override
+    public char getFileSystemSeparator() {
+        return '/';
+    }
+
+    @Override
+    public java.lang.String getPlatformName() {
+        return "headless";
+    }
+
+    @Override
+    public com.codename1.l10n.L10NManager getLocalizationManager() {
+        return L10N;
+    }
+}
diff --git a/maven/compat-testing/src/main/java/com/codename1/compat/testing/JdkResourceSupport.java b/maven/compat-testing/src/main/java/com/codename1/compat/testing/JdkResourceSupport.java
new file mode 100644
index 00000000000..1819efd0e5e
--- /dev/null
+++ b/maven/compat-testing/src/main/java/com/codename1/compat/testing/JdkResourceSupport.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.compat.testing;
+
+import com.codename1.impl.compat.Resources;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLStreamHandler;
+import java.util.Collections;
+import java.util.Enumeration;
+
+/// What the JavaSE and Android ports install into
+/// [com.codename1.impl.compat.Resources] when they start, so an application
+/// built from desktop sources finds the resources its build flattened on a
+/// real JDK: `cn1res:` URLs that read back through `Resources`, and a loader
+/// the JDK's `ResourceBundle` and `ServiceLoader` look nested names up
+/// through. The headless implementation stands in for those ports and
+/// installs the same, a copy of the JavaSE port's class.
+final class JdkResourceSupport {
+    private static final String SCHEME = "cn1res";
+
+    private JdkResourceSupport() {
+    }
+
+    /// Installs both into `Resources`. Idempotent.
+    static void install() {
+        Resources.cn1SetUrlFactory(new Factory());
+        if (Resources.cn1ClassLoader() == null) {
+            ClassLoader parent = Resources.class.getClassLoader();
+            Resources.cn1SetClassLoader(new FlatResourceLoader(parent));
+        }
+    }
+
+    private static URL create(String encodedPath) throws MalformedURLException {
+        return new URL(SCHEME, null, -1, encodedPath, Handler.INSTANCE);
+    }
+
+    private static final class Factory implements Resources.UrlFactory {
+        @Override
+        public URL create(String encodedPath) throws IOException {
+            return JdkResourceSupport.create(encodedPath);
+        }
+    }
+
+    private static final class Handler extends URLStreamHandler {
+        static final Handler INSTANCE = new Handler();
+
+        @Override
+        protected URLConnection openConnection(URL u) {
+            return new Connection(u);
+        }
+    }
+
+    private static final class Connection extends URLConnection {
+        Connection(URL url) {
+            super(url);
+        }
+
+        @Override
+        public void connect() {
+            connected = true;
+        }
+
+        @Override
+        public InputStream getInputStream() throws IOException {
+            InputStream in = Resources.openUrlPath(getURL().getPath());
+            if (in == null) {
+                throw new FileNotFoundException(getURL().toExternalForm());
+            }
+            return in;
+        }
+    }
+
+    /// The application's loader, then the resources the build flattened.
+    private static final class FlatResourceLoader extends ClassLoader {
+        FlatResourceLoader(ClassLoader parent) {
+            super(parent);
+        }
+
+        @Override
+        protected URL findResource(String name) {
+            if (name == null || name.startsWith("/") || !Resources.exists(name)) {
+                return null;
+            }
+            return Resources.getSystemResource(name);
+        }
+
+        @Override
+        protected Enumeration<URL> findResources(String name) {
+            URL url = findResource(name);
+            if (url == null) {
+                return Collections.<URL>emptyEnumeration();
+            }
+            return Collections.enumeration(Collections.singletonList(url));
+        }
+
+        /// A services file is the generated registry's list once one is
+        /// installed, and nothing else: the files the build flattened would
+        /// shadow one another, and would name providers that do not ship.
+        @Override
+        public Enumeration<URL> getResources(String name) throws IOException {
+            if (name != null && name.startsWith(Resources.SERVICES)) {
+                String file = Resources.cn1ServicesFile(name.substring(Resources.SERVICES.length()));
+                if (file != null) {
+                    URL url = new URL(SCHEME, null, -1, "/" + name, new TextHandler(file));
+                    return Collections.enumeration(Collections.singletonList(url));
+                }
+            }
+            return super.getResources(name);
+        }
+    }
+
+    /// Serves one text, as UTF-8, whatever the URL.
+    private static final class TextHandler extends URLStreamHandler {
+        private final String text;
+
+        TextHandler(String text) {
+            this.text = text;
+        }
+
+        @Override
+        protected URLConnection openConnection(URL u) {
+            return new URLConnection(u) {
+                @Override
+                public void connect() {
+                    connected = true;
+                }
+
+                @Override
+                public InputStream getInputStream() throws IOException {
+                    return new ByteArrayInputStream(text.getBytes("UTF-8"));
+                }
+            };
+        }
+    }
+}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/MainThreadRule.java b/maven/compat-testing/src/main/java/com/codename1/compat/testing/MainThreadRule.java
similarity index 93%
rename from maven/android-compat/src/test/java/com/codename1/androidcompat/testing/MainThreadRule.java
rename to maven/compat-testing/src/main/java/com/codename1/compat/testing/MainThreadRule.java
index 7cba00f8c82..bdf39fdcda4 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/testing/MainThreadRule.java
+++ b/maven/compat-testing/src/main/java/com/codename1/compat/testing/MainThreadRule.java
@@ -20,7 +20,7 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.testing;
+package com.codename1.compat.testing;
 
 import com.codename1.ui.Display;
 
@@ -28,7 +28,9 @@
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
 
-/// Runs each test on the Android main thread, which is Codename One's EDT.
+/// Runs each test on the UI thread every compatibility layer maps onto --
+/// Android's main thread, Swing's event dispatch thread, the JavaFX
+/// application thread -- which is Codename One's EDT.
 ///
 /// Until a display exists every thread counts as the main one, so a test
 /// that never starts one passes on the JUnit thread. Tests that run
diff --git a/maven/compat-testing/src/main/java/com/codename1/compat/testing/ReferenceJdk.java b/maven/compat-testing/src/main/java/com/codename1/compat/testing/ReferenceJdk.java
new file mode 100644
index 00000000000..ac342a5334f
--- /dev/null
+++ b/maven/compat-testing/src/main/java/com/codename1/compat/testing/ReferenceJdk.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.compat.testing;
+
+import org.junit.Assume;
+
+/// The JDK the compatibility layers' parity tests compare with.
+///
+/// A parity test runs the same input through a layer class and through the
+/// class of the JDK the test itself runs on, and requires the same answer.
+/// The layers were written to behave as Java 8 does, and the JDK has changed
+/// some of those answers since: where it has, the comparison only means
+/// something on Java 8, which is what the workflows that run these tests
+/// use. A test that depends on such an answer calls [#assume(String)]
+/// first, so that on a later JDK it is reported as skipped, with the reason,
+/// rather than as a difference nobody introduced.
+public final class ReferenceJdk {
+
+    private ReferenceJdk() {
+    }
+
+    /// Whether the tests are running on Java 8.
+    public static boolean isRunning() {
+        return "1.8".equals(System.getProperty("java.specification.version"));
+    }
+
+    /// Skips the calling test unless it runs on Java 8. `changed` completes
+    /// the sentence "After Java 8 the JDK ...".
+    public static void assume(String changed) {
+        Assume.assumeTrue("After Java 8 the JDK " + changed + "; the layer keeps the Java 8 behaviour, and this "
+                + "comparison runs on Java 8 only (this is Java " + System.getProperty("java.specification.version")
+                + ")", isRunning());
+    }
+}
diff --git a/maven/android-compat/src/test/java/com/codename1/impl/ImplementationFactory.java b/maven/compat-testing/src/main/java/com/codename1/impl/ImplementationFactory.java
similarity index 96%
rename from maven/android-compat/src/test/java/com/codename1/impl/ImplementationFactory.java
rename to maven/compat-testing/src/main/java/com/codename1/impl/ImplementationFactory.java
index fc98e18f555..09d44e4eb21 100644
--- a/maven/android-compat/src/test/java/com/codename1/impl/ImplementationFactory.java
+++ b/maven/compat-testing/src/main/java/com/codename1/impl/ImplementationFactory.java
@@ -22,7 +22,7 @@
  */
 package com.codename1.impl;
 
-import com.codename1.androidcompat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.HeadlessImplementation;
 
 /// The port hook Codename One's Display uses to create its implementation.
 /// Every port ships its own; the runtime's tests run on no port, so this one
diff --git a/maven/core-unittests/pom.xml b/maven/core-unittests/pom.xml
index fa0bb8cdf01..03e3e5058b0 100644
--- a/maven/core-unittests/pom.xml
+++ b/maven/core-unittests/pom.xml
@@ -29,6 +29,51 @@
             </resource>
         </resources>
         <plugins>
+            <!--
+            com.codename1.impl.JdkHost, the superclass of the core's
+            CoreJdkHost, belongs to the class library, not the core. It is
+            compiled here from the CLDC11 copy rather than taken from the
+            java-runtime jar: that jar's java.* classes on the analysis class
+            path shadow the JDK's and make SpotBugs report pre-existing core
+            code against CLDC signatures.
+            -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-antrun-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>copy-jdkhost</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>run</goal>
+                        </goals>
+                        <configuration>
+                            <target>
+                                <copy file="${basedir}/../../Ports/CLDC11/src/com/codename1/impl/JdkHost.java"
+                                      todir="${project.build.directory}/generated-sources/jdkhost/com/codename1/impl"/>
+                            </target>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>add-jdkhost-source</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>add-source</goal>
+                        </goals>
+                        <configuration>
+                            <sources>
+                                <source>${project.build.directory}/generated-sources/jdkhost</source>
+                            </sources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
diff --git a/maven/core-unittests/src/test/java/com/codename1/impl/CoreJdkHostInstallTest.java b/maven/core-unittests/src/test/java/com/codename1/impl/CoreJdkHostInstallTest.java
new file mode 100644
index 00000000000..f72487515f3
--- /dev/null
+++ b/maven/core-unittests/src/test/java/com/codename1/impl/CoreJdkHostInstallTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import com.codename1.ui.Display;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/// The core installs its host over the class library's `JdkHost`, which this
+/// module compiles from the `Ports/CLDC11` copy -- the copy the core jar is
+/// built against.
+class CoreJdkHostInstallTest {
+
+    /// Another test in the same JVM may have left a Display running; this
+    /// one is about the host with none.
+    @BeforeEach
+    void withoutADisplay() {
+        if (Display.isInitialized()) {
+            Display.deinitialize();
+        }
+        JdkHost.install(null);
+    }
+
+    @AfterEach
+    void restoreDefaults() {
+        JdkHost.install(null);
+    }
+
+    @Test
+    void installerInstallsTheCoreHost() {
+        assertFalse(JdkHost.get() instanceof CoreJdkHost, "nothing installed yet");
+        CoreJdkHostInstaller.install();
+        assertTrue(JdkHost.get() instanceof CoreJdkHost);
+    }
+
+    @Test
+    void coreHostWithoutADisplay() {
+        CoreJdkHostInstaller.install();
+        JdkHost host = JdkHost.get();
+        // No Display here: the host must answer without one and never block.
+        assertFalse(host.isUiThread());
+        final int[] ran = new int[1];
+        host.blockUi(new Runnable() {
+            @Override
+            public void run() {
+                ran[0]++;
+            }
+        });
+        assertEquals(1, ran[0], "blockUi off the EDT runs the task in place");
+        assertNull(host.property("os.name"));
+        assertNull(host.localeNumberSymbols());
+    }
+}
diff --git a/maven/core-unittests/src/test/java/com/codename1/impl/process/RuntimeExecTest.java b/maven/core-unittests/src/test/java/com/codename1/impl/process/RuntimeExecTest.java
new file mode 100644
index 00000000000..c2f6acd8e12
--- /dev/null
+++ b/maven/core-unittests/src/test/java/com/codename1/impl/process/RuntimeExecTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl.process;
+
+import com.codename1.impl.ImplementationFactory;
+import com.codename1.io.Process;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class RuntimeExecTest {
+    private final ImplementationFactory previous = ImplementationFactory.getInstance();
+    private String[] command;
+    private Map<String, String> environment;
+    private final Map<String, String> inherited = new HashMap<String, String>();
+
+    @BeforeEach void install() {
+        inherited.put("PATH", "/bin");
+        ImplementationFactory.setInstance(new ImplementationFactory() {
+            public Object createProcessSupport() {
+                return new ProcessSupport() {
+                    public Map<String, String> environment() {
+                        return new HashMap<String, String>(inherited);
+                    }
+                    public Process start(String[] args, String dir, Map<String, String> env, boolean merge) {
+                        command = args;
+                        environment = env;
+                        return new Fake();
+                    }
+                };
+            }
+        });
+    }
+
+    @AfterEach void restore() {
+        ImplementationFactory.setInstance(previous);
+    }
+
+    @Test void aCommandStringSplitsAtWhitespaceWithNoQuoting() throws IOException {
+        RuntimeExec.exec(Runtime.getRuntime(), "  ls\t-l \"a b\"\r\n\fx ");
+        assertEquals(Arrays.asList("ls", "-l", "\"a", "b\"", "x"), Arrays.asList(command));
+        assertNull(environment, "no envp inherits the environment");
+    }
+
+    @Test void anEmptyCommandFailsAsJavaSEDoes() {
+        assertThrows(IllegalArgumentException.class, () -> RuntimeExec.exec(Runtime.getRuntime(), ""));
+        assertThrows(IndexOutOfBoundsException.class, () -> RuntimeExec.exec(Runtime.getRuntime(), " \t "));
+        assertThrows(IndexOutOfBoundsException.class, () -> RuntimeExec.exec(Runtime.getRuntime(), new String[0]));
+        assertThrows(NullPointerException.class, () -> RuntimeExec.exec(Runtime.getRuntime(), (String) null));
+        assertThrows(NullPointerException.class, () -> RuntimeExec.exec(null, "ls"));
+    }
+
+    @Test void anArrayIsPassedThroughWordForWord() throws IOException {
+        RuntimeExec.exec(Runtime.getRuntime(), new String[] {"my tool", " a "});
+        assertEquals(Arrays.asList("my tool", " a "), Arrays.asList(command));
+    }
+
+    @Test void envpReplacesTheInheritedEnvironment() throws IOException {
+        RuntimeExec.exec(Runtime.getRuntime(), "tool",
+                new String[] {"A=1", "B==2", "NOEQUALS", "=hidden", "C=3\0junk"});
+        Map<String, String> expected = new HashMap<String, String>();
+        expected.put("A", "1");
+        expected.put("B", "=2");
+        expected.put("C", "3");
+        assertEquals(expected, environment);
+        RuntimeExec.exec(Runtime.getRuntime(), new String[] {"tool"}, new String[0]);
+        assertEquals(new HashMap<String, String>(), environment);
+    }
+
+    @Test void destroyForciblyFallsBackToDestroyAndPidIsUnsupported() {
+        Fake fake = new Fake();
+        assertSame(fake, fake.destroyForcibly());
+        assertEquals(1, fake.destroyed);
+        assertThrows(UnsupportedOperationException.class, fake::pid);
+    }
+
+    /// Implements exactly what is abstract in `java.lang.Process`, as a
+    /// relocated JavaSE subclass would.
+    private static final class Fake extends Process {
+        int destroyed;
+        public OutputStream getOutputStream() {
+            return new ByteArrayOutputStream();
+        }
+        public InputStream getInputStream() {
+            return new ByteArrayInputStream(new byte[0]);
+        }
+        public InputStream getErrorStream() {
+            return new ByteArrayInputStream(new byte[0]);
+        }
+        public int waitFor() {
+            return 0;
+        }
+        public int exitValue() {
+            return 0;
+        }
+        public void destroy() {
+            destroyed++;
+        }
+    }
+}
diff --git a/maven/core-unittests/src/test/java/com/codename1/io/ProcessApiShapeTest.java b/maven/core-unittests/src/test/java/com/codename1/io/ProcessApiShapeTest.java
new file mode 100644
index 00000000000..b50977ed7c2
--- /dev/null
+++ b/maven/core-unittests/src/test/java/com/codename1/io/ProcessApiShapeTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.io;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/// Desktop code compiled against `java.lang.Process` and
+/// `java.lang.ProcessBuilder` is moved onto the core classes by renaming
+/// those two classes and nothing else, so every JavaSE member must exist here
+/// under the descriptor the rename produces -- or be listed as one the device
+/// cannot have. Members newer than the running JDK are simply not seen.
+class ProcessApiShapeTest {
+    private static final Set<String> PROCESS_ABSENT = new HashSet<String>(Arrays.asList(
+            "toHandle()", "onExit()", "info()", "children()", "descendants()",
+            "supportsNormalTermination()",
+            "inputReader()", "inputReader(java.nio.charset.Charset)",
+            "errorReader()", "errorReader(java.nio.charset.Charset)",
+            "outputWriter()", "outputWriter(java.nio.charset.Charset)"));
+    private static final Set<String> BUILDER_ABSENT = new HashSet<String>(Arrays.asList(
+            "inheritIO()",
+            "redirectInput()", "redirectOutput()", "redirectError()",
+            "redirectInput(java.lang.ProcessBuilder$Redirect)",
+            "redirectOutput(java.lang.ProcessBuilder$Redirect)",
+            "redirectError(java.lang.ProcessBuilder$Redirect)",
+            "redirectInput(java.io.File)", "redirectOutput(java.io.File)", "redirectError(java.io.File)",
+            "startPipeline(java.util.List)"));
+
+    @Test void everyJavaSEProcessMemberHasACounterpart() {
+        assertEquals(new ArrayList<String>(), missing(java.lang.Process.class, Process.class, PROCESS_ABSENT));
+    }
+
+    @Test void everyJavaSEProcessBuilderMemberHasACounterpart() {
+        assertEquals(new ArrayList<String>(),
+                missing(java.lang.ProcessBuilder.class, ProcessBuilder.class, BUILDER_ABSENT));
+        assertTrue(Modifier.isFinal(ProcessBuilder.class.getModifiers()));
+        for (Constructor<?> c : java.lang.ProcessBuilder.class.getConstructors()) {
+            try {
+                ProcessBuilder.class.getConstructor(c.getParameterTypes());
+            } catch (NoSuchMethodException ex) {
+                fail("No constructor " + c);
+            }
+        }
+    }
+
+    /// A subclass written against JavaSE implements only what is abstract
+    /// there, so nothing may be abstract here that is concrete there.
+    @Test void aJavaSESubclassImplementsEveryAbstractMethod() throws Exception {
+        for (Method m : Process.class.getMethods()) {
+            if (Modifier.isAbstract(m.getModifiers())) {
+                Method jdk = java.lang.Process.class.getMethod(m.getName(), m.getParameterTypes());
+                assertTrue(Modifier.isAbstract(jdk.getModifiers()), m + " is concrete in JavaSE");
+            }
+        }
+    }
+
+    private static List<String> missing(Class<?> jdk, Class<?> core, Set<String> absent) {
+        List<String> out = new ArrayList<String>();
+        for (Method m : jdk.getDeclaredMethods()) {
+            if (!Modifier.isPublic(m.getModifiers())) {
+                continue;
+            }
+            String key = key(m);
+            if (absent.contains(key)) {
+                continue;
+            }
+            Method mine;
+            try {
+                mine = core.getMethod(m.getName(), m.getParameterTypes());
+            } catch (NoSuchMethodException ex) {
+                out.add(key);
+                continue;
+            }
+            if (!renamed(m.getReturnType()).equals(mine.getReturnType().getName())
+                    || Modifier.isStatic(m.getModifiers()) != Modifier.isStatic(mine.getModifiers())) {
+                out.add(key + " differs");
+            }
+        }
+        return out;
+    }
+
+    private static String renamed(Class<?> type) {
+        if (type == java.lang.Process.class) {
+            return Process.class.getName();
+        }
+        if (type == java.lang.ProcessBuilder.class) {
+            return ProcessBuilder.class.getName();
+        }
+        return type.getName();
+    }
+
+    private static String key(Method m) {
+        StringBuilder sb = new StringBuilder(m.getName()).append('(');
+        Class<?>[] params = m.getParameterTypes();
+        for (int i = 0; i < params.length; i++) {
+            if (i > 0) {
+                sb.append(',');
+            }
+            sb.append(params[i].getName());
+        }
+        return sb.append(')').toString();
+    }
+}
diff --git a/maven/core-unittests/src/test/java/com/codename1/ui/ImageTest.java b/maven/core-unittests/src/test/java/com/codename1/ui/ImageTest.java
index cac3a097609..9306682f256 100644
--- a/maven/core-unittests/src/test/java/com/codename1/ui/ImageTest.java
+++ b/maven/core-unittests/src/test/java/com/codename1/ui/ImageTest.java
@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package com.codename1.ui;
 
 import com.codename1.junit.FormTest;
@@ -116,6 +138,21 @@ void testScaled() {
         assertEquals(75, scaled.getHeight());
     }
 
+    /// A scaled copy is kept and handed out again, which is right only
+    /// while the image is what it was. A port that cannot draw an image at
+    /// a size draws the copy, so a mutable image drawn on a second time went
+    /// on showing what it held the first time.
+    @FormTest
+    void testScaledCopyIsForgottenWhenTheImageIsDrawnOnAgain() {
+        Image source = Image.createImage(100, 100);
+        Image first = source.scaled(50, 75);
+        assertSame(first, source.scaled(50, 75));
+
+        source.getGraphics().fillRect(0, 0, 10, 10);
+
+        assertNotSame(first, source.scaled(50, 75));
+    }
+
     @FormTest
     void testScaledSmallerRatio() {
         Image source = Image.createImage(100, 100);
diff --git a/maven/core-unittests/src/test/java/com/codename1/ui/geom/GeneralPathTest.java b/maven/core-unittests/src/test/java/com/codename1/ui/geom/GeneralPathTest.java
index d0aecfdffb8..5bad3c3179a 100644
--- a/maven/core-unittests/src/test/java/com/codename1/ui/geom/GeneralPathTest.java
+++ b/maven/core-unittests/src/test/java/com/codename1/ui/geom/GeneralPathTest.java
@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package com.codename1.ui.geom;
 
 import com.codename1.junit.UITestBase;
@@ -239,6 +261,63 @@ void testIntersectWithRectangleUpdatesPath() {
         assertNull(path.getCurrentPoint());
     }
 
+    private static GeneralPath roundedRectangle() {
+        // 40,300 to 290,385 with a corner radius of 10.
+        GeneralPath p = new GeneralPath();
+        p.moveTo(50, 300);
+        p.lineTo(280, 300);
+        p.curveTo(285, 300, 290, 305, 290, 310);
+        p.lineTo(290, 375);
+        p.curveTo(290, 380, 285, 385, 280, 385);
+        p.lineTo(50, 385);
+        p.curveTo(45, 385, 40, 380, 40, 375);
+        p.lineTo(40, 310);
+        p.curveTo(40, 305, 45, 300, 50, 300);
+        p.closePath();
+        return p;
+    }
+
+    private static int count(GeneralPath p, int segmentType) {
+        int n = 0;
+        PathIterator it = p.getPathIterator();
+        float[] c = new float[6];
+        while (!it.isDone()) {
+            if (it.currentSegment(c) == segmentType) {
+                n++;
+            }
+            it.next();
+        }
+        return n;
+    }
+
+    /// A shape with curved corners clipped by a rectangle is still ONE
+    /// outline. Every curve used to start a subpath of its own, so a rounded
+    /// rectangle came back as four slivers, one a corner and the edge after
+    /// it, and a port that keeps its shape clip as a path (Android, iOS, the
+    /// browser) filled those: `setClip(shape)` followed by `clipRect` left
+    /// only the outline of the shape to paint in.
+    @Test
+    void testIntersectKeepsACurvedShapeInOnePiece() {
+        GeneralPath whole = roundedRectangle();
+        assertTrue(whole.intersect(0, 0, 320, 640));
+        assertEquals(1, count(whole, PathIterator.SEG_MOVETO));
+        assertEquals(4, count(whole, PathIterator.SEG_CUBICTO));
+        assertTrue(whole.contains(165, 342), "the middle of the shape is inside it");
+        assertFalse(whole.contains(41, 301), "the corner of the bounds is outside the round corner");
+
+        // The rectangle cuts the right end off: the two corners left of the
+        // cut stay, joined to the rest by straight lines.
+        GeneralPath cut = roundedRectangle();
+        assertTrue(cut.intersect(0, 0, 200, 640));
+        assertEquals(1, count(cut, PathIterator.SEG_MOVETO));
+        assertEquals(2, count(cut, PathIterator.SEG_CUBICTO));
+        assertTrue(cut.contains(120, 342));
+        assertFalse(cut.contains(210, 342));
+        float[] b = cut.getBounds2D();
+        assertEquals(40f, b[0], 0.01f);
+        assertEquals(160f, b[2], 0.01f);
+    }
+
     @Test
     void testIsConvexPolygonLogic() {
         // Triangle (convex)
diff --git a/maven/core-unittests/src/test/java/com/codename1/util/regex/RegexDifferentialTest.java b/maven/core-unittests/src/test/java/com/codename1/util/regex/RegexDifferentialTest.java
new file mode 100644
index 00000000000..27e2a0a4d34
--- /dev/null
+++ b/maven/core-unittests/src/test/java/com/codename1/util/regex/RegexDifferentialTest.java
@@ -0,0 +1,516 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.util.regex;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/// A corpus of patterns, each run over a set of inputs through this package's
+/// `Pattern` and through `java.util.regex`: whether it compiles, whether it
+/// matches, every match `find` reports with every group, what a replacement
+/// and a split produce. The two have to agree on all of it.
+class RegexDifferentialTest {
+
+    private static final String[] INPUTS = {"", "a", "abc", "ABC", "aaa", "abab", "abcabc", "hello world",
+        "Hello, World!", "foo123bar", "2024-02-29", "12:34:56", "a,b,,c,", ",a,,b", "  lead and trail  ",
+        "line1\nline2\r\nline3\rline4", "\n", "\r\n", "a\nb", "tab\tsep\tvalues", "x=1;y=22;z=333",
+        "user@example.com", "The quick brown fox", "aAbBcC", "foo.bar.baz", "a|b|c", "(paren) [bracket] {brace}",
+        "1+1=2", "$100.50", "back\\slash", "C:\\dir\\file.txt", "/usr/local/bin", "key: value", "  ", "aXbXc",
+        "abba", "catcat dogdog", "<b>bold</b><i>it</i>", "0x1F 0xff 077", "camelCaseName", "snake_case_name",
+        "commit 1a2b3c4d\nAuthor: someone\nDate: today", "\u001b[31mred\u001b[0m", "caf\u00e9 na\u00efve",
+        "\u00c9COLE \u00e9cole", "a.b", "aab", "xyz", "ab12", "--flag=value", "feature/branch-name",
+        "refs/heads/main", "v1.2.3-rc1", "#comment", "a  b   c", "end.", "foo\n", "foo\r\n", "\nfoo", "aa\n\nbb\n"};
+
+    private static final String[] PATTERNS = {"a", "abc", "a*", "a+", "a?", "a{2}", "a{2,}", "a{1,2}", "a*?", "a+?",
+        "a??", "a{1,2}?", "a*+", "a++", "a?+", "a*+a", ".", ".*", ".+", ".*?", "..", "^", "$", "^$", "^a", "c$",
+        "^abc$", "\\Aa", "c\\z", "c\\Z", "\\z", "\\Z", "\\bfoo\\b", "\\b", "\\B", "\\b\\w+\\b", "\\d", "\\d+",
+        "\\D+", "\\w+", "\\W+", "\\s+", "\\S+", "\\s*", "[abc]", "[^abc]", "[a-c]+", "[^a-c]+", "[a-zA-Z]+",
+        "[a-z0-9_]+", "[\\d.]+", "[\\w.-]+@[\\w.-]+", "[a-z&&[^aeiou]]+", "[a-z&&[def]]", "[a-c[x-z]]+",
+        "[^\\s]+", "[\\[\\]]", "[]a]+", "[a\\-z]+", "[a-]+", "[-a]+", "[.]", "[$^]", "[\\\\/]", "a|b", "a|b|c",
+        "ab|cd", "abc|ab|a", "a|ab|abc", "(a|b)+", "(a|ab)(c|bcd)", "(?:a|b)+c", "x|", "|x", "(a)", "(a)(b)(c)",
+        "(a(b(c)))", "(a)|(b)", "(a)?b", "(a*)*", "(a*)+", "(a|b)*", "(a+)+", "(?:a+)+b", "(ab)+", "(ab)*",
+        "(ab){2}", "(ab){1,2}?", "(ab)?+ab", "(\\w)\\1", "(\\w+) \\1", "(a)(b)\\2\\1", "(?<first>\\w)\\k<first>",
+        "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})", "(\\d+):(\\d+):(\\d+)", "(\\w+)=(\\d+);?",
+        "(?i)abc", "(?i)a(?-i)bc", "(?i:a)bc", "a(?i)b|c", "(?i)[a-c]+", "(?i)[^a-c]+", "(?i)(\\w)\\1",
+        "(?m)^", "(?m)$", "(?m)^\\w+$", "(?m)^line\\d", "(?s).+", "(?s)a.b", "a.b", "(?d).+", "(?d)^.*$",
+        "(?md)^\\w+$", "(?x) a b c # comment", "(?x)a\\ b", "(?ms)^l.*4$", "(?=a)", "(?=a)a", "a(?=b)", "a(?!b)",
+        "(?<=a)b", "(?<!a)b", "(?<=a|bc)b", "(?<=\\d{1,3})\\D", "\\w+(?=,)", "(?<![a-z])\\d+", "(?!foo)\\w+",
+        "(?=(\\w))\\1", "(?>a+)a", "(?>a|ab)c", "(?>a*)", "\\Qa.b\\E", "\\Q.\\E+", "\\Q(paren)\\E", "a\\.b",
+        "\\$\\d+\\.\\d+", "\\(.*?\\)", "\\[.*\\]", "\\{.*\\}", "\\\\", "\\|", "\\t", "\\n", "\\r\\n", "\\r?\\n",
+        "\\x41", "\\u0041", "\\x{41}", "\\0101", "\\011", "\\e\\[[0-9;]*m", "\\u001B\\[[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~]",
+        "\\cA", "\\a", "\\f", "\\h+", "\\H+", "\\v+", "\\V+", "\\p{Alpha}+", "\\p{Digit}+", "\\p{Upper}\\p{Lower}+",
+        "\\p{Punct}+", "\\p{Space}+", "\\p{Alnum}+", "\\P{Alpha}+", "\\p{XDigit}+", "\\p{ASCII}+", "\\p{Blank}+",
+        "\\p{Graph}+", "\\p{Print}+", "\\p{Cntrl}", "\\p{Lu}", "\\p{Ll}+", "\\p{L}+", "\\pL+", "\\PL+",
+        "\\p{IsAlphabetic}+", "\\p{javaLowerCase}+", "\\p{javaUpperCase}+", "\\p{javaWhitespace}+", "\\p{Nd}+",
+        "[\\p{Alpha}\\d]+", "[^\\p{Alpha}]+", "[\\P{Alpha}&&\\S]+", "\\G\\w", "\\Ga", "\\G\\d\\d:?",
+        "^(\\w+)://([^/:]+)(:\\d+)?(/.*)?$", "^[\\w.+-]+@[\\w-]+\\.[\\w.-]+$", "^\\s+|\\s+$", "\\s{2,}",
+        "[,;]\\s*", "\\s*,\\s*", "(?<=[a-z])(?=[A-Z])", "_+", "\\.", "/", "0[xX][0-9a-fA-F]+", "^v?(\\d+)\\.(\\d+)\\.(\\d+)(?:-(\\w+))?$",
+        "<([a-z]+)>(.*?)</\\1>", "<[^>]+>", "^#.*", "^(?:refs/heads/)?(.+)$", "^commit ([0-9a-f]{7,40})$",
+        "(?m)^commit ([0-9a-f]+)$", "(?m)^(\\w+): (.*)$", "^-{1,2}(\\w+)(?:=(.*))?$", "(?i)\\bthe\\b", "(?iu)\\u00e9cole",
+        "(?i)\\u00e9cole", "caf.", "\\w+\\s\\w+", "[^,]*", "[^,]+", ",", "a{0}", "a{0,0}b", "(a{0,2}){2}", "(a|)+",
+        "(|a)+", "(a?)*?b", "(a*)*b", "(?:a?){3}", "(?:){2}", "()", "()*", "(a)*\\1", "\\1(a)", "(?:(a)|b)\\1",
+        "(a)|\\1", "[a-z]+(?:\\.[a-z]+)*", "(?:[a-z]+\\.)*[a-z]+", "\\d{4}-\\d{2}-\\d{2}", "^\\d+$", "^-?\\d+(\\.\\d+)?$",
+        "X", "aXb", "(.)\\1", "(.+)\\1", "(?s)(.)(?=.*\\1)", "^(?!.*\\.\\.)[\\w./-]+$", "[\\x00-\\x1f]", "[\\u0000-\\u007f]+",
+        "[^\\x00-\\x7f]+", "\\x1b", "[\\t ]+", "[ \\t\\n\\x0B\\f\\r]+", "\\S+\\s*$", "(?m)$\\n?", "(?m)^$",
+        // Not patterns at all.
+        "(", ")", "a)", "(a", "[", "[a", "[a-", "[z-a]", "*", "+", "?", "a**", "a{", "a{1", "a{2,1}", "a{x}", "\\",
+        "\\q", "\\k<none>", "(?<n>a)(?<n>b)", "(?<1n>a)", "(?<n", "(?", "(?z)",
+        "\\x4", "\\u004", "\\p{NoSuchThing}", "\\p{Alpha", "[[a]", "\\c", "\\0", "\\08", "x{2}{3}", "(?i", "[a&&]",
+        "\\x{110000}"};
+
+    /// `splitAsStream` and `results()` read their input only as the stream
+    /// asks: a change to a mutable input before the terminal operation is
+    /// seen, and `limit` stops the search.
+    @Test
+    void streamsAreLazy() {
+        StringBuilder text = new StringBuilder("a,b");
+        java.util.stream.Stream<String> mine = Pattern.compile(",").splitAsStream(text);
+        text.append(",c,,");
+        // What JDK 9 and later answer. JDK 8, which this suite also runs on,
+        // bounded the search by the length at the time the stream was made
+        // and answered [a, b,c,,].
+        assertEquals(Arrays.asList("a", "b", "c"), mine.collect(Collectors.toList()));
+        assertEquals(java.util.regex.Pattern.compile(",").splitAsStream("x,y,z").limit(2).collect(Collectors.toList()),
+                Pattern.compile(",").splitAsStream("x,y,z").limit(2).collect(Collectors.toList()));
+        // One empty piece, as split("") answers; JDK 9 and later agree, JDK 8
+        // answered none.
+        assertEquals(Arrays.asList(""), Pattern.compile(",").splitAsStream("").collect(Collectors.toList()));
+
+        Matcher m = Pattern.compile("\\d").matcher("1a2b3");
+        final List<String> found = new ArrayList<String>();
+        m.results().limit(1).forEach(new Consumer<MatchResult>() {
+            @Override
+            public void accept(MatchResult r) {
+                found.add(r.group());
+            }
+        });
+        assertEquals(Arrays.asList("1"), found);
+        // Only the first match was searched for, so the matcher carries on
+        // from it, and results() answers from where the matcher is.
+        assertTrue(m.find());
+        assertEquals("2", m.group());
+        assertEquals(1L, m.results().count());
+        assertEquals(0L, m.results().count());
+    }
+
+    /// Patterns for which a JDK older than the ones applications are
+    /// written against answers differently; they are checked against
+    /// expected values instead.
+    private static final String[] VERSION_DEPENDENT = {"\\R", "\\R+", "a\\Rb", "\\X", "\\N{LATIN SMALL LETTER A}",
+        "\\b{g}", "(?U)\\w", "\\p{IsGreek}", "\\p{InArrows}", "\\p{Sc}", "\\p{IsLatin}"};
+
+    private static String sign(Throwable t) {
+        return t.getClass().getSimpleName();
+    }
+
+    private static String jdk(String regex, int flags, String input) {
+        java.util.regex.Pattern p;
+        try {
+            p = java.util.regex.Pattern.compile(regex, flags);
+        } catch (java.util.regex.PatternSyntaxException e) {
+            return "PatternSyntaxException";
+        }
+        StringBuilder sb = new StringBuilder();
+        try {
+            java.util.regex.Matcher m = p.matcher(input);
+            sb.append(m.matches());
+            m.reset();
+            sb.append(m.lookingAt()).append('|');
+            m.reset();
+            int n = 0;
+            while (m.find() && n++ < 200) {
+                sb.append(m.start()).append('-').append(m.end());
+                for (int g = 1; g <= m.groupCount(); g++) {
+                    sb.append('(').append(m.start(g)).append(',').append(m.end(g)).append(',').append(m.group(g))
+                            .append(')');
+                }
+                sb.append(';');
+            }
+            sb.append('|').append(m.replaceAll("<$0>"));
+            sb.append('|').append(m.replaceFirst("!"));
+            sb.append('|').append(Arrays.toString(p.split(input)));
+            sb.append('|').append(Arrays.toString(p.split(input, -1)));
+            sb.append('|').append(Arrays.toString(p.split(input, 2)));
+            sb.append('|').append(p.splitAsStream(input).collect(Collectors.toList()));
+            // results() is the find loop below; JDK 8 has no Matcher.results().
+            m.reset();
+            sb.append('|');
+            int r = 0;
+            while (m.find() && r++ < 200) {
+                sb.append(m.start()).append('-').append(m.end()).append(m.group()).append(';');
+            }
+            sb.append('|').append(p.flags());
+            sb.append('|').append(m.find(input.length() / 2) ? m.start() : -1);
+            m.region(input.length() / 3, input.length() - input.length() / 4);
+            sb.append('|').append(m.find() ? m.start() + "-" + m.end() : "none");
+            sb.append(m.matches()).append(m.lookingAt());
+        } catch (StackOverflowError e) {
+            return "overflow";
+        } catch (RuntimeException e) {
+            sb.append(sign(e));
+        }
+        return sb.toString();
+    }
+
+    private static String shim(String regex, int flags, String input) {
+        Pattern p;
+        try {
+            p = Pattern.compile(regex, flags);
+        } catch (PatternSyntaxException e) {
+            return "PatternSyntaxException";
+        }
+        StringBuilder sb = new StringBuilder();
+        try {
+            Matcher m = p.matcher(input);
+            sb.append(m.matches());
+            m.reset();
+            sb.append(m.lookingAt()).append('|');
+            m.reset();
+            int n = 0;
+            while (m.find() && n++ < 200) {
+                sb.append(m.start()).append('-').append(m.end());
+                for (int g = 1; g <= m.groupCount(); g++) {
+                    sb.append('(').append(m.start(g)).append(',').append(m.end(g)).append(',').append(m.group(g))
+                            .append(')');
+                }
+                sb.append(';');
+            }
+            sb.append('|').append(m.replaceAll("<$0>"));
+            sb.append('|').append(m.replaceFirst("!"));
+            sb.append('|').append(Arrays.toString(p.split(input)));
+            sb.append('|').append(Arrays.toString(p.split(input, -1)));
+            sb.append('|').append(Arrays.toString(p.split(input, 2)));
+            sb.append('|').append(p.splitAsStream(input).collect(Collectors.toList()));
+            m.reset();
+            final StringBuilder results = sb.append('|');
+            m.results().limit(200).forEach(new Consumer<MatchResult>() {
+                @Override
+                public void accept(MatchResult r) {
+                    results.append(r.start()).append('-').append(r.end()).append(r.group()).append(';');
+                }
+            });
+            sb.append('|').append(p.flags());
+            sb.append('|').append(m.find(input.length() / 2) ? m.start() : -1);
+            m.region(input.length() / 3, input.length() - input.length() / 4);
+            sb.append('|').append(m.find() ? m.start() + "-" + m.end() : "none");
+            sb.append(m.matches()).append(m.lookingAt());
+        } catch (StackOverflowError e) {
+            return "overflow";
+        } catch (RuntimeException e) {
+            sb.append(sign(e));
+        }
+        return sb.toString();
+    }
+
+    private static String show(String s) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c < ' ' || c > '~') {
+                sb.append("\\x").append(Integer.toHexString(c)).append(';');
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    /// Whether this JDK predates JDK-8214245 (fixed in 16), under which the
+    /// case classes ignored CASE_INSENSITIVE. The shim follows the current
+    /// JDK, so on an older one the comparison for them is skipped.
+    private static final boolean JDK_CASE_CLASSES_IGNORE_CASE_FLAG = !java.util.regex.Pattern
+            .compile("\\p{Lu}", java.util.regex.Pattern.CASE_INSENSITIVE).matcher("a").matches();
+
+    private static final String[] CASE_CLASSES = {
+        "Lower}", "Upper}", "Lu}", "Ll}", "javaLowerCase}", "javaUpperCase}", "IsLowercase}", "IsUppercase}"
+    };
+
+    private static boolean namesACaseClass(String regex) {
+        for (String c : CASE_CLASSES) {
+            if (regex.contains("{" + c) || regex.contains("{Is" + c)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Whether this JDK predates JDK-8264160 (fixed in 19), under which `\b`
+    /// took any Unicode letter or digit as a word character rather than the
+    /// ASCII ones `\w` matches. The shim follows the current JDK, so on an
+    /// older one the comparison for boundaries is skipped.
+    private static final boolean JDK_UNICODE_WORD_BOUNDARY = java.util.regex.Pattern
+            .compile("\\b").matcher(String.valueOf((char) 0xe9)).find();
+
+    private static boolean namesAWordBoundary(String regex) {
+        return regex.contains("\\b") || regex.contains("\\B");
+    }
+
+    private static int compare(int flags) {
+        int compared = 0;
+        StringBuilder failures = new StringBuilder();
+        int failed = 0;
+        for (String regex : PATTERNS) {
+            if (JDK_CASE_CLASSES_IGNORE_CASE_FLAG && (flags & java.util.regex.Pattern.CASE_INSENSITIVE) != 0
+                    && (flags & java.util.regex.Pattern.LITERAL) == 0 && namesACaseClass(regex)) {
+                continue;
+            }
+            if (JDK_UNICODE_WORD_BOUNDARY && (flags & java.util.regex.Pattern.LITERAL) == 0
+                    && namesAWordBoundary(regex)) {
+                continue;
+            }
+            boolean reported = false;
+            for (String input : INPUTS) {
+                String expected = jdk(regex, flags, input);
+                String actual = shim(regex, flags, input);
+                compared++;
+                if (!expected.equals(actual)) {
+                    failed++;
+                }
+                if (!expected.equals(actual) && !reported && failures.length() < 6000) {
+                    reported = true;
+                    failures.append("\n/").append(show(regex)).append("/ flags ").append(flags).append(" on \"")
+                            .append(show(input)).append("\"\n  jdk  ").append(show(expected)).append("\n  shim ")
+                            .append(show(actual));
+                }
+                if (expected.equals("PatternSyntaxException")) {
+                    break;
+                }
+            }
+        }
+        if (failed > 0) {
+            fail(failed + " of " + compared + " differ:" + failures);
+        }
+        return compared;
+    }
+
+    @Test
+    void theCorpusAnswersAsTheJdkDoes() {
+        assertTrue(compare(0) > 10000);
+    }
+
+    @Test
+    void theCorpusAnswersAsTheJdkDoesUnderEachFlag() {
+        int compared = compare(java.util.regex.Pattern.CASE_INSENSITIVE);
+        compared += compare(java.util.regex.Pattern.MULTILINE);
+        compared += compare(java.util.regex.Pattern.DOTALL);
+        compared += compare(java.util.regex.Pattern.UNIX_LINES | java.util.regex.Pattern.MULTILINE);
+        compared += compare(java.util.regex.Pattern.CASE_INSENSITIVE | java.util.regex.Pattern.UNICODE_CASE);
+        compared += compare(java.util.regex.Pattern.LITERAL);
+        compared += compare(java.util.regex.Pattern.LITERAL | java.util.regex.Pattern.CASE_INSENSITIVE);
+        assertTrue(compared > 70000);
+    }
+
+    @Test
+    void theFlagConstantsAreTheJdkValues() {
+        assertEquals(java.util.regex.Pattern.UNIX_LINES, Pattern.UNIX_LINES);
+        assertEquals(java.util.regex.Pattern.CASE_INSENSITIVE, Pattern.CASE_INSENSITIVE);
+        assertEquals(java.util.regex.Pattern.COMMENTS, Pattern.COMMENTS);
+        assertEquals(java.util.regex.Pattern.MULTILINE, Pattern.MULTILINE);
+        assertEquals(java.util.regex.Pattern.LITERAL, Pattern.LITERAL);
+        assertEquals(java.util.regex.Pattern.DOTALL, Pattern.DOTALL);
+        assertEquals(java.util.regex.Pattern.UNICODE_CASE, Pattern.UNICODE_CASE);
+        assertEquals(java.util.regex.Pattern.CANON_EQ, Pattern.CANON_EQ);
+        assertEquals(java.util.regex.Pattern.UNICODE_CHARACTER_CLASS, Pattern.UNICODE_CHARACTER_CLASS);
+        assertEquals(Pattern.CASE_INSENSITIVE | Pattern.DOTALL, Pattern.compile("a", 34).flags());
+        assertEquals("a+", Pattern.compile("a+").pattern());
+        assertEquals("a+", Pattern.compile("a+").toString());
+    }
+
+    @Test
+    void quotingAndReplacementSyntaxAreTheJdks() {
+        String[] texts = {"", "a.b", "\\E", "a\\Eb\\E", "$1", "\\Q", "a\\Qb\\Ec", "1+1", "\\"};
+        for (String t : texts) {
+            assertEquals(java.util.regex.Pattern.quote(t), Pattern.quote(t));
+            assertTrue(Pattern.compile(Pattern.quote(t)).matcher(t).matches());
+            assertEquals(java.util.regex.Matcher.quoteReplacement(t), Matcher.quoteReplacement(t));
+            assertEquals(t, Pattern.compile("x").matcher("x").replaceAll(Matcher.quoteReplacement(t)));
+        }
+        String[] replacements = {"$1", "$2$1", "${word}", "\\$1", "$0$0", "[$1]", "$10", "$3", "$", "\\", "${none}",
+            "${", "${word", "$x", "a\\\\b", "${1}", "$1 0"};
+        for (String r : replacements) {
+            String expected;
+            try {
+                expected = java.util.regex.Pattern.compile("(?<word>\\w+) (\\d+)").matcher("abc 123, de 45")
+                        .replaceAll(r);
+            } catch (RuntimeException e) {
+                expected = sign(e);
+            }
+            String actual;
+            try {
+                actual = Pattern.compile("(?<word>\\w+) (\\d+)").matcher("abc 123, de 45").replaceAll(r);
+            } catch (RuntimeException e) {
+                actual = sign(e);
+            }
+            assertEquals(expected, actual, "replacement " + r);
+        }
+    }
+
+    @Test
+    void groupsAreReadByNameAndAfterTheMatcherMovedOn() {
+        Matcher m = Pattern.compile("(?<key>\\w+)=(?<value>\\d+)").matcher("a=1 bb=22");
+        java.util.regex.Matcher j = java.util.regex.Pattern.compile("(?<key>\\w+)=(?<value>\\d+)")
+                .matcher("a=1 bb=22");
+        assertTrue(m.find());
+        assertTrue(j.find());
+        MatchResult kept = m.toMatchResult();
+        assertEquals(j.group("key"), m.group("key"));
+        assertEquals(j.start("value"), m.start("value"));
+        assertEquals(j.end("value"), m.end("value"));
+        assertTrue(m.find());
+        assertEquals("a=1", kept.group());
+        assertEquals("1", kept.group(2));
+        assertEquals(2, kept.groupCount());
+        assertEquals("bb", m.group("key"));
+        try {
+            m.group("none");
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage().contains("none"));
+        }
+        try {
+            Pattern.compile("a").matcher("b").group();
+            fail();
+        } catch (IllegalStateException expected) {
+            assertEquals("No match found", expected.getMessage());
+        }
+        StringBuffer sb = new StringBuffer();
+        Matcher r = Pattern.compile("\\d").matcher("a1b2c");
+        while (r.find()) {
+            r.appendReplacement(sb, "#");
+        }
+        r.appendTail(sb);
+        assertEquals("a#b#c", sb.toString());
+        assertEquals("A1B2C", Pattern.compile("[a-z]").matcher("a1b2c").replaceAll(
+                new java.util.function.Function<MatchResult, String>() {
+                    @Override
+                    public String apply(MatchResult x) {
+                        return x.group().toUpperCase();
+                    }
+                }));
+        assertEquals(Pattern.CASE_INSENSITIVE, Pattern.compile("a(?i)b").flags());
+        assertEquals(0, Pattern.compile("(a(?i)b)c").flags());
+        assertEquals(0, Pattern.compile("(?-i)x", Pattern.CASE_INSENSITIVE).flags());
+        assertTrue(Pattern.compile("b").asPredicate().test("abc"));
+        assertTrue(!Pattern.compile("b").asMatchPredicate().test("abc"));
+        assertTrue(Pattern.matches("a+", "aaa"));
+    }
+
+    @Test
+    void aLineBreakIsOneMatchWhateverItsCharacters() {
+        assertEquals("a|b|c|d|e", Pattern.compile("\\R").matcher("a\nb\r\nc\rd\u2028e").replaceAll("|"));
+        assertTrue(Pattern.compile("a\\Rb").matcher("a\r\nb").matches());
+        assertTrue(!Pattern.compile("a\\R\\nb").matcher("a\r\nb").matches());
+        assertEquals(2, Pattern.compile("\\R").split("x\r\ny").length);
+    }
+
+    /// What this runtime does not have says so when the pattern is compiled,
+    /// naming the construct, and never matches something else instead.
+    @Test
+    void whatIsNotSupportedIsRefusedByName() {
+        String[][] refused = {{"\\X", "\\X"}, {"\\N{LATIN SMALL LETTER A}", "\\N"}, {"\\b{g}", "\\b{"},
+            {"(?U)\\w", "(?U)"}, {"\\p{IsGreek}", "IsGreek"}, {"\\p{InArrows}", "InArrows"}, {"\\p{Sc}", "Sc"},
+            {"\\p{IsLatin}", "IsLatin"}, {"[\\x{1F600}]", "U+FFFF"}};
+        // A look-behind with no upper bound is refused as current JDKs do.
+        for (String unbounded : new String[] {"(?<=a*)b", "(?<=a+)b", "(?<!\\w+)x"}) {
+            try {
+                Pattern.compile(unbounded);
+                fail(unbounded + " compiled");
+            } catch (PatternSyntaxException e) {
+                assertTrue(e.getDescription().contains("maximum length"));
+            }
+        }
+        for (String[] r : refused) {
+            try {
+                Pattern.compile(r[0]);
+                fail(r[0] + " compiled");
+            } catch (PatternSyntaxException e) {
+                assertTrue(e.getDescription().contains(r[1]), e.getMessage());
+                assertTrue(e.getDescription().contains("not supported by the Codename One runtime"), e.getMessage());
+                assertEquals(r[0], e.getPattern());
+            }
+        }
+        for (int flag : new int[] {Pattern.CANON_EQ, Pattern.UNICODE_CHARACTER_CLASS}) {
+            try {
+                Pattern.compile("a", flag);
+                fail();
+            } catch (UnsupportedOperationException e) {
+                assertTrue(e.getMessage().contains("not supported"));
+            }
+        }
+        assertEquals(11, VERSION_DEPENDENT.length);
+    }
+
+    @Test
+    void aCodePointAboveTheBasicPlaneIsMatchedAsWritten() {
+        String smile = new String(Character.toChars(0x1F600));
+        assertTrue(Pattern.compile("a\\x{1F600}b").matcher("a" + smile + "b").matches());
+        assertTrue(Pattern.compile("a" + smile + "+b").matcher("a" + smile + smile + "b").matches());
+        assertTrue(Pattern.compile(smile).matcher("x" + smile).find());
+    }
+
+    @Test
+    void aSingleCharacterRepeatsOverALongTextWithoutRecursing() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 200000; i++) {
+            sb.append(i % 7 == 0 ? 'b' : 'a');
+        }
+        sb.append('!');
+        String text = sb.toString();
+        assertTrue(Pattern.compile(".*!").matcher(text).matches());
+        assertTrue(Pattern.compile("[ab]+!").matcher(text).matches());
+        assertTrue(Pattern.compile("(?:a|b)*!").matcher(text).matches());
+        assertTrue(Pattern.compile("\\w*?!").matcher(text).matches());
+        assertEquals(text.length() - 1, Pattern.compile("!").matcher(text).replaceAll("").length());
+    }
+
+    @Test
+    void theStringMethodsTakeTheJdkSyntax() {
+        String[] texts = {"a,b,,c,,", "", "  two  spaces ", "a1b22c333", "x", ",", "a.b.c", "a|b", "tab\there"};
+        String[] regexes = {",", "\\s+", "\\d+", "\\.", ".", "|", "\\|", "[,.]", "x", "", "(?<=\\d)(?=[a-z])", "\\t",
+            "a", ",+"};
+        int compared = 0;
+        for (String t : texts) {
+            for (String r : regexes) {
+                for (int limit : new int[] {0, -1, 1, 2, 5}) {
+                    assertEquals(Arrays.toString(t.split(r, limit)), Arrays.toString(StringRegex.split(t, r, limit)),
+                            t + " split " + r + " " + limit);
+                    compared++;
+                }
+                assertEquals(Arrays.toString(t.split(r)), Arrays.toString(StringRegex.split(t, r)));
+                assertEquals(t.matches(r), StringRegex.matches(t, r));
+                assertEquals(t.replaceAll(r, "-"), StringRegex.replaceAll(t, r, "-"));
+                assertEquals(t.replaceFirst(r, "<$0>"), StringRegex.replaceFirst(t, r, "<$0>"));
+            }
+        }
+        assertTrue(compared > 500);
+    }
+}
diff --git a/maven/core-unittests/src/test/java/com/codename1/util/regex/StringRegexTest.java b/maven/core-unittests/src/test/java/com/codename1/util/regex/StringRegexTest.java
new file mode 100644
index 00000000000..92c9e4f03a8
--- /dev/null
+++ b/maven/core-unittests/src/test/java/com/codename1/util/regex/StringRegexTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.util.regex;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/// Holds [StringRegex], the stand-in for the regular expression methods of
+/// `java.lang.String`, to the answers of the JDK's own `String`.
+class StringRegexTest {
+
+    private static final String[] INPUTS = {"", "a", "a,b,c", ",a,,b,", ",,,", "a, b ,c", "one  two   three",
+        "key=value=more", "a.b.c", "a|b|c", "x1y22z333", "  lead", "trail  ", "a\tb\nc d", "abc", "aXbxc",
+        "1+2-3*4", "a$b$c", "\\a\\b", "a^b", "boo:and:foo", "a::b", "(a)(b)", "a[1]b[2]"};
+
+    private static final String[] REGEXES = {",", ", *", "\\s+", " ", "=", "\\.", "\\|", "[0-9]+", "\\d", "\\t",
+        "", "b", "[xX]", "[+*-]", "\\$", "\\\\", "\\^", ":", "o", "::", "[()]", "\\[|\\]", "a|c", ",|=", "\\s*,\\s*",
+        "$", "z"};
+
+    @Test
+    void splitMatchesTheJdkOverEveryInputAndPattern() {
+        for (String input : INPUTS) {
+            for (String regex : REGEXES) {
+                String at = "\"" + input + "\".split(\"" + regex + "\")";
+                assertEquals(Arrays.asList(input.split(regex)), Arrays.asList(StringRegex.split(input, regex)), at);
+            }
+        }
+    }
+
+    @Test
+    void splitWithALimitMatchesTheJdk() {
+        int[] limits = {-1, 0, 1, 2, 3, 5, 100};
+        for (String input : INPUTS) {
+            for (String regex : REGEXES) {
+                for (int limit : limits) {
+                    String at = "\"" + input + "\".split(\"" + regex + "\", " + limit + ")";
+                    assertEquals(Arrays.asList(input.split(regex, limit)),
+                            Arrays.asList(StringRegex.split(input, regex, limit)), at);
+                }
+            }
+        }
+    }
+
+    @Test
+    void theOtherMembersMatchTheJdk() {
+        for (String input : INPUTS) {
+            for (String regex : REGEXES) {
+                String at = "\"" + input + "\" with \"" + regex + "\"";
+                assertEquals(input.matches(regex), StringRegex.matches(input, regex), at);
+                assertEquals(input.replaceAll(regex, "<$0>"), StringRegex.replaceAll(input, regex, "<$0>"), at);
+                assertEquals(input.replaceFirst(regex, "[$0]"), StringRegex.replaceFirst(input, regex, "[$0]"), at);
+            }
+        }
+    }
+
+    @Test
+    void splitRefusesNull() {
+        try {
+            StringRegex.split("a", null);
+            fail();
+        } catch (NullPointerException expected) {
+            // As the JDK's.
+        }
+        try {
+            StringRegex.split(null, ",");
+            fail();
+        } catch (NullPointerException expected) {
+            // As a call on null would.
+        }
+    }
+}
diff --git a/maven/core/pom.xml b/maven/core/pom.xml
index a069cc54b1c..273642b2e51 100644
--- a/maven/core/pom.xml
+++ b/maven/core/pom.xml
@@ -19,6 +19,15 @@
             <artifactId>codenameone-factory</artifactId>
             <scope>provided</scope>
         </dependency>
+        <!-- com.codename1.impl.JdkHost, the superclass of CoreJdkHost. It
+             belongs to the class library (Ports/CLDC11 here, vm/JavaAPI on
+             device), so the core compiles against it and does not ship it;
+             the Java SE and Android ports carry their own copy. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>java-runtime</artifactId>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
     <properties>
         <java.version>1.5</java.version>
diff --git a/maven/fxml-compiler/pom.xml b/maven/fxml-compiler/pom.xml
new file mode 100644
index 00000000000..cd0667154cd
--- /dev/null
+++ b/maven/fxml-compiler/pom.xml
@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+
+    <parent>
+        <groupId>com.codenameone</groupId>
+        <artifactId>codenameone</artifactId>
+        <version>8.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>codenameone-fxml-compiler</artifactId>
+    <version>8.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>codenameone-fxml-compiler</name>
+    <description>
+        Build-time compiler for the FXML documents and JavaFX style sheets of
+        an application that uses the JavaFX compatibility layer. An FXML
+        document becomes Java source that builds the same tree with plain
+        constructors and setters; a style sheet becomes the binary table the
+        layer's style engine reads; and the members a controller marks @FXML
+        are reached by a generated dispatcher instead of by reflection.
+    </description>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <fxml.shared.css.source>${project.basedir}/../javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css</fxml.shared.css.source>
+        <fxml.shared.css.dir>${project.build.directory}/generated-sources/fxml-shared-css</fxml.shared.css.dir>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-antrun-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <!--
+                             The style value parser and the compiled sheet's
+                             reader and writer have ONE copy, in javafx-compat,
+                             where the device runs them. The compiler runs the
+                             same sources: they are copied here under a package
+                             of this module's own rather than depended on,
+                             because the build tools must not have the JavaFX
+                             layer on their class path (the Maven plugin keeps
+                             it "provided" so that an application's own version
+                             is the only one there is).
+                        -->
+                        <id>copy-shared-css-sources</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>run</goal>
+                        </goals>
+                        <configuration>
+                            <target>
+                                <copy todir="${fxml.shared.css.dir}/com/codename1/fxml/css" overwrite="false"
+                                      encoding="UTF-8">
+                                    <fileset dir="${fxml.shared.css.source}" includes="*.java"
+                                             excludes="package-info.java"/>
+                                    <filterchain>
+                                        <replacestring from="com.codename1.fxcompat.runtime.css"
+                                                       to="com.codename1.fxml.css"/>
+                                    </filterchain>
+                                </copy>
+                            </target>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>add-shared-css-sources</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>add-source</goal>
+                        </goals>
+                        <configuration>
+                            <sources>
+                                <source>${fxml.shared.css.dir}</source>
+                            </sources>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>com.github.spotbugs</groupId>
+                <artifactId>spotbugs-maven-plugin</artifactId>
+                <version>4.7.3.4</version>
+                <configuration>
+                    <effort>Max</effort>
+                    <threshold>Low</threshold>
+                    <failOnError>false</failOnError>
+                    <xmlOutput>true</xmlOutput>
+                    <xmlOutputDirectory>${project.build.directory}</xmlOutputDirectory>
+                    <excludeFilterFile>${project.basedir}/spotbugs-exclude.xml</excludeFilterFile>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>spotbugs</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>spotbugs</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <profiles>
+        <!-- Some JDK 8 distributions bundle JavaFX as an extension
+             (jre/lib/ext/jfxrt.jar), and an extension is found before the
+             class path. The main sources still compile there, because they
+             ARE the javafx classes, but the tests then meet the JDK's
+             javafx.scene.control.Control in place of this module's, at
+             compile time and again when they run. The extension directory
+             is pointed at nothing; the option does not exist after JDK 8,
+             where JavaFX is not part of the JDK either. -->
+        <profile>
+            <id>jdk8-without-bundled-javafx</id>
+            <activation>
+                <jdk>1.8</jdk>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <artifactId>maven-compiler-plugin</artifactId>
+                        <configuration>
+                            <compilerArgs>
+                                <arg>-extdirs</arg>
+                                <arg>${project.build.directory}/no-jdk-extensions</arg>
+                            </compilerArgs>
+                        </configuration>
+                    </plugin>
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <configuration>
+                            <argLine>-Djava.ext.dirs=${project.build.directory}/no-jdk-extensions</argLine>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+
+    <dependencies>
+        <!-- ResourceNames: the one rule for the flat name a resource ships
+             under, which the compiled style sheets are named by. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- Test scope only: the tests compile what the compiler generates
+             against the layer and run it. The compiler itself reads the
+             layer's class files as data, from the application's class path. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-javafx-compat</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-compat-testing</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/maven/fxml-compiler/spotbugs-exclude.xml b/maven/fxml-compiler/spotbugs-exclude.xml
new file mode 100644
index 00000000000..bf1c6466e52
--- /dev/null
+++ b/maven/fxml-compiler/spotbugs-exclude.xml
@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+    <!--
+        The shared style classes are copied from javafx-compat, where the
+        device runs them, and are written for that runtime: a value and a
+        selector take the arrays they are given and hand out no copies,
+        because a device cannot afford one per value and every caller is the
+        parser or the reader that just made the array. The same classes are
+        analysed, with the same reasoning, in javafx-compat.
+    -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.fxml.css.CssValue"/>
+            <Class name="com.codename1.fxml.css.CssSelector"/>
+            <Class name="com.codename1.fxml.css.CssSheetData"/>
+        </Or>
+        <Bug pattern="EI_EXPOSE_REP2"/>
+    </Match>
+
+    <!--
+        The value parser answers null for a list of gradient stops it could
+        not read, with the reason in error(); an empty array would be a
+        gradient without stops, which is a different thing. Copied from
+        javafx-compat like the classes above.
+    -->
+    <Match>
+        <Class name="com.codename1.fxml.css.CssValueParser"/>
+        <Method name="stops"/>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+
+    <!--
+        null is "the class path has no such class", which every caller
+        tests; an empty array would be a class file of no bytes.
+    -->
+    <Match>
+        <Class name="com.codename1.fxml.ClassModel"/>
+        <Method name="bytes"/>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+
+    <!--
+        These fields are filled by the reader that creates the object, before
+        anything else sees it: a class's name by the ASM visitor that reads
+        its file (ClassModel.read answers only what visit() named), a
+        document's root by the SAX handler (FxmlDocument.parse answers null
+        instead of a document without one), and the handler's locator by the
+        parser, which SAX requires to call setDocumentLocator first.
+    -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.fxml.ClassModel$Info"/>
+            <Class name="com.codename1.fxml.FxmlDocument"/>
+            <Class name="com.codename1.fxml.FxmlDocument$1"/>
+        </Or>
+        <Bug pattern="UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR"/>
+    </Match>
+</FindBugsFilter>
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/ClassModel.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/ClassModel.java
new file mode 100644
index 00000000000..4cfa7658d04
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/ClassModel.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+/// What the FXML compiler knows about the classes a document names: their
+/// constructors, setters, getters and constants, read out of the class
+/// files on the application's class path.
+///
+/// No class is ever loaded. The class path is the application's, built for
+/// a device, and running a static initializer of it inside the build would
+/// be running device code on the build machine; a class file read as data
+/// says everything the compiler asks. Classes of the JDK itself are read
+/// the same way, as resources of the build's own runtime.
+final class ClassModel implements Closeable {
+
+    /// One method or constructor.
+    static final class Method {
+        final String name;
+        final String descriptor;
+        final String signature;
+        final int access;
+        final Type[] parameters;
+        /// The `@NamedArg` name of each parameter, `null` where one has
+        /// none.
+        final String[] argNames;
+        /// The `@NamedArg` default of each parameter, `null` where none
+        /// was given.
+        final String[] argDefaults;
+
+        Method(String name, String descriptor, String signature, int access) {
+            this.name = name;
+            this.descriptor = descriptor;
+            this.signature = signature;
+            this.access = access;
+            this.parameters = Type.getArgumentTypes(descriptor);
+            this.argNames = new String[parameters.length];
+            this.argDefaults = new String[parameters.length];
+        }
+
+        boolean isPublic() {
+            return (access & Opcodes.ACC_PUBLIC) != 0;
+        }
+
+        boolean isStatic() {
+            return (access & Opcodes.ACC_STATIC) != 0;
+        }
+
+        Type returnType() {
+            return Type.getReturnType(descriptor);
+        }
+
+        boolean allArgsNamed() {
+            for (int i = 0; i < argNames.length; i++) {
+                if (argNames[i] == null) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    /// One field.
+    static final class Field {
+        final String name;
+        final String descriptor;
+        final int access;
+
+        Field(String name, String descriptor, int access) {
+            this.name = name;
+            this.descriptor = descriptor;
+            this.access = access;
+        }
+    }
+
+    /// One class.
+    static final class Info {
+        String name;
+        String superName;
+        String[] interfaces = new String[0];
+        int access;
+        String defaultProperty;
+        final List<Method> methods = new ArrayList<Method>();
+        final List<Field> fields = new ArrayList<Field>();
+
+        boolean isEnum() {
+            return (access & Opcodes.ACC_ENUM) != 0;
+        }
+
+        boolean isAbstract() {
+            return (access & (Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE)) != 0;
+        }
+
+        boolean isPublic() {
+            return (access & Opcodes.ACC_PUBLIC) != 0;
+        }
+
+        /// The name as Java source spells it.
+        String sourceName() {
+            return name.replace('/', '.').replace('$', '.');
+        }
+    }
+
+    private static final Info ABSENT = new Info();
+
+    private final List<File> directories = new ArrayList<File>();
+    private final List<ZipFile> jars = new ArrayList<ZipFile>();
+    private final Map<String, Info> cache = new HashMap<String, Info>();
+    private final String namedArg;
+    private final String defaultProperty;
+
+    /// Creates a model over a class path of directories and jars. Entries
+    /// that do not exist are ignored, as javac ignores them.
+    ClassModel(List<File> classpath) throws IOException {
+        this(classpath, "Ljavafx/beans/NamedArg;", "Ljavafx/beans/DefaultProperty;");
+    }
+
+    ClassModel(List<File> classpath, String namedArgDescriptor, String defaultPropertyDescriptor)
+            throws IOException {
+        this.namedArg = namedArgDescriptor;
+        this.defaultProperty = defaultPropertyDescriptor;
+        for (File f : classpath) {
+            if (f.isDirectory()) {
+                directories.add(f);
+            } else if (f.isFile()) {
+                jars.add(new ZipFile(f));
+            }
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        IOException first = null;
+        for (ZipFile jar : jars) {
+            try {
+                jar.close();
+            } catch (IOException e) {
+                first = first == null ? e : first;
+            }
+        }
+        jars.clear();
+        if (first != null) {
+            throw first;
+        }
+    }
+
+    private byte[] bytes(String internalName) throws IOException {
+        String entry = internalName + ".class";
+        for (File dir : directories) {
+            File f = new File(dir, entry);
+            if (f.isFile()) {
+                InputStream in = new FileInputStream(f);
+                try {
+                    return drain(in);
+                } finally {
+                    in.close();
+                }
+            }
+        }
+        for (ZipFile jar : jars) {
+            ZipEntry e = jar.getEntry(entry);
+            if (e != null) {
+                InputStream in = jar.getInputStream(e);
+                try {
+                    return drain(in);
+                } finally {
+                    in.close();
+                }
+            }
+        }
+        if (internalName.startsWith("java/")) {
+            InputStream in = ClassLoader.getSystemResourceAsStream(entry);
+            if (in != null) {
+                try {
+                    return drain(in);
+                } finally {
+                    in.close();
+                }
+            }
+        }
+        return null;
+    }
+
+    private static byte[] drain(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] buffer = new byte[8192];
+        int n;
+        while ((n = in.read(buffer)) > 0) {
+            out.write(buffer, 0, n);
+        }
+        return out.toByteArray();
+    }
+
+    /// The class of an internal name (`javafx/scene/control/Button`), or
+    /// `null` when the class path has none.
+    Info find(String internalName) throws IOException {
+        Info known = cache.get(internalName);
+        if (known == null) {
+            byte[] bytes = bytes(internalName);
+            known = bytes == null ? ABSENT : read(bytes);
+            cache.put(internalName, known);
+        }
+        return known == ABSENT ? null : known;
+    }
+
+    private Info read(byte[] bytes) {
+        final Info info = new Info();
+        new ClassReader(bytes).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public void visit(int version, int access, String name, String signature, String superName,
+                    String[] interfaces) {
+                info.name = name;
+                info.superName = superName;
+                info.access = access;
+                info.interfaces = interfaces == null ? new String[0] : interfaces;
+            }
+
+            @Override
+            public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
+                if (!defaultProperty.equals(descriptor)) {
+                    return null;
+                }
+                return new AnnotationVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visit(String name, Object value) {
+                        if ("value".equals(name) && value instanceof String) {
+                            info.defaultProperty = (String) value;
+                        }
+                    }
+                };
+            }
+
+            @Override
+            public FieldVisitor visitField(int access, String name, String descriptor, String signature,
+                    Object value) {
+                info.fields.add(new Field(name, descriptor, access));
+                return null;
+            }
+
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                if ((access & (Opcodes.ACC_SYNTHETIC | Opcodes.ACC_BRIDGE)) != 0) {
+                    return null;
+                }
+                final Method m = new Method(name, descriptor, signature, access);
+                info.methods.add(m);
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public AnnotationVisitor visitParameterAnnotation(final int parameter, String annotation,
+                            boolean visible) {
+                        if (!namedArg.equals(annotation) || parameter >= m.argNames.length) {
+                            return null;
+                        }
+                        return new AnnotationVisitor(Opcodes.ASM9) {
+                            @Override
+                            public void visit(String key, Object value) {
+                                if ("value".equals(key) && value instanceof String) {
+                                    m.argNames[parameter] = (String) value;
+                                } else if ("defaultValue".equals(key) && value instanceof String) {
+                                    m.argDefaults[parameter] = (String) value;
+                                }
+                            }
+                        };
+                    }
+                };
+            }
+        }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return info;
+    }
+
+    /// Whether a value of the class `from` can be assigned to a variable of
+    /// the class `to`. A class the class path does not have is assumed not
+    /// to be assignable to anything but itself and `Object`.
+    boolean isAssignable(String from, String to) throws IOException {
+        if (from.equals(to) || "java/lang/Object".equals(to)) {
+            return true;
+        }
+        Info info = find(from);
+        if (info == null) {
+            return false;
+        }
+        if (info.superName != null && isAssignable(info.superName, to)) {
+            return true;
+        }
+        for (String i : info.interfaces) {
+            if (isAssignable(i, to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The public methods named `name` of a class and of everything it
+    /// extends or implements, the most derived first.
+    List<Method> methods(String internalName, String name) throws IOException {
+        List<Method> out = new ArrayList<Method>();
+        collect(internalName, name, out, new ArrayList<String>());
+        return out;
+    }
+
+    private void collect(String internalName, String name, List<Method> out, List<String> seen)
+            throws IOException {
+        if (internalName == null || seen.contains(internalName)) {
+            return;
+        }
+        seen.add(internalName);
+        Info info = find(internalName);
+        if (info == null) {
+            return;
+        }
+        for (Method m : info.methods) {
+            if (m.name.equals(name) && m.isPublic()) {
+                boolean shadowed = false;
+                for (Method have : out) {
+                    shadowed |= have.descriptor.equals(m.descriptor);
+                }
+                if (!shadowed) {
+                    out.add(m);
+                }
+            }
+        }
+        collect(info.superName, name, out, seen);
+        for (String i : info.interfaces) {
+            collect(i, name, out, seen);
+        }
+    }
+
+    /// The default property of a class: what `@DefaultProperty` says on it
+    /// or on the nearest class above it that has one, or `null`.
+    String annotatedDefaultProperty(String internalName) throws IOException {
+        String at = internalName;
+        while (at != null) {
+            Info info = find(at);
+            if (info == null) {
+                return null;
+            }
+            if (info.defaultProperty != null) {
+                return info.defaultProperty;
+            }
+            at = info.superName;
+        }
+        return null;
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/CssCompiler.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/CssCompiler.java
new file mode 100644
index 00000000000..55ba5d52074
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/CssCompiler.java
@@ -0,0 +1,361 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.fxml.css.CssDeclaration;
+import com.codename1.fxml.css.CssDeclarations;
+import com.codename1.fxml.css.CssProperties;
+import com.codename1.fxml.css.CssSelector;
+import com.codename1.fxml.css.CssSheetData;
+import com.codename1.fxml.css.CssValueParser;
+
+/// Compiles one JavaFX style sheet into the table the device reads
+/// ([CssSheetData]).
+///
+/// #### What is an error and what is a warning
+///
+/// A style sheet written for the desktop names properties this layer does
+/// not have and values it cannot draw, and JavaFX itself only logs those.
+/// So a declaration that cannot be used -- an unknown property, a value
+/// that does not parse, a selector form that is not supported -- is a
+/// WARNING with its file and line, and is left out of the table. A sheet
+/// whose structure is broken -- a block that is never closed, a `}` with no
+/// block, declarations with no selector -- is an ERROR: nothing after that
+/// point can be trusted to mean what the author wrote.
+///
+/// #### At-rules
+///
+/// `@import` is resolved against the sheet's own path and recorded; the
+/// device reads the imported table first. `@font-face` is recorded as a
+/// family and the font file it names; the device loads the file when it
+/// reads the sheet, and the family is one more name of that font. Any
+/// other at-rule is skipped with a warning.
+public final class CssCompiler {
+
+    private final String file;
+    private final String path;
+    private final String text;
+    private final Messages messages;
+    private final Set<String> knownSheets;
+    private final CssValueParser parser = new CssValueParser();
+
+    private final List<String> imports = new ArrayList<String>();
+    private final List<String> fontFamilies = new ArrayList<String>();
+    private final List<String> fontSources = new ArrayList<String>();
+    private final List<CssSelector> selectors = new ArrayList<CssSelector>();
+    private final List<Integer> selectorBlocks = new ArrayList<Integer>();
+    private final List<CssDeclaration[]> blocks = new ArrayList<CssDeclaration[]>();
+
+    private CssCompiler(String file, String path, String text, Set<String> knownSheets, Messages messages) {
+        this.file = file;
+        this.path = path;
+        // An address in a value -- the picture of a background -- is
+        // written from where the sheet is.
+        int directory = path == null ? -1 : path.lastIndexOf('/');
+        parser.setBase(directory < 0 ? "" : path.substring(0, directory + 1));
+        this.text = CssDeclarations.stripComments(text);
+        this.knownSheets = knownSheets;
+        this.messages = messages;
+    }
+
+    /// Compiles a style sheet. Answers `null`, with the reason recorded as
+    /// an error, for a sheet whose structure is broken.
+    ///
+    /// #### Parameters
+    ///
+    /// - `file`: the file as messages name it
+    ///
+    /// - `path`: the resource path of the sheet, without a leading slash,
+    ///   which its imports are relative to
+    ///
+    /// - `text`: the content of the sheet
+    ///
+    /// - `knownSheets`: the resource paths of every style sheet of the
+    ///   application, to warn about an import of none of them; `null` to
+    ///   skip that check
+    ///
+    /// - `messages`: where warnings and errors go
+    public static CssSheetData compile(String file, String path, String text, Set<String> knownSheets,
+            Messages messages) {
+        CssCompiler c = new CssCompiler(file, path, text, knownSheets, messages);
+        if (!c.parse()) {
+            return null;
+        }
+        int[] blockOf = new int[c.selectorBlocks.size()];
+        for (int i = 0; i < blockOf.length; i++) {
+            blockOf[i] = c.selectorBlocks.get(i).intValue();
+        }
+        return new CssSheetData(c.imports.toArray(new String[0]), c.fontFamilies.toArray(new String[0]),
+                c.fontSources.toArray(new String[0]), c.selectors.toArray(new CssSelector[0]), blockOf,
+                c.blocks.toArray(new CssDeclaration[0][]));
+    }
+
+    private static boolean isSpace(char c) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
+    }
+
+    /// The index of the first of `stops` at or after `from` that is outside
+    /// a string and outside parentheses, or -1.
+    private int scan(int from, String stops) {
+        char quote = 0;
+        int depth = 0;
+        for (int i = from; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (quote != 0) {
+                if (c == '\\') {
+                    i++;
+                } else if (c == quote) {
+                    quote = 0;
+                }
+            } else if (c == '"' || c == '\'') {
+                quote = c;
+            } else if (c == '(') {
+                depth++;
+            } else if (c == ')') {
+                depth--;
+            } else if (depth <= 0 && stops.indexOf(c) >= 0) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /// The `}` that closes the block opened at `open`, nested blocks
+    /// skipped, or -1.
+    private int closing(int open) {
+        int depth = 0;
+        int i = open;
+        while (true) {
+            int at = scan(i, "{}");
+            if (at < 0) {
+                return -1;
+            }
+            if (text.charAt(at) == '{') {
+                depth++;
+            } else if (--depth == 0) {
+                return at;
+            }
+            i = at + 1;
+        }
+    }
+
+    private boolean parse() {
+        int i = 0;
+        int n = text.length();
+        while (i < n) {
+            while (i < n && isSpace(text.charAt(i))) {
+                i++;
+            }
+            if (i >= n) {
+                break;
+            }
+            int start = i;
+            if (text.charAt(i) == '}') {
+                messages.error(file, text, i, "'}' without a block to close");
+                return false;
+            }
+            int stop = scan(i, text.charAt(i) == '@' ? "{;" : "{}");
+            if (stop < 0) {
+                if (text.charAt(i) == '@') {
+                    messages.error(file, text, start, "'" + head(start) + "' is not ended by ';' or a block");
+                } else {
+                    messages.error(file, text, start, "'" + head(start) + "' is not followed by a '{' block");
+                }
+                return false;
+            }
+            if (text.charAt(stop) == '}') {
+                messages.error(file, text, stop, "'}' without a block to close, after '" + head(start) + "'");
+                return false;
+            }
+            int end = stop;
+            if (text.charAt(stop) == '{') {
+                end = closing(stop);
+                if (end < 0) {
+                    messages.error(file, text, stop, "the block of '" + text.substring(start, stop).trim()
+                            + "' is never closed");
+                    return false;
+                }
+            }
+            if (text.charAt(start) == '@') {
+                atRule(start, stop, end);
+            } else {
+                rule(start, stop, end);
+            }
+            i = end + 1;
+        }
+        return true;
+    }
+
+    private String head(int start) {
+        int end = start;
+        while (end < text.length() && end - start < 40 && text.charAt(end) != '\n') {
+            end++;
+        }
+        return text.substring(start, end).trim();
+    }
+
+    private void rule(int start, int open, int close) {
+        String list = text.substring(start, open);
+        if (list.trim().length() == 0) {
+            messages.warning(file, text, start, "a block without a selector; it is ignored");
+            return;
+        }
+        List<CssSelector> parsed = new ArrayList<CssSelector>();
+        int from = 0;
+        while (from <= list.length()) {
+            int comma = list.indexOf(',', from);
+            if (comma < 0) {
+                comma = list.length();
+            }
+            String one = list.substring(from, comma).trim();
+            CssSelector s = one.length() == 0 ? null : CssSelector.parse(one);
+            if (s == null) {
+                messages.warning(file, text, start + from, "the selector '" + one
+                        + "' is not supported (type, .class, #id, :state, descendant and '>' are); it is ignored");
+            } else {
+                parsed.add(s);
+            }
+            from = comma + 1;
+        }
+        List<CssDeclaration> declarations = new ArrayList<CssDeclaration>();
+        CssDeclarations.parse(text, open + 1, close, parser, new CssDeclarations.Reporter() {
+            @Override
+            public void warning(int offset, String message) {
+                messages.warning(file, text, offset, message);
+            }
+        }, declarations);
+        if (parsed.isEmpty() || declarations.isEmpty()) {
+            return;
+        }
+        Integer block = Integer.valueOf(blocks.size());
+        blocks.add(declarations.toArray(new CssDeclaration[0]));
+        for (CssSelector s : parsed) {
+            selectors.add(s);
+            selectorBlocks.add(block);
+        }
+    }
+
+    private void atRule(int start, int stop, int end) {
+        int nameEnd = start + 1;
+        while (nameEnd < stop && !isSpace(text.charAt(nameEnd))) {
+            nameEnd++;
+        }
+        String name = CssProperties.lower(text.substring(start, nameEnd));
+        if ("@import".equals(name) && text.charAt(stop) == ';') {
+            String target = address(text.substring(nameEnd, stop).trim());
+            String resolved = target == null ? null : resolve(target);
+            if (resolved == null) {
+                messages.warning(file, text, start, "'" + text.substring(start, stop).trim()
+                        + "' does not name a style sheet of the application; it is ignored");
+                return;
+            }
+            if (knownSheets != null && !knownSheets.contains(resolved)) {
+                messages.warning(file, text, start, "the imported style sheet " + resolved
+                        + " is not among the application's desktop resources; it will not be found");
+            }
+            imports.add(resolved);
+            return;
+        }
+        if ("@font-face".equals(name) && text.charAt(stop) == '{') {
+            fontFace(start, stop, end);
+            return;
+        }
+        messages.warning(file, text, start, name + " is not supported; it is ignored");
+    }
+
+    private void fontFace(int start, int open, int close) {
+        String family = null;
+        String source = null;
+        int i = open + 1;
+        while (i < close) {
+            int semi = scan(i, ";}");
+            int stop = semi < 0 || semi > close ? close : semi;
+            String declaration = text.substring(i, stop);
+            int colon = declaration.indexOf(':');
+            if (colon > 0) {
+                String property = CssProperties.lower(declaration.substring(0, colon).trim());
+                String value = declaration.substring(colon + 1).trim();
+                if ("font-family".equals(property)) {
+                    family = unquote(value);
+                } else if ("src".equals(property)) {
+                    String target = address(value);
+                    source = target == null ? null : resolve(target);
+                }
+            }
+            i = stop + 1;
+        }
+        if (family == null || source == null) {
+            messages.warning(file, text, start,
+                    "@font-face needs a font-family and a src that is a file of the application; it is ignored");
+            return;
+        }
+        fontFamilies.add(family);
+        fontSources.add(source);
+    }
+
+    private static String unquote(String s) {
+        String t = s.trim();
+        if (t.length() >= 2 && (t.charAt(0) == '"' || t.charAt(0) == '\'') && t.charAt(t.length() - 1) == t.charAt(0)) {
+            return t.substring(1, t.length() - 1);
+        }
+        return t;
+    }
+
+    /// The address in `"x"`, `'x'`, `url(x)` or `url("x")`; the first one
+    /// when a `src` lists several. `null` for anything else.
+    private static String address(String value) {
+        String v = value.trim();
+        if (v.length() > 4 && "url(".equals(CssProperties.lower(v.substring(0, 4)))) {
+            int close = v.indexOf(')');
+            if (close < 0) {
+                return null;
+            }
+            v = v.substring(4, close);
+        } else {
+            int end = v.indexOf(' ');
+            if (end > 0 && v.charAt(0) != '"' && v.charAt(0) != '\'') {
+                v = v.substring(0, end);
+            }
+        }
+        v = unquote(v);
+        return v.length() == 0 ? null : v;
+    }
+
+    /// The resource path an address in this sheet names, or `null` for one
+    /// that is not a file of the application (an `http:` address).
+    private String resolve(String address) {
+        if (address.indexOf(':') >= 0) {
+            return null;
+        }
+        if (address.startsWith("/")) {
+            return ResourceNames.normalize(address);
+        }
+        int slash = path.lastIndexOf('/');
+        return ResourceNames.normalize(slash < 0 ? address : path.substring(0, slash + 1) + address);
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/DesktopResourceCompiler.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/DesktopResourceCompiler.java
new file mode 100644
index 00000000000..543a4912b35
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/DesktopResourceCompiler.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.fxml.css.CssSheetData;
+
+/// Compiles the style sheets among an application's desktop resources and
+/// prepares its FXML documents for [FxmlClassCompiler]; the entry point both
+/// build plugins call before the application's sources are compiled.
+///
+/// #### What goes where
+///
+/// - Every `*.css` becomes `<flat name>.cn1css` at the root of the resource
+///   output directory, where `<flat name>` is what
+///   `ResourceNames.flatName` gives the sheet's path: `styles/app.css` is
+///   compiled to `styles__app.css.cn1css`. The build ships that directory
+///   with the application's other resources, and a file at its root keeps
+///   its name ([CssCompiler]).
+/// - Every `*.fxml` is parsed, so that a document that is not well formed
+///   fails the build before anything is compiled, and the documents together
+///   become one small source,
+///   `com/codename1/generated/fxml/FxmlDocuments.java`, under the Java output
+///   directory, which the build adds to the sources javac compiles.
+///
+/// #### Why the documents are not compiled here
+///
+/// A document names classes -- every element is one -- and a custom control
+/// is a class of the application, which does not exist until javac has
+/// compiled the application. So the documents are compiled after javac, by
+/// [FxmlClassCompiler]. Nothing the application wrote names a compiled
+/// document: it calls `FXMLLoader.load` with a location, and only the
+/// registry the build generates afterwards refers to the classes.
+///
+/// What is written here is what makes that later step safe. The source holds
+/// a digest of every document, so a build in which only a document changed
+/// changes a source and javac compiles the application again; and it names
+/// `javafx.fxml.FXMLLoader`, which the relocation that ends a build renames,
+/// so the class javac makes of it says whether the classes directory is as
+/// javac left it or as the last build's relocation did
+/// ([FxmlClassCompiler#relocated(File)]).
+///
+/// The path of a file relative to its resource directory is its resource
+/// path, the one `getResource` finds it under on a desktop. With several
+/// resource directories the first that has a path wins, as on a class path.
+///
+/// #### Idempotence
+///
+/// A file is only written when its content changes, and an output of an
+/// earlier run whose source is gone is deleted, so a build that changes no
+/// document recompiles nothing downstream.
+public final class DesktopResourceCompiler {
+
+    /// Where progress and warnings are reported.
+    public interface Log {
+        /// Something worth a line of build output.
+        void info(String message);
+
+        /// Something that was left out of the build's result.
+        void warn(String message);
+    }
+
+    private final List<File> resourceDirs;
+    private final File javaOut;
+    private final File resourcesOut;
+    private final Log log;
+    private int fxmlCount;
+    private int cssCount;
+
+    /// Creates a compiler.
+    ///
+    /// #### Parameters
+    ///
+    /// - `resourceDirs`: the directories of desktop resources; one that
+    ///   does not exist is ignored
+    ///
+    /// - `javaOut`: the root of the generated Java sources
+    ///
+    /// - `resourcesOut`: the directory of the compiled style sheets
+    ///
+    /// - `log`: where to report
+    public DesktopResourceCompiler(List<File> resourceDirs, File javaOut, File resourcesOut, Log log) {
+        this.resourceDirs = new ArrayList<File>(resourceDirs);
+        this.javaOut = javaOut;
+        this.resourcesOut = resourcesOut;
+        this.log = log;
+    }
+
+    /// How many documents the last run found.
+    public int fxmlCount() {
+        return fxmlCount;
+    }
+
+    /// How many style sheets the last run compiled.
+    public int cssCount() {
+        return cssCount;
+    }
+
+    /// Compiles everything. Warnings go to the log; errors are answered,
+    /// each as `file:line:column: message`, and an empty list means the
+    /// outputs are complete. With errors the outputs of the documents that
+    /// failed are absent.
+    public List<String> run() throws IOException {
+        Map<String, File> fxml = new TreeMap<String, File>();
+        Map<String, File> css = new TreeMap<String, File>();
+        for (File dir : resourceDirs) {
+            if (dir.isDirectory()) {
+                collect(dir, "", fxml, css);
+            }
+        }
+        Messages messages = new Messages();
+        prepareFxml(fxml, messages);
+        compileCss(css, messages);
+        for (String warning : messages.warnings()) {
+            log.warn(warning);
+        }
+        fxmlCount = fxml.size();
+        cssCount = css.size();
+        if (fxmlCount + cssCount > 0 && !messages.hasErrors()) {
+            log.info("Compiled " + cssCount + " style sheet" + (cssCount == 1 ? "" : "s") + "; " + fxmlCount
+                    + " FXML document" + (fxmlCount == 1 ? " is" : "s are") + " compiled after the application's"
+                    + " classes");
+        }
+        return messages.errors();
+    }
+
+    /// Deletes everything an earlier run wrote, as a run that found no
+    /// document and no sheet does. A build calls it instead of [#run()] when
+    /// the JavaFX layer has left its class path: the generated source names
+    /// the JavaFX API, and left in place it would no longer compile.
+    public void clear() throws IOException {
+        Messages messages = new Messages();
+        prepareFxml(new TreeMap<String, File>(), messages);
+        compileCss(new TreeMap<String, File>(), messages);
+        fxmlCount = 0;
+        cssCount = 0;
+    }
+
+    /// The FXML documents under `resourceDirs` by resource path, in the
+    /// order of their paths.
+    static Map<String, File> documents(List<File> resourceDirs) {
+        Map<String, File> fxml = new TreeMap<String, File>();
+        Map<String, File> css = new TreeMap<String, File>();
+        for (File dir : resourceDirs) {
+            if (dir != null && dir.isDirectory()) {
+                collect(dir, "", fxml, css);
+            }
+        }
+        return fxml;
+    }
+
+    private static void collect(File dir, String prefix, Map<String, File> fxml, Map<String, File> css) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        Arrays.sort(files);
+        for (File f : files) {
+            String name = f.getName();
+            if (f.isDirectory()) {
+                collect(f, prefix + name + "/", fxml, css);
+            } else if (name.endsWith(".fxml") && !fxml.containsKey(prefix + name)) {
+                fxml.put(prefix + name, f);
+            } else if (name.endsWith(".css") && !css.containsKey(prefix + name)) {
+                css.put(prefix + name, f);
+            }
+        }
+    }
+
+    static byte[] read(File f) throws IOException {
+        InputStream in = new FileInputStream(f);
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            byte[] buffer = new byte[8192];
+            int n;
+            while ((n = in.read(buffer)) > 0) {
+                out.write(buffer, 0, n);
+            }
+            return out.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    /// Parses every document and writes the source that stands for them
+    /// all; see the class description.
+    private void prepareFxml(Map<String, File> files, Messages messages) throws IOException {
+        File marker = new File(new File(javaOut, FxmlCompiler.PACKAGE.replace('.', '/')),
+                FxmlClassCompiler.MARKER + ".java");
+        // A source an earlier form of this step wrote there, which javac must
+        // not find: it names classes javac has not compiled yet.
+        deleteStale(marker.getParentFile(), "Fxml_", ".java", new HashSet<String>());
+        if (files.isEmpty()) {
+            if (marker.isFile() && !marker.delete()) {
+                throw new IOException("Could not delete the stale " + marker);
+            }
+            return;
+        }
+        parse(files, messages);
+        FxmlDispatchGenerator.writeIfDifferent(marker,
+                FxmlClassCompiler.markerSource(files).getBytes(StandardCharsets.UTF_8));
+    }
+
+    /// The parsed form of every document, by resource path. One that is not
+    /// well formed is left out, with the reason among `messages`.
+    static Map<String, FxmlDocument> parse(Map<String, File> files, Messages messages) throws IOException {
+        Map<String, FxmlDocument> documents = new LinkedHashMap<String, FxmlDocument>();
+        for (Map.Entry<String, File> e : files.entrySet()) {
+            InputStream in = new FileInputStream(e.getValue());
+            try {
+                FxmlDocument doc = FxmlDocument.parse(e.getValue().getPath(), e.getKey(), in, messages);
+                if (doc != null) {
+                    documents.put(e.getKey(), doc);
+                }
+            } finally {
+                in.close();
+            }
+        }
+        return documents;
+    }
+
+    private void compileCss(Map<String, File> files, Messages messages) throws IOException {
+        Set<String> written = new HashSet<String>();
+        for (Map.Entry<String, File> e : files.entrySet()) {
+            String text = new String(read(e.getValue()), StandardCharsets.UTF_8);
+            CssSheetData data = CssCompiler.compile(e.getValue().getPath(), e.getKey(), text, files.keySet(),
+                    messages);
+            if (data != null) {
+                ByteArrayOutputStream out = new ByteArrayOutputStream();
+                data.write(out);
+                String name = CssSheetData.compiledName(ResourceNames.flatName(e.getKey()));
+                FxmlDispatchGenerator.writeIfDifferent(new File(resourcesOut, name), out.toByteArray());
+                written.add(name);
+            }
+        }
+        deleteStale(resourcesOut, "", CssSheetData.SUFFIX, written);
+    }
+
+    static void deleteStale(File dir, String prefix, String suffix, Set<String> keep) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            String name = f.getName();
+            if (f.isFile() && name.startsWith(prefix) && name.endsWith(suffix) && !keep.contains(name)
+                    && !f.delete()) {
+                throw new IOException("Could not delete the stale " + f);
+            }
+        }
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlClassCompiler.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlClassCompiler.java
new file mode 100644
index 00000000000..17dab394a7f
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlClassCompiler.java
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+/// Compiles an application's FXML documents into classes, after javac has
+/// compiled the application and before the build relocates it.
+///
+/// #### Why after javac
+///
+/// An element of a document is a class, and the compiler has to read that
+/// class to know its constructors and the type of each setter
+/// ([FxmlCompiler]). A custom control -- a class of the application used as
+/// an element -- has no class file until javac has run, so a document can
+/// only be compiled afterwards. That costs the application nothing: no
+/// source of its own names a compiled document.
+///
+/// So this step reads the documents' classes from the layer's jar AND from
+/// the directories javac (and Kotlin) compiled into, writes one Java source
+/// per document, and compiles those sources itself, in process, into the
+/// classes directory. It is the second, small javac run of a build.
+///
+/// #### Why before the relocation, and how that is known
+///
+/// The generated source names the JavaFX API as an application does
+/// (`javafx.scene.control.Button`), and is compiled against the classes the
+/// application's own javac run left. Once the build has relocated those, a
+/// custom control extends `com.codename1.fxcompat.javafx...` and no longer
+/// fits where the source expects a `javafx.scene.Node`.
+///
+/// A build in which nothing changed does not run javac, and its classes
+/// directory is still the relocated one of the build before. The step must
+/// then do nothing, and it knows from the class
+/// [DesktopResourceCompiler] had javac compile with the application: that
+/// class names `javafx.fxml.FXMLLoader`, which a relocation renames
+/// ([#relocated(File)]). The same class is why the other case cannot arise --
+/// its source holds a digest of the documents, so a changed document is a
+/// changed source, and javac compiles the application again.
+///
+/// #### Class file version
+///
+/// The sources are compiled at Java 8 whatever JDK runs the build: they use
+/// nothing newer, and every consumer of an application's classes reads that
+/// version.
+public final class FxmlClassCompiler {
+
+    /// The simple name of the class that stands for all the documents; see
+    /// [DesktopResourceCompiler].
+    static final String MARKER = "FxmlDocuments";
+    /// What the class of [#MARKER] names until a relocation renames it.
+    private static final String UNRELOCATED = "javafx/fxml/FXMLLoader";
+
+    private final List<File> resourceDirs;
+    private final List<File> classpath;
+    private final List<File> classDirs;
+    private final File classesOut;
+    private final File sourcesOut;
+    private final DesktopResourceCompiler.Log log;
+    private int compiled;
+
+    /// Creates a compiler.
+    ///
+    /// #### Parameters
+    ///
+    /// - `resourceDirs`: the directories of desktop resources; one that
+    ///   does not exist is ignored
+    ///
+    /// - `classpath`: the application's compile class path, with the
+    ///   JavaFX layer's jar on it
+    ///
+    /// - `classDirs`: every directory the application's own classes were
+    ///   compiled into, as javac and Kotlin left them
+    ///
+    /// - `classesOut`: where the documents' classes are written -- the
+    ///   application's classes directory, which is also read as one of
+    ///   `classDirs`
+    ///
+    /// - `sourcesOut`: where the generated sources are kept for a reader,
+    ///   or `null` to keep none. Never a directory the application's javac
+    ///   run compiles from
+    ///
+    /// - `log`: where to report
+    public FxmlClassCompiler(List<File> resourceDirs, List<File> classpath, List<File> classDirs, File classesOut,
+            File sourcesOut, DesktopResourceCompiler.Log log) {
+        this.resourceDirs = new ArrayList<File>(resourceDirs);
+        this.classpath = new ArrayList<File>(classpath);
+        this.classDirs = new ArrayList<File>();
+        this.classDirs.add(classesOut);
+        for (File dir : classDirs) {
+            if (dir != null && !this.classDirs.contains(dir)) {
+                this.classDirs.add(dir);
+            }
+        }
+        this.classesOut = classesOut;
+        this.sourcesOut = sourcesOut;
+        this.log = log;
+    }
+
+    /// How many documents the last run compiled; 0 when it had nothing to
+    /// do.
+    public int compiled() {
+        return compiled;
+    }
+
+    /// The source of the class that stands for `files`, the documents by
+    /// resource path.
+    static String markerSource(Map<String, File> files) throws IOException {
+        MessageDigest digest;
+        try {
+            digest = MessageDigest.getInstance("SHA-256");
+        } catch (NoSuchAlgorithmException e) {
+            throw new IOException("This JDK has no SHA-256", e);
+        }
+        for (Map.Entry<String, File> e : files.entrySet()) {
+            digest.update(e.getKey().getBytes(StandardCharsets.UTF_8));
+            digest.update((byte) 0);
+            digest.update(DesktopResourceCompiler.read(e.getValue()));
+            digest.update((byte) 0);
+        }
+        StringBuilder hex = new StringBuilder();
+        for (byte b : digest.digest()) {
+            hex.append(Character.forDigit((b >> 4) & 0xf, 16)).append(Character.forDigit(b & 0xf, 16));
+        }
+        StringBuilder s = new StringBuilder();
+        s.append("// Generated by the Codename One FXML compiler from the application's .fxml documents.\n");
+        s.append("// Do not edit: the file is written again by every build.\n");
+        s.append("package ").append(FxmlCompiler.PACKAGE).append(";\n\n");
+        s.append("/// Stands for the FXML documents of the application, which are compiled once this\n");
+        s.append("/// class is: a changed document changes the digest, and so recompiles the application.\n");
+        s.append("public final class ").append(MARKER).append(" {\n\n");
+        s.append("    public static final int CN1_COUNT = ").append(files.size()).append(";\n");
+        s.append("    public static final String CN1_DIGEST = \"").append(hex).append("\";\n\n");
+        s.append("    private ").append(MARKER).append("() {\n    }\n\n");
+        s.append("    /// The loader the documents are read through. The build tells a classes\n");
+        s.append("    /// directory it has relocated from a freshly compiled one by this name.\n");
+        s.append("    public static Class<?> cn1Loader() {\n");
+        s.append("        return javafx.fxml.FXMLLoader.class;\n");
+        s.append("    }\n");
+        s.append("}\n");
+        return s.toString();
+    }
+
+    /// Whether a build has relocated `classesDir` since javac last compiled
+    /// into it: the class that stands for the documents is there and no
+    /// longer names `javafx.fxml.FXMLLoader`. False when the class is
+    /// absent, which is the state of a directory nothing was built into.
+    public static boolean relocated(File classesDir) throws IOException {
+        File marker = new File(classesDir, FxmlCompiler.PACKAGE.replace('.', '/') + "/" + MARKER + ".class");
+        if (!marker.isFile()) {
+            return false;
+        }
+        final boolean[] fresh = {false};
+        new ClassReader(DesktopResourceCompiler.read(marker)).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public void visitLdcInsn(Object value) {
+                        if (value instanceof Type && UNRELOCATED.equals(((Type) value).getInternalName())) {
+                            fresh[0] = true;
+                        }
+                    }
+                };
+            }
+        }, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return !fresh[0];
+    }
+
+    /// Compiles every document. Answers the errors, each as
+    /// `file:line:column: message`; an empty list means the documents'
+    /// classes are in place, or that there was nothing to do.
+    public List<String> run() throws IOException {
+        compiled = 0;
+        Map<String, File> files = DesktopResourceCompiler.documents(resourceDirs);
+        File packageDir = new File(classesOut, FxmlCompiler.PACKAGE.replace('.', '/'));
+        File sourceDir = sourcesOut == null ? null : new File(sourcesOut, FxmlCompiler.PACKAGE.replace('.', '/'));
+        if (files.isEmpty()) {
+            DesktopResourceCompiler.deleteStale(packageDir, "Fxml_", ".class", new HashSet<String>());
+            if (sourceDir != null) {
+                DesktopResourceCompiler.deleteStale(sourceDir, "Fxml_", ".java", new HashSet<String>());
+            }
+            return Collections.emptyList();
+        }
+        if (relocated(classesOut)) {
+            // Nothing was compiled since the last build relocated this
+            // directory, so no document changed either: its classes are the
+            // ones that build made.
+            return Collections.emptyList();
+        }
+        Messages messages = new Messages();
+        Map<String, FxmlDocument> documents = DesktopResourceCompiler.parse(files, messages);
+        Map<String, String> sources = new LinkedHashMap<String, String>();
+        List<File> modelPath = new ArrayList<File>(classDirs);
+        modelPath.addAll(classpath);
+        ClassModel model = new ClassModel(modelPath);
+        try {
+            FxmlCompiler compiler = new FxmlCompiler(model, documents, messages);
+            for (FxmlDocument doc : documents.values()) {
+                String source = compiler.compile(doc);
+                if (source != null) {
+                    sources.put(FxmlCompiler.className(doc.path), source);
+                }
+            }
+        } finally {
+            model.close();
+        }
+        // The classes of the build before: of a document that is gone, or
+        // that no longer compiles.
+        DesktopResourceCompiler.deleteStale(packageDir, "Fxml_", ".class", new HashSet<String>());
+        if (sourceDir != null) {
+            Set<String> written = new HashSet<String>();
+            for (Map.Entry<String, String> e : sources.entrySet()) {
+                FxmlDispatchGenerator.writeIfDifferent(new File(sourceDir, e.getKey() + ".java"),
+                        e.getValue().getBytes(StandardCharsets.UTF_8));
+                written.add(e.getKey() + ".java");
+            }
+            DesktopResourceCompiler.deleteStale(sourceDir, "Fxml_", ".java", written);
+        }
+        if (messages.hasErrors()) {
+            return messages.errors();
+        }
+        List<String> errors = javac(sources, sourceDir);
+        if (errors.isEmpty()) {
+            compiled = sources.size();
+            log.info("Compiled " + compiled + " FXML document" + (compiled == 1 ? "" : "s"));
+        }
+        return errors;
+    }
+
+    /// A generated source, handed to javac from memory under the name it
+    /// has (or would have) on disk.
+    private static final class Source extends SimpleJavaFileObject {
+        private final String text;
+
+        Source(URI uri, String text) {
+            super(uri, Kind.SOURCE);
+            this.text = text;
+        }
+
+        @Override
+        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+            return text;
+        }
+    }
+
+    private List<String> javac(Map<String, String> sources, File sourceDir) throws IOException {
+        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        if (compiler == null) {
+            return Collections.singletonList("The FXML documents cannot be compiled: the build is running on a Java"
+                    + " runtime without a compiler. Run it on a JDK.");
+        }
+        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
+        StandardJavaFileManager fm = compiler.getStandardFileManager(diagnostics, Locale.ROOT,
+                StandardCharsets.UTF_8);
+        try {
+            if (!classesOut.isDirectory() && !classesOut.mkdirs() && !classesOut.isDirectory()) {
+                throw new IOException("Could not create " + classesOut);
+            }
+            fm.setLocation(StandardLocation.CLASS_OUTPUT, Collections.singletonList(classesOut));
+            List<File> cp = new ArrayList<File>();
+            for (File dir : classDirs) {
+                if (dir.isDirectory()) {
+                    cp.add(dir);
+                }
+            }
+            for (File f : classpath) {
+                if (f.exists()) {
+                    cp.add(f);
+                }
+            }
+            fm.setLocation(StandardLocation.CLASS_PATH, cp);
+            // Empty rather than unset: without a source path javac looks for
+            // sources on the class path, and a classes directory may hold
+            // some as resources.
+            fm.setLocation(StandardLocation.SOURCE_PATH, Collections.<File>emptyList());
+            List<JavaFileObject> units = new ArrayList<JavaFileObject>();
+            for (Map.Entry<String, String> e : sources.entrySet()) {
+                URI uri = sourceDir != null ? new File(sourceDir, e.getKey() + ".java").toURI()
+                        : URI.create("string:///" + FxmlCompiler.PACKAGE.replace('.', '/') + "/" + e.getKey()
+                                + ".java");
+                units.add(new Source(uri, e.getValue()));
+            }
+            // -source/-target rather than --release: the build plugins still
+            // run on a JDK 8. The warning newer compilers print for it is a
+            // lint warning, which -Xlint:none turns off.
+            List<String> options = Arrays.asList("-Xlint:none", "-proc:none", "-source", "1.8", "-target", "1.8");
+            StringWriter out = new StringWriter();
+            Boolean ok = compiler.getTask(out, fm, diagnostics, options, null, units).call();
+            List<String> errors = new ArrayList<String>();
+            if (ok == null || !ok.booleanValue()) {
+                for (Diagnostic<? extends JavaFileObject> d : diagnostics.getDiagnostics()) {
+                    if (d.getKind() == Diagnostic.Kind.ERROR) {
+                        JavaFileObject at = d.getSource();
+                        String where = at == null ? "javac" : sourceDir != null ? new File(at.toUri()).getPath()
+                                : at.getName();
+                        errors.add(where + ":" + Math.max(d.getLineNumber(), 0) + ":"
+                                + Math.max(d.getColumnNumber(), 0) + ": " + d.getMessage(Locale.ROOT)
+                                + " (in the Java source generated from an FXML document; a member of a"
+                                + " controller or custom control the document names is missing or has another"
+                                + " type)");
+                    }
+                }
+                if (errors.isEmpty()) {
+                    errors.add("javac failed on the sources generated from the FXML documents: " + out);
+                }
+            }
+            return errors;
+        } finally {
+            fm.close();
+        }
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlCompiler.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlCompiler.java
new file mode 100644
index 00000000000..69715910b6c
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlCompiler.java
@@ -0,0 +1,1296 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.fxml.FxmlDocument.Attribute;
+import com.codename1.fxml.FxmlDocument.Element;
+import com.codename1.fxml.css.CssValue;
+import com.codename1.fxml.css.CssValueParser;
+
+/// Turns one FXML document into the Java source of a class that builds the
+/// same object tree with plain constructors and setters.
+///
+/// #### The generated class
+///
+/// `com.codename1.generated.fxml.Fxml_<name>`, where `<name>` is the
+/// document's resource path without its extension, encoded so that two
+/// paths never share a name ([#className(String)]). It has
+///
+/// - `CN1_PATH`, the resource path; `CN1_CONTROLLER`, the binary name of
+///   the `fx:controller` class or an empty string; `CN1_HANDLERS`, the
+///   `#handler` names the document uses, separated by commas. The step
+///   that generates the dispatcher after compilation reads these three out
+///   of the class file.
+/// - `load(FxmlContext)`, which builds the tree and answers the root.
+/// - one private method per element, so that a large document does not
+///   outgrow the size a single method may have.
+///
+/// #### What decides the code
+///
+/// Every class a document names is looked up in the class files of the
+/// application and of its class path ([ClassModel]); the compiler therefore
+/// knows the parameter type of each setter and converts an attribute's text
+/// to it while compiling. A class or a property that is not there is an
+/// error with the line of the element -- not something to find out on a
+/// device. The application's own classes are among them, because documents
+/// are compiled after it is ([FxmlClassCompiler]): a custom control is an
+/// element like any other. The generated source is then compiled by javac,
+/// which checks what this compiler does not.
+final class FxmlCompiler {
+
+    /// The package of every generated class.
+    static final String PACKAGE = "com.codename1.generated.fxml";
+    private static final String CONTEXT = "com.codename1.fxcompat.runtime.FxmlContext";
+    private static final String EVENT_HANDLER = "javafx/event/EventHandler";
+    private static final String LIST = "java/util/List";
+    private static final Type OBJECT = Type.getObjectType("java/lang/Object");
+    private static final Type STRING = Type.getObjectType("java/lang/String");
+
+    /// The default property of the classes of the layer, for the ones that
+    /// do not say it with `@DefaultProperty`: nearest class first.
+    private static final String[][] DEFAULT_PROPERTIES = {
+        {"javafx/scene/layout/Pane", "children"}, {"javafx/scene/Group", "children"},
+        {"javafx/scene/text/TextFlow", "children"}, {"javafx/scene/control/ScrollPane", "content"},
+        {"javafx/scene/control/TabPane", "tabs"}, {"javafx/scene/control/Tab", "content"},
+        {"javafx/scene/control/TitledPane", "content"}, {"javafx/scene/control/Accordion", "panes"},
+        {"javafx/scene/control/SplitPane", "items"}, {"javafx/scene/control/ToolBar", "items"},
+        {"javafx/scene/control/MenuBar", "menus"}, {"javafx/scene/control/Menu", "items"},
+        {"javafx/scene/control/MenuButton", "items"}, {"javafx/scene/control/ContextMenu", "items"},
+        {"javafx/scene/control/ButtonBar", "buttons"}, {"javafx/scene/control/ListView", "items"},
+        {"javafx/scene/control/TableView", "items"}, {"javafx/scene/control/TableColumn", "columns"},
+        {"javafx/scene/control/TreeView", "root"}, {"javafx/scene/control/TreeItem", "children"},
+        {"javafx/scene/control/ComboBox", "items"}, {"javafx/scene/control/ChoiceBox", "items"},
+        {"javafx/scene/control/ToggleGroup", "toggles"}, {"javafx/scene/control/DialogPane", "content"},
+        {"javafx/scene/control/Labeled", "text"}, {"javafx/scene/control/TextInputControl", "text"},
+        {"javafx/scene/text/Text", "text"}, {"javafx/scene/image/ImageView", "image"},
+        {"javafx/scene/shape/Path", "elements"}, {"javafx/scene/shape/Polygon", "points"},
+        {"javafx/scene/shape/Polyline", "points"}, {"javafx/scene/Scene", "root"},
+        {"javafx/stage/Stage", "scene"}, {"javafx/animation/Timeline", "keyFrames"},
+        {"javafx/animation/SequentialTransition", "children"},
+        {"javafx/animation/ParallelTransition", "children"},
+    };
+
+    /// A compile error with the element it is about.
+    private static final class Failure extends Exception {
+        private static final long serialVersionUID = 1L;
+        final transient Element at;
+
+        Failure(Element at, String message) {
+            super(message);
+            this.at = at;
+        }
+    }
+
+    /// An expression of the generated source and the type it has.
+    private static final class Value {
+        final String code;
+        final Type type;
+
+        Value(String code, Type type) {
+            this.code = code;
+            this.type = type;
+        }
+    }
+
+    private final ClassModel model;
+    private final Map<String, FxmlDocument> documents;
+    private final Messages messages;
+    private final CssValueParser values = new CssValueParser();
+
+    // The document being compiled.
+    private FxmlDocument doc;
+    private final List<String> methods = new ArrayList<String>();
+    private final Map<String, Type> ids = new HashMap<String, Type>();
+    private final Set<String> handlers = new LinkedHashSet<String>();
+    private String controller;
+    private int counter;
+
+    /// Creates a compiler.
+    ///
+    /// #### Parameters
+    ///
+    /// - `model`: the classes of the application's class path
+    ///
+    /// - `documents`: every document of the application by resource path,
+    ///   which an `<fx:include>` is resolved in
+    ///
+    /// - `messages`: where errors go
+    FxmlCompiler(ClassModel model, Map<String, FxmlDocument> documents, Messages messages) {
+        this.model = model;
+        this.documents = documents;
+        this.messages = messages;
+    }
+
+    /// The simple name of the class generated for the document at a
+    /// resource path. The encoding is one to one: a letter or a digit
+    /// stands for itself, `/` is `__`, `_` is `_u`, `.` is `_d`, `-` is
+    /// `_m` and any other character is `_x` and its code in four hex
+    /// digits.
+    static String className(String path) {
+        String p = path.endsWith(".fxml") ? path.substring(0, path.length() - 5) : path;
+        StringBuilder s = new StringBuilder("Fxml_");
+        for (int i = 0; i < p.length(); i++) {
+            char c = p.charAt(i);
+            if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')) {
+                s.append(c);
+            } else if (c == '/') {
+                s.append("__");
+            } else if (c == '_') {
+                s.append("_u");
+            } else if (c == '.') {
+                s.append("_d");
+            } else if (c == '-') {
+                s.append("_m");
+            } else {
+                String hex = Integer.toHexString(c);
+                s.append("_x").append("0000".substring(hex.length())).append(hex);
+            }
+        }
+        return s.toString();
+    }
+
+    /// Compiles a document. Answers the source of its class, or `null`
+    /// with the reason recorded as an error.
+    String compile(FxmlDocument document) throws IOException {
+        doc = document;
+        methods.clear();
+        ids.clear();
+        handlers.clear();
+        controller = null;
+        counter = 0;
+        try {
+            return generate();
+        } catch (Failure f) {
+            Element at = f.at == null ? doc.root : f.at;
+            messages.error(doc.file, at.line, at.column, f.getMessage() + " (at " + at.text() + ")");
+            return null;
+        }
+    }
+
+    private String generate() throws Failure, IOException {
+        Element root = doc.root;
+        String declared = root.fx("controller");
+        if (declared != null) {
+            controller = declared.trim();
+            if (!isQualifiedName(controller)) {
+                throw new Failure(root, "fx:controller=\"" + declared + "\" is not a class name");
+            }
+        }
+        Value tree = value(root, true);
+        String name = className(doc.path);
+        StringBuilder s = new StringBuilder();
+        s.append("// Generated from ").append(doc.path).append(" by the Codename One FXML compiler.\n");
+        s.append("// Do not edit: the file is written again by every build.\n");
+        s.append("package ").append(PACKAGE).append(";\n\n");
+        s.append("@SuppressWarnings({\"rawtypes\", \"unchecked\", \"cast\", \"deprecation\"})\n");
+        s.append("public final class ").append(name).append(" {\n\n");
+        s.append("    public static final String CN1_PATH = ").append(literal(doc.path)).append(";\n");
+        s.append("    public static final String CN1_CONTROLLER = ")
+                .append(literal(controller == null ? "" : controller)).append(";\n");
+        StringBuilder names = new StringBuilder();
+        for (String h : handlers) {
+            names.append(names.length() == 0 ? "" : ",").append(h);
+        }
+        s.append("    public static final String CN1_HANDLERS = ").append(literal(names.toString())).append(";\n\n");
+        s.append("    private ").append(name).append("() {\n    }\n\n");
+        s.append("    public static Object load(").append(CONTEXT).append(" c) throws Exception {\n");
+        s.append("        Object root = ").append(tree.code).append(";\n");
+        s.append("        c.done();\n");
+        s.append("        return root;\n");
+        s.append("    }\n");
+        for (String m : methods) {
+            s.append('\n').append(m);
+        }
+        s.append("}\n");
+        return s.toString();
+    }
+
+    // ------------------------------------------------------------- names
+
+    private static boolean isIdentifier(String s) {
+        if (s.length() == 0 || !Character.isJavaIdentifierStart(s.charAt(0))) {
+            return false;
+        }
+        for (int i = 1; i < s.length(); i++) {
+            if (!Character.isJavaIdentifierPart(s.charAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean isQualifiedName(String s) {
+        int from = 0;
+        while (true) {
+            int dot = s.indexOf('.', from);
+            if (!isIdentifier(s.substring(from, dot < 0 ? s.length() : dot))) {
+                return false;
+            }
+            if (dot < 0) {
+                return true;
+            }
+            from = dot + 1;
+        }
+    }
+
+    /// A Java string literal in ASCII.
+    static String literal(String text) {
+        StringBuilder s = new StringBuilder("\"");
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == '"' || c == '\\') {
+                s.append('\\').append(c);
+            } else if (c == '\n') {
+                s.append('\\').append('n');
+            } else if (c == '\r') {
+                s.append('\\').append('r');
+            } else if (c == '\t') {
+                s.append('\\').append('t');
+            } else if (c < ' ' || c > '~') {
+                String hex = Integer.toHexString(c);
+                s.append('\\').append('u').append("0000".substring(hex.length())).append(hex);
+            } else {
+                s.append(c);
+            }
+        }
+        return s.append('"').toString();
+    }
+
+    private static String cap(String property) {
+        if (property.length() == 0) {
+            return property;
+        }
+        char first = property.charAt(0);
+        // By hand: a property name is ASCII, and the locale must not fold it.
+        return (first >= 'a' && first <= 'z' ? (char) (first - ('a' - 'A')) : first) + property.substring(1);
+    }
+
+    /// The type as Java source spells it.
+    private static String java(Type t) {
+        if (t.getSort() == Type.ARRAY) {
+            StringBuilder s = new StringBuilder(java(t.getElementType()));
+            for (int i = 0; i < t.getDimensions(); i++) {
+                s.append("[]");
+            }
+            return s.toString();
+        }
+        return t.getClassName().replace('$', '.');
+    }
+
+    private static boolean isObject(Type t) {
+        return t.getSort() == Type.OBJECT;
+    }
+
+    /// The class a name in the document stands for: a qualified name, or a
+    /// simple one found through the imports.
+    private ClassModel.Info resolve(String name) throws IOException {
+        if (name.indexOf('.') >= 0) {
+            ClassModel.Info direct = qualified(name);
+            if (direct != null) {
+                return direct;
+            }
+        }
+        for (String imported : doc.imports) {
+            ClassModel.Info found = null;
+            if (imported.endsWith(".*")) {
+                found = qualified(imported.substring(0, imported.length() - 1) + name);
+            } else if (imported.equals(name) || imported.endsWith("." + name)) {
+                found = qualified(imported);
+            } else {
+                int dot = name.indexOf('.');
+                if (dot > 0 && (imported.equals(name.substring(0, dot))
+                        || imported.endsWith("." + name.substring(0, dot)))) {
+                    // A nested class named through its imported outer class.
+                    found = qualified(imported + name.substring(dot));
+                }
+            }
+            if (found != null) {
+                return found;
+            }
+        }
+        return name.indexOf('.') < 0 ? model.find("java/lang/" + name) : null;
+    }
+
+    /// The class of a dotted name, trying each split between package and
+    /// nested class.
+    private ClassModel.Info qualified(String dotted) throws IOException {
+        String internal = dotted.replace('.', '/');
+        while (true) {
+            ClassModel.Info info = model.find(internal);
+            if (info != null) {
+                return info;
+            }
+            int slash = internal.lastIndexOf('/');
+            if (slash < 0) {
+                return null;
+            }
+            internal = internal.substring(0, slash) + '$' + internal.substring(slash + 1);
+        }
+    }
+
+    private ClassModel.Info need(String name, Element at) throws Failure, IOException {
+        ClassModel.Info info = resolve(name);
+        if (info == null) {
+            throw new Failure(at, "unknown class " + name + ": it is not imported by a <?import?> of this"
+                    + " document, or it is neither a class of the application nor on its class path. Import a"
+                    + " custom control by its full name (<?import com.example.MyControl?>) or its package"
+                    + " (<?import com.example.*?>)");
+        }
+        if (!info.isPublic()) {
+            throw new Failure(at, "the class " + info.sourceName() + " is not public");
+        }
+        return info;
+    }
+
+    // ------------------------------------------------------- properties
+
+    private ClassModel.Method setter(String owner, String property) throws IOException {
+        List<ClassModel.Method> all = model.methods(owner, "set" + cap(property));
+        ClassModel.Method getter = getter(owner, property);
+        ClassModel.Method first = null;
+        for (ClassModel.Method m : all) {
+            if (m.isStatic() || m.parameters.length != 1) {
+                continue;
+            }
+            if (getter != null && getter.returnType().equals(m.parameters[0])) {
+                return m;
+            }
+            first = first == null ? m : first;
+        }
+        return first;
+    }
+
+    private ClassModel.Method getter(String owner, String property) throws IOException {
+        for (String prefix : new String[] {"get", "is"}) {
+            for (ClassModel.Method m : model.methods(owner, prefix + cap(property))) {
+                if (!m.isStatic() && m.parameters.length == 0 && m.returnType().getSort() != Type.VOID) {
+                    return m;
+                }
+            }
+        }
+        return null;
+    }
+
+    private ClassModel.Method staticSetter(String owner, String property) throws IOException {
+        for (ClassModel.Method m : model.methods(owner, "set" + cap(property))) {
+            if (m.isStatic() && m.parameters.length == 2) {
+                return m;
+            }
+        }
+        return null;
+    }
+
+    private boolean isList(Type t) throws IOException {
+        return isObject(t) && model.isAssignable(t.getInternalName(), LIST);
+    }
+
+    /// The element type a list getter declares, or `null` when the class
+    /// file does not say (a raw list, a type variable, a wildcard).
+    private static Type elementType(ClassModel.Method getter) {
+        String sig = getter.signature;
+        if (sig == null) {
+            return null;
+        }
+        int close = sig.indexOf(')');
+        int open = sig.indexOf('<', close);
+        if (close < 0 || open < 0 || open + 1 >= sig.length() || sig.charAt(open + 1) != 'L') {
+            return null;
+        }
+        int end = open + 2;
+        while (end < sig.length() && sig.charAt(end) != ';' && sig.charAt(end) != '<') {
+            end++;
+        }
+        return Type.getObjectType(sig.substring(open + 2, end));
+    }
+
+    private String defaultProperty(String owner) throws IOException {
+        String annotated = model.annotatedDefaultProperty(owner);
+        if (annotated != null) {
+            return annotated;
+        }
+        String best = null;
+        int bestDepth = Integer.MAX_VALUE;
+        for (String[] entry : DEFAULT_PROPERTIES) {
+            int depth = depth(owner, entry[0]);
+            if (depth >= 0 && depth < bestDepth) {
+                best = entry[1];
+                bestDepth = depth;
+            }
+        }
+        return best;
+    }
+
+    /// How many classes `ancestor` is above `cls`; -1 when it is not.
+    private int depth(String cls, String ancestor) throws IOException {
+        int depth = 0;
+        String at = cls;
+        while (at != null) {
+            if (at.equals(ancestor)) {
+                return depth;
+            }
+            ClassModel.Info info = model.find(at);
+            at = info == null ? null : info.superName;
+            depth++;
+        }
+        return -1;
+    }
+
+    // ----------------------------------------------------------- values
+
+    /// Builds the value an element stands for, in a method of its own, and
+    /// answers the call of that method.
+    private Value value(Element e, boolean isRoot) throws Failure, IOException {
+        StringBuilder body = new StringBuilder();
+        Type type;
+        boolean instance = false;
+        Set<Attribute> consumed = new LinkedHashSet<Attribute>();
+        Set<Element> consumedElements = new LinkedHashSet<Element>();
+        if (e.fx) {
+            if ("root".equals(e.name)) {
+                if (!isRoot) {
+                    throw new Failure(e, "<fx:root> can only be the root element of a document");
+                }
+                String typeName = e.plain("type");
+                if (typeName == null) {
+                    throw new Failure(e, "<fx:root> needs a type attribute");
+                }
+                ClassModel.Info info = need(typeName.trim(), e);
+                type = Type.getObjectType(info.name);
+                body.append("        Object given = c.root();\n");
+                body.append("        if (!(given instanceof ").append(java(type)).append(")) {\n");
+                body.append("            throw c.error(").append(literal("the root set on the loader must be a "
+                        + java(type) + ", as the <fx:root> element says")).append(");\n        }\n");
+                body.append("        ").append(java(type)).append(" v = (").append(java(type)).append(") given;\n");
+                instance = true;
+            } else if ("include".equals(e.name)) {
+                String source = e.plain("source");
+                if (source == null) {
+                    throw new Failure(e, "<fx:include> needs a source attribute");
+                }
+                FxmlDocument included = documents.get(resolvePath(source));
+                if (included == null) {
+                    throw new Failure(e, "the included document " + source + " (" + resolvePath(source)
+                            + ") is not among the application's desktop resources");
+                }
+                type = rootType(included, e);
+                String id = e.fx("id");
+                body.append("        Object loaded = c.include(").append(literal(source)).append(", ")
+                        .append(id == null ? "null" : literal(id)).append(");\n");
+                body.append("        if (!(loaded instanceof ").append(java(type)).append(")) {\n");
+                body.append("            throw c.error(").append(literal("the included document " + source
+                        + " did not answer a " + java(type))).append(");\n        }\n");
+                body.append("        ").append(java(type)).append(" v = (").append(java(type))
+                        .append(") loaded;\n");
+                if (id != null) {
+                    checkId(id, e);
+                    ids.put(id, type);
+                    String includedController = included.root.fx("controller");
+                    if (includedController != null) {
+                        ids.put(id + "Controller", Type.getObjectType(includedController.trim().replace('.', '/')));
+                    }
+                }
+            } else if ("reference".equals(e.name)) {
+                String source = e.plain("source");
+                if (source == null) {
+                    throw new Failure(e, "<fx:reference> needs a source attribute");
+                }
+                Value ref = reference(source.trim(), e);
+                type = ref.type;
+                body.append("        ").append(java(type)).append(" v = ").append(ref.code).append(";\n");
+            } else if ("script".equals(e.name)) {
+                throw new Failure(e, "<fx:script> is not supported: a document is compiled to Java, and a"
+                        + " script would have to be interpreted on the device. Write the code in the controller");
+            } else {
+                throw new Failure(e, "<fx:" + e.name + "> is not supported");
+            }
+        } else {
+            ClassModel.Info info = need(e.name, e);
+            type = construct(e, info, body, consumed, consumedElements);
+            instance = true;
+        }
+        if (e.fx("controller") != null && !isRoot) {
+            throw new Failure(e, "fx:controller can only be on the root element");
+        }
+        if (isRoot && controller != null) {
+            String source = controller.replace('$', '.');
+            body.insert(0, "        c.controller(" + source + ".class, " + literal(controller) + ");\n");
+        }
+        String id = e.fx("id");
+        if (id != null && !(e.fx && "include".equals(e.name))) {
+            checkId(id, e);
+            ids.put(id, type);
+            body.append("        c.id(").append(literal(id)).append(", v);\n");
+        }
+        for (Attribute a : e.attributes) {
+            if (a.fx || consumed.contains(a)) {
+                continue;
+            }
+            if (e.fx && ("source".equals(a.name) || "type".equals(a.name) || "resources".equals(a.name)
+                    || "charset".equals(a.name))) {
+                continue;
+            }
+            int dot = a.name.lastIndexOf('.');
+            if (dot > 0) {
+                staticAttribute(e, a, a.name.substring(0, dot), a.name.substring(dot + 1), type, body);
+            } else if (instance || (e.fx && "include".equals(e.name))) {
+                attribute(e, a, type, body);
+            } else {
+                throw new Failure(e, a.text() + " cannot be set here");
+            }
+        }
+        if (instance) {
+            children(e, type, body, consumedElements);
+        }
+        String method = "e" + counter++;
+        StringBuilder m = new StringBuilder();
+        m.append("    private static ").append(java(type)).append(' ').append(method).append('(').append(CONTEXT)
+                .append(" c) throws Exception {\n").append(body).append("        return v;\n    }\n");
+        methods.add(m.toString());
+        return new Value(method + "(c)", type);
+    }
+
+    private void checkId(String id, Element e) throws Failure {
+        if (!isIdentifier(id)) {
+            throw new Failure(e, "fx:id=\"" + id + "\" is not a valid name");
+        }
+        if (ids.containsKey(id)) {
+            throw new Failure(e, "fx:id=\"" + id + "\" is used twice in this document");
+        }
+    }
+
+    private String resolvePath(String source) {
+        if (source.startsWith("/")) {
+            return ResourceNames.normalize(source);
+        }
+        int slash = doc.path.lastIndexOf('/');
+        return ResourceNames.normalize(slash < 0 ? source : doc.path.substring(0, slash + 1) + source);
+    }
+
+    /// The type of the root of another document, resolved with that
+    /// document's own imports.
+    private Type rootType(FxmlDocument other, Element at) throws Failure, IOException {
+        FxmlDocument mine = doc;
+        doc = other;
+        try {
+            Element root = other.root;
+            String name = root.fx && "root".equals(root.name) ? root.plain("type") : root.fx ? null : root.name;
+            ClassModel.Info info = name == null ? null : resolve(name.trim());
+            if (info == null) {
+                throw new Failure(at, "cannot tell what the included document " + other.path
+                        + " builds: its root element " + root.text() + " is not a known class");
+            }
+            return Type.getObjectType(info.name);
+        } finally {
+            doc = mine;
+        }
+    }
+
+    private Value reference(String id, Element at) throws Failure {
+        if ("controller".equals(id)) {
+            if (controller == null) {
+                throw new Failure(at, "$controller is used but the document has no fx:controller");
+            }
+            String source = controller.replace('$', '.');
+            return new Value("((" + source + ") c.controller())", Type.getObjectType(controller.replace('.', '/')));
+        }
+        Type type = ids.get(id);
+        if (type == null) {
+            throw new Failure(at, "nothing with fx:id=\"" + id + "\" is defined before this point");
+        }
+        // The cast is to the type the compiler itself recorded for the id
+        // in this document, so it cannot fail.
+        return new Value("((" + java(type) + ") c.get(" + literal(id) + "))", type);
+    }
+
+    // ----------------------------------------------------- construction
+
+    private Type construct(Element e, ClassModel.Info info, StringBuilder body, Set<Attribute> consumed,
+            Set<Element> consumedElements) throws Failure, IOException {
+        Type type = Type.getObjectType(info.name);
+        String source = info.sourceName();
+        String value = e.fx("value");
+        String factory = e.fx("factory");
+        String constant = e.fx("constant");
+        if (value != null) {
+            body.append("        ").append(source).append(" v = ").append(coerce(value, type, e)).append(";\n");
+            return type;
+        }
+        if (constant != null) {
+            for (ClassModel.Field f : info.fields) {
+                if (f.name.equals(constant) && (f.access & Opcodes.ACC_STATIC) != 0
+                        && (f.access & Opcodes.ACC_PUBLIC) != 0) {
+                    Type ft = boxed(Type.getType(f.descriptor));
+                    body.append("        ").append(java(ft)).append(" v = ").append(source).append('.')
+                            .append(constant).append(";\n");
+                    return ft;
+                }
+            }
+            throw new Failure(e, source + " has no public static field " + constant);
+        }
+        if (factory != null) {
+            for (ClassModel.Method m : model.methods(info.name, factory)) {
+                if (m.isStatic() && m.parameters.length == 0 && isObject(m.returnType())) {
+                    Type rt = m.returnType();
+                    body.append("        ").append(java(rt)).append(" v = ").append(source).append('.')
+                            .append(factory).append("();\n");
+                    return rt;
+                }
+            }
+            throw new Failure(e, source + " has no public static method " + factory + "() without arguments");
+        }
+        if (info.isAbstract()) {
+            throw new Failure(e, source + " is abstract and cannot be an element");
+        }
+        ClassModel.Method noArgs = null;
+        List<ClassModel.Method> named = new ArrayList<ClassModel.Method>();
+        for (ClassModel.Method m : info.methods) {
+            if ("<init>".equals(m.name) && m.isPublic()) {
+                if (m.parameters.length == 0) {
+                    noArgs = m;
+                } else if (m.allArgsNamed()) {
+                    named.add(m);
+                }
+            }
+        }
+        // What the document sets: an attribute, or a property element that
+        // holds one value.
+        Map<String, Object> given = new LinkedHashMap<String, Object>();
+        boolean allSettable = true;
+        for (Attribute a : e.attributes) {
+            if (!a.fx && a.name.indexOf('.') < 0) {
+                given.put(a.name, a);
+                allSettable &= setter(info.name, a.name) != null || getter(info.name, a.name) != null;
+            }
+        }
+        for (Element child : e.elements()) {
+            if (!child.fx && child.name.indexOf('.') < 0 && Character.isLowerCase(child.name.charAt(0))
+                    && !given.containsKey(child.name)) {
+                given.put(child.name, child);
+                allSettable &= setter(info.name, child.name) != null || getter(info.name, child.name) != null;
+            }
+        }
+        if (noArgs != null && (allSettable || named.isEmpty())) {
+            body.append("        ").append(source).append(" v = new ").append(source).append("();\n");
+            return type;
+        }
+        ClassModel.Method best = null;
+        int bestMatched = -1;
+        for (ClassModel.Method m : named) {
+            int matched = 0;
+            for (String arg : m.argNames) {
+                matched += given.containsKey(arg) ? 1 : 0;
+            }
+            if (matched > bestMatched || (matched == bestMatched && best != null
+                    && m.parameters.length < best.parameters.length)) {
+                best = m;
+                bestMatched = matched;
+            }
+        }
+        if (best == null) {
+            throw new Failure(e, source + " has no public constructor without arguments and none whose"
+                    + " arguments are all named with @NamedArg, so a document cannot create it");
+        }
+        StringBuilder args = new StringBuilder();
+        for (int i = 0; i < best.parameters.length; i++) {
+            Type pt = best.parameters[i];
+            Object from = given.get(best.argNames[i]);
+            String code;
+            if (from instanceof Attribute) {
+                Attribute a = (Attribute) from;
+                consumed.add(a);
+                code = attributeValue(a.value, pt, e, a);
+            } else if (from instanceof Element) {
+                Element child = (Element) from;
+                consumedElements.add(child);
+                List<Element> inner = child.elements();
+                if (inner.size() == 1) {
+                    Value v = value(inner.get(0), false);
+                    requireAssignable(v.type, pt, child);
+                    code = v.code;
+                } else if (inner.isEmpty() && child.content().length() > 0) {
+                    code = coerce(child.content(), pt, child);
+                } else {
+                    throw new Failure(child, "the constructor argument " + child.name + " needs exactly one value");
+                }
+            } else if (best.argDefaults[i] != null && best.argDefaults[i].length() > 0) {
+                code = coerce(best.argDefaults[i], pt, e);
+            } else {
+                code = zero(pt);
+            }
+            args.append(i == 0 ? "" : ", ").append(code);
+        }
+        body.append("        ").append(source).append(" v = new ").append(source).append('(').append(args)
+                .append(");\n");
+        return type;
+    }
+
+    private static String zero(Type t) {
+        switch (t.getSort()) {
+            case Type.BOOLEAN:
+                return "false";
+            case Type.CHAR:
+                return "'\\0'";
+            case Type.BYTE:
+                return "(byte) 0";
+            case Type.SHORT:
+                return "(short) 0";
+            case Type.INT:
+                return "0";
+            case Type.LONG:
+                return "0L";
+            case Type.FLOAT:
+                return "0f";
+            case Type.DOUBLE:
+                return "0.0";
+            default:
+                return "(" + java(t) + ") null";
+        }
+    }
+
+    private static Type boxed(Type t) {
+        switch (t.getSort()) {
+            case Type.BOOLEAN:
+                return Type.getObjectType("java/lang/Boolean");
+            case Type.CHAR:
+                return Type.getObjectType("java/lang/Character");
+            case Type.BYTE:
+                return Type.getObjectType("java/lang/Byte");
+            case Type.SHORT:
+                return Type.getObjectType("java/lang/Short");
+            case Type.INT:
+                return Type.getObjectType("java/lang/Integer");
+            case Type.LONG:
+                return Type.getObjectType("java/lang/Long");
+            case Type.FLOAT:
+                return Type.getObjectType("java/lang/Float");
+            case Type.DOUBLE:
+                return Type.getObjectType("java/lang/Double");
+            default:
+                return t;
+        }
+    }
+
+    private void requireAssignable(Type from, Type to, Element at) throws Failure, IOException {
+        Type target = boxed(to);
+        if (!isObject(from) || !isObject(target)) {
+            if (from.equals(target)) {
+                return;
+            }
+            throw new Failure(at, "a " + java(from) + " cannot be used where a " + java(to) + " is expected");
+        }
+        if (model.find(from.getInternalName()) == null || model.find(target.getInternalName()) == null) {
+            // A class the model cannot read; javac decides.
+            return;
+        }
+        if (!model.isAssignable(from.getInternalName(), target.getInternalName())) {
+            throw new Failure(at, "a " + java(from) + " cannot be used where a " + java(to) + " is expected");
+        }
+    }
+
+    // ------------------------------------------------------- attributes
+
+    private void staticAttribute(Element e, Attribute a, String className, String property, Type type,
+            StringBuilder body) throws Failure, IOException {
+        ClassModel.Info owner = need(className, e);
+        ClassModel.Method m = staticSetter(owner.name, property);
+        if (m == null) {
+            throw new Failure(e, a.text() + ": " + owner.sourceName() + " has no static property " + property
+                    + " (a public static set" + cap(property) + " with two arguments)");
+        }
+        requireAssignable(type, m.parameters[0], e);
+        body.append("        ").append(owner.sourceName()).append(".set").append(cap(property)).append("(v, ")
+                .append(attributeValue(a.value, m.parameters[1], e, a)).append(");\n");
+    }
+
+    private void attribute(Element e, Attribute a, Type type, StringBuilder body) throws Failure, IOException {
+        if (!isObject(type)) {
+            throw new Failure(e, a.text() + " cannot be set on a " + java(type));
+        }
+        String owner = type.getInternalName();
+        String raw = a.value;
+        if (raw.startsWith("${") && raw.endsWith("}")) {
+            binding(e, a, owner, raw.substring(2, raw.length() - 1).trim(), body);
+            return;
+        }
+        ClassModel.Method set = setter(owner, a.name);
+        if (set != null) {
+            Type pt = set.parameters[0];
+            if (isObject(pt) && EVENT_HANDLER.equals(pt.getInternalName())) {
+                if (!raw.startsWith("#")) {
+                    throw new Failure(e, a.text() + ": a handler is written as \"#method\", naming a method of"
+                            + " the controller. Script handlers are not supported, because a document is"
+                            + " compiled to Java");
+                }
+                String name = raw.substring(1).trim();
+                if (!isIdentifier(name)) {
+                    throw new Failure(e, a.text() + ": '" + name + "' is not a method name");
+                }
+                if (controller == null) {
+                    throw new Failure(e, a.text() + ": the document has no fx:controller for the handler to be a"
+                            + " method of. A controller set with setController() is not known to the compiler;"
+                            + " name its class with fx:controller");
+                }
+                handlers.add(name);
+                body.append("        v.set").append(cap(a.name)).append("(c.handler(").append(literal(name))
+                        .append("));\n");
+                return;
+            }
+            body.append("        v.set").append(cap(a.name)).append('(').append(attributeValue(raw, pt, e, a))
+                    .append(");\n");
+            return;
+        }
+        ClassModel.Method get = getter(owner, a.name);
+        if (get != null && isList(get.returnType())) {
+            Type element = elementType(get);
+            Type target = element == null ? STRING : element;
+            int from = 0;
+            while (from <= raw.length()) {
+                int comma = raw.indexOf(',', from);
+                if (comma < 0) {
+                    comma = raw.length();
+                }
+                String item = raw.substring(from, comma).trim();
+                if (item.length() > 0) {
+                    body.append("        ((java.util.List) v.").append(get.name).append("()).add(")
+                            .append(attributeValue(item, target, e, a)).append(");\n");
+                }
+                from = comma + 1;
+            }
+            return;
+        }
+        throw new Failure(e, a.text() + ": " + java(type) + " has no property " + a.name + " (no public set"
+                + cap(a.name) + " and no list get" + cap(a.name) + ")");
+    }
+
+    /// The code of an attribute's value: a resource key, a location, a
+    /// reference, or text converted to the target type.
+    private String attributeValue(String raw, Type target, Element e, Attribute a) throws Failure, IOException {
+        if (raw.startsWith("\\")) {
+            return coerce(raw.substring(1), target, e);
+        }
+        if (raw.startsWith("%")) {
+            requireString(target, e, a);
+            return "c.string(" + literal(raw.substring(1)) + ")";
+        }
+        if (raw.startsWith("@")) {
+            requireString(target, e, a);
+            return "c.url(" + literal(raw.substring(1)) + ")";
+        }
+        if (raw.startsWith("${")) {
+            throw new Failure(e, a.text() + ": a ${binding} can only be the whole value of a property");
+        }
+        if (raw.startsWith("$")) {
+            Value ref = reference(raw.substring(1).trim(), e);
+            requireAssignable(ref.type, target, e);
+            return ref.code;
+        }
+        return coerce(raw, target, e);
+    }
+
+    private void requireString(Type target, Element e, Attribute a) throws Failure {
+        if (!isObject(target) || !("java/lang/String".equals(target.getInternalName())
+                || "java/lang/Object".equals(target.getInternalName())
+                || "java/lang/CharSequence".equals(target.getInternalName()))) {
+            throw new Failure(e, a.text() + ": the value is text, but the property is a " + java(target));
+        }
+    }
+
+    private void binding(Element e, Attribute a, String owner, String expression, StringBuilder body)
+            throws Failure, IOException {
+        int dot = expression.indexOf('.');
+        if (dot <= 0 || !isIdentifier(expression.substring(0, dot)) || !isIdentifier(expression.substring(dot + 1))) {
+            throw new Failure(e, a.text() + ": only a binding to one property of the controller or of an element"
+                    + " with an fx:id is supported, as in ${controller.name} or ${slider.value}. Write any"
+                    + " other expression as a binding in the controller's initialize()");
+        }
+        String property = expression.substring(dot + 1);
+        Value source = reference(expression.substring(0, dot), e);
+        if (model.find(source.type.getInternalName()) != null
+                && model.methods(source.type.getInternalName(), property + "Property").isEmpty()) {
+            throw new Failure(e, a.text() + ": " + java(source.type) + " has no " + property + "Property()");
+        }
+        if (model.methods(owner, a.name + "Property").isEmpty()) {
+            throw new Failure(e, a.text() + ": " + owner.replace('/', '.') + " has no " + a.name
+                    + "Property() to bind");
+        }
+        ClassModel.Method set = setter(owner, a.name);
+        String mode = "BIND_SAME";
+        if (set != null) {
+            Type pt = set.parameters[0];
+            if (isObject(pt) && "java/lang/String".equals(pt.getInternalName())) {
+                mode = "BIND_STRING";
+            } else if (pt.getSort() >= Type.BYTE && pt.getSort() <= Type.DOUBLE) {
+                mode = "BIND_NUMBER";
+            }
+        }
+        body.append("        ").append(CONTEXT).append(".bind(v.").append(a.name).append("Property(), ")
+                .append(source.code).append('.').append(property).append("Property(), ").append(CONTEXT)
+                .append('.').append(mode).append(");\n");
+    }
+
+    // --------------------------------------------------------- children
+
+    private void children(Element e, Type type, StringBuilder body, Set<Element> consumed)
+            throws Failure, IOException {
+        List<Value> defaults = new ArrayList<Value>();
+        Element firstDefault = null;
+        for (Element child : e.elements()) {
+            if (consumed.contains(child)) {
+                continue;
+            }
+            if (child.fx && "define".equals(child.name)) {
+                for (Element defined : child.elements()) {
+                    body.append("        ").append(value(defined, false).code).append(";\n");
+                }
+                continue;
+            }
+            int dot = child.name.lastIndexOf('.');
+            if (!child.fx && dot > 0 && Character.isLowerCase(child.name.charAt(dot + 1))
+                    && resolve(child.name) == null) {
+                staticElement(child, child.name.substring(0, dot), child.name.substring(dot + 1), type, body);
+            } else if (!child.fx && dot < 0 && Character.isLowerCase(child.name.charAt(0))) {
+                propertyElement(child, type, body);
+            } else {
+                firstDefault = firstDefault == null ? child : firstDefault;
+                defaults.add(value(child, false));
+            }
+        }
+        String text = e.content();
+        if (defaults.isEmpty() && text.length() == 0) {
+            return;
+        }
+        if (!isObject(type)) {
+            throw new Failure(e, "a " + java(type) + " cannot have content");
+        }
+        if (isList(type)) {
+            for (Value v : defaults) {
+                body.append("        ((java.util.List) v).add(").append(v.code).append(");\n");
+            }
+            if (text.length() > 0) {
+                body.append("        ((java.util.List) v).add(").append(literal(text)).append(");\n");
+            }
+            return;
+        }
+        String property = defaultProperty(type.getInternalName());
+        if (property == null) {
+            throw new Failure(firstDefault == null ? e : firstDefault, java(type) + " has no default property,"
+                    + " so content must be inside a property element such as <children>");
+        }
+        assign(e, type, property, defaults, text, body);
+    }
+
+    private void propertyElement(Element child, Type type, StringBuilder body) throws Failure, IOException {
+        if (!isObject(type)) {
+            throw new Failure(child, "a " + java(type) + " has no properties");
+        }
+        for (Attribute a : child.attributes) {
+            throw new Failure(child, a.text() + ": a property element takes no attributes");
+        }
+        List<Value> values = new ArrayList<Value>();
+        for (Element inner : child.elements()) {
+            if (inner.fx && "define".equals(inner.name)) {
+                throw new Failure(inner, "<fx:define> cannot be inside a property element");
+            }
+            values.add(value(inner, false));
+        }
+        assign(child, type, child.name, values, child.content(), body);
+    }
+
+    /// Gives a property its content: one value through the setter, or
+    /// every value added to a list the getter answers.
+    private void assign(Element at, Type type, String property, List<Value> values, String text,
+            StringBuilder body) throws Failure, IOException {
+        String owner = type.getInternalName();
+        ClassModel.Method set = setter(owner, property);
+        ClassModel.Method get = getter(owner, property);
+        boolean list = get != null && isList(get.returnType());
+        if (set != null && values.size() == 1 && text.length() == 0) {
+            Type from = values.get(0).type;
+            Type to = boxed(set.parameters[0]);
+            boolean fits = !isObject(from) || !isObject(to) || model.find(from.getInternalName()) == null
+                    || model.isAssignable(from.getInternalName(), to.getInternalName());
+            if (fits || !list) {
+                requireAssignable(from, set.parameters[0], at);
+                body.append("        v.set").append(cap(property)).append('(').append(values.get(0).code)
+                        .append(");\n");
+                return;
+            }
+        }
+        if (set != null && values.isEmpty() && text.length() > 0 && !list) {
+            body.append("        v.set").append(cap(property)).append('(')
+                    .append(coerce(text, set.parameters[0], at)).append(");\n");
+            return;
+        }
+        if (list) {
+            Type element = elementType(get);
+            for (Value v : values) {
+                if (element != null) {
+                    requireAssignable(v.type, element, at);
+                }
+                body.append("        ((java.util.List) v.").append(get.name).append("()).add(").append(v.code)
+                        .append(");\n");
+            }
+            if (text.length() > 0) {
+                body.append("        ((java.util.List) v.").append(get.name).append("()).add(")
+                        .append(coerce(text, element == null ? STRING : element, at)).append(");\n");
+            }
+            return;
+        }
+        if (set == null && get == null) {
+            throw new Failure(at, java(type) + " has no property " + property + " (no public set" + cap(property)
+                    + " and no get" + cap(property) + ")");
+        }
+        throw new Failure(at, "the property " + property + " of " + java(type) + " takes one value, and "
+                + (values.isEmpty() ? "none" : String.valueOf(values.size())) + " were given");
+    }
+
+    private void staticElement(Element child, String className, String property, Type type, StringBuilder body)
+            throws Failure, IOException {
+        ClassModel.Info owner = need(className, child);
+        ClassModel.Method m = staticSetter(owner.name, property);
+        if (m == null) {
+            throw new Failure(child, owner.sourceName() + " has no static property " + property
+                    + " (a public static set" + cap(property) + " with two arguments)");
+        }
+        requireAssignable(type, m.parameters[0], child);
+        List<Element> inner = child.elements();
+        String code;
+        if (inner.size() == 1) {
+            Value v = value(inner.get(0), false);
+            requireAssignable(v.type, m.parameters[1], child);
+            code = v.code;
+        } else if (inner.isEmpty() && child.content().length() > 0) {
+            code = coerce(child.content(), m.parameters[1], child);
+        } else {
+            throw new Failure(child, "a static property takes exactly one value");
+        }
+        body.append("        ").append(owner.sourceName()).append(".set").append(cap(property)).append("(v, ")
+                .append(code).append(");\n");
+    }
+
+    // ---------------------------------------------------------- coercion
+
+    private static String fold(String s) {
+        StringBuilder out = new StringBuilder(s.length());
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            out.append(c >= 'a' && c <= 'z' ? (char) (c - ('a' - 'A')) : c == '-' ? '_' : c);
+        }
+        return out.toString();
+    }
+
+    private Failure cannot(String text, Type target, Element at) {
+        return new Failure(at, "\"" + text + "\" is not a " + java(target));
+    }
+
+    /// The code of `text` as a value of `target`.
+    private String coerce(String text, Type target, Element at) throws Failure, IOException {
+        String t = text.trim();
+        switch (target.getSort()) {
+            case Type.BOOLEAN:
+                if ("true".equalsIgnoreCase(t) || "false".equalsIgnoreCase(t)) {
+                    return "true".equalsIgnoreCase(t) ? "true" : "false";
+                }
+                throw cannot(text, target, at);
+            case Type.CHAR:
+                if (text.length() == 1) {
+                    String quoted = literal(text);
+                    return "'" + ("\"".equals(text) ? "\\\"" : "'".equals(text) ? "\\'"
+                            : quoted.substring(1, quoted.length() - 1)) + "'";
+                }
+                throw cannot(text, target, at);
+            case Type.BYTE:
+            case Type.SHORT:
+            case Type.INT:
+            case Type.LONG:
+                try {
+                    long n = Long.parseLong(t);
+                    if (target.getSort() == Type.LONG) {
+                        return n + "L";
+                    }
+                    if (n < Integer.MIN_VALUE || n > Integer.MAX_VALUE) {
+                        throw cannot(text, target, at);
+                    }
+                    return target.getSort() == Type.INT ? String.valueOf(n) : "(" + java(target) + ") " + n;
+                } catch (NumberFormatException e) {
+                    throw cannot(text, target, at);
+                }
+            case Type.FLOAT:
+                return "(float) " + number(t, target, at);
+            case Type.DOUBLE:
+                return number(t, target, at);
+            case Type.OBJECT:
+                return coerceObject(text, t, target, at);
+            case Type.ARRAY:
+                // A comma separated list is an array of a primitive, as the
+                // dividerPositions of a SplitPane are.
+                if (target.getDimensions() == 1 && target.getElementType().getSort() != Type.OBJECT) {
+                    StringBuilder array = new StringBuilder("new " + java(target) + " {");
+                    if (t.length() > 0) {
+                        String[] parts = t.split(",", -1);
+                        for (int i = 0; i < parts.length; i++) {
+                            array.append(i > 0 ? ", " : "").append(coerce(parts[i], target.getElementType(), at));
+                        }
+                    }
+                    return array.append('}').toString();
+                }
+                throw cannot(text, target, at);
+            default:
+                throw cannot(text, target, at);
+        }
+    }
+
+    private String number(String t, Type target, Element at) throws Failure {
+        if ("Infinity".equals(t) || "+Infinity".equals(t)) {
+            return "Double.POSITIVE_INFINITY";
+        }
+        if ("-Infinity".equals(t)) {
+            return "Double.NEGATIVE_INFINITY";
+        }
+        if ("NaN".equals(t)) {
+            return "Double.NaN";
+        }
+        try {
+            double d = Double.parseDouble(t);
+            if (Double.isInfinite(d) || Double.isNaN(d)) {
+                throw cannot(t, target, at);
+            }
+            return Double.toString(d);
+        } catch (NumberFormatException e) {
+            throw cannot(t, target, at);
+        }
+    }
+
+    private String coerceObject(String text, String t, Type target, Element at) throws Failure, IOException {
+        String name = target.getInternalName();
+        if ("java/lang/String".equals(name) || "java/lang/Object".equals(name)
+                || "java/lang/CharSequence".equals(name)) {
+            return literal(text);
+        }
+        if ("java/lang/Boolean".equals(name)) {
+            return "true".equals(coerce(t, Type.BOOLEAN_TYPE, at)) ? "Boolean.TRUE" : "Boolean.FALSE";
+        }
+        if ("java/lang/Integer".equals(name) || "java/lang/Short".equals(name) || "java/lang/Byte".equals(name)) {
+            return "Integer".equals(java(target).substring(10))
+                    ? "Integer.valueOf(" + coerce(t, Type.INT_TYPE, at) + ")"
+                    : java(target) + ".valueOf((" + ("java/lang/Short".equals(name) ? "short" : "byte") + ") "
+                            + coerce(t, Type.INT_TYPE, at) + ")";
+        }
+        if ("java/lang/Long".equals(name)) {
+            return "Long.valueOf(" + coerce(t, Type.LONG_TYPE, at) + ")";
+        }
+        if ("java/lang/Double".equals(name) || "java/lang/Number".equals(name)) {
+            return "Double.valueOf(" + number(t, target, at) + ")";
+        }
+        if ("java/lang/Float".equals(name)) {
+            return "Float.valueOf((float) " + number(t, target, at) + ")";
+        }
+        if ("java/lang/Character".equals(name)) {
+            return "Character.valueOf(" + coerce(text, Type.CHAR_TYPE, at) + ")";
+        }
+        ClassModel.Info info = model.find(name);
+        if (info == null) {
+            throw new Failure(at, "\"" + text + "\" cannot be converted: the class " + java(target)
+                    + " is not on the application's class path");
+        }
+        if (info.isEnum()) {
+            String wanted = fold(t);
+            for (ClassModel.Field f : info.fields) {
+                if ((f.access & Opcodes.ACC_ENUM) != 0 && (f.name.equals(t) || fold(f.name).equals(wanted))) {
+                    return info.sourceName() + "." + f.name;
+                }
+            }
+            throw new Failure(at, "\"" + text + "\" is not a constant of " + java(target));
+        }
+        if ("javafx/geometry/Insets".equals(name)) {
+            List<String> parts = numbers(t, target, at);
+            if (parts.size() == 1) {
+                return "new javafx.geometry.Insets(" + parts.get(0) + ")";
+            }
+            if (parts.size() == 4) {
+                return "new javafx.geometry.Insets(" + parts.get(0) + ", " + parts.get(1) + ", " + parts.get(2)
+                        + ", " + parts.get(3) + ")";
+            }
+            throw new Failure(at, "\"" + text + "\" is not an Insets: one number, or top right bottom left");
+        }
+        if ("javafx/scene/text/Font".equals(name)) {
+            CssValue font = values.parse("-fx-font", t);
+            if (font == null || font.type() != CssValue.FONT || font.unit(0) != CssValue.UNIT_PX) {
+                throw new Failure(at, "\"" + text + "\" is not a font: write it as in a style sheet,"
+                        + " such as \"bold 14px Arial\"");
+            }
+            int weight = font.flags() & 0xffff;
+            return "javafx.scene.text.Font.font(" + literal(font.text()) + ", "
+                    + (weight == 0 ? "javafx.scene.text.FontWeight.NORMAL"
+                            : "javafx.scene.text.FontWeight.findByWeight(" + weight + ")")
+                    + ", javafx.scene.text.FontPosture." + ((font.flags() >> 16) == 2 ? "ITALIC" : "REGULAR") + ", "
+                    + Double.toString(font.num(0)) + ")";
+        }
+        if ("javafx/scene/paint/Color".equals(name) && values.constantColor(t) == null) {
+            throw new Failure(at, "\"" + text + "\" is not a colour");
+        }
+        if ("javafx/scene/Cursor".equals(name)) {
+            return "javafx.scene.Cursor.cursor(" + literal(t) + ")";
+        }
+        for (ClassModel.Method m : model.methods(name, "valueOf")) {
+            if (m.isStatic() && m.parameters.length == 1 && isObject(m.parameters[0])
+                    && "java/lang/String".equals(m.parameters[0].getInternalName())
+                    && isObject(m.returnType())
+                    && model.isAssignable(m.returnType().getInternalName(), name)) {
+                return info.sourceName() + ".valueOf(" + literal(t) + ")";
+            }
+        }
+        throw new Failure(at, "\"" + text + "\" cannot be converted to a " + java(target)
+                + ": the class has no valueOf(String). Write the value as an element");
+    }
+
+    private List<String> numbers(String t, Type target, Element at) throws Failure {
+        List<String> out = new ArrayList<String>();
+        StringBuilder current = new StringBuilder();
+        for (int i = 0; i <= t.length(); i++) {
+            char c = i < t.length() ? t.charAt(i) : ' ';
+            if (c == ' ' || c == ',' || c == '\t' || c == '\n' || c == '\r') {
+                if (current.length() > 0) {
+                    out.add(number(current.toString(), target, at));
+                    current.setLength(0);
+                }
+            } else {
+                current.append(c);
+            }
+        }
+        return out;
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlDispatchGenerator.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlDispatchGenerator.java
new file mode 100644
index 00000000000..a1a57caefc0
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlDispatchGenerator.java
@@ -0,0 +1,754 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+/// Generates, from the compiled classes of an application, what an FXML
+/// loader does by reflection on a desktop: finding the class that builds a
+/// document, creating a controller, setting its `@FXML` fields and calling
+/// its handler methods.
+///
+/// #### Why after javac, and why bytecode
+///
+/// A controller's `@FXML` members are usually private. Source generated
+/// before compilation could not name them, and only the class files say for
+/// certain which members exist, of which types, and what a controller
+/// inherits. So this runs on the compiled classes and does two things:
+///
+/// - it widens what it needs to reach -- the controller class, its `@FXML`
+///   fields and methods, its `initialize()` and its no-argument constructor
+///   become public, in place. Nothing else about the class changes;
+/// - it writes the registry class, whose methods are chains of string
+///   comparisons ending in a direct field write or method call.
+///
+/// #### The registry
+///
+/// A subclass of the runtime's `FxmlDispatch` under the fixed name the
+/// runtime instantiates (the names are parameters, because the application
+/// sees the runtime relocated and the tests do not). It overrides
+///
+/// - `has(path)` and `load(path, context)` from the `CN1_PATH` constant of
+///   each compiled document;
+/// - `create(className)` for every `fx:controller` class that has a
+///   no-argument constructor, by `new`;
+/// - `inject`, `invoke` and `init`, which find the controller's class with
+///   `instanceof` -- the most derived class first -- and hand over to one
+///   small class per controller, `<registry>$C<n>`, so that the registry
+///   itself declares nothing its placeholder does not.
+///
+/// A field is only written after an `instanceof` check of the value: a
+/// failed cast does not throw on every Codename One port, so the generated
+/// code never relies on one.
+///
+/// #### Which methods are handlers
+///
+/// Every method marked `@FXML`, and every public method whose name some
+/// document uses as `#name`, provided it takes no argument or one object.
+/// A handler with both forms is called with the event when the event is of
+/// the parameter's type. Members a controller inherits from another class
+/// of the application are included.
+public final class FxmlDispatchGenerator {
+
+    /// The names the generated code refers to, which differ between an
+    /// application build -- where the runtime is relocated -- and a test.
+    public static final class Names {
+        final String registry;
+        final String dispatch;
+        final String context;
+        final String annotation;
+
+        /// Creates a set of names.
+        ///
+        /// #### Parameters
+        ///
+        /// - `registry`: the internal name of the class to generate
+        ///
+        /// - `dispatch`: the internal name of the runtime's `FxmlDispatch`
+        ///
+        /// - `context`: the internal name of the runtime's `FxmlContext`
+        ///
+        /// - `fxmlAnnotation`: the internal name of the `FXML` annotation
+        public Names(String registry, String dispatch, String context, String fxmlAnnotation) {
+            this.registry = registry;
+            this.dispatch = dispatch;
+            this.context = context;
+            this.annotation = "L" + fxmlAnnotation + ";";
+        }
+    }
+
+    /// The internal name of the runtime's dispatcher, before relocation.
+    public static final String DISPATCH = "com/codename1/fxcompat/runtime/FxmlDispatch";
+    /// The internal name of the runtime's registry placeholder, before
+    /// relocation.
+    public static final String REGISTRY = "com/codename1/fxcompat/runtime/FxmlRegistry";
+    /// The internal name of the runtime's load context, before relocation.
+    public static final String CONTEXT = "com/codename1/fxcompat/runtime/FxmlContext";
+    /// The internal name of the `FXML` annotation, before relocation.
+    public static final String ANNOTATION = "javafx/fxml/FXML";
+    /// The internal name prefix of every compiled document.
+    public static final String LOADER_PREFIX = "com/codename1/generated/fxml/Fxml_";
+
+    private static final String PART = "$C";
+    private static final int VISIBILITY = Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC;
+
+    private static final class Member {
+        final String owner;
+        final String name;
+        final String descriptor;
+        final int access;
+        final boolean annotated;
+
+        Member(String owner, String name, String descriptor, int access, boolean annotated) {
+            this.owner = owner;
+            this.name = name;
+            this.descriptor = descriptor;
+            this.access = access;
+            this.annotated = annotated;
+        }
+
+        String key() {
+            return name + descriptor;
+        }
+    }
+
+    private static final class Scanned {
+        String name;
+        String superName;
+        int access;
+        boolean annotated;
+        final List<Member> fields = new ArrayList<Member>();
+        final List<Member> methods = new ArrayList<Member>();
+        String path;
+        String controller;
+        String handlers;
+    }
+
+    /// What one controller class needs, its own and inherited.
+    private static final class Controller {
+        final Scanned type;
+        final int depth;
+        final List<Member> fields = new ArrayList<Member>();
+        final List<Member> handlers = new ArrayList<Member>();
+        Member initialize;
+
+        Controller(Scanned type, int depth) {
+            this.type = type;
+            this.depth = depth;
+        }
+    }
+
+    private final File classesDir;
+    private final Names names;
+    private int documents;
+    private int controllers;
+
+    /// The order the registry asks the controllers in: a subclass before
+    /// the class it extends, so the first that matches is the nearest.
+    private static final Comparator<Controller> MOST_DERIVED_FIRST = new Comparator<Controller>() {
+        @Override
+        public int compare(Controller a, Controller b) {
+            return a.depth != b.depth ? b.depth - a.depth : a.type.name.compareTo(b.type.name);
+        }
+    };
+
+    /// Creates a generator over a directory of compiled classes.
+    public FxmlDispatchGenerator(File classesDir, Names names) {
+        this.classesDir = classesDir;
+        this.names = names;
+    }
+
+    /// How many compiled documents the last run registered.
+    public int documents() {
+        return documents;
+    }
+
+    /// How many controller classes the last run generated code for.
+    public int controllers() {
+        return controllers;
+    }
+
+    /// Generates the registry for the given classes of the application --
+    /// internal names, as they are in the directory -- and widens the
+    /// controllers among them. A second run over its own output changes no
+    /// file.
+    public void run(Collection<String> appClasses) throws IOException {
+        Map<String, Scanned> all = new TreeMap<String, Scanned>();
+        for (String name : appClasses) {
+            File f = new File(classesDir, name + ".class");
+            if (f.isFile() && !name.equals(names.registry) && !name.startsWith(names.registry + PART)) {
+                Scanned s = scan(read(f), names.annotation);
+                all.put(s.name, s);
+            }
+        }
+        Map<String, Scanned> loaders = new TreeMap<String, Scanned>();
+        Set<String> handlerNames = new HashSet<String>();
+        Set<String> named = new TreeSet<String>();
+        for (Scanned s : all.values()) {
+            if (s.name.startsWith(LOADER_PREFIX) && s.path != null) {
+                loaders.put(s.path, s);
+                if (s.handlers != null && s.handlers.length() > 0) {
+                    handlerNames.addAll(Arrays.asList(s.handlers.split(",")));
+                }
+                if (s.controller != null && s.controller.length() > 0) {
+                    named.add(s.controller);
+                }
+            }
+        }
+        List<Controller> found = new ArrayList<Controller>();
+        for (Scanned s : all.values()) {
+            boolean isNamed = named.contains(s.name.replace('/', '.'));
+            if ((s.access & Opcodes.ACC_INTERFACE) != 0 || !(isNamed || s.annotated)) {
+                continue;
+            }
+            found.add(controller(s, all, handlerNames));
+        }
+        Collections.sort(found, MOST_DERIVED_FIRST);
+
+        // Widen first: the registry refers to the members as public ones.
+        Map<String, Set<String>> widen = new LinkedHashMap<String, Set<String>>();
+        List<String> creatable = new ArrayList<String>();
+        for (Controller c : found) {
+            need(widen, c.type.name, null);
+            for (Member m : c.fields) {
+                need(widen, m.owner, m.key());
+            }
+            for (Member m : c.handlers) {
+                need(widen, m.owner, m.key());
+            }
+            if (c.initialize != null) {
+                need(widen, c.initialize.owner, c.initialize.key());
+            }
+        }
+        for (String binary : named) {
+            Scanned s = all.get(binary.replace('.', '/'));
+            if (s == null || (s.access & (Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE)) != 0) {
+                continue;
+            }
+            for (Member m : s.methods) {
+                if ("<init>".equals(m.name) && "()V".equals(m.descriptor)) {
+                    need(widen, s.name, m.key());
+                    creatable.add(binary);
+                }
+            }
+        }
+        for (Map.Entry<String, Set<String>> e : widen.entrySet()) {
+            File f = new File(classesDir, e.getKey() + ".class");
+            writeIfDifferent(f, widen(read(f), widen.keySet(), e.getValue()));
+        }
+
+        for (int i = 0; i < found.size(); i++) {
+            writeIfDifferent(new File(classesDir, names.registry + PART + i + ".class"),
+                    part(names.registry + PART + i, found.get(i)));
+        }
+        deleteStaleParts(found.size());
+        writeIfDifferent(new File(classesDir, names.registry + ".class"), registry(loaders, creatable, found));
+        documents = loaders.size();
+        controllers = found.size();
+    }
+
+    private static void need(Map<String, Set<String>> widen, String owner, String member) {
+        Set<String> members = widen.get(owner);
+        if (members == null) {
+            members = new HashSet<String>();
+            widen.put(owner, members);
+        }
+        if (member != null) {
+            members.add(member);
+        }
+    }
+
+    private void deleteStaleParts(int count) throws IOException {
+        File registry = new File(classesDir, names.registry + ".class");
+        File dir = registry.getParentFile();
+        String prefix = names.registry.substring(names.registry.lastIndexOf('/') + 1) + PART;
+        File[] files = dir == null ? null : dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            String n = f.getName();
+            if (!n.startsWith(prefix) || !n.endsWith(".class")) {
+                continue;
+            }
+            String index = n.substring(prefix.length(), n.length() - 6);
+            boolean stale;
+            try {
+                stale = Integer.parseInt(index) >= count;
+            } catch (NumberFormatException e) {
+                stale = false;
+            }
+            if (stale && !f.delete()) {
+                throw new IOException("Could not delete the stale " + f);
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ reading
+
+    private static byte[] read(File f) throws IOException {
+        InputStream in = new FileInputStream(f);
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            byte[] buffer = new byte[8192];
+            int n;
+            while ((n = in.read(buffer)) > 0) {
+                out.write(buffer, 0, n);
+            }
+            return out.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    /// Writes a file unless it already holds exactly these bytes, so that a
+    /// build that changes nothing touches nothing.
+    static boolean writeIfDifferent(File f, byte[] bytes) throws IOException {
+        if (f.isFile() && f.length() == bytes.length && Arrays.equals(read(f), bytes)) {
+            return false;
+        }
+        File dir = f.getParentFile();
+        if (dir != null && !dir.isDirectory() && !dir.mkdirs() && !dir.isDirectory()) {
+            throw new IOException("Could not create " + dir);
+        }
+        OutputStream out = new FileOutputStream(f);
+        try {
+            out.write(bytes);
+        } finally {
+            out.close();
+        }
+        return true;
+    }
+
+    private static Scanned scan(byte[] bytes, final String fxml) {
+        final Scanned s = new Scanned();
+        new ClassReader(bytes).accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public void visit(int version, int access, String name, String signature, String superName,
+                    String[] interfaces) {
+                s.name = name;
+                s.superName = superName;
+                s.access = access;
+            }
+
+            @Override
+            public FieldVisitor visitField(final int access, final String name, final String descriptor,
+                    String signature, Object value) {
+                if ((access & Opcodes.ACC_STATIC) != 0 && value instanceof String) {
+                    if ("CN1_PATH".equals(name)) {
+                        s.path = (String) value;
+                    } else if ("CN1_CONTROLLER".equals(name)) {
+                        s.controller = (String) value;
+                    } else if ("CN1_HANDLERS".equals(name)) {
+                        s.handlers = (String) value;
+                    }
+                }
+                final int at = s.fields.size();
+                s.fields.add(new Member(s.name, name, descriptor, access, false));
+                return new FieldVisitor(Opcodes.ASM9) {
+                    @Override
+                    public AnnotationVisitor visitAnnotation(String annotation, boolean visible) {
+                        if (fxml.equals(annotation)) {
+                            s.annotated = true;
+                            s.fields.set(at, new Member(s.name, name, descriptor, access, true));
+                        }
+                        return null;
+                    }
+                };
+            }
+
+            @Override
+            public MethodVisitor visitMethod(final int access, final String name, final String descriptor,
+                    String signature, String[] exceptions) {
+                if ((access & (Opcodes.ACC_SYNTHETIC | Opcodes.ACC_BRIDGE)) != 0) {
+                    return null;
+                }
+                final int at = s.methods.size();
+                s.methods.add(new Member(s.name, name, descriptor, access, false));
+                return new MethodVisitor(Opcodes.ASM9) {
+                    @Override
+                    public AnnotationVisitor visitAnnotation(String annotation, boolean visible) {
+                        if (fxml.equals(annotation)) {
+                            s.annotated = true;
+                            s.methods.set(at, new Member(s.name, name, descriptor, access, true));
+                        }
+                        return null;
+                    }
+                };
+            }
+        }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return s;
+    }
+
+    private static Controller controller(Scanned type, Map<String, Scanned> all, Set<String> handlerNames) {
+        int depth = 0;
+        for (Scanned s = all.get(type.superName); s != null; s = all.get(s.superName)) {
+            depth++;
+        }
+        Controller c = new Controller(type, depth);
+        Set<String> fields = new HashSet<String>();
+        Set<String> methods = new HashSet<String>();
+        for (Scanned s = type; s != null; s = all.get(s.superName)) {
+            for (Member f : s.fields) {
+                int sort = Type.getType(f.descriptor).getSort();
+                // A public field is the document's to set without the
+                // annotation, as it is for a desktop loader.
+                boolean settable = (f.annotated || (f.access & Opcodes.ACC_PUBLIC) != 0)
+                        && (f.access & (Opcodes.ACC_STATIC | Opcodes.ACC_FINAL)) == 0
+                        && (sort == Type.OBJECT || sort == Type.ARRAY);
+                // A field of a subclass hides the one it shadows.
+                if (settable && fields.add(f.name)) {
+                    c.fields.add(f);
+                }
+            }
+            for (Member m : s.methods) {
+                if (m.name.startsWith("<") || (m.access & Opcodes.ACC_ABSTRACT) != 0) {
+                    continue;
+                }
+                Type[] args = Type.getArgumentTypes(m.descriptor);
+                if ("initialize".equals(m.name) && args.length == 0 && (m.access & Opcodes.ACC_STATIC) == 0) {
+                    if (c.initialize == null) {
+                        c.initialize = m;
+                    }
+                    continue;
+                }
+                boolean wanted = m.annotated
+                        || ((m.access & Opcodes.ACC_PUBLIC) != 0 && handlerNames.contains(m.name));
+                boolean callable = args.length == 0 || (args.length == 1 && args[0].getSort() == Type.OBJECT);
+                if (wanted && callable && methods.add(m.key())) {
+                    c.handlers.add(m);
+                }
+            }
+        }
+        return c;
+    }
+
+    // ----------------------------------------------------------- widening
+
+    private static int open(int access) {
+        return (access & ~VISIBILITY) | Opcodes.ACC_PUBLIC;
+    }
+
+    private static byte[] widen(byte[] bytes, final Set<String> classes, final Set<String> members) {
+        ClassReader reader = new ClassReader(bytes);
+        ClassWriter writer = new ClassWriter(0);
+        final String[] self = new String[1];
+        reader.accept(new ClassVisitor(Opcodes.ASM9, writer) {
+            @Override
+            public void visit(int version, int access, String name, String signature, String superName,
+                    String[] interfaces) {
+                self[0] = name;
+                super.visit(version, open(access), name, signature, superName, interfaces);
+            }
+
+            @Override
+            public void visitInnerClass(String name, String outerName, String innerName, int access) {
+                super.visitInnerClass(name, outerName, innerName, classes.contains(name) ? open(access) : access);
+            }
+
+            @Override
+            public FieldVisitor visitField(int access, String name, String descriptor, String signature,
+                    Object value) {
+                return super.visitField(members.contains(name + descriptor) ? open(access) : access, name,
+                        descriptor, signature, value);
+            }
+
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                return super.visitMethod(members.contains(name + descriptor) ? open(access) : access, name,
+                        descriptor, signature, exceptions);
+            }
+        }, 0);
+        return writer.toByteArray();
+    }
+
+    // --------------------------------------------------------- generating
+
+    private static void ifNotNamed(MethodVisitor mv, String literal, int argument, Label otherwise) {
+        mv.visitLdcInsn(literal);
+        mv.visitVarInsn(Opcodes.ALOAD, argument);
+        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "equals", "(Ljava/lang/Object;)Z", false);
+        mv.visitJumpInsn(Opcodes.IFEQ, otherwise);
+    }
+
+    private static void answer(MethodVisitor mv, boolean value) {
+        mv.visitInsn(value ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
+        mv.visitInsn(Opcodes.IRETURN);
+    }
+
+    private static void end(MethodVisitor mv) {
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    private byte[] registry(Map<String, Scanned> loaders, List<String> creatable, List<Controller> found) {
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, names.registry, null,
+                names.dispatch, null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, names.dispatch, "<init>", "()V", false);
+        mv.visitInsn(Opcodes.RETURN);
+        end(mv);
+
+        mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "has", "(Ljava/lang/String;)Z", null, null);
+        mv.visitCode();
+        for (String path : loaders.keySet()) {
+            Label next = new Label();
+            ifNotNamed(mv, path, 1, next);
+            answer(mv, true);
+            mv.visitLabel(next);
+        }
+        answer(mv, false);
+        end(mv);
+
+        String loadDescriptor = "(Ljava/lang/String;L" + names.context + ";)Ljava/lang/Object;";
+        mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "load", loadDescriptor, null, new String[] {"java/lang/Exception"});
+        mv.visitCode();
+        for (Map.Entry<String, Scanned> e : loaders.entrySet()) {
+            Label next = new Label();
+            ifNotNamed(mv, e.getKey(), 1, next);
+            mv.visitVarInsn(Opcodes.ALOAD, 2);
+            mv.visitMethodInsn(Opcodes.INVOKESTATIC, e.getValue().name, "load",
+                    "(L" + names.context + ";)Ljava/lang/Object;", false);
+            mv.visitInsn(Opcodes.ARETURN);
+            mv.visitLabel(next);
+        }
+        mv.visitInsn(Opcodes.ACONST_NULL);
+        mv.visitInsn(Opcodes.ARETURN);
+        end(mv);
+
+        mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "create", "(Ljava/lang/String;)Ljava/lang/Object;", null, null);
+        mv.visitCode();
+        for (String binary : creatable) {
+            Label next = new Label();
+            ifNotNamed(mv, binary, 1, next);
+            String internal = binary.replace('.', '/');
+            mv.visitTypeInsn(Opcodes.NEW, internal);
+            mv.visitInsn(Opcodes.DUP);
+            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, internal, "<init>", "()V", false);
+            mv.visitInsn(Opcodes.ARETURN);
+            mv.visitLabel(next);
+        }
+        mv.visitInsn(Opcodes.ACONST_NULL);
+        mv.visitInsn(Opcodes.ARETURN);
+        end(mv);
+
+        delegate(cw, found, "inject", "Ljava/lang/String;Ljava/lang/Object;", null);
+        delegate(cw, found, "invoke", "Ljava/lang/String;Ljava/lang/Object;", new String[] {"java/lang/Exception"});
+        delegate(cw, found, "init", "", new String[] {"java/lang/Exception"});
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    /// One of the three methods that take a controller: the first class the
+    /// controller is an instance of answers, through its part class.
+    private void delegate(ClassWriter cw, List<Controller> found, String method, String rest, String[] throwing) {
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, method, "(Ljava/lang/Object;" + rest + ")Z", null,
+                throwing);
+        mv.visitCode();
+        int extra = rest.length() == 0 ? 0 : 2;
+        for (int i = 0; i < found.size(); i++) {
+            String type = found.get(i).type.name;
+            Label next = new Label();
+            mv.visitVarInsn(Opcodes.ALOAD, 1);
+            mv.visitTypeInsn(Opcodes.INSTANCEOF, type);
+            mv.visitJumpInsn(Opcodes.IFEQ, next);
+            mv.visitVarInsn(Opcodes.ALOAD, 1);
+            mv.visitTypeInsn(Opcodes.CHECKCAST, type);
+            for (int a = 0; a < extra; a++) {
+                mv.visitVarInsn(Opcodes.ALOAD, 2 + a);
+            }
+            mv.visitMethodInsn(Opcodes.INVOKESTATIC, names.registry + PART + i, method, "(L" + type + ";" + rest
+                    + ")Z", false);
+            mv.visitInsn(Opcodes.IRETURN);
+            mv.visitLabel(next);
+        }
+        answer(mv, false);
+        end(mv);
+    }
+
+    private byte[] part(String name, Controller c) {
+        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cw.visit(Opcodes.V1_5, Opcodes.ACC_FINAL | Opcodes.ACC_SUPER, name, null, "java/lang/Object", null);
+        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PRIVATE, "<init>", "()V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        mv.visitInsn(Opcodes.RETURN);
+        end(mv);
+        String self = "L" + c.type.name + ";";
+
+        mv = cw.visitMethod(Opcodes.ACC_STATIC, "inject", "(" + self + "Ljava/lang/String;Ljava/lang/Object;)Z",
+                null, null);
+        mv.visitCode();
+        for (Member f : c.fields) {
+            Type type = Type.getType(f.descriptor);
+            Label next = new Label();
+            Label set = new Label();
+            ifNotNamed(mv, f.name, 1, next);
+            mv.visitVarInsn(Opcodes.ALOAD, 2);
+            mv.visitJumpInsn(Opcodes.IFNULL, set);
+            mv.visitVarInsn(Opcodes.ALOAD, 2);
+            mv.visitTypeInsn(Opcodes.INSTANCEOF, type.getInternalName());
+            mv.visitJumpInsn(Opcodes.IFNE, set);
+            // Not a value of the field's type: say so rather than cast.
+            mv.visitVarInsn(Opcodes.ALOAD, 1);
+            mv.visitLdcInsn(type.getClassName());
+            mv.visitVarInsn(Opcodes.ALOAD, 2);
+            mv.visitMethodInsn(Opcodes.INVOKESTATIC, names.dispatch, "mismatch",
+                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)V", false);
+            answer(mv, true);
+            mv.visitLabel(set);
+            mv.visitVarInsn(Opcodes.ALOAD, 0);
+            mv.visitVarInsn(Opcodes.ALOAD, 2);
+            mv.visitTypeInsn(Opcodes.CHECKCAST, type.getInternalName());
+            mv.visitFieldInsn(Opcodes.PUTFIELD, f.owner, f.name, f.descriptor);
+            answer(mv, true);
+            mv.visitLabel(next);
+        }
+        answer(mv, false);
+        end(mv);
+
+        mv = cw.visitMethod(Opcodes.ACC_STATIC, "invoke", "(" + self + "Ljava/lang/String;Ljava/lang/Object;)Z",
+                null, new String[] {"java/lang/Exception"});
+        mv.visitCode();
+        // The form that takes the event first, so that it is preferred
+        // whenever the event is of its type.
+        for (int pass = 1; pass >= 0; pass--) {
+            for (Member m : c.handlers) {
+                Type[] args = Type.getArgumentTypes(m.descriptor);
+                if (args.length != pass) {
+                    continue;
+                }
+                Label next = new Label();
+                ifNotNamed(mv, m.name, 1, next);
+                boolean isStatic = (m.access & Opcodes.ACC_STATIC) != 0;
+                if (pass == 1) {
+                    mv.visitVarInsn(Opcodes.ALOAD, 2);
+                    mv.visitTypeInsn(Opcodes.INSTANCEOF, args[0].getInternalName());
+                    mv.visitJumpInsn(Opcodes.IFEQ, next);
+                }
+                if (!isStatic) {
+                    mv.visitVarInsn(Opcodes.ALOAD, 0);
+                }
+                if (pass == 1) {
+                    mv.visitVarInsn(Opcodes.ALOAD, 2);
+                    mv.visitTypeInsn(Opcodes.CHECKCAST, args[0].getInternalName());
+                }
+                mv.visitMethodInsn(isStatic ? Opcodes.INVOKESTATIC : Opcodes.INVOKEVIRTUAL, m.owner, m.name,
+                        m.descriptor, false);
+                int size = Type.getReturnType(m.descriptor).getSize();
+                if (size == 1) {
+                    mv.visitInsn(Opcodes.POP);
+                } else if (size == 2) {
+                    mv.visitInsn(Opcodes.POP2);
+                }
+                answer(mv, true);
+                mv.visitLabel(next);
+            }
+        }
+        answer(mv, false);
+        end(mv);
+
+        mv = cw.visitMethod(Opcodes.ACC_STATIC, "init", "(" + self + ")Z", null,
+                new String[] {"java/lang/Exception"});
+        mv.visitCode();
+        if (c.initialize != null) {
+            mv.visitVarInsn(Opcodes.ALOAD, 0);
+            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, c.initialize.owner, "initialize", c.initialize.descriptor,
+                    false);
+            int size = Type.getReturnType(c.initialize.descriptor).getSize();
+            if (size == 1) {
+                mv.visitInsn(Opcodes.POP);
+            } else if (size == 2) {
+                mv.visitInsn(Opcodes.POP2);
+            }
+            answer(mv, true);
+        } else {
+            answer(mv, false);
+        }
+        end(mv);
+        cw.visitEnd();
+        return cw.toByteArray();
+    }
+
+    /// The classes of a directory as internal names, for a caller that has
+    /// no list of its own.
+    public static List<String> classesIn(File dir) {
+        List<String> out = new ArrayList<String>();
+        collect(dir, "", out);
+        Collections.sort(out);
+        return out;
+    }
+
+    private static void collect(File dir, String prefix, List<String> out) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                collect(f, prefix + f.getName() + "/", out);
+            } else if (f.getName().endsWith(".class")) {
+                out.add(prefix + f.getName().substring(0, f.getName().length() - 6));
+            }
+        }
+    }
+
+    /// The names of an unrelocated runtime, as a test of this module or of
+    /// the layer sees it, with the registry under a name of the caller's.
+    public static Names unrelocated(String registry) {
+        return new Names(registry, DISPATCH, CONTEXT, ANNOTATION);
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlDocument.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlDocument.java
new file mode 100644
index 00000000000..81f0f5b33d0
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/FxmlDocument.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.InputSource;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.helpers.DefaultHandler;
+
+/// An FXML file as the compiler reads it: the element tree with the line
+/// and column of every element, and the `<?import?>` instructions.
+///
+/// The position of an element is where its start tag ends, which is what
+/// the XML parser reports; a message says which attribute it is about.
+final class FxmlDocument {
+
+    /// What an `fx:` name is in: the FXML namespace, whatever its version.
+    private static final String FX = "http://javafx.com/fxml";
+
+    /// One attribute.
+    static final class Attribute {
+        final String name;
+        final boolean fx;
+        final String value;
+
+        Attribute(String name, boolean fx, String value) {
+            this.name = name;
+            this.fx = fx;
+            this.value = value;
+        }
+
+        /// The attribute as it was written, for a message.
+        String text() {
+            return (fx ? "fx:" : "") + name + "=\"" + value + "\"";
+        }
+    }
+
+    /// One element. A child is an [Element] or a `String` of text.
+    static final class Element {
+        final String name;
+        final boolean fx;
+        final int line;
+        final int column;
+        final List<Attribute> attributes = new ArrayList<Attribute>();
+        final List<Object> children = new ArrayList<Object>();
+
+        Element(String name, boolean fx, int line, int column) {
+            this.name = name;
+            this.fx = fx;
+            this.line = line;
+            this.column = column;
+        }
+
+        /// The value of an `fx:` attribute, or `null`.
+        String fx(String attribute) {
+            for (Attribute a : attributes) {
+                if (a.fx && a.name.equals(attribute)) {
+                    return a.value;
+                }
+            }
+            return null;
+        }
+
+        /// The value of a plain attribute, or `null`.
+        String plain(String attribute) {
+            for (Attribute a : attributes) {
+                if (!a.fx && a.name.equals(attribute)) {
+                    return a.value;
+                }
+            }
+            return null;
+        }
+
+        /// The start tag as it was written, for a message.
+        String text() {
+            StringBuilder s = new StringBuilder("<").append(fx ? "fx:" : "").append(name);
+            for (Attribute a : attributes) {
+                s.append(' ').append(a.text());
+            }
+            return s.append('>').toString();
+        }
+
+        /// The text directly inside the element, trimmed; empty when there
+        /// is none.
+        String content() {
+            StringBuilder s = new StringBuilder();
+            for (Object child : children) {
+                if (child instanceof String) {
+                    s.append((String) child);
+                }
+            }
+            return s.toString().trim();
+        }
+
+        /// The child elements.
+        List<Element> elements() {
+            List<Element> out = new ArrayList<Element>();
+            for (Object child : children) {
+                if (child instanceof Element) {
+                    out.add((Element) child);
+                }
+            }
+            return out;
+        }
+    }
+
+    /// The file, as messages name it.
+    final String file;
+    /// The resource path, without a leading slash.
+    final String path;
+    /// The imports in the order written: a class name, or a package
+    /// followed by `.*`.
+    final List<String> imports = new ArrayList<String>();
+    Element root;
+
+    private FxmlDocument(String file, String path) {
+        this.file = file;
+        this.path = path;
+    }
+
+    /// Reads a document. Answers `null`, with the reason recorded as an
+    /// error, for a file that is not well formed XML or that uses a
+    /// scripting language.
+    static FxmlDocument parse(String file, String path, InputStream in, final Messages messages)
+            throws IOException {
+        final FxmlDocument doc = new FxmlDocument(file, path);
+        final boolean[] failed = new boolean[1];
+        try {
+            SAXParserFactory factory = SAXParserFactory.newInstance();
+            factory.setNamespaceAware(true);
+            factory.setValidating(false);
+            // A document is the application's own file, but nothing in FXML
+            // needs a DTD or an external entity, and a build must not fetch
+            // one.
+            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+            factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
+            factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
+            SAXParser parser = factory.newSAXParser();
+            InputSource source = new InputSource(in);
+            source.setSystemId(file);
+            parser.parse(source, new DefaultHandler() {
+                private Locator locator;
+                private final List<Element> stack = new ArrayList<Element>();
+
+                @Override
+                public void setDocumentLocator(Locator l) {
+                    locator = l;
+                }
+
+                @Override
+                public void processingInstruction(String target, String data) {
+                    String value = data == null ? "" : data.trim();
+                    if ("import".equals(target)) {
+                        doc.imports.add(value);
+                    } else if ("language".equals(target)) {
+                        failed[0] = true;
+                        doc.error(messages, locator, "<?language " + value + "?>: scripts are not supported. A"
+                                + " document is compiled to Java; write the handler as a controller method and"
+                                + " name it with onAction=\"#method\"");
+                    }
+                }
+
+                @Override
+                public void startElement(String uri, String localName, String qName, Attributes attributes) {
+                    Element e = new Element(localName, isFx(uri), locator.getLineNumber(),
+                            locator.getColumnNumber());
+                    for (int i = 0; i < attributes.getLength(); i++) {
+                        e.attributes.add(new Attribute(attributes.getLocalName(i), isFx(attributes.getURI(i)),
+                                attributes.getValue(i)));
+                    }
+                    if (stack.isEmpty()) {
+                        doc.root = e;
+                    } else {
+                        stack.get(stack.size() - 1).children.add(e);
+                    }
+                    stack.add(e);
+                }
+
+                @Override
+                public void endElement(String uri, String localName, String qName) {
+                    stack.remove(stack.size() - 1);
+                }
+
+                @Override
+                public void characters(char[] ch, int start, int length) {
+                    if (!stack.isEmpty()) {
+                        stack.get(stack.size() - 1).children.add(new String(ch, start, length));
+                    }
+                }
+
+                @Override
+                public void error(SAXParseException e) throws SAXException {
+                    throw e;
+                }
+            });
+        } catch (SAXParseException e) {
+            messages.error(file, Math.max(1, e.getLineNumber()), Math.max(1, e.getColumnNumber()),
+                    "not well formed XML: " + e.getMessage());
+            return null;
+        } catch (SAXException e) {
+            messages.error(file, 1, 1, "not well formed XML: " + e.getMessage());
+            return null;
+        } catch (ParserConfigurationException e) {
+            throw new IOException("No usable XML parser in this JDK: " + e.getMessage(), e);
+        }
+        if (failed[0] || doc.root == null) {
+            return null;
+        }
+        return doc;
+    }
+
+    private static boolean isFx(String uri) {
+        return uri != null && uri.startsWith(FX);
+    }
+
+    private void error(Messages messages, Locator locator, String message) {
+        messages.error(file, locator == null ? 1 : locator.getLineNumber(),
+                locator == null ? 1 : locator.getColumnNumber(), message);
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/Messages.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/Messages.java
new file mode 100644
index 00000000000..5872b6b01c5
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/Messages.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// What the compilers found, each entry in the form an IDE and a build log
+/// link back to the source: `file:line:column: message`.
+///
+/// An error fails the build once everything has been compiled -- every
+/// document is still compiled, so that one run reports all of them. A
+/// warning is printed and the build goes on: it is what a style sheet gets
+/// for a property or a value this layer does not have, which a style sheet
+/// written for the desktop is full of.
+public final class Messages {
+
+    private final List<String> errors = new ArrayList<String>();
+    private final List<String> warnings = new ArrayList<String>();
+
+    /// Creates an empty collection.
+    public Messages() {
+        // Nothing found yet.
+    }
+
+    /// The position of `offset` in `text` as `line:column`, both from 1.
+    static String position(String text, int offset) {
+        int line = 1;
+        int column = 1;
+        int end = Math.min(offset, text.length());
+        for (int i = 0; i < end; i++) {
+            if (text.charAt(i) == '\n') {
+                line++;
+                column = 1;
+            } else {
+                column++;
+            }
+        }
+        return line + ":" + column;
+    }
+
+    /// Records an error at a position.
+    public void error(String file, int line, int column, String message) {
+        errors.add(file + ":" + line + ":" + column + ": " + message);
+    }
+
+    /// Records an error at an offset in the text of a file.
+    void error(String file, String text, int offset, String message) {
+        errors.add(file + ":" + position(text, offset) + ": " + message);
+    }
+
+    /// Records a warning at an offset in the text of a file.
+    void warning(String file, String text, int offset, String message) {
+        warnings.add(file + ":" + position(text, offset) + ": " + message);
+    }
+
+    /// Records a warning about a file as a whole.
+    void warning(String file, String message) {
+        warnings.add(file + ": " + message);
+    }
+
+    /// The errors, in the order found.
+    public List<String> errors() {
+        return Collections.unmodifiableList(errors);
+    }
+
+    /// The warnings, in the order found.
+    public List<String> warnings() {
+        return Collections.unmodifiableList(warnings);
+    }
+
+    /// Whether anything was found that fails the build.
+    public boolean hasErrors() {
+        return !errors.isEmpty();
+    }
+}
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/css/package-info.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/css/package-info.java
new file mode 100644
index 00000000000..6aad3c87110
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/css/package-info.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The style value parser and the compiled style sheet format, as the
+/// build runs them.
+///
+/// The classes of this package are not written here. They are the sources
+/// of `com.codename1.fxcompat.runtime.css` in the JavaFX compatibility
+/// layer, copied under this package name when the module is built; see the
+/// description of that package for what they are and the `pom.xml` of this
+/// module for why they are copied rather than depended on. Change them
+/// there.
+package com.codename1.fxml.css;
diff --git a/maven/fxml-compiler/src/main/java/com/codename1/fxml/package-info.java b/maven/fxml-compiler/src/main/java/com/codename1/fxml/package-info.java
new file mode 100644
index 00000000000..af459024c41
--- /dev/null
+++ b/maven/fxml-compiler/src/main/java/com/codename1/fxml/package-info.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The build-time half of FXML and style sheet support in the JavaFX
+/// compatibility layer.
+///
+/// A device has no XML parser to spare, no reflection and no CSS parser, so
+/// everything a desktop `FXMLLoader` and style manager work out while the
+/// application runs is worked out here, while it is built:
+///
+/// - [com.codename1.fxml.DesktopResourceCompiler] is what a build plugin
+///   calls before javac: it turns every FXML document into Java source and
+///   every style sheet into a binary table.
+/// - [com.codename1.fxml.FxmlDispatchGenerator] is what the remap step
+///   calls after javac: it generates the code that reaches a controller's
+///   `@FXML` members.
+///
+/// The module depends on the JDK, on ASM and on the resource naming rule,
+/// and on nothing of the layer itself: the layer's classes are read as
+/// class files from the application's class path.
+package com.codename1.fxml;
diff --git a/maven/fxml-compiler/src/test/java/com/codename1/fxml/CssTest.java b/maven/fxml-compiler/src/test/java/com/codename1/fxml/CssTest.java
new file mode 100644
index 00000000000..eb617931595
--- /dev/null
+++ b/maven/fxml-compiler/src/test/java/com/codename1/fxml/CssTest.java
@@ -0,0 +1,731 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.StyleEngine;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.fxcompat.runtime.css.CssSheetData;
+import com.codename1.fxcompat.runtime.css.CssValue;
+
+import javafx.css.PseudoClass;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Cursor;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.Paint;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.text.FontPosture;
+import javafx.scene.text.FontWeight;
+
+/// Style sheets from their text to the nodes they style: the build's
+/// compiler writes the binary table, and the engine of the layer reads it
+/// back from the application's resources and runs the cascade.
+public class CssTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private FxmlHarness app;
+    private VBox root;
+    private HBox bar;
+    private Label title;
+    private Button ok;
+    private Label plain;
+    private Scene scene;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        StyleEngine.setInstance(null);
+    }
+
+    @After
+    public void tearDown() throws IOException {
+        if (app != null) {
+            app.close();
+        }
+        Units.setScale(0);
+        StyleEngine.setInstance(null);
+    }
+
+    /// Builds an application whose only resource is a style sheet, and a
+    /// scene that uses it:
+    ///
+    /// ```
+    /// VBox.root
+    ///   HBox.bar
+    ///     Label#title.title
+    ///     Button.primary
+    ///   Label
+    /// ```
+    private void styled(String name, String css) throws Exception {
+        app = new FxmlHarness(name).resource("style/app.css", css);
+        app.build();
+        tree();
+        scene.getStylesheets().add("file:/work/app/target/classes/style/app.css");
+    }
+
+    private void tree() {
+        root = new VBox();
+        bar = new HBox();
+        bar.getStyleClass().add("bar");
+        title = new Label("title");
+        title.setId("title");
+        title.getStyleClass().add("title");
+        ok = new Button("ok");
+        ok.getStyleClass().add("primary");
+        plain = new Label("plain");
+        bar.getChildren().addAll(title, ok);
+        root.getChildren().addAll(bar, plain);
+        scene = new Scene(root, 200, 200);
+    }
+
+    private static Paint fill(Region r) {
+        return r.getBackground() == null ? null : r.getBackground().getFills().get(0).getFill();
+    }
+
+    // ---------------------------------------------------------- matching
+
+    @Test
+    public void selectorsMatchByTypeClassIdAndPosition() throws Exception {
+        styled("match", "Label { -fx-text-fill: blue; }\n"
+                + ".bar { -fx-spacing: 7; }\n"
+                + "#title { -fx-underline: true; }\n"
+                + ".bar > .primary { -fx-text-fill: red; }\n"
+                + ".root Button { -fx-wrap-text: true; }\n"
+                + ".root > Button { -fx-underline: true; }\n"
+                + "VBox > Label { -fx-wrap-text: true; }\n"
+                + "Label.title#title { -fx-opacity: 0.5; }\n"
+                + "* { -fx-cursor: hand; }\n"
+                + ".nothing .bar, .root .bar { -fx-alignment: center-right; }\n");
+        assertEquals(Color.BLUE, title.getTextFill());
+        assertEquals(Color.BLUE, plain.getTextFill());
+        assertEquals(7, bar.getSpacing(), 0);
+        assertTrue(title.isUnderline());
+        assertFalse(plain.isUnderline());
+        assertEquals(Color.RED, ok.getTextFill());
+        // A descendant at any depth matches the descendant selector, only a
+        // direct child matches '>'.
+        assertTrue(ok.isWrapText());
+        assertFalse(ok.isUnderline());
+        assertTrue(plain.isWrapText());
+        assertFalse(title.isWrapText());
+        assertEquals(0.5, title.getOpacity(), 0);
+        assertEquals(1, plain.getOpacity(), 0);
+        assertEquals(Cursor.HAND, plain.getCursor());
+        assertEquals(Cursor.HAND, root.getCursor());
+        assertEquals(Pos.CENTER_RIGHT, bar.getAlignment());
+    }
+
+    @Test
+    public void theCascadeOrdersBySpecificityThenSourceOrderThenImportance() throws Exception {
+        styled("cascade", "#title { -fx-text-fill: green; }\n"
+                + ".title { -fx-text-fill: red; -fx-opacity: 0.2; }\n"
+                + "Label { -fx-text-fill: blue; -fx-opacity: 0.9 !important; -fx-underline: true; }\n"
+                + "Label { -fx-underline: false; }\n"
+                + ".bar .title { -fx-wrap-text: true; }\n"
+                + ".title { -fx-wrap-text: false; }\n");
+        // The id beats the class beats the type, whatever the order.
+        assertEquals(Color.GREEN, title.getTextFill());
+        assertEquals(Color.BLUE, plain.getTextFill());
+        // !important beats a more specific rule.
+        assertEquals(0.9, title.getOpacity(), 0);
+        // Of two rules of one specificity the later wins.
+        assertFalse(plain.isUnderline());
+        // Two classes beat one that comes later.
+        assertTrue(title.isWrapText());
+    }
+
+    @Test
+    public void inlineStyleBeatsTheSheetsAndIsWithdrawn() throws Exception {
+        styled("inline", ".title { -fx-text-fill: red; -fx-opacity: 0.5 !important; }\n");
+        title.setStyle("-fx-text-fill: #00ff00; -fx-opacity: 0.25; -fx-underline: true");
+        assertEquals(Color.LIME, title.getTextFill());
+        assertTrue(title.isUnderline());
+        // An important declaration of a sheet beats the inline style.
+        assertEquals(0.5, title.getOpacity(), 0);
+        title.setStyle(null);
+        assertEquals(Color.RED, title.getTextFill());
+        assertFalse(title.isUnderline());
+    }
+
+    @Test
+    public void pseudoClassesRestyleAndRestore() throws Exception {
+        styled("pseudo", ".primary { -fx-text-fill: blue; }\n"
+                + ".primary:hover { -fx-text-fill: red; -fx-underline: true; }\n"
+                + ".primary:hover:armed { -fx-text-fill: green; }\n"
+                + ".bar:selected > Label { -fx-opacity: 0.5; }\n"
+                + ".bar:selected .primary { -fx-wrap-text: true; }\n");
+        PseudoClass hover = PseudoClass.getPseudoClass("hover");
+        PseudoClass armed = PseudoClass.getPseudoClass("armed");
+        PseudoClass selected = PseudoClass.getPseudoClass("selected");
+        assertEquals(Color.BLUE, ok.getTextFill());
+        ok.pseudoClassStateChanged(hover, true);
+        assertEquals(Color.RED, ok.getTextFill());
+        assertTrue(ok.isUnderline());
+        ok.pseudoClassStateChanged(armed, true);
+        assertEquals(Color.GREEN, ok.getTextFill());
+        ok.pseudoClassStateChanged(armed, false);
+        assertEquals(Color.RED, ok.getTextFill());
+        ok.pseudoClassStateChanged(hover, false);
+        assertEquals(Color.BLUE, ok.getTextFill());
+        // What only the state set is gone, back to what the node had.
+        assertFalse(ok.isUnderline());
+        // A state of an ancestor restyles the descendants it selects.
+        bar.pseudoClassStateChanged(selected, true);
+        assertEquals(0.5, title.getOpacity(), 0);
+        assertTrue(ok.isWrapText());
+        assertEquals(1, plain.getOpacity(), 0);
+        bar.pseudoClassStateChanged(selected, false);
+        assertEquals(1, title.getOpacity(), 0);
+        assertFalse(ok.isWrapText());
+    }
+
+    @Test
+    public void aValueTheApplicationSetIsRestoredWhenTheRuleStopsMatching() throws Exception {
+        styled("restore", ".loud { -fx-text-fill: red; -fx-padding: 9; }\n");
+        plain.setTextFill(Color.NAVY);
+        plain.setPadding(new Insets(1));
+        plain.getStyleClass().add("loud");
+        assertEquals(Color.RED, plain.getTextFill());
+        assertEquals(new Insets(9), plain.getPadding());
+        plain.getStyleClass().remove("loud");
+        assertEquals(Color.NAVY, plain.getTextFill());
+        assertEquals(new Insets(1), plain.getPadding());
+        // Removing the sheet does the same for every node.
+        plain.getStyleClass().add("loud");
+        assertEquals(Color.RED, plain.getTextFill());
+        scene.getStylesheets().clear();
+        assertEquals(Color.NAVY, plain.getTextFill());
+    }
+
+    @Test
+    public void nodesAddedLaterAndParentSheetsAreStyled() throws Exception {
+        app = new FxmlHarness("parent").resource("a.css", "Label { -fx-text-fill: red; -fx-underline: true; }\n")
+                .resource("b.css", "Label { -fx-text-fill: blue; }\n");
+        app.build();
+        tree();
+        scene.getStylesheets().add("cn1res:/a.css");
+        assertEquals(Color.RED, title.getTextFill());
+        // A parent's sheet styles its subtree only, and after the scene's.
+        bar.getStylesheets().add("cn1res:/b.css");
+        assertEquals(Color.BLUE, title.getTextFill());
+        assertTrue(title.isUnderline());
+        assertEquals(Color.RED, plain.getTextFill());
+        Label late = new Label("late");
+        bar.getChildren().add(late);
+        assertEquals(Color.BLUE, late.getTextFill());
+        root.getChildren().add(late);
+        assertEquals(Color.RED, late.getTextFill());
+    }
+
+    // ------------------------------------------------------------- values
+
+    @Test
+    public void lookedUpColoursResolveThroughTheAncestors() throws Exception {
+        styled("lookup", ".root { -brand: #336699; -accent: -brand; -soft: derive(-brand, 100%); -fx-base: #101010; }\n"
+                + ".bar { -brand: red; }\n"
+                + "Label { -fx-text-fill: -accent; }\n"
+                + "Button { -fx-text-fill: -brand; -fx-background-color: -soft; }\n"
+                + "#title { -fx-background-color: linear-gradient(to right, -brand, white); }\n");
+        // -accent is resolved where it is used: under .bar, -brand is red.
+        assertEquals(Color.RED, title.getTextFill());
+        assertEquals(Color.web("#336699"), plain.getTextFill());
+        assertEquals(Color.RED, ok.getTextFill());
+        // derive() is the desktop's: a dark colour is lightened by less than was asked.
+        assertEquals(Color.web("#ff9999"), fill(ok));
+        LinearGradient g = (LinearGradient) fill(title);
+        assertEquals(Color.RED, g.getStops().get(0).getColor());
+        assertEquals(Color.WHITE, g.getStops().get(1).getColor());
+        // Redefining the colour restyles what looks it up.
+        bar.setStyle("-brand: lime");
+        assertEquals(Color.LIME, ok.getTextFill());
+        assertEquals(Color.LIME, title.getTextFill());
+    }
+
+    @Test
+    public void fontsInheritAndEmFollowsTheFontSize() throws Exception {
+        styled("font", ".root { -fx-font-size: 20px; }\n"
+                + ".bar { -fx-font-weight: bold; -fx-font-style: italic; }\n"
+                + "#title { -fx-padding: 0.5em 1em; -fx-font-family: \"Courier New\"; }\n"
+                + ".primary { -fx-font-size: 1.5em; -fx-padding: 1em; }\n"
+                + "Label { -fx-pref-width: 2em; }\n");
+        assertEquals(20, plain.getFont().getSize(), 0);
+        assertEquals(40, plain.getPrefWidth(), 0);
+        assertEquals(20, title.getFont().getSize(), 0);
+        assertEquals("Courier New", title.getFont().getFamily());
+        assertEquals(new Insets(10, 20, 10, 20), title.getPadding());
+        assertTrue(title.getFont().getStyle(), title.getFont().getStyle().contains("Bold"));
+        assertTrue(title.getFont().getStyle(), title.getFont().getStyle().contains("Italic"));
+        assertFalse(plain.getFont().getStyle(), plain.getFont().getStyle().contains("Bold"));
+        // An em font size is relative to the inherited size, and the node's
+        // other em lengths to the result.
+        assertEquals(30, ok.getFont().getSize(), 0);
+        assertEquals(new Insets(30), ok.getPadding());
+        root.setStyle("-fx-font-size: 10px");
+        assertEquals(10, plain.getFont().getSize(), 0);
+        assertEquals(15, ok.getFont().getSize(), 0);
+        assertEquals(new Insets(15), ok.getPadding());
+        assertEquals(new Insets(5, 10, 5, 10), title.getPadding());
+    }
+
+    @Test
+    public void fontShorthand() throws Exception {
+        styled("shorthand", "#title { -fx-font: italic bold 18px \"Helvetica Neue\"; }\n"
+                + ".primary { -fx-font: 12pt serif; }\n");
+        assertEquals(18, title.getFont().getSize(), 0);
+        assertEquals("Helvetica Neue", title.getFont().getFamily());
+        assertTrue(title.getFont().getStyle(), title.getFont().getStyle().contains("Bold"));
+        assertTrue(title.getFont().getStyle(), title.getFont().getStyle().contains("Italic"));
+        assertEquals(16, ok.getFont().getSize(), 0);
+        assertNotNull(FontWeight.BOLD);
+        assertNotNull(FontPosture.ITALIC);
+    }
+
+    @Test
+    public void everyKindOfColour() throws Exception {
+        String[][] cases = {
+            {"#f00", "#ff0000"}, {"#f008", "#ff000088"}, {"#00ff0080", "#00ff0080"}, {"navy", "#000080"},
+            {"transparent", "#00000000"}, {"rgb(255, 0, 128)", "#ff0080"}, {"rgb(100%, 0%, 50%)", "#ff0080"},
+            {"rgba(0, 0, 255, 0.5)", "#0000ff80"}, {"hsb(120, 100%, 100%)", "#00ff00"},
+            {"hsba(0, 100%, 100%, 0.5)", "#ff000080"}, {"hsl(240, 100%, 50%)", "#0000ff"},
+            {"derive(#808080, -100%)", "#000000"}, {"derive(black, 100%)", "#999999"},
+            {"RED", "#ff0000"},
+        };
+        StringBuilder css = new StringBuilder();
+        for (int i = 0; i < cases.length; i++) {
+            css.append(".c").append(i).append(" { -fx-text-fill: ").append(cases[i][0]).append("; }\n");
+        }
+        styled("colours", css.toString());
+        for (int i = 0; i < cases.length; i++) {
+            plain.getStyleClass().setAll("c" + i);
+            Color want = Color.web(cases[i][1]);
+            Color got = (Color) plain.getTextFill();
+            assertEquals(cases[i][0], want.getRed(), got.getRed(), 0.005);
+            assertEquals(cases[i][0], want.getGreen(), got.getGreen(), 0.005);
+            assertEquals(cases[i][0], want.getBlue(), got.getBlue(), 0.005);
+            assertEquals(cases[i][0], want.getOpacity(), got.getOpacity(), 0.005);
+        }
+    }
+
+    @Test
+    public void gradientsLengthsInsetsRadiiAndKeywords() throws Exception {
+        styled("values", ".bar { -fx-background-color: linear-gradient(to bottom right, red 0%, blue 100%);"
+                + " -fx-background-radius: 4 8; -fx-background-insets: 1 2 3 4; -fx-padding: 1px 2pt 1pc 1in;"
+                + " -fx-border-color: black; -fx-border-width: 2; -fx-border-radius: 3;"
+                + " -fx-alignment: bottom-left; -fx-spacing: 1.5em; -fx-min-width: 10mm; -fx-max-height: 1cm;"
+                + " -fx-fill-height: false; }\n"
+                + ".primary { -fx-background-color: radial-gradient(center 50% 50%, radius 50%, reflect, white, black 80%);"
+                + " -fx-content-display: right; -fx-text-alignment: center; -fx-cursor: crosshair;"
+                + " -fx-graphic-text-gap: 6; -fx-rotate: 45; -fx-scale-x: 2; -fx-translate-y: -3;"
+                + " -fx-background-color: red, radial-gradient(center 50% 50%, radius 50%, reflect, white, black 80%); }\n");
+        LinearGradient lg = (LinearGradient) fill(bar);
+        assertTrue(lg.isProportional());
+        assertEquals(0, lg.getStartX(), 0);
+        assertEquals(1, lg.getEndX(), 0);
+        assertEquals(1, lg.getEndY(), 0);
+        assertEquals(Color.BLUE, lg.getStops().get(1).getColor());
+        assertEquals(4, bar.getBackground().getFills().get(0).getRadii().getTopLeftHorizontalRadius(), 0);
+        assertEquals(8, bar.getBackground().getFills().get(0).getRadii().getTopRightHorizontalRadius(), 0);
+        assertEquals(new Insets(1, 2, 3, 4), bar.getBackground().getFills().get(0).getInsets());
+        assertEquals(1, bar.getPadding().getTop(), 0);
+        assertEquals(2 * 96.0 / 72, bar.getPadding().getRight(), 0.001);
+        assertEquals(16, bar.getPadding().getBottom(), 0.001);
+        assertEquals(96, bar.getPadding().getLeft(), 0.001);
+        assertNotNull(bar.getBorder());
+        assertEquals(Pos.BOTTOM_LEFT, bar.getAlignment());
+        assertEquals(1.5 * bar.getChildren().size() * 0 + 1.5 * javafx.scene.text.Font.getDefault().getSize(),
+                bar.getSpacing(), 0.001);
+        assertEquals(10 * 96 / 25.4, bar.getMinWidth(), 0.001);
+        assertEquals(96 / 2.54, bar.getMaxHeight(), 0.001);
+        assertFalse(bar.isFillHeight());
+        // Two layers are two fills, the first written at the bottom.
+        assertEquals(2, ok.getBackground().getFills().size());
+        assertEquals(Color.RED, fill(ok));
+        RadialGradient rg = (RadialGradient) ok.getBackground().getFills().get(1).getFill();
+        assertEquals(CycleMethod.REFLECT, rg.getCycleMethod());
+        assertEquals(0.5, rg.getRadius(), 0);
+        assertEquals(0.8, rg.getStops().get(1).getOffset(), 0.0001);
+        assertEquals(javafx.scene.control.ContentDisplay.RIGHT, ok.getContentDisplay());
+        assertEquals(javafx.scene.text.TextAlignment.CENTER, ok.getTextAlignment());
+        assertEquals(Cursor.CROSSHAIR, ok.getCursor());
+        assertEquals(6, ok.getGraphicTextGap(), 0);
+        assertEquals(45, ok.getRotate(), 0);
+        assertEquals(2, ok.getScaleX(), 0);
+        assertEquals(-3, ok.getTranslateY(), 0);
+        assertTrue(app.warnings.toString(), app.warnings.isEmpty());
+    }
+
+    // ---------------------------------------------------- the compiler
+
+    @Test
+    public void unknownPropertiesAndBadValuesAreWarningsWithALine() throws Exception {
+        app = new FxmlHarness("warn").resource("app.css", "/* a comment\n over two lines */\n"
+                + ".a { -fx-text-fill: red; }\n"
+                + ".b {\n  -fx-text-fil: red;\n  -fx-opacity: lots;\n  -fx-text-fill: blue;\n}\n"
+                + ".c:nth-child(2) { -fx-opacity: 1; }\n"
+                + "@media print { .d { -fx-opacity: 0; } }\n");
+        List<String> errors = app.compile();
+        assertTrue(errors.toString(), errors.isEmpty());
+        String file = app.file("app.css");
+        String all = app.warnings.toString();
+        assertEquals(all, 4, app.warnings.size());
+        assertTrue(all, app.warnings.get(0).startsWith(file + ":5:"));
+        assertTrue(all, app.warnings.get(0).contains("-fx-text-fil"));
+        assertTrue(all, app.warnings.get(1).startsWith(file + ":6:"));
+        assertTrue(all, app.warnings.get(1).contains("lots"));
+        assertTrue(all, app.warnings.get(2).startsWith(file + ":9:"));
+        assertTrue(all, app.warnings.get(2).contains("nth-child"));
+        assertTrue(all, app.warnings.get(3).startsWith(file + ":10:"));
+        assertTrue(all, app.warnings.get(3).contains("@media"));
+        // The sheet is compiled with what was understood.
+        CssSheetData data = read(app);
+        assertEquals(2, data.ruleCount());
+        assertEquals(1, data.declarationCount(data.blockOf(1)));
+        assertEquals("-fx-text-fill", data.declaration(data.blockOf(1), 0).name());
+    }
+
+    @Test
+    public void aSheetBrokenInItsStructureIsAnError() throws Exception {
+        app = new FxmlHarness("broken").resource("a.css", ".a { -fx-opacity: 1; }\n.b {\n  -fx-opacity: 0;\n")
+                .resource("b.css", ".a { -fx-opacity: 1; }\n}\n")
+                .resource("c.css", ".a { -fx-opacity: 1; }\n.dangling\n")
+                .resource("ok.css", ".a { -fx-opacity: 1; }\n");
+        List<String> errors = app.compile();
+        assertEquals(errors.toString(), 3, errors.size());
+        assertTrue(errors.toString(), errors.get(0).startsWith(app.file("a.css") + ":2:"));
+        assertTrue(errors.toString(), errors.get(0).contains("never closed"));
+        assertTrue(errors.toString(), errors.get(1).startsWith(app.file("b.css") + ":2:"));
+        assertTrue(errors.toString(), errors.get(2).startsWith(app.file("c.css") + ":2:"));
+        assertFalse(app.compiledSheet("a.css").exists());
+        assertTrue(app.compiledSheet("ok.css").exists());
+    }
+
+    private static CssSheetData read(FxmlHarness app) throws IOException {
+        InputStream in = new FileInputStream(app.compiledSheet("app.css"));
+        try {
+            return CssSheetData.read(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    @Test
+    public void theBinaryTableRoundTrips() throws Exception {
+        app = new FxmlHarness("binary").resource("app.css", "@import \"base.css\";\n"
+                + "@font-face { font-family: \"Brand\"; src: url(\"fonts/brand.ttf\"); }\n"
+                + ".root { -brand: #123456; }\n"
+                + ".a, VBox > #b:hover .c.d { -fx-text-fill: -brand !important; -fx-padding: 1em 2px;"
+                + " -fx-background-color: linear-gradient(to right, red, derive(-brand, 20%) 50%, blue);"
+                + " -fx-font: bold 12px \"Sans\"; -fx-alignment: center; -fx-wrap-text: true;"
+                + " -fx-background-radius: 50%; }\n")
+                .resource("base.css", "Label { -fx-opacity: 0.5; }\n")
+                .resource("fonts/brand.ttf", "not a font");
+        assertTrue(app.compile().isEmpty());
+        CssSheetData first = read(app);
+        assertEquals(1, first.importCount());
+        assertEquals("base.css", first.importPath(0));
+        assertEquals(1, first.fontCount());
+        assertEquals("Brand", first.fontFamily(0));
+        assertEquals("fonts/brand.ttf", first.fontSource(0));
+        assertEquals(3, first.ruleCount());
+        assertEquals(2, first.blockCount());
+        // Two selectors of one rule share its block.
+        assertEquals(first.blockOf(1), first.blockOf(2));
+        assertEquals(".a", first.selector(1).toString());
+        assertEquals("VBox > #b:hover .c.d", first.selector(2).toString());
+        assertEquals(7, first.declarationCount(first.blockOf(1)));
+        assertTrue(first.declaration(first.blockOf(1), 0).important());
+        assertFalse(first.declaration(first.blockOf(1), 1).important());
+        // Written again, the table is the same bytes: nothing is lost.
+        ByteArrayOutputStream again = new ByteArrayOutputStream();
+        first.write(again);
+        ByteArrayOutputStream third = new ByteArrayOutputStream();
+        CssSheetData.read(new ByteArrayInputStream(again.toByteArray())).write(third);
+        assertEquals(again.size(), app.compiledSheet("app.css").length());
+        assertTrue(java.util.Arrays.equals(again.toByteArray(), third.toByteArray()));
+        CssValue gradient = first.declaration(first.blockOf(1), 2).value();
+        assertNotNull(gradient);
+    }
+
+    @Test
+    public void importsComeBeforeTheSheetThatImportsThem() throws Exception {
+        app = new FxmlHarness("import").resource("css/app.css", "@import url(\"base.css\");\n"
+                + "Label { -fx-text-fill: red; }\n")
+                .resource("css/base.css", "Label { -fx-text-fill: blue; -fx-underline: true; }\n");
+        app.build();
+        tree();
+        scene.getStylesheets().add("cn1res:/css/app.css");
+        assertEquals(Color.RED, plain.getTextFill());
+        assertTrue(plain.isUnderline());
+    }
+
+    @Test
+    public void aSheetThatWasNotCompiledStylesNothing() throws Exception {
+        app = new FxmlHarness("absent");
+        app.build();
+        tree();
+        scene.getStylesheets().add("cn1res:/none.css");
+        scene.getStylesheets().add("cn1res:/none.css");
+        assertEquals(Color.BLACK, plain.getTextFill());
+    }
+
+    /// JavaFX reads a comment that runs to the end of its line, which CSS
+    /// has not; a sheet written for it has them, and the declaration on
+    /// the next line was swallowed into the comment's "property name".
+    /// The two slashes of an address inside `url()` are no comment.
+    @Test
+    public void aLineCommentEndsWithItsLineAndAnEffectIsCompiled() throws Exception {
+        app = new FxmlHarness("linecomment").resource("app.css", ".t {\n"
+                + "    -fx-text-fill: #f2b179; // f9f6f2\n"
+                + "    -fx-effect: dropshadow( three-pass-box, rgba(243, 215, 116, 1), 10, 0.5, 0, 0 );\n"
+                + "}\n");
+        assertTrue(app.compile().isEmpty());
+        CssSheetData data = read(app);
+        assertEquals(2, data.declarationCount(data.blockOf(0)));
+        assertEquals("-fx-effect", data.declaration(data.blockOf(0), 1).name());
+        CssValue effect = data.declaration(data.blockOf(0), 1).value();
+        assertEquals(CssValue.EFFECT, effect.type());
+        assertEquals(CssValue.EFFECT_DROP | (3 << 4), effect.flags());
+        assertEquals(10, effect.num(0), 0);
+        assertEquals(0.5, effect.num(1), 0);
+        assertEquals(CssValue.COLOR, effect.part(0).type());
+        assertEquals("a(b://c) d", com.codename1.fxml.css.CssDeclarations.stripComments("a(b://c) d// e").trim());
+    }
+
+    /// A background is as many fills as it has colours and a border as
+    /// many strokes, each with insets, radii, widths and a style of its
+    /// own -- the last given standing in for a layer without one -- and a
+    /// stroke has a paint per side. The standard themes and every
+    /// "flat" restyling of a control are written that way.
+    @Test
+    public void layersSidesBorderInsetsAndALadder() throws Exception {
+        styled("layers", ".bar { -fx-base: #202020;"
+                + " -fx-background-color: red, derive(-fx-base, 20%), blue;"
+                + " -fx-background-insets: 0 0 0 0, 1, 2 3; -fx-background-radius: 5, 4;"
+                + " -fx-border-color: transparent transparent derive(-fx-base, 80%) transparent, white green;"
+                + " -fx-border-width: 0 0 1 0, 2; -fx-border-insets: 0 10 1 0, 4;"
+                + " -fx-border-style: solid, segments(1, 1) inside; }\n"
+                + ".primary { -fx-background-color: #101010; -fx-background-insets: 0 0 0 0, 0, 1, 2;"
+                + " -fx-border-color: #e2e2e2; -fx-border-width: 2; }\n"
+                + "#title { -fx-text-fill: ladder(#101010, white 49%, black 50%); }\n"
+                + ".root > .label { -fx-text-fill: ladder(#f0f0f0, white 49%, black 50%);"
+                + " -fx-background-color: ladder(gray, black 0%, white 100%); }\n");
+        assertTrue(app.warnings.toString(), app.warnings.isEmpty());
+        java.util.List<javafx.scene.layout.BackgroundFill> fills = bar.getBackground().getFills();
+        assertEquals(3, fills.size());
+        assertEquals(Color.RED, fills.get(0).getFill());
+        assertEquals(Color.BLUE, fills.get(2).getFill());
+        assertTrue(fills.get(1).getFill() instanceof Color);
+        assertEquals(new javafx.geometry.Insets(0), fills.get(0).getInsets());
+        assertEquals(new javafx.geometry.Insets(1), fills.get(1).getInsets());
+        assertEquals(new javafx.geometry.Insets(2, 3, 2, 3), fills.get(2).getInsets());
+        assertEquals(5, fills.get(0).getRadii().getTopLeftHorizontalRadius(), 0);
+        assertEquals(4, fills.get(1).getRadii().getTopLeftHorizontalRadius(), 0);
+        assertEquals("the last radius stands in", 4, fills.get(2).getRadii().getTopLeftHorizontalRadius(), 0);
+
+        java.util.List<javafx.scene.layout.BorderStroke> strokes = bar.getBorder().getStrokes();
+        assertEquals(2, strokes.size());
+        javafx.scene.layout.BorderStroke under = strokes.get(0);
+        assertEquals(Color.TRANSPARENT, under.getTopStroke());
+        assertEquals(Color.TRANSPARENT, under.getLeftStroke());
+        assertTrue(under.getBottomStroke() instanceof Color);
+        assertTrue(((Color) under.getBottomStroke()).getBrightness() > 0.5);
+        assertEquals(1, under.getWidths().getBottom(), 0);
+        assertEquals(0, under.getWidths().getTop(), 0);
+        assertEquals(new javafx.geometry.Insets(0, 10, 1, 0), under.getInsets());
+        assertEquals(javafx.scene.layout.BorderStrokeStyle.SOLID, under.getTopStyle());
+        javafx.scene.layout.BorderStroke over = strokes.get(1);
+        assertEquals(Color.WHITE, over.getTopStroke());
+        assertEquals(Color.GREEN, over.getRightStroke());
+        assertEquals(Color.WHITE, over.getBottomStroke());
+        assertEquals(Color.GREEN, over.getLeftStroke());
+        assertEquals(2, over.getWidths().getLeft(), 0);
+        assertEquals(new javafx.geometry.Insets(4), over.getInsets());
+        assertEquals(javafx.scene.layout.BorderStrokeStyle.DASHED, over.getTopStyle());
+
+        // One colour is one fill, whatever number of insets is written.
+        assertEquals(1, ok.getBackground().getFills().size());
+        assertEquals(new javafx.geometry.Insets(0), ok.getBackground().getFills().get(0).getInsets());
+        assertEquals(2, ok.getBorder().getStrokes().get(0).getWidths().getTop(), 0);
+
+        assertEquals("dark picks the stop below", Color.WHITE, title.getTextFill());
+        assertEquals("light the stop above", Color.BLACK, plain.getTextFill());
+        Color between = (Color) fill(plain);
+        assertEquals(Color.GRAY.getBrightness(), between.getRed(), 0.01);
+
+        // Withdrawn, the region has what it had.
+        bar.getStyleClass().clear();
+        assertNull(bar.getBackground());
+        assertNull(bar.getBorder());
+    }
+
+    private static javafx.scene.Node find(javafx.scene.Parent in, String styleClass) {
+        java.util.List<javafx.scene.Node> children = in.getChildrenUnmodifiable();
+        for (int i = 0; i < children.size(); i++) {
+            javafx.scene.Node n = children.get(i);
+            if (n.getStyleClass().contains(styleClass)) {
+                return n;
+            }
+            if (n instanceof javafx.scene.Parent) {
+                javafx.scene.Node deeper = find((javafx.scene.Parent) n, styleClass);
+                if (deeper != null) {
+                    return deeper;
+                }
+            }
+        }
+        return null;
+    }
+
+    /// The colours of the standard theme are defined without any sheet,
+    /// in terms of `-fx-base`, and the controls drawn by this layer take
+    /// theirs from them: a sheet that redefines the base recolours a
+    /// table, and one that names `-fx-focus-color` finds it. A header is
+    /// a `.column-header` around a `.label`, and the text of a menu in a
+    /// bar is a `.label` too.
+    @Test
+    public void theThemeColoursAreDefinedAndRecolourATableItsHeadersAndAMenuBar() throws Exception {
+        styled("theme", ".primary { -fx-background-color: -fx-focus-color; -fx-text-fill: -fx-text-base-color; }\n"
+                + ".dark { -fx-base: #1d1d1d; -fx-control-inner-background: #1d1d1d; -fx-padding: 5;"
+                + " -fx-table-header-border-color: transparent; }\n"
+                + ".dark .column-header { -fx-size: 35; -fx-border-width: 0 0 1 0;"
+                + " -fx-border-color: transparent transparent derive(-fx-base, 80%) transparent;"
+                + " -fx-border-insets: 0 10 1 0; }\n"
+                + ".dark .column-header .label { -fx-font-size: 20pt; -fx-alignment: center-left; }\n"
+                + ".menu-bar .label { -fx-text-fill: white; }\n");
+        assertTrue(app.warnings.toString(), app.warnings.isEmpty());
+        assertEquals(Color.web("#039ed3"), fill(ok));
+        assertEquals("the base is light, its text dark", Color.web("#333333"), ok.getTextFill());
+
+        javafx.scene.control.TableView<String> plainTable = new javafx.scene.control.TableView<String>();
+        plainTable.getColumns().add(new javafx.scene.control.TableColumn<String, String>("One"));
+        javafx.scene.control.TableView<String> dark = new javafx.scene.control.TableView<String>();
+        dark.getStyleClass().add("dark");
+        dark.getColumns().add(new javafx.scene.control.TableColumn<String, String>("One"));
+        javafx.scene.control.MenuBar menus = new javafx.scene.control.MenuBar(new javafx.scene.control.Menu("File"));
+        root.getChildren().addAll(plainTable, dark, menus);
+        root.applyCss();
+        root.layout();
+
+        // The standard look: a border that is the fill under the inner one.
+        assertEquals(2, plainTable.getBackground().getFills().size());
+        Color border = (Color) plainTable.getBackground().getFills().get(0).getFill();
+        Color inner = (Color) plainTable.getBackground().getFills().get(1).getFill();
+        assertTrue("a light table: " + inner, inner.getBrightness() > 0.95);
+        assertTrue("with a grey edge: " + border, border.getBrightness() > 0.6 && border.getBrightness() < 0.9);
+        assertEquals(new javafx.geometry.Insets(1), plainTable.getPadding());
+
+        Color darkInner = (Color) dark.getBackground().getFills().get(1).getFill();
+        assertEquals(Color.web("#1d1d1d"), darkInner);
+        assertEquals("the edge of a dark base is black", Color.BLACK, dark.getBackground().getFills().get(0).getFill());
+        assertEquals(new javafx.geometry.Insets(5), dark.getPadding());
+
+        Region header = (Region) find(dark, "column-header");
+        assertNotNull(header);
+        assertTrue("-fx-size is the least height: " + header.prefHeight(-1), header.prefHeight(-1) >= 35);
+        javafx.scene.layout.BorderStroke line = header.getBorder().getStrokes().get(0);
+        assertEquals(Color.TRANSPARENT, line.getRightStroke());
+        assertTrue(((Color) line.getBottomStroke()).getBrightness() > 0.5);
+        assertEquals(new javafx.geometry.Insets(0, 10, 1, 0), line.getInsets());
+        Label text = (Label) find(header, "label");
+        assertNotNull("the header holds a label", text);
+        assertEquals(20 * 96.0 / 72, text.getFont().getSize(), 0.01);
+        assertEquals(Pos.CENTER_LEFT, text.getAlignment());
+        Label plainText = (Label) find((Region) find(plainTable, "column-header"), "label");
+        assertEquals(Pos.CENTER, plainText.getAlignment());
+
+        Label file = (Label) find(menus, "label");
+        assertNotNull("a menu's text is a label", file);
+        assertEquals(Color.WHITE, file.getTextFill());
+        assertTrue(file.getStyleClass().contains("menu"));
+    }
+
+    /// A button a sheet draws -- a fill, a border and a padding of its
+    /// own -- is that padding around its text: the padding the native
+    /// theme gives a button does not come on top, which made every
+    /// restyled button a third taller than in JavaFX. `:default` and
+    /// `:cancel` are states a sheet can name.
+    @Test
+    public void aRestyledButtonIsItsOwnPaddingAndKnowsDefaultAndCancel() throws Exception {
+        styled("button", ".primary { -fx-background-color: #101010; -fx-border-color: #e2e2e2;"
+                + " -fx-border-width: 2; -fx-padding: 5 22 5 22; }\n"
+                + ".primary:default { -fx-background-color: -fx-focus-color; }\n"
+                + ".primary:cancel { -fx-text-fill: red; }\n");
+        com.codename1.ui.Component c = ok.cn1Native();
+        // What the theme would add, made visible whatever the theme is.
+        root.applyCss();
+        com.codename1.ui.plaf.Style style = c.getStyle();
+        assertEquals(0, style.getPaddingTop() + style.getPaddingBottom() + style.getPaddingLeftNoRTL()
+                + style.getPaddingRightNoRTL());
+        double text = com.codename1.fxcompat.runtime.Units.toLogical(c.getPreferredSize().getHeight());
+        assertEquals(2 + 5 + text + 5 + 2, ok.prefHeight(-1), 1.0);
+        double wide = com.codename1.fxcompat.runtime.Units.toLogical(c.getPreferredSize().getWidth());
+        assertEquals(2 + 22 + wide + 22 + 2, ok.prefWidth(-1), 1.0);
+
+        assertEquals(Color.web("#101010"), fill(ok));
+        ok.setDefaultButton(true);
+        root.applyCss();
+        assertEquals(Color.web("#039ed3"), fill(ok));
+        ok.setDefaultButton(false);
+        ok.setCancelButton(true);
+        root.applyCss();
+        assertEquals(Color.web("#101010"), fill(ok));
+        assertEquals(Color.RED, ok.getTextFill());
+
+        // Without a padding of its own it keeps the theme's.
+        ok.getStyleClass().clear();
+        ok.setStyle("-fx-background-color: blue;");
+        root.applyCss();
+        com.codename1.ui.plaf.Style themed = com.codename1.ui.plaf.UIManager.getInstance().getComponentStyle(c.getUIID());
+        assertEquals(themed.getPaddingTop(), c.getStyle().getPaddingTop());
+    }
+}
diff --git a/maven/fxml-compiler/src/test/java/com/codename1/fxml/FxmlCompilerTest.java b/maven/fxml-compiler/src/test/java/com/codename1/fxml/FxmlCompilerTest.java
new file mode 100644
index 00000000000..34b543c2241
--- /dev/null
+++ b/maven/fxml-compiler/src/test/java/com/codename1/fxml/FxmlCompilerTest.java
@@ -0,0 +1,791 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.ListResourceBundle;
+import java.util.ResourceBundle;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.StyleEngine;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.collections.ObservableList;
+import javafx.fxml.FXMLLoader;
+import javafx.fxml.LoadException;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.control.Button;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.TextField;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Callback;
+
+/// Every FXML feature the compiler supports, through the whole of what a
+/// build does: document to Java source, javac, the generated dispatcher,
+/// and the tree the document builds on a headless device.
+public class FxmlCompilerTest {
+
+    private static final String HEAD = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+            + "<?import javafx.scene.control.*?>\n"
+            + "<?import javafx.scene.layout.*?>\n"
+            + "<?import javafx.geometry.Insets?>\n";
+    private static final String NS = " xmlns=\"http://javafx.com/javafx/17\" xmlns:fx=\"http://javafx.com/fxml/1\"";
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private FxmlHarness app;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() throws IOException {
+        if (app != null) {
+            app.close();
+        }
+        Units.setScale(0);
+        StyleEngine.setInstance(null);
+    }
+
+    private FxmlHarness app(String name) throws IOException {
+        app = new FxmlHarness(name);
+        return app;
+    }
+
+    /// The single error of a document that must not compile.
+    private String errorOf(String name, String document) throws IOException {
+        List<String> errors = app(name).resource("bad.fxml", document).compile();
+        assertEquals(errors.toString(), 1, errors.size());
+        return errors.get(0);
+    }
+
+    // ------------------------------------------------- the object graph
+
+    @Test
+    public void attributesAreCoercedToThePropertyType() throws Exception {
+        app("coerce").resource("main.fxml", HEAD + "<?import javafx.scene.shape.Rectangle?>\n"
+                + "<VBox" + NS + " spacing=\"8\" alignment=\"CENTER_RIGHT\" fillWidth=\"false\" id=\"box\""
+                + " styleClass=\"panel, wide\" prefWidth=\"120.5\" maxHeight=\"Infinity\" padding=\"1 2 3 4\">\n"
+                + "  <Label text=\"Hello\" wrapText=\"true\" textFill=\"#ff0000\" opacity=\".5\"/>\n"
+                + "  <Rectangle width=\"10\" height=\"20\" fill=\"BLUE\" arcWidth=\"4\"/>\n"
+                + "  <Label text=\"\\%not a key\"/>\n"
+                + "</VBox>\n").build();
+        VBox box = app.load("main.fxml");
+        assertEquals(8, box.getSpacing(), 0);
+        assertEquals(Pos.CENTER_RIGHT, box.getAlignment());
+        assertFalse(box.isFillWidth());
+        assertEquals("box", box.getId());
+        assertTrue(box.getStyleClass().contains("panel"));
+        assertTrue(box.getStyleClass().contains("wide"));
+        assertEquals(120.5, box.getPrefWidth(), 0);
+        assertEquals(Double.POSITIVE_INFINITY, box.getMaxHeight(), 0);
+        assertEquals(new Insets(1, 2, 3, 4), box.getPadding());
+        assertEquals(3, box.getChildren().size());
+        Label label = (Label) box.getChildren().get(0);
+        assertEquals("Hello", label.getText());
+        assertTrue(label.isWrapText());
+        assertEquals(Color.RED, label.getTextFill());
+        assertEquals(.5, label.getOpacity(), 0);
+        Rectangle r = (Rectangle) box.getChildren().get(1);
+        assertEquals(10, r.getWidth(), 0);
+        assertEquals(20, r.getHeight(), 0);
+        assertEquals(Color.BLUE, r.getFill());
+        assertEquals("%not a key", ((Label) box.getChildren().get(2)).getText());
+    }
+
+    @Test
+    public void aListOfNumbersIsAnArrayAndAButtonBarHoldsItsButtons() throws Exception {
+        app("arrays").resource("main.fxml", HEAD + "<?import javafx.scene.control.SplitPane?>\n"
+                + "<?import javafx.scene.control.ButtonBar?>\n"
+                + "<VBox" + NS + ">\n"
+                + "  <SplitPane dividerPositions=\"0.25, 0.75\">\n"
+                + "    <items><Label text=\"a\"/><Label text=\"b\"/><Label text=\"c\"/></items>\n"
+                + "  </SplitPane>\n"
+                + "  <ButtonBar>\n"
+                + "    <buttons>\n"
+                + "      <Button mnemonicParsing=\"false\" text=\"_OK\"/>\n"
+                + "      <Button text=\"_Cancel\"/>\n"
+                + "    </buttons>\n"
+                + "  </ButtonBar>\n"
+                + "</VBox>\n").build();
+        VBox box = app.load("main.fxml");
+        javafx.scene.control.SplitPane split = (javafx.scene.control.SplitPane) box.getChildren().get(0);
+        assertEquals(2, split.getDividerPositions().length);
+        assertEquals(0.25, split.getDividerPositions()[0], 0);
+        assertEquals(0.75, split.getDividerPositions()[1], 0);
+        javafx.scene.control.ButtonBar bar = (javafx.scene.control.ButtonBar) box.getChildren().get(1);
+        assertEquals(2, bar.getButtons().size());
+        assertFalse(((Button) bar.getButtons().get(0)).isMnemonicParsing());
+        assertTrue(((Button) bar.getButtons().get(1)).isMnemonicParsing());
+    }
+
+    @Test
+    public void propertyElementsListsAndTextContent() throws Exception {
+        app("elements").resource("main.fxml", HEAD + "<?import java.lang.String?>\n"
+                + "<BorderPane" + NS + ">\n"
+                + "  <padding><Insets top=\"1\" right=\"2\" bottom=\"3\" left=\"4\"/></padding>\n"
+                + "  <top><Label><text>Title</text></Label></top>\n"
+                + "  <center>\n"
+                + "    <HBox>\n"
+                + "      <children>\n"
+                + "        <Button text=\"One\"/>\n"
+                + "        <Button>Two</Button>\n"
+                + "      </children>\n"
+                + "    </HBox>\n"
+                + "  </center>\n"
+                + "  <bottom>\n"
+                + "    <ComboBox>\n"
+                + "      <items><String fx:value=\"a\"/><String fx:value=\"b\"/></items>\n"
+                + "    </ComboBox>\n"
+                + "  </bottom>\n"
+                + "  <styleClass><String fx:value=\"frame\"/></styleClass>\n"
+                + "</BorderPane>\n").build();
+        BorderPane pane = app.load("main.fxml");
+        assertEquals(new Insets(1, 2, 3, 4), pane.getPadding());
+        assertEquals("Title", ((Label) pane.getTop()).getText());
+        HBox center = (HBox) pane.getCenter();
+        assertEquals(2, center.getChildren().size());
+        assertEquals("One", ((Button) center.getChildren().get(0)).getText());
+        assertEquals("Two", ((Button) center.getChildren().get(1)).getText());
+        ComboBox<?> combo = (ComboBox<?>) pane.getBottom();
+        assertEquals(2, combo.getItems().size());
+        assertEquals("b", combo.getItems().get(1));
+        assertTrue(pane.getStyleClass().contains("frame"));
+    }
+
+    @Test
+    public void staticPropertiesAsAttributesAndElements() throws Exception {
+        app("static").resource("main.fxml", HEAD
+                + "<VBox" + NS + ">\n"
+                + "  <GridPane VBox.vgrow=\"ALWAYS\">\n"
+                + "    <Label text=\"a\" GridPane.rowIndex=\"2\" GridPane.columnIndex=\"1\"/>\n"
+                + "    <Label text=\"b\">\n"
+                + "      <GridPane.rowIndex>3</GridPane.rowIndex>\n"
+                + "      <VBox.margin><Insets topRightBottomLeft=\"6\"/></VBox.margin>\n"
+                + "    </Label>\n"
+                + "  </GridPane>\n"
+                + "</VBox>\n").build();
+        VBox box = app.load("main.fxml");
+        GridPane grid = (GridPane) box.getChildren().get(0);
+        assertEquals(Priority.ALWAYS, VBox.getVgrow(grid));
+        Node a = grid.getChildren().get(0);
+        assertEquals(Integer.valueOf(2), GridPane.getRowIndex(a));
+        assertEquals(Integer.valueOf(1), GridPane.getColumnIndex(a));
+        Node b = grid.getChildren().get(1);
+        assertEquals(Integer.valueOf(3), GridPane.getRowIndex(b));
+        assertEquals(new Insets(6), VBox.getMargin(b));
+    }
+
+    @Test
+    public void valueFactoryAndConstant() throws Exception {
+        app("factory").resource("main.fxml", HEAD + "<?import javafx.collections.FXCollections?>\n"
+                + "<?import javafx.scene.paint.Color?>\n<?import java.lang.Double?>\n<?import java.lang.String?>\n"
+                + "<VBox" + NS + ">\n"
+                + "  <fx:define>\n"
+                + "    <Double fx:id=\"gap\" fx:value=\"12.5\"/>\n"
+                + "    <FXCollections fx:id=\"names\" fx:factory=\"observableArrayList\">\n"
+                + "      <String fx:value=\"x\"/><String fx:value=\"y\"/>\n"
+                + "    </FXCollections>\n"
+                + "  </fx:define>\n"
+                + "  <Label fx:id=\"tinted\" text=\"t\">\n"
+                + "    <textFill><Color fx:constant=\"GREEN\"/></textFill>\n"
+                + "  </Label>\n"
+                + "  <ComboBox fx:id=\"combo\" items=\"$names\"/>\n"
+                + "  <HBox fx:id=\"row\" spacing=\"$gap\"/>\n"
+                + "</VBox>\n").build();
+        FXMLLoader loader = app.loader("main.fxml");
+        VBox box = loader.load();
+        assertEquals(3, box.getChildren().size());
+        assertEquals(Double.valueOf(12.5), loader.getNamespace().get("gap"));
+        ObservableList<?> names = (ObservableList<?>) loader.getNamespace().get("names");
+        assertEquals(2, names.size());
+        assertEquals(Color.GREEN, ((Label) box.getChildren().get(0)).getTextFill());
+        assertSame(names, ((ComboBox<?>) box.getChildren().get(1)).getItems());
+        assertEquals(12.5, ((HBox) box.getChildren().get(2)).getSpacing(), 0);
+        // An element with an fx:id and no id of its own is found by it.
+        assertEquals("row", box.getChildren().get(2).getId());
+    }
+
+    @Test
+    public void defineAndReference() throws Exception {
+        app("reference").resource("main.fxml", HEAD
+                + "<VBox" + NS + ">\n"
+                + "  <fx:define>\n"
+                + "    <ToggleGroup fx:id=\"group\"/>\n"
+                + "    <Insets fx:id=\"gap\" topRightBottomLeft=\"5\"/>\n"
+                + "    <Label fx:id=\"shared\" text=\"shared\"/>\n"
+                + "  </fx:define>\n"
+                + "  <RadioButton text=\"a\" toggleGroup=\"$group\" VBox.margin=\"$gap\"/>\n"
+                + "  <RadioButton text=\"b\"><toggleGroup><fx:reference source=\"group\"/></toggleGroup></RadioButton>\n"
+                + "  <fx:reference source=\"shared\"/>\n"
+                + "</VBox>\n").build();
+        FXMLLoader loader = app.loader("main.fxml");
+        VBox box = loader.load();
+        assertEquals(3, box.getChildren().size());
+        ToggleGroup group = (ToggleGroup) loader.getNamespace().get("group");
+        assertNotNull(group);
+        RadioButton a = (RadioButton) box.getChildren().get(0);
+        RadioButton b = (RadioButton) box.getChildren().get(1);
+        assertSame(group, a.getToggleGroup());
+        assertSame(group, b.getToggleGroup());
+        assertEquals(new Insets(5), VBox.getMargin(a));
+        assertSame(loader.getNamespace().get("shared"), box.getChildren().get(2));
+    }
+
+    @Test
+    public void resourceKeysAndLocations() throws Exception {
+        app("bundle").resource("views/main.fxml", HEAD + "<?import javafx.scene.image.*?>\n"
+                + "<VBox" + NS + " stylesheets=\"@main.css\">\n"
+                + "  <Label text=\"%greeting\"/>\n"
+                + "  <ImageView><image><Image url=\"@../img/logo.png\"/></image></ImageView>\n"
+                + "  <ImageView><Image url=\"@/abs/icon.png\"/></ImageView>\n"
+                + "</VBox>\n")
+                .resource("views/main.css", ".label { -fx-text-fill: red; }\n").build();
+        ResourceBundle bundle = new ListResourceBundle() {
+            @Override
+            protected Object[][] getContents() {
+                return new Object[][] {{"greeting", "Bonjour"}};
+            }
+        };
+        VBox box = FXMLLoader.load(FxmlHarness.location("views/main.fxml"), bundle);
+        assertEquals("Bonjour", ((Label) box.getChildren().get(0)).getText());
+        assertEquals("cn1res:/views/main.css", box.getStylesheets().get(0));
+        assertEquals("cn1res:/img/logo.png", ((ImageView) box.getChildren().get(1)).getImage().getUrl());
+        assertEquals("cn1res:/abs/icon.png", ((ImageView) box.getChildren().get(2)).getImage().getUrl());
+        try {
+            app.load("views/main.fxml");
+            fail("A %key without a bundle must fail");
+        } catch (LoadException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("views/main.fxml"));
+            assertTrue(e.getMessage(), e.getMessage().contains("%greeting"));
+        }
+    }
+
+    @Test
+    public void expressionBindingsFollowTheirSource() throws Exception {
+        app("binding").resource("main.fxml", HEAD
+                + "<VBox" + NS + ">\n"
+                + "  <TextField fx:id=\"name\" text=\"ann\" prefWidth=\"90\"/>\n"
+                + "  <Label fx:id=\"echo\" text=\"${name.text}\"/>\n"
+                + "  <Label fx:id=\"wide\" text=\"${name.prefWidth}\" prefWidth=\"${name.prefWidth}\"/>\n"
+                + "  <Button fx:id=\"go\" disable=\"${name.disable}\"/>\n"
+                + "</VBox>\n").build();
+        VBox box = app.load("main.fxml");
+        TextField name = (TextField) box.getChildren().get(0);
+        Label echo = (Label) box.getChildren().get(1);
+        Label wide = (Label) box.getChildren().get(2);
+        Button go = (Button) box.getChildren().get(3);
+        assertEquals("ann", echo.getText());
+        name.setText("bob");
+        assertEquals("bob", echo.getText());
+        assertEquals("90.0", wide.getText());
+        assertEquals(90, wide.getPrefWidth(), 0);
+        name.setPrefWidth(40);
+        assertEquals(40, wide.getPrefWidth(), 0);
+        assertFalse(go.isDisable());
+        name.setDisable(true);
+        assertTrue(go.isDisable());
+    }
+
+    // -------------------------------------------------------- controllers
+
+    private static final String BASE = "package app;\n"
+            + "import javafx.fxml.FXML;\nimport javafx.scene.control.Label;\n"
+            + "public class Base {\n"
+            + "    @FXML private Label status;\n"
+            + "    private int baseCalls;\n"
+            + "    @FXML private void onBase() { baseCalls++; }\n"
+            + "    Label status() { return status; }\n"
+            + "}\n";
+
+    private static final String MAIN = "package app;\n"
+            + "import javafx.event.ActionEvent;\nimport javafx.fxml.FXML;\nimport javafx.scene.control.*;\n"
+            + "import javafx.scene.layout.VBox;\n"
+            + "public class Main extends Base {\n"
+            + "    @FXML private Label title;\n"
+            + "    @FXML private Button go;\n"
+            + "    @FXML Button plain;\n"
+            + "    public Button open;\n"
+            + "    private Button unmarked;\n"
+            + "    @FXML private VBox sub;\n"
+            + "    @FXML private Sub subController;\n"
+            + "    @FXML private java.net.URL location;\n"
+            + "    @FXML private java.util.ResourceBundle resources;\n"
+            + "    private int events;\n    private int plains;\n    private String seen = \"\";\n"
+            + "    private Main() { }\n"
+            + "    @FXML private void onGo(ActionEvent e) { events++; seen += e.getSource() == go ? \"go\" : \"?\"; }\n"
+            + "    @FXML private void onPlain() { plains++; }\n"
+            + "    public void onOpen() { seen += \"open\"; }\n"
+            + "    @FXML private void initialize() {\n"
+            + "        seen += title != null && sub != null && subController != null ? \"init\" : \"early\";\n"
+            + "    }\n"
+            + "}\n";
+
+    private static final String SUB = "package app;\n"
+            + "import javafx.fxml.FXML;\nimport javafx.fxml.Initializable;\nimport javafx.scene.control.Label;\n"
+            + "public class Sub implements Initializable {\n"
+            + "    @FXML private Label inner;\n"
+            + "    String state = \"\";\n"
+            + "    @Override public void initialize(java.net.URL location, java.util.ResourceBundle resources) {\n"
+            + "        state = inner.getText() + \"@\" + location;\n"
+            + "    }\n"
+            + "}\n";
+
+    private FxmlHarness controllers(String name) throws Exception {
+        return app(name).source("app.Base", BASE).source("app.Main", MAIN).source("app.Sub", SUB)
+                .resource("ui/main.fxml", HEAD
+                        + "<VBox" + NS + " fx:controller=\"app.Main\">\n"
+                        + "  <Label fx:id=\"title\" text=\"T\"/>\n"
+                        + "  <Label fx:id=\"status\" text=\"S\"/>\n"
+                        + "  <Button fx:id=\"go\" onAction=\"#onGo\"/>\n"
+                        + "  <Button fx:id=\"plain\" onAction=\"#onPlain\"/>\n"
+                        + "  <Button fx:id=\"open\" onAction=\"#onOpen\"/>\n"
+                        + "  <Button fx:id=\"unmarked\" onAction=\"#onBase\"/>\n"
+                        + "  <fx:include fx:id=\"sub\" source=\"parts/sub.fxml\"/>\n"
+                        + "</VBox>\n")
+                .resource("ui/parts/sub.fxml", HEAD
+                        + "<VBox" + NS + " fx:controller=\"app.Sub\" spacing=\"3\">\n"
+                        + "  <Label fx:id=\"inner\" text=\"in\"/>\n"
+                        + "</VBox>\n")
+                .build();
+    }
+
+    @Test
+    public void controllerMembersAreInjectedThroughTheDispatcher() throws Exception {
+        controllers("controller");
+        assertEquals(2, app.generator().documents());
+        FXMLLoader loader = app.loader("ui/main.fxml");
+        VBox box = loader.load();
+        Object controller = loader.getController();
+        assertEquals("app.Main", controller.getClass().getName());
+        assertSame(controller, loader.getNamespace().get("controller"));
+        // Private, package and public fields, and one the superclass
+        // declares privately.
+        assertSame(box.getChildren().get(0), FxmlHarness.field(controller, "title"));
+        assertSame(box.getChildren().get(1), FxmlHarness.field(controller, "status"));
+        assertSame(box.getChildren().get(2), FxmlHarness.field(controller, "go"));
+        assertSame(box.getChildren().get(3), FxmlHarness.field(controller, "plain"));
+        assertSame(box.getChildren().get(4), FxmlHarness.field(controller, "open"));
+        // A private field without @FXML is not the document's to set.
+        assertNull(FxmlHarness.field(controller, "unmarked"));
+        assertEquals(FxmlHarness.location("ui/main.fxml"), FxmlHarness.field(controller, "location"));
+        assertNull(FxmlHarness.field(controller, "resources"));
+        // initialize() ran once, after every field was set.
+        assertEquals("init", FxmlHarness.field(controller, "seen"));
+    }
+
+    @Test
+    public void handlersCallControllerMethods() throws Exception {
+        controllers("handlers");
+        FXMLLoader loader = app.loader("ui/main.fxml");
+        VBox box = loader.load();
+        Object controller = loader.getController();
+        ((Button) box.getChildren().get(2)).fire();
+        ((Button) box.getChildren().get(2)).fire();
+        ((Button) box.getChildren().get(3)).fire();
+        ((Button) box.getChildren().get(4)).fire();
+        ((Button) box.getChildren().get(5)).fire();
+        assertEquals(2, FxmlHarness.field(controller, "events"));
+        assertEquals(1, FxmlHarness.field(controller, "plains"));
+        assertEquals("initgogoopen", FxmlHarness.field(controller, "seen"));
+        assertEquals(1, FxmlHarness.field(controller, "baseCalls"));
+    }
+
+    @Test
+    public void includesLoadTheirOwnDocumentAndController() throws Exception {
+        controllers("include");
+        FXMLLoader loader = app.loader("ui/main.fxml");
+        VBox box = loader.load();
+        Object controller = loader.getController();
+        VBox sub = (VBox) box.getChildren().get(6);
+        assertEquals(3, sub.getSpacing(), 0);
+        assertSame(sub, FxmlHarness.field(controller, "sub"));
+        Object subController = FxmlHarness.field(controller, "subController");
+        assertEquals("app.Sub", subController.getClass().getName());
+        assertSame(subController, loader.getNamespace().get("subController"));
+        assertSame(sub.getChildren().get(0), FxmlHarness.field(subController, "inner"));
+        // The included document is located relative to the including one.
+        assertEquals("in@" + FxmlHarness.location("ui/parts/sub.fxml"), FxmlHarness.field(subController, "state"));
+        // The included document's ids stay its own.
+        assertFalse(loader.getNamespace().containsKey("inner"));
+    }
+
+    @Test
+    public void controllerFactoryAndSetController() throws Exception {
+        controllers("factory2");
+        final Class<?> main = app.type("app.Main");
+        final Object[] made = new Object[1];
+        final int[] asked = new int[1];
+        FXMLLoader loader = app.loader("ui/parts/sub.fxml");
+        loader.setControllerFactory(new Callback<Class<?>, Object>() {
+            @Override
+            public Object call(Class<?> type) {
+                asked[0]++;
+                assertEquals("app.Sub", type.getName());
+                try {
+                    made[0] = type.newInstance();
+                } catch (Exception e) {
+                    throw new IllegalStateException(e);
+                }
+                return made[0];
+            }
+        });
+        loader.load();
+        assertEquals(1, asked[0]);
+        assertSame(made[0], loader.getController());
+        assertNotNull(main);
+        // A controller the application made itself is the one used.
+        Object own = app.type("app.Sub").newInstance();
+        FXMLLoader second = app.loader("ui/parts/sub.fxml");
+        second.setController(own);
+        VBox root = second.load();
+        assertSame(own, second.getController());
+        assertSame(root.getChildren().get(0), FxmlHarness.field(own, "inner"));
+    }
+
+    @Test
+    public void rootElementBuildsOnTheObjectTheLoaderWasGiven() throws Exception {
+        app("root").source("app.Card", "package app;\n"
+                + "import javafx.fxml.FXML;\nimport javafx.scene.control.Label;\nimport javafx.scene.layout.VBox;\n"
+                + "public class Card extends VBox {\n"
+                + "    @FXML private Label caption;\n"
+                + "    public String caption() { return caption.getText(); }\n"
+                + "}\n")
+                .resource("card.fxml", HEAD
+                        + "<fx:root type=\"VBox\"" + NS + " spacing=\"4\">\n"
+                        + "  <Label fx:id=\"caption\" text=\"cap\"/>\n"
+                        + "</fx:root>\n").build();
+        Object card = app.type("app.Card").newInstance();
+        FXMLLoader loader = app.loader("card.fxml");
+        loader.setRoot(card);
+        loader.setController(card);
+        assertSame(card, loader.load());
+        assertEquals(4, ((VBox) card).getSpacing(), 0);
+        assertEquals(1, ((VBox) card).getChildren().size());
+        assertSame(((VBox) card).getChildren().get(0), FxmlHarness.field(card, "caption"));
+        try {
+            app.loader("card.fxml").load();
+            fail("fx:root without setRoot must fail");
+        } catch (LoadException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("setRoot"));
+        }
+    }
+
+    @Test
+    public void aDocumentThatWasNotCompiledSaysSo() throws Exception {
+        controllers("missing");
+        try {
+            app.load("ui/other.fxml");
+            fail("A document that is not there must fail");
+        } catch (LoadException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("No compiled FXML document"));
+            assertTrue(e.getMessage(), e.getMessage().contains("ui/other.fxml"));
+        }
+    }
+
+    @Test
+    public void aWrongFieldTypeFailsWithTheNames() throws Exception {
+        app("mismatch").source("app.Wrong", "package app;\n"
+                + "public class Wrong {\n    @javafx.fxml.FXML private javafx.scene.control.Button title;\n}\n")
+                .resource("main.fxml", HEAD + "<VBox" + NS + " fx:controller=\"app.Wrong\">\n"
+                        + "  <Label fx:id=\"title\"/>\n</VBox>\n").build();
+        try {
+            app.load("main.fxml");
+            fail("A Label cannot be injected into a Button field");
+        } catch (LoadException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("title"));
+            assertTrue(e.getMessage(), e.getMessage().contains("Button"));
+            assertTrue(e.getMessage(), e.getMessage().contains("Label"));
+        }
+    }
+
+    // ------------------------------------------------------------- errors
+
+    @Test
+    public void unknownClassIsAnErrorWithItsPosition() throws Exception {
+        String error = errorOf("unknown-class", HEAD + "<VBox" + NS + ">\n"
+                + "  <Label text=\"a\"/>\n"
+                + "  <Lable text=\"b\"/>\n"
+                + "</VBox>\n");
+        assertTrue(error, error.startsWith(app.file("bad.fxml") + ":7:"));
+        assertTrue(error, error.contains("Lable"));
+        assertTrue(error, error.contains("<Lable text=\"b\">"));
+    }
+
+    @Test
+    public void unknownPropertyIsAnErrorWithItsPosition() throws Exception {
+        String error = errorOf("unknown-property", HEAD + "<VBox" + NS + ">\n"
+                + "  <Label txt=\"b\"/>\n"
+                + "</VBox>\n");
+        assertTrue(error, error.startsWith(app.file("bad.fxml") + ":6:"));
+        assertTrue(error, error.contains("txt=\"b\""));
+        assertTrue(error, error.contains("has no property txt"));
+    }
+
+    @Test
+    public void aValueThatDoesNotConvertIsAnError() throws Exception {
+        String error = errorOf("bad-value", HEAD + "<VBox" + NS + " spacing=\"wide\"/>\n");
+        assertTrue(error, error.startsWith(app.file("bad.fxml") + ":5:"));
+        assertTrue(error, error.contains("wide"));
+        error = errorOf("bad-enum", HEAD + "<VBox" + NS + " alignment=\"MIDDLE\"/>\n");
+        assertTrue(error, error.contains("MIDDLE"));
+    }
+
+    @Test
+    public void scriptsAreAnError() throws Exception {
+        String error = errorOf("script", HEAD + "<VBox" + NS + ">\n"
+                + "  <fx:script>var x = 1;</fx:script>\n</VBox>\n");
+        assertTrue(error, error.startsWith(app.file("bad.fxml") + ":6:"));
+        assertTrue(error, error.contains("<fx:script> is not supported"));
+        error = errorOf("language", "<?xml version=\"1.0\"?>\n<?language javascript?>\n"
+                + "<?import javafx.scene.layout.VBox?>\n<VBox" + NS + "/>\n");
+        assertTrue(error, error.startsWith(app.file("bad.fxml") + ":2:"));
+        assertTrue(error, error.contains("scripts are not supported"));
+        error = errorOf("script-handler", HEAD + "<Button" + NS + " onAction=\"go()\"/>\n");
+        assertTrue(error, error.contains("#method"));
+    }
+
+    @Test
+    public void structuralMistakesAreErrors() throws Exception {
+        String error = errorOf("malformed", HEAD + "<VBox" + NS + ">\n  <Label>\n</VBox>\n");
+        assertTrue(error, error.contains("not well formed XML"));
+        assertTrue(error, error.startsWith(app.file("bad.fxml") + ":7:"));
+        error = errorOf("no-controller", HEAD + "<Button" + NS + " onAction=\"#go\"/>\n");
+        assertTrue(error, error.contains("fx:controller"));
+        error = errorOf("no-include", HEAD + "<VBox" + NS + "><fx:include source=\"none.fxml\"/></VBox>\n");
+        assertTrue(error, error.contains("none.fxml"));
+        error = errorOf("bad-reference", HEAD + "<VBox" + NS + "><Label text=\"$nothing\"/></VBox>\n");
+        assertTrue(error, error.contains("nothing"));
+        error = errorOf("twice", HEAD + "<VBox" + NS + "><Label fx:id=\"a\"/><Label fx:id=\"a\"/></VBox>\n");
+        assertTrue(error, error.contains("used twice"));
+        error = errorOf("wrong-type", HEAD + "<VBox" + NS + "><padding><Label/></padding></VBox>\n");
+        assertTrue(error, error.contains("Insets"));
+        error = errorOf("expression", HEAD + "<VBox" + NS + "><TextField fx:id=\"n\"/>"
+                + "<Label text=\"${n.text + '!'}\"/></VBox>\n");
+        assertTrue(error, error.contains("${"));
+    }
+
+    @Test
+    public void everyBrokenDocumentIsReportedAndNoneStopsTheOthers() throws Exception {
+        List<String> errors = app("several")
+                .resource("a.fxml", HEAD + "<VBox" + NS + "><Nope/></VBox>\n")
+                .resource("b.fxml", HEAD + "<VBox" + NS + " nope=\"1\"/>\n")
+                .resource("c.fxml", HEAD + "<VBox" + NS + "/>\n").compile();
+        assertEquals(errors.toString(), 2, errors.size());
+        assertTrue(app.generated("c.fxml").contains("class Fxml_c"));
+    }
+
+    // ------------------------------------------------- custom controls
+
+    private static final String BADGE = "package shop;\n"
+            + "import javafx.fxml.FXML;\n"
+            + "import javafx.fxml.FXMLLoader;\n"
+            + "import javafx.scene.control.Label;\n"
+            + "import javafx.scene.layout.HBox;\n"
+            + "public class Badge extends HBox {\n"
+            + "    @FXML private Label caption;\n"
+            + "    private int level;\n"
+            + "    public Badge() {\n"
+            + "        try {\n"
+            // What Badge.class.getResource("badge.fxml") answers in a built
+            // application; this class loader has no resources of its own.
+            + "            FXMLLoader loader = new FXMLLoader(\n"
+            + "                    new java.net.URL(\"file:/work/app/target/classes/shop/badge.fxml\"));\n"
+            + "            loader.setRoot(this);\n"
+            + "            loader.setController(this);\n"
+            + "            loader.load();\n"
+            + "        } catch (java.io.IOException e) {\n"
+            + "            throw new RuntimeException(e);\n"
+            + "        }\n"
+            + "    }\n"
+            + "    public String getText() { return caption.getText(); }\n"
+            + "    public void setText(String text) { caption.setText(text); }\n"
+            + "    public int getLevel() { return level; }\n"
+            + "    public void setLevel(int level) { this.level = level; }\n"
+            + "}\n";
+
+    /// A class of the application as an element, itself built from a
+    /// document with `<fx:root>`: the documents are compiled after the
+    /// application, so the control's own setters are read like any other's.
+    @Test
+    public void aCustomControlOfTheApplicationIsAnElement() throws Exception {
+        app("custom").source("shop.Badge", BADGE)
+                .resource("shop/badge.fxml", HEAD + "<fx:root type=\"HBox\"" + NS + " spacing=\"3\">\n"
+                        + "  <Label fx:id=\"caption\" text=\"-\"/>\n"
+                        + "</fx:root>\n")
+                .resource("shop/main.fxml", HEAD + "<?import shop.Badge?>\n"
+                        + "<VBox" + NS + ">\n"
+                        + "  <Badge fx:id=\"first\" text=\"New\" level=\"7\" VBox.vgrow=\"ALWAYS\"/>\n"
+                        + "  <shop.Badge text=\"Sale\"/>\n"
+                        + "</VBox>\n").build();
+        VBox box = app.load("shop/main.fxml");
+        assertEquals(2, box.getChildren().size());
+        Node first = box.getChildren().get(0);
+        assertEquals("shop.Badge", first.getClass().getName());
+        assertEquals(3, ((HBox) first).getSpacing(), 0);
+        assertEquals(Priority.ALWAYS, VBox.getVgrow(first));
+        assertEquals("New", ((Label) ((HBox) first).getChildren().get(0)).getText());
+        assertEquals(Integer.valueOf(7), first.getClass().getMethod("getLevel").invoke(first));
+        assertEquals("Sale", ((Label) ((HBox) box.getChildren().get(1)).getChildren().get(0)).getText());
+    }
+
+    @Test
+    public void aPropertyACustomControlLacksIsAnErrorOfTheDocument() throws Exception {
+        List<String> errors = app("custom-bad").source("shop.Badge", BADGE)
+                .resource("shop/badge.fxml", HEAD + "<fx:root type=\"HBox\"" + NS + "><Label fx:id=\"caption\"/>"
+                        + "</fx:root>\n")
+                .resource("shop/main.fxml", HEAD + "<?import shop.*?>\n<VBox" + NS + "><Badge colour=\"red\"/></VBox>\n")
+                .compile();
+        assertEquals(errors.toString(), 1, errors.size());
+        assertTrue(errors.get(0), errors.get(0).contains("main.fxml:6:"));
+        assertTrue(errors.get(0), errors.get(0).contains("shop.Badge has no property colour"));
+    }
+
+    /// A build in which javac did not run finds the classes directory as
+    /// the last build's relocation left it, and must leave the documents'
+    /// classes alone: compiled again they would not fit the relocated
+    /// classes around them.
+    @Test
+    public void aRelocatedClassesDirectoryIsLeftAlone() throws Exception {
+        app("relocated").resource("main.fxml", HEAD + "<VBox" + NS + "/>\n").build();
+        File dir = new File(app.classes(), "com/codename1/generated/fxml");
+        File marker = new File(dir, "FxmlDocuments.class");
+        File document = new File(dir, "Fxml_main.class");
+        assertTrue(marker.isFile());
+        assertTrue(document.isFile());
+        assertFalse(FxmlClassCompiler.relocated(app.classes()));
+
+        // What the relocation does to the one name the class holds.
+        final org.objectweb.asm.ClassWriter moved = new org.objectweb.asm.ClassWriter(0);
+        new org.objectweb.asm.ClassReader(java.nio.file.Files.readAllBytes(marker.toPath())).accept(
+                new org.objectweb.asm.ClassVisitor(org.objectweb.asm.Opcodes.ASM9, moved) {
+                    @Override
+                    public org.objectweb.asm.MethodVisitor visitMethod(int access, String name, String descriptor,
+                            String signature, String[] exceptions) {
+                        return new org.objectweb.asm.MethodVisitor(org.objectweb.asm.Opcodes.ASM9,
+                                super.visitMethod(access, name, descriptor, signature, exceptions)) {
+                            @Override
+                            public void visitLdcInsn(Object value) {
+                                super.visitLdcInsn(value instanceof org.objectweb.asm.Type
+                                        ? org.objectweb.asm.Type.getObjectType("com/codename1/fxcompat/"
+                                                + ((org.objectweb.asm.Type) value).getInternalName()) : value);
+                            }
+                        };
+                    }
+                }, 0);
+        java.nio.file.Files.write(marker.toPath(), moved.toByteArray());
+        assertTrue(FxmlClassCompiler.relocated(app.classes()));
+
+        java.nio.file.Files.write(document.toPath(), new byte[] {1, 2, 3});
+        FxmlClassCompiler again = new FxmlClassCompiler(java.util.Collections.singletonList(
+                new File(app.file("main.fxml")).getParentFile()), FxmlHarness.classpath(),
+                java.util.Collections.<File>emptyList(), app.classes(), null, new DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                    }
+                });
+        assertTrue(again.run().isEmpty());
+        assertEquals(0, again.compiled());
+        assertEquals("The document's class was not compiled again", 3, document.length());
+    }
+
+    @Test
+    public void clearingRemovesWhatAnEarlierRunWrote() throws IOException {
+        File root = java.nio.file.Files.createTempDirectory("fxml-clear").toFile();
+        File res = new File(root, "res");
+        File gen = new File(root, "gen");
+        File out = new File(root, "out");
+        assertTrue(res.mkdirs() && out.mkdirs());
+        java.nio.file.Files.write(new File(res, "main.fxml").toPath(), ("<?xml version=\"1.0\"?>\n"
+                + "<?import javafx.scene.layout.VBox?>\n<VBox xmlns:fx=\"http://javafx.com/fxml\"/>\n")
+                .getBytes(java.nio.charset.StandardCharsets.UTF_8));
+        java.nio.file.Files.write(new File(res, "main.css").toPath(),
+                ".root { -fx-background-color: red; }\n".getBytes(java.nio.charset.StandardCharsets.UTF_8));
+        DesktopResourceCompiler compiler = new DesktopResourceCompiler(java.util.Collections.singletonList(res),
+                gen, out, new DesktopResourceCompiler.Log() {
+                    @Override
+                    public void info(String message) {
+                    }
+
+                    @Override
+                    public void warn(String message) {
+                    }
+                });
+        assertTrue(compiler.run().isEmpty());
+        File marker = new File(new File(gen, FxmlCompiler.PACKAGE.replace('.', '/')),
+                FxmlClassCompiler.MARKER + ".java");
+        File sheet = new File(out, com.codename1.fxml.css.CssSheetData.compiledName(
+                com.codename1.impl.compat.ResourceNames.flatName("main.css")));
+        assertTrue(marker.isFile());
+        assertTrue(sheet.isFile());
+        // The JavaFX layer left the build: the generated source names its
+        // API and must not stay where javac finds it.
+        compiler.clear();
+        assertFalse(marker.exists());
+        assertFalse(sheet.exists());
+    }
+
+    @Test
+    public void classNamesAreStableAndDistinct() {
+        assertEquals("Fxml_main", FxmlCompiler.className("main.fxml"));
+        assertEquals("Fxml_ui__main_mview", FxmlCompiler.className("ui/main-view.fxml"));
+        assertEquals("Fxml_a_ub", FxmlCompiler.className("a_b.fxml"));
+        assertFalse(FxmlCompiler.className("a/b.fxml").equals(FxmlCompiler.className("a__b.fxml")));
+    }
+}
diff --git a/maven/fxml-compiler/src/test/java/com/codename1/fxml/FxmlHarness.java b/maven/fxml-compiler/src/test/java/com/codename1/fxml/FxmlHarness.java
new file mode 100644
index 00000000000..b9fb8640697
--- /dev/null
+++ b/maven/fxml-compiler/src/test/java/com/codename1/fxml/FxmlHarness.java
@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxml;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.impl.compat.Resources;
+import com.codename1.fxcompat.runtime.FxmlDispatch;
+
+import javafx.fxml.FXMLLoader;
+
+/// What a build does to an application's FXML and style sheets, in a
+/// test: the resource compiler, javac over the generated sources and the
+/// application's own, the dispatch generator, and a class loader the
+/// result runs from.
+///
+/// The steps and their order are the ones of a real build. Nothing here
+/// stands in for a step: the controllers of a test are reached through the
+/// generated dispatcher and by no other route.
+final class FxmlHarness {
+
+    /// The registry a test generates. Not the layer's own name, which the
+    /// test class path already holds as a placeholder.
+    static final String REGISTRY = "fxmltest/Registry";
+
+    private final File res;
+    private final File src;
+    private final File gen;
+    private final File out;
+    private final File classes;
+    private final File fxmlSources;
+    private final List<String> sources = new ArrayList<String>();
+    final List<String> warnings = new ArrayList<String>();
+    final List<String> infos = new ArrayList<String>();
+    private URLClassLoader loader;
+    private FxmlDispatchGenerator generator;
+
+    FxmlHarness(String name) throws IOException {
+        File work = new File("target/fxml-test-work/" + name).getAbsoluteFile();
+        delete(work);
+        res = new File(work, "res");
+        src = new File(work, "src");
+        gen = new File(work, "gen");
+        out = new File(work, "out");
+        classes = new File(work, "classes");
+        fxmlSources = new File(work, "fxml");
+        for (File dir : new File[] {res, src, gen, out, classes}) {
+            if (!dir.mkdirs()) {
+                throw new IOException("Cannot create " + dir);
+            }
+        }
+    }
+
+    private static void delete(File f) {
+        File[] children = f.listFiles();
+        if (children != null) {
+            for (File child : children) {
+                delete(child);
+            }
+        }
+        f.delete();
+    }
+
+    private static void write(File f, String text) throws IOException {
+        f.getParentFile().mkdirs();
+        OutputStream o = new FileOutputStream(f);
+        try {
+            o.write(text.getBytes(StandardCharsets.UTF_8));
+        } finally {
+            o.close();
+        }
+    }
+
+    /// Adds a resource of the application: an FXML document, a style
+    /// sheet, or a file one of them names.
+    FxmlHarness resource(String path, String text) throws IOException {
+        write(new File(res, path), text);
+        return this;
+    }
+
+    /// The file of a resource, as messages name it.
+    String file(String path) {
+        return new File(res, path).getPath();
+    }
+
+    /// Adds a class of the application.
+    FxmlHarness source(String className, String text) throws IOException {
+        File f = new File(src, className.replace('.', '/') + ".java");
+        write(f, text);
+        sources.add(f.getPath());
+        return this;
+    }
+
+    /// The class path of the test, as the entries the layer, the core and
+    /// the shims were loaded from.
+    static List<File> classpath() {
+        List<File> path = new ArrayList<File>();
+        Class<?>[] of = {javafx.scene.Node.class, com.codename1.ui.Display.class, Resources.class};
+        for (Class<?> c : of) {
+            try {
+                File f = new File(c.getProtectionDomain().getCodeSource().getLocation().toURI());
+                if (!path.contains(f)) {
+                    path.add(f);
+                }
+            } catch (java.net.URISyntaxException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+        return path;
+    }
+
+    private DesktopResourceCompiler.Log log() {
+        return new DesktopResourceCompiler.Log() {
+            @Override
+            public void info(String message) {
+                infos.add(message);
+            }
+
+            @Override
+            public void warn(String message) {
+                warnings.add(message);
+            }
+        };
+    }
+
+    /// Runs the compilers in the order of a build and answers their errors:
+    /// the style sheets and the source that stands for the documents, javac
+    /// over that and the application's sources, then the documents.
+    List<String> compile() throws IOException {
+        List<String> errors = new DesktopResourceCompiler(java.util.Collections.singletonList(res), gen, out, log())
+                .run();
+        if (!errors.isEmpty()) {
+            return errors;
+        }
+        List<String> files = new ArrayList<String>(sources);
+        collect(gen, ".java", files);
+        if (!files.isEmpty()) {
+            StringBuilder cp = new StringBuilder();
+            for (File f : classpath()) {
+                cp.append(cp.length() == 0 ? "" : File.pathSeparator).append(f.getPath());
+            }
+            List<String> args = new ArrayList<String>();
+            args.add("-nowarn");
+            args.add("-encoding");
+            args.add("UTF-8");
+            args.add("-classpath");
+            args.add(cp.toString());
+            args.add("-d");
+            args.add(classes.getPath());
+            args.addAll(files);
+            JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+            ByteArrayOutputStream err = new ByteArrayOutputStream();
+            int rc = javac.run(null, null, err, args.toArray(new String[0]));
+            if (rc != 0) {
+                throw new AssertionError("javac failed:\n" + new String(err.toByteArray(), StandardCharsets.UTF_8));
+            }
+        }
+        return new FxmlClassCompiler(java.util.Collections.singletonList(res), classpath(),
+                java.util.Collections.<File>emptyList(), classes, fxmlSources, log()).run();
+    }
+
+    /// The generated source of a document.
+    String generated(String path) throws IOException {
+        File f = new File(fxmlSources, FxmlCompiler.PACKAGE.replace('.', '/') + "/" + FxmlCompiler.className(path)
+                + ".java");
+        return new String(read(f), StandardCharsets.UTF_8);
+    }
+
+    /// The compiled form of a style sheet, as the build wrote it.
+    File compiledSheet(String path) {
+        return new File(out, ResourceNames.flatName(path) + ".cn1css");
+    }
+
+    private static byte[] read(File f) throws IOException {
+        InputStream in = new FileInputStream(f);
+        try {
+            ByteArrayOutputStream o = new ByteArrayOutputStream();
+            byte[] buffer = new byte[4096];
+            int n;
+            while ((n = in.read(buffer)) > 0) {
+                o.write(buffer, 0, n);
+            }
+            return o.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    private static void collect(File dir, String suffix, List<String> into) {
+        File[] children = dir.listFiles();
+        if (children == null) {
+            return;
+        }
+        for (File child : children) {
+            if (child.isDirectory()) {
+                collect(child, suffix, into);
+            } else if (child.getName().endsWith(suffix)) {
+                into.add(child.getPath());
+            }
+        }
+    }
+
+    private static void index(File dir, String prefix, Map<String, File> into) {
+        File[] children = dir.listFiles();
+        if (children == null) {
+            return;
+        }
+        for (File child : children) {
+            if (child.isDirectory()) {
+                index(child, prefix + child.getName() + "/", into);
+            } else {
+                into.put(ResourceNames.flatName(prefix + child.getName()), child);
+            }
+        }
+    }
+
+    /// The whole build: compiles the resources, then the sources, then
+    /// generates the dispatcher and makes it the one the layer asks.
+    FxmlHarness build() throws Exception {
+        List<String> errors = compile();
+        if (!errors.isEmpty()) {
+            throw new AssertionError("The resources do not compile: " + errors);
+        }
+        generator =new FxmlDispatchGenerator(classes, FxmlDispatchGenerator.unrelocated(REGISTRY));
+        generator.run(FxmlDispatchGenerator.classesIn(classes));
+        loader = new URLClassLoader(new URL[] {classes.toURI().toURL()}, FxmlHarness.class.getClassLoader());
+        FxmlDispatch.install((FxmlDispatch) loader.loadClass(REGISTRY.replace('/', '.')).newInstance());
+        final Map<String, File> shipped = new HashMap<String, File>();
+        index(res, "", shipped);
+        index(out, "", shipped);
+        Resources.cn1SetProvider(new Resources.Provider() {
+            @Override
+            public InputStream open(String flatName) throws IOException {
+                File f = shipped.get(flatName);
+                return f == null ? null : new FileInputStream(f);
+            }
+        });
+        return this;
+    }
+
+    /// The generator of the last build.
+    FxmlDispatchGenerator generator() {
+        return generator;
+    }
+
+    /// The directory of the compiled classes.
+    File classes() {
+        return classes;
+    }
+
+    /// A class of the built application.
+    Class<?> type(String name) throws ClassNotFoundException {
+        return loader.loadClass(name);
+    }
+
+    /// The location of a document, as an application would hand it to a
+    /// loader. The directories before the resource path are the kind a
+    /// desktop URL carries and a device knows nothing about.
+    static URL location(String path) throws IOException {
+        return new URL("file:/work/app/target/classes/" + path);
+    }
+
+    /// A loader for a document.
+    FXMLLoader loader(String path) throws IOException {
+        return new FXMLLoader(location(path));
+    }
+
+    /// Loads a document.
+    <T> T load(String path) throws IOException {
+        return loader(path).<T>load();
+    }
+
+    /// Reads a field of an object of the built application. The test is
+    /// not the layer: it may use reflection to look at what the generated
+    /// code did.
+    static Object field(Object target, String name) throws Exception {
+        Class<?> c = target.getClass();
+        while (c != null) {
+            try {
+                java.lang.reflect.Field f = c.getDeclaredField(name);
+                f.setAccessible(true);
+                return f.get(target);
+            } catch (NoSuchFieldException e) {
+                c = c.getSuperclass();
+            }
+        }
+        throw new NoSuchFieldException(name);
+    }
+
+    /// Undoes what [#build()] installed.
+    void close() throws IOException {
+        FxmlDispatch.install(null);
+        Resources.cn1SetProvider(null);
+        if (loader != null) {
+            loader.close();
+        }
+    }
+}
diff --git a/maven/integration-tests/android-compat-test.sh b/maven/integration-tests/android-compat-test.sh
index f15f33a853f..a1e2767cdfc 100755
--- a/maven/integration-tests/android-compat-test.sh
+++ b/maven/integration-tests/android-compat-test.sh
@@ -19,47 +19,34 @@ SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
 set -e
 source "$SCRIPTPATH/inc/env.sh"
 source "$SCRIPTPATH/inc/gradle.sh"
+source "$SCRIPTPATH/inc/compat.sh"
 SAMPLES="$SCRIPTPATH/../../scripts/android-compat-samples"
 
 WORKDIR="$SCRIPTPATH/build/android-compat"
 rm -rf "$WORKDIR"
 mkdir -p "$WORKDIR"
 
-# Class files that still name an unrelocated Android package. A relocated name
-# is preceded by "/" (com/codename1/androidcompat/android/...), an unrelocated
-# one by the constant pool's length bytes or by the "L" of a descriptor.
-unrelocated() {
-  local dir="$1"
-  find "$dir" -name '*.class' -print0 | while IFS= read -r -d '' f; do
-    if LC_ALL=C grep -aEq '(^|[^/a-zA-Z0-9_$])L?(android|androidx|com/google/android/material)/[A-Za-z]' "$f"; then
-      echo "${f#$dir/}"
-    fi
-  done
-}
+FAILED=0
 
-staged_jar() {
-  sed -n 's/.*codename1.stageOnly is set: staged \(.*\) ([0-9]* bytes) for .*/\1/p' "$1" | tail -1
+# What every target's upload has to carry, whichever tool staged it.
+check_android_upload() {
+  local jar="$1"
+  assert_zip_has "$jar" '(^|/)com/codename1/generated/android/AndroidAppImpl\.class$'
+  assert_zip_has "$jar" '(^|/)com/codename1/androidcompat/android/app/Activity\.class$'
+  assert_zip_has "$jar" '(^|/)com/example/droid/R\.class$'
+  assert_zip_has "$jar" '(^|/)cn1_android_res\.bin$'
+  # At the root: the relocated runtime legitimately lives under
+  # com/codename1/androidcompat/android/.
+  assert_zip_lacks "$jar" '^(android|androidx)/.*\.class$'
 }
 
-# Bookkeeping, never read from the upload: directory entries and Maven's pom
-# metadata and manifest (as gradle-maven-parity-test.sh); Kotlin's module file,
-# which each tool names after its own project (app-common, DroidApp) and only
-# Kotlin reflection reads; and the ORM enhancer's per-directory list, which
-# Gradle keeps in each of its classes directories and the enhancer only ever
-# reads from the directory.
-IGNORED='/$|^META-INF/maven/|^META-INF/MANIFEST\.MF$|^META-INF/[^/]*\.kotlin_module$|^META-INF/cn1/orm-enhanced-dependencies\.list$'
-FAILED=0
-
 for sample_dir in "$SAMPLES"/*/; do
   sample=$(basename "$sample_dir")
   echo "== $sample"
   W="$WORKDIR/$sample"
   mkdir -p "$W"
   PKG=com.acme.droid
-  (cd "$W" && mvn_local archetype:generate -DarchetypeArtifactId=cn1app-archetype -DarchetypeGroupId=com.codenameone \
-    -DarchetypeVersion="$CN1_VERSION" -DartifactId=app -DgroupId=$PKG -Dpackage=$PKG \
-    -Dversion=1.0-SNAPSHOT -DmainName=DroidApp -DjavaVersion=17 -DinteractiveMode=false) > "$W/archetype.log" 2>&1 \
-    || { tail -40 "$W/archetype.log"; fail "$sample: archetype:generate"; }
+  compat_generate_app "$sample" "$W" $PKG DroidApp
   MAPP="$W/app"
   (cd "$MAPP" && mvn_local "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:import-android-project" \
       "-Dcn1.android.import=$sample_dir") > "$W/import.log" 2>&1 \
@@ -70,8 +57,7 @@ for sample_dir in "$SAMPLES"/*/; do
   grep -q 'extends com.codename1.androidcompat.runtime.AndroidLifecycle' "$MAPP/common/src/main/java/com/acme/droid/DroidApp.java" \
     || fail "$sample: the entry point does not start the Android application"
 
-  (cd "$MAPP" && JAVA_HOME="$GRADLE_JDK" mvn_local install -DskipTests -pl common -am) > "$W/mvn-common.log" 2>&1 \
-    || { tail -60 "$W/mvn-common.log"; fail "$sample: Maven build"; }
+  compat_build_common "$sample" "$W" "$MAPP"
   classes="$MAPP/common/target/classes"
   for expected in com/codename1/generated/android/AndroidAppImpl.class cn1_android_res.bin cn1_android_framework.bin \
                   com/codename1/androidcompat/rt/OnClickDispatch.class; do
@@ -79,50 +65,18 @@ for sample_dir in "$SAMPLES"/*/; do
   done
   ls "$classes"/com/codename1/androidcompat/android/app/Activity.class > /dev/null 2>&1 \
     || fail "$sample: the relocated runtime is not in the application's classes"
-  bad=$(unrelocated "$classes")
+  bad=$(compat_unrelocated "$classes" 'android|androidx|com/google/android/material')
   if [ -n "$bad" ]; then
     echo "FAIL: $sample: classes still name android.* after the remap:"
     echo "$bad" | head -20
     FAILED=1
   fi
 
-  (cd "$MAPP" && mvn_local "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:convert-to-gradle") > "$W/convert.log" 2>&1 \
-    || { cat "$W/convert.log"; fail "$sample: convert-to-gradle"; }
+  compat_convert_to_gradle "$sample" "$W" "$MAPP"
   GAPP="$W/app-gradle"
-  use_local_plugin "$GAPP"
   [ -f "$GAPP/src/main/android/AndroidManifest.xml" ] || fail "$sample: the Gradle conversion dropped src/main/android"
 
-  for spec in "android android-device buildAndroid" "ios ios-device buildIos" "javascript javascript buildJavascript" \
-              "javase mac-os-x-desktop buildMacDesktop"; do
-    read -r platform target task <<< "$spec"
-    mlog="$W/maven-$target.log"
-    glog="$W/gradle-$target.log"
-    (cd "$MAPP" && JAVA_HOME="$GRADLE_JDK" mvn_local package -DskipTests -Dopen=false -Dcodename1.platform=$platform \
-        -Dcodename1.buildTarget=$target -Dcodename1.stageOnly=true < /dev/null) > "$mlog" 2>&1 \
-      || { tail -40 "$mlog"; fail "$sample: Maven staging $target"; }
-    run_gradle "$GAPP" "$task" -Pcodename1.stageOnly=true > "$glog" 2>&1 || { tail -60 "$glog"; fail "$sample: Gradle staging $target"; }
-    mjar=$(staged_jar "$mlog")
-    gjar=$(staged_jar "$glog")
-    [ -f "$mjar" ] && [ -f "$gjar" ] || fail "$sample: $target: a staged jar is missing (maven=$mjar gradle=$gjar)"
-    for jar in "$mjar" "$gjar"; do
-      assert_zip_has "$jar" '(^|/)com/codename1/generated/android/AndroidAppImpl\.class$'
-      assert_zip_has "$jar" '(^|/)com/codename1/androidcompat/android/app/Activity\.class$'
-      assert_zip_has "$jar" '(^|/)com/example/droid/R\.class$'
-      assert_zip_has "$jar" '(^|/)cn1_android_res\.bin$'
-      # At the root: the relocated runtime legitimately lives under
-      # com/codename1/androidcompat/android/.
-      assert_zip_lacks "$jar" '^(android|androidx)/.*\.class$'
-    done
-    unzip -Z1 "$mjar" | grep -Ev "$IGNORED" | sort > "$W/maven-$target.txt"
-    unzip -Z1 "$gjar" | grep -Ev "$IGNORED" | sort > "$W/gradle-$target.txt"
-    if diff "$W/maven-$target.txt" "$W/gradle-$target.txt" > "$W/diff-$target.txt"; then
-      echo "   $target: $(wc -l < "$W/maven-$target.txt" | tr -d ' ') entries, Maven and Gradle identical"
-    else
-      echo "FAIL: $sample: $target uploads differ (< Maven only, > Gradle only):"
-      head -40 "$W/diff-$target.txt"
-      FAILED=1
-    fi
-  done
+  compat_stage_all "$sample" "$W" "$MAPP" "$GAPP" check_android_upload
   bash "$SCRIPTPATH/android-gradle-incremental-test.sh" "$GAPP"
 done
 
diff --git a/maven/integration-tests/desktop-compat-realport/RealPortDriver.java b/maven/integration-tests/desktop-compat-realport/RealPortDriver.java
new file mode 100644
index 00000000000..f7b23836cda
--- /dev/null
+++ b/maven/integration-tests/desktop-compat-realport/RealPortDriver.java
@@ -0,0 +1,407 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.javase.JavaSEPort;
+import com.codename1.ui.Display;
+
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Robot;
+import java.awt.Toolkit;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.List;
+import javax.imageio.ImageIO;
+import javax.swing.JFrame;
+import javax.swing.SwingUtilities;
+
+/// Runs a built Codename One application on the real JavaSE port, in a frame
+/// set up the way the generated desktop stub sets it up, and plays a script of
+/// real input against it: the pointer and the keys are the display server's,
+/// sent by `java.awt.Robot`, and nothing is called inside the application.
+///
+/// It fails -- exit code 1 -- when anything threw, on any thread, or when a
+/// step that is input left every pixel of the application as it was: a button
+/// that does nothing under a real pointer is the failure this exists to catch,
+/// and no test that fires an event at a node can see it.
+///
+/// Arguments: main class, width, height, script file, output directory.
+///
+/// The width and height are the size the application's area is opened at. An
+/// application that sizes its own window gets the size it asks for, as it does
+/// under the desktop stub; the line `REALPORT area:` says what it came to.
+///
+/// A script line is one step. A position is a fraction of the application's
+/// area.
+///
+/// - `sleep <ms>`
+/// - `move <x> <y>`
+/// - `click <x> <y>`
+/// - `drag <x1> <y1> <x2> <y2> <ms>`
+/// - `key <name>` -- a `java.awt.event.KeyEvent` constant without `VK_`
+/// - `type <text>` -- letters, digits and spaces
+/// - `shot <name>` -- saves the picture, changes nothing
+///
+/// `click`, `drag`, `key` and `type` have to change the picture within three
+/// seconds, outside what was already changing by itself -- a spinner, a caret.
+/// Prefix the line with `quiet` for a step that is not meant to.
+public final class RealPortDriver {
+
+    private static final List<String> FAILURES = new ArrayList<String>();
+    private static final java.util.concurrent.atomic.AtomicInteger THROWN =
+            new java.util.concurrent.atomic.AtomicInteger();
+
+    private static Robot robot;
+    private static Component canvas;
+    private static File out;
+    private static int step;
+
+    private RealPortDriver() {
+    }
+
+    /// Counts what is printed that reads as a stack trace or names an
+    /// exception, and passes everything on.
+    private static final class Watch extends OutputStream {
+        private final PrintStream to;
+        private final StringBuilder line = new StringBuilder();
+
+        Watch(PrintStream to) {
+            this.to = to;
+        }
+
+        @Override
+        public void write(int b) {
+            to.write(b);
+            if (b == '\n') {
+                String s = line.toString();
+                line.setLength(0);
+                if (s.contains("Exception") || s.startsWith("\tat ")) {
+                    THROWN.incrementAndGet();
+                }
+            } else {
+                line.append((char) b);
+            }
+        }
+    }
+
+    public static void main(final String[] a) throws Exception {
+        final int w = Integer.parseInt(a[1]);
+        final int h = Integer.parseInt(a[2]);
+        out = new File(a[4]);
+        if (!out.isDirectory() && !out.mkdirs()) {
+            throw new IllegalStateException("cannot create " + out);
+        }
+        System.setOut(new PrintStream(new Watch(System.out), true));
+        System.setErr(new PrintStream(new Watch(System.err), true));
+        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                System.out.println("Uncaught Exception on " + t.getName());
+                e.printStackTrace(System.out);
+            }
+        });
+        // A desktop build packages the theme of its platform as /NativeTheme.res; the
+        // classes of a project carry none, so the one a Linux build gets is named.
+        JavaSEPort.setNativeTheme(System.getProperty("realport.theme", "/GnomeAdwaitaTheme.res"));
+        JavaSEPort.blockMonitors();
+        JavaSEPort.setAppHomeDir(".cn1-realport");
+        JavaSEPort.setExposeFilesystem(true);
+        JavaSEPort.setTablet(true);
+        JavaSEPort.setUseNativeInput(true);
+        JavaSEPort.setShowEDTViolationStacks(false);
+        JavaSEPort.setShowEDTWarnings(false);
+        final JFrame frame = new JFrame("cn1-realport");
+        JavaSEPort.setDefaultPixelMilliRatio(Toolkit.getDefaultToolkit().getScreenResolution() / 25.4
+                * JavaSEPort.getRetinaScale());
+        Display.init(frame.getContentPane());
+        Display.getInstance().addEdtErrorHandler(new com.codename1.ui.events.ActionListener() {
+            @Override
+            public void actionPerformed(com.codename1.ui.events.ActionEvent e) {
+                System.out.println("Exception on the event thread: " + e.getSource());
+                if (e.getSource() instanceof Throwable) {
+                    ((Throwable) e.getSource()).printStackTrace(System.out);
+                }
+                e.consume();
+            }
+        });
+        SwingUtilities.invokeAndWait(new Runnable() {
+            @Override
+            public void run() {
+                frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+                frame.setUndecorated(true);
+                frame.getContentPane().setPreferredSize(new Dimension(w, h));
+                frame.pack();
+            }
+        });
+        Display.getInstance().callSeriallyAndWait(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Class<?> c = Class.forName(a[0]);
+                    Object app = c.getConstructor().newInstance();
+                    c.getMethod("init", Object.class).invoke(app, new Object[] {null});
+                    c.getMethod("start").invoke(app);
+                } catch (Throwable t) {
+                    System.out.println("Exception starting " + a[0]);
+                    t.printStackTrace(System.out);
+                }
+            }
+        });
+        SwingUtilities.invokeAndWait(new Runnable() {
+            @Override
+            public void run() {
+                // Shown at whatever size it has by now, as the desktop stub shows it:
+                // the frame was packed to the size asked for before the application
+                // started, and an application that sizes its own window -- a packed
+                // JFrame, a Stage with a Scene of a given size -- has since asked the
+                // port for that. Sizing the frame again here took that size away from
+                // an application that asked while it started, and not from one that
+                // asked a moment later, on the next cycle of the event thread.
+                frame.setLocation(40, 40);
+                frame.setVisible(true);
+                frame.validate();
+                frame.toFront();
+                canvas = frame.getContentPane().getComponent(0);
+                canvas.requestFocus();
+            }
+        });
+        robot = new Robot();
+        robot.setAutoDelay(0);
+        Thread.sleep(2500);
+        // What the fractions of a script are fractions of.
+        System.out.println("REALPORT area: " + area().width + "x" + area().height);
+        shot("start");
+        BufferedReader in = new BufferedReader(new FileReader(a[3]));
+        try {
+            String line;
+            while ((line = in.readLine()) != null) {
+                line = line.trim();
+                if (line.length() > 0 && line.charAt(0) != '#') {
+                    play(line);
+                }
+            }
+        } finally {
+            in.close();
+        }
+        Thread.sleep(500);
+        shot("end");
+        if (THROWN.get() > 0) {
+            FAILURES.add(THROWN.get() + " line(s) of output name an exception");
+        }
+        for (String f : FAILURES) {
+            System.out.println("REALPORT FAIL: " + f);
+        }
+        System.out.println("REALPORT " + (FAILURES.isEmpty() ? "OK" : "FAILED") + ": " + step + " steps, pictures in "
+                + out);
+        Runtime.getRuntime().halt(FAILURES.isEmpty() ? 0 : 1);
+    }
+
+    private static Rectangle area() {
+        Point p = canvas.getLocationOnScreen();
+        return new Rectangle(p.x, p.y, canvas.getWidth(), canvas.getHeight());
+    }
+
+    private static int x(String fraction) {
+        Rectangle r = area();
+        return r.x + (int) Math.round(Double.parseDouble(fraction) * r.width);
+    }
+
+    private static int y(String fraction) {
+        Rectangle r = area();
+        return r.y + (int) Math.round(Double.parseDouble(fraction) * r.height);
+    }
+
+    private static BufferedImage grab() {
+        return robot.createScreenCapture(area());
+    }
+
+    private static void shot(String name) throws Exception {
+        String n = (step < 10 ? "0" : "") + step + "-" + name.replaceAll("[^A-Za-z0-9_.-]", "_") + ".png";
+        ImageIO.write(grab(), "png", new File(out, n));
+    }
+
+    /// The pixels that change with nobody touching anything -- a progress
+    /// indicator, a blinking caret, a running animation -- found by watching for
+    /// longer than a caret's blink and widened by a few pixels. Input is judged
+    /// on the rest of the picture, or a click on nothing at all would pass on any
+    /// screen that has a spinner on it.
+    private static boolean[] moving() throws Exception {
+        BufferedImage last = grab();
+        int w = last.getWidth();
+        int h = last.getHeight();
+        boolean[] raw = new boolean[w * h];
+        for (int i = 0; i < 7; i++) {
+            Thread.sleep(200);
+            BufferedImage now = grab();
+            if (now.getWidth() != w || now.getHeight() != h) {
+                return new boolean[0];
+            }
+            for (int yy = 0; yy < h; yy++) {
+                for (int xx = 0; xx < w; xx++) {
+                    if (differs(last.getRGB(xx, yy), now.getRGB(xx, yy))) {
+                        raw[yy * w + xx] = true;
+                    }
+                }
+            }
+            last = now;
+        }
+        boolean[] wide = new boolean[w * h];
+        int r = 6;
+        for (int yy = 0; yy < h; yy++) {
+            for (int xx = 0; xx < w; xx++) {
+                if (raw[yy * w + xx]) {
+                    for (int dy = Math.max(0, yy - r); dy <= Math.min(h - 1, yy + r); dy++) {
+                        for (int dx = Math.max(0, xx - r); dx <= Math.min(w - 1, xx + r); dx++) {
+                            wide[dy * w + dx] = true;
+                        }
+                    }
+                }
+            }
+        }
+        return wide;
+    }
+
+    private static boolean differs(int p, int q) {
+        int d = Math.abs((p >> 16 & 255) - (q >> 16 & 255)) + Math.abs((p >> 8 & 255) - (q >> 8 & 255))
+                + Math.abs((p & 255) - (q & 255));
+        return d > 24;
+    }
+
+    private static int differing(BufferedImage a, BufferedImage b, boolean[] ignored) {
+        if (a.getWidth() != b.getWidth() || a.getHeight() != b.getHeight()) {
+            return Integer.MAX_VALUE;
+        }
+        int w = a.getWidth();
+        boolean masked = ignored.length == w * a.getHeight();
+        int n = 0;
+        for (int yy = 0; yy < a.getHeight(); yy++) {
+            for (int xx = 0; xx < w; xx++) {
+                if (masked && ignored[yy * w + xx]) {
+                    continue;
+                }
+                if (differs(a.getRGB(xx, yy), b.getRGB(xx, yy))) {
+                    n++;
+                }
+            }
+        }
+        return n;
+    }
+
+    private static void play(String line) throws Exception {
+        boolean quiet = line.startsWith("quiet ");
+        if (quiet) {
+            line = line.substring(6).trim();
+        }
+        String[] t = line.split("\\s+");
+        String op = t[0];
+        if ("sleep".equals(op)) {
+            Thread.sleep(Long.parseLong(t[1]));
+            return;
+        }
+        step++;
+        if ("shot".equals(op)) {
+            shot(t[1]);
+            return;
+        }
+        if ("move".equals(op)) {
+            robot.mouseMove(x(t[1]), y(t[2]));
+            Thread.sleep(300);
+            return;
+        }
+        BufferedImage before;
+        boolean[] ignored;
+        if ("click".equals(op)) {
+            robot.mouseMove(x(t[1]), y(t[2]));
+            // What hovering changes is not what the click changes.
+            Thread.sleep(400);
+            ignored = moving();
+            before = grab();
+            robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+            Thread.sleep(80);
+            robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+        } else if ("drag".equals(op)) {
+            int x1 = x(t[1]);
+            int y1 = y(t[2]);
+            int x2 = x(t[3]);
+            int y2 = y(t[4]);
+            long ms = Long.parseLong(t[5]);
+            robot.mouseMove(x1, y1);
+            Thread.sleep(400);
+            ignored = moving();
+            before = grab();
+            robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+            int n = 12;
+            for (int i = 1; i <= n; i++) {
+                robot.mouseMove(x1 + (x2 - x1) * i / n, y1 + (y2 - y1) * i / n);
+                Thread.sleep(Math.max(1, ms / n));
+            }
+            robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+        } else if ("key".equals(op)) {
+            ignored = moving();
+            before = grab();
+            int code = KeyEvent.class.getField("VK_" + t[1]).getInt(null);
+            robot.keyPress(code);
+            Thread.sleep(60);
+            robot.keyRelease(code);
+        } else if ("type".equals(op)) {
+            ignored = moving();
+            before = grab();
+            String text = line.substring(4).trim();
+            for (int i = 0; i < text.length(); i++) {
+                int code = KeyEvent.getExtendedKeyCodeForChar(text.charAt(i));
+                robot.keyPress(code);
+                Thread.sleep(40);
+                robot.keyRelease(code);
+                Thread.sleep(60);
+            }
+        } else {
+            FAILURES.add("step " + step + ": unknown step '" + line + "'");
+            return;
+        }
+        int changed = 0;
+        long until = System.currentTimeMillis() + 3000;
+        while (System.currentTimeMillis() < until) {
+            Thread.sleep(100);
+            changed = differing(before, grab(), ignored);
+            if (changed > 0) {
+                break;
+            }
+        }
+        // Let what the input started come to rest before the picture is kept.
+        Thread.sleep(600);
+        shot(op);
+        System.out.println("REALPORT step " + step + " '" + line + "': " + changed + " pixels changed");
+        if (changed == 0 && !quiet) {
+            FAILURES.add("step " + step + " '" + line + "': no pixel changed after the input");
+        }
+    }
+}
diff --git a/maven/integration-tests/desktop-compat-realport/javafx-gallery.txt b/maven/integration-tests/desktop-compat-realport/javafx-gallery.txt
new file mode 100644
index 00000000000..4d48073abdc
--- /dev/null
+++ b/maven/integration-tests/desktop-compat-realport/javafx-gallery.txt
@@ -0,0 +1,35 @@
+# The JavaFX gallery under a real pointer and real keys.
+# Every step but the quiet ones has to change the picture, outside whatever
+# was moving by itself; see RealPortDriver.java.
+#
+# Positions are fractions of the application's area, which is the one the
+# gallery gives itself: its scene is 920 by 660 logical pixels, and under
+# xvfb that is a window of 949 by 681 with 949 by 660 left under the port's
+# own menu bar ("REALPORT area: 949x660"). A step that stops changing the
+# picture after a change to the layer is first checked against the frames:
+# what it aimed at may have moved.
+sleep 4000
+shot start
+# A toggle, a button, a check box and a radio button. The toggle goes first:
+# the window opens with the focus on the button, as a JavaFX window does, and
+# the line that reports a press is below the slider's ticks, out of a window
+# of this height. A press of the button shows in the focus leaving the toggle.
+click 0.433 0.185
+click 0.056 0.185
+click 0.028 0.309
+click 0.028 0.359
+# A text field: focus, typing, and Tab on to the next one.
+click 0.300 0.433
+type ada
+key TAB
+# The slider follows a drag.
+drag 0.403 0.789 0.250 0.789 400
+# Tabs: Data, Layouts, Animation and back.
+click 0.092 0.059
+shot data
+click 0.148 0.059
+shot layouts
+click 0.406 0.059
+shot animation
+click 0.034 0.059
+shot controls
diff --git a/maven/integration-tests/desktop-compat-realport/run.sh b/maven/integration-tests/desktop-compat-realport/run.sh
new file mode 100755
index 00000000000..12f0a9e468c
--- /dev/null
+++ b/maven/integration-tests/desktop-compat-realport/run.sh
@@ -0,0 +1,81 @@
+#!/bin/bash
+# A built Codename One application on the REAL JavaSE port, under real input.
+#
+#   run.sh <application's common dir> <input script> [output dir]
+#
+# The application is the staged project of desktop-compat-test.sh (or any
+# Codename One project whose common module is built): its classes are run in a
+# frame set up as the generated desktop stub sets one up, and RealPortDriver
+# plays the script against it with the display server's own pointer and keys.
+#
+# It fails when anything threw, or when a step of input changed no pixel. That
+# second one is the point: the layers' unit tests fire events at the node they
+# are meant for, and an application whose buttons were dead under a real
+# pointer passed every one of them. See RealPortDriver.java for the script.
+#
+# Needs a display -- run it under xvfb-run where there is none -- and a JDK 11
+# or newer, which is what the port itself needs at run time: REALPORT_JAVA_HOME,
+# then GRADLE_JAVA_HOME, JAVA17_HOME, JAVA_HOME. The framework jars come from
+# the local Maven repository (MAVEN_REPO_LOCAL when the reactor was installed
+# with -Dmaven.repo.local). SIZE=WIDTHxHEIGHT is the size the application's area
+# is opened at; an application that sizes its own window, as both galleries do,
+# then gets the size it asks for.
+#
+# With no arguments it runs the smoke scripts beside it against the samples
+# desktop-compat-test.sh staged: <sample>.txt against build/desktop-compat/<sample>.
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+IT="$SCRIPTPATH/.."
+set -e
+CN1_VERSION="${CN1_VERSION:-$(bash "$IT/../print-version.sh")}"
+REPO="${MAVEN_REPO_LOCAL:-$HOME/.m2/repository}"
+JDK="${REALPORT_JAVA_HOME:-${GRADLE_JAVA_HOME:-${JAVA17_HOME:-$JAVA_HOME}}}"
+SIZE="${SIZE:-1000x800}"
+
+run_one() {
+  local common="$1" script="$2" out="$3"
+  local classes="$common/target/classes"
+  [ -d "$classes" ] || { echo "FAIL: $classes: the application is not built"; return 1; }
+  local settings="$common/codenameone_settings.properties"
+  local main pkg
+  main=$(sed -n 's/^codename1.mainName=//p' "$settings" | tr -d '\r')
+  pkg=$(sed -n 's/^codename1.packageName=//p' "$settings" | tr -d '\r')
+  [ -n "$main" ] && [ -n "$pkg" ] || { echo "FAIL: $settings names no main class"; return 1; }
+  local cp="$classes"
+  local artifact jar
+  # project-model: the port reads the project's layout through it when it opens the theme.
+  for artifact in codenameone-core codenameone-javase codenameone-project-model; do
+    jar="$REPO/com/codenameone/$artifact/$CN1_VERSION/$artifact-$CN1_VERSION.jar"
+    [ -f "$jar" ] || { echo "FAIL: $jar is not installed"; return 1; }
+    cp="$cp:$jar"
+  done
+  mkdir -p "$out/driver"
+  "$JDK/bin/javac" -nowarn -d "$out/driver" -cp "$cp" "$SCRIPTPATH/RealPortDriver.java"
+  # The port keeps its preferences and the application's storage under the home directory.
+  mkdir -p "$out/home"
+  (cd "$common" && "$JDK/bin/java" -Xmx1g "-Duser.home=$out/home" -cp "$out/driver:$cp" RealPortDriver \
+      "$pkg.$main" "${SIZE%x*}" "${SIZE#*x}" "$script" "$out/frames") > "$out/realport.log" 2>&1 \
+    || { tail -60 "$out/realport.log"; echo "FAIL: $(basename "$script") against $common"; return 1; }
+  grep "^REALPORT" "$out/realport.log"
+}
+
+if [ $# -ge 2 ]; then
+  run_one "$1" "$2" "${3:-$IT/build/desktop-compat-realport/$(basename "$2" .txt)}"
+  exit $?
+fi
+
+STAGED="${CN1_COMPAT_WORKDIR:-$IT/build}/desktop-compat"
+FAILED=0
+RAN=0
+for script in "$SCRIPTPATH"/*.txt; do
+  sample=$(basename "$script" .txt)
+  if [ ! -d "$STAGED/$sample/app/common" ]; then
+    echo "FAIL: $sample is not staged under $STAGED; run desktop-compat-test.sh first"
+    FAILED=1
+    continue
+  fi
+  echo "== $sample on the real port"
+  run_one "$STAGED/$sample/app/common" "$script" "$IT/build/desktop-compat-realport/$sample" || FAILED=1
+  RAN=$((RAN + 1))
+done
+[ "$RAN" -gt 0 ] || { echo "FAIL: no smoke script ran"; exit 1; }
+exit $FAILED
diff --git a/maven/integration-tests/desktop-compat-realport/swing-gallery.txt b/maven/integration-tests/desktop-compat-realport/swing-gallery.txt
new file mode 100644
index 00000000000..7526e5a98ca
--- /dev/null
+++ b/maven/integration-tests/desktop-compat-realport/swing-gallery.txt
@@ -0,0 +1,31 @@
+# The Swing gallery under a real pointer and real keys.
+# Every step but the quiet ones has to change the picture, outside whatever
+# was moving by itself; see RealPortDriver.java.
+#
+# Positions are fractions of the application's area, which is the one the
+# gallery gives itself: it packs its frame to 820 by 600 logical pixels, and
+# under xvfb that is a window of 846 by 619 with 846 by 598 left under the
+# port's own menu bar ("REALPORT area: 846x598"). The window's title is the
+# strip on top, the frame's menu bar the row under it, the tabs the row under
+# that. A step that stops changing the picture after a change to either layer
+# is first checked against the frames: what it aimed at may have moved.
+sleep 4000
+shot start
+# A button and a radio button, then the check box, which disables both.
+click 0.074 0.331
+click 0.290 0.331
+click 0.177 0.331
+# A text field: focus, typing, and Tab on to the next one.
+click 0.374 0.433
+type bc
+key TAB
+# The slider follows a drag, and the progress bar starts.
+drag 0.645 0.630 0.752 0.630 400
+click 0.251 0.776
+# Tabs: Layouts, Data and back.
+click 0.124 0.119
+shot layouts
+click 0.195 0.119
+shot data
+click 0.041 0.119
+shot controls
diff --git a/maven/integration-tests/desktop-compat-test.sh b/maven/integration-tests/desktop-compat-test.sh
new file mode 100755
index 00000000000..c8c481caf94
--- /dev/null
+++ b/maven/integration-tests/desktop-compat-test.sh
@@ -0,0 +1,181 @@
+#!/bin/bash
+# An unmodified Swing or JavaFX project (scripts/desktop-compat-samples/*) is
+# imported into an archetype application and built for every target, by Maven
+# and by Gradle. Checks, for each sample:
+#
+#   - cn1:import-desktop-project copies the sources and rewrites the
+#     application's main class (common/src/main/java) to start the imported
+#     application, extending the Swing or the JavaFX lifecycle;
+#   - the build relocated every reference to the toolkits: no class the
+#     application ships may name java/awt/, javax/swing/, java/beans/,
+#     org/jdesktop/ or javafx/, because no device has those classes and the
+#     first two packages cannot be defined by anything but a JDK;
+#   - the runtime of the toolkit the sample uses is in the application's
+#     classes, under its relocated name;
+#   - every target's upload jar (staged, never sent) carries all of it, so the
+#     iOS, Android, JavaScript and desktop builders all get the remapped code,
+#     and no class in any of those jars names a toolkit type either;
+#   - the Gradle build uploads the same entries as the Maven build.
+#
+# It also prints what the layer costs an application: the size of each staged
+# jar, and how many of its classes and bytes are the layer's runtime rather
+# than the application.
+#
+# Needs the reactor installed (mvn install) and a JDK 17+; see inc/gradle.sh.
+SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
+set -e
+SAMPLES="$SCRIPTPATH/../../scripts/desktop-compat-samples"
+if [ ! -d "$SAMPLES" ] || [ -z "$(find "$SAMPLES" -mindepth 1 -maxdepth 1 -type d 2>/dev/null)" ]; then
+  echo "desktop-compat-test: SKIPPED, no samples under scripts/desktop-compat-samples"
+  exit 0
+fi
+source "$SCRIPTPATH/inc/env.sh"
+source "$SCRIPTPATH/inc/gradle.sh"
+source "$SCRIPTPATH/inc/compat.sh"
+
+WORKDIR="${CN1_COMPAT_WORKDIR:-$SCRIPTPATH/build}/desktop-compat"
+rm -rf "$WORKDIR"
+mkdir -p "$WORKDIR"
+
+# The packages of both toolkits, as an application is compiled against them.
+TOOLKITS='java/awt|javax/swing|java/beans|javax/accessibility|javax/imageio|org/jdesktop|javafx'
+FAILED=0
+
+# What every target's upload has to carry, whichever tool staged it. MAIN_ENTRY
+# and RUNTIME are set per sample, below.
+check_desktop_upload() {
+  local jar="$1"
+  assert_zip_has "$jar" "(^|/)$MAIN_ENTRY\\.class\$"
+  assert_zip_has "$jar" "(^|/)$RUNTIME/.*\\.class\$"
+  # At the root: the relocated runtimes legitimately live under
+  # com/codename1/desktopcompat/ and com/codename1/fxcompat/.
+  assert_zip_lacks "$jar" "^($TOOLKITS)/.*\\.class\$"
+  # And inside the classes: the same question the classes directory was asked,
+  # of what is actually uploaded.
+  local bad
+  bad=$(compat_unrelocated "$jar" "$TOOLKITS")
+  if [ -n "$bad" ]; then
+    echo "FAIL: $jar: classes still name a desktop toolkit:"
+    echo "$bad" | head -20
+    FAILED=1
+  fi
+}
+
+# desktop_shipped_size <target> <jar>
+#
+# One line: the jar's size, and the share of it that is a compatibility
+# runtime (the relocated toolkit and the shared JDK classes) as a class count,
+# the bytes those classes take in the jar, and their size unpacked.
+desktop_shipped_size() {
+  local target="$1" jar="$2" total
+  total=$(wc -c < "$jar" | tr -d ' ')
+  unzip -v "$jar" | awk -v target="$target" -v total="$total" '
+    $NF ~ /\.class$/ { all++ }
+    $NF ~ /^com\/codename1\/(desktopcompat|fxcompat|compat\/jdk)\/.*\.class$/ { n++; raw += $1; packed += $3 }
+    END { printf "   size %s: jar %d bytes, %d classes; compatibility runtime %d classes, %d bytes in the jar (%d unpacked)\n",
+                 target, total, all, n, packed, raw }'
+}
+
+for sample_dir in "$SAMPLES"/*/; do
+  sample=$(basename "$sample_dir")
+  echo "== $sample"
+  W="$WORKDIR/$sample"
+  mkdir -p "$W"
+  PKG=com.acme.desktop
+  compat_generate_app "$sample" "$W" $PKG DesktopApp
+  MAPP="$W/app"
+  (cd "$MAPP" && mvn_local "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:import-desktop-project" \
+      "-Dcn1.desktop.import=$sample_dir") > "$W/import.log" 2>&1 \
+    || { tail -40 "$W/import.log"; fail "$sample: import-desktop-project"; }
+  desktop="$MAPP/common/src/main/desktop"
+  # The application's main class is what starts the imported one, and the
+  # lifecycle it extends says which toolkit that is.
+  main_source="$MAPP/common/src/main/java/com/acme/desktop/DesktopApp.java"
+  [ -f "$main_source" ] || fail "$sample: the import left no main class"
+  grep -q '^// Written by cn1:import-desktop-project\.' "$main_source" \
+    || fail "$sample: the import did not write the main class"
+  if grep -q 'extends com\.codename1\.desktopcompat\.rt\.DesktopLifecycle' "$main_source"; then
+    kind=swing; RUNTIME=com/codename1/desktopcompat
+  elif grep -q 'extends com\.codename1\.fxcompat\.runtime\.FxLifecycle' "$main_source"; then
+    kind=javafx; RUNTIME=com/codename1/fxcompat
+  else
+    fail "$sample: the main class extends neither desktop lifecycle"
+  fi
+  MAIN_ENTRY=com/acme/desktop/DesktopApp
+  [ -d "$desktop/java" ] || [ -d "$desktop/kotlin" ] || fail "$sample: the import copied no sources"
+  [ -z "$(find "$desktop" -name module-info.java)" ] || fail "$sample: the import kept a module descriptor"
+  echo "   $kind application, started by com.acme.desktop.DesktopApp:"
+  grep -E '^ +(return new |[A-Za-z_$][A-Za-z0-9_$.]*\.(main|launch|create)\()' "$main_source" | sed 's/^ */     /'
+
+  compat_build_common "$sample" "$W" "$MAPP"
+  classes="$MAPP/common/target/classes"
+  [ -f "$classes/$MAIN_ENTRY.class" ] || fail "$sample: the build produced no $MAIN_ENTRY.class"
+  [ -n "$(find "$classes/$RUNTIME" -name '*.class' 2>/dev/null | head -1)" ] \
+    || fail "$sample: the relocated $kind runtime is not in the application's classes"
+  bad=$(compat_unrelocated "$classes" "$TOOLKITS")
+  if [ -n "$bad" ]; then
+    echo "FAIL: $sample: classes still name a desktop toolkit after the remap:"
+    echo "$bad" | head -20
+    FAILED=1
+  fi
+
+  compat_convert_to_gradle "$sample" "$W" "$MAPP"
+  GAPP="$W/app-gradle"
+  [ -d "$GAPP/src/main/desktop" ] || fail "$sample: the Gradle conversion dropped src/main/desktop"
+
+  compat_stage_all "$sample" "$W" "$MAPP" "$GAPP" check_desktop_upload
+  for target in android-device ios-device javascript mac-os-x-desktop; do
+    staged=$(compat_staged_jar "$W/maven-$target.log")
+    [ -f "$staged" ] && desktop_shipped_size "$target" "$staged"
+  done
+done
+
+# An Android application and a desktop one in the SAME project. A project has
+# one main class: the Android import makes it start the Android application,
+# and the desktop import that follows has to leave it alone and bring the
+# desktop sources in as a library, relocated like any library the Android code
+# could call. Staged for one target; the relocation is the same for all of them
+# and the loop above covers the rest.
+ANDROID_SAMPLE="$SCRIPTPATH/../../scripts/android-compat-samples/gallery"
+SWING_SAMPLE="$SAMPLES/swing-gallery"
+if [ -d "$ANDROID_SAMPLE" ] && [ -d "$SWING_SAMPLE" ]; then
+  echo "== both layers (android gallery + swing-gallery)"
+  W="$WORKDIR/both-layers"
+  mkdir -p "$W"
+  compat_generate_app both "$W" com.acme.both BothApp
+  MAPP="$W/app"
+  (cd "$MAPP" && mvn_local "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:import-android-project" \
+      "-Dcn1.android.import=$ANDROID_SAMPLE") > "$W/import-android.log" 2>&1 \
+    || { tail -40 "$W/import-android.log"; fail "both: import-android-project"; }
+  (cd "$MAPP" && mvn_local "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:import-desktop-project" \
+      "-Dcn1.desktop.import=$SWING_SAMPLE") > "$W/import-desktop.log" 2>&1 \
+    || { tail -40 "$W/import-desktop.log"; fail "both: import-desktop-project"; }
+  grep -q 'AndroidLifecycle' "$MAPP/common/src/main/java/com/acme/both/BothApp.java" \
+    || fail "both: the desktop import replaced the Android application's main class"
+  grep -q 'Imported as a library' "$W/import-desktop.log" \
+    || { tail -40 "$W/import-desktop.log"; fail "both: the desktop import did not say it imported a library"; }
+  echo "   the desktop import kept the Android main class and imported a library"
+
+  compat_build_common both "$W" "$MAPP"
+  (cd "$MAPP" && JAVA_HOME="$GRADLE_JDK" mvn_local package -DskipTests -Dopen=false -Dcodename1.platform=ios \
+      -Dcodename1.buildTarget=ios-device -Dcodename1.stageOnly=true < /dev/null) > "$W/maven-ios-device.log" 2>&1 \
+    || { tail -40 "$W/maven-ios-device.log"; fail "both: Maven staging ios-device"; }
+  staged=$(compat_staged_jar "$W/maven-ios-device.log")
+  [ -f "$staged" ] || fail "both: no staged jar"
+  assert_zip_has "$staged" '^com/acme/both/BothApp\.class$'
+  assert_zip_has "$staged" '^com/codename1/generated/android/AndroidAppImpl\.class$'
+  assert_zip_has "$staged" '^com/codename1/androidcompat/android/app/Activity\.class$'
+  assert_zip_has "$staged" '^com/codename1/desktopcompat/javax/swing/JFrame\.class$'
+  assert_zip_has "$staged" '^com/example/gallery/GalleryApp\.class$'
+  bad=$(compat_unrelocated "$staged" "$TOOLKITS|android|androidx|com/google/android/material")
+  if [ -n "$bad" ]; then
+    echo "FAIL: both: classes still name a toolkit of either layer:"
+    echo "$bad" | head -20
+    FAILED=1
+  fi
+  echo "   the Android application starts, both runtimes ship relocated"
+  desktop_shipped_size "ios-device (both layers)" "$staged"
+fi
+
+[ $FAILED -eq 0 ] || exit 1
+echo "desktop-compat-test: OK"
diff --git a/maven/integration-tests/inc/compat.sh b/maven/integration-tests/inc/compat.sh
new file mode 100644
index 00000000000..0086d2fbbc7
--- /dev/null
+++ b/maven/integration-tests/inc/compat.sh
@@ -0,0 +1,127 @@
+# What the compatibility-layer tests (android-compat-test.sh,
+# desktop-compat-test.sh) share: generating the application a sample is
+# imported into, finding classes a relocation missed, and staging every
+# target's upload jar with Maven and with Gradle to compare them.
+#
+# Source inc/env.sh and inc/gradle.sh first; this file uses mvn_local,
+# run_gradle, fail and GRADLE_JDK from them. A script sets FAILED=0 before its
+# loop and exits by it afterwards: the functions here set it to 1 for a failure
+# worth reporting alongside the others, and call fail for one that leaves
+# nothing further to check.
+
+# The classpath of the build engine's class checker: the engine's own jar and
+# the two ASM jars it reads classes with, at the version the reactor pins. All
+# three are in the local repository once the reactor is installed.
+compat_checker_classpath() {
+  local pom="$SCRIPTPATH/../pom.xml" asm
+  asm=$(sed -n '/<artifactId>asm-commons<\/artifactId>/{n;s/.*<version>\(.*\)<\/version>.*/\1/p;}' "$pom" | head -1)
+  [ -n "$asm" ] || fail "could not read the ASM version from $pom"
+  local engine="$CN1_REPO/com/codenameone/codenameone-build-engine/$CN1_VERSION/codenameone-build-engine-$CN1_VERSION.jar"
+  local core="$CN1_REPO/org/ow2/asm/asm/$asm/asm-$asm.jar"
+  local commons="$CN1_REPO/org/ow2/asm/asm-commons/$asm/asm-commons-$asm.jar"
+  local jar
+  for jar in "$engine" "$core" "$commons"; do
+    [ -f "$jar" ] || fail "the class checker needs $jar; install the reactor first"
+  done
+  echo "$engine:$core:$commons"
+}
+
+# compat_unrelocated <classes dir or jar> <packages>
+#
+# Class files that still refer to a TYPE under one of <packages>, an ERE
+# alternation of slash-separated package names without the trailing slash
+# ("android|androidx"), one per line with the types named.
+#
+# Asked of com.codename1.maven.UnrelocatedTypes, which reads each class as the
+# relocation does: supertypes, descriptors, signatures, instruction operands.
+# A search of the bytes is not good enough -- an application may hold the text
+# "javax/swing/JTable" in a string, and the relocation rightly leaves it.
+compat_unrelocated() {
+  local dir="$1" packages="$2" cp status=0
+  cp=$(compat_checker_classpath) || exit 1
+  # Word splitting turns the alternation into the checker's arguments.
+  local IFS='|'
+  # shellcheck disable=SC2086
+  "$GRADLE_JDK/bin/java" -cp "$cp" com.codename1.maven.UnrelocatedTypes "$dir" $packages || status=$?
+  # 1 is "found some", and they are on stdout; anything above is a failure of
+  # the check itself, which must not read as a clean directory.
+  [ $status -le 1 ] || fail "the class checker failed on $dir (status $status)"
+}
+
+# The jar a build run with codename1.stageOnly=true reported in <log>.
+compat_staged_jar() {
+  sed -n 's/.*codename1.stageOnly is set: staged \(.*\) ([0-9]* bytes) for .*/\1/p' "$1" | tail -1
+}
+
+# Bookkeeping, never read from the upload: directory entries and Maven's pom
+# metadata and manifest (as gradle-maven-parity-test.sh); Kotlin's module file,
+# which each tool names after its own project (app-common, DroidApp) and only
+# Kotlin reflection reads; and the ORM enhancer's per-directory list, which
+# Gradle keeps in each of its classes directories and the enhancer only ever
+# reads from the directory.
+COMPAT_IGNORED='/$|^META-INF/maven/|^META-INF/MANIFEST\.MF$|^META-INF/[^/]*\.kotlin_module$|^META-INF/cn1/orm-enhanced-dependencies\.list$'
+
+# compat_generate_app <label> <work dir> <package> <main class name>
+#
+# Generates the archetype application as <work dir>/app.
+compat_generate_app() {
+  local label="$1" work="$2" pkg="$3" main="$4"
+  (cd "$work" && mvn_local archetype:generate -DarchetypeArtifactId=cn1app-archetype -DarchetypeGroupId=com.codenameone \
+    -DarchetypeVersion="$CN1_VERSION" -DartifactId=app -DgroupId=$pkg -Dpackage=$pkg \
+    -Dversion=1.0-SNAPSHOT -DmainName=$main -DjavaVersion=17 -DinteractiveMode=false) > "$work/archetype.log" 2>&1 \
+    || { tail -40 "$work/archetype.log"; fail "$label: archetype:generate"; }
+}
+
+# compat_build_common <label> <work dir> <maven app dir>
+#
+# Builds the common module, leaving its classes in common/target/classes.
+compat_build_common() {
+  local label="$1" work="$2" mapp="$3"
+  (cd "$mapp" && JAVA_HOME="$GRADLE_JDK" mvn_local install -DskipTests -pl common -am) > "$work/mvn-common.log" 2>&1 \
+    || { tail -60 "$work/mvn-common.log"; fail "$label: Maven build"; }
+}
+
+# compat_convert_to_gradle <label> <work dir> <maven app dir>
+#
+# Converts the application; the Gradle project is <work dir>/app-gradle, built
+# with the plugin from this checkout.
+compat_convert_to_gradle() {
+  local label="$1" work="$2" mapp="$3"
+  (cd "$mapp" && mvn_local "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:convert-to-gradle") > "$work/convert.log" 2>&1 \
+    || { cat "$work/convert.log"; fail "$label: convert-to-gradle"; }
+  use_local_plugin "$work/app-gradle"
+}
+
+# compat_stage_all <label> <work dir> <maven app dir> <gradle app dir> <check>
+#
+# Stages the upload jar of every target (never sent) with both tools, calls
+# <check> <jar> on each of the two jars, and compares their entry lists.
+compat_stage_all() {
+  local label="$1" work="$2" mapp="$3" gapp="$4" check="$5"
+  local spec platform target task mlog glog mjar gjar jar
+  for spec in "android android-device buildAndroid" "ios ios-device buildIos" "javascript javascript buildJavascript" \
+              "javase mac-os-x-desktop buildMacDesktop"; do
+    read -r platform target task <<< "$spec"
+    mlog="$work/maven-$target.log"
+    glog="$work/gradle-$target.log"
+    (cd "$mapp" && JAVA_HOME="$GRADLE_JDK" mvn_local package -DskipTests -Dopen=false -Dcodename1.platform=$platform \
+        -Dcodename1.buildTarget=$target -Dcodename1.stageOnly=true < /dev/null) > "$mlog" 2>&1 \
+      || { tail -40 "$mlog"; fail "$label: Maven staging $target"; }
+    run_gradle "$gapp" "$task" -Pcodename1.stageOnly=true > "$glog" 2>&1 || { tail -60 "$glog"; fail "$label: Gradle staging $target"; }
+    mjar=$(compat_staged_jar "$mlog")
+    gjar=$(compat_staged_jar "$glog")
+    [ -f "$mjar" ] && [ -f "$gjar" ] || fail "$label: $target: a staged jar is missing (maven=$mjar gradle=$gjar)"
+    for jar in "$mjar" "$gjar"; do
+      "$check" "$jar"
+    done
+    unzip -Z1 "$mjar" | grep -Ev "$COMPAT_IGNORED" | sort > "$work/maven-$target.txt"
+    unzip -Z1 "$gjar" | grep -Ev "$COMPAT_IGNORED" | sort > "$work/gradle-$target.txt"
+    if diff "$work/maven-$target.txt" "$work/gradle-$target.txt" > "$work/diff-$target.txt"; then
+      echo "   $target: $(wc -l < "$work/maven-$target.txt" | tr -d ' ') entries, Maven and Gradle identical"
+    else
+      echo "FAIL: $label: $target uploads differ (< Maven only, > Gradle only):"
+      head -40 "$work/diff-$target.txt"
+      FAILED=1
+    fi
+  done
+}
diff --git a/maven/javafx-compat/pom.xml b/maven/javafx-compat/pom.xml
new file mode 100644
index 00000000000..9ac1c2825e3
--- /dev/null
+++ b/maven/javafx-compat/pom.xml
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+
+    <parent>
+        <groupId>com.codenameone</groupId>
+        <artifactId>codenameone</artifactId>
+        <version>8.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>codenameone-javafx-compat</artifactId>
+    <version>8.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>codenameone-javafx-compat</name>
+    <description>
+        A subset of the javafx.* API implemented on top of Codename
+        One components. An application compiles against this jar under
+        the real names, and the remap step of the build plugins
+        relocates both to com.codename1.fxcompat.*.
+    </description>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>com.github.spotbugs</groupId>
+                <artifactId>spotbugs-maven-plugin</artifactId>
+                <version>4.7.3.4</version>
+                <configuration>
+                    <effort>Max</effort>
+                    <threshold>Low</threshold>
+                    <failOnError>false</failOnError>
+                    <xmlOutput>true</xmlOutput>
+                    <xmlOutputDirectory>${project.build.directory}</xmlOutputDirectory>
+                    <excludeFilterFile>${project.basedir}/spotbugs-exclude.xml</excludeFilterFile>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>spotbugs</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>spotbugs</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <profiles>
+        <!-- Some JDK 8 distributions bundle JavaFX as an extension
+             (jre/lib/ext/jfxrt.jar), and an extension is found before the
+             class path. The main sources still compile there, because they
+             ARE the javafx classes, but the tests then meet the JDK's
+             javafx.scene.control.Control in place of this module's, at
+             compile time and again when they run. The extension directory
+             is pointed at nothing; the option does not exist after JDK 8,
+             where JavaFX is not part of the JDK either. -->
+        <profile>
+            <id>jdk8-without-bundled-javafx</id>
+            <activation>
+                <jdk>1.8</jdk>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <artifactId>maven-compiler-plugin</artifactId>
+                        <configuration>
+                            <compilerArgs>
+                                <arg>-extdirs</arg>
+                                <arg>${project.build.directory}/no-jdk-extensions</arg>
+                            </compilerArgs>
+                        </configuration>
+                    </plugin>
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <configuration>
+                            <argLine>-Djava.ext.dirs=${project.build.directory}/no-jdk-extensions</argLine>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- ApiNamingTest reads the compiled classes to hold the cn1 hook
+             list to what is really declared. -->
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- The headless Codename One implementation the tests run on. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-compat-testing</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/maven/javafx-compat/spotbugs-exclude.xml b/maven/javafx-compat/spotbugs-exclude.xml
new file mode 100644
index 00000000000..41e9a54d45d
--- /dev/null
+++ b/maven/javafx-compat/spotbugs-exclude.xml
@@ -0,0 +1,275 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Intentional SpotBugs exceptions for this module. The report is a
+     zero-findings gate, so every entry is scoped and explained. -->
+<FindBugsFilter>
+    <!--
+        Observable values and collections are shared by reference; that is the
+        API. A property keeps the very observable it is bound to, a list
+        property holds the list it was given, a change report names the
+        collection that changed, a transformation list answers getSource()
+        with its source, and a read-only wrapper hands out the one view it
+        keeps. Copying any of them would break the binding.
+    -->
+    <Match>
+        <Or>
+            <Class name="~javafx\.beans\.property\.[A-Za-z]+PropertyBase"/>
+            <Class name="~javafx\.beans\.property\.ReadOnly[A-Za-z]+Wrapper"/>
+            <Class name="~javafx\.collections\.(List|Map|Set)ChangeListener\$Change"/>
+            <Class name="~javafx\.collections\.transformation\.(TransformationList|FilteredList|SortedList)"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!--
+        The wrappers FXCollections hands out exist to wrap the collection they
+        are given (observableList(list) writes through by contract), the
+        unmodifiable views watch their source, and the change builder reports
+        on the list that owns it. The map wrapper returns its cached entry
+        view the way java.util maps do.
+    -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.fxcompat.runtime.ArrayObservableList"/>
+            <Class name="com.codename1.fxcompat.runtime.ConstantObservableList"/>
+            <Class name="com.codename1.fxcompat.runtime.ListChangeBuilder"/>
+            <Class name="com.codename1.fxcompat.runtime.ObservableMapWrapper"/>
+            <Class name="com.codename1.fxcompat.runtime.ObservableSetWrapper"/>
+            <Class name="~com\.codename1\.fxcompat\.runtime\.UnmodifiableViews\$Of(List|Map|Set)"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!--
+        The listener lists are copy on write: a list is never modified after
+        it was stored, which is what lets a listener add or remove listeners
+        while it is being notified. Handing the current list to the code that
+        fires is therefore safe, and copying it would allocate on every event.
+    -->
+    <Match>
+        <Class name="com.codename1.fxcompat.runtime.ListenerSet"/>
+        <Method name="changeListeners"/>
+        <Bug pattern="MS_EXPOSE_REP"/>
+    </Match>
+
+    <!--
+        A listener set has only static operations because the set is created
+        on the first listener and dropped (null) with the last one, so an
+        observable nobody listens to carries no object. It still holds state,
+        the two lists, so instantiating it is intended.
+    -->
+    <Match>
+        <Class name="com.codename1.fxcompat.runtime.ListenerSet"/>
+        <Or>
+            <Method name="addInvalidation"/>
+            <Method name="addChange"/>
+        </Or>
+        <Bug pattern="ISC_INSTANTIATE_STATIC_CLASS"/>
+    </Match>
+
+    <!--
+        The bound observable is null until bind() is called, by design, and
+        boundValue() is only reached behind an observable != null check in
+        get() and unbind().
+    -->
+    <Match>
+        <Class name="~javafx\.beans\.property\.(Boolean|Integer|Long|Float|Double|String|Object)PropertyBase"/>
+        <Method name="boundValue"/>
+        <Bug pattern="UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!--
+        set() skips the notification when the new value is the same number, as
+        JavaFX does. Exact comparison is the point: a tolerance would swallow
+        real changes, and NaN deliberately counts as a change every time.
+    -->
+    <Match>
+        <Or>
+            <Class name="javafx.beans.property.DoublePropertyBase"/>
+            <Class name="javafx.beans.property.FloatPropertyBase"/>
+        </Or>
+        <Method name="set"/>
+        <Bug pattern="FE_FLOATING_POINT_EQUALITY"/>
+    </Match>
+
+    <!--
+        StringConverter<Boolean>.fromString answers null for empty text in
+        JavaFX; the boxed return type and its null are the API contract.
+    -->
+    <Match>
+        <Class name="javafx.util.converter.BooleanStringConverter"/>
+        <Method name="fromString"/>
+        <Bug pattern="NP_BOOLEAN_RETURN_NULL"/>
+    </Match>
+
+    <!--
+        Event.target is transient in JavaFX and a deserialized event has no
+        target there either. Nothing on a device serializes events; the class
+        is Serializable only because java.util.EventObject is.
+    -->
+    <Match>
+        <Class name="javafx.event.Event"/>
+        <Field name="target"/>
+        <Bug pattern="SE_TRANSIENT_FIELD_NOT_RESTORED"/>
+    </Match>
+
+    <!--
+        The same holds for the input and window events: the pick result, the
+        node a gesture started on and the like are transient because they
+        name live scene graph objects, which are not serializable in JavaFX
+        either.
+    -->
+    <Match>
+        <Or>
+            <Class name="~javafx\.scene\.input\.[A-Za-z]+Event"/>
+            <Class name="javafx.stage.WindowEvent"/>
+            <!-- The cell an edit event is about, and the value it ended with. -->
+            <Class name="javafx.scene.control.TableColumn$CellEditEvent"/>
+            <!-- The item a tree event is about; transient in JavaFX too. -->
+            <Class name="javafx.scene.control.TreeItem$TreeModificationEvent"/>
+        </Or>
+        <Bug pattern="SE_TRANSIENT_FIELD_NOT_RESTORED"/>
+    </Match>
+
+    <!--
+        A scene graph is shared by reference; that is the API. A node hands
+        out its properties, its children, its style classes, its scene and
+        its peer, a control hands out its items and its selection model, an
+        event names the node it happened on, and a peer or a renderer keeps
+        the node or the graphics it was made for. A defensive copy of any of
+        them would detach the caller from the live object it asked for.
+    -->
+    <Match>
+        <Or>
+            <Class name="~javafx\.(scene|stage|animation|concurrent|application)\..*"/>
+            <Class name="~com\.codename1\.fxcompat\.runtime\..*"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!--
+        Window.getWindows() answers one unmodifiable view of the showing
+        windows, as JavaFX does; callers listen to it for windows opening
+        and closing, so it has to be the same object every time.
+    -->
+    <Match>
+        <Class name="javafx.stage.Window"/>
+        <Method name="getWindows"/>
+        <Bug pattern="MS_EXPOSE_REP"/>
+    </Match>
+
+    <!--
+        null is the documented answer here and means something an empty
+        array could not: no matrix (identity, so nothing is installed), no
+        bounds (an empty path has none, not a box at the origin) and no dash
+        pattern (a solid stroke).
+    -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="javafx.scene.Node"/>
+                <Method name="cn1PaintMatrix"/>
+            </And>
+            <And>
+                <Class name="com.codename1.fxcompat.runtime.FxPath"/>
+                <Method name="bounds"/>
+            </And>
+            <And>
+                <Class name="javafx.scene.layout.Region"/>
+                <Method name="dashes"/>
+            </And>
+        </Or>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+    <!--
+        JavaFX declares GridPane.isFillWidth(Node) and isFillHeight(Node) as
+        returning Boolean, and null is the documented answer for a child that
+        has no such constraint: the pane then asks the row or column. The
+        signature and the three states are the API.
+    -->
+    <Match>
+        <Class name="javafx.scene.layout.GridPane"/>
+        <Or>
+            <Method name="isFillWidth"/>
+            <Method name="isFillHeight"/>
+        </Or>
+        <Bug pattern="NP_BOOLEAN_RETURN_NULL"/>
+    </Match>
+
+    <!--
+        The value parser answers null for a list of gradient stops it could
+        not read, with the reason in error(); an empty array would be a
+        gradient without stops, which is a different thing.
+    -->
+    <Match>
+        <Class name="com.codename1.fxcompat.runtime.css.CssValueParser"/>
+        <Method name="stops"/>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+
+    <!--
+        The default style engine, the FXML registry and the property registry
+        are created on first use, on the JavaFX application thread like every call of the layer:
+        Codename One is single threaded, and a lock or a volatile here would
+        be the only ones in the runtime.
+    -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.fxcompat.runtime.StyleEngine"/>
+                <Method name="getInstance"/>
+            </And>
+            <And>
+                <Class name="com.codename1.fxcompat.runtime.FxmlDispatch"/>
+                <Method name="current"/>
+            </And>
+            <And>
+                <Class name="com.codename1.fxcompat.runtime.PropertyAccess"/>
+                <Method name="current"/>
+            </And>
+        </Or>
+        <Bug pattern="LI_LAZY_INIT_STATIC"/>
+    </Match>
+
+    <!--
+        FXMLLoader's resources and namespace are the caller's objects by
+        contract: JavaFX hands back the bundle it was given, and the
+        namespace is the live map an application reads fx:id values from
+        and may add to before load().
+    -->
+    <Match>
+        <Class name="javafx.fxml.FXMLLoader"/>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+    <!--
+        These constructors register listeners whose bodies call methods
+        JavaFX declares overridable: Spinner.increment(), ComboBoxBase.show()
+        and hide(), TreeItem.isLeaf() (overridden by every lazily loaded
+        tree), TreeView.refresh(), Parent.requestLayout(). The listener runs
+        on a click or a change, long after construction, and an application
+        override must be the method that runs, so the call is not replaced
+        by a private copy. No constructor here calls one of them itself.
+    -->
+    <Match>
+        <Or>
+            <Class name="javafx.scene.control.ColorPicker"/>
+            <Class name="javafx.scene.control.Spinner"/>
+            <Class name="javafx.scene.control.TreeCell"/>
+            <Class name="javafx.scene.control.TreeItem"/>
+            <Class name="javafx.scene.control.TreeView"/>
+        </Or>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+</FindBugsFilter>
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/FxInterop.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/FxInterop.java
new file mode 100644
index 00000000000..8b65d81d97d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/FxInterop.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import com.codename1.fxcompat.runtime.SceneEmbed;
+import com.codename1.fxcompat.runtime.StageHosts;
+import com.codename1.ui.Component;
+
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+
+/// JavaFX inside a Codename One application: the calls that turn a scene
+/// graph into a Codename One component.
+///
+/// ```java
+/// // in src/main/desktop/java
+/// public class ChartPane {
+///     public static com.codename1.ui.Component create() {
+///         VBox box = new VBox(8, new Label("Sales"), new TableView<Row>(rows));
+///         return FxInterop.asComponent(box);
+///     }
+/// }
+///
+/// // anywhere in the Codename One application
+/// form.add(BorderLayout.CENTER, ChartPane.create());
+/// ```
+///
+/// Windows need nothing from this class. `new Stage().show()` shows the
+/// stage as a form over the current one, with a back command; closing it
+/// returns to the form it was shown over, and an `Alert` or a modal stage
+/// floats over whatever form is showing, `showAndWait` blocking its caller
+/// as on a desktop. In an application with a main class of its own,
+/// `Platform.exit()` and the last stage closing leave the application
+/// running.
+public final class FxInterop {
+
+    private FxInterop() {
+    }
+
+    /// Answers a Codename One component that shows a scene graph, laid out
+    /// to the size the answered component is given, painted with it, and
+    /// receiving the pointer input that falls on it. Its preferred size is
+    /// the root's, scaled to the display.
+    ///
+    /// The argument is a `javafx.scene.Parent` or a `javafx.scene.Scene`.
+    /// A root that is the root of a scene already is shown with that scene,
+    /// its style sheets included; any other is given a scene of its own.
+    /// Pass a scene to give it style sheets or a fill; one that a stage is
+    /// showing leaves that stage. Call this on the event dispatch thread,
+    /// which is the JavaFX application thread.
+    ///
+    /// The parameter is declared as `Object` because the build relocates
+    /// the JavaFX classes an application names: the application is compiled
+    /// against `javafx.scene.Parent`, and what reaches this method on a
+    /// device is the relocated class. Anything that is neither a parent nor
+    /// a scene is refused with an `IllegalArgumentException`.
+    ///
+    /// #### Parameters
+    ///
+    /// - `sceneOrRoot`: the `Scene` to show, or the `Parent` at the root of
+    ///   the scene graph to show
+    ///
+    /// #### Returns
+    ///
+    /// the Codename One component that shows it
+    public static Component asComponent(Object sceneOrRoot) {
+        // Library mode has no lifecycle to install the application's
+        // resources, bundles and services first; the first desktop
+        // component it wraps or window it shows does. Idempotent.
+        com.codename1.generated.compat.CompatRegistry.cn1Install();
+        Scene scene;
+        if (sceneOrRoot instanceof Scene) {
+            scene = (Scene) sceneOrRoot;
+        } else if (sceneOrRoot instanceof Parent) {
+            Parent root = (Parent) sceneOrRoot;
+            scene = root.getScene();
+            if (scene == null || scene.getRoot() != root) {
+                scene = new Scene(root);
+            }
+        } else {
+            throw new IllegalArgumentException("asComponent takes a javafx.scene.Parent or a javafx.scene.Scene, not "
+                    + (sceneOrRoot == null ? "null" : sceneOrRoot.getClass().getName()));
+        }
+        Stage stage = new Stage();
+        SceneEmbed embed = new SceneEmbed(stage);
+        stage.setScene(scene);
+        stage.cn1Embed(embed);
+        return embed;
+    }
+
+    /// Says whether stages other than the primary one open as windows of
+    /// the platform's window manager where it has one, which is the
+    /// default. With `false` every stage stays inside the application's
+    /// own window: a modal stage or an `Alert` is a dialog over the current
+    /// form and any other stage a form, as on a phone.
+    ///
+    /// #### Parameters
+    ///
+    /// - `nativeWindows`: `false` to keep every stage inside the
+    ///   application's window
+    public static void setNativeWindows(boolean nativeWindows) {
+        StageHosts.setNativeWindows(nativeWindows);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/package-info.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/package-info.java
new file mode 100644
index 00000000000..6697acadb30
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// What a Codename One application calls to use JavaFX screens of its own:
+/// [com.codename1.fxcompat.FxInterop].
+///
+/// The JavaFX layer itself is the `javafx` packages, which applications
+/// name as they always did; its runtime is below this package.
+package com.codename1.fxcompat;
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ArrayObservableList.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ArrayObservableList.java
new file mode 100644
index 00000000000..6c75ee559f1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ArrayObservableList.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.RandomAccess;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.collections.ModifiableObservableListBase;
+import javafx.util.Callback;
+
+/// The observable list `FXCollections` hands out: a `java.util.List` whose
+/// modifications are reported, each bulk operation as one change and a sort
+/// as a permutation.
+///
+/// With an extractor the list also watches the observables the extractor
+/// names for each element and reports an update of the element when one of
+/// them turns invalid.
+public final class ArrayObservableList<E> extends ModifiableObservableListBase<E> implements RandomAccess {
+
+    private final List<E> backing;
+    private final Callback<E, Observable[]> extractor;
+    private final IdentityHashMap<E, Watched> watched;
+    private final InvalidationListener elementListener;
+
+    /// Wraps a list, optionally watching its elements.
+    public ArrayObservableList(List<E> backing, Callback<E, Observable[]> extractor) {
+        this.backing = backing;
+        this.extractor = extractor;
+        if (extractor == null) {
+            watched = null;
+            elementListener = null;
+        } else {
+            watched = new IdentityHashMap<E, Watched>();
+            elementListener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    elementInvalidated(observable);
+                }
+            };
+            for (int i = 0; i < backing.size(); i++) {
+                attach(backing.get(i));
+            }
+        }
+    }
+
+    private void elementInvalidated(Observable observable) {
+        beginChange();
+        try {
+            for (int i = 0; i < backing.size(); i++) {
+                Watched entry = watched.get(backing.get(i));
+                if (entry != null && entry.has(observable)) {
+                    nextUpdate(i);
+                }
+            }
+        } finally {
+            endChange();
+        }
+    }
+
+    private void attach(E element) {
+        if (extractor == null || element == null) {
+            return;
+        }
+        Watched entry = watched.get(element);
+        if (entry == null) {
+            Observable[] observables = extractor.call(element);
+            entry = new Watched(observables == null ? new Observable[0] : observables.clone());
+            watched.put(element, entry);
+            for (Observable observable : entry.observables) {
+                observable.addListener(elementListener);
+            }
+        }
+        entry.count++;
+    }
+
+    private void detach(E element) {
+        if (extractor == null || element == null) {
+            return;
+        }
+        Watched entry = watched.get(element);
+        if (entry != null && --entry.count == 0) {
+            watched.remove(element);
+            for (Observable observable : entry.observables) {
+                observable.removeListener(elementListener);
+            }
+        }
+    }
+
+    @Override
+    public E get(int index) {
+        return backing.get(index);
+    }
+
+    @Override
+    public int size() {
+        return backing.size();
+    }
+
+    @Override
+    protected void doAdd(int index, E element) {
+        backing.add(index, element);
+        attach(element);
+    }
+
+    @Override
+    protected E doSet(int index, E element) {
+        E old = backing.set(index, element);
+        detach(old);
+        attach(element);
+        return old;
+    }
+
+    @Override
+    protected E doRemove(int index) {
+        E old = backing.remove(index);
+        detach(old);
+        return old;
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return backing.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return backing.lastIndexOf(o);
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return backing.contains(o);
+    }
+
+    @Override
+    public Object[] toArray() {
+        return backing.toArray();
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        return backing.toArray(a);
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        return addAll(backing.size(), c);
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends E> c) {
+        if (index < 0 || index > backing.size()) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        List<E> copy = new ArrayList<E>(c);
+        if (copy.isEmpty()) {
+            return false;
+        }
+        beginChange();
+        try {
+            backing.addAll(index, copy);
+            for (int i = 0; i < copy.size(); i++) {
+                attach(copy.get(i));
+            }
+            modCount++;
+            nextAdd(index, index + copy.size());
+        } finally {
+            endChange();
+        }
+        return true;
+    }
+
+    @Override
+    protected void removeRange(int fromIndex, int toIndex) {
+        if (fromIndex >= toIndex) {
+            return;
+        }
+        beginChange();
+        try {
+            List<E> range = backing.subList(fromIndex, toIndex);
+            List<E> removed = new ArrayList<E>(range);
+            range.clear();
+            for (int i = 0; i < removed.size(); i++) {
+                detach(removed.get(i));
+            }
+            modCount++;
+            nextRemove(fromIndex, removed);
+        } finally {
+            endChange();
+        }
+    }
+
+    /// Sorts the content and reports the reordering as a permutation. A
+    /// `null` comparator sorts into the natural order.
+    ///
+    /// #### Throws
+    ///
+    /// - `ClassCastException`: when there is no comparator and an element
+    ///   is not `Comparable`
+    @Override
+    @SuppressWarnings("unchecked")
+    public void sort(final Comparator<? super E> comparator) {
+        int count = backing.size();
+        if (count < 2) {
+            return;
+        }
+        final Object[] elements = backing.toArray();
+        Integer[] order = new Integer[count];
+        for (int i = 0; i < count; i++) {
+            order[i] = Integer.valueOf(i);
+        }
+        Arrays.sort(order, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer a, Integer b) {
+                Object first = elements[a.intValue()];
+                Object second = elements[b.intValue()];
+                if (comparator != null) {
+                    return comparator.compare((E) first, (E) second);
+                }
+                if (!(first instanceof Comparable)) {
+                    throw new ClassCastException("Element is not Comparable");
+                }
+                return ((Comparable<Object>) first).compareTo(second);
+            }
+        });
+        int[] perm = new int[count];
+        boolean moved = false;
+        for (int i = 0; i < count; i++) {
+            int old = order[i].intValue();
+            perm[old] = i;
+            moved |= old != i;
+        }
+        if (!moved) {
+            return;
+        }
+        beginChange();
+        try {
+            for (int i = 0; i < count; i++) {
+                backing.set(i, (E) elements[order[i].intValue()]);
+            }
+            modCount++;
+            nextPermutation(0, count, perm);
+        } finally {
+            endChange();
+        }
+    }
+
+    /// The observables watched on behalf of one element, and how often that
+    /// element is in the list.
+    private static final class Watched {
+        private final Observable[] observables;
+        private int count;
+
+        Watched(Observable[] observables) {
+            this.observables = observables;
+        }
+
+        boolean has(Observable observable) {
+            for (Observable candidate : observables) {
+                if (candidate == observable) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/BidirectionalBinding.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/BidirectionalBinding.java
new file mode 100644
index 00000000000..ee583a3b4de
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/BidirectionalBinding.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.lang.ref.WeakReference;
+import java.util.function.Function;
+
+import javafx.beans.WeakListener;
+import javafx.beans.property.Property;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+
+/// Keeps two properties equal: a change of either is written to the other,
+/// through a conversion when their types differ.
+///
+/// The binding is the change listener of both properties and holds both
+/// weakly, so neither property keeps the other alive; when one is collected
+/// the binding removes itself from the survivor. Two bindings of the same
+/// pair are equal whatever the order, which is how unbinding finds the
+/// listener to remove.
+public final class BidirectionalBinding<A, B> implements ChangeListener<Object>, WeakListener {
+
+    private final WeakReference first;
+    private final WeakReference second;
+    private final Function<? super B, ? extends A> toFirst;
+    private final Function<? super A, ? extends B> toSecond;
+    private final int hash;
+    private boolean updating;
+
+    private BidirectionalBinding(Object first, Object second, Function<? super B, ? extends A> toFirst,
+            Function<? super A, ? extends B> toSecond) {
+        this.first = new WeakReference(first);
+        this.second = new WeakReference(second);
+        this.toFirst = toFirst;
+        this.toSecond = toSecond;
+        this.hash = System.identityHashCode(first) * System.identityHashCode(second);
+    }
+
+    private static void check(Object first, Object second) {
+        if (first == null || second == null) {
+            throw new NullPointerException("Both properties must be specified.");
+        }
+        if (first == second) {
+            throw new IllegalArgumentException("Cannot bind property to itself");
+        }
+    }
+
+    /// Binds two properties of the same type; the first takes the value of
+    /// the second.
+    public static <T> void bind(Property<T> first, Property<T> second) {
+        bind(first, second, new Function<T, T>() {
+            @Override
+            public T apply(T value) {
+                return value;
+            }
+        }, new Function<T, T>() {
+            @Override
+            public T apply(T value) {
+                return value;
+            }
+        });
+    }
+
+    /// Binds two properties through a pair of conversions; the first takes
+    /// the converted value of the second.
+    @SuppressWarnings("unchecked")
+    public static <A, B> void bind(Property<A> first, Property<B> second, Function<? super B, ? extends A> toFirst,
+            Function<? super A, ? extends B> toSecond) {
+        check(first, second);
+        BidirectionalBinding<A, B> binding = new BidirectionalBinding<A, B>(first, second, toFirst, toSecond);
+        first.setValue(toFirst.apply(second.getValue()));
+        ((ObservableValue<Object>) first).addListener(binding);
+        ((ObservableValue<Object>) second).addListener(binding);
+    }
+
+    /// Removes the binding of two objects, when both are properties and one
+    /// exists.
+    @SuppressWarnings("unchecked")
+    public static void unbind(Object first, Object second) {
+        check(first, second);
+        if (first instanceof ObservableValue && second instanceof ObservableValue) {
+            BidirectionalBinding<Object, Object> probe = new BidirectionalBinding<Object, Object>(first, second, null,
+                    null);
+            ((ObservableValue<Object>) first).removeListener(probe);
+            ((ObservableValue<Object>) second).removeListener(probe);
+        }
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return first.get() == null || second.get() == null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void changed(ObservableValue<? extends Object> source, Object oldValue, Object newValue) {
+        if (updating) {
+            return;
+        }
+        Object a = first.get();
+        Object b = second.get();
+        if (!(a instanceof Property) || !(b instanceof Property)) {
+            if (a instanceof Property) {
+                ((Property<Object>) a).removeListener(this);
+            }
+            if (b instanceof Property) {
+                ((Property<Object>) b).removeListener(this);
+            }
+            return;
+        }
+        Property<A> one = (Property<A>) a;
+        Property<B> two = (Property<B>) b;
+        updating = true;
+        try {
+            if (one == source) {
+                two.setValue(toSecond.apply((A) newValue));
+            } else {
+                one.setValue(toFirst.apply((B) newValue));
+            }
+        } catch (RuntimeException failure) {
+            restore(one, two, source, oldValue);
+            throw new RuntimeException("Bidirectional binding failed, setting to the previous value", failure);
+        } finally {
+            updating = false;
+        }
+    }
+
+    /// Puts the changed property back to its old value and drops the binding,
+    /// so the two properties are not left disagreeing while bound.
+    @SuppressWarnings("unchecked")
+    private void restore(Property<A> one, Property<B> two, ObservableValue<?> source, Object oldValue) {
+        one.removeListener(this);
+        two.removeListener(this);
+        if (one == source) {
+            one.setValue((A) oldValue);
+        } else {
+            two.setValue((B) oldValue);
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof BidirectionalBinding)) {
+            return false;
+        }
+        Object a = first.get();
+        Object b = second.get();
+        if (a == null || b == null) {
+            return false;
+        }
+        BidirectionalBinding<?, ?> that = (BidirectionalBinding<?, ?>) other;
+        Object otherA = that.first.get();
+        Object otherB = that.second.get();
+        return (a == otherA && b == otherB) || (a == otherB && b == otherA);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/BindingObserver.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/BindingObserver.java
new file mode 100644
index 00000000000..2d33788e127
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/BindingObserver.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.lang.ref.WeakReference;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.binding.Binding;
+
+/// The listener a binding registers with its dependencies. It holds the
+/// binding weakly, so a binding nobody uses any more is collected although
+/// its dependencies still list this observer, which then removes itself.
+public final class BindingObserver implements InvalidationListener, WeakListener {
+
+    private final WeakReference ref;
+
+    /// Creates the observer of a binding.
+    public BindingObserver(Binding<?> binding) {
+        if (binding == null) {
+            throw new NullPointerException("Binding has to be specified.");
+        }
+        this.ref = new WeakReference(binding);
+    }
+
+    @Override
+    public void invalidated(Observable observable) {
+        Object binding = ref.get();
+        if (binding instanceof Binding) {
+            ((Binding<?>) binding).invalidate();
+        } else {
+            observable.removeListener(this);
+        }
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Changes.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Changes.java
new file mode 100644
index 00000000000..85cc2f3ddb7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Changes.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.List;
+
+import javafx.collections.ListChangeListener;
+import javafx.collections.MapChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.collections.SetChangeListener;
+
+/// The change reports of maps and sets, the report a view sends on behalf
+/// of its source, and the loops that deliver them.
+public final class Changes {
+
+    private static final int[] NO_PERMUTATION = new int[0];
+
+    private Changes() {
+    }
+
+    /// Tells the listeners of a map about a change.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static <K, V> void fire(ListenerSet<MapChangeListener<? super K, ? super V>> set, ObservableMap<K, V> map,
+            MapChangeListener.Change<K, V> change) {
+        ListenerSet.fireInvalidation(set, map);
+        List<MapChangeListener<? super K, ? super V>> targets = ListenerSet.changeListeners(set);
+        for (int i = 0; i < targets.size(); i++) {
+            ((MapChangeListener) targets.get(i)).onChanged(change);
+        }
+    }
+
+    /// Tells the listeners of a set about a change.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static <E> void fire(ListenerSet<SetChangeListener<? super E>> set, ObservableSet<E> observable,
+            SetChangeListener.Change<E> change) {
+        ListenerSet.fireInvalidation(set, observable);
+        List<SetChangeListener<? super E>> targets = ListenerSet.changeListeners(set);
+        for (int i = 0; i < targets.size(); i++) {
+            ((SetChangeListener) targets.get(i)).onChanged(change);
+        }
+    }
+
+    /// What happened to one key of a map.
+    public static final class OfMap<K, V> extends MapChangeListener.Change<K, V> {
+        private final K key;
+        private final V removed;
+        private final V added;
+        private final boolean wasAdded;
+        private final boolean wasRemoved;
+
+        /// Creates the report.
+        public OfMap(ObservableMap<K, V> map, K key, V removed, V added, boolean wasAdded, boolean wasRemoved) {
+            super(map);
+            this.key = key;
+            this.removed = removed;
+            this.added = added;
+            this.wasAdded = wasAdded;
+            this.wasRemoved = wasRemoved;
+        }
+
+        @Override
+        public boolean wasAdded() {
+            return wasAdded;
+        }
+
+        @Override
+        public boolean wasRemoved() {
+            return wasRemoved;
+        }
+
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValueAdded() {
+            return added;
+        }
+
+        @Override
+        public V getValueRemoved() {
+            return removed;
+        }
+
+        @Override
+        public String toString() {
+            if (wasAdded && wasRemoved) {
+                return removed + " replaced by " + added + " at key " + key;
+            }
+            return wasAdded ? added + " added at key " + key : removed + " removed at key " + key;
+        }
+    }
+
+    /// One element added to or removed from a set.
+    public static final class OfSet<E> extends SetChangeListener.Change<E> {
+        private final E element;
+        private final boolean added;
+
+        /// Creates the report.
+        public OfSet(ObservableSet<E> set, E element, boolean added) {
+            super(set);
+            this.element = element;
+            this.added = added;
+        }
+
+        @Override
+        public boolean wasAdded() {
+            return added;
+        }
+
+        @Override
+        public boolean wasRemoved() {
+            return !added;
+        }
+
+        @Override
+        public E getElementAdded() {
+            return added ? element : null;
+        }
+
+        @Override
+        public E getElementRemoved() {
+            return added ? null : element;
+        }
+
+        @Override
+        public String toString() {
+            return (added ? "added " : "removed ") + element;
+        }
+    }
+
+    /// The change of a source list, told again as a change of a view that
+    /// shows the same content at the same positions.
+    public static final class Relayed<E> extends ListChangeListener.Change<E> {
+        private final ListChangeListener.Change<? extends E> change;
+
+        /// Creates the report of a view from the report of its source.
+        public Relayed(ObservableList<E> list, ListChangeListener.Change<? extends E> change) {
+            super(list);
+            this.change = change;
+        }
+
+        @Override
+        public boolean next() {
+            return change.next();
+        }
+
+        @Override
+        public void reset() {
+            change.reset();
+        }
+
+        @Override
+        public int getFrom() {
+            return change.getFrom();
+        }
+
+        @Override
+        public int getTo() {
+            return change.getTo();
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public List<E> getRemoved() {
+            return (List<E>) change.getRemoved();
+        }
+
+        @Override
+        public boolean wasPermutated() {
+            return change.wasPermutated();
+        }
+
+        @Override
+        public boolean wasUpdated() {
+            return change.wasUpdated();
+        }
+
+        @Override
+        protected int[] getPermutation() {
+            if (!change.wasPermutated()) {
+                return NO_PERMUTATION;
+            }
+            int from = change.getFrom();
+            int[] result = new int[change.getTo() - from];
+            for (int i = 0; i < result.length; i++) {
+                result[i] = change.getPermutation(from + i);
+            }
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return change.toString();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ConstantObservableList.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ConstantObservableList.java
new file mode 100644
index 00000000000..db6cd7d3724
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ConstantObservableList.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.AbstractList;
+import java.util.Collection;
+import java.util.List;
+import java.util.RandomAccess;
+
+import javafx.beans.InvalidationListener;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// An observable list that cannot change. It refuses every modification
+/// and, having nothing to report, forgets its listeners.
+public final class ConstantObservableList<E> extends AbstractList<E> implements ObservableList<E>, RandomAccess {
+
+    private final List<E> content;
+
+    /// Creates a constant list over content nobody else will modify.
+    public ConstantObservableList(List<E> content) {
+        this.content = content;
+    }
+
+    @Override
+    public E get(int index) {
+        return content.get(index);
+    }
+
+    @Override
+    public int size() {
+        return content.size();
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+    }
+
+    @Override
+    public void addListener(ListChangeListener<? super E> listener) {
+    }
+
+    @Override
+    public void removeListener(ListChangeListener<? super E> listener) {
+    }
+
+    @Override
+    public boolean addAll(E... elements) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean setAll(E... elements) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean setAll(Collection<? extends E> col) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean removeAll(E... elements) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean retainAll(E... elements) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void remove(int from, int to) {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ContentBindings.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ContentBindings.java
new file mode 100644
index 00000000000..3c054d8adf6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ContentBindings.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javafx.beans.WeakListener;
+import javafx.collections.ListChangeListener;
+import javafx.collections.MapChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.collections.SetChangeListener;
+
+/// The bindings that make one collection mirror another.
+///
+/// A binding is a change listener of the observed collection that replays
+/// each change on the mirror, which it holds weakly: a mirror nobody uses is
+/// collected, and its binding then removes itself. Bindings of the same
+/// mirror are equal, which is how unbinding finds the listener to remove.
+public final class ContentBindings {
+
+    private ContentBindings() {
+    }
+
+    private static void check(Object first, Object second) {
+        if (first == null || second == null) {
+            throw new NullPointerException("Both parameters must be specified.");
+        }
+        if (first == second) {
+            throw new IllegalArgumentException("Cannot bind object to itself");
+        }
+    }
+
+    /// Replays a list change on another list holding the same content.
+    static <E> void replay(ListChangeListener.Change<? extends E> change, List<E> target) {
+        while (change.next()) {
+            int from = change.getFrom();
+            int to = change.getTo();
+            if (change.wasPermutated()) {
+                target.subList(from, to).clear();
+                target.addAll(from, new ArrayList<E>(change.getList().subList(from, to)));
+            } else {
+                if (change.wasRemoved()) {
+                    target.subList(from, from + change.getRemovedSize()).clear();
+                }
+                if (change.wasAdded()) {
+                    target.addAll(from, new ArrayList<E>(change.getAddedSubList()));
+                }
+            }
+        }
+    }
+
+    /// Makes a list mirror an observable list.
+    public static <E> void bind(List<E> list1, ObservableList<? extends E> list2) {
+        check(list1, list2);
+        ListContent<E> binding = new ListContent<E>(list1);
+        if (list1 instanceof ObservableList) {
+            ((ObservableList<E>) list1).setAll(list2);
+        } else {
+            list1.clear();
+            list1.addAll(list2);
+        }
+        list2.removeListener(binding);
+        list2.addListener(binding);
+    }
+
+    /// Makes a set mirror an observable set.
+    public static <E> void bind(Set<E> set1, ObservableSet<? extends E> set2) {
+        check(set1, set2);
+        SetContent<E> binding = new SetContent<E>(set1);
+        set1.clear();
+        set1.addAll(set2);
+        set2.removeListener(binding);
+        set2.addListener(binding);
+    }
+
+    /// Makes a map mirror an observable map.
+    public static <K, V> void bind(Map<K, V> map1, ObservableMap<? extends K, ? extends V> map2) {
+        check(map1, map2);
+        MapContent<K, V> binding = new MapContent<K, V>(map1);
+        map1.clear();
+        map1.putAll(map2);
+        map2.removeListener(binding);
+        map2.addListener(binding);
+    }
+
+    /// Removes the binding that makes the first object mirror the second.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static void unbind(Object obj1, Object obj2) {
+        check(obj1, obj2);
+        if (obj1 instanceof List && obj2 instanceof ObservableList) {
+            ((ObservableList) obj2).removeListener(new ListContent((List) obj1));
+        } else if (obj1 instanceof Set && obj2 instanceof ObservableSet) {
+            ((ObservableSet) obj2).removeListener(new SetContent((Set) obj1));
+        } else if (obj1 instanceof Map && obj2 instanceof ObservableMap) {
+            ((ObservableMap) obj2).removeListener(new MapContent((Map) obj1));
+        }
+    }
+
+    /// Keeps two observable lists equal, starting with the content of the
+    /// second.
+    public static <E> void bindBidirectional(ObservableList<E> list1, ObservableList<E> list2) {
+        check(list1, list2);
+        BothLists<E> binding = new BothLists<E>(list1, list2);
+        list1.setAll(list2);
+        list1.addListener(binding);
+        list2.addListener(binding);
+    }
+
+    /// Removes the binding that keeps two objects equal.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static void unbindBidirectional(Object obj1, Object obj2) {
+        check(obj1, obj2);
+        if (obj1 instanceof ObservableList && obj2 instanceof ObservableList) {
+            BothLists probe = new BothLists((ObservableList) obj1, (ObservableList) obj2);
+            ((ObservableList) obj1).removeListener(probe);
+            ((ObservableList) obj2).removeListener(probe);
+        }
+    }
+
+    /// Mirrors an observable list into a list.
+    private static final class ListContent<E> implements ListChangeListener<E>, WeakListener {
+        private final WeakReference ref;
+
+        ListContent(List<E> target) {
+            this.ref = new WeakReference(target);
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onChanged(Change<? extends E> change) {
+            Object target = ref.get();
+            if (target instanceof List) {
+                replay(change, (List<E>) target);
+            } else {
+                change.getList().removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+
+        @Override
+        public int hashCode() {
+            Object target = ref.get();
+            return target == null ? 0 : System.identityHashCode(target);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            if (this == other) {
+                return true;
+            }
+            Object target = ref.get();
+            return target != null && other instanceof ListContent && ((ListContent<?>) other).ref.get() == target;
+        }
+    }
+
+    /// Mirrors an observable set into a set.
+    private static final class SetContent<E> implements SetChangeListener<E>, WeakListener {
+        private final WeakReference ref;
+
+        SetContent(Set<E> target) {
+            this.ref = new WeakReference(target);
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onChanged(Change<? extends E> change) {
+            Object target = ref.get();
+            if (!(target instanceof Set)) {
+                change.getSet().removeListener(this);
+            } else if (change.wasRemoved()) {
+                ((Set<E>) target).remove(change.getElementRemoved());
+            } else {
+                ((Set<E>) target).add(change.getElementAdded());
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+
+        @Override
+        public int hashCode() {
+            Object target = ref.get();
+            return target == null ? 0 : System.identityHashCode(target);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            if (this == other) {
+                return true;
+            }
+            Object target = ref.get();
+            return target != null && other instanceof SetContent && ((SetContent<?>) other).ref.get() == target;
+        }
+    }
+
+    /// Mirrors an observable map into a map.
+    private static final class MapContent<K, V> implements MapChangeListener<K, V>, WeakListener {
+        private final WeakReference ref;
+
+        MapContent(Map<K, V> target) {
+            this.ref = new WeakReference(target);
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onChanged(Change<? extends K, ? extends V> change) {
+            Object target = ref.get();
+            if (!(target instanceof Map)) {
+                change.getMap().removeListener(this);
+            } else if (change.wasAdded()) {
+                ((Map<K, V>) target).put(change.getKey(), change.getValueAdded());
+            } else {
+                ((Map<K, V>) target).remove(change.getKey());
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+
+        @Override
+        public int hashCode() {
+            Object target = ref.get();
+            return target == null ? 0 : System.identityHashCode(target);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            if (this == other) {
+                return true;
+            }
+            Object target = ref.get();
+            return target != null && other instanceof MapContent && ((MapContent<?, ?>) other).ref.get() == target;
+        }
+    }
+
+    /// Keeps two observable lists equal, replaying the changes of each on
+    /// the other and ignoring the echo.
+    private static final class BothLists<E> implements ListChangeListener<E>, WeakListener {
+        private final WeakReference first;
+        private final WeakReference second;
+        private final int hash;
+        private boolean updating;
+
+        BothLists(ObservableList<E> first, ObservableList<E> second) {
+            this.first = new WeakReference(first);
+            this.second = new WeakReference(second);
+            this.hash = System.identityHashCode(first) * System.identityHashCode(second);
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void onChanged(Change<? extends E> change) {
+            if (updating) {
+                return;
+            }
+            Object a = first.get();
+            Object b = second.get();
+            if (!(a instanceof ObservableList) || !(b instanceof ObservableList)) {
+                if (a instanceof ObservableList) {
+                    ((ObservableList<E>) a).removeListener(this);
+                }
+                if (b instanceof ObservableList) {
+                    ((ObservableList<E>) b).removeListener(this);
+                }
+                return;
+            }
+            updating = true;
+            try {
+                replay(change, a == change.getList() ? (ObservableList<E>) b : (ObservableList<E>) a);
+            } finally {
+                updating = false;
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return first.get() == null || second.get() == null;
+        }
+
+        @Override
+        public int hashCode() {
+            return hash;
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            if (this == other) {
+                return true;
+            }
+            if (!(other instanceof BothLists)) {
+                return false;
+            }
+            Object a = first.get();
+            Object b = second.get();
+            if (a == null || b == null) {
+                return false;
+            }
+            BothLists<?> that = (BothLists<?>) other;
+            Object otherA = that.first.get();
+            Object otherB = that.second.get();
+            return (a == otherA && b == otherB) || (a == otherB && b == otherA);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/CssEngine.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/CssEngine.java
new file mode 100644
index 00000000000..e4fdb21953e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/CssEngine.java
@@ -0,0 +1,1204 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.css.CssDeclaration;
+import com.codename1.fxcompat.runtime.css.CssDeclarations;
+import com.codename1.fxcompat.runtime.css.CssProperties;
+import com.codename1.fxcompat.runtime.css.CssSelector;
+import com.codename1.fxcompat.runtime.css.CssSheetData;
+import com.codename1.fxcompat.runtime.css.CssValue;
+import com.codename1.fxcompat.runtime.css.CssValueParser;
+import com.codename1.io.Log;
+
+import javafx.collections.ObservableList;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Cursor;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+import javafx.scene.effect.BlurType;
+import javafx.scene.effect.DropShadow;
+import javafx.scene.effect.Effect;
+import javafx.scene.effect.InnerShadow;
+import javafx.scene.text.Font;
+
+/// The style engine that is installed by default: it reads the compiled
+/// form of the style sheets a scene and its parents name, matches their
+/// rules against each node, and hands the winning values to
+/// [StyleTarget#cn1ApplyStyle(String, Object)].
+///
+/// #### Where a style sheet comes from
+///
+/// Nothing on a device parses a `.css` file. The build compiles every style
+/// sheet of the application into a table (`CssSheetData`) that ships at the
+/// root of the bundle, and a location in `getStylesheets()` is only a name
+/// for one of them: a `cn1res:` address names it by its path, and any other
+/// address -- the `file:` or `jar:` URL a desktop `getResource` answers --
+/// by the longest tail of its path that a table exists for. A location no
+/// table exists for is reported once and then ignored. The one thing parsed
+/// at run time is the inline `style` of a node, by the value parser the
+/// build uses.
+///
+/// #### The cascade
+///
+/// The style sheets of the scene come first, then those of each ancestor
+/// parent from the root down, then the node's own; an import comes before
+/// the sheet that imports it. Among the declarations of one property the
+/// winner is, in this order: an `!important` one, an inline one, the one
+/// with the more specific selector, the one from the later sheet, the one
+/// written later.
+///
+/// #### What a child inherits
+///
+/// Two things, as in JavaFX: the font -- `-fx-font` and the four names it
+/// is short for -- and the colours a rule defines under a name of its own
+/// (`-fx-base: #336699`) for other rules to use. An `em` length is relative
+/// to the font size styled this way, or to the default font's when none
+/// was.
+///
+/// #### Cost
+///
+/// A rule is indexed by what its rightmost compound requires, so a node
+/// tries only the rules that name its id, one of its classes or its type.
+/// The cascade runs in arrays the engine owns and reuses; a node keeps one
+/// small object between restyles, which holds what was applied so that an
+/// unchanged value is not applied again and a withdrawn one is restored.
+/// A node whose styles changed restyles its descendants only when a
+/// selector, the font or a colour definition below could tell the
+/// difference.
+///
+/// Like the scene graph, the engine belongs to the JavaFX application
+/// thread and keeps no lock.
+public final class CssEngine extends StyleEngine {
+
+    private static final long IMPORTANT = 1L << 62;
+    private static final long INLINE = 1L << 61;
+
+    private static final HashMap<String, Integer> PROPERTY_IDS = new HashMap<String, Integer>();
+    private static final ArrayList<String> PROPERTY_NAMES = new ArrayList<String>();
+    private static final HashSet<String> WARNED = new HashSet<String>();
+    private static final HashMap<String, Pos> POSITIONS = new HashMap<String, Pos>();
+
+    private static final int FONT = propertyId("-fx-font");
+    private static final int FONT_FAMILY = propertyId("-fx-font-family");
+    private static final int FONT_SIZE = propertyId("-fx-font-size");
+    private static final int FONT_WEIGHT = propertyId("-fx-font-weight");
+    private static final int FONT_STYLE = propertyId("-fx-font-style");
+
+    private static final Object MISSING = new Object();
+    private static final CssSheet.Decl[] NO_DECLS = new CssSheet.Decl[0];
+
+    static {
+        Pos[] all = Pos.values();
+        for (int i = 0; i < all.length; i++) {
+            POSITIONS.put(CssProperties.lower(all[i].name()).replace('_', '-'), all[i]);
+        }
+    }
+
+    /// What a node keeps between two restyles.
+    private static final class State {
+        /// The properties applied to the node and the value each was given.
+        int[] ids = new int[4];
+        Object[] values = new Object[4];
+        int count;
+        /// The font in force here, the node's own or inherited; `null` and
+        /// `NaN` for a part nothing styled.
+        String family;
+        double size = Double.NaN;
+        Object weight;
+        String posture;
+        /// The colours this node defines.
+        String[] lookupNames;
+        CssValue[] lookupValues;
+        /// Whether this node or one above it defines a colour.
+        boolean lookupsAbove;
+        /// What of this node a selector for a descendant could ask about.
+        long signature;
+        /// The inline style last parsed, and what it parsed to.
+        String inlineText = "";
+        CssSheet.Decl[] inline = NO_DECLS;
+
+        boolean inherits() {
+            return lookupsAbove || family != null || weight != null || posture != null || size == size;
+        }
+
+        int indexOf(int id) {
+            for (int i = 0; i < count; i++) {
+                if (ids[i] == id) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        void add(int id, Object value) {
+            if (count == ids.length) {
+                int[] i = new int[count * 2];
+                Object[] v = new Object[count * 2];
+                System.arraycopy(ids, 0, i, 0, count);
+                System.arraycopy(values, 0, v, 0, count);
+                ids = i;
+                values = v;
+            }
+            ids[count] = id;
+            values[count++] = value;
+        }
+
+        void remove(int index) {
+            count--;
+            ids[index] = ids[count];
+            values[index] = values[count];
+            values[count] = null;
+        }
+    }
+
+    private final HashMap<String, Object> sheets = new HashMap<String, Object>();
+    private final HashMap<Class<?>, String> typeNames = new HashMap<Class<?>, String>();
+    private final CssValueParser parser = new CssValueParser();
+    private final ArrayList<CssDeclaration> parsed = new ArrayList<CssDeclaration>();
+
+    // The cascade of the node being styled; reused for every node.
+    private final ArrayList<CssSheet> scope = new ArrayList<CssSheet>();
+    private final ArrayList<Parent> chain = new ArrayList<Parent>();
+    private CssSheet.Decl[] winner = new CssSheet.Decl[64];
+    private long[] priority = new long[64];
+    private int[] stamp = new int[64];
+    private Object[] wanted = new Object[64];
+    private int[] touched = new int[64];
+    private int touchedCount;
+    private int generation;
+    private boolean parentSheets;
+
+    private boolean busy;
+    private final ArrayList<Node> pending = new ArrayList<Node>();
+
+    /// Creates an engine with no style sheet read yet.
+    public CssEngine() {
+        // Sheets are read when a scene first names them.
+    }
+
+    /// The number the engine knows a property by; names are numbered as
+    /// they are first seen.
+    static int propertyId(String name) {
+        Integer id = PROPERTY_IDS.get(name);
+        if (id == null) {
+            id = Integer.valueOf(PROPERTY_NAMES.size());
+            PROPERTY_NAMES.add(name);
+            PROPERTY_IDS.put(name, id);
+        }
+        return id.intValue();
+    }
+
+    /// Logs a message the first time it is given, and never again: a style
+    /// sheet that is not there is asked for at every restyle.
+    static void warnOnce(String message) {
+        if (WARNED.add(message)) {
+            Log.p("[css] " + message);
+        }
+    }
+
+    /// Gives the engine the compiled form of the style sheet a location
+    /// names, in place of the table it would read from the bundle. For
+    /// tests and tools; `null` makes the engine forget the location.
+    public void define(String location, CssSheetData data) {
+        if (data == null) {
+            sheets.remove(location);
+        } else {
+            sheets.put(location, CssSheet.of(data));
+        }
+    }
+
+    // ------------------------------------------------------------- sheets
+
+    private CssSheet sheet(String location) {
+        if (location == null) {
+            return null;
+        }
+        Object known = sheets.get(location);
+        if (known == null) {
+            known = read(location);
+            sheets.put(location, known == null ? MISSING : known);
+            if (known == null) {
+                warnOnce("No compiled style sheet for " + location
+                        + "; style sheets are compiled by the build from the application's desktop resources");
+            }
+        }
+        return known instanceof CssSheet ? (CssSheet) known : null;
+    }
+
+    private static CssSheet read(String location) {
+        String path = location;
+        int bang = path.lastIndexOf("!/");
+        if (bang >= 0) {
+            path = path.substring(bang + 2);
+        } else {
+            int colon = path.indexOf(':');
+            int slash = path.indexOf('/');
+            if (colon > 0 && (slash < 0 || colon < slash)) {
+                path = path.substring(colon + 1);
+            }
+        }
+        int query = path.indexOf('?');
+        if (query >= 0) {
+            path = path.substring(0, query);
+        }
+        try {
+            // The whole path first, then each shorter tail of it: a desktop
+            // URL starts with directories the bundle knows nothing about.
+            while (true) {
+                int start = 0;
+                while (start < path.length() && path.charAt(start) == '/') {
+                    start++;
+                }
+                path = path.substring(start);
+                if (path.length() == 0) {
+                    return null;
+                }
+                CssSheet found = CssSheet.load(path);
+                if (found != null) {
+                    return found;
+                }
+                int next = path.indexOf('/');
+                if (next < 0) {
+                    return null;
+                }
+                path = path.substring(next);
+            }
+        } catch (IOException e) {
+            warnOnce("The compiled style sheet for " + location + " cannot be read: " + e.getMessage());
+            return null;
+        }
+    }
+
+    // ---------------------------------------------------------- the calls
+
+    @Override
+    public void stylesheetsChanged(Parent parent) {
+        parentSheets = true;
+        super.stylesheetsChanged(parent);
+    }
+
+    @Override
+    public void restyle(Node node) {
+        if (node == null) {
+            return;
+        }
+        if (busy) {
+            // Something a styled value set asked for another node; it waits
+            // for the cascade arrays to be free.
+            pending.add(node);
+            return;
+        }
+        process(node, false);
+        while (!pending.isEmpty()) {
+            Node next = pending.remove(pending.size() - 1);
+            if (next.getScene() != null) {
+                process(next, false);
+            }
+        }
+    }
+
+    private static State stateOf(Node node) {
+        Object s = node.cn1StyleState();
+        return s instanceof State ? (State) s : null;
+    }
+
+    private void process(Node node, boolean force) {
+        boolean deep = force;
+        busy = true;
+        try {
+            deep |= style(node);
+        } finally {
+            busy = false;
+        }
+        if (deep && node instanceof Parent) {
+            ObservableList<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                process(children.get(i), true);
+            }
+        }
+    }
+
+    /// Styles one node; answers whether its descendants could be styled
+    /// differently for it.
+    private boolean style(Node node) {
+        State state = stateOf(node);
+        Parent parent = node.getParent();
+        State above = parent == null ? null : stateOf(parent);
+        collectScope(node);
+        String inlineText = node.getStyle();
+        String defaults = node.cn1DefaultStyle();
+        boolean fresh = state == null;
+        if (fresh) {
+            if (scope.isEmpty() && inlineText.length() == 0 && defaults == null
+                    && (above == null || !above.inherits())) {
+                return false;
+            }
+            state = new State();
+            node.cn1SetStyleState(state);
+        }
+
+        // 1. The cascade.
+        generation++;
+        touchedCount = 0;
+        String id = node.getId();
+        String type = typeName(node);
+        ObservableList<String> classes = node.getStyleClass();
+        long signature = 0;
+        if (defaults != null) {
+            // Below every rule: a sheet's priority is never negative.
+            CssSheet.Decl[] own = defaultDecls(defaults);
+            for (int i = 0; i < own.length; i++) {
+                offer(own[i], -1);
+            }
+        }
+        for (int s = 0; s < scope.size(); s++) {
+            CssSheet sheet = scope.get(s);
+            if (id != null) {
+                consider(sheet.byId.get(id), node, s);
+                if (sheet.ancestorIds.contains(id)) {
+                    signature = signature * 31 + id.hashCode();
+                }
+            }
+            for (int c = 0; c < classes.size(); c++) {
+                String cls = classes.get(c);
+                consider(sheet.byClass.get(cls), node, s);
+                if (sheet.ancestorClasses.contains(cls)) {
+                    signature = signature * 31 + cls.hashCode();
+                }
+            }
+            consider(sheet.byType.get(type), node, s);
+            consider(sheet.universal, node, s);
+            for (int p = 0; p < sheet.ancestorPseudos.length; p++) {
+                if (node.cn1HasPseudoClass(sheet.ancestorPseudos[p])) {
+                    signature = signature * 31 + (p + 1) * 7919L + s;
+                }
+            }
+        }
+        scope.clear();
+        if (!inlineText.equals(state.inlineText)) {
+            state.inlineText = inlineText;
+            state.inline = parseInline(inlineText);
+        }
+        for (int i = 0; i < state.inline.length; i++) {
+            CssSheet.Decl d = state.inline[i];
+            offer(d, d.important ? INLINE | IMPORTANT | i : INLINE | i);
+        }
+
+        // 2. The colours this node defines, which its own values may use.
+        boolean changed = updateLookups(state, above);
+        if (state.lookupsAbove) {
+            // Colours of the standard theme are redefined here or above:
+            // a node the native theme draws takes the standard theme's
+            // look, which is what those colours colour.
+            String themed = node.cn1ThemedStyle();
+            if (themed != null) {
+                CssSheet.Decl[] look = defaultDecls(themed);
+                for (int i = 0; i < look.length; i++) {
+                    offer(look[i], -1);
+                }
+            }
+        }
+
+        // 3. The font, which an em length below is relative to.
+        changed |= updateFont(state, above);
+
+        if (signature != state.signature) {
+            state.signature = signature;
+            changed = true;
+        }
+
+        // 4. The values.
+        for (int i = 0; i < touchedCount; i++) {
+            int property = touched[i];
+            CssSheet.Decl d = winner[property];
+            winner[property] = null;
+            if (d == null || d.kind == CssProperties.LOOKUP_DEFINITION || CssProperties.isFont(d.name)) {
+                wanted[property] = null;
+            } else {
+                wanted[property] = decode(d, node, state);
+            }
+        }
+        want(FONT_FAMILY, state.family);
+        want(FONT_SIZE, state.size == state.size ? Double.valueOf(state.size) : null);
+        want(FONT_WEIGHT, state.weight);
+        want(FONT_STYLE, state.posture);
+        apply(node, state);
+        return changed && !fresh;
+    }
+
+    private void want(int property, Object value) {
+        if (stamp[property] != generation) {
+            if (value == null) {
+                return;
+            }
+            stamp[property] = generation;
+            touched[touchedCount++] = property;
+        }
+        wanted[property] = value;
+    }
+
+    private void apply(Node node, State state) {
+        // Withdrawing one font name restores the whole font, so when one
+        // goes they all go and the ones still wanted are applied again.
+        boolean fontGoes = false;
+        for (int i = 0; i < state.count; i++) {
+            int property = state.ids[i];
+            if (isFontPart(property) && (stamp[property] != generation || wanted[property] == null)) {
+                fontGoes = true;
+            }
+        }
+        for (int i = state.count - 1; i >= 0; i--) {
+            int property = state.ids[i];
+            boolean keep = stamp[property] == generation && wanted[property] != null;
+            if (!keep || (fontGoes && isFontPart(property))) {
+                node.cn1ApplyStyle(PROPERTY_NAMES.get(property), null);
+                state.remove(i);
+            }
+        }
+        for (int i = 0; i < touchedCount; i++) {
+            int property = touched[i];
+            Object value = wanted[property];
+            wanted[property] = null;
+            if (value == null) {
+                continue;
+            }
+            int at = state.indexOf(property);
+            if (at < 0) {
+                node.cn1ApplyStyle(PROPERTY_NAMES.get(property), value);
+                state.add(property, value);
+            } else if (!value.equals(state.values[at])) {
+                node.cn1ApplyStyle(PROPERTY_NAMES.get(property), value);
+                state.values[at] = value;
+            }
+        }
+        touchedCount = 0;
+    }
+
+    private static boolean isFontPart(int property) {
+        return property == FONT_FAMILY || property == FONT_SIZE || property == FONT_WEIGHT || property == FONT_STYLE;
+    }
+
+    // -------------------------------------------------------- the cascade
+
+    private void collectScope(Node node) {
+        scope.clear();
+        Scene scene = node.getScene();
+        if (scene != null) {
+            ObservableList<String> list = scene.getStylesheets();
+            for (int i = 0; i < list.size(); i++) {
+                CssSheet s = sheet(list.get(i));
+                if (s != null) {
+                    scope.add(s);
+                }
+            }
+        }
+        if (!parentSheets) {
+            return;
+        }
+        chain.clear();
+        Parent p = node instanceof Parent ? (Parent) node : node.getParent();
+        while (p != null) {
+            if (p.cn1HasStylesheets()) {
+                chain.add(p);
+            }
+            p = p.getParent();
+        }
+        for (int c = chain.size() - 1; c >= 0; c--) {
+            ObservableList<String> list = chain.get(c).getStylesheets();
+            for (int i = 0; i < list.size(); i++) {
+                CssSheet s = sheet(list.get(i));
+                if (s != null) {
+                    scope.add(s);
+                }
+            }
+        }
+        chain.clear();
+    }
+
+    private String typeName(Node node) {
+        Class<?> c = node.getClass();
+        String name = typeNames.get(c);
+        if (name == null) {
+            name = node.getTypeSelector();
+            typeNames.put(c, name);
+        }
+        return name;
+    }
+
+    private void consider(CssSheet.Rule[] rules, Node node, int sheetIndex) {
+        if (rules == null) {
+            return;
+        }
+        for (int r = 0; r < rules.length; r++) {
+            CssSheet.Rule rule = rules[r];
+            if (!compound(rule, 0, node) || !above(rule, 1, node)) {
+                continue;
+            }
+            long base = ((long) rule.selector.specificity() << 32) | ((long) (sheetIndex & 0xfff) << 20)
+                    | (rule.order & 0xfffff);
+            for (int i = 0; i < rule.decls.length; i++) {
+                CssSheet.Decl d = rule.decls[i];
+                offer(d, d.important ? base | IMPORTANT : base);
+            }
+        }
+    }
+
+    private void offer(CssSheet.Decl d, long p) {
+        int property = d.id;
+        if (property >= stamp.length) {
+            int size = Math.max(property + 1, stamp.length * 2);
+            CssSheet.Decl[] w = new CssSheet.Decl[size];
+            long[] pr = new long[size];
+            int[] st = new int[size];
+            Object[] wa = new Object[size];
+            int[] to = new int[size];
+            System.arraycopy(winner, 0, w, 0, winner.length);
+            System.arraycopy(priority, 0, pr, 0, priority.length);
+            System.arraycopy(stamp, 0, st, 0, stamp.length);
+            System.arraycopy(wanted, 0, wa, 0, wanted.length);
+            System.arraycopy(touched, 0, to, 0, touched.length);
+            winner = w;
+            priority = pr;
+            stamp = st;
+            wanted = wa;
+            touched = to;
+        }
+        if (stamp[property] != generation) {
+            stamp[property] = generation;
+            touched[touchedCount++] = property;
+            winner[property] = d;
+            priority[property] = p;
+        } else if (winner[property] == null || p >= priority[property]) {
+            winner[property] = d;
+            priority[property] = p;
+        }
+    }
+
+    /// Whether `node` is what compound `i` of the rule's selector asks for.
+    private boolean compound(CssSheet.Rule rule, int i, Node node) {
+        CssSelector s = rule.selector;
+        String type = s.type(i);
+        if (type != null && !type.equals(typeName(node))) {
+            return false;
+        }
+        String id = s.id(i);
+        if (id != null && !id.equals(node.getId())) {
+            return false;
+        }
+        int n = s.classCount(i);
+        if (n > 0) {
+            ObservableList<String> classes = node.getStyleClass();
+            int have = classes.size();
+            for (int j = 0; j < n; j++) {
+                String wantedClass = s.styleClass(i, j);
+                boolean found = false;
+                for (int k = 0; k < have && !found; k++) {
+                    found = wantedClass.equals(classes.get(k));
+                }
+                if (!found) {
+                    return false;
+                }
+            }
+        }
+        javafx.css.PseudoClass[] states = rule.pseudo[i];
+        for (int j = 0; j < states.length; j++) {
+            if (!node.cn1HasPseudoClass(states[j])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Whether the compounds from `i` on are satisfied by what is above
+    /// `node`.
+    private boolean above(CssSheet.Rule rule, int i, Node node) {
+        if (i >= rule.selector.size()) {
+            return true;
+        }
+        Parent p = node.getParent();
+        if (rule.selector.combinator(i - 1) == CssSelector.CHILD) {
+            return p != null && compound(rule, i, p) && above(rule, i + 1, p);
+        }
+        while (p != null) {
+            if (compound(rule, i, p) && above(rule, i + 1, p)) {
+                return true;
+            }
+            p = p.getParent();
+        }
+        return false;
+    }
+
+    /// The inline style being parsed, for the message of a warning.
+    private String inlineText;
+
+    /// One reporter for every inline style, rather than one per parse.
+    private final CssDeclarations.Reporter inlineReporter = new CssDeclarations.Reporter() {
+        @Override
+        public void warning(int offset, String message) {
+            warnOnce("In the inline style \"" + inlineText + "\": " + message);
+        }
+    };
+
+    private final HashMap<String, CssSheet.Decl[]> defaultStyles = new HashMap<String, CssSheet.Decl[]>();
+
+    /// The declarations of a node's default style, read once per text:
+    /// every node of a class answers the same one.
+    private CssSheet.Decl[] defaultDecls(String text) {
+        CssSheet.Decl[] out = defaultStyles.get(text);
+        if (out == null) {
+            out = parseInline(text);
+            defaultStyles.put(text, out);
+        }
+        return out;
+    }
+
+    private CssSheet.Decl[] parseInline(String text) {
+        if (text.trim().length() == 0) {
+            return NO_DECLS;
+        }
+        parsed.clear();
+        String clean = CssDeclarations.stripComments(text);
+        inlineText = text;
+        CssDeclarations.parse(clean, 0, clean.length(), parser, inlineReporter, parsed);
+        inlineText = null;
+        CssSheet.Decl[] out = new CssSheet.Decl[parsed.size()];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = new CssSheet.Decl(parsed.get(i));
+        }
+        parsed.clear();
+        return out;
+    }
+
+    // ------------------------------------------------- inherited: colours
+
+    private boolean updateLookups(State state, State above) {
+        int n = 0;
+        boolean same = true;
+        for (int i = 0; i < touchedCount; i++) {
+            CssSheet.Decl d = winner[touched[i]];
+            if (d != null && d.kind == CssProperties.LOOKUP_DEFINITION) {
+                n++;
+                int at = -1;
+                for (int j = 0; state.lookupNames != null && j < state.lookupNames.length && at < 0; j++) {
+                    if (state.lookupNames[j].equals(d.name)) {
+                        at = j;
+                    }
+                }
+                same &= at >= 0 && state.lookupValues[at].equals(d.value);
+            }
+        }
+        same &= n == (state.lookupNames == null ? 0 : state.lookupNames.length);
+        if (!same) {
+            if (n == 0) {
+                state.lookupNames = null;
+                state.lookupValues = null;
+            } else {
+                state.lookupNames = new String[n];
+                state.lookupValues = new CssValue[n];
+                int at = 0;
+                for (int i = 0; i < touchedCount; i++) {
+                    CssSheet.Decl d = winner[touched[i]];
+                    if (d != null && d.kind == CssProperties.LOOKUP_DEFINITION) {
+                        state.lookupNames[at] = d.name;
+                        state.lookupValues[at++] = d.value;
+                    }
+                }
+            }
+        }
+        boolean chainNow = state.lookupNames != null || (above != null && above.lookupsAbove);
+        boolean changed = !same || chainNow != state.lookupsAbove;
+        state.lookupsAbove = chainNow;
+        return changed;
+    }
+
+    /// The value a name is defined as at `node` or the nearest ancestor
+    /// that defines it.
+    private static CssValue lookup(String name, Node node) {
+        Node at = node;
+        while (at != null) {
+            State s = stateOf(at);
+            if (s == null || !s.lookupsAbove) {
+                break;
+            }
+            if (s.lookupNames != null) {
+                for (int i = 0; i < s.lookupNames.length; i++) {
+                    if (s.lookupNames[i].equals(name)) {
+                        return s.lookupValues[i];
+                    }
+                }
+            }
+            at = at.getParent();
+        }
+        return themeDefault(name);
+    }
+
+    /// The colours of the standard JavaFX theme, as that theme defines
+    /// them: mostly in terms of each other, so that a sheet redefining
+    /// `-fx-base` alone changes them all. The few the theme writes as
+    /// gradients are given as their middle colour, since a looked-up
+    /// name stands for a colour here.
+    private static final String[] THEME = {
+        "-fx-base", "#ececec",
+        "-fx-background", "derive(-fx-base, 26.4%)",
+        "-fx-control-inner-background", "derive(-fx-base, 80%)",
+        "-fx-control-inner-background-alt", "derive(-fx-control-inner-background, -2%)",
+        "-fx-dark-text-color", "black",
+        "-fx-mid-text-color", "#333333",
+        "-fx-light-text-color", "white",
+        "-fx-accent", "#0096c9",
+        "-fx-default-button", "#abd8ed",
+        "-fx-focus-color", "#039ed3",
+        "-fx-faint-focus-color", "#039ed322",
+        "-fx-color", "-fx-base",
+        "-fx-hover-base", "ladder(-fx-base, derive(-fx-base, 20%) 20%, derive(-fx-base, 30%) 35%,"
+                + " derive(-fx-base, 40%) 50%)",
+        "-fx-pressed-base", "derive(-fx-base, -6%)",
+        "-fx-text-background-color", "ladder(-fx-background, -fx-light-text-color 45%, -fx-dark-text-color 46%,"
+                + " -fx-dark-text-color 59%, -fx-mid-text-color 60%)",
+        "-fx-text-base-color", "ladder(-fx-color, -fx-light-text-color 45%, -fx-dark-text-color 46%,"
+                + " -fx-dark-text-color 59%, -fx-mid-text-color 60%)",
+        "-fx-text-inner-color", "ladder(-fx-control-inner-background, -fx-light-text-color 45%,"
+                + " -fx-dark-text-color 46%, -fx-dark-text-color 59%, -fx-mid-text-color 60%)",
+        "-fx-box-border", "ladder(-fx-color, black 20%, derive(-fx-color, -15%) 30%)",
+        "-fx-text-box-border", "ladder(-fx-background, black 10%, derive(-fx-background, -15%) 30%)",
+        "-fx-shadow-highlight-color", "rgba(255, 255, 255, 0.7)",
+        "-fx-outer-border", "derive(-fx-color, -23%)",
+        "-fx-inner-border", "derive(-fx-color, 50%)",
+        "-fx-inner-border-horizontal", "derive(-fx-color, 50%)",
+        "-fx-inner-border-bottomup", "derive(-fx-color, 50%)",
+        "-fx-body-color", "-fx-color",
+        "-fx-mark-color", "ladder(-fx-color, white 30%, derive(-fx-color, -63%) 31%)",
+        "-fx-mark-highlight-color", "ladder(-fx-color, derive(-fx-color, 80%) 60%, white 70%)",
+        "-fx-progress-color", "-fx-accent",
+        "-fx-selection-bar", "-fx-accent",
+        "-fx-selection-bar-non-focused", "lightgrey",
+        "-fx-selection-bar-text", "ladder(-fx-selection-bar, -fx-light-text-color 45%, -fx-dark-text-color 46%,"
+                + " -fx-dark-text-color 59%, -fx-mid-text-color 60%)",
+        "-fx-cell-hover-color", "#cce3f4",
+        "-fx-cell-focus-inner-border", "derive(-fx-selection-bar, 20%)",
+        "-fx-focused-text-base-color", "-fx-text-base-color",
+        "-fx-focused-mark-color", "-fx-focused-text-base-color",
+        "-fx-table-cell-border-color", "derive(-fx-color, 5%)",
+        "-fx-table-header-border-color", "-fx-box-border",
+    };
+
+    private static final HashMap<String, CssValue> THEME_DEFAULTS = themeDefaults();
+
+    private static HashMap<String, CssValue> themeDefaults() {
+        HashMap<String, CssValue> made = new HashMap<String, CssValue>();
+        CssValueParser p = new CssValueParser();
+        for (int i = 0; i + 1 < THEME.length; i += 2) {
+            CssValue v = p.parse(THEME[i], THEME[i + 1]);
+            if (v != null) {
+                made.put(THEME[i], v);
+            }
+        }
+        return made;
+    }
+
+    private static CssValue themeDefault(String name) {
+        return THEME_DEFAULTS.get(name);
+    }
+
+    /// The colour a theme name stands for where `node` is: what the
+    /// nearest rule defines it as, else what the standard theme does.
+    /// `null` for a name that is neither.
+    public static Color themeColor(Node node, String name) {
+        return color(CssValue.text(CssValue.LOOKUP, name), node, 0);
+    }
+
+    // ---------------------------------------------------- inherited: font
+
+    private CssSheet.Decl won(int property) {
+        return property < stamp.length && stamp[property] == generation ? winner[property] : null;
+    }
+
+    private boolean updateFont(State state, State above) {
+        String family = above == null ? null : above.family;
+        double size = above == null ? Double.NaN : above.size;
+        Object weight = above == null ? null : above.weight;
+        String posture = above == null ? null : above.posture;
+        double base = size == size ? size : Font.getDefault().getSize();
+
+        CssSheet.Decl font = won(FONT);
+        if (font != null && font.value.type() == CssValue.FONT) {
+            CssValue v = font.value;
+            family = v.text();
+            size = fontSize(v, base);
+            int w = v.flags() & 0xffff;
+            weight = w == 0 ? (Object) "normal" : (Object) Integer.valueOf(w);
+            posture = (v.flags() >> 16) == 2 ? "italic" : "normal";
+        }
+        CssSheet.Decl d = won(FONT_FAMILY);
+        if (d != null && d.value.text() != null) {
+            family = d.value.text();
+        }
+        d = won(FONT_SIZE);
+        if (d != null && d.value.count() > 0) {
+            size = fontSize(d.value, base);
+        }
+        d = won(FONT_WEIGHT);
+        if (d != null) {
+            if (d.value.type() == CssValue.NUMBER) {
+                weight = Integer.valueOf((int) d.value.num(0));
+            } else if (d.value.text() != null) {
+                weight = d.value.text();
+            }
+        }
+        d = won(FONT_STYLE);
+        if (d != null && d.value.text() != null) {
+            posture = d.value.text();
+        }
+        boolean changed = !same(family, state.family) || !same(weight, state.weight) || !same(posture, state.posture)
+                || Double.doubleToLongBits(size) != Double.doubleToLongBits(state.size);
+        state.family = family;
+        state.size = size;
+        state.weight = weight;
+        state.posture = posture;
+        return changed;
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    private static double fontSize(CssValue v, double inherited) {
+        double n = v.num(0);
+        switch (v.unit(0)) {
+            case CssValue.UNIT_EM:
+                return n * inherited;
+            case CssValue.UNIT_PERCENT:
+                return n * inherited / 100;
+            default:
+                return n;
+        }
+    }
+
+    // --------------------------------------------------------- the values
+
+    /// The object the node takes for a declaration, or `null` when the
+    /// declaration cannot be applied here: a colour name nothing defines.
+    private Object decode(CssSheet.Decl d, Node node, State state) {
+        if (d.decoded != null) {
+            return d.decoded;
+        }
+        double em = state.size == state.size ? state.size : Font.getDefault().getSize();
+        Object out = decode(d.kind, d.name, d.value, node, em);
+        if (out != null && !d.value.isContextual()) {
+            d.decoded = out;
+        }
+        return out;
+    }
+
+    private static Object decode(int kind, String name, CssValue v, Node node, double em) {
+        if (v.type() == CssValue.LIST || v.type() == CssValue.SIDES) {
+            // Each layer, or side, is a value of the same kind; one that
+            // cannot be resolved takes the whole declaration with it.
+            Object[] items = new Object[v.partCount()];
+            for (int i = 0; i < items.length; i++) {
+                items[i] = v.part(i) == null ? null : decode(kind, name, v.part(i), node, em);
+                if (items[i] == null) {
+                    return null;
+                }
+            }
+            return new StyleList(items, v.type() == CssValue.SIDES);
+        }
+        switch (kind) {
+            case CssProperties.PAINT:
+                return paint(v, node, 0);
+            case CssProperties.LENGTH:
+                return v.count() == 0 || v.unit(0) == CssValue.UNIT_PERCENT ? null
+                        : (Object) Double.valueOf(length(v, 0, em));
+            case CssProperties.NUMBER:
+                return v.count() == 0 ? null : (Object) Double.valueOf(v.num(0));
+            case CssProperties.INSETS: {
+                int n = v.count();
+                if (n == 0) {
+                    return null;
+                }
+                double top = length(v, 0, em);
+                double right = n > 1 ? length(v, 1, em) : top;
+                double bottom = n > 2 ? length(v, 2, em) : top;
+                double left = n > 3 ? length(v, 3, em) : right;
+                return new Insets(top, right, bottom, left);
+            }
+            case CssProperties.RADII: {
+                int n = v.count();
+                if (n == 0) {
+                    return null;
+                }
+                double tl = length(v, 0, em);
+                double tr = n > 1 ? length(v, 1, em) : tl;
+                double br = n > 2 ? length(v, 2, em) : tl;
+                double bl = n > 3 ? length(v, 3, em) : tr;
+                return new CornerRadii(Math.max(0, tl), Math.max(0, tr), Math.max(0, br), Math.max(0, bl),
+                        v.unit(0) == CssValue.UNIT_PERCENT);
+            }
+            case CssProperties.BOOLEAN:
+                return v.flags() != 0 ? Boolean.TRUE : Boolean.FALSE;
+            case CssProperties.KEYWORD:
+            case CssProperties.TEXT:
+            case CssProperties.RAW:
+                return v.text();
+            case CssProperties.POS:
+                return v.text() == null ? null : POSITIONS.get(v.text());
+            case CssProperties.EFFECT:
+                return effect(v, node);
+            case CssProperties.CURSOR:
+                try {
+                    return v.text() == null ? null : Cursor.cursor(v.text());
+                } catch (IllegalArgumentException e) {
+                    warnOnce("Unknown cursor '" + v.text() + "' for " + name);
+                    return null;
+                }
+            default:
+                return null;
+        }
+    }
+
+    /// What `none` stands for: an effect that draws nothing, since a
+    /// declaration has to decode to something to win over another.
+    private static final Effect NO_EFFECT = new Effect() {
+    };
+
+    private static Object effect(CssValue v, Node node) {
+        int kind = v.flags() & 0xf;
+        if (kind == 0 || v.count() < 4) {
+            return NO_EFFECT;
+        }
+        Color c = v.partCount() == 0 ? null : color(v.part(0), node, 0);
+        if (c == null) {
+            return null;
+        }
+        int passes = v.flags() >> 4;
+        BlurType blur = passes == 1 ? BlurType.ONE_PASS_BOX
+                : (passes == 2 ? BlurType.TWO_PASS_BOX : BlurType.THREE_PASS_BOX);
+        if (kind == CssValue.EFFECT_INNER) {
+            return new InnerShadow(blur, c, v.num(0), v.num(1), v.num(2), v.num(3));
+        }
+        return new DropShadow(blur, c, v.num(0), v.num(1), v.num(2), v.num(3));
+    }
+
+    private static double length(CssValue v, int i, double em) {
+        double n = v.num(i);
+        if (v.unit(i) == CssValue.UNIT_EM) {
+            return n * em;
+        }
+        if (v.unit(i) == CssValue.UNIT_PERCENT) {
+            // A percentage radius is kept as written; the radii say so.
+            return n / 100;
+        }
+        return n;
+    }
+
+    private static Object paint(CssValue v, Node node, int depth) {
+        if (v == null || depth > 8) {
+            return null;
+        }
+        switch (v.type()) {
+            case CssValue.COLOR:
+            case CssValue.LOOKUP:
+            case CssValue.DERIVE:
+            case CssValue.LADDER:
+                return color(v, node, depth);
+            case CssValue.LINEAR: {
+                List<Stop> stops = stops(v, 4, node, depth);
+                if (stops == null) {
+                    return null;
+                }
+                return new LinearGradient(v.num(0), v.num(1), v.num(2), v.num(3),
+                        (v.flags() & CssValue.FLAG_PROPORTIONAL) != 0, cycle(v), stops);
+            }
+            case CssValue.RADIAL: {
+                List<Stop> stops = stops(v, 5, node, depth);
+                if (stops == null) {
+                    return null;
+                }
+                return new RadialGradient(v.num(0), v.num(1), v.num(2), v.num(3), v.num(4),
+                        (v.flags() & CssValue.FLAG_PROPORTIONAL) != 0, cycle(v), stops);
+            }
+            default:
+                return null;
+        }
+    }
+
+    private static CycleMethod cycle(CssValue v) {
+        if ((v.flags() & CssValue.FLAG_REFLECT) != 0) {
+            return CycleMethod.REFLECT;
+        }
+        return (v.flags() & CssValue.FLAG_REPEAT) != 0 ? CycleMethod.REPEAT : CycleMethod.NO_CYCLE;
+    }
+
+    private static List<Stop> stops(CssValue v, int from, Node node, int depth) {
+        int n = v.partCount();
+        if (n == 0 || v.count() < from + n) {
+            return null;
+        }
+        double[] offsets = new double[n];
+        for (int i = 0; i < n; i++) {
+            offsets[i] = v.num(from + i);
+        }
+        // A stop without an offset sits evenly between its neighbours.
+        if (offsets[0] != offsets[0]) {
+            offsets[0] = 0;
+        }
+        if (offsets[n - 1] != offsets[n - 1]) {
+            offsets[n - 1] = 1;
+        }
+        int known = 0;
+        for (int i = 1; i < n; i++) {
+            if (offsets[i] == offsets[i]) {
+                int gap = i - known;
+                for (int j = known + 1; j < i; j++) {
+                    offsets[j] = offsets[known] + (offsets[i] - offsets[known]) * (j - known) / gap;
+                }
+                known = i;
+            }
+        }
+        ArrayList<Stop> out = new ArrayList<Stop>(n);
+        for (int i = 0; i < n; i++) {
+            Color c = color(v.part(i), node, depth + 1);
+            if (c == null) {
+                return null;
+            }
+            out.add(new Stop(offsets[i], c));
+        }
+        return out;
+    }
+
+    private static Color color(CssValue v, Node node, int depth) {
+        if (v == null || depth > 8) {
+            return null;
+        }
+        switch (v.type()) {
+            case CssValue.COLOR: {
+                int argb = v.flags();
+                return Color.rgb((argb >> 16) & 0xff, (argb >> 8) & 0xff, argb & 0xff, ((argb >>> 24) & 0xff) / 255.0);
+            }
+            case CssValue.LOOKUP: {
+                CssValue defined = lookup(v.text(), node);
+                if (defined == null) {
+                    warnOnce("The colour '" + v.text() + "' is used but no rule defines it");
+                    return null;
+                }
+                Object p = paint(defined, node, depth + 1);
+                return p instanceof Color ? (Color) p : null;
+            }
+            case CssValue.DERIVE: {
+                Color c = v.partCount() == 0 ? null : color(v.part(0), node, depth + 1);
+                return c == null || v.count() == 0 ? null : derive(c, v.num(0) / 100);
+            }
+            case CssValue.LADDER:
+                return ladder(v, node, depth);
+            default:
+                return null;
+        }
+    }
+
+    /// JavaFX's `ladder()`: the stops are a gradient, and the brightness
+    /// of the first colour is the place in it the colour is read from.
+    /// That is how a theme picks a dark text for a light background and
+    /// a light one for a dark.
+    private static Color ladder(CssValue v, Node node, int depth) {
+        int n = v.partCount() - 1;
+        Color base = n < 1 ? null : color(v.part(0), node, depth + 1);
+        if (base == null || v.count() < n) {
+            return null;
+        }
+        // The brightness an eye sees, as JavaFX reads it here: the accent
+        // blue is a dark colour by this measure and takes a light text.
+        double at = 0.3 * base.getRed() + 0.59 * base.getGreen() + 0.11 * base.getBlue();
+        Color before = null;
+        double beforeAt = 0;
+        for (int i = 0; i < n; i++) {
+            Color c = color(v.part(i + 1), node, depth + 1);
+            if (c == null) {
+                return null;
+            }
+            double offset = v.num(i);
+            if (offset != offset) {
+                offset = n == 1 ? 0 : (double) i / (n - 1);
+            }
+            if (at <= offset) {
+                if (before == null || offset <= beforeAt) {
+                    return c;
+                }
+                return before.interpolate(c, (at - beforeAt) / (offset - beforeAt));
+            }
+            before = c;
+            beforeAt = offset;
+        }
+        return before;
+    }
+
+    /// JavaFX's `derive()`: a brightness change that is scaled by how
+    /// bright the colour already is, so that one percentage reads the same
+    /// on a light and on a dark base.
+    private static Color derive(Color c, double brightness) {
+        double base = 0.3 * c.getRed() + 0.59 * c.getGreen() + 0.11 * c.getBlue();
+        double by = brightness;
+        if (by > 0) {
+            if (base > 0.85) {
+                by = by * 1.6;
+            } else if (base > 0.6) {
+                by = by * 1.0;
+            } else if (base > 0.5) {
+                by = by * 0.9;
+            } else if (base > 0.4) {
+                by = by * 0.8;
+            } else if (base > 0.3) {
+                by = by * 0.7;
+            } else {
+                by = by * 0.6;
+            }
+        } else if (base < 0.2) {
+            by = by * 0.6;
+        }
+        by = Math.max(-1, Math.min(1, by));
+        double h = c.getHue();
+        double s = c.getSaturation();
+        double b = c.getBrightness();
+        if (by > 0) {
+            s = s * (1 - by);
+            b = b + (1 - b) * by;
+        } else {
+            b = b * (by + 1);
+        }
+        return Color.hsb(h, Math.max(0, Math.min(1, s)), Math.max(0, Math.min(1, b)), c.getOpacity());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/CssSheet.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/CssSheet.java
new file mode 100644
index 00000000000..bb6d714b818
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/CssSheet.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.impl.compat.Resources;
+import com.codename1.fxcompat.runtime.css.CssDeclaration;
+import com.codename1.fxcompat.runtime.css.CssSelector;
+import com.codename1.fxcompat.runtime.css.CssSheetData;
+import com.codename1.fxcompat.runtime.css.CssValue;
+
+import javafx.css.PseudoClass;
+
+/// A compiled style sheet as [CssEngine] matches against it: the rules of
+/// the sheet and of everything it imports, in cascade order, indexed by
+/// what the rightmost compound of each selector requires.
+///
+/// #### The index
+///
+/// A rule can only match a node that satisfies its subject compound, so
+/// each rule is filed under ONE thing that compound requires -- its id if
+/// it has one, else its first style class, else its type, else nothing --
+/// and a node only looks at the rules filed under its own id, its own
+/// classes, its own type, and the few filed under nothing. The rest of the
+/// sheet is never visited.
+///
+/// #### What an ancestor can change
+///
+/// [#ancestorIds], [#ancestorClasses], [#ancestorTypes] and
+/// [#ancestorPseudos] hold every name some rule requires of a compound that
+/// is NOT its subject. A node whose id, classes, type and states are in
+/// none of them cannot change which rules its descendants match, which is
+/// what lets the engine restyle one node without walking its subtree.
+final class CssSheet {
+
+    /// One declaration, with what the engine caches for it.
+    static final class Decl {
+        final String name;
+        final int id;
+        final int kind;
+        final CssValue value;
+        final boolean important;
+        /// The object a value that depends on no node decodes to, once made.
+        Object decoded;
+
+        Decl(CssDeclaration d) {
+            this.name = d.name();
+            this.id = CssEngine.propertyId(d.name());
+            this.kind = d.kind();
+            this.value = d.value();
+            this.important = d.important();
+        }
+    }
+
+    /// One selector and the declarations it brings.
+    static final class Rule {
+        final CssSelector selector;
+        /// `pseudo[i][j]` is pseudo-class `j` of compound `i`.
+        final PseudoClass[][] pseudo;
+        final Decl[] decls;
+        final int order;
+
+        Rule(CssSelector selector, Decl[] decls, int order) {
+            this.selector = selector;
+            this.decls = decls;
+            this.order = order;
+            pseudo = new PseudoClass[selector.size()][];
+            for (int i = 0; i < pseudo.length; i++) {
+                pseudo[i] = new PseudoClass[selector.pseudoCount(i)];
+                for (int j = 0; j < pseudo[i].length; j++) {
+                    pseudo[i][j] = PseudoClass.getPseudoClass(selector.pseudo(i, j));
+                }
+            }
+        }
+    }
+
+    private static final Rule[] NO_RULES = new Rule[0];
+
+    final HashMap<String, Rule[]> byId = new HashMap<String, Rule[]>();
+    final HashMap<String, Rule[]> byClass = new HashMap<String, Rule[]>();
+    final HashMap<String, Rule[]> byType = new HashMap<String, Rule[]>();
+    Rule[] universal = NO_RULES;
+    final HashSet<String> ancestorIds = new HashSet<String>();
+    final HashSet<String> ancestorClasses = new HashSet<String>();
+    final HashSet<String> ancestorTypes = new HashSet<String>();
+    PseudoClass[] ancestorPseudos = new PseudoClass[0];
+    private int ruleCount;
+
+    private CssSheet() {
+    }
+
+    /// How many rules the sheet holds, its imports included.
+    int size() {
+        return ruleCount;
+    }
+
+    /// Reads the compiled form of the style sheet at `path`, a resource
+    /// path without a leading slash, with everything it imports. Answers
+    /// `null` when the application ships no compiled sheet for that path.
+    static CssSheet load(String path) throws IOException {
+        CssSheet sheet = new CssSheet();
+        ArrayList<Rule> rules = new ArrayList<Rule>();
+        if (!sheet.read(path, rules, new HashSet<String>())) {
+            return null;
+        }
+        sheet.index(rules);
+        return sheet;
+    }
+
+    /// Builds a sheet from data already in memory; for tests and tools.
+    static CssSheet of(CssSheetData data) {
+        CssSheet sheet = new CssSheet();
+        ArrayList<Rule> rules = new ArrayList<Rule>();
+        sheet.add(data, rules);
+        sheet.index(rules);
+        return sheet;
+    }
+
+    private boolean read(String path, ArrayList<Rule> rules, HashSet<String> seen) throws IOException {
+        if (!seen.add(path)) {
+            // A sheet that imports itself, directly or not: once is enough.
+            return true;
+        }
+        InputStream in = Resources.open(CssSheetData.compiledName(ResourceNames.flatName(path)));
+        if (in == null) {
+            return false;
+        }
+        CssSheetData data;
+        try {
+            data = CssSheetData.read(in);
+        } finally {
+            in.close();
+        }
+        // An import comes before the rules of the sheet that imports it,
+        // so the importing sheet wins a tie.
+        for (int i = 0; i < data.importCount(); i++) {
+            if (!read(data.importPath(i), rules, seen)) {
+                CssEngine.warnOnce("The style sheet " + path + " imports " + data.importPath(i)
+                        + ", which was not compiled into the application");
+            }
+        }
+        for (int i = 0; i < data.fontCount(); i++) {
+            // The family the rule declares is one more name of the font.
+            FontFiles.Face face = FontFiles.load(data.fontSource(i));
+            if (face == null) {
+                CssEngine.warnOnce("The style sheet " + path + " declares the font " + data.fontFamily(i) + " from "
+                        + data.fontSource(i) + ", which is not a font file of the application");
+            } else {
+                FontFiles.alias(data.fontFamily(i), face);
+            }
+        }
+        add(data, rules);
+        return true;
+    }
+
+    private void add(CssSheetData data, ArrayList<Rule> rules) {
+        Decl[][] blocks = new Decl[data.blockCount()][];
+        for (int b = 0; b < blocks.length; b++) {
+            blocks[b] = new Decl[data.declarationCount(b)];
+            for (int i = 0; i < blocks[b].length; i++) {
+                blocks[b][i] = new Decl(data.declaration(b, i));
+            }
+        }
+        for (int i = 0; i < data.ruleCount(); i++) {
+            rules.add(new Rule(data.selector(i), blocks[data.blockOf(i)], rules.size()));
+        }
+    }
+
+    private void index(ArrayList<Rule> rules) {
+        ruleCount = rules.size();
+        HashMap<String, ArrayList<Rule>> ids = new HashMap<String, ArrayList<Rule>>();
+        HashMap<String, ArrayList<Rule>> classes = new HashMap<String, ArrayList<Rule>>();
+        HashMap<String, ArrayList<Rule>> types = new HashMap<String, ArrayList<Rule>>();
+        ArrayList<Rule> any = new ArrayList<Rule>();
+        ArrayList<PseudoClass> pseudos = new ArrayList<PseudoClass>();
+        for (int r = 0; r < rules.size(); r++) {
+            Rule rule = rules.get(r);
+            CssSelector s = rule.selector;
+            if (s.id(0) != null) {
+                file(ids, s.id(0), rule);
+            } else if (s.classCount(0) > 0) {
+                file(classes, s.styleClass(0, 0), rule);
+            } else if (s.type(0) != null) {
+                file(types, s.type(0), rule);
+            } else {
+                any.add(rule);
+            }
+            for (int c = 1; c < s.size(); c++) {
+                if (s.id(c) != null) {
+                    ancestorIds.add(s.id(c));
+                }
+                if (s.type(c) != null) {
+                    ancestorTypes.add(s.type(c));
+                }
+                for (int j = 0; j < s.classCount(c); j++) {
+                    ancestorClasses.add(s.styleClass(c, j));
+                }
+                for (int j = 0; j < rule.pseudo[c].length; j++) {
+                    if (!pseudos.contains(rule.pseudo[c][j])) {
+                        pseudos.add(rule.pseudo[c][j]);
+                    }
+                }
+            }
+        }
+        freeze(ids, byId);
+        freeze(classes, byClass);
+        freeze(types, byType);
+        universal = any.toArray(NO_RULES);
+        ancestorPseudos = pseudos.toArray(new PseudoClass[pseudos.size()]);
+    }
+
+    private static void file(HashMap<String, ArrayList<Rule>> into, String key, Rule rule) {
+        ArrayList<Rule> list = into.get(key);
+        if (list == null) {
+            list = new ArrayList<Rule>();
+            into.put(key, list);
+        }
+        list.add(rule);
+    }
+
+    private static void freeze(HashMap<String, ArrayList<Rule>> from, HashMap<String, Rule[]> into) {
+        for (java.util.Map.Entry<String, ArrayList<Rule>> e : from.entrySet()) {
+            into.put(e.getKey(), e.getValue().toArray(NO_RULES));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Diagnostics.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Diagnostics.java
new file mode 100644
index 00000000000..7b0fbf0a7cf
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Diagnostics.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// Where the layer reports a failure the JavaFX contract tells it to survive,
+/// such as a binding function that throws.
+public final class Diagnostics {
+
+    private Diagnostics() {
+    }
+
+    /// Reports a failure that was recovered from.
+    public static void report(Throwable failure) {
+        failure.printStackTrace();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Dirty.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Dirty.java
new file mode 100644
index 00000000000..43d4eb6c4bc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Dirty.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// What a property change makes stale. A property created through
+/// [FxDouble], [FxBoolean], [FxObject] or [FxString] reports the bits it
+/// was given to its owner each time its value is invalidated.
+public final class Dirty {
+
+    /// Nothing beyond the listeners.
+    public static final int NONE = 0;
+    /// The pixels of the node.
+    public static final int PAINT = 1;
+    /// The size the node asks for, or how it arranges its children.
+    public static final int LAYOUT = 2;
+    /// Where the node sits in its parent: position, translation, scale,
+    /// rotation.
+    public static final int BOUNDS = 4;
+    /// What a style sheet may match: id, style class, inline style.
+    public static final int STYLE = 8;
+    /// The state mirrored into the Codename One component of a control.
+    public static final int NATIVE = 16;
+    /// The shape of a node that computes its own geometry.
+    public static final int GEOMETRY = 32;
+    /// First bit free for a subclass.
+    public static final int USER = 256;
+
+    private Dirty() {
+    }
+
+    /// The owner of properties that report what they make stale.
+    public interface Owner {
+        /// Called when a property changed; `what` is the bits it was
+        /// created with.
+        void cn1Invalidated(int what);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Effects.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Effects.java
new file mode 100644
index 00000000000..4b90112e739
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Effects.java
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+
+import javafx.scene.Node;
+import javafx.scene.effect.BlurType;
+import javafx.scene.effect.DropShadow;
+import javafx.scene.effect.Effect;
+import javafx.scene.effect.InnerShadow;
+import javafx.scene.paint.Color;
+
+/// Draws the two effects the layer draws: the shadow a [DropShadow] casts
+/// behind a node and the one an [InnerShadow] casts inside it.
+///
+/// A shadow is the outline of what the node paints, blurred and coloured.
+/// The outline is whatever the node's peer paints -- a shape, a text, a
+/// region with its children and their native components -- so the peer is
+/// painted once into a picture of its own, the coverage of that picture is
+/// blurred with box passes, and the result is kept. Painting the node then
+/// costs one image.
+///
+/// The picture is kept on the node until something under the node changes:
+/// every change of every node arrives at `Node.cn1Invalidated`, which
+/// drops the pictures of the node and of what is above it. A changed
+/// effect, size or scale is noticed when the picture is next asked for.
+/// Nothing is walked while no node has a picture.
+///
+/// Every other effect is recorded and not drawn; see [Effect].
+public final class Effects {
+
+    /// The most pixels a shadow is made for. A node larger than this is
+    /// painted without one rather than blurred on every change.
+    private static final int MAX_PIXELS = 6000000;
+
+    private static int live;
+    private static int captures;
+    private static Node building;
+
+    private Effects() {
+    }
+
+    /// What is kept for a node.
+    private static final class Kept {
+        Effect effect;
+        double[] values;
+        int width;
+        int height;
+        int margin;
+        Image behind;
+        int behindX;
+        int behindY;
+        Image over;
+    }
+
+    /// How many pictures were made since the start; for tests, which
+    /// check that a second paint makes none.
+    public static int captureCount() {
+        return captures;
+    }
+
+    /// Whether a node has an effect that is drawn.
+    public static boolean has(Node node) {
+        Effect e = node.getEffect();
+        return e instanceof DropShadow || e instanceof InnerShadow;
+    }
+
+    /// Drops the pictures kept for a node and for everything above it,
+    /// because what they show has changed.
+    public static void invalidate(Node node) {
+        if (live <= 0) {
+            return;
+        }
+        for (Node n = node; n != null; n = n.getParent()) {
+            if (n.cn1EffectCache() != null) {
+                n.cn1SetEffectCache(null);
+                live--;
+            }
+        }
+    }
+
+    private static int passes(BlurType type) {
+        if (type == BlurType.ONE_PASS_BOX) {
+            return 1;
+        }
+        return type == BlurType.TWO_PASS_BOX ? 2 : 3;
+    }
+
+    private static int argb(Color c) {
+        if (c == null) {
+            return 0xff000000;
+        }
+        return ((int) Math.round(c.getOpacity() * 255) << 24) | ((int) Math.round(c.getRed() * 255) << 16)
+                | ((int) Math.round(c.getGreen() * 255) << 8) | (int) Math.round(c.getBlue() * 255);
+    }
+
+    /// The numbers a picture depends on: per shadow its kind, radius,
+    /// spread, offsets, colour and passes, then the scale.
+    private static double[] values(Effect top) {
+        double[] out = new double[17];
+        int at = 0;
+        Effect e = top;
+        for (int level = 0; level < 2 && e != null; level++) {
+            if (e instanceof DropShadow) {
+                DropShadow d = (DropShadow) e;
+                out[at] = 1;
+                out[at + 1] = d.getRadius();
+                out[at + 2] = d.getSpread();
+                out[at + 3] = d.getOffsetX();
+                out[at + 4] = d.getOffsetY();
+                out[at + 5] = argb(d.getColor());
+                out[at + 6] = passes(d.getBlurType());
+                e = d.getInput();
+            } else if (e instanceof InnerShadow) {
+                InnerShadow s = (InnerShadow) e;
+                out[at] = 2;
+                out[at + 1] = s.getRadius();
+                out[at + 2] = s.getChoke();
+                out[at + 3] = s.getOffsetX();
+                out[at + 4] = s.getOffsetY();
+                out[at + 5] = argb(s.getColor());
+                out[at + 6] = passes(s.getBlurType());
+                e = s.getInput();
+            } else {
+                e = null;
+            }
+            at += 8;
+        }
+        out[16] = Units.scale();
+        return out;
+    }
+
+    private static boolean same(double[] a, double[] b) {
+        for (int i = 0; i < a.length; i++) {
+            if (Double.compare(a[i], b[i]) != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// One box pass over rows of `w` values, then over columns. `edge` is
+    /// what lies beyond the picture: nothing for a shadow cast outwards,
+    /// everything for one cast inwards.
+    static void box(int[] a, int w, int h, int r, int edge) {
+        if (r <= 0 || w <= 0 || h <= 0) {
+            return;
+        }
+        int span = 2 * r + 1;
+        int[] line = new int[Math.max(w, h)];
+        for (int y = 0; y < h; y++) {
+            int row = y * w;
+            int sum = edge * r;
+            for (int x = 0; x <= r; x++) {
+                sum += x < w ? a[row + x] : edge;
+            }
+            for (int x = 0; x < w; x++) {
+                line[x] = sum / span;
+                int out = x - r;
+                int in = x + r + 1;
+                sum += (in < w ? a[row + in] : edge) - (out >= 0 ? a[row + out] : edge);
+            }
+            System.arraycopy(line, 0, a, row, w);
+        }
+        for (int x = 0; x < w; x++) {
+            int sum = edge * r;
+            for (int y = 0; y <= r; y++) {
+                sum += y < h ? a[y * w + x] : edge;
+            }
+            for (int y = 0; y < h; y++) {
+                line[y] = sum / span;
+                int out = y - r;
+                int in = y + r + 1;
+                sum += (in < h ? a[in * w + x] : edge) - (out >= 0 ? a[out * w + x] : edge);
+            }
+            for (int y = 0; y < h; y++) {
+                a[y * w + x] = line[y];
+            }
+        }
+    }
+
+    private static int boxRadius(double radius, int passes) {
+        if (!(radius > 0)) {
+            return 0;
+        }
+        // Passes of a box of radius r reach r * passes; JavaFX's radius is
+        // how far the whole blur reaches.
+        return Math.max(1, (int) Math.round(radius / passes));
+    }
+
+    private static int strengthen(int a, double spread) {
+        if (!(spread > 0)) {
+            return a;
+        }
+        if (spread >= 1) {
+            return a > 0 ? 255 : 0;
+        }
+        return (int) Math.min(255, a / (1 - spread));
+    }
+
+    /// The shadow a picture casts: its coverage blurred over `radius`
+    /// pixels in `passes` box passes, the inner `spread` of the blur at
+    /// full strength, in a colour. The answer has the size of the picture.
+    public static int[] dropShadow(int[] picture, int w, int h, double radius, int passes, double spread, int color) {
+        int[] a = new int[picture.length];
+        for (int i = 0; i < a.length; i++) {
+            a[i] = picture[i] >>> 24;
+        }
+        int r = boxRadius(radius, passes);
+        for (int p = 0; p < passes; p++) {
+            box(a, w, h, r, 0);
+        }
+        int alpha = color >>> 24;
+        int rgb = color & 0xffffff;
+        for (int i = 0; i < a.length; i++) {
+            a[i] = ((strengthen(a[i], spread) * alpha / 255) << 24) | rgb;
+        }
+        return a;
+    }
+
+    /// The shadow cast inside a picture by its own edge: what is NOT
+    /// covered, moved by an offset and blurred, kept only where the
+    /// picture is. Beyond the picture nothing is covered.
+    public static int[] innerShadow(int[] picture, int w, int h, double radius, int passes, double choke, int color,
+            int dx, int dy) {
+        int[] a = new int[picture.length];
+        for (int y = 0; y < h; y++) {
+            for (int x = 0; x < w; x++) {
+                int sx = x - dx;
+                int sy = y - dy;
+                boolean inside = sx >= 0 && sy >= 0 && sx < w && sy < h;
+                a[y * w + x] = inside ? 255 - (picture[sy * w + sx] >>> 24) : 255;
+            }
+        }
+        int r = boxRadius(radius, passes);
+        for (int p = 0; p < passes; p++) {
+            box(a, w, h, r, 255);
+        }
+        int alpha = color >>> 24;
+        int rgb = color & 0xffffff;
+        for (int i = 0; i < a.length; i++) {
+            int own = picture[i] >>> 24;
+            a[i] = ((strengthen(a[i], choke) * own / 255 * alpha / 255) << 24) | rgb;
+        }
+        return a;
+    }
+
+    private static Kept kept(Node node, Component peer) {
+        Effect effect = node.getEffect();
+        double[] values = values(effect);
+        Object cached = node.cn1EffectCache();
+        if (cached instanceof Kept) {
+            Kept k = (Kept) cached;
+            if (k.effect == effect && k.width == peer.getWidth() && k.height == peer.getHeight()
+                    && same(k.values, values)) {
+                return k;
+            }
+        }
+        Kept k = new Kept();
+        k.effect = effect;
+        k.values = values;
+        k.width = peer.getWidth();
+        k.height = peer.getHeight();
+        if (cached == null) {
+            live++;
+        }
+        // Kept before the picture is made, so that painting the peer into
+        // the picture finds it and does not start over.
+        node.cn1SetEffectCache(k);
+        build(k, node, peer);
+        return k;
+    }
+
+    private static void build(Kept k, Node node, Component peer) {
+        double scale = Units.scale();
+        double reach = 0;
+        for (int at = 0; at < 16; at += 8) {
+            if (k.values[at] != 0) {
+                reach = Math.max(reach, k.values[at + 1] * scale + 2);
+            }
+        }
+        int margin = (int) Math.ceil(reach) + 1;
+        if (node.cn1PaintMatrix() != null) {
+            // A turned or grown node paints beyond its box.
+            margin += Math.max(k.width, k.height) / 2;
+        }
+        int w = k.width + 2 * margin;
+        int h = k.height + 2 * margin;
+        if (k.width <= 0 || k.height <= 0 || (long) w * h > MAX_PIXELS) {
+            return;
+        }
+        int[] picture;
+        Node outer = building;
+        building = node;
+        try {
+            Image image = Image.createImage(w, h, 0);
+            Graphics g = image.getGraphics();
+            g.translate(margin - peer.getX(), margin - peer.getY());
+            g.setClip(peer.getX() - margin, peer.getY() - margin, w, h);
+            if (peer instanceof ParentPeer) {
+                ((ParentPeer) peer).capture(g);
+            } else if (peer instanceof NodePeer) {
+                ((NodePeer) peer).capture(g);
+            } else {
+                return;
+            }
+            // Read into an array of the size asked for: a port's picture
+            // may report another.
+            picture = new int[w * h];
+            image.getRGB(picture);
+        } catch (RuntimeException unavailable) {
+            // A port without pictures to paint into draws no shadow.
+            return;
+        } finally {
+            building = outer;
+        }
+        captures++;
+        k.margin = margin;
+        for (int at = 0; at < 16; at += 8) {
+            double[] v = k.values;
+            int color = (int) v[at + 5];
+            int dx = (int) Math.round(v[at + 3] * scale);
+            int dy = (int) Math.round(v[at + 4] * scale);
+            if (v[at] == 1 && k.behind == null) {
+                k.behind = Image.createImage(
+                        dropShadow(picture, w, h, v[at + 1] * scale, (int) v[at + 6], v[at + 2], color), w, h);
+                k.behindX = dx;
+                k.behindY = dy;
+            } else if (v[at] == 2 && k.over == null) {
+                k.over = Image.createImage(
+                        innerShadow(picture, w, h, v[at + 1] * scale, (int) v[at + 6], v[at + 2], color, dx, dy), w,
+                        h);
+            }
+        }
+    }
+
+    private static void draw(Graphics g, Component peer, Image image, int x, int y) {
+        int cx = g.getClipX();
+        int cy = g.getClipY();
+        int cw = g.getClipWidth();
+        int ch = g.getClipHeight();
+        // A shadow lies outside its node, which the node's own clip ends at.
+        PeerPaint.widenClip(g, peer);
+        g.drawImage(image, x, y);
+        g.setClip(cx, cy, cw, ch);
+    }
+
+    /// Draws what a node's effect puts behind it; called by the peer
+    /// before it paints the node.
+    static void paintBehind(Graphics g, Node node, Component peer) {
+        if (!has(node) || capturing(node)) {
+            return;
+        }
+        Kept k = kept(node, peer);
+        if (k.behind != null) {
+            draw(g, peer, k.behind, peer.getX() - k.margin + k.behindX, peer.getY() - k.margin + k.behindY);
+        }
+    }
+
+    /// Draws what a node's effect puts over it; called by the peer after
+    /// it has painted the node and everything in it.
+    static void paintOver(Graphics g, Node node, Component peer) {
+        if (!has(node) || capturing(node)) {
+            return;
+        }
+        Kept k = kept(node, peer);
+        if (k.over != null) {
+            draw(g, peer, k.over, peer.getX() - k.margin, peer.getY() - k.margin);
+        }
+    }
+
+    /// Whether the picture of this node is being made right now, when the
+    /// node is painted as it is without its effect.
+    private static boolean capturing(Node node) {
+        return building == node;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/EventDispatchChainImpl.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/EventDispatchChainImpl.java
new file mode 100644
index 00000000000..f9096bd297f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/EventDispatchChainImpl.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventDispatcher;
+
+/// The dispatch chain events travel along: an ordered list of dispatchers
+/// and the position of the next one to call.
+///
+/// Dispatching hands the event to the dispatcher at the current position
+/// together with the chain itself as the tail, moved one position on; a
+/// dispatcher that passes the event to the tail thereby reaches the next
+/// dispatcher. The position is restored when the dispatcher returns, so the
+/// chain can be dispatched through again.
+public final class EventDispatchChainImpl implements EventDispatchChain {
+
+    private final ArrayList<EventDispatcher> dispatchers = new ArrayList<EventDispatcher>();
+    private int next;
+
+    /// Creates an empty chain.
+    public EventDispatchChainImpl() {
+    }
+
+    @Override
+    public EventDispatchChain append(EventDispatcher eventDispatcher) {
+        if (eventDispatcher == null) {
+            throw new NullPointerException();
+        }
+        dispatchers.add(eventDispatcher);
+        return this;
+    }
+
+    @Override
+    public EventDispatchChain prepend(EventDispatcher eventDispatcher) {
+        if (eventDispatcher == null) {
+            throw new NullPointerException();
+        }
+        dispatchers.add(next, eventDispatcher);
+        return this;
+    }
+
+    @Override
+    public Event dispatchEvent(Event event) {
+        if (next >= dispatchers.size()) {
+            return event;
+        }
+        int position = next;
+        next = position + 1;
+        try {
+            return dispatchers.get(position).dispatchEvent(event, this);
+        } finally {
+            next = position;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/EventHandlerManager.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/EventHandlerManager.java
new file mode 100644
index 00000000000..13ade9d0339
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/EventHandlerManager.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventDispatcher;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.input.MouseEvent;
+
+/// The filters and handlers of one event target, and its stop on the
+/// dispatch chain.
+///
+/// An event travels down the chain from the window to its target, the
+/// capturing phase, in which each stop runs its filters; then back up, the
+/// bubbling phase, in which each stop runs its handlers. Consuming the
+/// event in either phase ends its journey: later stops never see it.
+/// At one stop every filter (or handler) for the event's type runs, most
+/// specific type first, the ones added with `addEventHandler` before the
+/// one set through a convenience property such as `setOnAction`; a
+/// handler consuming the event does not keep its neighbours at the same
+/// stop from running.
+///
+/// Each stop sees the event with itself as the source.
+public final class EventHandlerManager implements EventDispatcher {
+
+    private static boolean consumedByFilter;
+
+    private final Object owner;
+    private HashMap<EventType<?>, ArrayList<EventHandler<?>>> filters;
+    private HashMap<EventType<?>, ArrayList<EventHandler<?>>> handlers;
+    private HashMap<EventType<?>, ObjectProperty<?>> slots;
+
+    /// Creates the manager of an event target.
+    public EventHandlerManager(Object owner) {
+        this.owner = owner;
+    }
+
+    /// Clears the record of a filter having consumed an event.
+    public static void resetConsumedByFilter() {
+        consumedByFilter = false;
+    }
+
+    /// Returns whether an event was consumed by a filter, in the capturing
+    /// phase, since the record was last cleared.
+    public static boolean wasConsumedByFilter() {
+        return consumedByFilter;
+    }
+
+    private static HashMap<EventType<?>, ArrayList<EventHandler<?>>> add(
+            HashMap<EventType<?>, ArrayList<EventHandler<?>>> map, EventType<?> type, EventHandler<?> handler) {
+        if (type == null) {
+            throw new NullPointerException("Event type must not be null");
+        }
+        if (handler == null) {
+            throw new NullPointerException("Event handler must not be null");
+        }
+        HashMap<EventType<?>, ArrayList<EventHandler<?>>> m = map;
+        if (m == null) {
+            m = new HashMap<EventType<?>, ArrayList<EventHandler<?>>>();
+        }
+        ArrayList<EventHandler<?>> list = m.get(type);
+        if (list == null) {
+            list = new ArrayList<EventHandler<?>>();
+            m.put(type, list);
+        }
+        if (!list.contains(handler)) {
+            list.add(handler);
+        }
+        return m;
+    }
+
+    private static void remove(HashMap<EventType<?>, ArrayList<EventHandler<?>>> map, EventType<?> type,
+            EventHandler<?> handler) {
+        if (type == null) {
+            throw new NullPointerException("Event type must not be null");
+        }
+        if (handler == null) {
+            throw new NullPointerException("Event handler must not be null");
+        }
+        if (map != null) {
+            ArrayList<EventHandler<?>> list = map.get(type);
+            if (list != null) {
+                list.remove(handler);
+            }
+        }
+    }
+
+    /// Adds a handler for a type and its sub types.
+    public <T extends Event> void addEventHandler(EventType<T> type, EventHandler<? super T> handler) {
+        handlers = add(handlers, type, handler);
+    }
+
+    /// Removes a handler.
+    public <T extends Event> void removeEventHandler(EventType<T> type, EventHandler<? super T> handler) {
+        remove(handlers, type, handler);
+    }
+
+    /// Adds a filter for a type and its sub types.
+    public <T extends Event> void addEventFilter(EventType<T> type, EventHandler<? super T> filter) {
+        filters = add(filters, type, filter);
+    }
+
+    /// Removes a filter.
+    public <T extends Event> void removeEventFilter(EventType<T> type, EventHandler<? super T> filter) {
+        remove(filters, type, filter);
+    }
+
+    /// Returns the property behind a convenience handler such as
+    /// `onAction`, creating it the first time.
+    @SuppressWarnings("unchecked")
+    public <T extends Event> ObjectProperty<EventHandler<? super T>> slot(EventType<T> type, String name) {
+        if (slots == null) {
+            slots = new HashMap<EventType<?>, ObjectProperty<?>>();
+        }
+        ObjectProperty<?> existing = slots.get(type);
+        if (existing == null) {
+            existing = new SimpleObjectProperty<EventHandler<? super T>>(owner, name);
+            slots.put(type, existing);
+        }
+        return (ObjectProperty<EventHandler<? super T>>) existing;
+    }
+
+    /// Returns the convenience handler of a type, or `null`.
+    @SuppressWarnings("unchecked")
+    public <T extends Event> EventHandler<? super T> getSlot(EventType<T> type) {
+        if (slots == null) {
+            return null;
+        }
+        ObjectProperty<?> p = slots.get(type);
+        Object value = p == null ? null : p.get();
+        return value instanceof EventHandler ? (EventHandler<? super T>) value : null;
+    }
+
+    /// Sets the convenience handler of a type.
+    public <T extends Event> void setSlot(EventType<T> type, String name, EventHandler<? super T> handler) {
+        if (handler == null && (slots == null || !slots.containsKey(type))) {
+            return;
+        }
+        slot(type, name).set(handler);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private void fire(HashMap<EventType<?>, ArrayList<EventHandler<?>>> map, Event event, boolean withSlots) {
+        EventType<?> type = event.getEventType();
+        while (type != null) {
+            ArrayList<EventHandler<?>> list = map == null ? null : map.get(type);
+            if (list != null && !list.isEmpty()) {
+                EventHandler[] snapshot = list.toArray(new EventHandler[list.size()]);
+                for (int i = 0; i < snapshot.length; i++) {
+                    snapshot[i].handle(event);
+                }
+            }
+            if (withSlots && slots != null) {
+                ObjectProperty<?> p = slots.get(type);
+                Object h = p == null ? null : p.get();
+                if (h instanceof EventHandler) {
+                    ((EventHandler) h).handle(event);
+                }
+            }
+            type = type.getSuperType();
+        }
+    }
+
+    /// Returns the event as this stop delivers it: addressed to the owner,
+    /// and an entered or exited event that reached its own target typed as
+    /// the kind only the target sees.
+    private Event localize(Event event) {
+        EventTarget target = event.getTarget();
+        if (event instanceof MouseEvent && target == owner) {
+            MouseEvent mouse = (MouseEvent) event;
+            if (mouse.getEventType() == MouseEvent.MOUSE_ENTERED_TARGET) {
+                return mouse.copyFor(owner, target, MouseEvent.MOUSE_ENTERED);
+            } else if (mouse.getEventType() == MouseEvent.MOUSE_EXITED_TARGET) {
+                return mouse.copyFor(owner, target, MouseEvent.MOUSE_EXITED);
+            }
+        }
+        return event.getSource() == owner ? event : event.copyFor(owner, target);
+    }
+
+    private static void noteConsumedByFilter() {
+        consumedByFilter = true;
+    }
+
+    @Override
+    public Event dispatchEvent(Event event, EventDispatchChain tail) {
+        if (filters != null) {
+            Event capturing = localize(event);
+            fire(filters, capturing, false);
+            if (capturing.isConsumed()) {
+                noteConsumedByFilter();
+                return null;
+            }
+        }
+        Event result = tail.dispatchEvent(event);
+        if (result == null) {
+            return null;
+        }
+        if (handlers != null || slots != null) {
+            Event bubbling = localize(result);
+            fire(handlers, bubbling, true);
+            if (bubbling.isConsumed()) {
+                return null;
+            }
+        }
+        return result;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FilePicker.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FilePicker.java
new file mode 100644
index 00000000000..207de6fae68
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FilePicker.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import com.codename1.io.FileSystemStorage;
+import com.codename1.ui.Display;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+
+/// Asks the user for a file through the platform's own picker and waits
+/// for the answer, which is how a JavaFX file chooser behaves: the call
+/// returns the file or `null`.
+///
+/// Codename One's picker answers later, through a callback. The event
+/// thread keeps running on a nested loop meanwhile, as it does for a
+/// window shown with `showAndWait()`.
+public final class FilePicker {
+
+    private static Source source;
+
+    private FilePicker() {
+    }
+
+    /// What answers in place of the platform's picker.
+    public interface Source {
+        /// Returns the path chosen for a list of extensions, or `null` for
+        /// a user who cancelled.
+        String choose(String accept);
+    }
+
+    /// Puts something in place of the platform's picker, or with `null`
+    /// the picker back. A test has no user to choose a file.
+    public static void setSource(Source value) {
+        source = value;
+    }
+
+    /// Returns the path of the file the user chose, as the file system of
+    /// Codename One names it, or `null` when the user cancelled. `accept`
+    /// is a comma separated list of extensions, or `null` for any file.
+    public static String open(String accept) {
+        Source s = source;
+        if (s != null) {
+            return s.choose(accept);
+        }
+        if (!Display.isInitialized()) {
+            return null;
+        }
+        final String[] chosen = new String[1];
+        final AtomicBoolean answered = new AtomicBoolean();
+        Display.getInstance().openFileChooser(new ActionListener<ActionEvent>() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                Object path = evt == null ? null : evt.getSource();
+                if (path instanceof String) {
+                    chosen[0] = (String) path;
+                }
+                answered.set(true);
+            }
+        }, accept);
+        Display.getInstance().invokeAndBlock(new Runnable() {
+            @Override
+            public void run() {
+                while (!answered.get()) {
+                    try {
+                        Thread.sleep(20);
+                    } catch (InterruptedException interrupted) {
+                        return;
+                    }
+                }
+            }
+        });
+        return chosen[0];
+    }
+
+    /// Returns the directory the application may write to, which is where
+    /// a file to save goes when there is no picker to ask.
+    public static String home() {
+        if (!Display.isInitialized()) {
+            return "";
+        }
+        String home = FileSystemStorage.getInstance().getAppHomePath();
+        return home == null ? "" : home;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FontFiles.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FontFiles.java
new file mode 100644
index 00000000000..8c5ee5a7230
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FontFiles.java
@@ -0,0 +1,438 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.impl.compat.Resources;
+import com.codename1.ui.Font;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// The font files an application carries and has loaded: what
+/// `Font.loadFont` and a style sheet's `@font-face` register, and what a
+/// family name is looked up in before the platform's own faces.
+///
+/// A platform opens a font file by the name of the FILE, which is the flat
+/// name the build shipped the resource under, and -- on iOS -- by the name
+/// the font gives ITSELF, which only the file says. So a face is read
+/// here: the `name` table gives the family, the style, the full name and
+/// the PostScript name, and the `OS/2` table the weight and the slant. The
+/// names are what `Font.getFamily()` and `Font.getName()` then answer, as
+/// in JavaFX, and what a style sheet's `-fx-font-family` is matched
+/// against.
+///
+/// A port that cannot open a font file, or a file that is not at the root
+/// of the bundle under a name ending in `.ttf`, leaves the face without a
+/// native font; text in it is drawn with the system face of its weight.
+public final class FontFiles {
+
+    /// One face of one font file.
+    public static final class Face {
+        private final String family;
+        private final String style;
+        private final String fullName;
+        private final String postScriptName;
+        private final int weight;
+        private final boolean italic;
+        private String file;
+        private Font base;
+        private boolean failed;
+
+        Face(String family, String style, String fullName, String postScriptName, int weight, boolean italic) {
+            this.family = family;
+            this.style = style;
+            this.fullName = fullName;
+            this.postScriptName = postScriptName;
+            this.weight = weight;
+            this.italic = italic;
+        }
+
+        /// The family, `Clear Sans`.
+        public String family() {
+            return family;
+        }
+
+        /// The style, `Bold Italic`.
+        public String style() {
+            return style;
+        }
+
+        /// The full name, `Clear Sans Bold`.
+        public String fullName() {
+            return fullName;
+        }
+
+        /// The name the font is installed under, `ClearSans-Bold`.
+        public String postScriptName() {
+            return postScriptName;
+        }
+
+        /// The weight, 100 to 900.
+        public int weight() {
+            return weight;
+        }
+
+        /// Whether the face is slanted.
+        public boolean italic() {
+            return italic;
+        }
+
+        /// The flat name of the file in the bundle, or `null` for a face
+        /// that came from a stream no resource could be matched to.
+        public String file() {
+            return file;
+        }
+
+        /// The platform's font of this file, at no particular size; `null`
+        /// where the platform cannot open it.
+        Font base() {
+            if (base == null && !failed) {
+                failed = true;
+                if (file != null && file.indexOf('/') < 0 && file.endsWith(".ttf") && Font.isTrueTypeFileSupported()) {
+                    try {
+                        base = Font.createTrueTypeFont(postScriptName, file);
+                    } catch (RuntimeException unavailable) {
+                        // The platform refused the file: the system face is
+                        // drawn instead, which is what a missing font gets.
+                        base = null;
+                    }
+                }
+            }
+            return base;
+        }
+    }
+
+    private static final HashMap<String, Face> BY_PATH = new HashMap<String, Face>();
+    private static final HashMap<String, ArrayList<Face>> BY_NAME = new HashMap<String, ArrayList<Face>>();
+    private static boolean scanned;
+
+    private FontFiles() {
+    }
+
+    static String fold(String s) {
+        StringBuilder out = new StringBuilder(s.length());
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            out.append(c >= 'A' && c <= 'Z' ? (char) (c + 32) : c);
+        }
+        return out.toString().trim();
+    }
+
+    private static int u16(byte[] d, int at) {
+        return ((d[at] & 0xff) << 8) | (d[at + 1] & 0xff);
+    }
+
+    private static int u32(byte[] d, int at) {
+        return (u16(d, at) << 16) | u16(d, at + 2);
+    }
+
+    private static boolean word(String style, String word) {
+        return fold(style).indexOf(word) >= 0;
+    }
+
+    /// Reads the names, the weight and the slant out of a TrueType or
+    /// OpenType file (the first face of a collection). Answers `null` for
+    /// bytes that are no such file.
+    public static Face parse(byte[] d) {
+        if (d == null || d.length < 12) {
+            return null;
+        }
+        int base = 0;
+        int magic = u32(d, 0);
+        if (magic == 0x74746366) {
+            // 'ttcf': a collection; the first face's directory.
+            if (d.length < 16) {
+                return null;
+            }
+            base = u32(d, 12);
+            if (base < 0 || base + 12 > d.length) {
+                return null;
+            }
+            magic = u32(d, base);
+        }
+        if (magic != 0x00010000 && magic != 0x4f54544f && magic != 0x74727565) {
+            return null;
+        }
+        int tables = u16(d, base + 4);
+        int nameAt = -1;
+        int os2At = -1;
+        for (int i = 0; i < tables; i++) {
+            int entry = base + 12 + 16 * i;
+            if (entry + 16 > d.length) {
+                return null;
+            }
+            int tag = u32(d, entry);
+            int offset = u32(d, entry + 8);
+            if (tag == 0x6e616d65) {
+                nameAt = offset;
+            } else if (tag == 0x4f532f32) {
+                os2At = offset;
+            }
+        }
+        if (nameAt < 0 || nameAt + 6 > d.length) {
+            return null;
+        }
+        int count = u16(d, nameAt + 2);
+        int strings = nameAt + u16(d, nameAt + 4);
+        // Per name id: the string, and how good its record was. A Windows
+        // Unicode record in English beats any other Unicode one, which
+        // beats a Macintosh Roman one.
+        String[] found = new String[18];
+        int[] rank = new int[18];
+        for (int i = 0; i < count; i++) {
+            int record = nameAt + 6 + 12 * i;
+            if (record + 12 > d.length) {
+                break;
+            }
+            int platform = u16(d, record);
+            int encoding = u16(d, record + 2);
+            int language = u16(d, record + 4);
+            int id = u16(d, record + 6);
+            int length = u16(d, record + 8);
+            int at = strings + u16(d, record + 10);
+            if (id >= found.length || at < 0 || at + length > d.length) {
+                continue;
+            }
+            boolean wide = platform == 0 || (platform == 3 && (encoding == 0 || encoding == 1 || encoding == 10));
+            boolean roman = platform == 1 && encoding == 0;
+            if (!wide && !roman) {
+                continue;
+            }
+            int r = wide ? (platform == 3 && language == 0x409 ? 3 : 2) : 1;
+            if (r <= rank[id]) {
+                continue;
+            }
+            StringBuilder s = new StringBuilder();
+            if (wide) {
+                for (int k = 0; k + 1 < length; k += 2) {
+                    s.append((char) u16(d, at + k));
+                }
+            } else {
+                for (int k = 0; k < length; k++) {
+                    int b = d[at + k] & 0xff;
+                    s.append(b < 0x80 ? (char) b : '?');
+                }
+            }
+            if (s.length() > 0) {
+                found[id] = s.toString();
+                rank[id] = r;
+            }
+        }
+        // 16 and 17 are the family and style a font with more than four
+        // styles gives besides the four-style names 1 and 2; JavaFX
+        // reports 1 and 2, and so does this.
+        String family = found[1] != null ? found[1] : found[16];
+        String full = found[4];
+        if (family == null) {
+            family = full;
+        }
+        if (family == null) {
+            return null;
+        }
+        String style = found[2] != null ? found[2] : (found[17] != null ? found[17] : "Regular");
+        if (full == null) {
+            full = "Regular".equals(style) ? family : family + " " + style;
+        }
+        String postScript = found[6] != null ? found[6] : full;
+        int weight = -1;
+        boolean italic = word(style, "italic") || word(style, "oblique");
+        if (os2At >= 0 && os2At + 64 <= d.length) {
+            weight = u16(d, os2At + 4);
+            italic = italic || (u16(d, os2At + 62) & 1) != 0;
+        }
+        if (weight < 1 || weight > 1000) {
+            weight = word(style, "black") || word(style, "heavy") ? 900
+                    : (word(style, "bold") ? 700 : (word(style, "light") ? 300 : (word(style, "thin") ? 100 : 400)));
+        }
+        return new Face(family, style, full, postScript, weight, italic);
+    }
+
+    private static void file(String name, Face face) {
+        if (name == null) {
+            return;
+        }
+        String key = fold(name);
+        ArrayList<Face> faces = BY_NAME.get(key);
+        if (faces == null) {
+            faces = new ArrayList<Face>();
+            BY_NAME.put(key, faces);
+        }
+        for (int i = 0; i < faces.size(); i++) {
+            if (faces.get(i) == face) {
+                return;
+            }
+        }
+        faces.add(face);
+    }
+
+    private static void register(Face face) {
+        if (BY_NAME.get(fold(face.fullName)) == null || BY_NAME.get(fold(face.family)) == null) {
+            // Text already drawn in this family got the system face.
+            Fonts.flush();
+        }
+        file(face.family, face);
+        file(face.fullName, face);
+        file(face.postScriptName, face);
+    }
+
+    /// Loads the font file at a resource path (no leading slash) and
+    /// registers it under its names. Answers `null` when the application
+    /// ships no such resource or it is not a font.
+    public static Face load(String path) {
+        Face known = BY_PATH.get(path);
+        if (known != null) {
+            register(known);
+            return known;
+        }
+        Face face = read(path);
+        if (face != null) {
+            register(face);
+        }
+        return face;
+    }
+
+    /// Reads a font resource without registering it.
+    private static Face read(String path) {
+        Face known = BY_PATH.get(path);
+        if (known != null) {
+            return known;
+        }
+        InputStream in = Resources.open(path);
+        if (in == null) {
+            return null;
+        }
+        Face face;
+        try {
+            face = parse(ResourceUrls.readAll(in));
+        } catch (IOException unreadable) {
+            face = null;
+        }
+        close(in);
+        if (face != null) {
+            face.file = ResourceNames.flatName(path);
+            BY_PATH.put(path, face);
+        }
+        return face;
+    }
+
+    private static void close(InputStream in) {
+        try {
+            in.close();
+        } catch (IOException ignored) {
+            // Nothing to do about a stream that will not close.
+            return;
+        }
+    }
+
+    /// Loads the font file a URL string names; see [#load(String)].
+    public static Face loadUrl(String url) {
+        String path = ResourceUrls.find(url);
+        return path == null ? null : load(path);
+    }
+
+    private static boolean isFontPath(String path) {
+        int n = path.length();
+        return n > 4 && (path.regionMatches(true, n - 4, ".ttf", 0, 4) || path.regionMatches(true, n - 4, ".otf", 0, 4)
+                || path.regionMatches(true, n - 4, ".ttc", 0, 4));
+    }
+
+    /// Registers the font whose bytes these are. A stream carries no name,
+    /// and a platform opens a font by its file, so the file is found by
+    /// reading the application's font resources for the one that names
+    /// itself the same way. With none, the face is registered without a
+    /// file and drawn with the system font. Answers `null` for bytes that
+    /// are no font.
+    public static Face loadBytes(byte[] data) {
+        Face parsed = parse(data);
+        if (parsed == null) {
+            return null;
+        }
+        if (!scanned) {
+            scanned = true;
+            String[] paths = Resources.cn1ResourcePaths();
+            for (int i = 0; i < paths.length; i++) {
+                if (isFontPath(paths[i])) {
+                    read(paths[i]);
+                }
+            }
+        }
+        for (Face candidate : BY_PATH.values()) {
+            if (candidate.postScriptName.equals(parsed.postScriptName) && candidate.fullName.equals(parsed.fullName)) {
+                register(candidate);
+                return candidate;
+            }
+        }
+        ArrayList<Face> same = BY_NAME.get(fold(parsed.fullName));
+        if (same != null) {
+            for (int i = 0; i < same.size(); i++) {
+                if (same.get(i).postScriptName.equals(parsed.postScriptName)) {
+                    return same.get(i);
+                }
+            }
+        }
+        register(parsed);
+        return parsed;
+    }
+
+    /// Makes a loaded face answer to one more family name, the one an
+    /// `@font-face` rule declares it as.
+    public static void alias(String family, Face face) {
+        if (face != null) {
+            file(family, face);
+        }
+    }
+
+    /// The loaded face a name asks for: `name` is a family, a full name or
+    /// a PostScript name, compared without regard to ASCII case, and among
+    /// the faces that answer to it the one nearest the weight and slant
+    /// wins. `null` when no loaded font answers to the name.
+    public static Face find(String name, int weight, boolean italic) {
+        if (name == null || BY_NAME.isEmpty()) {
+            return null;
+        }
+        ArrayList<Face> faces = BY_NAME.get(fold(name));
+        if (faces == null) {
+            return null;
+        }
+        Face best = null;
+        int bestScore = Integer.MAX_VALUE;
+        for (int i = 0; i < faces.size(); i++) {
+            Face f = faces.get(i);
+            int score = Math.abs(f.weight - weight) + (f.italic == italic ? 0 : 1000);
+            if (score < bestScore) {
+                best = f;
+                bestScore = score;
+            }
+        }
+        return best;
+    }
+
+    /// Forgets every loaded font. For tests.
+    public static void reset() {
+        BY_PATH.clear();
+        BY_NAME.clear();
+        scanned = false;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FontStyles.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FontStyles.java
new file mode 100644
index 00000000000..8ff68911589
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FontStyles.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+
+import javafx.scene.text.Font;
+import javafx.scene.text.FontPosture;
+import javafx.scene.text.FontWeight;
+
+/// What nodes that show text share when they are styled and measured:
+/// the `-fx-font...` names, keyword values and the breaking of text into
+/// lines.
+public final class FontStyles {
+
+    private FontStyles() {
+    }
+
+    /// Returns whether a style name is one of `-fx-font`,
+    /// `-fx-font-size`, `-fx-font-family`, `-fx-font-weight` and
+    /// `-fx-font-style`.
+    public static boolean isFontProperty(String property) {
+        return "-fx-font".equals(property) || "-fx-font-size".equals(property)
+                || "-fx-font-family".equals(property) || "-fx-font-weight".equals(property)
+                || "-fx-font-style".equals(property);
+    }
+
+    private static FontWeight weight(Object value) {
+        if (value instanceof FontWeight) {
+            return (FontWeight) value;
+        } else if (value instanceof Number) {
+            return FontWeight.findByWeight(((Number) value).intValue());
+        } else if (value instanceof String) {
+            return FontWeight.findByName(((String) value).trim());
+        }
+        return null;
+    }
+
+    private static FontPosture posture(Object value) {
+        if (value instanceof FontPosture) {
+            return (FontPosture) value;
+        } else if (value instanceof String) {
+            String s = ((String) value).trim();
+            if ("italic".equalsIgnoreCase(s) || "oblique".equalsIgnoreCase(s)) {
+                return FontPosture.ITALIC;
+            } else if ("normal".equalsIgnoreCase(s) || "regular".equalsIgnoreCase(s)) {
+                return FontPosture.REGULAR;
+            }
+        }
+        return null;
+    }
+
+    /// Returns a font with one styled attribute replaced: the font itself
+    /// for `-fx-font` (a `Font`), or the base font with another size
+    /// (`Number`), family (`String`), weight (`FontWeight`, a `Number`
+    /// from 100 to 900 or a keyword) or posture (`FontPosture` or a
+    /// keyword). Answers `null` when the value does not suit the name.
+    public static Font apply(Font base, String property, Object value) {
+        if (value instanceof Font) {
+            return (Font) value;
+        }
+        Font from = base == null ? Font.getDefault() : base;
+        FontWeight w = from.cn1Weight();
+        FontPosture p = from.cn1Posture();
+        String family = from.getFamily();
+        double size = from.getSize();
+        if ("-fx-font-size".equals(property) && value instanceof Number) {
+            size = ((Number) value).doubleValue();
+        } else if ("-fx-font-family".equals(property) && value instanceof String) {
+            family = (String) value;
+        } else if ("-fx-font-weight".equals(property) && weight(value) != null) {
+            w = weight(value);
+        } else if ("-fx-font-style".equals(property) && posture(value) != null) {
+            p = posture(value);
+        } else {
+            return null;
+        }
+        return Font.font(family, w, p, size);
+    }
+
+    /// Returns the constant a style value stands for: the value itself
+    /// when it is one of the constants, or the constant whose name is the
+    /// keyword, compared without regard to ASCII case and with `-` for
+    /// `_` (`"round"`, `"space-between"`). Answers `null` otherwise.
+    public static Object keyword(Enum<?>[] constants, Object value) {
+        for (int i = 0; i < constants.length; i++) {
+            if (constants[i] == value) {
+                return constants[i];
+            }
+        }
+        if (value instanceof String) {
+            String wanted = ((String) value).trim().replace('-', '_');
+            for (int i = 0; i < constants.length; i++) {
+                if (constants[i].name().equalsIgnoreCase(wanted)) {
+                    return constants[i];
+                }
+            }
+        }
+        return null;
+    }
+
+    private static void wrap(String paragraph, Font font, double width, ArrayList<String> out) {
+        if (!(width > 0) || Fonts.width(font, paragraph) <= width) {
+            out.add(paragraph);
+            return;
+        }
+        int n = paragraph.length();
+        int lineStart = 0;
+        while (lineStart < n) {
+            // The longest run of whole words that fits; a word that does
+            // not fit on a line of its own is cut where it does.
+            int end = lineStart;
+            int lastBreak = -1;
+            while (end < n) {
+                char c = paragraph.charAt(end);
+                if (c == ' ' && end > lineStart) {
+                    lastBreak = end;
+                }
+                if (end > lineStart && Fonts.width(font, paragraph.substring(lineStart, end + 1)) > width) {
+                    break;
+                }
+                end++;
+            }
+            if (end >= n) {
+                out.add(paragraph.substring(lineStart));
+                return;
+            }
+            int cut = lastBreak > lineStart ? lastBreak : end;
+            out.add(paragraph.substring(lineStart, cut));
+            lineStart = cut;
+            while (lineStart < n && paragraph.charAt(lineStart) == ' ') {
+                lineStart++;
+            }
+        }
+    }
+
+    /// Breaks text into lines: at every line feed, and, with a wrapping
+    /// width above zero, between words wherever a line would be wider.
+    /// There is always at least one line; `null` text is one empty line.
+    public static String[] lines(String text, Font font, double wrappingWidth) {
+        ArrayList<String> out = new ArrayList<String>();
+        String t = text == null ? "" : text;
+        int start = 0;
+        while (true) {
+            int feed = t.indexOf('\n', start);
+            String paragraph = feed < 0 ? t.substring(start) : t.substring(start, feed);
+            if (paragraph.length() > 0 && paragraph.charAt(paragraph.length() - 1) == '\r') {
+                paragraph = paragraph.substring(0, paragraph.length() - 1);
+            }
+            wrap(paragraph, font, wrappingWidth, out);
+            if (feed < 0) {
+                break;
+            }
+            start = feed + 1;
+        }
+        String[] result = new String[out.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = out.get(i);
+        }
+        return result;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Fonts.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Fonts.java
new file mode 100644
index 00000000000..c55fecba1f5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Fonts.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.HashMap;
+
+import com.codename1.ui.Font;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+
+/// Turns a JavaFX font description into the Codename One font that draws
+/// it, and measures text with it in logical pixels.
+///
+/// A font size is converted to device pixels here rather than scaled by a
+/// transform when drawing, so glyphs are rasterised at their real size.
+/// Fonts are cached per description and scale.
+public final class Fonts {
+
+    private static final HashMap<String, Font> CACHE = new HashMap<String, Font>();
+    private static double cacheScale;
+
+    private Fonts() {
+    }
+
+    private static boolean isAsciiName(String family, String expected) {
+        return family != null && family.equalsIgnoreCase(expected);
+    }
+
+    /// Returns the native font of a family, a weight from 100 to 900, a
+    /// posture and a size in logical pixels.
+    public static Font create(String family, int weight, boolean italic, double size) {
+        double scale = Units.scale();
+        if (Double.compare(scale, cacheScale) != 0) {
+            CACHE.clear();
+            OVERHANG.clear();
+            cacheScale = scale;
+        }
+        String key = family + '|' + weight + '|' + italic + '|' + size;
+        Font cached = CACHE.get(key);
+        if (cached != null) {
+            return cached;
+        }
+        float pixels = (float) Math.max(1, size * scale);
+        Font font = null;
+        int style = (weight >= 600 ? Font.STYLE_BOLD : Font.STYLE_PLAIN) | (italic ? Font.STYLE_ITALIC : 0);
+        // A font file the application loaded answers to its names before
+        // any face of the platform does.
+        FontFiles.Face loaded = FontFiles.find(family, weight, italic);
+        if (loaded != null) {
+            Font base = loaded.base();
+            if (base != null) {
+                try {
+                    font = base.derive(pixels, Font.STYLE_PLAIN);
+                } catch (RuntimeException unavailable) {
+                    font = null;
+                }
+            }
+        }
+        if (font == null && (Font.isNativeFontSchemeSupported() || Font.isTrueTypeFileSupported())) {
+            String face;
+            if (isAsciiName(family, "Monospaced") || isAsciiName(family, "Monospace")
+                    || isAsciiName(family, "Courier New")) {
+                face = null;
+            } else if (weight >= 800) {
+                face = italic ? "native:ItalicBlack" : "native:MainBlack";
+            } else if (weight >= 600) {
+                face = italic ? "native:ItalicBold" : "native:MainBold";
+            } else if (weight <= 200) {
+                face = italic ? "native:ItalicThin" : "native:MainThin";
+            } else if (weight <= 300) {
+                face = italic ? "native:ItalicLight" : "native:MainLight";
+            } else {
+                face = italic ? "native:ItalicRegular" : "native:MainRegular";
+            }
+            if (face != null) {
+                try {
+                    Font base = Font.createTrueTypeFont(face, face);
+                    if (base != null) {
+                        font = base.derive(pixels, Font.STYLE_PLAIN);
+                    }
+                } catch (RuntimeException unavailable) {
+                    font = null;
+                }
+            }
+        }
+        if (font == null) {
+            int face = isAsciiName(family, "Monospaced") || isAsciiName(family, "Monospace")
+                    || isAsciiName(family, "Courier New") ? Font.FACE_MONOSPACE : Font.FACE_SYSTEM;
+            int sizeClass = pixels < 14 * scale ? Font.SIZE_SMALL
+                    : (pixels > 20 * scale ? Font.SIZE_LARGE : Font.SIZE_MEDIUM);
+            font = Font.createSystemFont(face, style, sizeClass);
+        }
+        CACHE.put(key, font);
+        return font;
+    }
+
+    /// Forgets every cached font, so a family is looked up again: a font
+    /// file loaded after a text was first drawn in its family takes over.
+    public static void flush() {
+        CACHE.clear();
+        OVERHANG.clear();
+    }
+
+    private static final HashMap<Font, HashMap<Character, Integer>> OVERHANG =
+            new HashMap<Font, HashMap<Character, Integer>>();
+
+    /// Returns how far the ink of the last character of a text reaches
+    /// past the width the text measures, in device pixels; 0 for a font
+    /// that is not italic.
+    ///
+    /// The width of a text is the sum of the advances of its characters,
+    /// and an italic leans past its own: the top of an `l` or a `d` is
+    /// drawn to the right of where the next character would start. A
+    /// native label clips its text to the room it measured, so a label
+    /// exactly as wide as its text lost the top of such a last letter. A
+    /// font does not say how far its glyphs lean, so the character is
+    /// drawn once and looked at; the answer is kept per font and
+    /// character.
+    public static int overhang(javafx.scene.text.Font font, String text) {
+        if (font == null || text == null || font.cn1Posture() != javafx.scene.text.FontPosture.ITALIC) {
+            return 0;
+        }
+        int end = text.length();
+        if (end == 0 || text.charAt(end - 1) <= ' ') {
+            return 0;
+        }
+        Font f = of(font);
+        Character last = Character.valueOf(text.charAt(end - 1));
+        HashMap<Character, Integer> known = OVERHANG.get(f);
+        if (known == null) {
+            known = new HashMap<Character, Integer>();
+            OVERHANG.put(f, known);
+        }
+        Integer kept = known.get(last);
+        if (kept == null) {
+            kept = Integer.valueOf(inkPastAdvance(f, last.charValue()));
+            known.put(last, kept);
+        }
+        return kept.intValue();
+    }
+
+    /// Draws a character in white on black and answers how many columns
+    /// right of its advance hold any of it. A glyph leans by less than it
+    /// is tall, which is the room it is given.
+    private static int inkPastAdvance(Font f, char c) {
+        int advance = f.charWidth(c);
+        int height = f.getHeight();
+        if (advance <= 0 || height <= 0) {
+            return 0;
+        }
+        int width = advance + height;
+        Image picture = Image.createImage(width, height, 0xff000000);
+        Graphics g = picture.getGraphics();
+        g.setClip(0, 0, width, height);
+        g.setFont(f);
+        g.setColor(0xffffff);
+        g.drawString(String.valueOf(c), 0, 0);
+        int[] rgb = picture.getRGB();
+        if (rgb == null || rgb.length < width * height) {
+            return 0;
+        }
+        for (int x = width - 1; x >= advance; x--) {
+            for (int y = 0; y < height; y++) {
+                // The faintest edge of an antialiased stroke is not worth
+                // a column of its own.
+                if ((rgb[y * width + x] & 0xff) > 0x30) {
+                    return x + 1 - advance;
+                }
+            }
+        }
+        return 0;
+    }
+
+    /// Returns whether a native font came from the cache of the current
+    /// scale, so it is still the right size.
+    public static boolean isCurrent(Object nativeFont) {
+        return Double.compare(cacheScale, Units.scale()) == 0 && nativeFont instanceof Font && CACHE.containsValue(nativeFont);
+    }
+
+    /// Returns the native font of a JavaFX font, the default font for
+    /// `null`.
+    public static Font of(javafx.scene.text.Font font) {
+        javafx.scene.text.Font f = font == null ? javafx.scene.text.Font.getDefault() : font;
+        Object n = f.cn1Native();
+        return n instanceof Font ? (Font) n : Font.getDefaultFont();
+    }
+
+    /// Returns the width of a text in logical pixels.
+    public static double width(javafx.scene.text.Font font, String text) {
+        if (text == null || text.length() == 0) {
+            return 0;
+        }
+        return Units.toLogical(of(font).stringWidth(text));
+    }
+
+    /// Returns the height of a line in logical pixels.
+    public static double lineHeight(javafx.scene.text.Font font) {
+        return Units.toLogical(of(font).getHeight());
+    }
+
+    /// Returns the distance from the top of a line to its baseline in
+    /// logical pixels.
+    public static double ascent(javafx.scene.text.Font font) {
+        Font f = of(font);
+        int ascent = f.getAscent();
+        if (ascent <= 0) {
+            ascent = f.getHeight() - Math.max(0, f.getDescent());
+        }
+        return Units.toLogical(ascent);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FrameClock.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FrameClock.java
new file mode 100644
index 00000000000..ee9bc6761f2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FrameClock.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.animations.Animation;
+
+/// The one frame clock of the JavaFX animation classes, the role of the
+/// JavaFX pulse: every running animation and animation timer is called
+/// once per frame with the time of that frame.
+///
+/// Codename One only ticks the animations registered with the form on
+/// screen, so the clock registers a single Codename One animation with
+/// the current form while something is running and removes it when the
+/// last receiver leaves; an idle application costs nothing. A receiver is
+/// commonly added before any form is shown, and forms change, so the
+/// stage hosts call [#ensureCurrent()] whenever they are laid out.
+///
+/// Tests switch the clock to manual mode ([#setManual(boolean)]): time
+/// then stands still until [#advance(long)] moves it and delivers one
+/// pulse, so a test states the exact time of every frame and never
+/// sleeps.
+public final class FrameClock {
+
+    /// A receiver of frames.
+    public interface Pulse {
+
+        /// Called once per frame with the time of the frame in
+        /// nanoseconds. The origin of the time is arbitrary; only
+        /// differences mean something.
+        void pulse(long nowNanos);
+    }
+
+    private static final ArrayList<Pulse> PULSES = new ArrayList<Pulse>();
+    private static Form form;
+    private static boolean manual;
+    private static long manualNanos;
+    private static final Animation TICK = new Animation() {
+        @Override
+        public boolean animate() {
+            if (!manual) {
+                tick();
+            }
+            return false;
+        }
+
+        @Override
+        public void paint(Graphics g) {
+        }
+    };
+
+    private FrameClock() {
+    }
+
+    /// Adds a receiver; adding one twice has no effect.
+    public static void add(Pulse pulse) {
+        if (!PULSES.contains(pulse)) {
+            PULSES.add(pulse);
+        }
+        ensureCurrent();
+    }
+
+    /// Removes a receiver. It is not called again, not even by a frame
+    /// that is being delivered.
+    public static void remove(Pulse pulse) {
+        PULSES.remove(pulse);
+        if (PULSES.isEmpty()) {
+            unregister();
+        }
+    }
+
+    /// Returns whether any receiver is registered.
+    public static boolean isActive() {
+        return !PULSES.isEmpty();
+    }
+
+    /// Returns the current time in nanoseconds: the time the last manual
+    /// advance reached in manual mode, the system's otherwise.
+    public static long nowNanos() {
+        return manual ? manualNanos : System.nanoTime();
+    }
+
+    /// Switches manual mode on or off. In manual mode nothing but
+    /// [#advance(long)] moves time or delivers a frame.
+    public static void setManual(boolean value) {
+        manual = value;
+        if (value) {
+            unregister();
+        } else {
+            ensureCurrent();
+        }
+    }
+
+    /// Returns whether the clock is in manual mode.
+    public static boolean isManual() {
+        return manual;
+    }
+
+    /// Moves manual time forward and delivers one frame at the new time.
+    public static void advance(long millis) {
+        if (!manual) {
+            throw new IllegalStateException("The frame clock is not in manual mode");
+        }
+        if (millis < 0) {
+            throw new IllegalArgumentException("Time does not run backwards");
+        }
+        manualNanos += millis * 1000000L;
+        tick();
+    }
+
+    /// Drops every receiver and leaves manual mode; for the end of a test.
+    public static void reset() {
+        PULSES.clear();
+        unregister();
+        manual = false;
+        // Manual time starts over too: what a frame shows depends on the
+        // time it is given, and a test must not inherit the last one's.
+        manualNanos = 0;
+    }
+
+    /// Moves the clock to the form on screen when it is not there
+    /// already.
+    public static void ensureCurrent() {
+        if (PULSES.isEmpty() || manual || !Display.isInitialized()) {
+            return;
+        }
+        Form current = Display.getInstance().getCurrent();
+        if (current == form) {
+            return;
+        }
+        unregister();
+        form = current;
+        if (form != null) {
+            form.registerAnimated(TICK);
+        }
+    }
+
+    private static void unregister() {
+        if (form != null) {
+            form.deregisterAnimated(TICK);
+            form = null;
+        }
+    }
+
+    private static void tick() {
+        long now = nowNanos();
+        Pulse[] snapshot = PULSES.toArray(new Pulse[PULSES.size()]);
+        for (int i = 0; i < snapshot.length; i++) {
+            if (PULSES.contains(snapshot[i])) {
+                snapshot[i].pulse(now);
+            }
+        }
+        if (PULSES.isEmpty()) {
+            unregister();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxBoolean.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxBoolean.java
new file mode 100644
index 00000000000..02db8408b81
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxBoolean.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.beans.property.SimpleBooleanProperty;
+
+/// A boolean property that tells its owner what its change makes stale.
+public class FxBoolean extends SimpleBooleanProperty {
+
+    private final Dirty.Owner owner;
+    private final int what;
+
+    /// Creates the property of an owner.
+    public FxBoolean(Dirty.Owner owner, String name, boolean initial, int what) {
+        super(owner, name, initial);
+        this.owner = owner;
+        this.what = what;
+    }
+
+    @Override
+    protected void invalidated() {
+        owner.cn1Invalidated(what);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxDouble.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxDouble.java
new file mode 100644
index 00000000000..5be725b304d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxDouble.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.beans.property.SimpleDoubleProperty;
+
+/// A double property that tells its owner what its change makes stale.
+public class FxDouble extends SimpleDoubleProperty {
+
+    private final Dirty.Owner owner;
+    private final int what;
+
+    /// Creates the property of an owner.
+    public FxDouble(Dirty.Owner owner, String name, double initial, int what) {
+        super(owner, name, initial);
+        this.owner = owner;
+        this.what = what;
+    }
+
+    @Override
+    protected void invalidated() {
+        owner.cn1Invalidated(what);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxLifecycle.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxLifecycle.java
new file mode 100644
index 00000000000..c5f9b375f34
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxLifecycle.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.generated.compat.CompatRegistry;
+import com.codename1.io.Log;
+import com.codename1.system.Lifecycle;
+import com.codename1.ui.Display;
+
+import javafx.application.Application;
+import javafx.stage.Stage;
+
+/// The Codename One lifecycle of a JavaFX application.
+///
+/// #### Contract
+///
+/// The application's Codename One main class -- the class
+/// `codename1.packageName` and `codename1.mainName` name, an ordinary source
+/// file of the project -- extends this class and implements one method.
+/// `cn1:import-desktop-project` writes that class:
+///
+/// ```java
+/// public class MyApp extends FxLifecycle {
+///     protected Application createApplication() {
+///         return new com.example.MyFxApp();
+///     }
+/// }
+/// ```
+///
+/// Extending this class is what makes the JavaFX stages THE application:
+/// [#runApp()] installs the [StageHosts#setExitHook(Runnable)] hook that
+/// exits it. A Codename One application that only uses some JavaFX scenes
+/// (library mode) has a main class that does not extend it, and the last
+/// stage closing returns to the form it was shown over.
+///
+/// Codename One then drives it as any `Lifecycle`:
+///
+/// - `init(Object)`: the inherited behaviour (theme, network error
+///   handling); nothing JavaFX runs yet.
+/// - `start()`, the first time: on the event dispatch thread, which is
+///   the JavaFX application thread, the application's resources are
+///   installed (`CompatRegistry.cn1Install()`), [#createApplication()] is called once,
+///   then `Application.init()`, then `Application.start(Stage)` with a
+///   new primary stage. The stage is a form (see [StageHosts]); the
+///   application shows it by calling `Stage.show()`.
+/// - `start()`, after a `stop()`: the form that was showing is shown
+///   again; the application is not restarted.
+/// - `stop()`: the inherited behaviour, remembering the current form.
+/// - `destroy()`: `Application.stop()` is called, once.
+///
+/// `Platform.exit()`, and the last window closing while
+/// `Platform.isImplicitExit()`, call `Application.stop()` once and then
+/// `Display.exitApplication()`.
+///
+/// An exception from `init`, `start` or `stop` is logged and rethrown as
+/// a `RuntimeException`. `Application.launch` is not used: there is no
+/// `main` method on a device, and no reflection to find the class with.
+/// The application's `main` is never called, and `launch` does nothing
+/// when something else calls it. `Application.getParameters()` answers
+/// empty parameters.
+public abstract class FxLifecycle extends Lifecycle {
+
+    private Application application;
+    private Stage primaryStage;
+    private boolean stopped;
+
+    /// Creates the application; called once, on the event dispatch thread.
+    protected abstract Application createApplication();
+
+    /// Returns the application, or `null` before the first `start()`.
+    public final Application getApplication() {
+        return application;
+    }
+
+    /// Returns the primary stage, or `null` before the first `start()`.
+    public final Stage getPrimaryStage() {
+        return primaryStage;
+    }
+
+    @Override
+    public void runApp() {
+        // Before any application code: its resources and bundles.
+        CompatRegistry.cn1Install();
+        application = createApplication();
+        if (application == null) {
+            throw new IllegalStateException("createApplication() answered null");
+        }
+        stopped = false;
+        StageHosts.setExitHook(new Runnable() {
+            @Override
+            public void run() {
+                stopApplication();
+                if (Display.isInitialized()) {
+                    Display.getInstance().exitApplication();
+                }
+            }
+        });
+        primaryStage = new Stage();
+        primaryStage.cn1MarkPrimary();
+        try {
+            application.init();
+            application.start(primaryStage);
+        } catch (RuntimeException e) {
+            Log.e(e);
+            throw e;
+        } catch (Exception e) {
+            Log.e(e);
+            throw new RuntimeException(e.toString(), e);
+        }
+    }
+
+    private void stopApplication() {
+        if (application == null || stopped) {
+            return;
+        }
+        stopped = true;
+        try {
+            application.stop();
+        } catch (RuntimeException e) {
+            Log.e(e);
+            throw e;
+        } catch (Exception e) {
+            Log.e(e);
+            throw new RuntimeException(e.toString(), e);
+        }
+    }
+
+    @Override
+    public void destroy() {
+        stopApplication();
+        super.destroy();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxObject.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxObject.java
new file mode 100644
index 00000000000..566f0073bb4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxObject.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.beans.property.SimpleObjectProperty;
+
+/// An object property that tells its owner what its change makes stale.
+public class FxObject<T> extends SimpleObjectProperty<T> {
+
+    private final Dirty.Owner owner;
+    private final int what;
+
+    /// Creates the property of an owner.
+    public FxObject(Dirty.Owner owner, String name, T initial, int what) {
+        super(owner, name, initial);
+        this.owner = owner;
+        this.what = what;
+    }
+
+    @Override
+    protected void invalidated() {
+        owner.cn1Invalidated(what);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxPath.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxPath.java
new file mode 100644
index 00000000000..faeb14791a1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxPath.java
@@ -0,0 +1,833 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.geom.GeneralPath;
+import com.codename1.util.MathUtil;
+
+/// A path in logical coordinates: the one geometry every shape, canvas
+/// call, background and border is reduced to before it is drawn.
+///
+/// The path keeps double precision and knows how to flatten itself, cut
+/// itself into dashes, answer whether a point is inside and produce the
+/// Codename One path of itself under an affine matrix.
+public final class FxPath {
+
+    /// Starts a new sub path; one point.
+    public static final byte MOVE = 0;
+    /// A straight line; one point.
+    public static final byte LINE = 1;
+    /// A quadratic curve; a control point and an end point.
+    public static final byte QUAD = 2;
+    /// A cubic curve; two control points and an end point.
+    public static final byte CUBIC = 3;
+    /// Closes the current sub path; no points.
+    public static final byte CLOSE = 4;
+
+    private static final double KAPPA = 0.5522847498307936;
+
+    private byte[] commands = new byte[8];
+    private double[] points = new double[32];
+    private int commandCount;
+    private int pointCount;
+    private boolean evenOdd;
+    private double startX;
+    private double startY;
+    private double lastX;
+    private double lastY;
+
+    /// Creates an empty path filled by the non-zero rule.
+    public FxPath() {
+    }
+
+    /// Sets whether the inside is decided by the even-odd rule.
+    public void setEvenOdd(boolean evenOdd) {
+        this.evenOdd = evenOdd;
+    }
+
+    /// Returns whether the inside is decided by the even-odd rule.
+    public boolean isEvenOdd() {
+        return evenOdd;
+    }
+
+    /// Removes every segment.
+    public void reset() {
+        commandCount = 0;
+        pointCount = 0;
+        lastX = 0;
+        lastY = 0;
+        startX = 0;
+        startY = 0;
+    }
+
+    /// Returns whether the path has no segments.
+    public boolean isEmpty() {
+        return commandCount == 0;
+    }
+
+    /// Returns the number of commands.
+    public int commandCount() {
+        return commandCount;
+    }
+
+    /// Returns a command, one of the constants of this class.
+    public byte command(int index) {
+        return commands[index];
+    }
+
+    /// Returns the coordinates, x and y alternating, in command order.
+    public double[] points() {
+        double[] copy = new double[pointCount];
+        System.arraycopy(points, 0, copy, 0, pointCount);
+        return copy;
+    }
+
+    /// Returns the x of the current point.
+    public double currentX() {
+        return lastX;
+    }
+
+    /// Returns the y of the current point.
+    public double currentY() {
+        return lastY;
+    }
+
+    private void add(byte command, int coordinates) {
+        if (commandCount == commands.length) {
+            byte[] grown = new byte[commandCount * 2];
+            System.arraycopy(commands, 0, grown, 0, commandCount);
+            commands = grown;
+        }
+        commands[commandCount++] = command;
+        if (pointCount + coordinates > points.length) {
+            double[] grown = new double[Math.max(points.length * 2, pointCount + coordinates)];
+            System.arraycopy(points, 0, grown, 0, pointCount);
+            points = grown;
+        }
+    }
+
+    /// Starts a new sub path.
+    public void moveTo(double x, double y) {
+        add(MOVE, 2);
+        points[pointCount++] = x;
+        points[pointCount++] = y;
+        lastX = x;
+        lastY = y;
+        startX = x;
+        startY = y;
+    }
+
+    /// Adds a line; on an empty path it starts a sub path instead.
+    public void lineTo(double x, double y) {
+        if (commandCount == 0) {
+            moveTo(x, y);
+            return;
+        }
+        add(LINE, 2);
+        points[pointCount++] = x;
+        points[pointCount++] = y;
+        lastX = x;
+        lastY = y;
+    }
+
+    /// Adds a quadratic curve.
+    public void quadTo(double cx, double cy, double x, double y) {
+        if (commandCount == 0) {
+            moveTo(cx, cy);
+        }
+        add(QUAD, 4);
+        points[pointCount++] = cx;
+        points[pointCount++] = cy;
+        points[pointCount++] = x;
+        points[pointCount++] = y;
+        lastX = x;
+        lastY = y;
+    }
+
+    /// Adds a cubic curve.
+    public void curveTo(double c1x, double c1y, double c2x, double c2y, double x, double y) {
+        if (commandCount == 0) {
+            moveTo(c1x, c1y);
+        }
+        add(CUBIC, 6);
+        points[pointCount++] = c1x;
+        points[pointCount++] = c1y;
+        points[pointCount++] = c2x;
+        points[pointCount++] = c2y;
+        points[pointCount++] = x;
+        points[pointCount++] = y;
+        lastX = x;
+        lastY = y;
+    }
+
+    /// Closes the current sub path with a line to its start.
+    public void closePath() {
+        if (commandCount == 0 || commands[commandCount - 1] == CLOSE) {
+            return;
+        }
+        add(CLOSE, 0);
+        lastX = startX;
+        lastY = startY;
+    }
+
+    /// Adds a closed rectangle.
+    public void addRect(double x, double y, double w, double h) {
+        moveTo(x, y);
+        lineTo(x + w, y);
+        lineTo(x + w, y + h);
+        lineTo(x, y + h);
+        closePath();
+    }
+
+    /// Adds a closed rectangle with a radius per corner, clockwise from
+    /// the top left. Radii are reduced so neighbours never overlap.
+    public void addRoundRect(double x, double y, double w, double h, double topLeft, double topRight,
+            double bottomRight, double bottomLeft) {
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        double tl = Math.max(0, topLeft);
+        double tr = Math.max(0, topRight);
+        double br = Math.max(0, bottomRight);
+        double bl = Math.max(0, bottomLeft);
+        double f = 1;
+        f = shrink(f, w, tl + tr);
+        f = shrink(f, w, bl + br);
+        f = shrink(f, h, tl + bl);
+        f = shrink(f, h, tr + br);
+        tl *= f;
+        tr *= f;
+        br *= f;
+        bl *= f;
+        if (tl == 0 && tr == 0 && br == 0 && bl == 0) {
+            addRect(x, y, w, h);
+            return;
+        }
+        double k = 1 - KAPPA;
+        moveTo(x + tl, y);
+        lineTo(x + w - tr, y);
+        if (tr > 0) {
+            curveTo(x + w - tr * k, y, x + w, y + tr * k, x + w, y + tr);
+        }
+        lineTo(x + w, y + h - br);
+        if (br > 0) {
+            curveTo(x + w, y + h - br * k, x + w - br * k, y + h, x + w - br, y + h);
+        }
+        lineTo(x + bl, y + h);
+        if (bl > 0) {
+            curveTo(x + bl * k, y + h, x, y + h - bl * k, x, y + h - bl);
+        }
+        lineTo(x, y + tl);
+        if (tl > 0) {
+            curveTo(x, y + tl * k, x + tl * k, y, x + tl, y);
+        }
+        closePath();
+    }
+
+    /// Adds a closed rectangle whose four corners are quarters of one
+    /// ellipse with the given radii, each at most half the side it lies
+    /// on. A radius that is not positive gives square corners.
+    public void addRoundRect(double x, double y, double w, double h, double radiusX, double radiusY) {
+        double rx = Math.min(Math.max(0, radiusX), w / 2);
+        double ry = Math.min(Math.max(0, radiusY), h / 2);
+        if (!(rx > 0) || !(ry > 0)) {
+            addRect(x, y, w, h);
+            return;
+        }
+        double kx = rx * (1 - KAPPA);
+        double ky = ry * (1 - KAPPA);
+        moveTo(x + rx, y);
+        lineTo(x + w - rx, y);
+        curveTo(x + w - kx, y, x + w, y + ky, x + w, y + ry);
+        lineTo(x + w, y + h - ry);
+        curveTo(x + w, y + h - ky, x + w - kx, y + h, x + w - rx, y + h);
+        lineTo(x + rx, y + h);
+        curveTo(x + kx, y + h, x, y + h - ky, x, y + h - ry);
+        lineTo(x, y + ry);
+        curveTo(x, y + ky, x + kx, y, x + rx, y);
+        closePath();
+    }
+
+    private static double shrink(double factor, double available, double wanted) {
+        if (wanted > available && wanted > 0) {
+            return Math.min(factor, available / wanted);
+        }
+        return factor;
+    }
+
+    /// Adds a closed ellipse.
+    public void addEllipse(double cx, double cy, double rx, double ry) {
+        double ox = rx * KAPPA;
+        double oy = ry * KAPPA;
+        moveTo(cx + rx, cy);
+        curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);
+        curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);
+        curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);
+        curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);
+        closePath();
+    }
+
+    /// Adds an elliptical arc as cubic curves. Angles are in degrees,
+    /// counter clockwise from the positive x axis as JavaFX measures them
+    /// (y pointing down, so a positive extent sweeps towards the top).
+    /// With `connect` the arc is joined to the current point by a line;
+    /// otherwise it starts a new sub path.
+    public void addArc(double cx, double cy, double rx, double ry, double startDegrees, double extentDegrees,
+            boolean connect) {
+        double extent = extentDegrees;
+        if (extent > 360) {
+            extent = 360;
+        } else if (extent < -360) {
+            extent = -360;
+        }
+        double start = Math.toRadians(-startDegrees);
+        double sweep = Math.toRadians(-extent);
+        int pieces = (int) Math.ceil(Math.abs(sweep) / (Math.PI / 2) - 1e-9);
+        if (pieces < 1) {
+            pieces = 1;
+        }
+        double step = sweep / pieces;
+        double t = 4.0 / 3.0 * Math.tan(step / 4);
+        double a = start;
+        double px = cx + rx * Math.cos(a);
+        double py = cy + ry * Math.sin(a);
+        if (connect && commandCount > 0) {
+            lineTo(px, py);
+        } else {
+            moveTo(px, py);
+        }
+        for (int i = 0; i < pieces; i++) {
+            double b = a + step;
+            double cosA = Math.cos(a);
+            double sinA = Math.sin(a);
+            double cosB = Math.cos(b);
+            double sinB = Math.sin(b);
+            curveTo(cx + rx * (cosA - t * sinA), cy + ry * (sinA + t * cosA), cx + rx * (cosB + t * sinB),
+                    cy + ry * (sinB - t * cosB), cx + rx * cosB, cy + ry * sinB);
+            a = b;
+        }
+    }
+
+    /// Adds an elliptical arc from the current point to an end point, in
+    /// the form SVG path data and `ArcTo` give it: two radii, the
+    /// rotation of the ellipse's x axis in degrees, whether the larger of
+    /// the two possible arcs is meant and whether it is drawn in the
+    /// direction of growing angles (clockwise on a screen). The arc is
+    /// converted to cubic curves of at most a quarter turn each.
+    ///
+    /// As SVG specifies: an arc to the current point adds nothing, a zero
+    /// radius gives a straight line, and radii too small to reach the end
+    /// point are scaled up until they do.
+    public void arcTo(double radiusX, double radiusY, double xAxisRotationDegrees, boolean largeArc, boolean sweep,
+            double x, double y) {
+        if (commandCount == 0) {
+            moveTo(x, y);
+            return;
+        }
+        double x0 = lastX;
+        double y0 = lastY;
+        if (Double.compare(x0, x) == 0 && Double.compare(y0, y) == 0) {
+            return;
+        }
+        double rx = Math.abs(radiusX);
+        double ry = Math.abs(radiusY);
+        if (!(rx > 0) || !(ry > 0)) {
+            lineTo(x, y);
+            return;
+        }
+        double phi = Math.toRadians(xAxisRotationDegrees);
+        double cosPhi = Math.cos(phi);
+        double sinPhi = Math.sin(phi);
+        double dx2 = (x0 - x) / 2;
+        double dy2 = (y0 - y) / 2;
+        double x1 = cosPhi * dx2 + sinPhi * dy2;
+        double y1 = -sinPhi * dx2 + cosPhi * dy2;
+        double lambda = (x1 * x1) / (rx * rx) + (y1 * y1) / (ry * ry);
+        if (lambda > 1) {
+            double grow = Math.sqrt(lambda);
+            rx *= grow;
+            ry *= grow;
+        }
+        double numerator = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1;
+        double denominator = rx * rx * y1 * y1 + ry * ry * x1 * x1;
+        double factor = denominator > 0 && numerator > 0 ? Math.sqrt(numerator / denominator) : 0;
+        if (largeArc == sweep) {
+            factor = -factor;
+        }
+        double cx1 = factor * (rx * y1 / ry);
+        double cy1 = factor * -(ry * x1 / rx);
+        double cx = cosPhi * cx1 - sinPhi * cy1 + (x0 + x) / 2;
+        double cy = sinPhi * cx1 + cosPhi * cy1 + (y0 + y) / 2;
+        double ux = (x1 - cx1) / rx;
+        double uy = (y1 - cy1) / ry;
+        double vx = (-x1 - cx1) / rx;
+        double vy = (-y1 - cy1) / ry;
+        double theta = MathUtil.atan2(uy, ux);
+        double delta = MathUtil.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+        if (!sweep && delta > 0) {
+            delta -= 2 * Math.PI;
+        } else if (sweep && delta < 0) {
+            delta += 2 * Math.PI;
+        }
+        int pieces = (int) Math.ceil(Math.abs(delta) / (Math.PI / 2) - 1e-9);
+        if (pieces < 1) {
+            pieces = 1;
+        }
+        double step = delta / pieces;
+        double t = 4.0 / 3.0 * Math.tan(step / 4);
+        double a = theta;
+        for (int i = 0; i < pieces; i++) {
+            double b = a + step;
+            double cosA = Math.cos(a);
+            double sinA = Math.sin(a);
+            double cosB = Math.cos(b);
+            double sinB = Math.sin(b);
+            // Points and tangents on the unrotated ellipse, then rotated.
+            double p1x = rx * (cosA - t * sinA);
+            double p1y = ry * (sinA + t * cosA);
+            double p2x = rx * (cosB + t * sinB);
+            double p2y = ry * (sinB - t * cosB);
+            double ex = i == pieces - 1 ? x : cx + cosPhi * rx * cosB - sinPhi * ry * sinB;
+            double ey = i == pieces - 1 ? y : cy + sinPhi * rx * cosB + cosPhi * ry * sinB;
+            curveTo(cx + cosPhi * p1x - sinPhi * p1y, cy + sinPhi * p1x + cosPhi * p1y,
+                    cx + cosPhi * p2x - sinPhi * p2y, cy + sinPhi * p2x + cosPhi * p2y, ex, ey);
+            a = b;
+        }
+    }
+
+    /// Returns a copy of this path.
+    public FxPath copy() {
+        return transformed(new double[] {1, 0, 0, 1, 0, 0});
+    }
+
+    /// Returns the x the current sub path started at.
+    public double startX() {
+        return startX;
+    }
+
+    /// Returns the y the current sub path started at.
+    public double startY() {
+        return startY;
+    }
+
+    /// Appends every segment of another path.
+    public void append(FxPath other) {
+        int p = 0;
+        for (int i = 0; i < other.commandCount; i++) {
+            double[] o = other.points;
+            switch (other.commands[i]) {
+                case MOVE:
+                    moveTo(o[p], o[p + 1]);
+                    p += 2;
+                    break;
+                case LINE:
+                    lineTo(o[p], o[p + 1]);
+                    p += 2;
+                    break;
+                case QUAD:
+                    quadTo(o[p], o[p + 1], o[p + 2], o[p + 3]);
+                    p += 4;
+                    break;
+                case CUBIC:
+                    curveTo(o[p], o[p + 1], o[p + 2], o[p + 3], o[p + 4], o[p + 5]);
+                    p += 6;
+                    break;
+                default:
+                    closePath();
+                    break;
+            }
+        }
+    }
+
+    private static int segments(double length, double tolerance) {
+        int n = (int) Math.ceil(Math.sqrt(length / Math.max(tolerance, 0.01)));
+        return n < 2 ? 2 : (n > 96 ? 96 : n);
+    }
+
+    private static double dist(double x1, double y1, double x2, double y2) {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    /// Returns this path with every curve replaced by lines that stay
+    /// within a tolerance of it.
+    public FxPath flatten(double tolerance) {
+        FxPath out = new FxPath();
+        out.evenOdd = evenOdd;
+        int p = 0;
+        double x = 0;
+        double y = 0;
+        for (int i = 0; i < commandCount; i++) {
+            switch (commands[i]) {
+                case MOVE:
+                    x = points[p];
+                    y = points[p + 1];
+                    out.moveTo(x, y);
+                    p += 2;
+                    break;
+                case LINE:
+                    x = points[p];
+                    y = points[p + 1];
+                    out.lineTo(x, y);
+                    p += 2;
+                    break;
+                case QUAD: {
+                    double cx = points[p];
+                    double cy = points[p + 1];
+                    double ex = points[p + 2];
+                    double ey = points[p + 3];
+                    int n = segments(dist(x, y, cx, cy) + dist(cx, cy, ex, ey), tolerance);
+                    for (int s = 1; s <= n; s++) {
+                        double t = (double) s / n;
+                        double u = 1 - t;
+                        out.lineTo(u * u * x + 2 * u * t * cx + t * t * ex, u * u * y + 2 * u * t * cy + t * t * ey);
+                    }
+                    x = ex;
+                    y = ey;
+                    p += 4;
+                    break;
+                }
+                case CUBIC: {
+                    double c1x = points[p];
+                    double c1y = points[p + 1];
+                    double c2x = points[p + 2];
+                    double c2y = points[p + 3];
+                    double ex = points[p + 4];
+                    double ey = points[p + 5];
+                    int n = segments(dist(x, y, c1x, c1y) + dist(c1x, c1y, c2x, c2y) + dist(c2x, c2y, ex, ey),
+                            tolerance);
+                    for (int s = 1; s <= n; s++) {
+                        double t = (double) s / n;
+                        double u = 1 - t;
+                        double a = u * u * u;
+                        double b = 3 * u * u * t;
+                        double c = 3 * u * t * t;
+                        double d = t * t * t;
+                        out.lineTo(a * x + b * c1x + c * c2x + d * ex, a * y + b * c1y + c * c2y + d * ey);
+                    }
+                    x = ex;
+                    y = ey;
+                    p += 6;
+                    break;
+                }
+                default:
+                    out.closePath();
+                    x = out.lastX;
+                    y = out.lastY;
+                    break;
+            }
+        }
+        return out;
+    }
+
+    /// Returns the bounds of the path as `{minX, minY, maxX, maxY}`, or
+    /// `null` for an empty path. Curves are measured by their flattened
+    /// form, so the result is tight.
+    public double[] bounds() {
+        if (pointCount == 0) {
+            return null;
+        }
+        FxPath flat = hasCurves() ? flatten(0.05) : this;
+        double minX = Double.MAX_VALUE;
+        double minY = Double.MAX_VALUE;
+        double maxX = -Double.MAX_VALUE;
+        double maxY = -Double.MAX_VALUE;
+        for (int i = 0; i < flat.pointCount; i += 2) {
+            double x = flat.points[i];
+            double y = flat.points[i + 1];
+            if (x < minX) {
+                minX = x;
+            }
+            if (x > maxX) {
+                maxX = x;
+            }
+            if (y < minY) {
+                minY = y;
+            }
+            if (y > maxY) {
+                maxY = y;
+            }
+        }
+        return new double[] {minX, minY, maxX, maxY};
+    }
+
+    private boolean hasCurves() {
+        for (int i = 0; i < commandCount; i++) {
+            if (commands[i] == QUAD || commands[i] == CUBIC) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Returns whether a point is inside the filled path. Open sub paths
+    /// count as closed, as they do when filling.
+    public boolean contains(double x, double y) {
+        FxPath flat = hasCurves() ? flatten(0.1) : this;
+        int winding = 0;
+        int crossings = 0;
+        int p = 0;
+        double sx = 0;
+        double sy = 0;
+        double cx = 0;
+        double cy = 0;
+        boolean open = false;
+        for (int i = 0; i <= flat.commandCount; i++) {
+            byte command = i < flat.commandCount ? flat.commands[i] : MOVE;
+            if (command == LINE) {
+                double nx = flat.points[p];
+                double ny = flat.points[p + 1];
+                p += 2;
+                int w = cross(cx, cy, nx, ny, x, y);
+                winding += w;
+                crossings += w == 0 ? 0 : 1;
+                cx = nx;
+                cy = ny;
+                continue;
+            }
+            if (open) {
+                int w = cross(cx, cy, sx, sy, x, y);
+                winding += w;
+                crossings += w == 0 ? 0 : 1;
+                cx = sx;
+                cy = sy;
+                open = command == CLOSE;
+            }
+            if (command == MOVE && i < flat.commandCount) {
+                sx = flat.points[p];
+                sy = flat.points[p + 1];
+                p += 2;
+                cx = sx;
+                cy = sy;
+                open = true;
+            }
+        }
+        return evenOdd ? (crossings & 1) != 0 : winding != 0;
+    }
+
+    private static int cross(double x1, double y1, double x2, double y2, double px, double py) {
+        if (y1 <= py) {
+            if (y2 > py && (x2 - x1) * (py - y1) - (px - x1) * (y2 - y1) > 0) {
+                return 1;
+            }
+        } else if (y2 <= py && (x2 - x1) * (py - y1) - (px - x1) * (y2 - y1) < 0) {
+            return -1;
+        }
+        return 0;
+    }
+
+    /// Returns whether a point is within a distance of the outline, which
+    /// is how a stroke is hit tested.
+    public boolean nearOutline(double x, double y, double distance) {
+        FxPath flat = hasCurves() ? flatten(0.1) : this;
+        int p = 0;
+        double sx = 0;
+        double sy = 0;
+        double cx = 0;
+        double cy = 0;
+        for (int i = 0; i < flat.commandCount; i++) {
+            byte command = flat.commands[i];
+            if (command == MOVE) {
+                sx = flat.points[p];
+                sy = flat.points[p + 1];
+                cx = sx;
+                cy = sy;
+                p += 2;
+                if (dist(cx, cy, x, y) <= distance) {
+                    return true;
+                }
+            } else {
+                double nx = command == CLOSE ? sx : flat.points[p];
+                double ny = command == CLOSE ? sy : flat.points[p + 1];
+                if (command == LINE) {
+                    p += 2;
+                }
+                if (segmentDistance(cx, cy, nx, ny, x, y) <= distance) {
+                    return true;
+                }
+                cx = nx;
+                cy = ny;
+            }
+        }
+        return false;
+    }
+
+    private static double segmentDistance(double x1, double y1, double x2, double y2, double px, double py) {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double len = dx * dx + dy * dy;
+        double t = len == 0 ? 0 : ((px - x1) * dx + (py - y1) * dy) / len;
+        t = t < 0 ? 0 : (t > 1 ? 1 : t);
+        return dist(x1 + t * dx, y1 + t * dy, px, py);
+    }
+
+    /// Returns the outline cut into dashes: `pattern` alternates the
+    /// lengths of dashes and gaps, and `offset` is where in the pattern
+    /// the outline starts. A pattern with no positive length answers this
+    /// path.
+    public FxPath dashed(double[] pattern, double offset) {
+        if (pattern == null || pattern.length == 0) {
+            return this;
+        }
+        double total = 0;
+        for (int i = 0; i < pattern.length; i++) {
+            if (pattern[i] < 0) {
+                return this;
+            }
+            total += pattern[i];
+        }
+        if (!(total > 0)) {
+            return this;
+        }
+        int entries = pattern.length % 2 == 0 ? pattern.length : pattern.length * 2;
+        double cycle = pattern.length % 2 == 0 ? total : total * 2;
+        FxPath flat = flatten(0.1);
+        FxPath out = new FxPath();
+        int p = 0;
+        double sx = 0;
+        double sy = 0;
+        double cx = 0;
+        double cy = 0;
+        int index = 0;
+        double remaining = 0;
+        boolean on = true;
+        boolean pen = false;
+        for (int i = 0; i < flat.commandCount; i++) {
+            byte command = flat.commands[i];
+            if (command == MOVE) {
+                sx = flat.points[p];
+                sy = flat.points[p + 1];
+                p += 2;
+                cx = sx;
+                cy = sy;
+                double phase = offset - Math.floor(offset / cycle) * cycle;
+                index = 0;
+                while (phase > 0 && phase >= pattern[index % pattern.length]) {
+                    phase -= pattern[index % pattern.length];
+                    index = (index + 1) % entries;
+                }
+                remaining = pattern[index % pattern.length] - phase;
+                on = index % 2 == 0;
+                pen = false;
+                continue;
+            }
+            double nx = command == CLOSE ? sx : flat.points[p];
+            double ny = command == CLOSE ? sy : flat.points[p + 1];
+            if (command == LINE) {
+                p += 2;
+            }
+            double len = dist(cx, cy, nx, ny);
+            double done = 0;
+            int guard = 0;
+            while (len - done > 1e-9 && guard++ < 100000) {
+                double take = Math.min(remaining, len - done);
+                double t0 = len == 0 ? 0 : done / len;
+                double t1 = len == 0 ? 0 : (done + take) / len;
+                if (on) {
+                    if (!pen) {
+                        out.moveTo(cx + (nx - cx) * t0, cy + (ny - cy) * t0);
+                        pen = true;
+                    }
+                    out.lineTo(cx + (nx - cx) * t1, cy + (ny - cy) * t1);
+                }
+                done += take;
+                remaining -= take;
+                if (remaining <= 1e-9) {
+                    index = (index + 1) % entries;
+                    remaining = pattern[index % pattern.length];
+                    on = index % 2 == 0;
+                    pen = false;
+                }
+            }
+            cx = nx;
+            cy = ny;
+        }
+        return out;
+    }
+
+    /// Returns the Codename One path of this path under the affine matrix
+    /// `{a, b, c, d, tx, ty}`, where `x' = a*x + c*y + tx` and
+    /// `y' = b*x + d*y + ty`.
+    public GeneralPath toDevice(double[] m) {
+        GeneralPath out = new GeneralPath();
+        out.setWindingRule(evenOdd ? GeneralPath.WIND_EVEN_ODD : GeneralPath.WIND_NON_ZERO);
+        int p = 0;
+        for (int i = 0; i < commandCount; i++) {
+            switch (commands[i]) {
+                case MOVE:
+                    out.moveTo(tx(m, points[p], points[p + 1]), ty(m, points[p], points[p + 1]));
+                    p += 2;
+                    break;
+                case LINE:
+                    out.lineTo(tx(m, points[p], points[p + 1]), ty(m, points[p], points[p + 1]));
+                    p += 2;
+                    break;
+                case QUAD:
+                    out.quadTo(tx(m, points[p], points[p + 1]), ty(m, points[p], points[p + 1]),
+                            tx(m, points[p + 2], points[p + 3]), ty(m, points[p + 2], points[p + 3]));
+                    p += 4;
+                    break;
+                case CUBIC:
+                    out.curveTo(tx(m, points[p], points[p + 1]), ty(m, points[p], points[p + 1]),
+                            tx(m, points[p + 2], points[p + 3]), ty(m, points[p + 2], points[p + 3]),
+                            tx(m, points[p + 4], points[p + 5]), ty(m, points[p + 4], points[p + 5]));
+                    p += 6;
+                    break;
+                default:
+                    out.closePath();
+                    break;
+            }
+        }
+        return out;
+    }
+
+    /// Returns this path with every point mapped through the affine
+    /// matrix `{a, b, c, d, tx, ty}`.
+    public FxPath transformed(double[] m) {
+        FxPath out = new FxPath();
+        out.evenOdd = evenOdd;
+        out.commands = new byte[Math.max(8, commandCount)];
+        System.arraycopy(commands, 0, out.commands, 0, commandCount);
+        out.commandCount = commandCount;
+        out.points = new double[Math.max(32, pointCount)];
+        for (int i = 0; i < pointCount; i += 2) {
+            out.points[i] = tx(m, points[i], points[i + 1]);
+            out.points[i + 1] = ty(m, points[i], points[i + 1]);
+        }
+        out.pointCount = pointCount;
+        out.lastX = tx(m, lastX, lastY);
+        out.lastY = ty(m, lastX, lastY);
+        out.startX = tx(m, startX, startY);
+        out.startY = ty(m, startX, startY);
+        return out;
+    }
+
+    private static double tx(double[] m, double x, double y) {
+        return m[0] * x + m[2] * y + m[4];
+    }
+
+    private static double ty(double[] m, double x, double y) {
+        return m[1] * x + m[3] * y + m[5];
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxPeer.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxPeer.java
new file mode 100644
index 00000000000..94264a9fbfc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxPeer.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.scene.Node;
+
+/// A Codename One component that is the peer of a scene graph node.
+public interface FxPeer {
+
+    /// Returns the node this component shows.
+    Node node();
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxString.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxString.java
new file mode 100644
index 00000000000..592e0007b23
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxString.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.beans.property.SimpleStringProperty;
+
+/// A string property that tells its owner what its change makes stale.
+public class FxString extends SimpleStringProperty {
+
+    private final Dirty.Owner owner;
+    private final int what;
+
+    /// Creates the property of an owner.
+    public FxString(Dirty.Owner owner, String name, String initial, int what) {
+        super(owner, name, initial);
+        this.owner = owner;
+        this.what = what;
+    }
+
+    @Override
+    protected void invalidated() {
+        owner.cn1Invalidated(what);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlContext.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlContext.java
new file mode 100644
index 00000000000..f094b188d64
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlContext.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+import com.codename1.impl.compat.ResourceNames;
+
+import javafx.beans.binding.DoubleBinding;
+import javafx.beans.binding.StringBinding;
+import javafx.beans.property.Property;
+import javafx.beans.value.ObservableValue;
+import javafx.event.Event;
+import javafx.event.EventHandler;
+import javafx.fxml.Initializable;
+import javafx.fxml.LoadException;
+import javafx.scene.Node;
+import javafx.util.Callback;
+
+/// What a compiled FXML document is given to build itself with: the one
+/// load it is part of. The build turns each `.fxml` file into a class with
+/// a method `load(FxmlContext)`; everything in a document that depends on
+/// who loads it -- the controller, the resource bundle, the location, the
+/// names other elements are known by -- that method asks of this object.
+///
+/// Nothing here is JavaFX API. The methods are public because generated
+/// code in the application's own packages calls them.
+public final class FxmlContext {
+
+    /// Bind the property to the source as it is.
+    public static final int BIND_SAME = 0;
+    /// Bind a string property to the text of the source's value.
+    public static final int BIND_STRING = 1;
+    /// Bind a number property to the source's number.
+    public static final int BIND_NUMBER = 2;
+
+    private final FxmlDispatch dispatch;
+    private final String path;
+    private final URL location;
+    private final ResourceBundle resources;
+    private final Callback<Class<?>, Object> controllerFactory;
+    private final Map<String, Object> namespace;
+    private final Object givenRoot;
+    private Object controller;
+
+    /// Creates the context of one load.
+    ///
+    /// #### Parameters
+    ///
+    /// - `dispatch`: the dispatcher that reaches controllers and documents
+    ///
+    /// - `path`: the resource path of the document, without a leading slash
+    ///
+    /// - `location`: where the document was asked for, or `null`
+    ///
+    /// - `resources`: the bundle of its `%key` strings, or `null`
+    ///
+    /// - `controllerFactory`: what creates controllers, or `null` for the
+    ///   no-argument constructor
+    ///
+    /// - `namespace`: the map the `fx:id` values are collected in
+    ///
+    /// - `root`: the object an `fx:root` document builds on, or `null`
+    ///
+    /// - `controller`: the controller set on the loader, or `null`
+    public FxmlContext(FxmlDispatch dispatch, String path, URL location, ResourceBundle resources,
+            Callback<Class<?>, Object> controllerFactory, Map<String, Object> namespace, Object root,
+            Object controller) {
+        this.dispatch = dispatch;
+        this.path = path;
+        this.location = location;
+        this.resources = resources;
+        this.controllerFactory = controllerFactory;
+        this.namespace = namespace;
+        this.givenRoot = root;
+        this.controller = controller;
+        if (controller != null) {
+            namespace.put("controller", controller);
+        }
+    }
+
+    /// A failure to load, naming the document.
+    public LoadException error(String message) {
+        return new LoadException(path + ": " + message);
+    }
+
+    /// The controller of the document, created now unless the loader was
+    /// given one: by the controller factory when there is one, otherwise by
+    /// the no-argument constructor of the class the document names.
+    public Object controller(Class<?> type, String className) throws LoadException {
+        if (controller == null) {
+            if (controllerFactory != null) {
+                controller = controllerFactory.call(type);
+                if (controller == null) {
+                    throw error("the controller factory answered null for " + className);
+                }
+            } else {
+                controller = dispatch.create(className);
+                if (controller == null) {
+                    throw error("cannot create the controller " + className
+                            + ": it needs a constructor without arguments, and must not be abstract");
+                }
+            }
+            namespace.put("controller", controller);
+        }
+        return controller;
+    }
+
+    /// The controller, or `null` when the document has none.
+    public Object controller() {
+        return controller;
+    }
+
+    /// The object an `fx:root` document builds on, which the application
+    /// set with `FXMLLoader.setRoot`.
+    public Object root() throws LoadException {
+        if (givenRoot == null) {
+            throw error("the document has an <fx:root> element, so setRoot() must be called before load()");
+        }
+        return givenRoot;
+    }
+
+    /// Records an element under its `fx:id`: in the namespace, in the
+    /// controller's field of that name, and as the id of a node that has
+    /// none.
+    public void id(String id, Object value) {
+        namespace.put(id, value);
+        if (value instanceof Node) {
+            Node node = (Node) value;
+            if (node.getId() == null) {
+                node.setId(id);
+            }
+        }
+        if (controller != null) {
+            dispatch.inject(controller, id, value);
+        }
+    }
+
+    /// The object recorded under an `fx:id`, for `$name` and
+    /// `<fx:reference>`.
+    public Object get(String id) throws LoadException {
+        Object value = namespace.get(id);
+        if (value == null && !namespace.containsKey(id)) {
+            throw error("nothing with the fx:id \"" + id + "\" was defined before it is used");
+        }
+        return value;
+    }
+
+    /// The handler for `onAction="#name"`: it calls the controller's method
+    /// of that name when the event arrives.
+    @SuppressWarnings("rawtypes")
+    public EventHandler handler(final String name) throws LoadException {
+        final Object target = controller;
+        if (target == null) {
+            throw error("the handler #" + name + " needs a controller, and the document has none");
+        }
+        return new Handler(dispatch, path, target, name);
+    }
+
+    /// The handler of one `#name`: a call of the controller's method.
+    private static final class Handler implements EventHandler<Event> {
+        private final FxmlDispatch dispatch;
+        private final String document;
+        private final Object target;
+        private final String name;
+
+        Handler(FxmlDispatch dispatch, String document, Object target, String name) {
+            this.dispatch = dispatch;
+            this.document = document;
+            this.target = target;
+            this.name = name;
+        }
+
+        @Override
+        public void handle(Event event) {
+            boolean called;
+            try {
+                called = dispatch.invoke(target, name, event);
+            } catch (RuntimeException e) {
+                throw e;
+            } catch (Exception e) {
+                RuntimeException wrapped = new RuntimeException(document + ": the handler #" + name
+                        + " failed: " + e);
+                wrapped.initCause(e);
+                throw wrapped;
+            }
+            if (!called) {
+                throw new IllegalStateException(document + ": the controller " + target.getClass().getName()
+                        + " has no handler method " + name
+                        + "() that is public or annotated @FXML and takes no argument or the event");
+            }
+        }
+    }
+
+    /// The string of a `%key`.
+    public String string(String key) throws LoadException {
+        if (resources == null) {
+            throw error("the document uses %" + key + " but was loaded without a resource bundle");
+        }
+        try {
+            return resources.getString(key);
+        } catch (MissingResourceException e) {
+            throw error("the resource bundle has no key \"" + key + "\"");
+        }
+    }
+
+    /// The address an `@path` stands for: the path taken relative to the
+    /// document, as a `cn1res:` address the image and style sheet loaders
+    /// read from the application's resources.
+    public String url(String relative) {
+        String resolved = resolve(relative);
+        return resolved == null ? relative : "cn1res:/" + resolved;
+    }
+
+    private String resolve(String relative) {
+        if (relative.startsWith("/")) {
+            return ResourceNames.normalize(relative);
+        }
+        int slash = path.lastIndexOf('/');
+        return ResourceNames.normalize(slash < 0 ? relative : path.substring(0, slash + 1) + relative);
+    }
+
+    /// Loads the document an `<fx:include source>` names and answers its
+    /// root. With an `fx:id`, the root is recorded under it and the
+    /// included document's controller under that id followed by
+    /// `Controller`.
+    public Object include(String source, String id) throws Exception {
+        String child = resolve(source);
+        if (child == null || !dispatch.has(child)) {
+            throw error("the included document " + source + " (" + child
+                    + ") was not compiled into the application");
+        }
+        URL childLocation = null;
+        if (location != null) {
+            try {
+                childLocation = new URL(location, source);
+            } catch (MalformedURLException e) {
+                childLocation = null;
+            }
+        }
+        FxmlContext context = new FxmlContext(dispatch, child, childLocation, resources, controllerFactory,
+                new java.util.HashMap<String, Object>(), null, null);
+        Object root = dispatch.load(child, context);
+        if (id != null) {
+            id(id, root);
+            if (context.controller != null) {
+                namespace.put(id + "Controller", context.controller);
+                if (controller != null) {
+                    dispatch.inject(controller, id + "Controller", context.controller);
+                }
+            }
+        }
+        return root;
+    }
+
+    /// Called by a compiled document when its tree is complete: hands the
+    /// controller its location and resources and calls its `initialize`.
+    public void done() throws Exception {
+        if (controller == null) {
+            return;
+        }
+        if (location != null) {
+            dispatch.inject(controller, "location", location);
+        }
+        if (resources != null) {
+            dispatch.inject(controller, "resources", resources);
+        }
+        if (controller instanceof Initializable) {
+            ((Initializable) controller).initialize(location, resources);
+        } else {
+            dispatch.init(controller);
+        }
+    }
+
+    /// Binds a property to a source for `${expression}`. `mode` says how
+    /// the value is converted: one of the `BIND_` constants.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    public static void bind(Property property, final ObservableValue source, int mode) {
+        if (mode == BIND_STRING) {
+            property.bind(new StringBinding() {
+                {
+                    bind(source);
+                }
+
+                @Override
+                protected String computeValue() {
+                    Object v = source.getValue();
+                    return v == null ? "" : v.toString();
+                }
+            });
+        } else if (mode == BIND_NUMBER) {
+            property.bind(new DoubleBinding() {
+                {
+                    bind(source);
+                }
+
+                @Override
+                protected double computeValue() {
+                    Object v = source.getValue();
+                    return v instanceof Number ? ((Number) v).doubleValue() : 0;
+                }
+            });
+        } else {
+            property.bind(source);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlDispatch.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlDispatch.java
new file mode 100644
index 00000000000..227089564ef
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlDispatch.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// Everything an FXML loader would find by name with reflection, as methods
+/// the build implements with direct code: the class that builds a document,
+/// the constructor of a controller, the field an `fx:id` goes into and the
+/// method an `onAction="#name"` calls.
+///
+/// #### Who implements it
+///
+/// The build does, once per application, in the class [FxmlRegistry]: after
+/// the application is compiled it reads the compiled documents and the
+/// controllers out of the class files and writes one override per method
+/// below. This class is what those overrides fall back to, and each method
+/// here answers "not mine" -- which is also what an application without a
+/// single FXML document gets.
+///
+/// #### Why generated code goes through here
+///
+/// A compiled document does not call the generated dispatcher itself; it
+/// calls [FxmlContext], which calls the installed instance of this class.
+/// The document is Java source, compiled with the application, and the
+/// dispatcher does not exist yet at that point: it is generated from the
+/// class files javac leaves, because only they say which members a
+/// controller really has. A fixed runtime class between the two lets each
+/// be generated without the other, and lets a test install a dispatcher of
+/// its own.
+///
+/// No method takes a `URL` or a `ResourceBundle`: the application sees
+/// those types relocated, and keeping them out of the generated signatures
+/// keeps the generator independent of where they went.
+public abstract class FxmlDispatch {
+
+    private static FxmlDispatch current;
+
+    /// Creates a dispatcher that knows nothing.
+    protected FxmlDispatch() {
+        // Every answer is the default one until a subclass overrides it.
+    }
+
+    /// The installed dispatcher: the application's generated one unless
+    /// [#install(FxmlDispatch)] replaced it.
+    public static FxmlDispatch current() {
+        if (current == null) {
+            current = new FxmlRegistry();
+        }
+        return current;
+    }
+
+    /// Installs a dispatcher; `null` returns to the generated one.
+    public static void install(FxmlDispatch dispatch) {
+        current = dispatch;
+    }
+
+    /// Whether the application has a compiled document for `path`, a
+    /// resource path without a leading slash (`com/example/main.fxml`).
+    public boolean has(String path) {
+        return false;
+    }
+
+    /// Builds the document at `path` and answers its root. Only called for
+    /// a path [#has(String)] answered `true` for.
+    public Object load(String path, FxmlContext context) throws Exception {
+        return null;
+    }
+
+    /// Creates the controller of a class by its no-argument constructor,
+    /// or answers `null` for a class the build generated no constructor
+    /// call for.
+    public Object create(String className) {
+        return null;
+    }
+
+    /// Sets the field of `controller` that is named `id` to `value`.
+    /// Answers `false` when the controller has no such field. Fails with
+    /// an `IllegalArgumentException` when it has one of another type.
+    public boolean inject(Object controller, String id, Object value) {
+        return false;
+    }
+
+    /// Calls the handler method `handler` of `controller`, with `event`
+    /// when the method takes one. Answers `false` when the controller has
+    /// no such method.
+    public boolean invoke(Object controller, String handler, Object event) throws Exception {
+        return false;
+    }
+
+    /// Calls the `initialize()` method of `controller`. Answers `false`
+    /// when it has none.
+    public boolean init(Object controller) throws Exception {
+        return false;
+    }
+
+    /// What the generated field code calls for a value of the wrong type.
+    public static void mismatch(String id, String fieldType, Object value) {
+        throw new IllegalArgumentException("The element with fx:id \"" + id + "\" is a "
+                + (value == null ? "null" : value.getClass().getName()) + ", but the controller's field is a "
+                + fieldType);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlRegistry.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlRegistry.java
new file mode 100644
index 00000000000..b942391e2ef
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/FxmlRegistry.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// The application's FXML dispatcher. This is a placeholder: the build
+/// replaces it, in every application that uses the JavaFX layer, with a
+/// class of the same name that overrides the methods of [FxmlDispatch] for
+/// the documents and controllers of that application.
+///
+/// The placeholder is what an application runs with where no build step
+/// generated anything -- a unit test of this module, a desktop run straight
+/// from an IDE -- and there it answers that no document was compiled, which
+/// [javafx.fxml.FXMLLoader] reports by name.
+///
+/// The build does not copy this class out of the runtime jar; it writes its
+/// own. Anything added here would therefore be missing on a device: keep
+/// the class empty.
+public final class FxmlRegistry extends FxmlDispatch {
+
+    /// Creates the dispatcher.
+    public FxmlRegistry() {
+        super();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/GradientRaster.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/GradientRaster.java
new file mode 100644
index 00000000000..e12d11c1da4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/GradientRaster.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.List;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.Paint;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+
+/// The colour of a gradient at a point, worked out from the definition of
+/// the gradient and nothing else. [Renderer] uses it wherever the
+/// platform has no paint of its own for a gradient: a radial gradient
+/// with a focus or a cycle, and any gradient that strokes an outline.
+///
+/// A gradient is a line of colours and a rule that gives every point a
+/// place on that line. The place is a number: 0 is the first colour, 1
+/// the last, and a number outside is brought back in by the cycle
+/// method.
+public final class GradientRaster {
+
+    /// The entries of a colour table.
+    static final int TABLE = 256;
+
+    /// The nearest a focus may come to the edge of its circle, as a
+    /// fraction of the radius. On the edge itself every ray from the focus
+    /// would be the whole gradient at once.
+    private static final double FOCUS_LIMIT = 0.98;
+
+    private GradientRaster() {
+    }
+
+    /// Returns where on a linear gradient a point is: its foot on the
+    /// line from the start to the end, 0 at the start and 1 at the end.
+    public static double linearOffset(double x, double y, double startX, double startY, double endX, double endY) {
+        double dx = endX - startX;
+        double dy = endY - startY;
+        double length = dx * dx + dy * dy;
+        if (!(length > 0)) {
+            return 1;
+        }
+        return ((x - startX) * dx + (y - startY) * dy) / length;
+    }
+
+    /// Returns where on a radial gradient a point is. A ray leaves the
+    /// focus through the point and meets the circle; the answer is how far
+    /// along that ray the point is, 0 at the focus and 1 on the circle.
+    public static double radialOffset(double x, double y, double centerX, double centerY, double radius,
+            double focusX, double focusY) {
+        if (!(radius > 0)) {
+            return 1;
+        }
+        double dx = x - focusX;
+        double dy = y - focusY;
+        double ex = focusX - centerX;
+        double ey = focusY - centerY;
+        double a = dx * dx + dy * dy;
+        if (!(a > 0)) {
+            return 0;
+        }
+        double b = 2 * (ex * dx + ey * dy);
+        double c = ex * ex + ey * ey - radius * radius;
+        double root = b * b - 4 * a * c;
+        if (root < 0) {
+            return 1;
+        }
+        double reach = -b + Math.sqrt(root);
+        return reach > 0 ? 2 * a / reach : 1;
+    }
+
+    /// Returns the focus of a radial gradient: the point that takes the
+    /// first colour, at an angle and a share of the radius from the centre.
+    /// The first entry is x, the second y.
+    public static double[] focus(double centerX, double centerY, double radius, double focusAngle,
+            double focusDistance) {
+        double d = Math.max(-FOCUS_LIMIT, Math.min(FOCUS_LIMIT, focusDistance));
+        double angle = Math.toRadians(focusAngle);
+        return new double[] {centerX + d * radius * Math.cos(angle), centerY + d * radius * Math.sin(angle)};
+    }
+
+    /// Brings a place on the line of colours back between 0 and 1. Without
+    /// a cycle everything before the line is its start and everything past
+    /// it its end; a repeat starts over, and a reflection walks back.
+    public static double cycle(double offset, CycleMethod method) {
+        if (offset != offset) {
+            return 0;
+        }
+        if (method == CycleMethod.REPEAT) {
+            return offset - Math.floor(offset);
+        } else if (method == CycleMethod.REFLECT) {
+            double twice = offset / 2;
+            double t = (twice - Math.floor(twice)) * 2;
+            return t > 1 ? 2 - t : t;
+        }
+        return offset < 0 ? 0 : (offset > 1 ? 1 : offset);
+    }
+
+    /// Returns the colour of a line of stops at a place between 0 and 1.
+    public static Color colorAt(List<Stop> stops, double t) {
+        Stop previous = stops.get(0);
+        if (t <= previous.getOffset()) {
+            return previous.getColor();
+        }
+        for (int i = 1; i < stops.size(); i++) {
+            Stop next = stops.get(i);
+            if (t <= next.getOffset()) {
+                double span = next.getOffset() - previous.getOffset();
+                return span <= 0 ? next.getColor()
+                        : previous.getColor().interpolate(next.getColor(), (t - previous.getOffset()) / span);
+            }
+            previous = next;
+        }
+        return previous.getColor();
+    }
+
+    /// Returns the line of colours as a table of ARGB values, the first
+    /// entry at 0 and the last at 1.
+    static int[] table(List<Stop> stops) {
+        int[] out = new int[TABLE];
+        for (int i = 0; i < TABLE; i++) {
+            out[i] = colorAt(stops, i / (double) (TABLE - 1)).cn1Argb();
+        }
+        return out;
+    }
+
+    /// Returns the place a point has on a gradient, between 0 and 1, or
+    /// -1 for a paint that is not a gradient. The rectangle is the one a
+    /// proportional gradient is measured against.
+    public static double offsetAt(Paint paint, double x, double y, double bx, double by, double bw, double bh) {
+        if (paint instanceof LinearGradient) {
+            LinearGradient lg = (LinearGradient) paint;
+            boolean p = lg.isProportional();
+            return cycle(linearOffset(x, y, p ? bx + lg.getStartX() * bw : lg.getStartX(),
+                    p ? by + lg.getStartY() * bh : lg.getStartY(), p ? bx + lg.getEndX() * bw : lg.getEndX(),
+                    p ? by + lg.getEndY() * bh : lg.getEndY()), lg.getCycleMethod());
+        } else if (paint instanceof RadialGradient) {
+            RadialGradient rg = (RadialGradient) paint;
+            double px = x;
+            double py = y;
+            if (rg.isProportional()) {
+                // A proportional gradient is a circle in a square of side
+                // one that is stretched over the rectangle, so over a
+                // rectangle that is not square it is an ellipse. The point
+                // is taken into the square instead.
+                if (!(bw > 0) || !(bh > 0)) {
+                    return 1;
+                }
+                px = (x - bx) / bw;
+                py = (y - by) / bh;
+            }
+            double[] f = focus(rg.getCenterX(), rg.getCenterY(), rg.getRadius(), rg.getFocusAngle(),
+                    rg.getFocusDistance());
+            return cycle(radialOffset(px, py, rg.getCenterX(), rg.getCenterY(), rg.getRadius(), f[0], f[1]),
+                    rg.getCycleMethod());
+        }
+        return -1;
+    }
+
+    /// Returns the colour a gradient has at a point, `null` for a paint
+    /// that is not a gradient.
+    public static Color colorAt(Paint paint, double x, double y, double bx, double by, double bw, double bh) {
+        double t = offsetAt(paint, x, y, bx, by, bw, bh);
+        if (paint instanceof LinearGradient) {
+            return colorAt(((LinearGradient) paint).getStops(), t);
+        } else if (paint instanceof RadialGradient) {
+            return colorAt(((RadialGradient) paint).getStops(), t);
+        }
+        return null;
+    }
+
+    /// Colours a mask. Every entry of `mask` is a pixel whose alpha says
+    /// how much of it the shape covers; it is replaced by the colour of
+    /// the gradient there, that much of it. `inverse` takes the middle of
+    /// a pixel, counted from `left` and `top`, to the coordinates the
+    /// gradient is written in.
+    static void colour(int[] mask, int width, int height, int left, int top, double[] inverse, Paint paint,
+            double bx, double by, double bw, double bh, double opacity) {
+        List<Stop> stops;
+        if (paint instanceof LinearGradient) {
+            stops = ((LinearGradient) paint).getStops();
+        } else if (paint instanceof RadialGradient) {
+            stops = ((RadialGradient) paint).getStops();
+        } else {
+            return;
+        }
+        int[] table = table(stops);
+        double share = Math.max(0, Math.min(1, opacity));
+        for (int row = 0; row < height; row++) {
+            double dy = top + row + 0.5;
+            int at = row * width;
+            for (int column = 0; column < width; column++, at++) {
+                int cover = mask[at] >>> 24;
+                if (cover == 0) {
+                    mask[at] = 0;
+                    continue;
+                }
+                double dx = left + column + 0.5;
+                double x = inverse[0] * dx + inverse[2] * dy + inverse[4];
+                double y = inverse[1] * dx + inverse[3] * dy + inverse[5];
+                int c = table[(int) (offsetAt(paint, x, y, bx, by, bw, bh) * (TABLE - 1) + 0.5)];
+                int alpha = (int) ((c >>> 24) * (cover / 255.0) * share + 0.5);
+                mask[at] = (alpha << 24) | (c & 0xffffff);
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/HostCore.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/HostCore.java
new file mode 100644
index 00000000000..984ac512390
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/HostCore.java
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.List;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.Display;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.Layout;
+
+import javafx.geometry.Bounds;
+import javafx.geometry.Orientation;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+
+import javafx.scene.Scene;
+import javafx.scene.layout.Region;
+import javafx.stage.Window;
+
+/// What the three kinds of host share: keeping the peer of the scene's
+/// root in the content pane, and waiting for a window to close.
+final class HostCore {
+
+    private final Window window;
+    private final Container content;
+    private final StageHost host;
+    private final AtomicBoolean closed = new AtomicBoolean();
+    private Scene scene;
+    private Component rootPeer;
+
+    HostCore(Window window, Container content, StageHost host) {
+        this.window = window;
+        this.content = content;
+        this.host = host;
+        PeerPaint.strip(content);
+        content.setLayout(new Fit());
+        content.setScrollable(false);
+    }
+
+    /// Gives the root of the scene the whole content pane, and more than
+    /// that where the scene cannot be made that small.
+    ///
+    /// JavaFX lays a scene out in whatever its window is and clips what
+    /// does not fit, which on a desktop the user answers by making the
+    /// window larger. A phone's window is the screen. So a root that has
+    /// a minimum size larger than the pane is laid out at that minimum,
+    /// and a root that is not resizable -- a group -- at the extent of
+    /// what it holds, and the pane scrolls along each axis that
+    /// overflows: nothing is laid out narrower than it can be, and all of
+    /// it can be reached.
+    ///
+    /// A minimum is not always what the scene needs, though. A root that
+    /// holds a group counts the group at its full size, and an
+    /// application that scales that group to its window -- a game board
+    /// that follows the size of its pane -- fits a pane far smaller than
+    /// the minimum says. So a resizable root is first laid out in the
+    /// pane as JavaFX would, and only an axis along which what it then
+    /// holds reaches past the pane is given the minimum and scrolls. A
+    /// minimum the application set on the root itself is taken as given.
+    ///
+    /// Laying the scene out in the pane to find that out, and then at its
+    /// minimum, moves every node twice, and a node that moved asks for the
+    /// layout to run again: a scene that did have to scroll was laid out
+    /// and painted without end. So what was found for a pane and a
+    /// minimum is kept, and the scene is tried in the pane once for each.
+    private final class Fit extends Layout {
+
+        private int triedWidth = -1;
+        private int triedHeight = -1;
+        private int triedLeastWidth = -1;
+        private int triedLeastHeight = -1;
+        private boolean triedOverX;
+        private boolean triedOverY;
+
+        @Override
+        public void layoutContainer(Container parent) {
+            if (rootPeer == null) {
+                return;
+            }
+            int w = parent.getWidth();
+            int h = parent.getHeight();
+            if (w <= 0 || h <= 0) {
+                return;
+            }
+            Dimension least = least(w, h);
+            boolean overX = least.getWidth() > w;
+            boolean overY = least.getHeight() > h;
+            if (triedWidth == w && triedHeight == h && triedLeastWidth == least.getWidth()
+                    && triedLeastHeight == least.getHeight()) {
+                overX = triedOverX;
+                overY = triedOverY;
+            } else if (overX || overY) {
+                Dimension reach = reach(w, h);
+                // A minimum the application set itself is what it asked
+                // for; only one worked out from the content is doubted.
+                Parent root = scene.getRoot();
+                boolean setX = root instanceof Region && ((Region) root).getMinWidth() >= 0;
+                boolean setY = root instanceof Region && ((Region) root).getMinHeight() >= 0;
+                if (reach != null) {
+                    overX = overX && (setX || reach.getWidth() > w);
+                    overY = overY && (setY || reach.getHeight() > h);
+                }
+                // Only a scene that scrolls is laid out at another size
+                // than it was tried at, so only that is kept: one that
+                // fits is tried again at no cost, and what it then holds
+                // may have grown.
+                if (overX || overY) {
+                    triedWidth = w;
+                    triedHeight = h;
+                    triedLeastWidth = least.getWidth();
+                    triedLeastHeight = least.getHeight();
+                    triedOverX = overX;
+                    triedOverY = overY;
+                } else {
+                    triedWidth = -1;
+                }
+            }
+            // Back to the start of an axis before it stops scrolling:
+            // a pane that does not scroll cannot be moved back.
+            if (parent.isScrollableX() != overX) {
+                if (!overX) {
+                    parent.scrollRectToVisible(0, parent.getScrollY(), 1, 1, parent);
+                }
+                parent.setScrollableX(overX);
+            }
+            if (parent.isScrollableY() != overY) {
+                if (!overY) {
+                    parent.scrollRectToVisible(parent.getScrollX(), 0, 1, 1, parent);
+                }
+                parent.setScrollableY(overY);
+            }
+            rootPeer.setX(0);
+            rootPeer.setY(0);
+            rootPeer.setWidth(overX ? least.getWidth() : w);
+            rootPeer.setHeight(overY ? least.getHeight() : h);
+        }
+
+        @Override
+        public Dimension getPreferredSize(Container parent) {
+            if (rootPeer == null) {
+                return new Dimension(0, 0);
+            }
+            Dimension preferred = rootPeer.getPreferredSize();
+            // What scrolls is what was laid out: the minimum for the size
+            // the pane has, once it has one, and before that for the size
+            // the scene would like.
+            boolean sized = parent.getWidth() > 0 && parent.getHeight() > 0;
+            Dimension least = least(sized ? parent.getWidth() : preferred.getWidth(),
+                    sized ? parent.getHeight() : preferred.getHeight());
+            return new Dimension(Math.max(preferred.getWidth(), least.getWidth()),
+                    Math.max(preferred.getHeight(), least.getHeight()));
+        }
+    }
+
+    /// The smallest the scene can be laid out at in a pane of the given
+    /// size, in device pixels.
+    ///
+    /// A root with a content bias has no one minimum: how tall a flow of
+    /// tiles has to be depends on how wide it is. Asked with no width it
+    /// answers for the width it would like, a desktop window's, where the
+    /// tiles are one row; in a phone's width they are four, and the scene
+    /// that "fits" is laid out past the top and the bottom of the pane with
+    /// neither end in reach. So the minimum along the biased axis is asked
+    /// for the length the root gets along the other: the pane's, or the
+    /// root's own minimum where that is larger and the pane scrolls.
+    private Dimension least(int paneWidth, int paneHeight) {
+        Parent root = scene == null ? null : scene.getRoot();
+        if (root == null) {
+            return new Dimension(0, 0);
+        }
+        double w;
+        double h;
+        if (root.isResizable()) {
+            Orientation bias = root.getContentBias();
+            if (bias == Orientation.VERTICAL) {
+                h = root.minHeight(-1);
+                w = root.minWidth(Math.max(h, Units.toLogical(paneHeight)));
+            } else {
+                w = root.minWidth(-1);
+                h = root.minHeight(bias == Orientation.HORIZONTAL ? Math.max(w, Units.toLogical(paneWidth)) : -1);
+            }
+        } else {
+            Bounds bounds = root.getLayoutBounds();
+            w = bounds.getMaxX();
+            h = bounds.getMaxY();
+        }
+        // A fraction of a pixel over is rounding, not content out of reach.
+        return new Dimension(Units.toPixels(Math.floor(w)), Units.toPixels(Math.floor(h)));
+    }
+
+    /// How far what a resizable root holds reaches when the root is laid
+    /// out in a pane of the given size, in device pixels; `null` for a
+    /// root that is not resizable, whose extent is its own.
+    private Dimension reach(int paneWidth, int paneHeight) {
+        Parent root = scene == null ? null : scene.getRoot();
+        if (root == null || !root.isResizable()) {
+            return null;
+        }
+        scene.cn1Layout(Units.toLogical(paneWidth), Units.toLogical(paneHeight));
+        double w = 0;
+        double h = 0;
+        List<Node> children = root.getChildrenUnmodifiable();
+        for (int i = 0; i < children.size(); i++) {
+            Node child = children.get(i);
+            if (!child.isVisible()) {
+                continue;
+            }
+            Bounds bounds = child.getBoundsInParent();
+            if (bounds.getWidth() < 0 || bounds.getHeight() < 0) {
+                continue;
+            }
+            w = Math.max(w, bounds.getMaxX());
+            h = Math.max(h, bounds.getMaxY());
+        }
+        return new Dimension(Units.toPixels(Math.floor(w)), Units.toPixels(Math.floor(h)));
+    }
+
+    Window window() {
+        return window;
+    }
+
+    Scene scene() {
+        return scene;
+    }
+
+    Component rootPeer() {
+        return rootPeer;
+    }
+
+    void sceneChanged() {
+        scene = window.getScene();
+        content.removeAll();
+        rootPeer = null;
+        if (scene != null) {
+            scene.cn1SetHost(host, window);
+            if (scene.getRoot() != null) {
+                rootPeer = scene.getRoot().cn1Peer();
+                Container holder = rootPeer.getParent();
+                if (holder != null) {
+                    holder.removeComponent(rootPeer);
+                }
+                content.addComponent(rootPeer);
+            }
+        }
+        content.revalidate();
+    }
+
+    void requestPulse() {
+        if (rootPeer != null) {
+            rootPeer.setShouldCalcPreferredSize(true);
+            content.revalidateLater();
+        }
+    }
+
+    void showCursor(int cursor) {
+        if (rootPeer != null) {
+            rootPeer.setCursor(cursor);
+        }
+    }
+
+    void sized() {
+        // An animation is commonly started before its stage is shown, and
+        // Codename One ticks only the form on screen: the frame clock follows
+        // whichever form was laid out last.
+        FrameClock.ensureCurrent();
+        if (rootPeer != null) {
+            double x = window.getX();
+            double y = window.getY();
+            window.cn1Bounds(Double.isNaN(x) ? 0 : x, Double.isNaN(y) ? 0 : y, Units.toLogical(content.getWidth()),
+                    Units.toLogical(content.getHeight()));
+        }
+    }
+
+    void markClosed() {
+        closed.set(true);
+    }
+
+    /// Returns once [#markClosed()] was called. The event thread keeps
+    /// running: Codename One handles events on a nested loop while the
+    /// waiting itself happens on another thread.
+    void block() {
+        if (!Display.isInitialized() || closed.get()) {
+            return;
+        }
+        Display.getInstance().invokeAndBlock(new Runnable() {
+            @Override
+            public void run() {
+                while (!closed.get()) {
+                    try {
+                        Thread.sleep(20);
+                    } catch (InterruptedException interrupted) {
+                        return;
+                    }
+                }
+            }
+        });
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ListChangeBuilder.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ListChangeBuilder.java
new file mode 100644
index 00000000000..bc9b64f3823
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ListChangeBuilder.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// Assembles the change report of an observable list from the single steps
+/// its implementation records.
+///
+/// The steps arrive in the order the list was modified, each in the
+/// coordinates the list had at that moment. The builder keeps them ordered
+/// by position, moves the earlier ones as later ones shift the content, and
+/// folds neighbours together, so that a removal followed by an insertion at
+/// the same place is reported as one replacement and a run of single
+/// insertions as one range. An element added and removed again inside one
+/// change leaves no trace.
+///
+/// A permutation is kept as one only while it is the whole change; combined
+/// with any other step it is reported as a replacement of its range, which
+/// says the same less precisely.
+public final class ListChangeBuilder<E> {
+
+    private static final int ADD_REMOVE = 0;
+    private static final int UPDATE = 1;
+    private static final int PERMUTATION = 2;
+    private static final int[] NO_PERMUTATION = new int[0];
+
+    private final ObservableList<E> list;
+    private int depth;
+    private ArrayList<Step<E>> steps = new ArrayList<Step<E>>();
+
+    /// Creates the builder of a list.
+    public ListChangeBuilder(ObservableList<E> list) {
+        this.list = list;
+    }
+
+    /// Opens a change; calls nest.
+    public void beginChange() {
+        depth++;
+    }
+
+    /// Closes a change. Returns the report when this closed the outermost
+    /// one and something was recorded, otherwise `null`.
+    public ListChangeListener.Change<E> endChange() {
+        if (depth <= 0) {
+            throw new IllegalStateException("Called endChange before beginChange");
+        }
+        depth--;
+        if (depth == 0 && !steps.isEmpty()) {
+            ArrayList<Step<E>> done = steps;
+            steps = new ArrayList<Step<E>>();
+            return new Built<E>(list, done);
+        }
+        return null;
+    }
+
+    private void check() {
+        if (depth == 0) {
+            throw new IllegalStateException("beginChange was not called on this builder");
+        }
+    }
+
+    /// Records that the range from `from` to `to` was added.
+    public void nextAdd(int from, int to) {
+        check();
+        if (from >= to) {
+            return;
+        }
+        convertPermutation();
+        splitUpdate(from);
+        int count = to - from;
+        Step<E> target = null;
+        int insertAt = steps.size();
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step.kind == ADD_REMOVE && step.from <= from && from <= step.to) {
+                target = step;
+                break;
+            }
+            if (step.from >= from) {
+                insertAt = i;
+                break;
+            }
+        }
+        if (target == null) {
+            target = new Step<E>(ADD_REMOVE, from, from);
+            steps.add(insertAt, target);
+        }
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step != target && step.from >= from) {
+                step.from += count;
+                step.to += count;
+            }
+        }
+        target.to += count;
+        tidy();
+    }
+
+    /// Records that an element was removed from a position.
+    public void nextRemove(int index, E removed) {
+        check();
+        convertPermutation();
+        splitUpdate(index);
+        Step<E> target = null;
+        int insertAt = steps.size();
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step.kind == ADD_REMOVE) {
+                if (step.from <= index && index < step.to) {
+                    // The element was added by this very change.
+                    step.to--;
+                    target = step;
+                    break;
+                }
+                if (step.to == index) {
+                    step.removed.add(removed);
+                    target = step;
+                    break;
+                }
+                if (step.from == index + 1) {
+                    step.from--;
+                    step.to--;
+                    step.removed.add(0, removed);
+                    target = step;
+                    break;
+                }
+            }
+            if (step.from >= index) {
+                insertAt = i;
+                break;
+            }
+        }
+        if (target == null) {
+            target = new Step<E>(ADD_REMOVE, index, index);
+            target.removed.add(removed);
+            steps.add(insertAt, target);
+        }
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step == target) {
+                continue;
+            }
+            if (step.from > index) {
+                step.from--;
+                step.to--;
+            } else if (step.kind == UPDATE && step.from <= index && index < step.to) {
+                step.to--;
+            }
+        }
+        tidy();
+    }
+
+    /// Records that the given elements were removed from a position.
+    public void nextRemove(int index, List<? extends E> removed) {
+        for (int i = 0; i < removed.size(); i++) {
+            nextRemove(index, removed.get(i));
+        }
+    }
+
+    /// Records that the element at a position was replaced.
+    public void nextSet(int index, E old) {
+        nextRemove(index, old);
+        nextAdd(index, index + 1);
+    }
+
+    /// Records that the range now at `from` to `to` replaced the given
+    /// elements.
+    public void nextReplace(int from, int to, List<? extends E> removed) {
+        nextRemove(from, removed);
+        nextAdd(from, to);
+    }
+
+    /// Records that the element at a position changed its own state.
+    public void nextUpdate(int index) {
+        check();
+        convertPermutation();
+        int insertAt = steps.size();
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step.from <= index && index < step.to) {
+                // Already reported as added or updated.
+                return;
+            }
+        }
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step.kind == UPDATE && step.to == index) {
+                step.to++;
+                tidy();
+                return;
+            }
+            if (step.kind == UPDATE && step.from == index + 1) {
+                step.from--;
+                tidy();
+                return;
+            }
+            if (step.from > index) {
+                insertAt = i;
+                break;
+            }
+        }
+        steps.add(insertAt, new Step<E>(UPDATE, index, index + 1));
+    }
+
+    /// Records that a range was reordered; entry `i` of the permutation is
+    /// the new position of the element that was at `from + i`.
+    public void nextPermutation(int from, int to, int[] perm) {
+        check();
+        if (from >= to) {
+            return;
+        }
+        // The order before the permutation, should it have to be reported
+        // as a replacement.
+        List<E> before = new ArrayList<E>(to - from);
+        for (int i = 0; i < to - from; i++) {
+            before.add(list.get(perm[i]));
+        }
+        if (steps.isEmpty()) {
+            Step<E> step = new Step<E>(PERMUTATION, from, to);
+            step.removed = before;
+            step.perm = perm.clone();
+            steps.add(step);
+            return;
+        }
+        Step<E> first = steps.get(0);
+        if (steps.size() == 1 && first.kind == PERMUTATION && first.from == from && first.to == to) {
+            for (int i = 0; i < first.perm.length; i++) {
+                first.perm[i] = perm[first.perm[i] - from];
+            }
+            return;
+        }
+        convertPermutation();
+        nextReplace(from, to, before);
+    }
+
+    private void convertPermutation() {
+        if (steps.size() == 1) {
+            Step<E> step = steps.get(0);
+            if (step.kind == PERMUTATION) {
+                step.kind = ADD_REMOVE;
+                step.perm = null;
+            }
+        }
+    }
+
+    /// Cuts an update range in two at a position strictly inside it, so a
+    /// step recorded at that position can sit between the halves.
+    private void splitUpdate(int index) {
+        for (int i = 0; i < steps.size(); i++) {
+            Step<E> step = steps.get(i);
+            if (step.kind == UPDATE && step.from < index && index < step.to) {
+                Step<E> tail = new Step<E>(UPDATE, index, step.to);
+                step.to = index;
+                steps.add(i + 1, tail);
+                return;
+            }
+        }
+    }
+
+    /// Drops the steps that ended up describing nothing and joins the
+    /// neighbours of the same kind that touch.
+    private void tidy() {
+        for (int i = steps.size() - 1; i >= 0; i--) {
+            Step<E> step = steps.get(i);
+            if (step.from == step.to && (step.kind == UPDATE || step.removed.isEmpty())) {
+                steps.remove(i);
+            }
+        }
+        for (int i = 0; i + 1 < steps.size(); i++) {
+            Step<E> first = steps.get(i);
+            Step<E> second = steps.get(i + 1);
+            if (first.kind == second.kind && first.kind != PERMUTATION && first.to == second.from) {
+                first.to = second.to;
+                first.removed.addAll(second.removed);
+                steps.remove(i + 1);
+                i--;
+            }
+        }
+    }
+
+    /// One step of a change.
+    private static final class Step<E> {
+        private int kind;
+        private int from;
+        private int to;
+        private List<E> removed = new ArrayList<E>();
+        private int[] perm;
+
+        Step(int kind, int from, int to) {
+            this.kind = kind;
+            this.from = from;
+            this.to = to;
+        }
+    }
+
+    /// The finished report.
+    private static final class Built<E> extends ListChangeListener.Change<E> {
+        private final List<Step<E>> steps;
+        private int cursor = -1;
+
+        Built(ObservableList<E> list, List<Step<E>> steps) {
+            super(list);
+            this.steps = steps;
+        }
+
+        private Step<E> current() {
+            if (cursor < 0) {
+                throw new IllegalStateException(
+                        "Invalid Change state: next() must be called before inspecting the Change.");
+            }
+            return steps.get(cursor);
+        }
+
+        @Override
+        public boolean next() {
+            if (cursor + 1 < steps.size()) {
+                cursor++;
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public void reset() {
+            cursor = -1;
+        }
+
+        @Override
+        public int getFrom() {
+            return current().from;
+        }
+
+        @Override
+        public int getTo() {
+            return current().to;
+        }
+
+        @Override
+        public List<E> getRemoved() {
+            Step<E> step = current();
+            if (step.kind == ADD_REMOVE) {
+                return Collections.unmodifiableList(step.removed);
+            }
+            return Collections.<E>emptyList();
+        }
+
+        @Override
+        protected int[] getPermutation() {
+            Step<E> step = current();
+            return step.kind == PERMUTATION ? step.perm : NO_PERMUTATION;
+        }
+
+        @Override
+        public boolean wasUpdated() {
+            return current().kind == UPDATE;
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder result = new StringBuilder("{ ");
+            for (int i = 0; i < steps.size(); i++) {
+                Step<E> step = steps.get(i);
+                if (i > 0) {
+                    result.append(", ");
+                }
+                if (step.kind == PERMUTATION) {
+                    result.append("permutated [").append(step.from).append(", ").append(step.to).append(')');
+                } else if (step.kind == UPDATE) {
+                    result.append("updated [").append(step.from).append(", ").append(step.to).append(')');
+                } else {
+                    result.append(step.removed).append(" replaced by [").append(step.from).append(", ")
+                            .append(step.to).append(')');
+                }
+            }
+            return result.append(" }").toString();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ListenerSet.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ListenerSet.java
new file mode 100644
index 00000000000..3d3c73e71f0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ListenerSet.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+
+/// The listeners of one observable: its invalidation listeners and its
+/// change listeners of type `L`.
+///
+/// Both lists are replaced, never edited, when a listener is added or
+/// removed, so a notification in progress keeps walking the list it started
+/// with and a listener may add or remove listeners freely. An owner with no
+/// listeners holds `null` instead of an empty set, which is why every
+/// operation is static and returns the set to keep.
+public final class ListenerSet<L> {
+
+    private List<InvalidationListener> invalidation = Collections.emptyList();
+    private List<L> change = Collections.emptyList();
+
+    private ListenerSet() {
+    }
+
+    /// Returns a copy with a listener appended and without the weak
+    /// listeners whose target is gone.
+    static <X> List<X> plus(List<X> source, X listener) {
+        if (listener == null) {
+            throw new NullPointerException();
+        }
+        List<X> result = new ArrayList<X>(source.size() + 1);
+        for (int i = 0; i < source.size(); i++) {
+            X existing = source.get(i);
+            if (!(existing instanceof WeakListener) || !((WeakListener) existing).wasGarbageCollected()) {
+                result.add(existing);
+            }
+        }
+        result.add(listener);
+        return result;
+    }
+
+    /// Returns a copy without the first listener equal to the given one, or
+    /// the list itself when there is none.
+    static <X> List<X> minus(List<X> source, Object listener) {
+        if (listener == null) {
+            throw new NullPointerException();
+        }
+        int index = source.indexOf(listener);
+        if (index < 0) {
+            return source;
+        }
+        List<X> result = new ArrayList<X>(source);
+        result.remove(index);
+        return result;
+    }
+
+    /// Adds an invalidation listener.
+    public static <L> ListenerSet<L> addInvalidation(ListenerSet<L> set, InvalidationListener listener) {
+        ListenerSet<L> result = set == null ? new ListenerSet<L>() : set;
+        result.invalidation = plus(result.invalidation, listener);
+        return result;
+    }
+
+    /// Removes an invalidation listener; returns `null` once nothing is left.
+    public static <L> ListenerSet<L> removeInvalidation(ListenerSet<L> set, InvalidationListener listener) {
+        if (listener == null) {
+            throw new NullPointerException();
+        }
+        if (set == null) {
+            return null;
+        }
+        set.invalidation = minus(set.invalidation, listener);
+        return set.invalidation.isEmpty() && set.change.isEmpty() ? null : set;
+    }
+
+    /// Adds a change listener.
+    public static <L> ListenerSet<L> addChange(ListenerSet<L> set, L listener) {
+        ListenerSet<L> result = set == null ? new ListenerSet<L>() : set;
+        result.change = plus(result.change, listener);
+        return result;
+    }
+
+    /// Removes a change listener; returns `null` once nothing is left.
+    public static <L> ListenerSet<L> removeChange(ListenerSet<L> set, Object listener) {
+        if (listener == null) {
+            throw new NullPointerException();
+        }
+        if (set == null) {
+            return null;
+        }
+        set.change = minus(set.change, listener);
+        return set.invalidation.isEmpty() && set.change.isEmpty() ? null : set;
+    }
+
+    /// Tells every invalidation listener that the observable is invalid.
+    public static void fireInvalidation(ListenerSet<?> set, Observable observable) {
+        if (set != null) {
+            List<InvalidationListener> listeners = set.invalidation;
+            for (int i = 0; i < listeners.size(); i++) {
+                listeners.get(i).invalidated(observable);
+            }
+        }
+    }
+
+    /// Returns the change listeners as they are now; the result is never
+    /// modified afterwards and must not be modified by the caller.
+    public static <L> List<L> changeListeners(ListenerSet<L> set) {
+        if (set == null) {
+            return Collections.emptyList();
+        }
+        return set.change;
+    }
+
+    /// Returns whether the set holds any listener at all.
+    public static boolean hasListeners(ListenerSet<?> set) {
+        return set != null;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Matrix2D.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Matrix2D.java
new file mode 100644
index 00000000000..8cac08afed7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Matrix2D.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// Arithmetic on the affine matrices the layer passes around as
+/// `{a, b, c, d, tx, ty}`: `x' = a*x + c*y + tx`, `y' = b*x + d*y + ty`.
+/// In JavaFX's names that is `{mxx, myx, mxy, myy, tx, ty}`.
+public final class Matrix2D {
+
+    private Matrix2D() {
+    }
+
+    /// Returns a new identity matrix.
+    public static double[] identity() {
+        return new double[] {1, 0, 0, 1, 0, 0};
+    }
+
+    /// Returns whether a matrix changes nothing.
+    public static boolean isIdentity(double[] m) {
+        return Double.compare(m[0], 1) == 0 && isZero(m[1]) && isZero(m[2]) && Double.compare(m[3], 1) == 0
+                && isZero(m[4]) && isZero(m[5]);
+    }
+
+    private static boolean isZero(double v) {
+        // Both zeroes count.
+        return !(v > 0) && !(v < 0) && !Double.isNaN(v);
+    }
+
+    /// Returns `left x right`: the matrix that applies `right` first and
+    /// `left` to its result.
+    public static double[] multiply(double[] left, double[] right) {
+        return new double[] {left[0] * right[0] + left[2] * right[1], left[1] * right[0] + left[3] * right[1],
+            left[0] * right[2] + left[2] * right[3], left[1] * right[2] + left[3] * right[3],
+            left[0] * right[4] + left[2] * right[5] + left[4], left[1] * right[4] + left[3] * right[5] + left[5]};
+    }
+
+    /// Returns the determinant of the linear part.
+    public static double determinant(double[] m) {
+        return m[0] * m[3] - m[1] * m[2];
+    }
+
+    /// Writes the inverse of a matrix into `out` and answers `true`;
+    /// answers `false`, leaving `out` alone, when it has none.
+    public static boolean invert(double[] m, double[] out) {
+        double det = determinant(m);
+        if (isZero(det) || Double.isNaN(det) || Double.isInfinite(det)) {
+            return false;
+        }
+        double a = m[3] / det;
+        double b = -m[1] / det;
+        double c = -m[2] / det;
+        double d = m[0] / det;
+        double tx = -(a * m[4] + c * m[5]);
+        double ty = -(b * m[4] + d * m[5]);
+        out[0] = a;
+        out[1] = b;
+        out[2] = c;
+        out[3] = d;
+        out[4] = tx;
+        out[5] = ty;
+        return true;
+    }
+
+    /// Returns the x of a point mapped through a matrix.
+    public static double x(double[] m, double x, double y) {
+        return m[0] * x + m[2] * y + m[4];
+    }
+
+    /// Returns the y of a point mapped through a matrix.
+    public static double y(double[] m, double x, double y) {
+        return m[1] * x + m[3] * y + m[5];
+    }
+
+    /// Returns the factor a matrix scales lengths by, the square root of
+    /// the area it maps a unit square to.
+    public static double uniformScale(double[] m) {
+        return Math.sqrt(Math.abs(determinant(m)));
+    }
+
+    /// Returns the bounds `{minX, minY, maxX, maxY}` of a rectangle mapped
+    /// through a matrix.
+    public static double[] bounds(double[] m, double x, double y, double w, double h) {
+        double[] xs = {x, x + w, x + w, x};
+        double[] ys = {y, y, y + h, y + h};
+        double minX = Double.MAX_VALUE;
+        double minY = Double.MAX_VALUE;
+        double maxX = -Double.MAX_VALUE;
+        double maxY = -Double.MAX_VALUE;
+        for (int i = 0; i < 4; i++) {
+            double px = x(m, xs[i], ys[i]);
+            double py = y(m, xs[i], ys[i]);
+            minX = Math.min(minX, px);
+            minY = Math.min(minY, py);
+            maxX = Math.max(maxX, px);
+            maxY = Math.max(maxY, py);
+        }
+        return new double[] {minX, minY, maxX, maxY};
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Mnemonics.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Mnemonics.java
new file mode 100644
index 00000000000..76d26ef1a0e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Mnemonics.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// Takes the mark of a mnemonic out of the text of a control.
+///
+/// JavaFX lets an underscore in the text of a button or a menu item mark
+/// the character after it as the mnemonic, the key that with a modifier
+/// fires the control, and does not show the underscore. The scene fires
+/// the control when that key comes with Alt held; the character is not
+/// drawn underlined. The text reads as it does in JavaFX:
+///
+/// - two underscores are one underscore that marks nothing;
+/// - the first single underscore with a character after it is left out;
+/// - the first `_(c)`, the form for a mnemonic that is not a letter of
+///   the text, is left out whole;
+/// - any later single underscore stays as it is, as does one that ends
+///   the text.
+public final class Mnemonics {
+
+    private Mnemonics() {
+    }
+
+    /// Returns the text as it is shown when mnemonics are parsed; `null`
+    /// for `null`.
+    public static String strip(String text) {
+        if (text == null || text.indexOf('_') < 0) {
+            return text;
+        }
+        StringBuilder out = new StringBuilder(text.length());
+        boolean found = false;
+        int n = text.length();
+        for (int i = 0; i < n; i++) {
+            char c = text.charAt(i);
+            if (c != '_' || i + 1 >= n) {
+                out.append(c);
+            } else if (text.charAt(i + 1) == '_') {
+                out.append('_');
+                i++;
+            } else if (found) {
+                out.append(c);
+            } else {
+                found = true;
+                if (text.charAt(i + 1) == '(' && i + 3 < n && text.charAt(i + 3) == ')') {
+                    i += 3;
+                }
+            }
+        }
+        return out.toString();
+    }
+
+    /// Returns the mnemonic a text marks, folded to upper case, or zero
+    /// when it marks none: the character after the first single
+    /// underscore, or the one in brackets after it.
+    public static char key(String text) {
+        if (text == null) {
+            return 0;
+        }
+        int n = text.length();
+        for (int i = 0; i + 1 < n; i++) {
+            if (text.charAt(i) != '_') {
+                continue;
+            }
+            char next = text.charAt(i + 1);
+            if (next == '_') {
+                i++;
+                continue;
+            }
+            if (next == '(' && i + 3 < n && text.charAt(i + 3) == ')') {
+                next = text.charAt(i + 2);
+            }
+            return upper(next);
+        }
+        return 0;
+    }
+
+    /// Folds an ASCII letter to upper case and leaves anything else. A
+    /// mnemonic is matched against a key, which has no locale.
+    public static char upper(char c) {
+        return c >= 'a' && c <= 'z' ? (char) (c - 'a' + 'A') : c;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/NodePeer.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/NodePeer.java
new file mode 100644
index 00000000000..a205a1c0fea
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/NodePeer.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.geom.Dimension;
+
+import javafx.scene.Node;
+
+/// The Codename One component behind a node that draws itself: a shape, a
+/// canvas, text. It has no look of its own; painting is the node's
+/// `cn1Paint`. Pointer events pass through it to the form, which is where
+/// the scene picks its own target.
+public class NodePeer extends Component implements FxPeer {
+
+    private final Node node;
+
+    /// Creates the peer of a node.
+    public NodePeer(Node node) {
+        this.node = node;
+        PeerPaint.strip(this);
+        setFocusable(false);
+    }
+
+    @Override
+    public Node node() {
+        return node;
+    }
+
+    @Override
+    public boolean isIgnorePointerEvents() {
+        return true;
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        if (PeerPaint.unseen(node)) {
+            return;
+        }
+        int old = g.getAlpha();
+        double opacity = node.getOpacity();
+        if (opacity < 1) {
+            g.setAlpha(PeerPaint.alpha(old, opacity));
+        }
+        int cx = g.getClipX();
+        int cy = g.getClipY();
+        int cw = g.getClipWidth();
+        int ch = g.getClipHeight();
+        boolean effect = Effects.has(node);
+        if (effect) {
+            g.setAlpha(old);
+            Effects.paintBehind(g, node, this);
+            g.setAlpha(opacity < 1 ? PeerPaint.alpha(old, opacity) : old);
+        }
+        boolean widened = node.cn1PaintMatrix() != null || node.cn1PaintsOutsideBounds();
+        if (widened) {
+            PeerPaint.widenClip(g, this);
+        }
+        PeerPaint.paintNode(g, node, getX(), getY(), false);
+        if (widened) {
+            g.setClip(cx, cy, cw, ch);
+        }
+        g.setAlpha(old);
+        if (effect) {
+            Effects.paintOver(g, node, this);
+        }
+    }
+
+    /// Paints the node into a picture of its own, for [Effects].
+    void capture(Graphics g) {
+        paint(g);
+    }
+
+    @Override
+    protected void paintBackground(Graphics g) {
+    }
+
+    @Override
+    protected Dimension calcPreferredSize() {
+        return new Dimension(Units.sizeToPixels(node.prefWidth(-1)), Units.sizeToPixels(node.prefHeight(-1)));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ObservableMapWrapper.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ObservableMapWrapper.java
new file mode 100644
index 00000000000..dad48aba293
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ObservableMapWrapper.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import javafx.beans.InvalidationListener;
+import javafx.collections.MapChangeListener;
+import javafx.collections.ObservableMap;
+
+/// The observable map `FXCollections` hands out: a `java.util.Map` whose
+/// modifications are reported one key at a time, also when they are made
+/// through its key, value or entry views.
+public final class ObservableMapWrapper<K, V> extends AbstractMap<K, V> implements ObservableMap<K, V> {
+
+    private final Map<K, V> backing;
+    private ListenerSet<MapChangeListener<? super K, ? super V>> listeners;
+    private Set<Map.Entry<K, V>> entries;
+
+    /// Wraps a map.
+    public ObservableMapWrapper(Map<K, V> backing) {
+        this.backing = backing;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        listeners = ListenerSet.addInvalidation(listeners, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        listeners = ListenerSet.removeInvalidation(listeners, listener);
+    }
+
+    @Override
+    public void addListener(MapChangeListener<? super K, ? super V> listener) {
+        listeners = ListenerSet.addChange(listeners, listener);
+    }
+
+    @Override
+    public void removeListener(MapChangeListener<? super K, ? super V> listener) {
+        listeners = ListenerSet.removeChange(listeners, listener);
+    }
+
+    private void fire(K key, V removed, V added, boolean wasAdded, boolean wasRemoved) {
+        if (ListenerSet.hasListeners(listeners)) {
+            Changes.fire(listeners, this, new Changes.OfMap<K, V>(this, key, removed, added, wasAdded, wasRemoved));
+        }
+    }
+
+    @Override
+    public int size() {
+        return backing.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return backing.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return backing.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return backing.containsValue(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return backing.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        boolean present = backing.containsKey(key);
+        V old = backing.put(key, value);
+        if (!present) {
+            fire(key, null, value, true, false);
+        } else if (old == null ? value != null : !old.equals(value)) {
+            fire(key, old, value, true, true);
+        }
+        return old;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public V remove(Object key) {
+        if (!backing.containsKey(key)) {
+            return null;
+        }
+        V old = backing.remove(key);
+        fire((K) key, old, null, false, true);
+        return old;
+    }
+
+    @Override
+    public void clear() {
+        for (Iterator<Map.Entry<K, V>> it = backing.entrySet().iterator(); it.hasNext();) {
+            Map.Entry<K, V> entry = it.next();
+            K key = entry.getKey();
+            V value = entry.getValue();
+            it.remove();
+            fire(key, value, null, false, true);
+        }
+    }
+
+    @Override
+    public Set<Map.Entry<K, V>> entrySet() {
+        if (entries == null) {
+            entries = new AbstractSet<Map.Entry<K, V>>() {
+                @Override
+                public int size() {
+                    return backing.size();
+                }
+
+                @Override
+                public Iterator<Map.Entry<K, V>> iterator() {
+                    return new EntryIterator();
+                }
+            };
+        }
+        return entries;
+    }
+
+    /// Walks the entries, reporting a removal made through the iterator and
+    /// a value set through an entry.
+    private final class EntryIterator implements Iterator<Map.Entry<K, V>> {
+        private final Iterator<Map.Entry<K, V>> source = backing.entrySet().iterator();
+        // The entry next() returned last. Its value is read when it is
+        // removed, not remembered at next(): a setValue on it, or on an
+        // entry handed out earlier, must not change what a removal reports.
+        private Map.Entry<K, V> last;
+
+        @Override
+        public boolean hasNext() {
+            return source.hasNext();
+        }
+
+        @Override
+        public Map.Entry<K, V> next() {
+            final Map.Entry<K, V> entry = source.next();
+            last = entry;
+            return new Map.Entry<K, V>() {
+                @Override
+                public K getKey() {
+                    return entry.getKey();
+                }
+
+                @Override
+                public V getValue() {
+                    return entry.getValue();
+                }
+
+                @Override
+                public V setValue(V value) {
+                    V old = entry.setValue(value);
+                    if (old == null ? value != null : !old.equals(value)) {
+                        fire(entry.getKey(), old, value, true, true);
+                    }
+                    return old;
+                }
+
+                @Override
+                public boolean equals(Object other) {
+                    return entry.equals(other);
+                }
+
+                @Override
+                public int hashCode() {
+                    return entry.hashCode();
+                }
+
+                @Override
+                public String toString() {
+                    return entry.toString();
+                }
+            };
+        }
+
+        @Override
+        public void remove() {
+            if (last == null) {
+                throw new IllegalStateException();
+            }
+            // Read before removing: a TreeMap may reuse the removed node for
+            // its successor.
+            K key = last.getKey();
+            V old = last.getValue();
+            source.remove();
+            last = null;
+            fire(key, old, null, false, true);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ObservableSetWrapper.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ObservableSetWrapper.java
new file mode 100644
index 00000000000..54166fac286
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ObservableSetWrapper.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.AbstractSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import javafx.beans.InvalidationListener;
+import javafx.collections.ObservableSet;
+import javafx.collections.SetChangeListener;
+
+/// The observable set `FXCollections` hands out: a `java.util.Set` whose
+/// modifications are reported one element at a time.
+public final class ObservableSetWrapper<E> extends AbstractSet<E> implements ObservableSet<E> {
+
+    private final Set<E> backing;
+    private ListenerSet<SetChangeListener<? super E>> listeners;
+
+    /// Wraps a set.
+    public ObservableSetWrapper(Set<E> backing) {
+        this.backing = backing;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        listeners = ListenerSet.addInvalidation(listeners, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        listeners = ListenerSet.removeInvalidation(listeners, listener);
+    }
+
+    @Override
+    public void addListener(SetChangeListener<? super E> listener) {
+        listeners = ListenerSet.addChange(listeners, listener);
+    }
+
+    @Override
+    public void removeListener(SetChangeListener<? super E> listener) {
+        listeners = ListenerSet.removeChange(listeners, listener);
+    }
+
+    private void fire(E element, boolean added) {
+        if (ListenerSet.hasListeners(listeners)) {
+            Changes.fire(listeners, this, new Changes.OfSet<E>(this, element, added));
+        }
+    }
+
+    @Override
+    public int size() {
+        return backing.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return backing.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return backing.contains(o);
+    }
+
+    @Override
+    public boolean add(E element) {
+        if (backing.add(element)) {
+            fire(element, true);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean remove(Object o) {
+        if (backing.remove(o)) {
+            fire((E) o, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void clear() {
+        for (Iterator<E> it = backing.iterator(); it.hasNext();) {
+            E element = it.next();
+            it.remove();
+            fire(element, false);
+        }
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        final Iterator<E> source = backing.iterator();
+        return new Iterator<E>() {
+            private E last;
+
+            @Override
+            public boolean hasNext() {
+                return source.hasNext();
+            }
+
+            @Override
+            public E next() {
+                last = source.next();
+                return last;
+            }
+
+            @Override
+            public void remove() {
+                source.remove();
+                fire(last, false);
+            }
+        };
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ParentPeer.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ParentPeer.java
new file mode 100644
index 00000000000..4dfd377220e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ParentPeer.java
@@ -0,0 +1,383 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+import com.codename1.ui.Transform;
+import com.codename1.ui.events.WheelEvent;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.Layout;
+
+import javafx.scene.Group;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Paint;
+
+/// The Codename One container behind a parent node. It holds the peers of
+/// the children, draws what the parent draws itself (a region's
+/// background and border) below them, and applies the parent's opacity,
+/// scale and rotation to all of it.
+///
+/// Its layout manager runs JavaFX layout, and only in the peer of a root:
+/// that pass places the whole tree, and every node pushes its own bounds
+/// into its peer as it is placed.
+public class ParentPeer extends Container implements FxPeer {
+
+    private final Parent node;
+    private int childClipX;
+    private int childClipY;
+    private int childClipW;
+    private int childClipH;
+    private int painting;
+
+    /// Creates the peer of a parent.
+    public ParentPeer(Parent node) {
+        super(new Bridge());
+        this.node = node;
+        PeerPaint.strip(this);
+        setScrollable(false);
+        setFocusable(false);
+    }
+
+    @Override
+    public Parent node() {
+        return node;
+    }
+
+    /// The area the children may paint in, in their coordinates; answers
+    /// false when there is none to give.
+    ///
+    /// While this peer paints its children it is the clip it painted them
+    /// with. That clip must not be kept for later, though. Codename One
+    /// also paints a peer on its own -- the one that asked to be painted
+    /// again -- and paints the peers lying over it clipped to that one's
+    /// area; a clip recorded during such a pass is that small area, and a
+    /// pane painted on its own afterwards took it for all it may draw in
+    /// and drew nothing. So outside a paint of this peer the area is
+    /// worked out from where the peers are.
+    public boolean childClip(int[] out) {
+        if (painting > 0) {
+            out[0] = childClipX;
+            out[1] = childClipY;
+            out[2] = childClipW;
+            out[3] = childClipH;
+            return true;
+        }
+        return allowed(out);
+    }
+
+    /// The area the children of this peer may ever paint in: its own
+    /// bounds where it cuts them off, and whatever its parent allows
+    /// where it does not. Answers false under a transform or a clip of
+    /// the application's, neither of which is a rectangle of the screen;
+    /// what asks then keeps the clip it has.
+    private boolean allowed(int[] out) {
+        if (node.cn1PaintMatrix() != null || node.cn1ClipPath() != null) {
+            return false;
+        }
+        Container above = getParent();
+        if (!(above instanceof ParentPeer)) {
+            out[0] = 0;
+            out[1] = 0;
+            out[2] = getWidth();
+            out[3] = getHeight();
+            return true;
+        }
+        if (!((ParentPeer) above).allowed(out)) {
+            return false;
+        }
+        out[0] -= getX();
+        out[1] -= getY();
+        if (clipsChildren(node)) {
+            int x1 = Math.max(0, out[0]);
+            int y1 = Math.max(0, out[1]);
+            int x2 = Math.min(getWidth(), out[0] + out[2]);
+            int y2 = Math.min(getHeight(), out[1] + out[3]);
+            out[0] = x1;
+            out[1] = y1;
+            out[2] = Math.max(0, x2 - x1);
+            out[3] = Math.max(0, y2 - y1);
+        }
+        return true;
+    }
+
+    /// Returns whether what is in a parent is cut off at its bounds. A
+    /// pane and a group draw their children whole wherever they are; a
+    /// control, whose skin holds a viewport, does not.
+    public static boolean clipsChildren(Parent parent) {
+        return !(parent instanceof Pane || parent instanceof Group);
+    }
+
+    /// Returns whether a parent above this one is scaled, rotated or
+    /// otherwise transformed.
+    public static boolean underTransform(Parent parent) {
+        for (Parent above = parent.getParent(); above != null; above = above.getParent()) {
+            if (above.cn1PaintMatrix() != null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        if (PeerPaint.unseen(node)) {
+            return;
+        }
+        int old = g.getAlpha();
+        double opacity = PeerPaint.opacity(node);
+        if (opacity < 1) {
+            g.setAlpha(PeerPaint.alpha(old, opacity));
+        }
+        double[] m = node.cn1PaintMatrix();
+        int cx = g.getClipX();
+        int cy = g.getClipY();
+        int cw = g.getClipWidth();
+        int ch = g.getClipHeight();
+        // A pane or a group does not clip what is in it: a child larger
+        // than the pane, or placed beyond its edge, is drawn whole. Codename
+        // One clips a container to its bounds, so the clip is the parent's
+        // again. A control keeps its own, which is what holds the content
+        // of a scroll pane or a list inside it.
+        //
+        // Not under a scale or a rotation, though: the clip recorded by
+        // the parent is in the coordinates of the screen, and under a
+        // transform the graphics reads it in the transformed ones.
+        boolean widened = m != null || (!clipsChildren(node) && !underTransform(node));
+        if (widened) {
+            PeerPaint.widenClip(g, this);
+        }
+        boolean clipped = PeerPaint.pushClip(g, node, getX(), getY());
+        // Codename One paints the children translated by this peer's origin.
+        childClipX = g.getClipX() - getX();
+        childClipY = g.getClipY() - getY();
+        childClipW = g.getClipWidth();
+        childClipH = g.getClipHeight();
+        int bx = g.getClipX();
+        int by = g.getClipY();
+        int bw = g.getClipWidth();
+        int bh = g.getClipHeight();
+        Transform saved = PeerPaint.push(g, node, m, getX(), getY());
+        // Codename One paints a child only where its bounds meet the clip,
+        // and compares the two as numbers. Under a matrix, on a port whose
+        // clip stays in the coordinates of the screen, those numbers are in
+        // two different spaces: a child drawn well inside the window was
+        // found outside the clip and never painted. The clip handed down
+        // is therefore widened to hold every child, here and in each
+        // parent below while the matrix is in force, and put back after.
+        // Each child is still clipped to its own bounds when it paints.
+        boolean screen = PeerPaint.underScreenClip()
+                || (saved != null && PeerPaint.clipStaysOnScreen(g, saved, bx, by, bw, bh));
+        if (screen) {
+            PeerPaint.includeChildren(g, this);
+            PeerPaint.screenClip(1);
+        }
+        painting++;
+        try {
+            if (screen && hostsAComponent()) {
+                paintChildrenOffTheMatrix(g);
+            } else {
+                super.paint(g);
+            }
+        } finally {
+            painting--;
+            if (screen) {
+                PeerPaint.screenClip(-1);
+            }
+        }
+        if (saved != null) {
+            PeerPaint.setDeviceTransform(g, saved);
+        }
+        if (clipped) {
+            g.popClip();
+        }
+        if (widened || screen) {
+            g.setClip(cx, cy, cw, ch);
+        }
+        g.setAlpha(old);
+        if (Effects.has(node)) {
+            Effects.paintOver(g, node, this);
+        }
+    }
+
+    /// Whether one of the children is a Codename One component rather than
+    /// the peer of a node: the label, button or field a control is shown by.
+    private boolean hostsAComponent() {
+        int n = getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = getComponentAt(i);
+            if (!(c instanceof FxPeer) && c.isVisible() && c.getWidth() > 0 && c.getHeight() > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Paints the children of a control under a matrix on a port that keeps
+    /// its clip in the coordinates of the screen (see
+    /// [PeerPaint#clipStaysOnScreen]), in place of Codename One doing it.
+    ///
+    /// The component a control is shown by is Codename One's own, and paints
+    /// as one: a label narrows the clip to its text with a rectangle made
+    /// of where the text goes and of the clip it reads back from the port.
+    /// On such a port the first is in the coordinates drawing is given in
+    /// and the second in the screen's, so the rectangle is in neither and
+    /// the text of every label under a scale was clipped away -- the
+    /// number on each tile of 2048, and its score. Nothing the layer hands
+    /// down as a clip makes those two agree, so the component paints where
+    /// no matrix is installed, into a picture of its own size, and the
+    /// picture is drawn under the matrix. The peers beside it are painted
+    /// as Codename One paints them: clipped to their bounds, background
+    /// first.
+    private void paintChildrenOffTheMatrix(Graphics g) {
+        g.translate(getX(), getY());
+        try {
+            int n = getComponentCount();
+            for (int i = 0; i < n; i++) {
+                Component c = getComponentAt(i);
+                if (!c.isVisible() || c.getWidth() <= 0 || c.getHeight() <= 0) {
+                    continue;
+                }
+                if (!(c instanceof FxPeer)) {
+                    Image picture = c.toImage();
+                    if (picture != null) {
+                        g.drawImage(picture, c.getX(), c.getY());
+                    }
+                    continue;
+                }
+                int cx = g.getClipX();
+                int cy = g.getClipY();
+                int cw = g.getClipWidth();
+                int ch = g.getClipHeight();
+                g.clipRect(c.getX(), c.getY(), c.getWidth(), c.getHeight());
+                if (c instanceof ParentPeer) {
+                    ((ParentPeer) c).capture(g);
+                } else if (c instanceof NodePeer) {
+                    ((NodePeer) c).capture(g);
+                }
+                g.setClip(cx, cy, cw, ch);
+            }
+        } finally {
+            g.translate(-getX(), -getY());
+        }
+    }
+
+    /// Paints the node and everything in it into a picture of its own,
+    /// for [Effects]: what Codename One paints for a container, without
+    /// the backgrounds of what is above it.
+    void capture(Graphics g) {
+        paintBackground(g);
+        paint(g);
+    }
+
+    @Override
+    protected void paintBackground(Graphics g) {
+        int old = g.getAlpha();
+        Scene scene = node.getScene();
+        if (node.getParent() == null && scene != null) {
+            Paint fill = scene.getFill();
+            if (fill != null) {
+                new Renderer(g, getX(), getY()).fillRect(0, 0, Units.toLogical(getWidth()),
+                        Units.toLogical(getHeight()), fill);
+            }
+        }
+        if (PeerPaint.unseen(node)) {
+            return;
+        }
+        if (Effects.has(node)) {
+            Effects.paintBehind(g, node, this);
+        }
+        double opacity = PeerPaint.opacity(node);
+        if (opacity < 1) {
+            g.setAlpha(PeerPaint.alpha(old, opacity));
+        }
+        double[] m = node.cn1PaintMatrix();
+        int cx = g.getClipX();
+        int cy = g.getClipY();
+        int cw = g.getClipWidth();
+        int ch = g.getClipHeight();
+        if (m != null) {
+            PeerPaint.widenClip(g, this);
+        }
+        PeerPaint.paintNode(g, node, getX(), getY(), false);
+        if (m != null) {
+            g.setClip(cx, cy, cw, ch);
+        }
+        g.setAlpha(old);
+    }
+
+    @Override
+    protected Dimension calcPreferredSize() {
+        return new Dimension(Units.sizeToPixels(node.prefWidth(-1)), Units.sizeToPixels(node.prefHeight(-1)));
+    }
+
+    @Override
+    protected boolean mouseWheel(WheelEvent ev) {
+        if (node.getParent() == null && node.getScene() != null && SceneInput.wheel(node.getScene(), this,
+                ev.getX(), ev.getY(), ev.getDeltaX(), ev.getDeltaY())) {
+            ev.consume();
+            return true;
+        }
+        return super.mouseWheel(ev);
+    }
+
+    /// Runs JavaFX layout from the peer of a root.
+    static final class Bridge extends Layout {
+
+        @Override
+        public void layoutContainer(Container parent) {
+            if (!(parent instanceof ParentPeer)) {
+                return;
+            }
+            Parent node = ((ParentPeer) parent).node;
+            if (node.getParent() != null) {
+                return;
+            }
+            int w = parent.getWidth();
+            int h = parent.getHeight();
+            if (w <= 0 && h <= 0) {
+                return;
+            }
+            Scene scene = node.getScene();
+            if (scene != null) {
+                scene.cn1Layout(Units.toLogical(w), Units.toLogical(h));
+            } else {
+                node.resize(Units.toLogical(w), Units.toLogical(h));
+                node.layout();
+            }
+        }
+
+        @Override
+        public Dimension getPreferredSize(Container parent) {
+            if (!(parent instanceof ParentPeer)) {
+                return new Dimension(0, 0);
+            }
+            Parent node = ((ParentPeer) parent).node;
+            return new Dimension(Units.sizeToPixels(node.prefWidth(-1)), Units.sizeToPixels(node.prefHeight(-1)));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PeerPaint.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PeerPaint.java
new file mode 100644
index 00000000000..a85eb425c9f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PeerPaint.java
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Transform;
+import com.codename1.ui.plaf.Border;
+import com.codename1.ui.plaf.Style;
+
+import javafx.geometry.Bounds;
+import javafx.scene.Node;
+import javafx.scene.control.Control;
+
+/// What the peers share: stripping a component of its Codename One look,
+/// and painting a node with its opacity, scale and rotation.
+///
+/// A leaf draws through a [Renderer], which carries the node's matrix
+/// itself. A parent's children are Codename One components that know
+/// nothing of the matrix, so it is installed on the graphics as a native
+/// transform around them, where the port supports one.
+public final class PeerPaint {
+
+    private PeerPaint() {
+    }
+
+    /// Removes everything Codename One would draw or reserve for a
+    /// component of its own: background, border, padding and margin.
+    public static void strip(Component c) {
+        c.setUIID("FxNode");
+        Style s = c.getAllStyles();
+        s.setBgTransparency(0);
+        s.setBgImage(null);
+        s.setBorder(Border.createEmpty());
+        s.setPadding(0, 0, 0, 0);
+        s.setMargin(0, 0, 0, 0);
+    }
+
+    /// Every style a native component is drawn with, as one: what is set
+    /// on the answer is set on each.
+    ///
+    /// `Component.getAllStyles()` is the styles at rest, selected, pressed
+    /// and disabled, and leaves out the one a theme may declare for a
+    /// component under the pointer. A font or a colour set through it was
+    /// therefore not the font or the colour of a hovered control: its
+    /// text changed size where it was sized for the font at rest, and the
+    /// last letter was cut off for as long as the pointer stayed.
+    public static Style allStyles(Component c) {
+        Style hover = c.getHoverStyle();
+        if (hover == null) {
+            return c.getAllStyles();
+        }
+        return Style.createProxyStyle(c.getUnselectedStyle(), c.getSelectedStyle(), c.getPressedStyle(),
+                c.getDisabledStyle(), hover);
+    }
+
+    /// Whether nothing of a node can be seen: it is fully transparent, or
+    /// its matrix leaves it no area. The peers then paint nothing at all.
+    /// A native component under a transparent node is the reason this is
+    /// asked rather than left to the alpha: a theme may draw its text with
+    /// an alpha of its own, and a label faded out to nothing stayed.
+    static boolean unseen(Node node) {
+        return !(node.getOpacity() > 0) || collapsed(node.cn1PaintMatrix());
+    }
+
+    /// Whether a node's matrix maps everything onto a line or a point, as a
+    /// scale of zero does -- the first frame of a node that grows into view.
+    /// Nothing of such a node is visible, and a matrix that cannot be
+    /// inverted leaves a port without a clip to answer, so the peers paint
+    /// nothing rather than install it.
+    static boolean collapsed(double[] m) {
+        if (m == null) {
+            return false;
+        }
+        double det = m[0] * m[3] - m[1] * m[2];
+        return !(det > 1e-12 || det < -1e-12);
+    }
+
+    /// The opacity JavaFX draws a disabled control with.
+    public static final double DISABLED_OPACITY = 0.4;
+
+    /// Returns the opacity a parent is painted with: its own, and for a
+    /// disabled control the dimming JavaFX gives one. The outermost
+    /// disabled control dims everything in it, the controls inside
+    /// included, so those do not dim a second time.
+    public static double opacity(Node node) {
+        double o = node.getOpacity();
+        if (node instanceof Control && node.isDisabled()) {
+            for (Node up = node.getParent(); up != null; up = up.getParent()) {
+                if (up instanceof Control && up.isDisabled()) {
+                    return o;
+                }
+            }
+            return o * DISABLED_OPACITY;
+        }
+        return o;
+    }
+
+    /// Returns the graphics alpha for a node drawn with an opacity.
+    static int alpha(int base, double opacity) {
+        double o = opacity < 0 ? 0 : (opacity > 1 ? 1 : opacity);
+        return (int) Math.round(base * o);
+    }
+
+    /// Lets a transformed node paint anywhere its parent may: a rotated or
+    /// scaled node is clipped by its parent, not by its own bounds.
+    static void widenClip(Graphics g, Component peer) {
+        Component parent = peer.getParent();
+        if (parent instanceof ParentPeer) {
+            int[] c = new int[4];
+            if (((ParentPeer) parent).childClip(c)) {
+                g.setClip(c[0], c[1], c[2], c[3]);
+            }
+        }
+    }
+
+    /// Whether the port keeps its clip in the coordinates of the screen
+    /// while a matrix is installed, asked right after one was: `before` is
+    /// the transform that was replaced and the rectangle is the clip read
+    /// under it.
+    ///
+    /// A port either answers the clip in the coordinates drawing is given
+    /// in, so that the numbers change with the matrix, or in those of the
+    /// screen, so that they do not. Only the second kind needs
+    /// [#includeChildren]; widening on the first would let what is inside a
+    /// viewport paint outside it. Unchanged numbers under a matrix that
+    /// moves the rectangle are what tells the two apart, and a matrix that
+    /// leaves the rectangle where it was needs nothing on either.
+    static boolean clipStaysOnScreen(Graphics g, Transform before, int x, int y, int w, int h) {
+        if (w <= 0 || h <= 0 || g.getClipX() != x || g.getClipY() != y || g.getClipWidth() != w
+                || g.getClipHeight() != h) {
+            return false;
+        }
+        Transform now = g.getTransform();
+        int ox = g.getTranslateX() + x;
+        int oy = g.getTranslateY() + y;
+        float[] in = new float[2];
+        float[] a = new float[2];
+        float[] b = new float[2];
+        for (int i = 0; i < 4; i++) {
+            in[0] = ox + ((i & 1) == 0 ? 0 : w);
+            in[1] = oy + ((i & 2) == 0 ? 0 : h);
+            before.transformPoint(in, a);
+            now.transformPoint(in, b);
+            if (Math.abs(a[0] - b[0]) > 1 || Math.abs(a[1] - b[1]) > 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// How many parents are painting their children under a matrix on a
+    /// port that keeps its clip in the coordinates of the screen. Painting
+    /// is on one thread.
+    private static int screenClipDepth;
+
+    /// Whether a parent further up is painting under such a matrix: the
+    /// parents below it widen their clip as well, since theirs is in the
+    /// same two spaces.
+    static boolean underScreenClip() {
+        return screenClipDepth > 0;
+    }
+
+    /// Whether this graphics is one that such a parent is painting on, with
+    /// a matrix installed: a clip read from it is not in the coordinates
+    /// drawing is given in. An image painted on in the meantime, with no
+    /// matrix of its own, is not.
+    static boolean screenClipUnderMatrix(Graphics g) {
+        return screenClipDepth > 0 && g.isTransformSupported() && !g.getTransform().isIdentity();
+    }
+
+    /// Enters (1) or leaves (-1) a parent that widened its clip.
+    static void screenClip(int by) {
+        screenClipDepth += by;
+    }
+
+    /// Widens the clip to hold every child of a peer about to paint them;
+    /// the caller restores the clip afterwards. See [#clipStaysOnScreen].
+    static void includeChildren(Graphics g, com.codename1.ui.Container peer) {
+        int x1 = g.getClipX();
+        int y1 = g.getClipY();
+        int x2 = x1 + g.getClipWidth();
+        int y2 = y1 + g.getClipHeight();
+        if (x2 <= x1 || y2 <= y1) {
+            return;
+        }
+        int ox = peer.getX() - peer.getScrollX();
+        int oy = peer.getY() - peer.getScrollY();
+        int n = peer.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = peer.getComponentAt(i);
+            x1 = Math.min(x1, ox + c.getX());
+            y1 = Math.min(y1, oy + c.getY());
+            x2 = Math.max(x2, ox + c.getX() + c.getWidth());
+            y2 = Math.max(y2, oy + c.getY() + c.getHeight());
+        }
+        g.setClip(x1, y1, x2 - x1, y2 - y1);
+    }
+
+    /// Installs a node's matrix on the graphics for a peer at a position;
+    /// answers the transform to restore, or `null` when nothing was done.
+    static Transform push(Graphics g, Node node, double[] m, int x, int y) {
+        if (m == null || !g.isTransformSupported()) {
+            return null;
+        }
+        Bounds lb = node.getLayoutBounds();
+        double[] d = deviceMatrix(m, lb.getMinX(), lb.getMinY(), Units.scale(), g.getTranslateX() + x,
+                g.getTranslateY() + y);
+        Transform saved = Transform.makeIdentity();
+        g.getTransform(saved);
+        Transform t = saved.copy();
+        t.concatenate(Transform.makeAffine(d[0], d[1], d[2], d[3], d[4], d[5]));
+        setDeviceTransform(g, t);
+        return saved;
+    }
+
+    /// A node's matrix, which is in logical units about the origin of its
+    /// layout bounds `(lx, ly)`, as the matrix in pixels for a peer whose
+    /// origin is drawn at `(ox, oy)`: a point of the peer stays where the
+    /// node's matrix puts it, whatever the peer's position.
+    public static double[] deviceMatrix(double[] m, double lx, double ly, double scale, double ox, double oy) {
+        double px = -ox / scale + lx;
+        double py = -oy / scale + ly;
+        return new double[] {m[0], m[1], m[2], m[3],
+            (m[0] * px + m[2] * py + m[4] - lx) * scale + ox,
+            (m[1] * px + m[3] * py + m[5] - ly) * scale + oy};
+    }
+
+    /// Sets a transform that acts on what is drawn where it is drawn.
+    ///
+    /// `Graphics.setTransform` called under a translation keeps the matrix
+    /// as one about the translated origin, and moves it along with every
+    /// later `translate`. A matrix installed for a parent would then scale
+    /// each child about the child's own corner, and a matrix read back and
+    /// restored further down the tree would be re-based on that place: the
+    /// siblings painted after a scaled node landed somewhere else. Set at
+    /// no translation, the matrix is the port's own and stays put.
+    static void setDeviceTransform(Graphics g, Transform t) {
+        int tx = g.getTranslateX();
+        int ty = g.getTranslateY();
+        if (tx == 0 && ty == 0) {
+            g.setTransform(t);
+            return;
+        }
+        g.translate(-tx, -ty);
+        g.setTransform(t);
+        g.translate(tx, ty);
+    }
+
+    private static Renderer renderer(Graphics g, Node node, int x, int y, boolean matrixInstalled) {
+        Renderer r = new Renderer(g, x, y);
+        Bounds lb = node.getLayoutBounds();
+        r.translate(-lb.getMinX(), -lb.getMinY());
+        if (!matrixInstalled) {
+            double[] m = node.cn1PaintMatrix();
+            if (m != null) {
+                r.concat(m[0], m[1], m[2], m[3], m[4], m[5]);
+            }
+        }
+        return r;
+    }
+
+    /// Restricts the graphics to the clip of a node, for a peer at a
+    /// position; answers whether a clip was pushed, which the caller
+    /// then pops with `Graphics.popClip()`. The clip is pushed after any
+    /// widening, so it is the node's clip that holds for its children.
+    static boolean pushClip(Graphics g, Node node, int x, int y) {
+        FxPath clip = node.cn1ClipPath();
+        if (clip == null) {
+            return false;
+        }
+        renderer(g, node, x, y, false).clip(clip);
+        return true;
+    }
+
+    /// Draws what a node draws itself, for a peer at a position, inside
+    /// the node's clip if it has one.
+    static void paintNode(Graphics g, Node node, int x, int y, boolean matrixInstalled) {
+        Renderer r = renderer(g, node, x, y, matrixInstalled);
+        FxPath clip = node.cn1ClipPath();
+        if (clip != null) {
+            r.save();
+            r.clip(clip);
+        }
+        node.cn1Paint(r);
+        if (clip != null) {
+            r.restore();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyAccess.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyAccess.java
new file mode 100644
index 00000000000..7fcc2ccab6b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyAccess.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// What `javafx.scene.control.cell.PropertyValueFactory` finds by name with
+/// reflection on a desktop, as one method the build implements with direct
+/// calls: the public accessor of a bean, called by its name.
+///
+/// #### Who implements it
+///
+/// The build does, once per application, in the class [PropertyRegistry]:
+/// after the application is compiled and relocated it reads the public
+/// classes out of the class files and writes one call per public
+/// `xxxProperty()`, `getXxx()` and `isXxx()` method that takes no argument.
+/// It does so for a class that has at least one `xxxProperty()` method,
+/// and for a class with an accessor for a name the application hands to a
+/// `PropertyValueFactory` constructor as a constant.
+///
+/// This class is what the generated one falls back to, and here every
+/// answer is [#NONE] -- which is also what a run without the build step
+/// gets, a unit test of this module among them. Such a run installs an
+/// implementation of its own with [#install(PropertyAccess)].
+public abstract class PropertyAccess {
+
+    /// The answer for a method the bean's class has no generated call for.
+    /// It is not `null`, because a getter may return `null`.
+    public static final Object NONE = new Object();
+
+    private static PropertyAccess current;
+
+    /// Creates an accessor that knows no bean.
+    protected PropertyAccess() {
+        // Every answer is NONE until a subclass overrides call.
+    }
+
+    /// The installed accessor: the application's generated one unless
+    /// [#install(PropertyAccess)] replaced it.
+    public static PropertyAccess current() {
+        if (current == null) {
+            current = new PropertyRegistry();
+        }
+        return current;
+    }
+
+    /// Installs an accessor; `null` returns to the generated one.
+    public static void install(PropertyAccess access) {
+        current = access;
+    }
+
+    /// Calls the public method `method` of `bean`, which takes no
+    /// argument, and answers what it returned -- a primitive in its
+    /// wrapper -- or [#NONE] when no call was generated for it.
+    public Object call(Object bean, String method) {
+        return NONE;
+    }
+
+    /// Whether any call was generated for the class of `bean`, which
+    /// tells a misspelt property from a class the build did not look at.
+    public boolean knows(Object bean) {
+        return false;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyRegistry.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyRegistry.java
new file mode 100644
index 00000000000..1ced8b39bee
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyRegistry.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// The application's property accessor. This is a placeholder: the build
+/// replaces it, in every application that uses the JavaFX layer, with a
+/// class of the same name that overrides the methods of [PropertyAccess]
+/// for the bean classes of that application.
+///
+/// The placeholder is what an application runs with where no build step
+/// generated anything -- a unit test of this module, a desktop run straight
+/// from an IDE -- and there it knows no bean, which
+/// `javafx.scene.control.cell.PropertyValueFactory` reports by name.
+///
+/// The build does not copy this class out of the runtime jar; it writes its
+/// own. Anything added here would therefore be missing on a device: keep
+/// the class empty.
+public final class PropertyRegistry extends PropertyAccess {
+
+    /// Creates the accessor.
+    public PropertyRegistry() {
+        super();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyText.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyText.java
new file mode 100644
index 00000000000..ba8fdd1e224
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/PropertyText.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.beans.property.ReadOnlyProperty;
+
+/// The text properties describe themselves with.
+public final class PropertyText {
+
+    private PropertyText() {
+    }
+
+    /// Builds `Type [bean: b, name: n, tail]`, leaving out a missing bean
+    /// and a missing or empty name.
+    public static String describe(String type, ReadOnlyProperty<?> property, String tail) {
+        StringBuilder result = new StringBuilder(type);
+        result.append(" [");
+        Object bean = property.getBean();
+        String name = property.getName();
+        if (bean != null) {
+            result.append("bean: ").append(bean).append(", ");
+        }
+        if (name != null && name.length() > 0) {
+            result.append("name: ").append(name).append(", ");
+        }
+        return result.append(tail).append(']').toString();
+    }
+
+    /// Returns `Bean.name : ` for a property that has both, otherwise an
+    /// empty string; the prefix of the error a bound property raises.
+    public static String owner(ReadOnlyProperty<?> property) {
+        Object bean = property.getBean();
+        String name = property.getName();
+        if (bean != null && name != null) {
+            return bean.getClass().getSimpleName() + "." + name + " : ";
+        }
+        return "";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Renderer.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Renderer.java
new file mode 100644
index 00000000000..5bfcb030ead
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Renderer.java
@@ -0,0 +1,774 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+import com.codename1.ui.LinearGradientPaint;
+import com.codename1.ui.MultipleGradientPaint;
+import com.codename1.ui.Stroke;
+import com.codename1.ui.Transform;
+import com.codename1.ui.geom.GeneralPath;
+import com.codename1.util.MathUtil;
+
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.Paint;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.text.Font;
+
+/// The one renderer behind shapes, the canvas, text, images, backgrounds
+/// and borders. It draws logical geometry onto a Codename One graphics.
+///
+/// The renderer keeps its own affine matrix from logical coordinates to
+/// the device pixels of the graphics. Geometry is mapped through that
+/// matrix before it reaches Codename One, so translation, scale, rotation
+/// and shear of paths are exact on every port, whether or not the port can
+/// transform its graphics. Only text and images under a rotation or shear
+/// need the port's own transform; where that is missing they are drawn
+/// upright at the transformed position.
+///
+/// The matrix is `{a, b, c, d, tx, ty}`: `x' = a*x + c*y + tx`,
+/// `y' = b*x + d*y + ty`.
+public final class Renderer {
+
+    /// Receives every drawing operation, for tests.
+    public interface Trace {
+        /// Called for each operation: `fill`, `stroke`, `text`, `image` or
+        /// `clip`, with the device bounds `{minX, minY, maxX, maxY}` of
+        /// what was drawn, its paint and, for text, the string.
+        void drawn(String operation, double[] deviceBounds, Paint paint, String text);
+    }
+
+    private static Trace trace;
+
+    private final Graphics g;
+    private double[] m;
+    private final ArrayList<double[]> saved = new ArrayList<double[]>();
+    private double opacity = 1;
+    private int clipDepth;
+
+    /// Creates a renderer whose logical origin is at a device position of
+    /// the graphics and whose scale is the display's.
+    public Renderer(Graphics g, double originXPixels, double originYPixels) {
+        this.g = g;
+        double s = Units.scale();
+        this.m = new double[] {s, 0, 0, s, originXPixels, originYPixels};
+    }
+
+    /// Installs the receiver of drawing operations; `null` removes it.
+    public static void setTrace(Trace receiver) {
+        trace = receiver;
+    }
+
+    /// Returns the graphics drawn on.
+    public Graphics graphics() {
+        return g;
+    }
+
+    /// Returns a copy of the current matrix.
+    public double[] matrix() {
+        return new double[] {m[0], m[1], m[2], m[3], m[4], m[5]};
+    }
+
+    /// Replaces the current matrix.
+    public void setMatrix(double[] matrix) {
+        m = new double[] {matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]};
+    }
+
+    /// Remembers the matrix, the opacity and the clip.
+    public void save() {
+        saved.add(new double[] {m[0], m[1], m[2], m[3], m[4], m[5], opacity, clipDepth});
+    }
+
+    /// Returns to the matrix, opacity and clip of the matching [#save()].
+    public void restore() {
+        if (saved.isEmpty()) {
+            return;
+        }
+        double[] s = saved.remove(saved.size() - 1);
+        m = new double[] {s[0], s[1], s[2], s[3], s[4], s[5]};
+        opacity = s[6];
+        int depth = (int) s[7];
+        while (clipDepth > depth) {
+            g.popClip();
+            clipDepth--;
+        }
+    }
+
+    /// Restricts everything drawn until the matching [#restore()] to the
+    /// inside of a path, in addition to the clip already in force. Call
+    /// it between [#save()] and [#restore()].
+    ///
+    /// Answers `true` when the clip is exact. On a port that cannot clip
+    /// to a shape the clip is the bounding box of the path under the
+    /// current matrix and the answer is `false`; a caller for which a box
+    /// would be wrong asks [#canClipToShape()] first.
+    public boolean clip(FxPath path) {
+        if (path == null) {
+            return false;
+        }
+        double[] b = path.isEmpty() ? new double[] {0, 0, 0, 0} : deviceBounds(path, m);
+        boolean exact = g.isShapeClipSupported();
+        if (trace != null) {
+            trace.drawn("clip", b, null, null);
+        }
+        g.pushClip();
+        clipDepth++;
+        if (exact && !path.isEmpty()) {
+            clipToShape(path.toDevice(m));
+        } else {
+            int x1 = (int) Math.floor(b[0]);
+            int y1 = (int) Math.floor(b[1]);
+            g.clipRect(x1, y1, (int) Math.ceil(b[2]) - x1, (int) Math.ceil(b[3]) - y1);
+        }
+        return exact;
+    }
+
+    /// Narrows the clip to a shape. Codename One replaces a clip by a shape,
+    /// so the rectangle that was in force is put back on top of it -- except
+    /// under a matrix on a port that keeps its clip in the coordinates of the
+    /// screen (see `PeerPaint.clipStaysOnScreen`). There the rectangle read
+    /// back is where the clip is on the screen, and handing it to `clipRect`
+    /// runs it through the matrix a second time: the clip moved off what it
+    /// was meant for and replaced the shape, and the text of every label
+    /// inside a scaled parent was cut away. The shape alone is the clip
+    /// there. It is the node's own and lies inside what its parent gave it
+    /// in all but the rarest scene, where it shows a little more.
+    private void clipToShape(com.codename1.ui.geom.Shape shape) {
+        int[] old = g.getClip();
+        g.setClip(shape);
+        if (!PeerPaint.screenClipUnderMatrix(g)) {
+            g.clipRect(old[0], old[1], old[2], old[3]);
+        }
+    }
+
+    /// Returns whether [#clip(FxPath)] clips to the path itself rather
+    /// than to its bounding box.
+    public boolean canClipToShape() {
+        return g.isShapeClipSupported();
+    }
+
+    /// Multiplies the opacity everything is drawn with.
+    public void multiplyOpacity(double factor) {
+        opacity *= factor < 0 ? 0 : (factor > 1 ? 1 : factor);
+    }
+
+    /// Returns the opacity everything is drawn with.
+    public double opacity() {
+        return opacity;
+    }
+
+    /// Applies an affine matrix to the coordinates that follow.
+    public void concat(double a, double b, double c, double d, double tx, double ty) {
+        double na = m[0] * a + m[2] * b;
+        double nb = m[1] * a + m[3] * b;
+        double nc = m[0] * c + m[2] * d;
+        double nd = m[1] * c + m[3] * d;
+        double ntx = m[0] * tx + m[2] * ty + m[4];
+        double nty = m[1] * tx + m[3] * ty + m[5];
+        m = new double[] {na, nb, nc, nd, ntx, nty};
+    }
+
+    /// Moves the origin.
+    public void translate(double x, double y) {
+        concat(1, 0, 0, 1, x, y);
+    }
+
+    /// Scales about the origin.
+    public void scale(double x, double y) {
+        concat(x, 0, 0, y, 0, 0);
+    }
+
+    /// Rotates clockwise about the origin, in degrees.
+    public void rotate(double degrees) {
+        double r = Math.toRadians(degrees);
+        double cos = Math.cos(r);
+        double sin = Math.sin(r);
+        concat(cos, sin, -sin, cos, 0, 0);
+    }
+
+    private boolean axisAligned() {
+        return m[1] == 0 && m[2] == 0;
+    }
+
+    private double uniformScale() {
+        double det = Math.abs(m[0] * m[3] - m[1] * m[2]);
+        return Math.sqrt(det);
+    }
+
+    private static int argb(Color c) {
+        return c.cn1Argb();
+    }
+
+    private int alpha(int base, int colorAlpha) {
+        int a = (int) Math.round(base * (colorAlpha / 255.0) * opacity);
+        return a < 0 ? 0 : (a > 255 ? 255 : a);
+    }
+
+    private static double[] deviceBounds(FxPath path, double[] matrix) {
+        double[] b = path.transformed(matrix).bounds();
+        return b == null ? new double[] {0, 0, 0, 0} : b;
+    }
+
+    /// Fills a rectangle; the fast path for backgrounds.
+    public void fillRect(double x, double y, double w, double h, Paint paint) {
+        if (paint == null || w <= 0 || h <= 0) {
+            return;
+        }
+        if (paint instanceof Color && axisAligned()) {
+            Color c = (Color) paint;
+            int x1 = (int) Math.round(m[0] * x + m[4]);
+            int y1 = (int) Math.round(m[3] * y + m[5]);
+            int x2 = (int) Math.round(m[0] * (x + w) + m[4]);
+            int y2 = (int) Math.round(m[3] * (y + h) + m[5]);
+            if (trace != null) {
+                trace.drawn("fill", new double[] {Math.min(x1, x2), Math.min(y1, y2), Math.max(x1, x2),
+                    Math.max(y1, y2)}, paint, null);
+            }
+            int old = g.getAlpha();
+            int a = alpha(old, argb(c) >>> 24);
+            if (a > 0) {
+                g.setAlpha(a);
+                g.setColor(argb(c) & 0xffffff);
+                g.fillRect(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
+                g.setAlpha(old);
+            }
+            return;
+        }
+        FxPath path = new FxPath();
+        path.addRect(x, y, w, h);
+        fill(path, paint, x, y, w, h);
+    }
+
+    /// Fills a path. The bounds are those a proportional gradient is
+    /// measured against, in the path's coordinates.
+    public void fill(FxPath path, Paint paint, double bx, double by, double bw, double bh) {
+        if (paint == null || path == null || path.isEmpty()) {
+            return;
+        }
+        if (trace != null) {
+            trace.drawn("fill", deviceBounds(path, m), paint, null);
+        }
+        if (paint instanceof Color) {
+            Color c = (Color) paint;
+            int old = g.getAlpha();
+            int a = alpha(old, argb(c) >>> 24);
+            if (a == 0) {
+                return;
+            }
+            g.setAlpha(a);
+            g.setColor(argb(c) & 0xffffff);
+            fillDevice(path);
+            g.setAlpha(old);
+        } else if (paint instanceof LinearGradient) {
+            fillLinear(path, (LinearGradient) paint, bx, by, bw, bh);
+        } else if (paint instanceof RadialGradient) {
+            fillRadial(path, (RadialGradient) paint, bx, by, bw, bh);
+        }
+    }
+
+    private void fillDevice(FxPath path) {
+        if (g.isShapeSupported()) {
+            boolean aa = g.isAntiAliased();
+            g.setAntiAliased(true);
+            g.fillShape(path.toDevice(m));
+            g.setAntiAliased(aa);
+            return;
+        }
+        // No path support on this port: fill each sub path as a polygon.
+        FxPath flat = path.transformed(m).flatten(0.5);
+        double[] pts = flat.points();
+        int p = 0;
+        int start = 0;
+        for (int i = 0; i <= flat.commandCount(); i++) {
+            byte command = i < flat.commandCount() ? flat.command(i) : FxPath.MOVE;
+            if (command == FxPath.MOVE) {
+                polygon(pts, start, p);
+                start = p;
+                if (i < flat.commandCount()) {
+                    p += 2;
+                }
+            } else if (command == FxPath.LINE) {
+                p += 2;
+            }
+        }
+    }
+
+    private void polygon(double[] pts, int from, int to) {
+        int n = (to - from) / 2;
+        if (n < 3) {
+            return;
+        }
+        int[] xs = new int[n];
+        int[] ys = new int[n];
+        for (int i = 0; i < n; i++) {
+            xs[i] = (int) Math.round(pts[from + i * 2]);
+            ys[i] = (int) Math.round(pts[from + i * 2 + 1]);
+        }
+        g.fillPolygon(xs, ys, n);
+    }
+
+    private static MultipleGradientPaint.CycleMethod cycle(CycleMethod method) {
+        if (method == CycleMethod.REFLECT) {
+            return MultipleGradientPaint.CycleMethod.REFLECT;
+        } else if (method == CycleMethod.REPEAT) {
+            return MultipleGradientPaint.CycleMethod.REPEAT;
+        }
+        return MultipleGradientPaint.CycleMethod.NO_CYCLE;
+    }
+
+    private void fillLinear(FxPath path, LinearGradient lg, double bx, double by, double bw, double bh) {
+        List<Stop> stops = lg.getStops();
+        if (!g.isShapeSupported()) {
+            fill(path, stops.get(stops.size() / 2).getColor(), bx, by, bw, bh);
+            return;
+        }
+        // Every linear gradient is coloured here, point by point, and not
+        // by the platform's paint. That paint confines itself to the shape
+        // with a rectangle on top of a shape clip, and what a port made of
+        // the pair decided the picture: one kept only the rectangle, so
+        // the fill ran over the bounds of whatever clipped the node, and
+        // two rebuilt a shape with a round corner as slivers along its
+        // edges, leaving an outline. It also put the reflected half of a
+        // reflecting gradient first, so the stops read backwards, and under
+        // a rotation it is made of lines one pixel wide that show as a
+        // hatch. Colouring a mask needs none of that from a port -- a shape
+        // filled in one colour, pixels read, an image drawn -- and it is
+        // what a radial gradient has always gone through. It costs an
+        // image the size of the shape inside the clip; the last few are
+        // kept, so a shape repainted where it was is one image drawn.
+        if (masked(path, null, lg, bx, by, bw, bh)) {
+            return;
+        }
+        // Only a fill past RASTER_LIMIT, or on an image without shapes,
+        // is left to the platform's paint below -- which draws under a
+        // matrix of its own and throws on a graphics that has none.
+        if (!g.isTransformSupported()) {
+            fill(path, stops.get(stops.size() / 2).getColor(), bx, by, bw, bh);
+            return;
+        }
+        double sx = lg.isProportional() ? bx + lg.getStartX() * bw : lg.getStartX();
+        double sy = lg.isProportional() ? by + lg.getStartY() * bh : lg.getStartY();
+        double ex = lg.isProportional() ? bx + lg.getEndX() * bw : lg.getEndX();
+        double ey = lg.isProportional() ? by + lg.getEndY() * bh : lg.getEndY();
+        float[] fractions = new float[stops.size()];
+        int[] colors = new int[stops.size()];
+        float last = -1;
+        for (int i = 0; i < fractions.length; i++) {
+            float f = (float) stops.get(i).getOffset();
+            // Codename One needs strictly increasing fractions.
+            if (f <= last) {
+                f = Math.min(1f, last + 0.0001f);
+            }
+            fractions[i] = f;
+            last = f;
+            int c = argb(stops.get(i).getColor());
+            colors[i] = (alpha(255, c >>> 24) << 24) | (c & 0xffffff);
+        }
+        LinearGradientPaint native0 = new LinearGradientPaint(m[0] * sx + m[2] * sy + m[4],
+                m[1] * sx + m[3] * sy + m[5], m[0] * ex + m[2] * ey + m[4], m[1] * ex + m[3] * ey + m[5], fractions,
+                colors, cycle(lg.getCycleMethod()), MultipleGradientPaint.ColorSpaceType.SRGB, null);
+        int color = g.getColor();
+        g.setColor(native0);
+        fillDevice(path);
+        g.setColor(color);
+    }
+
+    private static Color sample(List<Stop> stops, double t) {
+        Stop previous = stops.get(0);
+        for (int i = 1; i < stops.size(); i++) {
+            Stop next = stops.get(i);
+            if (t <= next.getOffset()) {
+                double span = next.getOffset() - previous.getOffset();
+                return span <= 0 ? next.getColor()
+                        : previous.getColor().interpolate(next.getColor(), (t - previous.getOffset()) / span);
+            }
+            previous = next;
+        }
+        return previous.getColor();
+    }
+
+    private void fillRadial(FxPath path, RadialGradient rg, double bx, double by, double bw, double bh) {
+        List<Stop> stops = rg.getStops();
+        Color outer = stops.get(stops.size() - 1).getColor();
+        if (!g.isShapeSupported() || !g.isShapeClipSupported()) {
+            fill(path, outer, bx, by, bw, bh);
+            return;
+        }
+        if (masked(path, null, rg, bx, by, bw, bh)) {
+            return;
+        }
+        double cx = rg.isProportional() ? bx + rg.getCenterX() * bw : rg.getCenterX();
+        double cy = rg.isProportional() ? by + rg.getCenterY() * bh : rg.getCenterY();
+        double rx = rg.isProportional() ? rg.getRadius() * bw : rg.getRadius();
+        double ry = rg.isProportional() ? rg.getRadius() * bh : rg.getRadius();
+        // Everything outside the circle takes the last colour; inside,
+        // rings from the outside in, each one covering the centre of the
+        // one before.
+        fill(path, outer, bx, by, bw, bh);
+        g.pushClip();
+        clipToShape(path.toDevice(m));
+        int rings = (int) Math.max(8, Math.min(64, Math.max(rx, ry) * uniformScale() / 2));
+        for (int i = rings; i >= 1; i--) {
+            double t = (double) i / rings;
+            FxPath ring = new FxPath();
+            ring.addEllipse(cx, cy, rx * t, ry * t);
+            Color c = sample(stops, t - 0.5 / rings);
+            int old = g.getAlpha();
+            g.setAlpha(alpha(old, argb(c) >>> 24));
+            g.setColor(argb(c) & 0xffffff);
+            g.fillShape(ring.toDevice(m));
+            g.setAlpha(old);
+        }
+        g.popClip();
+    }
+
+    /// A gradient drawn through a shape, kept for the next paint.
+    private static final class Raster {
+        Paint paint;
+        double[] key;
+        Image image;
+    }
+
+    private static final Raster[] RASTERS = new Raster[8];
+    private static int nextRaster;
+
+    /// The most pixels a gradient is worked out for. Past it the shape is
+    /// drawn the way a port without shapes draws it.
+    private static final int RASTER_LIMIT = 4000000;
+
+    /// Draws a gradient through a shape pixel by pixel: the shape is drawn
+    /// in one colour on an image of its own, which says how much of every
+    /// pixel it covers, and each pixel then takes the colour the gradient
+    /// has there. `stroke` is `null` to fill the path and the pen to draw
+    /// its outline with otherwise. Returns `false` when it cannot be done
+    /// here, and the caller draws what it can.
+    private boolean masked(FxPath path, Stroke stroke, Paint paint, double bx, double by, double bw, double bh) {
+        double det = m[0] * m[3] - m[1] * m[2];
+        if (!g.isShapeSupported() || det == 0) {
+            return false;
+        }
+        double[] b = deviceBounds(path, m);
+        double grow = stroke == null ? 1 : stroke.getLineWidth() * Math.max(1, stroke.getMiterLimit()) / 2 + 1;
+        int[] clip = g.getClip();
+        int left = (int) Math.floor(Math.max(b[0] - grow, clip[0]));
+        int top = (int) Math.floor(Math.max(b[1] - grow, clip[1]));
+        int right = (int) Math.ceil(Math.min(b[2] + grow, clip[0] + (double) clip[2]));
+        int bottom = (int) Math.ceil(Math.min(b[3] + grow, clip[1] + (double) clip[3]));
+        int w = right - left;
+        int h = bottom - top;
+        if (w <= 0 || h <= 0) {
+            return true;
+        }
+        if ((long) w * h > RASTER_LIMIT) {
+            return false;
+        }
+        double[] pts = path.points();
+        double sum = 0;
+        for (int i = 0; i < pts.length; i++) {
+            sum += pts[i] * (i + 1);
+        }
+        double[] key = new double[] {m[0], m[1], m[2], m[3], m[4] - left, m[5] - top, w, h, bx, by, bw, bh,
+            path.commandCount(), pts.length, sum, stroke == null ? -1 : stroke.getLineWidth(),
+            stroke == null ? 0 : stroke.getCapStyle(), stroke == null ? 0 : stroke.getJoinStyle(),
+            stroke == null ? 0 : stroke.getMiterLimit()};
+        Image image = null;
+        for (int i = 0; i < RASTERS.length && image == null; i++) {
+            Raster r = RASTERS[i];
+            if (r != null && r.paint.equals(paint) && java.util.Arrays.equals(r.key, key)) {
+                image = r.image;
+            }
+        }
+        if (image == null) {
+            Image mask = Image.createImage(w, h, 0);
+            Graphics mg = mask.getGraphics();
+            if (!mg.isShapeSupported()) {
+                return false;
+            }
+            double[] local = new double[] {m[0], m[1], m[2], m[3], m[4] - left, m[5] - top};
+            mg.setColor(0xffffff);
+            mg.setAntiAliased(true);
+            if (stroke == null) {
+                mg.fillShape(path.toDevice(local));
+            } else {
+                mg.drawShape(path.toDevice(local), stroke);
+            }
+            int[] pixels = mask.getRGB();
+            double[] inverse = new double[] {m[3] / det, -m[1] / det, -m[2] / det, m[0] / det,
+                (m[2] * m[5] - m[3] * m[4]) / det, (m[1] * m[4] - m[0] * m[5]) / det};
+            GradientRaster.colour(pixels, w, h, left, top, inverse, paint, bx, by, bw, bh, 1);
+            image = Image.createImage(pixels, w, h);
+            Raster r = new Raster();
+            r.paint = paint;
+            r.key = key;
+            r.image = image;
+            RASTERS[nextRaster] = r;
+            nextRaster = (nextRaster + 1) % RASTERS.length;
+        }
+        int old = g.getAlpha();
+        int a = alpha(old, 255);
+        if (a > 0) {
+            g.setAlpha(a);
+            g.drawImage(image, left, top);
+            g.setAlpha(old);
+        }
+        return true;
+    }
+
+    private static Color solid(Paint paint) {
+        if (paint instanceof Color) {
+            return (Color) paint;
+        } else if (paint instanceof LinearGradient) {
+            List<Stop> s = ((LinearGradient) paint).getStops();
+            return s.get(s.size() / 2).getColor();
+        } else if (paint instanceof RadialGradient) {
+            List<Stop> s = ((RadialGradient) paint).getStops();
+            return s.get(s.size() / 2).getColor();
+        }
+        return null;
+    }
+
+    /// Strokes the outline of a path. A gradient is drawn through the
+    /// outline pixel by pixel, and on a port without shapes with its
+    /// middle colour. Dashes are cut out of the flattened outline, so they
+    /// work on every port.
+    public void stroke(FxPath path, Paint paint, double width, StrokeLineCap cap, StrokeLineJoin join,
+            double miterLimit, double[] dashes, double dashOffset) {
+        Color c = solid(paint);
+        if (c == null || path == null || path.isEmpty() || !(width > 0)) {
+            return;
+        }
+        FxPath outline = dashes == null || dashes.length == 0 ? path : path.dashed(dashes, dashOffset);
+        if (outline.isEmpty()) {
+            return;
+        }
+        if (trace != null) {
+            double[] b = deviceBounds(outline, m);
+            double half = width * uniformScale() / 2;
+            trace.drawn("stroke", new double[] {b[0] - half, b[1] - half, b[2] + half, b[3] + half}, paint, null);
+        }
+        float deviceWidth = (float) Math.max(1, width * uniformScale());
+        int nativeCap = cap == StrokeLineCap.ROUND ? Stroke.CAP_ROUND
+                : (cap == StrokeLineCap.SQUARE ? Stroke.CAP_SQUARE : Stroke.CAP_BUTT);
+        int nativeJoin = join == StrokeLineJoin.ROUND ? Stroke.JOIN_ROUND
+                : (join == StrokeLineJoin.BEVEL ? Stroke.JOIN_BEVEL : Stroke.JOIN_MITER);
+        if (!(paint instanceof Color)) {
+            // A proportional gradient on an outline is measured against
+            // the bounds of the path, as a fill of the same shape is.
+            double[] pb = path.bounds();
+            if (pb != null && masked(outline, new Stroke(deviceWidth, nativeCap, nativeJoin,
+                    (float) Math.max(1, miterLimit)), paint, pb[0], pb[1], pb[2] - pb[0], pb[3] - pb[1])) {
+                return;
+            }
+        }
+        int old = g.getAlpha();
+        int a = alpha(old, argb(c) >>> 24);
+        if (a == 0) {
+            return;
+        }
+        g.setAlpha(a);
+        g.setColor(argb(c) & 0xffffff);
+        if (g.isShapeSupported()) {
+            boolean aa = g.isAntiAliased();
+            g.setAntiAliased(true);
+            g.drawShape(outline.toDevice(m),
+                    new Stroke(deviceWidth, nativeCap, nativeJoin, (float) Math.max(1, miterLimit)));
+            g.setAntiAliased(aa);
+        } else {
+            strokeLines(outline, Math.round(deviceWidth));
+        }
+        g.setAlpha(old);
+    }
+
+    private void strokeLines(FxPath outline, int thickness) {
+        FxPath flat = outline.transformed(m).flatten(0.5);
+        double[] pts = flat.points();
+        int p = 0;
+        double sx = 0;
+        double sy = 0;
+        double cx = 0;
+        double cy = 0;
+        for (int i = 0; i < flat.commandCount(); i++) {
+            byte command = flat.command(i);
+            if (command == FxPath.MOVE) {
+                sx = pts[p];
+                sy = pts[p + 1];
+                cx = sx;
+                cy = sy;
+                p += 2;
+                continue;
+            }
+            double nx = command == FxPath.CLOSE ? sx : pts[p];
+            double ny = command == FxPath.CLOSE ? sy : pts[p + 1];
+            if (command == FxPath.LINE) {
+                p += 2;
+            }
+            int x1 = (int) Math.round(cx);
+            int y1 = (int) Math.round(cy);
+            int x2 = (int) Math.round(nx);
+            int y2 = (int) Math.round(ny);
+            if (thickness > 1 && (x1 == x2 || y1 == y2)) {
+                int half = thickness / 2;
+                g.fillRect(Math.min(x1, x2) - (x1 == x2 ? half : 0), Math.min(y1, y2) - (y1 == y2 ? half : 0),
+                        x1 == x2 ? thickness : Math.abs(x2 - x1), y1 == y2 ? thickness : Math.abs(y2 - y1));
+            } else {
+                g.drawLine(x1, y1, x2, y2);
+            }
+            cx = nx;
+            cy = ny;
+        }
+    }
+
+    /// Returns the native font that draws a JavaFX font under the current
+    /// matrix: its size is converted, never scaled by a transform.
+    public com.codename1.ui.Font deviceFont(Font font) {
+        Font f = font == null ? Font.getDefault() : font;
+        double k = uniformScale() / Units.scale();
+        if (Math.abs(k - 1) < 0.001) {
+            return Fonts.of(f);
+        }
+        return Fonts.create(f.getFamily(), f.cn1Weight().getWeight(),
+                f.cn1Posture() == javafx.scene.text.FontPosture.ITALIC, f.getSize() * k);
+    }
+
+    /// Draws one line of text with its top left corner at a point.
+    public void drawText(String text, double x, double y, Font font, Paint paint) {
+        Color c = solid(paint);
+        if (text == null || text.length() == 0 || c == null) {
+            return;
+        }
+        com.codename1.ui.Font nativeFont = deviceFont(font);
+        double px = m[0] * x + m[2] * y + m[4];
+        double py = m[1] * x + m[3] * y + m[5];
+        if (trace != null) {
+            trace.drawn("text", new double[] {px, py, px + nativeFont.stringWidth(text), py + nativeFont.getHeight()},
+                    paint, text);
+        }
+        int old = g.getAlpha();
+        int a = alpha(old, argb(c) >>> 24);
+        if (a == 0) {
+            return;
+        }
+        g.setAlpha(a);
+        g.setColor(argb(c) & 0xffffff);
+        g.setFont(nativeFont);
+        if (axisAligned() || !g.isTransformSupported()) {
+            g.drawString(text, (int) Math.round(px), (int) Math.round(py));
+        } else {
+            Transform before = Transform.makeIdentity();
+            g.getTransform(before);
+            // The turn is about the point the drawing starts at, which is
+            // drawn at the graphics translation plus that point.
+            int ox = g.getTranslateX();
+            int oy = g.getTranslateY();
+            Transform t = before.copy();
+            t.translate((float) (ox + px), (float) (oy + py));
+            t.rotate((float) MathUtil.atan2(m[1], m[0]), 0, 0);
+            t.translate(-ox, -oy);
+            PeerPaint.setDeviceTransform(g, t);
+            g.drawString(text, 0, 0);
+            PeerPaint.setDeviceTransform(g, before);
+        }
+        g.setAlpha(old);
+    }
+
+    /// Draws an image into a rectangle.
+    public void drawImage(Image image, double x, double y, double w, double h) {
+        if (image == null || w <= 0 || h <= 0) {
+            return;
+        }
+        double px = m[0] * x + m[2] * y + m[4];
+        double py = m[1] * x + m[3] * y + m[5];
+        double k = uniformScale();
+        boolean straight = axisAligned();
+        int left = (int) Math.round(px);
+        int top = (int) Math.round(py);
+        int pw;
+        int ph;
+        if (straight) {
+            // Each edge goes to the device pixel nearest to where it is,
+            // so that two images that meet in logical pixels meet on the
+            // screen. Rounding the size instead leaves a gap or an
+            // overlap of a pixel wherever the place is not whole, which
+            // on a display with a fractional density is most places.
+            pw = Math.max(1, (int) Math.round(px + w * Math.abs(m[0])) - left);
+            ph = Math.max(1, (int) Math.round(py + h * Math.abs(m[3])) - top);
+        } else {
+            pw = (int) Math.max(1, Math.round(w * k));
+            ph = (int) Math.max(1, Math.round(h * k));
+        }
+        if (trace != null) {
+            trace.drawn("image", straight ? new double[] {left, top, left + pw, top + ph}
+                    : new double[] {px, py, px + pw, py + ph}, null, null);
+        }
+        int old = g.getAlpha();
+        g.setAlpha(alpha(old, 255));
+        if ((straight || !g.isTransformSupported()) && pw == image.getWidth() && ph == image.getHeight()) {
+            // At its own size there is nothing to scale. Asking for the
+            // size all the same makes a port that cannot draw an image at
+            // a size copy it first -- the native Linux port does -- and a
+            // canvas image is as large as the window and drawn every frame.
+            g.drawImage(image, left, top);
+        } else if (straight || !g.isTransformSupported()) {
+            g.drawImage(image, left, top, pw, ph);
+        } else {
+            Transform before = Transform.makeIdentity();
+            g.getTransform(before);
+            // The turn is about the point the drawing starts at, which is
+            // drawn at the graphics translation plus that point.
+            int ox = g.getTranslateX();
+            int oy = g.getTranslateY();
+            Transform t = before.copy();
+            t.translate((float) (ox + px), (float) (oy + py));
+            t.rotate((float) MathUtil.atan2(m[1], m[0]), 0, 0);
+            t.translate(-ox, -oy);
+            PeerPaint.setDeviceTransform(g, t);
+            g.drawImage(image, 0, 0, pw, ph);
+            PeerPaint.setDeviceTransform(g, before);
+        }
+        g.setAlpha(old);
+    }
+
+    /// Returns the path of a rectangle with corner radii, the outline of
+    /// a background or border.
+    public static FxPath roundRect(double x, double y, double w, double h, double topLeft, double topRight,
+            double bottomRight, double bottomLeft) {
+        FxPath path = new FxPath();
+        path.addRoundRect(x, y, w, h, topLeft, topRight, bottomRight, bottomLeft);
+        return path;
+    }
+
+    /// Returns the Codename One path of a logical path under the current
+    /// matrix, for clipping.
+    public GeneralPath devicePath(FxPath path) {
+        return path.toDevice(m);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ResourceUrls.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ResourceUrls.java
new file mode 100644
index 00000000000..f6f362f751f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ResourceUrls.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.impl.compat.Resources;
+import com.codename1.io.FileSystemStorage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/// Finds the application resource a URL string names.
+///
+/// An application hands a loader `getResource(name).toExternalForm()`,
+/// which is `cn1res:/com/example/img/logo.png` here and was
+/// `jar:file:/app.jar!/com/example/img/logo.png` or a `file:` URL of a
+/// build directory on a desktop. A device keeps every resource at the root
+/// of its bundle under a flat name only
+/// [com.codename1.impl.compat.Resources] knows, so every loader of the
+/// layer -- images, fonts -- resolves its URL here rather than asking the
+/// platform for a path with directories, which a port refuses outright.
+public final class ResourceUrls {
+
+    private ResourceUrls() {
+    }
+
+    private static int hex(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    /// Undoes percent encoding, reading the escaped bytes as UTF-8. An
+    /// escape that is not one is left as it is written.
+    static String decode(String s) {
+        if (s.indexOf('%') < 0) {
+            return s;
+        }
+        int n = s.length();
+        byte[] bytes = new byte[n * 3];
+        int used = 0;
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            if (c == '%' && i + 2 < n && hex(s.charAt(i + 1)) >= 0 && hex(s.charAt(i + 2)) >= 0) {
+                bytes[used++] = (byte) (hex(s.charAt(i + 1)) * 16 + hex(s.charAt(i + 2)));
+                i += 2;
+            } else if (c < 0x80) {
+                bytes[used++] = (byte) c;
+            } else if (c < 0x800) {
+                bytes[used++] = (byte) (0xc0 | (c >> 6));
+                bytes[used++] = (byte) (0x80 | (c & 0x3f));
+            } else {
+                bytes[used++] = (byte) (0xe0 | (c >> 12));
+                bytes[used++] = (byte) (0x80 | ((c >> 6) & 0x3f));
+                bytes[used++] = (byte) (0x80 | (c & 0x3f));
+            }
+        }
+        try {
+            return new String(bytes, 0, used, "UTF-8");
+        } catch (java.io.UnsupportedEncodingException e) {
+            // Every platform has UTF-8.
+            return s;
+        }
+    }
+
+    /// The path part of a URL string: no scheme, no archive, no query, the
+    /// escapes undone, and no leading slash. A string that is a plain path
+    /// already is answered as it is.
+    public static String path(String url) {
+        String path = url;
+        int bang = path.lastIndexOf("!/");
+        if (bang >= 0) {
+            path = path.substring(bang + 2);
+        } else {
+            int colon = path.indexOf(':');
+            int slash = path.indexOf('/');
+            if (colon > 0 && (slash < 0 || colon < slash)) {
+                path = path.substring(colon + 1);
+            }
+        }
+        int query = path.indexOf('?');
+        if (query >= 0) {
+            path = path.substring(0, query);
+        }
+        int start = 0;
+        while (start < path.length() && path.charAt(start) == '/') {
+            start++;
+        }
+        return decode(path.substring(start));
+    }
+
+    /// The resource path, without a leading slash, a URL string names: its
+    /// whole path when the application ships that, else the longest tail of
+    /// it the application does ship -- a desktop URL starts with directories
+    /// the bundle knows nothing about. Answers `null` when there is none.
+    public static String find(String url) {
+        if (url == null) {
+            return null;
+        }
+        String path = path(url);
+        while (path.length() > 0) {
+            if (Resources.exists(path)) {
+                return path;
+            }
+            int next = path.indexOf('/');
+            if (next < 0) {
+                return null;
+            }
+            path = path.substring(next + 1);
+        }
+        return null;
+    }
+
+    /// Opens the resource a URL string names, as [#find(String)] finds it;
+    /// `null` when the application ships none.
+    public static InputStream open(String url) {
+        String path = find(url);
+        return path == null ? null : Resources.open(path);
+    }
+
+    /// Opens what a `file:` URL string names, or answers `null`; nothing a
+    /// port throws leaves here.
+    ///
+    /// A port's file system takes absolute `file:/` paths only and throws
+    /// for anything else, so the URL is never handed over as written. An
+    /// absolute one is read from the file system. A relative one --
+    /// `file:resources/logo.png`, which a desktop reads from the working
+    /// directory -- is looked for in the application home first, where the
+    /// `File` shim puts a relative path the application wrote, and then
+    /// among the bundled resources, where the files a desktop project kept
+    /// beside its jar end up. An absolute URL that names no file is tried
+    /// as a resource too: it may be a desktop build directory.
+    public static InputStream openFile(String url) {
+        String rest = url;
+        if (rest.regionMatches(true, 0, "file:", 0, 5)) {
+            rest = rest.substring(5);
+        }
+        int query = rest.indexOf('?');
+        if (query >= 0) {
+            rest = rest.substring(0, query);
+        }
+        rest = decode(rest);
+        InputStream in = null;
+        try {
+            FileSystemStorage fs = FileSystemStorage.getInstance();
+            String storage;
+            if (rest.startsWith("/")) {
+                int start = 0;
+                while (start + 1 < rest.length() && rest.charAt(start + 1) == '/') {
+                    start++;
+                }
+                storage = "file://" + rest.substring(start);
+            } else {
+                String home = fs.getAppHomePath();
+                if (home == null || rest.length() == 0) {
+                    storage = null;
+                } else {
+                    storage = home.endsWith("/") ? home + rest : home + "/" + rest;
+                }
+            }
+            if (storage != null && fs.exists(storage) && !fs.isDirectory(storage)) {
+                in = fs.openInputStream(storage);
+            }
+        } catch (IOException unreadable) {
+            in = null;
+        } catch (RuntimeException refused) {
+            // A port rejects a path it does not like by throwing; the
+            // caller is told the file is not there, as a desktop is.
+            in = null;
+        }
+        return in != null ? in : open(url);
+    }
+
+    /// Reads a stream to its end. The stream is left open.
+    public static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] chunk = new byte[8192];
+        int n = in.read(chunk);
+        while (n >= 0) {
+            out.write(chunk, 0, n);
+            n = in.read(chunk);
+        }
+        return out.toByteArray();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneEmbed.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneEmbed.java
new file mode 100644
index 00000000000..ed3d02930a6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneEmbed.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Container;
+import com.codename1.ui.Form;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+
+import javafx.stage.Window;
+
+/// A Codename One component that shows a scene inside a form of a
+/// Codename One application: what `com.codename1.fxcompat.FxInterop`
+/// answers.
+///
+/// The scene is given a stage of its own that is never on the screen as a
+/// window, because a scene resolves its size, its popups and
+/// `Scene.getWindow()` through one. This component is that stage's host:
+/// the peer of the scene's root fills it, so the scene is laid out to
+/// whatever size Codename One gives the component, and its preferred size
+/// is the root's.
+///
+/// Pointer input is taken from the form the component is on, as a form
+/// that shows a stage takes it ([StageForm]), for as long as the component
+/// is on a showing form. Keys reach the text controls through Codename
+/// One's own editing; a key handler or accelerator of the scene needs a
+/// stage that is shown (`Stage.show()`).
+public final class SceneEmbed extends Container implements StageHost {
+
+    private final HostCore core;
+    private Form listening;
+    private boolean pressedInside;
+
+    private final ActionListener<ActionEvent> pressed = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            pressedInside = contains(evt.getX(), evt.getY());
+            if (pressedInside && SceneInput.pressed(core.scene(), core.rootPeer(), evt.getX(), evt.getY())) {
+                evt.consume();
+            }
+        }
+    };
+
+    private final ActionListener<ActionEvent> dragged = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (pressedInside && SceneInput.dragged(core.scene(), core.rootPeer(), evt.getX(), evt.getY())) {
+                evt.consume();
+            }
+        }
+    };
+
+    private final ActionListener<ActionEvent> released = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (pressedInside) {
+                pressedInside = false;
+                if (SceneInput.released(core.scene(), core.rootPeer(), evt.getX(), evt.getY())) {
+                    evt.consume();
+                }
+            }
+        }
+    };
+
+    private final ActionListener<ActionEvent> longPressed = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (contains(evt.getX(), evt.getY())
+                    && SceneInput.longPress(core.scene(), core.rootPeer(), evt.getX(), evt.getY())) {
+                evt.consume();
+            }
+        }
+    };
+
+    /// Creates the host of `window`, which the caller then embeds in it
+    /// with `Window.cn1Embed`.
+    public SceneEmbed(Window window) {
+        core = new HostCore(window, this, this);
+    }
+
+    /// The window the scene is under.
+    public Window window() {
+        return core.window();
+    }
+
+    @Override
+    protected void initComponent() {
+        super.initComponent();
+        Form f = getComponentForm();
+        if (f != null && listening != f) {
+            unlisten();
+            listening = f;
+            f.addPointerPressedListener(pressed);
+            f.addPointerDraggedListener(dragged);
+            f.addPointerReleasedListener(released);
+            f.addLongPressListener(longPressed);
+        }
+    }
+
+    @Override
+    protected void deinitialize() {
+        unlisten();
+        super.deinitialize();
+    }
+
+    private void unlisten() {
+        Form f = listening;
+        if (f != null) {
+            listening = null;
+            pressedInside = false;
+            f.removePointerPressedListener(pressed);
+            f.removePointerDraggedListener(dragged);
+            f.removePointerReleasedListener(released);
+            f.removeLongPressListener(longPressed);
+        }
+    }
+
+    @Override
+    public void layoutContainer() {
+        super.layoutContainer();
+        core.sized();
+    }
+
+    @Override
+    public void sceneChanged() {
+        core.sceneChanged();
+    }
+
+    @Override
+    public void rootChanged() {
+        core.sceneChanged();
+        repaint();
+    }
+
+    @Override
+    public void requestPulse() {
+        core.requestPulse();
+    }
+
+    @Override
+    public void showCursor(int cursor) {
+        core.showCursor(cursor);
+    }
+
+    @Override
+    public void stageChanged() {
+    }
+
+    @Override
+    public void boundsRequested() {
+    }
+
+    @Override
+    public void open() {
+    }
+
+    /// Returns at once: an embedded scene is never closed, so there is
+    /// nothing to wait for.
+    @Override
+    public void block() {
+    }
+
+    @Override
+    public void close() {
+    }
+
+    @Override
+    public void toFront() {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneHost.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneHost.java
new file mode 100644
index 00000000000..ed8157d2e85
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneHost.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// What shows a scene: a form, a dialog or a desktop window. A scene
+/// calls it when something outside the scene graph has to happen.
+public interface SceneHost {
+
+    /// Runs layout before the next frame is painted.
+    void requestPulse();
+
+    /// The scene has another root; its peer replaces the old one.
+    void rootChanged();
+
+    /// Shows a mouse pointer, one of the `Component` cursor constants.
+    void showCursor(int cursor);
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneInput.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneInput.java
new file mode 100644
index 00000000000..12c04b5dab6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SceneInput.java
@@ -0,0 +1,517 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.ReleasableComponent;
+import com.codename1.ui.events.PointerEvent;
+
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Control;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+
+/// Turns the pointer and key callbacks of the Codename One component that
+/// hosts a scene into the scene's input, and answers the state of the
+/// modifier keys.
+///
+/// Every host (form, dialog, desktop window) forwards its callbacks here
+/// first. A method answers `true` when a JavaFX event filter consumed the
+/// event, in which case the host does not pass it on to Codename One, so
+/// the native component under the pointer never sees it. An event consumed
+/// by a handler in the bubbling phase still reaches the native component:
+/// a button pressed is a button pressed.
+///
+/// An open popup under the pointer takes the event before the scene of
+/// the host does; see [StagePopup].
+///
+/// ### A native component is pressed where its node is drawn
+///
+/// Codename One finds the component under a pointer from the bounds of
+/// the components, and the bounds of a peer know nothing of a scale, a
+/// rotation or a transform of the node or of a parent of it: a button in
+/// a group scaled to fit its window is drawn in one place and its peer
+/// lies in another, often outside the form altogether. Left to Codename
+/// One such a button is never pressed, and a press where its peer lies,
+/// where nothing is drawn, presses it.
+///
+/// So the scene decides. The node it picks names the control, the scene
+/// point is taken into the control's own coordinates and from there into
+/// its peer's, and when that is not where the pointer is on the display
+/// the press, the drags and the release of the gesture go to the native
+/// component directly, at that point, and the host passes nothing on. A
+/// pointer over a native component whose node is drawn elsewhere is
+/// swallowed the same way. Where the two places agree, which is every
+/// scene with no such transform, Codename One delivers the event as it
+/// always did.
+public final class SceneInput {
+
+    private SceneInput() {
+    }
+
+    private static int touch;
+    private static int alt;
+
+    private static boolean display() {
+        return Display.isInitialized();
+    }
+
+    /// Returns whether the pointer is a finger: the display is a touch
+    /// screen and the platform is not a desktop, where the pointer is a
+    /// mouse whatever the screen can do. A scene then fires a touch event
+    /// ahead of every mouse event.
+    public static boolean touchInput() {
+        if (touch != 0) {
+            return touch > 0;
+        }
+        return display() && Display.getInstance().isTouchScreenDevice() && !Display.getInstance().isDesktop();
+    }
+
+    /// Fixes the answer of [#touchInput()]: positive for a finger,
+    /// negative for a mouse, zero for what the display says.
+    public static void setTouchInput(int value) {
+        touch = value;
+    }
+
+    /// Returns whether Shift is down.
+    public static boolean shiftDown() {
+        return display() && Display.getInstance().isShiftKeyDown();
+    }
+
+    /// Returns whether Control is down.
+    public static boolean controlDown() {
+        return display() && Display.getInstance().isControlKeyDown();
+    }
+
+    /// Returns whether Alt is down.
+    public static boolean altDown() {
+        if (alt != 0) {
+            return alt > 0;
+        }
+        return display() && Display.getInstance().isAltKeyDown();
+    }
+
+    /// Fixes the answer of [#altDown()]: positive for down, negative for
+    /// up, zero for what the display says.
+    public static void setAltDown(int value) {
+        alt = value;
+    }
+
+    /// Returns whether Meta (Command on a Mac) is down.
+    public static boolean metaDown() {
+        return display() && Display.getInstance().isMetaKeyDown();
+    }
+
+    /// Returns whether the platform's shortcut modifier is Meta rather
+    /// than Control, which is so on Apple's platforms.
+    public static boolean shortcutIsMeta() {
+        if (!display()) {
+            return false;
+        }
+        String name = Display.getInstance().getPlatformName();
+        return "mac".equalsIgnoreCase(name) || "ios".equalsIgnoreCase(name);
+    }
+
+    private static MouseButton button() {
+        PointerEvent e = display() ? Display.getInstance().getCurrentPointerEvent() : null;
+        if (e == null) {
+            return MouseButton.PRIMARY;
+        }
+        if (e.isSecondaryButton()) {
+            return MouseButton.SECONDARY;
+        }
+        return e.isMiddleButton() ? MouseButton.MIDDLE : MouseButton.PRIMARY;
+    }
+
+    private static double sceneX(Component root, int x) {
+        return Units.toLogical(x - root.getAbsoluteX());
+    }
+
+    private static double sceneY(Component root, int y) {
+        return Units.toLogical(y - root.getAbsoluteY());
+    }
+
+    /// A pointer went down at a display position.
+    public static boolean pressed(Scene scene, Component root, int x, int y) {
+        gesture = PLAIN;
+        captured = null;
+        capturedOwner = null;
+        if (StagePopup.pointer(MouseEvent.MOUSE_PRESSED, x, y, button())) {
+            return true;
+        }
+        if (scene == null || root == null) {
+            return false;
+        }
+        double sx = sceneX(root, x);
+        double sy = sceneY(root, y);
+        if (scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, sx, sy, button())) {
+            return true;
+        }
+        Control owner = controlAt(scene, sx, sy);
+        if (owner != null) {
+            if (!place(owner, sx, sy) || !apart(placeX, x) && !apart(placeY, y)) {
+                return false;
+            }
+            Component target = deepest(owner.cn1Native(), placeX, placeY);
+            gesture = DIRECT;
+            captured = target;
+            capturedOwner = owner;
+            if (target.isEnabled()) {
+                if (target.isFocusable()) {
+                    target.requestFocus();
+                }
+                target.pointerPressed(placeX, placeY);
+            }
+            return true;
+        }
+        if (phantom(root, x, y, sx, sy)) {
+            gesture = SWALLOWED;
+            return true;
+        }
+        return false;
+    }
+
+    /// A pointer moved while down.
+    public static boolean dragged(Scene scene, Component root, int x, int y) {
+        if (StagePopup.pointer(MouseEvent.MOUSE_DRAGGED, x, y, button())) {
+            return true;
+        }
+        if (scene == null || root == null) {
+            return false;
+        }
+        double sx = sceneX(root, x);
+        double sy = sceneY(root, y);
+        boolean consumed = scene.cn1Pointer(MouseEvent.MOUSE_DRAGGED, sx, sy, button());
+        if (gesture == DIRECT) {
+            if (!consumed && captured != null && captured.isEnabled() && capturedOwner != null
+                    && capturedOwner.getScene() == scene && place(capturedOwner, sx, sy)) {
+                captured.pointerDragged(placeX, placeY);
+            }
+            return true;
+        }
+        return consumed || gesture == SWALLOWED;
+    }
+
+    /// A pointer came up.
+    public static boolean released(Scene scene, Component root, int x, int y) {
+        int was = gesture;
+        Component target = captured;
+        Control owner = capturedOwner;
+        gesture = PLAIN;
+        captured = null;
+        capturedOwner = null;
+        if (StagePopup.pointer(MouseEvent.MOUSE_RELEASED, x, y, button())) {
+            cancel(target);
+            return true;
+        }
+        if (scene == null || root == null) {
+            return false;
+        }
+        double sx = sceneX(root, x);
+        double sy = sceneY(root, y);
+        boolean consumed = scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, sx, sy, button());
+        if (was == DIRECT) {
+            if (target != null && target.isEnabled() && !consumed && owner != null && owner.getScene() == scene
+                    && place(owner, sx, sy) && target.contains(placeX, placeY)) {
+                target.pointerReleased(placeX, placeY);
+            } else {
+                cancel(target);
+            }
+            return true;
+        }
+        return consumed || was == SWALLOWED;
+    }
+
+    /// A mouse moved with no button down.
+    public static boolean hover(Scene scene, Component root, int x, int y) {
+        if (StagePopup.pointer(MouseEvent.MOUSE_MOVED, x, y, MouseButton.NONE)) {
+            return true;
+        }
+        if (scene == null || root == null) {
+            return false;
+        }
+        double sx = sceneX(root, x);
+        double sy = sceneY(root, y);
+        if (scene.cn1Pointer(MouseEvent.MOUSE_MOVED, sx, sy, MouseButton.NONE)) {
+            return true;
+        }
+        Control owner = controlAt(scene, sx, sy);
+        if (owner != null) {
+            // Codename One would light up whatever peer lies under the pointer; the
+            // node's own hover state is what shows where the node is drawn.
+            return place(owner, sx, sy) && (apart(placeX, x) || apart(placeY, y));
+        }
+        return phantom(root, x, y, sx, sy);
+    }
+
+    // ------------------------------------------- native components
+
+    private static final int PLAIN = 0;
+    private static final int DIRECT = 1;
+    private static final int SWALLOWED = 2;
+
+    /// What became of the press of the gesture under way: left to
+    /// Codename One, delivered here to a native component, or kept from
+    /// Codename One altogether.
+    private static int gesture;
+    private static Component captured;
+    private static Control capturedOwner;
+    private static int placeX;
+    private static int placeY;
+
+    /// Two display positions further apart than the rounding of a chain
+    /// of peers accounts for.
+    private static boolean apart(int a, int b) {
+        int d = a - b;
+        return d > 2 || d < -2;
+    }
+
+    /// Returns the control a scene point is over: the nearest one, from
+    /// the node the scene picks upwards, whose native component the
+    /// point lies in.
+    private static Control controlAt(Scene scene, double sx, double sy) {
+        Parent root = scene.getRoot();
+        Node n = root == null ? null : root.cn1Pick(sx, sy);
+        while (n != null) {
+            if (n instanceof Control) {
+                Control c = (Control) n;
+                Component nat = c.cn1Native();
+                if (nat != null && place(c, sx, sy) && nat.contains(placeX, placeY)) {
+                    return c;
+                }
+            }
+            n = n.getParent();
+        }
+        return null;
+    }
+
+    /// Takes a scene point to the display position it has in the peer of
+    /// a node, which is where Codename One believes the node to be.
+    private static boolean place(Node node, double sx, double sy) {
+        Component peer = node.cn1Peer();
+        Point2D local = node.sceneToLocal(sx, sy);
+        placeX = peer.getAbsoluteX() + Units.toPixels(local.getX());
+        placeY = peer.getAbsoluteY() + Units.toPixels(local.getY());
+        return true;
+    }
+
+    /// Returns the innermost component of a native at a display
+    /// position, or the native itself where that is the peer of a node.
+    private static Component deepest(Component nat, int x, int y) {
+        if (!(nat instanceof Container)) {
+            return nat;
+        }
+        Component at = ((Container) nat).getComponentAt(x, y);
+        for (Component c = at; c != null && c != nat; c = c.getParent()) {
+            if (c instanceof FxPeer) {
+                return nat;
+            }
+        }
+        return at == null ? nat : at;
+    }
+
+    /// Returns whether Codename One would deliver a pointer at a display
+    /// position to a native component whose node is not drawn there.
+    private static boolean phantom(Component root, int x, int y, double sx, double sy) {
+        if (!(root instanceof Container)) {
+            return false;
+        }
+        Component c = ((Container) root).getComponentAt(x, y);
+        if (c == null || c instanceof FxPeer) {
+            return false;
+        }
+        while (c != null && c != root && !(c instanceof FxPeer)) {
+            c = c.getParent();
+        }
+        if (!(c instanceof FxPeer)) {
+            return false;
+        }
+        Node owner = ((FxPeer) c).node();
+        return owner != null && place(owner, sx, sy) && (apart(placeX, x) || apart(placeY, y));
+    }
+
+    /// Lets go of a native component that was pressed here and is not to
+    /// act on the release: the pointer came up somewhere else.
+    private static void cancel(Component target) {
+        if (target instanceof ReleasableComponent) {
+            ((ReleasableComponent) target).setReleased();
+        }
+    }
+
+    /// A touch was held in place: a context menu request.
+    public static boolean longPress(Scene scene, Component root, int x, int y) {
+        if (StagePopup.covers(x, y)) {
+            return true;
+        }
+        return scene != null && root != null && scene.cn1ContextMenu(sceneX(root, x), sceneY(root, y));
+    }
+
+    /// The wheel turned; deltas in display pixels.
+    public static boolean wheel(Scene scene, Component root, int x, int y, int deltaX, int deltaY) {
+        if (StagePopup.wheel(x, y, deltaX, deltaY)) {
+            return true;
+        }
+        return scene != null && root != null && scene.cn1Wheel(sceneX(root, x), sceneY(root, y),
+                Units.toLogical(deltaX), Units.toLogical(deltaY));
+    }
+
+    /// A key went down; `keyCode` is Codename One's.
+    public static boolean keyPressed(Scene scene, int keyCode) {
+        if (scene == null) {
+            return false;
+        }
+        KeyCode code = code(keyCode);
+        if (StagePopup.key(KeyEvent.KEY_PRESSED, code, text(keyCode))) {
+            return true;
+        }
+        boolean consumed = scene.cn1Key(KeyEvent.KEY_PRESSED, code, text(keyCode));
+        if (keyCode >= 32 && keyCode != 127) {
+            consumed |= scene.cn1Key(KeyEvent.KEY_TYPED, KeyCode.UNDEFINED, text(keyCode));
+        }
+        // Tab is the scene's: it moved the focus in the order of the scene
+        // graph, or the application took the key. A form of a desktop that
+        // is handed Tab as well moves the focus a second time, in an order
+        // of its own, and the two leave it on a control the scene does not
+        // think has it.
+        return consumed || code == KeyCode.TAB || toFocused(scene, keyCode, code, true);
+    }
+
+    /// Hands a key nothing in the scene wanted to the native component of
+    /// the control with the focus, and answers that the form is not to
+    /// have it. A form given a key looks for the component it believes
+    /// has the focus and, finding none or one that makes nothing of the
+    /// key, moves the focus by rules of its own; the focus of a scene is
+    /// the scene's, and a key is for the control the scene says has it.
+    /// Escape stays the form's, which closes a dialog with it.
+    private static boolean toFocused(Scene scene, int keyCode, KeyCode code, boolean down) {
+        if (code == KeyCode.ESCAPE) {
+            return false;
+        }
+        Node owner = scene.getFocusOwner();
+        if (!(owner instanceof Control) || owner.isDisabled()) {
+            return true;
+        }
+        Component nat = ((Control) owner).cn1Native();
+        if (nat == null) {
+            return true;
+        }
+        Component target = nat;
+        Form form = nat.getComponentForm();
+        Component focused = form == null ? null : form.getFocused();
+        for (Component c = focused; c != null; c = c.getParent()) {
+            if (c == nat) {
+                target = focused;
+                break;
+            }
+        }
+        if (target.isEnabled()) {
+            if (down) {
+                target.keyPressed(keyCode);
+            } else {
+                target.keyReleased(keyCode);
+            }
+        }
+        return true;
+    }
+
+    /// A key came up.
+    public static boolean keyReleased(Scene scene, int keyCode) {
+        if (scene == null) {
+            return false;
+        }
+        KeyCode code = code(keyCode);
+        return StagePopup.key(KeyEvent.KEY_RELEASED, code, text(keyCode))
+                || scene.cn1Key(KeyEvent.KEY_RELEASED, code, text(keyCode)) || code == KeyCode.TAB
+                || toFocused(scene, keyCode, code, false);
+    }
+
+    private static String text(int keyCode) {
+        return keyCode >= 32 && keyCode != 127 && keyCode <= 0xffff ? String.valueOf((char) keyCode) : "";
+    }
+
+    /// Returns the JavaFX key of a Codename One key code.
+    public static KeyCode code(int keyCode) {
+        if (keyCode >= 'a' && keyCode <= 'z') {
+            return letter(keyCode - 'a');
+        } else if (keyCode >= 'A' && keyCode <= 'Z') {
+            return letter(keyCode - 'A');
+        } else if (keyCode >= '0' && keyCode <= '9') {
+            return DIGITS[keyCode - '0'];
+        }
+        switch (keyCode) {
+            case 8:
+                return KeyCode.BACK_SPACE;
+            case 9:
+                return KeyCode.TAB;
+            case 10:
+            case 13:
+                return KeyCode.ENTER;
+            case 27:
+                return KeyCode.ESCAPE;
+            case 32:
+                return KeyCode.SPACE;
+            case 127:
+                return KeyCode.DELETE;
+            default:
+                break;
+        }
+        if (display() && keyCode < 0) {
+            int action = Display.getInstance().getGameAction(keyCode);
+            switch (action) {
+                case Display.GAME_UP:
+                    return KeyCode.UP;
+                case Display.GAME_DOWN:
+                    return KeyCode.DOWN;
+                case Display.GAME_LEFT:
+                    return KeyCode.LEFT;
+                case Display.GAME_RIGHT:
+                    return KeyCode.RIGHT;
+                case Display.GAME_FIRE:
+                    return KeyCode.ENTER;
+                default:
+                    break;
+            }
+        }
+        return KeyCode.UNDEFINED;
+    }
+
+    private static final KeyCode[] DIGITS = {KeyCode.DIGIT0, KeyCode.DIGIT1, KeyCode.DIGIT2, KeyCode.DIGIT3,
+        KeyCode.DIGIT4, KeyCode.DIGIT5, KeyCode.DIGIT6, KeyCode.DIGIT7, KeyCode.DIGIT8, KeyCode.DIGIT9};
+
+    private static final KeyCode[] LETTERS = {KeyCode.A, KeyCode.B, KeyCode.C, KeyCode.D, KeyCode.E, KeyCode.F,
+        KeyCode.G, KeyCode.H, KeyCode.I, KeyCode.J, KeyCode.K, KeyCode.L, KeyCode.M, KeyCode.N, KeyCode.O, KeyCode.P,
+        KeyCode.Q, KeyCode.R, KeyCode.S, KeyCode.T, KeyCode.U, KeyCode.V, KeyCode.W, KeyCode.X, KeyCode.Y,
+        KeyCode.Z};
+
+    private static KeyCode letter(int index) {
+        return LETTERS[index];
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageDialog.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageDialog.java
new file mode 100644
index 00000000000..d3cdfe1f10f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageDialog.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Command;
+import com.codename1.ui.Dialog;
+import com.codename1.ui.Display;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.layouts.BorderLayout;
+
+import javafx.stage.Stage;
+import javafx.stage.Window;
+
+/// A modal stage on a device without desktop windows: a Codename One
+/// dialog over the form that was showing. The dialog takes the preferred
+/// size of the scene. It is shown modeless as far as Codename One is
+/// concerned, so `Stage.show()` returns at once as JavaFX requires; the
+/// form below cannot be reached while it is up either way.
+public final class StageDialog extends Dialog implements StageHost {
+
+    private final HostCore core;
+
+    /// Creates the dialog of a window.
+    public StageDialog(Window window) {
+        super(new BorderLayout());
+        this.core = new HostCore(window, getContentPane(), this);
+        setDisposeWhenPointerOutOfBounds(false);
+        setAutoDispose(false);
+        // This host is the choice NOT to use a window of the window
+        // manager: StageHosts takes a native window first where the port
+        // has them and the application left them on. A theme may ask for
+        // every Codename One dialog to open in a window of its own (the
+        // Windows native theme does), and the stage then left the form an
+        // application had asked to keep it in.
+        setNativeWindowMode(false);
+        setBackCommand(new Command("Back") {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                core.window().cn1CloseRequested();
+            }
+        });
+        stageChanged();
+    }
+
+    @Override
+    public void pointerPressed(int x, int y) {
+        if (!SceneInput.pressed(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerPressed(x, y);
+        }
+    }
+
+    @Override
+    public void pointerDragged(int x, int y) {
+        if (!SceneInput.dragged(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerDragged(x, y);
+        }
+    }
+
+    /// The drag of a pointer as the display delivers it. A form has two
+    /// overloads and the display calls this one, which is an
+    /// implementation of its own and never reaches the one above: with
+    /// only that one overridden no drag got to the scene on a device,
+    /// while a press and a release, which a form routes through the plain
+    /// overloads, did. More than one pointer is a gesture of Codename
+    /// One's.
+    @Override
+    public void pointerDragged(int[] x, int[] y) {
+        if (x != null && y != null && x.length == 1 && y.length == 1
+                && SceneInput.dragged(core.scene(), core.rootPeer(), x[0], y[0])) {
+            return;
+        }
+        super.pointerDragged(x, y);
+    }
+
+    @Override
+    public void pointerReleased(int x, int y) {
+        if (!SceneInput.released(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerReleased(x, y);
+        }
+    }
+
+    @Override
+    public void pointerHover(int[] x, int[] y) {
+        if (x == null || y == null || x.length == 0 || y.length == 0
+                || !SceneInput.hover(core.scene(), core.rootPeer(), x[0], y[0])) {
+            super.pointerHover(x, y);
+        }
+    }
+
+    @Override
+    public void longPointerPress(int x, int y) {
+        if (!SceneInput.longPress(core.scene(), core.rootPeer(), x, y)) {
+            super.longPointerPress(x, y);
+        }
+    }
+
+    @Override
+    public void keyPressed(int keyCode) {
+        if (!SceneInput.keyPressed(core.scene(), keyCode)) {
+            super.keyPressed(keyCode);
+        }
+    }
+
+    @Override
+    public void keyReleased(int keyCode) {
+        if (!SceneInput.keyReleased(core.scene(), keyCode)) {
+            super.keyReleased(keyCode);
+        }
+    }
+
+    @Override
+    public void sceneChanged() {
+        core.sceneChanged();
+    }
+
+    @Override
+    public void rootChanged() {
+        core.sceneChanged();
+        repaint();
+    }
+
+    @Override
+    public void requestPulse() {
+        core.requestPulse();
+    }
+
+    @Override
+    public void block() {
+        core.block();
+    }
+
+    @Override
+    public void showCursor(int cursor) {
+        setEnableCursors(true);
+        core.showCursor(cursor);
+    }
+
+    @Override
+    public final void stageChanged() {
+        Window window = core.window();
+        if (window instanceof Stage) {
+            String title = ((Stage) window).getTitle();
+            setTitle(title == null ? "" : title);
+        }
+    }
+
+    @Override
+    public void boundsRequested() {
+    }
+
+    @Override
+    public void layoutContainer() {
+        super.layoutContainer();
+        core.sized();
+    }
+
+    @Override
+    public void open() {
+        if (Display.isInitialized()) {
+            showModeless();
+        }
+        core.sized();
+    }
+
+    @Override
+    public void close() {
+        core.markClosed();
+        if (Display.isInitialized()) {
+            dispose();
+        }
+    }
+
+    @Override
+    public void toFront() {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageForm.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageForm.java
new file mode 100644
index 00000000000..ffe19e54bab
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageForm.java
@@ -0,0 +1,356 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Command;
+import com.codename1.ui.Container;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.layouts.BorderLayout;
+
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import javafx.stage.Window;
+
+/// A stage shown as a Codename One form.
+///
+/// The scene fills the content pane. The primary stage has no title
+/// area: its scene is the whole screen, as it is the whole window on a
+/// desktop. A further stage shown as a form has a title and a back
+/// command; back asks the stage to close, which returns to the form that
+/// was showing before it.
+///
+/// Pointer and key events enter the scene here before Codename One sees
+/// them; see [SceneInput].
+public final class StageForm extends Form implements StageHost {
+
+    private final HostCore core;
+    private final boolean primary;
+    private Form previous;
+    /// The display size the last whole paint of this form was made for.
+    private int paintedWidth = -1;
+    private int paintedHeight = -1;
+    private int paintedAgain;
+    /// The size the application gave the stage before showing it, or NaN.
+    private final double askedWidth;
+    private final double askedHeight;
+    private final Runnable again = new Runnable() {
+        @Override
+        public void run() {
+            repaint();
+        }
+    };
+
+    /// Creates the form of a window.
+    public StageForm(Window window, boolean primary) {
+        super(new BorderLayout());
+        this.primary = primary;
+        // Read before the scene is attached: from then on the window
+        // reports the size the form gave it, not the one it was asked for.
+        this.askedWidth = window.getWidth();
+        this.askedHeight = window.getHeight();
+        this.core = new HostCore(window, getContentPane(), this);
+        if (primary) {
+            if (getToolbar() != null) {
+                getToolbar().hideToolbar();
+            }
+            Container titleArea = getTitleArea();
+            if (titleArea != null) {
+                titleArea.setHidden(true);
+            }
+        } else {
+            setBackCommand(new Command("Back") {
+                @Override
+                public void actionPerformed(ActionEvent evt) {
+                    core.window().cn1CloseRequested();
+                }
+            });
+        }
+        stageChanged();
+    }
+
+    /// Returns the window this form shows.
+    public Window window() {
+        return core.window();
+    }
+
+    @Override
+    public void pointerPressed(int x, int y) {
+        if (!SceneInput.pressed(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerPressed(x, y);
+        }
+    }
+
+    @Override
+    public void pointerDragged(int x, int y) {
+        if (!SceneInput.dragged(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerDragged(x, y);
+        }
+    }
+
+    /// The drag of a pointer as the display delivers it. A form has two
+    /// overloads and the display calls this one, which is an
+    /// implementation of its own and never reaches the one above: with
+    /// only that one overridden no drag got to the scene on a device,
+    /// while a press and a release, which a form routes through the plain
+    /// overloads, did. More than one pointer is a gesture of Codename
+    /// One's.
+    @Override
+    public void pointerDragged(int[] x, int[] y) {
+        if (x != null && y != null && x.length == 1 && y.length == 1
+                && SceneInput.dragged(core.scene(), core.rootPeer(), x[0], y[0])) {
+            return;
+        }
+        super.pointerDragged(x, y);
+    }
+
+    @Override
+    public void pointerReleased(int x, int y) {
+        if (!SceneInput.released(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerReleased(x, y);
+        }
+    }
+
+    @Override
+    public void pointerHover(int[] x, int[] y) {
+        if (x == null || y == null || x.length == 0 || y.length == 0
+                || !SceneInput.hover(core.scene(), core.rootPeer(), x[0], y[0])) {
+            super.pointerHover(x, y);
+        }
+    }
+
+    @Override
+    public void longPointerPress(int x, int y) {
+        if (!SceneInput.longPress(core.scene(), core.rootPeer(), x, y)) {
+            super.longPointerPress(x, y);
+        }
+    }
+
+    @Override
+    public void keyPressed(int keyCode) {
+        if (!SceneInput.keyPressed(core.scene(), keyCode)) {
+            super.keyPressed(keyCode);
+        }
+    }
+
+    @Override
+    public void keyReleased(int keyCode) {
+        if (!SceneInput.keyReleased(core.scene(), keyCode)) {
+            super.keyReleased(keyCode);
+        }
+    }
+
+    @Override
+    public void sceneChanged() {
+        core.sceneChanged();
+    }
+
+    @Override
+    public void rootChanged() {
+        core.sceneChanged();
+        repaint();
+    }
+
+    @Override
+    public void requestPulse() {
+        core.requestPulse();
+    }
+
+    @Override
+    public void block() {
+        core.block();
+    }
+
+    @Override
+    public void showCursor(int cursor) {
+        setEnableCursors(true);
+        core.showCursor(cursor);
+    }
+
+    @Override
+    public final void stageChanged() {
+        Window window = core.window();
+        if (!primary && window instanceof Stage) {
+            String title = ((Stage) window).getTitle();
+            setTitle(title == null ? "" : title);
+        }
+        nativeTitle();
+    }
+
+    /// Hands the title of the stage to the window of the operating
+    /// system, on a port that keeps the title of a form there.
+    ///
+    /// The primary stage has no title area, so its title had nowhere to
+    /// go and the window kept the port's own name. Its form is given the
+    /// title only where the port shows it on the window, never where it
+    /// would draw a title strip; and since Codename One pushes a title
+    /// that is set on the form showing, and not the title a form already
+    /// has when it is shown, the push is asked for here.
+    private void nativeTitle() {
+        if (!Display.isInitialized()) {
+            return;
+        }
+        Display d = Display.getInstance();
+        if (!d.isNativeTitle()) {
+            return;
+        }
+        Window window = core.window();
+        if (primary && window instanceof Stage) {
+            String title = ((Stage) window).getTitle();
+            String wanted = title == null ? "" : title;
+            if (!wanted.equals(getTitle())) {
+                setTitle(wanted);
+            }
+        }
+        if (d.getCurrent() == this) {
+            d.refreshNativeTitle();
+        }
+    }
+
+    @Override
+    public void boundsRequested() {
+    }
+
+    /// Gives the application's own window the size its primary stage
+    /// asks for: the stage's, or else the size its scene was created
+    /// with or prefers, as a stage with a window of its own is sized.
+    /// A stage shown over a form that is not a stage's is a guest in
+    /// that window and leaves its size alone.
+    ///
+    /// The size of a stage is its window's, frame and title bar included,
+    /// and that is what a port is asked for. The size of a scene is that
+    /// of what is drawn: asking the port for it gave the scene a window
+    /// with its frame taken out of it, so a scene made 800 by 600 was laid
+    /// out at 798 by 575. The frame, which is what the window has over the
+    /// display, is added to a size that came from the scene, and a scene
+    /// the display already fits asks for nothing: a window that opens at
+    /// the size of its scene is not resized under an application in the
+    /// middle of its first frame.
+    private void sizeWindow() {
+        Display d = Display.getInstance();
+        boolean own = previous == null || previous instanceof StageForm;
+        if (!primary || !own || !d.isDesktop()) {
+            return;
+        }
+        Scene scene = core.scene();
+        double width = askedWidth;
+        double height = askedHeight;
+        if (Double.isNaN(width) && scene != null) {
+            width = scene.cn1InitialWidth() >= 0 ? scene.cn1InitialWidth()
+                    : (scene.getRoot() == null ? 0 : scene.getRoot().prefWidth(-1));
+        }
+        if (Double.isNaN(height) && scene != null) {
+            height = scene.cn1InitialHeight() >= 0 ? scene.cn1InitialHeight()
+                    : (scene.getRoot() == null ? 0 : scene.getRoot().prefHeight(-1));
+        }
+        if (width > 0 && height > 0) {
+            int w = Units.sizeToPixels(width);
+            int h = Units.sizeToPixels(height);
+            boolean sceneWide = Double.isNaN(askedWidth);
+            boolean sceneHigh = Double.isNaN(askedHeight);
+            if (sceneWide && sceneHigh && w == d.getDisplayWidth() && h == d.getDisplayHeight()) {
+                return;
+            }
+            com.codename1.ui.geom.Rectangle window = d.getWindowBounds();
+            if (sceneWide) {
+                w += Math.max(0, window.getWidth() - d.getDisplayWidth());
+            }
+            if (sceneHigh) {
+                h += Math.max(0, window.getHeight() - d.getDisplayHeight());
+            }
+            d.setWindowSize(w, h);
+        }
+    }
+
+    /// Paints the form, and asks for one more paint when the display has
+    /// a size that no paint of this form was made for yet.
+    ///
+    /// A port that draws into a buffer of the window's size may replace
+    /// the buffer when the frame ends: the native Linux port applies a
+    /// resize it has recorded right after the flush, and shows a buffer
+    /// nothing has drawn on, until an input event makes something paint.
+    /// The frame after that flush is drawn on the new buffer. It costs
+    /// one paint for each size the display takes.
+    @Override
+    public void paint(com.codename1.ui.Graphics g) {
+        super.paint(g);
+        if (!Display.isInitialized()) {
+            return;
+        }
+        Display d = Display.getInstance();
+        int w = d.getDisplayWidth();
+        int h = d.getDisplayHeight();
+        if (w != paintedWidth || h != paintedHeight) {
+            paintedWidth = w;
+            paintedHeight = h;
+            paintedAgain++;
+            d.callSerially(again);
+        }
+    }
+
+    /// How many times a paint asked for another one; see [#paint].
+    public int cn1PaintedAgain() {
+        return paintedAgain;
+    }
+
+    @Override
+    public void layoutContainer() {
+        super.layoutContainer();
+        // Form's constructor lays itself out when the theme installs a global
+        // toolbar, which is before this class's own fields exist.
+        if (core != null) {
+            core.sized();
+        }
+    }
+
+    @Override
+    public void open() {
+        if (Display.isInitialized()) {
+            Form current = Display.getInstance().getCurrent();
+            previous = current == this ? null : current;
+            if (current != this) {
+                sizeWindow();
+            }
+            show();
+            nativeTitle();
+        }
+        core.sized();
+    }
+
+    @Override
+    public void close() {
+        core.markClosed();
+        if (!primary && previous != null && Display.isInitialized() && Display.getInstance().getCurrent() == this) {
+            previous.showBack();
+        }
+        previous = null;
+    }
+
+    @Override
+    public void toFront() {
+        if (Display.isInitialized() && Display.getInstance().getCurrent() != this) {
+            show();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageHost.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageHost.java
new file mode 100644
index 00000000000..ae67b4c1f91
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageHost.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// What a `javafx.stage.Window` is on screen while it is showing: a form,
+/// a dialog or a desktop window. The window calls it; it calls back
+/// `Window.cn1CloseRequested()` when the user closes it and
+/// `Window.cn1Bounds` when its size is known.
+public interface StageHost extends SceneHost {
+
+    /// The window has another scene, or none.
+    void sceneChanged();
+
+    /// The title, resizability or another attribute of the stage changed.
+    void stageChanged();
+
+    /// The application asked for a position or a size.
+    void boundsRequested();
+
+    /// Puts the window on screen.
+    void open();
+
+    /// Returns once the window was closed, handling events meanwhile.
+    void block();
+
+    /// Takes the window off screen.
+    void close();
+
+    /// Brings the window in front of the others.
+    void toFront();
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageHosts.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageHosts.java
new file mode 100644
index 00000000000..2c9523318b4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageHosts.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Desktop;
+import com.codename1.ui.Display;
+
+import javafx.stage.Modality;
+import javafx.stage.PopupWindow;
+import javafx.stage.Stage;
+import javafx.stage.Window;
+
+/// Chooses what a window is on screen.
+///
+/// - The primary stage is always a form, [StageForm]: it is the
+///   application's main surface on every device.
+/// - Any other window is a desktop window, [StageWindow], where
+///   `com.codename1.ui.Desktop.isSupported()`.
+/// - Elsewhere a stage with a modality is a Codename One dialog,
+///   [StageDialog], and any other window a form shown on top of the
+///   current one, whose back command asks the window to close and returns
+///   to the form below.
+/// - A popup (menu, tooltip) is never a window of its own: it is a
+///   [StagePopup], a layer over the form of its owner.
+public final class StageHosts {
+
+    private static Runnable exitHook;
+    private static boolean nativeWindows = true;
+
+    private StageHosts() {
+    }
+
+    /// Says whether windows other than the primary stage are windows of
+    /// the platform's window manager where it has one, which is the default.
+    /// With `false` every window stays inside the application's own: a
+    /// modal stage is a dialog over the current form and any other a form,
+    /// as on a phone.
+    public static void setNativeWindows(boolean value) {
+        nativeWindows = value;
+    }
+
+    /// Whether [#setNativeWindows] left the window manager in use.
+    public static boolean isNativeWindows() {
+        return nativeWindows;
+    }
+
+    /// Creates the host of a window that is about to be shown.
+    public static StageHost create(Window window) {
+        // Library mode has no lifecycle to install the application's
+        // resources, bundles and services first; the first desktop
+        // component it wraps or window it shows does. Idempotent.
+        com.codename1.generated.compat.CompatRegistry.cn1Install();
+        if (window instanceof PopupWindow) {
+            return new StagePopup((PopupWindow) window);
+        }
+        boolean primary = window instanceof Stage && ((Stage) window).cn1IsPrimary();
+        if (!primary && nativeWindows && Display.isInitialized() && Desktop.isSupported()) {
+            return new StageWindow(window);
+        }
+        if (!primary && window instanceof Stage && ((Stage) window).getModality() != Modality.NONE) {
+            return new StageDialog(window);
+        }
+        return new StageForm(window, primary);
+    }
+
+    /// Installs what ends the application; the lifecycle does.
+    public static void setExitHook(Runnable hook) {
+        exitHook = hook;
+    }
+
+    /// Ends the application, as `Platform.exit()` asks.
+    public static void exit() {
+        Runnable hook = exitHook;
+        if (hook != null) {
+            hook.run();
+        }
+    }
+
+    /// The last showing window was hidden.
+    public static void lastWindowHidden() {
+        if (javafx.application.Platform.isImplicitExit()) {
+            exit();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StagePopup.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StagePopup.java
new file mode 100644
index 00000000000..c513491a3a7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StagePopup.java
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.ArrayList;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.Layout;
+
+import javafx.event.EventType;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.stage.PopupWindow;
+import javafx.stage.Window;
+
+/// A popup on screen: the peer of its scene's root in a layer over the
+/// form that shows the popup's owner.
+///
+/// The layer is a layered pane of the form kept for popups, so a popup
+/// is drawn over everything the form shows and is clipped by the form.
+/// The scene takes its preferred size and is placed with its top left
+/// corner at the popup's anchor, moved back inside the form where it
+/// would stick out. An owner that is in no form (a scene that is not
+/// showing, or one in a separate desktop window) leaves the popup open
+/// but not drawn.
+///
+/// The pointer reaches a popup through [SceneInput]: every host forwards
+/// its pointer callbacks there, and an open popup under the pointer takes
+/// them before the scene of the host does. A press outside every popup
+/// hides those that hide automatically and then goes on to the host.
+public final class StagePopup implements StageHost {
+
+    private static final String X = "cn1.fx.popup.x";
+    private static final String Y = "cn1.fx.popup.y";
+    private static final ArrayList<StagePopup> OPEN = new ArrayList<StagePopup>();
+    private static StagePopup captured;
+
+    private final PopupWindow window;
+    private Scene scene;
+    private Component rootPeer;
+    private boolean opened;
+    private boolean placing;
+    private boolean pulsePending;
+
+    /// Creates the host of a popup.
+    public StagePopup(PopupWindow window) {
+        this.window = window;
+    }
+
+    /// Returns a point of a node in the coordinates popups are anchored
+    /// in: scene coordinates, plus the position of the popup the node is
+    /// in.
+    public static Point2D anchor(Node node, double localX, double localY) {
+        Point2D p = node.localToScene(localX, localY);
+        double x = p.getX();
+        double y = p.getY();
+        Scene s = node.getScene();
+        Window w = s == null ? null : s.getWindow();
+        if (w instanceof PopupWindow) {
+            x += clean(w.getX());
+            y += clean(w.getY());
+        }
+        return new Point2D(x, y);
+    }
+
+    private static double clean(double v) {
+        return Double.isNaN(v) ? 0 : v;
+    }
+
+    private static StagePopup at(int x, int y) {
+        for (int i = OPEN.size() - 1; i >= 0; i--) {
+            StagePopup p = OPEN.get(i);
+            Component c = p.rootPeer;
+            if (c != null && x >= c.getAbsoluteX() && y >= c.getAbsoluteY() && x < c.getAbsoluteX() + c.getWidth()
+                    && y < c.getAbsoluteY() + c.getHeight()) {
+                return p;
+            }
+        }
+        return null;
+    }
+
+    private static void dismiss() {
+        ArrayList<StagePopup> all = new ArrayList<StagePopup>(OPEN);
+        for (int i = 0; i < all.size(); i++) {
+            StagePopup p = all.get(i);
+            if (p.opened && p.window.isAutoHide()) {
+                p.window.hide();
+            }
+        }
+    }
+
+    /// Offers a pointer event at a display position to the open popups.
+    /// Answers whether one took it; the host then does nothing with it.
+    static boolean pointer(EventType<MouseEvent> kind, int x, int y, MouseButton button) {
+        if (OPEN.isEmpty()) {
+            return false;
+        }
+        if (kind == MouseEvent.MOUSE_PRESSED) {
+            StagePopup hit = at(x, y);
+            captured = hit;
+            if (hit == null) {
+                dismiss();
+                return false;
+            }
+            hit.deliver(kind, x, y, button);
+            return true;
+        }
+        if (kind == MouseEvent.MOUSE_DRAGGED || kind == MouseEvent.MOUSE_RELEASED) {
+            StagePopup c = captured;
+            if (c == null) {
+                return false;
+            }
+            if (kind == MouseEvent.MOUSE_RELEASED) {
+                captured = null;
+            }
+            if (c.opened) {
+                c.deliver(kind, x, y, button);
+            }
+            return true;
+        }
+        StagePopup hit = at(x, y);
+        if (hit == null) {
+            return false;
+        }
+        hit.deliver(kind, x, y, button);
+        return true;
+    }
+
+    /// Offers a turn of the wheel to the open popups.
+    static boolean wheel(int x, int y, int deltaX, int deltaY) {
+        StagePopup hit = OPEN.isEmpty() ? null : at(x, y);
+        if (hit == null || hit.scene == null) {
+            return false;
+        }
+        hit.scene.cn1Wheel(hit.localX(x), hit.localY(y), Units.toLogical(deltaX), Units.toLogical(deltaY));
+        return true;
+    }
+
+    /// Offers a key to the open popups. The one opened last that closes
+    /// by itself has the keyboard, as the popup window of a menu has in
+    /// JavaFX: the key goes to its scene and to nothing behind it, and
+    /// Escape closes it when nothing in it wanted the key.
+    static boolean key(EventType<KeyEvent> kind, KeyCode code, String text) {
+        for (int i = OPEN.size() - 1; i >= 0; i--) {
+            StagePopup p = OPEN.get(i);
+            if (!p.opened || p.scene == null || !p.window.isAutoHide()) {
+                continue;
+            }
+            boolean taken = p.scene.cn1Key(kind, code, text);
+            if (!taken && kind == KeyEvent.KEY_PRESSED && code == KeyCode.ESCAPE && p.opened) {
+                p.window.hide();
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /// Returns whether an open popup is under a display position.
+    static boolean covers(int x, int y) {
+        return !OPEN.isEmpty() && at(x, y) != null;
+    }
+
+    private static void closed(StagePopup popup) {
+        OPEN.remove(popup);
+        if (captured == popup) {
+            captured = null;
+        }
+    }
+
+    private static void opened(StagePopup popup) {
+        if (!OPEN.contains(popup)) {
+            OPEN.add(popup);
+        }
+    }
+
+    private double localX(int x) {
+        return Units.toLogical(x - (rootPeer == null ? 0 : rootPeer.getAbsoluteX()));
+    }
+
+    private double localY(int y) {
+        return Units.toLogical(y - (rootPeer == null ? 0 : rootPeer.getAbsoluteY()));
+    }
+
+    private void deliver(EventType<MouseEvent> kind, int x, int y, MouseButton button) {
+        if (scene != null) {
+            scene.cn1Pointer(kind, localX(x), localY(y), button);
+        }
+    }
+
+    /// Returns the peer of the root of the scene the popup floats over:
+    /// the one below every popup in between.
+    private Component basePeer() {
+        PopupWindow p = window;
+        for (int depth = 0; depth < 16; depth++) {
+            Node n = p.getOwnerNode();
+            Window w = p.getOwnerWindow();
+            Scene s = n != null ? n.getScene() : (w == null ? null : w.getScene());
+            if (s == null) {
+                return null;
+            }
+            Window in = s.getWindow();
+            if (in instanceof PopupWindow && in != p) {
+                p = (PopupWindow) in;
+                continue;
+            }
+            Parent root = s.getRoot();
+            return root == null ? null : root.cn1Peer();
+        }
+        return null;
+    }
+
+    private void detach() {
+        if (rootPeer != null) {
+            Container parent = rootPeer.getParent();
+            if (parent != null) {
+                parent.removeComponent(rootPeer);
+                parent.repaint();
+            }
+        }
+    }
+
+    private void place() {
+        if (!opened || placing || scene == null || scene.getRoot() == null || rootPeer == null) {
+            return;
+        }
+        placing = true;
+        try {
+            Parent root = scene.getRoot();
+            double w = root.prefWidth(-1);
+            double h = root.prefHeight(-1);
+            scene.cn1Layout(w, h);
+            double ax = clean(window.getAnchorX());
+            double ay = clean(window.getAnchorY());
+            int pw = Units.sizeToPixels(w);
+            int ph = Units.sizeToPixels(h);
+            int px = Units.toPixels(ax);
+            int py = Units.toPixels(ay);
+            Component base = basePeer();
+            Form form = base == null ? null : base.getComponentForm();
+            if (form != null) {
+                Container layer = form.getLayeredPane(StagePopup.class, true);
+                if (!(layer.getLayout() instanceof Spot)) {
+                    layer.setLayout(new Spot());
+                }
+                int x = base.getAbsoluteX() + px - layer.getAbsoluteX();
+                int y = base.getAbsoluteY() + py - layer.getAbsoluteY();
+                x = Math.max(0, Math.min(x, layer.getWidth() - pw));
+                y = Math.max(0, Math.min(y, layer.getHeight() - ph));
+                ax = Units.toLogical(x + layer.getAbsoluteX() - base.getAbsoluteX());
+                ay = Units.toLogical(y + layer.getAbsoluteY() - base.getAbsoluteY());
+                rootPeer.putClientProperty(X, Integer.valueOf(x));
+                rootPeer.putClientProperty(Y, Integer.valueOf(y));
+                if (rootPeer.getParent() != layer) {
+                    detach();
+                    layer.addComponent(rootPeer);
+                }
+                rootPeer.setX(x);
+                rootPeer.setY(y);
+                rootPeer.setWidth(pw);
+                rootPeer.setHeight(ph);
+                layer.repaint();
+            } else {
+                detach();
+                rootPeer.setX(px);
+                rootPeer.setY(py);
+                rootPeer.setWidth(pw);
+                rootPeer.setHeight(ph);
+            }
+            window.cn1Bounds(ax, ay, w, h);
+        } finally {
+            placing = false;
+        }
+    }
+
+    @Override
+    public void sceneChanged() {
+        detach();
+        scene = window.getScene();
+        rootPeer = null;
+        if (scene != null) {
+            scene.cn1SetHost(this, window);
+            if (scene.getRoot() != null) {
+                rootPeer = scene.getRoot().cn1Peer();
+            }
+        }
+        place();
+    }
+
+    @Override
+    public void rootChanged() {
+        sceneChanged();
+    }
+
+    @Override
+    public void requestPulse() {
+        if (!opened || pulsePending || !Display.isInitialized()) {
+            return;
+        }
+        pulsePending = true;
+        Display.getInstance().callSerially(new Runnable() {
+            @Override
+            public void run() {
+                pulsePending = false;
+                place();
+            }
+        });
+    }
+
+    @Override
+    public void showCursor(int cursor) {
+    }
+
+    @Override
+    public void stageChanged() {
+    }
+
+    @Override
+    public void boundsRequested() {
+        place();
+    }
+
+    @Override
+    public void open() {
+        opened = true;
+        opened(this);
+        place();
+    }
+
+    @Override
+    public void block() {
+    }
+
+    @Override
+    public void close() {
+        opened = false;
+        closed(this);
+        detach();
+    }
+
+    @Override
+    public void toFront() {
+    }
+
+    /// Places every popup of the layer where it was last put.
+    static final class Spot extends Layout {
+
+        @Override
+        public void layoutContainer(Container parent) {
+            int n = parent.getComponentCount();
+            for (int i = 0; i < n; i++) {
+                Component c = parent.getComponentAt(i);
+                Object x = c.getClientProperty(X);
+                Object y = c.getClientProperty(Y);
+                if (x instanceof Integer && y instanceof Integer) {
+                    c.setX(((Integer) x).intValue());
+                    c.setY(((Integer) y).intValue());
+                }
+            }
+        }
+
+        @Override
+        public Dimension getPreferredSize(Container parent) {
+            return new Dimension(0, 0);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageWindow.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageWindow.java
new file mode 100644
index 00000000000..dac4eb647c4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StageWindow.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.layouts.BorderLayout;
+
+import javafx.scene.Scene;
+import javafx.stage.Modality;
+import javafx.stage.Stage;
+import javafx.stage.StageStyle;
+import javafx.stage.Window;
+
+/// A stage shown as a desktop window, where Codename One has those.
+///
+/// The window is sized to the scene: the size the scene was created
+/// with, else the preferred size of its root, unless the stage was given
+/// a width and height. The platform's close control fires the stage's
+/// close request instead of closing the window itself.
+public final class StageWindow extends com.codename1.ui.Window implements StageHost {
+
+    private static final int SETTLE_TRIES = 4;
+
+    private final HostCore core;
+    private int wantedWidth = -1;
+    private int wantedHeight = -1;
+    private int settling;
+
+    /// Creates the desktop window of a stage.
+    public StageWindow(Window window) {
+        super("", new BorderLayout());
+        this.core = new HostCore(window, getContentPane(), this);
+        setCloseOperation(DO_NOTHING_ON_CLOSE);
+        addCloseListener(new ActionListener<ActionEvent>() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                evt.consume();
+                core.window().cn1CloseRequested();
+            }
+        });
+        addSizeChangedListener(new ActionListener<ActionEvent>() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                settleContentSize();
+                core.sized();
+            }
+        });
+        if (window instanceof Stage) {
+            Stage stage = (Stage) window;
+            Modality modality = stage.getModality();
+            if (modality == Modality.APPLICATION_MODAL) {
+                setModalityType(MODALITY_APPLICATION);
+            } else if (modality == Modality.WINDOW_MODAL) {
+                setModalityType(MODALITY_WINDOW);
+            }
+            StageStyle style = stage.getStyle();
+            if (style == StageStyle.UNDECORATED || style == StageStyle.TRANSPARENT) {
+                setDecorated(false);
+            } else if (style == StageStyle.UTILITY) {
+                setUtilityWindow(true);
+            }
+            Window owner = stage.getOwner();
+            if (owner != null && owner.cn1Host() instanceof StageWindow) {
+                setOwnerWindow((StageWindow) owner.cn1Host());
+            }
+        }
+        stageChanged();
+    }
+
+    @Override
+    public void pointerPressed(int x, int y) {
+        if (!SceneInput.pressed(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerPressed(x, y);
+        }
+    }
+
+    @Override
+    public void pointerDragged(int x, int y) {
+        if (!SceneInput.dragged(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerDragged(x, y);
+        }
+    }
+
+    /// The drag of a pointer as the display delivers it. A form has two
+    /// overloads and the display calls this one, which is an
+    /// implementation of its own and never reaches the one above: with
+    /// only that one overridden no drag got to the scene on a device,
+    /// while a press and a release, which a form routes through the plain
+    /// overloads, did. More than one pointer is a gesture of Codename
+    /// One's.
+    @Override
+    public void pointerDragged(int[] x, int[] y) {
+        if (x != null && y != null && x.length == 1 && y.length == 1
+                && SceneInput.dragged(core.scene(), core.rootPeer(), x[0], y[0])) {
+            return;
+        }
+        super.pointerDragged(x, y);
+    }
+
+    @Override
+    public void pointerReleased(int x, int y) {
+        if (!SceneInput.released(core.scene(), core.rootPeer(), x, y)) {
+            super.pointerReleased(x, y);
+        }
+    }
+
+    @Override
+    public void pointerHover(int[] x, int[] y) {
+        if (x == null || y == null || x.length == 0 || y.length == 0
+                || !SceneInput.hover(core.scene(), core.rootPeer(), x[0], y[0])) {
+            super.pointerHover(x, y);
+        }
+    }
+
+    @Override
+    public void longPointerPress(int x, int y) {
+        if (!SceneInput.longPress(core.scene(), core.rootPeer(), x, y)) {
+            super.longPointerPress(x, y);
+        }
+    }
+
+    @Override
+    public void keyPressed(int keyCode) {
+        if (!SceneInput.keyPressed(core.scene(), keyCode)) {
+            super.keyPressed(keyCode);
+        }
+    }
+
+    @Override
+    public void keyReleased(int keyCode) {
+        if (!SceneInput.keyReleased(core.scene(), keyCode)) {
+            super.keyReleased(keyCode);
+        }
+    }
+
+    @Override
+    public void sceneChanged() {
+        core.sceneChanged();
+    }
+
+    @Override
+    public void rootChanged() {
+        core.sceneChanged();
+        repaint();
+    }
+
+    @Override
+    public void requestPulse() {
+        core.requestPulse();
+    }
+
+    @Override
+    public void block() {
+        core.block();
+    }
+
+    @Override
+    public void showCursor(int cursor) {
+        core.showCursor(cursor);
+    }
+
+    @Override
+    public final void stageChanged() {
+        Window window = core.window();
+        if (window instanceof Stage) {
+            Stage stage = (Stage) window;
+            String title = stage.getTitle();
+            setTitle(title == null ? "" : title);
+            setResizable(stage.isResizable());
+            setAlwaysOnTop(stage.isAlwaysOnTop());
+        }
+    }
+
+    @Override
+    public void boundsRequested() {
+        Window w = core.window();
+        Scene scene = core.scene();
+        double width = w.getWidth();
+        double height = w.getHeight();
+        if (Double.isNaN(width) && scene != null) {
+            width = scene.cn1InitialWidth() >= 0 ? scene.cn1InitialWidth()
+                    : (scene.getRoot() == null ? 0 : scene.getRoot().prefWidth(-1));
+        }
+        if (Double.isNaN(height) && scene != null) {
+            height = scene.cn1InitialHeight() >= 0 ? scene.cn1InitialHeight()
+                    : (scene.getRoot() == null ? 0 : scene.getRoot().prefHeight(-1));
+        }
+        if (width > 0 && height > 0) {
+            wantedWidth = Units.sizeToPixels(width);
+            wantedHeight = Units.sizeToPixels(height);
+            settling = 0;
+            setWindowContentSize(wantedWidth, wantedHeight);
+        }
+        if (Double.isNaN(w.getX()) || Double.isNaN(w.getY())) {
+            centerOnDesktop();
+        } else {
+            setWindowLocation(Units.toPixels(w.getX()), Units.toPixels(w.getY()));
+        }
+    }
+
+    /// Asks again for the size of the scene while the window is not that
+    /// size, a few times at most.
+    ///
+    /// A window is asked for the size of what it shows, and the platform
+    /// is asked for a frame of that plus its title bar and borders, which
+    /// are measured as the frame less what is drawn in. On the desktop
+    /// port a window that was just created draws in nothing yet and says
+    /// one pixel, so the whole frame was taken for borders and the window
+    /// came up twice the size of its scene. The first sizes a window
+    /// reports are therefore checked against what was asked for, and it
+    /// is asked again once there is something to measure. After it was
+    /// the right size once, or was asked that often, its size is the
+    /// user's to change.
+    private void settleContentSize() {
+        if (wantedWidth <= 0 || wantedHeight <= 0) {
+            return;
+        }
+        if (Math.abs(getWidth() - wantedWidth) <= 1 && Math.abs(getHeight() - wantedHeight) <= 1) {
+            wantedWidth = -1;
+            return;
+        }
+        if (settling >= SETTLE_TRIES) {
+            wantedWidth = -1;
+            return;
+        }
+        settling++;
+        setWindowContentSize(wantedWidth, wantedHeight);
+    }
+
+    @Override
+    public void open() {
+        boundsRequested();
+        show();
+        settleContentSize();
+        core.sized();
+    }
+
+    @Override
+    public void close() {
+        core.markClosed();
+        dispose();
+    }
+
+    @Override
+    public void toFront() {
+        requestWindowFocus();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleEngine.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleEngine.java
new file mode 100644
index 00000000000..219da8b4d5f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleEngine.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+
+/// The pluggable style sheet engine. The scene graph calls the installed
+/// instance at every point where the styles of a node may have changed; the
+/// engine answers by calling [StyleTarget#cn1ApplyStyle(String, Object)] on
+/// the nodes concerned. The engine installed by default is [CssEngine],
+/// which applies the application's compiled style sheets and the inline
+/// styles of its nodes.
+///
+/// #### When the scene graph calls
+///
+/// - [#restyle(Node)] for a node that entered a scene. The whole subtree
+///   that entered is reported, one call per node, a parent before its
+///   children.
+/// - [#restyle(Node)] for one node whose id, style class list, inline
+///   `style` or set of pseudo-class states changed. Only that node is
+///   reported: an engine with descendant or child selectors that depend on
+///   it walks the subtree itself, for which [#restyleTree(Node)] is the
+///   helper.
+/// - [#stylesheetsChanged(Scene)] and [#stylesheetsChanged(Parent)] when
+///   the `getStylesheets()` list of a scene or a parent changed.
+/// - [#restyle(Node)] is also what `Node.applyCss()` calls.
+///
+/// A node that is not in a scene is never reported. Every call arrives on
+/// the JavaFX application thread, and never from inside another call for
+/// the same node: a property the engine sets does not trigger a restyle.
+///
+/// #### What the engine reads
+///
+/// `Node.getTypeSelector()`, `getId()`, `getStyleClass()`, `getStyle()`,
+/// `getPseudoClassStates()`, `getStyleableParent()`, and the style sheets
+/// of `Node.getScene()` and of each ancestor `Parent`.
+public abstract class StyleEngine {
+
+    private static final StyleEngine NONE = new StyleEngine() {
+        @Override
+        public void restyle(Node node) {
+        }
+
+        @Override
+        public void stylesheetsChanged(Scene scene) {
+        }
+
+        @Override
+        public void stylesheetsChanged(Parent parent) {
+        }
+    };
+
+    private static StyleEngine instance;
+
+    /// Returns the installed engine; never `null`.
+    public static StyleEngine getInstance() {
+        if (instance == null) {
+            // Made on first use rather than in a static initializer: the
+            // default engine is a subclass of this class.
+            instance = new CssEngine();
+        }
+        return instance;
+    }
+
+    /// Installs an engine; `null` returns to the default one, with nothing
+    /// kept of the style sheets the previous default had read.
+    public static void setInstance(StyleEngine engine) {
+        instance = engine;
+    }
+
+    /// Returns an engine that does nothing, for an application that styles
+    /// its nodes in code only and wants no cascade run.
+    public static StyleEngine none() {
+        return NONE;
+    }
+
+    /// Computes and applies the styles of one node.
+    public abstract void restyle(Node node);
+
+    /// Called when the style sheet list of a scene changed. Restyles every
+    /// node of the scene unless overridden.
+    public void stylesheetsChanged(Scene scene) {
+        if (scene != null && scene.getRoot() != null) {
+            restyleTree(scene.getRoot());
+        }
+    }
+
+    /// Called when the style sheet list of a parent changed. Restyles the
+    /// parent's subtree unless overridden.
+    public void stylesheetsChanged(Parent parent) {
+        if (parent != null && parent.getScene() != null) {
+            restyleTree(parent);
+        }
+    }
+
+    /// Calls [#restyle(Node)] for a node and everything below it, a parent
+    /// before its children.
+    public final void restyleTree(Node node) {
+        restyle(node);
+        if (node instanceof Parent) {
+            ObservableList<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                restyleTree(children.get(i));
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleList.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleList.java
new file mode 100644
index 00000000000..2627e12e9a7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleList.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// What a style sheet's layered value becomes for the node that takes it:
+/// one object per fill of a background or stroke of a border, or -- as
+/// [#isSides()] says -- the four paints of one stroke's sides, in the
+/// order top, right, bottom and left.
+///
+/// Two lists are equal when their items are, which is what lets the style
+/// engine see that a restyle changed nothing.
+public final class StyleList {
+
+    private final Object[] items;
+    private final boolean sides;
+
+    /// Creates a list that keeps `items` as its own.
+    public StyleList(Object[] items, boolean sides) {
+        this.items = items;
+        this.sides = sides;
+    }
+
+    /// Whether the items are the sides of one stroke rather than layers.
+    public boolean isSides() {
+        return sides;
+    }
+
+    /// How many items there are.
+    public int size() {
+        return items.length;
+    }
+
+    /// The item at `index`; past the end, the last one, which is how a
+    /// layer without a value of its own is given one. `null` when empty.
+    public Object get(int index) {
+        if (items.length == 0) {
+            return null;
+        }
+        return items[index < items.length ? Math.max(0, index) : items.length - 1];
+    }
+
+    /// The value of layer `index` in `value`: the layer's own when `value`
+    /// is a list of layers, else `value` itself for every layer.
+    public static Object layer(Object value, int index) {
+        if (value instanceof StyleList && !((StyleList) value).sides) {
+            return ((StyleList) value).get(index);
+        }
+        return value;
+    }
+
+    /// How many layers `value` is: its size as a list of layers, else one.
+    public static int layers(Object value) {
+        if (value instanceof StyleList && !((StyleList) value).sides) {
+            return ((StyleList) value).items.length;
+        }
+        return 1;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof StyleList)) {
+            return false;
+        }
+        StyleList other = (StyleList) o;
+        if (other.sides != sides || other.items.length != items.length) {
+            return false;
+        }
+        for (int i = 0; i < items.length; i++) {
+            Object a = items[i];
+            Object b = other.items[i];
+            if (a == null ? b != null : !a.equals(b)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int h = sides ? 31 : 17;
+        for (int i = 0; i < items.length; i++) {
+            h = h * 31 + (items[i] == null ? 0 : items[i].hashCode());
+        }
+        return h;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleTarget.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleTarget.java
new file mode 100644
index 00000000000..a706c813303
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/StyleTarget.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// The one entry point through which a style sheet engine sets the visual
+/// attributes of a node. Every `javafx.scene.Node` implements it.
+///
+/// #### The call
+///
+/// `cn1ApplyStyle(property, value)` takes the JavaFX CSS property name,
+/// spelled exactly as in a style sheet and in lower case (`-fx-text-fill`),
+/// and a value that is already parsed:
+///
+/// - a colour or gradient: `javafx.scene.paint.Paint`
+/// - a length or a plain number: `Number`, lengths in logical pixels
+/// - four lengths: `javafx.geometry.Insets`
+/// - corner radii: `javafx.scene.layout.CornerRadii`, or a `Number` for
+///   one radius on every corner
+/// - a font: `javafx.scene.text.Font`
+/// - an alignment: `javafx.geometry.Pos`
+/// - an enumerated keyword: the enum constant, or its CSS spelling as a
+///   `String` (`"bold"`, `"round"`, `"dashed"`); the string is matched
+///   without regard to ASCII case
+/// - a flag: `Boolean`
+/// - text: `String`
+///
+/// It answers `true` when the node took the value. It answers `false`,
+/// and changes nothing, when the node does not have that property or the
+/// value is of a type the property cannot use; an engine must treat that
+/// as "this declaration does not apply", never as an error.
+///
+/// #### Undoing a value
+///
+/// The first time a property is styled the node remembers the value it had.
+/// `cn1ApplyStyle(property, null)` puts that value back and forgets it,
+/// which is how an engine withdraws a declaration that stopped matching
+/// (a `:hover` rule when the pointer leaves). It answers whether the node
+/// has the property. A value the application sets through the ordinary
+/// setter while a style is in force is overwritten by the next styled
+/// value and is not what a later `null` restores.
+///
+/// #### Shorthands
+///
+/// The engine expands shorthands that carry several values: `-fx-font`
+/// arrives as one `Font`; the per side forms of `-fx-padding`,
+/// `-fx-border-width` and `-fx-background-insets` arrive as one `Insets`.
+/// Layered backgrounds and borders are not supported: one paint, one set of
+/// radii and one set of insets per node.
+///
+/// #### Property names by node family
+///
+/// - every node: `-fx-opacity`, `-fx-rotate`, `-fx-scale-x`, `-fx-scale-y`,
+///   `-fx-translate-x`, `-fx-translate-y` (`Number`); `-fx-cursor`
+///   (`javafx.scene.Cursor`); `visibility` (`Boolean`, or `"visible"`,
+///   `"hidden"`, `"collapse"`); `-fx-managed` (`Boolean`)
+/// - `Region` and everything below it, controls included:
+///   `-fx-background-color` (`Paint`), `-fx-background-radius`
+///   (`CornerRadii` or `Number`), `-fx-background-insets` (`Insets` or
+///   `Number`), `-fx-border-color` (`Paint`), `-fx-border-width`
+///   (`Insets`, `BorderWidths` or `Number`), `-fx-border-radius`
+///   (`CornerRadii` or `Number`), `-fx-border-style` (`BorderStrokeStyle`
+///   or `"none"`, `"solid"`, `"dashed"`, `"dotted"`), `-fx-padding`
+///   (`Insets` or `Number`), `-fx-min-width`, `-fx-pref-width`,
+///   `-fx-max-width`, `-fx-min-height`, `-fx-pref-height`,
+///   `-fx-max-height` (`Number`), `-fx-snap-to-pixel` (`Boolean`)
+/// - `HBox`, `VBox`: `-fx-spacing` (`Number`), `-fx-alignment` (`Pos`),
+///   `-fx-fill-height` / `-fx-fill-width` (`Boolean`)
+/// - `StackPane`: `-fx-alignment`
+/// - `FlowPane`, `TilePane`, `GridPane`: `-fx-hgap`, `-fx-vgap`
+///   (`Number`), `-fx-alignment`; `FlowPane` and `TilePane` also
+///   `-fx-orientation` (`javafx.geometry.Orientation` or its name)
+/// - `Labeled` (labels, buttons, check boxes...): `-fx-text-fill`
+///   (`Paint`), `-fx-font` (`Font`), `-fx-font-size` (`Number`),
+///   `-fx-font-family` (`String`), `-fx-font-weight` (`FontWeight`, a
+///   `Number` 100-900 or a keyword), `-fx-font-style` (`FontPosture` or a
+///   keyword), `-fx-alignment`, `-fx-text-alignment` (`TextAlignment` or a
+///   keyword), `-fx-wrap-text`, `-fx-underline` (`Boolean`),
+///   `-fx-graphic-text-gap` (`Number`), `-fx-content-display`
+///   (`ContentDisplay` or its name)
+///
+/// - text input controls (`TextField`, `PasswordField`, `TextArea`):
+///   `-fx-text-fill`, `-fx-prompt-text-fill` (`Paint`), and the font
+///   names of `Labeled`
+/// - `ScrollPane`: `-fx-fit-to-width`, `-fx-fit-to-height`,
+///   `-fx-pannable` (`Boolean`), `-fx-hbar-policy`, `-fx-vbar-policy`
+///   (`ScrollPane.ScrollBarPolicy`, or `"never"`, `"always"`,
+///   `"as-needed"`)
+/// - `Shape` and everything below it: `-fx-fill`, `-fx-stroke` (`Paint`;
+///   here `null` cannot mean "no paint", since it restores),
+///   `-fx-stroke-width`, `-fx-stroke-miter-limit`,
+///   `-fx-stroke-dash-offset` (`Number`), `-fx-stroke-line-cap`,
+///   `-fx-stroke-line-join`, `-fx-stroke-type` (the enum or its keyword),
+///   `-fx-smooth` (`Boolean`)
+/// - `Text`, besides the shape names: the font names of `Labeled`,
+///   `-fx-text-alignment`, `-fx-text-origin` (`VPos` or its keyword),
+///   `-fx-underline`, `-fx-strikethrough` (`Boolean`),
+///   `-fx-line-spacing` (`Number`)
+///
+/// A class that takes names of its own repeats them in its description,
+/// where it overrides `cn1StyleValue` and `cn1SetStyleValue`.
+public interface StyleTarget {
+
+    /// Sets, or with a `null` value restores, one styleable attribute.
+    /// See the interface description for the names and the value types.
+    boolean cn1ApplyStyle(String property, Object value);
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SvgPath.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SvgPath.java
new file mode 100644
index 00000000000..74ac56770d9
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/SvgPath.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+/// Reads SVG path data, the `d` attribute of an SVG path, into an
+/// [FxPath].
+///
+/// Every command is understood, in its absolute and relative form: `M`,
+/// `L`, `H`, `V`, `C`, `S`, `Q`, `T`, `A` and `Z`. So are the compact
+/// spellings the grammar allows: coordinates after a command repeat it
+/// (after a move they are lines), a sign or a second decimal point starts
+/// the next number (`1-2`, `.5.5`), numbers may carry an exponent and the
+/// two flags of an arc need no separator. Elliptical arcs become cubic
+/// curves.
+///
+/// Data that stops making sense ends the path there: what was read before
+/// the error is kept, which is what JavaFX and SVG renderers do.
+public final class SvgPath {
+
+    private final String s;
+    private int i;
+    private boolean failed;
+
+    private SvgPath(String data) {
+        this.s = data;
+    }
+
+    private void skip() {
+        while (i < s.length()) {
+            char c = s.charAt(i);
+            if (c == ' ' || c == ',' || c == '\t' || c == '\n' || c == '\r' || c == '\f') {
+                i++;
+            } else {
+                break;
+            }
+        }
+    }
+
+    private static boolean digit(char c) {
+        return c >= '0' && c <= '9';
+    }
+
+    private double number() {
+        skip();
+        int start = i;
+        int n = s.length();
+        if (i < n && (s.charAt(i) == '+' || s.charAt(i) == '-')) {
+            i++;
+        }
+        int digits = 0;
+        while (i < n && digit(s.charAt(i))) {
+            i++;
+            digits++;
+        }
+        if (i < n && s.charAt(i) == '.') {
+            i++;
+            while (i < n && digit(s.charAt(i))) {
+                i++;
+                digits++;
+            }
+        }
+        if (digits == 0) {
+            failed = true;
+            return 0;
+        }
+        if (i < n && (s.charAt(i) == 'e' || s.charAt(i) == 'E')) {
+            int e = i + 1;
+            if (e < n && (s.charAt(e) == '+' || s.charAt(e) == '-')) {
+                e++;
+            }
+            if (e < n && digit(s.charAt(e))) {
+                while (e < n && digit(s.charAt(e))) {
+                    e++;
+                }
+                i = e;
+            }
+        }
+        try {
+            return Double.parseDouble(s.substring(start, i));
+        } catch (NumberFormatException malformed) {
+            failed = true;
+            return 0;
+        }
+    }
+
+    private boolean flag() {
+        skip();
+        if (i < s.length() && (s.charAt(i) == '0' || s.charAt(i) == '1')) {
+            return s.charAt(i++) == '1';
+        }
+        failed = true;
+        return false;
+    }
+
+    private static boolean isCommand(char c) {
+        return "MmLlHhVvCcSsQqTtAaZz".indexOf(c) >= 0;
+    }
+
+    /// Appends path data to a path. Answers `false` when the data was
+    /// malformed; the path then holds everything up to the error. `null`
+    /// and empty data add nothing and are well formed. Data for an empty
+    /// path has to start with a move; data for a path that has segments
+    /// may continue from its current point.
+    public static boolean append(String data, FxPath out) {
+        if (data == null) {
+            return true;
+        }
+        return new SvgPath(data).read(out);
+    }
+
+    private boolean read(FxPath out) {
+        char command = 0;
+        char previous = 0;
+        // Data appended to a path that is already under way may draw on
+        // from its current point without a move of its own.
+        boolean continues = !out.isEmpty();
+        double cx = out.currentX();
+        double cy = out.currentY();
+        double sx = out.startX();
+        double sy = out.startY();
+        double kx = 0;
+        double ky = 0;
+        boolean reopen = false;
+        while (true) {
+            skip();
+            if (i >= s.length()) {
+                return true;
+            }
+            char ch = s.charAt(i);
+            if (isCommand(ch)) {
+                if (command == 0 && ch != 'M' && ch != 'm' && !continues) {
+                    return false;
+                }
+                command = ch;
+                i++;
+            } else if (command == 0 || command == 'Z' || command == 'z') {
+                return false;
+            }
+            boolean relative = command >= 'a';
+            char kind = relative ? (char) (command - ('a' - 'A')) : command;
+            double ox = relative ? cx : 0;
+            double oy = relative ? cy : 0;
+            if (kind == 'Z') {
+                out.closePath();
+                cx = sx;
+                cy = sy;
+                reopen = true;
+                previous = kind;
+                continue;
+            }
+            double x1 = 0;
+            double y1 = 0;
+            double x2 = 0;
+            double y2 = 0;
+            double x = cx;
+            double y = cy;
+            double rx = 0;
+            double ry = 0;
+            double rotation = 0;
+            boolean large = false;
+            boolean sweep = false;
+            switch (kind) {
+                case 'H':
+                    x = ox + number();
+                    break;
+                case 'V':
+                    y = oy + number();
+                    break;
+                case 'C':
+                    x1 = ox + number();
+                    y1 = oy + number();
+                    x2 = ox + number();
+                    y2 = oy + number();
+                    x = ox + number();
+                    y = oy + number();
+                    break;
+                case 'S':
+                    x2 = ox + number();
+                    y2 = oy + number();
+                    x = ox + number();
+                    y = oy + number();
+                    break;
+                case 'Q':
+                    x1 = ox + number();
+                    y1 = oy + number();
+                    x = ox + number();
+                    y = oy + number();
+                    break;
+                case 'A':
+                    rx = number();
+                    ry = number();
+                    rotation = number();
+                    large = flag();
+                    sweep = flag();
+                    x = ox + number();
+                    y = oy + number();
+                    break;
+                default:
+                    // M, L and T take one point.
+                    x = ox + number();
+                    y = oy + number();
+                    break;
+            }
+            if (failed) {
+                return false;
+            }
+            if (kind == 'M') {
+                out.moveTo(x, y);
+                sx = x;
+                sy = y;
+                reopen = false;
+                // Further points after a move are lines.
+                command = relative ? 'l' : 'L';
+            } else {
+                if (reopen) {
+                    out.moveTo(sx, sy);
+                    reopen = false;
+                }
+                if (kind == 'C') {
+                    out.curveTo(x1, y1, x2, y2, x, y);
+                    kx = x2;
+                    ky = y2;
+                } else if (kind == 'S') {
+                    boolean smooth = previous == 'C' || previous == 'S';
+                    out.curveTo(smooth ? 2 * cx - kx : cx, smooth ? 2 * cy - ky : cy, x2, y2, x, y);
+                    kx = x2;
+                    ky = y2;
+                } else if (kind == 'Q') {
+                    out.quadTo(x1, y1, x, y);
+                    kx = x1;
+                    ky = y1;
+                } else if (kind == 'T') {
+                    boolean smooth = previous == 'Q' || previous == 'T';
+                    kx = smooth ? 2 * cx - kx : cx;
+                    ky = smooth ? 2 * cy - ky : cy;
+                    out.quadTo(kx, ky, x, y);
+                } else if (kind == 'A') {
+                    out.arcTo(rx, ry, rotation, large, sweep, x, y);
+                } else {
+                    out.lineTo(x, y);
+                }
+            }
+            cx = x;
+            cy = y;
+            previous = kind;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Units.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Units.java
new file mode 100644
index 00000000000..dc42d09c89c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/Units.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import com.codename1.ui.Display;
+
+/// The conversion between JavaFX coordinates and device pixels.
+///
+/// A JavaFX coordinate is a density independent logical pixel, 1/96 of an
+/// inch. The scale is the number of device pixels in one of them, derived
+/// from the display density Codename One reports. The Display property
+/// `desktopcompat.scale` overrides it, and so does [#setScale(double)].
+///
+/// Sizes handed to Codename One are snapped to whole device pixels by
+/// converting both edges of a rectangle and subtracting, so two rectangles
+/// that touch in logical coordinates touch on the screen too.
+public final class Units {
+
+    private static double override;
+    private static double cached;
+
+    private Units() {
+    }
+
+    /// Returns the number of device pixels in one logical pixel.
+    public static double scale() {
+        if (override > 0) {
+            return override;
+        }
+        if (cached > 0) {
+            return cached;
+        }
+        if (!Display.isInitialized()) {
+            return 1;
+        }
+        double s = 0;
+        String property = Display.getInstance().getProperty("desktopcompat.scale", null);
+        if (property != null) {
+            try {
+                s = Double.parseDouble(property);
+            } catch (NumberFormatException malformed) {
+                s = 0;
+            }
+        }
+        if (!(s > 0)) {
+            double pixelsPerMm = Display.getInstance().convertToPixels(1000, true) / 1000.0;
+            s = pixelsPerMm * 25.4 / 96.0;
+        }
+        if (!(s > 0)) {
+            s = 1;
+        }
+        cached = s;
+        return s;
+    }
+
+    /// Fixes the scale; a value that is not positive returns to the
+    /// display's own.
+    public static void setScale(double scale) {
+        override = scale > 0 ? scale : 0;
+        cached = 0;
+    }
+
+    /// Converts a logical coordinate to the nearest device pixel.
+    public static int toPixels(double logical) {
+        return (int) Math.round(logical * scale());
+    }
+
+    /// Converts a logical length to device pixels, never rounding a visible
+    /// length down to nothing.
+    public static int sizeToPixels(double logical) {
+        if (!(logical > 0)) {
+            return 0;
+        }
+        int px = (int) Math.round(logical * scale());
+        return px < 1 ? 1 : px;
+    }
+
+    /// Converts device pixels to logical pixels.
+    public static double toLogical(double pixels) {
+        return pixels / scale();
+    }
+
+    /// Moves a logical coordinate onto the nearest device pixel boundary.
+    public static double snap(double logical) {
+        double s = scale();
+        return Math.round(logical * s) / s;
+    }
+
+    /// Grows a logical length to the next device pixel boundary.
+    public static double snapSize(double logical) {
+        double s = scale();
+        return Math.ceil(logical * s - 1e-6) / s;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/UnmodifiableViews.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/UnmodifiableViews.java
new file mode 100644
index 00000000000..43b5429cb09
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/UnmodifiableViews.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import javafx.beans.InvalidationListener;
+import javafx.collections.ListChangeListener;
+import javafx.collections.MapChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableListBase;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.collections.SetChangeListener;
+import javafx.collections.WeakListChangeListener;
+import javafx.collections.WeakMapChangeListener;
+import javafx.collections.WeakSetChangeListener;
+
+/// Read-only views of observable collections. Each refuses modification,
+/// shows the content of its source and tells its own listeners about every
+/// change of the source, which it observes weakly.
+public final class UnmodifiableViews {
+
+    private UnmodifiableViews() {
+    }
+
+    /// A read-only view of a list.
+    public static final class OfList<E> extends ObservableListBase<E> {
+        private final ObservableList<E> source;
+        private final ListChangeListener<E> listener;
+
+        /// Creates the view.
+        public OfList(ObservableList<E> source) {
+            this.source = source;
+            this.listener = new ListChangeListener<E>() {
+                @Override
+                public void onChanged(Change<? extends E> change) {
+                    relay(change);
+                }
+            };
+            source.addListener(new WeakListChangeListener<E>(listener));
+        }
+
+        private void relay(ListChangeListener.Change<? extends E> change) {
+            modCount++;
+            fireChange(new Changes.Relayed<E>(this, change));
+        }
+
+        @Override
+        public E get(int index) {
+            return source.get(index);
+        }
+
+        @Override
+        public int size() {
+            return source.size();
+        }
+    }
+
+    /// A read-only view of a map.
+    public static final class OfMap<K, V> extends AbstractMap<K, V> implements ObservableMap<K, V> {
+        private final ObservableMap<K, V> source;
+        private final Map<K, V> readOnly;
+        private final MapChangeListener<K, V> listener;
+        private ListenerSet<MapChangeListener<? super K, ? super V>> listeners;
+
+        /// Creates the view.
+        public OfMap(ObservableMap<K, V> source) {
+            this.source = source;
+            this.readOnly = Collections.unmodifiableMap(source);
+            this.listener = new MapChangeListener<K, V>() {
+                @Override
+                public void onChanged(Change<? extends K, ? extends V> change) {
+                    relay(change);
+                }
+            };
+            source.addListener(new WeakMapChangeListener<K, V>(listener));
+        }
+
+        private void relay(MapChangeListener.Change<? extends K, ? extends V> change) {
+            if (ListenerSet.hasListeners(listeners)) {
+                Changes.fire(listeners, this, new Changes.OfMap<K, V>(this, change.getKey(),
+                        change.getValueRemoved(), change.getValueAdded(), change.wasAdded(), change.wasRemoved()));
+            }
+        }
+
+        @Override
+        public void addListener(InvalidationListener invalidationListener) {
+            listeners = ListenerSet.addInvalidation(listeners, invalidationListener);
+        }
+
+        @Override
+        public void removeListener(InvalidationListener invalidationListener) {
+            listeners = ListenerSet.removeInvalidation(listeners, invalidationListener);
+        }
+
+        @Override
+        public void addListener(MapChangeListener<? super K, ? super V> changeListener) {
+            listeners = ListenerSet.addChange(listeners, changeListener);
+        }
+
+        @Override
+        public void removeListener(MapChangeListener<? super K, ? super V> changeListener) {
+            listeners = ListenerSet.removeChange(listeners, changeListener);
+        }
+
+        @Override
+        public int size() {
+            return source.size();
+        }
+
+        @Override
+        public boolean containsKey(Object key) {
+            return source.containsKey(key);
+        }
+
+        @Override
+        public V get(Object key) {
+            return source.get(key);
+        }
+
+        @Override
+        public Set<Map.Entry<K, V>> entrySet() {
+            return readOnly.entrySet();
+        }
+    }
+
+    /// A read-only view of a set.
+    public static final class OfSet<E> extends AbstractSet<E> implements ObservableSet<E> {
+        private final ObservableSet<E> source;
+        private final Set<E> readOnly;
+        private final SetChangeListener<E> listener;
+        private ListenerSet<SetChangeListener<? super E>> listeners;
+
+        /// Creates the view.
+        public OfSet(ObservableSet<E> source) {
+            this.source = source;
+            this.readOnly = Collections.unmodifiableSet(source);
+            this.listener = new SetChangeListener<E>() {
+                @Override
+                public void onChanged(Change<? extends E> change) {
+                    relay(change);
+                }
+            };
+            source.addListener(new WeakSetChangeListener<E>(listener));
+        }
+
+        private void relay(SetChangeListener.Change<? extends E> change) {
+            if (ListenerSet.hasListeners(listeners)) {
+                boolean added = change.wasAdded();
+                E element = added ? change.getElementAdded() : change.getElementRemoved();
+                Changes.fire(listeners, this, new Changes.OfSet<E>(this, element, added));
+            }
+        }
+
+        @Override
+        public void addListener(InvalidationListener invalidationListener) {
+            listeners = ListenerSet.addInvalidation(listeners, invalidationListener);
+        }
+
+        @Override
+        public void removeListener(InvalidationListener invalidationListener) {
+            listeners = ListenerSet.removeInvalidation(listeners, invalidationListener);
+        }
+
+        @Override
+        public void addListener(SetChangeListener<? super E> changeListener) {
+            listeners = ListenerSet.addChange(listeners, changeListener);
+        }
+
+        @Override
+        public void removeListener(SetChangeListener<? super E> changeListener) {
+            listeners = ListenerSet.removeChange(listeners, changeListener);
+        }
+
+        @Override
+        public int size() {
+            return source.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return source.contains(o);
+        }
+
+        @Override
+        public Iterator<E> iterator() {
+            return readOnly.iterator();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ValueListeners.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ValueListeners.java
new file mode 100644
index 00000000000..892c1ac16a3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/ValueListeners.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime;
+
+import java.util.List;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+
+/// The listeners of an observable value, and the last value its change
+/// listeners were told about.
+///
+/// The first change listener makes the owner eager: its value is read when
+/// the listener is added and again on every invalidation, because that is
+/// the only way to know the old and the new value.
+public final class ValueListeners<T> {
+
+    private final ObservableValue<T> observable;
+    private ListenerSet<ChangeListener<? super T>> set;
+    private T currentValue;
+
+    private ValueListeners(ObservableValue<T> observable) {
+        this.observable = observable;
+    }
+
+    /// Adds an invalidation listener.
+    public static <T> ValueListeners<T> add(ValueListeners<T> helper, ObservableValue<T> observable,
+            InvalidationListener listener) {
+        if (observable == null || listener == null) {
+            throw new NullPointerException();
+        }
+        ValueListeners<T> result = helper == null ? new ValueListeners<T>(observable) : helper;
+        result.set = ListenerSet.addInvalidation(result.set, listener);
+        return result;
+    }
+
+    /// Removes an invalidation listener; returns `null` once nothing is left.
+    public static <T> ValueListeners<T> remove(ValueListeners<T> helper, InvalidationListener listener) {
+        if (listener == null) {
+            throw new NullPointerException();
+        }
+        if (helper == null) {
+            return null;
+        }
+        helper.set = ListenerSet.removeInvalidation(helper.set, listener);
+        return helper.set == null ? null : helper;
+    }
+
+    /// Adds a change listener, reading the value if it is the first one.
+    public static <T> ValueListeners<T> add(ValueListeners<T> helper, ObservableValue<T> observable,
+            ChangeListener<? super T> listener) {
+        if (observable == null || listener == null) {
+            throw new NullPointerException();
+        }
+        ValueListeners<T> result = helper == null ? new ValueListeners<T>(observable) : helper;
+        boolean first = ListenerSet.changeListeners(result.set).isEmpty();
+        result.set = ListenerSet.addChange(result.set, listener);
+        if (first) {
+            result.currentValue = observable.getValue();
+        }
+        return result;
+    }
+
+    /// Removes a change listener; returns `null` once nothing is left.
+    public static <T> ValueListeners<T> remove(ValueListeners<T> helper, ChangeListener<? super T> listener) {
+        if (listener == null) {
+            throw new NullPointerException();
+        }
+        if (helper == null) {
+            return null;
+        }
+        helper.set = ListenerSet.removeChange(helper.set, listener);
+        if (ListenerSet.changeListeners(helper.set).isEmpty()) {
+            helper.currentValue = null;
+        }
+        return helper.set == null ? null : helper;
+    }
+
+    /// Tells the invalidation listeners the value is stale and, when the
+    /// value really differs from the last one reported, the change listeners.
+    public static <T> void fire(ValueListeners<T> helper) {
+        if (helper == null) {
+            return;
+        }
+        ListenerSet<ChangeListener<? super T>> set = helper.set;
+        ListenerSet.fireInvalidation(set, helper.observable);
+        List<ChangeListener<? super T>> listeners = ListenerSet.changeListeners(set);
+        if (!listeners.isEmpty()) {
+            T oldValue = helper.currentValue;
+            T newValue = helper.observable.getValue();
+            helper.currentValue = newValue;
+            boolean changed = newValue == null ? oldValue != null : !newValue.equals(oldValue);
+            if (changed) {
+                for (int i = 0; i < listeners.size(); i++) {
+                    listeners.get(i).changed(helper.observable, oldValue, newValue);
+                }
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssDeclaration.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssDeclaration.java
new file mode 100644
index 00000000000..b836d492b99
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssDeclaration.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+/// One declaration of a rule or of an inline style: a property, its parsed
+/// value, and whether it was marked `!important`.
+public final class CssDeclaration {
+
+    private final String name;
+    private final int kind;
+    private final CssValue value;
+    private final boolean important;
+
+    /// Creates a declaration. `kind` is the kind of the property in
+    /// [CssProperties], [CssProperties#LOOKUP_DEFINITION] for a name that
+    /// defines a looked-up colour.
+    public CssDeclaration(String name, int kind, CssValue value, boolean important) {
+        this.name = name;
+        this.kind = kind;
+        this.value = value;
+        this.important = important;
+    }
+
+    /// The property name, in lower case.
+    public String name() {
+        return name;
+    }
+
+    /// The kind of the property; see [CssProperties].
+    public int kind() {
+        return kind;
+    }
+
+    /// The parsed value.
+    public CssValue value() {
+        return value;
+    }
+
+    /// Whether the declaration was marked `!important`.
+    public boolean important() {
+        return important;
+    }
+
+    @Override
+    public String toString() {
+        return name + ": " + value + (important ? " !important" : "");
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssDeclarations.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssDeclarations.java
new file mode 100644
index 00000000000..56a9675978b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssDeclarations.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+import java.util.List;
+
+/// Reads a list of declarations -- the text between the braces of a rule,
+/// or an inline `style` string -- into [CssDeclaration]s.
+///
+/// CSS is forgiving, and so is this: a declaration that cannot be read is
+/// reported to the [Reporter] and left out, and the ones around it are
+/// kept. Only the caller knows what a report is worth: the build prints it
+/// with the file and the line, the device logs it once.
+public final class CssDeclarations {
+
+    /// Where the declarations that were left out are reported.
+    public interface Reporter {
+        /// Reports the declaration starting at `offset` in the text that was
+        /// parsed.
+        void warning(int offset, String message);
+    }
+
+    private CssDeclarations() {
+    }
+
+    /// `text` with every comment replaced by spaces, so that what is left
+    /// keeps its offsets and its line numbers. A comment left open runs to
+    /// the end of the text. Two slashes outside quotes and parentheses
+    /// start a comment that ends with its line, as in JavaFX.
+    public static String stripComments(String text) {
+        if (text.indexOf("/*") < 0 && text.indexOf("//") < 0) {
+            return text;
+        }
+        char[] out = text.toCharArray();
+        int n = out.length;
+        char quote = 0;
+        int depth = 0;
+        for (int i = 0; i < n; i++) {
+            char c = out[i];
+            if (quote != 0) {
+                if (c == '\\') {
+                    i++;
+                } else if (c == quote) {
+                    quote = 0;
+                }
+            } else if (c == '"' || c == '\'') {
+                quote = c;
+            } else if (c == '/' && i + 1 < n && out[i + 1] == '*') {
+                int end = text.indexOf("*/", i + 2);
+                end = end < 0 ? n : end + 2;
+                for (int j = i; j < end; j++) {
+                    if (out[j] != '\n' && out[j] != '\r') {
+                        out[j] = ' ';
+                    }
+                }
+                i = end - 1;
+            } else if (c == '(') {
+                depth++;
+            } else if (c == ')') {
+                depth = depth > 0 ? depth - 1 : 0;
+            } else if (c == '/' && depth == 0 && i + 1 < n && out[i + 1] == '/') {
+                // A comment to the end of the line, which JavaFX reads
+                // though CSS has none. Inside parentheses it is the two
+                // slashes of an address.
+                while (i < n && out[i] != '\n' && out[i] != '\r') {
+                    out[i++] = ' ';
+                }
+                i--;
+            }
+        }
+        return new String(out);
+    }
+
+    /// Parses the declarations in `text` between `from` and `to`, which
+    /// holds no comments, and adds them to `out` in the order written.
+    /// `parser` is the caller's, so that one is enough for a whole style
+    /// sheet.
+    public static void parse(String text, int from, int to, CssValueParser parser, Reporter reporter,
+            List<CssDeclaration> out) {
+        int i = from;
+        while (i < to) {
+            while (i < to && (CssValueParser.isSpace(text.charAt(i)) || text.charAt(i) == ';')) {
+                i++;
+            }
+            if (i >= to) {
+                break;
+            }
+            int start = i;
+            int colon = -1;
+            int depth = 0;
+            char quote = 0;
+            for (; i < to; i++) {
+                char c = text.charAt(i);
+                if (quote != 0) {
+                    if (c == '\\') {
+                        i++;
+                    } else if (c == quote) {
+                        quote = 0;
+                    }
+                } else if (c == '"' || c == '\'') {
+                    quote = c;
+                } else if (c == '(') {
+                    depth++;
+                } else if (c == ')') {
+                    depth--;
+                } else if (c == ':' && colon < 0 && depth == 0) {
+                    colon = i;
+                } else if (c == ';' && depth <= 0) {
+                    break;
+                }
+            }
+            int end = Math.min(i, to);
+            if (colon < 0) {
+                reporter.warning(start, "'" + text.substring(start, end).trim() + "' is not a declaration");
+                continue;
+            }
+            String name = CssProperties.lower(text.substring(start, colon).trim());
+            String value = text.substring(colon + 1, end).trim();
+            boolean important = false;
+            int bang = value.lastIndexOf('!');
+            if (bang >= 0 && "important".equals(CssProperties.lower(value.substring(bang + 1).trim()))) {
+                important = true;
+                value = value.substring(0, bang).trim();
+            }
+            if (name.length() == 0) {
+                reporter.warning(start, "a declaration needs a property name");
+                continue;
+            }
+            if (CssProperties.kind(name) == CssProperties.UNKNOWN && !CssProperties.isDefinitionName(name)) {
+                reporter.warning(start, name + " is not a property this layer styles; the declaration is ignored");
+                continue;
+            }
+            CssValue parsed = parser.parse(name, value);
+            if (parsed == null) {
+                reporter.warning(start, name + ": '" + value + "': " + parser.error()
+                        + "; the declaration is ignored");
+                continue;
+            }
+            if (parser.warning() != null) {
+                reporter.warning(start, name + ": " + parser.warning());
+            }
+            out.add(new CssDeclaration(name, CssValueParser.kindOf(name), parsed, important));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssProperties.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssProperties.java
new file mode 100644
index 00000000000..2991b72c596
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssProperties.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+import java.util.HashMap;
+
+/// The style properties the scene graph takes, and what kind of value each
+/// one is written as. It is the list in the description of
+/// `com.codename1.fxcompat.runtime.StyleTarget`, as data: the parser reads
+/// it to know how to read a value, and the engine to know what object to
+/// make of one.
+///
+/// A property that is not in the table is not an error. JavaFX lets a rule
+/// define any name as a colour and other rules use it (`-fx-base`,
+/// `-my-accent`), so an unknown name whose value reads as a paint is such a
+/// definition, [#LOOKUP_DEFINITION]; only an unknown name with any other
+/// value is reported and dropped.
+public final class CssProperties {
+
+    /// Not a property of the scene graph.
+    public static final int UNKNOWN = 0;
+    /// A colour or a gradient.
+    public static final int PAINT = 1;
+    /// One length.
+    public static final int LENGTH = 2;
+    /// A number without a unit; an angle in degrees for `-fx-rotate`.
+    public static final int NUMBER = 3;
+    /// One to four lengths: top, right, bottom, left.
+    public static final int INSETS = 4;
+    /// One to four radii, clockwise from the top left.
+    public static final int RADII = 5;
+    /// `true` or `false`.
+    public static final int BOOLEAN = 6;
+    /// One of a fixed set of words.
+    public static final int KEYWORD = 7;
+    /// One quoted string, taken as it is: the path of `-fx-shape`.
+    public static final int TEXT = 16;
+    /// The `-fx-font` shorthand.
+    public static final int FONT = 8;
+    /// A font size: a length, a percentage or a size keyword.
+    public static final int FONT_SIZE = 9;
+    /// A font family name.
+    public static final int FONT_FAMILY = 10;
+    /// A font weight: a keyword or 100 to 900.
+    public static final int FONT_WEIGHT = 11;
+    /// A font posture keyword.
+    public static final int FONT_STYLE = 12;
+    /// An alignment keyword such as `center-left`.
+    public static final int POS = 13;
+    /// A cursor name.
+    public static final int CURSOR = 14;
+    /// What an unknown name with a paint for a value is: a colour other
+    /// rules look up by that name.
+    public static final int LOOKUP_DEFINITION = 15;
+    /// `-fx-effect`: `dropshadow(...)`, `innershadow(...)` or `none`.
+    public static final int EFFECT = 17;
+
+    /// A value kept as the text that was written, for the node to read:
+    /// the pictures of a background and of a border, and how they are
+    /// placed. An address in it is made whole when the sheet is compiled.
+    public static final int RAW = 18;
+
+    private static final HashMap<String, Integer> KINDS = new HashMap<String, Integer>();
+    private static final HashMap<String, String[]> KEYWORDS = new HashMap<String, String[]>();
+
+    static {
+        add(PAINT, "-fx-background-color", "-fx-border-color", "-fx-text-fill", "-fx-prompt-text-fill", "-fx-fill",
+                "-fx-stroke");
+        add(LENGTH, "-fx-min-width", "-fx-pref-width", "-fx-max-width", "-fx-min-height", "-fx-pref-height",
+                "-fx-max-height", "-fx-spacing", "-fx-hgap", "-fx-vgap", "-fx-graphic-text-gap", "-fx-stroke-width",
+                "-fx-stroke-dash-offset", "-fx-line-spacing", "-fx-translate-x", "-fx-translate-y", "-fx-size");
+        add(NUMBER, "-fx-opacity", "-fx-rotate", "-fx-scale-x", "-fx-scale-y", "-fx-stroke-miter-limit");
+        add(INSETS, "-fx-padding", "-fx-background-insets", "-fx-border-width", "-fx-border-insets");
+        add(RADII, "-fx-background-radius", "-fx-border-radius");
+        add(BOOLEAN, "-fx-managed", "-fx-snap-to-pixel", "-fx-fill-height", "-fx-fill-width", "-fx-wrap-text",
+                "-fx-underline", "-fx-strikethrough", "-fx-fit-to-width", "-fx-fit-to-height", "-fx-pannable",
+                "-fx-smooth", "-fx-scale-shape", "-fx-position-shape");
+        add(TEXT, "-fx-shape");
+        add(RAW, "-fx-background-image", "-fx-background-repeat", "-fx-background-position",
+                "-fx-background-size", "-fx-border-image-source", "-fx-border-image-slice",
+                "-fx-border-image-width", "-fx-border-image-repeat", "-fx-border-image-insets");
+        add(FONT, "-fx-font");
+        add(FONT_SIZE, "-fx-font-size");
+        add(FONT_FAMILY, "-fx-font-family");
+        add(FONT_WEIGHT, "-fx-font-weight");
+        add(FONT_STYLE, "-fx-font-style");
+        add(POS, "-fx-alignment");
+        add(CURSOR, "-fx-cursor");
+        add(EFFECT, "-fx-effect");
+        keyword("visibility", "visible", "hidden", "collapse");
+        keyword("-fx-border-style", "none", "solid", "dashed", "dotted");
+        keyword("-fx-orientation", "horizontal", "vertical");
+        keyword("-fx-text-alignment", "left", "center", "right", "justify");
+        keyword("-fx-content-display", "top", "right", "bottom", "left", "center", "graphic-only", "text-only");
+        keyword("-fx-hbar-policy", "never", "always", "as-needed");
+        keyword("-fx-vbar-policy", "never", "always", "as-needed");
+        keyword("-fx-stroke-line-cap", "square", "butt", "round");
+        keyword("-fx-stroke-line-join", "miter", "bevel", "round");
+        keyword("-fx-stroke-type", "inside", "outside", "centered");
+        keyword("-fx-text-origin", "baseline", "top", "center", "bottom");
+    }
+
+    private CssProperties() {
+    }
+
+    /// The colours the standard JavaFX themes define and look up, which a
+    /// style sheet redefines to recolour an application. They are
+    /// definitions like any `-name: colour`, and the only names starting
+    /// with `-fx-` that are.
+    private static final String[] THEME_COLOURS = {
+        "-fx-base", "-fx-background", "-fx-control-inner-background", "-fx-control-inner-background-alt",
+        "-fx-accent", "-fx-default-button", "-fx-focus-color", "-fx-faint-focus-color", "-fx-color",
+        "-fx-text-base-color", "-fx-text-background-color", "-fx-text-inner-color", "-fx-dark-text-color",
+        "-fx-mid-text-color", "-fx-light-text-color", "-fx-body-color", "-fx-outer-border", "-fx-inner-border",
+        "-fx-inner-border-horizontal", "-fx-inner-border-bottomup", "-fx-shadow-highlight-color",
+        "-fx-box-border", "-fx-text-box-border", "-fx-hover-base", "-fx-pressed-base", "-fx-selection-bar",
+        "-fx-selection-bar-non-focused", "-fx-selection-bar-text", "-fx-cell-hover-color", "-fx-mark-color",
+        "-fx-mark-highlight-color", "-fx-cell-focus-inner-border", "-fx-focused-text-base-color",
+        "-fx-focused-mark-color", "-fx-table-cell-border-color", "-fx-table-header-border-color",
+        "-fx-progress-color",
+    };
+
+    /// Whether a name that is not a property may define a looked-up
+    /// colour: it starts with `-` and is not a misspelt or unsupported
+    /// `-fx-` property.
+    public static boolean isDefinitionName(String property) {
+        if (property.length() < 2 || property.charAt(0) != '-') {
+            return false;
+        }
+        if (!property.startsWith("-fx-")) {
+            return true;
+        }
+        for (String known : THEME_COLOURS) {
+            if (known.equals(property)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void add(int kind, String... names) {
+        for (int i = 0; i < names.length; i++) {
+            KINDS.put(names[i], Integer.valueOf(kind));
+        }
+    }
+
+    private static void keyword(String name, String... words) {
+        KINDS.put(name, Integer.valueOf(KEYWORD));
+        KEYWORDS.put(name, words);
+    }
+
+    /// The kind of value `property` takes, or [#UNKNOWN]. The name is in
+    /// lower case, as a style sheet's names are once read.
+    public static int kind(String property) {
+        Integer k = KINDS.get(property);
+        return k == null ? UNKNOWN : k.intValue();
+    }
+
+    /// Whether `word`, in lower case, is one `property` accepts. Only for a
+    /// property of the kind [#KEYWORD].
+    public static boolean accepts(String property, String word) {
+        String[] words = KEYWORDS.get(property);
+        if (words == null) {
+            return false;
+        }
+        for (int i = 0; i < words.length; i++) {
+            if (words[i].equals(word)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Whether a value of `property` is written in layers, separated by
+    /// commas: the fills of a background and the strokes of a border, each
+    /// with its own colour, insets, radii, widths and style.
+    public static boolean isLayered(String property) {
+        return "-fx-background-color".equals(property) || "-fx-background-insets".equals(property)
+                || "-fx-background-radius".equals(property) || "-fx-border-color".equals(property)
+                || "-fx-border-width".equals(property) || "-fx-border-radius".equals(property)
+                || "-fx-border-insets".equals(property) || "-fx-border-style".equals(property);
+    }
+
+    /// Whether `property` is one of the five font names, which a node takes
+    /// together: a child inherits them, and withdrawing one restores the
+    /// whole font.
+    public static boolean isFont(String property) {
+        return property.startsWith("-fx-font");
+    }
+
+    /// `s` with the ASCII capitals folded to lower case, and nothing else
+    /// touched. A style sheet's names and keywords are ASCII by
+    /// specification, and the locale's own folding would turn an `I` into
+    /// a dotless one on a device set to Turkish.
+    public static String lower(String s) {
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                char[] out = s.toCharArray();
+                for (int j = i; j < n; j++) {
+                    char d = out[j];
+                    if (d >= 'A' && d <= 'Z') {
+                        out[j] = (char) (d + ('a' - 'A'));
+                    }
+                }
+                return new String(out);
+            }
+        }
+        return s;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssSelector.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssSelector.java
new file mode 100644
index 00000000000..329fa42a510
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssSelector.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+import java.util.ArrayList;
+
+/// One selector: a chain of compound selectors joined by descendant and
+/// child combinators, such as `.sidebar > Button.primary:hover`.
+///
+/// The compounds are held from the subject outwards: compound 0 is the
+/// rightmost one, the node the rule styles, and each further compound is an
+/// ancestor of the one before it. That is the order a matcher needs them
+/// in, since it starts at the node and walks up.
+///
+/// A compound is a type name or `*`, at most one id, and any number of
+/// style classes and pseudo-classes. Names are compared as written: JavaFX
+/// type selectors and style classes are case sensitive.
+public final class CssSelector {
+
+    /// The compound is anywhere above the one before it.
+    public static final byte DESCENDANT = 1;
+    /// The compound is the parent of the one before it.
+    public static final byte CHILD = 2;
+
+    private static final String[] NONE = new String[0];
+
+    private final String[] types;
+    private final String[] ids;
+    private final String[][] classes;
+    private final String[][] pseudos;
+    private final byte[] combinators;
+    private final int specificity;
+
+    /// Creates a selector from its compounds, subject first. `types[i]`
+    /// and `ids[i]` are `null` for a compound without one;
+    /// `combinators[i]` says how compound `i + 1` relates to compound `i`
+    /// and has one entry fewer than there are compounds. The arrays are
+    /// taken as they are.
+    public CssSelector(String[] types, String[] ids, String[][] classes, String[][] pseudos, byte[] combinators) {
+        this.types = types;
+        this.ids = ids;
+        this.classes = classes;
+        this.pseudos = pseudos;
+        this.combinators = combinators;
+        int a = 0;
+        int b = 0;
+        int c = 0;
+        for (int i = 0; i < types.length; i++) {
+            a += ids[i] == null ? 0 : 1;
+            b += classes[i].length + pseudos[i].length;
+            c += types[i] == null ? 0 : 1;
+        }
+        this.specificity = (Math.min(a, 255) << 16) | (Math.min(b, 255) << 8) | Math.min(c, 255);
+    }
+
+    /// How many compounds the selector has; at least one.
+    public int size() {
+        return types.length;
+    }
+
+    /// The type name of compound `i`, or `null` when it matches any type.
+    public String type(int i) {
+        return types[i];
+    }
+
+    /// The id of compound `i`, or `null`.
+    public String id(int i) {
+        return ids[i];
+    }
+
+    /// How many style classes compound `i` requires.
+    public int classCount(int i) {
+        return classes[i].length;
+    }
+
+    /// Style class `j` of compound `i`.
+    public String styleClass(int i, int j) {
+        return classes[i][j];
+    }
+
+    /// How many pseudo-classes compound `i` requires.
+    public int pseudoCount(int i) {
+        return pseudos[i].length;
+    }
+
+    /// Pseudo-class `j` of compound `i`.
+    public String pseudo(int i, int j) {
+        return pseudos[i][j];
+    }
+
+    /// How compound `i + 1` relates to compound `i`: [#DESCENDANT] or
+    /// [#CHILD].
+    public byte combinator(int i) {
+        return combinators[i];
+    }
+
+    /// The specificity as one number that orders selectors the way CSS
+    /// does: ids, then classes and pseudo-classes, then types.
+    public int specificity() {
+        return specificity;
+    }
+
+    /// Parses one selector -- no commas; a selector list is split by the
+    /// caller. Answers `null` for text that is not a selector this layer
+    /// supports.
+    public static CssSelector parse(String text) {
+        ArrayList<String> types = new ArrayList<String>();
+        ArrayList<String> ids = new ArrayList<String>();
+        ArrayList<String[]> classes = new ArrayList<String[]>();
+        ArrayList<String[]> pseudos = new ArrayList<String[]>();
+        ArrayList<Byte> combinators = new ArrayList<Byte>();
+        String s = text.trim();
+        int n = s.length();
+        int i = 0;
+        boolean first = true;
+        while (i < n) {
+            // What separates this compound from the one before it.
+            byte combinator = first ? 0 : DESCENDANT;
+            boolean space = false;
+            while (i < n && (CssValueParser.isSpace(s.charAt(i)) || s.charAt(i) == '>')) {
+                if (s.charAt(i) == '>') {
+                    if (first || combinator == CHILD) {
+                        return null;
+                    }
+                    combinator = CHILD;
+                } else {
+                    space = true;
+                }
+                i++;
+            }
+            if (i >= n) {
+                // A combinator with nothing after it.
+                return combinator == CHILD ? null : build(types, ids, classes, pseudos, combinators);
+            }
+            if (!first && combinator == DESCENDANT && !space) {
+                return null;
+            }
+            String type = null;
+            String id = null;
+            ArrayList<String> cls = new ArrayList<String>();
+            ArrayList<String> pse = new ArrayList<String>();
+            boolean any = false;
+            int start = i;
+            while (i < n && !CssValueParser.isSpace(s.charAt(i)) && s.charAt(i) != '>') {
+                char kind = s.charAt(i);
+                if (kind == '*') {
+                    if (i != start) {
+                        return null;
+                    }
+                    any = true;
+                    i++;
+                    continue;
+                }
+                int from = kind == '#' || kind == '.' || kind == ':' ? i + 1 : i;
+                int end = from;
+                while (end < n && isNameChar(s.charAt(end))) {
+                    end++;
+                }
+                if (end == from) {
+                    return null;
+                }
+                String name = s.substring(from, end);
+                if (kind == '#') {
+                    if (id != null) {
+                        return null;
+                    }
+                    id = name;
+                } else if (kind == '.') {
+                    cls.add(name);
+                } else if (kind == ':') {
+                    pse.add(name);
+                } else {
+                    if (i != start || any) {
+                        return null;
+                    }
+                    type = name;
+                }
+                i = end;
+            }
+            if (!first) {
+                combinators.add(Byte.valueOf(combinator));
+            }
+            types.add(type);
+            ids.add(id);
+            classes.add(cls.toArray(NONE));
+            pseudos.add(pse.toArray(NONE));
+            first = false;
+        }
+        return build(types, ids, classes, pseudos, combinators);
+    }
+
+    private static boolean isNameChar(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_'
+                || c > 127;
+    }
+
+    /// Reverses what was read left to right into subject-first order.
+    private static CssSelector build(ArrayList<String> types, ArrayList<String> ids, ArrayList<String[]> classes,
+            ArrayList<String[]> pseudos, ArrayList<Byte> combinators) {
+        int n = types.size();
+        if (n == 0) {
+            return null;
+        }
+        String[] t = new String[n];
+        String[] d = new String[n];
+        String[][] c = new String[n][];
+        String[][] p = new String[n][];
+        byte[] k = new byte[n - 1];
+        for (int i = 0; i < n; i++) {
+            int src = n - 1 - i;
+            t[i] = types.get(src);
+            d[i] = ids.get(src);
+            c[i] = classes.get(src);
+            p[i] = pseudos.get(src);
+            if (i < n - 1) {
+                // Written between compound src - 1 and src.
+                k[i] = combinators.get(src - 1).byteValue();
+            }
+        }
+        return new CssSelector(t, d, c, p, k);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder();
+        for (int i = types.length - 1; i >= 0; i--) {
+            s.append(types[i] == null ? "" : types[i]);
+            if (ids[i] != null) {
+                s.append('#').append(ids[i]);
+            }
+            for (int j = 0; j < classes[i].length; j++) {
+                s.append('.').append(classes[i][j]);
+            }
+            for (int j = 0; j < pseudos[i].length; j++) {
+                s.append(':').append(pseudos[i][j]);
+            }
+            if (types[i] == null && ids[i] == null && classes[i].length == 0 && pseudos[i].length == 0) {
+                s.append('*');
+            }
+            if (i > 0) {
+                s.append(combinators[i - 1] == CHILD ? " > " : " ");
+            }
+        }
+        return s.toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssSheetData.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssSheetData.java
new file mode 100644
index 00000000000..37414d1ad34
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssSheetData.java
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// A compiled style sheet: what the build writes for every `.css` file of
+/// an application and the device reads in its place. Both directions are
+/// here, in one class, so that the two cannot drift apart.
+///
+/// #### What it holds
+///
+/// - the sheets it imports, as resource paths, in the order written;
+/// - its `@font-face` rules, as a family and the resource path of a font;
+/// - its rules, in the order written: a selector and the number of the
+///   declaration block it belongs to. A rule with a list of selectors
+///   (`a, b { ... }`) is one entry per selector, all naming one block, so a
+///   block is stored once.
+///
+/// #### The file
+///
+/// Big endian, as `DataOutputStream` writes: the magic number `CNFS`, a
+/// format version byte, a table of every string in the sheet, then the
+/// imports, the font faces, the declaration blocks and the rules, each as a
+/// count followed by its entries, with every string given as its number in
+/// the table. The format is private to one build of this layer -- the
+/// reader and the writer always ship together -- so the version only
+/// guards against a stale file, which is rejected rather than misread.
+///
+/// A sheet ships under the name [#compiledName(String)] gives its path.
+public final class CssSheetData {
+
+    /// What follows the flat name of a style sheet in the name its compiled
+    /// form ships under: `styles/app.css` is flattened to `styles__app.css`
+    /// like any resource and its compiled form is `styles__app.css.cn1css`,
+    /// at the root of the application bundle.
+    public static final String SUFFIX = ".cn1css";
+
+    private static final int MAGIC = 0x434E4653;
+    private static final int VERSION = 1;
+
+    private final String[] imports;
+    private final String[] fontFamilies;
+    private final String[] fontSources;
+    private final CssSelector[] selectors;
+    private final int[] selectorBlocks;
+    private final CssDeclaration[][] blocks;
+
+    /// Creates a sheet. `selectorBlocks[i]` is the index in `blocks` of the
+    /// declarations `selectors[i]` belongs to; `fontSources[i]` is the font
+    /// of `fontFamilies[i]`. The arrays are taken as they are.
+    public CssSheetData(String[] imports, String[] fontFamilies, String[] fontSources, CssSelector[] selectors,
+            int[] selectorBlocks, CssDeclaration[][] blocks) {
+        this.imports = imports;
+        this.fontFamilies = fontFamilies;
+        this.fontSources = fontSources;
+        this.selectors = selectors;
+        this.selectorBlocks = selectorBlocks;
+        this.blocks = blocks;
+    }
+
+    /// The name the compiled form of the style sheet at `flatName` -- the
+    /// name `com.codename1.impl.compat.ResourceNames.flatName` gives its
+    /// resource path -- ships under.
+    public static String compiledName(String flatName) {
+        return flatName + SUFFIX;
+    }
+
+    /// How many sheets this one imports.
+    public int importCount() {
+        return imports.length;
+    }
+
+    /// The resource path, without a leading slash, of import `i`.
+    public String importPath(int i) {
+        return imports[i];
+    }
+
+    /// How many `@font-face` rules the sheet has.
+    public int fontCount() {
+        return fontFamilies.length;
+    }
+
+    /// The family font `i` is declared as.
+    public String fontFamily(int i) {
+        return fontFamilies[i];
+    }
+
+    /// The resource path, without a leading slash, of font `i`.
+    public String fontSource(int i) {
+        return fontSources[i];
+    }
+
+    /// How many selectors the sheet has; a rule counts once per selector.
+    public int ruleCount() {
+        return selectors.length;
+    }
+
+    /// Selector `i`, in the order written.
+    public CssSelector selector(int i) {
+        return selectors[i];
+    }
+
+    /// The index of the declaration block selector `i` belongs to.
+    public int blockOf(int i) {
+        return selectorBlocks[i];
+    }
+
+    /// How many declaration blocks the sheet has.
+    public int blockCount() {
+        return blocks.length;
+    }
+
+    /// How many declarations block `block` has.
+    public int declarationCount(int block) {
+        return blocks[block].length;
+    }
+
+    /// Declaration `i` of block `block`.
+    public CssDeclaration declaration(int block, int i) {
+        return blocks[block][i];
+    }
+
+    // --------------------------------------------------------------- writing
+
+    private static final class Strings {
+        final HashMap<String, Integer> index = new HashMap<String, Integer>();
+        final ArrayList<String> list = new ArrayList<String>();
+
+        int of(String s) {
+            if (s == null) {
+                return 0;
+            }
+            Integer at = index.get(s);
+            if (at == null) {
+                list.add(s);
+                at = Integer.valueOf(list.size());
+                index.put(s, at);
+            }
+            return at.intValue();
+        }
+    }
+
+    /// Writes the sheet. The stream is flushed, not closed.
+    public void write(OutputStream to) throws IOException {
+        Strings strings = new Strings();
+        for (int i = 0; i < imports.length; i++) {
+            strings.of(imports[i]);
+        }
+        for (int i = 0; i < fontFamilies.length; i++) {
+            strings.of(fontFamilies[i]);
+            strings.of(fontSources[i]);
+        }
+        for (int b = 0; b < blocks.length; b++) {
+            for (int i = 0; i < blocks[b].length; i++) {
+                strings.of(blocks[b][i].name());
+                collect(blocks[b][i].value(), strings);
+            }
+        }
+        for (int i = 0; i < selectors.length; i++) {
+            CssSelector s = selectors[i];
+            for (int c = 0; c < s.size(); c++) {
+                strings.of(s.type(c));
+                strings.of(s.id(c));
+                for (int j = 0; j < s.classCount(c); j++) {
+                    strings.of(s.styleClass(c, j));
+                }
+                for (int j = 0; j < s.pseudoCount(c); j++) {
+                    strings.of(s.pseudo(c, j));
+                }
+            }
+        }
+        DataOutputStream out = new DataOutputStream(to);
+        out.writeInt(MAGIC);
+        out.writeByte(VERSION);
+        out.writeInt(strings.list.size());
+        for (int i = 0; i < strings.list.size(); i++) {
+            out.writeUTF(strings.list.get(i));
+        }
+        out.writeInt(imports.length);
+        for (int i = 0; i < imports.length; i++) {
+            out.writeInt(strings.of(imports[i]));
+        }
+        out.writeInt(fontFamilies.length);
+        for (int i = 0; i < fontFamilies.length; i++) {
+            out.writeInt(strings.of(fontFamilies[i]));
+            out.writeInt(strings.of(fontSources[i]));
+        }
+        out.writeInt(blocks.length);
+        for (int b = 0; b < blocks.length; b++) {
+            out.writeInt(blocks[b].length);
+            for (int i = 0; i < blocks[b].length; i++) {
+                CssDeclaration d = blocks[b][i];
+                out.writeInt(strings.of(d.name()));
+                out.writeByte(d.kind());
+                out.writeBoolean(d.important());
+                write(d.value(), out, strings);
+            }
+        }
+        out.writeInt(selectors.length);
+        for (int i = 0; i < selectors.length; i++) {
+            CssSelector s = selectors[i];
+            out.writeInt(selectorBlocks[i]);
+            out.writeByte(s.size());
+            for (int c = 0; c < s.size(); c++) {
+                out.writeByte(c == 0 ? 0 : s.combinator(c - 1));
+                out.writeInt(strings.of(s.type(c)));
+                out.writeInt(strings.of(s.id(c)));
+                out.writeByte(s.classCount(c));
+                for (int j = 0; j < s.classCount(c); j++) {
+                    out.writeInt(strings.of(s.styleClass(c, j)));
+                }
+                out.writeByte(s.pseudoCount(c));
+                for (int j = 0; j < s.pseudoCount(c); j++) {
+                    out.writeInt(strings.of(s.pseudo(c, j)));
+                }
+            }
+        }
+        out.flush();
+    }
+
+    private static void collect(CssValue v, Strings strings) {
+        strings.of(v.text());
+        for (int i = 0; i < v.partCount(); i++) {
+            if (v.part(i) != null) {
+                collect(v.part(i), strings);
+            }
+        }
+    }
+
+    private static void write(CssValue v, DataOutputStream out, Strings strings) throws IOException {
+        out.writeByte(v.type());
+        out.writeInt(v.flags());
+        out.writeByte(v.count());
+        boolean units = false;
+        for (int i = 0; i < v.count(); i++) {
+            out.writeDouble(v.num(i));
+            units |= v.unit(i) != CssValue.UNIT_NONE;
+        }
+        out.writeBoolean(units);
+        if (units) {
+            for (int i = 0; i < v.count(); i++) {
+                out.writeByte(v.unit(i));
+            }
+        }
+        out.writeInt(strings.of(v.text()));
+        out.writeByte(v.partCount());
+        for (int i = 0; i < v.partCount(); i++) {
+            out.writeBoolean(v.part(i) != null);
+            if (v.part(i) != null) {
+                write(v.part(i), out, strings);
+            }
+        }
+    }
+
+    // --------------------------------------------------------------- reading
+
+    /// Reads a sheet [#write(OutputStream)] wrote. Fails with an
+    /// `IOException` for anything else, a file of another format version
+    /// included. The stream is not closed.
+    public static CssSheetData read(InputStream from) throws IOException {
+        DataInputStream in = new DataInputStream(from);
+        if (in.readInt() != MAGIC) {
+            throw new IOException("Not a compiled style sheet");
+        }
+        int version = in.readUnsignedByte();
+        if (version != VERSION) {
+            throw new IOException("Compiled style sheet of format " + version + ", expected " + VERSION
+                    + "; rebuild the application");
+        }
+        String[] strings = new String[count(in) + 1];
+        for (int i = 1; i < strings.length; i++) {
+            strings[i] = in.readUTF();
+        }
+        String[] imports = new String[count(in)];
+        for (int i = 0; i < imports.length; i++) {
+            imports[i] = string(in, strings);
+        }
+        int fonts = count(in);
+        String[] families = new String[fonts];
+        String[] sources = new String[fonts];
+        for (int i = 0; i < fonts; i++) {
+            families[i] = string(in, strings);
+            sources[i] = string(in, strings);
+        }
+        CssDeclaration[][] blocks = new CssDeclaration[count(in)][];
+        for (int b = 0; b < blocks.length; b++) {
+            blocks[b] = new CssDeclaration[count(in)];
+            for (int i = 0; i < blocks[b].length; i++) {
+                String name = string(in, strings);
+                int kind = in.readUnsignedByte();
+                boolean important = in.readBoolean();
+                blocks[b][i] = new CssDeclaration(name, kind, value(in, strings, 0), important);
+            }
+        }
+        int rules = count(in);
+        CssSelector[] selectors = new CssSelector[rules];
+        int[] selectorBlocks = new int[rules];
+        for (int i = 0; i < rules; i++) {
+            selectorBlocks[i] = in.readInt();
+            if (selectorBlocks[i] < 0 || selectorBlocks[i] >= blocks.length) {
+                throw new IOException("Corrupt compiled style sheet");
+            }
+            int size = in.readUnsignedByte();
+            String[] types = new String[size];
+            String[] ids = new String[size];
+            String[][] classes = new String[size][];
+            String[][] pseudos = new String[size][];
+            byte[] combinators = new byte[Math.max(0, size - 1)];
+            for (int c = 0; c < size; c++) {
+                byte combinator = in.readByte();
+                if (c > 0) {
+                    combinators[c - 1] = combinator;
+                }
+                types[c] = string(in, strings);
+                ids[c] = string(in, strings);
+                classes[c] = new String[in.readUnsignedByte()];
+                for (int j = 0; j < classes[c].length; j++) {
+                    classes[c][j] = string(in, strings);
+                }
+                pseudos[c] = new String[in.readUnsignedByte()];
+                for (int j = 0; j < pseudos[c].length; j++) {
+                    pseudos[c][j] = string(in, strings);
+                }
+            }
+            selectors[i] = new CssSelector(types, ids, classes, pseudos, combinators);
+        }
+        return new CssSheetData(imports, families, sources, selectors, selectorBlocks, blocks);
+    }
+
+    /// A count, which a truncated or foreign file could make absurd.
+    private static int count(DataInputStream in) throws IOException {
+        int n = in.readInt();
+        if (n < 0 || n > 1000000) {
+            throw new IOException("Corrupt compiled style sheet");
+        }
+        return n;
+    }
+
+    private static String string(DataInputStream in, String[] strings) throws IOException {
+        int at = in.readInt();
+        if (at < 0 || at >= strings.length) {
+            throw new IOException("Corrupt compiled style sheet");
+        }
+        return strings[at];
+    }
+
+    private static CssValue value(DataInputStream in, String[] strings, int depth) throws IOException {
+        if (depth > 16) {
+            throw new IOException("Corrupt compiled style sheet");
+        }
+        int type = in.readUnsignedByte();
+        int flags = in.readInt();
+        double[] nums = new double[in.readUnsignedByte()];
+        for (int i = 0; i < nums.length; i++) {
+            nums[i] = in.readDouble();
+        }
+        byte[] units = null;
+        if (in.readBoolean()) {
+            units = new byte[nums.length];
+            for (int i = 0; i < units.length; i++) {
+                units[i] = in.readByte();
+            }
+        }
+        String text = string(in, strings);
+        CssValue[] parts = new CssValue[in.readUnsignedByte()];
+        for (int i = 0; i < parts.length; i++) {
+            if (in.readBoolean()) {
+                parts[i] = value(in, strings, depth + 1);
+            }
+        }
+        return new CssValue(type, flags, nums, units, text, parts);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssValue.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssValue.java
new file mode 100644
index 00000000000..7c9b619f250
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssValue.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+/// One parsed style value, in the form both the build and the device hold
+/// it: numbers, strings and nested values, nothing that needs a scene graph
+/// class. The build writes it into a compiled style sheet; the device reads
+/// it back, or gets it straight from [CssValueParser] for an inline style,
+/// and turns it into the object a node takes only when a node is styled --
+/// that is when an `em` length has a font size to be relative to and a
+/// looked-up colour has a cascade to be looked up in.
+///
+/// #### The types
+///
+/// - [#NUMBER]: `nums[0]` with the unit `units[0]`.
+/// - [#SIZES]: one to four numbers, each with its unit: insets or radii as
+///   written, before the CSS rule for missing sides is applied.
+/// - [#COLOR]: `flags` holds the colour as `0xAARRGGBB`.
+/// - [#LOOKUP]: `text` names a colour some rule defines.
+/// - [#DERIVE]: `parts[0]` is a colour, `nums[0]` the brightness change in
+///   percent.
+/// - [#LINEAR]: `nums` holds start x, start y, end x, end y, then one
+///   offset per stop (a fraction, or `NaN` for a stop without one);
+///   `parts` holds the colour of each stop; `flags` is [#FLAG_PROPORTIONAL]
+///   and the cycle method.
+/// - [#RADIAL]: `nums` holds focus angle, focus distance, centre x, centre
+///   y, radius, then the stop offsets; otherwise as [#LINEAR].
+/// - [#STRING]: `text`, case kept.
+/// - [#KEYWORD]: `text`, folded to lower case.
+/// - [#BOOLEAN]: `flags` is 1 for true.
+/// - [#FONT]: the `-fx-font` shorthand. `text` is the family, `nums[0]`
+///   the size with `units[0]`, `flags` the weight (0 when not given) in
+///   the low 16 bits and above them 1 for an upright and 2 for an italic
+///   posture.
+/// - [#URL]: `text` is the address as written.
+/// - [#EFFECT]: `-fx-effect`. The low four bits of `flags` are
+///   [#EFFECT_DROP] or [#EFFECT_INNER] (0 for `none`), the bits above them
+///   the number of box passes of the blur; `nums` holds the radius, the
+///   spread or choke as a fraction, and the x and y offsets; `parts[0]` is
+///   the colour.
+/// - [#LIST]: `parts` holds one value per layer, in the order written,
+///   each of the type the property takes for a single layer.
+/// - [#SIDES]: `parts` holds the paints of the top, right, bottom and left
+///   side.
+/// - [#LADDER]: `parts[0]` is the colour whose brightness picks, the
+///   further parts the colours of the stops; `nums` holds one offset per
+///   stop, as [#LINEAR] does from its fifth number on.
+///
+/// A value is immutable; the arrays are never changed after construction.
+public final class CssValue {
+
+    /// A number, with a unit.
+    public static final int NUMBER = 1;
+    /// One to four numbers.
+    public static final int SIZES = 2;
+    /// A colour.
+    public static final int COLOR = 3;
+    /// The name of a colour defined by a rule.
+    public static final int LOOKUP = 4;
+    /// A colour made brighter or darker.
+    public static final int DERIVE = 5;
+    /// A linear gradient.
+    public static final int LINEAR = 6;
+    /// A radial gradient.
+    public static final int RADIAL = 7;
+    /// Text.
+    public static final int STRING = 8;
+    /// A keyword.
+    public static final int KEYWORD = 9;
+    /// A flag.
+    public static final int BOOLEAN = 10;
+    /// The font shorthand.
+    public static final int FONT = 11;
+    /// An address.
+    public static final int URL = 12;
+    /// A shadow effect.
+    public static final int EFFECT = 13;
+    /// The layers of a background or a border.
+    public static final int LIST = 14;
+    /// A paint for each side of a border.
+    public static final int SIDES = 15;
+    /// A colour picked from a row of stops by the brightness of another.
+    public static final int LADDER = 16;
+
+    /// The `flags` of an [#EFFECT] that is `dropshadow()`.
+    public static final int EFFECT_DROP = 1;
+    /// The `flags` of an [#EFFECT] that is `innershadow()`.
+    public static final int EFFECT_INNER = 2;
+
+    /// No unit: a plain number, or an angle in degrees.
+    public static final byte UNIT_NONE = 0;
+    /// Logical pixels; every absolute unit is converted to it when parsed.
+    public static final byte UNIT_PX = 1;
+    /// Relative to the font size of the node.
+    public static final byte UNIT_EM = 2;
+    /// A percentage, kept as written (`50` for `50%`).
+    public static final byte UNIT_PERCENT = 3;
+
+    /// Set in the `flags` of a gradient whose geometry is relative to the
+    /// shape it fills.
+    public static final int FLAG_PROPORTIONAL = 1;
+    /// Set in the `flags` of a gradient that reflects.
+    public static final int FLAG_REFLECT = 2;
+    /// Set in the `flags` of a gradient that repeats.
+    public static final int FLAG_REPEAT = 4;
+
+    private static final double[] NO_NUMS = new double[0];
+    private static final byte[] NO_UNITS = new byte[0];
+    private static final CssValue[] NO_PARTS = new CssValue[0];
+
+    private final int type;
+    private final int flags;
+    private final double[] nums;
+    private final byte[] units;
+    private final String text;
+    private final CssValue[] parts;
+    private final boolean contextual;
+
+    /// Creates a value from all of its fields; `null` arrays stand for empty
+    /// ones. The arrays are taken as they are: the caller gives them up.
+    public CssValue(int type, int flags, double[] nums, byte[] units, String text, CssValue[] parts) {
+        this.type = type;
+        this.flags = flags;
+        this.nums = nums == null ? NO_NUMS : nums;
+        boolean anyUnit = false;
+        for (int i = 0; units != null && i < units.length; i++) {
+            anyUnit |= units[i] != UNIT_NONE;
+        }
+        // No array at all for numbers without units, so that a value read
+        // back from a compiled sheet equals the one that was written.
+        this.units = anyUnit ? units : NO_UNITS;
+        this.text = text;
+        this.parts = parts == null ? NO_PARTS : parts;
+        boolean ctx = type == LOOKUP;
+        for (int i = 0; i < this.units.length; i++) {
+            ctx |= this.units[i] == UNIT_EM;
+        }
+        if (type == FONT || type == NUMBER) {
+            // A percentage font size is relative to the inherited size.
+            ctx |= this.units.length > 0 && this.units[0] == UNIT_PERCENT;
+        }
+        for (int i = 0; i < this.parts.length; i++) {
+            ctx |= this.parts[i] != null && this.parts[i].contextual;
+        }
+        this.contextual = ctx;
+    }
+
+    /// A number with a unit.
+    public static CssValue number(double value, byte unit) {
+        return new CssValue(NUMBER, 0, new double[] {value}, new byte[] {unit}, null, null);
+    }
+
+    /// A colour from `0xAARRGGBB`.
+    public static CssValue color(int argb) {
+        return new CssValue(COLOR, argb, null, null, null, null);
+    }
+
+    /// A value that is only text: [#STRING], [#KEYWORD], [#LOOKUP] or
+    /// [#URL].
+    public static CssValue text(int type, String text) {
+        return new CssValue(type, 0, null, null, text, null);
+    }
+
+    /// A flag.
+    public static CssValue bool(boolean value) {
+        return new CssValue(BOOLEAN, value ? 1 : 0, null, null, null, null);
+    }
+
+    /// The type, one of the constants of this class.
+    public int type() {
+        return type;
+    }
+
+    /// The colour, flag, or gradient and font bits; see the class
+    /// description.
+    public int flags() {
+        return flags;
+    }
+
+    /// How many numbers the value holds.
+    public int count() {
+        return nums.length;
+    }
+
+    /// The number at `index`.
+    public double num(int index) {
+        return nums[index];
+    }
+
+    /// The unit of the number at `index`, [#UNIT_NONE] where the type keeps
+    /// none.
+    public byte unit(int index) {
+        return index < units.length ? units[index] : UNIT_NONE;
+    }
+
+    /// The text, or `null` for a type without any.
+    public String text() {
+        return text;
+    }
+
+    /// How many nested values the value holds.
+    public int partCount() {
+        return parts.length;
+    }
+
+    /// The nested value at `index`.
+    public CssValue part(int index) {
+        return parts[index];
+    }
+
+    /// Whether what this value stands for depends on the node it styles:
+    /// it has an `em` length, a percentage of the inherited font size, or
+    /// names a looked-up colour. Any other value becomes the same object
+    /// for every node, and that object can be kept.
+    public boolean isContextual() {
+        return contextual;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof CssValue)) {
+            return false;
+        }
+        CssValue v = (CssValue) o;
+        if (type != v.type || flags != v.flags || nums.length != v.nums.length || units.length != v.units.length
+                || parts.length != v.parts.length || !(text == null ? v.text == null : text.equals(v.text))) {
+            return false;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (Double.doubleToLongBits(nums[i]) != Double.doubleToLongBits(v.nums[i])) {
+                return false;
+            }
+        }
+        for (int i = 0; i < units.length; i++) {
+            if (units[i] != v.units[i]) {
+                return false;
+            }
+        }
+        for (int i = 0; i < parts.length; i++) {
+            if (parts[i] == null ? v.parts[i] != null : !parts[i].equals(v.parts[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int h = type * 31 + flags;
+        for (int i = 0; i < nums.length; i++) {
+            long bits = Double.doubleToLongBits(nums[i]);
+            h = h * 31 + (int) (bits ^ (bits >>> 32));
+        }
+        if (text != null) {
+            h = h * 31 + text.hashCode();
+        }
+        for (int i = 0; i < parts.length; i++) {
+            h = h * 31 + (parts[i] == null ? 0 : parts[i].hashCode());
+        }
+        return h;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder();
+        s.append("CssValue[").append(type);
+        if (flags != 0) {
+            s.append(" 0x").append(Integer.toHexString(flags));
+        }
+        for (int i = 0; i < nums.length; i++) {
+            s.append(' ').append(nums[i]);
+            if (i < units.length && units[i] != UNIT_NONE) {
+                s.append(units[i] == UNIT_PX ? "px" : units[i] == UNIT_EM ? "em" : "%");
+            }
+        }
+        if (text != null) {
+            s.append(" '").append(text).append('\'');
+        }
+        for (int i = 0; i < parts.length; i++) {
+            s.append(' ').append(parts[i]);
+        }
+        return s.append(']').toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssValueParser.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssValueParser.java
new file mode 100644
index 00000000000..db2d472b23d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/CssValueParser.java
@@ -0,0 +1,1212 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat.runtime.css;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/// Reads the value of one style declaration into a [CssValue].
+///
+/// The build uses it for every declaration of a style sheet, and the device
+/// for the declarations of an inline `style` string, which is the one piece
+/// of CSS that only exists at run time. One parser for both is what keeps
+/// `-fx-padding: 1em 4` meaning the same thing in a style sheet and in
+/// `setStyle`. It therefore uses nothing a device lacks: no regular
+/// expressions, no formatting, no locale sensitive case folding.
+///
+/// #### The grammar, by kind of property
+///
+/// - paint: `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, a colour name,
+///   `transparent`, `rgb()`, `rgba()`, `hsb()`, `hsba()`, `hsl()`,
+///   `hsla()`, `derive(colour, n%)`, `linear-gradient(...)`,
+///   `radial-gradient(...)`, `ladder(colour, stops)`, or the name of a
+///   looked-up colour. A border colour is one to four paints, one per
+///   side.
+/// - length: a number with `px`, `pt`, `pc`, `in`, `cm`, `mm`, `em`, `ex`
+///   or no unit (pixels).
+/// - insets and radii: one to four lengths; radii also take percentages.
+/// - font: `[italic] [bold | 100..900] size family`.
+/// - flags, keywords, alignments and cursors: the word.
+///
+/// A value in several layers (`-fx-background-color: a, b`) is a
+/// [CssValue#LIST] for the properties of a background and a border, see
+/// [CssProperties#isLayered(String)]. A border style is read for its line
+/// only -- `segments()` as a dashed line -- and its placement, join and
+/// cap are left out. Anywhere else a list has only its last value kept,
+/// which is reported through [#warning()], not as a failure.
+///
+/// An instance is not shared between threads; it holds the outcome of the
+/// last call.
+public final class CssValueParser {
+
+    private static final HashMap<String, Integer> NAMED = new HashMap<String, Integer>();
+
+    private static final String NAMES = "aliceblue=f0f8ff antiquewhite=faebd7 aqua=00ffff aquamarine=7fffd4 "
+            + "azure=f0ffff beige=f5f5dc bisque=ffe4c4 black=000000 blanchedalmond=ffebcd blue=0000ff "
+            + "blueviolet=8a2be2 brown=a52a2a burlywood=deb887 cadetblue=5f9ea0 chartreuse=7fff00 "
+            + "chocolate=d2691e coral=ff7f50 cornflowerblue=6495ed cornsilk=fff8dc crimson=dc143c cyan=00ffff "
+            + "darkblue=00008b darkcyan=008b8b darkgoldenrod=b8860b darkgray=a9a9a9 darkgreen=006400 "
+            + "darkgrey=a9a9a9 darkkhaki=bdb76b darkmagenta=8b008b darkolivegreen=556b2f darkorange=ff8c00 "
+            + "darkorchid=9932cc darkred=8b0000 darksalmon=e9967a darkseagreen=8fbc8f darkslateblue=483d8b "
+            + "darkslategray=2f4f4f darkslategrey=2f4f4f darkturquoise=00ced1 darkviolet=9400d3 "
+            + "deeppink=ff1493 deepskyblue=00bfff dimgray=696969 dimgrey=696969 dodgerblue=1e90ff "
+            + "firebrick=b22222 floralwhite=fffaf0 forestgreen=228b22 fuchsia=ff00ff gainsboro=dcdcdc "
+            + "ghostwhite=f8f8ff gold=ffd700 goldenrod=daa520 gray=808080 green=008000 greenyellow=adff2f "
+            + "grey=808080 honeydew=f0fff0 hotpink=ff69b4 indianred=cd5c5c indigo=4b0082 ivory=fffff0 "
+            + "khaki=f0e68c lavender=e6e6fa lavenderblush=fff0f5 lawngreen=7cfc00 lemonchiffon=fffacd "
+            + "lightblue=add8e6 lightcoral=f08080 lightcyan=e0ffff lightgoldenrodyellow=fafad2 "
+            + "lightgray=d3d3d3 lightgreen=90ee90 lightgrey=d3d3d3 lightpink=ffb6c1 lightsalmon=ffa07a "
+            + "lightseagreen=20b2aa lightskyblue=87cefa lightslategray=778899 lightslategrey=778899 "
+            + "lightsteelblue=b0c4de lightyellow=ffffe0 lime=00ff00 limegreen=32cd32 linen=faf0e6 "
+            + "magenta=ff00ff maroon=800000 mediumaquamarine=66cdaa mediumblue=0000cd mediumorchid=ba55d3 "
+            + "mediumpurple=9370db mediumseagreen=3cb371 mediumslateblue=7b68ee mediumspringgreen=00fa9a "
+            + "mediumturquoise=48d1cc mediumvioletred=c71585 midnightblue=191970 mintcream=f5fffa "
+            + "mistyrose=ffe4e1 moccasin=ffe4b5 navajowhite=ffdead navy=000080 oldlace=fdf5e6 olive=808000 "
+            + "olivedrab=6b8e23 orange=ffa500 orangered=ff4500 orchid=da70d6 palegoldenrod=eee8aa "
+            + "palegreen=98fb98 paleturquoise=afeeee palevioletred=db7093 papayawhip=ffefd5 peachpuff=ffdab9 "
+            + "peru=cd853f pink=ffc0cb plum=dda0dd powderblue=b0e0e6 purple=800080 red=ff0000 "
+            + "rosybrown=bc8f8f royalblue=4169e1 saddlebrown=8b4513 salmon=fa8072 sandybrown=f4a460 "
+            + "seagreen=2e8b57 seashell=fff5ee sienna=a0522d silver=c0c0c0 skyblue=87ceeb slateblue=6a5acd "
+            + "slategray=708090 slategrey=708090 snow=fffafa springgreen=00ff7f steelblue=4682b4 tan=d2b48c "
+            + "teal=008080 thistle=d8bfd8 tomato=ff6347 turquoise=40e0d0 violet=ee82ee wheat=f5deb3 "
+            + "white=ffffff whitesmoke=f5f5f5 yellow=ffff00 yellowgreen=9acd32";
+
+    private static final String[] POSITIONS = {
+        "top-left", "top-center", "top-right", "center-left", "center", "center-right", "bottom-left",
+        "bottom-center", "bottom-right", "baseline-left", "baseline-center", "baseline-right",
+    };
+
+    private static final String[] WEIGHTS = {
+        "normal", "bold", "bolder", "lighter", "thin", "extra-light", "ultra-light", "light", "medium", "semi-bold",
+        "demi-bold", "extra-bold", "ultra-bold", "black", "heavy",
+    };
+
+    private static final String[] SIZE_WORDS = {
+        "xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large", "smaller", "larger",
+    };
+
+    private static final double[] SIZE_FACTORS = {0.6, 0.75, 0.89, 1, 1.2, 1.5, 2, 0.83, 1.2};
+
+    static {
+        int i = 0;
+        int n = NAMES.length();
+        while (i < n) {
+            int eq = NAMES.indexOf('=', i);
+            int end = NAMES.indexOf(' ', eq);
+            if (end < 0) {
+                end = n;
+            }
+            NAMED.put(NAMES.substring(i, eq), Integer.valueOf(0xff000000 | hexInt(NAMES, eq + 1, end)));
+            i = end + 1;
+        }
+    }
+
+    private String error;
+    private String warning;
+    private String base;
+
+    /// Says where the text being parsed is: the directory of its style
+    /// sheet among the resources of the application, ending in a slash,
+    /// or an empty string for the root. An address written in a value is
+    /// then read from there, and kept as a path from the root. `null`,
+    /// which a parser starts with, keeps an address as it was written.
+    public void setBase(String directory) {
+        base = directory;
+    }
+
+    /// The addresses of a value, each `url(...)` of it, made whole.
+    private String rebased(String value) {
+        if (base == null) {
+            return value;
+        }
+        StringBuilder out = new StringBuilder();
+        int at = 0;
+        while (true) {
+            int open = -1;
+            for (int i = at; i + 4 <= value.length(); i++) {
+                if (value.regionMatches(true, i, "url(", 0, 4)) {
+                    open = i;
+                    break;
+                }
+            }
+            int close = open < 0 ? -1 : value.indexOf(')', open);
+            if (close < 0) {
+                out.append(value.substring(at));
+                return out.toString();
+            }
+            String address = unquote(value.substring(open + 4, close).trim());
+            out.append(value.substring(at, open)).append("url(\"").append(whole(address)).append("\")");
+            at = close + 1;
+        }
+    }
+
+    /// An address as a path from the root of the resources; one with a
+    /// scheme, or already from the root, is kept.
+    private String whole(String address) {
+        if (address.indexOf(':') >= 0 || address.startsWith("/")) {
+            return address;
+        }
+        String path = base + address;
+        ArrayList<String> kept = new ArrayList<String>();
+        int start = 0;
+        while (start <= path.length()) {
+            int slash = path.indexOf('/', start);
+            String part = path.substring(start, slash < 0 ? path.length() : slash);
+            if ("..".equals(part)) {
+                if (!kept.isEmpty()) {
+                    kept.remove(kept.size() - 1);
+                }
+            } else if (part.length() > 0 && !".".equals(part)) {
+                kept.add(part);
+            }
+            if (slash < 0) {
+                break;
+            }
+            start = slash + 1;
+        }
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < kept.size(); i++) {
+            out.append('/').append(kept.get(i));
+        }
+        return out.toString();
+    }
+
+    /// Creates a parser.
+    public CssValueParser() {
+        // Nothing to set up: the state is the outcome of a call.
+    }
+
+    /// Why the last [#parse(String, String)] answered `null`.
+    public String error() {
+        return error;
+    }
+
+    /// What the last successful [#parse(String, String)] left out of the
+    /// value it answered, or `null` when it kept everything.
+    public String warning() {
+        return warning;
+    }
+
+    /// The kind [#parse(String, String)] reads a value of `property` as:
+    /// its kind in [CssProperties], or [CssProperties#LOOKUP_DEFINITION]
+    /// for a name the table does not have.
+    public static int kindOf(String property) {
+        int kind = CssProperties.kind(property);
+        return kind == CssProperties.UNKNOWN ? CssProperties.LOOKUP_DEFINITION : kind;
+    }
+
+    /// Reads `text` as a value of `property`, whose name is in lower case.
+    /// Answers `null` when the text is not a value of that property, with
+    /// the reason in [#error()].
+    public CssValue parse(String property, String text) {
+        error = null;
+        warning = null;
+        int kind = kindOf(property);
+        String value = text == null ? "" : text.trim();
+        if (value.length() == 0) {
+            return fail("the value is empty");
+        }
+        List<String> layers = split(value, ',');
+        if (layers == null) {
+            return fail("unbalanced parentheses or quotes");
+        }
+        if (kind == CssProperties.RAW) {
+            return CssValue.text(CssValue.STRING, rebased(value));
+        }
+        if (kind == CssProperties.FONT_FAMILY || kind == CssProperties.FONT) {
+            // The further families are fallbacks; a device has one font per name.
+            value = layers.get(0);
+        } else if (layers.size() > 1 && CssProperties.isLayered(property)) {
+            CssValue[] parts = new CssValue[layers.size()];
+            String kept = null;
+            for (int i = 0; i < parts.length; i++) {
+                parts[i] = layer(kind, property, layers.get(i));
+                if (parts[i] == null) {
+                    return null;
+                }
+                kept = warning == null ? kept : warning;
+            }
+            warning = kept;
+            return new CssValue(CssValue.LIST, 0, null, null, null, parts);
+        } else if (layers.size() > 1) {
+            if (kind != CssProperties.PAINT && kind != CssProperties.INSETS && kind != CssProperties.RADII
+                    && kind != CssProperties.LOOKUP_DEFINITION) {
+                return fail("a list of values is not accepted here");
+            }
+            warning = "layered values are not supported; only the last layer is used";
+            value = layers.get(layers.size() - 1);
+        }
+        return layer(kind, property, value);
+    }
+
+    /// The line of a border style: its first word, with `segments()`
+    /// standing for a dashed line.
+    private CssValue borderStyle(String first) {
+        String word = CssProperties.lower(first);
+        if (word.startsWith("segments(")) {
+            return CssValue.text(CssValue.KEYWORD, "dashed");
+        }
+        if (!CssProperties.accepts("-fx-border-style", word)) {
+            return fail("'" + first + "' is not a border style");
+        }
+        return CssValue.text(CssValue.KEYWORD, word);
+    }
+
+    /// One to four paints, for the top, right, bottom and left side; a
+    /// side left out takes the paint of the one opposite, as in CSS.
+    private CssValue sides(List<String> terms) {
+        CssValue[] p = new CssValue[4];
+        for (int i = 0; i < terms.size(); i++) {
+            p[i] = paint(terms.get(i));
+            if (p[i] == null) {
+                return null;
+            }
+        }
+        int n = terms.size();
+        if (n < 2) {
+            p[1] = p[0];
+        }
+        if (n < 3) {
+            p[2] = p[0];
+        }
+        if (n < 4) {
+            p[3] = p[1];
+        }
+        return new CssValue(CssValue.SIDES, 0, null, null, null, p);
+    }
+
+    private CssValue layer(int kind, String property, String value) {
+        List<String> terms = split(value, ' ');
+        if (terms == null || terms.isEmpty()) {
+            return fail("the value is empty");
+        }
+        String first = terms.get(0);
+        if ("-fx-border-style".equals(property)) {
+            return borderStyle(first);
+        }
+        if ("-fx-border-color".equals(property) && terms.size() > 1 && terms.size() <= 4) {
+            return sides(terms);
+        }
+        switch (kind) {
+            case CssProperties.LOOKUP_DEFINITION: {
+                if (terms.size() != 1) {
+                    return fail("not a known property, and not a colour that could be looked up");
+                }
+                CssValue paint = paint(first);
+                if (paint == null) {
+                    error = "not a known property, and its value is not a colour that could be looked up";
+                }
+                return paint;
+            }
+            case CssProperties.PAINT:
+                if (terms.size() != 1 && terms.size() != 4) {
+                    return fail("expected one paint");
+                }
+                if (terms.size() == 4) {
+                    warning = "a paint per side is not supported; the first is used for every side";
+                }
+                return paint(first);
+            case CssProperties.LENGTH: {
+                CssValue length = one(terms) ? length(first, false) : null;
+                return length == null ? fail("expected a length") : length;
+            }
+            case CssProperties.NUMBER: {
+                CssValue number = one(terms) ? number(first) : null;
+                return number == null ? fail("expected a number") : number;
+            }
+            case CssProperties.INSETS:
+                return sizes(terms, false);
+            case CssProperties.RADII:
+                return sizes(terms, true);
+            case CssProperties.BOOLEAN: {
+                String word = CssProperties.lower(first);
+                if (!one(terms) || !("true".equals(word) || "false".equals(word))) {
+                    return fail("expected true or false");
+                }
+                return CssValue.bool("true".equals(word));
+            }
+            case CssProperties.KEYWORD: {
+                String word = CssProperties.lower(first);
+                if (!CssProperties.accepts(property, word)) {
+                    return fail("'" + first + "' is not a value of " + property);
+                }
+                return CssValue.text(CssValue.KEYWORD, word);
+            }
+            case CssProperties.TEXT: {
+                if (!one(terms) || unquote(first).equals(first)) {
+                    return fail("expected one quoted string");
+                }
+                return CssValue.text(CssValue.STRING, unquote(first));
+            }
+            case CssProperties.POS:
+                return word(terms, POSITIONS, "an alignment");
+            case CssProperties.CURSOR: {
+                if (!one(terms) || !isIdent(first)) {
+                    return fail("expected a cursor name");
+                }
+                return CssValue.text(CssValue.KEYWORD, CssProperties.lower(first));
+            }
+            case CssProperties.EFFECT:
+                return one(terms) ? effect(first) : fail("expected dropshadow(), innershadow() or none");
+            case CssProperties.FONT:
+                return font(terms);
+            case CssProperties.FONT_SIZE: {
+                CssValue size = one(terms) ? fontSize(first) : null;
+                return size == null ? fail("expected a font size") : size;
+            }
+            case CssProperties.FONT_FAMILY:
+                return CssValue.text(CssValue.STRING, family(terms, 0));
+            case CssProperties.FONT_WEIGHT: {
+                CssValue weight = one(terms) ? weight(first) : null;
+                return weight == null ? fail("expected a font weight") : weight;
+            }
+            case CssProperties.FONT_STYLE: {
+                String word = CssProperties.lower(first);
+                if (!one(terms) || !("normal".equals(word) || "italic".equals(word) || "oblique".equals(word))) {
+                    return fail("expected normal, italic or oblique");
+                }
+                return CssValue.text(CssValue.KEYWORD, word);
+            }
+            default:
+                return fail("unsupported property");
+        }
+    }
+
+    /// Reads a colour that needs no node to resolve -- a name, a hash form
+    /// or one of the colour functions -- as `0xAARRGGBB`. Answers `null`
+    /// for anything else, a looked-up name included.
+    public Integer constantColor(String text) {
+        CssValue v = text == null ? null : paint(text.trim());
+        return v != null && v.type() == CssValue.COLOR ? Integer.valueOf(v.flags()) : null;
+    }
+
+    private CssValue fail(String message) {
+        error = message;
+        return null;
+    }
+
+    private static boolean one(List<String> terms) {
+        return terms.size() == 1;
+    }
+
+    private CssValue word(List<String> terms, String[] words, String what) {
+        String word = CssProperties.lower(terms.get(0));
+        if (one(terms)) {
+            for (int i = 0; i < words.length; i++) {
+                if (words[i].equals(word)) {
+                    return CssValue.text(CssValue.KEYWORD, word);
+                }
+            }
+        }
+        return fail("expected " + what);
+    }
+
+    // ------------------------------------------------------------ splitting
+
+    /// Splits at `separator` outside quotes and parentheses; a space stands
+    /// for any run of white space. Answers `null` when a quote or a
+    /// parenthesis is left open.
+    static List<String> split(String s, char separator) {
+        ArrayList<String> out = new ArrayList<String>();
+        int depth = 0;
+        char quote = 0;
+        int start = 0;
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            if (quote != 0) {
+                if (c == '\\') {
+                    i++;
+                } else if (c == quote) {
+                    quote = 0;
+                }
+                continue;
+            }
+            if (c == '"' || c == '\'') {
+                quote = c;
+            } else if (c == '(') {
+                depth++;
+            } else if (c == ')') {
+                depth--;
+                if (depth < 0) {
+                    return null;
+                }
+            } else if (depth == 0 && (c == separator || (separator == ' ' && isSpace(c)))) {
+                addTerm(out, s, start, i, separator);
+                start = i + 1;
+            }
+        }
+        if (depth != 0 || quote != 0) {
+            return null;
+        }
+        addTerm(out, s, start, n, separator);
+        return out;
+    }
+
+    private static void addTerm(List<String> out, String s, int start, int end, char separator) {
+        String term = s.substring(start, end).trim();
+        // An empty term between spaces is a run of spaces; between commas it
+        // is a mistake the caller reports.
+        if (term.length() > 0 || separator != ' ') {
+            out.add(term);
+        }
+    }
+
+    static boolean isSpace(char c) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
+    }
+
+    private static boolean isIdent(String s) {
+        if (s.length() == 0) {
+            return false;
+        }
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            boolean letter = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '-';
+            if (!letter && !(i > 0 && c >= '0' && c <= '9')) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // -------------------------------------------------------------- numbers
+
+    /// The number a term starts with, and where it ends, in `end[0]`; NaN
+    /// when the term does not start with one.
+    private static double numberPrefix(String s, int[] end) {
+        int n = s.length();
+        int i = 0;
+        if (i < n && (s.charAt(i) == '+' || s.charAt(i) == '-')) {
+            i++;
+        }
+        int digits = 0;
+        while (i < n && s.charAt(i) >= '0' && s.charAt(i) <= '9') {
+            i++;
+            digits++;
+        }
+        if (i < n && s.charAt(i) == '.') {
+            i++;
+            while (i < n && s.charAt(i) >= '0' && s.charAt(i) <= '9') {
+                i++;
+                digits++;
+            }
+        }
+        end[0] = i;
+        if (digits == 0) {
+            return Double.NaN;
+        }
+        String text = s.charAt(0) == '+' ? s.substring(1, i) : s.substring(0, i);
+        try {
+            return Double.parseDouble(text);
+        } catch (NumberFormatException e) {
+            return Double.NaN;
+        }
+    }
+
+    /// A number with a length unit, a percentage when `percent` allows it.
+    private static CssValue length(String term, boolean percent) {
+        // "-fx-max-width: infinity" is how a style sheet lets a control grow.
+        if ("infinity".equalsIgnoreCase(term)) {
+            return CssValue.number(Double.MAX_VALUE, CssValue.UNIT_PX);
+        }
+        if ("-infinity".equalsIgnoreCase(term)) {
+            return CssValue.number(-Double.MAX_VALUE, CssValue.UNIT_PX);
+        }
+        int[] end = new int[1];
+        double v = numberPrefix(term, end);
+        if (v != v) {
+            return null;
+        }
+        String unit = CssProperties.lower(term.substring(end[0]));
+        if (unit.length() == 0 || "px".equals(unit)) {
+            return CssValue.number(v, CssValue.UNIT_PX);
+        } else if ("em".equals(unit)) {
+            return CssValue.number(v, CssValue.UNIT_EM);
+        } else if ("ex".equals(unit)) {
+            return CssValue.number(v / 2, CssValue.UNIT_EM);
+        } else if ("pt".equals(unit)) {
+            return CssValue.number(v * 4 / 3, CssValue.UNIT_PX);
+        } else if ("pc".equals(unit)) {
+            return CssValue.number(v * 16, CssValue.UNIT_PX);
+        } else if ("in".equals(unit)) {
+            return CssValue.number(v * 96, CssValue.UNIT_PX);
+        } else if ("cm".equals(unit)) {
+            return CssValue.number(v * 96 / 2.54, CssValue.UNIT_PX);
+        } else if ("mm".equals(unit)) {
+            return CssValue.number(v * 96 / 25.4, CssValue.UNIT_PX);
+        } else if (percent && "%".equals(unit)) {
+            return CssValue.number(v, CssValue.UNIT_PERCENT);
+        }
+        return null;
+    }
+
+    /// A number without a unit; an angle is converted to degrees.
+    private static CssValue number(String term) {
+        int[] end = new int[1];
+        double v = numberPrefix(term, end);
+        if (v != v) {
+            return null;
+        }
+        String unit = CssProperties.lower(term.substring(end[0]));
+        if (unit.length() == 0 || "deg".equals(unit) || "px".equals(unit)) {
+            return CssValue.number(v, CssValue.UNIT_NONE);
+        } else if ("rad".equals(unit)) {
+            return CssValue.number(v * 180 / Math.PI, CssValue.UNIT_NONE);
+        } else if ("grad".equals(unit)) {
+            return CssValue.number(v * 0.9, CssValue.UNIT_NONE);
+        } else if ("turn".equals(unit)) {
+            return CssValue.number(v * 360, CssValue.UNIT_NONE);
+        }
+        return null;
+    }
+
+    private CssValue sizes(List<String> terms, boolean radii) {
+        int count = terms.size();
+        for (int i = 0; i < count; i++) {
+            if ("/".equals(terms.get(i))) {
+                // Vertical radii: a node has one radius per corner.
+                warning = "elliptical radii are not supported; the horizontal radii are used";
+                count = i;
+            }
+        }
+        if (count < 1 || count > 4) {
+            return fail("expected one to four " + (radii ? "radii" : "lengths"));
+        }
+        double[] nums = new double[count];
+        byte[] units = new byte[count];
+        for (int i = 0; i < count; i++) {
+            CssValue v = length(terms.get(i), radii);
+            if (v == null) {
+                return fail("'" + terms.get(i) + "' is not a " + (radii ? "radius" : "length"));
+            }
+            nums[i] = v.num(0);
+            units[i] = v.unit(0);
+        }
+        return new CssValue(CssValue.SIZES, 0, nums, units, null, null);
+    }
+
+    // ---------------------------------------------------------------- fonts
+
+    private static CssValue fontSize(String term) {
+        String word = CssProperties.lower(term);
+        for (int i = 0; i < SIZE_WORDS.length; i++) {
+            if (SIZE_WORDS[i].equals(word)) {
+                return CssValue.number(SIZE_FACTORS[i], CssValue.UNIT_EM);
+            }
+        }
+        return length(term, true);
+    }
+
+    private static CssValue weight(String term) {
+        String word = CssProperties.lower(term);
+        for (int i = 0; i < WEIGHTS.length; i++) {
+            if (WEIGHTS[i].equals(word)) {
+                return CssValue.text(CssValue.KEYWORD, word);
+            }
+        }
+        int[] end = new int[1];
+        double v = numberPrefix(term, end);
+        if (v == v && end[0] == term.length() && v >= 100 && v <= 900) {
+            return CssValue.number(v, CssValue.UNIT_NONE);
+        }
+        return null;
+    }
+
+    private static int weightNumber(CssValue weight) {
+        if (weight.type() == CssValue.NUMBER) {
+            return (int) weight.num(0);
+        }
+        String w = weight.text();
+        if ("bold".equals(w) || "bolder".equals(w)) {
+            return 700;
+        } else if ("thin".equals(w)) {
+            return 100;
+        } else if ("extra-light".equals(w) || "ultra-light".equals(w)) {
+            return 200;
+        } else if ("light".equals(w) || "lighter".equals(w)) {
+            return 300;
+        } else if ("medium".equals(w)) {
+            return 500;
+        } else if ("semi-bold".equals(w) || "demi-bold".equals(w)) {
+            return 600;
+        } else if ("extra-bold".equals(w) || "ultra-bold".equals(w)) {
+            return 800;
+        } else if ("black".equals(w) || "heavy".equals(w)) {
+            return 900;
+        }
+        return 400;
+    }
+
+    private static String family(List<String> terms, int from) {
+        StringBuilder s = new StringBuilder();
+        for (int i = from; i < terms.size(); i++) {
+            if (s.length() > 0) {
+                s.append(' ');
+            }
+            s.append(terms.get(i));
+        }
+        return unquote(s.toString());
+    }
+
+    /// `s` without the quotes around it, and with its backslash escapes
+    /// taken.
+    static String unquote(String s) {
+        int n = s.length();
+        if (n >= 2 && (s.charAt(0) == '"' || s.charAt(0) == '\'') && s.charAt(n - 1) == s.charAt(0)) {
+            StringBuilder out = new StringBuilder();
+            for (int i = 1; i < n - 1; i++) {
+                char c = s.charAt(i);
+                if (c == '\\' && i + 1 < n - 1) {
+                    i++;
+                    c = s.charAt(i);
+                }
+                out.append(c);
+            }
+            return out.toString();
+        }
+        return s;
+    }
+
+    private CssValue font(List<String> terms) {
+        int i = 0;
+        int posture = 0;
+        int weight = 0;
+        CssValue size = null;
+        while (i < terms.size() && size == null) {
+            String term = terms.get(i);
+            String word = CssProperties.lower(term);
+            // The line height of "12px/1.5" has nothing to apply to.
+            int slash = term.indexOf('/');
+            String sizeTerm = slash > 0 ? term.substring(0, slash) : term;
+            boolean bareNumber = weight(term) != null && weight(term).type() == CssValue.NUMBER;
+            if ("italic".equals(word) || "oblique".equals(word)) {
+                posture = 2;
+            } else if ("normal".equals(word)) {
+                // Stands for whichever of posture and weight was left out.
+                posture = posture == 0 ? 1 : posture;
+            } else if (weight(term) != null && !bareNumber) {
+                weight = weightNumber(weight(term));
+            } else if (bareNumber && i + 2 < terms.size() && fontSize(terms.get(i + 1)) != null) {
+                // "600 12px Arial": a bare number before a size is a weight.
+                weight = weightNumber(weight(term));
+            } else {
+                size = fontSize(sizeTerm);
+                if (size == null) {
+                    return fail("'" + term + "' is not a font style, weight or size");
+                }
+            }
+            i++;
+        }
+        if (size == null || i >= terms.size()) {
+            return fail("a font needs a size and a family");
+        }
+        return new CssValue(CssValue.FONT, weight | (posture << 16), new double[] {size.num(0)},
+                new byte[] {size.unit(0)}, family(terms, i), null);
+    }
+
+    // --------------------------------------------------------------- paints
+
+    private CssValue paint(String term) {
+        if (term.length() == 0) {
+            return fail("expected a paint");
+        }
+        if (term.charAt(0) == '#') {
+            if (!isHashColor(term)) {
+                return fail("'" + term + "' is not a colour");
+            }
+            return CssValue.color(hashColor(term));
+        }
+        int open = term.indexOf('(');
+        if (open > 0 && term.charAt(term.length() - 1) == ')') {
+            String name = CssProperties.lower(term.substring(0, open).trim());
+            List<String> args = split(term.substring(open + 1, term.length() - 1), ',');
+            if (args == null) {
+                return fail("unbalanced parentheses in '" + term + "'");
+            }
+            if ("rgb".equals(name) || "rgba".equals(name)) {
+                return rgb(args, term);
+            } else if ("hsb".equals(name) || "hsba".equals(name)) {
+                return hsx(args, term, true);
+            } else if ("hsl".equals(name) || "hsla".equals(name)) {
+                return hsx(args, term, false);
+            } else if ("derive".equals(name)) {
+                return derive(args, term);
+            } else if ("linear-gradient".equals(name)) {
+                return linear(args);
+            } else if ("radial-gradient".equals(name)) {
+                return radial(args);
+            } else if ("ladder".equals(name)) {
+                return ladder(args, term);
+            }
+            return fail("'" + name + "()' is not a paint");
+        }
+        if (!isIdent(term)) {
+            return fail("'" + term + "' is not a paint");
+        }
+        String word = CssProperties.lower(term);
+        if ("transparent".equals(word)) {
+            return CssValue.color(0);
+        }
+        Integer named = NAMED.get(word);
+        if (named != null) {
+            return CssValue.color(named.intValue());
+        }
+        return CssValue.text(CssValue.LOOKUP, word);
+    }
+
+    private static int hexInt(String s, int from, int to) {
+        int v = 0;
+        for (int i = from; i < to; i++) {
+            char c = s.charAt(i);
+            int d;
+            if (c >= '0' && c <= '9') {
+                d = c - '0';
+            } else if (c >= 'a' && c <= 'f') {
+                d = c - 'a' + 10;
+            } else if (c >= 'A' && c <= 'F') {
+                d = c - 'A' + 10;
+            } else {
+                return -1;
+            }
+            v = (v << 4) | d;
+        }
+        return v;
+    }
+
+    private static boolean isHashColor(String term) {
+        int n = term.length() - 1;
+        if (n != 3 && n != 4 && n != 6 && n != 8) {
+            return false;
+        }
+        for (int i = 1; i <= n; i++) {
+            if (hexInt(term, i, i + 1) < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// The colour of `#rgb`, `#rgba`, `#rrggbb` or `#rrggbbaa`, which the
+    /// caller has checked `term` to be.
+    private static int hashColor(String term) {
+        int n = term.length() - 1;
+        int r;
+        int g;
+        int b;
+        int a = 255;
+        if (n <= 4) {
+            r = hexInt(term, 1, 2) * 17;
+            g = hexInt(term, 2, 3) * 17;
+            b = hexInt(term, 3, 4) * 17;
+            if (n == 4) {
+                a = hexInt(term, 4, 5) * 17;
+            }
+        } else {
+            r = hexInt(term, 1, 3);
+            g = hexInt(term, 3, 5);
+            b = hexInt(term, 5, 7);
+            if (n == 8) {
+                a = hexInt(term, 7, 9);
+            }
+        }
+        return (a << 24) | (r << 16) | (g << 8) | b;
+    }
+
+    private static int channel(double v) {
+        int i = (int) Math.floor(v + 0.5);
+        return i < 0 ? 0 : i > 255 ? 255 : i;
+    }
+
+    private static int argb(double r, double g, double b, double a) {
+        return (channel(a * 255) << 24) | (channel(r * 255) << 16) | (channel(g * 255) << 8) | channel(b * 255);
+    }
+
+    /// A plain number or a percentage of `whole`; NaN for anything else.
+    private static double component(String term, double whole) {
+        int[] end = new int[1];
+        double v = numberPrefix(term, end);
+        String rest = term.substring(end[0]);
+        if (v != v) {
+            return Double.NaN;
+        }
+        if ("%".equals(rest)) {
+            return v * whole / 100;
+        }
+        return rest.length() == 0 ? v : Double.NaN;
+    }
+
+    private static double alpha(List<String> args) {
+        if (args.size() == 3) {
+            return 1;
+        }
+        double a = component(args.get(3), 1);
+        return a < 0 ? 0 : a > 1 ? 1 : a;
+    }
+
+    private CssValue rgb(List<String> args, String term) {
+        if (args.size() != 3 && args.size() != 4) {
+            return fail("'" + term + "' needs three or four components");
+        }
+        double r = component(args.get(0), 255);
+        double g = component(args.get(1), 255);
+        double b = component(args.get(2), 255);
+        double a = alpha(args);
+        if (r != r || g != g || b != b || a != a) {
+            return fail("'" + term + "' is not a colour");
+        }
+        return CssValue.color(argb(r / 255, g / 255, b / 255, a));
+    }
+
+    private CssValue hsx(List<String> args, String term, boolean hsb) {
+        if (args.size() != 3 && args.size() != 4) {
+            return fail("'" + term + "' needs three or four components");
+        }
+        double h = component(args.get(0), 360);
+        double s = component(args.get(1), 1);
+        double v = component(args.get(2), 1);
+        double a = alpha(args);
+        if (h != h || s != s || v != v || a != a) {
+            return fail("'" + term + "' is not a colour");
+        }
+        s = s < 0 ? 0 : s > 1 ? 1 : s;
+        v = v < 0 ? 0 : v > 1 ? 1 : v;
+        if (!hsb) {
+            // HSL to HSB: the same hue, the lightness spread differently.
+            double brightness = v + s * (v < 0.5 ? v : 1 - v);
+            s = brightness == 0 ? 0 : 2 * (1 - v / brightness);
+            v = brightness;
+        }
+        h = h - 360 * Math.floor(h / 360);
+        double sector = h / 60;
+        int i = (int) Math.floor(sector);
+        double f = sector - i;
+        double p = v * (1 - s);
+        double q = v * (1 - s * f);
+        double t = v * (1 - s * (1 - f));
+        double r;
+        double g;
+        double b;
+        switch (i % 6) {
+            case 0:
+                r = v;
+                g = t;
+                b = p;
+                break;
+            case 1:
+                r = q;
+                g = v;
+                b = p;
+                break;
+            case 2:
+                r = p;
+                g = v;
+                b = t;
+                break;
+            case 3:
+                r = p;
+                g = q;
+                b = v;
+                break;
+            case 4:
+                r = t;
+                g = p;
+                b = v;
+                break;
+            default:
+                r = v;
+                g = p;
+                b = q;
+                break;
+        }
+        return CssValue.color(argb(r, g, b, a));
+    }
+
+    private CssValue colorOnly(String term) {
+        CssValue v = paint(term);
+        if (v != null && v.type() != CssValue.COLOR && v.type() != CssValue.LOOKUP && v.type() != CssValue.DERIVE
+                && v.type() != CssValue.LADDER) {
+            return fail("'" + term + "' is not a colour");
+        }
+        return v;
+    }
+
+    /// `dropshadow(blur-type, colour, radius, spread, x, y)`,
+    /// `innershadow(blur-type, colour, radius, choke, x, y)` or `none`.
+    private CssValue effect(String term) {
+        String word = CssProperties.lower(term);
+        if ("none".equals(word) || "null".equals(word)) {
+            return new CssValue(CssValue.EFFECT, 0, new double[4], null, null, null);
+        }
+        int open = term.indexOf('(');
+        if (open <= 0 || term.charAt(term.length() - 1) != ')') {
+            return fail("expected dropshadow(), innershadow() or none");
+        }
+        String name = CssProperties.lower(term.substring(0, open).trim());
+        int kind = "dropshadow".equals(name) ? CssValue.EFFECT_DROP
+                : ("innershadow".equals(name) ? CssValue.EFFECT_INNER : 0);
+        if (kind == 0) {
+            return fail("'" + name + "()' is not an effect this layer draws");
+        }
+        List<String> args = split(term.substring(open + 1, term.length() - 1), ',');
+        if (args == null || args.size() != 6) {
+            return fail(name + "() needs a blur type, a colour, a radius, a spread and two offsets");
+        }
+        String blur = CssProperties.lower(args.get(0).trim());
+        int passes;
+        if ("one-pass-box".equals(blur)) {
+            passes = 1;
+        } else if ("two-pass-box".equals(blur)) {
+            passes = 2;
+        } else if ("three-pass-box".equals(blur) || "gaussian".equals(blur)) {
+            passes = 3;
+        } else {
+            return fail("'" + args.get(0).trim() + "' is not a blur type");
+        }
+        CssValue color = colorOnly(args.get(1).trim());
+        if (color == null) {
+            return null;
+        }
+        double[] nums = new double[4];
+        for (int i = 0; i < 4; i++) {
+            String arg = args.get(2 + i).trim();
+            if (i == 1 && arg.endsWith("%")) {
+                nums[i] = component(arg, 1);
+            } else {
+                CssValue n = length(arg, false);
+                if (n == null || n.unit(0) == CssValue.UNIT_EM) {
+                    nums[i] = Double.NaN;
+                } else {
+                    nums[i] = n.num(0);
+                }
+            }
+            if (nums[i] != nums[i]) {
+                return fail("'" + arg + "' is not a number");
+            }
+        }
+        nums[1] = Math.max(0, Math.min(1, nums[1]));
+        return new CssValue(CssValue.EFFECT, kind | (passes << 4), nums, null, null, new CssValue[] {color});
+    }
+
+    private CssValue derive(List<String> args, String term) {
+        if (args.size() != 2) {
+            return fail("'" + term + "' needs a colour and a percentage");
+        }
+        CssValue base = colorOnly(args.get(0));
+        if (base == null) {
+            return null;
+        }
+        String amount = args.get(1);
+        double pct = amount.endsWith("%") ? component(amount, 100) : Double.NaN;
+        if (pct != pct) {
+            return fail("'" + amount + "' is not a percentage");
+        }
+        return new CssValue(CssValue.DERIVE, 0, new double[] {pct}, null, null, new CssValue[] {base});
+    }
+
+    /// `ladder(colour, stop, stop...)`: the colour at the place in the
+    /// stops that the brightness of the first colour marks.
+    private CssValue ladder(List<String> args, String term) {
+        if (args.size() < 3) {
+            return fail("'" + term + "' needs a colour and at least two stops");
+        }
+        CssValue base = colorOnly(args.get(0));
+        if (base == null) {
+            return null;
+        }
+        double[] nums = new double[args.size() - 1];
+        CssValue[] colors = stops(args, 1, nums, 0);
+        if (colors == null) {
+            return null;
+        }
+        CssValue[] parts = new CssValue[colors.length + 1];
+        parts[0] = base;
+        System.arraycopy(colors, 0, parts, 1, colors.length);
+        return new CssValue(CssValue.LADDER, 0, nums, null, null, parts);
+    }
+
+    /// Reads the stops from `args[from]` on into `nums` from `at` on, and
+    /// answers their colours; `null` after a failure.
+    private CssValue[] stops(List<String> args, int from, double[] nums, int at) {
+        int count = args.size() - from;
+        if (count < 2) {
+            fail("a gradient needs at least two stops");
+            return null;
+        }
+        CssValue[] colors = new CssValue[count];
+        for (int i = 0; i < count; i++) {
+            List<String> terms = split(args.get(from + i), ' ');
+            if (terms == null || terms.isEmpty() || terms.size() > 2) {
+                fail("'" + args.get(from + i) + "' is not a gradient stop");
+                return null;
+            }
+            colors[i] = colorOnly(terms.get(0));
+            if (colors[i] == null) {
+                return null;
+            }
+            double offset = Double.NaN;
+            if (terms.size() == 2) {
+                String o = terms.get(1);
+                offset = o.endsWith("%") ? component(o, 1) : Double.NaN;
+                if (offset != offset) {
+                    fail("a stop offset must be a percentage, not '" + o + "'");
+                    return null;
+                }
+            }
+            nums[at + i] = offset;
+        }
+        return colors;
+    }
+
+    /// Reads a point as two lengths or two percentages into `out[at]` and
+    /// `out[at + 1]`; answers 1 for percentages, 0 for lengths and -1 for
+    /// anything else.
+    private static int point(String x, String y, double[] out, int at) {
+        CssValue px = length(x, true);
+        CssValue py = length(y, true);
+        if (px == null || py == null || px.unit(0) == CssValue.UNIT_EM || py.unit(0) == CssValue.UNIT_EM) {
+            return -1;
+        }
+        boolean percentX = px.unit(0) == CssValue.UNIT_PERCENT;
+        if (percentX != (py.unit(0) == CssValue.UNIT_PERCENT)) {
+            return -1;
+        }
+        out[at] = percentX ? px.num(0) / 100 : px.num(0);
+        out[at + 1] = percentX ? py.num(0) / 100 : py.num(0);
+        return percentX ? 1 : 0;
+    }
+
+    private static int cycle(String arg) {
+        String word = CssProperties.lower(arg);
+        return "repeat".equals(word) ? CssValue.FLAG_REPEAT : "reflect".equals(word) ? CssValue.FLAG_REFLECT : -1;
+    }
+
+    private CssValue linear(List<String> args) {
+        int next = 0;
+        double[] geometry = {0, 0, 0, 1};
+        int flags = CssValue.FLAG_PROPORTIONAL;
+        List<String> head = args.isEmpty() ? null : split(args.get(0), ' ');
+        if (head != null && !head.isEmpty()) {
+            String lead = CssProperties.lower(head.get(0));
+            if ("from".equals(lead)) {
+                if (head.size() != 6 || !"to".equals(CssProperties.lower(head.get(3)))) {
+                    return fail("expected 'from x y to x y'");
+                }
+                int a = point(head.get(1), head.get(2), geometry, 0);
+                int b = point(head.get(4), head.get(5), geometry, 2);
+                if (a < 0 || a != b) {
+                    return fail("the points of a gradient are all lengths or all percentages");
+                }
+                flags = a == 1 ? CssValue.FLAG_PROPORTIONAL : 0;
+                next = 1;
+            } else if ("to".equals(lead)) {
+                geometry[3] = 0;
+                for (int i = 1; i < head.size(); i++) {
+                    String side = CssProperties.lower(head.get(i));
+                    if ("top".equals(side)) {
+                        geometry[1] = 1;
+                        geometry[3] = 0;
+                    } else if ("bottom".equals(side)) {
+                        geometry[1] = 0;
+                        geometry[3] = 1;
+                    } else if ("left".equals(side)) {
+                        geometry[0] = 1;
+                        geometry[2] = 0;
+                    } else if ("right".equals(side)) {
+                        geometry[0] = 0;
+                        geometry[2] = 1;
+                    } else {
+                        return fail("'" + head.get(i) + "' is not a side");
+                    }
+                }
+                if (head.size() < 2 || head.size() > 3) {
+                    return fail("expected 'to' and one or two sides");
+                }
+                next = 1;
+            }
+        }
+        if (next < args.size() && cycle(args.get(next)) >= 0) {
+            flags |= cycle(args.get(next));
+            next++;
+        }
+        double[] nums = new double[4 + Math.max(0, args.size() - next)];
+        System.arraycopy(geometry, 0, nums, 0, 4);
+        CssValue[] colors = stops(args, next, nums, 4);
+        return colors == null ? null : new CssValue(CssValue.LINEAR, flags, nums, null, null, colors);
+    }
+
+    private CssValue radial(List<String> args) {
+        int next = 0;
+        double[] geometry = {0, 0, 0.5, 0.5, 0.5};
+        int centre = -1;
+        int radius = -1;
+        while (next < args.size()) {
+            List<String> terms = split(args.get(next), ' ');
+            String lead = terms == null || terms.isEmpty() ? "" : CssProperties.lower(terms.get(0));
+            if ("focus-angle".equals(lead) && terms.size() == 2) {
+                CssValue angle = number(terms.get(1));
+                if (angle == null) {
+                    return fail("'" + terms.get(1) + "' is not an angle");
+                }
+                geometry[0] = angle.num(0);
+            } else if ("focus-distance".equals(lead) && terms.size() == 2) {
+                double d = terms.get(1).endsWith("%") ? component(terms.get(1), 1) : Double.NaN;
+                if (d != d) {
+                    return fail("the focus distance is a percentage");
+                }
+                geometry[1] = d;
+            } else if ("center".equals(lead) && terms.size() == 3) {
+                centre = point(terms.get(1), terms.get(2), geometry, 2);
+                if (centre < 0) {
+                    return fail("the centre is two lengths or two percentages");
+                }
+            } else if ("radius".equals(lead) && terms.size() == 2) {
+                CssValue r = length(terms.get(1), true);
+                if (r == null || r.unit(0) == CssValue.UNIT_EM) {
+                    return fail("'" + terms.get(1) + "' is not a radius");
+                }
+                radius = r.unit(0) == CssValue.UNIT_PERCENT ? 1 : 0;
+                geometry[4] = radius == 1 ? r.num(0) / 100 : r.num(0);
+            } else {
+                break;
+            }
+            next++;
+        }
+        if (radius < 0) {
+            return fail("a radial gradient needs a radius");
+        }
+        if (centre >= 0 && centre != radius || centre < 0 && radius == 0) {
+            return fail("the centre and the radius are all lengths or all percentages");
+        }
+        int flags = radius == 1 ? CssValue.FLAG_PROPORTIONAL : 0;
+        if (next < args.size() && cycle(args.get(next)) >= 0) {
+            flags |= cycle(args.get(next));
+            next++;
+        }
+        double[] nums = new double[5 + Math.max(0, args.size() - next)];
+        System.arraycopy(geometry, 0, nums, 0, 5);
+        CssValue[] colors = stops(args, next, nums, 5);
+        return colors == null ? null : new CssValue(CssValue.RADIAL, flags, nums, null, null, colors);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/package-info.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/package-info.java
new file mode 100644
index 00000000000..3daf0cd541d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/css/package-info.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The part of the JavaFX style sheet support that the build and the device
+/// share: the parsed form of a value, a selector and a declaration, the
+/// parser that reads a value, and the compiled form of a whole style sheet
+/// with its reader and its writer.
+///
+/// Nothing here names a scene graph class, so the build can run the same
+/// code without the JavaFX layer on its class path: the style sheet
+/// compiler takes a copy of these sources under a package of its own. What
+/// the build writes is therefore exactly what the device reads, and an
+/// inline `style` is parsed on the device by the parser that parsed the
+/// style sheets at build time.
+///
+/// Everything here keeps to the class library a device has: no regular
+/// expressions, no reflection, no locale sensitive case folding.
+package com.codename1.fxcompat.runtime.css;
diff --git a/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/package-info.java b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/package-info.java
new file mode 100644
index 00000000000..56184a93459
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/fxcompat/runtime/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The machinery behind the `javafx` packages of this module: listener
+/// bookkeeping, change assembly and the bindings that keep two objects in
+/// sync. Nothing here is JavaFX API; applications must not use it.
+package com.codename1.fxcompat.runtime;
diff --git a/maven/javafx-compat/src/main/java/com/codename1/generated/compat/CompatRegistry.java b/maven/javafx-compat/src/main/java/com/codename1/generated/compat/CompatRegistry.java
new file mode 100644
index 00000000000..5581d232472
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/generated/compat/CompatRegistry.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.generated.compat;
+
+/// A placeholder for the registry the build generates into every
+/// application with desktop sources, so that the layer's lifecycle, which
+/// installs it, compiles.
+///
+/// The build's remap step writes the real class under this name -- see
+/// `com.codename1.impl.compat.CompatRegistryBase` -- and never copies this
+/// one out of the jar. The Swing and JavaFX layers each carry one; neither
+/// ships.
+public final class CompatRegistry {
+
+    private CompatRegistry() {
+    }
+
+    /// Records what the application ships and installs the registry; here,
+    /// where nothing was generated, nothing.
+    public static void cn1Install() {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/com/codename1/generated/compat/package-info.java b/maven/javafx-compat/src/main/java/com/codename1/generated/compat/package-info.java
new file mode 100644
index 00000000000..fdcd39f3fc5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/com/codename1/generated/compat/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The class the build generates into every application with desktop
+/// sources; this module carries only a placeholder of it, which never ships.
+package com.codename1.generated.compat;
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/Animation.java b/maven/javafx-compat/src/main/java/javafx/animation/Animation.java
new file mode 100644
index 00000000000..68895fac4d3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/Animation.java
@@ -0,0 +1,762 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import com.codename1.fxcompat.runtime.FrameClock;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableMap;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.util.Duration;
+
+/// Something that plays over time: the playhead, its speed and
+/// direction, its cycles, and the controls that start, pause and stop
+/// it. [Timeline] and the transitions say what playing does.
+///
+/// An animation runs on the JavaFX application thread, one step per
+/// frame. A cycle lasts [#getCycleDuration()] and is played
+/// [#getCycleCount()] times; with [#isAutoReverse()] every second cycle
+/// runs backwards. A negative rate plays towards the start, and the
+/// animation then finishes when it gets there.
+///
+/// The cycle duration, the cycle count, auto reverse and the delay are
+/// read when the animation starts; changing them while it runs takes
+/// effect the next time it is started. The rate is read on every frame.
+///
+/// An animation that is a child of a [SequentialTransition] or a
+/// [ParallelTransition] is played by its parent, and its own controls
+/// throw `IllegalStateException`.
+public abstract class Animation {
+
+    /// The cycle count of an animation that repeats until it is stopped.
+    public static final int INDEFINITE = -1;
+
+    /// What an animation is doing.
+    public enum Status {
+        /// Stopped for now; [Animation#play()] continues where it was.
+        PAUSED,
+        /// Playing.
+        RUNNING,
+        /// Not playing, and back at its start when it was stopped
+        /// rather than finished.
+        STOPPED
+    }
+
+    /// The animation this one is a child of, which then plays it.
+    Animation parent;
+
+    private final DoubleProperty rate = new SimpleDoubleProperty(this, "rate", 1.0);
+    private final ReadOnlyDoubleWrapper currentRate = new ReadOnlyDoubleWrapper(this, "currentRate", 0.0);
+    private final ReadOnlyObjectWrapper<Duration> cycleDuration =
+            new ReadOnlyObjectWrapper<Duration>(this, "cycleDuration", Duration.ZERO);
+    private final ReadOnlyObjectWrapper<Duration> totalDuration =
+            new ReadOnlyObjectWrapper<Duration>(this, "totalDuration", Duration.ZERO);
+    private final ReadOnlyObjectWrapper<Duration> currentTime =
+            new ReadOnlyObjectWrapper<Duration>(this, "currentTime", Duration.ZERO);
+    /// Checked in the property, as OpenJFX does, so a value set or bound
+    /// through delayProperty() is held to the same rule as setDelay: a
+    /// negative delay becomes zero (unbinding first) and then throws.
+    private final ObjectProperty<Duration> delay = new DelayProperty(this);
+    /// Any count is accepted, as OpenJFX accepts it (checked against 23 and
+    /// 27): one that is neither positive nor INDEFINITE plays one cycle.
+    /// The total duration follows the property however it is set.
+    private final IntegerProperty cycleCount = new SimpleIntegerProperty(this, "cycleCount", 1) {
+        @Override
+        protected void invalidated() {
+            syncTotalDuration();
+        }
+    };
+    private final BooleanProperty autoReverse = new SimpleBooleanProperty(this, "autoReverse", false);
+    private final ReadOnlyObjectWrapper<Status> status =
+            new ReadOnlyObjectWrapper<Status>(this, "status", Status.STOPPED);
+    private final ObjectProperty<EventHandler<ActionEvent>> onFinished =
+            new SimpleObjectProperty<EventHandler<ActionEvent>>(this, "onFinished");
+    private ObservableMap<String, Duration> cuePoints;
+
+    // What the animation was started with.
+    private double cycleMillis;
+    private int cycles = 1;
+    private boolean reversing;
+
+    // The playhead: the cycle it is in, and how far into that cycle it
+    // is as the animation as a whole counts it, which runs opposite to
+    // the content's own time in a reversed cycle.
+    private long cycleIndex;
+    private double cyclePos;
+
+    private boolean startPending;
+    private boolean jumpPending;
+    private boolean lastPlayedFinished;
+    private double delayLeft;
+    private long lastPulseNanos;
+    private boolean embeddedForward = true;
+
+    /// Changes whenever the animation is started, paused, stopped or
+    /// moved, so that a step in progress, whose handler did it, notices
+    /// and ends.
+    int token;
+
+    private final FrameClock.Pulse pulse = new FrameClock.Pulse() {
+        @Override
+        public void pulse(long nowNanos) {
+            onPulse(nowNanos);
+        }
+    };
+
+    /// Creates an animation.
+    protected Animation() {
+    }
+
+    // ---- properties ----
+
+    /// Sets the speed and direction: 1 is normal speed, 2 twice as
+    /// fast, a negative rate plays backwards.
+    public final void setRate(double value) {
+        rate.set(value);
+        if (getStatus() == Status.RUNNING) {
+            syncCurrentRate();
+        }
+    }
+
+    /// Returns the speed and direction the animation is to play at.
+    public final double getRate() {
+        return rate.get();
+    }
+
+    /// The speed and direction the animation is to play at.
+    public final DoubleProperty rateProperty() {
+        return rate;
+    }
+
+    /// Returns the speed and direction the animation is playing at
+    /// right now: 0 when it is not running, and of the opposite sign to
+    /// the rate in a reversed cycle.
+    public final double getCurrentRate() {
+        return currentRate.get();
+    }
+
+    /// The speed and direction the animation is playing at right now.
+    public final ReadOnlyDoubleProperty currentRateProperty() {
+        return currentRate.getReadOnlyProperty();
+    }
+
+    /// Sets the length of one cycle.
+    protected final void setCycleDuration(Duration value) {
+        cycleDuration.set(value == null ? Duration.ZERO : value);
+        syncTotalDuration();
+    }
+
+    /// Returns the length of one cycle.
+    public final Duration getCycleDuration() {
+        syncWhenStopped();
+        return cycleDuration.get();
+    }
+
+    /// The length of one cycle.
+    public final ReadOnlyObjectProperty<Duration> cycleDurationProperty() {
+        syncWhenStopped();
+        return cycleDuration.getReadOnlyProperty();
+    }
+
+    /// Returns the length of all cycles together, `Duration.INDEFINITE`
+    /// for an animation that repeats until it is stopped.
+    public final Duration getTotalDuration() {
+        syncWhenStopped();
+        return totalDuration.get();
+    }
+
+    /// The length of all cycles together.
+    public final ReadOnlyObjectProperty<Duration> totalDurationProperty() {
+        syncWhenStopped();
+        return totalDuration.getReadOnlyProperty();
+    }
+
+    /// Returns the position of the playhead within its cycle.
+    public final Duration getCurrentTime() {
+        return currentTime.get();
+    }
+
+    /// The position of the playhead within its cycle.
+    public final ReadOnlyObjectProperty<Duration> currentTimeProperty() {
+        return currentTime.getReadOnlyProperty();
+    }
+
+    /// Sets the time the animation waits after it was started.
+    public final void setDelay(Duration value) {
+        delay.set(value);
+    }
+
+    /// Returns the time the animation waits after it was started.
+    public final Duration getDelay() {
+        return delay.get();
+    }
+
+    /// The time the animation waits after it was started.
+    public final ObjectProperty<Duration> delayProperty() {
+        return delay;
+    }
+
+    /// Sets how many cycles are played; [#INDEFINITE] repeats until the
+    /// animation is stopped.
+    public final void setCycleCount(int value) {
+        cycleCount.set(value);
+    }
+
+    /// Returns how many cycles are played.
+    public final int getCycleCount() {
+        return cycleCount.get();
+    }
+
+    /// How many cycles are played.
+    public final IntegerProperty cycleCountProperty() {
+        return cycleCount;
+    }
+
+    /// Sets whether every second cycle runs backwards.
+    public final void setAutoReverse(boolean value) {
+        autoReverse.set(value);
+    }
+
+    /// Returns whether every second cycle runs backwards.
+    public final boolean isAutoReverse() {
+        return autoReverse.get();
+    }
+
+    /// Whether every second cycle runs backwards.
+    public final BooleanProperty autoReverseProperty() {
+        return autoReverse;
+    }
+
+    /// Sets what the animation is doing.
+    protected final void setStatus(Status value) {
+        status.set(value);
+    }
+
+    /// Returns what the animation is doing.
+    public final Status getStatus() {
+        return status.get();
+    }
+
+    /// What the animation is doing.
+    public final ReadOnlyObjectProperty<Status> statusProperty() {
+        return status.getReadOnlyProperty();
+    }
+
+    /// Sets the handler that runs when the animation reaches its end by
+    /// itself. It does not run when the animation is stopped, and never
+    /// for one that repeats indefinitely.
+    public final void setOnFinished(EventHandler<ActionEvent> value) {
+        onFinished.set(value);
+    }
+
+    /// Returns the handler that runs when the animation finishes.
+    public final EventHandler<ActionEvent> getOnFinished() {
+        return onFinished.get();
+    }
+
+    /// The handler that runs when the animation finishes.
+    public final ObjectProperty<EventHandler<ActionEvent>> onFinishedProperty() {
+        return onFinished;
+    }
+
+    /// Returns the named positions of the animation, for
+    /// [#jumpTo(String)] and [#playFrom(String)]. The names `"start"`
+    /// and `"end"` always exist and need no entry.
+    public final ObservableMap<String, Duration> getCuePoints() {
+        if (cuePoints == null) {
+            cuePoints = FXCollections.observableHashMap();
+        }
+        return cuePoints;
+    }
+
+    // ---- controls ----
+
+    /// Plays from the current position in the direction of the rate. A
+    /// paused animation continues; one that finished starts over from
+    /// its start, or from its end when the rate is negative.
+    public void play() {
+        requireRoot("start");
+        Status s = getStatus();
+        if (s == Status.PAUSED) {
+            token++;
+            lastPulseNanos = FrameClock.nowNanos();
+            setStatus(Status.RUNNING);
+            syncCurrentRate();
+            FrameClock.add(pulse);
+        } else if (s == Status.STOPPED) {
+            token++;
+            double position = position();
+            snapshot();
+            if (lastPlayedFinished) {
+                place(getRate() < 0 ? totalMillis() : 0);
+                jumpPending = false;
+            } else {
+                place(position);
+            }
+            lastPlayedFinished = false;
+            delayLeft = millis(getDelay());
+            startPending = atEntryEdge(getRate() >= 0);
+            doStart(true);
+            syncCurrentTime();
+            lastPulseNanos = FrameClock.nowNanos();
+            setStatus(Status.RUNNING);
+            syncCurrentRate();
+            FrameClock.add(pulse);
+        }
+    }
+
+    /// Plays forwards from the start.
+    public void playFromStart() {
+        stop();
+        setRate(Math.abs(getRate()));
+        jumpTo(Duration.ZERO);
+        play();
+    }
+
+    /// Plays from a position.
+    public void playFrom(Duration time) {
+        jumpTo(time);
+        play();
+    }
+
+    /// Plays from a cue point.
+    public void playFrom(String cuePoint) {
+        jumpTo(cuePoint);
+        play();
+    }
+
+    /// Pauses a running animation where it is.
+    public void pause() {
+        requireRoot("pause");
+        if (getStatus() == Status.RUNNING) {
+            token++;
+            FrameClock.remove(pulse);
+            setStatus(Status.PAUSED);
+            currentRate.set(0.0);
+        }
+    }
+
+    /// Stops the animation and moves the playhead back to the start.
+    /// The values the animation has written stay as they are, and the
+    /// finished handler does not run.
+    public void stop() {
+        requireRoot("stop");
+        if (getStatus() != Status.STOPPED) {
+            token++;
+            FrameClock.remove(pulse);
+            doStop();
+            setStatus(Status.STOPPED);
+            currentRate.set(0.0);
+            place(0);
+            syncCurrentTime();
+            jumpPending = false;
+            lastPlayedFinished = true;
+        }
+    }
+
+    /// Moves the playhead to a position counted from the start of the
+    /// first cycle; a position outside the animation is moved to its
+    /// nearer end. A stopped animation shows the position once it is
+    /// played.
+    public void jumpTo(Duration time) {
+        if (time == null) {
+            throw new NullPointerException("Time needs to be specified.");
+        }
+        if (time.isUnknown()) {
+            throw new IllegalArgumentException("The time is invalid");
+        }
+        requireRoot("jump");
+        boolean stopped = getStatus() == Status.STOPPED;
+        if (stopped) {
+            snapshot();
+        }
+        token++;
+        double total = totalMillis();
+        double target = time.isIndefinite() ? (Double.isInfinite(total) ? cycleMillis : total)
+                : time.toMillis();
+        place(target);
+        lastPlayedFinished = false;
+        startPending = false;
+        syncCurrentTime();
+        if (stopped) {
+            jumpPending = true;
+        } else {
+            doJumpTo(localTime());
+            if (getStatus() == Status.RUNNING) {
+                syncCurrentRate();
+            }
+        }
+    }
+
+    /// Moves the playhead to a cue point: `"start"`, `"end"` or an
+    /// entry of [#getCuePoints()]. An unknown name does nothing.
+    public void jumpTo(String cuePoint) {
+        if (cuePoint == null) {
+            throw new NullPointerException("CuePoint needs to be specified");
+        }
+        if ("start".equalsIgnoreCase(cuePoint)) {
+            jumpTo(Duration.ZERO);
+        } else if ("end".equalsIgnoreCase(cuePoint)) {
+            jumpTo(getTotalDuration());
+        } else {
+            Duration target = getCuePoints().get(cuePoint);
+            if (target != null) {
+                jumpTo(target);
+            }
+        }
+    }
+
+    // ---- what a kind of animation provides ----
+
+    /// Called when the animation starts or, as a child, is entered.
+    /// With `capture` set it starts afresh and reads what it needs from
+    /// its targets; without, a parent is entering it again on a later
+    /// cycle.
+    abstract void doStart(boolean capture);
+
+    /// Moves the content from one time of its cycle to another, running
+    /// the handlers of what lies between. `atStart` says the cycle is
+    /// being entered at `from`, so that what lies exactly there counts
+    /// too.
+    abstract void doPlayTo(double from, double to, boolean forward, boolean atStart);
+
+    /// Shows the content at a time of its cycle, running no handlers.
+    abstract void doJumpTo(double time);
+
+    /// Called when the animation is stopped.
+    void doStop() {
+    }
+
+    /// Brings the cycle duration up to date with what it derives from.
+    void syncDuration() {
+    }
+
+    // ---- the engine ----
+
+    private void requireRoot(String what) {
+        if (parent != null) {
+            throw new IllegalStateException("Cannot " + what + " when embedded in another animation");
+        }
+    }
+
+    /// Returns the animation at the top of the tree this one is in.
+    final Animation root() {
+        Animation a = this;
+        while (a.parent != null) {
+            a = a.parent;
+        }
+        return a;
+    }
+
+    private void syncWhenStopped() {
+        if (root().getStatus() == Status.STOPPED) {
+            syncDuration();
+        }
+    }
+
+    private static double millis(Duration d) {
+        if (d == null || d.isUnknown()) {
+            return 0;
+        }
+        double ms = d.toMillis();
+        return ms < 0 ? 0 : ms;
+    }
+
+    private void syncTotalDuration() {
+        Duration cycle = cycleDuration.get();
+        int count = cycleCount.get();
+        Duration total;
+        if (count == INDEFINITE) {
+            total = Duration.INDEFINITE;
+        } else if (count <= 1) {
+            total = cycle;
+        } else {
+            total = cycle.multiply(count);
+        }
+        totalDuration.set(total);
+    }
+
+    private void snapshot() {
+        syncDuration();
+        syncTotalDuration();
+        cycleMillis = millis(cycleDuration.get());
+        int count = cycleCount.get();
+        cycles = count == INDEFINITE ? INDEFINITE : Math.max(1, count);
+        reversing = autoReverse.get();
+    }
+
+    /// Returns the length of the cycle the animation was started with,
+    /// in milliseconds.
+    final double cycleMillis() {
+        return cycleMillis;
+    }
+
+    private double totalMillis() {
+        return cycles == INDEFINITE ? Double.POSITIVE_INFINITY : cycleMillis * cycles;
+    }
+
+    private double position() {
+        return cycleIndex * cycleMillis + cyclePos;
+    }
+
+    private void place(double position) {
+        if (cycleMillis <= 0 || Double.isInfinite(cycleMillis)) {
+            cycleIndex = 0;
+            cyclePos = cycleMillis <= 0 || position < 0 ? 0 : position;
+            return;
+        }
+        double p = position < 0 ? 0 : Math.min(position, totalMillis());
+        long index = (long) Math.floor(p / cycleMillis);
+        if (cycles != INDEFINITE && index >= cycles) {
+            index = cycles - 1L;
+        }
+        cycleIndex = index;
+        cyclePos = Math.max(0, Math.min(cycleMillis, p - index * cycleMillis));
+    }
+
+    private boolean reversedCycle() {
+        return reversing && (cycleIndex & 1L) == 1L;
+    }
+
+    /// Returns the playhead as the content counts it, within its cycle.
+    final double localMillis() {
+        return localTime();
+    }
+
+    private double localTime() {
+        return reversedCycle() ? cycleMillis - cyclePos : cyclePos;
+    }
+
+    private boolean atEntryEdge(boolean forward) {
+        return forward ? cyclePos <= 0 : cyclePos >= cycleMillis;
+    }
+
+    private void syncCurrentTime() {
+        currentTime.set(Duration.millis(localTime()));
+    }
+
+    private void syncCurrentRate() {
+        double r = getRate();
+        currentRate.set(reversedCycle() ? -r : r);
+    }
+
+    private void onPulse(long nowNanos) {
+        double elapsed = (nowNanos - lastPulseNanos) / 1000000.0;
+        lastPulseNanos = nowNanos;
+        if (elapsed < 0) {
+            elapsed = 0;
+        }
+        if (delayLeft > 0) {
+            if (elapsed < delayLeft) {
+                delayLeft -= elapsed;
+                return;
+            }
+            elapsed -= delayLeft;
+            delayLeft = 0;
+        }
+        int started = token;
+        if (jumpPending) {
+            jumpPending = false;
+            doJumpTo(localTime());
+            if (token != started) {
+                return;
+            }
+        }
+        double r = getRate();
+        boolean finished = advance(elapsed * Math.abs(r), r >= 0);
+        if (token != started) {
+            return;
+        }
+        if (finished) {
+            token++;
+            FrameClock.remove(pulse);
+            setStatus(Status.STOPPED);
+            currentRate.set(0.0);
+            lastPlayedFinished = true;
+            fireFinished();
+        } else {
+            syncCurrentRate();
+        }
+    }
+
+    private void fireFinished() {
+        EventHandler<ActionEvent> handler = getOnFinished();
+        if (handler != null) {
+            handler.handle(new ActionEvent(this, null));
+        }
+    }
+
+    /// Moves the playhead by an amount of time in a direction, cycle by
+    /// cycle so that nothing in between is skipped, and returns whether
+    /// it reached the end of the animation in that direction.
+    private boolean advance(double amount, boolean forward) {
+        Animation top = root();
+        int started = top.token;
+        if (cycleMillis <= 0) {
+            boolean entering = startPending;
+            startPending = false;
+            doPlayTo(0, 0, forward, entering);
+            return top.token == started;
+        }
+        double remaining = amount;
+        while (true) {
+            boolean localForward = forward != reversedCycle();
+            double from = localTime();
+            boolean entering = startPending;
+            startPending = false;
+            double room = forward ? cycleMillis - cyclePos : cyclePos;
+            if (remaining < room) {
+                cyclePos += forward ? remaining : -remaining;
+                syncCurrentTime();
+                doPlayTo(from, localTime(), localForward, entering);
+                return false;
+            }
+            cyclePos = forward ? cycleMillis : 0;
+            remaining -= room;
+            syncCurrentTime();
+            doPlayTo(from, localTime(), localForward, entering);
+            if (top.token != started) {
+                return false;
+            }
+            boolean last = forward ? cycles != INDEFINITE && cycleIndex >= cycles - 1L : cycleIndex <= 0;
+            if (last) {
+                return true;
+            }
+            if (remaining <= 0) {
+                // Exactly on the boundary: the cycle that ended is still the
+                // one showing, and the next frame enters the next one.
+                return false;
+            }
+            cycleIndex += forward ? 1 : -1;
+            cyclePos = forward ? 0 : cycleMillis;
+            // A reversed cycle begins where the last one ended, which was
+            // visited a moment ago; any other begins at the far edge.
+            startPending = !reversing;
+            if (parent == null) {
+                syncCurrentRate();
+            }
+        }
+    }
+
+    // ---- being played by a parent ----
+
+    /// Returns how long this animation takes as a child: its delay and
+    /// all its cycles at its own rate.
+    final double embeddedSpan() {
+        snapshot();
+        double speed = Math.abs(getRate());
+        double total = totalMillis();
+        double wait = millis(getDelay());
+        if (speed <= 0) {
+            return wait;
+        }
+        return wait + total / speed;
+    }
+
+    /// Places the child at the edge its parent enters it from.
+    final void embeddedEnter(boolean parentForward, boolean capture) {
+        snapshot();
+        boolean forward = parentForward == (getRate() >= 0);
+        double total = totalMillis();
+        place(forward || Double.isInfinite(total) ? 0 : total);
+        embeddedForward = forward;
+        startPending = true;
+        jumpPending = false;
+        doStart(capture);
+        syncCurrentTime();
+    }
+
+    private double embeddedTarget(double elapsed) {
+        double speed = Math.abs(getRate());
+        double played = Math.max(0, elapsed - millis(getDelay())) * speed;
+        double total = totalMillis();
+        if (played > total) {
+            played = total;
+        }
+        return getRate() < 0 && !Double.isInfinite(total) ? total - played : played;
+    }
+
+    /// Plays the child to the time its parent has reached within it,
+    /// running its handlers, the finished handler included when it gets
+    /// to its end.
+    final void embeddedPlayTo(double elapsed) {
+        Animation top = root();
+        int started = top.token;
+        double target = embeddedTarget(elapsed);
+        double position = position();
+        if (target > position) {
+            embeddedForward = true;
+        } else if (target < position) {
+            embeddedForward = false;
+        }
+        boolean finished = advance(Math.abs(target - position), embeddedForward);
+        if (finished && top.token == started) {
+            fireFinished();
+        }
+    }
+
+    /// Shows the child at the time its parent has jumped to within it.
+    final void embeddedJumpTo(double elapsed) {
+        place(embeddedTarget(elapsed));
+        startPending = false;
+        syncCurrentTime();
+        doJumpTo(localTime());
+    }
+
+    /// The delay property, which checks every value however it arrives: a
+    /// negative delay becomes zero (unbinding first) and then throws, as
+    /// OpenJFX's does.
+    private static final class DelayProperty extends SimpleObjectProperty<Duration> {
+        DelayProperty(Object bean) {
+            super(bean, "delay", Duration.ZERO);
+        }
+
+        @Override
+        protected void invalidated() {
+            Duration value = get();
+            if (value == null) {
+                throw new NullPointerException("Delay must not be null");
+            }
+            if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+                if (isBound()) {
+                    unbind();
+                }
+                set(Duration.ZERO);
+                throw new IllegalArgumentException("Cannot set delay to negative value. Setting to Duration.ZERO");
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/AnimationTimer.java b/maven/javafx-compat/src/main/java/javafx/animation/AnimationTimer.java
new file mode 100644
index 00000000000..9b5d15ce0e1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/AnimationTimer.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import com.codename1.fxcompat.runtime.FrameClock;
+
+/// A callback that runs once per frame while the timer is started, on
+/// the JavaFX application thread.
+public abstract class AnimationTimer {
+
+    private boolean active;
+    private final FrameClock.Pulse pulse = new FrameClock.Pulse() {
+        @Override
+        public void pulse(long nowNanos) {
+            handle(nowNanos);
+        }
+    };
+
+    /// Creates a timer, which is not started.
+    public AnimationTimer() {
+    }
+
+    /// Called once per frame with the time of the frame in nanoseconds.
+    /// The time never runs backwards, and the same value is given to
+    /// every timer in one frame; its origin is arbitrary.
+    public abstract void handle(long now);
+
+    /// Starts the timer; starting a started timer has no effect.
+    public void start() {
+        if (!active) {
+            active = true;
+            FrameClock.add(pulse);
+        }
+    }
+
+    /// Stops the timer; it can be started again.
+    public void stop() {
+        if (active) {
+            active = false;
+            FrameClock.remove(pulse);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/ChildClips.java b/maven/javafx-compat/src/main/java/javafx/animation/ChildClips.java
new file mode 100644
index 00000000000..9effc40ecf2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/ChildClips.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import java.util.List;
+
+/// The children of a sequential or parallel transition, each placed on
+/// the time of its parent: when it begins and how long it takes.
+///
+/// A child is before the playhead, under it or behind it. The parent
+/// enters a child when the playhead reaches it, plays it while the
+/// playhead is under it and leaves it at its far edge; moving backwards
+/// does the same from the other side. A child reads what it starts from
+/// the first time it is entered after its parent started, so a child
+/// later in a sequence starts from what the earlier ones left.
+final class ChildClips {
+
+    private static final int BEFORE = 0;
+    private static final int UNDER = 1;
+    private static final int BEHIND = 2;
+
+    private final Animation owner;
+    private final boolean sequential;
+    private Animation[] clips = new Animation[0];
+    private double[] begin = new double[0];
+    private double[] span = new double[0];
+    private int[] state = new int[0];
+    private boolean[] entered = new boolean[0];
+
+    ChildClips(Animation owner, boolean sequential) {
+        this.owner = owner;
+        this.sequential = sequential;
+    }
+
+    /// Lays the children out and returns the length of the whole.
+    double layout(List<Animation> children) {
+        int count = 0;
+        for (int i = 0; i < children.size(); i++) {
+            if (children.get(i) != null) {
+                count++;
+            }
+        }
+        clips = new Animation[count];
+        begin = new double[count];
+        span = new double[count];
+        state = new int[count];
+        entered = new boolean[count];
+        double length = 0;
+        int at = 0;
+        for (int i = 0; i < children.size(); i++) {
+            Animation child = children.get(i);
+            if (child == null) {
+                continue;
+            }
+            clips[at] = child;
+            span[at] = child.embeddedSpan();
+            if (sequential) {
+                begin[at] = length;
+                length += span[at];
+            } else {
+                begin[at] = 0;
+                length = Math.max(length, span[at]);
+            }
+            at++;
+        }
+        return length;
+    }
+
+    /// Sets where every child stands for a playhead at a time, without
+    /// writing anything, and forgets what the children started from.
+    void start(double time, double length, boolean capture) {
+        for (int i = 0; i < clips.length; i++) {
+            if (capture) {
+                entered[i] = false;
+            }
+            double end = begin[i] + span[i];
+            if (time <= 0) {
+                state[i] = BEFORE;
+            } else if (time >= length || end <= time) {
+                state[i] = BEHIND;
+            } else {
+                // A child under the playhead is entered by the jump that
+                // put the playhead there, after the ones behind it.
+                state[i] = BEFORE;
+            }
+        }
+    }
+
+    /// Puts every child before or behind the playhead, as a new cycle
+    /// finds them.
+    void rewind(boolean forward) {
+        for (int i = 0; i < clips.length; i++) {
+            state[i] = forward ? BEFORE : BEHIND;
+        }
+    }
+
+    private void enter(int i, boolean forward) {
+        clips[i].embeddedEnter(forward, !entered[i]);
+        entered[i] = true;
+    }
+
+    void playTo(double to, boolean forward) {
+        Animation top = owner.root();
+        int started = top.token;
+        if (forward) {
+            for (int i = 0; i < clips.length; i++) {
+                double end = begin[i] + span[i];
+                if (state[i] == BEFORE && (to > begin[i] || span[i] <= 0 && to >= begin[i])) {
+                    enter(i, true);
+                    state[i] = UNDER;
+                }
+                if (state[i] == UNDER) {
+                    clips[i].embeddedPlayTo(Math.min(to - begin[i], span[i]));
+                    if (top.token != started) {
+                        return;
+                    }
+                    if (to >= end) {
+                        state[i] = BEHIND;
+                    }
+                }
+            }
+        } else {
+            for (int i = clips.length - 1; i >= 0; i--) {
+                double end = begin[i] + span[i];
+                if (state[i] == BEHIND && (to < end || span[i] <= 0 && to <= end)) {
+                    enter(i, false);
+                    state[i] = UNDER;
+                }
+                if (state[i] == UNDER) {
+                    clips[i].embeddedPlayTo(Math.max(0, to - begin[i]));
+                    if (top.token != started) {
+                        return;
+                    }
+                    if (to <= begin[i]) {
+                        state[i] = BEFORE;
+                    }
+                }
+            }
+        }
+    }
+
+    /// Shows the children as they are with the playhead at a time: the
+    /// ones behind it at their end, the ones it has not reached at their
+    /// start if they were ever played, and the one under it in between.
+    void jumpTo(double time) {
+        for (int i = 0; i < clips.length; i++) {
+            double end = begin[i] + span[i];
+            if (end <= time && time > 0) {
+                if (!entered[i]) {
+                    enter(i, true);
+                }
+                clips[i].embeddedJumpTo(span[i]);
+                state[i] = BEHIND;
+            }
+        }
+        for (int i = clips.length - 1; i >= 0; i--) {
+            double end = begin[i] + span[i];
+            if (end <= time && time > 0) {
+                continue;
+            }
+            if (begin[i] >= time) {
+                if (entered[i]) {
+                    clips[i].embeddedJumpTo(0);
+                }
+                state[i] = BEFORE;
+            } else {
+                if (!entered[i]) {
+                    enter(i, true);
+                }
+                clips[i].embeddedJumpTo(time - begin[i]);
+                state[i] = UNDER;
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/FadeTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/FadeTransition.java
new file mode 100644
index 00000000000..caa5ac002e8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/FadeTransition.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+/// Changes the opacity of a node over time.
+///
+/// The start is the `from` value, or what the node has when the
+/// transition starts. The end is the `to` value, or the start moved by
+/// the `by` value. All of them are read when the transition starts.
+/// Opacity stays between 0 and 1.
+public final class FadeTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private Node target;
+    private final DoubleProperty fromValue = new SimpleDoubleProperty(this, "fromValue", Double.NaN);
+    private final DoubleProperty toValue = new SimpleDoubleProperty(this, "toValue", Double.NaN);
+    private final DoubleProperty byValue = new SimpleDoubleProperty(this, "byValue", 0.0);
+    private double startValue;
+    private double deltaValue;
+
+    /// Creates a transition of a length for a node.
+    public FadeTransition(Duration duration, Node node) {
+        setDuration(duration);
+        setNode(node);
+    }
+
+    /// Creates a transition of a length.
+    public FadeTransition(Duration duration) {
+        this(duration, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public FadeTransition() {
+        this(Duration.millis(400), null);
+    }
+
+    /// Sets the length of the transition. It is read when the
+    /// transition starts.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns the length of the transition.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// The length of the transition; 400 milliseconds unless set.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the node that is animated. Without one the transition
+    /// animates the node of the nearest parent transition that names
+    /// one. It is read when the transition starts.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node that is animated.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node that is animated.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Sets the opacity the transition starts at; not a number, the default, starts at what the node has.
+    public final void setFromValue(double value) {
+        fromValue.set(value);
+    }
+
+    /// Returns the opacity the transition starts at; not a number, the default, starts at what the node has.
+    public final double getFromValue() {
+        return fromValue.get();
+    }
+
+    /// The opacity the transition starts at; not a number, the default, starts at what the node has.
+    public final DoubleProperty fromValueProperty() {
+        return fromValue;
+    }
+
+    /// Sets the opacity the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final void setToValue(double value) {
+        toValue.set(value);
+    }
+
+    /// Returns the opacity the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final double getToValue() {
+        return toValue.get();
+    }
+
+    /// The opacity the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final DoubleProperty toValueProperty() {
+        return toValue;
+    }
+
+    /// Sets how far the opacity moves from its start; used when no `to` value is set.
+    public final void setByValue(double value) {
+        byValue.set(value);
+    }
+
+    /// Returns how far the opacity moves from its start; used when no `to` value is set.
+    public final double getByValue() {
+        return byValue.get();
+    }
+
+    /// How far the opacity moves from its start; used when no `to` value is set.
+    public final DoubleProperty byValueProperty() {
+        return byValue;
+    }
+
+    @Override
+    void prepare() {
+        target = getNode() != null ? getNode() : getParentTargetNode();
+        if (target == null) {
+            return;
+        }
+        double fromValue = getFromValue();
+        double toValue = getToValue();
+        startValue = Double.isNaN(fromValue) ? target.getOpacity() : clamp(fromValue);
+        deltaValue = Double.isNaN(toValue) ? getByValue() : clamp(toValue) - startValue;
+        startValue = clamp(startValue);
+        deltaValue = clamp(startValue + deltaValue) - startValue;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target != null) {
+            target.setOpacity(clamp(startValue + frac * deltaValue));
+        }
+    }
+
+    private static double clamp(double v) {
+        return v < 0 ? 0 : v > 1 ? 1 : v;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/FillTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/FillTransition.java
new file mode 100644
index 00000000000..cb5622db468
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/FillTransition.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Shape;
+import javafx.util.Duration;
+
+/// Changes the fill of a shape from one colour to another over a
+/// duration.
+///
+/// Without a start colour the transition starts from the fill the shape
+/// has when it is played, which has to be a colour; without an end colour
+/// it ends where it started. The shape is the one set here, or the node
+/// of the transition this one is a child of when that node is a shape.
+public final class FillTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Shape> shape = new SimpleObjectProperty<Shape>(this, "shape");
+    private final ObjectProperty<Color> fromValue = new SimpleObjectProperty<Color>(this, "fromValue");
+    private final ObjectProperty<Color> toValue = new SimpleObjectProperty<Color>(this, "toValue");
+    private Shape target;
+    private Color start;
+    private Color end;
+
+    /// Creates a transition of a shape between two colours.
+    public FillTransition(Duration duration, Shape shape, Color fromValue, Color toValue) {
+        setDuration(duration);
+        setShape(shape);
+        setFromValue(fromValue);
+        setToValue(toValue);
+    }
+
+    /// Creates a transition between two colours.
+    public FillTransition(Duration duration, Color fromValue, Color toValue) {
+        this(duration, null, fromValue, toValue);
+    }
+
+    /// Creates a transition of a shape.
+    public FillTransition(Duration duration, Shape shape) {
+        this(duration, shape, null, null);
+    }
+
+    /// Creates a transition of a duration.
+    public FillTransition(Duration duration) {
+        this(duration, null, null, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public FillTransition() {
+        this(Duration.millis(400), null, null, null);
+    }
+
+    /// Sets how long the change takes.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns how long the change takes.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// How long the change takes.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the shape whose fill changes.
+    public final void setShape(Shape value) {
+        shape.set(value);
+    }
+
+    /// Returns the shape whose fill changes.
+    public final Shape getShape() {
+        return shape.get();
+    }
+
+    /// The shape whose fill changes.
+    public final ObjectProperty<Shape> shapeProperty() {
+        return shape;
+    }
+
+    /// Sets the colour the change starts from.
+    public final void setFromValue(Color value) {
+        fromValue.set(value);
+    }
+
+    /// Returns the colour the change starts from.
+    public final Color getFromValue() {
+        return fromValue.get();
+    }
+
+    /// The colour the change starts from.
+    public final ObjectProperty<Color> fromValueProperty() {
+        return fromValue;
+    }
+
+    /// Sets the colour the change ends at.
+    public final void setToValue(Color value) {
+        toValue.set(value);
+    }
+
+    /// Returns the colour the change ends at.
+    public final Color getToValue() {
+        return toValue.get();
+    }
+
+    /// The colour the change ends at.
+    public final ObjectProperty<Color> toValueProperty() {
+        return toValue;
+    }
+
+    @Override
+    void prepare() {
+        target = getShape();
+        if (target == null) {
+            Node parent = getParentTargetNode();
+            target = parent instanceof Shape ? (Shape) parent : null;
+        }
+        start = null;
+        if (target == null) {
+            return;
+        }
+        Paint now = target.getFill();
+        start = getFromValue() != null ? getFromValue() : (now instanceof Color ? (Color) now : null);
+        end = getToValue() != null ? getToValue() : start;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target != null && start != null && end != null) {
+            target.setFill(start.interpolate(end, frac));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/Interpolatable.java b/maven/javafx-compat/src/main/java/javafx/animation/Interpolatable.java
new file mode 100644
index 00000000000..3560dff368f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/Interpolatable.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+/// A value that can be blended with another of its kind, which is what
+/// lets an animation move between two of them.
+@FunctionalInterface
+public interface Interpolatable<T> {
+
+    /// Returns the value a fraction `t` of the way from this value to
+    /// `endValue`; 0 answers this value and 1 the end value.
+    T interpolate(T endValue, double t);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/Interpolator.java b/maven/javafx-compat/src/main/java/javafx/animation/Interpolator.java
new file mode 100644
index 00000000000..3f656e9484c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/Interpolator.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+/// The pacing of an animation between two values: it maps the fraction
+/// of time that has passed to the fraction of the way the value has
+/// gone.
+///
+/// Numbers are blended, and so are values that implement
+/// [Interpolatable]. Any other value cannot be blended: it stays the
+/// start value until the curve reaches its end and is the end value from
+/// then on.
+public abstract class Interpolator {
+
+    private static final double EPSILON = 1e-12;
+
+    /// Stays at the start value until the very end.
+    public static final Interpolator DISCRETE = new Builtin(Builtin.KIND_DISCRETE, 0, 0, 0, 0);
+
+    /// Moves at a constant speed.
+    public static final Interpolator LINEAR = new Builtin(Builtin.KIND_LINEAR, 0, 0, 0, 0);
+
+    /// Starts slowly, runs at a constant speed and ends slowly; the
+    /// first and the last fifth of the time are spent accelerating and
+    /// decelerating.
+    public static final Interpolator EASE_BOTH = new Builtin(Builtin.KIND_EASE_BOTH, 0, 0, 0, 0);
+
+    /// Starts slowly and then runs at a constant speed.
+    public static final Interpolator EASE_IN = new Builtin(Builtin.KIND_EASE_IN, 0, 0, 0, 0);
+
+    /// Runs at a constant speed and ends slowly.
+    public static final Interpolator EASE_OUT = new Builtin(Builtin.KIND_EASE_OUT, 0, 0, 0, 0);
+
+    /// Creates an interpolator.
+    protected Interpolator() {
+    }
+
+    /// Creates an interpolator that follows a cubic Bezier curve from
+    /// (0, 0) to (1, 1) with the two given control points; all four
+    /// coordinates lie between 0 and 1.
+    public static Interpolator SPLINE(double x1, double y1, double x2, double y2) {
+        return Builtin.spline(x1, y1, x2, y2);
+    }
+
+    /// Returns the value a fraction of the time between two values.
+    /// Numbers and [Interpolatable] values are blended, anything else
+    /// switches to the end value when the curve reaches its end.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public Object interpolate(Object startValue, Object endValue, double fraction) {
+        if (startValue instanceof Number && endValue instanceof Number) {
+            double start = ((Number) startValue).doubleValue();
+            double end = ((Number) endValue).doubleValue();
+            double value = start + (end - start) * curve(fraction);
+            if (startValue instanceof Double || endValue instanceof Double) {
+                return Double.valueOf(value);
+            }
+            if (startValue instanceof Float || endValue instanceof Float) {
+                return Float.valueOf((float) value);
+            }
+            if (startValue instanceof Long || endValue instanceof Long) {
+                return Long.valueOf(Math.round(value));
+            }
+            return Integer.valueOf((int) Math.round(value));
+        }
+        if (startValue instanceof Interpolatable && endValue instanceof Interpolatable) {
+            return ((Interpolatable) startValue).interpolate(endValue, curve(fraction));
+        }
+        return Math.abs(curve(fraction) - 1.0) < EPSILON ? endValue : startValue;
+    }
+
+    /// Returns the start value until the curve reaches its end and the
+    /// end value from then on.
+    public boolean interpolate(boolean startValue, boolean endValue, double fraction) {
+        return Math.abs(curve(fraction) - 1.0) < EPSILON ? endValue : startValue;
+    }
+
+    /// Returns the value a fraction of the time between two numbers.
+    public double interpolate(double startValue, double endValue, double fraction) {
+        return startValue + (endValue - startValue) * curve(fraction);
+    }
+
+    /// Returns the value a fraction of the time between two numbers,
+    /// rounded.
+    public int interpolate(int startValue, int endValue, double fraction) {
+        return startValue + (int) Math.round((endValue - startValue) * curve(fraction));
+    }
+
+    /// Returns the value a fraction of the time between two numbers,
+    /// rounded.
+    public long interpolate(long startValue, long endValue, double fraction) {
+        return startValue + Math.round((endValue - startValue) * curve(fraction));
+    }
+
+    /// Maps the fraction of time that has passed, 0 to 1, to the
+    /// fraction of the way the value has gone.
+    protected abstract double curve(double t);
+
+    /// The interpolators JavaFX provides. The class has no state of its
+    /// own to initialise, only constants the compiler folds, so the
+    /// class above can create its instances while it is itself being
+    /// initialised.
+    private static final class Builtin extends Interpolator {
+
+        private static final int KIND_DISCRETE = 0;
+        private static final int KIND_LINEAR = 1;
+        private static final int KIND_EASE_BOTH = 2;
+        private static final int KIND_EASE_IN = 3;
+        private static final int KIND_EASE_OUT = 4;
+        private static final int KIND_SPLINE = 5;
+
+        // The share of the time spent accelerating or decelerating.
+        private static final double EASE = 0.2;
+
+
+        private final int kind;
+        private final double x1;
+        private final double y1;
+        private final double x2;
+        private final double y2;
+
+        private Builtin(int kind, double x1, double y1, double x2, double y2) {
+            this.kind = kind;
+            this.x1 = x1;
+            this.y1 = y1;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        static Interpolator spline(double x1, double y1, double x2, double y2) {
+            // All four, y included, as OpenJFX's SplineInterpolator checks
+            // them: a y outside [0,1] throws there, so it throws here.
+            if (!(x1 >= 0 && x1 <= 1 && y1 >= 0 && y1 <= 1 && x2 >= 0 && x2 <= 1 && y2 >= 0 && y2 <= 1)) {
+                throw new IllegalArgumentException("Control point coordinates must all be in range [0,1]");
+            }
+            return new Builtin(KIND_SPLINE, x1, y1, x2, y2);
+        }
+
+        private static double clamp(double v) {
+            return v < 0 ? 0 : v > 1 ? 1 : v;
+        }
+
+        /// One coordinate of the Bezier curve with end points 0 and 1.
+        private static double bezier(double a, double b, double s) {
+            double r = 1 - s;
+            return 3 * r * r * s * a + 3 * r * s * s * b + s * s * s;
+        }
+
+        /// The curve is given by its parameter, the animation asks by
+        /// x. x grows with the parameter because both control points lie
+        /// between the ends, so halving the interval finds it.
+        private double splineAt(double t) {
+            double lo = 0;
+            double hi = 1;
+            double s = t;
+            for (int i = 0; i < 60; i++) {
+                double x = bezier(x1, x2, s);
+                if (Math.abs(x - t) < 1e-14) {
+                    break;
+                }
+                if (x < t) {
+                    lo = s;
+                } else {
+                    hi = s;
+                }
+                s = (lo + hi) / 2;
+            }
+            return bezier(y1, y2, s);
+        }
+
+        @Override
+        protected double curve(double t) {
+            switch (kind) {
+                case KIND_DISCRETE:
+                    return Math.abs(t - 1.0) < EPSILON ? 1.0 : 0.0;
+                case KIND_LINEAR:
+                    return t;
+                case KIND_EASE_BOTH:
+                    // Constant acceleration over the first fifth, constant speed,
+                    // constant deceleration over the last fifth: the top speed
+                    // is 1 / (1 - EASE).
+                    if (t < EASE) {
+                        return clamp(3.125 * t * t);
+                    } else if (t > 1 - EASE) {
+                        return clamp(-3.125 * t * t + 6.25 * t - 2.125);
+                    }
+                    return clamp(1.25 * t - 0.125);
+                case KIND_EASE_IN:
+                    // Top speed 1 / (1 - EASE / 2) = 10 / 9.
+                    if (t < EASE) {
+                        return clamp(25.0 / 9.0 * t * t);
+                    }
+                    return clamp(10.0 / 9.0 * t - 1.0 / 9.0);
+                case KIND_EASE_OUT:
+                    if (t > 1 - EASE) {
+                        return clamp(-25.0 / 9.0 * t * t + 50.0 / 9.0 * t - 16.0 / 9.0);
+                    }
+                    return clamp(10.0 / 9.0 * t);
+                case KIND_SPLINE:
+                    return splineAt(clamp(t));
+                default:
+                    return t;
+            }
+        }
+
+        @Override
+        public String toString() {
+            switch (kind) {
+                case KIND_DISCRETE:
+                    return "Interpolator.DISCRETE";
+                case KIND_LINEAR:
+                    return "Interpolator.LINEAR";
+                case KIND_EASE_BOTH:
+                    return "Interpolator.EASE_BOTH";
+                case KIND_EASE_IN:
+                    return "Interpolator.EASE_IN";
+                case KIND_EASE_OUT:
+                    return "Interpolator.EASE_OUT";
+                default:
+                    return "Interpolator.SPLINE [x1=" + x1 + ", y1=" + y1 + ", x2=" + x2 + ", y2=" + y2 + "]";
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/KeyFrame.java b/maven/javafx-compat/src/main/java/javafx/animation/KeyFrame.java
new file mode 100644
index 00000000000..cf526ec4042
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/KeyFrame.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.util.Duration;
+
+/// A point in time on a [Timeline]: the values its targets have reached
+/// by then, and a handler that runs when the timeline passes it.
+public final class KeyFrame {
+
+    private final Duration time;
+    private final Set<KeyValue> values;
+    private final EventHandler<ActionEvent> onFinished;
+    private final String name;
+
+    /// Creates a key frame.
+    public KeyFrame(Duration time, String name, EventHandler<ActionEvent> onFinished, Collection<KeyValue> values) {
+        if (time == null) {
+            throw new NullPointerException("The time has to be specified");
+        }
+        if (time.lessThan(Duration.ZERO) || time.isUnknown()) {
+            throw new IllegalArgumentException("The time is invalid.");
+        }
+        this.time = time;
+        this.name = name;
+        this.onFinished = onFinished;
+        LinkedHashSet<KeyValue> set = new LinkedHashSet<KeyValue>();
+        if (values != null) {
+            for (KeyValue value : values) {
+                if (value != null) {
+                    set.add(value);
+                }
+            }
+        }
+        this.values = Collections.unmodifiableSet(set);
+    }
+
+    /// Creates a key frame.
+    public KeyFrame(Duration time, String name, EventHandler<ActionEvent> onFinished, KeyValue... values) {
+        this(time, name, onFinished, list(values));
+    }
+
+    /// Creates a key frame without a name.
+    public KeyFrame(Duration time, EventHandler<ActionEvent> onFinished, KeyValue... values) {
+        this(time, null, onFinished, list(values));
+    }
+
+    /// Creates a key frame without a handler.
+    public KeyFrame(Duration time, String name, KeyValue... values) {
+        this(time, name, null, list(values));
+    }
+
+    /// Creates a key frame without a name or a handler.
+    public KeyFrame(Duration time, KeyValue... values) {
+        this(time, null, null, list(values));
+    }
+
+    private static Collection<KeyValue> list(KeyValue[] values) {
+        LinkedHashSet<KeyValue> set = new LinkedHashSet<KeyValue>();
+        if (values != null) {
+            for (int i = 0; i < values.length; i++) {
+                set.add(values[i]);
+            }
+        }
+        return set;
+    }
+
+    /// Returns the time of the key frame, from the start of a cycle.
+    public Duration getTime() {
+        return time;
+    }
+
+    /// Returns the values reached at the key frame; the set cannot be
+    /// changed.
+    public Set<KeyValue> getValues() {
+        return values;
+    }
+
+    /// Returns the handler that runs when the timeline passes the key
+    /// frame, or `null`.
+    public EventHandler<ActionEvent> getOnFinished() {
+        return onFinished;
+    }
+
+    /// Returns the name of the key frame, or `null`. A named key frame
+    /// is a cue point of its timeline.
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return "KeyFrame [time=" + time + ", values=" + values + ", onFinished=" + onFinished + ", name=" + name
+                + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/KeyValue.java b/maven/javafx-compat/src/main/java/javafx/animation/KeyValue.java
new file mode 100644
index 00000000000..350642f44dd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/KeyValue.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.value.WritableValue;
+
+/// The value a target has at a key frame, and the pacing with which it
+/// gets there from the key frame before.
+public final class KeyValue {
+
+    private final WritableValue<?> target;
+    private final Object endValue;
+    private final Interpolator interpolator;
+
+    /// Creates a key value.
+    public <T> KeyValue(WritableValue<T> target, T endValue, Interpolator interpolator) {
+        if (target == null) {
+            throw new NullPointerException("The target has to be specified");
+        }
+        if (interpolator == null) {
+            throw new NullPointerException("The interpolator has to be specified");
+        }
+        this.target = target;
+        this.endValue = endValue;
+        this.interpolator = interpolator;
+    }
+
+    /// Creates a key value that is reached at a constant speed.
+    public <T> KeyValue(WritableValue<T> target, T endValue) {
+        this(target, endValue, Interpolator.LINEAR);
+    }
+
+    /// Returns the target that is written.
+    public WritableValue<?> getTarget() {
+        return target;
+    }
+
+    /// Returns the value the target has at the key frame.
+    public Object getEndValue() {
+        return endValue;
+    }
+
+    /// Returns the pacing of the way to the value.
+    public Interpolator getInterpolator() {
+        return interpolator;
+    }
+
+    @Override
+    public String toString() {
+        return "KeyValue [target=" + target + ", endValue=" + endValue + ", interpolator=" + interpolator + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/ParallelTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/ParallelTransition.java
new file mode 100644
index 00000000000..0ae6522dd7d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/ParallelTransition.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+
+/// Plays its children at the same time.
+///
+/// The cycle lasts as long as the longest child, each counted with its
+/// own delay, cycles and rate; a shorter child stays at its end until
+/// the cycle is over. The finished handler of a child runs when it
+/// reaches its end.
+///
+/// The children are read when the transition starts.
+public final class ParallelTransition extends Transition {
+
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private final ObservableList<Animation> children = FXCollections.observableArrayList();
+    private final ChildClips clips = new ChildClips(this, false);
+
+    /// Creates a transition of children for a node.
+    public ParallelTransition(Node node, Animation... children) {
+        setInterpolator(Interpolator.LINEAR);
+        this.children.addListener(new ListChangeListener<Animation>() {
+            @Override
+            public void onChanged(Change<? extends Animation> change) {
+                childrenChanged(change);
+            }
+        });
+        this.node.set(node);
+        if (children != null) {
+            this.children.setAll(children);
+        }
+    }
+
+    /// Creates a transition of children.
+    public ParallelTransition(Animation... children) {
+        this(null, children);
+    }
+
+    /// Creates an empty transition for a node.
+    public ParallelTransition(Node node) {
+        this(node, (Animation[]) null);
+    }
+
+    /// Creates an empty transition.
+    public ParallelTransition() {
+        this((Node) null, (Animation[]) null);
+    }
+
+    /// Sets the node the children animate when they name none
+    /// themselves.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node the children animate when they name none
+    /// themselves.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node the children animate when they name none themselves.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Returns the children, all of which start together. An animation has one
+    /// parent at most: adding one that is a child elsewhere throws
+    /// `IllegalArgumentException`.
+    public final ObservableList<Animation> getChildren() {
+        return children;
+    }
+
+    private void childrenChanged(ListChangeListener.Change<? extends Animation> change) {
+        while (change.next()) {
+            for (Animation removed : change.getRemoved()) {
+                if (removed != null && removed.parent == this) {
+                    removed.parent = null;
+                }
+            }
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Animation child = children.get(i);
+            if (child == null) {
+                continue;
+            }
+            if (child.parent != null && child.parent != this) {
+                throw new IllegalArgumentException("Attempting to add a child that is already in another animation");
+            }
+            if (child.parent == null) {
+                if (child.getStatus() != Status.STOPPED) {
+                    child.stop();
+                }
+                child.parent = this;
+            }
+        }
+        if (root().getStatus() == Status.STOPPED) {
+            syncDuration();
+        }
+    }
+
+    @Override
+    protected Node getParentTargetNode() {
+        Node own = getNode();
+        return own != null ? own : super.getParentTargetNode();
+    }
+
+    /// Does nothing: the children do the animating.
+    @Override
+    protected void interpolate(double frac) {
+    }
+
+    @Override
+    void syncDuration() {
+        double length = clips.layout(children);
+        setCycleDuration(Double.isInfinite(length) ? javafx.util.Duration.INDEFINITE
+                : javafx.util.Duration.millis(length));
+    }
+
+    @Override
+    void doStart(boolean capture) {
+        // The layout was made by the snapshot that precedes every start.
+        clips.start(localMillis(), cycleMillis(), capture);
+    }
+
+    @Override
+    void doPlayTo(double from, double to, boolean forward, boolean atStart) {
+        if (atStart) {
+            clips.rewind(forward);
+        }
+        clips.playTo(to, forward);
+    }
+
+    @Override
+    void doJumpTo(double time) {
+        clips.jumpTo(time);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/PathTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/PathTransition.java
new file mode 100644
index 00000000000..11cf16b4d4f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/PathTransition.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.util.MathUtil;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.geometry.Bounds;
+import javafx.scene.Node;
+import javafx.scene.shape.Shape;
+import javafx.util.Duration;
+
+/// Moves a node along the outline of a shape over time.
+///
+/// The centre of the node's layout bounds follows the outline, through
+/// the node's `translateX` and `translateY`: the outline is read in the
+/// coordinates of the shape, as the coordinates of the node's parent.
+/// With [OrientationType#ORTHOGONAL_TO_TANGENT] the node is turned as
+/// well, through `rotate`, to face along the outline.
+///
+/// The outline is read when the transition starts, curves as short
+/// lines no further than a tenth of a pixel from them. An outline of
+/// several parts is travelled one part after the other, a gap between
+/// two parts taking no time.
+public final class PathTransition extends Transition {
+
+    /// How the node is turned as it moves.
+    public enum OrientationType {
+        /// The node keeps the rotation it has.
+        NONE,
+        /// The node is turned to face along the outline.
+        ORTHOGONAL_TO_TANGENT
+    }
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private final ObjectProperty<Shape> path = new SimpleObjectProperty<Shape>(this, "path");
+    private final ObjectProperty<OrientationType> orientation =
+            new SimpleObjectProperty<OrientationType>(this, "orientation", OrientationType.NONE);
+
+    private Node target;
+    private boolean turn;
+    /// The lines of the outline, four numbers each, and the length
+    /// travelled at the end of each.
+    private double[] lines = new double[0];
+    private double[] travelled = new double[0];
+    private int lineCount;
+    private double pivotX;
+    private double pivotY;
+
+    /// Creates a transition of a length along a shape for a node.
+    public PathTransition(Duration duration, Shape path, Node node) {
+        setDuration(duration);
+        setPath(path);
+        setNode(node);
+    }
+
+    /// Creates a transition of a length along a shape.
+    public PathTransition(Duration duration, Shape path) {
+        this(duration, path, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public PathTransition() {
+        this(Duration.millis(400), null, null);
+    }
+
+    /// Sets the length of the transition. It is read when the
+    /// transition starts.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns the length of the transition.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// The length of the transition; 400 milliseconds unless set.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the node that is moved. Without one the transition moves the
+    /// node of the nearest parent transition that names one. It is read
+    /// when the transition starts.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node that is moved.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node that is moved.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Sets the shape whose outline the node follows. It is read when
+    /// the transition starts.
+    public final void setPath(Shape value) {
+        path.set(value);
+    }
+
+    /// Returns the shape whose outline the node follows.
+    public final Shape getPath() {
+        return path.get();
+    }
+
+    /// The shape whose outline the node follows.
+    public final ObjectProperty<Shape> pathProperty() {
+        return path;
+    }
+
+    /// Sets how the node is turned as it moves.
+    public final void setOrientation(OrientationType value) {
+        orientation.set(value);
+    }
+
+    /// Returns how the node is turned as it moves.
+    public final OrientationType getOrientation() {
+        OrientationType o = orientation.get();
+        return o == null ? OrientationType.NONE : o;
+    }
+
+    /// How the node is turned as it moves; `NONE` unless set.
+    public final ObjectProperty<OrientationType> orientationProperty() {
+        return orientation;
+    }
+
+    @Override
+    void prepare() {
+        target = null;
+        lineCount = 0;
+        Node n = getNode() != null ? getNode() : getParentTargetNode();
+        Shape shape = getPath();
+        if (n == null || shape == null) {
+            return;
+        }
+        FxPath outline = shape.cn1Outline();
+        if (outline == null || outline.isEmpty()) {
+            return;
+        }
+        FxPath flat = outline.flatten(0.1);
+        int commands = flat.commandCount();
+        double[] p = flat.points();
+        lines = new double[commands * 4];
+        travelled = new double[commands];
+        int at = 0;
+        double x = 0;
+        double y = 0;
+        double startX = 0;
+        double startY = 0;
+        double total = 0;
+        for (int i = 0; i < commands; i++) {
+            byte command = flat.command(i);
+            double toX = x;
+            double toY = y;
+            boolean line = false;
+            if (command == FxPath.MOVE) {
+                x = p[at++];
+                y = p[at++];
+                startX = x;
+                startY = y;
+            } else if (command == FxPath.LINE) {
+                toX = p[at++];
+                toY = p[at++];
+                line = true;
+            } else if (command == FxPath.CLOSE) {
+                toX = startX;
+                toY = startY;
+                line = true;
+            } else if (command == FxPath.QUAD) {
+                // A flattened outline has no curve left; were there one, its end is where it leads.
+                at += 2;
+                toX = p[at++];
+                toY = p[at++];
+                line = true;
+            } else if (command == FxPath.CUBIC) {
+                at += 4;
+                toX = p[at++];
+                toY = p[at++];
+                line = true;
+            }
+            if (line) {
+                double dx = toX - x;
+                double dy = toY - y;
+                double length = Math.sqrt(dx * dx + dy * dy);
+                if (length > 0) {
+                    int o = lineCount * 4;
+                    lines[o] = x;
+                    lines[o + 1] = y;
+                    lines[o + 2] = toX;
+                    lines[o + 3] = toY;
+                    total += length;
+                    travelled[lineCount] = total;
+                    lineCount++;
+                }
+                x = toX;
+                y = toY;
+            }
+        }
+        if (lineCount == 0) {
+            // An outline that is one point: the node goes there and stays.
+            lines = new double[] {startX, startY, startX, startY};
+            travelled = new double[] {0};
+            lineCount = 1;
+        }
+        Bounds b = n.getLayoutBounds();
+        pivotX = b.getMinX() + b.getWidth() / 2;
+        pivotY = b.getMinY() + b.getHeight() / 2;
+        turn = getOrientation() == OrientationType.ORTHOGONAL_TO_TANGENT;
+        target = n;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target == null || lineCount == 0) {
+            return;
+        }
+        double total = travelled[lineCount - 1];
+        double f = frac < 0 ? 0 : frac > 1 ? 1 : frac;
+        double want = total * f;
+        // The first line that ends at or beyond the length wanted.
+        int lo = 0;
+        int hi = lineCount - 1;
+        while (lo < hi) {
+            int mid = (lo + hi) >>> 1;
+            if (travelled[mid] < want) {
+                lo = mid + 1;
+            } else {
+                hi = mid;
+            }
+        }
+        int o = lo * 4;
+        double before = lo == 0 ? 0 : travelled[lo - 1];
+        double length = travelled[lo] - before;
+        double along = length <= 0 ? 0 : (want - before) / length;
+        double x1 = lines[o];
+        double y1 = lines[o + 1];
+        double x2 = lines[o + 2];
+        double y2 = lines[o + 3];
+        target.setTranslateX(x1 + (x2 - x1) * along - pivotX);
+        target.setTranslateY(y1 + (y2 - y1) * along - pivotY);
+        if (turn && length > 0) {
+            target.setRotate(Math.toDegrees(MathUtil.atan2(y2 - y1, x2 - x1)));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/PauseTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/PauseTransition.java
new file mode 100644
index 00000000000..257565ef18d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/PauseTransition.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.util.Duration;
+
+/// Does nothing for a length of time and then runs its finished
+/// handler: a timer, and the pause between the children of a
+/// [SequentialTransition].
+public final class PauseTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+
+    /// Creates a pause of a length.
+    public PauseTransition(Duration duration) {
+        setDuration(duration);
+    }
+
+    /// Creates a pause of 400 milliseconds.
+    public PauseTransition() {
+        this(Duration.millis(400));
+    }
+
+    /// Sets the length of the transition. It is read when the
+    /// transition starts.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns the length of the transition.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// The length of the transition; 400 milliseconds unless set.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Does nothing: a pause changes nothing.
+    @Override
+    protected void interpolate(double frac) {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/RotateTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/RotateTransition.java
new file mode 100644
index 00000000000..efded1b4d91
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/RotateTransition.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+/// Turns a node over time by animating its `rotate` angle, in degrees.
+///
+/// The start is the `from` value, or what the node has when the
+/// transition starts. The end is the `to` value, or the start moved by
+/// the `by` value. All of them are read when the transition starts.
+/// The node turns in its own plane; there is no rotation axis.
+public final class RotateTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private Node target;
+    private final DoubleProperty fromAngle = new SimpleDoubleProperty(this, "fromAngle", Double.NaN);
+    private final DoubleProperty toAngle = new SimpleDoubleProperty(this, "toAngle", Double.NaN);
+    private final DoubleProperty byAngle = new SimpleDoubleProperty(this, "byAngle", 0.0);
+    private double startAngle;
+    private double deltaAngle;
+
+    /// Creates a transition of a length for a node.
+    public RotateTransition(Duration duration, Node node) {
+        setDuration(duration);
+        setNode(node);
+    }
+
+    /// Creates a transition of a length.
+    public RotateTransition(Duration duration) {
+        this(duration, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public RotateTransition() {
+        this(Duration.millis(400), null);
+    }
+
+    /// Sets the length of the transition. It is read when the
+    /// transition starts.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns the length of the transition.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// The length of the transition; 400 milliseconds unless set.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the node that is animated. Without one the transition
+    /// animates the node of the nearest parent transition that names
+    /// one. It is read when the transition starts.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node that is animated.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node that is animated.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Sets the angle the transition starts at; not a number, the default, starts at what the node has.
+    public final void setFromAngle(double value) {
+        fromAngle.set(value);
+    }
+
+    /// Returns the angle the transition starts at; not a number, the default, starts at what the node has.
+    public final double getFromAngle() {
+        return fromAngle.get();
+    }
+
+    /// The angle the transition starts at; not a number, the default, starts at what the node has.
+    public final DoubleProperty fromAngleProperty() {
+        return fromAngle;
+    }
+
+    /// Sets the angle the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final void setToAngle(double value) {
+        toAngle.set(value);
+    }
+
+    /// Returns the angle the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final double getToAngle() {
+        return toAngle.get();
+    }
+
+    /// The angle the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final DoubleProperty toAngleProperty() {
+        return toAngle;
+    }
+
+    /// Sets how far the angle moves from its start; used when no `to` value is set.
+    public final void setByAngle(double value) {
+        byAngle.set(value);
+    }
+
+    /// Returns how far the angle moves from its start; used when no `to` value is set.
+    public final double getByAngle() {
+        return byAngle.get();
+    }
+
+    /// How far the angle moves from its start; used when no `to` value is set.
+    public final DoubleProperty byAngleProperty() {
+        return byAngle;
+    }
+
+    @Override
+    void prepare() {
+        target = getNode() != null ? getNode() : getParentTargetNode();
+        if (target == null) {
+            return;
+        }
+        double fromAngle = getFromAngle();
+        double toAngle = getToAngle();
+        startAngle = Double.isNaN(fromAngle) ? target.getRotate() : fromAngle;
+        deltaAngle = Double.isNaN(toAngle) ? getByAngle() : toAngle - startAngle;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target != null) {
+            target.setRotate(startAngle + frac * deltaAngle);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/ScaleTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/ScaleTransition.java
new file mode 100644
index 00000000000..e93c820fe64
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/ScaleTransition.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+/// Resizes a node over time by animating its `scaleX` and `scaleY`.
+///
+/// The start is the `from` value, or what the node has when the
+/// transition starts. The end is the `to` value, or the start moved by
+/// the `by` value. All of them are read when the transition starts.
+/// There is no third axis.
+public final class ScaleTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private Node target;
+    private final DoubleProperty fromX = new SimpleDoubleProperty(this, "fromX", Double.NaN);
+    private final DoubleProperty toX = new SimpleDoubleProperty(this, "toX", Double.NaN);
+    private final DoubleProperty byX = new SimpleDoubleProperty(this, "byX", 0.0);
+    private double startX;
+    private double deltaX;
+    private final DoubleProperty fromY = new SimpleDoubleProperty(this, "fromY", Double.NaN);
+    private final DoubleProperty toY = new SimpleDoubleProperty(this, "toY", Double.NaN);
+    private final DoubleProperty byY = new SimpleDoubleProperty(this, "byY", 0.0);
+    private double startY;
+    private double deltaY;
+
+    /// Creates a transition of a length for a node.
+    public ScaleTransition(Duration duration, Node node) {
+        setDuration(duration);
+        setNode(node);
+    }
+
+    /// Creates a transition of a length.
+    public ScaleTransition(Duration duration) {
+        this(duration, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public ScaleTransition() {
+        this(Duration.millis(400), null);
+    }
+
+    /// Sets the length of the transition. It is read when the
+    /// transition starts.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns the length of the transition.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// The length of the transition; 400 milliseconds unless set.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the node that is animated. Without one the transition
+    /// animates the node of the nearest parent transition that names
+    /// one. It is read when the transition starts.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node that is animated.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node that is animated.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Sets the X scale the transition starts at; not a number, the default, starts at what the node has.
+    public final void setFromX(double value) {
+        fromX.set(value);
+    }
+
+    /// Returns the X scale the transition starts at; not a number, the default, starts at what the node has.
+    public final double getFromX() {
+        return fromX.get();
+    }
+
+    /// The X scale the transition starts at; not a number, the default, starts at what the node has.
+    public final DoubleProperty fromXProperty() {
+        return fromX;
+    }
+
+    /// Sets the X scale the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final void setToX(double value) {
+        toX.set(value);
+    }
+
+    /// Returns the X scale the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final double getToX() {
+        return toX.get();
+    }
+
+    /// The X scale the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final DoubleProperty toXProperty() {
+        return toX;
+    }
+
+    /// Sets how far the X scale moves from its start; used when no `to` value is set.
+    public final void setByX(double value) {
+        byX.set(value);
+    }
+
+    /// Returns how far the X scale moves from its start; used when no `to` value is set.
+    public final double getByX() {
+        return byX.get();
+    }
+
+    /// How far the X scale moves from its start; used when no `to` value is set.
+    public final DoubleProperty byXProperty() {
+        return byX;
+    }
+
+    /// Sets the Y scale the transition starts at; not a number, the default, starts at what the node has.
+    public final void setFromY(double value) {
+        fromY.set(value);
+    }
+
+    /// Returns the Y scale the transition starts at; not a number, the default, starts at what the node has.
+    public final double getFromY() {
+        return fromY.get();
+    }
+
+    /// The Y scale the transition starts at; not a number, the default, starts at what the node has.
+    public final DoubleProperty fromYProperty() {
+        return fromY;
+    }
+
+    /// Sets the Y scale the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final void setToY(double value) {
+        toY.set(value);
+    }
+
+    /// Returns the Y scale the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final double getToY() {
+        return toY.get();
+    }
+
+    /// The Y scale the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final DoubleProperty toYProperty() {
+        return toY;
+    }
+
+    /// Sets how far the Y scale moves from its start; used when no `to` value is set.
+    public final void setByY(double value) {
+        byY.set(value);
+    }
+
+    /// Returns how far the Y scale moves from its start; used when no `to` value is set.
+    public final double getByY() {
+        return byY.get();
+    }
+
+    /// How far the Y scale moves from its start; used when no `to` value is set.
+    public final DoubleProperty byYProperty() {
+        return byY;
+    }
+
+    @Override
+    void prepare() {
+        target = getNode() != null ? getNode() : getParentTargetNode();
+        if (target == null) {
+            return;
+        }
+        double fromX = getFromX();
+        double toX = getToX();
+        startX = Double.isNaN(fromX) ? target.getScaleX() : fromX;
+        deltaX = Double.isNaN(toX) ? getByX() : toX - startX;
+        double fromY = getFromY();
+        double toY = getToY();
+        startY = Double.isNaN(fromY) ? target.getScaleY() : fromY;
+        deltaY = Double.isNaN(toY) ? getByY() : toY - startY;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target != null) {
+            target.setScaleX(startX + frac * deltaX);
+            target.setScaleY(startY + frac * deltaY);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/SequentialTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/SequentialTransition.java
new file mode 100644
index 00000000000..e5388d188fe
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/SequentialTransition.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+
+/// Plays its children one after the other, in the order of the list.
+///
+/// The cycle lasts as long as all children together, each counted with
+/// its own delay, cycles and rate. A child starts from what the
+/// children before it left behind. The finished handler of a child
+/// runs when the playhead leaves it.
+///
+/// The children are read when the transition starts.
+public final class SequentialTransition extends Transition {
+
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private final ObservableList<Animation> children = FXCollections.observableArrayList();
+    private final ChildClips clips = new ChildClips(this, true);
+
+    /// Creates a transition of children for a node.
+    public SequentialTransition(Node node, Animation... children) {
+        setInterpolator(Interpolator.LINEAR);
+        this.children.addListener(new ListChangeListener<Animation>() {
+            @Override
+            public void onChanged(Change<? extends Animation> change) {
+                childrenChanged(change);
+            }
+        });
+        this.node.set(node);
+        if (children != null) {
+            this.children.setAll(children);
+        }
+    }
+
+    /// Creates a transition of children.
+    public SequentialTransition(Animation... children) {
+        this(null, children);
+    }
+
+    /// Creates an empty transition for a node.
+    public SequentialTransition(Node node) {
+        this(node, (Animation[]) null);
+    }
+
+    /// Creates an empty transition.
+    public SequentialTransition() {
+        this((Node) null, (Animation[]) null);
+    }
+
+    /// Sets the node the children animate when they name none
+    /// themselves.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node the children animate when they name none
+    /// themselves.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node the children animate when they name none themselves.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Returns the children, in the order they are played. An animation has one
+    /// parent at most: adding one that is a child elsewhere throws
+    /// `IllegalArgumentException`.
+    public final ObservableList<Animation> getChildren() {
+        return children;
+    }
+
+    private void childrenChanged(ListChangeListener.Change<? extends Animation> change) {
+        while (change.next()) {
+            for (Animation removed : change.getRemoved()) {
+                if (removed != null && removed.parent == this) {
+                    removed.parent = null;
+                }
+            }
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Animation child = children.get(i);
+            if (child == null) {
+                continue;
+            }
+            if (child.parent != null && child.parent != this) {
+                throw new IllegalArgumentException("Attempting to add a child that is already in another animation");
+            }
+            if (child.parent == null) {
+                if (child.getStatus() != Status.STOPPED) {
+                    child.stop();
+                }
+                child.parent = this;
+            }
+        }
+        if (root().getStatus() == Status.STOPPED) {
+            syncDuration();
+        }
+    }
+
+    @Override
+    protected Node getParentTargetNode() {
+        Node own = getNode();
+        return own != null ? own : super.getParentTargetNode();
+    }
+
+    /// Does nothing: the children do the animating.
+    @Override
+    protected void interpolate(double frac) {
+    }
+
+    @Override
+    void syncDuration() {
+        double length = clips.layout(children);
+        setCycleDuration(Double.isInfinite(length) ? javafx.util.Duration.INDEFINITE
+                : javafx.util.Duration.millis(length));
+    }
+
+    @Override
+    void doStart(boolean capture) {
+        // The layout was made by the snapshot that precedes every start.
+        clips.start(localMillis(), cycleMillis(), capture);
+    }
+
+    @Override
+    void doPlayTo(double from, double to, boolean forward, boolean atStart) {
+        if (atStart) {
+            clips.rewind(forward);
+        }
+        clips.playTo(to, forward);
+    }
+
+    @Override
+    void doJumpTo(double time) {
+        clips.jumpTo(time);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/StrokeTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/StrokeTransition.java
new file mode 100644
index 00000000000..d340b094abd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/StrokeTransition.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Shape;
+import javafx.util.Duration;
+
+/// Changes the stroke of a shape from one colour to another over a
+/// duration.
+///
+/// Without a start colour the transition starts from the stroke the shape
+/// has when it is played, which has to be a colour; without an end colour
+/// it ends where it started. The shape is the one set here, or the node
+/// of the transition this one is a child of when that node is a shape.
+public final class StrokeTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Shape> shape = new SimpleObjectProperty<Shape>(this, "shape");
+    private final ObjectProperty<Color> fromValue = new SimpleObjectProperty<Color>(this, "fromValue");
+    private final ObjectProperty<Color> toValue = new SimpleObjectProperty<Color>(this, "toValue");
+    private Shape target;
+    private Color start;
+    private Color end;
+
+    /// Creates a transition of a shape between two colours.
+    public StrokeTransition(Duration duration, Shape shape, Color fromValue, Color toValue) {
+        setDuration(duration);
+        setShape(shape);
+        setFromValue(fromValue);
+        setToValue(toValue);
+    }
+
+    /// Creates a transition between two colours.
+    public StrokeTransition(Duration duration, Color fromValue, Color toValue) {
+        this(duration, null, fromValue, toValue);
+    }
+
+    /// Creates a transition of a shape.
+    public StrokeTransition(Duration duration, Shape shape) {
+        this(duration, shape, null, null);
+    }
+
+    /// Creates a transition of a duration.
+    public StrokeTransition(Duration duration) {
+        this(duration, null, null, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public StrokeTransition() {
+        this(Duration.millis(400), null, null, null);
+    }
+
+    /// Sets how long the change takes.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns how long the change takes.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// How long the change takes.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the shape whose stroke changes.
+    public final void setShape(Shape value) {
+        shape.set(value);
+    }
+
+    /// Returns the shape whose stroke changes.
+    public final Shape getShape() {
+        return shape.get();
+    }
+
+    /// The shape whose stroke changes.
+    public final ObjectProperty<Shape> shapeProperty() {
+        return shape;
+    }
+
+    /// Sets the colour the change starts from.
+    public final void setFromValue(Color value) {
+        fromValue.set(value);
+    }
+
+    /// Returns the colour the change starts from.
+    public final Color getFromValue() {
+        return fromValue.get();
+    }
+
+    /// The colour the change starts from.
+    public final ObjectProperty<Color> fromValueProperty() {
+        return fromValue;
+    }
+
+    /// Sets the colour the change ends at.
+    public final void setToValue(Color value) {
+        toValue.set(value);
+    }
+
+    /// Returns the colour the change ends at.
+    public final Color getToValue() {
+        return toValue.get();
+    }
+
+    /// The colour the change ends at.
+    public final ObjectProperty<Color> toValueProperty() {
+        return toValue;
+    }
+
+    @Override
+    void prepare() {
+        target = getShape();
+        if (target == null) {
+            Node parent = getParentTargetNode();
+            target = parent instanceof Shape ? (Shape) parent : null;
+        }
+        start = null;
+        if (target == null) {
+            return;
+        }
+        Paint now = target.getStroke();
+        start = getFromValue() != null ? getFromValue() : (now instanceof Color ? (Color) now : null);
+        end = getToValue() != null ? getToValue() : start;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target != null && start != null && end != null) {
+            target.setStroke(start.interpolate(end, frac));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/Timeline.java b/maven/javafx-compat/src/main/java/javafx/animation/Timeline.java
new file mode 100644
index 00000000000..bf9b2bab754
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/Timeline.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import java.util.ArrayList;
+
+import javafx.beans.value.WritableBooleanValue;
+import javafx.beans.value.WritableDoubleValue;
+import javafx.beans.value.WritableFloatValue;
+import javafx.beans.value.WritableIntegerValue;
+import javafx.beans.value.WritableLongValue;
+import javafx.beans.value.WritableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.util.Duration;
+
+/// An animation described by key frames: at the time of each key frame
+/// its targets have the values it names, and in between they are
+/// interpolated.
+///
+/// A target with a key frame at time zero starts from that value. One
+/// without starts from the value it has when the timeline is played,
+/// which is read once, at that moment.
+///
+/// The handler of a key frame runs when the playhead passes the key
+/// frame, once per cycle and in either direction. A frame that takes
+/// the playhead past several key frames runs all their handlers, in the
+/// order the playhead passed them, and each sees the targets as they
+/// are at its own key frame.
+///
+/// The cycle lasts until the last key frame. The key frames are read
+/// when the timeline starts; changing them while it runs takes effect
+/// the next time it is played.
+///
+/// Differences from JavaFX: a timeline whose last key frame is at time
+/// zero is played like any other, so its values are written, its
+/// handlers run and it finishes, all on the next frame, where JavaFX
+/// only runs the finished handler from inside `play()`. A frame rate
+/// cannot be asked for; the timeline follows the display.
+public final class Timeline extends Animation {
+
+    /// One target and its values over the cycle.
+    private static final class Track {
+        WritableValue<?> target;
+        Object startValue;
+        final ArrayList<KeyValue> values = new ArrayList<KeyValue>();
+        final ArrayList<Double> times = new ArrayList<Double>();
+    }
+
+    private final ObservableList<KeyFrame> keyFrames = FXCollections.observableArrayList();
+    private KeyFrame[] frames = new KeyFrame[0];
+    private double[] frameTimes = new double[0];
+    private final ArrayList<Track> tracks = new ArrayList<Track>();
+
+    /// Creates a timeline of key frames.
+    public Timeline(KeyFrame... keyFrames) {
+        this.keyFrames.addListener(new ListChangeListener<KeyFrame>() {
+            @Override
+            public void onChanged(Change<? extends KeyFrame> change) {
+                keyFramesChanged(change);
+            }
+        });
+        if (keyFrames != null) {
+            this.keyFrames.setAll(keyFrames);
+        }
+    }
+
+    /// Creates an empty timeline.
+    public Timeline() {
+        this((KeyFrame[]) null);
+    }
+
+    /// Returns the key frames. A key frame with a name is also a cue
+    /// point of the timeline.
+    public final ObservableList<KeyFrame> getKeyFrames() {
+        return keyFrames;
+    }
+
+    private void keyFramesChanged(ListChangeListener.Change<? extends KeyFrame> change) {
+        while (change.next()) {
+            for (KeyFrame removed : change.getRemoved()) {
+                String name = removed.getName();
+                if (name != null) {
+                    getCuePoints().remove(name);
+                }
+            }
+            for (KeyFrame added : change.getAddedSubList()) {
+                String name = added.getName();
+                if (name != null) {
+                    getCuePoints().put(name, added.getTime());
+                }
+            }
+        }
+        syncDuration();
+    }
+
+    @Override
+    void syncDuration() {
+        Duration longest = Duration.ZERO;
+        for (int i = 0; i < keyFrames.size(); i++) {
+            KeyFrame frame = keyFrames.get(i);
+            if (frame != null && frame.getTime().greaterThan(longest)) {
+                longest = frame.getTime();
+            }
+        }
+        setCycleDuration(longest);
+    }
+
+    private Track track(WritableValue<?> target) {
+        for (int i = 0; i < tracks.size(); i++) {
+            Track t = tracks.get(i);
+            if (t.target == target) {
+                return t;
+            }
+        }
+        Track t = new Track();
+        t.target = target;
+        t.startValue = target.getValue();
+        tracks.add(t);
+        return t;
+    }
+
+    @Override
+    void doStart(boolean capture) {
+        if (!capture) {
+            return;
+        }
+        // Sorted by time; key frames of the same time keep their order.
+        ArrayList<KeyFrame> sorted = new ArrayList<KeyFrame>();
+        for (int i = 0; i < keyFrames.size(); i++) {
+            KeyFrame frame = keyFrames.get(i);
+            if (frame == null) {
+                continue;
+            }
+            int at = sorted.size();
+            while (at > 0 && sorted.get(at - 1).getTime().greaterThan(frame.getTime())) {
+                at--;
+            }
+            sorted.add(at, frame);
+        }
+        frames = sorted.toArray(new KeyFrame[sorted.size()]);
+        frameTimes = new double[frames.length];
+        tracks.clear();
+        for (int i = 0; i < frames.length; i++) {
+            double time = frames[i].getTime().toMillis();
+            frameTimes[i] = time;
+            for (KeyValue value : frames[i].getValues()) {
+                Track t = track(value.getTarget());
+                int last = t.values.size() - 1;
+                if (last >= 0 && Double.compare(t.times.get(last).doubleValue(), time) == 0) {
+                    // Two values for one target at one time: the later wins.
+                    t.values.set(last, value);
+                } else {
+                    t.values.add(value);
+                    t.times.add(Double.valueOf(time));
+                }
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void write(WritableValue<?> target, Object from, KeyValue to, double fraction) {
+        Interpolator interpolator = to.getInterpolator();
+        Object end = to.getEndValue();
+        boolean numbers = from instanceof Number && end instanceof Number;
+        if (numbers && target instanceof WritableDoubleValue) {
+            ((WritableDoubleValue) target).set(interpolator.interpolate(((Number) from).doubleValue(),
+                    ((Number) end).doubleValue(), fraction));
+        } else if (numbers && target instanceof WritableFloatValue) {
+            ((WritableFloatValue) target).set((float) interpolator.interpolate(((Number) from).doubleValue(),
+                    ((Number) end).doubleValue(), fraction));
+        } else if (numbers && target instanceof WritableIntegerValue) {
+            ((WritableIntegerValue) target).set(interpolator.interpolate(((Number) from).intValue(),
+                    ((Number) end).intValue(), fraction));
+        } else if (numbers && target instanceof WritableLongValue) {
+            ((WritableLongValue) target).set(interpolator.interpolate(((Number) from).longValue(),
+                    ((Number) end).longValue(), fraction));
+        } else if (from instanceof Boolean && end instanceof Boolean && target instanceof WritableBooleanValue) {
+            ((WritableBooleanValue) target).set(interpolator.interpolate(((Boolean) from).booleanValue(),
+                    ((Boolean) end).booleanValue(), fraction));
+        } else {
+            ((WritableValue<Object>) target).setValue(interpolator.interpolate(from, end, fraction));
+        }
+    }
+
+    /// Writes every target as it is at a time of the cycle.
+    private void apply(double time) {
+        for (int i = 0; i < tracks.size(); i++) {
+            Track t = tracks.get(i);
+            int count = t.values.size();
+            int next = 0;
+            while (next < count && t.times.get(next).doubleValue() <= time) {
+                next++;
+            }
+            if (next == count) {
+                KeyValue last = t.values.get(count - 1);
+                write(t.target, last.getEndValue(), last, 1.0);
+                continue;
+            }
+            double leftTime = next == 0 ? 0 : t.times.get(next - 1).doubleValue();
+            Object leftValue = next == 0 ? t.startValue : t.values.get(next - 1).getEndValue();
+            double length = t.times.get(next).doubleValue() - leftTime;
+            double fraction = length <= 0 ? 1.0 : (time - leftTime) / length;
+            write(t.target, leftValue, t.values.get(next), fraction < 0 ? 0 : fraction);
+        }
+    }
+
+    private boolean visit(int index, Animation top, int started) {
+        EventHandler<ActionEvent> handler = frames[index].getOnFinished();
+        if (handler != null) {
+            apply(frameTimes[index]);
+            handler.handle(new ActionEvent(frames[index], null));
+        }
+        return top.token == started;
+    }
+
+    @Override
+    void doPlayTo(double from, double to, boolean forward, boolean atStart) {
+        Animation top = root();
+        int started = top.token;
+        if (forward) {
+            for (int i = 0; i < frames.length; i++) {
+                double time = frameTimes[i];
+                boolean passed = time > from && time <= to;
+                if ((passed || atStart && Double.compare(time, from) == 0) && !visit(i, top, started)) {
+                    return;
+                }
+            }
+        } else {
+            for (int i = frames.length - 1; i >= 0; i--) {
+                double time = frameTimes[i];
+                boolean passed = time < from && time >= to;
+                if ((passed || atStart && Double.compare(time, from) == 0) && !visit(i, top, started)) {
+                    return;
+                }
+            }
+        }
+        apply(to);
+    }
+
+    @Override
+    void doJumpTo(double time) {
+        apply(time);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/Transition.java b/maven/javafx-compat/src/main/java/javafx/animation/Transition.java
new file mode 100644
index 00000000000..a6ca07ae015
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/Transition.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+
+/// An animation that is told, on every frame, how far through its cycle
+/// it is: a subclass sets its cycle duration and implements
+/// [#interpolate(double)].
+///
+/// The fraction of the cycle that has passed goes through the
+/// [interpolator][#interpolatorProperty()] first, so a transition eases
+/// in and out unless it is told otherwise. The interpolator is read
+/// when the transition starts.
+///
+/// A frame rate cannot be asked for; a transition follows the display.
+public abstract class Transition extends Animation {
+
+    private final ObjectProperty<Interpolator> interpolator =
+            new SimpleObjectProperty<Interpolator>(this, "interpolator", Interpolator.EASE_BOTH);
+    private Interpolator cachedInterpolator = Interpolator.EASE_BOTH;
+
+    /// Creates a transition.
+    public Transition() {
+    }
+
+    /// Sets the pacing of the transition.
+    public final void setInterpolator(Interpolator value) {
+        interpolator.set(value);
+    }
+
+    /// Returns the pacing of the transition.
+    public final Interpolator getInterpolator() {
+        return interpolator.get();
+    }
+
+    /// The pacing of the transition; `EASE_BOTH` unless set.
+    public final ObjectProperty<Interpolator> interpolatorProperty() {
+        return interpolator;
+    }
+
+    /// Returns the interpolator the transition was started with.
+    protected Interpolator getCachedInterpolator() {
+        return cachedInterpolator;
+    }
+
+    /// Returns the node of the nearest parent transition that names
+    /// one, for a transition that names none itself; `null` when there
+    /// is none.
+    protected Node getParentTargetNode() {
+        if (parent instanceof Transition) {
+            return ((Transition) parent).getParentTargetNode();
+        }
+        return null;
+    }
+
+    /// Shows the transition a fraction of the way through its cycle: 0
+    /// at the start, 1 at the end.
+    protected abstract void interpolate(double frac);
+
+    /// Reads what the transition starts from; called as it starts.
+    void prepare() {
+    }
+
+    private double fraction(double time) {
+        double length = cycleMillis();
+        double f = length <= 0 || Double.isInfinite(length) ? 1.0 : time / length;
+        f = f < 0 ? 0 : f > 1 ? 1 : f;
+        Interpolator i = cachedInterpolator == null ? Interpolator.LINEAR : cachedInterpolator;
+        return i.interpolate(0.0, 1.0, f);
+    }
+
+    @Override
+    void doStart(boolean capture) {
+        if (capture) {
+            cachedInterpolator = getInterpolator();
+            prepare();
+        }
+    }
+
+    @Override
+    void doPlayTo(double from, double to, boolean forward, boolean atStart) {
+        interpolate(fraction(to));
+    }
+
+    @Override
+    void doJumpTo(double time) {
+        interpolate(fraction(time));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/TranslateTransition.java b/maven/javafx-compat/src/main/java/javafx/animation/TranslateTransition.java
new file mode 100644
index 00000000000..fc96f106c2c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/TranslateTransition.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.animation;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.util.Duration;
+
+/// Moves a node over time by animating its `translateX` and
+/// `translateY`.
+///
+/// The start is the `from` value, or what the node has when the
+/// transition starts. The end is the `to` value, or the start moved by
+/// the `by` value. All of them are read when the transition starts.
+/// There is no third axis.
+public final class TranslateTransition extends Transition {
+
+    private final ObjectProperty<Duration> duration =
+            new SimpleObjectProperty<Duration>(this, "duration", Duration.millis(400));
+    private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+    private Node target;
+    private final DoubleProperty fromX = new SimpleDoubleProperty(this, "fromX", Double.NaN);
+    private final DoubleProperty toX = new SimpleDoubleProperty(this, "toX", Double.NaN);
+    private final DoubleProperty byX = new SimpleDoubleProperty(this, "byX", 0.0);
+    private double startX;
+    private double deltaX;
+    private final DoubleProperty fromY = new SimpleDoubleProperty(this, "fromY", Double.NaN);
+    private final DoubleProperty toY = new SimpleDoubleProperty(this, "toY", Double.NaN);
+    private final DoubleProperty byY = new SimpleDoubleProperty(this, "byY", 0.0);
+    private double startY;
+    private double deltaY;
+
+    /// Creates a transition of a length for a node.
+    public TranslateTransition(Duration duration, Node node) {
+        setDuration(duration);
+        setNode(node);
+    }
+
+    /// Creates a transition of a length.
+    public TranslateTransition(Duration duration) {
+        this(duration, null);
+    }
+
+    /// Creates a transition of 400 milliseconds.
+    public TranslateTransition() {
+        this(Duration.millis(400), null);
+    }
+
+    /// Sets the length of the transition. It is read when the
+    /// transition starts.
+    public final void setDuration(Duration value) {
+        if (value == null) {
+            throw new NullPointerException("Duration must not be null");
+        }
+        if (value.lessThan(Duration.ZERO) || value.isUnknown()) {
+            throw new IllegalArgumentException("Cannot set duration to negative value.");
+        }
+        duration.set(value);
+    }
+
+    /// Returns the length of the transition.
+    public final Duration getDuration() {
+        return duration.get();
+    }
+
+    /// The length of the transition; 400 milliseconds unless set.
+    public final ObjectProperty<Duration> durationProperty() {
+        return duration;
+    }
+
+    @Override
+    void syncDuration() {
+        Duration d = duration.get();
+        setCycleDuration(d == null || d.lessThan(Duration.ZERO) || d.isUnknown() ? Duration.ZERO : d);
+    }
+
+    /// Sets the node that is animated. Without one the transition
+    /// animates the node of the nearest parent transition that names
+    /// one. It is read when the transition starts.
+    public final void setNode(Node value) {
+        node.set(value);
+    }
+
+    /// Returns the node that is animated.
+    public final Node getNode() {
+        return node.get();
+    }
+
+    /// The node that is animated.
+    public final ObjectProperty<Node> nodeProperty() {
+        return node;
+    }
+
+    /// Sets the X translation the transition starts at; not a number, the default, starts at what the node has.
+    public final void setFromX(double value) {
+        fromX.set(value);
+    }
+
+    /// Returns the X translation the transition starts at; not a number, the default, starts at what the node has.
+    public final double getFromX() {
+        return fromX.get();
+    }
+
+    /// The X translation the transition starts at; not a number, the default, starts at what the node has.
+    public final DoubleProperty fromXProperty() {
+        return fromX;
+    }
+
+    /// Sets the X translation the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final void setToX(double value) {
+        toX.set(value);
+    }
+
+    /// Returns the X translation the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final double getToX() {
+        return toX.get();
+    }
+
+    /// The X translation the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final DoubleProperty toXProperty() {
+        return toX;
+    }
+
+    /// Sets how far the X translation moves from its start; used when no `to` value is set.
+    public final void setByX(double value) {
+        byX.set(value);
+    }
+
+    /// Returns how far the X translation moves from its start; used when no `to` value is set.
+    public final double getByX() {
+        return byX.get();
+    }
+
+    /// How far the X translation moves from its start; used when no `to` value is set.
+    public final DoubleProperty byXProperty() {
+        return byX;
+    }
+
+    /// Sets the Y translation the transition starts at; not a number, the default, starts at what the node has.
+    public final void setFromY(double value) {
+        fromY.set(value);
+    }
+
+    /// Returns the Y translation the transition starts at; not a number, the default, starts at what the node has.
+    public final double getFromY() {
+        return fromY.get();
+    }
+
+    /// The Y translation the transition starts at; not a number, the default, starts at what the node has.
+    public final DoubleProperty fromYProperty() {
+        return fromY;
+    }
+
+    /// Sets the Y translation the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final void setToY(double value) {
+        toY.set(value);
+    }
+
+    /// Returns the Y translation the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final double getToY() {
+        return toY.get();
+    }
+
+    /// The Y translation the transition ends at; not a number, the default, leaves the end to the `by` value.
+    public final DoubleProperty toYProperty() {
+        return toY;
+    }
+
+    /// Sets how far the Y translation moves from its start; used when no `to` value is set.
+    public final void setByY(double value) {
+        byY.set(value);
+    }
+
+    /// Returns how far the Y translation moves from its start; used when no `to` value is set.
+    public final double getByY() {
+        return byY.get();
+    }
+
+    /// How far the Y translation moves from its start; used when no `to` value is set.
+    public final DoubleProperty byYProperty() {
+        return byY;
+    }
+
+    @Override
+    void prepare() {
+        target = getNode() != null ? getNode() : getParentTargetNode();
+        if (target == null) {
+            return;
+        }
+        double fromX = getFromX();
+        double toX = getToX();
+        startX = Double.isNaN(fromX) ? target.getTranslateX() : fromX;
+        deltaX = Double.isNaN(toX) ? getByX() : toX - startX;
+        double fromY = getFromY();
+        double toY = getToY();
+        startY = Double.isNaN(fromY) ? target.getTranslateY() : fromY;
+        deltaY = Double.isNaN(toY) ? getByY() : toY - startY;
+    }
+
+    @Override
+    protected void interpolate(double frac) {
+        if (target != null) {
+            target.setTranslateX(startX + frac * deltaX);
+            target.setTranslateY(startY + frac * deltaY);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/animation/package-info.java b/maven/javafx-compat/src/main/java/javafx/animation/package-info.java
new file mode 100644
index 00000000000..0ea41192ef3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/animation/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Animation: timelines, transitions and the frame timer.
+package javafx.animation;
diff --git a/maven/javafx-compat/src/main/java/javafx/application/Application.java b/maven/javafx-compat/src/main/java/javafx/application/Application.java
new file mode 100644
index 00000000000..0aa3c59809a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/application/Application.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.application;
+
+import javafx.stage.Stage;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// The class a JavaFX application extends.
+///
+/// On Codename One the application is not launched from a `main` method:
+/// `com.codename1.fxcompat.runtime.FxLifecycle` creates it and calls
+/// [#init()], [#start(Stage)] and [#stop()], all on the JavaFX
+/// application thread. The application's `main` is never called, so
+/// [#launch(String...)] is never reached from it; see there for what it
+/// does when something else calls it. The user agent style sheet is not
+/// part of this layer.
+public abstract class Application {
+
+    private HostServices hostServices;
+
+    /// Creates the application.
+    public Application() {
+    }
+
+    /// Does nothing. On a desktop this creates the application and blocks
+    /// until it exits; here the lifecycle has already created the
+    /// application and started it before any application code runs, so by
+    /// the time this can be called there is nothing left to launch. It
+    /// returns at once, and the application that is running goes on.
+    public static void launch(String... args) {
+        // Deliberately empty: see the comment above.
+    }
+
+    /// Does nothing, as [#launch(String...)]: the application class is
+    /// named to the build, which starts it, and not looked up here.
+    public static void launch(Class<? extends Application> appClass, String... args) {
+        // Deliberately empty: see the comment above.
+    }
+
+    /// The command line of the application, which on a device has none:
+    /// every list and the map are empty and cannot be changed.
+    public final Parameters getParameters() {
+        return new EmptyParameters();
+    }
+
+    /// The services of the platform the application runs on.
+    public final HostServices getHostServices() {
+        if (hostServices == null) {
+            hostServices = new HostServices();
+        }
+        return hostServices;
+    }
+
+    /// Called once before [#start(Stage)]; does nothing unless overridden.
+    public void init() throws Exception {
+    }
+
+    /// Called once with the primary stage; builds and shows the user
+    /// interface.
+    public abstract void start(Stage primaryStage) throws Exception;
+
+    /// Called once when the application ends; does nothing unless
+    /// overridden.
+    public void stop() throws Exception {
+    }
+
+    /// The arguments an application was started with.
+    public abstract static class Parameters {
+
+        /// Creates the parameters.
+        public Parameters() {
+        }
+
+        /// Every argument, as it was given.
+        public abstract List<String> getRaw();
+
+        /// The arguments that are not of the form `--name=value`.
+        public abstract List<String> getUnnamed();
+
+        /// The `--name=value` arguments, by name.
+        public abstract Map<String, String> getNamed();
+    }
+
+    /// What [#getParameters()] answers: nothing. Each call hands out
+    /// collections of its own, so no caller can change what another sees.
+    private static final class EmptyParameters extends Parameters {
+        @Override
+        public List<String> getRaw() {
+            return new ArrayList<String>();
+        }
+
+        @Override
+        public List<String> getUnnamed() {
+            return new ArrayList<String>();
+        }
+
+        @Override
+        public Map<String, String> getNamed() {
+            return new HashMap<String, String>();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/application/ConditionalFeature.java b/maven/javafx-compat/src/main/java/javafx/application/ConditionalFeature.java
new file mode 100644
index 00000000000..d7cc21fb835
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/application/ConditionalFeature.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.application;
+
+/// The parts of JavaFX a platform may lack, as
+/// [Platform#isSupported(ConditionalFeature)] is asked about them.
+public enum ConditionalFeature {
+    /// The scene graph itself.
+    GRAPHICS,
+    /// The controls.
+    CONTROLS,
+    /// Sound and video.
+    MEDIA,
+    /// The embedded browser.
+    WEB,
+    /// Embedding in SWT.
+    SWT,
+    /// Embedding in Swing.
+    SWING,
+    /// Loading a scene from FXML.
+    FXML,
+    /// Three dimensional scenes.
+    SCENE3D,
+    /// The filter effects.
+    EFFECT,
+    /// Clipping a node to a shape.
+    SHAPE_CLIP,
+    /// Composing text through an input method.
+    INPUT_METHOD,
+    /// Windows that show what is behind them.
+    TRANSPARENT_WINDOW,
+    /// Windows whose decoration runs into their content.
+    UNIFIED_WINDOW,
+    /// Focus that moves in two levels, as on a television.
+    TWO_LEVEL_FOCUS,
+    /// A keyboard drawn on the screen by JavaFX.
+    VIRTUAL_KEYBOARD,
+    /// Touch events.
+    INPUT_TOUCH,
+    /// Touch events for several fingers at once.
+    INPUT_MULTITOUCH,
+    /// A pointing device.
+    INPUT_POINTER
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/application/HostServices.java b/maven/javafx-compat/src/main/java/javafx/application/HostServices.java
new file mode 100644
index 00000000000..a795e1b6e66
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/application/HostServices.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.application;
+
+import com.codename1.ui.Display;
+
+/// The services of the platform an application runs on; an application gets
+/// its instance from [Application#getHostServices()].
+public final class HostServices {
+
+    HostServices() {
+    }
+
+    /// The location the application was started from. A Codename One
+    /// application is not started from a location: the empty string.
+    public String getCodeBase() {
+        return "";
+    }
+
+    /// The location of the document that holds the application; the empty
+    /// string, as [#getCodeBase()].
+    public String getDocumentBase() {
+        return "";
+    }
+
+    /// Resolves `rel` against `base`, or against [#getDocumentBase()] when
+    /// `base` is null or empty.
+    public String resolveURI(String base, String rel) {
+        if (rel == null) {
+            return base == null ? "" : base;
+        }
+        if (base == null || base.length() == 0 || rel.indexOf(':') > 0) {
+            return rel;
+        }
+        if (base.endsWith("/") || rel.startsWith("/")) {
+            return base + rel;
+        }
+        int slash = base.lastIndexOf('/');
+        return slash < 0 ? rel : base.substring(0, slash + 1) + rel;
+    }
+
+    /// Opens `uri` in the platform's browser, or in whichever application
+    /// the platform has for it.
+    public void showDocument(String uri) {
+        if (uri != null && Display.isInitialized()) {
+            Display.getInstance().execute(uri);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/application/Platform.java b/maven/javafx-compat/src/main/java/javafx/application/Platform.java
new file mode 100644
index 00000000000..c7fa8559afd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/application/Platform.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.application;
+
+import com.codename1.fxcompat.runtime.SceneInput;
+import com.codename1.fxcompat.runtime.StageHosts;
+import com.codename1.ui.Display;
+
+/// Access to the JavaFX application thread, which is the Codename One
+/// event dispatch thread.
+public final class Platform {
+
+    private static boolean implicitExit = true;
+
+    private Platform() {
+    }
+
+    /// Runs code on the JavaFX application thread at some later time, in
+    /// the order it was asked for. Without a Codename One display, as in
+    /// a plain unit test, it runs at once on the calling thread.
+    public static void runLater(Runnable runnable) {
+        if (runnable == null) {
+            throw new NullPointerException("runnable must not be null");
+        }
+        if (Display.isInitialized()) {
+            Display.getInstance().callSerially(runnable);
+        } else {
+            runnable.run();
+        }
+    }
+
+    /// Returns whether the caller is on the JavaFX application thread.
+    /// Without a Codename One display every thread counts as it.
+    public static boolean isFxApplicationThread() {
+        return !Display.isInitialized() || Display.getInstance().isEdt();
+    }
+
+    /// Ends the application: `Application.stop()` is called and Codename
+    /// One exits.
+    public static void exit() {
+        StageHosts.exit();
+    }
+
+    /// Sets whether the application ends when its last window is hidden.
+    public static void setImplicitExit(boolean value) {
+        implicitExit = value;
+    }
+
+    /// Returns whether the application ends when its last window is
+    /// hidden.
+    public static boolean isImplicitExit() {
+        return implicitExit;
+    }
+
+    /// Returns whether a part of JavaFX is there to be used.
+    ///
+    /// The scene graph, the controls, FXML, clipping to a shape and a
+    /// pointing device are. Touch events are not: every pointer reaches
+    /// the scene as a mouse event, a finger included, so an application
+    /// that asks before it hides the cursor or wires touch handlers is
+    /// told the truth. Everything else answers `false`.
+    public static boolean isSupported(ConditionalFeature feature) {
+        return feature == ConditionalFeature.GRAPHICS || feature == ConditionalFeature.CONTROLS
+                || feature == ConditionalFeature.FXML || feature == ConditionalFeature.SHAPE_CLIP
+                || feature == ConditionalFeature.INPUT_POINTER
+                || (feature == ConditionalFeature.INPUT_TOUCH && SceneInput.touchInput());
+    }
+
+    /// The toolkit needs no starting on Codename One; the code is run on
+    /// the JavaFX application thread as [#runLater(Runnable)] would.
+    public static void startup(Runnable runnable) {
+        runLater(runnable);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/application/package-info.java b/maven/javafx-compat/src/main/java/javafx/application/package-info.java
new file mode 100644
index 00000000000..e7f3ba867b6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/application/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The application life cycle: the class an application extends, and
+/// access to the JavaFX application thread.
+package javafx.application;
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/DefaultProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/DefaultProperty.java
new file mode 100644
index 00000000000..f876628abe2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/DefaultProperty.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/// Names the property of a class that child content is added to when no
+/// property is named.
+@Inherited
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface DefaultProperty {
+
+    /// The name of the default property.
+    String value();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/InvalidationListener.java b/maven/javafx-compat/src/main/java/javafx/beans/InvalidationListener.java
new file mode 100644
index 00000000000..ddb362c6dd3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/InvalidationListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans;
+
+/// Told when an [Observable] turns invalid.
+@FunctionalInterface
+public interface InvalidationListener {
+
+    /// Called when the observable turned invalid.
+    void invalidated(Observable observable);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/NamedArg.java b/maven/javafx-compat/src/main/java/javafx/beans/NamedArg.java
new file mode 100644
index 00000000000..841f2543dcb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/NamedArg.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/// Names a constructor parameter, so a declarative loader can match an
+/// attribute to it.
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface NamedArg {
+
+    /// The name of the parameter.
+    String value();
+
+    /// The value used when the attribute is absent.
+    String defaultValue() default "";
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/Observable.java b/maven/javafx-compat/src/main/java/javafx/beans/Observable.java
new file mode 100644
index 00000000000..aa2e22d9bb0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/Observable.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans;
+
+/// Something whose content can become stale and that says so.
+///
+/// An invalidation tells a listener only that the content may have changed.
+/// Implementations that evaluate lazily send it once and stay silent until
+/// the content has been read again.
+public interface Observable {
+
+    /// Adds a listener told whenever this object turns invalid. Adding the
+    /// same listener twice makes it hear every invalidation twice.
+    void addListener(InvalidationListener listener);
+
+    /// Removes one registration of the listener; unknown listeners are ignored.
+    void removeListener(InvalidationListener listener);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/WeakInvalidationListener.java b/maven/javafx-compat/src/main/java/javafx/beans/WeakInvalidationListener.java
new file mode 100644
index 00000000000..8a2aade86a4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/WeakInvalidationListener.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans;
+
+import java.lang.ref.WeakReference;
+
+/// An [InvalidationListener] that forwards to another one without keeping it
+/// alive. Whoever creates it must hold the wrapped listener; once that is
+/// collected, this listener removes itself on the next invalidation.
+public final class WeakInvalidationListener implements InvalidationListener, WeakListener {
+
+    private final WeakReference ref;
+
+    /// Wraps a listener.
+    public WeakInvalidationListener(InvalidationListener listener) {
+        if (listener == null) {
+            throw new NullPointerException("Listener must be specified.");
+        }
+        this.ref = new WeakReference(listener);
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+
+    @Override
+    public void invalidated(Observable observable) {
+        Object listener = ref.get();
+        if (listener instanceof InvalidationListener) {
+            ((InvalidationListener) listener).invalidated(observable);
+        } else {
+            observable.removeListener(this);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/WeakListener.java b/maven/javafx-compat/src/main/java/javafx/beans/WeakListener.java
new file mode 100644
index 00000000000..f30c3ef8022
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/WeakListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans;
+
+/// Implemented by listeners that hold their target weakly, so the observable
+/// they are registered with can drop them once the target is gone.
+public interface WeakListener {
+
+    /// Returns whether the wrapped listener has been garbage collected.
+    boolean wasGarbageCollected();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/Binding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/Binding.java
new file mode 100644
index 00000000000..bb4b9f0d2f3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/Binding.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ObservableList;
+
+/// A value computed from other observable values.
+///
+/// A binding is valid once its value has been computed and turns invalid
+/// when a dependency changes; it tells its listeners so once and recomputes
+/// only when the value is next read.
+public interface Binding<T> extends ObservableValue<T> {
+
+    /// Returns whether the cached value is current.
+    boolean isValid();
+
+    /// Marks the value stale, so the next read computes it again.
+    void invalidate();
+
+    /// Returns what this binding depends on, as an unmodifiable list.
+    ObservableList<?> getDependencies();
+
+    /// Tells the binding it is no longer used, so it can stop observing its
+    /// dependencies. Bindings observe weakly, so calling this is optional.
+    void dispose();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/Bindings.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/Bindings.java
new file mode 100644
index 00000000000..176dab36bf3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/Bindings.java
@@ -0,0 +1,1550 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+import com.codename1.fxcompat.runtime.BidirectionalBinding;
+import com.codename1.fxcompat.runtime.ContentBindings;
+import com.codename1.fxcompat.runtime.Diagnostics;
+
+import javafx.beans.Observable;
+import javafx.beans.property.Property;
+import javafx.beans.value.ObservableBooleanValue;
+import javafx.beans.value.ObservableDoubleValue;
+import javafx.beans.value.ObservableFloatValue;
+import javafx.beans.value.ObservableIntegerValue;
+import javafx.beans.value.ObservableLongValue;
+import javafx.beans.value.ObservableNumberValue;
+import javafx.beans.value.ObservableObjectValue;
+import javafx.beans.value.ObservableStringValue;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.util.StringConverter;
+
+/// The operators of the binding API: every method returns a binding that
+/// follows its operands and recomputes lazily.
+///
+/// An arithmetic result has the wider of its two operand types -- `double`
+/// over `float` over `long` over `int` -- as the same expression would in
+/// Java. An integer division by zero throws `ArithmeticException` when the
+/// binding is read.
+public final class Bindings {
+
+    static final int ADD = 0;
+    static final int SUB = 1;
+    static final int MUL = 2;
+    static final int DIV = 3;
+    static final int MIN = 4;
+    static final int MAX = 5;
+    static final int NEG = 6;
+
+    static final int EQ = 0;
+    static final int NE = 1;
+    static final int GT = 2;
+    static final int LT = 3;
+    static final int GE = 4;
+    static final int LE = 5;
+    static final int EQ_IC = 6;
+    static final int NE_IC = 7;
+
+    private Bindings() {
+    }
+
+    // ---- shared machinery
+
+    /// Returns the candidates a binding has to observe: the ones that are
+    /// there and can change.
+    static Observable[] deps(Observable... candidates) {
+        int count = 0;
+        for (Observable candidate : candidates) {
+            if (candidate != null && !Const.isConstant(candidate)) {
+                count++;
+            }
+        }
+        Observable[] result = new Observable[count];
+        int next = 0;
+        for (Observable candidate : candidates) {
+            if (candidate != null && !Const.isConstant(candidate)) {
+                result[next++] = candidate;
+            }
+        }
+        return result;
+    }
+
+    private static int rank(ObservableNumberValue value) {
+        if (value instanceof ObservableDoubleValue) {
+            return 3;
+        }
+        if (value instanceof ObservableFloatValue) {
+            return 2;
+        }
+        if (value instanceof ObservableLongValue) {
+            return 1;
+        }
+        return 0;
+    }
+
+    private static void operands(Object first, Object second) {
+        if (first == null || second == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+    }
+
+    static NumberBinding arith(final int op, final ObservableNumberValue a, final ObservableNumberValue b) {
+        operands(a, b);
+        Observable[] deps = deps(a, b);
+        switch (Math.max(rank(a), rank(b))) {
+            case 3:
+                return new Fn.DoubleFn(() -> apply(op, a.doubleValue(), b.doubleValue()), deps);
+            case 2:
+                return new Fn.FloatFn(() -> apply(op, a.floatValue(), b.floatValue()), deps);
+            case 1:
+                return new Fn.LongFn(() -> apply(op, a.longValue(), b.longValue()), deps);
+            default:
+                return new Fn.IntegerFn(() -> apply(op, a.intValue(), b.intValue()), deps);
+        }
+    }
+
+    static NumberBinding choose(final ObservableBooleanValue condition, final ObservableNumberValue a,
+            final ObservableNumberValue b) {
+        Observable[] deps = deps(condition, a, b);
+        switch (Math.max(rank(a), rank(b))) {
+            case 3:
+                return new Fn.DoubleFn(() -> condition.get() ? a.doubleValue() : b.doubleValue(), deps);
+            case 2:
+                return new Fn.FloatFn(() -> condition.get() ? a.floatValue() : b.floatValue(), deps);
+            case 1:
+                return new Fn.LongFn(() -> condition.get() ? a.longValue() : b.longValue(), deps);
+            default:
+                return new Fn.IntegerFn(() -> condition.get() ? a.intValue() : b.intValue(), deps);
+        }
+    }
+
+    private static double apply(int op, double x, double y) {
+        switch (op) {
+            case ADD:
+                return x + y;
+            case SUB:
+                return x - y;
+            case MUL:
+                return x * y;
+            case DIV:
+                return x / y;
+            case MIN:
+                return Math.min(x, y);
+            case MAX:
+                return Math.max(x, y);
+            default:
+                return -x;
+        }
+    }
+
+    private static float apply(int op, float x, float y) {
+        switch (op) {
+            case ADD:
+                return x + y;
+            case SUB:
+                return x - y;
+            case MUL:
+                return x * y;
+            case DIV:
+                return x / y;
+            case MIN:
+                return Math.min(x, y);
+            case MAX:
+                return Math.max(x, y);
+            default:
+                return -x;
+        }
+    }
+
+    private static long apply(int op, long x, long y) {
+        switch (op) {
+            case ADD:
+                return x + y;
+            case SUB:
+                return x - y;
+            case MUL:
+                return x * y;
+            case DIV:
+                // The device VM answers 0 for an integer division by zero,
+                // so the exception Java promises is raised by hand.
+                if (y == 0) {
+                    throw new ArithmeticException("/ by zero");
+                }
+                return x / y;
+            case MIN:
+                return Math.min(x, y);
+            case MAX:
+                return Math.max(x, y);
+            default:
+                return -x;
+        }
+    }
+
+    private static int apply(int op, int x, int y) {
+        switch (op) {
+            case ADD:
+                return x + y;
+            case SUB:
+                return x - y;
+            case MUL:
+                return x * y;
+            case DIV:
+                if (y == 0) {
+                    throw new ArithmeticException("/ by zero");
+                }
+                return x / y;
+            case MIN:
+                return Math.min(x, y);
+            case MAX:
+                return Math.max(x, y);
+            default:
+                return -x;
+        }
+    }
+
+    static BooleanBinding compare(final int op, final ObservableNumberValue a, final ObservableNumberValue b,
+            final double epsilon) {
+        operands(a, b);
+        Observable[] deps = deps(a, b);
+        switch (Math.max(rank(a), rank(b))) {
+            case 3:
+                return new Fn.BooleanFn(() -> {
+                    double x = a.doubleValue();
+                    double y = b.doubleValue();
+                    return pick(op, Math.abs(x - y) <= epsilon, x > y, x >= y, x < y, x <= y);
+                }, deps);
+            case 2:
+                return new Fn.BooleanFn(() -> {
+                    float x = a.floatValue();
+                    float y = b.floatValue();
+                    return pick(op, Math.abs(x - y) <= epsilon, x > y, x >= y, x < y, x <= y);
+                }, deps);
+            case 1:
+                return new Fn.BooleanFn(() -> {
+                    long x = a.longValue();
+                    long y = b.longValue();
+                    return pick(op, Math.abs(x - y) <= epsilon, x > y, x >= y, x < y, x <= y);
+                }, deps);
+            default:
+                return new Fn.BooleanFn(() -> {
+                    int x = a.intValue();
+                    int y = b.intValue();
+                    return pick(op, Math.abs(x - y) <= epsilon, x > y, x >= y, x < y, x <= y);
+                }, deps);
+        }
+    }
+
+    private static boolean pick(int op, boolean eq, boolean gt, boolean ge, boolean lt, boolean le) {
+        switch (op) {
+            case EQ:
+                return eq;
+            case NE:
+                return !eq;
+            case GT:
+                return gt;
+            case GE:
+                return ge;
+            case LT:
+                return lt;
+            default:
+                return le;
+        }
+    }
+
+    static BooleanBinding strings(final int op, final ObservableStringValue a, final ObservableStringValue b) {
+        operands(a, b);
+        return new Fn.BooleanFn(() -> {
+            String x = a.get();
+            String y = b.get();
+            if (x == null) {
+                x = "";
+            }
+            if (y == null) {
+                y = "";
+            }
+            switch (op) {
+                case EQ:
+                    return x.equals(y);
+                case NE:
+                    return !x.equals(y);
+                case EQ_IC:
+                    return x.equalsIgnoreCase(y);
+                case NE_IC:
+                    return !x.equalsIgnoreCase(y);
+                case GT:
+                    return x.compareTo(y) > 0;
+                case GE:
+                    return x.compareTo(y) >= 0;
+                case LT:
+                    return x.compareTo(y) < 0;
+                default:
+                    return x.compareTo(y) <= 0;
+            }
+        }, deps(a, b));
+    }
+
+    /// The text of any observable value; `"null"` for none.
+    static StringBinding text(final ObservableValue<?> value) {
+        if (value == null) {
+            throw new NullPointerException("ObservableValue must be specified");
+        }
+        return new Fn.StringFn(() -> String.valueOf(value.getValue()), value);
+    }
+
+    private static Observable[] observables(Object[] args) {
+        int count = 0;
+        for (Object arg : args) {
+            if (arg instanceof ObservableValue) {
+                count++;
+            }
+        }
+        Observable[] result = new Observable[count];
+        int next = 0;
+        for (Object arg : args) {
+            if (arg instanceof ObservableValue) {
+                result[next++] = (ObservableValue<?>) arg;
+            }
+        }
+        return result;
+    }
+
+    static StringBinding formatted(final String format, final Object... args) {
+        if (format == null) {
+            throw new NullPointerException("Format cannot be null.");
+        }
+        final Object[] source = args == null ? new Object[0] : args.clone();
+        return new Fn.StringFn(() -> {
+            Object[] values = new Object[source.length];
+            for (int i = 0; i < values.length; i++) {
+                Object arg = source[i];
+                values[i] = arg instanceof ObservableValue ? ((ObservableValue<?>) arg).getValue() : arg;
+            }
+            return String.format(format, values);
+        }, observables(source));
+    }
+
+    // ---- custom bindings
+
+    /// Returns a boolean binding computed by a function; a function that
+    /// throws or returns `null` yields `false`.
+    public static BooleanBinding createBooleanBinding(final Callable<Boolean> func, final Observable... dependencies) {
+        return new Fn.BooleanFn(() -> {
+            try {
+                // Read as an Object and tested: the function's type is erased,
+                // and a failed cast is not an exception on every target.
+                Object value = ((Callable<?>) func).call();
+                if (value instanceof Boolean) {
+                    return ((Boolean) value).booleanValue();
+                }
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+            }
+            return false;
+        }, dependencies);
+    }
+
+    /// Returns a `double` binding computed by a function; a function that
+    /// throws or returns `null` yields zero.
+    public static DoubleBinding createDoubleBinding(final Callable<Double> func, final Observable... dependencies) {
+        return new Fn.DoubleFn(() -> {
+            try {
+                // Read as an Object and tested: the function's type is erased,
+                // and a failed cast is not an exception on every target.
+                Object value = ((Callable<?>) func).call();
+                if (value instanceof Double) {
+                    return ((Double) value).doubleValue();
+                }
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+            }
+            return 0.0;
+        }, dependencies);
+    }
+
+    /// Returns a `float` binding computed by a function; a function that
+    /// throws or returns `null` yields zero.
+    public static FloatBinding createFloatBinding(final Callable<Float> func, final Observable... dependencies) {
+        return new Fn.FloatFn(() -> {
+            try {
+                // Read as an Object and tested: the function's type is erased,
+                // and a failed cast is not an exception on every target.
+                Object value = ((Callable<?>) func).call();
+                if (value instanceof Float) {
+                    return ((Float) value).floatValue();
+                }
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+            }
+            return 0.0f;
+        }, dependencies);
+    }
+
+    /// Returns an `int` binding computed by a function; a function that
+    /// throws or returns `null` yields zero.
+    public static IntegerBinding createIntegerBinding(final Callable<Integer> func, final Observable... dependencies) {
+        return new Fn.IntegerFn(() -> {
+            try {
+                // Read as an Object and tested: the function's type is erased,
+                // and a failed cast is not an exception on every target.
+                Object value = ((Callable<?>) func).call();
+                if (value instanceof Integer) {
+                    return ((Integer) value).intValue();
+                }
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+            }
+            return 0;
+        }, dependencies);
+    }
+
+    /// Returns a `long` binding computed by a function; a function that
+    /// throws or returns `null` yields zero.
+    public static LongBinding createLongBinding(final Callable<Long> func, final Observable... dependencies) {
+        return new Fn.LongFn(() -> {
+            try {
+                // Read as an Object and tested: the function's type is erased,
+                // and a failed cast is not an exception on every target.
+                Object value = ((Callable<?>) func).call();
+                if (value instanceof Long) {
+                    return ((Long) value).longValue();
+                }
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+            }
+            return 0L;
+        }, dependencies);
+    }
+
+    /// Returns an object binding computed by a function; a function that
+    /// throws yields `null`.
+    public static <T> ObjectBinding<T> createObjectBinding(final Callable<T> func, final Observable... dependencies) {
+        return new Fn.ObjectFn<T>(() -> {
+            try {
+                return func.call();
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+                return null;
+            }
+        }, dependencies);
+    }
+
+    /// Returns a string binding computed by a function; a function that
+    /// throws yields the empty string.
+    public static StringBinding createStringBinding(final Callable<String> func, final Observable... dependencies) {
+        return new Fn.StringFn(() -> {
+            try {
+                // As above: the type is erased, so it is tested, not cast.
+                Object value = ((Callable<?>) func).call();
+                return value instanceof String ? (String) value : null;
+            } catch (Exception failure) {
+                Diagnostics.report(failure);
+                return "";
+            }
+        }, dependencies);
+    }
+
+    // ---- numbers
+
+    /// Returns a binding computing the negation of a number.
+    public static NumberBinding negate(final ObservableNumberValue value) {
+        if (value == null) {
+            throw new NullPointerException("Operand cannot be null.");
+        }
+        return arith(NEG, value, Const.of(0));
+    }
+
+    /// Returns a binding computing the sum of two numbers, typed by the wider operand.
+    public static NumberBinding add(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return arith(ADD, op1, op2);
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static DoubleBinding add(final ObservableNumberValue op1, final double op2) {
+        return (DoubleBinding) arith(ADD, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static DoubleBinding add(final double op1, final ObservableNumberValue op2) {
+        return (DoubleBinding) arith(ADD, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static NumberBinding add(final ObservableNumberValue op1, final float op2) {
+        return arith(ADD, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static NumberBinding add(final float op1, final ObservableNumberValue op2) {
+        return arith(ADD, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static NumberBinding add(final ObservableNumberValue op1, final long op2) {
+        return arith(ADD, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static NumberBinding add(final long op1, final ObservableNumberValue op2) {
+        return arith(ADD, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static NumberBinding add(final ObservableNumberValue op1, final int op2) {
+        return arith(ADD, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the sum of a number and a constant.
+    public static NumberBinding add(final int op1, final ObservableNumberValue op2) {
+        return arith(ADD, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the difference of two numbers, typed by the wider operand.
+    public static NumberBinding subtract(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return arith(SUB, op1, op2);
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static DoubleBinding subtract(final ObservableNumberValue op1, final double op2) {
+        return (DoubleBinding) arith(SUB, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static DoubleBinding subtract(final double op1, final ObservableNumberValue op2) {
+        return (DoubleBinding) arith(SUB, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static NumberBinding subtract(final ObservableNumberValue op1, final float op2) {
+        return arith(SUB, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static NumberBinding subtract(final float op1, final ObservableNumberValue op2) {
+        return arith(SUB, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static NumberBinding subtract(final ObservableNumberValue op1, final long op2) {
+        return arith(SUB, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static NumberBinding subtract(final long op1, final ObservableNumberValue op2) {
+        return arith(SUB, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static NumberBinding subtract(final ObservableNumberValue op1, final int op2) {
+        return arith(SUB, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the difference of a number and a constant.
+    public static NumberBinding subtract(final int op1, final ObservableNumberValue op2) {
+        return arith(SUB, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the product of two numbers, typed by the wider operand.
+    public static NumberBinding multiply(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return arith(MUL, op1, op2);
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static DoubleBinding multiply(final ObservableNumberValue op1, final double op2) {
+        return (DoubleBinding) arith(MUL, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static DoubleBinding multiply(final double op1, final ObservableNumberValue op2) {
+        return (DoubleBinding) arith(MUL, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static NumberBinding multiply(final ObservableNumberValue op1, final float op2) {
+        return arith(MUL, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static NumberBinding multiply(final float op1, final ObservableNumberValue op2) {
+        return arith(MUL, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static NumberBinding multiply(final ObservableNumberValue op1, final long op2) {
+        return arith(MUL, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static NumberBinding multiply(final long op1, final ObservableNumberValue op2) {
+        return arith(MUL, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static NumberBinding multiply(final ObservableNumberValue op1, final int op2) {
+        return arith(MUL, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the product of a number and a constant.
+    public static NumberBinding multiply(final int op1, final ObservableNumberValue op2) {
+        return arith(MUL, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the quotient of two numbers, typed by the wider operand.
+    public static NumberBinding divide(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return arith(DIV, op1, op2);
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static DoubleBinding divide(final ObservableNumberValue op1, final double op2) {
+        return (DoubleBinding) arith(DIV, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static DoubleBinding divide(final double op1, final ObservableNumberValue op2) {
+        return (DoubleBinding) arith(DIV, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static NumberBinding divide(final ObservableNumberValue op1, final float op2) {
+        return arith(DIV, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static NumberBinding divide(final float op1, final ObservableNumberValue op2) {
+        return arith(DIV, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static NumberBinding divide(final ObservableNumberValue op1, final long op2) {
+        return arith(DIV, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static NumberBinding divide(final long op1, final ObservableNumberValue op2) {
+        return arith(DIV, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static NumberBinding divide(final ObservableNumberValue op1, final int op2) {
+        return arith(DIV, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the quotient of a number and a constant.
+    public static NumberBinding divide(final int op1, final ObservableNumberValue op2) {
+        return arith(DIV, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the smaller of two numbers, typed by the wider operand.
+    public static NumberBinding min(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return arith(MIN, op1, op2);
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static DoubleBinding min(final ObservableNumberValue op1, final double op2) {
+        return (DoubleBinding) arith(MIN, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static DoubleBinding min(final double op1, final ObservableNumberValue op2) {
+        return (DoubleBinding) arith(MIN, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static NumberBinding min(final ObservableNumberValue op1, final float op2) {
+        return arith(MIN, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static NumberBinding min(final float op1, final ObservableNumberValue op2) {
+        return arith(MIN, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static NumberBinding min(final ObservableNumberValue op1, final long op2) {
+        return arith(MIN, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static NumberBinding min(final long op1, final ObservableNumberValue op2) {
+        return arith(MIN, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static NumberBinding min(final ObservableNumberValue op1, final int op2) {
+        return arith(MIN, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the smaller of a number and a constant.
+    public static NumberBinding min(final int op1, final ObservableNumberValue op2) {
+        return arith(MIN, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the larger of two numbers, typed by the wider operand.
+    public static NumberBinding max(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return arith(MAX, op1, op2);
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static DoubleBinding max(final ObservableNumberValue op1, final double op2) {
+        return (DoubleBinding) arith(MAX, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static DoubleBinding max(final double op1, final ObservableNumberValue op2) {
+        return (DoubleBinding) arith(MAX, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static NumberBinding max(final ObservableNumberValue op1, final float op2) {
+        return arith(MAX, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static NumberBinding max(final float op1, final ObservableNumberValue op2) {
+        return arith(MAX, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static NumberBinding max(final ObservableNumberValue op1, final long op2) {
+        return arith(MAX, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static NumberBinding max(final long op1, final ObservableNumberValue op2) {
+        return arith(MAX, Const.of(op1), op2);
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static NumberBinding max(final ObservableNumberValue op1, final int op2) {
+        return arith(MAX, op1, Const.of(op2));
+    }
+
+    /// Returns a binding computing the larger of a number and a constant.
+    public static NumberBinding max(final int op1, final ObservableNumberValue op2) {
+        return arith(MAX, Const.of(op1), op2);
+    }
+
+    /// Returns a binding telling whether two numbers are equal, within a tolerance.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(EQ, op1, op2, epsilon);
+    }
+
+    /// Returns a binding telling whether two numbers are equal.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return compare(EQ, op1, op2, 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final double op2, final double epsilon) {
+        return compare(EQ, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final double op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(EQ, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final float op2, final double epsilon) {
+        return compare(EQ, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final float op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(EQ, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final long op2, final double epsilon) {
+        return compare(EQ, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final long op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(EQ, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final long op2) {
+        return compare(EQ, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal.
+    public static BooleanBinding equal(final long op1, final ObservableNumberValue op2) {
+        return compare(EQ, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final int op2, final double epsilon) {
+        return compare(EQ, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal, within a tolerance.
+    public static BooleanBinding equal(final int op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(EQ, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal.
+    public static BooleanBinding equal(final ObservableNumberValue op1, final int op2) {
+        return compare(EQ, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are equal.
+    public static BooleanBinding equal(final int op1, final ObservableNumberValue op2) {
+        return compare(EQ, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether two numbers are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(NE, op1, op2, epsilon);
+    }
+
+    /// Returns a binding telling whether two numbers are not equal.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return compare(NE, op1, op2, 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final double op2, final double epsilon) {
+        return compare(NE, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final double op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(NE, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final float op2, final double epsilon) {
+        return compare(NE, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final float op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(NE, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final long op2, final double epsilon) {
+        return compare(NE, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final long op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(NE, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final long op2) {
+        return compare(NE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal.
+    public static BooleanBinding notEqual(final long op1, final ObservableNumberValue op2) {
+        return compare(NE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final int op2, final double epsilon) {
+        return compare(NE, op1, Const.of(op2), epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal, within a tolerance.
+    public static BooleanBinding notEqual(final int op1, final ObservableNumberValue op2, final double epsilon) {
+        return compare(NE, Const.of(op1), op2, epsilon);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal.
+    public static BooleanBinding notEqual(final ObservableNumberValue op1, final int op2) {
+        return compare(NE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether a number and a constant are not equal.
+    public static BooleanBinding notEqual(final int op1, final ObservableNumberValue op2) {
+        return compare(NE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first number is greater than the second.
+    public static BooleanBinding greaterThan(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return compare(GT, op1, op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final ObservableNumberValue op1, final double op2) {
+        return compare(GT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final double op1, final ObservableNumberValue op2) {
+        return compare(GT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final ObservableNumberValue op1, final float op2) {
+        return compare(GT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final float op1, final ObservableNumberValue op2) {
+        return compare(GT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final ObservableNumberValue op1, final long op2) {
+        return compare(GT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final long op1, final ObservableNumberValue op2) {
+        return compare(GT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final ObservableNumberValue op1, final int op2) {
+        return compare(GT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than the second.
+    public static BooleanBinding greaterThan(final int op1, final ObservableNumberValue op2) {
+        return compare(GT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first number is less than the second.
+    public static BooleanBinding lessThan(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return compare(LT, op1, op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final ObservableNumberValue op1, final double op2) {
+        return compare(LT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final double op1, final ObservableNumberValue op2) {
+        return compare(LT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final ObservableNumberValue op1, final float op2) {
+        return compare(LT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final float op1, final ObservableNumberValue op2) {
+        return compare(LT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final ObservableNumberValue op1, final long op2) {
+        return compare(LT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final long op1, final ObservableNumberValue op2) {
+        return compare(LT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final ObservableNumberValue op1, final int op2) {
+        return compare(LT, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than the second.
+    public static BooleanBinding lessThan(final int op1, final ObservableNumberValue op2) {
+        return compare(LT, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first number is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return compare(GE, op1, op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final ObservableNumberValue op1, final double op2) {
+        return compare(GE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final double op1, final ObservableNumberValue op2) {
+        return compare(GE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final ObservableNumberValue op1, final float op2) {
+        return compare(GE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final float op1, final ObservableNumberValue op2) {
+        return compare(GE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final ObservableNumberValue op1, final long op2) {
+        return compare(GE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final long op1, final ObservableNumberValue op2) {
+        return compare(GE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final ObservableNumberValue op1, final int op2) {
+        return compare(GE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is greater than or equal to the second.
+    public static BooleanBinding greaterThanOrEqual(final int op1, final ObservableNumberValue op2) {
+        return compare(GE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first number is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final ObservableNumberValue op1, final ObservableNumberValue op2) {
+        return compare(LE, op1, op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final ObservableNumberValue op1, final double op2) {
+        return compare(LE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final double op1, final ObservableNumberValue op2) {
+        return compare(LE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final ObservableNumberValue op1, final float op2) {
+        return compare(LE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final float op1, final ObservableNumberValue op2) {
+        return compare(LE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final ObservableNumberValue op1, final long op2) {
+        return compare(LE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final long op1, final ObservableNumberValue op2) {
+        return compare(LE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final ObservableNumberValue op1, final int op2) {
+        return compare(LE, op1, Const.of(op2), 0.0);
+    }
+
+    /// Returns a binding telling whether the first operand is less than or equal to the second.
+    public static BooleanBinding lessThanOrEqual(final int op1, final ObservableNumberValue op2) {
+        return compare(LE, Const.of(op1), op2, 0.0);
+    }
+
+    /// Returns a binding telling whether two strings are equal; `null` counts as empty.
+    public static BooleanBinding equal(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(EQ, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal; `null` counts as empty.
+    public static BooleanBinding equal(final ObservableStringValue op1, final String op2) {
+        return strings(EQ, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings are equal; `null` counts as empty.
+    public static BooleanBinding equal(final String op1, final ObservableStringValue op2) {
+        return strings(EQ, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings differ; `null` counts as empty.
+    public static BooleanBinding notEqual(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(NE, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings differ; `null` counts as empty.
+    public static BooleanBinding notEqual(final ObservableStringValue op1, final String op2) {
+        return strings(NE, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings differ; `null` counts as empty.
+    public static BooleanBinding notEqual(final String op1, final ObservableStringValue op2) {
+        return strings(NE, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal ignoring case; `null` counts as empty.
+    public static BooleanBinding equalIgnoreCase(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(EQ_IC, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal ignoring case; `null` counts as empty.
+    public static BooleanBinding equalIgnoreCase(final ObservableStringValue op1, final String op2) {
+        return strings(EQ_IC, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings are equal ignoring case; `null` counts as empty.
+    public static BooleanBinding equalIgnoreCase(final String op1, final ObservableStringValue op2) {
+        return strings(EQ_IC, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings differ even ignoring case; `null` counts as empty.
+    public static BooleanBinding notEqualIgnoreCase(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(NE_IC, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings differ even ignoring case; `null` counts as empty.
+    public static BooleanBinding notEqualIgnoreCase(final ObservableStringValue op1, final String op2) {
+        return strings(NE_IC, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings differ even ignoring case; `null` counts as empty.
+    public static BooleanBinding notEqualIgnoreCase(final String op1, final ObservableStringValue op2) {
+        return strings(NE_IC, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings are in descending order; `null` counts as empty.
+    public static BooleanBinding greaterThan(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(GT, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings are in descending order; `null` counts as empty.
+    public static BooleanBinding greaterThan(final ObservableStringValue op1, final String op2) {
+        return strings(GT, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings are in descending order; `null` counts as empty.
+    public static BooleanBinding greaterThan(final String op1, final ObservableStringValue op2) {
+        return strings(GT, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings are in ascending order; `null` counts as empty.
+    public static BooleanBinding lessThan(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(LT, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings are in ascending order; `null` counts as empty.
+    public static BooleanBinding lessThan(final ObservableStringValue op1, final String op2) {
+        return strings(LT, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings are in ascending order; `null` counts as empty.
+    public static BooleanBinding lessThan(final String op1, final ObservableStringValue op2) {
+        return strings(LT, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal or in descending order; `null` counts as empty.
+    public static BooleanBinding greaterThanOrEqual(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(GE, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal or in descending order; `null` counts as empty.
+    public static BooleanBinding greaterThanOrEqual(final ObservableStringValue op1, final String op2) {
+        return strings(GE, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings are equal or in descending order; `null` counts as empty.
+    public static BooleanBinding greaterThanOrEqual(final String op1, final ObservableStringValue op2) {
+        return strings(GE, new Const.Text(op1), op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal or in ascending order; `null` counts as empty.
+    public static BooleanBinding lessThanOrEqual(final ObservableStringValue op1, final ObservableStringValue op2) {
+        return strings(LE, op1, op2);
+    }
+
+    /// Returns a binding telling whether two strings are equal or in ascending order; `null` counts as empty.
+    public static BooleanBinding lessThanOrEqual(final ObservableStringValue op1, final String op2) {
+        return strings(LE, op1, new Const.Text(op2));
+    }
+
+    /// Returns a binding telling whether two strings are equal or in ascending order; `null` counts as empty.
+    public static BooleanBinding lessThanOrEqual(final String op1, final ObservableStringValue op2) {
+        return strings(LE, new Const.Text(op1), op2);
+    }
+
+    // ---- booleans
+
+    /// Returns a binding that is true while both operands are.
+    public static BooleanBinding and(final ObservableBooleanValue op1, final ObservableBooleanValue op2) {
+        operands(op1, op2);
+        return new Fn.BooleanFn(() -> op1.get() && op2.get(), op1, op2);
+    }
+
+    /// Returns a binding that is true while either operand is.
+    public static BooleanBinding or(final ObservableBooleanValue op1, final ObservableBooleanValue op2) {
+        operands(op1, op2);
+        return new Fn.BooleanFn(() -> op1.get() || op2.get(), op1, op2);
+    }
+
+    /// Returns a binding holding the opposite of a boolean.
+    public static BooleanBinding not(final ObservableBooleanValue op) {
+        if (op == null) {
+            throw new NullPointerException("Operand cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> !op.get(), op);
+    }
+
+    /// Returns a binding telling whether two booleans are equal.
+    public static BooleanBinding equal(final ObservableBooleanValue op1, final ObservableBooleanValue op2) {
+        operands(op1, op2);
+        return new Fn.BooleanFn(() -> op1.get() == op2.get(), op1, op2);
+    }
+
+    /// Returns a binding telling whether two booleans differ.
+    public static BooleanBinding notEqual(final ObservableBooleanValue op1, final ObservableBooleanValue op2) {
+        operands(op1, op2);
+        return new Fn.BooleanFn(() -> op1.get() != op2.get(), op1, op2);
+    }
+
+    // ---- objects
+
+    private static boolean same(Object x, Object y) {
+        return x == null ? y == null : x.equals(y);
+    }
+
+    /// Returns a binding telling whether two objects are equal.
+    public static BooleanBinding equal(final ObservableObjectValue<?> op1, final ObservableObjectValue<?> op2) {
+        operands(op1, op2);
+        return new Fn.BooleanFn(() -> same(op1.get(), op2.get()), op1, op2);
+    }
+
+    /// Returns a binding telling whether an object equals a constant.
+    public static BooleanBinding equal(final ObservableObjectValue<?> op1, Object op2) {
+        if (op1 == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> same(op1.get(), op2), op1);
+    }
+
+    /// Returns a binding telling whether a constant equals an object.
+    public static BooleanBinding equal(Object op1, final ObservableObjectValue<?> op2) {
+        if (op2 == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> same(op1, op2.get()), op2);
+    }
+
+    /// Returns a binding telling whether two objects differ.
+    public static BooleanBinding notEqual(final ObservableObjectValue<?> op1, final ObservableObjectValue<?> op2) {
+        operands(op1, op2);
+        return new Fn.BooleanFn(() -> !same(op1.get(), op2.get()), op1, op2);
+    }
+
+    /// Returns a binding telling whether an object differs from a constant.
+    public static BooleanBinding notEqual(final ObservableObjectValue<?> op1, Object op2) {
+        if (op1 == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> !same(op1.get(), op2), op1);
+    }
+
+    /// Returns a binding telling whether a constant differs from an object.
+    public static BooleanBinding notEqual(Object op1, final ObservableObjectValue<?> op2) {
+        if (op2 == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> !same(op1, op2.get()), op2);
+    }
+
+    /// Returns a binding telling whether a value is `null`.
+    public static BooleanBinding isNull(final ObservableObjectValue<?> op) {
+        if (op == null) {
+            throw new NullPointerException("Operand cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> op.get() == null, op);
+    }
+
+    /// Returns a binding telling whether a value is not `null`.
+    public static BooleanBinding isNotNull(final ObservableObjectValue<?> op) {
+        if (op == null) {
+            throw new NullPointerException("Operand cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> op.get() != null, op);
+    }
+
+    // ---- strings
+
+    /// Returns a binding holding the length of a string; zero for `null`.
+    public static IntegerBinding length(final ObservableStringValue op) {
+        if (op == null) {
+            throw new NullPointerException("Operand cannot be null");
+        }
+        return new Fn.IntegerFn(() -> {
+            String value = op.get();
+            return value == null ? 0 : value.length();
+        }, op);
+    }
+
+    /// Returns a binding telling whether a string is `null` or empty.
+    public static BooleanBinding isEmpty(final ObservableStringValue op) {
+        if (op == null) {
+            throw new NullPointerException("Operand cannot be null");
+        }
+        return new Fn.BooleanFn(() -> {
+            String value = op.get();
+            return value == null || value.length() == 0;
+        }, op);
+    }
+
+    /// Returns a binding telling whether a string has any character.
+    public static BooleanBinding isNotEmpty(final ObservableStringValue op) {
+        if (op == null) {
+            throw new NullPointerException("Operand cannot be null");
+        }
+        return new Fn.BooleanFn(() -> {
+            String value = op.get();
+            return value != null && value.length() > 0;
+        }, op);
+    }
+
+    /// Returns an expression holding the text of every argument in a row.
+    /// An argument that is an observable value contributes its current
+    /// value and is observed.
+    public static StringExpression concat(Object... args) {
+        final Object[] source = args == null ? new Object[0] : args.clone();
+        return new Fn.StringFn(() -> {
+            StringBuilder result = new StringBuilder();
+            for (Object arg : source) {
+                result.append(arg instanceof ObservableValue ? ((ObservableValue<?>) arg).getValue() : arg);
+            }
+            return result.toString();
+        }, observables(source));
+    }
+
+    /// Returns any observable value as a string expression: the value itself
+    /// when it already is one, otherwise a binding holding its text.
+    public static StringExpression convert(ObservableValue<?> observableValue) {
+        if (observableValue instanceof StringExpression) {
+            return (StringExpression) observableValue;
+        }
+        return text(observableValue);
+    }
+
+    /// Returns an expression holding the arguments formatted with a
+    /// `String.format` pattern. An argument that is an observable value
+    /// contributes its current value and is observed.
+    public static StringExpression format(String format, Object... args) {
+        return formatted(format, args);
+    }
+
+    // ---- collections
+
+    /// Returns a binding holding the size of a list.
+    public static <E> IntegerBinding size(final ObservableList<E> op) {
+        if (op == null) {
+            throw new NullPointerException("List cannot be null.");
+        }
+        return new Fn.IntegerFn(() -> op.size(), op);
+    }
+
+    /// Returns a binding telling whether a list is empty.
+    public static <E> BooleanBinding isEmpty(final ObservableList<E> op) {
+        if (op == null) {
+            throw new NullPointerException("List cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> op.isEmpty(), op);
+    }
+
+    /// Returns a binding telling whether a list has any element.
+    public static <E> BooleanBinding isNotEmpty(final ObservableList<E> op) {
+        if (op == null) {
+            throw new NullPointerException("List cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> !op.isEmpty(), op);
+    }
+
+    /// Returns a binding holding the element at a position of a list, or
+    /// `null` while the list is shorter than that.
+    public static <E> ObjectBinding<E> valueAt(final ObservableList<E> op, final int index) {
+        if (op == null) {
+            throw new NullPointerException("List cannot be null.");
+        }
+        if (index < 0) {
+            throw new IllegalArgumentException("Index cannot be negative");
+        }
+        return new Fn.ObjectFn<E>(() -> index < op.size() ? op.get(index) : null, op);
+    }
+
+    /// Returns a binding holding the element at an observed position of a
+    /// list, or `null` while the position is outside the list.
+    public static <E> ObjectBinding<E> valueAt(final ObservableList<E> op, final ObservableIntegerValue index) {
+        return valueAt(op, (ObservableNumberValue) index);
+    }
+
+    /// Returns a binding holding the element at an observed position of a
+    /// list, or `null` while the position is outside the list.
+    public static <E> ObjectBinding<E> valueAt(final ObservableList<E> op, final ObservableNumberValue index) {
+        if (op == null || index == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+        return new Fn.ObjectFn<E>(() -> {
+            int at = index.intValue();
+            return at >= 0 && at < op.size() ? op.get(at) : null;
+        }, op, index);
+    }
+
+    /// Returns a binding holding the size of a set.
+    public static <E> IntegerBinding size(final ObservableSet<E> op) {
+        if (op == null) {
+            throw new NullPointerException("Set cannot be null.");
+        }
+        return new Fn.IntegerFn(() -> op.size(), op);
+    }
+
+    /// Returns a binding telling whether a set is empty.
+    public static <E> BooleanBinding isEmpty(final ObservableSet<E> op) {
+        if (op == null) {
+            throw new NullPointerException("Set cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> op.isEmpty(), op);
+    }
+
+    /// Returns a binding telling whether a set has any element.
+    public static <E> BooleanBinding isNotEmpty(final ObservableSet<E> op) {
+        if (op == null) {
+            throw new NullPointerException("Set cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> !op.isEmpty(), op);
+    }
+
+    /// Returns a binding holding the size of a map.
+    public static <K, V> IntegerBinding size(final ObservableMap<K, V> op) {
+        if (op == null) {
+            throw new NullPointerException("Map cannot be null.");
+        }
+        return new Fn.IntegerFn(() -> op.size(), op);
+    }
+
+    /// Returns a binding telling whether a map is empty.
+    public static <K, V> BooleanBinding isEmpty(final ObservableMap<K, V> op) {
+        if (op == null) {
+            throw new NullPointerException("Map cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> op.isEmpty(), op);
+    }
+
+    /// Returns a binding telling whether a map has any entry.
+    public static <K, V> BooleanBinding isNotEmpty(final ObservableMap<K, V> op) {
+        if (op == null) {
+            throw new NullPointerException("Map cannot be null.");
+        }
+        return new Fn.BooleanFn(() -> !op.isEmpty(), op);
+    }
+
+    /// Returns a binding holding the value a map has for a key.
+    public static <K, V> ObjectBinding<V> valueAt(final ObservableMap<K, V> op, final K key) {
+        if (op == null) {
+            throw new NullPointerException("Map cannot be null.");
+        }
+        return new Fn.ObjectFn<V>(() -> op.get(key), op);
+    }
+
+    /// Returns a binding holding the value a map has for an observed key.
+    public static <K, V> ObjectBinding<V> valueAt(final ObservableMap<K, V> op,
+            final ObservableValue<? extends K> key) {
+        if (op == null || key == null) {
+            throw new NullPointerException("Operands cannot be null.");
+        }
+        return new Fn.ObjectFn<V>(() -> op.get(key.getValue()), op, key);
+    }
+
+    // ---- ternary
+
+    /// Starts a ternary binding: `when(condition).then(a).otherwise(b)`.
+    public static When when(final ObservableBooleanValue condition) {
+        return new When(condition);
+    }
+
+    // ---- bidirectional bindings
+
+    /// Keeps two properties equal, starting with the value of the second.
+    /// Neither property keeps the other alive.
+    public static <T> void bindBidirectional(Property<T> property1, Property<T> property2) {
+        BidirectionalBinding.bind(property1, property2);
+    }
+
+    /// Removes a bidirectional binding between two properties.
+    public static <T> void unbindBidirectional(Property<T> property1, Property<T> property2) {
+        BidirectionalBinding.unbind(property1, property2);
+    }
+
+    /// Removes a bidirectional binding between two objects, whatever kind
+    /// it was.
+    public static void unbindBidirectional(Object property1, Object property2) {
+        BidirectionalBinding.unbind(property1, property2);
+    }
+
+    /// Keeps a string property and a property of another type in sync
+    /// through a converter, starting with the text of the second.
+    public static <T> void bindBidirectional(Property<String> stringProperty, Property<T> otherProperty,
+            final StringConverter<T> converter) {
+        if (converter == null) {
+            throw new NullPointerException("Converter cannot be null");
+        }
+        BidirectionalBinding.bind(stringProperty, otherProperty, value -> converter.toString(value),
+                text -> converter.fromString(text));
+    }
+
+    // ---- content bindings
+
+    /// Makes a list mirror an observable list: it takes the content now and
+    /// follows every later change. The list is held weakly.
+    public static <E> void bindContent(List<E> list1, ObservableList<? extends E> list2) {
+        ContentBindings.bind(list1, list2);
+    }
+
+    /// Makes a set mirror an observable set, held weakly.
+    public static <E> void bindContent(Set<E> set1, ObservableSet<? extends E> set2) {
+        ContentBindings.bind(set1, set2);
+    }
+
+    /// Makes a map mirror an observable map, held weakly.
+    public static <K, V> void bindContent(Map<K, V> map1, ObservableMap<? extends K, ? extends V> map2) {
+        ContentBindings.bind(map1, map2);
+    }
+
+    /// Removes a content binding of the first object to the second.
+    public static void unbindContent(Object obj1, Object obj2) {
+        ContentBindings.unbind(obj1, obj2);
+    }
+
+    /// Keeps two observable lists equal, starting with the content of the
+    /// second. Neither list keeps the other alive.
+    public static <E> void bindContentBidirectional(ObservableList<E> list1, ObservableList<E> list2) {
+        ContentBindings.bindBidirectional(list1, list2);
+    }
+
+    /// Removes a bidirectional content binding between two objects.
+    public static void unbindContentBidirectional(Object obj1, Object obj2) {
+        ContentBindings.unbindBidirectional(obj1, obj2);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/BooleanBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/BooleanBinding.java
new file mode 100644
index 00000000000..2332cb3ed71
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/BooleanBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes a boolean.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class BooleanBinding extends BooleanExpression implements Binding<Boolean> {
+
+    private boolean value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<Boolean> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public BooleanBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Boolean> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Boolean> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final boolean get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract boolean computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "BooleanBinding [value: " + get() + "]" : "BooleanBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/BooleanExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/BooleanExpression.java
new file mode 100644
index 00000000000..0db52da9975
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/BooleanExpression.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableBooleanValue;
+import javafx.beans.value.ObservableValue;
+
+/// The fluent operations of an observable boolean.
+public abstract class BooleanExpression implements ObservableBooleanValue {
+
+    /// Creates the expression.
+    public BooleanExpression() {
+    }
+
+    @Override
+    public Boolean getValue() {
+        return Boolean.valueOf(get());
+    }
+
+    /// Returns the value as an expression: the value itself when it already
+    /// is one, otherwise a binding that follows it.
+    public static BooleanExpression booleanExpression(final ObservableBooleanValue value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof BooleanExpression) {
+            return (BooleanExpression) value;
+        }
+        return new Fn.BooleanFn(() -> value.get(), value);
+    }
+
+    /// Returns an expression following a boxed boolean; `null` reads as
+    /// `false`.
+    public static BooleanExpression booleanExpression(final ObservableValue<Boolean> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof BooleanExpression) {
+            return (BooleanExpression) value;
+        }
+        return new Fn.BooleanFn(() -> {
+            Boolean current = value.getValue();
+            return current != null && current.booleanValue();
+        }, value);
+    }
+
+    /// Returns a binding that is true while this value and the other are.
+    public BooleanBinding and(final ObservableBooleanValue other) {
+        return Bindings.and(this, other);
+    }
+
+    /// Returns a binding that is true while this value or the other is.
+    public BooleanBinding or(final ObservableBooleanValue other) {
+        return Bindings.or(this, other);
+    }
+
+    /// Returns a binding holding the opposite of this value.
+    public BooleanBinding not() {
+        return Bindings.not(this);
+    }
+
+    /// Returns a binding telling whether this value equals another.
+    public BooleanBinding isEqualTo(final ObservableBooleanValue other) {
+        return Bindings.equal(this, other);
+    }
+
+    /// Returns a binding telling whether this value differs from another.
+    public BooleanBinding isNotEqualTo(final ObservableBooleanValue other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    /// Returns a binding holding this value as `"true"` or `"false"`.
+    public StringBinding asString() {
+        return Bindings.text(this);
+    }
+
+    /// Returns an object expression holding the boxed value.
+    public ObjectExpression<Boolean> asObject() {
+        return new Fn.ObjectFn<Boolean>(() -> getValue(), this);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/Const.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/Const.java
new file mode 100644
index 00000000000..d5591e23cbc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/Const.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableDoubleValue;
+import javafx.beans.value.ObservableFloatValue;
+import javafx.beans.value.ObservableIntegerValue;
+import javafx.beans.value.ObservableLongValue;
+import javafx.beans.value.ObservableNumberValue;
+import javafx.beans.value.ObservableStringValue;
+
+/// A constant dressed as an observable number, so an operator taking a
+/// constant is the same code as the one taking two observables. It never
+/// changes and therefore keeps no listeners.
+abstract class Const implements ObservableNumberValue {
+
+    private final Number value;
+
+    Const(Number value) {
+        this.value = value;
+    }
+
+    static Const of(double value) {
+        return new OfDouble(value);
+    }
+
+    static Const of(float value) {
+        return new OfFloat(value);
+    }
+
+    static Const of(long value) {
+        return new OfLong(value);
+    }
+
+    static Const of(int value) {
+        return new OfInt(value);
+    }
+
+    static boolean isConstant(Object candidate) {
+        return candidate instanceof Const || candidate instanceof Text;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+    }
+
+    @Override
+    public Number getValue() {
+        return value;
+    }
+
+    @Override
+    public int intValue() {
+        return value.intValue();
+    }
+
+    @Override
+    public long longValue() {
+        return value.longValue();
+    }
+
+    @Override
+    public float floatValue() {
+        return value.floatValue();
+    }
+
+    @Override
+    public double doubleValue() {
+        return value.doubleValue();
+    }
+
+    static final class OfDouble extends Const implements ObservableDoubleValue {
+        OfDouble(double value) {
+            super(Double.valueOf(value));
+        }
+
+        @Override
+        public double get() {
+            return doubleValue();
+        }
+    }
+
+    static final class OfFloat extends Const implements ObservableFloatValue {
+        OfFloat(float value) {
+            super(Float.valueOf(value));
+        }
+
+        @Override
+        public float get() {
+            return floatValue();
+        }
+    }
+
+    static final class OfLong extends Const implements ObservableLongValue {
+        OfLong(long value) {
+            super(Long.valueOf(value));
+        }
+
+        @Override
+        public long get() {
+            return longValue();
+        }
+    }
+
+    static final class OfInt extends Const implements ObservableIntegerValue {
+        OfInt(int value) {
+            super(Integer.valueOf(value));
+        }
+
+        @Override
+        public int get() {
+            return intValue();
+        }
+    }
+
+    /// A constant string.
+    static final class Text implements ObservableStringValue {
+        private final String value;
+
+        Text(String value) {
+            this.value = value;
+        }
+
+        @Override
+        public void addListener(InvalidationListener listener) {
+        }
+
+        @Override
+        public void removeListener(InvalidationListener listener) {
+        }
+
+        @Override
+        public void addListener(ChangeListener<? super String> listener) {
+        }
+
+        @Override
+        public void removeListener(ChangeListener<? super String> listener) {
+        }
+
+        @Override
+        public String get() {
+            return value;
+        }
+
+        @Override
+        public String getValue() {
+            return value;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/DoubleBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/DoubleBinding.java
new file mode 100644
index 00000000000..757d1a351d6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/DoubleBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes a `double`.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class DoubleBinding extends DoubleExpression implements NumberBinding {
+
+    private double value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<Number> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public DoubleBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final double get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract double computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "DoubleBinding [value: " + get() + "]" : "DoubleBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/DoubleExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/DoubleExpression.java
new file mode 100644
index 00000000000..e9e57320526
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/DoubleExpression.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableDoubleValue;
+import javafx.beans.value.ObservableNumberValue;
+import javafx.beans.value.ObservableValue;
+
+/// A [NumberExpression] whose value is a `double`, with the arithmetic results typed
+/// the way Java would type them.
+public abstract class DoubleExpression extends NumberExpressionBase implements ObservableDoubleValue {
+
+    /// Creates the expression.
+    public DoubleExpression() {
+    }
+
+    @Override
+    public int intValue() {
+        return (int) get();
+    }
+
+    @Override
+    public long longValue() {
+        return (long) get();
+    }
+
+    @Override
+    public float floatValue() {
+        return (float) get();
+    }
+
+    @Override
+    public double doubleValue() {
+        return (double) get();
+    }
+
+    @Override
+    public Double getValue() {
+        return Double.valueOf(get());
+    }
+
+    /// Returns the value as an expression: the value itself when it already
+    /// is one, otherwise a binding that follows it.
+    public static DoubleExpression doubleExpression(final ObservableDoubleValue value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof DoubleExpression) {
+            return (DoubleExpression) value;
+        }
+        return new Fn.DoubleFn(new Fn.ToDouble() {
+            @Override
+            public double get() {
+                return value.get();
+            }
+        }, value);
+    }
+
+    /// Returns an expression following a boxed numeric value; a `null` value
+    /// reads as zero.
+    public static <T extends Number> DoubleExpression doubleExpression(final ObservableValue<T> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof DoubleExpression) {
+            return (DoubleExpression) value;
+        }
+        return new Fn.DoubleFn(new Fn.ToDouble() {
+            @Override
+            public double get() {
+                T current = value.getValue();
+                return current == null ? 0 : current.doubleValue();
+            }
+        }, value);
+    }
+
+    /// Returns an object expression holding the boxed value.
+    public ObjectExpression<Double> asObject() {
+        return new Fn.ObjectFn<Double>(new java.util.function.Supplier<Double>() {
+            @Override
+            public Double get() {
+                return getValue();
+            }
+        }, this);
+    }
+
+    @Override
+    public DoubleBinding negate() {
+        return (DoubleBinding) Bindings.negate(this);
+    }
+
+    @Override
+    public DoubleBinding add(final ObservableNumberValue other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding add(final double other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding add(final float other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding add(final long other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding add(final int other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final ObservableNumberValue other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final double other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final float other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final long other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final int other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final ObservableNumberValue other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final double other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final float other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final long other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final int other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final ObservableNumberValue other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final double other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final float other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final long other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final int other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/FloatBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/FloatBinding.java
new file mode 100644
index 00000000000..9efeb60903f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/FloatBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes a `float`.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class FloatBinding extends FloatExpression implements NumberBinding {
+
+    private float value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<Number> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public FloatBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final float get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract float computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "FloatBinding [value: " + get() + "]" : "FloatBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/FloatExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/FloatExpression.java
new file mode 100644
index 00000000000..fb940b995b6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/FloatExpression.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableFloatValue;
+import javafx.beans.value.ObservableValue;
+
+/// A [NumberExpression] whose value is a `float`, with the arithmetic results typed
+/// the way Java would type them.
+public abstract class FloatExpression extends NumberExpressionBase implements ObservableFloatValue {
+
+    /// Creates the expression.
+    public FloatExpression() {
+    }
+
+    @Override
+    public int intValue() {
+        return (int) get();
+    }
+
+    @Override
+    public long longValue() {
+        return (long) get();
+    }
+
+    @Override
+    public float floatValue() {
+        return (float) get();
+    }
+
+    @Override
+    public double doubleValue() {
+        return (double) get();
+    }
+
+    @Override
+    public Float getValue() {
+        return Float.valueOf(get());
+    }
+
+    /// Returns the value as an expression: the value itself when it already
+    /// is one, otherwise a binding that follows it.
+    public static FloatExpression floatExpression(final ObservableFloatValue value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof FloatExpression) {
+            return (FloatExpression) value;
+        }
+        return new Fn.FloatFn(new Fn.ToFloat() {
+            @Override
+            public float get() {
+                return value.get();
+            }
+        }, value);
+    }
+
+    /// Returns an expression following a boxed numeric value; a `null` value
+    /// reads as zero.
+    public static <T extends Number> FloatExpression floatExpression(final ObservableValue<T> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof FloatExpression) {
+            return (FloatExpression) value;
+        }
+        return new Fn.FloatFn(new Fn.ToFloat() {
+            @Override
+            public float get() {
+                T current = value.getValue();
+                return current == null ? 0 : current.floatValue();
+            }
+        }, value);
+    }
+
+    /// Returns an object expression holding the boxed value.
+    public ObjectExpression<Float> asObject() {
+        return new Fn.ObjectFn<Float>(new java.util.function.Supplier<Float>() {
+            @Override
+            public Float get() {
+                return getValue();
+            }
+        }, this);
+    }
+
+    @Override
+    public FloatBinding negate() {
+        return (FloatBinding) Bindings.negate(this);
+    }
+
+    @Override
+    public DoubleBinding add(final double other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public FloatBinding add(final float other) {
+        return (FloatBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public FloatBinding add(final long other) {
+        return (FloatBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public FloatBinding add(final int other) {
+        return (FloatBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final double other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public FloatBinding subtract(final float other) {
+        return (FloatBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public FloatBinding subtract(final long other) {
+        return (FloatBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public FloatBinding subtract(final int other) {
+        return (FloatBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final double other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public FloatBinding multiply(final float other) {
+        return (FloatBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public FloatBinding multiply(final long other) {
+        return (FloatBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public FloatBinding multiply(final int other) {
+        return (FloatBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final double other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public FloatBinding divide(final float other) {
+        return (FloatBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public FloatBinding divide(final long other) {
+        return (FloatBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public FloatBinding divide(final int other) {
+        return (FloatBinding) Bindings.divide(this, other);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/Fn.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/Fn.java
new file mode 100644
index 00000000000..551c251a501
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/Fn.java
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.Observable;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Bindings whose computation is a function object. Every operator of
+/// [Bindings] and of the fluent expressions is one of these.
+final class Fn {
+
+    private Fn() {
+    }
+
+    static ObservableList<?> dependencies(Observable[] deps) {
+        if (deps == null || deps.length == 0) {
+            return FXCollections.emptyObservableList();
+        }
+        if (deps.length == 1) {
+            return FXCollections.singletonObservableList(deps[0]);
+        }
+        return FXCollections.unmodifiableObservableList(FXCollections.observableArrayList(deps));
+    }
+
+    /// Computes a boolean.
+    interface ToBoolean {
+        boolean get();
+    }
+
+    /// A binding computing a boolean from a function.
+    static final class BooleanFn extends BooleanBinding {
+        private final ToBoolean fn;
+        private final Observable[] deps;
+
+        BooleanFn(ToBoolean fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected boolean computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+
+    /// Computes a `int`.
+    interface ToInteger {
+        int get();
+    }
+
+    /// A binding computing a `int` from a function.
+    static final class IntegerFn extends IntegerBinding {
+        private final ToInteger fn;
+        private final Observable[] deps;
+
+        IntegerFn(ToInteger fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected int computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+
+    /// Computes a `long`.
+    interface ToLong {
+        long get();
+    }
+
+    /// A binding computing a `long` from a function.
+    static final class LongFn extends LongBinding {
+        private final ToLong fn;
+        private final Observable[] deps;
+
+        LongFn(ToLong fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected long computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+
+    /// Computes a `float`.
+    interface ToFloat {
+        float get();
+    }
+
+    /// A binding computing a `float` from a function.
+    static final class FloatFn extends FloatBinding {
+        private final ToFloat fn;
+        private final Observable[] deps;
+
+        FloatFn(ToFloat fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected float computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+
+    /// Computes a `double`.
+    interface ToDouble {
+        double get();
+    }
+
+    /// A binding computing a `double` from a function.
+    static final class DoubleFn extends DoubleBinding {
+        private final ToDouble fn;
+        private final Observable[] deps;
+
+        DoubleFn(ToDouble fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected double computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+
+    /// Computes a string.
+    interface ToString {
+        String get();
+    }
+
+    /// A binding computing a string from a function.
+    static final class StringFn extends StringBinding {
+        private final ToString fn;
+        private final Observable[] deps;
+
+        StringFn(ToString fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected String computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+
+    /// A binding computing an object from a function.
+    static final class ObjectFn<T> extends ObjectBinding<T> {
+        private final java.util.function.Supplier<T> fn;
+        private final Observable[] deps;
+
+        ObjectFn(java.util.function.Supplier<T> fn, Observable... deps) {
+            this.fn = fn;
+            this.deps = deps;
+            bind(deps);
+        }
+
+        @Override
+        protected T computeValue() {
+            return fn.get();
+        }
+
+        @Override
+        public void dispose() {
+            unbind(deps);
+        }
+
+        @Override
+        public ObservableList<?> getDependencies() {
+            return dependencies(deps);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/IntegerBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/IntegerBinding.java
new file mode 100644
index 00000000000..be41eeee1f3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/IntegerBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes a `int`.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class IntegerBinding extends IntegerExpression implements NumberBinding {
+
+    private int value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<Number> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public IntegerBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final int get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract int computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "IntegerBinding [value: " + get() + "]" : "IntegerBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/IntegerExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/IntegerExpression.java
new file mode 100644
index 00000000000..c1e6c3f5b16
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/IntegerExpression.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableIntegerValue;
+import javafx.beans.value.ObservableValue;
+
+/// A [NumberExpression] whose value is a `int`, with the arithmetic results typed
+/// the way Java would type them.
+public abstract class IntegerExpression extends NumberExpressionBase implements ObservableIntegerValue {
+
+    /// Creates the expression.
+    public IntegerExpression() {
+    }
+
+    @Override
+    public int intValue() {
+        return (int) get();
+    }
+
+    @Override
+    public long longValue() {
+        return (long) get();
+    }
+
+    @Override
+    public float floatValue() {
+        return (float) get();
+    }
+
+    @Override
+    public double doubleValue() {
+        return (double) get();
+    }
+
+    @Override
+    public Integer getValue() {
+        return Integer.valueOf(get());
+    }
+
+    /// Returns the value as an expression: the value itself when it already
+    /// is one, otherwise a binding that follows it.
+    public static IntegerExpression integerExpression(final ObservableIntegerValue value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof IntegerExpression) {
+            return (IntegerExpression) value;
+        }
+        return new Fn.IntegerFn(new Fn.ToInteger() {
+            @Override
+            public int get() {
+                return value.get();
+            }
+        }, value);
+    }
+
+    /// Returns an expression following a boxed numeric value; a `null` value
+    /// reads as zero.
+    public static <T extends Number> IntegerExpression integerExpression(final ObservableValue<T> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof IntegerExpression) {
+            return (IntegerExpression) value;
+        }
+        return new Fn.IntegerFn(new Fn.ToInteger() {
+            @Override
+            public int get() {
+                T current = value.getValue();
+                return current == null ? 0 : current.intValue();
+            }
+        }, value);
+    }
+
+    /// Returns an object expression holding the boxed value.
+    public ObjectExpression<Integer> asObject() {
+        return new Fn.ObjectFn<Integer>(new java.util.function.Supplier<Integer>() {
+            @Override
+            public Integer get() {
+                return getValue();
+            }
+        }, this);
+    }
+
+    @Override
+    public IntegerBinding negate() {
+        return (IntegerBinding) Bindings.negate(this);
+    }
+
+    @Override
+    public DoubleBinding add(final double other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public FloatBinding add(final float other) {
+        return (FloatBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public LongBinding add(final long other) {
+        return (LongBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public IntegerBinding add(final int other) {
+        return (IntegerBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final double other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public FloatBinding subtract(final float other) {
+        return (FloatBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public LongBinding subtract(final long other) {
+        return (LongBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public IntegerBinding subtract(final int other) {
+        return (IntegerBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final double other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public FloatBinding multiply(final float other) {
+        return (FloatBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public LongBinding multiply(final long other) {
+        return (LongBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public IntegerBinding multiply(final int other) {
+        return (IntegerBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final double other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public FloatBinding divide(final float other) {
+        return (FloatBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public LongBinding divide(final long other) {
+        return (LongBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public IntegerBinding divide(final int other) {
+        return (IntegerBinding) Bindings.divide(this, other);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/ListExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/ListExpression.java
new file mode 100644
index 00000000000..63bff20d14d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/ListExpression.java
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.value.ObservableIntegerValue;
+import javafx.beans.value.ObservableListValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// The fluent operations of an observable reference to an observable list.
+///
+/// The expression is itself a list: every list operation goes to the list
+/// it currently holds. While it holds `null` it reads as an empty list and
+/// cannot be modified.
+public abstract class ListExpression<E> implements ObservableListValue<E> {
+
+    /// Creates the expression.
+    public ListExpression() {
+    }
+
+    private ObservableList<E> content() {
+        ObservableList<E> list = get();
+        return list == null ? FXCollections.<E>emptyObservableList() : list;
+    }
+
+    @Override
+    public ObservableList<E> getValue() {
+        return get();
+    }
+
+    /// Returns the number of elements.
+    public int getSize() {
+        return size();
+    }
+
+    /// Returns a property holding the number of elements.
+    public abstract ReadOnlyIntegerProperty sizeProperty();
+
+    /// Returns a property telling whether the list is empty.
+    public abstract ReadOnlyBooleanProperty emptyProperty();
+
+    /// Returns a binding holding the element at a position; `null` when the
+    /// position is outside the list.
+    public ObjectBinding<E> valueAt(int index) {
+        return Bindings.valueAt(this, index);
+    }
+
+    /// Returns a binding holding the element at an observable position.
+    public ObjectBinding<E> valueAt(ObservableIntegerValue index) {
+        return Bindings.valueAt(this, index);
+    }
+
+    /// Returns a binding telling whether this list and another hold equal
+    /// elements in the same order.
+    public BooleanBinding isEqualTo(final ObservableList<?> other) {
+        return new Fn.BooleanFn(() -> sameContent(other), this, other);
+    }
+
+    /// Returns a binding telling whether this list and another differ.
+    public BooleanBinding isNotEqualTo(final ObservableList<?> other) {
+        return new Fn.BooleanFn(() -> !sameContent(other), this, other);
+    }
+
+    private boolean sameContent(ObservableList<?> other) {
+        ObservableList<E> list = get();
+        if (list == null) {
+            return other == null;
+        }
+        return other != null && list.equals(other);
+    }
+
+    /// Returns a binding telling whether no list is held.
+    public BooleanBinding isNull() {
+        return new Fn.BooleanFn(() -> get() == null, this);
+    }
+
+    /// Returns a binding telling whether a list is held.
+    public BooleanBinding isNotNull() {
+        return new Fn.BooleanFn(() -> get() != null, this);
+    }
+
+    /// Returns a binding holding the text of the list.
+    public StringBinding asString() {
+        return Bindings.text(this);
+    }
+
+    @Override
+    public int size() {
+        return content().size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return content().isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object obj) {
+        return content().contains(obj);
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return content().iterator();
+    }
+
+    @Override
+    public Object[] toArray() {
+        return content().toArray();
+    }
+
+    @Override
+    public <T> T[] toArray(T[] array) {
+        return content().toArray(array);
+    }
+
+    @Override
+    public boolean add(E element) {
+        return content().add(element);
+    }
+
+    @Override
+    public boolean remove(Object obj) {
+        return content().remove(obj);
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> objects) {
+        return content().containsAll(objects);
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> elements) {
+        return content().addAll(elements);
+    }
+
+    @Override
+    public boolean addAll(int i, Collection<? extends E> elements) {
+        return content().addAll(i, elements);
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> objects) {
+        return content().removeAll(objects);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> objects) {
+        return content().retainAll(objects);
+    }
+
+    @Override
+    public void clear() {
+        content().clear();
+    }
+
+    @Override
+    public E get(int i) {
+        return content().get(i);
+    }
+
+    @Override
+    public E set(int i, E element) {
+        return content().set(i, element);
+    }
+
+    @Override
+    public void add(int i, E element) {
+        content().add(i, element);
+    }
+
+    @Override
+    public E remove(int i) {
+        return content().remove(i);
+    }
+
+    @Override
+    public int indexOf(Object obj) {
+        return content().indexOf(obj);
+    }
+
+    @Override
+    public int lastIndexOf(Object obj) {
+        return content().lastIndexOf(obj);
+    }
+
+    @Override
+    public ListIterator<E> listIterator() {
+        return content().listIterator();
+    }
+
+    @Override
+    public ListIterator<E> listIterator(int i) {
+        return content().listIterator(i);
+    }
+
+    @Override
+    public List<E> subList(int from, int to) {
+        return content().subList(from, to);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean addAll(E... elements) {
+        return content().addAll(elements);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean setAll(E... elements) {
+        return content().setAll(elements);
+    }
+
+    @Override
+    public boolean setAll(Collection<? extends E> elements) {
+        return content().setAll(elements);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean removeAll(E... elements) {
+        return content().removeAll(elements);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean retainAll(E... elements) {
+        return content().retainAll(elements);
+    }
+
+    @Override
+    public void remove(int from, int to) {
+        content().remove(from, to);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/LongBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/LongBinding.java
new file mode 100644
index 00000000000..cdfad6b8045
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/LongBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes a `long`.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class LongBinding extends LongExpression implements NumberBinding {
+
+    private long value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<Number> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public LongBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final long get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract long computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "LongBinding [value: " + get() + "]" : "LongBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/LongExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/LongExpression.java
new file mode 100644
index 00000000000..879dd746a80
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/LongExpression.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableLongValue;
+import javafx.beans.value.ObservableValue;
+
+/// A [NumberExpression] whose value is a `long`, with the arithmetic results typed
+/// the way Java would type them.
+public abstract class LongExpression extends NumberExpressionBase implements ObservableLongValue {
+
+    /// Creates the expression.
+    public LongExpression() {
+    }
+
+    @Override
+    public int intValue() {
+        return (int) get();
+    }
+
+    @Override
+    public long longValue() {
+        return (long) get();
+    }
+
+    @Override
+    public float floatValue() {
+        return (float) get();
+    }
+
+    @Override
+    public double doubleValue() {
+        return (double) get();
+    }
+
+    @Override
+    public Long getValue() {
+        return Long.valueOf(get());
+    }
+
+    /// Returns the value as an expression: the value itself when it already
+    /// is one, otherwise a binding that follows it.
+    public static LongExpression longExpression(final ObservableLongValue value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof LongExpression) {
+            return (LongExpression) value;
+        }
+        return new Fn.LongFn(new Fn.ToLong() {
+            @Override
+            public long get() {
+                return value.get();
+            }
+        }, value);
+    }
+
+    /// Returns an expression following a boxed numeric value; a `null` value
+    /// reads as zero.
+    public static <T extends Number> LongExpression longExpression(final ObservableValue<T> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof LongExpression) {
+            return (LongExpression) value;
+        }
+        return new Fn.LongFn(new Fn.ToLong() {
+            @Override
+            public long get() {
+                T current = value.getValue();
+                return current == null ? 0 : current.longValue();
+            }
+        }, value);
+    }
+
+    /// Returns an object expression holding the boxed value.
+    public ObjectExpression<Long> asObject() {
+        return new Fn.ObjectFn<Long>(new java.util.function.Supplier<Long>() {
+            @Override
+            public Long get() {
+                return getValue();
+            }
+        }, this);
+    }
+
+    @Override
+    public LongBinding negate() {
+        return (LongBinding) Bindings.negate(this);
+    }
+
+    @Override
+    public DoubleBinding add(final double other) {
+        return (DoubleBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public FloatBinding add(final float other) {
+        return (FloatBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public LongBinding add(final long other) {
+        return (LongBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public LongBinding add(final int other) {
+        return (LongBinding) Bindings.add(this, other);
+    }
+
+    @Override
+    public DoubleBinding subtract(final double other) {
+        return (DoubleBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public FloatBinding subtract(final float other) {
+        return (FloatBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public LongBinding subtract(final long other) {
+        return (LongBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public LongBinding subtract(final int other) {
+        return (LongBinding) Bindings.subtract(this, other);
+    }
+
+    @Override
+    public DoubleBinding multiply(final double other) {
+        return (DoubleBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public FloatBinding multiply(final float other) {
+        return (FloatBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public LongBinding multiply(final long other) {
+        return (LongBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public LongBinding multiply(final int other) {
+        return (LongBinding) Bindings.multiply(this, other);
+    }
+
+    @Override
+    public DoubleBinding divide(final double other) {
+        return (DoubleBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public FloatBinding divide(final float other) {
+        return (FloatBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public LongBinding divide(final long other) {
+        return (LongBinding) Bindings.divide(this, other);
+    }
+
+    @Override
+    public LongBinding divide(final int other) {
+        return (LongBinding) Bindings.divide(this, other);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberBinding.java
new file mode 100644
index 00000000000..a914b59b316
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberBinding.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+/// A binding whose value is a number.
+public interface NumberBinding extends Binding<Number>, NumberExpression {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberExpression.java
new file mode 100644
index 00000000000..3c264645ee3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberExpression.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableNumberValue;
+
+/// The fluent operations of an observable number: arithmetic, comparison and
+/// conversion to text, each returning a binding that follows this number.
+///
+/// The result of an arithmetic operation has the wider of the two operand
+/// types, as the same expression would in Java.
+public interface NumberExpression extends ObservableNumberValue {
+
+    /// Returns a binding computing the negation of this number.
+    NumberBinding negate();
+
+    /// Returns a binding computing the sum of this number and another.
+    NumberBinding add(final ObservableNumberValue other);
+
+    /// Returns a binding computing the sum of this number and a constant.
+    NumberBinding add(final double other);
+
+    /// Returns a binding computing the sum of this number and a constant.
+    NumberBinding add(final float other);
+
+    /// Returns a binding computing the sum of this number and a constant.
+    NumberBinding add(final long other);
+
+    /// Returns a binding computing the sum of this number and a constant.
+    NumberBinding add(final int other);
+
+    /// Returns a binding computing the difference of this number and another.
+    NumberBinding subtract(final ObservableNumberValue other);
+
+    /// Returns a binding computing the difference of this number and a constant.
+    NumberBinding subtract(final double other);
+
+    /// Returns a binding computing the difference of this number and a constant.
+    NumberBinding subtract(final float other);
+
+    /// Returns a binding computing the difference of this number and a constant.
+    NumberBinding subtract(final long other);
+
+    /// Returns a binding computing the difference of this number and a constant.
+    NumberBinding subtract(final int other);
+
+    /// Returns a binding computing the product of this number and another.
+    NumberBinding multiply(final ObservableNumberValue other);
+
+    /// Returns a binding computing the product of this number and a constant.
+    NumberBinding multiply(final double other);
+
+    /// Returns a binding computing the product of this number and a constant.
+    NumberBinding multiply(final float other);
+
+    /// Returns a binding computing the product of this number and a constant.
+    NumberBinding multiply(final long other);
+
+    /// Returns a binding computing the product of this number and a constant.
+    NumberBinding multiply(final int other);
+
+    /// Returns a binding computing the quotient of this number and another.
+    NumberBinding divide(final ObservableNumberValue other);
+
+    /// Returns a binding computing the quotient of this number and a constant.
+    NumberBinding divide(final double other);
+
+    /// Returns a binding computing the quotient of this number and a constant.
+    NumberBinding divide(final float other);
+
+    /// Returns a binding computing the quotient of this number and a constant.
+    NumberBinding divide(final long other);
+
+    /// Returns a binding computing the quotient of this number and a constant.
+    NumberBinding divide(final int other);
+
+    /// Returns a binding telling whether this number and another are equal.
+    BooleanBinding isEqualTo(final ObservableNumberValue other);
+
+    /// Returns a binding telling whether this number and another are equal, within a tolerance.
+    BooleanBinding isEqualTo(final ObservableNumberValue other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are equal, within a tolerance.
+    BooleanBinding isEqualTo(final double other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are equal, within a tolerance.
+    BooleanBinding isEqualTo(final float other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are equal.
+    BooleanBinding isEqualTo(final long other);
+
+    /// Returns a binding telling whether this number and a constant are equal, within a tolerance.
+    BooleanBinding isEqualTo(final long other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are equal.
+    BooleanBinding isEqualTo(final int other);
+
+    /// Returns a binding telling whether this number and a constant are equal, within a tolerance.
+    BooleanBinding isEqualTo(final int other, double epsilon);
+
+    /// Returns a binding telling whether this number and another are not equal.
+    BooleanBinding isNotEqualTo(final ObservableNumberValue other);
+
+    /// Returns a binding telling whether this number and another are not equal, within a tolerance.
+    BooleanBinding isNotEqualTo(final ObservableNumberValue other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are not equal, within a tolerance.
+    BooleanBinding isNotEqualTo(final double other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are not equal, within a tolerance.
+    BooleanBinding isNotEqualTo(final float other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are not equal.
+    BooleanBinding isNotEqualTo(final long other);
+
+    /// Returns a binding telling whether this number and a constant are not equal, within a tolerance.
+    BooleanBinding isNotEqualTo(final long other, double epsilon);
+
+    /// Returns a binding telling whether this number and a constant are not equal.
+    BooleanBinding isNotEqualTo(final int other);
+
+    /// Returns a binding telling whether this number and a constant are not equal, within a tolerance.
+    BooleanBinding isNotEqualTo(final int other, double epsilon);
+
+    /// Returns a binding telling whether this number is greater than another.
+    BooleanBinding greaterThan(final ObservableNumberValue other);
+
+    /// Returns a binding telling whether this number is greater than a constant.
+    BooleanBinding greaterThan(final double other);
+
+    /// Returns a binding telling whether this number is greater than a constant.
+    BooleanBinding greaterThan(final float other);
+
+    /// Returns a binding telling whether this number is greater than a constant.
+    BooleanBinding greaterThan(final long other);
+
+    /// Returns a binding telling whether this number is greater than a constant.
+    BooleanBinding greaterThan(final int other);
+
+    /// Returns a binding telling whether this number is less than another.
+    BooleanBinding lessThan(final ObservableNumberValue other);
+
+    /// Returns a binding telling whether this number is less than a constant.
+    BooleanBinding lessThan(final double other);
+
+    /// Returns a binding telling whether this number is less than a constant.
+    BooleanBinding lessThan(final float other);
+
+    /// Returns a binding telling whether this number is less than a constant.
+    BooleanBinding lessThan(final long other);
+
+    /// Returns a binding telling whether this number is less than a constant.
+    BooleanBinding lessThan(final int other);
+
+    /// Returns a binding telling whether this number is greater than or equal to another.
+    BooleanBinding greaterThanOrEqualTo(final ObservableNumberValue other);
+
+    /// Returns a binding telling whether this number is greater than or equal to a constant.
+    BooleanBinding greaterThanOrEqualTo(final double other);
+
+    /// Returns a binding telling whether this number is greater than or equal to a constant.
+    BooleanBinding greaterThanOrEqualTo(final float other);
+
+    /// Returns a binding telling whether this number is greater than or equal to a constant.
+    BooleanBinding greaterThanOrEqualTo(final long other);
+
+    /// Returns a binding telling whether this number is greater than or equal to a constant.
+    BooleanBinding greaterThanOrEqualTo(final int other);
+
+    /// Returns a binding telling whether this number is less than or equal to another.
+    BooleanBinding lessThanOrEqualTo(final ObservableNumberValue other);
+
+    /// Returns a binding telling whether this number is less than or equal to a constant.
+    BooleanBinding lessThanOrEqualTo(final double other);
+
+    /// Returns a binding telling whether this number is less than or equal to a constant.
+    BooleanBinding lessThanOrEqualTo(final float other);
+
+    /// Returns a binding telling whether this number is less than or equal to a constant.
+    BooleanBinding lessThanOrEqualTo(final long other);
+
+    /// Returns a binding telling whether this number is less than or equal to a constant.
+    BooleanBinding lessThanOrEqualTo(final int other);
+
+    /// Returns a binding holding this number as text.
+    StringBinding asString();
+
+    /// Returns a binding holding this number formatted with a `String.format` pattern.
+    StringBinding asString(String format);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberExpressionBase.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberExpressionBase.java
new file mode 100644
index 00000000000..06384d8cb29
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/NumberExpressionBase.java
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableDoubleValue;
+import javafx.beans.value.ObservableFloatValue;
+import javafx.beans.value.ObservableIntegerValue;
+import javafx.beans.value.ObservableLongValue;
+import javafx.beans.value.ObservableNumberValue;
+
+/// Implements every operation of [NumberExpression] on top of [Bindings],
+/// leaving only the value itself to the typed subclasses.
+public abstract class NumberExpressionBase implements NumberExpression {
+
+    /// Creates the expression.
+    public NumberExpressionBase() {
+    }
+
+    /// Returns a number as an expression: the value itself when it already
+    /// is one, otherwise a binding of the matching type that follows it.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the value is of none of the four
+    ///   typed kinds
+    public static <S extends Number> NumberExpressionBase numberExpression(final ObservableNumberValue value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof NumberExpressionBase) {
+            return (NumberExpressionBase) value;
+        }
+        if (value instanceof ObservableIntegerValue) {
+            return IntegerExpression.integerExpression((ObservableIntegerValue) value);
+        }
+        if (value instanceof ObservableDoubleValue) {
+            return DoubleExpression.doubleExpression((ObservableDoubleValue) value);
+        }
+        if (value instanceof ObservableFloatValue) {
+            return FloatExpression.floatExpression((ObservableFloatValue) value);
+        }
+        if (value instanceof ObservableLongValue) {
+            return LongExpression.longExpression((ObservableLongValue) value);
+        }
+        throw new IllegalArgumentException("Unsupported Type");
+    }
+
+    @Override
+    public NumberBinding negate() {
+        return Bindings.negate(this);
+    }
+
+    @Override
+    public NumberBinding add(final ObservableNumberValue other) {
+        return Bindings.add(this, other);
+    }
+
+    @Override
+    public NumberBinding add(final double other) {
+        return Bindings.add(this, other);
+    }
+
+    @Override
+    public NumberBinding add(final float other) {
+        return Bindings.add(this, other);
+    }
+
+    @Override
+    public NumberBinding add(final long other) {
+        return Bindings.add(this, other);
+    }
+
+    @Override
+    public NumberBinding add(final int other) {
+        return Bindings.add(this, other);
+    }
+
+    @Override
+    public NumberBinding subtract(final ObservableNumberValue other) {
+        return Bindings.subtract(this, other);
+    }
+
+    @Override
+    public NumberBinding subtract(final double other) {
+        return Bindings.subtract(this, other);
+    }
+
+    @Override
+    public NumberBinding subtract(final float other) {
+        return Bindings.subtract(this, other);
+    }
+
+    @Override
+    public NumberBinding subtract(final long other) {
+        return Bindings.subtract(this, other);
+    }
+
+    @Override
+    public NumberBinding subtract(final int other) {
+        return Bindings.subtract(this, other);
+    }
+
+    @Override
+    public NumberBinding multiply(final ObservableNumberValue other) {
+        return Bindings.multiply(this, other);
+    }
+
+    @Override
+    public NumberBinding multiply(final double other) {
+        return Bindings.multiply(this, other);
+    }
+
+    @Override
+    public NumberBinding multiply(final float other) {
+        return Bindings.multiply(this, other);
+    }
+
+    @Override
+    public NumberBinding multiply(final long other) {
+        return Bindings.multiply(this, other);
+    }
+
+    @Override
+    public NumberBinding multiply(final int other) {
+        return Bindings.multiply(this, other);
+    }
+
+    @Override
+    public NumberBinding divide(final ObservableNumberValue other) {
+        return Bindings.divide(this, other);
+    }
+
+    @Override
+    public NumberBinding divide(final double other) {
+        return Bindings.divide(this, other);
+    }
+
+    @Override
+    public NumberBinding divide(final float other) {
+        return Bindings.divide(this, other);
+    }
+
+    @Override
+    public NumberBinding divide(final long other) {
+        return Bindings.divide(this, other);
+    }
+
+    @Override
+    public NumberBinding divide(final int other) {
+        return Bindings.divide(this, other);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final ObservableNumberValue other) {
+        return Bindings.equal(this, other);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final ObservableNumberValue other, double epsilon) {
+        return Bindings.equal(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final double other, double epsilon) {
+        return Bindings.equal(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final float other, double epsilon) {
+        return Bindings.equal(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final long other) {
+        return Bindings.equal(this, other);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final long other, double epsilon) {
+        return Bindings.equal(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final int other) {
+        return Bindings.equal(this, other);
+    }
+
+    @Override
+    public BooleanBinding isEqualTo(final int other, double epsilon) {
+        return Bindings.equal(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final ObservableNumberValue other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final ObservableNumberValue other, double epsilon) {
+        return Bindings.notEqual(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final double other, double epsilon) {
+        return Bindings.notEqual(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final float other, double epsilon) {
+        return Bindings.notEqual(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final long other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final long other, double epsilon) {
+        return Bindings.notEqual(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final int other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding isNotEqualTo(final int other, double epsilon) {
+        return Bindings.notEqual(this, other, epsilon);
+    }
+
+    @Override
+    public BooleanBinding greaterThan(final ObservableNumberValue other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThan(final double other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThan(final float other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThan(final long other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThan(final int other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThan(final ObservableNumberValue other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThan(final double other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThan(final float other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThan(final long other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThan(final int other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThanOrEqualTo(final ObservableNumberValue other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThanOrEqualTo(final double other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThanOrEqualTo(final float other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThanOrEqualTo(final long other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding greaterThanOrEqualTo(final int other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThanOrEqualTo(final ObservableNumberValue other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThanOrEqualTo(final double other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThanOrEqualTo(final float other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThanOrEqualTo(final long other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    @Override
+    public BooleanBinding lessThanOrEqualTo(final int other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    @Override
+    public StringBinding asString() {
+        return Bindings.text(this);
+    }
+
+    @Override
+    public StringBinding asString(String format) {
+        return Bindings.formatted(format, this);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/ObjectBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/ObjectBinding.java
new file mode 100644
index 00000000000..26b6863d166
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/ObjectBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes an object.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class ObjectBinding<T> extends ObjectExpression<T> implements Binding<T> {
+
+    private T value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<T> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public ObjectBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final T get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract T computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "ObjectBinding [value: " + get() + "]" : "ObjectBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/ObjectExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/ObjectExpression.java
new file mode 100644
index 00000000000..1b61a4eef24
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/ObjectExpression.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableObjectValue;
+
+/// The fluent operations of an observable object reference.
+public abstract class ObjectExpression<T> implements ObservableObjectValue<T> {
+
+    /// Creates the expression.
+    public ObjectExpression() {
+    }
+
+    @Override
+    public T getValue() {
+        return get();
+    }
+
+    /// Returns the value as an expression: the value itself when it already
+    /// is one, otherwise a binding that follows it.
+    public static <T> ObjectExpression<T> objectExpression(final ObservableObjectValue<T> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        if (value instanceof ObjectExpression) {
+            return (ObjectExpression<T>) value;
+        }
+        return new Fn.ObjectFn<T>(() -> value.get(), value);
+    }
+
+    /// Returns a binding telling whether this object equals another.
+    public BooleanBinding isEqualTo(final ObservableObjectValue<?> other) {
+        return Bindings.equal(this, other);
+    }
+
+    /// Returns a binding telling whether this object equals a constant.
+    public BooleanBinding isEqualTo(final Object other) {
+        return Bindings.equal(this, other);
+    }
+
+    /// Returns a binding telling whether this object differs from another.
+    public BooleanBinding isNotEqualTo(final ObservableObjectValue<?> other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    /// Returns a binding telling whether this object differs from a constant.
+    public BooleanBinding isNotEqualTo(final Object other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    /// Returns a binding telling whether the value is `null`.
+    public BooleanBinding isNull() {
+        return Bindings.isNull(this);
+    }
+
+    /// Returns a binding telling whether the value is not `null`.
+    public BooleanBinding isNotNull() {
+        return Bindings.isNotNull(this);
+    }
+
+    /// Returns a binding holding the text of the object; `"null"` for none.
+    public StringBinding asString() {
+        return Bindings.text(this);
+    }
+
+    /// Returns a binding holding the object formatted with a `String.format`
+    /// pattern.
+    public StringBinding asString(String format) {
+        return Bindings.formatted(format, this);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/StringBinding.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/StringBinding.java
new file mode 100644
index 00000000000..b78d8ca4084
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/StringBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import com.codename1.fxcompat.runtime.BindingObserver;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Base class for a lazily evaluated binding that computes a string.
+///
+/// A subclass registers what it depends on with [#bind(Observable...)] and
+/// implements [#computeValue()]. The value is computed on the first read after
+/// an invalidation and cached until a dependency changes again; listeners are
+/// told about an invalidation once, until the value is read.
+public abstract class StringBinding extends StringExpression implements Binding<String> {
+
+    private String value;
+    private boolean valid;
+    private BindingObserver observer;
+    private ValueListeners<String> helper;
+
+    /// Creates an invalid binding with no dependencies.
+    public StringBinding() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super String> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super String> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Starts observing the dependencies; each one invalidates this binding.
+    protected final void bind(Observable... dependencies) {
+        if (dependencies != null && dependencies.length > 0) {
+            if (observer == null) {
+                observer = new BindingObserver(this);
+            }
+            for (Observable dependency : dependencies) {
+                dependency.addListener(observer);
+            }
+        }
+    }
+
+    /// Stops observing the dependencies.
+    protected final void unbind(Observable... dependencies) {
+        if (observer != null && dependencies != null) {
+            for (Observable dependency : dependencies) {
+                dependency.removeListener(observer);
+            }
+        }
+    }
+
+    /// Releases the dependencies. The default implementation does nothing.
+    @Override
+    public void dispose() {
+    }
+
+    /// Returns the dependencies; the default implementation reports none.
+    @Override
+    public ObservableList<?> getDependencies() {
+        return FXCollections.emptyObservableList();
+    }
+
+    /// Returns the value, computing it when the binding is invalid.
+    @Override
+    public final String get() {
+        if (!valid) {
+            value = computeValue();
+            valid = true;
+        }
+        return value;
+    }
+
+    /// Called when the binding turns invalid, before listeners are told.
+    protected void onInvalidating() {
+    }
+
+    @Override
+    public final void invalidate() {
+        if (valid) {
+            valid = false;
+            onInvalidating();
+            ValueListeners.fire(helper);
+        }
+    }
+
+    @Override
+    public final boolean isValid() {
+        return valid;
+    }
+
+    /// Computes the current value from the dependencies.
+    protected abstract String computeValue();
+
+    @Override
+    public String toString() {
+        return valid ? "StringBinding [value: " + get() + "]" : "StringBinding [invalid]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/StringExpression.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/StringExpression.java
new file mode 100644
index 00000000000..c95ffa17804
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/StringExpression.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableStringValue;
+import javafx.beans.value.ObservableValue;
+
+/// The fluent operations of an observable string. Comparisons treat `null`
+/// as the empty string.
+public abstract class StringExpression implements ObservableStringValue {
+
+    /// Creates the expression.
+    public StringExpression() {
+    }
+
+    @Override
+    public String getValue() {
+        return get();
+    }
+
+    /// Returns the value, or the empty string when it is `null`.
+    public final String getValueSafe() {
+        final String value = get();
+        return value == null ? "" : value;
+    }
+
+    /// Returns any observable value as a string expression: the value itself
+    /// when it already is one, otherwise a binding holding its text.
+    public static StringExpression stringExpression(final ObservableValue<?> value) {
+        if (value == null) {
+            throw new NullPointerException("Value must be specified.");
+        }
+        return Bindings.convert(value);
+    }
+
+    /// Returns an expression holding this string followed by the text of
+    /// another object, which is observed when it is an observable value.
+    public StringExpression concat(Object other) {
+        return Bindings.concat(this, other);
+    }
+
+    /// Returns a binding telling whether this string equals another.
+    public BooleanBinding isEqualTo(final ObservableStringValue other) {
+        return Bindings.equal(this, other);
+    }
+
+    /// Returns a binding telling whether this string equals a constant.
+    public BooleanBinding isEqualTo(final String other) {
+        return Bindings.equal(this, other);
+    }
+
+    /// Returns a binding telling whether this string differs from another.
+    public BooleanBinding isNotEqualTo(final ObservableStringValue other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    /// Returns a binding telling whether this string differs from a constant.
+    public BooleanBinding isNotEqualTo(final String other) {
+        return Bindings.notEqual(this, other);
+    }
+
+    /// Returns a binding telling whether this string equals another,
+    /// ignoring case.
+    public BooleanBinding isEqualToIgnoreCase(final ObservableStringValue other) {
+        return Bindings.equalIgnoreCase(this, other);
+    }
+
+    /// Returns a binding telling whether this string equals a constant,
+    /// ignoring case.
+    public BooleanBinding isEqualToIgnoreCase(final String other) {
+        return Bindings.equalIgnoreCase(this, other);
+    }
+
+    /// Returns a binding telling whether this string differs from another
+    /// even ignoring case.
+    public BooleanBinding isNotEqualToIgnoreCase(final ObservableStringValue other) {
+        return Bindings.notEqualIgnoreCase(this, other);
+    }
+
+    /// Returns a binding telling whether this string differs from a constant
+    /// even ignoring case.
+    public BooleanBinding isNotEqualToIgnoreCase(final String other) {
+        return Bindings.notEqualIgnoreCase(this, other);
+    }
+
+    /// Returns a binding telling whether this string sorts after another.
+    public BooleanBinding greaterThan(final ObservableStringValue other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    /// Returns a binding telling whether this string sorts after a constant.
+    public BooleanBinding greaterThan(final String other) {
+        return Bindings.greaterThan(this, other);
+    }
+
+    /// Returns a binding telling whether this string sorts before another.
+    public BooleanBinding lessThan(final ObservableStringValue other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    /// Returns a binding telling whether this string sorts before a constant.
+    public BooleanBinding lessThan(final String other) {
+        return Bindings.lessThan(this, other);
+    }
+
+    /// Returns a binding telling whether this string does not sort before
+    /// another.
+    public BooleanBinding greaterThanOrEqualTo(final ObservableStringValue other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    /// Returns a binding telling whether this string does not sort before a
+    /// constant.
+    public BooleanBinding greaterThanOrEqualTo(final String other) {
+        return Bindings.greaterThanOrEqual(this, other);
+    }
+
+    /// Returns a binding telling whether this string does not sort after
+    /// another.
+    public BooleanBinding lessThanOrEqualTo(final ObservableStringValue other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    /// Returns a binding telling whether this string does not sort after a
+    /// constant.
+    public BooleanBinding lessThanOrEqualTo(final String other) {
+        return Bindings.lessThanOrEqual(this, other);
+    }
+
+    /// Returns a binding telling whether the value is `null`.
+    public BooleanBinding isNull() {
+        return Bindings.isNull(this);
+    }
+
+    /// Returns a binding telling whether the value is not `null`.
+    public BooleanBinding isNotNull() {
+        return Bindings.isNotNull(this);
+    }
+
+    /// Returns a binding holding the length of the string; zero for `null`.
+    public IntegerBinding length() {
+        return Bindings.length(this);
+    }
+
+    /// Returns a binding telling whether the string is `null` or empty.
+    public BooleanBinding isEmpty() {
+        return Bindings.isEmpty(this);
+    }
+
+    /// Returns a binding telling whether the string has any character.
+    public BooleanBinding isNotEmpty() {
+        return Bindings.isNotEmpty(this);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/When.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/When.java
new file mode 100644
index 00000000000..3c8309c9ddc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/When.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.binding;
+
+import javafx.beans.value.ObservableBooleanValue;
+import javafx.beans.value.ObservableNumberValue;
+import javafx.beans.value.ObservableObjectValue;
+import javafx.beans.value.ObservableStringValue;
+
+/// The start of a ternary binding:
+/// `new When(condition).then(a).otherwise(b)` holds `a` while the condition
+/// is true and `b` otherwise. Either branch may be an observable value or a
+/// constant.
+public class When {
+
+    private final ObservableBooleanValue condition;
+
+    /// Starts a ternary binding on a condition.
+    public When(final ObservableBooleanValue condition) {
+        if (condition == null) {
+            throw new NullPointerException("Condition must be specified.");
+        }
+        this.condition = condition;
+    }
+
+    private static <V> V required(V value) {
+        if (value == null) {
+            throw new NullPointerException("Value needs to be specified");
+        }
+        return value;
+    }
+
+    private static BooleanBinding booleans(final ObservableBooleanValue condition, final ObservableBooleanValue yes,
+            final boolean yesConstant, final ObservableBooleanValue no, final boolean noConstant) {
+        return new Fn.BooleanFn(() -> {
+            if (condition.get()) {
+                return yes == null ? yesConstant : yes.get();
+            }
+            return no == null ? noConstant : no.get();
+        }, Bindings.deps(condition, yes, no));
+    }
+
+    private static <T> ObjectBinding<T> objects(final ObservableBooleanValue condition,
+            final ObservableObjectValue<T> yes, final T yesConstant, final ObservableObjectValue<T> no,
+            final T noConstant) {
+        return new Fn.ObjectFn<T>(() -> {
+            if (condition.get()) {
+                return yes == null ? yesConstant : yes.get();
+            }
+            return no == null ? noConstant : no.get();
+        }, Bindings.deps(condition, yes, no));
+    }
+
+    private static StringBinding strings(final ObservableBooleanValue condition, final ObservableStringValue yes,
+            final String yesConstant, final ObservableStringValue no, final String noConstant) {
+        return new Fn.StringFn(() -> {
+            if (condition.get()) {
+                return yes == null ? yesConstant : yes.get();
+            }
+            return no == null ? noConstant : no.get();
+        }, Bindings.deps(condition, yes, no));
+    }
+
+    /// Chooses a number for the true branch.
+    public NumberConditionBuilder then(final ObservableNumberValue thenValue) {
+        return new NumberConditionBuilder(required(thenValue));
+    }
+
+    /// Chooses a constant for the true branch.
+    public NumberConditionBuilder then(double thenValue) {
+        return new NumberConditionBuilder(Const.of(thenValue));
+    }
+
+    /// Chooses a constant for the true branch.
+    public NumberConditionBuilder then(float thenValue) {
+        return new NumberConditionBuilder(Const.of(thenValue));
+    }
+
+    /// Chooses a constant for the true branch.
+    public NumberConditionBuilder then(long thenValue) {
+        return new NumberConditionBuilder(Const.of(thenValue));
+    }
+
+    /// Chooses a constant for the true branch.
+    public NumberConditionBuilder then(int thenValue) {
+        return new NumberConditionBuilder(Const.of(thenValue));
+    }
+
+    /// Chooses a boolean for the true branch.
+    public BooleanConditionBuilder then(final ObservableBooleanValue thenValue) {
+        return new BooleanConditionBuilder(required(thenValue), false);
+    }
+
+    /// Chooses a constant for the true branch.
+    public BooleanConditionBuilder then(final boolean thenValue) {
+        return new BooleanConditionBuilder(null, thenValue);
+    }
+
+    /// Chooses a string for the true branch.
+    public StringConditionBuilder then(final ObservableStringValue thenValue) {
+        return new StringConditionBuilder(required(thenValue), null);
+    }
+
+    /// Chooses a constant for the true branch.
+    public StringConditionBuilder then(final String thenValue) {
+        return new StringConditionBuilder(null, thenValue);
+    }
+
+    /// Chooses an object for the true branch.
+    public <T> ObjectConditionBuilder<T> then(final ObservableObjectValue<T> thenValue) {
+        return new ObjectConditionBuilder<T>(required(thenValue), null);
+    }
+
+    /// Chooses a constant for the true branch.
+    public <T> ObjectConditionBuilder<T> then(final T thenValue) {
+        return new ObjectConditionBuilder<T>(null, thenValue);
+    }
+
+    /// A ternary binding with a numeric true branch, waiting for the other
+    /// one. The result has the wider of the two branch types.
+    public class NumberConditionBuilder {
+
+        private final ObservableNumberValue thenValue;
+
+        private NumberConditionBuilder(final ObservableNumberValue thenValue) {
+            this.thenValue = thenValue;
+        }
+
+        /// Completes the binding with a number for the false branch.
+        public NumberBinding otherwise(final ObservableNumberValue otherwiseValue) {
+            return Bindings.choose(condition, thenValue, required(otherwiseValue));
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public DoubleBinding otherwise(double otherwiseValue) {
+            return (DoubleBinding) Bindings.choose(condition, thenValue, Const.of(otherwiseValue));
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public NumberBinding otherwise(float otherwiseValue) {
+            return Bindings.choose(condition, thenValue, Const.of(otherwiseValue));
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public NumberBinding otherwise(long otherwiseValue) {
+            return Bindings.choose(condition, thenValue, Const.of(otherwiseValue));
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public NumberBinding otherwise(int otherwiseValue) {
+            return Bindings.choose(condition, thenValue, Const.of(otherwiseValue));
+        }
+    }
+
+    /// A ternary binding with a boolean true branch, waiting for the other
+    /// one.
+    public class BooleanConditionBuilder {
+
+        private final ObservableBooleanValue thenValue;
+        private final boolean thenConstant;
+
+        private BooleanConditionBuilder(final ObservableBooleanValue thenValue, boolean thenConstant) {
+            this.thenValue = thenValue;
+            this.thenConstant = thenConstant;
+        }
+
+        /// Completes the binding with a boolean for the false branch.
+        public BooleanBinding otherwise(final ObservableBooleanValue otherwiseValue) {
+            return booleans(condition, thenValue, thenConstant, required(otherwiseValue), false);
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public BooleanBinding otherwise(final boolean otherwiseValue) {
+            return booleans(condition, thenValue, thenConstant, null, otherwiseValue);
+        }
+    }
+
+    /// A ternary binding with a string true branch, waiting for the other
+    /// one.
+    public class StringConditionBuilder {
+
+        private final ObservableStringValue thenValue;
+        private final String thenConstant;
+
+        private StringConditionBuilder(final ObservableStringValue thenValue, String thenConstant) {
+            this.thenValue = thenValue;
+            this.thenConstant = thenConstant;
+        }
+
+        /// Completes the binding with a string for the false branch.
+        public StringBinding otherwise(final ObservableStringValue otherwiseValue) {
+            return strings(condition, thenValue, thenConstant, required(otherwiseValue), null);
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public StringBinding otherwise(final String otherwiseValue) {
+            return strings(condition, thenValue, thenConstant, null, otherwiseValue);
+        }
+    }
+
+    /// A ternary binding with an object true branch, waiting for the other
+    /// one.
+    public class ObjectConditionBuilder<T> {
+
+        private final ObservableObjectValue<T> thenValue;
+        private final T thenConstant;
+
+        private ObjectConditionBuilder(final ObservableObjectValue<T> thenValue, T thenConstant) {
+            this.thenValue = thenValue;
+            this.thenConstant = thenConstant;
+        }
+
+        /// Completes the binding with an object for the false branch.
+        public ObjectBinding<T> otherwise(final ObservableObjectValue<T> otherwiseValue) {
+            return objects(condition, thenValue, thenConstant, required(otherwiseValue), null);
+        }
+
+        /// Completes the binding with a constant for the false branch.
+        public ObjectBinding<T> otherwise(final T otherwiseValue) {
+            return objects(condition, thenValue, thenConstant, null, otherwiseValue);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/binding/package-info.java b/maven/javafx-compat/src/main/java/javafx/beans/binding/package-info.java
new file mode 100644
index 00000000000..1ec66068b7e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/binding/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Bindings: values computed from other observable values and recomputed
+/// lazily when those change, the fluent expression classes that build them
+/// and the [javafx.beans.binding.Bindings] operators.
+package javafx.beans.binding;
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/package-info.java b/maven/javafx-compat/src/main/java/javafx/beans/package-info.java
new file mode 100644
index 00000000000..fa25501a89a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The base of the observable model: [javafx.beans.Observable], its
+/// invalidation listener and the annotations declarative loaders read.
+package javafx.beans;
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/BooleanProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/BooleanProperty.java
new file mode 100644
index 00000000000..5431909328b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/BooleanProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.BidirectionalBinding;
+import com.codename1.fxcompat.runtime.PropertyText;
+import java.util.function.Function;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableBooleanValue;
+
+/// A property holding a boolean that can be read, written, observed and bound.
+public abstract class BooleanProperty extends ReadOnlyBooleanProperty implements Property<Boolean>, WritableBooleanValue {
+
+    /// Creates the property.
+    public BooleanProperty() {
+    }
+
+    @Override
+    public void setValue(Boolean v) {
+        if (v == null) {
+            set(false);
+        } else {
+            set(v.booleanValue());
+        }
+    }
+
+    @Override
+    public void bindBidirectional(Property<Boolean> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<Boolean> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    /// Returns a boolean property kept in sync, in both directions, with a boxed
+    /// property. Neither keeps the other alive.
+    public static BooleanProperty booleanProperty(final Property<Boolean> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        BooleanPropertyBase result = new BooleanPropertyBase() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+        BidirectionalBinding.bind(result, property, new Function<Boolean, Boolean>() {
+            @Override
+            public Boolean apply(Boolean v) {
+                return v;
+            }
+        }, new Function<Boolean, Boolean>() {
+            @Override
+            public Boolean apply(Boolean v) {
+                return Boolean.valueOf(v != null && v.booleanValue());
+            }
+        });
+        return result;
+    }
+
+    /// Returns an object property holding the boxed value, kept in sync with
+    /// this one in both directions.
+    @Override
+    public ObjectProperty<Boolean> asObject() {
+        ObjectPropertyBase<Boolean> result = new ObjectPropertyBase<Boolean>() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return BooleanProperty.this.getName();
+            }
+        };
+        Function<Boolean, Boolean> box = v -> Boolean.valueOf(v != null && v.booleanValue());
+        Function<Boolean, Boolean> unbox = v -> v;
+        BidirectionalBinding.bind(result, this, box, unbox);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("BooleanProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/BooleanPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/BooleanPropertyBase.java
new file mode 100644
index 00000000000..bcd8ef4a005
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/BooleanPropertyBase.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableBooleanValue;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of a boolean property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class BooleanPropertyBase extends BooleanProperty {
+
+    private boolean value;
+    private ObservableValue<? extends Boolean> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<Boolean> helper;
+
+    /// Creates the property with the default value.
+    public BooleanPropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public BooleanPropertyBase(boolean initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Boolean> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Boolean> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public boolean get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private boolean boundValue() {
+        if (observable instanceof ObservableBooleanValue) {
+            return ((ObservableBooleanValue) observable).get();
+        }
+        Boolean v = observable.getValue();
+        return v != null && v.booleanValue();
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(boolean newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends Boolean> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("BooleanProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(BooleanPropertyBase property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof BooleanPropertyBase) {
+                ((BooleanPropertyBase) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/DoubleProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/DoubleProperty.java
new file mode 100644
index 00000000000..2241327b85a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/DoubleProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.BidirectionalBinding;
+import com.codename1.fxcompat.runtime.PropertyText;
+import java.util.function.Function;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableDoubleValue;
+
+/// A property holding a `double` that can be read, written, observed and bound.
+public abstract class DoubleProperty extends ReadOnlyDoubleProperty implements Property<Number>, WritableDoubleValue {
+
+    /// Creates the property.
+    public DoubleProperty() {
+    }
+
+    @Override
+    public void setValue(Number v) {
+        if (v == null) {
+            set(0);
+        } else {
+            set(v.doubleValue());
+        }
+    }
+
+    @Override
+    public void bindBidirectional(Property<Number> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<Number> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    /// Returns a `double` property kept in sync, in both directions, with a boxed
+    /// property. Neither keeps the other alive.
+    public static DoubleProperty doubleProperty(final Property<Double> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        DoublePropertyBase result = new DoublePropertyBase() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+        BidirectionalBinding.bind(result, property, new Function<Double, Number>() {
+            @Override
+            public Number apply(Double v) {
+                return v;
+            }
+        }, new Function<Number, Double>() {
+            @Override
+            public Double apply(Number v) {
+                return Double.valueOf(v == null ? 0 : v.doubleValue());
+            }
+        });
+        return result;
+    }
+
+    /// Returns an object property holding the boxed value, kept in sync with
+    /// this one in both directions.
+    @Override
+    public ObjectProperty<Double> asObject() {
+        ObjectPropertyBase<Double> result = new ObjectPropertyBase<Double>() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return DoubleProperty.this.getName();
+            }
+        };
+        Function<Number, Double> box = v -> Double.valueOf(v == null ? 0 : v.doubleValue());
+        Function<Double, Number> unbox = v -> v;
+        BidirectionalBinding.bind(result, this, box, unbox);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("DoubleProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/DoublePropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/DoublePropertyBase.java
new file mode 100644
index 00000000000..f33440ba161
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/DoublePropertyBase.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableDoubleValue;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of a `double` property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class DoublePropertyBase extends DoubleProperty {
+
+    private double value;
+    private ObservableValue<? extends Number> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<Number> helper;
+
+    /// Creates the property with the default value.
+    public DoublePropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public DoublePropertyBase(double initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public double get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private double boundValue() {
+        if (observable instanceof ObservableDoubleValue) {
+            return ((ObservableDoubleValue) observable).get();
+        }
+        Number v = observable.getValue();
+        return v == null ? 0 : v.doubleValue();
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(double newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends Number> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("DoubleProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(DoublePropertyBase property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof DoublePropertyBase) {
+                ((DoublePropertyBase) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/FloatProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/FloatProperty.java
new file mode 100644
index 00000000000..8192d51b600
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/FloatProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.BidirectionalBinding;
+import com.codename1.fxcompat.runtime.PropertyText;
+import java.util.function.Function;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableFloatValue;
+
+/// A property holding a `float` that can be read, written, observed and bound.
+public abstract class FloatProperty extends ReadOnlyFloatProperty implements Property<Number>, WritableFloatValue {
+
+    /// Creates the property.
+    public FloatProperty() {
+    }
+
+    @Override
+    public void setValue(Number v) {
+        if (v == null) {
+            set(0);
+        } else {
+            set(v.floatValue());
+        }
+    }
+
+    @Override
+    public void bindBidirectional(Property<Number> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<Number> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    /// Returns a `float` property kept in sync, in both directions, with a boxed
+    /// property. Neither keeps the other alive.
+    public static FloatProperty floatProperty(final Property<Float> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        FloatPropertyBase result = new FloatPropertyBase() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+        BidirectionalBinding.bind(result, property, new Function<Float, Number>() {
+            @Override
+            public Number apply(Float v) {
+                return v;
+            }
+        }, new Function<Number, Float>() {
+            @Override
+            public Float apply(Number v) {
+                return Float.valueOf(v == null ? 0 : v.floatValue());
+            }
+        });
+        return result;
+    }
+
+    /// Returns an object property holding the boxed value, kept in sync with
+    /// this one in both directions.
+    @Override
+    public ObjectProperty<Float> asObject() {
+        ObjectPropertyBase<Float> result = new ObjectPropertyBase<Float>() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return FloatProperty.this.getName();
+            }
+        };
+        Function<Number, Float> box = v -> Float.valueOf(v == null ? 0 : v.floatValue());
+        Function<Float, Number> unbox = v -> v;
+        BidirectionalBinding.bind(result, this, box, unbox);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("FloatProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/FloatPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/FloatPropertyBase.java
new file mode 100644
index 00000000000..d64274627c9
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/FloatPropertyBase.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableFloatValue;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of a `float` property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class FloatPropertyBase extends FloatProperty {
+
+    private float value;
+    private ObservableValue<? extends Number> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<Number> helper;
+
+    /// Creates the property with the default value.
+    public FloatPropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public FloatPropertyBase(float initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public float get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private float boundValue() {
+        if (observable instanceof ObservableFloatValue) {
+            return ((ObservableFloatValue) observable).get();
+        }
+        Number v = observable.getValue();
+        return v == null ? 0 : v.floatValue();
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(float newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends Number> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("FloatProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(FloatPropertyBase property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof FloatPropertyBase) {
+                ((FloatPropertyBase) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/IntegerProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/IntegerProperty.java
new file mode 100644
index 00000000000..0418db78f3e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/IntegerProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.BidirectionalBinding;
+import com.codename1.fxcompat.runtime.PropertyText;
+import java.util.function.Function;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableIntegerValue;
+
+/// A property holding a `int` that can be read, written, observed and bound.
+public abstract class IntegerProperty extends ReadOnlyIntegerProperty implements Property<Number>, WritableIntegerValue {
+
+    /// Creates the property.
+    public IntegerProperty() {
+    }
+
+    @Override
+    public void setValue(Number v) {
+        if (v == null) {
+            set(0);
+        } else {
+            set(v.intValue());
+        }
+    }
+
+    @Override
+    public void bindBidirectional(Property<Number> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<Number> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    /// Returns a `int` property kept in sync, in both directions, with a boxed
+    /// property. Neither keeps the other alive.
+    public static IntegerProperty integerProperty(final Property<Integer> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        IntegerPropertyBase result = new IntegerPropertyBase() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+        BidirectionalBinding.bind(result, property, new Function<Integer, Number>() {
+            @Override
+            public Number apply(Integer v) {
+                return v;
+            }
+        }, new Function<Number, Integer>() {
+            @Override
+            public Integer apply(Number v) {
+                return Integer.valueOf(v == null ? 0 : v.intValue());
+            }
+        });
+        return result;
+    }
+
+    /// Returns an object property holding the boxed value, kept in sync with
+    /// this one in both directions.
+    @Override
+    public ObjectProperty<Integer> asObject() {
+        ObjectPropertyBase<Integer> result = new ObjectPropertyBase<Integer>() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return IntegerProperty.this.getName();
+            }
+        };
+        Function<Number, Integer> box = v -> Integer.valueOf(v == null ? 0 : v.intValue());
+        Function<Integer, Number> unbox = v -> v;
+        BidirectionalBinding.bind(result, this, box, unbox);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("IntegerProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/IntegerPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/IntegerPropertyBase.java
new file mode 100644
index 00000000000..4ccf6fbbd91
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/IntegerPropertyBase.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableIntegerValue;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of a `int` property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class IntegerPropertyBase extends IntegerProperty {
+
+    private int value;
+    private ObservableValue<? extends Number> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<Number> helper;
+
+    /// Creates the property with the default value.
+    public IntegerPropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public IntegerPropertyBase(int initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public int get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private int boundValue() {
+        if (observable instanceof ObservableIntegerValue) {
+            return ((ObservableIntegerValue) observable).get();
+        }
+        Number v = observable.getValue();
+        return v == null ? 0 : v.intValue();
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(int newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends Number> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("IntegerProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(IntegerPropertyBase property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof IntegerPropertyBase) {
+                ((IntegerPropertyBase) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ListProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ListProperty.java
new file mode 100644
index 00000000000..eb239afedd4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ListProperty.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableListValue;
+import javafx.collections.ObservableList;
+
+/// A property holding an observable list that can be read, replaced,
+/// observed and bound.
+public abstract class ListProperty<E> extends ReadOnlyListProperty<E>
+        implements Property<ObservableList<E>>, WritableListValue<E> {
+
+    /// Creates the property.
+    public ListProperty() {
+    }
+
+    @Override
+    public void setValue(ObservableList<E> v) {
+        set(v);
+    }
+
+    @Override
+    public void bindBidirectional(Property<ObservableList<E>> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<ObservableList<E>> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ListProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ListPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ListPropertyBase.java
new file mode 100644
index 00000000000..8603b9dac47
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ListPropertyBase.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Changes;
+import com.codename1.fxcompat.runtime.ListChangeBuilder;
+import com.codename1.fxcompat.runtime.ListenerSet;
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// The full implementation of a list property except for its bean and name.
+///
+/// The property reports two kinds of change. Replacing the list it holds
+/// tells the invalidation and change listeners, and tells the list
+/// listeners that the whole content was replaced. A modification of the
+/// list it holds tells the invalidation listeners and passes the report on
+/// to the list listeners with this property as the list.
+///
+/// The property follows the list it holds as soon as that list is set or
+/// the bound value changes, so the size and empty properties and the list
+/// listeners are always current.
+public abstract class ListPropertyBase<E> extends ListProperty<E> {
+
+    private ObservableList<E> value;
+    private ObservableValue<? extends ObservableList<E>> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<ObservableList<E>> helper;
+    private ListenerSet<ListChangeListener<? super E>> listListeners;
+    private ObservableList<E> watched;
+    private final ListChangeListener<E> contentListener = new ListChangeListener<E>() {
+        @Override
+        public void onChanged(ListChangeListener.Change<? extends E> change) {
+            contentChanged(change);
+        }
+    };
+    private SizeProperty size0;
+    private EmptyProperty empty0;
+
+    /// Creates the property holding no list.
+    public ListPropertyBase() {
+    }
+
+    /// Creates the property with an initial list.
+    public ListPropertyBase(ObservableList<E> initialValue) {
+        this.value = initialValue;
+        this.watched = initialValue;
+        if (initialValue != null) {
+            initialValue.addListener(contentListener);
+        }
+    }
+
+    @Override
+    public ReadOnlyIntegerProperty sizeProperty() {
+        if (size0 == null) {
+            size0 = new SizeProperty(this);
+        }
+        return size0;
+    }
+
+    @Override
+    public ReadOnlyBooleanProperty emptyProperty() {
+        if (empty0 == null) {
+            empty0 = new EmptyProperty(this);
+        }
+        return empty0;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super ObservableList<E>> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super ObservableList<E>> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ListChangeListener<? super E> listener) {
+        listListeners = ListenerSet.addChange(listListeners, listener);
+    }
+
+    @Override
+    public void removeListener(ListChangeListener<? super E> listener) {
+        listListeners = ListenerSet.removeChange(listListeners, listener);
+    }
+
+    /// Tells the invalidation and change listeners the held list may have
+    /// been replaced.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    /// Tells the list listeners about a change of the content.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    protected void fireValueChangedEvent(ListChangeListener.Change<? extends E> change) {
+        List<ListChangeListener<? super E>> targets = ListenerSet.changeListeners(listListeners);
+        for (int i = 0; i < targets.size(); i++) {
+            change.reset();
+            ((ListChangeListener) targets.get(i)).onChanged(change);
+        }
+    }
+
+    /// Called when the held list was replaced or modified, before listeners
+    /// are told.
+    protected void invalidated() {
+    }
+
+    private void contentChanged(ListChangeListener.Change<? extends E> change) {
+        fireDerived();
+        invalidated();
+        fireValueChangedEvent();
+        fireValueChangedEvent(new Changes.Relayed<E>(this, change));
+    }
+
+    private void fireDerived() {
+        if (size0 != null) {
+            size0.changed();
+        }
+        if (empty0 != null) {
+            empty0.changed();
+        }
+    }
+
+    private ObservableList<E> current() {
+        return observable == null ? value : observable.getValue();
+    }
+
+    private void markInvalid() {
+        ObservableList<E> before = watched;
+        ObservableList<E> now = current();
+        if (before != now) {
+            if (before != null) {
+                before.removeListener(contentListener);
+            }
+            watched = now;
+            if (now != null) {
+                now.addListener(contentListener);
+            }
+        }
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+        if (before != now) {
+            fireDerived();
+            List<E> removed = before == null ? new ArrayList<E>() : new ArrayList<E>(before);
+            int added = now == null ? 0 : now.size();
+            if (!removed.isEmpty() || added > 0) {
+                ListChangeBuilder<E> builder = new ListChangeBuilder<E>(this);
+                builder.beginChange();
+                builder.nextReplace(0, added, removed);
+                ListChangeListener.Change<E> change = builder.endChange();
+                if (change != null) {
+                    fireValueChangedEvent(change);
+                }
+            }
+        }
+    }
+
+    @Override
+    public ObservableList<E> get() {
+        valid = true;
+        return current();
+    }
+
+    /// Replaces the held list.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(ObservableList<E> newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends ObservableList<E>> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!sameObservable(newObservable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// An observable list value compares as a list, so the bound value is
+    /// recognized by identity.
+    private boolean sameObservable(Object candidate) {
+        return candidate == observable;
+    }
+
+    /// Stops following the bound value and keeps the list it held.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = observable.getValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("ListProperty", this, tail);
+    }
+
+    /// The number of elements of a list property.
+    private static final class SizeProperty extends ReadOnlyIntegerPropertyBase {
+        private final ListPropertyBase<?> owner;
+
+        SizeProperty(ListPropertyBase<?> owner) {
+            this.owner = owner;
+        }
+
+        void changed() {
+            fireValueChangedEvent();
+        }
+
+        @Override
+        public int get() {
+            return owner.size();
+        }
+
+        @Override
+        public Object getBean() {
+            return owner;
+        }
+
+        @Override
+        public String getName() {
+            return "size";
+        }
+    }
+
+    /// Whether a list property is empty.
+    private static final class EmptyProperty extends ReadOnlyBooleanPropertyBase {
+        private final ListPropertyBase<?> owner;
+
+        EmptyProperty(ListPropertyBase<?> owner) {
+            this.owner = owner;
+        }
+
+        void changed() {
+            fireValueChangedEvent();
+        }
+
+        @Override
+        public boolean get() {
+            return owner.isEmpty();
+        }
+
+        @Override
+        public Object getBean() {
+            return owner;
+        }
+
+        @Override
+        public String getName() {
+            return "empty";
+        }
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(ListPropertyBase<?> property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof ListPropertyBase) {
+                ((ListPropertyBase<?>) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/LongProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/LongProperty.java
new file mode 100644
index 00000000000..b7b6bc9f956
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/LongProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.BidirectionalBinding;
+import com.codename1.fxcompat.runtime.PropertyText;
+import java.util.function.Function;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableLongValue;
+
+/// A property holding a `long` that can be read, written, observed and bound.
+public abstract class LongProperty extends ReadOnlyLongProperty implements Property<Number>, WritableLongValue {
+
+    /// Creates the property.
+    public LongProperty() {
+    }
+
+    @Override
+    public void setValue(Number v) {
+        if (v == null) {
+            set(0);
+        } else {
+            set(v.longValue());
+        }
+    }
+
+    @Override
+    public void bindBidirectional(Property<Number> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<Number> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    /// Returns a `long` property kept in sync, in both directions, with a boxed
+    /// property. Neither keeps the other alive.
+    public static LongProperty longProperty(final Property<Long> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        LongPropertyBase result = new LongPropertyBase() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+        BidirectionalBinding.bind(result, property, new Function<Long, Number>() {
+            @Override
+            public Number apply(Long v) {
+                return v;
+            }
+        }, new Function<Number, Long>() {
+            @Override
+            public Long apply(Number v) {
+                return Long.valueOf(v == null ? 0 : v.longValue());
+            }
+        });
+        return result;
+    }
+
+    /// Returns an object property holding the boxed value, kept in sync with
+    /// this one in both directions.
+    @Override
+    public ObjectProperty<Long> asObject() {
+        ObjectPropertyBase<Long> result = new ObjectPropertyBase<Long>() {
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return LongProperty.this.getName();
+            }
+        };
+        Function<Number, Long> box = v -> Long.valueOf(v == null ? 0 : v.longValue());
+        Function<Long, Number> unbox = v -> v;
+        BidirectionalBinding.bind(result, this, box, unbox);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("LongProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/LongPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/LongPropertyBase.java
new file mode 100644
index 00000000000..e6ff4104e4e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/LongPropertyBase.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableLongValue;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of a `long` property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class LongPropertyBase extends LongProperty {
+
+    private long value;
+    private ObservableValue<? extends Number> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<Number> helper;
+
+    /// Creates the property with the default value.
+    public LongPropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public LongPropertyBase(long initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public long get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private long boundValue() {
+        if (observable instanceof ObservableLongValue) {
+            return ((ObservableLongValue) observable).get();
+        }
+        Number v = observable.getValue();
+        return v == null ? 0 : v.longValue();
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(long newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends Number> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("LongProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(LongPropertyBase property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof LongPropertyBase) {
+                ((LongPropertyBase) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ObjectProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ObjectProperty.java
new file mode 100644
index 00000000000..f3d1b4cc440
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ObjectProperty.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableObjectValue;
+
+/// A property holding an object that can be read, written, observed and bound.
+public abstract class ObjectProperty<T> extends ReadOnlyObjectProperty<T> implements Property<T>, WritableObjectValue<T> {
+
+    /// Creates the property.
+    public ObjectProperty() {
+    }
+
+    @Override
+    public void setValue(T v) {
+        set(v);
+    }
+
+    @Override
+    public void bindBidirectional(Property<T> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<T> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ObjectProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ObjectPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ObjectPropertyBase.java
new file mode 100644
index 00000000000..6f44ad1116e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ObjectPropertyBase.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of an object property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class ObjectPropertyBase<T> extends ObjectProperty<T> {
+
+    private T value;
+    private ObservableValue<? extends T> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<T> helper;
+
+    /// Creates the property with the default value.
+    public ObjectPropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public ObjectPropertyBase(T initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public T get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private T boundValue() {
+        T v = observable.getValue();
+        return v;
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(T newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if (value != newValue) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends T> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        // equals, not ==, as OpenJFX's ObjectPropertyBase.bind (and every
+        // other *PropertyBase) does: a source equal to the current one is
+        // taken to be the same binding and is not rebound.
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("ObjectProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(ObjectPropertyBase<?> property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof ObjectPropertyBase) {
+                ((ObjectPropertyBase<?>) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/Property.java b/maven/javafx-compat/src/main/java/javafx/beans/property/Property.java
new file mode 100644
index 00000000000..367c0691fb5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/Property.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import javafx.beans.value.ObservableValue;
+import javafx.beans.value.WritableValue;
+
+/// A value that can be written, observed and bound to other values.
+///
+/// A property bound with [#bind(ObservableValue)] follows its source and
+/// rejects every attempt to set it. Two properties bound with
+/// [#bindBidirectional(Property)] follow each other and both stay writable.
+public interface Property<T> extends ReadOnlyProperty<T>, WritableValue<T> {
+
+    /// Makes this property follow another value.
+    void bind(ObservableValue<? extends T> observable);
+
+    /// Stops following the bound value; does nothing when not bound.
+    void unbind();
+
+    /// Returns whether the property currently follows another value.
+    boolean isBound();
+
+    /// Keeps this property and another one equal, starting with the value
+    /// of the other.
+    void bindBidirectional(Property<T> other);
+
+    /// Removes a bidirectional binding with another property.
+    void unbindBidirectional(Property<T> other);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanProperty.java
new file mode 100644
index 00000000000..15c3b54a897
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.BooleanExpression;
+
+/// A property holding a boolean that can be read and observed but not written.
+public abstract class ReadOnlyBooleanProperty extends BooleanExpression implements ReadOnlyProperty<Boolean> {
+
+    /// Creates the property.
+    public ReadOnlyBooleanProperty() {
+    }
+
+    /// Returns a read-only view of a boxed property as a boolean property. A `null`
+    /// value reads as the default value.
+    public static ReadOnlyBooleanProperty readOnlyBooleanProperty(final ReadOnlyProperty<Boolean> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        if (property instanceof ReadOnlyBooleanProperty) {
+            return (ReadOnlyBooleanProperty) property;
+        }
+        return new ReadOnlyBooleanPropertyBase() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                property.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public boolean get() {
+                Boolean v = property.getValue();
+                return v != null && v.booleanValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+    }
+
+    /// Returns a read-only object property holding the boxed value of this one.
+    @Override
+    public ReadOnlyObjectProperty<Boolean> asObject() {
+        return new ReadOnlyObjectPropertyBase<Boolean>() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                ReadOnlyBooleanProperty.this.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public Boolean get() {
+                return ReadOnlyBooleanProperty.this.getValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return ReadOnlyBooleanProperty.this.getName();
+            }
+        };
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyBooleanProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanPropertyBase.java
new file mode 100644
index 00000000000..61a7b081b02
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanPropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding a boolean: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyBooleanPropertyBase extends ReadOnlyBooleanProperty {
+
+    private ValueListeners<Boolean> helper;
+
+    /// Creates the property.
+    public ReadOnlyBooleanPropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Boolean> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Boolean> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanWrapper.java
new file mode 100644
index 00000000000..93c6046876e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyBooleanWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyBooleanWrapper extends SimpleBooleanProperty {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyBooleanWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyBooleanWrapper(boolean initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyBooleanWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyBooleanWrapper(Object bean, String name, boolean initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyBooleanProperty getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyBooleanPropertyBase {
+
+        @Override
+        public boolean get() {
+            return ReadOnlyBooleanWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyBooleanWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyBooleanWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoubleProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoubleProperty.java
new file mode 100644
index 00000000000..88955d393fd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoubleProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.DoubleExpression;
+
+/// A property holding a `double` that can be read and observed but not written.
+public abstract class ReadOnlyDoubleProperty extends DoubleExpression implements ReadOnlyProperty<Number> {
+
+    /// Creates the property.
+    public ReadOnlyDoubleProperty() {
+    }
+
+    /// Returns a read-only view of a boxed property as a `double` property. A `null`
+    /// value reads as the default value.
+    public static <T extends Number> ReadOnlyDoubleProperty readOnlyDoubleProperty(final ReadOnlyProperty<T> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        if (property instanceof ReadOnlyDoubleProperty) {
+            return (ReadOnlyDoubleProperty) property;
+        }
+        return new ReadOnlyDoublePropertyBase() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                property.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public double get() {
+                T v = property.getValue();
+                return v == null ? 0 : v.doubleValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+    }
+
+    /// Returns a read-only object property holding the boxed value of this one.
+    @Override
+    public ReadOnlyObjectProperty<Double> asObject() {
+        return new ReadOnlyObjectPropertyBase<Double>() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                ReadOnlyDoubleProperty.this.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public Double get() {
+                return ReadOnlyDoubleProperty.this.getValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return ReadOnlyDoubleProperty.this.getName();
+            }
+        };
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyDoubleProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoublePropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoublePropertyBase.java
new file mode 100644
index 00000000000..067bc3fccbb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoublePropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding a `double`: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyDoublePropertyBase extends ReadOnlyDoubleProperty {
+
+    private ValueListeners<Number> helper;
+
+    /// Creates the property.
+    public ReadOnlyDoublePropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoubleWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoubleWrapper.java
new file mode 100644
index 00000000000..d200630449a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyDoubleWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyDoubleWrapper extends SimpleDoubleProperty {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyDoubleWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyDoubleWrapper(double initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyDoubleWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyDoubleWrapper(Object bean, String name, double initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyDoubleProperty getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyDoublePropertyBase {
+
+        @Override
+        public double get() {
+            return ReadOnlyDoubleWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyDoubleWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyDoubleWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatProperty.java
new file mode 100644
index 00000000000..17509786d68
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.FloatExpression;
+
+/// A property holding a `float` that can be read and observed but not written.
+public abstract class ReadOnlyFloatProperty extends FloatExpression implements ReadOnlyProperty<Number> {
+
+    /// Creates the property.
+    public ReadOnlyFloatProperty() {
+    }
+
+    /// Returns a read-only view of a boxed property as a `float` property. A `null`
+    /// value reads as the default value.
+    public static <T extends Number> ReadOnlyFloatProperty readOnlyFloatProperty(final ReadOnlyProperty<T> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        if (property instanceof ReadOnlyFloatProperty) {
+            return (ReadOnlyFloatProperty) property;
+        }
+        return new ReadOnlyFloatPropertyBase() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                property.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public float get() {
+                T v = property.getValue();
+                return v == null ? 0 : v.floatValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+    }
+
+    /// Returns a read-only object property holding the boxed value of this one.
+    @Override
+    public ReadOnlyObjectProperty<Float> asObject() {
+        return new ReadOnlyObjectPropertyBase<Float>() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                ReadOnlyFloatProperty.this.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public Float get() {
+                return ReadOnlyFloatProperty.this.getValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return ReadOnlyFloatProperty.this.getName();
+            }
+        };
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyFloatProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatPropertyBase.java
new file mode 100644
index 00000000000..74bbfcbfa16
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatPropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding a `float`: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyFloatPropertyBase extends ReadOnlyFloatProperty {
+
+    private ValueListeners<Number> helper;
+
+    /// Creates the property.
+    public ReadOnlyFloatPropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatWrapper.java
new file mode 100644
index 00000000000..b4194939d54
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyFloatWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyFloatWrapper extends SimpleFloatProperty {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyFloatWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyFloatWrapper(float initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyFloatWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyFloatWrapper(Object bean, String name, float initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyFloatProperty getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyFloatPropertyBase {
+
+        @Override
+        public float get() {
+            return ReadOnlyFloatWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyFloatWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyFloatWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerProperty.java
new file mode 100644
index 00000000000..6212173cd73
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.IntegerExpression;
+
+/// A property holding a `int` that can be read and observed but not written.
+public abstract class ReadOnlyIntegerProperty extends IntegerExpression implements ReadOnlyProperty<Number> {
+
+    /// Creates the property.
+    public ReadOnlyIntegerProperty() {
+    }
+
+    /// Returns a read-only view of a boxed property as a `int` property. A `null`
+    /// value reads as the default value.
+    public static <T extends Number> ReadOnlyIntegerProperty readOnlyIntegerProperty(final ReadOnlyProperty<T> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        if (property instanceof ReadOnlyIntegerProperty) {
+            return (ReadOnlyIntegerProperty) property;
+        }
+        return new ReadOnlyIntegerPropertyBase() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                property.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public int get() {
+                T v = property.getValue();
+                return v == null ? 0 : v.intValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+    }
+
+    /// Returns a read-only object property holding the boxed value of this one.
+    @Override
+    public ReadOnlyObjectProperty<Integer> asObject() {
+        return new ReadOnlyObjectPropertyBase<Integer>() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                ReadOnlyIntegerProperty.this.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public Integer get() {
+                return ReadOnlyIntegerProperty.this.getValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return ReadOnlyIntegerProperty.this.getName();
+            }
+        };
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyIntegerProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerPropertyBase.java
new file mode 100644
index 00000000000..c79df8db669
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerPropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding a `int`: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyIntegerPropertyBase extends ReadOnlyIntegerProperty {
+
+    private ValueListeners<Number> helper;
+
+    /// Creates the property.
+    public ReadOnlyIntegerPropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerWrapper.java
new file mode 100644
index 00000000000..30de24efa82
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyIntegerWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyIntegerWrapper extends SimpleIntegerProperty {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyIntegerWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyIntegerWrapper(int initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyIntegerWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyIntegerWrapper(Object bean, String name, int initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyIntegerProperty getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyIntegerPropertyBase {
+
+        @Override
+        public int get() {
+            return ReadOnlyIntegerWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyIntegerWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyIntegerWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyListProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyListProperty.java
new file mode 100644
index 00000000000..f022e915ba0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyListProperty.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import java.util.List;
+import java.util.ListIterator;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.ListExpression;
+import javafx.collections.ObservableList;
+
+/// A property holding an observable list that can be read and observed but
+/// not replaced.
+public abstract class ReadOnlyListProperty<E> extends ListExpression<E>
+        implements ReadOnlyProperty<ObservableList<E>> {
+
+    /// Creates the property.
+    public ReadOnlyListProperty() {
+    }
+
+    /// Keeps the content of this property and of a list equal in both
+    /// directions.
+    public void bindContentBidirectional(ObservableList<E> list) {
+        Bindings.bindContentBidirectional(this, list);
+    }
+
+    /// Removes a bidirectional content binding.
+    public void unbindContentBidirectional(Object object) {
+        Bindings.unbindContentBidirectional(this, object);
+    }
+
+    /// Makes the content of this property follow a list.
+    public void bindContent(ObservableList<E> list) {
+        Bindings.bindContent(this, list);
+    }
+
+    /// Removes a content binding.
+    public void unbindContent(Object object) {
+        Bindings.unbindContent(this, object);
+    }
+
+    /// Compares as a list: equal to any list of equal elements in the same
+    /// order.
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof List)) {
+            return false;
+        }
+        List<?> other = (List<?>) obj;
+        if (size() != other.size()) {
+            return false;
+        }
+        ListIterator<E> mine = listIterator();
+        ListIterator<?> theirs = other.listIterator();
+        while (mine.hasNext() && theirs.hasNext()) {
+            E first = mine.next();
+            Object second = theirs.next();
+            if (!(first == null ? second == null : first.equals(second))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Returns the hash code of the content, as a list defines it.
+    @Override
+    public int hashCode() {
+        int hashCode = 1;
+        for (E element : this) {
+            hashCode = 31 * hashCode + (element == null ? 0 : element.hashCode());
+        }
+        return hashCode;
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyListProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongProperty.java
new file mode 100644
index 00000000000..de5b0c8b943
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongProperty.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.LongExpression;
+
+/// A property holding a `long` that can be read and observed but not written.
+public abstract class ReadOnlyLongProperty extends LongExpression implements ReadOnlyProperty<Number> {
+
+    /// Creates the property.
+    public ReadOnlyLongProperty() {
+    }
+
+    /// Returns a read-only view of a boxed property as a `long` property. A `null`
+    /// value reads as the default value.
+    public static <T extends Number> ReadOnlyLongProperty readOnlyLongProperty(final ReadOnlyProperty<T> property) {
+        if (property == null) {
+            throw new NullPointerException("Property cannot be null");
+        }
+        if (property instanceof ReadOnlyLongProperty) {
+            return (ReadOnlyLongProperty) property;
+        }
+        return new ReadOnlyLongPropertyBase() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                property.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public long get() {
+                T v = property.getValue();
+                return v == null ? 0 : v.longValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return property.getName();
+            }
+        };
+    }
+
+    /// Returns a read-only object property holding the boxed value of this one.
+    @Override
+    public ReadOnlyObjectProperty<Long> asObject() {
+        return new ReadOnlyObjectPropertyBase<Long>() {
+            private final InvalidationListener listener = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    fireValueChangedEvent();
+                }
+            };
+
+            {
+                ReadOnlyLongProperty.this.addListener(new WeakInvalidationListener(listener));
+            }
+
+            @Override
+            public Long get() {
+                return ReadOnlyLongProperty.this.getValue();
+            }
+
+            @Override
+            public Object getBean() {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return ReadOnlyLongProperty.this.getName();
+            }
+        };
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyLongProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongPropertyBase.java
new file mode 100644
index 00000000000..28c2eb36cac
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongPropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding a `long`: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyLongPropertyBase extends ReadOnlyLongProperty {
+
+    private ValueListeners<Number> helper;
+
+    /// Creates the property.
+    public ReadOnlyLongPropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super Number> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongWrapper.java
new file mode 100644
index 00000000000..4b4bf63694d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyLongWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyLongWrapper extends SimpleLongProperty {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyLongWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyLongWrapper(long initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyLongWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyLongWrapper(Object bean, String name, long initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyLongProperty getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyLongPropertyBase {
+
+        @Override
+        public long get() {
+            return ReadOnlyLongWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyLongWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyLongWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectProperty.java
new file mode 100644
index 00000000000..33cb96e4518
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectProperty.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.ObjectExpression;
+
+/// A property holding an object that can be read and observed but not written.
+public abstract class ReadOnlyObjectProperty<T> extends ObjectExpression<T> implements ReadOnlyProperty<T> {
+
+    /// Creates the property.
+    public ReadOnlyObjectProperty() {
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyObjectProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectPropertyBase.java
new file mode 100644
index 00000000000..217f498ff13
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectPropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding an object: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyObjectPropertyBase<T> extends ReadOnlyObjectProperty<T> {
+
+    private ValueListeners<T> helper;
+
+    /// Creates the property.
+    public ReadOnlyObjectPropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectWrapper.java
new file mode 100644
index 00000000000..59644c9bf1f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyObjectWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyObjectWrapper<T> extends SimpleObjectProperty<T> {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyObjectWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyObjectWrapper(T initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyObjectWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyObjectWrapper(Object bean, String name, T initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyObjectProperty<T> getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyObjectPropertyBase<T> {
+
+        @Override
+        public T get() {
+            return ReadOnlyObjectWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyObjectWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyObjectWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyProperty.java
new file mode 100644
index 00000000000..7468ec12e2f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyProperty.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import javafx.beans.value.ObservableValue;
+
+/// An observable value that belongs to a bean and has a name there.
+public interface ReadOnlyProperty<T> extends ObservableValue<T> {
+
+    /// Returns the object owning the property, or `null`.
+    Object getBean();
+
+    /// Returns the name of the property; empty when it has none.
+    String getName();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringProperty.java
new file mode 100644
index 00000000000..a6f2b9276c6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringProperty.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.binding.StringExpression;
+
+/// A property holding a string that can be read and observed but not written.
+public abstract class ReadOnlyStringProperty extends StringExpression implements ReadOnlyProperty<String> {
+
+    /// Creates the property.
+    public ReadOnlyStringProperty() {
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("ReadOnlyStringProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringPropertyBase.java
new file mode 100644
index 00000000000..79bbcd6ad66
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringPropertyBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+import javafx.beans.InvalidationListener;
+import javafx.beans.value.ChangeListener;
+
+/// Base class for a read-only property holding a string: it keeps the listeners
+/// and leaves the value to the subclass, which calls
+/// [#fireValueChangedEvent()] whenever that value may have changed.
+public abstract class ReadOnlyStringPropertyBase extends ReadOnlyStringProperty {
+
+    private ValueListeners<String> helper;
+
+    /// Creates the property.
+    public ReadOnlyStringPropertyBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super String> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super String> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringWrapper.java b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringWrapper.java
new file mode 100644
index 00000000000..c5916fa81b3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/ReadOnlyStringWrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A writable property that hands out a read-only view of itself: the owner
+/// keeps the wrapper and writes to it, and publishes
+/// [#getReadOnlyProperty()], which always shows the same value.
+public class ReadOnlyStringWrapper extends SimpleStringProperty {
+
+    private ReadOnlyPropertyImpl readOnlyProperty;
+
+    /// Creates a wrapper with no bean, an empty name and the default value.
+    public ReadOnlyStringWrapper() {
+    }
+
+    /// Creates a wrapper with no bean and an empty name.
+    public ReadOnlyStringWrapper(String initialValue) {
+        super(initialValue);
+    }
+
+    /// Creates a wrapper of a bean with the default value.
+    public ReadOnlyStringWrapper(Object bean, String name) {
+        super(bean, name);
+    }
+
+    /// Creates a wrapper of a bean.
+    public ReadOnlyStringWrapper(Object bean, String name, String initialValue) {
+        super(bean, name, initialValue);
+    }
+
+    /// Returns the read-only view; the same object on every call.
+    public ReadOnlyStringProperty getReadOnlyProperty() {
+        if (readOnlyProperty == null) {
+            readOnlyProperty = new ReadOnlyPropertyImpl();
+        }
+        return readOnlyProperty;
+    }
+
+    @Override
+    protected void fireValueChangedEvent() {
+        super.fireValueChangedEvent();
+        if (readOnlyProperty != null) {
+            readOnlyProperty.fireValueChangedEvent();
+        }
+    }
+
+    private final class ReadOnlyPropertyImpl extends ReadOnlyStringPropertyBase {
+
+        @Override
+        public String get() {
+            return ReadOnlyStringWrapper.this.get();
+        }
+
+        @Override
+        public Object getBean() {
+            return ReadOnlyStringWrapper.this.getBean();
+        }
+
+        @Override
+        public String getName() {
+            return ReadOnlyStringWrapper.this.getName();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleBooleanProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleBooleanProperty.java
new file mode 100644
index 00000000000..18cabf5a7c4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleBooleanProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A boolean property with a bean and a name, ready to use as a field.
+public class SimpleBooleanProperty extends BooleanPropertyBase {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleBooleanProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleBooleanProperty(boolean initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleBooleanProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleBooleanProperty(Object bean, String name, boolean initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleDoubleProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleDoubleProperty.java
new file mode 100644
index 00000000000..5999a2683b0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleDoubleProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A `double` property with a bean and a name, ready to use as a field.
+public class SimpleDoubleProperty extends DoublePropertyBase {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleDoubleProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleDoubleProperty(double initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleDoubleProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleDoubleProperty(Object bean, String name, double initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleFloatProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleFloatProperty.java
new file mode 100644
index 00000000000..d8e48db1aa5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleFloatProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A `float` property with a bean and a name, ready to use as a field.
+public class SimpleFloatProperty extends FloatPropertyBase {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleFloatProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleFloatProperty(float initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleFloatProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleFloatProperty(Object bean, String name, float initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleIntegerProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleIntegerProperty.java
new file mode 100644
index 00000000000..75970ea365e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleIntegerProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A `int` property with a bean and a name, ready to use as a field.
+public class SimpleIntegerProperty extends IntegerPropertyBase {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleIntegerProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleIntegerProperty(int initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleIntegerProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleIntegerProperty(Object bean, String name, int initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleListProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleListProperty.java
new file mode 100644
index 00000000000..ea719becc3b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleListProperty.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import javafx.collections.ObservableList;
+
+/// A list property with a bean and a name, ready to use as a field.
+public class SimpleListProperty<E> extends ListPropertyBase<E> {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and no list.
+    public SimpleListProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleListProperty(ObservableList<E> initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean holding no list.
+    public SimpleListProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleListProperty(Object bean, String name, ObservableList<E> initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleLongProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleLongProperty.java
new file mode 100644
index 00000000000..0262af781b8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleLongProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A `long` property with a bean and a name, ready to use as a field.
+public class SimpleLongProperty extends LongPropertyBase {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleLongProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleLongProperty(long initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleLongProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleLongProperty(Object bean, String name, long initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleObjectProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleObjectProperty.java
new file mode 100644
index 00000000000..a2f81aa94d3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleObjectProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// An object property with a bean and a name, ready to use as a field.
+public class SimpleObjectProperty<T> extends ObjectPropertyBase<T> {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleObjectProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleObjectProperty(T initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleObjectProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleObjectProperty(Object bean, String name, T initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleStringProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleStringProperty.java
new file mode 100644
index 00000000000..9312197c7d3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/SimpleStringProperty.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+/// A string property with a bean and a name, ready to use as a field.
+public class SimpleStringProperty extends StringPropertyBase {
+
+    private static final Object DEFAULT_BEAN = null;
+    private static final String DEFAULT_NAME = "";
+
+    private final Object bean;
+    private final String name;
+
+    /// Creates a property with no bean, an empty name and the default value.
+    public SimpleStringProperty() {
+        this(DEFAULT_BEAN, DEFAULT_NAME);
+    }
+
+    /// Creates a property with no bean and an empty name.
+    public SimpleStringProperty(String initialValue) {
+        this(DEFAULT_BEAN, DEFAULT_NAME, initialValue);
+    }
+
+    /// Creates a property of a bean with the default value.
+    public SimpleStringProperty(Object bean, String name) {
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    /// Creates a property of a bean.
+    public SimpleStringProperty(Object bean, String name, String initialValue) {
+        super(initialValue);
+        this.bean = bean;
+        this.name = (name == null) ? DEFAULT_NAME : name;
+    }
+
+    @Override
+    public Object getBean() {
+        return bean;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/StringProperty.java b/maven/javafx-compat/src/main/java/javafx/beans/property/StringProperty.java
new file mode 100644
index 00000000000..55f59202b17
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/StringProperty.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import javafx.beans.binding.Bindings;
+import javafx.beans.value.WritableStringValue;
+import javafx.util.StringConverter;
+
+/// A property holding a string that can be read, written, observed and bound.
+public abstract class StringProperty extends ReadOnlyStringProperty implements Property<String>, WritableStringValue {
+
+    /// Creates the property.
+    public StringProperty() {
+    }
+
+    @Override
+    public void setValue(String v) {
+        set(v);
+    }
+
+    @Override
+    public void bindBidirectional(Property<String> other) {
+        Bindings.bindBidirectional(this, other);
+    }
+
+    @Override
+    public void unbindBidirectional(Property<String> other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    /// Keeps this property and another one of any type in sync through a
+    /// converter: this side holds the text, the other the converted value.
+    public <T> void bindBidirectional(Property<T> other, StringConverter<T> converter) {
+        Bindings.bindBidirectional(this, other, converter);
+    }
+
+    /// Removes a bidirectional binding to any object, converter based or not.
+    public void unbindBidirectional(Object other) {
+        Bindings.unbindBidirectional(this, other);
+    }
+
+    @Override
+    public String toString() {
+        return PropertyText.describe("StringProperty", this, "value: " + get());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/StringPropertyBase.java b/maven/javafx-compat/src/main/java/javafx/beans/property/StringPropertyBase.java
new file mode 100644
index 00000000000..c28105d2cb5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/StringPropertyBase.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.property;
+
+import com.codename1.fxcompat.runtime.PropertyText;
+import com.codename1.fxcompat.runtime.ValueListeners;
+import java.lang.ref.WeakReference;
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakListener;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+
+/// The full implementation of a string property except for its bean and name.
+///
+/// Invalidation is lazy: after a change, listeners are told once and not
+/// again until the value has been read. A change listener reads the value on
+/// every invalidation, so registering one makes the property eager.
+public abstract class StringPropertyBase extends StringProperty {
+
+    private String value;
+    private ObservableValue<? extends String> observable;
+    private InvalidationListener listener;
+    private boolean valid = true;
+    private ValueListeners<String> helper;
+
+    /// Creates the property with the default value.
+    public StringPropertyBase() {
+    }
+
+    /// Creates the property with an initial value.
+    public StringPropertyBase(String initialValue) {
+        this.value = initialValue;
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super String> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super String> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+
+    private void markInvalid() {
+        if (valid) {
+            valid = false;
+            invalidated();
+            fireValueChangedEvent();
+        }
+    }
+
+    /// Called when the property turns invalid, before listeners are told.
+    protected void invalidated() {
+    }
+
+    @Override
+    public String get() {
+        valid = true;
+        return observable == null ? value : boundValue();
+    }
+
+    private String boundValue() {
+        String v = observable.getValue();
+        return v;
+    }
+
+    /// Sets the value.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the property is bound
+    @Override
+    public void set(String newValue) {
+        if (isBound()) {
+            throw new RuntimeException(PropertyText.owner(this) + "A bound value cannot be set.");
+        }
+        if ((value == null) ? newValue != null : !value.equals(newValue)) {
+            value = newValue;
+            markInvalid();
+        }
+    }
+
+    @Override
+    public boolean isBound() {
+        return observable != null;
+    }
+
+    /// Makes this property follow another value until [#unbind()]. The
+    /// property observes it weakly, so being bound does not keep it alive.
+    @Override
+    public void bind(final ObservableValue<? extends String> newObservable) {
+        if (newObservable == null) {
+            throw new NullPointerException("Cannot bind to null");
+        }
+        if (!newObservable.equals(observable)) {
+            unbind();
+            observable = newObservable;
+            if (listener == null) {
+                listener = new Listener(this);
+            }
+            observable.addListener(listener);
+            markInvalid();
+        }
+    }
+
+    /// Stops following the bound value and keeps the value it had.
+    @Override
+    public void unbind() {
+        if (observable != null) {
+            value = boundValue();
+            observable.removeListener(listener);
+            observable = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        String tail;
+        if (isBound()) {
+            tail = valid ? "bound, value: " + get() : "bound, invalid";
+        } else {
+            tail = "value: " + get();
+        }
+        return PropertyText.describe("StringProperty", this, tail);
+    }
+
+    /// Forwards invalidations of the bound value without keeping the
+    /// property reachable from it.
+    private static final class Listener implements InvalidationListener, WeakListener {
+        private final WeakReference ref;
+
+        Listener(StringPropertyBase property) {
+            this.ref = new WeakReference(property);
+        }
+
+        @Override
+        public void invalidated(Observable source) {
+            Object property = ref.get();
+            if (property instanceof StringPropertyBase) {
+                ((StringPropertyBase) property).markInvalid();
+            } else {
+                source.removeListener(this);
+            }
+        }
+
+        @Override
+        public boolean wasGarbageCollected() {
+            return ref.get() == null;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/property/package-info.java b/maven/javafx-compat/src/main/java/javafx/beans/property/package-info.java
new file mode 100644
index 00000000000..19886158465
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/property/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Properties: observable, writable, bindable values that belong to a bean,
+/// in a typed family for every primitive kind, strings, objects and lists.
+package javafx.beans.property;
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ChangeListener.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ChangeListener.java
new file mode 100644
index 00000000000..5ca931c3096
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ChangeListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// Told when the value of an [ObservableValue] changes.
+@FunctionalInterface
+public interface ChangeListener<T> {
+
+    /// Called after the value changed.
+    void changed(ObservableValue<? extends T> observable, T oldValue, T newValue);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableBooleanValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableBooleanValue.java
new file mode 100644
index 00000000000..bce16a5a5d5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableBooleanValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding a boolean.
+public interface ObservableBooleanValue extends ObservableValue<Boolean> {
+
+    /// Returns the current value, validating a lazily evaluated one.
+    boolean get();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableDoubleValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableDoubleValue.java
new file mode 100644
index 00000000000..bab0b34f259
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableDoubleValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding a `double`.
+public interface ObservableDoubleValue extends ObservableNumberValue {
+
+    /// Returns the current value, validating a lazily evaluated one.
+    double get();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableFloatValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableFloatValue.java
new file mode 100644
index 00000000000..582a2dd29c3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableFloatValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding a `float`.
+public interface ObservableFloatValue extends ObservableNumberValue {
+
+    /// Returns the current value, validating a lazily evaluated one.
+    float get();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableIntegerValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableIntegerValue.java
new file mode 100644
index 00000000000..3753d4296a7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableIntegerValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding a `int`.
+public interface ObservableIntegerValue extends ObservableNumberValue {
+
+    /// Returns the current value, validating a lazily evaluated one.
+    int get();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableListValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableListValue.java
new file mode 100644
index 00000000000..26c912e9bfb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableListValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+import javafx.collections.ObservableList;
+
+/// An observable reference to an [ObservableList] that is itself usable as
+/// that list.
+public interface ObservableListValue<E> extends ObservableObjectValue<ObservableList<E>>, ObservableList<E> {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableLongValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableLongValue.java
new file mode 100644
index 00000000000..baaa5a0f017
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableLongValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding a `long`.
+public interface ObservableLongValue extends ObservableNumberValue {
+
+    /// Returns the current value, validating a lazily evaluated one.
+    long get();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableNumberValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableNumberValue.java
new file mode 100644
index 00000000000..65631d4d002
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableNumberValue.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable numeric value, readable as any primitive number type.
+public interface ObservableNumberValue extends ObservableValue<Number> {
+
+    /// Returns the value as an `int`.
+    int intValue();
+
+    /// Returns the value as a `long`.
+    long longValue();
+
+    /// Returns the value as a `float`.
+    float floatValue();
+
+    /// Returns the value as a `double`.
+    double doubleValue();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableObjectValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableObjectValue.java
new file mode 100644
index 00000000000..2b1c200e2d3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableObjectValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding an object.
+public interface ObservableObjectValue<T> extends ObservableValue<T> {
+
+    /// Returns the current value, validating a lazily evaluated one.
+    T get();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableStringValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableStringValue.java
new file mode 100644
index 00000000000..751e917bc90
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableStringValue.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// An observable value holding a string.
+public interface ObservableStringValue extends ObservableObjectValue<String> {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableValue.java
new file mode 100644
index 00000000000..84e38803318
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableValue.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+import javafx.beans.Observable;
+
+/// A value that can be read and observed.
+///
+/// An [javafx.beans.InvalidationListener] hears that the value may have
+/// changed; a [ChangeListener] is handed the old and the new value, which
+/// forces the value to be computed on every invalidation.
+public interface ObservableValue<T> extends Observable {
+
+    /// Adds a listener told whenever the value changes.
+    void addListener(ChangeListener<? super T> listener);
+
+    /// Removes one registration of the listener; unknown listeners are ignored.
+    void removeListener(ChangeListener<? super T> listener);
+
+    /// Returns the current value.
+    T getValue();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableValueBase.java b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableValueBase.java
new file mode 100644
index 00000000000..b78e89b340d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/ObservableValueBase.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+import com.codename1.fxcompat.runtime.ValueListeners;
+
+import javafx.beans.InvalidationListener;
+
+/// A convenient base for an [ObservableValue]: it keeps the listeners, and
+/// the subclass supplies the value and calls [#fireValueChangedEvent()] when
+/// it changes.
+public abstract class ObservableValueBase<T> implements ObservableValue<T> {
+
+    private ValueListeners<T> helper;
+
+    /// Creates the value.
+    public ObservableValueBase() {
+    }
+
+    @Override
+    public void addListener(InvalidationListener listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void addListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.add(helper, this, listener);
+    }
+
+    @Override
+    public void removeListener(InvalidationListener listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    @Override
+    public void removeListener(ChangeListener<? super T> listener) {
+        helper = ValueListeners.remove(helper, listener);
+    }
+
+    /// Tells the listeners the value may have changed.
+    protected void fireValueChangedEvent() {
+        ValueListeners.fire(helper);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WeakChangeListener.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WeakChangeListener.java
new file mode 100644
index 00000000000..9af5b0e4ab1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WeakChangeListener.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+import java.lang.ref.WeakReference;
+
+import javafx.beans.WeakListener;
+
+/// A [ChangeListener] that forwards to another one without keeping it alive.
+/// Whoever creates it must hold the wrapped listener; once that is collected,
+/// this listener removes itself on the next change.
+public final class WeakChangeListener<T> implements ChangeListener<T>, WeakListener {
+
+    private final WeakReference ref;
+
+    /// Wraps a listener.
+    public WeakChangeListener(ChangeListener<T> listener) {
+        if (listener == null) {
+            throw new NullPointerException("Listener must be specified.");
+        }
+        this.ref = new WeakReference(listener);
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+        Object listener = ref.get();
+        if (listener instanceof ChangeListener) {
+            ((ChangeListener<T>) listener).changed(observable, oldValue, newValue);
+        } else {
+            observable.removeListener(this);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableBooleanValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableBooleanValue.java
new file mode 100644
index 00000000000..ff930166a89
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableBooleanValue.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding a boolean.
+public interface WritableBooleanValue extends WritableValue<Boolean> {
+
+    /// Returns the current value.
+    boolean get();
+
+    /// Sets the value.
+    void set(boolean value);
+
+    /// Sets the value from its boxed form; `null` stores the default value.
+    @Override
+    void setValue(Boolean value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableDoubleValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableDoubleValue.java
new file mode 100644
index 00000000000..07ad691cfe5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableDoubleValue.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding a `double`.
+public interface WritableDoubleValue extends WritableNumberValue {
+
+    /// Returns the current value.
+    double get();
+
+    /// Sets the value.
+    void set(double value);
+
+    /// Sets the value from its boxed form; `null` stores the default value.
+    @Override
+    void setValue(Number value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableFloatValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableFloatValue.java
new file mode 100644
index 00000000000..f142a442172
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableFloatValue.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding a `float`.
+public interface WritableFloatValue extends WritableNumberValue {
+
+    /// Returns the current value.
+    float get();
+
+    /// Sets the value.
+    void set(float value);
+
+    /// Sets the value from its boxed form; `null` stores the default value.
+    @Override
+    void setValue(Number value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableIntegerValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableIntegerValue.java
new file mode 100644
index 00000000000..3b05c184b64
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableIntegerValue.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding a `int`.
+public interface WritableIntegerValue extends WritableNumberValue {
+
+    /// Returns the current value.
+    int get();
+
+    /// Sets the value.
+    void set(int value);
+
+    /// Sets the value from its boxed form; `null` stores the default value.
+    @Override
+    void setValue(Number value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableListValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableListValue.java
new file mode 100644
index 00000000000..512577d8d12
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableListValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+import javafx.collections.ObservableList;
+
+/// A writable reference to an [ObservableList] that is itself usable as that
+/// list.
+public interface WritableListValue<E> extends WritableObjectValue<ObservableList<E>>, ObservableList<E> {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableLongValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableLongValue.java
new file mode 100644
index 00000000000..6643864fce2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableLongValue.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding a `long`.
+public interface WritableLongValue extends WritableNumberValue {
+
+    /// Returns the current value.
+    long get();
+
+    /// Sets the value.
+    void set(long value);
+
+    /// Sets the value from its boxed form; `null` stores the default value.
+    @Override
+    void setValue(Number value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableNumberValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableNumberValue.java
new file mode 100644
index 00000000000..1b3745071b6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableNumberValue.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable numeric value.
+public interface WritableNumberValue extends WritableValue<Number> {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableObjectValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableObjectValue.java
new file mode 100644
index 00000000000..3521ec964ce
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableObjectValue.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding an object.
+public interface WritableObjectValue<T> extends WritableValue<T> {
+
+    /// Returns the current value.
+    T get();
+
+    /// Sets the value.
+    void set(T value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableStringValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableStringValue.java
new file mode 100644
index 00000000000..c37ec25a961
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableStringValue.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A writable value holding a string.
+public interface WritableStringValue extends WritableObjectValue<String> {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/WritableValue.java b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableValue.java
new file mode 100644
index 00000000000..58d46781f97
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/WritableValue.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.beans.value;
+
+/// A value that can be read and written.
+public interface WritableValue<T> {
+
+    /// Returns the current value.
+    T getValue();
+
+    /// Sets the value.
+    void setValue(T value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/beans/value/package-info.java b/maven/javafx-compat/src/main/java/javafx/beans/value/package-info.java
new file mode 100644
index 00000000000..f0971b815e3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/beans/value/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Observable and writable values, their listeners and the typed variants
+/// that read a primitive without boxing it.
+package javafx.beans.value;
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/FXCollections.java b/maven/javafx-compat/src/main/java/javafx/collections/FXCollections.java
new file mode 100644
index 00000000000..c7708dfa89c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/FXCollections.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+import com.codename1.fxcompat.runtime.ArrayObservableList;
+import com.codename1.fxcompat.runtime.ConstantObservableList;
+import com.codename1.fxcompat.runtime.ObservableMapWrapper;
+import com.codename1.fxcompat.runtime.ObservableSetWrapper;
+import com.codename1.fxcompat.runtime.UnmodifiableViews;
+
+import javafx.beans.Observable;
+import javafx.util.Callback;
+
+/// Creates observable collections and applies the bulk operations of
+/// `java.util.Collections` to them so that each is reported as one change.
+public class FXCollections {
+
+    private FXCollections() {
+    }
+
+    /// Wraps a list; changes made through the wrapper are reported, changes
+    /// made to the list directly are not.
+    public static <E> ObservableList<E> observableList(List<E> list) {
+        if (list == null) {
+            throw new NullPointerException();
+        }
+        return new ArrayObservableList<E>(list, null);
+    }
+
+    /// Wraps a list and also reports, as an update, a change of any
+    /// observable the extractor returns for an element.
+    public static <E> ObservableList<E> observableList(List<E> list, Callback<E, Observable[]> extractor) {
+        if (list == null || extractor == null) {
+            throw new NullPointerException();
+        }
+        return new ArrayObservableList<E>(list, extractor);
+    }
+
+    /// Creates an empty observable list backed by an array list.
+    public static <E> ObservableList<E> observableArrayList() {
+        return observableList(new ArrayList<E>());
+    }
+
+    /// Creates an empty observable list that also reports, as an update, a
+    /// change of any observable the extractor returns for an element.
+    public static <E> ObservableList<E> observableArrayList(Callback<E, Observable[]> extractor) {
+        return observableList(new ArrayList<E>(), extractor);
+    }
+
+    /// Creates an observable list holding the given elements.
+    public static <E> ObservableList<E> observableArrayList(E... items) {
+        ObservableList<E> list = observableArrayList();
+        list.addAll(items);
+        return list;
+    }
+
+    /// Creates an observable list holding a copy of a collection.
+    public static <E> ObservableList<E> observableArrayList(Collection<? extends E> col) {
+        ObservableList<E> list = observableArrayList();
+        list.addAll(col);
+        return list;
+    }
+
+    /// Wraps a map; changes made through the wrapper are reported.
+    public static <K, V> ObservableMap<K, V> observableMap(Map<K, V> map) {
+        if (map == null) {
+            throw new NullPointerException();
+        }
+        return new ObservableMapWrapper<K, V>(map);
+    }
+
+    /// Creates an empty observable map backed by a hash map.
+    public static <K, V> ObservableMap<K, V> observableHashMap() {
+        return observableMap(new HashMap<K, V>());
+    }
+
+    /// Wraps a set; changes made through the wrapper are reported.
+    public static <E> ObservableSet<E> observableSet(Set<E> set) {
+        if (set == null) {
+            throw new NullPointerException();
+        }
+        return new ObservableSetWrapper<E>(set);
+    }
+
+    /// Creates an observable set holding the given elements.
+    public static <E> ObservableSet<E> observableSet(E... elements) {
+        if (elements == null) {
+            throw new NullPointerException();
+        }
+        Set<E> set = new HashSet<E>(elements.length);
+        Collections.addAll(set, elements);
+        return new ObservableSetWrapper<E>(set);
+    }
+
+    /// Returns a read-only view of a list that reports its changes.
+    public static <E> ObservableList<E> unmodifiableObservableList(ObservableList<E> list) {
+        if (list == null) {
+            throw new NullPointerException();
+        }
+        return new UnmodifiableViews.OfList<E>(list);
+    }
+
+    /// Returns a read-only view of a map that reports its changes.
+    public static <K, V> ObservableMap<K, V> unmodifiableObservableMap(ObservableMap<K, V> map) {
+        if (map == null) {
+            throw new NullPointerException();
+        }
+        return new UnmodifiableViews.OfMap<K, V>(map);
+    }
+
+    /// Returns a read-only view of a set that reports its changes.
+    public static <E> ObservableSet<E> unmodifiableObservableSet(ObservableSet<E> set) {
+        if (set == null) {
+            throw new NullPointerException();
+        }
+        return new UnmodifiableViews.OfSet<E>(set);
+    }
+
+    /// Returns an empty list that can never change.
+    public static <E> ObservableList<E> emptyObservableList() {
+        return new ConstantObservableList<E>(Collections.<E>emptyList());
+    }
+
+    /// Returns an empty map that can never change.
+    public static <K, V> ObservableMap<K, V> emptyObservableMap() {
+        return new UnmodifiableViews.OfMap<K, V>(FXCollections.<K, V>observableHashMap());
+    }
+
+    /// Returns an empty set that can never change.
+    public static <E> ObservableSet<E> emptyObservableSet() {
+        return new UnmodifiableViews.OfSet<E>(observableSet(new HashSet<E>()));
+    }
+
+    /// Returns a list of one element that can never change.
+    public static <E> ObservableList<E> singletonObservableList(E e) {
+        return new ConstantObservableList<E>(Collections.singletonList(e));
+    }
+
+    /// Creates an observable list holding the content of several lists in
+    /// a row. It is a copy and does not follow them.
+    public static <E> ObservableList<E> concat(ObservableList<E>... lists) {
+        ObservableList<E> result = observableArrayList();
+        if (lists != null) {
+            for (ObservableList<E> list : lists) {
+                result.addAll(list);
+            }
+        }
+        return result;
+    }
+
+    /// Sorts a list into its natural order. A list created by this class
+    /// reports a permutation, any other a replacement of its content.
+    public static <T extends Comparable<? super T>> void sort(ObservableList<T> list) {
+        sort(list, null);
+    }
+
+    /// Sorts a list with a comparator. A list created by this class reports
+    /// a permutation, any other a replacement of its content.
+    public static <T> void sort(ObservableList<T> list, Comparator<? super T> c) {
+        if (list instanceof ArrayObservableList) {
+            list.sort(c);
+        } else {
+            List<T> copy = new ArrayList<T>(list);
+            Collections.sort(copy, c);
+            list.setAll(copy);
+        }
+    }
+
+    /// Reverses a list, reported as a replacement of its content.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static void reverse(ObservableList list) {
+        List copy = new ArrayList(list);
+        Collections.reverse(copy);
+        list.setAll(copy);
+    }
+
+    /// Shuffles a list with the given source of randomness, reported as a
+    /// replacement of its content.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static void shuffle(ObservableList list, Random rnd) {
+        List copy = new ArrayList(list);
+        for (int i = copy.size() - 1; i > 0; i--) {
+            int other = rnd.nextInt(i + 1);
+            Object swapped = copy.get(i);
+            copy.set(i, copy.get(other));
+            copy.set(other, swapped);
+        }
+        list.setAll(copy);
+    }
+
+    /// Sets every element of a list to one object, reported as one change.
+    public static <T> void fill(ObservableList<? super T> list, T obj) {
+        List<T> copy = new ArrayList<T>(list.size());
+        for (int i = list.size(); i > 0; i--) {
+            copy.add(obj);
+        }
+        list.setAll(copy);
+    }
+
+    /// Copies a list over the start of another, which must be at least as
+    /// long; reported as one change.
+    public static <T> void copy(ObservableList<? super T> dest, List<? extends T> src) {
+        final int srcSize = src.size();
+        if (srcSize > dest.size()) {
+            throw new IndexOutOfBoundsException("Source does not fit in dest");
+        }
+        List<Object> copy = new ArrayList<Object>(dest);
+        for (int i = 0; i < srcSize; i++) {
+            copy.set(i, src.get(i));
+        }
+        replaceContent(dest, copy);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private static void replaceContent(ObservableList dest, List content) {
+        dest.setAll(content);
+    }
+
+    /// Replaces every occurrence of a value in a list; returns whether
+    /// there was one.
+    public static <T> boolean replaceAll(ObservableList<T> list, T oldVal, T newVal) {
+        List<T> copy = new ArrayList<T>(list);
+        boolean modified = false;
+        for (int i = 0; i < copy.size(); i++) {
+            T current = copy.get(i);
+            if (current == null ? oldVal == null : current.equals(oldVal)) {
+                copy.set(i, newVal);
+                modified = true;
+            }
+        }
+        if (modified) {
+            list.setAll(copy);
+        }
+        return modified;
+    }
+
+    /// Rotates a list by a distance, reported as a replacement of its
+    /// content.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static void rotate(ObservableList list, int distance) {
+        List copy = new ArrayList(list);
+        Collections.rotate(copy, distance);
+        list.setAll(copy);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/ListChangeListener.java b/maven/javafx-compat/src/main/java/javafx/collections/ListChangeListener.java
new file mode 100644
index 00000000000..88a8d11949f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/ListChangeListener.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.Collections;
+import java.util.List;
+
+/// Told about the changes made to an [ObservableList].
+@FunctionalInterface
+public interface ListChangeListener<E> {
+
+    /// Called after the list changed. The change must be walked with
+    /// [Change#next()] and is only valid during the call.
+    void onChanged(Change<? extends E> c);
+
+    /// A report of what happened to a list, as a sequence of steps.
+    ///
+    /// The steps are ordered by position and each describes the list as it
+    /// is once the steps before it have been applied, so a listener can
+    /// replay them in order on a copy. A step is one of: a range of added
+    /// elements, possibly replacing removed ones ([#wasAdded()],
+    /// [#wasRemoved()], both for [#wasReplaced()]); a reordering of a range
+    /// ([#wasPermutated()]); or a range of elements whose own state changed
+    /// ([#wasUpdated()]).
+    ///
+    /// A new change stands before its first step: nothing may be read until
+    /// [#next()] returned `true`.
+    public abstract static class Change<E> {
+
+        private final ObservableList<E> list;
+
+        /// Creates a change of a list.
+        public Change(ObservableList<E> list) {
+            this.list = list;
+        }
+
+        /// Moves to the next step; returns `false` when there is none.
+        public abstract boolean next();
+
+        /// Goes back to before the first step.
+        public abstract void reset();
+
+        /// Returns the list that changed.
+        public ObservableList<E> getList() {
+            return list;
+        }
+
+        /// Returns where the step starts.
+        public abstract int getFrom();
+
+        /// Returns the end, exclusive, of the range the step added,
+        /// reordered or updated; equal to [#getFrom()] for a pure removal.
+        public abstract int getTo();
+
+        /// Returns the elements the step removed or replaced, in the order
+        /// they had; empty when it removed nothing.
+        public abstract List<E> getRemoved();
+
+        /// Returns whether the step reordered its range.
+        public boolean wasPermutated() {
+            return getPermutation().length != 0;
+        }
+
+        /// Returns whether the step added elements.
+        public boolean wasAdded() {
+            return !wasPermutated() && !wasUpdated() && getFrom() < getTo();
+        }
+
+        /// Returns whether the step removed elements.
+        public boolean wasRemoved() {
+            return !getRemoved().isEmpty();
+        }
+
+        /// Returns whether the step removed elements and added others in
+        /// their place.
+        public boolean wasReplaced() {
+            return wasAdded() && wasRemoved();
+        }
+
+        /// Returns whether the step reports elements whose state changed.
+        public boolean wasUpdated() {
+            return false;
+        }
+
+        /// Returns the added elements as a view of the list; empty when the
+        /// step added nothing.
+        public List<E> getAddedSubList() {
+            return wasAdded() ? getList().subList(getFrom(), getTo()) : Collections.<E>emptyList();
+        }
+
+        /// Returns how many elements the step removed.
+        public int getRemovedSize() {
+            return getRemoved().size();
+        }
+
+        /// Returns how many elements the step added.
+        public int getAddedSize() {
+            return wasAdded() ? getTo() - getFrom() : 0;
+        }
+
+        /// Returns the reordering: entry `i` is the new position of the
+        /// element that was at `getFrom() + i`. Empty when the step is not
+        /// a permutation.
+        protected abstract int[] getPermutation();
+
+        /// Returns the new position of the element that was at `i`.
+        ///
+        /// #### Throws
+        ///
+        /// - `IllegalStateException`: when the step is not a permutation
+        public int getPermutation(int i) {
+            if (!wasPermutated()) {
+                throw new IllegalStateException("Not a permutation change");
+            }
+            return getPermutation()[i - getFrom()];
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/MapChangeListener.java b/maven/javafx-compat/src/main/java/javafx/collections/MapChangeListener.java
new file mode 100644
index 00000000000..6c3a77e1b46
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/MapChangeListener.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+/// Told about the changes made to an [ObservableMap].
+@FunctionalInterface
+public interface MapChangeListener<K, V> {
+
+    /// Called after one key of the map changed.
+    void onChanged(Change<? extends K, ? extends V> change);
+
+    /// What happened to one key: a value was added, removed, or -- when
+    /// both [#wasAdded()] and [#wasRemoved()] hold -- replaced.
+    public abstract static class Change<K, V> {
+
+        private final ObservableMap<K, V> map;
+
+        /// Creates a change of a map.
+        public Change(ObservableMap<K, V> map) {
+            this.map = map;
+        }
+
+        /// Returns the map that changed.
+        public ObservableMap<K, V> getMap() {
+            return map;
+        }
+
+        /// Returns whether a value was put for the key.
+        public abstract boolean wasAdded();
+
+        /// Returns whether a value was removed for the key.
+        public abstract boolean wasRemoved();
+
+        /// Returns the key that changed.
+        public abstract K getKey();
+
+        /// Returns the value now stored, or `null` for a removal.
+        public abstract V getValueAdded();
+
+        /// Returns the value that was stored, or `null` for an addition.
+        public abstract V getValueRemoved();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/ModifiableObservableListBase.java b/maven/javafx-compat/src/main/java/javafx/collections/ModifiableObservableListBase.java
new file mode 100644
index 00000000000..6dcbc692ccd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/ModifiableObservableListBase.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/// Base class for a modifiable observable list over any storage: the
+/// subclass implements `get`, `size` and the three `do...` methods, and this
+/// class turns every `List` operation into them and reports the changes.
+public abstract class ModifiableObservableListBase<E> extends ObservableListBase<E> {
+
+    /// Creates the list.
+    public ModifiableObservableListBase() {
+    }
+
+    /// Stores an element at a position, shifting the ones after it.
+    protected abstract void doAdd(int index, E element);
+
+    /// Replaces the element at a position and returns the old one.
+    protected abstract E doSet(int index, E element);
+
+    /// Removes the element at a position and returns it.
+    protected abstract E doRemove(int index);
+
+    @Override
+    public boolean setAll(Collection<? extends E> col) {
+        List<E> copy = new ArrayList<E>(col);
+        beginChange();
+        try {
+            clear();
+            addAll(copy);
+        } finally {
+            endChange();
+        }
+        return true;
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        beginChange();
+        try {
+            return super.addAll(c);
+        } finally {
+            endChange();
+        }
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends E> c) {
+        beginChange();
+        try {
+            return super.addAll(index, c);
+        } finally {
+            endChange();
+        }
+    }
+
+    @Override
+    protected void removeRange(int fromIndex, int toIndex) {
+        beginChange();
+        try {
+            for (int i = fromIndex; i < toIndex; i++) {
+                remove(fromIndex);
+            }
+        } finally {
+            endChange();
+        }
+    }
+
+    @Override
+    public void clear() {
+        removeRange(0, size());
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        if (c == null) {
+            throw new NullPointerException();
+        }
+        boolean modified = false;
+        beginChange();
+        try {
+            for (int i = size() - 1; i >= 0; i--) {
+                if (c.contains(get(i))) {
+                    remove(i);
+                    modified = true;
+                }
+            }
+        } finally {
+            endChange();
+        }
+        return modified;
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        if (c == null) {
+            throw new NullPointerException();
+        }
+        boolean modified = false;
+        beginChange();
+        try {
+            for (int i = size() - 1; i >= 0; i--) {
+                if (!c.contains(get(i))) {
+                    remove(i);
+                    modified = true;
+                }
+            }
+        } finally {
+            endChange();
+        }
+        return modified;
+    }
+
+    @Override
+    public void add(int index, E element) {
+        doAdd(index, element);
+        beginChange();
+        nextAdd(index, index + 1);
+        ++modCount;
+        endChange();
+    }
+
+    @Override
+    public E set(int index, E element) {
+        E old = doSet(index, element);
+        beginChange();
+        nextSet(index, old);
+        endChange();
+        return old;
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        int index = indexOf(o);
+        if (index != -1) {
+            remove(index);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public E remove(int index) {
+        E old = doRemove(index);
+        beginChange();
+        nextRemove(index, old);
+        ++modCount;
+        endChange();
+        return old;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/ObservableList.java b/maven/javafx-compat/src/main/java/javafx/collections/ObservableList.java
new file mode 100644
index 00000000000..78410077f34
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/ObservableList.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Predicate;
+
+import javafx.beans.Observable;
+import javafx.collections.transformation.FilteredList;
+import javafx.collections.transformation.SortedList;
+
+/// A list that reports every change to its content.
+public interface ObservableList<E> extends List<E>, Observable {
+
+    /// Adds a listener told about every change to the content.
+    void addListener(ListChangeListener<? super E> listener);
+
+    /// Removes one registration of the listener; unknown listeners are ignored.
+    void removeListener(ListChangeListener<? super E> listener);
+
+    /// Appends the elements, reported as one change.
+    boolean addAll(E... elements);
+
+    /// Replaces the whole content, reported as one change.
+    boolean setAll(E... elements);
+
+    /// Replaces the whole content, reported as one change.
+    boolean setAll(Collection<? extends E> col);
+
+    /// Removes every occurrence of the elements, reported as one change.
+    boolean removeAll(E... elements);
+
+    /// Removes everything but the elements, reported as one change.
+    boolean retainAll(E... elements);
+
+    /// Removes the elements from `from` up to but excluding `to`.
+    void remove(int from, int to);
+
+    /// Returns a live view of the elements a predicate accepts.
+    default FilteredList<E> filtered(Predicate<E> predicate) {
+        return new FilteredList<E>(this, predicate);
+    }
+
+    /// Returns a live view of the content ordered by a comparator.
+    default SortedList<E> sorted(Comparator<E> comparator) {
+        return new SortedList<E>(this, comparator);
+    }
+
+    /// Returns a live view of the content in its natural order.
+    default SortedList<E> sorted() {
+        Comparator<E> natural = new Comparator<E>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public int compare(E first, E second) {
+                if (first == null && second == null) {
+                    return 0;
+                }
+                if (first == null) {
+                    return -1;
+                }
+                if (second == null) {
+                    return 1;
+                }
+                if (first instanceof Comparable) {
+                    return ((Comparable<Object>) first).compareTo(second);
+                }
+                // Elements with no order of their own keep the order they have.
+                return 0;
+            }
+        };
+        return sorted(natural);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/ObservableListBase.java b/maven/javafx-compat/src/main/java/javafx/collections/ObservableListBase.java
new file mode 100644
index 00000000000..60e9a545479
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/ObservableListBase.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.ListChangeBuilder;
+import com.codename1.fxcompat.runtime.ListenerSet;
+
+import javafx.beans.InvalidationListener;
+
+/// Base class for an observable list: it keeps the listeners and assembles
+/// the change reports.
+///
+/// A subclass wraps every modification in [#beginChange()] and
+/// [#endChange()] and describes it in between with the `next...` methods,
+/// each called right after the step it describes was applied. The steps are
+/// merged and ordered, and one change is sent when the outermost
+/// `endChange()` returns; the pairs nest, so a bulk operation built from
+/// single ones is still reported once.
+public abstract class ObservableListBase<E> extends AbstractList<E> implements ObservableList<E> {
+
+    private ListenerSet<ListChangeListener<? super E>> listeners;
+    private final ListChangeBuilder<E> changeBuilder = new ListChangeBuilder<E>(this);
+
+    /// Creates the list.
+    public ObservableListBase() {
+    }
+
+    /// Records that the element at a position changed its own state.
+    protected final void nextUpdate(int pos) {
+        changeBuilder.nextUpdate(pos);
+    }
+
+    /// Records that the element at a position was replaced.
+    protected final void nextSet(int idx, E old) {
+        changeBuilder.nextSet(idx, old);
+    }
+
+    /// Records that the range now at `from` to `to` replaced the given
+    /// elements.
+    protected final void nextReplace(int from, int to, List<? extends E> removed) {
+        changeBuilder.nextReplace(from, to, removed);
+    }
+
+    /// Records that the given elements were removed from a position.
+    protected final void nextRemove(int idx, List<? extends E> removed) {
+        changeBuilder.nextRemove(idx, removed);
+    }
+
+    /// Records that an element was removed from a position.
+    protected final void nextRemove(int idx, E removed) {
+        changeBuilder.nextRemove(idx, removed);
+    }
+
+    /// Records that a range was reordered; entry `i` of the permutation is
+    /// the new position of the element that was at `from + i`.
+    protected final void nextPermutation(int from, int to, int[] perm) {
+        changeBuilder.nextPermutation(from, to, perm);
+    }
+
+    /// Records that the range from `from` to `to` was added.
+    protected final void nextAdd(int from, int to) {
+        changeBuilder.nextAdd(from, to);
+    }
+
+    /// Opens a change; must be matched by [#endChange()].
+    protected final void beginChange() {
+        changeBuilder.beginChange();
+    }
+
+    /// Closes a change and, when it is the outermost one and anything was
+    /// recorded, tells the listeners.
+    protected final void endChange() {
+        ListChangeListener.Change<E> change = changeBuilder.endChange();
+        if (change != null) {
+            fireChange(change);
+        }
+    }
+
+    @Override
+    public final void addListener(InvalidationListener listener) {
+        listeners = ListenerSet.addInvalidation(listeners, listener);
+    }
+
+    @Override
+    public final void removeListener(InvalidationListener listener) {
+        listeners = ListenerSet.removeInvalidation(listeners, listener);
+    }
+
+    @Override
+    public final void addListener(ListChangeListener<? super E> listener) {
+        listeners = ListenerSet.addChange(listeners, listener);
+    }
+
+    @Override
+    public final void removeListener(ListChangeListener<? super E> listener) {
+        listeners = ListenerSet.removeChange(listeners, listener);
+    }
+
+    /// Sends a change to every listener, each starting before its first
+    /// step.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    protected final void fireChange(ListChangeListener.Change<? extends E> change) {
+        ListenerSet<ListChangeListener<? super E>> current = listeners;
+        ListenerSet.fireInvalidation(current, this);
+        List<ListChangeListener<? super E>> targets = ListenerSet.changeListeners(current);
+        for (int i = 0; i < targets.size(); i++) {
+            change.reset();
+            ((ListChangeListener) targets.get(i)).onChanged(change);
+        }
+    }
+
+    /// Returns whether anything listens to this list.
+    protected final boolean hasListeners() {
+        return ListenerSet.hasListeners(listeners);
+    }
+
+    @Override
+    public boolean addAll(E... elements) {
+        return addAll(Arrays.asList(elements));
+    }
+
+    @Override
+    public boolean setAll(E... elements) {
+        return setAll(Arrays.asList(elements));
+    }
+
+    @Override
+    public boolean setAll(Collection<? extends E> col) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean removeAll(E... elements) {
+        return removeAll(Arrays.asList(elements));
+    }
+
+    @Override
+    public boolean retainAll(E... elements) {
+        return retainAll(Arrays.asList(elements));
+    }
+
+    @Override
+    public void remove(int from, int to) {
+        removeRange(from, to);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/ObservableMap.java b/maven/javafx-compat/src/main/java/javafx/collections/ObservableMap.java
new file mode 100644
index 00000000000..77f96f76c15
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/ObservableMap.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.Map;
+
+import javafx.beans.Observable;
+
+/// A map that reports every change to its content.
+public interface ObservableMap<K, V> extends Map<K, V>, Observable {
+
+    /// Adds a listener told about every added, removed or replaced entry.
+    void addListener(MapChangeListener<? super K, ? super V> listener);
+
+    /// Removes one registration of the listener; unknown listeners are ignored.
+    void removeListener(MapChangeListener<? super K, ? super V> listener);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/ObservableSet.java b/maven/javafx-compat/src/main/java/javafx/collections/ObservableSet.java
new file mode 100644
index 00000000000..e0ed4435611
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/ObservableSet.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.util.Set;
+
+import javafx.beans.Observable;
+
+/// A set that reports every change to its content.
+public interface ObservableSet<E> extends Set<E>, Observable {
+
+    /// Adds a listener told about every added or removed element.
+    void addListener(SetChangeListener<? super E> listener);
+
+    /// Removes one registration of the listener; unknown listeners are ignored.
+    void removeListener(SetChangeListener<? super E> listener);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/SetChangeListener.java b/maven/javafx-compat/src/main/java/javafx/collections/SetChangeListener.java
new file mode 100644
index 00000000000..29ff3602bd3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/SetChangeListener.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+/// Told about the changes made to an [ObservableSet].
+@FunctionalInterface
+public interface SetChangeListener<E> {
+
+    /// Called after one element was added or removed.
+    void onChanged(Change<? extends E> change);
+
+    /// What happened to a set: one element was added or removed.
+    public abstract static class Change<E> {
+
+        private final ObservableSet<E> set;
+
+        /// Creates a change of a set.
+        public Change(ObservableSet<E> set) {
+            this.set = set;
+        }
+
+        /// Returns the set that changed.
+        public ObservableSet<E> getSet() {
+            return set;
+        }
+
+        /// Returns whether an element was added.
+        public abstract boolean wasAdded();
+
+        /// Returns whether an element was removed.
+        public abstract boolean wasRemoved();
+
+        /// Returns the added element, or `null` for a removal.
+        public abstract E getElementAdded();
+
+        /// Returns the removed element, or `null` for an addition.
+        public abstract E getElementRemoved();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/WeakListChangeListener.java b/maven/javafx-compat/src/main/java/javafx/collections/WeakListChangeListener.java
new file mode 100644
index 00000000000..02d15f4780d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/WeakListChangeListener.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.lang.ref.WeakReference;
+
+import javafx.beans.WeakListener;
+
+/// A [ListChangeListener] that forwards to another one without keeping it
+/// alive. Whoever creates it must hold the wrapped listener; once that is
+/// collected, this listener removes itself on the next change.
+public final class WeakListChangeListener<E> implements ListChangeListener<E>, WeakListener {
+
+    private final WeakReference ref;
+
+    /// Wraps a listener.
+    public WeakListChangeListener(ListChangeListener<E> listener) {
+        if (listener == null) {
+            throw new NullPointerException("Listener must be specified.");
+        }
+        this.ref = new WeakReference(listener);
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void onChanged(Change<? extends E> change) {
+        Object listener = ref.get();
+        if (listener instanceof ListChangeListener) {
+            ((ListChangeListener<E>) listener).onChanged(change);
+        } else {
+            change.getList().removeListener(this);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/WeakMapChangeListener.java b/maven/javafx-compat/src/main/java/javafx/collections/WeakMapChangeListener.java
new file mode 100644
index 00000000000..4429b2fe040
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/WeakMapChangeListener.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.lang.ref.WeakReference;
+
+import javafx.beans.WeakListener;
+
+/// A [MapChangeListener] that forwards to another one without keeping it
+/// alive. Whoever creates it must hold the wrapped listener; once that is
+/// collected, this listener removes itself on the next change.
+public final class WeakMapChangeListener<K, V> implements MapChangeListener<K, V>, WeakListener {
+
+    private final WeakReference ref;
+
+    /// Wraps a listener.
+    public WeakMapChangeListener(MapChangeListener<K, V> listener) {
+        if (listener == null) {
+            throw new NullPointerException("Listener must be specified.");
+        }
+        this.ref = new WeakReference(listener);
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void onChanged(Change<? extends K, ? extends V> change) {
+        Object listener = ref.get();
+        if (listener instanceof MapChangeListener) {
+            ((MapChangeListener<K, V>) listener).onChanged(change);
+        } else {
+            change.getMap().removeListener(this);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/WeakSetChangeListener.java b/maven/javafx-compat/src/main/java/javafx/collections/WeakSetChangeListener.java
new file mode 100644
index 00000000000..793690093e4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/WeakSetChangeListener.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections;
+
+import java.lang.ref.WeakReference;
+
+import javafx.beans.WeakListener;
+
+/// A [SetChangeListener] that forwards to another one without keeping it
+/// alive. Whoever creates it must hold the wrapped listener; once that is
+/// collected, this listener removes itself on the next change.
+public final class WeakSetChangeListener<E> implements SetChangeListener<E>, WeakListener {
+
+    private final WeakReference ref;
+
+    /// Wraps a listener.
+    public WeakSetChangeListener(SetChangeListener<E> listener) {
+        if (listener == null) {
+            throw new NullPointerException("Listener must be specified.");
+        }
+        this.ref = new WeakReference(listener);
+    }
+
+    @Override
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void onChanged(Change<? extends E> change) {
+        Object listener = ref.get();
+        if (listener instanceof SetChangeListener) {
+            ((SetChangeListener<E>) listener).onChanged(change);
+        } else {
+            change.getSet().removeListener(this);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/package-info.java b/maven/javafx-compat/src/main/java/javafx/collections/package-info.java
new file mode 100644
index 00000000000..cb3a01f28b5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Observable collections: lists, maps and sets that report every change to
+/// their content, the listeners that receive those reports and the
+/// [javafx.collections.FXCollections] factory.
+package javafx.collections;
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/transformation/FilteredList.java b/maven/javafx-compat/src/main/java/javafx/collections/transformation/FilteredList.java
new file mode 100644
index 00000000000..5ce7a504e55
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/transformation/FilteredList.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections.transformation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+import javafx.beans.NamedArg;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ObjectPropertyBase;
+import javafx.collections.ListChangeListener.Change;
+import javafx.collections.ObservableList;
+
+/// A live view of the elements of a list that a predicate accepts, in their
+/// source order. With no predicate it shows everything.
+///
+/// The view follows the source: elements appear and disappear as they are
+/// added, removed, or -- when the source reports an update -- start or stop
+/// matching. Changing the predicate is reported as a replacement of the
+/// whole content.
+public final class FilteredList<E> extends TransformationList<E, E> {
+
+    private int[] filtered;
+    private int size;
+    private final ObjectProperty<Predicate<? super E>> predicate;
+
+    /// Creates a view showing the elements a predicate accepts.
+    public FilteredList(@NamedArg("source") ObservableList<E> source,
+            @NamedArg("predicate") Predicate<? super E> predicate) {
+        super(source);
+        this.filtered = new int[source.size() * 3 / 2 + 1];
+        this.predicate = new ObjectPropertyBase<Predicate<? super E>>(predicate) {
+            @Override
+            protected void invalidated() {
+                refilter();
+            }
+
+            @Override
+            public Object getBean() {
+                return FilteredList.this;
+            }
+
+            @Override
+            public String getName() {
+                return "predicate";
+            }
+        };
+        refilter();
+    }
+
+    /// Creates a view showing every element.
+    public FilteredList(@NamedArg("source") ObservableList<E> source) {
+        this(source, null);
+    }
+
+    /// The predicate an element must satisfy to be shown; `null` shows all.
+    public final ObjectProperty<Predicate<? super E>> predicateProperty() {
+        return predicate;
+    }
+
+    /// Returns the predicate, or `null` when everything is shown.
+    public final Predicate<? super E> getPredicate() {
+        return predicate.get();
+    }
+
+    /// Sets the predicate; `null` shows everything.
+    public final void setPredicate(Predicate<? super E> predicate) {
+        this.predicate.set(predicate);
+    }
+
+    private boolean accepts(E element) {
+        Predicate<? super E> current = getPredicate();
+        return current == null || current.test(element);
+    }
+
+    private void ensureCapacity(int capacity) {
+        if (filtered.length < capacity) {
+            filtered = Arrays.copyOf(filtered, capacity * 3 / 2 + 1);
+        }
+    }
+
+    /// Returns the first view position whose source index is not below the
+    /// given one.
+    private int findPosition(int sourceIndex) {
+        int low = 0;
+        int high = size;
+        while (low < high) {
+            int mid = (low + high) >>> 1;
+            if (filtered[mid] < sourceIndex) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        return low;
+    }
+
+    private void refilter() {
+        ObservableList<? extends E> source = getSource();
+        List<E> removed = hasListeners() ? new ArrayList<E>(this) : null;
+        int count = source.size();
+        ensureCapacity(count);
+        size = 0;
+        for (int i = 0; i < count; i++) {
+            if (accepts(source.get(i))) {
+                filtered[size++] = i;
+            }
+        }
+        modCount++;
+        if (removed != null) {
+            beginChange();
+            nextReplace(0, size, removed);
+            endChange();
+        }
+    }
+
+    @Override
+    protected void sourceChanged(Change<? extends E> c) {
+        beginChange();
+        try {
+            while (c.next()) {
+                if (c.wasPermutated()) {
+                    permutate(c);
+                } else if (c.wasUpdated()) {
+                    update(c);
+                } else {
+                    addRemove(c);
+                }
+            }
+            modCount++;
+        } finally {
+            endChange();
+        }
+    }
+
+    private void permutate(Change<? extends E> c) {
+        int first = findPosition(c.getFrom());
+        int last = findPosition(c.getTo());
+        int count = last - first;
+        if (count == 0) {
+            return;
+        }
+        // Each key is the new source index with the old view offset below it,
+        // so sorting the keys orders the shown elements by where they are now.
+        long[] keys = new long[count];
+        for (int i = 0; i < count; i++) {
+            keys[i] = ((long) c.getPermutation(filtered[first + i]) << 32) | i;
+        }
+        Arrays.sort(keys);
+        int[] perm = new int[count];
+        boolean moved = false;
+        for (int i = 0; i < count; i++) {
+            int oldOffset = (int) (keys[i] & 0xffffffffL);
+            perm[oldOffset] = first + i;
+            filtered[first + i] = (int) (keys[i] >>> 32);
+            moved |= oldOffset != i;
+        }
+        if (moved) {
+            nextPermutation(first, last, perm);
+        }
+    }
+
+    private void update(Change<? extends E> c) {
+        ObservableList<? extends E> source = getSource();
+        for (int i = c.getFrom(); i < c.getTo(); i++) {
+            E element = source.get(i);
+            int position = findPosition(i);
+            boolean shown = position < size && filtered[position] == i;
+            boolean matches = accepts(element);
+            if (shown && matches) {
+                nextUpdate(position);
+            } else if (shown) {
+                System.arraycopy(filtered, position + 1, filtered, position, size - position - 1);
+                size--;
+                nextRemove(position, element);
+            } else if (matches) {
+                ensureCapacity(size + 1);
+                System.arraycopy(filtered, position, filtered, position + 1, size - position);
+                filtered[position] = i;
+                size++;
+                nextAdd(position, position + 1);
+            }
+        }
+    }
+
+    private void addRemove(Change<? extends E> c) {
+        ObservableList<? extends E> source = getSource();
+        int from = c.getFrom();
+        int removedSize = c.getRemovedSize();
+        int addedSize = c.getAddedSize();
+        if (removedSize > 0) {
+            int first = findPosition(from);
+            int last = findPosition(from + removedSize);
+            if (last > first) {
+                List<E> removed = new ArrayList<E>(last - first);
+                for (int p = first; p < last; p++) {
+                    removed.add(c.getRemoved().get(filtered[p] - from));
+                }
+                System.arraycopy(filtered, last, filtered, first, size - last);
+                size -= last - first;
+                nextRemove(first, removed);
+            }
+            for (int p = first; p < size; p++) {
+                filtered[p] -= removedSize;
+            }
+        }
+        if (addedSize > 0) {
+            int position = findPosition(from);
+            int[] accepted = new int[addedSize];
+            int count = 0;
+            for (int i = from; i < from + addedSize; i++) {
+                if (accepts(source.get(i))) {
+                    accepted[count++] = i;
+                }
+            }
+            ensureCapacity(size + count);
+            System.arraycopy(filtered, position, filtered, position + count, size - position);
+            System.arraycopy(accepted, 0, filtered, position, count);
+            size += count;
+            for (int p = position + count; p < size; p++) {
+                filtered[p] += addedSize;
+            }
+            if (count > 0) {
+                nextAdd(position, position + count);
+            }
+        }
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public E get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+        return getSource().get(filtered[index]);
+    }
+
+    @Override
+    public int getSourceIndex(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+        return filtered[index];
+    }
+
+    @Override
+    public int getViewIndex(int index) {
+        int position = findPosition(index);
+        return position < size && filtered[position] == index ? position : -1;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/transformation/SortedList.java b/maven/javafx-compat/src/main/java/javafx/collections/transformation/SortedList.java
new file mode 100644
index 00000000000..31f7dc24a7e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/transformation/SortedList.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections.transformation;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+import javafx.beans.NamedArg;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ObjectPropertyBase;
+import javafx.collections.ListChangeListener.Change;
+import javafx.collections.ObservableList;
+
+/// A live view of a list ordered by a comparator. With no comparator it
+/// shows the source order.
+///
+/// Elements the comparator calls equal keep their source order. The view
+/// follows the source: an added element is inserted where it belongs, and an
+/// element the source reports as updated moves if its order changed.
+/// Changing the comparator is reported as a permutation.
+public final class SortedList<E> extends TransformationList<E, E> {
+
+    private Object[] elements;
+    private int[] indexes;
+    private int size;
+    private final ObjectProperty<Comparator<? super E>> comparator;
+
+    /// Creates a view ordered by a comparator.
+    public SortedList(@NamedArg("source") ObservableList<? extends E> source,
+            @NamedArg("comparator") Comparator<? super E> comparator) {
+        super(source);
+        size = source.size();
+        elements = new Object[size * 3 / 2 + 1];
+        indexes = new int[elements.length];
+        for (int i = 0; i < size; i++) {
+            elements[i] = source.get(i);
+            indexes[i] = i;
+        }
+        this.comparator = new ObjectPropertyBase<Comparator<? super E>>(comparator) {
+            @Override
+            protected void invalidated() {
+                resort();
+            }
+
+            @Override
+            public Object getBean() {
+                return SortedList.this;
+            }
+
+            @Override
+            public String getName() {
+                return "comparator";
+            }
+        };
+        resort();
+    }
+
+    /// Creates a view in source order.
+    public SortedList(@NamedArg("source") ObservableList<? extends E> source) {
+        this(source, null);
+    }
+
+    /// The comparator ordering the view; `null` keeps the source order.
+    public final ObjectProperty<Comparator<? super E>> comparatorProperty() {
+        return comparator;
+    }
+
+    /// Returns the comparator, or `null` when the view is in source order.
+    public final Comparator<? super E> getComparator() {
+        return comparator.get();
+    }
+
+    /// Sets the comparator; `null` shows the source order.
+    public final void setComparator(Comparator<? super E> comparator) {
+        this.comparator.set(comparator);
+    }
+
+    /// Orders two entries by the comparator and then by source position, so
+    /// the order is total and equal elements stay in source order.
+    @SuppressWarnings("unchecked")
+    private int order(Object first, int firstIndex, Object second, int secondIndex) {
+        Comparator<? super E> current = getComparator();
+        if (current != null) {
+            int result = current.compare((E) first, (E) second);
+            if (result != 0) {
+                return result;
+            }
+        }
+        return firstIndex < secondIndex ? -1 : (firstIndex == secondIndex ? 0 : 1);
+    }
+
+    private void ensureCapacity(int capacity) {
+        if (elements.length < capacity) {
+            int grown = capacity * 3 / 2 + 1;
+            elements = Arrays.copyOf(elements, grown);
+            indexes = Arrays.copyOf(indexes, grown);
+        }
+    }
+
+    /// Sorts the whole view again and reports the reordering, if any.
+    private void resort() {
+        final Object[] oldElements = elements;
+        final int[] oldIndexes = indexes;
+        Integer[] positions = new Integer[size];
+        for (int i = 0; i < size; i++) {
+            positions[i] = Integer.valueOf(i);
+        }
+        Arrays.sort(positions, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer a, Integer b) {
+                int x = a.intValue();
+                int y = b.intValue();
+                return order(oldElements[x], oldIndexes[x], oldElements[y], oldIndexes[y]);
+            }
+        });
+        Object[] newElements = new Object[oldElements.length];
+        int[] newIndexes = new int[oldIndexes.length];
+        int[] perm = new int[size];
+        boolean moved = false;
+        for (int i = 0; i < size; i++) {
+            int old = positions[i].intValue();
+            newElements[i] = oldElements[old];
+            newIndexes[i] = oldIndexes[old];
+            perm[old] = i;
+            moved |= old != i;
+        }
+        elements = newElements;
+        indexes = newIndexes;
+        if (moved) {
+            modCount++;
+            if (hasListeners()) {
+                beginChange();
+                nextPermutation(0, size, perm);
+                endChange();
+            }
+        }
+    }
+
+    /// Returns where an entry belongs among the first `count` entries.
+    private int insertionPoint(Object element, int sourceIndex, int count) {
+        int low = 0;
+        int high = count;
+        while (low < high) {
+            int mid = (low + high) >>> 1;
+            if (order(elements[mid], indexes[mid], element, sourceIndex) < 0) {
+                low = mid + 1;
+            } else {
+                high = mid;
+            }
+        }
+        return low;
+    }
+
+    private void insert(int position, Object element, int sourceIndex) {
+        ensureCapacity(size + 1);
+        System.arraycopy(elements, position, elements, position + 1, size - position);
+        System.arraycopy(indexes, position, indexes, position + 1, size - position);
+        elements[position] = element;
+        indexes[position] = sourceIndex;
+        size++;
+    }
+
+    private void delete(int position) {
+        System.arraycopy(elements, position + 1, elements, position, size - position - 1);
+        System.arraycopy(indexes, position + 1, indexes, position, size - position - 1);
+        size--;
+        elements[size] = null;
+    }
+
+    @Override
+    protected void sourceChanged(Change<? extends E> c) {
+        beginChange();
+        try {
+            while (c.next()) {
+                if (c.wasPermutated()) {
+                    for (int i = 0; i < size; i++) {
+                        if (indexes[i] >= c.getFrom() && indexes[i] < c.getTo()) {
+                            indexes[i] = c.getPermutation(indexes[i]);
+                        }
+                    }
+                    // Equal elements are ordered by source position, which
+                    // just changed; with no comparator the whole view did.
+                    resort();
+                } else if (c.wasUpdated()) {
+                    update(c);
+                } else {
+                    addRemove(c);
+                }
+            }
+            modCount++;
+        } finally {
+            endChange();
+        }
+    }
+
+    private boolean inOrder() {
+        for (int i = 1; i < size; i++) {
+            if (order(elements[i - 1], indexes[i - 1], elements[i], indexes[i]) > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void update(Change<? extends E> c) {
+        int from = c.getFrom();
+        int to = c.getTo();
+        if (inOrder()) {
+            for (int i = 0; i < size; i++) {
+                if (indexes[i] >= from && indexes[i] < to) {
+                    nextUpdate(i);
+                }
+            }
+            return;
+        }
+        // Take the updated elements out, which leaves a sorted remainder,
+        // and put each back where it now belongs.
+        int count = to - from;
+        Object[] moved = new Object[count];
+        for (int i = size - 1; i >= 0; i--) {
+            if (indexes[i] >= from && indexes[i] < to) {
+                Object element = elements[i];
+                moved[indexes[i] - from] = element;
+                delete(i);
+                nextRemove(i, (E) element);
+            }
+        }
+        for (int i = 0; i < count; i++) {
+            int position = insertionPoint(moved[i], from + i, size);
+            insert(position, moved[i], from + i);
+            nextAdd(position, position + 1);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void addRemove(Change<? extends E> c) {
+        ObservableList<? extends E> source = getSource();
+        int from = c.getFrom();
+        int removedSize = c.getRemovedSize();
+        int addedSize = c.getAddedSize();
+        if (removedSize > 0) {
+            for (int i = size - 1; i >= 0; i--) {
+                if (indexes[i] >= from && indexes[i] < from + removedSize) {
+                    Object element = elements[i];
+                    delete(i);
+                    nextRemove(i, (E) element);
+                }
+            }
+            for (int i = 0; i < size; i++) {
+                if (indexes[i] >= from) {
+                    indexes[i] -= removedSize;
+                }
+            }
+        }
+        if (addedSize > 0) {
+            for (int i = 0; i < size; i++) {
+                if (indexes[i] >= from) {
+                    indexes[i] += addedSize;
+                }
+            }
+            if (size == 0) {
+                // Filling an empty view: sort the lot once instead of
+                // inserting element by element.
+                ensureCapacity(addedSize);
+                for (int i = 0; i < addedSize; i++) {
+                    elements[i] = source.get(from + i);
+                    indexes[i] = from + i;
+                }
+                size = addedSize;
+                boolean listening = hasListeners();
+                resortQuietly();
+                if (listening) {
+                    nextAdd(0, size);
+                }
+            } else {
+                for (int i = from; i < from + addedSize; i++) {
+                    Object element = source.get(i);
+                    int position = insertionPoint(element, i, size);
+                    insert(position, element, i);
+                    nextAdd(position, position + 1);
+                }
+            }
+        }
+    }
+
+    /// Sorts without reporting; for content nobody has been told about yet.
+    private void resortQuietly() {
+        final Object[] oldElements = elements;
+        final int[] oldIndexes = indexes;
+        Integer[] positions = new Integer[size];
+        for (int i = 0; i < size; i++) {
+            positions[i] = Integer.valueOf(i);
+        }
+        Arrays.sort(positions, new Comparator<Integer>() {
+            @Override
+            public int compare(Integer a, Integer b) {
+                int x = a.intValue();
+                int y = b.intValue();
+                return order(oldElements[x], oldIndexes[x], oldElements[y], oldIndexes[y]);
+            }
+        });
+        Object[] newElements = new Object[oldElements.length];
+        int[] newIndexes = new int[oldIndexes.length];
+        for (int i = 0; i < size; i++) {
+            int old = positions[i].intValue();
+            newElements[i] = oldElements[old];
+            newIndexes[i] = oldIndexes[old];
+        }
+        elements = newElements;
+        indexes = newIndexes;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public E get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+        return (E) elements[index];
+    }
+
+    @Override
+    public int getSourceIndex(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+        return indexes[index];
+    }
+
+    @Override
+    public int getViewIndex(int index) {
+        for (int i = 0; i < size; i++) {
+            if (indexes[i] == index) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/transformation/TransformationList.java b/maven/javafx-compat/src/main/java/javafx/collections/transformation/TransformationList.java
new file mode 100644
index 00000000000..a1e20528218
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/transformation/TransformationList.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.collections.transformation;
+
+import java.util.List;
+
+import javafx.collections.ListChangeListener;
+import javafx.collections.ListChangeListener.Change;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableListBase;
+import javafx.collections.WeakListChangeListener;
+
+/// Base class for a list that presents another observable list differently
+/// and follows its changes. The view observes its source weakly, so an
+/// unused view is collected while the source lives on.
+public abstract class TransformationList<E, F> extends ObservableListBase<E> {
+
+    private final ObservableList<? extends F> source;
+    private final ListChangeListener<F> sourceListener;
+
+    /// Creates a view of a source list.
+    protected TransformationList(ObservableList<? extends F> source) {
+        if (source == null) {
+            throw new NullPointerException();
+        }
+        this.source = source;
+        this.sourceListener = new ListChangeListener<F>() {
+            @Override
+            public void onChanged(Change<? extends F> change) {
+                TransformationList.this.sourceChanged(change);
+            }
+        };
+        source.addListener(new WeakListChangeListener<F>(sourceListener));
+    }
+
+    /// Returns the list this one is a view of.
+    public final ObservableList<? extends F> getSource() {
+        return source;
+    }
+
+    /// Returns whether a list is this view's source, or the source of its
+    /// source, and so on.
+    public final boolean isInTransformationChain(ObservableList<?> list) {
+        List<?> current = source;
+        while (current != list) {
+            if (!(current instanceof TransformationList)) {
+                return false;
+            }
+            current = ((TransformationList<?, ?>) current).source;
+        }
+        return true;
+    }
+
+    /// Called with every change of the source.
+    protected abstract void sourceChanged(Change<? extends F> c);
+
+    /// Returns the position in the source of the element at a position of
+    /// this view.
+    public abstract int getSourceIndex(int index);
+
+    /// Returns the position, in a list somewhere down the chain of sources,
+    /// of the element at a position of this view.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the list is not in the chain
+    public final int getSourceIndexFor(ObservableList<?> list, int index) {
+        if (!isInTransformationChain(list)) {
+            throw new IllegalArgumentException(
+                    "Provided list is not in the transformation chain of this transformation list");
+        }
+        List<?> current = source;
+        int result = getSourceIndex(index);
+        while (current != list && current instanceof TransformationList) {
+            TransformationList<?, ?> view = (TransformationList<?, ?>) current;
+            result = view.getSourceIndex(result);
+            current = view.source;
+        }
+        return result;
+    }
+
+    /// Returns the position in this view of the element at a position of
+    /// the source, or -1 when the view does not show it.
+    public abstract int getViewIndex(int index);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/collections/transformation/package-info.java b/maven/javafx-compat/src/main/java/javafx/collections/transformation/package-info.java
new file mode 100644
index 00000000000..205290a645c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/collections/transformation/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Live views of an observable list: a filtered one, a sorted one and the
+/// base class both are built on.
+package javafx.collections.transformation;
diff --git a/maven/javafx-compat/src/main/java/javafx/concurrent/Service.java b/maven/javafx-compat/src/main/java/javafx/concurrent/Service.java
new file mode 100644
index 00000000000..0375c7c905d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/concurrent/Service.java
@@ -0,0 +1,505 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.concurrent;
+
+import com.codename1.ui.Display;
+
+import javafx.application.Platform;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyStringProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// Work that can be done again and again: every start creates a fresh
+/// [Task] with [#createTask()] and runs it on a new background thread,
+/// and the properties of the service show that task's state, progress
+/// and result.
+///
+/// A service is used from the JavaFX application thread only. It can
+/// be started in the `READY` state alone: [#reset()] takes a service
+/// that ended back there, and [#restart()] cancels, resets and starts
+/// in one step.
+///
+/// Differences from JavaFX: Codename One has no
+/// `java.util.concurrent.Executor`, so there is no executor property;
+/// a subclass that wants its tasks run differently overrides
+/// [#executeTask(Task)].
+public abstract class Service<V> implements Worker<V>, EventTarget {
+
+    private final WorkerEvents events = new WorkerEvents(this);
+    private final ObjectProperty<State> state = new SimpleObjectProperty<State>(this, "state", State.READY);
+    private final ObjectProperty<V> value = new SimpleObjectProperty<V>(this, "value");
+    private final ObjectProperty<Throwable> exception = new SimpleObjectProperty<Throwable>(this, "exception");
+    private final DoubleProperty workDone = new SimpleDoubleProperty(this, "workDone", -1);
+    private final DoubleProperty totalWork = new SimpleDoubleProperty(this, "totalWork", -1);
+    private final DoubleProperty progress = new SimpleDoubleProperty(this, "progress", -1);
+    private final BooleanProperty running = new SimpleBooleanProperty(this, "running", false);
+    private final StringProperty message = new SimpleStringProperty(this, "message", "");
+    private final StringProperty title = new SimpleStringProperty(this, "title", "");
+    private Task<V> task;
+    private int threadNumber;
+
+    /// Creates a service.
+    protected Service() {
+        state.addListener(new ChangeListener<State>() {
+            @Override
+            public void changed(ObservableValue<? extends State> observable, State old, State next) {
+                entered(next);
+            }
+        });
+    }
+
+    /// Creates the task of one run. Called on the application thread
+    /// by every start.
+    protected abstract Task<V> createTask();
+
+    /// Runs a task the service has just created. This implementation
+    /// starts a new thread for it.
+    protected void executeTask(final Task<V> task) {
+        threadNumber++;
+        String name = "fx-service-" + threadNumber;
+        if (Display.isInitialized()) {
+            // A Codename One thread, which the platform's crash reporting knows.
+            Display.getInstance().createThread(task, name).start();
+        } else {
+            new Thread(task, name).start();
+        }
+    }
+
+    // ---- controls ----
+
+    private void checkThread() {
+        if (!Platform.isFxApplicationThread()) {
+            throw new IllegalStateException("Service must only be used from the FX Application Thread");
+        }
+    }
+
+    /// Starts the service, which must be `READY`: creates a task,
+    /// shows it through the properties and runs it.
+    public void start() {
+        checkThread();
+        if (getState() != State.READY) {
+            throw new IllegalStateException("Can only start a Service in the READY state. Was in state "
+                    + getState());
+        }
+        task = createTask();
+        state.bind(task.stateProperty());
+        value.bind(task.valueProperty());
+        exception.bind(task.exceptionProperty());
+        workDone.bind(task.workDoneProperty());
+        totalWork.bind(task.totalWorkProperty());
+        progress.bind(task.progressProperty());
+        running.bind(task.runningProperty());
+        message.bind(task.messageProperty());
+        title.bind(task.titleProperty());
+        task.setState(State.SCHEDULED);
+        executeTask(task);
+    }
+
+    /// Cancels the task that is running, if any. The service then
+    /// stays `CANCELLED` until it is reset.
+    @Override
+    public boolean cancel() {
+        checkThread();
+        if (task == null) {
+            if (state.get() == State.CANCELLED || state.get() == State.SUCCEEDED || state.get() == State.FAILED) {
+                return false;
+            }
+            state.unbind();
+            state.set(State.CANCELLED);
+            return true;
+        }
+        return task.cancel(true);
+    }
+
+    /// Cancels whatever is running and starts afresh.
+    public void restart() {
+        checkThread();
+        if (task != null) {
+            task.cancel();
+            task = null;
+            state.unbind();
+            state.set(State.CANCELLED);
+        }
+        reset();
+        start();
+    }
+
+    /// Takes a service that ended back to `READY` with its properties
+    /// at their defaults. A service that is scheduled or running cannot
+    /// be reset.
+    public void reset() {
+        checkThread();
+        State current = getState();
+        if (current == State.SCHEDULED || current == State.RUNNING) {
+            throw new IllegalStateException();
+        }
+        task = null;
+        state.unbind();
+        state.set(State.READY);
+        value.unbind();
+        value.set(null);
+        exception.unbind();
+        exception.set(null);
+        workDone.unbind();
+        workDone.set(-1);
+        totalWork.unbind();
+        totalWork.set(-1);
+        progress.unbind();
+        progress.set(-1);
+        running.unbind();
+        running.set(false);
+        message.unbind();
+        message.set("");
+        title.unbind();
+        title.set("");
+    }
+
+    private void entered(State next) {
+        if (next == null) {
+            return;
+        }
+        events.fire(this, next);
+        switch (next) {
+            case READY:
+                ready();
+                break;
+            case SCHEDULED:
+                scheduled();
+                break;
+            case RUNNING:
+                running();
+                break;
+            case SUCCEEDED:
+                succeeded();
+                break;
+            case CANCELLED:
+                cancelled();
+                break;
+            case FAILED:
+                failed();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /// Called when the service becomes ready again.
+    protected void ready() {
+    }
+
+    /// Called when the service is scheduled.
+    protected void scheduled() {
+    }
+
+    /// Called when the service starts running.
+    protected void running() {
+    }
+
+    /// Called when the service has finished with a result.
+    protected void succeeded() {
+    }
+
+    /// Called when the service was cancelled.
+    protected void cancelled() {
+    }
+
+    /// Called when an exception ended the service.
+    protected void failed() {
+    }
+
+    // ---- properties ----
+
+    @Override
+    public final State getState() {
+        checkThread();
+        return state.get();
+    }
+
+    @Override
+    public final ReadOnlyObjectProperty<State> stateProperty() {
+        checkThread();
+        return state;
+    }
+
+    @Override
+    public final V getValue() {
+        checkThread();
+        return value.get();
+    }
+
+    @Override
+    public final ReadOnlyObjectProperty<V> valueProperty() {
+        checkThread();
+        return value;
+    }
+
+    @Override
+    public final Throwable getException() {
+        checkThread();
+        return exception.get();
+    }
+
+    @Override
+    public final ReadOnlyObjectProperty<Throwable> exceptionProperty() {
+        checkThread();
+        return exception;
+    }
+
+    @Override
+    public final double getWorkDone() {
+        checkThread();
+        return workDone.get();
+    }
+
+    @Override
+    public final ReadOnlyDoubleProperty workDoneProperty() {
+        checkThread();
+        return workDone;
+    }
+
+    @Override
+    public final double getTotalWork() {
+        checkThread();
+        return totalWork.get();
+    }
+
+    @Override
+    public final ReadOnlyDoubleProperty totalWorkProperty() {
+        checkThread();
+        return totalWork;
+    }
+
+    @Override
+    public final double getProgress() {
+        checkThread();
+        return progress.get();
+    }
+
+    @Override
+    public final ReadOnlyDoubleProperty progressProperty() {
+        checkThread();
+        return progress;
+    }
+
+    @Override
+    public final boolean isRunning() {
+        checkThread();
+        return running.get();
+    }
+
+    @Override
+    public final ReadOnlyBooleanProperty runningProperty() {
+        checkThread();
+        return running;
+    }
+
+    @Override
+    public final String getMessage() {
+        checkThread();
+        return message.get();
+    }
+
+    @Override
+    public final ReadOnlyStringProperty messageProperty() {
+        checkThread();
+        return message;
+    }
+
+    @Override
+    public final String getTitle() {
+        checkThread();
+        return title.get();
+    }
+
+    @Override
+    public final ReadOnlyStringProperty titleProperty() {
+        checkThread();
+        return title;
+    }
+
+    // ---- handlers ----
+
+    /// The handler of the service becoming ready again.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onReadyProperty() {
+        checkThread();
+        return events.slot(State.READY);
+    }
+
+    /// Returns the handler of the service becoming ready again.
+    public final EventHandler<WorkerStateEvent> getOnReady() {
+        checkThread();
+        return events.get(State.READY);
+    }
+
+    /// Sets the handler of the service becoming ready again.
+    public final void setOnReady(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.READY).set(value);
+    }
+
+    /// The handler of the service being scheduled.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onScheduledProperty() {
+        checkThread();
+        return events.slot(State.SCHEDULED);
+    }
+
+    /// Returns the handler of the service being scheduled.
+    public final EventHandler<WorkerStateEvent> getOnScheduled() {
+        checkThread();
+        return events.get(State.SCHEDULED);
+    }
+
+    /// Sets the handler of the service being scheduled.
+    public final void setOnScheduled(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.SCHEDULED).set(value);
+    }
+
+    /// The handler of the service starting to run.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onRunningProperty() {
+        checkThread();
+        return events.slot(State.RUNNING);
+    }
+
+    /// Returns the handler of the service starting to run.
+    public final EventHandler<WorkerStateEvent> getOnRunning() {
+        checkThread();
+        return events.get(State.RUNNING);
+    }
+
+    /// Sets the handler of the service starting to run.
+    public final void setOnRunning(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.RUNNING).set(value);
+    }
+
+    /// The handler of the service finishing with a result.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onSucceededProperty() {
+        checkThread();
+        return events.slot(State.SUCCEEDED);
+    }
+
+    /// Returns the handler of the service finishing with a result.
+    public final EventHandler<WorkerStateEvent> getOnSucceeded() {
+        checkThread();
+        return events.get(State.SUCCEEDED);
+    }
+
+    /// Sets the handler of the service finishing with a result.
+    public final void setOnSucceeded(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.SUCCEEDED).set(value);
+    }
+
+    /// The handler of the service being cancelled.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onCancelledProperty() {
+        checkThread();
+        return events.slot(State.CANCELLED);
+    }
+
+    /// Returns the handler of the service being cancelled.
+    public final EventHandler<WorkerStateEvent> getOnCancelled() {
+        checkThread();
+        return events.get(State.CANCELLED);
+    }
+
+    /// Sets the handler of the service being cancelled.
+    public final void setOnCancelled(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.CANCELLED).set(value);
+    }
+
+    /// The handler of the service being ended by an exception.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onFailedProperty() {
+        checkThread();
+        return events.slot(State.FAILED);
+    }
+
+    /// Returns the handler of the service being ended by an exception.
+    public final EventHandler<WorkerStateEvent> getOnFailed() {
+        checkThread();
+        return events.get(State.FAILED);
+    }
+
+    /// Sets the handler of the service being ended by an exception.
+    public final void setOnFailed(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.FAILED).set(value);
+    }
+
+    /// Adds a handler for a type of event and its sub types.
+    public final <T extends Event> void addEventHandler(final EventType<T> eventType,
+            final EventHandler<? super T> eventHandler) {
+        checkThread();
+        events.manager.addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler.
+    public final <T extends Event> void removeEventHandler(final EventType<T> eventType,
+            final EventHandler<? super T> eventHandler) {
+        checkThread();
+        events.manager.removeEventHandler(eventType, eventHandler);
+    }
+
+    /// Adds a filter, which sees an event before the handlers do.
+    public final <T extends Event> void addEventFilter(final EventType<T> eventType,
+            final EventHandler<? super T> eventFilter) {
+        checkThread();
+        events.manager.addEventFilter(eventType, eventFilter);
+    }
+
+    /// Removes a filter.
+    public final <T extends Event> void removeEventFilter(final EventType<T> eventType,
+            final EventHandler<? super T> eventFilter) {
+        checkThread();
+        events.manager.removeEventFilter(eventType, eventFilter);
+    }
+
+    /// Delivers an event to the handlers of the service.
+    protected final void fireEvent(Event event) {
+        checkThread();
+        Event.fireEvent(this, event);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        checkThread();
+        return tail.prepend(events.manager);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/concurrent/Task.java b/maven/javafx-compat/src/main/java/javafx/concurrent/Task.java
new file mode 100644
index 00000000000..931d8ff182c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/concurrent/Task.java
@@ -0,0 +1,635 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.concurrent;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javafx.application.Platform;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.ReadOnlyStringProperty;
+import javafx.beans.property.ReadOnlyStringWrapper;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// One piece of work for a background thread, done once: [#call()]
+/// runs there, and everything it reports reaches the JavaFX application
+/// thread, where the properties of the task change and its handlers
+/// run.
+///
+/// A task is a `Runnable`: hand it to a thread, or let a [Service]
+/// start it. Run directly it goes from `READY` through `SCHEDULED` and
+/// `RUNNING` to `SUCCEEDED`, `FAILED` (an exception left `call()`, see
+/// [#getException()]) or `CANCELLED`. A task runs once; a second `run`
+/// does nothing.
+///
+/// `call()` reports with [#updateProgress(double, double)],
+/// [#updateMessage(String)], [#updateTitle(String)] and
+/// [#updateValue(Object)]. They may be called as often as the work
+/// likes: updates that arrive faster than the application thread takes
+/// them are merged, and it sees the latest.
+///
+/// Cancelling asks the work to stop, it cannot make it:
+/// `call()` should look at [#isCancelled()] now and then. The state
+/// becomes `CANCELLED` at once all the same, and whatever `call()`
+/// returns later is dropped.
+///
+/// The properties belong to the application thread; reading them from
+/// another thread throws `IllegalStateException`. [#isCancelled()],
+/// [#isDone()], [#cancel()] and the `update` methods are for any
+/// thread.
+///
+/// Differences from JavaFX: there a task is a
+/// `java.util.concurrent.FutureTask`. Codename One has no
+/// `java.util.concurrent` beyond the atomic classes, so the task is a
+/// `Runnable` with the `FutureTask` methods that need none of it
+/// (`run`, `cancel(boolean)`, `isCancelled`, `isDone`), and the blocking
+/// `get()` does not exist: take the result from [#getValue()] in a
+/// succeeded handler.
+public abstract class Task<V> implements Worker<V>, EventTarget, Runnable {
+
+    private static final int PENDING = 0;
+    private static final int COMPLETED = 1;
+    private static final int CANCELLED = 2;
+
+    /// The pair an update of the progress carries across threads.
+    private static final class ProgressUpdate {
+        final double workDone;
+        final double totalWork;
+
+        ProgressUpdate(double workDone, double totalWork) {
+            this.workDone = workDone;
+            this.totalWork = totalWork;
+        }
+    }
+
+    // The hand-over between the thread that works and the application
+    // thread. Nothing else of a task is touched by two threads.
+    private final AtomicBoolean started = new AtomicBoolean();
+    private final AtomicInteger outcome = new AtomicInteger(PENDING);
+    private final AtomicReference<Thread> runner = new AtomicReference<Thread>();
+    private final AtomicReference<ProgressUpdate> progressUpdate = new AtomicReference<ProgressUpdate>();
+    private final Pending<String> messageUpdate = new Pending<String>();
+    private final Pending<String> titleUpdate = new Pending<String>();
+    private final Pending<V> valueUpdate = new Pending<V>();
+
+    /// The latest update a worker thread published, coalesced into one
+    /// delivery on the FX thread. Whether a delivery is queued is its own
+    /// flag rather than a null value, because null is an update too: with
+    /// null standing for "nothing queued", `a`, `null`, `b` queued a second
+    /// delivery that overwrote `b` with null. OpenJFX coalesces that way and
+    /// has that defect; the last update must win.
+    private static final class Pending<T> {
+        private final AtomicReference<T> latest = new AtomicReference<T>();
+        private final AtomicBoolean queued = new AtomicBoolean();
+
+        /// Records an update; true when no delivery is queued and the
+        /// caller has to queue one.
+        boolean offer(T value) {
+            latest.set(value);
+            return queued.compareAndSet(false, true);
+        }
+
+        /// The update to deliver. The flag is cleared before the read, so
+        /// an update published after the read queues a delivery of its own.
+        T take() {
+            queued.set(false);
+            return latest.get();
+        }
+    }
+
+    private final WorkerEvents events = new WorkerEvents(this);
+    private final ReadOnlyObjectWrapper<State> state = new ReadOnlyObjectWrapper<State>(this, "state", State.READY);
+    private final ReadOnlyObjectWrapper<V> value = new ReadOnlyObjectWrapper<V>(this, "value");
+    private final ReadOnlyObjectWrapper<Throwable> exception =
+            new ReadOnlyObjectWrapper<Throwable>(this, "exception");
+    private final ReadOnlyDoubleWrapper workDone = new ReadOnlyDoubleWrapper(this, "workDone", -1);
+    private final ReadOnlyDoubleWrapper totalWork = new ReadOnlyDoubleWrapper(this, "totalWork", -1);
+    private final ReadOnlyDoubleWrapper progress = new ReadOnlyDoubleWrapper(this, "progress", -1);
+    private final ReadOnlyBooleanWrapper running = new ReadOnlyBooleanWrapper(this, "running", false);
+    private final ReadOnlyStringWrapper message = new ReadOnlyStringWrapper(this, "message", "");
+    private final ReadOnlyStringWrapper title = new ReadOnlyStringWrapper(this, "title", "");
+
+    /// Creates a task.
+    public Task() {
+    }
+
+    /// Does the work, on a background thread, and returns its result.
+    /// An exception it throws fails the task.
+    protected abstract V call() throws Exception;
+
+    // ---- running ----
+
+    /// Runs the task on the calling thread, which should not be the
+    /// JavaFX application thread: calls [#call()] and reports the
+    /// outcome to the application thread. Only the first call does
+    /// anything, and none does once the task was cancelled.
+    @Override
+    public void run() {
+        if (!started.compareAndSet(false, true) || outcome.get() != PENDING) {
+            return;
+        }
+        runner.set(Thread.currentThread());
+        Platform.runLater(new Runnable() {
+            @Override
+            public void run() {
+                setState(State.SCHEDULED);
+                setState(State.RUNNING);
+            }
+        });
+        try {
+            final V result = call();
+            if (outcome.compareAndSet(PENDING, COMPLETED)) {
+                Platform.runLater(new Runnable() {
+                    @Override
+                    public void run() {
+                        value.set(result);
+                        setState(State.SUCCEEDED);
+                    }
+                });
+            }
+        } catch (final Throwable failure) {
+            if (outcome.compareAndSet(PENDING, COMPLETED)) {
+                Platform.runLater(new Runnable() {
+                    @Override
+                    public void run() {
+                        exception.set(failure);
+                        setState(State.FAILED);
+                    }
+                });
+            }
+        } finally {
+            runner.set(null);
+        }
+    }
+
+    /// Cancels the task, interrupting the thread that runs it.
+    @Override
+    public final boolean cancel() {
+        return cancel(true);
+    }
+
+    /// Cancels the task. Returns `false` when it already ended or was
+    /// cancelled before. `call()` is never started on a cancelled task;
+    /// one that is running is interrupted if asked, and otherwise finds
+    /// out through [#isCancelled()].
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        if (!outcome.compareAndSet(PENDING, CANCELLED)) {
+            return false;
+        }
+        if (mayInterruptIfRunning) {
+            Thread thread = runner.get();
+            if (thread != null) {
+                thread.interrupt();
+            }
+        }
+        if (Platform.isFxApplicationThread()) {
+            setState(State.CANCELLED);
+        } else {
+            Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    setState(State.CANCELLED);
+                }
+            });
+        }
+        return true;
+    }
+
+    /// Returns whether the task was cancelled. For any thread.
+    public boolean isCancelled() {
+        return outcome.get() == CANCELLED;
+    }
+
+    /// Returns whether the task has ended: by returning, by throwing or
+    /// by being cancelled. For any thread; the state property follows
+    /// on the application thread a moment later.
+    public boolean isDone() {
+        return outcome.get() != PENDING;
+    }
+
+    // ---- state ----
+
+    private static boolean ended(State s) {
+        return s == State.SUCCEEDED || s == State.FAILED || s == State.CANCELLED;
+    }
+
+    /// Moves the task to a state, on the application thread: sets the
+    /// properties, delivers the event and calls the method of the
+    /// state. A task that ended stays as it is.
+    final void setState(State next) {
+        State current = state.get();
+        if (current == next || ended(current)) {
+            return;
+        }
+        if (isCancelled() && next != State.CANCELLED) {
+            return;
+        }
+        state.set(next);
+        running.set(next == State.SCHEDULED || next == State.RUNNING);
+        events.fire(this, next);
+        switch (next) {
+            case SCHEDULED:
+                scheduled();
+                break;
+            case RUNNING:
+                running();
+                break;
+            case SUCCEEDED:
+                succeeded();
+                break;
+            case CANCELLED:
+                cancelled();
+                break;
+            case FAILED:
+                failed();
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void checkThread() {
+        if (started.get() && !Platform.isFxApplicationThread()) {
+            throw new IllegalStateException("Task must only be used from the FX Application Thread");
+        }
+    }
+
+    /// Called on the application thread when the task is scheduled.
+    protected void scheduled() {
+    }
+
+    /// Called on the application thread when the task starts running.
+    protected void running() {
+    }
+
+    /// Called on the application thread when the task has finished
+    /// with a result.
+    protected void succeeded() {
+    }
+
+    /// Called on the application thread when the task was cancelled.
+    protected void cancelled() {
+    }
+
+    /// Called on the application thread when an exception ended the
+    /// task.
+    protected void failed() {
+    }
+
+    // ---- properties ----
+
+    @Override
+    public final State getState() {
+        checkThread();
+        return state.get();
+    }
+
+    @Override
+    public final ReadOnlyObjectProperty<State> stateProperty() {
+        checkThread();
+        return state.getReadOnlyProperty();
+    }
+
+    @Override
+    public final V getValue() {
+        checkThread();
+        return value.get();
+    }
+
+    @Override
+    public final ReadOnlyObjectProperty<V> valueProperty() {
+        checkThread();
+        return value.getReadOnlyProperty();
+    }
+
+    @Override
+    public final Throwable getException() {
+        checkThread();
+        return exception.get();
+    }
+
+    @Override
+    public final ReadOnlyObjectProperty<Throwable> exceptionProperty() {
+        checkThread();
+        return exception.getReadOnlyProperty();
+    }
+
+    @Override
+    public final double getWorkDone() {
+        checkThread();
+        return workDone.get();
+    }
+
+    @Override
+    public final ReadOnlyDoubleProperty workDoneProperty() {
+        checkThread();
+        return workDone.getReadOnlyProperty();
+    }
+
+    @Override
+    public final double getTotalWork() {
+        checkThread();
+        return totalWork.get();
+    }
+
+    @Override
+    public final ReadOnlyDoubleProperty totalWorkProperty() {
+        checkThread();
+        return totalWork.getReadOnlyProperty();
+    }
+
+    @Override
+    public final double getProgress() {
+        checkThread();
+        return progress.get();
+    }
+
+    @Override
+    public final ReadOnlyDoubleProperty progressProperty() {
+        checkThread();
+        return progress.getReadOnlyProperty();
+    }
+
+    @Override
+    public final boolean isRunning() {
+        checkThread();
+        return running.get();
+    }
+
+    @Override
+    public final ReadOnlyBooleanProperty runningProperty() {
+        checkThread();
+        return running.getReadOnlyProperty();
+    }
+
+    @Override
+    public final String getMessage() {
+        checkThread();
+        return message.get();
+    }
+
+    @Override
+    public final ReadOnlyStringProperty messageProperty() {
+        checkThread();
+        return message.getReadOnlyProperty();
+    }
+
+    @Override
+    public final String getTitle() {
+        checkThread();
+        return title.get();
+    }
+
+    @Override
+    public final ReadOnlyStringProperty titleProperty() {
+        checkThread();
+        return title.getReadOnlyProperty();
+    }
+
+    // ---- reporting from the work ----
+
+    /// Reports how much of the work is done; see
+    /// [#updateProgress(double, double)].
+    protected void updateProgress(long workDone, long max) {
+        updateProgress((double) workDone, (double) max);
+    }
+
+    /// Reports how much of the work is done, from any thread. A
+    /// negative or unusable number means unknown and is reported as -1;
+    /// more done than there is counts as all of it. The progress
+    /// property becomes the share that is done, or -1.
+    protected void updateProgress(double workDone, double max) {
+        double total = Double.isInfinite(max) || Double.isNaN(max) || max < 0 ? -1 : max;
+        double done = Double.isInfinite(workDone) || Double.isNaN(workDone) || workDone < 0 ? -1 : workDone;
+        if (done > total) {
+            done = total;
+        }
+        if (Platform.isFxApplicationThread()) {
+            applyProgress(done, total);
+        } else if (progressUpdate.getAndSet(new ProgressUpdate(done, total)) == null) {
+            // Nothing was waiting, so nothing is on its way to collect this
+            // one. Later updates replace it until it is collected.
+            Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    ProgressUpdate update = progressUpdate.getAndSet(null);
+                    if (update != null) {
+                        applyProgress(update.workDone, update.totalWork);
+                    }
+                }
+            });
+        }
+    }
+
+    private void applyProgress(double done, double total) {
+        totalWork.set(total);
+        workDone.set(done);
+        progress.set(done < 0 || total <= 0 ? -1 : done / total);
+    }
+
+    /// Reports what the work is doing, from any thread.
+    protected void updateMessage(String message) {
+        if (Platform.isFxApplicationThread()) {
+            this.message.set(message);
+        } else if (messageUpdate.offer(message)) {
+            Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    Task.this.message.set(messageUpdate.take());
+                }
+            });
+        }
+    }
+
+    /// Reports the title of the work, from any thread.
+    protected void updateTitle(String title) {
+        if (Platform.isFxApplicationThread()) {
+            this.title.set(title);
+        } else if (titleUpdate.offer(title)) {
+            Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    Task.this.title.set(titleUpdate.take());
+                }
+            });
+        }
+    }
+
+    /// Publishes a partial result, from any thread; the result
+    /// `call()` returns replaces it in the end.
+    protected void updateValue(V value) {
+        if (Platform.isFxApplicationThread()) {
+            this.value.set(value);
+        } else if (valueUpdate.offer(value)) {
+            Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    Task.this.value.set(valueUpdate.take());
+                }
+            });
+        }
+    }
+
+    // ---- handlers ----
+
+    /// The handler of the task being scheduled.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onScheduledProperty() {
+        checkThread();
+        return events.slot(State.SCHEDULED);
+    }
+
+    /// Returns the handler of the task being scheduled.
+    public final EventHandler<WorkerStateEvent> getOnScheduled() {
+        checkThread();
+        return events.get(State.SCHEDULED);
+    }
+
+    /// Sets the handler of the task being scheduled.
+    public final void setOnScheduled(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.SCHEDULED).set(value);
+    }
+
+    /// The handler of the task starting to run.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onRunningProperty() {
+        checkThread();
+        return events.slot(State.RUNNING);
+    }
+
+    /// Returns the handler of the task starting to run.
+    public final EventHandler<WorkerStateEvent> getOnRunning() {
+        checkThread();
+        return events.get(State.RUNNING);
+    }
+
+    /// Sets the handler of the task starting to run.
+    public final void setOnRunning(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.RUNNING).set(value);
+    }
+
+    /// The handler of the task finishing with a result.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onSucceededProperty() {
+        checkThread();
+        return events.slot(State.SUCCEEDED);
+    }
+
+    /// Returns the handler of the task finishing with a result.
+    public final EventHandler<WorkerStateEvent> getOnSucceeded() {
+        checkThread();
+        return events.get(State.SUCCEEDED);
+    }
+
+    /// Sets the handler of the task finishing with a result.
+    public final void setOnSucceeded(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.SUCCEEDED).set(value);
+    }
+
+    /// The handler of the task being cancelled.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onCancelledProperty() {
+        checkThread();
+        return events.slot(State.CANCELLED);
+    }
+
+    /// Returns the handler of the task being cancelled.
+    public final EventHandler<WorkerStateEvent> getOnCancelled() {
+        checkThread();
+        return events.get(State.CANCELLED);
+    }
+
+    /// Sets the handler of the task being cancelled.
+    public final void setOnCancelled(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.CANCELLED).set(value);
+    }
+
+    /// The handler of the task being ended by an exception.
+    public final ObjectProperty<EventHandler<WorkerStateEvent>> onFailedProperty() {
+        checkThread();
+        return events.slot(State.FAILED);
+    }
+
+    /// Returns the handler of the task being ended by an exception.
+    public final EventHandler<WorkerStateEvent> getOnFailed() {
+        checkThread();
+        return events.get(State.FAILED);
+    }
+
+    /// Sets the handler of the task being ended by an exception.
+    public final void setOnFailed(EventHandler<WorkerStateEvent> value) {
+        checkThread();
+        events.slot(State.FAILED).set(value);
+    }
+
+    /// Adds a handler for a type of event and its sub types.
+    public final <T extends Event> void addEventHandler(final EventType<T> eventType,
+            final EventHandler<? super T> eventHandler) {
+        checkThread();
+        events.manager.addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler.
+    public final <T extends Event> void removeEventHandler(final EventType<T> eventType,
+            final EventHandler<? super T> eventHandler) {
+        checkThread();
+        events.manager.removeEventHandler(eventType, eventHandler);
+    }
+
+    /// Adds a filter, which sees an event before the handlers do.
+    public final <T extends Event> void addEventFilter(final EventType<T> eventType,
+            final EventHandler<? super T> eventFilter) {
+        checkThread();
+        events.manager.addEventFilter(eventType, eventFilter);
+    }
+
+    /// Removes a filter.
+    public final <T extends Event> void removeEventFilter(final EventType<T> eventType,
+            final EventHandler<? super T> eventFilter) {
+        checkThread();
+        events.manager.removeEventFilter(eventType, eventFilter);
+    }
+
+    /// Delivers an event to the handlers of the task.
+    public final void fireEvent(Event event) {
+        checkThread();
+        Event.fireEvent(this, event);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        checkThread();
+        return tail.prepend(events.manager);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/concurrent/Worker.java b/maven/javafx-compat/src/main/java/javafx/concurrent/Worker.java
new file mode 100644
index 00000000000..f0fbd7e0fc3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/concurrent/Worker.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.concurrent;
+
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyStringProperty;
+
+/// Work that runs on a background thread and reports on the JavaFX
+/// application thread: its state, its progress and its result are
+/// properties that change only there, so the user interface can bind
+/// to them.
+public interface Worker<V> {
+
+    /// What a worker is doing.
+    enum State {
+        /// Created and not yet started.
+        READY,
+        /// About to run.
+        SCHEDULED,
+        /// Running.
+        RUNNING,
+        /// Finished with a result.
+        SUCCEEDED,
+        /// Cancelled before it finished.
+        CANCELLED,
+        /// Ended by an exception.
+        FAILED
+    }
+
+    /// Returns what the worker is doing.
+    State getState();
+
+    /// What the worker is doing.
+    ReadOnlyObjectProperty<State> stateProperty();
+
+    /// Returns the result of the work, or the latest partial result.
+    V getValue();
+
+    /// The result of the work, or the latest partial result.
+    ReadOnlyObjectProperty<V> valueProperty();
+
+    /// Returns what made the work fail, or `null`.
+    Throwable getException();
+
+    /// What made the work fail, or `null`.
+    ReadOnlyObjectProperty<Throwable> exceptionProperty();
+
+    /// Returns how much of the work is done, -1 when that is unknown.
+    double getWorkDone();
+
+    /// How much of the work is done, -1 when that is unknown.
+    ReadOnlyDoubleProperty workDoneProperty();
+
+    /// Returns how much work there is, -1 when that is unknown.
+    double getTotalWork();
+
+    /// How much work there is, -1 when that is unknown.
+    ReadOnlyDoubleProperty totalWorkProperty();
+
+    /// Returns the share of the work that is done, 0 to 1, or -1 when that is unknown.
+    double getProgress();
+
+    /// The share of the work that is done, 0 to 1, or -1 when that is unknown.
+    ReadOnlyDoubleProperty progressProperty();
+
+    /// Returns whether the worker is scheduled or running.
+    boolean isRunning();
+
+    /// Whether the worker is scheduled or running.
+    ReadOnlyBooleanProperty runningProperty();
+
+    /// Returns a message describing what the worker is doing.
+    String getMessage();
+
+    /// A message describing what the worker is doing.
+    ReadOnlyStringProperty messageProperty();
+
+    /// Returns the title of the work.
+    String getTitle();
+
+    /// The title of the work.
+    ReadOnlyStringProperty titleProperty();
+
+    /// Asks the worker to stop. Returns whether that changed anything:
+    /// a worker that already ended cannot be cancelled.
+    boolean cancel();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/concurrent/WorkerEvents.java b/maven/javafx-compat/src/main/java/javafx/concurrent/WorkerEvents.java
new file mode 100644
index 00000000000..9ad8dc6a40b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/concurrent/WorkerEvents.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.concurrent;
+
+import java.util.ArrayList;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.EventHandler;
+import javafx.event.EventType;
+
+/// The event handlers of a task or service: the ones added by type, and
+/// one property per state for the `setOn...` handlers, which run after
+/// them.
+final class WorkerEvents {
+
+    private static final String[] NAMES = {"onReady", "onScheduled", "onRunning", "onSucceeded", "onCancelled",
+        "onFailed"};
+
+    final EventHandlerManager manager;
+    private final Object owner;
+    private final ArrayList<ObjectProperty<EventHandler<WorkerStateEvent>>> slots =
+            new ArrayList<ObjectProperty<EventHandler<WorkerStateEvent>>>();
+
+    WorkerEvents(Object owner) {
+        this.owner = owner;
+        this.manager = new EventHandlerManager(owner);
+        for (int i = 0; i < NAMES.length; i++) {
+            slots.add(null);
+        }
+    }
+
+    static EventType<WorkerStateEvent> type(Worker.State state) {
+        switch (state) {
+            case READY:
+                return WorkerStateEvent.WORKER_STATE_READY;
+            case SCHEDULED:
+                return WorkerStateEvent.WORKER_STATE_SCHEDULED;
+            case RUNNING:
+                return WorkerStateEvent.WORKER_STATE_RUNNING;
+            case SUCCEEDED:
+                return WorkerStateEvent.WORKER_STATE_SUCCEEDED;
+            case CANCELLED:
+                return WorkerStateEvent.WORKER_STATE_CANCELLED;
+            default:
+                return WorkerStateEvent.WORKER_STATE_FAILED;
+        }
+    }
+
+    ObjectProperty<EventHandler<WorkerStateEvent>> slot(Worker.State state) {
+        int index = state.ordinal();
+        ObjectProperty<EventHandler<WorkerStateEvent>> slot = slots.get(index);
+        if (slot == null) {
+            slot = new SimpleObjectProperty<EventHandler<WorkerStateEvent>>(owner, NAMES[index]);
+            slots.set(index, slot);
+        }
+        return slot;
+    }
+
+    EventHandler<WorkerStateEvent> get(Worker.State state) {
+        ObjectProperty<EventHandler<WorkerStateEvent>> slot = slots.get(state.ordinal());
+        return slot == null ? null : slot.get();
+    }
+
+    /// Delivers the event of the owner entering a state: through the
+    /// dispatch chain to the filters and handlers added by type, then to
+    /// the handler set for the state.
+    void fire(Worker worker, Worker.State state) {
+        WorkerStateEvent event = new WorkerStateEvent(worker, type(state));
+        if (worker instanceof javafx.event.EventTarget) {
+            javafx.event.Event.fireEvent((javafx.event.EventTarget) worker, event);
+        }
+        EventHandler<WorkerStateEvent> handler = get(state);
+        if (handler != null && !event.isConsumed()) {
+            handler.handle(event);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/concurrent/WorkerStateEvent.java b/maven/javafx-compat/src/main/java/javafx/concurrent/WorkerStateEvent.java
new file mode 100644
index 00000000000..ee2febf4a4b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/concurrent/WorkerStateEvent.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.concurrent;
+
+import javafx.event.Event;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// The event of a worker entering a state.
+public class WorkerStateEvent extends Event {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Every worker state event.
+    public static final EventType<WorkerStateEvent> ANY =
+            new EventType<WorkerStateEvent>(Event.ANY, "WORKER_STATE");
+
+    /// The worker became ready again.
+    public static final EventType<WorkerStateEvent> WORKER_STATE_READY =
+            new EventType<WorkerStateEvent>(ANY, "WORKER_STATE_READY");
+
+    /// The worker was scheduled.
+    public static final EventType<WorkerStateEvent> WORKER_STATE_SCHEDULED =
+            new EventType<WorkerStateEvent>(ANY, "WORKER_STATE_SCHEDULED");
+
+    /// The worker started running.
+    public static final EventType<WorkerStateEvent> WORKER_STATE_RUNNING =
+            new EventType<WorkerStateEvent>(ANY, "WORKER_STATE_RUNNING");
+
+    /// The worker finished with a result.
+    public static final EventType<WorkerStateEvent> WORKER_STATE_SUCCEEDED =
+            new EventType<WorkerStateEvent>(ANY, "WORKER_STATE_SUCCEEDED");
+
+    /// The worker was cancelled.
+    public static final EventType<WorkerStateEvent> WORKER_STATE_CANCELLED =
+            new EventType<WorkerStateEvent>(ANY, "WORKER_STATE_CANCELLED");
+
+    /// The worker was ended by an exception.
+    public static final EventType<WorkerStateEvent> WORKER_STATE_FAILED =
+            new EventType<WorkerStateEvent>(ANY, "WORKER_STATE_FAILED");
+
+    /// Creates the event of a worker entering a state.
+    public WorkerStateEvent(Worker worker, EventType<? extends WorkerStateEvent> eventType) {
+        super(worker, worker instanceof EventTarget ? (EventTarget) worker : null, eventType);
+    }
+
+    /// Returns the worker that entered the state.
+    @Override
+    public Worker getSource() {
+        Object worker = super.getSource();
+        return worker instanceof Worker ? (Worker) worker : null;
+    }
+
+    @Override
+    public WorkerStateEvent copyFor(Object newSource, EventTarget newTarget) {
+        super.copyFor(newSource, newTarget);
+        return this;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/concurrent/package-info.java b/maven/javafx-compat/src/main/java/javafx/concurrent/package-info.java
new file mode 100644
index 00000000000..08dea25f1a0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/concurrent/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Work done off the JavaFX application thread whose progress and
+/// result are reported on it: tasks and the services that run them.
+package javafx.concurrent;
diff --git a/maven/javafx-compat/src/main/java/javafx/css/PseudoClass.java b/maven/javafx-compat/src/main/java/javafx/css/PseudoClass.java
new file mode 100644
index 00000000000..ffd0515108d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/css/PseudoClass.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.css;
+
+import java.util.HashMap;
+
+/// A state a node can be in that a style sheet can select on, such as
+/// `hover` or `focused`. There is one instance per name.
+public abstract class PseudoClass {
+
+    private static final HashMap<String, PseudoClass> KNOWN = new HashMap<String, PseudoClass>();
+
+    /// Creates a pseudo-class; applications use [#getPseudoClass(String)].
+    public PseudoClass() {
+    }
+
+    /// Returns the pseudo-class with a name, creating it the first time.
+    public static PseudoClass getPseudoClass(String pseudoClass) {
+        if (pseudoClass == null || pseudoClass.trim().length() == 0) {
+            throw new IllegalArgumentException("pseudoClass cannot be null or empty String");
+        }
+        final String name = pseudoClass.trim();
+        PseudoClass known = KNOWN.get(name);
+        if (known == null) {
+            known = new PseudoClass() {
+                @Override
+                public String getPseudoClassName() {
+                    return name;
+                }
+
+                @Override
+                public String toString() {
+                    return name;
+                }
+            };
+            KNOWN.put(name, known);
+        }
+        return known;
+    }
+
+    /// Returns the name, as written after the colon in a selector.
+    public abstract String getPseudoClassName();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/css/Styleable.java b/maven/javafx-compat/src/main/java/javafx/css/Styleable.java
new file mode 100644
index 00000000000..87a7bb86eff
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/css/Styleable.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.css;
+
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableSet;
+
+/// What a style sheet selector can match against: a type, an id, style
+/// classes, pseudo-class states and a parent.
+///
+/// The per property meta data of JavaFX (`getCssMetaData`) is not part of
+/// this layer; styles reach a node through
+/// `com.codename1.fxcompat.runtime.StyleTarget` instead.
+public interface Styleable {
+
+    /// Returns the name a type selector matches, `Button` for a button.
+    String getTypeSelector();
+
+    /// Returns the id an `#id` selector matches; may be `null`.
+    String getId();
+
+    /// Returns the classes a `.class` selector matches.
+    ObservableList<String> getStyleClass();
+
+    /// Returns the inline style, the text of a `style` attribute.
+    String getStyle();
+
+    /// Returns the parent selectors descend from; `null` at the root.
+    Styleable getStyleableParent();
+
+    /// Returns the pseudo-class states that are on.
+    ObservableSet<PseudoClass> getPseudoClassStates();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/css/package-info.java b/maven/javafx-compat/src/main/java/javafx/css/package-info.java
new file mode 100644
index 00000000000..f6a1b4d6881
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/css/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// What style sheets match against: pseudo-class states and the styleable
+/// contract of a node. The style sheet engine itself is plugged in through
+/// `com.codename1.fxcompat.runtime.StyleEngine`.
+package javafx.css;
diff --git a/maven/javafx-compat/src/main/java/javafx/event/ActionEvent.java b/maven/javafx-compat/src/main/java/javafx/event/ActionEvent.java
new file mode 100644
index 00000000000..a37f71da52f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/ActionEvent.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+/// The event of a control being activated: a button pressed, a menu item
+/// chosen, a text field committed.
+public class ActionEvent extends Event {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The only type of action event.
+    public static final EventType<ActionEvent> ACTION = new EventType<ActionEvent>(Event.ANY, "ACTION");
+
+    /// Every action event.
+    public static final EventType<ActionEvent> ANY = ACTION;
+
+    /// Creates an action event with no source and no target.
+    public ActionEvent() {
+        super(ACTION);
+    }
+
+    /// Creates an action event.
+    public ActionEvent(Object source, EventTarget target) {
+        super(source, target, ACTION);
+    }
+
+    @Override
+    public ActionEvent copyFor(Object newSource, EventTarget newTarget) {
+        if (getClass() == ActionEvent.class) {
+            ActionEvent copy = new ActionEvent(newSource, newTarget);
+            copy.consumed = consumed;
+            return copy;
+        }
+        super.copyFor(newSource, newTarget);
+        return this;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<? extends ActionEvent> getEventType() {
+        return (EventType<? extends ActionEvent>) super.getEventType();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/Event.java b/maven/javafx-compat/src/main/java/javafx/event/Event.java
new file mode 100644
index 00000000000..76c4f326bba
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/Event.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+import java.util.EventObject;
+
+import com.codename1.fxcompat.runtime.EventDispatchChainImpl;
+
+import javafx.beans.NamedArg;
+
+/// Base class of every event: a type, the source the handler sees it coming
+/// from, and the target it is being delivered to.
+///
+/// An event is copied for each object it is delivered through. A subclass
+/// that adds state must override [#copyFor(Object, EventTarget)] to build
+/// the copy with its own constructor; one that does not is re-addressed in
+/// place instead, because this runtime cannot clone an object of a class it
+/// does not know.
+public class Event extends EventObject {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The target of an event that has none.
+    public static final EventTarget NULL_SOURCE_TARGET = new EventTarget() {
+        @Override
+        public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+            return tail;
+        }
+    };
+
+    /// The type every event has.
+    public static final EventType<Event> ANY = EventType.ROOT;
+
+    /// The type of the event.
+    protected EventType<? extends Event> eventType;
+
+    /// The target the event is being delivered to.
+    protected transient EventTarget target;
+
+    /// Whether a handler consumed the event.
+    protected boolean consumed;
+
+    /// Creates an event of a type with no source and no target.
+    public Event(final @NamedArg("eventType") EventType<? extends Event> eventType) {
+        this(null, null, eventType);
+    }
+
+    /// Creates an event. A missing source or target is replaced by
+    /// [#NULL_SOURCE_TARGET].
+    public Event(final @NamedArg("source") Object source, final @NamedArg("target") EventTarget target,
+            final @NamedArg("eventType") EventType<? extends Event> eventType) {
+        super((source != null) ? source : NULL_SOURCE_TARGET);
+        this.target = (target != null) ? target : NULL_SOURCE_TARGET;
+        this.eventType = eventType;
+    }
+
+    /// Returns the target the event is being delivered to.
+    public EventTarget getTarget() {
+        return target;
+    }
+
+    /// Returns the type of the event.
+    public EventType<? extends Event> getEventType() {
+        return eventType;
+    }
+
+    /// Returns this event addressed to a new source and target. A missing
+    /// source or target is replaced by [#NULL_SOURCE_TARGET].
+    public Event copyFor(final Object newSource, final EventTarget newTarget) {
+        Object resolvedSource = (newSource != null) ? newSource : NULL_SOURCE_TARGET;
+        EventTarget resolvedTarget = (newTarget != null) ? newTarget : NULL_SOURCE_TARGET;
+        if (getClass() == Event.class) {
+            Event copy = new Event(resolvedSource, resolvedTarget, eventType);
+            copy.consumed = consumed;
+            return copy;
+        }
+        this.source = resolvedSource;
+        this.target = resolvedTarget;
+        return this;
+    }
+
+    /// Returns whether a handler consumed the event.
+    public boolean isConsumed() {
+        return consumed;
+    }
+
+    /// Marks the event consumed, which stops its delivery.
+    public void consume() {
+        consumed = true;
+    }
+
+    /// Delivers an event to a target, through the dispatch chain the
+    /// target builds.
+    public static void fireEvent(EventTarget eventTarget, Event event) {
+        if (eventTarget == null) {
+            throw new NullPointerException("Event target must not be null!");
+        }
+        if (event == null) {
+            throw new NullPointerException("Event must not be null!");
+        }
+        Event addressed = event.getTarget() == eventTarget ? event : event.copyFor(eventTarget, eventTarget);
+        EventDispatchChain chain = eventTarget.buildEventDispatchChain(new EventDispatchChainImpl());
+        chain.dispatchEvent(addressed);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/EventDispatchChain.java b/maven/javafx-compat/src/main/java/javafx/event/EventDispatchChain.java
new file mode 100644
index 00000000000..af374820702
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/EventDispatchChain.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+/// The ordered dispatchers an event travels through.
+public interface EventDispatchChain {
+
+    /// Adds a dispatcher after the others and returns the resulting chain.
+    EventDispatchChain append(EventDispatcher eventDispatcher);
+
+    /// Adds a dispatcher before the others and returns the resulting chain.
+    EventDispatchChain prepend(EventDispatcher eventDispatcher);
+
+    /// Sends an event through the chain, starting at its first dispatcher.
+    /// Returns the resulting event, or `null` when it was consumed.
+    Event dispatchEvent(Event event);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/EventDispatcher.java b/maven/javafx-compat/src/main/java/javafx/event/EventDispatcher.java
new file mode 100644
index 00000000000..18cda384320
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/EventDispatcher.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+/// One stop on the path of an event. It may handle the event, pass it on
+/// through the rest of the chain, replace it or swallow it.
+public interface EventDispatcher {
+
+    /// Handles an event and returns the event to continue with, or `null`
+    /// when it was consumed. To let the event travel on, the dispatcher
+    /// passes it to the tail.
+    Event dispatchEvent(Event event, EventDispatchChain tail);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/EventHandler.java b/maven/javafx-compat/src/main/java/javafx/event/EventHandler.java
new file mode 100644
index 00000000000..442be74b68e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/EventHandler.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+import java.util.EventListener;
+
+/// Receives the events of one kind.
+@FunctionalInterface
+public interface EventHandler<T extends Event> extends EventListener {
+
+    /// Called with an event.
+    void handle(T event);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/EventTarget.java b/maven/javafx-compat/src/main/java/javafx/event/EventTarget.java
new file mode 100644
index 00000000000..356ba293f8c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/EventTarget.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+/// Something events can be delivered to. It decides the path an event takes
+/// by adding its dispatchers to the chain.
+public interface EventTarget {
+
+    /// Adds this target's dispatchers in front of a chain and returns the
+    /// chain to deliver through.
+    EventDispatchChain buildEventDispatchChain(EventDispatchChain tail);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/EventType.java b/maven/javafx-compat/src/main/java/javafx/event/EventType.java
new file mode 100644
index 00000000000..284db95a5b4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/EventType.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+import java.io.Serializable;
+
+/// The kind of an event. Types form a tree under [#ROOT]: a handler
+/// registered for a type also receives the events of its sub types.
+public final class EventType<T extends Event> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The type every other type descends from.
+    public static final EventType<Event> ROOT = new EventType<Event>("EVENT", null);
+
+    private final EventType<? super T> superType;
+    private final String name;
+
+    /// Creates an unnamed type directly under [#ROOT].
+    ///
+    /// #### Deprecated
+    ///
+    /// A type without a name cannot be told apart in a log; name it.
+    @Deprecated
+    public EventType() {
+        this(ROOT, null);
+    }
+
+    /// Creates a named type directly under [#ROOT].
+    public EventType(final String name) {
+        this(ROOT, name);
+    }
+
+    /// Creates an unnamed sub type.
+    public EventType(final EventType<? super T> superType) {
+        this(superType, null);
+    }
+
+    /// Creates a named sub type.
+    public EventType(final EventType<? super T> superType, final String name) {
+        if (superType == null) {
+            throw new NullPointerException("Event super type must not be null!");
+        }
+        this.superType = superType;
+        this.name = name;
+    }
+
+    private EventType(final String name, final EventType<? super T> superType) {
+        this.superType = superType;
+        this.name = name;
+    }
+
+    /// Returns the type this one is a sub type of; `null` for [#ROOT].
+    public final EventType<? super T> getSuperType() {
+        return superType;
+    }
+
+    /// Returns the name; `null` for an unnamed type.
+    public final String getName() {
+        return name;
+    }
+
+    /// Returns the name, or the default text for an unnamed type.
+    @Override
+    public String toString() {
+        return (name != null) ? name : super.toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/WeakEventHandler.java b/maven/javafx-compat/src/main/java/javafx/event/WeakEventHandler.java
new file mode 100644
index 00000000000..70e97605eb2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/WeakEventHandler.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.event;
+
+import java.lang.ref.WeakReference;
+
+/// An [EventHandler] that forwards to another one without keeping it alive.
+/// Whoever creates it must hold the wrapped handler.
+public final class WeakEventHandler<T extends Event> implements EventHandler<T> {
+
+    private final WeakReference ref;
+
+    /// Wraps a handler.
+    public WeakEventHandler(final @javafx.beans.NamedArg("eventHandler") EventHandler<T> eventHandler) {
+        this.ref = new WeakReference(eventHandler);
+    }
+
+    /// Returns whether the wrapped handler has been garbage collected.
+    public boolean wasGarbageCollected() {
+        return ref.get() == null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void handle(final T event) {
+        Object handler = ref.get();
+        if (handler instanceof EventHandler) {
+            ((EventHandler<T>) handler).handle(event);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/event/package-info.java b/maven/javafx-compat/src/main/java/javafx/event/package-info.java
new file mode 100644
index 00000000000..ee1bb3c54b0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/event/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Events and their delivery: event types arranged in a hierarchy, the
+/// handlers that receive events and the dispatch chain an event travels
+/// along to reach its target.
+package javafx.event;
diff --git a/maven/javafx-compat/src/main/java/javafx/fxml/FXML.java b/maven/javafx-compat/src/main/java/javafx/fxml/FXML.java
new file mode 100644
index 00000000000..b97f0dc1f5d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/fxml/FXML.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.fxml;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/// Marks a field or a method of a controller that an FXML document may
+/// reach although it is not public: a field to receive the element with
+/// its name as `fx:id`, a method to be called as `onAction="#name"`.
+///
+/// Nothing looks the annotation up while the application runs. It is kept
+/// in the class file for the build, which generates the code that sets the
+/// field and calls the method directly and makes the member accessible to
+/// that code.
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD, ElementType.METHOD})
+public @interface FXML {
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/fxml/FXMLLoader.java b/maven/javafx-compat/src/main/java/javafx/fxml/FXMLLoader.java
new file mode 100644
index 00000000000..71cb231a5d8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/fxml/FXMLLoader.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.fxml;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.ResourceBundle;
+
+import com.codename1.fxcompat.runtime.FxmlContext;
+import com.codename1.fxcompat.runtime.FxmlDispatch;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableMap;
+import javafx.util.Callback;
+
+/// Loads the object tree an FXML document describes.
+///
+/// The document is not read here. The build compiled it into a class, and
+/// loading means finding that class for the location and running it; see
+/// the package description. A location is matched by its path: a `cn1res:`
+/// address by the whole path, any other address -- what `getResource`
+/// answers on a desktop -- by the longest tail of its path that is the
+/// resource path of a compiled document.
+///
+/// Not provided: builder factories, script handlers and the character set
+/// and class loader settings, none of which mean anything for a document
+/// that is compiled ahead of time.
+public class FXMLLoader {
+
+    private URL location;
+    private ResourceBundle resources;
+    private Object root;
+    private Object controller;
+    private Callback<Class<?>, Object> controllerFactory;
+    private final ObservableMap<String, Object> namespace = FXCollections
+            .observableMap(new HashMap<String, Object>());
+
+    /// Creates a loader without a location.
+    public FXMLLoader() {
+        this(null, null);
+    }
+
+    /// Creates a loader for the document at a location.
+    public FXMLLoader(URL location) {
+        this(location, null);
+    }
+
+    /// Creates a loader for the document at a location, with the bundle
+    /// its `%key` strings come from.
+    public FXMLLoader(URL location, ResourceBundle resources) {
+        this.location = location;
+        this.resources = resources;
+    }
+
+    /// Returns the location of the document.
+    public URL getLocation() {
+        return location;
+    }
+
+    /// Sets the location of the document.
+    public void setLocation(URL location) {
+        this.location = location;
+    }
+
+    /// Returns the bundle `%key` strings are read from.
+    public ResourceBundle getResources() {
+        return resources;
+    }
+
+    /// Sets the bundle `%key` strings are read from.
+    public void setResources(ResourceBundle resources) {
+        this.resources = resources;
+    }
+
+    /// Returns the map of the objects the document named with `fx:id`,
+    /// with the controller under `controller`.
+    public ObservableMap<String, Object> getNamespace() {
+        return namespace;
+    }
+
+    /// Returns the root of the loaded tree, or the one that was set.
+    @SuppressWarnings("unchecked")
+    public <T> T getRoot() {
+        return (T) root;
+    }
+
+    /// Sets the object a document whose root element is `<fx:root>` builds
+    /// on.
+    public void setRoot(Object root) {
+        this.root = root;
+    }
+
+    /// Returns the controller of the document.
+    @SuppressWarnings("unchecked")
+    public <T> T getController() {
+        return (T) controller;
+    }
+
+    /// Sets the controller, for a document that names none with
+    /// `fx:controller`.
+    public void setController(Object controller) {
+        this.controller = controller;
+        if (controller == null) {
+            namespace.remove("controller");
+        } else {
+            namespace.put("controller", controller);
+        }
+    }
+
+    /// Returns what creates the controllers.
+    public Callback<Class<?>, Object> getControllerFactory() {
+        return controllerFactory;
+    }
+
+    /// Sets what creates the controller of this document and of the ones
+    /// it includes; without one the no-argument constructor is used.
+    public void setControllerFactory(Callback<Class<?>, Object> controllerFactory) {
+        this.controllerFactory = controllerFactory;
+    }
+
+    /// Loads the document at the location of this loader.
+    @SuppressWarnings("unchecked")
+    public <T> T load() throws IOException {
+        if (location == null) {
+            throw new IllegalStateException("Location is not set.");
+        }
+        FxmlDispatch dispatch = FxmlDispatch.current();
+        String path = cn1Find(dispatch, location.toString());
+        if (path == null) {
+            throw new LoadException("No compiled FXML document for " + location
+                    + ". FXML is compiled by the build from the .fxml files among the application's desktop"
+                    + " resources; a document that is not there when the application is built cannot be loaded.");
+        }
+        FxmlContext context = new FxmlContext(dispatch, path, location, resources, controllerFactory, namespace,
+                root, controller);
+        Object loaded;
+        try {
+            loaded = dispatch.load(path, context);
+        } catch (IOException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            throw new LoadException(path + ": " + e, e);
+        } catch (Exception e) {
+            throw new LoadException(path + ": " + e, e);
+        }
+        controller = context.controller();
+        root = loaded;
+        return (T) loaded;
+    }
+
+    /// Loads the document at a location.
+    public static <T> T load(URL location) throws IOException {
+        return load(location, null);
+    }
+
+    /// Loads the document at a location, with the bundle its `%key`
+    /// strings come from.
+    public static <T> T load(URL location, ResourceBundle resources) throws IOException {
+        if (location == null) {
+            throw new NullPointerException("Location is required.");
+        }
+        return new FXMLLoader(location, resources).<T>load();
+    }
+
+    /// The resource path of the compiled document an address names, or
+    /// `null`.
+    private static String cn1Find(FxmlDispatch dispatch, String address) {
+        String path = address;
+        int bang = path.lastIndexOf("!/");
+        if (bang >= 0) {
+            path = path.substring(bang + 2);
+        } else {
+            int colon = path.indexOf(':');
+            int slash = path.indexOf('/');
+            if (colon > 0 && (slash < 0 || colon < slash)) {
+                path = path.substring(colon + 1);
+            }
+        }
+        while (true) {
+            int start = 0;
+            while (start < path.length() && path.charAt(start) == '/') {
+                start++;
+            }
+            path = path.substring(start);
+            if (path.length() == 0) {
+                return null;
+            }
+            if (dispatch.has(path)) {
+                return path;
+            }
+            int next = path.indexOf('/');
+            if (next < 0) {
+                return null;
+            }
+            path = path.substring(next);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/fxml/Initializable.java b/maven/javafx-compat/src/main/java/javafx/fxml/Initializable.java
new file mode 100644
index 00000000000..1734cfa5396
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/fxml/Initializable.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.fxml;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+/// A controller that is told when its document has been loaded. A
+/// controller can declare a method `initialize()` without arguments
+/// instead, which needs no interface.
+public interface Initializable {
+
+    /// Called once every `fx:id` field has been set.
+    ///
+    /// #### Parameters
+    ///
+    /// - `location`: where the document was loaded from, or `null`
+    ///
+    /// - `resources`: the bundle its `%key` strings came from, or `null`
+    void initialize(URL location, ResourceBundle resources);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/fxml/LoadException.java b/maven/javafx-compat/src/main/java/javafx/fxml/LoadException.java
new file mode 100644
index 00000000000..13d81fa4fa5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/fxml/LoadException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.fxml;
+
+import java.io.IOException;
+
+/// Thrown when an FXML document cannot be loaded.
+public class LoadException extends IOException {
+
+    /// Creates an exception without a message.
+    public LoadException() {
+        super();
+    }
+
+    /// Creates an exception with a message.
+    public LoadException(String message) {
+        super(message);
+    }
+
+    /// Creates an exception with a cause.
+    public LoadException(Throwable cause) {
+        super(cause == null ? null : cause.toString());
+        if (cause != null) {
+            initCause(cause);
+        }
+    }
+
+    /// Creates an exception with a message and a cause.
+    public LoadException(String message, Throwable cause) {
+        super(message);
+        if (cause != null) {
+            initCause(cause);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/fxml/package-info.java b/maven/javafx-compat/src/main/java/javafx/fxml/package-info.java
new file mode 100644
index 00000000000..484333b28fb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/fxml/package-info.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Loading a user interface from an FXML document.
+///
+/// #### How it works here
+///
+/// A desktop `FXMLLoader` parses the document while the application runs
+/// and builds the scene graph by reflection. A device has neither an XML
+/// parser to spare nor reflection, so the build does that work: every
+/// `.fxml` file among the application's desktop resources is compiled into
+/// a Java class that builds the same tree with plain constructors and
+/// setters, and [javafx.fxml.FXMLLoader] only finds the class for the
+/// location it is given and runs it. What a controller's
+/// [javafx.fxml.FXML] members need -- setting a private field, calling a
+/// private handler -- is generated too, as direct code.
+///
+/// The consequence to know: a document is fixed when the application is
+/// built. One that is fetched or written at run time cannot be loaded, and
+/// loading it fails with a [javafx.fxml.LoadException] that says so.
+package javafx.fxml;
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/BoundingBox.java b/maven/javafx-compat/src/main/java/javafx/geometry/BoundingBox.java
new file mode 100644
index 00000000000..88da642b5f8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/BoundingBox.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+import javafx.beans.NamedArg;
+
+/// Bounds given directly by a corner and a size.
+public class BoundingBox extends Bounds {
+
+    /// Creates a box in space.
+    public BoundingBox(@NamedArg("minX") double minX, @NamedArg("minY") double minY, @NamedArg("minZ") double minZ,
+            @NamedArg("width") double width, @NamedArg("height") double height, @NamedArg("depth") double depth) {
+        super(minX, minY, minZ, width, height, depth);
+    }
+
+    /// Creates a flat box.
+    public BoundingBox(@NamedArg("minX") double minX, @NamedArg("minY") double minY,
+            @NamedArg("width") double width, @NamedArg("height") double height) {
+        super(minX, minY, 0, width, height, 0);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return getMaxX() < getMinX() || getMaxY() < getMinY() || getMaxZ() < getMinZ();
+    }
+
+    @Override
+    public boolean contains(Point2D p) {
+        if (p == null) {
+            return false;
+        }
+        return contains(p.getX(), p.getY(), 0.0f);
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        return contains(x, y, 0.0f);
+    }
+
+    @Override
+    public boolean contains(double x, double y, double z) {
+        if (isEmpty()) {
+            return false;
+        }
+        return x >= getMinX() && x <= getMaxX() && y >= getMinY() && y <= getMaxY() && z >= getMinZ()
+                && z <= getMaxZ();
+    }
+
+    @Override
+    public boolean contains(Bounds b) {
+        if (b == null || b.isEmpty()) {
+            return false;
+        }
+        return contains(b.getMinX(), b.getMinY(), b.getMinZ(), b.getWidth(), b.getHeight(), b.getDepth());
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        return contains(x, y) && contains(x + w, y + h);
+    }
+
+    @Override
+    public boolean contains(double x, double y, double z, double w, double h, double d) {
+        return contains(x, y, z) && contains(x + w, y + h, z + d);
+    }
+
+    @Override
+    public boolean intersects(Bounds b) {
+        if (b == null || b.isEmpty()) {
+            return false;
+        }
+        return intersects(b.getMinX(), b.getMinY(), b.getMinZ(), b.getWidth(), b.getHeight(), b.getDepth());
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        return intersects(x, y, 0, w, h, 0);
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double z, double w, double h, double d) {
+        if (isEmpty() || w < 0 || h < 0 || d < 0) {
+            return false;
+        }
+        return x + w >= getMinX() && y + h >= getMinY() && z + d >= getMinZ() && x <= getMaxX() && y <= getMaxY()
+                && z <= getMaxZ();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof BoundingBox) {
+            BoundingBox other = (BoundingBox) obj;
+            return Geometry.same(getMinX(), other.getMinX()) && Geometry.same(getMinY(), other.getMinY())
+                    && Geometry.same(getMinZ(), other.getMinZ()) && Geometry.same(getWidth(), other.getWidth())
+                    && Geometry.same(getHeight(), other.getHeight()) && Geometry.same(getDepth(), other.getDepth());
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = Geometry.hash(Geometry.hash(Geometry.hash(7, getMinX()), getMinY()), getMinZ());
+        return Geometry.hash(Geometry.hash(Geometry.hash(hash, getWidth()), getHeight()), getDepth());
+    }
+
+    @Override
+    public String toString() {
+        return "BoundingBox [minX:" + getMinX() + ", minY:" + getMinY() + ", minZ:" + getMinZ() + ", width:"
+                + getWidth() + ", height:" + getHeight() + ", depth:" + getDepth() + ", maxX:" + getMaxX()
+                + ", maxY:" + getMaxY() + ", maxZ:" + getMaxZ() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Bounds.java b/maven/javafx-compat/src/main/java/javafx/geometry/Bounds.java
new file mode 100644
index 00000000000..edb7b4715ae
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Bounds.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// The immutable box around a node or any other object: a corner, a size
+/// and, for three dimensional content, a depth.
+public abstract class Bounds {
+
+    private final double minX;
+    private final double minY;
+    private final double minZ;
+    private final double width;
+    private final double height;
+    private final double depth;
+    private final double maxX;
+    private final double maxY;
+    private final double maxZ;
+
+    /// Creates bounds from a corner and a size.
+    protected Bounds(double minX, double minY, double minZ, double width, double height, double depth) {
+        this.minX = minX;
+        this.minY = minY;
+        this.minZ = minZ;
+        this.width = width;
+        this.height = height;
+        this.depth = depth;
+        this.maxX = minX + width;
+        this.maxY = minY + height;
+        this.maxZ = minZ + depth;
+    }
+
+    /// Returns the left edge.
+    public final double getMinX() {
+        return minX;
+    }
+
+    /// Returns the top edge.
+    public final double getMinY() {
+        return minY;
+    }
+
+    /// Returns the near edge.
+    public final double getMinZ() {
+        return minZ;
+    }
+
+    /// Returns the width.
+    public final double getWidth() {
+        return width;
+    }
+
+    /// Returns the height.
+    public final double getHeight() {
+        return height;
+    }
+
+    /// Returns the depth.
+    public final double getDepth() {
+        return depth;
+    }
+
+    /// Returns the right edge.
+    public final double getMaxX() {
+        return maxX;
+    }
+
+    /// Returns the bottom edge.
+    public final double getMaxY() {
+        return maxY;
+    }
+
+    /// Returns the far edge.
+    public final double getMaxZ() {
+        return maxZ;
+    }
+
+    /// Returns the horizontal center.
+    public final double getCenterX() {
+        return (getMaxX() + getMinX()) * 0.5;
+    }
+
+    /// Returns the vertical center.
+    public final double getCenterY() {
+        return (getMaxY() + getMinY()) * 0.5;
+    }
+
+    /// Returns the center in depth.
+    public final double getCenterZ() {
+        return (getMaxZ() + getMinZ()) * 0.5;
+    }
+
+    /// Returns whether a size is negative, which marks bounds of nothing.
+    public abstract boolean isEmpty();
+
+    /// Returns whether a point lies inside or on the edge.
+    public abstract boolean contains(Point2D p);
+
+    /// Returns whether a location lies inside or on the edge.
+    public abstract boolean contains(double x, double y);
+
+    /// Returns whether a location in space lies inside or on the edge.
+    public abstract boolean contains(double x, double y, double z);
+
+    /// Returns whether other bounds lie entirely inside these.
+    public abstract boolean contains(Bounds b);
+
+    /// Returns whether a rectangle lies entirely inside these bounds.
+    public abstract boolean contains(double x, double y, double w, double h);
+
+    /// Returns whether a box lies entirely inside these bounds.
+    public abstract boolean contains(double x, double y, double z, double w, double h, double d);
+
+    /// Returns whether other bounds overlap or touch these.
+    public abstract boolean intersects(Bounds b);
+
+    /// Returns whether a rectangle overlaps or touches these bounds.
+    public abstract boolean intersects(double x, double y, double w, double h);
+
+    /// Returns whether a box overlaps or touches these bounds.
+    public abstract boolean intersects(double x, double y, double z, double w, double h, double d);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Dimension2D.java b/maven/javafx-compat/src/main/java/javafx/geometry/Dimension2D.java
new file mode 100644
index 00000000000..6aa226f5d0a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Dimension2D.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+import javafx.beans.NamedArg;
+
+/// An immutable width and height.
+public class Dimension2D {
+
+    private final double width;
+    private final double height;
+
+    /// Creates a size.
+    public Dimension2D(@NamedArg("width") double width, @NamedArg("height") double height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    /// Returns the width.
+    public final double getWidth() {
+        return width;
+    }
+
+    /// Returns the height.
+    public final double getHeight() {
+        return height;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Dimension2D) {
+            Dimension2D other = (Dimension2D) obj;
+            return Geometry.same(getWidth(), other.getWidth()) && Geometry.same(getHeight(), other.getHeight());
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Geometry.hash(Geometry.hash(7, getWidth()), getHeight());
+    }
+
+    @Override
+    public String toString() {
+        return "Dimension2D [width = " + getWidth() + ", height = " + getHeight() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Geometry.java b/maven/javafx-compat/src/main/java/javafx/geometry/Geometry.java
new file mode 100644
index 00000000000..21b246d0017
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Geometry.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// Value comparison and hashing of coordinates, shared by the geometry
+/// classes. Coordinates are equal when `==` says so, as in JavaFX: positive
+/// and negative zero are the same coordinate and NaN equals nothing.
+final class Geometry {
+
+    private Geometry() {
+    }
+
+    static boolean same(double first, double second) {
+        return first == second;
+    }
+
+    static int hash(int seed, double value) {
+        // Negative zero equals zero, so both must hash alike.
+        long bits = Double.doubleToLongBits(value == 0.0 ? 0.0 : value);
+        return 37 * seed + (int) (bits ^ (bits >>> 32));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/HPos.java b/maven/javafx-compat/src/main/java/javafx/geometry/HPos.java
new file mode 100644
index 00000000000..3aa355e1162
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/HPos.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// A horizontal position.
+public enum HPos {
+    /// At the left.
+    LEFT,
+    /// In the middle.
+    CENTER,
+    /// At the right.
+    RIGHT
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/HorizontalDirection.java b/maven/javafx-compat/src/main/java/javafx/geometry/HorizontalDirection.java
new file mode 100644
index 00000000000..62f776f6ad6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/HorizontalDirection.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// A direction along the horizontal axis.
+public enum HorizontalDirection {
+    /// Towards the left.
+    LEFT,
+    /// Towards the right.
+    RIGHT
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Insets.java b/maven/javafx-compat/src/main/java/javafx/geometry/Insets.java
new file mode 100644
index 00000000000..74d21c25b9a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Insets.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+import javafx.beans.NamedArg;
+
+/// The four distances inside the edges of a rectangle.
+public class Insets {
+
+    /// No distance on any side.
+    public static final Insets EMPTY = new Insets(0, 0, 0, 0);
+
+    private final double top;
+    private final double right;
+    private final double bottom;
+    private final double left;
+
+    /// Creates insets with a distance for each side.
+    public Insets(@NamedArg("top") double top, @NamedArg("right") double right, @NamedArg("bottom") double bottom,
+            @NamedArg("left") double left) {
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.left = left;
+    }
+
+    /// Creates insets with the same distance on every side.
+    public Insets(@NamedArg("topRightBottomLeft") double topRightBottomLeft) {
+        this(topRightBottomLeft, topRightBottomLeft, topRightBottomLeft, topRightBottomLeft);
+    }
+
+    /// Returns the distance at the top.
+    public final double getTop() {
+        return top;
+    }
+
+    /// Returns the distance at the right.
+    public final double getRight() {
+        return right;
+    }
+
+    /// Returns the distance at the bottom.
+    public final double getBottom() {
+        return bottom;
+    }
+
+    /// Returns the distance at the left.
+    public final double getLeft() {
+        return left;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Insets) {
+            Insets other = (Insets) obj;
+            return Geometry.same(top, other.top) && Geometry.same(right, other.right)
+                    && Geometry.same(bottom, other.bottom) && Geometry.same(left, other.left);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Geometry.hash(Geometry.hash(Geometry.hash(Geometry.hash(17, top), right), bottom), left);
+    }
+
+    @Override
+    public String toString() {
+        return "Insets [top=" + top + ", right=" + right + ", bottom=" + bottom + ", left=" + left + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/NodeOrientation.java b/maven/javafx-compat/src/main/java/javafx/geometry/NodeOrientation.java
new file mode 100644
index 00000000000..29df9bd8cad
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/NodeOrientation.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// The reading direction a node lays its content out in.
+public enum NodeOrientation {
+    /// Content starts at the left.
+    LEFT_TO_RIGHT,
+    /// Content starts at the right.
+    RIGHT_TO_LEFT,
+    /// The direction of the parent.
+    INHERIT
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Orientation.java b/maven/javafx-compat/src/main/java/javafx/geometry/Orientation.java
new file mode 100644
index 00000000000..a5c1a603f50
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Orientation.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// The direction something is laid out in.
+public enum Orientation {
+    /// Left to right.
+    HORIZONTAL,
+    /// Top to bottom.
+    VERTICAL
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Point2D.java b/maven/javafx-compat/src/main/java/javafx/geometry/Point2D.java
new file mode 100644
index 00000000000..fade19a981d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Point2D.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+import com.codename1.util.MathUtil;
+
+import javafx.beans.NamedArg;
+
+/// An immutable point in the plane, also used as a vector.
+public class Point2D {
+
+    /// The origin.
+    public static final Point2D ZERO = new Point2D(0.0, 0.0);
+
+    private final double x;
+    private final double y;
+
+    /// Creates a point.
+    public Point2D(@NamedArg("x") double x, @NamedArg("y") double y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /// Returns the horizontal coordinate.
+    public final double getX() {
+        return x;
+    }
+
+    /// Returns the vertical coordinate.
+    public final double getY() {
+        return y;
+    }
+
+    /// Returns the distance to a location.
+    public double distance(double x1, double y1) {
+        double a = getX() - x1;
+        double b = getY() - y1;
+        return Math.sqrt(a * a + b * b);
+    }
+
+    /// Returns the distance to another point.
+    public double distance(Point2D point) {
+        return distance(point.getX(), point.getY());
+    }
+
+    /// Returns this point moved by an offset.
+    public Point2D add(double x, double y) {
+        return new Point2D(getX() + x, getY() + y);
+    }
+
+    /// Returns the sum of this vector and another.
+    public Point2D add(Point2D point) {
+        return add(point.getX(), point.getY());
+    }
+
+    /// Returns this point moved back by an offset.
+    public Point2D subtract(double x, double y) {
+        return new Point2D(getX() - x, getY() - y);
+    }
+
+    /// Returns this vector less another.
+    public Point2D subtract(Point2D point) {
+        return subtract(point.getX(), point.getY());
+    }
+
+    /// Returns this vector scaled by a factor.
+    public Point2D multiply(double factor) {
+        return new Point2D(getX() * factor, getY() * factor);
+    }
+
+    /// Returns the vector of the same direction and length one; the zero
+    /// vector for the zero vector.
+    public Point2D normalize() {
+        final double mag = magnitude();
+        if (mag == 0.0) {
+            return new Point2D(0.0, 0.0);
+        }
+        return new Point2D(getX() / mag, getY() / mag);
+    }
+
+    /// Returns the point halfway to a location.
+    public Point2D midpoint(double x, double y) {
+        return new Point2D(x + (getX() - x) / 2.0, y + (getY() - y) / 2.0);
+    }
+
+    /// Returns the point halfway to another point.
+    public Point2D midpoint(Point2D point) {
+        return midpoint(point.getX(), point.getY());
+    }
+
+    /// Returns the angle in degrees, from 0 to 180, between this vector and
+    /// the vector to a location.
+    public double angle(double x, double y) {
+        final double ax = getX();
+        final double ay = getY();
+        final double delta = (ax * x + ay * y) / Math.sqrt((ax * ax + ay * ay) * (x * x + y * y));
+        if (delta > 1.0) {
+            return 0.0;
+        }
+        if (delta < -1.0) {
+            return 180.0;
+        }
+        return Math.toDegrees(MathUtil.acos(delta));
+    }
+
+    /// Returns the angle in degrees between this vector and another.
+    public double angle(Point2D point) {
+        return angle(point.getX(), point.getY());
+    }
+
+    /// Returns the angle in degrees at this point between the directions
+    /// to two others.
+    public double angle(Point2D p1, Point2D p2) {
+        final double x = getX();
+        final double y = getY();
+        final double ax = p1.getX() - x;
+        final double ay = p1.getY() - y;
+        final double bx = p2.getX() - x;
+        final double by = p2.getY() - y;
+        final double delta = (ax * bx + ay * by) / Math.sqrt((ax * ax + ay * ay) * (bx * bx + by * by));
+        if (delta > 1.0) {
+            return 0.0;
+        }
+        if (delta < -1.0) {
+            return 180.0;
+        }
+        return Math.toDegrees(MathUtil.acos(delta));
+    }
+
+    /// Returns the length of this vector.
+    public double magnitude() {
+        final double x = getX();
+        final double y = getY();
+        return Math.sqrt(x * x + y * y);
+    }
+
+    /// Returns the dot product of this vector and another.
+    public double dotProduct(double x, double y) {
+        return getX() * x + getY() * y;
+    }
+
+    /// Returns the dot product of this vector and another.
+    public double dotProduct(Point2D vector) {
+        return dotProduct(vector.getX(), vector.getY());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Point2D) {
+            Point2D other = (Point2D) obj;
+            return Geometry.same(getX(), other.getX()) && Geometry.same(getY(), other.getY());
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Geometry.hash(Geometry.hash(7, getX()), getY());
+    }
+
+    @Override
+    public String toString() {
+        return "Point2D [x = " + getX() + ", y = " + getY() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Pos.java b/maven/javafx-compat/src/main/java/javafx/geometry/Pos.java
new file mode 100644
index 00000000000..d62753a71f7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Pos.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// A vertical and a horizontal position combined.
+public enum Pos {
+    /// Top, left.
+    TOP_LEFT(VPos.TOP, HPos.LEFT),
+    /// Top, centered horizontally.
+    TOP_CENTER(VPos.TOP, HPos.CENTER),
+    /// Top, right.
+    TOP_RIGHT(VPos.TOP, HPos.RIGHT),
+    /// Centered vertically, left.
+    CENTER_LEFT(VPos.CENTER, HPos.LEFT),
+    /// Centered both ways.
+    CENTER(VPos.CENTER, HPos.CENTER),
+    /// Centered vertically, right.
+    CENTER_RIGHT(VPos.CENTER, HPos.RIGHT),
+    /// Bottom, left.
+    BOTTOM_LEFT(VPos.BOTTOM, HPos.LEFT),
+    /// Bottom, centered horizontally.
+    BOTTOM_CENTER(VPos.BOTTOM, HPos.CENTER),
+    /// Bottom, right.
+    BOTTOM_RIGHT(VPos.BOTTOM, HPos.RIGHT),
+    /// On the baseline, left.
+    BASELINE_LEFT(VPos.BASELINE, HPos.LEFT),
+    /// On the baseline, centered horizontally.
+    BASELINE_CENTER(VPos.BASELINE, HPos.CENTER),
+    /// On the baseline, right.
+    BASELINE_RIGHT(VPos.BASELINE, HPos.RIGHT);
+
+    private final VPos vpos;
+    private final HPos hpos;
+
+    Pos(VPos vpos, HPos hpos) {
+        this.vpos = vpos;
+        this.hpos = hpos;
+    }
+
+    /// Returns the vertical part.
+    public VPos getVpos() {
+        return vpos;
+    }
+
+    /// Returns the horizontal part.
+    public HPos getHpos() {
+        return hpos;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Rectangle2D.java b/maven/javafx-compat/src/main/java/javafx/geometry/Rectangle2D.java
new file mode 100644
index 00000000000..2447487c6e8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Rectangle2D.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+import javafx.beans.NamedArg;
+
+/// An immutable rectangle given by its upper left corner and its size.
+public class Rectangle2D {
+
+    /// The rectangle at the origin with no size.
+    public static final Rectangle2D EMPTY = new Rectangle2D(0, 0, 0, 0);
+
+    private final double minX;
+    private final double minY;
+    private final double width;
+    private final double height;
+    private final double maxX;
+    private final double maxY;
+
+    /// Creates a rectangle.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the width or the height is negative
+    public Rectangle2D(@NamedArg("minX") double minX, @NamedArg("minY") double minY,
+            @NamedArg("width") double width, @NamedArg("height") double height) {
+        if (width < 0 || height < 0) {
+            throw new IllegalArgumentException("Both width and height must be >= 0");
+        }
+        this.minX = minX;
+        this.minY = minY;
+        this.width = width;
+        this.height = height;
+        this.maxX = minX + width;
+        this.maxY = minY + height;
+    }
+
+    /// Returns the left edge.
+    public double getMinX() {
+        return minX;
+    }
+
+    /// Returns the top edge.
+    public double getMinY() {
+        return minY;
+    }
+
+    /// Returns the width.
+    public double getWidth() {
+        return width;
+    }
+
+    /// Returns the height.
+    public double getHeight() {
+        return height;
+    }
+
+    /// Returns the right edge.
+    public double getMaxX() {
+        return maxX;
+    }
+
+    /// Returns the bottom edge.
+    public double getMaxY() {
+        return maxY;
+    }
+
+    /// Returns whether a point lies inside or on the edge.
+    public boolean contains(Point2D p) {
+        if (p == null) {
+            return false;
+        }
+        return contains(p.getX(), p.getY());
+    }
+
+    /// Returns whether a location lies inside or on the edge.
+    public boolean contains(double x, double y) {
+        return x >= minX && x <= maxX && y >= minY && y <= maxY;
+    }
+
+    /// Returns whether another rectangle lies entirely inside this one.
+    public boolean contains(Rectangle2D r) {
+        if (r == null) {
+            return false;
+        }
+        return r.minX >= minX && r.minY >= minY && r.maxX <= maxX && r.maxY <= maxY;
+    }
+
+    /// Returns whether a rectangle lies entirely inside this one.
+    public boolean contains(double x, double y, double w, double h) {
+        return x >= minX && y >= minY && w <= maxX - x && h <= maxY - y;
+    }
+
+    /// Returns whether another rectangle overlaps or touches this one.
+    public boolean intersects(Rectangle2D r) {
+        if (r == null) {
+            return false;
+        }
+        return r.maxX > minX && r.maxY > minY && r.minX < maxX && r.minY < maxY;
+    }
+
+    /// Returns whether a rectangle overlaps this one.
+    public boolean intersects(double x, double y, double w, double h) {
+        return x < maxX && y < maxY && x + w > minX && y + h > minY;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Rectangle2D) {
+            Rectangle2D other = (Rectangle2D) obj;
+            return Geometry.same(minX, other.minX) && Geometry.same(minY, other.minY)
+                    && Geometry.same(width, other.width) && Geometry.same(height, other.height);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Geometry.hash(Geometry.hash(Geometry.hash(Geometry.hash(7, minX), minY), width), height);
+    }
+
+    @Override
+    public String toString() {
+        return "Rectangle2D [minX = " + minX + ", minY=" + minY + ", maxX=" + maxX + ", maxY=" + maxY + ", width="
+                + width + ", height=" + height + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/Side.java b/maven/javafx-compat/src/main/java/javafx/geometry/Side.java
new file mode 100644
index 00000000000..fddb4b47023
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/Side.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// A side of a rectangle.
+public enum Side {
+    /// The top side.
+    TOP,
+    /// The bottom side.
+    BOTTOM,
+    /// The left side.
+    LEFT,
+    /// The right side.
+    RIGHT;
+
+    /// Returns whether this is the left or the right side.
+    public boolean isVertical() {
+        return this == LEFT || this == RIGHT;
+    }
+
+    /// Returns whether this is the top or the bottom side.
+    public boolean isHorizontal() {
+        return this == TOP || this == BOTTOM;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/VPos.java b/maven/javafx-compat/src/main/java/javafx/geometry/VPos.java
new file mode 100644
index 00000000000..59f0320dce5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/VPos.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// A vertical position.
+public enum VPos {
+    /// At the top.
+    TOP,
+    /// In the middle.
+    CENTER,
+    /// On the text baseline.
+    BASELINE,
+    /// At the bottom.
+    BOTTOM
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/VerticalDirection.java b/maven/javafx-compat/src/main/java/javafx/geometry/VerticalDirection.java
new file mode 100644
index 00000000000..94427c05f07
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/VerticalDirection.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.geometry;
+
+/// A direction along the vertical axis.
+public enum VerticalDirection {
+    /// Towards the top.
+    UP,
+    /// Towards the bottom.
+    DOWN
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/geometry/package-info.java b/maven/javafx-compat/src/main/java/javafx/geometry/package-info.java
new file mode 100644
index 00000000000..a2f8f296d4f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/geometry/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Immutable geometry values -- points, sizes, rectangles, bounds, insets --
+/// and the enumerations that name positions and directions.
+package javafx.geometry;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/Cursor.java b/maven/javafx-compat/src/main/java/javafx/scene/Cursor.java
new file mode 100644
index 00000000000..3899e781973
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/Cursor.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene;
+
+import com.codename1.ui.Component;
+
+/// The shape of the mouse pointer over a node or a scene. It is shown
+/// where Codename One has a pointer to change, which is the desktop; a
+/// cursor it has no shape for is shown as the default arrow. Custom image
+/// cursors are not supported.
+public abstract class Cursor {
+
+    /// The platform's default arrow.
+    public static final Cursor DEFAULT = new Standard("DEFAULT", Component.DEFAULT_CURSOR);
+    /// A cross hair.
+    public static final Cursor CROSSHAIR = new Standard("CROSSHAIR", Component.CROSSHAIR_CURSOR);
+    /// The text insertion beam.
+    public static final Cursor TEXT = new Standard("TEXT", Component.TEXT_CURSOR);
+    /// The busy indicator.
+    public static final Cursor WAIT = new Standard("WAIT", Component.WAIT_CURSOR);
+    /// Resizing from the south west corner.
+    public static final Cursor SW_RESIZE = new Standard("SW_RESIZE", Component.SW_RESIZE_CURSOR);
+    /// Resizing from the south east corner.
+    public static final Cursor SE_RESIZE = new Standard("SE_RESIZE", Component.SE_RESIZE_CURSOR);
+    /// Resizing from the north west corner.
+    public static final Cursor NW_RESIZE = new Standard("NW_RESIZE", Component.NW_RESIZE_CURSOR);
+    /// Resizing from the north east corner.
+    public static final Cursor NE_RESIZE = new Standard("NE_RESIZE", Component.NE_RESIZE_CURSOR);
+    /// Resizing from the top edge.
+    public static final Cursor N_RESIZE = new Standard("N_RESIZE", Component.N_RESIZE_CURSOR);
+    /// Resizing from the bottom edge.
+    public static final Cursor S_RESIZE = new Standard("S_RESIZE", Component.S_RESIZE_CURSOR);
+    /// Resizing from the left edge.
+    public static final Cursor W_RESIZE = new Standard("W_RESIZE", Component.W_RESIZE_CURSOR);
+    /// Resizing from the right edge.
+    public static final Cursor E_RESIZE = new Standard("E_RESIZE", Component.E_RESIZE_CURSOR);
+    /// A hand with the fingers open.
+    public static final Cursor OPEN_HAND = new Standard("OPEN_HAND", Component.HAND_CURSOR);
+    /// A hand with the fingers closed.
+    public static final Cursor CLOSED_HAND = new Standard("CLOSED_HAND", Component.MOVE_CURSOR);
+    /// A pointing hand, as over a link.
+    public static final Cursor HAND = new Standard("HAND", Component.HAND_CURSOR);
+    /// Moving something.
+    public static final Cursor MOVE = new Standard("MOVE", Component.MOVE_CURSOR);
+    /// Something that cannot be dropped here; shown as the default arrow.
+    public static final Cursor DISAPPEAR = new Standard("DISAPPEAR", Component.DEFAULT_CURSOR);
+    /// Resizing horizontally.
+    public static final Cursor H_RESIZE = new Standard("H_RESIZE", Component.E_RESIZE_CURSOR);
+    /// Resizing vertically.
+    public static final Cursor V_RESIZE = new Standard("V_RESIZE", Component.N_RESIZE_CURSOR);
+    /// No pointer; shown as the default arrow.
+    public static final Cursor NONE = new Standard("NONE", Component.DEFAULT_CURSOR);
+
+    private static final Cursor[] ALL = {DEFAULT, CROSSHAIR, TEXT, WAIT, SW_RESIZE, SE_RESIZE, NW_RESIZE, NE_RESIZE,
+        N_RESIZE, S_RESIZE, W_RESIZE, E_RESIZE, OPEN_HAND, CLOSED_HAND, HAND, MOVE, DISAPPEAR, H_RESIZE, V_RESIZE,
+        NONE};
+
+    Cursor() {
+    }
+
+    /// Returns the Codename One cursor constant of this cursor.
+    public abstract int cn1Code();
+
+    /// Returns the cursor of a name such as `HAND` or `hand`; the CSS
+    /// spelling with dashes is accepted too.
+    public static Cursor cursor(String identifier) {
+        if (identifier == null) {
+            throw new NullPointerException("The cursor identifier must not be null");
+        }
+        String wanted = identifier.trim().replace('-', '_');
+        for (int i = 0; i < ALL.length; i++) {
+            if (ALL[i].toString().equalsIgnoreCase(wanted)) {
+                return ALL[i];
+            }
+        }
+        throw new IllegalArgumentException("Unknown cursor: " + identifier);
+    }
+
+    private static final class Standard extends Cursor {
+        private final String name;
+        private final int code;
+
+        Standard(String name, int code) {
+            this.name = name;
+            this.code = code;
+        }
+
+        @Override
+        public int cn1Code() {
+            return code;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/Group.java b/maven/javafx-compat/src/main/java/javafx/scene/Group.java
new file mode 100644
index 00000000000..2e261628af1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/Group.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene;
+
+import java.util.Collection;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.collections.ObservableList;
+import javafx.geometry.Bounds;
+
+/// A parent that adds nothing of its own: its bounds are the union of its
+/// children's, and it does not position them. Transforms and opacity set
+/// on a group apply to all of its children.
+public class Group extends Parent {
+
+    private final BooleanProperty autoSizeChildren = new FxBoolean(this, "autoSizeChildren", true, Dirty.LAYOUT);
+    private boolean measuring;
+
+    /// Creates an empty group.
+    public Group() {
+    }
+
+    /// Creates a group with children.
+    public Group(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a group with children.
+    public Group(Collection<Node> children) {
+        cn1Children().addAll(children);
+    }
+
+    @Override
+    public ObservableList<Node> getChildren() {
+        return super.getChildren();
+    }
+
+    /// Returns whether resizable children get their preferred size at
+    /// each layout.
+    public final boolean isAutoSizeChildren() {
+        return autoSizeChildren.get();
+    }
+
+    /// Sets whether resizable children get their preferred size at each
+    /// layout.
+    public final void setAutoSizeChildren(boolean value) {
+        autoSizeChildren.set(value);
+    }
+
+    /// Whether resizable children get their preferred size at each layout.
+    public final BooleanProperty autoSizeChildrenProperty() {
+        return autoSizeChildren;
+    }
+
+    /// The bounds of a group that sizes its children are those of the
+    /// children at their preferred sizes, so a group asked before any
+    /// layout pass ran gives them those sizes first. An application reads
+    /// this in a constructor to learn how large what it just built is, and
+    /// divides by the answer.
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        if (!measuring && isAutoSizeChildren() && isNeedsLayout()) {
+            measuring = true;
+            try {
+                layout();
+            } finally {
+                measuring = false;
+            }
+        }
+        return super.cn1ComputeLayoutBounds();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        if (isAutoSizeChildren()) {
+            super.layoutChildren();
+        }
+    }
+
+    @Override
+    public double prefWidth(double height) {
+        if (isAutoSizeChildren()) {
+            layout();
+        }
+        double w = getLayoutBounds().getWidth();
+        return Double.isNaN(w) || w < 0 ? 0 : w;
+    }
+
+    @Override
+    public double prefHeight(double width) {
+        if (isAutoSizeChildren()) {
+            layout();
+        }
+        double h = getLayoutBounds().getHeight();
+        return Double.isNaN(h) || h < 0 ? 0 : h;
+    }
+
+    @Override
+    public double minWidth(double height) {
+        return prefWidth(height);
+    }
+
+    @Override
+    public double minHeight(double width) {
+        return prefHeight(width);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/Node.java b/maven/javafx-compat/src/main/java/javafx/scene/Node.java
new file mode 100644
index 00000000000..fca1e55b47a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/Node.java
@@ -0,0 +1,2168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Effects;
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.FxString;
+import com.codename1.fxcompat.runtime.Matrix2D;
+import com.codename1.fxcompat.runtime.NodePeer;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.StyleEngine;
+import com.codename1.fxcompat.runtime.StyleTarget;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.css.PseudoClass;
+import javafx.css.Styleable;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Orientation;
+import javafx.geometry.Point2D;
+import javafx.scene.effect.Effect;
+import javafx.scene.input.ContextMenuEvent;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.input.SwipeEvent;
+import javafx.scene.input.TouchEvent;
+import javafx.scene.transform.Transform;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.image.WritableImage;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import java.util.List;
+
+/// The base of everything in a scene graph.
+///
+/// #### How a node reaches the screen
+///
+/// Each node has one Codename One component, its peer, created the first
+/// time it is needed ([#cn1Peer()]). The peer of a parent is a container
+/// holding the peers of its children. JavaFX layout runs on the nodes, in
+/// logical pixels, and the result is pushed into the peers as device
+/// pixels. A node that draws itself does so through [#cn1Paint(Renderer)];
+/// a control shows a native Codename One component instead.
+///
+/// The peer covers the node's layout bounds moved by `layoutX/Y` and
+/// `translateX/Y`. Scale, rotation and the `getTransforms()` list are
+/// applied when painting, about the centre of the layout bounds for the
+/// first two.
+///
+/// #### Styling
+///
+/// A node is the subject of a style sheet through `getTypeSelector()`,
+/// `getId()`, `getStyleClass()`, `getStyle()` and its pseudo-class states,
+/// and receives values through
+/// [#cn1ApplyStyle(String, Object)]; see
+/// `com.codename1.fxcompat.runtime.StyleTarget` for the contract and
+/// `com.codename1.fxcompat.runtime.StyleEngine` for when a restyle is
+/// requested. A subclass adds styleable attributes by overriding
+/// [#cn1StyleValue(String)] and [#cn1SetStyleValue(String, Object)].
+///
+/// #### Not part of this layer
+///
+/// Effects, clipping to the outline of a node (a clip is the box around
+/// the clip node, see [#setClip(Node)]), blend modes, caching hints, snapshots,
+/// three dimensional transforms, accessibility attributes and drag and
+/// drop.
+public abstract class Node implements EventTarget, Styleable, StyleTarget, Dirty.Owner {
+
+    /// The baseline offset of a node whose baseline is its bottom edge.
+    public static final double BASELINE_OFFSET_SAME_AS_HEIGHT = Double.NEGATIVE_INFINITY;
+
+    /// What [#cn1StyleValue(String)] answers for a property the node does
+    /// not have.
+    protected static final Object CN1_NO_STYLE = new Object();
+
+    private static final Object NULL_VALUE = new Object();
+    private static final int VISIBILITY = 1 << 20;
+    private static final int DISABLE = 1 << 21;
+    private static final PseudoClass HOVER = PseudoClass.getPseudoClass("hover");
+    private static final PseudoClass PRESSED = PseudoClass.getPseudoClass("pressed");
+    private static final PseudoClass DISABLED = PseudoClass.getPseudoClass("disabled");
+    private static final PseudoClass FOCUSED = PseudoClass.getPseudoClass("focused");
+
+    private Component peer;
+    private EventHandlerManager events;
+    private final ReadOnlyObjectWrapper<Parent> parent = new ReadOnlyObjectWrapper<Parent>(this, "parent");
+    private final ReadOnlyObjectWrapper<Scene> scene = new ReadOnlyObjectWrapper<Scene>(this, "scene");
+
+    private final StringProperty id = new FxString(this, "id", null, Dirty.STYLE);
+    private final StringProperty style = new FxString(this, "style", "", Dirty.STYLE);
+    private final ObservableList<String> styleClass = FXCollections.observableArrayList();
+    private ObservableSet<PseudoClass> pseudoClasses;
+    private HashMap<String, Object> styledFrom;
+    private Object styleState;
+
+    private final BooleanProperty visible = new FxBoolean(this, "visible", true, Dirty.PAINT | VISIBILITY);
+    private final BooleanProperty managed = new FxBoolean(this, "managed", true, Dirty.LAYOUT);
+    private final BooleanProperty disable = new FxBoolean(this, "disable", false, DISABLE);
+    private final ReadOnlyBooleanWrapper disabled = new ReadOnlyBooleanWrapper(this, "disabled", false);
+    private final ReadOnlyBooleanWrapper hover = new ReadOnlyBooleanWrapper(this, "hover", false);
+    private final ReadOnlyBooleanWrapper pressed = new ReadOnlyBooleanWrapper(this, "pressed", false);
+    private final ReadOnlyBooleanWrapper focused = new ReadOnlyBooleanWrapper(this, "focused", false);
+    private final BooleanProperty focusTraversable = new FxBoolean(this, "focusTraversable", false, Dirty.NATIVE);
+    private final BooleanProperty mouseTransparent = new FxBoolean(this, "mouseTransparent", false, Dirty.NONE);
+    private final BooleanProperty pickOnBounds = new FxBoolean(this, "pickOnBounds", false, Dirty.NONE);
+
+    private final DoubleProperty opacity = new FxDouble(this, "opacity", 1, Dirty.PAINT);
+    private final DoubleProperty layoutX = new FxDouble(this, "layoutX", 0, Dirty.BOUNDS);
+    private final DoubleProperty layoutY = new FxDouble(this, "layoutY", 0, Dirty.BOUNDS);
+    private final DoubleProperty translateX = new FxDouble(this, "translateX", 0, Dirty.BOUNDS);
+    private final DoubleProperty translateY = new FxDouble(this, "translateY", 0, Dirty.BOUNDS);
+    private final DoubleProperty scaleX = new FxDouble(this, "scaleX", 1, Dirty.BOUNDS);
+    private final DoubleProperty scaleY = new FxDouble(this, "scaleY", 1, Dirty.BOUNDS);
+    private final DoubleProperty rotate = new FxDouble(this, "rotate", 0, Dirty.BOUNDS);
+
+    private ObservableList<Transform> transforms;
+    private ObjectProperty<Node> clip;
+    private ObjectProperty<Effect> effect;
+    private Object effectCache;
+    private ObjectProperty<Cursor> cursor;
+    private Object userData;
+    private ObservableMap<Object, Object> properties;
+    private Bounds layoutBoundsCache;
+    private ReadOnlyObjectWrapper<Bounds> layoutBoundsProperty;
+    private ReadOnlyObjectWrapper<Bounds> boundsInLocalProperty;
+    private ReadOnlyObjectWrapper<Bounds> boundsInParentProperty;
+    private boolean restyling;
+
+    /// Creates a node.
+    protected Node() {
+        styleClass.addListener(new ListChangeListener<String>() {
+            @Override
+            public void onChanged(Change<? extends String> change) {
+                cn1Invalidated(Dirty.STYLE);
+            }
+        });
+    }
+
+    // ------------------------------------------------------------- peer
+
+    /// Returns the Codename One component that shows this node, creating
+    /// it the first time.
+    public final Component cn1Peer() {
+        if (peer == null) {
+            peer = cn1CreatePeer();
+            peer.setVisible(isVisible());
+            cn1PeerCreated();
+            cn1SyncPeerBounds();
+        }
+        return peer;
+    }
+
+    /// Returns whether the peer exists yet.
+    public final boolean cn1HasPeer() {
+        return peer != null;
+    }
+
+    /// Creates the peer. A node that draws itself keeps the default.
+    protected Component cn1CreatePeer() {
+        return new NodePeer(this);
+    }
+
+    /// Called once, right after the peer was created.
+    protected void cn1PeerCreated() {
+    }
+
+    /// Draws this node. The renderer's origin is the node's local origin
+    /// and its matrix already holds the node's scale, rotation and
+    /// transforms. A parent is drawn before its children.
+    public void cn1Paint(Renderer renderer) {
+    }
+
+    /// Returns whether this node draws beyond its layout bounds, as a
+    /// shape with a stroke centred on its outline does. Its peer is then
+    /// clipped by the parent rather than by its own bounds.
+    public boolean cn1PaintsOutsideBounds() {
+        return false;
+    }
+
+    /// Pushes the position and size of this node into its peer, in device
+    /// pixels relative to the parent's peer. The root of a scene is placed
+    /// by the form that hosts it instead.
+    public final void cn1SyncPeerBounds() {
+        if (peer == null) {
+            return;
+        }
+        Parent p = getParent();
+        if (p == null) {
+            return;
+        }
+        // The parent's bounds first: a group that sizes its children gives
+        // them their sizes when asked for its bounds, this node among them,
+        // and bounds of this node read before that would be the old ones.
+        Bounds plb = p.getLayoutBounds();
+        Bounds lb = getLayoutBounds();
+        double x = getLayoutX() + getTranslateX() + lb.getMinX() - plb.getMinX();
+        double y = getLayoutY() + getTranslateY() + lb.getMinY() - plb.getMinY();
+        int x1 = Units.toPixels(x);
+        int y1 = Units.toPixels(y);
+        // Empty bounds, as of a shape with neither fill nor stroke, have a
+        // negative size.
+        int x2 = Units.toPixels(x + Math.max(0, lb.getWidth()));
+        int y2 = Units.toPixels(y + Math.max(0, lb.getHeight()));
+        if (peer.getX() != x1 || peer.getY() != y1 || peer.getWidth() != x2 - x1 || peer.getHeight() != y2 - y1) {
+            peer.setX(x1);
+            peer.setY(y1);
+            peer.setWidth(x2 - x1);
+            peer.setHeight(y2 - y1);
+            cn1PeerResized();
+        }
+    }
+
+    /// Called when the peer's bounds changed.
+    protected void cn1PeerResized() {
+    }
+
+    /// Returns the scale, rotation and transforms of this node as the
+    /// matrix `{a, b, c, d, tx, ty}` in local coordinates: everything
+    /// between the node's own coordinates and its translated position in
+    /// the parent. Answers `null` when there is none, the common case.
+    public double[] cn1PaintMatrix() {
+        double[] own = new double[6];
+        if (!scaleAndRotation(own)) {
+            own = null;
+        }
+        if (transforms == null || transforms.isEmpty()) {
+            return own;
+        }
+        // JavaFX's order: the list first, outermost first, then the
+        // node's own rotation and scale about its centre.
+        double[] m = null;
+        for (int i = 0; i < transforms.size(); i++) {
+            Transform t = transforms.get(i);
+            if (t == null || t.isIdentity()) {
+                continue;
+            }
+            double[] tm = {t.getMxx(), t.getMyx(), t.getMxy(), t.getMyy(), t.getTx(), t.getTy()};
+            m = m == null ? tm : Matrix2D.multiply(m, tm);
+        }
+        if (m == null) {
+            return own;
+        }
+        return own == null ? m : Matrix2D.multiply(m, own);
+    }
+
+    /// Writes the node's own scale and rotation about its centre into a
+    /// matrix; answers `false`, writing nothing, when it has neither.
+    private boolean scaleAndRotation(double[] out) {
+        double sx = getScaleX();
+        double sy = getScaleY();
+        double r = getRotate();
+        if (sx == 1 && sy == 1 && r == 0) {
+            return false;
+        }
+        Bounds lb = getLayoutBounds();
+        double px = lb.getMinX() + lb.getWidth() / 2;
+        double py = lb.getMinY() + lb.getHeight() / 2;
+        double rad = Math.toRadians(r);
+        double cos = Math.cos(rad);
+        double sin = Math.sin(rad);
+        double a = cos * sx;
+        double b = sin * sx;
+        double c = -sin * sy;
+        double d = cos * sy;
+        out[0] = a;
+        out[1] = b;
+        out[2] = c;
+        out[3] = d;
+        out[4] = px - a * px - c * py;
+        out[5] = py - b * px - d * py;
+        return true;
+    }
+
+    private double[] localToParentMatrix() {
+        double[] m = cn1PaintMatrix();
+        double tx = getLayoutX() + getTranslateX();
+        double ty = getLayoutY() + getTranslateY();
+        if (m == null) {
+            return new double[] {1, 0, 0, 1, tx, ty};
+        }
+        m[4] += tx;
+        m[5] += ty;
+        return m;
+    }
+
+    // ---------------------------------------------------------- snapshot
+
+    /// Renders this node and what is under it into an image and returns
+    /// the image.
+    ///
+    /// The image is the node's bounds in its parent after the transform
+    /// of the parameters, or the viewport when the parameters name one;
+    /// an image handed in is drawn into and keeps its size. One pixel is
+    /// one logical pixel, as in JavaFX. `null` parameters are the default
+    /// ones: no transform, a white fill.
+    ///
+    /// What is rendered is what the layer draws itself: shapes, text,
+    /// canvases, images and the backgrounds and borders of regions, each
+    /// under its transforms and inside its clip. A control drawn by the
+    /// platform's theme is not in the picture, and neither are opacity
+    /// and effects.
+    public WritableImage snapshot(SnapshotParameters params, WritableImage image) {
+        double[] m = localToParentMatrix();
+        Transform extra = params == null ? null : params.getTransform();
+        if (extra != null && !extra.isIdentity()) {
+            m = Matrix2D.multiply(new double[] {extra.getMxx(), extra.getMyx(), extra.getMxy(), extra.getMyy(),
+                extra.getTx(), extra.getTy()}, m);
+        }
+        Bounds local = getBoundsInLocal();
+        double[] box = Matrix2D.bounds(m, local.getMinX(), local.getMinY(), Math.max(0, local.getWidth()),
+                Math.max(0, local.getHeight()));
+        double x = box[0];
+        double y = box[1];
+        double w = box[2] - box[0];
+        double h = box[3] - box[1];
+        Rectangle2D viewport = params == null ? null : params.getViewport();
+        if (viewport != null) {
+            x = viewport.getMinX();
+            y = viewport.getMinY();
+            w = viewport.getWidth();
+            h = viewport.getHeight();
+        }
+        WritableImage out = image;
+        if (out == null) {
+            out = new WritableImage(Math.max(1, (int) Math.ceil(w - 1e-6)), Math.max(1, (int) Math.ceil(h - 1e-6)));
+        }
+        int iw = (int) out.getWidth();
+        int ih = (int) out.getHeight();
+        double s = Units.scale();
+        int pw = Math.max(1, (int) Math.ceil(iw * s - 1e-6));
+        int ph = Math.max(1, (int) Math.ceil(ih * s - 1e-6));
+        com.codename1.ui.Image surface = com.codename1.ui.Image.createImage(pw, ph, 0);
+        Renderer r = new Renderer(surface.getGraphics(), 0, 0);
+        Paint fill = params == null ? null : params.getFill();
+        r.fillRect(0, 0, iw, ih, fill == null ? Color.WHITE : fill);
+        r.translate(-x, -y);
+        if (extra != null && !extra.isIdentity()) {
+            r.concat(extra.getMxx(), extra.getMyx(), extra.getMxy(), extra.getMyy(), extra.getTx(), extra.getTy());
+        }
+        snapshot(r, this);
+        // The surface is in device pixels; the image is in logical ones.
+        com.codename1.ui.Image sized = pw == iw && ph == ih ? surface : surface.scaled(iw, ih);
+        int[] pixels = sized.getRGB();
+        if (pixels != null && pixels.length == iw * ih) {
+            out.cn1SetPixels(pixels);
+        }
+        return out;
+    }
+
+    private static void snapshot(Renderer r, Node node) {
+        if (!node.isVisible()) {
+            return;
+        }
+        r.save();
+        double[] m = node.localToParentMatrix();
+        r.concat(m[0], m[1], m[2], m[3], m[4], m[5]);
+        FxPath clip = node.cn1ClipPath();
+        if (clip != null) {
+            r.clip(clip);
+        }
+        node.cn1Paint(r);
+        if (node instanceof Parent) {
+            List<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                snapshot(r, children.get(i));
+            }
+        }
+        r.restore();
+    }
+
+    // --------------------------------------------------------- dirtiness
+
+    /// Reacts to a property change; see
+    /// `com.codename1.fxcompat.runtime.Dirty` for the bits. A subclass
+    /// that defines bits of its own overrides this and calls the super
+    /// implementation.
+    @Override
+    public void cn1Invalidated(int what) {
+        // Whatever changed, the picture an effect above keeps of it is old.
+        Effects.invalidate(this);
+        if ((what & VISIBILITY) != 0 && peer != null) {
+            peer.setVisible(isVisible());
+        }
+        if ((what & DISABLE) != 0) {
+            updateDisabled();
+        }
+        if ((what & Dirty.STYLE) != 0) {
+            cn1Restyle();
+        }
+        if ((what & Dirty.GEOMETRY) != 0) {
+            cn1GeometryChanged();
+        }
+        if ((what & Dirty.LAYOUT) != 0) {
+            cn1RequestLayout();
+        }
+        if ((what & Dirty.BOUNDS) != 0) {
+            cn1SyncPeerBounds();
+            fireBoundsChanged();
+            Parent p = getParent();
+            if (p != null) {
+                p.cn1ChildBoundsChanged(this);
+            }
+        }
+        if ((what & (Dirty.PAINT | Dirty.BOUNDS)) != 0) {
+            repaint((what & Dirty.BOUNDS) != 0);
+        }
+    }
+
+    /// Schedules this node to be drawn again. A node that is transformed,
+    /// translucent or below such a node is redrawn through the parent of
+    /// the outermost one, since only that paints the transform.
+    public final void cn1Repaint() {
+        repaint(false);
+    }
+
+    private void repaint(boolean moved) {
+        if (peer == null) {
+            return;
+        }
+        Node top = null;
+        for (Node n = this; n != null; n = n.getParent()) {
+            // A shadow lies outside its node, so it is the parent that
+            // has to paint again.
+            if (n.cn1PaintMatrix() != null || n.getOpacity() < 1 || (n.effect != null && n.effect.get() != null)) {
+                top = n;
+            }
+        }
+        Node target = top == null ? this : top;
+        // A moved or transformed node also uncovers part of its parent.
+        if ((top != null || moved) && target.getParent() != null) {
+            target = target.getParent();
+        }
+        // Codename One paints a component over the backgrounds of its
+        // parents and takes siblings not to overlap, so a node that lies
+        // over an earlier sibling -- the indicator over the veil of a
+        // stack pane -- would be painted again on a hole in that sibling.
+        // The parent paints both.
+        for (int level = 0; level < 8 && target.peer != null; level++) {
+            Parent holder = target.getParent();
+            if (holder == null || !target.liesOverASibling(holder)) {
+                break;
+            }
+            target = holder;
+        }
+        if (target.peer != null) {
+            target.peer.repaint();
+        }
+    }
+
+    private static final int OVERLAP_SIBLINGS = 64;
+
+    /// Whether a visible sibling drawn before this node lies under any
+    /// part of it. Not asked of a parent with many children, which is a
+    /// list of rows that do not overlap.
+    private boolean liesOverASibling(Parent holder) {
+        List<Node> all = holder.getChildrenUnmodifiable();
+        int n = all.size();
+        if (n < 2 || n > OVERLAP_SIBLINGS || all.get(0) == this) {
+            return false;
+        }
+        Bounds mine = getBoundsInParent();
+        for (int i = 0; i < n; i++) {
+            Node other = all.get(i);
+            if (other == this) {
+                break;
+            }
+            if (other.isVisible() && other.getBoundsInParent().intersects(mine)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Asks for the layout that places this node to run again.
+    protected void cn1RequestLayout() {
+        Parent p = getParent();
+        if (p != null) {
+            p.requestLayout();
+        }
+    }
+
+    /// Forgets the cached layout bounds; called when the geometry of a
+    /// node that computes its own changed.
+    protected final void cn1GeometryChanged() {
+        layoutBoundsCache = null;
+        fireBoundsChanged();
+        cn1SyncPeerBounds();
+        cn1RequestLayout();
+        repaint(true);
+        Parent p = getParent();
+        if (p != null) {
+            p.cn1ChildBoundsChanged(this);
+        }
+    }
+
+    final boolean cn1LayoutBoundsStale(Bounds fresh) {
+        Bounds old = layoutBoundsCache;
+        return old != null && (old.getMinX() != fresh.getMinX() || old.getMinY() != fresh.getMinY()
+                || old.getWidth() != fresh.getWidth() || old.getHeight() != fresh.getHeight());
+    }
+
+    private void fireBoundsChanged() {
+        if (layoutBoundsProperty != null) {
+            layoutBoundsProperty.set(getLayoutBounds());
+        }
+        if (boundsInLocalProperty != null) {
+            boundsInLocalProperty.set(getBoundsInLocal());
+        }
+        if (boundsInParentProperty != null) {
+            boundsInParentProperty.set(getBoundsInParent());
+        }
+    }
+
+    // -------------------------------------------------------------- tree
+
+    /// Returns the parent; `null` for a root or a detached node.
+    public final Parent getParent() {
+        return parent.get();
+    }
+
+    /// The parent of this node.
+    public final ReadOnlyObjectProperty<Parent> parentProperty() {
+        return parent.getReadOnlyProperty();
+    }
+
+    final void setParentInternal(Parent value) {
+        parent.set(value);
+        updateDisabled();
+    }
+
+    /// Returns the scene this node is in, or `null`.
+    public final Scene getScene() {
+        return scene.get();
+    }
+
+    /// The scene this node is in.
+    public final ReadOnlyObjectProperty<Scene> sceneProperty() {
+        return scene.getReadOnlyProperty();
+    }
+
+    void setSceneInternal(Scene value) {
+        Scene old = scene.get();
+        if (old == value) {
+            return;
+        }
+        if (old != null) {
+            old.cn1NodeLeft(this);
+        }
+        scene.set(value);
+        if (value != null) {
+            cn1Restyle();
+        }
+    }
+
+    /// Moves this node in front of its siblings.
+    public void toFront() {
+        Parent p = getParent();
+        if (p != null) {
+            p.cn1ToFront(this);
+        }
+    }
+
+    /// Moves this node behind its siblings.
+    public void toBack() {
+        Parent p = getParent();
+        if (p != null) {
+            p.cn1ToBack(this);
+        }
+    }
+
+    // ----------------------------------------------------------- styling
+
+    /// Returns the id, which an `#id` selector and [#lookup(String)] match.
+    public final String getId() {
+        return id.get();
+    }
+
+    /// Sets the id.
+    public final void setId(String value) {
+        id.set(value);
+    }
+
+    /// The id of this node.
+    public final StringProperty idProperty() {
+        return id;
+    }
+
+    /// Returns the inline style.
+    public final String getStyle() {
+        String s = style.get();
+        return s == null ? "" : s;
+    }
+
+    /// Sets the inline style, CSS declarations such as
+    /// `-fx-background-color: red;`. It has an effect once a style engine
+    /// is installed.
+    public final void setStyle(String value) {
+        style.set(value);
+    }
+
+    /// The inline style of this node.
+    public final StringProperty styleProperty() {
+        return style;
+    }
+
+    @Override
+    public final ObservableList<String> getStyleClass() {
+        return styleClass;
+    }
+
+    /// The name a style sheet selects this node by: the simple name of
+    /// its class.
+    ///
+    /// An anonymous subclass has no simple name, and is selected by the
+    /// name of its class without the package (`Outer$1`), which is what a
+    /// desktop JavaFX answers for it too. The name of the class it extends
+    /// is not used: the device library cannot ask a class for its
+    /// superclass. Select such a node by its style class, as the style
+    /// sheets of the controls do, or override this method.
+    @Override
+    public String getTypeSelector() {
+        String name = getClass().getName();
+        int dot = name.lastIndexOf('.');
+        int dollar = name.lastIndexOf('$');
+        if (dollar > dot && dollar + 1 < name.length()) {
+            char first = name.charAt(dollar + 1);
+            if (first < '0' || first > '9') {
+                return name.substring(dollar + 1);
+            }
+        }
+        return name.substring(dot + 1);
+    }
+
+    @Override
+    public Styleable getStyleableParent() {
+        return getParent();
+    }
+
+    @Override
+    public final ObservableSet<PseudoClass> getPseudoClassStates() {
+        if (pseudoClasses == null) {
+            pseudoClasses = FXCollections.observableSet(new HashSet<PseudoClass>());
+        }
+        return pseudoClasses;
+    }
+
+    /// Turns a pseudo-class state on or off and requests a restyle when
+    /// that changed something.
+    public final void pseudoClassStateChanged(PseudoClass pseudoClass, boolean active) {
+        if (pseudoClass == null) {
+            return;
+        }
+        boolean changed = active ? getPseudoClassStates().add(pseudoClass)
+                : (pseudoClasses != null && pseudoClasses.remove(pseudoClass));
+        if (changed) {
+            cn1Restyle();
+        }
+    }
+
+    /// Returns whether a pseudo-class state is on, without creating the
+    /// set [#getPseudoClassStates()] answers; what a style engine asks for
+    /// every selector it tries.
+    public final boolean cn1HasPseudoClass(PseudoClass pseudoClass) {
+        return pseudoClasses != null && pseudoClasses.contains(pseudoClass);
+    }
+
+    /// Returns what the style engine keeps for this node between two
+    /// restyles, or `null`. The object is the engine's own.
+    public final Object cn1StyleState() {
+        return styleState;
+    }
+
+    /// The declarations this node has before any style sheet is read,
+    /// written as an inline style, or `null` for none. They are what the
+    /// standard theme of JavaFX would give the node, and lose to every
+    /// rule of a sheet; a colour they name is looked up where the node
+    /// stands, which is how redefining `-fx-base` recolours a control.
+    public String cn1DefaultStyle() {
+        return null;
+    }
+
+    /// Returns the look the standard JavaFX theme gives this node, as the
+    /// text of a style, for a node that otherwise looks as the native
+    /// theme makes it; `null`, the default, for a node with none.
+    ///
+    /// It is applied, below every rule as [#cn1DefaultStyle()] is, only
+    /// where a rule or an inline style redefines one of the standard
+    /// theme's colours for the node or something above it: a button is
+    /// the platform's button until an application asks for a red one with
+    /// `-fx-base`, which only the standard theme's look can be. The text
+    /// may differ with the state of the node, and must not define colours
+    /// itself.
+    public String cn1ThemedStyle() {
+        return null;
+    }
+
+    /// Stores what the style engine keeps for this node.
+    public final void cn1SetStyleState(Object state) {
+        styleState = state;
+    }
+
+    /// Asks the style engine to style this node now.
+    public final void applyCss() {
+        cn1Restyle();
+    }
+
+    /// Requests a restyle of this node from the installed engine. Does
+    /// nothing outside a scene, or while the engine is styling this node.
+    protected final void cn1Restyle() {
+        if (getScene() == null || restyling) {
+            return;
+        }
+        restyling = true;
+        try {
+            StyleEngine.getInstance().restyle(this);
+        } finally {
+            restyling = false;
+        }
+    }
+
+    /// Sets, or with `null` restores, one styleable attribute; the entry
+    /// point of `com.codename1.fxcompat.runtime.StyleTarget`.
+    @Override
+    public final boolean cn1ApplyStyle(String property, Object value) {
+        if (property == null) {
+            return false;
+        }
+        if (value == null) {
+            if (styledFrom != null && styledFrom.containsKey(property)) {
+                Object original = styledFrom.remove(property);
+                cn1SetStyleValue(property, original == NULL_VALUE ? null : original);
+                return true;
+            }
+            return cn1StyleValue(property) != CN1_NO_STYLE;
+        }
+        Object current = cn1StyleValue(property);
+        if (current == CN1_NO_STYLE) {
+            return false;
+        }
+        if (!cn1SetStyleValue(property, value)) {
+            return false;
+        }
+        if (styledFrom == null) {
+            styledFrom = new HashMap<String, Object>();
+        }
+        if (!styledFrom.containsKey(property)) {
+            styledFrom.put(property, current == null ? NULL_VALUE : current);
+        }
+        return true;
+    }
+
+    /// Returns the current value of a styleable attribute in a form
+    /// [#cn1SetStyleValue(String, Object)] accepts back, or
+    /// [#CN1_NO_STYLE] when this node does not have the property.
+    /// Overridden per node family; an override handles its own names and
+    /// passes the rest to the super implementation.
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-opacity".equals(property)) {
+            return Double.valueOf(getOpacity());
+        } else if ("-fx-rotate".equals(property)) {
+            return Double.valueOf(getRotate());
+        } else if ("-fx-scale-x".equals(property)) {
+            return Double.valueOf(getScaleX());
+        } else if ("-fx-scale-y".equals(property)) {
+            return Double.valueOf(getScaleY());
+        } else if ("-fx-translate-x".equals(property)) {
+            return Double.valueOf(getTranslateX());
+        } else if ("-fx-translate-y".equals(property)) {
+            return Double.valueOf(getTranslateY());
+        } else if ("-fx-effect".equals(property)) {
+            return getEffect();
+        } else if ("-fx-cursor".equals(property)) {
+            return getCursor();
+        } else if ("visibility".equals(property)) {
+            return Boolean.valueOf(isVisible());
+        } else if ("-fx-managed".equals(property)) {
+            return Boolean.valueOf(isManaged());
+        }
+        return CN1_NO_STYLE;
+    }
+
+    /// Sets a styleable attribute from an already parsed value. Answers
+    /// `false`, changing nothing, for a property this node does not have
+    /// or a value of a type the property cannot use. `null` is only
+    /// passed for a property whose value was `null` before it was styled.
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-effect".equals(property)) {
+            if (value == null) {
+                setEffect(null);
+                return true;
+            } else if (value instanceof Effect) {
+                setEffect((Effect) value);
+                return true;
+            }
+            return false;
+        } else if ("-fx-cursor".equals(property)) {
+            if (value == null || value instanceof Cursor) {
+                setCursor((Cursor) value);
+                return true;
+            }
+            return false;
+        } else if ("visibility".equals(property)) {
+            if (value instanceof Boolean) {
+                setVisible(((Boolean) value).booleanValue());
+                return true;
+            } else if (value instanceof String) {
+                setVisible("visible".equalsIgnoreCase(((String) value).trim()));
+                return true;
+            }
+            return false;
+        } else if ("-fx-managed".equals(property)) {
+            if (value instanceof Boolean) {
+                setManaged(((Boolean) value).booleanValue());
+                return true;
+            }
+            return false;
+        }
+        if (!(value instanceof Number)) {
+            return false;
+        }
+        double v = ((Number) value).doubleValue();
+        if ("-fx-opacity".equals(property)) {
+            setOpacity(v);
+        } else if ("-fx-rotate".equals(property)) {
+            setRotate(v);
+        } else if ("-fx-scale-x".equals(property)) {
+            setScaleX(v);
+        } else if ("-fx-scale-y".equals(property)) {
+            setScaleY(v);
+        } else if ("-fx-translate-x".equals(property)) {
+            setTranslateX(v);
+        } else if ("-fx-translate-y".equals(property)) {
+            setTranslateY(v);
+        } else {
+            return false;
+        }
+        return true;
+    }
+
+    /// Returns the first node in this subtree, this node included, that a
+    /// selector matches. Supported are type, `#id` and `.class` selectors,
+    /// compounds of them and descendant chains separated by spaces.
+    public Node lookup(String selector) {
+        Set<Node> all = lookupAll(selector);
+        return all.isEmpty() ? null : all.iterator().next();
+    }
+
+    /// Returns every node in this subtree, this node included, that a
+    /// selector matches, in document order.
+    public Set<Node> lookupAll(String selector) {
+        LinkedHashSet<Node> found = new LinkedHashSet<Node>();
+        if (selector == null) {
+            return found;
+        }
+        String s = selector.trim();
+        if (s.length() == 0) {
+            return found;
+        }
+        int space = s.indexOf(' ');
+        String first = space < 0 ? s : s.substring(0, space);
+        String rest = space < 0 ? null : s.substring(space + 1).trim();
+        LinkedHashSet<Node> stage = new LinkedHashSet<Node>();
+        collect(first, stage);
+        if (rest == null || rest.length() == 0) {
+            return stage;
+        }
+        for (Node n : stage) {
+            if (n instanceof Parent) {
+                ObservableList<Node> children = ((Parent) n).getChildrenUnmodifiable();
+                for (int i = 0; i < children.size(); i++) {
+                    found.addAll(children.get(i).lookupAll(rest));
+                }
+            }
+        }
+        return found;
+    }
+
+    void collect(String compound, Set<Node> into) {
+        if (cn1Matches(compound)) {
+            into.add(this);
+        }
+    }
+
+    /// Returns whether a compound selector without combinators, such as
+    /// `Button.primary#ok`, matches this node.
+    public final boolean cn1Matches(String compound) {
+        int i = 0;
+        int n = compound.length();
+        while (i < n) {
+            char kind = compound.charAt(i);
+            int start = kind == '#' || kind == '.' ? i + 1 : i;
+            int end = start;
+            while (end < n && compound.charAt(end) != '#' && compound.charAt(end) != '.') {
+                end++;
+            }
+            String token = compound.substring(start, end);
+            if (kind == '#') {
+                if (!token.equals(getId())) {
+                    return false;
+                }
+            } else if (kind == '.') {
+                if (!styleClass.contains(token)) {
+                    return false;
+                }
+            } else if (!"*".equals(token) && !token.equals(getTypeSelector())) {
+                return false;
+            }
+            i = end;
+        }
+        return n > 0;
+    }
+
+    // ------------------------------------------------------------- state
+
+    /// Returns whether the node is shown. An invisible node still takes
+    /// its place in layout.
+    public final boolean isVisible() {
+        return visible.get();
+    }
+
+    /// Sets whether the node is shown.
+    public final void setVisible(boolean value) {
+        visible.set(value);
+    }
+
+    /// Whether the node is shown.
+    public final BooleanProperty visibleProperty() {
+        return visible;
+    }
+
+    /// Returns whether the parent lays this node out.
+    public final boolean isManaged() {
+        return managed.get();
+    }
+
+    /// Sets whether the parent lays this node out.
+    public final void setManaged(boolean value) {
+        managed.set(value);
+    }
+
+    /// Whether the parent lays this node out.
+    public final BooleanProperty managedProperty() {
+        return managed;
+    }
+
+    /// Returns whether this node itself was disabled.
+    public final boolean isDisable() {
+        return disable.get();
+    }
+
+    /// Disables or enables this node and everything below it.
+    public final void setDisable(boolean value) {
+        disable.set(value);
+    }
+
+    /// Whether this node itself was disabled.
+    public final BooleanProperty disableProperty() {
+        return disable;
+    }
+
+    /// Returns whether this node or an ancestor is disabled.
+    public final boolean isDisabled() {
+        return disabled.get();
+    }
+
+    /// Whether this node or an ancestor is disabled.
+    public final ReadOnlyBooleanProperty disabledProperty() {
+        return disabled.getReadOnlyProperty();
+    }
+
+    /// Sets whether this node is disabled; for subclasses.
+    protected final void setDisabled(boolean value) {
+        if (disabled.get() != value) {
+            disabled.set(value);
+            pseudoClassStateChanged(DISABLED, value);
+            cn1Invalidated(Dirty.NATIVE | Dirty.PAINT);
+            cn1DisabledChanged();
+        }
+    }
+
+    final void updateDisabled() {
+        Parent p = getParent();
+        setDisabled(isDisable() || (p != null && p.isDisabled()));
+    }
+
+    void cn1DisabledChanged() {
+    }
+
+    /// Returns whether the pointer is over this node.
+    public final boolean isHover() {
+        return hover.get();
+    }
+
+    /// Whether the pointer is over this node.
+    public final ReadOnlyBooleanProperty hoverProperty() {
+        return hover.getReadOnlyProperty();
+    }
+
+    /// Sets whether the pointer is over this node; for subclasses.
+    protected final void setHover(boolean value) {
+        if (hover.get() != value) {
+            hover.set(value);
+            pseudoClassStateChanged(HOVER, value);
+        }
+    }
+
+    /// Returns whether a button is pressed on this node.
+    public final boolean isPressed() {
+        return pressed.get();
+    }
+
+    /// Whether a button is pressed on this node.
+    public final ReadOnlyBooleanProperty pressedProperty() {
+        return pressed.getReadOnlyProperty();
+    }
+
+    /// Sets whether a button is pressed on this node; for subclasses.
+    protected final void setPressed(boolean value) {
+        if (pressed.get() != value) {
+            pressed.set(value);
+            pseudoClassStateChanged(PRESSED, value);
+        }
+    }
+
+    final void cn1SetHover(boolean value) {
+        setHover(value);
+    }
+
+    final void cn1SetPressed(boolean value) {
+        setPressed(value);
+    }
+
+    /// Returns whether this node has the keyboard focus.
+    public final boolean isFocused() {
+        return focused.get();
+    }
+
+    /// Whether this node has the keyboard focus.
+    public final ReadOnlyBooleanProperty focusedProperty() {
+        return focused.getReadOnlyProperty();
+    }
+
+    /// Sets whether this node has the focus; for subclasses.
+    protected final void setFocused(boolean value) {
+        if (focused.get() != value) {
+            focused.set(value);
+            pseudoClassStateChanged(FOCUSED, value);
+        }
+    }
+
+    final void cn1SetFocused(boolean value) {
+        setFocused(value);
+    }
+
+    /// Returns whether Tab moves the focus to this node.
+    public final boolean isFocusTraversable() {
+        return focusTraversable.get();
+    }
+
+    /// Sets whether Tab moves the focus to this node.
+    public final void setFocusTraversable(boolean value) {
+        focusTraversable.set(value);
+    }
+
+    /// Whether Tab moves the focus to this node.
+    public final BooleanProperty focusTraversableProperty() {
+        return focusTraversable;
+    }
+
+    /// Asks for the keyboard focus. It is given when the node is in a
+    /// scene, visible and not disabled.
+    public void requestFocus() {
+        Scene s = getScene();
+        if (s != null && isVisible() && !isDisabled()) {
+            s.cn1SetFocusOwner(this, true);
+        }
+    }
+
+    /// Called when the scene gives this node the focus through
+    /// [#requestFocus()], so a control can move the native focus too.
+    protected void cn1FocusRequested() {
+    }
+
+    /// Returns whether pointer events pass through this node and its
+    /// children.
+    public final boolean isMouseTransparent() {
+        return mouseTransparent.get();
+    }
+
+    /// Sets whether pointer events pass through this node.
+    public final void setMouseTransparent(boolean value) {
+        mouseTransparent.set(value);
+    }
+
+    /// Whether pointer events pass through this node.
+    public final BooleanProperty mouseTransparentProperty() {
+        return mouseTransparent;
+    }
+
+    /// Returns whether the node is hit anywhere in its bounds rather than
+    /// only on its shape.
+    public final boolean isPickOnBounds() {
+        return pickOnBounds.get();
+    }
+
+    /// Sets whether the node is hit anywhere in its bounds.
+    public final void setPickOnBounds(boolean value) {
+        pickOnBounds.set(value);
+    }
+
+    /// Whether the node is hit anywhere in its bounds.
+    public final BooleanProperty pickOnBoundsProperty() {
+        return pickOnBounds;
+    }
+
+    /// Returns the cursor shown over this node, or `null` to inherit.
+    public final Cursor getCursor() {
+        return cursor == null ? null : cursor.get();
+    }
+
+    /// Sets the cursor shown over this node.
+    public final void setCursor(Cursor value) {
+        if (value != null || cursor != null) {
+            cursorProperty().set(value);
+        }
+    }
+
+    /// The cursor shown over this node.
+    public final ObjectProperty<Cursor> cursorProperty() {
+        if (cursor == null) {
+            cursor = new FxObject<Cursor>(this, "cursor", null, Dirty.NATIVE);
+        }
+        return cursor;
+    }
+
+    /// Sets the effect of this node. A drop shadow and an inner shadow are
+    /// drawn; any other effect is recorded and the node is painted as it
+    /// is without one. The bounds of a node do not grow by what an effect
+    /// adds. See [Effect].
+    public final void setEffect(Effect value) {
+        effectProperty().set(value);
+    }
+
+    /// Returns the effect set on this node, `null` for none.
+    public final Effect getEffect() {
+        return effect == null ? null : effect.get();
+    }
+
+    /// The effect of this node; see [#setEffect(Effect)].
+    public final ObjectProperty<Effect> effectProperty() {
+        if (effect == null) {
+            effect = new FxObject<Effect>(this, "effect", null, Dirty.PAINT);
+        }
+        return effect;
+    }
+
+    /// The picture `com.codename1.fxcompat.runtime.Effects` keeps of this
+    /// node for its effect, `null` when it keeps none.
+    public final Object cn1EffectCache() {
+        return effectCache;
+    }
+
+    /// Sets what [#cn1EffectCache()] answers.
+    public final void cn1SetEffectCache(Object cache) {
+        effectCache = cache;
+    }
+
+    /// Returns the application's own object attached to this node.
+    public Object getUserData() {
+        return userData;
+    }
+
+    /// Attaches an object of the application to this node.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns a map for the application's and the layout panes' own
+    /// values on this node.
+    public final ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    /// Returns whether [#getProperties()] holds anything.
+    public boolean hasProperties() {
+        return properties != null && !properties.isEmpty();
+    }
+
+    // ---------------------------------------------------------- geometry
+
+    /// The node this one is clipped by, in this node's coordinates.
+    ///
+    /// What is clipped to is the box around the clip node, its
+    /// `getBoundsInParent()`: a rectangle clips exactly, any other shape
+    /// clips to its bounds. The clip limits what is drawn, of this node
+    /// and of its children, and what a pointer can hit. It is read when
+    /// the node is drawn; after changing the clip node itself, set it
+    /// again or change anything else that repaints.
+    public final ObjectProperty<Node> clipProperty() {
+        if (clip == null) {
+            clip = new FxObject<Node>(this, "clip", null, Dirty.PAINT);
+        }
+        return clip;
+    }
+
+    /// Sets the node this one is clipped by; `null` removes the clip.
+    public final void setClip(Node value) {
+        clipProperty().set(value);
+    }
+
+    /// Returns the node this one is clipped by, or `null`.
+    public final Node getClip() {
+        return clip == null ? null : clip.get();
+    }
+
+    /// Returns the area this node is clipped to as a path in its own
+    /// coordinates, or `null` when it has no clip.
+    public final FxPath cn1ClipPath() {
+        Node by = getClip();
+        if (by == null) {
+            return null;
+        }
+        Bounds b = by.getBoundsInParent();
+        FxPath path = new FxPath();
+        path.addRect(b.getMinX(), b.getMinY(), Math.max(0, b.getWidth()), Math.max(0, b.getHeight()));
+        return path;
+    }
+
+    /// Returns the opacity, 0 to 1.
+    public final double getOpacity() {
+        return opacity.get();
+    }
+
+    /// Sets the opacity of this node and its children.
+    public final void setOpacity(double value) {
+        opacity.set(value);
+    }
+
+    /// The opacity of this node.
+    public final DoubleProperty opacityProperty() {
+        return opacity;
+    }
+
+    /// Returns the x the layout placed this node at.
+    public final double getLayoutX() {
+        return layoutX.get();
+    }
+
+    /// Sets the x of this node in its parent.
+    public final void setLayoutX(double value) {
+        layoutX.set(value);
+    }
+
+    /// The x of this node in its parent.
+    public final DoubleProperty layoutXProperty() {
+        return layoutX;
+    }
+
+    /// Returns the y the layout placed this node at.
+    public final double getLayoutY() {
+        return layoutY.get();
+    }
+
+    /// Sets the y of this node in its parent.
+    public final void setLayoutY(double value) {
+        layoutY.set(value);
+    }
+
+    /// The y of this node in its parent.
+    public final DoubleProperty layoutYProperty() {
+        return layoutY;
+    }
+
+    /// Returns the x offset added after layout.
+    public final double getTranslateX() {
+        return translateX.get();
+    }
+
+    /// Sets the x offset added after layout.
+    public final void setTranslateX(double value) {
+        translateX.set(value);
+    }
+
+    /// The x offset added after layout.
+    public final DoubleProperty translateXProperty() {
+        return translateX;
+    }
+
+    /// Returns the y offset added after layout.
+    public final double getTranslateY() {
+        return translateY.get();
+    }
+
+    /// Sets the y offset added after layout.
+    public final void setTranslateY(double value) {
+        translateY.set(value);
+    }
+
+    /// The y offset added after layout.
+    public final DoubleProperty translateYProperty() {
+        return translateY;
+    }
+
+    /// Returns the horizontal scale about the centre.
+    public final double getScaleX() {
+        return scaleX.get();
+    }
+
+    /// Sets the horizontal scale about the centre.
+    public final void setScaleX(double value) {
+        scaleX.set(value);
+    }
+
+    /// The horizontal scale about the centre.
+    public final DoubleProperty scaleXProperty() {
+        return scaleX;
+    }
+
+    /// Returns the vertical scale about the centre.
+    public final double getScaleY() {
+        return scaleY.get();
+    }
+
+    /// Sets the vertical scale about the centre.
+    public final void setScaleY(double value) {
+        scaleY.set(value);
+    }
+
+    /// The vertical scale about the centre.
+    public final DoubleProperty scaleYProperty() {
+        return scaleY;
+    }
+
+    /// Returns the clockwise rotation about the centre, in degrees.
+    public final double getRotate() {
+        return rotate.get();
+    }
+
+    /// Sets the clockwise rotation about the centre, in degrees.
+    public final void setRotate(double value) {
+        rotate.set(value);
+    }
+
+    /// The rotation about the centre.
+    public final DoubleProperty rotateProperty() {
+        return rotate;
+    }
+
+    /// Returns the transforms applied to this node, the first one
+    /// outermost: a point of the node goes through the last transform
+    /// first. They take effect between the node's position (`layoutX/Y`
+    /// plus `translateX/Y`) and its own `rotate` and `scaleX/Y`, and are
+    /// part of every conversion between this node's coordinates and its
+    /// parent's, of `getBoundsInParent()`, of picking and of painting.
+    /// They do not change the layout bounds.
+    public final ObservableList<Transform> getTransforms() {
+        if (transforms == null) {
+            transforms = FXCollections.observableArrayList();
+            transforms.addListener(new ListChangeListener<Transform>() {
+                @Override
+                public void onChanged(Change<? extends Transform> change) {
+                    while (change.next()) {
+                        java.util.List<? extends Transform> removed = change.getRemoved();
+                        for (int i = 0; i < removed.size(); i++) {
+                            Transform t = removed.get(i);
+                            if (t != null) {
+                                t.cn1Detach(Node.this);
+                            }
+                        }
+                    }
+                    // A transform may be in the list twice; attaching is
+                    // idempotent, so attach whatever is there now.
+                    for (int i = 0; i < transforms.size(); i++) {
+                        Transform t = transforms.get(i);
+                        if (t != null) {
+                            t.cn1Attach(Node.this);
+                        }
+                    }
+                    cn1Invalidated(Dirty.BOUNDS);
+                }
+            });
+        }
+        return transforms;
+    }
+
+    /// Computes the layout bounds; overridden by every node with a size.
+    protected Bounds cn1ComputeLayoutBounds() {
+        return new BoundingBox(0, 0, 0, 0);
+    }
+
+    /// Returns the rectangle layout uses for this node, in its own
+    /// coordinates.
+    public final Bounds getLayoutBounds() {
+        if (layoutBoundsCache == null) {
+            layoutBoundsCache = cn1ComputeLayoutBounds();
+        }
+        return layoutBoundsCache;
+    }
+
+    /// The rectangle layout uses for this node.
+    public final ReadOnlyObjectProperty<Bounds> layoutBoundsProperty() {
+        if (layoutBoundsProperty == null) {
+            layoutBoundsProperty = new ReadOnlyObjectWrapper<Bounds>(this, "layoutBounds", getLayoutBounds());
+        }
+        return layoutBoundsProperty.getReadOnlyProperty();
+    }
+
+    /// Returns the bounds of what this node draws, in its own coordinates.
+    public final Bounds getBoundsInLocal() {
+        return cn1ComputeBoundsInLocal();
+    }
+
+    /// The bounds of what this node draws.
+    public final ReadOnlyObjectProperty<Bounds> boundsInLocalProperty() {
+        if (boundsInLocalProperty == null) {
+            boundsInLocalProperty = new ReadOnlyObjectWrapper<Bounds>(this, "boundsInLocal", getBoundsInLocal());
+        }
+        return boundsInLocalProperty.getReadOnlyProperty();
+    }
+
+    /// Computes the bounds in local coordinates; the layout bounds unless
+    /// overridden.
+    protected Bounds cn1ComputeBoundsInLocal() {
+        return getLayoutBounds();
+    }
+
+    /// Returns the bounds of this node in its parent's coordinates, after
+    /// every transform.
+    public final Bounds getBoundsInParent() {
+        return transformBounds(getBoundsInLocal(), localToParentMatrix());
+    }
+
+    /// The bounds of this node in its parent's coordinates.
+    public final ReadOnlyObjectProperty<Bounds> boundsInParentProperty() {
+        if (boundsInParentProperty == null) {
+            boundsInParentProperty = new ReadOnlyObjectWrapper<Bounds>(this, "boundsInParent", getBoundsInParent());
+        }
+        return boundsInParentProperty.getReadOnlyProperty();
+    }
+
+    private static Bounds transformBounds(Bounds b, double[] m) {
+        double[] xs = {b.getMinX(), b.getMaxX(), b.getMaxX(), b.getMinX()};
+        double[] ys = {b.getMinY(), b.getMinY(), b.getMaxY(), b.getMaxY()};
+        double minX = Double.MAX_VALUE;
+        double minY = Double.MAX_VALUE;
+        double maxX = -Double.MAX_VALUE;
+        double maxY = -Double.MAX_VALUE;
+        for (int i = 0; i < 4; i++) {
+            double x = m[0] * xs[i] + m[2] * ys[i] + m[4];
+            double y = m[1] * xs[i] + m[3] * ys[i] + m[5];
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+        return new BoundingBox(minX, minY, maxX - minX, maxY - minY);
+    }
+
+    /// Converts a point from this node's coordinates to its parent's.
+    public Point2D localToParent(double localX, double localY) {
+        double[] m = localToParentMatrix();
+        return new Point2D(m[0] * localX + m[2] * localY + m[4], m[1] * localX + m[3] * localY + m[5]);
+    }
+
+    /// Converts a point from this node's coordinates to its parent's.
+    public Point2D localToParent(Point2D localPoint) {
+        return localToParent(localPoint.getX(), localPoint.getY());
+    }
+
+    /// Converts bounds from this node's coordinates to its parent's.
+    public Bounds localToParent(Bounds localBounds) {
+        return transformBounds(localBounds, localToParentMatrix());
+    }
+
+    /// Converts a point from the parent's coordinates to this node's.
+    public Point2D parentToLocal(double parentX, double parentY) {
+        double[] m = localToParentMatrix();
+        double det = m[0] * m[3] - m[1] * m[2];
+        if (det == 0) {
+            return new Point2D(0, 0);
+        }
+        double x = parentX - m[4];
+        double y = parentY - m[5];
+        return new Point2D((m[3] * x - m[2] * y) / det, (m[0] * y - m[1] * x) / det);
+    }
+
+    /// Converts a point from the parent's coordinates to this node's.
+    public Point2D parentToLocal(Point2D parentPoint) {
+        return parentToLocal(parentPoint.getX(), parentPoint.getY());
+    }
+
+    /// Converts a point from this node's coordinates to the scene's.
+    public Point2D localToScene(double localX, double localY) {
+        Point2D p = localToParent(localX, localY);
+        Parent up = getParent();
+        while (up != null) {
+            p = up.localToParent(p.getX(), p.getY());
+            up = up.getParent();
+        }
+        return p;
+    }
+
+    /// Converts a point from this node's coordinates to the scene's.
+    public Point2D localToScene(Point2D localPoint) {
+        return localToScene(localPoint.getX(), localPoint.getY());
+    }
+
+    /// Converts bounds from this node's coordinates to the scene's.
+    public Bounds localToScene(Bounds localBounds) {
+        Bounds b = localToParent(localBounds);
+        Parent up = getParent();
+        while (up != null) {
+            b = up.localToParent(b);
+            up = up.getParent();
+        }
+        return b;
+    }
+
+    /// The position of the scene on the screen: where the window is plus
+    /// where the scene is in it. Answers false for a node in no window.
+    private boolean sceneOnScreen(double[] origin) {
+        Scene sc = getScene();
+        if (sc == null || sc.getWindow() == null) {
+            return false;
+        }
+        double wx = sc.getWindow().getX();
+        double wy = sc.getWindow().getY();
+        origin[0] = (Double.isNaN(wx) ? 0 : wx) + sc.getX();
+        origin[1] = (Double.isNaN(wy) ? 0 : wy) + sc.getY();
+        return true;
+    }
+
+    /// Converts a local point to the coordinates of the screen, or
+    /// `null` for a node that is in no window.
+    public Point2D localToScreen(double localX, double localY) {
+        double[] origin = new double[2];
+        if (!sceneOnScreen(origin)) {
+            return null;
+        }
+        Point2D p = localToScene(localX, localY);
+        return new Point2D(p.getX() + origin[0], p.getY() + origin[1]);
+    }
+
+    /// Converts a local point to the coordinates of the screen.
+    public Point2D localToScreen(Point2D localPoint) {
+        return localToScreen(localPoint.getX(), localPoint.getY());
+    }
+
+    /// Converts a point of the screen to local coordinates, or `null`
+    /// for a node that is in no window.
+    public Point2D screenToLocal(double screenX, double screenY) {
+        double[] origin = new double[2];
+        if (!sceneOnScreen(origin)) {
+            return null;
+        }
+        return sceneToLocal(screenX - origin[0], screenY - origin[1]);
+    }
+
+    /// Converts a point of the screen to local coordinates.
+    public Point2D screenToLocal(Point2D screenPoint) {
+        return screenToLocal(screenPoint.getX(), screenPoint.getY());
+    }
+
+    /// Converts a point from the scene's coordinates to this node's.
+    public Point2D sceneToLocal(double sceneX, double sceneY) {
+        Parent up = getParent();
+        Point2D p = up == null ? new Point2D(sceneX, sceneY) : up.sceneToLocal(sceneX, sceneY);
+        return parentToLocal(p.getX(), p.getY());
+    }
+
+    /// Converts a point from the scene's coordinates to this node's.
+    public Point2D sceneToLocal(Point2D scenePoint) {
+        return sceneToLocal(scenePoint.getX(), scenePoint.getY());
+    }
+
+    /// Returns whether a point in this node's coordinates is on the node.
+    public boolean contains(double localX, double localY) {
+        return getLayoutBounds().contains(localX, localY);
+    }
+
+    /// Returns whether a point in this node's coordinates is on the node.
+    public boolean contains(Point2D localPoint) {
+        return contains(localPoint.getX(), localPoint.getY());
+    }
+
+    /// Returns whether a rectangle in this node's coordinates touches it.
+    public boolean intersects(double localX, double localY, double localWidth, double localHeight) {
+        return getBoundsInLocal().intersects(localX, localY, localWidth, localHeight);
+    }
+
+    /// Returns whether bounds in this node's coordinates touch it.
+    public boolean intersects(Bounds localBounds) {
+        return getBoundsInLocal().intersects(localBounds);
+    }
+
+    /// Returns the node under a point given in the parent's coordinates:
+    /// this node, one below it, or `null`.
+    public Node cn1Pick(double parentX, double parentY) {
+        if (!isVisible() || isMouseTransparent()) {
+            return null;
+        }
+        Point2D local = parentToLocal(parentX, parentY);
+        Node by = getClip();
+        if (by != null && !by.getBoundsInParent().contains(local.getX(), local.getY())) {
+            return null;
+        }
+        return cn1PickLocal(local.getX(), local.getY());
+    }
+
+    /// Returns the node under a point in this node's coordinates.
+    protected Node cn1PickLocal(double x, double y) {
+        if (isPickOnBounds() ? getLayoutBounds().contains(x, y) : contains(x, y)) {
+            return this;
+        }
+        return null;
+    }
+
+    // ------------------------------------------------------------ layout
+
+    /// Returns whether a parent may resize this node.
+    public boolean isResizable() {
+        return false;
+    }
+
+    /// Returns whether one dimension of the preferred size depends on the
+    /// other, and which leads; `null` when they are independent.
+    public Orientation getContentBias() {
+        return null;
+    }
+
+    /// Returns the smallest width this node can take.
+    public double minWidth(double height) {
+        return prefWidth(height);
+    }
+
+    /// Returns the smallest height this node can take.
+    public double minHeight(double width) {
+        return prefHeight(width);
+    }
+
+    /// Returns the width this node would like.
+    public double prefWidth(double height) {
+        double w = getLayoutBounds().getWidth();
+        return Double.isNaN(w) || w < 0 ? 0 : w;
+    }
+
+    /// Returns the height this node would like.
+    public double prefHeight(double width) {
+        double h = getLayoutBounds().getHeight();
+        return Double.isNaN(h) || h < 0 ? 0 : h;
+    }
+
+    /// Returns the largest width this node can take.
+    public double maxWidth(double height) {
+        return prefWidth(height);
+    }
+
+    /// Returns the largest height this node can take.
+    public double maxHeight(double width) {
+        return prefHeight(width);
+    }
+
+    /// Sets the size of a resizable node; does nothing for others.
+    public void resize(double width, double height) {
+    }
+
+    /// Moves the node so the top left corner of its layout bounds is at a
+    /// point of the parent.
+    public void relocate(double x, double y) {
+        Bounds lb = getLayoutBounds();
+        setLayoutX(x - lb.getMinX());
+        setLayoutY(y - lb.getMinY());
+    }
+
+    /// Resizes and moves the node.
+    public void resizeRelocate(double x, double y, double width, double height) {
+        resize(width, height);
+        relocate(x, y);
+    }
+
+    /// Gives a resizable node its preferred size.
+    public final void autosize() {
+        if (isResizable()) {
+            Orientation bias = getContentBias();
+            double w;
+            double h;
+            if (bias == null) {
+                w = bounded(prefWidth(-1), minWidth(-1), maxWidth(-1));
+                h = bounded(prefHeight(-1), minHeight(-1), maxHeight(-1));
+            } else if (bias == Orientation.HORIZONTAL) {
+                w = bounded(prefWidth(-1), minWidth(-1), maxWidth(-1));
+                h = bounded(prefHeight(w), minHeight(w), maxHeight(w));
+            } else {
+                h = bounded(prefHeight(-1), minHeight(-1), maxHeight(-1));
+                w = bounded(prefWidth(h), minWidth(h), maxWidth(h));
+            }
+            resize(w, h);
+        }
+    }
+
+    private static double bounded(double value, double min, double max) {
+        return Math.min(Math.max(value, min), Math.max(min, max));
+    }
+
+    /// Returns the distance from the top of the layout bounds to the
+    /// baseline of the node's text; the bottom edge when it has none.
+    public double getBaselineOffset() {
+        Bounds lb = getLayoutBounds();
+        return lb.getMinY() + lb.getHeight();
+    }
+
+    // ------------------------------------------------------------ events
+
+    /// Returns the filters and handlers of this node.
+    protected final EventHandlerManager cn1Events() {
+        if (events == null) {
+            events = new EventHandlerManager(this);
+        }
+        return events;
+    }
+
+    /// Adds a handler called in the bubbling phase.
+    public final <T extends Event> void addEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        cn1Events().addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler.
+    public final <T extends Event> void removeEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        cn1Events().removeEventHandler(eventType, eventHandler);
+    }
+
+    /// Adds a filter called in the capturing phase.
+    public final <T extends Event> void addEventFilter(EventType<T> eventType,
+            EventHandler<? super T> eventFilter) {
+        cn1Events().addEventFilter(eventType, eventFilter);
+    }
+
+    /// Removes a filter.
+    public final <T extends Event> void removeEventFilter(EventType<T> eventType,
+            EventHandler<? super T> eventFilter) {
+        cn1Events().removeEventFilter(eventType, eventFilter);
+    }
+
+    /// Sets the one convenience handler of an event type; for subclasses
+    /// that offer `setOn...` methods.
+    protected final <T extends Event> void setEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        cn1Events().setSlot(eventType, eventType.getName(), eventHandler);
+    }
+
+    /// Delivers an event to this node through the scene graph.
+    public final void fireEvent(Event event) {
+        Event.fireEvent(this, event);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        EventDispatchChain chain = tail;
+        Node n = this;
+        while (n != null) {
+            if (n.events != null) {
+                chain = chain.prepend(n.events);
+            }
+            n = n.getParent();
+        }
+        Scene s = getScene();
+        if (s != null) {
+            chain = s.buildEventDispatchChain(chain);
+        }
+        return chain;
+    }
+
+    private <T extends Event> ObjectProperty<EventHandler<? super T>> on(EventType<T> type, String name) {
+        return cn1Events().slot(type, name);
+    }
+
+    private <T extends Event> EventHandler<? super T> handler(EventType<T> type) {
+        return events == null ? null : events.getSlot(type);
+    }
+
+    /// Sets the handler of a swipe upwards that began on this node.
+    public final void setOnSwipeUp(EventHandler<? super SwipeEvent> value) {
+        cn1Events().setSlot(SwipeEvent.SWIPE_UP, "onSwipeUp", value);
+    }
+
+    /// Returns the handler of a swipe upwards.
+    public final EventHandler<? super SwipeEvent> getOnSwipeUp() {
+        return handler(SwipeEvent.SWIPE_UP);
+    }
+
+    /// The handler of a swipe upwards.
+    public final ObjectProperty<EventHandler<? super SwipeEvent>> onSwipeUpProperty() {
+        return on(SwipeEvent.SWIPE_UP, "onSwipeUp");
+    }
+
+    /// Sets the handler of a swipe downwards that began on this node.
+    public final void setOnSwipeDown(EventHandler<? super SwipeEvent> value) {
+        cn1Events().setSlot(SwipeEvent.SWIPE_DOWN, "onSwipeDown", value);
+    }
+
+    /// Returns the handler of a swipe downwards.
+    public final EventHandler<? super SwipeEvent> getOnSwipeDown() {
+        return handler(SwipeEvent.SWIPE_DOWN);
+    }
+
+    /// The handler of a swipe downwards.
+    public final ObjectProperty<EventHandler<? super SwipeEvent>> onSwipeDownProperty() {
+        return on(SwipeEvent.SWIPE_DOWN, "onSwipeDown");
+    }
+
+    /// Sets the handler of a swipe to the left that began on this node.
+    public final void setOnSwipeLeft(EventHandler<? super SwipeEvent> value) {
+        cn1Events().setSlot(SwipeEvent.SWIPE_LEFT, "onSwipeLeft", value);
+    }
+
+    /// Returns the handler of a swipe to the left.
+    public final EventHandler<? super SwipeEvent> getOnSwipeLeft() {
+        return handler(SwipeEvent.SWIPE_LEFT);
+    }
+
+    /// The handler of a swipe to the left.
+    public final ObjectProperty<EventHandler<? super SwipeEvent>> onSwipeLeftProperty() {
+        return on(SwipeEvent.SWIPE_LEFT, "onSwipeLeft");
+    }
+
+    /// Sets the handler of a swipe to the right that began on this node.
+    public final void setOnSwipeRight(EventHandler<? super SwipeEvent> value) {
+        cn1Events().setSlot(SwipeEvent.SWIPE_RIGHT, "onSwipeRight", value);
+    }
+
+    /// Returns the handler of a swipe to the right.
+    public final EventHandler<? super SwipeEvent> getOnSwipeRight() {
+        return handler(SwipeEvent.SWIPE_RIGHT);
+    }
+
+    /// The handler of a swipe to the right.
+    public final ObjectProperty<EventHandler<? super SwipeEvent>> onSwipeRightProperty() {
+        return on(SwipeEvent.SWIPE_RIGHT, "onSwipeRight");
+    }
+
+    /// Sets the handler of a finger going down on this node. The scene
+    /// produces no touch events of its own, see [TouchEvent].
+    public final void setOnTouchPressed(EventHandler<? super TouchEvent> value) {
+        cn1Events().setSlot(TouchEvent.TOUCH_PRESSED, "onTouchPressed", value);
+    }
+
+    /// Returns the handler of a finger going down.
+    public final EventHandler<? super TouchEvent> getOnTouchPressed() {
+        return handler(TouchEvent.TOUCH_PRESSED);
+    }
+
+    /// The handler of a finger going down.
+    public final ObjectProperty<EventHandler<? super TouchEvent>> onTouchPressedProperty() {
+        return on(TouchEvent.TOUCH_PRESSED, "onTouchPressed");
+    }
+
+    /// Sets the handler of a finger moving on this node. The scene
+    /// produces no touch events of its own, see [TouchEvent].
+    public final void setOnTouchMoved(EventHandler<? super TouchEvent> value) {
+        cn1Events().setSlot(TouchEvent.TOUCH_MOVED, "onTouchMoved", value);
+    }
+
+    /// Returns the handler of a finger moving.
+    public final EventHandler<? super TouchEvent> getOnTouchMoved() {
+        return handler(TouchEvent.TOUCH_MOVED);
+    }
+
+    /// The handler of a finger moving.
+    public final ObjectProperty<EventHandler<? super TouchEvent>> onTouchMovedProperty() {
+        return on(TouchEvent.TOUCH_MOVED, "onTouchMoved");
+    }
+
+    /// Sets the handler of a finger being lifted from this node. The
+    /// scene produces no touch events of its own, see [TouchEvent].
+    public final void setOnTouchReleased(EventHandler<? super TouchEvent> value) {
+        cn1Events().setSlot(TouchEvent.TOUCH_RELEASED, "onTouchReleased", value);
+    }
+
+    /// Returns the handler of a finger being lifted.
+    public final EventHandler<? super TouchEvent> getOnTouchReleased() {
+        return handler(TouchEvent.TOUCH_RELEASED);
+    }
+
+    /// The handler of a finger being lifted.
+    public final ObjectProperty<EventHandler<? super TouchEvent>> onTouchReleasedProperty() {
+        return on(TouchEvent.TOUCH_RELEASED, "onTouchReleased");
+    }
+
+    /// Sets the handler of a finger resting on this node. The scene
+    /// produces no touch events of its own, see [TouchEvent].
+    public final void setOnTouchStationary(EventHandler<? super TouchEvent> value) {
+        cn1Events().setSlot(TouchEvent.TOUCH_STATIONARY, "onTouchStationary", value);
+    }
+
+    /// Returns the handler of a finger resting.
+    public final EventHandler<? super TouchEvent> getOnTouchStationary() {
+        return handler(TouchEvent.TOUCH_STATIONARY);
+    }
+
+    /// The handler of a finger resting.
+    public final ObjectProperty<EventHandler<? super TouchEvent>> onTouchStationaryProperty() {
+        return on(TouchEvent.TOUCH_STATIONARY, "onTouchStationary");
+    }
+
+    /// Sets the handler of a click on this node.
+    public final void setOnMouseClicked(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_CLICKED, "onMouseClicked", value);
+    }
+
+    /// Returns the handler of a click on this node.
+    public final EventHandler<? super MouseEvent> getOnMouseClicked() {
+        return handler(MouseEvent.MOUSE_CLICKED);
+    }
+
+    /// The handler of a click on this node.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMouseClickedProperty() {
+        return on(MouseEvent.MOUSE_CLICKED, "onMouseClicked");
+    }
+
+    /// Sets the handler of a button going down on this node.
+    public final void setOnMousePressed(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_PRESSED, "onMousePressed", value);
+    }
+
+    /// Returns the handler of a button going down on this node.
+    public final EventHandler<? super MouseEvent> getOnMousePressed() {
+        return handler(MouseEvent.MOUSE_PRESSED);
+    }
+
+    /// The handler of a button going down on this node.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMousePressedProperty() {
+        return on(MouseEvent.MOUSE_PRESSED, "onMousePressed");
+    }
+
+    /// Sets the handler of a button coming up.
+    public final void setOnMouseReleased(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_RELEASED, "onMouseReleased", value);
+    }
+
+    /// Returns the handler of a button coming up.
+    public final EventHandler<? super MouseEvent> getOnMouseReleased() {
+        return handler(MouseEvent.MOUSE_RELEASED);
+    }
+
+    /// The handler of a button coming up.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMouseReleasedProperty() {
+        return on(MouseEvent.MOUSE_RELEASED, "onMouseReleased");
+    }
+
+    /// Sets the handler of the pointer moving with a button down.
+    public final void setOnMouseDragged(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_DRAGGED, "onMouseDragged", value);
+    }
+
+    /// Returns the handler of the pointer moving with a button down.
+    public final EventHandler<? super MouseEvent> getOnMouseDragged() {
+        return handler(MouseEvent.MOUSE_DRAGGED);
+    }
+
+    /// The handler of the pointer moving with a button down.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMouseDraggedProperty() {
+        return on(MouseEvent.MOUSE_DRAGGED, "onMouseDragged");
+    }
+
+    /// Sets the handler of the pointer moving with no button down.
+    public final void setOnMouseMoved(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_MOVED, "onMouseMoved", value);
+    }
+
+    /// Returns the handler of the pointer moving with no button down.
+    public final EventHandler<? super MouseEvent> getOnMouseMoved() {
+        return handler(MouseEvent.MOUSE_MOVED);
+    }
+
+    /// The handler of the pointer moving with no button down.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMouseMovedProperty() {
+        return on(MouseEvent.MOUSE_MOVED, "onMouseMoved");
+    }
+
+    /// Sets the handler of the pointer entering this node.
+    public final void setOnMouseEntered(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_ENTERED, "onMouseEntered", value);
+    }
+
+    /// Returns the handler of the pointer entering this node.
+    public final EventHandler<? super MouseEvent> getOnMouseEntered() {
+        return handler(MouseEvent.MOUSE_ENTERED);
+    }
+
+    /// The handler of the pointer entering this node.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMouseEnteredProperty() {
+        return on(MouseEvent.MOUSE_ENTERED, "onMouseEntered");
+    }
+
+    /// Sets the handler of the pointer leaving this node.
+    public final void setOnMouseExited(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.MOUSE_EXITED, "onMouseExited", value);
+    }
+
+    /// Returns the handler of the pointer leaving this node.
+    public final EventHandler<? super MouseEvent> getOnMouseExited() {
+        return handler(MouseEvent.MOUSE_EXITED);
+    }
+
+    /// The handler of the pointer leaving this node.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onMouseExitedProperty() {
+        return on(MouseEvent.MOUSE_EXITED, "onMouseExited");
+    }
+
+    /// Sets the handler of a drag gesture being recognised.
+    public final void setOnDragDetected(EventHandler<? super MouseEvent> value) {
+        cn1Events().setSlot(MouseEvent.DRAG_DETECTED, "onDragDetected", value);
+    }
+
+    /// Returns the handler of a drag gesture being recognised.
+    public final EventHandler<? super MouseEvent> getOnDragDetected() {
+        return handler(MouseEvent.DRAG_DETECTED);
+    }
+
+    /// The handler of a drag gesture being recognised.
+    public final ObjectProperty<EventHandler<? super MouseEvent>> onDragDetectedProperty() {
+        return on(MouseEvent.DRAG_DETECTED, "onDragDetected");
+    }
+
+    /// Sets the handler of a key going down while this node has the focus.
+    public final void setOnKeyPressed(EventHandler<? super KeyEvent> value) {
+        cn1Events().setSlot(KeyEvent.KEY_PRESSED, "onKeyPressed", value);
+    }
+
+    /// Returns the handler of a key going down.
+    public final EventHandler<? super KeyEvent> getOnKeyPressed() {
+        return handler(KeyEvent.KEY_PRESSED);
+    }
+
+    /// The handler of a key going down.
+    public final ObjectProperty<EventHandler<? super KeyEvent>> onKeyPressedProperty() {
+        return on(KeyEvent.KEY_PRESSED, "onKeyPressed");
+    }
+
+    /// Sets the handler of a key coming up.
+    public final void setOnKeyReleased(EventHandler<? super KeyEvent> value) {
+        cn1Events().setSlot(KeyEvent.KEY_RELEASED, "onKeyReleased", value);
+    }
+
+    /// Returns the handler of a key coming up.
+    public final EventHandler<? super KeyEvent> getOnKeyReleased() {
+        return handler(KeyEvent.KEY_RELEASED);
+    }
+
+    /// The handler of a key coming up.
+    public final ObjectProperty<EventHandler<? super KeyEvent>> onKeyReleasedProperty() {
+        return on(KeyEvent.KEY_RELEASED, "onKeyReleased");
+    }
+
+    /// Sets the handler of a character being typed.
+    public final void setOnKeyTyped(EventHandler<? super KeyEvent> value) {
+        cn1Events().setSlot(KeyEvent.KEY_TYPED, "onKeyTyped", value);
+    }
+
+    /// Returns the handler of a character being typed.
+    public final EventHandler<? super KeyEvent> getOnKeyTyped() {
+        return handler(KeyEvent.KEY_TYPED);
+    }
+
+    /// The handler of a character being typed.
+    public final ObjectProperty<EventHandler<? super KeyEvent>> onKeyTypedProperty() {
+        return on(KeyEvent.KEY_TYPED, "onKeyTyped");
+    }
+
+    /// Sets the handler of the wheel scrolling over this node.
+    public final void setOnScroll(EventHandler<? super ScrollEvent> value) {
+        cn1Events().setSlot(ScrollEvent.SCROLL, "onScroll", value);
+    }
+
+    /// Returns the handler of the wheel scrolling over this node.
+    public final EventHandler<? super ScrollEvent> getOnScroll() {
+        return handler(ScrollEvent.SCROLL);
+    }
+
+    /// The handler of the wheel scrolling over this node.
+    public final ObjectProperty<EventHandler<? super ScrollEvent>> onScrollProperty() {
+        return on(ScrollEvent.SCROLL, "onScroll");
+    }
+
+    /// Sets the handler of a context menu being asked for.
+    public final void setOnContextMenuRequested(EventHandler<? super ContextMenuEvent> value) {
+        cn1Events().setSlot(ContextMenuEvent.CONTEXT_MENU_REQUESTED, "onContextMenuRequested", value);
+    }
+
+    /// Returns the handler of a context menu being asked for.
+    public final EventHandler<? super ContextMenuEvent> getOnContextMenuRequested() {
+        return handler(ContextMenuEvent.CONTEXT_MENU_REQUESTED);
+    }
+
+    /// The handler of a context menu being asked for.
+    public final ObjectProperty<EventHandler<? super ContextMenuEvent>> onContextMenuRequestedProperty() {
+        return on(ContextMenuEvent.CONTEXT_MENU_REQUESTED, "onContextMenuRequested");
+    }
+
+    /// Returns the class name and, when set, the id and style classes.
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder(getTypeSelector());
+        String nodeId = getId();
+        if (nodeId != null && nodeId.length() > 0) {
+            s.append("[id=").append(nodeId).append(']');
+        }
+        if (!styleClass.isEmpty()) {
+            s.append(styleClass);
+        }
+        return s.toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/Parent.java b/maven/javafx-compat/src/main/java/javafx/scene/Parent.java
new file mode 100644
index 00000000000..aeafad6e93f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/Parent.java
@@ -0,0 +1,708 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.codename1.fxcompat.runtime.FxPeer;
+import com.codename1.fxcompat.runtime.ParentPeer;
+import com.codename1.fxcompat.runtime.StyleEngine;
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ModifiableObservableListBase;
+import javafx.collections.ObservableList;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+
+/// A node with children.
+///
+/// The peer of a parent is a Codename One container that holds the peers
+/// of the children in the same order. Layout does not run in that
+/// container: [#layout()] runs on the nodes, from the root of the scene,
+/// and every node pushes its own bounds into its peer.
+///
+/// A parent that is not a region has no size of its own: its layout
+/// bounds are the union of its children's bounds.
+public abstract class Parent extends Node {
+
+    private final ObservableList<Node> children = new Children(this);
+    private final ObservableList<Node> unmodifiableChildren = FXCollections.unmodifiableObservableList(children);
+    private ObservableList<String> stylesheets;
+    private final ReadOnlyBooleanWrapper needsLayout = new ReadOnlyBooleanWrapper(this, "needsLayout", true);
+    private boolean performingLayout;
+    private double prefWidthCache = -1;
+    private double prefHeightCache = -1;
+    private double minWidthCache = -1;
+    private double minHeightCache = -1;
+
+    /// Creates a parent with no children.
+    protected Parent() {
+        children.addListener(new ListChangeListener<Node>() {
+            @Override
+            public void onChanged(Change<? extends Node> change) {
+                childrenChanged(change);
+            }
+        });
+    }
+
+    private void childrenChanged(ListChangeListener.Change<? extends Node> change) {
+        while (change.next()) {
+            if (change.wasPermutated()) {
+                continue;
+            }
+            List<? extends Node> removed = change.getRemoved();
+            for (int i = 0; i < removed.size(); i++) {
+                Node n = removed.get(i);
+                if (n.getParent() == this && !children.contains(n)) {
+                    n.setParentInternal(null);
+                    n.setSceneInternal(null);
+                }
+            }
+            // Every added node was checked by Children.validate before the
+            // list changed; what is left here is moving it in.
+            List<? extends Node> added = change.getAddedSubList();
+            for (int i = 0; i < added.size(); i++) {
+                Node n = added.get(i);
+                Parent old = n.getParent();
+                if (old == this) {
+                    continue;
+                }
+                if (old != null) {
+                    old.children.remove(n);
+                }
+                n.setParentInternal(this);
+                n.setSceneInternal(getScene());
+            }
+        }
+        if (cn1HasPeer()) {
+            syncPeerChildren();
+        }
+        requestLayout();
+        if (cn1SizedByChildren()) {
+            cn1GeometryChanged();
+        }
+        cn1Repaint();
+    }
+
+    /// Returns the number of components at the start of the peer that are
+    /// not children: a control keeps its native component there.
+    protected int cn1PeerChildOffset() {
+        return 0;
+    }
+
+    private void syncPeerChildren() {
+        Component c = cn1Peer();
+        if (!(c instanceof Container)) {
+            return;
+        }
+        Container peer = (Container) c;
+        int offset = cn1PeerChildOffset();
+        for (int i = peer.getComponentCount() - 1; i >= offset; i--) {
+            Component child = peer.getComponentAt(i);
+            Node n = child instanceof FxPeer ? ((FxPeer) child).node() : null;
+            if (n == null || n.getParent() != this) {
+                peer.removeComponent(child);
+            }
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Component expected = children.get(i).cn1Peer();
+            int at = offset + i;
+            if (at < peer.getComponentCount() && peer.getComponentAt(at) == expected) {
+                continue;
+            }
+            Container holder = expected.getParent();
+            if (holder != null) {
+                holder.removeComponent(expected);
+            }
+            if (at >= peer.getComponentCount()) {
+                peer.addComponent(expected);
+            } else {
+                peer.addComponent(at, expected);
+            }
+        }
+    }
+
+    /// Returns the modifiable list of children, for a constructor: unlike
+    /// [#getChildren()] it cannot be overridden, so it is safe to call
+    /// before a subclass is initialized.
+    protected final ObservableList<Node> cn1Children() {
+        return children;
+    }
+
+    @Override
+    protected Component cn1CreatePeer() {
+        return new ParentPeer(this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        syncPeerChildren();
+    }
+
+    /// Returns the modifiable list of children; public in the panes.
+    protected ObservableList<Node> getChildren() {
+        return children;
+    }
+
+    /// Returns a read-only view of the children.
+    public ObservableList<Node> getChildrenUnmodifiable() {
+        return unmodifiableChildren;
+    }
+
+    /// Returns the children the layout places: the managed ones.
+    protected <E extends Node> List<E> getManagedChildren() {
+        ArrayList<E> managed = new ArrayList<E>();
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n.isManaged()) {
+                @SuppressWarnings("unchecked")
+                E e = (E) n;
+                managed.add(e);
+            }
+        }
+        return managed;
+    }
+
+    /// Returns whether this parent has style sheets of its own, without
+    /// creating the list [#getStylesheets()] answers.
+    public final boolean cn1HasStylesheets() {
+        return stylesheets != null && !stylesheets.isEmpty();
+    }
+
+    /// Returns the style sheet locations of this parent. The list is
+    /// passed to the installed style engine; without one it has no effect.
+    public final ObservableList<String> getStylesheets() {
+        if (stylesheets == null) {
+            stylesheets = FXCollections.observableArrayList();
+            stylesheets.addListener(new ListChangeListener<String>() {
+                @Override
+                public void onChanged(Change<? extends String> change) {
+                    StyleEngine.getInstance().stylesheetsChanged(Parent.this);
+                }
+            });
+        }
+        return stylesheets;
+    }
+
+    @Override
+    void setSceneInternal(Scene value) {
+        super.setSceneInternal(value);
+        for (int i = 0; i < children.size(); i++) {
+            children.get(i).setSceneInternal(value);
+        }
+    }
+
+    @Override
+    void cn1DisabledChanged() {
+        for (int i = 0; i < children.size(); i++) {
+            children.get(i).updateDisabled();
+        }
+    }
+
+    @Override
+    void collect(String compound, Set<Node> into) {
+        super.collect(compound, into);
+        for (int i = 0; i < children.size(); i++) {
+            children.get(i).collect(compound, into);
+        }
+    }
+
+    final void cn1ToFront(Node child) {
+        int at = children.indexOf(child);
+        if (at >= 0 && at != children.size() - 1) {
+            children.remove(at);
+            children.add(child);
+        }
+    }
+
+    final void cn1ToBack(Node child) {
+        int at = children.indexOf(child);
+        if (at > 0) {
+            children.remove(at);
+            children.add(0, child);
+        }
+    }
+
+    // ---------------------------------------------------------- geometry
+
+    /// Returns whether the layout bounds of this parent are the union of
+    /// its children's bounds, which is so unless it is a region.
+    protected boolean cn1SizedByChildren() {
+        return true;
+    }
+
+    final void cn1ChildBoundsChanged(Node child) {
+        if (cn1SizedByChildren() && !performingLayout && cn1LayoutBoundsStale(unionOfChildren())) {
+            cn1GeometryChanged();
+            for (int i = 0; i < children.size(); i++) {
+                children.get(i).cn1SyncPeerBounds();
+            }
+        }
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        return unionOfChildren();
+    }
+
+    private Bounds unionOfChildren() {
+        double minX = Double.MAX_VALUE;
+        double minY = Double.MAX_VALUE;
+        double maxX = -Double.MAX_VALUE;
+        double maxY = -Double.MAX_VALUE;
+        boolean any = false;
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (!n.isVisible()) {
+                continue;
+            }
+            Bounds b = n.getBoundsInParent();
+            if (b.getWidth() < 0 || b.getHeight() < 0) {
+                continue;
+            }
+            any = true;
+            minX = Math.min(minX, b.getMinX());
+            minY = Math.min(minY, b.getMinY());
+            maxX = Math.max(maxX, b.getMaxX());
+            maxY = Math.max(maxY, b.getMaxY());
+        }
+        if (!any) {
+            return new BoundingBox(0, 0, 0, 0);
+        }
+        return new BoundingBox(minX, minY, maxX - minX, maxY - minY);
+    }
+
+    @Override
+    public boolean contains(double localX, double localY) {
+        for (int i = children.size() - 1; i >= 0; i--) {
+            Node n = children.get(i);
+            if (n.isVisible()) {
+                javafx.geometry.Point2D p = n.parentToLocal(localX, localY);
+                if (n.contains(p.getX(), p.getY())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    protected Node cn1PickLocal(double x, double y) {
+        for (int i = children.size() - 1; i >= 0; i--) {
+            Node hit = children.get(i).cn1Pick(x, y);
+            if (hit != null) {
+                return hit;
+            }
+        }
+        return cn1PickSelf(x, y) ? this : null;
+    }
+
+    /// Returns whether a point that hit no child hits this parent itself.
+    protected boolean cn1PickSelf(double x, double y) {
+        return isPickOnBounds() && getLayoutBounds().contains(x, y);
+    }
+
+    // ------------------------------------------------------------ layout
+
+    /// Returns whether the layout of this parent is out of date.
+    public final boolean isNeedsLayout() {
+        return needsLayout.get();
+    }
+
+    /// Whether the layout of this parent is out of date.
+    public final ReadOnlyBooleanProperty needsLayoutProperty() {
+        return needsLayout.getReadOnlyProperty();
+    }
+
+    /// Sets whether the layout is out of date; for subclasses.
+    protected final void setNeedsLayout(boolean value) {
+        needsLayout.set(value);
+    }
+
+    /// Marks the layout of this parent and of its ancestors as out of
+    /// date. It runs before the next frame.
+    public void requestLayout() {
+        prefWidthCache = -1;
+        prefHeightCache = -1;
+        minWidthCache = -1;
+        minHeightCache = -1;
+        cn1ClearSizeCache();
+        if (performingLayout) {
+            return;
+        }
+        needsLayout.set(true);
+        Parent p = getParent();
+        if (p != null) {
+            p.requestLayout();
+        } else {
+            Scene s = getScene();
+            if (s != null) {
+                s.cn1RequestPulse();
+            }
+        }
+    }
+
+    /// Called when cached sizes are no longer valid.
+    protected void cn1ClearSizeCache() {
+    }
+
+    /// Marks this parent alone as needing layout, without telling its
+    /// ancestors; used when a parent resizes it during their own layout.
+    protected final void cn1MarkNeedsLayout() {
+        needsLayout.set(true);
+    }
+
+    /// Lays out this parent and everything below it that needs it.
+    public final void layout() {
+        if (needsLayout.get()) {
+            needsLayout.set(false);
+            performingLayout = true;
+            try {
+                layoutChildren();
+            } finally {
+                performingLayout = false;
+            }
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n instanceof Parent) {
+                ((Parent) n).layout();
+            }
+        }
+        if (cn1SizedByChildren()) {
+            cn1ChildBoundsChanged(null);
+        }
+    }
+
+    /// Places the children. The default gives every managed resizable
+    /// child its preferred size and leaves it where it is.
+    protected void layoutChildren() {
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n.isResizable() && n.isManaged()) {
+                n.autosize();
+            }
+        }
+    }
+
+    @Override
+    public double prefWidth(double height) {
+        if (height == -1) {
+            if (prefWidthCache == -1) {
+                prefWidthCache = clean(computePrefWidth(-1));
+            }
+            return prefWidthCache;
+        }
+        return clean(computePrefWidth(height));
+    }
+
+    @Override
+    public double prefHeight(double width) {
+        if (width == -1) {
+            if (prefHeightCache == -1) {
+                prefHeightCache = clean(computePrefHeight(-1));
+            }
+            return prefHeightCache;
+        }
+        return clean(computePrefHeight(width));
+    }
+
+    @Override
+    public double minWidth(double height) {
+        if (height == -1) {
+            if (minWidthCache == -1) {
+                minWidthCache = clean(computeMinWidth(-1));
+            }
+            return minWidthCache;
+        }
+        return clean(computeMinWidth(height));
+    }
+
+    @Override
+    public double minHeight(double width) {
+        if (width == -1) {
+            if (minHeightCache == -1) {
+                minHeightCache = clean(computeMinHeight(-1));
+            }
+            return minHeightCache;
+        }
+        return clean(computeMinHeight(width));
+    }
+
+    private static double clean(double v) {
+        return Double.isNaN(v) || v < 0 ? 0 : v;
+    }
+
+    /// Computes the preferred width: the extent of the managed children at
+    /// their preferred sizes.
+    protected double computePrefWidth(double height) {
+        double minX = 0;
+        double maxX = 0;
+        boolean first = true;
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n.isManaged()) {
+                double x = n.getLayoutBounds().getMinX() + n.getLayoutX();
+                double right = x + Math.max(n.minWidth(-1), Math.min(n.prefWidth(-1), n.maxWidth(-1)));
+                minX = first ? x : Math.min(minX, x);
+                maxX = first ? right : Math.max(maxX, right);
+                first = false;
+            }
+        }
+        return maxX - minX;
+    }
+
+    /// Computes the preferred height: the extent of the managed children
+    /// at their preferred sizes.
+    protected double computePrefHeight(double width) {
+        double minY = 0;
+        double maxY = 0;
+        boolean first = true;
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n.isManaged()) {
+                double y = n.getLayoutBounds().getMinY() + n.getLayoutY();
+                double bottom = y + Math.max(n.minHeight(-1), Math.min(n.prefHeight(-1), n.maxHeight(-1)));
+                minY = first ? y : Math.min(minY, y);
+                maxY = first ? bottom : Math.max(maxY, bottom);
+                first = false;
+            }
+        }
+        return maxY - minY;
+    }
+
+    /// Computes the minimum width; the preferred width unless overridden.
+    protected double computeMinWidth(double height) {
+        return prefWidth(height);
+    }
+
+    /// Computes the minimum height; the preferred height unless
+    /// overridden.
+    protected double computeMinHeight(double width) {
+        return prefHeight(width);
+    }
+
+    @Override
+    public double getBaselineOffset() {
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n.isManaged()) {
+                double offset = n.getBaselineOffset();
+                if (offset == BASELINE_OFFSET_SAME_AS_HEIGHT) {
+                    continue;
+                }
+                return n.getLayoutBounds().getMinY() + n.getLayoutY() + offset;
+            }
+        }
+        return super.getBaselineOffset();
+    }
+
+    /// The children list, which refuses a change before making it, as
+    /// OpenJFX's does (a `VetoableListDecorator` whose `onProposedChange`
+    /// throws): a rejected `add` leaves the list, and every node, as it
+    /// was. Checked in a change listener instead, the node had already gone
+    /// in when the exception came, and stayed.
+    ///
+    /// Every way in is covered by the four entry points that take new
+    /// nodes: `add(E)`, `addAll(E...)`, sub lists and list iterators all
+    /// end in `add(int, E)`, `set`, `addAll(int, Collection)` or `setAll`.
+    private static final class Children extends ModifiableObservableListBase<Node>
+            implements java.util.RandomAccess {
+        private final Parent owner;
+        private final ArrayList<Node> items = new ArrayList<Node>();
+        /// Above zero while a checked batch adds its nodes one at a time.
+        private int batch;
+
+        Children(Parent owner) {
+            this.owner = owner;
+        }
+
+        @Override
+        public Node get(int index) {
+            return items.get(index);
+        }
+
+        @Override
+        public int size() {
+            return items.size();
+        }
+
+        @Override
+        protected void doAdd(int index, Node element) {
+            items.add(index, element);
+        }
+
+        @Override
+        protected Node doSet(int index, Node element) {
+            return items.set(index, element);
+        }
+
+        @Override
+        protected Node doRemove(int index) {
+            return items.remove(index);
+        }
+
+        @Override
+        public void add(int index, Node element) {
+            if (batch == 0) {
+                if (index < 0 || index > items.size()) {
+                    throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + items.size());
+                }
+                validate(java.util.Collections.singletonList(element), 0, 0);
+            }
+            super.add(index, element);
+        }
+
+        @Override
+        public Node set(int index, Node element) {
+            if (batch == 0) {
+                if (index < 0 || index >= items.size()) {
+                    throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + items.size());
+                }
+                validate(java.util.Collections.singletonList(element), index, index + 1);
+            }
+            return super.set(index, element);
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends Node> c) {
+            return addAll(items.size(), c);
+        }
+
+        @Override
+        public boolean addAll(int index, Collection<? extends Node> c) {
+            List<Node> copy = new ArrayList<Node>(c);
+            if (batch == 0) {
+                if (index < 0 || index > items.size()) {
+                    throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + items.size());
+                }
+                validate(copy, 0, 0);
+            }
+            batch++;
+            try {
+                return super.addAll(index, copy);
+            } finally {
+                batch--;
+            }
+        }
+
+        @Override
+        public boolean setAll(Collection<? extends Node> col) {
+            List<Node> copy = new ArrayList<Node>(col);
+            validate(copy, 0, items.size());
+            batch++;
+            try {
+                return super.setAll(copy);
+            } finally {
+                batch--;
+            }
+        }
+
+        /// Sorts in place and reports a permutation, as the list this
+        /// replaced did. The default `List.sort` sets the elements back one
+        /// at a time, and a node set where it is still in the list
+        /// elsewhere is a duplicate the check above refuses.
+        @Override
+        public void sort(java.util.Comparator<? super Node> comparator) {
+            int count = items.size();
+            if (count < 2) {
+                return;
+            }
+            Node[] sorted = items.toArray(new Node[count]);
+            // Stable, as the list this replaced sorted. Every child is in
+            // the list once, so a node's old position is found by identity.
+            java.util.Arrays.sort(sorted, comparator);
+            java.util.IdentityHashMap<Node, Integer> was = new java.util.IdentityHashMap<Node, Integer>();
+            for (int i = 0; i < count; i++) {
+                was.put(items.get(i), Integer.valueOf(i));
+            }
+            int[] perm = new int[count];
+            boolean moved = false;
+            for (int i = 0; i < count; i++) {
+                int old = was.get(sorted[i]).intValue();
+                perm[old] = i;
+                moved |= old != i;
+            }
+            if (!moved) {
+                return;
+            }
+            beginChange();
+            try {
+                for (int i = 0; i < count; i++) {
+                    items.set(i, sorted[i]);
+                }
+                modCount++;
+                nextPermutation(0, count, perm);
+            } finally {
+                endChange();
+            }
+        }
+
+        /// Throws, as OpenJFX does, if adding `added` in place of the
+        /// children in `[removeFrom, removeTo)` would leave a null child, a
+        /// child twice, a node inside itself or the root of a scene as a
+        /// child. A node already here is one whose parent is the owner, so
+        /// only such a node is looked for in the list.
+        private void validate(List<Node> added, int removeFrom, int removeTo) {
+            Set<Node> seen = added.size() > 1 ? new HashSet<Node>() : null;
+            for (int i = 0; i < added.size(); i++) {
+                Node n = added.get(i);
+                if (n == null) {
+                    throw new NullPointerException("Children: child node is null: parent = " + owner);
+                }
+                if ((seen != null && !seen.add(n)) || (n.getParent() == owner && kept(n, removeFrom, removeTo))) {
+                    throw new IllegalArgumentException("Children: duplicate children added: parent = " + owner);
+                }
+                for (Node up = owner; up != null; up = up.getParent()) {
+                    if (up == n) {
+                        throw new IllegalArgumentException("Children: cycle detected: parent = " + owner
+                                + ", node = " + n);
+                    }
+                }
+                if (n.getParent() == null && n.getScene() != null && n.getScene().getRoot() == n) {
+                    throw new IllegalArgumentException("Children: " + n
+                            + " is already set as a root of a scene: parent = " + owner);
+                }
+            }
+        }
+
+        /// Whether `n` is in the list outside `[removeFrom, removeTo)`.
+        private boolean kept(Node n, int removeFrom, int removeTo) {
+            for (int i = 0; i < items.size(); i++) {
+                if (items.get(i) == n && (i < removeFrom || i >= removeTo)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/Scene.java b/maven/javafx-compat/src/main/java/javafx/scene/Scene.java
new file mode 100644
index 00000000000..71ea6d6b586
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/Scene.java
@@ -0,0 +1,1166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+import com.codename1.fxcompat.runtime.SceneHost;
+import com.codename1.fxcompat.runtime.Mnemonics;
+import com.codename1.fxcompat.runtime.SceneInput;
+import com.codename1.fxcompat.runtime.StyleEngine;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ObjectPropertyBase;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.geometry.Bounds;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonBase;
+import javafx.scene.control.Label;
+import javafx.scene.control.Labeled;
+import javafx.scene.input.ContextMenuEvent;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.TextInputControl;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyCombination;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.PickResult;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.input.SwipeEvent;
+import javafx.scene.input.TouchEvent;
+import javafx.scene.input.TouchPoint;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.stage.Window;
+
+/// The content of a window: a tree of nodes below one root.
+///
+/// The scene fills the Codename One form, dialog or desktop window that
+/// shows its stage. A resizable root takes the size of the scene; layout
+/// runs before a frame whenever something asked for it.
+///
+/// #### Input
+///
+/// Pointer and key callbacks of the host become JavaFX events here. A
+/// mouse event goes to the deepest visible node under the pointer that is
+/// not mouse transparent; between a press and its release every event
+/// goes to the node that was pressed. A node that is disabled, or below a
+/// disabled node, takes the pointer but receives nothing. A key event
+/// goes to the focus owner, or to the scene when there is none. Tab and
+/// Shift+Tab move the focus through the focus traversable nodes in
+/// document order, unless a handler consumed the key. A secondary button
+/// release, and a long press on a touch screen, also ask for a context
+/// menu.
+///
+/// The camera, depth buffer, anti-aliasing, mnemonics, accelerators, drag
+/// and drop and snapshots of JavaFX are not part of this layer.
+public class Scene implements EventTarget {
+
+    private static final double DRAG_THRESHOLD = 4;
+    private static final long MULTI_CLICK_MILLIS = 500;
+    private static final double SWIPE_DISTANCE = 40;
+    private static final long SWIPE_MILLIS = 600;
+
+    private final ReadOnlyDoubleWrapper width = new ReadOnlyDoubleWrapper(this, "width", 0);
+    private final ReadOnlyDoubleWrapper height = new ReadOnlyDoubleWrapper(this, "height", 0);
+    private final ReadOnlyObjectWrapper<Window> window = new ReadOnlyObjectWrapper<Window>(this, "window");
+    private final ReadOnlyObjectWrapper<Node> focusOwner = new ReadOnlyObjectWrapper<Node>(this, "focusOwner");
+    private final ObjectProperty<Paint> fill = new SimpleObjectProperty<Paint>(this, "fill", Color.WHITE);
+    private final ObjectProperty<Cursor> cursor = new SimpleObjectProperty<Cursor>(this, "cursor");
+    private final ObservableList<String> stylesheets = FXCollections.observableArrayList();
+    private final EventHandlerManager events = new EventHandlerManager(this);
+    private final double initialWidth;
+    private final double initialHeight;
+    private ObservableMap<Object, Object> properties;
+    private ObservableMap<KeyCombination, Runnable> accelerators;
+    private Object userData;
+    private SceneHost host;
+
+    private final ArrayList<Node> hovered = new ArrayList<Node>();
+    private final ArrayList<Node> pressedNodes = new ArrayList<Node>();
+    private EventTarget pressTarget;
+    private EventTarget touchTarget;
+    private int touchSet;
+    private MouseButton pressButton = MouseButton.NONE;
+    private double pressX;
+    private double pressY;
+    private long pressTime;
+    private boolean still;
+    private boolean dragDetected;
+    private long lastClickTime;
+    private double lastClickX;
+    private double lastClickY;
+    private int clickCount;
+    private int shownCursor = -1;
+
+    private final ObjectProperty<Parent> root = new ObjectPropertyBase<Parent>() {
+        private Parent old;
+
+        /// Validates after the value is stored, as OpenJFX does: its
+        /// `Scene.rootProperty()` checks in `invalidated()` too (OpenJFX 23,
+        /// `Scene$8`), so a rejected `setRoot` throws and the property keeps
+        /// the rejected value there as well. Only the scene's own state --
+        /// the old root and its scene -- is left untouched, since every
+        /// check comes before it is changed.
+        @Override
+        protected void invalidated() {
+            Parent value = get();
+            if (value == old) {
+                return;
+            }
+            if (value == null) {
+                throw new NullPointerException("The root of a scene must not be null");
+            }
+            if (value.getParent() != null) {
+                throw new IllegalArgumentException(value + " is already inside a scene graph and cannot be a root");
+            }
+            if (value.getScene() != null && value.getScene() != Scene.this) {
+                throw new IllegalArgumentException(value + " is already the root of another scene");
+            }
+            if (old != null) {
+                old.setSceneInternal(null);
+            }
+            old = value;
+            if (!value.getStyleClass().contains("root")) {
+                value.getStyleClass().add(0, "root");
+            }
+            value.setSceneInternal(Scene.this);
+            if (host != null) {
+                host.rootChanged();
+            }
+            value.requestLayout();
+            cn1RequestPulse();
+        }
+
+        @Override
+        public Object getBean() {
+            return Scene.this;
+        }
+
+        @Override
+        public String getName() {
+            return "root";
+        }
+    };
+
+    /// Creates a scene that takes its size from its root, or from the
+    /// screen where a window cannot be sized.
+    public Scene(Parent root) {
+        this(root, -1, -1, Color.WHITE);
+    }
+
+    /// Creates a scene of a size, in logical pixels.
+    public Scene(Parent root, double width, double height) {
+        this(root, width, height, Color.WHITE);
+    }
+
+    /// Creates a scene with a background.
+    public Scene(Parent root, Paint fill) {
+        this(root, -1, -1, fill);
+    }
+
+    /// Creates a scene of a size with a background.
+    public Scene(Parent root, double width, double height, Paint fill) {
+        this.initialWidth = width;
+        this.initialHeight = height;
+        this.fill.set(fill);
+        stylesheets.addListener(new ListChangeListener<String>() {
+            @Override
+            public void onChanged(Change<? extends String> change) {
+                StyleEngine.getInstance().stylesheetsChanged(Scene.this);
+            }
+        });
+        if (width >= 0) {
+            this.width.set(width);
+        }
+        if (height >= 0) {
+            this.height.set(height);
+        }
+        setRoot(root);
+    }
+
+    // ---------------------------------------------------------- content
+
+    /// Returns the root of the scene graph.
+    public final Parent getRoot() {
+        return root.get();
+    }
+
+    /// Replaces the root of the scene graph.
+    public final void setRoot(Parent value) {
+        root.set(value);
+    }
+
+    /// The root of the scene graph.
+    public final ObjectProperty<Parent> rootProperty() {
+        return root;
+    }
+
+    /// Returns the width of the scene.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// The width of the scene.
+    public final ReadOnlyDoubleProperty widthProperty() {
+        return width.getReadOnlyProperty();
+    }
+
+    /// Returns the height of the scene.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// The height of the scene.
+    public final ReadOnlyDoubleProperty heightProperty() {
+        return height.getReadOnlyProperty();
+    }
+
+    /// Returns the x of the scene in its window; always 0.
+    public final double getX() {
+        return 0;
+    }
+
+    /// Returns the y of the scene in its window; always 0.
+    public final double getY() {
+        return 0;
+    }
+
+    /// Returns the paint behind the root.
+    public final Paint getFill() {
+        return fill.get();
+    }
+
+    /// Sets the paint behind the root.
+    public final void setFill(Paint value) {
+        fill.set(value);
+        if (host != null) {
+            host.rootChanged();
+        }
+    }
+
+    /// The paint behind the root.
+    public final ObjectProperty<Paint> fillProperty() {
+        return fill;
+    }
+
+    /// Returns the window showing this scene, or `null`.
+    public final Window getWindow() {
+        return window.get();
+    }
+
+    /// The window showing this scene.
+    public final ReadOnlyObjectProperty<Window> windowProperty() {
+        return window.getReadOnlyProperty();
+    }
+
+    /// Returns the cursor of the scene, used where no node sets one.
+    public final Cursor getCursor() {
+        return cursor.get();
+    }
+
+    /// Sets the cursor of the scene.
+    public final void setCursor(Cursor value) {
+        cursor.set(value);
+    }
+
+    /// The cursor of the scene.
+    public final ObjectProperty<Cursor> cursorProperty() {
+        return cursor;
+    }
+
+    /// Returns the style sheet locations of this scene. The list is
+    /// passed to the installed style engine; without one it has no effect.
+    public final ObservableList<String> getStylesheets() {
+        return stylesheets;
+    }
+
+    /// Returns the first node a selector matches, or `null`; see
+    /// `Node.lookup`.
+    public Node lookup(String selector) {
+        Parent r = getRoot();
+        return r == null ? null : r.lookup(selector);
+    }
+
+    /// Returns the application's own object attached to this scene.
+    public Object getUserData() {
+        return userData;
+    }
+
+    /// Attaches an object of the application to this scene.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns a map for the application's own values on this scene.
+    public final ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    /// Returns the key combinations of this scene and what each runs. One
+    /// is run when a hardware keyboard sends the combination and nothing
+    /// in the scene consumed the key press. The accelerators of the items
+    /// of a `MenuBar` in the scene are not listed here; they are found in
+    /// the menus when a key is pressed, after the ones of this map.
+    public ObservableMap<KeyCombination, Runnable> getAccelerators() {
+        if (accelerators == null) {
+            accelerators = FXCollections.observableHashMap();
+        }
+        return accelerators;
+    }
+
+    private ButtonBase keyArmed;
+
+    private boolean runAccelerator(KeyEvent event) {
+        if (accelerators != null && !accelerators.isEmpty()) {
+            ArrayList<KeyCombination> keys = new ArrayList<KeyCombination>(accelerators.keySet());
+            for (int i = 0; i < keys.size(); i++) {
+                KeyCombination key = keys.get(i);
+                Runnable run = key == null ? null : accelerators.get(key);
+                if (run != null && key.match(event)) {
+                    run.run();
+                    return true;
+                }
+            }
+        }
+        Parent top = getRoot();
+        return top != null && runMenuAccelerator(top, event);
+    }
+
+    private static boolean runMenuAccelerator(Node node, KeyEvent event) {
+        if (!node.isVisible() || node.isDisabled()) {
+            return false;
+        }
+        if (node instanceof MenuBar) {
+            List<Menu> menus = ((MenuBar) node).getMenus();
+            for (int i = 0; i < menus.size(); i++) {
+                if (runItemAccelerator(menus.get(i), event)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (node instanceof Parent) {
+            List<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                if (runMenuAccelerator(children.get(i), event)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static boolean runItemAccelerator(MenuItem item, KeyEvent event) {
+        if (item == null || item.isDisable() || !item.isVisible()) {
+            return false;
+        }
+        if (item instanceof Menu) {
+            List<MenuItem> items = ((Menu) item).getItems();
+            for (int i = 0; i < items.size(); i++) {
+                if (runItemAccelerator(items.get(i), event)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        KeyCombination key = item.getAccelerator();
+        if (key != null && key.match(event)) {
+            item.fire();
+            return true;
+        }
+        return false;
+    }
+
+    /// Returns whether [#getProperties()] holds anything.
+    public boolean hasProperties() {
+        return properties != null && !properties.isEmpty();
+    }
+
+    // ---------------------------------------------------------- hosting
+
+    /// Attaches the scene to what shows it, or detaches it with `null`.
+    public final void cn1SetHost(SceneHost value, Window owner) {
+        host = value;
+        window.set(owner);
+        shownCursor = -1;
+    }
+
+    /// Returns what shows this scene, or `null`.
+    public final SceneHost cn1Host() {
+        return host;
+    }
+
+    /// Returns the width asked for when the scene was created, or -1.
+    public final double cn1InitialWidth() {
+        return initialWidth;
+    }
+
+    /// Returns the height asked for when the scene was created, or -1.
+    public final double cn1InitialHeight() {
+        return initialHeight;
+    }
+
+    /// Asks for layout to run before the next frame.
+    public final void cn1RequestPulse() {
+        if (host != null) {
+            host.requestPulse();
+        }
+    }
+
+    /// Gives the scene a size and lays out the scene graph in it.
+    public final void cn1Layout(double sceneWidth, double sceneHeight) {
+        width.set(sceneWidth);
+        height.set(sceneHeight);
+        Parent r = getRoot();
+        if (r == null) {
+            return;
+        }
+        if (r.isResizable()) {
+            r.resize(sceneWidth, sceneHeight);
+        } else {
+            r.autosize();
+        }
+        // A pass can change the bounds of a group, which the parent of the
+        // group then has to place again.
+        for (int pass = 0; pass < 4; pass++) {
+            r.layout();
+            if (!r.isNeedsLayout()) {
+                break;
+            }
+        }
+    }
+
+    final void cn1NodeLeft(Node node) {
+        if (focusOwner.get() == node) {
+            node.cn1SetFocused(false);
+            focusOwner.set(null);
+        }
+        if (hovered.remove(node)) {
+            node.cn1SetHover(false);
+        }
+        if (pressedNodes.remove(node)) {
+            node.cn1SetPressed(false);
+        }
+        if (pressTarget == node) {
+            pressTarget = null;
+        }
+    }
+
+    // ------------------------------------------------------------ focus
+
+    /// Returns the node with the keyboard focus, or `null`.
+    public final Node getFocusOwner() {
+        return focusOwner.get();
+    }
+
+    /// The node with the keyboard focus.
+    public final ReadOnlyObjectProperty<Node> focusOwnerProperty() {
+        return focusOwner.getReadOnlyProperty();
+    }
+
+    /// Moves the focus to a node of this scene, or to nothing with
+    /// `null`. With `moveNative` the node is also told to take the native
+    /// focus; a control that already has it passes `false`.
+    public final void cn1SetFocusOwner(Node node, boolean moveNative) {
+        Node old = focusOwner.get();
+        if (old == node) {
+            return;
+        }
+        if (old != null) {
+            old.cn1SetFocused(false);
+        }
+        focusOwner.set(node);
+        if (node != null) {
+            node.cn1SetFocused(true);
+            if (moveNative) {
+                node.cn1FocusRequested();
+            }
+        }
+    }
+
+    /// Settles the focus of a scene a window has just shown. `chosen` is
+    /// the node the application gave the focus before the window opened,
+    /// or `null`: it keeps it, whatever the form focused as it came up,
+    /// and its widget now exists to be told. With no choice made the
+    /// first node that takes the focus gets it: what JavaFX does, and
+    /// what makes Space, Enter and the arrow keys mean something in a
+    /// window nobody has clicked in yet.
+    public final void cn1FocusInitial(Node chosen) {
+        if (getRoot() == null) {
+            return;
+        }
+        if (chosen != null && chosen.getScene() == this && chosen.isVisible() && !chosen.isDisabled()) {
+            if (focusOwner.get() == chosen) {
+                chosen.cn1FocusRequested();
+            } else {
+                cn1SetFocusOwner(chosen, true);
+            }
+            return;
+        }
+        if (focusOwner.get() != null) {
+            return;
+        }
+        ArrayList<Node> order = new ArrayList<Node>();
+        collectTraversable(getRoot(), order);
+        if (!order.isEmpty()) {
+            cn1SetFocusOwner(order.get(0), true);
+        }
+    }
+
+    private void collectTraversable(Node n, ArrayList<Node> into) {
+        if (!n.isVisible() || n.isDisabled()) {
+            return;
+        }
+        if (n.isFocusTraversable()) {
+            into.add(n);
+        }
+        if (n instanceof Parent) {
+            ObservableList<Node> children = ((Parent) n).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                collectTraversable(children.get(i), into);
+            }
+        }
+    }
+
+    private void traverse(boolean backward) {
+        ArrayList<Node> order = new ArrayList<Node>();
+        if (getRoot() != null) {
+            collectTraversable(getRoot(), order);
+        }
+        if (order.isEmpty()) {
+            return;
+        }
+        int at = order.indexOf(focusOwner.get());
+        int next;
+        if (at < 0) {
+            next = backward ? order.size() - 1 : 0;
+        } else {
+            next = (at + (backward ? order.size() - 1 : 1)) % order.size();
+        }
+        cn1SetFocusOwner(order.get(next), true);
+    }
+
+    /// Moves the focus from a node to the nearest one that takes it in
+    /// the direction of an arrow key, as the arrows do on a button, which
+    /// has no use of its own for them. Nearest counts the distance along
+    /// the arrow once and the distance across it twice, so a node straight
+    /// ahead wins over a closer one off to the side. Answers whether the
+    /// key was an arrow.
+    private boolean traverseTowards(KeyCode code, Node from) {
+        int dx = code == KeyCode.LEFT ? -1 : code == KeyCode.RIGHT ? 1 : 0;
+        int dy = code == KeyCode.UP ? -1 : code == KeyCode.DOWN ? 1 : 0;
+        if (dx == 0 && dy == 0) {
+            return false;
+        }
+        ArrayList<Node> order = new ArrayList<Node>();
+        if (getRoot() != null) {
+            collectTraversable(getRoot(), order);
+        }
+        Bounds here = from.localToScene(from.getBoundsInLocal());
+        double hx = (here.getMinX() + here.getMaxX()) / 2;
+        double hy = (here.getMinY() + here.getMaxY()) / 2;
+        Node best = null;
+        double bestCost = 0;
+        for (int i = 0; i < order.size(); i++) {
+            Node n = order.get(i);
+            Bounds b = n == from ? null : n.localToScene(n.getBoundsInLocal());
+            if (b == null) {
+                continue;
+            }
+            double ox = (b.getMinX() + b.getMaxX()) / 2 - hx;
+            double oy = (b.getMinY() + b.getMaxY()) / 2 - hy;
+            double along = dx != 0 ? ox * dx : oy * dy;
+            double across = Math.abs(dx != 0 ? oy : ox);
+            if (along <= 0 || across > along * 2) {
+                continue;
+            }
+            double cost = along + across * 2;
+            if (best == null || cost < bestCost) {
+                best = n;
+                bestCost = cost;
+            }
+        }
+        if (best != null) {
+            cn1SetFocusOwner(best, true);
+        }
+        return true;
+    }
+
+    // ------------------------------------------------------------ input
+
+    private Node pick(double x, double y) {
+        Parent r = getRoot();
+        return r == null ? null : r.cn1Pick(x, y);
+    }
+
+    private static boolean deliverable(EventTarget target) {
+        return !(target instanceof Node) || !((Node) target).isDisabled();
+    }
+
+    private MouseEvent mouse(EventType<? extends MouseEvent> type, EventTarget target, double x, double y,
+            MouseButton button, int clicks, boolean down, boolean popup) {
+        boolean primary = down && pressButton == MouseButton.PRIMARY;
+        boolean middle = down && pressButton == MouseButton.MIDDLE;
+        boolean secondary = down && pressButton == MouseButton.SECONDARY;
+        return new MouseEvent(target, target, type, x, y, x, y, button, clicks, SceneInput.shiftDown(),
+                SceneInput.controlDown(), SceneInput.altDown(), SceneInput.metaDown(), primary, middle, secondary,
+                false, popup, still, new PickResult(target, x, y));
+    }
+
+    private void fire(EventTarget target, Event event) {
+        if (target != null && deliverable(target)) {
+            Event.fireEvent(target, event);
+        }
+    }
+
+    private static void chain(Node from, ArrayList<Node> into) {
+        for (Node n = from; n != null; n = n.getParent()) {
+            into.add(n);
+        }
+    }
+
+    private void updateHover(Node target, double x, double y) {
+        ArrayList<Node> now = new ArrayList<Node>();
+        chain(target, now);
+        for (int i = 0; i < hovered.size(); i++) {
+            Node n = hovered.get(i);
+            if (!now.contains(n)) {
+                n.cn1SetHover(false);
+                fire(n, mouse(MouseEvent.MOUSE_EXITED_TARGET, n, x, y, MouseButton.NONE, 0,
+                        pressTarget != null, false));
+            }
+        }
+        for (int i = now.size() - 1; i >= 0; i--) {
+            Node n = now.get(i);
+            if (!hovered.contains(n)) {
+                if (!n.isDisabled()) {
+                    n.cn1SetHover(true);
+                }
+                fire(n, mouse(MouseEvent.MOUSE_ENTERED_TARGET, n, x, y, MouseButton.NONE, 0,
+                        pressTarget != null, false));
+            }
+        }
+        hovered.clear();
+        hovered.addAll(now);
+        Cursor wanted = null;
+        for (int i = 0; i < now.size() && wanted == null; i++) {
+            wanted = now.get(i).getCursor();
+        }
+        if (wanted == null) {
+            wanted = getCursor();
+        }
+        int code = wanted == null ? Cursor.DEFAULT.cn1Code() : wanted.cn1Code();
+        if (code != shownCursor && host != null) {
+            shownCursor = code;
+            host.showCursor(code);
+        }
+    }
+
+    private void clearPressed() {
+        for (int i = 0; i < pressedNodes.size(); i++) {
+            pressedNodes.get(i).cn1SetPressed(false);
+        }
+        pressedNodes.clear();
+    }
+
+    private static EventTarget commonAncestor(EventTarget a, EventTarget b) {
+        if (!(a instanceof Node) || !(b instanceof Node)) {
+            return a == b ? a : null;
+        }
+        ArrayList<Node> up = new ArrayList<Node>();
+        chain((Node) a, up);
+        for (Node n = (Node) b; n != null; n = n.getParent()) {
+            if (up.contains(n)) {
+                return n;
+            }
+        }
+        return null;
+    }
+
+    /// Feeds one pointer event into the scene, at scene coordinates. The
+    /// kind is `MOUSE_PRESSED`, `MOUSE_DRAGGED`, `MOUSE_RELEASED` or
+    /// `MOUSE_MOVED`. Answers whether a filter consumed what was fired.
+    public final boolean cn1Pointer(EventType<MouseEvent> kind, double x, double y, MouseButton button) {
+        EventHandlerManager.resetConsumedByFilter();
+        Node under = pick(x, y);
+        EventTarget target = under == null ? this : under;
+        if (SceneInput.touchInput()) {
+            touch(kind, target, x, y);
+        }
+        if (kind == MouseEvent.MOUSE_PRESSED) {
+            updateHover(under, x, y);
+            pressTarget = target;
+            pressButton = button == null || button == MouseButton.NONE ? MouseButton.PRIMARY : button;
+            pressX = x;
+            pressY = y;
+            pressTime = System.currentTimeMillis();
+            still = true;
+            dragDetected = false;
+            if (under != null && !under.isDisabled()) {
+                chain(under, pressedNodes);
+                for (int i = 0; i < pressedNodes.size(); i++) {
+                    pressedNodes.get(i).cn1SetPressed(true);
+                }
+                for (Node n = under; n != null; n = n.getParent()) {
+                    if (n.isFocusTraversable()) {
+                        n.requestFocus();
+                        break;
+                    }
+                }
+            }
+            fire(target, mouse(MouseEvent.MOUSE_PRESSED, target, x, y, pressButton, nextClickCount(x, y), true,
+                    false));
+        } else if (kind == MouseEvent.MOUSE_DRAGGED) {
+            if (pressTarget == null) {
+                return false;
+            }
+            if (still && (Math.abs(x - pressX) > DRAG_THRESHOLD || Math.abs(y - pressY) > DRAG_THRESHOLD)) {
+                still = false;
+            }
+            fire(pressTarget, mouse(MouseEvent.MOUSE_DRAGGED, pressTarget, x, y, pressButton, 0, true, false));
+            if (!still && !dragDetected) {
+                dragDetected = true;
+                fire(pressTarget, mouse(MouseEvent.DRAG_DETECTED, pressTarget, x, y, pressButton, 0, true, false));
+            }
+        } else if (kind == MouseEvent.MOUSE_RELEASED) {
+            if (pressTarget == null) {
+                return false;
+            }
+            EventTarget pressedOn = pressTarget;
+            MouseButton b = pressButton;
+            boolean popup = b == MouseButton.SECONDARY;
+            pressTarget = null;
+            clearPressed();
+            fire(pressedOn, mouse(MouseEvent.MOUSE_RELEASED, pressedOn, x, y, b, clickCount, false, popup));
+            boolean filtered = EventHandlerManager.wasConsumedByFilter();
+            EventTarget clicked = commonAncestor(pressedOn, target);
+            if (clicked != null) {
+                fire(clicked, mouse(MouseEvent.MOUSE_CLICKED, clicked, x, y, b, clickCount, false, false));
+            }
+            if (popup) {
+                fire(target, new ContextMenuEvent(target, target, ContextMenuEvent.CONTEXT_MENU_REQUESTED, x, y, x,
+                        y, false, new PickResult(target, x, y)));
+            }
+            // A swipe is a gesture of a finger. A mouse dragged across a JavaFX scene
+            // is a drag and nothing else, and an application that moves on a swipe
+            // stays where it is under a mouse, as it does on a desktop.
+            EventType<SwipeEvent> swipe = b == MouseButton.PRIMARY && SceneInput.touchInput()
+                    ? swipe(x - pressX, y - pressY) : null;
+            if (swipe != null) {
+                fire(pressedOn, new SwipeEvent(pressedOn, pressedOn, swipe, pressX, pressY, pressX, pressY,
+                        SceneInput.shiftDown(), SceneInput.controlDown(), SceneInput.altDown(),
+                        SceneInput.metaDown(), true, 1, new PickResult(pressedOn, pressX, pressY)));
+            }
+            pressButton = MouseButton.NONE;
+            updateHover(under, x, y);
+            return filtered;
+        } else {
+            updateHover(under, x, y);
+            fire(target, mouse(MouseEvent.MOUSE_MOVED, target, x, y, MouseButton.NONE, 0, false, false));
+        }
+        return EventHandlerManager.wasConsumedByFilter();
+    }
+
+    /// The touch a pointer event of a touch screen is, fired ahead of the
+    /// mouse event JavaFX makes of the same finger. There is one touch
+    /// point: Codename One hands the scene one pointer. Every event of a
+    /// touch goes to what the finger came down on, as in JavaFX, and the
+    /// events of one touch share an event set of one event each.
+    private void touch(EventType<MouseEvent> kind, EventTarget under, double x, double y) {
+        EventType<TouchEvent> type;
+        TouchPoint.State state;
+        if (kind == MouseEvent.MOUSE_PRESSED) {
+            touchTarget = under;
+            type = TouchEvent.TOUCH_PRESSED;
+            state = TouchPoint.State.PRESSED;
+        } else if (touchTarget == null) {
+            return;
+        } else if (kind == MouseEvent.MOUSE_DRAGGED) {
+            type = TouchEvent.TOUCH_MOVED;
+            state = TouchPoint.State.MOVED;
+        } else if (kind == MouseEvent.MOUSE_RELEASED) {
+            type = TouchEvent.TOUCH_RELEASED;
+            state = TouchPoint.State.RELEASED;
+        } else {
+            return;
+        }
+        EventTarget to = touchTarget;
+        if (kind == MouseEvent.MOUSE_RELEASED) {
+            touchTarget = null;
+        }
+        touchSet++;
+        TouchPoint point = new TouchPoint(1, state, x, y, x, y, to, new PickResult(under, x, y));
+        ArrayList<TouchPoint> points = new ArrayList<TouchPoint>();
+        points.add(point);
+        fire(to, new TouchEvent(to, to, type, point, points, touchSet, SceneInput.shiftDown(),
+                SceneInput.controlDown(), SceneInput.altDown(), SceneInput.metaDown()));
+    }
+
+    /// The swipe a finished press amounts to: far enough, quick enough
+    /// and at least twice as long along one axis as along the other.
+    private EventType<SwipeEvent> swipe(double dx, double dy) {
+        double ax = Math.abs(dx);
+        double ay = Math.abs(dy);
+        if (Math.max(ax, ay) < SWIPE_DISTANCE || System.currentTimeMillis() - pressTime > SWIPE_MILLIS) {
+            return null;
+        }
+        if (ax >= ay * 2) {
+            return dx < 0 ? SwipeEvent.SWIPE_LEFT : SwipeEvent.SWIPE_RIGHT;
+        } else if (ay >= ax * 2) {
+            return dy < 0 ? SwipeEvent.SWIPE_UP : SwipeEvent.SWIPE_DOWN;
+        }
+        return null;
+    }
+
+    private int nextClickCount(double x, double y) {
+        long now = System.currentTimeMillis();
+        if (now - lastClickTime <= MULTI_CLICK_MILLIS && Math.abs(x - lastClickX) <= DRAG_THRESHOLD
+                && Math.abs(y - lastClickY) <= DRAG_THRESHOLD) {
+            clickCount++;
+        } else {
+            clickCount = 1;
+        }
+        lastClickTime = now;
+        lastClickX = x;
+        lastClickY = y;
+        return clickCount;
+    }
+
+    /// The pointer left the scene: nothing is hovered any more.
+    public final void cn1PointerExited() {
+        updateHover(null, -1, -1);
+    }
+
+    /// Asks for a context menu at scene coordinates, as a long press
+    /// does. Answers whether a filter consumed the request.
+    public final boolean cn1ContextMenu(double x, double y) {
+        EventHandlerManager.resetConsumedByFilter();
+        Node under = pick(x, y);
+        EventTarget target = under == null ? this : under;
+        fire(target, new ContextMenuEvent(target, target, ContextMenuEvent.CONTEXT_MENU_REQUESTED, x, y, x, y, false,
+                new PickResult(target, x, y)));
+        return EventHandlerManager.wasConsumedByFilter();
+    }
+
+    /// Feeds a turn of the wheel into the scene. Answers whether a filter
+    /// consumed it.
+    public final boolean cn1Wheel(double x, double y, double deltaX, double deltaY) {
+        EventHandlerManager.resetConsumedByFilter();
+        Node under = pick(x, y);
+        EventTarget target = under == null ? this : under;
+        fire(target, new ScrollEvent(target, target, ScrollEvent.SCROLL, x, y, x, y, SceneInput.shiftDown(),
+                SceneInput.controlDown(), SceneInput.altDown(), SceneInput.metaDown(), false, false, deltaX, deltaY,
+                deltaX, deltaY, ScrollEvent.HorizontalTextScrollUnits.NONE, 0,
+                ScrollEvent.VerticalTextScrollUnits.NONE, 0, 0, new PickResult(target, x, y)));
+        return EventHandlerManager.wasConsumedByFilter();
+    }
+
+    /// Feeds a key event into the scene: `KEY_PRESSED`, `KEY_RELEASED` or
+    /// `KEY_TYPED`. Answers whether a filter consumed it.
+    public final boolean cn1Key(EventType<KeyEvent> kind, KeyCode code, String text) {
+        EventHandlerManager.resetConsumedByFilter();
+        Node owner = focusOwner.get();
+        EventTarget target = owner == null ? this : owner;
+        KeyEvent event = new KeyEvent(target, target, kind, text, text, code, SceneInput.shiftDown(),
+                SceneInput.controlDown(), SceneInput.altDown(), SceneInput.metaDown());
+        final boolean[] handled = new boolean[1];
+        if (deliverable(target)) {
+            handled[0] = cn1FireAndReport(target, event);
+        }
+        if (!handled[0] && kind != KeyEvent.KEY_TYPED && pressFocused(kind, code, owner)) {
+            return true;
+        }
+        if (kind == KeyEvent.KEY_PRESSED && !handled[0] && SceneInput.altDown() && code != null
+                && (code.isLetterKey() || code.isDigitKey()) && code.getName().length() == 1
+                && mnemonic(getRoot(), Mnemonics.upper(code.getName().charAt(0)))) {
+            return EventHandlerManager.wasConsumedByFilter();
+        }
+        if (kind == KeyEvent.KEY_PRESSED && !handled[0] && runAccelerator(event)) {
+            return EventHandlerManager.wasConsumedByFilter();
+        }
+        if (kind == KeyEvent.KEY_PRESSED && !handled[0] && fireStanding(code, owner)) {
+            return true;
+        }
+        if (kind == KeyEvent.KEY_PRESSED && code == KeyCode.TAB && !handled[0]) {
+            traverse(SceneInput.shiftDown());
+        }
+        if (kind == KeyEvent.KEY_PRESSED && !handled[0] && owner instanceof ButtonBase && traverseTowards(code, owner)) {
+            return true;
+        }
+        return EventHandlerManager.wasConsumedByFilter();
+    }
+
+    /// What Space and Enter do to the button with the focus: the press
+    /// arms it and the release fires it, as a press and a release of the
+    /// pointer over it do. The scene does this itself, and answers that
+    /// the key is spoken for, because the native component of the button
+    /// is told about a key only by a port that knows it has the focus,
+    /// and would then act a second time.
+    private boolean pressFocused(EventType<KeyEvent> kind, KeyCode code, Node owner) {
+        if ((code != KeyCode.ENTER && code != KeyCode.SPACE) || !(owner instanceof ButtonBase)
+                || owner.isDisabled()) {
+            return false;
+        }
+        ButtonBase button = (ButtonBase) owner;
+        if (kind == KeyEvent.KEY_PRESSED) {
+            keyArmed = button;
+            button.arm();
+        } else if (keyArmed == button) {
+            keyArmed = null;
+            if (button.isArmed()) {
+                button.disarm();
+                button.fire();
+            }
+        }
+        return true;
+    }
+
+    /// Enter fires the default button of the scene and Escape its cancel
+    /// button, when nothing nearer the focus wanted the key. A text
+    /// control keeps Enter: it reports its own action.
+    private boolean fireStanding(KeyCode code, Node owner) {
+        boolean enter = code == KeyCode.ENTER && !(owner instanceof TextInputControl);
+        if (!enter && code != KeyCode.ESCAPE) {
+            return false;
+        }
+        Button standing = standing(getRoot(), enter);
+        if (standing == null) {
+            return false;
+        }
+        standing.fire();
+        return true;
+    }
+
+    private static Button standing(Node node, boolean isDefault) {
+        if (node == null || !node.isVisible() || node.isDisabled()) {
+            return null;
+        }
+        if (node instanceof Button) {
+            Button b = (Button) node;
+            return (isDefault ? b.isDefaultButton() : b.isCancelButton()) ? b : null;
+        }
+        if (node instanceof Parent) {
+            List<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                Button found = standing(children.get(i), isDefault);
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    /// Acts on the first control under a node that is on screen, enabled
+    /// and marks a key as its mnemonic: a button is fired, and a label
+    /// that stands for another control hands that control the focus.
+    private static boolean mnemonic(Node node, char key) {
+        if (node == null || !node.isVisible() || node.isDisabled()) {
+            return false;
+        }
+        if (node instanceof Labeled) {
+            Labeled labeled = (Labeled) node;
+            if (labeled.isMnemonicParsing() && Mnemonics.key(labeled.getText()) == key) {
+                if (labeled instanceof ButtonBase) {
+                    ((ButtonBase) labeled).fire();
+                    return true;
+                }
+                if (labeled instanceof Label && ((Label) labeled).getLabelFor() != null) {
+                    ((Label) labeled).getLabelFor().requestFocus();
+                    return true;
+                }
+            }
+        }
+        if (node instanceof Parent) {
+            List<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                if (mnemonic(children.get(i), key)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /// Fires an event and answers whether anything consumed it.
+    private static boolean cn1FireAndReport(EventTarget target, Event event) {
+        EventDispatchChain chain = target.buildEventDispatchChain(
+                new com.codename1.fxcompat.runtime.EventDispatchChainImpl());
+        return chain.dispatchEvent(event) == null;
+    }
+
+    // ----------------------------------------------------------- events
+
+    /// Adds a handler called in the bubbling phase.
+    public final <T extends Event> void addEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        events.addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler.
+    public final <T extends Event> void removeEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        events.removeEventHandler(eventType, eventHandler);
+    }
+
+    /// Adds a filter called in the capturing phase.
+    public final <T extends Event> void addEventFilter(EventType<T> eventType,
+            EventHandler<? super T> eventFilter) {
+        events.addEventFilter(eventType, eventFilter);
+    }
+
+    /// Removes a filter.
+    public final <T extends Event> void removeEventFilter(EventType<T> eventType,
+            EventHandler<? super T> eventFilter) {
+        events.removeEventFilter(eventType, eventFilter);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        EventDispatchChain chain = tail.prepend(events);
+        Window w = getWindow();
+        return w == null ? chain : w.buildEventDispatchChain(chain);
+    }
+
+    /// Sets the handler of a click anywhere in the scene.
+    public final void setOnMouseClicked(EventHandler<? super MouseEvent> value) {
+        events.setSlot(MouseEvent.MOUSE_CLICKED, "onMouseClicked", value);
+    }
+
+    /// Returns the handler of a click anywhere in the scene.
+    public final EventHandler<? super MouseEvent> getOnMouseClicked() {
+        return events.getSlot(MouseEvent.MOUSE_CLICKED);
+    }
+
+    /// Sets the handler of a button going down.
+    public final void setOnMousePressed(EventHandler<? super MouseEvent> value) {
+        events.setSlot(MouseEvent.MOUSE_PRESSED, "onMousePressed", value);
+    }
+
+    /// Returns the handler of a button going down.
+    public final EventHandler<? super MouseEvent> getOnMousePressed() {
+        return events.getSlot(MouseEvent.MOUSE_PRESSED);
+    }
+
+    /// Sets the handler of a button coming up.
+    public final void setOnMouseReleased(EventHandler<? super MouseEvent> value) {
+        events.setSlot(MouseEvent.MOUSE_RELEASED, "onMouseReleased", value);
+    }
+
+    /// Returns the handler of a button coming up.
+    public final EventHandler<? super MouseEvent> getOnMouseReleased() {
+        return events.getSlot(MouseEvent.MOUSE_RELEASED);
+    }
+
+    /// Sets the handler of the pointer moving with a button down.
+    public final void setOnMouseDragged(EventHandler<? super MouseEvent> value) {
+        events.setSlot(MouseEvent.MOUSE_DRAGGED, "onMouseDragged", value);
+    }
+
+    /// Returns the handler of the pointer moving with a button down.
+    public final EventHandler<? super MouseEvent> getOnMouseDragged() {
+        return events.getSlot(MouseEvent.MOUSE_DRAGGED);
+    }
+
+    /// Sets the handler of the pointer moving with no button down.
+    public final void setOnMouseMoved(EventHandler<? super MouseEvent> value) {
+        events.setSlot(MouseEvent.MOUSE_MOVED, "onMouseMoved", value);
+    }
+
+    /// Returns the handler of the pointer moving with no button down.
+    public final EventHandler<? super MouseEvent> getOnMouseMoved() {
+        return events.getSlot(MouseEvent.MOUSE_MOVED);
+    }
+
+    /// Sets the handler of a key going down.
+    public final void setOnKeyPressed(EventHandler<? super KeyEvent> value) {
+        events.setSlot(KeyEvent.KEY_PRESSED, "onKeyPressed", value);
+    }
+
+    /// Returns the handler of a key going down.
+    public final EventHandler<? super KeyEvent> getOnKeyPressed() {
+        return events.getSlot(KeyEvent.KEY_PRESSED);
+    }
+
+    /// Sets the handler of a key coming up.
+    public final void setOnKeyReleased(EventHandler<? super KeyEvent> value) {
+        events.setSlot(KeyEvent.KEY_RELEASED, "onKeyReleased", value);
+    }
+
+    /// Returns the handler of a key coming up.
+    public final EventHandler<? super KeyEvent> getOnKeyReleased() {
+        return events.getSlot(KeyEvent.KEY_RELEASED);
+    }
+
+    /// Sets the handler of a character being typed.
+    public final void setOnKeyTyped(EventHandler<? super KeyEvent> value) {
+        events.setSlot(KeyEvent.KEY_TYPED, "onKeyTyped", value);
+    }
+
+    /// Returns the handler of a character being typed.
+    public final EventHandler<? super KeyEvent> getOnKeyTyped() {
+        return events.getSlot(KeyEvent.KEY_TYPED);
+    }
+
+    /// Sets the handler of the wheel scrolling.
+    public final void setOnScroll(EventHandler<? super ScrollEvent> value) {
+        events.setSlot(ScrollEvent.SCROLL, "onScroll", value);
+    }
+
+    /// Returns the handler of the wheel scrolling.
+    public final EventHandler<? super ScrollEvent> getOnScroll() {
+        return events.getSlot(ScrollEvent.SCROLL);
+    }
+
+    /// Sets the handler of a context menu being asked for.
+    public final void setOnContextMenuRequested(EventHandler<? super ContextMenuEvent> value) {
+        events.setSlot(ContextMenuEvent.CONTEXT_MENU_REQUESTED, "onContextMenuRequested", value);
+    }
+
+    /// Returns the handler of a context menu being asked for.
+    public final EventHandler<? super ContextMenuEvent> getOnContextMenuRequested() {
+        return events.getSlot(ContextMenuEvent.CONTEXT_MENU_REQUESTED);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/SnapshotParameters.java b/maven/javafx-compat/src/main/java/javafx/scene/SnapshotParameters.java
new file mode 100644
index 00000000000..746bbaafbe1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/SnapshotParameters.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene;
+
+import javafx.geometry.Rectangle2D;
+import javafx.scene.paint.Paint;
+import javafx.scene.transform.Transform;
+
+/// How a node is rendered into an image by
+/// [Node#snapshot(SnapshotParameters, javafx.scene.image.WritableImage)]:
+/// what the image is filled with first, a transform applied on top of
+/// the node's own, and the part of the result to keep.
+public class SnapshotParameters {
+
+    private boolean depthBuffer;
+    private Transform transform;
+    private Paint fill;
+    private Rectangle2D viewport;
+
+    /// Creates parameters with no transform, no viewport and a white
+    /// fill.
+    public SnapshotParameters() {
+    }
+
+    /// Returns whether a depth buffer was asked for; recorded only.
+    public boolean isDepthBuffer() {
+        return depthBuffer;
+    }
+
+    /// Asks for a depth buffer; recorded only, the layer draws in two
+    /// dimensions.
+    public void setDepthBuffer(boolean depthBuffer) {
+        this.depthBuffer = depthBuffer;
+    }
+
+    /// Returns the transform applied on top of the node's own, or `null`.
+    public Transform getTransform() {
+        return transform;
+    }
+
+    /// Sets the transform applied on top of the node's own.
+    public void setTransform(Transform transform) {
+        this.transform = transform;
+    }
+
+    /// Returns what the image is filled with first; `null` is white.
+    public Paint getFill() {
+        return fill;
+    }
+
+    /// Sets what the image is filled with first.
+    public void setFill(Paint fill) {
+        this.fill = fill;
+    }
+
+    /// Returns the part of the parent's coordinates that is rendered, or
+    /// `null` for the bounds of the node.
+    public Rectangle2D getViewport() {
+        return viewport;
+    }
+
+    /// Sets the part of the parent's coordinates that is rendered.
+    public void setViewport(Rectangle2D viewport) {
+        this.viewport = viewport;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/canvas/Canvas.java b/maven/javafx-compat/src/main/java/javafx/scene/canvas/Canvas.java
new file mode 100644
index 00000000000..ae8a9088703
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/canvas/Canvas.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.canvas;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.scene.Node;
+
+/// A rectangle that is drawn on through a [GraphicsContext].
+///
+/// JavaFX keeps the pixels of a canvas in an image. This layer keeps the
+/// drawing calls instead and replays them whenever the canvas is painted,
+/// through the same renderer the shapes use, so what was drawn persists
+/// and stays sharp at any display scale. [GraphicsContext] explains how
+/// the list of calls is kept from growing without bound.
+///
+/// A canvas is transparent where nothing was drawn, is not resizable by a
+/// layout and is hit anywhere inside its bounds.
+public class Canvas extends Node {
+
+    private final DoubleProperty width = new FxDouble(this, "width", 0, Dirty.GEOMETRY);
+    private final DoubleProperty height = new FxDouble(this, "height", 0, Dirty.GEOMETRY);
+    private GraphicsContext context;
+
+    /// Creates a canvas of no size.
+    public Canvas() {
+    }
+
+    /// Creates a canvas of a size.
+    public Canvas(double width, double height) {
+        this.width.set(width);
+        this.height.set(height);
+    }
+
+    /// Returns the one context that draws on this canvas.
+    public GraphicsContext getGraphicsContext2D() {
+        if (context == null) {
+            context = new GraphicsContext(this);
+        }
+        return context;
+    }
+
+    /// Returns the width.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Sets the width. What was drawn is kept.
+    public final void setWidth(double value) {
+        width.set(value);
+    }
+
+    /// The width.
+    public final DoubleProperty widthProperty() {
+        return width;
+    }
+
+    /// Returns the height.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// Sets the height. What was drawn is kept.
+    public final void setHeight(double value) {
+        height.set(value);
+    }
+
+    /// The height.
+    public final DoubleProperty heightProperty() {
+        return height;
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        return new BoundingBox(0, 0, Math.max(0, getWidth()), Math.max(0, getHeight()));
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        if (context != null) {
+            context.replay(renderer);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/canvas/GraphicsContext.java b/maven/javafx-compat/src/main/java/javafx/scene/canvas/GraphicsContext.java
new file mode 100644
index 00000000000..6b0da20a1e8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/canvas/GraphicsContext.java
@@ -0,0 +1,1219 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.canvas;
+
+import java.util.ArrayList;
+
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Matrix2D;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.SvgPath;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.VPos;
+import javafx.scene.image.Image;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.ArcType;
+import javafx.scene.shape.FillRule;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.text.Font;
+import javafx.scene.text.TextAlignment;
+import javafx.scene.transform.Affine;
+
+/// Draws on a [Canvas] with immediate mode calls.
+///
+/// #### A display list, not pixels
+///
+/// Each drawing call is recorded with the state it was made in (paint,
+/// line attributes, transform, global alpha, clip) and replayed through
+/// the layer's renderer every time the canvas is painted. What was drawn
+/// therefore persists between paints, exactly as on a JavaFX canvas.
+///
+/// The list is kept from growing without bound in three ways:
+///
+/// - `clearRect` over the whole canvas, with no clip in force, empties
+///   the list. This is what an animation that redraws every frame does
+///   first, so its list never holds more than one frame.
+/// - Any other `clearRect` removes the recorded calls that lie wholly
+///   inside the cleared rectangle. If calls remain that it only partly
+///   covers, everything recorded so far is drawn once into an off screen
+///   image at the display's resolution, the cleared area is made
+///   transparent in it, and the image replaces the list.
+/// - When more than [#CN1_MAX_RECORDED_CALLS] calls are recorded they
+///   are replaced by such an image in the same way.
+/// - A second image drawn over the whole canvas does the same at once. An
+///   application that shows a picture it keeps computing draws one every
+///   frame and clears nothing, and each recorded call would keep a frame
+///   of pixels alive.
+///
+/// Drawing that was turned into an image is no longer redrawn sharp if
+/// the display scale changes afterwards, and is not enlarged when the
+/// canvas grows.
+///
+/// #### How calls are drawn
+///
+/// - Fills and strokes are exact under any transform. A gradient strokes
+///   with its middle colour.
+/// - Text is drawn by the platform. `fillText` with a maximum width draws
+///   with a proportionally smaller font where JavaFX squeezes the glyphs.
+///   **Glyph outlines are not available, so `strokeText` fills the text
+///   with the stroke paint** instead of outlining it.
+/// - `clip()` is exact on a port that can clip to a shape and the
+///   bounding box of the path on one that cannot. Where several clips are
+///   in force the last one is exact and the earlier ones are reduced to
+///   their bounding boxes, because Codename One replaces a shape clip
+///   rather than intersecting it.
+/// - `drawImage` draws nothing for a `null` image or one that failed to
+///   load.
+///
+/// #### Not part of this layer
+///
+/// Effects, blend modes, `getPixelWriter()`, font smoothing and image
+/// smoothing settings.
+public final class GraphicsContext {
+
+    /// The number of recorded drawing calls above which the list is
+    /// replaced by an image of what it draws.
+    public static final int CN1_MAX_RECORDED_CALLS = 4096;
+
+    private static final int FILL = 0;
+    private static final int STROKE = 1;
+    private static final int TEXT = 2;
+    private static final int IMAGE = 3;
+    private static final FxPath[] NO_CLIPS = new FxPath[0];
+
+    /// One recorded call.
+    private static final class Op {
+        int kind;
+        FxPath path;
+        Paint paint;
+        double[] matrix;
+        double alpha;
+        double width;
+        StrokeLineCap cap;
+        StrokeLineJoin join;
+        double miter;
+        double[] dashes;
+        double dashOffset;
+        String text;
+        Font font;
+        com.codename1.ui.Image image;
+        boolean backing;
+        /// Whether the backing image may be drawn on again: it was made
+        /// to be drawn on and nothing replaced it by one made of pixels.
+        boolean reusable;
+        /// An image, not the backing one, that covers the whole canvas.
+        boolean cover;
+        double x;
+        double y;
+        double w;
+        double h;
+        FxPath[] clips;
+        double[] bounds;
+    }
+
+    /// Everything `save()` remembers.
+    private static final class State {
+        double[] matrix = Matrix2D.identity();
+        Paint fill = Color.BLACK;
+        Paint stroke = Color.BLACK;
+        double lineWidth = 1;
+        StrokeLineCap cap = StrokeLineCap.SQUARE;
+        StrokeLineJoin join = StrokeLineJoin.MITER;
+        double miter = 10;
+        double[] dashes = new double[0];
+        double dashOffset;
+        double alpha = 1;
+        Font font = Font.getDefault();
+        TextAlignment align = TextAlignment.LEFT;
+        VPos baseline = VPos.BASELINE;
+        FillRule rule = FillRule.NON_ZERO;
+        FxPath[] clips = NO_CLIPS;
+
+        State copy() {
+            State s = new State();
+            s.matrix = copyOf(matrix);
+            s.fill = fill;
+            s.stroke = stroke;
+            s.lineWidth = lineWidth;
+            s.cap = cap;
+            s.join = join;
+            s.miter = miter;
+            s.dashes = dashes;
+            s.dashOffset = dashOffset;
+            s.alpha = alpha;
+            s.font = font;
+            s.align = align;
+            s.baseline = baseline;
+            s.rule = rule;
+            s.clips = clips;
+            return s;
+        }
+    }
+
+    private final Canvas canvas;
+    private final ArrayList<Op> ops = new ArrayList<Op>();
+    private final ArrayList<State> saved = new ArrayList<State>();
+    private State state = new State();
+    private final FxPath path = new FxPath();
+    /// How many recorded images cover the whole canvas.
+    private int covers;
+
+    GraphicsContext(Canvas canvas) {
+        this.canvas = canvas;
+    }
+
+    private static double[] copyOf(double[] a) {
+        double[] out = new double[a.length];
+        System.arraycopy(a, 0, out, 0, a.length);
+        return out;
+    }
+
+    /// Returns the canvas this context draws on.
+    public Canvas getCanvas() {
+        return canvas;
+    }
+
+    // ------------------------------------------------------------- state
+
+    /// Remembers the current state: paints, line attributes, font, text
+    /// alignment, fill rule, global alpha, transform and clip. The path
+    /// is not part of it.
+    public void save() {
+        saved.add(state.copy());
+    }
+
+    /// Returns to the state of the matching [#save()]; does nothing when
+    /// there is none.
+    public void restore() {
+        if (!saved.isEmpty()) {
+            state = saved.remove(saved.size() - 1);
+        }
+    }
+
+    /// Moves the origin of the coordinates that follow.
+    public void translate(double x, double y) {
+        state.matrix = Matrix2D.multiply(state.matrix, new double[] {1, 0, 0, 1, x, y});
+    }
+
+    /// Scales the coordinates that follow.
+    public void scale(double x, double y) {
+        state.matrix = Matrix2D.multiply(state.matrix, new double[] {x, 0, 0, y, 0, 0});
+    }
+
+    /// Rotates the coordinates that follow, clockwise, in degrees.
+    public void rotate(double degrees) {
+        double r = Math.toRadians(degrees);
+        double cos = Math.cos(r);
+        double sin = Math.sin(r);
+        state.matrix = Matrix2D.multiply(state.matrix, new double[] {cos, sin, -sin, cos, 0, 0});
+    }
+
+    /// Applies a matrix, given column by column, to the coordinates that
+    /// follow.
+    public void transform(double mxx, double myx, double mxy, double myy, double mxt, double myt) {
+        state.matrix = Matrix2D.multiply(state.matrix, new double[] {mxx, myx, mxy, myy, mxt, myt});
+    }
+
+    /// Applies a transform to the coordinates that follow.
+    public void transform(Affine xform) {
+        if (xform != null) {
+            transform(xform.getMxx(), xform.getMyx(), xform.getMxy(), xform.getMyy(), xform.getTx(), xform.getTy());
+        }
+    }
+
+    /// Replaces the transform with a matrix given column by column.
+    public void setTransform(double mxx, double myx, double mxy, double myy, double mxt, double myt) {
+        state.matrix = new double[] {mxx, myx, mxy, myy, mxt, myt};
+    }
+
+    /// Replaces the transform.
+    public void setTransform(Affine xform) {
+        if (xform != null) {
+            setTransform(xform.getMxx(), xform.getMyx(), xform.getMxy(), xform.getMyy(), xform.getTx(),
+                    xform.getTy());
+        }
+    }
+
+    /// Copies the current transform into an `Affine`, a new one when
+    /// `xform` is `null`, and returns it.
+    public Affine getTransform(Affine xform) {
+        Affine out = xform == null ? new Affine() : xform;
+        double[] m = state.matrix;
+        out.setToTransform(m[0], m[2], m[4], m[1], m[3], m[5]);
+        return out;
+    }
+
+    /// Returns a copy of the current transform.
+    public Affine getTransform() {
+        return getTransform(null);
+    }
+
+    /// Sets the opacity everything is drawn with, clamped to 0..1.
+    public void setGlobalAlpha(double alpha) {
+        state.alpha = alpha > 1 ? 1 : (alpha < 0 ? 0 : alpha);
+    }
+
+    /// Returns the opacity everything is drawn with.
+    public double getGlobalAlpha() {
+        return state.alpha;
+    }
+
+    /// Sets the paint of fills; `null` is ignored.
+    public void setFill(Paint p) {
+        if (p != null) {
+            state.fill = p;
+        }
+    }
+
+    /// Returns the paint of fills.
+    public Paint getFill() {
+        return state.fill;
+    }
+
+    /// Sets the paint of strokes; `null` is ignored.
+    public void setStroke(Paint p) {
+        if (p != null) {
+            state.stroke = p;
+        }
+    }
+
+    /// Returns the paint of strokes.
+    public Paint getStroke() {
+        return state.stroke;
+    }
+
+    /// Sets the width of strokes; a width that is not positive and
+    /// finite is ignored.
+    public void setLineWidth(double lw) {
+        if (lw > 0 && lw < Double.POSITIVE_INFINITY) {
+            state.lineWidth = lw;
+        }
+    }
+
+    /// Returns the width of strokes.
+    public double getLineWidth() {
+        return state.lineWidth;
+    }
+
+    /// Sets how the ends of open strokes are drawn; `null` is ignored.
+    public void setLineCap(StrokeLineCap cap) {
+        if (cap != null) {
+            state.cap = cap;
+        }
+    }
+
+    /// Returns how the ends of open strokes are drawn.
+    public StrokeLineCap getLineCap() {
+        return state.cap;
+    }
+
+    /// Sets how corners of strokes are drawn; `null` is ignored.
+    public void setLineJoin(StrokeLineJoin join) {
+        if (join != null) {
+            state.join = join;
+        }
+    }
+
+    /// Returns how corners of strokes are drawn.
+    public StrokeLineJoin getLineJoin() {
+        return state.join;
+    }
+
+    /// Sets how far a mitred corner may reach, in line widths; a limit
+    /// that is not positive and finite is ignored.
+    public void setMiterLimit(double ml) {
+        if (ml > 0 && ml < Double.POSITIVE_INFINITY) {
+            state.miter = ml;
+        }
+    }
+
+    /// Returns how far a mitred corner may reach.
+    public double getMiterLimit() {
+        return state.miter;
+    }
+
+    /// Sets the dash pattern: the lengths of dashes and gaps in turn. No
+    /// lengths, `null`, a negative or non finite length or lengths that
+    /// are all zero give a solid line.
+    public void setLineDashes(double... dashes) {
+        state.dashes = new double[0];
+        if (dashes == null || dashes.length == 0) {
+            return;
+        }
+        boolean positive = false;
+        for (int i = 0; i < dashes.length; i++) {
+            double d = dashes[i];
+            if (!(d >= 0) || d == Double.POSITIVE_INFINITY) {
+                return;
+            }
+            positive |= d > 0;
+        }
+        if (positive) {
+            state.dashes = copyOf(dashes);
+        }
+    }
+
+    /// Returns a copy of the dash pattern, or `null` for a solid line.
+    public double[] getLineDashes() {
+        return state.dashes.length == 0 ? null : copyOf(state.dashes);
+    }
+
+    /// Sets where in the dash pattern a stroke starts; a non finite
+    /// offset is ignored.
+    public void setLineDashOffset(double dashOffset) {
+        if (dashOffset > Double.NEGATIVE_INFINITY && dashOffset < Double.POSITIVE_INFINITY) {
+            state.dashOffset = dashOffset;
+        }
+    }
+
+    /// Returns where in the dash pattern a stroke starts.
+    public double getLineDashOffset() {
+        return state.dashOffset;
+    }
+
+    /// Sets the font of text; `null` is ignored.
+    public void setFont(Font f) {
+        if (f != null) {
+            state.font = f;
+        }
+    }
+
+    /// Returns the font of text.
+    public Font getFont() {
+        return state.font;
+    }
+
+    /// Sets which part of a text its x is the position of: its left
+    /// edge, centre or right edge. `null` is ignored.
+    public void setTextAlign(TextAlignment align) {
+        if (align != null) {
+            state.align = align;
+        }
+    }
+
+    /// Returns which part of a text its x is the position of.
+    public TextAlignment getTextAlign() {
+        return state.align;
+    }
+
+    /// Sets which part of a text its y is the position of: the baseline,
+    /// top, centre or bottom. `null` is ignored.
+    public void setTextBaseline(VPos baseline) {
+        if (baseline != null) {
+            state.baseline = baseline;
+        }
+    }
+
+    /// Returns which part of a text its y is the position of.
+    public VPos getTextBaseline() {
+        return state.baseline;
+    }
+
+    /// Sets how the inside of a path or polygon is decided; `null` is
+    /// ignored.
+    public void setFillRule(FillRule fillRule) {
+        if (fillRule != null) {
+            state.rule = fillRule;
+        }
+    }
+
+    /// Returns how the inside of a path or polygon is decided.
+    public FillRule getFillRule() {
+        return state.rule;
+    }
+
+    // --------------------------------------------------------- recording
+
+    private Op op(int kind, double[] matrix) {
+        Op o = new Op();
+        o.kind = kind;
+        o.matrix = copyOf(matrix);
+        o.alpha = state.alpha;
+        o.clips = state.clips;
+        return o;
+    }
+
+    private void record(Op o) {
+        ops.add(o);
+        if (ops.size() > CN1_MAX_RECORDED_CALLS) {
+            rasterise();
+        }
+        canvas.cn1Repaint();
+    }
+
+    private void recordFill(FxPath shape, double[] matrix) {
+        double[] b = shape.transformed(matrix).bounds();
+        if (b == null) {
+            return;
+        }
+        Op o = op(FILL, matrix);
+        o.path = shape;
+        o.paint = state.fill;
+        o.bounds = b;
+        record(o);
+    }
+
+    private void recordStroke(FxPath shape, double[] matrix, double width) {
+        double[] b = shape.transformed(matrix).bounds();
+        if (b == null) {
+            return;
+        }
+        Op o = op(STROKE, matrix);
+        o.path = shape;
+        o.paint = state.stroke;
+        o.width = width;
+        o.cap = state.cap;
+        o.join = state.join;
+        o.miter = state.miter;
+        o.dashes = state.dashes;
+        o.dashOffset = state.dashOffset;
+        // Generous: a mitred corner and a square cap reach past half the
+        // width, and too large a box only costs an exact clear later.
+        double reach = width * Matrix2D.uniformScale(matrix)
+                * Math.max(2, state.join == StrokeLineJoin.MITER ? state.miter : 1) / 2;
+        o.bounds = new double[] {b[0] - reach, b[1] - reach, b[2] + reach, b[3] + reach};
+        record(o);
+    }
+
+    private void fillShape(FxPath shape) {
+        shape.setEvenOdd(state.rule == FillRule.EVEN_ODD);
+        recordFill(shape, state.matrix);
+    }
+
+    private void strokeShape(FxPath shape) {
+        recordStroke(shape, state.matrix, state.lineWidth);
+    }
+
+    /// Draws what was recorded; called by the canvas when it paints.
+    void replay(Renderer r) {
+        replay(r, 0);
+    }
+
+    private void replay(Renderer r, int from) {
+        for (int i = from; i < ops.size(); i++) {
+            Op o = ops.get(i);
+            r.save();
+            for (int c = 0; c < o.clips.length; c++) {
+                r.clip(o.clips[c]);
+            }
+            double[] m = o.matrix;
+            r.concat(m[0], m[1], m[2], m[3], m[4], m[5]);
+            r.multiplyOpacity(o.alpha);
+            switch (o.kind) {
+                case FILL: {
+                    double[] b = o.path.bounds();
+                    if (b != null) {
+                        r.fill(o.path, o.paint, b[0], b[1], b[2] - b[0], b[3] - b[1]);
+                    }
+                    break;
+                }
+                case STROKE:
+                    r.stroke(o.path, o.paint, o.width, o.cap, o.join, o.miter, o.dashes, o.dashOffset);
+                    break;
+                case TEXT:
+                    r.drawText(o.text, o.x, o.y, o.font, o.paint);
+                    break;
+                default:
+                    r.drawImage(o.image, o.x, o.y, o.w, o.h);
+                    break;
+            }
+            r.restore();
+        }
+    }
+
+    /// Replaces the list by one image of what it draws. Answers the
+    /// operation holding that image, or `null` when there is nothing to
+    /// keep.
+    private Op rasterise() {
+        if (ops.size() == 1 && ops.get(0).backing) {
+            return ops.get(0);
+        }
+        double s = Units.scale();
+        int pw = (int) Math.ceil(canvas.getWidth() * s - 1e-6);
+        int ph = (int) Math.ceil(canvas.getHeight() * s - 1e-6);
+        covers = 0;
+        if (pw <= 0 || ph <= 0 || ops.isEmpty()) {
+            ops.clear();
+            return null;
+        }
+        Op first = ops.get(0);
+        if (first.backing && first.reusable && first.image.getWidth() == pw && first.image.getHeight() == ph) {
+            // The image of the last time is at the bottom of the list and
+            // nothing else has it, so what came after is drawn onto it:
+            // the same pixels as drawing both onto a new one.
+            replay(new Renderer(fresh(first.image, pw, ph), 0, 0), 1);
+            ops.clear();
+            ops.add(first);
+            return first;
+        }
+        com.codename1.ui.Image image = com.codename1.ui.Image.createImage(pw, ph, 0);
+        replay(new Renderer(fresh(image, pw, ph), 0, 0));
+        ops.clear();
+        Op o = new Op();
+        o.kind = IMAGE;
+        o.matrix = Matrix2D.identity();
+        o.alpha = 1;
+        o.clips = NO_CLIPS;
+        o.image = image;
+        o.backing = true;
+        o.reusable = true;
+        o.w = pw / s;
+        o.h = ph / s;
+        o.bounds = new double[] {0, 0, o.w, o.h};
+        ops.add(o);
+        return o;
+    }
+
+    /// The graphics of an image about to be drawn on, as a new one is: no
+    /// clip but the image, no matrix, opaque. A port may hand out one
+    /// graphics for an image however often it is asked -- the native ports
+    /// do -- and that one still has the clip and the matrix the last
+    /// drawing left on it.
+    private static com.codename1.ui.Graphics fresh(com.codename1.ui.Image image, int pw, int ph) {
+        com.codename1.ui.Graphics g = image.getGraphics();
+        if (g.isTransformSupported()) {
+            g.setTransform(com.codename1.ui.Transform.makeIdentity());
+        }
+        g.translate(-g.getTranslateX(), -g.getTranslateY());
+        g.setClip(0, 0, pw, ph);
+        g.setAlpha(255);
+        return g;
+    }
+
+    // -------------------------------------------------------------- text
+
+    private void text(String text, double x, double y, double maxWidth, boolean limited, Paint paint) {
+        if (text == null || text.length() == 0 || (limited && !(maxWidth > 0))) {
+            return;
+        }
+        Font font = state.font;
+        int lineCount = 1;
+        for (int i = 0; i < text.length(); i++) {
+            if (text.charAt(i) == '\n') {
+                lineCount++;
+            }
+        }
+        String[] lines = new String[lineCount];
+        int start = 0;
+        double widest = 0;
+        for (int i = 0; i < lineCount; i++) {
+            int feed = text.indexOf('\n', start);
+            lines[i] = feed < 0 ? text.substring(start) : text.substring(start, feed);
+            start = feed + 1;
+            widest = Math.max(widest, Fonts.width(font, lines[i]));
+        }
+        if (limited && widest > maxWidth) {
+            font = Font.font(font.getFamily(), font.cn1Weight(), font.cn1Posture(),
+                    font.getSize() * maxWidth / widest);
+        }
+        double lineHeight = Fonts.lineHeight(font);
+        double height = lineHeight * lineCount;
+        double top = y - Fonts.ascent(font);
+        if (state.baseline == VPos.TOP) {
+            top = y;
+        } else if (state.baseline == VPos.CENTER) {
+            top = y - height / 2;
+        } else if (state.baseline == VPos.BOTTOM) {
+            top = y - height;
+        }
+        for (int i = 0; i < lineCount; i++) {
+            if (lines[i].length() == 0) {
+                continue;
+            }
+            double w = Fonts.width(font, lines[i]);
+            double left = x;
+            if (state.align == TextAlignment.CENTER) {
+                left = x - w / 2;
+            } else if (state.align == TextAlignment.RIGHT) {
+                left = x - w;
+            }
+            Op o = op(TEXT, state.matrix);
+            o.text = lines[i];
+            o.font = font;
+            o.paint = paint;
+            o.x = left;
+            o.y = top + i * lineHeight;
+            o.bounds = Matrix2D.bounds(state.matrix, o.x, o.y, w, lineHeight);
+            record(o);
+        }
+    }
+
+    /// Draws text with the fill paint at a point; see
+    /// [#setTextAlign(TextAlignment)] and [#setTextBaseline(VPos)] for
+    /// what the point is. Line feeds start new lines.
+    public void fillText(String text, double x, double y) {
+        text(text, x, y, 0, false, state.fill);
+    }
+
+    /// Draws text with the stroke paint at a point. The text is filled
+    /// rather than outlined; see the class description.
+    public void strokeText(String text, double x, double y) {
+        text(text, x, y, 0, false, state.stroke);
+    }
+
+    /// Draws text with the fill paint, made smaller when it is wider
+    /// than a maximum width. Nothing is drawn for a maximum that is not
+    /// positive.
+    public void fillText(String text, double x, double y, double maxWidth) {
+        text(text, x, y, maxWidth, true, state.fill);
+    }
+
+    /// Draws text with the stroke paint, made smaller when it is wider
+    /// than a maximum width. The text is filled rather than outlined.
+    public void strokeText(String text, double x, double y, double maxWidth) {
+        text(text, x, y, maxWidth, true, state.stroke);
+    }
+
+    // -------------------------------------------------------------- path
+
+    /// Adds a path given in the current coordinates to the context's
+    /// path, which is kept in the canvas's coordinates.
+    private void addToPath(FxPath user, boolean connect) {
+        FxPath t = user.transformed(state.matrix);
+        double[] pts = t.points();
+        int p = 0;
+        for (int i = 0; i < t.commandCount(); i++) {
+            switch (t.command(i)) {
+                case FxPath.MOVE:
+                    if (i == 0 && connect && !path.isEmpty()) {
+                        path.lineTo(pts[p], pts[p + 1]);
+                    } else {
+                        path.moveTo(pts[p], pts[p + 1]);
+                    }
+                    p += 2;
+                    break;
+                case FxPath.LINE:
+                    path.lineTo(pts[p], pts[p + 1]);
+                    p += 2;
+                    break;
+                case FxPath.QUAD:
+                    path.quadTo(pts[p], pts[p + 1], pts[p + 2], pts[p + 3]);
+                    p += 4;
+                    break;
+                case FxPath.CUBIC:
+                    path.curveTo(pts[p], pts[p + 1], pts[p + 2], pts[p + 3], pts[p + 4], pts[p + 5]);
+                    p += 6;
+                    break;
+                default:
+                    path.closePath();
+                    break;
+            }
+        }
+    }
+
+    private double tx(double x, double y) {
+        return Matrix2D.x(state.matrix, x, y);
+    }
+
+    private double ty(double x, double y) {
+        return Matrix2D.y(state.matrix, x, y);
+    }
+
+    /// Empties the path.
+    public void beginPath() {
+        path.reset();
+    }
+
+    /// Starts a new part of the path at a point.
+    public void moveTo(double x0, double y0) {
+        path.moveTo(tx(x0, y0), ty(x0, y0));
+    }
+
+    /// Adds a line to a point; on an empty path it only moves there.
+    public void lineTo(double x1, double y1) {
+        path.lineTo(tx(x1, y1), ty(x1, y1));
+    }
+
+    /// Adds a quadratic curve to a point.
+    public void quadraticCurveTo(double xc, double yc, double x1, double y1) {
+        path.quadTo(tx(xc, yc), ty(xc, yc), tx(x1, y1), ty(x1, y1));
+    }
+
+    /// Adds a cubic curve to a point.
+    public void bezierCurveTo(double xc1, double yc1, double xc2, double yc2, double x1, double y1) {
+        path.curveTo(tx(xc1, yc1), ty(xc1, yc1), tx(xc2, yc2), ty(xc2, yc2), tx(x1, y1), ty(x1, y1));
+    }
+
+    /// Rounds the corner at `(x1, y1)` on the way to `(x2, y2)`: adds a
+    /// line from the current point towards the corner and an arc of a
+    /// radius that touches both that line and the one from the corner to
+    /// the second point. On an empty path it moves to the corner; a zero
+    /// radius or three points on one line give a line to the corner.
+    public void arcTo(double x1, double y1, double x2, double y2, double radius) {
+        if (path.isEmpty()) {
+            moveTo(x1, y1);
+            return;
+        }
+        double[] inverse = new double[6];
+        if (!(radius > 0) || !Matrix2D.invert(state.matrix, inverse)) {
+            lineTo(x1, y1);
+            return;
+        }
+        double x0 = Matrix2D.x(inverse, path.currentX(), path.currentY());
+        double y0 = Matrix2D.y(inverse, path.currentX(), path.currentY());
+        double ax = x0 - x1;
+        double ay = y0 - y1;
+        double bx = x2 - x1;
+        double by = y2 - y1;
+        double la = Math.sqrt(ax * ax + ay * ay);
+        double lb = Math.sqrt(bx * bx + by * by);
+        if (!(la > 0) || !(lb > 0)) {
+            lineTo(x1, y1);
+            return;
+        }
+        ax /= la;
+        ay /= la;
+        bx /= lb;
+        by /= lb;
+        double cross = ax * by - ay * bx;
+        double dot = ax * bx + ay * by;
+        if (Math.abs(cross) < 1e-9) {
+            lineTo(x1, y1);
+            return;
+        }
+        // The distance from the corner to where the circle touches: the
+        // radius over the tangent of half the angle between the lines.
+        double halfTan = Math.sqrt((1 - dot) / (1 + dot));
+        double d = radius / halfTan;
+        FxPath arc = new FxPath();
+        arc.moveTo(x1 + ax * d, y1 + ay * d);
+        arc.arcTo(radius, radius, 0, false, cross < 0, x1 + bx * d, y1 + by * d);
+        addToPath(arc, true);
+    }
+
+    /// Adds part of an ellipse, joined to the current point by a line.
+    /// Angles are in degrees, counter clockwise from the positive x
+    /// axis.
+    public void arc(double centerX, double centerY, double radiusX, double radiusY, double startAngle,
+            double length) {
+        FxPath arc = new FxPath();
+        arc.addArc(centerX, centerY, radiusX, radiusY, startAngle, length, false);
+        addToPath(arc, true);
+    }
+
+    /// Adds a closed rectangle as a part of its own.
+    public void rect(double x, double y, double w, double h) {
+        FxPath r = new FxPath();
+        r.addRect(x, y, w, h);
+        addToPath(r, false);
+    }
+
+    /// Adds SVG path data. On an empty path it has to start with a move;
+    /// otherwise it may continue from the current point. Data that stops
+    /// making sense adds what came before the error.
+    public void appendSVGPath(String svgpath) {
+        if (svgpath == null) {
+            return;
+        }
+        FxPath user = new FxPath();
+        double[] inverse = new double[6];
+        boolean continues = !path.isEmpty() && Matrix2D.invert(state.matrix, inverse);
+        if (continues) {
+            user.moveTo(Matrix2D.x(inverse, path.currentX(), path.currentY()),
+                    Matrix2D.y(inverse, path.currentX(), path.currentY()));
+        }
+        SvgPath.append(svgpath, user);
+        addToPath(user, continues);
+    }
+
+    /// Closes the current part of the path.
+    public void closePath() {
+        path.closePath();
+    }
+
+    /// Fills the path with the fill paint.
+    public void fill() {
+        FxPath copy = path.copy();
+        copy.setEvenOdd(state.rule == FillRule.EVEN_ODD);
+        recordFill(copy, Matrix2D.identity());
+    }
+
+    /// Strokes the path with the stroke paint. The line width is scaled
+    /// by the current transform.
+    public void stroke() {
+        recordStroke(path.copy(), Matrix2D.identity(), state.lineWidth * Matrix2D.uniformScale(state.matrix));
+    }
+
+    /// Restricts what is drawn from now on to the inside of the path, in
+    /// addition to the clips already in force, until the matching
+    /// [#restore()]. See the class description for how exact that is.
+    public void clip() {
+        FxPath copy = path.copy();
+        copy.setEvenOdd(state.rule == FillRule.EVEN_ODD);
+        FxPath[] clips = new FxPath[state.clips.length + 1];
+        System.arraycopy(state.clips, 0, clips, 0, state.clips.length);
+        clips[state.clips.length] = copy;
+        state.clips = clips;
+    }
+
+    /// Returns whether a point, in the canvas's own coordinates, is
+    /// inside the path.
+    public boolean isPointInPath(double x, double y) {
+        FxPath copy = path.copy();
+        copy.setEvenOdd(state.rule == FillRule.EVEN_ODD);
+        return copy.contains(x, y);
+    }
+
+    // ------------------------------------------------------------ shapes
+
+    private static boolean inside(double[] inner, double[] outer) {
+        return inner[0] >= outer[0] - 1e-9 && inner[1] >= outer[1] - 1e-9 && inner[2] <= outer[2] + 1e-9
+                && inner[3] <= outer[3] + 1e-9;
+    }
+
+    private static boolean apart(double[] a, double[] b) {
+        return a[2] <= b[0] || b[2] <= a[0] || a[3] <= b[1] || b[3] <= a[1];
+    }
+
+    /// Makes a rectangle transparent again. See the class description
+    /// for what that does to the recorded calls. A clip in force limits
+    /// what is cleared.
+    public void clearRect(double x, double y, double w, double h) {
+        if (Math.abs(w) <= 0 || Math.abs(h) <= 0) {
+            return;
+        }
+        double[] m = state.matrix;
+        boolean upright = Math.abs(m[1]) <= 0 && Math.abs(m[2]) <= 0;
+        boolean clipped = state.clips.length > 0;
+        double[] cleared = Matrix2D.bounds(m, x, y, w, h);
+        double[] whole = {0, 0, Math.max(0, canvas.getWidth()), Math.max(0, canvas.getHeight())};
+        if (upright && !clipped && inside(whole, cleared)) {
+            ops.clear();
+            covers = 0;
+            canvas.cn1Repaint();
+            return;
+        }
+        boolean partly = false;
+        for (int i = ops.size() - 1; i >= 0; i--) {
+            double[] b = ops.get(i).bounds;
+            if (apart(b, cleared)) {
+                continue;
+            }
+            if (upright && !clipped && inside(b, cleared)) {
+                if (ops.remove(i).cover) {
+                    covers--;
+                }
+            } else {
+                partly = true;
+            }
+        }
+        if (partly) {
+            Op backing = rasterise();
+            if (backing != null) {
+                FxPath quad = new FxPath();
+                quad.addRect(x, y, w, h);
+                punch(backing, quad.transformed(m), upright && !clipped ? cleared : null);
+            }
+        }
+        canvas.cn1Repaint();
+    }
+
+    /// Makes the pixels of the backing image inside a shape, and inside
+    /// every clip in force, transparent. `box` is the shape when it is
+    /// an upright rectangle with no clip, which needs no test per pixel.
+    private void punch(Op backing, FxPath shape, double[] box) {
+        com.codename1.ui.Image image = backing.image;
+        int iw = image.getWidth();
+        int ih = image.getHeight();
+        if (iw <= 0 || ih <= 0 || !(backing.w > 0) || !(backing.h > 0)) {
+            return;
+        }
+        double sx = iw / backing.w;
+        double sy = ih / backing.h;
+        double[] toPixels = {sx, 0, 0, sy, 0, 0};
+        FxPath device = shape.transformed(toPixels).flatten(0.25);
+        double[] b = device.bounds();
+        if (b == null) {
+            return;
+        }
+        int x1 = (int) Math.max(0, box != null ? Math.round(b[0]) : Math.floor(b[0]));
+        int y1 = (int) Math.max(0, box != null ? Math.round(b[1]) : Math.floor(b[1]));
+        int x2 = (int) Math.min(iw, box != null ? Math.round(b[2]) : Math.ceil(b[2]));
+        int y2 = (int) Math.min(ih, box != null ? Math.round(b[3]) : Math.ceil(b[3]));
+        if (x2 <= x1 || y2 <= y1) {
+            return;
+        }
+        FxPath[] clips = new FxPath[state.clips.length];
+        for (int i = 0; i < clips.length; i++) {
+            clips[i] = state.clips[i].transformed(toPixels).flatten(0.25);
+        }
+        int[] rgb = image.getRGB();
+        if (rgb == null || rgb.length < iw * ih) {
+            return;
+        }
+        for (int py = y1; py < y2; py++) {
+            for (int px = x1; px < x2; px++) {
+                boolean clear = box != null || device.contains(px + 0.5, py + 0.5);
+                for (int c = 0; clear && c < clips.length; c++) {
+                    clear = clips[c].contains(px + 0.5, py + 0.5);
+                }
+                if (clear) {
+                    rgb[py * iw + px] = 0;
+                }
+            }
+        }
+        backing.image = com.codename1.ui.Image.createImage(rgb, iw, ih);
+        backing.reusable = false;
+    }
+
+    /// Fills a rectangle.
+    public void fillRect(double x, double y, double w, double h) {
+        FxPath p = new FxPath();
+        p.addRect(x, y, w, h);
+        fillShape(p);
+    }
+
+    /// Strokes the outline of a rectangle.
+    public void strokeRect(double x, double y, double w, double h) {
+        FxPath p = new FxPath();
+        p.addRect(x, y, w, h);
+        strokeShape(p);
+    }
+
+    /// Fills the ellipse inside a rectangle.
+    public void fillOval(double x, double y, double w, double h) {
+        FxPath p = new FxPath();
+        p.addEllipse(x + w / 2, y + h / 2, w / 2, h / 2);
+        fillShape(p);
+    }
+
+    /// Strokes the ellipse inside a rectangle.
+    public void strokeOval(double x, double y, double w, double h) {
+        FxPath p = new FxPath();
+        p.addEllipse(x + w / 2, y + h / 2, w / 2, h / 2);
+        strokeShape(p);
+    }
+
+    private static FxPath arcPath(double x, double y, double w, double h, double startAngle, double arcExtent,
+            ArcType closure) {
+        FxPath p = new FxPath();
+        double cx = x + w / 2;
+        double cy = y + h / 2;
+        if (closure == ArcType.ROUND) {
+            p.moveTo(cx, cy);
+        }
+        p.addArc(cx, cy, w / 2, h / 2, startAngle, arcExtent, closure == ArcType.ROUND);
+        if (closure == ArcType.ROUND || closure == ArcType.CHORD) {
+            p.closePath();
+        }
+        return p;
+    }
+
+    /// Fills part of the ellipse inside a rectangle. Angles are in
+    /// degrees, counter clockwise from the positive x axis; the closure
+    /// says how the ends are joined.
+    public void fillArc(double x, double y, double w, double h, double startAngle, double arcExtent,
+            ArcType closure) {
+        if (closure != null) {
+            fillShape(arcPath(x, y, w, h, startAngle, arcExtent, closure));
+        }
+    }
+
+    /// Strokes part of the ellipse inside a rectangle.
+    public void strokeArc(double x, double y, double w, double h, double startAngle, double arcExtent,
+            ArcType closure) {
+        if (closure != null) {
+            strokeShape(arcPath(x, y, w, h, startAngle, arcExtent, closure));
+        }
+    }
+
+    /// Fills a rectangle with rounded corners; the arc sizes are the
+    /// diameters of the corners.
+    public void fillRoundRect(double x, double y, double w, double h, double arcWidth, double arcHeight) {
+        FxPath p = new FxPath();
+        p.addRoundRect(x, y, w, h, arcWidth / 2, arcHeight / 2);
+        fillShape(p);
+    }
+
+    /// Strokes the outline of a rectangle with rounded corners.
+    public void strokeRoundRect(double x, double y, double w, double h, double arcWidth, double arcHeight) {
+        FxPath p = new FxPath();
+        p.addRoundRect(x, y, w, h, arcWidth / 2, arcHeight / 2);
+        strokeShape(p);
+    }
+
+    /// Strokes a line between two points.
+    public void strokeLine(double x1, double y1, double x2, double y2) {
+        FxPath p = new FxPath();
+        p.moveTo(x1, y1);
+        p.lineTo(x2, y2);
+        strokeShape(p);
+    }
+
+    private static FxPath polygon(double[] xPoints, double[] yPoints, int nPoints, boolean close) {
+        FxPath p = new FxPath();
+        if (xPoints == null || yPoints == null) {
+            return p;
+        }
+        int n = Math.min(nPoints, Math.min(xPoints.length, yPoints.length));
+        for (int i = 0; i < n; i++) {
+            if (i == 0) {
+                p.moveTo(xPoints[i], yPoints[i]);
+            } else {
+                p.lineTo(xPoints[i], yPoints[i]);
+            }
+        }
+        if (close && n > 0) {
+            p.closePath();
+        }
+        return p;
+    }
+
+    /// Fills the polygon through points, using the fill rule.
+    public void fillPolygon(double[] xPoints, double[] yPoints, int nPoints) {
+        if (nPoints >= 3) {
+            fillShape(polygon(xPoints, yPoints, nPoints, true));
+        }
+    }
+
+    /// Strokes the closed outline through points.
+    public void strokePolygon(double[] xPoints, double[] yPoints, int nPoints) {
+        if (nPoints >= 2) {
+            strokeShape(polygon(xPoints, yPoints, nPoints, true));
+        }
+    }
+
+    /// Strokes the open outline through points.
+    public void strokePolyline(double[] xPoints, double[] yPoints, int nPoints) {
+        if (nPoints >= 2) {
+            strokeShape(polygon(xPoints, yPoints, nPoints, false));
+        }
+    }
+
+    // ------------------------------------------------------------ images
+
+    private void image(com.codename1.ui.Image picture, double x, double y, double w, double h) {
+        if (picture == null) {
+            return;
+        }
+        // A negative size mirrors, as it does in JavaFX.
+        double[] m = state.matrix;
+        double dx = x;
+        double dy = y;
+        double dw = w;
+        double dh = h;
+        if (dw < 0 || dh < 0) {
+            m = Matrix2D.multiply(m, new double[] {dw < 0 ? -1 : 1, 0, 0, dh < 0 ? -1 : 1, dw < 0 ? 2 * x + w : 0,
+                dh < 0 ? 2 * y + h : 0});
+            if (dw < 0) {
+                dx = x + w;
+                dw = -w;
+            }
+            if (dh < 0) {
+                dy = y + h;
+                dh = -h;
+            }
+        }
+        if (!(dw > 0) || !(dh > 0)) {
+            return;
+        }
+        Op o = op(IMAGE, m);
+        o.image = picture;
+        o.x = dx;
+        o.y = dy;
+        o.w = dw;
+        o.h = dh;
+        o.bounds = Matrix2D.bounds(m, dx, dy, dw, dh);
+        // An image over the whole canvas hides most of what is under it,
+        // and an application that shows a picture it keeps computing
+        // draws one every frame without clearing. A list of them is a
+        // frame of pixels kept alive per call, thousands of them before
+        // the limit on calls is reached, and no collector can give back
+        // what is still referenced. The second one folds the list into
+        // the canvas image.
+        double[] whole = {0, 0, Math.max(0, canvas.getWidth()), Math.max(0, canvas.getHeight())};
+        o.cover = state.clips.length == 0 && inside(whole, o.bounds);
+        if (o.cover) {
+            covers++;
+        }
+        record(o);
+        if (covers > 1) {
+            rasterise();
+        }
+    }
+
+    /// Draws an image at its own size with its top left corner at a
+    /// point.
+    public void drawImage(Image img, double x, double y) {
+        if (img != null) {
+            image(img.cn1Native(), x, y, img.getWidth(), img.getHeight());
+        }
+    }
+
+    /// Draws an image into a rectangle.
+    public void drawImage(Image img, double x, double y, double w, double h) {
+        if (img != null) {
+            image(img.cn1Native(), x, y, w, h);
+        }
+    }
+
+    /// Draws a rectangle of an image, given in its pixels, into a
+    /// rectangle of the canvas. The part of the source rectangle that
+    /// lies outside the image is not drawn, unless it is less than a
+    /// pixel of it.
+    public void drawImage(Image img, double sx, double sy, double sw, double sh, double dx, double dy, double dw,
+            double dh) {
+        com.codename1.ui.Image full = img == null ? null : img.cn1Native();
+        if (full == null || !(sw > 0) || !(sh > 0)) {
+            return;
+        }
+        int x1 = (int) Math.max(0, Math.round(sx));
+        int y1 = (int) Math.max(0, Math.round(sy));
+        int x2 = (int) Math.min(full.getWidth(), Math.round(sx + sw));
+        int y2 = (int) Math.min(full.getHeight(), Math.round(sy + sh));
+        if (x2 <= x1 || y2 <= y1) {
+            return;
+        }
+        // The destination shrinks with the part of the source that was
+        // cut off -- but not for a part of less than one pixel. JavaFX
+        // reads past the edge of an image by repeating its last pixel,
+        // so a source rectangle a fraction wider than the image, which
+        // is what `(int) width` of a size that is not whole leaves,
+        // still fills its whole destination. Shrinking it left a line
+        // of the canvas undrawn between this image and whatever the
+        // application drew beside it.
+        double kx = dw / sw;
+        double ky = dh / sh;
+        double left = within(x1 - sx);
+        double top = within(y1 - sy);
+        double right = within(sx + sw - x2);
+        double bottom = within(sy + sh - y2);
+        // The whole picture is the picture: cutting it out of itself made
+        // a second image of the platform for every call.
+        boolean all = x1 == 0 && y1 == 0 && x2 == full.getWidth() && y2 == full.getHeight();
+        image(all ? full : full.subImage(x1, y1, x2 - x1, y2 - y1, true), dx + left * kx, dy + top * ky,
+                dw - (left + right) * kx, dh - (top + bottom) * ky);
+    }
+
+    /// What of a source rectangle is cut off at one side, for the
+    /// destination: nothing when it is less than a pixel, which the last
+    /// pixel of the image covers, and nothing for a negative amount, a
+    /// side that rounding moved outwards.
+    private static double within(double cut) {
+        return cut < 1 ? 0 : cut;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/canvas/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/canvas/package-info.java
new file mode 100644
index 00000000000..2b9b2c4c20e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/canvas/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The canvas: a node drawn on with immediate mode calls, which this
+/// layer records and replays through its one renderer.
+package javafx.scene.canvas;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/AreaChart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/AreaChart.java
new file mode 100644
index 00000000000..a355b91496a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/AreaChart.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.collections.ObservableList;
+import javafx.scene.paint.Color;
+
+/// A chart that fills the area between the line of each series and zero.
+///
+/// The points of a series are joined in the order of their X values; the
+/// fill is the colour of the series at a fifth of its strength, with a
+/// line of one pixel over it and a small ring at each point. See [Chart]
+/// for what the charts of this layer leave out.
+public class AreaChart<X, Y> extends XYChart<X, Y> {
+
+    private final BooleanProperty createSymbols = new FxBoolean(this, "createSymbols", true, Dirty.PAINT);
+
+    /// Creates an area chart.
+    public AreaChart(Axis<X> xAxis, Axis<Y> yAxis) {
+        super(xAxis, yAxis);
+    }
+
+    /// Creates an area chart of the given series.
+    public AreaChart(Axis<X> xAxis, Axis<Y> yAxis, ObservableList<Series<X, Y>> data) {
+        super(xAxis, yAxis);
+        setData(data);
+    }
+
+    /// Returns whether a symbol is drawn at each point.
+    public final boolean getCreateSymbols() {
+        return createSymbols.get();
+    }
+
+    /// Sets whether a symbol is drawn at each point.
+    public final void setCreateSymbols(boolean value) {
+        createSymbols.set(value);
+    }
+
+    /// Whether a symbol is drawn at each point.
+    public final BooleanProperty createSymbolsProperty() {
+        return createSymbols;
+    }
+
+    @Override
+    double[] legendSymbolSize(int index) {
+        return new double[] {12, 12};
+    }
+
+    @Override
+    void legendSymbol(Renderer renderer, int index, double x, double y) {
+        ring(renderer, x + 6, y + 6, 6, 3, color(index));
+    }
+
+    @Override
+    void drawSeries(Renderer renderer, List<Series<X, Y>> series, Scale sx, Scale sy, double x, double y, double w,
+            double h) {
+        double base = y + (sy.category ? h : sy.base());
+        for (int s = 0; s < series.size(); s++) {
+            List<double[]> points = LineChart.places(series.get(s), sx, sy, x, y, 0);
+            if (points.isEmpty()) {
+                continue;
+            }
+            Color color = color(s);
+            if (points.size() > 1) {
+                FxPath area = new FxPath();
+                area.moveTo(points.get(0)[0], base);
+                for (int i = 0; i < points.size(); i++) {
+                    area.lineTo(points.get(i)[0], points.get(i)[1]);
+                }
+                area.lineTo(points.get(points.size() - 1)[0], base);
+                area.closePath();
+                renderer.fill(area, Color.color(color.getRed(), color.getGreen(), color.getBlue(), 0.2), x, y, w,
+                        h);
+            }
+            LineChart.polyline(renderer, points, color, 1);
+            if (getCreateSymbols()) {
+                for (int i = 0; i < points.size(); i++) {
+                    ring(renderer, points.get(i)[0], points.get(i)[1], 3, 2, color);
+                }
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/Axis.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/Axis.java
new file mode 100644
index 00000000000..0f10b72d699
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/Axis.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxString;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.geometry.Side;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.Font;
+
+/// One axis of a chart: its label and how its ticks are shown.
+///
+/// An axis is drawn by the chart it belongs to and is not a child of it;
+/// it is a region so that code and FXML that treat it as one compile,
+/// and its own size and position mean nothing. The axis is drawn on its
+/// `side` of the plot, with its tick marks and labels outside the plot,
+/// and its tick labels turned by `tickLabelRotation` degrees.
+public abstract class Axis<T> extends Region {
+
+    private final StringProperty label = new FxString(this, "label", null, Dirty.PAINT);
+    private final ObjectProperty<Side> side = new FxObject<Side>(this, "side", null, Dirty.PAINT);
+    private final BooleanProperty autoRanging = new FxBoolean(this, "autoRanging", true, Dirty.PAINT);
+    private final BooleanProperty tickLabelsVisible = new FxBoolean(this, "tickLabelsVisible", true, Dirty.PAINT);
+    private final BooleanProperty tickMarkVisible = new FxBoolean(this, "tickMarkVisible", true, Dirty.PAINT);
+    private final DoubleProperty tickLabelRotation = new FxDouble(this, "tickLabelRotation", 0, Dirty.PAINT);
+    private final DoubleProperty tickLength = new FxDouble(this, "tickLength", 8, Dirty.PAINT);
+    private final DoubleProperty tickLabelGap = new FxDouble(this, "tickLabelGap", 3, Dirty.PAINT);
+    private final ObjectProperty<Font> tickLabelFont = new FxObject<Font>(this, "tickLabelFont", Font.font(10),
+            Dirty.PAINT);
+    private final ObjectProperty<Paint> tickLabelFill = new FxObject<Paint>(this, "tickLabelFill",
+            Color.web("#707070"), Dirty.PAINT);
+    private boolean animated = true;
+    private Chart chart;
+
+    /// Creates an axis.
+    public Axis() {
+    }
+
+    /// The chart that draws this axis.
+    final void attach(Chart owner) {
+        chart = owner;
+    }
+
+    /// A change of the axis is a repaint of its chart.
+    @Override
+    public void cn1Invalidated(int what) {
+        super.cn1Invalidated(what);
+        if (chart != null && what != Dirty.NONE) {
+            chart.cn1Repaint();
+        }
+    }
+
+    /// Returns the label of the axis, `null` for none.
+    public final String getLabel() {
+        return label.get();
+    }
+
+    /// Sets the label drawn along the axis.
+    public final void setLabel(String value) {
+        label.set(value);
+    }
+
+    /// The label drawn along the axis.
+    public final StringProperty labelProperty() {
+        return label;
+    }
+
+    /// Returns the side of the plot the axis is drawn on.
+    public final Side getSide() {
+        return side.get();
+    }
+
+    /// Sets the side of the plot the axis is drawn on. A side that does
+    /// not suit the direction of the axis - left or right for the X axis
+    /// of a chart - is taken as bottom, or left for a Y axis.
+    public final void setSide(Side value) {
+        side.set(value);
+    }
+
+    /// The side of the plot the axis is drawn on.
+    public final ObjectProperty<Side> sideProperty() {
+        return side;
+    }
+
+    /// The side the axis is drawn on when it runs in the given direction.
+    final Side side(boolean horizontal) {
+        Side s = side.get();
+        if (horizontal) {
+            return s == Side.TOP ? Side.TOP : Side.BOTTOM;
+        }
+        return s == Side.RIGHT ? Side.RIGHT : Side.LEFT;
+    }
+
+    /// Returns whether the axis takes its range from the data.
+    public final boolean isAutoRanging() {
+        return autoRanging.get();
+    }
+
+    /// Sets whether the axis takes its range from the data.
+    public final void setAutoRanging(boolean value) {
+        autoRanging.set(value);
+    }
+
+    /// Whether the axis takes its range from the data.
+    public final BooleanProperty autoRangingProperty() {
+        return autoRanging;
+    }
+
+    /// Returns whether the labels of the ticks are drawn.
+    public final boolean isTickLabelsVisible() {
+        return tickLabelsVisible.get();
+    }
+
+    /// Sets whether the labels of the ticks are drawn.
+    public final void setTickLabelsVisible(boolean value) {
+        tickLabelsVisible.set(value);
+    }
+
+    /// Whether the labels of the ticks are drawn.
+    public final BooleanProperty tickLabelsVisibleProperty() {
+        return tickLabelsVisible;
+    }
+
+    /// Returns whether the tick marks are drawn.
+    public final boolean isTickMarkVisible() {
+        return tickMarkVisible.get();
+    }
+
+    /// Sets whether the tick marks are drawn.
+    public final void setTickMarkVisible(boolean value) {
+        tickMarkVisible.set(value);
+    }
+
+    /// Whether the tick marks are drawn.
+    public final BooleanProperty tickMarkVisibleProperty() {
+        return tickMarkVisible;
+    }
+
+    /// Returns the rotation of the tick labels, in degrees.
+    public final double getTickLabelRotation() {
+        return tickLabelRotation.get();
+    }
+
+    /// Sets the rotation of the tick labels, in degrees clockwise about
+    /// the middle of each label.
+    public final void setTickLabelRotation(double value) {
+        tickLabelRotation.set(value);
+    }
+
+    /// The rotation of the tick labels, in degrees.
+    public final DoubleProperty tickLabelRotationProperty() {
+        return tickLabelRotation;
+    }
+
+    /// Returns the font of the tick labels.
+    public final Font getTickLabelFont() {
+        return tickLabelFont.get();
+    }
+
+    /// Sets the font of the tick labels.
+    public final void setTickLabelFont(Font value) {
+        tickLabelFont.set(value);
+    }
+
+    /// The font of the tick labels.
+    public final ObjectProperty<Font> tickLabelFontProperty() {
+        return tickLabelFont;
+    }
+
+    /// Returns the paint of the tick labels.
+    public final Paint getTickLabelFill() {
+        return tickLabelFill.get();
+    }
+
+    /// Sets the paint of the tick labels.
+    public final void setTickLabelFill(Paint value) {
+        tickLabelFill.set(value);
+    }
+
+    /// The paint of the tick labels.
+    public final ObjectProperty<Paint> tickLabelFillProperty() {
+        return tickLabelFill;
+    }
+
+    /// Returns the length of a tick mark.
+    public final double getTickLength() {
+        return tickLength.get();
+    }
+
+    /// Sets the length of a tick mark.
+    public final void setTickLength(double value) {
+        tickLength.set(value);
+    }
+
+    /// The length of a tick mark.
+    public final DoubleProperty tickLengthProperty() {
+        return tickLength;
+    }
+
+    /// Returns the gap between a tick mark and its label.
+    public final double getTickLabelGap() {
+        return tickLabelGap.get();
+    }
+
+    /// Sets the gap between a tick mark and its label.
+    public final void setTickLabelGap(double value) {
+        tickLabelGap.set(value);
+    }
+
+    /// The gap between a tick mark and its label.
+    public final DoubleProperty tickLabelGapProperty() {
+        return tickLabelGap;
+    }
+
+    /// Returns whether changes were asked to be animated.
+    public final boolean getAnimated() {
+        return animated;
+    }
+
+    /// Records whether changes are to be animated; they are drawn at once.
+    public final void setAnimated(boolean value) {
+        animated = value;
+    }
+
+    /// The words of a value on this axis, as a tick shows it.
+    abstract String text(Object value);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/BarChart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/BarChart.java
new file mode 100644
index 00000000000..bad77556389
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/BarChart.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.collections.ObservableList;
+
+/// A chart of bars, one for each data item, grouped by category.
+///
+/// One axis is a [CategoryAxis] and the other a [ValueAxis]: the bars
+/// stand upright when the categories are on the X axis and lie on their
+/// side when they are on the Y axis. A bar grows from zero, so the value
+/// axis always holds zero when it takes its range from the data. The
+/// bars of a category are as wide as its band of the axis allows after
+/// `categoryGap` between two categories and `barGap` after each bar. See
+/// [Chart] for what the charts of this layer leave out.
+public class BarChart<X, Y> extends XYChart<X, Y> {
+
+    private final DoubleProperty barGap = new FxDouble(this, "barGap", 4, Dirty.PAINT);
+    private final DoubleProperty categoryGap = new FxDouble(this, "categoryGap", 10, Dirty.PAINT);
+
+    /// Creates a bar chart.
+    ///
+    /// @throws IllegalArgumentException unless one axis is a value axis
+    ///     and the other a category axis
+    public BarChart(Axis<X> xAxis, Axis<Y> yAxis) {
+        super(xAxis, yAxis);
+        boolean upright = xAxis instanceof CategoryAxis && yAxis instanceof ValueAxis;
+        boolean sideways = yAxis instanceof CategoryAxis && xAxis instanceof ValueAxis;
+        if (!upright && !sideways) {
+            throw new IllegalArgumentException("Axis type incorrect, one of X,Y should be CategoryAxis and the "
+                    + "other NumberAxis");
+        }
+    }
+
+    /// Creates a bar chart of the given series.
+    public BarChart(Axis<X> xAxis, Axis<Y> yAxis, ObservableList<Series<X, Y>> data) {
+        this(xAxis, yAxis);
+        setData(data);
+    }
+
+    /// Creates a bar chart of the given series with a gap between the
+    /// categories.
+    public BarChart(Axis<X> xAxis, Axis<Y> yAxis, ObservableList<Series<X, Y>> data, double categoryGap) {
+        this(xAxis, yAxis);
+        setData(data);
+        setCategoryGap(categoryGap);
+    }
+
+    /// Returns the gap between two bars of one category.
+    public final double getBarGap() {
+        return barGap.get();
+    }
+
+    /// Sets the gap between two bars of one category.
+    public final void setBarGap(double value) {
+        barGap.set(value);
+    }
+
+    /// The gap between two bars of one category.
+    public final DoubleProperty barGapProperty() {
+        return barGap;
+    }
+
+    /// Returns the gap between the bars of two categories.
+    public final double getCategoryGap() {
+        return categoryGap.get();
+    }
+
+    /// Sets the gap between the bars of two categories.
+    public final void setCategoryGap(double value) {
+        categoryGap.set(value);
+    }
+
+    /// The gap between the bars of two categories.
+    public final DoubleProperty categoryGapProperty() {
+        return categoryGap;
+    }
+
+    @Override
+    boolean zeroBased() {
+        return true;
+    }
+
+    @Override
+    double[] legendSymbolSize(int index) {
+        return new double[] {16, 16};
+    }
+
+    @Override
+    void legendSymbol(Renderer renderer, int index, double x, double y) {
+        renderer.fillRect(x, y, 16, 16, color(index));
+    }
+
+    @Override
+    void drawSeries(Renderer renderer, List<Series<X, Y>> series, Scale sx, Scale sy, double x, double y, double w,
+            double h) {
+        boolean upright = sx.category;
+        Scale names = upright ? sx : sy;
+        Scale values = upright ? sy : sx;
+        int count = names.names.size();
+        int groups = series.size();
+        if (count == 0 || groups == 0 || values.category) {
+            return;
+        }
+        // The bars of a category share its band of the axis, less the
+        // gap between two categories, each followed by the gap between
+        // two bars.
+        double gap = getBarGap();
+        double bar = (names.spacing - (getCategoryGap() + gap)) / groups - gap;
+        if (!(bar > 0)) {
+            bar = 1;
+        }
+        double start = -((names.spacing - getCategoryGap()) / 2);
+        double zero = values.base();
+        if (zero != zero) {
+            return;
+        }
+        for (int s = 0; s < groups; s++) {
+            ObservableList<Data<X, Y>> items = series.get(s).getData();
+            for (int i = 0; i < items.size(); i++) {
+                Data<X, Y> item = items.get(i);
+                if (item == null) {
+                    continue;
+                }
+                double at = names.at(upright ? (Object) item.getXValue() : (Object) item.getYValue());
+                double value = values.at(upright ? (Object) item.getYValue() : (Object) item.getXValue());
+                if (at != at || value != value) {
+                    continue;
+                }
+                double offset = start + s * (bar + gap);
+                double from = Math.min(zero, value);
+                double length = Math.abs(value - zero);
+                if (upright) {
+                    renderer.fillRect(x + at + offset, y + from, bar, length, color(s));
+                } else {
+                    renderer.fillRect(x + from, y + at + offset, length, bar, color(s));
+                }
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/CategoryAxis.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/CategoryAxis.java
new file mode 100644
index 00000000000..260c8b6b7b6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/CategoryAxis.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// An axis of names, each with a band of the axis to itself.
+///
+/// The categories are the list given to the axis. While that list is
+/// empty the chart draws the names of its data, in the order it meets
+/// them, and leaves the list as it is; JavaFX fills the list in.
+///
+/// Labels that do not fit side by side along a horizontal axis are
+/// stood on end, as JavaFX does.
+public final class CategoryAxis extends Axis<String> {
+
+    private final ObservableList<String> categories;
+    private final DoubleProperty startMargin = new FxDouble(this, "startMargin", 5, Dirty.PAINT);
+    private final DoubleProperty endMargin = new FxDouble(this, "endMargin", 5, Dirty.PAINT);
+    private final BooleanProperty gapStartAndEnd = new FxBoolean(this, "gapStartAndEnd", true, Dirty.PAINT);
+
+    /// Creates an axis whose categories come from the data.
+    public CategoryAxis() {
+        this(FXCollections.<String>observableArrayList());
+    }
+
+    /// Creates an axis of the given categories.
+    public CategoryAxis(ObservableList<String> categories) {
+        this.categories = categories == null ? FXCollections.<String>observableArrayList() : categories;
+        this.categories.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                cn1Invalidated(Dirty.PAINT);
+            }
+        });
+    }
+
+    /// Returns the categories, in the order they are drawn.
+    public final ObservableList<String> getCategories() {
+        return categories;
+    }
+
+    /// Replaces the categories.
+    public final void setCategories(ObservableList<String> value) {
+        categories.clear();
+        if (value != null) {
+            categories.addAll(value);
+        }
+    }
+
+    /// Returns the margin asked for before the first category.
+    public final double getStartMargin() {
+        return startMargin.get();
+    }
+
+    /// Sets the margin left free before the first category.
+    public final void setStartMargin(double value) {
+        startMargin.set(value);
+    }
+
+    /// The margin asked for before the first category.
+    public final DoubleProperty startMarginProperty() {
+        return startMargin;
+    }
+
+    /// Returns the margin asked for after the last category.
+    public final double getEndMargin() {
+        return endMargin.get();
+    }
+
+    /// Sets the margin left free after the last category.
+    public final void setEndMargin(double value) {
+        endMargin.set(value);
+    }
+
+    /// The margin asked for after the last category.
+    public final DoubleProperty endMarginProperty() {
+        return endMargin;
+    }
+
+    /// Returns whether half a band is left free at each end.
+    public final boolean isGapStartAndEnd() {
+        return gapStartAndEnd.get();
+    }
+
+    /// Sets whether half a band is left free at each end. Without it
+    /// the first and the last category are at the margins of the axis.
+    public final void setGapStartAndEnd(boolean value) {
+        gapStartAndEnd.set(value);
+    }
+
+    /// Whether half a band is left free at each end.
+    public final BooleanProperty gapStartAndEndProperty() {
+        return gapStartAndEnd;
+    }
+
+    @Override
+    String text(Object value) {
+        return value == null ? "" : String.valueOf(value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/Chart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/Chart.java
new file mode 100644
index 00000000000..0cae2539643
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/Chart.java
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.FxString;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.geometry.Insets;
+import javafx.geometry.Side;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+
+/// The base of the charts: a title, a legend and a plot between them.
+///
+/// A chart here is one region that draws all of itself - the title, the
+/// axes, the plot and the legend. JavaFX builds a chart out of nodes, one
+/// for each bar, symbol, slice and legend entry, and lets a style sheet
+/// and the application reach them; this layer has no such nodes, so:
+///
+/// - the node of a data item or a series is `null` unless the
+///   application set one, and is not shown;
+/// - the chart classes of a style sheet (`.chart-bar`, `.default-color0`
+///   and the like) select nothing, and the series take the eight default
+///   colours of JavaFX in turn;
+/// - a change of the data is drawn at once; `animated` is recorded only.
+///
+/// The title is on its `titleSide` and the legend on its `legendSide`,
+/// in a box of its own: its entries side by side above or below the
+/// plot, wrapping onto more rows when they do not fit, and one under the
+/// other beside it. Each entry has the symbol its series is drawn with.
+/// The colours and sizes are those of the default style sheet of JavaFX.
+///
+/// The preferred size is the 500 by 400 of JavaFX.
+public abstract class Chart extends Region {
+
+    static final Color[] PALETTE = {
+        Color.web("#f3622d"), Color.web("#fba71b"), Color.web("#57b757"), Color.web("#41a9c9"),
+        Color.web("#4258c9"), Color.web("#9a42c8"), Color.web("#c84164"), Color.web("#888888"),
+    };
+    static final Color TEXT = Color.web("#333333");
+    /// The lines and tick marks of the axes, and the line to the name of
+    /// a slice.
+    static final Color AXIS = Color.web("#c3c3c3");
+    static final Color GRID = Color.web("#dbdbdb");
+    static final Color ZERO = Color.web("#858585");
+    /// The background of the plot, and of what is around a chart in a
+    /// scene that sets no colour of its own.
+    static final Color PLOT = Color.web("#f4f4f4");
+    private static final Color LEGEND_EDGE = Color.web("#dedede");
+    private static final Color LEGEND_FILL = Color.web("#f5f5f5");
+    /// The room inside the box of the legend, and between two entries.
+    private static final double LEGEND_PADDING = 6;
+    private static final double LEGEND_GAP = 5;
+    private static final double SYMBOL_GAP = 4;
+    /// The room around the plot and its axes.
+    private static final double CONTENT_PADDING = 10;
+
+    private final StringProperty title = new FxString(this, "title", null, Dirty.PAINT);
+    private final ObjectProperty<Side> titleSide = new FxObject<Side>(this, "titleSide", Side.TOP, Dirty.PAINT);
+    private final BooleanProperty legendVisible = new FxBoolean(this, "legendVisible", true, Dirty.PAINT);
+    private final ObjectProperty<Side> legendSide = new FxObject<Side>(this, "legendSide", Side.BOTTOM,
+            Dirty.PAINT);
+    private final BooleanProperty animated = new FxBoolean(this, "animated", true, Dirty.NONE);
+
+    /// Creates a chart.
+    public Chart() {
+        setPadding(new Insets(5));
+    }
+
+    /// Returns the title, `null` for none.
+    public final String getTitle() {
+        return title.get();
+    }
+
+    /// Sets the title of the chart.
+    public final void setTitle(String value) {
+        title.set(value);
+    }
+
+    /// The title of the chart.
+    public final StringProperty titleProperty() {
+        return title;
+    }
+
+    /// Returns the side of the chart the title is on.
+    public final Side getTitleSide() {
+        return titleSide.get();
+    }
+
+    /// Sets the side of the chart the title is on.
+    public final void setTitleSide(Side value) {
+        titleSide.set(value);
+    }
+
+    /// The side of the chart the title is on.
+    public final ObjectProperty<Side> titleSideProperty() {
+        return titleSide;
+    }
+
+    /// Returns whether the legend is drawn.
+    public final boolean isLegendVisible() {
+        return legendVisible.get();
+    }
+
+    /// Sets whether the legend is drawn.
+    public final void setLegendVisible(boolean value) {
+        legendVisible.set(value);
+    }
+
+    /// Whether the legend is drawn.
+    public final BooleanProperty legendVisibleProperty() {
+        return legendVisible;
+    }
+
+    /// Returns the side of the chart the legend is on.
+    public final Side getLegendSide() {
+        return legendSide.get();
+    }
+
+    /// Sets the side of the chart the legend is on.
+    public final void setLegendSide(Side value) {
+        legendSide.set(value);
+    }
+
+    /// The side of the chart the legend is on.
+    public final ObjectProperty<Side> legendSideProperty() {
+        return legendSide;
+    }
+
+    /// Returns whether changes were asked to be animated.
+    public final boolean getAnimated() {
+        return animated.get();
+    }
+
+    /// Records whether changes are to be animated; they are drawn at once.
+    public final void setAnimated(boolean value) {
+        animated.set(value);
+    }
+
+    /// Whether changes were asked to be animated.
+    public final BooleanProperty animatedProperty() {
+        return animated;
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        return 500;
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        return 400;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return 0;
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return 0;
+    }
+
+    static Color color(int index) {
+        return PALETTE[(index < 0 ? 0 : index) % PALETTE.length];
+    }
+
+    static Font font(double size) {
+        return Font.font(size);
+    }
+
+    /// The names of the legend, in the order of their colours.
+    abstract String[] legend();
+
+    /// The width and height of the symbol of a legend entry.
+    abstract double[] legendSymbolSize(int index);
+
+    /// Draws the symbol of a legend entry with its top left corner at a
+    /// point.
+    abstract void legendSymbol(Renderer renderer, int index, double x, double y);
+
+    /// Draws the plot into a rectangle of this chart.
+    abstract void plot(Renderer renderer, double x, double y, double w, double h);
+
+    private static int fit(double room, double tile, int count) {
+        int n = (int) Math.floor((room - 2 * LEGEND_PADDING + LEGEND_GAP) / (tile + LEGEND_GAP));
+        return n < 1 ? 1 : (n > count ? count : n);
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        super.cn1Paint(renderer);
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double w = getWidth() - in.getLeft() - in.getRight();
+        double h = getHeight() - in.getTop() - in.getBottom();
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        String t = getTitle();
+        if (t != null && t.length() > 0) {
+            Font f = font(16.8);
+            double tw = Fonts.width(f, t);
+            double th = Fonts.lineHeight(f);
+            Side side = getTitleSide();
+            if (side == Side.BOTTOM) {
+                renderer.drawText(t, x + (w - tw) / 2, y + h - th, f, TEXT);
+                h -= th;
+            } else if (side == Side.LEFT) {
+                renderer.drawText(t, x, y + (h - th) / 2, f, TEXT);
+                x += tw;
+                w -= tw;
+            } else if (side == Side.RIGHT) {
+                renderer.drawText(t, x + w - tw, y + (h - th) / 2, f, TEXT);
+                w -= tw;
+            } else {
+                renderer.drawText(t, x + (w - tw) / 2, y, f, TEXT);
+                y += th;
+                h -= th;
+            }
+        }
+        String[] names = isLegendVisible() ? legend() : new String[0];
+        if (names.length > 0 && w > 0 && h > 0) {
+            Font f = font(12);
+            double line = Fonts.lineHeight(f);
+            // Every entry has a tile of the size of the largest.
+            double tileW = 0;
+            double tileH = line;
+            for (int i = 0; i < names.length; i++) {
+                double[] size = legendSymbolSize(i);
+                tileW = Math.max(tileW, size[0] + SYMBOL_GAP + Fonts.width(f, names[i]));
+                tileH = Math.max(tileH, size[1]);
+            }
+            Side side = getLegendSide();
+            boolean beside = side == Side.LEFT || side == Side.RIGHT;
+            int count = names.length;
+            int columns;
+            int rows;
+            if (beside) {
+                rows = fit(h, tileH, count);
+                columns = (count + rows - 1) / rows;
+            } else {
+                columns = fit(w, tileW, count);
+                rows = (count + columns - 1) / columns;
+                columns = (count + rows - 1) / rows;
+            }
+            double lw = Math.min(w, 2 * LEGEND_PADDING + columns * tileW + (columns - 1) * LEGEND_GAP);
+            double lh = Math.min(h, 2 * LEGEND_PADDING + rows * tileH + (rows - 1) * LEGEND_GAP);
+            double lx;
+            double ly;
+            if (side == Side.TOP) {
+                lx = x + (w - lw) / 2;
+                ly = y;
+                y += lh;
+                h -= lh;
+            } else if (side == Side.LEFT) {
+                lx = x;
+                ly = y + (h - lh) / 2;
+                x += lw;
+                w -= lw;
+            } else if (side == Side.RIGHT) {
+                lx = x + w - lw;
+                ly = y + (h - lh) / 2;
+                w -= lw;
+            } else {
+                lx = x + (w - lw) / 2;
+                ly = y + h - lh;
+                h -= lh;
+            }
+            lx = Math.round(lx);
+            ly = Math.round(ly);
+            FxPath box = new FxPath();
+            box.addRoundRect(lx, ly, lw, lh, 4, 4);
+            renderer.fill(box, LEGEND_EDGE, lx, ly, lw, lh);
+            FxPath inside = new FxPath();
+            inside.addRoundRect(lx + 1, ly + 1, lw - 2, lh - 2, 3, 3);
+            renderer.fill(inside, LEGEND_FILL, lx + 1, ly + 1, lw - 2, lh - 2);
+            for (int i = 0; i < count; i++) {
+                // Row by row above or below the plot, column by column
+                // beside it.
+                int column = beside ? i / rows : i % columns;
+                int row = beside ? i % rows : i / columns;
+                double tx = lx + LEGEND_PADDING + column * (tileW + LEGEND_GAP);
+                double ty = ly + LEGEND_PADDING + row * (tileH + LEGEND_GAP);
+                double[] size = legendSymbolSize(i);
+                legendSymbol(renderer, i, tx, ty + (tileH - size[1]) / 2);
+                renderer.drawText(names[i], tx + size[0] + SYMBOL_GAP, ty + (tileH - line) / 2, f, TEXT);
+            }
+        }
+        x += CONTENT_PADDING;
+        y += CONTENT_PADDING;
+        w -= 2 * CONTENT_PADDING;
+        h -= 2 * CONTENT_PADDING;
+        if (w > 0 && h > 0) {
+            plot(renderer, x, y, w, h);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/LineChart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/LineChart.java
new file mode 100644
index 00000000000..43dc819b7c1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/LineChart.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.ObservableList;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+
+/// A chart that joins the points of each series with a line.
+///
+/// The points are joined in the order of their X values by default, and
+/// in the order of the data when the sorting policy is
+/// [SortingPolicy#NONE]; a policy of [SortingPolicy#Y_AXIS] orders them
+/// by their Y values. The line is three pixels wide, and a ring of the
+/// colour of the series with a white middle is drawn at each point
+/// unless `createSymbols` is off. See [Chart] for what the charts of
+/// this layer leave out.
+public class LineChart<X, Y> extends XYChart<X, Y> {
+
+    /// The order the points of a series are joined in.
+    public enum SortingPolicy {
+        /// The order of the data.
+        NONE,
+        /// The order of the X values.
+        X_AXIS,
+        /// The order of the Y values.
+        Y_AXIS
+    }
+
+    private final BooleanProperty createSymbols = new FxBoolean(this, "createSymbols", true, Dirty.PAINT);
+    private final ObjectProperty<SortingPolicy> axisSortingPolicy = new FxObject<SortingPolicy>(this,
+            "axisSortingPolicy", SortingPolicy.X_AXIS, Dirty.PAINT);
+
+    /// Creates a line chart.
+    public LineChart(Axis<X> xAxis, Axis<Y> yAxis) {
+        super(xAxis, yAxis);
+    }
+
+    /// Creates a line chart of the given series.
+    public LineChart(Axis<X> xAxis, Axis<Y> yAxis, ObservableList<Series<X, Y>> data) {
+        super(xAxis, yAxis);
+        setData(data);
+    }
+
+    /// Returns whether a symbol is drawn at each point.
+    public final boolean getCreateSymbols() {
+        return createSymbols.get();
+    }
+
+    /// Sets whether a symbol is drawn at each point.
+    public final void setCreateSymbols(boolean value) {
+        createSymbols.set(value);
+    }
+
+    /// Whether a symbol is drawn at each point.
+    public final BooleanProperty createSymbolsProperty() {
+        return createSymbols;
+    }
+
+    /// Returns the order the points of a series are joined in.
+    public final SortingPolicy getAxisSortingPolicy() {
+        return axisSortingPolicy.get();
+    }
+
+    /// Sets the order the points of a series are joined in.
+    public final void setAxisSortingPolicy(SortingPolicy value) {
+        axisSortingPolicy.set(value);
+    }
+
+    /// The order the points of a series are joined in.
+    public final ObjectProperty<SortingPolicy> axisSortingPolicyProperty() {
+        return axisSortingPolicy;
+    }
+
+    /// The places of the points of a series that the axes have a place
+    /// for, ordered along one axis: 0 for X, 1 for Y, anything else for
+    /// the order of the data.
+    static <X, Y> List<double[]> places(Series<X, Y> series, Scale sx, Scale sy, double x, double y,
+            int orderBy) {
+        List<double[]> out = new ArrayList<double[]>();
+        ObservableList<Data<X, Y>> items = series.getData();
+        for (int i = 0; i < items.size(); i++) {
+            Data<X, Y> item = items.get(i);
+            if (item == null) {
+                continue;
+            }
+            double[] p = place(item, sx, sy, x, y);
+            if (p.length < 2) {
+                continue;
+            }
+            int at = out.size();
+            if (orderBy == 0) {
+                while (at > 0 && out.get(at - 1)[0] > p[0]) {
+                    at--;
+                }
+            } else if (orderBy == 1) {
+                // A greater Y value is higher up, so its pixel is smaller.
+                while (at > 0 && out.get(at - 1)[1] < p[1]) {
+                    at--;
+                }
+            }
+            out.add(at, p);
+        }
+        return out;
+    }
+
+    static void polyline(Renderer renderer, List<double[]> points, Color color, double width) {
+        if (points.size() < 2) {
+            return;
+        }
+        FxPath path = new FxPath();
+        path.moveTo(points.get(0)[0], points.get(0)[1]);
+        for (int i = 1; i < points.size(); i++) {
+            path.lineTo(points.get(i)[0], points.get(i)[1]);
+        }
+        renderer.stroke(path, color, width, StrokeLineCap.BUTT, StrokeLineJoin.MITER, 10, null, 0);
+    }
+
+    @Override
+    double[] legendSymbolSize(int index) {
+        return new double[] {10, 10};
+    }
+
+    @Override
+    void legendSymbol(Renderer renderer, int index, double x, double y) {
+        ring(renderer, x + 5, y + 5, 5, 3, color(index));
+    }
+
+    @Override
+    void drawSeries(Renderer renderer, List<Series<X, Y>> series, Scale sx, Scale sy, double x, double y, double w,
+            double h) {
+        SortingPolicy policy = getAxisSortingPolicy();
+        int orderBy = policy == SortingPolicy.X_AXIS ? 0 : policy == SortingPolicy.Y_AXIS ? 1 : 2;
+        for (int s = 0; s < series.size(); s++) {
+            List<double[]> points = places(series.get(s), sx, sy, x, y, orderBy);
+            polyline(renderer, points, color(s), 3);
+            if (getCreateSymbols()) {
+                for (int i = 0; i < points.size(); i++) {
+                    ring(renderer, points.get(i)[0], points.get(i)[1], 5, 3, color(s));
+                }
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/ListWatch.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/ListWatch.java
new file mode 100644
index 00000000000..8cdf53668eb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/ListWatch.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// Follows one observable list at a time on behalf of a chart: every
+/// element that enters or leaves it is announced, and so is every change.
+abstract class ListWatch<E> implements ListChangeListener<E> {
+
+    private ObservableList<E> list;
+
+    /// Stops following the list followed so far and follows another.
+    final void watch(ObservableList<E> next) {
+        if (list == next) {
+            return;
+        }
+        if (list != null) {
+            list.removeListener(this);
+            List<E> old = new ArrayList<E>(list);
+            for (int i = 0; i < old.size(); i++) {
+                removed(old.get(i));
+            }
+        }
+        list = next;
+        if (next != null) {
+            List<E> now = new ArrayList<E>(next);
+            for (int i = 0; i < now.size(); i++) {
+                added(now.get(i));
+            }
+            next.addListener(this);
+        }
+        changed();
+    }
+
+    @Override
+    public final void onChanged(Change<? extends E> change) {
+        while (change.next()) {
+            if (change.wasRemoved()) {
+                List<? extends E> gone = change.getRemoved();
+                for (int i = 0; i < gone.size(); i++) {
+                    removed(gone.get(i));
+                }
+            }
+            if (change.wasAdded()) {
+                List<? extends E> came = change.getAddedSubList();
+                for (int i = 0; i < came.size(); i++) {
+                    added(came.get(i));
+                }
+            }
+        }
+        changed();
+    }
+
+    /// An element entered the list.
+    abstract void added(E element);
+
+    /// An element left the list.
+    abstract void removed(E element);
+
+    /// The list changed in some way.
+    abstract void changed();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/NumberAxis.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/NumberAxis.java
new file mode 100644
index 00000000000..9283380f686
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/NumberAxis.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.util.StringConverter;
+
+/// An axis of plain numbers, with a tick every `tickUnit`.
+///
+/// Auto ranging does what JavaFX does: the range of the data is padded
+/// by a hundredth of itself at each end, never across zero, and rounded
+/// outwards to a tick unit of 1, 2.5 or 5 times a power of ten - the
+/// smallest that gives a tick about every two label heights, no more
+/// than twenty ticks, and labels that do not touch. The unit it chose is
+/// written into `tickUnit`, and decides the decimals of the labels.
+///
+/// A label of an axis with a fixed range has its thousands grouped and
+/// up to three decimals, as `3,000` and `0.25`.
+public final class NumberAxis extends ValueAxis<Number> {
+
+    private final BooleanProperty forceZeroInRange = new FxBoolean(this, "forceZeroInRange", true, Dirty.PAINT);
+    private final DoubleProperty tickUnit = new FxDouble(this, "tickUnit", 5, Dirty.PAINT);
+    private int decimals = -1;
+    private boolean grouping = true;
+
+    /// Creates an auto ranging axis.
+    public NumberAxis() {
+    }
+
+    /// Creates an axis with a fixed range and tick unit.
+    public NumberAxis(double lowerBound, double upperBound, double tickUnit) {
+        super(lowerBound, upperBound);
+        this.tickUnit.set(tickUnit);
+    }
+
+    /// Creates a labelled axis with a fixed range and tick unit.
+    public NumberAxis(String axisLabel, double lowerBound, double upperBound, double tickUnit) {
+        super(lowerBound, upperBound);
+        this.tickUnit.set(tickUnit);
+        setLabel(axisLabel);
+    }
+
+    /// Returns whether zero is kept in a range taken from the data.
+    public final boolean isForceZeroInRange() {
+        return forceZeroInRange.get();
+    }
+
+    /// Sets whether zero is kept in a range taken from the data.
+    public final void setForceZeroInRange(boolean value) {
+        forceZeroInRange.set(value);
+    }
+
+    /// Whether zero is kept in a range taken from the data.
+    public final BooleanProperty forceZeroInRangeProperty() {
+        return forceZeroInRange;
+    }
+
+    /// Returns the distance between two ticks.
+    public final double getTickUnit() {
+        return tickUnit.get();
+    }
+
+    /// Sets the distance between two ticks of a fixed range.
+    public final void setTickUnit(double value) {
+        tickUnit.set(value);
+    }
+
+    /// The distance between two ticks.
+    public final DoubleProperty tickUnitProperty() {
+        return tickUnit;
+    }
+
+    @Override
+    double unit() {
+        return getTickUnit();
+    }
+
+    @Override
+    void unit(double value) {
+        tickUnit.set(value);
+    }
+
+    @Override
+    void format(int decimals, boolean grouping) {
+        this.decimals = decimals;
+        this.grouping = grouping;
+    }
+
+    @Override
+    boolean zeroInRange() {
+        return isForceZeroInRange();
+    }
+
+    /// Writes a number with a fixed count of decimals, or with up to
+    /// three and no trailing zeros when the count is negative.
+    static String plain(double value, int decimals, boolean grouping) {
+        if (value != value || Double.isInfinite(value)) {
+            return String.valueOf(value);
+        }
+        int places = decimals < 0 ? 3 : Math.min(decimals, 9);
+        long scale = 1;
+        for (int i = 0; i < places; i++) {
+            scale *= 10;
+        }
+        double magnitude = Math.abs(value) * scale;
+        if (magnitude > 9.0e17) {
+            return String.valueOf(value);
+        }
+        long scaled = Math.round(magnitude);
+        String whole = String.valueOf(scaled / scale);
+        StringBuilder out = new StringBuilder();
+        if (value < 0 && scaled != 0) {
+            out.append('-');
+        }
+        for (int i = 0; i < whole.length(); i++) {
+            if (grouping && i > 0 && (whole.length() - i) % 3 == 0) {
+                out.append(',');
+            }
+            out.append(whole.charAt(i));
+        }
+        if (places > 0) {
+            StringBuilder fraction = new StringBuilder(String.valueOf(scaled % scale));
+            while (fraction.length() < places) {
+                fraction.insert(0, '0');
+            }
+            int keep = fraction.length();
+            if (decimals < 0) {
+                while (keep > 0 && fraction.charAt(keep - 1) == '0') {
+                    keep--;
+                }
+            }
+            if (keep > 0) {
+                out.append('.');
+                for (int i = 0; i < keep; i++) {
+                    out.append(fraction.charAt(i));
+                }
+            }
+        }
+        return out.toString();
+    }
+
+    @Override
+    String text(Object value) {
+        if (!(value instanceof Number)) {
+            return String.valueOf(value);
+        }
+        Number n = (Number) value;
+        StringConverter<Number> format = getTickLabelFormatter();
+        if (format != null) {
+            return format.toString(n);
+        }
+        return plain(n.doubleValue(), decimals, grouping);
+    }
+
+    /// A formatter of tick labels that writes a number the way the axis
+    /// does, between a prefix and a suffix.
+    public static class DefaultFormatter extends StringConverter<Number> {
+
+        private final String prefix;
+        private final String suffix;
+
+        /// Creates a formatter for an axis.
+        public DefaultFormatter(NumberAxis axis) {
+            this(axis, null, null);
+        }
+
+        /// Creates a formatter that puts a text before and after a number.
+        public DefaultFormatter(NumberAxis axis, String prefix, String suffix) {
+            this.prefix = prefix;
+            this.suffix = suffix;
+        }
+
+        @Override
+        public String toString(Number object) {
+            if (object == null) {
+                return "";
+            }
+            double v = object.doubleValue();
+            String number = v == Math.rint(v) && Math.abs(v) < 1e15 ? String.valueOf((long) v) : String.valueOf(v);
+            return (prefix == null ? "" : prefix) + number + (suffix == null ? "" : suffix);
+        }
+
+        @Override
+        public Number fromString(String string) {
+            if (string == null) {
+                return null;
+            }
+            int from = prefix == null || !string.startsWith(prefix) ? 0 : prefix.length();
+            int to = suffix == null || suffix.length() == 0 || !string.endsWith(suffix) ? string.length()
+                    : string.length() - suffix.length();
+            if (to <= from) {
+                return null;
+            }
+            try {
+                return Double.valueOf(string.substring(from, to).trim());
+            } catch (NumberFormatException notANumber) {
+                return null;
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/PieChart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/PieChart.java
new file mode 100644
index 00000000000..1bc587b9076
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/PieChart.java
@@ -0,0 +1,520 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+import javafx.scene.layout.Region;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.text.Font;
+
+/// A circle cut into a slice for each data item, in proportion to its
+/// value.
+///
+/// The slices start at `startAngle`, measured counter clockwise from
+/// three o'clock, and follow each other clockwise unless `clockwise` is
+/// off. A data item whose value is not above zero has no slice. Each
+/// slice has its name beside it, at the end of a line of
+/// `labelLineLength`, unless `labelsVisible` is off; of two names that
+/// would run over each other the one of the smaller slice is left out,
+/// and all of them are where they would leave no room for the pie. The
+/// pie is as large as its names allow. A slice is filled with its colour
+/// alone, where JavaFX shades it. See [Chart] for what the charts of
+/// this layer leave out.
+///
+/// The node of a data item is a child of the chart that draws nothing:
+/// it is what the pointer finds over the slice, so a handler set on it
+/// hears of a click on the slice, and an event it does not consume goes
+/// on to the chart.
+public class PieChart extends Chart {
+
+    private final ObjectProperty<ObservableList<Data>> data = new SimpleObjectProperty<ObservableList<Data>>(this,
+            "data");
+    private final DoubleProperty startAngle = new FxDouble(this, "startAngle", 0, Dirty.PAINT);
+    private final BooleanProperty clockwise = new FxBoolean(this, "clockwise", true, Dirty.PAINT);
+    private final DoubleProperty labelLineLength = new FxDouble(this, "labelLineLength", 20, Dirty.PAINT);
+    private final BooleanProperty labelsVisible = new FxBoolean(this, "labelsVisible", true, Dirty.PAINT);
+
+    /// The room between the end of the line of a slice and its name.
+    private static final double LABEL_GAP = 6;
+    /// The smallest pie that keeps its names.
+    private static final double MIN_RADIUS = 25;
+
+    private final ListWatch<Data> watch = new ListWatch<Data>() {
+        @Override
+        void added(Data item) {
+            if (item != null) {
+                item.chart.set(PieChart.this);
+                item.node.drawn = false;
+                if (!getChildren().contains(item.node)) {
+                    getChildren().add(item.node);
+                }
+            }
+        }
+
+        @Override
+        void removed(Data item) {
+            if (item != null && item.chart.get() == PieChart.this) {
+                item.chart.set(null);
+                item.node.drawn = false;
+                getChildren().remove(item.node);
+            }
+        }
+
+        @Override
+        void changed() {
+            cn1Repaint();
+        }
+    };
+
+    /// Creates an empty pie chart.
+    public PieChart() {
+        this(FXCollections.<Data>observableArrayList());
+    }
+
+    /// Creates a pie chart of the given data.
+    public PieChart(ObservableList<Data> data) {
+        this.data.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                watch.watch(PieChart.this.data.get());
+            }
+        });
+        this.data.set(data);
+    }
+
+    /// Returns the data of the chart.
+    public final ObservableList<Data> getData() {
+        return data.get();
+    }
+
+    /// Sets the list the chart takes its data from.
+    public final void setData(ObservableList<Data> value) {
+        data.set(value);
+    }
+
+    /// The list the chart takes its data from.
+    public final ObjectProperty<ObservableList<Data>> dataProperty() {
+        return data;
+    }
+
+    /// Returns the angle the first slice starts at, in degrees.
+    public final double getStartAngle() {
+        return startAngle.get();
+    }
+
+    /// Sets the angle the first slice starts at, in degrees.
+    public final void setStartAngle(double value) {
+        startAngle.set(value);
+    }
+
+    /// The angle the first slice starts at, in degrees.
+    public final DoubleProperty startAngleProperty() {
+        return startAngle;
+    }
+
+    /// Returns whether the slices follow each other clockwise.
+    public final boolean isClockwise() {
+        return clockwise.get();
+    }
+
+    /// Sets whether the slices follow each other clockwise.
+    public final void setClockwise(boolean value) {
+        clockwise.set(value);
+    }
+
+    /// Whether the slices follow each other clockwise.
+    public final BooleanProperty clockwiseProperty() {
+        return clockwise;
+    }
+
+    /// Returns the length of the line from a slice to its name.
+    public final double getLabelLineLength() {
+        return labelLineLength.get();
+    }
+
+    /// Sets the length of the line from a slice to its name.
+    public final void setLabelLineLength(double value) {
+        labelLineLength.set(value);
+    }
+
+    /// The length of the line from a slice to its name.
+    public final DoubleProperty labelLineLengthProperty() {
+        return labelLineLength;
+    }
+
+    /// Returns whether the names are drawn beside the slices.
+    public final boolean getLabelsVisible() {
+        return labelsVisible.get();
+    }
+
+    /// Sets whether the names are drawn beside the slices.
+    public final void setLabelsVisible(boolean value) {
+        labelsVisible.set(value);
+    }
+
+    /// Whether the names are drawn beside the slices.
+    public final BooleanProperty labelsVisibleProperty() {
+        return labelsVisible;
+    }
+
+    private List<Data> items() {
+        List<Data> out = new ArrayList<Data>();
+        ObservableList<Data> all = getData();
+        if (all != null) {
+            for (int i = 0; i < all.size(); i++) {
+                if (all.get(i) != null) {
+                    out.add(all.get(i));
+                }
+            }
+        }
+        return out;
+    }
+
+    @Override
+    String[] legend() {
+        List<Data> all = items();
+        String[] names = new String[all.size()];
+        for (int i = 0; i < names.length; i++) {
+            String name = all.get(i).getName();
+            names[i] = name == null ? "" : name;
+        }
+        return names;
+    }
+
+    @Override
+    double[] legendSymbolSize(int index) {
+        return new double[] {16, 16};
+    }
+
+    @Override
+    void legendSymbol(Renderer renderer, int index, double x, double y) {
+        XYChart.ring(renderer, x + 8, y + 8, 7, 0, color(index));
+    }
+
+    /// An angle brought between -180 and 180 degrees.
+    private static double normal(double degrees) {
+        double a = degrees % 360;
+        if (a <= -180) {
+            a += 360;
+        }
+        if (a > 180) {
+            a -= 360;
+        }
+        return a;
+    }
+
+    @Override
+    void plot(Renderer renderer, double x, double y, double w, double h) {
+        List<Data> all = items();
+        double total = 0;
+        for (int i = 0; i < all.size(); i++) {
+            double v = all.get(i).getPieValue();
+            if (v > 0) {
+                total += v;
+            }
+        }
+        for (int i = 0; i < all.size(); i++) {
+            all.get(i).node.drawn = false;
+        }
+        if (!(total > 0)) {
+            return;
+        }
+        boolean labels = getLabelsVisible();
+        Font f = font(12);
+        double line = Fonts.lineHeight(f);
+        double ascent = Fonts.ascent(f);
+        double reach = Math.max(0, getLabelLineLength());
+        double direction = isClockwise() ? -1 : 1;
+        int count = all.size();
+        // The angle of the middle of each slice, counter clockwise from
+        // three o'clock, and how far its name is from the pie.
+        double[] middle = new double[count];
+        double[] outX = new double[count];
+        double[] outY = new double[count];
+        double padX = 0;
+        double padY = 0;
+        double angle = getStartAngle();
+        for (int i = 0; i < count; i++) {
+            double v = all.get(i).getPieValue();
+            if (!(v > 0)) {
+                continue;
+            }
+            double extent = direction * 360 * v / total;
+            middle[i] = normal(angle + extent / 2);
+            double r = Math.toRadians(-middle[i]);
+            outX[i] = reach * Math.cos(r);
+            outY[i] = reach * Math.sin(r);
+            padX = Math.max(padX, 2 * (Fonts.width(f, all.get(i).getName()) + LABEL_GAP + Math.abs(outX[i])));
+            padY = Math.max(padY, 2 * (Math.abs(outY[i]) + (outY[i] > 0 ? line - ascent : ascent)));
+            angle += extent;
+        }
+        // The pie is as large as the names around it allow; where that
+        // leaves no pie worth the name, the names go instead.
+        double radius = Math.min(w - padX, h - padY) / 2;
+        if (!labels || radius < MIN_RADIUS) {
+            labels = false;
+            radius = Math.min(w, h) / 2;
+        }
+        if (radius <= 0) {
+            return;
+        }
+        double cx = x + w / 2;
+        double cy = y + h / 2;
+        angle = getStartAngle();
+        for (int i = 0; i < count; i++) {
+            double v = all.get(i).getPieValue();
+            if (!(v > 0)) {
+                continue;
+            }
+            double extent = direction * 360 * v / total;
+            all.get(i).node.place(cx, cy, radius, angle, extent);
+            FxPath slice = new FxPath();
+            if (Math.abs(extent) >= 360 - 1e-9) {
+                slice.addEllipse(cx, cy, radius, radius);
+            } else {
+                slice.moveTo(cx, cy);
+                slice.addArc(cx, cy, radius, radius, angle, extent, true);
+                slice.closePath();
+            }
+            renderer.fill(slice, color(i), cx - radius, cy - radius, radius * 2, radius * 2);
+            // A thin line of the background parts two slices.
+            renderer.stroke(slice, PLOT, 1, StrokeLineCap.BUTT, StrokeLineJoin.MITER, 10, null, 0);
+            angle += extent;
+        }
+        if (!labels) {
+            return;
+        }
+        // Where each name goes: {left, top, right, bottom}.
+        double[][] boxes = new double[count][];
+        for (int i = 0; i < count; i++) {
+            String name = all.get(i).getName();
+            if (!(all.get(i).getPieValue() > 0) || name == null || name.length() == 0) {
+                continue;
+            }
+            double r = Math.toRadians(-middle[i]);
+            double endX = cx + radius * Math.cos(r) + outX[i];
+            double endY = cy + radius * Math.sin(r) + outY[i];
+            boolean left = !(middle[i] > -90 && middle[i] < 90);
+            double tw = Fonts.width(f, name);
+            double tx = left ? endX - tw - LABEL_GAP : endX + LABEL_GAP;
+            double top = endY - ascent / 2 - 2;
+            boxes[i] = new double[] {tx, top, tx + tw, top + line};
+        }
+        // Of two names that would run over each other, the one of the
+        // smaller slice is left out.
+        for (int i = 0; i < count; i++) {
+            for (int j = i + 1; j < count && boxes[i] != null; j++) {
+                double[] a = boxes[i];
+                double[] b = boxes[j];
+                if (b == null || a[0] > b[2] || b[0] > a[2] || a[1] > b[3] || b[1] > a[3]) {
+                    continue;
+                }
+                if (all.get(i).getPieValue() < all.get(j).getPieValue()) {
+                    boxes[i] = null;
+                } else {
+                    boxes[j] = null;
+                }
+            }
+        }
+        for (int i = 0; i < count; i++) {
+            if (boxes[i] == null) {
+                continue;
+            }
+            double r = Math.toRadians(-middle[i]);
+            double edgeX = cx + radius * Math.cos(r);
+            double edgeY = cy + radius * Math.sin(r);
+            XYChart.line(renderer, edgeX, edgeY, edgeX + outX[i], edgeY + outY[i], AXIS, 1);
+            FxPath end = new FxPath();
+            end.addEllipse(edgeX + outX[i], edgeY + outY[i], 2, 2);
+            renderer.stroke(end, AXIS, 1, StrokeLineCap.BUTT, StrokeLineJoin.MITER, 10, null, 0);
+            renderer.drawText(all.get(i).getName(), boxes[i][0], boxes[i][1], f, TEXT);
+        }
+    }
+
+    /// What the pointer finds over a slice. The chart draws the slice; this
+    /// node only answers whether a point of the chart is inside it.
+    static final class Slice extends Region {
+
+        boolean drawn;
+        private double cx;
+        private double cy;
+        private double radius;
+        private double start;
+        private double extent;
+
+        Slice() {
+            getStyleClass().add("chart-pie");
+            setManaged(false);
+        }
+
+        /// Where the chart drew the slice, in the chart's coordinates: the
+        /// centre and the radius of the pie, the angle the slice starts at
+        /// and how far it turns, counter clockwise when positive.
+        void place(double centreX, double centreY, double r, double from, double turn) {
+            cx = centreX;
+            cy = centreY;
+            radius = r;
+            start = from;
+            extent = turn;
+            drawn = true;
+        }
+
+        boolean inside(double x, double y) {
+            if (!drawn) {
+                return false;
+            }
+            double dx = x - cx;
+            double dy = y - cy;
+            if (dx * dx + dy * dy > radius * radius) {
+                return false;
+            }
+            if (Math.abs(extent) >= 360 - 1e-9) {
+                return true;
+            }
+            // The turn from the start of the slice to the point, in the
+            // direction the slice turns.
+            double turn = (Math.toDegrees(Math.atan2(-dy, dx)) - start) % 360;
+            if (extent < 0) {
+                turn = -turn;
+            }
+            if (turn < 0) {
+                turn += 360;
+            }
+            return turn <= Math.abs(extent);
+        }
+
+        @Override
+        public boolean contains(double x, double y) {
+            return inside(x, y);
+        }
+
+        @Override
+        protected Node cn1PickLocal(double x, double y) {
+            return inside(x, y) ? this : null;
+        }
+    }
+
+    /// One slice of a pie: a name and a value.
+    ///
+    /// The node of a data item draws nothing, the chart draws its slices
+    /// itself; it is what a click on the slice reaches.
+    public static final class Data {
+
+        private final StringProperty name = new SimpleStringProperty(this, "name");
+        private final DoubleProperty pieValue = new SimpleDoubleProperty(this, "pieValue");
+        final ReadOnlyObjectWrapper<PieChart> chart = new ReadOnlyObjectWrapper<PieChart>(this, "chart");
+        final Slice node = new Slice();
+
+        /// Creates a slice.
+        public Data(String name, double value) {
+            InvalidationListener repaint = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    PieChart owner = chart.get();
+                    if (owner != null) {
+                        owner.cn1Repaint();
+                    }
+                }
+            };
+            this.name.addListener(repaint);
+            this.pieValue.addListener(repaint);
+            this.name.set(name);
+            this.pieValue.set(value);
+        }
+
+        /// Returns the chart the slice is in, `null` when in none.
+        public final PieChart getChart() {
+            return chart.get();
+        }
+
+        /// The chart the slice is in.
+        public final ReadOnlyObjectProperty<PieChart> chartProperty() {
+            return chart.getReadOnlyProperty();
+        }
+
+        /// Returns the name of the slice.
+        public final String getName() {
+            return name.get();
+        }
+
+        /// Sets the name of the slice.
+        public final void setName(String value) {
+            name.set(value);
+        }
+
+        /// The name of the slice.
+        public final StringProperty nameProperty() {
+            return name;
+        }
+
+        /// Returns the value the size of the slice comes from.
+        public final double getPieValue() {
+            return pieValue.get();
+        }
+
+        /// Sets the value the size of the slice comes from.
+        public final void setPieValue(double value) {
+            pieValue.set(value);
+        }
+
+        /// The value the size of the slice comes from.
+        public final DoubleProperty pieValueProperty() {
+            return pieValue;
+        }
+
+        /// Returns the node a click on the slice reaches. It draws nothing:
+        /// the chart draws the slice.
+        public Node getNode() {
+            return node;
+        }
+
+        @Override
+        public String toString() {
+            return "Data[" + getName() + "," + getPieValue() + "]";
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/Scale.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/Scale.java
new file mode 100644
index 00000000000..4288d2fc384
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/Scale.java
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Fonts;
+
+import javafx.geometry.Side;
+import javafx.scene.text.Font;
+
+/// One axis laid out along a length of pixels: the range or the bands it
+/// settled on, where each value is along it, its ticks and their labels,
+/// and how much room it needs across itself.
+///
+/// A place along the axis is measured from the left end of a horizontal
+/// axis and from the top end of a vertical one, so that a greater number
+/// is further right or further up.
+final class Scale {
+
+    /// The room kept between two tick labels when a tick unit is chosen.
+    private static final double LABEL_ROOM = 6;
+
+    final Axis<?> axis;
+    final boolean category;
+    final Side side;
+    final boolean horizontal;
+    final double length;
+    final Font font;
+    final List<String> names = new ArrayList<String>();
+    final List<Object> ticks = new ArrayList<Object>();
+    final List<String> labels = new ArrayList<String>();
+    /// The places of the minor ticks along the axis.
+    final List<Double> minors = new ArrayList<Double>();
+    double lower;
+    double upper = 1;
+    double unit = 1;
+    /// The place of the first category and the distance to the next.
+    double first;
+    double spacing;
+    /// The rotation the tick labels are drawn with, in degrees.
+    double rotation;
+    /// The room the axis takes across itself: its tick marks, the gap,
+    /// the tick labels and its own label.
+    double thickness;
+
+    private Scale(Axis<?> axis, Side side, double length) {
+        this.axis = axis;
+        this.category = !(axis instanceof ValueAxis);
+        this.side = side;
+        this.horizontal = side.isHorizontal();
+        this.length = length;
+        Font f = axis.getTickLabelFont();
+        this.font = f == null ? Font.font(10) : f;
+        this.rotation = axis.getTickLabelRotation();
+    }
+
+    /// Lays an axis out along a length from the values the data has on
+    /// it.
+    ///
+    /// @param zero whether a range taken from the data must hold zero
+    ///     whatever the axis says, as the value axis of a bar chart does
+    static Scale of(Axis<?> axis, Side side, List<Object> values, boolean zero, double length) {
+        Scale s = new Scale(axis, side, Math.max(0, length));
+        if (axis instanceof ValueAxis) {
+            s.numbers((ValueAxis<?>) axis, values, zero);
+        } else {
+            s.categories(values);
+        }
+        s.measure();
+        return s;
+    }
+
+    /// The width and height of the box around a text turned by the
+    /// rotation of the tick labels.
+    double[] box(String text) {
+        double w = Fonts.width(font, text);
+        double h = Fonts.lineHeight(font);
+        if (rotation == 0) {
+            return new double[] {w, h};
+        }
+        double r = Math.toRadians(rotation);
+        double cos = Math.abs(Math.cos(r));
+        double sin = Math.abs(Math.sin(r));
+        return new double[] {w * cos + h * sin, w * sin + h * cos};
+    }
+
+    private void categories(List<Object> values) {
+        if (axis instanceof CategoryAxis) {
+            names.addAll(((CategoryAxis) axis).getCategories());
+        }
+        if (names.isEmpty()) {
+            for (int i = 0; i < values.size(); i++) {
+                String name = String.valueOf(values.get(i));
+                if (!names.contains(name)) {
+                    names.add(name);
+                }
+            }
+        }
+        double start = 0;
+        double end = 0;
+        boolean gap = true;
+        if (axis instanceof CategoryAxis) {
+            CategoryAxis c = (CategoryAxis) axis;
+            start = c.getStartMargin();
+            end = c.getEndMargin();
+            gap = c.isGapStartAndEnd();
+        }
+        int count = names.size();
+        int bands = gap ? count : count - 1;
+        spacing = bands > 0 ? (length - start - end) / bands : 0;
+        first = start + (gap ? spacing / 2 : 0);
+        for (int i = 0; i < count; i++) {
+            ticks.add(names.get(i));
+            labels.add(axis.text(names.get(i)));
+        }
+        // Labels that do not fit side by side along a horizontal axis
+        // are stood on end, and those of a vertical one laid flat.
+        double widest = 0;
+        double last = 0;
+        for (int i = 0; i < count; i++) {
+            double[] b = box(labels.get(i));
+            double size = horizontal && rotation == 0 ? b[0] : b[1];
+            if (i == 0) {
+                last = size / 2;
+            } else {
+                widest = Math.max(widest, last + LABEL_ROOM + size / 2);
+            }
+        }
+        if (start + widest * count + end > length) {
+            if (horizontal && rotation != 90) {
+                rotation = 90;
+            } else if (!horizontal && rotation != 0) {
+                rotation = 0;
+            }
+        }
+    }
+
+    private void numbers(ValueAxis<?> value, List<Object> values, boolean zero) {
+        if (!value.isAutoRanging()) {
+            lower = value.getLowerBound();
+            upper = value.getUpperBound();
+            unit = value.unit();
+        } else {
+            double min = Double.POSITIVE_INFINITY;
+            double max = Double.NEGATIVE_INFINITY;
+            for (int i = 0; i < values.size(); i++) {
+                double v = number(values.get(i));
+                if (v == v && !Double.isInfinite(v)) {
+                    min = Math.min(min, v);
+                    max = Math.max(max, v);
+                }
+            }
+            if (min > max) {
+                // No data: the range the axis has is rounded.
+                min = Math.min(value.getLowerBound(), value.getUpperBound());
+                max = Math.max(value.getLowerBound(), value.getUpperBound());
+            }
+            if (zero || value.zeroInRange()) {
+                if (max < 0) {
+                    max = 0;
+                } else if (min > 0) {
+                    min = 0;
+                }
+            }
+            autoRange(value, min, max);
+            value.range(lower, upper, unit);
+        }
+        numberTicks(value);
+    }
+
+    /// Ten to a power, exact for the small powers a tick unit has.
+    static double pow10(int exponent) {
+        double p = 1;
+        for (int i = exponent < 0 ? -exponent : exponent; i > 0; i--) {
+            p *= 10;
+        }
+        return exponent < 0 ? 1 / p : p;
+    }
+
+    /// Chooses the bounds and the tick unit for a range of data.
+    private void autoRange(ValueAxis<?> value, double min, double max) {
+        int fit = Math.max(2, (int) Math.floor(length / (font.getSize() * 2)));
+        int minor = Math.max(1, value.getMinorTickCount());
+        double range = max - min;
+        // A range too small to tell its minor ticks apart is no range.
+        if (range != 0 && range / ((double) fit * minor) <= Math.abs(min) * 2.3e-16) {
+            range = 0;
+        }
+        double padded = range == 0 ? (min == 0 ? 2 : Math.abs(min) * 0.02) : Math.abs(range) * 1.02;
+        double pad = (padded - range) / 2;
+        double from = min - pad;
+        double to = max + pad;
+        // The padding never carries a bound across zero.
+        if ((from < 0 && min >= 0) || (from > 0 && min <= 0)) {
+            from = 0;
+        }
+        if ((to < 0 && max >= 0) || (to > 0 && max <= 0)) {
+            to = 0;
+        }
+        double step = padded / fit;
+        if (!(step > 0) || Double.isInfinite(step)) {
+            lower = from;
+            upper = from + 1;
+            unit = 1;
+            value.format(0, false);
+            return;
+        }
+        for (int round = 0; round < 64; round++) {
+            int exponent = 0;
+            while (exponent > -300 && pow10(exponent) > step) {
+                exponent--;
+            }
+            while (exponent < 300 && pow10(exponent + 1) <= step) {
+                exponent++;
+            }
+            double mantissa = step / pow10(exponent);
+            double ratio = mantissa;
+            if (mantissa > 5) {
+                exponent++;
+                ratio = 1;
+            } else if (mantissa > 1) {
+                ratio = mantissa > 2.5 ? 5 : 2.5;
+            }
+            if (exponent > 1) {
+                value.format(0, true);
+            } else if (exponent == 1) {
+                value.format(0, false);
+            } else {
+                boolean fraction = !whole(ratio);
+                value.format(-exponent + (fraction ? 1 : 0), false);
+            }
+            unit = exponent < 0 ? ratio / pow10(-exponent) : ratio * pow10(exponent);
+            lower = Math.floor(from / unit) * unit;
+            upper = Math.ceil(to / unit) * unit;
+            int count = (int) Math.ceil((upper - lower) / unit);
+            // The room the labels of these ticks need along the axis.
+            double widest = 0;
+            double last = 0;
+            for (int i = 0; i < count && i <= 400; i++) {
+                double[] b = box(axis.text(Double.valueOf(lower + i * unit)));
+                double size = horizontal ? b[0] : b[1];
+                if (i == 0) {
+                    last = size / 2;
+                } else {
+                    widest = Math.max(widest, last + LABEL_ROOM + size / 2);
+                }
+            }
+            double needed = (count - 1) * widest;
+            step = unit;
+            if (fit == 2 && needed > length) {
+                break;
+            }
+            if (needed > length || count > 20) {
+                step *= 2;
+            } else {
+                break;
+            }
+        }
+        if (!(upper > lower)) {
+            upper = lower + unit;
+        }
+    }
+
+    /// Whether a number has no fraction.
+    private static boolean whole(double value) {
+        return value - Math.floor(value) <= 0;
+    }
+
+    private void numberTicks(ValueAxis<?> value) {
+        double span = upper - lower;
+        if (!(span > 0)) {
+            ticks.add(Double.valueOf(lower));
+        } else {
+            ticks.add(Double.valueOf(lower));
+            if (unit > 0 && lower + unit < upper && span / unit <= 2000) {
+                // A whole tick unit puts its ticks on whole numbers.
+                boolean whole = whole(unit);
+                double start = whole ? Math.ceil(lower) : lower + unit;
+                int count = (int) Math.ceil((upper - start) / unit);
+                for (int i = 0; i < count; i++) {
+                    double major = start + i * unit;
+                    if (major >= upper) {
+                        break;
+                    }
+                    if (major > lower) {
+                        ticks.add(Double.valueOf(major));
+                    }
+                }
+            }
+            ticks.add(Double.valueOf(upper));
+        }
+        for (int i = 0; i < ticks.size(); i++) {
+            labels.add(axis.text(ticks.get(i)));
+        }
+        int parts = Math.max(1, value.getMinorTickCount());
+        if (!value.isMinorTickVisible() || !(value.getMinorTickLength() > 0) || parts < 2 || !(span > 0)
+                || !(unit > 0)) {
+            return;
+        }
+        // Minor ticks are left out where they would be a pixel apart.
+        int wanted = (ticks.size() - 1) * (parts - 1);
+        if (length <= (ticks.size() + wanted) * 2.0) {
+            return;
+        }
+        double step = unit / parts;
+        if (span / step > 10000) {
+            return;
+        }
+        boolean whole = whole(unit);
+        double start = whole ? Math.ceil(lower) : lower;
+        if (whole) {
+            // The part of a tick unit before the first whole number.
+            for (int i = 1; i < parts; i++) {
+                double v = start - unit + i * step;
+                if (v > lower && v < start) {
+                    minors.add(Double.valueOf(along(v)));
+                }
+            }
+        }
+        int count = (int) Math.ceil((upper - start) / unit);
+        for (int i = 0; i < count; i++) {
+            double major = start + i * unit;
+            double next = Math.min(major + unit, upper);
+            for (int j = 1; j < parts; j++) {
+                double v = major + j * step;
+                if (v >= next) {
+                    break;
+                }
+                minors.add(Double.valueOf(along(v)));
+            }
+        }
+    }
+
+    /// Works out the room the axis takes across itself.
+    private void measure() {
+        double across = 0;
+        if (axis.isTickLabelsVisible()) {
+            for (int i = 0; i < labels.size(); i++) {
+                double[] b = box(labels.get(i));
+                across = Math.max(across, horizontal ? b[1] : b[0]);
+            }
+        }
+        thickness = across + axis.getTickLabelGap() + tickLength() + labelHeight();
+    }
+
+    /// The length of a tick mark, zero when none are drawn.
+    double tickLength() {
+        return axis.isTickMarkVisible() && axis.getTickLength() > 0 ? axis.getTickLength() : 0;
+    }
+
+    /// The room the label of the axis takes across it, zero when it has
+    /// none: a line of text and four pixels between it and the ticks.
+    double labelHeight() {
+        String label = axis.getLabel();
+        return label == null || label.length() == 0 ? 0 : Fonts.lineHeight(Chart.font(12)) + 4;
+    }
+
+    static double number(Object value) {
+        return value instanceof Number ? ((Number) value).doubleValue() : Double.NaN;
+    }
+
+    private double along(double number) {
+        double span = upper - lower;
+        if (!(span > 0)) {
+            return Double.NaN;
+        }
+        double along = (number - lower) * length / span;
+        return horizontal ? along : length - along;
+    }
+
+    /// Where a value is along the axis, or NaN when the axis has no
+    /// place for it.
+    double at(Object value) {
+        if (category) {
+            int index = names.indexOf(String.valueOf(value));
+            if (index < 0) {
+                return Double.NaN;
+            }
+            double along = first + index * spacing;
+            return horizontal ? along : length - along;
+        }
+        return along(number(value));
+    }
+
+    /// Where zero is along a number axis, NaN when zero is not in its
+    /// range.
+    double zero() {
+        if (category || lower > 0 || upper < 0) {
+            return Double.NaN;
+        }
+        return along(0);
+    }
+
+    /// Where a bar starts along a number axis: at zero, or at the end of
+    /// the axis nearest to zero when zero is not in its range.
+    double base() {
+        if (category) {
+            return 0;
+        }
+        return along(lower > 0 ? lower : upper < 0 ? upper : 0);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/ScatterChart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/ScatterChart.java
new file mode 100644
index 00000000000..011063a58e2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/ScatterChart.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.collections.ObservableList;
+import javafx.scene.paint.Color;
+
+/// A chart that draws a symbol at each point and joins nothing.
+///
+/// Each series has a symbol of its own shape as well as its own colour,
+/// the eight of JavaFX in turn: a disc, a square, a diamond, a cross, a
+/// triangle, and then a ring, a square and a diamond with white middles.
+/// See [Chart] for what the charts of this layer leave out.
+public class ScatterChart<X, Y> extends XYChart<X, Y> {
+
+    private static final double[] CROSS = {2, 0, 5, 4, 8, 0, 10, 0, 10, 2, 6, 5, 10, 8, 10, 10, 8, 10, 5, 6, 2, 10,
+        0, 10, 0, 8, 4, 5, 0, 2, 0, 0};
+
+    /// Creates a scatter chart.
+    public ScatterChart(Axis<X> xAxis, Axis<Y> yAxis) {
+        super(xAxis, yAxis);
+    }
+
+    /// Creates a scatter chart of the given series.
+    public ScatterChart(Axis<X> xAxis, Axis<Y> yAxis, ObservableList<Series<X, Y>> data) {
+        super(xAxis, yAxis);
+        setData(data);
+    }
+
+    private static int shape(int series) {
+        return (series < 0 ? 0 : series) % 8;
+    }
+
+    private static void diamond(Renderer renderer, double cx, double cy, double halfWidth, double halfHeight,
+            Color color) {
+        FxPath path = new FxPath();
+        path.moveTo(cx, cy - halfHeight);
+        path.lineTo(cx + halfWidth, cy);
+        path.lineTo(cx, cy + halfHeight);
+        path.lineTo(cx - halfWidth, cy);
+        path.closePath();
+        renderer.fill(path, color, cx - halfWidth, cy - halfHeight, halfWidth * 2, halfHeight * 2);
+    }
+
+    /// Draws the symbol of a series about a point.
+    static void mark(Renderer renderer, int series, double cx, double cy) {
+        Color color = color(series);
+        int shape = shape(series);
+        if (shape == 0) {
+            ring(renderer, cx, cy, 5, 0, color);
+        } else if (shape == 1) {
+            renderer.fillRect(cx - 5, cy - 5, 10, 10, color);
+        } else if (shape == 2) {
+            diamond(renderer, cx, cy, 5, 7, color);
+        } else if (shape == 3) {
+            FxPath path = new FxPath();
+            path.moveTo(cx - 5 + CROSS[0], cy - 5 + CROSS[1]);
+            for (int i = 2; i + 1 < CROSS.length; i += 2) {
+                path.lineTo(cx - 5 + CROSS[i], cy - 5 + CROSS[i + 1]);
+            }
+            path.closePath();
+            renderer.fill(path, color, cx - 5, cy - 5, 10, 10);
+        } else if (shape == 4) {
+            FxPath path = new FxPath();
+            path.moveTo(cx, cy - 5);
+            path.lineTo(cx + 5, cy + 5);
+            path.lineTo(cx - 5, cy + 5);
+            path.closePath();
+            renderer.fill(path, color, cx - 5, cy - 5, 10, 10);
+        } else if (shape == 5) {
+            ring(renderer, cx, cy, 5, 3, color);
+        } else if (shape == 6) {
+            renderer.fillRect(cx - 5, cy - 5, 10, 10, color);
+            renderer.fillRect(cx - 3, cy - 3, 6, 6, Color.WHITE);
+        } else {
+            diamond(renderer, cx, cy, 5, 7, color);
+            diamond(renderer, cx, cy, 2.5, 4.5, Color.WHITE);
+        }
+    }
+
+    @Override
+    double[] legendSymbolSize(int index) {
+        int shape = shape(index);
+        return new double[] {10, shape == 2 || shape == 7 ? 14 : 10};
+    }
+
+    @Override
+    void legendSymbol(Renderer renderer, int index, double x, double y) {
+        double[] size = legendSymbolSize(index);
+        mark(renderer, index, x + size[0] / 2, y + size[1] / 2);
+    }
+
+    @Override
+    void drawSeries(Renderer renderer, List<Series<X, Y>> series, Scale sx, Scale sy, double x, double y, double w,
+            double h) {
+        for (int s = 0; s < series.size(); s++) {
+            List<double[]> points = LineChart.places(series.get(s), sx, sy, x, y, 2);
+            for (int i = 0; i < points.size(); i++) {
+                mark(renderer, s, points.get(i)[0], points.get(i)[1]);
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/ValueAxis.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/ValueAxis.java
new file mode 100644
index 00000000000..307e0b4844e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/ValueAxis.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.util.StringConverter;
+
+/// An axis of numbers between a lower and an upper bound.
+///
+/// While the axis is auto ranging, the chart writes the range it chose
+/// into the bounds each time it draws. Between two ticks the axis draws
+/// minor ticks that cut the distance into `minorTickCount` parts, unless
+/// `minorTickVisible` is off or there is no room for them.
+public abstract class ValueAxis<T extends Number> extends Axis<T> {
+
+    private final DoubleProperty lowerBound = new FxDouble(this, "lowerBound", 0, Dirty.PAINT);
+    private final DoubleProperty upperBound = new FxDouble(this, "upperBound", 100, Dirty.PAINT);
+    private final IntegerProperty minorTickCount = new SimpleIntegerProperty(this, "minorTickCount", 5);
+    private final BooleanProperty minorTickVisible = new FxBoolean(this, "minorTickVisible", true, Dirty.PAINT);
+    private final DoubleProperty minorTickLength = new FxDouble(this, "minorTickLength", 5, Dirty.PAINT);
+    private final ObjectProperty<StringConverter<T>> tickLabelFormatter = new FxObject<StringConverter<T>>(this,
+            "tickLabelFormatter", null, Dirty.PAINT);
+    private boolean writing;
+
+    /// Creates an auto ranging axis.
+    public ValueAxis() {
+        minorTickCount.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                cn1Invalidated(Dirty.PAINT);
+            }
+        });
+    }
+
+    /// Creates an axis with a fixed range.
+    public ValueAxis(double lowerBound, double upperBound) {
+        this();
+        setAutoRanging(false);
+        this.lowerBound.set(lowerBound);
+        this.upperBound.set(upperBound);
+    }
+
+    /// Writes the range the chart chose, without asking for a repaint.
+    void range(double lower, double upper, double unit) {
+        writing = true;
+        try {
+            lowerBound.set(lower);
+            upperBound.set(upper);
+            unit(unit);
+        } finally {
+            writing = false;
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if (!writing) {
+            super.cn1Invalidated(what);
+        }
+    }
+
+    /// Returns the value at the start of the axis.
+    public final double getLowerBound() {
+        return lowerBound.get();
+    }
+
+    /// Sets the value at the start of the axis.
+    public final void setLowerBound(double value) {
+        lowerBound.set(value);
+    }
+
+    /// The value at the start of the axis.
+    public final DoubleProperty lowerBoundProperty() {
+        return lowerBound;
+    }
+
+    /// Returns the value at the end of the axis.
+    public final double getUpperBound() {
+        return upperBound.get();
+    }
+
+    /// Sets the value at the end of the axis.
+    public final void setUpperBound(double value) {
+        upperBound.set(value);
+    }
+
+    /// The value at the end of the axis.
+    public final DoubleProperty upperBoundProperty() {
+        return upperBound;
+    }
+
+    /// Returns the number of parts the minor ticks cut the distance
+    /// between two ticks into.
+    public final int getMinorTickCount() {
+        return minorTickCount.get();
+    }
+
+    /// Sets the number of parts the minor ticks cut the distance between
+    /// two ticks into: one fewer minor ticks are drawn between them.
+    public final void setMinorTickCount(int value) {
+        minorTickCount.set(value);
+    }
+
+    /// The number of parts the minor ticks cut the distance between two
+    /// ticks into.
+    public final IntegerProperty minorTickCountProperty() {
+        return minorTickCount;
+    }
+
+    /// Returns whether the minor ticks are drawn.
+    public final boolean isMinorTickVisible() {
+        return minorTickVisible.get();
+    }
+
+    /// Sets whether the minor ticks are drawn.
+    public final void setMinorTickVisible(boolean value) {
+        minorTickVisible.set(value);
+    }
+
+    /// Whether the minor ticks are drawn.
+    public final BooleanProperty minorTickVisibleProperty() {
+        return minorTickVisible;
+    }
+
+    /// Returns the length of a minor tick.
+    public final double getMinorTickLength() {
+        return minorTickLength.get();
+    }
+
+    /// Sets the length of a minor tick.
+    public final void setMinorTickLength(double value) {
+        minorTickLength.set(value);
+    }
+
+    /// The length of a minor tick.
+    public final DoubleProperty minorTickLengthProperty() {
+        return minorTickLength;
+    }
+
+    /// Returns what turns a tick value into its label, `null` for the
+    /// plain number.
+    public final StringConverter<T> getTickLabelFormatter() {
+        return tickLabelFormatter.get();
+    }
+
+    /// Sets what turns a tick value into its label.
+    public final void setTickLabelFormatter(StringConverter<T> value) {
+        tickLabelFormatter.set(value);
+    }
+
+    /// What turns a tick value into its label.
+    public final ObjectProperty<StringConverter<T>> tickLabelFormatterProperty() {
+        return tickLabelFormatter;
+    }
+
+    /// The distance between two ticks.
+    abstract double unit();
+
+    /// Takes the distance between two ticks the chart chose.
+    abstract void unit(double value);
+
+    /// Takes the number of decimals the chart chose for the tick labels
+    /// and whether their thousands are grouped.
+    abstract void format(int decimals, boolean grouping);
+
+    /// Whether zero is kept in a range taken from the data.
+    abstract boolean zeroInRange();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/XYChart.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/XYChart.java
new file mode 100644
index 00000000000..c69e27fcc1c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/XYChart.java
@@ -0,0 +1,766 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.chart;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Side;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.text.Font;
+
+/// A chart of series of data drawn against two axes.
+///
+/// The chart draws its axes itself, each on its side of the plot: the X
+/// axis below it unless its side is the top, the Y axis to its left
+/// unless its side is the right. Dashed grid lines cross the plot at the
+/// ticks of both, and what is drawn of the series is cut off at the edge
+/// of the plot. Alternating row and column fills are recorded and not
+/// drawn, as the default style sheet of JavaFX gives them no fill. See
+/// [Chart] for what all the charts of this layer leave out.
+public abstract class XYChart<X, Y> extends Chart {
+
+    private final Axis<X> xAxis;
+    private final Axis<Y> yAxis;
+    private final ObjectProperty<ObservableList<Series<X, Y>>> data =
+            new SimpleObjectProperty<ObservableList<Series<X, Y>>>(this, "data");
+    private final BooleanProperty horizontalGridLinesVisible = new FxBoolean(this, "horizontalGridLinesVisible",
+            true, Dirty.PAINT);
+    private final BooleanProperty verticalGridLinesVisible = new FxBoolean(this, "verticalGridLinesVisible", true,
+            Dirty.PAINT);
+    private final BooleanProperty horizontalZeroLineVisible = new FxBoolean(this, "horizontalZeroLineVisible",
+            true, Dirty.PAINT);
+    private final BooleanProperty verticalZeroLineVisible = new FxBoolean(this, "verticalZeroLineVisible", true,
+            Dirty.PAINT);
+    private final BooleanProperty alternativeRowFillVisible = new FxBoolean(this, "alternativeRowFillVisible",
+            true, Dirty.NONE);
+    private final BooleanProperty alternativeColumnFillVisible = new FxBoolean(this,
+            "alternativeColumnFillVisible", false, Dirty.NONE);
+
+    private final ListWatch<Series<X, Y>> watch = new ListWatch<Series<X, Y>>() {
+        @Override
+        void added(Series<X, Y> series) {
+            if (series != null) {
+                series.chart.set(XYChart.this);
+            }
+        }
+
+        @Override
+        void removed(Series<X, Y> series) {
+            if (series != null && series.chart.get() == XYChart.this) {
+                series.chart.set(null);
+            }
+        }
+
+        @Override
+        void changed() {
+            cn1Repaint();
+        }
+    };
+
+    /// Creates a chart of two axes.
+    public XYChart(Axis<X> xAxis, Axis<Y> yAxis) {
+        this.xAxis = xAxis;
+        this.yAxis = yAxis;
+        if (xAxis != null) {
+            if (xAxis.getSide() == null) {
+                xAxis.setSide(Side.BOTTOM);
+            }
+            xAxis.attach(this);
+        }
+        if (yAxis != null) {
+            if (yAxis.getSide() == null) {
+                yAxis.setSide(Side.LEFT);
+            }
+            yAxis.attach(this);
+        }
+        data.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                watch.watch(data.get());
+            }
+        });
+        data.set(FXCollections.<Series<X, Y>>observableArrayList());
+    }
+
+    /// Returns the horizontal axis.
+    public Axis<X> getXAxis() {
+        return xAxis;
+    }
+
+    /// Returns the vertical axis.
+    public Axis<Y> getYAxis() {
+        return yAxis;
+    }
+
+    /// Returns the series of the chart.
+    public final ObservableList<Series<X, Y>> getData() {
+        return data.get();
+    }
+
+    /// Sets the list the chart takes its series from.
+    public final void setData(ObservableList<Series<X, Y>> value) {
+        data.set(value);
+    }
+
+    /// The list the chart takes its series from.
+    public final ObjectProperty<ObservableList<Series<X, Y>>> dataProperty() {
+        return data;
+    }
+
+    /// Returns whether a grid line is drawn at each tick of the Y axis.
+    public final boolean isHorizontalGridLinesVisible() {
+        return horizontalGridLinesVisible.get();
+    }
+
+    /// Sets whether a grid line is drawn at each tick of the Y axis.
+    public final void setHorizontalGridLinesVisible(boolean value) {
+        horizontalGridLinesVisible.set(value);
+    }
+
+    /// Whether a grid line is drawn at each tick of the Y axis.
+    public final BooleanProperty horizontalGridLinesVisibleProperty() {
+        return horizontalGridLinesVisible;
+    }
+
+    /// Returns whether a grid line is drawn at each tick of the X axis.
+    public final boolean getVerticalGridLinesVisible() {
+        return verticalGridLinesVisible.get();
+    }
+
+    /// Sets whether a grid line is drawn at each tick of the X axis.
+    public final void setVerticalGridLinesVisible(boolean value) {
+        verticalGridLinesVisible.set(value);
+    }
+
+    /// Whether a grid line is drawn at each tick of the X axis.
+    public final BooleanProperty verticalGridLinesVisibleProperty() {
+        return verticalGridLinesVisible;
+    }
+
+    /// Returns whether the line of zero on the Y axis is drawn.
+    public final boolean isHorizontalZeroLineVisible() {
+        return horizontalZeroLineVisible.get();
+    }
+
+    /// Sets whether the line of zero on the Y axis is drawn.
+    public final void setHorizontalZeroLineVisible(boolean value) {
+        horizontalZeroLineVisible.set(value);
+    }
+
+    /// Whether the line of zero on the Y axis is drawn.
+    public final BooleanProperty horizontalZeroLineVisibleProperty() {
+        return horizontalZeroLineVisible;
+    }
+
+    /// Returns whether the line of zero on the X axis is drawn.
+    public final boolean isVerticalZeroLineVisible() {
+        return verticalZeroLineVisible.get();
+    }
+
+    /// Sets whether the line of zero on the X axis is drawn.
+    public final void setVerticalZeroLineVisible(boolean value) {
+        verticalZeroLineVisible.set(value);
+    }
+
+    /// Whether the line of zero on the X axis is drawn.
+    public final BooleanProperty verticalZeroLineVisibleProperty() {
+        return verticalZeroLineVisible;
+    }
+
+    /// Returns whether alternate rows were asked to be filled.
+    public final boolean isAlternativeRowFillVisible() {
+        return alternativeRowFillVisible.get();
+    }
+
+    /// Records whether alternate rows are to be filled; none are.
+    public final void setAlternativeRowFillVisible(boolean value) {
+        alternativeRowFillVisible.set(value);
+    }
+
+    /// Whether alternate rows were asked to be filled.
+    public final BooleanProperty alternativeRowFillVisibleProperty() {
+        return alternativeRowFillVisible;
+    }
+
+    /// Returns whether alternate columns were asked to be filled.
+    public final boolean isAlternativeColumnFillVisible() {
+        return alternativeColumnFillVisible.get();
+    }
+
+    /// Records whether alternate columns are to be filled; none are.
+    public final void setAlternativeColumnFillVisible(boolean value) {
+        alternativeColumnFillVisible.set(value);
+    }
+
+    /// Whether alternate columns were asked to be filled.
+    public final BooleanProperty alternativeColumnFillVisibleProperty() {
+        return alternativeColumnFillVisible;
+    }
+
+    /// The series of the chart that are there to draw.
+    final List<Series<X, Y>> series() {
+        List<Series<X, Y>> out = new ArrayList<Series<X, Y>>();
+        ObservableList<Series<X, Y>> all = getData();
+        if (all != null) {
+            for (int i = 0; i < all.size(); i++) {
+                Series<X, Y> s = all.get(i);
+                if (s != null && s.getData() != null) {
+                    out.add(s);
+                }
+            }
+        }
+        return out;
+    }
+
+    @Override
+    final String[] legend() {
+        List<Series<X, Y>> all = series();
+        String[] names = new String[all.size()];
+        for (int i = 0; i < names.length; i++) {
+            String name = all.get(i).getName();
+            names[i] = name == null ? "" : name;
+        }
+        return names;
+    }
+
+    /// Whether the number axis must hold zero, as one that bars grow
+    /// from does.
+    boolean zeroBased() {
+        return false;
+    }
+
+    /// Draws the series into the plot.
+    abstract void drawSeries(Renderer renderer, List<Series<X, Y>> series, Scale sx, Scale sy, double x, double y,
+            double w, double h);
+
+    private static final double[] NOWHERE = new double[0];
+    private static final double[] DASHES = {3, 3};
+
+    /// The place of a data item in the plot, or an empty array when an
+    /// axis has no place for it.
+    static double[] place(Data<?, ?> item, Scale sx, Scale sy, double x, double y) {
+        double fx = sx.at(item.getXValue());
+        double fy = sy.at(item.getYValue());
+        if (fx != fx || fy != fy) {
+            return NOWHERE;
+        }
+        return new double[] {x + fx, y + fy};
+    }
+
+    static void line(Renderer renderer, double x1, double y1, double x2, double y2, Color color, double width) {
+        FxPath path = new FxPath();
+        path.moveTo(x1, y1);
+        path.lineTo(x2, y2);
+        renderer.stroke(path, color, width, StrokeLineCap.BUTT, StrokeLineJoin.MITER, 10, null, 0);
+    }
+
+    private static void dashed(Renderer renderer, double x1, double y1, double x2, double y2) {
+        FxPath path = new FxPath();
+        path.moveTo(x1, y1);
+        path.lineTo(x2, y2);
+        renderer.stroke(path, GRID, 1, StrokeLineCap.BUTT, StrokeLineJoin.MITER, 10, DASHES, 0);
+    }
+
+    /// A disc of a colour with a white one of a smaller radius in it:
+    /// the symbol of a point of a line or an area.
+    static void ring(Renderer renderer, double cx, double cy, double radius, double hole, Color color) {
+        FxPath outer = new FxPath();
+        outer.addEllipse(cx, cy, radius, radius);
+        renderer.fill(outer, color, cx - radius, cy - radius, radius * 2, radius * 2);
+        if (hole > 0) {
+            FxPath inner = new FxPath();
+            inner.addEllipse(cx, cy, hole, hole);
+            renderer.fill(inner, Color.WHITE, cx - hole, cy - hole, hole * 2, hole * 2);
+        }
+    }
+
+    /// Draws a text turned about its middle.
+    static void turned(Renderer renderer, String text, double cx, double cy, double degrees, Font font,
+            Paint paint) {
+        double tw = Fonts.width(font, text);
+        double th = Fonts.lineHeight(font);
+        if (degrees == 0) {
+            renderer.drawText(text, cx - tw / 2, cy - th / 2, font, paint);
+            return;
+        }
+        renderer.save();
+        renderer.translate(cx, cy);
+        renderer.rotate(degrees);
+        renderer.drawText(text, -tw / 2, -th / 2, font, paint);
+        renderer.restore();
+    }
+
+    @Override
+    final void plot(Renderer renderer, double x, double y, double w, double h) {
+        if (xAxis == null || yAxis == null) {
+            return;
+        }
+        List<Series<X, Y>> all = series();
+        List<Object> xs = new ArrayList<Object>();
+        List<Object> ys = new ArrayList<Object>();
+        for (int i = 0; i < all.size(); i++) {
+            ObservableList<Data<X, Y>> items = all.get(i).getData();
+            for (int j = 0; j < items.size(); j++) {
+                Data<X, Y> item = items.get(j);
+                if (item != null) {
+                    xs.add(item.getXValue());
+                    ys.add(item.getYValue());
+                }
+            }
+        }
+        Side xSide = xAxis.side(true);
+        Side ySide = yAxis.side(false);
+        boolean zero = zeroBased();
+        // Each axis is as long as the plot, and the plot is what the
+        // other axis leaves: a few rounds settle the two.
+        double xThick = 0;
+        Scale sy = Scale.of(yAxis, ySide, ys, zero, h);
+        Scale sx = Scale.of(xAxis, xSide, xs, zero, w - Math.ceil(sy.thickness));
+        for (int round = 0; round < 4 && Math.abs(Math.ceil(sx.thickness) - xThick) > 0.5; round++) {
+            xThick = Math.ceil(sx.thickness);
+            sy = Scale.of(yAxis, ySide, ys, zero, h - xThick);
+            sx = Scale.of(xAxis, xSide, xs, zero, w - Math.ceil(sy.thickness));
+        }
+        xThick = Math.ceil(sx.thickness);
+        double ph = h - xThick;
+        if (Math.abs(sy.length - ph) > 0.01) {
+            sy = Scale.of(yAxis, ySide, ys, zero, ph);
+        }
+        double yThick = Math.ceil(sy.thickness);
+        double pw = w - yThick;
+        if (pw <= 0 || ph <= 0) {
+            return;
+        }
+        if (Math.abs(sx.length - pw) > 0.01) {
+            sx = Scale.of(xAxis, xSide, xs, zero, pw);
+        }
+        double px = x + (ySide == Side.LEFT ? yThick : 0);
+        double py = y + (xSide == Side.TOP ? xThick : 0);
+
+        renderer.fillRect(px, py, pw, ph, PLOT);
+        renderer.save();
+        FxPath clip = new FxPath();
+        clip.addRect(px, py, pw + 1, ph + 1);
+        renderer.clip(clip);
+        double zx = sx.zero();
+        double zy = sy.zero();
+        boolean zeroX = zx == zx && isVerticalZeroLineVisible();
+        boolean zeroY = zy == zy && isHorizontalZeroLineVisible();
+        if (getVerticalGridLinesVisible()) {
+            for (int i = 0; i < sx.ticks.size(); i++) {
+                double at = sx.at(sx.ticks.get(i));
+                if (at != at) {
+                    continue;
+                }
+                long g = Math.round(at);
+                if ((!zeroX || g != Math.round(zx)) && g > 0 && g <= pw) {
+                    dashed(renderer, px + g + 0.5, py, px + g + 0.5, py + ph);
+                }
+            }
+        }
+        if (isHorizontalGridLinesVisible()) {
+            for (int i = 0; i < sy.ticks.size(); i++) {
+                double at = sy.at(sy.ticks.get(i));
+                if (at != at) {
+                    continue;
+                }
+                long g = Math.round(at);
+                if ((!zeroY || g != Math.round(zy)) && g >= 0 && g < ph) {
+                    dashed(renderer, px, py + g + 0.5, px + pw, py + g + 0.5);
+                }
+            }
+        }
+        if (zeroX) {
+            double g = px + Math.round(zx) + 0.5;
+            line(renderer, g, py, g, py + ph, ZERO, 1);
+        }
+        if (zeroY) {
+            double g = py + Math.round(zy) + 0.5;
+            line(renderer, px, g, px + pw, g, ZERO, 1);
+        }
+        drawSeries(renderer, all, sx, sy, px, py, pw, ph);
+        renderer.restore();
+
+        drawAxis(renderer, sx, x, y, w, h, px, py, pw, ph);
+        drawAxis(renderer, sy, x, y, w, h, px, py, pw, ph);
+    }
+
+    /// Draws an axis on its side of the plot: its line along the edge of
+    /// the plot, the tick marks pointing away from the plot, the tick
+    /// labels beyond them and the label of the axis at the far edge.
+    ///
+    /// @param x the left of the room the chart has for plot and axes
+    /// @param px the left of the plot
+    private static void drawAxis(Renderer renderer, Scale s, double x, double y, double w, double h, double px,
+            double py, double pw, double ph) {
+        Axis<?> axis = s.axis;
+        boolean flat = s.horizontal;
+        // The edge of the plot the axis lies on, and the direction away
+        // from the plot.
+        double edge;
+        int away;
+        if (s.side == Side.TOP) {
+            edge = py;
+            away = -1;
+        } else if (s.side == Side.BOTTOM) {
+            edge = py + ph;
+            away = 1;
+        } else if (s.side == Side.LEFT) {
+            edge = px;
+            away = -1;
+        } else {
+            edge = px + pw;
+            away = 1;
+        }
+        double start = flat ? px : py;
+        if (flat) {
+            line(renderer, px, edge + 0.5, px + pw + 1, edge + 0.5, AXIS, 1);
+        } else {
+            line(renderer, edge + 0.5, py, edge + 0.5, py + ph + 1, AXIS, 1);
+        }
+        double minor = 0;
+        if (axis instanceof ValueAxis) {
+            minor = Math.max(0, ((ValueAxis<?>) axis).getMinorTickLength());
+        }
+        for (int i = 0; i < s.minors.size() && minor > 0; i++) {
+            double c = start + Math.round(s.minors.get(i).doubleValue()) + 0.5;
+            if (flat) {
+                line(renderer, c, edge, c, edge + away * minor, AXIS, 1);
+            } else {
+                line(renderer, edge, c, edge + away * minor, c, AXIS, 1);
+            }
+        }
+        double tick = s.tickLength();
+        double gap = axis.getTickLabelGap();
+        boolean labels = axis.isTickLabelsVisible();
+        Paint fill = axis.getTickLabelFill();
+        // The stretch of the axis the last label drawn covers.
+        double shownFrom = 0;
+        double shownTo = -1;
+        for (int i = 0; i < s.ticks.size(); i++) {
+            double at = s.at(s.ticks.get(i));
+            if (at != at) {
+                continue;
+            }
+            double c = start + Math.round(at);
+            if (tick > 0) {
+                if (flat) {
+                    line(renderer, c + 0.5, edge, c + 0.5, edge + away * tick, AXIS, 1);
+                } else {
+                    line(renderer, edge, c + 0.5, edge + away * tick, c + 0.5, AXIS, 1);
+                }
+            }
+            String text = s.labels.get(i);
+            if (!labels || text == null || text.length() == 0) {
+                continue;
+            }
+            double[] box = s.box(text);
+            double along = flat ? box[0] : box[1];
+            double across = flat ? box[1] : box[0];
+            // A label that would touch the one before it is left out.
+            if (shownTo >= shownFrom && c + along / 2 >= shownFrom && c - along / 2 <= shownTo) {
+                continue;
+            }
+            shownFrom = c - along / 2;
+            shownTo = c + along / 2;
+            double far = edge + away * (tick + gap + across / 2);
+            if (flat) {
+                turned(renderer, text, c, far, s.rotation, s.font, fill);
+            } else {
+                turned(renderer, text, far, c, s.rotation, s.font, fill);
+            }
+        }
+        String label = axis.getLabel();
+        if (label == null || label.length() == 0) {
+            return;
+        }
+        Font f = font(12);
+        double half = Fonts.lineHeight(f) / 2;
+        if (s.side == Side.TOP) {
+            turned(renderer, label, px + pw / 2, y + half, 0, f, TEXT);
+        } else if (s.side == Side.BOTTOM) {
+            turned(renderer, label, px + pw / 2, y + h - half, 0, f, TEXT);
+        } else if (s.side == Side.LEFT) {
+            turned(renderer, label, x + half, py + ph / 2, -90, f, TEXT);
+        } else {
+            turned(renderer, label, x + w - half, py + ph / 2, 90, f, TEXT);
+        }
+    }
+
+    /// One point of a series: a value on each axis.
+    ///
+    /// The node of a data item is the one the application set, `null`
+    /// otherwise; the chart shows none.
+    public static final class Data<X, Y> {
+
+        private final ObjectProperty<X> xValue = new SimpleObjectProperty<X>(this, "XValue");
+        private final ObjectProperty<Y> yValue = new SimpleObjectProperty<Y>(this, "YValue");
+        private final ObjectProperty<Object> extraValue = new SimpleObjectProperty<Object>(this, "extraValue");
+        private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+        Series<X, Y> series;
+
+        /// Creates a point with no values.
+        public Data() {
+            InvalidationListener repaint = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    if (series != null) {
+                        series.repaint();
+                    }
+                }
+            };
+            xValue.addListener(repaint);
+            yValue.addListener(repaint);
+            extraValue.addListener(repaint);
+        }
+
+        /// Creates a point.
+        public Data(X xValue, Y yValue) {
+            this();
+            this.xValue.set(xValue);
+            this.yValue.set(yValue);
+        }
+
+        /// Creates a point with a value of the application's beside it.
+        public Data(X xValue, Y yValue, Object extraValue) {
+            this(xValue, yValue);
+            this.extraValue.set(extraValue);
+        }
+
+        /// Returns the value on the X axis.
+        public final X getXValue() {
+            return xValue.get();
+        }
+
+        /// Sets the value on the X axis.
+        public final void setXValue(X value) {
+            xValue.set(value);
+        }
+
+        /// The value on the X axis.
+        public final ObjectProperty<X> XValueProperty() {
+            return xValue;
+        }
+
+        /// Returns the value on the Y axis.
+        public final Y getYValue() {
+            return yValue.get();
+        }
+
+        /// Sets the value on the Y axis.
+        public final void setYValue(Y value) {
+            yValue.set(value);
+        }
+
+        /// The value on the Y axis.
+        public final ObjectProperty<Y> YValueProperty() {
+            return yValue;
+        }
+
+        /// Returns the extra value of the point.
+        public final Object getExtraValue() {
+            return extraValue.get();
+        }
+
+        /// Sets an extra value for the point.
+        public final void setExtraValue(Object value) {
+            extraValue.set(value);
+        }
+
+        /// The extra value of the point.
+        public final ObjectProperty<Object> extraValueProperty() {
+            return extraValue;
+        }
+
+        /// Returns the node the application set for the point, `null`
+        /// when it set none.
+        public final Node getNode() {
+            return node.get();
+        }
+
+        /// Records a node for the point; the chart does not show it.
+        public final void setNode(Node value) {
+            node.set(value);
+        }
+
+        /// The node the application set for the point.
+        public final ObjectProperty<Node> nodeProperty() {
+            return node;
+        }
+
+        @Override
+        public String toString() {
+            return "Data[" + getXValue() + "," + getYValue() + "," + getExtraValue() + "]";
+        }
+    }
+
+    /// A named run of data points.
+    public static final class Series<X, Y> {
+
+        private final StringProperty name = new SimpleStringProperty(this, "name");
+        private final ObjectProperty<Node> node = new SimpleObjectProperty<Node>(this, "node");
+        private final ObjectProperty<ObservableList<Data<X, Y>>> data =
+                new SimpleObjectProperty<ObservableList<Data<X, Y>>>(this, "data");
+        final ReadOnlyObjectWrapper<XYChart<X, Y>> chart = new ReadOnlyObjectWrapper<XYChart<X, Y>>(this, "chart");
+
+        private final ListWatch<Data<X, Y>> watch = new ListWatch<Data<X, Y>>() {
+            @Override
+            void added(Data<X, Y> item) {
+                if (item != null) {
+                    item.series = Series.this;
+                }
+            }
+
+            @Override
+            void removed(Data<X, Y> item) {
+                if (item != null && item.series == Series.this) {
+                    item.series = null;
+                }
+            }
+
+            @Override
+            void changed() {
+                repaint();
+            }
+        };
+
+        /// Creates an empty series.
+        public Series() {
+            this(FXCollections.<Data<X, Y>>observableArrayList());
+        }
+
+        /// Creates a series of the given points.
+        public Series(ObservableList<Data<X, Y>> data) {
+            InvalidationListener relist = new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    watch.watch(Series.this.data.get());
+                }
+            };
+            this.data.addListener(relist);
+            name.addListener(new InvalidationListener() {
+                @Override
+                public void invalidated(Observable observable) {
+                    repaint();
+                }
+            });
+            this.data.set(data);
+        }
+
+        /// Creates a named series of the given points.
+        public Series(String name, ObservableList<Data<X, Y>> data) {
+            this(data);
+            setName(name);
+        }
+
+        void repaint() {
+            XYChart<X, Y> owner = chart.get();
+            if (owner != null) {
+                owner.cn1Repaint();
+            }
+        }
+
+        /// Returns the chart the series is in, `null` when in none.
+        public final XYChart<X, Y> getChart() {
+            return chart.get();
+        }
+
+        /// The chart the series is in.
+        public final ReadOnlyObjectProperty<XYChart<X, Y>> chartProperty() {
+            return chart.getReadOnlyProperty();
+        }
+
+        /// Returns the name the legend shows.
+        public final String getName() {
+            return name.get();
+        }
+
+        /// Sets the name the legend shows.
+        public final void setName(String value) {
+            name.set(value);
+        }
+
+        /// The name the legend shows.
+        public final StringProperty nameProperty() {
+            return name;
+        }
+
+        /// Returns the node the application set for the series, `null`
+        /// when it set none.
+        public final Node getNode() {
+            return node.get();
+        }
+
+        /// Records a node for the series; the chart does not show it.
+        public final void setNode(Node value) {
+            node.set(value);
+        }
+
+        /// The node the application set for the series.
+        public final ObjectProperty<Node> nodeProperty() {
+            return node;
+        }
+
+        /// Returns the points of the series.
+        public final ObservableList<Data<X, Y>> getData() {
+            return data.get();
+        }
+
+        /// Sets the list the series takes its points from.
+        public final void setData(ObservableList<Data<X, Y>> value) {
+            data.set(value);
+        }
+
+        /// The list the series takes its points from.
+        public final ObjectProperty<ObservableList<Data<X, Y>>> dataProperty() {
+            return data;
+        }
+
+        @Override
+        public String toString() {
+            return "Series[" + getName() + "]";
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/chart/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/chart/package-info.java
new file mode 100644
index 00000000000..97c9e9a905d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/chart/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Charts: bars, lines, areas, scattered points and pies.
+///
+/// Each chart is one region that draws all of itself, so the nodes
+/// JavaFX builds for bars, symbols, slices and legend entries do not
+/// exist here and a style sheet cannot restyle them; [javafx.scene.chart.Chart]
+/// lists what follows from that.
+package javafx.scene.chart;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Accordion.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Accordion.java
new file mode 100644
index 00000000000..25ba0902acf
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Accordion.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.List;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.VBox;
+
+/// A column of [TitledPane]s of which at most one is open.
+///
+/// Opening a panel closes the one that was open, and
+/// [#expandedPaneProperty()] names the open one or is `null`. The open
+/// panel takes the height the others leave. A panel is closed as it is
+/// added unless it is the one the accordion was told to expand.
+public class Accordion extends Control {
+
+    private final ObservableList<TitledPane> panes = FXCollections.observableArrayList();
+    private final ObjectProperty<TitledPane> expandedPane = new SimpleObjectProperty<TitledPane>(this,
+            "expandedPane");
+    private final VBox column = new VBox();
+    private final ChangeListener<Boolean> opened = new ChangeListener<Boolean>() {
+        @Override
+        public void changed(ObservableValue<? extends Boolean> observable, Boolean was, Boolean now) {
+            for (int i = 0; i < panes.size(); i++) {
+                TitledPane p = panes.get(i);
+                if (p.expandedProperty() == observable) {
+                    if (now.booleanValue()) {
+                        expandedPane.set(p);
+                    } else if (expandedPane.get() == p) {
+                        expandedPane.set(null);
+                    }
+                }
+            }
+        }
+    };
+
+    /// Creates an accordion without panels.
+    public Accordion() {
+        this((TitledPane[]) null);
+    }
+
+    /// Creates an accordion of panels.
+    public Accordion(TitledPane... titledPanes) {
+        getStyleClass().add("accordion");
+        setFocusTraversable(false);
+        panes.addListener((ListChangeListener<TitledPane>) change -> {
+            while (change.next()) {
+                List<? extends TitledPane> gone = change.getRemoved();
+                for (int i = 0; i < gone.size(); i++) {
+                    gone.get(i).expandedProperty().removeListener(opened);
+                    if (expandedPane.get() == gone.get(i)) {
+                        expandedPane.set(null);
+                    }
+                }
+                List<? extends TitledPane> come = change.getAddedSubList();
+                for (int i = 0; i < come.size(); i++) {
+                    TitledPane p = come.get(i);
+                    // As in JavaFX, a panel is open only when it is the one
+                    // the accordion was told to expand.
+                    p.setExpanded(p == expandedPane.get());
+                    p.expandedProperty().addListener(opened);
+                }
+            }
+            column.getChildren().setAll(panes);
+            one();
+        });
+        expandedPane.addListener((observable, was, now) -> one());
+        cn1MadeOf(column);
+        if (titledPanes != null) {
+            panes.addAll(titledPanes);
+        }
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    /// Leaves only the expanded panel open and gives it the spare height.
+    private void one() {
+        TitledPane open = expandedPane.get();
+        for (int i = 0; i < panes.size(); i++) {
+            TitledPane p = panes.get(i);
+            if (p != open && p.isExpanded()) {
+                p.setExpanded(false);
+            }
+            VBox.setVgrow(p, p == open ? Priority.ALWAYS : Priority.NEVER);
+        }
+        if (open != null && !open.isExpanded()) {
+            open.setExpanded(true);
+        }
+        requestLayout();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    /// Returns the panels, from the top.
+    public final ObservableList<TitledPane> getPanes() {
+        return panes;
+    }
+
+    /// Returns the open panel, or `null` when all are closed.
+    public final TitledPane getExpandedPane() {
+        return expandedPane.get();
+    }
+
+    /// Opens a panel and closes the others; `null` closes them all.
+    public final void setExpandedPane(TitledPane value) {
+        expandedPane.set(value);
+    }
+
+    /// The open panel.
+    public final ObjectProperty<TitledPane> expandedPaneProperty() {
+        return expandedPane;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Alert.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Alert.java
new file mode 100644
index 00000000000..feee68948ab
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Alert.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.NamedArg;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ObservableList;
+
+/// A dialog with a message and the buttons its kind calls for; it answers
+/// with the [ButtonType] of the button the user chose.
+///
+/// The kind sets the title, the header text and the buttons: OK for an
+/// information, a warning and an error, OK and Cancel for a confirmation,
+/// none for [AlertType#NONE]. Buttons given to the constructor, or put in
+/// [#getButtonTypes()], replace those of the kind and stay when the kind
+/// changes. The titles are English, and the icon JavaFX shows for each
+/// kind is not drawn.
+public class Alert extends Dialog<ButtonType> {
+
+    /// The kind of an alert.
+    public enum AlertType {
+
+        /// No title, header or buttons of its own.
+        NONE,
+
+        /// Tells the user something.
+        INFORMATION,
+
+        /// Warns the user.
+        WARNING,
+
+        /// Asks the user to confirm.
+        CONFIRMATION,
+
+        /// Reports an error.
+        ERROR
+    }
+
+    private final ObjectProperty<AlertType> alertType = new SimpleObjectProperty<AlertType>(this, "alertType");
+    private ButtonType[] installed;
+
+    /// Creates an alert of a kind.
+    public Alert(@NamedArg("alertType") AlertType alertType) {
+        this(alertType, "");
+    }
+
+    /// Creates an alert of a kind with a content text and buttons. With
+    /// no buttons it gets those of the kind.
+    public Alert(@NamedArg("alertType") AlertType alertType, @NamedArg("contentText") String contentText,
+            @NamedArg("buttonTypes") ButtonType... buttons) {
+        DialogPane pane = getDialogPane();
+        pane.setContentText(contentText);
+        pane.getStyleClass().add("alert");
+        this.alertType.addListener(new ChangeListener<AlertType>() {
+            @Override
+            public void changed(ObservableValue<? extends AlertType> observable, AlertType oldValue,
+                    AlertType newValue) {
+                apply(newValue);
+            }
+        });
+        this.alertType.set(alertType);
+        if (buttons != null && buttons.length > 0) {
+            pane.getButtonTypes().setAll(buttons);
+        }
+    }
+
+    private void apply(AlertType type) {
+        String title = null;
+        ButtonType[] defaults = new ButtonType[0];
+        if (type == AlertType.INFORMATION) {
+            title = "Message";
+            defaults = new ButtonType[] {ButtonType.OK};
+        } else if (type == AlertType.WARNING) {
+            title = "Warning";
+            defaults = new ButtonType[] {ButtonType.OK};
+        } else if (type == AlertType.ERROR) {
+            title = "Error";
+            defaults = new ButtonType[] {ButtonType.OK};
+        } else if (type == AlertType.CONFIRMATION) {
+            title = "Confirmation";
+            defaults = new ButtonType[] {ButtonType.OK, ButtonType.CANCEL};
+        }
+        setTitle(title == null ? "" : title);
+        setHeaderText(title);
+        // Buttons the application chose stay; those of the last kind go.
+        ObservableList<ButtonType> shown = getDialogPane().getButtonTypes();
+        if (installed == null || same(shown, installed)) {
+            shown.setAll(defaults);
+            installed = defaults;
+        }
+    }
+
+    private static boolean same(ObservableList<ButtonType> shown, ButtonType[] types) {
+        if (shown.size() != types.length) {
+            return false;
+        }
+        for (int i = 0; i < types.length; i++) {
+            if (shown.get(i) != types[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Returns the kind of the alert.
+    public final AlertType getAlertType() {
+        return alertType.get();
+    }
+
+    /// Sets the kind of the alert.
+    public final void setAlertType(AlertType alertType) {
+        this.alertType.set(alertType);
+    }
+
+    /// The kind of the alert.
+    public final ObjectProperty<AlertType> alertTypeProperty() {
+        return alertType;
+    }
+
+    /// Returns the button types of the alert: those of its pane.
+    public final ObservableList<ButtonType> getButtonTypes() {
+        return getDialogPane().getButtonTypes();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Button.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Button.java
new file mode 100644
index 00000000000..a1e10ee4166
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Button.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.event.ActionEvent;
+import javafx.scene.Node;
+
+/// A push button, shown as a Codename One `Button`.
+///
+/// A button with a background or a border of its own, set by the
+/// application or by a style sheet, is drawn by those alone: the native
+/// button under them gives up the background and the border of the
+/// theme and keeps its text. Without either it looks as the theme makes
+/// a button look -- unless a rule or an inline style redefines one of the
+/// standard theme's colours, `-fx-base` say, for the button or anything
+/// above it: the button is then drawn as the standard theme draws one,
+/// in those colours.
+///
+/// The default and cancel flags are recorded; Enter and Escape are not
+/// routed to such a button by this layer.
+public class Button extends ButtonBase {
+
+    private final BooleanProperty defaultButton = new SimpleBooleanProperty(this, "defaultButton", false);
+    private final BooleanProperty cancelButton = new SimpleBooleanProperty(this, "cancelButton", false);
+
+    {
+        // ":default" and ":cancel" are how a style sheet marks the two.
+        defaultButton.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                pseudoClassStateChanged(javafx.css.PseudoClass.getPseudoClass("default"), defaultButton.get());
+            }
+        });
+        cancelButton.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                pseudoClassStateChanged(javafx.css.PseudoClass.getPseudoClass("cancel"), cancelButton.get());
+            }
+        });
+        // The text of a button is centred unless the application says otherwise.
+        setAlignment(javafx.geometry.Pos.CENTER);
+    }
+
+    @Override
+    boolean cn1OwnsChrome() {
+        return true;
+    }
+
+    @Override
+    public String cn1ThemedStyle() {
+        return cn1StandardLook(false, isDefaultButton());
+    }
+
+    public Button() {
+        getStyleClass().add("button");
+    }
+
+    /// Creates a button with text.
+    public Button(String text) {
+        super(text);
+        getStyleClass().add("button");
+    }
+
+    /// Creates a button with text and a graphic.
+    public Button(String text, Node graphic) {
+        super(text, graphic);
+        getStyleClass().add("button");
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.Button b = new com.codename1.ui.Button();
+        b.addActionListener(cn1ActionBridge());
+        return b;
+    }
+
+    @Override
+    public void fire() {
+        if (!isDisabled()) {
+            fireEvent(new ActionEvent(this, this));
+        }
+    }
+
+    /// Returns whether this is the default button of its window.
+    public final boolean isDefaultButton() {
+        return defaultButton.get();
+    }
+
+    /// Sets whether this is the default button of its window.
+    public final void setDefaultButton(boolean value) {
+        defaultButton.set(value);
+    }
+
+    /// Whether this is the default button of its window.
+    public final BooleanProperty defaultButtonProperty() {
+        return defaultButton;
+    }
+
+    /// Returns whether this is the cancel button of its window.
+    public final boolean isCancelButton() {
+        return cancelButton.get();
+    }
+
+    /// Sets whether this is the cancel button of its window.
+    public final void setCancelButton(boolean value) {
+        cancelButton.set(value);
+    }
+
+    /// Whether this is the cancel button of its window.
+    public final BooleanProperty cancelButtonProperty() {
+        return cancelButton;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonBar.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonBar.java
new file mode 100644
index 00000000000..2c8020d6876
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonBar.java
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+
+/// A row of buttons, and the holder of [ButtonData], which says what a
+/// button is for.
+///
+/// The buttons are laid out in one row with a gap of ten between them.
+/// Those that are to be of a uniform size, as all are unless
+/// [#setButtonUniformSize(Node, boolean)] says otherwise, are given the
+/// width of the widest of them and at least `buttonMinWidth`.
+///
+/// JavaFX orders the buttons by their [ButtonData] in the way of the
+/// desktop it runs on. A device is none of those desktops, so the order
+/// here is [#BUTTON_ORDER_NONE] unless the application sets one: the
+/// buttons keep the order of the list and are aligned to the right. With
+/// an order set, the buttons are sorted by where the letter of their kind
+/// stands in it, a button without a kind counting as
+/// [ButtonData#OTHER]; the kinds before the first underscore of the order
+/// are placed on the left and all others on the right, and a kind the
+/// order does not name is placed last. The gaps an order asks for with
+/// `+` and `_` are not made: every gap is the same.
+///
+/// A `DialogPane` does not use this control; it shows its buttons in the
+/// order they were added.
+public class ButtonBar extends Control {
+
+    /// The order of buttons on Windows.
+    public static final String BUTTON_ORDER_WINDOWS = "L_E+U+FBXI_YNOCAH_R";
+
+    /// The order of buttons on macOS.
+    public static final String BUTTON_ORDER_MAC_OS = "L_HE+U+FBIX_NCYOA_R";
+
+    /// The order of buttons on Linux.
+    public static final String BUTTON_ORDER_LINUX = "L_HE+UNYACBXIO_R";
+
+    /// No order: the buttons stay as the list has them.
+    public static final String BUTTON_ORDER_NONE = "";
+
+    private static final String DATA = "javafx.scene.control.ButtonBar.ButtonData";
+    private static final String UNIFORM = "javafx.scene.control.ButtonBar.independentSize";
+    private static final double GAP = 10;
+
+    private final ObservableList<Node> buttons = FXCollections.observableArrayList();
+    private final StringProperty buttonOrder = new SimpleStringProperty(this, "buttonOrder", BUTTON_ORDER_NONE);
+    private final DoubleProperty buttonMinWidth = new SimpleDoubleProperty(this, "buttonMinWidth", 0);
+
+    /// Creates a button bar that keeps the order of its list.
+    public ButtonBar() {
+        this(null);
+    }
+
+    /// Creates a button bar with a button order; `null` for none.
+    public ButtonBar(String buttonOrder) {
+        getStyleClass().add("button-bar");
+        setFocusTraversable(false);
+        InvalidationListener relayout = new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                cn1Children().setAll(buttons);
+                requestLayout();
+            }
+        };
+        buttons.addListener(relayout);
+        this.buttonOrder.addListener(relayout);
+        this.buttonMinWidth.addListener(relayout);
+        if (buttonOrder != null) {
+            this.buttonOrder.set(buttonOrder);
+        }
+    }
+
+    /// Sets what a button is for; `null` takes the kind away.
+    public static void setButtonData(Node button, ButtonData buttonData) {
+        if (buttonData == null) {
+            button.getProperties().remove(DATA);
+        } else {
+            button.getProperties().put(DATA, buttonData);
+        }
+    }
+
+    /// Returns what a button is for, `null` when nothing was set.
+    public static ButtonData getButtonData(Node button) {
+        Object data = button.hasProperties() ? button.getProperties().get(DATA) : null;
+        return data instanceof ButtonData ? (ButtonData) data : null;
+    }
+
+    /// Sets whether a button takes the width the bar gives all its
+    /// uniform buttons.
+    public static void setButtonUniformSize(Node button, boolean uniformSize) {
+        if (uniformSize) {
+            button.getProperties().remove(UNIFORM);
+        } else {
+            button.getProperties().put(UNIFORM, Boolean.TRUE);
+        }
+    }
+
+    /// Returns whether a button takes the uniform width of its bar.
+    public static boolean isButtonUniformSize(Node button) {
+        return !button.hasProperties() || !button.getProperties().containsKey(UNIFORM);
+    }
+
+    /// Returns the buttons of the bar.
+    public final ObservableList<Node> getButtons() {
+        return buttons;
+    }
+
+    /// Returns the order the kinds of button are placed in.
+    public final String getButtonOrder() {
+        return buttonOrder.get();
+    }
+
+    /// Sets the order the kinds of button are placed in.
+    public final void setButtonOrder(String value) {
+        buttonOrder.set(value);
+    }
+
+    /// The order the kinds of button are placed in.
+    public final StringProperty buttonOrderProperty() {
+        return buttonOrder;
+    }
+
+    /// Returns the least width of a uniform button.
+    public final double getButtonMinWidth() {
+        return buttonMinWidth.get();
+    }
+
+    /// Sets the least width of a uniform button.
+    public final void setButtonMinWidth(double value) {
+        buttonMinWidth.set(value);
+    }
+
+    /// The least width of a uniform button.
+    public final DoubleProperty buttonMinWidthProperty() {
+        return buttonMinWidth;
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    private static int rank(Node button, String order) {
+        ButtonData data = getButtonData(button);
+        String code = (data == null ? ButtonData.OTHER : data).getTypeCode();
+        int at = order.indexOf(code);
+        return at < 0 ? order.length() : at;
+    }
+
+    /// The managed buttons in the order they are placed in.
+    private List<Node> ordered() {
+        String order = getButtonOrder();
+        List<Node> out = new ArrayList<Node>();
+        for (int i = 0; i < buttons.size(); i++) {
+            Node b = buttons.get(i);
+            if (b == null || !b.isManaged()) {
+                continue;
+            }
+            int at = out.size();
+            if (order != null && order.length() > 0) {
+                int rank = rank(b, order);
+                while (at > 0 && rank(out.get(at - 1), order) > rank) {
+                    at--;
+                }
+            }
+            out.add(at, b);
+        }
+        return out;
+    }
+
+    /// How many of the ordered buttons are placed on the left.
+    private int leftCount(List<Node> all) {
+        String order = getButtonOrder();
+        int split = order == null ? -1 : order.indexOf('_');
+        int n = 0;
+        if (split > 0) {
+            while (n < all.size() && rank(all.get(n), order) < split) {
+                n++;
+            }
+        }
+        return n;
+    }
+
+    private double uniformWidth(List<Node> all) {
+        double w = Math.max(0, getButtonMinWidth());
+        for (int i = 0; i < all.size(); i++) {
+            if (isButtonUniformSize(all.get(i))) {
+                w = Math.max(w, all.get(i).prefWidth(-1));
+            }
+        }
+        return w;
+    }
+
+    private static double width(Node button, double uniform) {
+        return isButtonUniformSize(button) ? uniform : button.prefWidth(-1);
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        List<Node> all = ordered();
+        double uniform = uniformWidth(all);
+        double w = 0;
+        for (int i = 0; i < all.size(); i++) {
+            w += (i > 0 ? GAP : 0) + width(all.get(i), uniform);
+        }
+        Insets in = getInsets();
+        return in.getLeft() + w + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        double h = 0;
+        for (int i = 0; i < buttons.size(); i++) {
+            Node b = buttons.get(i);
+            if (b != null && b.isManaged()) {
+                h = Math.max(h, b.prefHeight(-1));
+            }
+        }
+        Insets in = getInsets();
+        return in.getTop() + h + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return computePrefWidth(height);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return computePrefHeight(width);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> all = ordered();
+        double uniform = uniformWidth(all);
+        Insets in = getInsets();
+        double top = in.getTop();
+        double room = Math.max(0, getHeight() - top - in.getBottom());
+        int left = leftCount(all);
+        double x = in.getLeft();
+        for (int i = 0; i < left; i++) {
+            Node b = all.get(i);
+            double w = width(b, uniform);
+            double h = Math.min(room, b.prefHeight(-1));
+            b.resizeRelocate(x, top + (room - h) / 2, w, h);
+            x += w + GAP;
+        }
+        double rest = 0;
+        for (int i = left; i < all.size(); i++) {
+            rest += (i > left ? GAP : 0) + width(all.get(i), uniform);
+        }
+        // The right group never runs under the left one.
+        x = Math.max(x, getWidth() - in.getRight() - rest);
+        for (int i = left; i < all.size(); i++) {
+            Node b = all.get(i);
+            double w = width(b, uniform);
+            double h = Math.min(room, b.prefHeight(-1));
+            b.resizeRelocate(x, top + (room - h) / 2, w, h);
+            x += w + GAP;
+        }
+    }
+
+    /// What a button of a dialog is for.
+    public enum ButtonData {
+
+        /// A button placed on the left.
+        LEFT("L", false, false),
+
+        /// A button placed on the right.
+        RIGHT("R", false, false),
+
+        /// A help button.
+        HELP("H", false, false),
+
+        /// A second help button.
+        HELP_2("E", false, false),
+
+        /// The button that answers yes; a default button.
+        YES("Y", false, true),
+
+        /// The button that answers no; a cancel button.
+        NO("N", true, false),
+
+        /// The button that goes on to the next step; a default button.
+        NEXT_FORWARD("X", false, true),
+
+        /// The button that goes back a step.
+        BACK_PREVIOUS("B", false, false),
+
+        /// The button that finishes; a default button.
+        FINISH("I", false, true),
+
+        /// The button that applies.
+        APPLY("A", false, false),
+
+        /// The button that cancels or closes; a cancel button.
+        CANCEL_CLOSE("C", true, false),
+
+        /// The button that accepts; a default button.
+        OK_DONE("O", false, true),
+
+        /// A button with no meaning of its own.
+        OTHER("U", false, false),
+
+        /// A large gap between buttons.
+        BIG_GAP("+", false, false),
+
+        /// A small gap between buttons.
+        SMALL_GAP("_", false, false);
+
+        private final String typeCode;
+        private final boolean cancelButton;
+        private final boolean defaultButton;
+
+        ButtonData(String type, boolean cancelButton, boolean defaultButton) {
+            this.typeCode = type;
+            this.cancelButton = cancelButton;
+            this.defaultButton = defaultButton;
+        }
+
+        /// Returns the letter that stands for this kind in a button order.
+        public String getTypeCode() {
+            return typeCode;
+        }
+
+        /// Returns whether a button of this kind cancels its dialog.
+        public final boolean isCancelButton() {
+            return cancelButton;
+        }
+
+        /// Returns whether a button of this kind is the default button.
+        public final boolean isDefaultButton() {
+            return defaultButton;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonBase.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonBase.java
new file mode 100644
index 00000000000..914c9e520c1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonBase.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.ui.Component;
+import com.codename1.ui.plaf.Style;
+import com.codename1.ui.events.ActionListener;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.css.PseudoClass;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.Node;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.Border;
+
+/// The base of the controls that are pressed: buttons, check boxes,
+/// toggles, hyperlinks.
+///
+/// The native component's own action, however the user triggered it,
+/// calls [#fire()], which a subclass overrides to change its state and
+/// then fire an `ActionEvent`.
+public abstract class ButtonBase extends Labeled {
+
+    private static final PseudoClass ARMED = PseudoClass.getPseudoClass("armed");
+
+    private final ReadOnlyBooleanWrapper armed = new ReadOnlyBooleanWrapper(this, "armed", false);
+    private boolean ownChrome;
+    private boolean ownPadding;
+
+    {
+        InvalidationListener chrome = new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                if (cn1OwnsChrome()) {
+                    cn1Invalidated(Dirty.NATIVE);
+                }
+            }
+        };
+        backgroundProperty().addListener(chrome);
+        borderProperty().addListener(chrome);
+        paddingProperty().addListener(chrome);
+    }
+
+    /// Whether a background or a border of this button's own replaces the
+    /// look the native theme gives it: so for a push button and a toggle
+    /// button, whose whole look that is, and not for a check box or a
+    /// link.
+    boolean cn1OwnsChrome() {
+        return false;
+    }
+
+    private boolean drawsItself() {
+        Background b = getBackground();
+        if (b != null && !b.getFills().isEmpty()) {
+            return true;
+        }
+        Border border = getBorder();
+        return border != null && !border.getStrokes().isEmpty();
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        if (!cn1OwnsChrome()) {
+            super.cn1SyncNative();
+            return;
+        }
+        Component c = cn1NativeIfCreated();
+        boolean own = drawsItself();
+        // A button that draws itself and has a padding of its own is
+        // that padding around its text, as in JavaFX; the padding the
+        // theme gives its button would come on top of it.
+        javafx.geometry.Insets pad = getPadding();
+        boolean bare = own && getGraphic() == null && pad != null
+                && pad.getTop() + pad.getRight() + pad.getBottom() + pad.getLeft() > 0;
+        if (c != null && ((ownChrome && !own) || (ownPadding && !bare))) {
+            // Setting the UIID again brings the styles of the theme back.
+            c.setUIID(c.getUIID());
+        }
+        ownChrome = own;
+        ownPadding = bare;
+        super.cn1SyncNative();
+        if (c != null && own) {
+            Style style = com.codename1.fxcompat.runtime.PeerPaint.allStyles(c);
+            style.setBgTransparency(0);
+            style.setBorder(com.codename1.ui.plaf.Border.createEmpty());
+            if (bare) {
+                style.setPaddingUnit(Style.UNIT_TYPE_PIXELS);
+                style.setPadding(0, 0, 0, 0);
+            }
+        }
+    }
+
+    /// The look of the standard theme's button as a style, in the theme's
+    /// own colour names so that it follows whatever redefines them.
+    ///
+    /// The button is four fills one inside the other -- a highlight
+    /// below, the outer border, the inner border and the body, a gradient
+    /// of the button's colour -- and its text is light or dark by how
+    /// bright that colour is. Hovered, pressed, selected and default
+    /// buttons differ in the colour alone; a focused one has the focus
+    /// colour for its border and a faint ring of it outside.
+    final String cn1StandardLook(boolean selected, boolean byDefault) {
+        String c = "-fx-color";
+        if (selected) {
+            c = "derive(-fx-color, -17%)";
+        } else if (isArmed()) {
+            c = "-fx-pressed-base";
+        } else if (isHover()) {
+            c = "-fx-hover-base";
+        } else if (byDefault) {
+            c = "-fx-default-button";
+        }
+        String body = "linear-gradient(to bottom, derive(" + c + ", 8%), derive(" + c + ", -8%))";
+        String fills;
+        if (isFocused()) {
+            fills = "-fx-background-color: -fx-faint-focus-color, -fx-focus-color, derive(" + c + ", 50%), " + body
+                    + "; -fx-background-insets: -1.4, -0.2, 1, 2; -fx-background-radius: 4, 3, 2, 1;";
+        } else {
+            fills = "-fx-background-color: -fx-shadow-highlight-color, derive(" + c + ", -23%), derive(" + c
+                    + ", 50%), " + body
+                    + "; -fx-background-insets: 0 0 -1 0, 0, 1, 2; -fx-background-radius: 3, 3, 2, 1;";
+        }
+        return fills + " -fx-padding: 0.333333em 0.666667em 0.333333em 0.666667em; -fx-text-fill: ladder(" + c
+                + ", -fx-light-text-color 45%, -fx-dark-text-color 46%, -fx-dark-text-color 59%,"
+                + " -fx-mid-text-color 60%);";
+    }
+
+    /// Creates a button with no text.
+    public ButtonBase() {
+        setMnemonicParsing(true);
+    }
+
+    /// Creates a button with text.
+    public ButtonBase(String text) {
+        super(text);
+        setMnemonicParsing(true);
+    }
+
+    /// Creates a button with text and a graphic.
+    public ButtonBase(String text, Node graphic) {
+        super(text, graphic);
+        setMnemonicParsing(true);
+    }
+
+    /// Returns the listener a subclass adds to its native button: it
+    /// calls [#fire()] unless the control is disabled.
+    protected final ActionListener<com.codename1.ui.events.ActionEvent> cn1ActionBridge() {
+        return new ActionListener<com.codename1.ui.events.ActionEvent>() {
+            @Override
+            public void actionPerformed(com.codename1.ui.events.ActionEvent evt) {
+                if (!isDisabled()) {
+                    fire();
+                }
+            }
+        };
+    }
+
+    /// Returns whether a release now would fire the button.
+    public final boolean isArmed() {
+        return armed.get();
+    }
+
+    /// Whether a release now would fire the button.
+    public final ReadOnlyBooleanProperty armedProperty() {
+        return armed.getReadOnlyProperty();
+    }
+
+    /// Arms the button.
+    public void arm() {
+        if (!armed.get()) {
+            armed.set(true);
+            pseudoClassStateChanged(ARMED, true);
+        }
+    }
+
+    /// Disarms the button.
+    public void disarm() {
+        if (armed.get()) {
+            armed.set(false);
+            pseudoClassStateChanged(ARMED, false);
+        }
+    }
+
+    /// Invokes the button as a press and release would.
+    public abstract void fire();
+
+    /// Sets the handler of the button being invoked.
+    public final void setOnAction(EventHandler<ActionEvent> value) {
+        cn1Events().setSlot(ActionEvent.ACTION, "onAction", value);
+    }
+
+    /// Returns the handler of the button being invoked.
+    public final EventHandler<? super ActionEvent> getOnAction() {
+        return cn1Events().getSlot(ActionEvent.ACTION);
+    }
+
+    /// The handler of the button being invoked.
+    public final ObjectProperty<EventHandler<? super ActionEvent>> onActionProperty() {
+        return cn1Events().slot(ActionEvent.ACTION, "onAction");
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonType.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonType.java
new file mode 100644
index 00000000000..7c91f5350f6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ButtonType.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.NamedArg;
+import javafx.scene.control.ButtonBar.ButtonData;
+
+/// What a button of a dialog says and what it is for. A `DialogPane`
+/// makes one button for each button type it is given, and the type of the
+/// button the user chose is what a dialog answers with.
+///
+/// The texts of the predefined types are English; this layer does not
+/// translate them.
+public final class ButtonType {
+
+    /// An "Apply" button.
+    public static final ButtonType APPLY = new ButtonType("Apply", ButtonData.APPLY);
+
+    /// An "OK" button.
+    public static final ButtonType OK = new ButtonType("OK", ButtonData.OK_DONE);
+
+    /// A "Cancel" button.
+    public static final ButtonType CANCEL = new ButtonType("Cancel", ButtonData.CANCEL_CLOSE);
+
+    /// A "Close" button.
+    public static final ButtonType CLOSE = new ButtonType("Close", ButtonData.CANCEL_CLOSE);
+
+    /// A "Yes" button.
+    public static final ButtonType YES = new ButtonType("Yes", ButtonData.YES);
+
+    /// A "No" button.
+    public static final ButtonType NO = new ButtonType("No", ButtonData.NO);
+
+    /// A "Finish" button.
+    public static final ButtonType FINISH = new ButtonType("Finish", ButtonData.FINISH);
+
+    /// A "Next" button.
+    public static final ButtonType NEXT = new ButtonType("Next", ButtonData.NEXT_FORWARD);
+
+    /// A "Previous" button.
+    public static final ButtonType PREVIOUS = new ButtonType("Previous", ButtonData.BACK_PREVIOUS);
+
+    private final String text;
+    private final ButtonData buttonData;
+
+    /// Creates a button type with a text and no meaning of its own.
+    public ButtonType(@NamedArg("text") String text) {
+        this(text, ButtonData.OTHER);
+    }
+
+    /// Creates a button type with a text and what it is for.
+    public ButtonType(@NamedArg("text") String text, @NamedArg("buttonData") ButtonData buttonData) {
+        this.text = text;
+        this.buttonData = buttonData;
+    }
+
+    /// Returns what a button of this type is for.
+    public final ButtonData getButtonData() {
+        return buttonData;
+    }
+
+    /// Returns the text of a button of this type.
+    public final String getText() {
+        return text;
+    }
+
+    @Override
+    public String toString() {
+        return "ButtonType [text=" + getText() + ", buttonData=" + getButtonData() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Cell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Cell.java
new file mode 100644
index 00000000000..2b37c3ca8b5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Cell.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.CssEngine;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.plaf.Style;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.css.PseudoClass;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+
+/// One visual of a list or table: a labeled control that shows the item
+/// it was last given through [#updateItem(Object, boolean)].
+///
+/// A view creates few cells and reuses them for whatever rows are
+/// visible, so a cell must take everything it shows from the arguments of
+/// `updateItem` and clear it when `empty` is true.
+///
+/// The text is a Codename One `Label`. The graphic is a JavaFX node, a
+/// child of the cell, placed at the leading edge with the text after it;
+/// `ContentDisplay.GRAPHIC_ONLY` hides the text and `TEXT_ONLY` the
+/// graphic, the other values are shown as `LEFT`.
+///
+/// A cell without a text fill of its own is shown in white when what is
+/// behind it is dark, and in the colour of the theme otherwise. What is
+/// behind it is the nearest background up the tree, the cell's own
+/// included, whose last fill is a colour at least half opaque. JavaFX
+/// reaches the same end through the ladder of its default style sheet on
+/// `-fx-control-inner-background`; a view whose style sheet sets that
+/// colour without a background colour to match is not followed.
+///
+/// A selected cell without a background of its own is drawn with a
+/// translucent highlight. The pseudo-class states `empty`, `filled` and
+/// `selected` follow the cell, and `focused` the control.
+///
+/// A cell can be edited: [#startEdit()], [#commitEdit(Object)] and
+/// [#cancelEdit()] move it in and out of the editing state, and a
+/// subclass that edits overrides them to swap what it shows.
+///
+/// Styled through `cn1ApplyStyle` with the `Labeled` and `Region` names
+/// listed in `com.codename1.fxcompat.runtime.StyleTarget`; a cell adds no
+/// names of its own.
+public class Cell<T> extends Labeled {
+
+    private static final PseudoClass SELECTED = PseudoClass.getPseudoClass("selected");
+    private static final PseudoClass EMPTY = PseudoClass.getPseudoClass("empty");
+    private static final PseudoClass FILLED = PseudoClass.getPseudoClass("filled");
+    private static final Color HIGHLIGHT = Color.rgb(0, 150, 201);
+
+    private final ObjectProperty<T> item = new SimpleObjectProperty<T>(this, "item");
+    private final ReadOnlyBooleanWrapper empty = new ReadOnlyBooleanWrapper(this, "empty", true);
+    private final ReadOnlyBooleanWrapper selected = new ReadOnlyBooleanWrapper(this, "selected", false);
+    private final BooleanProperty editable = new SimpleBooleanProperty(this, "editable", true);
+    private final ReadOnlyBooleanWrapper editing = new ReadOnlyBooleanWrapper(this, "editing", false);
+    private int basePadding = -1;
+    private int themeText = -1;
+
+    /// Creates an empty cell.
+    public Cell() {
+        setText(null);
+        setFocusTraversable(false);
+        getStyleClass().add("cell");
+        pseudoClassStateChanged(EMPTY, true);
+        graphicProperty().addListener(new ChangeListener<Node>() {
+            @Override
+            public void changed(ObservableValue<? extends Node> observable, Node oldValue, Node newValue) {
+                if (oldValue != null) {
+                    cn1Children().remove(oldValue);
+                }
+                if (newValue != null && !cn1Children().contains(newValue)) {
+                    cn1Children().add(newValue);
+                }
+            }
+        });
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return new com.codename1.ui.Label();
+    }
+
+    @Override
+    boolean ownsGraphic() {
+        return true;
+    }
+
+    /// The room kept free before the graphic and the text, in logical
+    /// pixels: none, but a cell of a tree keeps its indent and its arrow
+    /// there.
+    double leading() {
+        return 0;
+    }
+
+    private Node shownGraphic() {
+        Node g = getGraphic();
+        return g == null || getContentDisplay() == ContentDisplay.TEXT_ONLY ? null : g;
+    }
+
+    private double graphicWidth() {
+        Node g = shownGraphic();
+        return g == null ? 0 : g.prefWidth(-1) + getGraphicTextGap();
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        Component before = cn1NativeIfCreated();
+        if (before != null && themeText < 0) {
+            themeText = before.getUnselectedStyle().getFgColor() & 0xffffff;
+        }
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c == null) {
+            return;
+        }
+        if (textFillProperty().get() == null && themeText >= 0) {
+            com.codename1.fxcompat.runtime.PeerPaint.allStyles(c).setFgColor(
+                    isSelected() && getBackground() == null ? selectedText() : (onDark() ? 0xffffff : themeText));
+        }
+        if (basePadding < 0) {
+            basePadding = c.getStyle().getPaddingLeftNoRTL();
+        }
+        // The text starts after the graphic, which is a node of its own.
+        Style style = com.codename1.fxcompat.runtime.PeerPaint.allStyles(c);
+        style.setPaddingUnitLeft(Style.UNIT_TYPE_PIXELS);
+        style.setPaddingLeft(basePadding + Units.toPixels(leading() + graphicWidth()));
+    }
+
+    /// The bar behind a selected cell: the theme's `-fx-selection-bar`
+    /// where the cell stands, which a style sheet recolours through
+    /// `-fx-accent`.
+    private Color selectionBar() {
+        Color c = com.codename1.fxcompat.runtime.CssEngine.themeColor(this, "-fx-selection-bar");
+        return c == null ? HIGHLIGHT : c;
+    }
+
+    /// White on a bar that reads as dark, the theme's text otherwise.
+    private int selectedText() {
+        Color c = selectionBar();
+        return 0.3 * c.getRed() + 0.59 * c.getGreen() + 0.11 * c.getBlue() < 0.455 ? 0xffffff
+                : (themeText >= 0 ? themeText : 0);
+    }
+
+    /// Whether the nearest background behind the text is a dark colour.
+    private boolean onDark() {
+        Node at = this;
+        while (at != null) {
+            if (at instanceof Region) {
+                Background b = ((Region) at).getBackground();
+                List<BackgroundFill> fills = b == null ? null : b.getFills();
+                if (fills != null && !fills.isEmpty()) {
+                    Paint p = fills.get(fills.size() - 1).getFill();
+                    if (p instanceof Color && ((Color) p).getOpacity() >= 0.5) {
+                        Color color = (Color) p;
+                        return 0.2126 * color.getRed() + 0.7152 * color.getGreen() + 0.0722 * color.getBlue() < 0.4;
+                    }
+                }
+            }
+            at = at.getParent();
+        }
+        return false;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        Node g = getGraphic();
+        if (g != null) {
+            boolean show = shownGraphic() != null;
+            g.setVisible(show);
+            if (show) {
+                Insets in = getInsets();
+                double w = g.prefWidth(-1);
+                double h = g.prefHeight(-1);
+                double space = getHeight() - in.getTop() - in.getBottom();
+                if (g.isResizable()) {
+                    g.resize(w, h);
+                }
+                g.relocate(in.getLeft() + leading() + Units.toLogical(Math.max(0, basePadding))
+                        - g.getLayoutBounds().getMinX(),
+                        in.getTop() + (space - h) / 2 - g.getLayoutBounds().getMinY());
+            }
+        }
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        double h = super.computePrefHeight(width);
+        Node g = shownGraphic();
+        if (g != null) {
+            Insets in = getInsets();
+            h = Math.max(h, in.getTop() + g.prefHeight(-1) + in.getBottom());
+        }
+        return h;
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return 0;
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        super.cn1Paint(renderer);
+        if (isSelected() && getBackground() == null) {
+            renderer.fillRect(0, 0, getWidth(), getHeight(), selectionBar());
+        } else if (getBackground() == null && striped()) {
+            // The standard theme shades every second row of a list and of
+            // a table. It is painted, not given as a background, so that a
+            // cell an application colours is still told from one it left.
+            Color alt = CssEngine.themeColor(this, "-fx-control-inner-background-alt");
+            if (alt != null) {
+                renderer.fillRect(0, 0, getWidth(), getHeight(), alt);
+            }
+        }
+    }
+
+    /// Whether this cell is on a row the standard theme shades.
+    boolean striped() {
+        return false;
+    }
+
+    /// The item this cell shows.
+    public final ObjectProperty<T> itemProperty() {
+        return item;
+    }
+
+    /// Sets the item; a view does, through [#updateItem(Object, boolean)].
+    public final void setItem(T value) {
+        item.set(value);
+    }
+
+    /// Returns the item this cell shows, `null` when empty.
+    public final T getItem() {
+        return item.get();
+    }
+
+    /// Whether this cell shows no item.
+    public final ReadOnlyBooleanProperty emptyProperty() {
+        return empty.getReadOnlyProperty();
+    }
+
+    /// Returns whether this cell shows no item.
+    public final boolean isEmpty() {
+        return empty.get();
+    }
+
+    /// Whether the row of this cell is selected.
+    public final ReadOnlyBooleanProperty selectedProperty() {
+        return selected.getReadOnlyProperty();
+    }
+
+    /// Returns whether the row of this cell is selected.
+    public final boolean isSelected() {
+        return selected.get();
+    }
+
+    /// Whether this cell may be edited; true unless the application says
+    /// otherwise.
+    public final BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Sets whether this cell may be edited.
+    public final void setEditable(boolean value) {
+        editable.set(value);
+    }
+
+    /// Returns whether this cell may be edited.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// Whether this cell is being edited.
+    public final ReadOnlyBooleanProperty editingProperty() {
+        return editing.getReadOnlyProperty();
+    }
+
+    /// Returns whether this cell is being edited.
+    public final boolean isEditing() {
+        return editing.get();
+    }
+
+    /// Starts editing, if the cell is editable, shows an item and is not
+    /// edited already. An override calls the super implementation and
+    /// then asks [#isEditing()] whether the edit began.
+    public void startEdit() {
+        if (isEditable() && !isEditing() && !isEmpty()) {
+            editing.set(true);
+        }
+    }
+
+    /// Ends the edit without a new value.
+    public void cancelEdit() {
+        if (isEditing()) {
+            editing.set(false);
+        }
+    }
+
+    /// Ends the edit with a new value. The cell does not keep the value;
+    /// the view it belongs to tells whoever owns the data.
+    public void commitEdit(T newValue) {
+        if (isEditing()) {
+            editing.set(false);
+        }
+    }
+
+    /// Gives the cell another item to show. An override calls the super
+    /// implementation first, then sets the text and the graphic, or
+    /// clears both when `empty` is true.
+    protected void updateItem(T item, boolean empty) {
+        setItem(item);
+        if (this.empty.get() != empty) {
+            this.empty.set(empty);
+            pseudoClassStateChanged(EMPTY, empty);
+            pseudoClassStateChanged(FILLED, !empty);
+        }
+        if (empty && isSelected()) {
+            updateSelected(false);
+        }
+    }
+
+    /// Tells the cell whether its row is selected. An empty cell is
+    /// never selected.
+    public void updateSelected(boolean selected) {
+        if (selected && isEmpty()) {
+            return;
+        }
+        if (this.selected.get() != selected) {
+            this.selected.set(selected);
+            pseudoClassStateChanged(SELECTED, selected);
+            // The text changes colour with the bar behind it.
+            cn1Invalidated(com.codename1.fxcompat.runtime.Dirty.NATIVE);
+            cn1Repaint();
+        }
+    }
+
+    /// Returns whether two items differ enough for the cell to be
+    /// updated; compares with `equals`.
+    protected boolean isItemChanged(T oldItem, T newItem) {
+        return oldItem != null ? !oldItem.equals(newItem) : newItem != null;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/CheckBox.java b/maven/javafx-compat/src/main/java/javafx/scene/control/CheckBox.java
new file mode 100644
index 00000000000..c911066be67
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/CheckBox.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.ui.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+import com.codename1.ui.plaf.DefaultLookAndFeel;
+import com.codename1.ui.plaf.LookAndFeel;
+import com.codename1.ui.plaf.Style;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.css.PseudoClass;
+import javafx.event.ActionEvent;
+
+/// A box that is checked or not, shown as a Codename One `CheckBox`.
+///
+/// With `allowIndeterminate` a press cycles unchecked, indeterminate,
+/// checked; without it a press flips checked and clears indeterminate.
+/// The native check box has no third look, so this one adds it: an
+/// indeterminate box is the empty box of the theme with a dash in it.
+/// The pseudo-classes `selected`, `indeterminate` and `determinate`
+/// follow the state.
+public class CheckBox extends ButtonBase {
+
+    private static final int STATE = Dirty.USER;
+    private static final PseudoClass SELECTED_STATE = PseudoClass.getPseudoClass("selected");
+    private static final PseudoClass INDETERMINATE_STATE = PseudoClass.getPseudoClass("indeterminate");
+    private static final PseudoClass DETERMINATE_STATE = PseudoClass.getPseudoClass("determinate");
+
+    private final BooleanProperty selected = new FxBoolean(this, "selected", false, STATE | Dirty.NATIVE);
+    private final BooleanProperty indeterminate = new FxBoolean(this, "indeterminate", false,
+            STATE | Dirty.NATIVE);
+    private final BooleanProperty allowIndeterminate = new SimpleBooleanProperty(this, "allowIndeterminate", false);
+
+    /// Creates a check box with no text.
+    public CheckBox() {
+        init();
+    }
+
+    /// Creates a check box with text.
+    public CheckBox(String text) {
+        super(text);
+        init();
+    }
+
+    private void init() {
+        getStyleClass().add("check-box");
+        pseudoClassStateChanged(DETERMINATE_STATE, true);
+    }
+
+    /// The native check box with the third look it lacks: the empty box
+    /// the theme draws, and a dash in it while the state is undetermined.
+    private static final class Box extends com.codename1.ui.CheckBox {
+
+        private boolean dash;
+
+        void dash(boolean on) {
+            if (dash != on) {
+                dash = on;
+                repaint();
+            }
+        }
+
+        @Override
+        public void paint(Graphics g) {
+            super.paint(g);
+            if (!dash || isToggle() || isOppositeSide()) {
+                return;
+            }
+            // The box is where the look and feel puts it: against the
+            // leading padding, as high as the image the theme draws for
+            // it -- as the text when the theme has none -- and centred on
+            // the height the padding leaves.
+            Style s = getStyle();
+            int side = s.getFont().getHeight();
+            LookAndFeel laf = getUIManager().getLookAndFeel();
+            if (laf instanceof DefaultLookAndFeel) {
+                Image[] images = ((DefaultLookAndFeel) laf).getCheckBoxImages();
+                if (images != null && images.length > 0 && images[0] != null) {
+                    side = images[0].getWidth();
+                }
+            }
+            int lead = s.getPaddingLeft(isRTL());
+            int x = isRTL() ? getX() + getWidth() - lead - side : getX() + lead;
+            int top = s.getPaddingTop();
+            int cy = getY() + top + (getHeight() - top - s.getPaddingBottom()) / 2;
+            int w = Math.max(4, side / 2);
+            int h = Math.max(2, side / 8);
+            int color = g.getColor();
+            g.setColor(s.getFgColor());
+            g.fillRect(x + (side - w) / 2, cy - h / 2, w, h);
+            g.setColor(color);
+        }
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.CheckBox b = new Box();
+        b.addActionListener(cn1ActionBridge());
+        return b;
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c instanceof Box) {
+            ((Box) c).setSelected(isSelected() && !isIndeterminate());
+            ((Box) c).dash(isIndeterminate());
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & STATE) != 0) {
+            pseudoClassStateChanged(SELECTED_STATE, isSelected());
+            pseudoClassStateChanged(INDETERMINATE_STATE, isIndeterminate());
+            pseudoClassStateChanged(DETERMINATE_STATE, !isIndeterminate());
+        }
+        super.cn1Invalidated(what);
+    }
+
+    /// Moves to the next state and fires an `ActionEvent`.
+    @Override
+    public void fire() {
+        if (isDisabled()) {
+            return;
+        }
+        if (isAllowIndeterminate()) {
+            if (isIndeterminate()) {
+                setSelected(true);
+                setIndeterminate(false);
+            } else if (isSelected()) {
+                setSelected(false);
+            } else {
+                setIndeterminate(true);
+            }
+        } else {
+            setSelected(!isSelected());
+            setIndeterminate(false);
+        }
+        fireEvent(new ActionEvent(this, this));
+    }
+
+    /// Returns whether the box is checked.
+    public final boolean isSelected() {
+        return selected.get();
+    }
+
+    /// Checks or unchecks the box.
+    public final void setSelected(boolean value) {
+        selected.set(value);
+    }
+
+    /// Whether the box is checked.
+    public final BooleanProperty selectedProperty() {
+        return selected;
+    }
+
+    /// Returns whether the box is in the third, undecided state.
+    public final boolean isIndeterminate() {
+        return indeterminate.get();
+    }
+
+    /// Puts the box in the third, undecided state or takes it out.
+    public final void setIndeterminate(boolean value) {
+        indeterminate.set(value);
+    }
+
+    /// Whether the box is in the third, undecided state.
+    public final BooleanProperty indeterminateProperty() {
+        return indeterminate;
+    }
+
+    /// Returns whether a press can reach the indeterminate state.
+    public final boolean isAllowIndeterminate() {
+        return allowIndeterminate.get();
+    }
+
+    /// Sets whether a press can reach the indeterminate state.
+    public final void setAllowIndeterminate(boolean value) {
+        allowIndeterminate.set(value);
+    }
+
+    /// Whether a press can reach the indeterminate state.
+    public final BooleanProperty allowIndeterminateProperty() {
+        return allowIndeterminate;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/CheckMenuItem.java b/maven/javafx-compat/src/main/java/javafx/scene/control/CheckMenuItem.java
new file mode 100644
index 00000000000..735bd441c69
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/CheckMenuItem.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.scene.Node;
+
+/// A menu item that is either selected or not; its row shows a mark while
+/// it is selected. Choosing the row flips the selection and then fires
+/// the item. [#fire()] alone leaves the selection as it is.
+public class CheckMenuItem extends MenuItem {
+
+    private final BooleanProperty selected = new SimpleBooleanProperty(this, "selected", false);
+
+    /// Creates an item with no text.
+    public CheckMenuItem() {
+        this(null, null);
+    }
+
+    /// Creates an item with a text.
+    public CheckMenuItem(String text) {
+        this(text, null);
+    }
+
+    /// Creates an item with a text and a graphic.
+    public CheckMenuItem(String text, Node graphic) {
+        super(text, graphic);
+        styleClasses().add("check-menu-item");
+    }
+
+    /// Sets whether the item is selected.
+    public final void setSelected(boolean value) {
+        selected.set(value);
+    }
+
+    /// Returns whether the item is selected.
+    public final boolean isSelected() {
+        return selected.get();
+    }
+
+    /// Whether the item is selected.
+    public final BooleanProperty selectedProperty() {
+        return selected;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceBox.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceBox.java
new file mode 100644
index 00000000000..a6b9b2cdd43
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceBox.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.spinner.Picker;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.util.StringConverter;
+
+/// A control that shows one of a short list of items and opens a chooser
+/// to pick another.
+///
+/// It is shown by a Codename One `Picker`, as a [ComboBox] is: a button
+/// with the text of the value, which opens the picker of the platform
+/// when it is pressed. The text of an item comes from the converter, or
+/// from `toString()` without one.
+///
+/// The value and the selection model follow each other, and a value the
+/// items no longer hold after they changed is cleared. A change of the
+/// value sends an `ActionEvent`. Codename One does not report a chooser the user
+/// dismissed without choosing, so `showing` can stay `true` after that.
+///
+/// The showing and hiding events of JavaFX are not part of this layer.
+///
+/// ## Style
+///
+/// The style class is `choice-box`. The region properties apply around
+/// the picker; the picker itself is drawn by the Codename One theme.
+public class ChoiceBox<T> extends Control {
+
+    private final ObjectProperty<ObservableList<T>> items = new SimpleObjectProperty<ObservableList<T>>(this,
+            "items");
+    private final ObjectProperty<T> value = new SimpleObjectProperty<T>(this, "value");
+    private final ObjectProperty<StringConverter<T>> converter = new SimpleObjectProperty<StringConverter<T>>(this,
+            "converter");
+    private final ObjectProperty<SingleSelectionModel<T>> selectionModel =
+            new SimpleObjectProperty<SingleSelectionModel<T>>(this, "selectionModel");
+    private final ReadOnlyBooleanWrapper showing = new ReadOnlyBooleanWrapper(this, "showing", false);
+    private final ObjectProperty<EventHandler<ActionEvent>> onAction =
+            new SimpleObjectProperty<EventHandler<ActionEvent>>(this, "onAction");
+    private final ChoiceCore<T> core;
+
+    /// Creates a choice box with no items.
+    public ChoiceBox() {
+        this(FXCollections.<T>observableArrayList());
+    }
+
+    /// Creates a choice box over a list of items.
+    public ChoiceBox(ObservableList<T> items) {
+        getStyleClass().add("choice-box");
+        addEventHandler(ActionEvent.ACTION, new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                EventHandler<ActionEvent> handler = onAction.get();
+                if (handler != null) {
+                    handler.handle(event);
+                }
+            }
+        });
+        core = new ChoiceCore<T>(this, this.items, value, selectionModel, converter, null,
+                showing.getReadOnlyProperty(), new ChoiceCore.Host() {
+                    @Override
+                    public void shown(boolean open) {
+                        showing.set(open);
+                    }
+                }, true);
+        value.addListener(new ChangeListener<T>() {
+            @Override
+            public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+                fireEvent(new ActionEvent(ChoiceBox.this, ChoiceBox.this));
+            }
+        });
+        selectionModel.set(new ChoiceModel<T>(this.items));
+        this.items.set(items);
+    }
+
+    /// The items to choose from.
+    public final ObjectProperty<ObservableList<T>> itemsProperty() {
+        return items;
+    }
+
+    /// Sets the items to choose from.
+    public final void setItems(ObservableList<T> value) {
+        items.set(value);
+    }
+
+    /// Returns the items to choose from.
+    public final ObservableList<T> getItems() {
+        return items.get();
+    }
+
+    /// The chosen item.
+    public ObjectProperty<T> valueProperty() {
+        return value;
+    }
+
+    /// Sets the chosen item.
+    public final void setValue(T value) {
+        this.value.set(value);
+    }
+
+    /// Returns the chosen item.
+    public final T getValue() {
+        return value.get();
+    }
+
+    /// Makes the text of an item.
+    public ObjectProperty<StringConverter<T>> converterProperty() {
+        return converter;
+    }
+
+    /// Sets what makes the text of an item.
+    public final void setConverter(StringConverter<T> value) {
+        converter.set(value);
+    }
+
+    /// Returns what makes the text of an item.
+    public final StringConverter<T> getConverter() {
+        return converter.get();
+    }
+
+    /// The model of the selected row.
+    public final ObjectProperty<SingleSelectionModel<T>> selectionModelProperty() {
+        return selectionModel;
+    }
+
+    /// Sets the model of the selected row.
+    public final void setSelectionModel(SingleSelectionModel<T> value) {
+        selectionModel.set(value);
+    }
+
+    /// Returns the model of the selected row.
+    public final SingleSelectionModel<T> getSelectionModel() {
+        return selectionModel.get();
+    }
+
+    /// Whether the chooser is open.
+    public final ReadOnlyBooleanProperty showingProperty() {
+        return showing.getReadOnlyProperty();
+    }
+
+    /// Returns whether the chooser is open.
+    public final boolean isShowing() {
+        return showing.get();
+    }
+
+    /// Opens the chooser; a disabled control stays closed.
+    public void show() {
+        if (isDisabled()) {
+            return;
+        }
+        if (showing.get()) {
+            // The chooser may have been dismissed unnoticed.
+            core.reopen();
+        } else {
+            showing.set(true);
+        }
+    }
+
+    /// Closes the chooser.
+    public void hide() {
+        showing.set(false);
+    }
+
+    /// The handler called when the value changed.
+    public final ObjectProperty<EventHandler<ActionEvent>> onActionProperty() {
+        return onAction;
+    }
+
+    /// Sets the handler called when the value changed.
+    public final void setOnAction(EventHandler<ActionEvent> value) {
+        onAction.set(value);
+    }
+
+    /// Returns the handler called when the value changed.
+    public final EventHandler<ActionEvent> getOnAction() {
+        return onAction.get();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return core.create();
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c instanceof Picker && core != null) {
+            core.sync((Picker) c);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceCore.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceCore.java
new file mode 100644
index 00000000000..e78db0f3008
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceCore.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+import com.codename1.ui.FontImage;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.spinner.Picker;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.scene.Scene;
+import javafx.util.StringConverter;
+
+/// What a [ComboBox] and a [ChoiceBox] share: the value and the selection
+/// kept in step, and the Codename One picker that shows the choice and
+/// lets the user change it.
+///
+/// The picker lists the items as text, made by the converter or by
+/// `toString()`. It tells rows apart by that text, so of two items with
+/// the same text the user can only pick the first.
+final class ChoiceCore<T> {
+
+    /// What the core tells its control.
+    interface Host {
+
+        /// The picker opened or closed.
+        void shown(boolean showing);
+    }
+
+    private final Control owner;
+    private final ObjectProperty<ObservableList<T>> items;
+    private final ObjectProperty<T> value;
+    private final ObjectProperty<SingleSelectionModel<T>> model;
+    private final ObjectProperty<StringConverter<T>> converter;
+    private final StringProperty prompt;
+    private final Host host;
+    private final boolean strict;
+    private boolean syncing;
+
+    private final ListChangeListener<T> itemsListener = new ListChangeListener<T>() {
+        @Override
+        public void onChanged(Change<? extends T> change) {
+            itemsChanged();
+        }
+    };
+
+    private final ChangeListener<T> selectedListener = new ChangeListener<T>() {
+        @Override
+        public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+            value.set(newValue);
+        }
+    };
+
+    /// Creates the core of a control. A strict core clears a value that
+    /// is not among the items; the other keeps it with no row selected.
+    ChoiceCore(Control owner, ObjectProperty<ObservableList<T>> items, ObjectProperty<T> value,
+            ObjectProperty<SingleSelectionModel<T>> model, ObjectProperty<StringConverter<T>> converter,
+            StringProperty prompt, ReadOnlyBooleanProperty showing, Host host, boolean strict) {
+        this.owner = owner;
+        this.items = items;
+        this.value = value;
+        this.model = model;
+        this.converter = converter;
+        this.prompt = prompt;
+        this.host = host;
+        this.strict = strict;
+        items.addListener(new ChangeListener<ObservableList<T>>() {
+            @Override
+            public void changed(ObservableValue<? extends ObservableList<T>> observable, ObservableList<T> oldValue,
+                    ObservableList<T> newValue) {
+                if (oldValue != null) {
+                    oldValue.removeListener(itemsListener);
+                }
+                if (newValue != null) {
+                    newValue.addListener(itemsListener);
+                }
+                itemsChanged();
+            }
+        });
+        model.addListener(new ChangeListener<SingleSelectionModel<T>>() {
+            @Override
+            public void changed(ObservableValue<? extends SingleSelectionModel<T>> observable,
+                    SingleSelectionModel<T> oldValue, SingleSelectionModel<T> newValue) {
+                if (oldValue != null) {
+                    oldValue.selectedItemProperty().removeListener(selectedListener);
+                }
+                if (newValue != null) {
+                    newValue.selectedItemProperty().addListener(selectedListener);
+                    applyValue(ChoiceCore.this.value.get());
+                }
+                refresh();
+            }
+        });
+        value.addListener(new ChangeListener<T>() {
+            @Override
+            public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+                applyValue(newValue);
+                refresh();
+            }
+        });
+        converter.addListener(new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                refresh();
+            }
+        });
+        if (prompt != null) {
+            prompt.addListener(new ChangeListener<Object>() {
+                @Override
+                public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                    refresh();
+                }
+            });
+        }
+        showing.addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
+                showingChanged(newValue != null && newValue.booleanValue());
+            }
+        });
+    }
+
+    private void applyValue(T v) {
+        SingleSelectionModel<T> m = model.get();
+        if (m == null) {
+            return;
+        }
+        T selected = m.getSelectedItem();
+        if (v == null ? selected == null : v.equals(selected)) {
+            return;
+        }
+        if (v == null) {
+            m.clearSelection();
+        } else {
+            m.select(v);
+        }
+    }
+
+    private void itemsChanged() {
+        SingleSelectionModel<T> m = model.get();
+        T v = value.get();
+        if (m != null && v != null) {
+            ObservableList<T> list = items.get();
+            int index = list == null ? -1 : list.indexOf(v);
+            if (index >= 0) {
+                if (m.getSelectedIndex() != index) {
+                    m.select(index);
+                }
+            } else if (strict) {
+                m.clearSelection();
+            } else if (m.getSelectedIndex() != -1) {
+                // The value stays, on no row.
+                m.select(v);
+            }
+        }
+        refresh();
+    }
+
+    private void refresh() {
+        owner.cn1Invalidated(Dirty.NATIVE);
+        owner.cn1NativeSizeChanged();
+    }
+
+    /// Returns the text an item is listed as.
+    String label(T item) {
+        StringConverter<T> c = converter.get();
+        String s = c != null ? c.toString(item) : (item == null ? null : item.toString());
+        return s == null ? "" : s;
+    }
+
+    /// Creates the picker of the control.
+    Picker create() {
+        final Picker p = new Picker();
+        p.setType(Display.PICKER_TYPE_STRINGS);
+        // The arrow that says a list drops down, after the text.
+        p.setMaterialIcon(FontImage.MATERIAL_ARROW_DROP_DOWN);
+        p.setTextPosition(Component.LEFT);
+        p.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                picked(p, evt);
+            }
+        });
+        return p;
+    }
+
+    private void picked(Picker p, ActionEvent evt) {
+        if (syncing) {
+            return;
+        }
+        boolean committed = evt.getX() == -99 && evt.getY() == -99;
+        if (!committed && p.isEditing()) {
+            // The picker just opened; what it holds is not chosen yet.
+            host.shown(true);
+            return;
+        }
+        int index = p.getSelectedStringIndex();
+        SingleSelectionModel<T> m = model.get();
+        if (m != null && index >= 0 && index != m.getSelectedIndex()) {
+            m.select(index);
+        }
+        host.shown(false);
+    }
+
+    /// Copies the items and the choice into the picker.
+    void sync(Picker p) {
+        syncing = true;
+        try {
+            ObservableList<T> list = items.get();
+            int n = list == null ? 0 : list.size();
+            String[] labels = new String[n];
+            for (int i = 0; i < n; i++) {
+                labels[i] = label(list.get(i));
+            }
+            p.setStrings(labels);
+            SingleSelectionModel<T> m = model.get();
+            int index = m == null ? -1 : m.getSelectedIndex();
+            T v = value.get();
+            if (index >= 0 && index < n) {
+                p.setSelectedStringIndex(index);
+            } else {
+                p.setSelectedString(null);
+                String text = prompt == null ? null : prompt.get();
+                p.setText(v != null ? label(v) : (text == null ? "" : text));
+            }
+        } finally {
+            syncing = false;
+        }
+    }
+
+    /// Opens the picker if it is not open.
+    void reopen() {
+        showingChanged(true);
+    }
+
+    private void showingChanged(boolean showing) {
+        Object c = owner.cn1NativeIfCreated();
+        if (!(c instanceof Picker)) {
+            return;
+        }
+        Picker p = (Picker) c;
+        if (showing) {
+            Scene s = owner.getScene();
+            ObservableList<T> list = items.get();
+            boolean onScreen = s != null && s.getWindow() != null && s.getWindow().isShowing();
+            if (onScreen && list != null && !list.isEmpty() && !p.isEditing()) {
+                p.startEditingAsync();
+            }
+        } else if (p.isEditing()) {
+            p.stopEditing(null);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceDialog.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceDialog.java
new file mode 100644
index 00000000000..ac4de8caa59
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceDialog.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.Collection;
+
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.collections.ObservableList;
+import javafx.scene.control.ButtonBar.ButtonData;
+import javafx.util.Callback;
+
+/// A dialog that asks the user to pick one of a list of items. It shows
+/// the items in a [ComboBox], has an OK and a Cancel button, and answers
+/// with the selected item when OK is chosen, with nothing otherwise.
+///
+/// The content text is shown as a label left of the combo box.
+public class ChoiceDialog<T> extends Dialog<T> {
+
+    private final T defaultChoice;
+    private final ComboBox<T> comboBox = new ComboBox<T>();
+
+    /// Creates a dialog with no items.
+    public ChoiceDialog() {
+        this((T) null, (T[]) null);
+    }
+
+    /// Creates a dialog over items, one of them selected to start with.
+    @SuppressWarnings("unchecked")
+    public ChoiceDialog(T defaultChoice, T... choices) {
+        this(defaultChoice, choices == null ? null : java.util.Arrays.asList(choices));
+    }
+
+    /// Creates a dialog over items, one of them selected to start with.
+    /// A default choice that is not among the items is ignored, and the
+    /// first item is selected.
+    public ChoiceDialog(T defaultChoice, Collection<T> choices) {
+        DialogRow row = new DialogRow(comboBox);
+        DialogPane pane = getDialogPane();
+        pane.contentTextProperty().addListener(row);
+        pane.getStyleClass().add("choice-dialog");
+        pane.setContent(row);
+        pane.getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);
+        setTitle("Confirmation");
+        pane.setHeaderText("Confirmation");
+        ObservableList<T> items = comboBox.getItems();
+        if (choices != null) {
+            items.addAll(choices);
+        }
+        this.defaultChoice = defaultChoice != null && items.contains(defaultChoice) ? defaultChoice : null;
+        SingleSelectionModel<T> model = comboBox.getSelectionModel();
+        if (this.defaultChoice == null) {
+            model.selectFirst();
+        } else {
+            model.select(this.defaultChoice);
+        }
+        setResultConverter(new Callback<ButtonType, T>() {
+            @Override
+            public T call(ButtonType chosen) {
+                ButtonData data = chosen == null ? null : chosen.getButtonData();
+                return data == ButtonData.OK_DONE ? getSelectedItem() : null;
+            }
+        });
+    }
+
+    /// Returns the items to pick from.
+    public final ObservableList<T> getItems() {
+        return comboBox.getItems();
+    }
+
+    /// Returns the selected item.
+    public final T getSelectedItem() {
+        return comboBox.getSelectionModel().getSelectedItem();
+    }
+
+    /// The selected item.
+    public final ReadOnlyObjectProperty<T> selectedItemProperty() {
+        return comboBox.getSelectionModel().selectedItemProperty();
+    }
+
+    /// Selects an item.
+    public final void setSelectedItem(T item) {
+        comboBox.getSelectionModel().select(item);
+    }
+
+    /// Returns the item selected to start with, or `null`.
+    public final T getDefaultChoice() {
+        return defaultChoice;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceModel.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceModel.java
new file mode 100644
index 00000000000..f0da9a18b01
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ChoiceModel.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.ObservableList;
+
+/// The selection model a [ComboBox] and a [ChoiceBox] start with: one
+/// selected row of the items of the control.
+final class ChoiceModel<T> extends SingleSelectionModel<T> {
+
+    private final ObjectProperty<ObservableList<T>> items;
+
+    ChoiceModel(ObjectProperty<ObservableList<T>> items) {
+        this.items = items;
+    }
+
+    @Override
+    protected T getModelItem(int index) {
+        ObservableList<T> list = items.get();
+        return list == null || index < 0 || index >= list.size() ? null : list.get(index);
+    }
+
+    @Override
+    protected int getItemCount() {
+        ObservableList<T> list = items.get();
+        return list == null ? 0 : list.size();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ColorPicker.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ColorPicker.java
new file mode 100644
index 00000000000..ebd02b48b1e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ColorPicker.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.StagePopup;
+import com.codename1.ui.Component;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Insets;
+import javafx.geometry.Point2D;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+
+/// A button that shows a colour and opens a palette to choose another.
+///
+/// The button is a swatch of the value beside its name, or its
+/// `#rrggbb` when it has none of the few names known here. The palette is
+/// a row of greys over rows of twelve hues from light to dark, and under
+/// them the colours of [#getCustomColors()]. Choosing one sets the value,
+/// which fires the action handler, and closes the palette.
+///
+/// There is no dialog to mix a colour: custom colours are the ones the
+/// application puts in the list. The style classes [#STYLE_CLASS_BUTTON]
+/// and [#STYLE_CLASS_SPLIT_BUTTON] are accepted and change nothing.
+public class ColorPicker extends ComboBoxBase<Color> {
+
+    /// The style class that asks for a plain button.
+    public static final String STYLE_CLASS_BUTTON = "button";
+    /// The style class that asks for a button with a separate arrow.
+    public static final String STYLE_CLASS_SPLIT_BUTTON = "split-button";
+
+    private static final int COLUMNS = 12;
+    private static final double SWATCH = 15;
+    private static final String[] NAMES = {"#ffffff", "White", "#000000", "Black", "#ff0000", "Red", "#008000",
+        "Green", "#0000ff", "Blue", "#ffff00", "Yellow", "#ffa500", "Orange", "#ffc0cb", "Pink", "#800080",
+        "Purple", "#808080", "Gray", "#00ffff", "Cyan", "#ff00ff", "Magenta", "#a52a2a", "Brown", "#00ff00",
+        "Lime"};
+
+    private final ObservableList<Color> customColors = FXCollections.observableArrayList();
+    private final Rectangle swatch = new Rectangle(SWATCH, SWATCH);
+    private final Label name = new Label();
+    private Palette palette;
+
+    /// The window of the palette.
+    private static final class Palette extends PopupControl {
+        Palette(javafx.scene.Parent content) {
+            setAutoHide(true);
+            setScene(new Scene(content));
+        }
+    }
+
+    /// Creates a picker that shows white.
+    public ColorPicker() {
+        this(Color.WHITE);
+    }
+
+    /// Creates a picker that shows a colour.
+    public ColorPicker(Color color) {
+        getStyleClass().add("color-picker");
+        swatch.setStroke(Color.gray(0.4));
+        // The arrow every combo box of the standard theme ends in.
+        javafx.scene.shape.Polygon arrow = new javafx.scene.shape.Polygon(0, 0, 7, 0, 3.5, 4);
+        arrow.setFill(Color.gray(0.25));
+        HBox row = new HBox(6, swatch, name, arrow);
+        HBox.setMargin(arrow, new javafx.geometry.Insets(0, 0, 0, 4));
+        row.setAlignment(Pos.CENTER_LEFT);
+        cn1MadeOf(row);
+        super.valueProperty().addListener((observable, was, now) -> shown());
+        addEventHandler(MouseEvent.MOUSE_CLICKED, e -> {
+            if (!isDisabled()) {
+                if (isShowing()) {
+                    hide();
+                } else {
+                    show();
+                }
+                e.consume();
+            }
+        });
+        setValue(color);
+        shown();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public String cn1DefaultStyle() {
+        return "-fx-background-color: -fx-outer-border, -fx-inner-border, linear-gradient(to bottom,"
+                + " derive(-fx-color, 8%), derive(-fx-color, -8%)); -fx-background-insets: 0, 1, 2;"
+                + " -fx-background-radius: 3, 2, 1; -fx-padding: 0.333333em 0.666667em 0.333333em 0.666667em;";
+    }
+
+    /// The text the button shows for a colour.
+    static String describe(Color c) {
+        if (c == null) {
+            return "";
+        }
+        String hex = hex(c);
+        for (int i = 0; i + 1 < NAMES.length; i += 2) {
+            if (NAMES[i].equals(hex)) {
+                return NAMES[i + 1];
+            }
+        }
+        return hex;
+    }
+
+    private static String hex(Color c) {
+        int rgb = c.cn1Argb() & 0xffffff;
+        String digits = Integer.toHexString(0x1000000 | rgb);
+        return "#" + digits.substring(1);
+    }
+
+    private void shown() {
+        Color c = getValue();
+        swatch.setFill(c == null ? Color.TRANSPARENT : c);
+        name.setText(describe(c));
+        requestLayout();
+    }
+
+    /// The colours of the palette, row after row.
+    static Color[] paletteColors() {
+        int rows = 9;
+        Color[] out = new Color[COLUMNS * (rows + 1)];
+        for (int i = 0; i < COLUMNS; i++) {
+            out[i] = Color.gray(1 - i / (double) (COLUMNS - 1));
+        }
+        for (int r = 0; r < rows; r++) {
+            // Light tints first, the pure hue in the middle, shades after.
+            double saturation = r < 4 ? 0.2 + 0.2 * r : 1;
+            double brightness = r <= 4 ? 1 : 1 - 0.18 * (r - 4);
+            for (int i = 0; i < COLUMNS; i++) {
+                out[(r + 1) * COLUMNS + i] = Color.hsb(360.0 * i / COLUMNS, saturation, brightness);
+            }
+        }
+        return out;
+    }
+
+    private void add(GridPane grid, final Color c, int column, int row) {
+        Rectangle r = new Rectangle(SWATCH, SWATCH, c);
+        r.setStroke(Color.gray(0.75));
+        r.addEventHandler(MouseEvent.MOUSE_CLICKED, e -> {
+            setValue(c);
+            hide();
+            e.consume();
+        });
+        grid.add(r, column, row);
+    }
+
+    private javafx.scene.Parent content() {
+        GridPane grid = new GridPane();
+        grid.setHgap(1);
+        grid.setVgap(1);
+        Color[] all = paletteColors();
+        for (int i = 0; i < all.length; i++) {
+            add(grid, all[i], i % COLUMNS, i / COLUMNS);
+        }
+        VBox box = new VBox(6, grid);
+        if (!customColors.isEmpty()) {
+            GridPane own = new GridPane();
+            own.setHgap(1);
+            own.setVgap(1);
+            for (int i = 0; i < customColors.size(); i++) {
+                add(own, customColors.get(i), i % COLUMNS, i / COLUMNS);
+            }
+            box.getChildren().addAll(new Label("Custom Colors"), own);
+        }
+        box.setPadding(new Insets(8));
+        box.setStyle("-fx-background-color: -fx-box-border, -fx-background; -fx-background-insets: 0, 1;");
+        return box;
+    }
+
+    /// Opens the palette under the button.
+    @Override
+    public void show() {
+        if (isDisabled() || getScene() == null) {
+            return;
+        }
+        if (palette != null) {
+            palette.hide();
+        }
+        palette = new Palette(content());
+        palette.setOnHidden(e -> chooserShown(false));
+        Point2D at = StagePopup.anchor(this, 0, getHeight());
+        palette.show(this, at.getX(), at.getY());
+        chooserShown(true);
+    }
+
+    /// Closes the palette.
+    @Override
+    public void hide() {
+        if (palette != null) {
+            Palette open = palette;
+            palette = null;
+            open.hide();
+        }
+        chooserShown(false);
+    }
+
+    /// Returns the colours the palette shows under its own.
+    public final ObservableList<Color> getCustomColors() {
+        return customColors;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ComboBox.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ComboBox.java
new file mode 100644
index 00000000000..fb9c2b3fa24
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ComboBox.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.spinner.Picker;
+
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.util.StringConverter;
+
+/// A control that shows one of a list of items and opens a chooser to
+/// pick another.
+///
+/// It is shown by a Codename One `Picker`: a button with the text of the
+/// value, which opens the picker of the platform, a wheel or a list, when
+/// it is pressed. The text of an item comes from the converter, or from
+/// `toString()` without one; the prompt text shows while there is no
+/// value.
+///
+/// The value and the selection model follow each other. Selecting a row
+/// makes its item the value; setting a value selects its row, and a value
+/// that is not among the items stays the value with no row selected. A
+/// change of the value sends an `ActionEvent`.
+///
+/// There are no cells here: the cell factory, the button cell, the
+/// placeholder and the editor of JavaFX are absent. `visibleRowCount` is
+/// recorded; the platform decides how many rows its picker shows.
+///
+/// ## Style
+///
+/// The style classes are `combo-box` and `combo-box-base`. The region
+/// properties (`-fx-background-color`, `-fx-border-color`, `-fx-padding`)
+/// apply around the picker; the picker itself is drawn by the Codename
+/// One theme.
+public class ComboBox<T> extends ComboBoxBase<T> {
+
+    private final ObjectProperty<ObservableList<T>> items = new SimpleObjectProperty<ObservableList<T>>(this,
+            "items");
+    private final ObjectProperty<StringConverter<T>> converter = new SimpleObjectProperty<StringConverter<T>>(this,
+            "converter");
+    private final ObjectProperty<SingleSelectionModel<T>> selectionModel =
+            new SimpleObjectProperty<SingleSelectionModel<T>>(this, "selectionModel");
+    private final IntegerProperty visibleRowCount = new SimpleIntegerProperty(this, "visibleRowCount", 10);
+    private final ChoiceCore<T> core;
+
+    /// Creates a combo box with no items.
+    public ComboBox() {
+        this(FXCollections.<T>observableArrayList());
+    }
+
+    /// Creates a combo box over a list of items.
+    public ComboBox(ObservableList<T> items) {
+        getStyleClass().add("combo-box");
+        core = new ChoiceCore<T>(this, this.items, valueRef(), selectionModel, converter, promptTextProperty(),
+                showingRef(), new ChoiceCore.Host() {
+                    @Override
+                    public void shown(boolean showing) {
+                        chooserShown(showing);
+                    }
+                }, false);
+        selectionModel.set(new ChoiceModel<T>(this.items));
+        this.items.set(items);
+    }
+
+    /// The items to choose from.
+    public final ObjectProperty<ObservableList<T>> itemsProperty() {
+        return items;
+    }
+
+    /// Sets the items to choose from.
+    public final void setItems(ObservableList<T> value) {
+        items.set(value);
+    }
+
+    /// Returns the items to choose from.
+    public final ObservableList<T> getItems() {
+        return items.get();
+    }
+
+    /// Makes the text of an item. `fromString` is never called: the user
+    /// cannot type a value.
+    public ObjectProperty<StringConverter<T>> converterProperty() {
+        return converter;
+    }
+
+    /// Sets what makes the text of an item.
+    public final void setConverter(StringConverter<T> value) {
+        converter.set(value);
+    }
+
+    /// Returns what makes the text of an item.
+    public final StringConverter<T> getConverter() {
+        return converter.get();
+    }
+
+    /// The model of the selected row.
+    public final ObjectProperty<SingleSelectionModel<T>> selectionModelProperty() {
+        return selectionModel;
+    }
+
+    /// Sets the model of the selected row.
+    public final void setSelectionModel(SingleSelectionModel<T> value) {
+        selectionModel.set(value);
+    }
+
+    /// Returns the model of the selected row.
+    public final SingleSelectionModel<T> getSelectionModel() {
+        return selectionModel.get();
+    }
+
+    /// The number of rows the chooser is asked to show; recorded.
+    public final IntegerProperty visibleRowCountProperty() {
+        return visibleRowCount;
+    }
+
+    /// Sets the number of rows the chooser is asked to show; recorded.
+    public final void setVisibleRowCount(int value) {
+        visibleRowCount.set(value);
+    }
+
+    /// Returns the number of rows the chooser is asked to show.
+    public final int getVisibleRowCount() {
+        return visibleRowCount.get();
+    }
+
+    @Override
+    void chooserReopen() {
+        core.reopen();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return core.create();
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c instanceof Picker && core != null) {
+            core.sync((Picker) c);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ComboBoxBase.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ComboBoxBase.java
new file mode 100644
index 00000000000..952165b75b0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ComboBoxBase.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxString;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+
+/// The base of the controls that show one value and open something to
+/// choose another: [ComboBox] and [DatePicker].
+///
+/// The value is what the control holds. A change of it, by the user or
+/// from code, sends an `ActionEvent` to the control. [#show()] opens the
+/// chooser and [#hide()] closes it; `showing` follows. Codename One does
+/// not report a chooser the user dismissed without choosing, so `showing`
+/// can stay `true` after that; [#show()] opens the chooser again all the
+/// same.
+///
+/// `editable` is recorded: there is no text field in these controls. The
+/// armed state and the showing and hiding events of JavaFX are not part
+/// of this layer.
+public abstract class ComboBoxBase<T> extends Control {
+
+    private final ObjectProperty<T> value = new FxObject<T>(this, "value", null, Dirty.NATIVE | Dirty.LAYOUT);
+    private final BooleanProperty editable = new SimpleBooleanProperty(this, "editable", false);
+    private final StringProperty promptText = new FxString(this, "promptText", "", Dirty.NATIVE | Dirty.LAYOUT);
+    private final ReadOnlyBooleanWrapper showing = new ReadOnlyBooleanWrapper(this, "showing", false);
+    private final ObjectProperty<EventHandler<ActionEvent>> onAction =
+            new SimpleObjectProperty<EventHandler<ActionEvent>>(this, "onAction");
+
+    /// Creates a control with no value.
+    public ComboBoxBase() {
+        getStyleClass().add("combo-box-base");
+        addEventHandler(ActionEvent.ACTION, new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                EventHandler<ActionEvent> handler = onAction.get();
+                if (handler != null) {
+                    handler.handle(event);
+                }
+            }
+        });
+        value.addListener(new ChangeListener<T>() {
+            @Override
+            public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+                fireEvent(new ActionEvent(ComboBoxBase.this, ComboBoxBase.this));
+            }
+        });
+    }
+
+    /// The value the control holds.
+    public ObjectProperty<T> valueProperty() {
+        return value;
+    }
+
+    /// Sets the value the control holds.
+    public final void setValue(T value) {
+        this.value.set(value);
+    }
+
+    /// Returns the value the control holds.
+    public final T getValue() {
+        return value.get();
+    }
+
+    /// Whether the user may type a value; recorded.
+    public BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Sets whether the user may type a value; recorded.
+    public final void setEditable(boolean value) {
+        editable.set(value);
+    }
+
+    /// Returns whether the user may type a value.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// The text shown while there is no value.
+    public final StringProperty promptTextProperty() {
+        return promptText;
+    }
+
+    /// Returns the text shown while there is no value.
+    public final String getPromptText() {
+        return promptText.get();
+    }
+
+    /// Sets the text shown while there is no value.
+    public final void setPromptText(String value) {
+        promptText.set(value);
+    }
+
+    /// Whether the chooser is open.
+    public ReadOnlyBooleanProperty showingProperty() {
+        return showing.getReadOnlyProperty();
+    }
+
+    /// Returns whether the chooser is open.
+    public final boolean isShowing() {
+        return showing.get();
+    }
+
+    /// The value, for a constructor.
+    final ObjectProperty<T> valueRef() {
+        return value;
+    }
+
+    /// Whether the chooser is open, for a constructor.
+    final ReadOnlyBooleanProperty showingRef() {
+        return showing.getReadOnlyProperty();
+    }
+
+    /// Records that the chooser opened or closed by itself.
+    final void chooserShown(boolean value) {
+        showing.set(value);
+    }
+
+    /// Opens the chooser; a disabled control stays closed.
+    public void show() {
+        if (isDisabled()) {
+            return;
+        }
+        if (showing.get()) {
+            // The chooser may have been dismissed unnoticed.
+            chooserReopen();
+        } else {
+            showing.set(true);
+        }
+    }
+
+    /// Opens the chooser again if it closed while `showing` stayed set.
+    void chooserReopen() {
+    }
+
+    /// Closes the chooser.
+    public void hide() {
+        showing.set(false);
+    }
+
+    /// The handler called when the value changed.
+    public final ObjectProperty<EventHandler<ActionEvent>> onActionProperty() {
+        return onAction;
+    }
+
+    /// Sets the handler called when the value changed.
+    public final void setOnAction(EventHandler<ActionEvent> value) {
+        onAction.set(value);
+    }
+
+    /// Returns the handler called when the value changed.
+    public final EventHandler<ActionEvent> getOnAction() {
+        return onAction.get();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ContentDisplay.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ContentDisplay.java
new file mode 100644
index 00000000000..60ee0ed0ebe
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ContentDisplay.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// Where the graphic of a labeled control sits relative to its text.
+public enum ContentDisplay {
+    /// Above the text.
+    TOP,
+    /// To the right of the text.
+    RIGHT,
+    /// Below the text.
+    BOTTOM,
+    /// To the left of the text.
+    LEFT,
+    /// Centred, over the text.
+    CENTER,
+    /// Only the graphic is shown.
+    GRAPHIC_ONLY,
+    /// Only the text is shown.
+    TEXT_ONLY
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ContextMenu.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ContextMenu.java
new file mode 100644
index 00000000000..7a095bd6008
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ContextMenu.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.StagePopup;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.Bounds;
+import javafx.geometry.Point2D;
+import javafx.geometry.Side;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.input.KeyEvent;
+import javafx.stage.Window;
+
+/// A popup that lists menu items, one row each.
+///
+/// [#show(Node, double, double)] opens it with its top left corner at a
+/// point, [#show(Node, Side, double, double)] beside a node. Choosing a
+/// row hides the menu, and the menus it was opened from, and then fires
+/// the item; the `ActionEvent` goes on to the handler set with
+/// [#setOnAction(EventHandler)]. A press outside hides the menu too. A
+/// row of a [Menu] opens the sub-menu to its right when it is chosen. A
+/// menu with no items does not open.
+///
+/// The rows are built when the menu opens: a change to an item while its
+/// menu is open shows the next time. Keyboard navigation is not part of
+/// this layer.
+///
+/// Set on a control with `Control.setContextMenu`, the menu opens where a
+/// context menu is asked for: a secondary click or a long press.
+///
+/// ## Style
+///
+/// The popup has the style class `context-menu` and its rows those of
+/// their items (`menu-item`, `menu`, `check-menu-item`). They are
+/// recorded and not matched by a style sheet: the rows are in a scene of
+/// their own, which does not have the style sheets of the owner.
+public class ContextMenu extends PopupControl {
+
+    private final ObservableList<MenuItem> items = FXCollections.observableArrayList();
+    private final ObjectProperty<EventHandler<ActionEvent>> onAction =
+            new SimpleObjectProperty<EventHandler<ActionEvent>>(this, "onAction");
+    private final Menu source;
+    private MenuContent content;
+    private Scene popupScene;
+    private boolean hiding;
+
+    /// Creates a menu with no items.
+    public ContextMenu() {
+        this((Menu) null);
+        items.addListener(new ListChangeListener<MenuItem>() {
+            @Override
+            public void onChanged(Change<? extends MenuItem> change) {
+                while (change.next()) {
+                    List<? extends MenuItem> removed = change.getRemoved();
+                    for (int i = 0; i < removed.size(); i++) {
+                        MenuItem item = removed.get(i);
+                        if (!items.contains(item)) {
+                            adopt(item, null);
+                        }
+                    }
+                    List<? extends MenuItem> added = change.getAddedSubList();
+                    for (int i = 0; i < added.size(); i++) {
+                        adopt(added.get(i), ContextMenu.this);
+                    }
+                }
+            }
+        });
+    }
+
+    /// Creates a menu with items.
+    public ContextMenu(MenuItem... items) {
+        this();
+        if (items != null) {
+            this.items.addAll(items);
+        }
+    }
+
+    /// Creates the popup of a menu: it lists the items of the menu, which
+    /// stay the menu's.
+    ContextMenu(Menu source) {
+        this.source = source;
+        getStyleClass().add("context-menu");
+        setAutoHide(true);
+        addEventHandler(ActionEvent.ACTION, new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                EventHandler<ActionEvent> handler = onAction.get();
+                if (handler != null) {
+                    handler.handle(event);
+                }
+            }
+        });
+    }
+
+    private static void adopt(MenuItem item, ContextMenu popup) {
+        item.setParentPopup(popup);
+        if (item instanceof Menu) {
+            List<MenuItem> children = ((Menu) item).getItems();
+            for (int i = 0; i < children.size(); i++) {
+                adopt(children.get(i), popup);
+            }
+        }
+    }
+
+    /// Returns the items of this menu.
+    public final ObservableList<MenuItem> getItems() {
+        return items;
+    }
+
+    /// Returns the items the popup lists.
+    List<MenuItem> rows() {
+        return source != null ? source.getItems() : items;
+    }
+
+    /// Sets the handler called when an item of this menu is chosen.
+    public final void setOnAction(EventHandler<ActionEvent> value) {
+        onAction.set(value);
+    }
+
+    /// Returns the handler called when an item of this menu is chosen.
+    public final EventHandler<ActionEvent> getOnAction() {
+        return onAction.get();
+    }
+
+    /// The handler called when an item of this menu is chosen.
+    public final ObjectProperty<EventHandler<ActionEvent>> onActionProperty() {
+        return onAction;
+    }
+
+    /// Opens the menu at a side of a node, moved by an offset.
+    public void show(Node anchor, Side side, double dx, double dy) {
+        if (anchor == null || rows().isEmpty()) {
+            return;
+        }
+        MenuContent probe = new MenuContent(this);
+        double w = probe.prefWidth(-1);
+        double h = probe.prefHeight(-1);
+        probe.dispose();
+        Bounds b = anchor.getLayoutBounds();
+        double x = b.getMinX();
+        double y = b.getMinY();
+        if (side == Side.TOP) {
+            y -= h;
+        } else if (side == Side.LEFT) {
+            x -= w;
+        } else if (side == Side.RIGHT) {
+            x += b.getWidth();
+        } else {
+            y += b.getHeight();
+        }
+        Point2D p = StagePopup.anchor(anchor, x, y);
+        show(anchor, p.getX() + dx, p.getY() + dy);
+    }
+
+    /// Opens the menu for a node with its top left corner at a point, in
+    /// the coordinates input events report as screen coordinates.
+    @Override
+    public void show(Node anchor, double screenX, double screenY) {
+        if (anchor == null || rows().isEmpty()) {
+            return;
+        }
+        build();
+        super.show(anchor, screenX, screenY);
+    }
+
+    /// Opens the menu over a window with its top left corner at a point.
+    @Override
+    public void show(Window ownerWindow, double anchorX, double anchorY) {
+        if (ownerWindow == null || rows().isEmpty()) {
+            return;
+        }
+        build();
+        super.show(ownerWindow, anchorX, anchorY);
+    }
+
+    private void build() {
+        if (content != null) {
+            content.dispose();
+        }
+        content = new MenuContent(this);
+        if (popupScene == null) {
+            popupScene = new Scene(content);
+            popupScene.addEventHandler(KeyEvent.KEY_PRESSED, new EventHandler<KeyEvent>() {
+                @Override
+                public void handle(KeyEvent event) {
+                    if (content != null && content.key(event.getCode())) {
+                        event.consume();
+                    }
+                }
+            });
+            setScene(popupScene);
+        } else {
+            popupScene.setRoot(content);
+        }
+    }
+
+    /// Returns whether this is the popup of a menu inside another menu.
+    boolean isSubMenu() {
+        Node owner = getOwnerNode();
+        Scene s = owner == null ? null : owner.getScene();
+        return s != null && s.getWindow() instanceof ContextMenu;
+    }
+
+    /// Returns the rows of the menu as it last opened, or `null`.
+    MenuContent content() {
+        return content;
+    }
+
+    /// Hides this menu and every menu it was opened from.
+    void hideAll() {
+        ContextMenu top = this;
+        for (int depth = 0; depth < 16; depth++) {
+            Node owner = top.getOwnerNode();
+            Scene s = owner == null ? null : owner.getScene();
+            Window w = s == null ? null : s.getWindow();
+            if (w instanceof ContextMenu) {
+                top = (ContextMenu) w;
+            } else {
+                break;
+            }
+        }
+        top.hide();
+    }
+
+    /// Hides the menu and the sub-menus opened from it.
+    @Override
+    public void hide() {
+        if (hiding) {
+            return;
+        }
+        hiding = true;
+        try {
+            if (content != null) {
+                content.dispose();
+            }
+            super.hide();
+            if (source != null && source.isShowing()) {
+                source.hide();
+            }
+        } finally {
+            hiding = false;
+        }
+    }
+
+    @Override
+    public String getTypeSelector() {
+        return "ContextMenu";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Control.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Control.java
new file mode 100644
index 00000000000..af02b472515
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Control.java
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.events.FocusListener;
+import com.codename1.ui.geom.Dimension;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.geometry.Point2D;
+import javafx.scene.input.ContextMenuEvent;
+import javafx.scene.layout.Region;
+
+/// The base of the controls.
+///
+/// #### How a control is shown
+///
+/// A control is a region whose peer holds one Codename One component,
+/// the *native* component, below the peers of any child nodes. The
+/// subclass creates it in [#cn1CreateNative()], the first time the
+/// control's peer is needed, and copies the control's state into it in
+/// [#cn1SyncNative()], which runs after creation and whenever a property
+/// created with `Dirty.NATIVE` changes. The native component fills the
+/// control inside its insets.
+///
+/// The preferred size of a control is the preferred size of the native
+/// component, in logical pixels, plus the insets; its minimum and maximum
+/// are the preferred size unless a subclass says otherwise. A subclass
+/// whose native preferred size changed calls [#cn1NativeSizeChanged()].
+///
+/// There are no skins: `Skin`, `SkinBase` and the behaviour classes of
+/// JavaFX are not part of this layer, and a control looks as the Codename
+/// One theme makes the native component look. The region's own background
+/// and border are drawn behind it.
+///
+/// #### Context menu and tooltip
+///
+/// A control with a context menu opens it where a context menu is asked
+/// for, a secondary click or a long press, and consumes that event. A
+/// tooltip is installed with `Tooltip.install`, which hands its text to
+/// the native component.
+public abstract class Control extends Region {
+
+    private final ObjectProperty<ContextMenu> contextMenu = new SimpleObjectProperty<ContextMenu>(this,
+            "contextMenu");
+    private final ObjectProperty<Tooltip> tooltip = new SimpleObjectProperty<Tooltip>(this, "tooltip");
+    private Component nativeComponent;
+    private boolean creating;
+    private Region made;
+
+    /// Makes this control out of other nodes of the layer: `root` is its
+    /// one child, fills it inside its insets, and gives it its sizes. A
+    /// control that is made so has no native component.
+    final void cn1MadeOf(Region root) {
+        made = root;
+        cn1Children().setAll(root);
+        requestLayout();
+    }
+
+    /// Returns the node this control is made of, or `null` for one that
+    /// shows a native component.
+    final Region cn1Made() {
+        return made;
+    }
+
+    /// Creates a control.
+    protected Control() {
+        setFocusTraversable(true);
+        addEventHandler(ContextMenuEvent.CONTEXT_MENU_REQUESTED, new EventHandler<ContextMenuEvent>() {
+            @Override
+            public void handle(ContextMenuEvent event) {
+                ContextMenu menu = getContextMenu();
+                if (menu != null && !event.isConsumed()) {
+                    Point2D p = sceneToLocal(event.getSceneX(), event.getSceneY());
+                    Point2D at = com.codename1.fxcompat.runtime.StagePopup.anchor(Control.this, p.getX(), p.getY());
+                    menu.show(Control.this, at.getX(), at.getY());
+                    event.consume();
+                }
+            }
+        });
+        tooltip.addListener(new ChangeListener<Tooltip>() {
+            @Override
+            public void changed(ObservableValue<? extends Tooltip> observable, Tooltip oldValue, Tooltip newValue) {
+                if (oldValue != null) {
+                    Tooltip.uninstall(Control.this, oldValue);
+                }
+                if (newValue != null) {
+                    Tooltip.install(Control.this, newValue);
+                }
+            }
+        });
+    }
+
+    /// Sets the menu opened where a context menu is asked for.
+    public final void setContextMenu(ContextMenu value) {
+        contextMenu.set(value);
+    }
+
+    /// Returns the menu opened where a context menu is asked for.
+    public final ContextMenu getContextMenu() {
+        return contextMenu.get();
+    }
+
+    /// The menu opened where a context menu is asked for.
+    public final ObjectProperty<ContextMenu> contextMenuProperty() {
+        return contextMenu;
+    }
+
+    /// Sets the tooltip of this control.
+    public final void setTooltip(Tooltip value) {
+        tooltip.set(value);
+    }
+
+    /// Returns the tooltip of this control.
+    public final Tooltip getTooltip() {
+        return tooltip.get();
+    }
+
+    /// The tooltip of this control.
+    public final ObjectProperty<Tooltip> tooltipProperty() {
+        return tooltip;
+    }
+
+    /// Creates the Codename One component this control shows, or `null`
+    /// for a control made of child nodes only.
+    protected abstract Component cn1CreateNative();
+
+    /// Copies the state of this control into the native component. An
+    /// override calls the super implementation, which handles what every
+    /// control has: enabled and focusable.
+    protected void cn1SyncNative() {
+        if (nativeComponent != null) {
+            nativeComponent.setEnabled(!isDisabled());
+            nativeComponent.setFocusable(isFocusTraversable() && !isDisabled());
+        }
+    }
+
+    /// Returns the native component, creating the peer if needed; `null`
+    /// for a control without one.
+    public final Component cn1Native() {
+        cn1Peer();
+        return nativeComponent;
+    }
+
+    /// Returns the native component if the peer was created, else `null`.
+    protected final Component cn1NativeIfCreated() {
+        return nativeComponent;
+    }
+
+    @Override
+    protected int cn1PeerChildOffset() {
+        return nativeComponent == null ? 0 : 1;
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        creating = true;
+        try {
+            nativeComponent = cn1CreateNative();
+            if (nativeComponent != null) {
+                if (nativeComponent instanceof com.codename1.ui.Label) {
+                    // A Codename One label that is a pixel short of its text scrolls it
+                    // back and forth while the pointer is over it or it holds the focus:
+                    // a phone's answer to a narrow screen. JavaFX text never moves.
+                    ((com.codename1.ui.Label) nativeComponent).setTickerEnabled(false);
+                    // Text with no room ends in an ellipsis, which is the default
+                    // overrun of a JavaFX label. A Codename One label takes that from
+                    // the theme, where it is off unless the theme says otherwise.
+                    ((com.codename1.ui.Label) nativeComponent).setEndsWith3Points(true);
+                }
+                Component peer = cn1Peer();
+                if (peer instanceof Container) {
+                    ((Container) peer).addComponent(0, nativeComponent);
+                }
+                nativeComponent.addFocusListener(new FocusListener() {
+                    @Override
+                    public void focusGained(Component cmp) {
+                        if (getScene() != null) {
+                            getScene().cn1SetFocusOwner(Control.this, false);
+                        }
+                    }
+
+                    @Override
+                    public void focusLost(Component cmp) {
+                        if (getScene() != null && getScene().getFocusOwner() == Control.this) {
+                            getScene().cn1SetFocusOwner(null, false);
+                        }
+                    }
+                });
+            }
+        } finally {
+            creating = false;
+        }
+        super.cn1PeerCreated();
+        cn1SyncNative();
+        placeNative();
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & Dirty.NATIVE) != 0 && nativeComponent != null && !creating) {
+            cn1SyncNative();
+            nativeComponent.repaint();
+        }
+        super.cn1Invalidated(what);
+    }
+
+    /// Tells layout that the preferred size of the native component may
+    /// have changed.
+    protected final void cn1NativeSizeChanged() {
+        if (nativeComponent != null) {
+            nativeComponent.setShouldCalcPreferredSize(true);
+        }
+        requestLayout();
+    }
+
+    /// The room, in logical pixels, the control keeps for itself below the
+    /// native component (`below`) or to its right, inside its insets:
+    /// what the control draws next to a widget that cannot draw it, as a
+    /// slider draws its tick marks. Zero for none.
+    protected double cn1NativeBand(boolean below) {
+        return 0;
+    }
+
+    private void placeNative() {
+        if (nativeComponent == null || !cn1HasPeer()) {
+            return;
+        }
+        Component peer = cn1Peer();
+        Insets in = getInsets();
+        int left = Units.toPixels(in.getLeft());
+        int top = Units.toPixels(in.getTop());
+        int w = Math.max(0, peer.getWidth() - left - Units.toPixels(in.getRight() + cn1NativeBand(false)));
+        int h = Math.max(0, peer.getHeight() - top - Units.toPixels(in.getBottom() + cn1NativeBand(true)));
+        if (nativeComponent.getX() != left || nativeComponent.getY() != top || nativeComponent.getWidth() != w
+                || nativeComponent.getHeight() != h) {
+            nativeComponent.setX(left);
+            nativeComponent.setY(top);
+            nativeComponent.setWidth(w);
+            nativeComponent.setHeight(h);
+            if (nativeComponent instanceof Container) {
+                // The bounds are final, so lay out in place; revalidate()
+                // would walk up to the form. Invalidating the preferred
+                // size is the public way to flag the container for layout.
+                nativeComponent.setShouldCalcPreferredSize(true);
+                ((Container) nativeComponent).layoutContainer();
+            }
+        }
+    }
+
+    @Override
+    protected void cn1PeerResized() {
+        placeNative();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        placeNative();
+        if (made != null) {
+            Insets in = getInsets();
+            made.resizeRelocate(in.getLeft(), in.getTop(), Math.max(0, getWidth() - in.getLeft() - in.getRight()),
+                    Math.max(0, getHeight() - in.getTop() - in.getBottom()));
+            return;
+        }
+        super.layoutChildren();
+    }
+
+    /// Returns the preferred size of the native component in device
+    /// pixels; 0 by 0 without one.
+    protected Dimension cn1NativePreferredSize() {
+        Component c = cn1Native();
+        return c == null ? new Dimension(0, 0) : c.getPreferredSize();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        if (made != null) {
+            return in.getLeft() + made.prefWidth(height) + in.getRight();
+        }
+        return in.getLeft() + snapSizeX(Units.toLogical(cn1NativePreferredSize().getWidth())) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        if (made != null) {
+            return in.getTop() + made.prefHeight(width) + in.getBottom();
+        }
+        return in.getTop() + snapSizeY(Units.toLogical(cn1NativePreferredSize().getHeight())) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        if (made != null) {
+            Insets in = getInsets();
+            return in.getLeft() + made.minWidth(height) + in.getRight();
+        }
+        return computePrefWidth(height);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        if (made != null) {
+            Insets in = getInsets();
+            return in.getTop() + made.minHeight(width) + in.getBottom();
+        }
+        return computePrefHeight(width);
+    }
+
+    /// A control grows no larger than its preferred size, and that is the
+    /// preferred size the application set when it set one: a button with
+    /// no text given `setPrefSize(40, 40)` is 40 wide, not as wide as its
+    /// missing text.
+    @Override
+    protected double computeMaxWidth(double height) {
+        return prefWidth(height);
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return prefHeight(width);
+    }
+
+    @Override
+    public double getBaselineOffset() {
+        Component c = cn1Native();
+        if (c == null) {
+            return super.getBaselineOffset();
+        }
+        Dimension d = c.getPreferredSize();
+        int baseline = c.getBaseline(d.getWidth(), d.getHeight());
+        if (baseline < 0) {
+            return BASELINE_OFFSET_SAME_AS_HEIGHT;
+        }
+        return getInsets().getTop() + Units.toLogical(baseline);
+    }
+
+    @Override
+    protected void cn1FocusRequested() {
+        Component c = cn1NativeIfCreated();
+        if (c != null && c.isFocusable()) {
+            c.requestFocus();
+        }
+    }
+
+    @Override
+    public boolean isResizable() {
+        return true;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/DatePicker.java b/maven/javafx-compat/src/main/java/javafx/scene/control/DatePicker.java
new file mode 100644
index 00000000000..78a45931cb0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/DatePicker.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.spinner.Picker;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.scene.Scene;
+
+/// A control that holds a date and opens a chooser to pick another.
+///
+/// It is shown by a Codename One `Picker` in date mode: a button with the
+/// date, written as the device writes short dates, which opens the date
+/// picker of the platform when it is pressed. The prompt text shows while
+/// there is no date. A change of the value, by the user or from code,
+/// sends an `ActionEvent`.
+///
+/// The date is a day of the calendar of the device's time zone. The
+/// chronology, the converter, the day cell factory, the editor and the
+/// week numbers of JavaFX are not part of this layer.
+///
+/// ## Style
+///
+/// The style classes are `date-picker` and `combo-box-base`. The region
+/// properties apply around the picker; the picker itself is drawn by the
+/// Codename One theme.
+public class DatePicker extends ComboBoxBase<LocalDate> {
+
+    private boolean syncing;
+
+    /// Creates a date picker with no date.
+    public DatePicker() {
+        this(null);
+    }
+
+    /// Creates a date picker holding a date.
+    public DatePicker(LocalDate localDate) {
+        getStyleClass().add("date-picker");
+        valueRef().set(localDate);
+        showingRef().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
+                if (newValue != null && newValue.booleanValue()) {
+                    open();
+                } else {
+                    Component c = cn1NativeIfCreated();
+                    if (c instanceof Picker && ((Picker) c).isEditing()) {
+                        ((Picker) c).stopEditing(null);
+                    }
+                }
+            }
+        });
+    }
+
+    private static Date toDate(LocalDate d) {
+        Calendar c = Calendar.getInstance();
+        c.set(Calendar.YEAR, d.getYear());
+        c.set(Calendar.MONTH, d.getMonthValue() - 1);
+        c.set(Calendar.DAY_OF_MONTH, d.getDayOfMonth());
+        // Noon, so that a change of the clock cannot move the day.
+        c.set(Calendar.HOUR_OF_DAY, 12);
+        c.set(Calendar.MINUTE, 0);
+        c.set(Calendar.SECOND, 0);
+        c.set(Calendar.MILLISECOND, 0);
+        return c.getTime();
+    }
+
+    private static LocalDate toLocal(Date d) {
+        Calendar c = Calendar.getInstance();
+        c.setTime(d);
+        return LocalDate.of(c.get(Calendar.YEAR), c.get(Calendar.MONTH) + 1, c.get(Calendar.DAY_OF_MONTH));
+    }
+
+    private void open() {
+        Component c = cn1NativeIfCreated();
+        Scene s = getScene();
+        boolean onScreen = s != null && s.getWindow() != null && s.getWindow().isShowing();
+        if (onScreen && c instanceof Picker && !((Picker) c).isEditing()) {
+            ((Picker) c).startEditingAsync();
+        }
+    }
+
+    @Override
+    void chooserReopen() {
+        open();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        final Picker p = new Picker();
+        p.setType(Display.PICKER_TYPE_DATE);
+        p.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                picked(p, evt);
+            }
+        });
+        return p;
+    }
+
+    private void picked(Picker p, ActionEvent evt) {
+        if (syncing) {
+            return;
+        }
+        boolean committed = evt.getX() == -99 && evt.getY() == -99;
+        if (!committed && p.isEditing()) {
+            // The picker just opened; what it holds is not chosen yet.
+            chooserShown(true);
+            return;
+        }
+        Date d = p.getDate();
+        LocalDate picked = d == null ? null : toLocal(d);
+        LocalDate current = getValue();
+        if (picked == null ? current != null : !picked.equals(current)) {
+            setValue(picked);
+        }
+        chooserShown(false);
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c instanceof Picker) {
+            Picker p = (Picker) c;
+            syncing = true;
+            try {
+                LocalDate v = getValue();
+                p.setDate(v == null ? null : toDate(v));
+                if (v == null) {
+                    String prompt = getPromptText();
+                    p.setText(prompt == null ? "" : prompt);
+                }
+            } finally {
+                syncing = false;
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Dialog.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Dialog.java
new file mode 100644
index 00000000000..ee37f3abe83
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Dialog.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.Optional;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.ButtonBar.ButtonData;
+import javafx.stage.Modality;
+import javafx.stage.Stage;
+import javafx.stage.StageStyle;
+import javafx.stage.Window;
+import javafx.stage.WindowEvent;
+import javafx.util.Callback;
+
+/// A window that asks the user something and answers with a result.
+///
+/// A dialog shows a [DialogPane] in a stage of its own, modal to the
+/// application unless [#initModality(Modality)] says otherwise.
+/// [#showAndWait()] shows it and returns the result once it closed;
+/// [#show()] returns at once, and the result is read from
+/// [#resultProperty()] later.
+///
+/// Invoking a button of the pane hands its [ButtonType] to the result
+/// converter, makes what that returns the result, and closes the dialog.
+/// Without a converter the button type itself is the result. Setting the
+/// result from code closes the dialog too.
+///
+/// [#close()] without a result closes the dialog only if the pane has a
+/// single button or a cancel button, as in JavaFX; the result is then
+/// what the converter makes of the cancel button, or of `null` when the
+/// single button is not one. The same holds for the user closing the
+/// window, which a handler of `DialogEvent.DIALOG_CLOSE_REQUEST` can
+/// refuse by consuming the event.
+///
+/// `showAndWait()` returns a `java.util.Optional`, which the device class
+/// library provides and the older CLDC profile of Codename One does not.
+public class Dialog<R> implements EventTarget {
+
+    private final Stage stage = new Stage();
+    private final Scene scene;
+    private final ObjectProperty<DialogPane> dialogPane = new SimpleObjectProperty<DialogPane>(this, "dialogPane");
+    private final ObjectProperty<R> result = new SimpleObjectProperty<R>(this, "result");
+    private final ObjectProperty<Callback<ButtonType, R>> resultConverter =
+            new SimpleObjectProperty<Callback<ButtonType, R>>(this, "resultConverter");
+    private final EventHandlerManager events = new EventHandlerManager(this);
+    private boolean closing;
+
+    /// Creates a dialog with an empty pane.
+    public Dialog() {
+        stage.initModality(Modality.APPLICATION_MODAL);
+        DialogPane pane = new DialogPane();
+        pane.attach(this);
+        dialogPane.set(pane);
+        scene = new Scene(pane);
+        stage.setScene(scene);
+        dialogPane.addListener(new ChangeListener<DialogPane>() {
+            @Override
+            public void changed(ObservableValue<? extends DialogPane> observable, DialogPane oldValue,
+                    DialogPane newValue) {
+                if (oldValue != null) {
+                    oldValue.attach(null);
+                }
+                DialogPane next = newValue;
+                if (next == null) {
+                    next = new DialogPane();
+                    dialogPane.set(next);
+                    return;
+                }
+                next.attach(Dialog.this);
+                scene.setRoot(next);
+            }
+        });
+        result.addListener(new ChangeListener<R>() {
+            @Override
+            public void changed(ObservableValue<? extends R> observable, R oldValue, R newValue) {
+                close();
+            }
+        });
+        relay(WindowEvent.WINDOW_SHOWING, DialogEvent.DIALOG_SHOWING);
+        relay(WindowEvent.WINDOW_SHOWN, DialogEvent.DIALOG_SHOWN);
+        relay(WindowEvent.WINDOW_HIDING, DialogEvent.DIALOG_HIDING);
+        relay(WindowEvent.WINDOW_HIDDEN, DialogEvent.DIALOG_HIDDEN);
+        stage.addEventHandler(WindowEvent.WINDOW_CLOSE_REQUEST, new EventHandler<WindowEvent>() {
+            @Override
+            public void handle(WindowEvent event) {
+                DialogEvent request = new DialogEvent(Dialog.this, DialogEvent.DIALOG_CLOSE_REQUEST);
+                Event.fireEvent(Dialog.this, request);
+                if (!request.isConsumed()) {
+                    close();
+                }
+                if (stage.isShowing()) {
+                    // Refused: the window stays.
+                    event.consume();
+                }
+            }
+        });
+    }
+
+    private void relay(EventType<WindowEvent> from, final EventType<DialogEvent> to) {
+        stage.addEventHandler(from, new EventHandler<WindowEvent>() {
+            @Override
+            public void handle(WindowEvent event) {
+                Event.fireEvent(Dialog.this, new DialogEvent(Dialog.this, to));
+            }
+        });
+    }
+
+    /// Shows the dialog and returns at once.
+    public final void show() {
+        stage.show();
+    }
+
+    /// Shows the dialog and returns its result once it closed: empty when
+    /// it closed without one. Events keep being handled meanwhile.
+    public final Optional<R> showAndWait() {
+        stage.showAndWait();
+        return Optional.ofNullable(getResult());
+    }
+
+    /// Closes the dialog, if it has a result or may close without one.
+    public final void close() {
+        if (closing) {
+            return;
+        }
+        closing = true;
+        try {
+            if (getResult() == null) {
+                DialogPane pane = getDialogPane();
+                ButtonType cancel = null;
+                boolean allowed = pane.getButtonTypes().size() == 1;
+                for (int i = 0; i < pane.getButtonTypes().size(); i++) {
+                    ButtonType type = pane.getButtonTypes().get(i);
+                    ButtonData data = type == null ? null : type.getButtonData();
+                    if (data == null) {
+                        continue;
+                    }
+                    if (data == ButtonData.CANCEL_CLOSE) {
+                        cancel = type;
+                        break;
+                    }
+                    if (data.isCancelButton()) {
+                        cancel = type;
+                    }
+                }
+                if (cancel == null && !allowed) {
+                    return;
+                }
+                answer(cancel, false);
+            }
+            stage.hide();
+        } finally {
+            closing = false;
+        }
+    }
+
+    /// Closes the dialog; the same as [#close()].
+    public final void hide() {
+        close();
+    }
+
+    /// Makes the result of a chosen button and, when asked to and the
+    /// result did not change, closes the dialog; a changed result closes
+    /// it by itself.
+    @SuppressWarnings("unchecked")
+    final void answer(ButtonType chosen, boolean close) {
+        Callback<ButtonType, R> converter = getResultConverter();
+        R prior = getResult();
+        // Without a converter the dialog answers with the button type, as
+        // a dialog declared for that type expects.
+        R next = converter == null ? (R) chosen : converter.call(chosen);
+        setResult(next);
+        if (close && prior == next) {
+            close();
+        }
+    }
+
+    /// Sets how the dialog blocks other windows; before it is shown.
+    public final void initModality(Modality modality) {
+        stage.initModality(modality);
+    }
+
+    /// Returns how the dialog blocks other windows.
+    public final Modality getModality() {
+        return stage.getModality();
+    }
+
+    /// Sets the style of the window of the dialog; before it is shown.
+    public final void initStyle(StageStyle style) {
+        stage.initStyle(style);
+    }
+
+    /// Sets the window the dialog belongs to; before it is shown.
+    public final void initOwner(Window window) {
+        stage.initOwner(window);
+    }
+
+    /// Returns the window the dialog belongs to.
+    public final Window getOwner() {
+        return stage.getOwner();
+    }
+
+    /// The pane the dialog shows. Setting `null` puts an empty pane.
+    public final ObjectProperty<DialogPane> dialogPaneProperty() {
+        return dialogPane;
+    }
+
+    /// Returns the pane the dialog shows.
+    public final DialogPane getDialogPane() {
+        return dialogPane.get();
+    }
+
+    /// Sets the pane the dialog shows.
+    public final void setDialogPane(DialogPane value) {
+        dialogPane.set(value);
+    }
+
+    /// The content text of the pane.
+    public final StringProperty contentTextProperty() {
+        return getDialogPane().contentTextProperty();
+    }
+
+    /// Returns the content text of the pane.
+    public final String getContentText() {
+        return getDialogPane().getContentText();
+    }
+
+    /// Sets the content text of the pane.
+    public final void setContentText(String contentText) {
+        getDialogPane().setContentText(contentText);
+    }
+
+    /// The header text of the pane.
+    public final StringProperty headerTextProperty() {
+        return getDialogPane().headerTextProperty();
+    }
+
+    /// Returns the header text of the pane.
+    public final String getHeaderText() {
+        return getDialogPane().getHeaderText();
+    }
+
+    /// Sets the header text of the pane.
+    public final void setHeaderText(String headerText) {
+        getDialogPane().setHeaderText(headerText);
+    }
+
+    /// The graphic of the pane; recorded.
+    public final ObjectProperty<Node> graphicProperty() {
+        return getDialogPane().graphicProperty();
+    }
+
+    /// Returns the graphic of the pane.
+    public final Node getGraphic() {
+        return getDialogPane().getGraphic();
+    }
+
+    /// Sets the graphic of the pane; recorded.
+    public final void setGraphic(Node graphic) {
+        getDialogPane().setGraphic(graphic);
+    }
+
+    /// The result. Setting it closes the dialog.
+    public final ObjectProperty<R> resultProperty() {
+        return result;
+    }
+
+    /// Returns the result, `null` while there is none.
+    public final R getResult() {
+        return result.get();
+    }
+
+    /// Sets the result, which closes the dialog.
+    public final void setResult(R value) {
+        result.set(value);
+    }
+
+    /// Makes the result out of the button the user chose.
+    public final ObjectProperty<Callback<ButtonType, R>> resultConverterProperty() {
+        return resultConverter;
+    }
+
+    /// Returns what makes the result out of the button the user chose.
+    public final Callback<ButtonType, R> getResultConverter() {
+        return resultConverter.get();
+    }
+
+    /// Sets what makes the result out of the button the user chose.
+    public final void setResultConverter(Callback<ButtonType, R> value) {
+        resultConverter.set(value);
+    }
+
+    /// Whether the dialog is on screen.
+    public final ReadOnlyBooleanProperty showingProperty() {
+        return stage.showingProperty();
+    }
+
+    /// Returns whether the dialog is on screen.
+    public final boolean isShowing() {
+        return stage.isShowing();
+    }
+
+    /// Whether the user may resize the window of the dialog.
+    public final BooleanProperty resizableProperty() {
+        return stage.resizableProperty();
+    }
+
+    /// Returns whether the user may resize the window of the dialog.
+    public final boolean isResizable() {
+        return stage.isResizable();
+    }
+
+    /// Sets whether the user may resize the window of the dialog.
+    public final void setResizable(boolean resizable) {
+        stage.setResizable(resizable);
+    }
+
+    /// The title of the window of the dialog.
+    public final StringProperty titleProperty() {
+        return stage.titleProperty();
+    }
+
+    /// Returns the title of the window of the dialog.
+    public final String getTitle() {
+        return stage.getTitle();
+    }
+
+    /// Sets the title of the window of the dialog.
+    public final void setTitle(String title) {
+        stage.setTitle(title);
+    }
+
+    /// The width of the window of the dialog.
+    public final ReadOnlyDoubleProperty widthProperty() {
+        return stage.widthProperty();
+    }
+
+    /// Returns the width of the window of the dialog.
+    public final double getWidth() {
+        return stage.getWidth();
+    }
+
+    /// Sets the width of the window of the dialog.
+    public final void setWidth(double width) {
+        stage.setWidth(width);
+    }
+
+    /// The height of the window of the dialog.
+    public final ReadOnlyDoubleProperty heightProperty() {
+        return stage.heightProperty();
+    }
+
+    /// Returns the height of the window of the dialog.
+    public final double getHeight() {
+        return stage.getHeight();
+    }
+
+    /// Sets the height of the window of the dialog.
+    public final void setHeight(double height) {
+        stage.setHeight(height);
+    }
+
+    /// The x of the window of the dialog.
+    public final ReadOnlyDoubleProperty xProperty() {
+        return stage.xProperty();
+    }
+
+    /// Returns the x of the window of the dialog.
+    public final double getX() {
+        return stage.getX();
+    }
+
+    /// Sets the x of the window of the dialog.
+    public final void setX(double x) {
+        stage.setX(x);
+    }
+
+    /// The y of the window of the dialog.
+    public final ReadOnlyDoubleProperty yProperty() {
+        return stage.yProperty();
+    }
+
+    /// Returns the y of the window of the dialog.
+    public final double getY() {
+        return stage.getY();
+    }
+
+    /// Sets the y of the window of the dialog.
+    public final void setY(double y) {
+        stage.setY(y);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        return tail.prepend(events);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private ObjectProperty<EventHandler<DialogEvent>> slot(EventType<DialogEvent> type, String name) {
+        // The slot is typed for any handler of a super type of the event;
+        // these properties only ever hold handlers of the event itself.
+        return (ObjectProperty) events.slot(type, name);
+    }
+
+    /// The handler called before the dialog shows.
+    public final ObjectProperty<EventHandler<DialogEvent>> onShowingProperty() {
+        return slot(DialogEvent.DIALOG_SHOWING, "onShowing");
+    }
+
+    /// Sets the handler called before the dialog shows.
+    public final void setOnShowing(EventHandler<DialogEvent> value) {
+        onShowingProperty().set(value);
+    }
+
+    /// Returns the handler called before the dialog shows.
+    public final EventHandler<DialogEvent> getOnShowing() {
+        return onShowingProperty().get();
+    }
+
+    /// The handler called after the dialog showed.
+    public final ObjectProperty<EventHandler<DialogEvent>> onShownProperty() {
+        return slot(DialogEvent.DIALOG_SHOWN, "onShown");
+    }
+
+    /// Sets the handler called after the dialog showed.
+    public final void setOnShown(EventHandler<DialogEvent> value) {
+        onShownProperty().set(value);
+    }
+
+    /// Returns the handler called after the dialog showed.
+    public final EventHandler<DialogEvent> getOnShown() {
+        return onShownProperty().get();
+    }
+
+    /// The handler called before the dialog hides.
+    public final ObjectProperty<EventHandler<DialogEvent>> onHidingProperty() {
+        return slot(DialogEvent.DIALOG_HIDING, "onHiding");
+    }
+
+    /// Sets the handler called before the dialog hides.
+    public final void setOnHiding(EventHandler<DialogEvent> value) {
+        onHidingProperty().set(value);
+    }
+
+    /// Returns the handler called before the dialog hides.
+    public final EventHandler<DialogEvent> getOnHiding() {
+        return onHidingProperty().get();
+    }
+
+    /// The handler called after the dialog hid.
+    public final ObjectProperty<EventHandler<DialogEvent>> onHiddenProperty() {
+        return slot(DialogEvent.DIALOG_HIDDEN, "onHidden");
+    }
+
+    /// Sets the handler called after the dialog hid.
+    public final void setOnHidden(EventHandler<DialogEvent> value) {
+        onHiddenProperty().set(value);
+    }
+
+    /// Returns the handler called after the dialog hid.
+    public final EventHandler<DialogEvent> getOnHidden() {
+        return onHiddenProperty().get();
+    }
+
+    /// The handler called when the user asks the window to close.
+    public final ObjectProperty<EventHandler<DialogEvent>> onCloseRequestProperty() {
+        return slot(DialogEvent.DIALOG_CLOSE_REQUEST, "onCloseRequest");
+    }
+
+    /// Sets the handler called when the user asks the window to close.
+    public final void setOnCloseRequest(EventHandler<DialogEvent> value) {
+        onCloseRequestProperty().set(value);
+    }
+
+    /// Returns the handler called when the user asks the window to close.
+    public final EventHandler<DialogEvent> getOnCloseRequest() {
+        return onCloseRequestProperty().get();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/DialogEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogEvent.java
new file mode 100644
index 00000000000..973e306658d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogEvent.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.NamedArg;
+import javafx.event.Event;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// An event of a [Dialog]: it is showing, shown, hiding or hidden, or the
+/// user asked its window to close.
+public class DialogEvent extends Event {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The super type of every dialog event.
+    public static final EventType<DialogEvent> ANY = new EventType<DialogEvent>(Event.ANY, "DIALOG");
+
+    /// Sent before the dialog shows.
+    public static final EventType<DialogEvent> DIALOG_SHOWING = new EventType<DialogEvent>(ANY, "DIALOG_SHOWING");
+
+    /// Sent after the dialog showed.
+    public static final EventType<DialogEvent> DIALOG_SHOWN = new EventType<DialogEvent>(ANY, "DIALOG_SHOWN");
+
+    /// Sent before the dialog hides.
+    public static final EventType<DialogEvent> DIALOG_HIDING = new EventType<DialogEvent>(ANY, "DIALOG_HIDING");
+
+    /// Sent after the dialog hid.
+    public static final EventType<DialogEvent> DIALOG_HIDDEN = new EventType<DialogEvent>(ANY, "DIALOG_HIDDEN");
+
+    /// Sent when the user asks the window of the dialog to close. A
+    /// handler that consumes it keeps the dialog open.
+    public static final EventType<DialogEvent> DIALOG_CLOSE_REQUEST = new EventType<DialogEvent>(ANY,
+            "DIALOG_CLOSE_REQUEST");
+
+    /// Creates an event of a dialog.
+    public DialogEvent(@NamedArg("source") Dialog<?> source,
+            @NamedArg("eventType") EventType<? extends Event> eventType) {
+        super(source, source, eventType);
+    }
+
+    @Override
+    public DialogEvent copyFor(Object newSource, EventTarget newTarget) {
+        Event copy = super.copyFor(newSource, newTarget);
+        return copy instanceof DialogEvent ? (DialogEvent) copy : this;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<DialogEvent> getEventType() {
+        return (EventType<DialogEvent>) super.getEventType();
+    }
+
+    @Override
+    public String toString() {
+        return "DialogEvent[source=" + getSource() + ", eventType=" + getEventType() + ", consumed=" + isConsumed()
+                + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/DialogField.java b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogField.java
new file mode 100644
index 00000000000..a1221e01bb6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogField.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.TextField;
+
+/// The line of text a [TextInputDialog] edits: a Codename One text field
+/// and nothing more.
+final class DialogField extends Control {
+
+    private String text;
+
+    DialogField(String text) {
+        this.text = text == null ? "" : text;
+    }
+
+    /// Returns the text as the user left it.
+    String text() {
+        Component c = cn1NativeIfCreated();
+        if (c instanceof TextField) {
+            String t = ((TextField) c).getText();
+            text = t == null ? "" : t;
+        }
+        return text;
+    }
+
+    /// Replaces the text.
+    void text(String value) {
+        text = value == null ? "" : value;
+        Component c = cn1NativeIfCreated();
+        if (c instanceof TextField) {
+            ((TextField) c).setText(text);
+        }
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return new TextField(text);
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        return Math.max(160, super.computePrefWidth(height));
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/DialogPane.java b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogPane.java
new file mode 100644
index 00000000000..0c106113b6f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogPane.java
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.control.ButtonBar.ButtonData;
+import javafx.scene.layout.Pane;
+
+/// The content of a [Dialog]: a header text, a content, and a row of
+/// buttons.
+///
+/// The content is the node set with [#setContent(Node)], or else the
+/// content text. The pane makes one button for each [ButtonType] in
+/// [#getButtonTypes()], with [#createButton(ButtonType)], and shows them
+/// right aligned at the bottom, in the order of the list; the order of
+/// the platform that JavaFX applies is not part of this layer. Invoking a
+/// button answers the dialog with its type and closes it, unless a
+/// handler of the button consumed the `ActionEvent` first.
+///
+/// The graphic is recorded and not drawn. An expandable content is shown
+/// under the content by a `Show Details` link, in the window as it is: the
+/// dialog does not grow for it, so it takes room from the content. The header node, the expandable
+/// content and the style sheet of the JavaFX pane are absent.
+///
+/// ## Style
+///
+/// The style class is `dialog-pane`; the header is a label with the
+/// class `header`, the content text one with `content`. The region
+/// properties (`-fx-background-color`, `-fx-border-color`, `-fx-padding`)
+/// apply to the pane.
+public class DialogPane extends Pane {
+
+    private static final double PAD = 12;
+    private static final double GAP = 8;
+    private static final double MIN_WIDTH = 240;
+
+    private final ObservableList<ButtonType> buttons = FXCollections.observableArrayList();
+    private final ArrayList<ButtonType> buttonKeys = new ArrayList<ButtonType>();
+    private final ArrayList<Node> buttonNodes = new ArrayList<Node>();
+    private final StringProperty headerText = new SimpleStringProperty(this, "headerText");
+    private final StringProperty contentText = new SimpleStringProperty(this, "contentText");
+    private final ObjectProperty<Node> content = new SimpleObjectProperty<Node>(this, "content");
+    private final ObjectProperty<Node> graphic = new SimpleObjectProperty<Node>(this, "graphic");
+    private final ObjectProperty<Node> expandableContent = new SimpleObjectProperty<Node>(this,
+            "expandableContent");
+    private final javafx.beans.property.BooleanProperty expanded =
+            new javafx.beans.property.SimpleBooleanProperty(this, "expanded", false);
+    private final Hyperlink detailsLink = new Hyperlink();
+    private final javafx.scene.layout.VBox withDetails = new javafx.scene.layout.VBox(PAD);
+    private final Label headerLabel = new Label();
+    private final Label contentLabel = new Label();
+    private Dialog<?> dialog;
+
+    /// Creates a pane with no text and no buttons.
+    public DialogPane() {
+        getStyleClass().add("dialog-pane");
+        headerLabel.getStyleClass().add("header");
+        headerLabel.setFocusTraversable(false);
+        contentLabel.getStyleClass().add("content");
+        contentLabel.setFocusTraversable(false);
+        ChangeListener<Object> rebuild = new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                rebuild();
+            }
+        };
+        headerText.addListener(rebuild);
+        contentText.addListener(rebuild);
+        content.addListener(rebuild);
+        expandableContent.addListener(rebuild);
+        expanded.addListener(rebuild);
+        detailsLink.getStyleClass().add("details-button");
+        detailsLink.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                setExpanded(!isExpanded());
+            }
+        });
+        buttons.addListener(new ListChangeListener<ButtonType>() {
+            @Override
+            public void onChanged(Change<? extends ButtonType> change) {
+                buttonsChanged();
+            }
+        });
+    }
+
+    /// Records the dialog this pane answers.
+    final void attach(Dialog<?> value) {
+        dialog = value;
+    }
+
+    private static boolean blank(String s) {
+        return s == null || s.length() == 0;
+    }
+
+    private void buttonsChanged() {
+        ArrayList<ButtonType> keys = new ArrayList<ButtonType>();
+        ArrayList<Node> nodes = new ArrayList<Node>();
+        for (int i = 0; i < buttons.size(); i++) {
+            ButtonType type = buttons.get(i);
+            if (type == null || keys.contains(type)) {
+                continue;
+            }
+            int old = buttonKeys.indexOf(type);
+            Node node = old >= 0 ? buttonNodes.get(old) : createButton(type);
+            if (node != null) {
+                keys.add(type);
+                nodes.add(node);
+            }
+        }
+        buttonKeys.clear();
+        buttonKeys.addAll(keys);
+        buttonNodes.clear();
+        buttonNodes.addAll(nodes);
+        rebuild();
+    }
+
+    private Node plainBody() {
+        Node c = content.get();
+        if (c != null) {
+            return c;
+        }
+        return blank(contentText.get()) ? null : contentLabel;
+    }
+
+    /// What is between the header and the buttons: the content, and with
+    /// an expandable content the link that shows it and, once expanded,
+    /// that content under it.
+    private Node body() {
+        Node plain = plainBody();
+        Node more = expandableContent.get();
+        if (more == null) {
+            return plain;
+        }
+        ArrayList<Node> all = new ArrayList<Node>();
+        if (plain != null) {
+            all.add(plain);
+        }
+        detailsLink.setText(isExpanded() ? "Hide Details" : "Show Details");
+        all.add(detailsLink);
+        if (isExpanded()) {
+            all.add(more);
+        }
+        if (!all.equals(withDetails.getChildren())) {
+            withDetails.getChildren().setAll(all);
+        }
+        return withDetails;
+    }
+
+    private void rebuild() {
+        headerLabel.setText(blank(headerText.get()) ? "" : headerText.get());
+        contentLabel.setText(blank(contentText.get()) ? "" : contentText.get());
+        ArrayList<Node> all = new ArrayList<Node>();
+        if (!blank(headerText.get())) {
+            all.add(headerLabel);
+        }
+        Node body = body();
+        if (body != null && !all.contains(body)) {
+            all.add(body);
+        }
+        for (int i = 0; i < buttonNodes.size(); i++) {
+            if (!all.contains(buttonNodes.get(i))) {
+                all.add(buttonNodes.get(i));
+            }
+        }
+        cn1Children().setAll(all);
+        requestLayout();
+    }
+
+    /// Returns the button types of the pane; it shows a button for each.
+    public final ObservableList<ButtonType> getButtonTypes() {
+        return buttons;
+    }
+
+    /// Returns the button the pane made for a button type, or `null` when
+    /// the type is not among the button types.
+    public final Node lookupButton(ButtonType buttonType) {
+        int i = buttonKeys.indexOf(buttonType);
+        return i < 0 ? null : buttonNodes.get(i);
+    }
+
+    /// Makes the button of a button type: a [Button] with the text of the
+    /// type that answers the dialog with the type when it is invoked. A
+    /// subclass may return another node; answering the dialog is then up
+    /// to that node.
+    protected Node createButton(final ButtonType buttonType) {
+        Button button = new Button(buttonType.getText());
+        ButtonData data = buttonType.getButtonData();
+        if (data != null) {
+            button.setDefaultButton(data.isDefaultButton());
+            button.setCancelButton(data.isCancelButton());
+        }
+        button.addEventHandler(ActionEvent.ACTION, new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                if (!event.isConsumed() && dialog != null) {
+                    dialog.answer(buttonType, true);
+                }
+            }
+        });
+        return button;
+    }
+
+    /// The text above the content.
+    public final StringProperty headerTextProperty() {
+        return headerText;
+    }
+
+    /// Sets the text above the content.
+    public final void setHeaderText(String value) {
+        headerText.set(value);
+    }
+
+    /// Returns the text above the content.
+    public final String getHeaderText() {
+        return headerText.get();
+    }
+
+    /// The text shown as the content while there is no content node.
+    public final StringProperty contentTextProperty() {
+        return contentText;
+    }
+
+    /// Sets the text shown as the content.
+    public final void setContentText(String value) {
+        contentText.set(value);
+    }
+
+    /// Returns the text shown as the content.
+    public final String getContentText() {
+        return contentText.get();
+    }
+
+    /// The node shown as the content, in place of the content text.
+    public final ObjectProperty<Node> contentProperty() {
+        return content;
+    }
+
+    /// Sets the node shown as the content.
+    public final void setContent(Node value) {
+        content.set(value);
+    }
+
+    /// Returns the node shown as the content.
+    public final Node getContent() {
+        return content.get();
+    }
+
+    /// The graphic of the header; recorded.
+    public final ObjectProperty<Node> graphicProperty() {
+        return graphic;
+    }
+
+    /// Sets the graphic of the header; recorded.
+    public final void setGraphic(Node value) {
+        graphic.set(value);
+    }
+
+    /// Returns the graphic of the header.
+    public final Node getGraphic() {
+        return graphic.get();
+    }
+
+    private boolean headerShown() {
+        return !blank(headerText.get());
+    }
+
+    private double buttonsWidth() {
+        double w = 0;
+        for (int i = 0; i < buttonNodes.size(); i++) {
+            w += buttonNodes.get(i).prefWidth(-1) + (i > 0 ? GAP : 0);
+        }
+        return w;
+    }
+
+    private double buttonsHeight() {
+        double h = 0;
+        for (int i = 0; i < buttonNodes.size(); i++) {
+            h = Math.max(h, buttonNodes.get(i).prefHeight(-1));
+        }
+        return h;
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        double w = Math.max(MIN_WIDTH, buttonsWidth());
+        if (headerShown()) {
+            w = Math.max(w, headerLabel.prefWidth(-1));
+        }
+        Node body = body();
+        if (body != null) {
+            w = Math.max(w, body.prefWidth(-1));
+        }
+        Insets in = getInsets();
+        return in.getLeft() + PAD + w + PAD + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        double h = PAD;
+        if (headerShown()) {
+            h += headerLabel.prefHeight(-1) + PAD;
+        }
+        Node body = body();
+        if (body != null) {
+            h += body.prefHeight(-1) + PAD;
+        }
+        if (!buttonNodes.isEmpty()) {
+            h += buttonsHeight() + PAD;
+        }
+        Insets in = getInsets();
+        return in.getTop() + h + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return computePrefWidth(height);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return computePrefHeight(width);
+    }
+
+    private static void place(Node node, double x, double y, double w, double h) {
+        if (node.isResizable()) {
+            node.resize(w, h);
+        }
+        node.relocate(x - node.getLayoutBounds().getMinX(), y - node.getLayoutBounds().getMinY());
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double x = in.getLeft() + PAD;
+        double w = Math.max(0, getWidth() - x - PAD - in.getRight());
+        double y = in.getTop() + PAD;
+        double bottom = getHeight() - in.getBottom() - PAD;
+        if (headerShown()) {
+            double h = headerLabel.prefHeight(-1);
+            place(headerLabel, x, y, w, h);
+            y += h + PAD;
+        }
+        if (!buttonNodes.isEmpty()) {
+            double h = buttonsHeight();
+            double bx = x + w;
+            for (int i = buttonNodes.size() - 1; i >= 0; i--) {
+                Node b = buttonNodes.get(i);
+                double bw = b.prefWidth(-1);
+                bx -= bw;
+                place(b, bx, bottom - h, bw, h);
+                bx -= GAP;
+            }
+            bottom -= h + PAD;
+        }
+        Node body = body();
+        if (body != null) {
+            place(body, x, y, w, Math.max(0, bottom - y));
+        }
+    }
+
+    /// What a `Show Details` link shows under the content.
+    public final ObjectProperty<Node> expandableContentProperty() {
+        return expandableContent;
+    }
+
+    /// Sets what a `Show Details` link shows under the content.
+    public final void setExpandableContent(Node value) {
+        expandableContent.set(value);
+    }
+
+    /// Returns what a `Show Details` link shows under the content.
+    public final Node getExpandableContent() {
+        return expandableContent.get();
+    }
+
+    /// Whether the expandable content is shown.
+    public final javafx.beans.property.BooleanProperty expandedProperty() {
+        return expanded;
+    }
+
+    /// Shows or hides the expandable content.
+    public final void setExpanded(boolean value) {
+        expanded.set(value);
+    }
+
+    /// Returns whether the expandable content is shown.
+    public final boolean isExpanded() {
+        return expanded.get();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/DialogRow.java b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogRow.java
new file mode 100644
index 00000000000..e23ce650fa5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/DialogRow.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.Insets;
+import javafx.scene.layout.Region;
+
+/// The content of an input dialog: a label, and to its right the control
+/// the user answers with, which takes the rest of the width. It listens
+/// to the content text of the dialog and shows it in the label.
+final class DialogRow extends Region implements ChangeListener<String> {
+
+    private static final double GAP = 10;
+
+    private final Label label = new Label();
+    private final Control field;
+
+    DialogRow(Control field) {
+        this.field = field;
+        label.setFocusTraversable(false);
+        cn1Children().add(label);
+        cn1Children().add(field);
+    }
+
+    /// Shows the content text of the dialog in the label.
+    @Override
+    public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
+        label.setText(newValue == null ? "" : newValue);
+        requestLayout();
+    }
+
+    private double labelWidth() {
+        String t = label.getText();
+        return t == null || t.length() == 0 ? 0 : label.prefWidth(-1) + GAP;
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + labelWidth() + field.prefWidth(-1) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + Math.max(label.prefHeight(-1), field.prefHeight(-1)) + in.getBottom();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double w = Math.max(0, getWidth() - x - in.getRight());
+        double h = Math.max(0, getHeight() - y - in.getBottom());
+        double lw = labelWidth();
+        double lh = label.prefHeight(-1);
+        double fh = Math.min(h, field.prefHeight(-1));
+        label.setVisible(lw > 0);
+        label.resizeRelocate(x, y + Math.max(0, (h - lh) / 2), Math.max(0, lw - GAP), lh);
+        field.resizeRelocate(x + lw, y + Math.max(0, (h - fh) / 2), Math.max(0, w - lw), fh);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Hyperlink.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Hyperlink.java
new file mode 100644
index 00000000000..e5a7f6bcf8d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Hyperlink.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.ui.Component;
+import com.codename1.ui.plaf.Border;
+import com.codename1.ui.plaf.Style;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.BooleanProperty;
+import javafx.css.PseudoClass;
+import javafx.event.ActionEvent;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+
+/// Text that is pressed like a link, shown as a Codename One `Button`
+/// without a border.
+///
+/// Invoking it marks it visited and fires an `ActionEvent`; opening
+/// anything is up to the handler. The `visited` pseudo-class follows the
+/// visited property.
+///
+/// A link without a text fill of its own is drawn in the accent colour of
+/// JavaFX, and in the colour of plain text once it was visited. The text
+/// is underlined while the pointer is over the link or the link is
+/// pressed or armed, and always when `setUnderline(true)` asked for it.
+public class Hyperlink extends ButtonBase {
+
+    private static final int VISITED = Dirty.USER;
+    private static final PseudoClass VISITED_STATE = PseudoClass.getPseudoClass("visited");
+
+    private static final Color LINK_TEXT = Color.rgb(0, 150, 201);
+    private static final Color VISITED_TEXT = Color.gray(0.2);
+
+    private final BooleanProperty visited = new FxBoolean(this, "visited", false, VISITED | Dirty.NATIVE);
+
+    /// Creates a hyperlink with no text.
+    public Hyperlink() {
+        init();
+    }
+
+    /// Creates a hyperlink with text.
+    public Hyperlink(String text) {
+        super(text);
+        init();
+    }
+
+    /// Creates a hyperlink with text and a graphic.
+    public Hyperlink(String text, Node graphic) {
+        super(text, graphic);
+        init();
+    }
+
+    private void init() {
+        getStyleClass().add("hyperlink");
+        // The line under the text comes and goes with the pointer.
+        InvalidationListener look = new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                cn1Invalidated(Dirty.NATIVE);
+            }
+        };
+        hoverProperty().addListener(look);
+        armedProperty().addListener(look);
+        pressedProperty().addListener(look);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.Button b = new com.codename1.ui.Button();
+        Style s = com.codename1.fxcompat.runtime.PeerPaint.allStyles(b);
+        s.setBorder(Border.createEmpty());
+        s.setBgTransparency(0);
+        b.addActionListener(cn1ActionBridge());
+        return b;
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c != null) {
+            Style s = com.codename1.fxcompat.runtime.PeerPaint.allStyles(c);
+            if (textFillProperty().get() == null) {
+                s.setFgColor((isVisited() ? VISITED_TEXT : LINK_TEXT).cn1Argb() & 0xffffff);
+                s.setOpacity(255);
+            }
+            boolean line = isUnderline() || isHover() || isArmed() || isPressed();
+            s.setTextDecoration(line ? Style.TEXT_DECORATION_UNDERLINE : Style.TEXT_DECORATION_NONE);
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & VISITED) != 0) {
+            pseudoClassStateChanged(VISITED_STATE, isVisited());
+        }
+        super.cn1Invalidated(what);
+    }
+
+    /// Marks the link visited and fires an `ActionEvent`.
+    @Override
+    public void fire() {
+        if (!isDisabled()) {
+            if (!visited.isBound()) {
+                setVisited(true);
+            }
+            fireEvent(new ActionEvent(this, this));
+        }
+    }
+
+    /// Returns whether the link was invoked before.
+    public final boolean isVisited() {
+        return visited.get();
+    }
+
+    /// Sets whether the link counts as invoked before.
+    public final void setVisited(boolean value) {
+        visited.set(value);
+    }
+
+    /// Whether the link was invoked before.
+    public final BooleanProperty visitedProperty() {
+        return visited;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/IndexRange.java b/maven/javafx-compat/src/main/java/javafx/scene/control/IndexRange.java
new file mode 100644
index 00000000000..73595bb1772
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/IndexRange.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.NamedArg;
+
+/// A range of positions between two indexes, the start included and the
+/// end not.
+public final class IndexRange {
+
+    /// What separates the two numbers in the text form of a range.
+    public static final String VALUE_DELIMITER = ",";
+
+    private final int start;
+    private final int end;
+
+    /// Creates a range.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the end is before the start
+    public IndexRange(@NamedArg("start") int start, @NamedArg("end") int end) {
+        if (end < start) {
+            throw new IllegalArgumentException("The end of a range must not be before its start");
+        }
+        this.start = start;
+        this.end = end;
+    }
+
+    /// Creates a copy of a range.
+    public IndexRange(@NamedArg("range") IndexRange range) {
+        this.start = range.start;
+        this.end = range.end;
+    }
+
+    /// Returns the first index of the range.
+    public int getStart() {
+        return start;
+    }
+
+    /// Returns the index after the last one of the range.
+    public int getEnd() {
+        return end;
+    }
+
+    /// Returns the number of indexes in the range.
+    public int getLength() {
+        return end - start;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (object == this) {
+            return true;
+        }
+        if (object instanceof IndexRange) {
+            IndexRange other = (IndexRange) object;
+            return start == other.start && end == other.end;
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 * start + end;
+    }
+
+    @Override
+    public String toString() {
+        return start + VALUE_DELIMITER + " " + end;
+    }
+
+    /// Creates a range from two indexes in either order.
+    public static IndexRange normalize(int v1, int v2) {
+        return new IndexRange(Math.min(v1, v2), Math.max(v1, v2));
+    }
+
+    /// Parses a range written as `start,end`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the text is not two integers
+    ///   separated by a comma
+    public static IndexRange valueOf(String value) {
+        if (value == null) {
+            throw new IllegalArgumentException("A range is two numbers separated by a comma");
+        }
+        int comma = value.indexOf(',');
+        if (comma < 0 || value.indexOf(',', comma + 1) >= 0) {
+            throw new IllegalArgumentException("A range is two numbers separated by a comma");
+        }
+        int s = Integer.parseInt(value.substring(0, comma).trim());
+        int e = Integer.parseInt(value.substring(comma + 1).trim());
+        return normalize(s, e);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/IndexedCell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/IndexedCell.java
new file mode 100644
index 00000000000..42113184fee
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/IndexedCell.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.property.ReadOnlyIntegerWrapper;
+import javafx.css.PseudoClass;
+
+/// A cell that shows the row at an index of its view. The pseudo-class
+/// states `even` and `odd` follow the index.
+public class IndexedCell<T> extends Cell<T> {
+
+    private static final PseudoClass ODD = PseudoClass.getPseudoClass("odd");
+    private static final PseudoClass EVEN = PseudoClass.getPseudoClass("even");
+
+    private final ReadOnlyIntegerWrapper index = new ReadOnlyIntegerWrapper(this, "index", -1);
+
+    /// Creates a cell that shows no row.
+    public IndexedCell() {
+        getStyleClass().add("indexed-cell");
+    }
+
+    /// Returns the row this cell shows, -1 for none.
+    public final int getIndex() {
+        return index.get();
+    }
+
+    /// The row this cell shows.
+    public final ReadOnlyIntegerProperty indexProperty() {
+        return index.getReadOnlyProperty();
+    }
+
+    /// Gives the cell another row to show; a view does.
+    public void updateIndex(int i) {
+        int old = index.get();
+        if (old != i) {
+            index.set(i);
+            boolean even = i % 2 == 0;
+            pseudoClassStateChanged(EVEN, i >= 0 && even);
+            pseudoClassStateChanged(ODD, i >= 0 && !even);
+        }
+        indexChanged(old, i);
+    }
+
+    /// Called after every [#updateIndex(int)], changed or not: a subclass
+    /// fetches the item of the row here.
+    void indexChanged(int oldIndex, int newIndex) {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Label.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Label.java
new file mode 100644
index 00000000000..251f8da8b67
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Label.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+
+/// A line of text that the user cannot edit, shown as a Codename One
+/// `Label`.
+public class Label extends Labeled {
+
+    private final ObjectProperty<Node> labelFor = new SimpleObjectProperty<Node>(this, "labelFor");
+
+    /// Creates a label with no text.
+    public Label() {
+        init();
+    }
+
+    /// Creates a label with text.
+    public Label(String text) {
+        super(text);
+        init();
+    }
+
+    /// Creates a label with text and a graphic.
+    public Label(String text, Node graphic) {
+        super(text, graphic);
+        init();
+    }
+
+    private void init() {
+        getStyleClass().add("label");
+        setFocusTraversable(false);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return new com.codename1.ui.Label();
+    }
+
+    @Override
+    boolean cn1BareText() {
+        return true;
+    }
+
+    /// Returns the control this label describes, or `null`.
+    public final Node getLabelFor() {
+        return labelFor.get();
+    }
+
+    /// Sets the control this label describes.
+    public final void setLabelFor(Node value) {
+        labelFor.set(value);
+    }
+
+    /// The control this label describes.
+    public final ObjectProperty<Node> labelForProperty() {
+        return labelFor;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Labeled.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Labeled.java
new file mode 100644
index 00000000000..9be54fa3e22
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Labeled.java
@@ -0,0 +1,784 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.Mnemonics;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxString;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.plaf.Style;
+import com.codename1.ui.plaf.UIManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontPosture;
+import javafx.scene.text.FontWeight;
+import javafx.scene.text.TextAlignment;
+
+/// A control with text: labels, buttons, check boxes and the like.
+///
+/// The native component is a Codename One `Label` or one of its
+/// subclasses; text, text colour, font, alignment, underline and the gap
+/// to the icon are copied into it. A font or colour that was never set
+/// leaves the theme's own in place. A plain native label, as a `Label`
+/// and a cell have, is made transparent and borderless whatever the
+/// theme gives it: in JavaFX a label has no background but the one of
+/// its region.
+///
+/// The graphic node is a child of the control, above the native label,
+/// placed beside the text where `contentDisplay` says and
+/// `graphicTextGap` away from it; the label's padding makes the room, so
+/// the preferred size covers both. A text too long for the control is cut
+/// short and ends in three points, and the minimum width is the width of
+/// those. `wrapText`, `ellipsisString`, `textOverrun`, `lineSpacing` are
+/// recorded or absent and have no effect on a single line native label.
+///
+/// With `mnemonicParsing` on, as it is for every button and off for a
+/// label, the underscore that marks a mnemonic is taken out of the text
+/// shown, as `com.codename1.fxcompat.runtime.Mnemonics` describes; the
+/// mnemonic itself does nothing, there being no key to hold for it.
+///
+/// Styled through `cn1ApplyStyle` with the `Labeled` names listed in
+/// `com.codename1.fxcompat.runtime.StyleTarget`.
+public abstract class Labeled extends Control {
+
+    private static final int TEXT = Dirty.NATIVE | Dirty.LAYOUT;
+
+    private final StringProperty text = new FxString(this, "text", "", TEXT);
+    private final ObjectProperty<Font> font = new FxObject<Font>(this, "font", null, TEXT);
+    private final ObjectProperty<Paint> textFill = new FxObject<Paint>(this, "textFill", null, Dirty.NATIVE);
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.CENTER_LEFT,
+            Dirty.NATIVE);
+    private final ObjectProperty<TextAlignment> textAlignment = new FxObject<TextAlignment>(this, "textAlignment",
+            TextAlignment.LEFT, Dirty.NATIVE);
+    private final BooleanProperty wrapText = new FxBoolean(this, "wrapText", false, TEXT);
+    private final BooleanProperty underline = new FxBoolean(this, "underline", false, Dirty.NATIVE);
+    private final ObjectProperty<Node> graphic = new FxObject<Node>(this, "graphic", null, TEXT);
+    private final DoubleProperty graphicTextGap = new FxDouble(this, "graphicTextGap", 4, TEXT);
+    private final ObjectProperty<ContentDisplay> contentDisplay = new FxObject<ContentDisplay>(this,
+            "contentDisplay", ContentDisplay.LEFT, TEXT);
+
+    private final BooleanProperty mnemonicParsing = new FxBoolean(this, "mnemonicParsing", false, TEXT);
+    private Node graphicChild;
+    private boolean paddedForGraphic;
+    private int shedLeft;
+    private int shedRight;
+    private int keptLeft = -1;
+    private int keptRight = -1;
+
+    {
+        ChangeListener<Object> shown = new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                syncGraphicChild();
+            }
+        };
+        graphic.addListener(shown);
+        contentDisplay.addListener(shown);
+    }
+
+    /// Creates a labeled control with no text.
+    public Labeled() {
+    }
+
+    /// Creates a labeled control with text.
+    public Labeled(String text) {
+        setText(text);
+    }
+
+    /// Creates a labeled control with text and a graphic.
+    public Labeled(String text, Node graphic) {
+        setText(text);
+        setGraphic(graphic);
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & Dirty.NATIVE) != 0 && (what & Dirty.LAYOUT) != 0) {
+            Component c = cn1NativeIfCreated();
+            if (c != null) {
+                c.setShouldCalcPreferredSize(true);
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (!(c instanceof com.codename1.ui.Label)) {
+            return;
+        }
+        com.codename1.ui.Label label = (com.codename1.ui.Label) c;
+        String t = isMnemonicParsing() ? Mnemonics.strip(getText()) : getText();
+        label.setText(t == null || getContentDisplay() == ContentDisplay.GRAPHIC_ONLY ? "" : t);
+        Style style = com.codename1.fxcompat.runtime.PeerPaint.allStyles(label);
+        if (c.getClass() == com.codename1.ui.Label.class) {
+            style.setBgTransparency(0);
+            style.setBorder(com.codename1.ui.plaf.Border.createEmpty());
+        }
+        // A JavaFX label is its text and nothing around it; the room a
+        // Codename One theme gives a label made every one a few pixels
+        // taller and wider than the application laid it out for.
+        boolean bare = cn1BareText();
+        if (bare) {
+            style.setPaddingUnit(Style.UNIT_TYPE_PIXELS);
+            style.setPadding(0, 0, 0, 0);
+            style.setMarginUnit(Style.UNIT_TYPE_PIXELS);
+            style.setMargin(0, 0, 0, 0);
+        }
+        Paint fill = getTextFill();
+        if (fill instanceof Color) {
+            int argb = ((Color) fill).cn1Argb();
+            style.setFgColor(argb & 0xffffff);
+            style.setOpacity(argb >>> 24);
+        }
+        Font f = font.get();
+        if (f != null) {
+            style.setFont(Fonts.of(f));
+        }
+        style.setTextDecoration(isUnderline() ? Style.TEXT_DECORATION_UNDERLINE : Style.TEXT_DECORATION_NONE);
+        Pos pos = getAlignment();
+        HPos h = pos == null ? HPos.LEFT : pos.getHpos();
+        label.setAlignment(h == HPos.CENTER ? Component.CENTER : (h == HPos.RIGHT ? Component.RIGHT : Component.LEFT));
+        label.setGap(Units.toPixels(getGraphicTextGap()));
+        Node g = shownGraphic();
+        if (g != null || paddedForGraphic) {
+            // The graphic is a node above the native label, which knows
+            // nothing of it: the label's padding grows by the room the
+            // graphic takes, so the text is drawn beside it and the
+            // preferred size of the label covers both.
+            Style base = UIManager.getInstance().getComponentStyle(label.getUIID());
+            int[] room = g == null ? new int[GRAPHIC_BOX] : graphicBox(label, g);
+            style.setPaddingUnit(Style.UNIT_TYPE_PIXELS);
+            if (bare) {
+                style.setPadding(room[0], room[1], room[2], room[3]);
+            } else {
+                style.setPadding(base.getPaddingTop() + room[0], base.getPaddingBottom() + room[1],
+                        base.getPaddingLeftNoRTL() + room[2], base.getPaddingRightNoRTL() + room[3]);
+            }
+            paddedForGraphic = g != null;
+        }
+    }
+
+    /// Whether the native component is text alone, with none of the
+    /// padding or margin a theme gives one. True of a label.
+    boolean cn1BareText() {
+        return false;
+    }
+
+    private static final int GRAPHIC_BOX = 9;
+
+    /// Whether a subclass places the graphic itself, as a cell does; this
+    /// class then leaves the graphic and the padding of the label alone.
+    boolean ownsGraphic() {
+        return false;
+    }
+
+    /// Returns the graphic this class shows beside the text, or `null`.
+    private Node shownGraphic() {
+        Node g = getGraphic();
+        return g == null || ownsGraphic() || getContentDisplay() == ContentDisplay.TEXT_ONLY ? null : g;
+    }
+
+    /// Keeps the shown graphic a child of this control, so that it has a
+    /// peer above the native label.
+    private void syncGraphicChild() {
+        Node g = shownGraphic();
+        if (g == graphicChild) {
+            return;
+        }
+        if (graphicChild != null) {
+            cn1Children().remove(graphicChild);
+        }
+        graphicChild = g;
+        if (g != null && !cn1Children().contains(g)) {
+            cn1Children().add(g);
+        }
+    }
+
+    /// Measures a graphic against the text of the native label, in device
+    /// pixels: the room the graphic needs at the `{top, bottom, left,
+    /// right}` of the text, then the graphic's `{width, height}`, the
+    /// text's `{width, height}` and the gap between the two.
+    private int[] graphicBox(com.codename1.ui.Label label, Node g) {
+        int gw = Units.sizeToPixels(g.isResizable() ? g.prefWidth(-1) : g.getLayoutBounds().getWidth());
+        int gh = Units.sizeToPixels(g.isResizable() ? g.prefHeight(-1) : g.getLayoutBounds().getHeight());
+        com.codename1.ui.Font f = label.getUnselectedStyle().getFont();
+        String t = label.getText();
+        boolean hasText = t != null && t.length() > 0 && f != null;
+        int tw = hasText ? f.stringWidth(t) : 0;
+        int th = hasText ? f.getHeight() : 0;
+        int gap = hasText ? Units.toPixels(getGraphicTextGap()) : 0;
+        ContentDisplay d = hasText ? getContentDisplay() : ContentDisplay.CENTER;
+        int[] box = new int[GRAPHIC_BOX];
+        if (d == ContentDisplay.TOP || d == ContentDisplay.BOTTOM) {
+            box[d == ContentDisplay.TOP ? 0 : 1] = gh + gap;
+        } else {
+            int taller = Math.max(0, gh - th);
+            box[0] = taller / 2;
+            box[1] = taller - box[0];
+        }
+        if (d == ContentDisplay.RIGHT) {
+            box[3] = gw + gap;
+        } else if (d == ContentDisplay.TOP || d == ContentDisplay.BOTTOM || d == ContentDisplay.CENTER) {
+            int wider = Math.max(0, gw - tw);
+            box[2] = wider / 2;
+            box[3] = wider - box[2];
+        } else {
+            box[2] = gw + gap;
+        }
+        box[4] = gw;
+        box[5] = gh;
+        box[6] = tw;
+        box[7] = th;
+        box[8] = gap;
+        return box;
+    }
+
+    /// A native label with no text and no icon asks for no room at all,
+    /// its padding included; with a graphic to show it is as large as the
+    /// padding, which holds the room of the graphic.
+    @Override
+    protected Dimension cn1NativePreferredSize() {
+        Dimension d = super.cn1NativePreferredSize();
+        Component c = cn1NativeIfCreated();
+        if (c != null && shed(c) > 0) {
+            // Padding given up to a width too narrow is still asked for.
+            d = new Dimension(d.getWidth() + shedLeft + shedRight, d.getHeight());
+        }
+        if (paddedForGraphic && c != null) {
+            Style s = c.getUnselectedStyle();
+            return new Dimension(Math.max(d.getWidth(), s.getHorizontalPadding()),
+                    Math.max(d.getHeight(), s.getVerticalPadding()));
+        }
+        // The native label clips its text to the width the text measures,
+        // which the last letter of an italic leans out of: the label is
+        // that much wider, so all of the letter is inside.
+        if (c instanceof com.codename1.ui.Label) {
+            int lean = Fonts.overhang(font.get(), ((com.codename1.ui.Label) c).getText());
+            if (lean > 0) {
+                return new Dimension(d.getWidth() + lean, d.getHeight());
+            }
+        }
+        return d;
+    }
+
+    /// What the native label gave up of its padding, in device pixels;
+    /// nothing once something else has set its padding since.
+    private int shed(Component c) {
+        if (shedLeft + shedRight > 0) {
+            Style s = c.getUnselectedStyle();
+            if (s.getPaddingLeftNoRTL() != keptLeft || s.getPaddingRightNoRTL() != keptRight) {
+                shedLeft = 0;
+                shedRight = 0;
+            }
+        }
+        return shedLeft + shedRight;
+    }
+
+    /// Whether the control is one that gives up padding: a native label
+    /// with padding of its theme, and no graphic whose room is kept in it.
+    private boolean sheds(Component c, Node graphic) {
+        return c instanceof com.codename1.ui.Label && graphic == null && !paddedForGraphic && !cn1BareText()
+                && !ownsGraphic();
+    }
+
+    /// The least of its padding a control keeps on a side: a quarter.
+    private static int kept(int full) {
+        return full / 4;
+    }
+
+    /// Takes the width a control is short of from the padding beside its
+    /// text before the text is cut.
+    ///
+    /// A JavaFX button has a few pixels beside its text, and one too
+    /// narrow can only lose letters. A theme of a phone puts a quarter of
+    /// an inch there, so three buttons in a row are wider than the display
+    /// with every word in full, and squeezed the way JavaFX squeezes them
+    /// they read "DISA...", "CA..." and "O" between empty margins wide
+    /// enough for all of it. The preferred size keeps counting the whole
+    /// padding, so what a pane hands the control does not move with this.
+    private void fitPadding(Component c, Node graphic) {
+        if (!sheds(c, graphic) || c.getWidth() <= 0) {
+            return;
+        }
+        shed(c);
+        Style s = c.getUnselectedStyle();
+        int fullLeft = s.getPaddingLeftNoRTL() + shedLeft;
+        int fullRight = s.getPaddingRightNoRTL() + shedRight;
+        int missing = cn1NativePreferredSize().getWidth() - c.getWidth();
+        int left = 0;
+        int right = 0;
+        if (missing > 0) {
+            int most = fullLeft - kept(fullLeft) + fullRight - kept(fullRight);
+            int give = Math.min(missing, most);
+            left = Math.min(fullLeft - kept(fullLeft), (give + 1) / 2);
+            right = Math.min(fullRight - kept(fullRight), give - left);
+            left = Math.min(fullLeft - kept(fullLeft), give - right);
+        }
+        if (left == shedLeft && right == shedRight) {
+            return;
+        }
+        int top = s.getPaddingTop();
+        int bottom = s.getPaddingBottom();
+        Style all = com.codename1.fxcompat.runtime.PeerPaint.allStyles(c);
+        all.setPaddingUnit(Style.UNIT_TYPE_PIXELS);
+        all.setPadding(top, bottom, fullLeft - left, fullRight - right);
+        shedLeft = left;
+        shedRight = right;
+        keptLeft = fullLeft - left;
+        keptRight = fullRight - right;
+        c.setShouldCalcPreferredSize(true);
+    }
+
+    /// Places the graphic beside the text the native label draws, where
+    /// the content display puts it.
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        Node g = shownGraphic();
+        Component c = cn1NativeIfCreated();
+        fitPadding(c, g);
+        if (g == null || g.getParent() != this || !(c instanceof com.codename1.ui.Label)) {
+            return;
+        }
+        com.codename1.ui.Label label = (com.codename1.ui.Label) c;
+        int[] box = graphicBox(label, g);
+        Style base = UIManager.getInstance().getComponentStyle(label.getUIID());
+        Insets in = getInsets();
+        // The area the label lays its content out in, less the room made
+        // for the graphic: where graphic and text sit together.
+        int areaX = Units.toPixels(in.getLeft()) + base.getPaddingLeftNoRTL();
+        int areaY = Units.toPixels(in.getTop()) + base.getPaddingTop();
+        int areaW = Units.toPixels(getWidth() - in.getLeft() - in.getRight()) - base.getPaddingLeftNoRTL()
+                - base.getPaddingRightNoRTL();
+        int areaH = Units.toPixels(getHeight() - in.getTop() - in.getBottom()) - base.getPaddingTop()
+                - base.getPaddingBottom();
+        int gw = box[4];
+        int gh = box[5];
+        int gap = box[8];
+        ContentDisplay d = box[6] == 0 ? ContentDisplay.CENTER : getContentDisplay();
+        boolean beside = d == ContentDisplay.LEFT || d == ContentDisplay.RIGHT;
+        // A text too long for the control is cut short by the label.
+        int tw = Math.max(0, Math.min(box[6], areaW - (beside ? gw + gap : 0)));
+        int contentW = beside ? gw + gap + tw : Math.max(gw, tw);
+        Pos pos = getAlignment();
+        HPos h = pos == null ? HPos.LEFT : pos.getHpos();
+        int contentX = areaX;
+        if (h == HPos.CENTER) {
+            contentX = areaX + (areaW - contentW) / 2;
+        } else if (h == HPos.RIGHT) {
+            contentX = areaX + areaW - contentW;
+        }
+        int gx = contentX + (contentW - gw) / 2;
+        int gy = areaY + (areaH - gh) / 2;
+        if (d == ContentDisplay.LEFT) {
+            gx = contentX;
+        } else if (d == ContentDisplay.RIGHT) {
+            gx = contentX + tw + gap;
+        } else if (d == ContentDisplay.TOP || d == ContentDisplay.BOTTOM) {
+            int contentY = areaY + (areaH - gh - gap - box[7]) / 2;
+            gy = d == ContentDisplay.TOP ? contentY : contentY + box[7] + gap;
+        }
+        double w = Units.toLogical(gw);
+        double height = Units.toLogical(gh);
+        if (g.isResizable()) {
+            g.resize(w, height);
+        }
+        positionInArea(g, Units.toLogical(gx), Units.toLogical(gy), w, height, 0, HPos.CENTER, VPos.CENTER);
+    }
+
+    /// A labeled control can be as narrow as its ellipsis: the native
+    /// label cuts a text that does not fit short and ends it with three
+    /// points, so a row that is too narrow shrinks its labels rather than
+    /// push the controls after them out of view.
+    @Override
+    protected double computeMinWidth(double height) {
+        double pref = computePrefWidth(height);
+        Component c = cn1NativeIfCreated();
+        if (c == null || cn1BareText()) {
+            // Asked before there is a native label, which is when a pane
+            // first sizes its children, or of a plain label, which is its
+            // text and nothing else: the same sum from the font of the
+            // control, so the answer does not change when the native label
+            // appears. Answering the whole text here made a label given a
+            // preferred width narrower than its text as wide as the text,
+            // and a tile pane of such labels a column short.
+            String text = getText();
+            if (text == null || text.length() == 0) {
+                return pref;
+            }
+            double room = Fonts.width(getFont(), text) - Fonts.width(getFont(), ELLIPSIS);
+            return room > 0 ? Math.max(0, pref - room) : pref;
+        }
+        if (!(c instanceof com.codename1.ui.Label)) {
+            return pref;
+        }
+        com.codename1.ui.Label label = (com.codename1.ui.Label) c;
+        com.codename1.ui.Font f = label.getUnselectedStyle().getFont();
+        String t = label.getText();
+        // Before any of the text goes, the padding beside it does.
+        int padding = 0;
+        if (sheds(c, shownGraphic())) {
+            shed(c);
+            Style s = c.getUnselectedStyle();
+            int left = s.getPaddingLeftNoRTL() + shedLeft;
+            int right = s.getPaddingRightNoRTL() + shedRight;
+            padding = left - kept(left) + right - kept(right);
+        }
+        if (f == null || t == null || t.length() == 0 || !label.isEndsWith3Points()) {
+            return Math.max(0, pref - Units.toLogical(padding));
+        }
+        int spare = Math.max(0, f.stringWidth(t) - f.stringWidth(ELLIPSIS));
+        return Math.max(0, pref - Units.toLogical(spare + padding));
+    }
+
+    private static final String ELLIPSIS = "...";
+
+    /// Returns whether an underscore in the text marks a mnemonic.
+    public final boolean isMnemonicParsing() {
+        return mnemonicParsing.get();
+    }
+
+    /// Sets whether an underscore in the text marks a mnemonic and is
+    /// left out of what is shown.
+    public final void setMnemonicParsing(boolean value) {
+        mnemonicParsing.set(value);
+    }
+
+    /// Whether an underscore in the text marks a mnemonic.
+    public final BooleanProperty mnemonicParsingProperty() {
+        return mnemonicParsing;
+    }
+
+    /// Returns the text.
+    public final String getText() {
+        return text.get();
+    }
+
+    /// Sets the text.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// The text of the control.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    /// Returns the font; the default font when none was set.
+    public final Font getFont() {
+        Font f = font.get();
+        return f == null ? Font.getDefault() : f;
+    }
+
+    /// Sets the font.
+    public final void setFont(Font value) {
+        font.set(value);
+    }
+
+    /// The font of the text.
+    public final ObjectProperty<Font> fontProperty() {
+        return font;
+    }
+
+    /// Returns the paint of the text; black when none was set.
+    public final Paint getTextFill() {
+        Paint p = textFill.get();
+        return p == null ? Color.BLACK : p;
+    }
+
+    /// Sets the paint of the text. Only a plain colour is shown.
+    public final void setTextFill(Paint value) {
+        textFill.set(value);
+    }
+
+    /// The paint of the text.
+    public final ObjectProperty<Paint> textFillProperty() {
+        return textFill;
+    }
+
+    /// Returns where the content sits in the control.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the content sits in the control. The horizontal part
+    /// is applied.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the content sits in the control.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Returns how lines of text align with each other.
+    public final TextAlignment getTextAlignment() {
+        return textAlignment.get();
+    }
+
+    /// Sets how lines of text align with each other.
+    public final void setTextAlignment(TextAlignment value) {
+        textAlignment.set(value);
+    }
+
+    /// How lines of text align with each other.
+    public final ObjectProperty<TextAlignment> textAlignmentProperty() {
+        return textAlignment;
+    }
+
+    /// Returns whether text is asked to wrap.
+    public final boolean isWrapText() {
+        return wrapText.get();
+    }
+
+    /// Asks for text to wrap.
+    public final void setWrapText(boolean value) {
+        wrapText.set(value);
+    }
+
+    /// Whether text is asked to wrap.
+    public final BooleanProperty wrapTextProperty() {
+        return wrapText;
+    }
+
+    /// Returns whether the text is underlined.
+    public final boolean isUnderline() {
+        return underline.get();
+    }
+
+    /// Sets whether the text is underlined.
+    public final void setUnderline(boolean value) {
+        underline.set(value);
+    }
+
+    /// Whether the text is underlined.
+    public final BooleanProperty underlineProperty() {
+        return underline;
+    }
+
+    /// Returns the graphic, or `null`.
+    public final Node getGraphic() {
+        return graphic.get();
+    }
+
+    /// Sets the graphic.
+    public final void setGraphic(Node value) {
+        graphic.set(value);
+    }
+
+    /// The graphic of the control.
+    public final ObjectProperty<Node> graphicProperty() {
+        return graphic;
+    }
+
+    /// Returns the gap between graphic and text.
+    public final double getGraphicTextGap() {
+        return graphicTextGap.get();
+    }
+
+    /// Sets the gap between graphic and text.
+    public final void setGraphicTextGap(double value) {
+        graphicTextGap.set(value);
+    }
+
+    /// The gap between graphic and text.
+    public final DoubleProperty graphicTextGapProperty() {
+        return graphicTextGap;
+    }
+
+    /// Returns where the graphic sits relative to the text.
+    public final ContentDisplay getContentDisplay() {
+        return contentDisplay.get();
+    }
+
+    /// Sets where the graphic sits relative to the text.
+    public final void setContentDisplay(ContentDisplay value) {
+        contentDisplay.set(value);
+    }
+
+    /// Where the graphic sits relative to the text.
+    public final ObjectProperty<ContentDisplay> contentDisplayProperty() {
+        return contentDisplay;
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-text-fill".equals(property)) {
+            return textFill.get();
+        } else if ("-fx-font".equals(property) || "-fx-font-size".equals(property)
+                || "-fx-font-family".equals(property) || "-fx-font-weight".equals(property)
+                || "-fx-font-style".equals(property)) {
+            return font.get();
+        } else if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        } else if ("-fx-text-alignment".equals(property)) {
+            return getTextAlignment();
+        } else if ("-fx-wrap-text".equals(property)) {
+            return Boolean.valueOf(isWrapText());
+        } else if ("-fx-underline".equals(property)) {
+            return Boolean.valueOf(isUnderline());
+        } else if ("-fx-graphic-text-gap".equals(property)) {
+            return Double.valueOf(getGraphicTextGap());
+        } else if ("-fx-content-display".equals(property)) {
+            return getContentDisplay();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    private static FontWeight weight(Object value) {
+        if (value instanceof FontWeight) {
+            return (FontWeight) value;
+        } else if (value instanceof Number) {
+            return FontWeight.findByWeight(((Number) value).intValue());
+        } else if (value instanceof String) {
+            return FontWeight.findByName(((String) value).trim());
+        }
+        return null;
+    }
+
+    private static FontPosture posture(Object value) {
+        if (value instanceof FontPosture) {
+            return (FontPosture) value;
+        } else if (value instanceof String) {
+            String s = ((String) value).trim();
+            if ("italic".equalsIgnoreCase(s) || "oblique".equalsIgnoreCase(s)) {
+                return FontPosture.ITALIC;
+            } else if ("normal".equalsIgnoreCase(s) || "regular".equalsIgnoreCase(s)) {
+                return FontPosture.REGULAR;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-text-fill".equals(property)) {
+            if (value != null && !(value instanceof Paint)) {
+                return false;
+            }
+            setTextFill((Paint) value);
+        } else if (property.startsWith("-fx-font")) {
+            // Restoring any of the font names restores the whole font.
+            if (value == null || value instanceof Font) {
+                setFont((Font) value);
+                return true;
+            }
+            Font base = getFont();
+            FontWeight w = base.cn1Weight();
+            FontPosture p = base.cn1Posture();
+            String family = base.getFamily();
+            double size = base.getSize();
+            if ("-fx-font-size".equals(property) && value instanceof Number) {
+                size = ((Number) value).doubleValue();
+            } else if ("-fx-font-family".equals(property) && value instanceof String) {
+                family = (String) value;
+            } else if ("-fx-font-weight".equals(property) && weight(value) != null) {
+                w = weight(value);
+            } else if ("-fx-font-style".equals(property) && posture(value) != null) {
+                p = posture(value);
+            } else {
+                return false;
+            }
+            setFont(Font.font(family, w, p, size));
+        } else if ("-fx-alignment".equals(property)) {
+            if (!(value instanceof Pos)) {
+                return false;
+            }
+            setAlignment((Pos) value);
+        } else if ("-fx-text-alignment".equals(property)) {
+            TextAlignment a = null;
+            if (value instanceof TextAlignment) {
+                a = (TextAlignment) value;
+            } else if (value instanceof String) {
+                TextAlignment[] all = TextAlignment.values();
+                for (int i = 0; i < all.length; i++) {
+                    if (all[i].name().equalsIgnoreCase(((String) value).trim())) {
+                        a = all[i];
+                    }
+                }
+            }
+            if (a == null) {
+                return false;
+            }
+            setTextAlignment(a);
+        } else if ("-fx-wrap-text".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            setWrapText(((Boolean) value).booleanValue());
+        } else if ("-fx-underline".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            setUnderline(((Boolean) value).booleanValue());
+        } else if ("-fx-graphic-text-gap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setGraphicTextGap(((Number) value).doubleValue());
+        } else if ("-fx-content-display".equals(property)) {
+            ContentDisplay d = null;
+            if (value instanceof ContentDisplay) {
+                d = (ContentDisplay) value;
+            } else if (value instanceof String) {
+                String wanted = ((String) value).trim().replace('-', '_');
+                ContentDisplay[] all = ContentDisplay.values();
+                for (int i = 0; i < all.length; i++) {
+                    if (all[i].name().equalsIgnoreCase(wanted)) {
+                        d = all[i];
+                    }
+                }
+            }
+            if (d == null) {
+                return false;
+            }
+            setContentDisplay(d);
+        } else {
+            return super.cn1SetStyleValue(property, value);
+        }
+        return true;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ListCell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ListCell.java
new file mode 100644
index 00000000000..62446a85b74
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ListCell.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.collections.ObservableList;
+
+/// A cell of a [ListView]. An application subclasses it and overrides
+/// `updateItem` to decide what a row looks like.
+public class ListCell<T> extends IndexedCell<T> {
+
+    private final ReadOnlyObjectWrapper<ListView<T>> listView = new ReadOnlyObjectWrapper<ListView<T>>(this,
+            "listView");
+    private boolean stale = true;
+
+    /// Creates a cell that belongs to no list yet.
+    public ListCell() {
+        getStyleClass().add("list-cell");
+    }
+
+    /// The list this cell belongs to.
+    public final ReadOnlyObjectProperty<ListView<T>> listViewProperty() {
+        return listView.getReadOnlyProperty();
+    }
+
+    /// Returns the list this cell belongs to.
+    public final ListView<T> getListView() {
+        return listView.get();
+    }
+
+    /// Tells the cell which list it belongs to; the list does.
+    public final void updateListView(ListView<T> listView) {
+        this.listView.set(listView);
+    }
+
+    /// Makes the next update show the item again even if it is the same.
+    final void markStale() {
+        stale = true;
+    }
+
+    @Override
+    void indexChanged(int oldIndex, int newIndex) {
+        ListView<T> view = getListView();
+        ObservableList<T> items = view == null ? null : view.getItems();
+        boolean valid = items != null && newIndex >= 0 && newIndex < items.size();
+        if (valid) {
+            T value = items.get(newIndex);
+            if (stale || isEmpty() || oldIndex != newIndex || isItemChanged(getItem(), value)) {
+                updateItem(value, false);
+            }
+        } else if (stale || !isEmpty()) {
+            updateItem(null, true);
+        }
+        stale = false;
+        MultipleSelectionModel<T> model = view == null ? null : view.getSelectionModel();
+        updateSelected(valid && model != null && model.isSelected(newIndex));
+    }
+
+    @Override
+    boolean striped() {
+        return getIndex() > 0 && (getIndex() & 1) != 0;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ListView.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ListView.java
new file mode 100644
index 00000000000..bb26e5e3eb9
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ListView.java
@@ -0,0 +1,549 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.Border;
+import javafx.scene.layout.BorderStroke;
+import javafx.scene.layout.BorderStrokeStyle;
+import javafx.scene.layout.BorderWidths;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.paint.Color;
+import javafx.util.Callback;
+
+/// A vertical list of items, each shown by a [ListCell].
+///
+/// The cells are JavaFX nodes made by the cell factory; only the rows in
+/// view have one, and a cell is given another row as the list scrolls.
+/// Every row has the same height: `fixedCellSize` when it is set, else
+/// the preferred height of the cell of the first row. The list scrolls by
+/// the wheel, by dragging and by [#scrollTo(int)].
+///
+/// A press selects the row under it. With
+/// `SelectionMode.MULTIPLE` a press with the shortcut key down adds or
+/// removes the row, and one with Shift down selects the range from the
+/// row pressed last.
+///
+/// The list is always vertical and cannot be edited: `orientation`,
+/// `editable`, the edit events and the focus model of JavaFX are not part
+/// of this layer.
+///
+/// The control has no native component. It starts with a white
+/// background and a thin grey border, which the `Region` style names
+/// replace; it adds no style names of its own.
+public class ListView<T> extends Control {
+
+    private final ObjectProperty<ObservableList<T>> items = new SimpleObjectProperty<ObservableList<T>>(this,
+            "items");
+    private final ObjectProperty<Node> placeholder = new SimpleObjectProperty<Node>(this, "placeholder");
+    private final ObjectProperty<MultipleSelectionModel<T>> selectionModel =
+            new SimpleObjectProperty<MultipleSelectionModel<T>>(this, "selectionModel");
+    private final ObjectProperty<Callback<ListView<T>, ListCell<T>>> cellFactory =
+            new SimpleObjectProperty<Callback<ListView<T>, ListCell<T>>>(this, "cellFactory");
+    private final DoubleProperty fixedCellSize = new SimpleDoubleProperty(this, "fixedCellSize", USE_COMPUTED_SIZE);
+    private final RowFlow flow;
+    private int anchor = -1;
+
+    private final ListChangeListener<T> itemsListener = new ListChangeListener<T>() {
+        @Override
+        public void onChanged(Change<? extends T> change) {
+            RowSelection<T> own = ownSelection();
+            if (own != null) {
+                own.rowsChanged(change);
+            }
+            contentChanged();
+        }
+    };
+
+    private final ListChangeListener<Integer> selectionListener = new ListChangeListener<Integer>() {
+        @Override
+        public void onChanged(Change<? extends Integer> change) {
+            syncSelection();
+        }
+    };
+
+    /// Creates a list with no items.
+    public ListView() {
+        this(FXCollections.<T>observableArrayList());
+    }
+
+    /// Creates a list of some items.
+    public ListView(ObservableList<T> items) {
+        getStyleClass().add("list-view");
+        setBackground(new Background(new BackgroundFill(Color.WHITE, CornerRadii.EMPTY, Insets.EMPTY)));
+        setBorder(new Border(new BorderStroke(Color.rgb(200, 200, 200), BorderStrokeStyle.SOLID, CornerRadii.EMPTY,
+                new BorderWidths(1))));
+        flow = new RowFlow(new FlowRows());
+        flow.stripes = true;
+        cn1Children().add(flow);
+        this.items.addListener(new ChangeListener<ObservableList<T>>() {
+            @Override
+            public void changed(ObservableValue<? extends ObservableList<T>> observable, ObservableList<T> oldValue,
+                    ObservableList<T> newValue) {
+                if (oldValue != null) {
+                    oldValue.removeListener(itemsListener);
+                }
+                if (newValue != null) {
+                    newValue.addListener(itemsListener);
+                }
+                RowSelection<T> own = ownSelection();
+                if (own != null) {
+                    own.rowsReplaced();
+                }
+                flow.scrollTo(0);
+                contentChanged();
+            }
+        });
+        selectionModel.addListener(new ChangeListener<MultipleSelectionModel<T>>() {
+            @Override
+            public void changed(ObservableValue<? extends MultipleSelectionModel<T>> observable,
+                    MultipleSelectionModel<T> oldValue, MultipleSelectionModel<T> newValue) {
+                if (oldValue != null) {
+                    oldValue.getSelectedIndices().removeListener(selectionListener);
+                }
+                if (newValue != null) {
+                    newValue.getSelectedIndices().addListener(selectionListener);
+                }
+                syncSelection();
+            }
+        });
+        placeholder.addListener(new ChangeListener<Node>() {
+            @Override
+            public void changed(ObservableValue<? extends Node> observable, Node oldValue, Node newValue) {
+                if (oldValue != null) {
+                    cn1Children().remove(oldValue);
+                }
+                if (newValue != null && !cn1Children().contains(newValue)) {
+                    cn1Children().add(newValue);
+                }
+                requestLayout();
+            }
+        });
+        cellFactory.addListener(new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                flow.rebuild();
+            }
+        });
+        fixedCellSize.addListener(new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
+                flow.rowsChanged();
+            }
+        });
+        flow.addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                pressed(event);
+            }
+        });
+        selectionModel.set(new Model<T>(this));
+        this.items.set(items);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    /// The selection of the model this list created, which follows the
+    /// items; `null` once the application installed its own model.
+    @SuppressWarnings("unchecked")
+    private RowSelection<T> ownSelection() {
+        MultipleSelectionModel<T> model = getSelectionModel();
+        return model instanceof Model ? ((Model<T>) model).selection : null;
+    }
+
+    private void contentChanged() {
+        flow.rowsChanged();
+        requestLayout();
+    }
+
+    private void syncSelection() {
+        MultipleSelectionModel<T> model = getSelectionModel();
+        ArrayList<IndexedCell<?>[]> slots = flow.slots();
+        for (int i = 0; i < slots.size(); i++) {
+            IndexedCell<?>[] slot = slots.get(i);
+            for (int c = 0; c < slot.length; c++) {
+                int row = slot[c].getIndex();
+                slot[c].updateSelected(model != null && row >= 0 && model.isSelected(row));
+            }
+        }
+    }
+
+    private void pressed(MouseEvent event) {
+        MultipleSelectionModel<T> model = getSelectionModel();
+        int row = flow.rowAt(event);
+        if (model == null || row < 0) {
+            return;
+        }
+        anchor = RowPress.apply(model, event.getButton() == MouseButton.PRIMARY, event.isShortcutDown(),
+                event.isShiftDown(), row, anchor);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double w = Math.max(0, getWidth() - in.getLeft() - in.getRight());
+        double h = Math.max(0, getHeight() - in.getTop() - in.getBottom());
+        Node empty = getPlaceholder();
+        ObservableList<T> list = getItems();
+        boolean showEmpty = empty != null && (list == null || list.isEmpty());
+        flow.setVisible(!showEmpty);
+        flow.resizeRelocate(in.getLeft(), in.getTop(), w, h);
+        if (empty != null) {
+            empty.setVisible(showEmpty);
+            if (showEmpty) {
+                layoutInArea(empty, in.getLeft(), in.getTop(), w, h, 0, javafx.geometry.HPos.CENTER,
+                        javafx.geometry.VPos.CENTER);
+            }
+        }
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        return 248;
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        return 400;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    public double getBaselineOffset() {
+        return BASELINE_OFFSET_SAME_AS_HEIGHT;
+    }
+
+    /// Sets the items shown. Changes to an observable list show at once.
+    public final void setItems(ObservableList<T> value) {
+        items.set(value);
+    }
+
+    /// Returns the items shown.
+    public final ObservableList<T> getItems() {
+        return items.get();
+    }
+
+    /// The items shown.
+    public final ObjectProperty<ObservableList<T>> itemsProperty() {
+        return items;
+    }
+
+    /// The node shown instead of the rows while there are no items.
+    public final ObjectProperty<Node> placeholderProperty() {
+        return placeholder;
+    }
+
+    /// Sets the node shown while there are no items.
+    public final void setPlaceholder(Node value) {
+        placeholder.set(value);
+    }
+
+    /// Returns the node shown while there are no items.
+    public final Node getPlaceholder() {
+        return placeholder.get();
+    }
+
+    /// Sets the selection model.
+    public final void setSelectionModel(MultipleSelectionModel<T> value) {
+        selectionModel.set(value);
+    }
+
+    /// Returns the selection model.
+    public final MultipleSelectionModel<T> getSelectionModel() {
+        return selectionModel.get();
+    }
+
+    /// The selection model.
+    public final ObjectProperty<MultipleSelectionModel<T>> selectionModelProperty() {
+        return selectionModel;
+    }
+
+    /// Sets the height of every row; `Region.USE_COMPUTED_SIZE` takes it
+    /// from the first cell.
+    public final void setFixedCellSize(double value) {
+        fixedCellSize.set(value);
+    }
+
+    /// Returns the height of every row, or `Region.USE_COMPUTED_SIZE`.
+    public final double getFixedCellSize() {
+        return fixedCellSize.get();
+    }
+
+    /// The height of every row.
+    public final DoubleProperty fixedCellSizeProperty() {
+        return fixedCellSize;
+    }
+
+    /// Sets what creates the cells. Without one a cell shows the item's
+    /// `toString()`, or the item itself when it is a node.
+    public final void setCellFactory(Callback<ListView<T>, ListCell<T>> value) {
+        cellFactory.set(value);
+    }
+
+    /// Returns what creates the cells, or `null` for the default.
+    public final Callback<ListView<T>, ListCell<T>> getCellFactory() {
+        return cellFactory.get();
+    }
+
+    /// What creates the cells.
+    public final ObjectProperty<Callback<ListView<T>, ListCell<T>>> cellFactoryProperty() {
+        return cellFactory;
+    }
+
+    /// Scrolls so that a row is the first one shown, as far as the rows
+    /// reach.
+    public void scrollTo(int index) {
+        flow.show(index);
+    }
+
+    /// Scrolls to an item of the list.
+    public void scrollTo(T object) {
+        ObservableList<T> list = getItems();
+        int at = list == null ? -1 : list.indexOf(object);
+        if (at >= 0) {
+            scrollTo(at);
+        }
+    }
+
+    /// Shows every visible row again, for items that changed in a way
+    /// the list could not observe.
+    public void refresh() {
+        flow.refresh();
+    }
+
+    private static final class DefaultCell<T> extends ListCell<T> {
+        @Override
+        protected void updateItem(T item, boolean empty) {
+            super.updateItem(item, empty);
+            if (empty) {
+                setText(null);
+                setGraphic(null);
+            } else if (item instanceof Node) {
+                setText(null);
+                setGraphic((Node) item);
+            } else {
+                setText(item == null ? "null" : item.toString());
+                setGraphic(null);
+            }
+        }
+    }
+
+    private final class FlowRows implements RowFlow.Rows {
+        @Override
+        public int rowCount() {
+            ObservableList<T> list = getItems();
+            return list == null ? 0 : list.size();
+        }
+
+        @Override
+        public int columnCount() {
+            return 1;
+        }
+
+        @Override
+        public void columns(double width, double[] x, double[] w) {
+            x[0] = 0;
+            w[0] = width;
+        }
+
+        @Override
+        public IndexedCell<?> createCell(int column) {
+            Callback<ListView<T>, ListCell<T>> factory = getCellFactory();
+            ListCell<T> cell = factory == null ? null : factory.call(ListView.this);
+            if (cell == null) {
+                cell = new DefaultCell<T>();
+            }
+            cell.updateListView(ListView.this);
+            return cell;
+        }
+
+        @Override
+        public void updateCell(IndexedCell<?> cell, int column, int row, boolean force) {
+            if (force && cell instanceof ListCell) {
+                ((ListCell<?>) cell).markStale();
+            }
+            cell.updateIndex(row);
+        }
+
+        @Override
+        public double fixedCellSize() {
+            return getFixedCellSize();
+        }
+    }
+
+    private static final class Model<T> extends MultipleSelectionModel<T> implements RowSelection.Owner<T> {
+
+        private final ListView<T> view;
+        private final RowSelection<T> selection;
+
+        Model(ListView<T> view) {
+            this.view = view;
+            this.selection = new RowSelection<T>(this);
+        }
+
+        @Override
+        public ObservableList<T> rows() {
+            return view.getItems();
+        }
+
+        @Override
+        public boolean multiple() {
+            return getSelectionMode() == SelectionMode.MULTIPLE;
+        }
+
+        @Override
+        public void lead(int index, T item) {
+            setSelectedIndex(index);
+            setSelectedItem(item);
+        }
+
+        @Override
+        public ObservableList<Integer> getSelectedIndices() {
+            return selection.indices();
+        }
+
+        @Override
+        public ObservableList<T> getSelectedItems() {
+            return selection.items();
+        }
+
+        @Override
+        public void selectIndices(int index, int... indices) {
+            selection.selectIndices(index, indices);
+        }
+
+        @Override
+        public void selectAll() {
+            selection.selectAll();
+        }
+
+        @Override
+        public void selectFirst() {
+            if (selection.rowCount() > 0) {
+                select(0);
+            }
+        }
+
+        @Override
+        public void selectLast() {
+            int n = selection.rowCount();
+            if (n > 0) {
+                select(n - 1);
+            }
+        }
+
+        @Override
+        public void clearAndSelect(int index) {
+            selection.clearAndSelect(index);
+        }
+
+        @Override
+        public void select(int index) {
+            selection.select(index);
+        }
+
+        @Override
+        public void select(T obj) {
+            selection.select(obj);
+        }
+
+        @Override
+        public void clearSelection(int index) {
+            selection.clear(index);
+        }
+
+        @Override
+        public void clearSelection() {
+            selection.clear();
+        }
+
+        @Override
+        public boolean isSelected(int index) {
+            return selection.isSelected(index);
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return selection.isEmpty();
+        }
+
+        @Override
+        public void selectPrevious() {
+            int lead = selection.lead();
+            if (lead > 0) {
+                select(lead - 1);
+            }
+        }
+
+        @Override
+        public void selectNext() {
+            int lead = selection.lead();
+            if (lead < selection.rowCount() - 1) {
+                select(lead + 1);
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Menu.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Menu.java
new file mode 100644
index 00000000000..69e7b0e909a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Menu.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.List;
+
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.Event;
+import javafx.event.EventType;
+import javafx.scene.Node;
+
+/// A menu item that opens a popup of further items: an entry of a
+/// [MenuBar], or a sub-menu inside another menu.
+///
+/// [#show()] and [#hide()] change `showing`; the menu bar or the menu
+/// that shows this one opens and closes the popup to match.
+public class Menu extends MenuItem {
+
+    /// Sent to a menu before it shows.
+    public static final EventType<Event> ON_SHOWING = new EventType<Event>(Event.ANY, "MENU_ON_SHOWING");
+
+    /// Sent to a menu after it showed.
+    public static final EventType<Event> ON_SHOWN = new EventType<Event>(Event.ANY, "MENU_ON_SHOWN");
+
+    /// Sent to a menu before it hides.
+    public static final EventType<Event> ON_HIDING = new EventType<Event>(Event.ANY, "MENU_ON_HIDING");
+
+    /// Sent to a menu after it hid.
+    public static final EventType<Event> ON_HIDDEN = new EventType<Event>(Event.ANY, "MENU_ON_HIDDEN");
+
+    private final ObservableList<MenuItem> items = FXCollections.observableArrayList();
+    private final ReadOnlyBooleanWrapper showing = new ReadOnlyBooleanWrapper(this, "showing", false);
+
+    /// Creates a menu with no text.
+    public Menu() {
+        this("");
+    }
+
+    /// Creates a menu with a text.
+    public Menu(String text) {
+        this(text, null);
+    }
+
+    /// Creates a menu with a text and a graphic.
+    public Menu(String text, Node graphic) {
+        this(text, graphic, (MenuItem[]) null);
+    }
+
+    /// Creates a menu with a text, a graphic and items.
+    public Menu(String text, Node graphic, MenuItem... items) {
+        super(text, graphic);
+        styleClasses().add("menu");
+        this.items.addListener(new ListChangeListener<MenuItem>() {
+            @Override
+            public void onChanged(Change<? extends MenuItem> change) {
+                while (change.next()) {
+                    List<? extends MenuItem> removed = change.getRemoved();
+                    for (int i = 0; i < removed.size(); i++) {
+                        MenuItem item = removed.get(i);
+                        if (!Menu.this.items.contains(item)) {
+                            item.setParentMenu(null);
+                            item.setParentPopup(null);
+                        }
+                    }
+                    List<? extends MenuItem> added = change.getAddedSubList();
+                    for (int i = 0; i < added.size(); i++) {
+                        MenuItem item = added.get(i);
+                        Menu old = item.getParentMenu();
+                        if (old != null && old != Menu.this) {
+                            old.getItems().remove(item);
+                        }
+                        item.setParentMenu(Menu.this);
+                        item.setParentPopup(getParentPopup());
+                    }
+                }
+                if (Menu.this.items.isEmpty() && isShowing()) {
+                    hide();
+                }
+            }
+        });
+        if (items != null) {
+            this.items.addAll(items);
+        }
+    }
+
+    /// Returns the items of this menu.
+    public final ObservableList<MenuItem> getItems() {
+        return items;
+    }
+
+    /// Returns whether the popup of this menu is open.
+    public final boolean isShowing() {
+        return showing.get();
+    }
+
+    /// Whether the popup of this menu is open.
+    public final ReadOnlyBooleanProperty showingProperty() {
+        return showing.getReadOnlyProperty();
+    }
+
+    /// Opens the popup of this menu. A disabled menu and one without
+    /// items stay closed.
+    public void show() {
+        if (isDisable() || isShowing() || items.isEmpty()) {
+            return;
+        }
+        Event.fireEvent(this, new Event(ON_SHOWING));
+        showing.set(true);
+        Event.fireEvent(this, new Event(ON_SHOWN));
+    }
+
+    /// Closes the popup of this menu and of the sub-menus in it.
+    public void hide() {
+        if (!isShowing()) {
+            return;
+        }
+        Event.fireEvent(this, new Event(ON_HIDING));
+        for (int i = 0; i < items.size(); i++) {
+            MenuItem item = items.get(i);
+            if (item instanceof Menu) {
+                ((Menu) item).hide();
+            }
+        }
+        showing.set(false);
+        Event.fireEvent(this, new Event(ON_HIDDEN));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/MenuBar.java b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuBar.java
new file mode 100644
index 00000000000..3b71e5820f6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuBar.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+
+import com.codename1.ui.Component;
+
+import javafx.application.Platform;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.geometry.Side;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.paint.Color;
+
+/// A row of menus. Each [Menu] is shown as its text; pressing it opens
+/// the popup of the menu under it, pressing it again or anywhere outside
+/// closes it. [Menu#show()] and [Menu#hide()] do the same from code.
+///
+/// The bar is always drawn inside the scene: the menu bar of the system,
+/// and with it `useSystemMenuBar`, is not part of this layer.
+///
+/// ## Style
+///
+/// The bar has the style class `menu-bar`, and takes `-fx-background-color`
+/// and the other region properties from a style sheet; without one it is
+/// light grey. The text of each menu is a label with the style classes of
+/// its menu (`menu`, `menu-item`).
+public class MenuBar extends Control {
+
+    private final ObservableList<Menu> menus = FXCollections.observableArrayList();
+    private final javafx.beans.property.BooleanProperty useSystemMenuBar =
+            new javafx.beans.property.SimpleBooleanProperty(this, "useSystemMenuBar", false);
+    private final ArrayList<Header> headers = new ArrayList<Header>();
+    private Menu justClosed;
+
+    /// The standard theme's bar: a shade under the base colour.
+    @Override
+    public String cn1DefaultStyle() {
+        return "-fx-background-color: derive(-fx-base, -3%);";
+    }
+
+    /// Creates a bar with no menus.
+    public MenuBar() {
+        this((Menu[]) null);
+    }
+
+    /// Creates a bar with menus.
+    public MenuBar(Menu... menus) {
+        getStyleClass().add("menu-bar");
+        setFocusTraversable(false);
+        setBackground(new Background(new BackgroundFill(Color.rgb(236, 236, 236), CornerRadii.EMPTY, Insets.EMPTY)));
+        this.menus.addListener(new ListChangeListener<Menu>() {
+            @Override
+            public void onChanged(Change<? extends Menu> change) {
+                rebuild();
+            }
+        });
+        if (menus != null) {
+            this.menus.addAll(menus);
+        }
+    }
+
+    /// Returns the menus of the bar, in the order they are shown.
+    public final ObservableList<Menu> getMenus() {
+        return menus;
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    private void rebuild() {
+        for (int i = 0; i < headers.size(); i++) {
+            headers.get(i).dispose();
+        }
+        headers.clear();
+        cn1Children().clear();
+        for (int i = 0; i < menus.size(); i++) {
+            Menu m = menus.get(i);
+            if (m != null) {
+                Header h = new Header(m);
+                headers.add(h);
+                cn1Children().add(h.label);
+            }
+        }
+        requestLayout();
+    }
+
+    private void pressed(Menu menu) {
+        if (menu.isShowing()) {
+            menu.hide();
+            return;
+        }
+        if (justClosed == menu) {
+            // The press that closed the popup is this one.
+            return;
+        }
+        for (int i = 0; i < headers.size(); i++) {
+            headers.get(i).menu.hide();
+        }
+        menu.show();
+    }
+
+    private void closed(final Menu menu) {
+        justClosed = menu;
+        Platform.runLater(new Runnable() {
+            @Override
+            public void run() {
+                if (justClosed == menu) {
+                    justClosed = null;
+                }
+            }
+        });
+    }
+
+    /// Returns the label that shows a menu of the bar, or `null`.
+    Label header(Menu menu) {
+        for (int i = 0; i < headers.size(); i++) {
+            if (headers.get(i).menu == menu) {
+                return headers.get(i).label;
+            }
+        }
+        return null;
+    }
+
+    /// Returns the open popup of a menu of the bar, or `null`.
+    ContextMenu popup(Menu menu) {
+        for (int i = 0; i < headers.size(); i++) {
+            if (headers.get(i).menu == menu) {
+                return headers.get(i).link.popup();
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        double w = 0;
+        for (int i = 0; i < headers.size(); i++) {
+            Header h = headers.get(i);
+            if (h.menu.isVisible()) {
+                w += h.label.prefWidth(-1);
+            }
+        }
+        Insets in = getInsets();
+        return in.getLeft() + w + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        double h = 0;
+        for (int i = 0; i < headers.size(); i++) {
+            h = Math.max(h, headers.get(i).label.prefHeight(-1));
+        }
+        Insets in = getInsets();
+        return in.getTop() + (h <= 0 ? 24 : h) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return 0;
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double h = Math.max(0, getHeight() - y - in.getBottom());
+        for (int i = 0; i < headers.size(); i++) {
+            Header header = headers.get(i);
+            boolean show = header.menu.isVisible();
+            header.label.setVisible(show);
+            if (show) {
+                double w = header.label.prefWidth(-1);
+                header.label.resizeRelocate(x, y, w, h);
+                x += w;
+            }
+        }
+    }
+
+    /// One menu of the bar: the label that shows it and what follows the
+    /// menu.
+    private final class Header {
+        final Menu menu;
+        final Label label;
+        final MenuLink link;
+        private final ChangeListener<Object> sync = new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                sync();
+            }
+        };
+        private final ChangeListener<Boolean> showing = new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
+                if (newValue != null && !newValue.booleanValue()) {
+                    closed(menu);
+                }
+            }
+        };
+
+        Header(Menu m) {
+            menu = m;
+            label = new Label();
+            // The label of a menu is a label to a style sheet as well:
+            // ".menu-bar .label" is how one sets the font of the bar.
+            label.getStyleClass().addAll(m.getStyleClass());
+            label.setFocusTraversable(false);
+            label.setPadding(new Insets(4, 8, 4, 8));
+            link = new MenuLink(m, label, Side.BOTTOM).attach();
+            m.textProperty().addListener(sync);
+            m.mnemonicParsingProperty().addListener(sync);
+            m.disableProperty().addListener(sync);
+            m.visibleProperty().addListener(sync);
+            m.showingProperty().addListener(showing);
+            label.addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+                @Override
+                public void handle(MouseEvent event) {
+                    if (event.getButton() == MouseButton.PRIMARY) {
+                        event.consume();
+                        pressed(menu);
+                    }
+                }
+            });
+            sync();
+        }
+
+        void sync() {
+            label.setText(menu.shownText());
+            label.setDisable(menu.isDisable());
+            requestLayout();
+        }
+
+        void dispose() {
+            menu.textProperty().removeListener(sync);
+            menu.disableProperty().removeListener(sync);
+            menu.visibleProperty().removeListener(sync);
+            menu.showingProperty().removeListener(showing);
+            link.detach();
+        }
+    }
+
+    /// Sets whether the menus go to the menu bar of the system; recorded,
+    /// the bar is always shown where it is in the scene.
+    public final void setUseSystemMenuBar(boolean value) {
+        useSystemMenuBar.set(value);
+    }
+
+    /// Returns whether the menus were asked to go to the system's bar.
+    public final boolean isUseSystemMenuBar() {
+        return useSystemMenuBar.get();
+    }
+
+    /// Whether the menus go to the menu bar of the system; recorded.
+    public final javafx.beans.property.BooleanProperty useSystemMenuBarProperty() {
+        return useSystemMenuBar;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/MenuContent.java b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuContent.java
new file mode 100644
index 00000000000..e9b42aa212b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuContent.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.geometry.Side;
+import javafx.scene.Node;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.Border;
+import javafx.scene.layout.BorderStroke;
+import javafx.scene.layout.BorderStrokeStyle;
+import javafx.scene.layout.BorderWidths;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// The content of an open menu: its visible items stacked as rows, a
+/// separator as a line.
+final class MenuContent extends Region {
+
+    private static final double GAP = 3;
+    private static final Color LINE = Color.rgb(200, 200, 200);
+    private static final Background HOVER = new Background(
+            new BackgroundFill(Color.rgb(210, 230, 245), CornerRadii.EMPTY, Insets.EMPTY));
+
+    private final ContextMenu popup;
+    private final ArrayList<Node> rows = new ArrayList<Node>();
+    private final ArrayList<MenuItem> rowItems = new ArrayList<MenuItem>();
+    private final ArrayList<MenuLink> links = new ArrayList<MenuLink>();
+
+    MenuContent(ContextMenu popup) {
+        this.popup = popup;
+        setBackground(new Background(new BackgroundFill(Color.WHITE, CornerRadii.EMPTY, Insets.EMPTY)));
+        setBorder(new Border(new BorderStroke(LINE, BorderStrokeStyle.SOLID, CornerRadii.EMPTY,
+                new BorderWidths(1))));
+        List<MenuItem> items = popup.rows();
+        for (int i = 0; i < items.size(); i++) {
+            MenuItem item = items.get(i);
+            if (item == null || !item.isVisible()) {
+                continue;
+            }
+            Node row = item instanceof SeparatorMenuItem ? line() : row(item);
+            rows.add(row);
+            rowItems.add(item);
+            cn1Children().add(row);
+        }
+    }
+
+    private static Region line() {
+        Region r = new Region();
+        r.setBackground(new Background(new BackgroundFill(LINE, CornerRadii.EMPTY, Insets.EMPTY)));
+        return r;
+    }
+
+    private MenuRow row(final MenuItem item) {
+        String text = item.shownText();
+        boolean marked = item instanceof CheckMenuItem && ((CheckMenuItem) item).isSelected();
+        final MenuRow row = new MenuRow(item instanceof Menu ? text + "   >" : text, marked);
+        row.getStyleClass().setAll(item.getStyleClass());
+        row.setId(item.getId());
+        row.setFocusTraversable(false);
+        row.setPadding(new Insets(4, 12, 4, 22));
+        if (item.isDisable()) {
+            row.setDisable(true);
+            row.setTextFill(Color.GRAY);
+            return row;
+        }
+        if (item instanceof Menu) {
+            links.add(new MenuLink((Menu) item, row, Side.RIGHT).attach());
+        }
+        row.addEventHandler(MouseEvent.MOUSE_ENTERED_TARGET, new Paint(row, HOVER));
+        row.addEventHandler(MouseEvent.MOUSE_EXITED_TARGET, new Paint(row, null));
+        row.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                if (event.getButton() == MouseButton.PRIMARY) {
+                    event.consume();
+                    choose(item);
+                }
+            }
+        });
+        return row;
+    }
+
+    /// Gives a row a background when the pointer enters or leaves it.
+    private static final class Paint implements EventHandler<MouseEvent> {
+        private final MenuRow row;
+        private final Background background;
+
+        Paint(MenuRow row, Background background) {
+            this.row = row;
+            this.background = background;
+        }
+
+        @Override
+        public void handle(MouseEvent event) {
+            row.setBackground(background);
+        }
+    }
+
+    private int current = -1;
+
+    /// Does what a key does to an open menu: Down and Up move to the next
+    /// and the previous item that can be chosen, around the ends; Enter
+    /// and Space choose the item moved to; Right opens the sub-menu of
+    /// that item and Left closes a sub-menu; Escape closes the menu.
+    /// Answers whether the key was one of these.
+    boolean key(KeyCode code) {
+        if (code == KeyCode.DOWN) {
+            move(1);
+        } else if (code == KeyCode.UP) {
+            move(-1);
+        } else if (code == KeyCode.ENTER || code == KeyCode.SPACE) {
+            if (current >= 0) {
+                choose(rowItems.get(current));
+            }
+        } else if (code == KeyCode.RIGHT) {
+            if (current >= 0 && rowItems.get(current) instanceof Menu
+                    && !((Menu) rowItems.get(current)).isShowing()) {
+                choose(rowItems.get(current));
+            }
+        } else if (code == KeyCode.LEFT) {
+            if (popup.isSubMenu()) {
+                popup.hide();
+            }
+        } else if (code == KeyCode.ESCAPE) {
+            popup.hide();
+        } else {
+            return false;
+        }
+        return true;
+    }
+
+    private void move(int step) {
+        int n = rows.size();
+        int at = current;
+        for (int tries = 0; tries < n; tries++) {
+            at = at < 0 ? (step > 0 ? 0 : n - 1) : (at + step + n) % n;
+            Node row = rows.get(at);
+            if (row instanceof MenuRow && !row.isDisabled()) {
+                if (current >= 0 && rows.get(current) instanceof MenuRow) {
+                    ((MenuRow) rows.get(current)).setBackground(null);
+                }
+                current = at;
+                ((MenuRow) row).setBackground(HOVER);
+                return;
+            }
+        }
+    }
+
+    /// Does what choosing the row of an item does.
+    void choose(MenuItem item) {
+        if (item.isDisable() || item instanceof SeparatorMenuItem) {
+            return;
+        }
+        if (item instanceof Menu) {
+            Menu m = (Menu) item;
+            if (m.isShowing()) {
+                m.hide();
+            } else {
+                for (int i = 0; i < links.size(); i++) {
+                    if (links.get(i).menu() != m) {
+                        links.get(i).menu().hide();
+                    }
+                }
+                m.show();
+            }
+            return;
+        }
+        if (item instanceof CheckMenuItem) {
+            CheckMenuItem check = (CheckMenuItem) item;
+            check.setSelected(!check.isSelected());
+        }
+        popup.hideAll();
+        item.fire();
+    }
+
+    /// Returns the row of an item, or `null` when it has none.
+    Node rowOf(MenuItem item) {
+        int i = rowItems.indexOf(item);
+        return i < 0 ? null : rows.get(i);
+    }
+
+    /// Returns the open popup of a sub-menu, or `null`.
+    ContextMenu popupOf(Menu menu) {
+        for (int i = 0; i < links.size(); i++) {
+            if (links.get(i).menu() == menu) {
+                return links.get(i).popup();
+            }
+        }
+        return null;
+    }
+
+    /// Closes the sub-menus and stops following them.
+    void dispose() {
+        ArrayList<MenuLink> all = new ArrayList<MenuLink>(links);
+        links.clear();
+        for (int i = 0; i < all.size(); i++) {
+            all.get(i).detach();
+        }
+    }
+
+    private double rowHeight(int i) {
+        return rowItems.get(i) instanceof SeparatorMenuItem ? GAP + 1 + GAP : rows.get(i).prefHeight(-1);
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        double w = 60;
+        for (int i = 0; i < rows.size(); i++) {
+            if (!(rowItems.get(i) instanceof SeparatorMenuItem)) {
+                w = Math.max(w, rows.get(i).prefWidth(-1));
+            }
+        }
+        Insets in = getInsets();
+        return in.getLeft() + w + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        double h = 0;
+        for (int i = 0; i < rows.size(); i++) {
+            h += rowHeight(i);
+        }
+        Insets in = getInsets();
+        return in.getTop() + h + in.getBottom();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double w = Math.max(0, getWidth() - x - in.getRight());
+        double y = in.getTop();
+        for (int i = 0; i < rows.size(); i++) {
+            Node row = rows.get(i);
+            double h = rowHeight(i);
+            if (rowItems.get(i) instanceof SeparatorMenuItem) {
+                row.resizeRelocate(x, y + GAP, w, 1);
+            } else {
+                row.resizeRelocate(x, y, w, h);
+            }
+            y += h;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/MenuItem.java b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuItem.java
new file mode 100644
index 00000000000..83da577f5e1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuItem.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.css.PseudoClass;
+import javafx.css.Styleable;
+import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.Node;
+import javafx.scene.input.KeyCombination;
+
+/// One entry of a menu. It is not a node: a [ContextMenu] or a [Menu]
+/// that holds it shows it as a row.
+///
+/// Choosing the row calls [#fire()], which sends an `ActionEvent` to the
+/// item; from there it goes on to the menus above it and to the context
+/// menu that holds them. A disabled item is shown greyed and cannot be
+/// chosen, an invisible one is left out.
+///
+/// The graphic is recorded and not drawn. The accelerator of an item in
+/// a [MenuBar] of the scene fires the item when a hardware keyboard
+/// sends the combination and nothing in the scene consumed the key; it
+/// is not shown beside the text, and the items of a context menu have
+/// none in effect. With `mnemonicParsing` on, as it is unless turned off,
+/// the underscore that marks a mnemonic is taken out of the text shown,
+/// as `com.codename1.fxcompat.runtime.Mnemonics` describes; the mnemonic
+/// itself does nothing. The menu validation event is absent.
+public class MenuItem implements EventTarget, Styleable {
+
+    private final StringProperty id = new SimpleStringProperty(this, "id");
+    private final StringProperty style = new SimpleStringProperty(this, "style", "");
+    private final ObservableList<String> styleClass = FXCollections.observableArrayList();
+    private final StringProperty text = new SimpleStringProperty(this, "text");
+    private final ObjectProperty<Node> graphic = new SimpleObjectProperty<Node>(this, "graphic");
+    private final BooleanProperty disable = new SimpleBooleanProperty(this, "disable", false);
+    private final ObjectProperty<KeyCombination> accelerator = new SimpleObjectProperty<KeyCombination>(this,
+            "accelerator");
+    private final BooleanProperty visible = new SimpleBooleanProperty(this, "visible", true);
+    private final BooleanProperty mnemonicParsing = new SimpleBooleanProperty(this, "mnemonicParsing", true);
+    private final ReadOnlyObjectWrapper<Menu> parentMenu = new ReadOnlyObjectWrapper<Menu>(this, "parentMenu");
+    private final ReadOnlyObjectWrapper<ContextMenu> parentPopup = new ReadOnlyObjectWrapper<ContextMenu>(this,
+            "parentPopup");
+    private final EventHandlerManager events = new EventHandlerManager(this);
+    private ObservableMap<Object, Object> properties;
+    private Object userData;
+
+    /// Creates an item with no text.
+    public MenuItem() {
+        this(null, null);
+    }
+
+    /// Creates an item with a text.
+    public MenuItem(String text) {
+        this(text, null);
+    }
+
+    /// Creates an item with a text and a graphic.
+    public MenuItem(String text, Node graphic) {
+        this.text.set(text);
+        this.graphic.set(graphic);
+        styleClass.add("menu-item");
+    }
+
+    /// Sets the key combination that fires this item.
+    public final void setAccelerator(KeyCombination value) {
+        accelerator.set(value);
+    }
+
+    /// Returns the key combination that fires this item, or `null`.
+    public final KeyCombination getAccelerator() {
+        return accelerator.get();
+    }
+
+    /// The key combination that fires this item.
+    public final ObjectProperty<KeyCombination> acceleratorProperty() {
+        return accelerator;
+    }
+
+    /// Sets the id a style sheet matches.
+    public final void setId(String value) {
+        id.set(value);
+    }
+
+    @Override
+    public final String getId() {
+        return id.get();
+    }
+
+    /// The id a style sheet matches.
+    public final StringProperty idProperty() {
+        return id;
+    }
+
+    /// Sets the inline style; recorded.
+    public final void setStyle(String value) {
+        style.set(value);
+    }
+
+    @Override
+    public final String getStyle() {
+        return style.get();
+    }
+
+    /// The inline style.
+    public final StringProperty styleProperty() {
+        return style;
+    }
+
+    @Override
+    public ObservableList<String> getStyleClass() {
+        return styleClass;
+    }
+
+    /// The style classes, for a constructor.
+    final ObservableList<String> styleClasses() {
+        return styleClass;
+    }
+
+    @Override
+    public String getTypeSelector() {
+        return "MenuItem";
+    }
+
+    @Override
+    public Styleable getStyleableParent() {
+        Menu menu = getParentMenu();
+        return menu != null ? menu : getParentPopup();
+    }
+
+    @Override
+    public final ObservableSet<PseudoClass> getPseudoClassStates() {
+        return FXCollections.<PseudoClass>emptyObservableSet();
+    }
+
+    /// Records the menu this item is in.
+    protected final void setParentMenu(Menu value) {
+        parentMenu.set(value);
+    }
+
+    /// Returns the menu this item is in, or `null`.
+    public final Menu getParentMenu() {
+        return parentMenu.get();
+    }
+
+    /// The menu this item is in.
+    public final ReadOnlyObjectProperty<Menu> parentMenuProperty() {
+        return parentMenu.getReadOnlyProperty();
+    }
+
+    /// Records the context menu this item is in.
+    protected final void setParentPopup(ContextMenu value) {
+        parentPopup.set(value);
+    }
+
+    /// Returns the context menu this item is in, or `null`.
+    public final ContextMenu getParentPopup() {
+        return parentPopup.get();
+    }
+
+    /// The context menu this item is in.
+    public final ReadOnlyObjectProperty<ContextMenu> parentPopupProperty() {
+        return parentPopup.getReadOnlyProperty();
+    }
+
+    /// Sets the text of the row.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// Returns the text of the row.
+    public final String getText() {
+        return text.get();
+    }
+
+    /// The text of the row.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    /// Sets the graphic; recorded.
+    public final void setGraphic(Node value) {
+        graphic.set(value);
+    }
+
+    /// Returns the graphic.
+    public final Node getGraphic() {
+        return graphic.get();
+    }
+
+    /// The graphic.
+    public final ObjectProperty<Node> graphicProperty() {
+        return graphic;
+    }
+
+    /// Sets the handler of the item being chosen.
+    public final void setOnAction(EventHandler<ActionEvent> value) {
+        events.setSlot(ActionEvent.ACTION, "onAction", value);
+    }
+
+    /// Returns the handler of the item being chosen.
+    public final EventHandler<ActionEvent> getOnAction() {
+        return onActionProperty().get();
+    }
+
+    /// The handler of the item being chosen.
+    public final ObjectProperty<EventHandler<ActionEvent>> onActionProperty() {
+        return onAction();
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private ObjectProperty<EventHandler<ActionEvent>> onAction() {
+        // The slot is typed for any handler of a super type of the event;
+        // this property only ever holds handlers of the event itself.
+        return (ObjectProperty) events.slot(ActionEvent.ACTION, "onAction");
+    }
+
+    /// Sets whether the item cannot be chosen.
+    public final void setDisable(boolean value) {
+        disable.set(value);
+    }
+
+    /// Returns whether the item cannot be chosen.
+    public final boolean isDisable() {
+        return disable.get();
+    }
+
+    /// Whether the item cannot be chosen.
+    public final BooleanProperty disableProperty() {
+        return disable;
+    }
+
+    /// Sets whether the item is shown in its menu.
+    public final void setVisible(boolean value) {
+        visible.set(value);
+    }
+
+    /// Returns whether the item is shown in its menu.
+    public final boolean isVisible() {
+        return visible.get();
+    }
+
+    /// Whether the item is shown in its menu.
+    public final BooleanProperty visibleProperty() {
+        return visible;
+    }
+
+    /// Returns whether an underscore in the text marks a mnemonic.
+    public final boolean isMnemonicParsing() {
+        return mnemonicParsing.get();
+    }
+
+    /// Sets whether an underscore in the text marks a mnemonic and is
+    /// left out of what is shown.
+    public final void setMnemonicParsing(boolean value) {
+        mnemonicParsing.set(value);
+    }
+
+    /// Whether an underscore in the text marks a mnemonic.
+    public final BooleanProperty mnemonicParsingProperty() {
+        return mnemonicParsing;
+    }
+
+    /// The text as a menu shows it: without the mark of a mnemonic when
+    /// mnemonics are parsed, and never `null`.
+    final String shownText() {
+        String t = getText();
+        if (t == null) {
+            return "";
+        }
+        return isMnemonicParsing() ? com.codename1.fxcompat.runtime.Mnemonics.strip(t) : t;
+    }
+
+    /// Chooses the item: sends it an `ActionEvent`.
+    ///
+    /// A disabled item fires too, as in OpenJFX, whose `MenuItem.fire()`
+    /// dispatches with no check (checked against javafx-controls 23): a
+    /// disabled item is kept from being chosen by the menu that shows it,
+    /// not by this method, and code that calls it directly gets the event.
+    public void fire() {
+        Event.fireEvent(this, new ActionEvent(this, this));
+    }
+
+    /// Adds a handler called in the bubbling phase.
+    public <E extends Event> void addEventHandler(EventType<E> eventType, EventHandler<E> eventHandler) {
+        events.addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler.
+    public <E extends Event> void removeEventHandler(EventType<E> eventType, EventHandler<E> eventHandler) {
+        events.removeEventHandler(eventType, eventHandler);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        EventDispatchChain chain = tail;
+        Menu menu = getParentMenu();
+        ContextMenu popup = getParentPopup();
+        if (menu != null) {
+            chain = menu.buildEventDispatchChain(chain);
+        } else if (popup != null) {
+            chain = popup.buildEventDispatchChain(chain);
+        }
+        return chain.prepend(events);
+    }
+
+    /// Returns the application's own object attached to this item.
+    public Object getUserData() {
+        return userData;
+    }
+
+    /// Attaches an object of the application to this item.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns a map for the application's own values on this item.
+    public ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[text=" + getText() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/MenuLink.java b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuLink.java
new file mode 100644
index 00000000000..3f6b30511d4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuLink.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.Side;
+import javafx.scene.Node;
+
+/// Keeps the popup of a [Menu] in step with its `showing` property: the
+/// popup opens beside a node while the menu shows and closes with it.
+final class MenuLink implements ChangeListener<Boolean> {
+
+    private final Menu menu;
+    private final Node anchor;
+    private final Side side;
+    private ContextMenu popup;
+
+    MenuLink(Menu menu, Node anchor, Side side) {
+        this.menu = menu;
+        this.anchor = anchor;
+        this.side = side;
+    }
+
+    /// Starts following the menu.
+    MenuLink attach() {
+        menu.showingProperty().addListener(this);
+        return this;
+    }
+
+    Menu menu() {
+        return menu;
+    }
+
+    Node anchor() {
+        return anchor;
+    }
+
+    /// Returns the open popup of the menu, or `null`.
+    ContextMenu popup() {
+        return popup;
+    }
+
+    /// Stops following the menu and closes it.
+    void detach() {
+        menu.hide();
+        menu.showingProperty().removeListener(this);
+        close();
+    }
+
+    private void close() {
+        ContextMenu p = popup;
+        popup = null;
+        if (p != null) {
+            p.hide();
+        }
+    }
+
+    @Override
+    public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
+        if (newValue != null && newValue.booleanValue()) {
+            if (popup == null) {
+                ContextMenu p = new ContextMenu(menu);
+                popup = p;
+                p.show(anchor, side, 0, 0);
+            }
+        } else {
+            close();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/MenuRow.java b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuRow.java
new file mode 100644
index 00000000000..d6ad9453bcc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/MenuRow.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.geometry.Insets;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// The row of one item in an open menu: its text, after room for the
+/// mark of a selected [CheckMenuItem].
+final class MenuRow extends Label {
+
+    private static final double MARK = 8;
+
+    private final Region mark;
+
+    MenuRow(String text, boolean marked) {
+        super(text);
+        if (marked) {
+            mark = new Region();
+            mark.setBackground(new Background(
+                    new BackgroundFill(Color.rgb(60, 60, 60), new CornerRadii(2), Insets.EMPTY)));
+            mark.setManaged(false);
+            cn1Children().add(mark);
+        } else {
+            mark = null;
+        }
+    }
+
+    /// Returns whether the row shows the mark of a selected item.
+    boolean marked() {
+        return mark != null;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        if (mark != null) {
+            mark.resizeRelocate(7, Math.max(0, (getHeight() - MARK) / 2), MARK, MARK);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/MultipleSelectionModel.java b/maven/javafx-compat/src/main/java/javafx/scene/control/MultipleSelectionModel.java
new file mode 100644
index 00000000000..499bff82086
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/MultipleSelectionModel.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ObjectPropertyBase;
+import javafx.collections.ObservableList;
+
+/// A selection of any number of rows, or of one when the mode is
+/// [SelectionMode#SINGLE].
+public abstract class MultipleSelectionModel<T> extends SelectionModel<T> {
+
+    private final ObjectProperty<SelectionMode> selectionMode = new ObjectPropertyBase<SelectionMode>(
+            SelectionMode.SINGLE) {
+        @Override
+        protected void invalidated() {
+            if (get() == SelectionMode.SINGLE && !isEmpty()) {
+                // One row survives a switch back to single selection.
+                int kept = getSelectedIndex();
+                clearSelection();
+                select(kept);
+            }
+        }
+
+        @Override
+        public Object getBean() {
+            return MultipleSelectionModel.this;
+        }
+
+        @Override
+        public String getName() {
+            return "selectionMode";
+        }
+    };
+
+    /// Creates a model with nothing selected, in single selection mode.
+    public MultipleSelectionModel() {
+    }
+
+    /// Sets how many rows may be selected.
+    public final void setSelectionMode(SelectionMode value) {
+        selectionMode.set(value);
+    }
+
+    /// Returns how many rows may be selected.
+    public final SelectionMode getSelectionMode() {
+        return selectionMode.get();
+    }
+
+    /// How many rows may be selected.
+    public final ObjectProperty<SelectionMode> selectionModeProperty() {
+        return selectionMode;
+    }
+
+    /// Returns the selected indices, in ascending order. The list cannot
+    /// be modified.
+    public abstract ObservableList<Integer> getSelectedIndices();
+
+    /// Returns the selected items, in the order of their indices. The
+    /// list cannot be modified.
+    public abstract ObservableList<T> getSelectedItems();
+
+    /// Selects several indices, keeping what is selected.
+    public abstract void selectIndices(int index, int... indices);
+
+    /// Selects the indices from `start` up to, not including, `end`.
+    public void selectRange(final int start, final int end) {
+        if (start == end) {
+            return;
+        }
+        boolean up = start < end;
+        int low = up ? start : end;
+        int high = up ? end : start;
+        int count = high - low - 1;
+        int[] rest = new int[count];
+        int first = up ? low : high;
+        int next = up ? low + 1 : high - 1;
+        for (int i = 0; i < count; i++) {
+            rest[i] = up ? next++ : next--;
+        }
+        selectIndices(first, rest);
+    }
+
+    /// Selects every row.
+    public abstract void selectAll();
+
+    @Override
+    public abstract void selectFirst();
+
+    @Override
+    public abstract void selectLast();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Pagination.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Pagination.java
new file mode 100644
index 00000000000..9a0d108475f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Pagination.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.util.Callback;
+
+/// Pages of content with a row of page numbers below to move among them.
+///
+/// The page factory is asked for the content of the current page whenever
+/// that page changes; a factory that answers `null` for an index leaves
+/// the page that was showing and the index it had. Below the page are a
+/// button to the previous page, one button per page number -- at most
+/// [#getMaxPageIndicatorCount()] of them, the group that holds the
+/// current page -- a button to the next page, and `current/count`.
+///
+/// The page changes at once: nothing slides. The style class
+/// [#STYLE_CLASS_BULLET] is accepted and the indicators stay numbered.
+public class Pagination extends Control {
+
+    /// The page count of a pagination that does not know how many pages
+    /// there are.
+    public static final int INDETERMINATE = Integer.MAX_VALUE;
+
+    /// The style class that asks for bullets in place of page numbers.
+    public static final String STYLE_CLASS_BULLET = "bullet";
+
+    private final IntegerProperty pageCount = new SimpleIntegerProperty(this, "pageCount", INDETERMINATE);
+    private final IntegerProperty currentPageIndex = new SimpleIntegerProperty(this, "currentPageIndex", 0);
+    private final IntegerProperty maxPageIndicatorCount = new SimpleIntegerProperty(this, "maxPageIndicatorCount",
+            10);
+    private final ObjectProperty<Callback<Integer, Node>> pageFactory =
+            new SimpleObjectProperty<Callback<Integer, Node>>(this, "pageFactory");
+    private final StackPane page = new StackPane();
+    private final HBox numbers = new HBox(4);
+    private final Label place = new Label();
+    private int shown = -1;
+    private boolean moving;
+
+    /// Creates a pagination of an unknown number of pages, at the first.
+    public Pagination() {
+        this(INDETERMINATE, 0);
+    }
+
+    /// Creates a pagination of a number of pages, at the first.
+    public Pagination(int pageCount) {
+        this(pageCount, 0);
+    }
+
+    /// Creates a pagination of a number of pages at a page.
+    public Pagination(int pageCount, int pageIndex) {
+        getStyleClass().add("pagination");
+        setFocusTraversable(false);
+        numbers.setAlignment(Pos.CENTER);
+        numbers.getStyleClass().add("control-box");
+        place.getStyleClass().add("page-information");
+        VBox.setVgrow(page, Priority.ALWAYS);
+        VBox below = new VBox(2, numbers, place);
+        below.setAlignment(Pos.CENTER);
+        below.setPadding(new Insets(6, 0, 6, 0));
+        below.getStyleClass().add("pagination-control");
+        VBox whole = new VBox(page, below);
+        this.pageCount.addListener((observable, was, now) -> changed());
+        this.currentPageIndex.addListener((observable, was, now) -> changed());
+        this.maxPageIndicatorCount.addListener((observable, was, now) -> changed());
+        this.pageFactory.addListener((observable, was, now) -> {
+            shown = -1;
+            changed();
+        });
+        setPageCount(pageCount);
+        setCurrentPageIndex(pageIndex);
+        cn1MadeOf(whole);
+        changed();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    private void changed() {
+        if (moving) {
+            return;
+        }
+        moving = true;
+        try {
+            int count = Math.max(1, getPageCount());
+            int at = Math.max(0, Math.min(count - 1, getCurrentPageIndex()));
+            if (at != getCurrentPageIndex()) {
+                currentPageIndex.set(at);
+            }
+            Callback<Integer, Node> factory = getPageFactory();
+            if (at != shown && factory != null) {
+                Node content = factory.call(Integer.valueOf(at));
+                if (content == null && shown >= 0) {
+                    // No such page: stay on the one that is showing.
+                    at = shown;
+                    currentPageIndex.set(at);
+                } else {
+                    shown = at;
+                    if (content == null) {
+                        page.getChildren().clear();
+                    } else {
+                        page.getChildren().setAll(content);
+                    }
+                }
+            }
+            indicators(at, count);
+        } finally {
+            moving = false;
+        }
+        requestLayout();
+    }
+
+    private void indicators(final int at, int count) {
+        int per = Math.max(1, getMaxPageIndicatorCount());
+        int first = at / per * per;
+        int last = (int) Math.min((long) first + per, count);
+        numbers.getChildren().clear();
+        Button back = new Button("<");
+        back.getStyleClass().add("left-arrow-button");
+        back.setDisable(at <= 0);
+        back.setOnAction(e -> setCurrentPageIndex(at - 1));
+        numbers.getChildren().add(back);
+        for (int i = first; i < last; i++) {
+            final int index = i;
+            ToggleButton number = new ToggleButton(String.valueOf(i + 1));
+            number.getStyleClass().add("number-button");
+            number.setSelected(i == at);
+            number.setOnAction(e -> {
+                setCurrentPageIndex(index);
+                changed();
+            });
+            numbers.getChildren().add(number);
+        }
+        Button on = new Button(">");
+        on.getStyleClass().add("right-arrow-button");
+        on.setDisable(at >= count - 1);
+        on.setOnAction(e -> setCurrentPageIndex(at + 1));
+        numbers.getChildren().add(on);
+        place.setText((at + 1) + "/" + (getPageCount() == INDETERMINATE ? "..." : String.valueOf(count)));
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    /// Returns the number of pages, or [#INDETERMINATE].
+    public final int getPageCount() {
+        return pageCount.get();
+    }
+
+    /// Sets the number of pages, which must be at least one.
+    public final void setPageCount(int value) {
+        if (value < 1) {
+            throw new IllegalArgumentException("Page count must be at least 1");
+        }
+        pageCount.set(value);
+    }
+
+    /// The number of pages.
+    public final IntegerProperty pageCountProperty() {
+        return pageCount;
+    }
+
+    /// Returns the index of the page that is showing, from zero.
+    public final int getCurrentPageIndex() {
+        return currentPageIndex.get();
+    }
+
+    /// Shows a page; an index outside the pages is the nearest page.
+    public final void setCurrentPageIndex(int value) {
+        currentPageIndex.set(value);
+    }
+
+    /// The index of the page that is showing.
+    public final IntegerProperty currentPageIndexProperty() {
+        return currentPageIndex;
+    }
+
+    /// Returns how many page numbers are shown at a time.
+    public final int getMaxPageIndicatorCount() {
+        return maxPageIndicatorCount.get();
+    }
+
+    /// Sets how many page numbers are shown at a time.
+    public final void setMaxPageIndicatorCount(int value) {
+        maxPageIndicatorCount.set(value);
+    }
+
+    /// How many page numbers are shown at a time.
+    public final IntegerProperty maxPageIndicatorCountProperty() {
+        return maxPageIndicatorCount;
+    }
+
+    /// Returns what makes the content of a page from its index.
+    public final Callback<Integer, Node> getPageFactory() {
+        return pageFactory.get();
+    }
+
+    /// Sets what makes the content of a page from its index.
+    public final void setPageFactory(Callback<Integer, Node> value) {
+        pageFactory.set(value);
+    }
+
+    /// What makes the content of a page from its index.
+    public final ObjectProperty<Callback<Integer, Node>> pageFactoryProperty() {
+        return pageFactory;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/PasswordField.java b/maven/javafx-compat/src/main/java/javafx/scene/control/PasswordField.java
new file mode 100644
index 00000000000..e7606d70655
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/PasswordField.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// A text field that hides what is typed, shown as a Codename One
+/// `TextField` with the password constraint. The text property holds the
+/// real characters.
+public class PasswordField extends TextField {
+
+    /// Creates an empty password field.
+    public PasswordField() {
+        getStyleClass().add("password-field");
+    }
+
+    @Override
+    int nativeConstraint() {
+        return com.codename1.ui.TextArea.PASSWORD;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/PopupControl.java b/maven/javafx-compat/src/main/java/javafx/scene/control/PopupControl.java
new file mode 100644
index 00000000000..a63c32ba894
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/PopupControl.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableSet;
+import javafx.css.PseudoClass;
+import javafx.css.Styleable;
+import javafx.stage.PopupWindow;
+
+/// A popup that a style sheet can address: the base of context menus and
+/// tooltips.
+///
+/// The id, the style classes and the inline style are recorded. There
+/// are no skins in this layer, so the skin and the size properties of
+/// JavaFX are absent; a popup takes the preferred size of its content.
+public class PopupControl extends PopupWindow implements Styleable {
+
+    private final StringProperty id = new SimpleStringProperty(this, "id");
+    private final StringProperty style = new SimpleStringProperty(this, "style", "");
+    private final ObservableList<String> styleClass = FXCollections.observableArrayList();
+
+    /// Creates a popup that is not showing.
+    public PopupControl() {
+    }
+
+    /// The id a style sheet matches.
+    public final StringProperty idProperty() {
+        return id;
+    }
+
+    /// Sets the id a style sheet matches.
+    public final void setId(String value) {
+        id.set(value);
+    }
+
+    @Override
+    public final String getId() {
+        return id.get();
+    }
+
+    @Override
+    public final ObservableList<String> getStyleClass() {
+        return styleClass;
+    }
+
+    /// Sets the inline style; recorded.
+    public final void setStyle(String value) {
+        style.set(value);
+    }
+
+    @Override
+    public final String getStyle() {
+        return style.get();
+    }
+
+    /// The inline style.
+    public final StringProperty styleProperty() {
+        return style;
+    }
+
+    @Override
+    public String getTypeSelector() {
+        return "PopupControl";
+    }
+
+    @Override
+    public Styleable getStyleableParent() {
+        return getOwnerNode();
+    }
+
+    @Override
+    public final ObservableSet<PseudoClass> getPseudoClassStates() {
+        return FXCollections.<PseudoClass>emptyObservableSet();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ProgressBar.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ProgressBar.java
new file mode 100644
index 00000000000..6936dacfe5e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ProgressBar.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.geometry.Insets;
+import javafx.scene.layout.Region;
+
+/// A bar that fills with progress.
+///
+/// The bar is two regions a style sheet reaches as it does in JavaFX: a
+/// `.track` the size of the control and, in it, a `.bar` whose width is
+/// the progress, from 0 to 1. Until a sheet says otherwise the track is
+/// the standard theme's inset well and the bar its accent colour. A
+/// negative progress is indeterminate: a segment of the track runs from
+/// one end to the other and back while the bar is in a scene.
+///
+/// The preferred size is 100 by 18 logical pixels, and `setPrefWidth`
+/// makes a longer or a shorter bar.
+public class ProgressBar extends ProgressIndicator {
+
+    private static final double DEFAULT_WIDTH = 100;
+    private static final double DEFAULT_HEIGHT = 18;
+    private static final double SEGMENT = 0.4;
+    private static final long SWEEP_MILLIS = 1200;
+
+    private final Region track = new Part("track",
+            "-fx-background-color: -fx-shadow-highlight-color, -fx-text-box-border,"
+                    + " derive(-fx-control-inner-background, -4%); -fx-background-insets: 0, 0 0 1 0, 1 1 2 1;"
+                    + " -fx-background-radius: 4, 3, 2;");
+    private final Region bar = new Part("bar",
+            "-fx-background-color: -fx-accent; -fx-background-insets: 3 3 4 3; -fx-background-radius: 2;");
+
+    /// One of the two regions of a bar, with the standard theme's look
+    /// below whatever a style sheet gives it.
+    private static final class Part extends Region {
+        private final String look;
+
+        Part(String styleClass, String look) {
+            this.look = look;
+            getStyleClass().add(styleClass);
+            setManaged(false);
+            setMouseTransparent(true);
+        }
+
+        @Override
+        public String cn1DefaultStyle() {
+            return look;
+        }
+    }
+
+    /// Creates an indeterminate progress bar.
+    public ProgressBar() {
+        this(INDETERMINATE_PROGRESS);
+    }
+
+    /// Creates a progress bar at a progress.
+    public ProgressBar(double progress) {
+        super(progress, false);
+        getStyleClass().setAll("progress-bar");
+        cn1Children().add(track);
+        cn1Children().add(bar);
+        built = true;
+    }
+
+    /// Returns the part of the track that is filled, as
+    /// `{start, length}` in fractions of the track: the progress from the
+    /// start, or where the running segment is at a time in milliseconds.
+    static double[] filledPart(double progress, long millis) {
+        if (progress >= 0) {
+            return new double[] {0, Math.min(1, progress)};
+        }
+        long t = millis % (2 * SWEEP_MILLIS);
+        double along = t < SWEEP_MILLIS ? t / (double) SWEEP_MILLIS : 2 - t / (double) SWEEP_MILLIS;
+        return new double[] {along * (1 - SEGMENT), SEGMENT};
+    }
+
+    @Override
+    void paintProgress(com.codename1.fxcompat.runtime.Renderer renderer, double x, double y, double w, double h) {
+        // The two regions are the bar.
+    }
+
+    @Override
+    void progressShown() {
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double w = Math.max(0, getWidth() - x - in.getRight());
+        double h = Math.max(0, getHeight() - y - in.getBottom());
+        track.resizeRelocate(x, y, w, h);
+        double[] part = filledPart(getProgress(), frameMillis());
+        double filled = w * part[1];
+        bar.setVisible(filled > 0);
+        bar.resizeRelocate(x + w * part[0], y, filled, h);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        progressShown();
+    }
+
+    @Override
+    double contentPrefWidth() {
+        return DEFAULT_WIDTH;
+    }
+
+    @Override
+    double contentPrefHeight() {
+        return DEFAULT_HEIGHT;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ProgressIndicator.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ProgressIndicator.java
new file mode 100644
index 00000000000..70cef46048c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ProgressIndicator.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.CssEngine;
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FrameClock;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.ui.Component;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.css.PseudoClass;
+import javafx.geometry.Insets;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+
+/// A round indicator of progress, drawn by the control itself: it has no
+/// native component, so it looks and measures the same on every theme.
+///
+/// A negative progress is indeterminate and shows a ring of dots, the
+/// brightest of which runs round the ring while the indicator is in a
+/// scene. From 0 to 1 the control draws a disc that fills clockwise from
+/// the top and, below it, the percentage; at 1 the disc is full, carries
+/// a tick, and the text is `Done`. The pseudo-classes `indeterminate` and
+/// `determinate` follow the progress.
+///
+/// The preferred size is that of a small disc with its line of text below
+/// it; a larger indicator is asked for with `setPrefSize`.
+public class ProgressIndicator extends Control {
+
+    /// The progress of an indicator that does not know how far it is.
+    public static final double INDETERMINATE_PROGRESS = -1;
+
+    /// The colour of the part that is done where no rule defines
+    /// `-fx-progress-color` or `-fx-accent`: the accent of JavaFX.
+    static final Color ACCENT = Color.rgb(0, 150, 201);
+
+    private static final int PROGRESS = Dirty.USER;
+    private static final double DEFAULT_DISC = 32;
+    private static final double TEXT_GAP = 2;
+    private static final int DOTS = 12;
+    private static final long STEP_MILLIS = 100;
+    private static final String DONE_TEXT = "Done";
+    private static final PseudoClass INDETERMINATE = PseudoClass.getPseudoClass("indeterminate");
+    private static final PseudoClass DETERMINATE = PseudoClass.getPseudoClass("determinate");
+    private static final Color TRACK = Color.gray(0.73);
+
+    /// The text below the disc, which a style sheet reaches as
+    /// `.percentage`; `null` in a bar, which has none.
+    private final Text percentage;
+
+    private final DoubleProperty progress = new FxDouble(this, "progress", INDETERMINATE_PROGRESS,
+            PROGRESS | Dirty.PAINT);
+    private final ReadOnlyBooleanWrapper indeterminate = new ReadOnlyBooleanWrapper(this, "indeterminate", true);
+    private long frameMillis;
+
+    /// Whether the constructors are through: the progress is set by the
+    /// first of them, before a bar has the regions it would place.
+    boolean built;
+    private final FrameClock.Pulse frames = new FrameClock.Pulse() {
+        @Override
+        public void pulse(long nowNanos) {
+            if (!seen()) {
+                // On a tab that is not selected, or under anything else
+                // that is hidden, nothing turns: the clock is left, and
+                // with nothing else running it stops and the application
+                // is idle. The next paint, which only something visible
+                // gets, takes the frames up again.
+                FrameClock.remove(frames);
+                return;
+            }
+            frameMillis = nowNanos / 1000000L;
+            // A peer that is on no form is not drawn.
+            progressShown();
+            if (cn1HasPeer() && cn1Peer().getComponentForm() != null) {
+                cn1Repaint();
+            }
+        }
+    };
+
+    /// Creates an indeterminate indicator.
+    public ProgressIndicator() {
+        this(INDETERMINATE_PROGRESS);
+    }
+
+    /// Creates an indicator at a progress.
+    public ProgressIndicator(double progress) {
+        this(progress, true);
+        built = true;
+    }
+
+    /// Creates an indicator with or without the line of text below it.
+    ProgressIndicator(double progress, boolean text) {
+        if (text) {
+            percentage = new Percentage();
+            cn1Children().add(percentage);
+        } else {
+            percentage = null;
+        }
+        getStyleClass().add("progress-indicator");
+        setFocusTraversable(false);
+        pseudoClassStateChanged(INDETERMINATE, true);
+        sceneProperty().addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                animate();
+            }
+        });
+        setProgress(progress);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    /// Whether the indicator and everything it is in are visible.
+    private boolean seen() {
+        for (javafx.scene.Node n = this; n != null; n = n.getParent()) {
+            if (!n.isVisible()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Runs the frames of the indeterminate look while it can be seen:
+    /// the progress is unknown and the indicator is in a scene. A frame
+    /// that finds it hidden stops them, and a paint starts them again.
+    private void animate() {
+        if (isIndeterminate() && getScene() != null) {
+            FrameClock.add(frames);
+        } else {
+            FrameClock.remove(frames);
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & PROGRESS) != 0) {
+            boolean unknown = getProgress() < 0;
+            indeterminate.set(unknown);
+            pseudoClassStateChanged(INDETERMINATE, unknown);
+            pseudoClassStateChanged(DETERMINATE, !unknown);
+            animate();
+            if (built) {
+                progressShown();
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    /// Returns the time of the frame the indeterminate look is at, in
+    /// milliseconds.
+    final long frameMillis() {
+        return frameMillis;
+    }
+
+    /// The text of an indicator: the text of the scene's background until
+    /// a style sheet fills it otherwise.
+    private static final class Percentage extends Text {
+        Percentage() {
+            getStyleClass().add("percentage");
+            setManaged(false);
+            setMouseTransparent(true);
+            setTextOrigin(javafx.geometry.VPos.TOP);
+        }
+
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-fill: -fx-text-background-color;";
+        }
+    }
+
+    /// Returns the colour of the part that is done: `-fx-progress-color`
+    /// where a rule defines it, which the standard theme does as the
+    /// accent colour.
+    final Color progressColor() {
+        Color c = CssEngine.themeColor(this, "-fx-progress-color");
+        return c == null ? ACCENT : c;
+    }
+
+    /// Brings what the indicator is made of up to date with its progress
+    /// and its size: here the text, in a bar its two regions.
+    void progressShown() {
+        if (percentage == null) {
+            return;
+        }
+        boolean shown = !isIndeterminate();
+        percentage.setVisible(shown);
+        if (!shown) {
+            return;
+        }
+        String text = progressText();
+        if (!text.equals(percentage.getText())) {
+            percentage.setText(text);
+        }
+        Insets in = getInsets();
+        double w = getWidth() - in.getLeft() - in.getRight();
+        double h = getHeight() - in.getTop() - in.getBottom();
+        Font font = percentage.getFont();
+        double below = TEXT_GAP + Fonts.lineHeight(font);
+        double d = Math.min(w, h - below);
+        if (!(d > 2)) {
+            percentage.setVisible(false);
+            return;
+        }
+        double top = in.getTop() + Math.max(0, (h - d - below) / 2);
+        percentage.relocate(in.getLeft() + (w - Fonts.width(font, text)) / 2, top + d + TEXT_GAP);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        progressShown();
+    }
+
+    /// Returns the text shown below the disc of a determinate indicator.
+    private String progressText() {
+        double p = getProgress();
+        if (p >= 1) {
+            return DONE_TEXT;
+        }
+        return ((int) Math.round(Math.max(0, p) * 100)) + "%";
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        super.cn1Paint(renderer);
+        animate();
+        Insets in = getInsets();
+        double w = getWidth() - in.getLeft() - in.getRight();
+        double h = getHeight() - in.getTop() - in.getBottom();
+        if (w > 0 && h > 0) {
+            paintProgress(renderer, in.getLeft(), in.getTop(), w, h);
+        }
+    }
+
+    /// Draws the indicator in a rectangle, the control less its insets; a
+    /// progress bar draws a bar instead.
+    void paintProgress(Renderer renderer, double x, double y, double w, double h) {
+        if (isIndeterminate()) {
+            paintRing(renderer, x, y, w, h);
+            return;
+        }
+        Font font = percentage == null ? Font.getDefault() : percentage.getFont();
+        Color done = progressColor();
+        double below = TEXT_GAP + Fonts.lineHeight(font);
+        double d = Math.min(w, h - below);
+        if (!(d > 2)) {
+            // No room for the text: the disc alone.
+            d = Math.min(w, h);
+            below = 0;
+        }
+        if (!(d > 2)) {
+            return;
+        }
+        double r = d / 2 - 0.5;
+        double cx = x + w / 2;
+        double top = y + Math.max(0, (h - d - below) / 2);
+        double cy = top + d / 2;
+        double p = Math.min(1, getProgress());
+        FxPath disc = new FxPath();
+        disc.addEllipse(cx, cy, r, r);
+        if (p >= 1) {
+            renderer.fill(disc, done, cx - r, cy - r, 2 * r, 2 * r);
+            FxPath tick = new FxPath();
+            tick.moveTo(cx - r * 0.45, cy + r * 0.05);
+            tick.lineTo(cx - r * 0.1, cy + r * 0.4);
+            tick.lineTo(cx + r * 0.5, cy - r * 0.35);
+            renderer.stroke(tick, Color.WHITE, Math.max(1, r * 0.2), StrokeLineCap.ROUND, StrokeLineJoin.ROUND, 10,
+                    null, 0);
+        } else {
+            renderer.fill(disc, Color.WHITE, cx - r, cy - r, 2 * r, 2 * r);
+            if (p > 0) {
+                FxPath pie = new FxPath();
+                pie.moveTo(cx, cy);
+                pie.addArc(cx, cy, r, r, 90, -360 * p, true);
+                pie.closePath();
+                renderer.fill(pie, done, cx - r, cy - r, 2 * r, 2 * r);
+            }
+            renderer.stroke(disc, TRACK, 1, StrokeLineCap.BUTT, StrokeLineJoin.MITER, 10, null, 0);
+        }
+    }
+
+    private void paintRing(Renderer renderer, double x, double y, double w, double h) {
+        double d = Math.min(w, h);
+        if (!(d > 4)) {
+            return;
+        }
+        double dot = d * 0.06;
+        double ring = d / 2 - dot;
+        double cx = x + w / 2;
+        double cy = y + h / 2;
+        Color done = progressColor();
+        int lead = (int) ((frameMillis / STEP_MILLIS) % DOTS);
+        for (int i = 0; i < DOTS; i++) {
+            // The dot the lead left longest ago is the faintest.
+            int age = (lead - i + DOTS) % DOTS;
+            double strength = 1 - age / (double) DOTS;
+            double angle = 2 * Math.PI * i / DOTS - Math.PI / 2;
+            double px = cx + ring * Math.cos(angle);
+            double py = cy + ring * Math.sin(angle);
+            FxPath p = new FxPath();
+            p.addEllipse(px, py, dot, dot);
+            renderer.fill(p, done.deriveColor(0, 1, 1, 0.15 + 0.85 * strength), px - dot, py - dot, 2 * dot,
+                    2 * dot);
+        }
+    }
+
+    /// Returns the preferred width inside the insets.
+    double contentPrefWidth() {
+        Font font = Font.getDefault();
+        return Math.max(DEFAULT_DISC, Math.max(Fonts.width(font, DONE_TEXT), Fonts.width(font, "100%")));
+    }
+
+    /// Returns the preferred height inside the insets.
+    double contentPrefHeight() {
+        return DEFAULT_DISC + TEXT_GAP + Fonts.lineHeight(Font.getDefault());
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + snapSizeX(contentPrefWidth()) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + snapSizeY(contentPrefHeight()) + in.getBottom();
+    }
+
+    /// Returns the progress: negative for unknown, else 0 to 1.
+    public final double getProgress() {
+        return progress.get();
+    }
+
+    /// Sets the progress: negative for unknown, else 0 to 1.
+    public final void setProgress(double value) {
+        progress.set(value);
+    }
+
+    /// The progress.
+    public final DoubleProperty progressProperty() {
+        return progress;
+    }
+
+    /// Returns whether the progress is unknown.
+    public final boolean isIndeterminate() {
+        return indeterminate.get();
+    }
+
+    /// Whether the progress is unknown.
+    public final ReadOnlyBooleanProperty indeterminateProperty() {
+        return indeterminate.getReadOnlyProperty();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/RadioButton.java b/maven/javafx-compat/src/main/java/javafx/scene/control/RadioButton.java
new file mode 100644
index 00000000000..4ecc5fc7734
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/RadioButton.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+
+import javafx.scene.Node;
+
+/// One choice of several, shown as a Codename One `RadioButton`. Radio
+/// buttons that exclude each other share a [ToggleGroup].
+///
+/// Pressing a selected radio button that is in a group leaves it
+/// selected; only selecting another one of the group deselects it.
+public class RadioButton extends ToggleButton {
+
+    /// Creates a radio button with no text.
+    public RadioButton() {
+        init();
+    }
+
+    /// Creates a radio button with text.
+    public RadioButton(String text) {
+        super(text);
+        init();
+    }
+
+    /// Creates a radio button with text and a graphic.
+    public RadioButton(String text, Node graphic) {
+        super(text, graphic);
+        init();
+    }
+
+    private void init() {
+        getStyleClass().setAll("radio-button");
+        // A radio button is text beside a mark, not a centred button.
+        setAlignment(javafx.geometry.Pos.CENTER_LEFT);
+    }
+
+    @Override
+    boolean cn1OwnsChrome() {
+        return false;
+    }
+
+    @Override
+    public String cn1ThemedStyle() {
+        return null;
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.RadioButton b = new com.codename1.ui.RadioButton();
+        // The toggle group decides; the native button never turns itself
+        // off on its own.
+        b.addActionListener(cn1ActionBridge());
+        return b;
+    }
+
+    /// Selects the radio button and fires an `ActionEvent`; does nothing
+    /// when it is already the selected one of a group.
+    @Override
+    public void fire() {
+        if (getToggleGroup() == null || !isSelected()) {
+            super.fire();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/RowFlow.java b/maven/javafx-compat/src/main/java/javafx/scene/control/RowFlow.java
new file mode 100644
index 00000000000..d0c9056475e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/RowFlow.java
@@ -0,0 +1,361 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// The scrolling body of a list or a table: rows of one height, of which
+/// only those in view have cells.
+///
+/// The cells are children of this region and its peer clips them, so a
+/// row scrolled half out of view is cut at the edge. There is one group
+/// of cells per visible row, one cell per column; a row keeps its cells
+/// while it stays in view and a row that scrolls in takes over the cells
+/// of the one that left. The rows below the last item are shown as empty
+/// cells.
+///
+/// Scrolling is vertical: by the wheel, by dragging, and by
+/// [#show(int)]. A thin thumb at the trailing edge shows the position.
+final class RowFlow extends Region {
+
+    /// What a view tells its flow.
+    interface Rows {
+        /// The number of rows.
+        int rowCount();
+
+        /// The number of columns; a list has one.
+        int columnCount();
+
+        /// Fills the x and width of every column for a body of a width.
+        void columns(double width, double[] x, double[] w);
+
+        /// Creates a cell of a column.
+        IndexedCell<?> createCell(int column);
+
+        /// Shows a row in a cell, or nothing with a row of -1.
+        void updateCell(IndexedCell<?> cell, int column, int row, boolean force);
+
+        /// The height the application fixed for every row, or 0.
+        double fixedCellSize();
+    }
+
+    private static final double DEFAULT_ROW = 24;
+    private static final double DRAG_SLOP = 6;
+    private static final int MAX_VISIBLE = 400;
+
+    private final Rows rows;
+    private final ArrayList<IndexedCell<?>[]> slots = new ArrayList<IndexedCell<?>[]>();
+    private final Region thumb = new Region();
+    private double offset;
+    private double measured;
+    private boolean force;
+    private double pressY;
+    private double pressOffset;
+    private boolean dragging;
+    private int pendingRow = -1;
+
+    RowFlow(Rows rows) {
+        this.rows = rows;
+        thumb.setMouseTransparent(true);
+        thumb.setManaged(false);
+        thumb.setVisible(false);
+        thumb.setBackground(new Background(new BackgroundFill(Color.color(0, 0, 0, 0.35), new CornerRadii(2),
+                Insets.EMPTY)));
+        cn1Children().add(thumb);
+        addEventHandler(ScrollEvent.SCROLL, new EventHandler<ScrollEvent>() {
+            @Override
+            public void handle(ScrollEvent event) {
+                double before = offset;
+                scrollTo(offset - event.getDeltaY());
+                if (Double.compare(before, offset) != 0) {
+                    event.consume();
+                }
+            }
+        });
+        addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                pressY = event.getSceneY();
+                pressOffset = offset;
+                dragging = false;
+            }
+        });
+        addEventHandler(MouseEvent.MOUSE_DRAGGED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                double moved = event.getSceneY() - pressY;
+                if (!dragging && Math.abs(moved) > DRAG_SLOP) {
+                    dragging = true;
+                }
+                if (dragging) {
+                    scrollTo(pressOffset - moved);
+                }
+            }
+        });
+    }
+
+    /// Whether every second row is shaded across the whole view, and the
+    /// room below the last row as rows would be, which the standard theme
+    /// does in a list and a table, not a tree.
+    boolean stripes;
+
+    @Override
+    public void cn1Paint(com.codename1.fxcompat.runtime.Renderer renderer) {
+        super.cn1Paint(renderer);
+        double rh = rowHeight();
+        // A view with no rows at all is left plain: JavaFX makes no cells
+        // for it, so there is nothing for the theme's odd rows to match.
+        if (!stripes || !(rh > 0) || rows.rowCount() <= 0) {
+            return;
+        }
+        // From the first row in view: a row is shaded to the edge of the
+        // view, past its last cell, and so is the room below the rows.
+        int first = (int) Math.floor(offset / rh);
+        double y = first * rh - offset;
+        Color alt = com.codename1.fxcompat.runtime.CssEngine.themeColor(this, "-fx-control-inner-background-alt");
+        if (alt == null) {
+            return;
+        }
+        for (int row = first; y < getHeight(); row++, y += rh) {
+            if ((row & 1) != 0 && y + rh > 0) {
+                double top = Math.max(0, y);
+                renderer.fillRect(0, top, getWidth(), Math.min(y + rh, getHeight()) - top, alt);
+            }
+        }
+    }
+
+    /// Returns the height of a row.
+    double rowHeight() {
+        double fixed = rows.fixedCellSize();
+        if (fixed > 0) {
+            return fixed;
+        }
+        return measured > 0 ? measured : DEFAULT_ROW;
+    }
+
+    double offset() {
+        return offset;
+    }
+
+    private double maxOffset() {
+        return Math.max(0, rows.rowCount() * rowHeight() - getHeight());
+    }
+
+    /// Scrolls so that the body starts `value` below the first row.
+    void scrollTo(double value) {
+        double max = maxOffset();
+        double v = value < 0 || Double.isNaN(value) ? 0 : (value > max ? max : value);
+        if (Double.compare(v, offset) != 0) {
+            offset = v;
+            requestLayout();
+        }
+    }
+
+    /// Scrolls so that a row is the first one shown, as far as the rows
+    /// reach.
+    void show(int row) {
+        pendingRow = row < 0 ? 0 : row;
+        requestLayout();
+    }
+
+    /// Returns the row at a y of this region, -1 below the last one.
+    int rowAt(double y) {
+        double h = rowHeight();
+        if (y < 0 || h <= 0) {
+            return -1;
+        }
+        int row = (int) Math.floor((y + offset) / h);
+        return row >= 0 && row < rows.rowCount() ? row : -1;
+    }
+
+    /// Returns the row under an event of the scene, -1 for none.
+    int rowAt(MouseEvent event) {
+        Point2D p = sceneToLocal(event.getSceneX(), event.getSceneY());
+        return rowAt(p.getY());
+    }
+
+    /// Returns the cell that shows a row in a column, or `null` when the
+    /// row is out of view.
+    IndexedCell<?> cell(int row, int column) {
+        for (int i = 0; i < slots.size(); i++) {
+            IndexedCell<?>[] slot = slots.get(i);
+            if (column < slot.length && slot[column].getIndex() == row) {
+                return slot[column];
+            }
+        }
+        return null;
+    }
+
+    /// Returns the cells of every visible row, row by row.
+    ArrayList<IndexedCell<?>[]> slots() {
+        return slots;
+    }
+
+    /// The rows changed: every cell is updated on the next layout.
+    void rowsChanged() {
+        requestLayout();
+    }
+
+    /// Shows every row again even where the item is the same.
+    void refresh() {
+        force = true;
+        requestLayout();
+    }
+
+    /// Drops every cell; the columns or the cell factory changed.
+    void rebuild() {
+        for (int i = 0; i < slots.size(); i++) {
+            IndexedCell<?>[] slot = slots.get(i);
+            for (int c = 0; c < slot.length; c++) {
+                cn1Children().remove(slot[c]);
+            }
+        }
+        slots.clear();
+        measured = 0;
+        requestLayout();
+    }
+
+    private IndexedCell<?>[] newSlot(int columns) {
+        IndexedCell<?>[] slot = new IndexedCell<?>[columns];
+        for (int c = 0; c < columns; c++) {
+            slot[c] = rows.createCell(c);
+            cn1Children().add(cn1Children().size() - 1, slot[c]);
+        }
+        return slot;
+    }
+
+    private void measure(int columns, int count) {
+        if (rows.fixedCellSize() > 0 || measured > 0 || columns == 0) {
+            return;
+        }
+        if (slots.isEmpty()) {
+            slots.add(newSlot(columns));
+        }
+        IndexedCell<?>[] slot = slots.get(0);
+        double h = 0;
+        for (int c = 0; c < slot.length; c++) {
+            rows.updateCell(slot[c], c, count > 0 ? 0 : -1, true);
+            h = Math.max(h, slot[c].prefHeight(-1));
+        }
+        if (h > 0 && count > 0) {
+            measured = h;
+        }
+    }
+
+    @Override
+    protected void layoutChildren() {
+        int columns = rows.columnCount();
+        int count = rows.rowCount();
+        if (!slots.isEmpty() && slots.get(0).length != columns) {
+            rebuild();
+        }
+        measure(columns, count);
+        double w = getWidth();
+        double h = getHeight();
+        double rh = rowHeight();
+        if (pendingRow >= 0) {
+            // Asked for before the height of a row was known.
+            offset = pendingRow * rh;
+            pendingRow = -1;
+        }
+        double max = maxOffset();
+        if (offset > max) {
+            offset = max;
+        }
+        int visible = rh > 0 && columns > 0 ? (int) Math.ceil(h / rh) + 1 : 0;
+        if (visible > MAX_VISIBLE) {
+            visible = MAX_VISIBLE;
+        }
+        while (slots.size() > visible) {
+            IndexedCell<?>[] gone = slots.remove(slots.size() - 1);
+            for (int c = 0; c < gone.length; c++) {
+                cn1Children().remove(gone[c]);
+            }
+        }
+        while (slots.size() < visible) {
+            slots.add(newSlot(columns));
+        }
+        double[] xs = new double[columns];
+        double[] ws = new double[columns];
+        rows.columns(w, xs, ws);
+        int first = rh > 0 ? (int) Math.floor(offset / rh) : 0;
+        for (int k = 0; k < visible; k++) {
+            int row = first + k;
+            // A row keeps its cells while it is in view.
+            IndexedCell<?>[] slot = slots.get(row % visible);
+            for (int c = 0; c < columns; c++) {
+                IndexedCell<?> cell = slot[c];
+                rows.updateCell(cell, c, row < count ? row : -1, force);
+                cell.setVisible(ws[c] > 0);
+                cell.resizeRelocate(xs[c], row * rh - offset, ws[c], rh);
+            }
+        }
+        force = false;
+        if (max > 0 && h > 0) {
+            double total = count * rh;
+            double th = Math.max(16, total > 0 ? h * h / total : h);
+            thumb.setVisible(true);
+            thumb.resizeRelocate(w - 5, offset / max * (h - th), 3, th);
+        } else {
+            thumb.setVisible(false);
+        }
+    }
+
+    @Override
+    protected Node cn1PickLocal(double x, double y) {
+        // Cells reach beyond the body; what is clipped cannot be hit.
+        return contains(x, y) ? super.cn1PickLocal(x, y) : null;
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        return 0;
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        return 0;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return 0;
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return 0;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/RowPress.java b/maven/javafx-compat/src/main/java/javafx/scene/control/RowPress.java
new file mode 100644
index 00000000000..81f81878d2b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/RowPress.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// What a press on a row does to the selection of a list or a table.
+final class RowPress {
+
+    private RowPress() {
+    }
+
+    /// Applies a press on a row and answers the row a later Shift press
+    /// extends from.
+    static <T> int apply(MultipleSelectionModel<T> model, boolean primary, boolean shortcut, boolean shift, int row,
+            int anchor) {
+        if (!primary) {
+            // A context menu acts on the row it was asked for.
+            if (!model.isSelected(row)) {
+                model.clearAndSelect(row);
+            }
+            return row;
+        }
+        boolean multiple = model.getSelectionMode() == SelectionMode.MULTIPLE;
+        if (multiple && shortcut) {
+            if (model.isSelected(row)) {
+                model.clearSelection(row);
+            } else {
+                model.select(row);
+            }
+            return row;
+        }
+        if (multiple && shift && anchor >= 0) {
+            model.clearSelection();
+            if (anchor <= row) {
+                model.selectRange(anchor, row + 1);
+            } else {
+                model.selectRange(anchor, row - 1);
+            }
+            return anchor;
+        }
+        model.clearAndSelect(row);
+        return row;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/RowSelection.java b/maven/javafx-compat/src/main/java/javafx/scene/control/RowSelection.java
new file mode 100644
index 00000000000..c439ebcfdbb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/RowSelection.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// The row selection the list view and the table view share: a sorted
+/// list of selected indices over the items of the view, kept right while
+/// the items change. The model that owns it publishes the result through
+/// its own `selectedIndex` and `selectedItem`.
+final class RowSelection<T> {
+
+    /// The model a selection reports to.
+    interface Owner<T> {
+        /// The items of the view; may be `null`.
+        ObservableList<T> rows();
+
+        /// Whether several rows may be selected.
+        boolean multiple();
+
+        /// Publishes the row selected last, -1 and `null` for none.
+        void lead(int index, T item);
+    }
+
+    private final Owner<T> owner;
+    private final ObservableList<Integer> indices = FXCollections.observableArrayList();
+    private final ObservableList<T> items = FXCollections.observableArrayList();
+    private final ObservableList<Integer> indicesView = FXCollections.unmodifiableObservableList(indices);
+    private final ObservableList<T> itemsView = FXCollections.unmodifiableObservableList(items);
+    private int lead = -1;
+
+    RowSelection(Owner<T> owner) {
+        this.owner = owner;
+    }
+
+    ObservableList<Integer> indices() {
+        return indicesView;
+    }
+
+    ObservableList<T> items() {
+        return itemsView;
+    }
+
+    private int count() {
+        ObservableList<T> rows = owner.rows();
+        return rows == null ? 0 : rows.size();
+    }
+
+    private T row(int index) {
+        ObservableList<T> rows = owner.rows();
+        return rows == null || index < 0 || index >= rows.size() ? null : rows.get(index);
+    }
+
+    /// Replaces the selection with a set of indices; the last valid one
+    /// given becomes the lead unless `newLead` names another.
+    private void commit(List<Integer> wanted, int newLead) {
+        ArrayList<Integer> sorted = new ArrayList<Integer>();
+        int n = count();
+        for (int i = 0; i < wanted.size(); i++) {
+            int v = wanted.get(i).intValue();
+            if (v < 0 || v >= n) {
+                continue;
+            }
+            int at = 0;
+            boolean present = false;
+            while (at < sorted.size()) {
+                int other = sorted.get(at).intValue();
+                if (other == v) {
+                    present = true;
+                    break;
+                }
+                if (other > v) {
+                    break;
+                }
+                at++;
+            }
+            if (!present) {
+                sorted.add(at, Integer.valueOf(v));
+            }
+        }
+        int l = newLead;
+        if (!sorted.contains(Integer.valueOf(l))) {
+            l = sorted.isEmpty() ? -1 : sorted.get(sorted.size() - 1).intValue();
+        }
+        if (!owner.multiple() && sorted.size() > 1) {
+            sorted.clear();
+            sorted.add(Integer.valueOf(l));
+        }
+        ArrayList<T> values = new ArrayList<T>();
+        for (int i = 0; i < sorted.size(); i++) {
+            values.add(row(sorted.get(i).intValue()));
+        }
+        lead = l;
+        if (!sorted.equals(indices)) {
+            indices.setAll(sorted);
+        }
+        if (!sameItems(values)) {
+            items.setAll(values);
+        }
+        owner.lead(l, row(l));
+    }
+
+    private boolean sameItems(List<T> values) {
+        if (values.size() != items.size()) {
+            return false;
+        }
+        for (int i = 0; i < values.size(); i++) {
+            if (values.get(i) != items.get(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    void clearAndSelect(int index) {
+        ArrayList<Integer> one = new ArrayList<Integer>();
+        one.add(Integer.valueOf(index));
+        commit(one, index);
+    }
+
+    void select(int index) {
+        if (index == -1) {
+            clear();
+            return;
+        }
+        if (index < 0 || index >= count()) {
+            return;
+        }
+        ArrayList<Integer> next = new ArrayList<Integer>();
+        if (owner.multiple()) {
+            next.addAll(indices);
+        }
+        next.add(Integer.valueOf(index));
+        commit(next, index);
+    }
+
+    void select(T item) {
+        ObservableList<T> rows = owner.rows();
+        if (item == null || rows == null) {
+            clear();
+            return;
+        }
+        int at = rows.indexOf(item);
+        if (at >= 0) {
+            select(at);
+        }
+    }
+
+    void selectIndices(int index, int[] more) {
+        ArrayList<Integer> next = new ArrayList<Integer>();
+        next.addAll(indices);
+        int n = count();
+        int last = index >= 0 && index < n ? index : -1;
+        next.add(Integer.valueOf(index));
+        if (more != null) {
+            for (int i = 0; i < more.length; i++) {
+                next.add(Integer.valueOf(more[i]));
+                if (more[i] >= 0 && more[i] < n) {
+                    last = more[i];
+                }
+            }
+        }
+        if (last < 0) {
+            return;
+        }
+        if (!owner.multiple()) {
+            clearAndSelect(last);
+            return;
+        }
+        commit(next, last);
+    }
+
+    void selectAll() {
+        if (!owner.multiple()) {
+            return;
+        }
+        ArrayList<Integer> all = new ArrayList<Integer>();
+        int n = count();
+        for (int i = 0; i < n; i++) {
+            all.add(Integer.valueOf(i));
+        }
+        commit(all, n - 1);
+    }
+
+    void clear(int index) {
+        if (!indices.contains(Integer.valueOf(index))) {
+            return;
+        }
+        ArrayList<Integer> next = new ArrayList<Integer>(indices);
+        next.remove(Integer.valueOf(index));
+        commit(next, lead == index ? -1 : lead);
+    }
+
+    void clear() {
+        commit(new ArrayList<Integer>(), -1);
+    }
+
+    boolean isSelected(int index) {
+        return indices.contains(Integer.valueOf(index));
+    }
+
+    boolean isEmpty() {
+        return indices.isEmpty();
+    }
+
+    int lead() {
+        return lead;
+    }
+
+    int rowCount() {
+        return count();
+    }
+
+    /// Keeps the selection on the same items while the items change.
+    void rowsChanged(ListChangeListener.Change<? extends T> change) {
+        ArrayList<Integer> next = new ArrayList<Integer>(indices);
+        int l = lead;
+        while (change.next()) {
+            if (change.wasPermutated()) {
+                for (int i = 0; i < next.size(); i++) {
+                    int v = next.get(i).intValue();
+                    if (v >= change.getFrom() && v < change.getTo()) {
+                        next.set(i, Integer.valueOf(change.getPermutation(v)));
+                    }
+                }
+                if (l >= change.getFrom() && l < change.getTo()) {
+                    l = change.getPermutation(l);
+                }
+                continue;
+            }
+            int from = change.getFrom();
+            int removed = change.getRemovedSize();
+            int added = change.getAddedSize();
+            // A row replaced in place, items.set(i, x), keeps its selection
+            // and now selects the new item, as in JavaFX. Replacing the
+            // whole list (setAll) leaves nothing selected, also as there.
+            int kept = 0;
+            if (change.wasReplaced() && !(from == 0 && added == change.getList().size())) {
+                kept = Math.min(removed, added);
+            }
+            ArrayList<Integer> shifted = new ArrayList<Integer>();
+            for (int i = 0; i < next.size(); i++) {
+                int v = next.get(i).intValue();
+                if (v < from + kept) {
+                    shifted.add(Integer.valueOf(v));
+                } else if (v >= from + removed) {
+                    shifted.add(Integer.valueOf(v - removed + added));
+                }
+            }
+            next = shifted;
+            if (l >= from + removed) {
+                l = l - removed + added;
+            } else if (l >= from + kept) {
+                l = -1;
+            }
+        }
+        // The items behind unchanged indices may be new objects.
+        items.clear();
+        commit(next, l);
+    }
+
+    /// The whole list of items was replaced: nothing stays selected.
+    void rowsReplaced() {
+        indices.clear();
+        items.clear();
+        lead = -1;
+        owner.lead(-1, null);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ScrollBar.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ScrollBar.java
new file mode 100644
index 00000000000..b93564f6272
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ScrollBar.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.ui.Component;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.css.PseudoClass;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Region;
+
+/// A bar with a thumb that is dragged along a track to choose a value
+/// between a minimum and a maximum.
+///
+/// The bar is two regions a style sheet reaches as `.track` and `.thumb`.
+/// The length of the thumb is the visible amount as a part of the range,
+/// and never less than the bar is thick. Dragging the thumb moves the
+/// value; a press on the track beside it moves the value by the block
+/// increment towards the press. There are no arrow buttons at the ends.
+///
+/// The preferred size is 14 by 100 logical pixels, the long side along
+/// the orientation.
+public class ScrollBar extends Control {
+
+    private static final int VALUE = Dirty.USER;
+    private static final int ORIENTATION = Dirty.USER << 1;
+    private static final double THICKNESS = 14;
+    private static final double LENGTH = 100;
+    private static final PseudoClass HORIZONTAL = PseudoClass.getPseudoClass("horizontal");
+    private static final PseudoClass VERTICAL = PseudoClass.getPseudoClass("vertical");
+
+    private final DoubleProperty min = new FxDouble(this, "min", 0, VALUE | Dirty.LAYOUT);
+    private final DoubleProperty max = new FxDouble(this, "max", 100, VALUE | Dirty.LAYOUT);
+    private final DoubleProperty value = new FxDouble(this, "value", 0, VALUE | Dirty.LAYOUT);
+    private final DoubleProperty visibleAmount = new FxDouble(this, "visibleAmount", 15, VALUE | Dirty.LAYOUT);
+    private final DoubleProperty unitIncrement = new FxDouble(this, "unitIncrement", 1, 0);
+    private final DoubleProperty blockIncrement = new FxDouble(this, "blockIncrement", 10, 0);
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, ORIENTATION | Dirty.LAYOUT);
+    private final Region track = new Part("track",
+            "-fx-background-color: derive(-fx-base, -9%), derive(-fx-base, 12%); -fx-background-insets: 0, 1;");
+    private final Region thumb = new Part("thumb",
+            "-fx-background-color: derive(-fx-base, -30%), derive(-fx-base, -8%);"
+                    + " -fx-background-insets: 2, 3; -fx-background-radius: 5, 4;");
+    private double grabbed;
+
+    private static final class Part extends Region {
+        private final String look;
+
+        Part(String styleClass, String look) {
+            this.look = look;
+            getStyleClass().add(styleClass);
+            setManaged(false);
+        }
+
+        @Override
+        public String cn1DefaultStyle() {
+            return look;
+        }
+    }
+
+    /// Creates a horizontal bar from 0 to 100.
+    public ScrollBar() {
+        getStyleClass().add("scroll-bar");
+        setFocusTraversable(false);
+        pseudoClassStateChanged(HORIZONTAL, true);
+        cn1Children().add(track);
+        cn1Children().add(thumb);
+        track.addEventHandler(MouseEvent.MOUSE_PRESSED, e -> {
+            if (!isDisabled()) {
+                adjustValue(positionOf(e.getX(), e.getY()));
+                e.consume();
+            }
+        });
+        thumb.addEventHandler(MouseEvent.MOUSE_PRESSED, e -> {
+            grabbed = upright() ? e.getY() : e.getX();
+            e.consume();
+        });
+        thumb.addEventHandler(MouseEvent.MOUSE_DRAGGED, e -> {
+            if (!isDisabled()) {
+                dragTo((upright() ? thumb.getLayoutY() + e.getY() : thumb.getLayoutX() + e.getX()) - grabbed);
+                e.consume();
+            }
+        });
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    private boolean upright() {
+        return getOrientation() == Orientation.VERTICAL;
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & ORIENTATION) != 0) {
+            pseudoClassStateChanged(VERTICAL, upright());
+            pseudoClassStateChanged(HORIZONTAL, !upright());
+        }
+        super.cn1Invalidated(what);
+    }
+
+    private double range() {
+        return Math.max(0, getMax() - getMin());
+    }
+
+    private static double clamp(double low, double v, double high) {
+        return v < low ? low : (v > high ? high : v);
+    }
+
+    /// Returns `{start of the track, its length, length of the thumb}`
+    /// along the bar, inside the insets.
+    private double[] along() {
+        Insets in = getInsets();
+        boolean upright = upright();
+        double start = upright ? in.getTop() : in.getLeft();
+        double length = Math.max(0, upright ? getHeight() - in.getTop() - in.getBottom()
+                : getWidth() - in.getLeft() - in.getRight());
+        double across = Math.max(0, upright ? getWidth() - in.getLeft() - in.getRight()
+                : getHeight() - in.getTop() - in.getBottom());
+        double range = range();
+        double part = range > 0 ? clamp(0, getVisibleAmount() / range, 1) : 1;
+        double thumbLength = Math.min(length, Math.max(across, length * part));
+        return new double[] {start, length, thumbLength};
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double w = Math.max(0, getWidth() - in.getLeft() - in.getRight());
+        double h = Math.max(0, getHeight() - in.getTop() - in.getBottom());
+        track.resizeRelocate(in.getLeft(), in.getTop(), w, h);
+        double[] a = along();
+        double range = range();
+        double at = range > 0 ? clamp(0, (getValue() - getMin()) / range, 1) : 0;
+        double offset = a[0] + (a[1] - a[2]) * at;
+        if (upright()) {
+            thumb.resizeRelocate(in.getLeft(), offset, w, a[2]);
+        } else {
+            thumb.resizeRelocate(offset, in.getTop(), a[2], h);
+        }
+    }
+
+    /// The place of a point of the track along the bar, from 0 to 1.
+    private double positionOf(double x, double y) {
+        double[] a = along();
+        return a[1] > 0 ? clamp(0, ((upright() ? y : x) - a[0]) / a[1], 1) : 0;
+    }
+
+    private void dragTo(double thumbStart) {
+        double[] a = along();
+        double room = a[1] - a[2];
+        if (room > 0) {
+            setValue(getMin() + range() * clamp(0, (thumbStart - a[0]) / room, 1));
+        }
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + (upright() ? THICKNESS : LENGTH) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + (upright() ? LENGTH : THICKNESS) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + THICKNESS + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + THICKNESS + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return upright() ? computePrefWidth(height) : Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return upright() ? Double.MAX_VALUE : computePrefHeight(width);
+    }
+
+    /// Moves the value by the block increment towards a place along the
+    /// bar, from 0 to 1, and not past it.
+    public void adjustValue(double position) {
+        double target = getMin() + range() * clamp(0, position, 1);
+        double now = getValue();
+        double block = getBlockIncrement();
+        if (target > now) {
+            setValue(clamp(getMin(), Math.min(target, now + block), getMax()));
+        } else if (target < now) {
+            setValue(clamp(getMin(), Math.max(target, now - block), getMax()));
+        }
+    }
+
+    /// Adds the unit increment to the value, up to the maximum.
+    public void increment() {
+        setValue(clamp(getMin(), getValue() + getUnitIncrement(), getMax()));
+    }
+
+    /// Takes the unit increment off the value, down to the minimum.
+    public void decrement() {
+        setValue(clamp(getMin(), getValue() - getUnitIncrement(), getMax()));
+    }
+
+    /// Returns the least value.
+    public final double getMin() {
+        return min.get();
+    }
+
+    /// Sets the least value.
+    public final void setMin(double v) {
+        min.set(v);
+    }
+
+    /// The least value.
+    public final DoubleProperty minProperty() {
+        return min;
+    }
+
+    /// Returns the greatest value.
+    public final double getMax() {
+        return max.get();
+    }
+
+    /// Sets the greatest value.
+    public final void setMax(double v) {
+        max.set(v);
+    }
+
+    /// The greatest value.
+    public final DoubleProperty maxProperty() {
+        return max;
+    }
+
+    /// Returns the value, which the thumb shows.
+    public final double getValue() {
+        return value.get();
+    }
+
+    /// Sets the value. It is not held between the minimum and the
+    /// maximum, as it is not in JavaFX; the thumb is.
+    public final void setValue(double v) {
+        value.set(v);
+    }
+
+    /// The value.
+    public final DoubleProperty valueProperty() {
+        return value;
+    }
+
+    /// Returns how much of the range is in view, which is the length of
+    /// the thumb.
+    public final double getVisibleAmount() {
+        return visibleAmount.get();
+    }
+
+    /// Sets how much of the range is in view.
+    public final void setVisibleAmount(double v) {
+        visibleAmount.set(v);
+    }
+
+    /// How much of the range is in view.
+    public final DoubleProperty visibleAmountProperty() {
+        return visibleAmount;
+    }
+
+    /// Returns what [#increment()] and [#decrement()] move the value by.
+    public final double getUnitIncrement() {
+        return unitIncrement.get();
+    }
+
+    /// Sets what [#increment()] and [#decrement()] move the value by.
+    public final void setUnitIncrement(double v) {
+        unitIncrement.set(v);
+    }
+
+    /// The small step.
+    public final DoubleProperty unitIncrementProperty() {
+        return unitIncrement;
+    }
+
+    /// Returns what a press on the track moves the value by.
+    public final double getBlockIncrement() {
+        return blockIncrement.get();
+    }
+
+    /// Sets what a press on the track moves the value by.
+    public final void setBlockIncrement(double v) {
+        blockIncrement.set(v);
+    }
+
+    /// The large step.
+    public final DoubleProperty blockIncrementProperty() {
+        return blockIncrement;
+    }
+
+    /// Returns whether the bar lies or stands.
+    public final Orientation getOrientation() {
+        return orientation.get();
+    }
+
+    /// Makes the bar lie or stand.
+    public final void setOrientation(Orientation v) {
+        orientation.set(v == null ? Orientation.HORIZONTAL : v);
+    }
+
+    /// Whether the bar lies or stands.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ScrollPane.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ScrollPane.java
new file mode 100644
index 00000000000..aa53f8bd62e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ScrollPane.java
@@ -0,0 +1,775 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.EventHandler;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.scene.Node;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// A view onto content larger than itself, moved by scrolling.
+///
+/// #### How it scrolls
+///
+/// There is no scrolling Codename One container behind this control. The
+/// content stays an ordinary node of the scene graph: it is the child of
+/// a viewport region that is the first child of the scroll pane, JavaFX
+/// layout sizes it, and scrolling sets its `layoutX` and `layoutY` to
+/// minus the scroll offset. The viewport's peer clips what it holds to
+/// its bounds, and the viewport does not pick content outside them. Events
+/// therefore reach the content through the usual dispatch chain, `lookup`
+/// finds it, and its bounds in the scene are true at every scroll
+/// position; a scrolling native container would have moved the peers
+/// behind the scene graph's back and left all three wrong.
+///
+/// `hvalue` and `vvalue` run from `hmin` to `hmax` and `vmin` to `vmax`
+/// (0 to 1 unless changed) and map linearly onto the distance the content
+/// can travel. The wheel scrolls, dragging a scroll bar thumb scrolls, and
+/// dragging the content pans when `pannable` is set, and always on a
+/// device that is not a desktop, where there is nothing else to scroll
+/// with.
+///
+/// #### Differences from JavaFX
+///
+/// The scroll bars are thin thumbs drawn over the edge of the viewport;
+/// they take no room, so the viewport is always the whole inside of the
+/// pane. A policy decides only whether a thumb shows. `viewportBounds`
+/// holds minus the scroll offset as its minimum and the viewport size.
+///
+/// #### Styling
+///
+/// Through `cn1ApplyStyle`, besides the region names: `-fx-fit-to-width`,
+/// `-fx-fit-to-height`, `-fx-pannable` (`Boolean`); `-fx-hbar-policy`,
+/// `-fx-vbar-policy` (`ScrollPane.ScrollBarPolicy`, or `"never"`,
+/// `"always"`, `"as-needed"`).
+public class ScrollPane extends Control {
+
+    /// When a scroll bar shows.
+    public enum ScrollBarPolicy {
+        /// Never.
+        NEVER,
+        /// Always.
+        ALWAYS,
+        /// Only while the content is larger than the viewport.
+        AS_NEEDED
+    }
+
+    private static final int SCROLL = Dirty.USER;
+    private static final int CONTENT = Dirty.USER << 1;
+    private static final double BAR = 6;
+    private static final double BAR_GAP = 2;
+    private static final double MIN_THUMB = 20;
+
+    private final ObjectProperty<Node> content = new FxObject<Node>(this, "content", null,
+            CONTENT | Dirty.LAYOUT);
+    private final ObjectProperty<ScrollBarPolicy> hbarPolicy = new FxObject<ScrollBarPolicy>(this, "hbarPolicy",
+            ScrollBarPolicy.AS_NEEDED, Dirty.LAYOUT);
+    private final ObjectProperty<ScrollBarPolicy> vbarPolicy = new FxObject<ScrollBarPolicy>(this, "vbarPolicy",
+            ScrollBarPolicy.AS_NEEDED, Dirty.LAYOUT);
+    private final BooleanProperty fitToWidth = new FxBoolean(this, "fitToWidth", false, Dirty.LAYOUT);
+    private final BooleanProperty fitToHeight = new FxBoolean(this, "fitToHeight", false, Dirty.LAYOUT);
+    private final BooleanProperty pannable = new FxBoolean(this, "pannable", false, Dirty.NONE);
+    private final DoubleProperty hvalue = new FxDouble(this, "hvalue", 0, SCROLL);
+    private final DoubleProperty vvalue = new FxDouble(this, "vvalue", 0, SCROLL);
+    private final DoubleProperty hmin = new FxDouble(this, "hmin", 0, SCROLL);
+    private final DoubleProperty vmin = new FxDouble(this, "vmin", 0, SCROLL);
+    private final DoubleProperty hmax = new FxDouble(this, "hmax", 1, SCROLL);
+    private final DoubleProperty vmax = new FxDouble(this, "vmax", 1, SCROLL);
+    private final DoubleProperty prefViewportWidth = new FxDouble(this, "prefViewportWidth", 0, Dirty.LAYOUT);
+    private final DoubleProperty prefViewportHeight = new FxDouble(this, "prefViewportHeight", 0, Dirty.LAYOUT);
+    private final DoubleProperty minViewportWidth = new FxDouble(this, "minViewportWidth", 0, Dirty.LAYOUT);
+    private final DoubleProperty minViewportHeight = new FxDouble(this, "minViewportHeight", 0, Dirty.LAYOUT);
+    private final ObjectProperty<Bounds> viewportBounds = new SimpleObjectProperty<Bounds>(this, "viewportBounds",
+            new BoundingBox(0, 0, 0, 0));
+
+    private final Viewport viewport = new Viewport();
+    private final Region hbar = thumb();
+    private final Region vbar = thumb();
+    private double contentWidth;
+    private double contentHeight;
+    private double pressX;
+    private double pressY;
+    private double pressH;
+    private double pressV;
+    private boolean panning;
+
+    /// Creates a scroll pane without content.
+    public ScrollPane() {
+        init();
+    }
+
+    /// Creates a scroll pane showing a node.
+    public ScrollPane(Node content) {
+        init();
+        setContent(content);
+    }
+
+    private static Region thumb() {
+        Region r = new Region();
+        r.setManaged(false);
+        r.setVisible(false);
+        r.setBackground(new Background(new BackgroundFill(Color.gray(0.35, 0.6), new CornerRadii(BAR / 2),
+                Insets.EMPTY)));
+        return r;
+    }
+
+    private void init() {
+        getStyleClass().add("scroll-pane");
+        setFocusTraversable(false);
+        cn1Children().addAll(viewport, vbar, hbar);
+        addEventHandler(ScrollEvent.SCROLL, new EventHandler<ScrollEvent>() {
+            @Override
+            public void handle(ScrollEvent event) {
+                if (scrollBy(-event.getDeltaX(), -event.getDeltaY())) {
+                    event.consume();
+                }
+            }
+        });
+        addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                rememberPress(event);
+                panning = isPannable() || (Display.isInitialized() && !Display.getInstance().isDesktop());
+            }
+        });
+        addEventHandler(MouseEvent.MOUSE_DRAGGED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                if (panning && panTo(pressX - event.getSceneX(), pressY - event.getSceneY())) {
+                    event.consume();
+                }
+            }
+        });
+        addEventHandler(MouseEvent.MOUSE_RELEASED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                panning = false;
+            }
+        });
+        dragThumb(hbar, true);
+        dragThumb(vbar, false);
+    }
+
+    private void rememberPress(MouseEvent event) {
+        pressX = event.getSceneX();
+        pressY = event.getSceneY();
+        pressH = getHvalue();
+        pressV = getVvalue();
+    }
+
+    private void dragThumb(final Region bar, final boolean horizontal) {
+        bar.addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                rememberPress(event);
+                panning = false;
+                event.consume();
+            }
+        });
+        bar.addEventHandler(MouseEvent.MOUSE_DRAGGED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                if (horizontal) {
+                    double track = viewport.getWidth() - 2 * BAR_GAP - bar.getWidth();
+                    if (track > 0) {
+                        setHvalue(bounded(pressH + (event.getSceneX() - pressX) / track * (getHmax() - getHmin()),
+                                getHmin(), getHmax()));
+                    }
+                } else {
+                    double track = viewport.getHeight() - 2 * BAR_GAP - bar.getHeight();
+                    if (track > 0) {
+                        setVvalue(bounded(pressV + (event.getSceneY() - pressY) / track * (getVmax() - getVmin()),
+                                getVmin(), getVmax()));
+                    }
+                }
+                event.consume();
+            }
+        });
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & CONTENT) != 0) {
+            viewport.show(getContent());
+        }
+        if ((what & SCROLL) != 0) {
+            placeContent();
+        }
+        super.cn1Invalidated(what);
+    }
+
+    // ------------------------------------------------------------ scrolling
+
+    private static double bounded(double value, double min, double max) {
+        return value < min ? min : (value > max ? max : value);
+    }
+
+    private static double offset(double value, double min, double max, double extent) {
+        double range = max - min;
+        if (!(extent > 0) || !(range > 0)) {
+            return 0;
+        }
+        return bounded((value - min) / range, 0, 1) * extent;
+    }
+
+    private static double valueAt(double offset, double min, double max, double extent) {
+        if (!(extent > 0)) {
+            return min;
+        }
+        return min + bounded(offset / extent, 0, 1) * (max - min);
+    }
+
+    /// Scrolls by a distance in logical pixels; answers whether anything
+    /// moved.
+    private boolean scrollBy(double dx, double dy) {
+        double extentX = contentWidth - viewport.getWidth();
+        double extentY = contentHeight - viewport.getHeight();
+        double oldH = getHvalue();
+        double oldV = getVvalue();
+        if (extentX > 0 && dx != 0 && !hvalue.isBound()) {
+            setHvalue(valueAt(offset(oldH, getHmin(), getHmax(), extentX) + dx, getHmin(), getHmax(), extentX));
+        }
+        if (extentY > 0 && dy != 0 && !vvalue.isBound()) {
+            setVvalue(valueAt(offset(oldV, getVmin(), getVmax(), extentY) + dy, getVmin(), getVmax(), extentY));
+        }
+        return Double.compare(oldH, getHvalue()) != 0 || Double.compare(oldV, getVvalue()) != 0;
+    }
+
+    /// Scrolls to where the content was at the press, moved by a
+    /// distance; answers whether the content can move at all.
+    private boolean panTo(double dx, double dy) {
+        double extentX = contentWidth - viewport.getWidth();
+        double extentY = contentHeight - viewport.getHeight();
+        if (extentX > 0 && !hvalue.isBound()) {
+            setHvalue(valueAt(offset(pressH, getHmin(), getHmax(), extentX) + dx, getHmin(), getHmax(), extentX));
+        }
+        if (extentY > 0 && !vvalue.isBound()) {
+            setVvalue(valueAt(offset(pressV, getVmin(), getVmax(), extentY) + dy, getVmin(), getVmax(), extentY));
+        }
+        return extentX > 0 || extentY > 0;
+    }
+
+    private void placeContent() {
+        double vw = viewport.getWidth();
+        double vh = viewport.getHeight();
+        double extentX = contentWidth - vw;
+        double extentY = contentHeight - vh;
+        double ox = snapPositionX(offset(getHvalue(), getHmin(), getHmax(), extentX));
+        double oy = snapPositionY(offset(getVvalue(), getVmin(), getVmax(), extentY));
+        Node c = getContent();
+        if (c != null && c.getParent() == viewport) {
+            Bounds lb = c.getLayoutBounds();
+            c.setLayoutX(-ox - lb.getMinX());
+            c.setLayoutY(-oy - lb.getMinY());
+        }
+        Bounds old = viewportBounds.get();
+        if (old == null || old.getMinX() != -ox || old.getMinY() != -oy || old.getWidth() != vw
+                || old.getHeight() != vh) {
+            viewportBounds.set(new BoundingBox(-ox, -oy, vw, vh));
+        }
+        placeThumb(hbar, true, getHbarPolicy(), extentX, vw, vh, contentWidth, ox);
+        placeThumb(vbar, false, getVbarPolicy(), extentY, vh, vw, contentHeight, oy);
+    }
+
+    private void placeThumb(Region bar, boolean horizontal, ScrollBarPolicy policy, double extent, double along,
+            double across, double contentLength, double scrolled) {
+        boolean shown = policy == ScrollBarPolicy.ALWAYS || (policy != ScrollBarPolicy.NEVER && extent > 0.5);
+        double track = along - 2 * BAR_GAP;
+        if (!shown || !(track > 0)) {
+            bar.setVisible(false);
+            return;
+        }
+        double length = track;
+        double at = 0;
+        if (extent > 0 && contentLength > 0) {
+            length = Math.min(track, Math.max(MIN_THUMB, track * along / contentLength));
+            at = (track - length) * scrolled / extent;
+        }
+        double x = viewport.getLayoutX();
+        double y = viewport.getLayoutY();
+        if (horizontal) {
+            bar.resizeRelocate(x + BAR_GAP + at, y + across - BAR - BAR_GAP, length, BAR);
+        } else {
+            bar.resizeRelocate(x + across - BAR - BAR_GAP, y + BAR_GAP + at, BAR, length);
+        }
+        bar.setVisible(true);
+    }
+
+    // --------------------------------------------------------------- layout
+
+    private static double size(double available, double min, double pref, double max, boolean fit) {
+        double wanted = fit ? available : pref;
+        return Math.max(min, Math.min(wanted, max));
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double w = Math.max(0, getWidth() - in.getLeft() - in.getRight());
+        double h = Math.max(0, getHeight() - in.getTop() - in.getBottom());
+        viewport.resizeRelocate(in.getLeft(), in.getTop(), w, h);
+        Node c = getContent();
+        contentWidth = 0;
+        contentHeight = 0;
+        if (c != null && c.getParent() == viewport) {
+            if (c.isResizable()) {
+                double cw;
+                double ch;
+                if (c.getContentBias() == Orientation.VERTICAL) {
+                    ch = size(h, c.minHeight(-1), c.prefHeight(-1), c.maxHeight(-1), isFitToHeight());
+                    cw = size(w, c.minWidth(ch), c.prefWidth(ch), c.maxWidth(ch), isFitToWidth());
+                } else {
+                    cw = size(w, c.minWidth(-1), c.prefWidth(-1), c.maxWidth(-1), isFitToWidth());
+                    double bias = c.getContentBias() == Orientation.HORIZONTAL ? cw : -1;
+                    ch = size(h, c.minHeight(bias), c.prefHeight(bias), c.maxHeight(bias), isFitToHeight());
+                }
+                c.resize(snapSizeX(cw), snapSizeY(ch));
+            }
+            Bounds lb = c.getLayoutBounds();
+            contentWidth = lb.getWidth();
+            contentHeight = lb.getHeight();
+        }
+        placeContent();
+    }
+
+    private double contentPref(boolean width) {
+        Node c = getContent();
+        if (c == null) {
+            return 0;
+        }
+        if (!c.isResizable()) {
+            Bounds lb = c.getLayoutBounds();
+            return width ? lb.getWidth() : lb.getHeight();
+        }
+        return width ? c.prefWidth(-1) : c.prefHeight(-1);
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        double inner = getPrefViewportWidth() > 0 ? getPrefViewportWidth() : contentPref(true);
+        return in.getLeft() + Math.max(inner, getMinViewportWidth()) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        double inner = getPrefViewportHeight() > 0 ? getPrefViewportHeight() : contentPref(false);
+        return in.getTop() + Math.max(inner, getMinViewportHeight()) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + Math.max(0, getMinViewportWidth()) + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + Math.max(0, getMinViewportHeight()) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    /// The region that holds the content and clips it.
+    private static final class Viewport extends Region {
+
+        void show(Node node) {
+            if (node == null) {
+                cn1Children().clear();
+            } else if (cn1Children().size() != 1 || cn1Children().get(0) != node) {
+                cn1Children().setAll(node);
+            }
+        }
+
+        @Override
+        protected void layoutChildren() {
+            // The scroll pane sizes and places the content.
+        }
+
+        @Override
+        protected Node cn1PickLocal(double x, double y) {
+            return contains(x, y) ? super.cn1PickLocal(x, y) : null;
+        }
+    }
+
+    // ----------------------------------------------------------- properties
+
+    /// Returns the node being scrolled, or `null`.
+    public final Node getContent() {
+        return content.get();
+    }
+
+    /// Sets the node being scrolled.
+    public final void setContent(Node value) {
+        content.set(value);
+    }
+
+    /// The node being scrolled.
+    public final ObjectProperty<Node> contentProperty() {
+        return content;
+    }
+
+    /// Returns when the horizontal scroll bar shows.
+    public final ScrollBarPolicy getHbarPolicy() {
+        ScrollBarPolicy p = hbarPolicy.get();
+        return p == null ? ScrollBarPolicy.AS_NEEDED : p;
+    }
+
+    /// Sets when the horizontal scroll bar shows.
+    public final void setHbarPolicy(ScrollBarPolicy value) {
+        hbarPolicy.set(value);
+    }
+
+    /// When the horizontal scroll bar shows.
+    public final ObjectProperty<ScrollBarPolicy> hbarPolicyProperty() {
+        return hbarPolicy;
+    }
+
+    /// Returns when the vertical scroll bar shows.
+    public final ScrollBarPolicy getVbarPolicy() {
+        ScrollBarPolicy p = vbarPolicy.get();
+        return p == null ? ScrollBarPolicy.AS_NEEDED : p;
+    }
+
+    /// Sets when the vertical scroll bar shows.
+    public final void setVbarPolicy(ScrollBarPolicy value) {
+        vbarPolicy.set(value);
+    }
+
+    /// When the vertical scroll bar shows.
+    public final ObjectProperty<ScrollBarPolicy> vbarPolicyProperty() {
+        return vbarPolicy;
+    }
+
+    /// Returns whether resizable content is made as wide as the viewport.
+    public final boolean isFitToWidth() {
+        return fitToWidth.get();
+    }
+
+    /// Sets whether resizable content is made as wide as the viewport.
+    public final void setFitToWidth(boolean value) {
+        fitToWidth.set(value);
+    }
+
+    /// Whether resizable content is made as wide as the viewport.
+    public final BooleanProperty fitToWidthProperty() {
+        return fitToWidth;
+    }
+
+    /// Returns whether resizable content is made as tall as the viewport.
+    public final boolean isFitToHeight() {
+        return fitToHeight.get();
+    }
+
+    /// Sets whether resizable content is made as tall as the viewport.
+    public final void setFitToHeight(boolean value) {
+        fitToHeight.set(value);
+    }
+
+    /// Whether resizable content is made as tall as the viewport.
+    public final BooleanProperty fitToHeightProperty() {
+        return fitToHeight;
+    }
+
+    /// Returns whether dragging the content with the pointer scrolls.
+    public final boolean isPannable() {
+        return pannable.get();
+    }
+
+    /// Sets whether dragging the content with the pointer scrolls.
+    public final void setPannable(boolean value) {
+        pannable.set(value);
+    }
+
+    /// Whether dragging the content with the pointer scrolls.
+    public final BooleanProperty pannableProperty() {
+        return pannable;
+    }
+
+    /// Returns the horizontal scroll position.
+    public final double getHvalue() {
+        return hvalue.get();
+    }
+
+    /// Sets the horizontal scroll position.
+    public final void setHvalue(double value) {
+        hvalue.set(value);
+    }
+
+    /// The horizontal scroll position, from `hmin` to `hmax`.
+    public final DoubleProperty hvalueProperty() {
+        return hvalue;
+    }
+
+    /// Returns the vertical scroll position.
+    public final double getVvalue() {
+        return vvalue.get();
+    }
+
+    /// Sets the vertical scroll position.
+    public final void setVvalue(double value) {
+        vvalue.set(value);
+    }
+
+    /// The vertical scroll position, from `vmin` to `vmax`.
+    public final DoubleProperty vvalueProperty() {
+        return vvalue;
+    }
+
+    /// Returns the `hvalue` of the content's left edge.
+    public final double getHmin() {
+        return hmin.get();
+    }
+
+    /// Sets the `hvalue` of the content's left edge.
+    public final void setHmin(double value) {
+        hmin.set(value);
+    }
+
+    /// The `hvalue` of the content's left edge.
+    public final DoubleProperty hminProperty() {
+        return hmin;
+    }
+
+    /// Returns the `vvalue` of the content's top edge.
+    public final double getVmin() {
+        return vmin.get();
+    }
+
+    /// Sets the `vvalue` of the content's top edge.
+    public final void setVmin(double value) {
+        vmin.set(value);
+    }
+
+    /// The `vvalue` of the content's top edge.
+    public final DoubleProperty vminProperty() {
+        return vmin;
+    }
+
+    /// Returns the `hvalue` of the content's right edge.
+    public final double getHmax() {
+        return hmax.get();
+    }
+
+    /// Sets the `hvalue` of the content's right edge.
+    public final void setHmax(double value) {
+        hmax.set(value);
+    }
+
+    /// The `hvalue` of the content's right edge.
+    public final DoubleProperty hmaxProperty() {
+        return hmax;
+    }
+
+    /// Returns the `vvalue` of the content's bottom edge.
+    public final double getVmax() {
+        return vmax.get();
+    }
+
+    /// Sets the `vvalue` of the content's bottom edge.
+    public final void setVmax(double value) {
+        vmax.set(value);
+    }
+
+    /// The `vvalue` of the content's bottom edge.
+    public final DoubleProperty vmaxProperty() {
+        return vmax;
+    }
+
+    /// Returns the preferred width of the viewport; 0 for the content's.
+    public final double getPrefViewportWidth() {
+        return prefViewportWidth.get();
+    }
+
+    /// Sets the preferred width of the viewport.
+    public final void setPrefViewportWidth(double value) {
+        prefViewportWidth.set(value);
+    }
+
+    /// The preferred width of the viewport.
+    public final DoubleProperty prefViewportWidthProperty() {
+        return prefViewportWidth;
+    }
+
+    /// Returns the preferred height of the viewport; 0 for the content's.
+    public final double getPrefViewportHeight() {
+        return prefViewportHeight.get();
+    }
+
+    /// Sets the preferred height of the viewport.
+    public final void setPrefViewportHeight(double value) {
+        prefViewportHeight.set(value);
+    }
+
+    /// The preferred height of the viewport.
+    public final DoubleProperty prefViewportHeightProperty() {
+        return prefViewportHeight;
+    }
+
+    /// Returns the minimum width of the viewport.
+    public final double getMinViewportWidth() {
+        return minViewportWidth.get();
+    }
+
+    /// Sets the minimum width of the viewport.
+    public final void setMinViewportWidth(double value) {
+        minViewportWidth.set(value);
+    }
+
+    /// The minimum width of the viewport.
+    public final DoubleProperty minViewportWidthProperty() {
+        return minViewportWidth;
+    }
+
+    /// Returns the minimum height of the viewport.
+    public final double getMinViewportHeight() {
+        return minViewportHeight.get();
+    }
+
+    /// Sets the minimum height of the viewport.
+    public final void setMinViewportHeight(double value) {
+        minViewportHeight.set(value);
+    }
+
+    /// The minimum height of the viewport.
+    public final DoubleProperty minViewportHeightProperty() {
+        return minViewportHeight;
+    }
+
+    /// Returns the bounds of the viewport: its minimum is minus the
+    /// scroll offset, its size the visible area.
+    public final Bounds getViewportBounds() {
+        return viewportBounds.get();
+    }
+
+    /// Sets the bounds of the viewport. Layout overwrites the value.
+    public final void setViewportBounds(Bounds value) {
+        viewportBounds.set(value);
+    }
+
+    /// The bounds of the viewport.
+    public final ObjectProperty<Bounds> viewportBoundsProperty() {
+        return viewportBounds;
+    }
+
+    // -------------------------------------------------------------- styling
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-fit-to-width".equals(property)) {
+            return Boolean.valueOf(isFitToWidth());
+        } else if ("-fx-fit-to-height".equals(property)) {
+            return Boolean.valueOf(isFitToHeight());
+        } else if ("-fx-pannable".equals(property)) {
+            return Boolean.valueOf(isPannable());
+        } else if ("-fx-hbar-policy".equals(property)) {
+            return getHbarPolicy();
+        } else if ("-fx-vbar-policy".equals(property)) {
+            return getVbarPolicy();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    private static ScrollBarPolicy policy(Object value) {
+        if (value instanceof ScrollBarPolicy) {
+            return (ScrollBarPolicy) value;
+        } else if (value instanceof String) {
+            String wanted = ((String) value).trim().replace('-', '_');
+            ScrollBarPolicy[] all = ScrollBarPolicy.values();
+            for (int i = 0; i < all.length; i++) {
+                if (all[i].name().equalsIgnoreCase(wanted)) {
+                    return all[i];
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-hbar-policy".equals(property) || "-fx-vbar-policy".equals(property)) {
+            ScrollBarPolicy p = policy(value);
+            if (p == null) {
+                return false;
+            }
+            if ("-fx-hbar-policy".equals(property)) {
+                setHbarPolicy(p);
+            } else {
+                setVbarPolicy(p);
+            }
+            return true;
+        }
+        boolean fitWidth = "-fx-fit-to-width".equals(property);
+        boolean fitHeight = "-fx-fit-to-height".equals(property);
+        if (fitWidth || fitHeight || "-fx-pannable".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            boolean on = ((Boolean) value).booleanValue();
+            if (fitWidth) {
+                setFitToWidth(on);
+            } else if (fitHeight) {
+                setFitToHeight(on);
+            } else {
+                setPannable(on);
+            }
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/SelectionMode.java b/maven/javafx-compat/src/main/java/javafx/scene/control/SelectionMode.java
new file mode 100644
index 00000000000..eeef1dd1e16
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/SelectionMode.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// How many rows a [MultipleSelectionModel] lets be selected at once.
+public enum SelectionMode {
+    /// One row at most.
+    SINGLE,
+    /// Any number of rows.
+    MULTIPLE
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/SelectionModel.java b/maven/javafx-compat/src/main/java/javafx/scene/control/SelectionModel.java
new file mode 100644
index 00000000000..1d6b2a8cef8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/SelectionModel.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.property.ReadOnlyIntegerWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+
+/// The selection of a control that shows a list of items: which index is
+/// selected and which item that is. A subclass decides how many items can
+/// be selected at once and where the items come from.
+public abstract class SelectionModel<T> {
+
+    private final ReadOnlyIntegerWrapper selectedIndex = new ReadOnlyIntegerWrapper(this, "selectedIndex", -1);
+    private final ReadOnlyObjectWrapper<T> selectedItem = new ReadOnlyObjectWrapper<T>(this, "selectedItem");
+
+    /// Creates a selection model with nothing selected.
+    public SelectionModel() {
+    }
+
+    /// The selected index, or -1; in a multiple selection the one selected
+    /// last.
+    public final ReadOnlyIntegerProperty selectedIndexProperty() {
+        return selectedIndex.getReadOnlyProperty();
+    }
+
+    /// Sets the selected index; for subclasses.
+    protected final void setSelectedIndex(int value) {
+        selectedIndex.set(value);
+    }
+
+    /// Returns the selected index, or -1.
+    public final int getSelectedIndex() {
+        return selectedIndex.get();
+    }
+
+    /// The selected item, or `null`.
+    public final ReadOnlyObjectProperty<T> selectedItemProperty() {
+        return selectedItem.getReadOnlyProperty();
+    }
+
+    /// Sets the selected item; for subclasses.
+    protected final void setSelectedItem(T value) {
+        selectedItem.set(value);
+    }
+
+    /// Returns the selected item, or `null`.
+    public final T getSelectedItem() {
+        return selectedItem.get();
+    }
+
+    /// Clears the selection and selects one index.
+    public abstract void clearAndSelect(int index);
+
+    /// Selects an index; an index outside the items is ignored.
+    public abstract void select(int index);
+
+    /// Selects the first index holding an item.
+    public abstract void select(T obj);
+
+    /// Removes one index from the selection.
+    public abstract void clearSelection(int index);
+
+    /// Removes everything from the selection.
+    public abstract void clearSelection();
+
+    /// Returns whether an index is selected.
+    public abstract boolean isSelected(int index);
+
+    /// Returns whether nothing is selected.
+    public abstract boolean isEmpty();
+
+    /// Selects the index before the selected one.
+    public abstract void selectPrevious();
+
+    /// Selects the index after the selected one.
+    public abstract void selectNext();
+
+    /// Selects the first index.
+    public abstract void selectFirst();
+
+    /// Selects the last index.
+    public abstract void selectLast();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Separator.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Separator.java
new file mode 100644
index 00000000000..2cd9c339c86
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Separator.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.css.PseudoClass;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.VPos;
+import javafx.scene.paint.Color;
+
+/// A line that divides content, horizontal or vertical.
+///
+/// There is no native component: the control draws one device pixel wide
+/// line in a neutral grey across its length. Given more room than the
+/// line is thick, a horizontal separator places the line by `valignment`
+/// and a vertical one by `halignment`. The pseudo-classes `horizontal`
+/// and `vertical` follow the orientation.
+public class Separator extends Control {
+
+    private static final int ORIENTATION = Dirty.USER;
+    private static final PseudoClass HORIZONTAL = PseudoClass.getPseudoClass("horizontal");
+    private static final PseudoClass VERTICAL = PseudoClass.getPseudoClass("vertical");
+    private static final Color LINE = Color.gray(0.7);
+
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, ORIENTATION | Dirty.LAYOUT | Dirty.PAINT);
+    private final ObjectProperty<HPos> halignment = new FxObject<HPos>(this, "halignment", HPos.CENTER,
+            Dirty.PAINT);
+    private final ObjectProperty<VPos> valignment = new FxObject<VPos>(this, "valignment", VPos.CENTER,
+            Dirty.PAINT);
+
+    /// Creates a horizontal separator.
+    public Separator() {
+        this(Orientation.HORIZONTAL);
+    }
+
+    /// Creates a separator of an orientation.
+    public Separator(Orientation orientation) {
+        getStyleClass().add("separator");
+        setFocusTraversable(false);
+        pseudoClassStateChanged(HORIZONTAL, true);
+        setOrientation(orientation);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & ORIENTATION) != 0) {
+            boolean vertical = getOrientation() == Orientation.VERTICAL;
+            pseudoClassStateChanged(VERTICAL, vertical);
+            pseudoClassStateChanged(HORIZONTAL, !vertical);
+        }
+        super.cn1Invalidated(what);
+    }
+
+    private static double thickness() {
+        return Units.toLogical(1);
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        super.cn1Paint(renderer);
+        Insets in = getInsets();
+        double t = thickness();
+        double w = getWidth() - in.getLeft() - in.getRight();
+        double h = getHeight() - in.getTop() - in.getBottom();
+        if (getOrientation() == Orientation.VERTICAL) {
+            HPos pos = getHalignment();
+            double x = in.getLeft();
+            if (pos == HPos.RIGHT) {
+                x += w - t;
+            } else if (pos != HPos.LEFT) {
+                x += (w - t) / 2;
+            }
+            renderer.fillRect(Units.snap(x), in.getTop(), t, h, LINE);
+        } else {
+            VPos pos = getValignment();
+            double y = in.getTop();
+            if (pos == VPos.BOTTOM) {
+                y += h - t;
+            } else if (pos != VPos.TOP) {
+                y += (h - t) / 2;
+            }
+            renderer.fillRect(in.getLeft(), Units.snap(y), w, t, LINE);
+        }
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + thickness() + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + thickness() + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return getOrientation() == Orientation.VERTICAL ? computePrefWidth(height) : Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return getOrientation() == Orientation.VERTICAL ? Double.MAX_VALUE : computePrefHeight(width);
+    }
+
+    /// Returns the direction of the line.
+    public final Orientation getOrientation() {
+        Orientation o = orientation.get();
+        return o == null ? Orientation.HORIZONTAL : o;
+    }
+
+    /// Sets the direction of the line.
+    public final void setOrientation(Orientation value) {
+        orientation.set(value);
+    }
+
+    /// The direction of the line.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+
+    /// Returns where a vertical line sits in a wider separator.
+    public final HPos getHalignment() {
+        HPos p = halignment.get();
+        return p == null ? HPos.CENTER : p;
+    }
+
+    /// Sets where a vertical line sits in a wider separator.
+    public final void setHalignment(HPos value) {
+        halignment.set(value);
+    }
+
+    /// Where a vertical line sits in a wider separator.
+    public final ObjectProperty<HPos> halignmentProperty() {
+        return halignment;
+    }
+
+    /// Returns where a horizontal line sits in a taller separator.
+    public final VPos getValignment() {
+        VPos p = valignment.get();
+        return p == null ? VPos.CENTER : p;
+    }
+
+    /// Sets where a horizontal line sits in a taller separator.
+    public final void setValignment(VPos value) {
+        valignment.set(value);
+    }
+
+    /// Where a horizontal line sits in a taller separator.
+    public final ObjectProperty<VPos> valignmentProperty() {
+        return valignment;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/SeparatorMenuItem.java b/maven/javafx-compat/src/main/java/javafx/scene/control/SeparatorMenuItem.java
new file mode 100644
index 00000000000..0fd5f6646da
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/SeparatorMenuItem.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// A line between two groups of items of a menu. It cannot be chosen.
+///
+/// In JavaFX this is a `CustomMenuItem` holding a separator; that class
+/// is not part of this layer, so here it is a plain [MenuItem] the menu
+/// draws as a line.
+public class SeparatorMenuItem extends MenuItem {
+
+    /// Creates a separator.
+    public SeparatorMenuItem() {
+        styleClasses().add("separator-menu-item");
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/SingleSelectionModel.java b/maven/javafx-compat/src/main/java/javafx/scene/control/SingleSelectionModel.java
new file mode 100644
index 00000000000..f2f7c1d197a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/SingleSelectionModel.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// A selection of at most one index. A subclass supplies the items
+/// through [#getModelItem(int)] and [#getItemCount()].
+public abstract class SingleSelectionModel<T> extends SelectionModel<T> {
+
+    /// Creates a selection model with nothing selected.
+    public SingleSelectionModel() {
+    }
+
+    /// Clears the selection.
+    @Override
+    public void clearSelection() {
+        updateSelectedIndex(-1);
+    }
+
+    /// Clears the selection if the index is the selected one.
+    @Override
+    public void clearSelection(int index) {
+        if (getSelectedIndex() == index) {
+            clearSelection();
+        }
+    }
+
+    /// Returns whether nothing is selected.
+    @Override
+    public boolean isEmpty() {
+        return getItemCount() == 0 || getSelectedIndex() == -1;
+    }
+
+    /// Returns whether the index is the selected one.
+    @Override
+    public boolean isSelected(int index) {
+        return getSelectedIndex() == index;
+    }
+
+    /// Selects the index; the same as [#select(int)] here.
+    @Override
+    public void clearAndSelect(int index) {
+        select(index);
+    }
+
+    /// Selects the first index holding the item. An item that is not
+    /// among the items becomes the selected item all the same, on no
+    /// index (-1); `null` clears the selection.
+    @Override
+    public void select(T obj) {
+        if (obj == null) {
+            setSelectedIndex(-1);
+            setSelectedItem(null);
+            return;
+        }
+        int count = getItemCount();
+        for (int i = 0; i < count; i++) {
+            T value = getModelItem(i);
+            if (value != null && value.equals(obj)) {
+                select(i);
+                return;
+            }
+        }
+        setSelectedIndex(-1);
+        setSelectedItem(obj);
+    }
+
+    /// Selects the index; -1 clears the selection and any other index
+    /// outside the items is ignored.
+    @Override
+    public void select(int index) {
+        if (index == -1) {
+            clearSelection();
+            return;
+        }
+        int count = getItemCount();
+        if (count == 0 || index < 0 || index >= count) {
+            return;
+        }
+        updateSelectedIndex(index);
+    }
+
+    /// Selects the index before the selected one, if there is one.
+    @Override
+    public void selectPrevious() {
+        if (getSelectedIndex() == 0) {
+            return;
+        }
+        select(getSelectedIndex() - 1);
+    }
+
+    /// Selects the index after the selected one, if there is one.
+    @Override
+    public void selectNext() {
+        select(getSelectedIndex() + 1);
+    }
+
+    /// Selects the first index, if there are items.
+    @Override
+    public void selectFirst() {
+        if (getItemCount() > 0) {
+            select(0);
+        }
+    }
+
+    /// Selects the last index, if there are items.
+    @Override
+    public void selectLast() {
+        int count = getItemCount();
+        if (count > 0 && getSelectedIndex() < count - 1) {
+            select(count - 1);
+        }
+    }
+
+    /// Returns the item at an index, or `null` for an index outside the
+    /// items.
+    protected abstract T getModelItem(int index);
+
+    /// Returns the number of items.
+    protected abstract int getItemCount();
+
+    private void updateSelectedIndex(int newIndex) {
+        setSelectedIndex(newIndex);
+        setSelectedItem(getModelItem(newIndex));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Slider.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Slider.java
new file mode 100644
index 00000000000..5669a383732
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Slider.java
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.events.DataChangedListener;
+import com.codename1.ui.plaf.Style;
+import com.codename1.ui.plaf.UIManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.css.PseudoClass;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+import javafx.util.StringConverter;
+
+/// A value picked from a range by moving a thumb, shown as an editable
+/// Codename One `Slider`.
+///
+/// The value is kept inside `min` and `max`: setting it beyond either
+/// end stores the end, and moving an end past the value moves the value.
+/// The native slider counts in whole steps, so the range is mapped onto
+/// 10000 of them; a value the user drags to is one of those.
+///
+/// The native slider draws no ticks. Tick marks and tick labels are drawn
+/// by this control in a band of its own, below a horizontal slider and to
+/// the right of a vertical one, with the label formatter's text when
+/// there is one. `valueChanging` is true while the user
+/// drags the slider and false again when the pointer is let go of.
+/// `snapToTicks`,
+/// `majorTickUnit` and `minorTickCount` do take part in
+/// [#adjustValue(double)], [#increment()] and [#decrement()]. The
+/// pseudo-classes `horizontal` and `vertical` follow the orientation.
+public class Slider extends Control {
+
+    private static final int MIN = Dirty.USER;
+    private static final int MAX = Dirty.USER << 1;
+    private static final int VALUE = Dirty.USER << 2;
+    private static final int ORIENTATION = Dirty.USER << 3;
+    private static final int STEPS = 10000;
+    private static final PseudoClass HORIZONTAL = PseudoClass.getPseudoClass("horizontal");
+    private static final PseudoClass VERTICAL = PseudoClass.getPseudoClass("vertical");
+
+    private final DoubleProperty min = new FxDouble(this, "min", 0, MIN | Dirty.NATIVE);
+    private final DoubleProperty max = new FxDouble(this, "max", 100, MAX | Dirty.NATIVE);
+    private final DoubleProperty value = new FxDouble(this, "value", 0, VALUE | Dirty.NATIVE);
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, ORIENTATION | Dirty.NATIVE | Dirty.LAYOUT);
+    private final BooleanProperty valueChanging = new SimpleBooleanProperty(this, "valueChanging", false);
+    private static final int TICKS = Dirty.PAINT | Dirty.LAYOUT;
+    private static final double MAJOR_TICK = 6;
+    private static final double MINOR_TICK = 3;
+    private static final double TICK_GAP = 2;
+    private static final int MAX_TICKS = 1000;
+
+    private final BooleanProperty showTickLabels = new FxBoolean(this, "showTickLabels", false, TICKS);
+    private final BooleanProperty showTickMarks = new FxBoolean(this, "showTickMarks", false, TICKS);
+    private final DoubleProperty majorTickUnit = new FxDouble(this, "majorTickUnit", 25, TICKS);
+    private final IntegerProperty minorTickCount = new SimpleIntegerProperty(this, "minorTickCount", 3);
+    private final BooleanProperty snapToTicks = new SimpleBooleanProperty(this, "snapToTicks", false);
+    private final DoubleProperty blockIncrement = new SimpleDoubleProperty(this, "blockIncrement", 10);
+    private final ObjectProperty<StringConverter<Double>> labelFormatter =
+            new FxObject<StringConverter<Double>>(this, "labelFormatter", null, TICKS);
+    private boolean clamping;
+    private boolean syncing;
+
+    /// Creates a slider from 0 to 100 at 0.
+    public Slider() {
+        init();
+    }
+
+    /// Creates a slider with a range and a value.
+    public Slider(double min, double max, double value) {
+        init();
+        setMax(max);
+        setMin(min);
+        setValue(value);
+    }
+
+    private void init() {
+        getStyleClass().add("slider");
+        // The value is changing from the moment a press on the slider turns
+        // into a drag until the pointer is let go of.
+        addEventHandler(javafx.scene.input.MouseEvent.DRAG_DETECTED,
+                new javafx.event.EventHandler<javafx.scene.input.MouseEvent>() {
+                    @Override
+                    public void handle(javafx.scene.input.MouseEvent event) {
+                        if (!isDisabled()) {
+                            setValueChanging(true);
+                        }
+                    }
+                });
+        addEventHandler(javafx.scene.input.MouseEvent.MOUSE_RELEASED,
+                new javafx.event.EventHandler<javafx.scene.input.MouseEvent>() {
+                    @Override
+                    public void handle(javafx.scene.input.MouseEvent event) {
+                        if (isValueChanging()) {
+                            setValueChanging(false);
+                        }
+                    }
+                });
+        minorTickCount.addListener(new javafx.beans.InvalidationListener() {
+            @Override
+            public void invalidated(javafx.beans.Observable observable) {
+                cn1Repaint();
+            }
+        });
+        pseudoClassStateChanged(HORIZONTAL, true);
+    }
+
+    /// The native slider with the thumb many themes leave out.
+    ///
+    /// A Codename One slider is a progress bar that can be dragged. A
+    /// theme that says nothing more draws the filled part and the rest
+    /// and no thumb at all, and the desktop themes draw a white knob with
+    /// no edge, which is not there on a white scene. A slider with
+    /// nothing to take hold of does not read as one, so where the theme's
+    /// own thumb cannot be seen this draws a round one, in the color of
+    /// the filled part, as the Swing layer's slider does. A theme whose
+    /// thumb is an image, casts a shadow or stands out from the theme's
+    /// own form is left as it is.
+    private static final class Track extends com.codename1.ui.Slider {
+
+        private static final int THUMB = 16;
+        private static final int TOUCH_THUMB = 24;
+
+        /// The diameter of the thumb this draws, in device pixels.
+        static int thumbSize() {
+            boolean touch = Display.isInitialized() && Display.getInstance().isTouchScreenDevice()
+                    && !Display.getInstance().isDesktop();
+            return Math.max(3, Units.toPixels(touch ? TOUCH_THUMB : THUMB));
+        }
+
+        private float constant(String name) {
+            String value = getUIManager().getThemeConstant(name, null);
+            if (value == null) {
+                return 0;
+            }
+            try {
+                return Float.parseFloat(value.trim());
+            } catch (NumberFormatException notANumber) {
+                return 0;
+            }
+        }
+
+        /// Whether the theme draws a thumb that can be told from what is
+        /// around it.
+        private boolean themeThumbShows() {
+            if (getThumbImage() != null) {
+                return true;
+            }
+            // The thumb a theme describes with constants is drawn on a
+            // horizontal slider only.
+            if (isVertical() || !(constant("sliderTrackThicknessMM") > 0)) {
+                return false;
+            }
+            if (constant("sliderThumbShadowSizeMM") > 0) {
+                return true;
+            }
+            int thumb = getUIManager().getComponentStyle(getUIID()).getFgColor();
+            int surface = getUIManager().getComponentStyle("Form").getBgColor();
+            int apart = Math.abs(((thumb >> 16) & 0xff) - ((surface >> 16) & 0xff))
+                    + Math.abs(((thumb >> 8) & 0xff) - ((surface >> 8) & 0xff))
+                    + Math.abs((thumb & 0xff) - (surface & 0xff));
+            // A scene is white unless it says otherwise, a shade or two
+            // from a light theme's form: a knob has to be well clear of
+            // the form to be clear of the scene as well.
+            return apart >= 96;
+        }
+
+        @Override
+        public void paint(Graphics g) {
+            super.paint(g);
+            if (isInfinite() || !isEditable() || themeThumbShows()) {
+                return;
+            }
+            int w = getWidth();
+            int h = getHeight();
+            int range = getMaxValue() - getMinValue();
+            float f = range <= 0 ? 0 : (getProgress() - getMinValue()) / (float) range;
+            f = Math.max(0, Math.min(1, f));
+            boolean vertical = isVertical();
+            int d = thumbSize();
+            // Large enough to cover a knob of the theme's that cannot be seen.
+            float knob = constant("sliderThumbWidthMM");
+            if (!vertical && knob > 0) {
+                d = Math.max(d, Display.getInstance().convertToPixels(knob) + 2);
+            }
+            d = Math.max(1, Math.min(d, Math.min(w, h)));
+            // The thumb's centre is where the filled part ends, kept half
+            // a thumb from either end.
+            int cx;
+            int cy;
+            if (vertical) {
+                cx = getX() + w / 2;
+                cy = getY() + Math.max(d / 2, Math.min(h - (d + 1) / 2, h - Math.round(f * h)));
+            } else {
+                cx = getX() + Math.max(d / 2, Math.min(w - (d + 1) / 2, Math.round(f * w)));
+                cy = getY() + h / 2;
+            }
+            Style full = getUIManager().getComponentStyle(getUIID() + "Full");
+            int ink = getUIManager().getComponentStyle("Label").getFgColor();
+            int surface = getUIManager().getComponentStyle("Form").getBgColor();
+            // The color the theme fills the track with; a theme that fills
+            // it with an image has none to give, and the thumb is then a
+            // shade of the text color.
+            int color = (full.getBgTransparency() & 0xff) != 0 && full.getBorder() == null
+                    ? full.getBgColor() : mix(surface, ink, 3);
+            if (!isEnabled()) {
+                color = mix(surface, ink, 1);
+            }
+            int before = g.getColor();
+            boolean smooth = g.isAntiAliased();
+            if (g.isAntiAliasingSupported()) {
+                g.setAntiAliased(true);
+            }
+            // An outline in the color behind keeps the thumb apart from
+            // the track on either side of it.
+            g.setColor(surface);
+            g.fillArc(cx - d / 2 - 1, cy - d / 2 - 1, d + 2, d + 2, 0, 360);
+            g.setColor(color);
+            g.fillArc(cx - d / 2, cy - d / 2, d, d, 0, 360);
+            if (g.isAntiAliasingSupported()) {
+                g.setAntiAliased(smooth);
+            }
+            g.setColor(before);
+        }
+
+        /// `a` with `quarters` quarters of `b` mixed in.
+        private static int mix(int a, int b, int quarters) {
+            int r = (((a >> 16) & 0xff) * (4 - quarters) + ((b >> 16) & 0xff) * quarters) / 4;
+            int gr = (((a >> 8) & 0xff) * (4 - quarters) + ((b >> 8) & 0xff) * quarters) / 4;
+            int bl = ((a & 0xff) * (4 - quarters) + (b & 0xff) * quarters) / 4;
+            return (r << 16) | (gr << 8) | bl;
+        }
+    }
+
+    /// The least a slider is across its track: the thumb, with a pixel of
+    /// outline and one to spare on either side. A theme's own slider can
+    /// ask for less than the thumb that is drawn on it.
+    private double across() {
+        Insets in = getInsets();
+        double thumb = Units.toLogical(Track.thumbSize()) + 4;
+        return getOrientation() == Orientation.VERTICAL ? in.getLeft() + thumb + in.getRight()
+                : in.getTop() + thumb + in.getBottom();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.Slider s = new Track();
+        s.setMinValue(0);
+        s.setMaxValue(STEPS);
+        s.setEditable(true);
+        s.addDataChangedListener(new DataChangedListener() {
+            @Override
+            public void dataChanged(int type, int index) {
+                // The native slider reports the new position as the index,
+                // in one case before it stores it.
+                if (!syncing && !value.isBound()) {
+                    double lo = getMin();
+                    setValue(lo + (getMax() - lo) * index / STEPS);
+                }
+            }
+        });
+        return s;
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (!(c instanceof com.codename1.ui.Slider)) {
+            return;
+        }
+        com.codename1.ui.Slider s = (com.codename1.ui.Slider) c;
+        double lo = getMin();
+        double span = getMax() - lo;
+        int position = span > 0 ? (int) Math.round((getValue() - lo) / span * STEPS) : 0;
+        position = Math.max(0, Math.min(STEPS, position));
+        double block = span > 0 ? getBlockIncrement() / span * STEPS : 0;
+        syncing = true;
+        try {
+            s.setVertical(getOrientation() == Orientation.VERTICAL);
+            s.setIncrements(Math.max(1, (int) Math.round(block)));
+            if (s.getProgress() != position) {
+                s.setProgress(position);
+            }
+        } finally {
+            syncing = false;
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & (MIN | MAX | VALUE)) != 0 && !clamping) {
+            clamping = true;
+            try {
+                if ((what & MIN) != 0 && getMin() > getMax() && !max.isBound()) {
+                    setMax(getMin());
+                } else if ((what & MAX) != 0 && getMax() < getMin() && !min.isBound()) {
+                    setMin(getMax());
+                }
+                if (!value.isBound()) {
+                    double v = getValue();
+                    if (v < getMin()) {
+                        setValue(getMin());
+                    } else if (v > getMax()) {
+                        setValue(getMax());
+                    }
+                }
+            } finally {
+                clamping = false;
+            }
+        }
+        if ((what & ORIENTATION) != 0) {
+            boolean vertical = getOrientation() == Orientation.VERTICAL;
+            pseudoClassStateChanged(VERTICAL, vertical);
+            pseudoClassStateChanged(HORIZONTAL, !vertical);
+            Component c = cn1NativeIfCreated();
+            if (c != null) {
+                c.setShouldCalcPreferredSize(true);
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    // ------------------------------------------------------------ ticks
+
+    /// The font of the tick labels: the default one, a little smaller.
+    private static Font tickFont() {
+        return Font.font(Font.getDefault().getSize() * 0.85);
+    }
+
+    /// What a tick label reads: the formatter's text, or the number with
+    /// no fraction when it has none.
+    private String tickText(double v) {
+        StringConverter<Double> f = getLabelFormatter();
+        if (f != null) {
+            String s = f.toString(Double.valueOf(v));
+            return s == null ? "" : s;
+        }
+        if (v == Math.floor(v) && Math.abs(v) < 1e15) {
+            return String.valueOf((long) v);
+        }
+        return String.valueOf(Math.round(v * 100) / 100.0);
+    }
+
+    /// How many major ticks the range holds, the one at `min` included;
+    /// zero when the unit cannot be drawn.
+    private int majorTicks() {
+        double unit = getMajorTickUnit();
+        double span = getMax() - getMin();
+        if (!(unit > 0) || !(span > 0)) {
+            return 0;
+        }
+        double n = Math.floor(span / unit + 1e-9) + 1;
+        return n > MAX_TICKS ? 0 : (int) n;
+    }
+
+    /// The room the tick marks and the tick labels take: below the track
+    /// of a horizontal slider, to the right of a vertical one.
+    private double tickBand() {
+        double band = isShowTickMarks() ? MAJOR_TICK + TICK_GAP : 0;
+        if (!isShowTickLabels()) {
+            return band;
+        }
+        Font font = tickFont();
+        if (getOrientation() != Orientation.VERTICAL) {
+            return band + Fonts.lineHeight(font) + TICK_GAP;
+        }
+        double widest = 0;
+        int n = majorTicks();
+        for (int i = 0; i < n; i++) {
+            widest = Math.max(widest, Fonts.width(font, tickText(getMin() + i * getMajorTickUnit())));
+        }
+        return band + widest + TICK_GAP;
+    }
+
+    @Override
+    protected double cn1NativeBand(boolean below) {
+        if (below == (getOrientation() == Orientation.VERTICAL)) {
+            return 0;
+        }
+        double band = isShowTickMarks() || isShowTickLabels() ? tickBand() : 0;
+        return band > 0 ? band : 0;
+    }
+
+    /// Draws the tick marks and the tick labels the application asked
+    /// for, in the band kept beside the native slider, which draws
+    /// neither. A tick is where the thumb stands at that value: the
+    /// native slider moves it over its width less its padding.
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        super.cn1Paint(renderer);
+        boolean marks = isShowTickMarks();
+        boolean labels = isShowTickLabels();
+        int n = marks || labels ? majorTicks() : 0;
+        if (n == 0) {
+            return;
+        }
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        Insets in = getInsets();
+        double band = tickBand();
+        double lead = 0;
+        double trail = 0;
+        Component c = cn1NativeIfCreated();
+        if (c != null) {
+            Style s = c.getStyle();
+            lead = Units.toLogical(vertical ? s.getPaddingTop() : s.getPaddingLeftNoRTL());
+            trail = Units.toLogical(vertical ? s.getPaddingBottom() : s.getPaddingRightNoRTL());
+        }
+        // The line the ticks start from, and the run of the track along it.
+        double from = vertical ? in.getTop() + lead : in.getLeft() + lead;
+        double length = (vertical ? getHeight() - in.getBottom() : getWidth() - in.getRight()) - trail - from;
+        double edge = vertical ? getWidth() - in.getRight() - band : getHeight() - in.getBottom() - band;
+        if (!(length > 0)) {
+            return;
+        }
+        int fg = UIManager.getInstance().getComponentStyle("Label").getFgColor();
+        Color ink = Color.rgb((fg >> 16) & 0xff, (fg >> 8) & 0xff, fg & 0xff);
+        Color line = Color.rgb((fg >> 16) & 0xff, (fg >> 8) & 0xff, fg & 0xff, 0.55);
+        double unit = getMajorTickUnit();
+        double span = getMax() - getMin();
+        double t = Units.toLogical(1);
+        Font font = tickFont();
+        double lineHeight = Fonts.lineHeight(font);
+        int minor = Math.max(0, getMinorTickCount());
+        double step = unit / (minor + 1) / span * length;
+        double lastEnd = -Double.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            double v = getMin() + i * unit;
+            double f = (v - getMin()) / span;
+            double at = from + (vertical ? (1 - f) * length : f * length);
+            if (marks) {
+                tick(renderer, vertical, at, edge, MAJOR_TICK, t, line);
+                // The marks between this one and the next, where they
+                // can be told apart.
+                for (int j = 1; j <= minor && step >= 2 && v + j * unit / (minor + 1) <= getMax() + 1e-9; j++) {
+                    tick(renderer, vertical, at + (vertical ? -j * step : j * step), edge, MINOR_TICK, t, line);
+                }
+            }
+            if (labels) {
+                String text = tickText(v);
+                double w = Fonts.width(font, text);
+                double start = edge + (marks ? MAJOR_TICK + TICK_GAP : TICK_GAP);
+                if (vertical) {
+                    double y = Math.max(0, Math.min(getHeight() - lineHeight, at - lineHeight / 2));
+                    // Upwards: a label is drawn when it ends above the one before.
+                    if (i == 0 || y + lineHeight <= lastEnd) {
+                        renderer.drawText(text, start, y, font, ink);
+                        lastEnd = y;
+                    }
+                } else {
+                    double x = Math.max(0, Math.min(getWidth() - w, at - w / 2));
+                    if (x >= lastEnd) {
+                        renderer.drawText(text, x, start, font, ink);
+                        lastEnd = x + w + TICK_GAP;
+                    }
+                }
+            }
+        }
+    }
+
+    private static void tick(Renderer renderer, boolean vertical, double at, double edge, double length, double t,
+            Color line) {
+        double p = Units.snap(at - t / 2);
+        if (vertical) {
+            renderer.fillRect(edge, p, length, t, line);
+        } else {
+            renderer.fillRect(p, edge, t, length, line);
+        }
+    }
+
+    /// The length a slider asks for is JavaFX's, 140, and not the platform
+    /// slider's, which asks for most of a screen: a slider among other
+    /// controls in a row would push them out of it.
+    @Override
+    protected double computePrefWidth(double height) {
+        if (getOrientation() == Orientation.VERTICAL) {
+            return Math.max(super.computePrefWidth(height), across()) + tickBand();
+        }
+        Insets in = getInsets();
+        return in.getLeft() + 140 + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        if (getOrientation() != Orientation.VERTICAL) {
+            return Math.max(super.computePrefHeight(width), across()) + tickBand();
+        }
+        Insets in = getInsets();
+        return in.getTop() + 140 + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        return getOrientation() == Orientation.VERTICAL ? computePrefWidth(height) : Math.min(60, computePrefWidth(height));
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return getOrientation() == Orientation.VERTICAL ? Math.min(60, computePrefHeight(width)) : computePrefHeight(width);
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return getOrientation() == Orientation.VERTICAL ? computePrefWidth(height) : Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return getOrientation() == Orientation.VERTICAL ? Double.MAX_VALUE : computePrefHeight(width);
+    }
+
+    /// Moves the value to the given one, kept inside the range and, with
+    /// `snapToTicks`, moved to the nearest tick. Does nothing while the
+    /// range is empty.
+    public void adjustValue(double newValue) {
+        double lo = getMin();
+        double hi = getMax();
+        if (hi <= lo) {
+            return;
+        }
+        double v = newValue < lo ? lo : (newValue > hi ? hi : newValue);
+        setValue(snap(v));
+    }
+
+    /// Raises the value by the block increment.
+    public void increment() {
+        adjustValue(getValue() + getBlockIncrement());
+    }
+
+    /// Lowers the value by the block increment.
+    public void decrement() {
+        adjustValue(getValue() - getBlockIncrement());
+    }
+
+    private double snap(double v) {
+        if (!isSnapToTicks()) {
+            return v;
+        }
+        double spacing = getMajorTickUnit();
+        int minor = getMinorTickCount();
+        if (minor > 0) {
+            spacing = spacing / (minor + 1);
+        }
+        if (!(spacing > 0)) {
+            return v;
+        }
+        double lo = getMin();
+        double hi = getMax();
+        double before = Math.floor((v - lo) / spacing) * spacing + lo;
+        double after = before + spacing;
+        double snapped = v - before <= after - v ? before : after;
+        return snapped < lo ? lo : (snapped > hi ? hi : snapped);
+    }
+
+    /// Returns the low end of the range.
+    public final double getMin() {
+        return min.get();
+    }
+
+    /// Sets the low end of the range.
+    public final void setMin(double value) {
+        min.set(value);
+    }
+
+    /// The low end of the range.
+    public final DoubleProperty minProperty() {
+        return min;
+    }
+
+    /// Returns the high end of the range.
+    public final double getMax() {
+        return max.get();
+    }
+
+    /// Sets the high end of the range.
+    public final void setMax(double value) {
+        max.set(value);
+    }
+
+    /// The high end of the range.
+    public final DoubleProperty maxProperty() {
+        return max;
+    }
+
+    /// Returns the value.
+    public final double getValue() {
+        return value.get();
+    }
+
+    /// Sets the value; one outside the range becomes the nearer end.
+    public final void setValue(double value) {
+        if (!this.value.isBound()) {
+            this.value.set(value);
+        }
+    }
+
+    /// The value.
+    public final DoubleProperty valueProperty() {
+        return value;
+    }
+
+    /// Returns whether the value is in the middle of being changed by
+    /// the user. Nothing in this layer sets it.
+    public final boolean isValueChanging() {
+        return valueChanging.get();
+    }
+
+    /// Sets whether the value is in the middle of being changed.
+    public final void setValueChanging(boolean value) {
+        valueChanging.set(value);
+    }
+
+    /// Whether the value is in the middle of being changed.
+    public final BooleanProperty valueChangingProperty() {
+        return valueChanging;
+    }
+
+    /// Returns the direction of the slider.
+    public final Orientation getOrientation() {
+        Orientation o = orientation.get();
+        return o == null ? Orientation.HORIZONTAL : o;
+    }
+
+    /// Sets the direction of the slider.
+    public final void setOrientation(Orientation value) {
+        orientation.set(value);
+    }
+
+    /// The direction of the slider.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+
+    /// Returns whether tick labels are asked for.
+    public final boolean isShowTickLabels() {
+        return showTickLabels.get();
+    }
+
+    /// Asks for tick labels.
+    public final void setShowTickLabels(boolean value) {
+        showTickLabels.set(value);
+    }
+
+    /// Whether tick labels are asked for.
+    public final BooleanProperty showTickLabelsProperty() {
+        return showTickLabels;
+    }
+
+    /// Returns whether tick marks are asked for.
+    public final boolean isShowTickMarks() {
+        return showTickMarks.get();
+    }
+
+    /// Asks for tick marks.
+    public final void setShowTickMarks(boolean value) {
+        showTickMarks.set(value);
+    }
+
+    /// Whether tick marks are asked for.
+    public final BooleanProperty showTickMarksProperty() {
+        return showTickMarks;
+    }
+
+    /// Returns the distance between major ticks.
+    public final double getMajorTickUnit() {
+        return majorTickUnit.get();
+    }
+
+    /// Sets the distance between major ticks.
+    public final void setMajorTickUnit(double value) {
+        majorTickUnit.set(value);
+    }
+
+    /// The distance between major ticks.
+    public final DoubleProperty majorTickUnitProperty() {
+        return majorTickUnit;
+    }
+
+    /// Returns the number of minor ticks between two major ones.
+    public final int getMinorTickCount() {
+        return minorTickCount.get();
+    }
+
+    /// Sets the number of minor ticks between two major ones.
+    public final void setMinorTickCount(int value) {
+        minorTickCount.set(value);
+    }
+
+    /// The number of minor ticks between two major ones.
+    public final IntegerProperty minorTickCountProperty() {
+        return minorTickCount;
+    }
+
+    /// Returns whether adjusting the value moves it to the nearest tick.
+    public final boolean isSnapToTicks() {
+        return snapToTicks.get();
+    }
+
+    /// Sets whether adjusting the value moves it to the nearest tick.
+    public final void setSnapToTicks(boolean value) {
+        snapToTicks.set(value);
+    }
+
+    /// Whether adjusting the value moves it to the nearest tick.
+    public final BooleanProperty snapToTicksProperty() {
+        return snapToTicks;
+    }
+
+    /// Returns the step of [#increment()] and [#decrement()].
+    public final double getBlockIncrement() {
+        return blockIncrement.get();
+    }
+
+    /// Sets the step of [#increment()] and [#decrement()].
+    public final void setBlockIncrement(double value) {
+        blockIncrement.set(value);
+    }
+
+    /// The step of [#increment()] and [#decrement()].
+    public final DoubleProperty blockIncrementProperty() {
+        return blockIncrement;
+    }
+
+    /// Returns the converter for tick labels.
+    public final StringConverter<Double> getLabelFormatter() {
+        return labelFormatter.get();
+    }
+
+    /// Sets the converter for tick labels.
+    public final void setLabelFormatter(StringConverter<Double> value) {
+        labelFormatter.set(value);
+    }
+
+    /// The converter for tick labels.
+    public final ObjectProperty<StringConverter<Double>> labelFormatterProperty() {
+        return labelFormatter;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Spinner.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Spinner.java
new file mode 100644
index 00000000000..9d6a7b7f168
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Spinner.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Polygon;
+import javafx.util.StringConverter;
+
+/// A text field with two arrows that step a value up and down.
+///
+/// The value and how it steps belong to a [SpinnerValueFactory]; the
+/// spinner shows the value in its editor through the factory's converter.
+/// In an editable spinner, Enter in the editor or the editor losing the
+/// focus reads the text back through the converter, and a text the
+/// converter cannot read puts the value back.
+///
+/// The arrows are one above the other at the right of the editor unless
+/// one of the `STYLE_CLASS_*` constants is among the style classes, which
+/// moves them as its name says. Arrows beside the editor point left and
+/// right, and the one that steps up is the right one.
+public class Spinner<T> extends Control {
+
+    /// The arrows beside each other at the right.
+    public static final String STYLE_CLASS_ARROWS_ON_RIGHT_HORIZONTAL = "arrows-on-right-horizontal";
+    /// The arrows one above the other at the left.
+    public static final String STYLE_CLASS_ARROWS_ON_LEFT_VERTICAL = "arrows-on-left-vertical";
+    /// The arrows beside each other at the left.
+    public static final String STYLE_CLASS_ARROWS_ON_LEFT_HORIZONTAL = "arrows-on-left-horizontal";
+    /// One arrow above the editor and one below it.
+    public static final String STYLE_CLASS_SPLIT_ARROWS_VERTICAL = "split-arrows-vertical";
+    /// One arrow at either side of the editor.
+    public static final String STYLE_CLASS_SPLIT_ARROWS_HORIZONTAL = "split-arrows-horizontal";
+
+    private final ReadOnlyObjectWrapper<T> value = new ReadOnlyObjectWrapper<T>(this, "value");
+    private final ObjectProperty<SpinnerValueFactory<T>> valueFactory =
+            new SimpleObjectProperty<SpinnerValueFactory<T>>(this, "valueFactory");
+    private final BooleanProperty editable = new SimpleBooleanProperty(this, "editable", false);
+    private final TextField editor = new TextField();
+    private final Arrow up = new Arrow(true);
+    private final Arrow down = new Arrow(false);
+    private final VBox pair = new VBox();
+    private final HBox row = new HBox();
+    private final VBox box = new VBox();
+    private int arranged = -1;
+    private final ChangeListener<T> stepped = new ChangeListener<T>() {
+        @Override
+        public void changed(ObservableValue<? extends T> observable, T was, T now) {
+            value.set(now);
+            show();
+        }
+    };
+
+    /// One of the two arrows: a region with the standard theme's button
+    /// look and a triangle on it.
+    private static final class Arrow extends StackPane {
+        private final boolean up;
+        private final Polygon mark = new Polygon();
+
+        Arrow(boolean up) {
+            this.up = up;
+            getStyleClass().add(up ? "increment-arrow-button" : "decrement-arrow-button");
+            mark.setFill(Color.gray(0.25));
+            mark.setMouseTransparent(true);
+            getChildren().add(mark);
+            point(false);
+        }
+
+        /// Points the triangle up or down, or right or left for arrows
+        /// that are beside each other.
+        void point(boolean sideways) {
+            Double[] p;
+            if (sideways) {
+                p = up ? corners(0, 0, 4, 4, 0, 8) : corners(4, 0, 0, 4, 4, 8);
+            } else {
+                p = up ? corners(0, 4, 4, 0, 8, 4) : corners(0, 0, 8, 0, 4, 4);
+            }
+            mark.getPoints().setAll(p);
+        }
+
+        private static Double[] corners(double... at) {
+            Double[] out = new Double[at.length];
+            for (int i = 0; i < at.length; i++) {
+                out[i] = Double.valueOf(at[i]);
+            }
+            return out;
+        }
+
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-background-color: -fx-outer-border, linear-gradient(to bottom, derive(-fx-color, 8%),"
+                    + " derive(-fx-color, -8%)); -fx-background-insets: 0, 1; -fx-padding: 3 6 3 6;";
+        }
+    }
+
+    /// Creates a spinner with no value factory.
+    public Spinner() {
+        getStyleClass().add("spinner");
+        editor.setPrefColumnCount(6);
+        editor.setMinWidth(0);
+        editor.setEditable(false);
+        VBox.setVgrow(up, Priority.ALWAYS);
+        VBox.setVgrow(down, Priority.ALWAYS);
+        HBox.setHgrow(editor, Priority.ALWAYS);
+        getStyleClass().addListener((ListChangeListener<String>) change -> arrange());
+        up.addEventHandler(MouseEvent.MOUSE_PRESSED, e -> {
+            if (!isDisabled()) {
+                increment();
+                e.consume();
+            }
+        });
+        down.addEventHandler(MouseEvent.MOUSE_PRESSED, e -> {
+            if (!isDisabled()) {
+                decrement();
+                e.consume();
+            }
+        });
+        editor.setOnAction(e -> commitValue());
+        editor.focusedProperty().addListener((observable, was, now) -> {
+            if (!now.booleanValue()) {
+                commitValue();
+            }
+        });
+        editable.addListener((observable, was, now) -> editor.setEditable(now.booleanValue()));
+        valueFactory.addListener((observable, was, now) -> {
+            if (was != null) {
+                was.valueProperty().removeListener(stepped);
+            }
+            if (now != null) {
+                now.valueProperty().addListener(stepped);
+                value.set(now.getValue());
+            } else {
+                value.set(null);
+            }
+            show();
+        });
+        arrange();
+        cn1MadeOf(box);
+    }
+
+    /// Puts the editor and the arrows where the style classes say.
+    private void arrange() {
+        ObservableList<String> classes = getStyleClass();
+        int now = 0;
+        if (classes.contains(STYLE_CLASS_ARROWS_ON_RIGHT_HORIZONTAL)) {
+            now = 1;
+        } else if (classes.contains(STYLE_CLASS_ARROWS_ON_LEFT_VERTICAL)) {
+            now = 2;
+        } else if (classes.contains(STYLE_CLASS_ARROWS_ON_LEFT_HORIZONTAL)) {
+            now = 3;
+        } else if (classes.contains(STYLE_CLASS_SPLIT_ARROWS_VERTICAL)) {
+            now = 4;
+        } else if (classes.contains(STYLE_CLASS_SPLIT_ARROWS_HORIZONTAL)) {
+            now = 5;
+        }
+        if (now == arranged) {
+            return;
+        }
+        arranged = now;
+        box.getChildren().clear();
+        row.getChildren().clear();
+        pair.getChildren().clear();
+        boolean sideways = now == 1 || now == 3 || now == 5;
+        up.point(sideways);
+        down.point(sideways);
+        if (now == 4) {
+            box.getChildren().addAll(up, editor, down);
+        } else if (now == 5) {
+            row.getChildren().addAll(down, editor, up);
+            box.getChildren().add(row);
+        } else if (now == 1) {
+            row.getChildren().addAll(editor, down, up);
+            box.getChildren().add(row);
+        } else if (now == 3) {
+            row.getChildren().addAll(down, up, editor);
+            box.getChildren().add(row);
+        } else {
+            pair.getChildren().addAll(up, down);
+            if (now == 2) {
+                row.getChildren().addAll(pair, editor);
+            } else {
+                row.getChildren().addAll(editor, pair);
+            }
+            box.getChildren().add(row);
+        }
+        requestLayout();
+    }
+
+    /// A spinner is as wide as its editor and its arrows unless it is
+    /// given a width, and the editor then takes what the arrows leave.
+    @Override
+    protected double computeMinWidth(double height) {
+        return 0;
+    }
+
+    /// Creates a spinner of whole numbers that steps by one.
+    public Spinner(int min, int max, int initialValue) {
+        this(min, max, initialValue, 1);
+    }
+
+    /// Creates a spinner of whole numbers.
+    @SuppressWarnings("unchecked")
+    public Spinner(int min, int max, int initialValue, int amountToStepBy) {
+        this();
+        Object factory = new SpinnerValueFactory.IntegerSpinnerValueFactory(min, max, initialValue, amountToStepBy);
+        setValueFactory((SpinnerValueFactory<T>) factory);
+    }
+
+    /// Creates a spinner of decimal numbers that steps by one.
+    public Spinner(double min, double max, double initialValue) {
+        this(min, max, initialValue, 1);
+    }
+
+    /// Creates a spinner of decimal numbers.
+    @SuppressWarnings("unchecked")
+    public Spinner(double min, double max, double initialValue, double amountToStepBy) {
+        this();
+        Object factory = new SpinnerValueFactory.DoubleSpinnerValueFactory(min, max, initialValue, amountToStepBy);
+        setValueFactory((SpinnerValueFactory<T>) factory);
+    }
+
+    /// Creates a spinner of the items of a list.
+    public Spinner(ObservableList<T> items) {
+        this();
+        setValueFactory(new SpinnerValueFactory.ListSpinnerValueFactory<T>(items));
+    }
+
+    /// Creates a spinner of what a factory steps through.
+    public Spinner(SpinnerValueFactory<T> valueFactory) {
+        this();
+        setValueFactory(valueFactory);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    private void show() {
+        SpinnerValueFactory<T> f = getValueFactory();
+        StringConverter<T> c = f == null ? null : f.getConverter();
+        T v = getValue();
+        String text = v == null ? "" : (c == null ? v.toString() : c.toString(v));
+        editor.setText(text == null ? "" : text);
+    }
+
+    /// Reads the text of the editor into the value, when the spinner is
+    /// editable and the text is one the converter reads; any other text
+    /// is replaced by the value.
+    public final void commitValue() {
+        SpinnerValueFactory<T> f = getValueFactory();
+        StringConverter<T> c = f == null ? null : f.getConverter();
+        if (!isEditable() || c == null) {
+            return;
+        }
+        T read = null;
+        try {
+            read = c.fromString(editor.getText());
+        } catch (RuntimeException notAValue) {
+            read = null;
+        }
+        if (read != null) {
+            f.setValue(read);
+        }
+        show();
+    }
+
+    /// Puts the value back into the editor, dropping what was typed.
+    public final void cancelEdit() {
+        show();
+    }
+
+    /// Steps the value up once.
+    public void increment() {
+        increment(1);
+    }
+
+    /// Steps the value up.
+    public void increment(int steps) {
+        SpinnerValueFactory<T> f = getValueFactory();
+        if (f == null) {
+            throw new IllegalStateException("Can't increment Spinner with a null SpinnerValueFactory");
+        }
+        commitValue();
+        f.increment(steps);
+    }
+
+    /// Steps the value down once.
+    public void decrement() {
+        decrement(1);
+    }
+
+    /// Steps the value down.
+    public void decrement(int steps) {
+        SpinnerValueFactory<T> f = getValueFactory();
+        if (f == null) {
+            throw new IllegalStateException("Can't decrement Spinner with a null SpinnerValueFactory");
+        }
+        commitValue();
+        f.decrement(steps);
+    }
+
+    /// Returns the value, which is the factory's.
+    public final T getValue() {
+        return value.get();
+    }
+
+    /// The value.
+    public final ReadOnlyObjectProperty<T> valueProperty() {
+        return value.getReadOnlyProperty();
+    }
+
+    /// Returns what the spinner steps through.
+    public final SpinnerValueFactory<T> getValueFactory() {
+        return valueFactory.get();
+    }
+
+    /// Sets what the spinner steps through.
+    public final void setValueFactory(SpinnerValueFactory<T> newValue) {
+        valueFactory.set(newValue);
+    }
+
+    /// What the spinner steps through.
+    public final ObjectProperty<SpinnerValueFactory<T>> valueFactoryProperty() {
+        return valueFactory;
+    }
+
+    /// Returns whether a value can be typed.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// Sets whether a value can be typed.
+    public final void setEditable(boolean newValue) {
+        editable.set(newValue);
+    }
+
+    /// Whether a value can be typed.
+    public final BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Returns the text field the value is shown in.
+    public final TextField getEditor() {
+        return editor;
+    }
+
+    /// The text field the value is shown in.
+    public final ReadOnlyObjectProperty<TextField> editorProperty() {
+        return new ReadOnlyObjectWrapper<TextField>(this, "editor", editor).getReadOnlyProperty();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/SpinnerValueFactory.java b/maven/javafx-compat/src/main/java/javafx/scene/control/SpinnerValueFactory.java
new file mode 100644
index 00000000000..7eb0bc5e653
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/SpinnerValueFactory.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.util.StringConverter;
+import javafx.util.converter.DoubleStringConverter;
+import javafx.util.converter.IntegerStringConverter;
+
+/// What a [Spinner] steps through: it holds the value, moves it by a
+/// number of steps either way, and turns it into the text of the editor
+/// and back.
+///
+/// The three factories of JavaFX for whole numbers, decimal numbers and
+/// the items of a list are nested here. The ones for dates and times are
+/// not provided.
+public abstract class SpinnerValueFactory<T> {
+
+    private final ObjectProperty<T> value = new SimpleObjectProperty<T>(this, "value");
+    private final ObjectProperty<StringConverter<T>> converter = new SimpleObjectProperty<StringConverter<T>>(this,
+            "converter");
+    private final BooleanProperty wrapAround = new SimpleBooleanProperty(this, "wrapAround", false);
+
+    /// Creates a factory with no value.
+    public SpinnerValueFactory() {
+    }
+
+    /// Moves the value down by a number of steps.
+    public abstract void decrement(int steps);
+
+    /// Moves the value up by a number of steps.
+    public abstract void increment(int steps);
+
+    /// Returns the value.
+    public final T getValue() {
+        return value.get();
+    }
+
+    /// Sets the value.
+    public final void setValue(T newValue) {
+        value.set(newValue);
+    }
+
+    /// The value.
+    public final ObjectProperty<T> valueProperty() {
+        return value;
+    }
+
+    /// Returns what turns a value into the text of the editor and back.
+    public final StringConverter<T> getConverter() {
+        return converter.get();
+    }
+
+    /// Sets what turns a value into the text of the editor and back.
+    public final void setConverter(StringConverter<T> newValue) {
+        converter.set(newValue);
+    }
+
+    /// The converter.
+    public final ObjectProperty<StringConverter<T>> converterProperty() {
+        return converter;
+    }
+
+    /// Returns whether a step past one end arrives at the other.
+    public final boolean isWrapAround() {
+        return wrapAround.get();
+    }
+
+    /// Sets whether a step past one end arrives at the other.
+    public final void setWrapAround(boolean newValue) {
+        wrapAround.set(newValue);
+    }
+
+    /// Whether a step past one end arrives at the other.
+    public final BooleanProperty wrapAroundProperty() {
+        return wrapAround;
+    }
+
+    /// Whole numbers between a minimum and a maximum.
+    public static class IntegerSpinnerValueFactory extends SpinnerValueFactory<Integer> {
+
+        private final IntegerProperty min = new SimpleIntegerProperty(this, "min");
+        private final IntegerProperty max = new SimpleIntegerProperty(this, "max");
+        private final IntegerProperty amountToStepBy = new SimpleIntegerProperty(this, "amountToStepBy", 1);
+
+        /// Creates a factory that starts at the minimum and steps by one.
+        public IntegerSpinnerValueFactory(int min, int max) {
+            this(min, max, min);
+        }
+
+        /// Creates a factory that steps by one.
+        public IntegerSpinnerValueFactory(int min, int max, int initialValue) {
+            this(min, max, initialValue, 1);
+        }
+
+        /// Creates a factory. An initial value outside the range is the
+        /// minimum.
+        public IntegerSpinnerValueFactory(int min, int max, int initialValue, int amountToStepBy) {
+            this.min.set(min);
+            this.max.set(max);
+            this.amountToStepBy.set(amountToStepBy);
+            setConverter(new IntegerStringConverter());
+            valueProperty().addListener((observable, was, now) -> {
+                if (now == null) {
+                    return;
+                }
+                if (now.intValue() < getMin()) {
+                    setValue(Integer.valueOf(getMin()));
+                } else if (now.intValue() > getMax()) {
+                    setValue(Integer.valueOf(getMax()));
+                }
+            });
+            setValue(Integer.valueOf(initialValue >= min && initialValue <= max ? initialValue : min));
+        }
+
+        @Override
+        public void decrement(int steps) {
+            step(-steps);
+        }
+
+        @Override
+        public void increment(int steps) {
+            step(steps);
+        }
+
+        private void step(int steps) {
+            int low = getMin();
+            int high = getMax();
+            Integer now = getValue();
+            long next = (now == null ? low : now.intValue()) + (long) steps * getAmountToStepBy();
+            if (next < low || next > high) {
+                long span = (long) high - low + 1;
+                if (isWrapAround() && span > 0) {
+                    next = low + (((next - low) % span) + span) % span;
+                } else {
+                    next = next < low ? low : high;
+                }
+            }
+            setValue(Integer.valueOf((int) next));
+        }
+
+        /// Returns the least value.
+        public final int getMin() {
+            return min.get();
+        }
+
+        /// Sets the least value.
+        public final void setMin(int value) {
+            min.set(value);
+        }
+
+        /// The least value.
+        public final IntegerProperty minProperty() {
+            return min;
+        }
+
+        /// Returns the greatest value.
+        public final int getMax() {
+            return max.get();
+        }
+
+        /// Sets the greatest value.
+        public final void setMax(int value) {
+            max.set(value);
+        }
+
+        /// The greatest value.
+        public final IntegerProperty maxProperty() {
+            return max;
+        }
+
+        /// Returns the size of one step.
+        public final int getAmountToStepBy() {
+            return amountToStepBy.get();
+        }
+
+        /// Sets the size of one step.
+        public final void setAmountToStepBy(int value) {
+            amountToStepBy.set(value);
+        }
+
+        /// The size of one step.
+        public final IntegerProperty amountToStepByProperty() {
+            return amountToStepBy;
+        }
+    }
+
+    /// Decimal numbers between a minimum and a maximum.
+    public static class DoubleSpinnerValueFactory extends SpinnerValueFactory<Double> {
+
+        private final DoubleProperty min = new SimpleDoubleProperty(this, "min");
+        private final DoubleProperty max = new SimpleDoubleProperty(this, "max");
+        private final DoubleProperty amountToStepBy = new SimpleDoubleProperty(this, "amountToStepBy", 1);
+
+        /// Creates a factory that starts at the minimum and steps by one.
+        public DoubleSpinnerValueFactory(double min, double max) {
+            this(min, max, min);
+        }
+
+        /// Creates a factory that steps by one.
+        public DoubleSpinnerValueFactory(double min, double max, double initialValue) {
+            this(min, max, initialValue, 1);
+        }
+
+        /// Creates a factory. An initial value outside the range is the
+        /// minimum.
+        public DoubleSpinnerValueFactory(double min, double max, double initialValue, double amountToStepBy) {
+            this.min.set(min);
+            this.max.set(max);
+            this.amountToStepBy.set(amountToStepBy);
+            setConverter(new DoubleStringConverter());
+            valueProperty().addListener((observable, was, now) -> {
+                if (now == null) {
+                    return;
+                }
+                if (now.doubleValue() < getMin()) {
+                    setValue(Double.valueOf(getMin()));
+                } else if (now.doubleValue() > getMax()) {
+                    setValue(Double.valueOf(getMax()));
+                }
+            });
+            setValue(Double.valueOf(initialValue >= min && initialValue <= max ? initialValue : min));
+        }
+
+        @Override
+        public void decrement(int steps) {
+            step(-steps);
+        }
+
+        @Override
+        public void increment(int steps) {
+            step(steps);
+        }
+
+        private void step(int steps) {
+            double low = getMin();
+            double high = getMax();
+            Double now = getValue();
+            double next = (now == null ? low : now.doubleValue()) + steps * getAmountToStepBy();
+            if (next < low) {
+                next = isWrapAround() ? high : low;
+            } else if (next > high) {
+                next = isWrapAround() ? low : high;
+            }
+            setValue(Double.valueOf(next));
+        }
+
+        /// Returns the least value.
+        public final double getMin() {
+            return min.get();
+        }
+
+        /// Sets the least value.
+        public final void setMin(double value) {
+            min.set(value);
+        }
+
+        /// The least value.
+        public final DoubleProperty minProperty() {
+            return min;
+        }
+
+        /// Returns the greatest value.
+        public final double getMax() {
+            return max.get();
+        }
+
+        /// Sets the greatest value.
+        public final void setMax(double value) {
+            max.set(value);
+        }
+
+        /// The greatest value.
+        public final DoubleProperty maxProperty() {
+            return max;
+        }
+
+        /// Returns the size of one step.
+        public final double getAmountToStepBy() {
+            return amountToStepBy.get();
+        }
+
+        /// Sets the size of one step.
+        public final void setAmountToStepBy(double value) {
+            amountToStepBy.set(value);
+        }
+
+        /// The size of one step.
+        public final DoubleProperty amountToStepByProperty() {
+            return amountToStepBy;
+        }
+    }
+
+    /// The items of a list, in its order.
+    public static class ListSpinnerValueFactory<T> extends SpinnerValueFactory<T> {
+
+        private final ObjectProperty<ObservableList<T>> items = new SimpleObjectProperty<ObservableList<T>>(this,
+                "items");
+
+        /// Creates a factory that starts at the first item of a list.
+        public ListSpinnerValueFactory(ObservableList<T> items) {
+            setConverter(new StringConverter<T>() {
+                @Override
+                public String toString(T object) {
+                    return object == null ? "" : object.toString();
+                }
+
+                @Override
+                public T fromString(String string) {
+                    ObservableList<T> all = getItems();
+                    for (int i = 0; all != null && i < all.size(); i++) {
+                        T item = all.get(i);
+                        if (item != null && item.toString().equals(string)) {
+                            return item;
+                        }
+                    }
+                    return getValue();
+                }
+            });
+            this.items.set(items == null ? FXCollections.<T>observableArrayList() : items);
+            ObservableList<T> all = this.items.get();
+            setValue(all.isEmpty() ? null : all.get(0));
+        }
+
+        @Override
+        public void decrement(int steps) {
+            step(-steps);
+        }
+
+        @Override
+        public void increment(int steps) {
+            step(steps);
+        }
+
+        private void step(int steps) {
+            ObservableList<T> all = getItems();
+            int n = all == null ? 0 : all.size();
+            if (n == 0) {
+                return;
+            }
+            int at = Math.max(0, all.indexOf(getValue())) + steps;
+            if (at < 0 || at >= n) {
+                at = isWrapAround() ? ((at % n) + n) % n : (at < 0 ? 0 : n - 1);
+            }
+            setValue(all.get(at));
+        }
+
+        /// Returns the items.
+        public final ObservableList<T> getItems() {
+            return items.get();
+        }
+
+        /// Sets the items.
+        public final void setItems(ObservableList<T> value) {
+            items.set(value);
+        }
+
+        /// The items.
+        public final ObjectProperty<ObservableList<T>> itemsProperty() {
+            return items;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/SplitPane.java b/maven/javafx-compat/src/main/java/javafx/scene/control/SplitPane.java
new file mode 100644
index 00000000000..2122c01015b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/SplitPane.java
@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.ui.Component;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.css.PseudoClass;
+import javafx.event.EventHandler;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Point2D;
+import javafx.geometry.VPos;
+import javafx.scene.Cursor;
+import javafx.scene.Node;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// Items side by side, or one above the other, with a divider between
+/// each two that the user drags to give one more room and the other
+/// less.
+///
+/// The items are children of the split pane, laid out by it; between
+/// them sit divider bars, regions of this control that follow the
+/// pointer while it is down on them. A divider's position is the
+/// fraction, 0 to 1, of the pane's length at which its bar is centred.
+///
+/// #### Differences from JavaFX
+///
+/// - A divider is never placed before the one in front of it, and where
+///   there is room it leaves the items on both sides their minimum
+///   size; the stored position is not rewritten when that moves the bar.
+/// - Positions are fractions of the pane at every size, so every item
+///   grows and shrinks with the pane: what `setResizableWithParent`
+///   records is not applied.
+/// - An item is not clipped to its area.
+///
+/// The pseudo-classes `horizontal` and `vertical` follow the
+/// orientation.
+public class SplitPane extends Control {
+
+    private static final int ORIENTATION = Dirty.USER;
+    private static final double BAR = 6;
+    private static final String RESIZABLE_WITH_PARENT = "resizable-with-parent";
+    private static final PseudoClass HORIZONTAL = PseudoClass.getPseudoClass("horizontal");
+    private static final PseudoClass VERTICAL = PseudoClass.getPseudoClass("vertical");
+
+    private final ObservableList<Node> items = FXCollections.observableArrayList();
+    private final ObservableList<Divider> dividers = FXCollections.observableArrayList();
+    private final ObservableList<Divider> unmodifiableDividers = FXCollections.unmodifiableObservableList(dividers);
+    private final ArrayList<Region> bars = new ArrayList<Region>();
+    private final HashMap<Integer, Double> pending = new HashMap<Integer, Double>();
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, ORIENTATION | Dirty.LAYOUT);
+    private final InvalidationListener moved = new InvalidationListener() {
+        @Override
+        public void invalidated(Observable observable) {
+            requestLayout();
+        }
+    };
+
+    /// Sets whether an item keeps its share when the split pane is
+    /// resized. Recorded in the node's properties; see the class
+    /// description.
+    public static void setResizableWithParent(Node node, Boolean value) {
+        if (value == null) {
+            node.getProperties().remove(RESIZABLE_WITH_PARENT);
+        } else {
+            node.getProperties().put(RESIZABLE_WITH_PARENT, value);
+        }
+    }
+
+    /// Returns what [#setResizableWithParent(Node, Boolean)] recorded for
+    /// a node; true when nothing was.
+    public static Boolean isResizableWithParent(Node node) {
+        if (node.hasProperties()) {
+            Object value = node.getProperties().get(RESIZABLE_WITH_PARENT);
+            if (value instanceof Boolean) {
+                return (Boolean) value;
+            }
+        }
+        return Boolean.TRUE;
+    }
+
+    /// Creates an empty split pane.
+    public SplitPane() {
+        this((Node[]) null);
+    }
+
+    /// Creates a split pane with items.
+    public SplitPane(Node... items) {
+        getStyleClass().add("split-pane");
+        setFocusTraversable(false);
+        pseudoClassStateChanged(HORIZONTAL, true);
+        this.items.addListener(new ListChangeListener<Node>() {
+            @Override
+            public void onChanged(Change<? extends Node> change) {
+                itemsChanged();
+            }
+        });
+        if (items != null) {
+            this.items.addAll(items);
+        }
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & ORIENTATION) != 0) {
+            boolean vertical = getOrientation() == Orientation.VERTICAL;
+            pseudoClassStateChanged(VERTICAL, vertical);
+            pseudoClassStateChanged(HORIZONTAL, !vertical);
+            for (int i = 0; i < bars.size(); i++) {
+                bars.get(i).setCursor(vertical ? Cursor.V_RESIZE : Cursor.H_RESIZE);
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    private void itemsChanged() {
+        int wanted = Math.max(0, items.size() - 1);
+        while (dividers.size() > wanted) {
+            dividers.remove(dividers.size() - 1);
+            bars.remove(bars.size() - 1);
+        }
+        while (dividers.size() < wanted) {
+            Divider d = new Divider();
+            Double early = pending.remove(Integer.valueOf(dividers.size()));
+            if (early != null) {
+                d.setPosition(early.doubleValue());
+            }
+            d.positionProperty().addListener(moved);
+            dividers.add(d);
+            bars.add(bar(d));
+        }
+        ArrayList<Node> all = new ArrayList<Node>(items);
+        all.addAll(bars);
+        cn1Children().setAll(all);
+        requestLayout();
+    }
+
+    /// The bar between two items, in the colour the theme gives one.
+    private static final class Bar extends Region {
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-background-color: derive(-fx-base, -12%);";
+        }
+    }
+
+    private Region bar(final Divider divider) {
+        Region r = new Bar();
+        r.setManaged(false);
+        r.getStyleClass().add("split-pane-divider");
+        r.setBackground(new Background(new BackgroundFill(Color.gray(0.8), CornerRadii.EMPTY, Insets.EMPTY)));
+        r.setCursor(getOrientation() == Orientation.VERTICAL ? Cursor.V_RESIZE : Cursor.H_RESIZE);
+        EventHandler<MouseEvent> drag = new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                if (event.getEventType() == MouseEvent.MOUSE_DRAGGED && !divider.positionProperty().isBound()) {
+                    Insets in = getInsets();
+                    Point2D p = sceneToLocal(event.getSceneX(), event.getSceneY());
+                    boolean vertical = getOrientation() == Orientation.VERTICAL;
+                    double length = vertical ? getHeight() - in.getTop() - in.getBottom()
+                            : getWidth() - in.getLeft() - in.getRight();
+                    double along = vertical ? p.getY() - in.getTop() : p.getX() - in.getLeft();
+                    if (length > 0) {
+                        divider.setPosition(Math.max(0, Math.min(1, along / length)));
+                    }
+                }
+                event.consume();
+            }
+        };
+        r.addEventHandler(MouseEvent.MOUSE_PRESSED, drag);
+        r.addEventHandler(MouseEvent.MOUSE_DRAGGED, drag);
+        return r;
+    }
+
+    // --------------------------------------------------------------- layout
+
+    private static double along(Node n, boolean vertical, boolean min) {
+        if (!n.isResizable()) {
+            return vertical ? n.getLayoutBounds().getHeight() : n.getLayoutBounds().getWidth();
+        }
+        if (min) {
+            return vertical ? n.minHeight(-1) : n.minWidth(-1);
+        }
+        return vertical ? n.prefHeight(-1) : n.prefWidth(-1);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        double w = Math.max(0, getWidth() - in.getLeft() - in.getRight());
+        double h = Math.max(0, getHeight() - in.getTop() - in.getBottom());
+        double length = vertical ? h : w;
+        int n = items.size();
+        double start = 0;
+        for (int i = 0; i < n; i++) {
+            double end = length;
+            if (i < n - 1 && i < bars.size()) {
+                double p = Math.max(0, Math.min(1, dividers.get(i).getPosition()));
+                double remaining = (n - 2 - i) * BAR;
+                double low = start;
+                double high = Math.max(low, length - BAR - remaining);
+                double lowMin = start + along(items.get(i), vertical, true);
+                double highMin = high - along(items.get(i + 1), vertical, true);
+                if (lowMin <= highMin) {
+                    low = lowMin;
+                    high = highMin;
+                }
+                double at = p * length - BAR / 2;
+                at = at < low ? low : (at > high ? high : at);
+                end = vertical ? snapPositionY(at) : snapPositionX(at);
+                Region bar = bars.get(i);
+                if (vertical) {
+                    bar.resizeRelocate(in.getLeft(), in.getTop() + end, w, BAR);
+                } else {
+                    bar.resizeRelocate(in.getLeft() + end, in.getTop(), BAR, h);
+                }
+            }
+            double size = Math.max(0, end - start);
+            if (vertical) {
+                layoutInArea(items.get(i), in.getLeft(), in.getTop() + start, w, size, 0, HPos.CENTER, VPos.CENTER);
+            } else {
+                layoutInArea(items.get(i), in.getLeft() + start, in.getTop(), size, h, 0, HPos.CENTER, VPos.CENTER);
+            }
+            start = end + BAR;
+        }
+    }
+
+    private double sum(boolean vertical, boolean min) {
+        double total = bars.size() * BAR;
+        for (int i = 0; i < items.size(); i++) {
+            total += along(items.get(i), vertical, min);
+        }
+        return total;
+    }
+
+    private double widest(boolean vertical, boolean min) {
+        double most = 0;
+        for (int i = 0; i < items.size(); i++) {
+            most = Math.max(most, along(items.get(i), vertical, min));
+        }
+        return most;
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        return in.getLeft() + (vertical ? widest(false, false) : sum(false, false)) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        return in.getTop() + (vertical ? sum(true, false) : widest(true, false)) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        return in.getLeft() + (vertical ? widest(false, true) : sum(false, true)) + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        return in.getTop() + (vertical ? sum(true, true) : widest(true, true)) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    // ------------------------------------------------------------------ API
+
+    /// Returns the nodes this split pane shows, in order.
+    public ObservableList<Node> getItems() {
+        return items;
+    }
+
+    /// Returns the dividers, one fewer than the items; the list cannot be
+    /// changed.
+    public ObservableList<Divider> getDividers() {
+        return unmodifiableDividers;
+    }
+
+    /// Sets the position of one divider. A position for a divider that
+    /// does not exist yet is kept for when it does.
+    public void setDividerPosition(int dividerIndex, double position) {
+        if (dividerIndex >= 0 && dividerIndex < dividers.size()) {
+            dividers.get(dividerIndex).setPosition(position);
+        } else if (dividerIndex >= 0) {
+            pending.put(Integer.valueOf(dividerIndex), Double.valueOf(position));
+        }
+    }
+
+    /// Sets the positions of the dividers, in order.
+    public void setDividerPositions(double... positions) {
+        if (positions == null) {
+            return;
+        }
+        for (int i = 0; i < positions.length; i++) {
+            setDividerPosition(i, positions[i]);
+        }
+    }
+
+    /// Returns the positions of the dividers, in order.
+    public double[] getDividerPositions() {
+        double[] positions = new double[dividers.size()];
+        for (int i = 0; i < positions.length; i++) {
+            positions[i] = dividers.get(i).getPosition();
+        }
+        return positions;
+    }
+
+    /// Returns whether the items are side by side or stacked.
+    public final Orientation getOrientation() {
+        Orientation o = orientation.get();
+        return o == null ? Orientation.HORIZONTAL : o;
+    }
+
+    /// Sets whether the items are side by side (horizontal) or stacked.
+    public final void setOrientation(Orientation value) {
+        orientation.set(value);
+    }
+
+    /// Whether the items are side by side or stacked.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+
+    /// The boundary between two items of a split pane.
+    public static class Divider {
+
+        private final DoubleProperty position = new SimpleDoubleProperty(this, "position", 0.5);
+
+        /// Creates a divider in the middle.
+        public Divider() {
+        }
+
+        /// Sets where the divider is, as a fraction of the pane's length.
+        public final void setPosition(double value) {
+            position.set(value);
+        }
+
+        /// Returns where the divider is, as a fraction of the pane's
+        /// length.
+        public final double getPosition() {
+            return position.get();
+        }
+
+        /// Where the divider is, as a fraction of the pane's length.
+        public final DoubleProperty positionProperty() {
+            return position;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Tab.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Tab.java
new file mode 100644
index 00000000000..d56ef979899
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Tab.java
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.HashSet;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.css.PseudoClass;
+import javafx.css.Styleable;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.Node;
+
+/// One page of a [TabPane]: a header with text and an optional graphic,
+/// and the content shown while the tab is selected.
+///
+/// A tab is not a node. Its events are delivered to the tab alone:
+/// `SELECTION_CHANGED_EVENT` when it becomes or stops being the selected
+/// tab, `TAB_CLOSE_REQUEST_EVENT` when the user asks to close it (a
+/// handler that consumes it keeps the tab open) and `CLOSED_EVENT` after
+/// it was closed. The context menu and tooltip of a JavaFX tab are not
+/// part of this layer.
+public class Tab implements EventTarget, Styleable {
+
+    /// Fired when the tab becomes, or stops being, the selected tab.
+    public static final EventType<Event> SELECTION_CHANGED_EVENT = new EventType<Event>(Event.ANY,
+            "SELECTION_CHANGED_EVENT");
+
+    /// Fired after the tab was closed.
+    public static final EventType<Event> CLOSED_EVENT = new EventType<Event>(Event.ANY, "TAB_CLOSED");
+
+    /// Fired when the user asks to close the tab; consuming it keeps the
+    /// tab open.
+    public static final EventType<Event> TAB_CLOSE_REQUEST_EVENT = new EventType<Event>(Event.ANY,
+            "TAB_CLOSE_REQUEST_EVENT");
+
+    private static final PseudoClass SELECTED = PseudoClass.getPseudoClass("selected");
+    private static final PseudoClass DISABLED = PseudoClass.getPseudoClass("disabled");
+
+    private final EventHandlerManager events = new EventHandlerManager(this);
+    private final StringProperty id = new SimpleStringProperty(this, "id");
+    private final StringProperty style = new SimpleStringProperty(this, "style", "");
+    private final ObservableList<String> styleClass = FXCollections.observableArrayList();
+    private final ObservableSet<PseudoClass> pseudoClasses = FXCollections.observableSet(
+            new HashSet<PseudoClass>());
+    private final ReadOnlyBooleanWrapper selected = new ReadOnlyBooleanWrapper(this, "selected", false);
+    private final ReadOnlyObjectWrapper<TabPane> tabPane = new ReadOnlyObjectWrapper<TabPane>(this, "tabPane");
+    private final StringProperty text = new SimpleStringProperty(this, "text");
+    private final ObjectProperty<Node> graphic = new SimpleObjectProperty<Node>(this, "graphic");
+    private final ObjectProperty<Node> content = new SimpleObjectProperty<Node>(this, "content");
+    private final ObjectProperty<Tooltip> tooltip = new SimpleObjectProperty<Tooltip>(this, "tooltip");
+    private final BooleanProperty closable = new SimpleBooleanProperty(this, "closable", true);
+    private final BooleanProperty disable = new SimpleBooleanProperty(this, "disable", false);
+    private final ReadOnlyBooleanWrapper disabled = new ReadOnlyBooleanWrapper(this, "disabled", false);
+    private final ObjectProperty<EventHandler<Event>> onSelectionChanged = slot(SELECTION_CHANGED_EVENT,
+            "onSelectionChanged");
+    private final ObjectProperty<EventHandler<Event>> onClosed = slot(CLOSED_EVENT, "onClosed");
+    private final ObjectProperty<EventHandler<Event>> onCloseRequest = slot(TAB_CLOSE_REQUEST_EVENT,
+            "onCloseRequest");
+    private Object userData;
+    private ObservableMap<Object, Object> properties;
+
+    /// Creates a tab with no text.
+    public Tab() {
+        this(null);
+    }
+
+    /// Creates a tab with text.
+    public Tab(String text) {
+        this(text, null);
+    }
+
+    /// Creates a tab with text and content.
+    public Tab(String text, Node content) {
+        styleClass.add("tab");
+        this.text.set(text);
+        this.content.set(content);
+        ChangeListener<Object> changed = new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                updateDisabled();
+                TabPane pane = getTabPane();
+                if (pane != null) {
+                    pane.tabChanged(Tab.this);
+                }
+            }
+        };
+        this.text.addListener(changed);
+        this.graphic.addListener(changed);
+        this.content.addListener(changed);
+        this.closable.addListener(changed);
+        this.disable.addListener(changed);
+    }
+
+    private ObjectProperty<EventHandler<Event>> slot(final EventType<Event> type, final String name) {
+        return new SimpleObjectProperty<EventHandler<Event>>(this, name) {
+            @Override
+            protected void invalidated() {
+                events.setSlot(type, name, get());
+            }
+        };
+    }
+
+    // ------------------------------------------------------- package hooks
+
+    final void setTabPane(TabPane value) {
+        tabPane.set(value);
+        updateDisabled();
+    }
+
+    final void setSelected(boolean value) {
+        if (selected.get() != value) {
+            selected.set(value);
+            if (value) {
+                pseudoClasses.add(SELECTED);
+            } else {
+                pseudoClasses.remove(SELECTED);
+            }
+            Event.fireEvent(this, new Event(this, this, SELECTION_CHANGED_EVENT));
+        }
+    }
+
+    final void updateDisabled() {
+        TabPane pane = getTabPane();
+        boolean now = isDisable() || (pane != null && pane.isDisabled());
+        if (disabled.get() != now) {
+            disabled.set(now);
+            if (now) {
+                pseudoClasses.add(DISABLED);
+            } else {
+                pseudoClasses.remove(DISABLED);
+            }
+        }
+    }
+
+    // --------------------------------------------------------------- state
+
+    /// Returns whether this is the selected tab of its tab pane.
+    public final boolean isSelected() {
+        return selected.get();
+    }
+
+    /// Whether this is the selected tab of its tab pane.
+    public final ReadOnlyBooleanProperty selectedProperty() {
+        return selected.getReadOnlyProperty();
+    }
+
+    /// Returns the tab pane this tab is in, or `null`.
+    public final TabPane getTabPane() {
+        return tabPane.get();
+    }
+
+    /// The tab pane this tab is in.
+    public final ReadOnlyObjectProperty<TabPane> tabPaneProperty() {
+        return tabPane.getReadOnlyProperty();
+    }
+
+    /// Sets the text of the header.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// Returns the text of the header.
+    public final String getText() {
+        return text.get();
+    }
+
+    /// The text of the header.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    /// Sets the node shown in the header before the text.
+    public final void setGraphic(Node value) {
+        graphic.set(value);
+    }
+
+    /// Returns the node shown in the header before the text, or `null`.
+    public final Node getGraphic() {
+        return graphic.get();
+    }
+
+    /// The node shown in the header before the text.
+    public final ObjectProperty<Node> graphicProperty() {
+        return graphic;
+    }
+
+    /// Sets the node shown while this tab is selected.
+    public final void setContent(Node value) {
+        content.set(value);
+    }
+
+    /// Returns the node shown while this tab is selected, or `null`.
+    public final Node getContent() {
+        return content.get();
+    }
+
+    /// The node shown while this tab is selected.
+    public final ObjectProperty<Node> contentProperty() {
+        return content;
+    }
+
+    /// Sets whether the user can close this tab, where the tab pane's
+    /// closing policy lets any be closed.
+    public final void setClosable(boolean value) {
+        closable.set(value);
+    }
+
+    /// Returns whether the user can close this tab.
+    public final boolean isClosable() {
+        return closable.get();
+    }
+
+    /// Whether the user can close this tab.
+    public final BooleanProperty closableProperty() {
+        return closable;
+    }
+
+    /// Sets whether this tab is disabled: it cannot be selected by the
+    /// user and its content is disabled.
+    public final void setDisable(boolean value) {
+        disable.set(value);
+    }
+
+    /// Returns whether this tab was disabled itself.
+    public final boolean isDisable() {
+        return disable.get();
+    }
+
+    /// Whether this tab was disabled itself.
+    public final BooleanProperty disableProperty() {
+        return disable;
+    }
+
+    /// Returns whether this tab or its tab pane is disabled.
+    public final boolean isDisabled() {
+        return disabled.get();
+    }
+
+    /// Whether this tab or its tab pane is disabled.
+    public final ReadOnlyBooleanProperty disabledProperty() {
+        return disabled.getReadOnlyProperty();
+    }
+
+    // -------------------------------------------------------------- events
+
+    /// Sets the handler of this tab becoming or ceasing to be selected.
+    public final void setOnSelectionChanged(EventHandler<Event> value) {
+        onSelectionChanged.set(value);
+    }
+
+    /// Returns the handler of this tab becoming or ceasing to be selected.
+    public final EventHandler<Event> getOnSelectionChanged() {
+        return onSelectionChanged.get();
+    }
+
+    /// The handler of this tab becoming or ceasing to be selected.
+    public final ObjectProperty<EventHandler<Event>> onSelectionChangedProperty() {
+        return onSelectionChanged;
+    }
+
+    /// Sets the handler of this tab having been closed.
+    public final void setOnClosed(EventHandler<Event> value) {
+        onClosed.set(value);
+    }
+
+    /// Returns the handler of this tab having been closed.
+    public final EventHandler<Event> getOnClosed() {
+        return onClosed.get();
+    }
+
+    /// The handler of this tab having been closed.
+    public final ObjectProperty<EventHandler<Event>> onClosedProperty() {
+        return onClosed;
+    }
+
+    /// Sets the handler of the user asking to close this tab.
+    public final void setOnCloseRequest(EventHandler<Event> value) {
+        onCloseRequest.set(value);
+    }
+
+    /// Returns the handler of the user asking to close this tab.
+    public final EventHandler<Event> getOnCloseRequest() {
+        return onCloseRequest.get();
+    }
+
+    /// The handler of the user asking to close this tab.
+    public final ObjectProperty<EventHandler<Event>> onCloseRequestProperty() {
+        return onCloseRequest;
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        return tail.prepend(events);
+    }
+
+    // ------------------------------------------------- styling, user data
+
+    /// Sets the id a style sheet can select this tab by.
+    public final void setId(String value) {
+        id.set(value);
+    }
+
+    /// Returns the id a style sheet can select this tab by.
+    @Override
+    public final String getId() {
+        return id.get();
+    }
+
+    /// The id a style sheet can select this tab by.
+    public final StringProperty idProperty() {
+        return id;
+    }
+
+    /// Sets the inline style of this tab.
+    public final void setStyle(String value) {
+        style.set(value);
+    }
+
+    /// Returns the inline style of this tab.
+    @Override
+    public final String getStyle() {
+        return style.get();
+    }
+
+    /// The inline style of this tab.
+    public final StringProperty styleProperty() {
+        return style;
+    }
+
+    /// Returns the style classes of this tab; `tab` to begin with.
+    @Override
+    public ObservableList<String> getStyleClass() {
+        return styleClass;
+    }
+
+    /// Returns `Tab`.
+    @Override
+    public String getTypeSelector() {
+        return "Tab";
+    }
+
+    /// Returns the tab pane this tab is in.
+    @Override
+    public Styleable getStyleableParent() {
+        return getTabPane();
+    }
+
+    /// Returns the pseudo-class states of this tab: `selected` and
+    /// `disabled`.
+    @Override
+    public final ObservableSet<PseudoClass> getPseudoClassStates() {
+        return FXCollections.unmodifiableObservableSet(pseudoClasses);
+    }
+
+    /// Attaches an object of the application's.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns the object the application attached, or `null`.
+    public Object getUserData() {
+        return userData;
+    }
+
+    /// Returns the map of properties the application attached.
+    public final ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    /// Returns whether any property was attached.
+    public boolean hasProperties() {
+        return properties != null && !properties.isEmpty();
+    }
+
+    /// Sets the tooltip of the tab; recorded, the header shows none.
+    public final void setTooltip(Tooltip value) {
+        tooltip.set(value);
+    }
+
+    /// Returns the tooltip of the tab.
+    public final Tooltip getTooltip() {
+        return tooltip.get();
+    }
+
+    /// The tooltip of the tab; recorded.
+    public final ObjectProperty<Tooltip> tooltipProperty() {
+        return tooltip;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TabPane.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TabPane.java
new file mode 100644
index 00000000000..2000bc4a331
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TabPane.java
@@ -0,0 +1,680 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.ui.Component;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.css.PseudoClass;
+import javafx.event.Event;
+import javafx.event.EventHandler;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Side;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// Pages of which one shows at a time, chosen from a strip of tab
+/// headers.
+///
+/// #### How it is built
+///
+/// There is no native component. Every tab has two regions among the
+/// children of the tab pane: a header in the strip, holding the tab's
+/// graphic, a `Label` with its text and, where the tab can be closed, a
+/// `Label` to close it; and a content region holding the tab's content
+/// node, visible only while the tab is selected. The content of every tab
+/// is therefore in the scene graph all the time, as in JavaFX, and
+/// `lookup` finds it whether it shows or not. The content region fills
+/// the pane next to the strip and sizes its content to itself.
+///
+/// Pressing a header selects its tab. Pressing the close label fires
+/// `Tab.TAB_CLOSE_REQUEST_EVENT` at the tab and, unless a handler
+/// consumed it, removes the tab and fires `Tab.CLOSED_EVENT`.
+///
+/// #### Differences from JavaFX
+///
+/// - On the left and right sides the headers are stacked upright, not
+///   rotated.
+/// - Headers that do not fit the strip are cut off; there is no menu of
+///   hidden tabs, and tabs cannot be dragged to reorder them.
+/// - `rotateGraphic` is recorded: headers on a left or right side are not
+///   rotated, so their graphics have nothing to turn with.
+/// - The tab size limits and the drag policy are not
+///   part of this layer.
+///
+/// The pseudo-classes `top`, `right`, `bottom` and `left` follow the
+/// side.
+public class TabPane extends Control {
+
+    /// When the user can close tabs.
+    public enum TabClosingPolicy {
+        /// Only the selected tab shows a way to close it.
+        SELECTED_TAB,
+        /// Every closable tab shows a way to close it.
+        ALL_TABS,
+        /// No tab can be closed by the user.
+        UNAVAILABLE
+    }
+
+    /// The style class of a tab pane drawn without a frame.
+    public static final String STYLE_CLASS_FLOATING = "floating";
+
+    private static final int MODEL = Dirty.USER;
+    private static final int SIDE = Dirty.USER << 1;
+    private static final int HEADERS = Dirty.USER << 2;
+    private static final double PAD = 6;
+    private static final double GAP = 4;
+    private static final Color STRIP = Color.gray(0.88);
+    private static final Color TAB = Color.gray(0.8);
+    private static final Color CHOSEN = Color.WHITE;
+    private static final PseudoClass SELECTED = PseudoClass.getPseudoClass("selected");
+    private static final PseudoClass[] SIDES = {PseudoClass.getPseudoClass("top"),
+        PseudoClass.getPseudoClass("right"), PseudoClass.getPseudoClass("bottom"),
+        PseudoClass.getPseudoClass("left")};
+
+    private final ObservableList<Tab> tabs = FXCollections.observableArrayList();
+    private final ObjectProperty<SingleSelectionModel<Tab>> selectionModel =
+            new FxObject<SingleSelectionModel<Tab>>(this, "selectionModel", null, MODEL);
+    private final javafx.beans.property.BooleanProperty rotateGraphic =
+            new javafx.beans.property.SimpleBooleanProperty(this, "rotateGraphic", false);
+    private final ObjectProperty<Side> side = new FxObject<Side>(this, "side", Side.TOP, SIDE | Dirty.LAYOUT);
+    private final ObjectProperty<TabClosingPolicy> tabClosingPolicy = new FxObject<TabClosingPolicy>(this,
+            "tabClosingPolicy", TabClosingPolicy.SELECTED_TAB, HEADERS);
+    private final ArrayList<Page> pages = new ArrayList<Page>();
+    private final ChangeListener<Tab> selectionListener = new ChangeListener<Tab>() {
+        @Override
+        public void changed(ObservableValue<? extends Tab> observable, Tab oldValue, Tab newValue) {
+            selectionChanged();
+        }
+    };
+    private SingleSelectionModel<Tab> watched;
+    private double stripX;
+    private double stripY;
+    private double stripWidth;
+    private double stripHeight;
+
+    /// Creates a tab pane without tabs.
+    public TabPane() {
+        this((Tab[]) null);
+    }
+
+    /// Creates a tab pane with tabs.
+    public TabPane(Tab... tabs) {
+        getStyleClass().add("tab-pane");
+        pseudoClassStateChanged(SIDES[0], true);
+        this.tabs.addListener(new ListChangeListener<Tab>() {
+            @Override
+            public void onChanged(Change<? extends Tab> change) {
+                tabsChanged(change);
+            }
+        });
+        disabledProperty().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue,
+                    Boolean newValue) {
+                for (int i = 0; i < TabPane.this.tabs.size(); i++) {
+                    TabPane.this.tabs.get(i).updateDisabled();
+                }
+            }
+        });
+        selectionModel.set(new TabSelectionModel(this.tabs));
+        if (tabs != null) {
+            this.tabs.addAll(tabs);
+        }
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & MODEL) != 0) {
+            if (watched != null) {
+                watched.selectedItemProperty().removeListener(selectionListener);
+            }
+            watched = selectionModel.get();
+            if (watched != null) {
+                watched.selectedItemProperty().addListener(selectionListener);
+            }
+            selectionChanged();
+        }
+        if ((what & SIDE) != 0) {
+            Side s = getSide();
+            pseudoClassStateChanged(SIDES[0], s == Side.TOP);
+            pseudoClassStateChanged(SIDES[1], s == Side.RIGHT);
+            pseudoClassStateChanged(SIDES[2], s == Side.BOTTOM);
+            pseudoClassStateChanged(SIDES[3], s == Side.LEFT);
+        }
+        if ((what & HEADERS) != 0) {
+            for (int i = 0; i < pages.size(); i++) {
+                pages.get(i).refresh();
+            }
+            requestLayout();
+        }
+        super.cn1Invalidated(what);
+    }
+
+    // ---------------------------------------------------------------- tabs
+
+    private Page pageOf(Tab tab) {
+        for (int i = 0; i < pages.size(); i++) {
+            if (pages.get(i).tab == tab) {
+                return pages.get(i);
+            }
+        }
+        return null;
+    }
+
+    private void tabsChanged(ListChangeListener.Change<? extends Tab> change) {
+        SingleSelectionModel<Tab> model = getSelectionModel();
+        Tab chosen = model == null ? null : model.getSelectedItem();
+        int chosenIndex = model == null ? -1 : model.getSelectedIndex();
+        while (change.next()) {
+            List<? extends Tab> removed = change.getRemoved();
+            for (int i = 0; i < removed.size(); i++) {
+                Tab t = removed.get(i);
+                if (t != null && !tabs.contains(t) && t.getTabPane() == this) {
+                    t.setSelected(false);
+                    t.setTabPane(null);
+                }
+            }
+            List<? extends Tab> added = change.getAddedSubList();
+            for (int i = 0; i < added.size(); i++) {
+                Tab t = added.get(i);
+                if (t == null) {
+                    throw new NullPointerException("A tab must not be null");
+                }
+                t.setTabPane(this);
+            }
+        }
+        ArrayList<Page> fresh = new ArrayList<Page>();
+        ArrayList<Node> children = new ArrayList<Node>();
+        for (int i = 0; i < tabs.size(); i++) {
+            Page page = pageOf(tabs.get(i));
+            if (page == null) {
+                page = new Page(tabs.get(i));
+            }
+            fresh.add(page);
+            children.add(page.body);
+        }
+        for (int i = 0; i < fresh.size(); i++) {
+            children.add(fresh.get(i).header);
+        }
+        pages.clear();
+        pages.addAll(fresh);
+        cn1Children().setAll(children);
+        if (model != null) {
+            if (tabs.isEmpty()) {
+                model.clearSelection();
+            } else if (chosen != null && tabs.contains(chosen)) {
+                model.select(tabs.indexOf(chosen));
+            } else {
+                // The tab that takes the place of a removed selection, or
+                // the first tab of a pane that had none.
+                int next = Math.max(0, Math.min(chosenIndex, tabs.size() - 1));
+                model.clearSelection();
+                model.select(next);
+            }
+        }
+        selectionChanged();
+        requestLayout();
+    }
+
+    private void selectionChanged() {
+        SingleSelectionModel<Tab> model = getSelectionModel();
+        Tab chosen = model == null ? null : model.getSelectedItem();
+        for (int i = 0; i < tabs.size(); i++) {
+            Tab t = tabs.get(i);
+            if (t != chosen) {
+                t.setSelected(false);
+            }
+        }
+        if (chosen != null && tabs.contains(chosen)) {
+            chosen.setSelected(true);
+        }
+        for (int i = 0; i < pages.size(); i++) {
+            pages.get(i).refresh();
+        }
+        requestLayout();
+    }
+
+    /// A property of a tab of this pane changed.
+    final void tabChanged(Tab tab) {
+        Page page = pageOf(tab);
+        if (page != null) {
+            page.refresh();
+            requestLayout();
+        }
+    }
+
+    private void requestClose(Tab tab) {
+        Event request = new Event(tab, tab, Tab.TAB_CLOSE_REQUEST_EVENT);
+        Event.fireEvent(tab, request);
+        if (!request.isConsumed() && tabs.remove(tab)) {
+            Event.fireEvent(tab, new Event(tab, tab, Tab.CLOSED_EVENT));
+        }
+    }
+
+    // -------------------------------------------------------------- layout
+
+    private boolean upright() {
+        Side s = getSide();
+        return s == Side.LEFT || s == Side.RIGHT;
+    }
+
+    private double stripThickness() {
+        boolean upright = upright();
+        double most = 0;
+        for (int i = 0; i < pages.size(); i++) {
+            Region header = pages.get(i).header;
+            most = Math.max(most, upright ? header.prefWidth(-1) : header.prefHeight(-1));
+        }
+        return snapSizeY(most);
+    }
+
+    private double stripLength() {
+        boolean upright = upright();
+        double total = 0;
+        for (int i = 0; i < pages.size(); i++) {
+            Region header = pages.get(i).header;
+            total += upright ? header.prefHeight(-1) : header.prefWidth(-1);
+        }
+        return total;
+    }
+
+    private double bodySize(boolean width, boolean min) {
+        double most = 0;
+        for (int i = 0; i < pages.size(); i++) {
+            Region body = pages.get(i).body;
+            double size;
+            if (min) {
+                size = width ? body.minWidth(-1) : body.minHeight(-1);
+            } else {
+                size = width ? body.prefWidth(-1) : body.prefHeight(-1);
+            }
+            most = Math.max(most, size);
+        }
+        return most;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double w = Math.max(0, getWidth() - in.getLeft() - in.getRight());
+        double h = Math.max(0, getHeight() - in.getTop() - in.getBottom());
+        Side s = getSide();
+        boolean upright = upright();
+        double thick = Math.min(stripThickness(), upright ? w : h);
+        double bodyX = x;
+        double bodyY = y;
+        double bodyW = w;
+        double bodyH = h;
+        if (upright) {
+            stripX = s == Side.LEFT ? x : x + w - thick;
+            stripY = y;
+            stripWidth = thick;
+            stripHeight = h;
+            bodyW = w - thick;
+            bodyX = s == Side.LEFT ? x + thick : x;
+        } else {
+            stripX = x;
+            stripY = s == Side.BOTTOM ? y + h - thick : y;
+            stripWidth = w;
+            stripHeight = thick;
+            bodyH = h - thick;
+            bodyY = s == Side.BOTTOM ? y : y + thick;
+        }
+        double at = 0;
+        for (int i = 0; i < pages.size(); i++) {
+            Page page = pages.get(i);
+            if (upright) {
+                double length = snapSizeY(page.header.prefHeight(-1));
+                page.header.resizeRelocate(stripX, stripY + at, thick, length);
+                at += length;
+            } else {
+                double length = snapSizeX(page.header.prefWidth(-1));
+                page.header.resizeRelocate(stripX + at, stripY, length, thick);
+                at += length;
+            }
+            page.body.resizeRelocate(bodyX, bodyY, bodyW, bodyH);
+        }
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        super.cn1Paint(renderer);
+        if (!pages.isEmpty()) {
+            renderer.fillRect(stripX, stripY, stripWidth, stripHeight, STRIP);
+        }
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        double inner = upright() ? stripThickness() + bodySize(true, false)
+                : Math.max(stripLength(), bodySize(true, false));
+        return in.getLeft() + inner + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        double inner = upright() ? Math.max(stripLength(), bodySize(false, false))
+                : stripThickness() + bodySize(false, false);
+        return in.getTop() + inner + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        double inner = upright() ? stripThickness() + bodySize(true, true) : bodySize(true, true);
+        return in.getLeft() + inner + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        double inner = upright() ? bodySize(false, true) : stripThickness() + bodySize(false, true);
+        return in.getTop() + inner + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    // ------------------------------------------------------------- the API
+
+    /// Returns the tabs, in the order of their headers.
+    public final ObservableList<Tab> getTabs() {
+        return tabs;
+    }
+
+    /// Sets the selection model.
+    public final void setSelectionModel(SingleSelectionModel<Tab> value) {
+        selectionModel.set(value);
+    }
+
+    /// Returns the selection model: which tab shows.
+    public final SingleSelectionModel<Tab> getSelectionModel() {
+        return selectionModel.get();
+    }
+
+    /// The selection model.
+    public final ObjectProperty<SingleSelectionModel<Tab>> selectionModelProperty() {
+        return selectionModel;
+    }
+
+    /// Sets the side the headers are on.
+    public final void setSide(Side value) {
+        side.set(value);
+    }
+
+    /// Returns the side the headers are on.
+    public final Side getSide() {
+        Side s = side.get();
+        return s == null ? Side.TOP : s;
+    }
+
+    /// The side the headers are on.
+    public final ObjectProperty<Side> sideProperty() {
+        return side;
+    }
+
+    /// Sets when the user can close tabs.
+    public final void setTabClosingPolicy(TabClosingPolicy value) {
+        tabClosingPolicy.set(value);
+    }
+
+    /// Returns when the user can close tabs.
+    public final TabClosingPolicy getTabClosingPolicy() {
+        TabClosingPolicy p = tabClosingPolicy.get();
+        return p == null ? TabClosingPolicy.SELECTED_TAB : p;
+    }
+
+    /// When the user can close tabs.
+    public final ObjectProperty<TabClosingPolicy> tabClosingPolicyProperty() {
+        return tabClosingPolicy;
+    }
+
+    // ------------------------------------------------------------- helpers
+
+    /// The selection of a tab pane: one of its tabs.
+    private static final class TabSelectionModel extends SingleSelectionModel<Tab> {
+
+        private final ObservableList<Tab> tabs;
+
+        TabSelectionModel(ObservableList<Tab> tabs) {
+            this.tabs = tabs;
+        }
+
+        @Override
+        protected Tab getModelItem(int index) {
+            return index < 0 || index >= tabs.size() ? null : tabs.get(index);
+        }
+
+        @Override
+        protected int getItemCount() {
+            return tabs.size();
+        }
+    }
+
+    /// The two regions of one tab: its header and its content region.
+    private final class Page {
+
+        final Tab tab;
+        final Header header;
+        final Body body;
+
+        Page(Tab tab) {
+            this.tab = tab;
+            this.header = new Header();
+            this.body = new Body();
+            final Tab subject = tab;
+            header.addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+                @Override
+                public void handle(MouseEvent event) {
+                    SingleSelectionModel<Tab> model = getSelectionModel();
+                    if (model != null && !subject.isDisabled()) {
+                        model.select(subject);
+                    }
+                }
+            });
+            header.close.addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+                @Override
+                public void handle(MouseEvent event) {
+                    event.consume();
+                }
+            });
+            header.close.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {
+                @Override
+                public void handle(MouseEvent event) {
+                    event.consume();
+                    if (!subject.isDisabled()) {
+                        requestClose(subject);
+                    }
+                }
+            });
+            refresh();
+        }
+
+        void refresh() {
+            boolean chosen = tab.isSelected();
+            TabClosingPolicy policy = getTabClosingPolicy();
+            boolean closes = tab.isClosable() && policy != TabClosingPolicy.UNAVAILABLE
+                    && (policy == TabClosingPolicy.ALL_TABS || chosen);
+            header.show(tab.getGraphic(), tab.getText(), closes, chosen);
+            header.setDisable(tab.isDisable());
+            body.show(tab.getContent());
+            body.setVisible(chosen);
+            body.setDisable(tab.isDisable());
+        }
+    }
+
+    /// The header of a tab in the strip.
+    private static final class Header extends Region {
+
+        private final Label title = new Label();
+        private final Label close = new Label("x");
+
+        Header() {
+            getStyleClass().add("tab");
+            close.getStyleClass().add("tab-close-button");
+        }
+
+        void show(Node graphic, String text, boolean closes, boolean chosen) {
+            title.setText(text == null ? "" : text);
+            ArrayList<Node> wanted = new ArrayList<Node>();
+            if (graphic != null) {
+                wanted.add(graphic);
+            }
+            wanted.add(title);
+            if (closes) {
+                wanted.add(close);
+            }
+            if (!wanted.equals(cn1Children())) {
+                cn1Children().setAll(wanted);
+            }
+            pseudoClassStateChanged(SELECTED, chosen);
+            setBackground(new Background(new BackgroundFill(chosen ? CHOSEN : TAB, CornerRadii.EMPTY,
+                    new Insets(0, 1, 0, 0))));
+        }
+
+        private static double width(Node n) {
+            return n.isResizable() ? n.prefWidth(-1) : n.getLayoutBounds().getWidth();
+        }
+
+        private static double height(Node n) {
+            return n.isResizable() ? n.prefHeight(-1) : n.getLayoutBounds().getHeight();
+        }
+
+        @Override
+        protected void layoutChildren() {
+            List<Node> children = getChildrenUnmodifiable();
+            double x = PAD;
+            for (int i = 0; i < children.size(); i++) {
+                Node n = children.get(i);
+                double w = width(n);
+                layoutInArea(n, x, 0, w, getHeight(), 0, HPos.LEFT, VPos.CENTER);
+                x += w + GAP;
+            }
+        }
+
+        @Override
+        protected double computePrefWidth(double height) {
+            List<Node> children = getChildrenUnmodifiable();
+            double total = 2 * PAD;
+            for (int i = 0; i < children.size(); i++) {
+                total += width(children.get(i)) + (i > 0 ? GAP : 0);
+            }
+            return total;
+        }
+
+        @Override
+        protected double computePrefHeight(double width) {
+            List<Node> children = getChildrenUnmodifiable();
+            double most = 0;
+            for (int i = 0; i < children.size(); i++) {
+                most = Math.max(most, height(children.get(i)));
+            }
+            return most + PAD;
+        }
+    }
+
+    /// The region that holds the content of one tab.
+    private static final class Body extends Region {
+
+        void show(Node node) {
+            if (node == null) {
+                if (!cn1Children().isEmpty()) {
+                    cn1Children().clear();
+                }
+            } else if (cn1Children().size() != 1 || cn1Children().get(0) != node) {
+                cn1Children().setAll(node);
+            }
+        }
+
+        @Override
+        protected void layoutChildren() {
+            List<Node> children = getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                layoutInArea(children.get(i), 0, 0, getWidth(), getHeight(), 0, HPos.CENTER, VPos.CENTER);
+            }
+        }
+
+        @Override
+        protected double computeMinWidth(double height) {
+            List<Node> children = getChildrenUnmodifiable();
+            return children.isEmpty() ? 0 : children.get(0).minWidth(-1);
+        }
+
+        @Override
+        protected double computeMinHeight(double width) {
+            List<Node> children = getChildrenUnmodifiable();
+            return children.isEmpty() ? 0 : children.get(0).minHeight(-1);
+        }
+    }
+
+    /// Sets whether the graphic of a header turns with a side header;
+    /// recorded, since side headers are upright here.
+    public final void setRotateGraphic(boolean value) {
+        rotateGraphic.set(value);
+    }
+
+    /// Returns whether the graphic of a header turns with a side header.
+    public final boolean isRotateGraphic() {
+        return rotateGraphic.get();
+    }
+
+    /// Whether the graphic of a header turns with a side header; recorded.
+    public final javafx.beans.property.BooleanProperty rotateGraphicProperty() {
+        return rotateGraphic;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TableCell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TableCell.java
new file mode 100644
index 00000000000..a5a3f99991d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TableCell.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ObservableList;
+import javafx.event.Event;
+
+/// A cell of a [TableView]: the value of one column for one row.
+///
+/// While it shows a row the cell listens to the observable value the
+/// column's cell value factory answered, and shows the new value when it
+/// changes.
+///
+/// There are no row nodes in this layer, so `tableRow` is absent.
+public class TableCell<S, T> extends IndexedCell<T> {
+
+    private final ReadOnlyObjectWrapper<TableColumn<S, T>> tableColumn = new ReadOnlyObjectWrapper<TableColumn<S, T>>(
+            this, "tableColumn");
+    private final ReadOnlyObjectWrapper<TableView<S>> tableView = new ReadOnlyObjectWrapper<TableView<S>>(this,
+            "tableView");
+    private final ChangeListener<T> valueListener = new ChangeListener<T>() {
+        @Override
+        public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+            if (observable == observed) {
+                updateItem(newValue, false);
+            }
+        }
+    };
+    private ObservableValue<T> observed;
+    private boolean stale = true;
+
+    /// Creates a cell that belongs to no table yet.
+    public TableCell() {
+        getStyleClass().add("table-cell");
+    }
+
+    /// The column this cell is in.
+    public final ReadOnlyObjectProperty<TableColumn<S, T>> tableColumnProperty() {
+        return tableColumn.getReadOnlyProperty();
+    }
+
+    /// Returns the column this cell is in.
+    public final TableColumn<S, T> getTableColumn() {
+        return tableColumn.get();
+    }
+
+    /// The table this cell is in.
+    public final ReadOnlyObjectProperty<TableView<S>> tableViewProperty() {
+        return tableView.getReadOnlyProperty();
+    }
+
+    /// Returns the table this cell is in.
+    public final TableView<S> getTableView() {
+        return tableView.get();
+    }
+
+    /// Tells the cell which table it is in; the table does.
+    public final void updateTableView(TableView<S> tv) {
+        tableView.set(tv);
+    }
+
+    /// Tells the cell which column it is in; the table does.
+    public final void updateTableColumn(TableColumn<S, T> col) {
+        tableColumn.set(col);
+    }
+
+    /// Makes the next update show the value again even if it is the same.
+    final void markStale() {
+        stale = true;
+    }
+
+    private void observe(ObservableValue<T> value) {
+        if (observed == value) {
+            return;
+        }
+        if (observed != null) {
+            observed.removeListener(valueListener);
+        }
+        observed = value;
+        if (value != null) {
+            value.addListener(valueListener);
+        }
+    }
+
+    private TablePosition<S, T> position() {
+        return new TablePosition<S, T>(getTableView(), getIndex(), getTableColumn());
+    }
+
+    /// Starts editing this cell, when the table, the column and the cell
+    /// are all editable, and tells the column.
+    @Override
+    public void startEdit() {
+        TableView<S> table = getTableView();
+        TableColumn<S, T> column = getTableColumn();
+        if (table == null || column == null || !table.isEditable() || !column.isEditable()) {
+            return;
+        }
+        super.startEdit();
+        if (!isEditing()) {
+            return;
+        }
+        TablePosition<S, T> at = position();
+        table.editing(at);
+        Event.fireEvent(column, new TableColumn.CellEditEvent<S, T>(table, at, TableColumn.<S, T>editStartEvent(),
+                null));
+    }
+
+    /// Ends the edit with a value: the column is told, which is where the
+    /// value is stored, and the cell then shows it.
+    @Override
+    public void commitEdit(T newValue) {
+        if (!isEditing()) {
+            return;
+        }
+        TableView<S> table = getTableView();
+        TableColumn<S, T> column = getTableColumn();
+        TablePosition<S, T> at = position();
+        super.commitEdit(newValue);
+        if (table != null) {
+            table.editing(null);
+        }
+        if (table != null && column != null) {
+            Event.fireEvent(column, new TableColumn.CellEditEvent<S, T>(table, at,
+                    TableColumn.<S, T>editCommitEvent(), newValue));
+        }
+        updateItem(newValue, false);
+    }
+
+    /// Ends the edit without a value and tells the column.
+    @Override
+    public void cancelEdit() {
+        if (!isEditing()) {
+            return;
+        }
+        TableView<S> table = getTableView();
+        TableColumn<S, T> column = getTableColumn();
+        TablePosition<S, T> at = position();
+        super.cancelEdit();
+        if (table != null) {
+            table.editing(null);
+        }
+        if (table != null && column != null) {
+            Event.fireEvent(column, new TableColumn.CellEditEvent<S, T>(table, at,
+                    TableColumn.<S, T>editCancelEvent(), null));
+        }
+    }
+
+    @Override
+    void indexChanged(int oldIndex, int newIndex) {
+        if (isEditing() && oldIndex != newIndex) {
+            // The cell is given another row: what was typed is dropped.
+            cancelEdit();
+        }
+        TableView<S> table = getTableView();
+        TableColumn<S, T> column = getTableColumn();
+        ObservableList<S> items = table == null ? null : table.getItems();
+        boolean valid = column != null && items != null && newIndex >= 0 && newIndex < items.size();
+        if (valid) {
+            ObservableValue<T> source = column.getCellObservableValue(newIndex);
+            boolean moved = observed != source;
+            observe(source);
+            T value = source == null ? null : source.getValue();
+            if (stale || moved || isEmpty() || oldIndex != newIndex || isItemChanged(getItem(), value)) {
+                updateItem(value, false);
+            }
+        } else {
+            observe(null);
+            if (stale || !isEmpty()) {
+                updateItem(null, true);
+            }
+        }
+        stale = false;
+        TableView.TableViewSelectionModel<S> model = table == null ? null : table.getSelectionModel();
+        updateSelected(valid && model != null && model.isSelected(newIndex));
+    }
+
+    @Override
+    boolean striped() {
+        return getIndex() > 0 && (getIndex() & 1) != 0;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TableColumn.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TableColumn.java
new file mode 100644
index 00000000000..6bd43daaf81
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TableColumn.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ObservableValue;
+import javafx.beans.value.WritableValue;
+import javafx.collections.ObservableList;
+import javafx.css.Styleable;
+import javafx.event.Event;
+import javafx.event.EventHandler;
+import javafx.event.EventType;
+import javafx.scene.Node;
+import javafx.util.Callback;
+
+/// A column of a [TableView]: `S` is the type of the table's items and
+/// `T` the type of the value this column shows for one.
+///
+/// The cell value factory answers, for an item, the observable value the
+/// cell shows; the cell follows that value while it shows the row.
+/// `PropertyValueFactory` is not part of this layer because it reads
+/// properties by reflection, which a device build does not have: write
+/// the callback out, `f -> f.getValue().nameProperty()`.
+///
+/// A table is sorted by the columns of its sort order, each in the
+/// direction of its sort type and by its comparator. A cell that was
+/// edited reports through the edit events of its column; until the
+/// application sets a handler of its own, a committed value is written
+/// to the observable value of the cell when that is writable.
+///
+/// Nested columns and `sortNode` are not part of this layer.
+public class TableColumn<S, T> extends TableColumnBase<S, T> {
+
+    /// Creates the cell a column without a cell factory uses: it shows
+    /// the value's `toString()`, or the value itself when it is a node.
+    public static final Callback<TableColumn<?, ?>, TableCell<?, ?>> DEFAULT_CELL_FACTORY =
+            new Callback<TableColumn<?, ?>, TableCell<?, ?>>() {
+                @Override
+                public TableCell<?, ?> call(TableColumn<?, ?> column) {
+                    return new DefaultCell<Object, Object>();
+                }
+            };
+
+    private static final EventType<Event> EDIT_ANY_EVENT = new EventType<Event>(Event.ANY, "TABLE_COLUMN_EDIT");
+    private static final EventType<Event> EDIT_START_EVENT = new EventType<Event>(EDIT_ANY_EVENT, "EDIT_START");
+    private static final EventType<Event> EDIT_CANCEL_EVENT = new EventType<Event>(EDIT_ANY_EVENT, "EDIT_CANCEL");
+    private static final EventType<Event> EDIT_COMMIT_EVENT = new EventType<Event>(EDIT_ANY_EVENT, "EDIT_COMMIT");
+
+    private final ObjectProperty<SortType> sortType = new SimpleObjectProperty<SortType>(this, "sortType",
+            SortType.ASCENDING);
+    private final ReadOnlyObjectWrapper<TableView<S>> tableView = new ReadOnlyObjectWrapper<TableView<S>>(this,
+            "tableView");
+    private final ObjectProperty<Callback<CellDataFeatures<S, T>, ObservableValue<T>>> cellValueFactory =
+            new SimpleObjectProperty<Callback<CellDataFeatures<S, T>, ObservableValue<T>>>(this, "cellValueFactory");
+    private final ObjectProperty<Callback<TableColumn<S, T>, TableCell<S, T>>> cellFactory =
+            new SimpleObjectProperty<Callback<TableColumn<S, T>, TableCell<S, T>>>(this, "cellFactory");
+
+    /// Creates a column with no header text.
+    public TableColumn() {
+        init();
+    }
+
+    /// Creates a column with a header text.
+    public TableColumn(String text) {
+        super(text);
+        init();
+    }
+
+    /// The type every edit event of a table column descends from.
+    @SuppressWarnings("unchecked")
+    public static <S, T> EventType<CellEditEvent<S, T>> editAnyEvent() {
+        return (EventType<CellEditEvent<S, T>>) (EventType<?>) EDIT_ANY_EVENT;
+    }
+
+    /// The event of a cell that began to be edited.
+    @SuppressWarnings("unchecked")
+    public static <S, T> EventType<CellEditEvent<S, T>> editStartEvent() {
+        return (EventType<CellEditEvent<S, T>>) (EventType<?>) EDIT_START_EVENT;
+    }
+
+    /// The event of an edit that ended without a value.
+    @SuppressWarnings("unchecked")
+    public static <S, T> EventType<CellEditEvent<S, T>> editCancelEvent() {
+        return (EventType<CellEditEvent<S, T>>) (EventType<?>) EDIT_CANCEL_EVENT;
+    }
+
+    /// The event of an edit that ended with a new value.
+    @SuppressWarnings("unchecked")
+    public static <S, T> EventType<CellEditEvent<S, T>> editCommitEvent() {
+        return (EventType<CellEditEvent<S, T>>) (EventType<?>) EDIT_COMMIT_EVENT;
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private void init() {
+        styleClasses().add("table-column");
+        // What a commit does until the application says otherwise.
+        setOnEditCommit(new EventHandler<CellEditEvent<S, T>>() {
+            @Override
+            public void handle(CellEditEvent<S, T> event) {
+                TablePosition<S, T> at = event.getTablePosition();
+                ObservableValue<T> value = at == null ? null : getCellObservableValue(at.getRow());
+                if (value instanceof WritableValue) {
+                    ((WritableValue<T>) value).setValue(event.getNewValue());
+                }
+            }
+        });
+        // The default factory makes cells of any type.
+        cellFactory.set((Callback) DEFAULT_CELL_FACTORY);
+    }
+
+    /// The table this column is in.
+    public final ReadOnlyObjectProperty<TableView<S>> tableViewProperty() {
+        return tableView.getReadOnlyProperty();
+    }
+
+    final void setTableView(TableView<S> value) {
+        tableView.set(value);
+    }
+
+    /// Returns the table this column is in, or `null`.
+    public final TableView<S> getTableView() {
+        return tableView.get();
+    }
+
+    /// The direction this column sorts in.
+    public final ObjectProperty<SortType> sortTypeProperty() {
+        return sortType;
+    }
+
+    /// Sets the direction this column sorts in.
+    public final void setSortType(SortType value) {
+        sortType.set(value);
+    }
+
+    /// Returns the direction this column sorts in.
+    public final SortType getSortType() {
+        return sortType.get();
+    }
+
+    /// Sets what is told that a cell of this column began to be edited.
+    public final void setOnEditStart(EventHandler<CellEditEvent<S, T>> value) {
+        events().setSlot(TableColumn.<S, T>editStartEvent(), "onEditStart", value);
+    }
+
+    /// Returns what is told that a cell began to be edited.
+    @SuppressWarnings("unchecked")
+    public final EventHandler<CellEditEvent<S, T>> getOnEditStart() {
+        return (EventHandler<CellEditEvent<S, T>>) events().getSlot(TableColumn.<S, T>editStartEvent());
+    }
+
+    /// Sets what takes the value of a committed edit. It replaces the
+    /// handler that writes the value to the cell's observable value, so
+    /// it stores the value itself.
+    public final void setOnEditCommit(EventHandler<CellEditEvent<S, T>> value) {
+        events().setSlot(TableColumn.<S, T>editCommitEvent(), "onEditCommit", value);
+    }
+
+    /// Returns what takes the value of a committed edit.
+    @SuppressWarnings("unchecked")
+    public final EventHandler<CellEditEvent<S, T>> getOnEditCommit() {
+        return (EventHandler<CellEditEvent<S, T>>) events().getSlot(TableColumn.<S, T>editCommitEvent());
+    }
+
+    /// Sets what is told that an edit ended without a value.
+    public final void setOnEditCancel(EventHandler<CellEditEvent<S, T>> value) {
+        events().setSlot(TableColumn.<S, T>editCancelEvent(), "onEditCancel", value);
+    }
+
+    /// Returns what is told that an edit ended without a value.
+    @SuppressWarnings("unchecked")
+    public final EventHandler<CellEditEvent<S, T>> getOnEditCancel() {
+        return (EventHandler<CellEditEvent<S, T>>) events().getSlot(TableColumn.<S, T>editCancelEvent());
+    }
+
+    /// Sets what answers the value of this column for an item.
+    public final void setCellValueFactory(Callback<CellDataFeatures<S, T>, ObservableValue<T>> value) {
+        cellValueFactory.set(value);
+    }
+
+    /// Returns what answers the value of this column for an item.
+    public final Callback<CellDataFeatures<S, T>, ObservableValue<T>> getCellValueFactory() {
+        return cellValueFactory.get();
+    }
+
+    /// What answers the value of this column for an item.
+    public final ObjectProperty<Callback<CellDataFeatures<S, T>, ObservableValue<T>>> cellValueFactoryProperty() {
+        return cellValueFactory;
+    }
+
+    /// Sets what creates the cells of this column.
+    public final void setCellFactory(Callback<TableColumn<S, T>, TableCell<S, T>> value) {
+        cellFactory.set(value);
+    }
+
+    /// Returns what creates the cells of this column.
+    public final Callback<TableColumn<S, T>, TableCell<S, T>> getCellFactory() {
+        return cellFactory.get();
+    }
+
+    /// What creates the cells of this column.
+    public final ObjectProperty<Callback<TableColumn<S, T>, TableCell<S, T>>> cellFactoryProperty() {
+        return cellFactory;
+    }
+
+    @Override
+    public ObservableValue<T> getCellObservableValue(int index) {
+        TableView<S> table = getTableView();
+        ObservableList<S> items = table == null ? null : table.getItems();
+        if (items == null || index < 0 || index >= items.size()) {
+            return null;
+        }
+        return getCellObservableValue(items.get(index));
+    }
+
+    @Override
+    public ObservableValue<T> getCellObservableValue(S item) {
+        Callback<CellDataFeatures<S, T>, ObservableValue<T>> factory = getCellValueFactory();
+        TableView<S> table = getTableView();
+        if (factory == null || table == null) {
+            return null;
+        }
+        return factory.call(new CellDataFeatures<S, T>(table, this, item));
+    }
+
+    @Override
+    public Styleable getStyleableParent() {
+        return getTableView();
+    }
+
+    /// What a cell value factory is asked with: the item of the row, and
+    /// the table and column the value is for.
+    public static class CellDataFeatures<S, T> {
+
+        private final TableView<S> tableView;
+        private final TableColumn<S, T> tableColumn;
+        private final S value;
+
+        /// Creates the question for one item.
+        public CellDataFeatures(TableView<S> tableView, TableColumn<S, T> tableColumn, S value) {
+            this.tableView = tableView;
+            this.tableColumn = tableColumn;
+            this.value = value;
+        }
+
+        /// Returns the item of the row.
+        public S getValue() {
+            return value;
+        }
+
+        /// Returns the column the value is for.
+        public TableColumn<S, T> getTableColumn() {
+            return tableColumn;
+        }
+
+        /// Returns the table the value is for.
+        public TableView<S> getTableView() {
+            return tableView;
+        }
+    }
+
+    /// The direction a column sorts in.
+    public enum SortType {
+        /// Smallest first.
+        ASCENDING,
+        /// Largest first.
+        DESCENDING
+    }
+
+    /// What the edit handlers of a column are told: the cell, and for a
+    /// commit the value the edit ended with.
+    public static class CellEditEvent<S, T> extends Event {
+
+        private static final long serialVersionUID = 1L;
+
+        // Transient as in JavaFX: a position names a live table, and is
+        // where the event's table is read from.
+        private final transient TablePosition<S, T> pos;
+        private final transient T newValue;
+
+        /// Creates the event of a cell.
+        public CellEditEvent(TableView<S> table, TablePosition<S, T> pos, EventType<CellEditEvent<S, T>> eventType,
+                T newValue) {
+            super(table, Event.NULL_SOURCE_TARGET, eventType);
+            if (table == null) {
+                throw new NullPointerException("TableView can not be null");
+            }
+            this.pos = pos;
+            this.newValue = newValue;
+        }
+
+        /// Returns the table.
+        public TableView<S> getTableView() {
+            return pos == null ? null : pos.getTableView();
+        }
+
+        /// Returns the column.
+        public TableColumn<S, T> getTableColumn() {
+            return pos == null ? null : pos.getTableColumn();
+        }
+
+        /// Returns the cell that was edited.
+        public TablePosition<S, T> getTablePosition() {
+            return pos;
+        }
+
+        /// Returns the value the edit ended with; `null` unless this is
+        /// a commit.
+        public T getNewValue() {
+            return newValue;
+        }
+
+        /// Returns the value the cell has now.
+        public T getOldValue() {
+            TableColumn<S, T> column = getTableColumn();
+            return pos == null || column == null ? null : column.getCellData(pos.getRow());
+        }
+
+        /// Returns the item of the row that was edited.
+        public S getRowValue() {
+            TableView<S> table = getTableView();
+            ObservableList<S> items = table == null ? null : table.getItems();
+            int row = pos == null ? -1 : pos.getRow();
+            return items == null || row < 0 || row >= items.size() ? null : items.get(row);
+        }
+    }
+
+    private static final class DefaultCell<S, T> extends TableCell<S, T> {
+        @Override
+        protected void updateItem(T item, boolean empty) {
+            super.updateItem(item, empty);
+            if (empty || item == null) {
+                setText(null);
+                setGraphic(null);
+            } else if (item instanceof Node) {
+                setText(null);
+                setGraphic((Node) item);
+            } else {
+                setText(item.toString());
+                setGraphic(null);
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TableColumnBase.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TableColumnBase.java
new file mode 100644
index 00000000000..3610359f3d5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TableColumnBase.java
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.Comparator;
+import java.util.HashSet;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.css.PseudoClass;
+import javafx.css.Styleable;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// What the columns of the table controls share: a header text, a width
+/// between a minimum and a maximum, and whether the column is shown.
+///
+/// The width of a column is its preferred width held between the minimum
+/// and the maximum; the user cannot drag a column wider, and `resizable`
+/// and `sortable` are recorded. Nested columns, sorting, the header
+/// graphic and the column context menu are not part of this layer.
+public abstract class TableColumnBase<S, T> implements EventTarget, Styleable {
+
+    /// Orders the values of a column that names no comparator of its own:
+    /// `null` first, numbers by value, values of one comparable class by
+    /// `compareTo`, anything else by its `toString()`.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static final Comparator DEFAULT_COMPARATOR = new Comparator() {
+        @Override
+        public int compare(Object a, Object b) {
+            if (a == null || b == null) {
+                return a == b ? 0 : (a == null ? -1 : 1);
+            }
+            if (a instanceof Number && b instanceof Number) {
+                return Double.compare(((Number) a).doubleValue(), ((Number) b).doubleValue());
+            }
+            if (a instanceof Comparable && a.getClass() == b.getClass()) {
+                return ((Comparable) a).compareTo(b);
+            }
+            return a.toString().compareTo(b.toString());
+        }
+    };
+
+    static final double DEFAULT_WIDTH = 80;
+    static final double DEFAULT_MIN_WIDTH = 10;
+    static final double DEFAULT_MAX_WIDTH = 5000;
+
+    private final StringProperty text = new SimpleStringProperty(this, "text", "");
+    private final BooleanProperty visible = new SimpleBooleanProperty(this, "visible", true);
+    private final BooleanProperty resizable = new SimpleBooleanProperty(this, "resizable", true);
+    private final BooleanProperty sortable = new SimpleBooleanProperty(this, "sortable", true);
+    private final BooleanProperty editable = new SimpleBooleanProperty(this, "editable", true);
+    @SuppressWarnings("unchecked")
+    private final ObjectProperty<Comparator<T>> comparator = new SimpleObjectProperty<Comparator<T>>(this,
+            "comparator", DEFAULT_COMPARATOR);
+    private final DoubleProperty minWidth = new SimpleDoubleProperty(this, "minWidth", DEFAULT_MIN_WIDTH);
+    private final DoubleProperty prefWidth = new SimpleDoubleProperty(this, "prefWidth", DEFAULT_WIDTH);
+    private final DoubleProperty maxWidth = new SimpleDoubleProperty(this, "maxWidth", DEFAULT_MAX_WIDTH);
+    private final ReadOnlyDoubleWrapper width = new ReadOnlyDoubleWrapper(this, "width", DEFAULT_WIDTH);
+    private final StringProperty id = new SimpleStringProperty(this, "id");
+    private final StringProperty style = new SimpleStringProperty(this, "style", "");
+    private final ObservableList<String> styleClass = FXCollections.observableArrayList();
+    private final EventHandlerManager events = new EventHandlerManager(this);
+    private ObservableSet<PseudoClass> pseudoClasses;
+    private ObservableMap<Object, Object> properties;
+    private Object userData;
+
+    /// Creates a column with no header text.
+    protected TableColumnBase() {
+        this("");
+    }
+
+    /// Creates a column with a header text.
+    protected TableColumnBase(String text) {
+        this.text.set(text);
+        ChangeListener<Number> sized = new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
+                doSetWidth(prefWidth.get());
+            }
+        };
+        prefWidth.addListener(sized);
+        minWidth.addListener(sized);
+        maxWidth.addListener(sized);
+    }
+
+    /// Sets the width, held between the minimum and the maximum.
+    final void doSetWidth(double value) {
+        double w = Math.min(Math.max(value, minWidth.get()), maxWidth.get());
+        width.set(w < 0 || Double.isNaN(w) ? 0 : w);
+    }
+
+    /// The header text.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    /// Sets the header text.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// Returns the header text.
+    public final String getText() {
+        return text.get();
+    }
+
+    /// Sets whether the column is shown.
+    public final void setVisible(boolean value) {
+        visible.set(value);
+    }
+
+    /// Returns whether the column is shown.
+    public final boolean isVisible() {
+        return visible.get();
+    }
+
+    /// Whether the column is shown.
+    public final BooleanProperty visibleProperty() {
+        return visible;
+    }
+
+    /// Sets the id a style sheet matches.
+    public final void setId(String value) {
+        id.set(value);
+    }
+
+    @Override
+    public final String getId() {
+        return id.get();
+    }
+
+    /// The id a style sheet matches.
+    public final StringProperty idProperty() {
+        return id;
+    }
+
+    /// Sets the inline style; recorded.
+    public final void setStyle(String value) {
+        style.set(value);
+    }
+
+    @Override
+    public final String getStyle() {
+        return style.get();
+    }
+
+    /// The inline style.
+    public final StringProperty styleProperty() {
+        return style;
+    }
+
+    @Override
+    public ObservableList<String> getStyleClass() {
+        return styleClass;
+    }
+
+    /// The style classes, for a constructor.
+    final ObservableList<String> styleClasses() {
+        return styleClass;
+    }
+
+    @Override
+    public String getTypeSelector() {
+        return "TableColumn";
+    }
+
+    @Override
+    public Styleable getStyleableParent() {
+        return null;
+    }
+
+    @Override
+    public final ObservableSet<PseudoClass> getPseudoClassStates() {
+        if (pseudoClasses == null) {
+            pseudoClasses = FXCollections.observableSet(new HashSet<PseudoClass>());
+        }
+        return pseudoClasses;
+    }
+
+    /// The width the column has.
+    public final ReadOnlyDoubleProperty widthProperty() {
+        return width.getReadOnlyProperty();
+    }
+
+    /// Returns the width the column has.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Sets the least width.
+    public final void setMinWidth(double value) {
+        minWidth.set(value);
+    }
+
+    /// Returns the least width.
+    public final double getMinWidth() {
+        return minWidth.get();
+    }
+
+    /// The least width.
+    public final DoubleProperty minWidthProperty() {
+        return minWidth;
+    }
+
+    /// Sets the width the column asks for.
+    public final void setPrefWidth(double value) {
+        prefWidth.set(value);
+    }
+
+    /// Returns the width the column asks for.
+    public final double getPrefWidth() {
+        return prefWidth.get();
+    }
+
+    /// The width the column asks for.
+    public final DoubleProperty prefWidthProperty() {
+        return prefWidth;
+    }
+
+    /// Sets the greatest width.
+    public final void setMaxWidth(double value) {
+        maxWidth.set(value);
+    }
+
+    /// Returns the greatest width.
+    public final double getMaxWidth() {
+        return maxWidth.get();
+    }
+
+    /// The greatest width.
+    public final DoubleProperty maxWidthProperty() {
+        return maxWidth;
+    }
+
+    /// Sets whether the user may resize the column; recorded.
+    public final void setResizable(boolean value) {
+        resizable.set(value);
+    }
+
+    /// Returns whether the user may resize the column.
+    public final boolean isResizable() {
+        return resizable.get();
+    }
+
+    /// Whether the user may resize the column.
+    public final BooleanProperty resizableProperty() {
+        return resizable;
+    }
+
+    /// Sets whether the table may be sorted by this column; recorded.
+    public final void setSortable(boolean value) {
+        sortable.set(value);
+    }
+
+    /// Returns whether the table may be sorted by this column.
+    public final boolean isSortable() {
+        return sortable.get();
+    }
+
+    /// Whether the table may be sorted by this column.
+    public final BooleanProperty sortableProperty() {
+        return sortable;
+    }
+
+    /// Attaches an object of the application to this column.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns the application's own object attached to this column.
+    public Object getUserData() {
+        return userData;
+    }
+
+    /// Returns a map for the application's own values on this column.
+    public final ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    /// Returns whether [#getProperties()] holds anything.
+    public boolean hasProperties() {
+        return properties != null && !properties.isEmpty();
+    }
+
+    /// Sets whether the cells of this column may be edited.
+    public final void setEditable(boolean value) {
+        editable.set(value);
+    }
+
+    /// Returns whether the cells of this column may be edited.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// Whether the cells of this column may be edited; true by default,
+    /// and in effect only in an editable table.
+    public final BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Sets what orders the values of this column when the table is
+    /// sorted by it.
+    public final void setComparator(Comparator<T> value) {
+        comparator.set(value);
+    }
+
+    /// Returns what orders the values of this column.
+    public final Comparator<T> getComparator() {
+        return comparator.get();
+    }
+
+    /// What orders the values of this column; [#DEFAULT_COMPARATOR]
+    /// unless the application sets another.
+    public final ObjectProperty<Comparator<T>> comparatorProperty() {
+        return comparator;
+    }
+
+    /// The handlers of this column.
+    final EventHandlerManager events() {
+        return events;
+    }
+
+    /// Adds a handler for the events of this column, the edit events of
+    /// a table column among them.
+    public <E extends Event> void addEventHandler(EventType<E> eventType, EventHandler<E> eventHandler) {
+        events.addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler added by `addEventHandler`.
+    public <E extends Event> void removeEventHandler(EventType<E> eventType, EventHandler<E> eventHandler) {
+        events.removeEventHandler(eventType, eventHandler);
+    }
+
+    /// Returns the value this column shows for a row, or `null`.
+    public final T getCellData(final int index) {
+        ObservableValue<T> result = getCellObservableValue(index);
+        return result == null ? null : result.getValue();
+    }
+
+    /// Returns the value this column shows for an item, or `null`.
+    public final T getCellData(final S item) {
+        ObservableValue<T> result = getCellObservableValue(item);
+        return result == null ? null : result.getValue();
+    }
+
+    /// Returns the observable value this column shows for a row.
+    public abstract ObservableValue<T> getCellObservableValue(int index);
+
+    /// Returns the observable value this column shows for an item.
+    public abstract ObservableValue<T> getCellObservableValue(S item);
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        return tail.prepend(events);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TablePosition.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TablePosition.java
new file mode 100644
index 00000000000..712de091be5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TablePosition.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.NamedArg;
+
+/// A cell of a [TableView], by row and column.
+///
+/// Unlike in JavaFX the position does not remember the item of its row:
+/// it is read from the table when asked for.
+public class TablePosition<S, T> extends TablePositionBase<TableColumn<S, T>> {
+
+    private final TableView<S> tableView;
+
+    /// Creates the position of a row in a column of a table.
+    public TablePosition(@NamedArg("tableView") TableView<S> tableView, @NamedArg("row") int row,
+            @NamedArg("tableColumn") TableColumn<S, T> tableColumn) {
+        super(row, tableColumn);
+        this.tableView = tableView;
+    }
+
+    @Override
+    public int getColumn() {
+        TableColumn<S, T> column = getTableColumn();
+        return tableView == null || column == null ? -1 : tableView.getColumns().indexOf(column);
+    }
+
+    /// Returns the table.
+    public final TableView<S> getTableView() {
+        return tableView;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof TablePosition && super.equals(obj) && tableView == ((TablePosition<?, ?>) obj).tableView;
+    }
+
+    @Override
+    public int hashCode() {
+        return 79 * super.hashCode() + (tableView == null ? 0 : tableView.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return "TablePosition [ row: " + getRow() + ", column: " + getColumn() + " ]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TablePositionBase.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TablePositionBase.java
new file mode 100644
index 00000000000..940fca7e6fd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TablePositionBase.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+/// A cell of a table named by its row and its column, rather than by the
+/// node that happens to show it.
+public abstract class TablePositionBase<TC extends TableColumnBase> {
+
+    private final int row;
+    private final TC tableColumn;
+
+    /// Creates the position of a row in a column.
+    protected TablePositionBase(int row, TC tableColumn) {
+        this.row = row;
+        this.tableColumn = tableColumn;
+    }
+
+    /// Returns the row.
+    public int getRow() {
+        return row;
+    }
+
+    /// Returns the index of the column among the columns of the table, -1
+    /// when it is in none.
+    public abstract int getColumn();
+
+    /// Returns the column.
+    public TC getTableColumn() {
+        return tableColumn;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TablePositionBase)) {
+            return false;
+        }
+        TablePositionBase<?> other = (TablePositionBase<?>) obj;
+        return row == other.row && tableColumn == other.tableColumn;
+    }
+
+    @Override
+    public int hashCode() {
+        return 79 * (79 * 5 + row) + (tableColumn == null ? 0 : tableColumn.hashCode());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TableView.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TableView.java
new file mode 100644
index 00000000000..ab4534c40fb
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TableView.java
@@ -0,0 +1,1150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.transformation.SortedList;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Polygon;
+import javafx.util.Callback;
+
+/// A table: one row per item, one [TableCell] per row and column, under
+/// a row of column headers.
+///
+/// The columns are laid side by side from the leading edge, each at the
+/// width its [TableColumnBase] says; a column that does not fit is cut at
+/// the edge, there is no horizontal scrolling. The rows work as in
+/// [ListView]: one height for all of them, cells only for the rows in
+/// view, vertical scrolling by wheel and by dragging.
+///
+/// Selection is by row. A press selects the row under it, and with
+/// `SelectionMode.MULTIPLE` the shortcut key and Shift work as in a list.
+///
+/// A press on the header of a sortable column sorts by it: ascending,
+/// then descending, then not at all, and with Shift held the column is
+/// added to the ones already sorted by. The order is a comparator of
+/// the items, [#comparatorProperty()]. Items in a `SortedList` are
+/// sorted by binding its comparator to the table's; any other list is
+/// sorted in place. `sortPolicy` and `onSort` are absent.
+///
+/// In an editable table a double click on a cell edits it, if its
+/// column is editable and its cell factory makes cells that edit.
+///
+/// With [#CONSTRAINED_RESIZE_POLICY] as the column resize policy the
+/// visible columns share the whole width of the table, each in
+/// proportion to its preferred width and within its minimum and maximum.
+/// With [#UNCONSTRAINED_RESIZE_POLICY], the default, each keeps its own
+/// width. The table knows these two by identity and never calls a
+/// policy: the user cannot drag a column wider here, so a policy of the
+/// application's own is recorded and the columns keep their own widths.
+///
+/// Cell selection (`TableSelectionModel`), row nodes (`TableRow`,
+/// `rowFactory`) and the focus model of JavaFX are not part of this
+/// layer.
+///
+/// The control has no native component. It starts with a white
+/// background and a thin grey border, which the `Region` style names
+/// replace; each header is a region with the style class `column-header`
+/// holding a label, on a strip with the style class
+/// `column-header-background`, and `-fx-size` on a header is its least
+/// height. The colours are those of the standard theme, looked up where
+/// the table stands: `-fx-box-border` around `-fx-control-inner-background`.
+public class TableView<S> extends Control {
+
+    /// The policy that leaves every column at its own width.
+    @SuppressWarnings("rawtypes")
+    public static final Callback<ResizeFeatures, Boolean> UNCONSTRAINED_RESIZE_POLICY =
+            new Callback<ResizeFeatures, Boolean>() {
+                @Override
+                public Boolean call(ResizeFeatures features) {
+                    return Boolean.FALSE;
+                }
+
+                @Override
+                public String toString() {
+                    return "unconstrained-resize";
+                }
+            };
+
+    /// The policy that makes the visible columns share the width of the
+    /// table.
+    @SuppressWarnings("rawtypes")
+    public static final Callback<ResizeFeatures, Boolean> CONSTRAINED_RESIZE_POLICY =
+            new Callback<ResizeFeatures, Boolean>() {
+                @Override
+                public Boolean call(ResizeFeatures features) {
+                    return Boolean.FALSE;
+                }
+
+                @Override
+                public String toString() {
+                    return "constrained-resize";
+                }
+            };
+
+    /// What a column resize policy is told: the table, the column that
+    /// is being resized and by how much.
+    public static class ResizeFeatures<S> {
+
+        private final TableView<S> table;
+        private final TableColumn<S, ?> column;
+        private final Double delta;
+
+        /// Creates the description of a resize.
+        public ResizeFeatures(TableView<S> table, TableColumn<S, ?> column, Double delta) {
+            this.table = table;
+            this.column = column;
+            this.delta = delta;
+        }
+
+        /// Returns the table.
+        public TableView<S> getTable() {
+            return table;
+        }
+
+        /// Returns the column being resized, `null` for all of them.
+        public TableColumn<S, ?> getColumn() {
+            return column;
+        }
+
+        /// Returns the change of width asked for.
+        public Double getDelta() {
+            return delta;
+        }
+    }
+
+    @SuppressWarnings("rawtypes")
+    private final ObjectProperty<Callback<ResizeFeatures, Boolean>> columnResizePolicy =
+            new SimpleObjectProperty<Callback<ResizeFeatures, Boolean>>(this, "columnResizePolicy",
+                    UNCONSTRAINED_RESIZE_POLICY);
+
+    /// Sets the column resize policy.
+    @SuppressWarnings("rawtypes")
+    public final void setColumnResizePolicy(Callback<ResizeFeatures, Boolean> value) {
+        columnResizePolicy.set(value);
+        requestLayout();
+    }
+
+    /// Returns the column resize policy.
+    @SuppressWarnings("rawtypes")
+    public final Callback<ResizeFeatures, Boolean> getColumnResizePolicy() {
+        return columnResizePolicy.get();
+    }
+
+    /// The column resize policy.
+    @SuppressWarnings("rawtypes")
+    public final ObjectProperty<Callback<ResizeFeatures, Boolean>> columnResizePolicyProperty() {
+        return columnResizePolicy;
+    }
+
+    /// Makes the visible columns share a width, each in proportion to
+    /// its preferred width and within its own bounds.
+    private void fitColumns(double width) {
+        int n = columns.size();
+        boolean[] held = new boolean[n];
+        double room = width;
+        // A column that hits a bound keeps it and the others share the
+        // rest, so each pass settles at least one column or all of them.
+        for (int pass = 0; pass <= n; pass++) {
+            double weight = 0;
+            for (int i = 0; i < n; i++) {
+                TableColumn<S, ?> c = columns.get(i);
+                if (c.isVisible() && !held[i]) {
+                    weight += Math.max(1, c.getPrefWidth());
+                }
+            }
+            if (!(weight > 0)) {
+                return;
+            }
+            boolean again = false;
+            for (int i = 0; i < n; i++) {
+                TableColumn<S, ?> c = columns.get(i);
+                if (!c.isVisible() || held[i]) {
+                    continue;
+                }
+                double share = Math.max(0, room) * Math.max(1, c.getPrefWidth()) / weight;
+                double bounded = Math.min(Math.max(share, c.getMinWidth()), c.getMaxWidth());
+                if (bounded != share) {
+                    held[i] = true;
+                    c.doSetWidth(bounded);
+                    room -= bounded;
+                    again = true;
+                    break;
+                }
+            }
+            if (!again) {
+                for (int i = 0; i < n; i++) {
+                    TableColumn<S, ?> c = columns.get(i);
+                    if (c.isVisible() && !held[i]) {
+                        c.doSetWidth(Math.max(0, room) * Math.max(1, c.getPrefWidth()) / weight);
+                    }
+                }
+                return;
+            }
+        }
+    }
+
+    private final ObjectProperty<ObservableList<S>> items = new SimpleObjectProperty<ObservableList<S>>(this,
+            "items");
+    private final ObservableList<TableColumn<S, ?>> columns = FXCollections.observableArrayList();
+    private final ObjectProperty<Node> placeholder = new SimpleObjectProperty<Node>(this, "placeholder");
+    private final Label noContent = new Label();
+    private final ObjectProperty<TableViewSelectionModel<S>> selectionModel =
+            new SimpleObjectProperty<TableViewSelectionModel<S>>(this, "selectionModel");
+    private final DoubleProperty fixedCellSize = new SimpleDoubleProperty(this, "fixedCellSize", USE_COMPUTED_SIZE);
+    private final RowFlow flow;
+    private final Region header = new Region() {
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-background-color: derive(-fx-base, -2%);";
+        }
+    };
+    private final ArrayList<ColumnHeader> headerCells = new ArrayList<ColumnHeader>();
+    private final ArrayList<Polygon> headerArrows = new ArrayList<Polygon>();
+    private final ObservableList<TableColumn<S, ?>> sortOrder = FXCollections.observableArrayList();
+    private final ReadOnlyObjectWrapper<Comparator<S>> comparator = new ReadOnlyObjectWrapper<Comparator<S>>(this,
+            "comparator");
+    private final BooleanProperty editable = new SimpleBooleanProperty(this, "editable", false);
+    private final ReadOnlyObjectWrapper<TablePosition<S, ?>> editingCell =
+            new ReadOnlyObjectWrapper<TablePosition<S, ?>>(this, "editingCell");
+    private boolean sorting;
+    private int anchor = -1;
+
+    private final ChangeListener<Object> sortListener = new ChangeListener<Object>() {
+        @Override
+        public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+            sort();
+        }
+    };
+
+    private final ListChangeListener<S> itemsListener = new ListChangeListener<S>() {
+        @Override
+        public void onChanged(Change<? extends S> change) {
+            RowSelection<S> own = ownSelection();
+            if (own != null) {
+                own.rowsChanged(change);
+            }
+            contentChanged();
+        }
+    };
+
+    private final ListChangeListener<Integer> selectionListener = new ListChangeListener<Integer>() {
+        @Override
+        public void onChanged(Change<? extends Integer> change) {
+            syncSelection();
+        }
+    };
+
+    private final ChangeListener<Object> columnListener = new ChangeListener<Object>() {
+        @Override
+        public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+            columnsChanged();
+        }
+    };
+
+    private final ChangeListener<Object> widthListener = new ChangeListener<Object>() {
+        @Override
+        public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+            // The cells stay; they are placed again.
+            flow.requestLayout();
+            requestLayout();
+        }
+    };
+
+    /// Creates a table with no items.
+    public TableView() {
+        this(FXCollections.<S>observableArrayList());
+    }
+
+    /// Creates a table of some items.
+    public TableView(ObservableList<S> items) {
+        getStyleClass().add("table-view");
+        setBackground(new Background(new BackgroundFill(Color.WHITE, CornerRadii.EMPTY, Insets.EMPTY)));
+        header.setBackground(new Background(new BackgroundFill(Color.rgb(232, 232, 232), CornerRadii.EMPTY,
+                Insets.EMPTY)));
+        // The name JavaFX gives the strip behind its column headers.
+        header.getStyleClass().add("column-header-background");
+        flow = new RowFlow(new FlowRows());
+        flow.stripes = true;
+        cn1Children().add(flow);
+        cn1Children().add(header);
+        this.items.addListener(new ChangeListener<ObservableList<S>>() {
+            @Override
+            public void changed(ObservableValue<? extends ObservableList<S>> observable, ObservableList<S> oldValue,
+                    ObservableList<S> newValue) {
+                if (oldValue != null) {
+                    oldValue.removeListener(itemsListener);
+                }
+                if (newValue != null) {
+                    newValue.addListener(itemsListener);
+                }
+                RowSelection<S> own = ownSelection();
+                if (own != null) {
+                    own.rowsReplaced();
+                }
+                flow.scrollTo(0);
+                contentChanged();
+            }
+        });
+        columns.addListener(new ListChangeListener<TableColumn<S, ?>>() {
+            @Override
+            public void onChanged(Change<? extends TableColumn<S, ?>> change) {
+                while (change.next()) {
+                    List<? extends TableColumn<S, ?>> removed = change.getRemoved();
+                    for (int i = 0; i < removed.size(); i++) {
+                        detach(removed.get(i));
+                    }
+                    List<? extends TableColumn<S, ?>> added = change.getAddedSubList();
+                    for (int i = 0; i < added.size(); i++) {
+                        attach(added.get(i));
+                    }
+                }
+                columnsChanged();
+            }
+        });
+        selectionModel.addListener(new ChangeListener<TableViewSelectionModel<S>>() {
+            @Override
+            public void changed(ObservableValue<? extends TableViewSelectionModel<S>> observable,
+                    TableViewSelectionModel<S> oldValue, TableViewSelectionModel<S> newValue) {
+                if (oldValue != null) {
+                    oldValue.getSelectedIndices().removeListener(selectionListener);
+                }
+                if (newValue != null) {
+                    newValue.getSelectedIndices().addListener(selectionListener);
+                }
+                syncSelection();
+            }
+        });
+        noContent.setMouseTransparent(true);
+        noContent.setVisible(false);
+        cn1Children().add(noContent);
+        placeholder.addListener(new ChangeListener<Node>() {
+            @Override
+            public void changed(ObservableValue<? extends Node> observable, Node oldValue, Node newValue) {
+                if (oldValue != null) {
+                    cn1Children().remove(oldValue);
+                }
+                if (newValue != null && !cn1Children().contains(newValue)) {
+                    cn1Children().add(newValue);
+                }
+                requestLayout();
+            }
+        });
+        fixedCellSize.addListener(new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
+                flow.rowsChanged();
+            }
+        });
+        flow.addEventHandler(MouseEvent.MOUSE_PRESSED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                pressed(event);
+            }
+        });
+        flow.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent event) {
+                clicked(event);
+            }
+        });
+        sortOrder.addListener(new ListChangeListener<TableColumn<S, ?>>() {
+            @Override
+            public void onChanged(Change<? extends TableColumn<S, ?>> change) {
+                sort();
+            }
+        });
+        selectionModel.set(new Model<S>(this));
+        this.items.set(items);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    private void attach(TableColumn<S, ?> column) {
+        if (column.getTableView() == this) {
+            return;
+        }
+        column.setTableView(this);
+        column.textProperty().addListener(columnListener);
+        column.visibleProperty().addListener(columnListener);
+        column.widthProperty().addListener(widthListener);
+        column.cellFactoryProperty().addListener(columnListener);
+        column.cellValueFactoryProperty().addListener(columnListener);
+        column.sortTypeProperty().addListener(sortListener);
+        column.sortableProperty().addListener(sortListener);
+        column.comparatorProperty().addListener(sortListener);
+    }
+
+    private void detach(TableColumn<S, ?> column) {
+        if (columns.contains(column)) {
+            return;
+        }
+        column.setTableView(null);
+        column.textProperty().removeListener(columnListener);
+        column.visibleProperty().removeListener(columnListener);
+        column.widthProperty().removeListener(widthListener);
+        column.cellFactoryProperty().removeListener(columnListener);
+        column.cellValueFactoryProperty().removeListener(columnListener);
+        column.sortTypeProperty().removeListener(sortListener);
+        column.sortableProperty().removeListener(sortListener);
+        column.comparatorProperty().removeListener(sortListener);
+        sortOrder.remove(column);
+    }
+
+    /// The standard theme's table: a border that is the outermost fill,
+    /// showing around the inner one.
+    @Override
+    public String cn1DefaultStyle() {
+        return "-fx-background-color: -fx-box-border, -fx-control-inner-background;"
+                + " -fx-background-insets: 0, 1; -fx-padding: 1;";
+    }
+
+    /// The header of one column: a region a style sheet reaches as
+    /// `.column-header`, around the label it reaches as
+    /// `.column-header .label`.
+    private static final class ColumnHeader extends Region {
+        private final Label label;
+        private double size;
+
+        ColumnHeader(String text) {
+            getStyleClass().add("column-header");
+            label = new Label(text);
+            label.setAlignment(javafx.geometry.Pos.CENTER);
+            label.setMouseTransparent(true);
+            cn1Children().add(label);
+        }
+
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-border-color: transparent -fx-table-header-border-color -fx-table-header-border-color"
+                    + " transparent; -fx-border-width: 0 1 1 0; -fx-padding: 2; -fx-size: 24;"
+                    + " -fx-font-weight: bold;";
+        }
+
+        @Override
+        protected Object cn1StyleValue(String property) {
+            if ("-fx-size".equals(property)) {
+                return Double.valueOf(size);
+            }
+            return super.cn1StyleValue(property);
+        }
+
+        @Override
+        protected boolean cn1SetStyleValue(String property, Object value) {
+            if ("-fx-size".equals(property)) {
+                if (!(value instanceof Number)) {
+                    return false;
+                }
+                size = ((Number) value).doubleValue();
+                requestLayout();
+                if (getParent() != null) {
+                    getParent().requestLayout();
+                }
+                return true;
+            }
+            return super.cn1SetStyleValue(property, value);
+        }
+
+        @Override
+        protected double computePrefHeight(double width) {
+            Insets in = getInsets();
+            return Math.max(size, in.getTop() + label.prefHeight(-1) + in.getBottom());
+        }
+
+        @Override
+        protected double computePrefWidth(double height) {
+            Insets in = getInsets();
+            return in.getLeft() + label.prefWidth(-1) + in.getRight();
+        }
+
+        @Override
+        protected void layoutChildren() {
+            Insets in = getInsets();
+            label.resizeRelocate(in.getLeft(), in.getTop(),
+                    Math.max(0, getWidth() - in.getLeft() - in.getRight()),
+                    Math.max(0, getHeight() - in.getTop() - in.getBottom()));
+        }
+    }
+
+    /// The columns, their widths or what they show changed: the headers
+    /// and every cell are made again.
+    private void columnsChanged() {
+        for (int i = 0; i < headerCells.size(); i++) {
+            cn1Children().remove(headerCells.get(i));
+        }
+        headerCells.clear();
+        for (int i = 0; i < headerArrows.size(); i++) {
+            cn1Children().remove(headerArrows.get(i));
+        }
+        headerArrows.clear();
+        for (int i = 0; i < columns.size(); i++) {
+            final TableColumn<S, ?> column = columns.get(i);
+            ColumnHeader label = new ColumnHeader(column.getText());
+            label.setManaged(false);
+            label.setVisible(column.isVisible());
+            label.addEventHandler(MouseEvent.MOUSE_CLICKED, new EventHandler<MouseEvent>() {
+                @Override
+                public void handle(MouseEvent event) {
+                    if (event.getButton() == MouseButton.PRIMARY) {
+                        headerClicked(column, event.isShiftDown());
+                    }
+                }
+            });
+            headerCells.add(label);
+            cn1Children().add(label);
+            Polygon arrow = new Polygon();
+            arrow.setManaged(false);
+            arrow.setMouseTransparent(true);
+            arrow.setFill(Color.rgb(90, 90, 90));
+            arrow.setVisible(false);
+            headerArrows.add(arrow);
+            cn1Children().add(arrow);
+        }
+        flow.rebuild();
+        syncArrows();
+        requestLayout();
+    }
+
+    @SuppressWarnings("unchecked")
+    private RowSelection<S> ownSelection() {
+        TableViewSelectionModel<S> model = getSelectionModel();
+        return model instanceof Model ? ((Model<S>) model).selection : null;
+    }
+
+    private void contentChanged() {
+        flow.rowsChanged();
+        requestLayout();
+    }
+
+    private void syncSelection() {
+        TableViewSelectionModel<S> model = getSelectionModel();
+        ArrayList<IndexedCell<?>[]> slots = flow.slots();
+        for (int i = 0; i < slots.size(); i++) {
+            IndexedCell<?>[] slot = slots.get(i);
+            for (int c = 0; c < slot.length; c++) {
+                int row = slot[c].getIndex();
+                slot[c].updateSelected(model != null && row >= 0 && model.isSelected(row));
+            }
+        }
+    }
+
+    private void pressed(MouseEvent event) {
+        TableViewSelectionModel<S> model = getSelectionModel();
+        int row = flow.rowAt(event);
+        if (model == null || row < 0) {
+            return;
+        }
+        anchor = RowPress.apply(model, event.getButton() == MouseButton.PRIMARY, event.isShortcutDown(),
+                event.isShiftDown(), row, anchor);
+    }
+
+    private void clicked(MouseEvent event) {
+        if (!isEditable() || event.getButton() != MouseButton.PRIMARY || event.getClickCount() < 2) {
+            return;
+        }
+        int row = flow.rowAt(event);
+        if (row < 0) {
+            return;
+        }
+        double x = flow.sceneToLocal(event.getSceneX(), event.getSceneY()).getX();
+        double at = 0;
+        for (int i = 0; i < columns.size(); i++) {
+            TableColumn<S, ?> column = columns.get(i);
+            if (!column.isVisible()) {
+                continue;
+            }
+            if (x >= at && x < at + column.getWidth()) {
+                edit(row, column);
+                return;
+            }
+            at += column.getWidth();
+        }
+    }
+
+    /// A header was pressed: the column is sorted ascending, then
+    /// descending, then not at all. Alone, unless it is added to the
+    /// columns already sorted by.
+    private void headerClicked(TableColumn<S, ?> column, boolean add) {
+        if (!column.isSortable()) {
+            return;
+        }
+        boolean sorted = sortOrder.contains(column);
+        sorting = true;
+        if (!sorted) {
+            column.setSortType(TableColumn.SortType.ASCENDING);
+            if (!add) {
+                sortOrder.clear();
+            }
+            sortOrder.add(column);
+        } else if (column.getSortType() == TableColumn.SortType.ASCENDING) {
+            column.setSortType(TableColumn.SortType.DESCENDING);
+            if (!add && sortOrder.size() > 1) {
+                sortOrder.setAll(java.util.Collections.<TableColumn<S, ?>>singletonList(column));
+            }
+        } else {
+            sortOrder.remove(column);
+        }
+        sorting = false;
+        sort();
+    }
+
+    private static <S, T> int compareBy(TableColumn<S, T> column, S a, S b) {
+        Comparator<T> by = column.getComparator();
+        if (by == null) {
+            return 0;
+        }
+        // Descending by exchanging the operands: negating a result fails for
+        // a comparator that answers Integer.MIN_VALUE.
+        return column.getSortType() == TableColumn.SortType.DESCENDING
+                ? by.compare(column.getCellData(b), column.getCellData(a))
+                : by.compare(column.getCellData(a), column.getCellData(b));
+    }
+
+    /// Sorts the items by the columns of the sort order. With none the
+    /// comparator is `null`: a `SortedList` bound to it returns to the
+    /// order of its source, any other list stays as it is.
+    public void sort() {
+        if (sorting) {
+            return;
+        }
+        final ArrayList<TableColumn<S, ?>> by = new ArrayList<TableColumn<S, ?>>();
+        for (int i = 0; i < sortOrder.size(); i++) {
+            TableColumn<S, ?> column = sortOrder.get(i);
+            if (column != null && column.isSortable() && !by.contains(column)) {
+                by.add(column);
+            }
+        }
+        Comparator<S> order = by.isEmpty() ? null : new Comparator<S>() {
+            @Override
+            public int compare(S a, S b) {
+                for (int i = 0; i < by.size(); i++) {
+                    int c = compareBy(by.get(i), a, b);
+                    if (c != 0) {
+                        return c;
+                    }
+                }
+                return 0;
+            }
+        };
+        sorting = true;
+        comparator.set(order);
+        ObservableList<S> list = getItems();
+        // A sorted list takes the comparator through its own property.
+        if (order != null && list != null && !(list instanceof SortedList)) {
+            FXCollections.sort(list, order);
+        }
+        sorting = false;
+        syncArrows();
+        requestLayout();
+    }
+
+    private void syncArrows() {
+        for (int i = 0; i < headerArrows.size() && i < columns.size(); i++) {
+            TableColumn<S, ?> column = columns.get(i);
+            Polygon arrow = headerArrows.get(i);
+            boolean shown = column.isVisible() && column.isSortable() && sortOrder.contains(column);
+            arrow.setVisible(shown);
+            if (shown) {
+                boolean up = column.getSortType() != TableColumn.SortType.DESCENDING;
+                arrow.getPoints().setAll(0.0, up ? 6.0 : 0.0, 8.0, up ? 6.0 : 0.0, 4.0, up ? 0.0 : 6.0);
+            }
+        }
+    }
+
+    final void editing(TablePosition<S, ?> cell) {
+        editingCell.set(cell);
+    }
+
+    /// Starts editing the cell of a row in a column, when the table and
+    /// the column are editable and the row is in view; a row of -1 or a
+    /// `null` column cancels the edit in progress.
+    public void edit(int row, TableColumn<S, ?> column) {
+        TablePosition<S, ?> now = editingCell.get();
+        if (now != null) {
+            IndexedCell<?> cell = flow.cell(now.getRow(), now.getColumn());
+            if (cell != null && cell.isEditing()) {
+                cell.cancelEdit();
+            }
+            editingCell.set(null);
+        }
+        int at = column == null ? -1 : columns.indexOf(column);
+        if (row < 0 || at < 0 || !isEditable() || !column.isEditable()) {
+            return;
+        }
+        IndexedCell<?> cell = flow.cell(row, at);
+        if (cell != null) {
+            cell.startEdit();
+        }
+    }
+
+    /// Returns the cell being edited, or `null`.
+    public final TablePosition<S, ?> getEditingCell() {
+        return editingCell.get();
+    }
+
+    /// The cell being edited.
+    public final ReadOnlyObjectProperty<TablePosition<S, ?>> editingCellProperty() {
+        return editingCell.getReadOnlyProperty();
+    }
+
+    /// Sets whether the cells of this table may be edited.
+    public final void setEditable(boolean value) {
+        editable.set(value);
+    }
+
+    /// Returns whether the cells of this table may be edited.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// Whether the cells of this table may be edited; false by default.
+    public final BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Returns the columns the table is sorted by, the first one first.
+    public final ObservableList<TableColumn<S, ?>> getSortOrder() {
+        return sortOrder;
+    }
+
+    /// The order of the items the sort order asks for, `null` with no
+    /// sort order. A `SortedList` shown by the table binds its own
+    /// comparator to this one.
+    public final ReadOnlyObjectProperty<Comparator<S>> comparatorProperty() {
+        return comparator.getReadOnlyProperty();
+    }
+
+    /// Returns the order of the items the sort order asks for, or `null`.
+    public final Comparator<S> getComparator() {
+        return comparator.get();
+    }
+
+    private double headerHeight() {
+        double h = 0;
+        for (int i = 0; i < headerCells.size(); i++) {
+            h = Math.max(h, headerCells.get(i).prefHeight(-1));
+        }
+        return h > 0 ? h : 24;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double w = Math.max(0, getWidth() - in.getLeft() - in.getRight());
+        double h = Math.max(0, getHeight() - in.getTop() - in.getBottom());
+        double hh = Math.min(h, headerHeight());
+        if (getColumnResizePolicy() == CONSTRAINED_RESIZE_POLICY && w > 0) {
+            fitColumns(w);
+        }
+        header.resizeRelocate(in.getLeft(), in.getTop(), w, hh);
+        double x = 0;
+        for (int i = 0; i < headerCells.size() && i < columns.size(); i++) {
+            TableColumn<S, ?> column = columns.get(i);
+            ColumnHeader label = headerCells.get(i);
+            if (!column.isVisible()) {
+                continue;
+            }
+            double cw = Math.max(0, Math.min(column.getWidth(), w - x));
+            label.setVisible(cw > 0);
+            label.resizeRelocate(in.getLeft() + x, in.getTop(), cw, hh);
+            if (i < headerArrows.size()) {
+                Polygon arrow = headerArrows.get(i);
+                if (cw < 16) {
+                    arrow.setVisible(false);
+                }
+                arrow.relocate(in.getLeft() + x + cw - 12, in.getTop() + (hh - 6) / 2);
+            }
+            x += column.getWidth();
+        }
+        // A table with nothing to show says so, in the words of the standard
+        // skin, unless the application gave it something else to show.
+        Node empty = getPlaceholder();
+        if (empty == null) {
+            empty = noContent;
+            noContent.setText(columns.isEmpty() ? "No columns in table" : "No content in table");
+        } else {
+            noContent.setVisible(false);
+        }
+        ObservableList<S> list = getItems();
+        boolean showEmpty = list == null || list.isEmpty() || columns.isEmpty();
+        flow.setVisible(!showEmpty);
+        flow.resizeRelocate(in.getLeft(), in.getTop() + hh, w, h - hh);
+        empty.setVisible(showEmpty);
+        if (showEmpty) {
+            layoutInArea(empty, in.getLeft(), in.getTop() + hh, w, h - hh, 0, javafx.geometry.HPos.CENTER,
+                    javafx.geometry.VPos.CENTER);
+        }
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        double w = 0;
+        for (int i = 0; i < columns.size(); i++) {
+            if (columns.get(i).isVisible()) {
+                w += columns.get(i).getWidth();
+            }
+        }
+        return Math.max(248, in.getLeft() + w + in.getRight());
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        return 400;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    public double getBaselineOffset() {
+        return BASELINE_OFFSET_SAME_AS_HEIGHT;
+    }
+
+    /// The items shown, one per row.
+    public final ObjectProperty<ObservableList<S>> itemsProperty() {
+        return items;
+    }
+
+    /// Sets the items shown. Changes to an observable list show at once.
+    public final void setItems(ObservableList<S> value) {
+        items.set(value);
+    }
+
+    /// Returns the items shown.
+    public final ObservableList<S> getItems() {
+        return items.get();
+    }
+
+    /// Returns the columns, in the order they are shown.
+    public final ObservableList<TableColumn<S, ?>> getColumns() {
+        return columns;
+    }
+
+    /// The node shown instead of the rows while there are no items.
+    public final ObjectProperty<Node> placeholderProperty() {
+        return placeholder;
+    }
+
+    /// Sets the node shown while there are no items.
+    public final void setPlaceholder(Node value) {
+        placeholder.set(value);
+    }
+
+    /// Returns the node shown while there are no items.
+    public final Node getPlaceholder() {
+        return placeholder.get();
+    }
+
+    /// The selection model.
+    public final ObjectProperty<TableViewSelectionModel<S>> selectionModelProperty() {
+        return selectionModel;
+    }
+
+    /// Sets the selection model.
+    public final void setSelectionModel(TableViewSelectionModel<S> value) {
+        selectionModel.set(value);
+    }
+
+    /// Returns the selection model.
+    public final TableViewSelectionModel<S> getSelectionModel() {
+        return selectionModel.get();
+    }
+
+    /// Sets the height of every row; `Region.USE_COMPUTED_SIZE` takes it
+    /// from the cells of the first row.
+    public final void setFixedCellSize(double value) {
+        fixedCellSize.set(value);
+    }
+
+    /// Returns the height of every row, or `Region.USE_COMPUTED_SIZE`.
+    public final double getFixedCellSize() {
+        return fixedCellSize.get();
+    }
+
+    /// The height of every row.
+    public final DoubleProperty fixedCellSizeProperty() {
+        return fixedCellSize;
+    }
+
+    /// Scrolls so that a row is the first one shown, as far as the rows
+    /// reach.
+    public void scrollTo(int index) {
+        flow.show(index);
+    }
+
+    /// Scrolls to an item of the table.
+    public void scrollTo(S object) {
+        ObservableList<S> list = getItems();
+        int at = list == null ? -1 : list.indexOf(object);
+        if (at >= 0) {
+            scrollTo(at);
+        }
+    }
+
+    /// Shows every visible row again, for items that changed in a way
+    /// the table could not observe.
+    public void refresh() {
+        flow.refresh();
+    }
+
+    private <T> TableCell<S, T> createCell(TableColumn<S, T> column) {
+        TableCell<S, T> cell = column.getCellFactory() == null ? null : column.getCellFactory().call(column);
+        if (cell == null) {
+            @SuppressWarnings("unchecked")
+            TableCell<S, T> made = (TableCell<S, T>) TableColumn.DEFAULT_CELL_FACTORY.call(column);
+            cell = made;
+        }
+        cell.updateTableView(this);
+        cell.updateTableColumn(column);
+        return cell;
+    }
+
+    private final class FlowRows implements RowFlow.Rows {
+        @Override
+        public int rowCount() {
+            ObservableList<S> list = getItems();
+            return list == null ? 0 : list.size();
+        }
+
+        @Override
+        public int columnCount() {
+            return columns.size();
+        }
+
+        @Override
+        public void columns(double width, double[] x, double[] w) {
+            double at = 0;
+            for (int i = 0; i < x.length && i < columns.size(); i++) {
+                TableColumn<S, ?> column = columns.get(i);
+                x[i] = at;
+                w[i] = column.isVisible() ? Math.max(0, Math.min(column.getWidth(), width - at)) : 0;
+                if (column.isVisible()) {
+                    at += column.getWidth();
+                }
+            }
+        }
+
+        @Override
+        public IndexedCell<?> createCell(int column) {
+            return TableView.this.createCell(columns.get(column));
+        }
+
+        @Override
+        public void updateCell(IndexedCell<?> cell, int column, int row, boolean force) {
+            if (force && cell instanceof TableCell) {
+                ((TableCell<?, ?>) cell).markStale();
+            }
+            cell.updateIndex(row);
+        }
+
+        @Override
+        public double fixedCellSize() {
+            return getFixedCellSize();
+        }
+    }
+
+    /// The selection of a table: whole rows.
+    ///
+    /// Unlike in JavaFX this class extends [MultipleSelectionModel]
+    /// directly; the cell selection members of `TableSelectionModel` are
+    /// not part of this layer.
+    public abstract static class TableViewSelectionModel<S> extends MultipleSelectionModel<S> {
+
+        private final TableView<S> tableView;
+
+        /// Creates the selection model of a table.
+        public TableViewSelectionModel(final TableView<S> tableView) {
+            if (tableView == null) {
+                throw new NullPointerException("TableView can not be null");
+            }
+            this.tableView = tableView;
+        }
+
+        /// Returns the table this model selects in.
+        public TableView<S> getTableView() {
+            return tableView;
+        }
+    }
+
+    private static final class Model<S> extends TableViewSelectionModel<S> implements RowSelection.Owner<S> {
+
+        private final RowSelection<S> selection;
+
+        Model(TableView<S> view) {
+            super(view);
+            this.selection = new RowSelection<S>(this);
+        }
+
+        @Override
+        public ObservableList<S> rows() {
+            return getTableView().getItems();
+        }
+
+        @Override
+        public boolean multiple() {
+            return getSelectionMode() == SelectionMode.MULTIPLE;
+        }
+
+        @Override
+        public void lead(int index, S item) {
+            setSelectedIndex(index);
+            setSelectedItem(item);
+        }
+
+        @Override
+        public ObservableList<Integer> getSelectedIndices() {
+            return selection.indices();
+        }
+
+        @Override
+        public ObservableList<S> getSelectedItems() {
+            return selection.items();
+        }
+
+        @Override
+        public void selectIndices(int index, int... indices) {
+            selection.selectIndices(index, indices);
+        }
+
+        @Override
+        public void selectAll() {
+            selection.selectAll();
+        }
+
+        @Override
+        public void selectFirst() {
+            if (selection.rowCount() > 0) {
+                select(0);
+            }
+        }
+
+        @Override
+        public void selectLast() {
+            int n = selection.rowCount();
+            if (n > 0) {
+                select(n - 1);
+            }
+        }
+
+        @Override
+        public void clearAndSelect(int index) {
+            selection.clearAndSelect(index);
+        }
+
+        @Override
+        public void select(int index) {
+            selection.select(index);
+        }
+
+        @Override
+        public void select(S obj) {
+            selection.select(obj);
+        }
+
+        @Override
+        public void clearSelection(int index) {
+            selection.clear(index);
+        }
+
+        @Override
+        public void clearSelection() {
+            selection.clear();
+        }
+
+        @Override
+        public boolean isSelected(int index) {
+            return selection.isSelected(index);
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return selection.isEmpty();
+        }
+
+        @Override
+        public void selectPrevious() {
+            int lead = selection.lead();
+            if (lead > 0) {
+                select(lead - 1);
+            }
+        }
+
+        @Override
+        public void selectNext() {
+            int lead = selection.lead();
+            if (lead < selection.rowCount() - 1) {
+                select(lead + 1);
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TextArea.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TextArea.java
new file mode 100644
index 00000000000..1a7867736ea
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TextArea.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.ui.Component;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+
+/// Several lines of text the user types, shown as a Codename One
+/// `TextArea`.
+///
+/// The preferred size is the native area's for `prefColumnCount` columns
+/// and `prefRowCount` rows. The native area always breaks lines that do
+/// not fit and scrolls on its own, so `wrapText` is recorded and `false`
+/// does not give a horizontally scrolling area; `scrollTop`,
+/// `scrollLeft` and `getParagraphs` are not part of this layer.
+///
+/// Styled as its base class describes.
+public class TextArea extends TextInputControl {
+
+    /// The number of columns of a text area that was not told otherwise.
+    public static final int DEFAULT_PREF_COLUMN_COUNT = 40;
+
+    /// The number of rows of a text area that was not told otherwise.
+    public static final int DEFAULT_PREF_ROW_COUNT = 10;
+
+    private final IntegerProperty prefColumnCount = new SimpleIntegerProperty(this, "prefColumnCount",
+            DEFAULT_PREF_COLUMN_COUNT) {
+        @Override
+        protected void invalidated() {
+            cn1Invalidated(Dirty.NATIVE | Dirty.LAYOUT);
+        }
+    };
+    private final IntegerProperty prefRowCount = new SimpleIntegerProperty(this, "prefRowCount",
+            DEFAULT_PREF_ROW_COUNT) {
+        @Override
+        protected void invalidated() {
+            cn1Invalidated(Dirty.NATIVE | Dirty.LAYOUT);
+        }
+    };
+    private final BooleanProperty wrapText = new SimpleBooleanProperty(this, "wrapText", false);
+
+    /// Creates an empty text area.
+    public TextArea() {
+        this("");
+    }
+
+    /// Creates a text area with text.
+    public TextArea(String text) {
+        getStyleClass().add("text-area");
+        setText(text);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.TextArea area = new com.codename1.ui.TextArea();
+        area.setSingleLineTextArea(false);
+        area.setGrowByContent(false);
+        area.addDataChangedListener(textBridge());
+        return area;
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (!(c instanceof com.codename1.ui.TextArea)) {
+            return;
+        }
+        com.codename1.ui.TextArea area = (com.codename1.ui.TextArea) c;
+        int columns = Math.max(1, getPrefColumnCount());
+        if (area.getColumns() != columns) {
+            area.setColumns(columns);
+        }
+        int rows = Math.max(1, getPrefRowCount());
+        if (area.getRows() != rows) {
+            area.setRows(rows);
+        }
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    /// Returns the number of columns the preferred width is for.
+    public final int getPrefColumnCount() {
+        return prefColumnCount.get();
+    }
+
+    /// Sets the number of columns the preferred width is for.
+    public final void setPrefColumnCount(int value) {
+        prefColumnCount.set(value);
+    }
+
+    /// The number of columns the preferred width is for.
+    public final IntegerProperty prefColumnCountProperty() {
+        return prefColumnCount;
+    }
+
+    /// Returns the number of rows the preferred height is for.
+    public final int getPrefRowCount() {
+        return prefRowCount.get();
+    }
+
+    /// Sets the number of rows the preferred height is for.
+    public final void setPrefRowCount(int value) {
+        prefRowCount.set(value);
+    }
+
+    /// The number of rows the preferred height is for.
+    public final IntegerProperty prefRowCountProperty() {
+        return prefRowCount;
+    }
+
+    /// Returns whether lines are asked to wrap; the native area always
+    /// wraps.
+    public final boolean isWrapText() {
+        return wrapText.get();
+    }
+
+    /// Asks for lines to wrap; the native area always wraps.
+    public final void setWrapText(boolean value) {
+        wrapText.set(value);
+    }
+
+    /// Whether lines are asked to wrap.
+    public final BooleanProperty wrapTextProperty() {
+        return wrapText;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TextField.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TextField.java
new file mode 100644
index 00000000000..37141ebf0e6
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TextField.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.ui.Component;
+import com.codename1.ui.events.ActionListener;
+
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.HPos;
+import javafx.geometry.Pos;
+
+/// One line of text the user types, shown as a Codename One `TextField`.
+///
+/// The preferred width is the native field's for `prefColumnCount`
+/// columns. An `ActionEvent` is fired when the native field reports that
+/// editing was finished with the done or Enter key. The horizontal part
+/// of the alignment is applied.
+///
+/// Styled as its base class describes.
+public class TextField extends TextInputControl {
+
+    /// The number of columns of a text field that was not told otherwise.
+    public static final int DEFAULT_PREF_COLUMN_COUNT = 12;
+
+    private final IntegerProperty prefColumnCount = new SimpleIntegerProperty(this, "prefColumnCount",
+            DEFAULT_PREF_COLUMN_COUNT) {
+        @Override
+        protected void invalidated() {
+            cn1Invalidated(Dirty.NATIVE | Dirty.LAYOUT);
+        }
+    };
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.CENTER_LEFT,
+            Dirty.NATIVE);
+
+    private final ObjectProperty<EventHandler<ActionEvent>> onAction =
+            new SimpleObjectProperty<EventHandler<ActionEvent>>(this, "onAction") {
+        @Override
+        protected void invalidated() {
+            setEventHandler(ActionEvent.ACTION, get());
+        }
+    };
+
+    /// Creates an empty text field.
+    public TextField() {
+        this("");
+    }
+
+    /// Creates a text field with text.
+    public TextField(String text) {
+        getStyleClass().add("text-field");
+        setText(text);
+    }
+
+    /// Returns the Codename One input constraint of the native field.
+    int nativeConstraint() {
+        return com.codename1.ui.TextArea.ANY;
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.TextField field = new com.codename1.ui.TextField();
+        field.setConstraint(nativeConstraint());
+        field.addDataChangedListener(textBridge());
+        field.setDoneListener(new ActionListener<com.codename1.ui.events.ActionEvent>() {
+            @Override
+            public void actionPerformed(com.codename1.ui.events.ActionEvent evt) {
+                if (!isDisabled()) {
+                    fireEvent(new ActionEvent(TextField.this, TextField.this));
+                }
+            }
+        });
+        return field;
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (!(c instanceof com.codename1.ui.TextField)) {
+            return;
+        }
+        com.codename1.ui.TextField field = (com.codename1.ui.TextField) c;
+        int columns = Math.max(1, getPrefColumnCount());
+        if (field.getColumns() != columns) {
+            field.setColumns(columns);
+        }
+        Pos pos = getAlignment();
+        HPos h = pos == null ? HPos.LEFT : pos.getHpos();
+        field.setAlignment(h == HPos.CENTER ? Component.CENTER : (h == HPos.RIGHT ? Component.RIGHT : Component.LEFT));
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    /// A field is as narrow as its padding and room for one letter, as a
+    /// JavaFX field is as narrow as its padding: the columns are what it
+    /// would like, not what it needs. With the preferred width for a
+    /// minimum a field was the one rigid thing in a row too narrow for it,
+    /// and the label before it gave up every pixel that was missing -- a
+    /// form on a phone read "N...", "P..." beside fields with room to spare.
+    @Override
+    protected double computeMinWidth(double height) {
+        double pref = computePrefWidth(height);
+        Component c = cn1NativeIfCreated();
+        if (!(c instanceof com.codename1.ui.TextField)) {
+            return pref;
+        }
+        com.codename1.ui.plaf.Style s = c.getUnselectedStyle();
+        com.codename1.ui.Font f = s.getFont();
+        int least = s.getHorizontalPadding() + (f == null ? 0 : f.charWidth('W'));
+        javafx.geometry.Insets in = getInsets();
+        return Math.min(pref, in.getLeft() + snapSizeX(com.codename1.fxcompat.runtime.Units.toLogical(least))
+                + in.getRight());
+    }
+
+    /// Returns the text as a character sequence.
+    public CharSequence getCharacters() {
+        String t = getText();
+        return t == null ? "" : t;
+    }
+
+    /// Returns the number of columns the preferred width is for.
+    public final int getPrefColumnCount() {
+        return prefColumnCount.get();
+    }
+
+    /// Sets the number of columns the preferred width is for.
+    public final void setPrefColumnCount(int value) {
+        prefColumnCount.set(value);
+    }
+
+    /// The number of columns the preferred width is for.
+    public final IntegerProperty prefColumnCountProperty() {
+        return prefColumnCount;
+    }
+
+    /// Returns where the text sits in the field.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the text sits in the field.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the text sits in the field.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Sets the handler of editing being finished with Enter.
+    public final void setOnAction(EventHandler<ActionEvent> value) {
+        onAction.set(value);
+    }
+
+    /// Returns the handler of editing being finished with Enter.
+    public final EventHandler<ActionEvent> getOnAction() {
+        return onAction.get();
+    }
+
+    /// The handler of editing being finished with Enter.
+    public final ObjectProperty<EventHandler<ActionEvent>> onActionProperty() {
+        return onAction;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TextInputControl.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TextInputControl.java
new file mode 100644
index 00000000000..fb09016c497
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TextInputControl.java
@@ -0,0 +1,692 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxString;
+import com.codename1.ui.Component;
+import com.codename1.ui.events.DataChangedListener;
+import com.codename1.ui.plaf.Style;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.property.ReadOnlyIntegerWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.ReadOnlyStringProperty;
+import javafx.beans.property.ReadOnlyStringWrapper;
+import javafx.beans.property.StringProperty;
+import javafx.css.PseudoClass;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontPosture;
+import javafx.scene.text.FontWeight;
+
+/// The base of the controls the user types text into.
+///
+/// The native component is a Codename One `TextField` or `TextArea`.
+/// The text property and the native text follow each other: setting the
+/// property shows the text, and whatever the user types, or anything
+/// else that changes the native text, sets the property and tells its
+/// listeners. The prompt text is the native hint, shown while the control
+/// is empty.
+///
+/// #### Caret and selection
+///
+/// The caret position, anchor and selection are kept by this class.
+/// A single line field shows the caret where the caret position says and
+/// reports the caret the user placed after each edit; the native editors
+/// have no selection highlight, so a selection is only what
+/// [#replaceSelection(String)], [#getSelectedText()] and the other
+/// methods here work on, never something the user sees or makes.
+/// Setting the text moves the caret to the start, as in JavaFX.
+///
+/// #### Not part of this layer
+///
+/// The clipboard methods, undo and redo, word navigation and
+/// `TextFormatter`.
+///
+/// #### Styling
+///
+/// Through `cn1ApplyStyle`, besides the region names:
+///
+/// - `-fx-text-fill`: `Paint`; only a plain `Color` is shown
+/// - `-fx-prompt-text-fill`: `Paint`; only a plain `Color` is shown
+/// - `-fx-font`: `Font`
+/// - `-fx-font-size`: `Number`, in logical pixels
+/// - `-fx-font-family`: `String`
+/// - `-fx-font-weight`: `FontWeight`, a `Number` or its name as a `String`
+/// - `-fx-font-style`: `FontPosture`, or `"italic"`, `"oblique"`,
+///   `"normal"`
+///
+/// The pseudo-class `readonly` is set while the control is not editable.
+public abstract class TextInputControl extends Control {
+
+    private static final int TEXT = Dirty.USER;
+    private static final int EDITABLE = Dirty.USER << 1;
+    private static final PseudoClass READONLY = PseudoClass.getPseudoClass("readonly");
+
+    private final StringProperty text = new FxString(this, "text", "", TEXT | Dirty.NATIVE);
+    private final StringProperty promptText = new FxString(this, "promptText", "", Dirty.NATIVE);
+    private final BooleanProperty editable = new FxBoolean(this, "editable", true, EDITABLE | Dirty.NATIVE);
+    private final ObjectProperty<Font> font = new FxObject<Font>(this, "font", null, Dirty.NATIVE | Dirty.LAYOUT);
+    private final ReadOnlyIntegerWrapper length = new ReadOnlyIntegerWrapper(this, "length", 0);
+    private final ReadOnlyIntegerWrapper anchor = new ReadOnlyIntegerWrapper(this, "anchor", 0);
+    private final ReadOnlyIntegerWrapper caretPosition = new ReadOnlyIntegerWrapper(this, "caretPosition", 0);
+    private final ReadOnlyObjectWrapper<IndexRange> selection = new ReadOnlyObjectWrapper<IndexRange>(this,
+            "selection", new IndexRange(0, 0));
+    private final ReadOnlyStringWrapper selectedText = new ReadOnlyStringWrapper(this, "selectedText", "");
+    private Paint textFill;
+    private Paint promptTextFill;
+    private boolean fillShown;
+    private int themeFill;
+    private int themeOpacity;
+    private boolean syncing;
+    private boolean fromNative;
+    private int pendingCaret = -1;
+
+    /// Creates a text input control.
+    protected TextInputControl() {
+        getStyleClass().add("text-input");
+    }
+
+    /// Returns the listener a subclass adds to its native text component:
+    /// it copies the native text into the text property.
+    final DataChangedListener textBridge() {
+        return new DataChangedListener() {
+            @Override
+            public void dataChanged(int type, int index) {
+                Component c = cn1NativeIfCreated();
+                if (syncing || text.isBound() || !(c instanceof com.codename1.ui.TextArea)) {
+                    return;
+                }
+                fromNative = true;
+                try {
+                    text.set(((com.codename1.ui.TextArea) c).getText());
+                } finally {
+                    fromNative = false;
+                }
+            }
+        };
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (!(c instanceof com.codename1.ui.TextArea)) {
+            return;
+        }
+        com.codename1.ui.TextArea area = (com.codename1.ui.TextArea) c;
+        syncing = true;
+        try {
+            String t = getText();
+            if (t == null) {
+                t = "";
+            }
+            if (!t.equals(area.getText())) {
+                area.setText(t);
+            }
+            String prompt = getPromptText();
+            if (prompt == null) {
+                prompt = "";
+            }
+            if (!prompt.equals(area.getHint()) && (prompt.length() > 0 || area.getHint() != null)) {
+                area.setHint(prompt);
+            }
+            if (area.isEditable() != isEditable()) {
+                area.setEditable(isEditable());
+            }
+            Style style = com.codename1.fxcompat.runtime.PeerPaint.allStyles(area);
+            if (textFill instanceof Color) {
+                if (!fillShown) {
+                    // Remembered so that withdrawing the fill shows the
+                    // theme's colour again.
+                    Style theme = area.getUnselectedStyle();
+                    themeFill = theme.getFgColor();
+                    themeOpacity = theme.getOpacity();
+                    fillShown = true;
+                }
+                int argb = ((Color) textFill).cn1Argb();
+                style.setFgColor(argb & 0xffffff);
+                style.setOpacity(argb >>> 24);
+            } else if (fillShown) {
+                fillShown = false;
+                style.setFgColor(themeFill);
+                style.setOpacity(themeOpacity);
+            }
+            Font f = font.get();
+            if (f != null) {
+                style.setFont(Fonts.of(f));
+            }
+            com.codename1.ui.Label hint = area.getHintLabel();
+            if (hint != null && promptTextFill instanceof Color) {
+                hint.getAllStyles().setFgColor(((Color) promptTextFill).cn1Argb() & 0xffffff);
+            }
+            if (hint != null && f != null) {
+                // The prompt is written in the font of the control: the
+                // hint is a label of its own, which otherwise keeps the
+                // theme's size beside a field given a larger one.
+                hint.getAllStyles().setFont(Fonts.of(f));
+            }
+        } finally {
+            syncing = false;
+        }
+        showCaret();
+    }
+
+    private void showCaret() {
+        Component c = cn1NativeIfCreated();
+        if (c instanceof com.codename1.ui.TextField && !fromNative) {
+            com.codename1.ui.TextField field = (com.codename1.ui.TextField) c;
+            if (field.getCursorPosition() != getCaretPosition()) {
+                field.setCursorPosition(getCaretPosition());
+            }
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & TEXT) != 0) {
+            String t = text.get();
+            int len = t == null ? 0 : t.length();
+            length.set(len);
+            int caret = 0;
+            if (pendingCaret >= 0) {
+                caret = pendingCaret;
+            } else if (fromNative) {
+                Component c = cn1NativeIfCreated();
+                caret = c instanceof com.codename1.ui.TextField
+                        ? ((com.codename1.ui.TextField) c).getCursorPosition() : len;
+            }
+            moveSelection(caret, caret);
+        }
+        if ((what & EDITABLE) != 0) {
+            pseudoClassStateChanged(READONLY, !isEditable());
+        }
+        if ((what & Dirty.NATIVE) != 0 && (what & Dirty.LAYOUT) != 0) {
+            Component c = cn1NativeIfCreated();
+            if (c != null) {
+                c.setShouldCalcPreferredSize(true);
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    private void moveSelection(int newAnchor, int newCaret) {
+        int len = getLength();
+        int a = Math.max(0, Math.min(len, newAnchor));
+        int c = Math.max(0, Math.min(len, newCaret));
+        anchor.set(a);
+        caretPosition.set(c);
+        IndexRange range = IndexRange.normalize(a, c);
+        if (!range.equals(selection.get())) {
+            selection.set(range);
+        }
+        String t = text.get();
+        selectedText.set(t == null || range.getLength() == 0 ? "" : t.substring(range.getStart(), range.getEnd()));
+    }
+
+    // -------------------------------------------------------------- text
+
+    /// Returns the text.
+    public final String getText() {
+        return text.get();
+    }
+
+    /// Sets the text and moves the caret to its start.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// The text of the control.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    /// Returns part of the text.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the start is after the end
+    /// - `IndexOutOfBoundsException`: when either is outside the text
+    public String getText(int start, int end) {
+        if (start > end) {
+            throw new IllegalArgumentException("The start must be <= the end");
+        }
+        if (start < 0 || end > getLength()) {
+            throw new IndexOutOfBoundsException();
+        }
+        String t = text.get();
+        return t == null ? "" : t.substring(start, end);
+    }
+
+    /// Returns the number of characters.
+    public final int getLength() {
+        return length.get();
+    }
+
+    /// The number of characters.
+    public final ReadOnlyIntegerProperty lengthProperty() {
+        return length.getReadOnlyProperty();
+    }
+
+    /// Adds text at the end and puts the caret after it.
+    public void appendText(String text) {
+        insertText(getLength(), text);
+    }
+
+    /// Inserts text at an index and puts the caret after it.
+    public void insertText(int index, String text) {
+        replaceText(index, index, text);
+    }
+
+    /// Deletes a range of the text.
+    public void deleteText(IndexRange range) {
+        replaceText(range, "");
+    }
+
+    /// Deletes the text between two indexes.
+    public void deleteText(int start, int end) {
+        replaceText(start, end, "");
+    }
+
+    /// Replaces a range of the text and puts the caret after the new
+    /// text.
+    public void replaceText(IndexRange range, String text) {
+        replaceText(range.getStart(), range.getEnd(), text);
+    }
+
+    /// Replaces the text between two indexes and puts the caret after the
+    /// new text. Does nothing while the text property is bound.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the start is after the end
+    /// - `NullPointerException`: when the text is `null`
+    /// - `IndexOutOfBoundsException`: when an index is outside the text
+    public void replaceText(int start, int end, String text) {
+        if (start > end) {
+            throw new IllegalArgumentException("The start must be <= the end");
+        }
+        if (text == null) {
+            throw new NullPointerException("The text must not be null");
+        }
+        if (start < 0 || end > getLength()) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (this.text.isBound()) {
+            return;
+        }
+        String old = this.text.get();
+        if (old == null) {
+            old = "";
+        }
+        int caret = start + text.length();
+        pendingCaret = caret;
+        try {
+            this.text.set(old.substring(0, start) + text + old.substring(end));
+        } finally {
+            pendingCaret = -1;
+        }
+        selectRange(caret, caret);
+    }
+
+    /// Removes all the text.
+    public void clear() {
+        deselect();
+        if (!text.isBound()) {
+            setText("");
+        }
+    }
+
+    // ---------------------------------------------------- caret, selection
+
+    /// Returns the position of the caret.
+    public final int getCaretPosition() {
+        return caretPosition.get();
+    }
+
+    /// The position of the caret.
+    public final ReadOnlyIntegerProperty caretPositionProperty() {
+        return caretPosition.getReadOnlyProperty();
+    }
+
+    /// Returns the end of the selection that is not the caret.
+    public final int getAnchor() {
+        return anchor.get();
+    }
+
+    /// The end of the selection that is not the caret.
+    public final ReadOnlyIntegerProperty anchorProperty() {
+        return anchor.getReadOnlyProperty();
+    }
+
+    /// Returns the selected range; empty at the caret without one.
+    public final IndexRange getSelection() {
+        return selection.get();
+    }
+
+    /// The selected range.
+    public final ReadOnlyObjectProperty<IndexRange> selectionProperty() {
+        return selection.getReadOnlyProperty();
+    }
+
+    /// Returns the selected text; empty without a selection.
+    public final String getSelectedText() {
+        return selectedText.get();
+    }
+
+    /// The selected text.
+    public final ReadOnlyStringProperty selectedTextProperty() {
+        return selectedText.getReadOnlyProperty();
+    }
+
+    /// Selects from an anchor to a caret position; both are kept inside
+    /// the text.
+    public void selectRange(int anchor, int caretPosition) {
+        moveSelection(anchor, caretPosition);
+        showCaret();
+    }
+
+    /// Moves the caret, dropping the selection.
+    public void positionCaret(int pos) {
+        selectRange(pos, pos);
+    }
+
+    /// Moves the caret, keeping the anchor.
+    public void selectPositionCaret(int pos) {
+        selectRange(getAnchor(), pos);
+    }
+
+    /// Extends the selection to a position: the end of the selection
+    /// farther from it becomes the anchor.
+    public void extendSelection(int pos) {
+        int p = Math.max(0, Math.min(getLength(), pos));
+        int dot = getCaretPosition();
+        int mark = getAnchor();
+        int start = Math.min(dot, mark);
+        int end = Math.max(dot, mark);
+        if (p < start) {
+            selectRange(end, p);
+        } else {
+            selectRange(start, p);
+        }
+    }
+
+    /// Selects all the text.
+    public void selectAll() {
+        selectRange(0, getLength());
+    }
+
+    /// Drops the selection, leaving the caret where it is.
+    public void deselect() {
+        selectRange(getCaretPosition(), getCaretPosition());
+    }
+
+    /// Moves the caret to the start.
+    public void home() {
+        selectRange(0, 0);
+    }
+
+    /// Moves the caret to the end.
+    public void end() {
+        int len = getLength();
+        selectRange(len, len);
+    }
+
+    /// Moves the caret to the start, keeping the anchor.
+    public void selectHome() {
+        selectRange(getAnchor(), 0);
+    }
+
+    /// Moves the caret to the end, keeping the anchor.
+    public void selectEnd() {
+        selectRange(getAnchor(), getLength());
+    }
+
+    /// Moves the caret one character on; with a selection, to its end.
+    public void forward() {
+        int len = getLength();
+        int dot = getCaretPosition();
+        int mark = getAnchor();
+        if (dot != mark) {
+            int pos = Math.max(dot, mark);
+            selectRange(pos, pos);
+        } else if (dot < len) {
+            selectRange(dot + 1, dot + 1);
+        }
+    }
+
+    /// Moves the caret one character back; with a selection, to its
+    /// start.
+    public void backward() {
+        int dot = getCaretPosition();
+        int mark = getAnchor();
+        if (dot != mark) {
+            int pos = Math.min(dot, mark);
+            selectRange(pos, pos);
+        } else if (dot > 0) {
+            selectRange(dot - 1, dot - 1);
+        }
+    }
+
+    /// Moves the caret one character on, keeping the anchor.
+    public void selectForward() {
+        if (getCaretPosition() < getLength()) {
+            selectRange(getAnchor(), getCaretPosition() + 1);
+        }
+    }
+
+    /// Moves the caret one character back, keeping the anchor.
+    public void selectBackward() {
+        if (getCaretPosition() > 0) {
+            selectRange(getAnchor(), getCaretPosition() - 1);
+        }
+    }
+
+    /// Replaces the selection, or inserts at the caret without one.
+    public void replaceSelection(String replacement) {
+        IndexRange range = getSelection();
+        replaceText(range.getStart(), range.getEnd(), replacement);
+    }
+
+    /// Deletes the selection, or without one the character before the
+    /// caret. Answers whether anything was deleted.
+    public boolean deletePreviousChar() {
+        if (!isEditable() || isDisabled()) {
+            return false;
+        }
+        IndexRange range = getSelection();
+        if (range.getLength() > 0) {
+            replaceText(range.getStart(), range.getEnd(), "");
+            return true;
+        }
+        int dot = getCaretPosition();
+        if (dot == 0) {
+            return false;
+        }
+        replaceText(dot - 1, dot, "");
+        return true;
+    }
+
+    /// Deletes the selection, or without one the character after the
+    /// caret. Answers whether anything was deleted.
+    public boolean deleteNextChar() {
+        if (!isEditable() || isDisabled()) {
+            return false;
+        }
+        IndexRange range = getSelection();
+        if (range.getLength() > 0) {
+            replaceText(range.getStart(), range.getEnd(), "");
+            return true;
+        }
+        int dot = getCaretPosition();
+        if (dot >= getLength()) {
+            return false;
+        }
+        replaceText(dot, dot + 1, "");
+        return true;
+    }
+
+    // -------------------------------------------------------- properties
+
+    /// Returns the text shown while the control is empty.
+    public final String getPromptText() {
+        return promptText.get();
+    }
+
+    /// Sets the text shown while the control is empty.
+    public final void setPromptText(String value) {
+        promptText.set(value);
+    }
+
+    /// The text shown while the control is empty.
+    public final StringProperty promptTextProperty() {
+        return promptText;
+    }
+
+    /// Returns whether the user can change the text.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// Sets whether the user can change the text.
+    public final void setEditable(boolean value) {
+        editable.set(value);
+    }
+
+    /// Whether the user can change the text.
+    public final BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Returns the font; the default font when none was set.
+    public final Font getFont() {
+        Font f = font.get();
+        return f == null ? Font.getDefault() : f;
+    }
+
+    /// Sets the font.
+    public final void setFont(Font value) {
+        font.set(value);
+    }
+
+    /// The font of the text.
+    public final ObjectProperty<Font> fontProperty() {
+        return font;
+    }
+
+    // ------------------------------------------------------------ styling
+
+    private void restyleNative() {
+        cn1Invalidated(Dirty.NATIVE);
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-text-fill".equals(property)) {
+            return textFill;
+        } else if ("-fx-prompt-text-fill".equals(property)) {
+            return promptTextFill;
+        } else if ("-fx-font".equals(property) || "-fx-font-size".equals(property)
+                || "-fx-font-family".equals(property) || "-fx-font-weight".equals(property)
+                || "-fx-font-style".equals(property)) {
+            return font.get();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    private static FontWeight weight(Object value) {
+        if (value instanceof FontWeight) {
+            return (FontWeight) value;
+        } else if (value instanceof Number) {
+            return FontWeight.findByWeight(((Number) value).intValue());
+        } else if (value instanceof String) {
+            return FontWeight.findByName(((String) value).trim());
+        }
+        return null;
+    }
+
+    private static FontPosture posture(Object value) {
+        if (value instanceof FontPosture) {
+            return (FontPosture) value;
+        } else if (value instanceof String) {
+            String s = ((String) value).trim();
+            if ("italic".equalsIgnoreCase(s) || "oblique".equalsIgnoreCase(s)) {
+                return FontPosture.ITALIC;
+            } else if ("normal".equalsIgnoreCase(s) || "regular".equalsIgnoreCase(s)) {
+                return FontPosture.REGULAR;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-text-fill".equals(property)) {
+            if (value != null && !(value instanceof Paint)) {
+                return false;
+            }
+            textFill = (Paint) value;
+            restyleNative();
+        } else if ("-fx-prompt-text-fill".equals(property)) {
+            if (value != null && !(value instanceof Paint)) {
+                return false;
+            }
+            promptTextFill = (Paint) value;
+            restyleNative();
+        } else if (property.startsWith("-fx-font")) {
+            // Restoring any of the font names restores the whole font.
+            if (value == null || value instanceof Font) {
+                setFont((Font) value);
+                return true;
+            }
+            Font base = getFont();
+            FontWeight w = base.cn1Weight();
+            FontPosture p = base.cn1Posture();
+            String family = base.getFamily();
+            double size = base.getSize();
+            if ("-fx-font-size".equals(property) && value instanceof Number) {
+                size = ((Number) value).doubleValue();
+            } else if ("-fx-font-family".equals(property) && value instanceof String) {
+                family = (String) value;
+            } else if ("-fx-font-weight".equals(property) && weight(value) != null) {
+                w = weight(value);
+            } else if ("-fx-font-style".equals(property) && posture(value) != null) {
+                p = posture(value);
+            } else {
+                return false;
+            }
+            setFont(Font.font(family, w, p, size));
+        } else {
+            return super.cn1SetStyleValue(property, value);
+        }
+        return true;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TextInputDialog.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TextInputDialog.java
new file mode 100644
index 00000000000..e6eb97fa9d9
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TextInputDialog.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.NamedArg;
+import javafx.scene.control.ButtonBar.ButtonData;
+import javafx.util.Callback;
+
+/// A dialog that asks for a line of text. It has an OK and a Cancel
+/// button and answers with the text when OK is chosen, with nothing
+/// otherwise.
+///
+/// The content text is shown as a label left of the field. The field is
+/// a Codename One text field owned by the dialog; `getEditor()` of JavaFX
+/// is absent, since it returns a `TextField` control this dialog does not
+/// use.
+public class TextInputDialog extends Dialog<String> {
+
+    private final String defaultValue;
+    private final DialogField field;
+
+    /// Creates a dialog with an empty field.
+    public TextInputDialog() {
+        this("");
+    }
+
+    /// Creates a dialog whose field starts with a text.
+    public TextInputDialog(@NamedArg("defaultValue") String defaultValue) {
+        this.defaultValue = defaultValue == null ? "" : defaultValue;
+        field = new DialogField(this.defaultValue);
+        DialogRow row = new DialogRow(field);
+        DialogPane pane = getDialogPane();
+        pane.contentTextProperty().addListener(row);
+        pane.getStyleClass().add("text-input-dialog");
+        pane.setContent(row);
+        pane.getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);
+        setTitle("Confirmation");
+        pane.setHeaderText("Confirmation");
+        setResultConverter(new Callback<ButtonType, String>() {
+            @Override
+            public String call(ButtonType chosen) {
+                ButtonData data = chosen == null ? null : chosen.getButtonData();
+                return data == ButtonData.OK_DONE ? field.text() : null;
+            }
+        });
+    }
+
+    /// Returns the text the field started with.
+    public final String getDefaultValue() {
+        return defaultValue;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TitledPane.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TitledPane.java
new file mode 100644
index 00000000000..4de1879e613
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TitledPane.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.css.PseudoClass;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Polygon;
+
+/// A panel with a title that opens and closes it.
+///
+/// The title is a bar with an arrow, the graphic and the text; a press on
+/// it opens or closes the panel when it is collapsible. A style sheet
+/// reaches the bar as `.titled-pane > .title`, the arrow in it as
+/// `.arrow` and the area of the content as `.titled-pane > .content`. The
+/// pseudo-classes `expanded` and `collapsed` follow the state.
+///
+/// The panel opens and closes at once: `animated` is recorded and nothing
+/// slides.
+public class TitledPane extends Labeled {
+
+    private static final PseudoClass EXPANDED = PseudoClass.getPseudoClass("expanded");
+    private static final PseudoClass COLLAPSED = PseudoClass.getPseudoClass("collapsed");
+
+    private final ObjectProperty<Node> content = new SimpleObjectProperty<Node>(this, "content");
+    private final BooleanProperty expanded = new SimpleBooleanProperty(this, "expanded", true);
+    private final BooleanProperty animated = new SimpleBooleanProperty(this, "animated", true);
+    private final BooleanProperty collapsible = new SimpleBooleanProperty(this, "collapsible", true);
+    private final Label title = new Label();
+    private final Polygon arrow = new Polygon(0, 0, 8, 4, 0, 8);
+    private final HBox bar = new Bar();
+    private final StackPane area = new Area();
+
+    /// The title bar, drawn as the standard theme draws it.
+    private static final class Bar extends HBox {
+        Bar() {
+            super(6);
+        }
+
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-background-color: -fx-box-border, derive(-fx-color, 50%), linear-gradient(to bottom,"
+                    + " derive(-fx-color, 8%), derive(-fx-color, -8%)); -fx-background-insets: 0, 1, 2;"
+                    + " -fx-padding: 0.3333em 0.75em 0.3333em 0.75em;";
+        }
+    }
+
+    /// What holds the content, with the border around three sides.
+    private static final class Area extends StackPane {
+        @Override
+        public String cn1DefaultStyle() {
+            return "-fx-background-color: -fx-box-border, -fx-background; -fx-background-insets: 0, 0 1 1 1;"
+                    + " -fx-padding: 0.167em;";
+        }
+    }
+    private final VBox whole = new VBox(bar, area);
+
+    /// Creates a panel with no title and no content.
+    public TitledPane() {
+        getStyleClass().add("titled-pane");
+        setFocusTraversable(false);
+        setMnemonicParsing(false);
+        bar.getStyleClass().add("title");
+        bar.setAlignment(Pos.CENTER_LEFT);
+        arrow.getStyleClass().add("arrow");
+        arrow.setFill(Color.gray(0.2));
+        arrow.setRotate(90);
+        title.textProperty().bind(textProperty());
+        title.graphicProperty().bind(graphicProperty());
+        bar.getChildren().addAll(arrow, title);
+        area.getStyleClass().add("content");
+        VBox.setVgrow(area, Priority.ALWAYS);
+        bar.addEventHandler(MouseEvent.MOUSE_CLICKED, e -> {
+            if (isCollapsible() && !isDisabled()) {
+                setExpanded(!isExpanded());
+                e.consume();
+            }
+        });
+        content.addListener((observable, was, now) -> {
+            if (now == null) {
+                area.getChildren().clear();
+            } else {
+                area.getChildren().setAll(now);
+            }
+        });
+        expanded.addListener((observable, was, now) -> shown());
+        collapsible.addListener((observable, was, now) -> shown());
+        shown();
+        cn1MadeOf(whole);
+    }
+
+    /// Creates a panel with a title and a content.
+    public TitledPane(String title, Node content) {
+        this();
+        setText(title);
+        setContent(content);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    /// The graphic is shown by the title, not beside a text of the
+    /// panel's own.
+    @Override
+    boolean ownsGraphic() {
+        return true;
+    }
+
+    private void shown() {
+        boolean open = isExpanded();
+        pseudoClassStateChanged(EXPANDED, open);
+        pseudoClassStateChanged(COLLAPSED, !open);
+        arrow.setRotate(open ? 90 : 0);
+        arrow.setVisible(isCollapsible());
+        arrow.setManaged(isCollapsible());
+        area.setVisible(open);
+        area.setManaged(open);
+        requestLayout();
+        if (getParent() != null) {
+            getParent().requestLayout();
+        }
+    }
+
+    /// A panel takes the room it is given; closed, it is as tall as its
+    /// title.
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return isExpanded() ? Double.MAX_VALUE : computePrefHeight(width);
+    }
+
+    /// Returns what the panel shows below its title.
+    public final Node getContent() {
+        return content.get();
+    }
+
+    /// Sets what the panel shows below its title.
+    public final void setContent(Node value) {
+        content.set(value);
+    }
+
+    /// What the panel shows below its title.
+    public final ObjectProperty<Node> contentProperty() {
+        return content;
+    }
+
+    /// Returns whether the panel is open.
+    public final boolean isExpanded() {
+        return expanded.get();
+    }
+
+    /// Opens or closes the panel.
+    public final void setExpanded(boolean value) {
+        expanded.set(value);
+    }
+
+    /// Whether the panel is open.
+    public final BooleanProperty expandedProperty() {
+        return expanded;
+    }
+
+    /// Returns whether opening and closing is asked to be animated.
+    public final boolean isAnimated() {
+        return animated.get();
+    }
+
+    /// Records whether opening and closing is to be animated; it is not.
+    public final void setAnimated(boolean value) {
+        animated.set(value);
+    }
+
+    /// Whether opening and closing is asked to be animated.
+    public final BooleanProperty animatedProperty() {
+        return animated;
+    }
+
+    /// Returns whether a press on the title opens and closes the panel.
+    public final boolean isCollapsible() {
+        return collapsible.get();
+    }
+
+    /// Sets whether a press on the title opens and closes the panel.
+    public final void setCollapsible(boolean value) {
+        collapsible.set(value);
+    }
+
+    /// Whether a press on the title opens and closes the panel.
+    public final BooleanProperty collapsibleProperty() {
+        return collapsible;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Toggle.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Toggle.java
new file mode 100644
index 00000000000..317369000b7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Toggle.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.ObservableMap;
+
+/// Something that is either selected or not and can belong to a
+/// [ToggleGroup], of which at most one member is selected.
+public interface Toggle {
+
+    /// Returns the group this toggle belongs to, or `null`.
+    ToggleGroup getToggleGroup();
+
+    /// Moves this toggle into a group, or out of any with `null`.
+    void setToggleGroup(ToggleGroup toggleGroup);
+
+    /// The group this toggle belongs to.
+    ObjectProperty<ToggleGroup> toggleGroupProperty();
+
+    /// Returns whether this toggle is selected.
+    boolean isSelected();
+
+    /// Selects or deselects this toggle.
+    void setSelected(boolean selected);
+
+    /// Whether this toggle is selected.
+    BooleanProperty selectedProperty();
+
+    /// Returns the object the application attached, or `null`.
+    Object getUserData();
+
+    /// Attaches an object of the application's.
+    void setUserData(Object value);
+
+    /// Returns the map of properties the application attached.
+    ObservableMap<Object, Object> getProperties();
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ToggleButton.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ToggleButton.java
new file mode 100644
index 00000000000..6d5fb4900be
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ToggleButton.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.ui.Component;
+import com.codename1.ui.plaf.Border;
+import com.codename1.ui.plaf.Style;
+import com.codename1.ui.plaf.UIManager;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.css.PseudoClass;
+import javafx.event.ActionEvent;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+
+/// A button that stays selected until it is pressed again, shown as a
+/// Codename One toggle button.
+///
+/// In a [ToggleGroup] selecting it deselects the group's selected toggle;
+/// unlike a [RadioButton] it can be deselected by pressing it, leaving
+/// the group with nothing selected. The `selected` pseudo-class follows
+/// the selected property.
+public class ToggleButton extends ButtonBase implements Toggle {
+
+    private static final int SELECTED = Dirty.USER;
+    private static final PseudoClass SELECTED_STATE = PseudoClass.getPseudoClass("selected");
+
+    private final BooleanProperty selected = new FxBoolean(this, "selected", false, SELECTED | Dirty.NATIVE);
+    private final ObjectProperty<ToggleGroup> toggleGroup = new SimpleObjectProperty<ToggleGroup>(this,
+            "toggleGroup") {
+        private ToggleGroup joined;
+
+        @Override
+        protected void invalidated() {
+            ToggleGroup now = get();
+            if (now == joined) {
+                return;
+            }
+            ToggleGroup was = joined;
+            joined = now;
+            if (was != null) {
+                was.getToggles().remove(ToggleButton.this);
+            }
+            if (now != null && !now.getToggles().contains(ToggleButton.this)) {
+                now.getToggles().add(ToggleButton.this);
+            }
+        }
+    };
+
+    /// Creates a toggle button with no text.
+    public ToggleButton() {
+        init();
+    }
+
+    /// Creates a toggle button with text.
+    public ToggleButton(String text) {
+        super(text);
+        init();
+    }
+
+    /// Creates a toggle button with text and a graphic.
+    public ToggleButton(String text, Node graphic) {
+        super(text, graphic);
+        init();
+    }
+
+    private void init() {
+        getStyleClass().add("toggle-button");
+        // The text of a button is centred unless the application says otherwise.
+        setAlignment(Pos.CENTER);
+    }
+
+    /// Whether the theme says nothing about a component name: its style
+    /// is the one a name no theme knows gets, so nothing tells such a
+    /// component from the form behind it.
+    static boolean unstyled(String uiid) {
+        Style s = UIManager.getInstance().getComponentStyle(uiid);
+        Style none = UIManager.getInstance().getComponentStyle("FxNoSuchComponent");
+        return s.getBgColor() == none.getBgColor() && s.getBgTransparency() == none.getBgTransparency()
+                && s.getBgImage() == none.getBgImage() && sameBorder(s.getBorder(), none.getBorder())
+                && s.getPaddingTop() == none.getPaddingTop()
+                && s.getPaddingLeftNoRTL() == none.getPaddingLeftNoRTL();
+    }
+
+    private static boolean sameBorder(Border a, Border b) {
+        boolean noA = a == null || a.isEmptyBorder();
+        boolean noB = b == null || b.isEmptyBorder();
+        return a == b || (noA && noB);
+    }
+
+    @Override
+    boolean cn1OwnsChrome() {
+        return true;
+    }
+
+    @Override
+    public String cn1ThemedStyle() {
+        return cn1StandardLook(isSelected(), false);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        com.codename1.ui.CheckBox b = new com.codename1.ui.CheckBox();
+        b.setToggle(true);
+        if (unstyled(b.getUIID())) {
+            // A theme with no look for a toggle button, as the desktop
+            // themes are, would leave bare text with no sign of being
+            // selected. The toggle then takes the look of a push button,
+            // which Codename One draws pressed while it is selected.
+            b.setUIID("Button");
+        }
+        b.addActionListener(cn1ActionBridge());
+        return b;
+    }
+
+    @Override
+    protected void cn1SyncNative() {
+        super.cn1SyncNative();
+        Component c = cn1NativeIfCreated();
+        if (c instanceof com.codename1.ui.CheckBox) {
+            ((com.codename1.ui.CheckBox) c).setSelected(isSelected());
+        } else if (c instanceof com.codename1.ui.RadioButton) {
+            ((com.codename1.ui.RadioButton) c).setSelected(isSelected());
+        }
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & SELECTED) != 0) {
+            boolean now = isSelected();
+            pseudoClassStateChanged(SELECTED_STATE, now);
+            ToggleGroup group = getToggleGroup();
+            if (group != null) {
+                if (now) {
+                    group.selectToggle(this);
+                } else if (group.getSelectedToggle() == this) {
+                    group.clearSelectedToggle();
+                }
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    /// Flips the selected state and fires an `ActionEvent`.
+    @Override
+    public void fire() {
+        if (!isDisabled()) {
+            setSelected(!isSelected());
+            fireEvent(new ActionEvent(this, this));
+        }
+    }
+
+    @Override
+    public final boolean isSelected() {
+        return selected.get();
+    }
+
+    @Override
+    public final void setSelected(boolean value) {
+        selected.set(value);
+    }
+
+    @Override
+    public final BooleanProperty selectedProperty() {
+        return selected;
+    }
+
+    @Override
+    public final ToggleGroup getToggleGroup() {
+        return toggleGroup.get();
+    }
+
+    @Override
+    public final void setToggleGroup(ToggleGroup value) {
+        toggleGroup.set(value);
+    }
+
+    @Override
+    public final ObjectProperty<ToggleGroup> toggleGroupProperty() {
+        return toggleGroup;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ToggleGroup.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ToggleGroup.java
new file mode 100644
index 00000000000..73f5f405279
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ToggleGroup.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.List;
+
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+
+/// A set of toggles of which at most one is selected: selecting one
+/// deselects the one that was.
+///
+/// A toggle joins through `Toggle.setToggleGroup` or by being added to
+/// [#getToggles()]; either way both sides agree afterwards.
+public class ToggleGroup {
+
+    private final ObservableList<Toggle> toggles = FXCollections.observableArrayList();
+    private final ReadOnlyObjectWrapper<Toggle> selectedToggle = new ReadOnlyObjectWrapper<Toggle>(this,
+            "selectedToggle");
+    private Object userData;
+    private ObservableMap<Object, Object> properties;
+
+    /// Creates an empty group.
+    public ToggleGroup() {
+        toggles.addListener(new ListChangeListener<Toggle>() {
+            @Override
+            public void onChanged(Change<? extends Toggle> change) {
+                togglesChanged(change);
+            }
+        });
+    }
+
+    private void togglesChanged(ListChangeListener.Change<? extends Toggle> change) {
+        while (change.next()) {
+            List<? extends Toggle> removed = change.getRemoved();
+            for (int i = 0; i < removed.size(); i++) {
+                Toggle t = removed.get(i);
+                if (t == null || toggles.contains(t)) {
+                    continue;
+                }
+                if (selectedToggle.get() == t) {
+                    selectedToggle.set(null);
+                }
+                if (t.getToggleGroup() == this) {
+                    t.setToggleGroup(null);
+                }
+            }
+            List<? extends Toggle> added = change.getAddedSubList();
+            for (int i = 0; i < added.size(); i++) {
+                Toggle t = added.get(i);
+                if (t == null) {
+                    continue;
+                }
+                if (t.getToggleGroup() != this) {
+                    t.setToggleGroup(this);
+                }
+                if (t.isSelected()) {
+                    selectToggle(t);
+                }
+            }
+        }
+    }
+
+    /// Returns the toggles of this group.
+    public final ObservableList<Toggle> getToggles() {
+        return toggles;
+    }
+
+    /// Selects a toggle, deselecting the one that was selected; `null`
+    /// deselects it and leaves nothing selected. A toggle of another group
+    /// is ignored.
+    public final void selectToggle(Toggle value) {
+        Toggle old = selectedToggle.get();
+        if (old == value) {
+            return;
+        }
+        if (value != null && value.getToggleGroup() != this) {
+            return;
+        }
+        selectedToggle.set(value);
+        if (old != null && old.getToggleGroup() == this && old.isSelected()) {
+            old.setSelected(false);
+        }
+        if (value != null && !value.isSelected()) {
+            value.setSelected(true);
+        }
+    }
+
+    /// The selected toggle, or `null`.
+    public final ReadOnlyObjectProperty<Toggle> selectedToggleProperty() {
+        return selectedToggle.getReadOnlyProperty();
+    }
+
+    /// Returns the selected toggle, or `null`.
+    public final Toggle getSelectedToggle() {
+        return selectedToggle.get();
+    }
+
+    /// Forgets the selected toggle after it was deselected directly.
+    final void clearSelectedToggle() {
+        selectedToggle.set(null);
+    }
+
+    /// Returns the map of properties the application attached.
+    public final ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    /// Returns whether any property was attached.
+    public boolean hasProperties() {
+        return properties != null && !properties.isEmpty();
+    }
+
+    /// Attaches an object of the application's.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns the object the application attached, or `null`.
+    public Object getUserData() {
+        return userData;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/ToolBar.java b/maven/javafx-compat/src/main/java/javafx/scene/control/ToolBar.java
new file mode 100644
index 00000000000..e363b77139e
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/ToolBar.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.ui.Component;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.css.PseudoClass;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.VBox;
+
+/// A bar of controls, in a row or in a column.
+///
+/// The items are laid out one after the other at their preferred sizes,
+/// centred across the bar, on the standard theme's bar: a gradient of the
+/// base colour over a line of the border colour. A style sheet reaches
+/// the bar as `.tool-bar` and sets its spacing with `-fx-spacing` on it.
+///
+/// Items that do not fit are cut off at the end of the bar: there is no
+/// overflow button with a menu of them.
+public class ToolBar extends Control {
+
+    private static final int ORIENTATION = Dirty.USER;
+    private static final PseudoClass HORIZONTAL = PseudoClass.getPseudoClass("horizontal");
+    private static final PseudoClass VERTICAL = PseudoClass.getPseudoClass("vertical");
+
+    private final ObservableList<Node> items = FXCollections.observableArrayList();
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, ORIENTATION | Dirty.LAYOUT);
+    private final HBox row = new HBox();
+    private final VBox column = new VBox();
+    private double spacing = 4;
+
+    /// Creates a bar without items.
+    public ToolBar() {
+        this((Node[]) null);
+    }
+
+    /// Creates a bar of items.
+    public ToolBar(Node... items) {
+        getStyleClass().add("tool-bar");
+        setFocusTraversable(false);
+        pseudoClassStateChanged(HORIZONTAL, true);
+        row.setAlignment(Pos.CENTER_LEFT);
+        column.setAlignment(Pos.TOP_CENTER);
+        this.items.addListener((ListChangeListener<Node>) change -> rebuild());
+        if (items != null) {
+            this.items.addAll(items);
+        }
+        rebuild();
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public String cn1DefaultStyle() {
+        return "-fx-background-color: -fx-box-border, linear-gradient(to bottom, derive(-fx-base, 46.9%),"
+                + " derive(-fx-base, -2.1%)); -fx-background-insets: 0, 0 0 1 0;"
+                + " -fx-padding: 0.416667em 0.833333em 0.416667em 0.833333em; -fx-spacing: 0.333em;";
+    }
+
+    private void rebuild() {
+        boolean upright = getOrientation() == Orientation.VERTICAL;
+        Pane holder = upright ? column : row;
+        Pane other = upright ? row : column;
+        other.getChildren().clear();
+        holder.getChildren().setAll(items);
+        row.setSpacing(spacing);
+        column.setSpacing(spacing);
+        if (cn1Made() != holder) {
+            cn1MadeOf(holder);
+        }
+        requestLayout();
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & ORIENTATION) != 0) {
+            boolean upright = getOrientation() == Orientation.VERTICAL;
+            pseudoClassStateChanged(VERTICAL, upright);
+            pseudoClassStateChanged(HORIZONTAL, !upright);
+            rebuild();
+        }
+        super.cn1Invalidated(what);
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-spacing".equals(property)) {
+            return Double.valueOf(spacing);
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-spacing".equals(property)) {
+            if (value instanceof Number) {
+                spacing = ((Number) value).doubleValue();
+                row.setSpacing(spacing);
+                column.setSpacing(spacing);
+            }
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+
+    /// A bar is as long as it is given room for.
+    @Override
+    protected double computeMaxWidth(double height) {
+        return getOrientation() == Orientation.VERTICAL ? computePrefWidth(height) : Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return getOrientation() == Orientation.VERTICAL ? Double.MAX_VALUE : computePrefHeight(width);
+    }
+
+    /// A bar may be made shorter than its items, which are then cut off.
+    @Override
+    protected double computeMinWidth(double height) {
+        return getOrientation() == Orientation.VERTICAL ? computePrefWidth(height) : 0;
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return getOrientation() == Orientation.VERTICAL ? 0 : computePrefHeight(width);
+    }
+
+    /// Returns the items of the bar, in the order they are shown.
+    public final ObservableList<Node> getItems() {
+        return items;
+    }
+
+    /// Returns whether the bar is a row or a column.
+    public final Orientation getOrientation() {
+        return orientation.get();
+    }
+
+    /// Makes the bar a row or a column.
+    public final void setOrientation(Orientation value) {
+        orientation.set(value == null ? Orientation.HORIZONTAL : value);
+    }
+
+    /// Whether the bar is a row or a column.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/Tooltip.java b/maven/javafx-compat/src/main/java/javafx/scene/control/Tooltip.java
new file mode 100644
index 00000000000..7d4f56e86c5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/Tooltip.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.TooltipManager;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.scene.Node;
+
+/// A short text shown while the pointer rests on a node.
+///
+/// The text is handed to Codename One, which shows its own tooltip for
+/// the component of the node: [#install(Node, Tooltip)] sets it on the
+/// native component of a control, or on the peer of any other node, and
+/// a later change of the text follows. So the tooltip looks and is timed
+/// as Codename One's are, on the platforms that have a pointer to hover
+/// with. This object is never opened as a popup itself, and the graphic,
+/// the wrapping, the delays and the font of the JavaFX tooltip are not
+/// part of this layer.
+///
+/// The first tooltip installed turns the tooltips of Codename One on.
+public class Tooltip extends PopupControl {
+
+    private static final String KEY = "cn1.fx.tooltip";
+    private static boolean enabled;
+
+    private final StringProperty text = new SimpleStringProperty(this, "text", "");
+    private final ArrayList<Node> nodes = new ArrayList<Node>();
+    private final javafx.beans.property.ObjectProperty<Node> graphic =
+            new javafx.beans.property.SimpleObjectProperty<Node>(this, "graphic");
+
+    /// Creates a tooltip with no text.
+    public Tooltip() {
+        this(null);
+    }
+
+    /// Creates a tooltip with a text.
+    public Tooltip(String text) {
+        getStyleClass().add("tooltip");
+        this.text.set(text == null ? "" : text);
+        this.text.addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
+                for (int i = 0; i < nodes.size(); i++) {
+                    apply(nodes.get(i), newValue);
+                }
+            }
+        });
+    }
+
+    /// Sets the text shown.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// Returns the text shown.
+    public final String getText() {
+        return text.get();
+    }
+
+    /// The text shown.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    private static Component target(Node node) {
+        Component c = node instanceof Control ? ((Control) node).cn1Native() : null;
+        return c != null ? c : node.cn1Peer();
+    }
+
+    private static void apply(Node node, String text) {
+        Component c = target(node);
+        if (c != null) {
+            c.setTooltip(text == null || text.length() == 0 ? null : text);
+        }
+    }
+
+    private static void enable() {
+        if (!enabled) {
+            enabled = true;
+            TooltipManager.enableTooltips();
+        }
+    }
+
+    /// Shows a tooltip for a node; it replaces one installed before.
+    public static void install(Node node, Tooltip t) {
+        if (node == null) {
+            return;
+        }
+        Object old = node.getProperties().get(KEY);
+        if (old instanceof Tooltip && old != t) {
+            ((Tooltip) old).nodes.remove(node);
+        }
+        if (t == null) {
+            node.getProperties().remove(KEY);
+            apply(node, null);
+            return;
+        }
+        enable();
+        node.getProperties().put(KEY, t);
+        if (!t.nodes.contains(node)) {
+            t.nodes.add(node);
+        }
+        apply(node, t.getText());
+    }
+
+    /// Stops showing a tooltip for a node.
+    public static void uninstall(Node node, Tooltip t) {
+        if (node == null) {
+            return;
+        }
+        Object old = node.getProperties().get(KEY);
+        if (t != null) {
+            t.nodes.remove(node);
+        }
+        if (old == t || t == null) {
+            if (old instanceof Tooltip) {
+                ((Tooltip) old).nodes.remove(node);
+            }
+            node.getProperties().remove(KEY);
+            apply(node, null);
+        }
+    }
+
+    @Override
+    public String getTypeSelector() {
+        return "Tooltip";
+    }
+
+    /// Sets the graphic; recorded, a tooltip shows its text only.
+    public final void setGraphic(Node value) {
+        graphic.set(value);
+    }
+
+    /// Returns the graphic.
+    public final Node getGraphic() {
+        return graphic.get();
+    }
+
+    /// The graphic; recorded.
+    public final javafx.beans.property.ObjectProperty<Node> graphicProperty() {
+        return graphic;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TreeCell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TreeCell.java
new file mode 100644
index 00000000000..f2e7ccd5911
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TreeCell.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import com.codename1.fxcompat.runtime.Dirty;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.css.PseudoClass;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.layout.StackPane;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Polygon;
+
+/// A cell of a [TreeView]. An application subclasses it and overrides
+/// `updateItem` to decide what a row looks like; the item is the value of
+/// the [TreeItem] of the row, which [#getTreeItem()] answers.
+///
+/// Before its graphic and text a cell keeps the indent of its depth and,
+/// for an item with children, the disclosure node: an arrow that points
+/// right while the item is closed and down while it is open. The
+/// pseudo-class states `expanded` and `collapsed` follow the item.
+public class TreeCell<T> extends IndexedCell<T> {
+
+    private static final PseudoClass EXPANDED = PseudoClass.getPseudoClass("expanded");
+    private static final PseudoClass COLLAPSED = PseudoClass.getPseudoClass("collapsed");
+
+    /// The width kept for one level of depth, and for the arrow.
+    static final double INDENT = 18;
+
+    private final ReadOnlyObjectWrapper<TreeItem<T>> treeItem = new ReadOnlyObjectWrapper<TreeItem<T>>(this,
+            "treeItem");
+    private final ReadOnlyObjectWrapper<TreeView<T>> treeView = new ReadOnlyObjectWrapper<TreeView<T>>(this,
+            "treeView");
+    private final ObjectProperty<Node> disclosureNode = new SimpleObjectProperty<Node>(this, "disclosureNode");
+    private final Polygon arrow = new Polygon();
+    private boolean stale = true;
+    private boolean open;
+    private boolean branch;
+    private int level;
+
+    /// Creates a cell that belongs to no tree yet.
+    public TreeCell() {
+        getStyleClass().add("tree-cell");
+        disclosureNode.addListener((observable, was, now) -> {
+            if (was != null) {
+                cn1Children().remove(was);
+            }
+            if (now != null && !cn1Children().contains(now)) {
+                cn1Children().add(now);
+            }
+            requestLayout();
+        });
+        arrow.setFill(Color.gray(0.3));
+        arrow.getStyleClass().add("arrow");
+        StackPane node = new StackPane(arrow);
+        node.getStyleClass().add("tree-disclosure-node");
+        node.setMouseTransparent(true);
+        setDisclosureNode(node);
+        shape();
+    }
+
+    private void shape() {
+        if (open) {
+            arrow.getPoints().setAll(Double.valueOf(0), Double.valueOf(0), Double.valueOf(8), Double.valueOf(0),
+                    Double.valueOf(4), Double.valueOf(5));
+        } else {
+            arrow.getPoints().setAll(Double.valueOf(0), Double.valueOf(0), Double.valueOf(5), Double.valueOf(4),
+                    Double.valueOf(0), Double.valueOf(8));
+        }
+    }
+
+    @Override
+    double leading() {
+        return (level + 1) * INDENT;
+    }
+
+    /// Where the arrow area of this cell starts, from its left edge.
+    final double arrowStart() {
+        return getInsets().getLeft() + level * INDENT;
+    }
+
+    /// Whether the cell shows an item that has children.
+    final boolean isBranch() {
+        return branch;
+    }
+
+    /// Makes the next update show the item again even if it is the same.
+    final void markStale() {
+        stale = true;
+    }
+
+    @Override
+    void indexChanged(int oldIndex, int newIndex) {
+        TreeView<T> view = getTreeView();
+        TreeItem<T> item = view == null ? null : view.getTreeItem(newIndex);
+        TreeItem<T> before = getTreeItem();
+        if (item != null) {
+            boolean other = before != item;
+            updateTreeItem(item);
+            T value = item.getValue();
+            if (stale || other || isEmpty() || isItemChanged(getItem(), value)) {
+                updateItem(value, false);
+            }
+        } else {
+            updateTreeItem(null);
+            if (stale || !isEmpty()) {
+                updateItem(null, true);
+            }
+        }
+        stale = false;
+        boolean nowBranch = item != null && !item.isLeaf();
+        boolean nowOpen = nowBranch && item.isExpanded();
+        int nowLevel = item == null || view == null ? 0 : Math.max(0, view.getTreeItemLevel(item)
+                - (view.isShowRoot() ? 0 : 1));
+        if (nowBranch != branch || nowOpen != open || nowLevel != level) {
+            branch = nowBranch;
+            open = nowOpen;
+            level = nowLevel;
+            shape();
+            cn1Invalidated(Dirty.NATIVE);
+            requestLayout();
+        }
+        pseudoClassStateChanged(EXPANDED, nowOpen);
+        pseudoClassStateChanged(COLLAPSED, nowBranch && !nowOpen);
+        MultipleSelectionModel<TreeItem<T>> model = view == null ? null : view.getSelectionModel();
+        updateSelected(item != null && model != null && model.isSelected(newIndex));
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        Node node = getDisclosureNode();
+        if (node != null) {
+            node.setVisible(branch);
+            if (branch) {
+                Insets in = getInsets();
+                double h = getHeight() - in.getTop() - in.getBottom();
+                double w = node.prefWidth(-1);
+                double nh = node.prefHeight(-1);
+                if (node.isResizable()) {
+                    node.resize(w, nh);
+                }
+                node.relocate(arrowStart() + (INDENT - w) / 2 - node.getLayoutBounds().getMinX(),
+                        in.getTop() + (h - nh) / 2 - node.getLayoutBounds().getMinY());
+            }
+        }
+    }
+
+    /// Returns the item of the tree this cell shows, or `null`.
+    public final TreeItem<T> getTreeItem() {
+        return treeItem.get();
+    }
+
+    /// The item of the tree this cell shows.
+    public final ReadOnlyObjectProperty<TreeItem<T>> treeItemProperty() {
+        return treeItem.getReadOnlyProperty();
+    }
+
+    /// Tells the cell which item it shows; the tree does.
+    public final void updateTreeItem(TreeItem<T> item) {
+        treeItem.set(item);
+    }
+
+    /// Returns the tree this cell belongs to.
+    public final TreeView<T> getTreeView() {
+        return treeView.get();
+    }
+
+    /// The tree this cell belongs to.
+    public final ReadOnlyObjectProperty<TreeView<T>> treeViewProperty() {
+        return treeView.getReadOnlyProperty();
+    }
+
+    /// Tells the cell which tree it belongs to; the tree does.
+    public final void updateTreeView(TreeView<T> tree) {
+        treeView.set(tree);
+    }
+
+    /// Returns the node that opens and closes an item with children.
+    public final Node getDisclosureNode() {
+        return disclosureNode.get();
+    }
+
+    /// Sets the node that opens and closes an item with children.
+    public final void setDisclosureNode(Node value) {
+        disclosureNode.set(value);
+    }
+
+    /// The node that opens and closes an item with children.
+    public final ObjectProperty<Node> disclosureNodeProperty() {
+        return disclosureNode;
+    }
+
+    /// Ends the edit with a new value, which becomes the value of the
+    /// item of the row.
+    @Override
+    public void commitEdit(T newValue) {
+        boolean was = isEditing();
+        super.commitEdit(newValue);
+        TreeItem<T> item = getTreeItem();
+        if (was && item != null) {
+            item.setValue(newValue);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TreeItem.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TreeItem.java
new file mode 100644
index 00000000000..e92b5c48e99
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TreeItem.java
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.Node;
+
+/// One item of a tree: a value, an optional graphic, and the items under
+/// it.
+///
+/// An item with no children is a leaf. An item with children is open or
+/// closed by [#setExpanded(boolean)], and its children are shown by a
+/// [TreeView] while it and every item above it is open.
+///
+/// Changes are told as [TreeModificationEvent]s to the handlers of the
+/// item and of every item above it, which is how a tree view hears of
+/// them: the value, the graphic, the children, and a branch opening or
+/// closing. The count events of JavaFX
+/// (`expandedItemCountChangeEvent`) are told as
+/// [#treeNotificationEvent()].
+public class TreeItem<T> implements EventTarget {
+
+    private static final EventType<Event> TREE_NOTIFICATION = new EventType<Event>(Event.ANY,
+            "TreeNotificationEvent");
+    private static final EventType<Event> VALUE_CHANGED = new EventType<Event>(TREE_NOTIFICATION,
+            "ValueChangedEvent");
+    private static final EventType<Event> GRAPHIC_CHANGED = new EventType<Event>(TREE_NOTIFICATION,
+            "GraphicChangedEvent");
+    private static final EventType<Event> CHILDREN_MODIFICATION = new EventType<Event>(TREE_NOTIFICATION,
+            "ChildrenModificationEvent");
+    private static final EventType<Event> BRANCH_EXPANDED = new EventType<Event>(TREE_NOTIFICATION,
+            "BranchExpandedEvent");
+    private static final EventType<Event> BRANCH_COLLAPSED = new EventType<Event>(TREE_NOTIFICATION,
+            "BranchCollapsedEvent");
+
+    private final ObjectProperty<T> value = new SimpleObjectProperty<T>(this, "value");
+    private final ObjectProperty<Node> graphic = new SimpleObjectProperty<Node>(this, "graphic");
+    private final BooleanProperty expanded = new SimpleBooleanProperty(this, "expanded", false);
+    private final ReadOnlyBooleanWrapper leaf = new ReadOnlyBooleanWrapper(this, "leaf", true);
+    private final ReadOnlyObjectWrapper<TreeItem<T>> parent = new ReadOnlyObjectWrapper<TreeItem<T>>(this,
+            "parent");
+    private final ObservableList<TreeItem<T>> children = FXCollections.observableArrayList();
+    private HashMap<EventType<?>, ArrayList<EventHandler<?>>> handlers;
+
+    /// Creates an item with no value.
+    public TreeItem() {
+        this(null);
+    }
+
+    /// Creates an item with a value.
+    public TreeItem(T value) {
+        this(value, null);
+    }
+
+    /// Creates an item with a value and a graphic.
+    public TreeItem(T value, Node graphic) {
+        this.value.set(value);
+        this.graphic.set(graphic);
+        children.addListener((ListChangeListener<TreeItem<T>>) change -> {
+            while (change.next()) {
+                List<? extends TreeItem<T>> gone = change.getRemoved();
+                for (int i = 0; i < gone.size(); i++) {
+                    TreeItem<T> item = gone.get(i);
+                    if (item != null && item.getParent() == TreeItem.this && !children.contains(item)) {
+                        item.parent.set(null);
+                    }
+                }
+                List<? extends TreeItem<T>> come = change.getAddedSubList();
+                for (int i = 0; i < come.size(); i++) {
+                    TreeItem<T> item = come.get(i);
+                    if (item != null) {
+                        item.parent.set(TreeItem.this);
+                    }
+                }
+            }
+            leaf.set(children.isEmpty());
+            tell(CHILDREN_MODIFICATION);
+        });
+        this.value.addListener((observable, was, now) -> tell(VALUE_CHANGED));
+        this.graphic.addListener((observable, was, now) -> tell(GRAPHIC_CHANGED));
+        this.expanded.addListener((observable, was, now) -> {
+            if (!isLeaf()) {
+                tell(now.booleanValue() ? BRANCH_EXPANDED : BRANCH_COLLAPSED);
+            }
+        });
+    }
+
+    /// The type every event of a tree item is of.
+    @SuppressWarnings("unchecked")
+    public static <T> EventType<TreeModificationEvent<T>> treeNotificationEvent() {
+        return (EventType<TreeModificationEvent<T>>) (EventType<?>) TREE_NOTIFICATION;
+    }
+
+    /// The value of an item changed.
+    @SuppressWarnings("unchecked")
+    public static <T> EventType<TreeModificationEvent<T>> valueChangedEvent() {
+        return (EventType<TreeModificationEvent<T>>) (EventType<?>) VALUE_CHANGED;
+    }
+
+    /// The graphic of an item changed.
+    @SuppressWarnings("unchecked")
+    public static <T> EventType<TreeModificationEvent<T>> graphicChangedEvent() {
+        return (EventType<TreeModificationEvent<T>>) (EventType<?>) GRAPHIC_CHANGED;
+    }
+
+    /// Items were added to or removed from the children of an item.
+    @SuppressWarnings("unchecked")
+    public static <T> EventType<TreeModificationEvent<T>> childrenModificationEvent() {
+        return (EventType<TreeModificationEvent<T>>) (EventType<?>) CHILDREN_MODIFICATION;
+    }
+
+    /// An item with children was opened.
+    @SuppressWarnings("unchecked")
+    public static <T> EventType<TreeModificationEvent<T>> branchExpandedEvent() {
+        return (EventType<TreeModificationEvent<T>>) (EventType<?>) BRANCH_EXPANDED;
+    }
+
+    /// An item with children was closed.
+    @SuppressWarnings("unchecked")
+    public static <T> EventType<TreeModificationEvent<T>> branchCollapsedEvent() {
+        return (EventType<TreeModificationEvent<T>>) (EventType<?>) BRANCH_COLLAPSED;
+    }
+
+    /// The number of items a tree shows changed; told here as
+    /// [#treeNotificationEvent()].
+    public static <T> EventType<TreeModificationEvent<T>> expandedItemCountChangeEvent() {
+        return treeNotificationEvent();
+    }
+
+    /// Tells the handlers of this item and of every item above it.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private void tell(EventType<Event> type) {
+        TreeModificationEvent<T> event = new TreeModificationEvent<T>((EventType) type, this);
+        TreeItem<T> at = this;
+        // A tree is not deep enough to need more; a cycle must not hang.
+        for (int depth = 0; at != null && depth < 10000; depth++) {
+            if (at.handlers != null) {
+                EventType<?> t = type;
+                while (t != null) {
+                    ArrayList<EventHandler<?>> list = at.handlers.get(t);
+                    if (list != null) {
+                        Object[] all = list.toArray();
+                        for (int i = 0; i < all.length; i++) {
+                            ((EventHandler) all[i]).handle(event);
+                        }
+                    }
+                    t = t.getSuperType();
+                }
+            }
+            at = at.getParent();
+        }
+    }
+
+    /// Adds a handler for events of a type from this item and the items
+    /// under it.
+    public <E extends Event> void addEventHandler(EventType<E> eventType, EventHandler<E> eventHandler) {
+        if (eventType == null || eventHandler == null) {
+            return;
+        }
+        if (handlers == null) {
+            handlers = new HashMap<EventType<?>, ArrayList<EventHandler<?>>>();
+        }
+        ArrayList<EventHandler<?>> list = handlers.get(eventType);
+        if (list == null) {
+            list = new ArrayList<EventHandler<?>>();
+            handlers.put(eventType, list);
+        }
+        list.add(eventHandler);
+    }
+
+    /// Removes a handler.
+    public <E extends Event> void removeEventHandler(EventType<E> eventType, EventHandler<E> eventHandler) {
+        ArrayList<EventHandler<?>> list = handlers == null ? null : handlers.get(eventType);
+        if (list != null) {
+            list.remove(eventHandler);
+        }
+    }
+
+    /// The events of a tree item go to its own handlers, not along a
+    /// chain of the scene.
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        return tail;
+    }
+
+    /// Returns the value.
+    public final T getValue() {
+        return value.get();
+    }
+
+    /// Sets the value.
+    public final void setValue(T newValue) {
+        value.set(newValue);
+    }
+
+    /// The value.
+    public final ObjectProperty<T> valueProperty() {
+        return value;
+    }
+
+    /// Returns the node shown before the value.
+    public final Node getGraphic() {
+        return graphic.get();
+    }
+
+    /// Sets the node shown before the value.
+    public final void setGraphic(Node newValue) {
+        graphic.set(newValue);
+    }
+
+    /// The node shown before the value.
+    public final ObjectProperty<Node> graphicProperty() {
+        return graphic;
+    }
+
+    /// Returns whether the item is open.
+    public final boolean isExpanded() {
+        return expanded.get();
+    }
+
+    /// Opens or closes the item.
+    public final void setExpanded(boolean newValue) {
+        expanded.set(newValue);
+    }
+
+    /// Whether the item is open.
+    public final BooleanProperty expandedProperty() {
+        return expanded;
+    }
+
+    /// Returns whether the item has no children.
+    public boolean isLeaf() {
+        return leaf.get();
+    }
+
+    /// Whether the item has no children.
+    public final ReadOnlyBooleanProperty leafProperty() {
+        return leaf.getReadOnlyProperty();
+    }
+
+    /// Returns the item this one is a child of, or `null`.
+    public final TreeItem<T> getParent() {
+        return parent.get();
+    }
+
+    /// The item this one is a child of.
+    public final ReadOnlyObjectProperty<TreeItem<T>> parentProperty() {
+        return parent.getReadOnlyProperty();
+    }
+
+    /// Returns the items under this one.
+    public ObservableList<TreeItem<T>> getChildren() {
+        return children;
+    }
+
+    /// Returns the item before this one under the same parent, or `null`.
+    public TreeItem<T> previousSibling() {
+        return sibling(-1);
+    }
+
+    /// Returns the item after this one under the same parent, or `null`.
+    public TreeItem<T> nextSibling() {
+        return sibling(1);
+    }
+
+    private TreeItem<T> sibling(int step) {
+        TreeItem<T> above = getParent();
+        if (above == null) {
+            return null;
+        }
+        int at = above.children.indexOf(this) + step;
+        return at < 0 || at >= above.children.size() ? null : above.children.get(at);
+    }
+
+    @Override
+    public String toString() {
+        return "TreeItem [ value: " + getValue() + " ]";
+    }
+
+    /// What happened to an item of a tree.
+    public static class TreeModificationEvent<T> extends Event {
+
+        private static final long serialVersionUID = 1L;
+
+        private final transient TreeItem<T> treeItem;
+
+        /// Creates an event about an item.
+        public TreeModificationEvent(EventType<? extends Event> eventType, TreeItem<T> treeItem) {
+            super(eventType);
+            this.treeItem = treeItem;
+        }
+
+        /// Returns the item the event is about.
+        public TreeItem<T> getTreeItem() {
+            return treeItem;
+        }
+
+        @Override
+        public TreeItem<T> getSource() {
+            return treeItem;
+        }
+
+        /// Returns the value of the item now.
+        public T getNewValue() {
+            return treeItem == null ? null : treeItem.getValue();
+        }
+
+        /// Returns whether the event is a branch opening.
+        public boolean wasExpanded() {
+            return getEventType() == BRANCH_EXPANDED;
+        }
+
+        /// Returns whether the event is a branch closing.
+        public boolean wasCollapsed() {
+            return getEventType() == BRANCH_COLLAPSED;
+        }
+
+        /// Returns whether the event is a change of children.
+        public boolean wasAdded() {
+            return getEventType() == CHILDREN_MODIFICATION;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/TreeView.java b/maven/javafx-compat/src/main/java/javafx/scene/control/TreeView.java
new file mode 100644
index 00000000000..6035d153e61
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/TreeView.java
@@ -0,0 +1,580 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.ui.Component;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.property.ReadOnlyIntegerWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Region;
+import javafx.util.Callback;
+
+/// A tree of [TreeItem]s shown as rows: the root, and under every open
+/// item its children, each indented by its depth.
+///
+/// A press on the arrow of a row opens or closes its item, and so does a
+/// double click anywhere on the row; any other press selects the row. The
+/// rows are the items that can be seen -- an item is one while every item
+/// above it is open -- and the selection model counts in those rows, so
+/// an index is a row, as it is in JavaFX. Closing an item deselects what
+/// was selected under it.
+///
+/// A cell factory makes the [TreeCell]s; without one a cell shows the
+/// value's `toString()` after the graphic of its item, or the value
+/// itself when it is a node. Rows are all one height, the height of the
+/// first cell or [#setFixedCellSize(double)].
+///
+/// There is no focus model and no editing by the tree itself: a cell
+/// that edits commits into its item.
+public class TreeView<T> extends Control {
+
+    private final ObjectProperty<TreeItem<T>> root = new SimpleObjectProperty<TreeItem<T>>(this, "root");
+    private final BooleanProperty showRoot = new SimpleBooleanProperty(this, "showRoot", true);
+    private final BooleanProperty editable = new SimpleBooleanProperty(this, "editable", false);
+    private final ObjectProperty<Callback<TreeView<T>, TreeCell<T>>> cellFactory =
+            new SimpleObjectProperty<Callback<TreeView<T>, TreeCell<T>>>(this, "cellFactory");
+    private final ObjectProperty<MultipleSelectionModel<TreeItem<T>>> selectionModel =
+            new SimpleObjectProperty<MultipleSelectionModel<TreeItem<T>>>(this, "selectionModel");
+    private final DoubleProperty fixedCellSize = new SimpleDoubleProperty(this, "fixedCellSize",
+            Region.USE_COMPUTED_SIZE);
+    private final ReadOnlyIntegerWrapper expandedItemCount = new ReadOnlyIntegerWrapper(this, "expandedItemCount",
+            0);
+    private final ObservableList<TreeItem<T>> rows = FXCollections.observableArrayList();
+    private final RowFlow flow;
+    private int anchor = -1;
+    private final EventHandler<TreeItem.TreeModificationEvent<T>> treeChanged = event -> {
+        if (event.getEventType() == TreeItem.valueChangedEvent()
+                || event.getEventType() == TreeItem.graphicChangedEvent()) {
+            refresh();
+        } else {
+            rowsChanged();
+        }
+    };
+    private final ListChangeListener<Integer> selectionListener = change -> syncSelection();
+
+    /// Creates a tree with no root.
+    public TreeView() {
+        this(null);
+    }
+
+    /// Creates a tree of a root item.
+    public TreeView(TreeItem<T> root) {
+        getStyleClass().add("tree-view");
+        flow = new RowFlow(new FlowRows());
+        cn1Children().add(flow);
+        this.root.addListener((observable, was, now) -> {
+            if (was != null) {
+                was.removeEventHandler(TreeItem.<T>treeNotificationEvent(), treeChanged);
+            }
+            if (now != null) {
+                now.addEventHandler(TreeItem.<T>treeNotificationEvent(), treeChanged);
+            }
+            flow.scrollTo(0);
+            rowsChanged();
+        });
+        showRoot.addListener((observable, was, now) -> rowsChanged());
+        cellFactory.addListener((observable, was, now) -> flow.rebuild());
+        fixedCellSize.addListener((observable, was, now) -> flow.rowsChanged());
+        selectionModel.addListener((observable, was, now) -> {
+            if (was != null) {
+                was.getSelectedIndices().removeListener(selectionListener);
+            }
+            if (now != null) {
+                now.getSelectedIndices().addListener(selectionListener);
+            }
+            syncSelection();
+        });
+        flow.addEventHandler(MouseEvent.MOUSE_PRESSED, this::pressed);
+        selectionModel.set(new Model<T>(this));
+        this.root.set(root);
+    }
+
+    @Override
+    protected Component cn1CreateNative() {
+        return null;
+    }
+
+    @Override
+    public String cn1DefaultStyle() {
+        return "-fx-background-color: -fx-box-border, -fx-control-inner-background; -fx-background-insets: 0, 1;"
+                + " -fx-padding: 1;";
+    }
+
+    private void collect(TreeItem<T> item, List<TreeItem<T>> into, int depth) {
+        // A tree that holds itself must not hang the walk.
+        if (item == null || depth > 1000) {
+            return;
+        }
+        into.add(item);
+        if (item.isExpanded()) {
+            List<TreeItem<T>> under = item.getChildren();
+            for (int i = 0; i < under.size(); i++) {
+                collect(under.get(i), into, depth + 1);
+            }
+        }
+    }
+
+    /// Works out the rows again and keeps selected what is still a row.
+    private void rowsChanged() {
+        ArrayList<TreeItem<T>> next = new ArrayList<TreeItem<T>>();
+        TreeItem<T> top = getRoot();
+        if (top != null) {
+            if (isShowRoot()) {
+                collect(top, next, 0);
+            } else {
+                List<TreeItem<T>> under = top.getChildren();
+                for (int i = 0; i < under.size(); i++) {
+                    collect(under.get(i), next, 1);
+                }
+            }
+        }
+        MultipleSelectionModel<TreeItem<T>> model = getSelectionModel();
+        ArrayList<TreeItem<T>> kept = new ArrayList<TreeItem<T>>();
+        if (model != null) {
+            kept.addAll(model.getSelectedItems());
+        }
+        rows.setAll(next);
+        if (model instanceof Model) {
+            ((Model<T>) model).selection.rowsReplaced();
+        }
+        if (model != null) {
+            for (int i = 0; i < kept.size(); i++) {
+                int at = rows.indexOf(kept.get(i));
+                if (at >= 0) {
+                    model.select(at);
+                }
+            }
+        }
+        anchor = -1;
+        expandedItemCount.set(rows.size());
+        flow.rowsChanged();
+        flow.refresh();
+        requestLayout();
+    }
+
+    private void syncSelection() {
+        MultipleSelectionModel<TreeItem<T>> model = getSelectionModel();
+        ArrayList<IndexedCell<?>[]> slots = flow.slots();
+        for (int i = 0; i < slots.size(); i++) {
+            IndexedCell<?>[] slot = slots.get(i);
+            for (int c = 0; c < slot.length; c++) {
+                int row = slot[c].getIndex();
+                slot[c].updateSelected(model != null && row >= 0 && model.isSelected(row));
+            }
+        }
+    }
+
+    private void pressed(MouseEvent event) {
+        int row = flow.rowAt(event);
+        TreeItem<T> item = getTreeItem(row);
+        if (item == null) {
+            return;
+        }
+        IndexedCell<?> cell = flow.cell(row, 0);
+        if (!item.isLeaf() && cell instanceof TreeCell) {
+            TreeCell<?> shown = (TreeCell<?>) cell;
+            Point2D p = shown.sceneToLocal(event.getSceneX(), event.getSceneY());
+            double from = shown.arrowStart();
+            boolean onArrow = p.getX() >= from && p.getX() < from + TreeCell.INDENT;
+            if (onArrow || event.getClickCount() == 2) {
+                item.setExpanded(!item.isExpanded());
+                if (onArrow) {
+                    return;
+                }
+            }
+        }
+        MultipleSelectionModel<TreeItem<T>> model = getSelectionModel();
+        // The rows may have changed under the press.
+        row = rows.indexOf(item);
+        if (model != null && row >= 0) {
+            anchor = RowPress.apply(model, event.getButton() == MouseButton.PRIMARY, event.isShortcutDown(),
+                    event.isShiftDown(), row, anchor);
+        }
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        flow.resizeRelocate(in.getLeft(), in.getTop(), Math.max(0, getWidth() - in.getLeft() - in.getRight()),
+                Math.max(0, getHeight() - in.getTop() - in.getBottom()));
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        return 248;
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        return 400;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + in.getBottom();
+    }
+
+    @Override
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    /// Returns the item at a row, or `null` when there is no such row.
+    public TreeItem<T> getTreeItem(int row) {
+        return row >= 0 && row < rows.size() ? rows.get(row) : null;
+    }
+
+    /// Returns the row of an item, -1 when it cannot be seen.
+    public int getRow(TreeItem<T> item) {
+        return rows.indexOf(item);
+    }
+
+    /// Returns how many items are above an item, none for the root.
+    public int getTreeItemLevel(TreeItem<?> node) {
+        int level = 0;
+        TreeItem<?> at = node == null ? null : node.getParent();
+        while (at != null && level < 1000) {
+            level++;
+            at = at.getParent();
+        }
+        return level;
+    }
+
+    /// Returns how many rows the tree has.
+    public final int getExpandedItemCount() {
+        return expandedItemCount.get();
+    }
+
+    /// How many rows the tree has.
+    public final ReadOnlyIntegerProperty expandedItemCountProperty() {
+        return expandedItemCount.getReadOnlyProperty();
+    }
+
+    /// Returns the item at the top of the tree.
+    public final TreeItem<T> getRoot() {
+        return root.get();
+    }
+
+    /// Sets the item at the top of the tree.
+    public final void setRoot(TreeItem<T> value) {
+        root.set(value);
+    }
+
+    /// The item at the top of the tree.
+    public final ObjectProperty<TreeItem<T>> rootProperty() {
+        return root;
+    }
+
+    /// Returns whether the root has a row of its own.
+    public final boolean isShowRoot() {
+        return showRoot.get();
+    }
+
+    /// Sets whether the root has a row of its own; without one its
+    /// children are the first level, whether it is open or not.
+    public final void setShowRoot(boolean value) {
+        showRoot.set(value);
+    }
+
+    /// Whether the root has a row of its own.
+    public final BooleanProperty showRootProperty() {
+        return showRoot;
+    }
+
+    /// Returns whether cells may be edited.
+    public final boolean isEditable() {
+        return editable.get();
+    }
+
+    /// Sets whether cells may be edited.
+    public final void setEditable(boolean value) {
+        editable.set(value);
+    }
+
+    /// Whether cells may be edited.
+    public final BooleanProperty editableProperty() {
+        return editable;
+    }
+
+    /// Sets what creates the cells.
+    public final void setCellFactory(Callback<TreeView<T>, TreeCell<T>> value) {
+        cellFactory.set(value);
+    }
+
+    /// Returns what creates the cells, or `null` for the default.
+    public final Callback<TreeView<T>, TreeCell<T>> getCellFactory() {
+        return cellFactory.get();
+    }
+
+    /// What creates the cells.
+    public final ObjectProperty<Callback<TreeView<T>, TreeCell<T>>> cellFactoryProperty() {
+        return cellFactory;
+    }
+
+    /// Sets the selection model.
+    public final void setSelectionModel(MultipleSelectionModel<TreeItem<T>> value) {
+        selectionModel.set(value);
+    }
+
+    /// Returns the selection model, whose indices are rows.
+    public final MultipleSelectionModel<TreeItem<T>> getSelectionModel() {
+        return selectionModel.get();
+    }
+
+    /// The selection model.
+    public final ObjectProperty<MultipleSelectionModel<TreeItem<T>>> selectionModelProperty() {
+        return selectionModel;
+    }
+
+    /// Sets the height of every row; `Region.USE_COMPUTED_SIZE` takes it
+    /// from the first cell.
+    public final void setFixedCellSize(double value) {
+        fixedCellSize.set(value);
+    }
+
+    /// Returns the height of every row, or `Region.USE_COMPUTED_SIZE`.
+    public final double getFixedCellSize() {
+        return fixedCellSize.get();
+    }
+
+    /// The height of every row.
+    public final DoubleProperty fixedCellSizeProperty() {
+        return fixedCellSize;
+    }
+
+    /// Scrolls so that a row is the first one shown, as far as the rows
+    /// reach.
+    public void scrollTo(int index) {
+        flow.show(index);
+    }
+
+    /// Shows every visible row again, for items that changed in a way
+    /// the tree could not observe.
+    public void refresh() {
+        flow.refresh();
+    }
+
+    private static final class DefaultCell<T> extends TreeCell<T> {
+        @Override
+        protected void updateItem(T item, boolean empty) {
+            super.updateItem(item, empty);
+            TreeItem<T> of = getTreeItem();
+            if (empty) {
+                setText(null);
+                setGraphic(null);
+            } else if (item instanceof Node) {
+                setText(null);
+                setGraphic((Node) item);
+            } else {
+                setText(item == null ? "null" : item.toString());
+                setGraphic(of == null ? null : of.getGraphic());
+            }
+        }
+    }
+
+    private final class FlowRows implements RowFlow.Rows {
+        @Override
+        public int rowCount() {
+            return rows.size();
+        }
+
+        @Override
+        public int columnCount() {
+            return 1;
+        }
+
+        @Override
+        public void columns(double width, double[] x, double[] w) {
+            x[0] = 0;
+            w[0] = width;
+        }
+
+        @Override
+        public IndexedCell<?> createCell(int column) {
+            Callback<TreeView<T>, TreeCell<T>> factory = getCellFactory();
+            TreeCell<T> cell = factory == null ? null : factory.call(TreeView.this);
+            if (cell == null) {
+                cell = new DefaultCell<T>();
+            }
+            cell.updateTreeView(TreeView.this);
+            return cell;
+        }
+
+        @Override
+        public void updateCell(IndexedCell<?> cell, int column, int row, boolean force) {
+            if (force && cell instanceof TreeCell) {
+                ((TreeCell<?>) cell).markStale();
+            }
+            cell.updateIndex(row);
+        }
+
+        @Override
+        public double fixedCellSize() {
+            return getFixedCellSize();
+        }
+    }
+
+    private static final class Model<T> extends MultipleSelectionModel<TreeItem<T>>
+            implements RowSelection.Owner<TreeItem<T>> {
+
+        private final TreeView<T> view;
+        private final RowSelection<TreeItem<T>> selection;
+
+        Model(TreeView<T> view) {
+            this.view = view;
+            this.selection = new RowSelection<TreeItem<T>>(this);
+        }
+
+        @Override
+        public ObservableList<TreeItem<T>> rows() {
+            return view.rows;
+        }
+
+        @Override
+        public boolean multiple() {
+            return getSelectionMode() == SelectionMode.MULTIPLE;
+        }
+
+        @Override
+        public void lead(int index, TreeItem<T> item) {
+            setSelectedIndex(index);
+            setSelectedItem(item);
+        }
+
+        @Override
+        public ObservableList<Integer> getSelectedIndices() {
+            return selection.indices();
+        }
+
+        @Override
+        public ObservableList<TreeItem<T>> getSelectedItems() {
+            return selection.items();
+        }
+
+        @Override
+        public void selectIndices(int index, int... indices) {
+            selection.selectIndices(index, indices);
+        }
+
+        @Override
+        public void selectAll() {
+            selection.selectAll();
+        }
+
+        @Override
+        public void selectFirst() {
+            if (selection.rowCount() > 0) {
+                select(0);
+            }
+        }
+
+        @Override
+        public void selectLast() {
+            int n = selection.rowCount();
+            if (n > 0) {
+                select(n - 1);
+            }
+        }
+
+        @Override
+        public void clearAndSelect(int index) {
+            selection.clearAndSelect(index);
+        }
+
+        @Override
+        public void select(int index) {
+            selection.select(index);
+        }
+
+        @Override
+        public void select(TreeItem<T> obj) {
+            selection.select(obj);
+        }
+
+        @Override
+        public void clearSelection(int index) {
+            selection.clear(index);
+        }
+
+        @Override
+        public void clearSelection() {
+            selection.clear();
+        }
+
+        @Override
+        public boolean isSelected(int index) {
+            return selection.isSelected(index);
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return selection.isEmpty();
+        }
+
+        @Override
+        public void selectPrevious() {
+            int lead = selection.lead();
+            if (lead > 0) {
+                select(lead - 1);
+            }
+        }
+
+        @Override
+        public void selectNext() {
+            int lead = selection.lead();
+            if (lead < selection.rowCount() - 1) {
+                select(lead + 1);
+            }
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/cell/CheckBoxTableCell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/CheckBoxTableCell.java
new file mode 100644
index 00000000000..fee3e563129
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/CheckBoxTableCell.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control.cell;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.value.ObservableValue;
+import javafx.geometry.Pos;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.TableCell;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.util.Callback;
+import javafx.util.StringConverter;
+
+/// A table cell that shows a check box, with a text beside it when the
+/// cell has a converter.
+///
+/// The box follows a boolean value: the one the selected-state callback
+/// answers for the row, or without a callback the value of the cell's
+/// column. When that value is a `BooleanProperty` the two are bound both
+/// ways, so a click on the box writes the property; no edit is started or
+/// committed. The box is disabled while the table, the column or the cell
+/// is not editable.
+public class CheckBoxTableCell<S, T> extends TableCell<S, T> {
+
+    private final CheckBox checkBox = new CheckBox();
+    private final ObjectProperty<StringConverter<T>> converter = new SimpleObjectProperty<StringConverter<T>>(this,
+            "converter");
+    private final ObjectProperty<Callback<Integer, ObservableValue<Boolean>>> selectedStateCallback =
+            new SimpleObjectProperty<Callback<Integer, ObservableValue<Boolean>>>(this, "selectedStateCallback");
+    private BooleanProperty bound;
+
+    /// Creates a cell that follows the value of its column.
+    public CheckBoxTableCell() {
+        this(null, null);
+    }
+
+    /// Creates a cell that follows what a callback answers for its row.
+    public CheckBoxTableCell(Callback<Integer, ObservableValue<Boolean>> getSelectedProperty) {
+        this(getSelectedProperty, null);
+    }
+
+    /// Creates a cell that follows what a callback answers for its row and
+    /// shows its item as text through a converter.
+    public CheckBoxTableCell(Callback<Integer, ObservableValue<Boolean>> getSelectedProperty,
+            StringConverter<T> converter) {
+        getStyleClass().add("check-box-table-cell");
+        setSelectedStateCallback(getSelectedProperty);
+        setConverter(converter);
+        setAlignment(Pos.CENTER);
+    }
+
+    /// Returns a cell factory for a column of booleans.
+    public static <S> Callback<TableColumn<S, Boolean>, TableCell<S, Boolean>> forTableColumn(
+            TableColumn<S, Boolean> column) {
+        return forTableColumn((Callback<Integer, ObservableValue<Boolean>>) null, null);
+    }
+
+    /// Returns a cell factory whose boxes follow a callback.
+    public static <S, T> Callback<TableColumn<S, T>, TableCell<S, T>> forTableColumn(
+            Callback<Integer, ObservableValue<Boolean>> getSelectedProperty) {
+        return forTableColumn(getSelectedProperty, null);
+    }
+
+    /// Returns a cell factory whose boxes follow a callback, with the item
+    /// as text beside the box when `showLabel` is true.
+    public static <S, T> Callback<TableColumn<S, T>, TableCell<S, T>> forTableColumn(
+            Callback<Integer, ObservableValue<Boolean>> getSelectedProperty, boolean showLabel) {
+        StringConverter<T> text = !showLabel ? null : new StringConverter<T>() {
+            @Override
+            public String toString(T object) {
+                return object == null ? "" : object.toString();
+            }
+
+            @Override
+            public T fromString(String string) {
+                return null;
+            }
+        };
+        return forTableColumn(getSelectedProperty, text);
+    }
+
+    /// Returns a cell factory whose boxes follow a callback, with the item
+    /// as text through a converter.
+    public static <S, T> Callback<TableColumn<S, T>, TableCell<S, T>> forTableColumn(
+            final Callback<Integer, ObservableValue<Boolean>> getSelectedProperty,
+            final StringConverter<T> converter) {
+        return new Callback<TableColumn<S, T>, TableCell<S, T>>() {
+            @Override
+            public TableCell<S, T> call(TableColumn<S, T> column) {
+                return new CheckBoxTableCell<S, T>(getSelectedProperty, converter);
+            }
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    private ObservableValue<Boolean> selectedValue() {
+        Callback<Integer, ObservableValue<Boolean>> callback = getSelectedStateCallback();
+        if (callback != null) {
+            return callback.call(Integer.valueOf(getIndex()));
+        }
+        TableColumn<S, T> column = getTableColumn();
+        // The column's value is read as a boolean; only the type argument
+        // is taken on trust, and no class is checked for it at run time.
+        ObservableValue<?> value = column == null ? null : column.getCellObservableValue(getIndex());
+        return (ObservableValue<Boolean>) value;
+    }
+
+    @Override
+    protected void updateItem(T item, boolean empty) {
+        super.updateItem(item, empty);
+        if (bound != null) {
+            checkBox.selectedProperty().unbindBidirectional(bound);
+            bound = null;
+        }
+        if (empty) {
+            setText(null);
+            setGraphic(null);
+            return;
+        }
+        StringConverter<T> c = getConverter();
+        setText(c == null ? null : c.toString(item));
+        setGraphic(checkBox);
+        ObservableValue<Boolean> value = selectedValue();
+        if (value instanceof BooleanProperty) {
+            bound = (BooleanProperty) value;
+            checkBox.selectedProperty().bindBidirectional(bound);
+        } else {
+            Object now = value == null ? item : value.getValue();
+            checkBox.setSelected(Boolean.TRUE.equals(now));
+        }
+        TableView<S> table = getTableView();
+        TableColumn<S, T> column = getTableColumn();
+        checkBox.setDisable(table == null || column == null || !table.isEditable() || !column.isEditable()
+                || !isEditable());
+    }
+
+    /// The converter that makes the text beside the box.
+    public final ObjectProperty<StringConverter<T>> converterProperty() {
+        return converter;
+    }
+
+    /// Sets the converter that makes the text beside the box.
+    public final void setConverter(StringConverter<T> value) {
+        converter.set(value);
+    }
+
+    /// Returns the converter, or `null` for a box without a text.
+    public final StringConverter<T> getConverter() {
+        return converter.get();
+    }
+
+    /// What answers the value the box of a row follows.
+    public final ObjectProperty<Callback<Integer, ObservableValue<Boolean>>> selectedStateCallbackProperty() {
+        return selectedStateCallback;
+    }
+
+    /// Sets what answers the value the box of a row follows.
+    public final void setSelectedStateCallback(Callback<Integer, ObservableValue<Boolean>> value) {
+        selectedStateCallback.set(value);
+    }
+
+    /// Returns what answers the value the box of a row follows.
+    public final Callback<Integer, ObservableValue<Boolean>> getSelectedStateCallback() {
+        return selectedStateCallback.get();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/cell/PropertyValueFactory.java b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/PropertyValueFactory.java
new file mode 100644
index 00000000000..ced71ba9dbc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/PropertyValueFactory.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control.cell;
+
+import com.codename1.fxcompat.runtime.PropertyAccess;
+
+import javafx.beans.NamedArg;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.value.ObservableValue;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableColumn.CellDataFeatures;
+import javafx.util.Callback;
+
+/// A cell value factory that takes the value of a column from a property
+/// of the row's item, named as a string.
+///
+/// For the name `firstName` it answers what the item's
+/// `firstNameProperty()` returns, so the cell follows the property. An
+/// item without that method is asked `getFirstName()`, then
+/// `isFirstName()`, and the answer is wrapped in a value that does not
+/// change.
+///
+/// #### No reflection
+///
+/// JavaFX finds those methods by reflection. Here the build generates the
+/// calls, for every public class of the application that has at least one
+/// public `xxxProperty()` method, and for a public class with an accessor
+/// for a name that is handed to this constructor as a constant. The
+/// methods have to be public and take no argument.
+///
+/// A row whose class or property the build generated nothing for is an
+/// `IllegalStateException` that names both; JavaFX logs a warning and
+/// shows an empty cell. A lambda -- `c -> c.getValue().firstNameProperty()`
+/// -- needs none of this and is the way around it.
+public class PropertyValueFactory<S, T> implements Callback<CellDataFeatures<S, T>, ObservableValue<T>> {
+
+    private final String property;
+
+    /// Creates a factory for the property of a name.
+    public PropertyValueFactory(@NamedArg("property") String property) {
+        this.property = property;
+    }
+
+    /// Returns the name of the property.
+    public final String getProperty() {
+        return property;
+    }
+
+    /// Returns the value of the property for the item of a row, or `null`
+    /// for a row without an item.
+    @Override
+    @SuppressWarnings("unchecked")
+    public ObservableValue<T> call(CellDataFeatures<S, T> param) {
+        return cn1ValueOf(param == null ? null : param.getValue(), property);
+    }
+
+    /// The value of a property of a bean, as [#call(CellDataFeatures)]
+    /// answers it.
+    @SuppressWarnings("unchecked")
+    static <T> ObservableValue<T> cn1ValueOf(Object bean, String property) {
+        if (bean == null || property == null || property.length() == 0) {
+            return null;
+        }
+        PropertyAccess access = PropertyAccess.current();
+        Object observable = access.call(bean, property + "Property");
+        if (observable instanceof ObservableValue) {
+            return (ObservableValue<T>) observable;
+        }
+        // As JavaFX does: the first letter in upper case, the rest as given.
+        char first = property.charAt(0);
+        String capital = (first >= 'a' && first <= 'z' ? (char) (first - 'a' + 'A') : first) + property.substring(1);
+        Object value = access.call(bean, "get" + capital);
+        if (value == PropertyAccess.NONE) {
+            value = access.call(bean, "is" + capital);
+        }
+        if (value == PropertyAccess.NONE) {
+            String type = bean.getClass().getName();
+            throw new IllegalStateException(access.knows(bean)
+                    ? "PropertyValueFactory: " + type + " has no public " + property + "Property(), get" + capital
+                            + "() or is" + capital + "() method without arguments"
+                    : "PropertyValueFactory: no accessors were generated for " + type + " (property \"" + property
+                            + "\"). The class must be public and have a public xxxProperty() method, or the"
+                            + " property name must be a constant where the PropertyValueFactory is created;"
+                            + " otherwise use a lambda as the cell value factory");
+        }
+        return new ReadOnlyObjectWrapper<T>((T) value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/cell/TextFieldTableCell.java b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/TextFieldTableCell.java
new file mode 100644
index 00000000000..0555a136ec3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/TextFieldTableCell.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.control.cell;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.Insets;
+import javafx.scene.control.TableCell;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TextField;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.util.Callback;
+import javafx.util.StringConverter;
+import javafx.util.converter.DefaultStringConverter;
+
+/// A table cell that shows its value as text and, while it is edited, as a
+/// text field. The action of the field commits what was typed, converted
+/// by the cell's converter, and Escape cancels.
+///
+/// A cell is edited by a double click in an editable table, or by
+/// `TableView.edit`.
+public class TextFieldTableCell<S, T> extends TableCell<S, T> {
+
+    private final ObjectProperty<StringConverter<T>> converter = new SimpleObjectProperty<StringConverter<T>>(this,
+            "converter");
+    private TextField textField;
+
+    /// Creates a cell with no converter: it can show a value and cannot
+    /// commit one.
+    public TextFieldTableCell() {
+        this(null);
+    }
+
+    /// Creates a cell that converts between its values and text.
+    public TextFieldTableCell(StringConverter<T> converter) {
+        getStyleClass().add("text-field-table-cell");
+        setConverter(converter);
+    }
+
+    /// Returns a cell factory for a column of strings.
+    public static <S> Callback<TableColumn<S, String>, TableCell<S, String>> forTableColumn() {
+        return forTableColumn(new DefaultStringConverter());
+    }
+
+    /// Returns a cell factory for a column of values a converter reads
+    /// from text and writes as text.
+    public static <S, T> Callback<TableColumn<S, T>, TableCell<S, T>> forTableColumn(
+            final StringConverter<T> converter) {
+        return new Callback<TableColumn<S, T>, TableCell<S, T>>() {
+            @Override
+            public TableCell<S, T> call(TableColumn<S, T> column) {
+                return new TextFieldTableCell<S, T>(converter);
+            }
+        };
+    }
+
+    /// The converter between the values of this cell and text.
+    public final ObjectProperty<StringConverter<T>> converterProperty() {
+        return converter;
+    }
+
+    /// Sets the converter.
+    public final void setConverter(StringConverter<T> value) {
+        converter.set(value);
+    }
+
+    /// Returns the converter, or `null`.
+    public final StringConverter<T> getConverter() {
+        return converter.get();
+    }
+
+    private String itemText() {
+        T item = getItem();
+        StringConverter<T> c = getConverter();
+        if (c != null) {
+            return c.toString(item);
+        }
+        return item == null ? "" : item.toString();
+    }
+
+    private TextField field() {
+        if (textField == null) {
+            textField = new TextField();
+            textField.setOnAction(new EventHandler<ActionEvent>() {
+                @Override
+                public void handle(ActionEvent event) {
+                    StringConverter<T> c = getConverter();
+                    if (c == null) {
+                        throw new IllegalStateException("Attempting to convert text input into Object, but provided "
+                                + "StringConverter is null. Be sure to set a StringConverter in your cell factory.");
+                    }
+                    commitEdit(c.fromString(textField.getText()));
+                    event.consume();
+                }
+            });
+            textField.addEventHandler(KeyEvent.KEY_RELEASED, new EventHandler<KeyEvent>() {
+                @Override
+                public void handle(KeyEvent event) {
+                    if (event.getCode() == KeyCode.ESCAPE) {
+                        cancelEdit();
+                        event.consume();
+                    }
+                }
+            });
+        }
+        return textField;
+    }
+
+    @Override
+    public void startEdit() {
+        super.startEdit();
+        if (!isEditing()) {
+            return;
+        }
+        TextField field = field();
+        field.setText(itemText());
+        setText(null);
+        setGraphic(field);
+        field.selectAll();
+        field.requestFocus();
+    }
+
+    @Override
+    public void cancelEdit() {
+        super.cancelEdit();
+        setText(itemText());
+        setGraphic(null);
+    }
+
+    @Override
+    protected void updateItem(T item, boolean empty) {
+        super.updateItem(item, empty);
+        if (empty) {
+            setText(null);
+            setGraphic(null);
+        } else if (isEditing()) {
+            field().setText(itemText());
+            setText(null);
+            setGraphic(textField);
+        } else {
+            setText(itemText());
+            setGraphic(null);
+        }
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+        if (textField != null && getGraphic() == textField) {
+            // The field takes the whole cell, not its preferred width.
+            Insets in = getInsets();
+            textField.resizeRelocate(in.getLeft(), in.getTop(), Math.max(0, getWidth() - in.getLeft() - in.getRight()),
+                    Math.max(0, getHeight() - in.getTop() - in.getBottom()));
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/cell/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/package-info.java
new file mode 100644
index 00000000000..ca0f708ce6a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/cell/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Ready made cells. A cell that edits is created by a cell factory set on
+/// the column; the table and the column must both be editable.
+package javafx.scene.control.cell;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/control/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/control/package-info.java
new file mode 100644
index 00000000000..aa2adb63edc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/control/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The controls. Each one shows the matching Codename One component, so
+/// it looks and behaves as that component does on the device.
+package javafx.scene.control;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/BlurType.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/BlurType.java
new file mode 100644
index 00000000000..e69c1788975
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/BlurType.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+/// The way a shadow is softened. Recorded only: see [Effect].
+public enum BlurType {
+    /// One pass of a box blur.
+    ONE_PASS_BOX,
+    /// Two passes of a box blur.
+    TWO_PASS_BOX,
+    /// Three passes of a box blur.
+    THREE_PASS_BOX,
+    /// A Gaussian blur.
+    GAUSSIAN
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/BoxBlur.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/BoxBlur.java
new file mode 100644
index 00000000000..8868201f12c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/BoxBlur.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+
+/// A box blur of a node. **Recorded and not drawn**: a node with one is
+/// painted sharp, see [Effect].
+public class BoxBlur extends Effect {
+
+    private final ObjectProperty<Effect> input = new SimpleObjectProperty<Effect>(this, "input");
+    private final DoubleProperty width = new SimpleDoubleProperty(this, "width", 5);
+    private final DoubleProperty height = new SimpleDoubleProperty(this, "height", 5);
+    private final IntegerProperty iterations = new SimpleIntegerProperty(this, "iterations", 1);
+
+    /// Creates a blur five wide, five high, run once.
+    public BoxBlur() {
+    }
+
+    /// Creates a blur of a width, a height and a number of passes.
+    public BoxBlur(double width, double height, int iterations) {
+        setWidth(width);
+        setHeight(height);
+        setIterations(iterations);
+    }
+
+    /// Returns the effect this one is applied on top of.
+    public final Effect getInput() {
+        return input.get();
+    }
+
+    /// Sets the effect this one is applied on top of.
+    public final void setInput(Effect value) {
+        input.set(value);
+    }
+
+    /// The effect this one is applied on top of.
+    public final ObjectProperty<Effect> inputProperty() {
+        return input;
+    }
+
+    /// Returns the width of the blur, from 0 to 255.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Sets the width of the blur.
+    public final void setWidth(double value) {
+        width.set(DropShadow.clamp(value, 0, 255));
+    }
+
+    /// The width of the blur.
+    public final DoubleProperty widthProperty() {
+        return width;
+    }
+
+    /// Returns the height of the blur, from 0 to 255.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// Sets the height of the blur.
+    public final void setHeight(double value) {
+        height.set(DropShadow.clamp(value, 0, 255));
+    }
+
+    /// The height of the blur.
+    public final DoubleProperty heightProperty() {
+        return height;
+    }
+
+    /// Returns the number of passes, from 0 to 3.
+    public final int getIterations() {
+        return iterations.get();
+    }
+
+    /// Sets the number of passes.
+    public final void setIterations(int value) {
+        iterations.set(value < 0 ? 0 : (value > 3 ? 3 : value));
+    }
+
+    /// The number of passes.
+    public final IntegerProperty iterationsProperty() {
+        return iterations;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/DropShadow.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/DropShadow.java
new file mode 100644
index 00000000000..9c6c3ab2230
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/DropShadow.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.paint.Color;
+
+/// A shadow cast behind a node: the outline of what the node paints,
+/// blurred over the radius, in the shadow's colour, moved by the offset.
+/// Every blur type is drawn with box passes -- three for a Gaussian one --
+/// and the radius decides the reach; `width` and `height` are kept and
+/// not read. A change of a value is drawn when the node is next painted.
+public class DropShadow extends Effect {
+
+    private final ObjectProperty<Effect> input = new SimpleObjectProperty<Effect>(this, "input");
+    private final DoubleProperty radius = new SimpleDoubleProperty(this, "radius", 10);
+    private final DoubleProperty width = new SimpleDoubleProperty(this, "width", 21);
+    private final DoubleProperty height = new SimpleDoubleProperty(this, "height", 21);
+    private final ObjectProperty<BlurType> blurType = new SimpleObjectProperty<BlurType>(this, "blurType",
+            BlurType.THREE_PASS_BOX);
+    private final DoubleProperty spread = new SimpleDoubleProperty(this, "spread", 0);
+    private final ObjectProperty<Color> color = new SimpleObjectProperty<Color>(this, "color", Color.BLACK);
+    private final DoubleProperty offsetX = new SimpleDoubleProperty(this, "offsetX", 0);
+    private final DoubleProperty offsetY = new SimpleDoubleProperty(this, "offsetY", 0);
+
+    /// Creates a black shadow of radius ten right under the node.
+    public DropShadow() {
+    }
+
+    /// Creates a shadow of a radius and a color.
+    public DropShadow(double radius, Color color) {
+        setRadius(radius);
+        setColor(color);
+    }
+
+    /// Creates a shadow of a radius, an offset and a color.
+    public DropShadow(double radius, double offsetX, double offsetY, Color color) {
+        setRadius(radius);
+        setOffsetX(offsetX);
+        setOffsetY(offsetY);
+        setColor(color);
+    }
+
+    /// Creates a shadow with every value given.
+    public DropShadow(BlurType blurType, Color color, double radius, double spread, double offsetX,
+            double offsetY) {
+        setBlurType(blurType);
+        setColor(color);
+        setRadius(radius);
+        setSpread(spread);
+        setOffsetX(offsetX);
+        setOffsetY(offsetY);
+    }
+
+    /// Returns the effect this one is applied on top of.
+    public final Effect getInput() {
+        return input.get();
+    }
+
+    /// Sets the effect this one is applied on top of.
+    public final void setInput(Effect value) {
+        input.set(value);
+    }
+
+    /// The effect this one is applied on top of.
+    public final ObjectProperty<Effect> inputProperty() {
+        return input;
+    }
+
+    /// Returns the radius of the blur, from 0 to 127.
+    public final double getRadius() {
+        return radius.get();
+    }
+
+    /// Sets the radius of the blur; the width and the height follow it,
+    /// each twice the radius and one.
+    public final void setRadius(double value) {
+        double r = clamp(value, 0, 127);
+        radius.set(r);
+        width.set(r * 2 + 1);
+        height.set(r * 2 + 1);
+    }
+
+    /// The radius of the blur.
+    public final DoubleProperty radiusProperty() {
+        return radius;
+    }
+
+    /// Returns the width of the blur, from 0 to 255.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Sets the width of the blur; the radius becomes what the width and
+    /// the height average to.
+    public final void setWidth(double value) {
+        width.set(clamp(value, 0, 255));
+        radius.set(((width.get() + height.get()) / 2 - 1) / 2);
+    }
+
+    /// The width of the blur.
+    public final DoubleProperty widthProperty() {
+        return width;
+    }
+
+    /// Returns the height of the blur, from 0 to 255.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// Sets the height of the blur; the radius becomes what the width
+    /// and the height average to.
+    public final void setHeight(double value) {
+        height.set(clamp(value, 0, 255));
+        radius.set(((width.get() + height.get()) / 2 - 1) / 2);
+    }
+
+    /// The height of the blur.
+    public final DoubleProperty heightProperty() {
+        return height;
+    }
+
+    /// Returns the way the shadow is softened.
+    public final BlurType getBlurType() {
+        BlurType t = blurType.get();
+        return t == null ? BlurType.THREE_PASS_BOX : t;
+    }
+
+    /// Sets the way the shadow is softened.
+    public final void setBlurType(BlurType value) {
+        blurType.set(value);
+    }
+
+    /// The way the shadow is softened.
+    public final ObjectProperty<BlurType> blurTypeProperty() {
+        return blurType;
+    }
+
+    /// Returns the part of the radius that is solid, from 0 to 1.
+    public final double getSpread() {
+        return spread.get();
+    }
+
+    /// Sets the part of the radius that is solid.
+    public final void setSpread(double value) {
+        spread.set(clamp(value, 0, 1));
+    }
+
+    /// The part of the radius that is solid.
+    public final DoubleProperty spreadProperty() {
+        return spread;
+    }
+
+    /// Returns the color of the shadow.
+    public final Color getColor() {
+        Color c = color.get();
+        return c == null ? Color.BLACK : c;
+    }
+
+    /// Sets the color of the shadow.
+    public final void setColor(Color value) {
+        color.set(value);
+    }
+
+    /// The color of the shadow.
+    public final ObjectProperty<Color> colorProperty() {
+        return color;
+    }
+
+    /// Returns how far to the right of the node the shadow falls.
+    public final double getOffsetX() {
+        return offsetX.get();
+    }
+
+    /// Sets how far to the right of the node the shadow falls.
+    public final void setOffsetX(double value) {
+        offsetX.set(value);
+    }
+
+    /// How far to the right of the node the shadow falls.
+    public final DoubleProperty offsetXProperty() {
+        return offsetX;
+    }
+
+    /// Returns how far below the node the shadow falls.
+    public final double getOffsetY() {
+        return offsetY.get();
+    }
+
+    /// Sets how far below the node the shadow falls.
+    public final void setOffsetY(double value) {
+        offsetY.set(value);
+    }
+
+    /// How far below the node the shadow falls.
+    public final DoubleProperty offsetYProperty() {
+        return offsetY;
+    }
+
+    static double clamp(double value, double min, double max) {
+        return value < min ? min : (value > max ? max : value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/Effect.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/Effect.java
new file mode 100644
index 00000000000..a2283c02d14
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/Effect.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+/// The base of the filters JavaFX runs over the picture of a node.
+///
+/// **Two effects are drawn: [DropShadow] and [InnerShadow]**, set on a
+/// node or by the `-fx-effect` of a style sheet (`dropshadow(...)`,
+/// `innershadow(...)`), behind or inside whatever the node paints. Each
+/// is also drawn when it is the `input` of the other.
+///
+/// Every other effect is recorded, read back and bound like any other
+/// property, and the node is painted exactly as it is without one: no
+/// glow, no blur. An effect adds nothing to the bounds of its node, drawn
+/// or not. The other classes are here because an effect is nearly always
+/// decoration, and an application that sets one is better drawn without
+/// it than not built at all. The effects that change what a node shows rather than
+/// decorate it - the perspective transform, lighting, blending, the
+/// displacement map - are deliberately not part of this package.
+///
+/// `Platform.isSupported(ConditionalFeature.EFFECT)` answers `false`.
+public abstract class Effect {
+
+    /// Creates an effect.
+    protected Effect() {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/GaussianBlur.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/GaussianBlur.java
new file mode 100644
index 00000000000..fa54c2c87aa
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/GaussianBlur.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+
+/// A Gaussian blur of a node. **Recorded and not drawn**: a node with
+/// one is painted sharp, see [Effect].
+public class GaussianBlur extends Effect {
+
+    private final ObjectProperty<Effect> input = new SimpleObjectProperty<Effect>(this, "input");
+    private final DoubleProperty radius = new SimpleDoubleProperty(this, "radius", 10);
+
+    /// Creates a blur of radius ten.
+    public GaussianBlur() {
+    }
+
+    /// Creates a blur of a radius.
+    public GaussianBlur(double radius) {
+        setRadius(radius);
+    }
+
+    /// Returns the effect this one is applied on top of.
+    public final Effect getInput() {
+        return input.get();
+    }
+
+    /// Sets the effect this one is applied on top of.
+    public final void setInput(Effect value) {
+        input.set(value);
+    }
+
+    /// The effect this one is applied on top of.
+    public final ObjectProperty<Effect> inputProperty() {
+        return input;
+    }
+
+    /// Returns the radius of the blur, from 0 to 63.
+    public final double getRadius() {
+        return radius.get();
+    }
+
+    /// Sets the radius of the blur.
+    public final void setRadius(double value) {
+        radius.set(DropShadow.clamp(value, 0, 63));
+    }
+
+    /// The radius of the blur.
+    public final DoubleProperty radiusProperty() {
+        return radius;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/Glow.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/Glow.java
new file mode 100644
index 00000000000..aeb33ca199c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/Glow.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+
+/// A glow over the bright parts of a node. **Recorded and not drawn**:
+/// see [Effect].
+public class Glow extends Effect {
+
+    private final ObjectProperty<Effect> input = new SimpleObjectProperty<Effect>(this, "input");
+    private final DoubleProperty level = new SimpleDoubleProperty(this, "level", 0.3);
+
+    /// Creates a glow of level 0.3.
+    public Glow() {
+    }
+
+    /// Creates a glow of a level.
+    public Glow(double level) {
+        setLevel(level);
+    }
+
+    /// Returns the effect this one is applied on top of.
+    public final Effect getInput() {
+        return input.get();
+    }
+
+    /// Sets the effect this one is applied on top of.
+    public final void setInput(Effect value) {
+        input.set(value);
+    }
+
+    /// The effect this one is applied on top of.
+    public final ObjectProperty<Effect> inputProperty() {
+        return input;
+    }
+
+    /// Returns the strength of the glow, from 0 to 1.
+    public final double getLevel() {
+        return level.get();
+    }
+
+    /// Sets the strength of the glow.
+    public final void setLevel(double value) {
+        level.set(DropShadow.clamp(value, 0, 1));
+    }
+
+    /// The strength of the glow.
+    public final DoubleProperty levelProperty() {
+        return level;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/InnerShadow.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/InnerShadow.java
new file mode 100644
index 00000000000..7b5b7921e9c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/InnerShadow.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.effect;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.paint.Color;
+
+/// A shadow cast inside the edges of a node, drawn over what it paints:
+/// see [Effect].
+public class InnerShadow extends Effect {
+
+    private final ObjectProperty<Effect> input = new SimpleObjectProperty<Effect>(this, "input");
+    private final DoubleProperty radius = new SimpleDoubleProperty(this, "radius", 10);
+    private final DoubleProperty width = new SimpleDoubleProperty(this, "width", 21);
+    private final DoubleProperty height = new SimpleDoubleProperty(this, "height", 21);
+    private final ObjectProperty<BlurType> blurType = new SimpleObjectProperty<BlurType>(this, "blurType",
+            BlurType.THREE_PASS_BOX);
+    private final DoubleProperty choke = new SimpleDoubleProperty(this, "choke", 0);
+    private final ObjectProperty<Color> color = new SimpleObjectProperty<Color>(this, "color", Color.BLACK);
+    private final DoubleProperty offsetX = new SimpleDoubleProperty(this, "offsetX", 0);
+    private final DoubleProperty offsetY = new SimpleDoubleProperty(this, "offsetY", 0);
+
+    /// Creates a black shadow of radius ten with no offset.
+    public InnerShadow() {
+    }
+
+    /// Creates a shadow of a radius and a color.
+    public InnerShadow(double radius, Color color) {
+        setRadius(radius);
+        setColor(color);
+    }
+
+    /// Creates a shadow of a radius, an offset and a color.
+    public InnerShadow(double radius, double offsetX, double offsetY, Color color) {
+        setRadius(radius);
+        setOffsetX(offsetX);
+        setOffsetY(offsetY);
+        setColor(color);
+    }
+
+    /// Creates a shadow with every value given.
+    public InnerShadow(BlurType blurType, Color color, double radius, double choke, double offsetX,
+            double offsetY) {
+        setBlurType(blurType);
+        setColor(color);
+        setRadius(radius);
+        setChoke(choke);
+        setOffsetX(offsetX);
+        setOffsetY(offsetY);
+    }
+
+    /// Returns the effect this one is applied on top of.
+    public final Effect getInput() {
+        return input.get();
+    }
+
+    /// Sets the effect this one is applied on top of.
+    public final void setInput(Effect value) {
+        input.set(value);
+    }
+
+    /// The effect this one is applied on top of.
+    public final ObjectProperty<Effect> inputProperty() {
+        return input;
+    }
+
+    /// Returns the radius of the blur, from 0 to 127.
+    public final double getRadius() {
+        return radius.get();
+    }
+
+    /// Sets the radius of the blur; the width and the height follow it.
+    public final void setRadius(double value) {
+        double r = DropShadow.clamp(value, 0, 127);
+        radius.set(r);
+        width.set(r * 2 + 1);
+        height.set(r * 2 + 1);
+    }
+
+    /// The radius of the blur.
+    public final DoubleProperty radiusProperty() {
+        return radius;
+    }
+
+    /// Returns the width of the blur, from 0 to 255.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Sets the width of the blur; the radius follows it.
+    public final void setWidth(double value) {
+        width.set(DropShadow.clamp(value, 0, 255));
+        radius.set(((width.get() + height.get()) / 2 - 1) / 2);
+    }
+
+    /// The width of the blur.
+    public final DoubleProperty widthProperty() {
+        return width;
+    }
+
+    /// Returns the height of the blur, from 0 to 255.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// Sets the height of the blur; the radius follows it.
+    public final void setHeight(double value) {
+        height.set(DropShadow.clamp(value, 0, 255));
+        radius.set(((width.get() + height.get()) / 2 - 1) / 2);
+    }
+
+    /// The height of the blur.
+    public final DoubleProperty heightProperty() {
+        return height;
+    }
+
+    /// Returns the way the shadow is softened.
+    public final BlurType getBlurType() {
+        BlurType t = blurType.get();
+        return t == null ? BlurType.THREE_PASS_BOX : t;
+    }
+
+    /// Sets the way the shadow is softened.
+    public final void setBlurType(BlurType value) {
+        blurType.set(value);
+    }
+
+    /// The way the shadow is softened.
+    public final ObjectProperty<BlurType> blurTypeProperty() {
+        return blurType;
+    }
+
+    /// Returns the part of the radius that is solid, from 0 to 1.
+    public final double getChoke() {
+        return choke.get();
+    }
+
+    /// Sets the part of the radius that is solid.
+    public final void setChoke(double value) {
+        choke.set(DropShadow.clamp(value, 0, 1));
+    }
+
+    /// The part of the radius that is solid.
+    public final DoubleProperty chokeProperty() {
+        return choke;
+    }
+
+    /// Returns the color of the shadow.
+    public final Color getColor() {
+        Color c = color.get();
+        return c == null ? Color.BLACK : c;
+    }
+
+    /// Sets the color of the shadow.
+    public final void setColor(Color value) {
+        color.set(value);
+    }
+
+    /// The color of the shadow.
+    public final ObjectProperty<Color> colorProperty() {
+        return color;
+    }
+
+    /// Returns how far to the right the shadow falls.
+    public final double getOffsetX() {
+        return offsetX.get();
+    }
+
+    /// Sets how far to the right the shadow falls.
+    public final void setOffsetX(double value) {
+        offsetX.set(value);
+    }
+
+    /// How far to the right the shadow falls.
+    public final DoubleProperty offsetXProperty() {
+        return offsetX;
+    }
+
+    /// Returns how far down the shadow falls.
+    public final double getOffsetY() {
+        return offsetY.get();
+    }
+
+    /// Sets how far down the shadow falls.
+    public final void setOffsetY(double value) {
+        offsetY.set(value);
+    }
+
+    /// How far down the shadow falls.
+    public final DoubleProperty offsetYProperty() {
+        return offsetY;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/effect/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/effect/package-info.java
new file mode 100644
index 00000000000..4b3a9eb67fe
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/effect/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The decorating effects of JavaFX, recorded and not drawn.
+///
+/// A node keeps the effect it is given and is painted without it. See
+/// [javafx.scene.effect.Effect] for what that means and for the effects
+/// that are left out on purpose.
+package javafx.scene.effect;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/image/Image.java b/maven/javafx-compat/src/main/java/javafx/scene/image/Image.java
new file mode 100644
index 00000000000..25da7282b5a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/image/Image.java
@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.image;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import com.codename1.fxcompat.runtime.ResourceUrls;
+import com.codename1.ui.Display;
+
+import javafx.beans.NamedArg;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.scene.paint.Color;
+
+/// A picture decoded by Codename One, for an [ImageView] or a canvas.
+///
+/// #### Where a URL is looked up
+///
+/// - `file:` URLs are opened through Codename One's
+///   `FileSystemStorage`, so they name files of the device's file system.
+/// - Anything else that is not `http:` or `https:` is a resource of the
+///   application, as a class path URL is in JavaFX: `"/images/logo.png"`,
+///   `"logo.png"` and the `jar:` or `file:`-less result of
+///   `getResource(...).toExternalForm()` all work. The whole path is
+///   tried first and then the file name alone, because a Codename One
+///   application keeps its resources in one flat directory on a device.
+/// - `http:` and `https:` URLs are **not loaded**; the image reports an
+///   error.
+///
+/// #### Loading is synchronous
+///
+/// The constructor returns with the image decoded or failed, also when
+/// `backgroundLoading` is asked for; the flag is recorded and
+/// `getProgress()` is 1 for a loaded image from the start. A failure
+/// never throws: `isError()` answers `true`, `getException()` says why
+/// and the size is zero.
+///
+/// The size is in pixels of the picture, and one of them is drawn as one
+/// logical pixel. A requested size scales the decoded picture once, here.
+///
+/// #### Not part of this layer
+///
+/// `getPixelReader()`, `WritableImage`, animated images and `smooth` as
+/// anything but a recorded flag.
+public class Image {
+
+    private final String url;
+    private final double requestedWidth;
+    private final double requestedHeight;
+    private final boolean preserveRatio;
+    private final boolean smooth;
+    private final boolean backgroundLoading;
+    private final ReadOnlyDoubleWrapper width = new ReadOnlyDoubleWrapper(this, "width", 0);
+    private final ReadOnlyDoubleWrapper height = new ReadOnlyDoubleWrapper(this, "height", 0);
+    private final ReadOnlyDoubleWrapper progress = new ReadOnlyDoubleWrapper(this, "progress", 0);
+    private final ReadOnlyBooleanWrapper error = new ReadOnlyBooleanWrapper(this, "error", false);
+    private final ReadOnlyObjectWrapper<Exception> exception = new ReadOnlyObjectWrapper<Exception>(this,
+            "exception");
+    private com.codename1.ui.Image nativeImage;
+    private int[] argb;
+    private PixelReader reader;
+
+    /// Loads an image from a URL at its own size.
+    public Image(@NamedArg("url") String url) {
+        this(url, 0, 0, false, false, false);
+    }
+
+    /// Loads an image from a URL at its own size. Loading is synchronous
+    /// whatever the flag says.
+    public Image(@NamedArg("url") String url, @NamedArg("backgroundLoading") boolean backgroundLoading) {
+        this(url, 0, 0, false, false, backgroundLoading);
+    }
+
+    /// Loads an image from a URL and scales it to a requested size; a
+    /// dimension that is not positive keeps the picture's own, or follows
+    /// the other one when the ratio is preserved.
+    public Image(@NamedArg("url") String url, @NamedArg("requestedWidth") double requestedWidth,
+            @NamedArg("requestedHeight") double requestedHeight, @NamedArg("preserveRatio") boolean preserveRatio,
+            @NamedArg("smooth") boolean smooth) {
+        this(url, requestedWidth, requestedHeight, preserveRatio, smooth, false);
+    }
+
+    /// Loads an image from a URL and scales it to a requested size.
+    /// Loading is synchronous whatever the flag says.
+    public Image(@NamedArg("url") String url, @NamedArg("requestedWidth") double requestedWidth,
+            @NamedArg("requestedHeight") double requestedHeight, @NamedArg("preserveRatio") boolean preserveRatio,
+            @NamedArg("smooth") boolean smooth, @NamedArg("backgroundLoading") boolean backgroundLoading) {
+        if (url == null) {
+            throw new NullPointerException("URL must not be null");
+        }
+        this.url = url;
+        this.requestedWidth = requestedWidth;
+        this.requestedHeight = requestedHeight;
+        this.preserveRatio = preserveRatio;
+        this.smooth = smooth;
+        this.backgroundLoading = backgroundLoading;
+        InputStream in = null;
+        try {
+            in = open(url);
+            decode(in);
+        } catch (IOException failed) {
+            fail(failed);
+        } catch (RuntimeException failed) {
+            // JavaFX never throws for a URL it cannot load: the image is
+            // in error, with the reason kept. A port may refuse a path or
+            // a picture by throwing.
+            fail(failed);
+        } finally {
+            close(in);
+        }
+    }
+
+    /// Decodes an image from a stream at its own size. The stream is read
+    /// to its end and left open.
+    public Image(InputStream is) {
+        this(is, 0, 0, false, false);
+    }
+
+    /// Decodes an image from a stream and scales it to a requested size.
+    public Image(InputStream is, double requestedWidth, double requestedHeight, boolean preserveRatio,
+            boolean smooth) {
+        if (is == null) {
+            throw new NullPointerException("Input stream must not be null");
+        }
+        this.url = null;
+        this.requestedWidth = requestedWidth;
+        this.requestedHeight = requestedHeight;
+        this.preserveRatio = preserveRatio;
+        this.smooth = smooth;
+        this.backgroundLoading = false;
+        try {
+            decode(is);
+        } catch (IOException failed) {
+            fail(failed);
+        } catch (RuntimeException failed) {
+            fail(failed);
+        }
+    }
+
+    /// Creates an image with no picture yet, of a size: what an image
+    /// that is written to starts as.
+    Image(int width, int height) {
+        if (width <= 0 || height <= 0) {
+            throw new IllegalArgumentException("Image dimensions must be positive (w,h > 0)");
+        }
+        this.url = null;
+        this.requestedWidth = 0;
+        this.requestedHeight = 0;
+        this.preserveRatio = false;
+        this.smooth = false;
+        this.backgroundLoading = false;
+        this.width.set(width);
+        this.height.set(height);
+        this.progress.set(1);
+    }
+
+    /// The Codename One image as it is now.
+    com.codename1.ui.Image current() {
+        return nativeImage;
+    }
+
+    /// The pixels as `0xAARRGGBB`, row after row, or `null` when there is
+    /// no picture. Not to be written to.
+    int[] pixels() {
+        if (argb == null && nativeImage != null) {
+            argb = nativeImage.getRGB();
+        }
+        return argb;
+    }
+
+    /// Has a view told when the pixels change; an image that was decoded
+    /// never changes.
+    void addPixelListener(Runnable listener) {
+    }
+
+    /// Stops telling a view.
+    void removePixelListener(Runnable listener) {
+    }
+
+    /// Returns what reads the pixels of the image, or `null` for an
+    /// image that failed to load.
+    public final PixelReader getPixelReader() {
+        if (pixels() == null) {
+            return null;
+        }
+        if (reader == null) {
+            reader = new PixelReader() {
+                @Override
+                public int getArgb(int x, int y) {
+                    int w = (int) getWidth();
+                    int h = (int) getHeight();
+                    if (x < 0 || y < 0 || x >= w || y >= h) {
+                        throw new IndexOutOfBoundsException(x + ", " + y);
+                    }
+                    return pixels()[y * w + x];
+                }
+
+                @Override
+                public Color getColor(int x, int y) {
+                    int v = getArgb(x, y);
+                    return Color.rgb((v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff, ((v >>> 24) & 0xff) / 255.0);
+                }
+            };
+        }
+        return reader;
+    }
+
+    private static void close(InputStream in) {
+        if (in != null) {
+            try {
+                in.close();
+            } catch (IOException ignored) {
+                // Nothing to do about a stream that will not close.
+                return;
+            }
+        }
+    }
+
+    private static boolean startsWith(String s, String prefix) {
+        return s.regionMatches(true, 0, prefix, 0, prefix.length());
+    }
+
+    private static InputStream resource(String path) {
+        try {
+            return Display.getInstance().getResourceAsStream(Image.class, path);
+        } catch (RuntimeException unavailable) {
+            // A port that keeps resources flat rejects a path with
+            // directories outright.
+            return null;
+        }
+    }
+
+    private static InputStream open(String url) throws IOException {
+        if (startsWith(url, "http:") || startsWith(url, "https:")) {
+            throw new IOException("Remote images are not supported: " + url);
+        }
+        if (startsWith(url, "file:")) {
+            // Never the URL as written: a port's file system throws for a
+            // path that is not absolute.
+            InputStream file = ResourceUrls.openFile(url);
+            if (file == null) {
+                throw new IOException("Image not found: " + url);
+            }
+            return file;
+        }
+        String path = url;
+        int bang = path.lastIndexOf("!/");
+        if (bang >= 0) {
+            // jar:file:/app.jar!/images/logo.png
+            path = path.substring(bang + 1);
+        } else {
+            int scheme = path.indexOf(":/");
+            if (scheme >= 0) {
+                path = path.substring(scheme + 1);
+            }
+        }
+        while (path.startsWith("//")) {
+            path = path.substring(1);
+        }
+        if (!path.startsWith("/")) {
+            path = "/" + path;
+        }
+        // Through the resource index first: a device keeps a nested
+        // resource under a flat name only that knows, and a port refuses a
+        // path with directories.
+        InputStream in = ResourceUrls.open(url);
+        if (in == null) {
+            in = resource(path);
+        }
+        int slash = path.lastIndexOf('/');
+        if (in == null && slash > 0) {
+            in = resource(path.substring(slash));
+        }
+        if (in == null) {
+            throw new IOException("Image not found: " + url);
+        }
+        return in;
+    }
+
+    private void fail(Exception why) {
+        nativeImage = null;
+        width.set(0);
+        height.set(0);
+        exception.set(why);
+        error.set(true);
+    }
+
+    private void decode(InputStream in) throws IOException {
+        com.codename1.ui.Image decoded;
+        try {
+            decoded = com.codename1.ui.Image.createImage(in);
+        } catch (RuntimeException undecodable) {
+            throw new IOException("Not an image: " + undecodable);
+        }
+        if (decoded == null || decoded.getWidth() <= 0 || decoded.getHeight() <= 0) {
+            throw new IOException("Not an image");
+        }
+        double w = decoded.getWidth();
+        double h = decoded.getHeight();
+        double tw;
+        double th;
+        if (preserveRatio) {
+            double k = 1;
+            if (requestedWidth > 0 && requestedHeight > 0) {
+                k = Math.min(requestedWidth / w, requestedHeight / h);
+            } else if (requestedWidth > 0) {
+                k = requestedWidth / w;
+            } else if (requestedHeight > 0) {
+                k = requestedHeight / h;
+            }
+            tw = w * k;
+            th = h * k;
+        } else {
+            tw = requestedWidth > 0 ? requestedWidth : w;
+            th = requestedHeight > 0 ? requestedHeight : h;
+        }
+        int pw = (int) Math.max(1, Math.round(tw));
+        int ph = (int) Math.max(1, Math.round(th));
+        if (pw != decoded.getWidth() || ph != decoded.getHeight()) {
+            decoded = decoded.scaled(pw, ph);
+        }
+        nativeImage = decoded;
+        width.set(pw);
+        height.set(ph);
+        progress.set(1);
+    }
+
+    /// Returns the Codename One image, or `null` when loading failed.
+    public final com.codename1.ui.Image cn1Native() {
+        return current();
+    }
+
+    /// Returns the URL the image was loaded from; `null` for a stream.
+    public final String getUrl() {
+        return url;
+    }
+
+    /// Returns how much of the image is loaded: 1 for a loaded image, 0
+    /// for one that failed.
+    public final double getProgress() {
+        return progress.get();
+    }
+
+    /// How much of the image is loaded.
+    public final ReadOnlyDoubleProperty progressProperty() {
+        return progress.getReadOnlyProperty();
+    }
+
+    /// Returns the width asked for, or 0.
+    public final double getRequestedWidth() {
+        return requestedWidth;
+    }
+
+    /// Returns the height asked for, or 0.
+    public final double getRequestedHeight() {
+        return requestedHeight;
+    }
+
+    /// Returns the width in pixels; 0 when loading failed.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// The width in pixels.
+    public final ReadOnlyDoubleProperty widthProperty() {
+        return width.getReadOnlyProperty();
+    }
+
+    /// Returns the height in pixels; 0 when loading failed.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// The height in pixels.
+    public final ReadOnlyDoubleProperty heightProperty() {
+        return height.getReadOnlyProperty();
+    }
+
+    /// Returns whether a requested size keeps the picture's proportions.
+    public final boolean isPreserveRatio() {
+        return preserveRatio;
+    }
+
+    /// Returns whether a better scaling filter was asked for.
+    public final boolean isSmooth() {
+        return smooth;
+    }
+
+    /// Returns whether loading in the background was asked for.
+    public final boolean isBackgroundLoading() {
+        return backgroundLoading;
+    }
+
+    /// Returns whether loading failed.
+    public final boolean isError() {
+        return error.get();
+    }
+
+    /// Whether loading failed.
+    public final ReadOnlyBooleanProperty errorProperty() {
+        return error.getReadOnlyProperty();
+    }
+
+    /// Returns why loading failed, or `null`.
+    public final Exception getException() {
+        return exception.get();
+    }
+
+    /// Why loading failed.
+    public final ReadOnlyObjectProperty<Exception> exceptionProperty() {
+        return exception.getReadOnlyProperty();
+    }
+
+    /// Stops a background load. Loading is over before the constructor
+    /// returns, so there is never one to stop.
+    public void cancel() {
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/image/ImageView.java b/maven/javafx-compat/src/main/java/javafx/scene/image/ImageView.java
new file mode 100644
index 00000000000..cb519d08f9f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/image/ImageView.java
@@ -0,0 +1,315 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.image;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.Node;
+
+/// A node that shows an [Image], or the part of it a viewport selects,
+/// at its own size or fitted into a box.
+///
+/// The size shown starts from the viewport's size, or the image's when
+/// there is no viewport. `fitWidth` and `fitHeight`, when above zero,
+/// replace the width and the height; with `preserveRatio` the picture is
+/// instead scaled by one factor so that it fits inside what was given:
+/// the smaller of the two factors when both are set, the one that is set
+/// otherwise.
+///
+/// `smooth` is recorded; scaling quality is the platform's. The `-fx-image`
+/// style name is not part of this layer.
+public class ImageView extends Node {
+
+    private final ObjectProperty<Image> image = new FxObject<Image>(this, "image", null, Dirty.GEOMETRY);
+    private final DoubleProperty x = new FxDouble(this, "x", 0, Dirty.GEOMETRY);
+    private final DoubleProperty y = new FxDouble(this, "y", 0, Dirty.GEOMETRY);
+    private final DoubleProperty fitWidth = new FxDouble(this, "fitWidth", 0, Dirty.GEOMETRY);
+    private final DoubleProperty fitHeight = new FxDouble(this, "fitHeight", 0, Dirty.GEOMETRY);
+    private final BooleanProperty preserveRatio = new FxBoolean(this, "preserveRatio", false, Dirty.GEOMETRY);
+    private final BooleanProperty smooth = new FxBoolean(this, "smooth", true, Dirty.PAINT);
+    private final ObjectProperty<Rectangle2D> viewport = new FxObject<Rectangle2D>(this, "viewport", null,
+            Dirty.GEOMETRY);
+
+    private com.codename1.ui.Image shown;
+    private boolean shownValid;
+    private Image heard;
+    private final Runnable pixelsChanged = new Runnable() {
+        @Override
+        public void run() {
+            pixelsChanged();
+        }
+    };
+
+    /// Creates a view without an image.
+    public ImageView() {
+    }
+
+    /// Creates a view of the image at a URL; see [Image] for where it is
+    /// looked up.
+    public ImageView(String url) {
+        image.set(new Image(url));
+    }
+
+    /// Creates a view of an image.
+    public ImageView(Image image) {
+        this.image.set(image);
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & Dirty.GEOMETRY) != 0) {
+            shown = null;
+            shownValid = false;
+            // An image that is written to tells the view it is shown in.
+            Image now = image == null ? null : image.get();
+            if (now != heard) {
+                if (heard != null) {
+                    heard.removePixelListener(pixelsChanged);
+                }
+                heard = now;
+                if (now != null) {
+                    now.addPixelListener(pixelsChanged);
+                }
+            }
+        }
+        super.cn1Invalidated(what);
+    }
+
+    private void pixelsChanged() {
+        shown = null;
+        shownValid = false;
+        super.cn1Invalidated(Dirty.PAINT);
+    }
+
+    /// Returns the image, or `null`.
+    public final Image getImage() {
+        return image.get();
+    }
+
+    /// Sets the image.
+    public final void setImage(Image value) {
+        image.set(value);
+    }
+
+    /// The image.
+    public final ObjectProperty<Image> imageProperty() {
+        return image;
+    }
+
+    /// Returns the x of the top left corner.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the top left corner.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the top left corner.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the top left corner.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the top left corner.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the top left corner.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    /// Returns the width to fit the picture into; 0 for its own.
+    public final double getFitWidth() {
+        return fitWidth.get();
+    }
+
+    /// Sets the width to fit the picture into; 0 for its own.
+    public final void setFitWidth(double value) {
+        fitWidth.set(value);
+    }
+
+    /// The width to fit the picture into.
+    public final DoubleProperty fitWidthProperty() {
+        return fitWidth;
+    }
+
+    /// Returns the height to fit the picture into; 0 for its own.
+    public final double getFitHeight() {
+        return fitHeight.get();
+    }
+
+    /// Sets the height to fit the picture into; 0 for its own.
+    public final void setFitHeight(double value) {
+        fitHeight.set(value);
+    }
+
+    /// The height to fit the picture into.
+    public final DoubleProperty fitHeightProperty() {
+        return fitHeight;
+    }
+
+    /// Returns whether fitting keeps the picture's proportions.
+    public final boolean isPreserveRatio() {
+        return preserveRatio.get();
+    }
+
+    /// Sets whether fitting keeps the picture's proportions.
+    public final void setPreserveRatio(boolean value) {
+        preserveRatio.set(value);
+    }
+
+    /// Whether fitting keeps the picture's proportions.
+    public final BooleanProperty preserveRatioProperty() {
+        return preserveRatio;
+    }
+
+    /// Returns whether a better scaling filter was asked for.
+    public final boolean isSmooth() {
+        return smooth.get();
+    }
+
+    /// Records whether a better scaling filter is asked for.
+    public final void setSmooth(boolean value) {
+        smooth.set(value);
+    }
+
+    /// Whether a better scaling filter is asked for.
+    public final BooleanProperty smoothProperty() {
+        return smooth;
+    }
+
+    /// Returns the part of the image that is shown, in its pixels, or
+    /// `null` for all of it.
+    public final Rectangle2D getViewport() {
+        return viewport.get();
+    }
+
+    /// Sets the part of the image that is shown.
+    public final void setViewport(Rectangle2D value) {
+        viewport.set(value);
+    }
+
+    /// The part of the image that is shown.
+    public final ObjectProperty<Rectangle2D> viewportProperty() {
+        return viewport;
+    }
+
+    private double sourceWidth() {
+        Rectangle2D v = getViewport();
+        if (v != null && v.getWidth() > 0 && v.getHeight() > 0) {
+            return v.getWidth();
+        }
+        Image i = getImage();
+        return i == null ? 0 : i.getWidth();
+    }
+
+    private double sourceHeight() {
+        Rectangle2D v = getViewport();
+        if (v != null && v.getWidth() > 0 && v.getHeight() > 0) {
+            return v.getHeight();
+        }
+        Image i = getImage();
+        return i == null ? 0 : i.getHeight();
+    }
+
+    /// Writes the size the picture is shown at into `{width, height}`.
+    private double[] shownSize() {
+        double w = sourceWidth();
+        double h = sourceHeight();
+        double fw = getFitWidth();
+        double fh = getFitHeight();
+        if (!(w > 0) || !(h > 0)) {
+            return new double[] {0, 0};
+        }
+        if (isPreserveRatio()) {
+            double k = 1;
+            if (fw > 0 && fh > 0) {
+                k = Math.min(fw / w, fh / h);
+            } else if (fw > 0) {
+                k = fw / w;
+            } else if (fh > 0) {
+                k = fh / h;
+            }
+            return new double[] {w * k, h * k};
+        }
+        return new double[] {fw > 0 ? fw : w, fh > 0 ? fh : h};
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        double[] size = shownSize();
+        return new BoundingBox(getX(), getY(), size[0], size[1]);
+    }
+
+    private com.codename1.ui.Image picture() {
+        if (shownValid) {
+            return shown;
+        }
+        shownValid = true;
+        shown = null;
+        Image i = getImage();
+        com.codename1.ui.Image full = i == null ? null : i.cn1Native();
+        if (full == null) {
+            return null;
+        }
+        shown = full;
+        Rectangle2D v = getViewport();
+        if (v != null && v.getWidth() > 0 && v.getHeight() > 0) {
+            // The part of the viewport that lies on the picture.
+            int x1 = (int) Math.max(0, Math.round(v.getMinX()));
+            int y1 = (int) Math.max(0, Math.round(v.getMinY()));
+            int x2 = (int) Math.min(full.getWidth(), Math.round(v.getMaxX()));
+            int y2 = (int) Math.min(full.getHeight(), Math.round(v.getMaxY()));
+            shown = x2 > x1 && y2 > y1 ? full.subImage(x1, y1, x2 - x1, y2 - y1, true) : null;
+        }
+        return shown;
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        com.codename1.ui.Image picture = picture();
+        if (picture == null) {
+            return;
+        }
+        double[] size = shownSize();
+        renderer.drawImage(picture, getX(), getY(), size[0], size[1]);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/image/PixelReader.java b/maven/javafx-compat/src/main/java/javafx/scene/image/PixelReader.java
new file mode 100644
index 00000000000..89fb921ecfe
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/image/PixelReader.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.image;
+
+import javafx.scene.paint.Color;
+
+/// Reads the pixels of an image, one at a time. The buffer forms of
+/// JavaFX, which need `java.nio`, are not part of this layer.
+public interface PixelReader {
+
+    /// Returns a pixel as `0xAARRGGBB`, not premultiplied.
+    int getArgb(int x, int y);
+
+    /// Returns a pixel as a colour.
+    Color getColor(int x, int y);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/image/PixelWriter.java b/maven/javafx-compat/src/main/java/javafx/scene/image/PixelWriter.java
new file mode 100644
index 00000000000..cb04c39c76c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/image/PixelWriter.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.image;
+
+import javafx.scene.paint.Color;
+
+/// Writes the pixels of an image. It may be written to from any thread,
+/// as in JavaFX; what shows the image follows on the application
+/// thread. The buffer forms of JavaFX, which need `java.nio`, are not
+/// part of this layer.
+public interface PixelWriter {
+
+    /// Sets a pixel from `0xAARRGGBB`, not premultiplied.
+    void setArgb(int x, int y, int argb);
+
+    /// Sets a pixel from a colour.
+    void setColor(int x, int y, Color c);
+
+    /// Copies a rectangle of pixels from a reader.
+    void setPixels(int dstx, int dsty, int w, int h, PixelReader reader, int srcx, int srcy);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/image/WritableImage.java b/maven/javafx-compat/src/main/java/javafx/scene/image/WritableImage.java
new file mode 100644
index 00000000000..d9c9e95594b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/image/WritableImage.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.image;
+
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import com.codename1.ui.Display;
+
+import javafx.scene.paint.Color;
+
+/// An image whose pixels the application writes.
+///
+/// The pixels are kept as an array, which is what the writer and the
+/// reader work on. The Codename One image that is drawn is made from
+/// the array when it is next needed after a change, so a burst of
+/// writes costs one image. A change reaches the views of the image on
+/// the application thread, once for all the writes made since the last
+/// time, whichever thread wrote.
+public class WritableImage extends Image {
+
+    private final int w;
+    private final int h;
+    private final int[] argb;
+    private final ArrayList<Runnable> listeners = new ArrayList<Runnable>();
+    private final AtomicBoolean pending = new AtomicBoolean();
+    private final AtomicBoolean stale = new AtomicBoolean(true);
+    private com.codename1.ui.Image built;
+    private PixelWriter writer;
+
+    private final Runnable tell = new Runnable() {
+        @Override
+        public void run() {
+            pending.set(false);
+            Runnable[] all = listeners.toArray(new Runnable[listeners.size()]);
+            for (int i = 0; i < all.length; i++) {
+                all[i].run();
+            }
+        }
+    };
+
+    /// Creates a transparent image of a size.
+    public WritableImage(int width, int height) {
+        super(width, height);
+        this.w = width;
+        this.h = height;
+        this.argb = new int[width * height];
+    }
+
+    /// Creates an image of a size from the pixels a reader answers.
+    public WritableImage(PixelReader reader, int width, int height) {
+        this(reader, 0, 0, width, height);
+    }
+
+    /// Creates an image from a rectangle of the pixels a reader answers.
+    public WritableImage(PixelReader reader, int x, int y, int width, int height) {
+        this(width, height);
+        if (reader == null) {
+            throw new NullPointerException("reader must not be null");
+        }
+        for (int row = 0; row < height; row++) {
+            for (int col = 0; col < width; col++) {
+                argb[row * width + col] = reader.getArgb(x + col, y + row);
+            }
+        }
+    }
+
+    @Override
+    int[] pixels() {
+        return argb;
+    }
+
+    @Override
+    com.codename1.ui.Image current() {
+        if (stale.getAndSet(false) || built == null) {
+            built = com.codename1.ui.Image.createImage(argb, w, h);
+        }
+        return built;
+    }
+
+    @Override
+    void addPixelListener(Runnable listener) {
+        listeners.add(listener);
+    }
+
+    @Override
+    void removePixelListener(Runnable listener) {
+        listeners.remove(listener);
+    }
+
+    /// The pixels changed: the image drawn is out of date, and the views
+    /// hear of it on the application thread.
+    private void changed() {
+        stale.set(true);
+        if (pending.compareAndSet(false, true)) {
+            if (Display.isInitialized() && !Display.getInstance().isEdt()) {
+                Display.getInstance().callSerially(tell);
+            } else {
+                tell.run();
+            }
+        }
+    }
+
+    /// Replaces every pixel; the array is `0xAARRGGBB` row after row and
+    /// as long as the image is large.
+    public final void cn1SetPixels(int[] pixels) {
+        if (pixels == null || pixels.length != argb.length) {
+            throw new IllegalArgumentException("as many pixels as the image has");
+        }
+        System.arraycopy(pixels, 0, argb, 0, argb.length);
+        changed();
+    }
+
+    /// Returns what writes the pixels of the image.
+    public final PixelWriter getPixelWriter() {
+        if (writer == null) {
+            writer = new PixelWriter() {
+                @Override
+                public void setArgb(int x, int y, int value) {
+                    if (x < 0 || y < 0 || x >= w || y >= h) {
+                        throw new IndexOutOfBoundsException(x + ", " + y);
+                    }
+                    argb[y * w + x] = value;
+                    changed();
+                }
+
+                @Override
+                public void setColor(int x, int y, Color c) {
+                    if (c == null) {
+                        throw new NullPointerException("Color cannot be null");
+                    }
+                    setArgb(x, y, c.cn1Argb());
+                }
+
+                @Override
+                public void setPixels(int dstx, int dsty, int width, int height, PixelReader reader, int srcx,
+                        int srcy) {
+                    if (reader == null) {
+                        throw new NullPointerException("Reader cannot be null");
+                    }
+                    for (int row = 0; row < height; row++) {
+                        for (int col = 0; col < width; col++) {
+                            int x = dstx + col;
+                            int y = dsty + row;
+                            if (x >= 0 && y >= 0 && x < w && y < h) {
+                                argb[y * w + x] = reader.getArgb(srcx + col, srcy + row);
+                            }
+                        }
+                    }
+                    changed();
+                }
+            };
+        }
+        return writer;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/image/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/image/package-info.java
new file mode 100644
index 00000000000..efbaa30ee7b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/image/package-info.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Images and the node that shows one. Pictures are decoded by Codename
+/// One. Pixels are read and written one at a time or as a rectangle
+/// copied from a reader; the `java.nio` buffer forms are not part of
+/// this layer.
+package javafx.scene.image;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/ContextMenuEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/ContextMenuEvent.java
new file mode 100644
index 00000000000..870bea0ad61
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/ContextMenuEvent.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+
+/// The user asked for a context menu: a secondary click with a mouse, a
+/// long press on a touch screen.
+public class ContextMenuEvent extends InputEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// A context menu was asked for.
+    public static final EventType<ContextMenuEvent> CONTEXT_MENU_REQUESTED = new EventType<ContextMenuEvent>(
+            InputEvent.ANY, "CONTEXTMENUREQUESTED");
+
+    /// Every context menu event.
+    public static final EventType<ContextMenuEvent> ANY = CONTEXT_MENU_REQUESTED;
+
+    private final boolean keyboardTrigger;
+    private transient double x;
+    private transient double y;
+    private final double screenX;
+    private final double screenY;
+    private final double sceneX;
+    private final double sceneY;
+    private final transient PickResult pickResult;
+
+    /// Creates a context menu event; `x` and `y` are scene coordinates.
+    public ContextMenuEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<ContextMenuEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("keyboardTrigger") boolean keyboardTrigger, @NamedArg("pickResult") PickResult pickResult) {
+        super(source, target, eventType);
+        this.sceneX = x;
+        this.sceneY = y;
+        this.screenX = screenX;
+        this.screenY = screenY;
+        this.keyboardTrigger = keyboardTrigger;
+        this.pickResult = pickResult != null ? pickResult : new PickResult(target, x, y);
+        localize(source);
+    }
+
+    /// Creates a context menu event with no source and no target.
+    public ContextMenuEvent(@NamedArg("eventType") EventType<ContextMenuEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("keyboardTrigger") boolean keyboardTrigger, @NamedArg("pickResult") PickResult pickResult) {
+        this(null, null, eventType, x, y, screenX, screenY, keyboardTrigger, pickResult);
+    }
+
+    private void localize(Object source) {
+        if (source instanceof Node) {
+            Point2D local = ((Node) source).sceneToLocal(sceneX, sceneY);
+            x = local.getX();
+            y = local.getY();
+        } else {
+            x = sceneX;
+            y = sceneY;
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public ContextMenuEvent copyFor(Object newSource, EventTarget newTarget) {
+        if (getClass() != ContextMenuEvent.class) {
+            super.copyFor(newSource, newTarget);
+            localize(getSource());
+            return this;
+        }
+        return new ContextMenuEvent(newSource, newTarget, (EventType<ContextMenuEvent>) getEventType(), sceneX,
+                sceneY, screenX, screenY, keyboardTrigger, pickResult);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<ContextMenuEvent> getEventType() {
+        return (EventType<ContextMenuEvent>) super.getEventType();
+    }
+
+    /// Returns whether the keyboard asked for the menu.
+    public boolean isKeyboardTrigger() {
+        return keyboardTrigger;
+    }
+
+    /// Returns the x of the request in the source's coordinates.
+    public final double getX() {
+        return x;
+    }
+
+    /// Returns the y of the request in the source's coordinates.
+    public final double getY() {
+        return y;
+    }
+
+    /// Always 0: this layer is two dimensional.
+    public final double getZ() {
+        return 0;
+    }
+
+    /// Returns the x of the request on the screen.
+    public final double getScreenX() {
+        return screenX;
+    }
+
+    /// Returns the y of the request on the screen.
+    public final double getScreenY() {
+        return screenY;
+    }
+
+    /// Returns the x of the request in the scene.
+    public final double getSceneX() {
+        return sceneX;
+    }
+
+    /// Returns the y of the request in the scene.
+    public final double getSceneY() {
+        return sceneY;
+    }
+
+    /// Returns what was under the pointer.
+    public final PickResult getPickResult() {
+        return pickResult;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/GestureEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/GestureEvent.java
new file mode 100644
index 00000000000..b3855e6b517
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/GestureEvent.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+
+/// The base of the events a gesture produces, such as a swipe.
+///
+/// A gesture is reported where it began. Its position is the centre of the
+/// gesture in the coordinates of the node the event is delivered to, in the
+/// scene and on the screen.
+public class GestureEvent extends InputEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The supertype of every gesture event.
+    public static final EventType<GestureEvent> ANY = new EventType<GestureEvent>(InputEvent.ANY, "GESTURE");
+
+    private transient double x;
+    private transient double y;
+    private final double screenX;
+    private final double screenY;
+    private final double sceneX;
+    private final double sceneY;
+    private final boolean shiftDown;
+    private final boolean controlDown;
+    private final boolean altDown;
+    private final boolean metaDown;
+    private final boolean direct;
+    private final boolean inertia;
+    private final transient PickResult pickResult;
+
+    /// Creates a gesture event at scene coordinates.
+    protected GestureEvent(Object source, EventTarget target, EventType<? extends GestureEvent> eventType, double x,
+            double y, double screenX, double screenY, boolean shiftDown, boolean controlDown, boolean altDown,
+            boolean metaDown, boolean direct, boolean inertia, PickResult pickResult) {
+        super(source, target, eventType);
+        this.sceneX = x;
+        this.sceneY = y;
+        this.screenX = screenX;
+        this.screenY = screenY;
+        this.shiftDown = shiftDown;
+        this.controlDown = controlDown;
+        this.altDown = altDown;
+        this.metaDown = metaDown;
+        this.direct = direct;
+        this.inertia = inertia;
+        this.pickResult = pickResult != null ? pickResult : new PickResult(target, x, y);
+        localize(source);
+    }
+
+    /// Creates a gesture event with no source or target.
+    protected GestureEvent(EventType<? extends GestureEvent> eventType, double x, double y, double screenX,
+            double screenY, boolean shiftDown, boolean controlDown, boolean altDown, boolean metaDown,
+            boolean direct, boolean inertia, PickResult pickResult) {
+        this(null, null, eventType, x, y, screenX, screenY, shiftDown, controlDown, altDown, metaDown, direct,
+                inertia, pickResult);
+    }
+
+    private void localize(Object source) {
+        if (source instanceof Node) {
+            Point2D local = ((Node) source).sceneToLocal(sceneX, sceneY);
+            x = local.getX();
+            y = local.getY();
+        } else {
+            x = sceneX;
+            y = sceneY;
+        }
+    }
+
+    /// Re-targets this event; the position follows the new source.
+    @Override
+    public GestureEvent copyFor(Object newSource, EventTarget newTarget) {
+        Object copied = super.copyFor(newSource, newTarget);
+        if (copied instanceof GestureEvent) {
+            GestureEvent e = (GestureEvent) copied;
+            e.localize(e.getSource());
+            return e;
+        }
+        return this;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<? extends GestureEvent> getEventType() {
+        return (EventType<? extends GestureEvent>) super.getEventType();
+    }
+
+    /// Returns the horizontal position in the coordinates of the source.
+    public final double getX() {
+        return x;
+    }
+
+    /// Returns the vertical position in the coordinates of the source.
+    public final double getY() {
+        return y;
+    }
+
+    /// Returns the depth of the position, always zero in a flat scene.
+    public final double getZ() {
+        return 0;
+    }
+
+    /// Returns the horizontal position on the screen.
+    public final double getScreenX() {
+        return screenX;
+    }
+
+    /// Returns the vertical position on the screen.
+    public final double getScreenY() {
+        return screenY;
+    }
+
+    /// Returns the horizontal position in the scene.
+    public final double getSceneX() {
+        return sceneX;
+    }
+
+    /// Returns the vertical position in the scene.
+    public final double getSceneY() {
+        return sceneY;
+    }
+
+    /// Returns whether Shift was held.
+    public final boolean isShiftDown() {
+        return shiftDown;
+    }
+
+    /// Returns whether Control was held.
+    public final boolean isControlDown() {
+        return controlDown;
+    }
+
+    /// Returns whether Alt was held.
+    public final boolean isAltDown() {
+        return altDown;
+    }
+
+    /// Returns whether Meta was held.
+    public final boolean isMetaDown() {
+        return metaDown;
+    }
+
+    /// Returns whether the gesture was made on the screen itself rather
+    /// than on a trackpad.
+    public final boolean isDirect() {
+        return direct;
+    }
+
+    /// Returns whether the event continues a gesture the user already
+    /// ended.
+    public boolean isInertia() {
+        return inertia;
+    }
+
+    /// Returns what was under the gesture.
+    public final PickResult getPickResult() {
+        return pickResult;
+    }
+
+    /// Returns whether the platform's shortcut modifier was held.
+    public final boolean isShortcutDown() {
+        return controlDown || metaDown;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/InputEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/InputEvent.java
new file mode 100644
index 00000000000..743bc61df25
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/InputEvent.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.beans.NamedArg;
+import javafx.event.Event;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// The base of every event that comes from the user: mouse, key, scroll.
+public class InputEvent extends Event {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Every input event.
+    public static final EventType<InputEvent> ANY = new EventType<InputEvent>(Event.ANY, "INPUT");
+
+    /// Creates an input event with no source and no target.
+    public InputEvent(@NamedArg("eventType") EventType<? extends InputEvent> eventType) {
+        super(eventType);
+    }
+
+    /// Creates an input event.
+    public InputEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<? extends InputEvent> eventType) {
+        super(source, target, eventType);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<? extends InputEvent> getEventType() {
+        return (EventType<? extends InputEvent>) super.getEventType();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCode.java b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCode.java
new file mode 100644
index 00000000000..58ba0d108dc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCode.java
@@ -0,0 +1,817 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import java.util.HashMap;
+
+/// The keys of a keyboard, each with the name it is shown by.
+public enum KeyCode {
+
+    /// The `Enter` key.
+    ENTER(0x0A, "Enter", KeyCodeClass.WHITESPACE),
+
+    /// The `Backspace` key.
+    BACK_SPACE(0x08, "Backspace"),
+
+    /// The `Tab` key.
+    TAB(0x09, "Tab", KeyCodeClass.WHITESPACE),
+
+    /// The `Cancel` key.
+    CANCEL(0x03, "Cancel"),
+
+    /// The `Clear` key.
+    CLEAR(0x0C, "Clear"),
+
+    /// The `Shift` key.
+    SHIFT(0x10, "Shift", KeyCodeClass.MODIFIER),
+
+    /// The `Ctrl` key.
+    CONTROL(0x11, "Ctrl", KeyCodeClass.MODIFIER),
+
+    /// The `Alt` key.
+    ALT(0x12, "Alt", KeyCodeClass.MODIFIER),
+
+    /// The `Pause` key.
+    PAUSE(0x13, "Pause"),
+
+    /// The `Caps Lock` key.
+    CAPS(0x14, "Caps Lock"),
+
+    /// The `Esc` key.
+    ESCAPE(0x1B, "Esc"),
+
+    /// The `Space` key.
+    SPACE(0x20, "Space", KeyCodeClass.WHITESPACE),
+
+    /// The `Page Up` key.
+    PAGE_UP(0x21, "Page Up", KeyCodeClass.NAVIGATION),
+
+    /// The `Page Down` key.
+    PAGE_DOWN(0x22, "Page Down", KeyCodeClass.NAVIGATION),
+
+    /// The `End` key.
+    END(0x23, "End", KeyCodeClass.NAVIGATION),
+
+    /// The `Home` key.
+    HOME(0x24, "Home", KeyCodeClass.NAVIGATION),
+
+    /// The `Left` key.
+    LEFT(0x25, "Left", KeyCodeClass.ARROW | KeyCodeClass.NAVIGATION),
+
+    /// The `Up` key.
+    UP(0x26, "Up", KeyCodeClass.ARROW | KeyCodeClass.NAVIGATION),
+
+    /// The `Right` key.
+    RIGHT(0x27, "Right", KeyCodeClass.ARROW | KeyCodeClass.NAVIGATION),
+
+    /// The `Down` key.
+    DOWN(0x28, "Down", KeyCodeClass.ARROW | KeyCodeClass.NAVIGATION),
+
+    /// The `Comma` key.
+    COMMA(0x2C, "Comma"),
+
+    /// The `Minus` key.
+    MINUS(0x2D, "Minus"),
+
+    /// The `Period` key.
+    PERIOD(0x2E, "Period"),
+
+    /// The `Slash` key.
+    SLASH(0x2F, "Slash"),
+
+    /// The `0` key.
+    DIGIT0(0x30, "0", KeyCodeClass.DIGIT),
+
+    /// The `1` key.
+    DIGIT1(0x31, "1", KeyCodeClass.DIGIT),
+
+    /// The `2` key.
+    DIGIT2(0x32, "2", KeyCodeClass.DIGIT),
+
+    /// The `3` key.
+    DIGIT3(0x33, "3", KeyCodeClass.DIGIT),
+
+    /// The `4` key.
+    DIGIT4(0x34, "4", KeyCodeClass.DIGIT),
+
+    /// The `5` key.
+    DIGIT5(0x35, "5", KeyCodeClass.DIGIT),
+
+    /// The `6` key.
+    DIGIT6(0x36, "6", KeyCodeClass.DIGIT),
+
+    /// The `7` key.
+    DIGIT7(0x37, "7", KeyCodeClass.DIGIT),
+
+    /// The `8` key.
+    DIGIT8(0x38, "8", KeyCodeClass.DIGIT),
+
+    /// The `9` key.
+    DIGIT9(0x39, "9", KeyCodeClass.DIGIT),
+
+    /// The `Semicolon` key.
+    SEMICOLON(0x3B, "Semicolon"),
+
+    /// The `Equals` key.
+    EQUALS(0x3D, "Equals"),
+
+    /// The `A` key.
+    A(0x41, "A", KeyCodeClass.LETTER),
+
+    /// The `B` key.
+    B(0x42, "B", KeyCodeClass.LETTER),
+
+    /// The `C` key.
+    C(0x43, "C", KeyCodeClass.LETTER),
+
+    /// The `D` key.
+    D(0x44, "D", KeyCodeClass.LETTER),
+
+    /// The `E` key.
+    E(0x45, "E", KeyCodeClass.LETTER),
+
+    /// The `F` key.
+    F(0x46, "F", KeyCodeClass.LETTER),
+
+    /// The `G` key.
+    G(0x47, "G", KeyCodeClass.LETTER),
+
+    /// The `H` key.
+    H(0x48, "H", KeyCodeClass.LETTER),
+
+    /// The `I` key.
+    I(0x49, "I", KeyCodeClass.LETTER),
+
+    /// The `J` key.
+    J(0x4A, "J", KeyCodeClass.LETTER),
+
+    /// The `K` key.
+    K(0x4B, "K", KeyCodeClass.LETTER),
+
+    /// The `L` key.
+    L(0x4C, "L", KeyCodeClass.LETTER),
+
+    /// The `M` key.
+    M(0x4D, "M", KeyCodeClass.LETTER),
+
+    /// The `N` key.
+    N(0x4E, "N", KeyCodeClass.LETTER),
+
+    /// The `O` key.
+    O(0x4F, "O", KeyCodeClass.LETTER),
+
+    /// The `P` key.
+    P(0x50, "P", KeyCodeClass.LETTER),
+
+    /// The `Q` key.
+    Q(0x51, "Q", KeyCodeClass.LETTER),
+
+    /// The `R` key.
+    R(0x52, "R", KeyCodeClass.LETTER),
+
+    /// The `S` key.
+    S(0x53, "S", KeyCodeClass.LETTER),
+
+    /// The `T` key.
+    T(0x54, "T", KeyCodeClass.LETTER),
+
+    /// The `U` key.
+    U(0x55, "U", KeyCodeClass.LETTER),
+
+    /// The `V` key.
+    V(0x56, "V", KeyCodeClass.LETTER),
+
+    /// The `W` key.
+    W(0x57, "W", KeyCodeClass.LETTER),
+
+    /// The `X` key.
+    X(0x58, "X", KeyCodeClass.LETTER),
+
+    /// The `Y` key.
+    Y(0x59, "Y", KeyCodeClass.LETTER),
+
+    /// The `Z` key.
+    Z(0x5A, "Z", KeyCodeClass.LETTER),
+
+    /// The `Open Bracket` key.
+    OPEN_BRACKET(0x5B, "Open Bracket"),
+
+    /// The `Back Slash` key.
+    BACK_SLASH(0x5C, "Back Slash"),
+
+    /// The `Close Bracket` key.
+    CLOSE_BRACKET(0x5D, "Close Bracket"),
+
+    /// The `Numpad 0` key.
+    NUMPAD0(0x60, "Numpad 0", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 1` key.
+    NUMPAD1(0x61, "Numpad 1", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 2` key.
+    NUMPAD2(0x62, "Numpad 2", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 3` key.
+    NUMPAD3(0x63, "Numpad 3", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 4` key.
+    NUMPAD4(0x64, "Numpad 4", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 5` key.
+    NUMPAD5(0x65, "Numpad 5", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 6` key.
+    NUMPAD6(0x66, "Numpad 6", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 7` key.
+    NUMPAD7(0x67, "Numpad 7", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 8` key.
+    NUMPAD8(0x68, "Numpad 8", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Numpad 9` key.
+    NUMPAD9(0x69, "Numpad 9", KeyCodeClass.DIGIT | KeyCodeClass.KEYPAD),
+
+    /// The `Multiply` key.
+    MULTIPLY(0x6A, "Multiply"),
+
+    /// The `Add` key.
+    ADD(0x6B, "Add"),
+
+    /// The `Separator` key.
+    SEPARATOR(0x6C, "Separator"),
+
+    /// The `Subtract` key.
+    SUBTRACT(0x6D, "Subtract"),
+
+    /// The `Decimal` key.
+    DECIMAL(0x6E, "Decimal"),
+
+    /// The `Divide` key.
+    DIVIDE(0x6F, "Divide"),
+
+    /// The `Delete` key.
+    DELETE(0x7F, "Delete"),
+
+    /// The `Num Lock` key.
+    NUM_LOCK(0x90, "Num Lock"),
+
+    /// The `Scroll Lock` key.
+    SCROLL_LOCK(0x91, "Scroll Lock"),
+
+    /// The `F1` key.
+    F1(0x70, "F1", KeyCodeClass.FUNCTION),
+
+    /// The `F2` key.
+    F2(0x71, "F2", KeyCodeClass.FUNCTION),
+
+    /// The `F3` key.
+    F3(0x72, "F3", KeyCodeClass.FUNCTION),
+
+    /// The `F4` key.
+    F4(0x73, "F4", KeyCodeClass.FUNCTION),
+
+    /// The `F5` key.
+    F5(0x74, "F5", KeyCodeClass.FUNCTION),
+
+    /// The `F6` key.
+    F6(0x75, "F6", KeyCodeClass.FUNCTION),
+
+    /// The `F7` key.
+    F7(0x76, "F7", KeyCodeClass.FUNCTION),
+
+    /// The `F8` key.
+    F8(0x77, "F8", KeyCodeClass.FUNCTION),
+
+    /// The `F9` key.
+    F9(0x78, "F9", KeyCodeClass.FUNCTION),
+
+    /// The `F10` key.
+    F10(0x79, "F10", KeyCodeClass.FUNCTION),
+
+    /// The `F11` key.
+    F11(0x7A, "F11", KeyCodeClass.FUNCTION),
+
+    /// The `F12` key.
+    F12(0x7B, "F12", KeyCodeClass.FUNCTION),
+
+    /// The `F13` key.
+    F13(0xF000, "F13", KeyCodeClass.FUNCTION),
+
+    /// The `F14` key.
+    F14(0xF001, "F14", KeyCodeClass.FUNCTION),
+
+    /// The `F15` key.
+    F15(0xF002, "F15", KeyCodeClass.FUNCTION),
+
+    /// The `F16` key.
+    F16(0xF003, "F16", KeyCodeClass.FUNCTION),
+
+    /// The `F17` key.
+    F17(0xF004, "F17", KeyCodeClass.FUNCTION),
+
+    /// The `F18` key.
+    F18(0xF005, "F18", KeyCodeClass.FUNCTION),
+
+    /// The `F19` key.
+    F19(0xF006, "F19", KeyCodeClass.FUNCTION),
+
+    /// The `F20` key.
+    F20(0xF007, "F20", KeyCodeClass.FUNCTION),
+
+    /// The `F21` key.
+    F21(0xF008, "F21", KeyCodeClass.FUNCTION),
+
+    /// The `F22` key.
+    F22(0xF009, "F22", KeyCodeClass.FUNCTION),
+
+    /// The `F23` key.
+    F23(0xF00A, "F23", KeyCodeClass.FUNCTION),
+
+    /// The `F24` key.
+    F24(0xF00B, "F24", KeyCodeClass.FUNCTION),
+
+    /// The `Print Screen` key.
+    PRINTSCREEN(0x9A, "Print Screen"),
+
+    /// The `Insert` key.
+    INSERT(0x9B, "Insert"),
+
+    /// The `Help` key.
+    HELP(0x9C, "Help"),
+
+    /// The `Meta` key.
+    META(0x9D, "Meta", KeyCodeClass.MODIFIER),
+
+    /// The `Back Quote` key.
+    BACK_QUOTE(0xC0, "Back Quote"),
+
+    /// The `Quote` key.
+    QUOTE(0xDE, "Quote"),
+
+    /// The `Numpad Up` key.
+    KP_UP(0xE0, "Numpad Up", KeyCodeClass.ARROW | KeyCodeClass.KEYPAD | KeyCodeClass.NAVIGATION),
+
+    /// The `Numpad Down` key.
+    KP_DOWN(0xE1, "Numpad Down", KeyCodeClass.ARROW | KeyCodeClass.KEYPAD | KeyCodeClass.NAVIGATION),
+
+    /// The `Numpad Left` key.
+    KP_LEFT(0xE2, "Numpad Left", KeyCodeClass.ARROW | KeyCodeClass.KEYPAD | KeyCodeClass.NAVIGATION),
+
+    /// The `Numpad Right` key.
+    KP_RIGHT(0xE3, "Numpad Right", KeyCodeClass.ARROW | KeyCodeClass.KEYPAD | KeyCodeClass.NAVIGATION),
+
+    /// The `Dead Grave` key.
+    DEAD_GRAVE(0x80, "Dead Grave"),
+
+    /// The `Dead Acute` key.
+    DEAD_ACUTE(0x81, "Dead Acute"),
+
+    /// The `Dead Circumflex` key.
+    DEAD_CIRCUMFLEX(0x82, "Dead Circumflex"),
+
+    /// The `Dead Tilde` key.
+    DEAD_TILDE(0x83, "Dead Tilde"),
+
+    /// The `Dead Macron` key.
+    DEAD_MACRON(0x84, "Dead Macron"),
+
+    /// The `Dead Breve` key.
+    DEAD_BREVE(0x85, "Dead Breve"),
+
+    /// The `Dead Abovedot` key.
+    DEAD_ABOVEDOT(0x86, "Dead Abovedot"),
+
+    /// The `Dead Diaeresis` key.
+    DEAD_DIAERESIS(0x87, "Dead Diaeresis"),
+
+    /// The `Dead Abovering` key.
+    DEAD_ABOVERING(0x88, "Dead Abovering"),
+
+    /// The `Dead Doubleacute` key.
+    DEAD_DOUBLEACUTE(0x89, "Dead Doubleacute"),
+
+    /// The `Dead Caron` key.
+    DEAD_CARON(0x8A, "Dead Caron"),
+
+    /// The `Dead Cedilla` key.
+    DEAD_CEDILLA(0x8B, "Dead Cedilla"),
+
+    /// The `Dead Ogonek` key.
+    DEAD_OGONEK(0x8C, "Dead Ogonek"),
+
+    /// The `Dead Iota` key.
+    DEAD_IOTA(0x8D, "Dead Iota"),
+
+    /// The `Dead Voiced Sound` key.
+    DEAD_VOICED_SOUND(0x8E, "Dead Voiced Sound"),
+
+    /// The `Dead Semivoiced Sound` key.
+    DEAD_SEMIVOICED_SOUND(0x8F, "Dead Semivoiced Sound"),
+
+    /// The `Ampersand` key.
+    AMPERSAND(0x96, "Ampersand"),
+
+    /// The `Asterisk` key.
+    ASTERISK(0x97, "Asterisk"),
+
+    /// The `Double Quote` key.
+    QUOTEDBL(0x98, "Double Quote"),
+
+    /// The `Less` key.
+    LESS(0x99, "Less"),
+
+    /// The `Greater` key.
+    GREATER(0xA0, "Greater"),
+
+    /// The `Left Brace` key.
+    BRACELEFT(0xA1, "Left Brace"),
+
+    /// The `Right Brace` key.
+    BRACERIGHT(0xA2, "Right Brace"),
+
+    /// The `At` key.
+    AT(0x0200, "At"),
+
+    /// The `Colon` key.
+    COLON(0x0201, "Colon"),
+
+    /// The `Circumflex` key.
+    CIRCUMFLEX(0x0202, "Circumflex"),
+
+    /// The `Dollar` key.
+    DOLLAR(0x0203, "Dollar"),
+
+    /// The `Euro Sign` key.
+    EURO_SIGN(0x0204, "Euro Sign"),
+
+    /// The `Exclamation Mark` key.
+    EXCLAMATION_MARK(0x0205, "Exclamation Mark"),
+
+    /// The `Inverted Exclamation Mark` key.
+    INVERTED_EXCLAMATION_MARK(0x0206, "Inverted Exclamation Mark"),
+
+    /// The `Left Parenthesis` key.
+    LEFT_PARENTHESIS(0x0207, "Left Parenthesis"),
+
+    /// The `Number Sign` key.
+    NUMBER_SIGN(0x0208, "Number Sign"),
+
+    /// The `Plus` key.
+    PLUS(0x0209, "Plus"),
+
+    /// The `Right Parenthesis` key.
+    RIGHT_PARENTHESIS(0x020A, "Right Parenthesis"),
+
+    /// The `Underscore` key.
+    UNDERSCORE(0x020B, "Underscore"),
+
+    /// The `Windows` key.
+    WINDOWS(0x020C, "Windows", KeyCodeClass.MODIFIER),
+
+    /// The `Context Menu` key.
+    CONTEXT_MENU(0x020D, "Context Menu"),
+
+    /// The `Final` key.
+    FINAL(0x0018, "Final"),
+
+    /// The `Convert` key.
+    CONVERT(0x001C, "Convert"),
+
+    /// The `Nonconvert` key.
+    NONCONVERT(0x001D, "Nonconvert"),
+
+    /// The `Accept` key.
+    ACCEPT(0x001E, "Accept"),
+
+    /// The `Mode Change` key.
+    MODECHANGE(0x001F, "Mode Change"),
+
+    /// The `Kana` key.
+    KANA(0x0015, "Kana"),
+
+    /// The `Kanji` key.
+    KANJI(0x0019, "Kanji"),
+
+    /// The `Alphanumeric` key.
+    ALPHANUMERIC(0x00F0, "Alphanumeric"),
+
+    /// The `Katakana` key.
+    KATAKANA(0x00F1, "Katakana"),
+
+    /// The `Hiragana` key.
+    HIRAGANA(0x00F2, "Hiragana"),
+
+    /// The `Full Width` key.
+    FULL_WIDTH(0x00F3, "Full Width"),
+
+    /// The `Half Width` key.
+    HALF_WIDTH(0x00F4, "Half Width"),
+
+    /// The `Roman Characters` key.
+    ROMAN_CHARACTERS(0x00F5, "Roman Characters"),
+
+    /// The `All Candidates` key.
+    ALL_CANDIDATES(0x0100, "All Candidates"),
+
+    /// The `Previous Candidate` key.
+    PREVIOUS_CANDIDATE(0x0101, "Previous Candidate"),
+
+    /// The `Code Input` key.
+    CODE_INPUT(0x0102, "Code Input"),
+
+    /// The `Japanese Katakana` key.
+    JAPANESE_KATAKANA(0x0103, "Japanese Katakana"),
+
+    /// The `Japanese Hiragana` key.
+    JAPANESE_HIRAGANA(0x0104, "Japanese Hiragana"),
+
+    /// The `Japanese Roman` key.
+    JAPANESE_ROMAN(0x0105, "Japanese Roman"),
+
+    /// The `Kana Lock` key.
+    KANA_LOCK(0x0106, "Kana Lock"),
+
+    /// The `Input Method On Off` key.
+    INPUT_METHOD_ON_OFF(0x0107, "Input Method On Off"),
+
+    /// The `Cut` key.
+    CUT(0xFFD1, "Cut"),
+
+    /// The `Copy` key.
+    COPY(0xFFCD, "Copy"),
+
+    /// The `Paste` key.
+    PASTE(0xFFCF, "Paste"),
+
+    /// The `Undo` key.
+    UNDO(0xFFCB, "Undo"),
+
+    /// The `Again` key.
+    AGAIN(0xFFC9, "Again"),
+
+    /// The `Find` key.
+    FIND(0xFFD0, "Find"),
+
+    /// The `Properties` key.
+    PROPS(0xFFCA, "Properties"),
+
+    /// The `Stop` key.
+    STOP(0xFFC8, "Stop"),
+
+    /// The `Compose` key.
+    COMPOSE(0xFF20, "Compose"),
+
+    /// The `Alt Graph` key.
+    ALT_GRAPH(0xFF7E, "Alt Graph", KeyCodeClass.MODIFIER),
+
+    /// The `Begin` key.
+    BEGIN(0xFF58, "Begin"),
+
+    /// The `Undefined` key.
+    UNDEFINED(0x0, "Undefined"),
+
+    /// The `Softkey 0` key.
+    SOFTKEY_0(0x1000, "Softkey 0"),
+
+    /// The `Softkey 1` key.
+    SOFTKEY_1(0x1001, "Softkey 1"),
+
+    /// The `Softkey 2` key.
+    SOFTKEY_2(0x1002, "Softkey 2"),
+
+    /// The `Softkey 3` key.
+    SOFTKEY_3(0x1003, "Softkey 3"),
+
+    /// The `Softkey 4` key.
+    SOFTKEY_4(0x1004, "Softkey 4"),
+
+    /// The `Softkey 5` key.
+    SOFTKEY_5(0x1005, "Softkey 5"),
+
+    /// The `Softkey 6` key.
+    SOFTKEY_6(0x1006, "Softkey 6"),
+
+    /// The `Softkey 7` key.
+    SOFTKEY_7(0x1007, "Softkey 7"),
+
+    /// The `Softkey 8` key.
+    SOFTKEY_8(0x1008, "Softkey 8"),
+
+    /// The `Softkey 9` key.
+    SOFTKEY_9(0x1009, "Softkey 9"),
+
+    /// The `Game A` key.
+    GAME_A(0x100A, "Game A"),
+
+    /// The `Game B` key.
+    GAME_B(0x100B, "Game B"),
+
+    /// The `Game C` key.
+    GAME_C(0x100C, "Game C"),
+
+    /// The `Game D` key.
+    GAME_D(0x100D, "Game D"),
+
+    /// The `Star` key.
+    STAR(0x100E, "Star"),
+
+    /// The `Pound` key.
+    POUND(0x100F, "Pound"),
+
+    /// The `Power` key.
+    POWER(0x199, "Power"),
+
+    /// The `Info` key.
+    INFO(0x1C9, "Info"),
+
+    /// The `Colored Key 0` key.
+    COLORED_KEY_0(0x193, "Colored Key 0"),
+
+    /// The `Colored Key 1` key.
+    COLORED_KEY_1(0x194, "Colored Key 1"),
+
+    /// The `Colored Key 2` key.
+    COLORED_KEY_2(0x195, "Colored Key 2"),
+
+    /// The `Colored Key 3` key.
+    COLORED_KEY_3(0x196, "Colored Key 3"),
+
+    /// The `Eject` key.
+    EJECT_TOGGLE(0x19E, "Eject", KeyCodeClass.MEDIA),
+
+    /// The `Play` key.
+    PLAY(0x19F, "Play", KeyCodeClass.MEDIA),
+
+    /// The `Record` key.
+    RECORD(0x1A0, "Record", KeyCodeClass.MEDIA),
+
+    /// The `Fast Forward` key.
+    FAST_FWD(0x1A1, "Fast Forward", KeyCodeClass.MEDIA),
+
+    /// The `Rewind` key.
+    REWIND(0x19C, "Rewind", KeyCodeClass.MEDIA),
+
+    /// The `Previous Track` key.
+    TRACK_PREV(0x1A8, "Previous Track", KeyCodeClass.MEDIA),
+
+    /// The `Next Track` key.
+    TRACK_NEXT(0x1A9, "Next Track", KeyCodeClass.MEDIA),
+
+    /// The `Channel Up` key.
+    CHANNEL_UP(0x1AB, "Channel Up", KeyCodeClass.MEDIA),
+
+    /// The `Channel Down` key.
+    CHANNEL_DOWN(0x1AC, "Channel Down", KeyCodeClass.MEDIA),
+
+    /// The `Volume Up` key.
+    VOLUME_UP(0x1bf, "Volume Up", KeyCodeClass.MEDIA),
+
+    /// The `Volume Down` key.
+    VOLUME_DOWN(0x1C0, "Volume Down", KeyCodeClass.MEDIA),
+
+    /// The `Mute` key.
+    MUTE(0x1C1, "Mute", KeyCodeClass.MEDIA),
+
+    /// The `Command` key.
+    COMMAND(0x300, "Command", KeyCodeClass.MODIFIER),
+
+    /// The `Shortcut` key.
+    SHORTCUT(-1, "Shortcut");
+
+    private static final class KeyCodeClass {
+        static final int FUNCTION = 1;
+        static final int NAVIGATION = 1 << 1;
+        static final int ARROW = 1 << 2;
+        static final int MODIFIER = 1 << 3;
+        static final int LETTER = 1 << 4;
+        static final int DIGIT = 1 << 5;
+        static final int KEYPAD = 1 << 6;
+        static final int WHITESPACE = 1 << 7;
+        static final int MEDIA = 1 << 8;
+
+        private KeyCodeClass() {
+        }
+    }
+
+
+    private final int code;
+    private final String ch;
+    private final String name;
+    private final int mask;
+
+    KeyCode(int code, String name, int mask) {
+        this.code = code;
+        this.name = name;
+        this.mask = mask;
+        this.ch = String.valueOf((char) code);
+    }
+
+    KeyCode(int code, String name) {
+        this(code, name, 0);
+    }
+
+    /// Returns whether this is a function key, `F1` and the like.
+    public final boolean isFunctionKey() {
+        return (mask & KeyCodeClass.FUNCTION) != 0;
+    }
+
+    /// Returns whether this is a navigation key: arrows, Home, End, Page
+    /// Up, Page Down.
+    public final boolean isNavigationKey() {
+        return (mask & KeyCodeClass.NAVIGATION) != 0;
+    }
+
+    /// Returns whether this is an arrow key.
+    public final boolean isArrowKey() {
+        return (mask & KeyCodeClass.ARROW) != 0;
+    }
+
+    /// Returns whether this is a modifier key.
+    public final boolean isModifierKey() {
+        return (mask & KeyCodeClass.MODIFIER) != 0;
+    }
+
+    /// Returns whether this is a letter.
+    public final boolean isLetterKey() {
+        return (mask & KeyCodeClass.LETTER) != 0;
+    }
+
+    /// Returns whether this is a digit, on the main block or the keypad.
+    public final boolean isDigitKey() {
+        return (mask & KeyCodeClass.DIGIT) != 0;
+    }
+
+    /// Returns whether this key is on the numeric keypad.
+    public final boolean isKeypadKey() {
+        return (mask & KeyCodeClass.KEYPAD) != 0;
+    }
+
+    /// Returns whether this key types white space.
+    public final boolean isWhitespaceKey() {
+        return (mask & KeyCodeClass.WHITESPACE) != 0;
+    }
+
+    /// Returns whether this is a media key.
+    public final boolean isMediaKey() {
+        return (mask & KeyCodeClass.MEDIA) != 0;
+    }
+
+    /// Returns the name the key is shown by, `Page Up`.
+    public final String getName() {
+        return name;
+    }
+
+    /// Returns the character of the key's code as a string.
+    public String getChar() {
+        return ch;
+    }
+
+    /// Returns the numeric code of the key.
+    public int getCode() {
+        return code;
+    }
+
+    /// Returns the key with a name as [#getName()] answers it, or `null`.
+    public static KeyCode getKeyCode(String name) {
+        return Names.BY_NAME.get(name);
+    }
+
+    /// The keys by name, built when first asked for: an enum cannot fill
+    /// a static map from its own constructor.
+    private static final class Names {
+        static final HashMap<String, KeyCode> BY_NAME = build();
+
+        private Names() {
+        }
+
+        private static HashMap<String, KeyCode> build() {
+            HashMap<String, KeyCode> map = new HashMap<String, KeyCode>();
+            KeyCode[] all = values();
+            for (int i = 0; i < all.length; i++) {
+                map.put(all[i].name, all[i]);
+            }
+            return map;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCodeCombination.java b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCodeCombination.java
new file mode 100644
index 00000000000..b91eb3e06b7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCodeCombination.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.beans.NamedArg;
+
+/// A key combination whose key is named by its [KeyCode]: the Q of
+/// `Shortcut+Q`.
+public final class KeyCodeCombination extends KeyCombination {
+
+    private final KeyCode code;
+
+    /// Creates a combination from a key and the state of each modifier.
+    public KeyCodeCombination(@NamedArg("code") KeyCode code, @NamedArg("shift") ModifierValue shift,
+            @NamedArg("control") ModifierValue control, @NamedArg("alt") ModifierValue alt,
+            @NamedArg("meta") ModifierValue meta, @NamedArg("shortcut") ModifierValue shortcut) {
+        super(shift, control, alt, meta, shortcut);
+        this.code = valid(code);
+    }
+
+    /// Creates a combination from a key and the modifiers that are not up.
+    public KeyCodeCombination(@NamedArg("code") KeyCode code, @NamedArg("modifiers") Modifier... modifiers) {
+        super(modifiers);
+        this.code = valid(code);
+    }
+
+    private static KeyCode valid(KeyCode code) {
+        if (code == null) {
+            throw new NullPointerException("Key code must not be null!");
+        }
+        if (code.isModifierKey() || code == KeyCode.UNDEFINED) {
+            throw new IllegalArgumentException("Key code must not match modifier key!");
+        }
+        return code;
+    }
+
+    /// Returns the key.
+    public KeyCode getCode() {
+        return code;
+    }
+
+    @Override
+    public boolean match(KeyEvent event) {
+        return event.getCode() == code && super.match(event);
+    }
+
+    @Override
+    public String getName() {
+        return super.getName() + code.getName();
+    }
+
+    @Override
+    public String getDisplayText() {
+        return super.getDisplayText() + code.getName();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof KeyCodeCombination)) {
+            return false;
+        }
+        return code == ((KeyCodeCombination) obj).code && super.equals(obj);
+    }
+
+    @Override
+    public int hashCode() {
+        return 23 * super.hashCode() + code.ordinal();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCombination.java b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCombination.java
new file mode 100644
index 00000000000..1883c12ece1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyCombination.java
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import com.codename1.fxcompat.runtime.SceneInput;
+
+/// A key together with the state every modifier must be in for a key
+/// event to count as it: what a menu item's accelerator is.
+///
+/// The only kind in this layer is [KeyCodeCombination], a key named by
+/// its [KeyCode]. `KeyCharacterCombination`, which names a key by the
+/// character it types on the current keyboard layout, is not part of
+/// this layer, so [#valueOf(String)] accepts key names only.
+///
+/// A device has no keyboard most of the time. An accelerator is matched
+/// against the key events a hardware keyboard sends and is otherwise
+/// inert; it is never the only way to reach a command.
+public abstract class KeyCombination {
+
+    /// Shift must be down.
+    public static final Modifier SHIFT_DOWN = new Modifier(KeyCode.SHIFT, ModifierValue.DOWN);
+    /// Shift may be down or up.
+    public static final Modifier SHIFT_ANY = new Modifier(KeyCode.SHIFT, ModifierValue.ANY);
+    /// Control must be down.
+    public static final Modifier CONTROL_DOWN = new Modifier(KeyCode.CONTROL, ModifierValue.DOWN);
+    /// Control may be down or up.
+    public static final Modifier CONTROL_ANY = new Modifier(KeyCode.CONTROL, ModifierValue.ANY);
+    /// Alt must be down.
+    public static final Modifier ALT_DOWN = new Modifier(KeyCode.ALT, ModifierValue.DOWN);
+    /// Alt may be down or up.
+    public static final Modifier ALT_ANY = new Modifier(KeyCode.ALT, ModifierValue.ANY);
+    /// Meta must be down.
+    public static final Modifier META_DOWN = new Modifier(KeyCode.META, ModifierValue.DOWN);
+    /// Meta may be down or up.
+    public static final Modifier META_ANY = new Modifier(KeyCode.META, ModifierValue.ANY);
+    /// The platform's shortcut modifier must be down: Meta on Apple
+    /// platforms, Control elsewhere.
+    public static final Modifier SHORTCUT_DOWN = new Modifier(KeyCode.SHORTCUT, ModifierValue.DOWN);
+    /// The platform's shortcut modifier may be down or up.
+    public static final Modifier SHORTCUT_ANY = new Modifier(KeyCode.SHORTCUT, ModifierValue.ANY);
+
+    /// A combination no key event matches.
+    public static final KeyCombination NO_MATCH = new KeyCombination() {
+        @Override
+        public boolean match(KeyEvent event) {
+            return false;
+        }
+    };
+
+    private static final Modifier[] POSSIBLE = {SHIFT_DOWN, SHIFT_ANY, CONTROL_DOWN, CONTROL_ANY, ALT_DOWN, ALT_ANY,
+        META_DOWN, META_ANY, SHORTCUT_DOWN, SHORTCUT_ANY};
+
+    private final ModifierValue shift;
+    private final ModifierValue control;
+    private final ModifierValue alt;
+    private final ModifierValue meta;
+    private final ModifierValue shortcut;
+
+    /// Creates a combination from the state of each modifier.
+    protected KeyCombination(ModifierValue shift, ModifierValue control, ModifierValue alt, ModifierValue meta,
+            ModifierValue shortcut) {
+        if (shift == null || control == null || alt == null || meta == null || shortcut == null) {
+            throw new NullPointerException("Modifier value must not be null!");
+        }
+        this.shift = shift;
+        this.control = control;
+        this.alt = alt;
+        this.meta = meta;
+        this.shortcut = shortcut;
+    }
+
+    /// Creates a combination from the modifiers that are not up; naming
+    /// one twice is an error.
+    protected KeyCombination(Modifier... modifiers) {
+        this(value(KeyCode.SHIFT, modifiers), value(KeyCode.CONTROL, modifiers), value(KeyCode.ALT, modifiers),
+                value(KeyCode.META, modifiers), value(KeyCode.SHORTCUT, modifiers));
+    }
+
+    private static ModifierValue value(KeyCode key, Modifier[] modifiers) {
+        ModifierValue found = null;
+        if (modifiers != null) {
+            for (int i = 0; i < modifiers.length; i++) {
+                Modifier m = modifiers[i];
+                if (m == null) {
+                    throw new NullPointerException("Modifier must not be null!");
+                }
+                if (m.getKey() == key) {
+                    if (found != null) {
+                        throw new IllegalArgumentException("Duplicate modifiers [" + m.getKey().getName() + "]");
+                    }
+                    found = m.getValue();
+                }
+            }
+        }
+        return found == null ? ModifierValue.UP : found;
+    }
+
+    /// Returns the state Shift must be in.
+    public final ModifierValue getShift() {
+        return shift;
+    }
+
+    /// Returns the state Control must be in.
+    public final ModifierValue getControl() {
+        return control;
+    }
+
+    /// Returns the state Alt must be in.
+    public final ModifierValue getAlt() {
+        return alt;
+    }
+
+    /// Returns the state Meta must be in.
+    public final ModifierValue getMeta() {
+        return meta;
+    }
+
+    /// Returns the state the platform's shortcut modifier must be in.
+    public final ModifierValue getShortcut() {
+        return shortcut;
+    }
+
+    private static boolean agrees(ModifierValue wanted, boolean down) {
+        return wanted == ModifierValue.ANY || (wanted == ModifierValue.DOWN) == down;
+    }
+
+    /// Returns whether the modifiers of a key event are what this
+    /// combination asks for. The shortcut modifier stands for Meta or
+    /// Control, whichever the platform uses, and the state asked of that
+    /// key is then the stronger of the two.
+    public boolean match(KeyEvent event) {
+        boolean shortcutIsMeta = SceneInput.shortcutIsMeta();
+        ModifierValue wantControl = control;
+        ModifierValue wantMeta = meta;
+        if (shortcut != ModifierValue.UP) {
+            if (shortcutIsMeta) {
+                wantMeta = stronger(meta, shortcut);
+            } else {
+                wantControl = stronger(control, shortcut);
+            }
+        }
+        return agrees(shift, event.isShiftDown()) && agrees(wantControl, event.isControlDown())
+                && agrees(alt, event.isAltDown()) && agrees(wantMeta, event.isMetaDown());
+    }
+
+    private static ModifierValue stronger(ModifierValue a, ModifierValue b) {
+        if (a == ModifierValue.DOWN || b == ModifierValue.DOWN) {
+            return ModifierValue.DOWN;
+        }
+        return a == ModifierValue.ANY || b == ModifierValue.ANY ? ModifierValue.ANY : ModifierValue.UP;
+    }
+
+    /// Returns the modifiers as [#valueOf(String)] reads them, each
+    /// followed by a plus sign: `Shift+Ctrl+`.
+    public String getName() {
+        StringBuilder sb = new StringBuilder();
+        append(sb, shift, "Shift");
+        append(sb, control, "Ctrl");
+        append(sb, alt, "Alt");
+        append(sb, meta, "Meta");
+        append(sb, shortcut, "Shortcut");
+        return sb.toString();
+    }
+
+    private static void append(StringBuilder sb, ModifierValue value, String name) {
+        if (value == ModifierValue.DOWN) {
+            sb.append(name).append('+');
+        } else if (value == ModifierValue.ANY) {
+            sb.append("Ignore ").append(name).append('+');
+        }
+    }
+
+    /// Returns the modifiers as a menu shows them, the shortcut modifier
+    /// by the name of the key it stands for.
+    public String getDisplayText() {
+        StringBuilder sb = new StringBuilder();
+        if (shift == ModifierValue.DOWN) {
+            sb.append("Shift+");
+        }
+        boolean shortcutIsMeta = SceneInput.shortcutIsMeta();
+        if (control == ModifierValue.DOWN || (shortcut == ModifierValue.DOWN && !shortcutIsMeta)) {
+            sb.append("Ctrl+");
+        }
+        if (alt == ModifierValue.DOWN) {
+            sb.append("Alt+");
+        }
+        if (meta == ModifierValue.DOWN || (shortcut == ModifierValue.DOWN && shortcutIsMeta)) {
+            sb.append("Meta+");
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof KeyCombination)) {
+            return false;
+        }
+        KeyCombination other = (KeyCombination) obj;
+        return shift == other.shift && control == other.control && alt == other.alt && meta == other.meta
+                && shortcut == other.shortcut;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 23 * hash + shift.ordinal();
+        hash = 23 * hash + control.ordinal();
+        hash = 23 * hash + alt.ordinal();
+        hash = 23 * hash + meta.ordinal();
+        hash = 23 * hash + shortcut.ordinal();
+        return hash;
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+
+    /// Reads a combination written as modifier names and one key name
+    /// joined by plus signs, `Shortcut+Shift+S`; an FXML `accelerator`
+    /// attribute is read this way. The modifier names are `Shift`, `Ctrl`,
+    /// `Alt`, `Meta` and `Shortcut`, each optionally after `Ignore `, and
+    /// the key is named as `KeyCode.getName()` or the enum constant spell
+    /// it.
+    public static KeyCombination valueOf(String value) {
+        return keyCombination(value);
+    }
+
+    /// Reads a combination; see [#valueOf(String)].
+    public static KeyCombination keyCombination(String name) {
+        if (name == null) {
+            throw new NullPointerException("Key combination name must not be null!");
+        }
+        ModifierValue[] values = {ModifierValue.UP, ModifierValue.UP, ModifierValue.UP, ModifierValue.UP,
+            ModifierValue.UP};
+        boolean[] seen = new boolean[5];
+        KeyCode key = null;
+        int from = 0;
+        int n = name.length();
+        while (from <= n) {
+            int plus = name.indexOf('+', from);
+            // A trailing plus sign is the key itself.
+            if (plus < 0 || plus == n - 1) {
+                plus = n;
+            }
+            String token = name.substring(from, plus).trim();
+            from = plus + 1;
+            if (token.length() == 0) {
+                throw new IllegalArgumentException("Key combination name not valid: " + name);
+            }
+            Modifier modifier = modifier(token);
+            if (modifier != null) {
+                int slot = slot(modifier.getKey());
+                if (seen[slot]) {
+                    throw new IllegalArgumentException("Duplicate modifiers [" + modifier.getKey().getName() + "]");
+                }
+                seen[slot] = true;
+                values[slot] = modifier.getValue();
+                continue;
+            }
+            if (key != null || from <= n) {
+                throw new IllegalArgumentException("Key combination name not valid: " + name);
+            }
+            key = key(token);
+            if (key == null) {
+                throw new IllegalArgumentException("Unknown key in a key combination: " + token
+                        + " (keys are named as KeyCode names them; a key named by the character it types is "
+                        + "not supported)");
+            }
+        }
+        if (key == null) {
+            throw new IllegalArgumentException("Key combination name not valid: " + name);
+        }
+        return new KeyCodeCombination(key, values[0], values[1], values[2], values[3], values[4]);
+    }
+
+    private static int slot(KeyCode key) {
+        if (key == KeyCode.SHIFT) {
+            return 0;
+        }
+        if (key == KeyCode.CONTROL) {
+            return 1;
+        }
+        if (key == KeyCode.ALT) {
+            return 2;
+        }
+        return key == KeyCode.META ? 3 : 4;
+    }
+
+    private static Modifier modifier(String token) {
+        for (int i = 0; i < POSSIBLE.length; i++) {
+            if (POSSIBLE[i].toString().equals(token)) {
+                return POSSIBLE[i];
+            }
+        }
+        return null;
+    }
+
+    private static KeyCode key(String token) {
+        KeyCode byName = KeyCode.getKeyCode(token);
+        if (byName != null) {
+            return byName;
+        }
+        KeyCode[] all = KeyCode.values();
+        for (int i = 0; i < all.length; i++) {
+            if (all[i].name().equals(token) || all[i].getName().equalsIgnoreCase(token)) {
+                return all[i];
+            }
+        }
+        return null;
+    }
+
+    /// One modifier key and the state a combination asks of it.
+    public static final class Modifier {
+
+        private final KeyCode key;
+        private final ModifierValue value;
+
+        private Modifier(KeyCode key, ModifierValue value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        /// Returns the modifier key.
+        public KeyCode getKey() {
+            return key;
+        }
+
+        /// Returns the state asked of the key.
+        public ModifierValue getValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return (value == ModifierValue.ANY ? "Ignore " : "") + key.getName();
+        }
+    }
+
+    /// The state a combination asks of a modifier key.
+    public enum ModifierValue {
+        /// The key must be down.
+        DOWN,
+        /// The key must be up.
+        UP,
+        /// The key may be either.
+        ANY
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/KeyEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyEvent.java
new file mode 100644
index 00000000000..29ab144abd3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/KeyEvent.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import com.codename1.fxcompat.runtime.SceneInput;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// A key going down, coming up or typing a character. Key events go to the
+/// node that has the focus, or to the scene when no node has it.
+///
+/// A control backed by a native text editor consumes the keys it edits
+/// with; while it is being edited the scene does not see them.
+public final class KeyEvent extends InputEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Every key event.
+    public static final EventType<KeyEvent> ANY = new EventType<KeyEvent>(InputEvent.ANY, "KEY");
+
+    /// A key went down.
+    public static final EventType<KeyEvent> KEY_PRESSED = new EventType<KeyEvent>(ANY, "KEY_PRESSED");
+
+    /// A key came up.
+    public static final EventType<KeyEvent> KEY_RELEASED = new EventType<KeyEvent>(ANY, "KEY_RELEASED");
+
+    /// A character was typed.
+    public static final EventType<KeyEvent> KEY_TYPED = new EventType<KeyEvent>(ANY, "KEY_TYPED");
+
+    /// The character of an event that typed none.
+    public static final String CHAR_UNDEFINED = KeyCode.UNDEFINED.getChar();
+
+    private final String character;
+    private final String text;
+    private final KeyCode code;
+    private final boolean shiftDown;
+    private final boolean controlDown;
+    private final boolean altDown;
+    private final boolean metaDown;
+
+    /// Creates a key event.
+    public KeyEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<KeyEvent> eventType, @NamedArg("character") String character,
+            @NamedArg("text") String text, @NamedArg("code") KeyCode code, @NamedArg("shiftDown") boolean shiftDown,
+            @NamedArg("controlDown") boolean controlDown, @NamedArg("altDown") boolean altDown,
+            @NamedArg("metaDown") boolean metaDown) {
+        super(source, target, eventType);
+        boolean typed = eventType == KEY_TYPED;
+        this.character = typed ? character : CHAR_UNDEFINED;
+        this.text = typed ? "" : text;
+        this.code = typed ? KeyCode.UNDEFINED : code;
+        this.shiftDown = shiftDown;
+        this.controlDown = controlDown;
+        this.altDown = altDown;
+        this.metaDown = metaDown;
+    }
+
+    /// Creates a key event with no source and no target.
+    public KeyEvent(@NamedArg("eventType") EventType<KeyEvent> eventType, @NamedArg("character") String character,
+            @NamedArg("text") String text, @NamedArg("code") KeyCode code, @NamedArg("shiftDown") boolean shiftDown,
+            @NamedArg("controlDown") boolean controlDown, @NamedArg("altDown") boolean altDown,
+            @NamedArg("metaDown") boolean metaDown) {
+        this(null, null, eventType, character, text, code, shiftDown, controlDown, altDown, metaDown);
+    }
+
+    /// Returns the character typed; [#CHAR_UNDEFINED] unless this is a
+    /// typed event.
+    public final String getCharacter() {
+        return character;
+    }
+
+    /// Returns a description of the key; empty for a typed event.
+    public final String getText() {
+        return text;
+    }
+
+    /// Returns the key; `UNDEFINED` for a typed event.
+    public final KeyCode getCode() {
+        return code;
+    }
+
+    /// Returns whether Shift is down.
+    public final boolean isShiftDown() {
+        return shiftDown;
+    }
+
+    /// Returns whether Control is down.
+    public final boolean isControlDown() {
+        return controlDown;
+    }
+
+    /// Returns whether Alt is down.
+    public final boolean isAltDown() {
+        return altDown;
+    }
+
+    /// Returns whether Meta is down.
+    public final boolean isMetaDown() {
+        return metaDown;
+    }
+
+    /// Returns whether the platform's shortcut modifier is down: Meta on
+    /// Apple platforms, Control elsewhere.
+    public final boolean isShortcutDown() {
+        return SceneInput.shortcutIsMeta() ? metaDown : controlDown;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public KeyEvent copyFor(Object newSource, EventTarget newTarget) {
+        KeyEvent copy = new KeyEvent(newSource, newTarget, (EventType<KeyEvent>) getEventType(), character, text,
+                code, shiftDown, controlDown, altDown, metaDown);
+        return copy;
+    }
+
+    /// Returns a copy with another source, target and type.
+    public KeyEvent copyFor(Object source, EventTarget target, EventType<KeyEvent> type) {
+        return new KeyEvent(source, target, type, character, text, code, shiftDown, controlDown, altDown, metaDown);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<KeyEvent> getEventType() {
+        return (EventType<KeyEvent>) super.getEventType();
+    }
+
+    @Override
+    public String toString() {
+        return "KeyEvent [source = " + getSource() + ", target = " + getTarget() + ", eventType = "
+                + getEventType() + ", consumed = " + isConsumed() + ", character = " + character + ", text = "
+                + text + ", code = " + code + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/MouseButton.java b/maven/javafx-compat/src/main/java/javafx/scene/input/MouseButton.java
new file mode 100644
index 00000000000..24a8ded0bfd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/MouseButton.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+/// The buttons of a mouse. A touch counts as the primary button.
+public enum MouseButton {
+    /// No button.
+    NONE,
+    /// The primary button, usually the left one.
+    PRIMARY,
+    /// The middle button.
+    MIDDLE,
+    /// The secondary button, usually the right one.
+    SECONDARY,
+    /// The back button.
+    BACK,
+    /// The forward button.
+    FORWARD
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/MouseEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/MouseEvent.java
new file mode 100644
index 00000000000..be4ee65ba68
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/MouseEvent.java
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import com.codename1.fxcompat.runtime.SceneInput;
+
+import javafx.beans.NamedArg;
+import javafx.event.Event;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+
+/// A mouse or touch event: a press, a release, a click, a move, a drag,
+/// or the pointer entering or leaving a node.
+///
+/// `getX()` and `getY()` are in the coordinates of the event's source and
+/// are recomputed each time the event is delivered to another node. On a
+/// device without a mouse a touch is the primary button; there are no
+/// move events and no hover.
+public class MouseEvent extends InputEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Every mouse event.
+    public static final EventType<MouseEvent> ANY = new EventType<MouseEvent>(InputEvent.ANY, "MOUSE");
+
+    /// A button went down.
+    public static final EventType<MouseEvent> MOUSE_PRESSED = new EventType<MouseEvent>(ANY, "MOUSE_PRESSED");
+
+    /// A button went up.
+    public static final EventType<MouseEvent> MOUSE_RELEASED = new EventType<MouseEvent>(ANY, "MOUSE_RELEASED");
+
+    /// A button went down and up over the same node.
+    public static final EventType<MouseEvent> MOUSE_CLICKED = new EventType<MouseEvent>(ANY, "MOUSE_CLICKED");
+
+    /// The pointer entered a node or one of its descendants; delivered
+    /// along the whole dispatch chain.
+    public static final EventType<MouseEvent> MOUSE_ENTERED_TARGET = new EventType<MouseEvent>(ANY,
+            "MOUSE_ENTERED_TARGET");
+
+    /// The pointer entered a node; delivered to that node only.
+    public static final EventType<MouseEvent> MOUSE_ENTERED = new EventType<MouseEvent>(MOUSE_ENTERED_TARGET,
+            "MOUSE_ENTERED");
+
+    /// The pointer left a node or one of its descendants; delivered along
+    /// the whole dispatch chain.
+    public static final EventType<MouseEvent> MOUSE_EXITED_TARGET = new EventType<MouseEvent>(ANY,
+            "MOUSE_EXITED_TARGET");
+
+    /// The pointer left a node; delivered to that node only.
+    public static final EventType<MouseEvent> MOUSE_EXITED = new EventType<MouseEvent>(MOUSE_EXITED_TARGET,
+            "MOUSE_EXITED");
+
+    /// The pointer moved with no button down.
+    public static final EventType<MouseEvent> MOUSE_MOVED = new EventType<MouseEvent>(ANY, "MOUSE_MOVED");
+
+    /// The pointer moved with a button down.
+    public static final EventType<MouseEvent> MOUSE_DRAGGED = new EventType<MouseEvent>(ANY, "MOUSE_DRAGGED");
+
+    /// A drag gesture was recognised.
+    public static final EventType<MouseEvent> DRAG_DETECTED = new EventType<MouseEvent>(ANY, "DRAG_DETECTED");
+
+    private transient double x;
+    private transient double y;
+    private final double screenX;
+    private final double screenY;
+    private final double sceneX;
+    private final double sceneY;
+    private final MouseButton button;
+    private final int clickCount;
+    private final boolean stillSincePress;
+    private final boolean shiftDown;
+    private final boolean controlDown;
+    private final boolean altDown;
+    private final boolean metaDown;
+    private final boolean synthesized;
+    private final boolean popupTrigger;
+    private final boolean primaryButtonDown;
+    private final boolean secondaryButtonDown;
+    private final boolean middleButtonDown;
+    private final transient PickResult pickResult;
+    private boolean dragDetect = true;
+
+    /// Creates a mouse event with no source and no target; `x` and `y`
+    /// are scene coordinates.
+    public MouseEvent(@NamedArg("eventType") EventType<? extends MouseEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("button") MouseButton button, @NamedArg("clickCount") int clickCount,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown,
+            @NamedArg("primaryButtonDown") boolean primaryButtonDown,
+            @NamedArg("middleButtonDown") boolean middleButtonDown,
+            @NamedArg("secondaryButtonDown") boolean secondaryButtonDown,
+            @NamedArg("synthesized") boolean synthesized, @NamedArg("popupTrigger") boolean popupTrigger,
+            @NamedArg("stillSincePress") boolean stillSincePress, @NamedArg("pickResult") PickResult pickResult) {
+        this(null, null, eventType, x, y, screenX, screenY, button, clickCount, shiftDown, controlDown, altDown,
+                metaDown, primaryButtonDown, middleButtonDown, secondaryButtonDown, synthesized, popupTrigger,
+                stillSincePress, pickResult);
+    }
+
+    /// Creates a mouse event; `x` and `y` are scene coordinates.
+    public MouseEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<? extends MouseEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("button") MouseButton button, @NamedArg("clickCount") int clickCount,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown,
+            @NamedArg("primaryButtonDown") boolean primaryButtonDown,
+            @NamedArg("middleButtonDown") boolean middleButtonDown,
+            @NamedArg("secondaryButtonDown") boolean secondaryButtonDown,
+            @NamedArg("synthesized") boolean synthesized, @NamedArg("popupTrigger") boolean popupTrigger,
+            @NamedArg("stillSincePress") boolean stillSincePress, @NamedArg("pickResult") PickResult pickResult) {
+        super(source, target, eventType);
+        this.sceneX = x;
+        this.sceneY = y;
+        this.screenX = screenX;
+        this.screenY = screenY;
+        this.button = button == null ? MouseButton.NONE : button;
+        this.clickCount = clickCount;
+        this.shiftDown = shiftDown;
+        this.controlDown = controlDown;
+        this.altDown = altDown;
+        this.metaDown = metaDown;
+        this.primaryButtonDown = primaryButtonDown;
+        this.middleButtonDown = middleButtonDown;
+        this.secondaryButtonDown = secondaryButtonDown;
+        this.synthesized = synthesized;
+        this.popupTrigger = popupTrigger;
+        this.stillSincePress = stillSincePress;
+        this.pickResult = pickResult != null ? pickResult : new PickResult(target, x, y);
+        localize(source);
+    }
+
+    private void localize(Object source) {
+        if (source instanceof Node) {
+            Point2D local = ((Node) source).sceneToLocal(sceneX, sceneY);
+            x = local.getX();
+            y = local.getY();
+        } else {
+            x = sceneX;
+            y = sceneY;
+        }
+    }
+
+    @Override
+    public MouseEvent copyFor(Object newSource, EventTarget newTarget) {
+        if (getClass() != MouseEvent.class) {
+            super.copyFor(newSource, newTarget);
+            localize(getSource());
+            return this;
+        }
+        return copyFor(newSource, newTarget, getEventType());
+    }
+
+    /// Returns a copy with another source, target and type.
+    public MouseEvent copyFor(Object newSource, EventTarget newTarget, EventType<? extends MouseEvent> eventType) {
+        MouseEvent copy = new MouseEvent(newSource, newTarget, eventType, sceneX, sceneY, screenX, screenY, button,
+                clickCount, shiftDown, controlDown, altDown, metaDown, primaryButtonDown, middleButtonDown,
+                secondaryButtonDown, synthesized, popupTrigger, stillSincePress, pickResult);
+        copy.dragDetect = dragDetect;
+        return copy;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<? extends MouseEvent> getEventType() {
+        return (EventType<? extends MouseEvent>) super.getEventType();
+    }
+
+    /// Returns the x of the pointer in the source's coordinates.
+    public final double getX() {
+        return x;
+    }
+
+    /// Returns the y of the pointer in the source's coordinates.
+    public final double getY() {
+        return y;
+    }
+
+    /// Always 0: this layer is two dimensional.
+    public final double getZ() {
+        return 0;
+    }
+
+    /// Returns the x of the pointer on the screen.
+    public final double getScreenX() {
+        return screenX;
+    }
+
+    /// Returns the y of the pointer on the screen.
+    public final double getScreenY() {
+        return screenY;
+    }
+
+    /// Returns the x of the pointer in the scene.
+    public final double getSceneX() {
+        return sceneX;
+    }
+
+    /// Returns the y of the pointer in the scene.
+    public final double getSceneY() {
+        return sceneY;
+    }
+
+    /// Returns the button whose change caused the event.
+    public final MouseButton getButton() {
+        return button;
+    }
+
+    /// Returns how many clicks in a row this is.
+    public final int getClickCount() {
+        return clickCount;
+    }
+
+    /// Returns whether the pointer stayed in place since the press.
+    public final boolean isStillSincePress() {
+        return stillSincePress;
+    }
+
+    /// Returns whether Shift is down.
+    public final boolean isShiftDown() {
+        return shiftDown;
+    }
+
+    /// Returns whether Control is down.
+    public final boolean isControlDown() {
+        return controlDown;
+    }
+
+    /// Returns whether Alt is down.
+    public final boolean isAltDown() {
+        return altDown;
+    }
+
+    /// Returns whether Meta is down.
+    public final boolean isMetaDown() {
+        return metaDown;
+    }
+
+    /// Returns whether the event comes from a touch rather than a mouse.
+    public boolean isSynthesized() {
+        return synthesized;
+    }
+
+    /// Returns whether the platform's shortcut modifier is down: Meta on
+    /// Apple platforms, Control elsewhere.
+    public final boolean isShortcutDown() {
+        return SceneInput.shortcutIsMeta() ? metaDown : controlDown;
+    }
+
+    /// Returns whether this event should open a context menu.
+    public final boolean isPopupTrigger() {
+        return popupTrigger;
+    }
+
+    /// Returns whether the primary button is down.
+    public final boolean isPrimaryButtonDown() {
+        return primaryButtonDown;
+    }
+
+    /// Returns whether the secondary button is down.
+    public final boolean isSecondaryButtonDown() {
+        return secondaryButtonDown;
+    }
+
+    /// Returns whether the middle button is down.
+    public final boolean isMiddleButtonDown() {
+        return middleButtonDown;
+    }
+
+    /// Returns whether a drag is to be detected after this event.
+    public boolean isDragDetect() {
+        return dragDetect;
+    }
+
+    /// Sets whether a drag is to be detected after this event.
+    public void setDragDetect(boolean dragDetect) {
+        this.dragDetect = dragDetect;
+    }
+
+    /// Returns what was under the pointer.
+    public final PickResult getPickResult() {
+        return pickResult;
+    }
+
+    /// Returns a copy of a mouse event with another type.
+    public static MouseEvent copyForMouseDragEvent(MouseEvent e, Object source, EventTarget target,
+            EventType<MouseEvent> type, Object gestureSource, PickResult pickResult) {
+        return e.copyFor(source, target, type);
+    }
+
+    @Override
+    public String toString() {
+        return "MouseEvent [source = " + getSource() + ", target = " + getTarget() + ", eventType = "
+                + getEventType() + ", consumed = " + isConsumed() + ", x = " + x + ", y = " + y + ", button = "
+                + button + ", clickCount = " + clickCount + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/PickResult.java b/maven/javafx-compat/src/main/java/javafx/scene/input/PickResult.java
new file mode 100644
index 00000000000..df31e30761d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/PickResult.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.scene.Node;
+
+/// What lay under the pointer when an event happened. This layer is two
+/// dimensional: the result names the node and nothing about depth.
+public class PickResult {
+
+    private final Node node;
+    private final double sceneX;
+    private final double sceneY;
+
+    /// Creates the result of a pick at a scene position.
+    public PickResult(@NamedArg("target") EventTarget target, @NamedArg("sceneX") double sceneX,
+            @NamedArg("sceneY") double sceneY) {
+        this.node = target instanceof Node ? (Node) target : null;
+        this.sceneX = sceneX;
+        this.sceneY = sceneY;
+    }
+
+    /// Returns the node under the pointer; `null` when it was the scene.
+    public final Node getIntersectedNode() {
+        return node;
+    }
+
+    /// Returns the x of the pick in scene coordinates.
+    public double cn1SceneX() {
+        return sceneX;
+    }
+
+    /// Returns the y of the pick in scene coordinates.
+    public double cn1SceneY() {
+        return sceneY;
+    }
+
+    @Override
+    public String toString() {
+        return "PickResult [node = " + node + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/ScrollEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/ScrollEvent.java
new file mode 100644
index 00000000000..fed81c08a13
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/ScrollEvent.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import com.codename1.fxcompat.runtime.SceneInput;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+
+/// The mouse wheel or a track pad scrolling. A positive `deltaY` scrolls
+/// the content down, which is the wheel turning away from the user.
+public final class ScrollEvent extends InputEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Every scroll event.
+    public static final EventType<ScrollEvent> ANY = new EventType<ScrollEvent>(InputEvent.ANY, "ANY_SCROLL");
+
+    /// The content was scrolled.
+    public static final EventType<ScrollEvent> SCROLL = new EventType<ScrollEvent>(ANY, "SCROLL");
+
+    /// A scroll gesture started.
+    public static final EventType<ScrollEvent> SCROLL_STARTED = new EventType<ScrollEvent>(ANY, "SCROLL_STARTED");
+
+    /// A scroll gesture ended.
+    public static final EventType<ScrollEvent> SCROLL_FINISHED = new EventType<ScrollEvent>(ANY, "SCROLL_FINISHED");
+
+    /// The unit of the horizontal text based scroll amount.
+    public enum HorizontalTextScrollUnits {
+        /// No text based amount is available.
+        NONE,
+        /// The amount is in characters.
+        CHARACTERS
+    }
+
+    /// The unit of the vertical text based scroll amount.
+    public enum VerticalTextScrollUnits {
+        /// No text based amount is available.
+        NONE,
+        /// The amount is in lines.
+        LINES,
+        /// The amount is in pages.
+        PAGES
+    }
+
+    private transient double x;
+    private transient double y;
+    private final double screenX;
+    private final double screenY;
+    private final double sceneX;
+    private final double sceneY;
+    private final double deltaX;
+    private final double deltaY;
+    private final double totalDeltaX;
+    private final double totalDeltaY;
+    private final HorizontalTextScrollUnits textDeltaXUnits;
+    private final VerticalTextScrollUnits textDeltaYUnits;
+    private final double textDeltaX;
+    private final double textDeltaY;
+    private final int touchCount;
+    private final boolean inertia;
+    private final boolean direct;
+    private final boolean shiftDown;
+    private final boolean controlDown;
+    private final boolean altDown;
+    private final boolean metaDown;
+    private final transient PickResult pickResult;
+
+    /// Creates a scroll event; `x` and `y` are scene coordinates.
+    public ScrollEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<ScrollEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown,
+            @NamedArg("direct") boolean direct, @NamedArg("inertia") boolean inertia,
+            @NamedArg("deltaX") double deltaX, @NamedArg("deltaY") double deltaY,
+            @NamedArg("totalDeltaX") double totalDeltaX, @NamedArg("totalDeltaY") double totalDeltaY,
+            @NamedArg("textDeltaXUnits") HorizontalTextScrollUnits textDeltaXUnits,
+            @NamedArg("textDeltaX") double textDeltaX,
+            @NamedArg("textDeltaYUnits") VerticalTextScrollUnits textDeltaYUnits,
+            @NamedArg("textDeltaY") double textDeltaY, @NamedArg("touchCount") int touchCount,
+            @NamedArg("pickResult") PickResult pickResult) {
+        super(source, target, eventType);
+        this.sceneX = x;
+        this.sceneY = y;
+        this.screenX = screenX;
+        this.screenY = screenY;
+        this.shiftDown = shiftDown;
+        this.controlDown = controlDown;
+        this.altDown = altDown;
+        this.metaDown = metaDown;
+        this.direct = direct;
+        this.inertia = inertia;
+        this.deltaX = deltaX;
+        this.deltaY = deltaY;
+        this.totalDeltaX = totalDeltaX;
+        this.totalDeltaY = totalDeltaY;
+        this.textDeltaXUnits = textDeltaXUnits;
+        this.textDeltaX = textDeltaX;
+        this.textDeltaYUnits = textDeltaYUnits;
+        this.textDeltaY = textDeltaY;
+        this.touchCount = touchCount;
+        this.pickResult = pickResult != null ? pickResult : new PickResult(target, x, y);
+        localize(source);
+    }
+
+    /// Creates a scroll event with no source and no target.
+    public ScrollEvent(@NamedArg("eventType") EventType<ScrollEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown,
+            @NamedArg("direct") boolean direct, @NamedArg("inertia") boolean inertia,
+            @NamedArg("deltaX") double deltaX, @NamedArg("deltaY") double deltaY,
+            @NamedArg("totalDeltaX") double totalDeltaX, @NamedArg("totalDeltaY") double totalDeltaY,
+            @NamedArg("textDeltaXUnits") HorizontalTextScrollUnits textDeltaXUnits,
+            @NamedArg("textDeltaX") double textDeltaX,
+            @NamedArg("textDeltaYUnits") VerticalTextScrollUnits textDeltaYUnits,
+            @NamedArg("textDeltaY") double textDeltaY, @NamedArg("touchCount") int touchCount,
+            @NamedArg("pickResult") PickResult pickResult) {
+        this(null, null, eventType, x, y, screenX, screenY, shiftDown, controlDown, altDown, metaDown, direct,
+                inertia, deltaX, deltaY, totalDeltaX, totalDeltaY, textDeltaXUnits, textDeltaX, textDeltaYUnits,
+                textDeltaY, touchCount, pickResult);
+    }
+
+    private void localize(Object source) {
+        if (source instanceof Node) {
+            Point2D local = ((Node) source).sceneToLocal(sceneX, sceneY);
+            x = local.getX();
+            y = local.getY();
+        } else {
+            x = sceneX;
+            y = sceneY;
+        }
+    }
+
+    @Override
+    public ScrollEvent copyFor(Object newSource, EventTarget newTarget) {
+        return copyFor(newSource, newTarget, getEventType());
+    }
+
+    /// Returns a copy with another source, target and type.
+    public ScrollEvent copyFor(Object newSource, EventTarget newTarget, EventType<ScrollEvent> type) {
+        return new ScrollEvent(newSource, newTarget, type, sceneX, sceneY, screenX, screenY, shiftDown, controlDown,
+                altDown, metaDown, direct, inertia, deltaX, deltaY, totalDeltaX, totalDeltaY, textDeltaXUnits,
+                textDeltaX, textDeltaYUnits, textDeltaY, touchCount, pickResult);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<ScrollEvent> getEventType() {
+        return (EventType<ScrollEvent>) super.getEventType();
+    }
+
+    /// Returns the x of the pointer in the source's coordinates.
+    public final double getX() {
+        return x;
+    }
+
+    /// Returns the y of the pointer in the source's coordinates.
+    public final double getY() {
+        return y;
+    }
+
+    /// Always 0: this layer is two dimensional.
+    public final double getZ() {
+        return 0;
+    }
+
+    /// Returns the x of the pointer on the screen.
+    public final double getScreenX() {
+        return screenX;
+    }
+
+    /// Returns the y of the pointer on the screen.
+    public final double getScreenY() {
+        return screenY;
+    }
+
+    /// Returns the x of the pointer in the scene.
+    public final double getSceneX() {
+        return sceneX;
+    }
+
+    /// Returns the y of the pointer in the scene.
+    public final double getSceneY() {
+        return sceneY;
+    }
+
+    /// Returns the horizontal amount scrolled, in logical pixels.
+    public double getDeltaX() {
+        return deltaX;
+    }
+
+    /// Returns the vertical amount scrolled, in logical pixels.
+    public double getDeltaY() {
+        return deltaY;
+    }
+
+    /// Returns the horizontal amount scrolled over the whole gesture.
+    public double getTotalDeltaX() {
+        return totalDeltaX;
+    }
+
+    /// Returns the vertical amount scrolled over the whole gesture.
+    public double getTotalDeltaY() {
+        return totalDeltaY;
+    }
+
+    /// Returns the unit of the horizontal text based amount.
+    public HorizontalTextScrollUnits getTextDeltaXUnits() {
+        return textDeltaXUnits;
+    }
+
+    /// Returns the unit of the vertical text based amount.
+    public VerticalTextScrollUnits getTextDeltaYUnits() {
+        return textDeltaYUnits;
+    }
+
+    /// Returns the horizontal text based amount.
+    public double getTextDeltaX() {
+        return textDeltaX;
+    }
+
+    /// Returns the vertical text based amount.
+    public double getTextDeltaY() {
+        return textDeltaY;
+    }
+
+    /// Returns the number of fingers; 0 for a wheel.
+    public int getTouchCount() {
+        return touchCount;
+    }
+
+    /// Returns whether the event was produced by scrolling inertia.
+    public boolean isInertia() {
+        return inertia;
+    }
+
+    /// Returns whether the event came from a touch on the screen itself.
+    public final boolean isDirect() {
+        return direct;
+    }
+
+    /// Returns whether Shift is down.
+    public final boolean isShiftDown() {
+        return shiftDown;
+    }
+
+    /// Returns whether Control is down.
+    public final boolean isControlDown() {
+        return controlDown;
+    }
+
+    /// Returns whether Alt is down.
+    public final boolean isAltDown() {
+        return altDown;
+    }
+
+    /// Returns whether Meta is down.
+    public final boolean isMetaDown() {
+        return metaDown;
+    }
+
+    /// Returns whether the platform's shortcut modifier is down.
+    public final boolean isShortcutDown() {
+        return SceneInput.shortcutIsMeta() ? metaDown : controlDown;
+    }
+
+    /// Returns what was under the pointer.
+    public final PickResult getPickResult() {
+        return pickResult;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/SwipeEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/SwipeEvent.java
new file mode 100644
index 00000000000..b3c159222de
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/SwipeEvent.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// A quick stroke of the finger in one of the four directions.
+///
+/// The scene produces one when a press is dragged a clear distance along
+/// one axis and let go within a moment. It is delivered to the node the
+/// press began on, after the release of that press, and it carries the
+/// position the stroke began at.
+public final class SwipeEvent extends GestureEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The supertype of the four swipes.
+    public static final EventType<SwipeEvent> ANY = new EventType<SwipeEvent>(GestureEvent.ANY, "ANY_SWIPE");
+
+    /// A stroke to the left.
+    public static final EventType<SwipeEvent> SWIPE_LEFT = new EventType<SwipeEvent>(ANY, "SWIPE_LEFT");
+
+    /// A stroke to the right.
+    public static final EventType<SwipeEvent> SWIPE_RIGHT = new EventType<SwipeEvent>(ANY, "SWIPE_RIGHT");
+
+    /// A stroke upwards.
+    public static final EventType<SwipeEvent> SWIPE_UP = new EventType<SwipeEvent>(ANY, "SWIPE_UP");
+
+    /// A stroke downwards.
+    public static final EventType<SwipeEvent> SWIPE_DOWN = new EventType<SwipeEvent>(ANY, "SWIPE_DOWN");
+
+    private final int touchCount;
+
+    /// Creates a swipe at scene coordinates.
+    public SwipeEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<SwipeEvent> eventType, @NamedArg("x") double x, @NamedArg("y") double y,
+            @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown,
+            @NamedArg("direct") boolean direct, @NamedArg("touchCount") int touchCount,
+            @NamedArg("pickResult") PickResult pickResult) {
+        super(source, target, eventType, x, y, screenX, screenY, shiftDown, controlDown, altDown, metaDown, direct,
+                false, pickResult);
+        this.touchCount = touchCount;
+    }
+
+    /// Creates a swipe with no source or target.
+    public SwipeEvent(@NamedArg("eventType") EventType<SwipeEvent> eventType, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown,
+            @NamedArg("direct") boolean direct, @NamedArg("touchCount") int touchCount,
+            @NamedArg("pickResult") PickResult pickResult) {
+        this(null, null, eventType, x, y, screenX, screenY, shiftDown, controlDown, altDown, metaDown, direct,
+                touchCount, pickResult);
+    }
+
+    /// Returns how many fingers made the stroke.
+    public int getTouchCount() {
+        return touchCount;
+    }
+
+    @Override
+    public SwipeEvent copyFor(Object newSource, EventTarget newTarget) {
+        return new SwipeEvent(newSource, newTarget, getEventType(), getSceneX(), getSceneY(), getScreenX(),
+                getScreenY(), isShiftDown(), isControlDown(), isAltDown(), isMetaDown(), isDirect(), touchCount,
+                getPickResult());
+    }
+
+    /// Returns a copy with another source, target and type.
+    public SwipeEvent copyFor(Object newSource, EventTarget newTarget, EventType<SwipeEvent> type) {
+        return new SwipeEvent(newSource, newTarget, type, getSceneX(), getSceneY(), getScreenX(), getScreenY(),
+                isShiftDown(), isControlDown(), isAltDown(), isMetaDown(), isDirect(), touchCount, getPickResult());
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<SwipeEvent> getEventType() {
+        return (EventType<SwipeEvent>) super.getEventType();
+    }
+
+    @Override
+    public String toString() {
+        return "SwipeEvent [type = " + getEventType() + ", touchCount = " + touchCount + ", x = " + getX()
+                + ", y = " + getY() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/TouchEvent.java b/maven/javafx-compat/src/main/java/javafx/scene/input/TouchEvent.java
new file mode 100644
index 00000000000..963892ad131
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/TouchEvent.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// What a finger on the screen did.
+///
+/// Codename One hands every pointer to the scene as a mouse event, which
+/// is what JavaFX itself does on a screen it does not report as a touch
+/// screen: `Platform.isSupported(ConditionalFeature.INPUT_TOUCH)` answers
+/// `false`, and the scene never produces a touch event of its own. The
+/// type is here so that handlers can be registered and so that an
+/// application can fire one. A handler on `onTouchPressed` that repeats
+/// what `onMouseClicked` or `onAction` does is therefore reached through
+/// the mouse handler alone.
+public final class TouchEvent extends InputEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The supertype of every touch event.
+    public static final EventType<TouchEvent> ANY = new EventType<TouchEvent>(InputEvent.ANY, "TOUCH");
+
+    /// A finger went down.
+    public static final EventType<TouchEvent> TOUCH_PRESSED = new EventType<TouchEvent>(ANY, "TOUCH_PRESSED");
+
+    /// A finger moved.
+    public static final EventType<TouchEvent> TOUCH_MOVED = new EventType<TouchEvent>(ANY, "TOUCH_MOVED");
+
+    /// A finger was lifted.
+    public static final EventType<TouchEvent> TOUCH_RELEASED = new EventType<TouchEvent>(ANY, "TOUCH_RELEASED");
+
+    /// A finger stayed where it was while another moved.
+    public static final EventType<TouchEvent> TOUCH_STATIONARY = new EventType<TouchEvent>(ANY,
+            "TOUCH_STATIONARY");
+
+    private final int eventSetId;
+    private final boolean shiftDown;
+    private final boolean controlDown;
+    private final boolean altDown;
+    private final boolean metaDown;
+    private final transient TouchPoint touchPoint;
+    private final transient List<TouchPoint> touchPoints;
+
+    /// Creates a touch event for one finger out of those on the screen.
+    public TouchEvent(@NamedArg("source") Object source, @NamedArg("target") EventTarget target,
+            @NamedArg("eventType") EventType<TouchEvent> eventType, @NamedArg("touchPoint") TouchPoint touchPoint,
+            @NamedArg("touchPoints") List<TouchPoint> touchPoints, @NamedArg("eventSetId") int eventSetId,
+            @NamedArg("shiftDown") boolean shiftDown, @NamedArg("controlDown") boolean controlDown,
+            @NamedArg("altDown") boolean altDown, @NamedArg("metaDown") boolean metaDown) {
+        super(source, target, eventType);
+        this.touchPoint = touchPoint;
+        List<TouchPoint> all = new ArrayList<TouchPoint>();
+        if (touchPoints != null) {
+            all.addAll(touchPoints);
+        }
+        this.touchPoints = Collections.unmodifiableList(all);
+        this.eventSetId = eventSetId;
+        this.shiftDown = shiftDown;
+        this.controlDown = controlDown;
+        this.altDown = altDown;
+        this.metaDown = metaDown;
+        localize(source);
+    }
+
+    /// Creates a touch event with no source or target.
+    public TouchEvent(@NamedArg("eventType") EventType<TouchEvent> eventType,
+            @NamedArg("touchPoint") TouchPoint touchPoint, @NamedArg("touchPoints") List<TouchPoint> touchPoints,
+            @NamedArg("eventSetId") int eventSetId, @NamedArg("shiftDown") boolean shiftDown,
+            @NamedArg("controlDown") boolean controlDown, @NamedArg("altDown") boolean altDown,
+            @NamedArg("metaDown") boolean metaDown) {
+        this(null, null, eventType, touchPoint, touchPoints, eventSetId, shiftDown, controlDown, altDown, metaDown);
+    }
+
+    private void localize(Object source) {
+        if (touchPoint != null) {
+            touchPoint.localize(source);
+        }
+        for (int i = 0; i < touchPoints.size(); i++) {
+            TouchPoint p = touchPoints.get(i);
+            if (p != null && p != touchPoint) {
+                p.localize(source);
+            }
+        }
+    }
+
+    /// Returns how many fingers were on the screen.
+    public int getTouchCount() {
+        return touchPoints.size();
+    }
+
+    @Override
+    public TouchEvent copyFor(Object newSource, EventTarget newTarget) {
+        return new TouchEvent(newSource, newTarget, getEventType(), touchPoint, touchPoints, eventSetId, shiftDown,
+                controlDown, altDown, metaDown);
+    }
+
+    /// Returns a copy with another source, target and type.
+    public TouchEvent copyFor(Object newSource, EventTarget newTarget, EventType<TouchEvent> type) {
+        return new TouchEvent(newSource, newTarget, type, touchPoint, touchPoints, eventSetId, shiftDown,
+                controlDown, altDown, metaDown);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<TouchEvent> getEventType() {
+        return (EventType<TouchEvent>) super.getEventType();
+    }
+
+    /// Returns the number shared by the events one movement of several
+    /// fingers produced.
+    public final int getEventSetId() {
+        return eventSetId;
+    }
+
+    /// Returns whether Shift was held.
+    public final boolean isShiftDown() {
+        return shiftDown;
+    }
+
+    /// Returns whether Control was held.
+    public final boolean isControlDown() {
+        return controlDown;
+    }
+
+    /// Returns whether Alt was held.
+    public final boolean isAltDown() {
+        return altDown;
+    }
+
+    /// Returns whether Meta was held.
+    public final boolean isMetaDown() {
+        return metaDown;
+    }
+
+    /// Returns the finger this event is about.
+    public TouchPoint getTouchPoint() {
+        return touchPoint;
+    }
+
+    /// Returns every finger on the screen, this event's among them.
+    public List<TouchPoint> getTouchPoints() {
+        return touchPoints;
+    }
+
+    @Override
+    public String toString() {
+        return "TouchEvent [type = " + getEventType() + ", touchCount = " + getTouchCount() + ", eventSetId = "
+                + eventSetId + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/TouchPoint.java b/maven/javafx-compat/src/main/java/javafx/scene/input/TouchPoint.java
new file mode 100644
index 00000000000..ed146c4fe87
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/TouchPoint.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.input;
+
+import javafx.beans.NamedArg;
+import javafx.event.EventTarget;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+
+/// One finger on the screen, as a [TouchEvent] reports it.
+public final class TouchPoint {
+
+    /// What a finger did since the event before.
+    public enum State {
+        /// The finger went down.
+        PRESSED,
+        /// The finger moved.
+        MOVED,
+        /// The finger stayed where it was.
+        STATIONARY,
+        /// The finger was lifted.
+        RELEASED
+    }
+
+    private final int id;
+    private final State state;
+    private double x;
+    private double y;
+    private final double screenX;
+    private final double screenY;
+    private final double sceneX;
+    private final double sceneY;
+    private final EventTarget target;
+    private EventTarget grabbed;
+    private final PickResult pickResult;
+
+    /// Creates a touch point at scene coordinates.
+    public TouchPoint(@NamedArg("id") int id, @NamedArg("state") State state, @NamedArg("x") double x,
+            @NamedArg("y") double y, @NamedArg("screenX") double screenX, @NamedArg("screenY") double screenY,
+            @NamedArg("target") EventTarget target, @NamedArg("pickResult") PickResult pickResult) {
+        this.id = id;
+        this.state = state;
+        this.x = x;
+        this.y = y;
+        this.sceneX = x;
+        this.sceneY = y;
+        this.screenX = screenX;
+        this.screenY = screenY;
+        this.target = target;
+        this.pickResult = pickResult != null ? pickResult : new PickResult(target, x, y);
+    }
+
+    /// Moves the point into the coordinates of the node an event is being
+    /// delivered to.
+    void localize(Object source) {
+        if (source instanceof Node) {
+            Point2D local = ((Node) source).sceneToLocal(sceneX, sceneY);
+            x = local.getX();
+            y = local.getY();
+        } else {
+            x = sceneX;
+            y = sceneY;
+        }
+    }
+
+    /// Returns whether this point is delivered to a target or to one of
+    /// the nodes inside it.
+    public boolean belongsTo(EventTarget target) {
+        EventTarget mine = this.target;
+        if (mine instanceof Node) {
+            Node node = (Node) mine;
+            for (Node n = node; n != null; n = n.getParent()) {
+                if (n == target) {
+                    return true;
+                }
+            }
+            return target != null && node.getScene() == target;
+        }
+        return mine == target;
+    }
+
+    /// Delivers the rest of this finger's events to a target.
+    public void grab(EventTarget target) {
+        grabbed = target;
+    }
+
+    /// Delivers the rest of this finger's events to where this one went.
+    public void grab() {
+        grabbed = target;
+    }
+
+    /// Delivers this finger's events to whatever is under it again.
+    public void ungrab() {
+        grabbed = null;
+    }
+
+    /// Returns the target that grabbed this finger, `null` for none.
+    public EventTarget getGrabbed() {
+        return grabbed;
+    }
+
+    /// Returns the number that tells this finger from the others.
+    public final int getId() {
+        return id;
+    }
+
+    /// Returns what the finger did.
+    public final State getState() {
+        return state;
+    }
+
+    /// Returns the horizontal position in the coordinates of the source.
+    public final double getX() {
+        return x;
+    }
+
+    /// Returns the vertical position in the coordinates of the source.
+    public final double getY() {
+        return y;
+    }
+
+    /// Returns the depth of the position, always zero in a flat scene.
+    public final double getZ() {
+        return 0;
+    }
+
+    /// Returns the horizontal position on the screen.
+    public final double getScreenX() {
+        return screenX;
+    }
+
+    /// Returns the vertical position on the screen.
+    public final double getScreenY() {
+        return screenY;
+    }
+
+    /// Returns the horizontal position in the scene.
+    public final double getSceneX() {
+        return sceneX;
+    }
+
+    /// Returns the vertical position in the scene.
+    public final double getSceneY() {
+        return sceneY;
+    }
+
+    /// Returns what was under the finger.
+    public final PickResult getPickResult() {
+        return pickResult;
+    }
+
+    /// Returns where the finger's events are delivered.
+    public EventTarget getTarget() {
+        return target;
+    }
+
+    @Override
+    public String toString() {
+        return "TouchPoint [state = " + state + ", id = " + id + ", x = " + x + ", y = " + y + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/input/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/input/package-info.java
new file mode 100644
index 00000000000..a9431d7c63c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/input/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Input events: mouse and touch, keys, scrolling and context menu
+/// requests, and the key codes of a keyboard.
+package javafx.scene.input;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/AnchorPane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/AnchorPane.java
new file mode 100644
index 00000000000..f4c03b3e3bd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/AnchorPane.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import javafx.geometry.Bounds;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.scene.Node;
+
+/// Keeps the edges of its managed children at fixed distances from its
+/// own edges.
+///
+/// An anchor is the distance from an edge of the pane's content area (the
+/// area inside the padding) to the same edge of the child. A resizable
+/// child anchored on two opposite sides is stretched between them,
+/// whatever its minimum and maximum size; any other child keeps its
+/// preferred size. A child with no anchor in a direction stays at its
+/// `layoutX` or `layoutY`.
+///
+/// The preferred size of the pane is the smallest that shows every child
+/// at its preferred size with its anchors; the minimum size uses the
+/// minimum size of the children that are anchored on both sides.
+public class AnchorPane extends Pane {
+
+    private static final String TOP = "pane-top-anchor";
+    private static final String LEFT = "pane-left-anchor";
+    private static final String BOTTOM = "pane-bottom-anchor";
+    private static final String RIGHT = "pane-right-anchor";
+
+    /// Creates an empty anchor pane.
+    public AnchorPane() {
+    }
+
+    /// Creates an anchor pane with children.
+    public AnchorPane(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Sets the distance from the top of the content area to the top of a
+    /// child; `null` removes the anchor.
+    public static void setTopAnchor(Node child, Double value) {
+        setConstraint(child, TOP, value);
+    }
+
+    /// Returns the top anchor of a child, or `null`.
+    public static Double getTopAnchor(Node child) {
+        return LayoutSupport.number(child, TOP);
+    }
+
+    /// Sets the distance from the left of the content area to the left of
+    /// a child; `null` removes the anchor.
+    public static void setLeftAnchor(Node child, Double value) {
+        setConstraint(child, LEFT, value);
+    }
+
+    /// Returns the left anchor of a child, or `null`.
+    public static Double getLeftAnchor(Node child) {
+        return LayoutSupport.number(child, LEFT);
+    }
+
+    /// Sets the distance from the bottom of the content area to the bottom
+    /// of a child; `null` removes the anchor.
+    public static void setBottomAnchor(Node child, Double value) {
+        setConstraint(child, BOTTOM, value);
+    }
+
+    /// Returns the bottom anchor of a child, or `null`.
+    public static Double getBottomAnchor(Node child) {
+        return LayoutSupport.number(child, BOTTOM);
+    }
+
+    /// Sets the distance from the right of the content area to the right
+    /// of a child; `null` removes the anchor.
+    public static void setRightAnchor(Node child, Double value) {
+        setConstraint(child, RIGHT, value);
+    }
+
+    /// Returns the right anchor of a child, or `null`.
+    public static Double getRightAnchor(Node child) {
+        return LayoutSupport.number(child, RIGHT);
+    }
+
+    /// Removes the anchors from a child.
+    public static void clearConstraints(Node child) {
+        setTopAnchor(child, null);
+        setRightAnchor(child, null);
+        setBottomAnchor(child, null);
+        setLeftAnchor(child, null);
+    }
+
+    private static double value(Double anchor) {
+        return anchor == null ? 0 : anchor.doubleValue();
+    }
+
+    private double extent(boolean horizontal, boolean minimum, double across) {
+        List<Node> managed = getManagedChildren();
+        double max = 0;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            Double near = horizontal ? getLeftAnchor(child) : getTopAnchor(child);
+            Double far = horizontal ? getRightAnchor(child) : getBottomAnchor(child);
+            Bounds lb = child.getLayoutBounds();
+            double start;
+            if (near != null) {
+                start = near.doubleValue();
+            } else {
+                start = horizontal ? lb.getMinX() + child.getLayoutX() : lb.getMinY() + child.getLayoutY();
+            }
+            double other = -1;
+            Orientation bias = child.getContentBias();
+            if (across != -1 && bias == (horizontal ? Orientation.VERTICAL : Orientation.HORIZONTAL)) {
+                other = horizontal ? childHeight(child, across, -1) : childWidth(child, across, -1);
+            }
+            double size;
+            if (minimum && near != null && far != null) {
+                size = horizontal ? child.minWidth(other) : child.minHeight(other);
+            } else if (horizontal) {
+                size = computeChildPrefAreaWidth(child, null, other);
+            } else {
+                size = computeChildPrefAreaHeight(child, null, other);
+            }
+            max = Math.max(max, start + size + value(far));
+        }
+        return max;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + extent(true, true, height == -1 ? -1 : height - in.getTop() - in.getBottom())
+                + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + extent(false, true, width == -1 ? -1 : width - in.getLeft() - in.getRight())
+                + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + extent(true, false, height == -1 ? -1 : height - in.getTop() - in.getBottom())
+                + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + extent(false, false, width == -1 ? -1 : width - in.getLeft() - in.getRight())
+                + in.getBottom();
+    }
+
+    /// The width of a child in a content area of a given width.
+    private double childWidth(Node child, double insideWidth, double height) {
+        Double left = getLeftAnchor(child);
+        Double right = getRightAnchor(child);
+        if (left != null && right != null && child.isResizable()) {
+            return Math.max(0, insideWidth - left.doubleValue() - right.doubleValue());
+        }
+        return computeChildPrefAreaWidth(child, null, height);
+    }
+
+    private double childHeight(Node child, double insideHeight, double width) {
+        Double top = getTopAnchor(child);
+        Double bottom = getBottomAnchor(child);
+        if (top != null && bottom != null && child.isResizable()) {
+            return Math.max(0, insideHeight - top.doubleValue() - bottom.doubleValue());
+        }
+        return computeChildPrefAreaHeight(child, null, width);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> managed = getManagedChildren();
+        Insets in = getInsets();
+        double insideWidth = getWidth() - in.getLeft() - in.getRight();
+        double insideHeight = getHeight() - in.getTop() - in.getBottom();
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            Bounds lb = child.getLayoutBounds();
+            Orientation bias = child.getContentBias();
+            double w;
+            double h;
+            if (bias == Orientation.VERTICAL) {
+                h = childHeight(child, insideHeight, -1);
+                w = childWidth(child, insideWidth, h);
+            } else if (bias == Orientation.HORIZONTAL) {
+                w = childWidth(child, insideWidth, -1);
+                h = childHeight(child, insideHeight, w);
+            } else {
+                w = childWidth(child, insideWidth, -1);
+                h = childHeight(child, insideHeight, -1);
+            }
+            double x = child.getLayoutX() + lb.getMinX();
+            double y = child.getLayoutY() + lb.getMinY();
+            Double left = getLeftAnchor(child);
+            Double right = getRightAnchor(child);
+            Double top = getTopAnchor(child);
+            Double bottom = getBottomAnchor(child);
+            if (left != null) {
+                x = in.getLeft() + left.doubleValue();
+            } else if (right != null) {
+                x = getWidth() - in.getRight() - right.doubleValue() - w;
+            }
+            if (top != null) {
+                y = in.getTop() + top.doubleValue();
+            } else if (bottom != null) {
+                y = getHeight() - in.getBottom() - bottom.doubleValue() - h;
+            }
+            child.resizeRelocate(snapPositionX(x), snapPositionY(y), w, h);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/Background.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/Background.java
new file mode 100644
index 00000000000..20517431460
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/Background.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.beans.NamedArg;
+import javafx.geometry.Insets;
+
+/// The background of a region: fills painted one above the other, the
+/// first one at the bottom. Background images are not part of this layer.
+public final class Background {
+
+    /// A background that paints nothing.
+    public static final Background EMPTY = new Background((BackgroundFill[]) null);
+
+    private final List<BackgroundFill> fills;
+    private final List<BackgroundImage> images;
+    private final Insets outsets;
+
+    /// Creates a background from fills; `null` entries are ignored.
+    public Background(@NamedArg("fills") BackgroundFill... fills) {
+        this(fills, (BackgroundImage[]) null);
+    }
+
+    /// Creates a background of pictures and no fills, bottom first.
+    public Background(@NamedArg("images") BackgroundImage... images) {
+        this((BackgroundFill[]) null, images);
+    }
+
+    /// Creates a background of fills with pictures over them, each list
+    /// bottom first; `null` entries are left out.
+    public Background(@NamedArg("fills") List<BackgroundFill> fills,
+            @NamedArg("images") List<BackgroundImage> images) {
+        this(fills == null ? null : fills.toArray(new BackgroundFill[0]),
+                images == null ? null : images.toArray(new BackgroundImage[0]));
+    }
+
+    /// Creates a background of fills with pictures over them, each array
+    /// bottom first; `null` entries are left out.
+    public Background(@NamedArg("fills") BackgroundFill[] fills, @NamedArg("images") BackgroundImage[] images) {
+        ArrayList<BackgroundImage> pictures = new ArrayList<BackgroundImage>();
+        if (images != null) {
+            for (int i = 0; i < images.length; i++) {
+                if (images[i] != null) {
+                    pictures.add(images[i]);
+                }
+            }
+        }
+        this.images = Collections.unmodifiableList(pictures);
+        ArrayList<BackgroundFill> list = new ArrayList<BackgroundFill>();
+        double top = 0;
+        double right = 0;
+        double bottom = 0;
+        double left = 0;
+        if (fills != null) {
+            for (int i = 0; i < fills.length; i++) {
+                BackgroundFill fill = fills[i];
+                if (fill != null) {
+                    list.add(fill);
+                    Insets in = fill.getInsets();
+                    top = Math.max(top, -in.getTop());
+                    right = Math.max(right, -in.getRight());
+                    bottom = Math.max(bottom, -in.getBottom());
+                    left = Math.max(left, -in.getLeft());
+                }
+            }
+        }
+        this.fills = Collections.unmodifiableList(list);
+        this.outsets = new Insets(top, right, bottom, left);
+    }
+
+    /// Returns the fills, bottom first; unmodifiable.
+    public final List<BackgroundFill> getFills() {
+        return fills;
+    }
+
+    /// Returns how far the background reaches outside the region.
+    public final Insets getOutsets() {
+        return outsets;
+    }
+
+    /// Returns whether there is nothing to paint.
+    public final boolean isEmpty() {
+        return fills.isEmpty() && images.isEmpty();
+    }
+
+    /// Returns whether any fill has corner radii given as a fraction of
+    /// the size.
+    public boolean isFillPercentageBased() {
+        for (int i = 0; i < fills.size(); i++) {
+            if (fills.get(i).getRadii().isTopLeftHorizontalRadiusAsPercentage()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        return o instanceof Background && fills.equals(((Background) o).fills)
+                && images.equals(((Background) o).images);
+    }
+
+    @Override
+    public int hashCode() {
+        return fills.hashCode();
+    }
+
+    /// Returns the pictures, bottom first; unmodifiable. They are drawn
+    /// over the fills.
+    public final List<BackgroundImage> getImages() {
+        return images;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundFill.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundFill.java
new file mode 100644
index 00000000000..4f7b1c20ddc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundFill.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+import javafx.geometry.Insets;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+
+/// One layer of a background: a paint, the corner radii of the area it
+/// fills and how far that area is inset from the edges of the region.
+public final class BackgroundFill {
+
+    private final Paint fill;
+    private final CornerRadii radii;
+    private final Insets insets;
+
+    /// Creates a fill; a missing paint is transparent, missing radii are
+    /// square and missing insets are none.
+    public BackgroundFill(@NamedArg("fill") Paint fill, @NamedArg("radii") CornerRadii radii,
+            @NamedArg("insets") Insets insets) {
+        this.fill = fill == null ? Color.TRANSPARENT : fill;
+        this.radii = radii == null ? CornerRadii.EMPTY : radii;
+        this.insets = insets == null ? Insets.EMPTY : insets;
+    }
+
+    /// Returns the paint.
+    public final Paint getFill() {
+        return fill;
+    }
+
+    /// Returns the corner radii.
+    public final CornerRadii getRadii() {
+        return radii;
+    }
+
+    /// Returns the insets from the edges of the region.
+    public final Insets getInsets() {
+        return insets;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BackgroundFill)) {
+            return false;
+        }
+        BackgroundFill that = (BackgroundFill) o;
+        return fill.equals(that.fill) && insets.equals(that.insets) && radii.equals(that.radii);
+    }
+
+    @Override
+    public int hashCode() {
+        return (fill.hashCode() * 31 + radii.hashCode()) * 31 + insets.hashCode();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundImage.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundImage.java
new file mode 100644
index 00000000000..81220d48530
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundImage.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+import javafx.scene.image.Image;
+
+/// A picture drawn behind the content of a region, over its fills: where
+/// it is placed, at what size, and how it fills the rest of the region.
+public final class BackgroundImage {
+
+    private final Image image;
+    private final BackgroundRepeat repeatX;
+    private final BackgroundRepeat repeatY;
+    private final BackgroundPosition position;
+    private final BackgroundSize size;
+
+    /// Creates a background image. A `null` repeat is `REPEAT`, a `null`
+    /// position the top left corner and a `null` size the picture's own.
+    public BackgroundImage(@NamedArg("image") Image image, @NamedArg("repeatX") BackgroundRepeat repeatX,
+            @NamedArg("repeatY") BackgroundRepeat repeatY, @NamedArg("position") BackgroundPosition position,
+            @NamedArg("size") BackgroundSize size) {
+        if (image == null) {
+            throw new NullPointerException("Image cannot be null");
+        }
+        this.image = image;
+        this.repeatX = repeatX == null ? BackgroundRepeat.REPEAT : repeatX;
+        this.repeatY = repeatY == null ? BackgroundRepeat.REPEAT : repeatY;
+        this.position = position == null ? BackgroundPosition.DEFAULT : position;
+        this.size = size == null ? BackgroundSize.DEFAULT : size;
+    }
+
+    /// Returns the picture.
+    public final Image getImage() {
+        return image;
+    }
+
+    /// Returns how the picture fills the width.
+    public final BackgroundRepeat getRepeatX() {
+        return repeatX;
+    }
+
+    /// Returns how the picture fills the height.
+    public final BackgroundRepeat getRepeatY() {
+        return repeatY;
+    }
+
+    /// Returns where the picture is placed.
+    public final BackgroundPosition getPosition() {
+        return position;
+    }
+
+    /// Returns the size the picture is drawn at.
+    public final BackgroundSize getSize() {
+        return size;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BackgroundImage)) {
+            return false;
+        }
+        BackgroundImage b = (BackgroundImage) o;
+        return image == b.image && repeatX == b.repeatX && repeatY == b.repeatY && position.equals(b.position)
+                && size.equals(b.size);
+    }
+
+    @Override
+    public int hashCode() {
+        return position.hashCode() * 7 + size.hashCode() + repeatX.hashCode() + repeatY.hashCode() * 3;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundPosition.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundPosition.java
new file mode 100644
index 00000000000..de80f6b7407
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundPosition.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+import javafx.geometry.Side;
+
+/// Where a background image is placed in its region: a distance from one
+/// side for each direction. A distance that is a percentage, written
+/// 0 to 1, places that share of the image at that share of the region,
+/// so 0.5 centres it.
+public class BackgroundPosition {
+
+    /// The top left corner.
+    public static final BackgroundPosition DEFAULT = new BackgroundPosition(Side.LEFT, 0, true, Side.TOP, 0, true);
+
+    /// The middle.
+    public static final BackgroundPosition CENTER =
+            new BackgroundPosition(Side.LEFT, 0.5, true, Side.TOP, 0.5, true);
+
+    private final Side horizontalSide;
+    private final Side verticalSide;
+    private final double horizontalPosition;
+    private final double verticalPosition;
+    private final boolean horizontalAsPercentage;
+    private final boolean verticalAsPercentage;
+
+    /// Creates a position. The horizontal side is `LEFT` or `RIGHT`, the
+    /// vertical one `TOP` or `BOTTOM`; `null` is the left and the top.
+    public BackgroundPosition(@NamedArg("horizontalSide") Side horizontalSide,
+            @NamedArg("horizontalPosition") double horizontalPosition,
+            @NamedArg("horizontalAsPercentage") boolean horizontalAsPercentage,
+            @NamedArg("verticalSide") Side verticalSide, @NamedArg("verticalPosition") double verticalPosition,
+            @NamedArg("verticalAsPercentage") boolean verticalAsPercentage) {
+        if (horizontalSide == Side.TOP || horizontalSide == Side.BOTTOM) {
+            throw new IllegalArgumentException("The horizontalSide must be LEFT or RIGHT");
+        }
+        if (verticalSide == Side.LEFT || verticalSide == Side.RIGHT) {
+            throw new IllegalArgumentException("The verticalSide must be TOP or BOTTOM");
+        }
+        this.horizontalSide = horizontalSide == null ? Side.LEFT : horizontalSide;
+        this.verticalSide = verticalSide == null ? Side.TOP : verticalSide;
+        this.horizontalPosition = horizontalPosition;
+        this.verticalPosition = verticalPosition;
+        this.horizontalAsPercentage = horizontalAsPercentage;
+        this.verticalAsPercentage = verticalAsPercentage;
+    }
+
+    /// Returns the side the horizontal distance is from.
+    public final Side getHorizontalSide() {
+        return horizontalSide;
+    }
+
+    /// Returns the side the vertical distance is from.
+    public final Side getVerticalSide() {
+        return verticalSide;
+    }
+
+    /// Returns the horizontal distance.
+    public final double getHorizontalPosition() {
+        return horizontalPosition;
+    }
+
+    /// Returns the vertical distance.
+    public final double getVerticalPosition() {
+        return verticalPosition;
+    }
+
+    /// Returns whether the horizontal distance is a share, 0 to 1.
+    public final boolean isHorizontalAsPercentage() {
+        return horizontalAsPercentage;
+    }
+
+    /// Returns whether the vertical distance is a share, 0 to 1.
+    public final boolean isVerticalAsPercentage() {
+        return verticalAsPercentage;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BackgroundPosition)) {
+            return false;
+        }
+        BackgroundPosition p = (BackgroundPosition) o;
+        return horizontalSide == p.horizontalSide && verticalSide == p.verticalSide
+                && horizontalPosition == p.horizontalPosition && verticalPosition == p.verticalPosition
+                && horizontalAsPercentage == p.horizontalAsPercentage
+                && verticalAsPercentage == p.verticalAsPercentage;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (horizontalPosition * 31 + verticalPosition * 17) + horizontalSide.hashCode() * 7
+                + verticalSide.hashCode() + (horizontalAsPercentage ? 3 : 0) + (verticalAsPercentage ? 5 : 0);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundRepeat.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundRepeat.java
new file mode 100644
index 00000000000..a8f18e08253
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundRepeat.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+/// How a background image fills the room its one copy leaves.
+public enum BackgroundRepeat {
+    /// Copies side by side from the position, cut off at the edges.
+    REPEAT,
+    /// As many whole copies as fit, spread out so the first and the last
+    /// touch the edges.
+    SPACE,
+    /// Copies resized so that a whole number of them fits exactly.
+    ROUND,
+    /// One copy.
+    NO_REPEAT
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundSize.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundSize.java
new file mode 100644
index 00000000000..0283d3e19f8
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BackgroundSize.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+
+/// The size a background image is drawn at. A width or height is a
+/// length, a share of the region written 0 to 1, or [#AUTO]: the size of
+/// the picture, or what keeps its shape when the other is given.
+/// `contain` and `cover` overrule both: the largest size that fits whole,
+/// and the smallest that leaves nothing bare.
+public final class BackgroundSize {
+
+    /// The size the picture has, or the one that keeps its shape.
+    public static final double AUTO = -1;
+
+    /// The picture at its own size.
+    public static final BackgroundSize DEFAULT = new BackgroundSize(AUTO, AUTO, true, true, false, false);
+
+    private final double width;
+    private final double height;
+    private final boolean widthAsPercentage;
+    private final boolean heightAsPercentage;
+    private final boolean contain;
+    private final boolean cover;
+
+    /// Creates a size.
+    public BackgroundSize(@NamedArg("width") double width, @NamedArg("height") double height,
+            @NamedArg("widthAsPercentage") boolean widthAsPercentage,
+            @NamedArg("heightAsPercentage") boolean heightAsPercentage, @NamedArg("contain") boolean contain,
+            @NamedArg("cover") boolean cover) {
+        if (width < 0 && width != AUTO) {
+            throw new IllegalArgumentException("Width cannot be < 0, except when AUTO");
+        }
+        if (height < 0 && height != AUTO) {
+            throw new IllegalArgumentException("Height cannot be < 0, except when AUTO");
+        }
+        this.width = width;
+        this.height = height;
+        this.widthAsPercentage = widthAsPercentage;
+        this.heightAsPercentage = heightAsPercentage;
+        this.contain = contain;
+        this.cover = cover;
+    }
+
+    /// Returns the width, or [#AUTO].
+    public final double getWidth() {
+        return width;
+    }
+
+    /// Returns the height, or [#AUTO].
+    public final double getHeight() {
+        return height;
+    }
+
+    /// Returns whether the width is a share of the region, 0 to 1.
+    public final boolean isWidthAsPercentage() {
+        return widthAsPercentage;
+    }
+
+    /// Returns whether the height is a share of the region, 0 to 1.
+    public final boolean isHeightAsPercentage() {
+        return heightAsPercentage;
+    }
+
+    /// Returns whether the picture is as large as fits whole.
+    public final boolean isContain() {
+        return contain;
+    }
+
+    /// Returns whether the picture is as small as covers the region.
+    public final boolean isCover() {
+        return cover;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BackgroundSize)) {
+            return false;
+        }
+        BackgroundSize s = (BackgroundSize) o;
+        return width == s.width && height == s.height && widthAsPercentage == s.widthAsPercentage
+                && heightAsPercentage == s.heightAsPercentage && contain == s.contain && cover == s.cover;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (width * 31 + height * 17) + (widthAsPercentage ? 1 : 0) + (heightAsPercentage ? 2 : 0)
+                + (contain ? 4 : 0) + (cover ? 8 : 0);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/Border.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/Border.java
new file mode 100644
index 00000000000..0d1cc8f7e53
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/Border.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.beans.NamedArg;
+import javafx.geometry.Insets;
+
+/// The border of a region: strokes drawn one above the other. A border
+/// takes room: its widths are part of the region's insets. Border images
+/// are not part of this layer.
+public final class Border {
+
+    /// A border that draws nothing and takes no room.
+    public static final Border EMPTY = new Border((BorderStroke[]) null);
+
+    private final List<BorderStroke> strokes;
+    private final List<BorderImage> images;
+    private final Insets insets;
+    private final Insets outsets;
+
+    /// Creates a border from strokes; `null` entries are ignored.
+    public Border(@NamedArg("strokes") BorderStroke... strokes) {
+        this(strokes, (BorderImage[]) null);
+    }
+
+    /// Creates a border of pictures and no strokes, bottom first.
+    public Border(@NamedArg("images") BorderImage... images) {
+        this((BorderStroke[]) null, images);
+    }
+
+    /// Creates a border of strokes with pictures over them, each list
+    /// bottom first; `null` entries are left out.
+    public Border(@NamedArg("strokes") List<BorderStroke> strokes, @NamedArg("images") List<BorderImage> images) {
+        this(strokes == null ? null : strokes.toArray(new BorderStroke[0]),
+                images == null ? null : images.toArray(new BorderImage[0]));
+    }
+
+    /// Creates a border of strokes with pictures over them, each array
+    /// bottom first; `null` entries are left out.
+    public Border(@NamedArg("strokes") BorderStroke[] strokes, @NamedArg("images") BorderImage[] images) {
+        ArrayList<BorderStroke> list = new ArrayList<BorderStroke>();
+        ArrayList<BorderImage> pictures = new ArrayList<BorderImage>();
+        double top = 0;
+        double right = 0;
+        double bottom = 0;
+        double left = 0;
+        if (images != null) {
+            for (int i = 0; i < images.length; i++) {
+                BorderImage image = images[i];
+                if (image == null) {
+                    continue;
+                }
+                pictures.add(image);
+                // A width that is a share of the region cannot be room
+                // taken from it before the region has a size.
+                Insets in = image.getInsets();
+                BorderWidths w = image.getWidths();
+                top = Math.max(top, in.getTop() + (w.isTopAsPercentage() ? 0 : Math.max(0, w.getTop())));
+                right = Math.max(right, in.getRight() + (w.isRightAsPercentage() ? 0 : Math.max(0, w.getRight())));
+                bottom = Math.max(bottom,
+                        in.getBottom() + (w.isBottomAsPercentage() ? 0 : Math.max(0, w.getBottom())));
+                left = Math.max(left, in.getLeft() + (w.isLeftAsPercentage() ? 0 : Math.max(0, w.getLeft())));
+            }
+        }
+        this.images = Collections.unmodifiableList(pictures);
+        double outTop = 0;
+        double outRight = 0;
+        double outBottom = 0;
+        double outLeft = 0;
+        if (strokes != null) {
+            for (int i = 0; i < strokes.length; i++) {
+                BorderStroke stroke = strokes[i];
+                if (stroke == null) {
+                    continue;
+                }
+                list.add(stroke);
+                Insets in = stroke.getInsets();
+                BorderWidths w = stroke.getWidths();
+                top = Math.max(top, in.getTop() + side(w.getTop(), stroke.getTopStyle()));
+                right = Math.max(right, in.getRight() + side(w.getRight(), stroke.getRightStyle()));
+                bottom = Math.max(bottom, in.getBottom() + side(w.getBottom(), stroke.getBottomStyle()));
+                left = Math.max(left, in.getLeft() + side(w.getLeft(), stroke.getLeftStyle()));
+                outTop = Math.max(outTop, -in.getTop());
+                outRight = Math.max(outRight, -in.getRight());
+                outBottom = Math.max(outBottom, -in.getBottom());
+                outLeft = Math.max(outLeft, -in.getLeft());
+            }
+        }
+        this.strokes = Collections.unmodifiableList(list);
+        this.insets = new Insets(Math.max(0, top), Math.max(0, right), Math.max(0, bottom), Math.max(0, left));
+        this.outsets = new Insets(outTop, outRight, outBottom, outLeft);
+    }
+
+    private static double side(double width, BorderStrokeStyle style) {
+        if (style == BorderStrokeStyle.NONE) {
+            return 0;
+        }
+        return width == BorderWidths.AUTO ? 1 : width;
+    }
+
+    /// Returns the strokes, bottom first; unmodifiable.
+    public final List<BorderStroke> getStrokes() {
+        return strokes;
+    }
+
+    /// Returns the room the border takes inside the region.
+    public final Insets getInsets() {
+        return insets;
+    }
+
+    /// Returns how far the border reaches outside the region.
+    public final Insets getOutsets() {
+        return outsets;
+    }
+
+    /// Returns whether there is nothing to draw.
+    public final boolean isEmpty() {
+        return strokes.isEmpty() && images.isEmpty();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        return o instanceof Border && strokes.equals(((Border) o).strokes)
+                && images.equals(((Border) o).images);
+    }
+
+    @Override
+    public int hashCode() {
+        return strokes.hashCode();
+    }
+
+    /// Returns the pictures, bottom first; unmodifiable. They are drawn
+    /// over the strokes.
+    public final List<BorderImage> getImages() {
+        return images;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderImage.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderImage.java
new file mode 100644
index 00000000000..fec5ce90dd0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderImage.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+import javafx.geometry.Insets;
+import javafx.scene.image.Image;
+
+/// A picture drawn as the border of a region. Four cuts, one from each
+/// edge of the picture, divide it into nine pieces: the corners are drawn
+/// in the corners of the border, the four sides along its sides, stretched
+/// or repeated, and the middle over the inside when the border is filled.
+public class BorderImage {
+
+    private final Image image;
+    private final BorderRepeat repeatX;
+    private final BorderRepeat repeatY;
+    private final BorderWidths widths;
+    private final BorderWidths slices;
+    private final boolean filled;
+    private final Insets insets;
+    private com.codename1.ui.Image[] pieces;
+
+    /// Creates a border image. `widths` are the widths of the border the
+    /// pieces are drawn into, `slices` the cuts into the picture and
+    /// `insets` how far inside the region the border starts; `null` is a
+    /// width of one, a cut of one and no insets, and a `null` repeat is
+    /// `STRETCH`.
+    public BorderImage(@NamedArg("image") Image image, @NamedArg("widths") BorderWidths widths,
+            @NamedArg("insets") Insets insets, @NamedArg("slices") BorderWidths slices,
+            @NamedArg("filled") boolean filled, @NamedArg("repeatX") BorderRepeat repeatX,
+            @NamedArg("repeatY") BorderRepeat repeatY) {
+        if (image == null) {
+            throw new NullPointerException("Image cannot be null");
+        }
+        this.image = image;
+        this.widths = widths == null ? BorderWidths.DEFAULT : widths;
+        this.insets = insets == null ? Insets.EMPTY : insets;
+        this.slices = slices == null ? BorderWidths.DEFAULT : slices;
+        this.filled = filled;
+        this.repeatX = repeatX == null ? BorderRepeat.STRETCH : repeatX;
+        this.repeatY = repeatY == null ? this.repeatX : repeatY;
+    }
+
+    /// Returns the picture.
+    public final Image getImage() {
+        return image;
+    }
+
+    /// Returns how the top and bottom sides are filled.
+    public final BorderRepeat getRepeatX() {
+        return repeatX;
+    }
+
+    /// Returns how the left and right sides are filled.
+    public final BorderRepeat getRepeatY() {
+        return repeatY;
+    }
+
+    /// Returns the widths of the border the pieces are drawn into.
+    public final BorderWidths getWidths() {
+        return widths;
+    }
+
+    /// Returns the cuts into the picture, from each of its edges.
+    public final BorderWidths getSlices() {
+        return slices;
+    }
+
+    /// Returns whether the middle piece is drawn over the inside.
+    public final boolean isFilled() {
+        return filled;
+    }
+
+    /// Returns how far inside the region the border starts.
+    public final Insets getInsets() {
+        return insets;
+    }
+
+    /// The nine pieces once cut, row by row; an entry is `null` for a
+    /// piece of no size.
+    com.codename1.ui.Image[] pieces() {
+        return pieces;
+    }
+
+    /// Keeps the nine pieces, which are cut once.
+    void pieces(com.codename1.ui.Image[] cut) {
+        pieces = cut;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BorderImage)) {
+            return false;
+        }
+        BorderImage b = (BorderImage) o;
+        return image == b.image && repeatX == b.repeatX && repeatY == b.repeatY && widths.equals(b.widths)
+                && slices.equals(b.slices) && filled == b.filled && insets.equals(b.insets);
+    }
+
+    @Override
+    public int hashCode() {
+        return widths.hashCode() * 7 + slices.hashCode() * 3 + insets.hashCode() + (filled ? 1 : 0)
+                + repeatX.hashCode() + repeatY.hashCode();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderPane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderPane.java
new file mode 100644
index 00000000000..cf62e572627
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderPane.java
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.ObservableList;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Places up to five children: one along each edge and one in the middle.
+///
+/// The top and bottom children span the whole width and take their
+/// preferred height. The left and right children take their preferred
+/// width and the height between top and bottom. The center child gets
+/// what is left and is stretched to it, up to its maximum size. When the
+/// pane is too small the edges keep their size and the center gives way.
+///
+/// Setting one of the five properties adds the node to the children and
+/// removes the node it replaces. A node that does not fill its area is
+/// placed by its alignment constraint; without one the top and left sit
+/// top left, the bottom sits bottom left, the right top right and the
+/// center in the middle.
+public class BorderPane extends Pane {
+
+    private static final String MARGIN = "borderpane-margin";
+    private static final String ALIGNMENT = "borderpane-alignment";
+
+    private final ObjectProperty<Node> center = new Slot("center");
+    private final ObjectProperty<Node> top = new Slot("top");
+    private final ObjectProperty<Node> bottom = new Slot("bottom");
+    private final ObjectProperty<Node> left = new Slot("left");
+    private final ObjectProperty<Node> right = new Slot("right");
+
+    /// Creates an empty border pane.
+    public BorderPane() {
+    }
+
+    /// Creates a border pane with a center.
+    public BorderPane(Node center) {
+        this.center.set(center);
+    }
+
+    /// Creates a border pane with a node for each position; any of them
+    /// may be `null`.
+    public BorderPane(Node center, Node top, Node right, Node bottom, Node left) {
+        this.center.set(center);
+        this.top.set(top);
+        this.right.set(right);
+        this.bottom.set(bottom);
+        this.left.set(left);
+    }
+
+    /// One of the five positions: keeps the list of children in step.
+    private final class Slot extends SimpleObjectProperty<Node> {
+        private Node shown;
+
+        Slot(String name) {
+            super(BorderPane.this, name);
+        }
+
+        @Override
+        protected void invalidated() {
+            Node now = get();
+            if (now == shown) {
+                return;
+            }
+            ObservableList<Node> children = cn1Children();
+            Node before = shown;
+            shown = now;
+            if (before != null) {
+                children.remove(before);
+            }
+            if (now != null && !children.contains(now)) {
+                children.add(now);
+            }
+            requestLayout();
+        }
+    }
+
+    /// Sets where a child sits in its area of a border pane; `null`
+    /// removes the constraint.
+    public static void setAlignment(Node child, Pos value) {
+        setConstraint(child, ALIGNMENT, value);
+    }
+
+    /// Returns the alignment constraint of a child, or `null`.
+    public static Pos getAlignment(Node child) {
+        return LayoutSupport.pos(child, ALIGNMENT);
+    }
+
+    /// Sets the space kept free around a child in a border pane; `null`
+    /// removes the constraint.
+    public static void setMargin(Node child, Insets value) {
+        setConstraint(child, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node child) {
+        return LayoutSupport.insets(child, MARGIN);
+    }
+
+    /// Removes the border pane constraints from a child.
+    public static void clearConstraints(Node child) {
+        setAlignment(child, null);
+        setMargin(child, null);
+    }
+
+    /// Returns the node in the middle, or `null`.
+    public final Node getCenter() {
+        return center.get();
+    }
+
+    /// Sets the node in the middle.
+    public final void setCenter(Node value) {
+        center.set(value);
+    }
+
+    /// The node in the middle.
+    public final ObjectProperty<Node> centerProperty() {
+        return center;
+    }
+
+    /// Returns the node along the top edge, or `null`.
+    public final Node getTop() {
+        return top.get();
+    }
+
+    /// Sets the node along the top edge.
+    public final void setTop(Node value) {
+        top.set(value);
+    }
+
+    /// The node along the top edge.
+    public final ObjectProperty<Node> topProperty() {
+        return top;
+    }
+
+    /// Returns the node along the bottom edge, or `null`.
+    public final Node getBottom() {
+        return bottom.get();
+    }
+
+    /// Sets the node along the bottom edge.
+    public final void setBottom(Node value) {
+        bottom.set(value);
+    }
+
+    /// The node along the bottom edge.
+    public final ObjectProperty<Node> bottomProperty() {
+        return bottom;
+    }
+
+    /// Returns the node along the left edge, or `null`.
+    public final Node getLeft() {
+        return left.get();
+    }
+
+    /// Sets the node along the left edge.
+    public final void setLeft(Node value) {
+        left.set(value);
+    }
+
+    /// The node along the left edge.
+    public final ObjectProperty<Node> leftProperty() {
+        return left;
+    }
+
+    /// Returns the node along the right edge, or `null`.
+    public final Node getRight() {
+        return right.get();
+    }
+
+    /// Sets the node along the right edge.
+    public final void setRight(Node value) {
+        right.set(value);
+    }
+
+    /// The node along the right edge.
+    public final ObjectProperty<Node> rightProperty() {
+        return right;
+    }
+
+    /// A position's node when layout places it: managed and still a child.
+    private Node placed(ObjectProperty<Node> slot) {
+        Node n = slot.get();
+        return n != null && n.isManaged() && n.getParent() == this ? n : null;
+    }
+
+    private static boolean biased(Node n, Orientation bias) {
+        return n != null && n.getContentBias() == bias;
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        Node c = placed(center);
+        if (c != null && c.getContentBias() != null) {
+            return c.getContentBias();
+        }
+        if (biased(placed(right), Orientation.VERTICAL) || biased(placed(left), Orientation.VERTICAL)) {
+            return Orientation.VERTICAL;
+        }
+        if (biased(placed(bottom), Orientation.HORIZONTAL) || biased(placed(top), Orientation.HORIZONTAL)) {
+            return Orientation.HORIZONTAL;
+        }
+        return null;
+    }
+
+    private double areaWidth(Node child, double height, boolean minimum) {
+        if (child == null) {
+            return 0;
+        }
+        Insets m = getMargin(child);
+        return minimum ? computeChildMinAreaWidth(child, m, height) : computeChildPrefAreaWidth(child, m, height);
+    }
+
+    private double areaHeight(Node child, double width, boolean minimum) {
+        if (child == null) {
+            return 0;
+        }
+        Insets m = getMargin(child);
+        return minimum ? computeChildMinAreaHeight(child, m, width) : computeChildPrefAreaHeight(child, m, width);
+    }
+
+    private double contentWidth(double height, boolean minimum) {
+        Node t = placed(top);
+        Node b = placed(bottom);
+        Node l = placed(left);
+        Node r = placed(right);
+        Node c = placed(center);
+        double middle = -1;
+        if (height != -1 && (biased(l, Orientation.VERTICAL) || biased(r, Orientation.VERTICAL)
+                || biased(c, Orientation.VERTICAL))) {
+            Insets in = getInsets();
+            middle = Math.max(0, height - in.getTop() - in.getBottom() - areaHeight(t, -1, false)
+                    - areaHeight(b, -1, false));
+        }
+        double row = areaWidth(l, middle, minimum) + areaWidth(c, middle, minimum) + areaWidth(r, middle, minimum);
+        return Math.max(row, Math.max(areaWidth(t, -1, minimum), areaWidth(b, -1, minimum)));
+    }
+
+    private double contentHeight(double width, boolean minimum) {
+        Node t = placed(top);
+        Node b = placed(bottom);
+        Node l = placed(left);
+        Node r = placed(right);
+        Node c = placed(center);
+        double inside = -1;
+        double middle = -1;
+        if (width != -1) {
+            Insets in = getInsets();
+            inside = Math.max(0, width - in.getLeft() - in.getRight());
+            if (biased(c, Orientation.HORIZONTAL)) {
+                middle = Math.max(0, inside - areaWidth(l, -1, false) - areaWidth(r, -1, false));
+            }
+        }
+        double row = Math.max(areaHeight(c, middle, minimum),
+                Math.max(areaHeight(l, -1, minimum), areaHeight(r, -1, minimum)));
+        return areaHeight(t, inside, minimum) + row + areaHeight(b, inside, minimum);
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + contentWidth(height, true) + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + contentHeight(width, true) + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + contentWidth(height, false) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + contentHeight(width, false) + in.getBottom();
+    }
+
+    private static double horizontal(Insets m) {
+        return m == null ? 0 : m.getLeft() + m.getRight();
+    }
+
+    private static double vertical(Insets m) {
+        return m == null ? 0 : m.getTop() + m.getBottom();
+    }
+
+    /// Sizes an edge child to an area less its margin and answers the
+    /// size it took: a resizable child fills the area within its minimum
+    /// and maximum.
+    private double[] sizeEdge(Node child, double areaWidth, double areaHeight, Insets margin) {
+        double w = Math.max(0, areaWidth - horizontal(margin));
+        double h = Math.max(0, areaHeight - vertical(margin));
+        if (child.isResizable()) {
+            Orientation bias = child.getContentBias();
+            if (bias == Orientation.VERTICAL) {
+                h = boundedSize(child.minHeight(-1), h, child.maxHeight(-1));
+                w = boundedSize(child.minWidth(h), w, child.maxWidth(h));
+            } else if (bias == Orientation.HORIZONTAL) {
+                w = boundedSize(child.minWidth(-1), w, child.maxWidth(-1));
+                h = boundedSize(child.minHeight(w), h, child.maxHeight(w));
+            } else {
+                w = boundedSize(child.minWidth(-1), w, child.maxWidth(-1));
+                h = boundedSize(child.minHeight(-1), h, child.maxHeight(-1));
+            }
+            w = snapSizeX(w);
+            h = snapSizeY(h);
+            child.resize(w, h);
+        } else {
+            w = child.getLayoutBounds().getWidth();
+            h = child.getLayoutBounds().getHeight();
+        }
+        return new double[] {w, h};
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double width = Math.max(getWidth(), minWidth(-1));
+        double height = Math.max(getHeight(), minHeight(-1));
+        double insideX = in.getLeft();
+        double insideY = in.getTop();
+        double insideWidth = width - insideX - in.getRight();
+        double insideHeight = height - insideY - in.getBottom();
+        Node t = placed(top);
+        Node b = placed(bottom);
+        Node l = placed(left);
+        Node r = placed(right);
+        Node c = placed(center);
+
+        double topHeight = 0;
+        if (t != null) {
+            Insets m = getMargin(t);
+            double inner = Math.max(0, insideWidth - horizontal(m));
+            double wanted = Math.min(snapSizeY(t.prefHeight(inner)), Math.max(0, insideHeight - vertical(m)));
+            double[] size = sizeEdge(t, insideWidth, wanted + vertical(m), m);
+            topHeight = snapSizeY(size[1] + vertical(m));
+            Pos pos = getAlignment(t);
+            positionInMargin(t, insideX, insideY, insideWidth, topHeight, m, pos == null ? HPos.LEFT : pos.getHpos(),
+                    pos == null ? VPos.TOP : pos.getVpos());
+        }
+        double bottomHeight = 0;
+        if (b != null) {
+            Insets m = getMargin(b);
+            double inner = Math.max(0, insideWidth - horizontal(m));
+            double wanted = Math.min(snapSizeY(b.prefHeight(inner)),
+                    Math.max(0, insideHeight - topHeight - vertical(m)));
+            double[] size = sizeEdge(b, insideWidth, wanted + vertical(m), m);
+            bottomHeight = snapSizeY(size[1] + vertical(m));
+            Pos pos = getAlignment(b);
+            positionInMargin(b, insideX, insideY + insideHeight - bottomHeight, insideWidth, bottomHeight, m,
+                    pos == null ? HPos.LEFT : pos.getHpos(), pos == null ? VPos.BOTTOM : pos.getVpos());
+        }
+        double middleHeight = Math.max(0, insideHeight - topHeight - bottomHeight);
+        double leftWidth = 0;
+        if (l != null) {
+            Insets m = getMargin(l);
+            double inner = Math.max(0, middleHeight - vertical(m));
+            double wanted = Math.min(snapSizeX(l.prefWidth(inner)), Math.max(0, insideWidth - horizontal(m)));
+            double[] size = sizeEdge(l, wanted + horizontal(m), middleHeight, m);
+            leftWidth = snapSizeX(size[0] + horizontal(m));
+            Pos pos = getAlignment(l);
+            positionInMargin(l, insideX, insideY + topHeight, leftWidth, middleHeight, m,
+                    pos == null ? HPos.LEFT : pos.getHpos(), pos == null ? VPos.TOP : pos.getVpos());
+        }
+        double rightWidth = 0;
+        if (r != null) {
+            Insets m = getMargin(r);
+            double inner = Math.max(0, middleHeight - vertical(m));
+            double wanted = Math.min(snapSizeX(r.prefWidth(inner)),
+                    Math.max(0, insideWidth - leftWidth - horizontal(m)));
+            double[] size = sizeEdge(r, wanted + horizontal(m), middleHeight, m);
+            rightWidth = snapSizeX(size[0] + horizontal(m));
+            Pos pos = getAlignment(r);
+            positionInMargin(r, insideX + insideWidth - rightWidth, insideY + topHeight, rightWidth, middleHeight, m,
+                    pos == null ? HPos.RIGHT : pos.getHpos(), pos == null ? VPos.TOP : pos.getVpos());
+        }
+        if (c != null) {
+            Pos pos = getAlignment(c);
+            layoutInArea(c, insideX + leftWidth, insideY + topHeight,
+                    Math.max(0, insideWidth - leftWidth - rightWidth), middleHeight, 0, getMargin(c),
+                    pos == null ? HPos.CENTER : pos.getHpos(), pos == null ? VPos.CENTER : pos.getVpos());
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderRepeat.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderRepeat.java
new file mode 100644
index 00000000000..87630bbd92f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderRepeat.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+/// How a slice of a border image fills its side of the border.
+public enum BorderRepeat {
+    /// One copy, stretched over the side.
+    STRETCH,
+    /// Copies side by side from the middle, cut off at the corners.
+    REPEAT,
+    /// Copies resized so that a whole number of them fits exactly.
+    ROUND,
+    /// As many whole copies as fit, spread out evenly.
+    SPACE
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderStroke.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderStroke.java
new file mode 100644
index 00000000000..f181af7559a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderStroke.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+import javafx.geometry.Insets;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+
+/// One line around a region: its paint, style, corner radii and widths,
+/// and how far it is inset from the edges.
+///
+/// A stroke whose four sides share a paint, a style and a width is drawn
+/// as one rounded outline. One whose sides differ is drawn side by side as
+/// straight lines, without the corner radii.
+public class BorderStroke {
+
+    /// A thin border, one logical pixel.
+    public static final BorderWidths THIN = new BorderWidths(1);
+
+    /// A medium border, three logical pixels.
+    public static final BorderWidths MEDIUM = new BorderWidths(3);
+
+    /// A thick border, five logical pixels.
+    public static final BorderWidths THICK = new BorderWidths(5);
+
+    /// The widths used when none are given.
+    public static final BorderWidths DEFAULT_WIDTHS = THIN;
+
+    private final Paint topStroke;
+    private final Paint rightStroke;
+    private final Paint bottomStroke;
+    private final Paint leftStroke;
+    private final BorderStrokeStyle topStyle;
+    private final BorderStrokeStyle rightStyle;
+    private final BorderStrokeStyle bottomStyle;
+    private final BorderStrokeStyle leftStyle;
+    private final BorderWidths widths;
+    private final Insets insets;
+    private final CornerRadii radii;
+
+    /// Creates a stroke that is the same on every side.
+    public BorderStroke(@NamedArg("stroke") Paint stroke, @NamedArg("style") BorderStrokeStyle style,
+            @NamedArg("radii") CornerRadii radii, @NamedArg("widths") BorderWidths widths) {
+        this(stroke, stroke, stroke, stroke, style, style, style, style, radii, widths, null);
+    }
+
+    /// Creates a stroke that is the same on every side and inset from the
+    /// edges.
+    public BorderStroke(@NamedArg("stroke") Paint stroke, @NamedArg("style") BorderStrokeStyle style,
+            @NamedArg("radii") CornerRadii radii, @NamedArg("widths") BorderWidths widths,
+            @NamedArg("insets") Insets insets) {
+        this(stroke, stroke, stroke, stroke, style, style, style, style, radii, widths, insets);
+    }
+
+    /// Creates a stroke with a paint and a style per side.
+    public BorderStroke(@NamedArg("topStroke") Paint topStroke, @NamedArg("rightStroke") Paint rightStroke,
+            @NamedArg("bottomStroke") Paint bottomStroke, @NamedArg("leftStroke") Paint leftStroke,
+            @NamedArg("topStyle") BorderStrokeStyle topStyle, @NamedArg("rightStyle") BorderStrokeStyle rightStyle,
+            @NamedArg("bottomStyle") BorderStrokeStyle bottomStyle,
+            @NamedArg("leftStyle") BorderStrokeStyle leftStyle, @NamedArg("radii") CornerRadii radii,
+            @NamedArg("widths") BorderWidths widths, @NamedArg("insets") Insets insets) {
+        this.topStroke = topStroke == null ? Color.BLACK : topStroke;
+        this.rightStroke = rightStroke == null ? this.topStroke : rightStroke;
+        this.bottomStroke = bottomStroke == null ? this.topStroke : bottomStroke;
+        this.leftStroke = leftStroke == null ? this.rightStroke : leftStroke;
+        this.topStyle = topStyle == null ? BorderStrokeStyle.NONE : topStyle;
+        this.rightStyle = rightStyle == null ? this.topStyle : rightStyle;
+        this.bottomStyle = bottomStyle == null ? this.topStyle : bottomStyle;
+        this.leftStyle = leftStyle == null ? this.rightStyle : leftStyle;
+        this.radii = radii == null ? CornerRadii.EMPTY : radii;
+        this.widths = widths == null ? DEFAULT_WIDTHS : widths;
+        this.insets = insets == null ? Insets.EMPTY : insets;
+    }
+
+    /// Returns the paint of the top side.
+    public final Paint getTopStroke() {
+        return topStroke;
+    }
+
+    /// Returns the paint of the right side.
+    public final Paint getRightStroke() {
+        return rightStroke;
+    }
+
+    /// Returns the paint of the bottom side.
+    public final Paint getBottomStroke() {
+        return bottomStroke;
+    }
+
+    /// Returns the paint of the left side.
+    public final Paint getLeftStroke() {
+        return leftStroke;
+    }
+
+    /// Returns the style of the top side.
+    public final BorderStrokeStyle getTopStyle() {
+        return topStyle;
+    }
+
+    /// Returns the style of the right side.
+    public final BorderStrokeStyle getRightStyle() {
+        return rightStyle;
+    }
+
+    /// Returns the style of the bottom side.
+    public final BorderStrokeStyle getBottomStyle() {
+        return bottomStyle;
+    }
+
+    /// Returns the style of the left side.
+    public final BorderStrokeStyle getLeftStyle() {
+        return leftStyle;
+    }
+
+    /// Returns the widths of the sides.
+    public final BorderWidths getWidths() {
+        return widths;
+    }
+
+    /// Returns the insets from the edges of the region.
+    public final Insets getInsets() {
+        return insets;
+    }
+
+    /// Returns the corner radii.
+    public final CornerRadii getRadii() {
+        return radii;
+    }
+
+    /// Returns whether all four sides have the same paint and style.
+    public final boolean isStrokeUniform() {
+        return topStroke.equals(rightStroke) && topStroke.equals(bottomStroke) && topStroke.equals(leftStroke)
+                && topStyle.equals(rightStyle) && topStyle.equals(bottomStyle) && topStyle.equals(leftStyle);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BorderStroke)) {
+            return false;
+        }
+        BorderStroke that = (BorderStroke) o;
+        return topStroke.equals(that.topStroke) && rightStroke.equals(that.rightStroke)
+                && bottomStroke.equals(that.bottomStroke) && leftStroke.equals(that.leftStroke)
+                && topStyle.equals(that.topStyle) && rightStyle.equals(that.rightStyle)
+                && bottomStyle.equals(that.bottomStyle) && leftStyle.equals(that.leftStyle)
+                && widths.equals(that.widths) && radii.equals(that.radii) && insets.equals(that.insets);
+    }
+
+    @Override
+    public int hashCode() {
+        return (((topStroke.hashCode() * 31 + topStyle.hashCode()) * 31 + widths.hashCode()) * 31
+                + radii.hashCode()) * 31 + insets.hashCode();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderStrokeStyle.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderStrokeStyle.java
new file mode 100644
index 00000000000..d7d63d4ae8a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderStrokeStyle.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.beans.NamedArg;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.shape.StrokeType;
+
+/// How the line of a border is drawn: solid, dashed, dotted or not at
+/// all, and how its corners and ends are finished.
+public final class BorderStrokeStyle {
+
+    /// No line.
+    public static final BorderStrokeStyle NONE = new BorderStrokeStyle(StrokeType.INSIDE, StrokeLineJoin.MITER,
+            StrokeLineCap.BUTT, 0, 0, null);
+
+    /// A line of round dots.
+    public static final BorderStrokeStyle DOTTED = new BorderStrokeStyle(StrokeType.INSIDE, StrokeLineJoin.MITER,
+            StrokeLineCap.ROUND, 10, 0, list(0, 2));
+
+    /// A line of dashes.
+    public static final BorderStrokeStyle DASHED = new BorderStrokeStyle(StrokeType.INSIDE, StrokeLineJoin.MITER,
+            StrokeLineCap.BUTT, 10, 0, list(2, 1.4));
+
+    /// An unbroken line.
+    public static final BorderStrokeStyle SOLID = new BorderStrokeStyle(StrokeType.INSIDE, StrokeLineJoin.MITER,
+            StrokeLineCap.BUTT, 10, 0, null);
+
+    private final StrokeType type;
+    private final StrokeLineJoin lineJoin;
+    private final StrokeLineCap lineCap;
+    private final double miterLimit;
+    private final double dashOffset;
+    private final List<Double> dashArray;
+
+    /// Creates a style. The dash lengths are in multiples of the stroke
+    /// width for the predefined styles and in logical pixels otherwise.
+    public BorderStrokeStyle(@NamedArg("type") StrokeType type, @NamedArg("lineJoin") StrokeLineJoin lineJoin,
+            @NamedArg("lineCap") StrokeLineCap lineCap, @NamedArg("miterLimit") double miterLimit,
+            @NamedArg("dashOffset") double dashOffset, @NamedArg("dashArray") List<Double> dashArray) {
+        this.type = type != null ? type : StrokeType.CENTERED;
+        this.lineJoin = lineJoin != null ? lineJoin : StrokeLineJoin.MITER;
+        this.lineCap = lineCap != null ? lineCap : StrokeLineCap.BUTT;
+        this.miterLimit = miterLimit;
+        this.dashOffset = dashOffset;
+        if (dashArray == null) {
+            this.dashArray = Collections.<Double>emptyList();
+        } else {
+            this.dashArray = Collections.unmodifiableList(new ArrayList<Double>(dashArray));
+        }
+    }
+
+    private static List<Double> list(double a, double b) {
+        ArrayList<Double> l = new ArrayList<Double>();
+        l.add(Double.valueOf(a));
+        l.add(Double.valueOf(b));
+        return l;
+    }
+
+    /// Returns where the line lies relative to the edge.
+    public final StrokeType getType() {
+        return type;
+    }
+
+    /// Returns how corners are joined.
+    public final StrokeLineJoin getLineJoin() {
+        return lineJoin;
+    }
+
+    /// Returns how dash ends are finished.
+    public final StrokeLineCap getLineCap() {
+        return lineCap;
+    }
+
+    /// Returns the limit beyond which a mitred corner is cut off.
+    public final double getMiterLimit() {
+        return miterLimit;
+    }
+
+    /// Returns where in the dash pattern the line starts.
+    public final double getDashOffset() {
+        return dashOffset;
+    }
+
+    /// Returns the lengths of dashes and gaps; empty for a solid line.
+    public final List<Double> getDashArray() {
+        return dashArray;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BorderStrokeStyle)) {
+            return false;
+        }
+        BorderStrokeStyle that = (BorderStrokeStyle) o;
+        if ((this == NONE) != (that == NONE)) {
+            return false;
+        }
+        return type == that.type && lineJoin == that.lineJoin && lineCap == that.lineCap
+                && Double.compare(miterLimit, that.miterLimit) == 0
+                && Double.compare(dashOffset, that.dashOffset) == 0 && dashArray.equals(that.dashArray);
+    }
+
+    @Override
+    public int hashCode() {
+        return ((type.hashCode() * 31 + lineJoin.hashCode()) * 31 + lineCap.hashCode()) * 31 + dashArray.hashCode()
+                + (this == NONE ? 0 : 1);
+    }
+
+    @Override
+    public String toString() {
+        if (this == NONE) {
+            return "BorderStyle.NONE";
+        } else if (this == DASHED) {
+            return "BorderStyle.DASHED";
+        } else if (this == DOTTED) {
+            return "BorderStyle.DOTTED";
+        } else if (this == SOLID) {
+            return "BorderStyle.SOLID";
+        }
+        return "BorderStyle [" + type + ", " + lineJoin + ", " + lineCap + ", " + miterLimit + ", " + dashOffset
+                + ", " + dashArray + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderWidths.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderWidths.java
new file mode 100644
index 00000000000..0aaead5c72c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/BorderWidths.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+
+/// The widths of the four sides of a border, in logical pixels.
+public final class BorderWidths {
+
+    /// The width that stands for "take it from the stroke"; treated as 1.
+    public static final double AUTO = -1;
+
+    /// One logical pixel on every side.
+    public static final BorderWidths DEFAULT = new BorderWidths(1, 1, 1, 1);
+
+    /// No width on any side.
+    public static final BorderWidths EMPTY = new BorderWidths(0, 0, 0, 0);
+
+    private final double top;
+    private final double right;
+    private final double bottom;
+    private final double left;
+    private final boolean topAsPercentage;
+    private final boolean rightAsPercentage;
+    private final boolean bottomAsPercentage;
+    private final boolean leftAsPercentage;
+
+    /// Creates the same width on every side.
+    public BorderWidths(@NamedArg("width") double width) {
+        this(width, width, width, width);
+    }
+
+    /// Creates a width per side.
+    public BorderWidths(@NamedArg("top") double top, @NamedArg("right") double right,
+            @NamedArg("bottom") double bottom, @NamedArg("left") double left) {
+        this(top, right, bottom, left, false, false, false, false);
+    }
+
+    /// Creates a width per side, each a length or a share written 0 to 1
+    /// of the side it is measured against.
+    public BorderWidths(@NamedArg("top") double top, @NamedArg("right") double right,
+            @NamedArg("bottom") double bottom, @NamedArg("left") double left,
+            @NamedArg("topAsPercentage") boolean topAsPercentage,
+            @NamedArg("rightAsPercentage") boolean rightAsPercentage,
+            @NamedArg("bottomAsPercentage") boolean bottomAsPercentage,
+            @NamedArg("leftAsPercentage") boolean leftAsPercentage) {
+        if ((top < 0 && top != AUTO) || (right < 0 && right != AUTO) || (bottom < 0 && bottom != AUTO)
+                || (left < 0 && left != AUTO)) {
+            throw new IllegalArgumentException("None of the widths can be < 0");
+        }
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.left = left;
+        this.topAsPercentage = topAsPercentage;
+        this.rightAsPercentage = rightAsPercentage;
+        this.bottomAsPercentage = bottomAsPercentage;
+        this.leftAsPercentage = leftAsPercentage;
+    }
+
+    /// Returns whether the top width is a share, 0 to 1.
+    public final boolean isTopAsPercentage() {
+        return topAsPercentage;
+    }
+
+    /// Returns whether the right width is a share, 0 to 1.
+    public final boolean isRightAsPercentage() {
+        return rightAsPercentage;
+    }
+
+    /// Returns whether the bottom width is a share, 0 to 1.
+    public final boolean isBottomAsPercentage() {
+        return bottomAsPercentage;
+    }
+
+    /// Returns whether the left width is a share, 0 to 1.
+    public final boolean isLeftAsPercentage() {
+        return leftAsPercentage;
+    }
+
+    /// Returns the width of the top side.
+    public final double getTop() {
+        return top;
+    }
+
+    /// Returns the width of the right side.
+    public final double getRight() {
+        return right;
+    }
+
+    /// Returns the width of the bottom side.
+    public final double getBottom() {
+        return bottom;
+    }
+
+    /// Returns the width of the left side.
+    public final double getLeft() {
+        return left;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof BorderWidths)) {
+            return false;
+        }
+        BorderWidths that = (BorderWidths) o;
+        return Double.compare(top, that.top) == 0 && Double.compare(right, that.right) == 0
+                && Double.compare(bottom, that.bottom) == 0 && Double.compare(left, that.left) == 0
+                && topAsPercentage == that.topAsPercentage && rightAsPercentage == that.rightAsPercentage
+                && bottomAsPercentage == that.bottomAsPercentage && leftAsPercentage == that.leftAsPercentage;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(top) * 31 + Double.doubleToLongBits(right) * 17
+                + Double.doubleToLongBits(bottom) * 7 + Double.doubleToLongBits(left);
+        return (int) (bits ^ (bits >>> 32));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/ColumnConstraints.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/ColumnConstraints.java
new file mode 100644
index 00000000000..f566bcd9c0b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/ColumnConstraints.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.HPos;
+
+/// How a `GridPane` sizes one column and places the children in it. The
+/// constraint at index `n` of the pane's list applies to column `n`.
+///
+/// A size left at `Region.USE_COMPUTED_SIZE` is computed from the
+/// children of the column. A `percentWidth` of zero or more makes the
+/// column that share of the pane's width less the gaps, whatever the
+/// sizes say. A `hgrow` or `halignment` left `null` falls back to what the
+/// children ask for.
+public class ColumnConstraints extends ConstraintsBase {
+
+    private final DoubleProperty min = new Num(this, "minWidth", Region.USE_COMPUTED_SIZE);
+    private final DoubleProperty pref = new Num(this, "prefWidth", Region.USE_COMPUTED_SIZE);
+    private final DoubleProperty max = new Num(this, "maxWidth", Region.USE_COMPUTED_SIZE);
+    private final DoubleProperty percent = new Num(this, "percentWidth", -1);
+    private final ObjectProperty<Priority> grow = new Ref<Priority>(this, "hgrow");
+    private final ObjectProperty<HPos> align = new Ref<HPos>(this, "halignment");
+    private final BooleanProperty fill = new Flag(this, "fillWidth", true);
+
+    /// Creates a constraint that computes everything from the children.
+    public ColumnConstraints() {
+    }
+
+    /// Creates a column of a fixed width.
+    public ColumnConstraints(double width) {
+        min.set(Region.USE_PREF_SIZE);
+        pref.set(width);
+        max.set(Region.USE_PREF_SIZE);
+    }
+
+    /// Creates a column with a range of sizes.
+    public ColumnConstraints(double minWidth, double prefWidth, double maxWidth) {
+        min.set(minWidth);
+        pref.set(prefWidth);
+        max.set(maxWidth);
+    }
+
+    /// Creates a column with a range of sizes, a grow priority, an
+    /// alignment for its children and whether it stretches them.
+    public ColumnConstraints(double minWidth, double prefWidth, double maxWidth, Priority hgrow, HPos halignment,
+            boolean fillWidth) {
+        min.set(minWidth);
+        pref.set(prefWidth);
+        max.set(maxWidth);
+        grow.set(hgrow);
+        align.set(halignment);
+        fill.set(fillWidth);
+    }
+
+    /// Returns the minimum width, `Region.USE_COMPUTED_SIZE` or
+    /// `Region.USE_PREF_SIZE`.
+    public final double getMinWidth() {
+        return min.get();
+    }
+
+    /// Sets the minimum width.
+    public final void setMinWidth(double value) {
+        min.set(value);
+    }
+
+    /// The minimum width of the column.
+    public final DoubleProperty minWidthProperty() {
+        return min;
+    }
+
+    /// Returns the preferred width, or `Region.USE_COMPUTED_SIZE`.
+    public final double getPrefWidth() {
+        return pref.get();
+    }
+
+    /// Sets the preferred width.
+    public final void setPrefWidth(double value) {
+        pref.set(value);
+    }
+
+    /// The preferred width of the column.
+    public final DoubleProperty prefWidthProperty() {
+        return pref;
+    }
+
+    /// Returns the maximum width, `Region.USE_COMPUTED_SIZE` or
+    /// `Region.USE_PREF_SIZE`.
+    public final double getMaxWidth() {
+        return max.get();
+    }
+
+    /// Sets the maximum width.
+    public final void setMaxWidth(double value) {
+        max.set(value);
+    }
+
+    /// The maximum width of the column.
+    public final DoubleProperty maxWidthProperty() {
+        return max;
+    }
+
+    /// Returns the share of the pane in percent, or a negative number.
+    public final double getPercentWidth() {
+        return percent.get();
+    }
+
+    /// Sets the share of the pane this column takes, in percent; a negative
+    /// number turns it off.
+    public final void setPercentWidth(double value) {
+        percent.set(value);
+    }
+
+    /// The share of the pane this column takes, in percent.
+    public final DoubleProperty percentWidthProperty() {
+        return percent;
+    }
+
+    /// Returns how eagerly the column takes spare space, or `null`.
+    public final Priority getHgrow() {
+        return grow.get();
+    }
+
+    /// Sets how eagerly the column takes spare space.
+    public final void setHgrow(Priority value) {
+        grow.set(value);
+    }
+
+    /// How eagerly the column takes spare space.
+    public final ObjectProperty<Priority> hgrowProperty() {
+        return grow;
+    }
+
+    /// Returns where the children sit in the column, or `null`.
+    public final HPos getHalignment() {
+        return align.get();
+    }
+
+    /// Sets where the children sit in the column.
+    public final void setHalignment(HPos value) {
+        align.set(value);
+    }
+
+    /// Where the children sit in the column.
+    public final ObjectProperty<HPos> halignmentProperty() {
+        return align;
+    }
+
+    /// Returns whether resizable children are stretched to the width of
+    /// the column.
+    public final boolean isFillWidth() {
+        return fill.get();
+    }
+
+    /// Sets whether resizable children are stretched to the width of the
+    /// column.
+    public final void setFillWidth(boolean value) {
+        fill.set(value);
+    }
+
+    /// Whether resizable children are stretched to the width of the column.
+    public final BooleanProperty fillWidthProperty() {
+        return fill;
+    }
+
+    @Override
+    double minSize() {
+        return min.get();
+    }
+
+    @Override
+    double prefSize() {
+        return pref.get();
+    }
+
+    @Override
+    double maxSize() {
+        return max.get();
+    }
+
+    @Override
+    double percent() {
+        return percent.get();
+    }
+
+    @Override
+    Priority grow() {
+        return grow.get();
+    }
+
+    @Override
+    boolean fill() {
+        return fill.get();
+    }
+
+    /// Returns a description for debugging.
+    @Override
+    public String toString() {
+        return "ColumnConstraints percentWidth=" + getPercentWidth() + " minWidth=" + getMinWidth() + " prefWidth="
+                + getPrefWidth() + " maxWidth=" + getMaxWidth() + " hgrow=" + getHgrow() + " fillWidth="
+                + isFillWidth() + " halignment=" + getHalignment();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/ConstraintsBase.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/ConstraintsBase.java
new file mode 100644
index 00000000000..08a64e34e53
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/ConstraintsBase.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.ArrayList;
+
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Parent;
+
+/// The base of the constraints a `GridPane` keeps for a row or a column.
+/// A change to a constraint asks every pane that uses it for layout.
+public abstract class ConstraintsBase {
+
+    /// For a minimum or maximum: the same as the preferred size.
+    public static final double CONSTRAIN_TO_PREF = Double.NEGATIVE_INFINITY;
+
+    private final ArrayList<Parent> users = new ArrayList<Parent>();
+
+    ConstraintsBase() {
+    }
+
+    /// Asks the panes that use this constraint for layout.
+    protected void requestLayout() {
+        for (int i = 0; i < users.size(); i++) {
+            users.get(i).requestLayout();
+        }
+    }
+
+    void add(Parent pane) {
+        users.add(pane);
+    }
+
+    void remove(Parent pane) {
+        users.remove(pane);
+    }
+
+    /// The minimum size set, or `Region.USE_COMPUTED_SIZE`.
+    abstract double minSize();
+
+    /// The preferred size set, or `Region.USE_COMPUTED_SIZE`.
+    abstract double prefSize();
+
+    /// The maximum size set, or `Region.USE_COMPUTED_SIZE`.
+    abstract double maxSize();
+
+    /// The share of the pane in percent, or a negative number.
+    abstract double percent();
+
+    /// The grow priority set, or `null`.
+    abstract Priority grow();
+
+    /// Whether children are stretched across the row or column.
+    abstract boolean fill();
+
+    /// A number whose change asks for layout.
+    static final class Num extends SimpleDoubleProperty {
+        private final ConstraintsBase owner;
+
+        Num(ConstraintsBase owner, String name, double initial) {
+            super(owner, name, initial);
+            this.owner = owner;
+        }
+
+        @Override
+        protected void invalidated() {
+            owner.requestLayout();
+        }
+    }
+
+    /// A flag whose change asks for layout.
+    static final class Flag extends SimpleBooleanProperty {
+        private final ConstraintsBase owner;
+
+        Flag(ConstraintsBase owner, String name, boolean initial) {
+            super(owner, name, initial);
+            this.owner = owner;
+        }
+
+        @Override
+        protected void invalidated() {
+            owner.requestLayout();
+        }
+    }
+
+    /// A value whose change asks for layout.
+    static final class Ref<T> extends SimpleObjectProperty<T> {
+        private final ConstraintsBase owner;
+
+        Ref(ConstraintsBase owner, String name) {
+            super(owner, name);
+            this.owner = owner;
+        }
+
+        @Override
+        protected void invalidated() {
+            owner.requestLayout();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/CornerRadii.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/CornerRadii.java
new file mode 100644
index 00000000000..9d840e56418
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/CornerRadii.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.NamedArg;
+
+/// The radii of the four corners of a rounded rectangle, in logical pixels
+/// or as a fraction of the rectangle's size.
+public class CornerRadii {
+
+    /// Square corners.
+    public static final CornerRadii EMPTY = new CornerRadii(0);
+
+    private final double topLeft;
+    private final double topRight;
+    private final double bottomRight;
+    private final double bottomLeft;
+    private final boolean percent;
+
+    /// Creates the same radius on every corner.
+    public CornerRadii(@NamedArg("radius") double radius) {
+        this(radius, radius, radius, radius, false);
+    }
+
+    /// Creates the same radius on every corner, optionally as a fraction
+    /// of the size.
+    public CornerRadii(@NamedArg("radius") double radius, @NamedArg("asPercent") boolean asPercent) {
+        this(radius, radius, radius, radius, asPercent);
+    }
+
+    /// Creates a radius per corner, clockwise from the top left.
+    public CornerRadii(@NamedArg("topLeft") double topLeft, @NamedArg("topRight") double topRight,
+            @NamedArg("bottomRight") double bottomRight, @NamedArg("bottomLeft") double bottomLeft,
+            @NamedArg("asPercent") boolean asPercent) {
+        if (topLeft < 0 || topRight < 0 || bottomRight < 0 || bottomLeft < 0) {
+            throw new IllegalArgumentException("No radii value may be < 0");
+        }
+        this.topLeft = topLeft;
+        this.topRight = topRight;
+        this.bottomRight = bottomRight;
+        this.bottomLeft = bottomLeft;
+        this.percent = asPercent;
+    }
+
+    /// Returns the horizontal radius of the top left corner.
+    public final double getTopLeftHorizontalRadius() {
+        return topLeft;
+    }
+
+    /// Returns the vertical radius of the top left corner.
+    public final double getTopLeftVerticalRadius() {
+        return topLeft;
+    }
+
+    /// Returns the vertical radius of the top right corner.
+    public final double getTopRightVerticalRadius() {
+        return topRight;
+    }
+
+    /// Returns the horizontal radius of the top right corner.
+    public final double getTopRightHorizontalRadius() {
+        return topRight;
+    }
+
+    /// Returns the horizontal radius of the bottom right corner.
+    public final double getBottomRightHorizontalRadius() {
+        return bottomRight;
+    }
+
+    /// Returns the vertical radius of the bottom right corner.
+    public final double getBottomRightVerticalRadius() {
+        return bottomRight;
+    }
+
+    /// Returns the vertical radius of the bottom left corner.
+    public final double getBottomLeftVerticalRadius() {
+        return bottomLeft;
+    }
+
+    /// Returns the horizontal radius of the bottom left corner.
+    public final double getBottomLeftHorizontalRadius() {
+        return bottomLeft;
+    }
+
+    /// Returns whether the top left radius is a fraction of the size.
+    public final boolean isTopLeftHorizontalRadiusAsPercentage() {
+        return percent;
+    }
+
+    /// Returns whether the top right radius is a fraction of the size.
+    public final boolean isTopRightHorizontalRadiusAsPercentage() {
+        return percent;
+    }
+
+    /// Returns whether the bottom right radius is a fraction of the size.
+    public final boolean isBottomRightHorizontalRadiusAsPercentage() {
+        return percent;
+    }
+
+    /// Returns whether the bottom left radius is a fraction of the size.
+    public final boolean isBottomLeftHorizontalRadiusAsPercentage() {
+        return percent;
+    }
+
+    /// Returns whether every corner has the same radius.
+    public final boolean isUniform() {
+        return topLeft == topRight && topLeft == bottomRight && topLeft == bottomLeft;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof CornerRadii)) {
+            return false;
+        }
+        CornerRadii that = (CornerRadii) o;
+        return Double.compare(topLeft, that.topLeft) == 0 && Double.compare(topRight, that.topRight) == 0
+                && Double.compare(bottomRight, that.bottomRight) == 0
+                && Double.compare(bottomLeft, that.bottomLeft) == 0 && percent == that.percent;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(topLeft) * 31 + Double.doubleToLongBits(topRight) * 17
+                + Double.doubleToLongBits(bottomRight) * 7 + Double.doubleToLongBits(bottomLeft);
+        return (int) (bits ^ (bits >>> 32)) + (percent ? 1 : 0);
+    }
+
+    @Override
+    public String toString() {
+        return "CornerRadii [" + topLeft + ", " + topRight + ", " + bottomRight + ", " + bottomLeft
+                + (percent ? " %" : "") + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/FlowPane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/FlowPane.java
new file mode 100644
index 00000000000..ebd08c332df
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/FlowPane.java
@@ -0,0 +1,473 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Lays its managed children out one after the other and starts a new
+/// row, or a new column, when the next child does not fit.
+///
+/// A horizontal flow pane fills rows from left to right and wraps at its
+/// own width; a vertical one fills columns from top to bottom and wraps
+/// at its height. Every child takes its preferred size along the flow. A
+/// row is as tall as its tallest child (a column as wide as its widest),
+/// and a resizable child is stretched to that, up to its maximum size;
+/// `rowValignment` and `columnHalignment` place the children that do not
+/// fill it. `alignment` places the rows and columns in the pane.
+///
+/// The preferred size along the flow is `prefWrapLength`, or the longest
+/// child when that is longer; the preferred size across it is what the
+/// content needs when wrapped at the size given, or at `prefWrapLength`
+/// when none is given.
+///
+/// #### Styling
+///
+/// Besides the names of a region: `-fx-hgap`, `-fx-vgap` (`Number`),
+/// `-fx-alignment` (`javafx.geometry.Pos` or its CSS spelling as a
+/// `String`) and `-fx-orientation` (`javafx.geometry.Orientation` or its
+/// name as a `String`); strings are matched without regard to ASCII case.
+public class FlowPane extends Pane {
+
+    private static final String MARGIN = "flowpane-margin";
+
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, Dirty.LAYOUT);
+    private final DoubleProperty hgap = new FxDouble(this, "hgap", 0, Dirty.LAYOUT);
+    private final DoubleProperty vgap = new FxDouble(this, "vgap", 0, Dirty.LAYOUT);
+    private final DoubleProperty prefWrapLength = new FxDouble(this, "prefWrapLength", 400, Dirty.LAYOUT);
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.TOP_LEFT, Dirty.LAYOUT);
+    private final ObjectProperty<HPos> columnHalignment = new FxObject<HPos>(this, "columnHalignment", HPos.LEFT,
+            Dirty.LAYOUT);
+    private final ObjectProperty<VPos> rowValignment = new FxObject<VPos>(this, "rowValignment", VPos.CENTER,
+            Dirty.LAYOUT);
+
+    /// Creates an empty horizontal flow pane without gaps.
+    public FlowPane() {
+    }
+
+    /// Creates an empty flow pane without gaps.
+    public FlowPane(Orientation orientation) {
+        this.orientation.set(orientation);
+    }
+
+    /// Creates an empty horizontal flow pane with gaps.
+    public FlowPane(double hgap, double vgap) {
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+    }
+
+    /// Creates an empty flow pane with gaps.
+    public FlowPane(Orientation orientation, double hgap, double vgap) {
+        this.orientation.set(orientation);
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+    }
+
+    /// Creates a horizontal flow pane with children.
+    public FlowPane(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a flow pane with children.
+    public FlowPane(Orientation orientation, Node... children) {
+        this.orientation.set(orientation);
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a horizontal flow pane with gaps and children.
+    public FlowPane(double hgap, double vgap, Node... children) {
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a flow pane with gaps and children.
+    public FlowPane(Orientation orientation, double hgap, double vgap, Node... children) {
+        this.orientation.set(orientation);
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+        cn1Children().addAll(children);
+    }
+
+    /// Sets the space kept free around a child in a flow pane; `null`
+    /// removes the constraint.
+    public static void setMargin(Node child, Insets value) {
+        setConstraint(child, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node child) {
+        return LayoutSupport.insets(child, MARGIN);
+    }
+
+    /// Removes the flow pane constraints from a child.
+    public static void clearConstraints(Node child) {
+        setMargin(child, null);
+    }
+
+    /// Returns the direction of the flow.
+    public final Orientation getOrientation() {
+        Orientation o = orientation.get();
+        return o == null ? Orientation.HORIZONTAL : o;
+    }
+
+    /// Sets the direction of the flow.
+    public final void setOrientation(Orientation value) {
+        orientation.set(value);
+    }
+
+    /// The direction of the flow.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+
+    /// Returns the horizontal gap between children or columns.
+    public final double getHgap() {
+        return hgap.get();
+    }
+
+    /// Sets the horizontal gap between children or columns.
+    public final void setHgap(double value) {
+        hgap.set(value);
+    }
+
+    /// The horizontal gap between children or columns.
+    public final DoubleProperty hgapProperty() {
+        return hgap;
+    }
+
+    /// Returns the vertical gap between children or rows.
+    public final double getVgap() {
+        return vgap.get();
+    }
+
+    /// Sets the vertical gap between children or rows.
+    public final void setVgap(double value) {
+        vgap.set(value);
+    }
+
+    /// The vertical gap between children or rows.
+    public final DoubleProperty vgapProperty() {
+        return vgap;
+    }
+
+    /// Returns the length at which the content wraps when the preferred
+    /// size is computed.
+    public final double getPrefWrapLength() {
+        return prefWrapLength.get();
+    }
+
+    /// Sets the length at which the content wraps when the preferred size
+    /// is computed.
+    public final void setPrefWrapLength(double value) {
+        prefWrapLength.set(value);
+    }
+
+    /// The length at which the content wraps when the preferred size is
+    /// computed.
+    public final DoubleProperty prefWrapLengthProperty() {
+        return prefWrapLength;
+    }
+
+    /// Returns where the rows or columns sit in the pane.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the rows or columns sit in the pane.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the rows or columns sit in the pane.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Returns where a child sits across its column in a vertical flow.
+    public final HPos getColumnHalignment() {
+        return columnHalignment.get();
+    }
+
+    /// Sets where a child sits across its column in a vertical flow.
+    public final void setColumnHalignment(HPos value) {
+        columnHalignment.set(value);
+    }
+
+    /// Where a child sits across its column in a vertical flow.
+    public final ObjectProperty<HPos> columnHalignmentProperty() {
+        return columnHalignment;
+    }
+
+    /// Returns where a child sits across its row in a horizontal flow.
+    public final VPos getRowValignment() {
+        return rowValignment.get();
+    }
+
+    /// Sets where a child sits across its row in a horizontal flow.
+    public final void setRowValignment(VPos value) {
+        rowValignment.set(value);
+    }
+
+    /// Where a child sits across its row in a horizontal flow.
+    public final ObjectProperty<VPos> rowValignmentProperty() {
+        return rowValignment;
+    }
+
+    private Pos align() {
+        Pos p = alignment.get();
+        return p == null ? Pos.TOP_LEFT : p;
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        return getOrientation();
+    }
+
+    /// One row of a horizontal flow, or one column of a vertical one.
+    private static final class Run {
+        final List<Node> nodes = new ArrayList<Node>();
+        final List<double[]> areas = new ArrayList<double[]>();
+        double offset;
+        double length;
+        double breadth;
+        double baseline;
+    }
+
+    private boolean rowsOnBaseline() {
+        return getOrientation() == Orientation.HORIZONTAL && getRowValignment() == VPos.BASELINE;
+    }
+
+    private void close(Run run, double offset, double gap) {
+        int n = run.areas.size();
+        double length = 0;
+        double breadth = 0;
+        for (int i = 0; i < n; i++) {
+            double[] a = run.areas.get(i);
+            length += a[1];
+            breadth = Math.max(breadth, a[2]);
+        }
+        run.length = n > 1 ? length + gap * (n - 1) : length;
+        run.breadth = breadth;
+        run.offset = offset;
+        if (rowsOnBaseline()) {
+            run.baseline = LayoutSupport.areaBaseline(this, run.nodes, MARGIN);
+            run.breadth = LayoutSupport.baselineAreaHeight(this, run.nodes, MARGIN);
+        }
+    }
+
+    /// Breaks the children into runs no longer than a limit. An area is
+    /// position along the run, length along it and breadth across it.
+    private List<Run> runs(double limit) {
+        boolean horizontal = getOrientation() == Orientation.HORIZONTAL;
+        double along = horizontal ? snapSpaceX(getHgap()) : snapSpaceY(getVgap());
+        double across = horizontal ? snapSpaceY(getVgap()) : snapSpaceX(getHgap());
+        List<Node> managed = getManagedChildren();
+        List<Run> runs = new ArrayList<Run>();
+        Run run = new Run();
+        double offset = 0;
+        double length = 0;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            Insets m = getMargin(child);
+            double w = computeChildPrefAreaWidth(child, m, -1);
+            double h = computeChildPrefAreaHeight(child, m, -1);
+            double size = horizontal ? w : h;
+            if (length + size > limit && length > 0) {
+                close(run, offset, along);
+                offset += run.breadth + across;
+                runs.add(run);
+                run = new Run();
+                length = 0;
+            }
+            run.nodes.add(child);
+            run.areas.add(new double[] {length, size, horizontal ? h : w});
+            length += size + along;
+        }
+        close(run, offset, along);
+        runs.add(run);
+        return runs;
+    }
+
+    private static double longest(List<Run> runs) {
+        double max = 0;
+        for (int i = 0; i < runs.size(); i++) {
+            max = Math.max(max, runs.get(i).length);
+        }
+        return max;
+    }
+
+    private static double breadth(List<Run> runs) {
+        Run last = runs.get(runs.size() - 1);
+        return last.offset + last.breadth;
+    }
+
+    private double largestChild(boolean width) {
+        List<Node> managed = getManagedChildren();
+        double max = 0;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            Insets m = getMargin(child);
+            max = Math.max(max, width ? computeChildPrefAreaWidth(child, m, -1)
+                    : computeChildPrefAreaHeight(child, m, -1));
+        }
+        return max;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        if (getOrientation() == Orientation.HORIZONTAL) {
+            Insets in = getInsets();
+            return in.getLeft() + snapSizeX(largestChild(true)) + in.getRight();
+        }
+        return computePrefWidth(height);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        if (getOrientation() == Orientation.VERTICAL) {
+            Insets in = getInsets();
+            return in.getTop() + snapSizeY(largestChild(false)) + in.getBottom();
+        }
+        return computePrefHeight(width);
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        if (getOrientation() == Orientation.HORIZONTAL) {
+            double wrap = getPrefWrapLength();
+            double content = longest(runs(wrap));
+            return in.getLeft() + snapSizeX(Math.max(wrap, content)) + in.getRight();
+        }
+        double limit = height != -1 ? height - in.getTop() - in.getBottom() : getPrefWrapLength();
+        return in.getLeft() + breadth(runs(limit)) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        if (getOrientation() == Orientation.HORIZONTAL) {
+            double limit = width != -1 ? width - in.getLeft() - in.getRight() : getPrefWrapLength();
+            return in.getTop() + breadth(runs(limit)) + in.getBottom();
+        }
+        double wrap = getPrefWrapLength();
+        double content = longest(runs(wrap));
+        return in.getTop() + snapSizeY(Math.max(wrap, content)) + in.getBottom();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double insideWidth = getWidth() - in.getLeft() - in.getRight();
+        double insideHeight = getHeight() - in.getTop() - in.getBottom();
+        boolean horizontal = getOrientation() == Orientation.HORIZONTAL;
+        List<Run> runs = runs(horizontal ? insideWidth : insideHeight);
+        Pos pos = align();
+        HPos hpos = getColumnHalignment() == null ? HPos.LEFT : getColumnHalignment();
+        VPos vpos = getRowValignment() == null ? VPos.CENTER : getRowValignment();
+        boolean baseline = rowsOnBaseline();
+        double across = breadth(runs);
+        for (int r = 0; r < runs.size(); r++) {
+            Run run = runs.get(r);
+            double x0 = in.getLeft() + LayoutSupport.xOffset(insideWidth, horizontal ? run.length : across,
+                    pos.getHpos());
+            double y0 = in.getTop() + LayoutSupport.yOffset(insideHeight, horizontal ? across : run.length,
+                    pos.getVpos());
+            for (int i = 0; i < run.nodes.size(); i++) {
+                Node child = run.nodes.get(i);
+                double[] a = run.areas.get(i);
+                if (!horizontal) {
+                    layoutInArea(child, x0 + run.offset, y0 + a[0], run.breadth, a[1], 0, getMargin(child), hpos,
+                            vpos == VPos.BASELINE ? VPos.TOP : vpos);
+                } else if (baseline) {
+                    LayoutSupport.layoutOnBaseline(this, child, x0 + a[0], y0 + run.offset, a[1], run.breadth,
+                            run.baseline, getMargin(child), true, hpos);
+                } else {
+                    layoutInArea(child, x0 + a[0], y0 + run.offset, a[1], run.breadth, 0, getMargin(child), hpos,
+                            vpos);
+                }
+            }
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-hgap".equals(property)) {
+            return Double.valueOf(getHgap());
+        } else if ("-fx-vgap".equals(property)) {
+            return Double.valueOf(getVgap());
+        } else if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        } else if ("-fx-orientation".equals(property)) {
+            return getOrientation();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-hgap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setHgap(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-vgap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setVgap(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-alignment".equals(property)) {
+            Pos p = LayoutSupport.toPos(value);
+            if (value != null && p == null) {
+                return false;
+            }
+            setAlignment(p);
+            return true;
+        } else if ("-fx-orientation".equals(property)) {
+            Orientation o = LayoutSupport.toOrientation(value);
+            if (o == null) {
+                return false;
+            }
+            setOrientation(o);
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/GridPane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/GridPane.java
new file mode 100644
index 00000000000..ab02f3f7caa
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/GridPane.java
@@ -0,0 +1,1051 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Lays its managed children out in a grid of rows and columns.
+///
+/// A child sits in the cell its column and row index constraints name
+/// (0, 0 without them) and may span several cells; a span of
+/// [#REMAINING] reaches the last row or column. Several children may
+/// share a cell. The grid has as many rows and columns as the children
+/// and the constraint lists need.
+///
+/// #### Sizes
+///
+/// A column is as wide as the widest child that sits in it alone, and a
+/// row as tall as its tallest, unless a `ColumnConstraints` or
+/// `RowConstraints` at its index says otherwise. A child that spans
+/// several columns widens them when it needs more than they have: the
+/// columns that grow share what is missing, or all of the spanned columns
+/// that have no size of their own when none grows.
+///
+/// A column with a percentage takes that share of the pane's width less
+/// the gaps. When the pane is wider than the rest need, the spare width
+/// goes in equal shares to the columns that grow `ALWAYS`, then to those
+/// that grow `SOMETIMES`, each up to its maximum; when it is narrower,
+/// every column without a percentage gives up an equal share down to its
+/// minimum. A column grows as its constraint says or, when that says
+/// nothing, as eagerly as the most eager child in it. Without any growing
+/// column the grid keeps its size and is placed by `alignment`. Rows
+/// behave the same way with heights.
+///
+/// #### In the cell
+///
+/// A resizable child is stretched to its cell, up to its maximum size,
+/// unless a fill constraint on the child or on the row or column says
+/// no. A child that does not fill the cell is placed by its own
+/// alignment constraints, then by those of the row and column, and
+/// otherwise left and vertically centered.
+///
+/// Grid lines (`gridLinesVisible`) are drawn solid along the edges of
+/// every column and row, behind the children; JavaFX dashes them.
+///
+/// #### Styling
+///
+/// Besides the names of a region: `-fx-hgap`, `-fx-vgap` (`Number`) and
+/// `-fx-alignment` (`javafx.geometry.Pos`, or its CSS spelling as a
+/// `String`, matched without regard to ASCII case).
+public class GridPane extends Pane {
+
+    /// A span that reaches the last row or column of the grid.
+    public static final int REMAINING = Integer.MAX_VALUE;
+
+    private static final String ROW = "gridpane-row";
+    private static final String COLUMN = "gridpane-column";
+    private static final String ROW_SPAN = "gridpane-row-span";
+    private static final String COLUMN_SPAN = "gridpane-column-span";
+    private static final String MARGIN = "gridpane-margin";
+    private static final String HALIGNMENT = "gridpane-halignment";
+    private static final String VALIGNMENT = "gridpane-valignment";
+    private static final String HGROW = "gridpane-hgrow";
+    private static final String VGROW = "gridpane-vgrow";
+    private static final String FILL_WIDTH = "gridpane-fill-width";
+    private static final String FILL_HEIGHT = "gridpane-fill-height";
+
+    private final javafx.beans.property.BooleanProperty gridLinesVisible =
+            new com.codename1.fxcompat.runtime.FxBoolean(this, "gridLinesVisible", false, Dirty.PAINT);
+    private final DoubleProperty hgap = new FxDouble(this, "hgap", 0, Dirty.LAYOUT);
+    private final DoubleProperty vgap = new FxDouble(this, "vgap", 0, Dirty.LAYOUT);
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.TOP_LEFT, Dirty.LAYOUT);
+    private final ObservableList<RowConstraints> rowConstraints = FXCollections.observableArrayList();
+    private final ObservableList<ColumnConstraints> columnConstraints = FXCollections.observableArrayList();
+
+    private double[] columnStarts = new double[0];
+    private double[] columnWidths = new double[0];
+    private double[] rowStarts = new double[0];
+    private double[] rowHeights = new double[0];
+
+    /// Creates an empty grid without gaps.
+    public GridPane() {
+        rowConstraints.addListener(new ListChangeListener<RowConstraints>() {
+            @Override
+            public void onChanged(Change<? extends RowConstraints> change) {
+                constraintsChanged(change);
+            }
+        });
+        columnConstraints.addListener(new ListChangeListener<ColumnConstraints>() {
+            @Override
+            public void onChanged(Change<? extends ColumnConstraints> change) {
+                constraintsChanged(change);
+            }
+        });
+    }
+
+    private void constraintsChanged(ListChangeListener.Change<? extends ConstraintsBase> change) {
+        while (change.next()) {
+            List<? extends ConstraintsBase> removed = change.getRemoved();
+            for (int i = 0; i < removed.size(); i++) {
+                ConstraintsBase c = removed.get(i);
+                if (c != null) {
+                    c.remove(this);
+                }
+            }
+            List<? extends ConstraintsBase> added = change.getAddedSubList();
+            for (int i = 0; i < added.size(); i++) {
+                ConstraintsBase c = added.get(i);
+                if (c != null) {
+                    c.add(this);
+                }
+            }
+        }
+        requestLayout();
+    }
+
+    // ------------------------------------------------------- constraints
+
+    private static void checkIndex(Integer value, String what) {
+        if (value != null && value.intValue() < 0) {
+            throw new IllegalArgumentException(what + " must be greater or equal to 0, but was " + value);
+        }
+    }
+
+    private static void checkSpan(Integer value, String what) {
+        if (value != null && value.intValue() < 1) {
+            throw new IllegalArgumentException(what + " must be greater or equal to 1, but was " + value);
+        }
+    }
+
+    /// Sets the row a child sits in; `null` removes the constraint.
+    public static void setRowIndex(Node child, Integer value) {
+        checkIndex(value, "rowIndex");
+        setConstraint(child, ROW, value);
+    }
+
+    /// Returns the row index constraint of a child, or `null`.
+    public static Integer getRowIndex(Node child) {
+        return LayoutSupport.integer(child, ROW);
+    }
+
+    /// Sets the column a child sits in; `null` removes the constraint.
+    public static void setColumnIndex(Node child, Integer value) {
+        checkIndex(value, "columnIndex");
+        setConstraint(child, COLUMN, value);
+    }
+
+    /// Returns the column index constraint of a child, or `null`.
+    public static Integer getColumnIndex(Node child) {
+        return LayoutSupport.integer(child, COLUMN);
+    }
+
+    /// Sets how many rows a child spans, or [#REMAINING]; `null` removes
+    /// the constraint.
+    public static void setRowSpan(Node child, Integer value) {
+        checkSpan(value, "rowSpan");
+        setConstraint(child, ROW_SPAN, value);
+    }
+
+    /// Returns the row span constraint of a child, or `null`.
+    public static Integer getRowSpan(Node child) {
+        return LayoutSupport.integer(child, ROW_SPAN);
+    }
+
+    /// Sets how many columns a child spans, or [#REMAINING]; `null`
+    /// removes the constraint.
+    public static void setColumnSpan(Node child, Integer value) {
+        checkSpan(value, "columnSpan");
+        setConstraint(child, COLUMN_SPAN, value);
+    }
+
+    /// Returns the column span constraint of a child, or `null`.
+    public static Integer getColumnSpan(Node child) {
+        return LayoutSupport.integer(child, COLUMN_SPAN);
+    }
+
+    /// Sets the space kept free around a child in its cell; `null`
+    /// removes the constraint.
+    public static void setMargin(Node child, Insets value) {
+        setConstraint(child, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node child) {
+        return LayoutSupport.insets(child, MARGIN);
+    }
+
+    /// Sets where a child sits horizontally in its cell; `null` removes
+    /// the constraint.
+    public static void setHalignment(Node child, HPos value) {
+        setConstraint(child, HALIGNMENT, value);
+    }
+
+    /// Returns the horizontal alignment constraint of a child, or `null`.
+    public static HPos getHalignment(Node child) {
+        Object v = getConstraint(child, HALIGNMENT);
+        return v instanceof HPos ? (HPos) v : null;
+    }
+
+    /// Sets where a child sits vertically in its cell; `null` removes the
+    /// constraint.
+    public static void setValignment(Node child, VPos value) {
+        setConstraint(child, VALIGNMENT, value);
+    }
+
+    /// Returns the vertical alignment constraint of a child, or `null`.
+    public static VPos getValignment(Node child) {
+        Object v = getConstraint(child, VALIGNMENT);
+        return v instanceof VPos ? (VPos) v : null;
+    }
+
+    /// Sets how eagerly the columns of a child take spare width; `null`
+    /// removes the constraint.
+    public static void setHgrow(Node child, Priority value) {
+        setConstraint(child, HGROW, value);
+    }
+
+    /// Returns the horizontal grow constraint of a child, or `null`.
+    public static Priority getHgrow(Node child) {
+        return LayoutSupport.priority(child, HGROW);
+    }
+
+    /// Sets how eagerly the rows of a child take spare height; `null`
+    /// removes the constraint.
+    public static void setVgrow(Node child, Priority value) {
+        setConstraint(child, VGROW, value);
+    }
+
+    /// Returns the vertical grow constraint of a child, or `null`.
+    public static Priority getVgrow(Node child) {
+        return LayoutSupport.priority(child, VGROW);
+    }
+
+    /// Sets whether a child is stretched to the width of its cell; `null`
+    /// removes the constraint.
+    public static void setFillWidth(Node child, Boolean value) {
+        setConstraint(child, FILL_WIDTH, value);
+    }
+
+    /// Returns the fill width constraint of a child, or `null`.
+    public static Boolean isFillWidth(Node child) {
+        Object v = getConstraint(child, FILL_WIDTH);
+        return v instanceof Boolean ? (Boolean) v : null;
+    }
+
+    /// Sets whether a child is stretched to the height of its cell;
+    /// `null` removes the constraint.
+    public static void setFillHeight(Node child, Boolean value) {
+        setConstraint(child, FILL_HEIGHT, value);
+    }
+
+    /// Returns the fill height constraint of a child, or `null`.
+    public static Boolean isFillHeight(Node child) {
+        Object v = getConstraint(child, FILL_HEIGHT);
+        return v instanceof Boolean ? (Boolean) v : null;
+    }
+
+    /// Sets the cell of a child.
+    public static void setConstraints(Node child, int columnIndex, int rowIndex) {
+        setRowIndex(child, Integer.valueOf(rowIndex));
+        setColumnIndex(child, Integer.valueOf(columnIndex));
+    }
+
+    /// Sets the cell and the spans of a child.
+    public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan) {
+        setRowIndex(child, Integer.valueOf(rowIndex));
+        setColumnIndex(child, Integer.valueOf(columnIndex));
+        setRowSpan(child, Integer.valueOf(rowspan));
+        setColumnSpan(child, Integer.valueOf(columnspan));
+    }
+
+    /// Sets the cell, the spans and the alignment of a child.
+    public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan,
+            HPos halignment, VPos valignment) {
+        setConstraints(child, columnIndex, rowIndex, columnspan, rowspan);
+        setHalignment(child, halignment);
+        setValignment(child, valignment);
+    }
+
+    /// Sets the cell, the spans, the alignment and the grow priorities of
+    /// a child.
+    public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan,
+            HPos halignment, VPos valignment, Priority hgrow, Priority vgrow) {
+        setConstraints(child, columnIndex, rowIndex, columnspan, rowspan);
+        setHalignment(child, halignment);
+        setValignment(child, valignment);
+        setHgrow(child, hgrow);
+        setVgrow(child, vgrow);
+    }
+
+    /// Sets the cell, the spans, the alignment, the grow priorities and
+    /// the margin of a child.
+    public static void setConstraints(Node child, int columnIndex, int rowIndex, int columnspan, int rowspan,
+            HPos halignment, VPos valignment, Priority hgrow, Priority vgrow, Insets margin) {
+        setConstraints(child, columnIndex, rowIndex, columnspan, rowspan);
+        setHalignment(child, halignment);
+        setValignment(child, valignment);
+        setHgrow(child, hgrow);
+        setVgrow(child, vgrow);
+        setMargin(child, margin);
+    }
+
+    /// Removes the grid constraints from a child.
+    public static void clearConstraints(Node child) {
+        setRowIndex(child, null);
+        setColumnIndex(child, null);
+        setRowSpan(child, null);
+        setColumnSpan(child, null);
+        setHalignment(child, null);
+        setValignment(child, null);
+        setHgrow(child, null);
+        setVgrow(child, null);
+        setMargin(child, null);
+        setFillWidth(child, null);
+        setFillHeight(child, null);
+    }
+
+    // -------------------------------------------------------- properties
+
+    /// Returns the gap between columns.
+    public final double getHgap() {
+        return hgap.get();
+    }
+
+    /// Sets the gap between columns.
+    public final void setHgap(double value) {
+        hgap.set(value);
+    }
+
+    /// The gap between columns.
+    public final DoubleProperty hgapProperty() {
+        return hgap;
+    }
+
+    /// Returns the gap between rows.
+    public final double getVgap() {
+        return vgap.get();
+    }
+
+    /// Sets the gap between rows.
+    public final void setVgap(double value) {
+        vgap.set(value);
+    }
+
+    /// The gap between rows.
+    public final DoubleProperty vgapProperty() {
+        return vgap;
+    }
+
+    /// Returns where the grid sits when the pane has room to spare.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the grid sits when the pane has room to spare.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the grid sits when the pane has room to spare.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Returns the constraints of the rows, by row index.
+    public final ObservableList<RowConstraints> getRowConstraints() {
+        return rowConstraints;
+    }
+
+    /// Returns the constraints of the columns, by column index.
+    public final ObservableList<ColumnConstraints> getColumnConstraints() {
+        return columnConstraints;
+    }
+
+    /// Adds a child in a cell.
+    public void add(Node child, int columnIndex, int rowIndex) {
+        setConstraints(child, columnIndex, rowIndex);
+        getChildren().add(child);
+    }
+
+    /// Adds a child in a cell, spanning columns and rows.
+    public void add(Node child, int columnIndex, int rowIndex, int colspan, int rowspan) {
+        setConstraints(child, columnIndex, rowIndex, colspan, rowspan);
+        getChildren().add(child);
+    }
+
+    /// Adds children to a row, each in the next column after what the row
+    /// already holds.
+    public void addRow(int rowIndex, Node... children) {
+        int next = nextFree(false, rowIndex);
+        for (int i = 0; i < children.length; i++) {
+            setConstraints(children[i], next + i, rowIndex);
+        }
+        getChildren().addAll(children);
+    }
+
+    /// Adds children to a column, each in the next row after what the
+    /// column already holds.
+    public void addColumn(int columnIndex, Node... children) {
+        int next = nextFree(true, columnIndex);
+        for (int i = 0; i < children.length; i++) {
+            setConstraints(children[i], columnIndex, next + i);
+        }
+        getChildren().addAll(children);
+    }
+
+    /// The first index along a column (or a row) after the children that
+    /// already sit in it.
+    private int nextFree(boolean column, int line) {
+        List<Node> managed = getManagedChildren();
+        int next = 0;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            int at = index(child, column);
+            int span = span(child, column);
+            if (line >= at && (span == REMAINING || line <= at + span - 1)) {
+                int other = index(child, !column);
+                int otherSpan = span(child, !column);
+                next = Math.max(next, (otherSpan == REMAINING ? other : other + otherSpan - 1) + 1);
+            }
+        }
+        return next;
+    }
+
+    /// Returns the number of rows of the grid.
+    public final int getRowCount() {
+        List<Node> managed = getManagedChildren();
+        return count(false, managed);
+    }
+
+    /// Returns the number of columns of the grid.
+    public final int getColumnCount() {
+        List<Node> managed = getManagedChildren();
+        return count(true, managed);
+    }
+
+    /// Returns the bounds of a cell as of the last layout, in the
+    /// coordinates of the pane; a cell outside the grid has no size and
+    /// sits after the last row or column.
+    public final Bounds getCellBounds(int columnIndex, int rowIndex) {
+        Insets in = getInsets();
+        double x = in.getLeft();
+        double w = 0;
+        if (columnIndex >= 0 && columnIndex < columnWidths.length) {
+            x = columnStarts[columnIndex];
+            w = columnWidths[columnIndex];
+        } else if (columnWidths.length > 0) {
+            int last = columnWidths.length - 1;
+            x = columnStarts[last] + columnWidths[last];
+        }
+        double y = in.getTop();
+        double h = 0;
+        if (rowIndex >= 0 && rowIndex < rowHeights.length) {
+            y = rowStarts[rowIndex];
+            h = rowHeights[rowIndex];
+        } else if (rowHeights.length > 0) {
+            int last = rowHeights.length - 1;
+            y = rowStarts[last] + rowHeights[last];
+        }
+        return new BoundingBox(x, y, w, h);
+    }
+
+    // ------------------------------------------------------------ tracks
+
+    private static int index(Node child, boolean column) {
+        Integer v = column ? getColumnIndex(child) : getRowIndex(child);
+        return v == null ? 0 : v.intValue();
+    }
+
+    private static int span(Node child, boolean column) {
+        Integer v = column ? getColumnSpan(child) : getRowSpan(child);
+        return v == null ? 1 : v.intValue();
+    }
+
+    /// The last row or column a child covers.
+    private static int last(Node child, boolean column, int count) {
+        int at = index(child, column);
+        int span = span(child, column);
+        return span == REMAINING ? Math.max(at, count - 1) : at + span - 1;
+    }
+
+    private int count(boolean column, List<Node> managed) {
+        int n = column ? columnConstraints.size() : rowConstraints.size();
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            int at = index(child, column);
+            int span = span(child, column);
+            n = Math.max(n, span == REMAINING ? at + 1 : at + span);
+        }
+        return n;
+    }
+
+    private ConstraintsBase constraint(boolean column, int i) {
+        if (column) {
+            return i < columnConstraints.size() ? columnConstraints.get(i) : null;
+        }
+        return i < rowConstraints.size() ? rowConstraints.get(i) : null;
+    }
+
+    /// The rows or the columns of the grid as layout sees them.
+    private static final class Tracks {
+        final double[] min;
+        final double[] pref;
+        final double[] max;
+        /// The share of the pane as a fraction, or a negative number.
+        final double[] share;
+        final boolean[] fixedPref;
+        final boolean[] fixedMin;
+        final Priority[] grow;
+        /// Whether something in the track may be larger than it would
+        /// like: a field, a slider. Such a track has no one right size.
+        final boolean[] elastic;
+        double gap;
+
+        Tracks(int n) {
+            min = new double[n];
+            pref = new double[n];
+            max = new double[n];
+            share = new double[n];
+            fixedPref = new boolean[n];
+            elastic = new boolean[n];
+            fixedMin = new boolean[n];
+            grow = new Priority[n];
+        }
+
+        double gaps() {
+            return min.length > 1 ? gap * (min.length - 1) : 0;
+        }
+    }
+
+    private double areaSize(Node child, boolean column, boolean minimum, double given) {
+        Insets m = getMargin(child);
+        if (column) {
+            return minimum ? computeChildMinAreaWidth(child, m, given) : computeChildPrefAreaWidth(child, m, given);
+        }
+        return minimum ? computeChildMinAreaHeight(child, m, given) : computeChildPrefAreaHeight(child, m, given);
+    }
+
+    private static double range(double[] sizes, int from, int to, double gap) {
+        double total = 0;
+        for (int i = from; i <= to && i < sizes.length; i++) {
+            total += sizes[i];
+        }
+        return to > from ? total + gap * (to - from) : total;
+    }
+
+    /// Widens the tracks a spanning child covers until they hold it.
+    private static void widen(double[] sizes, boolean[] fixed, Tracks t, int from, int to, double need) {
+        double missing = need - range(sizes, from, to, t.gap);
+        if (!(missing > 0)) {
+            return;
+        }
+        for (int pass = 0; pass < 3; pass++) {
+            int takers = 0;
+            for (int i = from; i <= to; i++) {
+                if (takes(fixed, t, i, pass)) {
+                    takers++;
+                }
+            }
+            if (takers > 0) {
+                double each = missing / takers;
+                for (int i = from; i <= to; i++) {
+                    if (takes(fixed, t, i, pass)) {
+                        sizes[i] += each;
+                    }
+                }
+                return;
+            }
+        }
+    }
+
+    private static boolean takes(boolean[] fixed, Tracks t, int i, int pass) {
+        if (fixed[i] || t.share[i] >= 0) {
+            return false;
+        }
+        if (pass == 0) {
+            return t.grow[i] == Priority.ALWAYS;
+        } else if (pass == 1) {
+            return t.grow[i] == Priority.SOMETIMES;
+        }
+        return true;
+    }
+
+    /// Measures the columns, or the rows. `widths` are the widths of the
+    /// columns when the rows are measured for a known width, else `null`.
+    private Tracks measure(boolean column, List<Node> managed, double[] widths, double widthGap) {
+        int n = count(column, managed);
+        int columns = column ? n : count(true, managed);
+        Tracks t = new Tracks(n);
+        t.gap = column ? snapSpaceX(getHgap()) : snapSpaceY(getVgap());
+        double[] setMin = new double[n];
+        double[] setPref = new double[n];
+        double[] setMax = new double[n];
+        boolean[] ownGrow = new boolean[n];
+        double shares = 0;
+        for (int i = 0; i < n; i++) {
+            ConstraintsBase c = constraint(column, i);
+            setMin[i] = c == null ? USE_COMPUTED_SIZE : c.minSize();
+            setPref[i] = c == null ? USE_COMPUTED_SIZE : c.prefSize();
+            setMax[i] = c == null ? USE_COMPUTED_SIZE : c.maxSize();
+            double percent = c == null ? -1 : c.percent();
+            t.share[i] = percent >= 0 ? percent / 100 : -1;
+            if (percent >= 0) {
+                shares += percent / 100;
+            }
+            t.grow[i] = c == null ? null : c.grow();
+            ownGrow[i] = t.grow[i] != null;
+            t.fixedPref[i] = setPref[i] != USE_COMPUTED_SIZE;
+            t.fixedMin[i] = setMin[i] != USE_COMPUTED_SIZE;
+        }
+        if (shares > 1) {
+            for (int i = 0; i < n; i++) {
+                if (t.share[i] >= 0) {
+                    t.share[i] = t.share[i] / shares;
+                }
+            }
+        }
+        List<List<Node>> onBaseline = null;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            int from = index(child, column);
+            int to = last(child, column, n);
+            Priority wants = column ? getHgrow(child) : getVgrow(child);
+            if (wants != null) {
+                for (int k = from; k <= to; k++) {
+                    if (!ownGrow[k]) {
+                        t.grow[k] = t.grow[k] == null ? wants : Priority.max(t.grow[k], wants);
+                    }
+                }
+            }
+            if (from != to) {
+                continue;
+            }
+            double given = column || widths == null ? -1
+                    : range(widths, index(child, true), last(child, true, columns), widthGap);
+            t.min[from] = Math.max(t.min[from], areaSize(child, column, true, given));
+            double liked = areaSize(child, column, false, given);
+            t.pref[from] = Math.max(t.pref[from], liked);
+            if ((column ? child.maxWidth(-1) : child.maxHeight(-1)) > liked + 1) {
+                t.elastic[from] = true;
+            }
+            if (!column && valignment(child, from) == VPos.BASELINE) {
+                if (onBaseline == null) {
+                    onBaseline = new ArrayList<List<Node>>();
+                    for (int k = 0; k < n; k++) {
+                        onBaseline.add(new ArrayList<Node>());
+                    }
+                }
+                onBaseline.get(from).add(child);
+            }
+        }
+        if (onBaseline != null) {
+            for (int i = 0; i < n; i++) {
+                if (!onBaseline.get(i).isEmpty()) {
+                    t.pref[i] = Math.max(t.pref[i], LayoutSupport.baselineAreaHeight(this, onBaseline.get(i), MARGIN));
+                }
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            if (t.fixedPref[i]) {
+                double low = !t.fixedMin[i] || setMin[i] == USE_PREF_SIZE ? 0 : setMin[i];
+                double high = setMax[i] == USE_COMPUTED_SIZE || setMax[i] == USE_PREF_SIZE ? Double.MAX_VALUE
+                        : setMax[i];
+                t.pref[i] = boundedSize(low, setPref[i], high);
+            }
+            if (t.fixedMin[i]) {
+                t.min[i] = setMin[i] == USE_PREF_SIZE ? t.pref[i] : setMin[i];
+            }
+        }
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            int from = index(child, column);
+            int to = last(child, column, n);
+            if (from == to) {
+                continue;
+            }
+            double given = column || widths == null ? -1
+                    : range(widths, index(child, true), last(child, true, columns), widthGap);
+            widen(t.pref, t.fixedPref, t, from, to, areaSize(child, column, false, given));
+            widen(t.min, t.fixedMin, t, from, to, areaSize(child, column, true, given));
+        }
+        for (int i = 0; i < n; i++) {
+            if (setMax[i] == USE_COMPUTED_SIZE) {
+                t.max[i] = Double.MAX_VALUE;
+            } else if (setMax[i] == USE_PREF_SIZE) {
+                t.max[i] = t.pref[i];
+            } else {
+                t.max[i] = setMax[i];
+            }
+            if (t.max[i] < t.min[i]) {
+                t.max[i] = t.min[i];
+            }
+            if (t.pref[i] > t.max[i]) {
+                t.pref[i] = t.max[i];
+            }
+            if (t.pref[i] < t.min[i]) {
+                if (t.fixedPref[i] && !t.fixedMin[i]) {
+                    t.min[i] = t.pref[i];
+                } else {
+                    t.pref[i] = t.min[i];
+                }
+            }
+            t.pref[i] = column ? snapSizeX(t.pref[i]) : snapSizeY(t.pref[i]);
+            t.min[i] = column ? snapSizeX(t.min[i]) : snapSizeY(t.min[i]);
+        }
+        return t;
+    }
+
+    /// The length the grid needs for its tracks at given sizes, gaps
+    /// included: large enough for every percentage to hold what its track
+    /// needs and for the rest to fit in what the percentages leave.
+    private static double total(Tracks t, double[] sizes) {
+        double rest = 0;
+        double shares = 0;
+        double content = 0;
+        for (int i = 0; i < sizes.length; i++) {
+            if (t.share[i] >= 0) {
+                shares += t.share[i];
+                if (t.share[i] > 0) {
+                    content = Math.max(content, sizes[i] / t.share[i]);
+                }
+            } else {
+                rest += sizes[i];
+            }
+        }
+        if (shares > 0 && shares < 1) {
+            content = Math.max(content, rest / (1 - shares));
+        } else {
+            content = Math.max(content, rest);
+        }
+        return content + t.gaps();
+    }
+
+    /// Fits the tracks to a length and answers their sizes.
+    private double[] resolve(Tracks t, double length, boolean column) {
+        int n = t.pref.length;
+        double[] sizes = new double[n];
+        double space = Math.max(0, length - t.gaps());
+        double used = 0;
+        for (int i = 0; i < n; i++) {
+            if (t.share[i] >= 0) {
+                sizes[i] = column ? snapSpaceX(space * t.share[i]) : snapSpaceY(space * t.share[i]);
+            } else {
+                sizes[i] = t.pref[i];
+            }
+            used += sizes[i];
+        }
+        double extra = space - used;
+        if (extra < 0) {
+            double[] limits = new double[n];
+            for (int i = 0; i < n; i++) {
+                limits[i] = t.share[i] >= 0 ? Double.NaN : t.min[i];
+            }
+            double missing = extra;
+            if (LayoutSupport.growersGiveFirst()) {
+                // On a phone the tracks told to grow give way before the
+                // others; see LayoutSupport.growersGiveFirst.
+                for (int pass = 0; pass < 3; pass++) {
+                    Priority wanted = pass == 0 ? Priority.ALWAYS : Priority.SOMETIMES;
+                    double[] some = new double[n];
+                    for (int i = 0; i < n; i++) {
+                        boolean gives = pass < 2 ? t.grow[i] == wanted : t.elastic[i];
+                        some[i] = gives ? limits[i] : Double.NaN;
+                    }
+                    missing = LayoutSupport.distribute(this, sizes, some, missing);
+                }
+            }
+            LayoutSupport.distribute(this, sizes, limits, missing);
+        } else if (extra > 0) {
+            double remaining = extra;
+            for (int pass = 0; pass < 2; pass++) {
+                Priority wanted = pass == 0 ? Priority.ALWAYS : Priority.SOMETIMES;
+                double[] limits = new double[n];
+                for (int i = 0; i < n; i++) {
+                    limits[i] = t.share[i] < 0 && t.grow[i] == wanted ? t.max[i] : Double.NaN;
+                }
+                remaining = LayoutSupport.distribute(this, sizes, limits, remaining);
+            }
+        }
+        return sizes;
+    }
+
+    private double[] widthsFor(List<Node> managed, double width) {
+        Tracks t = measure(true, managed, null, 0);
+        Insets in = getInsets();
+        double length = width == -1 ? total(t, t.pref) : width - in.getLeft() - in.getRight();
+        return resolve(t, length, true);
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        List<Node> managed = getManagedChildren();
+        return LayoutSupport.bias(managed);
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        Tracks t = measure(true, managed, null, 0);
+        return in.getLeft() + total(t, t.min) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        Tracks t = measure(true, managed, null, 0);
+        return in.getLeft() + total(t, t.pref) + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        Tracks t = measure(false, managed, widthsFor(managed, width), snapSpaceX(getHgap()));
+        return in.getTop() + total(t, t.min) + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        Tracks t = measure(false, managed, widthsFor(managed, width), snapSpaceX(getHgap()));
+        return in.getTop() + total(t, t.pref) + in.getBottom();
+    }
+
+    private static double[] starts(double[] sizes, double first, double gap) {
+        double[] out = new double[sizes.length];
+        double at = first;
+        for (int i = 0; i < sizes.length; i++) {
+            out[i] = at;
+            at += sizes[i] + gap;
+        }
+        return out;
+    }
+
+    private HPos halignment(Node child, int column) {
+        HPos own = getHalignment(child);
+        if (own != null) {
+            return own;
+        }
+        if (column < columnConstraints.size()) {
+            ColumnConstraints c = columnConstraints.get(column);
+            if (c != null && c.getHalignment() != null) {
+                return c.getHalignment();
+            }
+        }
+        return HPos.LEFT;
+    }
+
+    private VPos valignment(Node child, int row) {
+        VPos own = getValignment(child);
+        if (own != null) {
+            return own;
+        }
+        if (row < rowConstraints.size()) {
+            RowConstraints c = rowConstraints.get(row);
+            if (c != null && c.getValignment() != null) {
+                return c.getValignment();
+            }
+        }
+        return VPos.CENTER;
+    }
+
+    private boolean fills(Node child, boolean column, int at) {
+        Boolean own = column ? isFillWidth(child) : isFillHeight(child);
+        if (own != null) {
+            return own.booleanValue();
+        }
+        ConstraintsBase c = constraint(column, at);
+        return c == null || c.fill();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> managed = getManagedChildren();
+        Insets in = getInsets();
+        double insideWidth = getWidth() - in.getLeft() - in.getRight();
+        double insideHeight = getHeight() - in.getTop() - in.getBottom();
+        Tracks columns = measure(true, managed, null, 0);
+        double[] widths = resolve(columns, insideWidth, true);
+        Tracks rows = measure(false, managed, widths, columns.gap);
+        double[] heights = resolve(rows, insideHeight, false);
+        Pos pos = alignment.get() == null ? Pos.TOP_LEFT : alignment.get();
+        double x0 = in.getLeft()
+                + LayoutSupport.xOffset(insideWidth, LayoutSupport.sum(widths, columns.gap), pos.getHpos());
+        double y0 = in.getTop()
+                + LayoutSupport.yOffset(insideHeight, LayoutSupport.sum(heights, rows.gap), pos.getVpos());
+        double[] xs = starts(widths, x0, columns.gap);
+        double[] ys = starts(heights, y0, rows.gap);
+        columnStarts = xs;
+        columnWidths = widths;
+        rowStarts = ys;
+        rowHeights = heights;
+        double[] baselines = null;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            int c0 = index(child, true);
+            int c1 = last(child, true, widths.length);
+            int r0 = index(child, false);
+            int r1 = last(child, false, heights.length);
+            double w = range(widths, c0, c1, columns.gap);
+            double h = range(heights, r0, r1, rows.gap);
+            HPos hpos = halignment(child, c0);
+            VPos vpos = valignment(child, r0);
+            boolean fillWidth = fills(child, true, c0);
+            if (vpos == VPos.BASELINE) {
+                if (baselines == null) {
+                    baselines = rowBaselines(managed, heights.length);
+                }
+                LayoutSupport.layoutOnBaseline(this, child, xs[c0], ys[r0], w, h, baselines[r0], getMargin(child),
+                        fillWidth, hpos);
+            } else {
+                layoutInArea(child, xs[c0], ys[r0], w, h, 0, getMargin(child), fillWidth, fills(child, false, r0),
+                        hpos, vpos);
+            }
+        }
+    }
+
+    /// The baseline of each row: the lowest baseline among the children
+    /// aligned to it that sit in that row alone.
+    private double[] rowBaselines(List<Node> managed, int rows) {
+        double[] out = new double[rows];
+        for (int r = 0; r < rows; r++) {
+            List<Node> row = new ArrayList<Node>();
+            for (int i = 0; i < managed.size(); i++) {
+                Node child = managed.get(i);
+                if (index(child, false) == r && valignment(child, r) == VPos.BASELINE) {
+                    row.add(child);
+                }
+            }
+            out[r] = LayoutSupport.areaBaseline(this, row, MARGIN);
+        }
+        return out;
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-hgap".equals(property)) {
+            return Double.valueOf(getHgap());
+        } else if ("-fx-vgap".equals(property)) {
+            return Double.valueOf(getVgap());
+        } else if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-hgap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setHgap(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-vgap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setVgap(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-alignment".equals(property)) {
+            Pos p = LayoutSupport.toPos(value);
+            if (value != null && p == null) {
+                return false;
+            }
+            setAlignment(p);
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+
+    /// Sets whether the edges of the columns and rows are drawn, which is
+    /// meant for looking at a layout while it is made.
+    public final void setGridLinesVisible(boolean value) {
+        gridLinesVisible.set(value);
+    }
+
+    /// Returns whether the edges of the columns and rows are drawn.
+    public final boolean isGridLinesVisible() {
+        return gridLinesVisible.get();
+    }
+
+    /// Whether the edges of the columns and rows are drawn.
+    public final javafx.beans.property.BooleanProperty gridLinesVisibleProperty() {
+        return gridLinesVisible;
+    }
+
+    @Override
+    public void cn1Paint(com.codename1.fxcompat.runtime.Renderer renderer) {
+        super.cn1Paint(renderer);
+        int columns = Math.min(columnStarts.length, columnWidths.length);
+        int rows = Math.min(rowStarts.length, rowHeights.length);
+        if (!isGridLinesVisible() || columns == 0 || rows == 0) {
+            return;
+        }
+        javafx.scene.paint.Color line = javafx.scene.paint.Color.rgb(30, 30, 30);
+        double left = columnStarts[0];
+        double right = columnStarts[columns - 1] + columnWidths[columns - 1];
+        double top = rowStarts[0];
+        double bottom = rowStarts[rows - 1] + rowHeights[rows - 1];
+        for (int i = 0; i < columns; i++) {
+            renderer.fillRect(columnStarts[i], top, 1, bottom - top, line);
+            renderer.fillRect(columnStarts[i] + columnWidths[i], top, 1, bottom - top + 1, line);
+        }
+        for (int i = 0; i < rows; i++) {
+            renderer.fillRect(left, rowStarts[i], right - left, 1, line);
+            renderer.fillRect(left, rowStarts[i] + rowHeights[i], right - left + 1, 1, line);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/HBox.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/HBox.java
new file mode 100644
index 00000000000..a61267fe075
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/HBox.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Lays its managed children out in one row, left to right, in the order of the list.
+///
+/// Each child gets its preferred width. When the box is wider than
+/// its children need, the spare space goes in equal shares to the
+/// children whose hgrow priority is `ALWAYS`, each up to its maximum
+/// width, and only if space is still left to those with `SOMETIMES`.
+/// When the box is narrower, every child gives up an equal share down to
+/// its minimum width. Shares are whole device pixels, so up to one
+/// logical pixel may stay unused. Spare space nobody takes is placed
+/// according to the horizontal part of `alignment`.
+///
+/// Across the box a resizable child is stretched to the height of the
+/// box, up to its own maximum, while `fillHeight` is set; otherwise it keeps
+/// its preferred height. The vertical part of `alignment` places a child
+/// that does not fill the height.
+///
+/// With a baseline alignment the children keep their preferred height and
+/// are moved down until their baselines are level. A child without text
+/// has its baseline at its bottom edge.
+///
+/// #### Styling
+///
+/// Besides the names of a region: `-fx-spacing` (`Number`),
+/// `-fx-alignment` (`javafx.geometry.Pos`, or its CSS spelling such as
+/// `"center-left"` as a `String`, matched without regard to ASCII case)
+/// and `-fx-fill-height` (`Boolean`).
+public class HBox extends Pane {
+
+    private static final String MARGIN = "hbox-margin";
+    private static final String GROW = "hbox-hgrow";
+
+    private final DoubleProperty spacing = new FxDouble(this, "spacing", 0, Dirty.LAYOUT);
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.TOP_LEFT, Dirty.LAYOUT);
+    private final BooleanProperty fill = new FxBoolean(this, "fillHeight", true, Dirty.LAYOUT);
+
+    /// Creates an empty box without spacing.
+    public HBox() {
+    }
+
+    /// Creates an empty box with a gap between its children.
+    public HBox(double spacing) {
+        this.spacing.set(spacing);
+    }
+
+    /// Creates a box with children and no spacing.
+    public HBox(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a box with children and a gap between them.
+    public HBox(double spacing, Node... children) {
+        this.spacing.set(spacing);
+        cn1Children().addAll(children);
+    }
+
+    /// Sets how eagerly a child takes spare width in an HBox; `null`
+    /// removes the constraint.
+    public static void setHgrow(Node child, Priority value) {
+        setConstraint(child, GROW, value);
+    }
+
+    /// Returns the hgrow priority of a child, or `null`.
+    public static Priority getHgrow(Node child) {
+        return LayoutSupport.priority(child, GROW);
+    }
+
+    /// Sets the space kept free around a child in an HBox; `null`
+    /// removes the constraint.
+    public static void setMargin(Node child, Insets value) {
+        setConstraint(child, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node child) {
+        return LayoutSupport.insets(child, MARGIN);
+    }
+
+    /// Removes the HBox constraints from a child.
+    public static void clearConstraints(Node child) {
+        setHgrow(child, null);
+        setMargin(child, null);
+    }
+
+    /// Returns the gap between neighbouring children.
+    public final double getSpacing() {
+        return spacing.get();
+    }
+
+    /// Sets the gap between neighbouring children.
+    public final void setSpacing(double value) {
+        spacing.set(value);
+    }
+
+    /// The gap between neighbouring children.
+    public final DoubleProperty spacingProperty() {
+        return spacing;
+    }
+
+    /// Returns where the children sit when the box has room to spare.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the children sit when the box has room to spare.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the children sit when the box has room to spare.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Returns whether resizable children are stretched to the height of
+    /// the box.
+    public final boolean isFillHeight() {
+        return fill.get();
+    }
+
+    /// Sets whether resizable children are stretched to the height of the
+    /// box.
+    public final void setFillHeight(boolean value) {
+        fill.set(value);
+    }
+
+    /// Whether resizable children are stretched to the height of the box.
+    public final BooleanProperty fillHeightProperty() {
+        return fill;
+    }
+
+    private Pos align() {
+        Pos p = alignment.get();
+        return p == null ? Pos.TOP_LEFT : p;
+    }
+
+    private double gap() {
+        return snapSpaceX(getSpacing());
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        List<Node> managed = getManagedChildren();
+        return LayoutSupport.bias(managed);
+    }
+
+    private boolean onBaseline() {
+        return align().getVpos() == VPos.BASELINE;
+    }
+
+    private double[] areaWidths(List<Node> managed, double height, boolean minimum) {
+        Insets in = getInsets();
+        double inside = height == -1 || !isFillHeight() || onBaseline() ? -1 : height - in.getTop() - in.getBottom();
+        return LayoutSupport.areaSizes(this, managed, true, MARGIN, inside, minimum);
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        return in.getLeft() + LayoutSupport.sum(areaWidths(managed, height, true), gap()) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        return in.getLeft() + LayoutSupport.sum(areaWidths(managed, height, false), gap()) + in.getRight();
+    }
+
+    private double contentHeight(double width, boolean minimum) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        if (onBaseline()) {
+            return LayoutSupport.baselineAreaHeight(this, managed, MARGIN);
+        }
+        double[] widths = null;
+        if (width != -1 && getContentBias() == Orientation.HORIZONTAL) {
+            widths = areaWidths(managed, -1, false);
+            LayoutSupport.fit(this, managed, true, MARGIN, GROW, widths, gap(),
+                    width - in.getLeft() - in.getRight(), -1);
+        }
+        return LayoutSupport.maxCross(this, managed, true, MARGIN, widths, minimum);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + contentHeight(width, true) + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + contentHeight(width, false) + in.getBottom();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> managed = getManagedChildren();
+        Insets in = getInsets();
+        double width = getWidth();
+        double height = getHeight();
+        double insideWidth = width - in.getLeft() - in.getRight();
+        double insideHeight = height - in.getTop() - in.getBottom();
+        double gap = gap();
+        Pos pos = align();
+        boolean baseline = onBaseline();
+        boolean fillHeight = isFillHeight() && !baseline;
+        double[] widths = areaWidths(managed, height, false);
+        double used = LayoutSupport.fit(this, managed, true, MARGIN, GROW, widths, gap, insideWidth,
+                fillHeight ? insideHeight : -1);
+        double x = in.getLeft() + LayoutSupport.xOffset(insideWidth, used, pos.getHpos());
+        double y = in.getTop();
+        double areaBaseline = baseline ? LayoutSupport.areaBaseline(this, managed, MARGIN) : 0;
+        for (int i = 0; i < widths.length; i++) {
+            Node child = managed.get(i);
+            if (baseline) {
+                LayoutSupport.layoutOnBaseline(this, child, x, y, widths[i], insideHeight, areaBaseline,
+                        getMargin(child), true, HPos.CENTER);
+            } else {
+                layoutInArea(child, x, y, widths[i], insideHeight, 0, getMargin(child), true, fillHeight,
+                        HPos.CENTER, pos.getVpos());
+            }
+            x += widths[i] + gap;
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-spacing".equals(property)) {
+            return Double.valueOf(getSpacing());
+        } else if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        } else if ("-fx-fill-height".equals(property)) {
+            return Boolean.valueOf(isFillHeight());
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-spacing".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setSpacing(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-alignment".equals(property)) {
+            Pos p = LayoutSupport.toPos(value);
+            if (value != null && p == null) {
+                return false;
+            }
+            setAlignment(p);
+            return true;
+        } else if ("-fx-fill-height".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            setFillHeight(((Boolean) value).booleanValue());
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/LayoutSupport.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/LayoutSupport.java
new file mode 100644
index 00000000000..0088d6f3d50
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/LayoutSupport.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import javafx.geometry.Bounds;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// What the layout panes share: the per child constraints, the keyword
+/// forms of the styled values, the offsets of an alignment, baselines and
+/// the distribution of spare space along a row or a column of children.
+final class LayoutSupport {
+
+    private static final Pos[] POSITIONS = Pos.values();
+    private static final Orientation[] ORIENTATIONS = Orientation.values();
+
+    private LayoutSupport() {
+    }
+
+    // ------------------------------------------------------- constraints
+
+    static Insets insets(Node child, Object key) {
+        Object v = Pane.getConstraint(child, key);
+        return v instanceof Insets ? (Insets) v : null;
+    }
+
+    static Priority priority(Node child, Object key) {
+        Object v = Pane.getConstraint(child, key);
+        return v instanceof Priority ? (Priority) v : null;
+    }
+
+    static Pos pos(Node child, Object key) {
+        Object v = Pane.getConstraint(child, key);
+        return v instanceof Pos ? (Pos) v : null;
+    }
+
+    static Double number(Node child, Object key) {
+        Object v = Pane.getConstraint(child, key);
+        return v instanceof Double ? (Double) v : null;
+    }
+
+    static Integer integer(Node child, Object key) {
+        Object v = Pane.getConstraint(child, key);
+        return v instanceof Integer ? (Integer) v : null;
+    }
+
+    // ------------------------------------------------------ styled values
+
+    private static boolean sameKeyword(String name, String text) {
+        if (name.length() != text.length()) {
+            return false;
+        }
+        for (int i = 0; i < name.length(); i++) {
+            char a = name.charAt(i);
+            char b = text.charAt(i);
+            if (a == '_') {
+                a = '-';
+            }
+            if (b == '_') {
+                b = '-';
+            }
+            if (a >= 'A' && a <= 'Z') {
+                a = (char) (a + ('a' - 'A'));
+            }
+            if (b >= 'A' && b <= 'Z') {
+                b = (char) (b + ('a' - 'A'));
+            }
+            if (a != b) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Returns the position a styled value stands for: the constant, or
+    /// its CSS spelling (`center-left`); `null` for anything else.
+    static Pos toPos(Object value) {
+        if (value instanceof Pos) {
+            return (Pos) value;
+        } else if (value instanceof String) {
+            String s = ((String) value).trim();
+            for (int i = 0; i < POSITIONS.length; i++) {
+                if (sameKeyword(POSITIONS[i].name(), s)) {
+                    return POSITIONS[i];
+                }
+            }
+        }
+        return null;
+    }
+
+    /// Returns the orientation a styled value stands for, or `null`.
+    static Orientation toOrientation(Object value) {
+        if (value instanceof Orientation) {
+            return (Orientation) value;
+        } else if (value instanceof String) {
+            String s = ((String) value).trim();
+            for (int i = 0; i < ORIENTATIONS.length; i++) {
+                if (sameKeyword(ORIENTATIONS[i].name(), s)) {
+                    return ORIENTATIONS[i];
+                }
+            }
+        }
+        return null;
+    }
+
+    // ---------------------------------------------------------- offsets
+
+    static double xOffset(double available, double content, HPos pos) {
+        if (pos == HPos.CENTER) {
+            return (available - content) / 2;
+        } else if (pos == HPos.RIGHT) {
+            return available - content;
+        }
+        return 0;
+    }
+
+    static double yOffset(double available, double content, VPos pos) {
+        if (pos == VPos.CENTER) {
+            return (available - content) / 2;
+        } else if (pos == VPos.BOTTOM) {
+            return available - content;
+        }
+        return 0;
+    }
+
+    /// A share of spare space on a device pixel boundary, rounded towards
+    /// zero so that the shares never add up to more than there is.
+    static double portion(Region pane, double value) {
+        if (!pane.isSnapToPixel()) {
+            return value;
+        }
+        double s = com.codename1.fxcompat.runtime.Units.scale();
+        if (s <= 0) {
+            return value;
+        }
+        double scaled = value * s;
+        return (scaled >= 0 ? Math.floor(scaled + 1e-6) : Math.ceil(scaled - 1e-6)) / s;
+    }
+
+    // --------------------------------------------------------- baselines
+
+    /// Returns the height a child takes when it is not stretched, without
+    /// its margin.
+    static double restHeight(Node child) {
+        if (!child.isResizable()) {
+            return child.getLayoutBounds().getHeight();
+        }
+        return Region.boundedSize(child.minHeight(-1), child.prefHeight(-1), child.maxHeight(-1));
+    }
+
+    /// Returns the distance from the top of a child of a given height to
+    /// its baseline: the whole height for a child without text.
+    static double baseline(Node child, double height) {
+        double offset = child.getBaselineOffset();
+        if (Double.compare(offset, Node.BASELINE_OFFSET_SAME_AS_HEIGHT) == 0) {
+            return height;
+        }
+        if (child.isResizable()) {
+            // A resizable node that reports its current bottom edge has
+            // no baseline of its own; the edge moves with the height.
+            Bounds lb = child.getLayoutBounds();
+            if (Double.compare(offset, lb.getMinY() + lb.getHeight()) == 0) {
+                return height;
+            }
+        }
+        return offset;
+    }
+
+    static double top(Insets margin) {
+        return margin == null ? 0 : margin.getTop();
+    }
+
+    static double bottom(Insets margin) {
+        return margin == null ? 0 : margin.getBottom();
+    }
+
+    /// Returns the baseline of an area shared by several children: the
+    /// largest distance from the top of the area to a child's baseline.
+    static double areaBaseline(Region pane, List<Node> children, Object marginKey) {
+        double max = 0;
+        for (int i = 0; i < children.size(); i++) {
+            Node child = children.get(i);
+            double above = pane.snapSpaceY(top(insets(child, marginKey))) + baseline(child, restHeight(child));
+            if (above > max) {
+                max = above;
+            }
+        }
+        return max;
+    }
+
+    /// Returns the height of an area whose children sit on one baseline.
+    static double baselineAreaHeight(Region pane, List<Node> children, Object marginKey) {
+        double above = 0;
+        double below = 0;
+        for (int i = 0; i < children.size(); i++) {
+            Node child = children.get(i);
+            Insets m = insets(child, marginKey);
+            double h = restHeight(child);
+            double b = baseline(child, h);
+            above = Math.max(above, pane.snapSpaceY(top(m)) + b);
+            below = Math.max(below, h - b + pane.snapSpaceY(bottom(m)));
+        }
+        return above + below;
+    }
+
+    /// Places a child with its baseline on the baseline of an area. The
+    /// child keeps its preferred height.
+    static void layoutOnBaseline(Region pane, Node child, double x, double y, double width, double height,
+            double areaBaseline, Insets margin, boolean fillWidth, HPos hpos) {
+        Insets m = margin == null ? Insets.EMPTY : margin;
+        double shift = areaBaseline - pane.snapSpaceY(m.getTop()) - baseline(child, restHeight(child));
+        Insets moved = new Insets(m.getTop() + (shift > 0 ? shift : 0), m.getRight(), m.getBottom(), m.getLeft());
+        pane.layoutInArea(child, x, y, width, height, 0, moved, fillWidth, false, hpos, VPos.TOP);
+    }
+
+    // ------------------------------------------------- rows and columns
+
+    /// Returns the length along a box of the area of each child: its
+    /// minimum or its preferred size plus its margin.
+    static double[] areaSizes(Region pane, List<Node> children, boolean horizontal, Object marginKey, double cross,
+            boolean minimum) {
+        double[] sizes = new double[children.size()];
+        for (int i = 0; i < sizes.length; i++) {
+            Node child = children.get(i);
+            Insets m = insets(child, marginKey);
+            if (horizontal) {
+                sizes[i] = minimum ? pane.computeChildMinAreaWidth(child, m, cross)
+                        : pane.computeChildPrefAreaWidth(child, m, cross);
+            } else {
+                sizes[i] = minimum ? pane.computeChildMinAreaHeight(child, m, cross)
+                        : pane.computeChildPrefAreaHeight(child, m, cross);
+            }
+        }
+        return sizes;
+    }
+
+    static double sum(double[] sizes, double gap) {
+        double total = 0;
+        for (int i = 0; i < sizes.length; i++) {
+            total += sizes[i];
+        }
+        return sizes.length > 1 ? total + gap * (sizes.length - 1) : total;
+    }
+
+    /// Hands spare space to the areas that may take it, or takes missing
+    /// space from all of them, in equal shares within each area's limit.
+    /// `limits` holds the limit of each area taking part and NaN for the
+    /// others. Returns what could not be handed out.
+    static double distribute(Region pane, double[] sizes, double[] limits, double extra) {
+        int taking = 0;
+        for (int i = 0; i < limits.length; i++) {
+            if (!Double.isNaN(limits[i])) {
+                taking++;
+            }
+        }
+        double available = extra;
+        boolean done = false;
+        while (!done && Math.abs(available) > 1 && taking > 0) {
+            double share = portion(pane, available / taking);
+            if (!(Math.abs(share) > 0)) {
+                break;
+            }
+            for (int i = 0; i < sizes.length; i++) {
+                if (Double.isNaN(limits[i])) {
+                    continue;
+                }
+                double room = limits[i] - sizes[i];
+                double change = Math.abs(room) <= Math.abs(share) ? room : share;
+                if (extra > 0 ? change < 0 : change > 0) {
+                    change = 0;
+                }
+                sizes[i] += change;
+                available -= change;
+                if (Math.abs(available) < 1) {
+                    done = true;
+                    break;
+                }
+                if (Math.abs(change) < Math.abs(share)) {
+                    limits[i] = Double.NaN;
+                    taking--;
+                }
+            }
+        }
+        return available;
+    }
+
+    /// Whether missing space is taken first from what was told to grow.
+    ///
+    /// JavaFX takes it from every area in equal shares, and on a desktop so
+    /// does this: a window there opens at the size its content asks for,
+    /// and is too small only when somebody made it so. A phone gives every
+    /// scene a width a desktop window is never opened at, about two
+    /// hundred logical pixels, and equal shares there cut the labels of a
+    /// form short while the field beside each, told to take whatever room
+    /// there is, stays wider than its content. What was told to grow is
+    /// what the application said can change size, so on a display that
+    /// decides the width it is also what gives way first. After it comes
+    /// what may be larger than it would like without being told to grow,
+    /// a text field or a slider: a control with no one right size loses
+    /// nothing a reader misses, and a label loses letters.
+    ///
+    /// A page in a browser is such a display on a desktop as well: it is
+    /// as wide as the browser made it, and no window there takes the size
+    /// its content asks for.
+    static boolean growersGiveFirst() {
+        if (!com.codename1.ui.Display.isInitialized()) {
+            return false;
+        }
+        com.codename1.ui.Display d = com.codename1.ui.Display.getInstance();
+        return !d.isDesktop() || "HTML5".equals(d.getPlatformName());
+    }
+
+    /// Fits the areas of a box to the length it has: grows the children
+    /// that always grow, then those that sometimes do, or shrinks them
+    /// all towards their minimum. Returns the length used, gaps included.
+    static double fit(Region pane, List<Node> children, boolean horizontal, Object marginKey, Object growKey,
+            double[] sizes, double gap, double length, double cross) {
+        double content = sum(sizes, gap);
+        double extra = length - content;
+        if (sizes.length == 0 || !(Math.abs(extra) > 1)) {
+            return content;
+        }
+        double remaining = extra;
+        if (extra < 0) {
+            double[] limits = areaSizes(pane, children, horizontal, marginKey, cross, true);
+            if (growersGiveFirst()) {
+                for (int pass = 0; pass < 3; pass++) {
+                    Priority wanted = pass == 0 ? Priority.ALWAYS : Priority.SOMETIMES;
+                    double[] some = new double[limits.length];
+                    for (int i = 0; i < some.length; i++) {
+                        Node child = children.get(i);
+                        boolean gives;
+                        if (pass < 2) {
+                            gives = priority(child, growKey) == wanted;
+                        } else {
+                            Insets m = insets(child, marginKey);
+                            double most = horizontal ? pane.computeChildMaxAreaWidth(child, m, cross)
+                                    : pane.computeChildMaxAreaHeight(child, m, cross);
+                            gives = most > sizes[i] + 1;
+                        }
+                        some[i] = gives ? limits[i] : Double.NaN;
+                    }
+                    remaining = distribute(pane, sizes, some, remaining);
+                }
+            }
+            remaining = distribute(pane, sizes, limits, remaining);
+        } else {
+            for (int pass = 0; pass < 2; pass++) {
+                Priority wanted = pass == 0 ? Priority.ALWAYS : Priority.SOMETIMES;
+                double[] limits = new double[sizes.length];
+                for (int i = 0; i < limits.length; i++) {
+                    Node child = children.get(i);
+                    if (priority(child, growKey) == wanted) {
+                        Insets m = insets(child, marginKey);
+                        limits[i] = horizontal ? pane.computeChildMaxAreaWidth(child, m, cross)
+                                : pane.computeChildMaxAreaHeight(child, m, cross);
+                    } else {
+                        limits[i] = Double.NaN;
+                    }
+                }
+                remaining = distribute(pane, sizes, limits, remaining);
+            }
+        }
+        return content + extra - remaining;
+    }
+
+    /// Returns the largest area across a box that its children ask for.
+    static double maxCross(Region pane, List<Node> children, boolean horizontal, Object marginKey, double[] along,
+            boolean minimum) {
+        double max = 0;
+        for (int i = 0; i < children.size(); i++) {
+            Node child = children.get(i);
+            Insets m = insets(child, marginKey);
+            double given = along == null ? -1 : along[i];
+            double v;
+            if (horizontal) {
+                v = minimum ? pane.computeChildMinAreaHeight(child, m, given)
+                        : pane.computeChildPrefAreaHeight(child, m, given);
+            } else {
+                v = minimum ? pane.computeChildMinAreaWidth(child, m, given)
+                        : pane.computeChildPrefAreaWidth(child, m, given);
+            }
+            if (v > max) {
+                max = v;
+            }
+        }
+        return max;
+    }
+
+    /// Returns the content bias of the first managed child that has one.
+    static Orientation bias(List<Node> children) {
+        Orientation found = null;
+        for (int i = 0; i < children.size(); i++) {
+            Orientation b = children.get(i).getContentBias();
+            if (b != null) {
+                found = b;
+                if (b == Orientation.HORIZONTAL) {
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/Pane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/Pane.java
new file mode 100644
index 00000000000..c749b6c94e3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/Pane.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+
+/// A region whose children the application positions itself: layout only
+/// gives each resizable child its preferred size and leaves it at its
+/// `layoutX`, `layoutY`. The base of the layout panes.
+public class Pane extends Region {
+
+    /// Creates an empty pane.
+    public Pane() {
+    }
+
+    /// Creates a pane with children.
+    public Pane(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    @Override
+    public ObservableList<Node> getChildren() {
+        return super.getChildren();
+    }
+
+    /// Stores a layout constraint on a node, or removes it with `null`.
+    static void setConstraint(Node node, Object key, Object value) {
+        if (value == null) {
+            if (node.hasProperties()) {
+                node.getProperties().remove(key);
+            }
+        } else {
+            node.getProperties().put(key, value);
+        }
+        if (node.getParent() != null) {
+            node.getParent().requestLayout();
+        }
+    }
+
+    /// Returns a layout constraint of a node, or `null`.
+    static Object getConstraint(Node node, Object key) {
+        return node.hasProperties() ? node.getProperties().get(key) : null;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/Priority.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/Priority.java
new file mode 100644
index 00000000000..afb08c76f9d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/Priority.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+/// How eagerly a node, a row or a column takes space its container has
+/// left over.
+public enum Priority {
+    /// Takes extra space, sharing it with the others that always do.
+    ALWAYS,
+    /// Takes extra space only when nothing asks for it [#ALWAYS].
+    SOMETIMES,
+    /// Keeps its preferred size.
+    NEVER;
+
+    /// Returns the more eager of two priorities.
+    public static Priority max(Priority a, Priority b) {
+        if (a == ALWAYS || b == ALWAYS) {
+            return ALWAYS;
+        } else if (a == SOMETIMES || b == SOMETIMES) {
+            return SOMETIMES;
+        }
+        return NEVER;
+    }
+
+    /// Returns the less eager of two priorities.
+    public static Priority min(Priority a, Priority b) {
+        if (a == NEVER || b == NEVER) {
+            return NEVER;
+        } else if (a == SOMETIMES || b == SOMETIMES) {
+            return SOMETIMES;
+        }
+        return ALWAYS;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/Region.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/Region.java
new file mode 100644
index 00000000000..e1f02d7bcea
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/Region.java
@@ -0,0 +1,1405 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.StyleList;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.SVGPath;
+import javafx.scene.shape.Shape;
+
+/// A parent with a size of its own, a background, a border and padding;
+/// the base of the layout panes and of the controls.
+///
+/// A region is resizable: its parent gives it a width and a height
+/// between what `minWidth`/`minHeight` and `maxWidth`/`maxHeight` answer,
+/// preferably `prefWidth`/`prefHeight`. Each of those is the value set
+/// through the matching property, or computed from the content while the
+/// property holds [#USE_COMPUTED_SIZE].
+///
+/// #### Painting
+///
+/// Each fill of the background is drawn in order, then each stroke of
+/// the border. A border is always drawn inside the region's bounds, and a
+/// stroke whose four sides differ in paint or width is drawn as four
+/// straight sides without corner radii. Background images are not
+/// supported.
+///
+/// #### Styling
+///
+/// The names a region takes through `cn1ApplyStyle` are listed in
+/// `com.codename1.fxcompat.runtime.StyleTarget`. The background and
+/// border names are an overlay: `-fx-background-color` replaces the
+/// fills of the background the application set with one fill,
+/// `-fx-background-radius` and `-fx-background-insets` change the radii
+/// and insets of every fill, and the `-fx-border-*` names do the same to
+/// the first stroke of the border. Withdrawing them all shows what the
+/// application set again. `getBackground()` and `getBorder()` answer the
+/// result of the overlay.
+public class Region extends Parent {
+
+    /// The size a region computes from its content.
+    public static final double USE_COMPUTED_SIZE = -1;
+
+    /// For a minimum or maximum: the same as the preferred size.
+    public static final double USE_PREF_SIZE = Double.NEGATIVE_INFINITY;
+
+    private static final int SIZE = Dirty.USER << 8;
+    private static final int LOOK = Dirty.USER << 9;
+    private static final int EDGE = Dirty.USER << 10;
+
+    private final ReadOnlyDoubleWrapper width = new ReadOnlyDoubleWrapper(this, "width", 0);
+    private final ReadOnlyDoubleWrapper height = new ReadOnlyDoubleWrapper(this, "height", 0);
+    private final DoubleProperty minWidth = new FxDouble(this, "minWidth", USE_COMPUTED_SIZE, Dirty.LAYOUT);
+    private final DoubleProperty minHeight = new FxDouble(this, "minHeight", USE_COMPUTED_SIZE, Dirty.LAYOUT);
+    private final DoubleProperty prefWidth = new FxDouble(this, "prefWidth", USE_COMPUTED_SIZE, Dirty.LAYOUT);
+    private final DoubleProperty prefHeight = new FxDouble(this, "prefHeight", USE_COMPUTED_SIZE, Dirty.LAYOUT);
+    private final DoubleProperty maxWidth = new FxDouble(this, "maxWidth", USE_COMPUTED_SIZE, Dirty.LAYOUT);
+    private final DoubleProperty maxHeight = new FxDouble(this, "maxHeight", USE_COMPUTED_SIZE, Dirty.LAYOUT);
+    private final ObjectProperty<Insets> padding = new FxObject<Insets>(this, "padding", Insets.EMPTY, SIZE);
+    private final ObjectProperty<Background> background = new FxObject<Background>(this, "background", null, LOOK);
+    private final ObjectProperty<Border> border = new FxObject<Border>(this, "border", null, EDGE | SIZE);
+    private final BooleanProperty snapToPixel = new FxBoolean(this, "snapToPixel", true, Dirty.LAYOUT);
+    private final ObjectProperty<Shape> shape = new FxObject<Shape>(this, "shape", null, Dirty.PAINT);
+    private final BooleanProperty scaleShape = new FxBoolean(this, "scaleShape", true, Dirty.PAINT);
+    private final BooleanProperty centerShape = new FxBoolean(this, "centerShape", true, Dirty.PAINT);
+
+    private Background baseBackground;
+    private Border baseBorder;
+    private boolean composing;
+    private Object styleFill;
+    private Object styleFillRadii;
+    private Object styleFillInsets;
+    private Object styleStroke;
+    private Object styleStrokeWidths;
+    private Object styleStrokeRadii;
+    private Object styleStrokeStyle;
+    private Object styleStrokeInsets;
+    // The pictures of the background and of the border, as the text a
+    // style gives; StyleImages reads them.
+    private Object styleImage;
+    private Object styleImageRepeat;
+    private Object styleImagePosition;
+    private Object styleImageSize;
+    private Object styleEdge;
+    private Object styleEdgeSlice;
+    private Object styleEdgeWidth;
+    private Object styleEdgeRepeat;
+    private Object styleEdgeInsets;
+    private Insets insetsCache;
+
+    /// Creates an empty region.
+    public Region() {
+        setPickOnBounds(true);
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        int rest = what;
+        if ((what & LOOK) != 0) {
+            if (!composing) {
+                baseBackground = background.get();
+            }
+            rest |= Dirty.PAINT;
+        }
+        if ((what & EDGE) != 0) {
+            if (!composing) {
+                baseBorder = border.get();
+            }
+            rest |= Dirty.PAINT;
+        }
+        if ((what & SIZE) != 0) {
+            insetsCache = null;
+            rest |= Dirty.LAYOUT;
+            requestLayout();
+        }
+        super.cn1Invalidated(rest);
+    }
+
+    @Override
+    protected void cn1RequestLayout() {
+        // A change of this region's own constraints needs both this region
+        // and its parent laid out again.
+        requestLayout();
+    }
+
+    /// The standard theme gives the root of a scene the background colour
+    /// of the theme, the light grey a JavaFX window has behind its
+    /// controls; the white fill of the scene shows only under a root that
+    /// is not a region. A sheet that gives the root a background of its
+    /// own wins, as every rule does over these.
+    @Override
+    public String cn1DefaultStyle() {
+        Scene scene = getScene();
+        return scene != null && scene.getRoot() == this ? "-fx-background-color: -fx-background;" : null;
+    }
+
+    // -------------------------------------------------------------- size
+
+    @Override
+    public boolean isResizable() {
+        return true;
+    }
+
+    @Override
+    protected boolean cn1SizedByChildren() {
+        return false;
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        return new BoundingBox(0, 0, getWidth(), getHeight());
+    }
+
+    @Override
+    public void resize(double width, double height) {
+        double w = width < 0 || Double.isNaN(width) ? 0 : width;
+        double h = height < 0 || Double.isNaN(height) ? 0 : height;
+        if (w != getWidth() || h != getHeight()) {
+            this.width.set(w);
+            this.height.set(h);
+            cn1MarkNeedsLayout();
+            cn1ResizedGeometry();
+        }
+    }
+
+    private void cn1ResizedGeometry() {
+        cn1GeometryChanged();
+    }
+
+    /// Returns the width the parent gave this region.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// The width the parent gave this region.
+    public final ReadOnlyDoubleProperty widthProperty() {
+        return width.getReadOnlyProperty();
+    }
+
+    /// Sets the width; for subclasses.
+    protected void setWidth(double value) {
+        resize(value, getHeight());
+    }
+
+    /// Returns the height the parent gave this region.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// The height the parent gave this region.
+    public final ReadOnlyDoubleProperty heightProperty() {
+        return height.getReadOnlyProperty();
+    }
+
+    /// Sets the height; for subclasses.
+    protected void setHeight(double value) {
+        resize(getWidth(), value);
+    }
+
+    /// Returns the minimum width override.
+    public final double getMinWidth() {
+        return minWidth.get();
+    }
+
+    /// Sets the minimum width, [#USE_COMPUTED_SIZE] or [#USE_PREF_SIZE].
+    public final void setMinWidth(double value) {
+        minWidth.set(value);
+    }
+
+    /// The minimum width override.
+    public final DoubleProperty minWidthProperty() {
+        return minWidth;
+    }
+
+    /// Returns the minimum height override.
+    public final double getMinHeight() {
+        return minHeight.get();
+    }
+
+    /// Sets the minimum height, [#USE_COMPUTED_SIZE] or [#USE_PREF_SIZE].
+    public final void setMinHeight(double value) {
+        minHeight.set(value);
+    }
+
+    /// The minimum height override.
+    public final DoubleProperty minHeightProperty() {
+        return minHeight;
+    }
+
+    /// Sets both minimum overrides.
+    public void setMinSize(double minWidth, double minHeight) {
+        setMinWidth(minWidth);
+        setMinHeight(minHeight);
+    }
+
+    /// Returns the preferred width override.
+    public final double getPrefWidth() {
+        return prefWidth.get();
+    }
+
+    /// Sets the preferred width, or [#USE_COMPUTED_SIZE].
+    public final void setPrefWidth(double value) {
+        prefWidth.set(value);
+    }
+
+    /// The preferred width override.
+    public final DoubleProperty prefWidthProperty() {
+        return prefWidth;
+    }
+
+    /// Returns the preferred height override.
+    public final double getPrefHeight() {
+        return prefHeight.get();
+    }
+
+    /// Sets the preferred height, or [#USE_COMPUTED_SIZE].
+    public final void setPrefHeight(double value) {
+        prefHeight.set(value);
+    }
+
+    /// The preferred height override.
+    public final DoubleProperty prefHeightProperty() {
+        return prefHeight;
+    }
+
+    /// Sets both preferred overrides.
+    public void setPrefSize(double prefWidth, double prefHeight) {
+        setPrefWidth(prefWidth);
+        setPrefHeight(prefHeight);
+    }
+
+    /// Returns the maximum width override.
+    public final double getMaxWidth() {
+        return maxWidth.get();
+    }
+
+    /// Sets the maximum width, [#USE_COMPUTED_SIZE] or [#USE_PREF_SIZE].
+    public final void setMaxWidth(double value) {
+        maxWidth.set(value);
+    }
+
+    /// The maximum width override.
+    public final DoubleProperty maxWidthProperty() {
+        return maxWidth;
+    }
+
+    /// Returns the maximum height override.
+    public final double getMaxHeight() {
+        return maxHeight.get();
+    }
+
+    /// Sets the maximum height, [#USE_COMPUTED_SIZE] or [#USE_PREF_SIZE].
+    public final void setMaxHeight(double value) {
+        maxHeight.set(value);
+    }
+
+    /// The maximum height override.
+    public final DoubleProperty maxHeightProperty() {
+        return maxHeight;
+    }
+
+    /// Sets both maximum overrides.
+    public void setMaxSize(double maxWidth, double maxHeight) {
+        setMaxWidth(maxWidth);
+        setMaxHeight(maxHeight);
+    }
+
+    @Override
+    public final double prefWidth(double height) {
+        double override = getPrefWidth();
+        if (override == USE_COMPUTED_SIZE) {
+            return super.prefWidth(height);
+        }
+        return Double.isNaN(override) || override < 0 ? 0 : override;
+    }
+
+    @Override
+    public final double prefHeight(double width) {
+        double override = getPrefHeight();
+        if (override == USE_COMPUTED_SIZE) {
+            return super.prefHeight(width);
+        }
+        return Double.isNaN(override) || override < 0 ? 0 : override;
+    }
+
+    @Override
+    public final double minWidth(double height) {
+        double override = getMinWidth();
+        if (override == USE_COMPUTED_SIZE) {
+            return super.minWidth(height);
+        } else if (override == USE_PREF_SIZE) {
+            return prefWidth(height);
+        }
+        return Double.isNaN(override) || override < 0 ? 0 : override;
+    }
+
+    @Override
+    public final double minHeight(double width) {
+        double override = getMinHeight();
+        if (override == USE_COMPUTED_SIZE) {
+            return super.minHeight(width);
+        } else if (override == USE_PREF_SIZE) {
+            return prefHeight(width);
+        }
+        return Double.isNaN(override) || override < 0 ? 0 : override;
+    }
+
+    @Override
+    public final double maxWidth(double height) {
+        double override = getMaxWidth();
+        if (override == USE_COMPUTED_SIZE) {
+            return computeMaxWidth(height);
+        } else if (override == USE_PREF_SIZE) {
+            return prefWidth(height);
+        }
+        return Double.isNaN(override) || override < 0 ? 0 : override;
+    }
+
+    @Override
+    public final double maxHeight(double width) {
+        double override = getMaxHeight();
+        if (override == USE_COMPUTED_SIZE) {
+            return computeMaxHeight(width);
+        } else if (override == USE_PREF_SIZE) {
+            return prefHeight(width);
+        }
+        return Double.isNaN(override) || override < 0 ? 0 : override;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + super.computePrefWidth(height) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        return in.getTop() + super.computePrefHeight(width) + in.getBottom();
+    }
+
+    /// Computes the maximum width; unbounded unless overridden.
+    protected double computeMaxWidth(double height) {
+        return Double.MAX_VALUE;
+    }
+
+    /// Computes the maximum height; unbounded unless overridden.
+    protected double computeMaxHeight(double width) {
+        return Double.MAX_VALUE;
+    }
+
+    @Override
+    public boolean contains(double localX, double localY) {
+        return localX >= 0 && localY >= 0 && localX <= getWidth() && localY <= getHeight();
+    }
+
+    @Override
+    protected boolean cn1PickSelf(double x, double y) {
+        return contains(x, y);
+    }
+
+    // ------------------------------------------------ padding and insets
+
+    /// Returns the space kept free inside the border.
+    public final Insets getPadding() {
+        Insets p = padding.get();
+        return p == null ? Insets.EMPTY : p;
+    }
+
+    /// Sets the space kept free inside the border.
+    public final void setPadding(Insets value) {
+        padding.set(value);
+    }
+
+    /// The space kept free inside the border.
+    public final ObjectProperty<Insets> paddingProperty() {
+        return padding;
+    }
+
+    /// Returns the space between the edges and the content: the border's
+    /// insets plus the padding.
+    public final Insets getInsets() {
+        if (insetsCache == null) {
+            Insets p = getPadding();
+            Border b = getBorder();
+            Insets bi = b == null ? Insets.EMPTY : b.getInsets();
+            insetsCache = new Insets(snapSizeY(p.getTop() + bi.getTop()), snapSizeX(p.getRight() + bi.getRight()),
+                    snapSizeY(p.getBottom() + bi.getBottom()), snapSizeX(p.getLeft() + bi.getLeft()));
+        }
+        return insetsCache;
+    }
+
+    /// Returns the top inset on a pixel boundary.
+    public final double snappedTopInset() {
+        return getInsets().getTop();
+    }
+
+    /// Returns the bottom inset on a pixel boundary.
+    public final double snappedBottomInset() {
+        return getInsets().getBottom();
+    }
+
+    /// Returns the left inset on a pixel boundary.
+    public final double snappedLeftInset() {
+        return getInsets().getLeft();
+    }
+
+    /// Returns the right inset on a pixel boundary.
+    public final double snappedRightInset() {
+        return getInsets().getRight();
+    }
+
+    /// Returns whether layout rounds to device pixels.
+    public final boolean isSnapToPixel() {
+        return snapToPixel.get();
+    }
+
+    /// Sets whether layout rounds to device pixels.
+    public final void setSnapToPixel(boolean value) {
+        snapToPixel.set(value);
+    }
+
+    /// Whether layout rounds to device pixels.
+    public final BooleanProperty snapToPixelProperty() {
+        return snapToPixel;
+    }
+
+    /// Rounds a horizontal gap to device pixels when snapping.
+    public double snapSpaceX(double value) {
+        return isSnapToPixel() ? Units.snap(value) : value;
+    }
+
+    /// Rounds a vertical gap to device pixels when snapping.
+    public double snapSpaceY(double value) {
+        return isSnapToPixel() ? Units.snap(value) : value;
+    }
+
+    /// Grows a width to whole device pixels when snapping.
+    public double snapSizeX(double value) {
+        return isSnapToPixel() ? Units.snapSize(value) : value;
+    }
+
+    /// Grows a height to whole device pixels when snapping.
+    public double snapSizeY(double value) {
+        return isSnapToPixel() ? Units.snapSize(value) : value;
+    }
+
+    /// Rounds an x position to device pixels when snapping.
+    public double snapPositionX(double value) {
+        return isSnapToPixel() ? Units.snap(value) : value;
+    }
+
+    /// Rounds a y position to device pixels when snapping.
+    public double snapPositionY(double value) {
+        return isSnapToPixel() ? Units.snap(value) : value;
+    }
+
+    // ------------------------------------------------- layout utilities
+
+    static double boundedSize(double min, double pref, double max) {
+        double a = pref >= min ? pref : min;
+        double b = min >= max ? min : max;
+        return a <= b ? a : b;
+    }
+
+    /// Returns the width a child takes in an area of a given height, less
+    /// its margin: its preferred width kept between its minimum and
+    /// maximum.
+    double computeChildPrefAreaWidth(Node child, Insets margin, double height) {
+        double left = margin == null ? 0 : snapSpaceX(margin.getLeft());
+        double right = margin == null ? 0 : snapSpaceX(margin.getRight());
+        double alt = -1;
+        if (height != -1 && child.isResizable() && child.getContentBias() == Orientation.VERTICAL) {
+            double top = margin == null ? 0 : snapSpaceY(margin.getTop());
+            double bottom = margin == null ? 0 : snapSpaceY(margin.getBottom());
+            alt = boundedSize(child.minHeight(-1), height - top - bottom, child.maxHeight(-1));
+        }
+        return left + snapSizeX(boundedSize(child.minWidth(alt), child.prefWidth(alt), child.maxWidth(alt))) + right;
+    }
+
+    double computeChildPrefAreaHeight(Node child, Insets margin, double width) {
+        double top = margin == null ? 0 : snapSpaceY(margin.getTop());
+        double bottom = margin == null ? 0 : snapSpaceY(margin.getBottom());
+        double alt = -1;
+        if (width != -1 && child.isResizable() && child.getContentBias() == Orientation.HORIZONTAL) {
+            double left = margin == null ? 0 : snapSpaceX(margin.getLeft());
+            double right = margin == null ? 0 : snapSpaceX(margin.getRight());
+            alt = boundedSize(child.minWidth(-1), width - left - right, child.maxWidth(-1));
+        }
+        return top + snapSizeY(boundedSize(child.minHeight(alt), child.prefHeight(alt), child.maxHeight(alt)))
+                + bottom;
+    }
+
+    double computeChildMinAreaWidth(Node child, Insets margin, double height) {
+        double left = margin == null ? 0 : snapSpaceX(margin.getLeft());
+        double right = margin == null ? 0 : snapSpaceX(margin.getRight());
+        double alt = -1;
+        if (height != -1 && child.isResizable() && child.getContentBias() == Orientation.VERTICAL) {
+            double top = margin == null ? 0 : snapSpaceY(margin.getTop());
+            double bottom = margin == null ? 0 : snapSpaceY(margin.getBottom());
+            alt = boundedSize(child.minHeight(-1), height - top - bottom, child.maxHeight(-1));
+        }
+        return left + snapSizeX(child.minWidth(alt)) + right;
+    }
+
+    double computeChildMinAreaHeight(Node child, Insets margin, double width) {
+        double top = margin == null ? 0 : snapSpaceY(margin.getTop());
+        double bottom = margin == null ? 0 : snapSpaceY(margin.getBottom());
+        double alt = -1;
+        if (width != -1 && child.isResizable() && child.getContentBias() == Orientation.HORIZONTAL) {
+            double left = margin == null ? 0 : snapSpaceX(margin.getLeft());
+            double right = margin == null ? 0 : snapSpaceX(margin.getRight());
+            alt = boundedSize(child.minWidth(-1), width - left - right, child.maxWidth(-1));
+        }
+        return top + snapSizeY(child.minHeight(alt)) + bottom;
+    }
+
+    double computeChildMaxAreaWidth(Node child, Insets margin, double height) {
+        double max = child.maxWidth(-1);
+        if (max == Double.MAX_VALUE) {
+            return max;
+        }
+        double left = margin == null ? 0 : snapSpaceX(margin.getLeft());
+        double right = margin == null ? 0 : snapSpaceX(margin.getRight());
+        return left + snapSizeX(boundedSize(child.minWidth(-1), max, Double.MAX_VALUE)) + right;
+    }
+
+    double computeChildMaxAreaHeight(Node child, Insets margin, double width) {
+        double max = child.maxHeight(-1);
+        if (max == Double.MAX_VALUE) {
+            return max;
+        }
+        double top = margin == null ? 0 : snapSpaceY(margin.getTop());
+        double bottom = margin == null ? 0 : snapSpaceY(margin.getBottom());
+        return top + snapSizeY(boundedSize(child.minHeight(-1), max, Double.MAX_VALUE)) + bottom;
+    }
+
+    /// Sizes a child to fit an area and positions it there.
+    protected void layoutInArea(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
+            double areaBaselineOffset, HPos halignment, VPos valignment) {
+        layoutInArea(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset, Insets.EMPTY, true, true,
+                halignment, valignment);
+    }
+
+    /// Sizes a child to fit an area less a margin and positions it there.
+    protected void layoutInArea(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
+            double areaBaselineOffset, Insets margin, HPos halignment, VPos valignment) {
+        layoutInArea(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset, margin, true, true, halignment,
+                valignment);
+    }
+
+    /// Sizes a child to an area less a margin and positions it there. A
+    /// resizable child fills the area in each direction asked for, up to
+    /// its maximum; otherwise it takes its preferred size, never more
+    /// than the area unless its minimum is larger.
+    protected void layoutInArea(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
+            double areaBaselineOffset, Insets margin, boolean fillWidth, boolean fillHeight, HPos halignment,
+            VPos valignment) {
+        Insets m = margin == null ? Insets.EMPTY : margin;
+        double top = snapSpaceY(m.getTop());
+        double bottom = snapSpaceY(m.getBottom());
+        double left = snapSpaceX(m.getLeft());
+        double right = snapSpaceX(m.getRight());
+        if (valignment == VPos.BASELINE) {
+            double bo = child.getBaselineOffset();
+            if (bo == BASELINE_OFFSET_SAME_AS_HEIGHT) {
+                if (child.isResizable()) {
+                    bottom += snapSpaceY(areaHeight - areaBaselineOffset);
+                } else {
+                    top = snapSpaceY(areaBaselineOffset - child.getLayoutBounds().getHeight());
+                }
+            } else {
+                top = snapSpaceY(areaBaselineOffset - bo);
+            }
+        }
+        if (child.isResizable()) {
+            double innerW = Math.max(0, areaWidth - left - right);
+            double innerH = Math.max(0, areaHeight - top - bottom);
+            Orientation bias = child.getContentBias();
+            double w;
+            double h;
+            if (bias == Orientation.HORIZONTAL) {
+                w = areaSize(innerW, child.minWidth(-1), child.prefWidth(-1), child.maxWidth(-1), fillWidth);
+                h = areaSize(innerH, child.minHeight(w), child.prefHeight(w), child.maxHeight(w), fillHeight);
+            } else if (bias == Orientation.VERTICAL) {
+                h = areaSize(innerH, child.minHeight(-1), child.prefHeight(-1), child.maxHeight(-1), fillHeight);
+                w = areaSize(innerW, child.minWidth(h), child.prefWidth(h), child.maxWidth(h), fillWidth);
+            } else {
+                w = areaSize(innerW, child.minWidth(-1), child.prefWidth(-1), child.maxWidth(-1), fillWidth);
+                h = areaSize(innerH, child.minHeight(-1), child.prefHeight(-1), child.maxHeight(-1), fillHeight);
+            }
+            child.resize(snapSizeX(w), snapSizeY(h));
+        }
+        position(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset, top, right, bottom, left,
+                halignment, valignment);
+    }
+
+    private static double areaSize(double available, double min, double pref, double max, boolean fill) {
+        double wanted = fill ? available : Math.min(available, pref);
+        return boundedSize(min, wanted, max);
+    }
+
+    /// Positions a child in an area without resizing it.
+    protected void positionInArea(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
+            double areaBaselineOffset, HPos halignment, VPos valignment) {
+        position(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset, 0, 0, 0, 0, halignment, valignment);
+    }
+
+    /// Positions a child in an area less a margin without resizing it;
+    /// for the panes of this package.
+    void positionInMargin(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
+            Insets margin, HPos halignment, VPos valignment) {
+        Insets m = margin == null ? Insets.EMPTY : margin;
+        position(child, areaX, areaY, areaWidth, areaHeight, 0, snapSpaceY(m.getTop()), snapSpaceX(m.getRight()),
+                snapSpaceY(m.getBottom()), snapSpaceX(m.getLeft()), halignment, valignment);
+    }
+
+    private void position(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
+            double areaBaselineOffset, double top, double right, double bottom, double left, HPos hpos, VPos vpos) {
+        Bounds lb = child.getLayoutBounds();
+        double w = lb.getWidth();
+        double h = lb.getHeight();
+        double x = left;
+        if (hpos == HPos.CENTER) {
+            x = left + (areaWidth - left - right - w) / 2;
+        } else if (hpos == HPos.RIGHT) {
+            x = areaWidth - right - w;
+        }
+        double y = top;
+        if (vpos == VPos.CENTER) {
+            y = top + (areaHeight - top - bottom - h) / 2;
+        } else if (vpos == VPos.BOTTOM) {
+            y = areaHeight - bottom - h;
+        } else if (vpos == VPos.BASELINE) {
+            double bo = child.getBaselineOffset();
+            y = bo == BASELINE_OFFSET_SAME_AS_HEIGHT ? areaBaselineOffset - h : areaBaselineOffset - bo;
+        }
+        child.relocate(snapPositionX(areaX + x), snapPositionY(areaY + y));
+    }
+
+    // -------------------------------------------------------------- shape
+
+    /// Returns the shape this region takes its form from, `null` for the
+    /// rectangle it is.
+    public final Shape getShape() {
+        return shape.get();
+    }
+
+    /// Gives this region the form of a shape: its background fills and
+    /// its border are drawn as that shape instead of as rectangles. The
+    /// shape is read when the region paints; it is not a child of the
+    /// region, and changing it afterwards shows at the next repaint of
+    /// the region, not by itself. The size the region computes for
+    /// itself does not change with the shape.
+    public final void setShape(Shape value) {
+        shape.set(value);
+    }
+
+    /// The shape this region takes its form from.
+    public final ObjectProperty<Shape> shapeProperty() {
+        return shape;
+    }
+
+    /// Returns whether the shape is stretched to the size of the region.
+    public final boolean isScaleShape() {
+        return scaleShape.get();
+    }
+
+    /// Sets whether the shape is stretched to the size of the region.
+    public final void setScaleShape(boolean value) {
+        scaleShape.set(value);
+    }
+
+    /// Whether the shape is stretched to the size of the region.
+    public final BooleanProperty scaleShapeProperty() {
+        return scaleShape;
+    }
+
+    /// Returns whether a shape that is not stretched is centred.
+    public final boolean isCenterShape() {
+        return centerShape.get();
+    }
+
+    /// Sets whether a shape that is not stretched is centred.
+    public final void setCenterShape(boolean value) {
+        centerShape.set(value);
+    }
+
+    /// Whether a shape that is not stretched is centred.
+    public final BooleanProperty centerShapeProperty() {
+        return centerShape;
+    }
+
+    // --------------------------------------------- background and border
+
+    /// Returns the background, or `null`.
+    public final Background getBackground() {
+        return background.get();
+    }
+
+    /// Sets the background.
+    public final void setBackground(Background value) {
+        background.set(value);
+    }
+
+    /// The background of this region.
+    public final ObjectProperty<Background> backgroundProperty() {
+        return background;
+    }
+
+    /// Returns the border, or `null`.
+    public final Border getBorder() {
+        return border.get();
+    }
+
+    /// Sets the border.
+    public final void setBorder(Border value) {
+        border.set(value);
+    }
+
+    /// The border of this region.
+    public final ObjectProperty<Border> borderProperty() {
+        return border;
+    }
+
+    private static CornerRadii radii(Object value, CornerRadii fallback) {
+        if (value instanceof CornerRadii) {
+            return (CornerRadii) value;
+        } else if (value instanceof Number) {
+            return new CornerRadii(((Number) value).doubleValue());
+        }
+        return fallback;
+    }
+
+    private static Insets insets(Object value, Insets fallback) {
+        if (value instanceof Insets) {
+            return (Insets) value;
+        } else if (value instanceof Number) {
+            return new Insets(((Number) value).doubleValue());
+        }
+        return fallback;
+    }
+
+    private static Paint side(StyleList sides, int index) {
+        Object p = sides.get(index);
+        return p instanceof Paint ? (Paint) p : null;
+    }
+
+    /// Whether `value` is what `single` accepts, or layers that each are.
+    private static boolean layersOf(Object value, int what) {
+        for (int i = 0; i < StyleList.layers(value); i++) {
+            Object v = StyleList.layer(value, i);
+            boolean ok;
+            switch (what) {
+                case 0:
+                    ok = v instanceof Paint;
+                    break;
+                case 1:
+                    ok = v instanceof Paint || (v instanceof StyleList && ((StyleList) v).isSides());
+                    break;
+                case 2:
+                    ok = v instanceof CornerRadii || v instanceof Number;
+                    break;
+                case 3:
+                    ok = v instanceof Insets || v instanceof Number || v instanceof BorderWidths;
+                    break;
+                default:
+                    ok = strokeStyle(v) != null;
+                    break;
+            }
+            if (!ok) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void compose() {
+        composing = true;
+        try {
+            Background bg = baseBackground;
+            if (styleFill != null || styleFillRadii != null || styleFillInsets != null) {
+                List<BackgroundFill> fills = bg == null ? null : bg.getFills();
+                if (styleFill != null) {
+                    // One fill per colour; a colour without radii or
+                    // insets of its own takes those of the last layer
+                    // that has them.
+                    BackgroundFill first = fills == null || fills.isEmpty() ? null : fills.get(0);
+                    BackgroundFill[] made = new BackgroundFill[StyleList.layers(styleFill)];
+                    for (int i = 0; i < made.length; i++) {
+                        Object paint = StyleList.layer(styleFill, i);
+                        made[i] = new BackgroundFill(paint instanceof Paint ? (Paint) paint : null,
+                                radii(StyleList.layer(styleFillRadii, i),
+                                        first == null ? CornerRadii.EMPTY : first.getRadii()),
+                                insets(StyleList.layer(styleFillInsets, i),
+                                        first == null ? Insets.EMPTY : first.getInsets()));
+                    }
+                    bg = new Background(made);
+                } else if (fills != null && !fills.isEmpty()) {
+                    BackgroundFill[] changed = new BackgroundFill[fills.size()];
+                    for (int i = 0; i < changed.length; i++) {
+                        BackgroundFill f = fills.get(i);
+                        changed[i] = new BackgroundFill(f.getFill(),
+                                radii(StyleList.layer(styleFillRadii, i), f.getRadii()),
+                                insets(StyleList.layer(styleFillInsets, i), f.getInsets()));
+                    }
+                    bg = new Background(changed);
+                }
+            }
+            if (styleImage != null) {
+                BackgroundImage[] pictures = StyleImages.backgrounds(styleImage, styleImageRepeat,
+                        styleImagePosition, styleImageSize);
+                if (pictures.length > 0 || (bg != null && !bg.getImages().isEmpty())) {
+                    bg = new Background(bg == null ? null : bg.getFills().toArray(new BackgroundFill[0]), pictures);
+                }
+            }
+            background.set(bg);
+            Border b = baseBorder;
+            if (styleStroke != null || styleStrokeWidths != null || styleStrokeRadii != null
+                    || styleStrokeStyle != null || styleStrokeInsets != null) {
+                List<BorderStroke> strokes = b == null ? null : b.getStrokes();
+                BorderStroke first = strokes == null || strokes.isEmpty() ? null : strokes.get(0);
+                // One stroke per colour, as one fill per colour above.
+                BorderStroke[] made = new BorderStroke[StyleList.layers(styleStroke)];
+                int count = 0;
+                for (int i = 0; i < made.length; i++) {
+                    Object paint = StyleList.layer(styleStroke, i);
+                    Paint top = first == null ? null : first.getTopStroke();
+                    Paint right = first == null ? null : first.getRightStroke();
+                    Paint bottom = first == null ? null : first.getBottomStroke();
+                    Paint left = first == null ? null : first.getLeftStroke();
+                    if (paint instanceof Paint) {
+                        top = (Paint) paint;
+                        right = top;
+                        bottom = top;
+                        left = top;
+                    } else if (paint instanceof StyleList && ((StyleList) paint).size() == 4) {
+                        StyleList sides = (StyleList) paint;
+                        top = side(sides, 0);
+                        right = side(sides, 1);
+                        bottom = side(sides, 2);
+                        left = side(sides, 3);
+                    }
+                    if (top == null && right == null && bottom == null && left == null) {
+                        continue;
+                    }
+                    BorderWidths widths = first == null ? BorderWidths.DEFAULT : first.getWidths();
+                    Object w = StyleList.layer(styleStrokeWidths, i);
+                    if (w instanceof BorderWidths) {
+                        widths = (BorderWidths) w;
+                    } else if (w instanceof Insets) {
+                        Insets in = (Insets) w;
+                        widths = new BorderWidths(in.getTop(), in.getRight(), in.getBottom(), in.getLeft());
+                    } else if (w instanceof Number) {
+                        widths = new BorderWidths(((Number) w).doubleValue());
+                    }
+                    BorderStrokeStyle strokeStyle = strokeStyle(StyleList.layer(styleStrokeStyle, i));
+                    if (strokeStyle == null) {
+                        strokeStyle = first == null ? BorderStrokeStyle.SOLID : first.getTopStyle();
+                    }
+                    made[count++] = new BorderStroke(top, right, bottom, left, strokeStyle, strokeStyle,
+                            strokeStyle, strokeStyle,
+                            radii(StyleList.layer(styleStrokeRadii, i),
+                                    first == null ? CornerRadii.EMPTY : first.getRadii()),
+                            widths,
+                            insets(StyleList.layer(styleStrokeInsets, i),
+                                    first == null ? Insets.EMPTY : first.getInsets()));
+                }
+                if (count > 0) {
+                    BorderStroke[] kept = new BorderStroke[count];
+                    System.arraycopy(made, 0, kept, 0, count);
+                    b = new Border(kept);
+                }
+            }
+            if (styleEdge != null) {
+                BorderImage[] pictures = StyleImages.borders(styleEdge, styleEdgeSlice, styleEdgeWidth,
+                        styleEdgeRepeat, styleEdgeInsets);
+                if (pictures.length > 0 || (b != null && !b.getImages().isEmpty())) {
+                    b = new Border(b == null ? null : b.getStrokes().toArray(new BorderStroke[0]), pictures);
+                }
+            }
+            border.set(b);
+        } finally {
+            composing = false;
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-background-color".equals(property)) {
+            return styleFill;
+        } else if ("-fx-background-radius".equals(property)) {
+            return styleFillRadii;
+        } else if ("-fx-background-insets".equals(property)) {
+            return styleFillInsets;
+        } else if ("-fx-border-color".equals(property)) {
+            return styleStroke;
+        } else if ("-fx-border-width".equals(property)) {
+            return styleStrokeWidths;
+        } else if ("-fx-border-radius".equals(property)) {
+            return styleStrokeRadii;
+        } else if ("-fx-border-style".equals(property)) {
+            return styleStrokeStyle;
+        } else if ("-fx-border-insets".equals(property)) {
+            return styleStrokeInsets;
+        } else if ("-fx-background-image".equals(property)) {
+            return styleImage;
+        } else if ("-fx-background-repeat".equals(property)) {
+            return styleImageRepeat;
+        } else if ("-fx-background-position".equals(property)) {
+            return styleImagePosition;
+        } else if ("-fx-background-size".equals(property)) {
+            return styleImageSize;
+        } else if ("-fx-border-image-source".equals(property)) {
+            return styleEdge;
+        } else if ("-fx-border-image-slice".equals(property)) {
+            return styleEdgeSlice;
+        } else if ("-fx-border-image-width".equals(property)) {
+            return styleEdgeWidth;
+        } else if ("-fx-border-image-repeat".equals(property)) {
+            return styleEdgeRepeat;
+        } else if ("-fx-border-image-insets".equals(property)) {
+            return styleEdgeInsets;
+        } else if ("-fx-padding".equals(property)) {
+            return getPadding();
+        } else if ("-fx-min-width".equals(property)) {
+            return Double.valueOf(getMinWidth());
+        } else if ("-fx-pref-width".equals(property)) {
+            return Double.valueOf(getPrefWidth());
+        } else if ("-fx-max-width".equals(property)) {
+            return Double.valueOf(getMaxWidth());
+        } else if ("-fx-min-height".equals(property)) {
+            return Double.valueOf(getMinHeight());
+        } else if ("-fx-pref-height".equals(property)) {
+            return Double.valueOf(getPrefHeight());
+        } else if ("-fx-max-height".equals(property)) {
+            return Double.valueOf(getMaxHeight());
+        } else if ("-fx-snap-to-pixel".equals(property)) {
+            return Boolean.valueOf(isSnapToPixel());
+        } else if ("-fx-shape".equals(property)) {
+            return getShape();
+        } else if ("-fx-scale-shape".equals(property)) {
+            return Boolean.valueOf(isScaleShape());
+        } else if ("-fx-position-shape".equals(property)) {
+            return Boolean.valueOf(isCenterShape());
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    private static BorderStrokeStyle strokeStyle(Object value) {
+        if (value instanceof BorderStrokeStyle) {
+            return (BorderStrokeStyle) value;
+        } else if (value instanceof String) {
+            String s = ((String) value).trim();
+            if ("none".equalsIgnoreCase(s)) {
+                return BorderStrokeStyle.NONE;
+            } else if ("solid".equalsIgnoreCase(s)) {
+                return BorderStrokeStyle.SOLID;
+            } else if ("dashed".equalsIgnoreCase(s)) {
+                return BorderStrokeStyle.DASHED;
+            } else if ("dotted".equalsIgnoreCase(s)) {
+                return BorderStrokeStyle.DOTTED;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-background-color".equals(property)) {
+            if (value != null && !layersOf(value, 0)) {
+                return false;
+            }
+            styleFill = value;
+        } else if ("-fx-background-radius".equals(property)) {
+            if (value != null && !layersOf(value, 2)) {
+                return false;
+            }
+            styleFillRadii = value;
+        } else if ("-fx-background-insets".equals(property)) {
+            if (value != null && !layersOf(value, 3)) {
+                return false;
+            }
+            styleFillInsets = value;
+        } else if ("-fx-border-color".equals(property)) {
+            if (value != null && !layersOf(value, 1)) {
+                return false;
+            }
+            styleStroke = value;
+        } else if ("-fx-border-width".equals(property)) {
+            if (value != null && !layersOf(value, 3)) {
+                return false;
+            }
+            styleStrokeWidths = value;
+        } else if ("-fx-border-radius".equals(property)) {
+            if (value != null && !layersOf(value, 2)) {
+                return false;
+            }
+            styleStrokeRadii = value;
+        } else if ("-fx-border-style".equals(property)) {
+            if (value != null && !layersOf(value, 4)) {
+                return false;
+            }
+            styleStrokeStyle = value;
+        } else if ("-fx-border-insets".equals(property)) {
+            if (value != null && !layersOf(value, 3)) {
+                return false;
+            }
+            styleStrokeInsets = value;
+        } else if ("-fx-background-image".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleImage = value;
+        } else if ("-fx-background-repeat".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleImageRepeat = value;
+        } else if ("-fx-background-position".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleImagePosition = value;
+        } else if ("-fx-background-size".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleImageSize = value;
+        } else if ("-fx-border-image-source".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleEdge = value;
+        } else if ("-fx-border-image-slice".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleEdgeSlice = value;
+        } else if ("-fx-border-image-width".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleEdgeWidth = value;
+        } else if ("-fx-border-image-repeat".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleEdgeRepeat = value;
+        } else if ("-fx-border-image-insets".equals(property)) {
+            if (value != null && !(value instanceof String)) {
+                return false;
+            }
+            styleEdgeInsets = value;
+        } else if ("-fx-padding".equals(property)) {
+            Insets in = insets(value, null);
+            if (in == null) {
+                return false;
+            }
+            setPadding(in);
+            return true;
+        } else if ("-fx-snap-to-pixel".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            setSnapToPixel(((Boolean) value).booleanValue());
+            return true;
+        } else if ("-fx-shape".equals(property)) {
+            // A style sheet gives the path as text; what comes back to
+            // restore the property is the shape that was there before.
+            if (value instanceof String) {
+                SVGPath svg = new SVGPath();
+                svg.setContent((String) value);
+                setShape(svg);
+            } else if (value instanceof Shape) {
+                setShape((Shape) value);
+            } else if (value == null) {
+                setShape(null);
+            } else {
+                return false;
+            }
+            return true;
+        } else if ("-fx-scale-shape".equals(property) || "-fx-position-shape".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            if ("-fx-scale-shape".equals(property)) {
+                setScaleShape(((Boolean) value).booleanValue());
+            } else {
+                setCenterShape(((Boolean) value).booleanValue());
+            }
+            return true;
+        } else if (property.endsWith("-width") || property.endsWith("-height")) {
+            DoubleProperty target = sizeProperty(property);
+            if (target == null) {
+                return super.cn1SetStyleValue(property, value);
+            }
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            target.set(((Number) value).doubleValue());
+            return true;
+        } else {
+            return super.cn1SetStyleValue(property, value);
+        }
+        compose();
+        return true;
+    }
+
+    private DoubleProperty sizeProperty(String property) {
+        if ("-fx-min-width".equals(property)) {
+            return minWidth;
+        } else if ("-fx-pref-width".equals(property)) {
+            return prefWidth;
+        } else if ("-fx-max-width".equals(property)) {
+            return maxWidth;
+        } else if ("-fx-min-height".equals(property)) {
+            return minHeight;
+        } else if ("-fx-pref-height".equals(property)) {
+            return prefHeight;
+        } else if ("-fx-max-height".equals(property)) {
+            return maxHeight;
+        }
+        return null;
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        double w = getWidth();
+        double h = getHeight();
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        Background bg = getBackground();
+        Shape form = getShape();
+        FxPath formPath = form == null ? null : form.cn1Outline();
+        double[] formBounds = formPath == null ? null : formPath.bounds();
+        if (formBounds != null) {
+            paintShaped(renderer, formPath, formBounds, w, h);
+            return;
+        }
+        if (bg != null) {
+            List<BackgroundFill> fills = bg.getFills();
+            for (int i = 0; i < fills.size(); i++) {
+                BackgroundFill f = fills.get(i);
+                Insets in = f.getInsets();
+                double x = in.getLeft();
+                double y = in.getTop();
+                double fw = w - in.getLeft() - in.getRight();
+                double fh = h - in.getTop() - in.getBottom();
+                if (f.getFill() == null || fw <= 0 || fh <= 0) {
+                    continue;
+                }
+                CornerRadii r = f.getRadii();
+                if (isSquare(r)) {
+                    renderer.fillRect(x, y, fw, fh, f.getFill());
+                } else {
+                    renderer.fill(outline(r, x, y, fw, fh, 0), f.getFill(), x, y, fw, fh);
+                }
+            }
+            List<BackgroundImage> pictures = bg.getImages();
+            for (int i = 0; i < pictures.size(); i++) {
+                StyleImages.paint(renderer, pictures.get(i), w, h);
+            }
+        }
+        Border b = getBorder();
+        if (b != null) {
+            List<BorderStroke> strokes = b.getStrokes();
+            for (int i = 0; i < strokes.size(); i++) {
+                paintStroke(renderer, strokes.get(i), w, h);
+            }
+            List<BorderImage> edges = b.getImages();
+            for (int i = 0; i < edges.size(); i++) {
+                StyleImages.paint(renderer, edges.get(i), w, h);
+            }
+        }
+    }
+
+    /// The shape placed in a rectangle of this region: stretched over it
+    /// when the shape is scaled, else at its own size and centred when
+    /// it is positioned.
+    private FxPath placed(FxPath path, double[] b, double x, double y, double w, double h) {
+        double pw = b[2] - b[0];
+        double ph = b[3] - b[1];
+        double sx = 1;
+        double sy = 1;
+        if (isScaleShape()) {
+            sx = pw > 0 ? w / pw : 1;
+            sy = ph > 0 ? h / ph : 1;
+        }
+        double tx;
+        double ty;
+        if (isScaleShape() || isCenterShape()) {
+            tx = x + (w - pw * sx) / 2 - b[0] * sx;
+            ty = y + (h - ph * sy) / 2 - b[1] * sy;
+        } else {
+            tx = x;
+            ty = y;
+        }
+        return path.transformed(new double[] {sx, 0, 0, sy, tx, ty});
+    }
+
+    /// Paints the fills and the strokes in the form of the shape rather
+    /// than as rectangles; the corner radii play no part then.
+    private void paintShaped(Renderer renderer, FxPath path, double[] bounds, double w, double h) {
+        Background bg = getBackground();
+        if (bg != null) {
+            List<BackgroundFill> fills = bg.getFills();
+            for (int i = 0; i < fills.size(); i++) {
+                BackgroundFill f = fills.get(i);
+                Insets in = f.getInsets();
+                double x = in.getLeft();
+                double y = in.getTop();
+                double fw = w - in.getLeft() - in.getRight();
+                double fh = h - in.getTop() - in.getBottom();
+                if (f.getFill() != null && fw > 0 && fh > 0) {
+                    renderer.fill(placed(path, bounds, x, y, fw, fh), f.getFill(), x, y, fw, fh);
+                }
+            }
+        }
+        Border b = getBorder();
+        if (b != null) {
+            List<BorderStroke> strokes = b.getStrokes();
+            for (int i = 0; i < strokes.size(); i++) {
+                BorderStroke s = strokes.get(i);
+                BorderWidths bw = s.getWidths();
+                BorderStrokeStyle style = s.getTopStyle();
+                if (bw == null || style == null || style == BorderStrokeStyle.NONE || bw.getTop() <= 0
+                        || s.getTopStroke() == null) {
+                    continue;
+                }
+                renderer.stroke(placed(path, bounds, 0, 0, w, h), s.getTopStroke(), bw.getTop(),
+                        style.getLineCap(), style.getLineJoin(), style.getMiterLimit(), dashes(style),
+                        style.getDashOffset());
+            }
+        }
+    }
+
+    private static boolean isSquare(CornerRadii r) {
+        return r == null || (r.getTopLeftHorizontalRadius() <= 0 && r.getTopRightHorizontalRadius() <= 0
+                && r.getBottomRightHorizontalRadius() <= 0 && r.getBottomLeftHorizontalRadius() <= 0);
+    }
+
+    private static double radius(double value, boolean percent, double w, double h, double shrink) {
+        double r = percent ? value * Math.min(w, h) : value;
+        r -= shrink;
+        double limit = Math.min(w, h) / 2;
+        return r < 0 ? 0 : (r > limit ? limit : r);
+    }
+
+    private static FxPath outline(CornerRadii r, double x, double y, double w, double h, double shrink) {
+        return Renderer.roundRect(x, y, w, h,
+                radius(r.getTopLeftHorizontalRadius(), r.isTopLeftHorizontalRadiusAsPercentage(), w, h, shrink),
+                radius(r.getTopRightHorizontalRadius(), r.isTopRightHorizontalRadiusAsPercentage(), w, h, shrink),
+                radius(r.getBottomRightHorizontalRadius(), r.isBottomRightHorizontalRadiusAsPercentage(), w, h,
+                        shrink),
+                radius(r.getBottomLeftHorizontalRadius(), r.isBottomLeftHorizontalRadiusAsPercentage(), w, h,
+                        shrink));
+    }
+
+    private static double[] dashes(BorderStrokeStyle style) {
+        List<Double> list = style == null ? null : style.getDashArray();
+        if (list == null || list.isEmpty()) {
+            return null;
+        }
+        double[] out = new double[list.size()];
+        for (int i = 0; i < out.length; i++) {
+            Double d = list.get(i);
+            out[i] = d == null ? 0 : d.doubleValue();
+        }
+        return out;
+    }
+
+    private void paintStroke(Renderer renderer, BorderStroke s, double w, double h) {
+        BorderWidths bw = s.getWidths();
+        Insets in = s.getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double sw = w - in.getLeft() - in.getRight();
+        double sh = h - in.getTop() - in.getBottom();
+        if (sw <= 0 || sh <= 0) {
+            return;
+        }
+        double t = bw.getTop();
+        boolean uniformWidth = t == bw.getRight() && t == bw.getBottom() && t == bw.getLeft();
+        BorderStrokeStyle style = s.getTopStyle();
+        if (uniformWidth && s.isStrokeUniform()) {
+            if (t <= 0 || s.getTopStroke() == null || style == BorderStrokeStyle.NONE) {
+                return;
+            }
+            CornerRadii r = s.getRadii() == null ? CornerRadii.EMPTY : s.getRadii();
+            FxPath path = outline(r, x + t / 2, y + t / 2, sw - t, sh - t, t / 2);
+            renderer.stroke(path, s.getTopStroke(), t, style.getLineCap(), style.getLineJoin(),
+                    style.getMiterLimit(), dashes(style), style.getDashOffset());
+            return;
+        }
+        if (bw.getTop() > 0 && s.getTopStroke() != null && s.getTopStyle() != BorderStrokeStyle.NONE) {
+            renderer.fillRect(x, y, sw, bw.getTop(), s.getTopStroke());
+        }
+        if (bw.getBottom() > 0 && s.getBottomStroke() != null && s.getBottomStyle() != BorderStrokeStyle.NONE) {
+            renderer.fillRect(x, y + sh - bw.getBottom(), sw, bw.getBottom(), s.getBottomStroke());
+        }
+        if (bw.getLeft() > 0 && s.getLeftStroke() != null && s.getLeftStyle() != BorderStrokeStyle.NONE) {
+            renderer.fillRect(x, y, bw.getLeft(), sh, s.getLeftStroke());
+        }
+        if (bw.getRight() > 0 && s.getRightStroke() != null && s.getRightStyle() != BorderStrokeStyle.NONE) {
+            renderer.fillRect(x + sw - bw.getRight(), y, bw.getRight(), sh, s.getRightStroke());
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/RowConstraints.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/RowConstraints.java
new file mode 100644
index 00000000000..46b64109940
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/RowConstraints.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.VPos;
+
+/// How a `GridPane` sizes one row and places the children in it. The
+/// constraint at index `n` of the pane's list applies to row `n`.
+///
+/// A size left at `Region.USE_COMPUTED_SIZE` is computed from the
+/// children of the row. A `percentHeight` of zero or more makes the
+/// row that share of the pane's height less the gaps, whatever the
+/// sizes say. A `vgrow` or `valignment` left `null` falls back to what the
+/// children ask for.
+public class RowConstraints extends ConstraintsBase {
+
+    private final DoubleProperty min = new Num(this, "minHeight", Region.USE_COMPUTED_SIZE);
+    private final DoubleProperty pref = new Num(this, "prefHeight", Region.USE_COMPUTED_SIZE);
+    private final DoubleProperty max = new Num(this, "maxHeight", Region.USE_COMPUTED_SIZE);
+    private final DoubleProperty percent = new Num(this, "percentHeight", -1);
+    private final ObjectProperty<Priority> grow = new Ref<Priority>(this, "vgrow");
+    private final ObjectProperty<VPos> align = new Ref<VPos>(this, "valignment");
+    private final BooleanProperty fill = new Flag(this, "fillHeight", true);
+
+    /// Creates a constraint that computes everything from the children.
+    public RowConstraints() {
+    }
+
+    /// Creates a row of a fixed height.
+    public RowConstraints(double height) {
+        min.set(Region.USE_PREF_SIZE);
+        pref.set(height);
+        max.set(Region.USE_PREF_SIZE);
+    }
+
+    /// Creates a row with a range of sizes.
+    public RowConstraints(double minHeight, double prefHeight, double maxHeight) {
+        min.set(minHeight);
+        pref.set(prefHeight);
+        max.set(maxHeight);
+    }
+
+    /// Creates a row with a range of sizes, a grow priority, an
+    /// alignment for its children and whether it stretches them.
+    public RowConstraints(double minHeight, double prefHeight, double maxHeight, Priority vgrow, VPos valignment,
+            boolean fillHeight) {
+        min.set(minHeight);
+        pref.set(prefHeight);
+        max.set(maxHeight);
+        grow.set(vgrow);
+        align.set(valignment);
+        fill.set(fillHeight);
+    }
+
+    /// Returns the minimum height, `Region.USE_COMPUTED_SIZE` or
+    /// `Region.USE_PREF_SIZE`.
+    public final double getMinHeight() {
+        return min.get();
+    }
+
+    /// Sets the minimum height.
+    public final void setMinHeight(double value) {
+        min.set(value);
+    }
+
+    /// The minimum height of the row.
+    public final DoubleProperty minHeightProperty() {
+        return min;
+    }
+
+    /// Returns the preferred height, or `Region.USE_COMPUTED_SIZE`.
+    public final double getPrefHeight() {
+        return pref.get();
+    }
+
+    /// Sets the preferred height.
+    public final void setPrefHeight(double value) {
+        pref.set(value);
+    }
+
+    /// The preferred height of the row.
+    public final DoubleProperty prefHeightProperty() {
+        return pref;
+    }
+
+    /// Returns the maximum height, `Region.USE_COMPUTED_SIZE` or
+    /// `Region.USE_PREF_SIZE`.
+    public final double getMaxHeight() {
+        return max.get();
+    }
+
+    /// Sets the maximum height.
+    public final void setMaxHeight(double value) {
+        max.set(value);
+    }
+
+    /// The maximum height of the row.
+    public final DoubleProperty maxHeightProperty() {
+        return max;
+    }
+
+    /// Returns the share of the pane in percent, or a negative number.
+    public final double getPercentHeight() {
+        return percent.get();
+    }
+
+    /// Sets the share of the pane this row takes, in percent; a negative
+    /// number turns it off.
+    public final void setPercentHeight(double value) {
+        percent.set(value);
+    }
+
+    /// The share of the pane this row takes, in percent.
+    public final DoubleProperty percentHeightProperty() {
+        return percent;
+    }
+
+    /// Returns how eagerly the row takes spare space, or `null`.
+    public final Priority getVgrow() {
+        return grow.get();
+    }
+
+    /// Sets how eagerly the row takes spare space.
+    public final void setVgrow(Priority value) {
+        grow.set(value);
+    }
+
+    /// How eagerly the row takes spare space.
+    public final ObjectProperty<Priority> vgrowProperty() {
+        return grow;
+    }
+
+    /// Returns where the children sit in the row, or `null`.
+    public final VPos getValignment() {
+        return align.get();
+    }
+
+    /// Sets where the children sit in the row.
+    public final void setValignment(VPos value) {
+        align.set(value);
+    }
+
+    /// Where the children sit in the row.
+    public final ObjectProperty<VPos> valignmentProperty() {
+        return align;
+    }
+
+    /// Returns whether resizable children are stretched to the height of
+    /// the row.
+    public final boolean isFillHeight() {
+        return fill.get();
+    }
+
+    /// Sets whether resizable children are stretched to the height of the
+    /// row.
+    public final void setFillHeight(boolean value) {
+        fill.set(value);
+    }
+
+    /// Whether resizable children are stretched to the height of the row.
+    public final BooleanProperty fillHeightProperty() {
+        return fill;
+    }
+
+    @Override
+    double minSize() {
+        return min.get();
+    }
+
+    @Override
+    double prefSize() {
+        return pref.get();
+    }
+
+    @Override
+    double maxSize() {
+        return max.get();
+    }
+
+    @Override
+    double percent() {
+        return percent.get();
+    }
+
+    @Override
+    Priority grow() {
+        return grow.get();
+    }
+
+    @Override
+    boolean fill() {
+        return fill.get();
+    }
+
+    /// Returns a description for debugging.
+    @Override
+    public String toString() {
+        return "RowConstraints percentHeight=" + getPercentHeight() + " minHeight=" + getMinHeight() + " prefHeight="
+                + getPrefHeight() + " maxHeight=" + getMaxHeight() + " vgrow=" + getVgrow() + " fillHeight="
+                + isFillHeight() + " valignment=" + getValignment();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/StackPane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/StackPane.java
new file mode 100644
index 00000000000..ee0ca06c8e1
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/StackPane.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Lays its managed children out on top of each other, the first at the
+/// back, each in the whole area inside the padding.
+///
+/// A resizable child is stretched to that area, up to its maximum size. A
+/// child that does not fill it is placed by its own alignment constraint,
+/// or by the `alignment` of the pane when it has none. The preferred size
+/// of the pane is that of its largest child plus the padding.
+///
+/// #### Styling
+///
+/// Besides the names of a region: `-fx-alignment` (`javafx.geometry.Pos`,
+/// or its CSS spelling such as `"bottom-right"` as a `String`, matched
+/// without regard to ASCII case).
+public class StackPane extends Pane {
+
+    private static final String MARGIN = "stackpane-margin";
+    private static final String ALIGNMENT = "stackpane-alignment";
+
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.CENTER, Dirty.LAYOUT);
+
+    /// Creates an empty stack.
+    public StackPane() {
+    }
+
+    /// Creates a stack with children.
+    public StackPane(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Sets where a child sits in a stack, overriding the alignment of the
+    /// pane; `null` removes the constraint.
+    public static void setAlignment(Node child, Pos value) {
+        setConstraint(child, ALIGNMENT, value);
+    }
+
+    /// Returns the alignment constraint of a child, or `null`.
+    public static Pos getAlignment(Node child) {
+        return LayoutSupport.pos(child, ALIGNMENT);
+    }
+
+    /// Sets the space kept free around a child in a stack; `null` removes
+    /// the constraint.
+    public static void setMargin(Node child, Insets value) {
+        setConstraint(child, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node child) {
+        return LayoutSupport.insets(child, MARGIN);
+    }
+
+    /// Removes the stack constraints from a child.
+    public static void clearConstraints(Node child) {
+        setAlignment(child, null);
+        setMargin(child, null);
+    }
+
+    /// Returns where children without a constraint of their own sit.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where children without a constraint of their own sit.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where children without a constraint of their own sit.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    private Pos align() {
+        Pos p = alignment.get();
+        return p == null ? Pos.CENTER : p;
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        List<Node> managed = getManagedChildren();
+        for (int i = 0; i < managed.size(); i++) {
+            Orientation b = managed.get(i).getContentBias();
+            if (b != null) {
+                return b;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        double[] given = given(managed.size(), height == -1 ? -1 : height - in.getTop() - in.getBottom());
+        return in.getLeft() + LayoutSupport.maxCross(this, managed, false, MARGIN, given, true) + in.getRight();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        double[] given = given(managed.size(), width == -1 ? -1 : width - in.getLeft() - in.getRight());
+        return in.getTop() + LayoutSupport.maxCross(this, managed, true, MARGIN, given, true) + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        double[] given = given(managed.size(), height == -1 ? -1 : height - in.getTop() - in.getBottom());
+        return in.getLeft() + LayoutSupport.maxCross(this, managed, false, MARGIN, given, false) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        double[] given = given(managed.size(), width == -1 ? -1 : width - in.getLeft() - in.getRight());
+        return in.getTop() + LayoutSupport.maxCross(this, managed, true, MARGIN, given, false) + in.getBottom();
+    }
+
+    private static double[] given(int count, double value) {
+        double[] out = new double[count];
+        for (int i = 0; i < count; i++) {
+            out[i] = value;
+        }
+        return out;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> managed = getManagedChildren();
+        Insets in = getInsets();
+        double insideWidth = getWidth() - in.getLeft() - in.getRight();
+        double insideHeight = getHeight() - in.getTop() - in.getBottom();
+        Pos pos = align();
+        double areaBaseline = -1;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            Pos own = getAlignment(child);
+            Pos use = own == null ? pos : own;
+            if (use.getVpos() == VPos.BASELINE) {
+                if (areaBaseline < 0) {
+                    areaBaseline = LayoutSupport.areaBaseline(this, managed, MARGIN);
+                }
+                LayoutSupport.layoutOnBaseline(this, child, in.getLeft(), in.getTop(), insideWidth, insideHeight,
+                        areaBaseline, getMargin(child), true, use.getHpos());
+            } else {
+                layoutInArea(child, in.getLeft(), in.getTop(), insideWidth, insideHeight, 0, getMargin(child),
+                        use.getHpos(), use.getVpos());
+            }
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-alignment".equals(property)) {
+            Pos p = LayoutSupport.toPos(value);
+            if (value != null && p == null) {
+                return false;
+            }
+            setAlignment(p);
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/StyleImages.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/StyleImages.java
new file mode 100644
index 00000000000..6465a59f927
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/StyleImages.java
@@ -0,0 +1,596 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import javafx.geometry.Insets;
+import javafx.geometry.Side;
+import javafx.scene.image.Image;
+import javafx.scene.text.Font;
+
+/// The pictures of a background and of a border: reading them from the
+/// values a style sheet gives (`-fx-background-image` and the properties
+/// beside it, `-fx-border-image-source` and its), and drawing them.
+///
+/// The values arrive as the text that was written. A style sheet's
+/// addresses have been made whole by the build, which knows where the
+/// sheet is; an inline style's are read from the root of the
+/// application, as JavaFX reads them.
+final class StyleImages {
+
+    /// The most copies of one picture drawn in one direction.
+    private static final int MOST = 2000;
+
+    private static final HashMap<String, Image> LOADED = new HashMap<String, Image>();
+
+    private StyleImages() {
+    }
+
+    // ------------------------------------------------------------ reading
+
+    /// Splits at a separator that is outside parentheses and quotes.
+    static List<String> split(String text, char separator) {
+        ArrayList<String> out = new ArrayList<String>();
+        if (text == null) {
+            return out;
+        }
+        int depth = 0;
+        char quote = 0;
+        int start = 0;
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (quote != 0) {
+                if (c == quote) {
+                    quote = 0;
+                }
+            } else if (c == '"' || c == '\'') {
+                quote = c;
+            } else if (c == '(') {
+                depth++;
+            } else if (c == ')') {
+                depth--;
+            } else if (depth == 0 && (c == separator || (separator == ' ' && c <= ' '))) {
+                String part = text.substring(start, i).trim();
+                if (part.length() > 0 || separator != ' ') {
+                    out.add(part);
+                }
+                start = i + 1;
+            }
+        }
+        String last = text.substring(start).trim();
+        if (last.length() > 0 || (separator != ' ' && !out.isEmpty())) {
+            out.add(last);
+        }
+        return out;
+    }
+
+    private static String layer(List<String> layers, int i) {
+        if (layers.isEmpty()) {
+            return null;
+        }
+        // A property with fewer layers than there are pictures starts
+        // over, as CSS has it.
+        return layers.get(i % layers.size());
+    }
+
+    private static boolean is(String word, String expected) {
+        return word != null && word.equalsIgnoreCase(expected);
+    }
+
+    /// The picture a `url(...)` names, `null` for `none` and for one that
+    /// cannot be read.
+    static Image image(String term) {
+        if (term == null) {
+            return null;
+        }
+        String t = term.trim();
+        if (t.length() > 4 && t.regionMatches(true, 0, "url(", 0, 4) && t.endsWith(")")) {
+            t = t.substring(4, t.length() - 1).trim();
+        } else if (is(t, "none") || t.length() == 0) {
+            return null;
+        }
+        char open = t.length() >= 2 ? t.charAt(0) : 0;
+        if ((open == '"' || open == '\'') && t.charAt(t.length() - 1) == open) {
+            t = t.substring(1, t.length() - 1);
+        }
+        if (t.length() == 0) {
+            return null;
+        }
+        Image found = LOADED.get(t);
+        if (found == null) {
+            found = new Image(t);
+            LOADED.put(t, found);
+        }
+        return found.isError() || found.cn1Native() == null ? null : found;
+    }
+
+    /// A length, or a share written with `%` as 0 to 1; NaN for neither.
+    /// The second entry is 1 for a share.
+    private static double[] measure(String term) {
+        String t = term.trim();
+        double factor = 1;
+        double share = 0;
+        int end = t.length();
+        if (t.endsWith("%")) {
+            factor = 0.01;
+            share = 1;
+            end--;
+        } else if (t.regionMatches(true, Math.max(0, end - 2), "px", 0, 2)) {
+            end -= 2;
+        } else if (t.regionMatches(true, Math.max(0, end - 2), "em", 0, 2)) {
+            factor = Font.getDefault().getSize();
+            end -= 2;
+        } else if (t.regionMatches(true, Math.max(0, end - 2), "pt", 0, 2)) {
+            factor = 96.0 / 72;
+            end -= 2;
+        }
+        try {
+            return new double[] {Double.parseDouble(t.substring(0, end)) * factor, share};
+        } catch (NumberFormatException notANumber) {
+            return new double[] {Double.NaN, 0};
+        }
+    }
+
+    private static BackgroundRepeat repeat(String word) {
+        if (is(word, "repeat")) {
+            return BackgroundRepeat.REPEAT;
+        } else if (is(word, "space")) {
+            return BackgroundRepeat.SPACE;
+        } else if (is(word, "round")) {
+            return BackgroundRepeat.ROUND;
+        }
+        return BackgroundRepeat.NO_REPEAT;
+    }
+
+    private static BackgroundSize size(String value) {
+        List<String> terms = split(value, ' ');
+        if (terms.isEmpty()) {
+            return BackgroundSize.DEFAULT;
+        }
+        String first = terms.get(0);
+        if (is(first, "cover")) {
+            return new BackgroundSize(BackgroundSize.AUTO, BackgroundSize.AUTO, true, true, false, true);
+        } else if (is(first, "contain")) {
+            return new BackgroundSize(BackgroundSize.AUTO, BackgroundSize.AUTO, true, true, true, false);
+        } else if (is(first, "stretch")) {
+            return new BackgroundSize(1, 1, true, true, false, false);
+        }
+        double[] w = is(first, "auto") ? null : measure(first);
+        double[] h = terms.size() < 2 || is(terms.get(1), "auto") ? null : measure(terms.get(1));
+        double width = w == null || !(w[0] >= 0) ? BackgroundSize.AUTO : w[0];
+        double height = h == null || !(h[0] >= 0) ? BackgroundSize.AUTO : h[0];
+        return new BackgroundSize(width, height, w == null || w[1] != 0, h == null || h[1] != 0, false, false);
+    }
+
+    private static BackgroundPosition position(String value) {
+        List<String> terms = split(value, ' ');
+        Side hSide = Side.LEFT;
+        Side vSide = Side.TOP;
+        double h = 0;
+        double v = 0;
+        boolean hShare = true;
+        boolean vShare = true;
+        boolean hGiven = false;
+        boolean vGiven = false;
+        // What the last word was: 1 a horizontal side, 2 a vertical one;
+        // a length after a side is the distance from it.
+        int after = 0;
+        for (int i = 0; i < terms.size(); i++) {
+            String t = terms.get(i);
+            if (is(t, "left") || is(t, "right")) {
+                hSide = is(t, "left") ? Side.LEFT : Side.RIGHT;
+                h = 0;
+                hShare = true;
+                hGiven = true;
+                after = 1;
+            } else if (is(t, "top") || is(t, "bottom")) {
+                vSide = is(t, "top") ? Side.TOP : Side.BOTTOM;
+                v = 0;
+                vShare = true;
+                vGiven = true;
+                after = 2;
+            } else if (is(t, "center")) {
+                if (!hGiven && (i == 0 || vGiven)) {
+                    h = 0.5;
+                    hGiven = true;
+                } else {
+                    v = 0.5;
+                    vGiven = true;
+                }
+                after = 0;
+            } else {
+                double[] m = measure(t);
+                if (m[0] != m[0]) {
+                    continue;
+                }
+                if (after == 1 || (after == 0 && !hGiven)) {
+                    h = m[0];
+                    hShare = m[1] != 0;
+                    hGiven = true;
+                } else {
+                    v = m[0];
+                    vShare = m[1] != 0;
+                    vGiven = true;
+                }
+                after = 0;
+            }
+        }
+        if (hGiven && !vGiven && terms.size() == 1) {
+            // One value is the horizontal place; the other is the middle.
+            v = 0.5;
+        } else if (vGiven && !hGiven && terms.size() == 1) {
+            h = 0.5;
+        }
+        return new BackgroundPosition(hSide, h, hShare, vSide, v, vShare);
+    }
+
+    /// The background pictures a style gives, bottom first; none when the
+    /// source names none that can be read.
+    static BackgroundImage[] backgrounds(Object source, Object repeat, Object position, Object size) {
+        if (!(source instanceof String)) {
+            return new BackgroundImage[0];
+        }
+        List<String> sources = split((String) source, ',');
+        List<String> repeats = split(repeat instanceof String ? (String) repeat : null, ',');
+        List<String> positions = split(position instanceof String ? (String) position : null, ',');
+        List<String> sizes = split(size instanceof String ? (String) size : null, ',');
+        ArrayList<BackgroundImage> out = new ArrayList<BackgroundImage>();
+        for (int i = 0; i < sources.size(); i++) {
+            Image image = image(sources.get(i));
+            if (image == null) {
+                continue;
+            }
+            BackgroundRepeat rx = BackgroundRepeat.REPEAT;
+            BackgroundRepeat ry = BackgroundRepeat.REPEAT;
+            BackgroundSize s = sizes.isEmpty() ? BackgroundSize.DEFAULT : size(layer(sizes, i));
+            String r = layer(repeats, i);
+            if (r != null) {
+                List<String> words = split(r, ' ');
+                String first = words.isEmpty() ? "repeat" : words.get(0);
+                if (is(first, "repeat-x")) {
+                    ry = BackgroundRepeat.NO_REPEAT;
+                } else if (is(first, "repeat-y")) {
+                    rx = BackgroundRepeat.NO_REPEAT;
+                } else if (is(first, "stretch")) {
+                    rx = BackgroundRepeat.NO_REPEAT;
+                    ry = BackgroundRepeat.NO_REPEAT;
+                    s = new BackgroundSize(1, 1, true, true, false, false);
+                } else {
+                    rx = repeat(first);
+                    ry = words.size() > 1 ? repeat(words.get(1)) : rx;
+                }
+            }
+            out.add(new BackgroundImage(image, rx, ry,
+                    positions.isEmpty() ? BackgroundPosition.DEFAULT : position(layer(positions, i)), s));
+        }
+        return out.toArray(new BackgroundImage[0]);
+    }
+
+    private static BorderRepeat borderRepeat(String word) {
+        if (is(word, "repeat")) {
+            return BorderRepeat.REPEAT;
+        } else if (is(word, "round")) {
+            return BorderRepeat.ROUND;
+        } else if (is(word, "space")) {
+            return BorderRepeat.SPACE;
+        }
+        return BorderRepeat.STRETCH;
+    }
+
+    /// One to four widths, as CSS writes the sides of a box; `null` for a
+    /// value that holds no number.
+    private static BorderWidths widths(String value, boolean[] fill) {
+        List<String> terms = split(value, ' ');
+        double[] n = new double[4];
+        boolean[] share = new boolean[4];
+        int count = 0;
+        for (int i = 0; i < terms.size(); i++) {
+            String t = terms.get(i);
+            if (is(t, "fill")) {
+                if (fill != null) {
+                    fill[0] = true;
+                }
+                continue;
+            }
+            double[] m = measure(t);
+            if (m[0] == m[0] && m[0] >= 0 && count < 4) {
+                n[count] = m[0];
+                share[count++] = m[1] != 0;
+            }
+        }
+        if (count == 0) {
+            return null;
+        }
+        int right = count > 1 ? 1 : 0;
+        int bottom = count > 2 ? 2 : 0;
+        int left = count > 3 ? 3 : right;
+        return new BorderWidths(n[0], n[right], n[bottom], n[left], share[0], share[right], share[bottom],
+                share[left]);
+    }
+
+    /// The border pictures a style gives; none when the source names none
+    /// that can be read.
+    static BorderImage[] borders(Object source, Object slice, Object width, Object repeat, Object insets) {
+        if (!(source instanceof String)) {
+            return new BorderImage[0];
+        }
+        List<String> sources = split((String) source, ',');
+        List<String> slices = split(slice instanceof String ? (String) slice : null, ',');
+        List<String> widths = split(width instanceof String ? (String) width : null, ',');
+        List<String> repeats = split(repeat instanceof String ? (String) repeat : null, ',');
+        List<String> allInsets = split(insets instanceof String ? (String) insets : null, ',');
+        ArrayList<BorderImage> out = new ArrayList<BorderImage>();
+        for (int i = 0; i < sources.size(); i++) {
+            Image image = image(sources.get(i));
+            if (image == null) {
+                continue;
+            }
+            boolean[] fill = new boolean[1];
+            // A cut that is not given is the whole picture, which leaves
+            // four corners and nothing between them.
+            BorderWidths cut = slices.isEmpty() ? null : widths(layer(slices, i), fill);
+            if (cut == null) {
+                cut = new BorderWidths(1, 1, 1, 1, true, true, true, true);
+            }
+            BorderWidths w = widths.isEmpty() ? null : widths(layer(widths, i), null);
+            BorderWidths in = allInsets.isEmpty() ? null : widths(layer(allInsets, i), null);
+            BorderRepeat rx = BorderRepeat.STRETCH;
+            BorderRepeat ry = BorderRepeat.STRETCH;
+            String r = layer(repeats, i);
+            if (r != null) {
+                List<String> words = split(r, ' ');
+                String first = words.isEmpty() ? "stretch" : words.get(0);
+                if (is(first, "repeat-x")) {
+                    rx = BorderRepeat.REPEAT;
+                } else if (is(first, "repeat-y")) {
+                    ry = BorderRepeat.REPEAT;
+                } else {
+                    rx = borderRepeat(first);
+                    ry = words.size() > 1 ? borderRepeat(words.get(1)) : rx;
+                }
+            }
+            out.add(new BorderImage(image, w, in == null ? Insets.EMPTY
+                    : new Insets(in.getTop(), in.getRight(), in.getBottom(), in.getLeft()), cut, fill[0], rx, ry));
+        }
+        return out.toArray(new BorderImage[0]);
+    }
+
+    // ------------------------------------------------------------ drawing
+
+    private static double tile(BackgroundRepeat repeat, double room, double size) {
+        if (repeat == BackgroundRepeat.ROUND && size > 0) {
+            // Resized so that a whole number of copies fits.
+            return room / Math.max(1, Math.round(room / size));
+        }
+        return size;
+    }
+
+    /// Fills `room` with copies of length `size` and calls them out as
+    /// starts in `starts`; answers how many.
+    private static int starts(BackgroundRepeat repeat, double room, double size, double place, double[] starts) {
+        if (!(size > 0)) {
+            return 0;
+        }
+        if (repeat == BackgroundRepeat.NO_REPEAT) {
+            starts[0] = place;
+            return 1;
+        }
+        if (repeat == BackgroundRepeat.SPACE) {
+            int n = (int) Math.floor(room / size);
+            if (n < 2) {
+                starts[0] = n == 1 ? place : (room - size) / 2;
+                return 1;
+            }
+            n = Math.min(n, starts.length);
+            double gap = (room - n * size) / (n - 1);
+            for (int i = 0; i < n; i++) {
+                starts[i] = i * (size + gap);
+            }
+            return n;
+        }
+        double first = repeat == BackgroundRepeat.ROUND ? 0 : place - Math.ceil(place / size) * size;
+        int n = 0;
+        for (double at = first; at < room - 1e-6 && n < starts.length; at += size) {
+            starts[n++] = at;
+        }
+        return n;
+    }
+
+    /// Draws one background picture over a region of a size.
+    static void paint(Renderer renderer, BackgroundImage bi, double w, double h) {
+        com.codename1.ui.Image picture = bi.getImage().cn1Native();
+        double iw = bi.getImage().getWidth();
+        double ih = bi.getImage().getHeight();
+        if (picture == null || !(iw > 0) || !(ih > 0) || !(w > 0) || !(h > 0)) {
+            return;
+        }
+        BackgroundSize size = bi.getSize();
+        double tw;
+        double th;
+        if (size.isCover() || size.isContain()) {
+            double scale = size.isCover() ? Math.max(w / iw, h / ih) : Math.min(w / iw, h / ih);
+            tw = iw * scale;
+            th = ih * scale;
+        } else {
+            double sw = size.getWidth();
+            double sh = size.getHeight();
+            tw = sw == BackgroundSize.AUTO ? -1 : (size.isWidthAsPercentage() ? sw * w : sw);
+            th = sh == BackgroundSize.AUTO ? -1 : (size.isHeightAsPercentage() ? sh * h : sh);
+            if (tw < 0 && th < 0) {
+                tw = iw;
+                th = ih;
+            } else if (tw < 0) {
+                tw = th * iw / ih;
+            } else if (th < 0) {
+                th = tw * ih / iw;
+            }
+        }
+        tw = tile(bi.getRepeatX(), w, tw);
+        th = tile(bi.getRepeatY(), h, th);
+        if (!(tw > 0) || !(th > 0)) {
+            return;
+        }
+        BackgroundPosition p = bi.getPosition();
+        double x = p.isHorizontalAsPercentage() ? (w - tw) * p.getHorizontalPosition() : p.getHorizontalPosition();
+        double y = p.isVerticalAsPercentage() ? (h - th) * p.getVerticalPosition() : p.getVerticalPosition();
+        if (p.getHorizontalSide() == Side.RIGHT) {
+            x = w - tw - x;
+        }
+        if (p.getVerticalSide() == Side.BOTTOM) {
+            y = h - th - y;
+        }
+        double[] xs = new double[(int) Math.min(MOST, Math.max(1, Math.ceil(w / tw) + 2))];
+        double[] ys = new double[(int) Math.min(MOST, Math.max(1, Math.ceil(h / th) + 2))];
+        int nx = starts(bi.getRepeatX(), w, tw, x, xs);
+        int ny = starts(bi.getRepeatY(), h, th, y, ys);
+        renderer.save();
+        FxPath box = new FxPath();
+        box.addRect(0, 0, w, h);
+        renderer.clip(box);
+        for (int row = 0; row < ny; row++) {
+            for (int column = 0; column < nx; column++) {
+                renderer.drawImage(picture, xs[column], ys[row], tw, th);
+            }
+        }
+        renderer.restore();
+    }
+
+    private static double part(double value, boolean share, double whole) {
+        return share ? value * whole : value;
+    }
+
+    private static com.codename1.ui.Image piece(com.codename1.ui.Image picture, int x, int y, int w, int h) {
+        if (w <= 0 || h <= 0) {
+            return null;
+        }
+        return picture.subImage(x, y, w, h, true);
+    }
+
+    /// Draws one piece of a border along a side, or over the middle.
+    private static void side(Renderer renderer, com.codename1.ui.Image piece, double x, double y, double w, double h,
+            double tw, double th, BorderRepeat rx, BorderRepeat ry) {
+        if (piece == null || !(w > 0) || !(h > 0)) {
+            return;
+        }
+        if (rx == BorderRepeat.STRETCH || !(tw > 0)) {
+            tw = w;
+        } else if (rx == BorderRepeat.ROUND) {
+            tw = w / Math.max(1, Math.round(w / tw));
+        }
+        if (ry == BorderRepeat.STRETCH || !(th > 0)) {
+            th = h;
+        } else if (ry == BorderRepeat.ROUND) {
+            th = h / Math.max(1, Math.round(h / th));
+        }
+        if (tw == w && th == h) {
+            renderer.drawImage(piece, x, y, w, h);
+            return;
+        }
+        double[] xs = new double[(int) Math.min(MOST, Math.ceil(w / tw) + 2)];
+        double[] ys = new double[(int) Math.min(MOST, Math.ceil(h / th) + 2)];
+        // A repeated side is centred, so that it is cut the same at both
+        // corners.
+        int nx = starts(rx == BorderRepeat.SPACE ? BackgroundRepeat.SPACE
+                : (tw == w ? BackgroundRepeat.NO_REPEAT : BackgroundRepeat.REPEAT), w, tw,
+                tw == w || rx == BorderRepeat.ROUND ? 0 : (w - tw) / 2, xs);
+        int ny = starts(ry == BorderRepeat.SPACE ? BackgroundRepeat.SPACE
+                : (th == h ? BackgroundRepeat.NO_REPEAT : BackgroundRepeat.REPEAT), h, th,
+                th == h || ry == BorderRepeat.ROUND ? 0 : (h - th) / 2, ys);
+        renderer.save();
+        FxPath box = new FxPath();
+        box.addRect(x, y, w, h);
+        renderer.clip(box);
+        for (int row = 0; row < ny; row++) {
+            for (int column = 0; column < nx; column++) {
+                renderer.drawImage(piece, x + xs[column], y + ys[row], tw, th);
+            }
+        }
+        renderer.restore();
+    }
+
+    /// Draws one border picture around a region of a size.
+    static void paint(Renderer renderer, BorderImage bi, double w, double h) {
+        com.codename1.ui.Image picture = bi.getImage().cn1Native();
+        if (picture == null) {
+            return;
+        }
+        int iw = (int) Math.round(bi.getImage().getWidth());
+        int ih = (int) Math.round(bi.getImage().getHeight());
+        Insets in = bi.getInsets();
+        double x = in.getLeft();
+        double y = in.getTop();
+        double aw = w - in.getLeft() - in.getRight();
+        double ah = h - in.getTop() - in.getBottom();
+        if (iw <= 0 || ih <= 0 || !(aw > 0) || !(ah > 0)) {
+            return;
+        }
+        BorderWidths s = bi.getSlices();
+        int st = (int) Math.min(ih, Math.round(part(s.getTop(), s.isTopAsPercentage(), ih)));
+        int sb = (int) Math.min(ih - st, Math.round(part(s.getBottom(), s.isBottomAsPercentage(), ih)));
+        int sl = (int) Math.min(iw, Math.round(part(s.getLeft(), s.isLeftAsPercentage(), iw)));
+        int sr = (int) Math.min(iw - sl, Math.round(part(s.getRight(), s.isRightAsPercentage(), iw)));
+        com.codename1.ui.Image[] p = bi.pieces();
+        if (p == null) {
+            int mw = iw - sl - sr;
+            int mh = ih - st - sb;
+            p = new com.codename1.ui.Image[] {
+                piece(picture, 0, 0, sl, st), piece(picture, sl, 0, mw, st), piece(picture, iw - sr, 0, sr, st),
+                piece(picture, 0, st, sl, mh), piece(picture, sl, st, mw, mh), piece(picture, iw - sr, st, sr, mh),
+                piece(picture, 0, ih - sb, sl, sb), piece(picture, sl, ih - sb, mw, sb),
+                piece(picture, iw - sr, ih - sb, sr, sb),
+            };
+            bi.pieces(p);
+        }
+        BorderWidths bw = bi.getWidths();
+        double wt = Math.min(ah, Math.max(0, part(bw.getTop(), bw.isTopAsPercentage(), ah)));
+        double wb = Math.min(ah - wt, Math.max(0, part(bw.getBottom(), bw.isBottomAsPercentage(), ah)));
+        double wl = Math.min(aw, Math.max(0, part(bw.getLeft(), bw.isLeftAsPercentage(), aw)));
+        double wr = Math.min(aw - wl, Math.max(0, part(bw.getRight(), bw.isRightAsPercentage(), aw)));
+        double mw = aw - wl - wr;
+        double mh = ah - wt - wb;
+        // A side piece keeps its shape: as thick as the border, and as
+        // long as that makes it.
+        double topTile = st > 0 ? (iw - sl - sr) * wt / st : 0;
+        double bottomTile = sb > 0 ? (iw - sl - sr) * wb / sb : 0;
+        double leftTile = sl > 0 ? (ih - st - sb) * wl / sl : 0;
+        double rightTile = sr > 0 ? (ih - st - sb) * wr / sr : 0;
+        BorderRepeat rx = bi.getRepeatX();
+        BorderRepeat ry = bi.getRepeatY();
+        if (bi.isFilled()) {
+            side(renderer, p[4], x + wl, y + wt, mw, mh, topTile > 0 ? topTile : bottomTile,
+                    leftTile > 0 ? leftTile : rightTile, rx, ry);
+        }
+        side(renderer, p[1], x + wl, y, mw, wt, topTile, 0, rx, BorderRepeat.STRETCH);
+        side(renderer, p[7], x + wl, y + ah - wb, mw, wb, bottomTile, 0, rx, BorderRepeat.STRETCH);
+        side(renderer, p[3], x, y + wt, wl, mh, 0, leftTile, BorderRepeat.STRETCH, ry);
+        side(renderer, p[5], x + aw - wr, y + wt, wr, mh, 0, rightTile, BorderRepeat.STRETCH, ry);
+        side(renderer, p[0], x, y, wl, wt, 0, 0, BorderRepeat.STRETCH, BorderRepeat.STRETCH);
+        side(renderer, p[2], x + aw - wr, y, wr, wt, 0, 0, BorderRepeat.STRETCH, BorderRepeat.STRETCH);
+        side(renderer, p[6], x, y + ah - wb, wl, wb, 0, 0, BorderRepeat.STRETCH, BorderRepeat.STRETCH);
+        side(renderer, p[8], x + aw - wr, y + ah - wb, wr, wb, 0, 0, BorderRepeat.STRETCH, BorderRepeat.STRETCH);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/TilePane.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/TilePane.java
new file mode 100644
index 00000000000..7d727438b98
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/TilePane.java
@@ -0,0 +1,554 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Lays its managed children out in a grid of equally sized tiles.
+///
+/// A horizontal tile pane fills rows from left to right and starts a new
+/// row when the next tile does not fit in its width; a vertical one fills
+/// columns from top to bottom and wraps at its height. A tile is as wide
+/// as the widest child and as tall as the tallest, unless `prefTileWidth`
+/// or `prefTileHeight` say otherwise, and never larger than the pane.
+///
+/// A resizable child is stretched to its tile, up to its maximum size. A
+/// child that does not fill the tile is placed by its own alignment
+/// constraint, or by `tileAlignment`. `alignment` places the grid in the
+/// pane; in a horizontal pane an incomplete last row is placed by the
+/// horizontal part of `alignment` on its own, in a vertical one an
+/// incomplete last column by the vertical part.
+///
+/// The preferred size is `prefColumns` tiles wide for a horizontal pane
+/// and as many rows as the children then need, and `prefRows` tiles tall
+/// for a vertical one.
+///
+/// `tileWidth` and `tileHeight` are brought up to date when they are
+/// read through [#getTileWidth()] and [#getTileHeight()] and on every
+/// layout.
+///
+/// #### Styling
+///
+/// Besides the names of a region: `-fx-hgap`, `-fx-vgap` (`Number`),
+/// `-fx-alignment` (`javafx.geometry.Pos` or its CSS spelling as a
+/// `String`) and `-fx-orientation` (`javafx.geometry.Orientation` or its
+/// name as a `String`); strings are matched without regard to ASCII case.
+public class TilePane extends Pane {
+
+    private static final String MARGIN = "tilepane-margin";
+    private static final String ALIGNMENT = "tilepane-alignment";
+
+    private final ObjectProperty<Orientation> orientation = new FxObject<Orientation>(this, "orientation",
+            Orientation.HORIZONTAL, Dirty.LAYOUT);
+    private final IntegerProperty prefRows = new Count("prefRows");
+    private final IntegerProperty prefColumns = new Count("prefColumns");
+    private final DoubleProperty prefTileWidth = new FxDouble(this, "prefTileWidth", USE_COMPUTED_SIZE,
+            Dirty.LAYOUT);
+    private final DoubleProperty prefTileHeight = new FxDouble(this, "prefTileHeight", USE_COMPUTED_SIZE,
+            Dirty.LAYOUT);
+    private final ReadOnlyDoubleWrapper tileWidth = new ReadOnlyDoubleWrapper(this, "tileWidth", 0);
+    private final ReadOnlyDoubleWrapper tileHeight = new ReadOnlyDoubleWrapper(this, "tileHeight", 0);
+    private final DoubleProperty hgap = new FxDouble(this, "hgap", 0, Dirty.LAYOUT);
+    private final DoubleProperty vgap = new FxDouble(this, "vgap", 0, Dirty.LAYOUT);
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.TOP_LEFT, Dirty.LAYOUT);
+    private final ObjectProperty<Pos> tileAlignment = new FxObject<Pos>(this, "tileAlignment", Pos.CENTER,
+            Dirty.LAYOUT);
+
+    /// A count of tiles whose change asks for layout.
+    private final class Count extends SimpleIntegerProperty {
+        Count(String name) {
+            super(TilePane.this, name, 5);
+        }
+
+        @Override
+        protected void invalidated() {
+            requestLayout();
+        }
+    }
+
+    /// Creates an empty horizontal tile pane without gaps.
+    public TilePane() {
+    }
+
+    /// Creates an empty tile pane without gaps.
+    public TilePane(Orientation orientation) {
+        this.orientation.set(orientation);
+    }
+
+    /// Creates an empty horizontal tile pane with gaps.
+    public TilePane(double hgap, double vgap) {
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+    }
+
+    /// Creates an empty tile pane with gaps.
+    public TilePane(Orientation orientation, double hgap, double vgap) {
+        this.orientation.set(orientation);
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+    }
+
+    /// Creates a horizontal tile pane with children.
+    public TilePane(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a tile pane with children.
+    public TilePane(Orientation orientation, Node... children) {
+        this.orientation.set(orientation);
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a horizontal tile pane with gaps and children.
+    public TilePane(double hgap, double vgap, Node... children) {
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a tile pane with gaps and children.
+    public TilePane(Orientation orientation, double hgap, double vgap, Node... children) {
+        this.orientation.set(orientation);
+        this.hgap.set(hgap);
+        this.vgap.set(vgap);
+        cn1Children().addAll(children);
+    }
+
+    /// Sets where a child sits in its tile, overriding `tileAlignment`;
+    /// `null` removes the constraint.
+    public static void setAlignment(Node node, Pos value) {
+        setConstraint(node, ALIGNMENT, value);
+    }
+
+    /// Returns the alignment constraint of a child, or `null`.
+    public static Pos getAlignment(Node node) {
+        return LayoutSupport.pos(node, ALIGNMENT);
+    }
+
+    /// Sets the space kept free around a child in its tile; `null` removes
+    /// the constraint.
+    public static void setMargin(Node node, Insets value) {
+        setConstraint(node, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node node) {
+        return LayoutSupport.insets(node, MARGIN);
+    }
+
+    /// Removes the tile pane constraints from a child.
+    public static void clearConstraints(Node child) {
+        setAlignment(child, null);
+        setMargin(child, null);
+    }
+
+    /// Returns the direction in which tiles are filled.
+    public final Orientation getOrientation() {
+        Orientation o = orientation.get();
+        return o == null ? Orientation.HORIZONTAL : o;
+    }
+
+    /// Sets the direction in which tiles are filled.
+    public final void setOrientation(Orientation value) {
+        orientation.set(value);
+    }
+
+    /// The direction in which tiles are filled.
+    public final ObjectProperty<Orientation> orientationProperty() {
+        return orientation;
+    }
+
+    /// Returns the number of rows a vertical pane prefers.
+    public final int getPrefRows() {
+        return prefRows.get();
+    }
+
+    /// Sets the number of rows a vertical pane prefers.
+    public final void setPrefRows(int value) {
+        prefRows.set(value);
+    }
+
+    /// The number of rows a vertical pane prefers.
+    public final IntegerProperty prefRowsProperty() {
+        return prefRows;
+    }
+
+    /// Returns the number of columns a horizontal pane prefers.
+    public final int getPrefColumns() {
+        return prefColumns.get();
+    }
+
+    /// Sets the number of columns a horizontal pane prefers.
+    public final void setPrefColumns(int value) {
+        prefColumns.set(value);
+    }
+
+    /// The number of columns a horizontal pane prefers.
+    public final IntegerProperty prefColumnsProperty() {
+        return prefColumns;
+    }
+
+    /// Returns the width asked for every tile, or
+    /// [Region#USE_COMPUTED_SIZE].
+    public final double getPrefTileWidth() {
+        return prefTileWidth.get();
+    }
+
+    /// Sets the width of every tile; [Region#USE_COMPUTED_SIZE] makes it
+    /// that of the widest child.
+    public final void setPrefTileWidth(double value) {
+        prefTileWidth.set(value);
+    }
+
+    /// The width asked for every tile.
+    public final DoubleProperty prefTileWidthProperty() {
+        return prefTileWidth;
+    }
+
+    /// Returns the height asked for every tile, or
+    /// [Region#USE_COMPUTED_SIZE].
+    public final double getPrefTileHeight() {
+        return prefTileHeight.get();
+    }
+
+    /// Sets the height of every tile; [Region#USE_COMPUTED_SIZE] makes it
+    /// that of the tallest child.
+    public final void setPrefTileHeight(double value) {
+        prefTileHeight.set(value);
+    }
+
+    /// The height asked for every tile.
+    public final DoubleProperty prefTileHeightProperty() {
+        return prefTileHeight;
+    }
+
+    /// Returns the width of a tile before it is limited to the pane.
+    public final double getTileWidth() {
+        double w = measureTile(true);
+        tileWidth.set(w);
+        return w;
+    }
+
+    /// The width of a tile.
+    public final ReadOnlyDoubleProperty tileWidthProperty() {
+        return tileWidth.getReadOnlyProperty();
+    }
+
+    /// Returns the height of a tile before it is limited to the pane.
+    public final double getTileHeight() {
+        double h = measureTile(false);
+        tileHeight.set(h);
+        return h;
+    }
+
+    /// The height of a tile.
+    public final ReadOnlyDoubleProperty tileHeightProperty() {
+        return tileHeight.getReadOnlyProperty();
+    }
+
+    /// Returns the horizontal gap between tiles.
+    public final double getHgap() {
+        return hgap.get();
+    }
+
+    /// Sets the horizontal gap between tiles.
+    public final void setHgap(double value) {
+        hgap.set(value);
+    }
+
+    /// The horizontal gap between tiles.
+    public final DoubleProperty hgapProperty() {
+        return hgap;
+    }
+
+    /// Returns the vertical gap between tiles.
+    public final double getVgap() {
+        return vgap.get();
+    }
+
+    /// Sets the vertical gap between tiles.
+    public final void setVgap(double value) {
+        vgap.set(value);
+    }
+
+    /// The vertical gap between tiles.
+    public final DoubleProperty vgapProperty() {
+        return vgap;
+    }
+
+    /// Returns where the grid of tiles sits in the pane.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the grid of tiles sits in the pane.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the grid of tiles sits in the pane.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Returns where a child sits in its tile.
+    public final Pos getTileAlignment() {
+        return tileAlignment.get();
+    }
+
+    /// Sets where a child sits in its tile.
+    public final void setTileAlignment(Pos value) {
+        tileAlignment.set(value);
+    }
+
+    /// Where a child sits in its tile.
+    public final ObjectProperty<Pos> tileAlignmentProperty() {
+        return tileAlignment;
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        return getOrientation();
+    }
+
+    private double measureTile(boolean width) {
+        double asked = width ? getPrefTileWidth() : getPrefTileHeight();
+        if (asked != USE_COMPUTED_SIZE) {
+            double clean = Double.isNaN(asked) || asked < 0 ? 0 : asked;
+            return width ? snapSizeX(clean) : snapSizeY(clean);
+        }
+        List<Node> managed = getManagedChildren();
+        double max = 0;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            Insets m = getMargin(child);
+            max = Math.max(max, width ? computeChildPrefAreaWidth(child, m, -1)
+                    : computeChildPrefAreaHeight(child, m, -1));
+        }
+        return width ? snapSizeX(max) : snapSizeY(max);
+    }
+
+    /// How many tiles of a size fit in a length; at least one.
+    private static int fitting(double length, double tile, double gap) {
+        double step = tile + gap;
+        if (!(step > 0)) {
+            return 1;
+        }
+        int n = (int) ((length + gap) / step);
+        return n < 1 ? 1 : n;
+    }
+
+    /// How many lines of `cells` tiles a number of nodes needs.
+    private static int linesFor(int nodes, int cells) {
+        if (cells <= 0) {
+            return 0;
+        }
+        return (nodes + cells - 1) / cells;
+    }
+
+    private static double span(int count, double tile, double gap) {
+        return count <= 0 ? 0 : count * tile + (count - 1) * gap;
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        if (getOrientation() == Orientation.HORIZONTAL) {
+            Insets in = getInsets();
+            return in.getLeft() + getTileWidth() + in.getRight();
+        }
+        return computePrefWidth(height);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        if (getOrientation() == Orientation.VERTICAL) {
+            Insets in = getInsets();
+            return in.getTop() + getTileHeight() + in.getBottom();
+        }
+        return computePrefHeight(width);
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        int columns;
+        if (height != -1) {
+            int rows = fitting(height - in.getTop() - in.getBottom(), getTileHeight(), snapSpaceY(getVgap()));
+            columns = linesFor(managed.size(), rows);
+        } else if (getOrientation() == Orientation.HORIZONTAL) {
+            columns = getPrefColumns();
+        } else {
+            columns = linesFor(managed.size(), getPrefRows());
+        }
+        return in.getLeft() + span(columns, getTileWidth(), snapSpaceX(getHgap())) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        int rows;
+        if (width != -1) {
+            int columns = fitting(width - in.getLeft() - in.getRight(), getTileWidth(), snapSpaceX(getHgap()));
+            rows = linesFor(managed.size(), columns);
+        } else if (getOrientation() == Orientation.HORIZONTAL) {
+            rows = linesFor(managed.size(), getPrefColumns());
+        } else {
+            rows = getPrefRows();
+        }
+        return in.getTop() + span(rows, getTileHeight(), snapSpaceY(getVgap())) + in.getBottom();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> managed = getManagedChildren();
+        Insets in = getInsets();
+        double insideWidth = getWidth() - in.getLeft() - in.getRight();
+        double insideHeight = getHeight() - in.getTop() - in.getBottom();
+        double hg = snapSpaceX(getHgap());
+        double vg = snapSpaceY(getVgap());
+        double tileW = Math.min(getTileWidth(), Math.max(0, insideWidth));
+        double tileH = Math.min(getTileHeight(), Math.max(0, insideHeight));
+        Pos pos = alignment.get() == null ? Pos.TOP_LEFT : alignment.get();
+        Pos inTile = tileAlignment.get() == null ? Pos.CENTER : tileAlignment.get();
+        HPos hpos = pos.getHpos();
+        VPos vpos = pos.getVpos();
+        boolean horizontal = getOrientation() == Orientation.HORIZONTAL;
+        int count = managed.size();
+        int columns;
+        int rows;
+        int lastRow = 0;
+        int lastColumn = 0;
+        if (horizontal) {
+            columns = fitting(insideWidth, tileW, hg);
+            rows = linesFor(count, columns);
+            lastRow = hpos != HPos.LEFT ? columns - (columns * rows - count) : 0;
+        } else {
+            rows = fitting(insideHeight, tileH, vg);
+            columns = linesFor(count, rows);
+            lastColumn = vpos != VPos.TOP && vpos != VPos.BASELINE ? rows - (columns * rows - count) : 0;
+        }
+        double rowX = in.getLeft() + LayoutSupport.xOffset(insideWidth, span(columns, tileW, hg), hpos);
+        double columnY = in.getTop() + LayoutSupport.yOffset(insideHeight, span(rows, tileH, vg), vpos);
+        double lastRowX = lastRow > 0 ? in.getLeft() + LayoutSupport.xOffset(insideWidth, span(lastRow, tileW, hg),
+                hpos) : rowX;
+        double lastColumnY = lastColumn > 0 ? in.getTop() + LayoutSupport.yOffset(insideHeight,
+                span(lastColumn, tileH, vg), vpos) : columnY;
+        double areaBaseline = -1;
+        int r = 0;
+        int c = 0;
+        for (int i = 0; i < count; i++) {
+            Node child = managed.get(i);
+            double x = (r == rows - 1 ? lastRowX : rowX) + c * (tileW + hg);
+            double y = (c == columns - 1 ? lastColumnY : columnY) + r * (tileH + vg);
+            Pos own = getAlignment(child);
+            Pos use = own == null ? inTile : own;
+            if (use.getVpos() == VPos.BASELINE) {
+                if (areaBaseline < 0) {
+                    areaBaseline = LayoutSupport.areaBaseline(this, managed, MARGIN);
+                }
+                LayoutSupport.layoutOnBaseline(this, child, x, y, tileW, tileH, areaBaseline, getMargin(child), true,
+                        use.getHpos());
+            } else {
+                layoutInArea(child, x, y, tileW, tileH, 0, getMargin(child), use.getHpos(), use.getVpos());
+            }
+            if (horizontal) {
+                c++;
+                if (c == columns) {
+                    c = 0;
+                    r++;
+                }
+            } else {
+                r++;
+                if (r == rows) {
+                    r = 0;
+                    c++;
+                }
+            }
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-hgap".equals(property)) {
+            return Double.valueOf(getHgap());
+        } else if ("-fx-vgap".equals(property)) {
+            return Double.valueOf(getVgap());
+        } else if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        } else if ("-fx-orientation".equals(property)) {
+            return getOrientation();
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-hgap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setHgap(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-vgap".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setVgap(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-alignment".equals(property)) {
+            Pos p = LayoutSupport.toPos(value);
+            if (value != null && p == null) {
+                return false;
+            }
+            setAlignment(p);
+            return true;
+        } else if ("-fx-orientation".equals(property)) {
+            Orientation o = LayoutSupport.toOrientation(value);
+            if (o == null) {
+                return false;
+            }
+            setOrientation(o);
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/VBox.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/VBox.java
new file mode 100644
index 00000000000..07ddc23480f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/VBox.java
@@ -0,0 +1,293 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.layout;
+
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+
+/// Lays its managed children out in one column, top to bottom, in the order of the list.
+///
+/// Each child gets its preferred height. When the box is taller than
+/// its children need, the spare space goes in equal shares to the
+/// children whose vgrow priority is `ALWAYS`, each up to its maximum
+/// height, and only if space is still left to those with `SOMETIMES`.
+/// When the box is shorter, every child gives up an equal share down to
+/// its minimum height. Shares are whole device pixels, so up to one
+/// logical pixel may stay unused. Spare space nobody takes is placed
+/// according to the vertical part of `alignment`.
+///
+/// Across the box a resizable child is stretched to the width of the
+/// box, up to its own maximum, while `fillWidth` is set; otherwise it keeps
+/// its preferred width. The horizontal part of `alignment` places a child
+/// that does not fill the width.
+///
+/// A column has no shared baseline: a baseline alignment places the
+/// children like the matching top alignment.
+///
+/// #### Styling
+///
+/// Besides the names of a region: `-fx-spacing` (`Number`),
+/// `-fx-alignment` (`javafx.geometry.Pos`, or its CSS spelling such as
+/// `"center-left"` as a `String`, matched without regard to ASCII case)
+/// and `-fx-fill-width` (`Boolean`).
+public class VBox extends Pane {
+
+    private static final String MARGIN = "vbox-margin";
+    private static final String GROW = "vbox-vgrow";
+
+    private final DoubleProperty spacing = new FxDouble(this, "spacing", 0, Dirty.LAYOUT);
+    private final ObjectProperty<Pos> alignment = new FxObject<Pos>(this, "alignment", Pos.TOP_LEFT, Dirty.LAYOUT);
+    private final BooleanProperty fill = new FxBoolean(this, "fillWidth", true, Dirty.LAYOUT);
+
+    /// Creates an empty box without spacing.
+    public VBox() {
+    }
+
+    /// Creates an empty box with a gap between its children.
+    public VBox(double spacing) {
+        this.spacing.set(spacing);
+    }
+
+    /// Creates a box with children and no spacing.
+    public VBox(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Creates a box with children and a gap between them.
+    public VBox(double spacing, Node... children) {
+        this.spacing.set(spacing);
+        cn1Children().addAll(children);
+    }
+
+    /// Sets how eagerly a child takes spare height in a VBox; `null`
+    /// removes the constraint.
+    public static void setVgrow(Node child, Priority value) {
+        setConstraint(child, GROW, value);
+    }
+
+    /// Returns the vgrow priority of a child, or `null`.
+    public static Priority getVgrow(Node child) {
+        return LayoutSupport.priority(child, GROW);
+    }
+
+    /// Sets the space kept free around a child in a VBox; `null`
+    /// removes the constraint.
+    public static void setMargin(Node child, Insets value) {
+        setConstraint(child, MARGIN, value);
+    }
+
+    /// Returns the margin of a child, or `null`.
+    public static Insets getMargin(Node child) {
+        return LayoutSupport.insets(child, MARGIN);
+    }
+
+    /// Removes the VBox constraints from a child.
+    public static void clearConstraints(Node child) {
+        setVgrow(child, null);
+        setMargin(child, null);
+    }
+
+    /// Returns the gap between neighbouring children.
+    public final double getSpacing() {
+        return spacing.get();
+    }
+
+    /// Sets the gap between neighbouring children.
+    public final void setSpacing(double value) {
+        spacing.set(value);
+    }
+
+    /// The gap between neighbouring children.
+    public final DoubleProperty spacingProperty() {
+        return spacing;
+    }
+
+    /// Returns where the children sit when the box has room to spare.
+    public final Pos getAlignment() {
+        return alignment.get();
+    }
+
+    /// Sets where the children sit when the box has room to spare.
+    public final void setAlignment(Pos value) {
+        alignment.set(value);
+    }
+
+    /// Where the children sit when the box has room to spare.
+    public final ObjectProperty<Pos> alignmentProperty() {
+        return alignment;
+    }
+
+    /// Returns whether resizable children are stretched to the width of
+    /// the box.
+    public final boolean isFillWidth() {
+        return fill.get();
+    }
+
+    /// Sets whether resizable children are stretched to the width of the
+    /// box.
+    public final void setFillWidth(boolean value) {
+        fill.set(value);
+    }
+
+    /// Whether resizable children are stretched to the width of the box.
+    public final BooleanProperty fillWidthProperty() {
+        return fill;
+    }
+
+    private Pos align() {
+        Pos p = alignment.get();
+        return p == null ? Pos.TOP_LEFT : p;
+    }
+
+    private double gap() {
+        return snapSpaceY(getSpacing());
+    }
+
+    @Override
+    public Orientation getContentBias() {
+        List<Node> managed = getManagedChildren();
+        return LayoutSupport.bias(managed);
+    }
+
+    private double[] areaHeights(List<Node> managed, double width, boolean minimum) {
+        Insets in = getInsets();
+        double inside = width == -1 || !isFillWidth() ? -1 : width - in.getLeft() - in.getRight();
+        return LayoutSupport.areaSizes(this, managed, false, MARGIN, inside, minimum);
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        return in.getTop() + LayoutSupport.sum(areaHeights(managed, width, true), gap()) + in.getBottom();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        return in.getTop() + LayoutSupport.sum(areaHeights(managed, width, false), gap()) + in.getBottom();
+    }
+
+    private double contentWidth(double height, boolean minimum) {
+        Insets in = getInsets();
+        List<Node> managed = getManagedChildren();
+        double[] heights = null;
+        if (height != -1 && getContentBias() == Orientation.VERTICAL) {
+            heights = areaHeights(managed, -1, false);
+            LayoutSupport.fit(this, managed, false, MARGIN, GROW, heights, gap(),
+                    height - in.getTop() - in.getBottom(), -1);
+        }
+        return LayoutSupport.maxCross(this, managed, false, MARGIN, heights, minimum);
+    }
+
+    @Override
+    protected double computeMinWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + contentWidth(height, true) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + contentWidth(height, false) + in.getRight();
+    }
+
+    @Override
+    protected void layoutChildren() {
+        List<Node> managed = getManagedChildren();
+        Insets in = getInsets();
+        double width = getWidth();
+        double height = getHeight();
+        double insideWidth = width - in.getLeft() - in.getRight();
+        double insideHeight = height - in.getTop() - in.getBottom();
+        double gap = gap();
+        Pos pos = align();
+        boolean fillWidth = isFillWidth();
+        // A column has no shared baseline: a baseline alignment places
+        // the children like a top alignment.
+        VPos vpos = pos.getVpos() == VPos.BASELINE ? VPos.TOP : pos.getVpos();
+        double[] heights = areaHeights(managed, width, false);
+        double used = LayoutSupport.fit(this, managed, false, MARGIN, GROW, heights, gap, insideHeight,
+                fillWidth ? insideWidth : -1);
+        double x = in.getLeft();
+        double y = in.getTop() + LayoutSupport.yOffset(insideHeight, used, vpos);
+        for (int i = 0; i < heights.length; i++) {
+            Node child = managed.get(i);
+            layoutInArea(child, x, y, insideWidth, heights[i], 0, getMargin(child), fillWidth, true, pos.getHpos(),
+                    vpos);
+            y += heights[i] + gap;
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-spacing".equals(property)) {
+            return Double.valueOf(getSpacing());
+        } else if ("-fx-alignment".equals(property)) {
+            return getAlignment();
+        } else if ("-fx-fill-width".equals(property)) {
+            return Boolean.valueOf(isFillWidth());
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-spacing".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setSpacing(((Number) value).doubleValue());
+            return true;
+        } else if ("-fx-alignment".equals(property)) {
+            Pos p = LayoutSupport.toPos(value);
+            if (value != null && p == null) {
+                return false;
+            }
+            setAlignment(p);
+            return true;
+        } else if ("-fx-fill-width".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            setFillWidth(((Boolean) value).booleanValue());
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/layout/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/layout/package-info.java
new file mode 100644
index 00000000000..f7f71e27941
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/layout/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Regions and layout panes, and the backgrounds and borders of a region.
+package javafx.scene.layout;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/package-info.java
new file mode 100644
index 00000000000..bc222aeb49f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The scene graph: nodes, parents, groups, the scene that holds them and
+/// the mouse cursor.
+package javafx.scene;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/Color.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/Color.java
new file mode 100644
index 00000000000..423ff536822
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/Color.java
@@ -0,0 +1,925 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.paint;
+
+import java.util.HashMap;
+
+import javafx.animation.Interpolatable;
+import javafx.beans.NamedArg;
+
+/// A colour in the sRGB space with an opacity. Each component is a number
+/// from 0 to 1.
+public final class Color extends Paint implements Interpolatable<Color> {
+
+    private static final HashMap<String, Color> NAMED = new HashMap<String, Color>();
+    private static final double DARKER_BRIGHTER_FACTOR = 0.7;
+    private static final double SATURATE_DESATURATE_FACTOR = 0.7;
+
+    /// A fully transparent colour.
+    public static final Color TRANSPARENT = new Color(0, 0, 0, 0);
+
+    /// The colour `aliceblue`, `#F0F8FF`.
+    public static final Color ALICEBLUE = named("aliceblue", 0xF0F8FF);
+
+    /// The colour `antiquewhite`, `#FAEBD7`.
+    public static final Color ANTIQUEWHITE = named("antiquewhite", 0xFAEBD7);
+
+    /// The colour `aqua`, `#00FFFF`.
+    public static final Color AQUA = named("aqua", 0x00FFFF);
+
+    /// The colour `aquamarine`, `#7FFFD4`.
+    public static final Color AQUAMARINE = named("aquamarine", 0x7FFFD4);
+
+    /// The colour `azure`, `#F0FFFF`.
+    public static final Color AZURE = named("azure", 0xF0FFFF);
+
+    /// The colour `beige`, `#F5F5DC`.
+    public static final Color BEIGE = named("beige", 0xF5F5DC);
+
+    /// The colour `bisque`, `#FFE4C4`.
+    public static final Color BISQUE = named("bisque", 0xFFE4C4);
+
+    /// The colour `black`, `#000000`.
+    public static final Color BLACK = named("black", 0x000000);
+
+    /// The colour `blanchedalmond`, `#FFEBCD`.
+    public static final Color BLANCHEDALMOND = named("blanchedalmond", 0xFFEBCD);
+
+    /// The colour `blue`, `#0000FF`.
+    public static final Color BLUE = named("blue", 0x0000FF);
+
+    /// The colour `blueviolet`, `#8A2BE2`.
+    public static final Color BLUEVIOLET = named("blueviolet", 0x8A2BE2);
+
+    /// The colour `brown`, `#A52A2A`.
+    public static final Color BROWN = named("brown", 0xA52A2A);
+
+    /// The colour `burlywood`, `#DEB887`.
+    public static final Color BURLYWOOD = named("burlywood", 0xDEB887);
+
+    /// The colour `cadetblue`, `#5F9EA0`.
+    public static final Color CADETBLUE = named("cadetblue", 0x5F9EA0);
+
+    /// The colour `chartreuse`, `#7FFF00`.
+    public static final Color CHARTREUSE = named("chartreuse", 0x7FFF00);
+
+    /// The colour `chocolate`, `#D2691E`.
+    public static final Color CHOCOLATE = named("chocolate", 0xD2691E);
+
+    /// The colour `coral`, `#FF7F50`.
+    public static final Color CORAL = named("coral", 0xFF7F50);
+
+    /// The colour `cornflowerblue`, `#6495ED`.
+    public static final Color CORNFLOWERBLUE = named("cornflowerblue", 0x6495ED);
+
+    /// The colour `cornsilk`, `#FFF8DC`.
+    public static final Color CORNSILK = named("cornsilk", 0xFFF8DC);
+
+    /// The colour `crimson`, `#DC143C`.
+    public static final Color CRIMSON = named("crimson", 0xDC143C);
+
+    /// The colour `cyan`, `#00FFFF`.
+    public static final Color CYAN = named("cyan", 0x00FFFF);
+
+    /// The colour `darkblue`, `#00008B`.
+    public static final Color DARKBLUE = named("darkblue", 0x00008B);
+
+    /// The colour `darkcyan`, `#008B8B`.
+    public static final Color DARKCYAN = named("darkcyan", 0x008B8B);
+
+    /// The colour `darkgoldenrod`, `#B8860B`.
+    public static final Color DARKGOLDENROD = named("darkgoldenrod", 0xB8860B);
+
+    /// The colour `darkgray`, `#A9A9A9`.
+    public static final Color DARKGRAY = named("darkgray", 0xA9A9A9);
+
+    /// The colour `darkgreen`, `#006400`.
+    public static final Color DARKGREEN = named("darkgreen", 0x006400);
+
+    /// The colour `darkgrey`, `#A9A9A9`.
+    public static final Color DARKGREY = named("darkgrey", 0xA9A9A9);
+
+    /// The colour `darkkhaki`, `#BDB76B`.
+    public static final Color DARKKHAKI = named("darkkhaki", 0xBDB76B);
+
+    /// The colour `darkmagenta`, `#8B008B`.
+    public static final Color DARKMAGENTA = named("darkmagenta", 0x8B008B);
+
+    /// The colour `darkolivegreen`, `#556B2F`.
+    public static final Color DARKOLIVEGREEN = named("darkolivegreen", 0x556B2F);
+
+    /// The colour `darkorange`, `#FF8C00`.
+    public static final Color DARKORANGE = named("darkorange", 0xFF8C00);
+
+    /// The colour `darkorchid`, `#9932CC`.
+    public static final Color DARKORCHID = named("darkorchid", 0x9932CC);
+
+    /// The colour `darkred`, `#8B0000`.
+    public static final Color DARKRED = named("darkred", 0x8B0000);
+
+    /// The colour `darksalmon`, `#E9967A`.
+    public static final Color DARKSALMON = named("darksalmon", 0xE9967A);
+
+    /// The colour `darkseagreen`, `#8FBC8F`.
+    public static final Color DARKSEAGREEN = named("darkseagreen", 0x8FBC8F);
+
+    /// The colour `darkslateblue`, `#483D8B`.
+    public static final Color DARKSLATEBLUE = named("darkslateblue", 0x483D8B);
+
+    /// The colour `darkslategray`, `#2F4F4F`.
+    public static final Color DARKSLATEGRAY = named("darkslategray", 0x2F4F4F);
+
+    /// The colour `darkslategrey`, `#2F4F4F`.
+    public static final Color DARKSLATEGREY = named("darkslategrey", 0x2F4F4F);
+
+    /// The colour `darkturquoise`, `#00CED1`.
+    public static final Color DARKTURQUOISE = named("darkturquoise", 0x00CED1);
+
+    /// The colour `darkviolet`, `#9400D3`.
+    public static final Color DARKVIOLET = named("darkviolet", 0x9400D3);
+
+    /// The colour `deeppink`, `#FF1493`.
+    public static final Color DEEPPINK = named("deeppink", 0xFF1493);
+
+    /// The colour `deepskyblue`, `#00BFFF`.
+    public static final Color DEEPSKYBLUE = named("deepskyblue", 0x00BFFF);
+
+    /// The colour `dimgray`, `#696969`.
+    public static final Color DIMGRAY = named("dimgray", 0x696969);
+
+    /// The colour `dimgrey`, `#696969`.
+    public static final Color DIMGREY = named("dimgrey", 0x696969);
+
+    /// The colour `dodgerblue`, `#1E90FF`.
+    public static final Color DODGERBLUE = named("dodgerblue", 0x1E90FF);
+
+    /// The colour `firebrick`, `#B22222`.
+    public static final Color FIREBRICK = named("firebrick", 0xB22222);
+
+    /// The colour `floralwhite`, `#FFFAF0`.
+    public static final Color FLORALWHITE = named("floralwhite", 0xFFFAF0);
+
+    /// The colour `forestgreen`, `#228B22`.
+    public static final Color FORESTGREEN = named("forestgreen", 0x228B22);
+
+    /// The colour `fuchsia`, `#FF00FF`.
+    public static final Color FUCHSIA = named("fuchsia", 0xFF00FF);
+
+    /// The colour `gainsboro`, `#DCDCDC`.
+    public static final Color GAINSBORO = named("gainsboro", 0xDCDCDC);
+
+    /// The colour `ghostwhite`, `#F8F8FF`.
+    public static final Color GHOSTWHITE = named("ghostwhite", 0xF8F8FF);
+
+    /// The colour `gold`, `#FFD700`.
+    public static final Color GOLD = named("gold", 0xFFD700);
+
+    /// The colour `goldenrod`, `#DAA520`.
+    public static final Color GOLDENROD = named("goldenrod", 0xDAA520);
+
+    /// The colour `gray`, `#808080`.
+    public static final Color GRAY = named("gray", 0x808080);
+
+    /// The colour `green`, `#008000`.
+    public static final Color GREEN = named("green", 0x008000);
+
+    /// The colour `greenyellow`, `#ADFF2F`.
+    public static final Color GREENYELLOW = named("greenyellow", 0xADFF2F);
+
+    /// The colour `grey`, `#808080`.
+    public static final Color GREY = named("grey", 0x808080);
+
+    /// The colour `honeydew`, `#F0FFF0`.
+    public static final Color HONEYDEW = named("honeydew", 0xF0FFF0);
+
+    /// The colour `hotpink`, `#FF69B4`.
+    public static final Color HOTPINK = named("hotpink", 0xFF69B4);
+
+    /// The colour `indianred`, `#CD5C5C`.
+    public static final Color INDIANRED = named("indianred", 0xCD5C5C);
+
+    /// The colour `indigo`, `#4B0082`.
+    public static final Color INDIGO = named("indigo", 0x4B0082);
+
+    /// The colour `ivory`, `#FFFFF0`.
+    public static final Color IVORY = named("ivory", 0xFFFFF0);
+
+    /// The colour `khaki`, `#F0E68C`.
+    public static final Color KHAKI = named("khaki", 0xF0E68C);
+
+    /// The colour `lavender`, `#E6E6FA`.
+    public static final Color LAVENDER = named("lavender", 0xE6E6FA);
+
+    /// The colour `lavenderblush`, `#FFF0F5`.
+    public static final Color LAVENDERBLUSH = named("lavenderblush", 0xFFF0F5);
+
+    /// The colour `lawngreen`, `#7CFC00`.
+    public static final Color LAWNGREEN = named("lawngreen", 0x7CFC00);
+
+    /// The colour `lemonchiffon`, `#FFFACD`.
+    public static final Color LEMONCHIFFON = named("lemonchiffon", 0xFFFACD);
+
+    /// The colour `lightblue`, `#ADD8E6`.
+    public static final Color LIGHTBLUE = named("lightblue", 0xADD8E6);
+
+    /// The colour `lightcoral`, `#F08080`.
+    public static final Color LIGHTCORAL = named("lightcoral", 0xF08080);
+
+    /// The colour `lightcyan`, `#E0FFFF`.
+    public static final Color LIGHTCYAN = named("lightcyan", 0xE0FFFF);
+
+    /// The colour `lightgoldenrodyellow`, `#FAFAD2`.
+    public static final Color LIGHTGOLDENRODYELLOW = named("lightgoldenrodyellow", 0xFAFAD2);
+
+    /// The colour `lightgray`, `#D3D3D3`.
+    public static final Color LIGHTGRAY = named("lightgray", 0xD3D3D3);
+
+    /// The colour `lightgreen`, `#90EE90`.
+    public static final Color LIGHTGREEN = named("lightgreen", 0x90EE90);
+
+    /// The colour `lightgrey`, `#D3D3D3`.
+    public static final Color LIGHTGREY = named("lightgrey", 0xD3D3D3);
+
+    /// The colour `lightpink`, `#FFB6C1`.
+    public static final Color LIGHTPINK = named("lightpink", 0xFFB6C1);
+
+    /// The colour `lightsalmon`, `#FFA07A`.
+    public static final Color LIGHTSALMON = named("lightsalmon", 0xFFA07A);
+
+    /// The colour `lightseagreen`, `#20B2AA`.
+    public static final Color LIGHTSEAGREEN = named("lightseagreen", 0x20B2AA);
+
+    /// The colour `lightskyblue`, `#87CEFA`.
+    public static final Color LIGHTSKYBLUE = named("lightskyblue", 0x87CEFA);
+
+    /// The colour `lightslategray`, `#778899`.
+    public static final Color LIGHTSLATEGRAY = named("lightslategray", 0x778899);
+
+    /// The colour `lightslategrey`, `#778899`.
+    public static final Color LIGHTSLATEGREY = named("lightslategrey", 0x778899);
+
+    /// The colour `lightsteelblue`, `#B0C4DE`.
+    public static final Color LIGHTSTEELBLUE = named("lightsteelblue", 0xB0C4DE);
+
+    /// The colour `lightyellow`, `#FFFFE0`.
+    public static final Color LIGHTYELLOW = named("lightyellow", 0xFFFFE0);
+
+    /// The colour `lime`, `#00FF00`.
+    public static final Color LIME = named("lime", 0x00FF00);
+
+    /// The colour `limegreen`, `#32CD32`.
+    public static final Color LIMEGREEN = named("limegreen", 0x32CD32);
+
+    /// The colour `linen`, `#FAF0E6`.
+    public static final Color LINEN = named("linen", 0xFAF0E6);
+
+    /// The colour `magenta`, `#FF00FF`.
+    public static final Color MAGENTA = named("magenta", 0xFF00FF);
+
+    /// The colour `maroon`, `#800000`.
+    public static final Color MAROON = named("maroon", 0x800000);
+
+    /// The colour `mediumaquamarine`, `#66CDAA`.
+    public static final Color MEDIUMAQUAMARINE = named("mediumaquamarine", 0x66CDAA);
+
+    /// The colour `mediumblue`, `#0000CD`.
+    public static final Color MEDIUMBLUE = named("mediumblue", 0x0000CD);
+
+    /// The colour `mediumorchid`, `#BA55D3`.
+    public static final Color MEDIUMORCHID = named("mediumorchid", 0xBA55D3);
+
+    /// The colour `mediumpurple`, `#9370DB`.
+    public static final Color MEDIUMPURPLE = named("mediumpurple", 0x9370DB);
+
+    /// The colour `mediumseagreen`, `#3CB371`.
+    public static final Color MEDIUMSEAGREEN = named("mediumseagreen", 0x3CB371);
+
+    /// The colour `mediumslateblue`, `#7B68EE`.
+    public static final Color MEDIUMSLATEBLUE = named("mediumslateblue", 0x7B68EE);
+
+    /// The colour `mediumspringgreen`, `#00FA9A`.
+    public static final Color MEDIUMSPRINGGREEN = named("mediumspringgreen", 0x00FA9A);
+
+    /// The colour `mediumturquoise`, `#48D1CC`.
+    public static final Color MEDIUMTURQUOISE = named("mediumturquoise", 0x48D1CC);
+
+    /// The colour `mediumvioletred`, `#C71585`.
+    public static final Color MEDIUMVIOLETRED = named("mediumvioletred", 0xC71585);
+
+    /// The colour `midnightblue`, `#191970`.
+    public static final Color MIDNIGHTBLUE = named("midnightblue", 0x191970);
+
+    /// The colour `mintcream`, `#F5FFFA`.
+    public static final Color MINTCREAM = named("mintcream", 0xF5FFFA);
+
+    /// The colour `mistyrose`, `#FFE4E1`.
+    public static final Color MISTYROSE = named("mistyrose", 0xFFE4E1);
+
+    /// The colour `moccasin`, `#FFE4B5`.
+    public static final Color MOCCASIN = named("moccasin", 0xFFE4B5);
+
+    /// The colour `navajowhite`, `#FFDEAD`.
+    public static final Color NAVAJOWHITE = named("navajowhite", 0xFFDEAD);
+
+    /// The colour `navy`, `#000080`.
+    public static final Color NAVY = named("navy", 0x000080);
+
+    /// The colour `oldlace`, `#FDF5E6`.
+    public static final Color OLDLACE = named("oldlace", 0xFDF5E6);
+
+    /// The colour `olive`, `#808000`.
+    public static final Color OLIVE = named("olive", 0x808000);
+
+    /// The colour `olivedrab`, `#6B8E23`.
+    public static final Color OLIVEDRAB = named("olivedrab", 0x6B8E23);
+
+    /// The colour `orange`, `#FFA500`.
+    public static final Color ORANGE = named("orange", 0xFFA500);
+
+    /// The colour `orangered`, `#FF4500`.
+    public static final Color ORANGERED = named("orangered", 0xFF4500);
+
+    /// The colour `orchid`, `#DA70D6`.
+    public static final Color ORCHID = named("orchid", 0xDA70D6);
+
+    /// The colour `palegoldenrod`, `#EEE8AA`.
+    public static final Color PALEGOLDENROD = named("palegoldenrod", 0xEEE8AA);
+
+    /// The colour `palegreen`, `#98FB98`.
+    public static final Color PALEGREEN = named("palegreen", 0x98FB98);
+
+    /// The colour `paleturquoise`, `#AFEEEE`.
+    public static final Color PALETURQUOISE = named("paleturquoise", 0xAFEEEE);
+
+    /// The colour `palevioletred`, `#DB7093`.
+    public static final Color PALEVIOLETRED = named("palevioletred", 0xDB7093);
+
+    /// The colour `papayawhip`, `#FFEFD5`.
+    public static final Color PAPAYAWHIP = named("papayawhip", 0xFFEFD5);
+
+    /// The colour `peachpuff`, `#FFDAB9`.
+    public static final Color PEACHPUFF = named("peachpuff", 0xFFDAB9);
+
+    /// The colour `peru`, `#CD853F`.
+    public static final Color PERU = named("peru", 0xCD853F);
+
+    /// The colour `pink`, `#FFC0CB`.
+    public static final Color PINK = named("pink", 0xFFC0CB);
+
+    /// The colour `plum`, `#DDA0DD`.
+    public static final Color PLUM = named("plum", 0xDDA0DD);
+
+    /// The colour `powderblue`, `#B0E0E6`.
+    public static final Color POWDERBLUE = named("powderblue", 0xB0E0E6);
+
+    /// The colour `purple`, `#800080`.
+    public static final Color PURPLE = named("purple", 0x800080);
+
+    /// The colour `red`, `#FF0000`.
+    public static final Color RED = named("red", 0xFF0000);
+
+    /// The colour `rosybrown`, `#BC8F8F`.
+    public static final Color ROSYBROWN = named("rosybrown", 0xBC8F8F);
+
+    /// The colour `royalblue`, `#4169E1`.
+    public static final Color ROYALBLUE = named("royalblue", 0x4169E1);
+
+    /// The colour `saddlebrown`, `#8B4513`.
+    public static final Color SADDLEBROWN = named("saddlebrown", 0x8B4513);
+
+    /// The colour `salmon`, `#FA8072`.
+    public static final Color SALMON = named("salmon", 0xFA8072);
+
+    /// The colour `sandybrown`, `#F4A460`.
+    public static final Color SANDYBROWN = named("sandybrown", 0xF4A460);
+
+    /// The colour `seagreen`, `#2E8B57`.
+    public static final Color SEAGREEN = named("seagreen", 0x2E8B57);
+
+    /// The colour `seashell`, `#FFF5EE`.
+    public static final Color SEASHELL = named("seashell", 0xFFF5EE);
+
+    /// The colour `sienna`, `#A0522D`.
+    public static final Color SIENNA = named("sienna", 0xA0522D);
+
+    /// The colour `silver`, `#C0C0C0`.
+    public static final Color SILVER = named("silver", 0xC0C0C0);
+
+    /// The colour `skyblue`, `#87CEEB`.
+    public static final Color SKYBLUE = named("skyblue", 0x87CEEB);
+
+    /// The colour `slateblue`, `#6A5ACD`.
+    public static final Color SLATEBLUE = named("slateblue", 0x6A5ACD);
+
+    /// The colour `slategray`, `#708090`.
+    public static final Color SLATEGRAY = named("slategray", 0x708090);
+
+    /// The colour `slategrey`, `#708090`.
+    public static final Color SLATEGREY = named("slategrey", 0x708090);
+
+    /// The colour `snow`, `#FFFAFA`.
+    public static final Color SNOW = named("snow", 0xFFFAFA);
+
+    /// The colour `springgreen`, `#00FF7F`.
+    public static final Color SPRINGGREEN = named("springgreen", 0x00FF7F);
+
+    /// The colour `steelblue`, `#4682B4`.
+    public static final Color STEELBLUE = named("steelblue", 0x4682B4);
+
+    /// The colour `tan`, `#D2B48C`.
+    public static final Color TAN = named("tan", 0xD2B48C);
+
+    /// The colour `teal`, `#008080`.
+    public static final Color TEAL = named("teal", 0x008080);
+
+    /// The colour `thistle`, `#D8BFD8`.
+    public static final Color THISTLE = named("thistle", 0xD8BFD8);
+
+    /// The colour `tomato`, `#FF6347`.
+    public static final Color TOMATO = named("tomato", 0xFF6347);
+
+    /// The colour `turquoise`, `#40E0D0`.
+    public static final Color TURQUOISE = named("turquoise", 0x40E0D0);
+
+    /// The colour `violet`, `#EE82EE`.
+    public static final Color VIOLET = named("violet", 0xEE82EE);
+
+    /// The colour `wheat`, `#F5DEB3`.
+    public static final Color WHEAT = named("wheat", 0xF5DEB3);
+
+    /// The colour `white`, `#FFFFFF`.
+    public static final Color WHITE = named("white", 0xFFFFFF);
+
+    /// The colour `whitesmoke`, `#F5F5F5`.
+    public static final Color WHITESMOKE = named("whitesmoke", 0xF5F5F5);
+
+    /// The colour `yellow`, `#FFFF00`.
+    public static final Color YELLOW = named("yellow", 0xFFFF00);
+
+    /// The colour `yellowgreen`, `#9ACD32`.
+    public static final Color YELLOWGREEN = named("yellowgreen", 0x9ACD32);
+
+    static {
+        NAMED.put("transparent", TRANSPARENT);
+    }
+
+    private final float red;
+    private final float green;
+    private final float blue;
+    private final float opacity;
+
+    /// Creates a colour from its components, each from 0 to 1.
+    public Color(@NamedArg("red") double red, @NamedArg("green") double green, @NamedArg("blue") double blue,
+            @NamedArg(value = "opacity", defaultValue = "1") double opacity) {
+        check(red, "red");
+        check(green, "green");
+        check(blue, "blue");
+        check(opacity, "opacity");
+        this.red = (float) red;
+        this.green = (float) green;
+        this.blue = (float) blue;
+        this.opacity = (float) opacity;
+    }
+
+    private static void check(double value, String name) {
+        if (!(value >= 0 && value <= 1)) {
+            throw new IllegalArgumentException("Color's " + name + " value (" + value + ") must be in the range 0.0-1.0");
+        }
+    }
+
+    private static Color named(String name, int rgb) {
+        Color c = rgb((rgb >> 16) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff);
+        NAMED.put(name, c);
+        return c;
+    }
+
+    /// Creates a colour from components from 0 to 1.
+    public static Color color(double red, double green, double blue, double opacity) {
+        return new Color(red, green, blue, opacity);
+    }
+
+    /// Creates an opaque colour from components from 0 to 1.
+    public static Color color(double red, double green, double blue) {
+        return new Color(red, green, blue, 1);
+    }
+
+    /// Creates a colour from components from 0 to 255 and an opacity.
+    public static Color rgb(int red, int green, int blue, double opacity) {
+        checkByte(red, "red");
+        checkByte(green, "green");
+        checkByte(blue, "blue");
+        return new Color(red / 255.0, green / 255.0, blue / 255.0, opacity);
+    }
+
+    /// Creates an opaque colour from components from 0 to 255.
+    public static Color rgb(int red, int green, int blue) {
+        return rgb(red, green, blue, 1);
+    }
+
+    private static void checkByte(int value, String name) {
+        if (value < 0 || value > 255) {
+            throw new IllegalArgumentException("Color.rgb's " + name + " parameter (" + value + ") expects color values 0-255");
+        }
+    }
+
+    /// Creates an opaque grey from 0 to 255.
+    public static Color grayRgb(int gray) {
+        return rgb(gray, gray, gray);
+    }
+
+    /// Creates a grey from 0 to 255 with an opacity.
+    public static Color grayRgb(int gray, double opacity) {
+        return rgb(gray, gray, gray, opacity);
+    }
+
+    /// Creates a grey from 0 to 1 with an opacity.
+    public static Color gray(double gray, double opacity) {
+        return new Color(gray, gray, gray, opacity);
+    }
+
+    /// Creates an opaque grey from 0 to 1.
+    public static Color gray(double gray) {
+        return gray(gray, 1);
+    }
+
+    /// Creates a colour from hue in degrees, saturation and brightness.
+    public static Color hsb(double hue, double saturation, double brightness, double opacity) {
+        if (!(saturation >= 0 && saturation <= 1)) {
+            throw new IllegalArgumentException("Color.hsb's saturation parameter (" + saturation + ") expects values 0.0-1.0");
+        }
+        if (!(brightness >= 0 && brightness <= 1)) {
+            throw new IllegalArgumentException("Color.hsb's brightness parameter (" + brightness + ") expects values 0.0-1.0");
+        }
+        double[] rgb = hsbToRgb(hue, saturation, brightness);
+        return new Color(rgb[0], rgb[1], rgb[2], opacity);
+    }
+
+    /// Creates an opaque colour from hue, saturation and brightness.
+    public static Color hsb(double hue, double saturation, double brightness) {
+        return hsb(hue, saturation, brightness, 1);
+    }
+
+    /// Parses a colour as written in HTML or CSS: a name, `#rgb`,
+    /// `#rrggbb`, `#rrggbbaa`, `0x...`, `rgb(...)`, `rgba(...)`,
+    /// `hsl(...)` or `hsla(...)`; the opacity scales the result.
+    public static Color web(String colorString, double opacity) {
+        if (colorString == null) {
+            throw new NullPointerException("The color components or name must be specified");
+        }
+        String color = lower(colorString.trim());
+        if (color.length() == 0) {
+            throw new IllegalArgumentException("Invalid color specification");
+        }
+        if (color.startsWith("#")) {
+            return hex(color.substring(1), opacity);
+        }
+        if (color.startsWith("0x")) {
+            return hex(color.substring(2), opacity);
+        }
+        if (color.startsWith("rgba(") || color.startsWith("rgb(") || color.startsWith("hsla(")
+                || color.startsWith("hsl(")) {
+            return functional(color, opacity);
+        }
+        Color named = NAMED.get(color);
+        if (named != null) {
+            if (opacity == 1) {
+                return named;
+            }
+            return new Color(named.red, named.green, named.blue, named.opacity * opacity);
+        }
+        return hex(color, opacity);
+    }
+
+    /// Parses a colour as written in HTML or CSS.
+    public static Color web(String colorString) {
+        return web(colorString, 1);
+    }
+
+    /// Parses a colour; the same as [#web(String)].
+    public static Color valueOf(String value) {
+        if (value == null) {
+            throw new NullPointerException("color must be specified");
+        }
+        return web(value);
+    }
+
+    private static String lower(String s) {
+        StringBuilder out = new StringBuilder(s.length());
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            out.append(c >= 'A' && c <= 'Z' ? (char) (c + 32) : c);
+        }
+        return out.toString();
+    }
+
+    private static int digit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        throw new IllegalArgumentException("Invalid color specification");
+    }
+
+    private static Color hex(String h, double opacity) {
+        int len = h.length();
+        int r;
+        int g;
+        int b;
+        int a = 255;
+        if (len == 3 || len == 4) {
+            r = digit(h.charAt(0)) * 17;
+            g = digit(h.charAt(1)) * 17;
+            b = digit(h.charAt(2)) * 17;
+            if (len == 4) {
+                a = digit(h.charAt(3)) * 17;
+            }
+        } else if (len == 6 || len == 8) {
+            r = digit(h.charAt(0)) * 16 + digit(h.charAt(1));
+            g = digit(h.charAt(2)) * 16 + digit(h.charAt(3));
+            b = digit(h.charAt(4)) * 16 + digit(h.charAt(5));
+            if (len == 8) {
+                a = digit(h.charAt(6)) * 16 + digit(h.charAt(7));
+            }
+        } else {
+            throw new IllegalArgumentException("Invalid color specification");
+        }
+        return rgb(r, g, b, opacity * a / 255.0);
+    }
+
+    private static Color functional(String color, double opacity) {
+        int open = color.indexOf('(');
+        int close = color.lastIndexOf(')');
+        if (close < open) {
+            throw new IllegalArgumentException("Invalid color specification");
+        }
+        boolean hsl = color.startsWith("hsl");
+        boolean alpha = color.charAt(open - 1) == 'a';
+        String[] parts = new String[4];
+        int count = 0;
+        int start = open + 1;
+        for (int i = open + 1; i <= close; i++) {
+            if (i == close || color.charAt(i) == ',') {
+                if (count == 4) {
+                    throw new IllegalArgumentException("Invalid color specification");
+                }
+                parts[count++] = color.substring(start, i).trim();
+                start = i + 1;
+            }
+        }
+        if (count != (alpha ? 4 : 3)) {
+            throw new IllegalArgumentException("Invalid color specification");
+        }
+        double a = alpha ? component(parts[3], 1, false) : 1;
+        // The product is checked, not clamped: OpenJFX throws for
+        // web("rgba(255,0,0,0.6)", 2), whose opacity comes to 1.2.
+        if (hsl) {
+            // Read as hue, saturation and BRIGHTNESS, as OpenJFX's Color.web
+            // does -- hsl(0,100%,50%) is 0x800000 there, not red (checked
+            // against OpenJFX 23 and 27). An application keeps the colour it
+            // had on the desktop. Stylesheets do not come through here: the
+            // CSS runtime reads hsl() itself.
+            return hsb(number(parts[0]), component(parts[1], 1, true), component(parts[2], 1, true),
+                    a * opacity);
+        }
+        return new Color(component(parts[0], 255, false), component(parts[1], 255, false),
+                component(parts[2], 255, false), a * opacity);
+    }
+
+    private static double number(String s) {
+        try {
+            return Double.parseDouble(s);
+        } catch (NumberFormatException malformed) {
+            throw new IllegalArgumentException("Invalid color specification");
+        }
+    }
+
+    /// A component out of range is clamped, not rejected: OpenJFX reads
+    /// rgb(300,0,0) as red and rgba(255,0,0,1.5) as opaque (checked against
+    /// OpenJFX 23 and 27), as CSS does. Only the opacity the caller passes
+    /// on top is range checked, by the constructor.
+    private static double component(String s, double range, boolean percentOnly) {
+        if (s.endsWith("%")) {
+            return clamp(number(s.substring(0, s.length() - 1).trim()) / 100.0);
+        }
+        if (percentOnly) {
+            throw new IllegalArgumentException("Invalid color specification");
+        }
+        return clamp(number(s) / range);
+    }
+
+    private static double clamp(double v) {
+        return v < 0 ? 0 : (v > 1 ? 1 : v);
+    }
+
+    private static double[] hsbToRgb(double hue, double saturation, double brightness) {
+        double h = hue - Math.floor(hue / 360.0) * 360.0;
+        h = h / 60.0;
+        int sector = (int) Math.floor(h);
+        double f = h - sector;
+        double p = brightness * (1 - saturation);
+        double q = brightness * (1 - saturation * f);
+        double t = brightness * (1 - saturation * (1 - f));
+        switch (sector) {
+            case 0:
+                return new double[] {brightness, t, p};
+            case 1:
+                return new double[] {q, brightness, p};
+            case 2:
+                return new double[] {p, brightness, t};
+            case 3:
+                return new double[] {p, q, brightness};
+            case 4:
+                return new double[] {t, p, brightness};
+            default:
+                return new double[] {brightness, p, q};
+        }
+    }
+
+    private double[] toHsb() {
+        double max = Math.max(red, Math.max(green, blue));
+        double min = Math.min(red, Math.min(green, blue));
+        double brightness = max;
+        double saturation = max == 0 ? 0 : (max - min) / max;
+        double hue = 0;
+        if (saturation != 0) {
+            double delta = max - min;
+            if (red == max) {
+                hue = (green - blue) / delta;
+            } else if (green == max) {
+                hue = 2.0 + (blue - red) / delta;
+            } else {
+                hue = 4.0 + (red - green) / delta;
+            }
+            hue *= 60;
+            if (hue < 0) {
+                hue += 360;
+            }
+        }
+        return new double[] {hue, saturation, brightness};
+    }
+
+    /// Returns the hue in degrees, 0 to 360.
+    public double getHue() {
+        return toHsb()[0];
+    }
+
+    /// Returns the saturation, 0 to 1.
+    public double getSaturation() {
+        return toHsb()[1];
+    }
+
+    /// Returns the brightness, 0 to 1.
+    public double getBrightness() {
+        return toHsb()[2];
+    }
+
+    /// Returns a colour derived by shifting the hue and scaling the
+    /// saturation, brightness and opacity.
+    public Color deriveColor(double hueShift, double saturationFactor, double brightnessFactor, double opacityFactor) {
+        double[] hsb = toHsb();
+        double b = hsb[2];
+        if (b == 0 && brightnessFactor > 1.0) {
+            b = 0.05;
+        }
+        double h = hsb[0] + hueShift;
+        h = h - Math.floor(h / 360.0) * 360.0;
+        double s = clamp(hsb[1] * saturationFactor);
+        b = clamp(b * brightnessFactor);
+        double a = clamp(opacity * opacityFactor);
+        return hsb(h, s, b, a);
+    }
+
+    /// Returns a brighter version of this colour.
+    public Color brighter() {
+        return deriveColor(0, 1.0, 1.0 / DARKER_BRIGHTER_FACTOR, 1.0);
+    }
+
+    /// Returns a darker version of this colour.
+    public Color darker() {
+        return deriveColor(0, 1.0, DARKER_BRIGHTER_FACTOR, 1.0);
+    }
+
+    /// Returns a more saturated version of this colour.
+    public Color saturate() {
+        return deriveColor(0, 1.0 / SATURATE_DESATURATE_FACTOR, 1.0, 1.0);
+    }
+
+    /// Returns a less saturated version of this colour.
+    public Color desaturate() {
+        return deriveColor(0, SATURATE_DESATURATE_FACTOR, 1.0, 1.0);
+    }
+
+    /// Returns the grey of the same perceived brightness.
+    public Color grayscale() {
+        double gray = 0.21 * red + 0.71 * green + 0.07 * blue;
+        return new Color(gray, gray, gray, opacity);
+    }
+
+    /// Returns the colour with each component inverted.
+    public Color invert() {
+        return new Color(1.0 - red, 1.0 - green, 1.0 - blue, opacity);
+    }
+
+    /// Returns the red component, 0 to 1.
+    public final double getRed() {
+        return red;
+    }
+
+    /// Returns the green component, 0 to 1.
+    public final double getGreen() {
+        return green;
+    }
+
+    /// Returns the blue component, 0 to 1.
+    public final double getBlue() {
+        return blue;
+    }
+
+    /// Returns the opacity, 0 to 1.
+    public final double getOpacity() {
+        return opacity;
+    }
+
+    @Override
+    public final boolean isOpaque() {
+        return opacity >= 1f;
+    }
+
+    @Override
+    public Color interpolate(Color endValue, double t) {
+        if (t <= 0.0) {
+            return this;
+        }
+        if (t >= 1.0) {
+            return endValue;
+        }
+        float ft = (float) t;
+        return new Color(red + (endValue.red - red) * ft, green + (endValue.green - green) * ft,
+                blue + (endValue.blue - blue) * ft, opacity + (endValue.opacity - opacity) * ft);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Color) {
+            Color other = (Color) obj;
+            return cn1Argb() == other.cn1Argb() && Float.floatToIntBits(red) == Float.floatToIntBits(other.red)
+                    && Float.floatToIntBits(green) == Float.floatToIntBits(other.green)
+                    && Float.floatToIntBits(blue) == Float.floatToIntBits(other.blue)
+                    && Float.floatToIntBits(opacity) == Float.floatToIntBits(other.opacity);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return cn1Argb();
+    }
+
+    /// Returns the colour as `0xrrggbbaa`.
+    @Override
+    public String toString() {
+        int argb = cn1Argb();
+        String hex = "0123456789abcdef";
+        StringBuilder out = new StringBuilder("0x");
+        int rgba = (argb << 8) | (argb >>> 24);
+        for (int shift = 28; shift >= 0; shift -= 4) {
+            out.append(hex.charAt((rgba >>> shift) & 0xf));
+        }
+        return out.toString();
+    }
+
+    /// Returns the colour as a packed `0xAARRGGBB` integer, the form
+    /// Codename One takes.
+    public int cn1Argb() {
+        int r = (int) Math.round(red * 255.0);
+        int g = (int) Math.round(green * 255.0);
+        int b = (int) Math.round(blue * 255.0);
+        int a = (int) Math.round(opacity * 255.0);
+        return (a << 24) | (r << 16) | (g << 8) | b;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/CycleMethod.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/CycleMethod.java
new file mode 100644
index 00000000000..4dbc3906e21
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/CycleMethod.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.paint;
+
+/// How a gradient continues outside its bounds.
+public enum CycleMethod {
+    /// The end colours extend outwards.
+    NO_CYCLE,
+    /// The gradient runs back and forth.
+    REFLECT,
+    /// The gradient starts again.
+    REPEAT
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/LinearGradient.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/LinearGradient.java
new file mode 100644
index 00000000000..ad9c4721a4f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/LinearGradient.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.paint;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javafx.beans.NamedArg;
+
+/// A paint that blends colours along a line. With `proportional` set the
+/// line is given in fractions of the bounds of the shape being filled;
+/// otherwise in the shape's own coordinates.
+public final class LinearGradient extends Paint {
+
+    private final double startX;
+    private final double startY;
+    private final double endX;
+    private final double endY;
+    private final boolean proportional;
+    private final CycleMethod cycleMethod;
+    private final List<Stop> stops;
+
+    /// Creates a gradient from stops given one by one.
+    public LinearGradient(@NamedArg("startX") double startX, @NamedArg("startY") double startY,
+            @NamedArg(value = "endX", defaultValue = "1") double endX,
+            @NamedArg(value = "endY", defaultValue = "1") double endY,
+            @NamedArg(value = "proportional", defaultValue = "true") boolean proportional,
+            @NamedArg("cycleMethod") CycleMethod cycleMethod, @NamedArg("stops") Stop... stops) {
+        this(startX, startY, endX, endY, proportional, cycleMethod, asList(stops));
+    }
+
+    /// Creates a gradient from a list of stops.
+    public LinearGradient(@NamedArg("startX") double startX, @NamedArg("startY") double startY,
+            @NamedArg(value = "endX", defaultValue = "1") double endX,
+            @NamedArg(value = "endY", defaultValue = "1") double endY,
+            @NamedArg(value = "proportional", defaultValue = "true") boolean proportional,
+            @NamedArg("cycleMethod") CycleMethod cycleMethod, @NamedArg("stops") List<Stop> stops) {
+        this.startX = startX;
+        this.startY = startY;
+        this.endX = endX;
+        this.endY = endY;
+        this.proportional = proportional;
+        this.cycleMethod = cycleMethod == null ? CycleMethod.NO_CYCLE : cycleMethod;
+        this.stops = Stop.normalize(stops);
+    }
+
+    static List<Stop> asList(Stop[] stops) {
+        ArrayList<Stop> list = new ArrayList<Stop>();
+        if (stops != null) {
+            for (int i = 0; i < stops.length; i++) {
+                list.add(stops[i]);
+            }
+        }
+        return list;
+    }
+
+    /// Returns the x of the start of the line.
+    public final double getStartX() {
+        return startX;
+    }
+
+    /// Returns the y of the start of the line.
+    public final double getStartY() {
+        return startY;
+    }
+
+    /// Returns the x of the end of the line.
+    public final double getEndX() {
+        return endX;
+    }
+
+    /// Returns the y of the end of the line.
+    public final double getEndY() {
+        return endY;
+    }
+
+    /// Returns whether the line is in fractions of the filled bounds.
+    public final boolean isProportional() {
+        return proportional;
+    }
+
+    /// Returns how the gradient continues outside the line.
+    public final CycleMethod getCycleMethod() {
+        return cycleMethod;
+    }
+
+    /// Returns the stops, sorted and covering 0 to 1; unmodifiable.
+    public final List<Stop> getStops() {
+        return stops;
+    }
+
+    @Override
+    public final boolean isOpaque() {
+        for (int i = 0; i < stops.size(); i++) {
+            if (!stops.get(i).getColor().isOpaque()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof LinearGradient) {
+            LinearGradient o = (LinearGradient) obj;
+            return Double.compare(startX, o.startX) == 0 && Double.compare(startY, o.startY) == 0
+                    && Double.compare(endX, o.endX) == 0 && Double.compare(endY, o.endY) == 0
+                    && proportional == o.proportional && cycleMethod == o.cycleMethod && stops.equals(o.stops);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(startX) * 31 + Double.doubleToLongBits(startY) * 17
+                + Double.doubleToLongBits(endX) * 7 + Double.doubleToLongBits(endY);
+        return (int) (bits ^ (bits >>> 32)) * 37 + stops.hashCode() + (proportional ? 1 : 0);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder("linear-gradient(from ").append(startX).append(' ').append(startY)
+                .append(" to ").append(endX).append(' ').append(endY);
+        for (int i = 0; i < stops.size(); i++) {
+            s.append(", ").append(stops.get(i));
+        }
+        return s.append(')').toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/Paint.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/Paint.java
new file mode 100644
index 00000000000..6188924c8ba
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/Paint.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.paint;
+
+/// What a shape is filled or stroked with: a [Color] or a gradient.
+public abstract class Paint {
+
+    Paint() {
+    }
+
+    /// Returns whether the paint covers everything beneath it.
+    public abstract boolean isOpaque();
+
+    /// Parses a paint. Colours in every form [Color#web(String)] takes are
+    /// supported; the textual gradient syntax is not.
+    public static Paint valueOf(String value) {
+        if (value == null) {
+            throw new NullPointerException("paint must be specified");
+        }
+        if (value.length() == 0) {
+            throw new IllegalArgumentException("Invalid paint specification");
+        }
+        return Color.web(value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/RadialGradient.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/RadialGradient.java
new file mode 100644
index 00000000000..81933cb4019
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/RadialGradient.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.paint;
+
+import java.util.List;
+
+import javafx.beans.NamedArg;
+
+/// A paint that blends colours outwards from a point to a circle. With
+/// `proportional` set the centre and radius are fractions of the bounds of
+/// the shape being filled.
+public final class RadialGradient extends Paint {
+
+    private final double focusAngle;
+    private final double focusDistance;
+    private final double centerX;
+    private final double centerY;
+    private final double radius;
+    private final boolean proportional;
+    private final CycleMethod cycleMethod;
+    private final List<Stop> stops;
+
+    /// Creates a gradient from stops given one by one.
+    public RadialGradient(@NamedArg("focusAngle") double focusAngle, @NamedArg("focusDistance") double focusDistance,
+            @NamedArg("centerX") double centerX, @NamedArg("centerY") double centerY,
+            @NamedArg(value = "radius", defaultValue = "1") double radius,
+            @NamedArg(value = "proportional", defaultValue = "true") boolean proportional,
+            @NamedArg("cycleMethod") CycleMethod cycleMethod, @NamedArg("stops") Stop... stops) {
+        this(focusAngle, focusDistance, centerX, centerY, radius, proportional, cycleMethod,
+                LinearGradient.asList(stops));
+    }
+
+    /// Creates a gradient from a list of stops.
+    public RadialGradient(@NamedArg("focusAngle") double focusAngle, @NamedArg("focusDistance") double focusDistance,
+            @NamedArg("centerX") double centerX, @NamedArg("centerY") double centerY,
+            @NamedArg(value = "radius", defaultValue = "1") double radius,
+            @NamedArg(value = "proportional", defaultValue = "true") boolean proportional,
+            @NamedArg("cycleMethod") CycleMethod cycleMethod, @NamedArg("stops") List<Stop> stops) {
+        this.focusAngle = focusAngle;
+        this.focusDistance = focusDistance;
+        this.centerX = centerX;
+        this.centerY = centerY;
+        this.radius = radius;
+        this.proportional = proportional;
+        this.cycleMethod = cycleMethod == null ? CycleMethod.NO_CYCLE : cycleMethod;
+        this.stops = Stop.normalize(stops);
+    }
+
+    /// Returns the angle in degrees from the centre to the focus point.
+    public final double getFocusAngle() {
+        return focusAngle;
+    }
+
+    /// Returns the distance of the focus point from the centre as a
+    /// fraction of the radius.
+    public final double getFocusDistance() {
+        return focusDistance;
+    }
+
+    /// Returns the x of the centre.
+    public final double getCenterX() {
+        return centerX;
+    }
+
+    /// Returns the y of the centre.
+    public final double getCenterY() {
+        return centerY;
+    }
+
+    /// Returns the radius of the circle the last stop lies on.
+    public final double getRadius() {
+        return radius;
+    }
+
+    /// Returns whether centre and radius are fractions of the filled
+    /// bounds.
+    public final boolean isProportional() {
+        return proportional;
+    }
+
+    /// Returns how the gradient continues outside the circle.
+    public final CycleMethod getCycleMethod() {
+        return cycleMethod;
+    }
+
+    /// Returns the stops, sorted and covering 0 to 1; unmodifiable.
+    public final List<Stop> getStops() {
+        return stops;
+    }
+
+    @Override
+    public final boolean isOpaque() {
+        for (int i = 0; i < stops.size(); i++) {
+            if (!stops.get(i).getColor().isOpaque()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof RadialGradient) {
+            RadialGradient o = (RadialGradient) obj;
+            return Double.compare(focusAngle, o.focusAngle) == 0
+                    && Double.compare(focusDistance, o.focusDistance) == 0
+                    && Double.compare(centerX, o.centerX) == 0 && Double.compare(centerY, o.centerY) == 0
+                    && Double.compare(radius, o.radius) == 0 && proportional == o.proportional
+                    && cycleMethod == o.cycleMethod && stops.equals(o.stops);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(centerX) * 31 + Double.doubleToLongBits(centerY) * 17
+                + Double.doubleToLongBits(radius) * 7 + Double.doubleToLongBits(focusAngle);
+        return (int) (bits ^ (bits >>> 32)) * 37 + stops.hashCode() + (proportional ? 1 : 0);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder("radial-gradient(center ").append(centerX).append(' ').append(centerY)
+                .append(", radius ").append(radius);
+        for (int i = 0; i < stops.size(); i++) {
+            s.append(", ").append(stops.get(i));
+        }
+        return s.append(')').toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/Stop.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/Stop.java
new file mode 100644
index 00000000000..5ca6eb80590
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/Stop.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.paint;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javafx.beans.NamedArg;
+
+/// One colour of a gradient and where along it the colour sits, from 0 at
+/// the start to 1 at the end.
+public final class Stop {
+
+    private final double offset;
+    private final Color color;
+
+    /// Creates a stop.
+    public Stop(@NamedArg("offset") double offset, @NamedArg(value = "color", defaultValue = "BLACK") Color color) {
+        this.offset = offset;
+        this.color = color;
+    }
+
+    /// Returns the position, 0 to 1.
+    public final double getOffset() {
+        return offset;
+    }
+
+    /// Returns the colour.
+    public final Color getColor() {
+        return color;
+    }
+
+    /// Returns stops as a gradient uses them: without the ones that have no
+    /// colour, sorted, clamped to 0..1 and with a stop at both ends.
+    static List<Stop> normalize(List<Stop> stops) {
+        ArrayList<Stop> out = new ArrayList<Stop>();
+        if (stops != null) {
+            for (int i = 0; i < stops.size(); i++) {
+                Stop s = stops.get(i);
+                if (s == null || s.color == null) {
+                    continue;
+                }
+                double o = s.offset < 0 ? 0 : (s.offset > 1 ? 1 : s.offset);
+                Stop clamped = s.offset >= 0 && s.offset <= 1 ? s : new Stop(o, s.color);
+                int at = out.size();
+                while (at > 0 && out.get(at - 1).offset > o) {
+                    at--;
+                }
+                out.add(at, clamped);
+            }
+        }
+        if (out.isEmpty()) {
+            out.add(new Stop(0, Color.TRANSPARENT));
+            out.add(new Stop(1, Color.TRANSPARENT));
+        } else {
+            if (out.get(0).offset > 0) {
+                out.add(0, new Stop(0, out.get(0).color));
+            }
+            if (out.get(out.size() - 1).offset < 1) {
+                out.add(new Stop(1, out.get(out.size() - 1).color));
+            }
+        }
+        return Collections.unmodifiableList(out);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Stop) {
+            Stop other = (Stop) obj;
+            return Double.compare(offset, other.offset) == 0
+                    && (color == null ? other.color == null : color.equals(other.color));
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(offset);
+        return 37 * (int) (bits ^ (bits >>> 32)) + (color == null ? 0 : color.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return color + " " + offset * 100 + "%";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/paint/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/paint/package-info.java
new file mode 100644
index 00000000000..53273bd2db2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/paint/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Colours and gradients, the paints shapes, text and backgrounds are
+/// filled and stroked with.
+package javafx.scene.paint;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Arc.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Arc.java
new file mode 100644
index 00000000000..2de256f84f0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Arc.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+
+/// Part of an ellipse, from a start angle over a length, both in degrees.
+/// Angles are counted counter clockwise from the positive x axis, as
+/// JavaFX counts them: a positive length sweeps towards the top of the
+/// screen.
+public class Arc extends Shape {
+
+    private final DoubleProperty centerX = geometry("centerX", 0);
+    private final DoubleProperty centerY = geometry("centerY", 0);
+    private final DoubleProperty radiusX = geometry("radiusX", 0);
+    private final DoubleProperty radiusY = geometry("radiusY", 0);
+    private final DoubleProperty startAngle = geometry("startAngle", 0);
+    private final DoubleProperty length = geometry("length", 0);
+    private final ObjectProperty<ArcType> type = new FxObject<ArcType>(this, "type", ArcType.OPEN, Dirty.GEOMETRY);
+
+    /// Creates an arc of no size.
+    public Arc() {
+    }
+
+    /// Creates an arc of an ellipse.
+    public Arc(double centerX, double centerY, double radiusX, double radiusY, double startAngle, double length) {
+        this.centerX.set(centerX);
+        this.centerY.set(centerY);
+        this.radiusX.set(radiusX);
+        this.radiusY.set(radiusY);
+        this.startAngle.set(startAngle);
+        this.length.set(length);
+    }
+
+    /// Returns the x of the centre.
+    public final double getCenterX() {
+        return centerX.get();
+    }
+
+    /// Sets the x of the centre.
+    public final void setCenterX(double value) {
+        centerX.set(value);
+    }
+
+    /// The x of the centre.
+    public final DoubleProperty centerXProperty() {
+        return centerX;
+    }
+
+    /// Returns the y of the centre.
+    public final double getCenterY() {
+        return centerY.get();
+    }
+
+    /// Sets the y of the centre.
+    public final void setCenterY(double value) {
+        centerY.set(value);
+    }
+
+    /// The y of the centre.
+    public final DoubleProperty centerYProperty() {
+        return centerY;
+    }
+
+    /// Returns the horizontal radius.
+    public final double getRadiusX() {
+        return radiusX.get();
+    }
+
+    /// Sets the horizontal radius.
+    public final void setRadiusX(double value) {
+        radiusX.set(value);
+    }
+
+    /// The horizontal radius.
+    public final DoubleProperty radiusXProperty() {
+        return radiusX;
+    }
+
+    /// Returns the vertical radius.
+    public final double getRadiusY() {
+        return radiusY.get();
+    }
+
+    /// Sets the vertical radius.
+    public final void setRadiusY(double value) {
+        radiusY.set(value);
+    }
+
+    /// The vertical radius.
+    public final DoubleProperty radiusYProperty() {
+        return radiusY;
+    }
+
+    /// Returns the angle the arc starts at, in degrees.
+    public final double getStartAngle() {
+        return startAngle.get();
+    }
+
+    /// Sets the angle the arc starts at, in degrees.
+    public final void setStartAngle(double value) {
+        startAngle.set(value);
+    }
+
+    /// The angle the arc starts at.
+    public final DoubleProperty startAngleProperty() {
+        return startAngle;
+    }
+
+    /// Returns the angle the arc covers, in degrees.
+    public final double getLength() {
+        return length.get();
+    }
+
+    /// Sets the angle the arc covers, in degrees.
+    public final void setLength(double value) {
+        length.set(value);
+    }
+
+    /// The angle the arc covers.
+    public final DoubleProperty lengthProperty() {
+        return length;
+    }
+
+    /// Returns how the ends are joined.
+    public final ArcType getType() {
+        ArcType t = type.get();
+        return t == null ? ArcType.OPEN : t;
+    }
+
+    /// Sets how the ends are joined.
+    public final void setType(ArcType value) {
+        type.set(value);
+    }
+
+    /// How the ends are joined.
+    public final ObjectProperty<ArcType> typeProperty() {
+        return type;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        ArcType t = getType();
+        if (t == ArcType.ROUND) {
+            p.moveTo(getCenterX(), getCenterY());
+        }
+        p.addArc(getCenterX(), getCenterY(), Math.max(0, getRadiusX()), Math.max(0, getRadiusY()), getStartAngle(),
+                getLength(), t == ArcType.ROUND);
+        if (t != ArcType.OPEN) {
+            p.closePath();
+        }
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/ArcTo.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/ArcTo.java
new file mode 100644
index 00000000000..188abeaa068
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/ArcTo.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+
+/// Draws part of an ellipse to a point, as an SVG arc does: of the
+/// ellipses with the given radii and rotation that pass through the
+/// current point and the end point, `largeArcFlag` picks the longer or the
+/// shorter way round and `sweepFlag` the direction, clockwise on the screen
+/// when set. The arc is drawn as cubic curves.
+///
+/// Radii too small to reach the end point are scaled up until they do; a
+/// zero radius gives a straight line.
+public class ArcTo extends PathElement {
+
+    private final DoubleProperty radiusX = coordinate("radiusX", 0);
+    private final DoubleProperty radiusY = coordinate("radiusY", 0);
+    private final DoubleProperty xAxisRotation = coordinate("XAxisRotation", 0);
+    private final DoubleProperty x = coordinate("x", 0);
+    private final DoubleProperty y = coordinate("y", 0);
+    private final BooleanProperty largeArcFlag = flag("largeArcFlag");
+    private final BooleanProperty sweepFlag = flag("sweepFlag");
+
+    /// Creates the element with every value zero.
+    public ArcTo() {
+    }
+
+    /// Creates an arc from its radii, rotation, end point and flags.
+    public ArcTo(double radiusX, double radiusY, double xAxisRotation,
+            double x, double y, boolean largeArcFlag, boolean sweepFlag) {
+        this.radiusX.set(radiusX);
+        this.radiusY.set(radiusY);
+        this.xAxisRotation.set(xAxisRotation);
+        this.x.set(x);
+        this.y.set(y);
+        this.largeArcFlag.set(largeArcFlag);
+        this.sweepFlag.set(sweepFlag);
+    }
+
+    /// Returns the horizontal radius of the ellipse.
+    public final double getRadiusX() {
+        return radiusX.get();
+    }
+
+    /// Sets the horizontal radius of the ellipse.
+    public final void setRadiusX(double value) {
+        radiusX.set(value);
+    }
+
+    /// The horizontal radius of the ellipse.
+    public final DoubleProperty radiusXProperty() {
+        return radiusX;
+    }
+
+    /// Returns the vertical radius of the ellipse.
+    public final double getRadiusY() {
+        return radiusY.get();
+    }
+
+    /// Sets the vertical radius of the ellipse.
+    public final void setRadiusY(double value) {
+        radiusY.set(value);
+    }
+
+    /// The vertical radius of the ellipse.
+    public final DoubleProperty radiusYProperty() {
+        return radiusY;
+    }
+
+    /// Returns the rotation of the ellipse in degrees.
+    public final double getXAxisRotation() {
+        return xAxisRotation.get();
+    }
+
+    /// Sets the rotation of the ellipse in degrees.
+    public final void setXAxisRotation(double value) {
+        xAxisRotation.set(value);
+    }
+
+    /// The rotation of the ellipse in degrees.
+    public final DoubleProperty XAxisRotationProperty() {
+        return xAxisRotation;
+    }
+
+    /// Returns the x of the end point.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the end point.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the end point.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the end point.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the end point.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the end point.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    /// Returns whether the longer of the two arcs is drawn.
+    public final boolean isLargeArcFlag() {
+        return largeArcFlag.get();
+    }
+
+    /// Sets whether the longer of the two arcs is drawn.
+    public final void setLargeArcFlag(boolean value) {
+        largeArcFlag.set(value);
+    }
+
+    /// Whether the longer of the two arcs is drawn.
+    public final BooleanProperty largeArcFlagProperty() {
+        return largeArcFlag;
+    }
+
+    /// Returns whether the arc is drawn clockwise.
+    public final boolean isSweepFlag() {
+        return sweepFlag.get();
+    }
+
+    /// Sets whether the arc is drawn clockwise.
+    public final void setSweepFlag(boolean value) {
+        sweepFlag.set(value);
+    }
+
+    /// Whether the arc is drawn clockwise.
+    public final BooleanProperty sweepFlagProperty() {
+        return sweepFlag;
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        path.arcTo(getRadiusX(), getRadiusY(), getXAxisRotation(), isLargeArcFlag(), isSweepFlag(),
+                originX(path) + getX(), originY(path) + getY());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/ArcType.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/ArcType.java
new file mode 100644
index 00000000000..849cd01a586
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/ArcType.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+/// How the two ends of an arc are joined.
+public enum ArcType {
+    /// Not at all: the arc alone.
+    OPEN,
+    /// By a straight line from end to end.
+    CHORD,
+    /// By lines to the centre, as a slice of a pie.
+    ROUND
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Circle.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Circle.java
new file mode 100644
index 00000000000..691a960d724
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Circle.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.scene.paint.Paint;
+
+/// A circle given by its centre and radius.
+public class Circle extends Shape {
+
+    private final DoubleProperty centerX = geometry("centerX", 0);
+    private final DoubleProperty centerY = geometry("centerY", 0);
+    private final DoubleProperty radius = geometry("radius", 0);
+
+    /// Creates a circle of radius zero at the origin.
+    public Circle() {
+    }
+
+    /// Creates a circle about the origin.
+    public Circle(double radius) {
+        this.radius.set(radius);
+    }
+
+    /// Creates a circle about the origin with a fill.
+    public Circle(double radius, Paint fill) {
+        this.radius.set(radius);
+        fillProperty().set(fill);
+    }
+
+    /// Creates a circle about a centre.
+    public Circle(double centerX, double centerY, double radius) {
+        this.centerX.set(centerX);
+        this.centerY.set(centerY);
+        this.radius.set(radius);
+    }
+
+    /// Creates a circle about a centre with a fill.
+    public Circle(double centerX, double centerY, double radius, Paint fill) {
+        this.centerX.set(centerX);
+        this.centerY.set(centerY);
+        this.radius.set(radius);
+        fillProperty().set(fill);
+    }
+
+    /// Returns the x of the centre.
+    public final double getCenterX() {
+        return centerX.get();
+    }
+
+    /// Sets the x of the centre.
+    public final void setCenterX(double value) {
+        centerX.set(value);
+    }
+
+    /// The x of the centre.
+    public final DoubleProperty centerXProperty() {
+        return centerX;
+    }
+
+    /// Returns the y of the centre.
+    public final double getCenterY() {
+        return centerY.get();
+    }
+
+    /// Sets the y of the centre.
+    public final void setCenterY(double value) {
+        centerY.set(value);
+    }
+
+    /// The y of the centre.
+    public final DoubleProperty centerYProperty() {
+        return centerY;
+    }
+
+    /// Returns the radius.
+    public final double getRadius() {
+        return radius.get();
+    }
+
+    /// Sets the radius.
+    public final void setRadius(double value) {
+        radius.set(value);
+    }
+
+    /// The radius.
+    public final DoubleProperty radiusProperty() {
+        return radius;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        double r = Math.max(0, getRadius());
+        p.addEllipse(getCenterX(), getCenterY(), r, r);
+        return p;
+    }
+
+    @Override
+    FxPath offsetOutline(double distance) {
+        double r = Math.max(0, getRadius()) + distance;
+        if (!(r > 0)) {
+            return null;
+        }
+        FxPath p = new FxPath();
+        p.addEllipse(getCenterX(), getCenterY(), r, r);
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/ClosePath.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/ClosePath.java
new file mode 100644
index 00000000000..fd2446e6198
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/ClosePath.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+/// Closes the current part of the outline with a line to where it started.
+public class ClosePath extends PathElement {
+
+    /// Creates the element.
+    public ClosePath() {
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        path.closePath();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/CubicCurve.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/CubicCurve.java
new file mode 100644
index 00000000000..45f59d67446
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/CubicCurve.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// A cubic curve from a start point to an end point, bent towards two
+/// control points.
+public class CubicCurve extends Shape {
+
+    private final DoubleProperty startX = geometry("startX", 0);
+    private final DoubleProperty startY = geometry("startY", 0);
+    private final DoubleProperty controlX1 = geometry("controlX1", 0);
+    private final DoubleProperty controlY1 = geometry("controlY1", 0);
+    private final DoubleProperty controlX2 = geometry("controlX2", 0);
+    private final DoubleProperty controlY2 = geometry("controlY2", 0);
+    private final DoubleProperty endX = geometry("endX", 0);
+    private final DoubleProperty endY = geometry("endY", 0);
+
+    /// Creates a curve with every point at the origin.
+    public CubicCurve() {
+    }
+
+    /// Creates a curve from its four points.
+    public CubicCurve(double startX, double startY, double controlX1, double controlY1, double controlX2,
+            double controlY2, double endX, double endY) {
+        this.startX.set(startX);
+        this.startY.set(startY);
+        this.controlX1.set(controlX1);
+        this.controlY1.set(controlY1);
+        this.controlX2.set(controlX2);
+        this.controlY2.set(controlY2);
+        this.endX.set(endX);
+        this.endY.set(endY);
+    }
+
+    /// Returns the x of the start.
+    public final double getStartX() {
+        return startX.get();
+    }
+
+    /// Sets the x of the start.
+    public final void setStartX(double value) {
+        startX.set(value);
+    }
+
+    /// The x of the start.
+    public final DoubleProperty startXProperty() {
+        return startX;
+    }
+
+    /// Returns the y of the start.
+    public final double getStartY() {
+        return startY.get();
+    }
+
+    /// Sets the y of the start.
+    public final void setStartY(double value) {
+        startY.set(value);
+    }
+
+    /// The y of the start.
+    public final DoubleProperty startYProperty() {
+        return startY;
+    }
+
+    /// Returns the x of the first control point.
+    public final double getControlX1() {
+        return controlX1.get();
+    }
+
+    /// Sets the x of the first control point.
+    public final void setControlX1(double value) {
+        controlX1.set(value);
+    }
+
+    /// The x of the first control point.
+    public final DoubleProperty controlX1Property() {
+        return controlX1;
+    }
+
+    /// Returns the y of the first control point.
+    public final double getControlY1() {
+        return controlY1.get();
+    }
+
+    /// Sets the y of the first control point.
+    public final void setControlY1(double value) {
+        controlY1.set(value);
+    }
+
+    /// The y of the first control point.
+    public final DoubleProperty controlY1Property() {
+        return controlY1;
+    }
+
+    /// Returns the x of the second control point.
+    public final double getControlX2() {
+        return controlX2.get();
+    }
+
+    /// Sets the x of the second control point.
+    public final void setControlX2(double value) {
+        controlX2.set(value);
+    }
+
+    /// The x of the second control point.
+    public final DoubleProperty controlX2Property() {
+        return controlX2;
+    }
+
+    /// Returns the y of the second control point.
+    public final double getControlY2() {
+        return controlY2.get();
+    }
+
+    /// Sets the y of the second control point.
+    public final void setControlY2(double value) {
+        controlY2.set(value);
+    }
+
+    /// The y of the second control point.
+    public final DoubleProperty controlY2Property() {
+        return controlY2;
+    }
+
+    /// Returns the x of the end.
+    public final double getEndX() {
+        return endX.get();
+    }
+
+    /// Sets the x of the end.
+    public final void setEndX(double value) {
+        endX.set(value);
+    }
+
+    /// The x of the end.
+    public final DoubleProperty endXProperty() {
+        return endX;
+    }
+
+    /// Returns the y of the end.
+    public final double getEndY() {
+        return endY.get();
+    }
+
+    /// Sets the y of the end.
+    public final void setEndY(double value) {
+        endY.set(value);
+    }
+
+    /// The y of the end.
+    public final DoubleProperty endYProperty() {
+        return endY;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.moveTo(getStartX(), getStartY());
+        p.curveTo(getControlX1(), getControlY1(), getControlX2(), getControlY2(), getEndX(), getEndY());
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/CubicCurveTo.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/CubicCurveTo.java
new file mode 100644
index 00000000000..96e4de2ea03
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/CubicCurveTo.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Draws a cubic curve to a point, bent towards two control points.
+public class CubicCurveTo extends PathElement {
+
+    private final DoubleProperty controlX1 = coordinate("controlX1", 0);
+    private final DoubleProperty controlY1 = coordinate("controlY1", 0);
+    private final DoubleProperty controlX2 = coordinate("controlX2", 0);
+    private final DoubleProperty controlY2 = coordinate("controlY2", 0);
+    private final DoubleProperty x = coordinate("x", 0);
+    private final DoubleProperty y = coordinate("y", 0);
+
+    /// Creates the element with every value zero.
+    public CubicCurveTo() {
+    }
+
+    /// Creates a curve from its two control points and end point.
+    public CubicCurveTo(double controlX1, double controlY1, double controlX2, double controlY2, double x, double y) {
+        this.controlX1.set(controlX1);
+        this.controlY1.set(controlY1);
+        this.controlX2.set(controlX2);
+        this.controlY2.set(controlY2);
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Returns the x of the first control point.
+    public final double getControlX1() {
+        return controlX1.get();
+    }
+
+    /// Sets the x of the first control point.
+    public final void setControlX1(double value) {
+        controlX1.set(value);
+    }
+
+    /// The x of the first control point.
+    public final DoubleProperty controlX1Property() {
+        return controlX1;
+    }
+
+    /// Returns the y of the first control point.
+    public final double getControlY1() {
+        return controlY1.get();
+    }
+
+    /// Sets the y of the first control point.
+    public final void setControlY1(double value) {
+        controlY1.set(value);
+    }
+
+    /// The y of the first control point.
+    public final DoubleProperty controlY1Property() {
+        return controlY1;
+    }
+
+    /// Returns the x of the second control point.
+    public final double getControlX2() {
+        return controlX2.get();
+    }
+
+    /// Sets the x of the second control point.
+    public final void setControlX2(double value) {
+        controlX2.set(value);
+    }
+
+    /// The x of the second control point.
+    public final DoubleProperty controlX2Property() {
+        return controlX2;
+    }
+
+    /// Returns the y of the second control point.
+    public final double getControlY2() {
+        return controlY2.get();
+    }
+
+    /// Sets the y of the second control point.
+    public final void setControlY2(double value) {
+        controlY2.set(value);
+    }
+
+    /// The y of the second control point.
+    public final DoubleProperty controlY2Property() {
+        return controlY2;
+    }
+
+    /// Returns the x of the end point.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the end point.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the end point.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the end point.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the end point.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the end point.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        double ox = originX(path);
+        double oy = originY(path);
+        path.curveTo(ox + getControlX1(), oy + getControlY1(), ox + getControlX2(), oy + getControlY2(), ox + getX(),
+                oy + getY());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Ellipse.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Ellipse.java
new file mode 100644
index 00000000000..5d626ccb7ab
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Ellipse.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// An ellipse given by its centre and its two radii.
+public class Ellipse extends Shape {
+
+    private final DoubleProperty centerX = geometry("centerX", 0);
+    private final DoubleProperty centerY = geometry("centerY", 0);
+    private final DoubleProperty radiusX = geometry("radiusX", 0);
+    private final DoubleProperty radiusY = geometry("radiusY", 0);
+
+    /// Creates an ellipse of no size at the origin.
+    public Ellipse() {
+    }
+
+    /// Creates an ellipse about the origin.
+    public Ellipse(double radiusX, double radiusY) {
+        this.radiusX.set(radiusX);
+        this.radiusY.set(radiusY);
+    }
+
+    /// Creates an ellipse about a centre.
+    public Ellipse(double centerX, double centerY, double radiusX, double radiusY) {
+        this.centerX.set(centerX);
+        this.centerY.set(centerY);
+        this.radiusX.set(radiusX);
+        this.radiusY.set(radiusY);
+    }
+
+    /// Returns the x of the centre.
+    public final double getCenterX() {
+        return centerX.get();
+    }
+
+    /// Sets the x of the centre.
+    public final void setCenterX(double value) {
+        centerX.set(value);
+    }
+
+    /// The x of the centre.
+    public final DoubleProperty centerXProperty() {
+        return centerX;
+    }
+
+    /// Returns the y of the centre.
+    public final double getCenterY() {
+        return centerY.get();
+    }
+
+    /// Sets the y of the centre.
+    public final void setCenterY(double value) {
+        centerY.set(value);
+    }
+
+    /// The y of the centre.
+    public final DoubleProperty centerYProperty() {
+        return centerY;
+    }
+
+    /// Returns the horizontal radius.
+    public final double getRadiusX() {
+        return radiusX.get();
+    }
+
+    /// Sets the horizontal radius.
+    public final void setRadiusX(double value) {
+        radiusX.set(value);
+    }
+
+    /// The horizontal radius.
+    public final DoubleProperty radiusXProperty() {
+        return radiusX;
+    }
+
+    /// Returns the vertical radius.
+    public final double getRadiusY() {
+        return radiusY.get();
+    }
+
+    /// Sets the vertical radius.
+    public final void setRadiusY(double value) {
+        radiusY.set(value);
+    }
+
+    /// The vertical radius.
+    public final DoubleProperty radiusYProperty() {
+        return radiusY;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.addEllipse(getCenterX(), getCenterY(), Math.max(0, getRadiusX()), Math.max(0, getRadiusY()));
+        return p;
+    }
+
+    @Override
+    FxPath offsetOutline(double distance) {
+        double rx = Math.max(0, getRadiusX()) + distance;
+        double ry = Math.max(0, getRadiusY()) + distance;
+        if (!(rx > 0) || !(ry > 0)) {
+            return null;
+        }
+        FxPath p = new FxPath();
+        p.addEllipse(getCenterX(), getCenterY(), rx, ry);
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/FillRule.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/FillRule.java
new file mode 100644
index 00000000000..cb8660e680b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/FillRule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+/// How the inside of an outline that crosses itself or has several parts
+/// is decided.
+public enum FillRule {
+    /// A point is inside when a ray from it crosses the outline an odd
+    /// number of times.
+    EVEN_ODD,
+    /// A point is inside when the outline winds around it: crossings in
+    /// one direction minus crossings in the other is not zero.
+    NON_ZERO
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/HLineTo.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/HLineTo.java
new file mode 100644
index 00000000000..ed610eebf82
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/HLineTo.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Draws a horizontal line to an x.
+public class HLineTo extends PathElement {
+
+    private final DoubleProperty x = coordinate("x", 0);
+
+    /// Creates the element with every value zero.
+    public HLineTo() {
+    }
+
+    /// Creates a horizontal line to an x.
+    public HLineTo(double x) {
+        this.x.set(x);
+    }
+
+    /// Returns the x the line ends at.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x the line ends at.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x the line ends at.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        path.lineTo(originX(path) + getX(), path.currentY());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Line.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Line.java
new file mode 100644
index 00000000000..693b674ab91
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Line.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+
+/// A straight line between two points. It has a black stroke and no fill
+/// to begin with, and a fill would have nothing to cover.
+///
+/// The layout bounds are those of the stroked segment exactly: half the
+/// stroke width to either side, and beyond each end only when the cap is
+/// not `BUTT`.
+public class Line extends Shape {
+
+    private final DoubleProperty startX = geometry("startX", 0);
+    private final DoubleProperty startY = geometry("startY", 0);
+    private final DoubleProperty endX = geometry("endX", 0);
+    private final DoubleProperty endY = geometry("endY", 0);
+
+    /// Creates a line of no length at the origin.
+    public Line() {
+        super(true);
+    }
+
+    /// Creates a line between two points.
+    public Line(double startX, double startY, double endX, double endY) {
+        super(true);
+        this.startX.set(startX);
+        this.startY.set(startY);
+        this.endX.set(endX);
+        this.endY.set(endY);
+    }
+
+    /// Returns the x of the start.
+    public final double getStartX() {
+        return startX.get();
+    }
+
+    /// Sets the x of the start.
+    public final void setStartX(double value) {
+        startX.set(value);
+    }
+
+    /// The x of the start.
+    public final DoubleProperty startXProperty() {
+        return startX;
+    }
+
+    /// Returns the y of the start.
+    public final double getStartY() {
+        return startY.get();
+    }
+
+    /// Sets the y of the start.
+    public final void setStartY(double value) {
+        startY.set(value);
+    }
+
+    /// The y of the start.
+    public final DoubleProperty startYProperty() {
+        return startY;
+    }
+
+    /// Returns the x of the end.
+    public final double getEndX() {
+        return endX.get();
+    }
+
+    /// Sets the x of the end.
+    public final void setEndX(double value) {
+        endX.set(value);
+    }
+
+    /// The x of the end.
+    public final DoubleProperty endXProperty() {
+        return endX;
+    }
+
+    /// Returns the y of the end.
+    public final double getEndY() {
+        return endY.get();
+    }
+
+    /// Sets the y of the end.
+    public final void setEndY(double value) {
+        endY.set(value);
+    }
+
+    /// The y of the end.
+    public final DoubleProperty endYProperty() {
+        return endY;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.moveTo(getStartX(), getStartY());
+        p.lineTo(getEndX(), getEndY());
+        return p;
+    }
+
+    private double halfWidth() {
+        double w = Math.max(0, getStrokeWidth());
+        // A line has no inside, so only the width itself matters.
+        return getStrokeType() == StrokeType.CENTERED ? w / 2 : w;
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        if (getStroke() == null) {
+            return empty();
+        }
+        double x1 = getStartX();
+        double y1 = getStartY();
+        double x2 = getEndX();
+        double y2 = getEndY();
+        double half = halfWidth();
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double length = Math.sqrt(dx * dx + dy * dy);
+        double padX = half;
+        double padY = half;
+        if (length > 0) {
+            // Across the line the stroke reaches half its width; along
+            // it only a cap does.
+            double ux = Math.abs(dx / length);
+            double uy = Math.abs(dy / length);
+            double cap = getStrokeLineCap() == StrokeLineCap.BUTT ? 0 : half;
+            padX = uy * half + ux * cap;
+            padY = ux * half + uy * cap;
+        }
+        double minX = Math.min(x1, x2) - padX;
+        double minY = Math.min(y1, y2) - padY;
+        return new BoundingBox(minX, minY, Math.max(x1, x2) + padX - minX, Math.max(y1, y2) + padY - minY);
+    }
+
+    @Override
+    public boolean contains(double localX, double localY) {
+        return getStroke() != null && outline().nearOutline(localX, localY, halfWidth());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/LineTo.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/LineTo.java
new file mode 100644
index 00000000000..15de03ccaae
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/LineTo.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Draws a straight line to a point.
+public class LineTo extends PathElement {
+
+    private final DoubleProperty x = coordinate("x", 0);
+    private final DoubleProperty y = coordinate("y", 0);
+
+    /// Creates the element with every value zero.
+    public LineTo() {
+    }
+
+    /// Creates a line to a point.
+    public LineTo(double x, double y) {
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Returns the x of the point.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the point.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the point.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the point.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the point.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the point.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        path.lineTo(originX(path) + getX(), originY(path) + getY());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/MoveTo.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/MoveTo.java
new file mode 100644
index 00000000000..995b7794efc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/MoveTo.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Starts a new part of the outline at a point, without drawing to it.
+public class MoveTo extends PathElement {
+
+    private final DoubleProperty x = coordinate("x", 0);
+    private final DoubleProperty y = coordinate("y", 0);
+
+    /// Creates the element with every value zero.
+    public MoveTo() {
+    }
+
+    /// Creates a move to a point.
+    public MoveTo(double x, double y) {
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Returns the x of the point.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the point.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the point.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the point.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the point.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the point.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        path.moveTo(originX(path) + getX(), originY(path) + getY());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Path.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Path.java
new file mode 100644
index 00000000000..7f888c47ca2
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Path.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import java.util.Collection;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// An outline built from a list of [PathElement]s. It has a black stroke
+/// and no fill to begin with.
+///
+/// The first element has to be a [MoveTo]; a path that starts with
+/// anything else draws nothing, as in JavaFX.
+public class Path extends Shape {
+
+    private final ObservableList<PathElement> elements = FXCollections.observableArrayList();
+    private final ObjectProperty<FillRule> fillRule = new FxObject<FillRule>(this, "fillRule", FillRule.NON_ZERO,
+            Dirty.GEOMETRY);
+
+    /// Creates a path without elements.
+    public Path() {
+        super(true);
+        listen();
+    }
+
+    /// Creates a path from elements.
+    public Path(PathElement... elements) {
+        super(true);
+        listen();
+        if (elements != null) {
+            for (int i = 0; i < elements.length; i++) {
+                this.elements.add(elements[i]);
+            }
+        }
+    }
+
+    /// Creates a path from elements.
+    public Path(Collection<? extends PathElement> elements) {
+        super(true);
+        listen();
+        if (elements != null) {
+            this.elements.addAll(elements);
+        }
+    }
+
+    private void listen() {
+        elements.addListener(new ListChangeListener<PathElement>() {
+            @Override
+            public void onChanged(Change<? extends PathElement> change) {
+                while (change.next()) {
+                    List<? extends PathElement> removed = change.getRemoved();
+                    for (int i = 0; i < removed.size(); i++) {
+                        PathElement e = removed.get(i);
+                        if (e != null) {
+                            e.removeOwner(Path.this);
+                        }
+                    }
+                    if (change.wasAdded()) {
+                        List<? extends PathElement> added = change.getAddedSubList();
+                        for (int i = 0; i < added.size(); i++) {
+                            PathElement e = added.get(i);
+                            if (e != null) {
+                                e.addOwner(Path.this);
+                            }
+                        }
+                    }
+                }
+                cn1Invalidated(Dirty.GEOMETRY);
+            }
+        });
+    }
+
+    /// Returns the elements of the outline, in drawing order.
+    public final ObservableList<PathElement> getElements() {
+        return elements;
+    }
+
+    /// Returns how the inside is decided.
+    public final FillRule getFillRule() {
+        FillRule r = fillRule.get();
+        return r == null ? FillRule.NON_ZERO : r;
+    }
+
+    /// Sets how the inside is decided.
+    public final void setFillRule(FillRule value) {
+        fillRule.set(value);
+    }
+
+    /// How the inside is decided.
+    public final ObjectProperty<FillRule> fillRuleProperty() {
+        return fillRule;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.setEvenOdd(getFillRule() == FillRule.EVEN_ODD);
+        if (elements.isEmpty() || !(elements.get(0) instanceof MoveTo)) {
+            return p;
+        }
+        boolean closed = false;
+        for (int i = 0; i < elements.size(); i++) {
+            PathElement e = elements.get(i);
+            if (e == null) {
+                continue;
+            }
+            if (closed && !(e instanceof MoveTo) && !(e instanceof ClosePath)) {
+                // Drawing on after a close starts again where the closed
+                // part started.
+                p.moveTo(p.currentX(), p.currentY());
+            }
+            e.addTo(p);
+            closed = e instanceof ClosePath;
+        }
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/PathElement.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/PathElement.java
new file mode 100644
index 00000000000..6a7ed64d182
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/PathElement.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import java.util.ArrayList;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+
+/// One step of a [Path]: a move, a line, a curve, an arc or the closing
+/// of the outline.
+///
+/// The coordinates of an element are absolute by default. With
+/// `absolute` off they are distances from the point the previous element
+/// ended at; that holds for control points too.
+public abstract class PathElement {
+
+    private final ArrayList<Path> owners = new ArrayList<Path>(1);
+    private final BooleanProperty absolute = new SimpleBooleanProperty(this, "absolute", true) {
+        @Override
+        protected void invalidated() {
+            changed();
+        }
+    };
+
+    /// Creates an element.
+    public PathElement() {
+    }
+
+    final void addOwner(Path path) {
+        owners.add(path);
+    }
+
+    final void removeOwner(Path path) {
+        owners.remove(path);
+    }
+
+    final void changed() {
+        for (int i = 0; i < owners.size(); i++) {
+            owners.get(i).cn1Invalidated(Dirty.GEOMETRY);
+        }
+    }
+
+    /// Creates a coordinate property that reshapes the paths using this
+    /// element when it changes.
+    final DoubleProperty coordinate(String name, double initial) {
+        return new SimpleDoubleProperty(this, name, initial) {
+            @Override
+            protected void invalidated() {
+                changed();
+            }
+        };
+    }
+
+    /// Creates a flag property that reshapes the paths using this
+    /// element when it changes.
+    final BooleanProperty flag(String name) {
+        return new SimpleBooleanProperty(this, name, false) {
+            @Override
+            protected void invalidated() {
+                changed();
+            }
+        };
+    }
+
+    /// Adds this element to an outline whose current point is where the
+    /// previous element ended.
+    abstract void addTo(FxPath path);
+
+    /// The x a relative coordinate is counted from.
+    final double originX(FxPath path) {
+        return isAbsolute() ? 0 : path.currentX();
+    }
+
+    /// The y a relative coordinate is counted from.
+    final double originY(FxPath path) {
+        return isAbsolute() ? 0 : path.currentY();
+    }
+
+    /// Returns whether the coordinates are absolute.
+    public final boolean isAbsolute() {
+        return absolute.get();
+    }
+
+    /// Sets whether the coordinates are absolute rather than distances
+    /// from the end of the previous element.
+    public final void setAbsolute(boolean value) {
+        absolute.set(value);
+    }
+
+    /// Whether the coordinates are absolute.
+    public final BooleanProperty absoluteProperty() {
+        return absolute;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Polygon.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Polygon.java
new file mode 100644
index 00000000000..69bc97be64d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Polygon.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// A closed outline through a list of points, x and y alternating. A
+/// trailing x without its y is ignored.
+public class Polygon extends Shape {
+
+    private final ObservableList<Double> points = FXCollections.observableArrayList();
+
+    /// Creates a polygon without points.
+    public Polygon() {
+        listen();
+    }
+
+    /// Creates a polygon through points, x and y alternating.
+    public Polygon(double... points) {
+        if (points != null) {
+            for (int i = 0; i < points.length; i++) {
+                this.points.add(Double.valueOf(points[i]));
+            }
+        }
+        listen();
+    }
+
+    private void listen() {
+        points.addListener(new ListChangeListener<Double>() {
+            @Override
+            public void onChanged(Change<? extends Double> change) {
+                cn1Invalidated(Dirty.GEOMETRY);
+            }
+        });
+    }
+
+    /// Returns the points, x and y alternating.
+    public final ObservableList<Double> getPoints() {
+        return points;
+    }
+
+    static FxPath through(ObservableList<Double> points, boolean close) {
+        FxPath p = new FxPath();
+        int n = points.size() & ~1;
+        for (int i = 0; i < n; i += 2) {
+            Double x = points.get(i);
+            Double y = points.get(i + 1);
+            if (x == null || y == null) {
+                continue;
+            }
+            if (p.isEmpty()) {
+                p.moveTo(x.doubleValue(), y.doubleValue());
+            } else {
+                p.lineTo(x.doubleValue(), y.doubleValue());
+            }
+        }
+        if (close) {
+            p.closePath();
+        }
+        return p;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        return through(points, true);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Polyline.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Polyline.java
new file mode 100644
index 00000000000..a167deaff81
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Polyline.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+
+/// An open outline through a list of points, x and y alternating. It has
+/// a black stroke and no fill to begin with; a fill, when set, covers the
+/// outline as if it were closed.
+public class Polyline extends Shape {
+
+    private final ObservableList<Double> points = FXCollections.observableArrayList();
+
+    /// Creates a polyline without points.
+    public Polyline() {
+        super(true);
+        listen();
+    }
+
+    /// Creates a polyline through points, x and y alternating.
+    public Polyline(double... points) {
+        super(true);
+        if (points != null) {
+            for (int i = 0; i < points.length; i++) {
+                this.points.add(Double.valueOf(points[i]));
+            }
+        }
+        listen();
+    }
+
+    private void listen() {
+        points.addListener(new ListChangeListener<Double>() {
+            @Override
+            public void onChanged(Change<? extends Double> change) {
+                cn1Invalidated(Dirty.GEOMETRY);
+            }
+        });
+    }
+
+    /// Returns the points, x and y alternating.
+    public final ObservableList<Double> getPoints() {
+        return points;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        return Polygon.through(points, false);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/QuadCurve.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/QuadCurve.java
new file mode 100644
index 00000000000..22297be0f7a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/QuadCurve.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// A quadratic curve from a start point to an end point, bent towards
+/// one control point.
+public class QuadCurve extends Shape {
+
+    private final DoubleProperty startX = geometry("startX", 0);
+    private final DoubleProperty startY = geometry("startY", 0);
+    private final DoubleProperty controlX = geometry("controlX", 0);
+    private final DoubleProperty controlY = geometry("controlY", 0);
+    private final DoubleProperty endX = geometry("endX", 0);
+    private final DoubleProperty endY = geometry("endY", 0);
+
+    /// Creates a curve with every point at the origin.
+    public QuadCurve() {
+    }
+
+    /// Creates a curve from its three points.
+    public QuadCurve(double startX, double startY, double controlX, double controlY, double endX, double endY) {
+        this.startX.set(startX);
+        this.startY.set(startY);
+        this.controlX.set(controlX);
+        this.controlY.set(controlY);
+        this.endX.set(endX);
+        this.endY.set(endY);
+    }
+
+    /// Returns the x of the start.
+    public final double getStartX() {
+        return startX.get();
+    }
+
+    /// Sets the x of the start.
+    public final void setStartX(double value) {
+        startX.set(value);
+    }
+
+    /// The x of the start.
+    public final DoubleProperty startXProperty() {
+        return startX;
+    }
+
+    /// Returns the y of the start.
+    public final double getStartY() {
+        return startY.get();
+    }
+
+    /// Sets the y of the start.
+    public final void setStartY(double value) {
+        startY.set(value);
+    }
+
+    /// The y of the start.
+    public final DoubleProperty startYProperty() {
+        return startY;
+    }
+
+    /// Returns the x of the control point.
+    public final double getControlX() {
+        return controlX.get();
+    }
+
+    /// Sets the x of the control point.
+    public final void setControlX(double value) {
+        controlX.set(value);
+    }
+
+    /// The x of the control point.
+    public final DoubleProperty controlXProperty() {
+        return controlX;
+    }
+
+    /// Returns the y of the control point.
+    public final double getControlY() {
+        return controlY.get();
+    }
+
+    /// Sets the y of the control point.
+    public final void setControlY(double value) {
+        controlY.set(value);
+    }
+
+    /// The y of the control point.
+    public final DoubleProperty controlYProperty() {
+        return controlY;
+    }
+
+    /// Returns the x of the end.
+    public final double getEndX() {
+        return endX.get();
+    }
+
+    /// Sets the x of the end.
+    public final void setEndX(double value) {
+        endX.set(value);
+    }
+
+    /// The x of the end.
+    public final DoubleProperty endXProperty() {
+        return endX;
+    }
+
+    /// Returns the y of the end.
+    public final double getEndY() {
+        return endY.get();
+    }
+
+    /// Sets the y of the end.
+    public final void setEndY(double value) {
+        endY.set(value);
+    }
+
+    /// The y of the end.
+    public final DoubleProperty endYProperty() {
+        return endY;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.moveTo(getStartX(), getStartY());
+        p.quadTo(getControlX(), getControlY(), getEndX(), getEndY());
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/QuadCurveTo.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/QuadCurveTo.java
new file mode 100644
index 00000000000..2017943079d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/QuadCurveTo.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Draws a quadratic curve to a point, bent towards a control point.
+public class QuadCurveTo extends PathElement {
+
+    private final DoubleProperty controlX = coordinate("controlX", 0);
+    private final DoubleProperty controlY = coordinate("controlY", 0);
+    private final DoubleProperty x = coordinate("x", 0);
+    private final DoubleProperty y = coordinate("y", 0);
+
+    /// Creates the element with every value zero.
+    public QuadCurveTo() {
+    }
+
+    /// Creates a curve from its control point and end point.
+    public QuadCurveTo(double controlX, double controlY, double x, double y) {
+        this.controlX.set(controlX);
+        this.controlY.set(controlY);
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Returns the x of the control point.
+    public final double getControlX() {
+        return controlX.get();
+    }
+
+    /// Sets the x of the control point.
+    public final void setControlX(double value) {
+        controlX.set(value);
+    }
+
+    /// The x of the control point.
+    public final DoubleProperty controlXProperty() {
+        return controlX;
+    }
+
+    /// Returns the y of the control point.
+    public final double getControlY() {
+        return controlY.get();
+    }
+
+    /// Sets the y of the control point.
+    public final void setControlY(double value) {
+        controlY.set(value);
+    }
+
+    /// The y of the control point.
+    public final DoubleProperty controlYProperty() {
+        return controlY;
+    }
+
+    /// Returns the x of the end point.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the end point.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the end point.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the end point.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the end point.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the end point.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    @Override
+    void addTo(FxPath path) {
+        double ox = originX(path);
+        double oy = originY(path);
+        path.quadTo(ox + getControlX(), oy + getControlY(), ox + getX(), oy + getY());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Rectangle.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Rectangle.java
new file mode 100644
index 00000000000..71e67752ffc
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Rectangle.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.FxPath;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.scene.paint.Paint;
+
+/// A rectangle, with rounded corners when `arcWidth` and `arcHeight` are
+/// above zero: they are the diameters of the ellipse a corner is a
+/// quarter of.
+public class Rectangle extends Shape {
+
+    private final DoubleProperty x = geometry("x", 0);
+    private final DoubleProperty y = geometry("y", 0);
+    private final DoubleProperty width = geometry("width", 0);
+    private final DoubleProperty height = geometry("height", 0);
+    private final DoubleProperty arcWidth = geometry("arcWidth", 0);
+    private final DoubleProperty arcHeight = geometry("arcHeight", 0);
+
+    /// Creates an empty rectangle at the origin.
+    public Rectangle() {
+    }
+
+    /// Creates a rectangle of a size at the origin.
+    public Rectangle(double width, double height) {
+        this.width.set(width);
+        this.height.set(height);
+    }
+
+    /// Creates a rectangle of a size at the origin with a fill.
+    public Rectangle(double width, double height, Paint fill) {
+        this.width.set(width);
+        this.height.set(height);
+        fillProperty().set(fill);
+    }
+
+    /// Creates a rectangle at a position.
+    public Rectangle(double x, double y, double width, double height) {
+        this.x.set(x);
+        this.y.set(y);
+        this.width.set(width);
+        this.height.set(height);
+    }
+
+    /// Returns the x of the top left corner.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the top left corner.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the top left corner.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the top left corner.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the top left corner.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the top left corner.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    /// Returns the width.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Sets the width.
+    public final void setWidth(double value) {
+        width.set(value);
+    }
+
+    /// The width.
+    public final DoubleProperty widthProperty() {
+        return width;
+    }
+
+    /// Returns the height.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// Sets the height.
+    public final void setHeight(double value) {
+        height.set(value);
+    }
+
+    /// The height.
+    public final DoubleProperty heightProperty() {
+        return height;
+    }
+
+    /// Returns the horizontal diameter of the corners.
+    public final double getArcWidth() {
+        return arcWidth.get();
+    }
+
+    /// Sets the horizontal diameter of the corners.
+    public final void setArcWidth(double value) {
+        arcWidth.set(value);
+    }
+
+    /// The horizontal diameter of the corners.
+    public final DoubleProperty arcWidthProperty() {
+        return arcWidth;
+    }
+
+    /// Returns the vertical diameter of the corners.
+    public final double getArcHeight() {
+        return arcHeight.get();
+    }
+
+    /// Sets the vertical diameter of the corners.
+    public final void setArcHeight(double value) {
+        arcHeight.set(value);
+    }
+
+    /// The vertical diameter of the corners.
+    public final DoubleProperty arcHeightProperty() {
+        return arcHeight;
+    }
+
+    private static FxPath build(double x, double y, double w, double h, double radiusX, double radiusY) {
+        FxPath p = new FxPath();
+        p.addRoundRect(x, y, w, h, radiusX, radiusY);
+        return p;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        return build(getX(), getY(), Math.max(0, getWidth()), Math.max(0, getHeight()), getArcWidth() / 2,
+                getArcHeight() / 2);
+    }
+
+    @Override
+    FxPath offsetOutline(double distance) {
+        double w = Math.max(0, getWidth()) + 2 * distance;
+        double h = Math.max(0, getHeight()) + 2 * distance;
+        if (!(w > 0) || !(h > 0)) {
+            return null;
+        }
+        boolean round = getArcWidth() > 0 && getArcHeight() > 0;
+        return build(getX() - distance, getY() - distance, w, h, round ? getArcWidth() / 2 + distance : 0,
+                round ? getArcHeight() / 2 + distance : 0);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/SVGPath.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/SVGPath.java
new file mode 100644
index 00000000000..5f2ad443461
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/SVGPath.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.FxString;
+import com.codename1.fxcompat.runtime.SvgPath;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+
+/// An outline written as SVG path data, the `d` attribute of an SVG
+/// `path`.
+///
+/// Every command of the path grammar is read, with its relative form,
+/// repeated coordinates and the compact number spellings; arcs are drawn
+/// as cubic curves. See `com.codename1.fxcompat.runtime.SvgPath`. Content
+/// that stops making sense draws what came before the error; JavaFX logs
+/// such content and, depending on where the error is, draws that much or
+/// nothing.
+public class SVGPath extends Shape {
+
+    private final StringProperty content = new FxString(this, "content", "", Dirty.GEOMETRY);
+    private final ObjectProperty<FillRule> fillRule = new FxObject<FillRule>(this, "fillRule", FillRule.NON_ZERO,
+            Dirty.GEOMETRY);
+
+    /// Creates a path without content.
+    public SVGPath() {
+    }
+
+    /// Returns the path data.
+    public final String getContent() {
+        String c = content.get();
+        return c == null ? "" : c;
+    }
+
+    /// Sets the path data.
+    public final void setContent(String value) {
+        content.set(value);
+    }
+
+    /// The path data.
+    public final StringProperty contentProperty() {
+        return content;
+    }
+
+    /// Returns how the inside is decided.
+    public final FillRule getFillRule() {
+        FillRule r = fillRule.get();
+        return r == null ? FillRule.NON_ZERO : r;
+    }
+
+    /// Sets how the inside is decided.
+    public final void setFillRule(FillRule value) {
+        fillRule.set(value);
+    }
+
+    /// How the inside is decided.
+    public final ObjectProperty<FillRule> fillRuleProperty() {
+        return fillRule;
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.setEvenOdd(getFillRule() == FillRule.EVEN_ODD);
+        SvgPath.append(getContent(), p);
+        return p;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/Shape.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/Shape.java
new file mode 100644
index 00000000000..442a17a4ff9
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/Shape.java
@@ -0,0 +1,532 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FontStyles;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.scene.Node;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+
+/// The base of the geometric nodes: an outline that is filled with one
+/// paint and stroked with another.
+///
+/// A shape is black inside and has no stroke until told otherwise; `Line`,
+/// `Polyline` and `Path` start the other way round, as in JavaFX.
+///
+/// #### Geometry
+///
+/// Every shape reduces itself to one path, [#cn1CreatePath()], which the
+/// layer's renderer fills and strokes. The layout bounds are the bounds
+/// of that path grown by the stroke: half the width for a `CENTERED`
+/// stroke, the whole width for `OUTSIDE`, nothing for `INSIDE`. JavaFX
+/// measures the stroked outline of a general path exactly, so that a
+/// sharp mitred corner reaches beyond that and half a pixel is added all
+/// around; here those bounds are the uniform growth just described.
+/// A shape with neither fill nor stroke has empty bounds.
+///
+/// A point is on the shape when it is inside a filled outline or on the
+/// stroke. Dashes are ignored for both, as JavaFX ignores them.
+///
+/// An `INSIDE` or `OUTSIDE` stroke of a rectangle, circle or ellipse is
+/// drawn exactly, on an outline moved by half the width. For other
+/// shapes it is a stroke of twice the width clipped to the inside or
+/// outside of the outline, which needs a port that can clip to a shape;
+/// on one that cannot the stroke is drawn centred.
+///
+/// #### Styling
+///
+/// Through `cn1ApplyStyle` (see
+/// `com.codename1.fxcompat.runtime.StyleTarget`) a shape takes, besides
+/// the names of every node:
+///
+/// - `-fx-fill`, `-fx-stroke`: `javafx.scene.paint.Paint`
+/// - `-fx-stroke-width`, `-fx-stroke-miter-limit`,
+///   `-fx-stroke-dash-offset`: `Number`
+/// - `-fx-stroke-line-cap`: `StrokeLineCap` or `"butt"`, `"round"`,
+///   `"square"`
+/// - `-fx-stroke-line-join`: `StrokeLineJoin` or `"miter"`, `"round"`,
+///   `"bevel"`
+/// - `-fx-stroke-type`: `StrokeType` or `"inside"`, `"outside"`,
+///   `"centered"`
+/// - `-fx-smooth`: `Boolean`
+///
+/// Keywords are matched without regard to ASCII case.
+///
+/// #### Not part of this layer
+///
+/// The static `union`, `subtract` and `intersect`, and
+/// `-fx-stroke-dash-array` as a style name. `smooth` is recorded;
+/// shapes are always drawn anti-aliased where the port can.
+public abstract class Shape extends Node {
+
+    private static final int FILL = Dirty.USER;
+    private static final int STROKE = Dirty.USER << 1;
+
+    private final ObjectProperty<Paint> fill;
+    private final ObjectProperty<Paint> stroke;
+    private final DoubleProperty strokeWidth = new FxDouble(this, "strokeWidth", 1, Dirty.GEOMETRY);
+    private final ObjectProperty<StrokeType> strokeType = new FxObject<StrokeType>(this, "strokeType",
+            StrokeType.CENTERED, Dirty.GEOMETRY);
+    private final ObjectProperty<StrokeLineCap> strokeLineCap = new FxObject<StrokeLineCap>(this, "strokeLineCap",
+            StrokeLineCap.SQUARE, Dirty.GEOMETRY);
+    private final ObjectProperty<StrokeLineJoin> strokeLineJoin = new FxObject<StrokeLineJoin>(this,
+            "strokeLineJoin", StrokeLineJoin.MITER, Dirty.PAINT);
+    private final DoubleProperty strokeMiterLimit = new FxDouble(this, "strokeMiterLimit", 10, Dirty.PAINT);
+    private final DoubleProperty strokeDashOffset = new FxDouble(this, "strokeDashOffset", 0, Dirty.PAINT);
+    private final ObservableList<Double> strokeDashArray = FXCollections.observableArrayList();
+    private final BooleanProperty smooth = new FxBoolean(this, "smooth", true, Dirty.PAINT);
+
+    private FxPath path;
+    private boolean hadFill;
+    private boolean hadStroke;
+
+    /// Creates a shape filled black and without a stroke.
+    public Shape() {
+        this(false);
+    }
+
+    Shape(boolean outlineOnly) {
+        fill = new FxObject<Paint>(this, "fill", outlineOnly ? null : Color.BLACK, FILL);
+        stroke = new FxObject<Paint>(this, "stroke", outlineOnly ? Color.BLACK : null, STROKE);
+        hadFill = !outlineOnly;
+        hadStroke = outlineOnly;
+        strokeDashArray.addListener(new ListChangeListener<Double>() {
+            @Override
+            public void onChanged(Change<? extends Double> change) {
+                cn1Repaint();
+            }
+        });
+    }
+
+    /// Returns the outline of this shape in its own coordinates. Called
+    /// again after a change reported with `Dirty.GEOMETRY`; the result is
+    /// kept until then and must not be changed by the caller.
+    protected abstract FxPath cn1CreatePath();
+
+    final FxPath outline() {
+        if (path == null) {
+            path = cn1CreatePath();
+        }
+        return path;
+    }
+
+    /// Returns the outline of this shape in its own coordinates, for a
+    /// region that takes its form from the shape. The path is the
+    /// shape's own and must not be changed.
+    public final FxPath cn1Outline() {
+        return outline();
+    }
+
+    final DoubleProperty geometry(String name, double initial) {
+        return new FxDouble(this, name, initial, Dirty.GEOMETRY);
+    }
+
+    /// Returns the outline a stroke lying wholly on one side follows: this
+    /// shape's outline moved outwards by a distance, inwards for a
+    /// negative one. `null` when the shape cannot say.
+    FxPath offsetOutline(double distance) {
+        return null;
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        int w = what;
+        if ((w & (FILL | STROKE)) != 0) {
+            boolean f = fill.get() != null;
+            boolean s = stroke.get() != null;
+            // A paint appearing or going away changes the bounds; one
+            // paint replacing another only the pixels.
+            if (f != hadFill || s != hadStroke) {
+                hadFill = f;
+                hadStroke = s;
+                w |= Dirty.GEOMETRY;
+            } else {
+                w |= Dirty.PAINT;
+            }
+        }
+        if ((w & Dirty.GEOMETRY) != 0) {
+            path = null;
+        }
+        super.cn1Invalidated(w);
+    }
+
+    /// Returns the paint of the inside, or `null` for none.
+    public final Paint getFill() {
+        return fill.get();
+    }
+
+    /// Sets the paint of the inside; `null` leaves it empty.
+    public final void setFill(Paint value) {
+        fill.set(value);
+    }
+
+    /// The paint of the inside.
+    public final ObjectProperty<Paint> fillProperty() {
+        return fill;
+    }
+
+    /// Returns the paint of the outline, or `null` for none.
+    public final Paint getStroke() {
+        return stroke.get();
+    }
+
+    /// Sets the paint of the outline; `null` draws none. A gradient
+    /// strokes with its middle colour.
+    public final void setStroke(Paint value) {
+        stroke.set(value);
+    }
+
+    /// The paint of the outline.
+    public final ObjectProperty<Paint> strokeProperty() {
+        return stroke;
+    }
+
+    /// Returns the width of the stroke.
+    public final double getStrokeWidth() {
+        return strokeWidth.get();
+    }
+
+    /// Sets the width of the stroke.
+    public final void setStrokeWidth(double value) {
+        strokeWidth.set(value);
+    }
+
+    /// The width of the stroke.
+    public final DoubleProperty strokeWidthProperty() {
+        return strokeWidth;
+    }
+
+    /// Returns on which side of the outline the stroke lies.
+    public final StrokeType getStrokeType() {
+        StrokeType t = strokeType.get();
+        return t == null ? StrokeType.CENTERED : t;
+    }
+
+    /// Sets on which side of the outline the stroke lies.
+    public final void setStrokeType(StrokeType value) {
+        strokeType.set(value);
+    }
+
+    /// On which side of the outline the stroke lies.
+    public final ObjectProperty<StrokeType> strokeTypeProperty() {
+        return strokeType;
+    }
+
+    /// Returns how the ends of an open outline are drawn.
+    public final StrokeLineCap getStrokeLineCap() {
+        StrokeLineCap c = strokeLineCap.get();
+        return c == null ? StrokeLineCap.SQUARE : c;
+    }
+
+    /// Sets how the ends of an open outline are drawn.
+    public final void setStrokeLineCap(StrokeLineCap value) {
+        strokeLineCap.set(value);
+    }
+
+    /// How the ends of an open outline are drawn.
+    public final ObjectProperty<StrokeLineCap> strokeLineCapProperty() {
+        return strokeLineCap;
+    }
+
+    /// Returns how corners of the outline are drawn.
+    public final StrokeLineJoin getStrokeLineJoin() {
+        StrokeLineJoin j = strokeLineJoin.get();
+        return j == null ? StrokeLineJoin.MITER : j;
+    }
+
+    /// Sets how corners of the outline are drawn.
+    public final void setStrokeLineJoin(StrokeLineJoin value) {
+        strokeLineJoin.set(value);
+    }
+
+    /// How corners of the outline are drawn.
+    public final ObjectProperty<StrokeLineJoin> strokeLineJoinProperty() {
+        return strokeLineJoin;
+    }
+
+    /// Returns how far a mitred corner may reach, in stroke widths,
+    /// before it is cut off.
+    public final double getStrokeMiterLimit() {
+        return strokeMiterLimit.get();
+    }
+
+    /// Sets how far a mitred corner may reach.
+    public final void setStrokeMiterLimit(double value) {
+        strokeMiterLimit.set(value);
+    }
+
+    /// How far a mitred corner may reach.
+    public final DoubleProperty strokeMiterLimitProperty() {
+        return strokeMiterLimit;
+    }
+
+    /// Returns where in the dash pattern the outline starts.
+    public final double getStrokeDashOffset() {
+        return strokeDashOffset.get();
+    }
+
+    /// Sets where in the dash pattern the outline starts.
+    public final void setStrokeDashOffset(double value) {
+        strokeDashOffset.set(value);
+    }
+
+    /// Where in the dash pattern the outline starts.
+    public final DoubleProperty strokeDashOffsetProperty() {
+        return strokeDashOffset;
+    }
+
+    /// Returns the dash pattern: the lengths of dashes and gaps in turn.
+    /// Empty for a solid stroke.
+    public final ObservableList<Double> getStrokeDashArray() {
+        return strokeDashArray;
+    }
+
+    /// Returns whether anti-aliasing was asked for.
+    public final boolean isSmooth() {
+        return smooth.get();
+    }
+
+    /// Records whether anti-aliasing is asked for.
+    public final void setSmooth(boolean value) {
+        smooth.set(value);
+    }
+
+    /// Whether anti-aliasing is asked for.
+    public final BooleanProperty smoothProperty() {
+        return smooth;
+    }
+
+    final boolean strokeDrawn() {
+        return getStroke() != null && getStrokeWidth() > 0;
+    }
+
+    /// How far the stroke reaches beyond the outline.
+    final double strokeReach() {
+        if (getStroke() == null) {
+            return 0;
+        }
+        double w = Math.max(0, getStrokeWidth());
+        StrokeType type = getStrokeType();
+        return type == StrokeType.INSIDE ? 0 : (type == StrokeType.OUTSIDE ? w : w / 2);
+    }
+
+    static Bounds empty() {
+        return new BoundingBox(0, 0, -1, -1);
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        if (getFill() == null && getStroke() == null) {
+            return empty();
+        }
+        double[] b = outline().bounds();
+        if (b == null) {
+            return empty();
+        }
+        double reach = strokeReach();
+        return new BoundingBox(b[0] - reach, b[1] - reach, b[2] - b[0] + 2 * reach, b[3] - b[1] + 2 * reach);
+    }
+
+    @Override
+    public boolean cn1PaintsOutsideBounds() {
+        // A mitred corner reaches past the uniform growth of the bounds.
+        return getStroke() != null;
+    }
+
+    @Override
+    public boolean contains(double localX, double localY) {
+        FxPath p = outline();
+        if (p.isEmpty()) {
+            return false;
+        }
+        boolean inside = p.contains(localX, localY);
+        if (getFill() != null && inside) {
+            return true;
+        }
+        if (getStroke() == null) {
+            return false;
+        }
+        double w = Math.max(0, getStrokeWidth());
+        StrokeType type = getStrokeType();
+        if (type == StrokeType.INSIDE) {
+            return inside && p.nearOutline(localX, localY, w);
+        } else if (type == StrokeType.OUTSIDE) {
+            return !inside && p.nearOutline(localX, localY, w);
+        }
+        return p.nearOutline(localX, localY, w / 2);
+    }
+
+    private double[] dashes() {
+        int n = strokeDashArray.size();
+        double[] out = new double[n];
+        for (int i = 0; i < n; i++) {
+            Double d = strokeDashArray.get(i);
+            out[i] = d == null ? 0 : d.doubleValue();
+        }
+        return out;
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        FxPath p = outline();
+        double[] b = p.bounds();
+        if (b == null) {
+            return;
+        }
+        Paint f = getFill();
+        if (f != null) {
+            renderer.fill(p, f, b[0], b[1], b[2] - b[0], b[3] - b[1]);
+        }
+        if (!strokeDrawn()) {
+            return;
+        }
+        Paint s = getStroke();
+        double w = getStrokeWidth();
+        StrokeType type = getStrokeType();
+        double[] dash = dashes();
+        if (type != StrokeType.CENTERED) {
+            boolean in = type == StrokeType.INSIDE;
+            FxPath moved = offsetOutline(in ? -w / 2 : w / 2);
+            if (moved != null) {
+                renderer.stroke(moved, s, w, getStrokeLineCap(), getStrokeLineJoin(), getStrokeMiterLimit(), dash,
+                        getStrokeDashOffset());
+                return;
+            }
+            if (renderer.canClipToShape()) {
+                FxPath clip = p;
+                if (!in) {
+                    // Everything but the inside: a box around the widest
+                    // possible stroke with the outline cut out of it.
+                    double far = 2 * w * Math.max(1, getStrokeMiterLimit()) + 1;
+                    clip = new FxPath();
+                    clip.addRect(b[0] - far, b[1] - far, b[2] - b[0] + 2 * far, b[3] - b[1] + 2 * far);
+                    clip.append(p);
+                    clip.setEvenOdd(true);
+                }
+                renderer.save();
+                renderer.clip(clip);
+                renderer.stroke(p, s, 2 * w, getStrokeLineCap(), getStrokeLineJoin(), getStrokeMiterLimit(), dash,
+                        getStrokeDashOffset());
+                renderer.restore();
+                return;
+            }
+        }
+        renderer.stroke(p, s, w, getStrokeLineCap(), getStrokeLineJoin(), getStrokeMiterLimit(), dash,
+                getStrokeDashOffset());
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-fill".equals(property)) {
+            return getFill();
+        } else if ("-fx-stroke".equals(property)) {
+            return getStroke();
+        } else if ("-fx-stroke-width".equals(property)) {
+            return Double.valueOf(getStrokeWidth());
+        } else if ("-fx-stroke-miter-limit".equals(property)) {
+            return Double.valueOf(getStrokeMiterLimit());
+        } else if ("-fx-stroke-dash-offset".equals(property)) {
+            return Double.valueOf(getStrokeDashOffset());
+        } else if ("-fx-stroke-line-cap".equals(property)) {
+            return getStrokeLineCap();
+        } else if ("-fx-stroke-line-join".equals(property)) {
+            return getStrokeLineJoin();
+        } else if ("-fx-stroke-type".equals(property)) {
+            return getStrokeType();
+        } else if ("-fx-smooth".equals(property)) {
+            return Boolean.valueOf(isSmooth());
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-fill".equals(property) || "-fx-stroke".equals(property)) {
+            Paint p = null;
+            if (value instanceof Paint) {
+                p = (Paint) value;
+            } else if (value != null) {
+                return false;
+            }
+            if ("-fx-fill".equals(property)) {
+                setFill(p);
+            } else {
+                setStroke(p);
+            }
+        } else if ("-fx-stroke-width".equals(property) || "-fx-stroke-miter-limit".equals(property)
+                || "-fx-stroke-dash-offset".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            double v = ((Number) value).doubleValue();
+            if ("-fx-stroke-width".equals(property)) {
+                setStrokeWidth(v);
+            } else if ("-fx-stroke-miter-limit".equals(property)) {
+                setStrokeMiterLimit(v);
+            } else {
+                setStrokeDashOffset(v);
+            }
+        } else if ("-fx-stroke-line-cap".equals(property)) {
+            Object k = FontStyles.keyword(StrokeLineCap.values(), value);
+            if (!(k instanceof StrokeLineCap)) {
+                return false;
+            }
+            setStrokeLineCap((StrokeLineCap) k);
+        } else if ("-fx-stroke-line-join".equals(property)) {
+            Object k = FontStyles.keyword(StrokeLineJoin.values(), value);
+            if (!(k instanceof StrokeLineJoin)) {
+                return false;
+            }
+            setStrokeLineJoin((StrokeLineJoin) k);
+        } else if ("-fx-stroke-type".equals(property)) {
+            Object k = FontStyles.keyword(StrokeType.values(), value);
+            if (!(k instanceof StrokeType)) {
+                return false;
+            }
+            setStrokeType((StrokeType) k);
+        } else if ("-fx-smooth".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            setSmooth(((Boolean) value).booleanValue());
+        } else {
+            return super.cn1SetStyleValue(property, value);
+        }
+        return true;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeLineCap.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeLineCap.java
new file mode 100644
index 00000000000..86dcf4f35fa
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeLineCap.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+/// How the open ends of a stroke are finished.
+public enum StrokeLineCap {
+    /// The end is extended by half the stroke width.
+    SQUARE,
+    /// The end is cut at the last point.
+    BUTT,
+    /// The end is rounded.
+    ROUND
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeLineJoin.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeLineJoin.java
new file mode 100644
index 00000000000..fe458ccb638
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeLineJoin.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+/// How two segments of a stroke are joined at a corner.
+public enum StrokeLineJoin {
+    /// The outer edges are extended until they meet.
+    MITER,
+    /// The corner is cut off.
+    BEVEL,
+    /// The corner is rounded.
+    ROUND
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeType.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeType.java
new file mode 100644
index 00000000000..5f03d1fc81f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/StrokeType.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.shape;
+
+/// Where a stroke lies relative to the outline it follows.
+public enum StrokeType {
+    /// Inside the outline.
+    INSIDE,
+    /// Outside the outline.
+    OUTSIDE,
+    /// Half on each side of the outline.
+    CENTERED
+}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileTypeContractTest.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/VLineTo.java
similarity index 59%
rename from maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileTypeContractTest.java
rename to maven/javafx-compat/src/main/java/javafx/scene/shape/VLineTo.java
index 6f2cd7459d4..77ea610de9e 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileTypeContractTest.java
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/VLineTo.java
@@ -20,29 +20,43 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package javafx.scene.shape;
 
-import android.content.Intent;
+import com.codename1.fxcompat.runtime.FxPath;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
-import org.junit.Rule;
-import org.junit.Test;
+import javafx.beans.property.DoubleProperty;
 
-import static org.junit.Assert.assertEquals;
+/// Draws a vertical line to a y.
+public class VLineTo extends PathElement {
 
-/// The remap turns `java.io.File` into this shim but leaves method
-/// descriptors that name the JDK class's supertypes, such as
-/// `Intent.putExtra(String, Serializable)`: the shim must have them too.
-public class FileTypeContractTest {
+    private final DoubleProperty y = coordinate("y", 0);
 
-    @Rule
-    public final MainThreadRule mainThread = new MainThreadRule();
+    /// Creates the element with every value zero.
+    public VLineTo() {
+    }
+
+    /// Creates a vertical line to a y.
+    public VLineTo(double y) {
+        this.y.set(y);
+    }
+
+    /// Returns the y the line ends at.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y the line ends at.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y the line ends at.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
 
-    @Test
-    public void aFileGoesIntoAnIntentAsSerializable() {
-        java.io.Serializable file = new File("notes.txt");
-        Intent intent = new Intent();
-        intent.putExtra("file", file);
-        assertEquals("notes.txt", ((File) intent.getSerializableExtra("file")).getName());
+    @Override
+    void addTo(FxPath path) {
+        path.lineTo(path.currentX(), originY(path) + getY());
     }
 }
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/shape/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/shape/package-info.java
new file mode 100644
index 00000000000..cf328fe51e5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/shape/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Geometric shapes and the attributes of the strokes that outline them.
+package javafx.scene.shape;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/Font.java b/maven/javafx-compat/src/main/java/javafx/scene/text/Font.java
new file mode 100644
index 00000000000..c833be8077b
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/Font.java
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.text;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.FontFiles;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.ResourceUrls;
+
+import javafx.beans.NamedArg;
+
+/// A font: a family, a weight, a posture and a size in logical pixels.
+///
+/// Fonts are those of the platform. A family the platform does not know
+/// by name falls back to its default typeface, and every weight is drawn
+/// with the nearest of the weights the platform font has.
+public final class Font {
+
+    private static final double DEFAULT_SIZE = 13;
+
+    private final String family;
+    private final String name;
+    private final String style;
+    private final double size;
+    private final FontWeight weight;
+    private final FontPosture posture;
+    private final String lookup;
+    private final int lookupWeight;
+    private Object nativeFont;
+
+    /// Creates the default typeface at a size.
+    public Font(@NamedArg("size") double size) {
+        this((String) null, size);
+    }
+
+    /// Creates a font by its full name, `Arial Bold`.
+    public Font(@NamedArg("name") String name, @NamedArg("size") double size) {
+        this(familyOf(name), weightOf(name), postureOf(name), size);
+    }
+
+    /// A font out of a file the application loaded: its names are the
+    /// file's own.
+    private Font(FontFiles.Face face, double size) {
+        this.family = face.family();
+        this.name = face.fullName();
+        this.style = face.style();
+        this.size = size < 0 ? DEFAULT_SIZE : size;
+        this.weight = FontWeight.findByWeight(face.weight());
+        this.posture = face.italic() ? FontPosture.ITALIC : FontPosture.REGULAR;
+        this.lookup = face.fullName();
+        this.lookupWeight = face.weight();
+    }
+
+    private Font(String family, FontWeight weight, FontPosture posture, double size) {
+        this.lookup = null;
+        this.lookupWeight = 0;
+        this.family = family == null || family.length() == 0 ? "System" : family;
+        this.weight = weight == null ? FontWeight.NORMAL : weight;
+        this.posture = posture == null ? FontPosture.REGULAR : posture;
+        this.size = size < 0 ? DEFAULT_SIZE : size;
+        String s;
+        if (this.weight == FontWeight.NORMAL) {
+            s = this.posture == FontPosture.ITALIC ? "Italic" : "Regular";
+        } else {
+            s = styleName(this.weight) + (this.posture == FontPosture.ITALIC ? " Italic" : "");
+        }
+        this.style = s;
+        this.name = this.family + " " + s;
+    }
+
+    private static String styleName(FontWeight w) {
+        switch (w) {
+            case THIN:
+                return "Thin";
+            case EXTRA_LIGHT:
+                return "Extra Light";
+            case LIGHT:
+                return "Light";
+            case MEDIUM:
+                return "Medium";
+            case SEMI_BOLD:
+                return "Semi Bold";
+            case BOLD:
+                return "Bold";
+            case EXTRA_BOLD:
+                return "Extra Bold";
+            case BLACK:
+                return "Black";
+            default:
+                return "Regular";
+        }
+    }
+
+    private static boolean endsWithWord(String name, String word) {
+        int at = name.length() - word.length();
+        return at > 0 && name.charAt(at - 1) == ' ' && name.regionMatches(true, at, word, 0, word.length());
+    }
+
+    private static String strip(String name) {
+        String n = name;
+        boolean again = true;
+        while (again) {
+            again = false;
+            String[] words = {"Italic", "Regular", "Bold", "Light", "Thin", "Medium", "Black", "Semi", "Extra"};
+            for (int i = 0; i < words.length; i++) {
+                if (endsWithWord(n, words[i])) {
+                    n = n.substring(0, n.length() - words[i].length()).trim();
+                    again = true;
+                }
+            }
+        }
+        return n;
+    }
+
+    private static String familyOf(String name) {
+        return name == null ? null : strip(name.trim());
+    }
+
+    private static FontWeight weightOf(String name) {
+        if (name == null) {
+            return FontWeight.NORMAL;
+        }
+        String rest = name.trim();
+        if (endsWithWord(rest, "Italic")) {
+            rest = rest.substring(0, rest.length() - 6).trim();
+        }
+        FontWeight[] all = FontWeight.values();
+        for (int i = all.length - 1; i >= 0; i--) {
+            if (all[i] != FontWeight.NORMAL && endsWithWord(rest, styleName(all[i]))) {
+                return all[i];
+            }
+        }
+        return FontWeight.NORMAL;
+    }
+
+    private static FontPosture postureOf(String name) {
+        return name != null && endsWithWord(name.trim(), "Italic") ? FontPosture.ITALIC : FontPosture.REGULAR;
+    }
+
+    /// Returns the default font, the platform typeface at the default
+    /// size.
+    public static Font getDefault() {
+        return Default.FONT;
+    }
+
+    /// Holds the default font, created when first asked for.
+    private static final class Default {
+        static final Font FONT = new Font("System", FontWeight.NORMAL, FontPosture.REGULAR, DEFAULT_SIZE);
+
+        private Default() {
+        }
+    }
+
+    /// Returns the font of a family with a weight, a posture and a size.
+    public static Font font(String family, FontWeight weight, FontPosture posture, double size) {
+        return new Font(family, weight, posture, size);
+    }
+
+    /// Returns the font of a family with a weight and a size.
+    public static Font font(String family, FontWeight weight, double size) {
+        return new Font(family, weight, null, size);
+    }
+
+    /// Returns the font of a family with a posture and a size.
+    public static Font font(String family, FontPosture posture, double size) {
+        return new Font(family, null, posture, size);
+    }
+
+    /// Returns the font of a family at a size.
+    public static Font font(String family, double size) {
+        return new Font(family, null, null, size);
+    }
+
+    /// Returns the font of a family at the default size.
+    public static Font font(String family) {
+        return new Font(family, null, null, -1);
+    }
+
+    /// Returns the default typeface at a size.
+    public static Font font(double size) {
+        return new Font(null, null, null, size);
+    }
+
+    /// Loads a font file the application carries and answers the font at
+    /// a size. The URL is the one `getResource(...).toExternalForm()` gave;
+    /// the file has to be one of the application's resources.
+    ///
+    /// From then on the font answers to its family and to its full name,
+    /// in [#font(String, double)] and in a style sheet's `-fx-font-family`,
+    /// which is what an application loads one for. The names are the
+    /// file's own, read from it.
+    ///
+    /// The answer is `null` for a URL that names no resource or a file that
+    /// is not a TrueType or OpenType font, as in JavaFX. A platform that
+    /// cannot open the file still answers a font with the file's names; its
+    /// text is drawn with the system face of the same weight.
+    public static Font loadFont(String urlStr, double size) {
+        if (urlStr == null) {
+            return null;
+        }
+        FontFiles.Face face = FontFiles.loadUrl(urlStr);
+        return face == null ? null : new Font(face, size);
+    }
+
+    /// Loads a font from a stream, which is read to its end and left
+    /// open; see [#loadFont(String, double)]. A platform opens a font by
+    /// its file, so the font drawn is the application resource that names
+    /// itself as these bytes do, and the system face when there is none.
+    public static Font loadFont(InputStream in, double size) {
+        if (in == null) {
+            return null;
+        }
+        byte[] data;
+        try {
+            data = ResourceUrls.readAll(in);
+        } catch (IOException unreadable) {
+            return null;
+        }
+        FontFiles.Face face = FontFiles.loadBytes(data);
+        return face == null ? null : new Font(face, size);
+    }
+
+    /// Returns the family names known by name to every platform.
+    public static List<String> getFamilies() {
+        ArrayList<String> families = new ArrayList<String>();
+        families.add("System");
+        families.add("SansSerif");
+        families.add("Serif");
+        families.add("Monospaced");
+        return families;
+    }
+
+    /// Returns the family, `Arial`.
+    public final String getFamily() {
+        return family;
+    }
+
+    /// Returns the full name, `Arial Bold`.
+    public final String getName() {
+        return name;
+    }
+
+    /// Returns the style part of the name, `Bold Italic`.
+    public final String getStyle() {
+        return style;
+    }
+
+    /// Returns the size in logical pixels.
+    public final double getSize() {
+        return size;
+    }
+
+    /// Returns the weight this font was asked for.
+    public FontWeight cn1Weight() {
+        return weight;
+    }
+
+    /// Returns the posture this font was asked for.
+    public FontPosture cn1Posture() {
+        return posture;
+    }
+
+    /// Returns the Codename One font that draws this one at the current
+    /// scale, a `com.codename1.ui.Font`.
+    public Object cn1Native() {
+        if (nativeFont == null || !Fonts.isCurrent(nativeFont)) {
+            nativeFont = lookup != null ? Fonts.create(lookup, lookupWeight, posture == FontPosture.ITALIC, size)
+                    : Fonts.create(family, weight.getWeight(), posture == FontPosture.ITALIC, size);
+        }
+        return nativeFont;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Font) {
+            Font other = (Font) obj;
+            return Double.compare(size, other.size) == 0 && name.equals(other.name);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode() * 37 + (int) (size * 16);
+    }
+
+    @Override
+    public String toString() {
+        return "Font[name=" + name + ", family=" + family + ", style=" + style + ", size=" + size + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/FontPosture.java b/maven/javafx-compat/src/main/java/javafx/scene/text/FontPosture.java
new file mode 100644
index 00000000000..ce9d0d150a0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/FontPosture.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.text;
+
+/// Whether a font is upright or slanted.
+public enum FontPosture {
+    /// Upright.
+    REGULAR("", "regular"),
+    /// Slanted.
+    ITALIC("italic");
+
+    private final String[] names;
+
+    FontPosture(String... names) {
+        this.names = names;
+    }
+
+    /// Returns the posture with a name, compared without regard to case,
+    /// or `null`.
+    public static FontPosture findByName(String name) {
+        if (name == null) {
+            return null;
+        }
+        FontPosture[] all = values();
+        for (int i = 0; i < all.length; i++) {
+            for (int j = 0; j < all[i].names.length; j++) {
+                if (all[i].names[j].equalsIgnoreCase(name)) {
+                    return all[i];
+                }
+            }
+        }
+        return null;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/FontWeight.java b/maven/javafx-compat/src/main/java/javafx/scene/text/FontWeight.java
new file mode 100644
index 00000000000..ea4f781a91a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/FontWeight.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.text;
+
+/// How heavy the strokes of a font are, on the 100 to 900 scale.
+public enum FontWeight {
+    /// Weight 100.
+    THIN(100, "Thin"),
+    /// Weight 200.
+    EXTRA_LIGHT(200, "Extra Light", "Ultra Light"),
+    /// Weight 300.
+    LIGHT(300, "Light"),
+    /// Weight 400, the ordinary weight.
+    NORMAL(400, "Normal", "Regular"),
+    /// Weight 500.
+    MEDIUM(500, "Medium"),
+    /// Weight 600.
+    SEMI_BOLD(600, "Semi Bold", "Demi Bold"),
+    /// Weight 700.
+    BOLD(700, "Bold"),
+    /// Weight 800.
+    EXTRA_BOLD(800, "Extra Bold", "Ultra Bold"),
+    /// Weight 900.
+    BLACK(900, "Black", "Heavy");
+
+    private final int weight;
+    private final String[] names;
+
+    FontWeight(int weight, String... names) {
+        this.weight = weight;
+        this.names = names;
+    }
+
+    /// Returns the weight on the 100 to 900 scale.
+    public int getWeight() {
+        return weight;
+    }
+
+    /// Returns the weight with a name, compared without regard to case, or
+    /// `null`.
+    public static FontWeight findByName(String name) {
+        if (name == null) {
+            return null;
+        }
+        FontWeight[] all = values();
+        for (int i = 0; i < all.length; i++) {
+            for (int j = 0; j < all[i].names.length; j++) {
+                if (all[i].names[j].equalsIgnoreCase(name)) {
+                    return all[i];
+                }
+            }
+        }
+        return null;
+    }
+
+    /// Returns the weight nearest to a number on the 100 to 900 scale.
+    public static FontWeight findByWeight(int weight) {
+        if (weight <= 150) {
+            return THIN;
+        } else if (weight <= 250) {
+            return EXTRA_LIGHT;
+        } else if (weight < 350) {
+            return LIGHT;
+        } else if (weight <= 450) {
+            return NORMAL;
+        } else if (weight <= 550) {
+            return MEDIUM;
+        } else if (weight < 650) {
+            return SEMI_BOLD;
+        } else if (weight <= 750) {
+            return BOLD;
+        } else if (weight <= 850) {
+            return EXTRA_BOLD;
+        }
+        return BLACK;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/Text.java b/maven/javafx-compat/src/main/java/javafx/scene/text/Text.java
new file mode 100644
index 00000000000..ac933a1f49f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/Text.java
@@ -0,0 +1,478 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.text;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FontStyles;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxBoolean;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.FxString;
+import com.codename1.fxcompat.runtime.Renderer;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.VPos;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Shape;
+
+/// A node that draws text, on one line or several.
+///
+/// A new line starts at every line feed and, when `wrappingWidth` is
+/// above zero, between words wherever a line would become wider than
+/// that; a word wider than the whole width is cut. `x` and `y` place the
+/// text: `x` is its left edge and `y`, depending on `textOrigin`, the
+/// baseline of the first line (the default), or the top, centre or
+/// bottom of the whole block.
+///
+/// #### Measuring
+///
+/// Widths, line height and ascent come from the Codename One font the
+/// JavaFX font maps to, converted to logical pixels, so they are those of
+/// the platform's own text engine rather than JavaFX's. The layout bounds
+/// are the logical bounds of the block: its width is the widest line, or
+/// the wrapping width when one is set, and its height the lines plus the
+/// line spacing between them.
+///
+/// #### Painting
+///
+/// Text is drawn by the platform with the fill; a gradient fill draws
+/// with its middle colour. **The outlines of glyphs are not available, so
+/// the stroke of a text is not drawn** and does not enlarge the bounds;
+/// stroke properties are recorded only. A point is on the text when it
+/// is inside the layout bounds.
+///
+/// #### Styling
+///
+/// Besides the names of `javafx.scene.shape.Shape`: `-fx-font`
+/// (`Font`), `-fx-font-size` (`Number`), `-fx-font-family` (`String`),
+/// `-fx-font-weight` (`FontWeight`, a `Number` from 100 to 900 or a
+/// keyword), `-fx-font-style` (`FontPosture` or a keyword),
+/// `-fx-text-alignment` (`TextAlignment` or a keyword), `-fx-text-origin`
+/// (`javafx.geometry.VPos` or a keyword), `-fx-underline`,
+/// `-fx-strikethrough` (`Boolean`) and `-fx-line-spacing` (`Number`).
+///
+/// #### Not part of this layer
+///
+/// `boundsType`, `fontSmoothingType`, the selection and caret properties,
+/// `hitTest` and tab size. `JUSTIFY` aligns to the left.
+public class Text extends Shape {
+
+    private final StringProperty text = new FxString(this, "text", "", Dirty.GEOMETRY);
+    private final DoubleProperty x = new FxDouble(this, "x", 0, Dirty.GEOMETRY);
+    private final DoubleProperty y = new FxDouble(this, "y", 0, Dirty.GEOMETRY);
+    private final ObjectProperty<Font> font = new FxObject<Font>(this, "font", null, Dirty.GEOMETRY);
+    private final ObjectProperty<VPos> textOrigin = new FxObject<VPos>(this, "textOrigin", VPos.BASELINE,
+            Dirty.GEOMETRY);
+    private final DoubleProperty wrappingWidth = new FxDouble(this, "wrappingWidth", 0, Dirty.GEOMETRY);
+    private final ObjectProperty<TextAlignment> textAlignment = new FxObject<TextAlignment>(this, "textAlignment",
+            TextAlignment.LEFT, Dirty.PAINT);
+    private final BooleanProperty underline = new FxBoolean(this, "underline", false, Dirty.PAINT);
+    private final BooleanProperty strikethrough = new FxBoolean(this, "strikethrough", false, Dirty.PAINT);
+    private final DoubleProperty lineSpacing = new FxDouble(this, "lineSpacing", 0, Dirty.GEOMETRY);
+
+    private String[] lines;
+
+    /// Creates a text node without text.
+    public Text() {
+    }
+
+    /// Creates a text node.
+    public Text(String text) {
+        this.text.set(text);
+    }
+
+    /// Creates a text node at a position.
+    public Text(double x, double y, String text) {
+        this.x.set(x);
+        this.y.set(y);
+        this.text.set(text);
+    }
+
+    @Override
+    public void cn1Invalidated(int what) {
+        if ((what & Dirty.GEOMETRY) != 0) {
+            lines = null;
+        }
+        super.cn1Invalidated(what);
+    }
+
+    /// Returns the text; never `null`.
+    public final String getText() {
+        String t = text.get();
+        return t == null ? "" : t;
+    }
+
+    /// Sets the text.
+    public final void setText(String value) {
+        text.set(value);
+    }
+
+    /// The text.
+    public final StringProperty textProperty() {
+        return text;
+    }
+
+    /// Returns the x of the left edge.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the x of the left edge.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The x of the left edge.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the y of the text origin.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the y of the text origin.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The y of the text origin.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    /// Returns the font; the default font when none was set.
+    public final Font getFont() {
+        Font f = font.get();
+        return f == null ? Font.getDefault() : f;
+    }
+
+    /// Sets the font; `null` returns to the default font.
+    public final void setFont(Font value) {
+        font.set(value);
+    }
+
+    /// The font.
+    public final ObjectProperty<Font> fontProperty() {
+        return font;
+    }
+
+    /// Returns what `y` is the position of.
+    public final VPos getTextOrigin() {
+        VPos v = textOrigin.get();
+        return v == null ? VPos.BASELINE : v;
+    }
+
+    /// Sets what `y` is the position of: the baseline of the first line,
+    /// or the top, centre or bottom of the text.
+    public final void setTextOrigin(VPos value) {
+        textOrigin.set(value);
+    }
+
+    /// What `y` is the position of.
+    public final ObjectProperty<VPos> textOriginProperty() {
+        return textOrigin;
+    }
+
+    /// Returns the width lines are wrapped at; zero for no wrapping.
+    public final double getWrappingWidth() {
+        return wrappingWidth.get();
+    }
+
+    /// Sets the width lines are wrapped at; zero for no wrapping.
+    public final void setWrappingWidth(double value) {
+        wrappingWidth.set(value);
+    }
+
+    /// The width lines are wrapped at.
+    public final DoubleProperty wrappingWidthProperty() {
+        return wrappingWidth;
+    }
+
+    /// Returns how lines are aligned within the width of the text.
+    public final TextAlignment getTextAlignment() {
+        TextAlignment a = textAlignment.get();
+        return a == null ? TextAlignment.LEFT : a;
+    }
+
+    /// Sets how lines are aligned within the width of the text.
+    public final void setTextAlignment(TextAlignment value) {
+        textAlignment.set(value);
+    }
+
+    /// How lines are aligned within the width of the text.
+    public final ObjectProperty<TextAlignment> textAlignmentProperty() {
+        return textAlignment;
+    }
+
+    /// Returns whether a line is drawn under the text.
+    public final boolean isUnderline() {
+        return underline.get();
+    }
+
+    /// Sets whether a line is drawn under the text.
+    public final void setUnderline(boolean value) {
+        underline.set(value);
+    }
+
+    /// Whether a line is drawn under the text.
+    public final BooleanProperty underlineProperty() {
+        return underline;
+    }
+
+    /// Returns whether a line is drawn through the text.
+    public final boolean isStrikethrough() {
+        return strikethrough.get();
+    }
+
+    /// Sets whether a line is drawn through the text.
+    public final void setStrikethrough(boolean value) {
+        strikethrough.set(value);
+    }
+
+    /// Whether a line is drawn through the text.
+    public final BooleanProperty strikethroughProperty() {
+        return strikethrough;
+    }
+
+    /// Returns the extra distance between lines.
+    public final double getLineSpacing() {
+        return lineSpacing.get();
+    }
+
+    /// Sets the extra distance between lines.
+    public final void setLineSpacing(double value) {
+        lineSpacing.set(value);
+    }
+
+    /// The extra distance between lines.
+    public final DoubleProperty lineSpacingProperty() {
+        return lineSpacing;
+    }
+
+    private String[] textLines() {
+        if (lines == null) {
+            lines = FontStyles.lines(getText(), getFont(), getWrappingWidth());
+        }
+        return lines;
+    }
+
+    private double blockWidth() {
+        double wrap = getWrappingWidth();
+        if (wrap > 0) {
+            return wrap;
+        }
+        double widest = 0;
+        String[] all = textLines();
+        Font f = getFont();
+        for (int i = 0; i < all.length; i++) {
+            widest = Math.max(widest, Fonts.width(f, all[i]));
+        }
+        return widest;
+    }
+
+    private double blockHeight() {
+        int n = textLines().length;
+        return n * Fonts.lineHeight(getFont()) + (n - 1) * getLineSpacing();
+    }
+
+    private double top() {
+        VPos origin = getTextOrigin();
+        if (origin == VPos.TOP) {
+            return getY();
+        } else if (origin == VPos.CENTER) {
+            return getY() - blockHeight() / 2;
+        } else if (origin == VPos.BOTTOM) {
+            return getY() - blockHeight();
+        }
+        return getY() - Fonts.ascent(getFont());
+    }
+
+    @Override
+    protected Bounds cn1ComputeLayoutBounds() {
+        return new BoundingBox(getX(), top(), blockWidth(), blockHeight());
+    }
+
+    @Override
+    public double getBaselineOffset() {
+        return Fonts.ascent(getFont());
+    }
+
+    /// A text a flow cut into runs draws them where the flow put them,
+    /// which is beyond the box of the text when a run of another text
+    /// stands between two of its own.
+    @Override
+    public boolean cn1PaintsOutsideBounds() {
+        return flowParts != null;
+    }
+
+    @Override
+    public boolean contains(double localX, double localY) {
+        return getLayoutBounds().contains(localX, localY);
+    }
+
+    @Override
+    protected FxPath cn1CreatePath() {
+        FxPath p = new FxPath();
+        p.addRect(getX(), top(), blockWidth(), blockHeight());
+        return p;
+    }
+
+    /// The runs a flow cut this text into and where each starts, counted
+    /// from the left of the text; `null` for a text drawn whole.
+    private String[] flowParts;
+    private double[] flowOffsets;
+
+    /// Has the text drawn as runs of one direction each, which a flow
+    /// places apart when the order they are read in is not the order
+    /// they are seen in. `null` draws the text whole again.
+    void flowRuns(String[] parts, double[] offsets) {
+        if (parts == null && flowParts == null) {
+            return;
+        }
+        flowParts = parts;
+        flowOffsets = offsets;
+        cn1Repaint();
+    }
+
+    @Override
+    public void cn1Paint(Renderer renderer) {
+        Paint fill = getFill();
+        if (fill == null) {
+            return;
+        }
+        Font f = getFont();
+        String[] all = textLines();
+        double width = blockWidth();
+        double lineHeight = Fonts.lineHeight(f);
+        double ascent = Fonts.ascent(f);
+        double thickness = Math.max(1, f.getSize() / 14);
+        if (flowParts != null && flowOffsets != null) {
+            double y = top();
+            for (int i = 0; i < flowParts.length && i < flowOffsets.length; i++) {
+                double w = Fonts.width(f, flowParts[i]);
+                double lx = getX() + flowOffsets[i];
+                renderer.drawText(flowParts[i], lx, y, f, fill);
+                if (w > 0 && isUnderline()) {
+                    renderer.fillRect(lx, y + ascent + thickness, w, thickness, fill);
+                }
+                if (w > 0 && isStrikethrough()) {
+                    renderer.fillRect(lx, y + ascent * 0.65, w, thickness, fill);
+                }
+            }
+            return;
+        }
+        TextAlignment align = getTextAlignment();
+        double lineTop = top();
+        for (int i = 0; i < all.length; i++) {
+            String line = all[i];
+            double w = Fonts.width(f, line);
+            double lx = getX();
+            if (align == TextAlignment.CENTER) {
+                lx += (width - w) / 2;
+            } else if (align == TextAlignment.RIGHT) {
+                lx += width - w;
+            }
+            renderer.drawText(line, lx, lineTop, f, fill);
+            if (w > 0 && isUnderline()) {
+                renderer.fillRect(lx, lineTop + ascent + thickness, w, thickness, fill);
+            }
+            if (w > 0 && isStrikethrough()) {
+                renderer.fillRect(lx, lineTop + ascent * 0.65, w, thickness, fill);
+            }
+            lineTop += lineHeight + getLineSpacing();
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if (FontStyles.isFontProperty(property)) {
+            return font.get();
+        } else if ("-fx-text-alignment".equals(property)) {
+            return getTextAlignment();
+        } else if ("-fx-text-origin".equals(property)) {
+            return getTextOrigin();
+        } else if ("-fx-underline".equals(property)) {
+            return Boolean.valueOf(isUnderline());
+        } else if ("-fx-strikethrough".equals(property)) {
+            return Boolean.valueOf(isStrikethrough());
+        } else if ("-fx-line-spacing".equals(property)) {
+            return Double.valueOf(getLineSpacing());
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if (FontStyles.isFontProperty(property)) {
+            // Restoring any of the font names restores the whole font.
+            if (value == null) {
+                setFont(null);
+                return true;
+            }
+            Font styled = FontStyles.apply(getFont(), property, value);
+            if (styled == null) {
+                return false;
+            }
+            setFont(styled);
+        } else if ("-fx-text-alignment".equals(property)) {
+            Object k = FontStyles.keyword(TextAlignment.values(), value);
+            if (!(k instanceof TextAlignment)) {
+                return false;
+            }
+            setTextAlignment((TextAlignment) k);
+        } else if ("-fx-text-origin".equals(property)) {
+            Object k = FontStyles.keyword(VPos.values(), value);
+            if (!(k instanceof VPos)) {
+                return false;
+            }
+            setTextOrigin((VPos) k);
+        } else if ("-fx-underline".equals(property) || "-fx-strikethrough".equals(property)) {
+            if (!(value instanceof Boolean)) {
+                return false;
+            }
+            boolean on = ((Boolean) value).booleanValue();
+            if ("-fx-underline".equals(property)) {
+                setUnderline(on);
+            } else {
+                setStrikethrough(on);
+            }
+        } else if ("-fx-line-spacing".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setLineSpacing(((Number) value).doubleValue());
+        } else {
+            return super.cn1SetStyleValue(property, value);
+        }
+        return true;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/TextAlignment.java b/maven/javafx-compat/src/main/java/javafx/scene/text/TextAlignment.java
new file mode 100644
index 00000000000..50bdcc107e3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/TextAlignment.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.text;
+
+/// How the lines of a text are placed across its width.
+public enum TextAlignment {
+    /// Against the left edge.
+    LEFT,
+    /// Centred.
+    CENTER,
+    /// Against the right edge.
+    RIGHT,
+    /// Spread to both edges; drawn as [#LEFT] by this layer.
+    JUSTIFY
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/TextFlow.java b/maven/javafx-compat/src/main/java/javafx/scene/text/TextFlow.java
new file mode 100644
index 00000000000..2aaf18d0665
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/TextFlow.java
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.text;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.FontStyles;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.FxDouble;
+import com.codename1.fxcompat.runtime.FxObject;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.geometry.Bounds;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.scene.Node;
+import javafx.scene.layout.Pane;
+
+/// A pane that sets its children out as words on a line: one after the
+/// other on a shared baseline, onto a new line when the width runs out
+/// or a [Text] ends in a line feed.
+///
+/// Each child is one piece that is never split. JavaFX breaks a long
+/// `Text` between its own words where the line ends; here a `Text` moves
+/// to the next line whole, so rich text made of short runs - a word or a
+/// phrase in each `Text`, which is what gives the runs their different
+/// styles - is laid out the same, and a single long paragraph in one
+/// `Text` is not wrapped. A `Text` with line feeds inside it keeps them
+/// and is placed as the block it is. The `x`, `y` and wrapping width of
+/// a child `Text` are not used, as in JavaFX.
+///
+/// `JUSTIFY` is laid out as `LEFT`.
+///
+/// #### Text of two directions
+///
+/// A line that holds right-to-left characters is ordered as the Unicode
+/// bidirectional algorithm orders it at the level of runs: the texts of
+/// the line are cut into runs of one direction each, a space or a mark
+/// between two runs of a direction joins them, and a row of runs that go
+/// against the direction of the line is seen in reverse. So two Arabic
+/// words in two `Text` nodes of different colours are seen right to left
+/// inside a line that reads left to right. The direction of a line is
+/// that of its first letter. Which characters are right to left is what
+/// `Display.isRTL` says; the letters inside a run are ordered by the
+/// platform that draws the run. Numbers are taken as left-to-right
+/// letters, and explicit embedding marks are not read.
+public class TextFlow extends Pane {
+
+    private final ObjectProperty<TextAlignment> textAlignment = new FxObject<TextAlignment>(this, "textAlignment",
+            TextAlignment.LEFT, Dirty.LAYOUT);
+    private final DoubleProperty lineSpacing = new FxDouble(this, "lineSpacing", 0, Dirty.LAYOUT);
+
+    /// Creates an empty flow.
+    public TextFlow() {
+    }
+
+    /// Creates a flow of some children.
+    public TextFlow(Node... children) {
+        cn1Children().addAll(children);
+    }
+
+    /// Returns how the lines sit in the width of the flow.
+    public final TextAlignment getTextAlignment() {
+        TextAlignment a = textAlignment.get();
+        return a == null ? TextAlignment.LEFT : a;
+    }
+
+    /// Sets how the lines sit in the width of the flow.
+    public final void setTextAlignment(TextAlignment value) {
+        textAlignment.set(value);
+    }
+
+    /// How the lines sit in the width of the flow.
+    public final ObjectProperty<TextAlignment> textAlignmentProperty() {
+        return textAlignment;
+    }
+
+    /// Returns the space added between two lines.
+    public final double getLineSpacing() {
+        return lineSpacing.get();
+    }
+
+    /// Sets the space added between two lines.
+    public final void setLineSpacing(double value) {
+        lineSpacing.set(value);
+    }
+
+    /// The space added between two lines.
+    public final DoubleProperty lineSpacingProperty() {
+        return lineSpacing;
+    }
+
+    /// The width decides the height, as it decides where the lines end.
+    @Override
+    public Orientation getContentBias() {
+        return Orientation.HORIZONTAL;
+    }
+
+    private static final class Line {
+        final List<Node> nodes = new ArrayList<Node>();
+        final List<double[]> boxes = new ArrayList<double[]>();
+        double top;
+        double width;
+        double above;
+        double below;
+        double empty;
+
+        double height() {
+            return nodes.isEmpty() ? empty : above + below;
+        }
+    }
+
+    private static int trailingFeeds(String text) {
+        int n = 0;
+        for (int i = text.length() - 1; i >= 0 && text.charAt(i) == '\n'; i--) {
+            n++;
+        }
+        return n;
+    }
+
+    /// The lines the children fall into for a width; a width of zero or
+    /// less never wraps.
+    private List<Line> lines(double limit) {
+        List<Node> managed = getManagedChildren();
+        List<Line> lines = new ArrayList<Line>();
+        Line line = new Line();
+        double lastLineHeight = 0;
+        for (int i = 0; i < managed.size(); i++) {
+            Node child = managed.get(i);
+            double w;
+            double h;
+            int feeds = 0;
+            if (child.isResizable()) {
+                w = child.prefWidth(-1);
+                h = child.prefHeight(w);
+            } else {
+                Bounds b = child.getLayoutBounds();
+                w = b.getWidth();
+                h = b.getHeight();
+            }
+            double baseline = child.getBaselineOffset();
+            if (child instanceof Text) {
+                Text t = (Text) child;
+                double lineHeight = Fonts.lineHeight(t.getFont());
+                lastLineHeight = lineHeight;
+                feeds = trailingFeeds(t.getText());
+                if (feeds > 0) {
+                    // The empty lines after the feeds belong to the flow,
+                    // not to the height of this piece.
+                    h = Math.max(lineHeight, h - feeds * (lineHeight + t.getLineSpacing()));
+                }
+            }
+            // A child that has no baseline of its own, or was not given
+            // its size yet, stands on the line.
+            if (baseline == BASELINE_OFFSET_SAME_AS_HEIGHT || baseline > h
+                    || (baseline <= 0 && child.isResizable())) {
+                baseline = h;
+            }
+            if (limit > 0 && !line.nodes.isEmpty() && line.width + w > limit) {
+                lines.add(line);
+                line = new Line();
+            }
+            line.nodes.add(child);
+            line.boxes.add(new double[] {line.width, w, h, baseline});
+            line.width += w;
+            line.above = Math.max(line.above, baseline);
+            line.below = Math.max(line.below, h - baseline);
+            for (int f = 0; f < feeds; f++) {
+                lines.add(line);
+                line = new Line();
+                line.empty = lastLineHeight;
+            }
+        }
+        if (!line.nodes.isEmpty() || !lines.isEmpty()) {
+            lines.add(line);
+        }
+        double top = 0;
+        for (int i = 0; i < lines.size(); i++) {
+            Line l = lines.get(i);
+            l.top = top;
+            top += l.height() + getLineSpacing();
+        }
+        return lines;
+    }
+
+    private static double widest(List<Line> lines) {
+        double max = 0;
+        for (int i = 0; i < lines.size(); i++) {
+            max = Math.max(max, lines.get(i).width);
+        }
+        return max;
+    }
+
+    private static double tall(List<Line> lines) {
+        if (lines.isEmpty()) {
+            return 0;
+        }
+        Line last = lines.get(lines.size() - 1);
+        return last.top + last.height();
+    }
+
+    @Override
+    protected double computePrefWidth(double height) {
+        Insets in = getInsets();
+        return in.getLeft() + snapSizeX(widest(lines(0))) + in.getRight();
+    }
+
+    @Override
+    protected double computePrefHeight(double width) {
+        Insets in = getInsets();
+        double limit = width == -1 ? 0 : Math.max(1, width - in.getLeft() - in.getRight());
+        return in.getTop() + snapSizeY(tall(lines(limit))) + in.getBottom();
+    }
+
+    @Override
+    protected double computeMinHeight(double width) {
+        return computePrefHeight(width);
+    }
+
+    /// The baseline of the first line.
+    @Override
+    public double getBaselineOffset() {
+        List<Line> lines = lines(0);
+        Insets in = getInsets();
+        if (lines.isEmpty() || lines.get(0).nodes.isEmpty()) {
+            return in.getTop();
+        }
+        return in.getTop() + lines.get(0).above;
+    }
+
+    @Override
+    protected void layoutChildren() {
+        Insets in = getInsets();
+        double inside = Math.max(1, getWidth() - in.getLeft() - in.getRight());
+        List<Line> lines = lines(inside);
+        TextAlignment align = getTextAlignment();
+        for (int r = 0; r < lines.size(); r++) {
+            Line line = lines.get(r);
+            double x0 = in.getLeft();
+            if (align == TextAlignment.CENTER) {
+                x0 += (inside - line.width) / 2;
+            } else if (align == TextAlignment.RIGHT) {
+                x0 += inside - line.width;
+            }
+            for (int i = 0; i < line.nodes.size(); i++) {
+                Node child = line.nodes.get(i);
+                double[] box = line.boxes.get(i);
+                if (child.isResizable()) {
+                    child.resize(snapSizeX(box[1]), snapSizeY(box[2]));
+                }
+                child.relocate(snapPositionX(x0 + box[0]), snapPositionY(in.getTop() + line.top + line.above - box[3]));
+            }
+            reorder(line, x0, in.getTop());
+        }
+    }
+
+    /// One run of a line: characters of one direction from one child, or
+    /// a child that is not text.
+    private static final class Run {
+        Node node;
+        double[] box;
+        String text;
+        /// 0 left to right, 1 right to left, 2 for neither yet.
+        int kind;
+        double width;
+        double x;
+    }
+
+    private static int kind(char c) {
+        if (com.codename1.ui.Display.getInstance().isRTL(c)) {
+            return 1;
+        }
+        boolean letter = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c >= 0xc0;
+        return letter ? 0 : 2;
+    }
+
+    private static boolean hasRightToLeft(String text) {
+        for (int i = 0; i < text.length(); i++) {
+            if (kind(text.charAt(i)) == 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The text of a child that can be cut into runs: a `Text` of one
+    /// line. `null` for any other child.
+    private static String cuttable(Node child) {
+        if (!(child instanceof Text)) {
+            return null;
+        }
+        String s = ((Text) child).getText();
+        s = s.substring(0, s.length() - trailingFeeds(s));
+        return s.indexOf('\n') >= 0 ? null : s;
+    }
+
+    private static void reverse(List<Run> runs, int from, int to) {
+        for (int a = from, b = to - 1; a < b; a++, b--) {
+            Run kept = runs.get(a);
+            runs.set(a, runs.get(b));
+            runs.set(b, kept);
+        }
+    }
+
+    /// Puts the runs of a line in the order they are seen in, when the
+    /// line holds text of both directions.
+    private void reorder(Line line, double x0, double top) {
+        boolean mixed = false;
+        for (int i = 0; i < line.nodes.size(); i++) {
+            String s = cuttable(line.nodes.get(i));
+            mixed = mixed || (s != null && hasRightToLeft(s));
+        }
+        if (!mixed) {
+            for (int i = 0; i < line.nodes.size(); i++) {
+                Node child = line.nodes.get(i);
+                if (child instanceof Text) {
+                    ((Text) child).flowRuns(null, null);
+                }
+            }
+            return;
+        }
+        // Cut: a piece per stretch of one kind of character.
+        List<Run> runs = new ArrayList<Run>();
+        for (int i = 0; i < line.nodes.size(); i++) {
+            Node child = line.nodes.get(i);
+            String s = cuttable(child);
+            if (s == null) {
+                Run whole = new Run();
+                whole.node = child;
+                whole.box = line.boxes.get(i);
+                whole.width = whole.box[1];
+                runs.add(whole);
+                continue;
+            }
+            int start = 0;
+            while (start < s.length()) {
+                int k = kind(s.charAt(start));
+                int end = start + 1;
+                while (end < s.length() && kind(s.charAt(end)) == k) {
+                    end++;
+                }
+                Run piece = new Run();
+                piece.node = child;
+                piece.box = line.boxes.get(i);
+                piece.text = s.substring(start, end);
+                piece.kind = k;
+                runs.add(piece);
+                start = end;
+            }
+        }
+        int base = 0;
+        for (int i = 0; i < runs.size(); i++) {
+            if (runs.get(i).kind != 2) {
+                base = runs.get(i).kind;
+                break;
+            }
+        }
+        // What is neither takes the direction both its neighbours have,
+        // and that of the line when they differ.
+        int before = base;
+        for (int i = 0; i < runs.size(); i++) {
+            Run r = runs.get(i);
+            if (r.kind != 2) {
+                before = r.kind;
+                continue;
+            }
+            int after = base;
+            for (int j = i + 1; j < runs.size(); j++) {
+                if (runs.get(j).kind != 2) {
+                    after = runs.get(j).kind;
+                    break;
+                }
+            }
+            r.kind = before == after ? before : base;
+        }
+        // Join what one child has side by side in one direction.
+        List<Run> joined = new ArrayList<Run>();
+        for (int i = 0; i < runs.size(); i++) {
+            Run r = runs.get(i);
+            Run last = joined.isEmpty() ? null : joined.get(joined.size() - 1);
+            if (last != null && last.node == r.node && last.kind == r.kind && r.text != null) {
+                last.text = last.text + r.text;
+            } else {
+                joined.add(r);
+            }
+        }
+        for (int i = 0; i < joined.size(); i++) {
+            Run r = joined.get(i);
+            if (r.text != null && r.node instanceof Text) {
+                r.width = Fonts.width(((Text) r.node).getFont(), r.text);
+            }
+        }
+        // Seen: a line that reads right to left starts at its end, and a
+        // row of runs against the line is seen in reverse.
+        if (base == 1) {
+            reverse(joined, 0, joined.size());
+        }
+        int from = 0;
+        while (from < joined.size()) {
+            int to = from;
+            while (to < joined.size() && joined.get(to).kind != base) {
+                to++;
+            }
+            if (to > from) {
+                reverse(joined, from, to);
+                from = to;
+            } else {
+                from++;
+            }
+        }
+        double at = x0;
+        for (int i = 0; i < joined.size(); i++) {
+            joined.get(i).x = at;
+            at += joined.get(i).width;
+        }
+        for (int i = 0; i < line.nodes.size(); i++) {
+            Node child = line.nodes.get(i);
+            double left = Double.MAX_VALUE;
+            int count = 0;
+            for (int j = 0; j < joined.size(); j++) {
+                if (joined.get(j).node == child) {
+                    left = Math.min(left, joined.get(j).x);
+                    count++;
+                }
+            }
+            if (count == 0) {
+                continue;
+            }
+            double[] box = line.boxes.get(i);
+            child.relocate(snapPositionX(left), snapPositionY(top + line.top + line.above - box[3]));
+            if (!(child instanceof Text) || cuttable(child) == null) {
+                continue;
+            }
+            String[] parts = new String[count];
+            double[] offsets = new double[count];
+            int n = 0;
+            for (int j = 0; j < joined.size(); j++) {
+                Run r = joined.get(j);
+                if (r.node == child) {
+                    parts[n] = r.text;
+                    offsets[n++] = r.x - left;
+                }
+            }
+            ((Text) child).flowRuns(parts, offsets);
+        }
+    }
+
+    @Override
+    protected Object cn1StyleValue(String property) {
+        if ("-fx-text-alignment".equals(property)) {
+            return getTextAlignment();
+        } else if ("-fx-line-spacing".equals(property)) {
+            return Double.valueOf(getLineSpacing());
+        }
+        return super.cn1StyleValue(property);
+    }
+
+    @Override
+    protected boolean cn1SetStyleValue(String property, Object value) {
+        if ("-fx-text-alignment".equals(property)) {
+            Object k = FontStyles.keyword(TextAlignment.values(), value);
+            if (!(k instanceof TextAlignment)) {
+                return false;
+            }
+            setTextAlignment((TextAlignment) k);
+            return true;
+        } else if ("-fx-line-spacing".equals(property)) {
+            if (!(value instanceof Number)) {
+                return false;
+            }
+            setLineSpacing(((Number) value).doubleValue());
+            return true;
+        }
+        return super.cn1SetStyleValue(property, value);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/text/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/text/package-info.java
new file mode 100644
index 00000000000..e80eaafc0c3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/text/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Fonts and text: the font model shared by controls, the text node and
+/// the canvas, and the ways lines of text are aligned.
+package javafx.scene.text;
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/Affine.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/Affine.java
new file mode 100644
index 00000000000..461cb18ca90
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/Affine.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import com.codename1.fxcompat.runtime.Matrix2D;
+
+import javafx.beans.property.DoubleProperty;
+import javafx.geometry.Point2D;
+
+/// A general affine transform whose six elements are properties, with
+/// methods that combine it with other transforms in place.
+///
+/// To `append` a transform is to apply it before this one (the matrix is
+/// multiplied on the right, as adding it after this one to a node's
+/// list would); to `prepend` is to apply it after.
+///
+/// The z elements, the three dimensional overloads and the array and
+/// `MatrixType` forms of JavaFX's `Affine` are absent.
+public class Affine extends Transform {
+
+    private final DoubleProperty mxx = new TDouble(this, "mxx", 1);
+    private final DoubleProperty mxy = new TDouble(this, "mxy", 0);
+    private final DoubleProperty tx = new TDouble(this, "tx", 0);
+    private final DoubleProperty myx = new TDouble(this, "myx", 0);
+    private final DoubleProperty myy = new TDouble(this, "myy", 1);
+    private final DoubleProperty ty = new TDouble(this, "ty", 0);
+
+    /// Creates the identity.
+    public Affine() {
+    }
+
+    /// Creates a copy of another transform.
+    public Affine(Transform transform) {
+        this(transform.getMxx(), transform.getMxy(), transform.getTx(), transform.getMyx(), transform.getMyy(),
+                transform.getTy());
+    }
+
+    /// Creates a transform from its six elements, row by row.
+    public Affine(double mxx, double mxy, double tx, double myx, double myy, double ty) {
+        this.mxx.set(mxx);
+        this.mxy.set(mxy);
+        this.tx.set(tx);
+        this.myx.set(myx);
+        this.myy.set(myy);
+        this.ty.set(ty);
+    }
+
+    /// Sets the factor of x in the resulting x.
+    public final void setMxx(double value) {
+        mxx.set(value);
+    }
+
+    @Override
+    public final double getMxx() {
+        return mxx.get();
+    }
+
+    /// The factor of x in the resulting x.
+    public final DoubleProperty mxxProperty() {
+        return mxx;
+    }
+
+    /// Sets the factor of y in the resulting x.
+    public final void setMxy(double value) {
+        mxy.set(value);
+    }
+
+    @Override
+    public final double getMxy() {
+        return mxy.get();
+    }
+
+    /// The factor of y in the resulting x.
+    public final DoubleProperty mxyProperty() {
+        return mxy;
+    }
+
+    /// Sets the amount added to the resulting x.
+    public final void setTx(double value) {
+        tx.set(value);
+    }
+
+    @Override
+    public final double getTx() {
+        return tx.get();
+    }
+
+    /// The amount added to the resulting x.
+    public final DoubleProperty txProperty() {
+        return tx;
+    }
+
+    /// Sets the factor of x in the resulting y.
+    public final void setMyx(double value) {
+        myx.set(value);
+    }
+
+    @Override
+    public final double getMyx() {
+        return myx.get();
+    }
+
+    /// The factor of x in the resulting y.
+    public final DoubleProperty myxProperty() {
+        return myx;
+    }
+
+    /// Sets the factor of y in the resulting y.
+    public final void setMyy(double value) {
+        myy.set(value);
+    }
+
+    @Override
+    public final double getMyy() {
+        return myy.get();
+    }
+
+    /// The factor of y in the resulting y.
+    public final DoubleProperty myyProperty() {
+        return myy;
+    }
+
+    /// Sets the amount added to the resulting y.
+    public final void setTy(double value) {
+        ty.set(value);
+    }
+
+    @Override
+    public final double getTy() {
+        return ty.get();
+    }
+
+    /// The amount added to the resulting y.
+    public final DoubleProperty tyProperty() {
+        return ty;
+    }
+
+    private void assign(double[] m) {
+        setToTransform(m[0], m[2], m[4], m[1], m[3], m[5]);
+    }
+
+    private static double[] row(double mxx, double mxy, double tx, double myx, double myy, double ty) {
+        return new double[] {mxx, myx, mxy, myy, tx, ty};
+    }
+
+    private static double[] rotation(double angle, double pivotX, double pivotY) {
+        double r = Math.toRadians(angle);
+        double cos = Math.cos(r);
+        double sin = Math.sin(r);
+        return row(cos, -sin, pivotX - pivotX * cos + pivotY * sin, sin, cos, pivotY - pivotX * sin - pivotY * cos);
+    }
+
+    private static double[] scaling(double sx, double sy, double pivotX, double pivotY) {
+        return row(sx, 0, (1 - sx) * pivotX, 0, sy, (1 - sy) * pivotY);
+    }
+
+    private static double[] shearing(double shx, double shy, double pivotX, double pivotY) {
+        return row(1, shx, -shx * pivotY, shy, 1, -shy * pivotX);
+    }
+
+    private void appendMatrix(double[] m) {
+        assign(Matrix2D.multiply(matrix(), m));
+    }
+
+    private void prependMatrix(double[] m) {
+        assign(Matrix2D.multiply(m, matrix()));
+    }
+
+    /// Makes this a copy of another transform.
+    public void setToTransform(Transform transform) {
+        setToTransform(transform.getMxx(), transform.getMxy(), transform.getTx(), transform.getMyx(),
+                transform.getMyy(), transform.getTy());
+    }
+
+    /// Sets the six elements, row by row.
+    public void setToTransform(double mxx, double mxy, double tx, double myx, double myy, double ty) {
+        this.mxx.set(mxx);
+        this.mxy.set(mxy);
+        this.tx.set(tx);
+        this.myx.set(myx);
+        this.myy.set(myy);
+        this.ty.set(ty);
+    }
+
+    /// Makes this the identity.
+    public void setToIdentity() {
+        setToTransform(1, 0, 0, 0, 1, 0);
+    }
+
+    /// Replaces this transform with its inverse.
+    public void invert() throws NonInvertibleTransformException {
+        double[] out = new double[6];
+        if (!Matrix2D.invert(matrix(), out)) {
+            throw new NonInvertibleTransformException("Determinant is 0");
+        }
+        assign(out);
+    }
+
+    /// Applies another transform before this one.
+    public void append(Transform transform) {
+        appendMatrix(transform.matrix());
+    }
+
+    /// Applies a transform given by its elements, row by row, before this
+    /// one.
+    public void append(double mxx, double mxy, double tx, double myx, double myy, double ty) {
+        appendMatrix(row(mxx, mxy, tx, myx, myy, ty));
+    }
+
+    /// Applies another transform after this one.
+    public void prepend(Transform transform) {
+        prependMatrix(transform.matrix());
+    }
+
+    /// Applies a transform given by its elements, row by row, after this
+    /// one.
+    public void prepend(double mxx, double mxy, double tx, double myx, double myy, double ty) {
+        prependMatrix(row(mxx, mxy, tx, myx, myy, ty));
+    }
+
+    /// Applies a translation before this transform.
+    public void appendTranslation(double tx, double ty) {
+        appendMatrix(row(1, 0, tx, 0, 1, ty));
+    }
+
+    /// Applies a translation after this transform.
+    public void prependTranslation(double tx, double ty) {
+        prependMatrix(row(1, 0, tx, 0, 1, ty));
+    }
+
+    /// Applies a scale about the origin before this transform.
+    public void appendScale(double sx, double sy) {
+        appendMatrix(scaling(sx, sy, 0, 0));
+    }
+
+    /// Applies a scale about a pivot before this transform.
+    public void appendScale(double sx, double sy, double pivotX, double pivotY) {
+        appendMatrix(scaling(sx, sy, pivotX, pivotY));
+    }
+
+    /// Applies a scale about a pivot before this transform.
+    public void appendScale(double sx, double sy, Point2D pivot) {
+        appendMatrix(scaling(sx, sy, pivot.getX(), pivot.getY()));
+    }
+
+    /// Applies a scale about the origin after this transform.
+    public void prependScale(double sx, double sy) {
+        prependMatrix(scaling(sx, sy, 0, 0));
+    }
+
+    /// Applies a scale about a pivot after this transform.
+    public void prependScale(double sx, double sy, double pivotX, double pivotY) {
+        prependMatrix(scaling(sx, sy, pivotX, pivotY));
+    }
+
+    /// Applies a scale about a pivot after this transform.
+    public void prependScale(double sx, double sy, Point2D pivot) {
+        prependMatrix(scaling(sx, sy, pivot.getX(), pivot.getY()));
+    }
+
+    /// Applies a rotation about the origin, in degrees, before this
+    /// transform.
+    public void appendRotation(double angle) {
+        appendMatrix(rotation(angle, 0, 0));
+    }
+
+    /// Applies a rotation about a pivot before this transform.
+    public void appendRotation(double angle, double pivotX, double pivotY) {
+        appendMatrix(rotation(angle, pivotX, pivotY));
+    }
+
+    /// Applies a rotation about a pivot before this transform.
+    public void appendRotation(double angle, Point2D pivot) {
+        appendMatrix(rotation(angle, pivot.getX(), pivot.getY()));
+    }
+
+    /// Applies a rotation about the origin, in degrees, after this
+    /// transform.
+    public void prependRotation(double angle) {
+        prependMatrix(rotation(angle, 0, 0));
+    }
+
+    /// Applies a rotation about a pivot after this transform.
+    public void prependRotation(double angle, double pivotX, double pivotY) {
+        prependMatrix(rotation(angle, pivotX, pivotY));
+    }
+
+    /// Applies a rotation about a pivot after this transform.
+    public void prependRotation(double angle, Point2D pivot) {
+        prependMatrix(rotation(angle, pivot.getX(), pivot.getY()));
+    }
+
+    /// Applies a shear about the origin before this transform.
+    public void appendShear(double shx, double shy) {
+        appendMatrix(shearing(shx, shy, 0, 0));
+    }
+
+    /// Applies a shear about a pivot before this transform.
+    public void appendShear(double shx, double shy, double pivotX, double pivotY) {
+        appendMatrix(shearing(shx, shy, pivotX, pivotY));
+    }
+
+    /// Applies a shear about a pivot before this transform.
+    public void appendShear(double shx, double shy, Point2D pivot) {
+        appendMatrix(shearing(shx, shy, pivot.getX(), pivot.getY()));
+    }
+
+    /// Applies a shear about the origin after this transform.
+    public void prependShear(double shx, double shy) {
+        prependMatrix(shearing(shx, shy, 0, 0));
+    }
+
+    /// Applies a shear about a pivot after this transform.
+    public void prependShear(double shx, double shy, double pivotX, double pivotY) {
+        prependMatrix(shearing(shx, shy, pivotX, pivotY));
+    }
+
+    /// Applies a shear about a pivot after this transform.
+    public void prependShear(double shx, double shy, Point2D pivot) {
+        prependMatrix(shearing(shx, shy, pivot.getX(), pivot.getY()));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/NonInvertibleTransformException.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/NonInvertibleTransformException.java
new file mode 100644
index 00000000000..a66f4ba9411
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/NonInvertibleTransformException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+/// Thrown when the inverse of a transform is asked for and it has none,
+/// because it flattens the plane onto a line or a point.
+public class NonInvertibleTransformException extends Exception {
+
+    /// Creates the exception with a message.
+    public NonInvertibleTransformException(String message) {
+        super(message);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/Rotate.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/Rotate.java
new file mode 100644
index 00000000000..db383faa5b4
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/Rotate.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Rotates coordinates about a pivot point by an angle in degrees. A
+/// positive angle turns clockwise on the screen, where y points down.
+///
+/// The rotation is in the plane only: the `axis` of JavaFX's `Rotate`,
+/// its axis constants and the pivot's z are absent.
+public class Rotate extends Transform {
+
+    private final DoubleProperty angle = new TDouble(this, "angle", 0);
+    private final DoubleProperty pivotX = new TDouble(this, "pivotX", 0);
+    private final DoubleProperty pivotY = new TDouble(this, "pivotY", 0);
+
+    /// Creates a rotation by nothing.
+    public Rotate() {
+    }
+
+    /// Creates a rotation about the origin.
+    public Rotate(double angle) {
+        this.angle.set(angle);
+    }
+
+    /// Creates a rotation about a pivot.
+    public Rotate(double angle, double pivotX, double pivotY) {
+        this.angle.set(angle);
+        this.pivotX.set(pivotX);
+        this.pivotY.set(pivotY);
+    }
+
+    /// Returns the angle in degrees.
+    public final double getAngle() {
+        return angle.get();
+    }
+
+    /// Sets the angle in degrees.
+    public final void setAngle(double value) {
+        angle.set(value);
+    }
+
+    /// The angle in degrees.
+    public final DoubleProperty angleProperty() {
+        return angle;
+    }
+
+    /// Returns the x of the point rotated about.
+    public final double getPivotX() {
+        return pivotX.get();
+    }
+
+    /// Sets the x of the point rotated about.
+    public final void setPivotX(double value) {
+        pivotX.set(value);
+    }
+
+    /// The x of the point rotated about.
+    public final DoubleProperty pivotXProperty() {
+        return pivotX;
+    }
+
+    /// Returns the y of the point rotated about.
+    public final double getPivotY() {
+        return pivotY.get();
+    }
+
+    /// Sets the y of the point rotated about.
+    public final void setPivotY(double value) {
+        pivotY.set(value);
+    }
+
+    /// The y of the point rotated about.
+    public final DoubleProperty pivotYProperty() {
+        return pivotY;
+    }
+
+    private double cos() {
+        return Math.cos(Math.toRadians(getAngle()));
+    }
+
+    private double sin() {
+        return Math.sin(Math.toRadians(getAngle()));
+    }
+
+    @Override
+    public double getMxx() {
+        return cos();
+    }
+
+    @Override
+    public double getMxy() {
+        return -sin();
+    }
+
+    @Override
+    public double getMyx() {
+        return sin();
+    }
+
+    @Override
+    public double getMyy() {
+        return cos();
+    }
+
+    @Override
+    public double getTx() {
+        return getPivotX() - getPivotX() * cos() + getPivotY() * sin();
+    }
+
+    @Override
+    public double getTy() {
+        return getPivotY() - getPivotX() * sin() - getPivotY() * cos();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/Scale.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/Scale.java
new file mode 100644
index 00000000000..c0bad9fd937
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/Scale.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Scales coordinates about a pivot point, which stays where it is.
+public class Scale extends Transform {
+
+    private final DoubleProperty x = new TDouble(this, "x", 1);
+    private final DoubleProperty y = new TDouble(this, "y", 1);
+    private final DoubleProperty pivotX = new TDouble(this, "pivotX", 0);
+    private final DoubleProperty pivotY = new TDouble(this, "pivotY", 0);
+
+    /// Creates a scale that changes nothing.
+    public Scale() {
+    }
+
+    /// Creates a scale about the origin.
+    public Scale(double x, double y) {
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Creates a scale about a pivot.
+    public Scale(double x, double y, double pivotX, double pivotY) {
+        this.x.set(x);
+        this.y.set(y);
+        this.pivotX.set(pivotX);
+        this.pivotY.set(pivotY);
+    }
+
+    /// Returns the horizontal factor.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the horizontal factor.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The horizontal factor.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the vertical factor.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the vertical factor.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The vertical factor.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    /// Returns the x of the point that stays in place.
+    public final double getPivotX() {
+        return pivotX.get();
+    }
+
+    /// Sets the x of the point that stays in place.
+    public final void setPivotX(double value) {
+        pivotX.set(value);
+    }
+
+    /// The x of the point that stays in place.
+    public final DoubleProperty pivotXProperty() {
+        return pivotX;
+    }
+
+    /// Returns the y of the point that stays in place.
+    public final double getPivotY() {
+        return pivotY.get();
+    }
+
+    /// Sets the y of the point that stays in place.
+    public final void setPivotY(double value) {
+        pivotY.set(value);
+    }
+
+    /// The y of the point that stays in place.
+    public final DoubleProperty pivotYProperty() {
+        return pivotY;
+    }
+
+    @Override
+    public double getMxx() {
+        return getX();
+    }
+
+    @Override
+    public double getMyy() {
+        return getY();
+    }
+
+    @Override
+    public double getTx() {
+        return (1 - getX()) * getPivotX();
+    }
+
+    @Override
+    public double getTy() {
+        return (1 - getY()) * getPivotY();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/Shear.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/Shear.java
new file mode 100644
index 00000000000..a25e2cb82c3
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/Shear.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Slants coordinates: x moves in proportion to the distance from the
+/// pivot's y, and y in proportion to the distance from the pivot's x.
+public class Shear extends Transform {
+
+    private final DoubleProperty x = new TDouble(this, "x", 0);
+    private final DoubleProperty y = new TDouble(this, "y", 0);
+    private final DoubleProperty pivotX = new TDouble(this, "pivotX", 0);
+    private final DoubleProperty pivotY = new TDouble(this, "pivotY", 0);
+
+    /// Creates a shear that changes nothing.
+    public Shear() {
+    }
+
+    /// Creates a shear about the origin.
+    public Shear(double x, double y) {
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Creates a shear about a pivot.
+    public Shear(double x, double y, double pivotX, double pivotY) {
+        this.x.set(x);
+        this.y.set(y);
+        this.pivotX.set(pivotX);
+        this.pivotY.set(pivotY);
+    }
+
+    /// Returns how far x moves per unit of y.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets how far x moves per unit of y.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// How far x moves per unit of y.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns how far y moves per unit of x.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets how far y moves per unit of x.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// How far y moves per unit of x.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    /// Returns the x of the point that stays in place.
+    public final double getPivotX() {
+        return pivotX.get();
+    }
+
+    /// Sets the x of the point that stays in place.
+    public final void setPivotX(double value) {
+        pivotX.set(value);
+    }
+
+    /// The x of the point that stays in place.
+    public final DoubleProperty pivotXProperty() {
+        return pivotX;
+    }
+
+    /// Returns the y of the point that stays in place.
+    public final double getPivotY() {
+        return pivotY.get();
+    }
+
+    /// Sets the y of the point that stays in place.
+    public final void setPivotY(double value) {
+        pivotY.set(value);
+    }
+
+    /// The y of the point that stays in place.
+    public final DoubleProperty pivotYProperty() {
+        return pivotY;
+    }
+
+    @Override
+    public double getMxy() {
+        return getX();
+    }
+
+    @Override
+    public double getMyx() {
+        return getY();
+    }
+
+    @Override
+    public double getTx() {
+        return -getX() * getPivotY();
+    }
+
+    @Override
+    public double getTy() {
+        return -getY() * getPivotX();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/TDouble.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/TDouble.java
new file mode 100644
index 00000000000..6bc3cc4952c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/TDouble.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import javafx.beans.property.SimpleDoubleProperty;
+
+/// A property of a transform; a change reaches the nodes that use it.
+final class TDouble extends SimpleDoubleProperty {
+
+    private final Transform owner;
+
+    TDouble(Transform owner, String name, double initial) {
+        super(owner, name, initial);
+        this.owner = owner;
+    }
+
+    @Override
+    protected void invalidated() {
+        owner.transformChanged();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/Transform.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/Transform.java
new file mode 100644
index 00000000000..1a942ae43db
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/Transform.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import java.util.ArrayList;
+
+import com.codename1.fxcompat.runtime.Dirty;
+import com.codename1.fxcompat.runtime.Matrix2D;
+
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Point2D;
+
+/// An affine transformation of the plane:
+///
+/// ```
+/// x' = mxx * x + mxy * y + tx
+/// y' = myx * x + myy * y + ty
+/// ```
+///
+/// A node applies the transforms in its `getTransforms()` list in order,
+/// the first one outermost, between its layout position and its own
+/// scale and rotation.
+///
+/// Only two dimensions exist in this layer: the z elements of JavaFX's
+/// matrix (`getMxz()`, `getTz()` and the like), the three dimensional
+/// overloads, `Point3D`, `toArray`, `column`, `row`, `similarTo`,
+/// `clone()` and the `TransformChangedEvent` handlers are absent.
+public abstract class Transform {
+
+    private ArrayList<Dirty.Owner> owners;
+
+    /// Creates a transform.
+    public Transform() {
+    }
+
+    /// Returns an affine transform with the six elements given column by
+    /// column.
+    public static Affine affine(double mxx, double myx, double mxy, double myy, double tx, double ty) {
+        return new Affine(mxx, mxy, tx, myx, myy, ty);
+    }
+
+    /// Returns a translation.
+    public static Translate translate(double x, double y) {
+        return new Translate(x, y);
+    }
+
+    /// Returns a clockwise rotation by an angle in degrees about a pivot.
+    public static Rotate rotate(double angle, double pivotX, double pivotY) {
+        return new Rotate(angle, pivotX, pivotY);
+    }
+
+    /// Returns a scale about the origin.
+    public static Scale scale(double x, double y) {
+        return new Scale(x, y);
+    }
+
+    /// Returns a scale about a pivot.
+    public static Scale scale(double x, double y, double pivotX, double pivotY) {
+        return new Scale(x, y, pivotX, pivotY);
+    }
+
+    /// Returns a shear about the origin.
+    public static Shear shear(double x, double y) {
+        return new Shear(x, y);
+    }
+
+    /// Returns a shear about a pivot.
+    public static Shear shear(double x, double y, double pivotX, double pivotY) {
+        return new Shear(x, y, pivotX, pivotY);
+    }
+
+    /// Returns the factor of x in the resulting x.
+    public double getMxx() {
+        return 1;
+    }
+
+    /// Returns the factor of y in the resulting x.
+    public double getMxy() {
+        return 0;
+    }
+
+    /// Returns the amount added to the resulting x.
+    public double getTx() {
+        return 0;
+    }
+
+    /// Returns the factor of x in the resulting y.
+    public double getMyx() {
+        return 0;
+    }
+
+    /// Returns the factor of y in the resulting y.
+    public double getMyy() {
+        return 1;
+    }
+
+    /// Returns the amount added to the resulting y.
+    public double getTy() {
+        return 0;
+    }
+
+    final double[] matrix() {
+        return new double[] {getMxx(), getMyx(), getMxy(), getMyy(), getTx(), getTy()};
+    }
+
+    /// Returns whether this transform changes nothing.
+    public final boolean isIdentity() {
+        return Matrix2D.isIdentity(matrix());
+    }
+
+    /// Returns the determinant of the matrix; zero when the transform
+    /// cannot be inverted.
+    public double determinant() {
+        return getMxx() * getMyy() - getMxy() * getMyx();
+    }
+
+    /// Transforms a point.
+    public Point2D transform(double x, double y) {
+        return new Point2D(getMxx() * x + getMxy() * y + getTx(), getMyx() * x + getMyy() * y + getTy());
+    }
+
+    /// Transforms a point.
+    public Point2D transform(Point2D point) {
+        return transform(point.getX(), point.getY());
+    }
+
+    private static Bounds box(double[] m, Bounds bounds) {
+        double[] b = Matrix2D.bounds(m, bounds.getMinX(), bounds.getMinY(), bounds.getWidth(),
+                bounds.getHeight());
+        return new BoundingBox(b[0], b[1], b[2] - b[0], b[3] - b[1]);
+    }
+
+    /// Returns the box around transformed bounds.
+    public Bounds transform(Bounds bounds) {
+        return box(matrix(), bounds);
+    }
+
+    /// Transforms a distance: the point without the translation.
+    public Point2D deltaTransform(double x, double y) {
+        return new Point2D(getMxx() * x + getMxy() * y, getMyx() * x + getMyy() * y);
+    }
+
+    /// Transforms a distance: the point without the translation.
+    public Point2D deltaTransform(Point2D point) {
+        return deltaTransform(point.getX(), point.getY());
+    }
+
+    private double[] inverse() throws NonInvertibleTransformException {
+        double[] out = new double[6];
+        if (!Matrix2D.invert(matrix(), out)) {
+            throw new NonInvertibleTransformException("Determinant is 0");
+        }
+        return out;
+    }
+
+    /// Maps a transformed point back.
+    public Point2D inverseTransform(double x, double y) throws NonInvertibleTransformException {
+        double[] inv = inverse();
+        return new Point2D(Matrix2D.x(inv, x, y), Matrix2D.y(inv, x, y));
+    }
+
+    /// Maps a transformed point back.
+    public Point2D inverseTransform(Point2D point) throws NonInvertibleTransformException {
+        return inverseTransform(point.getX(), point.getY());
+    }
+
+    /// Returns the box around bounds mapped back.
+    public Bounds inverseTransform(Bounds bounds) throws NonInvertibleTransformException {
+        return box(inverse(), bounds);
+    }
+
+    /// Maps a transformed distance back.
+    public Point2D inverseDeltaTransform(double x, double y) throws NonInvertibleTransformException {
+        double[] inv = inverse();
+        return new Point2D(inv[0] * x + inv[2] * y, inv[1] * x + inv[3] * y);
+    }
+
+    /// Maps a transformed distance back.
+    public Point2D inverseDeltaTransform(Point2D point) throws NonInvertibleTransformException {
+        return inverseDeltaTransform(point.getX(), point.getY());
+    }
+
+    /// Returns this transform followed, in a node's list, by another: a
+    /// point goes through `transform` first and through this one second,
+    /// exactly as when both are added to `getTransforms()` in that order.
+    public Transform createConcatenation(Transform transform) {
+        double[] m = Matrix2D.multiply(matrix(), transform.matrix());
+        return new Affine(m[0], m[2], m[4], m[1], m[3], m[5]);
+    }
+
+    /// Returns the transform that undoes this one.
+    public Transform createInverse() throws NonInvertibleTransformException {
+        double[] m = inverse();
+        return new Affine(m[0], m[2], m[4], m[1], m[3], m[5]);
+    }
+
+    /// Tells the nodes using this transform that it changed. Called by
+    /// the properties of the subclasses; a subclass of the application's
+    /// own calls it when what its getters answer changed.
+    protected void transformChanged() {
+        if (owners != null) {
+            for (int i = owners.size() - 1; i >= 0; i--) {
+                if (i < owners.size()) {
+                    owners.get(i).cn1Invalidated(Dirty.BOUNDS);
+                }
+            }
+        }
+    }
+
+    /// Registers a node whose `getTransforms()` holds this transform; it
+    /// is told with `Dirty.BOUNDS` when the transform changes. Registering
+    /// twice counts once.
+    public final void cn1Attach(Dirty.Owner node) {
+        if (owners == null) {
+            owners = new ArrayList<Dirty.Owner>(2);
+        }
+        if (!owners.contains(node)) {
+            owners.add(node);
+        }
+    }
+
+    /// Removes a node registered with [#cn1Attach(Dirty.Owner)].
+    public final void cn1Detach(Dirty.Owner node) {
+        if (owners != null) {
+            owners.remove(node);
+        }
+    }
+
+    /// Returns the class name and the six elements.
+    @Override
+    public String toString() {
+        String name = getClass().getName();
+        return name.substring(name.lastIndexOf('.') + 1) + " [" + getMxx() + ", " + getMxy() + ", " + getTx() + ", "
+                + getMyx() + ", " + getMyy() + ", " + getTy() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/Translate.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/Translate.java
new file mode 100644
index 00000000000..ed78007519f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/Translate.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.scene.transform;
+
+import javafx.beans.property.DoubleProperty;
+
+/// Moves coordinates by a distance.
+public class Translate extends Transform {
+
+    private final DoubleProperty x = new TDouble(this, "x", 0);
+    private final DoubleProperty y = new TDouble(this, "y", 0);
+
+    /// Creates a translation by nothing.
+    public Translate() {
+    }
+
+    /// Creates a translation.
+    public Translate(double x, double y) {
+        this.x.set(x);
+        this.y.set(y);
+    }
+
+    /// Returns the horizontal distance.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Sets the horizontal distance.
+    public final void setX(double value) {
+        x.set(value);
+    }
+
+    /// The horizontal distance.
+    public final DoubleProperty xProperty() {
+        return x;
+    }
+
+    /// Returns the vertical distance.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Sets the vertical distance.
+    public final void setY(double value) {
+        y.set(value);
+    }
+
+    /// The vertical distance.
+    public final DoubleProperty yProperty() {
+        return y;
+    }
+
+    @Override
+    public double getTx() {
+        return getX();
+    }
+
+    @Override
+    public double getTy() {
+        return getY();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/scene/transform/package-info.java b/maven/javafx-compat/src/main/java/javafx/scene/transform/package-info.java
new file mode 100644
index 00000000000..9808a5181b5
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/scene/transform/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Affine transforms of the plane for a node's `getTransforms()` list:
+/// translation, scale, rotation, shear and the general matrix. Three
+/// dimensional transforms are not part of this layer.
+package javafx.scene.transform;
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/FileChooser.java b/maven/javafx-compat/src/main/java/javafx/stage/FileChooser.java
new file mode 100644
index 00000000000..4a528feec12
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/FileChooser.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.codename1.fxcompat.runtime.FilePicker;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+/// Asks the user for a file.
+///
+/// Opening goes through the platform's own document picker, limited to
+/// the extensions of the filters, and the call waits for the answer as
+/// in JavaFX. Three things differ from a desktop:
+///
+/// - the picker answers one file, so [#showOpenMultipleDialog(Window)]
+///   answers a list of one;
+/// - a device has no dialog that names a new file. [#showSaveDialog(Window)]
+///   answers the file of the initial name, or `untitled` with the first
+///   extension of the selected filter, in the initial directory when one
+///   was given and otherwise in the directory the application may write
+///   to. It does not ask, and it never answers `null`;
+/// - the title, and the initial directory when opening, are recorded
+///   and not shown: the platform's picker decides where it starts.
+public final class FileChooser {
+
+    private final StringProperty title = new SimpleStringProperty(this, "title");
+    private final ObjectProperty<File> initialDirectory = new SimpleObjectProperty<File>(this, "initialDirectory");
+    private final ObjectProperty<String> initialFileName = new SimpleObjectProperty<String>(this,
+            "initialFileName");
+    private final ObjectProperty<ExtensionFilter> selectedExtensionFilter = new SimpleObjectProperty<ExtensionFilter>(
+            this, "selectedExtensionFilter");
+    private final ObservableList<ExtensionFilter> extensionFilters = FXCollections.observableArrayList();
+
+    /// A named set of file name patterns, each `*.` and an extension;
+    /// `*.*` and `*` stand for any file.
+    public static final class ExtensionFilter {
+
+        private final String description;
+        private final List<String> extensions;
+
+        /// Creates a filter from a description and its patterns.
+        public ExtensionFilter(String description, String... extensions) {
+            this(description, list(extensions));
+        }
+
+        /// Creates a filter from a description and a list of patterns.
+        public ExtensionFilter(String description, List<String> extensions) {
+            if (description == null) {
+                throw new NullPointerException("Description must not be null");
+            }
+            if (description.length() == 0) {
+                throw new IllegalArgumentException("Description must not be empty");
+            }
+            if (extensions == null) {
+                throw new NullPointerException("Extensions must not be null");
+            }
+            if (extensions.isEmpty()) {
+                throw new IllegalArgumentException("At least one extension must be defined");
+            }
+            ArrayList<String> copy = new ArrayList<String>();
+            for (int i = 0; i < extensions.size(); i++) {
+                String e = extensions.get(i);
+                if (e == null) {
+                    throw new NullPointerException("Extension must not be null");
+                }
+                if (e.length() == 0) {
+                    throw new IllegalArgumentException("Extension must not be empty");
+                }
+                copy.add(e);
+            }
+            this.description = description;
+            this.extensions = Collections.unmodifiableList(copy);
+        }
+
+        private static List<String> list(String[] extensions) {
+            if (extensions == null) {
+                throw new NullPointerException("Extensions must not be null");
+            }
+            ArrayList<String> out = new ArrayList<String>();
+            for (int i = 0; i < extensions.length; i++) {
+                out.add(extensions[i]);
+            }
+            return out;
+        }
+
+        /// Returns the description.
+        public String getDescription() {
+            return description;
+        }
+
+        /// Returns the patterns, which cannot be changed.
+        public List<String> getExtensions() {
+            return extensions;
+        }
+    }
+
+    /// Creates a chooser with no filter.
+    public FileChooser() {
+    }
+
+    /// Returns the title.
+    public final String getTitle() {
+        return title.get();
+    }
+
+    /// Sets the title.
+    public final void setTitle(String value) {
+        title.set(value);
+    }
+
+    /// The title of the dialog.
+    public final StringProperty titleProperty() {
+        return title;
+    }
+
+    /// Returns the directory to start in.
+    public final File getInitialDirectory() {
+        return initialDirectory.get();
+    }
+
+    /// Sets the directory to start in.
+    public final void setInitialDirectory(File value) {
+        initialDirectory.set(value);
+    }
+
+    /// The directory to start in.
+    public final ObjectProperty<File> initialDirectoryProperty() {
+        return initialDirectory;
+    }
+
+    /// Returns the name a file to save starts with.
+    public final String getInitialFileName() {
+        return initialFileName.get();
+    }
+
+    /// Sets the name a file to save starts with.
+    public final void setInitialFileName(String value) {
+        initialFileName.set(value);
+    }
+
+    /// The name a file to save starts with.
+    public final ObjectProperty<String> initialFileNameProperty() {
+        return initialFileName;
+    }
+
+    /// Returns the filters, to be added to.
+    public ObservableList<ExtensionFilter> getExtensionFilters() {
+        return extensionFilters;
+    }
+
+    /// Returns the filter in use.
+    public final ExtensionFilter getSelectedExtensionFilter() {
+        return selectedExtensionFilter.get();
+    }
+
+    /// Sets the filter in use.
+    public final void setSelectedExtensionFilter(ExtensionFilter value) {
+        selectedExtensionFilter.set(value);
+    }
+
+    /// The filter in use.
+    public final ObjectProperty<ExtensionFilter> selectedExtensionFilterProperty() {
+        return selectedExtensionFilter;
+    }
+
+    /// Asks for a file to open and returns it, or `null` when the user
+    /// cancelled.
+    public File showOpenDialog(Window ownerWindow) {
+        String path = FilePicker.open(accept());
+        return path == null ? null : new File(path);
+    }
+
+    /// Asks for files to open and returns them, or `null` when the user
+    /// cancelled. The list holds the one file the platform's picker
+    /// answers.
+    public List<File> showOpenMultipleDialog(Window ownerWindow) {
+        File one = showOpenDialog(ownerWindow);
+        if (one == null) {
+            return null;
+        }
+        ArrayList<File> out = new ArrayList<File>();
+        out.add(one);
+        return Collections.unmodifiableList(out);
+    }
+
+    /// Returns the file to save to; see the class for which that is.
+    public File showSaveDialog(Window ownerWindow) {
+        String name = getInitialFileName();
+        if (name == null || name.length() == 0) {
+            name = "untitled" + suffix();
+        }
+        File dir = getInitialDirectory();
+        return dir != null ? new File(dir, name) : new File(FilePicker.home(), name);
+    }
+
+    /// The filter that applies: the selected one, or the first.
+    private ExtensionFilter filter() {
+        ExtensionFilter selected = getSelectedExtensionFilter();
+        if (selected == null && !extensionFilters.isEmpty()) {
+            selected = extensionFilters.get(0);
+        }
+        return selected;
+    }
+
+    /// The extension a file saved under the applying filter gets, with
+    /// its dot, or nothing for a filter of any file.
+    private String suffix() {
+        ExtensionFilter f = filter();
+        if (f == null) {
+            return "";
+        }
+        String e = extension(f.getExtensions().get(0));
+        return e == null ? "" : "." + e;
+    }
+
+    /// The extensions of every filter, separated by commas, as the
+    /// platform's picker takes them; `null` when any filter takes any
+    /// file, or there is no filter.
+    private String accept() {
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < extensionFilters.size(); i++) {
+            List<String> patterns = extensionFilters.get(i).getExtensions();
+            for (int j = 0; j < patterns.size(); j++) {
+                String e = extension(patterns.get(j));
+                if (e == null) {
+                    return null;
+                }
+                if (out.length() > 0) {
+                    out.append(',');
+                }
+                out.append(e);
+            }
+        }
+        return out.length() == 0 ? null : out.toString();
+    }
+
+    /// The extension a pattern names, or `null` for one that takes any
+    /// file.
+    private static String extension(String pattern) {
+        int dot = pattern.lastIndexOf('.');
+        String e = dot < 0 ? pattern : pattern.substring(dot + 1);
+        return e.length() == 0 || e.indexOf('*') >= 0 ? null : e;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/Modality.java b/maven/javafx-compat/src/main/java/javafx/stage/Modality.java
new file mode 100644
index 00000000000..e97772d48dd
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/Modality.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+/// How a stage blocks input to the other windows while it is showing.
+public enum Modality {
+    /// The stage blocks nothing.
+    NONE,
+    /// The stage blocks its owner and the owner's owners.
+    WINDOW_MODAL,
+    /// The stage blocks every other window of the application.
+    APPLICATION_MODAL
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/PopupWindow.java b/maven/javafx-compat/src/main/java/javafx/stage/PopupWindow.java
new file mode 100644
index 00000000000..9e5a46bed0f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/PopupWindow.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+import java.util.ArrayList;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+
+/// A window without decoration that floats over the window of its owner:
+/// the base of menus, tooltips and other popups.
+///
+/// A popup is not a window of the device. Its scene is drawn in a layer
+/// over the form that shows the owner, at the anchor, and moved back
+/// inside the form where it would stick out; see
+/// `com.codename1.fxcompat.runtime.StagePopup`. An owner shown in a
+/// separate desktop window has no such layer, and a popup of it is not
+/// drawn.
+///
+/// The anchor is in the coordinates the input events of this layer report
+/// as screen coordinates: those of the scene of the owning window, or,
+/// for a popup opened from a popup, of the scene below both.
+///
+/// A popup with `autoHide` is hidden by a press outside every open popup;
+/// the press then goes on to what is under it. `autoFix`,
+/// `hideOnEscape`, `consumeAutoHidingEvents` and the anchor location of
+/// JavaFX are not part of this layer.
+public abstract class PopupWindow extends Window {
+
+    private final ReadOnlyObjectWrapper<Window> ownerWindow = new ReadOnlyObjectWrapper<Window>(this, "ownerWindow");
+    private final ReadOnlyObjectWrapper<Node> ownerNode = new ReadOnlyObjectWrapper<Node>(this, "ownerNode");
+    private final BooleanProperty autoHide = new SimpleBooleanProperty(this, "autoHide", false);
+    private final ReadOnlyDoubleWrapper anchorX = new ReadOnlyDoubleWrapper(this, "anchorX", Double.NaN);
+    private final ReadOnlyDoubleWrapper anchorY = new ReadOnlyDoubleWrapper(this, "anchorY", Double.NaN);
+
+    /// Creates a popup that is not showing.
+    public PopupWindow() {
+    }
+
+    /// The window this popup floats over.
+    public final ReadOnlyObjectProperty<Window> ownerWindowProperty() {
+        return ownerWindow.getReadOnlyProperty();
+    }
+
+    /// Returns the window this popup floats over, `null` while hidden.
+    public final Window getOwnerWindow() {
+        return ownerWindow.get();
+    }
+
+    /// The node this popup was opened for.
+    public final ReadOnlyObjectProperty<Node> ownerNodeProperty() {
+        return ownerNode.getReadOnlyProperty();
+    }
+
+    /// Returns the node this popup was opened for, or `null`.
+    public final Node getOwnerNode() {
+        return ownerNode.get();
+    }
+
+    /// Sets whether a press outside the popup hides it.
+    public final void setAutoHide(boolean value) {
+        autoHide.set(value);
+    }
+
+    /// Returns whether a press outside the popup hides it.
+    public final boolean isAutoHide() {
+        return autoHide.get();
+    }
+
+    /// Whether a press outside the popup hides it.
+    public final BooleanProperty autoHideProperty() {
+        return autoHide;
+    }
+
+    /// The x the top left corner of the popup is asked to be at.
+    public final ReadOnlyDoubleProperty anchorXProperty() {
+        return anchorX.getReadOnlyProperty();
+    }
+
+    /// Asks for an x of the top left corner.
+    public final void setAnchorX(final double value) {
+        anchorX.set(value);
+        if (cn1Host() != null) {
+            cn1Host().boundsRequested();
+        }
+    }
+
+    /// Returns the x the top left corner is asked to be at.
+    public final double getAnchorX() {
+        return anchorX.get();
+    }
+
+    /// The y the top left corner of the popup is asked to be at.
+    public final ReadOnlyDoubleProperty anchorYProperty() {
+        return anchorY.getReadOnlyProperty();
+    }
+
+    /// Asks for a y of the top left corner.
+    public final void setAnchorY(final double value) {
+        anchorY.set(value);
+        if (cn1Host() != null) {
+            cn1Host().boundsRequested();
+        }
+    }
+
+    /// Returns the y the top left corner is asked to be at.
+    public final double getAnchorY() {
+        return anchorY.get();
+    }
+
+    /// Shows the popup over a window, where it last was.
+    public void show(Window owner) {
+        if (owner == null) {
+            throw new NullPointerException("The owner must not be null");
+        }
+        ownerNode.set(null);
+        ownerWindow.set(owner);
+        cn1Show(false);
+    }
+
+    /// Shows the popup for a node, with its top left corner at the
+    /// anchor. Unlike in JavaFX the node need not be in a showing window;
+    /// the popup is then open but not drawn.
+    public void show(Node ownerNode, double anchorX, double anchorY) {
+        if (ownerNode == null) {
+            throw new NullPointerException("The owner node must not be null");
+        }
+        Scene s = ownerNode.getScene();
+        this.ownerNode.set(ownerNode);
+        this.ownerWindow.set(s == null ? null : s.getWindow());
+        place(anchorX, anchorY);
+    }
+
+    /// Shows the popup over a window, with its top left corner at the
+    /// anchor.
+    public void show(Window ownerWindow, double anchorX, double anchorY) {
+        if (ownerWindow == null) {
+            throw new NullPointerException("The owner window must not be null");
+        }
+        this.ownerNode.set(null);
+        this.ownerWindow.set(ownerWindow);
+        place(anchorX, anchorY);
+    }
+
+    private void place(double x, double y) {
+        anchorX.set(x);
+        anchorY.set(y);
+        if (isShowing()) {
+            if (cn1Host() != null) {
+                cn1Host().boundsRequested();
+            }
+        } else {
+            cn1Show(false);
+        }
+    }
+
+    private boolean opened(PopupWindow other) {
+        if (other.getOwnerWindow() == this) {
+            return true;
+        }
+        Node n = other.getOwnerNode();
+        return n != null && n.getScene() != null && n.getScene().getWindow() == this;
+    }
+
+    /// Hides the popup and every popup opened from it.
+    @Override
+    public void hide() {
+        if (!isShowing()) {
+            return;
+        }
+        ArrayList<Window> all = new ArrayList<Window>(Window.getWindows());
+        for (int i = 0; i < all.size(); i++) {
+            Window w = all.get(i);
+            if (w != this && w instanceof PopupWindow && w.isShowing() && opened((PopupWindow) w)) {
+                w.hide();
+            }
+        }
+        super.hide();
+        ownerWindow.set(null);
+        ownerNode.set(null);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/Screen.java b/maven/javafx-compat/src/main/java/javafx/stage/Screen.java
new file mode 100644
index 00000000000..0ca7c09cc64
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/Screen.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Display;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Rectangle2D;
+
+/// The display the application is on.
+///
+/// Codename One has one: the screen of the device, or the window of the
+/// application on a desktop. Its bounds are that display in logical
+/// pixels, read each time they are asked for, so they follow a rotation
+/// of the device. The visual bounds are the same rectangle, because the
+/// status bar and the keyboard are outside what Codename One reports.
+///
+/// Before the display exists, as in a plain unit test, both are empty.
+public final class Screen {
+
+    private static final Screen PRIMARY = new Screen();
+
+    private Screen() {
+    }
+
+    /// Returns the one screen.
+    public static Screen getPrimary() {
+        return PRIMARY;
+    }
+
+    /// Returns the screens, which is the one screen.
+    public static ObservableList<Screen> getScreens() {
+        ObservableList<Screen> list = FXCollections.observableArrayList();
+        list.add(PRIMARY);
+        return list;
+    }
+
+    /// Returns the screens that a rectangle touches, which is the one
+    /// screen when it touches it.
+    public static ObservableList<Screen> getScreensForRectangle(double x, double y, double width, double height) {
+        ObservableList<Screen> list = FXCollections.observableArrayList();
+        if (PRIMARY.getBounds().intersects(x, y, width, height)) {
+            list.add(PRIMARY);
+        }
+        return list;
+    }
+
+    /// Returns the screens that a rectangle touches.
+    public static ObservableList<Screen> getScreensForRectangle(Rectangle2D r) {
+        return getScreensForRectangle(r.getMinX(), r.getMinY(), r.getWidth(), r.getHeight());
+    }
+
+    /// Returns the whole of the screen in logical pixels.
+    ///
+    /// At a desk that is the desktop the window is on, not the window: an
+    /// application sizes its stage as a share of the screen, and one that
+    /// was told its 800 by 600 window was the screen opened at a fraction
+    /// of the size it has on JavaFX. A port with no desktop to report
+    /// answers the display, which on a phone is the screen.
+    public final Rectangle2D getBounds() {
+        if (!Display.isInitialized()) {
+            return Rectangle2D.EMPTY;
+        }
+        com.codename1.ui.geom.Dimension size = Display.getInstance().getDesktopSize();
+        return new Rectangle2D(0, 0, Units.toLogical(size.getWidth()), Units.toLogical(size.getHeight()));
+    }
+
+    /// Returns the part of the screen an application can use, which is
+    /// all of what [#getBounds()] reports.
+    public final Rectangle2D getVisualBounds() {
+        return getBounds();
+    }
+
+    /// Returns the number of logical pixels to an inch, which is 96 by
+    /// the definition of a logical pixel here.
+    public final double getDpi() {
+        return 96;
+    }
+
+    /// Returns the number of device pixels in a logical pixel, across.
+    public final double getOutputScaleX() {
+        return Units.scale();
+    }
+
+    /// Returns the number of device pixels in a logical pixel, down.
+    public final double getOutputScaleY() {
+        return Units.scale();
+    }
+
+    @Override
+    public String toString() {
+        return "Screen[bounds = " + getBounds() + "]";
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/Stage.java b/maven/javafx-compat/src/main/java/javafx/stage/Stage.java
new file mode 100644
index 00000000000..f00e11d5df0
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/Stage.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+import com.codename1.ui.Display;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.scene.image.Image;
+import javafx.scene.Scene;
+
+/// The top level container of a JavaFX application.
+///
+/// The primary stage, the one handed to `Application.start`, is a
+/// Codename One form. A further stage is a desktop window where the
+/// device has those; elsewhere a modal stage is a Codename One dialog and
+/// any other a form shown on top of the previous one, with a back
+/// command that asks the stage to close.
+///
+/// Full screen, iconified and maximized are recorded and, where the
+/// stage is a desktop window, not otherwise acted on. The icons are
+/// recorded and not shown: the icon of an application is the one its
+/// Codename One project is built with.
+public class Stage extends Window {
+
+    private final StringProperty title = new SimpleStringProperty(this, "title", "");
+    private final BooleanProperty resizable = new SimpleBooleanProperty(this, "resizable", true);
+    private final BooleanProperty fullScreen = new SimpleBooleanProperty(this, "fullScreen", false);
+    private final ObjectProperty<String> fullScreenExitHint = new SimpleObjectProperty<String>(this,
+            "fullScreenExitHint");
+    private final BooleanProperty maximized =new SimpleBooleanProperty(this, "maximized", false);
+    private final BooleanProperty iconified = new SimpleBooleanProperty(this, "iconified", false);
+    private final BooleanProperty alwaysOnTop = new SimpleBooleanProperty(this, "alwaysOnTop", false);
+    private final ObservableList<Image> icons = FXCollections.observableArrayList();
+    private StageStyle style;
+    private Modality modality = Modality.NONE;
+    private Window owner;
+    private boolean primary;
+    private double minWidth;
+    private double minHeight;
+    private double maxWidth = Double.MAX_VALUE;
+    private double maxHeight = Double.MAX_VALUE;
+
+    /// Creates a decorated stage.
+    public Stage() {
+        this(StageStyle.DECORATED);
+    }
+
+    /// Creates a stage with a decoration.
+    public Stage(StageStyle style) {
+        this.style = style == null ? StageStyle.DECORATED : style;
+        ChangeListener<Object> push = new ChangeListener<Object>() {
+            @Override
+            public void changed(ObservableValue<? extends Object> observable, Object oldValue, Object newValue) {
+                if (cn1Host() != null) {
+                    cn1Host().stageChanged();
+                }
+            }
+        };
+        title.addListener(push);
+        resizable.addListener(push);
+        alwaysOnTop.addListener(push);
+    }
+
+    /// Marks this stage as the primary one; called by the lifecycle.
+    public final void cn1MarkPrimary() {
+        primary = true;
+    }
+
+    /// Returns whether this is the stage handed to `Application.start`.
+    public final boolean cn1IsPrimary() {
+        return primary;
+    }
+
+    @Override
+    public final void setScene(Scene value) {
+        super.setScene(value);
+    }
+
+    @Override
+    public final void show() {
+        super.show();
+    }
+
+    /// Shows the stage and returns once it is hidden again. Events keep
+    /// being handled meanwhile.
+    public void showAndWait() {
+        if (primary) {
+            throw new IllegalStateException("Cannot call this method on primary stage");
+        }
+        if (isShowing()) {
+            throw new IllegalStateException("Stage already visible");
+        }
+        if (Display.isInitialized() && !Display.getInstance().isEdt()) {
+            throw new IllegalStateException("Not on FX application thread");
+        }
+        cn1Show(true);
+    }
+
+    /// Closes the stage; the same as [#hide()].
+    public void close() {
+        hide();
+    }
+
+    /// Brings the stage in front of the others.
+    public void toFront() {
+        if (cn1Host() != null) {
+            cn1Host().toFront();
+        }
+    }
+
+    /// Sends the stage behind the others; not acted on.
+    public void toBack() {
+    }
+
+    /// Sets the decoration; before the stage is first shown.
+    public final void initStyle(StageStyle value) {
+        if (isShowing()) {
+            throw new IllegalStateException("Cannot set style once stage has been set visible");
+        }
+        style = value == null ? StageStyle.DECORATED : value;
+    }
+
+    /// Returns the decoration.
+    public final StageStyle getStyle() {
+        return style;
+    }
+
+    /// Sets what the stage blocks; before the stage is first shown.
+    public final void initModality(Modality value) {
+        if (isShowing()) {
+            throw new IllegalStateException("Cannot set modality once stage has been set visible");
+        }
+        if (primary) {
+            throw new IllegalStateException("Cannot set modality for the primary stage");
+        }
+        modality = value == null ? Modality.NONE : value;
+    }
+
+    /// Returns what the stage blocks.
+    public final Modality getModality() {
+        return modality;
+    }
+
+    /// Sets the window this stage belongs to; before it is first shown.
+    public final void initOwner(Window value) {
+        if (isShowing()) {
+            throw new IllegalStateException("Cannot set owner once stage has been set visible");
+        }
+        if (primary) {
+            throw new IllegalStateException("Cannot set owner for the primary stage");
+        }
+        owner = value;
+    }
+
+    /// Returns the window this stage belongs to, or `null`.
+    public final Window getOwner() {
+        return owner;
+    }
+
+    /// Returns the icons of the window. They are recorded; the icon shown
+    /// for the application is the one the project is built with.
+    public final ObservableList<Image> getIcons() {
+        return icons;
+    }
+
+    /// Returns the title.
+    public final String getTitle() {
+        return title.get();
+    }
+
+    /// Sets the title.
+    public final void setTitle(String value) {
+        title.set(value);
+    }
+
+    /// The title of the stage.
+    public final StringProperty titleProperty() {
+        return title;
+    }
+
+    /// Returns whether the user can resize the stage.
+    public final boolean isResizable() {
+        return resizable.get();
+    }
+
+    /// Sets whether the user can resize the stage.
+    public final void setResizable(boolean value) {
+        resizable.set(value);
+    }
+
+    /// Whether the user can resize the stage.
+    public final BooleanProperty resizableProperty() {
+        return resizable;
+    }
+
+    /// Returns whether full screen was asked for.
+    public final boolean isFullScreen() {
+        return fullScreen.get();
+    }
+
+    /// Asks for full screen.
+    public final void setFullScreen(boolean value) {
+        fullScreen.set(value);
+    }
+
+    /// Whether full screen was asked for.
+    public final BooleanProperty fullScreenProperty() {
+        return fullScreen;
+    }
+
+    /// Sets the words JavaFX shows as a stage enters full screen. They
+    /// are recorded and never shown: a stage here does not change into
+    /// full screen, so there is nothing to tell the user how to leave.
+    public final void setFullScreenExitHint(String value) {
+        fullScreenExitHint.set(value);
+    }
+
+    /// Returns the words set for entering full screen.
+    public final String getFullScreenExitHint() {
+        return fullScreenExitHint.get();
+    }
+
+    /// The words set for entering full screen.
+    public final ObjectProperty<String> fullScreenExitHintProperty() {
+        return fullScreenExitHint;
+    }
+
+    /// Returns whether the stage was asked to be maximized.
+    public final boolean isMaximized() {
+        return maximized.get();
+    }
+
+    /// Asks for the stage to be maximized.
+    public final void setMaximized(boolean value) {
+        maximized.set(value);
+    }
+
+    /// Whether the stage was asked to be maximized.
+    public final BooleanProperty maximizedProperty() {
+        return maximized;
+    }
+
+    /// Returns whether the stage was asked to be iconified.
+    public final boolean isIconified() {
+        return iconified.get();
+    }
+
+    /// Asks for the stage to be iconified.
+    public final void setIconified(boolean value) {
+        iconified.set(value);
+    }
+
+    /// Whether the stage was asked to be iconified.
+    public final BooleanProperty iconifiedProperty() {
+        return iconified;
+    }
+
+    /// Returns whether the stage stays above other windows.
+    public final boolean isAlwaysOnTop() {
+        return alwaysOnTop.get();
+    }
+
+    /// Sets whether the stage stays above other windows.
+    public final void setAlwaysOnTop(boolean value) {
+        alwaysOnTop.set(value);
+    }
+
+    /// Whether the stage stays above other windows.
+    public final BooleanProperty alwaysOnTopProperty() {
+        return alwaysOnTop;
+    }
+
+    /// Returns the smallest width the user can give the stage.
+    public final double getMinWidth() {
+        return minWidth;
+    }
+
+    /// Sets the smallest width the user can give the stage.
+    public final void setMinWidth(double value) {
+        minWidth = value;
+        if (cn1Host() != null) {
+            cn1Host().stageChanged();
+        }
+    }
+
+    /// Returns the smallest height the user can give the stage.
+    public final double getMinHeight() {
+        return minHeight;
+    }
+
+    /// Sets the smallest height the user can give the stage.
+    public final void setMinHeight(double value) {
+        minHeight = value;
+        if (cn1Host() != null) {
+            cn1Host().stageChanged();
+        }
+    }
+
+    /// Returns the largest width the user can give the stage.
+    public final double getMaxWidth() {
+        return maxWidth;
+    }
+
+    /// Sets the largest width; recorded, not enforced.
+    public final void setMaxWidth(double value) {
+        maxWidth = value;
+    }
+
+    /// Returns the largest height the user can give the stage.
+    public final double getMaxHeight() {
+        return maxHeight;
+    }
+
+    /// Sets the largest height; recorded, not enforced.
+    public final void setMaxHeight(double value) {
+        maxHeight = value;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/StageStyle.java b/maven/javafx-compat/src/main/java/javafx/stage/StageStyle.java
new file mode 100644
index 00000000000..54a5a831d58
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/StageStyle.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+/// The decoration of a stage. It is honoured where the stage is a desktop
+/// window; a stage shown as a form or a dialog has no decoration to
+/// choose.
+public enum StageStyle {
+    /// The platform's title bar and border.
+    DECORATED,
+    /// No decoration.
+    UNDECORATED,
+    /// No decoration; shown as undecorated, without transparency.
+    TRANSPARENT,
+    /// The decoration of a utility window.
+    UTILITY,
+    /// A decoration with a uniform colour; shown as decorated.
+    UNIFIED
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/Window.java b/maven/javafx-compat/src/main/java/javafx/stage/Window.java
new file mode 100644
index 00000000000..42c5d34a929
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/Window.java
@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+import com.codename1.fxcompat.runtime.EventHandlerManager;
+import com.codename1.fxcompat.runtime.StageHost;
+import com.codename1.fxcompat.runtime.StageHosts;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyDoubleProperty;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+
+/// A top level window that shows a scene.
+///
+/// What a window is on screen depends on the device; see
+/// `com.codename1.fxcompat.runtime.StageHosts`. Position and size are in
+/// logical pixels. They are requests: a window shown as a form always
+/// fills the screen, and its `x` and `y` stay 0.
+public class Window implements EventTarget {
+
+    private static final ObservableList<Window> WINDOWS = FXCollections.observableArrayList();
+    private static final ObservableList<Window> WINDOWS_VIEW = FXCollections.unmodifiableObservableList(WINDOWS);
+
+    private final ReadOnlyObjectWrapper<Scene> scene = new ReadOnlyObjectWrapper<Scene>(this, "scene");
+    private final ReadOnlyBooleanWrapper showing = new ReadOnlyBooleanWrapper(this, "showing", false);
+    private final ReadOnlyDoubleWrapper x = new ReadOnlyDoubleWrapper(this, "x", Double.NaN);
+    private final ReadOnlyDoubleWrapper y = new ReadOnlyDoubleWrapper(this, "y", Double.NaN);
+    private final ReadOnlyDoubleWrapper width = new ReadOnlyDoubleWrapper(this, "width", Double.NaN);
+    private final ReadOnlyDoubleWrapper height = new ReadOnlyDoubleWrapper(this, "height", Double.NaN);
+    private final EventHandlerManager events = new EventHandlerManager(this);
+    private ObservableMap<Object, Object> properties;
+    private Object userData;
+    private StageHost host;
+    private boolean embedded;
+
+    /// Creates a window.
+    protected Window() {
+    }
+
+    /// Returns the windows that are showing.
+    public static ObservableList<Window> getWindows() {
+        return WINDOWS_VIEW;
+    }
+
+    // ------------------------------------------------------------ scene
+
+    /// Returns the scene shown in this window.
+    public final Scene getScene() {
+        return scene.get();
+    }
+
+    /// The scene shown in this window.
+    public final ReadOnlyObjectProperty<Scene> sceneProperty() {
+        return scene.getReadOnlyProperty();
+    }
+
+    /// Sets the scene shown in this window.
+    protected void setScene(Scene value) {
+        Scene old = scene.get();
+        if (old == value) {
+            return;
+        }
+        if (value != null && value.getWindow() != null && value.getWindow() != this) {
+            Window other = value.getWindow();
+            other.setScene(null);
+        }
+        scene.set(value);
+        if (host != null) {
+            if (old != null) {
+                old.cn1SetHost(null, null);
+            }
+            host.sceneChanged();
+        }
+    }
+
+    // --------------------------------------------------------- geometry
+
+    /// Returns the x of the window on the screen.
+    public final double getX() {
+        return x.get();
+    }
+
+    /// Asks for an x on the screen.
+    public final void setX(double value) {
+        x.set(value);
+        if (host != null) {
+            host.boundsRequested();
+        }
+    }
+
+    /// The x of the window on the screen.
+    public final ReadOnlyDoubleProperty xProperty() {
+        return x.getReadOnlyProperty();
+    }
+
+    /// Returns the y of the window on the screen.
+    public final double getY() {
+        return y.get();
+    }
+
+    /// Asks for a y on the screen.
+    public final void setY(double value) {
+        y.set(value);
+        if (host != null) {
+            host.boundsRequested();
+        }
+    }
+
+    /// The y of the window on the screen.
+    public final ReadOnlyDoubleProperty yProperty() {
+        return y.getReadOnlyProperty();
+    }
+
+    /// Returns the width of the window.
+    public final double getWidth() {
+        return width.get();
+    }
+
+    /// Asks for a width.
+    public final void setWidth(double value) {
+        width.set(value);
+        if (host != null) {
+            host.boundsRequested();
+        }
+    }
+
+    /// The width of the window.
+    public final ReadOnlyDoubleProperty widthProperty() {
+        return width.getReadOnlyProperty();
+    }
+
+    /// Returns the height of the window.
+    public final double getHeight() {
+        return height.get();
+    }
+
+    /// Asks for a height.
+    public final void setHeight(double value) {
+        height.set(value);
+        if (host != null) {
+            host.boundsRequested();
+        }
+    }
+
+    /// The height of the window.
+    public final ReadOnlyDoubleProperty heightProperty() {
+        return height.getReadOnlyProperty();
+    }
+
+    /// Sizes the window to the preferred size of its scene, where a
+    /// window can be sized.
+    public void sizeToScene() {
+        width.set(Double.NaN);
+        height.set(Double.NaN);
+        if (host != null) {
+            host.boundsRequested();
+        }
+    }
+
+    /// Centres the window on the screen, where a window can be moved.
+    public void centerOnScreen() {
+        x.set(Double.NaN);
+        y.set(Double.NaN);
+        if (host != null) {
+            host.boundsRequested();
+        }
+    }
+
+    /// Records the bounds the window really has; called by its host.
+    public final void cn1Bounds(double newX, double newY, double newWidth, double newHeight) {
+        x.set(newX);
+        y.set(newY);
+        width.set(newWidth);
+        height.set(newHeight);
+    }
+
+    // ---------------------------------------------------------- showing
+
+    /// Returns whether the window is showing.
+    public final boolean isShowing() {
+        return showing.get();
+    }
+
+    /// Whether the window is showing.
+    public final ReadOnlyBooleanProperty showingProperty() {
+        return showing.getReadOnlyProperty();
+    }
+
+    /// Returns what shows this window, or `null` while it is hidden.
+    public final StageHost cn1Host() {
+        return host;
+    }
+
+    /// Puts the window inside a host its caller owns, for good: a
+    /// Codename One component that shows a scene inside a form of the
+    /// application (see `com.codename1.fxcompat.FxInterop`).
+    ///
+    /// Such a window is showing from here on and is not one of the
+    /// application's windows: [#getWindows()] does not list it, hiding it
+    /// does nothing, and it never counts as the last window closing. The
+    /// component that hosts it is what comes and goes.
+    public final void cn1Embed(StageHost value) {
+        embedded = true;
+        host = value;
+        showing.set(true);
+        value.sceneChanged();
+    }
+
+    /// Whether [#cn1Embed] put this window inside a component.
+    public final boolean cn1Embedded() {
+        return embedded;
+    }
+
+    /// Shows the window.
+    protected void show() {
+        cn1Show(false);
+    }
+
+    /// Shows the window, and with `block` returns only once it is hidden
+    /// again while events keep being handled.
+    protected final void cn1Show(boolean block) {
+        if (showing.get() || embedded) {
+            return;
+        }
+        fireEvent(new WindowEvent(this, WindowEvent.WINDOW_SHOWING));
+        Scene shown = getScene();
+        Node chosen = shown == null ? null : shown.getFocusOwner();
+        host = StageHosts.create(this);
+        showing.set(true);
+        WINDOWS.add(this);
+        host.sceneChanged();
+        host.open();
+        // A window that takes the keyboard starts with the focus on its
+        // first control. A popup does not take the keyboard from its owner.
+        if (shown != null && shown == getScene() && !(this instanceof PopupWindow)) {
+            shown.cn1FocusInitial(chosen);
+        }
+        fireEvent(new WindowEvent(this, WindowEvent.WINDOW_SHOWN));
+        if (block && host != null) {
+            host.block();
+        }
+    }
+
+    /// Hides the window.
+    public void hide() {
+        if (!showing.get() || embedded) {
+            return;
+        }
+        fireEvent(new WindowEvent(this, WindowEvent.WINDOW_HIDING));
+        StageHost closing = host;
+        host = null;
+        showing.set(false);
+        WINDOWS.remove(this);
+        Scene s = getScene();
+        if (s != null) {
+            s.cn1SetHost(null, null);
+        }
+        if (closing != null) {
+            closing.close();
+        }
+        fireEvent(new WindowEvent(this, WindowEvent.WINDOW_HIDDEN));
+        // A popup going away is never the application's last window closing.
+        if (WINDOWS.isEmpty() && !(this instanceof PopupWindow)) {
+            StageHosts.lastWindowHidden();
+        }
+    }
+
+    /// The user asked to close the window, through the platform's close
+    /// control or the back command: fires `WINDOW_CLOSE_REQUEST` and
+    /// hides the window unless a handler consumed it. Answers whether the
+    /// window was hidden.
+    public final boolean cn1CloseRequested() {
+        WindowEvent request = new WindowEvent(this, WindowEvent.WINDOW_CLOSE_REQUEST);
+        fireEvent(request);
+        if (request.isConsumed()) {
+            return false;
+        }
+        hide();
+        return true;
+    }
+
+    /// Asks for the input focus.
+    public final void requestFocus() {
+        if (host != null) {
+            host.toFront();
+        }
+    }
+
+    /// Returns the application's own object attached to this window.
+    public Object getUserData() {
+        return userData;
+    }
+
+    /// Attaches an object of the application to this window.
+    public void setUserData(Object value) {
+        userData = value;
+    }
+
+    /// Returns a map for the application's own values on this window.
+    public final ObservableMap<Object, Object> getProperties() {
+        if (properties == null) {
+            properties = FXCollections.observableHashMap();
+        }
+        return properties;
+    }
+
+    /// Returns whether [#getProperties()] holds anything.
+    public boolean hasProperties() {
+        return properties != null && !properties.isEmpty();
+    }
+
+    // ----------------------------------------------------------- events
+
+    /// Adds a handler called in the bubbling phase.
+    public final <T extends Event> void addEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        events.addEventHandler(eventType, eventHandler);
+    }
+
+    /// Removes a handler.
+    public final <T extends Event> void removeEventHandler(EventType<T> eventType,
+            EventHandler<? super T> eventHandler) {
+        events.removeEventHandler(eventType, eventHandler);
+    }
+
+    /// Adds a filter called in the capturing phase.
+    public final <T extends Event> void addEventFilter(EventType<T> eventType,
+            EventHandler<? super T> eventFilter) {
+        events.addEventFilter(eventType, eventFilter);
+    }
+
+    /// Removes a filter.
+    public final <T extends Event> void removeEventFilter(EventType<T> eventType,
+            EventHandler<? super T> eventFilter) {
+        events.removeEventFilter(eventType, eventFilter);
+    }
+
+    /// Delivers an event to this window.
+    public final void fireEvent(Event event) {
+        Event.fireEvent(this, event);
+    }
+
+    @Override
+    public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+        return tail.prepend(events);
+    }
+
+    /// Sets the handler of the user asking to close the window.
+    public final void setOnCloseRequest(EventHandler<WindowEvent> value) {
+        events.setSlot(WindowEvent.WINDOW_CLOSE_REQUEST, "onCloseRequest", value);
+    }
+
+    /// Returns the handler of the user asking to close the window.
+    public final EventHandler<? super WindowEvent> getOnCloseRequest() {
+        return events.getSlot(WindowEvent.WINDOW_CLOSE_REQUEST);
+    }
+
+    /// The handler of the user asking to close the window.
+    public final ObjectProperty<EventHandler<? super WindowEvent>> onCloseRequestProperty() {
+        return events.slot(WindowEvent.WINDOW_CLOSE_REQUEST, "onCloseRequest");
+    }
+
+    /// Sets the handler called before the window is shown.
+    public final void setOnShowing(EventHandler<WindowEvent> value) {
+        events.setSlot(WindowEvent.WINDOW_SHOWING, "onShowing", value);
+    }
+
+    /// Returns the handler called before the window is shown.
+    public final EventHandler<? super WindowEvent> getOnShowing() {
+        return events.getSlot(WindowEvent.WINDOW_SHOWING);
+    }
+
+    /// Sets the handler called after the window was shown.
+    public final void setOnShown(EventHandler<WindowEvent> value) {
+        events.setSlot(WindowEvent.WINDOW_SHOWN, "onShown", value);
+    }
+
+    /// Returns the handler called after the window was shown.
+    public final EventHandler<? super WindowEvent> getOnShown() {
+        return events.getSlot(WindowEvent.WINDOW_SHOWN);
+    }
+
+    /// Sets the handler called before the window is hidden.
+    public final void setOnHiding(EventHandler<WindowEvent> value) {
+        events.setSlot(WindowEvent.WINDOW_HIDING, "onHiding", value);
+    }
+
+    /// Returns the handler called before the window is hidden.
+    public final EventHandler<? super WindowEvent> getOnHiding() {
+        return events.getSlot(WindowEvent.WINDOW_HIDING);
+    }
+
+    /// Sets the handler called after the window was hidden.
+    public final void setOnHidden(EventHandler<WindowEvent> value) {
+        events.setSlot(WindowEvent.WINDOW_HIDDEN, "onHidden", value);
+    }
+
+    /// Returns the handler called after the window was hidden.
+    public final EventHandler<? super WindowEvent> getOnHidden() {
+        return events.getSlot(WindowEvent.WINDOW_HIDDEN);
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/WindowEvent.java b/maven/javafx-compat/src/main/java/javafx/stage/WindowEvent.java
new file mode 100644
index 00000000000..4368d6b2b71
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/WindowEvent.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.stage;
+
+import javafx.beans.NamedArg;
+import javafx.event.Event;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+
+/// A window is being shown or hidden, or the user asked to close it.
+public class WindowEvent extends Event {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Every window event.
+    public static final EventType<WindowEvent> ANY = new EventType<WindowEvent>(Event.ANY, "WINDOW");
+
+    /// The window is about to be shown.
+    public static final EventType<WindowEvent> WINDOW_SHOWING = new EventType<WindowEvent>(ANY, "WINDOW_SHOWING");
+
+    /// The window was shown.
+    public static final EventType<WindowEvent> WINDOW_SHOWN = new EventType<WindowEvent>(ANY, "WINDOW_SHOWN");
+
+    /// The window is about to be hidden.
+    public static final EventType<WindowEvent> WINDOW_HIDING = new EventType<WindowEvent>(ANY, "WINDOW_HIDING");
+
+    /// The window was hidden.
+    public static final EventType<WindowEvent> WINDOW_HIDDEN = new EventType<WindowEvent>(ANY, "WINDOW_HIDDEN");
+
+    /// The user asked to close the window; consuming the event keeps it
+    /// open.
+    public static final EventType<WindowEvent> WINDOW_CLOSE_REQUEST = new EventType<WindowEvent>(ANY,
+            "WINDOW_CLOSE_REQUEST");
+
+    /// Creates a window event.
+    public WindowEvent(@NamedArg("source") Window source, @NamedArg("eventType") EventType<? extends Event> eventType) {
+        super(source, source, eventType);
+    }
+
+    @Override
+    public WindowEvent copyFor(Object newSource, EventTarget newTarget) {
+        Event copy = super.copyFor(newSource, newTarget);
+        return copy instanceof WindowEvent ? (WindowEvent) copy : this;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public EventType<WindowEvent> getEventType() {
+        return (EventType<WindowEvent>) super.getEventType();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/stage/package-info.java b/maven/javafx-compat/src/main/java/javafx/stage/package-info.java
new file mode 100644
index 00000000000..891073968db
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/stage/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Windows: the stage that shows a scene, its modality and decoration,
+/// and the events of a window opening and closing.
+package javafx.stage;
diff --git a/maven/javafx-compat/src/main/java/javafx/util/Callback.java b/maven/javafx-compat/src/main/java/javafx/util/Callback.java
new file mode 100644
index 00000000000..7cf2b88012a
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/Callback.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util;
+
+/// A function of one argument, used wherever the API asks the application
+/// to produce something on demand.
+@FunctionalInterface
+public interface Callback<P, R> {
+
+    /// Computes the result for an argument.
+    R call(P param);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/Duration.java b/maven/javafx-compat/src/main/java/javafx/util/Duration.java
new file mode 100644
index 00000000000..8b0e128f16c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/Duration.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util;
+
+import java.io.Serializable;
+
+import javafx.beans.NamedArg;
+
+/// An immutable length of time, kept in milliseconds. It may be negative,
+/// [#INDEFINITE] (infinitely long) or [#UNKNOWN] (not a number).
+public class Duration implements Comparable<Duration>, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /// No time at all.
+    public static final Duration ZERO = new Duration(0);
+
+    /// One millisecond.
+    public static final Duration ONE = new Duration(1);
+
+    /// An infinitely long time.
+    public static final Duration INDEFINITE = new Duration(Double.POSITIVE_INFINITY);
+
+    /// A time that is not known.
+    public static final Duration UNKNOWN = new Duration(Double.NaN);
+
+    private final double millis;
+
+    /// Creates a duration of a number of milliseconds.
+    public Duration(@NamedArg("millis") double millis) {
+        this.millis = millis;
+    }
+
+    /// Parses a number followed directly by a unit: `ms`, `s`, `m` or `h`,
+    /// in either case. `"1.5s"` is one and a half seconds.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when the text is not such a value
+    public static Duration valueOf(String time) {
+        if (time == null) {
+            throw new NullPointerException("time");
+        }
+        // The number is digits, '.' and '-' and ends at the first other
+        // character, as in OpenJFX, whose valueOf rejects "+2s" and "1e3ms"
+        // too (checked against javafx-base 23): a sign or an exponent is
+        // read as the start of the unit. Accepting them would let a value
+        // through here that the real JavaFX refuses.
+        int split = -1;
+        for (int i = 0; i < time.length(); i++) {
+            char c = time.charAt(i);
+            if (!(c >= '0' && c <= '9') && c != '.' && c != '-') {
+                split = i;
+                break;
+            }
+        }
+        if (split == -1) {
+            throw new IllegalArgumentException("The time parameter must have a suffix of [ms|s|m|h]");
+        }
+        double value;
+        try {
+            value = Double.parseDouble(time.substring(0, split));
+        } catch (NumberFormatException malformed) {
+            throw new IllegalArgumentException("The time parameter must be a number followed by [ms|s|m|h]");
+        }
+        // Units are ASCII by definition, so they are folded by hand: the
+        // locale sensitive String.toLowerCase() would turn "S" into something
+        // else on a Turkish device.
+        String unit = asciiLower(time.substring(split));
+        if ("ms".equals(unit)) {
+            return millis(value);
+        }
+        if ("s".equals(unit)) {
+            return seconds(value);
+        }
+        if ("m".equals(unit)) {
+            return minutes(value);
+        }
+        if ("h".equals(unit)) {
+            return hours(value);
+        }
+        throw new IllegalArgumentException("The time parameter must have a suffix of [ms|s|m|h]");
+    }
+
+    private static String asciiLower(String text) {
+        StringBuilder result = new StringBuilder(text.length());
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            result.append(c >= 'A' && c <= 'Z' ? (char) (c + ('a' - 'A')) : c);
+        }
+        return result.toString();
+    }
+
+    /// Returns a duration of a number of milliseconds.
+    public static Duration millis(double ms) {
+        if (ms == 0) {
+            return ZERO;
+        }
+        if (ms == 1) {
+            return ONE;
+        }
+        if (ms == Double.POSITIVE_INFINITY) {
+            return INDEFINITE;
+        }
+        if (Double.isNaN(ms)) {
+            return UNKNOWN;
+        }
+        return new Duration(ms);
+    }
+
+    /// Returns a duration of a number of seconds.
+    public static Duration seconds(double s) {
+        return millis(s * 1000.0);
+    }
+
+    /// Returns a duration of a number of minutes.
+    public static Duration minutes(double m) {
+        return millis(m * (1000.0 * 60.0));
+    }
+
+    /// Returns a duration of a number of hours.
+    public static Duration hours(double h) {
+        return millis(h * (1000.0 * 60.0 * 60.0));
+    }
+
+    /// Returns the length in milliseconds.
+    public double toMillis() {
+        return millis;
+    }
+
+    /// Returns the length in seconds.
+    public double toSeconds() {
+        return millis / 1000.0;
+    }
+
+    /// Returns the length in minutes.
+    public double toMinutes() {
+        return millis / (60 * 1000.0);
+    }
+
+    /// Returns the length in hours.
+    public double toHours() {
+        return millis / (60 * 60 * 1000.0);
+    }
+
+    /// Returns the sum of this duration and another.
+    public Duration add(Duration other) {
+        return millis(millis + other.millis);
+    }
+
+    /// Returns this duration less another.
+    public Duration subtract(Duration other) {
+        return millis(millis - other.millis);
+    }
+
+    /// Returns the product of the two lengths in milliseconds.
+    ///
+    /// #### Deprecated
+    ///
+    /// Multiplying two durations has no meaning; use [#multiply(double)].
+    @Deprecated
+    public Duration multiply(Duration other) {
+        return millis(millis * other.millis);
+    }
+
+    /// Returns this duration scaled by a factor.
+    public Duration multiply(double n) {
+        return millis(millis * n);
+    }
+
+    /// Returns this duration divided by a number.
+    public Duration divide(double n) {
+        return millis(millis / n);
+    }
+
+    /// Returns the quotient of the two lengths in milliseconds.
+    ///
+    /// #### Deprecated
+    ///
+    /// The result is not a duration; divide [#toMillis()] values instead.
+    @Deprecated
+    public Duration divide(Duration other) {
+        return millis(millis / other.millis);
+    }
+
+    /// Returns the duration of the same length and opposite sign.
+    public Duration negate() {
+        return millis(-millis);
+    }
+
+    /// Returns whether this is infinitely long.
+    public boolean isIndefinite() {
+        return millis == Double.POSITIVE_INFINITY;
+    }
+
+    /// Returns whether the length is not a number.
+    public boolean isUnknown() {
+        return Double.isNaN(millis);
+    }
+
+    /// Returns whether this is shorter than another duration.
+    public boolean lessThan(Duration other) {
+        return millis < other.millis;
+    }
+
+    /// Returns whether this is not longer than another duration.
+    public boolean lessThanOrEqualTo(Duration other) {
+        return millis <= other.millis;
+    }
+
+    /// Returns whether this is longer than another duration.
+    public boolean greaterThan(Duration other) {
+        return millis > other.millis;
+    }
+
+    /// Returns whether this is not shorter than another duration.
+    public boolean greaterThanOrEqualTo(Duration other) {
+        return millis >= other.millis;
+    }
+
+    /// Returns `INDEFINITE`, `UNKNOWN` or the milliseconds followed by
+    /// ` ms`.
+    @Override
+    public String toString() {
+        return isIndefinite() ? "INDEFINITE" : (isUnknown() ? "UNKNOWN" : millis + " ms");
+    }
+
+    @Override
+    public int compareTo(Duration d) {
+        return Double.compare(millis, d.millis);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        return obj instanceof Duration && Double.compare(((Duration) obj).millis, millis) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(millis);
+        return (int) (bits ^ (bits >>> 32));
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/Pair.java b/maven/javafx-compat/src/main/java/javafx/util/Pair.java
new file mode 100644
index 00000000000..f000698a7e7
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/Pair.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util;
+
+import java.io.Serializable;
+
+import javafx.beans.NamedArg;
+
+/// An immutable key and value.
+public class Pair<K, V> implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final K key;
+    private final V value;
+
+    /// Creates a pair.
+    public Pair(@NamedArg("key") K key, @NamedArg("value") V value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    /// Returns the key.
+    public K getKey() {
+        return key;
+    }
+
+    /// Returns the value.
+    public V getValue() {
+        return value;
+    }
+
+    /// Returns the pair as `key=value`.
+    @Override
+    public String toString() {
+        return key + "=" + value;
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 * (key == null ? 0 : key.hashCode()) + (value == null ? 0 : value.hashCode());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o instanceof Pair) {
+            Pair<?, ?> other = (Pair<?, ?>) o;
+            return (key == null ? other.key == null : key.equals(other.key))
+                    && (value == null ? other.value == null : value.equals(other.value));
+        }
+        return false;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/StringConverter.java b/maven/javafx-compat/src/main/java/javafx/util/StringConverter.java
new file mode 100644
index 00000000000..e6bbf4dfa5c
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/StringConverter.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util;
+
+/// Converts between objects of one type and their text.
+public abstract class StringConverter<T> {
+
+    /// Creates the converter.
+    public StringConverter() {
+    }
+
+    /// Returns the text of an object.
+    public abstract String toString(T object);
+
+    /// Returns the object a text stands for.
+    public abstract T fromString(String string);
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/converter/BooleanStringConverter.java b/maven/javafx-compat/src/main/java/javafx/util/converter/BooleanStringConverter.java
new file mode 100644
index 00000000000..5bdb8b80438
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/converter/BooleanStringConverter.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util.converter;
+
+import javafx.util.StringConverter;
+
+/// Converts between `Boolean` and `"true"` or `"false"`. Parsing ignores
+/// surrounding blanks and case; empty text is `null`, anything but `true`
+/// is `false`.
+public class BooleanStringConverter extends StringConverter<Boolean> {
+
+    /// Creates the converter.
+    public BooleanStringConverter() {
+    }
+
+    @Override
+    public Boolean fromString(String value) {
+        if (value == null) {
+            return null;
+        }
+        String text = value.trim();
+        if (text.length() < 1) {
+            return null;
+        }
+        return Boolean.valueOf("true".equalsIgnoreCase(text));
+    }
+
+    @Override
+    public String toString(Boolean value) {
+        if (value == null) {
+            return "";
+        }
+        return value.toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/converter/DefaultStringConverter.java b/maven/javafx-compat/src/main/java/javafx/util/converter/DefaultStringConverter.java
new file mode 100644
index 00000000000..99f83c08cce
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/converter/DefaultStringConverter.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util.converter;
+
+import javafx.util.StringConverter;
+
+/// Converts a string to itself; `null` becomes the empty string when
+/// formatted and stays `null` when parsed.
+public class DefaultStringConverter extends StringConverter<String> {
+
+    /// Creates the converter.
+    public DefaultStringConverter() {
+    }
+
+    @Override
+    public String toString(String value) {
+        return value != null ? value : "";
+    }
+
+    @Override
+    public String fromString(String value) {
+        return value;
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/converter/DoubleStringConverter.java b/maven/javafx-compat/src/main/java/javafx/util/converter/DoubleStringConverter.java
new file mode 100644
index 00000000000..2eac8efec53
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/converter/DoubleStringConverter.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util.converter;
+
+import javafx.util.StringConverter;
+
+/// Converts between `Double` and the text `Double.toString` produces.
+/// Parsing ignores surrounding blanks, turns empty text into `null` and
+/// throws `NumberFormatException` for anything else that is not a number.
+public class DoubleStringConverter extends StringConverter<Double> {
+
+    /// Creates the converter.
+    public DoubleStringConverter() {
+    }
+
+    @Override
+    public Double fromString(String value) {
+        if (value == null) {
+            return null;
+        }
+        String text = value.trim();
+        if (text.length() < 1) {
+            return null;
+        }
+        return Double.valueOf(text);
+    }
+
+    @Override
+    public String toString(Double value) {
+        if (value == null) {
+            return "";
+        }
+        return Double.toString(value.doubleValue());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/converter/IntegerStringConverter.java b/maven/javafx-compat/src/main/java/javafx/util/converter/IntegerStringConverter.java
new file mode 100644
index 00000000000..35a35a081ec
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/converter/IntegerStringConverter.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util.converter;
+
+import javafx.util.StringConverter;
+
+/// Converts between `Integer` and its decimal text. Parsing ignores
+/// surrounding blanks, turns empty text into `null` and throws
+/// `NumberFormatException` for anything else that is not an integer.
+public class IntegerStringConverter extends StringConverter<Integer> {
+
+    /// Creates the converter.
+    public IntegerStringConverter() {
+    }
+
+    @Override
+    public Integer fromString(String value) {
+        if (value == null) {
+            return null;
+        }
+        String text = value.trim();
+        if (text.length() < 1) {
+            return null;
+        }
+        return Integer.valueOf(text);
+    }
+
+    @Override
+    public String toString(Integer value) {
+        if (value == null) {
+            return "";
+        }
+        return Integer.toString(value.intValue());
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/converter/NumberStringConverter.java b/maven/javafx-compat/src/main/java/javafx/util/converter/NumberStringConverter.java
new file mode 100644
index 00000000000..8961cb91f8f
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/converter/NumberStringConverter.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package javafx.util.converter;
+
+import javafx.util.StringConverter;
+
+/// Converts between `Number` and its text.
+///
+/// Numbers are written the way the default number format of an English
+/// locale writes them, on every device: digits grouped in threes with a
+/// comma, a dot before the fraction, at most three fraction digits rounded
+/// half to even, and no trailing zeros. Parsing accepts the same form and
+/// returns a `Long` for a whole number and a `Double` otherwise.
+public class NumberStringConverter extends StringConverter<Number> {
+
+    /// Creates the converter.
+    public NumberStringConverter() {
+    }
+
+    /// Parses a number. Surrounding blanks are ignored and empty text is
+    /// `null`.
+    ///
+    /// #### Throws
+    ///
+    /// - `RuntimeException`: when the text is not a number
+    @Override
+    public Number fromString(String value) {
+        if (value == null) {
+            return null;
+        }
+        String text = value.trim();
+        if (text.length() < 1) {
+            return null;
+        }
+        StringBuilder plain = new StringBuilder(text.length());
+        boolean fraction = false;
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == ',' && !fraction) {
+                continue;
+            }
+            if (c == '.' || c == 'e' || c == 'E') {
+                fraction = true;
+            }
+            plain.append(c);
+        }
+        try {
+            if (!fraction) {
+                return Long.valueOf(Long.parseLong(plain.toString()));
+            }
+            double parsed = Double.parseDouble(plain.toString());
+            if (parsed == Math.floor(parsed) && Math.abs(parsed) < 9.0e18) {
+                return Long.valueOf((long) parsed);
+            }
+            return Double.valueOf(parsed);
+        } catch (NumberFormatException malformed) {
+            throw new RuntimeException("Unparseable number: \"" + value + "\"", malformed);
+        }
+    }
+
+    @Override
+    public String toString(Number value) {
+        if (value == null) {
+            return "";
+        }
+        if (value instanceof Integer || value instanceof Long || value instanceof Short || value instanceof Byte) {
+            long whole = value.longValue();
+            if (whole == Long.MIN_VALUE) {
+                return "-9,223,372,036,854,775,808";
+            }
+            return (whole < 0 ? "-" : "") + group(Long.toString(Math.abs(whole)));
+        }
+        double number = value.doubleValue();
+        if (Double.isNaN(number)) {
+            return "NaN";
+        }
+        if (Double.isInfinite(number)) {
+            return number > 0 ? "Infinity" : "-Infinity";
+        }
+        double magnitude = Math.abs(number);
+        if (magnitude >= 9.0e15) {
+            // Beyond this a double has no fraction digits left to print.
+            return (number < 0 ? "-" : "") + group(plainDigits(magnitude));
+        }
+        long whole = (long) Math.floor(magnitude);
+        long thousandths = roundHalfEven((magnitude - whole) * 1000.0);
+        if (thousandths == 1000) {
+            whole++;
+            thousandths = 0;
+        }
+        StringBuilder result = new StringBuilder();
+        if (number < 0 && (whole != 0 || thousandths != 0)) {
+            result.append('-');
+        }
+        result.append(group(Long.toString(whole)));
+        if (thousandths != 0) {
+            String digits = Long.toString(thousandths);
+            while (digits.length() < 3) {
+                digits = "0" + digits;
+            }
+            int end = digits.length();
+            while (digits.charAt(end - 1) == '0') {
+                end--;
+            }
+            result.append('.').append(digits.substring(0, end));
+        }
+        return result.toString();
+    }
+
+    private static long roundHalfEven(double value) {
+        double floor = Math.floor(value);
+        double rest = value - floor;
+        long result = (long) floor;
+        if (rest > 0.5 || (rest == 0.5 && (result & 1) == 1)) {
+            result++;
+        }
+        return result;
+    }
+
+    /// The digits of a whole number too large for a `long`.
+    private static String plainDigits(double magnitude) {
+        if (magnitude < 9.0e18) {
+            return Long.toString((long) magnitude);
+        }
+        StringBuilder digits = new StringBuilder();
+        double rest = magnitude;
+        while (rest >= 1.0) {
+            double tenth = Math.floor(rest / 10.0);
+            digits.insert(0, (char) ('0' + (int) (rest - tenth * 10.0)));
+            rest = tenth;
+        }
+        return digits.toString();
+    }
+
+    private static String group(String digits) {
+        StringBuilder result = new StringBuilder(digits.length() + digits.length() / 3);
+        int lead = digits.length() % 3;
+        for (int i = 0; i < digits.length(); i++) {
+            if (i > 0 && (i - lead) % 3 == 0) {
+                result.append(',');
+            }
+            result.append(digits.charAt(i));
+        }
+        return result.toString();
+    }
+}
diff --git a/maven/javafx-compat/src/main/java/javafx/util/converter/package-info.java b/maven/javafx-compat/src/main/java/javafx/util/converter/package-info.java
new file mode 100644
index 00000000000..7d1c2d0a114
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/converter/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The standard string converters for text, booleans and numbers.
+package javafx.util.converter;
diff --git a/maven/javafx-compat/src/main/java/javafx/util/package-info.java b/maven/javafx-compat/src/main/java/javafx/util/package-info.java
new file mode 100644
index 00000000000..c3d093a9d6d
--- /dev/null
+++ b/maven/javafx-compat/src/main/java/javafx/util/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Small general purpose types used across the API: callbacks, pairs,
+/// durations and string converters.
+package javafx.util;
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/AnimationTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/AnimationTest.java
new file mode 100644
index 00000000000..f63d921b708
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/AnimationTest.java
@@ -0,0 +1,992 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.FrameClock;
+
+import javafx.animation.Animation;
+import javafx.animation.AnimationTimer;
+import javafx.animation.FadeTransition;
+import javafx.animation.Interpolatable;
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.ParallelTransition;
+import javafx.animation.PauseTransition;
+import javafx.animation.RotateTransition;
+import javafx.animation.ScaleTransition;
+import javafx.animation.SequentialTransition;
+import javafx.animation.Timeline;
+import javafx.animation.Transition;
+import javafx.animation.TranslateTransition;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.layout.Region;
+import javafx.util.Duration;
+
+/// Animation on the manual frame clock: every test states the time of
+/// each frame, so the values it expects are exact and nothing sleeps.
+public class AnimationTest {
+
+    private static final double EXACT = 1e-9;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> log = new ArrayList<String>();
+
+    @BeforeClass
+    public static void display() {
+        HeadlessImplementation.install();
+    }
+
+    @Before
+    public void setUp() {
+        FrameClock.reset();
+        FrameClock.setManual(true);
+    }
+
+    @After
+    public void tearDown() {
+        FrameClock.reset();
+    }
+
+    private static Duration ms(double millis) {
+        return Duration.millis(millis);
+    }
+
+    private EventHandler<ActionEvent> note(final String what) {
+        return new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                log.add(what);
+            }
+        };
+    }
+
+    private static Timeline line(DoubleProperty x, double to, double millis) {
+        return new Timeline(new KeyFrame(ms(millis), new KeyValue(x, to)));
+    }
+
+    // ---- interpolators ----
+
+    @Test
+    public void interpolatorCurves() {
+        assertEquals(25.0, Interpolator.LINEAR.interpolate(0.0, 100.0, 0.25), EXACT);
+        assertEquals(0.0, Interpolator.EASE_BOTH.interpolate(0.0, 1.0, 0.0), EXACT);
+        assertEquals(1.0, Interpolator.EASE_BOTH.interpolate(0.0, 1.0, 1.0), EXACT);
+        assertEquals(0.5, Interpolator.EASE_BOTH.interpolate(0.0, 1.0, 0.5), EXACT);
+        // Accelerating: 3.125 t^2 over the first fifth.
+        assertEquals(0.03125, Interpolator.EASE_BOTH.interpolate(0.0, 1.0, 0.1), EXACT);
+        assertEquals(0.96875, Interpolator.EASE_BOTH.interpolate(0.0, 1.0, 0.9), EXACT);
+        // The two parts meet at the same value.
+        assertEquals(0.125, Interpolator.EASE_BOTH.interpolate(0.0, 1.0, 0.2), EXACT);
+        assertEquals(25.0 / 900.0, Interpolator.EASE_IN.interpolate(0.0, 1.0, 0.1), EXACT);
+        assertEquals(1.0, Interpolator.EASE_IN.interpolate(0.0, 1.0, 1.0), EXACT);
+        assertEquals(5.0 / 9.0, Interpolator.EASE_OUT.interpolate(0.0, 1.0, 0.5), EXACT);
+        assertEquals(1.0, Interpolator.EASE_OUT.interpolate(0.0, 1.0, 1.0), EXACT);
+        assertEquals(0.0, Interpolator.DISCRETE.interpolate(0.0, 1.0, 0.999), EXACT);
+        assertEquals(1.0, Interpolator.DISCRETE.interpolate(0.0, 1.0, 1.0), EXACT);
+    }
+
+    @Test
+    public void splineMidpointByHand() {
+        // x(s) = 3(1-s)^2 s x1 + 3(1-s) s^2 x2 + s^3. With x1 + x2 = 1 the
+        // curve is at x = 0.5 for s = 0.5: 3/8 * 1 + 1/8. There
+        // y = 3/8 * (0.2 + 0.4) + 1/8 = 0.35.
+        Interpolator spline = Interpolator.SPLINE(0.3, 0.2, 0.7, 0.4);
+        assertEquals(0.35, spline.interpolate(0.0, 1.0, 0.5), 1e-9);
+        assertEquals(0.0, spline.interpolate(0.0, 1.0, 0.0), 1e-9);
+        assertEquals(1.0, spline.interpolate(0.0, 1.0, 1.0), 1e-9);
+        try {
+            Interpolator.SPLINE(1.5, 0, 0, 0);
+            fail("a control point outside 0..1 is refused");
+        } catch (IllegalArgumentException expected) {
+            // expected
+        }
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(ms(1000), new KeyValue(x, 100.0, spline)));
+        t.play();
+        FrameClock.advance(500);
+        assertEquals(35.0, x.get(), 1e-6);
+    }
+
+    /// A value that blends itself.
+    private static final class Span implements Interpolatable<Span> {
+        final double length;
+
+        Span(double length) {
+            this.length = length;
+        }
+
+        @Override
+        public Span interpolate(Span endValue, double t) {
+            return new Span(length + (endValue.length - length) * t);
+        }
+    }
+
+    @Test
+    public void whatInterpolatesAndWhatSwitchesAtTheEnd() {
+        Interpolator i = Interpolator.LINEAR;
+        assertEquals(Integer.valueOf(3), i.interpolate(Integer.valueOf(0), Integer.valueOf(10), 0.25));
+        assertEquals(Long.valueOf(5), i.interpolate(Long.valueOf(0), Long.valueOf(10), 0.5));
+        assertEquals(Double.valueOf(2.5), i.interpolate(Integer.valueOf(0), Double.valueOf(10), 0.25));
+        assertEquals(3, i.interpolate(0, 10, 0.25));
+        assertEquals(5L, i.interpolate(0L, 10L, 0.5));
+        Object blended = i.interpolate(new Span(10), new Span(20), 0.5);
+        assertTrue(blended instanceof Span);
+        assertEquals(15.0, ((Span) blended).length, EXACT);
+        assertEquals("a", i.interpolate("a", "b", 0.99));
+        assertEquals("b", i.interpolate("a", "b", 1.0));
+        assertFalse(i.interpolate(false, true, 0.99));
+        assertTrue(i.interpolate(false, true, 1.0));
+
+        ObjectProperty<String> text = new SimpleObjectProperty<String>("before");
+        IntegerProperty count = new SimpleIntegerProperty(0);
+        BooleanProperty flag = new SimpleBooleanProperty(false);
+        Timeline t = new Timeline(new KeyFrame(ms(100), new KeyValue(text, "after"), new KeyValue(count, 10),
+                new KeyValue(flag, true)));
+        t.play();
+        FrameClock.advance(50);
+        assertEquals("before", text.get());
+        assertEquals(5, count.get());
+        assertFalse(flag.get());
+        FrameClock.advance(50);
+        assertEquals("after", text.get());
+        assertEquals(10, count.get());
+        assertTrue(flag.get());
+    }
+
+    // ---- timeline ----
+
+    @Test
+    public void linearValuesAtChosenTimes() {
+        DoubleProperty x = new SimpleDoubleProperty(10);
+        Timeline t = line(x, 110, 1000);
+        t.setOnFinished(note("finished"));
+        assertEquals(ms(1000), t.getCycleDuration());
+        assertEquals(ms(1000), t.getTotalDuration());
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+        t.play();
+        assertSame(Animation.Status.RUNNING, t.getStatus());
+        assertEquals(1.0, t.getCurrentRate(), EXACT);
+        assertEquals(10.0, x.get(), EXACT);
+        FrameClock.advance(250);
+        assertEquals(35.0, x.get(), EXACT);
+        assertEquals(ms(250), t.getCurrentTime());
+        FrameClock.advance(250);
+        assertEquals(60.0, x.get(), EXACT);
+        assertTrue(log.isEmpty());
+        FrameClock.advance(500);
+        assertEquals(110.0, x.get(), EXACT);
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+        assertEquals(0.0, t.getCurrentRate(), EXACT);
+        assertEquals(Arrays.asList("finished"), log);
+        assertFalse("an idle clock has no receivers", FrameClock.isActive());
+        FrameClock.advance(500);
+        assertEquals(Arrays.asList("finished"), log);
+    }
+
+    @Test
+    public void aKeyFrameAtZeroSetsTheStartOtherwiseItIsCapturedAtPlay() {
+        DoubleProperty x = new SimpleDoubleProperty(5);
+        DoubleProperty y = new SimpleDoubleProperty(7);
+        Timeline t = new Timeline(new KeyFrame(Duration.ZERO, new KeyValue(x, 20.0)),
+                new KeyFrame(ms(1000), new KeyValue(x, 40.0), new KeyValue(y, 200.0)));
+        // Changed after the timeline was built, before it is played: this is
+        // the value y starts from.
+        y.set(100);
+        t.play();
+        y.set(-1);
+        FrameClock.advance(500);
+        assertEquals(30.0, x.get(), EXACT);
+        assertEquals(150.0, y.get(), EXACT);
+        FrameClock.advance(500);
+        assertEquals(40.0, x.get(), EXACT);
+        assertEquals(200.0, y.get(), EXACT);
+    }
+
+    @Test
+    public void severalKeyFramesForOneTarget() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(ms(100), new KeyValue(x, 100.0)),
+                new KeyFrame(ms(300), new KeyValue(x, 0.0)));
+        t.play();
+        FrameClock.advance(50);
+        assertEquals(50.0, x.get(), EXACT);
+        FrameClock.advance(150);
+        assertEquals(50.0, x.get(), EXACT);
+        FrameClock.advance(50);
+        assertEquals(25.0, x.get(), EXACT);
+    }
+
+    @Test
+    public void keyFrameHandlersRunInOrderWhenAFrameJumpsPastSeveral() {
+        final DoubleProperty x = new SimpleDoubleProperty(0);
+        final List<Double> seen = new ArrayList<Double>();
+        EventHandler<ActionEvent> record = new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                seen.add(Double.valueOf(x.get()));
+            }
+        };
+        // Deliberately not in time order.
+        Timeline t = new Timeline(new KeyFrame(ms(300), note("c"), new KeyValue(x, 300.0)),
+                new KeyFrame(ms(100), note("a")), new KeyFrame(ms(200), note("b")),
+                new KeyFrame(Duration.ZERO, note("zero")), new KeyFrame(ms(100), record),
+                new KeyFrame(ms(200), record));
+        t.setOnFinished(note("finished"));
+        t.play();
+        assertTrue("nothing runs before the first frame", log.isEmpty());
+        FrameClock.advance(1000);
+        assertEquals(Arrays.asList("zero", "a", "b", "c", "finished"), log);
+        // Each handler saw the targets as they are at its own key frame.
+        assertEquals(Arrays.asList(Double.valueOf(100), Double.valueOf(200)), seen);
+    }
+
+    @Test
+    public void keyFrameHandlersRunOncePerCycle() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(Duration.ZERO, note("start")),
+                new KeyFrame(ms(100), note("end"), new KeyValue(x, 100.0)));
+        t.setCycleCount(3);
+        t.setOnFinished(note("finished"));
+        assertEquals(ms(300), t.getTotalDuration());
+        t.play();
+        FrameClock.advance(50);
+        assertEquals(Arrays.asList("start"), log);
+        FrameClock.advance(200);
+        // 250 ms: two cycles over, half way through the third.
+        assertEquals(Arrays.asList("start", "end", "start", "end", "start"), log);
+        assertEquals(50.0, x.get(), EXACT);
+        assertSame(Animation.Status.RUNNING, t.getStatus());
+        FrameClock.advance(50);
+        assertEquals(Arrays.asList("start", "end", "start", "end", "start", "end", "finished"), log);
+        assertEquals(100.0, x.get(), EXACT);
+
+        log.clear();
+        t.play();
+        FrameClock.advance(5000);
+        assertEquals(Arrays.asList("start", "end", "start", "end", "start", "end", "finished"), log);
+    }
+
+    @Test
+    public void autoReverseFlipsTheDirection() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(ms(1000), note("end"), new KeyValue(x, 100.0)));
+        t.setCycleCount(2);
+        t.setAutoReverse(true);
+        t.setOnFinished(note("finished"));
+        t.play();
+        FrameClock.advance(500);
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(1.0, t.getCurrentRate(), EXACT);
+        FrameClock.advance(750);
+        // 1250 ms: a quarter of the way back.
+        assertEquals(75.0, x.get(), EXACT);
+        assertEquals(-1.0, t.getCurrentRate(), EXACT);
+        assertEquals(ms(750), t.getCurrentTime());
+        assertEquals("the key frame at the turning point runs once", Arrays.asList("end"), log);
+        FrameClock.advance(500);
+        assertEquals(25.0, x.get(), EXACT);
+        FrameClock.advance(250);
+        assertEquals(0.0, x.get(), EXACT);
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+        assertEquals(Arrays.asList("end", "finished"), log);
+    }
+
+    @Test
+    public void rateScalesAndANegativeRatePlaysBackwards() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = line(x, 100, 1000);
+        t.setOnFinished(note("finished"));
+        t.setRate(2);
+        t.play();
+        FrameClock.advance(250);
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(2.0, t.getCurrentRate(), EXACT);
+        // Turned round in mid flight.
+        t.setRate(-1);
+        assertEquals(-1.0, t.getCurrentRate(), EXACT);
+        FrameClock.advance(200);
+        assertEquals(30.0, x.get(), EXACT);
+        FrameClock.advance(300);
+        assertEquals(0.0, x.get(), EXACT);
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+        assertEquals(Arrays.asList("finished"), log);
+
+        // From the end, backwards.
+        log.clear();
+        t.jumpTo("end");
+        t.play();
+        FrameClock.advance(250);
+        assertEquals(75.0, x.get(), EXACT);
+        FrameClock.advance(750);
+        assertEquals(0.0, x.get(), EXACT);
+        assertEquals(Arrays.asList("finished"), log);
+
+        // Having finished, a backwards animation starts over from its end.
+        log.clear();
+        t.play();
+        FrameClock.advance(500);
+        assertEquals(50.0, x.get(), EXACT);
+        assertTrue(log.isEmpty());
+    }
+
+    @Test
+    public void pauseKeepsThePositionAndPlayResumes() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = line(x, 100, 1000);
+        t.play();
+        FrameClock.advance(300);
+        t.pause();
+        assertSame(Animation.Status.PAUSED, t.getStatus());
+        assertEquals(0.0, t.getCurrentRate(), EXACT);
+        assertFalse(FrameClock.isActive());
+        FrameClock.advance(5000);
+        assertEquals(30.0, x.get(), EXACT);
+        assertEquals(ms(300), t.getCurrentTime());
+        t.play();
+        assertSame(Animation.Status.RUNNING, t.getStatus());
+        FrameClock.advance(200);
+        assertEquals(50.0, x.get(), EXACT);
+    }
+
+    @Test
+    public void stopResetsToTheStartAndDoesNotFinish() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = line(x, 100, 1000);
+        t.setOnFinished(note("finished"));
+        t.play();
+        FrameClock.advance(300);
+        t.stop();
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+        assertEquals(Duration.ZERO, t.getCurrentTime());
+        assertEquals("the value stays where the animation left it", 30.0, x.get(), EXACT);
+        FrameClock.advance(5000);
+        assertTrue(log.isEmpty());
+        assertEquals(30.0, x.get(), EXACT);
+        // Played again it starts at the start, from the value the target has now.
+        t.play();
+        FrameClock.advance(500);
+        assertEquals(65.0, x.get(), EXACT);
+    }
+
+    @Test
+    public void jumpToAndCuePoints() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(ms(250), "quarter", new KeyValue[0]),
+                new KeyFrame(ms(1000), new KeyValue(x, 100.0)));
+        assertEquals(ms(250), t.getCuePoints().get("quarter"));
+        t.getCuePoints().put("most", ms(800));
+        t.play();
+        FrameClock.advance(100);
+        t.jumpTo(ms(800));
+        assertEquals("a running animation shows the position at once", 80.0, x.get(), EXACT);
+        assertEquals(ms(800), t.getCurrentTime());
+        FrameClock.advance(100);
+        assertEquals(90.0, x.get(), EXACT);
+        t.jumpTo(ms(-5));
+        assertEquals(0.0, x.get(), EXACT);
+        t.jumpTo(ms(99999));
+        assertEquals(100.0, x.get(), EXACT);
+        t.stop();
+
+        x.set(0);
+        t.playFrom("quarter");
+        assertEquals(ms(250), t.getCurrentTime());
+        FrameClock.advance(250);
+        assertEquals(50.0, x.get(), EXACT);
+        t.jumpTo("most");
+        assertEquals(80.0, x.get(), EXACT);
+        t.jumpTo("no such cue point");
+        assertEquals(80.0, x.get(), EXACT);
+        t.playFrom(ms(500));
+        FrameClock.advance(100);
+        assertEquals(60.0, x.get(), EXACT);
+        t.setRate(-3);
+        t.playFromStart();
+        assertEquals(3.0, t.getRate(), EXACT);
+        // 300 ms in at three times the speed, starting from the 60 it had.
+        FrameClock.advance(100);
+        assertEquals(72.0, x.get(), EXACT);
+    }
+
+    @Test
+    public void indefiniteNeverFinishes() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(ms(100), note("end"), new KeyValue(x, 100.0)));
+        t.setCycleCount(Animation.INDEFINITE);
+        t.setOnFinished(note("finished"));
+        assertEquals(Duration.INDEFINITE, t.getTotalDuration());
+        t.play();
+        FrameClock.advance(100050);
+        assertSame(Animation.Status.RUNNING, t.getStatus());
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(1000, log.size());
+        assertFalse(log.contains("finished"));
+        t.stop();
+        assertFalse(FrameClock.isActive());
+    }
+
+    /// As OpenJFX (checked against 23 and 27): any cycle count is taken, one
+    /// that is neither positive nor INDEFINITE plays a single cycle, and the
+    /// total duration follows the property however it is set.
+    @Test
+    public void aCycleCountIsTakenAsOpenJfxTakesIt() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = new Timeline(new KeyFrame(ms(100), new KeyValue(x, 100.0)));
+        t.setCycleCount(0);
+        assertEquals(0, t.getCycleCount());
+        assertEquals(ms(100), t.getTotalDuration());
+        t.cycleCountProperty().set(3);
+        assertEquals(ms(300), t.getTotalDuration());
+        t.cycleCountProperty().set(-5);
+        assertEquals(ms(100), t.getTotalDuration());
+        t.setOnFinished(note("finished"));
+        t.play();
+        FrameClock.advance(150);
+        assertEquals(Arrays.asList("finished"), log);
+        assertEquals(100.0, x.get(), EXACT);
+    }
+
+    /// A negative delay is refused through the property too, as OpenJFX
+    /// refuses it: the delay becomes zero, a binding is dropped, and the
+    /// caller gets the exception.
+    @Test
+    public void aNegativeDelayIsRefusedThroughThePropertyToo() {
+        Timeline t = new Timeline(new KeyFrame(ms(100)));
+        t.setDelay(ms(50));
+        try {
+            t.delayProperty().set(ms(-1));
+            fail("a negative delay");
+        } catch (IllegalArgumentException expected) {
+            assertEquals(Duration.ZERO, t.getDelay());
+        }
+        t.setDelay(ms(50));
+        try {
+            t.delayProperty().bind(new SimpleObjectProperty<Duration>(ms(-5)));
+            fail("a negative delay");
+        } catch (IllegalArgumentException expected) {
+            assertEquals(Duration.ZERO, t.getDelay());
+            assertFalse(t.delayProperty().isBound());
+        }
+        try {
+            t.setDelay(ms(-1));
+            fail("a negative delay");
+        } catch (IllegalArgumentException expected) {
+            assertEquals(Duration.ZERO, t.getDelay());
+        }
+    }
+
+    @Test
+    public void aZeroDurationTimelineFinishesOnTheNextPulse() {
+        DoubleProperty x = new SimpleDoubleProperty(1);
+        Timeline t = new Timeline(new KeyFrame(Duration.ZERO, note("frame"), new KeyValue(x, 9.0)));
+        t.setOnFinished(note("finished"));
+        t.play();
+        assertSame(Animation.Status.RUNNING, t.getStatus());
+        assertTrue(log.isEmpty());
+        assertEquals(1.0, x.get(), EXACT);
+        FrameClock.advance(0);
+        assertEquals(9.0, x.get(), EXACT);
+        assertEquals(Arrays.asList("frame", "finished"), log);
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+
+        log.clear();
+        Timeline empty = new Timeline();
+        empty.setOnFinished(note("finished"));
+        empty.play();
+        FrameClock.advance(16);
+        assertEquals(Arrays.asList("finished"), log);
+    }
+
+    @Test
+    public void theDelayComesFirst() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline t = line(x, 100, 1000);
+        t.setDelay(ms(200));
+        t.play();
+        FrameClock.advance(150);
+        assertEquals(0.0, x.get(), EXACT);
+        FrameClock.advance(150);
+        assertEquals(10.0, x.get(), EXACT);
+    }
+
+    @Test
+    public void aHandlerMayStopTheAnimation() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        final Timeline t = new Timeline();
+        t.getKeyFrames().addAll(new KeyFrame(ms(100), new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                log.add("stopping");
+                t.stop();
+            }
+        }), new KeyFrame(ms(200), note("late")), new KeyFrame(ms(300), new KeyValue(x, 300.0)));
+        t.setOnFinished(note("finished"));
+        t.play();
+        FrameClock.advance(1000);
+        assertEquals(Arrays.asList("stopping"), log);
+        assertSame(Animation.Status.STOPPED, t.getStatus());
+        assertEquals(100.0, x.get(), EXACT);
+        assertFalse(FrameClock.isActive());
+    }
+
+    // ---- composition ----
+
+    @Test
+    public void sequentialPlaysOneAfterTheOther() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        DoubleProperty y = new SimpleDoubleProperty(0);
+        Timeline a = line(x, 100, 100);
+        a.setOnFinished(note("a"));
+        PauseTransition pause = new PauseTransition(ms(50));
+        pause.setOnFinished(note("pause"));
+        Timeline b = line(y, 10, 100);
+        b.setOnFinished(note("b"));
+        SequentialTransition seq = new SequentialTransition(a, pause, b);
+        seq.setOnFinished(note("seq"));
+        assertEquals(ms(250), seq.getCycleDuration());
+        seq.play();
+        FrameClock.advance(50);
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(0.0, y.get(), EXACT);
+        assertTrue(log.isEmpty());
+        FrameClock.advance(75);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(0.0, y.get(), EXACT);
+        assertEquals(Arrays.asList("a"), log);
+        FrameClock.advance(75);
+        assertEquals(5.0, y.get(), EXACT);
+        assertEquals(Arrays.asList("a", "pause"), log);
+        FrameClock.advance(50);
+        assertEquals(10.0, y.get(), EXACT);
+        assertEquals(Arrays.asList("a", "pause", "b", "seq"), log);
+        assertSame(Animation.Status.STOPPED, seq.getStatus());
+
+        // One big frame runs it all, in order.
+        log.clear();
+        x.set(0);
+        y.set(0);
+        seq.play();
+        FrameClock.advance(10000);
+        assertEquals(Arrays.asList("a", "pause", "b", "seq"), log);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(10.0, y.get(), EXACT);
+    }
+
+    @Test
+    public void aLaterChildStartsFromWhatTheEarlierOnesLeft() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        SequentialTransition seq = new SequentialTransition(line(x, 100, 100), line(x, 0, 100));
+        seq.play();
+        FrameClock.advance(150);
+        assertEquals(50.0, x.get(), EXACT);
+        FrameClock.advance(50);
+        assertEquals(0.0, x.get(), EXACT);
+    }
+
+    @Test
+    public void aSequenceRunsBackwardsJumpsAndPauses() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        DoubleProperty y = new SimpleDoubleProperty(0);
+        SequentialTransition seq = new SequentialTransition(line(x, 100, 100), line(y, 10, 100));
+        seq.setCycleCount(2);
+        seq.setAutoReverse(true);
+        seq.setOnFinished(note("seq"));
+        seq.play();
+        FrameClock.advance(150);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(5.0, y.get(), EXACT);
+        // 250 ms: 50 ms into the way back, which undoes the second child first.
+        FrameClock.advance(100);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(5.0, y.get(), EXACT);
+        assertEquals(-1.0, seq.getCurrentRate(), EXACT);
+        seq.pause();
+        FrameClock.advance(1000);
+        assertEquals(5.0, y.get(), EXACT);
+        seq.play();
+        FrameClock.advance(100);
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(0.0, y.get(), EXACT);
+        assertTrue(log.isEmpty());
+        FrameClock.advance(50);
+        assertEquals(0.0, x.get(), EXACT);
+        assertEquals(Arrays.asList("seq"), log);
+
+        // A jump shows every child as it is at that time.
+        seq.setAutoReverse(false);
+        seq.setCycleCount(1);
+        seq.play();
+        FrameClock.advance(20);
+        seq.jumpTo(ms(150));
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(5.0, y.get(), EXACT);
+        seq.jumpTo(ms(50));
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(0.0, y.get(), EXACT);
+        FrameClock.advance(100);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(5.0, y.get(), EXACT);
+        seq.stop();
+        assertEquals(Duration.ZERO, seq.getCurrentTime());
+    }
+
+    @Test
+    public void parallelPlaysTogetherAndLastsAsLongAsTheLongest() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        DoubleProperty y = new SimpleDoubleProperty(0);
+        Timeline a = line(x, 100, 100);
+        a.setOnFinished(note("a"));
+        Timeline b = line(y, 10, 200);
+        b.setOnFinished(note("b"));
+        ParallelTransition par = new ParallelTransition(a, b);
+        par.setOnFinished(note("par"));
+        assertEquals(ms(200), par.getCycleDuration());
+        par.play();
+        FrameClock.advance(50);
+        assertEquals(50.0, x.get(), EXACT);
+        assertEquals(2.5, y.get(), EXACT);
+        FrameClock.advance(100);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(7.5, y.get(), EXACT);
+        assertEquals(Arrays.asList("a"), log);
+        FrameClock.advance(50);
+        assertEquals(10.0, y.get(), EXACT);
+        assertEquals(Arrays.asList("a", "b", "par"), log);
+    }
+
+    @Test
+    public void nestedCompositionAndCycles() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        DoubleProperty y = new SimpleDoubleProperty(0);
+        DoubleProperty z = new SimpleDoubleProperty(0);
+        Timeline a = new Timeline(new KeyFrame(Duration.ZERO, new KeyValue(x, 0.0)),
+                new KeyFrame(ms(100), new KeyValue(x, 100.0)));
+        Timeline b = new Timeline(new KeyFrame(Duration.ZERO, new KeyValue(y, 0.0)),
+                new KeyFrame(ms(200), new KeyValue(y, 10.0)));
+        Timeline c = new Timeline(new KeyFrame(Duration.ZERO, new KeyValue(z, 0.0)),
+                new KeyFrame(ms(100), new KeyValue(z, 1.0)));
+        b.setOnFinished(note("b"));
+        c.setOnFinished(note("c"));
+        ParallelTransition par = new ParallelTransition(a, b);
+        par.setOnFinished(note("par"));
+        SequentialTransition seq = new SequentialTransition(par, c);
+        seq.setCycleCount(2);
+        seq.setOnFinished(note("seq"));
+        assertEquals(ms(300), seq.getCycleDuration());
+        assertEquals(ms(600), seq.getTotalDuration());
+        seq.play();
+        FrameClock.advance(250);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(10.0, y.get(), EXACT);
+        assertEquals(0.5, z.get(), EXACT);
+        assertEquals(Arrays.asList("b", "par"), log);
+        // 400 ms: 100 ms into the second cycle.
+        FrameClock.advance(150);
+        assertEquals(100.0, x.get(), EXACT);
+        assertEquals(5.0, y.get(), EXACT);
+        assertEquals(Arrays.asList("b", "par", "c"), log);
+        FrameClock.advance(200);
+        assertEquals(Arrays.asList("b", "par", "c", "b", "par", "c", "seq"), log);
+        assertEquals(1.0, z.get(), EXACT);
+    }
+
+    @Test
+    public void aChildCannotBePlayedOnItsOwn() {
+        DoubleProperty x = new SimpleDoubleProperty(0);
+        Timeline child = line(x, 100, 100);
+        SequentialTransition seq = new SequentialTransition(child);
+        try {
+            child.play();
+            fail("a child is played by its parent");
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        try {
+            child.pause();
+            fail();
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        try {
+            child.stop();
+            fail();
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        try {
+            child.jumpTo(ms(10));
+            fail();
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        try {
+            new ParallelTransition(child);
+            fail("an animation has one parent");
+        } catch (IllegalArgumentException expected) {
+            // expected
+        }
+        // Taken out, it is its own again.
+        seq.getChildren().clear();
+        assertEquals(Duration.ZERO, seq.getCycleDuration());
+        child.play();
+        FrameClock.advance(50);
+        assertEquals(50.0, x.get(), EXACT);
+    }
+
+    // ---- transitions ----
+
+    private static Region node() {
+        Region r = new Region();
+        r.resize(10, 10);
+        return r;
+    }
+
+    @Test
+    public void fadeChangesTheOpacity() {
+        Region n = node();
+        FadeTransition fade = new FadeTransition(ms(1000), n);
+        fade.setFromValue(1.0);
+        fade.setToValue(0.0);
+        fade.setInterpolator(Interpolator.LINEAR);
+        assertEquals(ms(1000), fade.getCycleDuration());
+        fade.play();
+        FrameClock.advance(250);
+        assertEquals(0.75, n.getOpacity(), EXACT);
+        FrameClock.advance(750);
+        assertEquals(0.0, n.getOpacity(), EXACT);
+
+        // From what the node has, by an amount, eased.
+        n.setOpacity(0.2);
+        FadeTransition by = new FadeTransition(ms(1000), n);
+        by.setByValue(0.4);
+        assertSame(Interpolator.EASE_BOTH, by.getInterpolator());
+        by.play();
+        FrameClock.advance(100);
+        assertEquals(0.2 + 0.4 * 0.03125, n.getOpacity(), EXACT);
+        FrameClock.advance(400);
+        assertEquals(0.4, n.getOpacity(), EXACT);
+        FrameClock.advance(500);
+        assertEquals(0.6, n.getOpacity(), 1e-12);
+    }
+
+    @Test
+    public void translateMovesTheNodeThroughItsRealProperties() {
+        Region n = node();
+        final int[] invalidations = {0};
+        n.boundsInParentProperty().addListener(new javafx.beans.InvalidationListener() {
+            @Override
+            public void invalidated(javafx.beans.Observable observable) {
+                invalidations[0]++;
+            }
+        });
+        n.getBoundsInParent();
+        TranslateTransition move = new TranslateTransition(ms(1000), n);
+        move.setByX(100);
+        move.setFromY(10);
+        move.setToY(50);
+        move.setInterpolator(Interpolator.LINEAR);
+        move.play();
+        FrameClock.advance(250);
+        assertEquals(25.0, n.getTranslateX(), EXACT);
+        assertEquals(20.0, n.getTranslateY(), EXACT);
+        assertTrue("the node's geometry was invalidated", invalidations[0] > 0);
+        assertEquals(25.0, n.getBoundsInParent().getMinX(), EXACT);
+        assertEquals(20.0, n.getBoundsInParent().getMinY(), EXACT);
+        FrameClock.advance(750);
+        assertEquals(100.0, n.getTranslateX(), EXACT);
+        assertEquals(50.0, n.getTranslateY(), EXACT);
+    }
+
+    @Test
+    public void scaleAndRotate() {
+        Region n = node();
+        ScaleTransition scale = new ScaleTransition(ms(1000), n);
+        scale.setToX(2);
+        scale.setByY(2);
+        scale.setInterpolator(Interpolator.LINEAR);
+        RotateTransition rotate = new RotateTransition(ms(1000), n);
+        rotate.setByAngle(360);
+        rotate.setInterpolator(Interpolator.LINEAR);
+        scale.play();
+        rotate.play();
+        FrameClock.advance(500);
+        assertEquals(1.5, n.getScaleX(), EXACT);
+        assertEquals(2.0, n.getScaleY(), EXACT);
+        assertEquals(180.0, n.getRotate(), EXACT);
+        FrameClock.advance(500);
+        assertEquals(2.0, n.getScaleX(), EXACT);
+        assertEquals(3.0, n.getScaleY(), EXACT);
+        assertEquals(360.0, n.getRotate(), EXACT);
+
+        RotateTransition back = new RotateTransition(ms(100), n);
+        back.setFromAngle(90);
+        back.setToAngle(0);
+        back.setInterpolator(Interpolator.LINEAR);
+        back.play();
+        FrameClock.advance(50);
+        assertEquals(45.0, n.getRotate(), EXACT);
+    }
+
+    @Test
+    public void childrenAnimateTheNodeOfTheirParent() {
+        Region n = node();
+        FadeTransition fade = new FadeTransition(ms(100));
+        fade.setFromValue(1);
+        fade.setToValue(0);
+        fade.setInterpolator(Interpolator.LINEAR);
+        TranslateTransition move = new TranslateTransition(ms(100));
+        move.setToX(40);
+        move.setInterpolator(Interpolator.LINEAR);
+        ParallelTransition par = new ParallelTransition(n, fade, move);
+        SequentialTransition seq = new SequentialTransition(new PauseTransition(ms(100)), par);
+        assertSame(n, par.getNode());
+        seq.play();
+        FrameClock.advance(100);
+        assertEquals(1.0, n.getOpacity(), EXACT);
+        FrameClock.advance(50);
+        assertEquals(0.5, n.getOpacity(), EXACT);
+        assertEquals(20.0, n.getTranslateX(), EXACT);
+        FrameClock.advance(50);
+        assertEquals(0.0, n.getOpacity(), EXACT);
+        assertEquals(40.0, n.getTranslateX(), EXACT);
+        assertSame(Animation.Status.STOPPED, seq.getStatus());
+    }
+
+    @Test
+    public void aTransitionOfOnesOwn() {
+        final List<Double> fractions = new ArrayList<Double>();
+        Transition t = new Transition() {
+            {
+                setCycleDuration(ms(200));
+                setInterpolator(Interpolator.LINEAR);
+            }
+
+            @Override
+            protected void interpolate(double frac) {
+                fractions.add(Double.valueOf(frac));
+            }
+        };
+        t.setOnFinished(note("finished"));
+        t.play();
+        FrameClock.advance(50);
+        FrameClock.advance(100);
+        FrameClock.advance(100);
+        assertEquals(Arrays.asList(Double.valueOf(0.25), Double.valueOf(0.75), Double.valueOf(1.0)), fractions);
+        assertEquals(Arrays.asList("finished"), log);
+
+        log.clear();
+        PauseTransition pause = new PauseTransition(ms(300));
+        pause.setOnFinished(note("pause over"));
+        pause.play();
+        FrameClock.advance(299);
+        assertTrue(log.isEmpty());
+        FrameClock.advance(1);
+        assertEquals(Arrays.asList("pause over"), log);
+    }
+
+    // ---- the timer ----
+
+    @Test
+    public void animationTimerGetsEveryFrameUntilItIsStopped() {
+        final List<Long> times = new ArrayList<Long>();
+        AnimationTimer timer = new AnimationTimer() {
+            @Override
+            public void handle(long now) {
+                times.add(Long.valueOf(now));
+            }
+        };
+        FrameClock.advance(16);
+        assertTrue("not started yet", times.isEmpty());
+        timer.start();
+        timer.start();
+        assertTrue(FrameClock.isActive());
+        FrameClock.advance(16);
+        FrameClock.advance(16);
+        FrameClock.advance(34);
+        assertEquals(3, times.size());
+        assertEquals(16000000L, times.get(1).longValue() - times.get(0).longValue());
+        assertEquals(34000000L, times.get(2).longValue() - times.get(1).longValue());
+        timer.stop();
+        assertFalse(FrameClock.isActive());
+        FrameClock.advance(16);
+        assertEquals(3, times.size());
+        timer.start();
+        FrameClock.advance(16);
+        assertEquals(4, times.size());
+        assertTrue(times.get(3).longValue() > times.get(2).longValue());
+        timer.stop();
+    }
+
+    @Test
+    public void aTimerMayStopItselfInsideAFrame() {
+        final int[] calls = {0};
+        final AnimationTimer[] self = new AnimationTimer[1];
+        self[0] = new AnimationTimer() {
+            @Override
+            public void handle(long now) {
+                calls[0]++;
+                self[0].stop();
+            }
+        };
+        self[0].start();
+        FrameClock.advance(16);
+        FrameClock.advance(16);
+        assertEquals(1, calls[0]);
+        try {
+            FrameClock.advance(-1);
+            fail("time does not run backwards");
+        } catch (IllegalArgumentException expected) {
+            // expected
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ApiNamingTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ApiNamingTest.java
new file mode 100644
index 00000000000..f17f6a11d1b
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ApiNamingTest.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.junit.Test;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/// Holds the `javafx.*` classes to the rule that keeps them honest: a
+/// public or protected member JavaFX does not have is named `cn1...` (or
+/// `CN1_...` for a constant), and every such member is listed in
+/// `cn1-hooks.txt`.
+///
+/// The list is what makes a hook a decision. Application code compiles
+/// against these classes under the real names, so a hook is one more
+/// member an application could call by accident and then fail to compile
+/// against JavaFX itself; adding one takes a line in a file a reviewer
+/// reads.
+///
+/// An entry is `binary.class.Name#member`, named for the class that
+/// introduces the hook; overrides in subclasses are covered by it.
+public class ApiNamingTest {
+
+    private static final class Info {
+        String name;
+        String superName;
+        String[] interfaces;
+        boolean exported;
+        final Set<String> hooks = new TreeSet<String>();
+    }
+
+    private static boolean isHookName(String name) {
+        return name.startsWith("cn1") || name.startsWith("CN1_");
+    }
+
+    private static void collect(File dir, List<File> out) {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                collect(f, out);
+            } else if (f.getName().endsWith(".class")) {
+                out.add(f);
+            }
+        }
+    }
+
+    private static Info read(File file) throws IOException {
+        final Info info = new Info();
+        InputStream in = new FileInputStream(file);
+        try {
+            new ClassReader(in).accept(new ClassVisitor(Opcodes.ASM9) {
+                @Override
+                public void visit(int version, int access, String name, String signature, String superName,
+                        String[] interfaces) {
+                    info.name = name;
+                    info.superName = superName;
+                    info.interfaces = interfaces;
+                    info.exported = (access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) != 0;
+                }
+
+                @Override
+                public void visitInnerClass(String name, String outerName, String innerName, int access) {
+                    if (name.equals(info.name)) {
+                        info.exported = (access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) != 0;
+                    }
+                }
+
+                @Override
+                public FieldVisitor visitField(int access, String name, String descriptor, String signature,
+                        Object value) {
+                    member(access, name);
+                    return null;
+                }
+
+                @Override
+                public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                        String[] exceptions) {
+                    member(access, name);
+                    return null;
+                }
+
+                private void member(int access, String name) {
+                    if ((access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) != 0
+                            && (access & Opcodes.ACC_SYNTHETIC) == 0 && isHookName(name)) {
+                        info.hooks.add(name);
+                    }
+                }
+            }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        } finally {
+            in.close();
+        }
+        return info;
+    }
+
+    /// Collects the topmost classes of a hierarchy that declare a member:
+    /// the ones that introduce it.
+    private static boolean introducers(Map<String, Info> classes, String owner, String member, Set<String> out) {
+        Info info = owner == null ? null : classes.get(owner);
+        if (info == null) {
+            return false;
+        }
+        boolean above = introducers(classes, info.superName, member, out);
+        if (info.interfaces != null) {
+            for (String i : info.interfaces) {
+                above |= introducers(classes, i, member, out);
+            }
+        }
+        if (!above && info.hooks.contains(member)) {
+            out.add(info.name.replace('/', '.') + "#" + member);
+            return true;
+        }
+        return above;
+    }
+
+    @Test
+    public void everyHookIsListedAndEveryListedHookExists() throws IOException {
+        File root = new File("target/classes");
+        assertTrue("run after compile: " + root.getAbsolutePath(), root.isDirectory());
+        List<File> files = new ArrayList<File>();
+        collect(root, files);
+        Map<String, Info> classes = new HashMap<String, Info>();
+        for (File f : files) {
+            Info info = read(f);
+            classes.put(info.name, info);
+        }
+
+        Set<String> listed = new HashSet<String>();
+        InputStream in = ApiNamingTest.class.getResourceAsStream("/cn1-hooks.txt");
+        assertTrue("cn1-hooks.txt is missing", in != null);
+        BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
+        try {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                line = line.trim();
+                if (line.length() > 0 && line.charAt(0) != '#') {
+                    listed.add(line);
+                }
+            }
+        } finally {
+            reader.close();
+        }
+
+        Set<String> required = new HashSet<String>();
+        Set<String> unlisted = new TreeSet<String>();
+        for (Info info : classes.values()) {
+            for (String hook : info.hooks) {
+                // A nested class is as visible as its outermost holder lets it be,
+                // and javac records that only on the inner class entry.
+                if (info.name.startsWith("javafx/") && info.exported) {
+                    Set<String> owners = new TreeSet<String>();
+                    introducers(classes, info.name, hook, owners);
+                    for (String entry : owners) {
+                        required.add(entry);
+                        if (!listed.contains(entry)) {
+                            unlisted.add(entry);
+                        }
+                    }
+                }
+            }
+        }
+        List<String> stale = new ArrayList<String>();
+        for (String entry : listed) {
+            if (!required.contains(entry)) {
+                stale.add(entry);
+            }
+        }
+        Collections.sort(stale);
+        if (!unlisted.isEmpty() || !stale.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("cn1-hooks.txt is out of date.\nAdd (each is API an application can see):\n");
+            for (String s : unlisted) {
+                sb.append(s).append('\n');
+            }
+            sb.append("Remove (no javafx class has or inherits it, or a superclass introduces it):\n");
+            for (String s : stale) {
+                sb.append(s).append('\n');
+            }
+            fail(sb.toString());
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ApplicationWindowTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ApplicationWindowTest.java
new file mode 100644
index 00000000000..19f146dc034
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ApplicationWindowTest.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.StageForm;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Image;
+
+import javafx.application.Platform;
+import javafx.scene.Scene;
+import javafx.scene.layout.Pane;
+import javafx.stage.Stage;
+
+/// The primary stage in the application's own window on a desktop: the
+/// window takes the stage's title and size, and the first frame painted
+/// for a display size is followed by another.
+public class ApplicationWindowTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicit;
+    private Stage stage;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        implicit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+        // A form an earlier test class left showing is not a stage's, and
+        // the first stage shown over it would be a guest in its window,
+        // which sizes nothing: whichever test ran first here failed. A
+        // stage shown and hidden leaves a stage's form behind instead.
+        Stage first = new Stage();
+        first.cn1MarkPrimary();
+        first.setScene(new Scene(new Pane(), 10, 10));
+        first.show();
+        first.hide();
+        HeadlessImplementation.windowTitle = null;
+        HeadlessImplementation.windowSize = null;
+    }
+
+    @After
+    public void tearDown() {
+        if (stage != null && stage.isShowing()) {
+            stage.hide();
+        }
+        Platform.setImplicitExit(implicit);
+        Units.setScale(0);
+        HeadlessImplementation.setDesktop(false);
+        HeadlessImplementation.nativeTitle = false;
+        HeadlessImplementation.windowTitle = null;
+        HeadlessImplementation.windowSize = null;
+        HeadlessImplementation.windowFrame = null;
+    }
+
+    private static void desktop() {
+        HeadlessImplementation.setDesktop(true);
+        HeadlessImplementation.nativeTitle = true;
+    }
+
+    private StageForm primary(String title, Scene scene) {
+        stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setTitle(title);
+        stage.setScene(scene);
+        stage.show();
+        return (StageForm) stage.cn1Host();
+    }
+
+    /// The port pushes a title only when asked to, and Codename One asks
+    /// only for a title set on the form that is showing. A stage is
+    /// titled before it is shown, and the primary one has no title area.
+    /// A window opens with the focus on its first control, so Space fires
+    /// it before anything was clicked; a choice the application made stays.
+    @Test
+    public void aShownWindowStartsWithTheFocusOnItsFirstControl() {
+        desktop();
+        javafx.scene.control.Label title = new javafx.scene.control.Label("Title");
+        javafx.scene.control.Button first = new javafx.scene.control.Button("0");
+        javafx.scene.control.Button second = new javafx.scene.control.Button("1");
+        final int[] fired = new int[1];
+        first.setOnAction(e -> fired[0]++);
+        Scene scene = new Scene(new javafx.scene.layout.HBox(title, first, second), 320, 200);
+        primary("Ledger", scene);
+        assertSame(first, scene.getFocusOwner());
+        assertTrue(first.isFocused());
+        scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.SPACE, " ");
+        scene.cn1Key(javafx.scene.input.KeyEvent.KEY_RELEASED, javafx.scene.input.KeyCode.SPACE, " ");
+        assertEquals(1, fired[0]);
+        stage.hide();
+
+        desktop();
+        javafx.scene.control.Button chosen = new javafx.scene.control.Button("chosen");
+        Scene other = new Scene(new javafx.scene.layout.HBox(new javafx.scene.control.Button("a"), chosen), 320, 200);
+        chosen.requestFocus();
+        primary("Ledger", other);
+        assertSame(chosen, other.getFocusOwner());
+    }
+
+    @Test
+    public void theTitleGivenBeforeShowingReachesTheWindow() {
+        desktop();
+        primary("Ledger", new Scene(new Pane(), 320, 200));
+        assertEquals("Ledger", HeadlessImplementation.windowTitle);
+        stage.setTitle("Ledger - accounts.txt");
+        assertEquals("Ledger - accounts.txt", HeadlessImplementation.windowTitle);
+    }
+
+    @Test
+    public void theWindowIsAskedForTheSizeOfTheSceneInDevicePixels() {
+        desktop();
+        primary("Ledger", new Scene(new Pane(), 320, 200));
+        assertArrayEquals(new int[] {Units.sizeToPixels(320), Units.sizeToPixels(200)},
+                HeadlessImplementation.windowSize);
+    }
+
+    /// The size of a scene is that of what is drawn in the window, and a
+    /// port is asked for the size of the window: the frame goes on top.
+    @Test
+    public void theFrameOfTheWindowIsAddedToTheSizeOfAScene() {
+        desktop();
+        HeadlessImplementation.windowFrame = new int[] {2, 25};
+        primary("Ledger", new Scene(new Pane(), 320, 200));
+        assertArrayEquals(new int[] {Units.sizeToPixels(320) + 2, Units.sizeToPixels(200) + 25},
+                HeadlessImplementation.windowSize);
+    }
+
+    /// A window that already shows a display of the size of the scene is
+    /// left alone. Mandelbrot, whose scene is the 800 by 600 the native
+    /// Linux window opens at, was resized to that size less the frame, took
+    /// the resize in its first frame for one made by the user, and kept a
+    /// black picture.
+    @Test
+    public void aSceneTheDisplayAlreadyFitsResizesNothing() {
+        desktop();
+        HeadlessImplementation.windowFrame = new int[] {2, 25};
+        primary("Ledger", new Scene(new Pane(), Units.toLogical(HeadlessImplementation.WIDTH),
+                Units.toLogical(HeadlessImplementation.HEIGHT)));
+        assertNull(HeadlessImplementation.windowSize);
+    }
+
+    /// The size of a stage is its window's: nothing is added to it.
+    @Test
+    public void aSizeGivenToTheStageIsTheWindowsFrameIncluded() {
+        desktop();
+        HeadlessImplementation.windowFrame = new int[] {2, 25};
+        stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setScene(new Scene(new Pane(), 320, 200));
+        stage.setWidth(500);
+        stage.setHeight(400);
+        stage.show();
+        assertArrayEquals(new int[] {Units.sizeToPixels(500), Units.sizeToPixels(400)},
+                HeadlessImplementation.windowSize);
+    }
+
+    @Test
+    public void aSizeGivenToTheStageWins() {
+        desktop();
+        stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setScene(new Scene(new Pane(), 320, 200));
+        stage.setWidth(500);
+        stage.setHeight(400);
+        stage.show();
+        assertArrayEquals(new int[] {Units.sizeToPixels(500), Units.sizeToPixels(400)},
+                HeadlessImplementation.windowSize);
+    }
+
+    /// Off a desktop the display is the screen: nothing resizes it, and a
+    /// title has no window to go to.
+    @Test
+    public void aScreenIsNeitherResizedNorTitled() {
+        primary("Ledger", new Scene(new Pane(), 320, 200));
+        assertNull(HeadlessImplementation.windowSize);
+        assertNull(HeadlessImplementation.windowTitle);
+    }
+
+    /// The native Linux port shows an empty buffer after the first frame
+    /// of a window whose size it has just changed, so the first paint for
+    /// a display size asks for one more; a paint for the same size does
+    /// not, or the form would paint for ever.
+    @Test
+    public void theFirstPaintForADisplaySizeAsksForAnother() {
+        StageForm form = primary("Ledger", new Scene(new Pane(), 320, 200));
+        Image target = Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+        form.paintComponent(target.getGraphics());
+        assertEquals(1, form.cn1PaintedAgain());
+        form.paintComponent(target.getGraphics());
+        form.paintComponent(target.getGraphics());
+        assertEquals(1, form.cn1PaintedAgain());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/BindingsTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/BindingsTest.java
new file mode 100644
index 00000000000..e6f05dddf78
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/BindingsTest.java
@@ -0,0 +1,693 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+import org.junit.Test;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.BooleanBinding;
+import javafx.beans.binding.DoubleBinding;
+import javafx.beans.binding.FloatBinding;
+import javafx.beans.binding.IntegerBinding;
+import javafx.beans.binding.LongBinding;
+import javafx.beans.binding.NumberBinding;
+import javafx.beans.binding.ObjectBinding;
+import javafx.beans.binding.StringBinding;
+import javafx.beans.binding.StringExpression;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.FloatProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.LongProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleFloatProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleLongProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.util.converter.IntegerStringConverter;
+
+public class BindingsTest {
+
+    private final IntegerProperty i = new SimpleIntegerProperty(6);
+    private final LongProperty l = new SimpleLongProperty(4L);
+    private final FloatProperty f = new SimpleFloatProperty(1.5f);
+    private final DoubleProperty d = new SimpleDoubleProperty(2.5);
+
+    @Test
+    public void customBindingIsLazyAndCaches() {
+        final int[] computed = new int[1];
+        final IntegerProperty source = new SimpleIntegerProperty(2);
+        IntegerBinding binding = new IntegerBinding() {
+            {
+                bind(source);
+            }
+
+            @Override
+            protected int computeValue() {
+                computed[0]++;
+                return source.get() * 10;
+            }
+        };
+        assertFalse(binding.isValid());
+        assertEquals(20, binding.get());
+        assertEquals(20, binding.get());
+        assertEquals("the value is cached while valid", 1, computed[0]);
+        assertTrue(binding.isValid());
+        Probe.Invalidations probe = new Probe.Invalidations();
+        binding.addListener(probe);
+        source.set(3);
+        source.get();
+        source.set(4);
+        assertEquals("one invalidation until read", 1, probe.count);
+        assertFalse(binding.isValid());
+        assertEquals(1, computed[0]);
+        assertEquals(40, binding.get());
+        assertEquals(2, computed[0]);
+        binding.invalidate();
+        assertFalse(binding.isValid());
+        assertEquals(2, probe.count);
+    }
+
+    @Test
+    public void changeListenerOnABindingReportsOldAndNew() {
+        NumberBinding sum = i.add(1);
+        Probe.Values<Number> changes = new Probe.Values<Number>();
+        sum.addListener(changes);
+        i.set(7);
+        i.set(7);
+        i.set(8);
+        assertEquals("[7->8, 8->9]", changes.log.toString());
+    }
+
+    @Test
+    public void arithmeticResultHasTheWiderType() {
+        assertTrue(Bindings.add(i, i) instanceof IntegerBinding);
+        assertTrue(Bindings.add(i, l) instanceof LongBinding);
+        assertTrue(Bindings.add(l, f) instanceof FloatBinding);
+        assertTrue(Bindings.add(f, d) instanceof DoubleBinding);
+        assertTrue(Bindings.add(i, 1) instanceof IntegerBinding);
+        assertTrue(Bindings.add(i, 1L) instanceof LongBinding);
+        assertTrue(Bindings.add(i, 1f) instanceof FloatBinding);
+        assertTrue(Bindings.multiply(2L, i) instanceof LongBinding);
+        assertTrue(Bindings.subtract(d, 1) instanceof DoubleBinding);
+        assertTrue(i.multiply(l) instanceof LongBinding);
+        assertTrue(l.divide(2) instanceof LongBinding);
+        DoubleBinding widened = Bindings.add(i, 1.0);
+        assertEquals(7.0, widened.get(), 0d);
+        DoubleBinding fluent = d.add(i);
+        assertEquals(8.5, fluent.get(), 0d);
+    }
+
+    @Test
+    public void arithmeticValues() {
+        assertEquals(10, Bindings.add(i, l).intValue());
+        assertEquals(2, Bindings.subtract(i, l).intValue());
+        assertEquals(24, Bindings.multiply(i, l).intValue());
+        assertEquals(1, Bindings.divide(i, l).intValue());
+        assertEquals("integer division truncates", 1L, Bindings.divide(i, l).longValue());
+        assertEquals(2.4, Bindings.divide(i, d).doubleValue(), 1e-9);
+        assertEquals(4.0, Bindings.add(f, d).doubleValue(), 1e-9);
+        assertEquals(3.5, Bindings.subtract(i, d).doubleValue(), 1e-9);
+        assertEquals(9.0f, Bindings.multiply(i, f).floatValue(), 0f);
+        assertEquals(16, Bindings.add(10, i).intValue());
+        assertEquals(4, Bindings.subtract(10, i).intValue());
+        assertEquals(-4, Bindings.subtract(i, 10).intValue());
+        assertEquals(60, Bindings.multiply(i, 10).intValue());
+        assertEquals(3, Bindings.divide(i, 2).intValue());
+        assertEquals(2, Bindings.divide(12, i).intValue());
+        assertEquals(1.25, Bindings.divide(d, 2).doubleValue(), 1e-9);
+        assertEquals(-6, Bindings.negate(i).intValue());
+        assertEquals(-2.5, d.negate().get(), 0d);
+        assertTrue(i.negate() instanceof IntegerBinding);
+    }
+
+    @Test
+    public void arithmeticFollowsItsOperands() {
+        NumberBinding expression = i.multiply(2).add(l).subtract(d);
+        assertEquals(13.5, expression.doubleValue(), 1e-9);
+        i.set(1);
+        assertEquals(3.5, expression.doubleValue(), 1e-9);
+        l.set(10);
+        d.set(0.5);
+        assertEquals(11.5, expression.doubleValue(), 1e-9);
+        Probe.Invalidations probe = new Probe.Invalidations();
+        expression.addListener(probe);
+        i.set(2);
+        assertEquals(1, probe.count);
+    }
+
+    @Test
+    public void integerDivisionByZeroThrows() {
+        IntegerProperty zero = new SimpleIntegerProperty(0);
+        NumberBinding quotient = Bindings.divide(i, zero);
+        try {
+            quotient.intValue();
+            fail("expected ArithmeticException");
+        } catch (ArithmeticException expected) {
+            assertTrue(true);
+        }
+        assertTrue(Double.isInfinite(Bindings.divide(d, zero).doubleValue()));
+    }
+
+    @Test
+    public void minAndMax() {
+        assertEquals(4, Bindings.min(i, l).intValue());
+        assertEquals(6, Bindings.max(i, l).intValue());
+        assertTrue(Bindings.max(i, l) instanceof LongBinding);
+        assertEquals(2.5, Bindings.min(i, d).doubleValue(), 0d);
+        assertEquals(6, Bindings.min(i, 100).intValue());
+        assertEquals(100, Bindings.max(i, 100).intValue());
+        assertEquals(1, Bindings.min(1, i).intValue());
+        assertEquals(6.5, Bindings.max(6.5, i).doubleValue(), 0d);
+        NumberBinding max = Bindings.max(i, l);
+        l.set(50);
+        assertEquals(50, max.intValue());
+    }
+
+    @Test
+    public void numericEquality() {
+        assertFalse(Bindings.equal(i, l).get());
+        l.set(6);
+        assertTrue(Bindings.equal(i, l).get());
+        assertFalse(Bindings.notEqual(i, l).get());
+        assertTrue(Bindings.equal(i, 6).get());
+        assertTrue(Bindings.equal(6L, i).get());
+        assertTrue(Bindings.notEqual(i, 7).get());
+        assertTrue(Bindings.equal(d, 2.6, 0.2).get());
+        assertFalse(Bindings.equal(d, 2.6, 0.05).get());
+        assertTrue(Bindings.notEqual(d, 2.6, 0.05).get());
+        assertTrue(Bindings.equal(2.4, d, 0.2).get());
+        assertTrue(Bindings.equal(i, d, 4.0).get());
+        assertTrue(i.isEqualTo(6).get());
+        assertTrue(i.isNotEqualTo(5).get());
+        assertTrue(d.isEqualTo(2.5, 0.0).get());
+        assertTrue(i.isEqualTo(l).get());
+        BooleanBinding equal = i.isEqualTo(l);
+        i.set(1);
+        assertFalse(equal.get());
+    }
+
+    @Test
+    public void numericOrdering() {
+        assertTrue(Bindings.greaterThan(i, l).get());
+        assertFalse(Bindings.lessThan(i, l).get());
+        assertTrue(Bindings.greaterThanOrEqual(i, 6).get());
+        assertTrue(Bindings.lessThanOrEqual(i, 6).get());
+        assertFalse(Bindings.greaterThan(i, 6).get());
+        assertFalse(Bindings.lessThan(i, 6).get());
+        assertTrue(Bindings.lessThan(1, i).get());
+        assertTrue(Bindings.greaterThan(6.5, i).get());
+        assertTrue(Bindings.lessThanOrEqual(2.5, d).get());
+        assertTrue(Bindings.greaterThanOrEqual(2.5f, d).get());
+        assertTrue(i.greaterThan(l).get());
+        assertTrue(i.greaterThanOrEqualTo(6).get());
+        assertTrue(l.lessThan(i).get());
+        assertTrue(l.lessThanOrEqualTo(4L).get());
+        assertTrue(d.lessThan(2.6).get());
+        BooleanBinding greater = i.greaterThan(l);
+        l.set(100);
+        assertFalse(greater.get());
+    }
+
+    @Test
+    public void booleanOperators() {
+        BooleanProperty a = new SimpleBooleanProperty(true);
+        BooleanProperty b = new SimpleBooleanProperty(false);
+        BooleanBinding and = Bindings.and(a, b);
+        BooleanBinding or = Bindings.or(a, b);
+        BooleanBinding not = Bindings.not(a);
+        assertFalse(and.get());
+        assertTrue(or.get());
+        assertFalse(not.get());
+        b.set(true);
+        assertTrue(and.get());
+        a.set(false);
+        assertFalse(and.get());
+        assertTrue(or.get());
+        assertTrue(not.get());
+        b.set(false);
+        assertFalse(or.get());
+        assertTrue(a.not().get());
+        assertFalse(a.and(b).get());
+        assertTrue(a.or(b.not()).get());
+        assertTrue(Bindings.equal(a, b).get());
+        assertFalse(Bindings.notEqual(a, b).get());
+        assertTrue(a.isEqualTo(b).get());
+        a.set(true);
+        assertTrue(a.isNotEqualTo(b).get());
+        assertEquals("true", a.asString().get());
+        assertEquals(Boolean.TRUE, a.asObject().get());
+    }
+
+    @Test
+    public void booleanBindingInvalidatesWhenAnOperandChanges() {
+        BooleanProperty a = new SimpleBooleanProperty(true);
+        BooleanProperty b = new SimpleBooleanProperty(true);
+        BooleanBinding and = a.and(b);
+        assertTrue(and.get());
+        Probe.Values<Boolean> changes = new Probe.Values<Boolean>();
+        and.addListener(changes);
+        b.set(false);
+        b.set(true);
+        assertEquals("[true->false, false->true]", changes.log.toString());
+    }
+
+    @Test
+    public void whenThenOtherwise() {
+        BooleanProperty condition = new SimpleBooleanProperty(true);
+        NumberBinding number = Bindings.when(condition).then(i).otherwise(l);
+        assertEquals(6, number.intValue());
+        assertTrue(number instanceof LongBinding);
+        condition.set(false);
+        assertEquals(4, number.intValue());
+        l.set(40);
+        assertEquals(40, number.intValue());
+        condition.set(true);
+        i.set(60);
+        assertEquals(60, number.intValue());
+
+        NumberBinding constants = Bindings.when(condition).then(1).otherwise(2);
+        assertTrue(constants instanceof IntegerBinding);
+        assertEquals(1, constants.intValue());
+        condition.set(false);
+        assertEquals(2, constants.intValue());
+        DoubleBinding mixed = Bindings.when(condition).then(i).otherwise(0.5);
+        assertEquals(0.5, mixed.get(), 0d);
+
+        StringProperty yes = new SimpleStringProperty("yes");
+        StringBinding text = Bindings.when(condition).then(yes).otherwise("no");
+        assertEquals("no", text.get());
+        condition.set(true);
+        assertEquals("yes", text.get());
+        yes.set("YES");
+        assertEquals("YES", text.get());
+        assertEquals("a", Bindings.when(condition).then("a").otherwise("b").get());
+
+        BooleanBinding flag = Bindings.when(condition).then(false).otherwise(true);
+        assertFalse(flag.get());
+        BooleanProperty other = new SimpleBooleanProperty(true);
+        assertTrue(Bindings.when(condition).then(other).otherwise(false).get());
+
+        ObjectProperty<List<String>> list = new SimpleObjectProperty<List<String>>(new ArrayList<String>());
+        ObjectBinding<List<String>> object = Bindings.when(condition).then(list).otherwise((List<String>) null);
+        assertSame(list.get(), object.get());
+        condition.set(false);
+        assertNull(object.get());
+    }
+
+    @Test
+    public void whenInvalidatesOnConditionChange() {
+        BooleanProperty condition = new SimpleBooleanProperty(true);
+        NumberBinding binding = Bindings.when(condition).then(1).otherwise(2);
+        binding.intValue();
+        Probe.Invalidations probe = new Probe.Invalidations();
+        binding.addListener(probe);
+        condition.set(false);
+        assertEquals(1, probe.count);
+    }
+
+    @Test
+    public void stringConcatAndConvert() {
+        StringProperty name = new SimpleStringProperty("World");
+        StringExpression greeting = Bindings.concat("Hello ", name, "! ", i);
+        assertEquals("Hello World! 6", greeting.get());
+        name.set("FX");
+        i.set(7);
+        assertEquals("Hello FX! 7", greeting.get());
+        assertEquals("FX7", name.concat(i).get());
+        assertEquals("FX-", name.concat("-").get());
+        assertEquals("7", Bindings.convert(i).get());
+        assertEquals("7", i.asString().get());
+        StringExpression converted = Bindings.convert(d);
+        d.set(1.25);
+        assertEquals("1.25", converted.get());
+        name.set(null);
+        assertEquals("null-", name.concat("-").get());
+        assertEquals("", name.getValueSafe());
+    }
+
+    @Test
+    public void stringFormat() {
+        StringProperty name = new SimpleStringProperty("x");
+        StringExpression formatted = Bindings.format("%s=%d", name, i);
+        assertEquals("x=6", formatted.get());
+        i.set(8);
+        assertEquals("x=8", formatted.get());
+        assertEquals("[8]", i.asString("[%d]").get());
+    }
+
+    @Test
+    public void stringComparisons() {
+        StringProperty a = new SimpleStringProperty("apple");
+        StringProperty b = new SimpleStringProperty("Banana");
+        assertFalse(Bindings.equal(a, b).get());
+        assertTrue(Bindings.notEqual(a, b).get());
+        assertTrue(Bindings.equal(a, "apple").get());
+        assertTrue(Bindings.equal("apple", a).get());
+        assertTrue(Bindings.equalIgnoreCase(a, "APPLE").get());
+        assertFalse(Bindings.notEqualIgnoreCase(a, "APPLE").get());
+        assertTrue(Bindings.notEqualIgnoreCase(a, b).get());
+        assertTrue(Bindings.greaterThan(a, b).get());
+        assertTrue(Bindings.lessThan(b, a).get());
+        assertTrue(Bindings.greaterThanOrEqual(a, "apple").get());
+        assertTrue(Bindings.lessThanOrEqual("apple", a).get());
+        assertTrue(a.isEqualTo("apple").get());
+        assertTrue(a.isNotEqualTo(b).get());
+        assertTrue(a.isEqualToIgnoreCase("Apple").get());
+        assertTrue(a.isNotEqualToIgnoreCase(b).get());
+        assertTrue(a.greaterThan("aardvark").get());
+        assertTrue(a.lessThan("b").get());
+        assertTrue(a.greaterThanOrEqualTo(a).get());
+        assertTrue(a.lessThanOrEqualTo("apple").get());
+        StringProperty empty = new SimpleStringProperty();
+        assertTrue("null counts as empty", Bindings.equal(empty, "").get());
+        BooleanBinding equal = a.isEqualTo(b);
+        b.set("apple");
+        assertTrue(equal.get());
+    }
+
+    @Test
+    public void stringLengthAndEmptiness() {
+        StringProperty s = new SimpleStringProperty();
+        assertTrue(s.isNull().get());
+        assertFalse(s.isNotNull().get());
+        assertTrue(s.isEmpty().get());
+        assertFalse(s.isNotEmpty().get());
+        assertEquals(0, s.length().get());
+        IntegerBinding length = s.length();
+        BooleanBinding isEmpty = s.isEmpty();
+        s.set("abc");
+        assertEquals(3, length.get());
+        assertFalse(isEmpty.get());
+        assertTrue(s.isNotNull().get());
+        assertTrue(s.isNotEmpty().get());
+        s.set("");
+        assertTrue(isEmpty.get());
+        assertFalse(s.isNull().get());
+    }
+
+    @Test
+    public void objectComparisonsAndNullChecks() {
+        ObjectProperty<String> a = new SimpleObjectProperty<String>("x");
+        ObjectProperty<String> b = new SimpleObjectProperty<String>("y");
+        assertFalse(Bindings.equal(a, b).get());
+        assertTrue(Bindings.notEqual(a, b).get());
+        assertTrue(Bindings.equal(a, "x").get());
+        assertTrue(Bindings.equal("y", b).get());
+        assertTrue(Bindings.notEqual(a, "z").get());
+        assertTrue(Bindings.notEqual("z", a).get());
+        assertFalse(Bindings.isNull(a).get());
+        assertTrue(Bindings.isNotNull(a).get());
+        BooleanBinding isNull = a.isNull();
+        BooleanBinding equal = a.isEqualTo(b);
+        a.set(null);
+        assertTrue(isNull.get());
+        assertFalse(a.isNotNull().get());
+        assertFalse(equal.get());
+        b.set(null);
+        assertTrue("two nulls are equal", equal.get());
+        assertTrue(a.isEqualTo((Object) null).get());
+        assertTrue(a.isNotEqualTo("x").get());
+        a.set("v");
+        assertEquals("v", a.asString().get());
+    }
+
+    @Test
+    public void createBindingsFromCallables() {
+        final IntegerProperty source = new SimpleIntegerProperty(3);
+        IntegerBinding integer = Bindings.createIntegerBinding(new Callable<Integer>() {
+            @Override
+            public Integer call() {
+                return Integer.valueOf(source.get() * 2);
+            }
+        }, source);
+        assertEquals(6, integer.get());
+        source.set(5);
+        assertEquals(10, integer.get());
+        assertEquals(1, integer.getDependencies().size());
+        assertSame(source, integer.getDependencies().get(0));
+        DoubleBinding dbl = Bindings.createDoubleBinding(() -> source.get() / 2.0, source);
+        assertEquals(2.5, dbl.get(), 0d);
+        LongBinding lng = Bindings.createLongBinding(() -> (long) source.get() << 33, source);
+        assertEquals(5L << 33, lng.get());
+        FloatBinding flt = Bindings.createFloatBinding(() -> source.get() + 0.5f, source);
+        assertEquals(5.5f, flt.get(), 0f);
+        BooleanBinding bool = Bindings.createBooleanBinding(() -> source.get() > 4, source);
+        assertTrue(bool.get());
+        StringBinding str = Bindings.createStringBinding(() -> "n" + source.get(), source);
+        assertEquals("n5", str.get());
+        ObjectBinding<List<Integer>> obj = Bindings.createObjectBinding(() -> {
+            List<Integer> result = new ArrayList<Integer>();
+            result.add(Integer.valueOf(source.get()));
+            return result;
+        }, source);
+        assertEquals("[5]", obj.get().toString());
+        source.set(1);
+        assertEquals(0.5, dbl.get(), 0d);
+        assertFalse(bool.get());
+        assertEquals("n1", str.get());
+        assertEquals("[1]", obj.get().toString());
+        assertEquals(0, Bindings.createIntegerBinding(() -> 1).getDependencies().size());
+    }
+
+    @Test
+    public void disposeStopsObserving() {
+        final IntegerProperty source = new SimpleIntegerProperty(3);
+        IntegerBinding binding = Bindings.createIntegerBinding(() -> source.get(), source);
+        assertEquals(3, binding.get());
+        Probe.Invalidations probe = new Probe.Invalidations();
+        binding.addListener(probe);
+        binding.dispose();
+        source.set(4);
+        assertEquals(0, probe.count);
+        assertEquals("the cached value stays", 3, binding.get());
+    }
+
+    @Test
+    public void listBindings() {
+        ObservableList<String> list = FXCollections.observableArrayList("a", "b");
+        IntegerBinding size = Bindings.size(list);
+        BooleanBinding empty = Bindings.isEmpty(list);
+        BooleanBinding notEmpty = Bindings.isNotEmpty(list);
+        ObjectBinding<String> second = Bindings.valueAt(list, 1);
+        IntegerProperty index = new SimpleIntegerProperty(0);
+        ObjectBinding<String> indexed = Bindings.valueAt(list, index);
+        assertEquals(2, size.get());
+        assertFalse(empty.get());
+        assertTrue(notEmpty.get());
+        assertEquals("b", second.get());
+        assertEquals("a", indexed.get());
+        index.set(1);
+        assertEquals("b", indexed.get());
+        index.set(5);
+        assertNull("outside the list is null", indexed.get());
+        list.remove(1);
+        assertEquals(1, size.get());
+        assertNull(second.get());
+        list.clear();
+        assertTrue(empty.get());
+        assertFalse(notEmpty.get());
+        assertEquals(0, size.get());
+    }
+
+    @Test
+    public void setAndMapBindings() {
+        ObservableSet<String> set = FXCollections.observableSet(new HashSet<String>());
+        IntegerBinding setSize = Bindings.size(set);
+        BooleanBinding setEmpty = Bindings.isEmpty(set);
+        assertTrue(setEmpty.get());
+        set.add("a");
+        assertEquals(1, setSize.get());
+        assertFalse(setEmpty.get());
+        assertTrue(Bindings.isNotEmpty(set).get());
+
+        ObservableMap<String, Integer> map = FXCollections.observableHashMap();
+        IntegerBinding mapSize = Bindings.size(map);
+        BooleanBinding mapEmpty = Bindings.isEmpty(map);
+        ObjectBinding<Integer> value = Bindings.valueAt(map, "k");
+        StringProperty key = new SimpleStringProperty("k");
+        ObjectBinding<Integer> keyed = Bindings.valueAt(map, key);
+        assertTrue(mapEmpty.get());
+        assertNull(value.get());
+        map.put("k", Integer.valueOf(1));
+        map.put("j", Integer.valueOf(2));
+        assertEquals(2, mapSize.get());
+        assertFalse(mapEmpty.get());
+        assertTrue(Bindings.isNotEmpty(map).get());
+        assertEquals(Integer.valueOf(1), value.get());
+        assertEquals(Integer.valueOf(1), keyed.get());
+        key.set("j");
+        assertEquals(Integer.valueOf(2), keyed.get());
+        map.remove("k");
+        assertNull(value.get());
+    }
+
+    @Test
+    public void bidirectionalBindingThroughAConverter() {
+        StringProperty text = new SimpleStringProperty("0");
+        ObjectProperty<Integer> number = new SimpleObjectProperty<Integer>(Integer.valueOf(12));
+        Bindings.bindBidirectional(text, number, new IntegerStringConverter());
+        assertEquals("12", text.get());
+        number.set(Integer.valueOf(5));
+        assertEquals("5", text.get());
+        text.set("42");
+        assertEquals(Integer.valueOf(42), number.get());
+        Bindings.unbindBidirectional(text, number);
+        text.set("1");
+        assertEquals(Integer.valueOf(42), number.get());
+
+        StringProperty fluent = new SimpleStringProperty();
+        fluent.bindBidirectional(number, new IntegerStringConverter());
+        assertEquals("42", fluent.get());
+        fluent.set("7");
+        assertEquals(Integer.valueOf(7), number.get());
+        fluent.unbindBidirectional(number);
+        fluent.set("8");
+        assertEquals(Integer.valueOf(7), number.get());
+    }
+
+    @Test
+    public void staticBidirectionalBinding() {
+        StringProperty a = new SimpleStringProperty("a");
+        StringProperty b = new SimpleStringProperty("b");
+        Bindings.bindBidirectional(a, b);
+        assertEquals("b", a.get());
+        b.set("c");
+        assertEquals("c", a.get());
+        Bindings.unbindBidirectional(a, b);
+        b.set("d");
+        assertEquals("c", a.get());
+        try {
+            Bindings.bindBidirectional(a, a);
+            fail("expected IllegalArgumentException");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void bindContentOfAList() {
+        ObservableList<String> source = FXCollections.observableArrayList("a", "b");
+        List<String> target = new ArrayList<String>();
+        target.add("stale");
+        Bindings.bindContent(target, source);
+        assertEquals("[a, b]", target.toString());
+        source.add("c");
+        source.remove("a");
+        source.set(0, "B");
+        assertEquals("[B, c]", target.toString());
+        FXCollections.sort(source);
+        assertEquals(source.toString(), target.toString());
+        source.setAll("x", "y", "z");
+        assertEquals("[x, y, z]", target.toString());
+        source.remove(0, 2);
+        assertEquals("[z]", target.toString());
+        Bindings.unbindContent(target, source);
+        source.add("late");
+        assertEquals("[z]", target.toString());
+    }
+
+    @Test
+    public void bindContentOfASetAndAMap() {
+        ObservableSet<String> sourceSet = FXCollections.observableSet(new HashSet<String>());
+        sourceSet.add("a");
+        Set<String> targetSet = new HashSet<String>();
+        targetSet.add("stale");
+        Bindings.bindContent(targetSet, sourceSet);
+        assertEquals(sourceSet, targetSet);
+        sourceSet.add("b");
+        sourceSet.remove("a");
+        assertEquals(sourceSet, targetSet);
+        assertEquals(1, targetSet.size());
+        Bindings.unbindContent(targetSet, sourceSet);
+        sourceSet.add("c");
+        assertEquals(1, targetSet.size());
+
+        ObservableMap<String, Integer> sourceMap = FXCollections.observableHashMap();
+        sourceMap.put("a", Integer.valueOf(1));
+        Map<String, Integer> targetMap = new HashMap<String, Integer>();
+        targetMap.put("stale", Integer.valueOf(0));
+        Bindings.bindContent(targetMap, sourceMap);
+        assertEquals(sourceMap, targetMap);
+        sourceMap.put("a", Integer.valueOf(2));
+        sourceMap.put("b", Integer.valueOf(3));
+        sourceMap.remove("a");
+        assertEquals(sourceMap, targetMap);
+        assertEquals("{b=3}", targetMap.toString());
+        Bindings.unbindContent(targetMap, sourceMap);
+        sourceMap.clear();
+        assertEquals("{b=3}", targetMap.toString());
+    }
+
+    @Test
+    public void bindContentBidirectional() {
+        ObservableList<String> a = FXCollections.observableArrayList("a");
+        ObservableList<String> b = FXCollections.observableArrayList("b", "c");
+        Bindings.bindContentBidirectional(a, b);
+        assertEquals("[b, c]", a.toString());
+        a.add("d");
+        assertEquals("[b, c, d]", b.toString());
+        b.remove("b");
+        assertEquals("[c, d]", a.toString());
+        a.set(0, "C");
+        assertEquals("[C, d]", b.toString());
+        Bindings.unbindContentBidirectional(a, b);
+        a.add("e");
+        assertEquals("[C, d]", b.toString());
+        b.clear();
+        assertEquals("[C, d, e]", a.toString());
+    }
+
+    @Test
+    public void expressionFactoriesReturnTheValueItself() {
+        assertSame(i, javafx.beans.binding.IntegerExpression.integerExpression(i));
+        assertSame(d, javafx.beans.binding.NumberExpressionBase.numberExpression(d));
+        StringProperty s = new SimpleStringProperty("s");
+        assertSame(s, StringExpression.stringExpression(s));
+        assertEquals("6", StringExpression.stringExpression(i).get());
+        assertEquals(Integer.valueOf(6), i.asObject().get());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ButtonBarAndMnemonicsTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ButtonBarAndMnemonicsTest.java
new file mode 100644
index 00000000000..07f331196b0
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ButtonBarAndMnemonicsTest.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Mnemonics;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonBar;
+import javafx.scene.control.ButtonBar.ButtonData;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.layout.Region;
+
+/// A button bar places its buttons in a row at the right; the mark of a
+/// mnemonic is taken out of the text a control shows; the columns of a
+/// constrained table share its width.
+public class ButtonBarAndMnemonicsTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+    }
+
+    private static Region box(double width) {
+        Region r = new Region();
+        r.setPrefSize(width, 20);
+        return r;
+    }
+
+    @Test
+    public void buttonsKeepTheirOrderAtTheRightAndShareAWidth() {
+        ButtonBar bar = new ButtonBar();
+        assertEquals(ButtonBar.BUTTON_ORDER_NONE, bar.getButtonOrder());
+        Region ok = box(40);
+        Region cancel = box(120);
+        bar.getButtons().addAll(ok, cancel);
+        assertEquals(250, bar.prefWidth(-1), 0.01);
+        assertEquals(20, bar.prefHeight(-1), 0.01);
+        bar.resize(400, 30);
+        bar.layout();
+        // Both are as wide as the wider, the last ends at the right edge.
+        assertEquals(120, ok.getWidth(), 0.01);
+        assertEquals(120, cancel.getWidth(), 0.01);
+        assertEquals(280, cancel.getLayoutX(), 0.01);
+        assertEquals(150, ok.getLayoutX(), 0.01);
+        assertEquals(5, ok.getLayoutY(), 0.01);
+
+        // A button that is not uniform keeps its own width.
+        assertTrue(ButtonBar.isButtonUniformSize(ok));
+        ButtonBar.setButtonUniformSize(ok, false);
+        assertFalse(ButtonBar.isButtonUniformSize(ok));
+        bar.requestLayout();
+        bar.layout();
+        assertEquals(40, ok.getWidth(), 0.01);
+        assertEquals(230, ok.getLayoutX(), 0.01);
+
+        bar.setButtonMinWidth(200);
+        bar.layout();
+        assertEquals(200, cancel.getWidth(), 0.01);
+        assertEquals(40, ok.getWidth(), 0.01);
+    }
+
+    @Test
+    public void anOrderSortsTheKindsAndPutsTheLeftOnesAtTheLeft() {
+        ButtonBar bar = new ButtonBar(ButtonBar.BUTTON_ORDER_WINDOWS);
+        Region cancel = box(50);
+        Region ok = box(50);
+        Region help = box(50);
+        Region left = box(50);
+        Region plain = box(50);
+        assertNull(ButtonBar.getButtonData(ok));
+        ButtonBar.setButtonData(cancel, ButtonData.CANCEL_CLOSE);
+        ButtonBar.setButtonData(ok, ButtonData.OK_DONE);
+        ButtonBar.setButtonData(help, ButtonData.HELP);
+        ButtonBar.setButtonData(left, ButtonData.LEFT);
+        assertEquals(ButtonData.OK_DONE, ButtonBar.getButtonData(ok));
+        bar.getButtons().addAll(cancel, ok, help, left, plain);
+        bar.resize(500, 20);
+        bar.layout();
+        // L_E+U+FBXI_YNOCAH_R: left, then other, ok, cancel and help.
+        assertEquals(0, left.getLayoutX(), 0.01);
+        assertEquals(450, help.getLayoutX(), 0.01);
+        assertEquals(390, cancel.getLayoutX(), 0.01);
+        assertEquals(330, ok.getLayoutX(), 0.01);
+        assertEquals(270, plain.getLayoutX(), 0.01);
+        ButtonBar.setButtonData(ok, null);
+        assertNull(ButtonBar.getButtonData(ok));
+    }
+
+    @Test
+    public void constrainedColumnsShareTheWidthOfTheTable() {
+        TableView<String> table = new TableView<String>();
+        assertTrue(table.getColumnResizePolicy() == TableView.UNCONSTRAINED_RESIZE_POLICY);
+        TableColumn<String, String> a = new TableColumn<String, String>("A");
+        TableColumn<String, String> b = new TableColumn<String, String>("B");
+        TableColumn<String, String> hidden = new TableColumn<String, String>("C");
+        a.setPrefWidth(100);
+        b.setPrefWidth(300);
+        hidden.setVisible(false);
+        table.getColumns().add(a);
+        table.getColumns().add(b);
+        table.getColumns().add(hidden);
+        table.resize(802, 200);
+        table.layout();
+        assertEquals(100, a.getWidth(), 0.01);
+        assertEquals(300, b.getWidth(), 0.01);
+
+        table.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
+        table.layout();
+        double inner = a.getWidth() + b.getWidth();
+        assertEquals(3, b.getWidth() / a.getWidth(), 0.001);
+        assertTrue(inner > 780 && inner <= 802);
+
+        // A column at its maximum keeps it and the other takes the rest.
+        b.setMaxWidth(400);
+        table.requestLayout();
+        table.layout();
+        assertEquals(400, b.getWidth(), 0.01);
+        assertEquals(inner - 400, a.getWidth(), 0.01);
+
+        TableView.ResizeFeatures<String> features = new TableView.ResizeFeatures<String>(table, a,
+                Double.valueOf(5));
+        assertTrue(features.getTable() == table);
+        assertTrue(features.getColumn() == a);
+        assertEquals(5, features.getDelta().doubleValue(), 0);
+    }
+
+    @Test
+    public void theMarkOfAMnemonicIsNotShown() {
+        assertNull(Mnemonics.strip(null));
+        assertEquals("Save", Mnemonics.strip("_Save"));
+        assertEquals("Save As", Mnemonics.strip("Save _As"));
+        assertEquals("a_b", Mnemonics.strip("a__b"));
+        assertEquals("Open_file", Mnemonics.strip("_Open_file"));
+        assertEquals("Print", Mnemonics.strip("Print_(p)"));
+        assertEquals("end_", Mnemonics.strip("end_"));
+        assertEquals("plain", Mnemonics.strip("plain"));
+
+        // Buttons parse mnemonics, labels do not, as in JavaFX.
+        Button button = new Button("_Go");
+        assertTrue(button.isMnemonicParsing());
+        assertTrue(new CheckBox().isMnemonicParsing());
+        Label label = new Label("my_file");
+        assertFalse(label.isMnemonicParsing());
+        assertEquals("_Go", button.getText());
+        assertEquals("Go", ((com.codename1.ui.Label) button.cn1Native()).getText());
+        assertEquals("my_file", ((com.codename1.ui.Label) label.cn1Native()).getText());
+        button.setMnemonicParsing(false);
+        assertEquals("_Go", ((com.codename1.ui.Label) button.cn1Native()).getText());
+
+        MenuItem item = new MenuItem("_File");
+        assertTrue(item.isMnemonicParsing());
+        item.setMnemonicParsing(false);
+        assertFalse(item.mnemonicParsingProperty().get());
+    }
+
+    /// Alt with the key a text marks fires the button, wherever the focus
+    /// is; without Alt the key is only a key, and a hidden or disabled
+    /// button is passed over.
+    @Test
+    public void altWithTheMarkedKeyFiresTheButton() {
+        final java.util.List<String> log = new java.util.ArrayList<String>();
+        Button save = new Button("_Save");
+        save.setOnAction(e -> log.add("save"));
+        Button other = new Button("Sa_ve as");
+        other.setOnAction(e -> log.add("other"));
+        Button hidden = new Button("_Open");
+        hidden.setOnAction(e -> log.add("hidden"));
+        hidden.setVisible(false);
+        Button open = new Button("Reopen_(o)");
+        open.setOnAction(e -> log.add("open"));
+        CheckBox check = new CheckBox("_Bold");
+        javafx.scene.layout.VBox root = new javafx.scene.layout.VBox(save, other, hidden, open, check);
+        javafx.scene.Scene scene = new javafx.scene.Scene(root, 300, 300);
+        scene.cn1Layout(300, 300);
+        assertEquals('S', Mnemonics.key("_Save"));
+        assertEquals('V', Mnemonics.key("Sa_ve as"));
+        assertEquals('O', Mnemonics.key("Reopen_(o)"));
+        assertEquals(0, Mnemonics.key("a__b"));
+        assertEquals(0, Mnemonics.key("end_"));
+        assertEquals(0, Mnemonics.key(null));
+        try {
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.S, "s");
+            assertEquals("[]", log.toString());
+            com.codename1.fxcompat.runtime.SceneInput.setAltDown(1);
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.S, "s");
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.V, "v");
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.O, "o");
+            assertEquals("[save, other, open]", log.toString());
+            assertFalse(check.isSelected());
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.B, "b");
+            assertTrue(check.isSelected());
+            save.setDisable(true);
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.S, "s");
+            scene.cn1Key(javafx.scene.input.KeyEvent.KEY_PRESSED, javafx.scene.input.KeyCode.X, "x");
+            assertEquals("[save, other, open]", log.toString());
+        } finally {
+            com.codename1.fxcompat.runtime.SceneInput.setAltDown(0);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/CanvasTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/CanvasTest.java
new file mode 100644
index 00000000000..6d6f7eb261d
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/CanvasTest.java
@@ -0,0 +1,709 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.VPos;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.ArcType;
+import javafx.scene.shape.FillRule;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.text.TextAlignment;
+import javafx.scene.transform.Affine;
+
+/// The canvas: what its context records and what a paint replays.
+public class CanvasTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> drawn = new ArrayList<String>();
+    private final List<double[]> bounds = new ArrayList<double[]>();
+    private final List<Paint> paints = new ArrayList<Paint>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        Renderer.setTrace(null);
+        HeadlessImplementation.pixelImages = false;
+        HeadlessImplementation.rasterImages = false;
+        HeadlessImplementation.resetRaster();
+    }
+
+    /// A picture that is being computed is drawn over the canvas every
+    /// frame, with nothing cleared between. The canvas used to keep every
+    /// one of them on its list of calls: a frame of memory per call, still
+    /// referenced and so beyond any collector, until four thousand were
+    /// recorded. What it keeps now is its own image and the frame on top.
+    @Test
+    public void aPictureDrawnEveryFrameIsNotKept() {
+        Units.setScale(1);
+        // An image has a size here only when it keeps its pixels.
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        javafx.scene.image.WritableImage picture = new javafx.scene.image.WritableImage(40, 30);
+        Canvas canvas = new Canvas(40, 30);
+        GraphicsContext gc = canvas.getGraphicsContext2D();
+        java.util.List<java.lang.ref.WeakReference<Object>> frames =
+                new java.util.ArrayList<java.lang.ref.WeakReference<Object>>();
+        HeadlessImplementation.mutableImagesMade = 0;
+        for (int frame = 0; frame < 200; frame++) {
+            picture.getPixelWriter().setArgb(frame % 40, frame % 30, 0xff000000 | frame);
+            gc.drawImage(picture, 0, 0, 40, 30, 0, 0, 40, 30);
+            frames.add(new java.lang.ref.WeakReference<Object>(picture.cn1Native()));
+        }
+        // One image to draw on, however many frames went into it.
+        assertEquals(1, HeadlessImplementation.mutableImagesMade);
+        int kept = 0;
+        for (int tries = 0; tries < 20; tries++) {
+            System.gc();
+            kept = 0;
+            for (int i = 0; i < frames.size(); i++) {
+                if (frames.get(i).get() != null) {
+                    kept++;
+                }
+            }
+            if (kept <= 2) {
+                break;
+            }
+        }
+        assertTrue("the canvas keeps " + kept + " of 200 frames alive", kept <= 2);
+    }
+
+    /// Folding the frames into one image keeps what a canvas keeps: a
+    /// pixel an earlier frame drew shows through where a later frame is
+    /// transparent.
+    @Test
+    public void framesDrawnOverEachOtherKeepWhatWasUnderThem() {
+        Units.setScale(1);
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        javafx.scene.image.WritableImage picture = new javafx.scene.image.WritableImage(8, 6);
+        javafx.scene.image.PixelWriter w = picture.getPixelWriter();
+        Canvas canvas = new Canvas(8, 6);
+        GraphicsContext gc = canvas.getGraphicsContext2D();
+        w.setArgb(1, 1, 0xffff0000);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        w.setArgb(1, 1, 0);
+        w.setArgb(2, 2, 0xff0000ff);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        w.setArgb(2, 2, 0);
+        w.setArgb(3, 3, 0xff00ff00);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        w.setArgb(4, 4, 0xffffffff);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        com.codename1.ui.Image target = com.codename1.ui.Image.createImage(8, 6, 0);
+        canvas.cn1Paint(new Renderer(target.getGraphics(), 0, 0));
+        int[] seen = target.getRGB();
+        assertEquals(0xffff0000, seen[1 * 8 + 1]);
+        assertEquals(0xff0000ff, seen[2 * 8 + 2]);
+        assertEquals(0xff00ff00, seen[3 * 8 + 3]);
+        assertEquals(0xffffffff, seen[4 * 8 + 4]);
+        assertEquals(0, seen[5 * 8 + 5]);
+    }
+
+    /// The canvas image is drawn on again after it was shown. A port that
+    /// cannot draw an image at a size shows a copy the image keeps, and the
+    /// copy made for the first frame went on being shown: Mandelbrot on the
+    /// native Linux port ended on a black picture more often than not. The
+    /// canvas is drawn at two device pixels to one here, so that what is
+    /// shown is such a copy.
+    @Test
+    public void theCanvasImageDrawnOnAgainIsWhatIsShown() {
+        Units.setScale(1);
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        javafx.scene.image.WritableImage picture = new javafx.scene.image.WritableImage(8, 6);
+        javafx.scene.image.PixelWriter w = picture.getPixelWriter();
+        Canvas canvas = new Canvas(8, 6);
+        GraphicsContext gc = canvas.getGraphicsContext2D();
+        w.setArgb(1, 1, 0xffff0000);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        com.codename1.ui.Image first = com.codename1.ui.Image.createImage(16, 12, 0);
+        Renderer twice = new Renderer(first.getGraphics(), 0, 0);
+        twice.concat(2, 0, 0, 2, 0, 0);
+        canvas.cn1Paint(twice);
+        assertEquals(0xffff0000, first.getRGB()[2 * 16 + 2]);
+        assertEquals(0, first.getRGB()[6 * 16 + 6]);
+        w.setArgb(3, 3, 0xff0000ff);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+        com.codename1.ui.Image second = com.codename1.ui.Image.createImage(16, 12, 0);
+        twice = new Renderer(second.getGraphics(), 0, 0);
+        twice.concat(2, 0, 0, 2, 0, 0);
+        canvas.cn1Paint(twice);
+        assertEquals(0xffff0000, second.getRGB()[2 * 16 + 2]);
+        assertEquals(0xff0000ff, second.getRGB()[6 * 16 + 6]);
+    }
+
+    /// The canvas image is drawn on again and again, and a port may hand
+    /// out the one graphics it keeps for an image each time: a clip the
+    /// last frame left there must not cut the next one.
+    @Test
+    public void aClipLeftOnTheCanvasImageDoesNotCutTheNextFrame() {
+        Units.setScale(1);
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        HeadlessImplementation.trackClip = true;
+        try {
+            javafx.scene.image.WritableImage picture = new javafx.scene.image.WritableImage(8, 6);
+            javafx.scene.image.PixelWriter w = picture.getPixelWriter();
+            Canvas canvas = new Canvas(8, 6);
+            GraphicsContext gc = canvas.getGraphicsContext2D();
+            gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+            gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+            // What a port that keeps one graphics per image would still
+            // have from the frame before.
+            com.codename1.ui.Image.createImage(1, 1, 0).getGraphics().setClip(0, 0, 2, 2);
+            w.setArgb(6, 4, 0xff00ff00);
+            gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+            gc.drawImage(picture, 0, 0, 8, 6, 0, 0, 8, 6);
+            HeadlessImplementation.trackClip = false;
+            com.codename1.ui.Image target = com.codename1.ui.Image.createImage(8, 6, 0);
+            canvas.cn1Paint(new Renderer(target.getGraphics(), 0, 0));
+            assertEquals(0xff00ff00, target.getRGB()[4 * 8 + 6]);
+        } finally {
+            HeadlessImplementation.trackClip = false;
+        }
+    }
+
+    private void paint(Canvas canvas) {
+        drawn.clear();
+        bounds.clear();
+        paints.clear();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                drawn.add(text == null ? operation : operation + ":" + text);
+                bounds.add(deviceBounds);
+                paints.add(paint);
+            }
+        });
+        canvas.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(400, 400, 0).getGraphics(), 0, 0));
+        Renderer.setTrace(null);
+    }
+
+    private void device(int index, double minX, double minY, double maxX, double maxY) {
+        double[] b = bounds.get(index);
+        assertEquals("minX", minX, b[0], 1e-6);
+        assertEquals("minY", minY, b[1], 1e-6);
+        assertEquals("maxX", maxX, b[2], 1e-6);
+        assertEquals("maxY", maxY, b[3], 1e-6);
+    }
+
+    @Test
+    public void canvasHasASizeAndOneContext() {
+        Canvas c = new Canvas(100, 50);
+        assertEquals(100, c.getLayoutBounds().getWidth(), 0);
+        assertEquals(50, c.getLayoutBounds().getHeight(), 0);
+        assertFalse(c.isResizable());
+        GraphicsContext gc = c.getGraphicsContext2D();
+        assertSame(gc, c.getGraphicsContext2D());
+        assertSame(c, gc.getCanvas());
+        c.setWidth(10);
+        assertEquals(10, c.getLayoutBounds().getWidth(), 0);
+        paint(new Canvas());
+        assertTrue(drawn.isEmpty());
+    }
+
+    @Test
+    public void whatWasDrawnIsReplayedOnEveryPaint() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.setFill(Color.RED);
+        gc.fillRect(10, 10, 20, 20);
+        gc.save();
+        gc.translate(50, 0);
+        gc.scale(2, 2);
+        gc.setFill(Color.BLUE);
+        gc.setStroke(Color.GREEN);
+        gc.fillRect(0, 0, 5, 5);
+        gc.restore();
+        // The state from before the save is back.
+        assertSame(Color.RED, gc.getFill());
+        assertSame(Color.BLACK, gc.getStroke());
+        gc.fillOval(0, 50, 10, 10);
+        gc.strokeLine(0, 0, 10, 0);
+        gc.fillText("hi", 1, 20);
+
+        for (int pass = 0; pass < 2; pass++) {
+            paint(c);
+            assertEquals(5, drawn.size());
+            assertEquals("fill", drawn.get(0));
+            assertSame(Color.RED, paints.get(0));
+            device(0, 20, 20, 60, 60);
+            assertEquals("fill", drawn.get(1));
+            // Recorded with the transform and paint of the moment.
+            assertSame(Color.BLUE, paints.get(1));
+            device(1, 100, 0, 120, 20);
+            assertEquals("fill", drawn.get(2));
+            assertSame(Color.RED, paints.get(2));
+            assertEquals(0, bounds.get(2)[0], 0.2);
+            assertEquals(120, bounds.get(2)[3], 0.2);
+            assertEquals("stroke", drawn.get(3));
+            assertSame(Color.BLACK, paints.get(3));
+            assertEquals("text:hi", drawn.get(4));
+            assertSame(Color.RED, paints.get(4));
+        }
+    }
+
+    @Test
+    public void restoreWithoutSaveIsIgnored() {
+        Canvas c = new Canvas(10, 10);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.setLineWidth(3);
+        gc.restore();
+        assertEquals(3, gc.getLineWidth(), 0);
+        gc.save();
+        gc.save();
+        gc.setLineWidth(5);
+        gc.restore();
+        assertEquals(3, gc.getLineWidth(), 0);
+        gc.setLineWidth(7);
+        gc.restore();
+        assertEquals(3, gc.getLineWidth(), 0);
+    }
+
+    @Test
+    public void attributesKeepJavaFxDefaultsAndRejectNonsense() {
+        GraphicsContext gc = new Canvas(10, 10).getGraphicsContext2D();
+        assertSame(Color.BLACK, gc.getFill());
+        assertSame(Color.BLACK, gc.getStroke());
+        assertEquals(1, gc.getLineWidth(), 0);
+        assertEquals(StrokeLineCap.SQUARE, gc.getLineCap());
+        assertEquals(StrokeLineJoin.MITER, gc.getLineJoin());
+        assertEquals(10, gc.getMiterLimit(), 0);
+        assertEquals(1, gc.getGlobalAlpha(), 0);
+        assertEquals(TextAlignment.LEFT, gc.getTextAlign());
+        assertEquals(VPos.BASELINE, gc.getTextBaseline());
+        assertEquals(FillRule.NON_ZERO, gc.getFillRule());
+        assertNull(gc.getLineDashes());
+        assertEquals(0, gc.getLineDashOffset(), 0);
+
+        gc.setLineWidth(-1);
+        gc.setLineWidth(Double.NaN);
+        assertEquals(1, gc.getLineWidth(), 0);
+        gc.setFill(null);
+        gc.setStroke(null);
+        gc.setLineCap(null);
+        gc.setFont(null);
+        assertSame(Color.BLACK, gc.getFill());
+        assertEquals(StrokeLineCap.SQUARE, gc.getLineCap());
+        gc.setGlobalAlpha(3);
+        assertEquals(1, gc.getGlobalAlpha(), 0);
+        gc.setGlobalAlpha(-1);
+        assertEquals(0, gc.getGlobalAlpha(), 0);
+        gc.setLineDashes(2, 3);
+        assertArrayEquals(new double[] {2, 3}, gc.getLineDashes(), 0);
+        gc.setLineDashes(2, -3);
+        assertNull(gc.getLineDashes());
+        gc.setLineDashes(4);
+        gc.setLineDashes();
+        assertNull(gc.getLineDashes());
+        gc.setLineDashOffset(1.5);
+        assertEquals(1.5, gc.getLineDashOffset(), 0);
+    }
+
+    @Test
+    public void transformIsReadBackAndReplaced() {
+        GraphicsContext gc = new Canvas(10, 10).getGraphicsContext2D();
+        gc.translate(3, 4);
+        gc.scale(2, 5);
+        Affine a = gc.getTransform();
+        assertEquals(2, a.getMxx(), 0);
+        assertEquals(5, a.getMyy(), 0);
+        assertEquals(3, a.getTx(), 0);
+        assertEquals(4, a.getTy(), 0);
+        Affine into = new Affine();
+        assertSame(into, gc.getTransform(into));
+        assertEquals(3, into.getTx(), 0);
+        gc.setTransform(1, 0, 0, 1, 7, 8);
+        assertEquals(7, gc.getTransform().getTx(), 0);
+        gc.rotate(90);
+        a = gc.getTransform();
+        assertEquals(0, a.getMxx(), 1e-9);
+        assertEquals(1, a.getMyx(), 1e-9);
+        assertEquals(-1, a.getMxy(), 1e-9);
+        gc.setTransform(new Affine());
+        gc.transform(new Affine(2, 0, 1, 0, 2, 1));
+        gc.transform(1, 0, 0, 1, 10, 10);
+        assertEquals(21, gc.getTransform().getTx(), 0);
+        assertEquals(21, gc.getTransform().getTy(), 0);
+    }
+
+    @Test
+    public void globalAlphaAndRotationAreRecorded() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.translate(20, 20);
+        gc.rotate(90);
+        gc.fillRect(0, 0, 10, 4);
+        paint(c);
+        // Turned a quarter clockwise about (20, 20): 4 wide, 10 tall, to the left.
+        device(0, 32, 40, 40, 60);
+    }
+
+    @Test
+    public void thePathIsBuiltInTheTransformOfEachCall() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.beginPath();
+        gc.moveTo(0, 0);
+        gc.lineTo(10, 0);
+        gc.lineTo(10, 10);
+        gc.closePath();
+        assertTrue(gc.isPointInPath(8, 2));
+        assertFalse(gc.isPointInPath(2, 8));
+        gc.fill();
+        gc.translate(10, 10);
+        gc.beginPath();
+        gc.rect(0, 0, 5, 5);
+        // The points keep the transform they were added under.
+        gc.setTransform(1, 0, 0, 1, 0, 0);
+        assertTrue(gc.isPointInPath(12, 12));
+        assertFalse(gc.isPointInPath(2, 2));
+        gc.fill();
+        gc.stroke();
+        paint(c);
+        assertEquals(3, drawn.size());
+        device(0, 0, 0, 20, 20);
+        device(1, 20, 20, 30, 30);
+        assertEquals("stroke", drawn.get(2));
+        // The path survives being drawn; beginPath empties it.
+        gc.beginPath();
+        assertFalse(gc.isPointInPath(12, 12));
+        gc.fill();
+        paint(c);
+        assertEquals(3, drawn.size());
+    }
+
+    @Test
+    public void curvesArcsAndSvgDataJoinThePath() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        // A corner at (10, 0) rounded with radius 5.
+        gc.beginPath();
+        gc.moveTo(0, 0);
+        gc.arcTo(10, 0, 10, 10, 5);
+        gc.lineTo(10, 10);
+        gc.closePath();
+        assertTrue(gc.isPointInPath(8, 3));
+        assertTrue(gc.isPointInPath(3, 0.5));
+        assertFalse(gc.isPointInPath(9.5, 0.5));
+        assertFalse(gc.isPointInPath(2, 8));
+
+        gc.beginPath();
+        gc.moveTo(0, 0);
+        gc.quadraticCurveTo(5, 10, 10, 0);
+        gc.bezierCurveTo(10, -10, 20, -10, 20, 0);
+        assertTrue(gc.isPointInPath(5, 3));
+        assertTrue(gc.isPointInPath(15, -5));
+        assertFalse(gc.isPointInPath(5, 6));
+
+        // A full ellipse, then the upper half of a circle.
+        gc.beginPath();
+        gc.arc(50, 50, 20, 10, 0, 360);
+        assertTrue(gc.isPointInPath(68, 50));
+        assertFalse(gc.isPointInPath(50, 61));
+        gc.beginPath();
+        gc.arc(50, 50, 10, 10, 0, 180);
+        assertTrue(gc.isPointInPath(50, 45));
+        assertFalse(gc.isPointInPath(50, 55));
+
+        gc.beginPath();
+        gc.appendSVGPath("M0 0 h10 v10 z");
+        assertTrue(gc.isPointInPath(8, 2));
+        assertFalse(gc.isPointInPath(2, 8));
+        gc.beginPath();
+        gc.moveTo(20, 20);
+        gc.appendSVGPath("l10 0 l0 10 z");
+        assertTrue(gc.isPointInPath(28, 22));
+        assertFalse(gc.isPointInPath(22, 28));
+    }
+
+    @Test
+    public void fillRuleOfThePath() {
+        GraphicsContext gc = new Canvas(100, 100).getGraphicsContext2D();
+        gc.rect(0, 0, 30, 30);
+        gc.rect(10, 10, 10, 10);
+        assertTrue(gc.isPointInPath(15, 15));
+        gc.setFillRule(FillRule.EVEN_ODD);
+        assertFalse(gc.isPointInPath(15, 15));
+        assertTrue(gc.isPointInPath(5, 5));
+    }
+
+    @Test
+    public void clipLastsUntilRestore() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.fillRect(0, 0, 1, 1);
+        gc.save();
+        gc.beginPath();
+        gc.rect(10, 10, 20, 20);
+        gc.clip();
+        gc.fillRect(0, 0, 50, 50);
+        gc.strokeRect(0, 0, 50, 50);
+        gc.restore();
+        gc.fillRect(0, 0, 2, 2);
+        paint(c);
+        assertEquals("[fill, clip, fill, clip, stroke, fill]", drawn.toString());
+        device(1, 20, 20, 60, 60);
+        device(2, 0, 0, 100, 100);
+    }
+
+    @Test
+    public void shapeCallsRecordOneOperationEach() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.fillRoundRect(0, 0, 20, 10, 4, 4);
+        gc.strokeRoundRect(0, 0, 20, 10, 4, 4);
+        gc.strokeOval(0, 0, 10, 10);
+        gc.fillArc(0, 0, 20, 20, 0, 90, ArcType.ROUND);
+        gc.strokeArc(0, 0, 20, 20, 0, 90, ArcType.OPEN);
+        gc.fillPolygon(new double[] {0, 10, 10}, new double[] {0, 0, 10}, 3);
+        gc.strokePolygon(new double[] {0, 10, 10}, new double[] {0, 0, 10}, 3);
+        gc.strokePolyline(new double[] {0, 10, 10}, new double[] {0, 0, 10}, 3);
+        gc.strokeText("s", 0, 10);
+        gc.drawImage(null, 0, 0);
+        paint(c);
+        assertEquals("[fill, stroke, stroke, fill, stroke, fill, stroke, stroke, text:s]", drawn.toString());
+        assertEquals(0, bounds.get(0)[0], 0.2);
+        assertEquals(40, bounds.get(0)[2], 0.2);
+        assertEquals(20, bounds.get(0)[3], 0.2);
+        // The pie slice: centre (10, 10), up and to the right.
+        assertEquals(20, bounds.get(3)[0], 0.2);
+        assertEquals(0, bounds.get(3)[1], 0.2);
+        assertEquals(40, bounds.get(3)[2], 0.2);
+        assertEquals(20, bounds.get(3)[3], 0.2);
+        device(5, 0, 0, 20, 20);
+    }
+
+    @Test
+    public void textIsPlacedByAlignmentAndBaseline() {
+        Canvas c = new Canvas(200, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.setTextBaseline(VPos.TOP);
+        gc.fillText("abcd", 50, 10);
+        gc.setTextAlign(TextAlignment.CENTER);
+        gc.fillText("abcd", 50, 10);
+        gc.setTextAlign(TextAlignment.RIGHT);
+        gc.fillText("abcd", 50, 10);
+        gc.setTextAlign(TextAlignment.LEFT);
+        gc.setTextBaseline(VPos.BASELINE);
+        gc.fillText("abcd", 50, 10);
+        gc.setTextBaseline(VPos.BOTTOM);
+        gc.fillText("abcd", 50, 10);
+        gc.setTextBaseline(VPos.TOP);
+        gc.fillText("ab\ncd", 50, 10);
+        gc.fillText("", 0, 0);
+        gc.fillText(null, 0, 0);
+        paint(c);
+        assertEquals(7, drawn.size());
+        double width = bounds.get(0)[2] - bounds.get(0)[0];
+        double height = bounds.get(0)[3] - bounds.get(0)[1];
+        assertTrue(width > 0);
+        assertEquals(100, bounds.get(0)[0], 1e-6);
+        assertEquals(20, bounds.get(0)[1], 1e-6);
+        assertEquals(100 - width / 2, bounds.get(1)[0], 1e-6);
+        assertEquals(100 - width, bounds.get(2)[0], 1e-6);
+        // The baseline is below the top of the text, the bottom lower still.
+        assertTrue(bounds.get(3)[1] < 20);
+        assertTrue(bounds.get(4)[1] < bounds.get(3)[1]);
+        assertEquals(20 - height, bounds.get(4)[1], 1e-6);
+        assertEquals("text:ab", drawn.get(5));
+        assertEquals("text:cd", drawn.get(6));
+        assertEquals(20 + height, bounds.get(6)[1], 1e-6);
+    }
+
+    @Test
+    public void maximumWidthShrinksText() {
+        Canvas c = new Canvas(200, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.fillText("abcdefgh", 0, 20);
+        paint(c);
+        double full = bounds.get(0)[2] - bounds.get(0)[0];
+        gc.fillText("abcdefgh", 0, 40, full / 2 / 2);
+        gc.fillText("abcdefgh", 0, 60, full * 4);
+        gc.fillText("abcdefgh", 0, 80, 0);
+        paint(c);
+        // A maximum of nothing draws nothing. The headless port measures
+        // every font size alike, so the smaller font cannot be seen here.
+        assertEquals(3, drawn.size());
+        assertEquals(full, bounds.get(2)[2] - bounds.get(2)[0], 1e-6);
+    }
+
+    @Test
+    public void clearingTheWholeCanvasEmptiesTheList() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        for (int frame = 0; frame < 3; frame++) {
+            gc.clearRect(0, 0, c.getWidth(), c.getHeight());
+            gc.fillRect(frame, 0, 10, 10);
+            gc.strokeLine(0, 0, 50, 50);
+            paint(c);
+            assertEquals("[fill, stroke]", drawn.toString());
+        }
+        gc.clearRect(-5, -5, 500, 500);
+        paint(c);
+        assertTrue(drawn.isEmpty());
+    }
+
+    @Test
+    public void clearingAPartRemovesWhatLiesInsideIt() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.setFill(Color.RED);
+        gc.fillRect(0, 0, 10, 10);
+        gc.setFill(Color.BLUE);
+        gc.fillRect(50, 50, 10, 10);
+        gc.clearRect(40, 40, 30, 30);
+        paint(c);
+        assertEquals("[fill]", drawn.toString());
+        assertSame(Color.RED, paints.get(0));
+        // Clearing where nothing was drawn changes nothing.
+        gc.clearRect(60, 60, 10, 10);
+        paint(c);
+        assertEquals("[fill]", drawn.toString());
+        // Cutting into a call turns what was drawn into one picture.
+        gc.clearRect(5, 5, 20, 20);
+        paint(c);
+        assertEquals("[image]", drawn.toString());
+        device(0, 0, 0, 200, 200);
+        gc.fillRect(1, 1, 1, 1);
+        paint(c);
+        assertEquals("[image, fill]", drawn.toString());
+        gc.clearRect(0, 0, 100, 100);
+        paint(c);
+        assertTrue(drawn.isEmpty());
+    }
+
+    @Test
+    public void aClipInForceKeepsAClearFromEmptyingTheList() {
+        Canvas c = new Canvas(100, 100);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.fillRect(0, 0, 10, 10);
+        gc.save();
+        gc.beginPath();
+        gc.rect(50, 50, 10, 10);
+        gc.clip();
+        gc.clearRect(0, 0, 100, 100);
+        gc.restore();
+        paint(c);
+        assertEquals(1, drawn.size());
+    }
+
+    @Test
+    public void theListIsCappedByTurningItIntoAPicture() {
+        Canvas c = new Canvas(20, 20);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        for (int i = 0; i < GraphicsContext.CN1_MAX_RECORDED_CALLS + 10; i++) {
+            gc.fillRect(i % 10, 0, 1, 1);
+        }
+        paint(c);
+        assertEquals(10, drawn.size());
+        assertEquals("image", drawn.get(0));
+        device(0, 0, 0, 40, 40);
+        assertEquals("fill", drawn.get(9));
+    }
+
+    /// The Mandelbrot sample on a display whose density is not whole: it
+    /// keeps what was drawn in an image of `(int) width` pixels, draws it
+    /// back with the width itself, and computes only what lies beyond
+    /// that width. The fraction of a pixel between the two was left
+    /// undrawn, a line across the picture.
+    @Test
+    public void aSourceAFractionWiderThanTheImageStillFillsItsDestination() {
+        HeadlessImplementation.pixelImages = true;
+        Canvas c = new Canvas(100, 100);
+        javafx.scene.image.WritableImage kept = new javafx.scene.image.WritableImage(50, 40);
+        kept.getPixelWriter().setArgb(0, 0, 0xff102030);
+        GraphicsContext gc = c.getGraphicsContext2D();
+        gc.drawImage(kept, 0, 0, 50.8, 40.6, 0, 0, 50.8, 40.6);
+        paint(c);
+        assertEquals("[image]", drawn.toString());
+        // At two device pixels to one, each edge on the nearest of them.
+        device(0, 0, 0, 102, 81);
+
+        // More than a pixel past the edge is not there to be drawn.
+        gc.clearRect(0, 0, 100, 100);
+        gc.drawImage(kept, 0, 0, 60, 40, 0, 0, 60, 40);
+        paint(c);
+        device(drawn.size() - 1, 0, 0, 100, 80);
+    }
+
+    /// A picture drawn whole through the call that names a source
+    /// rectangle is the picture itself: one image of the platform for the
+    /// pixels, and none for a part that is all of it. There were two a
+    /// call, which a port that never frees an image keeps for good.
+    @Test
+    public void aPictureDrawnWholeIsNotCutOutOfItself() {
+        Units.setScale(1);
+        boolean before = HeadlessImplementation.rasterImages;
+        // An image has a size here only when it keeps its pixels.
+        HeadlessImplementation.rasterImages = true;
+        try {
+            javafx.scene.image.WritableImage picture = new javafx.scene.image.WritableImage(40, 30);
+            Canvas canvas = new Canvas(40, 30);
+            GraphicsContext gc = canvas.getGraphicsContext2D();
+            HeadlessImplementation.imagesMade = 0;
+            for (int frame = 0; frame < 10; frame++) {
+                picture.getPixelWriter().setArgb(frame, frame, 0xff000000 | frame);
+                gc.drawImage(picture, 0, 0, 40, 30, 0, 0, 40, 30);
+            }
+            assertEquals(10, HeadlessImplementation.imagesMade);
+        } finally {
+            HeadlessImplementation.rasterImages = before;
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ChartTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ChartTest.java
new file mode 100644
index 00000000000..b3b28206082
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ChartTest.java
@@ -0,0 +1,933 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Side;
+import javafx.scene.chart.AreaChart;
+import javafx.scene.chart.BarChart;
+import javafx.scene.chart.CategoryAxis;
+import javafx.scene.chart.Chart;
+import javafx.scene.chart.LineChart;
+import javafx.scene.chart.NumberAxis;
+import javafx.scene.chart.PieChart;
+import javafx.scene.chart.ScatterChart;
+import javafx.scene.chart.XYChart;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+
+/// The charts draw themselves: what is asserted here is what reaches the
+/// renderer - the bars, lines, slices and words - and the model the
+/// application reads back.
+public class ChartTest {
+
+    private static final Color FIRST = Color.web("#f3622d");
+    private static final Color SECOND = Color.web("#fba71b");
+    private static final Color PLOT = Color.web("#f4f4f4");
+    private static final Color AXIS = Color.web("#c3c3c3");
+    private static final Color GRID = Color.web("#dbdbdb");
+    private static final Color LEGEND = Color.web("#f5f5f5");
+    /// The line height and character width of the headless font.
+    private static final double LINE = 32;
+    private static final double CHAR = 16;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> operations = new ArrayList<String>();
+    private final List<double[]> bounds = new ArrayList<double[]>();
+    private final List<Paint> paints = new ArrayList<Paint>();
+    private final List<String> words = new ArrayList<String>();
+    private final List<String> texts = new ArrayList<String>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        Renderer.setTrace(null);
+    }
+
+    private void paint(Chart chart) {
+        paint(chart, 800, 600);
+    }
+
+    private void paint(Chart chart, int width, int height) {
+        operations.clear();
+        bounds.clear();
+        paints.clear();
+        words.clear();
+        texts.clear();
+        chart.resize(width, height);
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                operations.add(operation);
+                bounds.add(deviceBounds);
+                paints.add(paint);
+                texts.add(text);
+                if (text != null) {
+                    words.add(text);
+                }
+            }
+        });
+        chart.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(width, height, 0).getGraphics(), 0, 0));
+        Renderer.setTrace(null);
+    }
+
+    /// The bounds of everything drawn by an operation in a colour.
+    private List<double[]> drawn(String operation, Color color) {
+        List<double[]> out = new ArrayList<double[]>();
+        for (int i = 0; i < operations.size(); i++) {
+            if (operation.equals(operations.get(i)) && color.equals(paints.get(i)) && bounds.get(i) != null) {
+                out.add(bounds.get(i));
+            }
+        }
+        return out;
+    }
+
+    /// The box of the legend, or `null` when none was drawn.
+    private double[] legendBox() {
+        List<double[]> boxes = drawn("fill", LEGEND);
+        return boxes.isEmpty() ? null : boxes.get(0);
+    }
+
+    private static boolean inside(double[] inner, double[] outer) {
+        return outer != null && inner[0] >= outer[0] - 1 && inner[1] >= outer[1] - 1 && inner[2] <= outer[2] + 1
+                && inner[3] <= outer[3] + 1;
+    }
+
+    /// The bounds of everything filled in a colour outside the legend.
+    private List<double[]> filled(Color color) {
+        List<double[]> out = new ArrayList<double[]>();
+        double[] legend = legendBox();
+        List<double[]> all = drawn("fill", color);
+        for (int i = 0; i < all.size(); i++) {
+            if (!inside(all.get(i), legend)) {
+                out.add(all.get(i));
+            }
+        }
+        return out;
+    }
+
+    /// The bounds of everything filled in a colour inside the legend.
+    private List<double[]> legendFilled(Color color) {
+        List<double[]> out = new ArrayList<double[]>();
+        double[] legend = legendBox();
+        List<double[]> all = drawn("fill", color);
+        for (int i = 0; i < all.size(); i++) {
+            if (inside(all.get(i), legend)) {
+                out.add(all.get(i));
+            }
+        }
+        return out;
+    }
+
+    /// The rectangle of the plot of a chart of two axes.
+    private double[] plot() {
+        return drawn("fill", PLOT).get(0);
+    }
+
+    /// Where a text was drawn: the device place its drawing starts at,
+    /// which is its top left corner while it is upright.
+    private double[] word(String text) {
+        for (int i = 0; i < operations.size(); i++) {
+            if (text.equals(texts.get(i))) {
+                return bounds.get(i);
+            }
+        }
+        fail("not drawn: " + text);
+        return null;
+    }
+
+    /// The strokes in the colour of the axes of a width and height.
+    private List<double[]> marks(double width, double height) {
+        List<double[]> out = new ArrayList<double[]>();
+        List<double[]> all = drawn("stroke", AXIS);
+        for (int i = 0; i < all.size(); i++) {
+            double[] b = all.get(i);
+            if (Math.abs(b[2] - b[0] - width) < 0.01 && Math.abs(b[3] - b[1] - height) < 0.01) {
+                out.add(b);
+            }
+        }
+        return out;
+    }
+
+    private int count(String operation, Color color) {
+        int n = 0;
+        for (int i = 0; i < operations.size(); i++) {
+            if (operation.equals(operations.get(i)) && color.equals(paints.get(i))) {
+                n++;
+            }
+        }
+        return n;
+    }
+
+    private static XYChart.Series<String, Number> series(String name, double a, double b) {
+        XYChart.Series<String, Number> s = new XYChart.Series<String, Number>();
+        s.setName(name);
+        s.getData().add(new XYChart.Data<String, Number>("A", Double.valueOf(a)));
+        s.getData().add(new XYChart.Data<String, Number>("B", Double.valueOf(b)));
+        return s;
+    }
+
+    @Test
+    public void barsGrowFromZeroInProportionToTheirValues() {
+        CategoryAxis x = new CategoryAxis();
+        NumberAxis y = new NumberAxis();
+        BarChart<String, Number> chart = new BarChart<String, Number>(x, y);
+        chart.setTitle("Sales");
+        chart.getData().add(series("2023", 10, 20));
+        chart.getData().add(series("2024", 5, 15));
+        paint(chart);
+
+        // The range comes from the data, holds zero and ends on a tick
+        // beyond the data.
+        assertEquals(0, y.getLowerBound(), 0);
+        assertEquals(22.5, y.getUpperBound(), 0);
+        assertEquals(2.5, y.getTickUnit(), 0);
+
+        List<double[]> first = filled(FIRST);
+        List<double[]> second = filled(SECOND);
+        assertEquals(2, first.size());
+        assertEquals(2, second.size());
+        double a = first.get(0)[3] - first.get(0)[1];
+        double b = first.get(1)[3] - first.get(1)[1];
+        assertEquals(2, b / a, 0.02);
+        // All bars stand on the same line.
+        assertEquals(first.get(0)[3], first.get(1)[3], 0.01);
+        assertEquals(first.get(0)[3], second.get(1)[3], 0.01);
+        double c = second.get(1)[3] - second.get(1)[1];
+        assertEquals(0.75, c / b, 0.02);
+        // Category A is left of category B, and the second series is
+        // beside the first within a category.
+        assertTrue(first.get(0)[2] <= second.get(0)[0]);
+        assertTrue(second.get(0)[2] < first.get(1)[0]);
+
+        assertTrue(words.contains("Sales"));
+        assertTrue(words.contains("A"));
+        assertTrue(words.contains("B"));
+        assertTrue(words.contains("2023"));
+        assertTrue(words.contains("2024"));
+        assertTrue(words.contains("0.0"));
+        assertTrue(words.contains("20.0"));
+
+        chart.setLegendVisible(false);
+        chart.setTitle(null);
+        paint(chart);
+        assertFalse(words.contains("2023"));
+        assertFalse(words.contains("Sales"));
+    }
+
+    @Test
+    public void aBarChartLiesOnItsSideWhenTheCategoriesAreOnTheYAxis() {
+        NumberAxis x = new NumberAxis();
+        CategoryAxis y = new CategoryAxis(FXCollections.observableArrayList("A", "B"));
+        BarChart<Number, String> chart = new BarChart<Number, String>(x, y);
+        XYChart.Series<Number, String> s = new XYChart.Series<Number, String>();
+        s.getData().add(new XYChart.Data<Number, String>(Integer.valueOf(4), "A"));
+        s.getData().add(new XYChart.Data<Number, String>(Integer.valueOf(8), "B"));
+        // A category the axis does not list has no place and no bar.
+        s.getData().add(new XYChart.Data<Number, String>(Integer.valueOf(8), "C"));
+        chart.getData().add(s);
+        paint(chart);
+        List<double[]> bars = filled(FIRST);
+        assertEquals(2, bars.size());
+        assertEquals(bars.get(0)[0], bars.get(1)[0], 0.01);
+        assertEquals(2, (bars.get(1)[2] - bars.get(1)[0]) / (bars.get(0)[2] - bars.get(0)[0]), 0.02);
+        // The first category is the lower one.
+        assertTrue(bars.get(0)[1] > bars.get(1)[3]);
+    }
+
+    @Test
+    public void aBarChartNeedsOneAxisOfEachKind() {
+        try {
+            new BarChart<Number, Number>(new NumberAxis(), new NumberAxis());
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage().indexOf("CategoryAxis") >= 0);
+        }
+    }
+
+    @Test
+    public void aSeriesKnowsItsChartAndFollowsTheListItIsGiven() {
+        LineChart<Number, Number> chart = new LineChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        XYChart.Series<Number, Number> s = new XYChart.Series<Number, Number>();
+        assertNull(s.getChart());
+        chart.getData().add(s);
+        assertSame(chart, s.getChart());
+        assertSame(chart, s.chartProperty().get());
+        ObservableList<XYChart.Series<Number, Number>> other = FXCollections.observableArrayList();
+        chart.setData(other);
+        assertNull(s.getChart());
+        assertSame(other, chart.getData());
+        other.add(s);
+        assertSame(chart, s.getChart());
+        other.remove(s);
+        assertNull(s.getChart());
+        XYChart.Data<Number, Number> d = new XYChart.Data<Number, Number>(Integer.valueOf(1), Integer.valueOf(2), "x");
+        assertNull(d.getNode());
+        assertEquals("x", d.getExtraValue());
+        assertEquals(Integer.valueOf(1), d.XValueProperty().get());
+        assertEquals(Integer.valueOf(2), d.YValueProperty().get());
+    }
+
+    @Test
+    public void aLineJoinsThePointsOfASeriesAndMarksEach() {
+        NumberAxis x = new NumberAxis(0, 1, 0.25);
+        NumberAxis y = new NumberAxis();
+        y.setForceZeroInRange(false);
+        LineChart<Number, Number> chart = new LineChart<Number, Number>(x, y);
+        XYChart.Series<Number, Number> s = new XYChart.Series<Number, Number>();
+        s.setName("one");
+        s.getData().add(new XYChart.Data<Number, Number>(Double.valueOf(1), Integer.valueOf(130)));
+        s.getData().add(new XYChart.Data<Number, Number>(Double.valueOf(0), Integer.valueOf(110)));
+        s.getData().add(new XYChart.Data<Number, Number>(Double.valueOf(0.5), Integer.valueOf(120)));
+        chart.getData().add(s);
+        chart.setLegendVisible(false);
+        paint(chart);
+        // Zero is not forced into the range, so it hugs the data.
+        assertEquals(107.5, y.getLowerBound(), 0);
+        assertEquals(132.5, y.getUpperBound(), 0);
+        // A fixed axis keeps its bounds, and its labels have the decimals
+        // each needs.
+        assertEquals(1, x.getUpperBound(), 0);
+        assertTrue(words.contains("0.25"));
+        assertTrue(words.contains("1"));
+        assertTrue(words.contains("110.0"));
+        assertEquals(1, count("stroke", FIRST));
+        assertEquals(3, count("fill", FIRST));
+        // The line runs the whole width of the plot whatever the order of
+        // the data, and rises to the right.
+        List<double[]> marks = new ArrayList<double[]>();
+        for (int i = 0; i < operations.size(); i++) {
+            if ("fill".equals(operations.get(i)) && FIRST.equals(paints.get(i))) {
+                marks.add(bounds.get(i));
+            }
+        }
+        double left = Double.MAX_VALUE;
+        double right = 0;
+        for (int i = 0; i < marks.size(); i++) {
+            left = Math.min(left, marks.get(i)[0]);
+            right = Math.max(right, marks.get(i)[2]);
+        }
+        assertTrue(right - left > 250);
+
+        chart.setCreateSymbols(false);
+        paint(chart);
+        assertEquals(0, count("fill", FIRST));
+        assertEquals(1, count("stroke", FIRST));
+    }
+
+    @Test
+    public void areasAndScatteredPointsDrawWhatTheirNamesSay() {
+        AreaChart<Number, Number> area = new AreaChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        XYChart.Series<Number, Number> s = new XYChart.Series<Number, Number>();
+        s.getData().add(new XYChart.Data<Number, Number>(Integer.valueOf(0), Integer.valueOf(1)));
+        s.getData().add(new XYChart.Data<Number, Number>(Integer.valueOf(10), Integer.valueOf(5)));
+        area.getData().add(s);
+        area.setCreateSymbols(false);
+        paint(area);
+        assertEquals(1, count("stroke", FIRST));
+        assertEquals(1, count("fill", Color.color(FIRST.getRed(), FIRST.getGreen(), FIRST.getBlue(), 0.2)));
+
+        ScatterChart<Number, Number> scatter = new ScatterChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        XYChart.Series<Number, Number> t = new XYChart.Series<Number, Number>();
+        t.getData().add(new XYChart.Data<Number, Number>(Integer.valueOf(0), Integer.valueOf(1)));
+        t.getData().add(new XYChart.Data<Number, Number>(Integer.valueOf(10), Integer.valueOf(5)));
+        scatter.getData().add(t);
+        scatter.setLegendVisible(false);
+        paint(scatter);
+        assertEquals(0, count("stroke", FIRST));
+        assertEquals(2, count("fill", FIRST));
+    }
+
+    @Test
+    public void aPieGivesEachPositiveValueASliceOfItsShare() {
+        PieChart.Data quarter = new PieChart.Data("Quarter", 1);
+        PieChart.Data rest = new PieChart.Data("Rest", 3);
+        PieChart.Data nothing = new PieChart.Data("Nothing", 0);
+        PieChart chart = new PieChart(FXCollections.observableArrayList(quarter, rest, nothing));
+        assertSame(chart, quarter.getChart());
+        chart.setLegendVisible(false);
+        paint(chart);
+        List<double[]> first = filled(FIRST);
+        List<double[]> second = filled(SECOND);
+        assertEquals(1, first.size());
+        assertEquals(1, second.size());
+        assertEquals(0, filled(Color.web("#57b757")).size());
+        // Clockwise from three o'clock: the first quarter is the lower
+        // right one, and the rest reaches over the whole circle.
+        double[] q = first.get(0);
+        double[] r = second.get(0);
+        double radius = (r[2] - r[0]) / 2;
+        assertEquals(radius, q[2] - q[0], 0.6);
+        assertEquals(radius, q[3] - q[1], 0.6);
+        assertEquals(r[2], q[2], 0.6);
+        assertEquals(r[3], q[3], 0.6);
+        assertTrue(words.contains("Quarter"));
+        assertTrue(words.contains("Rest"));
+        assertFalse(words.contains("Nothing"));
+
+        chart.setClockwise(false);
+        paint(chart);
+        q = filled(FIRST).get(0);
+        r = filled(SECOND).get(0);
+        // Counter clockwise it is the upper right one.
+        assertEquals(r[2], q[2], 0.6);
+        assertEquals(r[1], q[1], 0.6);
+
+        chart.setLabelsVisible(false);
+        paint(chart);
+        assertFalse(words.contains("Quarter"));
+
+        chart.getData().remove(quarter);
+        assertNull(quarter.getChart());
+        paint(chart);
+        // The colours follow the place in the data, so "Rest" is first now.
+        assertEquals(1, filled(FIRST).size());
+        assertEquals(0, filled(SECOND).size());
+    }
+
+    /// The node of a slice is what an application sets its handlers on:
+    /// `data.getNode().setOnMouseClicked(...)`. It was `null`, and the
+    /// application stopped there. The chart draws the slice and the node
+    /// answers the pointer over it.
+    @Test
+    public void theNodeOfASliceIsFoundUnderThePointerOverTheSlice() {
+        PieChart.Data quarter = new PieChart.Data("Quarter", 1);
+        PieChart.Data rest = new PieChart.Data("Rest", 3);
+        PieChart chart = new PieChart(FXCollections.observableArrayList(quarter, rest));
+        assertNotNull(quarter.getNode());
+        assertNotSame(quarter.getNode(), rest.getNode());
+        chart.setLegendVisible(false);
+        // Not drawn yet: there is no slice to be over.
+        chart.resize(800, 600);
+        assertSame(chart, chart.cn1Pick(400, 300));
+        paint(chart);
+        double[] r = filled(SECOND).get(0);
+        double cx = (r[0] + r[2]) / 2;
+        double cy = (r[1] + r[3]) / 2;
+        double radius = (r[2] - r[0]) / 2;
+        // Clockwise from three o'clock: the quarter is the lower right one.
+        assertSame(quarter.getNode(), chart.cn1Pick(cx + radius / 2, cy + radius / 2));
+        assertSame(rest.getNode(), chart.cn1Pick(cx - radius / 2, cy + radius / 2));
+        assertSame(rest.getNode(), chart.cn1Pick(cx - radius / 2, cy - radius / 2));
+        assertSame(rest.getNode(), chart.cn1Pick(cx + radius / 2, cy - radius / 2));
+        // Outside the pie it is the chart.
+        assertSame(chart, chart.cn1Pick(cx + radius * 0.9, cy + radius * 0.9));
+        assertSame(chart, quarter.getNode().getParent());
+
+        chart.setClockwise(false);
+        paint(chart);
+        assertSame(quarter.getNode(), chart.cn1Pick(cx + radius / 2, cy - radius / 2));
+        assertSame(rest.getNode(), chart.cn1Pick(cx + radius / 2, cy + radius / 2));
+
+        // A slice taken out of the chart is no longer found.
+        chart.getData().remove(quarter);
+        assertNull(quarter.getNode().getParent());
+        paint(chart);
+        assertSame(rest.getNode(), chart.cn1Pick(cx + radius / 2, cy - radius / 2));
+    }
+
+    private static XYChart.Series<Number, Number> numbers(String name, double x1, double y1, double x2,
+            double y2) {
+        XYChart.Series<Number, Number> s = new XYChart.Series<Number, Number>();
+        s.setName(name);
+        s.getData().add(new XYChart.Data<Number, Number>(Double.valueOf(x1), Double.valueOf(y1)));
+        s.getData().add(new XYChart.Data<Number, Number>(Double.valueOf(x2), Double.valueOf(y2)));
+        return s;
+    }
+
+    private static double size(double[] b, int axis) {
+        return b[axis + 2] - b[axis];
+    }
+
+    @Test
+    public void anAxisIsDrawnOnItsSideOfThePlotWithItsTicksOutside() {
+        NumberAxis x = new NumberAxis(0, 4, 1);
+        NumberAxis y = new NumberAxis(10, 50, 10);
+        LineChart<Number, Number> chart = new LineChart<Number, Number>(x, y);
+        chart.getData().add(numbers("s", 0, 10, 4, 50));
+        chart.setLegendVisible(false);
+        // An axis that was given no side is at the bottom or on the left.
+        assertSame(Side.BOTTOM, x.getSide());
+        assertSame(Side.LEFT, y.getSide());
+        paint(chart);
+        // Five pixels of padding and ten around the plot and its axes;
+        // an axis takes a tick of 8, a gap of 3 and its labels.
+        double[] plot = plot();
+        assertEquals(15 + 8 + 3 + 2 * CHAR, plot[0], 0.01);
+        assertEquals(15, plot[1], 0.01);
+        assertEquals(785, plot[2], 0.01);
+        assertEquals(585 - 8 - 3 - LINE, plot[3], 0.01);
+        assertEquals(plot[3] + 11, word("4")[1], 0.01);
+        assertEquals(plot[0] - 11, word("50")[0] + 2 * CHAR, 0.01);
+        List<double[]> down = marks(1, 9);
+        List<double[]> left = marks(9, 1);
+        assertEquals(5, down.size());
+        assertEquals(5, left.size());
+        for (int i = 0; i < 5; i++) {
+            assertTrue(down.get(i)[1] >= plot[3] - 0.5);
+            assertTrue(left.get(i)[2] <= plot[0] + 0.5);
+        }
+
+        x.setSide(Side.TOP);
+        y.setSide(Side.RIGHT);
+        x.setLabel("X");
+        paint(chart);
+        plot = plot();
+        // The plot gave up its top and its right instead, and the label
+        // of the axis is at the far edge, four pixels from the ticks.
+        assertEquals(15, plot[0], 0.01);
+        assertEquals(15 + LINE + 4 + LINE + 3 + 8, plot[1], 0.01);
+        assertEquals(785 - 8 - 3 - 2 * CHAR, plot[2], 0.01);
+        assertEquals(585, plot[3], 0.01);
+        assertEquals(plot[1] - 11, word("4")[1] + LINE, 0.01);
+        assertEquals(plot[2] + 11, word("50")[0], 0.01);
+        assertEquals(15, word("X")[1], 0.01);
+        List<double[]> up = marks(1, 9);
+        List<double[]> right = marks(9, 1);
+        assertEquals(5, up.size());
+        assertEquals(5, right.size());
+        for (int i = 0; i < 5; i++) {
+            assertTrue(up.get(i)[3] <= plot[1] + 0.5);
+            assertTrue(right.get(i)[0] >= plot[2] - 0.5);
+        }
+
+        // A side across the direction of an axis is taken as its usual one.
+        x.setSide(Side.LEFT);
+        x.setLabel(null);
+        paint(chart);
+        assertEquals(15, plot()[1], 0.01);
+        assertEquals(plot()[3] + 11, word("4")[1], 0.01);
+    }
+
+    @Test
+    public void tickLabelsAreTurnedAndTheAxisMakesRoomForThem() {
+        CategoryAxis x = new CategoryAxis(FXCollections.observableArrayList("January", "February"));
+        NumberAxis y = new NumberAxis(0, 10, 5);
+        BarChart<String, Number> chart = new BarChart<String, Number>(x, y);
+        XYChart.Series<String, Number> s = new XYChart.Series<String, Number>();
+        s.getData().add(new XYChart.Data<String, Number>("January", Integer.valueOf(4)));
+        s.getData().add(new XYChart.Data<String, Number>("February", Integer.valueOf(8)));
+        chart.getData().add(s);
+        chart.setLegendVisible(false);
+        paint(chart);
+        double upright = plot()[3];
+        double tick = marks(1, 9).get(0)[0];
+        assertEquals(585 - 11 - LINE, upright, 0.01);
+        // Upright, a label is centred under its tick.
+        assertEquals(tick - 7 * CHAR / 2, word("January")[0], 0.01);
+        assertEquals(upright + 11, word("January")[1], 0.01);
+
+        x.setTickLabelRotation(90);
+        paint(chart);
+        double turned = plot()[3];
+        // The axis is as deep as its longest label is wide now.
+        assertEquals(585 - 11 - 8 * CHAR, turned, 0.01);
+        // A label turned a quarter clockwise about its middle starts at
+        // the top of its box, half a line right of its tick.
+        assertEquals(tick + LINE / 2, word("January")[0], 0.01);
+        assertEquals(turned + 11, word("January")[1], 0.01);
+        // The shorter label is centred in the room of the longer one...
+        assertEquals(turned + 11, word("February")[1], 0.01);
+
+        x.setTickLabelRotation(45);
+        paint(chart);
+        double diagonal = (8 * CHAR + LINE) * Math.sqrt(0.5);
+        assertEquals(585 - Math.ceil(11 + diagonal), plot()[3], 0.01);
+
+        // The labels of a vertical axis are turned about their middles too.
+        x.setTickLabelRotation(0);
+        y.setTickLabelRotation(90);
+        paint(chart);
+        // "10" turned is a line wide and two characters high.
+        assertEquals(15 + 11 + LINE, plot()[0], 0.01);
+        double level = marks(9, 1).get(marks(9, 1).size() - 1)[1];
+        assertEquals(plot()[0] - 11, word("10")[0], 0.01);
+        assertEquals(level - CHAR, word("10")[1], 0.01);
+    }
+
+    @Test
+    public void categoryLabelsThatDoNotFitSideBySideAreStoodOnEnd() {
+        CategoryAxis x = new CategoryAxis();
+        NumberAxis y = new NumberAxis(0, 10, 5);
+        LineChart<String, Number> chart = new LineChart<String, Number>(x, y);
+        XYChart.Series<String, Number> s = new XYChart.Series<String, Number>();
+        for (int i = 0; i < 8; i++) {
+            s.getData().add(new XYChart.Data<String, Number>("Category " + i, Integer.valueOf(i)));
+        }
+        chart.getData().add(s);
+        chart.setLegendVisible(false);
+        paint(chart);
+        double[] plot = plot();
+        assertEquals(585 - 11 - 10 * CHAR, plot[3], 0.01);
+        double tick = marks(1, 9).get(0)[0];
+        assertEquals(tick + LINE / 2, word("Category 0")[0], 0.01);
+        assertEquals(plot[3] + 11, word("Category 0")[1], 0.01);
+        // Every category has a band of the axis between its margins of
+        // five pixels, and its tick in the middle of the band.
+        double band = (plot[2] - plot[0] - 10) / 8;
+        assertEquals(plot[0] + 5 + band / 2, tick, 0.51);
+        assertEquals(8, marks(1, 9).size());
+        assertEquals(plot[0] + 5 + band * 7.5, marks(1, 9).get(7)[0], 0.51);
+    }
+
+    @Test
+    public void minorTicksCutTheDistanceBetweenTwoTicks() {
+        NumberAxis x = new NumberAxis(0, 10, 5);
+        NumberAxis y = new NumberAxis(0, 10, 5);
+        y.setMinorTickVisible(false);
+        assertEquals(5, x.getMinorTickCount());
+        assertEquals(5, x.getMinorTickLength(), 0);
+        assertTrue(x.isMinorTickVisible());
+        LineChart<Number, Number> chart = new LineChart<Number, Number>(x, y);
+        chart.getData().add(numbers("s", 0, 0, 10, 10));
+        chart.setLegendVisible(false);
+        paint(chart);
+        double[] plot = plot();
+        // Three ticks, and four minor ones of five pixels in each of the
+        // two gaps; none on the axis that turned them off.
+        assertEquals(3, marks(1, 9).size());
+        List<double[]> minor = marks(1, 6);
+        assertEquals(8, minor.size());
+        assertEquals(0, marks(6, 1).size());
+        double width = plot[2] - plot[0];
+        for (int i = 0; i < 4; i++) {
+            assertEquals(plot[0] + width * (i + 1) / 10, minor.get(i)[0], 0.51);
+            assertEquals(plot[0] + width * (i + 6) / 10, minor.get(i + 4)[0], 0.51);
+            assertEquals(plot[3] - 0.5, minor.get(i)[1], 0.01);
+        }
+
+        x.setMinorTickCount(2);
+        x.setMinorTickLength(3);
+        paint(chart);
+        minor = marks(1, 4);
+        assertEquals(2, minor.size());
+        assertEquals(plot[0] + width / 4, minor.get(0)[0], 0.51);
+        assertEquals(0, marks(1, 6).size());
+
+        // On the top they point up, away from the plot.
+        x.setSide(Side.TOP);
+        paint(chart);
+        minor = marks(1, 4);
+        assertEquals(2, minor.size());
+        assertEquals(plot()[1] + 0.5, minor.get(0)[3], 0.01);
+
+        x.setMinorTickVisible(false);
+        paint(chart);
+        assertEquals(0, marks(1, 4).size());
+        assertEquals(3, marks(1, 9).size());
+    }
+
+    @Test
+    public void autoRangingChoosesTheBoundsAndTheTickUnitJavaFxDoes() {
+        // The data of the area chart sample: X from 0 to 10, Y from 2 to 9.
+        NumberAxis x = new NumberAxis();
+        x.setLabel("X Values");
+        NumberAxis y = new NumberAxis();
+        y.setLabel("Y Values");
+        AreaChart<Number, Number> area = new AreaChart<Number, Number>(x, y);
+        area.getData().add(numbers("Series 1", 0, 2, 10, 9));
+        paint(area, 1280, 860);
+        // Padded by a hundredth at each end but never across zero, then
+        // rounded outwards to the unit: half a unit beyond 9, one beyond 10.
+        assertEquals(0, y.getLowerBound(), 0);
+        assertEquals(9.5, y.getUpperBound(), 0);
+        assertEquals(0.5, y.getTickUnit(), 0);
+        assertEquals(0, x.getLowerBound(), 0);
+        assertEquals(11, x.getUpperBound(), 0);
+        assertEquals(1, x.getTickUnit(), 0);
+        // The labels have the decimals of the unit.
+        assertTrue(words.contains("9.5"));
+        assertTrue(words.contains("9.0"));
+        assertTrue(words.contains("11"));
+        assertFalse(words.contains("11.0"));
+
+        // The data of the category line chart sample.
+        NumberAxis v = new NumberAxis();
+        v.setLabel("Y Axis");
+        CategoryAxis c = new CategoryAxis();
+        c.setLabel("X Axis");
+        LineChart<String, Number> line = new LineChart<String, Number>(c, v);
+        line.setTitle("LineChart with Category Axis");
+        XYChart.Series<String, Number> s = new XYChart.Series<String, Number>();
+        s.setName("Data Series 1");
+        String[] names = {"Alpha", "Beta", "RC1", "RC2", "1.0", "1.1"};
+        int[] values = {50, 80, 90, 30, 122, 10};
+        for (int i = 0; i < names.length; i++) {
+            s.getData().add(new XYChart.Data<String, Number>(names[i], Integer.valueOf(values[i])));
+        }
+        line.getData().add(s);
+        paint(line, 1280, 860);
+        assertEquals(0, v.getLowerBound(), 0);
+        assertEquals(130, v.getUpperBound(), 0);
+        assertEquals(10, v.getTickUnit(), 0);
+        assertTrue(words.contains("130"));
+        assertTrue(words.contains("Alpha"));
+
+        // A range that does not hold zero is padded at both ends, and a
+        // unit that would make more than twenty ticks is doubled.
+        NumberAxis free = new NumberAxis();
+        free.setForceZeroInRange(false);
+        LineChart<Number, Number> hug = new LineChart<Number, Number>(new NumberAxis(0, 1, 1), free);
+        hug.getData().add(numbers("s", 0, 1000, 1, 3000));
+        paint(hug, 1280, 860);
+        assertEquals(750, free.getLowerBound(), 0);
+        assertEquals(3250, free.getUpperBound(), 0);
+        assertEquals(250, free.getTickUnit(), 0);
+        // Thousands are grouped from a unit of a hundred on.
+        assertTrue(words.contains("3,000"));
+
+        // Where the labels of a unit would touch, the unit is doubled
+        // until they do not.
+        paint(hug, 1280, 300);
+        assertEquals(1000, free.getTickUnit(), 0);
+        assertEquals(0, free.getLowerBound(), 0);
+        assertEquals(4000, free.getUpperBound(), 0);
+
+        // A fixed range groups its thousands and writes the decimals a
+        // label needs.
+        NumberAxis fixed = new NumberAxis("Units Sold", 0, 3000, 1000);
+        BarChart<String, Number> bars = new BarChart<String, Number>(new CategoryAxis(), fixed);
+        bars.getData().add(series("Apples", 567, 1292));
+        paint(bars);
+        assertTrue(words.contains("3,000"));
+        assertTrue(words.contains("0"));
+        assertEquals(3000, fixed.getUpperBound(), 0);
+    }
+
+    @Test
+    public void theLegendShowsTheSymbolOfEachSeriesOnItsSide() {
+        BarChart<String, Number> bars = new BarChart<String, Number>(new CategoryAxis(), new NumberAxis());
+        bars.getData().add(series("2023", 10, 20));
+        bars.getData().add(series("2024", 5, 15));
+        paint(bars);
+        double[] box = legendBox();
+        // Below the plot and in the middle: six pixels of padding around
+        // two tiles five pixels apart, each a square of 16, a gap of 4
+        // and the name.
+        double tile = 16 + 4 + 4 * CHAR;
+        assertEquals(595, box[3] + 1, 0.01);
+        assertEquals(LINE + 12, box[3] - box[1] + 2, 0.01);
+        assertEquals(2 * tile + 5 + 12, box[2] - box[0] + 2, 0.01);
+        assertEquals(400, (box[0] + box[2]) / 2, 1);
+        assertTrue(plot()[3] < box[1]);
+        List<double[]> first = legendFilled(FIRST);
+        List<double[]> second = legendFilled(SECOND);
+        assertEquals(1, first.size());
+        assertEquals(1, second.size());
+        assertEquals(16, size(first.get(0), 0), 0.01);
+        assertEquals(16, size(first.get(0), 1), 0.01);
+        assertEquals(first.get(0)[0] + tile + 5, second.get(0)[0], 0.01);
+        assertEquals(first.get(0)[1], second.get(0)[1], 0.01);
+        assertEquals(first.get(0)[2] + 4, word("2023")[0], 0.01);
+
+        bars.setLegendSide(Side.TOP);
+        paint(bars);
+        box = legendBox();
+        assertEquals(5, box[1] - 1, 0.01);
+        assertTrue(plot()[1] > box[3]);
+
+        bars.setLegendSide(Side.LEFT);
+        paint(bars);
+        box = legendBox();
+        // Beside the plot the entries are one under the other.
+        assertEquals(5, box[0] - 1, 0.01);
+        assertEquals(300, (box[1] + box[3]) / 2, 1);
+        assertEquals(legendFilled(FIRST).get(0)[0], legendFilled(SECOND).get(0)[0], 0.01);
+        assertEquals(legendFilled(FIRST).get(0)[1] + LINE + 5, legendFilled(SECOND).get(0)[1], 0.01);
+        assertTrue(plot()[0] > box[2]);
+
+        bars.setLegendSide(Side.RIGHT);
+        paint(bars);
+        box = legendBox();
+        assertEquals(795, box[2] + 1, 0.01);
+        assertTrue(plot()[2] < box[0]);
+
+        // Entries that do not fit in a row go on to the next.
+        bars.setLegendSide(Side.BOTTOM);
+        paint(bars, 180, 600);
+        box = legendBox();
+        assertEquals(2 * LINE + 5 + 12, box[3] - box[1] + 2, 0.01);
+        assertEquals(legendFilled(FIRST).get(0)[0], legendFilled(SECOND).get(0)[0], 0.01);
+
+        // A line has a ring of ten pixels with a white middle of six.
+        LineChart<Number, Number> line = new LineChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        line.getData().add(numbers("one", 0, 1, 10, 5));
+        paint(line);
+        double[] ring = legendFilled(FIRST).get(0);
+        double[] hole = legendFilled(Color.WHITE).get(0);
+        assertEquals(10, size(ring, 0), 0.5);
+        assertEquals(6, size(hole, 0), 0.5);
+        assertEquals((ring[0] + ring[2]) / 2, (hole[0] + hole[2]) / 2, 0.01);
+        assertEquals((ring[1] + ring[3]) / 2, (hole[1] + hole[3]) / 2, 0.01);
+
+        // An area has a ring of twelve.
+        AreaChart<Number, Number> area = new AreaChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        area.getData().add(numbers("one", 0, 1, 10, 5));
+        paint(area);
+        assertEquals(12, size(legendFilled(FIRST).get(0), 0), 0.5);
+        assertEquals(6, size(legendFilled(Color.WHITE).get(0), 0), 0.5);
+
+        // A pie has a disc for each slice.
+        PieChart pie = new PieChart(FXCollections.observableArrayList(new PieChart.Data("a", 1),
+                new PieChart.Data("b", 3)));
+        paint(pie);
+        assertEquals(14, size(legendFilled(FIRST).get(0), 0), 0.5);
+        assertEquals(14, size(legendFilled(FIRST).get(0), 1), 0.5);
+        assertEquals(14, size(legendFilled(SECOND).get(0), 0), 0.5);
+        assertEquals(0, legendFilled(Color.WHITE).size());
+
+        // Scattered points have the shape of their series: a disc for
+        // the first, a square for the second, a diamond for the third.
+        ScatterChart<Number, Number> scatter = new ScatterChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        scatter.getData().add(numbers("one", 0, 1, 10, 5));
+        scatter.getData().add(numbers("two", 1, 2, 9, 4));
+        scatter.getData().add(numbers("three", 2, 3, 8, 3));
+        paint(scatter);
+        Color third = Color.web("#57b757");
+        assertEquals(10, size(legendFilled(FIRST).get(0), 1), 0.5);
+        assertEquals(10, size(legendFilled(SECOND).get(0), 1), 0.01);
+        assertEquals(14, size(legendFilled(third).get(0), 1), 0.01);
+        assertEquals(2, filled(SECOND).size());
+        assertEquals(10, size(filled(SECOND).get(0), 0), 0.01);
+        assertEquals(10, size(filled(SECOND).get(0), 1), 0.01);
+        assertEquals(10, size(filled(third).get(0), 0), 0.01);
+        assertEquals(14, size(filled(third).get(0), 1), 0.01);
+    }
+
+    @Test
+    public void thePlotHasDashedGridLinesAndCutsOffWhatLeavesIt() {
+        CategoryAxis x = new CategoryAxis();
+        NumberAxis y = new NumberAxis(0, 10, 5);
+        LineChart<String, Number> chart = new LineChart<String, Number>(x, y);
+        XYChart.Series<String, Number> s = new XYChart.Series<String, Number>();
+        s.getData().add(new XYChart.Data<String, Number>("A", Integer.valueOf(0)));
+        s.getData().add(new XYChart.Data<String, Number>("B", Integer.valueOf(10)));
+        s.getData().add(new XYChart.Data<String, Number>("C", Integer.valueOf(5)));
+        chart.getData().add(s);
+        chart.setLegendVisible(false);
+        paint(chart);
+        double[] plot = plot();
+        // A line up from each category, and one across at 5 and at 10;
+        // the one at zero is the zero line, which the axis lies on.
+        List<double[]> grid = drawn("stroke", GRID);
+        assertEquals(5, grid.size());
+        double band = (plot[2] - plot[0] - 10) / 3;
+        for (int i = 0; i < 3; i++) {
+            assertEquals(1, size(grid.get(i), 0), 0.01);
+            assertEquals(plot[0] + 5 + band * (i + 0.5), grid.get(i)[0], 0.51);
+            assertEquals(plot[1], grid.get(i)[1], 0.51);
+        }
+        assertEquals(1, size(grid.get(3), 1), 0.01);
+        assertEquals((plot[1] + plot[3]) / 2, grid.get(3)[1], 0.51);
+        assertEquals(plot[1], grid.get(4)[1], 0.01);
+        // The series is drawn inside a clip of the plot and a pixel more.
+        int clips = 0;
+        for (int i = 0; i < operations.size(); i++) {
+            if ("clip".equals(operations.get(i))) {
+                clips++;
+                assertEquals(plot[0], bounds.get(i)[0], 0.01);
+                assertEquals(plot[1], bounds.get(i)[1], 0.01);
+                assertEquals(plot[2] + 1, bounds.get(i)[2], 0.01);
+                assertEquals(plot[3] + 1, bounds.get(i)[3], 0.01);
+            }
+        }
+        assertEquals(1, clips);
+        // The symbol of a line is a ring of ten pixels with a hole of six.
+        assertEquals(10, size(filled(FIRST).get(0), 0), 0.5);
+        assertEquals(6, size(filled(Color.WHITE).get(0), 0), 0.5);
+
+        chart.setVerticalGridLinesVisible(false);
+        paint(chart);
+        assertEquals(2, drawn("stroke", GRID).size());
+        chart.setHorizontalGridLinesVisible(false);
+        paint(chart);
+        assertEquals(0, drawn("stroke", GRID).size());
+    }
+
+    @Test
+    public void barsShareTheBandOfTheirCategoryLessItsGaps() {
+        CategoryAxis x = new CategoryAxis();
+        NumberAxis y = new NumberAxis(0, 20, 10);
+        BarChart<String, Number> chart = new BarChart<String, Number>(x, y);
+        chart.getData().add(series("2023", 10, 20));
+        chart.getData().add(series("2024", 5, 15));
+        chart.setLegendVisible(false);
+        chart.setCategoryGap(25);
+        paint(chart);
+        double[] plot = plot();
+        double band = (plot[2] - plot[0] - 10) / 2;
+        double bar = (band - 25 - 4) / 2 - 4;
+        List<double[]> first = filled(FIRST);
+        List<double[]> second = filled(SECOND);
+        assertEquals(bar, size(first.get(0), 0), 1.01);
+        assertEquals(bar, size(second.get(0), 0), 1.01);
+        // Half the gap between two categories is before the first bar,
+        // and the gap between two bars after each.
+        assertEquals(plot[0] + 5 + 12.5, first.get(0)[0], 0.51);
+        assertEquals(first.get(0)[0] + bar + 4, second.get(0)[0], 1.01);
+        assertEquals(first.get(0)[0] + band, first.get(1)[0], 1.01);
+        // A bar of the whole range is as tall as the plot.
+        assertEquals(plot[1], first.get(1)[1], 0.01);
+        assertEquals(plot[3], first.get(1)[3], 0.01);
+
+        // The symbol of an area is a ring of six pixels with a hole of four.
+        AreaChart<Number, Number> area = new AreaChart<Number, Number>(new NumberAxis(), new NumberAxis());
+        area.getData().add(numbers("one", 0, 1, 10, 5));
+        area.setLegendVisible(false);
+        paint(area);
+        assertEquals(2, filled(FIRST).size());
+        assertEquals(6, size(filled(FIRST).get(0), 0), 0.5);
+        assertEquals(4, size(filled(Color.WHITE).get(0), 0), 0.5);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/CollapsedTransformTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/CollapsedTransformTest.java
new file mode 100644
index 00000000000..b102abcf34c
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/CollapsedTransformTest.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+
+import javafx.scene.Group;
+import javafx.scene.Scene;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+import javafx.stage.Stage;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/// A node scaled to nothing, which is how a node that grows into view
+/// starts, and a node faded out to nothing paint nothing and leave the rest
+/// of the scene painting.
+public class CollapsedTransformTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<Paint> filled = new ArrayList<Paint>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Renderer.setTrace(null);
+        List<javafx.stage.Window> open = new ArrayList<javafx.stage.Window>(javafx.stage.Window.getWindows());
+        for (int i = 0; i < open.size(); i++) {
+            open.get(i).hide();
+        }
+        Units.setScale(0);
+    }
+
+    private void paint() {
+        filled.clear();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                if ("fill".equals(operation)) {
+                    filled.add(paint);
+                }
+            }
+        });
+        Form f = Display.getInstance().getCurrent();
+        f.revalidate();
+        f.paintComponent(Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT).getGraphics());
+        Renderer.setTrace(null);
+    }
+
+    @Test
+    public void aShapeAndAGroupScaledToZeroPaintNothingUntilTheyGrow() {
+        Rectangle inGroup = new Rectangle(10, 10, 40, 40);
+        inGroup.setFill(Color.RED);
+        Group growing = new Group(inGroup);
+        Rectangle alone = new Rectangle(60, 10, 40, 40);
+        alone.setFill(Color.GREEN);
+        Rectangle steady = new Rectangle(110, 10, 40, 40);
+        steady.setFill(Color.BLUE);
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(growing, alone, steady), 200, 100));
+        stage.show();
+
+        growing.setScaleX(0);
+        growing.setScaleY(0);
+        alone.setScaleY(0);
+        paint();
+        assertFalse("a group scaled to nothing painted its child", filled.contains(Color.RED));
+        assertFalse("a shape scaled to nothing was painted", filled.contains(Color.GREEN));
+        assertTrue("the node after them was not painted", filled.contains(Color.BLUE));
+
+        growing.setScaleX(0.5);
+        growing.setScaleY(0.5);
+        alone.setScaleY(1);
+        paint();
+        assertTrue(filled.contains(Color.RED));
+        assertTrue(filled.contains(Color.GREEN));
+        assertTrue(filled.contains(Color.BLUE));
+    }
+
+    /// What a fade to nothing ends on: a node at opacity zero.
+    @Test
+    public void aNodeFadedOutPaintsNothingAndItsTextIsNotDrawn() {
+        Rectangle faded = new Rectangle(10, 10, 40, 40);
+        faded.setFill(Color.RED);
+        javafx.scene.control.Label points = new javafx.scene.control.Label("+8");
+        Rectangle steady = new Rectangle(110, 10, 40, 40);
+        steady.setFill(Color.BLUE);
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(faded, points, steady), 200, 100));
+        stage.show();
+
+        HeadlessImplementation.drawnText.clear();
+        HeadlessImplementation.recordText = true;
+        try {
+            paint();
+            assertTrue(filled.contains(Color.RED));
+            assertTrue("the label was not drawn at all", drewText("+8"));
+
+            faded.setOpacity(0);
+            points.setOpacity(0);
+            HeadlessImplementation.drawnText.clear();
+            paint();
+            assertFalse(filled.contains(Color.RED));
+            assertFalse("a label at opacity zero was drawn", drewText("+8"));
+            assertTrue(filled.contains(Color.BLUE));
+        } finally {
+            HeadlessImplementation.recordText = false;
+            HeadlessImplementation.drawnText.clear();
+        }
+    }
+
+    private static boolean drewText(String wanted) {
+        for (int i = 0; i < HeadlessImplementation.drawnText.size(); i++) {
+            Object[] entry = HeadlessImplementation.drawnText.get(i);
+            for (int j = 0; j < entry.length; j++) {
+                if (wanted.equals(entry[j])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ConcurrencyTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ConcurrencyTest.java
new file mode 100644
index 00000000000..fbbc0c27861
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ConcurrencyTest.java
@@ -0,0 +1,786 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+
+import javafx.application.Platform;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.concurrent.Service;
+import javafx.concurrent.Task;
+import javafx.concurrent.Worker;
+import javafx.concurrent.Worker.State;
+import javafx.concurrent.WorkerStateEvent;
+import javafx.event.EventHandler;
+
+/// Tasks and services. The tests run on the application thread, as an
+/// application's code does, so a test that waits for a background thread
+/// lets the event queue run meanwhile (`await`): it never sleeps for a
+/// result, it waits for a condition, and gives up after a bound.
+public class ConcurrencyTest {
+
+    private static final long BOUND_MILLIS = 20000;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> log = new ArrayList<String>();
+
+    /// The display has to exist before the rule decides which thread a
+    /// test runs on, or the first test of the JVM runs off the
+    /// application thread.
+    @BeforeClass
+    public static void display() {
+        HeadlessImplementation.install();
+    }
+
+    private interface Check {
+        boolean ok();
+    }
+
+    /// Lets the event queue run until a condition holds.
+    private static void await(String what, Check check) {
+        long deadline = System.currentTimeMillis() + BOUND_MILLIS;
+        while (!check.ok()) {
+            if (System.currentTimeMillis() > deadline) {
+                fail("timed out waiting for " + what);
+            }
+            MainThreadRule.drain();
+        }
+    }
+
+    /// Holds the application thread, delivering nothing, until a
+    /// background thread has raised a flag.
+    private static void holdUntil(String what, AtomicBoolean flag) {
+        long deadline = System.currentTimeMillis() + BOUND_MILLIS;
+        while (!flag.get()) {
+            if (System.currentTimeMillis() > deadline) {
+                fail("timed out waiting for " + what);
+            }
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                fail("interrupted");
+            }
+        }
+    }
+
+    private static void pause() {
+        try {
+            Thread.sleep(2);
+        } catch (InterruptedException e) {
+            // a cancelled task is interrupted; the loop around this looks
+        }
+    }
+
+    private void record(final Worker<?> worker, final String prefix) {
+        worker.stateProperty().addListener(new ChangeListener<State>() {
+            @Override
+            public void changed(ObservableValue<? extends State> observable, State old, State next) {
+                log.add(prefix + next + (Platform.isFxApplicationThread() ? "" : " OFF THE FX THREAD"));
+            }
+        });
+        worker.runningProperty().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> observable, Boolean old, Boolean next) {
+                log.add(prefix + "running=" + next + (Platform.isFxApplicationThread() ? "" : " OFF THE FX THREAD"));
+            }
+        });
+    }
+
+    private EventHandler<WorkerStateEvent> note(final String what) {
+        return new EventHandler<WorkerStateEvent>() {
+            @Override
+            public void handle(WorkerStateEvent event) {
+                log.add(what + (Platform.isFxApplicationThread() ? "" : " OFF THE FX THREAD"));
+            }
+        };
+    }
+
+    // ---- tasks ----
+
+    @Test
+    public void aTaskSucceeds() {
+        assertTrue(Platform.isFxApplicationThread());
+        final AtomicBoolean calledOnFxThread = new AtomicBoolean(true);
+        final Task<String> task = new Task<String>() {
+            @Override
+            protected String call() {
+                calledOnFxThread.set(Platform.isFxApplicationThread());
+                updateTitle("copying");
+                updateMessage("half way");
+                updateProgress(1, 2);
+                return "done";
+            }
+
+            @Override
+            protected void scheduled() {
+                log.add("scheduled()");
+            }
+
+            @Override
+            protected void running() {
+                log.add("running()");
+            }
+
+            @Override
+            protected void succeeded() {
+                log.add("succeeded() " + getValue());
+            }
+        };
+        record(task, "");
+        task.setOnScheduled(note("onScheduled"));
+        task.setOnRunning(note("onRunning"));
+        task.setOnSucceeded(note("onSucceeded"));
+        task.setOnFailed(note("onFailed"));
+        task.setOnCancelled(note("onCancelled"));
+        final List<Object> sources = new ArrayList<Object>();
+        task.addEventHandler(WorkerStateEvent.ANY, new EventHandler<WorkerStateEvent>() {
+            @Override
+            public void handle(WorkerStateEvent event) {
+                sources.add(event.getSource());
+                sources.add(event.getEventType());
+            }
+        });
+        assertSame(State.READY, task.getState());
+        assertEquals(-1.0, task.getProgress(), 0);
+        assertEquals("", task.getMessage());
+        assertFalse(task.isDone());
+
+        new Thread(task).start();
+        await("the task to succeed", new Check() {
+            @Override
+            public boolean ok() {
+                return task.getState() == State.SUCCEEDED;
+            }
+        });
+        assertEquals(Arrays.asList("SCHEDULED", "running=true", "onScheduled", "scheduled()", "RUNNING",
+                "onRunning", "running()", "SUCCEEDED", "running=false", "onSucceeded", "succeeded() done"), log);
+        assertEquals(Arrays.asList(task, WorkerStateEvent.WORKER_STATE_SCHEDULED, task,
+                WorkerStateEvent.WORKER_STATE_RUNNING, task, WorkerStateEvent.WORKER_STATE_SUCCEEDED), sources);
+        assertFalse("call() runs off the application thread", calledOnFxThread.get());
+        assertEquals("done", task.getValue());
+        assertNull(task.getException());
+        assertEquals("copying", task.getTitle());
+        assertEquals("half way", task.getMessage());
+        assertEquals(1.0, task.getWorkDone(), 0);
+        assertEquals(2.0, task.getTotalWork(), 0);
+        assertEquals(0.5, task.getProgress(), 0);
+        assertFalse(task.isRunning());
+        assertTrue(task.isDone());
+        assertFalse(task.isCancelled());
+        assertFalse("a finished task cannot be cancelled", task.cancel());
+        assertSame(State.SUCCEEDED, task.getState());
+        assertSame(task.getOnSucceeded(), task.onSucceededProperty().get());
+    }
+
+    @Test
+    public void aTaskFails() {
+        final IllegalStateException boom = new IllegalStateException("boom");
+        final Task<String> task = new Task<String>() {
+            @Override
+            protected String call() {
+                throw boom;
+            }
+
+            @Override
+            protected void failed() {
+                log.add("failed()");
+            }
+
+            @Override
+            protected void succeeded() {
+                log.add("succeeded()");
+            }
+        };
+        record(task, "");
+        task.setOnFailed(note("onFailed"));
+        task.setOnSucceeded(note("onSucceeded"));
+        new Thread(task).start();
+        await("the task to fail", new Check() {
+            @Override
+            public boolean ok() {
+                return task.getState() == State.FAILED;
+            }
+        });
+        assertEquals(Arrays.asList("SCHEDULED", "running=true", "RUNNING", "FAILED", "running=false", "onFailed",
+                "failed()"), log);
+        assertSame(boom, task.getException());
+        assertNull(task.getValue());
+        assertTrue(task.isDone());
+        assertFalse(task.isCancelled());
+    }
+
+    /// A task that works until it is cancelled or released.
+    private final class Waiting extends Task<String> {
+        final AtomicBoolean entered = new AtomicBoolean();
+        final AtomicBoolean left = new AtomicBoolean();
+        final AtomicBoolean release = new AtomicBoolean();
+        final String result;
+
+        Waiting(String result) {
+            this.result = result;
+        }
+
+        @Override
+        protected String call() {
+            entered.set(true);
+            try {
+                while (!isCancelled() && !release.get()) {
+                    pause();
+                }
+                return result;
+            } finally {
+                left.set(true);
+            }
+        }
+
+        @Override
+        protected void cancelled() {
+            log.add("task cancelled()");
+        }
+
+        @Override
+        protected void succeeded() {
+            log.add("task succeeded()");
+        }
+    }
+
+    @Test
+    public void aRunningTaskIsCancelled() {
+        final Waiting task = new Waiting("never");
+        record(task, "");
+        task.setOnCancelled(note("onCancelled"));
+        task.setOnSucceeded(note("onSucceeded"));
+        new Thread(task).start();
+        await("the task to run", new Check() {
+            @Override
+            public boolean ok() {
+                return task.entered.get() && task.getState() == State.RUNNING;
+            }
+        });
+        assertTrue(task.isRunning());
+        assertTrue(task.cancel());
+        // On the application thread the state changes there and then.
+        assertSame(State.CANCELLED, task.getState());
+        assertTrue(task.isCancelled());
+        assertTrue(task.isDone());
+        assertFalse(task.isRunning());
+        assertFalse("cancelled once", task.cancel());
+        await("call() to return", new Check() {
+            @Override
+            public boolean ok() {
+                return task.left.get();
+            }
+        });
+        MainThreadRule.drain();
+        MainThreadRule.drain();
+        // What call() returned after the cancellation is dropped.
+        assertEquals(Arrays.asList("SCHEDULED", "running=true", "RUNNING", "CANCELLED", "running=false",
+                "onCancelled", "task cancelled()"), log);
+        assertSame(State.CANCELLED, task.getState());
+        assertNull(task.getValue());
+    }
+
+    @Test
+    public void aTaskCancelledBeforeItRunsNeverCalls() {
+        final AtomicBoolean called = new AtomicBoolean();
+        final AtomicBoolean returned = new AtomicBoolean();
+        final Task<String> task = new Task<String>() {
+            @Override
+            protected String call() {
+                called.set(true);
+                return "x";
+            }
+        };
+        record(task, "");
+        assertTrue(task.cancel(false));
+        assertSame(State.CANCELLED, task.getState());
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                task.run();
+                returned.set(true);
+            }
+        }).start();
+        await("run() to return", new Check() {
+            @Override
+            public boolean ok() {
+                return returned.get();
+            }
+        });
+        MainThreadRule.drain();
+        assertFalse(called.get());
+        assertEquals(Arrays.asList("CANCELLED"), log);
+    }
+
+    @Test
+    public void aTaskCancelledFromAnotherThreadChangesStateOnTheFxThread() {
+        final Waiting task = new Waiting("never");
+        record(task, "");
+        new Thread(task).start();
+        await("the task to run", new Check() {
+            @Override
+            public boolean ok() {
+                return task.entered.get() && task.getState() == State.RUNNING;
+            }
+        });
+        final AtomicReference<Boolean> answer = new AtomicReference<Boolean>();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                answer.set(Boolean.valueOf(task.cancel()));
+            }
+        }).start();
+        await("the cancellation to arrive", new Check() {
+            @Override
+            public boolean ok() {
+                return task.getState() == State.CANCELLED;
+            }
+        });
+        assertEquals(Boolean.TRUE, answer.get());
+        assertEquals(Arrays.asList("SCHEDULED", "running=true", "RUNNING", "CANCELLED", "running=false",
+                "task cancelled()"), log);
+    }
+
+    @Test
+    public void rapidUpdatesAreMergedAndTheLastOneArrives() {
+        final AtomicBoolean produced = new AtomicBoolean();
+        final AtomicBoolean release = new AtomicBoolean();
+        final Task<Integer> task = new Task<Integer>() {
+            @Override
+            protected Integer call() {
+                for (int i = 1; i <= 1000; i++) {
+                    updateProgress(i, 1000);
+                    updateMessage("step " + i);
+                    updateTitle("title " + i);
+                    updateValue(Integer.valueOf(i));
+                }
+                produced.set(true);
+                while (!release.get()) {
+                    pause();
+                }
+                return Integer.valueOf(-1);
+            }
+        };
+        final List<String> messages = new ArrayList<String>();
+        final List<Double> progress = new ArrayList<Double>();
+        final List<Integer> values = new ArrayList<Integer>();
+        final AtomicInteger offThread = new AtomicInteger();
+        task.messageProperty().addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> observable, String old, String next) {
+                messages.add(next);
+                if (!Platform.isFxApplicationThread()) {
+                    offThread.incrementAndGet();
+                }
+            }
+        });
+        task.progressProperty().addListener(new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> observable, Number old, Number next) {
+                progress.add(Double.valueOf(next.doubleValue()));
+                if (!Platform.isFxApplicationThread()) {
+                    offThread.incrementAndGet();
+                }
+            }
+        });
+        task.valueProperty().addListener(new ChangeListener<Integer>() {
+            @Override
+            public void changed(ObservableValue<? extends Integer> observable, Integer old, Integer next) {
+                values.add(next);
+            }
+        });
+        new Thread(task).start();
+        // The application thread is busy here, in this test, so none of the
+        // thousand updates can be delivered while they are made.
+        holdUntil("the updates", produced);
+        assertTrue(messages.isEmpty());
+        assertTrue(progress.isEmpty());
+        await("the updates to arrive", new Check() {
+            @Override
+            public boolean ok() {
+                return !messages.isEmpty() && !progress.isEmpty() && !values.isEmpty()
+                        && "title 1000".equals(task.getTitle());
+            }
+        });
+        MainThreadRule.drain();
+        assertEquals(Arrays.asList("step 1000"), messages);
+        assertEquals(Arrays.asList(Double.valueOf(1.0)), progress);
+        assertEquals(Arrays.asList(Integer.valueOf(1000)), values);
+        assertEquals(1000.0, task.getWorkDone(), 0);
+        assertEquals(1000.0, task.getTotalWork(), 0);
+        assertEquals(0, offThread.get());
+        release.set(true);
+        await("the task to succeed", new Check() {
+            @Override
+            public boolean ok() {
+                return task.getState() == State.SUCCEEDED;
+            }
+        });
+        assertEquals("the result replaces the partial value", Integer.valueOf(-1), task.getValue());
+    }
+
+    @Test
+    public void aNullUpdateBetweenTwoDoesNotOutliveTheLast() {
+        final AtomicBoolean produced = new AtomicBoolean();
+        final AtomicBoolean release = new AtomicBoolean();
+        final Task<String> task = new Task<String>() {
+            @Override
+            protected String call() {
+                updateValue("a");
+                updateMessage("a");
+                updateTitle("a");
+                updateValue(null);
+                updateMessage(null);
+                updateTitle(null);
+                updateValue("b");
+                updateMessage("b");
+                updateTitle("b");
+                produced.set(true);
+                while (!release.get()) {
+                    pause();
+                }
+                return "done";
+            }
+        };
+        new Thread(task).start();
+        // Nothing is delivered while the updates are made, so all three are
+        // queued behind one another.
+        holdUntil("the updates", produced);
+        await("the updates to arrive", new Check() {
+            @Override
+            public boolean ok() {
+                return "b".equals(task.getValue());
+            }
+        });
+        MainThreadRule.drain();
+        MainThreadRule.drain();
+        assertEquals("b", task.getValue());
+        assertEquals("b", task.getMessage());
+        assertEquals("b", task.getTitle());
+        release.set(true);
+        await("the task to succeed", new Check() {
+            @Override
+            public boolean ok() {
+                return task.getState() == State.SUCCEEDED;
+            }
+        });
+    }
+
+    @Test
+    public void progressNumbersAreNormalised() {
+        /// Reports on the calling thread, which is the application thread.
+        final class Reporter extends Task<Void> {
+            @Override
+            protected Void call() {
+                return null;
+            }
+
+            void report(double done, double max) {
+                updateProgress(done, max);
+            }
+
+            void report(long done, long max) {
+                updateProgress(done, max);
+            }
+        }
+        Reporter task = new Reporter();
+        task.report(3L, 4L);
+        assertEquals(0.75, task.getProgress(), 0);
+        task.report(9.0, 4.0);
+        assertEquals(4.0, task.getWorkDone(), 0);
+        assertEquals(1.0, task.getProgress(), 0);
+        task.report(-5.0, 4.0);
+        assertEquals(-1.0, task.getWorkDone(), 0);
+        assertEquals(-1.0, task.getProgress(), 0);
+        task.report(Double.NaN, Double.POSITIVE_INFINITY);
+        assertEquals(-1.0, task.getTotalWork(), 0);
+        assertEquals(-1.0, task.getProgress(), 0);
+        task.report(0.0, 0.0);
+        assertEquals("nothing to do is not a division by zero", -1.0, task.getProgress(), 0);
+    }
+
+    @Test
+    public void aStartedTaskBelongsToTheFxThread() {
+        final Waiting task = new Waiting("x");
+        new Thread(task).start();
+        await("the task to run", new Check() {
+            @Override
+            public boolean ok() {
+                return task.entered.get();
+            }
+        });
+        final AtomicReference<String> seen = new AtomicReference<String>();
+        final AtomicBoolean finished = new AtomicBoolean();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    task.getState();
+                    seen.set("no exception");
+                } catch (IllegalStateException expected) {
+                    seen.set("refused");
+                }
+                finished.set(true);
+            }
+        }).start();
+        await("the other thread", new Check() {
+            @Override
+            public boolean ok() {
+                return finished.get();
+            }
+        });
+        assertEquals("refused", seen.get());
+        task.release.set(true);
+        await("the task to succeed", new Check() {
+            @Override
+            public boolean ok() {
+                return task.getState() == State.SUCCEEDED;
+            }
+        });
+        assertEquals("x", task.getValue());
+    }
+
+    // ---- services ----
+
+    /// A service whose tasks answer at once, or work until released.
+    private final class Counting extends Service<String> {
+        int created;
+        boolean waiting;
+        Waiting last;
+
+        @Override
+        protected Task<String> createTask() {
+            created++;
+            final String result = "v" + created;
+            if (waiting) {
+                last = new Waiting(result);
+                return last;
+            }
+            return new Task<String>() {
+                @Override
+                protected String call() {
+                    updateMessage("made " + result);
+                    return result;
+                }
+            };
+        }
+
+        @Override
+        protected void ready() {
+            log.add("ready()");
+        }
+
+        @Override
+        protected void succeeded() {
+            log.add("succeeded() " + getValue());
+        }
+
+        @Override
+        protected void cancelled() {
+            log.add("cancelled()");
+        }
+    }
+
+    private void awaitState(final Service<?> service, final State state) {
+        await("the service to be " + state, new Check() {
+            @Override
+            public boolean ok() {
+                return service.getState() == state;
+            }
+        });
+    }
+
+    @Test
+    public void aServiceStartsResetsAndStartsAgain() {
+        final Counting service = new Counting();
+        record(service, "");
+        service.setOnSucceeded(note("onSucceeded"));
+        service.setOnReady(note("onReady"));
+        assertSame(State.READY, service.getState());
+        service.start();
+        assertSame("scheduled by start itself", State.SCHEDULED, service.getState());
+        assertTrue(service.isRunning());
+        awaitState(service, State.SUCCEEDED);
+        assertEquals(Arrays.asList("SCHEDULED", "running=true", "RUNNING", "onSucceeded", "succeeded() v1",
+                "SUCCEEDED", "running=false"), log);
+        assertEquals("v1", service.getValue());
+        assertEquals("made v1", service.getMessage());
+        assertFalse(service.isRunning());
+        try {
+            service.start();
+            fail("a service that ended has to be reset first");
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        assertFalse("nothing left to cancel", service.cancel());
+
+        log.clear();
+        service.reset();
+        assertEquals(Arrays.asList("onReady", "ready()", "READY"), log);
+        assertSame(State.READY, service.getState());
+        assertNull(service.getValue());
+        assertEquals("", service.getMessage());
+        assertEquals(-1.0, service.getProgress(), 0);
+
+        log.clear();
+        service.start();
+        awaitState(service, State.SUCCEEDED);
+        assertEquals("v2", service.getValue());
+        assertEquals(2, service.created);
+
+        log.clear();
+        service.restart();
+        awaitState(service, State.SUCCEEDED);
+        assertEquals("v3", service.getValue());
+        assertEquals(Arrays.asList("cancelled()", "CANCELLED", "onReady", "ready()", "READY", "SCHEDULED",
+                "running=true", "RUNNING", "onSucceeded", "succeeded() v3", "SUCCEEDED", "running=false"), log);
+    }
+
+    @Test
+    public void aRunningServiceIsCancelledAndRestarted() {
+        final Counting service = new Counting();
+        service.waiting = true;
+        record(service, "");
+        service.start();
+        try {
+            service.reset();
+            fail("a scheduled service cannot be reset");
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        try {
+            service.start();
+            fail("a scheduled service cannot be started");
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        awaitState(service, State.RUNNING);
+        try {
+            service.reset();
+            fail("a running service cannot be reset");
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        final Waiting first = service.last;
+        assertTrue(service.cancel());
+        assertSame(State.CANCELLED, service.getState());
+        assertTrue(first.isCancelled());
+        assertFalse(service.cancel());
+        assertEquals(Arrays.asList("SCHEDULED", "running=true", "RUNNING", "cancelled()", "CANCELLED",
+                "running=false", "task cancelled()"), log);
+        await("the first task to leave", new Check() {
+            @Override
+            public boolean ok() {
+                return first.left.get();
+            }
+        });
+
+        // Restarting a running service cancels its task and runs a new one.
+        service.reset();
+        service.start();
+        awaitState(service, State.RUNNING);
+        final Waiting second = service.last;
+        log.clear();
+        service.waiting = false;
+        service.restart();
+        assertTrue(second.isCancelled());
+        awaitState(service, State.SUCCEEDED);
+        assertEquals("v3", service.getValue());
+        assertEquals(Arrays.asList("cancelled()", "CANCELLED", "running=false", "task cancelled()", "ready()", "READY",
+                "SCHEDULED",
+                "running=true", "RUNNING", "succeeded() v3", "SUCCEEDED", "running=false"), log);
+        await("the second task to leave", new Check() {
+            @Override
+            public boolean ok() {
+                return second.left.get();
+            }
+        });
+    }
+
+    @Test
+    public void aServiceThatNeverStartedCanBeCancelled() {
+        Counting service = new Counting();
+        record(service, "");
+        assertTrue(service.cancel());
+        assertSame(State.CANCELLED, service.getState());
+        assertFalse(service.cancel());
+        try {
+            service.start();
+            fail("cancelled is not ready");
+        } catch (IllegalStateException expected) {
+            // expected
+        }
+        service.reset();
+        assertSame(State.READY, service.getState());
+        assertEquals(0, service.created);
+    }
+
+    @Test
+    public void aServiceBelongsToTheFxThread() {
+        final Counting service = new Counting();
+        final AtomicReference<String> seen = new AtomicReference<String>();
+        final AtomicBoolean finished = new AtomicBoolean();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    service.start();
+                    seen.set("no exception");
+                } catch (IllegalStateException expected) {
+                    seen.set("refused");
+                }
+                finished.set(true);
+            }
+        }).start();
+        await("the other thread", new Check() {
+            @Override
+            public boolean ok() {
+                return finished.get();
+            }
+        });
+        assertEquals("refused", seen.get());
+        assertEquals(0, service.created);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlLookTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlLookTest.java
new file mode 100644
index 00000000000..a401922c0f7
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlLookTest.java
@@ -0,0 +1,635 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.FrameClock;
+import com.codename1.fxcompat.runtime.PeerPaint;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.plaf.Style;
+
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.ContentDisplay;
+import javafx.scene.control.Control;
+import javafx.scene.control.Hyperlink;
+import javafx.scene.control.Label;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.control.ProgressIndicator;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.Slider;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// What the controls show: the progress controls that draw themselves,
+/// the graphic of a labeled control, the states of a hyperlink and of a
+/// toggle button, the arrow of a choice box, the dimming of a disabled
+/// control and a label that gives way in a row that is too narrow.
+public class ControlLookTest {
+
+    private static final int ACCENT = 0x0096c9;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Renderer.setTrace(null);
+        FrameClock.reset();
+        Units.setScale(0);
+    }
+
+    /// One drawing operation of a traced paint.
+    private static final class Op {
+        String kind;
+        double[] bounds;
+        Paint paint;
+        String text;
+
+        double width() {
+            return bounds[2] - bounds[0];
+        }
+
+        boolean accent() {
+            return paint instanceof Color && (((Color) paint).cn1Argb() & 0xffffff) == ACCENT;
+        }
+    }
+
+    private static List<Op> paint(Node node) {
+        final List<Op> ops = new ArrayList<Op>();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                Op op = new Op();
+                op.kind = operation;
+                op.bounds = deviceBounds;
+                op.paint = paint;
+                op.text = text;
+                ops.add(op);
+            }
+        });
+        node.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(400, 400, 0).getGraphics(), 0, 0));
+        Renderer.setTrace(null);
+        return ops;
+    }
+
+    private static Op accentFill(List<Op> ops) {
+        Op found = null;
+        for (Op op : ops) {
+            if ("fill".equals(op.kind) && op.accent()) {
+                assertNull("one accent fill", found);
+                found = op;
+            }
+        }
+        return found;
+    }
+
+    private static List<String> texts(List<Op> ops) {
+        List<String> out = new ArrayList<String>();
+        for (Op op : ops) {
+            if ("text".equals(op.kind)) {
+                out.add(op.text);
+            }
+        }
+        return out;
+    }
+
+    private static com.codename1.ui.Label nativeLabel(Control control) {
+        Component c = control.cn1Native();
+        assertTrue(c instanceof com.codename1.ui.Label);
+        return (com.codename1.ui.Label) c;
+    }
+
+    // ------------------------------------------------------------ progress
+
+    @Test
+    public void aProgressBarIsAHundredByEighteenUnlessAskedOtherwise() {
+        ProgressBar bar = new ProgressBar();
+        assertEquals(100, bar.prefWidth(-1), 0.01);
+        assertEquals(18, bar.prefHeight(-1), 0.01);
+        ProgressBar wide = new ProgressBar(0.5);
+        wide.setPrefWidth(150);
+        VBox box = new VBox(bar, wide);
+        box.resize(600, 200);
+        box.layout();
+        assertEquals(100, bar.getWidth(), 0.01);
+        assertEquals(150, wide.getWidth(), 0.01);
+        assertEquals(18, wide.getHeight(), 0.01);
+    }
+
+    private static javafx.scene.layout.Region part(ProgressBar bar, String name) {
+        Node found = bar.lookup("." + name);
+        assertTrue("no ." + name, found instanceof javafx.scene.layout.Region);
+        return (javafx.scene.layout.Region) found;
+    }
+
+    /// The bar is two regions, as in JavaFX, so that a style sheet's
+    /// `.track` and `.bar` rules have something to style.
+    @Test
+    public void aProgressBarFillsItsTrackInProportion() {
+        ProgressBar bar = new ProgressBar(0.25);
+        bar.resize(100, 18);
+        bar.layout();
+        assertEquals("the track spans the bar", 100, part(bar, "track").getWidth(), 0.01);
+        assertEquals(25, part(bar, "bar").getWidth(), 0.01);
+        assertEquals(0, part(bar, "bar").getLayoutX(), 0.01);
+        assertEquals(18, part(bar, "bar").getHeight(), 0.01);
+
+        bar.setProgress(1);
+        assertEquals(100, part(bar, "bar").getWidth(), 0.01);
+        bar.setProgress(0);
+        assertFalse("nothing is done yet", part(bar, "bar").isVisible());
+    }
+
+    @Test
+    public void aStyleSheetColoursTheTwoRegionsOfABar() {
+        ProgressBar bar = new ProgressBar(0.5);
+        bar.getStyleClass().add("time");
+        StackPane root = new StackPane(bar);
+        Scene scene = new Scene(root, 300, 100);
+        root.setStyle("-fx-accent: #ff0000;");
+        scene.cn1Layout(300, 100);
+        javafx.scene.layout.Background fill = part(bar, "bar").getBackground();
+        assertNotNull(fill);
+        assertEquals(Color.web("#ff0000"), fill.getFills().get(0).getFill());
+    }
+
+    @Test
+    public void anIndeterminateProgressBarRunsASegmentAlongTheTrack() {
+        FrameClock.setManual(true);
+        ProgressBar bar = new ProgressBar();
+        Scene scene = new Scene(new StackPane(bar), 300, 100);
+        assertNotNull(scene);
+        assertTrue("an indeterminate bar in a scene takes frames", FrameClock.isActive());
+        bar.resize(100, 18);
+        bar.layout();
+        double width = part(bar, "bar").getWidth();
+        double at = part(bar, "bar").getLayoutX();
+        assertTrue("a segment, not the whole track", width > 10 && width < 60);
+        FrameClock.advance(300);
+        bar.layout();
+        assertEquals(width, part(bar, "bar").getWidth(), 0.01);
+        assertTrue("the segment moved", part(bar, "bar").getLayoutX() > at + 5);
+        assertTrue(part(bar, "bar").getLayoutX() + width <= 100.01);
+
+        bar.setProgress(0.5);
+        assertFalse("a determinate bar takes no frames", FrameClock.isActive());
+    }
+
+    @Test
+    public void aDeterminateIndicatorShowsItsPercentageAndDone() {
+        ProgressIndicator quarter = new ProgressIndicator(0.25);
+        assertNull("the indicator draws itself", quarter.cn1Native());
+        // A disc of 32 with a line of text below it, however wide and
+        // tall the font of the platform makes that line.
+        double line = com.codename1.fxcompat.runtime.Fonts.lineHeight(javafx.scene.text.Font.getDefault());
+        double text = com.codename1.fxcompat.runtime.Fonts.width(javafx.scene.text.Font.getDefault(), "100%");
+        assertEquals(Math.max(32, text), quarter.prefWidth(-1), 1.01);
+        assertEquals(32 + 2 + line, quarter.prefHeight(-1), 1.01);
+        quarter.resize(50, 50);
+        quarter.layout();
+        Node shown = quarter.lookup(".percentage");
+        assertTrue(shown instanceof javafx.scene.text.Text);
+        assertEquals("25%", ((javafx.scene.text.Text) shown).getText());
+        assertNotNull("the part that is done", accentFill(paint(quarter)));
+
+        quarter.setProgress(1);
+        assertEquals("Done", ((javafx.scene.text.Text) shown).getText());
+    }
+
+    /// `-fx-progress-color` is the standard theme's name for the colour
+    /// of what is done, and a rule that defines it recolours the disc.
+    @Test
+    public void aRuleDefiningTheProgressColourRecoloursTheIndicator() {
+        ProgressIndicator done = new ProgressIndicator(1);
+        StackPane root = new StackPane(done);
+        Scene scene = new Scene(root, 300, 100);
+        done.setStyle("-fx-progress-color: red;");
+        scene.cn1Layout(300, 100);
+        List<Op> ops = paint(done);
+        assertEquals(Color.RED, ops.get(0).paint);
+    }
+
+    @Test
+    public void anIndeterminateIndicatorIsARingOfDotsThatTurns() {
+        FrameClock.setManual(true);
+        ProgressIndicator spinner = new ProgressIndicator();
+        Scene scene = new Scene(new StackPane(spinner), 300, 100);
+        assertNotNull(scene);
+        spinner.resize(50, 50);
+        List<Op> ops = paint(spinner);
+        assertEquals(12, ops.size());
+        assertTrue(texts(ops).isEmpty());
+        double firstBefore = ((Color) ops.get(0).paint).getOpacity();
+        FrameClock.advance(300);
+        double firstAfter = ((Color) paint(spinner).get(0).paint).getOpacity();
+        assertTrue("the bright dot moved on", firstAfter < firstBefore);
+    }
+
+    /// A spinner on a tab that is not selected is in the scene and
+    /// hidden. It used to take a frame sixty times a second all the same,
+    /// which kept an application that showed nothing moving from idling.
+    @Test
+    public void anIndicatorThatIsHiddenTakesNoFrames() {
+        FrameClock.setManual(true);
+        ProgressIndicator spinner = new ProgressIndicator();
+        StackPane tab = new StackPane(spinner);
+        Scene scene = new Scene(new StackPane(tab), 300, 100);
+        assertNotNull(scene);
+        spinner.resize(50, 50);
+        assertTrue(FrameClock.isActive());
+        FrameClock.advance(16);
+        assertTrue("visible, it goes on", FrameClock.isActive());
+        tab.setVisible(false);
+        FrameClock.advance(16);
+        assertFalse("hidden, it leaves the clock", FrameClock.isActive());
+        tab.setVisible(true);
+        paint(spinner);
+        assertTrue("painted again, it takes frames again", FrameClock.isActive());
+    }
+
+    // ------------------------------------------------------------- graphic
+
+    @Test
+    public void aGraphicIsShownBesideTheTextAndCounted() {
+        Button button = new Button("Go");
+        double textOnly = button.prefWidth(-1);
+        double height = button.prefHeight(-1);
+        Rectangle mark = new Rectangle(30, 10);
+        button.setGraphic(mark);
+        assertSame("the graphic is a node of the control", button, mark.getParent());
+        assertEquals(textOnly + 30 + button.getGraphicTextGap(), button.prefWidth(-1), 1.01);
+        assertEquals(height, button.prefHeight(-1), 1.01);
+
+        double textWidth = Units.toLogical(
+                nativeLabel(button).getUnselectedStyle().getFont().stringWidth("Go"));
+        button.resize(button.prefWidth(-1), button.prefHeight(-1));
+        button.layout();
+        double left = mark.getBoundsInParent().getMinX();
+        assertTrue("inside the button", left >= 0 && mark.getBoundsInParent().getMaxX() <= button.getWidth());
+
+        button.setContentDisplay(ContentDisplay.RIGHT);
+        button.layout();
+        assertEquals("the graphic follows the text", left + textWidth + button.getGraphicTextGap(),
+                mark.getBoundsInParent().getMinX(), 1.01);
+
+        button.setGraphicTextGap(20);
+        assertEquals(textOnly + 30 + 20, button.prefWidth(-1), 1.01);
+        button.setGraphicTextGap(4);
+
+        button.setContentDisplay(ContentDisplay.TOP);
+        assertEquals(height + 10 + 4, button.prefHeight(-1), 1.01);
+        assertEquals("as wide as the wider of the two", textOnly + Math.max(0, 30 - textWidth),
+                button.prefWidth(-1), 1.01);
+        button.resize(button.prefWidth(-1), button.prefHeight(-1));
+        button.layout();
+        assertTrue("above the text", mark.getBoundsInParent().getMaxY() <= button.getHeight() / 2 + 1);
+
+        button.setContentDisplay(ContentDisplay.TEXT_ONLY);
+        assertNull(mark.getParent());
+        assertEquals(textOnly, button.prefWidth(-1), 0.01);
+        assertEquals(height, button.prefHeight(-1), 0.01);
+
+        button.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
+        assertSame(button, mark.getParent());
+        assertEquals("", nativeLabel(button).getText());
+        assertEquals(textOnly - textWidth + 30, button.prefWidth(-1), 1.01);
+
+        button.setGraphic(null);
+        assertNull(mark.getParent());
+    }
+
+    @Test
+    public void theConstructorsWithAGraphicShowIt() {
+        Rectangle a = new Rectangle(16, 16);
+        Label label = new Label("Name", a);
+        assertSame(label, a.getParent());
+        assertTrue(label.prefWidth(-1) >= new Label("Name").prefWidth(-1) + 16);
+
+        Rectangle tall = new Rectangle(48, 48);
+        Hyperlink link = new Hyperlink("Hyperlink with Image", tall);
+        assertSame(link, tall.getParent());
+        assertTrue("as tall as its graphic", link.prefHeight(-1) >= 48);
+        link.resize(link.prefWidth(-1), link.prefHeight(-1));
+        link.layout();
+        assertTrue(tall.getBoundsInParent().getMinY() >= 0);
+        assertTrue(tall.getBoundsInParent().getMaxY() <= link.getHeight() + 0.01);
+
+        Rectangle c = new Rectangle(8, 8);
+        ToggleButton toggle = new ToggleButton("On", c);
+        assertSame(toggle, c.getParent());
+    }
+
+    // ----------------------------------------------------------- hyperlink
+
+    @Test
+    public void aHyperlinkIsAccentColouredAndUnderlinedOnlyWhileArmed() {
+        Hyperlink link = new Hyperlink("site");
+        com.codename1.ui.Label n = nativeLabel(link);
+        assertEquals(ACCENT, n.getUnselectedStyle().getFgColor() & 0xffffff);
+        assertEquals(Style.TEXT_DECORATION_NONE, n.getUnselectedStyle().getTextDecoration());
+        link.arm();
+        assertEquals(Style.TEXT_DECORATION_UNDERLINE, n.getUnselectedStyle().getTextDecoration());
+        link.disarm();
+        assertEquals(Style.TEXT_DECORATION_NONE, n.getUnselectedStyle().getTextDecoration());
+
+        link.fire();
+        assertTrue(link.isVisited());
+        assertTrue("a visited link looks visited", (n.getUnselectedStyle().getFgColor() & 0xffffff) != ACCENT);
+        link.setVisited(false);
+        assertEquals(ACCENT, n.getUnselectedStyle().getFgColor() & 0xffffff);
+
+        link.setTextFill(Color.RED);
+        assertEquals(0xff0000, n.getUnselectedStyle().getFgColor() & 0xffffff);
+        link.setUnderline(true);
+        assertEquals(Style.TEXT_DECORATION_UNDERLINE, n.getUnselectedStyle().getTextDecoration());
+    }
+
+    // ------------------------------------------------------------ disabled
+
+    @Test
+    public void aDisabledControlIsDimmedOnce() {
+        Button button = new Button("Go");
+        assertEquals(1, PeerPaint.opacity(button), 0);
+        button.setDisable(true);
+        assertEquals(0.4, PeerPaint.opacity(button), 0.001);
+        button.setOpacity(0.5);
+        assertEquals(0.2, PeerPaint.opacity(button), 0.001);
+        button.setOpacity(1);
+
+        // The label is in a disabled button, which dims it already.
+        Label inside = new Label("in");
+        button.setGraphic(inside);
+        assertTrue(inside.isDisabled());
+        assertEquals(1, PeerPaint.opacity(inside), 0);
+
+        // A pane is not dimmed; each control in a disabled pane is.
+        CheckBox check = new CheckBox("c");
+        HBox pane = new HBox(check);
+        pane.setDisable(true);
+        assertEquals(1, PeerPaint.opacity(pane), 0);
+        assertEquals(0.4, PeerPaint.opacity(check), 0.001);
+        pane.setDisable(false);
+        assertEquals(1, PeerPaint.opacity(check), 0);
+    }
+
+    // -------------------------------------------------- choice and toggles
+
+    @Test
+    public void aChoiceBoxShowsADropDownArrowAfterItsText() {
+        ChoiceBox<String> box = new ChoiceBox<String>();
+        box.getItems().addAll("Dog", "Cat");
+        box.setValue("Dog");
+        com.codename1.ui.Label n = nativeLabel(box);
+        assertEquals(com.codename1.ui.FontImage.MATERIAL_ARROW_DROP_DOWN, n.getMaterialIcon());
+        assertEquals("the text is left of the arrow", Component.LEFT, n.getTextPosition());
+    }
+
+    @Test
+    public void aToggleButtonHasTheChromeOfAButtonAndCentredText() {
+        ToggleButton toggle = new ToggleButton("Cat");
+        com.codename1.ui.Label n = nativeLabel(toggle);
+        assertEquals("a theme with no toggle look gets the button look", "Button", n.getUIID());
+        assertEquals(Component.CENTER, n.getAlignment());
+        assertTrue(n instanceof com.codename1.ui.Button);
+        com.codename1.ui.Button b = (com.codename1.ui.Button) n;
+        assertTrue(b.isToggle());
+        assertFalse(b.isSelected());
+        toggle.setSelected(true);
+        assertTrue("drawn pressed while selected", b.isSelected());
+
+        assertEquals(Component.CENTER, nativeLabel(new Button("Go")).getAlignment());
+        assertEquals(Component.LEFT, nativeLabel(new RadioButton("r")).getAlignment());
+        assertEquals(Component.LEFT, nativeLabel(new Label("l")).getAlignment());
+    }
+
+    // ------------------------------------------------------------- overrun
+
+    @Test
+    public void aLabelGivesWayInARowThatIsTooNarrow() {
+        // The theme's own default is no ellipsis, and it is what a label
+        // gets once a theme was loaded: the layer asks for one itself.
+        com.codename1.ui.plaf.LookAndFeel laf = com.codename1.ui.plaf.UIManager.getInstance().getLookAndFeel();
+        boolean before = laf.isDefaultEndsWith3Points();
+        laf.setDefaultEndsWith3Points(false);
+        Label label;
+        try {
+            label = new Label("A long label that cannot be shown in full here");
+            nativeLabel(label);
+        } finally {
+            laf.setDefaultEndsWith3Points(before);
+        }
+        Button ok = new Button("OK");
+        double pref = label.prefWidth(-1);
+        double min = label.minWidth(-1);
+        assertTrue("min " + min + " pref " + pref, min < pref / 2);
+        assertTrue(min > 0);
+        assertTrue(nativeLabel(label).isEndsWith3Points());
+
+        HBox row = new HBox(label, ok);
+        double width = ok.prefWidth(-1) + pref / 2;
+        row.resize(width, 40);
+        row.layout();
+        assertTrue("the label shrank: " + label.getWidth(), label.getWidth() < pref);
+        assertTrue("the button after it is still in view",
+                ok.getBoundsInParent().getMaxX() <= width + 0.01);
+        // The button gives up padding of its theme with the label, and
+        // none of its text.
+        com.codename1.ui.Label n = (com.codename1.ui.Label) ok.cn1Native();
+        com.codename1.ui.plaf.Style style = n.getUnselectedStyle();
+        assertTrue(Units.toPixels(ok.getWidth()) - style.getHorizontalPadding()
+                >= style.getFont().stringWidth("OK"));
+    }
+
+    // ---------------------------------------------- what the native lacks
+
+    /// The native slider draws no ticks, so the layer does: one label for
+    /// every major unit, in a band the slider grows by.
+    @Test
+    public void aSliderDrawsTheTickMarksAndLabelsItWasAskedFor() {
+        Slider plain = new Slider(0, 100, 40);
+        new Scene(new StackPane(plain), 300, 100);
+        double bare = plain.prefHeight(-1);
+        assertTrue("nothing is drawn unasked", paint(plain).isEmpty());
+
+        Slider slider = new Slider(0, 100, 40);
+        slider.setMajorTickUnit(25);
+        slider.setMinorTickCount(4);
+        slider.setShowTickMarks(true);
+        slider.setShowTickLabels(true);
+        new Scene(new StackPane(slider), 300, 100);
+        double tall = slider.prefHeight(-1);
+        assertTrue("the ticks have room of their own: " + bare + " -> " + tall, tall > bare + 10);
+        slider.resize(300, tall);
+        slider.layout();
+
+        List<Op> ops = paint(slider);
+        assertEquals(java.util.Arrays.asList("0", "25", "50", "75", "100"), texts(ops));
+        int marks = 0;
+        double left = Double.MAX_VALUE;
+        double right = -Double.MAX_VALUE;
+        for (Op op : ops) {
+            if ("fill".equals(op.kind)) {
+                marks++;
+                left = Math.min(left, op.bounds[0]);
+                right = Math.max(right, op.bounds[2]);
+            }
+        }
+        // Five major marks and four minor ones in each of the four gaps.
+        assertEquals(21, marks);
+        assertTrue("the marks span the track: " + left + ".." + right, right - left > 200);
+
+        // The native slider keeps clear of the band.
+        Component c = slider.cn1Native();
+        assertTrue("native " + c.getHeight() + " of " + tall,
+                Units.toLogical(c.getHeight()) <= tall - 10);
+
+        slider.setShowTickLabels(false);
+        assertTrue(texts(paint(slider)).isEmpty());
+        assertTrue(slider.prefHeight(-1) < tall);
+    }
+
+    /// A theme that says nothing of a slider's thumb draws the filled part
+    /// of the track and stops: a slider with nothing to take hold of. The
+    /// layer draws the thumb then, round and centred where the filled part
+    /// ends, so moving the value changes pixels on both sides of both
+    /// places, which a track alone does only between them.
+    @Test
+    public void aSliderHasAThumbWhereTheThemeDrawsNone() {
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        try {
+            Slider slider = new Slider(0, 100, 30);
+            new Scene(new StackPane(slider), 300, 100);
+            double high = slider.prefHeight(-1);
+            assertTrue("room for the thumb: " + high, high >= 20);
+            slider.resize(200, high);
+            slider.layout();
+            Component c = slider.cn1Native();
+            int w = c.getWidth();
+            int h = c.getHeight();
+            int[] low = raster(slider);
+            slider.setValue(70);
+            int[] far = raster(slider);
+            int before = 0;
+            int after = 0;
+            int top = h;
+            int bottom = -1;
+            for (int y = 0; y < h; y++) {
+                for (int x = 0; x < w; x++) {
+                    if (low[y * w + x] == far[y * w + x]) {
+                        continue;
+                    }
+                    if (x < w * 30 / 100 - 2) {
+                        before++;
+                        top = Math.min(top, y);
+                        bottom = Math.max(bottom, y);
+                    } else if (x > w * 70 / 100 + 2) {
+                        after++;
+                    }
+                }
+            }
+            assertTrue("a thumb left of the lower value: " + before, before >= 20);
+            assertTrue("a thumb right of the higher value: " + after, after >= 20);
+            assertTrue("the thumb is round, not a slice of the track: " + top + ".." + bottom, bottom - top >= 10);
+        } finally {
+            HeadlessImplementation.rasterImages = false;
+            HeadlessImplementation.pixelImages = false;
+        }
+    }
+
+    /// The native check box has two looks; the third state gets a dash of
+    /// its own, and loses it when the box is determined again.
+    @Test
+    public void anIndeterminateCheckBoxShowsADash() {
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        try {
+            CheckBox box = new CheckBox("Maybe");
+            new Scene(new StackPane(box), 300, 100);
+            box.resize(box.prefWidth(-1), box.prefHeight(-1));
+            box.layout();
+            // Red, since the headless display draws the glyph of a themed
+            // box as a block of the theme's colour: a dash of that colour
+            // would be lost in it whenever an earlier class left a theme.
+            box.setTextFill(javafx.scene.paint.Color.RED);
+            int[] empty = raster(box);
+            box.setIndeterminate(true);
+            int[] dashed = raster(box);
+            int changed = 0;
+            for (int i = 0; i < empty.length; i++) {
+                if (empty[i] != dashed[i]) {
+                    changed++;
+                }
+            }
+            assertTrue("a dash was drawn: " + changed + " pixels", changed >= 8);
+            box.setIndeterminate(false);
+            assertTrue(java.util.Arrays.equals(empty, raster(box)));
+        } finally {
+            HeadlessImplementation.rasterImages = false;
+            HeadlessImplementation.pixelImages = false;
+        }
+    }
+
+    private static int[] raster(Control control) {
+        Component c = control.cn1Native();
+        com.codename1.ui.Image image = com.codename1.ui.Image.createImage(
+                Math.max(1, c.getWidth()), Math.max(1, c.getHeight()), 0xffffffff);
+        com.codename1.ui.Graphics g = image.getGraphics();
+        g.translate(-c.getX(), -c.getY());
+        c.paintComponent(g, false);
+        return image.getRGB();
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlSizeTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlSizeTest.java
new file mode 100644
index 00000000000..e7a64c07b77
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlSizeTest.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.scene.control.Button;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
+import javafx.scene.paint.Paint;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/// The size a layout pane gives a control whose preferred size was set.
+public class ControlSizeTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Renderer.setTrace(null);
+        Units.setScale(0);
+    }
+
+    /// The toolbar of 2048FX: buttons with no text, sized by the
+    /// application and drawn as an icon by `-fx-shape`.
+    @Test
+    public void aButtonWithNoTextKeepsThePreferredSizeItWasGiven() {
+        Button icon = new Button();
+        icon.setPrefSize(40, 40);
+        assertEquals(40, icon.maxWidth(-1), 0.01);
+        assertEquals(40, icon.maxHeight(-1), 0.01);
+        HBox bar = new HBox(icon);
+        bar.resize(300, 60);
+        bar.layout();
+        assertEquals(40, icon.getWidth(), 0.01);
+        assertEquals(40, icon.getHeight(), 0.01);
+    }
+
+    @Test
+    public void aStackPaneDoesNotStretchAButtonPastItsPreferredSize() {
+        Button icon = new Button();
+        icon.setPrefSize(40, 30);
+        StackPane pane = new StackPane(icon);
+        pane.resize(200, 200);
+        pane.layout();
+        assertEquals(40, icon.getWidth(), 0.01);
+        assertEquals(30, icon.getHeight(), 0.01);
+    }
+
+    @Test
+    public void theShapeOfASizedButtonIsFilled() {
+        Button icon = new Button();
+        icon.setPrefSize(40, 40);
+        icon.setStyle("-fx-shape: \"M0 0h4v12h-4z\"; -fx-background-color: #f9f6f2;");
+        // A style is applied by the scene, at its layout.
+        new javafx.scene.Scene(new HBox(icon), 300, 60).cn1Layout(300, 60);
+        assertEquals(40, icon.getWidth(), 0.01);
+        final List<String> drawn = new ArrayList<String>();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                drawn.add(operation + ":" + Math.round(deviceBounds[2]) + "x" + Math.round(deviceBounds[3]));
+            }
+        });
+        icon.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(100, 100, 0).getGraphics(), 0, 0));
+        assertTrue("drew " + drawn, drawn.contains("fill:40x40"));
+    }
+
+    /// A label is its text and nothing around it: the padding the native
+    /// theme gives its own labels is not part of a JavaFX one, and with it
+    /// every row of labels stood taller than the original.
+    @Test
+    public void aLabelIsAsTallAsItsLineOfText() {
+        javafx.scene.control.Label label = new javafx.scene.control.Label("First Name");
+        label.setFont(javafx.scene.text.Font.font(20));
+        javafx.scene.text.Text text = new javafx.scene.text.Text("First Name");
+        text.setFont(javafx.scene.text.Font.font(20));
+        new javafx.scene.Scene(new HBox(label, text), 300, 60).cn1Layout(300, 60);
+        double line = text.getLayoutBounds().getHeight();
+        assertEquals(line, label.prefHeight(-1), 2.5);
+    }
+
+    /// The last letter of an italic leans past the width its text
+    /// measures, and a native label clips its text to that width: a label
+    /// given its preferred width is wider by the lean, and all of the
+    /// letter is drawn. The display here draws a text as a box that many
+    /// pixels wider than it measures, which is what a port does.
+    @Test
+    public void anItalicLabelHasRoomForTheLeanOfItsLastLetter() {
+        boolean before = HeadlessImplementation.rasterImages;
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.trackClip = true;
+        HeadlessImplementation.textOverhang = 5;
+        com.codename1.fxcompat.runtime.Fonts.flush();
+        javafx.stage.Stage stage = new javafx.stage.Stage();
+        try {
+            javafx.scene.control.Label upright = new javafx.scene.control.Label("Small");
+            javafx.scene.control.Label italic = new javafx.scene.control.Label("Small");
+            italic.setFont(javafx.scene.text.Font.font("System", javafx.scene.text.FontPosture.ITALIC, 12));
+            italic.setTextFill(javafx.scene.paint.Color.RED);
+            javafx.scene.control.Label spaced = new javafx.scene.control.Label("Small ");
+            spaced.setFont(italic.getFont());
+            stage.setScene(new javafx.scene.Scene(new javafx.scene.layout.VBox(upright, italic, spaced), 600, 400));
+            stage.show();
+            int text = 5 * HeadlessImplementation.CHAR_WIDTH;
+            assertEquals(text, upright.getWidth(), 0.01);
+            assertEquals(text + 5, italic.getWidth(), 0.01);
+            assertEquals("nothing leans out of a space", text + HeadlessImplementation.CHAR_WIDTH, spaced.getWidth(),
+                    0.01);
+            com.codename1.ui.Form f = (com.codename1.ui.Form) stage.cn1Host();
+            f.revalidate();
+            com.codename1.ui.Image picture = com.codename1.ui.Image.createImage(HeadlessImplementation.WIDTH,
+                    HeadlessImplementation.HEIGHT, 0xffffffff);
+            com.codename1.ui.Graphics g = picture.getGraphics();
+            g.setClip(0, 0, HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+            f.paintComponent(g);
+            int[] rgb = picture.getRGB();
+            int red = 0;
+            int row = -1;
+            for (int i = 0; i < rgb.length && (row < 0 || i / HeadlessImplementation.WIDTH == row); i++) {
+                if (rgb[i] == 0xffff0000) {
+                    row = i / HeadlessImplementation.WIDTH;
+                    red++;
+                }
+            }
+            assertEquals("the pixels of one row of the italic text", text + 5, red);
+        } finally {
+            stage.hide();
+            HeadlessImplementation.textOverhang = 0;
+            HeadlessImplementation.trackClip = false;
+            HeadlessImplementation.rasterImages = before;
+            HeadlessImplementation.resetRaster();
+            com.codename1.fxcompat.runtime.Fonts.flush();
+        }
+    }
+
+    /// The standard theme draws a column's header bold, and a style sheet
+    /// that only changes its size keeps that.
+    @Test
+    public void aColumnHeaderIsBoldUntilAStyleSheetSaysOtherwise() {
+        javafx.scene.control.TableView<String> table = new javafx.scene.control.TableView<String>();
+        table.getColumns().add(new javafx.scene.control.TableColumn<String, String>("First Name"));
+        new javafx.scene.Scene(new StackPane(table), 300, 200).cn1Layout(300, 200);
+        javafx.scene.Node found = table.lookup(".column-header .label");
+        assertTrue("no header label", found instanceof javafx.scene.control.Label);
+        javafx.scene.control.Label header = (javafx.scene.control.Label) found;
+        assertTrue("header font is " + header.getFont().getStyle(),
+                header.getFont().getStyle().indexOf("Bold") >= 0);
+    }
+
+    /// Ensemble's coloured buttons: `setStyle("-fx-base: ...")` on a
+    /// button that has no other style. Only the standard theme's button
+    /// is coloured by that name, so the button takes that look.
+    @Test
+    public void anInlineBaseColourMakesAButtonOfThatColour() {
+        Button plain = new Button("Plain");
+        Button red = new Button("Red");
+        red.setStyle("-fx-base: #ff0000;");
+        new javafx.scene.Scene(new HBox(plain, red), 300, 60).cn1Layout(300, 60);
+        assertTrue("a plain button is the native theme's", plain.getBackground() == null
+                || plain.getBackground().getFills().isEmpty());
+        javafx.scene.layout.Background drawn = red.getBackground();
+        assertTrue("the red button draws itself", drawn != null && drawn.getFills().size() == 4);
+        Paint body = drawn.getFills().get(3).getFill();
+        assertTrue("the body is a gradient", body instanceof javafx.scene.paint.LinearGradient);
+        javafx.scene.paint.Color top = ((javafx.scene.paint.LinearGradient) body).getStops().get(0).getColor();
+        assertTrue("of the base colour: " + top, top.getRed() > 0.9 && top.getBlue() < 0.3);
+        // Light text on a dark colour, as the theme's ladder picks it.
+        assertEquals(javafx.scene.paint.Color.WHITE, red.getTextFill());
+        // Two thirds of an em at either side.
+        assertEquals(javafx.scene.text.Font.getDefault().getSize() * 2 / 3, red.getPadding().getLeft(), 0.1);
+
+        red.setStyle("");
+        new javafx.scene.Scene(new HBox(red), 300, 60).cn1Layout(300, 60);
+        assertTrue("and the native look again without it", red.getBackground() == null
+                || red.getBackground().getFills().isEmpty());
+    }
+
+    @Test
+    public void aLabelGivenAWidthNarrowerThanItsTextKeepsThatWidth() {
+        // The text is cut short with an ellipsis; the label is not made
+        // as wide as the text, before it is shown or after.
+        javafx.scene.layout.TilePane tiles = new javafx.scene.layout.TilePane(5, 5);
+        javafx.scene.control.Label[] labels = new javafx.scene.control.Label[3];
+        String[] texts = {"HAND", "A_VERY_LONG_NAME_THAT_DOES_NOT_FIT_AT_ALL", "MOVE"};
+        for (int i = 0; i < labels.length; i++) {
+            labels[i] = new javafx.scene.control.Label(texts[i]);
+            labels[i].setAlignment(javafx.geometry.Pos.CENTER);
+            labels[i].setPrefSize(85, 65);
+            labels[i].setStyle("-fx-border-color: #aaaaaa; -fx-background-color: #dddddd;");
+            tiles.getChildren().add(labels[i]);
+        }
+        assertEquals(85, labels[1].prefWidth(-1), 0.01);
+        // Five columns is what a tile pane asks for when it is not told.
+        assertEquals(5 * 85 + 4 * 5, tiles.prefWidth(-1), 0.01);
+        javafx.scene.Scene scene = new javafx.scene.Scene(tiles, 600, 400);
+        scene.cn1Layout(600, 400);
+        scene.cn1Layout(600, 400);
+        assertEquals(85, labels[1].getWidth(), 0.01);
+        assertEquals(90, labels[1].getLayoutX() - labels[0].getLayoutX(), 0.01);
+        assertEquals(85, labels[1].prefWidth(-1), 0.01);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsBasicTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsBasicTest.java
new file mode 100644
index 00000000000..12054792bc2
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsBasicTest.java
@@ -0,0 +1,760 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.css.PseudoClass;
+import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.event.EventHandler;
+import javafx.geometry.Bounds;
+import javafx.geometry.Orientation;
+import javafx.geometry.Side;
+import javafx.scene.Scene;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.Control;
+import javafx.scene.control.Hyperlink;
+import javafx.scene.control.IndexRange;
+import javafx.scene.control.PasswordField;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.control.ProgressIndicator;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.Separator;
+import javafx.scene.control.Slider;
+import javafx.scene.control.SplitPane;
+import javafx.scene.control.Tab;
+import javafx.scene.control.TabPane;
+import javafx.scene.control.TextArea;
+import javafx.scene.control.TextField;
+import javafx.scene.control.Toggle;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+
+/// The basic controls: text input, toggles, ranges, and the scroll, split
+/// and tab panes.
+public class ControlsBasicTest {
+
+    private static final double EPS = 0.6;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+    }
+
+    private static boolean has(javafx.scene.Node node, String pseudoClass) {
+        return node.getPseudoClassStates().contains(PseudoClass.getPseudoClass(pseudoClass));
+    }
+
+    private static void press(Control control) {
+        Component c = control.cn1Native();
+        assertTrue(c instanceof com.codename1.ui.Button);
+        com.codename1.ui.Button b = (com.codename1.ui.Button) c;
+        b.pressed();
+        b.released();
+    }
+
+    private static Region box(double w, double h) {
+        Region r = new Region();
+        r.setMinSize(10, 10);
+        r.setPrefSize(w, h);
+        r.setMaxSize(Double.MAX_VALUE, Double.MAX_VALUE);
+        return r;
+    }
+
+    private static void assertPrefSize(Control c) {
+        double w = c.prefWidth(-1);
+        double h = c.prefHeight(-1);
+        assertTrue(c.getClass().getName() + " pref width " + w, w > 0 && w < 2000);
+        assertTrue(c.getClass().getName() + " pref height " + h, h > 0 && h < 2000);
+    }
+
+    // ---------------------------------------------------------------- text
+
+    @Test
+    public void textFieldSyncsBothWays() {
+        TextField field = new TextField("one");
+        Component c = field.cn1Native();
+        assertTrue(c instanceof com.codename1.ui.TextField);
+        com.codename1.ui.TextField nativeField = (com.codename1.ui.TextField) c;
+        assertEquals("one", nativeField.getText());
+
+        field.setText("two");
+        assertEquals("two", nativeField.getText());
+
+        final List<String> seen = new ArrayList<String>();
+        field.textProperty().addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> o, String oldValue, String newValue) {
+                seen.add(oldValue + ">" + newValue);
+            }
+        });
+        nativeField.setText("typed");
+        assertEquals("typed", field.getText());
+        assertEquals("[two>typed]", seen.toString());
+        assertEquals(5, field.getLength());
+
+        field.setPromptText("hint");
+        assertEquals("hint", nativeField.getHint());
+        field.setEditable(false);
+        assertFalse(nativeField.isEditable());
+        assertTrue(has(field, "readonly"));
+        field.setEditable(true);
+        assertTrue(nativeField.isEditable());
+    }
+
+    @Test
+    public void textEditingApi() {
+        TextField field = new TextField();
+        field.appendText("hello");
+        field.appendText(" world");
+        assertEquals("hello world", field.getText());
+        assertEquals(11, field.getLength());
+        assertEquals("hello", field.getText(0, 5));
+        field.insertText(5, ",");
+        assertEquals("hello, world", field.getText());
+        field.deleteText(5, 6);
+        assertEquals("hello world", field.getText());
+        field.replaceText(0, 5, "HOWDY");
+        assertEquals("HOWDY world", field.getText());
+
+        field.selectRange(0, 5);
+        assertEquals("HOWDY", field.getSelectedText());
+        assertEquals(new IndexRange(0, 5), field.getSelection());
+        assertEquals(0, field.getAnchor());
+        assertEquals(5, field.getCaretPosition());
+        field.replaceSelection("hi");
+        assertEquals("hi world", field.getText());
+        field.selectAll();
+        assertEquals(8, field.getSelection().getLength());
+        field.deselect();
+        assertEquals(0, field.getSelection().getLength());
+        field.positionCaret(2);
+        assertEquals(2, field.getCaretPosition());
+        field.end();
+        assertEquals(8, field.getCaretPosition());
+        assertTrue(field.deletePreviousChar());
+        assertEquals("hi worl", field.getText());
+        field.home();
+        assertTrue(field.deleteNextChar());
+        assertEquals("i worl", field.getText());
+
+        field.clear();
+        assertEquals("", field.getText());
+        assertEquals(0, field.getLength());
+        assertEquals("", ((com.codename1.ui.TextField) field.cn1Native()).getText());
+
+        IndexRange range = IndexRange.valueOf("2, 7");
+        assertEquals(2, range.getStart());
+        assertEquals(7, range.getEnd());
+        assertEquals(5, range.getLength());
+        assertEquals(new IndexRange(3, 9), IndexRange.normalize(9, 3));
+    }
+
+    @Test
+    public void textFieldActionAndColumns() {
+        TextField field = new TextField();
+        final int[] fired = new int[1];
+        field.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                fired[0]++;
+            }
+        });
+        Component c = field.cn1Native();
+        assertTrue(c instanceof com.codename1.ui.TextField);
+        final com.codename1.ui.TextField nativeField = (com.codename1.ui.TextField) c;
+        if (Display.getInstance().isEdt()) {
+            nativeField.fireDoneEvent();
+        } else {
+            // The native field hands the event over to the event thread.
+            Display.getInstance().callSeriallyAndWait(new Runnable() {
+                @Override
+                public void run() {
+                    nativeField.fireDoneEvent();
+                }
+            });
+        }
+        assertEquals(1, fired[0]);
+
+        assertEquals(TextField.DEFAULT_PREF_COLUMN_COUNT, field.getPrefColumnCount());
+        double narrow = field.prefWidth(-1);
+        field.setPrefColumnCount(40);
+        assertTrue(field.prefWidth(-1) > narrow);
+        assertPrefSize(field);
+    }
+
+    @Test
+    public void passwordFieldAndTextArea() {
+        PasswordField password = new PasswordField();
+        Component p = password.cn1Native();
+        assertTrue(p instanceof com.codename1.ui.TextField);
+        assertTrue((((com.codename1.ui.TextField) p).getConstraint() & com.codename1.ui.TextArea.PASSWORD) != 0);
+        password.setText("secret");
+        assertEquals("secret", ((com.codename1.ui.TextField) p).getText());
+        assertPrefSize(password);
+
+        TextArea area = new TextArea("a\nb");
+        Component a = area.cn1Native();
+        assertTrue(a instanceof com.codename1.ui.TextArea);
+        com.codename1.ui.TextArea nativeArea = (com.codename1.ui.TextArea) a;
+        assertEquals("a\nb", nativeArea.getText());
+        assertFalse(nativeArea.isSingleLineTextArea());
+        nativeArea.setText("changed\nthere");
+        assertEquals("changed\nthere", area.getText());
+        area.appendText("!");
+        assertEquals("changed\nthere!", nativeArea.getText());
+        area.setPrefRowCount(4);
+        area.setPrefColumnCount(20);
+        assertEquals(4, nativeArea.getRows());
+        assertEquals(20, nativeArea.getColumns());
+        area.setWrapText(true);
+        assertTrue(area.isWrapText());
+        assertPrefSize(area);
+    }
+
+    // ------------------------------------------------------------- toggles
+
+    @Test
+    public void checkBoxSyncAndTriStateCycle() {
+        CheckBox box = new CheckBox("Agree");
+        Component c = box.cn1Native();
+        assertTrue(c instanceof com.codename1.ui.CheckBox);
+        com.codename1.ui.CheckBox nativeBox = (com.codename1.ui.CheckBox) c;
+        assertEquals("Agree", nativeBox.getText());
+        assertFalse(nativeBox.isSelected());
+
+        box.setSelected(true);
+        assertTrue(nativeBox.isSelected());
+        assertTrue(has(box, "selected"));
+
+        final List<Boolean> seen = new ArrayList<Boolean>();
+        final int[] actions = new int[1];
+        box.selectedProperty().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> o, Boolean oldValue, Boolean newValue) {
+                seen.add(newValue);
+            }
+        });
+        box.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                actions[0]++;
+            }
+        });
+        press(box);
+        assertFalse(box.isSelected());
+        assertFalse(nativeBox.isSelected());
+        assertEquals("[false]", seen.toString());
+        assertEquals(1, actions[0]);
+        assertFalse(has(box, "selected"));
+
+        // unchecked -> indeterminate -> checked -> unchecked
+        box.setAllowIndeterminate(true);
+        box.fire();
+        assertTrue(box.isIndeterminate());
+        assertFalse(box.isSelected());
+        assertTrue(has(box, "indeterminate"));
+        assertFalse(nativeBox.isSelected());
+        box.fire();
+        assertFalse(box.isIndeterminate());
+        assertTrue(box.isSelected());
+        assertTrue(nativeBox.isSelected());
+        assertFalse(has(box, "indeterminate"));
+        box.fire();
+        assertFalse(box.isIndeterminate());
+        assertFalse(box.isSelected());
+        press(box);
+        assertTrue(box.isIndeterminate());
+        assertPrefSize(box);
+    }
+
+    @Test
+    public void toggleGroupIsExclusive() {
+        ToggleGroup group = new ToggleGroup();
+        RadioButton a = new RadioButton("a");
+        RadioButton b = new RadioButton("b");
+        ToggleButton c = new ToggleButton("c");
+        a.setToggleGroup(group);
+        b.setToggleGroup(group);
+        c.setToggleGroup(group);
+        assertEquals(3, group.getToggles().size());
+        assertNull(group.getSelectedToggle());
+
+        final List<Toggle> seen = new ArrayList<Toggle>();
+        group.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
+            @Override
+            public void changed(ObservableValue<? extends Toggle> o, Toggle oldValue, Toggle newValue) {
+                seen.add(newValue);
+            }
+        });
+        a.setSelected(true);
+        assertSame(a, group.getSelectedToggle());
+        b.setSelected(true);
+        assertSame(b, group.getSelectedToggle());
+        assertFalse(a.isSelected());
+        assertTrue(has(b, "selected"));
+        assertFalse(has(a, "selected"));
+        Component na = a.cn1Native();
+        Component nb = b.cn1Native();
+        assertTrue(na instanceof com.codename1.ui.RadioButton);
+        assertFalse(((com.codename1.ui.RadioButton) na).isSelected());
+        assertTrue(((com.codename1.ui.RadioButton) nb).isSelected());
+
+        // Clicking the selected radio button of a group leaves it selected.
+        press(b);
+        assertTrue(b.isSelected());
+        assertSame(b, group.getSelectedToggle());
+        // Clicking another one moves the selection.
+        press(a);
+        assertTrue(a.isSelected());
+        assertFalse(b.isSelected());
+        assertFalse(((com.codename1.ui.RadioButton) nb).isSelected());
+        assertSame(a, group.getSelectedToggle());
+
+        // A toggle button of a group can be deselected by clicking it.
+        press(c);
+        assertTrue(c.isSelected());
+        assertFalse(a.isSelected());
+        press(c);
+        assertFalse(c.isSelected());
+        assertNull(group.getSelectedToggle());
+
+        group.selectToggle(b);
+        assertTrue(b.isSelected());
+        b.setToggleGroup(null);
+        assertEquals(2, group.getToggles().size());
+        assertNull(group.getSelectedToggle());
+        assertFalse(seen.isEmpty());
+        assertPrefSize(a);
+        assertPrefSize(c);
+    }
+
+    @Test
+    public void hyperlinkVisited() {
+        Hyperlink link = new Hyperlink("site");
+        final int[] actions = new int[1];
+        link.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                actions[0]++;
+            }
+        });
+        assertFalse(link.isVisited());
+        press(link);
+        assertEquals(1, actions[0]);
+        assertTrue(link.isVisited());
+        assertTrue(has(link, "visited"));
+        link.setVisited(false);
+        assertFalse(has(link, "visited"));
+        assertPrefSize(link);
+    }
+
+    @Test
+    public void separatorOrientation() {
+        Separator separator = new Separator();
+        assertEquals(Orientation.HORIZONTAL, separator.getOrientation());
+        assertTrue(has(separator, "horizontal"));
+        double thin = separator.prefHeight(-1);
+        assertTrue(thin > 0 && thin < 10);
+        assertEquals(Double.MAX_VALUE, separator.maxWidth(-1), 0);
+        separator.setOrientation(Orientation.VERTICAL);
+        assertTrue(has(separator, "vertical"));
+        assertFalse(has(separator, "horizontal"));
+        assertTrue(separator.prefWidth(-1) > 0 && separator.prefWidth(-1) < 10);
+        assertEquals(Double.MAX_VALUE, separator.maxHeight(-1), 0);
+    }
+
+    // -------------------------------------------------------------- ranges
+
+    @Test
+    public void sliderClampsAndAdjusts() {
+        Slider slider = new Slider(0, 100, 50);
+        Component c = slider.cn1Native();
+        assertTrue(c instanceof com.codename1.ui.Slider);
+        com.codename1.ui.Slider nativeSlider = (com.codename1.ui.Slider) c;
+        int span = nativeSlider.getMaxValue() - nativeSlider.getMinValue();
+        assertTrue(span > 0);
+        assertEquals(span / 2, nativeSlider.getProgress() - nativeSlider.getMinValue());
+
+        slider.setValue(150);
+        assertEquals(100, slider.getValue(), 0);
+        slider.setValue(-20);
+        assertEquals(0, slider.getValue(), 0);
+        assertEquals(nativeSlider.getMinValue(), nativeSlider.getProgress());
+
+        final List<Double> seen = new ArrayList<Double>();
+        slider.valueProperty().addListener(new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> o, Number oldValue, Number newValue) {
+                seen.add(Double.valueOf(newValue.doubleValue()));
+            }
+        });
+        nativeSlider.setProgress(nativeSlider.getMinValue() + span / 4);
+        assertEquals(25, slider.getValue(), 0.01);
+        assertEquals(1, seen.size());
+
+        slider.setValue(50);
+        slider.increment();
+        assertEquals(60, slider.getValue(), 0);
+        slider.decrement();
+        slider.decrement();
+        assertEquals(40, slider.getValue(), 0);
+        slider.adjustValue(77);
+        assertEquals(77, slider.getValue(), 0);
+        slider.adjustValue(500);
+        assertEquals(100, slider.getValue(), 0);
+
+        slider.setMax(60);
+        assertEquals(60, slider.getValue(), 0);
+        slider.setMin(70);
+        assertTrue(slider.getMax() >= slider.getMin());
+        assertTrue(slider.getValue() >= slider.getMin() && slider.getValue() <= slider.getMax());
+
+        Slider snapping = new Slider(0, 100, 0);
+        snapping.setMajorTickUnit(20);
+        snapping.setMinorTickCount(0);
+        snapping.setSnapToTicks(true);
+        snapping.adjustValue(33);
+        assertEquals(40, snapping.getValue(), 0);
+        assertPrefSize(slider);
+        snapping.setOrientation(Orientation.VERTICAL);
+        assertPrefSize(snapping);
+    }
+
+    @Test
+    public void progressIndeterminate() {
+        ProgressBar bar = new ProgressBar();
+        assertTrue(bar.isIndeterminate());
+        assertEquals(ProgressIndicator.INDETERMINATE_PROGRESS, bar.getProgress(), 0);
+        assertTrue(has(bar, "indeterminate"));
+        // The bar draws itself; ControlLookTest covers what it draws.
+        assertNull(bar.cn1Native());
+
+        final List<Boolean> seen = new ArrayList<Boolean>();
+        bar.indeterminateProperty().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> o, Boolean oldValue, Boolean newValue) {
+                seen.add(newValue);
+            }
+        });
+        bar.setProgress(0.5);
+        assertFalse(bar.isIndeterminate());
+        assertEquals("[false]", seen.toString());
+        assertFalse(has(bar, "indeterminate"));
+        assertTrue(has(bar, "determinate"));
+        bar.setProgress(-1);
+        assertTrue(bar.isIndeterminate());
+        assertEquals(100, bar.prefWidth(-1), 0.01);
+        assertPrefSize(bar);
+
+        ProgressIndicator indicator = new ProgressIndicator();
+        assertTrue(indicator.isIndeterminate());
+        indicator.setProgress(1);
+        assertFalse(indicator.isIndeterminate());
+        assertPrefSize(indicator);
+        assertPrefSize(new ProgressIndicator(0.25));
+    }
+
+    // --------------------------------------------------------------- panes
+
+    @Test
+    public void scrollPaneViewportAndScrolling() {
+        Region content = new Region();
+        content.setMinSize(400, 600);
+        content.setPrefSize(400, 600);
+        content.setMaxSize(400, 600);
+        ScrollPane pane = new ScrollPane(content);
+        Pane root = new Pane();
+        root.getChildren().add(pane);
+        Scene scene = new Scene(root, 300, 300);
+        pane.resizeRelocate(0, 0, 200, 150);
+        scene.cn1Layout(300, 300);
+        pane.resize(200, 150);
+        pane.layout();
+
+        // The content is a real descendant at its own size.
+        assertSame(scene, content.getScene());
+        assertEquals(400, content.getWidth(), EPS);
+        assertEquals(600, content.getHeight(), EPS);
+        Bounds viewport = pane.getViewportBounds();
+        assertEquals(200, viewport.getWidth(), EPS);
+        assertEquals(150, viewport.getHeight(), EPS);
+        assertEquals(0, content.localToScene(0, 0).getY(), EPS);
+
+        pane.setVvalue(1);
+        pane.layout();
+        assertEquals(-450, content.localToScene(0, 0).getY(), EPS);
+        assertEquals(-450, pane.getViewportBounds().getMinY(), EPS);
+        pane.setVvalue(0.5);
+        pane.setHvalue(1);
+        pane.layout();
+        assertEquals(-225, content.localToScene(0, 0).getY(), EPS);
+        assertEquals(-200, content.localToScene(0, 0).getX(), EPS);
+
+        // As in JavaFX the value is not clamped, the position is.
+        pane.setVvalue(7);
+        pane.layout();
+        assertEquals(-450, content.localToScene(0, 0).getY(), EPS);
+        pane.setVvalue(-3);
+        pane.layout();
+        assertEquals(0, content.localToScene(0, 0).getY(), EPS);
+        pane.setVvalue(0);
+
+        // The wheel moves the value.
+        pane.setHvalue(0);
+        pane.layout();
+        scene.cn1Wheel(50, 50, 0, -90);
+        assertEquals(0.2, pane.getVvalue(), 0.01);
+        scene.cn1Wheel(50, 50, 0, 9000);
+        assertEquals(0, pane.getVvalue(), 0);
+
+        // Content that fits takes the viewport when asked to.
+        Region small = box(50, 40);
+        pane.setContent(small);
+        pane.setFitToWidth(true);
+        pane.setFitToHeight(true);
+        pane.layout();
+        assertNull(content.getScene());
+        assertEquals(200, small.getWidth(), EPS);
+        assertEquals(150, small.getHeight(), EPS);
+
+        pane.setPrefViewportWidth(120);
+        pane.setPrefViewportHeight(80);
+        assertTrue(pane.prefWidth(-1) >= 120);
+        assertTrue(pane.prefHeight(-1) >= 80);
+        assertPrefSize(pane);
+    }
+
+    @Test
+    public void splitPaneDividers() {
+        Region a = box(100, 100);
+        Region b = box(100, 100);
+        Region c = box(100, 100);
+        SplitPane split = new SplitPane(a, b, c);
+        assertEquals(2, split.getDividers().size());
+        split.setDividerPositions(0.25, 0.75);
+        split.resize(400, 200);
+        split.layout();
+
+        double[] positions = split.getDividerPositions();
+        assertEquals(0.25, positions[0], 0.001);
+        assertEquals(0.75, positions[1], 0.001);
+        assertEquals(0, a.getBoundsInParent().getMinX(), EPS);
+        assertEquals(100, a.getBoundsInParent().getMaxX(), 4);
+        assertEquals(100, b.getBoundsInParent().getMinX(), 4);
+        assertEquals(300, b.getBoundsInParent().getMaxX(), 4);
+        assertEquals(300, c.getBoundsInParent().getMinX(), 4);
+        assertEquals(400, c.getBoundsInParent().getMaxX(), EPS);
+        assertEquals(200, a.getHeight(), EPS);
+        // Items do not overlap and leave room for the divider bars.
+        assertTrue(a.getBoundsInParent().getMaxX() <= b.getBoundsInParent().getMinX());
+        assertTrue(b.getBoundsInParent().getMaxX() <= c.getBoundsInParent().getMinX());
+
+        split.setDividerPosition(0, 0.5);
+        split.layout();
+        assertEquals(200, a.getBoundsInParent().getMaxX(), 4);
+        split.getDividers().get(1).setPosition(0.9);
+        split.layout();
+        assertEquals(360, c.getBoundsInParent().getMinX(), 4);
+
+        split.setOrientation(Orientation.VERTICAL);
+        split.setDividerPositions(0.5, 0.75);
+        split.resize(200, 400);
+        split.layout();
+        assertTrue(has(split, "vertical"));
+        assertEquals(200, a.getWidth(), EPS);
+        assertEquals(200, a.getBoundsInParent().getMaxY(), 4);
+        assertEquals(300, c.getBoundsInParent().getMinY(), 4);
+
+        split.getItems().remove(b);
+        assertEquals(1, split.getDividers().size());
+        assertNull(b.getParent());
+        assertPrefSize(split);
+    }
+
+    @Test
+    public void splitPaneDividerDrags() {
+        Region a = box(100, 100);
+        Region b = box(100, 100);
+        SplitPane split = new SplitPane(a, b);
+        Pane root = new Pane();
+        root.getChildren().add(split);
+        Scene scene = new Scene(root, 400, 200);
+        scene.cn1Layout(400, 200);
+        split.resizeRelocate(0, 0, 400, 200);
+        split.layout();
+        assertEquals(0.5, split.getDividerPositions()[0], 0.001);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 200, 100, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_DRAGGED, 300, 100, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 300, 100, MouseButton.PRIMARY);
+        assertEquals(0.75, split.getDividerPositions()[0], 0.02);
+        split.layout();
+        assertEquals(300, a.getBoundsInParent().getMaxX(), 6);
+    }
+
+    @Test
+    public void tabPaneSelectionSwitchesContent() {
+        Region first = box(80, 60);
+        Region second = box(120, 90);
+        Tab one = new Tab("One", first);
+        Tab two = new Tab("Two", second);
+        TabPane tabs = new TabPane(one, two);
+        assertSame(tabs, one.getTabPane());
+        assertSame(one, tabs.getSelectionModel().getSelectedItem());
+        assertEquals(0, tabs.getSelectionModel().getSelectedIndex());
+        assertTrue(one.isSelected());
+        assertFalse(two.isSelected());
+
+        Pane root = new Pane();
+        root.getChildren().add(tabs);
+        Scene scene = new Scene(root, 400, 300);
+        scene.cn1Layout(400, 300);
+        tabs.resizeRelocate(0, 0, 300, 200);
+        tabs.layout();
+
+        // Both contents are in the scene graph; only the selected one shows.
+        assertSame(scene, first.getScene());
+        assertSame(scene, second.getScene());
+        assertTrue(first.getParent().isVisible());
+        assertFalse(second.getParent().isVisible());
+        double strip = first.localToScene(0, 0).getY();
+        assertTrue("strip " + strip, strip > 4 && strip < 80);
+        assertEquals(300, first.getWidth(), EPS);
+        assertEquals(200 - strip, first.getHeight(), EPS);
+
+        final List<String> log = new ArrayList<String>();
+        two.setOnSelectionChanged(new EventHandler<Event>() {
+            @Override
+            public void handle(Event event) {
+                log.add("two " + two.isSelected());
+            }
+        });
+        tabs.getSelectionModel().select(1);
+        tabs.layout();
+        assertTrue(two.isSelected());
+        assertFalse(one.isSelected());
+        assertEquals("[two true]", log.toString());
+        assertFalse(first.getParent().isVisible());
+        assertTrue(second.getParent().isVisible());
+        assertEquals(300, second.getWidth(), EPS);
+        assertEquals(strip, second.localToScene(0, 0).getY(), EPS);
+
+        // Pressing a header selects its tab.
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 8, strip / 2, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 8, strip / 2, MouseButton.PRIMARY);
+        assertTrue(one.isSelected());
+        assertSame(one, tabs.getSelectionModel().getSelectedItem());
+
+        // A disabled tab is not selected by the user.
+        two.setDisable(true);
+        assertTrue(two.isDisabled());
+        tabs.getSelectionModel().selectNext();
+        assertTrue(two.isSelected());
+        tabs.getSelectionModel().selectFirst();
+        two.setDisable(false);
+
+        tabs.setSide(Side.BOTTOM);
+        tabs.layout();
+        assertTrue(has(tabs, "bottom"));
+        assertEquals(0, first.localToScene(0, 0).getY(), EPS);
+        assertEquals(200 - strip, first.getHeight(), EPS);
+        tabs.setSide(Side.LEFT);
+        tabs.layout();
+        assertTrue(first.localToScene(0, 0).getX() > 4);
+        assertEquals(200, first.getHeight(), EPS);
+
+        assertTrue(tabs.prefWidth(-1) >= 120);
+        assertTrue(tabs.prefHeight(-1) >= 90);
+        assertPrefSize(tabs);
+    }
+
+    @Test
+    public void tabPaneAddRemoveAndClose() {
+        TabPane tabs = new TabPane();
+        assertNull(tabs.getSelectionModel().getSelectedItem());
+        assertEquals(-1, tabs.getSelectionModel().getSelectedIndex());
+        final Tab one = new Tab("One", box(10, 10));
+        final Tab two = new Tab("Two", box(10, 10));
+        Tab three = new Tab("Three");
+        tabs.getTabs().addAll(one, two, three);
+        assertSame(one, tabs.getSelectionModel().getSelectedItem());
+        tabs.getSelectionModel().select(two);
+        assertEquals(1, tabs.getSelectionModel().getSelectedIndex());
+
+        // Removing an earlier tab keeps the selected tab selected.
+        tabs.getTabs().remove(one);
+        assertNull(one.getTabPane());
+        assertFalse(one.isSelected());
+        assertSame(two, tabs.getSelectionModel().getSelectedItem());
+        assertEquals(0, tabs.getSelectionModel().getSelectedIndex());
+
+        // Removing the selected tab selects a neighbour.
+        tabs.getTabs().remove(two);
+        assertSame(three, tabs.getSelectionModel().getSelectedItem());
+        assertTrue(three.isSelected());
+        assertFalse(two.isSelected());
+
+        tabs.getTabs().clear();
+        assertNull(tabs.getSelectionModel().getSelectedItem());
+        assertFalse(three.isSelected());
+        assertNotNull(tabs.getTabClosingPolicy());
+        tabs.setTabClosingPolicy(TabPane.TabClosingPolicy.ALL_TABS);
+        assertEquals(TabPane.TabClosingPolicy.ALL_TABS, tabs.getTabClosingPolicy());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsContainerTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsContainerTest.java
new file mode 100644
index 00000000000..885bfec94e7
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsContainerTest.java
@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.application.Platform;
+import javafx.collections.FXCollections;
+import javafx.geometry.Orientation;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Accordion;
+import javafx.scene.control.Button;
+import javafx.scene.control.ColorPicker;
+import javafx.scene.control.Label;
+import javafx.scene.control.Pagination;
+import javafx.scene.control.ScrollBar;
+import javafx.scene.control.Spinner;
+import javafx.scene.control.SpinnerValueFactory;
+import javafx.scene.control.TitledPane;
+import javafx.scene.control.ToolBar;
+import javafx.scene.control.TreeCell;
+import javafx.scene.control.TreeItem;
+import javafx.scene.control.TreeView;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+
+/// The controls made of other nodes: tool bars, scroll bars, titled
+/// panes and accordions, spinners, paginations, colour pickers and trees.
+public class ControlsContainerTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicitExit;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        implicitExit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+    }
+
+    @After
+    public void tearDown() {
+        List<javafx.stage.Window> open = new ArrayList<javafx.stage.Window>(javafx.stage.Window.getWindows());
+        for (int i = 0; i < open.size(); i++) {
+            open.get(i).hide();
+        }
+        Units.setScale(0);
+        Platform.setImplicitExit(implicitExit);
+    }
+
+    private static Scene sceneOf(Node control, double w, double h) {
+        Pane root = new Pane();
+        root.getChildren().add(control);
+        if (control instanceof Region) {
+            ((Region) control).setPrefSize(w, h);
+        }
+        Scene scene = new Scene(root, w, h);
+        scene.cn1Layout(w, h);
+        return scene;
+    }
+
+    private static void press(Scene scene, Node node, double x, double y) {
+        Point2D p = node.localToScene(x, y);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, p.getX(), p.getY(), MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, p.getX(), p.getY(), MouseButton.PRIMARY);
+    }
+
+    private static double sceneX(Node n) {
+        return n.localToScene(0, 0).getX();
+    }
+
+    private static double sceneY(Node n) {
+        return n.localToScene(0, 0).getY();
+    }
+
+    @Test
+    public void aToolBarPutsItsItemsInARowAndUprightInAColumn() {
+        Button a = new Button("One");
+        Button b = new Button("Two");
+        ToolBar bar = new ToolBar(a, b);
+        Scene scene = sceneOf(bar, 300, 200);
+        assertTrue("the second item is right of the first", sceneX(b) >= sceneX(a) + a.getWidth());
+        assertEquals("on one line", sceneY(a), sceneY(b), 0.5);
+        bar.setPrefSize(Region.USE_COMPUTED_SIZE, Region.USE_COMPUTED_SIZE);
+        assertTrue("a bar is as tall as its items, not as the room", bar.prefHeight(-1) < 80);
+
+        bar.setOrientation(Orientation.VERTICAL);
+        scene.cn1Layout(300, 200);
+        assertTrue("the second item is under the first", sceneY(b) >= sceneY(a) + a.getHeight());
+        assertSame(a, bar.getItems().get(0));
+    }
+
+    @Test
+    public void aScrollBarKeepsItsValueInRangeAndSizesItsThumbByWhatIsVisible() {
+        ScrollBar bar = new ScrollBar();
+        bar.setMin(0);
+        bar.setMax(200);
+        bar.setVisibleAmount(50);
+        bar.setUnitIncrement(30);
+        Scene scene = sceneOf(bar, 200, 16);
+        Node thumb = bar.lookup(".thumb");
+        assertNotNull(thumb);
+        assertEquals("a quarter is visible", 50, thumb.getLayoutBounds().getWidth(), 1);
+        assertEquals(0, thumb.getLayoutX(), 0.5);
+
+        bar.increment();
+        assertEquals(30, bar.getValue(), 0);
+        for (int i = 0; i < 10; i++) {
+            bar.increment();
+        }
+        assertEquals("the value stops at the maximum", 200, bar.getValue(), 0);
+        scene.cn1Layout(200, 16);
+        assertEquals("the thumb ends where the track ends", 150, thumb.getLayoutX(), 1);
+        bar.decrement();
+        assertEquals(170, bar.getValue(), 0);
+
+        bar.setValue(0);
+        bar.setBlockIncrement(40);
+        bar.adjustValue(1);
+        assertEquals("a press on the track moves one block", 40, bar.getValue(), 0);
+        bar.adjustValue(0.25);
+        assertEquals("and not past the place pressed", 50, bar.getValue(), 0);
+    }
+
+    @Test
+    public void aTitledPaneClosesToItsTitle() {
+        Label inside = new Label("content");
+        inside.setPrefSize(100, 120);
+        TitledPane pane = new TitledPane("Title", inside);
+        Scene scene = sceneOf(pane, 200, 200);
+        pane.setPrefSize(Region.USE_COMPUTED_SIZE, Region.USE_COMPUTED_SIZE);
+        double open = pane.prefHeight(-1);
+        assertTrue("open, the pane holds its content", open >= 120);
+        assertTrue(pane.isExpanded());
+
+        Node title = pane.lookup(".title");
+        assertNotNull(title);
+        press(scene, title, 30, 4);
+        assertFalse("a click on the title closes the pane", pane.isExpanded());
+        assertTrue("closed, the pane is as tall as its title", pane.prefHeight(-1) < open - 100);
+
+        pane.setCollapsible(false);
+        press(scene, title, 30, 4);
+        assertFalse("a pane that does not collapse stays as it is", pane.isExpanded());
+    }
+
+    @Test
+    public void anAccordionKeepsOnePaneOpen() {
+        TitledPane a = new TitledPane("A", new Label("a"));
+        TitledPane b = new TitledPane("B", new Label("b"));
+        Accordion accordion = new Accordion(a, b);
+        sceneOf(accordion, 200, 300);
+        assertFalse(a.isExpanded());
+        assertFalse(b.isExpanded());
+        assertNull(accordion.getExpandedPane());
+
+        accordion.setExpandedPane(a);
+        assertTrue(a.isExpanded());
+        b.setExpanded(true);
+        assertFalse("opening one pane closes the other", a.isExpanded());
+        assertSame(b, accordion.getExpandedPane());
+        b.setExpanded(false);
+        assertNull(accordion.getExpandedPane());
+    }
+
+    @Test
+    public void aSpinnerStepsThroughItsFactoryAndShowsTheValue() {
+        Spinner<Integer> spinner = new Spinner<Integer>(0, 10, 9, 2);
+        sceneOf(spinner, 120, 30);
+        assertEquals(Integer.valueOf(9), spinner.getValue());
+        assertEquals("9", spinner.getEditor().getText());
+        spinner.increment();
+        assertEquals("a step past the maximum stops there", Integer.valueOf(10), spinner.getValue());
+        assertEquals("10", spinner.getEditor().getText());
+        spinner.getValueFactory().setWrapAround(true);
+        spinner.increment();
+        assertEquals("and wraps when the factory says so", Integer.valueOf(1), spinner.getValue());
+        spinner.decrement(1);
+        assertEquals(Integer.valueOf(10), spinner.getValue());
+
+        Spinner<String> words = new Spinner<String>(FXCollections.observableArrayList("a", "b", "c"));
+        assertEquals("a", words.getValue());
+        words.increment(2);
+        assertEquals("c", words.getValue());
+        words.increment();
+        assertEquals("c", words.getValue());
+
+        SpinnerValueFactory.DoubleSpinnerValueFactory halves =
+                new SpinnerValueFactory.DoubleSpinnerValueFactory(0, 1, 0.5, 0.25);
+        Spinner<Double> decimal = new Spinner<Double>(halves);
+        decimal.decrement(3);
+        assertEquals(0, decimal.getValue().doubleValue(), 0);
+    }
+
+    /// The arrow style classes move the arrows, and a spinner given a
+    /// width keeps it: the editor takes what the arrows leave.
+    @Test
+    public void theArrowsOfASpinnerAreWhereItsStyleClassPutsThem() {
+        Spinner<Integer> spinner = new Spinner<Integer>(0, 10, 5);
+        spinner.setPrefWidth(80);
+        Scene scene = sceneOf(new javafx.scene.layout.HBox(spinner), 300, 60);
+        Node up = spinner.lookup(".increment-arrow-button");
+        Node down = spinner.lookup(".decrement-arrow-button");
+        Node editor = spinner.getEditor();
+        assertEquals("the width it was given", 80, spinner.getWidth(), 0.5);
+        assertTrue("arrows at the right", x(up, spinner) > x(editor, spinner));
+        assertTrue("one above the other", y(up, spinner) < y(down, spinner));
+        assertEquals(x(up, spinner), x(down, spinner), 0.5);
+
+        spinner.getStyleClass().add(Spinner.STYLE_CLASS_ARROWS_ON_LEFT_HORIZONTAL);
+        scene.cn1Layout(300, 60);
+        assertEquals(80, spinner.getWidth(), 0.5);
+        assertTrue("the step down is the left one", x(down, spinner) < x(up, spinner));
+        assertTrue("both left of the editor", x(up, spinner) < x(editor, spinner));
+        assertEquals(y(up, spinner), y(down, spinner), 0.5);
+
+        spinner.getStyleClass().setAll("spinner", Spinner.STYLE_CLASS_SPLIT_ARROWS_HORIZONTAL);
+        scene.cn1Layout(300, 60);
+        assertTrue(x(down, spinner) < x(editor, spinner));
+        assertTrue(x(editor, spinner) < x(up, spinner));
+
+        spinner.getStyleClass().setAll("spinner", Spinner.STYLE_CLASS_SPLIT_ARROWS_VERTICAL);
+        scene.cn1Layout(300, 60);
+        assertTrue(y(up, spinner) < y(editor, spinner));
+        assertTrue(y(editor, spinner) < y(down, spinner));
+    }
+
+    private static double x(Node node, Node in) {
+        return in.sceneToLocal(node.localToScene(0, 0)).getX();
+    }
+
+    private static double y(Node node, Node in) {
+        return in.sceneToLocal(node.localToScene(0, 0)).getY();
+    }
+
+    @Test
+    public void anEditableSpinnerReadsWhatWasTyped() {
+        Spinner<Integer> spinner = new Spinner<Integer>(0, 100, 5);
+        spinner.setEditable(true);
+        sceneOf(spinner, 120, 30);
+        spinner.getEditor().setText("42");
+        spinner.increment();
+        assertEquals("the typed value is read before the step", Integer.valueOf(43), spinner.getValue());
+        spinner.getEditor().setText("nothing");
+        spinner.increment();
+        assertEquals("a text that is no number changes nothing", Integer.valueOf(44), spinner.getValue());
+    }
+
+    @Test
+    public void aPaginationAsksItsFactoryForThePageItShows() {
+        final List<Integer> asked = new ArrayList<Integer>();
+        Pagination pages = new Pagination(5, 0);
+        pages.setPageFactory(index -> {
+            asked.add(index);
+            return index.intValue() == 3 ? null : new Label("page " + index);
+        });
+        sceneOf(pages, 300, 200);
+        assertEquals("[0]", asked.toString());
+        pages.setCurrentPageIndex(2);
+        assertEquals("[0, 2]", asked.toString());
+        pages.setCurrentPageIndex(99);
+        assertEquals("an index past the last page is the last page", 4, pages.getCurrentPageIndex());
+        pages.setCurrentPageIndex(3);
+        assertEquals("a page the factory has nothing for is not gone to", 4, pages.getCurrentPageIndex());
+        pages.setCurrentPageIndex(-4);
+        assertEquals(0, pages.getCurrentPageIndex());
+    }
+
+    @Test
+    public void aColorPickerShowsItsValueAndTellsWhenItChanges() {
+        ColorPicker picker = new ColorPicker(Color.RED);
+        final int[] actions = new int[1];
+        picker.setOnAction(e -> actions[0]++);
+        sceneOf(picker, 140, 30);
+        assertEquals(Color.RED, picker.getValue());
+        picker.setValue(Color.BLUE);
+        assertEquals(1, actions[0]);
+        assertTrue("the button is wide enough for a swatch and a name", picker.prefWidth(-1) > 40);
+    }
+
+    private static <T> TreeView<T> treeOf(TreeItem<T> root, final List<TreeCell<T>> cells) {
+        TreeView<T> tree = new TreeView<T>(root);
+        tree.setFixedCellSize(20);
+        tree.setCellFactory(view -> {
+            TreeCell<T> cell = new TreeCell<T>() {
+                @Override
+                protected void updateItem(T item, boolean empty) {
+                    super.updateItem(item, empty);
+                    setText(empty || item == null ? null : item.toString());
+                }
+            };
+            cells.add(cell);
+            return cell;
+        });
+        return tree;
+    }
+
+    private static <T> TreeCell<T> cellAt(List<TreeCell<T>> cells, int row) {
+        for (int i = 0; i < cells.size(); i++) {
+            if (cells.get(i).getIndex() == row && !cells.get(i).isEmpty()) {
+                return cells.get(i);
+            }
+        }
+        return null;
+    }
+
+    private static TreeItem<String> family() {
+        TreeItem<String> root = new TreeItem<String>("root");
+        TreeItem<String> a = new TreeItem<String>("a");
+        TreeItem<String> b = new TreeItem<String>("b");
+        a.getChildren().add(new TreeItem<String>("a1"));
+        a.getChildren().add(new TreeItem<String>("a2"));
+        root.getChildren().add(a);
+        root.getChildren().add(b);
+        return root;
+    }
+
+    @Test
+    public void theRowsOfATreeAreTheItemsUnderOpenItems() {
+        TreeItem<String> root = family();
+        TreeItem<String> a = root.getChildren().get(0);
+        List<TreeCell<String>> cells = new ArrayList<TreeCell<String>>();
+        TreeView<String> tree = treeOf(root, cells);
+        Scene scene = sceneOf(tree, 200, 200);
+        assertEquals("a closed root is the only row", 1, tree.getExpandedItemCount());
+        assertTrue(root.isLeaf() == false && a.getParent() == root);
+
+        root.setExpanded(true);
+        assertEquals(3, tree.getExpandedItemCount());
+        a.setExpanded(true);
+        assertEquals(5, tree.getExpandedItemCount());
+        assertSame(a.getChildren().get(1), tree.getTreeItem(3));
+        assertEquals(4, tree.getRow(root.getChildren().get(1)));
+        assertEquals(2, tree.getTreeItemLevel(a.getChildren().get(0)));
+
+        scene.cn1Layout(200, 200);
+        assertEquals("a1", cellAt(cells, 2).getText());
+        assertSame(a, cellAt(cells, 1).getTreeItem());
+
+        tree.setShowRoot(false);
+        assertEquals("without its root a tree starts at the children", 4, tree.getExpandedItemCount());
+        assertSame(a, tree.getTreeItem(0));
+
+        a.getChildren().remove(0);
+        assertEquals(3, tree.getExpandedItemCount());
+        a.getChildren().clear();
+        assertTrue(a.isLeaf());
+        assertEquals(2, tree.getExpandedItemCount());
+    }
+
+    @Test
+    public void aPressOnTheArrowOpensAnItemAndElsewhereSelectsIt() {
+        TreeItem<String> root = family();
+        root.setExpanded(true);
+        TreeItem<String> a = root.getChildren().get(0);
+        List<TreeCell<String>> cells = new ArrayList<TreeCell<String>>();
+        TreeView<String> tree = treeOf(root, cells);
+        Scene scene = sceneOf(tree, 200, 200);
+        TreeCell<String> cell = cellAt(cells, 1);
+        assertNotNull(cell);
+        // One level down: the arrow is in the second indent.
+        press(scene, cell, 18 + 9, 10);
+        assertTrue("the arrow opens the item", a.isExpanded());
+        assertTrue("and selects nothing", tree.getSelectionModel().isEmpty());
+
+        scene.cn1Layout(200, 200);
+        press(scene, cellAt(cells, 2), 100, 10);
+        assertSame(a.getChildren().get(0), tree.getSelectionModel().getSelectedItem());
+        assertEquals(2, tree.getSelectionModel().getSelectedIndex());
+        assertTrue(cellAt(cells, 2).isSelected());
+
+        tree.getSelectionModel().select(root.getChildren().get(1));
+        assertEquals(4, tree.getSelectionModel().getSelectedIndex());
+        a.setExpanded(false);
+        assertEquals("the selected item keeps its selection at its new row", 2,
+                tree.getSelectionModel().getSelectedIndex());
+        assertSame(root.getChildren().get(1), tree.getSelectionModel().getSelectedItem());
+    }
+
+    @Test
+    public void whatHappensToAnItemIsToldToTheItemsAboveIt() {
+        TreeItem<String> root = family();
+        TreeItem<String> a = root.getChildren().get(0);
+        final List<String> told = new ArrayList<String>();
+        root.addEventHandler(TreeItem.<String>branchExpandedEvent(), e -> told.add("open " + e.getTreeItem()
+                .getValue()));
+        root.addEventHandler(TreeItem.<String>treeNotificationEvent(), e -> told.add("any " + e.getTreeItem()
+                .getValue()));
+        a.setExpanded(true);
+        assertEquals("[open a, any a]", told.toString());
+        told.clear();
+        a.getChildren().get(0).setValue("other");
+        assertEquals("[any other]", told.toString());
+        told.clear();
+        a.getChildren().get(0).setExpanded(true);
+        assertEquals("a leaf has nothing to open", "[]", told.toString());
+        assertSame(a.getChildren().get(1), a.getChildren().get(0).nextSibling());
+        assertNull(a.getChildren().get(0).previousSibling());
+    }
+
+    @Test
+    public void aDialogPaneShowsItsExpandableContentWhenAsked() {
+        javafx.scene.control.DialogPane pane = new javafx.scene.control.DialogPane();
+        pane.setContentText("message");
+        Label details = new Label("details");
+        details.setPrefSize(100, 60);
+        double plain = pane.prefHeight(-1);
+        pane.setExpandableContent(details);
+        double withLink = pane.prefHeight(-1);
+        assertTrue("the link to the details takes a line", withLink > plain);
+        assertNull("closed, the details are not in the pane", details.getParent());
+        pane.setExpanded(true);
+        assertNotNull(details.getParent());
+        assertTrue(pane.prefHeight(-1) >= withLink + 60);
+        pane.setExpanded(false);
+        assertNull(details.getParent());
+    }
+
+    @Test
+    public void theDefaultTickFormatterWritesANumberBetweenItsPrefixAndSuffix() {
+        javafx.scene.chart.NumberAxis axis = new javafx.scene.chart.NumberAxis();
+        javafx.scene.chart.NumberAxis.DefaultFormatter money =
+                new javafx.scene.chart.NumberAxis.DefaultFormatter(axis, "$", "k");
+        assertEquals("$12k", money.toString(Integer.valueOf(12)));
+        assertEquals("$1.5k", money.toString(Double.valueOf(1.5)));
+        assertEquals(12.0, money.fromString("$12k").doubleValue(), 0);
+        assertNull(money.fromString("$k"));
+        assertEquals("7", new javafx.scene.chart.NumberAxis.DefaultFormatter(axis).toString(Double.valueOf(7)));
+    }
+
+    @Test
+    public void aFillAndAStrokeTransitionBlendTheColoursOfAShape() {
+        com.codename1.fxcompat.runtime.FrameClock.reset();
+        com.codename1.fxcompat.runtime.FrameClock.setManual(true);
+        try {
+            javafx.scene.shape.Rectangle r = new javafx.scene.shape.Rectangle(10, 10, Color.BLACK);
+            r.setStroke(Color.WHITE);
+            javafx.animation.FillTransition fill = new javafx.animation.FillTransition(
+                    javafx.util.Duration.millis(1000), r, null, Color.WHITE);
+            fill.setInterpolator(javafx.animation.Interpolator.LINEAR);
+            javafx.animation.StrokeTransition stroke = new javafx.animation.StrokeTransition(
+                    javafx.util.Duration.millis(1000), r, Color.RED, Color.BLUE);
+            stroke.setInterpolator(javafx.animation.Interpolator.LINEAR);
+            fill.play();
+            stroke.play();
+            com.codename1.fxcompat.runtime.FrameClock.advance(500);
+            Color half = (Color) r.getFill();
+            assertEquals("half way from the fill the shape had", 0.5, half.getRed(), 0.02);
+            Color line = (Color) r.getStroke();
+            assertEquals(0.5, line.getRed(), 0.02);
+            assertEquals(0.5, line.getBlue(), 0.02);
+            com.codename1.fxcompat.runtime.FrameClock.advance(600);
+            assertEquals(Color.WHITE, r.getFill());
+            assertEquals(Color.BLUE, r.getStroke());
+        } finally {
+            com.codename1.fxcompat.runtime.FrameClock.reset();
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsDataTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsDataTest.java
new file mode 100644
index 00000000000..85aba3e7713
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ControlsDataTest.java
@@ -0,0 +1,1019 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.spinner.Picker;
+
+import javafx.application.Platform;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.Point2D;
+import javafx.geometry.Side;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonBar.ButtonData;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.CheckMenuItem;
+import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.ChoiceDialog;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.DatePicker;
+import javafx.scene.control.Dialog;
+import javafx.scene.control.DialogEvent;
+import javafx.scene.control.Label;
+import javafx.scene.control.Labeled;
+import javafx.scene.control.ListCell;
+import javafx.scene.control.ListView;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.SelectionMode;
+import javafx.scene.control.SeparatorMenuItem;
+import javafx.scene.control.TableCell;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.TextInputDialog;
+import javafx.scene.control.Tooltip;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+import javafx.util.Callback;
+import javafx.util.StringConverter;
+
+/// The controls that show data and those that open something: lists and
+/// tables with their cells and selection, combo and choice boxes, menus,
+/// tooltips, dialogs and the date picker.
+public class ControlsDataTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicitExit;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        implicitExit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+    }
+
+    @After
+    public void tearDown() {
+        // A failed test must not leave its popups to the next one.
+        List<javafx.stage.Window> open = new ArrayList<javafx.stage.Window>(javafx.stage.Window.getWindows());
+        for (int i = 0; i < open.size(); i++) {
+            open.get(i).hide();
+        }
+        Units.setScale(0);
+        Platform.setImplicitExit(implicitExit);
+    }
+
+    /// Counts the action events it is handed.
+    private static final class Count implements EventHandler<ActionEvent> {
+        int n;
+
+        @Override
+        public void handle(ActionEvent event) {
+            n++;
+        }
+    }
+
+    private static ObservableList<String> names(int n) {
+        ObservableList<String> list = FXCollections.observableArrayList();
+        for (int i = 0; i < n; i++) {
+            list.add("item " + i);
+        }
+        return list;
+    }
+
+    /// Tells the listeners of a picker what it tells them when the user
+    /// chose a value in its popup.
+    private static void commit(Picker picker) {
+        List<com.codename1.ui.events.ActionListener<com.codename1.ui.events.ActionEvent>> all =
+                new ArrayList<com.codename1.ui.events.ActionListener<com.codename1.ui.events.ActionEvent>>(
+                        picker.getListeners());
+        for (int i = 0; i < all.size(); i++) {
+            all.get(i).actionPerformed(new com.codename1.ui.events.ActionEvent(picker, -99, -99));
+        }
+    }
+
+    private static Scene sceneOf(Node control, double w, double h) {
+        Pane root = new Pane();
+        root.getChildren().add(control);
+        if (control instanceof Region) {
+            // The pane gives its children their preferred size.
+            ((Region) control).setPrefSize(w, h);
+        }
+        Scene scene = new Scene(root, w, h);
+        scene.cn1Layout(w, h);
+        return scene;
+    }
+
+    private static void click(Scene scene, Node node) {
+        Point2D p = node.localToScene(4, 4);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, p.getX(), p.getY(), MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, p.getX(), p.getY(), MouseButton.PRIMARY);
+    }
+
+    private static <C extends javafx.scene.control.IndexedCell<?>> C cellAt(List<C> cells, int index) {
+        C found = null;
+        for (int i = 0; i < cells.size(); i++) {
+            C c = cells.get(i);
+            if (c.getIndex() == index && !c.isEmpty()) {
+                assertNull("two cells show row " + index, found);
+                found = c;
+            }
+        }
+        return found;
+    }
+
+    private static <T> ListView<T> listOf(ObservableList<T> items, final List<ListCell<T>> cells) {
+        ListView<T> list = new ListView<T>(items);
+        list.setFixedCellSize(20);
+        list.setCellFactory(new Callback<ListView<T>, ListCell<T>>() {
+            @Override
+            public ListCell<T> call(ListView<T> view) {
+                ListCell<T> cell = new ListCell<T>() {
+                    @Override
+                    protected void updateItem(T item, boolean empty) {
+                        super.updateItem(item, empty);
+                        setText(empty || item == null ? null : "<" + item + ">");
+                    }
+                };
+                cells.add(cell);
+                return cell;
+            }
+        });
+        return list;
+    }
+
+    @Test
+    public void listViewShowsItsItemsInRecycledCells() {
+        List<ListCell<String>> cells = new ArrayList<ListCell<String>>();
+        ObservableList<String> items = names(100);
+        ListView<String> list = listOf(items, cells);
+        Scene scene = sceneOf(list, 200, 100);
+
+        assertTrue("cells were made by the factory", cells.size() >= 5);
+        assertTrue("only the rows in view have cells: " + cells.size(), cells.size() <= 8);
+        int made = cells.size();
+        for (int row = 0; row < 4; row++) {
+            ListCell<String> cell = cellAt(cells, row);
+            assertNotNull("row " + row, cell);
+            assertEquals("<item " + row + ">", cell.getText());
+            assertEquals("item " + row, cell.getItem());
+            assertSame(list, cell.getListView());
+            assertEquals(20, cell.getHeight(), 0.01);
+        }
+        assertEquals(20, cellAt(cells, 1).localToScene(0, 0).getY() - cellAt(cells, 0).localToScene(0, 0).getY(),
+                0.01);
+        assertNull(cellAt(cells, 50));
+
+        list.scrollTo(50);
+        scene.cn1Layout(200, 100);
+        assertEquals("scrolling reuses the cells", made, cells.size());
+        assertNull(cellAt(cells, 0));
+        for (int row = 50; row < 54; row++) {
+            assertEquals("<item " + row + ">", cellAt(cells, row).getText());
+        }
+
+        items.remove(50);
+        scene.cn1Layout(200, 100);
+        assertEquals("<item 51>", cellAt(cells, 50).getText());
+        items.add(50, "new");
+        scene.cn1Layout(200, 100);
+        assertEquals("<new>", cellAt(cells, 50).getText());
+        assertEquals("<item 51>", cellAt(cells, 51).getText());
+        items.set(51, "changed");
+        scene.cn1Layout(200, 100);
+        assertEquals("<changed>", cellAt(cells, 51).getText());
+        assertEquals(made, cells.size());
+
+        items.setAll("a", "b");
+        scene.cn1Layout(200, 100);
+        assertEquals("<a>", cellAt(cells, 0).getText());
+        assertEquals("<b>", cellAt(cells, 1).getText());
+        assertNull(cellAt(cells, 2));
+    }
+
+    @Test
+    public void listViewScrollsWithTheWheel() {
+        List<ListCell<String>> cells = new ArrayList<ListCell<String>>();
+        ListView<String> list = listOf(names(100), cells);
+        Scene scene = sceneOf(list, 200, 100);
+        assertNotNull(cellAt(cells, 0));
+        scene.cn1Wheel(50, 50, 0, -60);
+        scene.cn1Layout(200, 100);
+        assertNull(cellAt(cells, 0));
+        assertEquals("<item 3>", cellAt(cells, 3).getText());
+        scene.cn1Wheel(50, 50, 0, 60);
+        scene.cn1Layout(200, 100);
+        assertEquals("<item 0>", cellAt(cells, 0).getText());
+        scene.cn1Wheel(50, 50, 0, 60);
+        scene.cn1Layout(200, 100);
+        assertEquals("the top of the list does not scroll further", "<item 0>", cellAt(cells, 0).getText());
+    }
+
+    @Test
+    public void listViewSelectsOnClick() {
+        List<ListCell<String>> cells = new ArrayList<ListCell<String>>();
+        ListView<String> list = listOf(names(100), cells);
+        Scene scene = sceneOf(list, 200, 100);
+        assertEquals(-1, list.getSelectionModel().getSelectedIndex());
+
+        click(scene, cellAt(cells, 2));
+        assertEquals(2, list.getSelectionModel().getSelectedIndex());
+        assertEquals("item 2", list.getSelectionModel().getSelectedItem());
+        assertTrue(cellAt(cells, 2).isSelected());
+        assertFalse(cellAt(cells, 1).isSelected());
+
+        click(scene, cellAt(cells, 1));
+        assertEquals("[1]", list.getSelectionModel().getSelectedIndices().toString());
+        assertTrue(cellAt(cells, 1).isSelected());
+        assertFalse(cellAt(cells, 2).isSelected());
+
+        list.getItems().add(0, "first");
+        scene.cn1Layout(200, 100);
+        assertEquals("the selection follows its item", 2, list.getSelectionModel().getSelectedIndex());
+        assertEquals("item 1", list.getSelectionModel().getSelectedItem());
+        assertTrue(cellAt(cells, 2).isSelected());
+    }
+
+    @Test
+    public void listViewSelectsSeveralRows() {
+        List<ListCell<String>> cells = new ArrayList<ListCell<String>>();
+        ListView<String> list = listOf(names(100), cells);
+        Scene scene = sceneOf(list, 200, 100);
+
+        list.getSelectionModel().selectIndices(1, 3);
+        assertEquals("single selection keeps one row", 1, list.getSelectionModel().getSelectedIndices().size());
+
+        list.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
+        list.getSelectionModel().clearSelection();
+        list.getSelectionModel().selectIndices(1, 3);
+        scene.cn1Layout(200, 100);
+        assertEquals("[1, 3]", list.getSelectionModel().getSelectedIndices().toString());
+        assertEquals("[item 1, item 3]", list.getSelectionModel().getSelectedItems().toString());
+        assertTrue(cellAt(cells, 1).isSelected());
+        assertFalse(cellAt(cells, 2).isSelected());
+        assertTrue(cellAt(cells, 3).isSelected());
+        assertTrue(list.getSelectionModel().isSelected(3));
+
+        // A row replaced in place stays selected and selects the new item.
+        list.getItems().set(3, "three");
+        assertEquals("[1, 3]", list.getSelectionModel().getSelectedIndices().toString());
+        assertEquals("[item 1, three]", list.getSelectionModel().getSelectedItems().toString());
+        list.getItems().set(3, "item 3");
+
+        list.getSelectionModel().selectRange(0, 3);
+        assertEquals("[0, 1, 2, 3]", list.getSelectionModel().getSelectedIndices().toString());
+        list.getSelectionModel().clearSelection(1);
+        assertEquals("[0, 2, 3]", list.getSelectionModel().getSelectedIndices().toString());
+
+        click(scene, cellAt(cells, 1));
+        assertEquals("a plain click selects that row alone", "[1]",
+                list.getSelectionModel().getSelectedIndices().toString());
+    }
+
+    @Test
+    public void listViewShowsAPlaceholderWhileEmpty() {
+        ListView<String> list = new ListView<String>();
+        Label empty = new Label("nothing");
+        list.setPlaceholder(empty);
+        Scene scene = sceneOf(list, 200, 100);
+        assertTrue(empty.isVisible());
+        assertSame(list, empty.getParent());
+        list.getItems().add("x");
+        scene.cn1Layout(200, 100);
+        assertFalse(empty.isVisible());
+    }
+
+    /// A row of the table tests.
+    private static final class Person {
+        final StringProperty name;
+        final int age;
+
+        Person(String name, int age) {
+            this.name = new SimpleStringProperty(name);
+            this.age = age;
+        }
+    }
+
+    private static <T> Callback<TableColumn<Person, T>, TableCell<Person, T>> cellsInto(
+            final List<TableCell<Person, T>> cells) {
+        return new Callback<TableColumn<Person, T>, TableCell<Person, T>>() {
+            @Override
+            public TableCell<Person, T> call(TableColumn<Person, T> column) {
+                TableCell<Person, T> cell = new TableCell<Person, T>() {
+                    @Override
+                    protected void updateItem(T item, boolean empty) {
+                        super.updateItem(item, empty);
+                        setText(empty || item == null ? null : String.valueOf(item));
+                    }
+                };
+                cells.add(cell);
+                return cell;
+            }
+        };
+    }
+
+    @Test
+    public void tableViewShowsValuesFromTheColumnCallbacks() {
+        ObservableList<Person> people = FXCollections.observableArrayList();
+        for (int i = 0; i < 40; i++) {
+            people.add(new Person("name " + i, 20 + i));
+        }
+        TableView<Person> table = new TableView<Person>(people);
+        table.setFixedCellSize(20);
+        TableColumn<Person, String> name = new TableColumn<Person, String>("Name");
+        name.setCellValueFactory(new Callback<TableColumn.CellDataFeatures<Person, String>, ObservableValue<String>>() {
+            @Override
+            public ObservableValue<String> call(TableColumn.CellDataFeatures<Person, String> features) {
+                assertSame(table, features.getTableView());
+                return features.getValue().name;
+            }
+        });
+        TableColumn<Person, Integer> age = new TableColumn<Person, Integer>("Age");
+        age.setCellValueFactory(
+                new Callback<TableColumn.CellDataFeatures<Person, Integer>, ObservableValue<Integer>>() {
+                    @Override
+                    public ObservableValue<Integer> call(TableColumn.CellDataFeatures<Person, Integer> features) {
+                        return new ReadOnlyObjectWrapper<Integer>(Integer.valueOf(features.getValue().age));
+                    }
+                });
+        List<TableCell<Person, String>> names = new ArrayList<TableCell<Person, String>>();
+        List<TableCell<Person, Integer>> ages = new ArrayList<TableCell<Person, Integer>>();
+        name.setCellFactory(cellsInto(names));
+        age.setCellFactory(cellsInto(ages));
+        name.setPrefWidth(100);
+        age.setPrefWidth(60);
+        table.getColumns().add(name);
+        table.getColumns().add(age);
+        Scene scene = sceneOf(table, 300, 160);
+
+        assertSame(table, name.getTableView());
+        assertEquals(100, name.getWidth(), 0.01);
+        assertEquals("name 3", name.getCellData(3));
+        assertEquals(Integer.valueOf(23), age.getCellData(3));
+        assertTrue(names.size() >= 5 && names.size() <= 10);
+        assertEquals(names.size(), ages.size());
+        for (int row = 0; row < 4; row++) {
+            assertEquals("name " + row, cellAt(names, row).getText());
+            assertEquals(String.valueOf(20 + row), cellAt(ages, row).getText());
+        }
+        TableCell<Person, String> first = cellAt(names, 0);
+        TableCell<Person, Integer> firstAge = cellAt(ages, 0);
+        assertSame(name, first.getTableColumn());
+        assertSame(table, first.getTableView());
+        assertEquals(100, first.getWidth(), 0.01);
+        assertEquals(60, firstAge.getWidth(), 0.01);
+        assertEquals(20, first.getHeight(), 0.01);
+        assertEquals(100, firstAge.localToScene(0, 0).getX() - first.localToScene(0, 0).getX(), 0.01);
+        assertEquals(first.localToScene(0, 0).getY(), firstAge.localToScene(0, 0).getY(), 0.01);
+        assertTrue("the rows start below the header", first.localToScene(0, 0).getY() > 5);
+
+        people.get(2).name.set("renamed");
+        assertEquals("a change of the observable value reaches the cell", "renamed", cellAt(names, 2).getText());
+
+        name.setPrefWidth(140);
+        scene.cn1Layout(300, 160);
+        assertEquals(140, cellAt(names, 0).getWidth(), 0.01);
+        assertEquals(140, cellAt(ages, 0).localToScene(0, 0).getX() - cellAt(names, 0).localToScene(0, 0).getX(),
+                0.01);
+
+        click(scene, cellAt(ages, 1));
+        assertEquals(1, table.getSelectionModel().getSelectedIndex());
+        assertSame(people.get(1), table.getSelectionModel().getSelectedItem());
+        assertTrue(cellAt(names, 1).isSelected());
+        assertTrue(cellAt(ages, 1).isSelected());
+        assertFalse(cellAt(names, 0).isSelected());
+
+        int made = names.size();
+        table.scrollTo(30);
+        scene.cn1Layout(300, 160);
+        assertEquals(made, names.size());
+        assertEquals("name 30", cellAt(names, 30).getText());
+        assertEquals("50", cellAt(ages, 30).getText());
+
+        people.remove(30);
+        scene.cn1Layout(300, 160);
+        assertEquals("name 31", cellAt(names, 30).getText());
+        people.get(30).name.set("late");
+        assertEquals("late", cellAt(names, 30).getText());
+        table.refresh();
+        scene.cn1Layout(300, 160);
+        assertEquals("late", cellAt(names, 30).getText());
+    }
+
+    @Test
+    public void comboBoxKeepsValueAndSelectionInStep() {
+        ComboBox<String> combo = new ComboBox<String>(FXCollections.observableArrayList("a", "b", "c"));
+        Count actions = new Count();
+        combo.setOnAction(actions);
+        assertNull(combo.getValue());
+        assertEquals(-1, combo.getSelectionModel().getSelectedIndex());
+
+        combo.setValue("b");
+        assertEquals(1, combo.getSelectionModel().getSelectedIndex());
+        assertEquals("b", combo.getSelectionModel().getSelectedItem());
+        assertEquals(1, actions.n);
+
+        combo.getSelectionModel().select(2);
+        assertEquals("c", combo.getValue());
+        assertEquals(2, actions.n);
+        combo.getSelectionModel().select(2);
+        assertEquals("the same value is no change", 2, actions.n);
+
+        combo.getSelectionModel().selectFirst();
+        assertEquals("a", combo.getValue());
+        combo.getItems().add(0, "z");
+        assertEquals("a", combo.getValue());
+        assertEquals("the row of the value moved", 1, combo.getSelectionModel().getSelectedIndex());
+
+        combo.setValue("other");
+        assertEquals("other", combo.getValue());
+        assertEquals(-1, combo.getSelectionModel().getSelectedIndex());
+
+        combo.setValue(null);
+        assertNull(combo.getSelectionModel().getSelectedItem());
+        assertEquals(-1, combo.getSelectionModel().getSelectedIndex());
+
+        combo.show();
+        assertTrue(combo.isShowing());
+        combo.hide();
+        assertFalse(combo.isShowing());
+        combo.setDisable(true);
+        combo.show();
+        assertFalse(combo.isShowing());
+    }
+
+    @Test
+    public void comboBoxShowsItsValueInThePicker() {
+        ComboBox<Integer> combo = new ComboBox<Integer>();
+        combo.getItems().addAll(Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3));
+        combo.setPromptText("pick");
+        combo.setConverter(new StringConverter<Integer>() {
+            @Override
+            public String toString(Integer object) {
+                return object == null ? "" : "#" + object;
+            }
+
+            @Override
+            public Integer fromString(String string) {
+                return null;
+            }
+        });
+        sceneOf(combo, 120, 30);
+        assertTrue(combo.cn1Native() instanceof Picker);
+        Picker picker = (Picker) combo.cn1Native();
+        assertEquals("pick", picker.getText());
+        assertEquals(3, picker.getStrings().length);
+        assertEquals("#2", picker.getStrings()[1]);
+
+        combo.setValue(Integer.valueOf(2));
+        assertEquals("#2", picker.getText());
+        assertEquals(1, picker.getSelectedStringIndex());
+
+        combo.getItems().add(Integer.valueOf(4));
+        assertEquals(4, picker.getStrings().length);
+        assertEquals(1, picker.getSelectedStringIndex());
+
+        // What the picker does when the user chose a row.
+        picker.setSelectedStringIndex(3);
+        commit(picker);
+        assertEquals(Integer.valueOf(4), combo.getValue());
+        assertEquals(3, combo.getSelectionModel().getSelectedIndex());
+    }
+
+    @Test
+    public void choiceBoxKeepsValueAndSelectionInStep() {
+        ChoiceBox<String> box = new ChoiceBox<String>();
+        box.getItems().addAll("a", "b", "c");
+        Count actions = new Count();
+        box.setOnAction(actions);
+
+        box.getSelectionModel().select(1);
+        assertEquals("b", box.getValue());
+        assertEquals(1, actions.n);
+        box.setValue("c");
+        assertEquals(2, box.getSelectionModel().getSelectedIndex());
+        assertEquals(2, actions.n);
+
+        sceneOf(box, 120, 30);
+        Picker picker = (Picker) box.cn1Native();
+        assertEquals("c", picker.getText());
+        picker.setSelectedStringIndex(0);
+        commit(picker);
+        assertEquals("a", box.getValue());
+        assertEquals(3, actions.n);
+
+        box.getItems().remove("a");
+        assertNull("a value that left the items is cleared", box.getValue());
+        assertEquals(-1, box.getSelectionModel().getSelectedIndex());
+
+        box.show();
+        assertTrue(box.isShowing());
+        box.hide();
+        assertFalse(box.isShowing());
+    }
+
+    private static Node rowOf(ContextMenu menu, String text) {
+        Parent root = menu.getScene().getRoot();
+        List<Node> rows = root.getChildrenUnmodifiable();
+        for (int i = 0; i < rows.size(); i++) {
+            Node n = rows.get(i);
+            if (n instanceof Labeled && ((Labeled) n).getText().startsWith(text)) {
+                return n;
+            }
+        }
+        return null;
+    }
+
+    private static void clickRow(ContextMenu menu, String text) {
+        Node row = rowOf(menu, text);
+        assertNotNull("row " + text, row);
+        click(menu.getScene(), row);
+    }
+
+    @Test
+    public void menuItemsFireAndReportToTheirMenus() {
+        MenuItem copy = new MenuItem("Copy");
+        MenuItem paste = new MenuItem("Paste");
+        Menu more = new Menu("More");
+        MenuItem deep = new MenuItem("Deep");
+        more.getItems().add(deep);
+        ContextMenu menu = new ContextMenu(copy, paste, more);
+        assertSame(menu, copy.getParentPopup());
+        assertSame(more, deep.getParentMenu());
+        assertSame(menu, deep.getParentPopup());
+
+        Count onCopy = new Count();
+        Count onMenu = new Count();
+        Count onMore = new Count();
+        copy.setOnAction(onCopy);
+        menu.setOnAction(onMenu);
+        more.setOnAction(onMore);
+        copy.fire();
+        assertEquals(1, onCopy.n);
+        assertEquals(1, onMenu.n);
+        deep.fire();
+        assertEquals("an action goes up through the menu it is in", 1, onMore.n);
+        assertEquals(2, onMenu.n);
+
+        menu.getItems().remove(copy);
+        assertNull(copy.getParentPopup());
+        copy.fire();
+        assertEquals(2, onCopy.n);
+        assertEquals(2, onMenu.n);
+    }
+
+    @Test
+    public void contextMenuShowsRowsThatFireTheirItems() {
+        Button owner = new Button("owner");
+        Scene scene = sceneOf(owner, 100, 30);
+        MenuItem copy = new MenuItem("Copy");
+        MenuItem off = new MenuItem("Off");
+        off.setDisable(true);
+        MenuItem hidden = new MenuItem("Hidden");
+        hidden.setVisible(false);
+        CheckMenuItem check = new CheckMenuItem("Check");
+        ContextMenu menu = new ContextMenu(copy, new SeparatorMenuItem(), off, hidden, check);
+        Count onCopy = new Count();
+        Count onOff = new Count();
+        Count onCheck = new Count();
+        copy.setOnAction(onCopy);
+        off.setOnAction(onOff);
+        check.setOnAction(onCheck);
+
+        assertFalse(menu.isShowing());
+        menu.show(owner, 10, 12);
+        assertTrue(menu.isShowing());
+        assertSame(owner, menu.getOwnerNode());
+        assertEquals(10, menu.getAnchorX(), 0.01);
+        assertEquals(12, menu.getAnchorY(), 0.01);
+        assertNotNull(rowOf(menu, "Copy"));
+        assertNull("an invisible item has no row", rowOf(menu, "Hidden"));
+        assertTrue(rowOf(menu, "Off").isDisabled());
+        assertTrue(rowOf(menu, "Copy").getBoundsInParent().getHeight() > 0);
+
+        clickRow(menu, "Off");
+        assertEquals("a disabled item cannot be chosen", 0, onOff.n);
+        assertTrue(menu.isShowing());
+
+        clickRow(menu, "Copy");
+        assertEquals(1, onCopy.n);
+        assertFalse("choosing an item hides the menu", menu.isShowing());
+        assertNull(menu.getOwnerNode());
+
+        menu.show(owner, Side.BOTTOM, 0, 0);
+        assertTrue(menu.isShowing());
+        assertTrue(owner.getHeight() > 0);
+        assertEquals("below the owner", owner.getHeight(), menu.getAnchorY(), 0.01);
+        clickRow(menu, "Check");
+        assertTrue(check.isSelected());
+        assertEquals(1, onCheck.n);
+        assertFalse(menu.isShowing());
+
+        menu.show(owner, 0, 0);
+        menu.hide();
+        assertFalse(menu.isShowing());
+        assertNotNull(scene);
+
+        new ContextMenu().show(owner, 0, 0);
+    }
+
+    @Test
+    public void subMenuOpensFromItsRow() {
+        Button owner = new Button("owner");
+        sceneOf(owner, 100, 30);
+        Menu more = new Menu("More");
+        MenuItem deep = new MenuItem("Deep");
+        more.getItems().add(deep);
+        ContextMenu menu = new ContextMenu(new MenuItem("Top"), more);
+        Count onDeep = new Count();
+        deep.setOnAction(onDeep);
+
+        menu.show(owner, 0, 0);
+        assertFalse(more.isShowing());
+        clickRow(menu, "More");
+        assertTrue(more.isShowing());
+        ContextMenu sub = null;
+        List<javafx.stage.Window> windows = javafx.stage.Window.getWindows();
+        for (int i = 0; i < windows.size(); i++) {
+            javafx.stage.Window w = windows.get(i);
+            if (w instanceof ContextMenu && w != menu) {
+                sub = (ContextMenu) w;
+            }
+        }
+        assertNotNull("the sub-menu is a popup of its own", sub);
+        assertTrue(sub.isShowing());
+        clickRow(sub, "Deep");
+        assertEquals(1, onDeep.n);
+        assertFalse(sub.isShowing());
+        assertFalse(more.isShowing());
+        assertFalse(menu.isShowing());
+    }
+
+    @Test
+    public void controlOpensItsContextMenuWhereOneIsAskedFor() {
+        Button owner = new Button("owner");
+        Scene scene = sceneOf(owner, 100, 30);
+        ContextMenu menu = new ContextMenu(new MenuItem("One"));
+        assertNull(owner.getContextMenu());
+        owner.setContextMenu(menu);
+        assertSame(menu, owner.getContextMenu());
+        assertSame(menu, owner.contextMenuProperty().get());
+
+        scene.cn1ContextMenu(20, 10);
+        assertTrue(menu.isShowing());
+        assertSame(owner, menu.getOwnerNode());
+        assertEquals(20, menu.getAnchorX(), 0.01);
+        assertEquals(10, menu.getAnchorY(), 0.01);
+        menu.hide();
+
+        owner.setContextMenu(null);
+        scene.cn1ContextMenu(20, 10);
+        assertFalse(menu.isShowing());
+    }
+
+    @Test
+    public void menuBarOpensAMenuFromItsText() {
+        Menu file = new Menu("File");
+        MenuItem open = new MenuItem("Open");
+        file.getItems().add(open);
+        Menu edit = new Menu("Edit");
+        edit.getItems().add(new MenuItem("Undo"));
+        MenuBar bar = new MenuBar(file, edit);
+        Scene scene = sceneOf(bar, 200, 30);
+        assertEquals(2, bar.getMenus().size());
+        List<Node> headers = bar.getChildrenUnmodifiable();
+        assertEquals(2, headers.size());
+        assertEquals("File", ((Labeled) headers.get(0)).getText());
+        assertTrue(headers.get(1).getBoundsInParent().getMinX() >= headers.get(0).getBoundsInParent().getMaxX() - 0.01);
+
+        Point2D p = headers.get(0).localToScene(4, 4);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, p.getX(), p.getY(), MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, p.getX(), p.getY(), MouseButton.PRIMARY);
+        assertTrue(file.isShowing());
+        assertFalse(edit.isShowing());
+
+        edit.show();
+        assertTrue(edit.isShowing());
+        file.hide();
+        assertFalse(file.isShowing());
+
+        ContextMenu popup = null;
+        List<javafx.stage.Window> windows = javafx.stage.Window.getWindows();
+        for (int i = 0; i < windows.size(); i++) {
+            if (windows.get(i) instanceof ContextMenu) {
+                assertNull("one popup is open: " + windows + " owners " + popup
+                        + (popup == null ? "" : " " + popup.getOwnerNode() + " " + popup.isShowing()), popup);
+                popup = (ContextMenu) windows.get(i);
+            }
+        }
+        assertNotNull(popup);
+        assertSame(headers.get(1), popup.getOwnerNode());
+        Count undo = new Count();
+        edit.getItems().get(0).setOnAction(undo);
+        clickRow(popup, "Undo");
+        assertEquals(1, undo.n);
+        assertFalse(edit.isShowing());
+        assertFalse(popup.isShowing());
+
+        file.setDisable(true);
+        file.show();
+        assertFalse(file.isShowing());
+    }
+
+    @Test
+    public void tooltipTextReachesTheNativeComponent() {
+        Button button = new Button("b");
+        sceneOf(button, 100, 30);
+        Tooltip tip = new Tooltip("hint");
+        button.setTooltip(tip);
+        assertSame(tip, button.getTooltip());
+        assertEquals("hint", button.cn1Native().getTooltip());
+        tip.setText("other");
+        assertEquals("other", button.cn1Native().getTooltip());
+        button.setTooltip(null);
+        assertNull(button.cn1Native().getTooltip());
+
+        Label label = new Label("l");
+        Tooltip.install(label, tip);
+        assertEquals("other", label.cn1Native().getTooltip());
+        Tooltip.uninstall(label, tip);
+        assertNull(label.cn1Native().getTooltip());
+        tip.setText("late");
+        assertNull(label.cn1Native().getTooltip());
+    }
+
+    @Test
+    public void buttonTypesSayWhatTheyAreFor() {
+        assertEquals("OK", ButtonType.OK.getText());
+        assertSame(ButtonData.OK_DONE, ButtonType.OK.getButtonData());
+        assertSame(ButtonData.CANCEL_CLOSE, ButtonType.CANCEL.getButtonData());
+        assertSame(ButtonData.CANCEL_CLOSE, ButtonType.CLOSE.getButtonData());
+        assertSame(ButtonData.OTHER, new ButtonType("Mine").getButtonData());
+        assertTrue(ButtonData.OK_DONE.isDefaultButton());
+        assertFalse(ButtonData.OK_DONE.isCancelButton());
+        assertTrue(ButtonData.CANCEL_CLOSE.isCancelButton());
+        assertTrue(ButtonData.NO.isCancelButton());
+        assertTrue(ButtonData.YES.isDefaultButton());
+        assertEquals("C", ButtonData.CANCEL_CLOSE.getTypeCode());
+    }
+
+    @Test
+    public void alertHasTheButtonsOfItsKind() {
+        Alert info = new Alert(AlertType.INFORMATION);
+        assertEquals("[" + ButtonType.OK + "]", info.getButtonTypes().toString());
+        assertEquals("Message", info.getTitle());
+        assertEquals("Message", info.getHeaderText());
+
+        Alert confirm = new Alert(AlertType.CONFIRMATION, "Sure?");
+        assertEquals(2, confirm.getButtonTypes().size());
+        assertSame(ButtonType.OK, confirm.getButtonTypes().get(0));
+        assertSame(ButtonType.CANCEL, confirm.getButtonTypes().get(1));
+        assertEquals("Sure?", confirm.getContentText());
+        assertEquals("Sure?", confirm.getDialogPane().getContentText());
+        assertEquals(0, new Alert(AlertType.NONE).getButtonTypes().size());
+
+        confirm.setAlertType(AlertType.ERROR);
+        assertEquals("the buttons follow the kind", 1, confirm.getButtonTypes().size());
+        assertEquals("Error", confirm.getTitle());
+
+        Alert own = new Alert(AlertType.WARNING, "Save?", ButtonType.YES, ButtonType.NO);
+        assertSame(ButtonType.YES, own.getButtonTypes().get(0));
+        assertSame(ButtonType.NO, own.getButtonTypes().get(1));
+        own.setAlertType(AlertType.CONFIRMATION);
+        assertEquals("buttons of the application stay", 2, own.getButtonTypes().size());
+        assertSame(ButtonType.YES, own.getButtonTypes().get(0));
+
+        Node yes = own.getDialogPane().lookupButton(ButtonType.YES);
+        assertTrue(yes instanceof Button);
+        assertEquals("Yes", ((Button) yes).getText());
+        assertTrue(((Button) yes).isDefaultButton());
+        assertTrue(((Button) own.getDialogPane().lookupButton(ButtonType.NO)).isCancelButton());
+        assertNull(own.getDialogPane().lookupButton(ButtonType.OK));
+    }
+
+    @Test
+    public void alertAnswersWithTheButtonChosen() {
+        Alert confirm = new Alert(AlertType.CONFIRMATION, "Sure?");
+        assertNull(confirm.getResult());
+        ((Button) confirm.getDialogPane().lookupButton(ButtonType.OK)).fire();
+        assertSame(ButtonType.OK, confirm.getResult());
+
+        Alert cancelled = new Alert(AlertType.CONFIRMATION, "Sure?");
+        cancelled.close();
+        assertSame("closing answers with the cancel button", ButtonType.CANCEL, cancelled.getResult());
+
+        Alert set = new Alert(AlertType.CONFIRMATION, "Sure?");
+        set.setResult(ButtonType.CANCEL);
+        assertSame(ButtonType.CANCEL, set.getResult());
+    }
+
+    @Test
+    public void dialogConvertsTheButtonIntoItsResult() {
+        Dialog<String> dialog = new Dialog<String>();
+        final ButtonType save = new ButtonType("Save", ButtonData.OK_DONE);
+        dialog.getDialogPane().getButtonTypes().addAll(save, ButtonType.CANCEL);
+        dialog.setHeaderText("Header");
+        dialog.setContentText("Content");
+        dialog.setTitle("Title");
+        assertEquals("Header", dialog.getDialogPane().getHeaderText());
+        assertEquals("Title", dialog.getTitle());
+        dialog.setResultConverter(new Callback<ButtonType, String>() {
+            @Override
+            public String call(ButtonType chosen) {
+                return chosen == save ? "saved" : null;
+            }
+        });
+        final List<String> log = new ArrayList<String>();
+        dialog.setOnShown(new EventHandler<DialogEvent>() {
+            @Override
+            public void handle(DialogEvent event) {
+                log.add("shown");
+            }
+        });
+        dialog.setOnHidden(new EventHandler<DialogEvent>() {
+            @Override
+            public void handle(DialogEvent event) {
+                log.add("hidden");
+            }
+        });
+        dialog.initModality(javafx.stage.Modality.NONE);
+        dialog.show();
+        assertTrue(dialog.isShowing());
+        assertTrue(dialog.getDialogPane().getWidth() > 0);
+        Node saveButton = dialog.getDialogPane().lookupButton(save);
+        Node cancelButton = dialog.getDialogPane().lookupButton(ButtonType.CANCEL);
+        assertTrue("the buttons are in a row", Math.abs(saveButton.getBoundsInParent().getMinY()
+                - cancelButton.getBoundsInParent().getMinY()) < 0.01);
+        assertTrue(saveButton.getBoundsInParent().getMaxX() <= cancelButton.getBoundsInParent().getMinX() + 0.01);
+
+        ((Button) saveButton).fire();
+        assertEquals("saved", dialog.getResult());
+        assertFalse(dialog.isShowing());
+        assertEquals("[shown, hidden]", log.toString());
+    }
+
+    @Test
+    public void dialogClosesWithoutAResultOnlyWhenItMay() {
+        Dialog<String> stuck = new Dialog<String>();
+        stuck.initModality(javafx.stage.Modality.NONE);
+        stuck.getDialogPane().getButtonTypes().addAll(ButtonType.YES, ButtonType.APPLY);
+        stuck.show();
+        stuck.close();
+        assertTrue("two buttons, none of them cancels", stuck.isShowing());
+        stuck.setResult("done");
+        assertFalse(stuck.isShowing());
+        assertEquals("done", stuck.getResult());
+
+        Dialog<ButtonType> single = new Dialog<ButtonType>();
+        single.initModality(javafx.stage.Modality.NONE);
+        single.getDialogPane().getButtonTypes().add(ButtonType.OK);
+        single.show();
+        single.close();
+        assertFalse("a single button lets it close", single.isShowing());
+        assertNull(single.getResult());
+    }
+
+    @Test
+    public void showAndWaitReturnsTheResultOnceTheDialogClosed() {
+        final Alert alert = new Alert(AlertType.CONFIRMATION, "Sure?");
+        final List<String> log = new ArrayList<String>();
+        Platform.runLater(new Runnable() {
+            @Override
+            public void run() {
+                log.add("showing=" + alert.isShowing());
+                ((Button) alert.getDialogPane().lookupButton(ButtonType.OK)).fire();
+            }
+        });
+        java.util.Optional<ButtonType> answer = alert.showAndWait();
+        assertEquals("[showing=true]", log.toString());
+        assertTrue(answer.isPresent());
+        assertSame(ButtonType.OK, answer.get());
+        assertFalse(alert.isShowing());
+
+        final Alert closed = new Alert(AlertType.NONE, "Nothing to choose");
+        closed.getButtonTypes().add(new ButtonType("Fine"));
+        Platform.runLater(new Runnable() {
+            @Override
+            public void run() {
+                closed.close();
+            }
+        });
+        assertFalse(closed.showAndWait().isPresent());
+    }
+
+    @Test
+    public void inputDialogsAnswerWithWhatWasEntered() {
+        TextInputDialog text = new TextInputDialog("abc");
+        assertEquals("abc", text.getDefaultValue());
+        assertEquals(2, text.getDialogPane().getButtonTypes().size());
+        text.setContentText("Name:");
+        ((Button) text.getDialogPane().lookupButton(ButtonType.OK)).fire();
+        assertEquals("abc", text.getResult());
+
+        TextInputDialog cancelled = new TextInputDialog("abc");
+        ((Button) cancelled.getDialogPane().lookupButton(ButtonType.CANCEL)).fire();
+        assertNull(cancelled.getResult());
+
+        ChoiceDialog<String> choice = new ChoiceDialog<String>("b", "a", "b", "c");
+        assertEquals("[a, b, c]", choice.getItems().toString());
+        assertEquals("b", choice.getDefaultChoice());
+        assertEquals("b", choice.getSelectedItem());
+        choice.setSelectedItem("c");
+        assertEquals("c", choice.selectedItemProperty().get());
+        ((Button) choice.getDialogPane().lookupButton(ButtonType.OK)).fire();
+        assertEquals("c", choice.getResult());
+
+        ChoiceDialog<String> first = new ChoiceDialog<String>("missing", "a", "b");
+        assertNull(first.getDefaultChoice());
+        assertEquals("a", first.getSelectedItem());
+        first.close();
+        assertNull(first.getResult());
+    }
+
+    @Test
+    public void datePickerHoldsALocalDate() {
+        DatePicker picker = new DatePicker();
+        Count actions = new Count();
+        picker.setOnAction(actions);
+        picker.setPromptText("when");
+        sceneOf(picker, 120, 30);
+        Picker peer = (Picker) picker.cn1Native();
+        assertEquals("when", peer.getText());
+        assertNull(peer.getDate());
+
+        picker.setValue(LocalDate.of(2024, 2, 29));
+        assertEquals(1, actions.n);
+        Calendar c = Calendar.getInstance();
+        c.setTime(peer.getDate());
+        assertEquals(2024, c.get(Calendar.YEAR));
+        assertEquals(Calendar.FEBRUARY, c.get(Calendar.MONTH));
+        assertEquals(29, c.get(Calendar.DAY_OF_MONTH));
+
+        // What the picker does when the user chose a day.
+        c.set(2025, Calendar.DECEMBER, 31);
+        peer.setDate(c.getTime());
+        commit(peer);
+        assertEquals(LocalDate.of(2025, 12, 31), picker.getValue());
+        assertEquals(2, actions.n);
+
+        assertEquals(LocalDate.of(2020, 1, 2), new DatePicker(LocalDate.of(2020, 1, 2)).getValue());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/DeviceMatrixTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/DeviceMatrixTest.java
new file mode 100644
index 00000000000..0f50ae11e11
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/DeviceMatrixTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import com.codename1.fxcompat.runtime.PeerPaint;
+
+import javafx.scene.shape.Rectangle;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/// A node's matrix as the matrix a peer installs: in pixels, about the
+/// place the peer is drawn at.
+public class DeviceMatrixTest {
+
+    private static double[] map(double[] d, double x, double y) {
+        return new double[] {d[0] * x + d[2] * y + d[4], d[1] * x + d[3] * y + d[5]};
+    }
+
+    @Test
+    public void aScaleAboutTheCentreKeepsTheCentreWhereverThePeerIsDrawn() {
+        Rectangle r = new Rectangle(10, 10);
+        r.setScaleX(2);
+        r.setScaleY(2);
+        double[] m = r.cn1PaintMatrix();
+        // Three pixels to the unit, the peer's corner drawn at (100, 200).
+        double[] d = PeerPaint.deviceMatrix(m, 0, 0, 3, 100, 200);
+        double[] centre = map(d, 115, 215);
+        assertEquals(115, centre[0], 1e-9);
+        assertEquals(215, centre[1], 1e-9);
+        double[] corner = map(d, 100, 200);
+        assertEquals(85, corner[0], 1e-9);
+        assertEquals(185, corner[1], 1e-9);
+        // The same node drawn elsewhere: the same picture, moved.
+        double[] moved = PeerPaint.deviceMatrix(m, 0, 0, 3, 400, 50);
+        double[] movedCorner = map(moved, 400, 50);
+        assertEquals(385, movedCorner[0], 1e-9);
+        assertEquals(35, movedCorner[1], 1e-9);
+    }
+
+    /// A shape whose layout bounds do not start at zero is drawn with its
+    /// bounds' corner at the peer's corner.
+    @Test
+    public void theOriginOfTheLayoutBoundsIsThePeersCorner() {
+        Rectangle r = new Rectangle(20, 30, 10, 10);
+        r.setScaleX(0.5);
+        double[] m = r.cn1PaintMatrix();
+        double[] d = PeerPaint.deviceMatrix(m, 20, 30, 1, 7, 9);
+        // The centre of the rectangle, five pixels in, does not move.
+        double[] centre = map(d, 12, 14);
+        assertEquals(12, centre[0], 1e-9);
+        assertEquals(14, centre[1], 1e-9);
+        double[] corner = map(d, 7, 9);
+        assertEquals(9.5, corner[0], 1e-9);
+        assertEquals(9, corner[1], 1e-9);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/EffectAndRegionShapeTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/EffectAndRegionShapeTest.java
new file mode 100644
index 00000000000..946d859f78b
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/EffectAndRegionShapeTest.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.application.ConditionalFeature;
+import javafx.application.Platform;
+import javafx.geometry.Bounds;
+import javafx.geometry.Insets;
+import javafx.scene.effect.BlurType;
+import javafx.scene.effect.BoxBlur;
+import javafx.scene.effect.DropShadow;
+import javafx.scene.effect.GaussianBlur;
+import javafx.scene.effect.Glow;
+import javafx.scene.effect.InnerShadow;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.shape.SVGPath;
+
+/// Effects are recorded and change nothing a node draws or measures; a
+/// region with a shape paints its fills in the form of that shape.
+public class EffectAndRegionShapeTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> drawn = new ArrayList<String>();
+    private final List<double[]> bounds = new ArrayList<double[]>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        Renderer.setTrace(null);
+    }
+
+    private void paint(javafx.scene.Node node) {
+        drawn.clear();
+        bounds.clear();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                drawn.add(operation);
+                bounds.add(deviceBounds);
+            }
+        });
+        node.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(400, 400, 0).getGraphics(), 0, 0));
+        Renderer.setTrace(null);
+    }
+
+    @Test
+    public void anEffectIsRecordedAndChangesNeitherBoundsNorPaint() {
+        assertFalse(Platform.isSupported(ConditionalFeature.EFFECT));
+        Rectangle r = new Rectangle(10, 20, 100, 50);
+        r.setFill(Color.RED);
+        assertNull(r.getEffect());
+        Bounds before = r.getBoundsInParent();
+        paint(r);
+        List<String> plain = new ArrayList<String>(drawn);
+        DropShadow shadow = new DropShadow(30, 5, 6, Color.BLUE);
+        r.setEffect(shadow);
+        assertSame(shadow, r.getEffect());
+        assertSame(shadow, r.effectProperty().get());
+        assertEquals(before, r.getBoundsInParent());
+        paint(r);
+        assertEquals(plain, drawn);
+        r.setEffect(null);
+        assertNull(r.getEffect());
+    }
+
+    @Test
+    public void shadowsKeepTheRangesAndDefaultsOfJavaFx() {
+        DropShadow d = new DropShadow();
+        assertEquals(10, d.getRadius(), 0);
+        assertEquals(21, d.getWidth(), 0);
+        assertEquals(21, d.getHeight(), 0);
+        assertEquals(Color.BLACK, d.getColor());
+        assertEquals(BlurType.THREE_PASS_BOX, d.getBlurType());
+        d.setRadius(500);
+        assertEquals(127, d.getRadius(), 0);
+        assertEquals(255, d.getWidth(), 0);
+        d.setWidth(11);
+        d.setHeight(11);
+        assertEquals(5, d.getRadius(), 0);
+        d.setSpread(3);
+        assertEquals(1, d.getSpread(), 0);
+        DropShadow full = new DropShadow(BlurType.GAUSSIAN, Color.RED, 4, 0.5, 1, 2);
+        assertEquals(BlurType.GAUSSIAN, full.getBlurType());
+        assertEquals(0.5, full.getSpread(), 0);
+        assertEquals(1, full.getOffsetX(), 0);
+        assertEquals(2, full.getOffsetY(), 0);
+        full.setInput(d);
+        assertSame(d, full.getInput());
+        InnerShadow in = new InnerShadow(BlurType.ONE_PASS_BOX, Color.GREEN, 8, 2, 3, 4);
+        assertEquals(8, in.getRadius(), 0);
+        assertEquals(17, in.getWidth(), 0);
+        assertEquals(1, in.getChoke(), 0);
+        assertEquals(3, in.getOffsetX(), 0);
+        assertEquals(4, in.getOffsetY(), 0);
+        assertEquals(Color.GREEN, new InnerShadow(2, Color.GREEN).getColor());
+        assertEquals(63, new GaussianBlur(100).getRadius(), 0);
+        assertEquals(10, new GaussianBlur().getRadius(), 0);
+        BoxBlur box = new BoxBlur(300, 7, 9);
+        assertEquals(255, box.getWidth(), 0);
+        assertEquals(7, box.getHeight(), 0);
+        assertEquals(3, box.getIterations());
+        assertEquals(0.3, new Glow().getLevel(), 0);
+        assertEquals(1, new Glow(4).getLevel(), 0);
+    }
+
+    private Pane filled(double w, double h) {
+        Pane p = new Pane();
+        p.setBackground(new Background(new BackgroundFill(Color.RED, new CornerRadii(8), new Insets(10))));
+        p.resize(w, h);
+        return p;
+    }
+
+    @Test
+    public void aRegionWithAShapePaintsItsFillStretchedOverTheFillArea() {
+        Pane p = filled(200, 100);
+        paint(p);
+        assertEquals(1, drawn.size());
+        SVGPath triangle = new SVGPath();
+        triangle.setContent("M0 0 L10 0 L5 20 Z");
+        p.setShape(triangle);
+        assertSame(triangle, p.getShape());
+        assertTrue(p.isScaleShape());
+        assertTrue(p.isCenterShape());
+        paint(p);
+        assertEquals(1, drawn.size());
+        double[] b = bounds.get(0);
+        assertEquals(10, b[0], 0.01);
+        assertEquals(10, b[1], 0.01);
+        assertEquals(190, b[2], 0.01);
+        assertEquals(90, b[3], 0.01);
+    }
+
+    @Test
+    public void aShapeThatIsNotScaledIsCentredAtItsOwnSize() {
+        Pane p = filled(200, 100);
+        p.setShape(new Circle(50, 50, 15));
+        p.setScaleShape(false);
+        paint(p);
+        double[] b = bounds.get(0);
+        assertEquals(85, b[0], 0.2);
+        assertEquals(35, b[1], 0.2);
+        assertEquals(115, b[2], 0.2);
+        assertEquals(65, b[3], 0.2);
+        p.setCenterShape(false);
+        paint(p);
+        b = bounds.get(0);
+        // Unplaced, the shape keeps its own coordinates, moved by the insets of the fill.
+        assertEquals(45, b[0], 0.2);
+        assertEquals(45, b[1], 0.2);
+        assertEquals(40, p.prefWidth(-1) + 40, 0);
+        p.setShape(null);
+        paint(p);
+        b = bounds.get(0);
+        assertEquals(10, b[0], 0.01);
+        assertEquals(190, b[2], 0.01);
+    }
+
+    @Test
+    public void aStyleSheetGivesAShapeAsAQuotedPath() {
+        Pane p = filled(100, 100);
+        Pane bare = filled(100, 100);
+        p.setStyle("-fx-shape: \"M0 0 L10 0 L5 20 Z\"; -fx-scale-shape: false; -fx-position-shape: false;");
+        // Without quotes it is not a path, and the declaration is dropped.
+        bare.setStyle("-fx-shape: bare;");
+        javafx.scene.Scene scene = new javafx.scene.Scene(new Pane(p, bare), 300, 300);
+        scene.cn1Layout(300, 300);
+        assertTrue(p.getShape() instanceof SVGPath);
+        assertEquals("M0 0 L10 0 L5 20 Z", ((SVGPath) p.getShape()).getContent());
+        assertFalse(p.isScaleShape());
+        assertFalse(p.isCenterShape());
+        assertNull(bare.getShape());
+        p.setStyle("");
+        scene.cn1Layout(300, 300);
+        assertNull(p.getShape());
+        assertTrue(p.isScaleShape());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/EventTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/EventTest.java
new file mode 100644
index 00000000000..2f2c0610064
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/EventTest.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import com.codename1.fxcompat.runtime.EventDispatchChainImpl;
+
+import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.event.EventDispatchChain;
+import javafx.event.EventDispatcher;
+import javafx.event.EventHandler;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.event.WeakEventHandler;
+
+public class EventTest {
+
+    private final List<String> log = new ArrayList<String>();
+
+    private EventDispatcher named(final String name, final boolean consume) {
+        return new EventDispatcher() {
+            @Override
+            public Event dispatchEvent(Event event, EventDispatchChain tail) {
+                log.add(name + ">");
+                if (consume) {
+                    event.consume();
+                    return null;
+                }
+                Event result = tail.dispatchEvent(event);
+                log.add("<" + name);
+                return result;
+            }
+        };
+    }
+
+    @Test
+    public void eventTypeHierarchy() {
+        assertNull(EventType.ROOT.getSuperType());
+        assertEquals("EVENT", EventType.ROOT.getName());
+        assertSame(EventType.ROOT, Event.ANY);
+        assertSame(Event.ANY, ActionEvent.ACTION.getSuperType());
+        assertEquals("ACTION", ActionEvent.ACTION.getName());
+        assertEquals("ACTION", ActionEvent.ACTION.toString());
+        assertSame(ActionEvent.ACTION, ActionEvent.ANY);
+        EventType<Event> custom = new EventType<Event>("CUSTOM");
+        assertSame(EventType.ROOT, custom.getSuperType());
+        EventType<Event> child = new EventType<Event>(custom, "CHILD");
+        assertSame(custom, child.getSuperType());
+        assertEquals("CHILD", child.getName());
+        EventType<Event> unnamed = new EventType<Event>(custom);
+        assertNull(unnamed.getName());
+        assertTrue(unnamed.toString().length() > 0);
+        try {
+            new EventType<Event>((EventType<Event>) null, "X");
+            fail("expected NullPointerException");
+        } catch (NullPointerException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void eventBasics() {
+        Event bare = new Event(Event.ANY);
+        assertSame(Event.NULL_SOURCE_TARGET, bare.getSource());
+        assertSame(Event.NULL_SOURCE_TARGET, bare.getTarget());
+        assertSame(Event.ANY, bare.getEventType());
+        assertFalse(bare.isConsumed());
+        bare.consume();
+        assertTrue(bare.isConsumed());
+        EventTarget target = tail -> tail;
+        Object source = new Object();
+        Event event = new Event(source, target, ActionEvent.ACTION);
+        assertSame(source, event.getSource());
+        assertSame(target, event.getTarget());
+        Event copy = event.copyFor("other", null);
+        assertNotSame(event, copy);
+        assertEquals("other", copy.getSource());
+        assertSame(Event.NULL_SOURCE_TARGET, copy.getTarget());
+        assertSame(ActionEvent.ACTION, copy.getEventType());
+        assertSame("the original is untouched", source, event.getSource());
+    }
+
+    @Test
+    public void actionEvent() {
+        ActionEvent bare = new ActionEvent();
+        assertSame(ActionEvent.ACTION, bare.getEventType());
+        assertSame(Event.NULL_SOURCE_TARGET, bare.getTarget());
+        EventTarget target = tail -> tail;
+        ActionEvent event = new ActionEvent("button", target);
+        assertEquals("button", event.getSource());
+        ActionEvent copy = event.copyFor("menu", target);
+        assertNotSame(event, copy);
+        assertEquals("menu", copy.getSource());
+        assertSame(target, copy.getTarget());
+        assertSame(ActionEvent.ACTION, copy.getEventType());
+    }
+
+    @Test
+    public void subclassWithoutCopyForIsReaddressed() {
+        class Custom extends Event {
+            private static final long serialVersionUID = 1L;
+            final String payload = "p";
+
+            Custom() {
+                super(Event.ANY);
+            }
+        }
+        Custom custom = new Custom();
+        Event copy = custom.copyFor("s", null);
+        assertTrue(copy instanceof Custom);
+        assertEquals("p", ((Custom) copy).payload);
+        assertEquals("s", copy.getSource());
+    }
+
+    @Test
+    public void dispatchChainRunsInOrderAndUnwinds() {
+        EventDispatchChain chain = new EventDispatchChainImpl();
+        chain = chain.append(named("b", false));
+        chain = chain.append(named("c", false));
+        chain = chain.prepend(named("a", false));
+        Event event = new Event(Event.ANY);
+        assertSame(event, chain.dispatchEvent(event));
+        assertEquals("[a>, b>, c>, <c, <b, <a]", log.toString());
+        log.clear();
+        chain.dispatchEvent(event);
+        assertEquals("a chain can be dispatched through again", 6, log.size());
+    }
+
+    @Test
+    public void consumingDispatcherStopsTheChain() {
+        EventDispatchChain chain = new EventDispatchChainImpl().append(named("a", false))
+                .append(named("stop", true)).append(named("never", false));
+        Event event = new Event(Event.ANY);
+        assertNull(chain.dispatchEvent(event));
+        assertTrue(event.isConsumed());
+        assertEquals("[a>, stop>, <a]", log.toString());
+        assertSame("an empty chain returns the event", event, new EventDispatchChainImpl().dispatchEvent(event));
+    }
+
+    @Test
+    public void fireEventGoesThroughTheTargetsChain() {
+        final List<Event> seen = new ArrayList<Event>();
+        final EventHandler<ActionEvent> handler = new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                seen.add(event);
+            }
+        };
+        EventTarget target = new EventTarget() {
+            @Override
+            public EventDispatchChain buildEventDispatchChain(EventDispatchChain tail) {
+                return tail.prepend(new EventDispatcher() {
+                    @Override
+                    public Event dispatchEvent(Event event, EventDispatchChain rest) {
+                        if (event instanceof ActionEvent) {
+                            handler.handle((ActionEvent) event);
+                        }
+                        return rest.dispatchEvent(event);
+                    }
+                });
+            }
+        };
+        ActionEvent original = new ActionEvent();
+        Event.fireEvent(target, original);
+        assertEquals(1, seen.size());
+        assertSame("the event is addressed to the target", target, seen.get(0).getTarget());
+        assertSame(target, seen.get(0).getSource());
+        assertSame(Event.NULL_SOURCE_TARGET, original.getTarget());
+        try {
+            Event.fireEvent(null, original);
+            fail("expected NullPointerException");
+        } catch (NullPointerException expected) {
+            assertTrue(true);
+        }
+        try {
+            Event.fireEvent(target, null);
+            fail("expected NullPointerException");
+        } catch (NullPointerException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void weakEventHandlerForwards() {
+        final int[] calls = new int[1];
+        EventHandler<ActionEvent> strong = event -> calls[0]++;
+        WeakEventHandler<ActionEvent> weak = new WeakEventHandler<ActionEvent>(strong);
+        weak.handle(new ActionEvent());
+        assertEquals(1, calls[0]);
+        assertFalse(weak.wasGarbageCollected());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FileChooserTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FileChooserTest.java
new file mode 100644
index 00000000000..c6626d3395e
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FileChooserTest.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Test;
+
+import com.codename1.fxcompat.runtime.FilePicker;
+
+import javafx.stage.FileChooser;
+import javafx.stage.FileChooser.ExtensionFilter;
+
+/// The file chooser: what it asks the platform's picker for, what it
+/// makes of the answer, and the file it names for saving where no
+/// dialog can.
+public class FileChooserTest {
+
+    private final List<String> asked = new ArrayList<String>();
+
+    @After
+    public void tearDown() {
+        FilePicker.setSource(null);
+    }
+
+    private void answer(final String path) {
+        FilePicker.setSource(new FilePicker.Source() {
+            @Override
+            public String choose(String accept) {
+                asked.add(String.valueOf(accept));
+                return path;
+            }
+        });
+    }
+
+    @Test
+    public void openingAsksForTheExtensionsOfTheFiltersAndAnswersTheFile() {
+        answer("/data/people.xml");
+        FileChooser chooser = new FileChooser();
+        assertNotNull(chooser.showOpenDialog(null));
+        chooser.getExtensionFilters().add(new ExtensionFilter("XML files (*.xml)", "*.xml"));
+        chooser.getExtensionFilters().add(new ExtensionFilter("Text", "*.txt", "*.TEXT"));
+        File file = chooser.showOpenDialog(null);
+        assertEquals("people.xml", file.getName());
+        List<File> files = chooser.showOpenMultipleDialog(null);
+        assertEquals(1, files.size());
+        assertEquals(file, files.get(0));
+        // A filter of any file lifts the limit.
+        chooser.getExtensionFilters().add(new ExtensionFilter("All", "*.*"));
+        chooser.showOpenDialog(null);
+        assertEquals("[null, xml,txt,TEXT, xml,txt,TEXT, null]", asked.toString());
+    }
+
+    @Test
+    public void aUserWhoCancelsIsNull() {
+        answer(null);
+        FileChooser chooser = new FileChooser();
+        assertNull(chooser.showOpenDialog(null));
+        assertNull(chooser.showOpenMultipleDialog(null));
+    }
+
+    @Test
+    public void savingNamesAFileWithoutAsking() {
+        answer("/never/asked");
+        FileChooser chooser = new FileChooser();
+        assertEquals("untitled", chooser.showSaveDialog(null).getName());
+        ExtensionFilter xml = new ExtensionFilter("XML", "*.xml");
+        ExtensionFilter csv = new ExtensionFilter("CSV", "*.csv");
+        chooser.getExtensionFilters().addAll(xml, csv);
+        assertEquals("untitled.xml", chooser.showSaveDialog(null).getName());
+        chooser.setSelectedExtensionFilter(csv);
+        assertSame(csv, chooser.selectedExtensionFilterProperty().get());
+        assertEquals("untitled.csv", chooser.showSaveDialog(null).getName());
+        chooser.setInitialFileName("people.xml");
+        chooser.setInitialDirectory(new File("/data/out"));
+        File file = chooser.showSaveDialog(null);
+        assertEquals("people.xml", file.getName());
+        assertEquals(new File("/data/out"), file.getParentFile());
+        assertEquals("[]", asked.toString());
+    }
+
+    @Test
+    public void propertiesAndTheRulesOfAFilter() {
+        FileChooser chooser = new FileChooser();
+        assertNull(chooser.getTitle());
+        chooser.setTitle("Open");
+        assertEquals("Open", chooser.titleProperty().get());
+        assertNull(chooser.getInitialDirectory());
+        assertNull(chooser.getInitialFileName());
+        chooser.initialFileNameProperty().set("a.txt");
+        assertEquals("a.txt", chooser.getInitialFileName());
+        ExtensionFilter filter = new ExtensionFilter("Images", "*.png", "*.jpg");
+        assertEquals("Images", filter.getDescription());
+        assertEquals("[*.png, *.jpg]", filter.getExtensions().toString());
+        try {
+            filter.getExtensions().add("*.gif");
+            fail("the extensions of a filter are fixed");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals(2, filter.getExtensions().size());
+        }
+        try {
+            new ExtensionFilter("", "*.png");
+            fail("an empty description");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            new ExtensionFilter("None");
+            fail("no extension");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            new ExtensionFilter(null, "*.png");
+            fail("no description");
+        } catch (NullPointerException expected) {
+            assertNotNull(expected.getMessage());
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FileUrlImageTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FileUrlImageTest.java
new file mode 100644
index 00000000000..0a5a069bdf1
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FileUrlImageTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
+import com.codename1.impl.compat.Resources;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.ResourceUrls;
+import com.codename1.io.FileSystemStorage;
+import java.io.IOException;
+import java.io.InputStream;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+/// An image named by a `file:` URL never throws out of its constructor.
+///
+/// A port's file system throws `IllegalArgumentException` for any path
+/// that is not an absolute `file:/` one, and the headless implementation
+/// does the same, so a relative URL handed over as written kills the
+/// application in `start`. JavaFX answers an image in error instead.
+public class FileUrlImageTest {
+
+    @Rule
+    public MainThreadRule edt = new MainThreadRule();
+
+    private static byte[] dot() throws IOException {
+        InputStream in = FileUrlImageTest.class.getResourceAsStream("/dot.png");
+        assertNotNull(in);
+        try {
+            return ResourceUrls.readAll(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    @Before
+    public void start() {
+        HeadlessImplementation.install();
+        HeadlessImplementation.pixelImages = true;
+        HeadlessImplementation.fileSystem = true;
+        HeadlessImplementation.FILES.clear();
+    }
+
+    @After
+    public void forget() {
+        HeadlessImplementation.pixelImages = false;
+        HeadlessImplementation.fileSystem = false;
+        HeadlessImplementation.FILES.clear();
+        Resources.cn1SetProvider(null);
+        Resources.cn1ClearIndex();
+    }
+
+    @Test
+    public void theFileSystemRefusesARelativePathAsAPortDoes() throws IOException {
+        try {
+            FileSystemStorage.getInstance().openInputStream("file:resources/images/address_book_32.png");
+            fail("a port throws for a path that is not absolute");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            FileSystemStorage.getInstance().exists("records.txt");
+            fail("a port throws for a path that is not absolute");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+    }
+
+    @Test
+    public void aRelativeFileUrlThatNamesNothingIsAnImageInError() {
+        Image image = new Image("file:resources/images/address_book_32.png");
+        assertEquals(true, image.isError());
+        assertNotNull(image.getException());
+        assertEquals(0, image.getWidth(), 0);
+        assertEquals(0, image.getHeight(), 0);
+        assertNull(image.getPixelReader());
+        // And through the view that takes a URL.
+        assertEquals(true, new ImageView("file:resources/images/address_book_32.png").getImage().isError());
+    }
+
+    @Test
+    public void anAbsoluteFileUrlThatNamesNothingIsAnImageInError() {
+        assertEquals(true, new Image("file:/nowhere/at/all.png").isError());
+        assertEquals(true, new Image("file:///nowhere/at/all.png").isError());
+        assertEquals(true, new Image("file:").isError());
+    }
+
+    @Test
+    public void aRelativeFileUrlIsReadFromTheApplicationHome() throws IOException {
+        String home = FileSystemStorage.getInstance().getAppHomePath();
+        HeadlessImplementation.FILES.put(home + "pictures/dot.png", dot());
+        Image image = new Image("file:pictures/dot.png");
+        assertEquals(false, image.isError());
+        assertEquals(2, image.getWidth(), 0);
+    }
+
+    @Test
+    public void anAbsoluteFileUrlIsReadFromTheFileSystem() throws IOException {
+        HeadlessImplementation.FILES.put("file:///data/dot.png", dot());
+        assertEquals(false, new Image("file:/data/dot.png").isError());
+        assertEquals(false, new Image("file:///data/dot.png").isError());
+    }
+
+    @Test
+    public void aRelativeFileUrlFindsABundledResource() {
+        Resources.cn1BeginIndex();
+        Resources.cn1AddResource("resources/images/dot.png");
+        Resources.cn1SetProvider(new Resources.Provider() {
+            @Override
+            public InputStream open(String flatName) {
+                if ("resources__images__dot.png".equals(flatName)) {
+                    return FileUrlImageTest.class.getResourceAsStream("/dot.png");
+                }
+                return null;
+            }
+        });
+        Image image = new Image("file:resources/images/dot.png");
+        assertEquals(false, image.isError());
+        assertEquals(2, image.getWidth(), 0);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FontLoadingTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FontLoadingTest.java
new file mode 100644
index 00000000000..162c2371582
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FontLoadingTest.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
+import com.codename1.impl.compat.Resources;
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.FontFiles;
+import com.codename1.fxcompat.runtime.ResourceUrls;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import javafx.scene.image.Image;
+import javafx.scene.text.Font;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+/// A font file the application carries is loaded: `Font.loadFont` answers
+/// a font named as the file names itself, and the family then finds the
+/// file. The font is the Material Icons file the framework ships.
+public class FontLoadingTest {
+
+    private static final String PATH = "com/example/fonts/Icons.ttf";
+    private static final String FLAT = "com__example__fonts__Icons.ttf";
+
+    @Rule
+    public MainThreadRule edt = new MainThreadRule();
+
+    private final List<String> opened = new ArrayList<String>();
+
+    private static byte[] fontBytes() throws IOException {
+        InputStream in = FontLoadingTest.class.getResourceAsStream("/material-design-font.ttf");
+        assertNotNull("the framework's icon font is on the class path", in);
+        try {
+            return ResourceUrls.readAll(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    @Before
+    public void shipTheFont() throws IOException {
+        HeadlessImplementation.install();
+        HeadlessImplementation.pixelImages = true;
+        final byte[] font = fontBytes();
+        FontFiles.reset();
+        Resources.cn1BeginIndex();
+        Resources.cn1AddResource(PATH);
+        Resources.cn1AddResource("com/example/img/dot.png");
+        Resources.cn1SetProvider(new Resources.Provider() {
+            @Override
+            public InputStream open(String flatName) {
+                opened.add(flatName);
+                if (FLAT.equals(flatName)) {
+                    return new ByteArrayInputStream(font);
+                }
+                if ("com__example__img__dot.png".equals(flatName)) {
+                    return FontLoadingTest.class.getResourceAsStream("/dot.png");
+                }
+                return null;
+            }
+        });
+    }
+
+    @After
+    public void forget() {
+        HeadlessImplementation.pixelImages = false;
+        Resources.cn1SetProvider(null);
+        Resources.cn1ClearIndex();
+        FontFiles.reset();
+    }
+
+    @Test
+    public void aFontFileAnswersAFontNamedAsTheFileNamesItself() {
+        Font font = Font.loadFont("cn1res:/" + PATH, 18);
+        assertNotNull(font);
+        assertEquals("Material Icons", font.getFamily());
+        assertEquals("Material Icons", font.getName());
+        assertEquals("Regular", font.getStyle());
+        assertEquals(18, font.getSize(), 0);
+        assertNotNull(font.cn1Native());
+        FontFiles.Face face = FontFiles.find("material icons", 400, false);
+        assertNotNull("the family finds the file", face);
+        // The platform is handed the flat name the build shipped, and the
+        // name the font is installed under.
+        assertEquals(FLAT, face.file());
+        assertEquals("MaterialIcons-Regular", face.postScriptName());
+        assertSame(face, FontFiles.find("MaterialIcons-Regular", 700, true));
+        assertNull(FontFiles.find("Clear Sans", 400, false));
+    }
+
+    @Test
+    public void aDesktopUrlFindsTheSameResource() {
+        assertNotNull(Font.loadFont("jar:file:/opt/app/app.jar!/" + PATH, 10));
+        FontFiles.reset();
+        assertNotNull(Font.loadFont("file:/home/me/build/classes/" + PATH, 10));
+    }
+
+    @Test
+    public void whatIsNoFontIsNull() {
+        assertNull(Font.loadFont("cn1res:/com/example/fonts/Missing.ttf", 10));
+        assertNull(Font.loadFont(new ByteArrayInputStream(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}), 10));
+        assertNull(Font.loadFont((String) null, 10));
+    }
+
+    @Test
+    public void aStreamIsMatchedToTheResourceItCameFrom() throws IOException {
+        Font font = Font.loadFont(new ByteArrayInputStream(fontBytes()), 12);
+        assertNotNull(font);
+        assertEquals("Material Icons", font.getFamily());
+        FontFiles.Face face = FontFiles.find("Material Icons", 400, false);
+        assertNotNull(face);
+        assertEquals(FLAT, face.file());
+    }
+
+    @Test
+    public void bytesThatAreNoTableDirectoryAreRefused() {
+        assertNull(FontFiles.parse(new byte[0]));
+        assertNull(FontFiles.parse(new byte[64]));
+        byte[] truncated = new byte[20];
+        truncated[1] = 1;
+        truncated[5] = 9;
+        assertNull(FontFiles.parse(truncated));
+    }
+
+    /// An image named by the URL of a nested resource is read under the
+    /// flat name, never asked of the platform as a path with directories.
+    @Test
+    public void anImageUrlIsReadThroughTheResourceIndex() {
+        opened.clear();
+        Image image = new Image("cn1res:/com/example/img/dot.png");
+        assertEquals(opened.toString(), true, opened.contains("com__example__img__dot.png"));
+        assertEquals(false, image.isError());
+        assertEquals(2, image.getWidth(), 0);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FxInteropTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FxInteropTest.java
new file mode 100644
index 00000000000..beec0dfad9f
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/FxInteropTest.java
@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.SceneEmbed;
+import com.codename1.fxcompat.runtime.StageDialog;
+import com.codename1.fxcompat.runtime.StageForm;
+import com.codename1.fxcompat.runtime.StageHosts;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import com.codename1.ui.layouts.BorderLayout;
+
+import javafx.application.Platform;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.Label;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+
+/// JavaFX inside a Codename One application that has a main class of its
+/// own (library mode): a scene graph embedded in a form of the
+/// application, stages shown over its forms and closed back to them, and
+/// a menu bar reachable inside either. No lifecycle of the layer runs in
+/// any of these, so nothing installs an exit hook: the application must
+/// survive every one of them.
+public class FxInteropTest {
+
+    static {
+        // The rule runs a test on the event thread only once Codename One
+        // is up, and a form shown from another thread is not current when
+        // show() returns.
+        HeadlessImplementation.install();
+    }
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicitExit;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        implicitExit = Platform.isImplicitExit();
+        StageHosts.setExitHook(null);
+    }
+
+    @After
+    public void tearDown() {
+        List<javafx.stage.Window> open = new ArrayList<javafx.stage.Window>(javafx.stage.Window.getWindows());
+        for (int i = 0; i < open.size(); i++) {
+            open.get(i).hide();
+        }
+        Units.setScale(0);
+        Platform.setImplicitExit(implicitExit);
+        FxInterop.setNativeWindows(true);
+    }
+
+    private static final class Count implements EventHandler<ActionEvent> {
+        int n;
+
+        @Override
+        public void handle(ActionEvent event) {
+            n++;
+        }
+    }
+
+    private static Form home(String title) {
+        Form f = new Form(title, new BorderLayout());
+        f.show();
+        return f;
+    }
+
+    private static List<Object[]> paint(Form f) {
+        HeadlessImplementation.drawnText.clear();
+        HeadlessImplementation.recordText = true;
+        try {
+            Image target = Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+            f.paintComponent(target.getGraphics());
+            return new ArrayList<Object[]>(HeadlessImplementation.drawnText);
+        } finally {
+            HeadlessImplementation.recordText = false;
+            HeadlessImplementation.drawnText.clear();
+        }
+    }
+
+    private static boolean drew(List<Object[]> text, String wanted) {
+        for (int i = 0; i < text.size(); i++) {
+            Object[] entry = text.get(i);
+            for (int j = 0; j < entry.length; j++) {
+                if (wanted.equals(entry[j])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /// Presses and releases on the form, at a point of `node`: what a touch
+    /// on the screen does.
+    private static void click(Form f, Component hosted, Node node) {
+        Point2D p = node.localToScene(4, 4);
+        int x = hosted.getAbsoluteX() + Units.toPixels(p.getX());
+        int y = hosted.getAbsoluteY() + Units.toPixels(p.getY());
+        f.pointerPressed(x, y);
+        f.pointerReleased(x, y);
+    }
+
+    @Test
+    public void aSceneGraphIsAComponentOfACodenameOneForm() {
+        Label label = new Label("Embedded label");
+        Button button = new Button("Press");
+        Count clicks = new Count();
+        button.setOnAction(clicks);
+        VBox box = new VBox(8, label, button);
+        box.setPrefSize(120, 90);
+
+        Component hosted = FxInterop.asComponent(box);
+        assertTrue(hosted instanceof SceneEmbed);
+        assertEquals("the preferred size is the root's, in device pixels", 240, hosted.getPreferredW());
+        assertEquals(180, hosted.getPreferredH());
+        assertNotNull(box.getScene());
+        assertNotNull("a scene has a window to answer for it", box.getScene().getWindow());
+        assertTrue(box.getScene().getWindow().cn1Embedded());
+        assertTrue(box.getScene().getWindow().isShowing());
+        assertEquals("which is not one of the application's windows", 0, javafx.stage.Window.getWindows().size());
+
+        Form form = home("Host");
+        form.add(BorderLayout.CENTER, hosted);
+        form.revalidate();
+        assertSame(form, Display.getInstance().getCurrent());
+        assertTrue(hosted.getWidth() > 0 && hosted.getHeight() > 0);
+        assertEquals("laid out to the size Codename One gave the component", Units.toLogical(hosted.getWidth()),
+                box.getWidth(), 0.51);
+        assertEquals(Units.toLogical(hosted.getHeight()), box.getHeight(), 0.51);
+        assertTrue(button.getWidth() > 0 && button.getHeight() > 0);
+
+        List<Object[]> text = paint(form);
+        assertTrue("the graph paints with the form", drew(text, "Embedded label"));
+        assertTrue(drew(text, "Press"));
+
+        click(form, hosted, button);
+        assertEquals("pointer input on the form reaches the graph", 1, clicks.n);
+
+        // It cannot be closed from inside, and closing it ends nothing.
+        box.getScene().getWindow().hide();
+        assertTrue(box.getScene().getWindow().isShowing());
+        click(form, hosted, button);
+        assertEquals(2, clicks.n);
+
+        // Off the screen it takes no more input, and takes it again later.
+        Form other = home("Other");
+        other.pointerPressed(hosted.getAbsoluteX() + 10, hosted.getAbsoluteY() + 10);
+        other.pointerReleased(hosted.getAbsoluteX() + 10, hosted.getAbsoluteY() + 10);
+        assertEquals(2, clicks.n);
+        form.show();
+        click(form, hosted, button);
+        assertEquals(3, clicks.n);
+    }
+
+    @Test
+    public void aSceneKeepsItsOwnSettingsWhenEmbedded() {
+        VBox box = new VBox(new Label("Styled"));
+        Scene scene = new Scene(box, 100, 60);
+        scene.getStylesheets().add("app.css");
+        Component hosted = FxInterop.asComponent(scene);
+        assertSame(scene, box.getScene());
+        assertEquals(1, scene.getStylesheets().size());
+        assertSame("a root that has a scene is shown with it", scene,
+                ((SceneEmbed) FxInterop.asComponent(box)).window().getScene());
+        assertNotNull(hosted);
+        try {
+            FxInterop.asComponent(null);
+            fail("nothing");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            FxInterop.asComponent("a string");
+            fail("neither a scene nor a root");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+    }
+
+    @Test
+    public void aMenuBarIsReachableInAnEmbeddedScene() {
+        Menu file = new Menu("File");
+        MenuItem open = new MenuItem("Open");
+        Count opened = new Count();
+        open.setOnAction(opened);
+        file.getItems().add(open);
+        MenuBar bar = new MenuBar(file);
+        VBox box = new VBox(bar, new Label("Body"));
+        Component hosted = FxInterop.asComponent(box);
+        Form form = home("Menus");
+        form.add(BorderLayout.CENTER, hosted);
+        form.revalidate();
+
+        assertTrue("the bar is drawn in the scene, on every form factor", drew(paint(form), "File"));
+        List<Node> headers = bar.getChildrenUnmodifiable();
+        assertEquals(1, headers.size());
+        click(form, hosted, headers.get(0));
+        assertTrue("a touch on its text opens the menu", file.isShowing());
+        open.fire();
+        assertEquals(1, opened.n);
+        file.hide();
+        assertFalse(file.isShowing());
+    }
+
+    @Test
+    public void aStageShownFromACodenameOneFormClosesBackToIt() {
+        Form app = home("Application");
+        Platform.setImplicitExit(true);
+        Menu file = new Menu("File");
+        file.getItems().add(new MenuItem("Open"));
+        MenuBar bar = new MenuBar(file);
+        Stage stage = new Stage();
+        stage.setTitle("Details");
+        stage.setScene(new Scene(new VBox(bar, new Label("In a stage")), 200, 120));
+        stage.show();
+        assertTrue(stage.isShowing());
+        Form shown = Display.getInstance().getCurrent();
+        assertTrue("a stage is a form over the application's", shown instanceof StageForm);
+        shown.revalidate();
+        List<Object[]> text = paint(shown);
+        assertTrue(drew(text, "In a stage"));
+        assertTrue("its menu bar is drawn in the scene", drew(text, "File"));
+        assertNotNull("the form has a way back", shown.getBackCommand());
+
+        shown.getBackCommand().actionPerformed(new com.codename1.ui.events.ActionEvent(shown));
+        assertFalse(stage.isShowing());
+        assertSame("closing the last stage returns to the application, which keeps running", app,
+                Display.getInstance().getCurrent());
+
+        // Platform.exit() is the lifecycle's to honour, and there is none.
+        Platform.exit();
+        assertSame(app, Display.getInstance().getCurrent());
+    }
+
+    @Test
+    public void anAlertFloatsOverTheApplicationsFormAndAnswers() {
+        Form app = home("Application");
+        FxInterop.setNativeWindows(false);
+        final Alert alert = new Alert(AlertType.CONFIRMATION, "Sure?");
+        final List<String> log = new ArrayList<String>();
+        // The dialog is on screen once its transition ran, which is after
+        // the work that was queued when showAndWait() was called.
+        Display.getInstance().setTimeout(50, new Runnable() {
+            private int tries;
+
+            @Override
+            public void run() {
+                Form current = Display.getInstance().getCurrent();
+                boolean up = current instanceof StageDialog;
+                if (!up && ++tries < 100) {
+                    Display.getInstance().setTimeout(50, this);
+                    return;
+                }
+                log.add("dialog=" + up);
+                log.add("ownWindow=" + (up && ((StageDialog) current).isNativeWindowMode()));
+                Node ok = alert.getDialogPane().lookupButton(ButtonType.OK);
+                if (ok instanceof Button) {
+                    ((Button) ok).fire();
+                }
+            }
+        });
+        // A theme may ask for every Codename One dialog to open in a
+        // window of its own, as the Windows native theme does. A stage
+        // the layer keeps in the application's form is not one of them.
+        boolean before = com.codename1.ui.Dialog.isDefaultNativeWindowMode();
+        com.codename1.ui.Dialog.setDefaultNativeWindowMode(true);
+        Optional<ButtonType> answer;
+        try {
+            answer = alert.showAndWait();
+        } finally {
+            com.codename1.ui.Dialog.setDefaultNativeWindowMode(before);
+        }
+        assertEquals("[dialog=true, ownWindow=false]", log.toString());
+        assertTrue(answer.isPresent());
+        assertSame(ButtonType.OK, answer.get());
+        assertSame(app, Display.getInstance().getCurrent());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GeometryTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GeometryTest.java
new file mode 100644
index 00000000000..35b9a3b73f0
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GeometryTest.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Dimension2D;
+import javafx.geometry.HPos;
+import javafx.geometry.HorizontalDirection;
+import javafx.geometry.Insets;
+import javafx.geometry.NodeOrientation;
+import javafx.geometry.Orientation;
+import javafx.geometry.Point2D;
+import javafx.geometry.Pos;
+import javafx.geometry.Rectangle2D;
+import javafx.geometry.Side;
+import javafx.geometry.VPos;
+import javafx.geometry.VerticalDirection;
+
+public class GeometryTest {
+
+    @Test
+    public void insets() {
+        Insets insets = new Insets(1, 2, 3, 4);
+        assertEquals(1.0, insets.getTop(), 0d);
+        assertEquals(2.0, insets.getRight(), 0d);
+        assertEquals(3.0, insets.getBottom(), 0d);
+        assertEquals(4.0, insets.getLeft(), 0d);
+        Insets uniform = new Insets(5);
+        assertEquals(5.0, uniform.getTop(), 0d);
+        assertEquals(5.0, uniform.getLeft(), 0d);
+        assertEquals(insets, new Insets(1, 2, 3, 4));
+        assertEquals(insets.hashCode(), new Insets(1, 2, 3, 4).hashCode());
+        assertNotEquals(insets, uniform);
+        assertNotEquals(insets, "insets");
+        assertEquals(Insets.EMPTY, new Insets(0));
+        assertEquals("Insets [top=1.0, right=2.0, bottom=3.0, left=4.0]", insets.toString());
+    }
+
+    @Test
+    public void point() {
+        Point2D p = new Point2D(3, 4);
+        assertEquals(3.0, p.getX(), 0d);
+        assertEquals(4.0, p.getY(), 0d);
+        assertEquals(5.0, p.magnitude(), 1e-12);
+        assertEquals(5.0, p.distance(0, 0), 1e-12);
+        assertEquals(5.0, p.distance(Point2D.ZERO), 1e-12);
+        assertEquals(new Point2D(4, 6), p.add(1, 2));
+        assertEquals(new Point2D(4, 6), p.add(new Point2D(1, 2)));
+        assertEquals(new Point2D(2, 2), p.subtract(1, 2));
+        assertEquals(new Point2D(2, 2), p.subtract(new Point2D(1, 2)));
+        assertEquals(new Point2D(6, 8), p.multiply(2));
+        Point2D unit = p.normalize();
+        assertEquals(0.6, unit.getX(), 1e-12);
+        assertEquals(0.8, unit.getY(), 1e-12);
+        assertEquals(Point2D.ZERO, Point2D.ZERO.normalize());
+        assertEquals(new Point2D(2, 3), p.midpoint(1, 2));
+        assertEquals(new Point2D(1.5, 2), p.midpoint(Point2D.ZERO));
+        assertEquals(11.0, p.dotProduct(1, 2), 0d);
+        assertEquals(25.0, p.dotProduct(p), 0d);
+        assertEquals(90.0, new Point2D(1, 0).angle(0, 1), 1e-9);
+        assertEquals(0.0, new Point2D(1, 0).angle(new Point2D(5, 0)), 1e-9);
+        assertEquals(180.0, new Point2D(1, 0).angle(-2, 0), 1e-9);
+        assertEquals(45.0, new Point2D(1, 0).angle(1, 1), 1e-9);
+        assertEquals(90.0, Point2D.ZERO.angle(new Point2D(1, 0), new Point2D(0, 3)), 1e-9);
+        assertEquals(p.hashCode(), new Point2D(3, 4).hashCode());
+        assertNotEquals(p, new Point2D(4, 3));
+        assertNotEquals(p, "point");
+        assertEquals("Point2D [x = 3.0, y = 4.0]", p.toString());
+        assertEquals(new Point2D(0.0, 0.0), new Point2D(-0.0, 0.0));
+        assertEquals(new Point2D(0.0, 0.0).hashCode(), new Point2D(-0.0, 0.0).hashCode());
+        assertNotEquals(new Point2D(Double.NaN, 0.0), new Point2D(Double.NaN, 0.0));
+    }
+
+    @Test
+    public void dimension() {
+        Dimension2D d = new Dimension2D(2, 3);
+        assertEquals(2.0, d.getWidth(), 0d);
+        assertEquals(3.0, d.getHeight(), 0d);
+        assertEquals(d, new Dimension2D(2, 3));
+        assertEquals(d.hashCode(), new Dimension2D(2, 3).hashCode());
+        assertNotEquals(d, new Dimension2D(3, 2));
+        assertEquals("Dimension2D [width = 2.0, height = 3.0]", d.toString());
+    }
+
+    @Test
+    public void rectangle() {
+        Rectangle2D r = new Rectangle2D(10, 20, 30, 40);
+        assertEquals(10.0, r.getMinX(), 0d);
+        assertEquals(20.0, r.getMinY(), 0d);
+        assertEquals(30.0, r.getWidth(), 0d);
+        assertEquals(40.0, r.getHeight(), 0d);
+        assertEquals(40.0, r.getMaxX(), 0d);
+        assertEquals(60.0, r.getMaxY(), 0d);
+        assertTrue(r.contains(10, 20));
+        assertTrue(r.contains(40, 60));
+        assertFalse(r.contains(41, 60));
+        assertTrue(r.contains(new Point2D(25, 30)));
+        assertFalse(r.contains((Point2D) null));
+        assertTrue(r.contains(new Rectangle2D(15, 25, 5, 5)));
+        assertFalse(r.contains(new Rectangle2D(15, 25, 50, 5)));
+        assertFalse(r.contains((Rectangle2D) null));
+        assertTrue(r.contains(10, 20, 30, 40));
+        assertFalse(r.contains(10, 20, 31, 40));
+        assertTrue(r.intersects(new Rectangle2D(35, 55, 100, 100)));
+        assertFalse(r.intersects(new Rectangle2D(41, 61, 5, 5)));
+        assertFalse(r.intersects((Rectangle2D) null));
+        assertTrue(r.intersects(0, 0, 11, 21));
+        assertFalse(r.intersects(0, 0, 5, 5));
+        assertEquals(r, new Rectangle2D(10, 20, 30, 40));
+        assertEquals(r.hashCode(), new Rectangle2D(10, 20, 30, 40).hashCode());
+        assertNotEquals(r, Rectangle2D.EMPTY);
+        assertTrue(r.toString().startsWith("Rectangle2D [minX = 10.0"));
+        try {
+            new Rectangle2D(0, 0, -1, 1);
+            fail("expected IllegalArgumentException");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void boundingBox() {
+        Bounds b = new BoundingBox(1, 2, 10, 20);
+        assertEquals(1.0, b.getMinX(), 0d);
+        assertEquals(2.0, b.getMinY(), 0d);
+        assertEquals(0.0, b.getMinZ(), 0d);
+        assertEquals(10.0, b.getWidth(), 0d);
+        assertEquals(20.0, b.getHeight(), 0d);
+        assertEquals(0.0, b.getDepth(), 0d);
+        assertEquals(11.0, b.getMaxX(), 0d);
+        assertEquals(22.0, b.getMaxY(), 0d);
+        assertEquals(0.0, b.getMaxZ(), 0d);
+        assertEquals(6.0, b.getCenterX(), 0d);
+        assertEquals(12.0, b.getCenterY(), 0d);
+        assertEquals(0.0, b.getCenterZ(), 0d);
+        assertFalse(b.isEmpty());
+        assertTrue(new BoundingBox(0, 0, -1, 5).isEmpty());
+        assertTrue(b.contains(1, 2));
+        assertTrue(b.contains(11, 22));
+        assertFalse(b.contains(12, 22));
+        assertTrue(b.contains(new Point2D(5, 5)));
+        assertFalse(b.contains((Point2D) null));
+        assertTrue(b.contains(5, 5, 0));
+        assertFalse(b.contains(5, 5, 1));
+        assertTrue(b.contains(new BoundingBox(2, 3, 1, 1)));
+        assertFalse(b.contains(new BoundingBox(2, 3, 100, 1)));
+        assertFalse(b.contains((Bounds) null));
+        assertTrue(b.contains(2, 3, 4, 5));
+        assertTrue(b.contains(2, 3, 0, 4, 5, 0));
+        assertTrue(b.intersects(new BoundingBox(10, 20, 50, 50)));
+        assertFalse(b.intersects(new BoundingBox(12, 23, 5, 5)));
+        assertFalse(b.intersects((Bounds) null));
+        assertTrue(b.intersects(0, 0, 1, 2));
+        assertFalse(b.intersects(0, 0, 0.5, 0.5));
+        assertTrue(b.intersects(0, 0, 0, 5, 5, 0));
+        assertFalse(new BoundingBox(0, 0, -1, 5).contains(0, 0));
+        Bounds box = new BoundingBox(0, 0, 0, 2, 4, 6);
+        assertEquals(6.0, box.getMaxZ(), 0d);
+        assertEquals(3.0, box.getCenterZ(), 0d);
+        assertTrue(box.contains(1, 1, 5));
+        assertEquals(b, new BoundingBox(1, 2, 10, 20));
+        assertEquals(b.hashCode(), new BoundingBox(1, 2, 10, 20).hashCode());
+        assertNotEquals(b, box);
+        assertTrue(b.toString().startsWith("BoundingBox [minX:1.0"));
+    }
+
+    @Test
+    public void positions() {
+        assertSame(VPos.TOP, Pos.TOP_LEFT.getVpos());
+        assertSame(HPos.LEFT, Pos.TOP_LEFT.getHpos());
+        assertSame(VPos.CENTER, Pos.CENTER.getVpos());
+        assertSame(HPos.CENTER, Pos.CENTER.getHpos());
+        assertSame(VPos.BASELINE, Pos.BASELINE_RIGHT.getVpos());
+        assertSame(HPos.RIGHT, Pos.BASELINE_RIGHT.getHpos());
+        assertSame(VPos.BOTTOM, Pos.BOTTOM_CENTER.getVpos());
+        assertEquals(12, Pos.values().length);
+        assertSame(Pos.CENTER_LEFT, Pos.valueOf("CENTER_LEFT"));
+        assertEquals(3, HPos.values().length);
+        assertEquals(4, VPos.values().length);
+    }
+
+    @Test
+    public void directions() {
+        assertTrue(Side.LEFT.isVertical());
+        assertTrue(Side.RIGHT.isVertical());
+        assertTrue(Side.TOP.isHorizontal());
+        assertTrue(Side.BOTTOM.isHorizontal());
+        assertFalse(Side.TOP.isVertical());
+        assertFalse(Side.LEFT.isHorizontal());
+        assertEquals(2, Orientation.values().length);
+        assertEquals(2, HorizontalDirection.values().length);
+        assertEquals(2, VerticalDirection.values().length);
+        assertEquals(3, NodeOrientation.values().length);
+        assertSame(NodeOrientation.INHERIT, NodeOrientation.valueOf("INHERIT"));
+        assertSame(Orientation.VERTICAL, Orientation.valueOf("VERTICAL"));
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GradientAndImageTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GradientAndImageTest.java
new file mode 100644
index 00000000000..0c49980c697
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GradientAndImageTest.java
@@ -0,0 +1,463 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.GradientRaster;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.Insets;
+import javafx.geometry.Side;
+import javafx.scene.Group;
+import javafx.scene.Scene;
+import javafx.scene.image.WritableImage;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundImage;
+import javafx.scene.layout.BackgroundPosition;
+import javafx.scene.layout.BackgroundRepeat;
+import javafx.scene.layout.BackgroundSize;
+import javafx.scene.layout.Border;
+import javafx.scene.layout.BorderImage;
+import javafx.scene.layout.BorderRepeat;
+import javafx.scene.layout.BorderWidths;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.Paint;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// Gradients held against what their definition gives, and the pictures
+/// of a background and of a border against where CSS places them.
+public class GradientAndImageTest {
+
+    private static final double EPS = 1e-9;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        // A picture read from a file has a size only when its pixels are kept.
+        HeadlessImplementation.pixelImages = true;
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Renderer.setTrace(null);
+        Units.setScale(0);
+        HeadlessImplementation.pixelImages = false;
+    }
+
+    private static Color at(Paint paint, double x, double y) {
+        return GradientRaster.colorAt(paint, x, y, 0, 0, 100, 50);
+    }
+
+    private static void same(Color expected, Color actual) {
+        assertEquals(expected.getRed(), actual.getRed(), 0.004);
+        assertEquals(expected.getGreen(), actual.getGreen(), 0.004);
+        assertEquals(expected.getBlue(), actual.getBlue(), 0.004);
+        assertEquals(expected.getOpacity(), actual.getOpacity(), 0.004);
+    }
+
+    private static int channel(int argb, int shift) {
+        return (argb >> shift) & 0xff;
+    }
+
+    private static void near(String what, int expected, int actual) {
+        assertTrue(what + ": alpha " + (actual >>> 24), (actual >>> 24) >= 250);
+        for (int shift = 0; shift <= 16; shift += 8) {
+            assertTrue(what + ": expected " + Integer.toHexString(expected) + ", was "
+                    + Integer.toHexString(actual), Math.abs(channel(expected, shift) - channel(actual, shift)) <= 4);
+        }
+    }
+
+    /// A gradient that does not cycle, through a shape with round corners:
+    /// the scene the captures of three ports drew wrong. The colours are
+    /// those of the definition, and nothing is painted outside the shape --
+    /// not in the square corner its bounds have and the shape has not, and
+    /// not anywhere else on the surface. The platform's paint confined
+    /// itself with a rectangle on top of a shape clip, which a port may
+    /// drop or mangle; the implementation these tests run on does not clip
+    /// to a shape at all, so a fill that leans on one shows here.
+    @Test
+    public void aGradientThatDoesNotCycleStaysInsideARoundedShape() {
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.shapes = true;
+        try {
+            com.codename1.ui.Image surface = com.codename1.ui.Image.createImage(200, 120, 0);
+            Renderer r = new Renderer(surface.getGraphics(), 0, 0);
+            com.codename1.fxcompat.runtime.FxPath path = new com.codename1.fxcompat.runtime.FxPath();
+            path.addRoundRect(20, 30, 100, 60, 20, 20);
+            Stop[] stops = {new Stop(0, Color.web("#11998e")), new Stop(1, Color.web("#38ef7d"))};
+            r.fill(path, new LinearGradient(0, 0, 1, 0, true, CycleMethod.NO_CYCLE, stops), 20, 30, 100, 60);
+            int[] px = surface.getRGB();
+            // Along the middle: the first colour, the mean, the last.
+            near("start", 0xff11998e, px[60 * 200 + 21]);
+            near("middle", 0xff25c486, px[60 * 200 + 70]);
+            near("end", 0xff38ef7d, px[60 * 200 + 118]);
+            // The corner of the bounds lies outside the round corner.
+            assertEquals("the corner of the bounds", 0, px[31 * 200 + 21] >>> 24);
+            assertEquals("the far corner of the bounds", 0, px[88 * 200 + 118] >>> 24);
+            // And nothing reaches past the shape on any side.
+            for (int y = 0; y < 120; y++) {
+                for (int x = 0; x < 200; x++) {
+                    if (x < 20 || x >= 120 || y < 30 || y >= 90) {
+                        assertEquals("painted outside the shape at " + x + "," + y, 0, px[y * 200 + x] >>> 24);
+                    }
+                }
+            }
+        } finally {
+            HeadlessImplementation.rasterImages = false;
+            HeadlessImplementation.shapes = false;
+            HeadlessImplementation.resetRaster();
+        }
+    }
+
+    @Test
+    public void aLinearGradientGivesAPointThePlaceOfItsFootOnTheLine() {
+        Stop[] stops = {new Stop(0, Color.BLACK), new Stop(1, Color.WHITE)};
+        // Proportional: the line runs over the whole width of 100.
+        LinearGradient across = new LinearGradient(0, 0, 1, 0, true, CycleMethod.NO_CYCLE, stops);
+        same(Color.gray(0.25), at(across, 25, 40));
+        same(Color.BLACK, at(across, -30, 10));
+        same(Color.WHITE, at(across, 130, 10));
+        // Absolute: from 10 to 30 whatever the rectangle is.
+        LinearGradient part = new LinearGradient(10, 0, 30, 0, false, CycleMethod.NO_CYCLE, stops);
+        same(Color.gray(0.5), at(part, 20, 0));
+        same(Color.WHITE, at(part, 60, 0));
+        // A diagonal: the foot of (10, 10) on the line from (0, 0) to
+        // (20, 20) is half way.
+        LinearGradient diagonal = new LinearGradient(0, 0, 20, 20, false, CycleMethod.NO_CYCLE, stops);
+        same(Color.gray(0.5), at(diagonal, 20, 0));
+        same(Color.gray(0.5), at(diagonal, 10, 10));
+    }
+
+    @Test
+    public void theCycleMethodsBringAPlaceOutsideTheLineBackIn() {
+        assertEquals(1, GradientRaster.cycle(1.3, CycleMethod.NO_CYCLE), EPS);
+        assertEquals(0, GradientRaster.cycle(-0.3, CycleMethod.NO_CYCLE), EPS);
+        assertEquals(0.3, GradientRaster.cycle(1.3, CycleMethod.REPEAT), EPS);
+        assertEquals(0.7, GradientRaster.cycle(-0.3, CycleMethod.REPEAT), EPS);
+        assertEquals(0.7, GradientRaster.cycle(1.3, CycleMethod.REFLECT), EPS);
+        assertEquals(0.3, GradientRaster.cycle(-0.3, CycleMethod.REFLECT), EPS);
+        assertEquals(0.3, GradientRaster.cycle(2.3, CycleMethod.REFLECT), EPS);
+        Stop[] stops = {new Stop(0, Color.BLACK), new Stop(1, Color.WHITE)};
+        LinearGradient reflected = new LinearGradient(0, 0, 20, 0, false, CycleMethod.REFLECT, stops);
+        same(Color.gray(0.5), at(reflected, 30, 0));
+        same(Color.BLACK, at(reflected, 40, 0));
+        LinearGradient repeated = new LinearGradient(0, 0, 20, 0, false, CycleMethod.REPEAT, stops);
+        same(Color.gray(0.25), at(repeated, 45, 0));
+    }
+
+    @Test
+    public void aGradientOfSeveralStopsBlendsBetweenTheTwoAroundAPlace() {
+        LinearGradient three = new LinearGradient(0, 0, 100, 0, false, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.RED), new Stop(0.5, Color.LIME), new Stop(1, Color.BLUE));
+        same(Color.RED, at(three, 0, 0));
+        same(Color.color(0.5, 0.5, 0), at(three, 25, 0));
+        same(Color.LIME, at(three, 50, 0));
+        same(Color.color(0, 0.2, 0.8), at(three, 90, 0));
+    }
+
+    @Test
+    public void aRadialGradientMeasuresAlongTheRayFromItsFocus() {
+        Stop[] stops = {new Stop(0, Color.BLACK), new Stop(1, Color.WHITE)};
+        // No focus: the distance from the centre over the radius.
+        RadialGradient plain = new RadialGradient(0, 0, 50, 25, 20, false, CycleMethod.NO_CYCLE, stops);
+        same(Color.BLACK, at(plain, 50, 25));
+        same(Color.gray(0.5), at(plain, 60, 25));
+        same(Color.gray(0.5), at(plain, 50, 15));
+        same(Color.WHITE, at(plain, 90, 25));
+        // A focus half way to the right edge of the circle: the ray to the
+        // right is 10 long, the ray to the left 30.
+        RadialGradient focused = new RadialGradient(0, 0.5, 50, 25, 20, false, CycleMethod.NO_CYCLE, stops);
+        same(Color.BLACK, at(focused, 60, 25));
+        same(Color.gray(0.5), at(focused, 65, 25));
+        same(Color.gray(0.5), at(focused, 45, 25));
+        same(Color.WHITE, at(focused, 30, 25));
+        // The angle turns the focus: a quarter turn puts it below the
+        // centre, y growing downwards.
+        RadialGradient below = new RadialGradient(90, 0.5, 50, 25, 20, false, CycleMethod.NO_CYCLE, stops);
+        same(Color.BLACK, at(below, 50, 35));
+        same(Color.gray(0.5), at(below, 50, 40));
+        // Past the circle a repeat starts over.
+        RadialGradient rings = new RadialGradient(0, 0, 50, 25, 20, false, CycleMethod.REPEAT, stops);
+        same(Color.gray(0.25), at(rings, 75, 25));
+    }
+
+    @Test
+    public void aProportionalRadialGradientIsACircleOfTheUnitSquareStretchedOverTheRectangle() {
+        Stop[] stops = {new Stop(0, Color.BLACK), new Stop(1, Color.WHITE)};
+        RadialGradient g = new RadialGradient(0, 0, 0.5, 0.5, 0.5, true, CycleMethod.NO_CYCLE, stops);
+        // Over 100 by 50 the circle is an ellipse with radii 50 and 25.
+        same(Color.BLACK, at(g, 50, 25));
+        same(Color.gray(0.5), at(g, 75, 25));
+        same(Color.gray(0.5), at(g, 50, 37.5));
+        same(Color.WHITE, at(g, 50, 50));
+    }
+
+    // ------------------------------------------------------------ pictures
+
+    private static List<double[]> images(Region region) {
+        final List<double[]> out = new ArrayList<double[]>();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                if ("image".equals(operation)) {
+                    out.add(deviceBounds);
+                }
+            }
+        });
+        region.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(400, 400, 0).getGraphics(), 0, 0));
+        Renderer.setTrace(null);
+        return out;
+    }
+
+    private static Region sized(double w, double h) {
+        Pane pane = new Pane();
+        pane.resize(w, h);
+        return pane;
+    }
+
+    private static void box(double x, double y, double w, double h, double[] bounds) {
+        assertEquals(x, bounds[0], 0.01);
+        assertEquals(y, bounds[1], 0.01);
+        assertEquals(x + w, bounds[2], 0.01);
+        assertEquals(y + h, bounds[3], 0.01);
+    }
+
+    @Test
+    public void aBackgroundImageIsPlacedSizedAndRepeatedAsItSays() {
+        WritableImage picture = new WritableImage(20, 10);
+        Region region = sized(100, 50);
+        // One copy in the middle.
+        region.setBackground(new Background(new BackgroundImage(picture, BackgroundRepeat.NO_REPEAT,
+                BackgroundRepeat.NO_REPEAT, BackgroundPosition.CENTER, BackgroundSize.DEFAULT)));
+        List<double[]> drawn = images(region);
+        assertEquals(1, drawn.size());
+        box(40, 20, 20, 10, drawn.get(0));
+        // Ten from the right edge and five from the bottom.
+        region.setBackground(new Background(new BackgroundImage(picture, BackgroundRepeat.NO_REPEAT,
+                BackgroundRepeat.NO_REPEAT, new BackgroundPosition(Side.RIGHT, 10, false, Side.BOTTOM, 5, false),
+                null)));
+        box(70, 35, 20, 10, images(region).get(0));
+        // Repeated both ways from the corner: five across, five down.
+        region.setBackground(new Background(new BackgroundImage(picture, null, null, null, null)));
+        assertEquals(25, images(region).size());
+        // Across only.
+        region.setBackground(new Background(new BackgroundImage(picture, BackgroundRepeat.REPEAT,
+                BackgroundRepeat.NO_REPEAT, null, null)));
+        assertEquals(5, images(region).size());
+        // Covering: the smallest size that leaves nothing bare.
+        region.setBackground(new Background(new BackgroundImage(picture, BackgroundRepeat.NO_REPEAT,
+                BackgroundRepeat.NO_REPEAT, null,
+                new BackgroundSize(BackgroundSize.AUTO, BackgroundSize.AUTO, true, true, false, true))));
+        box(0, 0, 100, 50, images(region).get(0));
+        // Half the width, and the height that keeps the shape.
+        region.setBackground(new Background(new BackgroundImage(picture, BackgroundRepeat.NO_REPEAT,
+                BackgroundRepeat.NO_REPEAT, null,
+                new BackgroundSize(0.5, BackgroundSize.AUTO, true, true, false, false))));
+        box(0, 0, 50, 25, images(region).get(0));
+        // Rounded: 30 wide in 100 is three copies of a third each.
+        region.setBackground(new Background(new BackgroundImage(picture, BackgroundRepeat.ROUND,
+                BackgroundRepeat.NO_REPEAT, null, new BackgroundSize(30, 10, false, false, false, false))));
+        drawn = images(region);
+        assertEquals(3, drawn.size());
+        assertEquals(100 / 3.0, drawn.get(0)[2] - drawn.get(0)[0], 1);
+    }
+
+    @Test
+    public void aBorderImageIsCutInNineAndDrawnAroundTheRegion() {
+        WritableImage picture = new WritableImage(30, 30);
+        Region region = sized(100, 60);
+        region.setBorder(new Border(new BorderImage(picture, new BorderWidths(10), Insets.EMPTY,
+                new BorderWidths(10), false, BorderRepeat.STRETCH, BorderRepeat.STRETCH)));
+        List<double[]> drawn = images(region);
+        assertEquals("four sides and four corners", 8, drawn.size());
+        box(10, 0, 80, 10, drawn.get(0));
+        box(10, 50, 80, 10, drawn.get(1));
+        box(0, 10, 10, 40, drawn.get(2));
+        box(90, 10, 10, 40, drawn.get(3));
+        box(0, 0, 10, 10, drawn.get(4));
+        box(90, 50, 10, 10, drawn.get(7));
+        assertEquals("the border takes its width from the inside", 10, region.getInsets().getLeft(), EPS);
+
+        // Filled, the middle is drawn too, under the rest.
+        region.setBorder(new Border(new BorderImage(picture, new BorderWidths(10), Insets.EMPTY,
+                new BorderWidths(10), true, BorderRepeat.STRETCH, BorderRepeat.STRETCH)));
+        drawn = images(region);
+        assertEquals(9, drawn.size());
+        box(10, 10, 80, 40, drawn.get(0));
+
+        // Repeated, a side is copies of its piece at the thickness of the
+        // border, 10 long in 80. One copy is centred on the side, as CSS
+        // has it, so seven whole ones and a half at each corner: nine.
+        region.setBorder(new Border(new BorderImage(picture, new BorderWidths(10), Insets.EMPTY,
+                new BorderWidths(10), false, BorderRepeat.REPEAT, BorderRepeat.STRETCH)));
+        assertEquals(9 + 9 + 2 + 4, images(region).size());
+        // Rounded, a whole number fits: eight.
+        region.setBorder(new Border(new BorderImage(picture, new BorderWidths(10), Insets.EMPTY,
+                new BorderWidths(10), false, BorderRepeat.ROUND, BorderRepeat.STRETCH)));
+        assertEquals(8 + 8 + 2 + 4, images(region).size());
+    }
+
+    @Test
+    public void aStyleNamesThePicturesOfABackgroundAndOfABorder() throws Exception {
+        // The picture is made here and put where the resources of the
+        // tests are read from; nothing is kept in the tree.
+        File classes = new File(GradientAndImageTest.class.getResource("/cn1-hooks.txt").toURI()).getParentFile();
+        java.awt.image.BufferedImage made = new java.awt.image.BufferedImage(20, 10,
+                java.awt.image.BufferedImage.TYPE_INT_ARGB);
+        javax.imageio.ImageIO.write(made, "png", new File(classes, "style-picture.png"));
+
+        Pane pane = new Pane();
+        pane.setStyle("-fx-background-image: url('style-picture.png'); -fx-background-repeat: no-repeat;"
+                + " -fx-background-position: right 10px bottom 5px;");
+        Scene scene = new Scene(new Group(pane), 200, 200);
+        scene.cn1Layout(200, 200);
+        Background bg = pane.getBackground();
+        assertNotNull(bg);
+        assertEquals(1, bg.getImages().size());
+        BackgroundImage image = bg.getImages().get(0);
+        assertEquals(20, image.getImage().getWidth(), EPS);
+        assertEquals(BackgroundRepeat.NO_REPEAT, image.getRepeatX());
+        assertEquals(Side.RIGHT, image.getPosition().getHorizontalSide());
+        assertEquals(10, image.getPosition().getHorizontalPosition(), EPS);
+        assertEquals(Side.BOTTOM, image.getPosition().getVerticalSide());
+        assertEquals(5, image.getPosition().getVerticalPosition(), EPS);
+
+        pane.setStyle("-fx-background-image: url('style-picture.png'); -fx-background-repeat: repeat-x;"
+                + " -fx-background-position: center; -fx-background-size: 50% auto;");
+        scene.cn1Layout(200, 200);
+        image = pane.getBackground().getImages().get(0);
+        assertEquals(BackgroundRepeat.REPEAT, image.getRepeatX());
+        assertEquals(BackgroundRepeat.NO_REPEAT, image.getRepeatY());
+        assertEquals(0.5, image.getPosition().getHorizontalPosition(), EPS);
+        assertTrue(image.getPosition().isVerticalAsPercentage());
+        assertEquals(0.5, image.getPosition().getVerticalPosition(), EPS);
+        assertEquals(0.5, image.getSize().getWidth(), EPS);
+        assertTrue(image.getSize().isWidthAsPercentage());
+        assertEquals(BackgroundSize.AUTO, image.getSize().getHeight(), EPS);
+
+        pane.setStyle("-fx-border-image-source: url('style-picture.png'); -fx-border-image-slice: 3 4 fill;"
+                + " -fx-border-image-width: 6; -fx-border-image-repeat: round stretch;"
+                + " -fx-border-image-insets: 2;");
+        scene.cn1Layout(200, 200);
+        assertTrue("the background picture went with its style", pane.getBackground() == null
+                || pane.getBackground().getImages().isEmpty());
+        Border border = pane.getBorder();
+        assertNotNull(border);
+        assertEquals(1, border.getImages().size());
+        BorderImage edge = border.getImages().get(0);
+        assertTrue(edge.isFilled());
+        assertEquals(3, edge.getSlices().getTop(), EPS);
+        assertEquals(4, edge.getSlices().getRight(), EPS);
+        assertEquals(3, edge.getSlices().getBottom(), EPS);
+        assertEquals(4, edge.getSlices().getLeft(), EPS);
+        assertEquals(6, edge.getWidths().getLeft(), EPS);
+        assertEquals(BorderRepeat.ROUND, edge.getRepeatX());
+        assertEquals(BorderRepeat.STRETCH, edge.getRepeatY());
+        assertEquals(2, edge.getInsets().getTop(), EPS);
+        assertEquals("insets and width together", 8, pane.getInsets().getTop(), EPS);
+    }
+
+    // ------------------------------------------------------------ direction
+
+    private static String arabic(int... letters) {
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < letters.length; i++) {
+            out.append((char) letters[i]);
+        }
+        return out.toString();
+    }
+
+    @Test
+    public void aFlowShowsRunsAgainstTheLineInReverse() {
+        // "He said <first>" in one text and " <second> to me." in the
+        // next: read, the first Arabic word comes before the second;
+        // seen, the two are one stretch that goes right to left, so the
+        // second is on the left of the first.
+        String first = arabic(0x627, 0x644, 0x633);
+        String second = arabic(0x639, 0x644, 0x64a);
+        javafx.scene.text.Text one = new javafx.scene.text.Text("He said " + first);
+        javafx.scene.text.Text two = new javafx.scene.text.Text(" " + second + " to me.");
+        javafx.scene.text.TextFlow flow = new javafx.scene.text.TextFlow(one, two);
+        Scene scene = new Scene(new Group(flow), 600, 200);
+        scene.cn1Layout(600, 200);
+
+        final List<String> texts = new ArrayList<String>();
+        final List<double[]> where = new ArrayList<double[]>();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                if ("text".equals(operation)) {
+                    texts.add(text);
+                    where.add(deviceBounds);
+                }
+            }
+        });
+        Renderer renderer = new Renderer(com.codename1.ui.Image.createImage(600, 200, 0).getGraphics(), 0, 0);
+        renderer.translate(one.getLayoutX(), one.getLayoutY());
+        one.cn1Paint(renderer);
+        renderer = new Renderer(com.codename1.ui.Image.createImage(600, 200, 0).getGraphics(), 0, 0);
+        renderer.translate(two.getLayoutX(), two.getLayoutY());
+        two.cn1Paint(renderer);
+        Renderer.setTrace(null);
+
+        assertEquals(4, texts.size());
+        double english = where.get(texts.indexOf("He said "))[0];
+        double firstWord = where.get(texts.indexOf(first))[0];
+        double secondWord = where.get(texts.indexOf(" " + second))[0];
+        double tail = where.get(texts.indexOf(" to me."))[0];
+        assertTrue("the line starts with its left-to-right start", english < secondWord);
+        assertTrue("the second word is seen before the first", secondWord < firstWord);
+        assertTrue("and the line ends with its left-to-right end", firstWord < tail);
+
+        // A line with no right-to-left text is drawn as it was.
+        javafx.scene.text.Text plain = new javafx.scene.text.Text("plain ");
+        javafx.scene.text.Text words = new javafx.scene.text.Text("words");
+        javafx.scene.text.TextFlow simple = new javafx.scene.text.TextFlow(plain, words);
+        new Scene(new Group(simple), 600, 200).cn1Layout(600, 200);
+        assertTrue(plain.getLayoutX() < words.getLayoutX());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GroupBoundsTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GroupBoundsTest.java
new file mode 100644
index 00000000000..b973c8d2ac4
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/GroupBoundsTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.Bounds;
+import javafx.scene.Group;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.scene.shape.Rectangle;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/// A group's layout bounds, asked before anything laid it out.
+public class GroupBoundsTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    private static HBox fixed(double w, double h) {
+        HBox box = new HBox();
+        box.setMinSize(w, h);
+        box.setPrefSize(w, h);
+        box.setMaxSize(w, h);
+        return box;
+    }
+
+    /// 2048FX builds its board in a constructor, reads the group's bounds on
+    /// the next line and scales the game by them: bounds of zero there are
+    /// a scale of infinity and an empty window.
+    @Test
+    public void aGroupOfRegionsHasTheirPreferredSizeBeforeAnyLayout() {
+        VBox column = new VBox();
+        column.getChildren().addAll(fixed(300, 90), fixed(300, 300));
+        Group inner = new Group(column);
+        Group outer = new Group(inner);
+        Bounds b = outer.getLayoutBounds();
+        assertEquals(300, b.getWidth(), 0.01);
+        assertEquals(390, b.getHeight(), 0.01);
+        assertEquals(300, column.getWidth(), 0.01);
+    }
+
+    @Test
+    public void aGroupThatDoesNotSizeItsChildrenLeavesThemAlone() {
+        HBox box = fixed(120, 40);
+        Group group = new Group();
+        group.setAutoSizeChildren(false);
+        group.getChildren().add(box);
+        assertEquals(0, group.getLayoutBounds().getWidth(), 0.01);
+        assertEquals(0, box.getWidth(), 0.01);
+    }
+
+    @Test
+    public void shapesNeedNoLayoutAndAChildAddedLaterIsCounted() {
+        Group group = new Group(new Rectangle(10, 20, 30, 40));
+        assertEquals(30, group.getLayoutBounds().getWidth(), 0.01);
+        group.getChildren().add(fixed(200, 10));
+        assertEquals(200, group.getLayoutBounds().getWidth(), 0.01);
+        assertEquals(60, group.getLayoutBounds().getHeight(), 0.01);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/LayoutPanesTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/LayoutPanesTest.java
new file mode 100644
index 00000000000..1e86873c566
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/LayoutPanesTest.java
@@ -0,0 +1,996 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.Bounds;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.geometry.VPos;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.ColumnConstraints;
+import javafx.scene.layout.FlowPane;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.RowConstraints;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.TilePane;
+import javafx.scene.layout.VBox;
+
+/// The layout panes: the bounds each gives its children and the sizes it
+/// asks for. The expected numbers are worked out by hand from the layout
+/// rules JavaFX documents, in logical pixels.
+public class LayoutPanesTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+    }
+
+    /// A region that prefers a size and may be stretched or squeezed.
+    private static Region box(double w, double h) {
+        Region r = new Region();
+        r.setPrefSize(w, h);
+        return r;
+    }
+
+    /// A region that always keeps one size.
+    private static Region fixed(double w, double h) {
+        Region r = box(w, h);
+        r.setMinSize(Region.USE_PREF_SIZE, Region.USE_PREF_SIZE);
+        r.setMaxSize(Region.USE_PREF_SIZE, Region.USE_PREF_SIZE);
+        return r;
+    }
+
+    /// A region whose height depends on its width: 1000 / width.
+    private static final class Wrapping extends Region {
+        @Override
+        public Orientation getContentBias() {
+            return Orientation.HORIZONTAL;
+        }
+
+        @Override
+        protected double computePrefWidth(double height) {
+            return 100;
+        }
+
+        @Override
+        protected double computePrefHeight(double width) {
+            return width < 0 ? 10 : 1000 / width;
+        }
+    }
+
+    private static void lay(Pane pane, double w, double h) {
+        pane.resize(w, h);
+        pane.requestLayout();
+        pane.layout();
+    }
+
+    private static void assertBounds(String what, Region r, double x, double y, double w, double h) {
+        assertEquals(what + " x", x, r.getLayoutX(), 1e-9);
+        assertEquals(what + " y", y, r.getLayoutY(), 1e-9);
+        assertEquals(what + " width", w, r.getWidth(), 1e-9);
+        assertEquals(what + " height", h, r.getHeight(), 1e-9);
+    }
+
+    // ------------------------------------------------------------- HBox
+
+    @Test
+    public void hboxPlacesChildrenInARowWithSpacingAndPadding() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        HBox box = new HBox(10, a, b);
+        box.setPadding(new Insets(5));
+        assertEquals(100, box.prefWidth(-1), 0);
+        assertEquals(50, box.prefHeight(-1), 0);
+        // The children can shrink to nothing: padding and spacing remain.
+        assertEquals(20, box.minWidth(-1), 0);
+        lay(box, 200, 100);
+        // fillHeight stretches both to the 90 between the paddings.
+        assertBounds("a", a, 5, 5, 30, 90);
+        assertBounds("b", b, 45, 5, 50, 90);
+    }
+
+    @Test
+    public void hboxAlignmentPlacesTheRowAndTheChildrenThatDoNotFill() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        HBox box = new HBox(10, a, b);
+        box.setPadding(new Insets(5));
+        box.setFillHeight(false);
+        box.setAlignment(Pos.CENTER);
+        lay(box, 200, 100);
+        // 190 inside, 90 of content: 50 spare on each side.
+        assertBounds("a", a, 55, 40, 30, 20);
+        assertBounds("b", b, 95, 30, 50, 40);
+        box.setAlignment(Pos.BOTTOM_RIGHT);
+        assertTrue(box.isNeedsLayout());
+        box.layout();
+        assertBounds("a", a, 105, 75, 30, 20);
+        assertBounds("b", b, 145, 55, 50, 40);
+    }
+
+    @Test
+    public void hboxGivesSpareWidthToTheChildrenThatGrow() {
+        Region a = box(30, 20);
+        Region b = box(50, 20);
+        Region c = box(20, 20);
+        HBox box = new HBox(a, b, c);
+        HBox.setHgrow(b, Priority.ALWAYS);
+        assertSame(Priority.ALWAYS, HBox.getHgrow(b));
+        lay(box, 200, 20);
+        assertBounds("a", a, 0, 0, 30, 20);
+        assertBounds("b", b, 30, 0, 150, 20);
+        assertBounds("c", c, 180, 0, 20, 20);
+
+        // Two growing children share the 100 spare pixels equally.
+        HBox.setHgrow(a, Priority.ALWAYS);
+        lay(box, 200, 20);
+        assertBounds("a", a, 0, 0, 80, 20);
+        assertBounds("b", b, 80, 0, 100, 20);
+        assertBounds("c", c, 180, 0, 20, 20);
+
+        // A maximum stops one of them; the other takes what it leaves.
+        a.setMaxWidth(50);
+        lay(box, 200, 20);
+        assertBounds("a", a, 0, 0, 50, 20);
+        assertBounds("b", b, 50, 0, 130, 20);
+        assertBounds("c", c, 180, 0, 20, 20);
+
+        // SOMETIMES only gets what ALWAYS could not take.
+        HBox.setHgrow(b, null);
+        HBox.setHgrow(c, Priority.SOMETIMES);
+        lay(box, 200, 20);
+        assertBounds("a", a, 0, 0, 50, 20);
+        assertBounds("b", b, 50, 0, 50, 20);
+        assertBounds("c", c, 100, 0, 100, 20);
+
+        HBox.clearConstraints(c);
+        assertNull(HBox.getHgrow(c));
+    }
+
+    @Test
+    public void hboxShrinksChildrenDownToTheirMinimum() {
+        Region a = box(100, 20);
+        a.setMinWidth(80);
+        Region b = box(100, 20);
+        HBox box = new HBox(a, b);
+        lay(box, 150, 20);
+        // 50 too narrow: a can only give 20, b gives the other 30.
+        assertBounds("a", a, 0, 0, 80, 20);
+        assertBounds("b", b, 80, 0, 70, 20);
+        assertEquals(80, box.minWidth(-1), 0);
+    }
+
+    @Test
+    public void hboxMarginSurroundsAChild() {
+        Region a = box(30, 20);
+        Region b = box(50, 20);
+        HBox box = new HBox(a, b);
+        HBox.setMargin(a, new Insets(1, 2, 3, 4));
+        assertEquals(new Insets(1, 2, 3, 4), HBox.getMargin(a));
+        assertEquals(86, box.prefWidth(-1), 0);
+        assertEquals(24, box.prefHeight(-1), 0);
+        lay(box, 200, 50);
+        assertBounds("a", a, 4, 1, 30, 46);
+        assertBounds("b", b, 36, 0, 50, 50);
+    }
+
+    @Test
+    public void hboxBaselineAlignmentLevelsTheBottomsOfChildrenWithoutText() {
+        Region a = fixed(10, 20);
+        Region b = fixed(10, 50);
+        HBox box = new HBox(a, b);
+        box.setAlignment(Pos.BASELINE_LEFT);
+        assertEquals(50, box.prefHeight(-1), 0);
+        lay(box, 100, 80);
+        assertBounds("a", a, 0, 30, 10, 20);
+        assertBounds("b", b, 10, 0, 10, 50);
+    }
+
+    @Test
+    public void hboxSkipsUnmanagedChildren() {
+        Region a = box(30, 20);
+        Region skipped = box(500, 500);
+        skipped.setManaged(false);
+        skipped.resize(7, 7);
+        skipped.relocate(3, 3);
+        Region b = box(50, 20);
+        HBox box = new HBox(a, skipped, b);
+        assertEquals(80, box.prefWidth(-1), 0);
+        lay(box, 200, 20);
+        assertBounds("b", b, 30, 0, 50, 20);
+        assertBounds("skipped", skipped, 3, 3, 7, 7);
+    }
+
+    @Test
+    public void hboxSnapsToDevicePixels() {
+        Units.setScale(2);
+        Region a = box(10.2, 10);
+        Region b = box(10, 10);
+        HBox box = new HBox(0.3, a, b);
+        lay(box, 100, 10);
+        // 10.2 grows to 10.5 (21 device pixels); the gap rounds to 0.5.
+        assertBounds("a", a, 0, 0, 10.5, 10);
+        assertBounds("b", b, 11, 0, 10, 10);
+        assertEquals(21, box.prefWidth(-1), 0);
+    }
+
+    @Test
+    public void hboxTakesStyleValuesAndRestoresThem() {
+        HBox box = new HBox(3);
+        assertTrue(box.cn1ApplyStyle("-fx-spacing", Integer.valueOf(12)));
+        assertEquals(12, box.getSpacing(), 0);
+        assertTrue(box.cn1ApplyStyle("-fx-spacing", null));
+        assertEquals(3, box.getSpacing(), 0);
+        assertFalse(box.cn1ApplyStyle("-fx-spacing", "wide"));
+
+        assertTrue(box.cn1ApplyStyle("-fx-alignment", "Center-LEFT"));
+        assertSame(Pos.CENTER_LEFT, box.getAlignment());
+        assertTrue(box.cn1ApplyStyle("-fx-alignment", Pos.BOTTOM_RIGHT));
+        assertSame(Pos.BOTTOM_RIGHT, box.getAlignment());
+        assertFalse(box.cn1ApplyStyle("-fx-alignment", "sideways"));
+        assertSame(Pos.BOTTOM_RIGHT, box.getAlignment());
+        assertTrue(box.cn1ApplyStyle("-fx-alignment", null));
+        assertSame(Pos.TOP_LEFT, box.getAlignment());
+
+        assertTrue(box.cn1ApplyStyle("-fx-fill-height", Boolean.FALSE));
+        assertFalse(box.isFillHeight());
+        assertTrue(box.cn1ApplyStyle("-fx-fill-height", null));
+        assertTrue(box.isFillHeight());
+        assertFalse(box.cn1ApplyStyle("-fx-fill-width", Boolean.FALSE));
+        assertFalse(box.cn1ApplyStyle("-fx-hgap", Integer.valueOf(1)));
+    }
+
+    // ------------------------------------------------------------- VBox
+
+    @Test
+    public void vboxPlacesChildrenInAColumn() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        VBox box = new VBox(5, a, b);
+        assertEquals(50, box.prefWidth(-1), 0);
+        assertEquals(65, box.prefHeight(-1), 0);
+        lay(box, 100, 165);
+        assertBounds("a", a, 0, 0, 100, 20);
+        assertBounds("b", b, 0, 25, 100, 40);
+
+        box.setFillWidth(false);
+        box.setAlignment(Pos.CENTER);
+        box.layout();
+        // 100 of spare height: 50 above; each child centered on its own.
+        assertBounds("a", a, 35, 50, 30, 20);
+        assertBounds("b", b, 25, 75, 50, 40);
+
+        box.setAlignment(Pos.TOP_RIGHT);
+        VBox.setVgrow(b, Priority.ALWAYS);
+        VBox.setMargin(a, new Insets(2, 4, 0, 0));
+        lay(box, 100, 165);
+        assertBounds("a", a, 66, 2, 30, 20);
+        // a's area is 22 tall, then the gap; b takes the rest.
+        assertBounds("b", b, 50, 27, 50, 138);
+        VBox.clearConstraints(b);
+        assertNull(VBox.getVgrow(b));
+    }
+
+    @Test
+    public void vboxGivesAWidthBiasedChildTheHeightItsWidthNeeds() {
+        Wrapping text = new Wrapping();
+        VBox box = new VBox(text);
+        assertSame(Orientation.HORIZONTAL, box.getContentBias());
+        assertEquals(10, box.prefHeight(-1), 0);
+        assertEquals(20, box.prefHeight(50), 0);
+        lay(box, 50, 100);
+        assertBounds("text", text, 0, 0, 50, 20);
+    }
+
+    @Test
+    public void vboxTakesStyleValuesAndRestoresThem() {
+        VBox box = new VBox();
+        assertTrue(box.cn1ApplyStyle("-fx-spacing", Double.valueOf(4.5)));
+        assertEquals(4.5, box.getSpacing(), 0);
+        assertTrue(box.cn1ApplyStyle("-fx-alignment", "bottom-center"));
+        assertSame(Pos.BOTTOM_CENTER, box.getAlignment());
+        assertTrue(box.cn1ApplyStyle("-fx-fill-width", Boolean.FALSE));
+        assertFalse(box.isFillWidth());
+        assertFalse(box.cn1ApplyStyle("-fx-fill-width", "no"));
+        assertTrue(box.cn1ApplyStyle("-fx-spacing", null));
+        assertTrue(box.cn1ApplyStyle("-fx-alignment", null));
+        assertTrue(box.cn1ApplyStyle("-fx-fill-width", null));
+        assertEquals(0, box.getSpacing(), 0);
+        assertSame(Pos.TOP_LEFT, box.getAlignment());
+        assertTrue(box.isFillWidth());
+        assertFalse(box.cn1ApplyStyle("-fx-fill-height", Boolean.TRUE));
+    }
+
+    // -------------------------------------------------------- StackPane
+
+    @Test
+    public void stackPaneStacksChildrenInItsContentArea() {
+        Region small = fixed(30, 20);
+        Region big = box(50, 40);
+        StackPane stack = new StackPane(big, small);
+        stack.setPadding(new Insets(10));
+        assertEquals(70, stack.prefWidth(-1), 0);
+        assertEquals(60, stack.prefHeight(-1), 0);
+        // The fixed child cannot shrink below 30 x 20.
+        assertEquals(50, stack.minWidth(-1), 0);
+        assertEquals(40, stack.minHeight(-1), 0);
+        lay(stack, 100, 80);
+        assertBounds("big", big, 10, 10, 80, 60);
+        assertBounds("small", small, 35, 30, 30, 20);
+
+        StackPane.setAlignment(small, Pos.BOTTOM_RIGHT);
+        lay(stack, 100, 80);
+        assertBounds("small", small, 60, 50, 30, 20);
+
+        StackPane.setMargin(small, new Insets(0, 5, 7, 0));
+        lay(stack, 100, 80);
+        assertBounds("small", small, 55, 43, 30, 20);
+
+        StackPane.clearConstraints(small);
+        assertNull(StackPane.getAlignment(small));
+        assertNull(StackPane.getMargin(small));
+        stack.setAlignment(Pos.TOP_LEFT);
+        stack.layout();
+        assertBounds("small", small, 10, 10, 30, 20);
+    }
+
+    @Test
+    public void stackPaneTakesStyleValuesAndRestoresThem() {
+        StackPane stack = new StackPane();
+        assertTrue(stack.cn1ApplyStyle("-fx-alignment", "top-right"));
+        assertSame(Pos.TOP_RIGHT, stack.getAlignment());
+        assertFalse(stack.cn1ApplyStyle("-fx-alignment", Integer.valueOf(3)));
+        assertTrue(stack.cn1ApplyStyle("-fx-alignment", null));
+        assertSame(Pos.CENTER, stack.getAlignment());
+        assertFalse(stack.cn1ApplyStyle("-fx-spacing", Integer.valueOf(3)));
+    }
+
+    // ------------------------------------------------------- BorderPane
+
+    @Test
+    public void borderPanePlacesTheFivePositions() {
+        Region top = box(10, 20);
+        Region bottom = box(10, 30);
+        Region left = box(40, 10);
+        Region right = box(50, 10);
+        Region center = box(5, 5);
+        BorderPane pane = new BorderPane(center, top, right, bottom, left);
+        assertEquals(5, pane.getChildren().size());
+        assertEquals(95, pane.prefWidth(-1), 0);
+        assertEquals(60, pane.prefHeight(-1), 0);
+        lay(pane, 300, 200);
+        assertBounds("top", top, 0, 0, 300, 20);
+        assertBounds("bottom", bottom, 0, 170, 300, 30);
+        assertBounds("left", left, 0, 20, 40, 150);
+        assertBounds("right", right, 250, 20, 50, 150);
+        assertBounds("center", center, 40, 20, 210, 150);
+
+        BorderPane.setMargin(center, new Insets(5));
+        lay(pane, 300, 200);
+        assertBounds("center", center, 45, 25, 200, 140);
+    }
+
+    @Test
+    public void borderPaneAlignsChildrenThatDoNotFillTheirArea() {
+        Region top = fixed(100, 20);
+        Region center = fixed(60, 40);
+        BorderPane pane = new BorderPane();
+        pane.setTop(top);
+        pane.setCenter(center);
+        lay(pane, 300, 200);
+        assertBounds("top", top, 0, 0, 100, 20);
+        // The center has 300 x 180 below the top.
+        assertBounds("center", center, 120, 90, 60, 40);
+
+        BorderPane.setAlignment(top, Pos.CENTER);
+        BorderPane.setAlignment(center, Pos.TOP_LEFT);
+        lay(pane, 300, 200);
+        assertBounds("top", top, 100, 0, 100, 20);
+        assertBounds("center", center, 0, 20, 60, 40);
+        BorderPane.clearConstraints(top);
+        assertNull(BorderPane.getAlignment(top));
+    }
+
+    @Test
+    public void borderPaneMarginOfAnEdgeMovesTheMiddle() {
+        Region top = box(10, 20);
+        Region left = box(40, 10);
+        BorderPane pane = new BorderPane();
+        pane.setTop(top);
+        pane.setLeft(left);
+        BorderPane.setMargin(top, new Insets(2, 3, 4, 5));
+        lay(pane, 300, 200);
+        assertBounds("top", top, 5, 2, 292, 20);
+        assertBounds("left", left, 0, 26, 40, 174);
+    }
+
+    @Test
+    public void borderPanePropertiesKeepTheChildrenInStep() {
+        Region first = box(1, 1);
+        Region second = box(1, 1);
+        BorderPane pane = new BorderPane(first);
+        assertSame(first, pane.getCenter());
+        assertSame(pane, first.getParent());
+        pane.setCenter(second);
+        assertNull(first.getParent());
+        assertEquals(1, pane.getChildren().size());
+        assertSame(second, pane.getChildren().get(0));
+        pane.setTop(first);
+        assertEquals(2, pane.getChildren().size());
+        pane.setTop(null);
+        pane.setCenter(null);
+        assertTrue(pane.getChildren().isEmpty());
+    }
+
+    // ------------------------------------------------------- AnchorPane
+
+    @Test
+    public void anchorPaneKeepsEdgesAtTheirAnchors() {
+        Region a = box(30, 20);
+        Region b = box(30, 20);
+        Region c = box(30, 20);
+        AnchorPane pane = new AnchorPane(a, b, c);
+        pane.setPadding(new Insets(10));
+        AnchorPane.setTopAnchor(a, Double.valueOf(5));
+        AnchorPane.setLeftAnchor(a, Double.valueOf(7));
+        AnchorPane.setLeftAnchor(b, Double.valueOf(10));
+        AnchorPane.setRightAnchor(b, Double.valueOf(20));
+        AnchorPane.setTopAnchor(b, Double.valueOf(5));
+        AnchorPane.setBottomAnchor(b, Double.valueOf(5));
+        AnchorPane.setRightAnchor(c, Double.valueOf(0));
+        AnchorPane.setBottomAnchor(c, Double.valueOf(0));
+        assertEquals(Double.valueOf(20), AnchorPane.getRightAnchor(b));
+        // b needs 10 + 30 + 20 across and 5 + 20 + 5 down, plus padding.
+        assertEquals(80, pane.prefWidth(-1), 0);
+        assertEquals(50, pane.prefHeight(-1), 0);
+        lay(pane, 200, 100);
+        assertBounds("a", a, 17, 15, 30, 20);
+        // Anchored on both sides: stretched between them.
+        assertBounds("b", b, 20, 15, 150, 70);
+        assertBounds("c", c, 160, 70, 30, 20);
+
+        AnchorPane.clearConstraints(b);
+        assertNull(AnchorPane.getLeftAnchor(b));
+        assertNull(AnchorPane.getTopAnchor(b));
+        assertNull(AnchorPane.getRightAnchor(b));
+        assertNull(AnchorPane.getBottomAnchor(b));
+        lay(pane, 200, 100);
+        // Without anchors it keeps its position and takes its own size.
+        assertBounds("b", b, 20, 15, 30, 20);
+    }
+
+    // --------------------------------------------------------- FlowPane
+
+    @Test
+    public void flowPaneWrapsRowsAtItsWidth() {
+        Region a = fixed(40, 20);
+        Region b = fixed(40, 20);
+        Region c = fixed(40, 20);
+        Region d = fixed(40, 30);
+        FlowPane flow = new FlowPane(5, 10, a, b, c, d);
+        assertSame(Orientation.HORIZONTAL, flow.getContentBias());
+        assertEquals(400, flow.prefWidth(-1), 0);
+        flow.setPrefWrapLength(100);
+        assertEquals(100, flow.prefWidth(-1), 0);
+        // Two rows of 20 and 30 with a gap of 10.
+        assertEquals(60, flow.prefHeight(-1), 0);
+        // In 200 everything fits one row as tall as d.
+        assertEquals(30, flow.prefHeight(200), 0);
+        assertEquals(40, flow.minWidth(-1), 0);
+        lay(flow, 100, 100);
+        assertBounds("a", a, 0, 0, 40, 20);
+        assertBounds("b", b, 45, 0, 40, 20);
+        // c is centered in a row as tall as d.
+        assertBounds("c", c, 0, 35, 40, 20);
+        assertBounds("d", d, 45, 30, 40, 30);
+
+        flow.setRowValignment(VPos.TOP);
+        flow.layout();
+        assertBounds("c", c, 0, 30, 40, 20);
+
+        flow.setAlignment(Pos.CENTER);
+        lay(flow, 105, 100);
+        // Rows are 85 wide in 105, the content 60 tall in 100.
+        assertBounds("a", a, 10, 20, 40, 20);
+        assertBounds("b", b, 55, 20, 40, 20);
+        assertBounds("c", c, 10, 50, 40, 20);
+        assertBounds("d", d, 55, 50, 40, 30);
+    }
+
+    @Test
+    public void flowPaneMarginCountsTowardsTheRow() {
+        Region a = fixed(40, 20);
+        Region b = fixed(40, 20);
+        Region c = fixed(40, 20);
+        FlowPane flow = new FlowPane(5, 10, a, b, c);
+        FlowPane.setMargin(a, new Insets(0, 0, 0, 6));
+        lay(flow, 135, 100);
+        // 46 + 5 + 40 + 5 + 40 is one more than fits.
+        assertBounds("a", a, 6, 0, 40, 20);
+        assertBounds("b", b, 51, 0, 40, 20);
+        assertBounds("c", c, 0, 30, 40, 20);
+        FlowPane.clearConstraints(a);
+        assertNull(FlowPane.getMargin(a));
+        lay(flow, 135, 100);
+        assertBounds("c", c, 90, 0, 40, 20);
+    }
+
+    @Test
+    public void flowPaneVerticalWrapsColumnsAtItsHeight() {
+        Region a = fixed(40, 20);
+        Region b = fixed(40, 20);
+        Region c = fixed(30, 20);
+        Region d = fixed(40, 30);
+        FlowPane flow = new FlowPane(Orientation.VERTICAL, 5, 10, a, b, c, d);
+        assertSame(Orientation.VERTICAL, flow.getContentBias());
+        lay(flow, 200, 60);
+        assertBounds("a", a, 0, 0, 40, 20);
+        assertBounds("b", b, 0, 30, 40, 20);
+        assertBounds("c", c, 45, 0, 30, 20);
+        assertBounds("d", d, 45, 30, 40, 30);
+        flow.setColumnHalignment(HPos.RIGHT);
+        flow.layout();
+        assertBounds("c", c, 55, 0, 30, 20);
+        // Two columns of 40 with a gap of 5.
+        assertEquals(85, flow.prefWidth(60), 0);
+        assertEquals(30, flow.minHeight(-1), 0);
+    }
+
+    @Test
+    public void flowPaneTakesStyleValuesAndRestoresThem() {
+        FlowPane flow = new FlowPane();
+        assertTrue(flow.cn1ApplyStyle("-fx-hgap", Integer.valueOf(4)));
+        assertTrue(flow.cn1ApplyStyle("-fx-vgap", Integer.valueOf(6)));
+        assertTrue(flow.cn1ApplyStyle("-fx-alignment", "center"));
+        assertTrue(flow.cn1ApplyStyle("-fx-orientation", "VERTICAL"));
+        assertEquals(4, flow.getHgap(), 0);
+        assertEquals(6, flow.getVgap(), 0);
+        assertSame(Pos.CENTER, flow.getAlignment());
+        assertSame(Orientation.VERTICAL, flow.getOrientation());
+        assertFalse(flow.cn1ApplyStyle("-fx-orientation", "diagonal"));
+        assertTrue(flow.cn1ApplyStyle("-fx-orientation", Orientation.HORIZONTAL));
+        assertTrue(flow.cn1ApplyStyle("-fx-hgap", null));
+        assertTrue(flow.cn1ApplyStyle("-fx-vgap", null));
+        assertTrue(flow.cn1ApplyStyle("-fx-alignment", null));
+        assertTrue(flow.cn1ApplyStyle("-fx-orientation", null));
+        assertEquals(0, flow.getHgap(), 0);
+        assertEquals(0, flow.getVgap(), 0);
+        assertSame(Pos.TOP_LEFT, flow.getAlignment());
+        assertSame(Orientation.HORIZONTAL, flow.getOrientation());
+    }
+
+    // --------------------------------------------------------- TilePane
+
+    @Test
+    public void tilePaneGivesEveryChildATileOfTheLargestSize() {
+        Region a = fixed(30, 20);
+        Region b = fixed(50, 40);
+        Region c = fixed(10, 10);
+        TilePane tiles = new TilePane(5, 5, a, b, c);
+        assertEquals(50, tiles.getTileWidth(), 0);
+        assertEquals(40, tiles.getTileHeight(), 0);
+        assertEquals(50, tiles.tileWidthProperty().get(), 0);
+        // Five columns by default: one row.
+        assertEquals(270, tiles.prefWidth(-1), 0);
+        assertEquals(40, tiles.prefHeight(-1), 0);
+        tiles.setPrefColumns(2);
+        assertEquals(105, tiles.prefWidth(-1), 0);
+        assertEquals(85, tiles.prefHeight(-1), 0);
+        assertEquals(85, tiles.prefHeight(120), 0);
+        assertEquals(50, tiles.minWidth(-1), 0);
+        lay(tiles, 120, 200);
+        // Two tiles of 50 and a gap fit in 120; children sit centered.
+        assertBounds("a", a, 10, 10, 30, 20);
+        assertBounds("b", b, 55, 0, 50, 40);
+        assertBounds("c", c, 20, 60, 10, 10);
+
+        TilePane.setAlignment(a, Pos.TOP_LEFT);
+        tiles.setTileAlignment(Pos.BOTTOM_RIGHT);
+        lay(tiles, 120, 200);
+        assertBounds("a", a, 0, 0, 30, 20);
+        assertBounds("c", c, 40, 75, 10, 10);
+        TilePane.clearConstraints(a);
+        assertNull(TilePane.getAlignment(a));
+    }
+
+    @Test
+    public void tilePaneStretchesResizableChildrenAndAlignsTheLastRow() {
+        Region a = box(30, 20);
+        Region b = fixed(50, 40);
+        Region c = fixed(10, 10);
+        TilePane tiles = new TilePane(5, 5, a, b, c);
+        tiles.setAlignment(Pos.TOP_RIGHT);
+        TilePane.setMargin(a, new Insets(1, 2, 3, 4));
+        lay(tiles, 125, 200);
+        // The grid of two columns is 105 wide: 20 spare on the left.
+        assertBounds("a", a, 24, 1, 44, 36);
+        assertBounds("b", b, 75, 0, 50, 40);
+        // The single tile of the last row goes to the right on its own.
+        assertBounds("c", c, 95, 60, 10, 10);
+    }
+
+    @Test
+    public void tilePaneVerticalFillsColumnsAndHonoursPrefTileSize() {
+        Region a = fixed(30, 20);
+        Region b = fixed(50, 40);
+        Region c = fixed(10, 10);
+        TilePane tiles = new TilePane(Orientation.VERTICAL, 5, 5, a, b, c);
+        tiles.setTileAlignment(Pos.TOP_LEFT);
+        lay(tiles, 300, 90);
+        assertBounds("a", a, 0, 0, 30, 20);
+        assertBounds("b", b, 0, 45, 50, 40);
+        assertBounds("c", c, 55, 0, 10, 10);
+        tiles.setPrefTileWidth(60);
+        tiles.setPrefTileHeight(42);
+        tiles.setPrefRows(3);
+        assertEquals(60, tiles.getTileWidth(), 0);
+        // Three rows hold all three children in one column.
+        assertEquals(60, tiles.prefWidth(-1), 0);
+        assertEquals(136, tiles.prefHeight(-1), 0);
+        lay(tiles, 300, 90);
+        assertBounds("b", b, 0, 47, 50, 40);
+        assertBounds("c", c, 65, 0, 10, 10);
+    }
+
+    @Test
+    public void tilePaneTakesStyleValuesAndRestoresThem() {
+        TilePane tiles = new TilePane(2, 3);
+        assertTrue(tiles.cn1ApplyStyle("-fx-hgap", Integer.valueOf(4)));
+        assertTrue(tiles.cn1ApplyStyle("-fx-vgap", Integer.valueOf(6)));
+        assertTrue(tiles.cn1ApplyStyle("-fx-alignment", "bottom-left"));
+        assertTrue(tiles.cn1ApplyStyle("-fx-orientation", "vertical"));
+        assertEquals(4, tiles.getHgap(), 0);
+        assertEquals(6, tiles.getVgap(), 0);
+        assertSame(Pos.BOTTOM_LEFT, tiles.getAlignment());
+        assertSame(Orientation.VERTICAL, tiles.getOrientation());
+        assertFalse(tiles.cn1ApplyStyle("-fx-hgap", "x"));
+        assertTrue(tiles.cn1ApplyStyle("-fx-hgap", null));
+        assertTrue(tiles.cn1ApplyStyle("-fx-vgap", null));
+        assertTrue(tiles.cn1ApplyStyle("-fx-alignment", null));
+        assertTrue(tiles.cn1ApplyStyle("-fx-orientation", null));
+        assertEquals(2, tiles.getHgap(), 0);
+        assertEquals(3, tiles.getVgap(), 0);
+        assertSame(Pos.TOP_LEFT, tiles.getAlignment());
+        assertSame(Orientation.HORIZONTAL, tiles.getOrientation());
+    }
+
+    // --------------------------------------------------------- GridPane
+
+    private static GridPane grid(Region a, Region b, Region c, Region d) {
+        GridPane grid = new GridPane();
+        grid.setHgap(5);
+        grid.setVgap(10);
+        grid.add(a, 0, 0);
+        grid.add(b, 1, 0);
+        grid.add(c, 0, 1);
+        grid.add(d, 1, 1);
+        return grid;
+    }
+
+    @Test
+    public void gridPaneSizesRowsAndColumnsToTheirLargestChild() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        Region c = box(40, 10);
+        Region d = box(20, 20);
+        GridPane grid = grid(a, b, c, d);
+        assertEquals(2, grid.getColumnCount());
+        assertEquals(2, grid.getRowCount());
+        assertEquals(Integer.valueOf(1), GridPane.getColumnIndex(d));
+        assertEquals(Integer.valueOf(1), GridPane.getRowIndex(d));
+        assertEquals(95, grid.prefWidth(-1), 0);
+        assertEquals(70, grid.prefHeight(-1), 0);
+        lay(grid, 200, 200);
+        // Columns of 40 and 50, rows of 40 and 20; nothing grows.
+        assertBounds("a", a, 0, 0, 40, 40);
+        assertBounds("b", b, 45, 0, 50, 40);
+        assertBounds("c", c, 0, 50, 40, 20);
+        assertBounds("d", d, 45, 50, 50, 20);
+        Bounds cell = grid.getCellBounds(1, 1);
+        assertEquals(45, cell.getMinX(), 0);
+        assertEquals(50, cell.getMinY(), 0);
+        assertEquals(50, cell.getWidth(), 0);
+        assertEquals(20, cell.getHeight(), 0);
+
+        grid.setAlignment(Pos.CENTER);
+        lay(grid, 195, 170);
+        assertBounds("a", a, 50, 50, 40, 40);
+        assertBounds("d", d, 95, 100, 50, 20);
+    }
+
+    @Test
+    public void gridPaneAlignsAndFillsInsideTheCell() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        Region c = box(40, 10);
+        Region d = box(20, 20);
+        Region dot = fixed(10, 10);
+        GridPane grid = grid(a, b, c, d);
+        grid.add(dot, 0, 0);
+        lay(grid, 200, 200);
+        // Left and vertically centered unless told otherwise.
+        assertBounds("dot", dot, 0, 15, 10, 10);
+        GridPane.setHalignment(dot, HPos.RIGHT);
+        GridPane.setValignment(dot, VPos.BOTTOM);
+        GridPane.setFillWidth(a, Boolean.FALSE);
+        GridPane.setFillHeight(a, Boolean.FALSE);
+        assertSame(Boolean.FALSE, GridPane.isFillWidth(a));
+        lay(grid, 200, 200);
+        assertBounds("dot", dot, 30, 30, 10, 10);
+        assertBounds("a", a, 0, 10, 30, 20);
+
+        // The constraints of the column and the row apply to the rest.
+        ColumnConstraints second = new ColumnConstraints();
+        second.setHalignment(HPos.CENTER);
+        second.setFillWidth(false);
+        RowConstraints lower = new RowConstraints();
+        lower.setValignment(VPos.TOP);
+        lower.setFillHeight(false);
+        grid.getColumnConstraints().addAll(new ColumnConstraints(), second);
+        grid.getRowConstraints().addAll(new RowConstraints(), lower);
+        lay(grid, 200, 200);
+        assertBounds("d", d, 60, 50, 20, 20);
+        assertBounds("c", c, 0, 50, 40, 10);
+        assertBounds("b", b, 45, 0, 50, 40);
+    }
+
+    @Test
+    public void gridPaneGrowsTheColumnsAndRowsThatAskForIt() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        Region c = box(40, 10);
+        Region d = box(20, 20);
+        GridPane grid = grid(a, b, c, d);
+        GridPane.setHgrow(b, Priority.ALWAYS);
+        GridPane.setVgrow(c, Priority.ALWAYS);
+        lay(grid, 200, 200);
+        assertBounds("a", a, 0, 0, 40, 40);
+        assertBounds("b", b, 45, 0, 155, 40);
+        assertBounds("c", c, 0, 50, 40, 150);
+        assertBounds("d", d, 45, 50, 155, 150);
+
+        // A constraint decides for its column whatever the children ask.
+        ColumnConstraints first = new ColumnConstraints();
+        first.setHgrow(Priority.ALWAYS);
+        ColumnConstraints second = new ColumnConstraints();
+        second.setHgrow(Priority.NEVER);
+        grid.getColumnConstraints().addAll(first, second);
+        lay(grid, 200, 200);
+        assertBounds("a", a, 0, 0, 145, 40);
+        assertBounds("b", b, 150, 0, 50, 40);
+
+        // Two growing columns share the 106 spare pixels.
+        second.setHgrow(Priority.ALWAYS);
+        assertTrue(grid.isNeedsLayout());
+        lay(grid, 201, 200);
+        assertBounds("a", a, 0, 0, 93, 40);
+        assertBounds("b", b, 98, 0, 103, 40);
+    }
+
+    @Test
+    public void gridPaneConstraintsFixTheSizeOfARowOrColumn() {
+        Region a = box(30, 20);
+        Region b = box(50, 40);
+        Region c = box(40, 10);
+        Region d = box(20, 20);
+        GridPane grid = grid(a, b, c, d);
+        grid.getColumnConstraints().addAll(new ColumnConstraints(100), new ColumnConstraints(60));
+        grid.getRowConstraints().add(new RowConstraints(25));
+        assertEquals(165, grid.prefWidth(-1), 0);
+        assertEquals(55, grid.prefHeight(-1), 0);
+        lay(grid, 400, 400);
+        assertBounds("a", a, 0, 0, 100, 25);
+        assertBounds("b", b, 105, 0, 60, 25);
+        assertBounds("c", c, 0, 35, 100, 20);
+        assertBounds("d", d, 105, 35, 60, 20);
+
+        ColumnConstraints ranged = new ColumnConstraints(10, 70, 80);
+        ranged.setHgrow(Priority.ALWAYS);
+        grid.getColumnConstraints().set(1, ranged);
+        lay(grid, 400, 400);
+        // It prefers 70 and may grow, but only to 80.
+        assertBounds("b", b, 105, 0, 80, 25);
+    }
+
+    @Test
+    public void gridPanePercentagesShareThePaneLessTheGaps() {
+        Region a = box(30, 20);
+        Region b = box(60, 20);
+        GridPane grid = new GridPane();
+        grid.setHgap(10);
+        grid.add(a, 0, 0);
+        grid.add(b, 1, 0);
+        ColumnConstraints quarter = new ColumnConstraints();
+        quarter.setPercentWidth(25);
+        ColumnConstraints rest = new ColumnConstraints();
+        rest.setPercentWidth(75);
+        grid.getColumnConstraints().addAll(quarter, rest);
+        RowConstraints half = new RowConstraints();
+        half.setPercentHeight(50);
+        grid.getRowConstraints().add(half);
+        lay(grid, 210, 100);
+        assertBounds("a", a, 0, 0, 50, 50);
+        assertBounds("b", b, 60, 0, 150, 50);
+        // A quarter must hold 30: 120 of columns, plus the gap.
+        assertEquals(130, grid.prefWidth(-1), 0);
+        // Half of the height must hold 20.
+        assertEquals(40, grid.prefHeight(-1), 0);
+    }
+
+    @Test
+    public void gridPaneSpansCoverSeveralColumns() {
+        Region title = box(20, 10);
+        Region a = box(30, 20);
+        Region b = box(30, 20);
+        GridPane grid = new GridPane();
+        grid.setHgap(5);
+        grid.add(title, 0, 0, 2, 1);
+        grid.add(a, 0, 1);
+        grid.add(b, 1, 1);
+        assertEquals(Integer.valueOf(2), GridPane.getColumnSpan(title));
+        assertEquals(65, grid.prefWidth(-1), 0);
+        lay(grid, 300, 300);
+        assertBounds("title", title, 0, 0, 65, 10);
+        assertBounds("b", b, 35, 10, 30, 20);
+
+        // A span that needs more than its columns have widens them.
+        title.setPrefWidth(105);
+        GridPane.setColumnSpan(title, Integer.valueOf(GridPane.REMAINING));
+        assertEquals(2, grid.getColumnCount());
+        assertEquals(105, grid.prefWidth(-1), 0);
+        lay(grid, 300, 300);
+        assertBounds("title", title, 0, 0, 105, 10);
+        assertBounds("a", a, 0, 10, 50, 20);
+        assertBounds("b", b, 55, 10, 50, 20);
+    }
+
+    @Test
+    public void gridPaneMarginSurroundsAChildInItsCell() {
+        Region a = box(30, 20);
+        GridPane grid = new GridPane();
+        GridPane.setConstraints(a, 0, 0, 1, 1, HPos.LEFT, VPos.TOP, Priority.NEVER, Priority.NEVER,
+                new Insets(2, 3, 4, 5));
+        grid.getChildren().add(a);
+        assertEquals(38, grid.prefWidth(-1), 0);
+        assertEquals(26, grid.prefHeight(-1), 0);
+        lay(grid, 100, 100);
+        assertBounds("a", a, 5, 2, 30, 20);
+        GridPane.clearConstraints(a);
+        assertNull(GridPane.getMargin(a));
+        assertNull(GridPane.getHgrow(a));
+        assertNull(GridPane.getHalignment(a));
+        assertNull(GridPane.getRowIndex(a));
+    }
+
+    @Test
+    public void gridPaneShrinksColumnsDownToTheirMinimum() {
+        Region a = box(100, 20);
+        Region b = box(100, 20);
+        b.setMinWidth(80);
+        GridPane grid = new GridPane();
+        grid.addRow(0, a, b);
+        assertEquals(80, grid.minWidth(-1), 0);
+        lay(grid, 150, 20);
+        assertBounds("a", a, 0, 0, 70, 20);
+        assertBounds("b", b, 70, 0, 80, 20);
+    }
+
+    @Test
+    public void gridPaneAddRowAndAddColumnContinueAfterWhatIsThere() {
+        Region a = box(1, 1);
+        Region b = box(1, 1);
+        Region c = box(1, 1);
+        Region d = box(1, 1);
+        GridPane grid = new GridPane();
+        grid.addRow(0, a, b);
+        grid.addRow(0, c);
+        grid.addColumn(1, d);
+        assertEquals(Integer.valueOf(0), GridPane.getColumnIndex(a));
+        assertEquals(Integer.valueOf(1), GridPane.getColumnIndex(b));
+        assertEquals(Integer.valueOf(2), GridPane.getColumnIndex(c));
+        assertEquals(Integer.valueOf(0), GridPane.getRowIndex(c));
+        assertEquals(Integer.valueOf(1), GridPane.getColumnIndex(d));
+        assertEquals(Integer.valueOf(1), GridPane.getRowIndex(d));
+        assertEquals(3, grid.getColumnCount());
+        assertEquals(2, grid.getRowCount());
+    }
+
+    @Test
+    public void gridPaneConstraintChangesAskForLayout() {
+        GridPane grid = new GridPane();
+        ColumnConstraints column = new ColumnConstraints();
+        grid.getColumnConstraints().add(column);
+        grid.add(box(10, 10), 0, 0);
+        lay(grid, 100, 100);
+        assertFalse(grid.isNeedsLayout());
+        column.setPrefWidth(40);
+        assertTrue(grid.isNeedsLayout());
+        grid.layout();
+        assertEquals(40, grid.prefWidth(-1), 0);
+        grid.getColumnConstraints().clear();
+        grid.layout();
+        column.setPrefWidth(50);
+        assertFalse(grid.isNeedsLayout());
+        grid.setHgap(3);
+        assertTrue(grid.isNeedsLayout());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void gridPaneRejectsANegativeIndex() {
+        GridPane.setRowIndex(box(1, 1), Integer.valueOf(-1));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void gridPaneRejectsAnEmptySpan() {
+        GridPane.setColumnSpan(box(1, 1), Integer.valueOf(0));
+    }
+
+    @Test
+    public void gridPaneTakesStyleValuesAndRestoresThem() {
+        GridPane grid = new GridPane();
+        assertTrue(grid.cn1ApplyStyle("-fx-hgap", Integer.valueOf(4)));
+        assertTrue(grid.cn1ApplyStyle("-fx-vgap", Double.valueOf(6)));
+        assertTrue(grid.cn1ApplyStyle("-fx-alignment", "BASELINE-CENTER"));
+        assertEquals(4, grid.getHgap(), 0);
+        assertEquals(6, grid.getVgap(), 0);
+        assertSame(Pos.BASELINE_CENTER, grid.getAlignment());
+        assertFalse(grid.cn1ApplyStyle("-fx-orientation", "vertical"));
+        assertTrue(grid.cn1ApplyStyle("-fx-hgap", null));
+        assertTrue(grid.cn1ApplyStyle("-fx-vgap", null));
+        assertTrue(grid.cn1ApplyStyle("-fx-alignment", null));
+        assertEquals(0, grid.getHgap(), 0);
+        assertEquals(0, grid.getVgap(), 0);
+        assertSame(Pos.TOP_LEFT, grid.getAlignment());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/NarrowScreenTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/NarrowScreenTest.java
new file mode 100644
index 00000000000..6b2df702ea1
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/NarrowScreenTest.java
@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.StageForm;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Container;
+import com.codename1.ui.Display;
+
+import javafx.application.Platform;
+import javafx.scene.Group;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.layout.Pane;
+import javafx.scene.shape.Rectangle;
+import javafx.stage.Stage;
+
+/// A scene on a screen it was not written for. JavaFX clips what does
+/// not fit its window; a phone's window is the screen, so a scene that
+/// cannot be laid out that small is laid out at the least it can be and
+/// the stage scrolls along the axis that overflows.
+public class NarrowScreenTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicit;
+    private Stage stage;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+        implicit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+    }
+
+    @After
+    public void tearDown() {
+        if (stage != null && stage.isShowing()) {
+            stage.hide();
+        }
+        Platform.setImplicitExit(implicit);
+        Units.setScale(0);
+    }
+
+    private Container shown(Parent root) {
+        stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setScene(new Scene(root));
+        stage.show();
+        StageForm form = (StageForm) stage.cn1Host();
+        form.revalidate();
+        return form.getContentPane();
+    }
+
+    @Test
+    public void aSceneThatFitsIsTheSizeOfTheFormAndDoesNotScroll() {
+        Pane root = new Pane();
+        root.setMinSize(100, 100);
+        Container content = shown(root);
+        assertTrue(content.getWidth() > 100);
+        assertEquals(content.getWidth(), root.getWidth(), 0.01);
+        assertEquals(content.getHeight(), root.getHeight(), 0.01);
+        assertFalse(content.isScrollableX());
+        assertFalse(content.isScrollableY());
+        // A point of a node on the screen is its point in the scene moved
+        // by where the window is; a node in no window has none.
+        Pane child = new Pane();
+        child.relocate(30, 40);
+        root.getChildren().add(child);
+        javafx.geometry.Point2D scene = child.localToScene(1, 2);
+        javafx.geometry.Point2D screen = child.localToScreen(1, 2);
+        assertEquals(scene.getX() + stage.getX() + root.getScene().getX(), screen.getX(), 0.01);
+        assertEquals(scene.getY() + stage.getY() + root.getScene().getY(), screen.getY(), 0.01);
+        javafx.geometry.Point2D back = child.screenToLocal(screen);
+        assertEquals(1, back.getX(), 0.01);
+        assertEquals(2, back.getY(), 0.01);
+        assertEquals(null, new Pane().localToScreen(0, 0));
+    }
+
+    @Test
+    public void aRootWiderThanTheFormAtItsLeastIsLaidOutThatWideAndScrolls() {
+        Pane root = new Pane();
+        int wide = Display.getInstance().getDisplayWidth() + 500;
+        root.setMinSize(wide, 100);
+        Container content = shown(root);
+        assertEquals(wide, root.getWidth(), 0.01);
+        assertEquals(wide, root.getScene().getWidth(), 0.01);
+        // Only the axis that overflows scrolls; the other is the form's.
+        assertEquals(content.getHeight(), root.getHeight(), 0.01);
+        assertTrue(content.isScrollableX());
+        assertFalse(content.isScrollableY());
+        assertEquals(wide, content.getScrollDimension().getWidth());
+        // The window is still what is on screen.
+        assertEquals(content.getWidth(), stage.getWidth(), 0.01);
+
+        // The scene follows a pan: what is under a point of the screen is
+        // what was scrolled there.
+        content.scrollRectToVisible(300, 0, content.getWidth(), 10, content);
+        assertEquals(300, content.getScrollX());
+        assertEquals(-300, root.cn1Peer().getAbsoluteX() - (content.getAbsoluteX() + content.getScrollX()));
+
+        // Made able to fit again, it fits and is back where it started.
+        root.setMinSize(100, 100);
+        content.getComponentForm().revalidate();
+        assertFalse(content.isScrollableX());
+        assertEquals(0, content.getScrollX());
+        assertEquals(content.getWidth(), root.getWidth(), 0.01);
+    }
+
+    @Test
+    public void aGroupLargerThanTheFormScrollsOverAllOfIt() {
+        int w = Display.getInstance().getDisplayWidth();
+        int h = Display.getInstance().getDisplayHeight();
+        Group root = new Group(new Rectangle(0, 0, w + 200, h + 300));
+        Container content = shown(root);
+        assertTrue(content.isScrollableX());
+        assertTrue(content.isScrollableY());
+        assertEquals(w + 200, content.getScrollDimension().getWidth());
+        assertEquals(h + 300, content.getScrollDimension().getHeight());
+    }
+
+    /// The display hands a form every pointer event as arrays of
+    /// coordinates, one element for one finger. A press and a release get
+    /// to the plain overloads from there and a drag does not, so a scene
+    /// that heard of drags only through the plain overload heard of none
+    /// on a device: no swipe, no slider, no divider.
+    @Test
+    public void aDragDeliveredAsTheDisplayDeliversItReachesTheScene() {
+        Pane root = new Pane();
+        root.setMinSize(100, 100);
+        final java.util.List<String> seen = new java.util.ArrayList<String>();
+        javafx.event.EventHandler<javafx.scene.input.MouseEvent> log =
+                new javafx.event.EventHandler<javafx.scene.input.MouseEvent>() {
+            @Override
+            public void handle(javafx.scene.input.MouseEvent event) {
+                seen.add(event.getEventType().getName() + "@" + Math.round(event.getX()));
+            }
+        };
+        root.setOnMousePressed(log);
+        root.setOnMouseDragged(log);
+        root.setOnMouseReleased(log);
+        Container content = shown(root);
+        com.codename1.ui.Form form = (com.codename1.ui.Form) stage.cn1Host();
+        int x = content.getAbsoluteX() + 20;
+        int y = content.getAbsoluteY() + 20;
+        form.pointerPressed(new int[] {x}, new int[] {y});
+        form.pointerDragged(new int[] {x + 30}, new int[] {y});
+        form.pointerReleased(new int[] {x + 30}, new int[] {y});
+        assertEquals("[MOUSE_PRESSED@20, MOUSE_DRAGGED@50, MOUSE_RELEASED@50]", seen.toString());
+        // Two fingers are a gesture of Codename One's, not a drag of the scene's.
+        seen.clear();
+        form.pointerDragged(new int[] {x, x + 40}, new int[] {y, y});
+        assertEquals("[]", seen.toString());
+    }
+
+    /// A pane that holds a group has the size of the group for its
+    /// minimum, whatever the application does with the group. One that
+    /// scales the group to the pane -- a game board that follows its
+    /// window -- fits any pane, and was laid out at the full size of the
+    /// board all the same: larger than the screen, scrolling, with every
+    /// swipe moving the page and none reaching the game.
+    @Test
+    public void aRootThatScalesWhatItHoldsToFitIsNotMadeToScroll() {
+        final int wide = Display.getInstance().getDisplayWidth() * 2;
+        final int tall = Display.getInstance().getDisplayHeight() * 2;
+        final javafx.scene.Group board = new javafx.scene.Group(new javafx.scene.shape.Rectangle(wide, tall));
+        final javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane(board);
+        javafx.beans.value.ChangeListener<Number> fit = new javafx.beans.value.ChangeListener<Number>() {
+            @Override
+            public void changed(javafx.beans.value.ObservableValue<? extends Number> o, Number before, Number now) {
+                double scale = Math.min(root.getWidth() / wide, root.getHeight() / tall);
+                board.setScaleX(scale);
+                board.setScaleY(scale);
+            }
+        };
+        root.widthProperty().addListener(fit);
+        root.heightProperty().addListener(fit);
+        assertTrue(root.minWidth(-1) >= wide);
+        Container content = shown(root);
+        assertFalse(content.isScrollableX());
+        assertFalse(content.isScrollableY());
+        assertEquals(content.getWidth(), root.getWidth(), 0.01);
+        assertEquals(content.getHeight(), root.getHeight(), 0.01);
+
+        // The same board left at its size does not fit, and scrolls.
+        javafx.scene.layout.StackPane plain = new javafx.scene.layout.StackPane(
+                new javafx.scene.Group(new javafx.scene.shape.Rectangle(wide, 10)));
+        stage.hide();
+        Container other = shown(plain);
+        assertTrue(other.isScrollableX());
+        assertFalse(other.isScrollableY());
+        assertEquals(wide, plain.getWidth(), 1);
+    }
+
+    /// A flow of tiles is as tall as its width makes it. Asked how tall it
+    /// has to be with no width named, it answers for the width it would
+    /// like -- one row -- and a scene judged by that fits any screen. In
+    /// the screen's width the tiles are many rows, taller than the pane,
+    /// and the pane that centres them put the first rows above its top
+    /// and the last below its bottom, neither in reach. The minimum is
+    /// asked for the width the scene gets, and the pane scrolls.
+    @Test
+    public void aFlowTallerThanTheFormInItsWidthStartsAtTheTopAndScrolls() {
+        int w = Display.getInstance().getDisplayWidth();
+        int h = Display.getInstance().getDisplayHeight();
+        javafx.scene.layout.FlowPane flow = new javafx.scene.layout.FlowPane();
+        // One row at the width it would like.
+        flow.setPrefWrapLength(100000);
+        int tile = w / 3;
+        int tiles = 3 * (h / tile + 2);
+        for (int i = 0; i < tiles; i++) {
+            flow.getChildren().add(new Rectangle(tile - 1, tile));
+        }
+        javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane(flow);
+        assertTrue(root.minHeight(-1) < h);
+        Container content = shown(root);
+        assertTrue("taller than the form in its width", root.minHeight(content.getWidth()) > content.getHeight());
+        assertFalse(content.isScrollableX());
+        assertTrue(content.isScrollableY());
+        assertEquals(content.getWidth(), root.getWidth(), 0.01);
+        assertEquals(root.minHeight(content.getWidth()), root.getHeight(), 1);
+        assertEquals("the first row is at the top", 0, flow.getBoundsInParent().getMinY(), 0.01);
+        assertTrue(content.getScrollDimension().getHeight() > content.getHeight());
+    }
+
+    /// A form whose fields ask for more columns than the screen has: the
+    /// field, told to take whatever room there is, is what gives way, and
+    /// the label before it keeps every letter. The field had its preferred
+    /// width for a minimum, so the label lost all that was missing and
+    /// read "P..." beside a field with room to spare.
+    @Test
+    public void aLabelKeepsItsTextBesideAFieldWiderThanTheScreen() {
+        javafx.scene.layout.GridPane grid = new javafx.scene.layout.GridPane();
+        grid.setHgap(8);
+        javafx.scene.control.Label label = new javafx.scene.control.Label("Password:");
+        javafx.scene.control.TextField field = new javafx.scene.control.TextField("secret");
+        field.setPrefColumnCount(200);
+        grid.add(label, 0, 0);
+        grid.add(field, 1, 0);
+        javafx.scene.layout.GridPane.setHgrow(field, javafx.scene.layout.Priority.ALWAYS);
+        javafx.scene.control.Label boxed = new javafx.scene.control.Label("Planet:");
+        javafx.scene.control.TextField inBox = new javafx.scene.control.TextField("Earth");
+        inBox.setPrefColumnCount(200);
+        javafx.scene.layout.HBox.setHgrow(inBox, javafx.scene.layout.Priority.ALWAYS);
+        // And a field nothing told to grow: it has no one right width
+        // either, where the label beside it has exactly one.
+        javafx.scene.layout.GridPane plain = new javafx.scene.layout.GridPane();
+        javafx.scene.control.Label owner = new javafx.scene.control.Label("Owner:");
+        javafx.scene.control.TextField named = new javafx.scene.control.TextField("Ada");
+        named.setPrefColumnCount(200);
+        plain.add(owner, 0, 0);
+        plain.add(named, 1, 0);
+        javafx.scene.layout.VBox root = new javafx.scene.layout.VBox(grid, new javafx.scene.layout.HBox(8, boxed, inBox),
+                plain);
+        Container content = shown(root);
+        assertTrue("wider than the screen", field.prefWidth(-1) > content.getWidth());
+        assertFalse(content.isScrollableX());
+        assertEquals(label.prefWidth(-1), label.getWidth(), 0.5);
+        assertEquals(boxed.prefWidth(-1), boxed.getWidth(), 0.5);
+        assertEquals(owner.prefWidth(-1), owner.getWidth(), 0.5);
+        assertEquals(content.getWidth(), named.getBoundsInParent().getMaxX(), 1);
+        assertEquals(content.getWidth(), field.getBoundsInParent().getMaxX(), 1);
+        assertEquals(content.getWidth(), inBox.getBoundsInParent().getMaxX(), 1);
+    }
+
+    /// Three buttons under a theme that puts a wide margin beside the text
+    /// of a button, as the themes of phones do: together wider than the
+    /// screen, though their words would fit it twice. Each gives up
+    /// padding, and no letter.
+    @Test
+    public void buttonsTooWideForTheScreenGiveUpPaddingBeforeLetters() {
+        java.util.Hashtable<String, Object> theme = new java.util.Hashtable<String, Object>();
+        theme.put("Button.padding", "10,10,160,160");
+        theme.put("Button.padUnit", new byte[] {0, 0, 0, 0});
+        com.codename1.ui.plaf.UIManager.getInstance().addThemeProps(theme);
+        try {
+            javafx.scene.control.Button[] buttons = {new javafx.scene.control.Button("Disabled"),
+                new javafx.scene.control.Button("Cancel"), new javafx.scene.control.Button("OK")};
+            javafx.scene.layout.HBox row = new javafx.scene.layout.HBox(8, buttons);
+            Container content = shown(new javafx.scene.layout.VBox(row));
+            double asked = row.prefWidth(-1);
+            assertTrue("wider than the screen: " + asked, asked > content.getWidth());
+            assertFalse(content.isScrollableX());
+            for (int i = 0; i < buttons.length; i++) {
+                com.codename1.ui.Label n = (com.codename1.ui.Label) buttons[i].cn1Native();
+                com.codename1.ui.plaf.Style s = n.getUnselectedStyle();
+                int room = n.getWidth() - s.getHorizontalPadding();
+                assertTrue(n.getText() + " has " + room + " for its text",
+                        room >= s.getFont().stringWidth(n.getText()));
+                // Shares of the missing width are whole pixels; what is
+                // left of it after the last share is under one each.
+                assertTrue("inside the screen: " + buttons[i].getBoundsInParent(),
+                        buttons[i].getBoundsInParent().getMaxX() <= content.getWidth() + buttons.length);
+            }
+            // What they ask for is what they asked before giving anything up.
+            content.getComponentForm().revalidate();
+            assertEquals(asked, row.prefWidth(-1), 0.5);
+        } finally {
+            // The theme is the display's, and the classes after this one
+            // draw their controls with it.
+            com.codename1.ui.plaf.UIManager.getInstance().setThemeProps(
+                    new java.util.Hashtable<String, Object>());
+        }
+    }
+
+    /// To learn whether a scene has to scroll it is laid out in the pane
+    /// first, and then at its minimum. Done on every pass, that moved
+    /// every node twice each time, each move asked for another pass, and
+    /// a scene wider than the screen was laid out and painted for as long
+    /// as it was shown. A pass with nothing changed leaves the scene be.
+    @Test
+    public void aSceneThatScrollsIsNotLaidOutAgainByEveryPass() {
+        final int wide = Display.getInstance().getDisplayWidth() * 2;
+        final javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane(
+                new javafx.scene.Group(new javafx.scene.shape.Rectangle(wide, 10)));
+        Container content = shown(root);
+        assertTrue(content.isScrollableX());
+        assertEquals(wide, root.getWidth(), 1);
+        final int[] changes = new int[1];
+        root.widthProperty().addListener(new javafx.beans.value.ChangeListener<Number>() {
+            @Override
+            public void changed(javafx.beans.value.ObservableValue<? extends Number> o, Number before, Number now) {
+                changes[0]++;
+            }
+        });
+        for (int i = 0; i < 3; i++) {
+            content.setShouldCalcPreferredSize(true);
+            content.getComponentForm().revalidate();
+        }
+        assertEquals(0, changes[0]);
+        assertTrue(content.isScrollableX());
+        assertEquals(wide, root.getWidth(), 1);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/NativeChromeTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/NativeChromeTest.java
new file mode 100644
index 00000000000..4dbd5985ea0
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/NativeChromeTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.plaf.Style;
+
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.ListCell;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Color;
+
+/// What the native component of a control keeps of the theme: nothing
+/// behind the text of a label, nothing behind a button that has a
+/// background of its own, and a text colour a cell can be read in.
+public class NativeChromeTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+    }
+
+    private static Background fill(Color color) {
+        return new Background(new BackgroundFill(color, CornerRadii.EMPTY, Insets.EMPTY));
+    }
+
+    @Test
+    public void aLabelHasNoBackgroundOfTheTheme() {
+        Label label = new Label("text");
+        Component c = label.cn1Native();
+        // Whatever the theme says of a Label, the opaque style is undone.
+        c.getAllStyles().setBgTransparency(255);
+        label.setText("other");
+        assertEquals(0, c.getUnselectedStyle().getBgTransparency() & 0xff);
+        assertTrue(c.getUnselectedStyle().getBorder().isEmptyBorder());
+    }
+
+    @Test
+    public void aButtonWithItsOwnBackgroundDropsTheOneOfTheTheme() {
+        Button button = new Button("go");
+        Component c = button.cn1Native();
+        Style theme = c.getUnselectedStyle();
+        theme.setBgTransparency(255);
+        button.setText("still themed");
+        assertEquals(255, c.getUnselectedStyle().getBgTransparency() & 0xff);
+
+        button.setBackground(fill(Color.RED));
+        assertEquals(0, c.getUnselectedStyle().getBgTransparency() & 0xff);
+        assertEquals(0, c.getPressedStyle().getBgTransparency() & 0xff);
+        assertTrue(c.getUnselectedStyle().getBorder().isEmptyBorder());
+
+        // Without it the styles are those of the theme again, not the
+        // ones this test or the layer wrote.
+        button.setBackground(null);
+        assertFalse(c.getUnselectedStyle() == theme);
+        assertEquals("still themed", ((com.codename1.ui.Button) c).getText());
+    }
+
+    @Test
+    public void aCellIsReadableOnADarkBackground() {
+        Pane pane = new Pane();
+        ListCell<String> cell = new ListCell<String>();
+        pane.getChildren().add(cell);
+        Component c = cell.cn1Native();
+        int theme = c.getUnselectedStyle().getFgColor() & 0xffffff;
+
+        pane.setBackground(fill(Color.web("#1d1d1d")));
+        cell.setText("dark");
+        assertEquals(0xffffff, c.getUnselectedStyle().getFgColor() & 0xffffff);
+
+        pane.setBackground(fill(Color.web("#f4f4f4")));
+        cell.setText("light");
+        assertEquals(theme, c.getUnselectedStyle().getFgColor() & 0xffffff);
+
+        // A translucent wash does not count; the dark one behind it does.
+        Pane outer = new Pane();
+        outer.setBackground(fill(Color.BLACK));
+        outer.getChildren().add(pane);
+        pane.setBackground(fill(Color.color(1, 1, 1, 0.1)));
+        cell.setText("washed");
+        assertEquals(0xffffff, c.getUnselectedStyle().getFgColor() & 0xffffff);
+
+        // A text fill of the application's own is left alone.
+        cell.setTextFill(Color.RED);
+        assertEquals(0xff0000, c.getUnselectedStyle().getFgColor() & 0xffffff);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ObservableListTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ObservableListTest.java
new file mode 100644
index 00000000000..c38d69ada6b
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ObservableListTest.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Random;
+
+import org.junit.Test;
+
+import javafx.beans.Observable;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ModifiableObservableListBase;
+import javafx.collections.ObservableList;
+import javafx.collections.WeakListChangeListener;
+import javafx.util.Callback;
+
+public class ObservableListTest {
+
+    private ObservableList<String> list;
+    private Probe.ListChanges<String> probe;
+
+    private void start(String... items) {
+        list = FXCollections.observableArrayList(items);
+        probe = new Probe.ListChanges<String>();
+        list.addListener(probe);
+    }
+
+    @Test
+    public void addReportsTheAddedRange() {
+        start();
+        assertTrue(list.add("a"));
+        assertEquals("[add[0,1] +[a]]", probe.take());
+        list.add(0, "b");
+        assertEquals("[add[0,1] +[b]]", probe.take());
+        list.addAll("c", "d");
+        assertEquals("[add[2,4] +[c, d]]", probe.take());
+        list.addAll(1, Arrays.asList("x", "y"));
+        assertEquals("[add[1,3] +[x, y]]", probe.take());
+        assertEquals("[b, x, y, a, c, d]", list.toString());
+        assertEquals(4, probe.events);
+        assertFalse(list.addAll(new ArrayList<String>()));
+        assertEquals("an empty addition is not reported", 4, probe.events);
+    }
+
+    @Test
+    public void removeReportsTheRemovedElements() {
+        start("a", "b", "c", "d");
+        assertEquals("b", list.remove(1));
+        assertEquals("[rem[1] -[b]]", probe.take());
+        assertTrue(list.remove("d"));
+        assertEquals("[rem[2] -[d]]", probe.take());
+        assertFalse(list.remove("missing"));
+        assertEquals("[]", probe.take());
+        list.clear();
+        assertEquals("[rem[0] -[a, c]]", probe.take());
+        list.clear();
+        assertEquals(3, probe.events);
+    }
+
+    @Test
+    public void removeRange() {
+        start("a", "b", "c", "d", "e");
+        list.remove(1, 3);
+        assertEquals("[rem[1] -[b, c]]", probe.take());
+        assertEquals("[a, d, e]", list.toString());
+        list.remove(1, 1);
+        assertEquals("[]", probe.take());
+    }
+
+    @Test
+    public void setReportsAReplacement() {
+        start("a", "b", "c");
+        assertEquals("b", list.set(1, "B"));
+        assertEquals("[rep[1,2] -[b] +[B]]", probe.take());
+    }
+
+    @Test
+    public void setAllReplacesEverything() {
+        start("a", "b");
+        list.setAll("x", "y", "z");
+        assertEquals("[rep[0,3] -[a, b] +[x, y, z]]", probe.take());
+        list.setAll(Arrays.asList("q"));
+        assertEquals("[rep[0,1] -[x, y, z] +[q]]", probe.take());
+        list.setAll(new ArrayList<String>());
+        assertEquals("[rem[0] -[q]]", probe.take());
+        list.setAll("n");
+        assertEquals("[add[0,1] +[n]]", probe.take());
+    }
+
+    @Test
+    public void removeAllReportsEveryRunInOneEvent() {
+        start("a", "b", "c", "d", "e");
+        assertTrue(list.removeAll("a", "c", "d"));
+        assertEquals(1, probe.events);
+        assertEquals("[rem[0] -[a], rem[1] -[c, d]]", probe.take());
+        assertEquals("[b, e]", list.toString());
+        assertFalse(list.removeAll(Arrays.asList("zz")));
+        assertEquals(1, probe.events);
+    }
+
+    @Test
+    public void retainAllReportsEveryRunInOneEvent() {
+        start("a", "b", "c", "d", "e");
+        assertTrue(list.retainAll("b", "e"));
+        assertEquals(1, probe.events);
+        assertEquals("[rem[0] -[a], rem[1] -[c, d]]", probe.take());
+        assertEquals("[b, e]", list.toString());
+        assertFalse(list.retainAll(Arrays.asList("b", "e")));
+        assertEquals(1, probe.events);
+    }
+
+    @Test
+    public void removeIfReportsEachRemoval() {
+        start("a", "bb", "c", "dd");
+        assertTrue(list.removeIf(s -> s.length() == 2));
+        assertEquals("removeIf goes through the iterator, as in JavaFX", 2, probe.events);
+        assertEquals("[rem[1] -[bb], rem[2] -[dd]]", probe.take());
+    }
+
+    @Test
+    public void sortReportsAPermutation() {
+        start("c", "a", "b");
+        FXCollections.sort(list);
+        assertEquals("[a, b, c]", list.toString());
+        assertEquals("entry i is where the element at i went", "[perm[0,3]{2,0,1}]", probe.take());
+        list.sort(Comparator.<String>reverseOrder());
+        assertEquals("[c, b, a]", list.toString());
+        assertEquals("[perm[0,3]{2,1,0}]", probe.take());
+        FXCollections.sort(list, Comparator.<String>reverseOrder());
+        assertEquals("an already sorted list reports nothing", "[]", probe.take());
+    }
+
+    @Test
+    public void reverseShuffleRotateFillReplace() {
+        start("a", "b", "c");
+        FXCollections.reverse(list);
+        assertEquals("[c, b, a]", list.toString());
+        assertEquals(1, probe.events);
+        FXCollections.rotate(list, 1);
+        assertEquals("[a, c, b]", list.toString());
+        FXCollections.shuffle(list, new Random(42));
+        List<String> sorted = new ArrayList<String>(list);
+        Collections.sort(sorted);
+        assertEquals("[a, b, c]", sorted.toString());
+        assertTrue(FXCollections.replaceAll(list, "a", "A"));
+        assertTrue(list.contains("A"));
+        assertFalse(FXCollections.replaceAll(list, "nothing", "N"));
+        FXCollections.fill(list, "z");
+        assertEquals("[z, z, z]", list.toString());
+        FXCollections.copy(list, Arrays.asList("1", "2"));
+        assertEquals("[1, 2, z]", list.toString());
+        assertTrue(probe.events >= 5);
+    }
+
+    @Test
+    public void subListEditsAreReportedOnTheList() {
+        start("a", "b", "c", "d");
+        List<String> middle = list.subList(1, 3);
+        assertEquals("[b, c]", middle.toString());
+        middle.clear();
+        assertEquals("[a, d]", list.toString());
+        assertEquals("[rem[1] -[b, c]]", probe.take());
+        List<String> tail = list.subList(1, 2);
+        tail.add("e");
+        assertEquals("[a, d, e]", list.toString());
+        assertEquals("[add[2,3] +[e]]", probe.take());
+        tail.set(0, "D");
+        assertEquals("[rep[1,2] -[d] +[D]]", probe.take());
+        tail.remove("e");
+        assertEquals("[rem[2] -[e]]", probe.take());
+    }
+
+    @Test
+    public void iteratorEditsAreReported() {
+        start("a", "b", "c");
+        Iterator<String> it = list.iterator();
+        it.next();
+        it.remove();
+        assertEquals("[rem[0] -[a]]", probe.take());
+        ListIterator<String> li = list.listIterator();
+        li.next();
+        li.set("B");
+        assertEquals("[rep[0,1] -[b] +[B]]", probe.take());
+        li.add("x");
+        assertEquals("[add[1,2] +[x]]", probe.take());
+        assertEquals("[B, x, c]", list.toString());
+    }
+
+    @Test
+    public void changeAccessorsFollowTheProtocol() {
+        list = FXCollections.observableArrayList("a", "b", "c");
+        final int[] checked = new int[1];
+        list.addListener(new ListChangeListener<String>() {
+            @Override
+            public void onChanged(Change<? extends String> c) {
+                assertSame(list, c.getList());
+                try {
+                    c.getFrom();
+                    fail("reading before next() must fail");
+                } catch (IllegalStateException expected) {
+                    checked[0]++;
+                }
+                assertTrue(c.next());
+                assertTrue(c.wasReplaced());
+                assertTrue(c.wasAdded());
+                assertTrue(c.wasRemoved());
+                assertFalse(c.wasPermutated());
+                assertFalse(c.wasUpdated());
+                assertEquals(1, c.getFrom());
+                assertEquals(2, c.getTo());
+                assertEquals(1, c.getAddedSize());
+                assertEquals(1, c.getRemovedSize());
+                assertEquals("[B]", c.getAddedSubList().toString());
+                assertEquals("[b]", c.getRemoved().toString());
+                assertFalse(c.next());
+                c.reset();
+                assertTrue(c.next());
+                assertEquals(1, c.getFrom());
+                checked[0]++;
+            }
+        });
+        list.set(1, "B");
+        assertEquals(2, checked[0]);
+    }
+
+    @Test
+    public void everyListenerSeesTheWholeChange() {
+        start("a");
+        Probe.ListChanges<String> second = new Probe.ListChanges<String>();
+        list.addListener(second);
+        list.addAll("b", "c");
+        assertEquals("[add[1,3] +[b, c]]", probe.take());
+        assertEquals("[add[1,3] +[b, c]]", second.take());
+        list.removeListener(second);
+        list.add("d");
+        assertEquals(1, second.events);
+    }
+
+    @Test
+    public void invalidationListenerIsToldOfEveryChange() {
+        start("a");
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        list.addListener(invalidations);
+        list.add("b");
+        list.add("c");
+        assertEquals("a list has no value to read, so it is never lazy", 2, invalidations.count);
+        assertSame(list, invalidations.last);
+        list.removeListener(invalidations);
+        list.add("d");
+        assertEquals(2, invalidations.count);
+    }
+
+    @Test
+    public void extractorReportsUpdates() {
+        ObservableList<IntegerProperty> items = FXCollections
+                .observableArrayList(new Callback<IntegerProperty, Observable[]>() {
+                    @Override
+                    public Observable[] call(IntegerProperty item) {
+                        return new Observable[] {item};
+                    }
+                });
+        IntegerProperty first = new SimpleIntegerProperty(1);
+        IntegerProperty second = new SimpleIntegerProperty(2);
+        items.add(first);
+        items.add(second);
+        Probe.ListChanges<IntegerProperty> updates = new Probe.ListChanges<IntegerProperty>();
+        items.addListener(updates);
+        second.set(20);
+        assertEquals("[upd[1,2]]", updates.take());
+        first.set(10);
+        assertEquals("[upd[0,1]]", updates.take());
+        items.remove(first);
+        updates.take();
+        first.get();
+        first.set(11);
+        assertEquals("a removed element is no longer watched", "[]", updates.take());
+        second.get();
+        second.set(21);
+        assertEquals("[upd[0,1]]", updates.take());
+    }
+
+    @Test
+    public void observableListWrapsTheBackingList() {
+        List<String> backing = new ArrayList<String>();
+        backing.add("a");
+        ObservableList<String> wrapped = FXCollections.observableList(backing);
+        wrapped.add("b");
+        assertEquals("[a, b]", backing.toString());
+        assertEquals(2, wrapped.size());
+        ObservableList<String> copy = FXCollections.observableArrayList(backing);
+        copy.add("c");
+        assertEquals("a copy does not write through", 2, backing.size());
+    }
+
+    @Test
+    public void unmodifiableViewForwardsChangesAndRejectsEdits() {
+        start("a");
+        ObservableList<String> view = FXCollections.unmodifiableObservableList(list);
+        Probe.ListChanges<String> viewProbe = new Probe.ListChanges<String>();
+        view.addListener(viewProbe);
+        list.add("b");
+        assertEquals("[add[1,2] +[b]]", viewProbe.take());
+        assertEquals("[a, b]", view.toString());
+        try {
+            view.add("c");
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals(2, view.size());
+        }
+        try {
+            view.remove(0);
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals(2, list.size());
+        }
+    }
+
+    @Test
+    public void emptyAndSingletonLists() {
+        ObservableList<String> empty = FXCollections.emptyObservableList();
+        assertEquals(0, empty.size());
+        try {
+            empty.add("a");
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertTrue(empty.isEmpty());
+        }
+        ObservableList<String> one = FXCollections.singletonObservableList("x");
+        assertEquals(1, one.size());
+        assertEquals("x", one.get(0));
+        try {
+            one.set(0, "y");
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals("x", one.get(0));
+        }
+        ObservableList<String> joined = FXCollections.concat(one, FXCollections.observableArrayList("y", "z"));
+        assertEquals("[x, y, z]", joined.toString());
+    }
+
+    @Test
+    public void weakListChangeListenerForwards() {
+        start();
+        Probe.ListChanges<String> target = new Probe.ListChanges<String>();
+        WeakListChangeListener<String> weak = new WeakListChangeListener<String>(target);
+        list.addListener(weak);
+        list.add("a");
+        assertEquals("[add[0,1] +[a]]", target.take());
+        assertFalse(weak.wasGarbageCollected());
+    }
+
+    @Test
+    public void modifiableBaseDerivesEverythingFromFourMethods() {
+        final List<String> store = new ArrayList<String>();
+        ObservableList<String> custom = new ModifiableObservableListBase<String>() {
+            @Override
+            public String get(int index) {
+                return store.get(index);
+            }
+
+            @Override
+            public int size() {
+                return store.size();
+            }
+
+            @Override
+            protected void doAdd(int index, String element) {
+                store.add(index, element);
+            }
+
+            @Override
+            protected String doSet(int index, String element) {
+                return store.set(index, element);
+            }
+
+            @Override
+            protected String doRemove(int index) {
+                return store.remove(index);
+            }
+        };
+        Probe.ListChanges<String> changes = new Probe.ListChanges<String>();
+        custom.addListener(changes);
+        custom.addAll("a", "b", "c");
+        assertEquals("[add[0,3] +[a, b, c]]", changes.take());
+        custom.set(0, "A");
+        assertEquals("[rep[0,1] -[a] +[A]]", changes.take());
+        custom.remove("b");
+        assertEquals("[rem[1] -[b]]", changes.take());
+        custom.setAll("x");
+        assertEquals("[rep[0,1] -[A, c] +[x]]", changes.take());
+        custom.retainAll("none");
+        assertEquals("[rem[0] -[x]]", changes.take());
+        assertEquals("[]", store.toString());
+    }
+
+    @Test
+    public void listPropertyTracksItsList() {
+        javafx.beans.property.ListProperty<String> property = new javafx.beans.property.SimpleListProperty<String>(
+                this, "items", FXCollections.<String>observableArrayList("a"));
+        Probe.ListChanges<String> content = new Probe.ListChanges<String>();
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        property.addListener(content);
+        property.addListener(invalidations);
+        assertEquals(1, property.getSize());
+        assertEquals("items", property.getName());
+        javafx.beans.property.ReadOnlyIntegerProperty size = property.sizeProperty();
+        javafx.beans.property.ReadOnlyBooleanProperty empty = property.emptyProperty();
+        Probe.Values<Number> sizes = new Probe.Values<Number>();
+        size.addListener(sizes);
+        property.add("b");
+        assertEquals("[add[1,2] +[b]]", content.take());
+        assertEquals(1, invalidations.count);
+        assertEquals("[1->2]", sizes.log.toString());
+        assertFalse(empty.get());
+        ObservableList<String> other = FXCollections.observableArrayList("x", "y", "z");
+        property.set(other);
+        assertEquals("[rep[0,3] -[a, b] +[x, y, z]]", content.take());
+        assertSame(other, property.get());
+        assertEquals(3, size.get());
+        other.remove("y");
+        assertEquals("[rem[1] -[y]]", content.take());
+        assertEquals("[x, z]", property.toString().substring(property.toString().indexOf("value: ") + 7,
+                property.toString().length() - 1));
+        assertTrue(property.isEqualTo(FXCollections.observableArrayList("x", "z")).get());
+        assertEquals("z", property.valueAt(1).get());
+        property.set(null);
+        assertEquals("[rem[0] -[x, z]]", content.take());
+        assertTrue(empty.get());
+        assertEquals(0, property.size());
+        assertTrue(property.isNull().get());
+        javafx.beans.property.ListProperty<String> bound = new javafx.beans.property.SimpleListProperty<String>();
+        bound.bind(property);
+        property.set(other);
+        assertSame(other, bound.get());
+        try {
+            bound.set(null);
+            fail("expected a RuntimeException");
+        } catch (RuntimeException expected) {
+            assertTrue(expected.getMessage().endsWith("A bound value cannot be set."));
+        }
+        bound.unbind();
+        bound.set(null);
+        assertEquals(0, bound.size());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ObservableMapSetTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ObservableMapSetTest.java
new file mode 100644
index 00000000000..07547e99834
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ObservableMapSetTest.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+import javafx.collections.FXCollections;
+import javafx.collections.MapChangeListener;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+import javafx.collections.SetChangeListener;
+
+public class ObservableMapSetTest {
+
+    private final List<String> log = new ArrayList<String>();
+
+    private final MapChangeListener<String, Integer> mapProbe = new MapChangeListener<String, Integer>() {
+        @Override
+        public void onChanged(Change<? extends String, ? extends Integer> c) {
+            log.add(c.getKey() + (c.wasRemoved() ? " -" + c.getValueRemoved() : "")
+                    + (c.wasAdded() ? " +" + c.getValueAdded() : ""));
+        }
+    };
+
+    private final SetChangeListener<String> setProbe = new SetChangeListener<String>() {
+        @Override
+        public void onChanged(Change<? extends String> c) {
+            log.add(c.wasAdded() ? "+" + c.getElementAdded() : "-" + c.getElementRemoved());
+        }
+    };
+
+    private String take() {
+        String result = log.toString();
+        log.clear();
+        return result;
+    }
+
+    @Test
+    public void mapReportsPutReplaceAndRemove() {
+        ObservableMap<String, Integer> map = FXCollections.observableMap(new LinkedHashMap<String, Integer>());
+        map.addListener(mapProbe);
+        assertNull(map.put("a", Integer.valueOf(1)));
+        assertEquals("[a +1]", take());
+        assertEquals(Integer.valueOf(1), map.put("a", Integer.valueOf(2)));
+        assertEquals("[a -1 +2]", take());
+        map.put("a", Integer.valueOf(2));
+        assertEquals("putting an equal value reports nothing", "[]", take());
+        assertEquals(Integer.valueOf(2), map.remove("a"));
+        assertEquals("[a -2]", take());
+        assertNull(map.remove("a"));
+        assertEquals("[]", take());
+        Map<String, Integer> more = new LinkedHashMap<String, Integer>();
+        more.put("x", Integer.valueOf(1));
+        more.put("y", Integer.valueOf(2));
+        map.putAll(more);
+        assertEquals("[x +1, y +2]", take());
+        map.clear();
+        assertEquals("[x -1, y -2]", take());
+        assertTrue(map.isEmpty());
+    }
+
+    @Test
+    public void mapViewsReportRemovals() {
+        ObservableMap<String, Integer> map = FXCollections.observableMap(new LinkedHashMap<String, Integer>());
+        map.put("a", Integer.valueOf(1));
+        map.put("b", Integer.valueOf(2));
+        map.put("c", Integer.valueOf(3));
+        map.addListener(mapProbe);
+        assertTrue(map.keySet().remove("a"));
+        assertEquals("[a -1]", take());
+        assertTrue(map.values().remove(Integer.valueOf(2)));
+        assertEquals("[b -2]", take());
+        Iterator<Map.Entry<String, Integer>> entries = map.entrySet().iterator();
+        Map.Entry<String, Integer> entry = entries.next();
+        entry.setValue(Integer.valueOf(30));
+        assertEquals("[c -3 +30]", take());
+        entries.remove();
+        assertEquals("[c -30]", take());
+        assertEquals(0, map.size());
+    }
+
+    /// A value set through an entry handed out earlier does not change
+    /// what a removal of the current one reports, and a sorted map that
+    /// reuses the removed node reports the value that was removed.
+    @Test
+    public void anEarlierEntrysValueIsNotTheRemovedOne() {
+        ObservableMap<String, Integer> map = FXCollections.observableMap(new java.util.TreeMap<String, Integer>());
+        map.put("a", Integer.valueOf(1));
+        map.put("b", Integer.valueOf(2));
+        map.put("c", Integer.valueOf(3));
+        map.addListener(mapProbe);
+        Iterator<Map.Entry<String, Integer>> entries = map.entrySet().iterator();
+        Map.Entry<String, Integer> first = entries.next();
+        entries.next();
+        first.setValue(Integer.valueOf(10));
+        assertEquals("[a -1 +10]", take());
+        entries.remove();
+        assertEquals("[b -2]", take());
+        assertEquals("c", entries.next().getKey());
+        entries.remove();
+        assertEquals("[c -3]", take());
+        try {
+            entries.remove();
+            fail("Removed twice");
+        } catch (IllegalStateException expected) {
+            assertTrue(map.containsKey("a"));
+        }
+    }
+
+    @Test
+    public void mapInvalidationAndListenerRemoval() {
+        ObservableMap<String, Integer> map = FXCollections.observableHashMap();
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        map.addListener(invalidations);
+        map.addListener(mapProbe);
+        map.put("a", Integer.valueOf(1));
+        assertEquals(1, invalidations.count);
+        assertSame(map, invalidations.last);
+        map.removeListener(mapProbe);
+        map.removeListener(invalidations);
+        map.put("b", Integer.valueOf(2));
+        assertEquals(1, invalidations.count);
+        assertEquals("[a +1]", take());
+        assertEquals(Integer.valueOf(2), map.get("b"));
+        assertTrue(map.containsKey("a"));
+        assertTrue(map.containsValue(Integer.valueOf(1)));
+    }
+
+    @Test
+    public void unmodifiableAndEmptyMaps() {
+        ObservableMap<String, Integer> map = FXCollections.observableMap(new HashMap<String, Integer>());
+        ObservableMap<String, Integer> view = FXCollections.unmodifiableObservableMap(map);
+        view.addListener(mapProbe);
+        map.put("a", Integer.valueOf(1));
+        assertEquals("[a +1]", take());
+        assertEquals(Integer.valueOf(1), view.get("a"));
+        try {
+            view.put("b", Integer.valueOf(2));
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals(1, view.size());
+        }
+        ObservableMap<String, Integer> empty = FXCollections.emptyObservableMap();
+        assertTrue(empty.isEmpty());
+        try {
+            empty.put("a", Integer.valueOf(1));
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertTrue(empty.isEmpty());
+        }
+    }
+
+    @Test
+    public void setReportsAddAndRemove() {
+        ObservableSet<String> set = FXCollections.observableSet(new LinkedHashSet<String>());
+        set.addListener(setProbe);
+        assertTrue(set.add("a"));
+        assertEquals("[+a]", take());
+        assertFalse(set.add("a"));
+        assertEquals("[]", take());
+        List<String> more = new ArrayList<String>();
+        more.add("a");
+        more.add("b");
+        more.add("c");
+        assertTrue(set.addAll(more));
+        assertEquals("[+b, +c]", take());
+        assertTrue(set.remove("b"));
+        assertEquals("[-b]", take());
+        assertFalse(set.remove("b"));
+        List<String> keep = new ArrayList<String>();
+        keep.add("c");
+        assertTrue(set.retainAll(keep));
+        assertEquals("[-a]", take());
+        set.add("d");
+        take();
+        Iterator<String> it = set.iterator();
+        it.next();
+        it.remove();
+        assertEquals("[-c]", take());
+        set.clear();
+        assertEquals("[-d]", take());
+        assertTrue(set.isEmpty());
+    }
+
+    @Test
+    public void setFactoriesAndViews() {
+        ObservableSet<String> set = FXCollections.observableSet("a", "b");
+        assertEquals(2, set.size());
+        assertTrue(set.contains("a"));
+        ObservableSet<String> view = FXCollections.unmodifiableObservableSet(set);
+        view.addListener(setProbe);
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        set.addListener(invalidations);
+        set.add("c");
+        assertEquals("[+c]", take());
+        assertEquals(1, invalidations.count);
+        try {
+            view.add("d");
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals(3, view.size());
+        }
+        ObservableSet<String> empty = FXCollections.emptyObservableSet();
+        assertTrue(empty.isEmpty());
+        set.removeListener(invalidations);
+        set.add("e");
+        assertEquals(1, invalidations.count);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PortControlsTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PortControlsTest.java
new file mode 100644
index 00000000000..de1c6c231cc
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PortControlsTest.java
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.StageForm;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.application.Platform;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonBase;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.Hyperlink;
+import javafx.scene.control.Label;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.Slider;
+import javafx.scene.control.Toggle;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+import javafx.stage.Stage;
+
+/// The controls under the keyboard and the pointer of a port: what a key
+/// does to the control with the focus, to the default and the cancel
+/// button and to an open menu, and what a pointer does to the controls
+/// that keep a state between two presses.
+///
+/// Every event enters through the form on screen, as a port delivers it.
+/// Each test here was a difference between the layer and JavaFX found by
+/// playing one script of real input against both.
+public class PortControlsTest {
+
+    private static final int FIRE = -90;
+    private static final int DOWN = -92;
+    private static final int ESCAPE = 27;
+    private static final int TAB = 9;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicit;
+    private Stage stage;
+    private StageForm form;
+    private final List<String> seen = new ArrayList<String>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        // A desk: the form moves the focus on Tab itself, and a mouse is no finger.
+        HeadlessImplementation.setDesktop(true);
+        Units.setScale(1);
+        implicit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+    }
+
+    @After
+    public void tearDown() {
+        if (stage != null && stage.isShowing()) {
+            stage.hide();
+        }
+        Platform.setImplicitExit(implicit);
+        HeadlessImplementation.setDesktop(false);
+        Units.setScale(0);
+    }
+
+    private void show(Parent root) {
+        stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setScene(new Scene(root, 400, 300));
+        stage.show();
+        form = (StageForm) stage.cn1Host();
+        form.revalidate();
+    }
+
+    private int px(double sceneX) {
+        return form.getContentPane().getAbsoluteX() + Units.toPixels(sceneX);
+    }
+
+    private int py(double sceneY) {
+        return form.getContentPane().getAbsoluteY() + Units.toPixels(sceneY);
+    }
+
+    private void click(double sceneX, double sceneY) {
+        form.pointerPressed(new int[] {px(sceneX)}, new int[] {py(sceneY)});
+        form.pointerReleased(new int[] {px(sceneX)}, new int[] {py(sceneY)});
+        MainThreadRule.drain();
+    }
+
+    private void key(int code) {
+        form.keyPressed(code);
+        form.keyReleased(code);
+        MainThreadRule.drain();
+    }
+
+    private <T extends Region> T at(Pane root, T node, double x, double y) {
+        node.relocate(x, y);
+        node.setPrefSize(80, 30);
+        node.setMinSize(80, 30);
+        node.setMaxSize(80, 30);
+        root.getChildren().add(node);
+        return node;
+    }
+
+    private <T extends ButtonBase> T reporting(T button, final String name) {
+        button.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                seen.add(name);
+            }
+        });
+        return button;
+    }
+
+    /// Two radio buttons of a group, pressed in turn more than once: each
+    /// press of the one that is not selected selects it, the third as the
+    /// first.
+    @Test
+    public void aRadioButtonIsSelectedAgainAfterItsGroupMovedOn() {
+        Pane root = new Pane();
+        final RadioButton one = at(root, new RadioButton("One"), 20, 20);
+        final RadioButton two = at(root, new RadioButton("Two"), 120, 20);
+        ToggleGroup group = new ToggleGroup();
+        one.setToggleGroup(group);
+        two.setToggleGroup(group);
+        group.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
+            @Override
+            public void changed(ObservableValue<? extends Toggle> o, Toggle was, Toggle now) {
+                seen.add(now == one ? "one" : now == two ? "two" : "none");
+            }
+        });
+        show(root);
+        click(40, 35);
+        click(140, 35);
+        click(40, 35);
+        assertSame(one, stage.getScene().getFocusOwner());
+        click(140, 35);
+        assertEquals("[one, two, one, two]", seen.toString());
+        assertTrue(two.isSelected());
+        assertFalse(one.isSelected());
+    }
+
+    /// A slider dragged along its track: its value is changing from the
+    /// drag until the pointer is let go of, and the value the application
+    /// reads when that ends is where the pointer was let go of.
+    @Test
+    public void aSliderDraggedSaysItsValueIsChangingUntilItIsLetGoOf() {
+        Pane root = new Pane();
+        final Slider slider = new Slider(0, 100, 0);
+        slider.relocate(20, 20);
+        slider.setPrefSize(300, 30);
+        slider.setMinSize(300, 30);
+        slider.setMaxSize(300, 30);
+        root.getChildren().add(slider);
+        slider.valueChangingProperty().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> o, Boolean was, Boolean now) {
+                seen.add(now.booleanValue() ? "changing" : (slider.getValue() > 60 ? "high" : "low"));
+            }
+        });
+        show(root);
+        form.pointerPressed(new int[] {px(28)}, new int[] {py(35)});
+        for (int x = 48; x <= 288; x += 20) {
+            form.pointerDragged(new int[] {px(x)}, new int[] {py(35)});
+            MainThreadRule.drain();
+        }
+        assertTrue(slider.isValueChanging());
+        form.pointerReleased(new int[] {px(288)}, new int[] {py(35)});
+        MainThreadRule.drain();
+        assertFalse(slider.isValueChanging());
+        assertEquals("[changing, high]", seen.toString());
+    }
+
+    /// Space and Enter on the control with the focus do once what a click
+    /// on it does, whatever kind of button it is.
+    @Test
+    public void theKeyThatFiresActsOnceOnTheButtonWithTheFocus() {
+        Pane root = new Pane();
+        at(root, reporting(new Button("b"), "button"), 20, 20);
+        ToggleButton toggle = at(root, reporting(new ToggleButton("t"), "toggle"), 120, 20);
+        CheckBox check = at(root, reporting(new CheckBox("c"), "check"), 220, 20);
+        at(root, reporting(new Hyperlink("h"), "link"), 20, 80);
+        show(root);
+        click(40, 35);
+        seen.clear();
+        key(FIRE);
+        assertEquals("[button]", seen.toString());
+        key(TAB);
+        assertSame(toggle, stage.getScene().getFocusOwner());
+        key(FIRE);
+        assertTrue(toggle.isSelected());
+        key(' ');
+        assertFalse(toggle.isSelected());
+        key(TAB);
+        assertSame(check, stage.getScene().getFocusOwner());
+        key(FIRE);
+        assertTrue(check.isSelected());
+        key(TAB);
+        key(FIRE);
+        assertEquals("[button, toggle, toggle, check, link]", seen.toString());
+    }
+
+    /// Tab moves the focus one control on in the order of the scene graph
+    /// and no further, and a key no control makes anything of leaves the
+    /// focus where it is: the form under the scene is not asked.
+    @Test
+    public void theFocusMovesOnTabOnlyAndInTheOrderOfTheScene() {
+        Pane root = new Pane();
+        // Laid out against the order they were added in.
+        Button first = at(root, reporting(new Button("1"), "first"), 220, 80);
+        Button second = at(root, reporting(new Button("2"), "second"), 20, 20);
+        Button third = at(root, reporting(new Button("3"), "third"), 120, 20);
+        show(root);
+        click(240, 95);
+        seen.clear();
+        key(TAB);
+        assertSame(second, stage.getScene().getFocusOwner());
+        key(TAB);
+        assertSame(third, stage.getScene().getFocusOwner());
+        key('q');
+        key(16);
+        key(113);
+        assertSame(third, stage.getScene().getFocusOwner());
+        key(FIRE);
+        assertEquals("[third]", seen.toString());
+        key(TAB);
+        assertSame(first, stage.getScene().getFocusOwner());
+    }
+
+    /// An arrow key on a button moves the focus to the nearest control in
+    /// that direction, and stays where it is when there is none.
+    @Test
+    public void anArrowOnAButtonMovesTheFocusThatWay() {
+        Pane root = new Pane();
+        Button a = at(root, new Button("a"), 20, 20);
+        Button b = at(root, new Button("b"), 120, 20);
+        Button c = at(root, new Button("c"), 20, 80);
+        show(root);
+        click(40, 35);
+        key(-94);
+        assertSame(b, stage.getScene().getFocusOwner());
+        key(-94);
+        assertSame(b, stage.getScene().getFocusOwner());
+        key(-93);
+        assertSame(a, stage.getScene().getFocusOwner());
+        key(DOWN);
+        assertSame(c, stage.getScene().getFocusOwner());
+        key(-91);
+        assertSame(a, stage.getScene().getFocusOwner());
+    }
+
+    /// The press of the key arms the button and the release fires it, so
+    /// a key held down fires once.
+    @Test
+    public void aKeyHeldDownOnAButtonFiresItWhenItIsLetGoOf() {
+        Pane root = new Pane();
+        Button b = at(root, reporting(new Button("b"), "button"), 20, 20);
+        show(root);
+        click(40, 35);
+        seen.clear();
+        form.keyPressed(FIRE);
+        MainThreadRule.drain();
+        assertTrue(b.isArmed());
+        assertEquals("[]", seen.toString());
+        form.keyReleased(FIRE);
+        MainThreadRule.drain();
+        assertFalse(b.isArmed());
+        assertEquals("[button]", seen.toString());
+    }
+
+    /// Enter with the focus on nothing that takes it fires the default
+    /// button, and Escape the cancel button.
+    @Test
+    public void enterFiresTheDefaultButtonAndEscapeTheCancelButton() {
+        Pane root = new Pane();
+        // The first control of a scene has the focus, and this one makes nothing of Enter.
+        at(root, new Slider(0, 100, 0), 20, 100);
+        CheckBox check = at(root, reporting(new CheckBox("c"), "check"), 220, 20);
+        Button ok = at(root, reporting(new Button("ok"), "ok"), 20, 20);
+        ok.setDefaultButton(true);
+        Button cancel = at(root, reporting(new Button("cancel"), "cancel"), 120, 20);
+        cancel.setCancelButton(true);
+        show(root);
+        key(FIRE);
+        assertEquals("[ok]", seen.toString());
+        key(ESCAPE);
+        assertEquals("[ok, cancel]", seen.toString());
+        // The control with the focus comes first: the key ticks the box.
+        click(240, 35);
+        seen.clear();
+        key(FIRE);
+        assertEquals("[check]", seen.toString());
+        assertFalse(check.isSelected());
+        key(ESCAPE);
+        assertEquals("[check, cancel]", seen.toString());
+        // A button that is not shown is not fired.
+        seen.clear();
+        cancel.setVisible(false);
+        key(ESCAPE);
+        assertEquals("[]", seen.toString());
+    }
+
+    /// A key handler of the scene that consumes the key keeps it from the
+    /// default button.
+    @Test
+    public void aKeyTheApplicationConsumedFiresNoButton() {
+        Pane root = new Pane();
+        Label label = new Label("nothing");
+        label.relocate(20, 100);
+        root.getChildren().add(label);
+        Button ok = new Button("ok");
+        ok.relocate(20, 20);
+        ok.setFocusTraversable(false);
+        reporting(ok, "ok").setDefaultButton(true);
+        root.getChildren().add(ok);
+        show(root);
+        stage.getScene().setOnKeyPressed(new EventHandler<KeyEvent>() {
+            @Override
+            public void handle(KeyEvent event) {
+                if (event.getCode() == KeyCode.ENTER) {
+                    seen.add("mine");
+                    event.consume();
+                }
+            }
+        });
+        key(FIRE);
+        assertEquals("[mine]", seen.toString());
+    }
+
+    private MenuItem item(final String name) {
+        MenuItem item = new MenuItem(name);
+        item.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                seen.add(name);
+            }
+        });
+        return item;
+    }
+
+    /// An open context menu has the keyboard: Down moves through its
+    /// items, Enter chooses the one moved to and closes the menu, and none
+    /// of it reaches the scene behind.
+    @Test
+    public void anOpenMenuIsWalkedAndChosenFromWithTheKeyboard() {
+        Pane root = new Pane();
+        Button ok = at(root, reporting(new Button("ok"), "ok"), 20, 20);
+        ok.setDefaultButton(true);
+        Label anchor = new Label("anchor");
+        anchor.relocate(200, 100);
+        root.getChildren().add(anchor);
+        MenuItem off = item("off");
+        off.setDisable(true);
+        ContextMenu menu = new ContextMenu(item("first"), off, item("third"));
+        show(root);
+        menu.show(anchor, 200, 100);
+        MainThreadRule.drain();
+        assertTrue(menu.isShowing());
+        key(FIRE);
+        assertTrue(menu.isShowing());
+        assertEquals("[]", seen.toString());
+        key(DOWN);
+        key(DOWN);
+        key(FIRE);
+        assertEquals("[third]", seen.toString());
+        assertFalse(menu.isShowing());
+        menu.show(anchor, 200, 100);
+        MainThreadRule.drain();
+        key(ESCAPE);
+        assertFalse(menu.isShowing());
+        assertEquals("[third]", seen.toString());
+        // With the menu gone the keys are the scene's again.
+        key(FIRE);
+        assertEquals("[third, ok]", seen.toString());
+    }
+
+    /// A button a little narrower than its text keeps the text where it is
+    /// under the pointer and with the focus. The native label scrolled it
+    /// back and forth, which is what a phone does and JavaFX never does.
+    @Test
+    public void theTextOfANarrowButtonDoesNotScroll() {
+        Pane root = new Pane();
+        Button narrow = new Button("A button with more text than room");
+        narrow.resizeRelocate(10, 10, 60, 30);
+        narrow.setManaged(false);
+        root.getChildren().add(narrow);
+        show(root);
+        assertTrue(narrow.cn1Native() instanceof com.codename1.ui.Label);
+        com.codename1.ui.Label label = (com.codename1.ui.Label) narrow.cn1Native();
+        form.pointerHover(new int[] {px(30)}, new int[] {py(25)});
+        narrow.requestFocus();
+        label.requestFocus();
+        MainThreadRule.drain();
+        form.pointerHover(new int[] {px(32)}, new int[] {py(25)});
+        MainThreadRule.drain();
+        assertFalse(label.isTickerRunning());
+    }
+
+    /// A theme of a desktop port has a style for a component under the
+    /// pointer, which `getAllStyles()` leaves out. The font and the fill
+    /// of a control are the font and the fill of that one too: the text of
+    /// a hovered button was drawn in the theme's font, wider than the room
+    /// the button was given for its own.
+    @Test
+    public void aHoveredButtonKeepsItsFontAndItsFill() {
+        java.util.Hashtable<String, Object> theme = new java.util.Hashtable<String, Object>();
+        theme.put("Button.hover#fgColor", "ff0000");
+        com.codename1.ui.plaf.UIManager.getInstance().addThemeProps(theme);
+        try {
+            aHoveredButtonUnderTheTheme();
+        } finally {
+            // The theme is the display's, and the classes after this one
+            // draw their controls with it.
+            com.codename1.ui.plaf.UIManager.getInstance().setThemeProps(
+                    new java.util.Hashtable<String, Object>());
+        }
+    }
+
+    private void aHoveredButtonUnderTheTheme() {
+        Pane root = new Pane();
+        Button b = new Button("Click me");
+        b.setFont(javafx.scene.text.Font.font(21));
+        b.setTextFill(javafx.scene.paint.Color.BLUE);
+        b.relocate(10, 10);
+        root.getChildren().add(b);
+        show(root);
+        MainThreadRule.drain();
+        com.codename1.ui.Component c = b.cn1Native();
+        com.codename1.ui.plaf.Style hover = c.getHoverStyle();
+        assertTrue("the theme has a hover style", hover != null);
+        assertEquals(0x0000ff, hover.getFgColor());
+        assertSame(c.getUnselectedStyle().getFont(), hover.getFont());
+    }
+
+    /// The menu of a menu bar, opened, is walked the same way.
+    @Test
+    public void theMenuOfAMenuBarIsChosenFromWithTheKeyboard() {
+        Pane root = new Pane();
+        Menu file = new Menu("File", null, item("open"), item("save"));
+        MenuBar bar = new MenuBar(file);
+        bar.setPrefWidth(400);
+        root.getChildren().add(bar);
+        show(root);
+        file.show();
+        MainThreadRule.drain();
+        assertTrue(file.isShowing());
+        key(DOWN);
+        key(DOWN);
+        key(FIRE);
+        assertEquals("[save]", seen.toString());
+        assertFalse(file.isShowing());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PortInputTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PortInputTest.java
new file mode 100644
index 00000000000..c4ffc95d519
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PortInputTest.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.SceneInput;
+import com.codename1.fxcompat.runtime.StageForm;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Display;
+
+import javafx.application.Platform;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.Group;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.SwipeEvent;
+import javafx.scene.layout.Pane;
+import javafx.stage.Stage;
+
+/// Input as a port delivers it: through the form on screen, at the
+/// position of the pointer on the display, with nothing told to the
+/// scene or to a control directly.
+///
+/// The tests here exist because an application passed every test that
+/// fired its events at the node they were meant for, and was dead under a
+/// real pointer: where a node is drawn and where its Codename One peer
+/// lies are two different places once a parent is scaled, and a key
+/// pressed before the first click had nowhere to go.
+public class PortInputTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicit;
+    private Stage stage;
+    private StageForm form;
+    private final List<String> seen = new ArrayList<String>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+        implicit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+    }
+
+    @After
+    public void tearDown() {
+        if (stage != null && stage.isShowing()) {
+            stage.hide();
+        }
+        Platform.setImplicitExit(implicit);
+        Units.setScale(0);
+    }
+
+    private void show(Parent root) {
+        stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setScene(new Scene(root));
+        stage.show();
+        form = (StageForm) stage.cn1Host();
+        form.revalidate();
+    }
+
+    /// A click as the display delivers it, at a point of the scene.
+    private void click(double sceneX, double sceneY) {
+        int x = form.getContentPane().getAbsoluteX() + Units.toPixels(sceneX);
+        int y = form.getContentPane().getAbsoluteY() + Units.toPixels(sceneY);
+        form.pointerPressed(new int[] {x}, new int[] {y});
+        form.pointerReleased(new int[] {x}, new int[] {y});
+        // A native component fires its listeners on the event thread.
+        MainThreadRule.drain();
+    }
+
+    private void press(double sceneX, double sceneY) {
+        int x = form.getContentPane().getAbsoluteX() + Units.toPixels(sceneX);
+        int y = form.getContentPane().getAbsoluteY() + Units.toPixels(sceneY);
+        form.pointerPressed(new int[] {x}, new int[] {y});
+    }
+
+    private void release(double sceneX, double sceneY) {
+        int x = form.getContentPane().getAbsoluteX() + Units.toPixels(sceneX);
+        int y = form.getContentPane().getAbsoluteY() + Units.toPixels(sceneY);
+        form.pointerReleased(new int[] {x}, new int[] {y});
+        MainThreadRule.drain();
+    }
+
+    /// A press on a button that is let go of somewhere else fires nothing,
+    /// scaled or not, and leaves the button ready for the next press.
+    @Test
+    public void aPressLetGoOfOutsideAScaledButtonFiresNothing() {
+        Pane root = new Pane();
+        Group group = new Group();
+        Button a = button("a");
+        Button b = button("b");
+        b.relocate(360, 360);
+        group.getChildren().addAll(a, b);
+        group.setScaleX(0.5);
+        group.setScaleY(0.5);
+        root.getChildren().add(group);
+        show(root);
+        press(110, 110);
+        assertTrue(a.isPressed());
+        release(200, 200);
+        assertFalse(a.isPressed());
+        assertEquals("[]", seen.toString());
+        click(110, 110);
+        assertEquals("[a]", seen.toString());
+    }
+
+    /// A rotated parent: the button is pressed where the rotation puts it.
+    @Test
+    public void aButtonInARotatedGroupFiresWhereItIsDrawn() {
+        Pane root = new Pane();
+        Group group = new Group();
+        Button a = button("a");
+        Button b = button("b");
+        b.relocate(360, 360);
+        group.getChildren().addAll(a, b);
+        group.setRotate(180);
+        root.getChildren().add(group);
+        show(root);
+        // Half a turn about the centre at 200 puts a where b was laid out.
+        click(380, 380);
+        assertEquals("[a]", seen.toString());
+        click(20, 20);
+        assertEquals("[a, b]", seen.toString());
+    }
+
+    private Button button(final String name) {
+        Button b = new Button(name);
+        b.setPrefSize(40, 40);
+        b.setMinSize(40, 40);
+        b.setMaxSize(40, 40);
+        b.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                seen.add(name);
+            }
+        });
+        return b;
+    }
+
+    @Test
+    public void aButtonFiresWhereItIsDrawn() {
+        Pane root = new Pane();
+        Button b = button("plain");
+        b.relocate(100, 100);
+        root.getChildren().add(b);
+        show(root);
+        click(120, 120);
+        assertEquals("[plain]", seen.toString());
+        click(160, 120);
+        assertEquals("[plain]", seen.toString());
+    }
+
+    /// A group scaled to half its size about its centre, as a game board
+    /// scaled to its window is: the button is drawn at half its size and
+    /// nearer the centre, and that is where it is pressed.
+    @Test
+    public void aButtonInAScaledGroupFiresWhereItIsDrawn() {
+        Pane root = new Pane();
+        Group group = new Group();
+        Button a = button("a");
+        a.relocate(0, 0);
+        Button b = button("b");
+        b.relocate(360, 360);
+        group.getChildren().addAll(a, b);
+        group.setScaleX(0.5);
+        group.setScaleY(0.5);
+        root.getChildren().add(group);
+        show(root);
+        // The group is 400 wide about a centre at 200: a is drawn from 100 to 120, b from 280 to 300.
+        click(110, 110);
+        assertEquals("[a]", seen.toString());
+        click(290, 290);
+        assertEquals("[a, b]", seen.toString());
+        // Where the peers lie, unscaled, nothing is drawn and nothing fires.
+        click(20, 20);
+        click(380, 380);
+        assertEquals("[a, b]", seen.toString());
+    }
+
+    @Test
+    public void aButtonMovedByATranslateFiresWhereItIsDrawn() {
+        Pane root = new Pane();
+        Button b = button("moved");
+        b.relocate(100, 100);
+        b.setTranslateX(200);
+        root.getChildren().add(b);
+        show(root);
+        click(320, 120);
+        assertEquals("[moved]", seen.toString());
+        click(120, 120);
+        assertEquals("[moved]", seen.toString());
+    }
+
+    @Test
+    public void aCheckBoxInAScaledGroupIsTickedWhereItIsDrawn() {
+        Pane root = new Pane();
+        Group group = new Group();
+        CheckBox box = new CheckBox("x");
+        box.relocate(250, 250);
+        Pane filler = new Pane();
+        filler.setPrefSize(400, 400);
+        filler.setMinSize(400, 400);
+        filler.setMouseTransparent(true);
+        group.getChildren().addAll(filler, box);
+        group.setScaleX(2);
+        group.setScaleY(2);
+        root.getChildren().add(group);
+        show(root);
+        filler.resize(400, 400);
+        javafx.geometry.Bounds at = box.localToScene(box.getBoundsInLocal());
+        assertFalse(box.isSelected());
+        click(at.getMinX() + 6, at.getMinY() + at.getHeight() / 2);
+        assertTrue(box.isSelected());
+    }
+
+    /// A drag as the display delivers it: a press, moves through the
+    /// overload a display calls, a release.
+    private void drag(double fromX, double fromY, double toX, double toY) {
+        int ox = form.getContentPane().getAbsoluteX();
+        int oy = form.getContentPane().getAbsoluteY();
+        form.pointerPressed(new int[] {ox + Units.toPixels(fromX)}, new int[] {oy + Units.toPixels(fromY)});
+        for (int i = 1; i <= 4; i++) {
+            double x = fromX + (toX - fromX) * i / 4;
+            double y = fromY + (toY - fromY) * i / 4;
+            form.pointerDragged(new int[] {ox + Units.toPixels(x)}, new int[] {oy + Units.toPixels(y)});
+        }
+        form.pointerReleased(new int[] {ox + Units.toPixels(toX)}, new int[] {oy + Units.toPixels(toY)});
+        MainThreadRule.drain();
+    }
+
+    private Pane swipeBoard() {
+        Pane root = new Pane();
+        root.setPrefSize(400, 400);
+        root.setOnSwipeLeft(new EventHandler<SwipeEvent>() {
+            @Override
+            public void handle(SwipeEvent event) {
+                seen.add("left");
+            }
+        });
+        root.setOnSwipeDown(new EventHandler<SwipeEvent>() {
+            @Override
+            public void handle(SwipeEvent event) {
+                seen.add("down");
+            }
+        });
+        return root;
+    }
+
+    /// A finger dragged across the scene is one swipe, once, when it lifts.
+    @Test
+    public void aFingerDraggedAcrossTheSceneIsOneSwipe() {
+        SceneInput.setTouchInput(1);
+        try {
+            show(swipeBoard());
+            drag(300, 200, 100, 205);
+            assertEquals("[left]", seen.toString());
+            drag(200, 100, 195, 300);
+            assertEquals("[left, down]", seen.toString());
+            // Too short to be a swipe.
+            drag(200, 200, 185, 200);
+            assertEquals("[left, down]", seen.toString());
+        } finally {
+            SceneInput.setTouchInput(0);
+        }
+    }
+
+    /// A mouse dragged across a JavaFX scene is a drag: no swipe comes of
+    /// it, and a game that moves on a swipe stays put.
+    @Test
+    public void aMouseDraggedAcrossTheSceneIsNoSwipe() {
+        SceneInput.setTouchInput(-1);
+        try {
+            show(swipeBoard());
+            drag(300, 200, 100, 205);
+            drag(200, 100, 195, 300);
+            assertEquals("[]", seen.toString());
+        } finally {
+            SceneInput.setTouchInput(0);
+        }
+    }
+
+    /// The application asks for the focus on its root once the stage is
+    /// showing; a key pressed before any click goes there.
+    @Test
+    public void aKeyPressedBeforeAnyClickReachesTheNodeThatAskedForTheFocus() {
+        Pane root = new Pane();
+        root.getChildren().add(button("b"));
+        root.setFocusTraversable(true);
+        root.setOnKeyPressed(new EventHandler<KeyEvent>() {
+            @Override
+            public void handle(KeyEvent event) {
+                seen.add(String.valueOf(event.getCode()));
+            }
+        });
+        show(root);
+        root.requestFocus();
+        assertSame(root, root.getScene().getFocusOwner());
+        int left = Display.getInstance().getKeyCode(Display.GAME_LEFT);
+        Display.getInstance().getCurrent().keyPressed(left);
+        Display.getInstance().getCurrent().keyReleased(left);
+        assertEquals("[LEFT]", seen.toString());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/Probe.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/Probe.java
new file mode 100644
index 00000000000..d56ff698a9d
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/Probe.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ListChangeListener;
+
+/// Listeners that record what they are told, shared by the tests.
+public final class Probe {
+
+    private Probe() {
+    }
+
+    /// Counts invalidations.
+    public static final class Invalidations implements InvalidationListener {
+        public int count;
+        public Observable last;
+
+        @Override
+        public void invalidated(Observable observable) {
+            count++;
+            last = observable;
+        }
+    }
+
+    /// Records every change as `old->new`.
+    public static final class Values<T> implements ChangeListener<T> {
+        public final List<String> log = new ArrayList<String>();
+
+        @Override
+        public void changed(ObservableValue<? extends T> observable, T oldValue, T newValue) {
+            log.add(oldValue + "->" + newValue);
+        }
+    }
+
+    /// Records every list change, one entry per step.
+    public static final class ListChanges<E> implements ListChangeListener<E> {
+        public final List<String> log = new ArrayList<String>();
+        public int events;
+
+        @Override
+        public void onChanged(Change<? extends E> change) {
+            events++;
+            while (change.next()) {
+                StringBuilder step = new StringBuilder();
+                if (change.wasPermutated()) {
+                    step.append("perm[").append(change.getFrom()).append(',').append(change.getTo()).append("]{");
+                    for (int i = change.getFrom(); i < change.getTo(); i++) {
+                        if (i > change.getFrom()) {
+                            step.append(',');
+                        }
+                        step.append(change.getPermutation(i));
+                    }
+                    step.append('}');
+                } else if (change.wasUpdated()) {
+                    step.append("upd[").append(change.getFrom()).append(',').append(change.getTo()).append(']');
+                } else if (change.wasReplaced()) {
+                    step.append("rep[").append(change.getFrom()).append(',').append(change.getTo()).append("] -")
+                            .append(change.getRemoved()).append(" +").append(change.getAddedSubList());
+                } else if (change.wasAdded()) {
+                    step.append("add[").append(change.getFrom()).append(',').append(change.getTo()).append("] +")
+                            .append(change.getAddedSubList());
+                } else if (change.wasRemoved()) {
+                    step.append("rem[").append(change.getFrom()).append("] -").append(change.getRemoved());
+                } else {
+                    step.append("none");
+                }
+                log.add(step.toString());
+            }
+        }
+
+        public String take() {
+            String result = log.toString();
+            log.clear();
+            return result;
+        }
+    }
+
+    /// Runs the collector until a weak reference clears; returns whether it
+    /// did.
+    public static boolean collected(WeakReference ref) {
+        for (int i = 0; i < 200 && ref.get() != null; i++) {
+            System.gc();
+            byte[][] pressure = new byte[32][];
+            for (int j = 0; j < pressure.length; j++) {
+                pressure[j] = new byte[64 * 1024];
+            }
+            try {
+                Thread.sleep(5);
+            } catch (InterruptedException interrupted) {
+                return false;
+            }
+        }
+        return ref.get() == null;
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PropertyTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PropertyTest.java
new file mode 100644
index 00000000000..d06a67d15f8
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PropertyTest.java
@@ -0,0 +1,614 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.Observable;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.FloatProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.LongProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyBooleanWrapper;
+import javafx.beans.property.ReadOnlyDoubleWrapper;
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.property.ReadOnlyIntegerWrapper;
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.property.ReadOnlyStringProperty;
+import javafx.beans.property.ReadOnlyStringWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleFloatProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleLongProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.beans.value.WeakChangeListener;
+
+public class PropertyTest {
+
+    @Test
+    public void defaultsAndInitialValues() {
+        assertEquals(0, new SimpleIntegerProperty().get());
+        assertEquals(0L, new SimpleLongProperty().get());
+        assertEquals(0f, new SimpleFloatProperty().get(), 0f);
+        assertEquals(0d, new SimpleDoubleProperty().get(), 0d);
+        assertFalse(new SimpleBooleanProperty().get());
+        assertNull(new SimpleStringProperty().get());
+        assertNull(new SimpleObjectProperty<Object>().get());
+        assertEquals(7, new SimpleIntegerProperty(7).get());
+        assertEquals(7L, new SimpleLongProperty(7L).get());
+        assertEquals(1.5f, new SimpleFloatProperty(1.5f).get(), 0f);
+        assertEquals(2.5, new SimpleDoubleProperty(2.5).get(), 0d);
+        assertTrue(new SimpleBooleanProperty(true).get());
+        assertEquals("x", new SimpleStringProperty("x").get());
+        assertEquals("o", new SimpleObjectProperty<String>("o").get());
+    }
+
+    @Test
+    public void beanAndName() {
+        Object bean = new Object();
+        IntegerProperty p = new SimpleIntegerProperty(bean, "width", 3);
+        assertSame(bean, p.getBean());
+        assertEquals("width", p.getName());
+        assertEquals(3, p.get());
+        IntegerProperty anonymous = new SimpleIntegerProperty();
+        assertNull(anonymous.getBean());
+        assertEquals("", anonymous.getName());
+        assertEquals("", new SimpleStringProperty(bean, null).getName());
+        assertEquals("s", new SimpleStringProperty(bean, "s", "v").getName());
+        assertEquals("d", new SimpleDoubleProperty(bean, "d").getName());
+    }
+
+    @Test
+    public void typedValueAccessors() {
+        IntegerProperty i = new SimpleIntegerProperty(5);
+        assertEquals(Integer.valueOf(5), i.getValue());
+        assertEquals(5L, i.longValue());
+        assertEquals(5f, i.floatValue(), 0f);
+        assertEquals(5d, i.doubleValue(), 0d);
+        assertEquals(5, i.intValue());
+        i.setValue(9);
+        assertEquals(9, i.get());
+        DoubleProperty d = new SimpleDoubleProperty(2.75);
+        assertEquals(2, d.intValue());
+        assertEquals(2L, d.longValue());
+        assertEquals(Double.valueOf(2.75), d.getValue());
+        d.setValue(4);
+        assertEquals(4.0, d.get(), 0d);
+        LongProperty l = new SimpleLongProperty(1L << 40);
+        assertEquals(Long.valueOf(1L << 40), l.getValue());
+        FloatProperty f = new SimpleFloatProperty(0.5f);
+        assertEquals(Float.valueOf(0.5f), f.getValue());
+        BooleanProperty b = new SimpleBooleanProperty();
+        b.setValue(Boolean.TRUE);
+        assertTrue(b.get());
+        assertEquals(Boolean.TRUE, b.getValue());
+        StringProperty s = new SimpleStringProperty();
+        s.setValue("hello");
+        assertEquals("hello", s.getValue());
+    }
+
+    @Test
+    public void invalidationIsLazy() {
+        IntegerProperty p = new SimpleIntegerProperty(1);
+        Probe.Invalidations probe = new Probe.Invalidations();
+        p.addListener(probe);
+        p.set(2);
+        assertEquals(1, probe.count);
+        assertSame(p, probe.last);
+        p.set(3);
+        p.set(4);
+        assertEquals("no second invalidation until the value is read", 1, probe.count);
+        assertEquals(4, p.get());
+        p.set(5);
+        assertEquals(2, probe.count);
+        p.get();
+        p.set(5);
+        assertEquals("setting the same value does not invalidate", 2, probe.count);
+    }
+
+    @Test
+    public void changeListenerMakesThePropertyEager() {
+        IntegerProperty p = new SimpleIntegerProperty(1);
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        Probe.Values<Number> changes = new Probe.Values<Number>();
+        p.addListener(invalidations);
+        p.addListener(changes);
+        p.set(2);
+        p.set(3);
+        p.set(3);
+        assertEquals(2, invalidations.count);
+        assertEquals("[1->2, 2->3]", changes.log.toString());
+    }
+
+    @Test
+    public void listenersRunInRegistrationOrder() {
+        final List<String> order = new ArrayList<String>();
+        StringProperty p = new SimpleStringProperty("a");
+        p.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                order.add("inv1");
+            }
+        });
+        p.addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> o, String oldValue, String newValue) {
+                order.add("chg1");
+            }
+        });
+        p.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                order.add("inv2");
+            }
+        });
+        p.addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> o, String oldValue, String newValue) {
+                order.add("chg2");
+            }
+        });
+        p.set("b");
+        assertEquals("[inv1, inv2, chg1, chg2]", order.toString());
+    }
+
+    @Test
+    public void removedListenersAreNotCalled() {
+        DoubleProperty p = new SimpleDoubleProperty();
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        Probe.Values<Number> changes = new Probe.Values<Number>();
+        p.addListener(invalidations);
+        p.addListener(changes);
+        p.set(1);
+        p.removeListener(invalidations);
+        p.removeListener(changes);
+        p.set(2);
+        assertEquals(1, invalidations.count);
+        assertEquals(1, changes.log.size());
+        p.removeListener(invalidations);
+        p.removeListener(changes);
+    }
+
+    @Test
+    public void listenerMayRemoveItselfWhileNotified() {
+        final IntegerProperty p = new SimpleIntegerProperty();
+        final int[] calls = new int[2];
+        p.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                calls[0]++;
+                p.removeListener(this);
+            }
+        });
+        p.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                calls[1]++;
+            }
+        });
+        p.set(1);
+        p.get();
+        p.set(2);
+        assertEquals(1, calls[0]);
+        assertEquals(2, calls[1]);
+    }
+
+    @Test
+    public void changeListenerSeesNestedChangeInOrder() {
+        final IntegerProperty p = new SimpleIntegerProperty(0);
+        final Probe.Values<Number> changes = new Probe.Values<Number>();
+        p.addListener(new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> o, Number oldValue, Number newValue) {
+                if (newValue.intValue() == 1) {
+                    p.set(2);
+                }
+            }
+        });
+        p.addListener(changes);
+        p.set(1);
+        assertEquals(2, p.get());
+        assertEquals("the nested change is delivered first, as in JavaFX", "[1->2, 0->1]",
+                changes.log.toString());
+    }
+
+    @Test
+    public void bindFollowsTheSource() {
+        IntegerProperty source = new SimpleIntegerProperty(1);
+        IntegerProperty target = new SimpleIntegerProperty(9);
+        Probe.Invalidations probe = new Probe.Invalidations();
+        target.addListener(probe);
+        assertFalse(target.isBound());
+        target.bind(source);
+        assertTrue(target.isBound());
+        assertEquals(1, probe.count);
+        assertEquals(1, target.get());
+        source.set(2);
+        assertEquals(2, probe.count);
+        source.set(3);
+        assertEquals("lazy while unread", 2, probe.count);
+        assertEquals(3, target.get());
+        target.unbind();
+        assertFalse(target.isBound());
+        source.set(4);
+        assertEquals("keeps the last bound value", 3, target.get());
+        target.set(10);
+        assertEquals(10, target.get());
+        assertEquals(4, source.get());
+    }
+
+    @Test
+    public void bindingTwiceToTheSameSourceIsANoOp() {
+        StringProperty source = new SimpleStringProperty("a");
+        StringProperty target = new SimpleStringProperty();
+        target.bind(source);
+        target.get();
+        Probe.Invalidations probe = new Probe.Invalidations();
+        target.addListener(probe);
+        target.bind(source);
+        assertEquals(0, probe.count);
+        StringProperty other = new SimpleStringProperty("b");
+        target.bind(other);
+        assertEquals("b", target.get());
+        source.set("c");
+        assertEquals("the first source was released", "b", target.get());
+    }
+
+    @Test
+    public void aBoundValueCannotBeSet() {
+        Object bean = "owner";
+        IntegerProperty source = new SimpleIntegerProperty(1);
+        IntegerProperty i = new SimpleIntegerProperty(bean, "count");
+        i.bind(source);
+        try {
+            i.set(5);
+            fail("expected a RuntimeException");
+        } catch (RuntimeException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().endsWith("A bound value cannot be set."));
+            assertTrue(expected.getMessage(), expected.getMessage().indexOf("count") >= 0);
+        }
+        try {
+            i.setValue(6);
+            fail("expected a RuntimeException");
+        } catch (RuntimeException expected) {
+            assertEquals(1, i.get());
+        }
+        StringProperty s = new SimpleStringProperty();
+        s.bind(new SimpleStringProperty("x"));
+        try {
+            s.set("y");
+            fail("expected a RuntimeException");
+        } catch (RuntimeException expected) {
+            assertEquals("A bound value cannot be set.", expected.getMessage());
+        }
+        BooleanProperty b = new SimpleBooleanProperty();
+        b.bind(new SimpleBooleanProperty(true));
+        DoubleProperty d = new SimpleDoubleProperty();
+        d.bind(source);
+        LongProperty l = new SimpleLongProperty();
+        l.bind(source);
+        FloatProperty f = new SimpleFloatProperty();
+        f.bind(source);
+        ObjectProperty<String> o = new SimpleObjectProperty<String>();
+        o.bind(new SimpleObjectProperty<String>("v"));
+        int thrown = 0;
+        try {
+            b.set(false);
+        } catch (RuntimeException expected) {
+            thrown++;
+        }
+        try {
+            d.set(2);
+        } catch (RuntimeException expected) {
+            thrown++;
+        }
+        try {
+            l.set(2);
+        } catch (RuntimeException expected) {
+            thrown++;
+        }
+        try {
+            f.set(2);
+        } catch (RuntimeException expected) {
+            thrown++;
+        }
+        try {
+            o.set("w");
+        } catch (RuntimeException expected) {
+            thrown++;
+        }
+        assertEquals(5, thrown);
+        assertTrue(b.get());
+        assertEquals(1.0, d.get(), 0d);
+        assertEquals(1L, l.get());
+        assertEquals(1f, f.get(), 0f);
+        assertEquals("v", o.get());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void bindToNullThrows() {
+        new SimpleIntegerProperty().bind(null);
+    }
+
+    @Test
+    public void numericPropertyBindsToAnyNumber() {
+        DoubleProperty d = new SimpleDoubleProperty();
+        IntegerProperty i = new SimpleIntegerProperty(4);
+        d.bind(i);
+        assertEquals(4.0, d.get(), 0d);
+        i.set(6);
+        assertEquals(6.0, d.get(), 0d);
+        IntegerProperty truncated = new SimpleIntegerProperty();
+        DoubleProperty source = new SimpleDoubleProperty(2.9);
+        truncated.bind(source);
+        assertEquals(2, truncated.get());
+    }
+
+    @Test
+    public void aBoundPropertyIsNotKeptAliveByItsSource() {
+        IntegerProperty source = new SimpleIntegerProperty(1);
+        IntegerProperty target = new SimpleIntegerProperty();
+        target.bind(source);
+        assertEquals(1, target.get());
+        WeakReference ref = new WeakReference(target);
+        target = null;
+        assertTrue("the bound property stayed reachable from its source", Probe.collected(ref));
+        source.set(2);
+        source.set(3);
+        assertEquals(3, source.get());
+    }
+
+    @Test
+    public void bidirectionalBindingCopiesBothWays() {
+        IntegerProperty a = new SimpleIntegerProperty(1);
+        IntegerProperty b = new SimpleIntegerProperty(2);
+        a.bindBidirectional(b);
+        assertEquals("the first takes the value of the second", 2, a.get());
+        a.set(5);
+        assertEquals(5, b.get());
+        b.set(7);
+        assertEquals(7, a.get());
+        a.unbindBidirectional(b);
+        a.set(8);
+        assertEquals(7, b.get());
+        b.set(9);
+        assertEquals(8, a.get());
+    }
+
+    @Test
+    public void bidirectionalUnbindWorksFromEitherSide() {
+        StringProperty a = new SimpleStringProperty("a");
+        StringProperty b = new SimpleStringProperty("b");
+        a.bindBidirectional(b);
+        b.unbindBidirectional(a);
+        a.set("x");
+        assertEquals("b", b.get());
+        ObjectProperty<String> c = new SimpleObjectProperty<String>("c");
+        ObjectProperty<String> d = new SimpleObjectProperty<String>("d");
+        c.bindBidirectional(d);
+        c.bindBidirectional(d);
+        d.set("e");
+        assertEquals("e", c.get());
+        c.unbindBidirectional(d);
+        d.set("f");
+        assertEquals("binding twice needs unbinding twice", "f", c.get());
+        c.unbindBidirectional(d);
+        d.set("g");
+        assertEquals("f", c.get());
+    }
+
+    @Test
+    public void bidirectionalBindingDoesNotKeepEitherSideAlive() {
+        DoubleProperty a = new SimpleDoubleProperty(1);
+        DoubleProperty b = new SimpleDoubleProperty(2);
+        a.bindBidirectional(b);
+        WeakReference ref = new WeakReference(b);
+        b = null;
+        assertTrue("the partner stayed reachable through the binding", Probe.collected(ref));
+        a.set(3);
+        a.set(4);
+        assertEquals(4.0, a.get(), 0d);
+    }
+
+    @Test
+    public void bidirectionalBindingToABoundPropertyRestoresTheValue() {
+        IntegerProperty a = new SimpleIntegerProperty(1);
+        IntegerProperty b = new SimpleIntegerProperty(1);
+        IntegerProperty master = new SimpleIntegerProperty(1);
+        a.bindBidirectional(b);
+        b.bind(master);
+        try {
+            a.set(5);
+            fail("expected a RuntimeException");
+        } catch (RuntimeException expected) {
+            assertEquals("the change that could not be copied is undone", 1, a.get());
+        }
+    }
+
+    @Test
+    public void chainOfBidirectionalBindings() {
+        BooleanProperty a = new SimpleBooleanProperty();
+        BooleanProperty b = new SimpleBooleanProperty();
+        BooleanProperty c = new SimpleBooleanProperty();
+        a.bindBidirectional(b);
+        b.bindBidirectional(c);
+        a.set(true);
+        assertTrue(b.get());
+        assertTrue(c.get());
+        c.set(false);
+        assertFalse(a.get());
+    }
+
+    @Test
+    public void weakInvalidationListenerForwardsAndReleases() {
+        IntegerProperty p = new SimpleIntegerProperty();
+        Probe.Invalidations probe = new Probe.Invalidations();
+        WeakInvalidationListener weak = new WeakInvalidationListener(probe);
+        p.addListener(weak);
+        p.set(1);
+        assertEquals(1, probe.count);
+        assertFalse(weak.wasGarbageCollected());
+        WeakReference ref = new WeakReference(probe);
+        probe = null;
+        assertTrue(Probe.collected(ref));
+        assertTrue(weak.wasGarbageCollected());
+        p.get();
+        p.set(2);
+        p.get();
+        p.set(3);
+        assertEquals(3, p.get());
+    }
+
+    @Test
+    public void weakChangeListenerForwards() {
+        StringProperty p = new SimpleStringProperty("a");
+        Probe.Values<String> probe = new Probe.Values<String>();
+        WeakChangeListener<String> weak = new WeakChangeListener<String>(probe);
+        p.addListener(weak);
+        p.set("b");
+        assertEquals("[a->b]", probe.log.toString());
+        assertFalse(weak.wasGarbageCollected());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void weakListenerRejectsNull() {
+        new WeakInvalidationListener(null);
+    }
+
+    @Test
+    public void readOnlyWrapperExposesAReadOnlyView() {
+        ReadOnlyIntegerWrapper wrapper = new ReadOnlyIntegerWrapper(this, "size", 1);
+        ReadOnlyIntegerProperty view = wrapper.getReadOnlyProperty();
+        assertSame(view, wrapper.getReadOnlyProperty());
+        assertFalse(view instanceof IntegerProperty);
+        assertEquals(1, view.get());
+        assertSame(this, view.getBean());
+        assertEquals("size", view.getName());
+        Probe.Invalidations invalidations = new Probe.Invalidations();
+        Probe.Values<Number> changes = new Probe.Values<Number>();
+        view.addListener(invalidations);
+        wrapper.set(2);
+        assertEquals(1, invalidations.count);
+        wrapper.set(3);
+        assertEquals(1, invalidations.count);
+        assertEquals(3, view.get());
+        view.addListener(changes);
+        wrapper.set(4);
+        assertEquals("[3->4]", changes.log.toString());
+    }
+
+    @Test
+    public void everyWrapperTypeHasAView() {
+        ReadOnlyStringWrapper s = new ReadOnlyStringWrapper("a");
+        ReadOnlyStringProperty view = s.getReadOnlyProperty();
+        s.set("b");
+        assertEquals("b", view.get());
+        ReadOnlyBooleanWrapper b = new ReadOnlyBooleanWrapper(true);
+        assertTrue(b.getReadOnlyProperty().get());
+        ReadOnlyDoubleWrapper d = new ReadOnlyDoubleWrapper(1.5);
+        assertEquals(1.5, d.getReadOnlyProperty().get(), 0d);
+        ReadOnlyObjectWrapper<String> o = new ReadOnlyObjectWrapper<String>("x");
+        assertEquals("x", o.getReadOnlyProperty().get());
+        IntegerProperty source = new SimpleIntegerProperty(8);
+        ReadOnlyIntegerWrapper bound = new ReadOnlyIntegerWrapper();
+        bound.bind(source);
+        assertEquals(8, bound.getReadOnlyProperty().get());
+        Probe.Invalidations probe = new Probe.Invalidations();
+        bound.getReadOnlyProperty().addListener(probe);
+        source.set(9);
+        assertEquals(1, probe.count);
+        assertEquals(9, bound.getReadOnlyProperty().get());
+    }
+
+    @Test
+    public void asObjectIsALiveTwoWayView() {
+        IntegerProperty i = new SimpleIntegerProperty(1);
+        ObjectProperty<Integer> boxed = i.asObject();
+        assertEquals(Integer.valueOf(1), boxed.get());
+        i.set(2);
+        assertEquals(Integer.valueOf(2), boxed.get());
+        boxed.set(Integer.valueOf(3));
+        assertEquals(3, i.get());
+        ObjectProperty<Double> source = new SimpleObjectProperty<Double>(Double.valueOf(1.5));
+        DoubleProperty d = DoubleProperty.doubleProperty(source);
+        assertEquals(1.5, d.get(), 0d);
+        d.set(2.5);
+        assertEquals(Double.valueOf(2.5), source.get());
+        source.set(Double.valueOf(4));
+        assertEquals(4.0, d.get(), 0d);
+    }
+
+    @Test
+    public void toStringDescribesTheProperty() {
+        assertEquals("IntegerProperty [value: 3]", new SimpleIntegerProperty(3).toString());
+        String named = new SimpleStringProperty("bean", "title", "t").toString();
+        assertTrue(named, named.startsWith("StringProperty ["));
+        assertTrue(named, named.indexOf("bean: bean") >= 0);
+        assertTrue(named, named.indexOf("name: title") >= 0);
+        assertTrue(named, named.endsWith("value: t]"));
+        IntegerProperty bound = new SimpleIntegerProperty();
+        IntegerProperty source = new SimpleIntegerProperty(4);
+        bound.bind(source);
+        assertTrue(bound.toString(), bound.toString().indexOf("bound") >= 0);
+    }
+
+    @Test
+    public void invalidatedHookRunsBeforeListeners() {
+        final List<String> order = new ArrayList<String>();
+        IntegerProperty p = new SimpleIntegerProperty() {
+            @Override
+            protected void invalidated() {
+                order.add("hook");
+            }
+        };
+        p.addListener(new InvalidationListener() {
+            @Override
+            public void invalidated(Observable observable) {
+                order.add("listener");
+            }
+        });
+        p.set(1);
+        p.set(2);
+        assertEquals("[hook, listener]", order.toString());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PropertyValueFactoryTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PropertyValueFactoryTest.java
new file mode 100644
index 00000000000..fbbedb94fd7
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/PropertyValueFactoryTest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.PropertyAccess;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.scene.Scene;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.cell.CheckBoxTableCell;
+import javafx.scene.control.cell.PropertyValueFactory;
+import javafx.scene.layout.Pane;
+
+/// `PropertyValueFactory` over an installed accessor -- the build
+/// generates the application's -- and the check box cell.
+public class PropertyValueFactoryTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    /// A row of the table.
+    public static final class Person {
+        final StringProperty name = new SimpleStringProperty("Ann");
+        final BooleanProperty active = new SimpleBooleanProperty(false);
+    }
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        // What the build generates for a class like Person.
+        PropertyAccess.install(new PropertyAccess() {
+            @Override
+            public Object call(Object bean, String method) {
+                if (bean instanceof Person) {
+                    Person p = (Person) bean;
+                    if ("nameProperty".equals(method)) {
+                        return p.name;
+                    }
+                    if ("getName".equals(method)) {
+                        return p.name.get();
+                    }
+                    if ("getAge".equals(method)) {
+                        return Integer.valueOf(41);
+                    }
+                    if ("isActive".equals(method)) {
+                        return Boolean.valueOf(p.active.get());
+                    }
+                    if ("getNothing".equals(method)) {
+                        return null;
+                    }
+                }
+                return NONE;
+            }
+
+            @Override
+            public boolean knows(Object bean) {
+                return bean instanceof Person;
+            }
+        });
+    }
+
+    @After
+    public void tearDown() {
+        PropertyAccess.install(null);
+        Units.setScale(0);
+    }
+
+    private static <T> ObservableValue<T> value(String property, Object row) {
+        TableColumn<Object, T> column = new TableColumn<Object, T>(property);
+        column.setCellValueFactory(new PropertyValueFactory<Object, T>(property));
+        return column.getCellValueFactory().call(new TableColumn.CellDataFeatures<Object, T>(null, column, row));
+    }
+
+    @Test
+    public void aPropertyMethodIsPreferredAndAGetterIsWrapped() {
+        Person ann = new Person();
+        assertSame("the cell follows the property itself", ann.name, value("name", ann));
+        ObservableValue<Integer> age = value("age", ann);
+        assertEquals(Integer.valueOf(41), age.getValue());
+        ObservableValue<Boolean> active = value("active", ann);
+        assertEquals(Boolean.FALSE, active.getValue());
+        ObservableValue<Object> nothing = value("nothing", ann);
+        assertNotNull("a getter that returns null is still a property", nothing);
+        assertNull(nothing.getValue());
+        assertEquals("name", new PropertyValueFactory<Object, String>("name").getProperty());
+    }
+
+    @Test
+    public void anUnknownPropertyIsAnErrorThatNamesTheClassAndTheProperty() {
+        try {
+            value("nmae", new Person());
+            fail("Person has no such property");
+        } catch (IllegalStateException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains(Person.class.getName()));
+            assertTrue(e.getMessage(), e.getMessage().contains("nmaeProperty()"));
+        }
+        try {
+            value("length", "a string");
+            fail("Nothing is generated for String");
+        } catch (IllegalStateException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("java.lang.String"));
+            assertTrue(e.getMessage(), e.getMessage().contains("\"length\""));
+            assertTrue(e.getMessage(), e.getMessage().contains("lambda"));
+        }
+    }
+
+    @Test
+    public void aCheckBoxCellWritesThePropertyItShows() {
+        Person ann = new Person();
+        TableView<Person> table = new TableView<Person>(FXCollections.observableArrayList(ann));
+        table.setEditable(true);
+        TableColumn<Person, Boolean> column = new TableColumn<Person, Boolean>("Active");
+        column.setCellValueFactory(f -> f.getValue().active);
+        final List<CheckBoxTableCell<Person, Boolean>> cells = new ArrayList<CheckBoxTableCell<Person, Boolean>>();
+        column.setCellFactory(c -> {
+            CheckBoxTableCell<Person, Boolean> cell = new CheckBoxTableCell<Person, Boolean>();
+            cells.add(cell);
+            return cell;
+        });
+        table.getColumns().add(column);
+        Pane root = new Pane();
+        root.getChildren().add(table);
+        table.setPrefSize(200, 120);
+        Scene scene = new Scene(root, 200, 120);
+        scene.cn1Layout(200, 120);
+
+        CheckBox box = null;
+        for (int i = 0; i < cells.size(); i++) {
+            if (cells.get(i).getIndex() == 0 && cells.get(i).getGraphic() instanceof CheckBox) {
+                box = (CheckBox) cells.get(i).getGraphic();
+            }
+        }
+        assertNotNull("the row shows a check box", box);
+        assertFalse(box.isSelected());
+        assertFalse(box.isDisabled());
+        box.setSelected(true);
+        assertTrue("the box writes the property", ann.active.get());
+        ann.active.set(false);
+        assertFalse("and follows it", box.isSelected());
+        assertNotNull(CheckBoxTableCell.forTableColumn(column).call(column));
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/SceneGraphTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/SceneGraphTest.java
new file mode 100644
index 00000000000..81a463b3511
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/SceneGraphTest.java
@@ -0,0 +1,716 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.FxLifecycle;
+import com.codename1.fxcompat.runtime.StageForm;
+import com.codename1.fxcompat.runtime.StyleEngine;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.Display;
+
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.css.PseudoClass;
+import javafx.event.ActionEvent;
+import javafx.event.Event;
+import javafx.event.EventHandler;
+import javafx.geometry.Bounds;
+import javafx.geometry.Insets;
+import javafx.geometry.Point2D;
+import javafx.scene.Group;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+import javafx.scene.paint.Color;
+import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+
+/// The core of the scene graph: tree, geometry, peers, events, focus,
+/// stages and the styling hooks.
+public class SceneGraphTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        StyleEngine.setInstance(null);
+    }
+
+    private static Region box(double w, double h) {
+        Region r = new Region();
+        r.setPrefSize(w, h);
+        return r;
+    }
+
+    @Test
+    public void childrenKeepOneParentAndFollowTheScene() {
+        Pane a = new Pane();
+        Pane b = new Pane();
+        Region child = box(10, 10);
+        a.getChildren().add(child);
+        assertSame(a, child.getParent());
+        b.getChildren().add(child);
+        assertSame(b, child.getParent());
+        assertTrue(a.getChildren().isEmpty());
+        Scene scene = new Scene(b, 100, 100);
+        assertSame(scene, child.getScene());
+        b.getChildren().remove(child);
+        assertNull(child.getScene());
+        assertNull(child.getParent());
+        assertTrue(b.getStyleClass().contains("root"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void duplicateChildIsRejected() {
+        Pane p = new Pane();
+        Region child = box(1, 1);
+        p.getChildren().addAll(child, child);
+    }
+
+    /// A change OpenJFX refuses leaves the children, and every node, as they
+    /// were: it is checked before the list changes. Checked afterwards, the
+    /// rejected node had gone in and stayed. Messages and outcomes are
+    /// OpenJFX 23's for each case.
+    @Test
+    public void aRejectedChildChangeLeavesTheChildrenAsTheyWere() {
+        final Pane p = new Pane();
+        final Region a = box(1, 1);
+        final Region b = box(1, 1);
+        p.getChildren().add(a);
+        rejected(NullPointerException.class, new Runnable() {
+            public void run() {
+                p.getChildren().add(null);
+            }
+        });
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                p.getChildren().add(a);
+            }
+        });
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                p.getChildren().addAll(b, b);
+            }
+        });
+        rejected(NullPointerException.class, new Runnable() {
+            public void run() {
+                p.getChildren().addAll(b, null);
+            }
+        });
+        assertNull("a node of a rejected batch was adopted", b.getParent());
+        final Pane inner = new Pane();
+        p.getChildren().add(inner);
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                inner.getChildren().add(p);
+            }
+        });
+        assertTrue(inner.getChildren().isEmpty());
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                p.getChildren().add(p);
+            }
+        });
+        final Pane root = new Pane();
+        new Scene(root, 10, 10);
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                p.getChildren().add(root);
+            }
+        });
+        assertNull(root.getParent());
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                p.getChildren().set(1, a);
+            }
+        });
+        rejected(IllegalArgumentException.class, new Runnable() {
+            public void run() {
+                p.getChildren().setAll(a, a);
+            }
+        });
+        assertEquals(2, p.getChildren().size());
+        assertSame(a, p.getChildren().get(0));
+        assertSame(inner, p.getChildren().get(1));
+        assertSame(p, a.getParent());
+        assertSame(p, inner.getParent());
+
+        // What is allowed still is: the same node at its own index, a
+        // replacement that keeps a node, a move from another parent, and a
+        // sort, which reorders without adding anything.
+        p.getChildren().set(0, a);
+        p.getChildren().setAll(inner, a, b);
+        assertSame(p, b.getParent());
+        inner.getChildren().add(b);
+        assertSame(inner, b.getParent());
+        assertEquals(2, p.getChildren().size());
+        p.getChildren().sort(new java.util.Comparator<Node>() {
+            public int compare(Node x, Node y) {
+                return x == a ? -1 : y == a ? 1 : 0;
+            }
+        });
+        assertSame(a, p.getChildren().get(0));
+        assertSame(inner, p.getChildren().get(1));
+    }
+
+    private static void rejected(Class<? extends RuntimeException> type, Runnable change) {
+        try {
+            change.run();
+        } catch (RuntimeException e) {
+            assertSame(e.toString(), type, e.getClass());
+            return;
+        }
+        throw new AssertionError("accepted a change OpenJFX refuses");
+    }
+
+    @Test
+    public void paneSizesChildrenAndPeersFollowInDevicePixels() {
+        Pane root = new Pane();
+        Region child = box(30, 20);
+        child.setLayoutX(5);
+        child.setLayoutY(7);
+        root.getChildren().add(child);
+        root.resize(200, 100);
+        root.layout();
+        assertEquals(30, child.getWidth(), 0);
+        assertEquals(20, child.getHeight(), 0);
+        Component peer = child.cn1Peer();
+        assertEquals(10, peer.getX());
+        assertEquals(14, peer.getY());
+        assertEquals(60, peer.getWidth());
+        assertEquals(40, peer.getHeight());
+        child.setTranslateX(1.5);
+        assertEquals(13, peer.getX());
+        assertTrue(root.cn1Peer() instanceof Container);
+        assertSame(root.cn1Peer(), peer.getParent());
+        root.getChildren().clear();
+        assertNull(peer.getParent());
+    }
+
+    @Test
+    public void peerOrderFollowsChildOrder() {
+        Pane root = new Pane();
+        Region a = box(1, 1);
+        Region b = box(1, 1);
+        Region c = box(1, 1);
+        root.getChildren().addAll(a, b, c);
+        Container peer = (Container) root.cn1Peer();
+        assertEquals(3, peer.getComponentCount());
+        a.toFront();
+        assertSame(b.cn1Peer(), peer.getComponentAt(0));
+        assertSame(a.cn1Peer(), peer.getComponentAt(2));
+        c.toBack();
+        assertSame(c.cn1Peer(), peer.getComponentAt(0));
+        root.getChildren().remove(b);
+        assertEquals(2, peer.getComponentCount());
+    }
+
+    @Test
+    public void regionSizingHonoursOverrides() {
+        Region r = new Region();
+        r.setPadding(new Insets(1, 2, 3, 4));
+        assertEquals(6, r.prefWidth(-1), 0);
+        assertEquals(4, r.prefHeight(-1), 0);
+        r.setPrefWidth(50);
+        r.setMinWidth(Region.USE_PREF_SIZE);
+        r.setMaxHeight(40);
+        assertEquals(50, r.minWidth(-1), 0);
+        assertEquals(Double.MAX_VALUE, r.maxWidth(-1), 0);
+        assertEquals(40, r.maxHeight(-1), 0);
+        r.autosize();
+        assertEquals(50, r.getWidth(), 0);
+    }
+
+    @Test
+    public void groupBoundsAreTheUnionOfItsChildren() {
+        Region a = box(10, 10);
+        Region b = box(10, 10);
+        b.setLayoutX(30);
+        b.setLayoutY(-5);
+        Group g = new Group(a, b);
+        g.layout();
+        Bounds lb = g.getLayoutBounds();
+        assertEquals(0, lb.getMinX(), 0);
+        assertEquals(-5, lb.getMinY(), 0);
+        assertEquals(40, lb.getWidth(), 0);
+        assertEquals(15, lb.getHeight(), 0);
+        b.setLayoutX(50);
+        assertEquals(60, g.getLayoutBounds().getWidth(), 0);
+    }
+
+    @Test
+    public void coordinatesConvertThroughScaleAndRotation() {
+        Pane root = new Pane();
+        Region child = box(20, 10);
+        child.setLayoutX(100);
+        child.setLayoutY(50);
+        root.getChildren().add(child);
+        root.resize(300, 300);
+        root.layout();
+        Point2D p = child.localToScene(0, 0);
+        assertEquals(100, p.getX(), 1e-9);
+        assertEquals(50, p.getY(), 1e-9);
+        child.setScaleX(2);
+        assertEquals(90, child.localToScene(0, 0).getX(), 1e-9);
+        child.setScaleX(1);
+        child.setRotate(90);
+        Point2D corner = child.localToParent(0, 0);
+        assertEquals(115, corner.getX(), 1e-9);
+        assertEquals(45, corner.getY(), 1e-9);
+        Point2D back = child.sceneToLocal(corner.getX(), corner.getY());
+        assertEquals(0, back.getX(), 1e-9);
+        assertEquals(0, back.getY(), 1e-9);
+        Bounds inParent = child.getBoundsInParent();
+        assertEquals(10, inParent.getWidth(), 1e-9);
+        assertEquals(20, inParent.getHeight(), 1e-9);
+    }
+
+    @Test
+    public void lookupMatchesIdClassTypeAndDescendants() {
+        Pane root = new Pane();
+        Pane inner = new Pane();
+        inner.setId("inner");
+        Region leaf = box(1, 1);
+        leaf.getStyleClass().add("leaf");
+        inner.getChildren().add(leaf);
+        root.getChildren().add(inner);
+        assertSame(inner, root.lookup("#inner"));
+        assertSame(leaf, root.lookup(".leaf"));
+        assertSame(leaf, root.lookup("#inner .leaf"));
+        assertSame(leaf, root.lookup("Region.leaf"));
+        assertNull(root.lookup("#inner #inner"));
+        assertEquals(2, root.lookupAll("Pane").size());
+    }
+
+    @Test
+    public void disableIsInherited() {
+        Pane root = new Pane();
+        Region leaf = box(1, 1);
+        root.getChildren().add(leaf);
+        root.setDisable(true);
+        assertTrue(leaf.isDisabled());
+        assertFalse(leaf.isDisable());
+        assertTrue(leaf.getPseudoClassStates().contains(PseudoClass.getPseudoClass("disabled")));
+        root.setDisable(false);
+        assertFalse(leaf.isDisabled());
+    }
+
+    private static final class Log implements EventHandler<Event> {
+        final List<String> entries;
+        final String name;
+        boolean consume;
+
+        Log(List<String> entries, String name) {
+            this.entries = entries;
+            this.name = name;
+        }
+
+        @Override
+        public void handle(Event event) {
+            entries.add(name + ":" + event.getEventType().getName());
+            if (consume) {
+                event.consume();
+            }
+        }
+    }
+
+    @Test
+    public void mouseEventsCaptureThenBubbleAndFiltersCanConsume() {
+        List<String> log = new ArrayList<String>();
+        Pane root = new Pane();
+        Pane mid = new Pane();
+        mid.setPrefSize(100, 100);
+        Region leaf = box(50, 50);
+        mid.getChildren().add(leaf);
+        root.getChildren().add(mid);
+        Scene scene = new Scene(root, 200, 200);
+        scene.cn1Layout(200, 200);
+        scene.addEventFilter(MouseEvent.MOUSE_PRESSED, new Log(log, "sceneF"));
+        root.addEventFilter(MouseEvent.MOUSE_PRESSED, new Log(log, "rootF"));
+        Log midFilter = new Log(log, "midF");
+        mid.addEventFilter(MouseEvent.MOUSE_PRESSED, midFilter);
+        leaf.addEventHandler(MouseEvent.MOUSE_PRESSED, new Log(log, "leafH"));
+        leaf.setOnMousePressed(new Log(log, "leafOn"));
+        mid.addEventHandler(MouseEvent.MOUSE_PRESSED, new Log(log, "midH"));
+        scene.addEventHandler(MouseEvent.MOUSE_PRESSED, new Log(log, "sceneH"));
+
+        assertFalse(scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 10, 10, MouseButton.PRIMARY));
+        assertEquals("[sceneF:MOUSE_PRESSED, rootF:MOUSE_PRESSED, midF:MOUSE_PRESSED, leafH:MOUSE_PRESSED, "
+                + "leafOn:MOUSE_PRESSED, midH:MOUSE_PRESSED, sceneH:MOUSE_PRESSED]", log.toString());
+        assertTrue(leaf.isPressed());
+        assertTrue(mid.isPressed());
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 10, 10, MouseButton.PRIMARY);
+        assertFalse(leaf.isPressed());
+
+        log.clear();
+        midFilter.consume = true;
+        assertTrue(scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 10, 10, MouseButton.PRIMARY));
+        assertEquals("[sceneF:MOUSE_PRESSED, rootF:MOUSE_PRESSED, midF:MOUSE_PRESSED]", log.toString());
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 10, 10, MouseButton.PRIMARY);
+    }
+
+    @Test
+    public void clickHoverAndLocalCoordinates() {
+        final List<String> log = new ArrayList<String>();
+        Pane root = new Pane();
+        final Region leaf = box(50, 50);
+        leaf.setLayoutX(20);
+        leaf.setLayoutY(30);
+        root.getChildren().add(leaf);
+        Scene scene = new Scene(root, 200, 200);
+        scene.cn1Layout(200, 200);
+        leaf.setOnMouseClicked(new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent e) {
+                log.add("click " + e.getX() + "," + e.getY() + " scene " + e.getSceneX() + " n=" + e.getClickCount()
+                        + " src=" + (e.getSource() == leaf));
+            }
+        });
+        leaf.setOnMouseEntered(new Log(log, "in"));
+        leaf.setOnMouseExited(new Log(log, "out"));
+        root.setOnMouseEntered(new Log(log, "rootIn"));
+        scene.cn1Pointer(MouseEvent.MOUSE_MOVED, 25, 35, MouseButton.NONE);
+        assertTrue(leaf.isHover());
+        assertTrue(root.isHover());
+        assertEquals("[rootIn:MOUSE_ENTERED, in:MOUSE_ENTERED]", log.toString());
+        log.clear();
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 25, 35, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 25, 35, MouseButton.PRIMARY);
+        assertEquals("[click 5.0,5.0 scene 25.0 n=1 src=true]", log.toString());
+        log.clear();
+        scene.cn1Pointer(MouseEvent.MOUSE_MOVED, 150, 150, MouseButton.NONE);
+        assertFalse(leaf.isHover());
+        assertEquals("[out:MOUSE_EXITED]", log.toString());
+
+        log.clear();
+        leaf.setDisable(true);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 25, 35, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 25, 35, MouseButton.PRIMARY);
+        assertTrue(log.toString(), log.isEmpty());
+        leaf.setDisable(false);
+        leaf.setMouseTransparent(true);
+        final boolean[] rootClicked = new boolean[1];
+        root.setOnMouseClicked(new EventHandler<MouseEvent>() {
+            @Override
+            public void handle(MouseEvent e) {
+                rootClicked[0] = true;
+            }
+        });
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 25, 35, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 25, 35, MouseButton.PRIMARY);
+        assertTrue(rootClicked[0]);
+        // The pointer leaves the leaf once it turns transparent; it is
+        // never clicked.
+        assertEquals("[out:MOUSE_EXITED]", log.toString());
+    }
+
+    @Test
+    public void keysGoToTheFocusOwnerAndTabTraverses() {
+        final List<String> log = new ArrayList<String>();
+        Pane root = new Pane();
+        Region a = box(10, 10);
+        Region b = box(10, 10);
+        a.setFocusTraversable(true);
+        b.setFocusTraversable(true);
+        root.getChildren().addAll(a, b);
+        Scene scene = new Scene(root, 100, 100);
+        a.requestFocus();
+        assertTrue(a.isFocused());
+        assertSame(a, scene.getFocusOwner());
+        a.setOnKeyPressed(new EventHandler<KeyEvent>() {
+            @Override
+            public void handle(KeyEvent e) {
+                log.add("a " + e.getCode());
+            }
+        });
+        scene.setOnKeyPressed(new EventHandler<KeyEvent>() {
+            @Override
+            public void handle(KeyEvent e) {
+                log.add("scene " + e.getCode());
+            }
+        });
+        scene.cn1Key(KeyEvent.KEY_PRESSED, KeyCode.A, "a");
+        assertEquals("[a A, scene A]", log.toString());
+        scene.cn1Key(KeyEvent.KEY_PRESSED, KeyCode.TAB, "");
+        assertSame(b, scene.getFocusOwner());
+        assertFalse(a.isFocused());
+        scene.cn1Key(KeyEvent.KEY_PRESSED, KeyCode.TAB, "");
+        assertSame(a, scene.getFocusOwner());
+        root.getChildren().remove(a);
+        assertNull(scene.getFocusOwner());
+    }
+
+    @Test
+    public void stageShowsItsSceneInAFormAndLaysItOut() {
+        Pane root = new Pane();
+        Region child = box(40, 40);
+        root.getChildren().add(child);
+        Stage stage = new Stage();
+        stage.cn1MarkPrimary();
+        stage.setScene(new Scene(root));
+        final List<String> log = new ArrayList<String>();
+        stage.setOnShown(new EventHandler<WindowEvent>() {
+            @Override
+            public void handle(WindowEvent e) {
+                log.add("shown");
+            }
+        });
+        stage.setOnHidden(new EventHandler<WindowEvent>() {
+            @Override
+            public void handle(WindowEvent e) {
+                log.add("hidden");
+            }
+        });
+        boolean implicit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+        try {
+            stage.show();
+            assertTrue(stage.isShowing());
+            assertTrue(javafx.stage.Window.getWindows().contains(stage));
+            assertTrue(Display.getInstance().getCurrent() instanceof StageForm);
+            StageForm form = (StageForm) Display.getInstance().getCurrent();
+            form.revalidate();
+            assertSame(stage, root.getScene().getWindow());
+            assertEquals(Units.toLogical(root.cn1Peer().getWidth()), root.getWidth(), 0.01);
+            assertTrue(root.getWidth() > 0);
+            assertEquals(40, child.getWidth(), 0);
+            assertEquals(80, child.cn1Peer().getWidth());
+            stage.setOnCloseRequest(new EventHandler<WindowEvent>() {
+                @Override
+                public void handle(WindowEvent e) {
+                    e.consume();
+                }
+            });
+            assertFalse(stage.cn1CloseRequested());
+            assertTrue(stage.isShowing());
+            stage.setOnCloseRequest(null);
+            assertTrue(stage.cn1CloseRequested());
+            assertFalse(stage.isShowing());
+            assertEquals("[shown, hidden]", log.toString());
+        } finally {
+            Platform.setImplicitExit(implicit);
+        }
+    }
+
+    @Test
+    public void lifecycleDrivesTheApplication() {
+        final List<String> log = new ArrayList<String>();
+        final Application app = new Application() {
+            @Override
+            public void init() {
+                log.add("init");
+            }
+
+            @Override
+            public void start(Stage primaryStage) {
+                log.add("start primary=" + primaryStage.cn1IsPrimary() + " fx=" + Platform.isFxApplicationThread());
+            }
+
+            @Override
+            public void stop() {
+                log.add("stop");
+            }
+        };
+        FxLifecycle lifecycle = new FxLifecycle() {
+            @Override
+            protected Application createApplication() {
+                return app;
+            }
+        };
+        lifecycle.runApp();
+        assertSame(app, lifecycle.getApplication());
+        assertNotNull(lifecycle.getPrimaryStage());
+        lifecycle.destroy();
+        lifecycle.destroy();
+        assertEquals("[init, start primary=true fx=true, stop]", log.toString());
+        com.codename1.fxcompat.runtime.StageHosts.setExitHook(null);
+    }
+
+    @Test
+    public void buttonFiresActionFromItsNativeComponent() {
+        Button button = new Button("Go");
+        final int[] fired = new int[1];
+        button.setOnAction(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent e) {
+                fired[0]++;
+            }
+        });
+        Component nativeButton = button.cn1Native();
+        assertTrue(nativeButton instanceof com.codename1.ui.Button);
+        assertEquals("Go", ((com.codename1.ui.Button) nativeButton).getText());
+        assertTrue(button.prefWidth(-1) > 0);
+        ((com.codename1.ui.Button) nativeButton).pressed();
+        ((com.codename1.ui.Button) nativeButton).released();
+        assertEquals(1, fired[0]);
+        button.setText("Longer text");
+        assertEquals("Longer text", ((com.codename1.ui.Button) nativeButton).getText());
+        button.setDisable(true);
+        assertFalse(nativeButton.isEnabled());
+        button.fire();
+        assertEquals(1, fired[0]);
+        Label label = new Label("x");
+        assertFalse(label.isFocusTraversable());
+        assertEquals("Label", label.getTypeSelector());
+    }
+
+    @Test
+    public void styleTargetAppliesAndRestores() {
+        Region r = new Region();
+        r.setOpacity(0.5);
+        assertTrue(r.cn1ApplyStyle("-fx-opacity", Double.valueOf(0.25)));
+        assertEquals(0.25, r.getOpacity(), 0);
+        assertTrue(r.cn1ApplyStyle("-fx-opacity", Double.valueOf(0.75)));
+        assertTrue(r.cn1ApplyStyle("-fx-opacity", null));
+        assertEquals(0.5, r.getOpacity(), 0);
+        assertFalse(r.cn1ApplyStyle("-fx-no-such-thing", "x"));
+        assertFalse(r.cn1ApplyStyle("-fx-opacity", "not a number"));
+        assertEquals(0.5, r.getOpacity(), 0);
+
+        Background own = new Background(new BackgroundFill(Color.RED, new CornerRadii(3), Insets.EMPTY));
+        r.setBackground(own);
+        assertTrue(r.cn1ApplyStyle("-fx-background-color", Color.BLUE));
+        assertTrue(r.cn1ApplyStyle("-fx-background-radius", Double.valueOf(8)));
+        BackgroundFill styled = r.getBackground().getFills().get(0);
+        assertEquals(Color.BLUE, styled.getFill());
+        assertEquals(8, styled.getRadii().getTopLeftHorizontalRadius(), 0);
+        assertTrue(r.cn1ApplyStyle("-fx-background-color", null));
+        assertEquals(Color.RED, r.getBackground().getFills().get(0).getFill());
+        assertTrue(r.cn1ApplyStyle("-fx-background-radius", null));
+        assertEquals(own, r.getBackground());
+
+        assertTrue(r.cn1ApplyStyle("-fx-border-color", Color.BLACK));
+        assertTrue(r.cn1ApplyStyle("-fx-border-width", Double.valueOf(2)));
+        assertEquals(2, r.getInsets().getLeft(), 0);
+        assertTrue(r.cn1ApplyStyle("-fx-border-style", "dashed"));
+        assertTrue(r.cn1ApplyStyle("-fx-padding", new Insets(5)));
+        assertEquals(7, r.getInsets().getTop(), 0);
+        assertTrue(r.cn1ApplyStyle("-fx-border-color", null));
+        assertNull(r.getBorder());
+
+        Label label = new Label("t");
+        assertTrue(label.cn1ApplyStyle("-fx-text-fill", Color.GREEN));
+        assertEquals(Color.GREEN, label.getTextFill());
+        assertTrue(label.cn1ApplyStyle("-fx-font-size", Double.valueOf(20)));
+        assertEquals(20, label.getFont().getSize(), 0);
+        assertTrue(label.cn1ApplyStyle("-fx-font-size", null));
+        assertTrue(label.cn1ApplyStyle("-fx-text-fill", null));
+        assertEquals(Color.BLACK, label.getTextFill());
+    }
+
+    @Test
+    public void styleEngineIsToldWhenANodeMayHaveChanged() {
+        final List<String> log = new ArrayList<String>();
+        StyleEngine.setInstance(new StyleEngine() {
+            @Override
+            public void restyle(Node node) {
+                log.add(node.getTypeSelector() + (node.getId() == null ? "" : "#" + node.getId()));
+            }
+        });
+        Pane root = new Pane();
+        Region leaf = box(1, 1);
+        leaf.setId("leaf");
+        leaf.getStyleClass().add("ignored-outside-a-scene");
+        root.getChildren().add(leaf);
+        assertTrue(log.isEmpty());
+        Scene scene = new Scene(root, 10, 10);
+        assertEquals("[Pane, Region#leaf]", log.toString());
+        log.clear();
+        leaf.getStyleClass().add("x");
+        leaf.pseudoClassStateChanged(PseudoClass.getPseudoClass("selected"), true);
+        leaf.pseudoClassStateChanged(PseudoClass.getPseudoClass("selected"), true);
+        leaf.setStyle("-fx-opacity: 0.5");
+        leaf.setId("other");
+        assertEquals("[Region#leaf, Region#leaf, Region#leaf, Region#other]", log.toString());
+        log.clear();
+        scene.getStylesheets().add("app.css");
+        assertEquals("[Pane, Region#other]", log.toString());
+    }
+
+    /// A JavaFX window is light grey behind its controls: the standard
+    /// theme gives the root of a scene the theme's background colour. The
+    /// layer left a root with no background, and the white fill of the
+    /// scene showed instead. A group has no background, a pane that is
+    /// not the root none either, and a sheet's own rule wins.
+    @Test
+    public void theRootRegionOfASceneHasTheBackgroundOfTheTheme() {
+        javafx.scene.layout.Pane inner = new javafx.scene.layout.Pane();
+        javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane(inner);
+        javafx.scene.Scene scene = new javafx.scene.Scene(root, 200, 100);
+        scene.cn1Layout(200, 100);
+        assertNotNull(root.getBackground());
+        assertEquals(Color.web("#f4f4f4").toString(),
+                root.getBackground().getFills().get(0).getFill().toString());
+        assertNull(inner.getBackground());
+
+        javafx.scene.layout.StackPane styled = new javafx.scene.layout.StackPane();
+        styled.setStyle("-fx-background-color: red;");
+        javafx.scene.Scene other = new javafx.scene.Scene(styled, 200, 100);
+        other.cn1Layout(200, 100);
+        assertEquals(Color.RED, styled.getBackground().getFills().get(0).getFill());
+
+        // No longer the root, no longer grey.
+        scene.setRoot(new javafx.scene.Group());
+        javafx.scene.layout.StackPane holder = new javafx.scene.layout.StackPane(root);
+        javafx.scene.Scene third = new javafx.scene.Scene(holder, 200, 100);
+        third.cn1Layout(200, 100);
+        assertNull(root.getBackground());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ScreenSpaceClipTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ScreenSpaceClipTest.java
new file mode 100644
index 00000000000..16d385d21bd
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ScreenSpaceClipTest.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+
+import javafx.scene.Group;
+import javafx.scene.Scene;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.transform.Scale;
+import javafx.stage.Stage;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/// What is inside a scaled parent is painted on a port that keeps its clip
+/// in the coordinates of the screen while a matrix is installed, which is
+/// what the native Linux port does. Codename One paints a child only where
+/// its bounds meet the clip; there the two are in different spaces, and
+/// 2048, whose whole scene is one scaled group, lost everything but the
+/// board.
+public class ScreenSpaceClipTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<Paint> filled = new ArrayList<Paint>();
+    private Graphics target;
+    private int[] clipAtRed;
+    private double[] redLands;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+        HeadlessImplementation.trackClip = true;
+        HeadlessImplementation.screenSpaceClip = true;
+        HeadlessImplementation.drawnText.clear();
+    }
+
+    @After
+    public void tearDown() {
+        Renderer.setTrace(null);
+        HeadlessImplementation.screenSpaceClip = false;
+        HeadlessImplementation.trackClip = false;
+        List<javafx.stage.Window> open = new ArrayList<javafx.stage.Window>(javafx.stage.Window.getWindows());
+        for (int i = 0; i < open.size(); i++) {
+            open.get(i).hide();
+        }
+        Units.setScale(0);
+    }
+
+    private Graphics paint() {
+        filled.clear();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                if ("fill".equals(operation)) {
+                    filled.add(paint);
+                    if (paint == Color.RED && target != null) {
+                        // The clip as the port has it, without the translation
+                        // the graphics adds to what it is given.
+                        clipAtRed = new int[] {target.getClipX() + target.getTranslateX(),
+                            target.getClipY() + target.getTranslateY(), target.getClipWidth(),
+                            target.getClipHeight()};
+                        // And where the port puts the middle of what is drawn.
+                        redLands = HeadlessImplementation.onScreen(
+                                (deviceBounds[0] + deviceBounds[2]) / 2 + target.getTranslateX(),
+                                (deviceBounds[1] + deviceBounds[3]) / 2 + target.getTranslateY());
+                    }
+                }
+            }
+        });
+        Form f = Display.getInstance().getCurrent();
+        f.revalidate();
+        Graphics g = Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT).getGraphics();
+        target = g;
+        clipAtRed = null;
+        redLands = null;
+        g.setClip(0, 0, HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+        f.paintComponent(g);
+        Renderer.setTrace(null);
+        return g;
+    }
+
+    /// The red square is 1500 pixels along in the coordinates of the group
+    /// that holds it, beyond the 1080 of the screen, and at half size it is
+    /// drawn at 750: on the screen, and outside the clip only for whoever
+    /// compares the two numbers as they are.
+    @Test
+    public void aChildOfAScaledParentThatLandsOnTheScreenIsPainted() {
+        Rectangle near = new Rectangle(10, 10, 40, 40);
+        near.setFill(Color.BLUE);
+        Rectangle far = new Rectangle(1500, 10, 100, 100);
+        far.setFill(Color.RED);
+        Group inner = new Group(near, far);
+        Group scaled = new Group(inner);
+        scaled.getTransforms().add(new Scale(0.5, 0.5, 0, 0));
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(scaled), 1000, 400));
+        stage.show();
+
+        // The first class to run in a JVM is not on the event dispatch thread
+        // yet, and the form is then shown from the queue.
+        MainThreadRule.drain();
+
+        Graphics g = paint();
+        assertTrue(filled.contains(Color.BLUE));
+        assertTrue("a child that lands on the screen under its parent's scale was culled",
+                filled.contains(Color.RED));
+        // The widened clip is the scaled parent's own business: what paints
+        // after it has the clip it had.
+        assertEquals(0, g.getClipX());
+        assertEquals(0, g.getClipY());
+        assertEquals(HeadlessImplementation.WIDTH, g.getClipWidth());
+        assertEquals(HeadlessImplementation.HEIGHT, g.getClipHeight());
+    }
+
+    /// The text of a label inside a scaled and moved parent is drawn: the
+    /// number on a tile of 2048, and its score. A JavaFX label is shown by a
+    /// Codename One one, which narrows the clip to its text with numbers it
+    /// reads back from the port; under a matrix those are the screen's, and
+    /// the text was drawn outside the clip it had just made.
+    @Test
+    public void theTextOfALabelUnderAScaledParentIsInsideItsClip() {
+        javafx.scene.control.Label tile = new javafx.scene.control.Label("2048");
+        tile.setLayoutX(900);
+        tile.setLayoutY(300);
+        tile.setPrefSize(200, 100);
+        javafx.scene.layout.VBox box = new javafx.scene.layout.VBox(new javafx.scene.control.Label("score"));
+        box.setLayoutX(1300);
+        box.setLayoutY(40);
+        Group scaled = new Group(new Group(tile, box));
+        scaled.getTransforms().add(new Scale(0.5, 0.5, 0, 0));
+        scaled.setLayoutX(150);
+        scaled.setLayoutY(60);
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(scaled), 1000, 400));
+        stage.show();
+        MainThreadRule.drain();
+
+        HeadlessImplementation.drawnText.clear();
+        HeadlessImplementation.recordText = true;
+        try {
+            paint();
+        } finally {
+            HeadlessImplementation.recordText = false;
+        }
+        List<String> seen = new ArrayList<String>();
+        List<String> cut = new ArrayList<String>();
+        for (Object[] text : HeadlessImplementation.drawnText) {
+            (Boolean.TRUE.equals(text[3]) ? seen : cut).add(String.valueOf(text[0]));
+        }
+        assertTrue("drawn outside the clip: " + cut, cut.isEmpty());
+        assertTrue("the tile: " + seen, seen.contains("2048"));
+        assertTrue("the score: " + seen, seen.contains("score"));
+    }
+
+    /// A node with a clip of its own, which is what every label is. The clip
+    /// that holds while it draws has to be where the port draws it: the
+    /// layer used to read the clip back, in the coordinates of the screen,
+    /// and hand it to the port again as if it were in those of the group.
+    /// That put it through the matrix twice, and the text of every tile of
+    /// 2048 was cut away.
+    @Test
+    public void aClippedNodeUnderAScaledParentKeepsItsClipWhereItLands() {
+        Rectangle far = new Rectangle(1500, 10, 100, 100);
+        far.setFill(Color.RED);
+        far.setClip(new Rectangle(1500, 10, 100, 100));
+        Group scaled = new Group(new Group(far));
+        scaled.getTransforms().add(new Scale(0.5, 0.5, 0, 0));
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(scaled), 1000, 400));
+        stage.show();
+        MainThreadRule.drain();
+
+        paint();
+        assertTrue(filled.contains(Color.RED));
+        assertTrue("clip " + java.util.Arrays.toString(clipAtRed) + " does not hold what is drawn at "
+                + java.util.Arrays.toString(redLands),
+                clipAtRed != null && clipAtRed[0] <= redLands[0] && clipAtRed[0] + clipAtRed[2] >= redLands[0]
+                        && clipAtRed[1] <= redLands[1] && clipAtRed[1] + clipAtRed[3] >= redLands[1]);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShadowEffectTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShadowEffectTest.java
new file mode 100644
index 00000000000..eb299e74b50
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShadowEffectTest.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Effects;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import java.util.ArrayList;
+import java.util.List;
+import javafx.scene.Group;
+import javafx.scene.Scene;
+import javafx.scene.effect.BlurType;
+import javafx.scene.effect.DropShadow;
+import javafx.scene.effect.Effect;
+import javafx.scene.effect.Glow;
+import javafx.scene.effect.InnerShadow;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+import javafx.stage.Stage;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+/// A drop shadow and an inner shadow are drawn: the pixels of each, and
+/// that a node's peer draws the picture and keeps it between paints.
+public class ShadowEffectTest {
+
+    private static final int W = 24;
+    private static final int H = 24;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(1);
+    }
+
+    @After
+    public void tearDown() {
+        HeadlessImplementation.recordDraws = false;
+        HeadlessImplementation.draws.clear();
+        List<javafx.stage.Window> open = new ArrayList<javafx.stage.Window>(javafx.stage.Window.getWindows());
+        for (int i = 0; i < open.size(); i++) {
+            open.get(i).hide();
+        }
+        Units.setScale(0);
+    }
+
+    /// An opaque red square from 8 to 15 on a transparent picture.
+    private static int[] square() {
+        int[] p = new int[W * H];
+        for (int y = 8; y < 16; y++) {
+            for (int x = 8; x < 16; x++) {
+                p[y * W + x] = 0xffff0000;
+            }
+        }
+        return p;
+    }
+
+    private static int alpha(int[] p, int x, int y) {
+        return p[y * W + x] >>> 24;
+    }
+
+    @Test
+    public void aDropShadowIsTheOutlineBlurredInTheShadowsColour() {
+        int[] s = Effects.dropShadow(square(), W, H, 3, 3, 0, 0xff102030);
+        for (int i = 0; i < s.length; i++) {
+            assertEquals("the colour of pixel " + i, 0x102030, s[i] & 0xffffff);
+        }
+        assertTrue("dense under the middle: " + alpha(s, 11, 11), alpha(s, 11, 11) > 200);
+        int justOutside = alpha(s, 6, 11);
+        assertTrue("soft beyond the edge: " + justOutside, justOutside > 10 && justOutside < 200);
+        assertTrue("fading with distance", alpha(s, 5, 11) < justOutside && alpha(s, 7, 11) > justOutside);
+        assertEquals("nothing past the radius", 0, alpha(s, 2, 11));
+        assertEquals("nothing in the corner", 0, alpha(s, 0, 0));
+        // The same on every side.
+        assertEquals(alpha(s, 6, 11), alpha(s, 17, 12));
+        assertEquals(alpha(s, 6, 11), alpha(s, 11, 6));
+        assertEquals(alpha(s, 6, 11), alpha(s, 12, 17));
+    }
+
+    @Test
+    public void aSpreadStrengthensAndAColoursAlphaWeakensTheShadow() {
+        int[] plain = Effects.dropShadow(square(), W, H, 3, 3, 0, 0xff000000);
+        int[] spread = Effects.dropShadow(square(), W, H, 3, 3, 0.5, 0xff000000);
+        int[] faint = Effects.dropShadow(square(), W, H, 3, 3, 0, 0x80000000);
+        assertTrue(alpha(spread, 6, 11) >= 2 * alpha(plain, 6, 11) - 1);
+        assertEquals(255, alpha(spread, 11, 11));
+        assertTrue(alpha(faint, 11, 11) <= 128 && alpha(faint, 11, 11) > 100);
+        // No radius: the outline itself, hard.
+        int[] hard = Effects.dropShadow(square(), W, H, 0, 3, 0, 0xff000000);
+        assertEquals(255, alpha(hard, 8, 8));
+        assertEquals(0, alpha(hard, 7, 8));
+    }
+
+    @Test
+    public void oneBoxPassIsAFlatAverage() {
+        int[] s = Effects.dropShadow(square(), W, H, 2, 1, 0, 0xff000000);
+        // A box of five by five around (7, 11) covers one column of the
+        // square in all five rows: a fifth.
+        assertEquals(255 / 5, alpha(s, 6, 11));
+        assertEquals(0, alpha(s, 5, 11));
+    }
+
+    @Test
+    public void anInnerShadowDarkensTheEdgeInsideAndNothingOutside() {
+        int[] s = Effects.innerShadow(square(), W, H, 2, 3, 0, 0xff000000, 0, 0);
+        assertEquals("nothing where the node is not", 0, alpha(s, 7, 11));
+        assertEquals(0, alpha(s, 0, 0));
+        assertTrue("dark at the edge: " + alpha(s, 8, 11), alpha(s, 8, 11) > 80);
+        assertTrue("lighter further in", alpha(s, 10, 11) < alpha(s, 8, 11));
+        assertEquals("clear in the middle of a large enough node", 0, alpha(s, 11, 11) > 40 ? 1 : 0);
+        // Moved right, the shadow falls from the left edge.
+        int[] moved = Effects.innerShadow(square(), W, H, 1, 1, 0, 0xff000000, 3, 0);
+        assertTrue(alpha(moved, 9, 11) > 200);
+        assertTrue(alpha(moved, 15, 11) < alpha(moved, 9, 11));
+    }
+
+    private static int images() {
+        int n = 0;
+        for (int i = 0; i < HeadlessImplementation.draws.size(); i++) {
+            if ("drawImage".equals(HeadlessImplementation.draws.get(i)[0])) {
+                n++;
+            }
+        }
+        return n;
+    }
+
+    private static int paint() {
+        HeadlessImplementation.draws.clear();
+        HeadlessImplementation.recordDraws = true;
+        Form f = Display.getInstance().getCurrent();
+        f.revalidate();
+        f.paintComponent(Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT).getGraphics());
+        HeadlessImplementation.recordDraws = false;
+        return images();
+    }
+
+    @Test
+    public void aNodeDrawsItsShadowAndKeepsThePictureUntilSomethingUnderItChanges() {
+        Rectangle inside = new Rectangle(5, 5, 30, 30);
+        inside.setFill(Color.RED);
+        Pane card = new Pane(inside);
+        card.resizeRelocate(40, 40, 100, 60);
+        Rectangle plain = new Rectangle(200, 10, 20, 20);
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(card, plain), 300, 200));
+        stage.show();
+        int without = paint();
+
+        card.setEffect(new DropShadow(BlurType.GAUSSIAN, Color.BLACK, 6, 0, 2, 3));
+        int made = Effects.captureCount();
+        assertEquals("one picture more is drawn, the shadow", without + 1, paint());
+        assertEquals("the node was painted once to make it", made + 1, Effects.captureCount());
+        assertEquals(without + 1, paint());
+        assertEquals("and not again for a second paint", made + 1, Effects.captureCount());
+
+        // Something inside the node changed: its outline may have.
+        inside.setWidth(50);
+        paint();
+        assertEquals(made + 2, Effects.captureCount());
+        // A value of the effect changed.
+        ((DropShadow) card.getEffect()).setRadius(9);
+        paint();
+        assertEquals(made + 3, Effects.captureCount());
+        // An unrelated node does not disturb it.
+        plain.setFill(Color.GREEN);
+        paint();
+        assertEquals(made + 3, Effects.captureCount());
+
+        // Both at once: one behind and one over.
+        InnerShadow inner = new InnerShadow(4, Color.BLUE);
+        inner.setInput(new DropShadow(5, Color.GRAY));
+        card.setEffect(inner);
+        assertEquals(without + 2, paint());
+
+        // An effect that is not drawn costs nothing, and none restores.
+        card.setEffect(new Glow(0.5));
+        assertEquals(without, paint());
+        card.setEffect(null);
+        assertEquals(without, paint());
+        assertNull(card.cn1EffectCache());
+    }
+
+    @Test
+    public void aStyleSheetsEffectIsADropShadowOrAnInnerShadow() {
+        Pane card = new Pane();
+        Stage stage = new Stage();
+        stage.setScene(new Scene(new Group(card), 300, 200));
+        stage.show();
+        card.setStyle("-fx-effect: dropshadow( three-pass-box , rgba(0,0,0,0.5) , 10, 0.25 , 2 , 4 );");
+        card.applyCss();
+        Effect e = card.getEffect();
+        assertTrue(String.valueOf(e), e instanceof DropShadow);
+        DropShadow d = (DropShadow) e;
+        assertEquals(10, d.getRadius(), 0);
+        assertEquals(0.25, d.getSpread(), 0);
+        assertEquals(2, d.getOffsetX(), 0);
+        assertEquals(4, d.getOffsetY(), 0);
+        assertEquals(0.5, d.getColor().getOpacity(), 0.01);
+        assertEquals(BlurType.THREE_PASS_BOX, d.getBlurType());
+
+        card.setStyle("-fx-effect: innershadow(one-pass-box, derive(#804020, -20%), 3, 0, 0, 1);");
+        card.applyCss();
+        assertTrue(card.getEffect() instanceof InnerShadow);
+        assertEquals(BlurType.ONE_PASS_BOX, ((InnerShadow) card.getEffect()).getBlurType());
+
+        card.setStyle("");
+        card.applyCss();
+        assertNull("the effect goes with the style", card.getEffect());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShapeTransitionTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShapeTransitionTest.java
new file mode 100644
index 00000000000..4c4cf356b79
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShapeTransitionTest.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.FrameClock;
+
+import javafx.animation.Animation;
+import javafx.animation.FillTransition;
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.ParallelTransition;
+import javafx.animation.PathTransition;
+import javafx.animation.ScaleTransition;
+import javafx.animation.SequentialTransition;
+import javafx.animation.StrokeTransition;
+import javafx.animation.Timeline;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.Stop;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Line;
+import javafx.scene.shape.LineTo;
+import javafx.scene.shape.MoveTo;
+import javafx.scene.shape.Path;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Duration;
+
+/// The transitions of a shape, and the animation of a game move as the
+/// game writes it, on the manual frame clock: every frame has a stated
+/// time, so what is expected is exact.
+public class ShapeTransitionTest {
+
+    private static final double EXACT = 1e-9;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> log = new ArrayList<String>();
+
+    @BeforeClass
+    public static void display() {
+        HeadlessImplementation.install();
+    }
+
+    @Before
+    public void setUp() {
+        FrameClock.reset();
+        FrameClock.setManual(true);
+    }
+
+    @After
+    public void tearDown() {
+        FrameClock.reset();
+    }
+
+    private static Duration ms(double millis) {
+        return Duration.millis(millis);
+    }
+
+    private static long now() {
+        return FrameClock.nowNanos() / 1000000L;
+    }
+
+    private static void assertColor(Color expected, Color actual) {
+        assertEquals(expected.getRed(), actual.getRed(), EXACT);
+        assertEquals(expected.getGreen(), actual.getGreen(), EXACT);
+        assertEquals(expected.getBlue(), actual.getBlue(), EXACT);
+        assertEquals(expected.getOpacity(), actual.getOpacity(), EXACT);
+    }
+
+    @Test
+    public void fillGoesFromOneColourToTheOther() {
+        Rectangle r = new Rectangle(10, 10, Color.GREEN);
+        FillTransition fill = new FillTransition(ms(1000), r, Color.BLACK, Color.WHITE);
+        fill.setInterpolator(Interpolator.LINEAR);
+        assertSame(r, fill.getShape());
+        assertEquals(ms(1000), fill.getCycleDuration());
+        fill.play();
+        FrameClock.advance(250);
+        assertColor(Color.color(0.25, 0.25, 0.25), (Color) r.getFill());
+        FrameClock.advance(750);
+        // The end is the colour asked for itself.
+        assertSame(Color.WHITE, r.getFill());
+        assertEquals(Animation.Status.STOPPED, fill.getStatus());
+    }
+
+    @Test
+    public void fillStartsAtWhatTheShapeHasAndEases() {
+        Rectangle r = new Rectangle(10, 10, Color.color(0, 0, 0, 0));
+        FillTransition fill = new FillTransition(ms(1000), r);
+        fill.setToValue(Color.color(1, 0, 0, 1));
+        assertSame(Interpolator.EASE_BOTH, fill.getInterpolator());
+        fill.play();
+        FrameClock.advance(100);
+        // A tenth of the way in the eased curve has covered 3.125 * 0.1 * 0.1.
+        assertColor(Color.color(0.03125, 0, 0, 0.03125), (Color) r.getFill());
+        FrameClock.advance(400);
+        assertColor(Color.color(0.5, 0, 0, 0.5), (Color) r.getFill());
+    }
+
+    @Test
+    public void aFillThatIsNoColourIsLeftAlone() {
+        LinearGradient gradient = new LinearGradient(0, 0, 1, 0, true, null, new Stop(0, Color.RED),
+                new Stop(1, Color.BLUE));
+        Rectangle r = new Rectangle(10, 10);
+        r.setFill(gradient);
+        FillTransition fill = new FillTransition(ms(100), r);
+        fill.setToValue(Color.WHITE);
+        fill.play();
+        FrameClock.advance(50);
+        assertSame(gradient, r.getFill());
+        FrameClock.advance(50);
+        assertSame(gradient, r.getFill());
+        // Neither end given: nothing to do.
+        r.setFill(Color.RED);
+        FillTransition none = new FillTransition(ms(100), r);
+        none.play();
+        FrameClock.advance(100);
+        assertSame(Color.RED, r.getFill());
+    }
+
+    @Test
+    public void strokeGoesFromOneColourToTheOtherAndBack() {
+        Circle c = new Circle(10);
+        c.setStroke(Color.BLACK);
+        StrokeTransition stroke = new StrokeTransition(ms(200), c, Color.BLACK, Color.WHITE);
+        stroke.setInterpolator(Interpolator.LINEAR);
+        stroke.setCycleCount(2);
+        stroke.setAutoReverse(true);
+        stroke.play();
+        FrameClock.advance(100);
+        assertColor(Color.color(0.5, 0.5, 0.5), (Color) c.getStroke());
+        FrameClock.advance(150);
+        assertColor(Color.color(0.75, 0.75, 0.75), (Color) c.getStroke());
+        FrameClock.advance(150);
+        assertSame(Color.BLACK, c.getStroke());
+        assertEquals(Animation.Status.STOPPED, stroke.getStatus());
+    }
+
+    @Test
+    public void aShapeTransitionInAParallelOneAnimatesItsShape() {
+        Rectangle r = new Rectangle(10, 10, Color.BLACK);
+        FillTransition fill = new FillTransition(ms(100));
+        fill.setToValue(Color.WHITE);
+        fill.setInterpolator(Interpolator.LINEAR);
+        ParallelTransition both = new ParallelTransition(r, fill);
+        both.play();
+        FrameClock.advance(50);
+        assertColor(Color.color(0.5, 0.5, 0.5), (Color) r.getFill());
+        FrameClock.advance(50);
+        assertSame(Color.WHITE, r.getFill());
+    }
+
+    @Test
+    public void aNodeFollowsALineByItsCentre() {
+        Rectangle r = new Rectangle(20, 10);
+        Line line = new Line(100, 50, 300, 50);
+        PathTransition along = new PathTransition(ms(1000), line, r);
+        along.setInterpolator(Interpolator.LINEAR);
+        assertSame(PathTransition.OrientationType.NONE, along.getOrientation());
+        along.play();
+        FrameClock.advance(0);
+        assertEquals(100 - 10, r.getTranslateX(), EXACT);
+        assertEquals(50 - 5, r.getTranslateY(), EXACT);
+        FrameClock.advance(250);
+        assertEquals(150 - 10, r.getTranslateX(), EXACT);
+        FrameClock.advance(750);
+        assertEquals(300 - 10, r.getTranslateX(), EXACT);
+        assertEquals(50 - 5, r.getTranslateY(), EXACT);
+        assertEquals(0, r.getRotate(), EXACT);
+    }
+
+    @Test
+    public void aNodeFollowsACornerAtAnEvenSpeedAndTurnsWithIt() {
+        Rectangle r = new Rectangle(10, 10);
+        Path path = new Path(new MoveTo(0, 0), new LineTo(100, 0), new LineTo(100, 300));
+        PathTransition along = new PathTransition(ms(400), path, r);
+        along.setInterpolator(Interpolator.LINEAR);
+        along.setOrientation(PathTransition.OrientationType.ORTHOGONAL_TO_TANGENT);
+        along.play();
+        // 400 units in 400 ms: one unit a millisecond, whatever the leg.
+        FrameClock.advance(50);
+        assertEquals(50 - 5, r.getTranslateX(), EXACT);
+        assertEquals(-5, r.getTranslateY(), EXACT);
+        assertEquals(0, r.getRotate(), EXACT);
+        FrameClock.advance(150);
+        assertEquals(100 - 5, r.getTranslateX(), EXACT);
+        assertEquals(100 - 5, r.getTranslateY(), EXACT);
+        assertEquals(90, r.getRotate(), 1e-6);
+        FrameClock.advance(200);
+        assertEquals(300 - 5, r.getTranslateY(), EXACT);
+        assertEquals(Animation.Status.STOPPED, along.getStatus());
+    }
+
+    @Test
+    public void aCurveIsFollowedWithinATenthOfAPixel() {
+        Rectangle r = new Rectangle(0, 0);
+        Circle circle = new Circle(100, 100, 50);
+        PathTransition along = new PathTransition(ms(1000), circle, r);
+        along.setInterpolator(Interpolator.LINEAR);
+        along.play();
+        for (int i = 0; i < 10; i++) {
+            FrameClock.advance(100);
+            double dx = r.getTranslateX() - 100;
+            double dy = r.getTranslateY() - 100;
+            assertEquals(50, Math.sqrt(dx * dx + dy * dy), 0.11);
+        }
+    }
+
+    /// One move of a sliding tile game as such a game writes it: every
+    /// tile slides for 65 ms, then the new tile grows for 125 ms while a
+    /// merged one swells and settles in two steps of 80 ms. What matters
+    /// is that every stage ends exactly on its end value and on time, with
+    /// frames 16 ms apart that never land on a boundary.
+    @Test
+    public void aGameMoveSlidesThenGrowsAndEndsOnItsValues() {
+        final Rectangle slider = new Rectangle(10, 10);
+        final Rectangle born = new Rectangle(10, 10);
+        final Rectangle merged = new Rectangle(10, 10);
+        born.setScaleX(0);
+        born.setScaleY(0);
+        Timeline slide = new Timeline(new KeyFrame(ms(65),
+                new KeyValue(slider.layoutXProperty(), 396, Interpolator.EASE_OUT),
+                new KeyValue(slider.layoutYProperty(), 132, Interpolator.EASE_OUT)));
+        final ScaleTransition grow = new ScaleTransition(ms(125), born);
+        grow.setToX(1.0);
+        grow.setToY(1.0);
+        grow.setInterpolator(Interpolator.EASE_OUT);
+        grow.setOnFinished(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                log.add("grown@" + now());
+            }
+        });
+        ScaleTransition up = new ScaleTransition(ms(80), merged);
+        up.setToX(1.2);
+        up.setToY(1.2);
+        up.setInterpolator(Interpolator.EASE_IN);
+        ScaleTransition down = new ScaleTransition(ms(80), merged);
+        down.setToX(1.0);
+        down.setToY(1.0);
+        down.setInterpolator(Interpolator.EASE_OUT);
+        final SequentialTransition pop = new SequentialTransition(up, down);
+        pop.setOnFinished(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                log.add("popped@" + now());
+            }
+        });
+        final ParallelTransition after = new ParallelTransition(grow, pop);
+        slide.setOnFinished(new EventHandler<ActionEvent>() {
+            @Override
+            public void handle(ActionEvent event) {
+                log.add("slid@" + now());
+                after.play();
+            }
+        });
+        long start = now();
+        slide.play();
+        double last = 0;
+        double peak = 0;
+        for (int t = 16; t <= 320; t += 16) {
+            FrameClock.advance(16);
+            // A slide only ever moves forward.
+            assertEquals(true, slider.getLayoutX() >= last);
+            last = slider.getLayoutX();
+            peak = Math.max(peak, merged.getScaleX());
+        }
+        assertEquals(396, slider.getLayoutX(), EXACT);
+        assertEquals(132, slider.getLayoutY(), EXACT);
+        assertEquals(1.0, born.getScaleX(), EXACT);
+        assertEquals(1.0, born.getScaleY(), EXACT);
+        assertEquals(1.0, merged.getScaleX(), EXACT);
+        assertEquals(true, peak > 1.15);
+        // The slide is over on the first frame at or after 65 ms, the growth 125 ms
+        // after that frame and the pop 160 ms after it, each on the next frame.
+        assertEquals("[slid@" + (start + 80) + ", grown@" + (start + 80 + 128) + ", popped@" + (start + 80 + 160) + "]",
+                log.toString());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShapesTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShapesTest.java
new file mode 100644
index 00000000000..b09b14e4581
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/ShapesTest.java
@@ -0,0 +1,600 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.Bounds;
+import javafx.geometry.Rectangle2D;
+import javafx.geometry.VPos;
+import javafx.scene.Node;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Arc;
+import javafx.scene.shape.ArcTo;
+import javafx.scene.shape.ArcType;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.ClosePath;
+import javafx.scene.shape.CubicCurve;
+import javafx.scene.shape.CubicCurveTo;
+import javafx.scene.shape.Ellipse;
+import javafx.scene.shape.FillRule;
+import javafx.scene.shape.HLineTo;
+import javafx.scene.shape.Line;
+import javafx.scene.shape.LineTo;
+import javafx.scene.shape.MoveTo;
+import javafx.scene.shape.Path;
+import javafx.scene.shape.Polygon;
+import javafx.scene.shape.Polyline;
+import javafx.scene.shape.QuadCurve;
+import javafx.scene.shape.QuadCurveTo;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.shape.Shape;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.shape.StrokeLineJoin;
+import javafx.scene.shape.StrokeType;
+import javafx.scene.shape.VLineTo;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+
+/// Shapes, text and image views: their bounds, what counts as inside
+/// them and what they hand the renderer.
+public class ShapesTest {
+
+    private static final double CURVE = 0.1;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> drawn = new ArrayList<String>();
+    private final List<double[]> drawnBounds = new ArrayList<double[]>();
+    private final List<Paint> drawnPaint = new ArrayList<Paint>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        Renderer.setTrace(null);
+        HeadlessImplementation.pixelImages = false;
+    }
+
+    private static void box(double x, double y, double w, double h, Bounds b, double eps) {
+        assertEquals("minX", x, b.getMinX(), eps);
+        assertEquals("minY", y, b.getMinY(), eps);
+        assertEquals("width", w, b.getWidth(), eps);
+        assertEquals("height", h, b.getHeight(), eps);
+    }
+
+    private static void box(double x, double y, double w, double h, Bounds b) {
+        box(x, y, w, h, b, 1e-9);
+    }
+
+    private void paint(Node node) {
+        drawn.clear();
+        drawnBounds.clear();
+        drawnPaint.clear();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String operation, double[] deviceBounds, Paint paint, String text) {
+                drawn.add(text == null ? operation : operation + ":" + text);
+                drawnBounds.add(deviceBounds);
+                drawnPaint.add(paint);
+            }
+        });
+        node.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(400, 400, 0).getGraphics(), 0, 0));
+        Renderer.setTrace(null);
+    }
+
+    @Test
+    public void rectangleBoundsFollowTheStrokeType() {
+        Rectangle r = new Rectangle(10, 20, 30, 40);
+        assertEquals(Color.BLACK, r.getFill());
+        assertNull(r.getStroke());
+        box(10, 20, 30, 40, r.getLayoutBounds());
+        // A width without a paint draws nothing and takes no room.
+        r.setStrokeWidth(4);
+        box(10, 20, 30, 40, r.getLayoutBounds());
+        r.setStroke(Color.RED);
+        assertEquals(StrokeType.CENTERED, r.getStrokeType());
+        box(8, 18, 34, 44, r.getLayoutBounds());
+        r.setStrokeType(StrokeType.INSIDE);
+        box(10, 20, 30, 40, r.getLayoutBounds());
+        r.setStrokeType(StrokeType.OUTSIDE);
+        box(6, 16, 38, 48, r.getLayoutBounds());
+        r.setStroke(null);
+        r.setFill(null);
+        assertTrue(r.getLayoutBounds().isEmpty());
+        r.setFill(Color.BLUE);
+        r.setWidth(50);
+        box(10, 20, 50, 40, r.getLayoutBounds());
+    }
+
+    @Test
+    public void rectangleInsideIsItsFillAndItsStroke() {
+        Rectangle r = new Rectangle(0, 0, 20, 20);
+        assertTrue(r.contains(1, 1));
+        assertFalse(r.contains(-1, 1));
+        r.setStroke(Color.RED);
+        r.setStrokeWidth(4);
+        assertTrue(r.contains(-1, 10));
+        assertFalse(r.contains(-3, 10));
+        // Without a fill only the stroke is hit.
+        r.setFill(null);
+        assertFalse(r.contains(10, 10));
+        assertTrue(r.contains(1, 10));
+        assertTrue(r.contains(-1, 10));
+        // Rounded corners cut the corner off.
+        Rectangle round = new Rectangle(0, 0, 20, 20);
+        round.setArcWidth(20);
+        round.setArcHeight(20);
+        assertFalse(round.contains(1, 1));
+        assertTrue(round.contains(10, 1));
+        box(0, 0, 20, 20, round.getLayoutBounds(), CURVE);
+    }
+
+    @Test
+    public void circleAndEllipse() {
+        Circle c = new Circle(50, 50, 10);
+        box(40, 40, 20, 20, c.getLayoutBounds(), CURVE);
+        assertTrue(c.contains(50, 50));
+        assertTrue(c.contains(57, 57));
+        assertFalse(c.contains(58, 58));
+        c.setStroke(Color.BLACK);
+        c.setStrokeWidth(2);
+        box(39, 39, 22, 22, c.getLayoutBounds(), CURVE);
+        c.setStrokeType(StrokeType.OUTSIDE);
+        box(38, 38, 24, 24, c.getLayoutBounds(), CURVE);
+        c.setStrokeType(StrokeType.INSIDE);
+        box(40, 40, 20, 20, c.getLayoutBounds(), CURVE);
+
+        Ellipse e = new Ellipse(0, 0, 20, 10);
+        box(-20, -10, 40, 20, e.getLayoutBounds(), CURVE);
+        assertTrue(e.contains(18, 0));
+        assertFalse(e.contains(0, 11));
+        assertFalse(e.contains(15, 8));
+        e.setRadiusX(5);
+        box(-5, -10, 10, 20, e.getLayoutBounds(), CURVE);
+    }
+
+    @Test
+    public void lineIsOnlyItsStroke() {
+        Line l = new Line(0, 0, 10, 0);
+        assertEquals(Color.BLACK, l.getStroke());
+        assertNull(l.getFill());
+        assertEquals(StrokeLineCap.SQUARE, l.getStrokeLineCap());
+        box(-0.5, -0.5, 11, 1, l.getLayoutBounds());
+        l.setStrokeLineCap(StrokeLineCap.BUTT);
+        box(0, -0.5, 10, 1, l.getLayoutBounds());
+        l.setStrokeWidth(4);
+        box(0, -2, 10, 4, l.getLayoutBounds());
+        assertTrue(l.contains(5, 1.5));
+        assertFalse(l.contains(5, 2.5));
+        assertFalse(l.contains(13, 0));
+        l.setStroke(null);
+        assertTrue(l.getLayoutBounds().isEmpty());
+        assertFalse(l.contains(5, 0));
+    }
+
+    @Test
+    public void pickingAStrokeOnlyLine() {
+        Pane parent = new Pane();
+        Line l = new Line(0, 0, 20, 20);
+        l.setStrokeWidth(2);
+        parent.getChildren().add(l);
+        assertSame(l, l.cn1Pick(10, 10));
+        assertSame(l, l.cn1Pick(10.5, 9.5));
+        // Inside the bounds but off the line.
+        assertNull(l.cn1Pick(18, 2));
+        l.setPickOnBounds(true);
+        assertSame(l, l.cn1Pick(18, 2));
+        l.setPickOnBounds(false);
+        l.setLayoutX(100);
+        assertNull(l.cn1Pick(10, 10));
+        assertSame(l, l.cn1Pick(110, 10));
+        Rectangle r = new Rectangle(0, 0, 10, 10);
+        assertSame(r, r.cn1Pick(5, 5));
+        assertNull(r.cn1Pick(11, 5));
+        r.setMouseTransparent(true);
+        assertNull(r.cn1Pick(5, 5));
+    }
+
+    @Test
+    public void polygonAndPolyline() {
+        Polygon p = new Polygon(0, 0, 10, 0, 10, 10);
+        assertEquals(Color.BLACK, p.getFill());
+        box(0, 0, 10, 10, p.getLayoutBounds());
+        assertTrue(p.contains(8, 2));
+        assertFalse(p.contains(2, 8));
+        p.getPoints().addAll(0.0, 10.0);
+        assertTrue(p.contains(2, 8));
+        p.setStroke(Color.RED);
+        p.setStrokeWidth(2);
+        box(-1, -1, 12, 12, p.getLayoutBounds());
+
+        Polyline open = new Polyline(0, 0, 10, 0, 10, 10);
+        assertNull(open.getFill());
+        assertEquals(Color.BLACK, open.getStroke());
+        box(-0.5, -0.5, 11, 11, open.getLayoutBounds());
+        assertTrue(open.contains(5, 0));
+        assertFalse(open.contains(8, 2));
+        // The closing edge is not drawn.
+        assertFalse(open.contains(5, 5));
+        open.setFill(Color.RED);
+        assertTrue(open.contains(8, 2));
+        assertTrue(new Polygon().getLayoutBounds().isEmpty());
+    }
+
+    @Test
+    public void arcTypes() {
+        // A quarter, counter clockwise from three o'clock: up and to the right.
+        Arc a = new Arc(0, 0, 10, 10, 0, 90);
+        assertEquals(ArcType.OPEN, a.getType());
+        box(0, -10, 10, 10, a.getLayoutBounds(), CURVE);
+        // Open and chord fill the segment cut off by the chord.
+        assertTrue(a.contains(6.5, -6.5));
+        assertFalse(a.contains(2, -2));
+        a.setType(ArcType.CHORD);
+        assertFalse(a.contains(2, -2));
+        a.setType(ArcType.ROUND);
+        assertTrue(a.contains(2, -2));
+        assertFalse(a.contains(-2, -2));
+        box(0, -10, 10, 10, a.getLayoutBounds(), CURVE);
+        a.setLength(180);
+        box(-10, -10, 20, 10, a.getLayoutBounds(), CURVE);
+        a.setStartAngle(180);
+        box(-10, 0, 20, 10, a.getLayoutBounds(), CURVE);
+    }
+
+    @Test
+    public void curves() {
+        QuadCurve q = new QuadCurve(0, 0, 5, 10, 10, 0);
+        box(0, 0, 10, 5, q.getLayoutBounds(), CURVE);
+        assertTrue(q.contains(5, 2));
+        assertFalse(q.contains(5, 6));
+        CubicCurve c = new CubicCurve(0, 0, 0, 10, 10, 10, 10, 0);
+        box(0, 0, 10, 7.5, c.getLayoutBounds(), CURVE);
+        assertTrue(c.contains(5, 5));
+        assertFalse(c.contains(5, 8));
+        c.setControlY1(-10);
+        c.setControlY2(-10);
+        box(0, -7.5, 10, 7.5, c.getLayoutBounds(), CURVE);
+    }
+
+    @Test
+    public void pathElements() {
+        Path p = new Path(new MoveTo(0, 0), new LineTo(10, 0), new VLineTo(10), new HLineTo(0), new ClosePath());
+        assertNull(p.getFill());
+        assertEquals(Color.BLACK, p.getStroke());
+        box(-0.5, -0.5, 11, 11, p.getLayoutBounds());
+        assertTrue(p.contains(0, 5));
+        assertFalse(p.contains(5, 5));
+        p.setFill(Color.RED);
+        assertTrue(p.contains(5, 5));
+        p.setStroke(null);
+        box(0, 0, 10, 10, p.getLayoutBounds());
+
+        // Relative elements start from the point before them.
+        LineTo side = new LineTo(10, 0);
+        side.setAbsolute(false);
+        VLineTo down = new VLineTo(5);
+        down.setAbsolute(false);
+        Path relative = new Path(new MoveTo(20, 20), side, down);
+        relative.setStroke(null);
+        relative.setFill(Color.RED);
+        box(20, 20, 10, 5, relative.getLayoutBounds());
+
+        // Changing an element changes the path.
+        side.setX(30);
+        box(20, 20, 30, 5, relative.getLayoutBounds());
+        relative.getElements().remove(down);
+        box(20, 20, 30, 0, relative.getLayoutBounds());
+
+        // A path has to start with a move.
+        Path headless = new Path(new LineTo(10, 10), new LineTo(20, 0));
+        assertTrue(headless.getLayoutBounds().isEmpty());
+    }
+
+    @Test
+    public void curvedPathElements() {
+        Path p = new Path(new MoveTo(0, 0), new QuadCurveTo(5, 10, 10, 0));
+        p.setStroke(null);
+        p.setFill(Color.RED);
+        box(0, 0, 10, 5, p.getLayoutBounds(), CURVE);
+        p.getElements().add(new CubicCurveTo(10, -10, 20, -10, 20, 0));
+        box(0, -7.5, 20, 12.5, p.getLayoutBounds(), CURVE);
+
+        // Half a circle of radius 5, over the top.
+        ArcTo arc = new ArcTo(5, 5, 0, 10, 0, false, true);
+        Path half = new Path(new MoveTo(0, 0), arc);
+        half.setStroke(null);
+        half.setFill(Color.RED);
+        box(0, -5, 10, 5, half.getLayoutBounds(), CURVE);
+        arc.setSweepFlag(false);
+        box(0, 0, 10, 5, half.getLayoutBounds(), CURVE);
+    }
+
+    @Test
+    public void fillRuleDecidesTheHole() {
+        // A square inside a square, both wound the same way.
+        Path p = new Path(new MoveTo(0, 0), new LineTo(30, 0), new LineTo(30, 30), new LineTo(0, 30),
+                new ClosePath(), new MoveTo(10, 10), new LineTo(20, 10), new LineTo(20, 20), new LineTo(10, 20),
+                new ClosePath());
+        p.setStroke(null);
+        p.setFill(Color.RED);
+        assertEquals(FillRule.NON_ZERO, p.getFillRule());
+        assertTrue(p.contains(15, 15));
+        p.setFillRule(FillRule.EVEN_ODD);
+        assertFalse(p.contains(15, 15));
+        assertTrue(p.contains(5, 5));
+    }
+
+    @Test
+    public void shapesDrawThroughTheRenderer() {
+        Rectangle r = new Rectangle(10, 20, 30, 40);
+        r.setFill(Color.RED);
+        paint(r);
+        assertEquals(1, drawn.size());
+        assertEquals("fill", drawn.get(0));
+        assertSame(Color.RED, drawnPaint.get(0));
+        // Device pixels at a scale of two.
+        assertEquals(20, drawnBounds.get(0)[0], 1e-6);
+        assertEquals(40, drawnBounds.get(0)[1], 1e-6);
+        assertEquals(80, drawnBounds.get(0)[2], 1e-6);
+        assertEquals(120, drawnBounds.get(0)[3], 1e-6);
+        r.setStroke(Color.BLUE);
+        paint(r);
+        assertEquals(2, drawn.size());
+        assertEquals("fill", drawn.get(0));
+        assertEquals("stroke", drawn.get(1));
+        assertSame(Color.BLUE, drawnPaint.get(1));
+        r.setFill(null);
+        paint(r);
+        assertEquals(1, drawn.size());
+        assertEquals("stroke", drawn.get(0));
+        Line l = new Line(0, 0, 10, 10);
+        paint(l);
+        assertEquals(1, drawn.size());
+        assertEquals("stroke", drawn.get(0));
+        l.setStroke(null);
+        paint(l);
+        assertTrue(drawn.isEmpty());
+    }
+
+    @Test
+    public void styleNamesReachTheShape() {
+        Rectangle r = new Rectangle(0, 0, 10, 10);
+        Shape s = r;
+        assertTrue(s.cn1ApplyStyle("-fx-fill", Color.RED));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke", Color.BLUE));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke-width", Double.valueOf(4)));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke-type", "outside"));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke-line-cap", "round"));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke-line-join", StrokeLineJoin.BEVEL));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke-miter-limit", Double.valueOf(3)));
+        assertTrue(s.cn1ApplyStyle("-fx-stroke-dash-offset", Double.valueOf(2)));
+        assertSame(Color.RED, s.getFill());
+        assertSame(Color.BLUE, s.getStroke());
+        assertEquals(4, s.getStrokeWidth(), 0);
+        assertEquals(StrokeType.OUTSIDE, s.getStrokeType());
+        assertEquals(StrokeLineCap.ROUND, s.getStrokeLineCap());
+        assertEquals(StrokeLineJoin.BEVEL, s.getStrokeLineJoin());
+        assertEquals(3, s.getStrokeMiterLimit(), 0);
+        assertEquals(2, s.getStrokeDashOffset(), 0);
+        box(-4, -4, 18, 18, s.getLayoutBounds());
+        assertFalse(s.cn1ApplyStyle("-fx-stroke-type", "sideways"));
+        assertFalse(s.cn1ApplyStyle("-fx-stroke-width", "wide"));
+        // Taking the style away puts back what the program had set.
+        assertTrue(s.cn1ApplyStyle("-fx-stroke", null));
+        assertNull(s.getStroke());
+        assertTrue(s.cn1ApplyStyle("-fx-fill", null));
+        assertEquals(Color.BLACK, s.getFill());
+        box(0, 0, 10, 10, s.getLayoutBounds());
+
+        Text t = new Text("abc");
+        assertTrue(t.cn1ApplyStyle("-fx-text-origin", "top"));
+        assertEquals(VPos.TOP, t.getTextOrigin());
+        assertTrue(t.cn1ApplyStyle("-fx-text-alignment", "center"));
+        assertEquals(TextAlignment.CENTER, t.getTextAlignment());
+        assertTrue(t.cn1ApplyStyle("-fx-underline", Boolean.TRUE));
+        assertTrue(t.isUnderline());
+        assertTrue(t.cn1ApplyStyle("-fx-strikethrough", Boolean.TRUE));
+        assertTrue(t.isStrikethrough());
+        assertTrue(t.cn1ApplyStyle("-fx-line-spacing", Double.valueOf(2)));
+        assertEquals(2, t.getLineSpacing(), 0);
+        assertTrue(t.cn1ApplyStyle("-fx-font-size", Double.valueOf(30)));
+        assertEquals(30, t.getFont().getSize(), 0);
+        assertTrue(t.cn1ApplyStyle("-fx-fill", Color.RED));
+        assertSame(Color.RED, t.getFill());
+    }
+
+    @Test
+    public void textBoundsGrowWithTheText() {
+        Text shortText = new Text("abc");
+        Text longText = new Text("abcdef");
+        Bounds a = shortText.getLayoutBounds();
+        Bounds b = longText.getLayoutBounds();
+        assertTrue(a.getWidth() > 0);
+        assertTrue(a.getHeight() > 0);
+        assertEquals(2 * a.getWidth(), b.getWidth(), 1e-6);
+        assertEquals(a.getHeight(), b.getHeight(), 1e-6);
+        // The origin is the baseline: the box starts above y.
+        assertTrue(a.getMinY() < 0);
+        assertEquals(-shortText.getBaselineOffset(), a.getMinY(), 1e-6);
+        shortText.setTextOrigin(VPos.TOP);
+        assertEquals(0, shortText.getLayoutBounds().getMinY(), 1e-6);
+        shortText.setX(7);
+        shortText.setY(9);
+        assertEquals(7, shortText.getLayoutBounds().getMinX(), 1e-6);
+        assertEquals(9, shortText.getLayoutBounds().getMinY(), 1e-6);
+        // A line feed is a second line.
+        longText.setText("abc\ndef");
+        assertEquals(a.getWidth(), longText.getLayoutBounds().getWidth(), 1e-6);
+        assertEquals(2 * a.getHeight(), longText.getLayoutBounds().getHeight(), 1e-6);
+        // The headless port measures every font alike, so only that a
+        // font can be set is checked here.
+        Text big = new Text("abc");
+        Font twice = Font.font(big.getFont().getFamily(), big.getFont().getSize() * 2);
+        big.setFont(twice);
+        assertSame(twice, big.getFont());
+        assertTrue(new Text().getLayoutBounds().getWidth() == 0);
+    }
+
+    @Test
+    public void wrappingWidthBreaksTextIntoLines() {
+        Text t = new Text("aaaa bbbb cccc dddd");
+        Bounds one = t.getLayoutBounds();
+        double word = new Text("aaaa").getLayoutBounds().getWidth();
+        t.setWrappingWidth(word * 2.5);
+        Bounds wrapped = t.getLayoutBounds();
+        assertEquals(word * 2.5, wrapped.getWidth(), 1e-6);
+        assertEquals(2 * one.getHeight(), wrapped.getHeight(), 1e-6);
+        t.setWrappingWidth(word * 1.2);
+        assertEquals(4 * one.getHeight(), t.getLayoutBounds().getHeight(), 1e-6);
+        t.setLineSpacing(3);
+        assertEquals(4 * one.getHeight() + 9, t.getLayoutBounds().getHeight(), 1e-6);
+        t.setLineSpacing(0);
+        t.setWrappingWidth(0);
+        assertEquals(one.getHeight(), t.getLayoutBounds().getHeight(), 1e-6);
+        assertEquals(one.getWidth(), t.getLayoutBounds().getWidth(), 1e-6);
+    }
+
+    @Test
+    public void textDrawsALineAtATime() {
+        Text t = new Text("one\ntwo");
+        t.setFill(Color.GREEN);
+        paint(t);
+        assertEquals(2, drawn.size());
+        assertEquals("text:one", drawn.get(0));
+        assertEquals("text:two", drawn.get(1));
+        assertSame(Color.GREEN, drawnPaint.get(0));
+        assertTrue(drawnBounds.get(1)[1] > drawnBounds.get(0)[1]);
+        t.setFill(null);
+        paint(t);
+        assertTrue(drawn.isEmpty());
+    }
+
+    private static Image picture(int w, int h) throws Exception {
+        java.awt.image.BufferedImage img = new java.awt.image.BufferedImage(w, h,
+                java.awt.image.BufferedImage.TYPE_INT_ARGB);
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        javax.imageio.ImageIO.write(img, "png", out);
+        return new Image(new ByteArrayInputStream(out.toByteArray()));
+    }
+
+    @Test
+    public void imageViewFitsItsPicture() throws Exception {
+        HeadlessImplementation.pixelImages = true;
+        Image image = picture(40, 20);
+        assertFalse(image.isError());
+        assertEquals(40, image.getWidth(), 0);
+        assertEquals(20, image.getHeight(), 0);
+        assertEquals(1, image.getProgress(), 0);
+
+        ImageView view = new ImageView(image);
+        box(0, 0, 40, 20, view.getLayoutBounds());
+        view.setX(3);
+        view.setY(4);
+        box(3, 4, 40, 20, view.getLayoutBounds());
+        view.setX(0);
+        view.setY(0);
+        // Without the ratio each side is fitted on its own.
+        view.setFitWidth(20);
+        box(0, 0, 20, 20, view.getLayoutBounds());
+        view.setFitHeight(60);
+        box(0, 0, 20, 60, view.getLayoutBounds());
+        // With it, the picture fits inside the box.
+        view.setPreserveRatio(true);
+        box(0, 0, 20, 10, view.getLayoutBounds());
+        view.setFitWidth(100);
+        view.setFitHeight(20);
+        box(0, 0, 40, 20, view.getLayoutBounds());
+        view.setFitWidth(0);
+        view.setFitHeight(40);
+        box(0, 0, 80, 40, view.getLayoutBounds());
+        view.setFitHeight(0);
+        box(0, 0, 40, 20, view.getLayoutBounds());
+        // A viewport is the picture that is fitted.
+        view.setViewport(new Rectangle2D(10, 0, 10, 10));
+        box(0, 0, 10, 10, view.getLayoutBounds());
+        view.setFitWidth(30);
+        box(0, 0, 30, 30, view.getLayoutBounds());
+
+        paint(view);
+        assertEquals(1, drawn.size());
+        assertEquals("image", drawn.get(0));
+        assertEquals(60, drawnBounds.get(0)[2], 1e-6);
+        assertEquals(60, drawnBounds.get(0)[3], 1e-6);
+
+        // As in JavaFX, a viewport gives a size even without a picture.
+        view.setImage(null);
+        box(0, 0, 30, 30, view.getLayoutBounds());
+        paint(view);
+        assertTrue(drawn.isEmpty());
+        view.setViewport(null);
+        box(0, 0, 0, 0, view.getLayoutBounds());
+        paint(view);
+        assertTrue(drawn.isEmpty());
+        assertTrue(new ImageView().getLayoutBounds().getWidth() == 0);
+    }
+
+    @Test
+    public void anImageThatCannotBeReadReportsAnError() {
+        Image missing = new Image("no/such/picture.png");
+        assertTrue(missing.isError());
+        assertNotNull(missing.getException());
+        assertEquals(0, missing.getWidth(), 0);
+        ImageView view = new ImageView(missing);
+        box(0, 0, 0, 0, view.getLayoutBounds());
+        paint(view);
+        assertTrue(drawn.isEmpty());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/SvgPathTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/SvgPathTest.java
new file mode 100644
index 00000000000..0dd179c7f6f
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/SvgPathTest.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.FxPath;
+import com.codename1.fxcompat.runtime.SvgPath;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.Bounds;
+import javafx.scene.shape.SVGPath;
+
+/// The SVG path data parser, checked against segments worked out by hand.
+public class SvgPathTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+    }
+
+    private static String number(double v) {
+        long thousandths = Math.round(v * 1000);
+        if (thousandths % 1000 == 0) {
+            return Long.toString(thousandths / 1000);
+        }
+        return Double.toString(thousandths / 1000.0);
+    }
+
+    /// Writes a path as `M x y L x y ...`, rounded to thousandths.
+    static String dump(FxPath path) {
+        StringBuilder out = new StringBuilder();
+        double[] pts = path.points();
+        int p = 0;
+        for (int i = 0; i < path.commandCount(); i++) {
+            int n;
+            switch (path.command(i)) {
+                case FxPath.MOVE:
+                    out.append('M');
+                    n = 2;
+                    break;
+                case FxPath.LINE:
+                    out.append('L');
+                    n = 2;
+                    break;
+                case FxPath.QUAD:
+                    out.append('Q');
+                    n = 4;
+                    break;
+                case FxPath.CUBIC:
+                    out.append('C');
+                    n = 6;
+                    break;
+                default:
+                    out.append('Z');
+                    n = 0;
+                    break;
+            }
+            for (int k = 0; k < n; k++) {
+                out.append(' ').append(number(pts[p++]));
+            }
+            if (i < path.commandCount() - 1) {
+                out.append(' ');
+            }
+        }
+        return out.toString();
+    }
+
+    private static String parse(String data) {
+        FxPath path = new FxPath();
+        assertTrue(data, SvgPath.append(data, path));
+        return dump(path);
+    }
+
+    private static String prefix(String data) {
+        FxPath path = new FxPath();
+        assertFalse(data, SvgPath.append(data, path));
+        return dump(path);
+    }
+
+    @Test
+    public void absoluteLinesAndClose() {
+        assertEquals("M 10 20 L 30 40 L 50 40 L 50 60 Z", parse("M10 20 L30 40 H50 V60 Z"));
+        assertEquals("M 0 0 L 10 0", parse("  M 0,0\n\tL 10 , 0  "));
+    }
+
+    @Test
+    public void relativeLines() {
+        assertEquals("M 10 10 L 15 10 L 20 10 L 20 15 Z", parse("m10 10 l5 0 h5 v5 z"));
+        // A relative command after a close starts from the start point.
+        assertEquals("M 10 10 L 20 10 Z M 10 10 L 11 11", parse("M10 10 h10 z l1 1"));
+    }
+
+    @Test
+    public void coordinatesRepeatTheCommand() {
+        assertEquals("M 0 0 L 10 0 L 10 10", parse("M0 0 10 0 10 10"));
+        assertEquals("M 1 1 L 3 3 L 6 6", parse("m1 1 2 2 3 3"));
+        assertEquals("M 0 0 L 1 0 L 2 0 L 2 5 L 2 7", parse("M0 0 H1 2 V5 7"));
+        assertEquals("M 0 0 Q 1 1 2 0 Q 3 1 4 0", parse("M0 0 Q1 1 2 0 3 1 4 0"));
+    }
+
+    @Test
+    public void compactNumbers() {
+        assertEquals("M 1 -2 L 0.5 0.5", parse("M1-2L.5.5"));
+        assertEquals("M -1 -2 L 3 4", parse("M-1-2L+3+4"));
+        assertEquals("M 10 0.2 L 15 0", parse("M1e1 2E-1 L1.5e+1 0"));
+        assertEquals("M 0 0 L 0.5 0.25 L 0.75 2", parse("M0 0L.5.25.75 2."));
+    }
+
+    @Test
+    public void cubicsAndTheirSmoothForm() {
+        assertEquals("M 0 0 C 0 10 10 10 10 0 C 10 -10 20 -10 20 0", parse("M0 0 C0 10 10 10 10 0 S20 -10 20 0"));
+        // Without a cubic before it the first control point is the current point.
+        assertEquals("M 0 0 C 0 0 5 5 10 0", parse("M0 0 S5 5 10 0"));
+        assertEquals("M 10 10 C 10 15 15 15 15 10 C 15 5 20 5 20 10", parse("M10 10 c0 5 5 5 5 0 s5 -5 5 0"));
+    }
+
+    @Test
+    public void quadraticsAndTheirSmoothForm() {
+        assertEquals("M 0 0 Q 5 10 10 0 Q 15 -10 20 0 Q 25 10 30 0", parse("M0 0 Q5 10 10 0 T20 0 T30 0"));
+        assertEquals("M 0 0 Q 0 0 10 0", parse("M0 0 T10 0"));
+        assertEquals("M 10 10 Q 15 15 20 10 Q 25 5 30 10", parse("M10 10 q5 5 10 0 t10 0"));
+        // A line in between forgets the control point.
+        assertEquals("M 0 0 Q 5 10 10 0 L 20 0 Q 20 0 30 0", parse("M0 0 Q5 10 10 0 L20 0 T30 0"));
+    }
+
+    private static FxPath path(String data) {
+        FxPath path = new FxPath();
+        assertTrue(data, SvgPath.append(data, path));
+        return path;
+    }
+
+    @Test
+    public void arcsEndWhereTheySayAndBendTheRightWay() {
+        // Half a circle of radius 5; the flags and the x run together.
+        FxPath up = path("M0 0 A5 5 0 0110 0");
+        assertEquals(10, up.currentX(), 0);
+        assertEquals(0, up.currentY(), 0);
+        double[] b = up.bounds();
+        assertEquals(0, b[0], 0.05);
+        assertEquals(-5, b[1], 0.05);
+        assertEquals(10, b[2], 0.05);
+        assertEquals(0, b[3], 0.05);
+
+        FxPath down = path("M0 0 A5 5 0 0010 0");
+        b = down.bounds();
+        assertEquals(0, b[1], 0.05);
+        assertEquals(5, b[3], 0.05);
+        assertEquals(FxPath.CUBIC, down.command(1));
+    }
+
+    @Test
+    public void largeArcFlagPicksTheLongWayRound() {
+        FxPath small = path("M10 0 A10 10 0 0 1 20 10");
+        double[] b = small.bounds();
+        assertEquals(10, b[2] - b[0], 0.05);
+        assertEquals(10, b[3] - b[1], 0.05);
+        FxPath large = path("M10 0 A10 10 0 1 1 20 10");
+        b = large.bounds();
+        assertEquals(20, b[2] - b[0], 0.05);
+        assertEquals(20, b[3] - b[1], 0.05);
+        assertEquals(20, large.currentX(), 0);
+        assertEquals(10, large.currentY(), 0);
+    }
+
+    @Test
+    public void relativeArcAndDegenerateArcs() {
+        FxPath relative = path("M5 5 a5 5 0 0 1 10 0");
+        assertEquals(15, relative.currentX(), 0);
+        assertEquals(5, relative.currentY(), 0);
+        // A zero radius is a line.
+        assertEquals("M 0 0 L 10 0", parse("M0 0 A0 5 0 0 1 10 0"));
+        // Arriving where it started draws nothing.
+        assertEquals("M 3 3", parse("M3 3 A5 5 0 0 1 3 3"));
+        // Radii too small to reach are scaled up until they do.
+        double[] b = path("M0 0 A1 1 0 0 1 10 0").bounds();
+        assertEquals(-5, b[1], 0.05);
+        assertEquals(10, b[2], 0.05);
+    }
+
+    @Test
+    public void rotatedEllipticalArc() {
+        // An ellipse 10 by 5 turned a quarter: its long axis is vertical.
+        FxPath p = path("M0 0 A10 5 90 0 1 10 0");
+        assertEquals(10, p.currentX(), 0);
+        assertEquals(0, p.currentY(), 0);
+        double[] b = p.bounds();
+        assertEquals(-10, b[1], 0.05);
+        assertEquals(0, b[3], 0.05);
+    }
+
+    @Test
+    public void malformedDataKeepsWhatCameBefore() {
+        assertEquals("M 0 0 L 10 0", prefix("M0 0 L10 0 L10 x"));
+        assertEquals("", prefix("L10 10"));
+        assertEquals("", prefix("10 10"));
+        assertEquals("M 0 0 L 5 5 Z", prefix("M0 0 L5 5 Z 5 5"));
+        assertEquals("M 0 0", prefix("M0 0 A5 5 0 2 1 10 0"));
+        assertEquals("M 0 0 L 1 1", prefix("M0 0 L1 1 X 5 5 L9 9"));
+        assertEquals("M 0 0", prefix("M0 0 C1 1 2 2 3"));
+        assertEquals("", parse(""));
+        FxPath none = new FxPath();
+        assertTrue(SvgPath.append(null, none));
+        assertTrue(none.isEmpty());
+    }
+
+    @Test
+    public void dataMayContinueAPathThatIsUnderWay() {
+        FxPath p = new FxPath();
+        p.moveTo(1, 1);
+        assertTrue(SvgPath.append("l2 0 V5", p));
+        assertEquals("M 1 1 L 3 1 L 3 5", dump(p));
+    }
+
+    @Test
+    public void svgPathNodeUsesTheData() {
+        SVGPath node = new SVGPath();
+        assertTrue(node.getLayoutBounds().isEmpty());
+        node.setContent("M0 0 L10 0 L10 20 Z");
+        Bounds b = node.getLayoutBounds();
+        assertEquals(0, b.getMinX(), 0);
+        assertEquals(10, b.getWidth(), 0);
+        assertEquals(20, b.getHeight(), 0);
+        assertTrue(node.contains(8, 4));
+        assertFalse(node.contains(2, 15));
+        // Broken data shows what came before the error.
+        node.setContent("M0 0 L4 0 L4 4 oops");
+        assertEquals(4, node.getLayoutBounds().getWidth(), 0);
+        assertEquals(4, node.getLayoutBounds().getHeight(), 0);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TableEditSortTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TableEditSortTest.java
new file mode 100644
index 00000000000..c870cdd1210
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TableEditSortTest.java
@@ -0,0 +1,417 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.application.Platform;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.transformation.SortedList;
+import javafx.geometry.Point2D;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Label;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.TableCell;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.TextField;
+import javafx.scene.control.cell.TextFieldTableCell;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyCodeCombination;
+import javafx.scene.input.KeyCombination;
+import javafx.scene.input.KeyEvent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.VBox;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Callback;
+import javafx.util.converter.DefaultStringConverter;
+
+/// Sorting a table by its headers, editing a cell, clipping a node and the
+/// accelerators of a menu bar.
+public class TableEditSortTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private boolean implicitExit;
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+        implicitExit = Platform.isImplicitExit();
+        Platform.setImplicitExit(false);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        Platform.setImplicitExit(implicitExit);
+    }
+
+    private static final class Person {
+        final SimpleStringProperty name;
+        final SimpleIntegerProperty age;
+
+        Person(String name, int age) {
+            this.name = new SimpleStringProperty(name);
+            this.age = new SimpleIntegerProperty(age);
+        }
+    }
+
+    private static ObservableList<Person> people() {
+        ObservableList<Person> list = FXCollections.observableArrayList();
+        list.add(new Person("Carol", 41));
+        list.add(new Person("alice", 30));
+        list.add(new Person("Bob", 30));
+        return list;
+    }
+
+    private static String names(List<Person> list) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < list.size(); i++) {
+            sb.append(i == 0 ? "" : ",").append(list.get(i).name.get());
+        }
+        return sb.toString();
+    }
+
+    private static Scene sceneOf(Node control, double w, double h) {
+        Pane root = new Pane();
+        root.getChildren().add(control);
+        if (control instanceof Region) {
+            ((Region) control).setPrefSize(w, h);
+        }
+        Scene scene = new Scene(root, w, h);
+        scene.cn1Layout(w, h);
+        return scene;
+    }
+
+    private static void clickAt(Scene scene, Node node, double x) {
+        Point2D p = node.localToScene(x, 4);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, p.getX(), p.getY(), MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, p.getX(), p.getY(), MouseButton.PRIMARY);
+    }
+
+    private static Label header(Parent table, String text) {
+        List<Node> children = table.getChildrenUnmodifiable();
+        for (int i = 0; i < children.size(); i++) {
+            Node n = children.get(i);
+            if (n instanceof Parent && n.getStyleClass().contains("column-header")) {
+                Node inside = ((Parent) n).getChildrenUnmodifiable().get(0);
+                if (inside instanceof Label && text.equals(((Label) inside).getText())) {
+                    return (Label) inside;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static TableColumn<Person, String> nameColumn() {
+        TableColumn<Person, String> name = new TableColumn<Person, String>("Name");
+        name.setCellValueFactory(f -> f.getValue().name);
+        name.setPrefWidth(120);
+        return name;
+    }
+
+    private static TableColumn<Person, Number> ageColumn() {
+        TableColumn<Person, Number> age = new TableColumn<Person, Number>("Age");
+        age.setCellValueFactory(f -> f.getValue().age);
+        age.setPrefWidth(60);
+        return age;
+    }
+
+    @Test
+    public void aHeaderClickSortsAscendingThenDescendingThenNotAtAll() {
+        ObservableList<Person> source = people();
+        SortedList<Person> sorted = new SortedList<Person>(source);
+        TableView<Person> table = new TableView<Person>();
+        TableColumn<Person, String> name = nameColumn();
+        TableColumn<Person, Number> age = ageColumn();
+        table.getColumns().add(name);
+        table.getColumns().add(age);
+        sorted.comparatorProperty().bind(table.comparatorProperty());
+        table.setItems(sorted);
+        Scene scene = sceneOf(table, 300, 160);
+        assertNull(table.getComparator());
+        assertEquals("Carol,alice,Bob", names(table.getItems()));
+
+        // Each click well apart from the last, so none is a double click.
+        assertNotNull(header(table, "Age"));
+        clickAt(scene, header(table, "Age"), 4);
+        assertEquals(1, table.getSortOrder().size());
+        assertSame(age, table.getSortOrder().get(0));
+        assertEquals(TableColumn.SortType.ASCENDING, age.getSortType());
+        assertNotNull(table.getComparator());
+        assertEquals("equal ages keep their order", "alice,Bob,Carol", names(table.getItems()));
+        assertEquals("the source is left alone", "Carol,alice,Bob", names(source));
+
+        scene.cn1Layout(300, 160);
+        clickAt(scene, header(table, "Age"), 24);
+        assertEquals(TableColumn.SortType.DESCENDING, age.getSortType());
+        assertEquals("Carol,alice,Bob", names(table.getItems()));
+
+        scene.cn1Layout(300, 160);
+        clickAt(scene, header(table, "Age"), 44);
+        assertTrue(table.getSortOrder().isEmpty());
+        assertNull(table.getComparator());
+        assertEquals("Carol,alice,Bob", names(table.getItems()));
+    }
+
+    @Test
+    public void theSortOrderSortsAPlainListInPlace() {
+        ObservableList<Person> list = people();
+        TableView<Person> table = new TableView<Person>(list);
+        TableColumn<Person, String> name = nameColumn();
+        TableColumn<Person, Number> age = ageColumn();
+        table.getColumns().add(name);
+        table.getColumns().add(age);
+        sceneOf(table, 300, 160);
+
+        table.getSortOrder().add(name);
+        assertEquals("strings sort as String.compareTo orders them", "Bob,Carol,alice", names(list));
+        name.setComparator(String.CASE_INSENSITIVE_ORDER);
+        assertEquals("alice,Bob,Carol", names(list));
+        name.setSortType(TableColumn.SortType.DESCENDING);
+        assertEquals("Carol,Bob,alice", names(list));
+        table.getSortOrder().setAll(java.util.Arrays.<TableColumn<Person, ?>>asList(age, name));
+        assertEquals("by age, then by name descending", "Bob,alice,Carol", names(list));
+        name.setSortable(false);
+        assertEquals("an unsortable column is skipped", "Bob,alice,Carol", names(list));
+    }
+
+    @Test
+    public void aCellIsEditedAndTheCommitReachesTheModel() {
+        final ObservableList<Person> list = people();
+        TableView<Person> table = new TableView<Person>(list);
+        table.setFixedCellSize(20);
+        TableColumn<Person, String> name = nameColumn();
+        final List<TableCell<Person, String>> cells = new ArrayList<TableCell<Person, String>>();
+        final Callback<TableColumn<Person, String>, TableCell<Person, String>> factory =
+                TextFieldTableCell.forTableColumn();
+        name.setCellFactory(column -> {
+            TableCell<Person, String> cell = factory.call(column);
+            cells.add(cell);
+            return cell;
+        });
+        table.getColumns().add(name);
+        table.getColumns().add(ageColumn());
+        Scene scene = sceneOf(table, 300, 160);
+        TableCell<Person, String> second = null;
+        for (int i = 0; i < cells.size(); i++) {
+            if (cells.get(i).getIndex() == 1) {
+                second = cells.get(i);
+            }
+        }
+        assertNotNull(second);
+        assertEquals("alice", second.getText());
+
+        clickAt(scene, second, 4);
+        clickAt(scene, second, 4);
+        assertFalse("a table is not editable until it is told to be", second.isEditing());
+        assertNull(table.getEditingCell());
+
+        table.setEditable(true);
+        clickAt(scene, second, 4);
+        clickAt(scene, second, 4);
+        assertTrue("a double click edits the cell", second.isEditing());
+        assertNotNull(table.getEditingCell());
+        assertEquals(1, table.getEditingCell().getRow());
+        assertSame(name, table.getEditingCell().getTableColumn());
+        assertTrue(second.getGraphic() instanceof TextField);
+        TextField field = (TextField) second.getGraphic();
+        assertEquals("alice", field.getText());
+        assertNull(second.getText());
+
+        second.cancelEdit();
+        assertFalse(second.isEditing());
+        assertNull(table.getEditingCell());
+        assertEquals("alice", second.getText());
+        assertNull(second.getGraphic());
+
+        final String[] committed = new String[2];
+        name.setOnEditCommit(event -> {
+            committed[0] = event.getNewValue();
+            committed[1] = event.getOldValue();
+            assertSame(list.get(1), event.getRowValue());
+            event.getRowValue().name.set(event.getNewValue());
+        });
+        table.edit(1, name);
+        assertTrue(second.isEditing());
+        second.commitEdit("Alicia");
+        assertFalse(second.isEditing());
+        assertEquals("Alicia", committed[0]);
+        assertEquals("alice", committed[1]);
+        assertEquals("Alicia", list.get(1).name.get());
+        assertEquals("Alicia", second.getText());
+        assertNull(table.getEditingCell());
+
+        name.setEditable(false);
+        table.edit(1, name);
+        assertFalse(second.isEditing());
+    }
+
+    @Test
+    public void withoutAHandlerACommitIsWrittenToTheObservableValue() {
+        ObservableList<Person> list = people();
+        TableView<Person> table = new TableView<Person>(list);
+        table.setEditable(true);
+        TableColumn<Person, String> name = nameColumn();
+        name.setCellFactory(column -> new TextFieldTableCell<Person, String>(new DefaultStringConverter()));
+        table.getColumns().add(name);
+        sceneOf(table, 300, 160);
+        table.edit(0, name);
+        assertNotNull(table.getEditingCell());
+        TableCell<Person, String> editing = null;
+        List<Node> all = new ArrayList<Node>();
+        collect(table, all);
+        for (int i = 0; i < all.size(); i++) {
+            if (all.get(i) instanceof TableCell && ((TableCell<?, ?>) all.get(i)).isEditing()) {
+                @SuppressWarnings("unchecked")
+                TableCell<Person, String> found = (TableCell<Person, String>) all.get(i);
+                editing = found;
+            }
+        }
+        assertNotNull(editing);
+        editing.commitEdit("Caroline");
+        assertEquals("Caroline", list.get(0).name.get());
+    }
+
+    private static void collect(Node node, List<Node> into) {
+        into.add(node);
+        if (node instanceof Parent) {
+            List<Node> children = ((Parent) node).getChildrenUnmodifiable();
+            for (int i = 0; i < children.size(); i++) {
+                collect(children.get(i), into);
+            }
+        }
+    }
+
+    @Test
+    public void aClippedNodeIsOnlyHitInsideItsClip() {
+        Rectangle box = new Rectangle(0, 0, 100, 100);
+        Pane root = new Pane(box);
+        Scene scene = new Scene(root, 200, 200);
+        scene.cn1Layout(200, 200);
+        assertSame(box, root.cn1Pick(80, 80));
+        assertNull(box.getClip());
+        assertNull(box.cn1ClipPath());
+
+        Rectangle clip = new Rectangle(10, 10, 40, 30);
+        box.setClip(clip);
+        assertSame(clip, box.getClip());
+        assertSame(box, root.cn1Pick(20, 20));
+        assertFalse("outside the clip the node is not there", root.cn1Pick(80, 80) == box);
+        double[] b = box.cn1ClipPath().bounds();
+        assertEquals(10, b[0], 0.01);
+        assertEquals(10, b[1], 0.01);
+        assertEquals(50, b[2], 0.01);
+        assertEquals(40, b[3], 0.01);
+
+        box.setClip(null);
+        assertSame(box, root.cn1Pick(80, 80));
+    }
+
+    private static KeyEvent press(KeyCode code, boolean shift, boolean control, boolean alt) {
+        return new KeyEvent(null, null, KeyEvent.KEY_PRESSED, "", "", code, shift, control, alt, false);
+    }
+
+    @Test
+    public void keyCombinationsReadAndMatch() {
+        KeyCombination save = KeyCombination.valueOf("Ctrl+Shift+S");
+        assertEquals(new KeyCodeCombination(KeyCode.S, KeyCombination.SHIFT_DOWN, KeyCombination.CONTROL_DOWN), save);
+        assertEquals("Shift+Ctrl+S", save.getName());
+        assertEquals(KeyCombination.ModifierValue.UP, save.getAlt());
+        assertTrue(save.match(press(KeyCode.S, true, true, false)));
+        assertFalse("a modifier that must be up is down", save.match(press(KeyCode.S, true, true, true)));
+        assertFalse(save.match(press(KeyCode.A, true, true, false)));
+        KeyCombination any = KeyCombination.keyCombination("Ignore Shift+F5");
+        assertEquals(KeyCombination.ModifierValue.ANY, any.getShift());
+        assertTrue(any.match(press(KeyCode.F5, true, false, false)));
+        assertTrue(any.match(press(KeyCode.F5, false, false, false)));
+        try {
+            KeyCombination.valueOf("Ctrl+Ctrl+S");
+            org.junit.Assert.fail("a modifier named twice");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage().contains("Duplicate"));
+        }
+        try {
+            new KeyCodeCombination(KeyCode.SHIFT);
+            org.junit.Assert.fail("a modifier as the key");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+    }
+
+    @Test
+    public void anAcceleratorFiresItsMenuItemAndTheScenesOwnRun() {
+        MenuItem plain = new MenuItem("Refresh");
+        plain.setAccelerator(new KeyCodeCombination(KeyCode.F5));
+        final int[] fired = new int[2];
+        plain.setOnAction(event -> fired[0]++);
+        Menu menu = new Menu("View");
+        menu.getItems().add(plain);
+        MenuBar bar = new MenuBar();
+        bar.getMenus().add(menu);
+        VBox root = new VBox(bar, new Label("content"));
+        Scene scene = new Scene(root, 300, 200);
+        scene.cn1Layout(300, 200);
+        scene.getAccelerators().put(new KeyCodeCombination(KeyCode.F6), () -> fired[1]++);
+
+        scene.cn1Key(KeyEvent.KEY_PRESSED, KeyCode.F5, "");
+        assertEquals(1, fired[0]);
+        scene.cn1Key(KeyEvent.KEY_RELEASED, KeyCode.F5, "");
+        assertEquals("only a press fires", 1, fired[0]);
+        scene.cn1Key(KeyEvent.KEY_PRESSED, KeyCode.F6, "");
+        assertEquals(1, fired[1]);
+        plain.setDisable(true);
+        scene.cn1Key(KeyEvent.KEY_PRESSED, KeyCode.F5, "");
+        assertEquals("a disabled item is not fired", 1, fired[0]);
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TouchAndTextFlowTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TouchAndTextFlowTest.java
new file mode 100644
index 00000000000..420f82a71a7
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TouchAndTextFlowTest.java
@@ -0,0 +1,493 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Fonts;
+import com.codename1.fxcompat.runtime.SceneInput;
+import com.codename1.fxcompat.runtime.Units;
+import com.codename1.ui.Display;
+
+import javafx.application.ConditionalFeature;
+import javafx.application.Platform;
+import javafx.event.EventType;
+import javafx.geometry.Insets;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.Scene;
+import javafx.scene.input.GestureEvent;
+import javafx.scene.input.InputEvent;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.SwipeEvent;
+import javafx.scene.input.TouchEvent;
+import javafx.scene.input.TouchPoint;
+import javafx.scene.layout.Pane;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+import javafx.scene.text.TextFlow;
+import javafx.stage.Screen;
+import javafx.stage.Stage;
+
+/// The swipe the scene makes out of a quick drag, the touch types that
+/// are there to be registered, the one screen, and the flow of text.
+public class TouchAndTextFlowTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> log = new ArrayList<String>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+        SceneInput.setTouchInput(0);
+    }
+
+    /// On a touch screen every pointer event is a touch first: pressed,
+    /// moved and released, one point, delivered to what the finger came
+    /// down on wherever it went, each ahead of the mouse event JavaFX
+    /// synthesises from it.
+    @Test
+    public void aFingerFiresATouchAheadOfEveryMouseEvent() {
+        SceneInput.setTouchInput(1);
+        assertTrue(Platform.isSupported(ConditionalFeature.INPUT_TOUCH));
+        assertFalse(Platform.isSupported(ConditionalFeature.INPUT_MULTITOUCH));
+        Pane root = new Pane();
+        root.setPrefSize(200, 200);
+        Pane inner = new Pane();
+        inner.resizeRelocate(40, 40, 50, 50);
+        inner.setStyle("-fx-background-color: red;");
+        root.getChildren().add(inner);
+        final List<TouchEvent> seen = new ArrayList<TouchEvent>();
+        inner.addEventHandler(TouchEvent.ANY, e -> {
+            seen.add(e);
+            log.add(e.getEventType().getName() + " " + e.getTouchPoint().getState() + " "
+                    + e.getTouchPoint().getX() + "," + e.getTouchPoint().getY() + " scene "
+                    + e.getTouchPoint().getSceneX() + "," + e.getTouchPoint().getSceneY() + " n" + e.getTouchCount());
+        });
+        inner.setOnMousePressed(e -> log.add("mouse pressed"));
+        inner.setOnMouseDragged(e -> log.add("mouse dragged"));
+        inner.setOnMouseReleased(e -> log.add("mouse released"));
+        Scene scene = new Scene(root, 200, 200);
+        scene.cn1Layout(200, 200);
+        inner.resizeRelocate(40, 40, 50, 50);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 50, 60, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_DRAGGED, 150, 160, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 150, 160, MouseButton.PRIMARY);
+        assertEquals("[TOUCH_PRESSED PRESSED 10.0,20.0 scene 50.0,60.0 n1, mouse pressed,"
+                + " TOUCH_MOVED MOVED 110.0,120.0 scene 150.0,160.0 n1, mouse dragged,"
+                + " TOUCH_RELEASED RELEASED 110.0,120.0 scene 150.0,160.0 n1, mouse released]", log.toString());
+        assertEquals(1, seen.get(0).getTouchPoint().getId());
+        assertSame(inner, seen.get(2).getTouchPoint().getTarget());
+        assertTrue(seen.get(1).getEventSetId() > seen.get(0).getEventSetId());
+        // A pointer that only moves is no finger on the screen.
+        log.clear();
+        scene.cn1Pointer(MouseEvent.MOUSE_MOVED, 50, 60, MouseButton.NONE);
+        assertEquals("[]", log.toString());
+    }
+
+    private Scene swipeScene() {
+        Pane root = new Pane();
+        root.setPrefSize(400, 400);
+        root.setOnSwipeUp(e -> log.add("up " + e.getSceneX() + "," + e.getSceneY() + " " + e.getTouchCount()));
+        root.setOnSwipeDown(e -> log.add("down"));
+        root.setOnSwipeLeft(e -> log.add("left"));
+        root.setOnSwipeRight(e -> log.add("right"));
+        root.setOnMouseReleased(e -> log.add("released"));
+        Scene scene = new Scene(root, 400, 400);
+        scene.cn1Layout(400, 400);
+        return scene;
+    }
+
+    private static void drag(Scene scene, double x1, double y1, double x2, double y2) {
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, x1, y1, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_DRAGGED, (x1 + x2) / 2, (y1 + y2) / 2, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, x2, y2, MouseButton.PRIMARY);
+    }
+
+    @Test
+    public void aQuickDragAlongOneAxisIsASwipeAfterTheRelease() {
+        Scene scene = swipeScene();
+        drag(scene, 200, 300, 205, 100);
+        assertEquals("[released, up 200.0,300.0 1]", log.toString());
+        log.clear();
+        drag(scene, 200, 100, 190, 300);
+        drag(scene, 300, 200, 100, 210);
+        drag(scene, 100, 200, 300, 190);
+        assertEquals("[released, down, released, left, released, right]", log.toString());
+    }
+
+    @Test
+    public void aShortOrDiagonalOrSecondaryDragIsNoSwipe() {
+        Scene scene = swipeScene();
+        drag(scene, 200, 200, 230, 200);
+        drag(scene, 100, 100, 300, 300);
+        drag(scene, 100, 100, 300, 220);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 100, 100, MouseButton.SECONDARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 300, 100, MouseButton.SECONDARY);
+        assertEquals("[released, released, released, released]", log.toString());
+    }
+
+    @Test
+    public void swipeHandlersAreProperties() {
+        Pane p = new Pane();
+        assertNull(p.getOnSwipeLeft());
+        javafx.event.EventHandler<SwipeEvent> h = e -> log.add("fired " + e.getEventType());
+        p.setOnSwipeLeft(h);
+        assertSame(h, p.getOnSwipeLeft());
+        assertSame(h, p.onSwipeLeftProperty().get());
+        p.fireEvent(new SwipeEvent(SwipeEvent.SWIPE_LEFT, 1, 2, 3, 4, false, false, false, false, true, 2, null));
+        assertEquals("[fired SWIPE_LEFT]", log.toString());
+        p.onSwipeLeftProperty().set(null);
+        assertNull(p.getOnSwipeLeft());
+    }
+
+    @Test
+    public void swipeEventTypesAndCopies() {
+        assertSame(GestureEvent.ANY, SwipeEvent.ANY.getSuperType());
+        assertSame(InputEvent.ANY, GestureEvent.ANY.getSuperType());
+        assertSame(SwipeEvent.ANY, SwipeEvent.SWIPE_DOWN.getSuperType());
+        Rectangle r = new Rectangle(10, 10, 50, 50);
+        r.setLayoutX(100);
+        Pane root = new Pane(r);
+        Scene scene = new Scene(root, 300, 300);
+        scene.cn1Layout(300, 300);
+        SwipeEvent e = new SwipeEvent(SwipeEvent.SWIPE_RIGHT, 120, 30, 500, 600, true, false, true, false, true, 3,
+                null);
+        assertEquals(120, e.getX(), 0);
+        assertEquals(3, e.getTouchCount());
+        assertTrue(e.isShiftDown());
+        assertTrue(e.isAltDown());
+        assertFalse(e.isShortcutDown());
+        assertFalse(e.isInertia());
+        assertTrue(e.isDirect());
+        SwipeEvent copy = e.copyFor(r, r);
+        assertSame(r, copy.getSource());
+        assertEquals(20, copy.getX(), 1e-9);
+        assertEquals(30, copy.getY(), 1e-9);
+        assertEquals(120, copy.getSceneX(), 0);
+        assertEquals(500, copy.getScreenX(), 0);
+        assertEquals(600, copy.getScreenY(), 0);
+        assertSame(SwipeEvent.SWIPE_UP, e.copyFor(r, r, SwipeEvent.SWIPE_UP).getEventType());
+    }
+
+    @Test
+    public void touchHandlersRegisterAndAMouseFiresNoTouch() {
+        SceneInput.setTouchInput(-1);
+        assertFalse(Platform.isSupported(ConditionalFeature.INPUT_TOUCH));
+        assertFalse(Platform.isSupported(ConditionalFeature.INPUT_MULTITOUCH));
+        assertTrue(Platform.isSupported(ConditionalFeature.INPUT_POINTER));
+        assertTrue(Platform.isSupported(ConditionalFeature.CONTROLS));
+        assertTrue(Platform.isSupported(ConditionalFeature.FXML));
+        assertFalse(Platform.isSupported(ConditionalFeature.SCENE3D));
+        assertFalse(Platform.isSupported(ConditionalFeature.MEDIA));
+        assertFalse(Platform.isSupported(null));
+        Pane root = new Pane();
+        root.setPrefSize(200, 200);
+        root.setOnTouchPressed(e -> log.add("touch " + e.getTouchPoint().getState() + " " + e.getTouchCount()));
+        root.setOnTouchReleased(e -> log.add("touch released"));
+        root.setOnTouchMoved(e -> log.add("touch moved"));
+        root.setOnTouchStationary(e -> log.add("touch stationary"));
+        root.setOnMousePressed(e -> log.add("mouse"));
+        Scene scene = new Scene(root, 200, 200);
+        scene.cn1Layout(200, 200);
+        scene.cn1Pointer(MouseEvent.MOUSE_PRESSED, 50, 50, MouseButton.PRIMARY);
+        scene.cn1Pointer(MouseEvent.MOUSE_RELEASED, 50, 50, MouseButton.PRIMARY);
+        assertEquals("[mouse]", log.toString());
+        log.clear();
+        TouchPoint point = new TouchPoint(7, TouchPoint.State.PRESSED, 50, 60, 150, 160, root, null);
+        List<TouchPoint> points = new ArrayList<TouchPoint>();
+        points.add(point);
+        TouchEvent event = new TouchEvent(TouchEvent.TOUCH_PRESSED, point, points, 4, false, true, false, false);
+        root.fireEvent(event);
+        assertEquals("[touch PRESSED 1]", log.toString());
+        assertEquals(7, point.getId());
+        assertEquals(4, event.getEventSetId());
+        assertTrue(event.isControlDown());
+        assertTrue(point.belongsTo(root));
+        assertTrue(point.belongsTo(scene));
+        assertFalse(point.belongsTo(new Pane()));
+        assertNull(point.getGrabbed());
+        point.grab();
+        assertSame(root, point.getGrabbed());
+        point.ungrab();
+        assertNull(point.getGrabbed());
+        assertSame(TouchEvent.ANY, TouchEvent.TOUCH_MOVED.getSuperType());
+        EventType<TouchEvent> type = event.copyFor(root, root, TouchEvent.TOUCH_RELEASED).getEventType();
+        assertSame(TouchEvent.TOUCH_RELEASED, type);
+    }
+
+    /// At a desk the screen is the desktop, not the window the application
+    /// was opened in: 2048 sizes its stage from it.
+    @Test
+    public void theScreenOfADesktopIsTheDesktopAndNotTheWindow() {
+        HeadlessImplementation.setDesktop(true);
+        HeadlessImplementation.desktopSize = new int[] {2560, 1600};
+        try {
+            Rectangle2D b = Screen.getPrimary().getVisualBounds();
+            assertEquals(1280, b.getWidth(), 1e-9);
+            assertEquals(800, b.getHeight(), 1e-9);
+        } finally {
+            HeadlessImplementation.desktopSize = null;
+            HeadlessImplementation.setDesktop(false);
+        }
+    }
+
+    @Test
+    public void theScreenIsTheDisplayInLogicalPixels() {
+        Screen s = Screen.getPrimary();
+        Display d = Display.getInstance();
+        Rectangle2D b = s.getBounds();
+        assertEquals(d.getDisplayWidth() / 2.0, b.getWidth(), 1e-9);
+        assertEquals(d.getDisplayHeight() / 2.0, b.getHeight(), 1e-9);
+        assertEquals(b, s.getVisualBounds());
+        assertEquals(1, Screen.getScreens().size());
+        assertSame(s, Screen.getScreens().get(0));
+        assertEquals(2, s.getOutputScaleX(), 0);
+        assertEquals(2, s.getOutputScaleY(), 0);
+        assertEquals(96, s.getDpi(), 0);
+        assertEquals(1, Screen.getScreensForRectangle(0, 0, 10, 10).size());
+        assertEquals(0, Screen.getScreensForRectangle(-50, -50, 10, 10).size());
+    }
+
+    @Test
+    public void aFontFileIsNotLoadedAndTheHintIsOnlyRecorded() {
+        assertNull(Font.loadFont("file:/nowhere/Some.ttf", 12));
+        assertNull(Font.loadFont((java.io.InputStream) null, 12));
+        Stage stage = new Stage();
+        assertNull(stage.getFullScreenExitHint());
+        stage.setFullScreenExitHint("");
+        assertEquals("", stage.getFullScreenExitHint());
+        assertEquals("", stage.fullScreenExitHintProperty().get());
+    }
+
+    private static double width(Text t) {
+        return Fonts.width(t.getFont(), t.getText());
+    }
+
+    @Test
+    public void textFlowsOnOneBaselineAndBreaksAtALineFeed() {
+        Text big = new Text("2048");
+        big.setFont(Font.font(40));
+        Text small = new Text("FX");
+        small.setFont(Font.font(12));
+        Text feed = new Text(" Game\n");
+        Text next = new Text("second line");
+        TextFlow flow = new TextFlow(big, small, feed, next);
+        flow.setPadding(new Insets(10, 0, 0, 5));
+        double bigLine = Fonts.lineHeight(big.getFont());
+        double line = Fonts.lineHeight(next.getFont());
+        double first = width(big) + width(small) + Fonts.width(feed.getFont(), " Game");
+        assertEquals(5 + Math.max(first, width(next)), flow.prefWidth(-1), 1.01);
+        assertEquals(10 + bigLine + line, flow.prefHeight(-1), 1.01);
+        flow.resize(600, 300);
+        flow.layout();
+        double baseline = big.getLayoutY() + big.getBaselineOffset() + big.getLayoutBounds().getMinY();
+        assertEquals(baseline, small.getLayoutY() + small.getLayoutBounds().getMinY() + small.getBaselineOffset(),
+                1.01);
+        assertEquals(5, big.getBoundsInParent().getMinX(), 0.51);
+        assertEquals(5 + width(big), small.getBoundsInParent().getMinX(), 1.01);
+        assertEquals(5 + width(big) + width(small), feed.getBoundsInParent().getMinX(), 1.01);
+        assertEquals(5, next.getBoundsInParent().getMinX(), 0.51);
+        assertEquals(10 + bigLine, next.getBoundsInParent().getMinY(), 1.01);
+        assertEquals(10 + Fonts.ascent(big.getFont()), flow.getBaselineOffset(), 1.01);
+    }
+
+    @Test
+    public void textFlowWrapsWholePiecesAndAlignsEachLine() {
+        Text a = new Text("alpha ");
+        Text b = new Text("beta ");
+        Text c = new Text("gamma");
+        TextFlow flow = new TextFlow(a, b, c);
+        double line = Fonts.lineHeight(a.getFont());
+        double narrow = width(a) + width(b) + 2;
+        assertEquals(2 * line, flow.prefHeight(narrow), 1.01);
+        assertEquals(3 * line, flow.prefHeight(width(c) + 1), 1.01);
+        assertEquals(line, flow.prefHeight(-1), 1.01);
+        flow.setTextAlignment(TextAlignment.RIGHT);
+        flow.resize(narrow, 100);
+        flow.layout();
+        assertEquals(narrow - width(a) - width(b), a.getBoundsInParent().getMinX(), 1.01);
+        assertEquals(narrow - width(c), c.getBoundsInParent().getMinX(), 1.01);
+        assertEquals(line, c.getBoundsInParent().getMinY(), 1.01);
+        flow.setTextAlignment(TextAlignment.CENTER);
+        flow.layout();
+        assertEquals((narrow - width(c)) / 2, c.getBoundsInParent().getMinX(), 1.01);
+        flow.setLineSpacing(7);
+        flow.layout();
+        assertEquals(line + 7, c.getBoundsInParent().getMinY(), 1.01);
+        assertEquals(TextAlignment.CENTER, flow.textAlignmentProperty().get());
+        assertEquals(7, flow.lineSpacingProperty().get(), 0);
+        assertEquals(0, new TextFlow().prefHeight(-1), 0);
+    }
+
+    @Test
+    public void textFlowSizesAControlBesideText() {
+        Text a = new Text("label ");
+        Pane box = new Pane();
+        box.setPrefSize(30, 50);
+        TextFlow flow = new TextFlow(a, box);
+        assertEquals(width(a) + 30, flow.prefWidth(-1), 1.01);
+        // The box stands on the baseline; the descent of the text hangs below it.
+        double descent = Fonts.lineHeight(a.getFont()) - Fonts.ascent(a.getFont());
+        assertEquals(50 + descent, flow.prefHeight(-1), 1.01);
+        flow.resize(300, 100);
+        flow.layout();
+        assertEquals(30, box.getWidth(), 0);
+        assertEquals(50, box.getHeight(), 0);
+        assertEquals(0, box.getLayoutY(), 0.51);
+        assertEquals(50 - Fonts.ascent(a.getFont()), a.getBoundsInParent().getMinY(), 1.01);
+    }
+
+    /// A group gives a resizable child its preferred size when it is asked
+    /// for its own bounds. The peer of the child asked the group while it
+    /// was placing itself, with the child's bounds from before in hand,
+    /// and stayed empty: a text flow in a group, shown after the scene was
+    /// laid out once, drew nothing.
+    @Test
+    public void aRegionInAGroupAddedToAShownSceneHasAPeerOfItsSize() {
+        javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane();
+        javafx.scene.Scene scene = new javafx.scene.Scene(root, 400, 300);
+        scene.cn1Layout(400, 300);
+        root.cn1Peer();
+        javafx.scene.text.TextFlow flow = new javafx.scene.text.TextFlow(new javafx.scene.text.Text("some words"));
+        root.getChildren().setAll(new javafx.scene.Group(flow));
+        scene.cn1Layout(400, 300);
+        org.junit.Assert.assertTrue(flow.getWidth() > 0);
+        org.junit.Assert.assertEquals(com.codename1.fxcompat.runtime.Units.toPixels(flow.getWidth()),
+                flow.cn1Peer().getWidth(), 1);
+        org.junit.Assert.assertEquals(com.codename1.fxcompat.runtime.Units.toPixels(flow.getHeight()),
+                flow.cn1Peer().getHeight(), 1);
+    }
+
+    /// A pane does not clip its children. Codename One clips a container
+    /// to its bounds, so a tile pane taller than the pane it is in lost
+    /// the rows below the pane's edge. What the children of a pane may
+    /// paint in is what the pane itself may: the area of its parent.
+    @Test
+    public void aPaneLetsItsChildrenPaintBeyondItsBounds() {
+        javafx.scene.layout.Pane small = new javafx.scene.layout.Pane();
+        small.setMaxSize(40, 30);
+        small.setPrefSize(40, 30);
+        javafx.scene.layout.Pane tall = new javafx.scene.layout.Pane();
+        tall.setPrefSize(40, 120);
+        small.getChildren().add(tall);
+        javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane(small);
+        javafx.scene.Scene scene = new javafx.scene.Scene(root, 400, 300);
+        scene.cn1Layout(400, 300);
+        org.junit.Assert.assertEquals(30, small.getHeight(), 0.5);
+        org.junit.Assert.assertEquals(120, tall.getHeight(), 0.5);
+        org.junit.Assert.assertFalse(com.codename1.fxcompat.runtime.ParentPeer.clipsChildren(small));
+        org.junit.Assert.assertFalse(com.codename1.fxcompat.runtime.ParentPeer.clipsChildren(root));
+        org.junit.Assert.assertFalse(
+                com.codename1.fxcompat.runtime.ParentPeer.clipsChildren(new javafx.scene.Group()));
+        // Under a scaled parent the clip of the screen cannot be handed
+        // down, and a pane is left with the one it has.
+        org.junit.Assert.assertFalse(com.codename1.fxcompat.runtime.ParentPeer.underTransform(small));
+        root.setScaleX(0.5);
+        org.junit.Assert.assertTrue(com.codename1.fxcompat.runtime.ParentPeer.underTransform(small));
+        org.junit.Assert.assertFalse(com.codename1.fxcompat.runtime.ParentPeer.underTransform(root));
+        // The content of a scroll pane or a list stays inside it.
+        org.junit.Assert.assertTrue(com.codename1.fxcompat.runtime.ParentPeer
+                .clipsChildren(new javafx.scene.control.ScrollPane()));
+        org.junit.Assert.assertTrue(com.codename1.fxcompat.runtime.ParentPeer
+                .clipsChildren(new javafx.scene.control.ListView<String>()));
+    }
+
+    /// What a pane may paint in was the clip its parent last painted
+    /// with. Codename One also paints a peer on its own, and the peers
+    /// lying over it clipped to that one's area, so the clip a parent
+    /// was left with could be a few pixels of a label elsewhere: a pane
+    /// that then painted on its own drew nothing, and a whole scene came
+    /// up empty now and then. Outside a paint of the parent the area
+    /// comes from where the peers are.
+    @Test
+    public void whatAPaneMayPaintInDoesNotComeFromAnEarlierPaint() {
+        javafx.scene.layout.Pane inner = new javafx.scene.layout.Pane();
+        inner.setPrefSize(40, 30);
+        inner.setMaxSize(40, 30);
+        javafx.scene.control.ListView<String> list = new javafx.scene.control.ListView<String>();
+        list.setPrefSize(100, 80);
+        list.setMaxSize(100, 80);
+        javafx.scene.layout.VBox box = new javafx.scene.layout.VBox(inner, list);
+        javafx.scene.layout.StackPane root = new javafx.scene.layout.StackPane(box);
+        javafx.scene.Scene scene = new javafx.scene.Scene(root, 400, 300);
+        scene.cn1Layout(400, 300);
+        com.codename1.ui.Component rootPeer = root.cn1Peer();
+        rootPeer.setWidth(400);
+        rootPeer.setHeight(300);
+        scene.cn1Layout(400, 300);
+        com.codename1.fxcompat.runtime.ParentPeer top = (com.codename1.fxcompat.runtime.ParentPeer) rootPeer;
+        com.codename1.fxcompat.runtime.ParentPeer boxPeer =
+                (com.codename1.fxcompat.runtime.ParentPeer) box.cn1Peer();
+        com.codename1.fxcompat.runtime.ParentPeer listPeer =
+                (com.codename1.fxcompat.runtime.ParentPeer) list.cn1Peer();
+
+        // Never painted, and painted for a corner of it only: the same.
+        for (int pass = 0; pass < 2; pass++) {
+            int[] area = new int[4];
+            org.junit.Assert.assertTrue(top.childClip(area));
+            org.junit.Assert.assertArrayEquals(new int[] {0, 0, 400, 300}, area);
+            // A pane hands on the area of its parent, in its own coordinates.
+            org.junit.Assert.assertTrue(boxPeer.childClip(area));
+            org.junit.Assert.assertArrayEquals(
+                    new int[] {-boxPeer.getX(), -boxPeer.getY(), 400, 300}, area);
+            // A control ends it at its own bounds.
+            org.junit.Assert.assertTrue(listPeer.childClip(area));
+            org.junit.Assert.assertArrayEquals(
+                    new int[] {0, 0, listPeer.getWidth(), listPeer.getHeight()}, area);
+            com.codename1.ui.Image picture = com.codename1.ui.Image.createImage(400, 300, 0xffffffff);
+            com.codename1.ui.Graphics g = picture.getGraphics();
+            g.setClip(390, 290, 2, 2);
+            top.paint(g);
+        }
+
+        // Under a scale the area is not a rectangle of the screen.
+        box.setScaleX(0.5);
+        org.junit.Assert.assertFalse(boxPeer.childClip(new int[4]));
+        org.junit.Assert.assertFalse(listPeer.childClip(new int[4]));
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TransformTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TransformTest.java
new file mode 100644
index 00000000000..8c8296c82d2
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TransformTest.java
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Point2D;
+import javafx.scene.layout.Pane;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.transform.Affine;
+import javafx.scene.transform.NonInvertibleTransformException;
+import javafx.scene.transform.Rotate;
+import javafx.scene.transform.Scale;
+import javafx.scene.transform.Shear;
+import javafx.scene.transform.Transform;
+import javafx.scene.transform.Translate;
+
+/// The transform classes and their part in a node's coordinates.
+public class TransformTest {
+
+    private static final double EPS = 1e-9;
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Units.setScale(0);
+    }
+
+    private static void at(double x, double y, Point2D p) {
+        assertEquals(x, p.getX(), EPS);
+        assertEquals(y, p.getY(), EPS);
+    }
+
+    private static void box(double x, double y, double w, double h, Bounds b) {
+        assertEquals(x, b.getMinX(), EPS);
+        assertEquals(y, b.getMinY(), EPS);
+        assertEquals(w, b.getWidth(), EPS);
+        assertEquals(h, b.getHeight(), EPS);
+    }
+
+    @Test
+    public void theSimpleTransforms() {
+        at(11, 7, new Translate(10, 5).transform(1, 2));
+        at(2, 6, new Scale(2, 3).transform(1, 2));
+        // Clockwise on a y down screen.
+        at(0, 10, new Rotate(90).transform(10, 0));
+        at(1, 1, new Shear(1, 0).transform(0, 1));
+        at(1, 1, new Shear(0, 1).transform(1, 0));
+        assertTrue(new Translate().isIdentity());
+        assertTrue(new Rotate(0).isIdentity());
+        assertFalse(new Scale(2, 1).isIdentity());
+        assertEquals(6, new Scale(2, 3).determinant(), EPS);
+        // A delta is not moved.
+        at(2, 4, new Translate(10, 5).createConcatenation(new Scale(2, 2)).deltaTransform(1, 2));
+    }
+
+    @Test
+    public void pivotsStayPut() {
+        Rotate r = new Rotate(90, 10, 10);
+        at(10, 10, r.transform(10, 10));
+        at(10, 20, r.transform(20, 10));
+        Scale s = new Scale(2, 3, 10, 10);
+        at(10, 10, s.transform(10, 10));
+        at(12, 13, s.transform(11, 11));
+        Shear sh = new Shear(1, 0, 0, 10);
+        at(5, 10, sh.transform(5, 10));
+        at(6, 11, sh.transform(5, 11));
+        at(10, 10, Transform.rotate(180, 10, 10).transform(10, 10));
+        at(0, 0, Transform.rotate(180, 10, 10).transform(20, 20));
+    }
+
+    @Test
+    public void concatenationAppliesTheArgumentFirst() {
+        Transform moveThenScale = new Translate(10, 0).createConcatenation(new Scale(2, 2));
+        at(12, 2, moveThenScale.transform(1, 1));
+        Transform scaleThenMove = new Scale(2, 2).createConcatenation(new Translate(10, 0));
+        at(22, 2, scaleThenMove.transform(1, 1));
+        assertEquals(2, moveThenScale.getMxx(), EPS);
+        assertEquals(10, moveThenScale.getTx(), EPS);
+        assertEquals(20, scaleThenMove.getTx(), EPS);
+    }
+
+    @Test
+    public void inverseRoundTrip() throws NonInvertibleTransformException {
+        Affine a = new Affine();
+        a.appendRotation(30);
+        a.appendTranslation(5, 7);
+        a.appendScale(2, 3);
+        a.appendShear(0.25, 0);
+        Point2D p = a.transform(3, -4);
+        at(3, -4, a.inverseTransform(p));
+        at(3, -4, a.createInverse().transform(p));
+        Transform both = a.createConcatenation(a.createInverse());
+        assertEquals(1, both.getMxx(), EPS);
+        assertEquals(0, both.getMxy(), EPS);
+        assertEquals(0, both.getMyx(), EPS);
+        assertEquals(1, both.getMyy(), EPS);
+        assertEquals(0, both.getTx(), EPS);
+        assertEquals(0, both.getTy(), EPS);
+        at(1, 2, a.inverseDeltaTransform(a.deltaTransform(1, 2)));
+        Bounds there = a.transform(new BoundingBox(0, 0, 10, 10));
+        assertTrue(there.contains(a.transform(5, 5)));
+        Affine copy = new Affine(a);
+        copy.invert();
+        at(3, -4, copy.transform(p));
+    }
+
+    @Test
+    public void aFlatTransformHasNoInverse() {
+        try {
+            new Scale(0, 1).createInverse();
+            fail("expected NonInvertibleTransformException");
+        } catch (NonInvertibleTransformException expected) {
+            assertTrue(expected.getMessage() != null);
+        }
+        try {
+            new Scale(1, 0).inverseTransform(1, 1);
+            fail("expected NonInvertibleTransformException");
+        } catch (NonInvertibleTransformException expected) {
+            assertTrue(expected.getMessage() != null);
+        }
+    }
+
+    @Test
+    public void affineAppendsAndPrepends() {
+        Affine a = new Affine(1, 0, 10, 0, 1, 20);
+        assertEquals(10, a.getTx(), 0);
+        assertEquals(20, a.getTy(), 0);
+        a.append(new Scale(2, 2));
+        at(12, 22, a.transform(1, 1));
+        a.prepend(new Translate(100, 0));
+        at(112, 22, a.transform(1, 1));
+        a.prependScale(0.5, 0.5);
+        at(56, 11, a.transform(1, 1));
+        a.setToIdentity();
+        assertTrue(a.isIdentity());
+        a.appendRotation(90, 10, 10);
+        at(10, 20, a.transform(20, 10));
+        a.setToTransform(new Translate(1, 2));
+        at(1, 2, a.transform(0, 0));
+        a.setMxx(3);
+        at(4, 2, a.transform(1, 0));
+    }
+
+    @Test
+    public void nodeTransformsComeBeforeItsOwnScaleAndRotation() {
+        Rectangle r = new Rectangle(0, 0, 10, 10);
+        assertNull(r.cn1PaintMatrix());
+        r.getTransforms().add(new Translate(5, 5));
+        at(5, 5, r.localToParent(0, 0));
+        r.getTransforms().add(new Rotate(90));
+        // Rotated first, then moved: the list reads outermost first.
+        at(5, 15, r.localToParent(10, 0));
+        box(-5, 5, 10, 10, r.getBoundsInParent());
+        at(10, 0, r.parentToLocal(5, 15));
+        r.setLayoutX(100);
+        at(105, 15, r.localToParent(10, 0));
+        box(95, 5, 10, 10, r.getBoundsInParent());
+        // The layout bounds are not transformed.
+        box(0, 0, 10, 10, r.getLayoutBounds());
+    }
+
+    @Test
+    public void nodeScaleIsInnermost() {
+        Rectangle r = new Rectangle(0, 0, 10, 10);
+        r.getTransforms().add(new Scale(2, 2));
+        r.setScaleX(3);
+        // The node's own scale is about its centre, then the list applies.
+        at(2 * (5 + 3 * 5), 20, r.localToParent(10, 10));
+        box(-20, 0, 60, 20, r.getBoundsInParent());
+    }
+
+    @Test
+    public void pickingFollowsTheTransforms() {
+        Pane parent = new Pane();
+        Rectangle r = new Rectangle(0, 0, 10, 10);
+        parent.getChildren().add(r);
+        assertSame(r, r.cn1Pick(8, 8));
+        r.getTransforms().add(new Translate(5, 5));
+        r.getTransforms().add(new Rotate(90));
+        assertSame(r, r.cn1Pick(-2, 8));
+        assertNull(r.cn1Pick(8, 8));
+        assertNull(r.cn1Pick(-6, 8));
+        r.getTransforms().clear();
+        assertSame(r, r.cn1Pick(8, 8));
+        assertNull(r.cn1PaintMatrix());
+    }
+
+    @Test
+    public void changingATransformMovesTheNode() {
+        Rectangle r = new Rectangle(0, 0, 10, 10);
+        Translate t = new Translate(5, 0);
+        Scale s = new Scale(1, 1);
+        r.getTransforms().addAll(t, s);
+        box(5, 0, 10, 10, r.getBoundsInParent());
+        t.setX(20);
+        box(20, 0, 10, 10, r.getBoundsInParent());
+        s.setX(2);
+        s.setY(3);
+        box(20, 0, 20, 30, r.getBoundsInParent());
+        double[] m = r.cn1PaintMatrix();
+        assertEquals(2, m[0], EPS);
+        assertEquals(3, m[3], EPS);
+        assertEquals(20, m[4], EPS);
+        // Once removed, a transform no longer reaches the node.
+        r.getTransforms().remove(t);
+        t.setX(500);
+        box(0, 0, 20, 30, r.getBoundsInParent());
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TransformationListTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TransformationListTest.java
new file mode 100644
index 00000000000..14e2e1743e5
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/TransformationListTest.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.Test;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.transformation.FilteredList;
+import javafx.collections.transformation.SortedList;
+
+public class TransformationListTest {
+
+    private static List<Integer> ints(int... values) {
+        List<Integer> result = new ArrayList<Integer>();
+        for (int value : values) {
+            result.add(Integer.valueOf(value));
+        }
+        return result;
+    }
+
+    @Test
+    public void filteredListShowsMatchingElements() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(1, 2, 3, 4, 5, 6));
+        FilteredList<Integer> even = new FilteredList<Integer>(source, n -> n.intValue() % 2 == 0);
+        assertEquals("[2, 4, 6]", even.toString());
+        assertEquals(3, even.size());
+        assertEquals(1, even.getSourceIndex(0));
+        assertEquals(5, even.getSourceIndex(2));
+        assertEquals(1, even.getViewIndex(3));
+        assertTrue(even.getViewIndex(0) < 0);
+        assertSame(source, even.getSource());
+        assertTrue(even.isInTransformationChain(source));
+        assertEquals(3, even.getSourceIndexFor(source, 1));
+    }
+
+    @Test
+    public void filteredListPropagatesSourceChanges() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(1, 2, 3, 4));
+        FilteredList<Integer> even = source.filtered(n -> n.intValue() % 2 == 0);
+        Probe.ListChanges<Integer> probe = new Probe.ListChanges<Integer>();
+        even.addListener(probe);
+        source.add(Integer.valueOf(6));
+        assertEquals("[add[2,3] +[6]]", probe.take());
+        source.add(Integer.valueOf(7));
+        assertEquals("an element that does not match changes nothing", "[]", probe.take());
+        source.add(0, Integer.valueOf(0));
+        assertEquals("[add[0,1] +[0]]", probe.take());
+        assertEquals("[0, 2, 4, 6]", even.toString());
+        source.remove(Integer.valueOf(2));
+        assertEquals("[rem[1] -[2]]", probe.take());
+        source.remove(Integer.valueOf(1));
+        assertEquals("[]", probe.take());
+        source.set(0, Integer.valueOf(10));
+        assertEquals("[rep[0,1] -[0] +[10]]", probe.take());
+        source.set(0, Integer.valueOf(11));
+        assertEquals("[rem[0] -[10]]", probe.take());
+        source.set(0, Integer.valueOf(12));
+        assertEquals("[add[0,1] +[12]]", probe.take());
+        assertEquals("[12, 4, 6]", even.toString());
+        source.clear();
+        assertEquals("[rem[0] -[12, 4, 6]]", probe.take());
+        assertEquals(0, even.size());
+    }
+
+    @Test
+    public void filteredListFollowsASourceSort() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(6, 1, 4, 3, 2));
+        FilteredList<Integer> even = new FilteredList<Integer>(source, n -> n.intValue() % 2 == 0);
+        assertEquals("[6, 4, 2]", even.toString());
+        FXCollections.sort(source);
+        assertEquals("[2, 4, 6]", even.toString());
+        assertEquals(1, even.getSourceIndex(0));
+        source.removeAll(Integer.valueOf(2), Integer.valueOf(6), Integer.valueOf(1));
+        assertEquals("[4]", even.toString());
+    }
+
+    @Test
+    public void filteredListPredicateChange() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(1, 2, 3, 4));
+        FilteredList<Integer> view = new FilteredList<Integer>(source);
+        assertNull(view.getPredicate());
+        assertEquals("no predicate shows everything", "[1, 2, 3, 4]", view.toString());
+        Probe.ListChanges<Integer> probe = new Probe.ListChanges<Integer>();
+        view.addListener(probe);
+        view.setPredicate(n -> n.intValue() > 2);
+        assertEquals("[3, 4]", view.toString());
+        assertEquals(1, probe.events);
+        view.predicateProperty().set(n -> n.intValue() < 2);
+        assertEquals("[1]", view.toString());
+        assertEquals(2, probe.events);
+        view.setPredicate(null);
+        assertEquals(4, view.size());
+    }
+
+    @Test
+    public void filteredListIsReadOnly() {
+        FilteredList<Integer> view = new FilteredList<Integer>(FXCollections.observableArrayList(ints(1)));
+        try {
+            view.add(Integer.valueOf(2));
+            fail("expected UnsupportedOperationException");
+        } catch (UnsupportedOperationException expected) {
+            assertEquals(1, view.size());
+        }
+    }
+
+    @Test
+    public void sortedListOrdersItsSource() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(3, 1, 2));
+        SortedList<Integer> sorted = new SortedList<Integer>(source, Comparator.<Integer>naturalOrder());
+        assertEquals("[1, 2, 3]", sorted.toString());
+        assertEquals("[3, 1, 2]", source.toString());
+        assertEquals(1, sorted.getSourceIndex(0));
+        assertEquals(0, sorted.getSourceIndex(2));
+        assertEquals(2, sorted.getViewIndex(0));
+        assertEquals(0, sorted.getViewIndex(1));
+    }
+
+    @Test
+    public void sortedListPropagatesSourceChanges() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(30, 10));
+        SortedList<Integer> sorted = source.sorted();
+        Probe.ListChanges<Integer> probe = new Probe.ListChanges<Integer>();
+        sorted.addListener(probe);
+        source.add(Integer.valueOf(20));
+        assertEquals("[add[1,2] +[20]]", probe.take());
+        assertEquals("[10, 20, 30]", sorted.toString());
+        source.add(Integer.valueOf(5));
+        assertEquals("[add[0,1] +[5]]", probe.take());
+        source.remove(Integer.valueOf(20));
+        assertEquals("[rem[2] -[20]]", probe.take());
+        assertEquals("[5, 10, 30]", sorted.toString());
+        source.set(0, Integer.valueOf(7));
+        assertEquals("[5, 7, 10]", sorted.toString());
+        assertEquals(1, probe.events - 3);
+        probe.take();
+        source.addAll(ints(1, 100));
+        assertEquals("[1, 5, 7, 10, 100]", sorted.toString());
+        assertEquals("[add[0,1] +[1], add[4,5] +[100]]", probe.take());
+        source.clear();
+        assertEquals("[rem[0] -[1, 5, 7, 10, 100]]", probe.take());
+    }
+
+    @Test
+    public void sortedListIsStableForEqualElements() {
+        ObservableList<String> source = FXCollections.observableArrayList("bb", "a", "cc", "d");
+        SortedList<String> byLength = source.sorted(new Comparator<String>() {
+            @Override
+            public int compare(String first, String second) {
+                return first.length() - second.length();
+            }
+        });
+        assertEquals("[a, d, bb, cc]", byLength.toString());
+        source.add("e");
+        assertEquals("[a, d, e, bb, cc]", byLength.toString());
+        source.add(0, "ff");
+        assertEquals("[a, d, e, ff, bb, cc]", byLength.toString());
+    }
+
+    @Test
+    public void sortedListComparatorChangeIsAPermutation() {
+        ObservableList<Integer> source = FXCollections.observableArrayList(ints(2, 3, 1));
+        SortedList<Integer> sorted = new SortedList<Integer>(source, Comparator.<Integer>naturalOrder());
+        Probe.ListChanges<Integer> probe = new Probe.ListChanges<Integer>();
+        sorted.addListener(probe);
+        sorted.setComparator(Comparator.<Integer>reverseOrder());
+        assertEquals("[3, 2, 1]", sorted.toString());
+        assertEquals("[perm[0,3]{2,1,0}]", probe.take());
+        sorted.setComparator(null);
+        assertEquals("no comparator shows the source order", "[2, 3, 1]", sorted.toString());
+        assertNull(sorted.getComparator());
+        sorted.comparatorProperty().set(Comparator.<Integer>naturalOrder());
+        assertEquals("[1, 2, 3]", sorted.toString());
+    }
+
+    @Test
+    public void sortedOverFilteredFollowsRandomEdits() {
+        ObservableList<Integer> source = FXCollections.observableArrayList();
+        FilteredList<Integer> filtered = source.filtered(n -> n.intValue() % 3 != 0);
+        SortedList<Integer> sorted = filtered.sorted();
+        final List<Integer> mirror = new ArrayList<Integer>();
+        sorted.addListener(new javafx.collections.ListChangeListener<Integer>() {
+            @Override
+            public void onChanged(Change<? extends Integer> c) {
+                while (c.next()) {
+                    if (c.wasPermutated()) {
+                        List<Integer> before = new ArrayList<Integer>(mirror.subList(c.getFrom(), c.getTo()));
+                        for (int i = c.getFrom(); i < c.getTo(); i++) {
+                            mirror.set(c.getPermutation(i), before.get(i - c.getFrom()));
+                        }
+                    } else {
+                        for (int i = 0; i < c.getRemovedSize(); i++) {
+                            mirror.remove(c.getFrom());
+                        }
+                        mirror.addAll(c.getFrom(), c.getAddedSubList());
+                    }
+                }
+            }
+        });
+        Random random = new Random(7);
+        for (int step = 0; step < 400; step++) {
+            int action = random.nextInt(6);
+            if (action < 2 || source.isEmpty()) {
+                source.add(random.nextInt(source.size() + 1), Integer.valueOf(random.nextInt(50)));
+            } else if (action == 2) {
+                source.remove(random.nextInt(source.size()));
+            } else if (action == 3) {
+                source.set(random.nextInt(source.size()), Integer.valueOf(random.nextInt(50)));
+            } else if (action == 4) {
+                source.removeAll(Integer.valueOf(random.nextInt(50)), Integer.valueOf(random.nextInt(50)));
+            } else {
+                FXCollections.shuffle(source, random);
+            }
+            List<Integer> expected = new ArrayList<Integer>();
+            for (Integer value : source) {
+                if (value.intValue() % 3 != 0) {
+                    expected.add(value);
+                }
+            }
+            assertEquals("filtered view after step " + step, expected, new ArrayList<Integer>(filtered));
+            Collections.sort(expected);
+            assertEquals("sorted view after step " + step, expected, new ArrayList<Integer>(sorted));
+            assertEquals("replaying the reported changes after step " + step, expected, mirror);
+        }
+        assertFalse(sorted.isInTransformationChain(FXCollections.observableArrayList()));
+        assertTrue(sorted.isInTransformationChain(source));
+    }
+
+    @Test
+    public void replayingListChangesReproducesTheList() {
+        final ObservableList<Integer> source = FXCollections.observableArrayList();
+        final List<Integer> mirror = new ArrayList<Integer>();
+        source.addListener(new javafx.collections.ListChangeListener<Integer>() {
+            @Override
+            public void onChanged(Change<? extends Integer> c) {
+                while (c.next()) {
+                    if (c.wasPermutated()) {
+                        List<Integer> before = new ArrayList<Integer>(mirror.subList(c.getFrom(), c.getTo()));
+                        for (int i = c.getFrom(); i < c.getTo(); i++) {
+                            mirror.set(c.getPermutation(i), before.get(i - c.getFrom()));
+                        }
+                    } else if (!c.wasUpdated()) {
+                        for (int i = 0; i < c.getRemovedSize(); i++) {
+                            assertEquals(c.getRemoved().get(i), mirror.remove(c.getFrom()));
+                        }
+                        mirror.addAll(c.getFrom(), c.getAddedSubList());
+                    }
+                }
+            }
+        });
+        Random random = new Random(11);
+        for (int step = 0; step < 500; step++) {
+            int action = random.nextInt(9);
+            if (action < 2 || source.size() < 2) {
+                source.addAll(random.nextInt(source.size() + 1), ints(random.nextInt(20), random.nextInt(20)));
+            } else if (action == 2) {
+                source.remove(random.nextInt(source.size()));
+            } else if (action == 3) {
+                source.set(random.nextInt(source.size()), Integer.valueOf(random.nextInt(20)));
+            } else if (action == 4) {
+                source.removeAll(ints(random.nextInt(20), random.nextInt(20), random.nextInt(20)));
+            } else if (action == 5) {
+                source.retainAll(ints(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, random.nextInt(20)));
+            } else if (action == 6) {
+                FXCollections.sort(source);
+            } else if (action == 7) {
+                int from = random.nextInt(source.size());
+                source.subList(from, from + random.nextInt(source.size() - from)).clear();
+            } else {
+                final int limit = random.nextInt(20);
+                source.removeIf(n -> n.intValue() > limit && n.intValue() % 2 == 0);
+            }
+            assertEquals("after step " + step, new ArrayList<Integer>(source), mirror);
+        }
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/UtilTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/UtilTest.java
new file mode 100644
index 00000000000..87367a07b79
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/UtilTest.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+
+import javafx.util.Callback;
+import javafx.util.Duration;
+import javafx.util.Pair;
+import javafx.util.StringConverter;
+import javafx.util.converter.BooleanStringConverter;
+import javafx.util.converter.DefaultStringConverter;
+import javafx.util.converter.DoubleStringConverter;
+import javafx.util.converter.IntegerStringConverter;
+import javafx.util.converter.NumberStringConverter;
+
+public class UtilTest {
+
+    /// Color.web as OpenJFX reads it (each expectation is what OpenJFX 23
+    /// and 27 print): components are clamped, hsl() is hue, saturation
+    /// and brightness, and only the opacity passed on top is refused when
+    /// the product leaves 0-1.
+    @Test
+    public void webColorsReadAsOpenJfxReadsThem() {
+        assertEquals("0xff0000ff", javafx.scene.paint.Color.web("rgb(300,0,0)").toString());
+        assertEquals("0x000000ff", javafx.scene.paint.Color.web("rgb(-5,0,0)").toString());
+        assertEquals("0xff0000ff", javafx.scene.paint.Color.web("rgba(255,0,0,1.5)").toString());
+        assertEquals("0x800000ff", javafx.scene.paint.Color.web("hsl(0,100%,50%)").toString());
+        assertEquals("0x004000ff", javafx.scene.paint.Color.web("hsl(120,100%,25%)").toString());
+        assertEquals("0x6060bfff", javafx.scene.paint.Color.web("hsl(240,50%,75%)").toString());
+        String[][] refused = {{"rgba(255,0,0,0.6)", "2"}, {"rgb(255,0,0)", "2"}, {"rgb(255,0,0)", "-1"},
+            {"hsl(0,100%,50%)", "2"}, {"red", "2"}};
+        for (String[] r : refused) {
+            try {
+                javafx.scene.paint.Color.web(r[0], Double.parseDouble(r[1]));
+                fail(r[0] + " at opacity " + r[1]);
+            } catch (IllegalArgumentException expected) {
+                assertTrue(expected.getMessage(), expected.getMessage().startsWith("Color's opacity value"));
+            }
+        }
+    }
+
+    @Test
+    public void durationFactoriesAndConversions() {
+        assertEquals(1500.0, Duration.seconds(1.5).toMillis(), 0d);
+        assertEquals(120000.0, Duration.minutes(2).toMillis(), 0d);
+        assertEquals(7200000.0, Duration.hours(2).toMillis(), 0d);
+        Duration d = Duration.millis(90000);
+        assertEquals(90.0, d.toSeconds(), 0d);
+        assertEquals(1.5, d.toMinutes(), 0d);
+        assertEquals(0.025, d.toHours(), 1e-12);
+        assertSame(Duration.ZERO, Duration.millis(0));
+        assertSame(Duration.ONE, Duration.millis(1));
+        assertSame(Duration.INDEFINITE, Duration.millis(Double.POSITIVE_INFINITY));
+        assertSame(Duration.UNKNOWN, Duration.seconds(Double.NaN));
+        assertEquals(250.0, new Duration(250).toMillis(), 0d);
+    }
+
+    @Test
+    public void durationArithmetic() {
+        Duration a = Duration.seconds(3);
+        Duration b = Duration.millis(500);
+        assertEquals(3500.0, a.add(b).toMillis(), 0d);
+        assertEquals(2500.0, a.subtract(b).toMillis(), 0d);
+        assertEquals(6000.0, a.multiply(2).toMillis(), 0d);
+        assertEquals(1500.0, a.divide(2).toMillis(), 0d);
+        assertEquals(-3000.0, a.negate().toMillis(), 0d);
+        assertSame(Duration.ZERO, a.subtract(a));
+        assertTrue(a.add(Duration.INDEFINITE).isIndefinite());
+        assertTrue(a.add(Duration.UNKNOWN).isUnknown());
+        assertTrue(Duration.INDEFINITE.subtract(Duration.INDEFINITE).isUnknown());
+        assertFalse(a.isIndefinite());
+        assertFalse(a.isUnknown());
+        assertTrue(a.divide(0).isIndefinite());
+    }
+
+    @Test
+    public void durationComparison() {
+        Duration a = Duration.seconds(1);
+        Duration b = Duration.seconds(2);
+        assertTrue(a.lessThan(b));
+        assertTrue(a.lessThanOrEqualTo(b));
+        assertTrue(a.lessThanOrEqualTo(Duration.millis(1000)));
+        assertTrue(b.greaterThan(a));
+        assertTrue(b.greaterThanOrEqualTo(a));
+        assertFalse(a.greaterThan(b));
+        assertFalse(a.greaterThan(Duration.UNKNOWN));
+        assertFalse(a.lessThan(Duration.UNKNOWN));
+        assertTrue(a.lessThan(Duration.INDEFINITE));
+        assertTrue(a.compareTo(b) < 0);
+        assertTrue(b.compareTo(a) > 0);
+        assertEquals(0, a.compareTo(Duration.millis(1000)));
+        assertEquals(a, Duration.millis(1000));
+        assertEquals(a.hashCode(), Duration.millis(1000).hashCode());
+        assertNotEquals(a, b);
+        assertNotEquals(a, "1000.0 ms");
+        assertEquals(Duration.UNKNOWN, new Duration(Double.NaN));
+    }
+
+    @Test
+    public void durationParsing() {
+        assertEquals(500.0, Duration.valueOf("500ms").toMillis(), 0d);
+        assertEquals(1500.0, Duration.valueOf("1.5s").toMillis(), 0d);
+        assertEquals(120000.0, Duration.valueOf("2m").toMillis(), 0d);
+        assertEquals(3600000.0, Duration.valueOf("1h").toMillis(), 0d);
+        assertEquals(-250.0, Duration.valueOf("-250ms").toMillis(), 0d);
+        assertEquals(500.0, Duration.valueOf(".5s").toMillis(), 0d);
+        assertEquals("units fold as ASCII", 2000.0, Duration.valueOf("2S").toMillis(), 0d);
+        assertEquals(3.0, Duration.valueOf("3MS").toMillis(), 0d);
+        assertSame(Duration.ZERO, Duration.valueOf("0s"));
+        String[] malformed = {"", "10", "ms", "10 ms", "10x", "1.2.3s", "s10", "10sec", "--1s"};
+        for (String text : malformed) {
+            try {
+                Duration.valueOf(text);
+                fail("expected IllegalArgumentException for \"" + text + "\"");
+            } catch (IllegalArgumentException expected) {
+                assertTrue(expected.getMessage().length() > 0);
+            }
+        }
+        try {
+            Duration.valueOf(null);
+            fail("expected NullPointerException");
+        } catch (NullPointerException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void durationText() {
+        assertEquals("1500.0 ms", Duration.seconds(1.5).toString());
+        assertEquals("0.0 ms", Duration.ZERO.toString());
+        assertEquals("-2.5 ms", Duration.millis(-2.5).toString());
+        assertEquals("INDEFINITE", Duration.INDEFINITE.toString());
+        assertEquals("UNKNOWN", Duration.UNKNOWN.toString());
+    }
+
+    @Test
+    public void pair() {
+        Pair<String, Integer> pair = new Pair<String, Integer>("k", Integer.valueOf(1));
+        assertEquals("k", pair.getKey());
+        assertEquals(Integer.valueOf(1), pair.getValue());
+        assertEquals("k=1", pair.toString());
+        assertEquals(pair, new Pair<String, Integer>("k", Integer.valueOf(1)));
+        assertEquals(pair.hashCode(), new Pair<String, Integer>("k", Integer.valueOf(1)).hashCode());
+        assertNotEquals(pair, new Pair<String, Integer>("k", Integer.valueOf(2)));
+        assertNotEquals(pair, new Pair<String, Integer>("j", Integer.valueOf(1)));
+        assertNotEquals(pair, "k=1");
+        Pair<String, Integer> nulls = new Pair<String, Integer>(null, null);
+        assertEquals(nulls, new Pair<String, Integer>(null, null));
+        assertEquals("null=null", nulls.toString());
+        assertNotEquals(nulls, pair);
+        assertNotEquals(pair, nulls);
+    }
+
+    @Test
+    public void callback() {
+        Callback<String, Integer> length = new Callback<String, Integer>() {
+            @Override
+            public Integer call(String param) {
+                return Integer.valueOf(param.length());
+            }
+        };
+        assertEquals(Integer.valueOf(3), length.call("abc"));
+        Callback<Integer, Integer> twice = n -> Integer.valueOf(n.intValue() * 2);
+        assertEquals(Integer.valueOf(8), twice.call(Integer.valueOf(4)));
+    }
+
+    @Test
+    public void simpleConverters() {
+        StringConverter<String> text = new DefaultStringConverter();
+        assertEquals("a", text.toString("a"));
+        assertEquals("", text.toString(null));
+        assertEquals("a", text.fromString("a"));
+        assertNull(text.fromString(null));
+
+        StringConverter<Boolean> bool = new BooleanStringConverter();
+        assertEquals("true", bool.toString(Boolean.TRUE));
+        assertEquals("false", bool.toString(Boolean.FALSE));
+        assertEquals("", bool.toString(null));
+        assertEquals(Boolean.TRUE, bool.fromString(" TRUE "));
+        assertEquals(Boolean.TRUE, bool.fromString("true"));
+        assertEquals(Boolean.FALSE, bool.fromString("yes"));
+        assertNull(bool.fromString("  "));
+        assertNull(bool.fromString(null));
+
+        StringConverter<Integer> integer = new IntegerStringConverter();
+        assertEquals("42", integer.toString(Integer.valueOf(42)));
+        assertEquals("-7", integer.toString(Integer.valueOf(-7)));
+        assertEquals("", integer.toString(null));
+        assertEquals(Integer.valueOf(42), integer.fromString(" 42 "));
+        assertEquals(Integer.valueOf(-7), integer.fromString("-7"));
+        assertNull(integer.fromString(""));
+        assertNull(integer.fromString(null));
+        try {
+            integer.fromString("4.2");
+            fail("expected NumberFormatException");
+        } catch (NumberFormatException expected) {
+            assertTrue(true);
+        }
+
+        StringConverter<Double> dbl = new DoubleStringConverter();
+        assertEquals("1.5", dbl.toString(Double.valueOf(1.5)));
+        assertEquals("", dbl.toString(null));
+        assertEquals(Double.valueOf(1.5), dbl.fromString(" 1.5 "));
+        assertEquals(Double.valueOf(3), dbl.fromString("3"));
+        assertNull(dbl.fromString(" "));
+        try {
+            dbl.fromString("abc");
+            fail("expected NumberFormatException");
+        } catch (NumberFormatException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void numberConverterFormats() {
+        NumberStringConverter c = new NumberStringConverter();
+        assertEquals("", c.toString(null));
+        assertEquals("0", c.toString(Integer.valueOf(0)));
+        assertEquals("42", c.toString(Integer.valueOf(42)));
+        assertEquals("1,234", c.toString(Integer.valueOf(1234)));
+        assertEquals("-1,234,567", c.toString(Long.valueOf(-1234567L)));
+        assertEquals("999", c.toString(Long.valueOf(999)));
+        assertEquals("1,000", c.toString(Long.valueOf(1000)));
+        assertEquals("-9,223,372,036,854,775,808", c.toString(Long.valueOf(Long.MIN_VALUE)));
+        assertEquals("1.5", c.toString(Double.valueOf(1.5)));
+        assertEquals("1,234.568", c.toString(Double.valueOf(1234.5678)));
+        assertEquals("0.125", c.toString(Double.valueOf(0.125)));
+        assertEquals("half rounds to the even digit", "0.062", c.toString(Double.valueOf(0.0625)));
+        assertEquals("0.188", c.toString(Double.valueOf(0.1875)));
+        assertEquals("2", c.toString(Double.valueOf(1.9999)));
+        assertEquals("3", c.toString(Double.valueOf(3.0)));
+        assertEquals("-0.5", c.toString(Double.valueOf(-0.5)));
+        assertEquals("0", c.toString(Double.valueOf(-0.0001)));
+        assertEquals("2.5", c.toString(Float.valueOf(2.5f)));
+        assertEquals("NaN", c.toString(Double.valueOf(Double.NaN)));
+        assertEquals("10,000,000,000,000,000", c.toString(Double.valueOf(1e16)));
+    }
+
+    @Test
+    public void numberConverterParses() {
+        NumberStringConverter c = new NumberStringConverter();
+        assertNull(c.fromString(null));
+        assertNull(c.fromString("   "));
+        assertEquals(Long.valueOf(42), c.fromString("42"));
+        assertEquals(Long.valueOf(1234567), c.fromString(" 1,234,567 "));
+        assertEquals(Long.valueOf(-5), c.fromString("-5"));
+        assertEquals(Double.valueOf(1.5), c.fromString("1.5"));
+        assertEquals(Double.valueOf(1234.25), c.fromString("1,234.25"));
+        assertEquals("a whole number is a Long", Long.valueOf(3), c.fromString("3.0"));
+        try {
+            c.fromString("abc");
+            fail("expected RuntimeException");
+        } catch (RuntimeException expected) {
+            assertTrue(expected.getMessage().indexOf("abc") >= 0);
+        }
+        assertEquals(Long.valueOf(1234), c.fromString(c.toString(Integer.valueOf(1234))));
+    }
+}
diff --git a/maven/javafx-compat/src/test/java/com/codename1/fxcompat/WritableImageTest.java b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/WritableImageTest.java
new file mode 100644
index 00000000000..5ce2b12b5b4
--- /dev/null
+++ b/maven/javafx-compat/src/test/java/com/codename1/fxcompat/WritableImageTest.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.fxcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.fxcompat.runtime.Renderer;
+import com.codename1.fxcompat.runtime.Units;
+
+import javafx.geometry.Rectangle2D;
+import javafx.scene.Group;
+import javafx.scene.SnapshotParameters;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.image.ImageView;
+import javafx.scene.image.PixelReader;
+import javafx.scene.image.PixelWriter;
+import javafx.scene.image.WritableImage;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.transform.Translate;
+
+/// An image the application writes, and a node rendered into one.
+public class WritableImageTest {
+
+    @Rule
+    public final MainThreadRule mainThread = new MainThreadRule();
+
+    private final List<String> drawn = new ArrayList<String>();
+
+    @Before
+    public void setUp() {
+        HeadlessImplementation.install();
+        Units.setScale(2);
+    }
+
+    @After
+    public void tearDown() {
+        Renderer.setTrace(null);
+        Units.setScale(0);
+    }
+
+    @Test
+    public void whatIsWrittenIsReadBackAndTheDrawnImageFollows() {
+        WritableImage image = new WritableImage(4, 3);
+        assertEquals(4, image.getWidth(), 0);
+        assertEquals(3, image.getHeight(), 0);
+        assertEquals(1, image.getProgress(), 0);
+        PixelWriter writer = image.getPixelWriter();
+        PixelReader reader = image.getPixelReader();
+        assertSame(writer, image.getPixelWriter());
+        assertEquals(0, reader.getArgb(1, 1));
+        com.codename1.ui.Image before = image.cn1Native();
+        assertSame("nothing was written: the same image is drawn", before, image.cn1Native());
+        writer.setArgb(1, 2, 0x80112233);
+        writer.setColor(3, 0, Color.RED);
+        assertEquals(0x80112233, reader.getArgb(1, 2));
+        assertEquals(0xffff0000, reader.getArgb(3, 0));
+        assertEquals(Color.RED, reader.getColor(3, 0));
+        assertEquals(0x80 / 255.0, reader.getColor(1, 2).getOpacity(), 0.001);
+        com.codename1.ui.Image after = image.cn1Native();
+        assertNotSame("a write makes the image that is drawn anew", before, after);
+        assertSame(after, image.cn1Native());
+
+        // A copy through a reader, and a rectangle of one.
+        WritableImage copy = new WritableImage(reader, 4, 3);
+        assertEquals(0x80112233, copy.getPixelReader().getArgb(1, 2));
+        WritableImage part = new WritableImage(reader, 3, 0, 1, 1);
+        assertEquals(0xffff0000, part.getPixelReader().getArgb(0, 0));
+        WritableImage target = new WritableImage(2, 2);
+        target.getPixelWriter().setPixels(1, 1, 1, 1, reader, 3, 0);
+        assertEquals(0xffff0000, target.getPixelReader().getArgb(1, 1));
+        assertEquals(0, target.getPixelReader().getArgb(0, 0));
+
+        try {
+            writer.setArgb(4, 0, 1);
+            fail("outside the image");
+        } catch (IndexOutOfBoundsException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            new WritableImage(0, 5);
+            fail("no width");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+    }
+
+    @Test
+    public void aViewOfTheImageDrawsWhatWasWrittenLast() {
+        WritableImage image = new WritableImage(2, 2);
+        ImageView view = new ImageView(image);
+        final com.codename1.ui.Image[] shown = new com.codename1.ui.Image[1];
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String what, double[] bounds, Paint paint, String text) {
+                drawn.add(what);
+            }
+        });
+        com.codename1.ui.Image first = image.cn1Native();
+        image.getPixelWriter().setArgb(0, 0, 0xff00ff00);
+        // The view asks the image again: it is not left showing the picture from before the write.
+        view.cn1Paint(new Renderer(com.codename1.ui.Image.createImage(4, 4, 0).getGraphics(), 0, 0));
+        assertEquals("[image]", drawn.toString());
+        shown[0] = image.cn1Native();
+        assertNotSame(first, shown[0]);
+        // Another image, and the first no longer reaches the view.
+        view.setImage(new WritableImage(2, 2));
+        image.getPixelWriter().setArgb(1, 1, 1);
+        view.setImage(null);
+    }
+
+    @Test
+    public void aNodeIsRenderedIntoAnImageOfItsBoundsOrTheOneHandedIn() {
+        Rectangle rect = new Rectangle(10, 20, 30, 40);
+        rect.setFill(Color.BLUE);
+        Group group = new Group(rect);
+        final List<double[]> boxes = new ArrayList<double[]>();
+        Renderer.setTrace(new Renderer.Trace() {
+            @Override
+            public void drawn(String what, double[] bounds, Paint paint, String text) {
+                drawn.add(what + " " + paint);
+                boxes.add(bounds);
+            }
+        });
+        WritableImage image = group.snapshot(null, null);
+        assertEquals(30, image.getWidth(), 0);
+        assertEquals(40, image.getHeight(), 0);
+        // The fill of the image first, white by default, then the rectangle at the origin of the image:
+        // device pixels, two to a logical one.
+        assertEquals(2, drawn.size());
+        assertTrue(drawn.get(0), drawn.get(0).startsWith("fill " + Color.WHITE));
+        assertTrue(drawn.get(1), drawn.get(1).startsWith("fill " + Color.BLUE));
+        assertEquals(0, boxes.get(1)[0], 0.01);
+        assertEquals(0, boxes.get(1)[1], 0.01);
+        assertEquals(60, boxes.get(1)[2], 0.01);
+        assertEquals(80, boxes.get(1)[3], 0.01);
+
+        // An image handed in keeps its size; a transform moves what is drawn and a fill replaces white.
+        drawn.clear();
+        boxes.clear();
+        SnapshotParameters params = new SnapshotParameters();
+        params.setFill(Color.BLACK);
+        params.setTransform(new Translate(5, 0));
+        WritableImage given = new WritableImage(100, 50);
+        assertSame(given, group.snapshot(params, given));
+        assertTrue(drawn.get(0), drawn.get(0).startsWith("fill " + Color.BLACK));
+        assertEquals(200, boxes.get(0)[2], 0.01);
+        assertEquals(100, boxes.get(0)[3], 0.01);
+        // The bounds moved with the transform, so the rectangle is still at the origin of the image.
+        assertEquals(0, boxes.get(1)[0], 0.01);
+
+        // A viewport is the part of the parent that is kept.
+        drawn.clear();
+        boxes.clear();
+        SnapshotParameters part = new SnapshotParameters();
+        part.setViewport(new Rectangle2D(0, 0, 20, 30));
+        WritableImage corner = group.snapshot(part, null);
+        assertEquals(20, corner.getWidth(), 0);
+        assertEquals(30, corner.getHeight(), 0);
+        assertEquals(20, boxes.get(1)[0], 0.01);
+        assertEquals(40, boxes.get(1)[1], 0.01);
+        assertSame(Color.BLACK, params.getFill());
+        assertNotNull(params.getTransform());
+        assertEquals(20, part.getViewport().getWidth(), 0);
+        part.setDepthBuffer(true);
+        assertTrue(part.isDepthBuffer());
+
+        // A canvas is a node like any other.
+        Canvas canvas = new Canvas(8, 8);
+        canvas.getGraphicsContext2D().setFill(Color.GREEN);
+        canvas.getGraphicsContext2D().fillRect(0, 0, 8, 8);
+        drawn.clear();
+        WritableImage of = canvas.snapshot(null, null);
+        assertEquals(8, of.getWidth(), 0);
+        assertTrue(drawn.toString(), drawn.size() >= 2);
+    }
+}
diff --git a/maven/javafx-compat/src/test/resources/cn1-hooks.txt b/maven/javafx-compat/src/test/resources/cn1-hooks.txt
new file mode 100644
index 00000000000..e5fd2d4428f
--- /dev/null
+++ b/maven/javafx-compat/src/test/resources/cn1-hooks.txt
@@ -0,0 +1,87 @@
+# The members of the public javafx.* classes that JavaFX does not have.
+# One per line, binary.class.Name#member, named for the class that
+# introduces it. ApiNamingTest fails when this list and the compiled
+# classes disagree, in either direction.
+com.codename1.fxcompat.runtime.Dirty$Owner#cn1Invalidated
+com.codename1.fxcompat.runtime.StyleTarget#cn1ApplyStyle
+javafx.scene.Cursor#cn1Code
+javafx.scene.Node#CN1_NO_STYLE
+javafx.scene.Node#cn1ClipPath
+javafx.scene.Node#cn1ComputeBoundsInLocal
+javafx.scene.Node#cn1ComputeLayoutBounds
+javafx.scene.Node#cn1CreatePeer
+javafx.scene.Node#cn1DefaultStyle
+javafx.scene.Node#cn1ThemedStyle
+javafx.scene.Node#cn1EffectCache
+javafx.scene.Node#cn1SetEffectCache
+javafx.scene.Node#cn1Events
+javafx.scene.Node#cn1FocusRequested
+javafx.scene.Node#cn1GeometryChanged
+javafx.scene.Node#cn1HasPeer
+javafx.scene.Node#cn1HasPseudoClass
+javafx.scene.Node#cn1Matches
+javafx.scene.Node#cn1Paint
+javafx.scene.Node#cn1PaintMatrix
+javafx.scene.Node#cn1PaintsOutsideBounds
+javafx.scene.Node#cn1Peer
+javafx.scene.Node#cn1PeerCreated
+javafx.scene.Node#cn1PeerResized
+javafx.scene.Node#cn1Pick
+javafx.scene.Node#cn1PickLocal
+javafx.scene.Node#cn1Repaint
+javafx.scene.Node#cn1RequestLayout
+javafx.scene.Node#cn1Restyle
+javafx.scene.Node#cn1SetStyleState
+javafx.scene.Node#cn1SetStyleValue
+javafx.scene.Node#cn1StyleState
+javafx.scene.Node#cn1StyleValue
+javafx.scene.Node#cn1SyncPeerBounds
+javafx.scene.Parent#cn1Children
+javafx.scene.Parent#cn1ClearSizeCache
+javafx.scene.Parent#cn1HasStylesheets
+javafx.scene.Parent#cn1MarkNeedsLayout
+javafx.scene.Parent#cn1PeerChildOffset
+javafx.scene.Parent#cn1PickSelf
+javafx.scene.Parent#cn1SizedByChildren
+javafx.scene.Scene#cn1ContextMenu
+javafx.scene.Scene#cn1FocusInitial
+javafx.scene.Scene#cn1Host
+javafx.scene.Scene#cn1InitialHeight
+javafx.scene.Scene#cn1InitialWidth
+javafx.scene.Scene#cn1Key
+javafx.scene.Scene#cn1Layout
+javafx.scene.Scene#cn1Pointer
+javafx.scene.Scene#cn1PointerExited
+javafx.scene.Scene#cn1RequestPulse
+javafx.scene.Scene#cn1SetFocusOwner
+javafx.scene.Scene#cn1SetHost
+javafx.scene.Scene#cn1Wheel
+javafx.scene.canvas.GraphicsContext#CN1_MAX_RECORDED_CALLS
+javafx.scene.control.ButtonBase#cn1ActionBridge
+javafx.scene.control.Control#cn1CreateNative
+javafx.scene.control.Control#cn1Native
+javafx.scene.control.Control#cn1NativeBand
+javafx.scene.control.Control#cn1NativeIfCreated
+javafx.scene.control.Control#cn1NativePreferredSize
+javafx.scene.control.Control#cn1NativeSizeChanged
+javafx.scene.control.Control#cn1SyncNative
+javafx.scene.image.Image#cn1Native
+javafx.scene.image.WritableImage#cn1SetPixels
+javafx.scene.input.PickResult#cn1SceneX
+javafx.scene.input.PickResult#cn1SceneY
+javafx.scene.paint.Color#cn1Argb
+javafx.scene.shape.Shape#cn1CreatePath
+javafx.scene.text.Font#cn1Native
+javafx.scene.text.Font#cn1Posture
+javafx.scene.text.Font#cn1Weight
+javafx.scene.transform.Transform#cn1Attach
+javafx.scene.transform.Transform#cn1Detach
+javafx.stage.Stage#cn1IsPrimary
+javafx.stage.Stage#cn1MarkPrimary
+javafx.stage.Window#cn1Bounds
+javafx.stage.Window#cn1CloseRequested
+javafx.stage.Window#cn1Embed
+javafx.stage.Window#cn1Embedded
+javafx.stage.Window#cn1Host
+javafx.stage.Window#cn1Show
+javafx.scene.shape.Shape#cn1Outline
diff --git a/maven/javafx-compat/src/test/resources/dot.png b/maven/javafx-compat/src/test/resources/dot.png
new file mode 100644
index 00000000000..6a68df846ae
Binary files /dev/null and b/maven/javafx-compat/src/test/resources/dot.png differ
diff --git a/maven/pom.xml b/maven/pom.xml
index d165caacd07..01c74110a02 100644
--- a/maven/pom.xml
+++ b/maven/pom.xml
@@ -91,8 +91,12 @@
         <module>svg-transcoder</module>
         <!-- Android compatibility: the res/ compiler (used by the Maven and
              Gradle plugins) and the android.* runtime built on top of core. -->
+        <module>compat-testing</module>
         <module>android-res-compiler</module>
         <module>android-compat</module>
+        <module>swing-compat</module>
+        <module>javafx-compat</module>
+        <module>fxml-compiler</module>
         <module>lottie-transcoder</module>
         <module>sqlite-jdbc</module>
         <!-- The backend runtime, after sqlite-jdbc because it depends on it. -->
diff --git a/maven/project-model/src/main/java/com/codename1/project/ProjectLayout.java b/maven/project-model/src/main/java/com/codename1/project/ProjectLayout.java
index 3f50adb3b9f..e23ae53f1a8 100644
--- a/maven/project-model/src/main/java/com/codename1/project/ProjectLayout.java
+++ b/maven/project-model/src/main/java/com/codename1/project/ProjectLayout.java
@@ -269,6 +269,17 @@ public File androidSourceDir() {
         return srcMain("android");
     }
 
+    /// A Swing or JavaFX application's sources (`java/`, `kotlin/`,
+    /// `resources/`), laid out like a desktop project's `src/main`; compiled
+    /// onto the Swing and JavaFX compatibility runtimes. The directory
+    /// existing is what enables those layers.
+    public File desktopSourceDir() {
+        if (isAnt()) {
+            return file(projectDir, "desktop-src");
+        }
+        return srcMain("desktop");
+    }
+
     /// The directory the Game Builder saves scenes to.
     public File gamesDir() {
         return new File(resourcesDir(), "games");
diff --git a/maven/project-model/src/test/java/com/codename1/project/ProjectLayoutsTest.java b/maven/project-model/src/test/java/com/codename1/project/ProjectLayoutsTest.java
index 4f7257ef9c2..2a654813148 100644
--- a/maven/project-model/src/test/java/com/codename1/project/ProjectLayoutsTest.java
+++ b/maven/project-model/src/test/java/com/codename1/project/ProjectLayoutsTest.java
@@ -125,6 +125,8 @@ void mavenPathsMatchTheArchetype() throws IOException {
         assertEquals(new File(root, "android/src/main/java"), l.nativeSourceDir(NativePlatform.ANDROID));
         assertEquals(new File(root, "ios/src/main/objectivec"), l.nativeSourceDir(NativePlatform.IOS));
         assertEquals(new File(root, "cn1libs"), l.legacyCn1libDir());
+        assertEquals(new File(common, "src/main/android"), l.androidSourceDir());
+        assertEquals(new File(common, "src/main/desktop"), l.desktopSourceDir());
         assertEquals(new File(common, "pom.xml"), l.dependencyFile());
         assertEquals(new File(root, "backend"), l.backendDir());
         assertEquals(new File(common, "target/css/theme.css.merged"), l.cssMergeFile(l.themeCss()));
@@ -389,6 +391,15 @@ void antPaths() throws IOException {
         assertEquals(new File(root, "lib/impl/css"), l.libraryCssDir());
         assertEquals(new File(root, "css/theme.css.merged"), l.cssMergeFile(l.themeCss()));
         assertEquals(new File(root, "lib"), l.legacyCn1libDir());
+        assertEquals(new File(root, "desktop-src"), l.desktopSourceDir());
+    }
+
+    /// A Gradle application has no common module: the desktop sources sit
+    /// beside the application's own.
+    @Test
+    void gradleDesktopSourcesAreInTheProject() throws IOException {
+        File root = gradleApp().getCanonicalFile();
+        assertEquals(new File(root, "src/main/desktop"), ProjectLayouts.detect(root).desktopSourceDir());
     }
 
     @Test
diff --git a/maven/swing-compat/pom.xml b/maven/swing-compat/pom.xml
new file mode 100644
index 00000000000..18b055c514d
--- /dev/null
+++ b/maven/swing-compat/pom.xml
@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+
+    <parent>
+        <groupId>com.codenameone</groupId>
+        <artifactId>codenameone</artifactId>
+        <version>8.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>codenameone-swing-compat</artifactId>
+    <version>8.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>codenameone-swing-compat</name>
+    <description>
+        The java.awt, javax.swing, java.beans and SwingX APIs
+        implemented on top of Codename One components, so desktop
+        Swing code runs on devices. The JDK owns those package names,
+        so an application keeps compiling against the JDK's own
+        classes and this module is authored directly under the names
+        it ships as, com.codename1.desktopcompat.*; the remap step of
+        the build plugins rewrites the application's references to
+        match.
+    </description>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>com.github.spotbugs</groupId>
+                <artifactId>spotbugs-maven-plugin</artifactId>
+                <version>4.7.3.4</version>
+                <configuration>
+                    <effort>Max</effort>
+                    <threshold>Low</threshold>
+                    <failOnError>false</failOnError>
+                    <xmlOutput>true</xmlOutput>
+                    <xmlOutputDirectory>${project.build.directory}</xmlOutputDirectory>
+                    <excludeFilterFile>${project.basedir}/spotbugs-exclude.xml</excludeFilterFile>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>spotbugs</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>spotbugs</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- The headless Codename One implementation the tests run on. -->
+        <dependency>
+            <groupId>com.codenameone</groupId>
+            <artifactId>codenameone-compat-testing</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- The real SwingX, for SwingXApiShapeTest alone: the layer's
+             org.jdesktop classes are held to its signatures. Test scope on
+             purpose; nothing the module ships may name it. -->
+        <dependency>
+            <groupId>org.swinglabs.swingx</groupId>
+            <artifactId>swingx-all</artifactId>
+            <version>1.6.5-1</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- The real FlatLaf and RSyntaxTextArea, for the API shape tests
+             alone: the layer's com.formdev.flatlaf and org.fife classes are
+             held to their signatures. Test scope on purpose; nothing the
+             module ships may name them. RSyntaxTextArea is the last line
+             that is Java 8 bytecode, which is what these tests run on. -->
+        <dependency>
+            <groupId>com.formdev</groupId>
+            <artifactId>flatlaf</artifactId>
+            <version>3.7.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.formdev</groupId>
+            <artifactId>flatlaf-extras</artifactId>
+            <version>3.7.1</version>
+            <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>*</groupId>
+                    <artifactId>*</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.fifesoft</groupId>
+            <artifactId>rsyntaxtextarea</artifactId>
+            <version>3.6.0</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/maven/swing-compat/spotbugs-exclude.xml b/maven/swing-compat/spotbugs-exclude.xml
new file mode 100644
index 00000000000..431b10d3bc2
--- /dev/null
+++ b/maven/swing-compat/spotbugs-exclude.xml
@@ -0,0 +1,740 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Intentional SpotBugs exceptions for this module. The report is a
+     zero-findings gate, so every entry is scoped and explained. -->
+<FindBugsFilter>
+
+    <!-- AWT and Swing are an object graph by contract: getParent(),
+         getLayout(), getModel(), getContentPane(), an event's getChild()
+         return THE object, and a setter or constructor keeps the one it is
+         given. A defensive copy would be a different component. Scoped to
+         the relocated JDK packages, whose signatures are not ours to
+         change. -->
+    <Match>
+        <Class name="~com\.codename1\.desktopcompat\.(java\.awt|java\.beans|javax\.swing|javax\.accessibility)\..*"/>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- The runtime's wiring objects exist to hold a reference to the
+         component, form, image or graphics they bridge to. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.rt.PeerSupport"/>
+            <Class name="com.codename1.desktopcompat.rt.FrameForm"/>
+            <Class name="com.codename1.desktopcompat.rt.EmbedHost"/>
+            <Class name="com.codename1.desktopcompat.rt.LayoutBridge"/>
+            <Class name="com.codename1.desktopcompat.rt.NativeImage"/>
+            <Class name="com.codename1.desktopcompat.rt.G2D"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- The focus owner is one component for the whole application, as in
+         AWT's KeyboardFocusManager; it is read and written on the event
+         dispatch thread only. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.EventBridge"/>
+        <Or>
+            <Bug pattern="EI_EXPOSE_STATIC_REP2"/>
+            <Bug pattern="MS_EXPOSE_REP"/>
+        </Or>
+    </Match>
+
+    <!-- Object.clone() returns null for anything but an array on ParparVM
+         and in the CLDC class library, so no clone() here may call
+         super.clone(); each one copies its fields explicitly. -->
+    <Match>
+        <Class name="~com\.codename1\.desktopcompat\.java\.awt\..*"/>
+        <Method name="clone"/>
+        <Bug pattern="CN_IDIOM_NO_SUPER_CALL"/>
+    </Match>
+
+    <!-- The event classes are Serializable only because java.util.EventObject
+         is. A device has no object streams, so there is no serialized form
+         to version and no field that could fail to be written. -->
+    <Match>
+        <Class name="~com\.codename1\.desktopcompat\.(java\.awt\.event|java\.beans|javax\.swing\.event|javax\.swing\.text\.html)\..*Event"/>
+        <Or>
+            <Bug pattern="SE_NO_SERIALVERSIONID"/>
+            <Bug pattern="SE_BAD_FIELD"/>
+        </Or>
+    </Match>
+
+    <!-- The four public arrays are GridBagLayout's API: the application
+         assigns them to set minimum sizes and weights, the layout only
+         reads them. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.java.awt.GridBagLayout"/>
+        <Bug pattern="UWF_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD"/>
+    </Match>
+
+    <!-- Swing's constructors build the root pane through overridable
+         methods (setRootPane, setContentPane, setLayout), and applications
+         override them counting on that. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.javax.swing.JFrame"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JDialog"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JRootPane"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JInternalFrame"/>
+        </Or>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- The JDK documents null, not an empty array, as the answer of these
+         three when there is nothing selected or no key defined, and callers
+         test for it. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.AbstractAction"/>
+                <Method name="getKeys"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.AbstractButton"/>
+                <Method name="getSelectedObjects"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.DefaultButtonModel"/>
+                <Method name="getSelectedObjects"/>
+            </And>
+        </Or>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+
+    <!-- Point and Rectangle define equals and inherit hashCode from Point2D
+         and Rectangle2D, exactly as the JDK's do; the inherited hash is
+         computed from the same coordinates and is consistent with both. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.java.awt.Point"/>
+            <Class name="com.codename1.desktopcompat.java.awt.Rectangle"/>
+        </Or>
+        <Bug pattern="HE_EQUALS_NO_HASHCODE"/>
+    </Match>
+
+    <!-- Rectangle is declared "implements Shape, Serializable" in the JDK
+         although Rectangle2D already implements Shape; the declaration is
+         kept so the class has the JDK's shape. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.java.awt.Rectangle"/>
+        <Bug pattern="RI_REDUNDANT_INTERFACES"/>
+    </Match>
+
+    <!-- Exact comparison is the specification here: two transforms are
+         equal when their six entries are, and the type flags ask whether an
+         entry IS 0 or 1, not whether it is near it. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.java.awt.geom.AffineTransform"/>
+        <Or>
+            <Method name="equals"/>
+            <Method name="getType"/>
+        </Or>
+        <Bug pattern="FE_FLOATING_POINT_EQUALITY"/>
+    </Match>
+
+    <!-- Created on first use by the event dispatch thread, which is the
+         only thread that touches the toolkit; the layer takes no locks. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.java.awt.Toolkit"/>
+        <Method name="getDefaultToolkit"/>
+        <Bug pattern="LI_LAZY_INIT_STATIC"/>
+    </Match>
+
+    <!-- EventQueue has a public constructor in the JDK and
+         Toolkit.getSystemEventQueue() must return an instance, even though
+         everything the layer implements on it is static. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.DesktopToolkit"/>
+        <Bug pattern="ISC_INSTANTIATE_STATIC_CLASS"/>
+    </Match>
+    <!-- BEGIN widgets slice -->
+
+    <!-- Swing's own contract: each of these constructors builds a part of
+         the component through a protected factory method a subclass may
+         replace (createViewport and the scroll bars, createSelectionModel,
+         createDefaultModel), or installs the document through the public
+         setDocument. Calling them from the constructor is the documented
+         extension point, so it cannot be made final or private here. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.javax.swing.JScrollPane"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JList"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JTextArea"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JTextField"/>
+        </Or>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- The stamp exists to paint a component somebody else owns: the
+         renderer hands it the cell for one paint and takes it back. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.CellStamp"/>
+        <Method name="setCell"/>
+        <Bug pattern="EI_EXPOSE_REP2"/>
+    </Match>
+
+    <!-- END widgets slice -->
+
+    <!-- BEGIN table-tree slice -->
+
+    <!-- The JDK builds a table, its header, a column model and a tree
+         editor through protected factory and setter methods
+         (createDefaultColumnModel, setColumnModel, createDefaultRenderers,
+         createTreeCellEditor, ...) called from the constructor, and
+         applications override them counting on that. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.javax.swing.JTable"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.table.JTableHeader"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.table.DefaultTableColumnModel"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellEditor"/>
+        </Or>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- The JDK documents null, not an empty array, as the answer of
+         these: no selection, no rows between two indexes, a structure event
+         that names no children, a path of no node. Callers test for it. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.JTree"/>
+                <Or>
+                    <Method name="getSelectionPaths"/>
+                    <Method name="getPathBetweenRows"/>
+                </Or>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.tree.DefaultTreeSelectionModel"/>
+                <Method name="getSelectionPaths"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.event.TreeModelEvent"/>
+                <Or>
+                    <Method name="getChildIndices"/>
+                    <Method name="getChildren"/>
+                </Or>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode"/>
+                <Method name="getPathToRoot"/>
+            </And>
+        </Or>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+
+    <!-- Object.clone() answers null for anything but an array on a device,
+         so these two copy themselves field by field instead of calling
+         super.clone(). -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.tree.DefaultTreeSelectionModel"/>
+        </Or>
+        <Method name="clone"/>
+        <Bug pattern="CN_IDIOM_NO_SUPER_CALL"/>
+    </Match>
+
+    <!-- noFocusBorder is "protected static Border", not final, in the JDK,
+         and subclasses of the renderer assign it. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.table.DefaultTableCellRenderer"/>
+        <Field name="noFocusBorder"/>
+        <Bug pattern="MS_SHOULD_BE_FINAL"/>
+    </Match>
+
+    <!-- END table-tree slice -->
+
+    <!-- BEGIN windows-menus slice -->
+
+    <!-- The JDK documents null, not an empty array, as the answer of these
+         when there is no key, nothing selected, or no option set, and
+         callers test for it. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.ActionMap"/>
+                <Method name="keys"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.InputMap"/>
+                <Method name="keys"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.JCheckBoxMenuItem"/>
+                <Method name="getSelectedObjects"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.JOptionPane"/>
+                <Or>
+                    <Method name="getOptions"/>
+                    <Method name="getSelectionValues"/>
+                </Or>
+            </And>
+        </Or>
+        <Bug pattern="PZLA_PREFER_ZERO_LENGTH_ARRAYS"/>
+    </Match>
+
+    <!-- Created on first use by the event dispatch thread, the only thread
+         that touches them; the layer takes no locks. Creating them when the
+         class loads would have a superclass initializer create its own
+         subclass, and JOptionPane a frame no application asked for. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.java.awt.GraphicsEnvironment"/>
+                <Method name="getLocalGraphicsEnvironment"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.java.awt.KeyboardFocusManager"/>
+                <Method name="getCurrentKeyboardFocusManager"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.JOptionPane"/>
+                <Method name="getRootFrame"/>
+            </And>
+        </Or>
+        <Bug pattern="LI_LAZY_INIT_STATIC"/>
+    </Match>
+
+    <!-- Each of these is one object for the whole application by the
+         JDK's contract: the caller gets THE focus manager, THE menu
+         selection manager, THE root frame, and sets the root frame it is
+         given. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.java.awt.KeyboardFocusManager"/>
+                <Method name="getCurrentKeyboardFocusManager"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.MenuSelectionManager"/>
+                <Method name="defaultManager"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.JOptionPane"/>
+                <Or>
+                    <Method name="getRootFrame"/>
+                    <Method name="setRootFrame"/>
+                </Or>
+            </And>
+        </Or>
+        <Or>
+            <Bug pattern="MS_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_STATIC_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- The container a window's peer pans in exists to hold the window
+         whose minimum size it lays that peer out at. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.RootPan"/>
+        <Bug pattern="EI_EXPOSE_REP2"/>
+    </Match>
+
+    <!-- The JDK's renderer takes its three icons from getDefaultOpenIcon,
+         getDefaultClosedIcon and getDefaultLeafIcon while it is being
+         built, and an application overrides those to give a tree its own
+         icons; calling them from the constructor is the contract. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer"/>
+        <Method name="&lt;init&gt;"/>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- The form a dialog floats in exists to hold the window it shows. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.DialogForm"/>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- AWT's Window constructor sets its layout through the overridable
+         setLayout, and JWindow builds its root pane through the overridable
+         windowInit, as JFrame and JDialog do; applications override them
+         counting on that. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.java.awt.Window"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.JWindow"/>
+        </Or>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- END windows-menus slice -->
+
+    <!-- BEGIN swingx slice -->
+
+    <!-- SwingX hands out and takes the objects a component is built from,
+         as Swing does: a table's column control and column factory, a
+         list's sorter, a titled panel's content, a renderer's provider and
+         the component a cell context describes are the application's to
+         configure. A copy would not be the object the component uses. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXBusyLabel"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXCollapsiblePane"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXDatePicker"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXFrame"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXList"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.error.ErrorEvent"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXMonthView"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXSearchField"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXTable"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXTitledPanel"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.painter.ImagePainter"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.AbstractRenderer"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.CellContext"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.ComponentProvider"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.ListCellContext"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.TableCellContext"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.TreeCellContext"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.sort.ListSortController"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.sort.TableSortController"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.table.ColumnControlButton"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- The shared column factory is a replaceable singleton in SwingX:
+         getInstance/setInstance are its API, and it is made on first use.
+         It is only reached from the event dispatch thread. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.table.ColumnFactory"/>
+        <Or>
+            <Bug pattern="EI_EXPOSE_STATIC_REP2"/>
+            <Bug pattern="MS_EXPOSE_REP"/>
+            <Bug pattern="LI_LAZY_INIT_STATIC"/>
+        </Or>
+    </Match>
+
+    <!-- createTableColumn is overridable and SwingX documents that an
+         override may answer null to leave a model column out, so the null
+         checks are live although this class's own version never does. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.table.ColumnFactory"/>
+                <Method name="createAndConfigureTableColumn"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXTable"/>
+                <Method name="createDefaultColumnsFromModel"/>
+            </And>
+        </Or>
+        <Bug pattern="RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE"/>
+    </Match>
+
+    <!-- SwingX builds a provider's component and a renderer's provider in
+         the constructor through overridable factory methods
+         (createRendererComponent, createDefaultComponentProvider), and the
+         collapsible pane sets its content pane the same way; subclasses
+         override them counting on that. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.JXCollapsiblePane"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.AbstractRenderer"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.ComponentProvider"/>
+        </Or>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- noFocusBorder is "protected static Border", not final, in SwingX,
+         and dropOn and the three icons are protected fields a subclass
+         assigns; nothing in the layer writes them. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.CellContext"/>
+            <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.TreeCellContext"/>
+        </Or>
+        <Or>
+            <Bug pattern="MS_SHOULD_BE_FINAL"/>
+            <Bug pattern="UWF_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD"/>
+        </Or>
+    </Match>
+
+    <!-- The default tree icons are read from one renderer made on first
+         use; cell contexts are only used on the event dispatch thread. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.renderer.TreeCellContext"/>
+        <Bug pattern="LI_LAZY_INIT_STATIC"/>
+    </Match>
+
+    <!-- Serializable only because java.util.EventObject is; nothing in
+         Codename One serializes an event. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent"/>
+        <Bug pattern="SE_NO_SERIALVERSIONID"/>
+    </Match>
+
+    <!-- Picker's constructor calls updateValue() before this class has
+         its host. The override expects that: it tests the field for null
+         and falls back to the superclass's text. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.DatePickerPeer"/>
+        <Method name="updateValue"/>
+        <Bug pattern="UR_UNINIT_READ_CALLED_FROM_SUPER_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- TreeModelSupport is final in SwingX and still has a protected
+         listener list, and it keeps the model whose events it fires. A
+         tree table node hands out and takes its parent and user object, as
+         Swing's tree nodes do, and its constructor makes the child list
+         through the protected createChildrenList, which SwingX documents
+         as the hook for another list type. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.tree.TreeModelSupport"/>
+        <Or>
+            <Bug pattern="CI_CONFUSED_INHERITANCE"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.jdesktop.swingx.treetable.AbstractMutableTreeTableNode"/>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+            <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+        </Or>
+    </Match>
+
+    <!-- END swingx slice -->
+
+    <!-- BEGIN hardening slice -->
+
+    <!-- UIManager.getDefaults() and getLookAndFeelDefaults() answer THE
+         table: an application writes its defaults into what they return,
+         so a copy would lose every put. The table is static because the
+         JDK's methods are. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.UIManager"/>
+        <Or>
+            <Method name="getDefaults"/>
+            <Method name="getLookAndFeelDefaults"/>
+            <Method name="getLookAndFeel"/>
+        </Or>
+        <Bug pattern="MS_EXPOSE_REP"/>
+    </Match>
+
+    <!-- The JDK's BasicComboBoxEditor makes its text field through the
+         protected createEditorComponent() from its constructor, and a
+         subclass overrides exactly that to supply its own field. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.plaf.basic.BasicComboBoxEditor"/>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- The combo box peer calls its owner back when the popup opens and
+         closes; holding the watcher is the point of setting it. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.ComboPeer"/>
+        <Method name="setPopupWatcher"/>
+        <Bug pattern="EI_EXPOSE_REP2"/>
+    </Match>
+
+    <!-- Toolkit.getSystemClipboard() answers the one system clipboard;
+         a copy would be a clipboard nothing else reads. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.DesktopToolkit"/>
+        <Method name="getSystemClipboard"/>
+        <Bug pattern="EI_EXPOSE_REP"/>
+    </Match>
+
+    <!-- Swing has one tool tip manager and one current Metal theme for the
+         whole application, handed out and replaced through static methods
+         by contract; both are touched on the event dispatch thread only. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.javax.swing.ToolTipManager"/>
+            <Class name="com.codename1.desktopcompat.javax.swing.plaf.metal.MetalLookAndFeel"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_STATIC_REP2"/>
+            <Bug pattern="MS_EXPOSE_REP"/>
+        </Or>
+    </Match>
+
+    <!-- FileView.isTraversable answers a Boolean so that null can mean
+         "ask the file system view"; that is the JDK's signature and its
+         documented contract, and the chooser tests for null. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.filechooser.FileView"/>
+        <Method name="isTraversable"/>
+        <Bug pattern="NP_BOOLEAN_RETURN_NULL"/>
+    </Match>
+
+    <!-- END hardening slice -->
+
+    <!-- BEGIN drag and drop, styled text and created fonts -->
+
+    <!-- The desktop, the toolkit, the default style context and the three
+         clipboard actions of TransferHandler are each one object for the
+         whole application, handed out by a static method: that is the
+         JDK's contract, and every one is touched on the event dispatch
+         thread only. The style context is made on first use there. -->
+    <Match>
+        <Or>
+            <And>
+                <Class name="com.codename1.desktopcompat.java.awt.Desktop"/>
+                <Method name="getDesktop"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.java.awt.Toolkit"/>
+                <Method name="getDefaultToolkit"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.text.StyleContext"/>
+                <Method name="getDefaultStyleContext"/>
+            </And>
+            <And>
+                <Class name="com.codename1.desktopcompat.javax.swing.TransferHandler"/>
+                <Or>
+                    <Method name="getCutAction"/>
+                    <Method name="getCopyAction"/>
+                    <Method name="getPasteAction"/>
+                </Or>
+            </And>
+        </Or>
+        <Or>
+            <Bug pattern="MS_EXPOSE_REP"/>
+            <Bug pattern="LI_LAZY_INIT_STATIC"/>
+        </Or>
+    </Match>
+
+    <!-- The drop target events and the desktop's application events are
+         Serializable only because java.util.EventObject is. A device has
+         no object streams, so there is no serialized form to version and
+         no field that could fail to be written. -->
+    <Match>
+        <Class name="~com\.codename1\.desktopcompat\.java\.awt\.(dnd|desktop)\..*Event"/>
+        <Or>
+            <Bug pattern="SE_NO_SERIALVERSIONID"/>
+            <Bug pattern="SE_BAD_FIELD"/>
+        </Or>
+    </Match>
+
+    <!-- A text pane's document has to be a styled one, so JTextPane
+         overrides setDocument, which the constructor of JEditorPane
+         calls (as the JDK does) before this class has its fields. The
+         override reads its listener field to tell that call apart, and
+         a null there is the answer it is looking for. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.JTextPane"/>
+        <Method name="setDocument"/>
+        <Bug pattern="UR_UNINIT_READ_CALLED_FROM_SUPER_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- A face hands out the platform's font of its file, which is an
+         immutable handle: deriving a size from it makes another. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.rt.FontFiles$Face"/>
+        <Method name="base"/>
+        <Bug pattern="EI_EXPOSE_REP"/>
+    </Match>
+
+    <!-- Making a drop target for a component attaches it: the JDK's
+         constructor calls the component's setDropTarget, a public method
+         of Component, and so does this one. The target's own fields are
+         all set before the call. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.java.awt.dnd.DropTarget"/>
+        <Method name="&lt;init&gt;"/>
+        <Bug pattern="MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR"/>
+    </Match>
+
+    <!-- END drag and drop, styled text and created fonts -->
+
+    <!-- BEGIN look-and-feel slice: UIManager's palettes, FlatLaf and
+         RSyntaxTextArea under their own names -->
+
+    <!-- Whether a look and feel is dark has three answers: dark, light,
+         and a name the layer does not know, which keeps the palette. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.javax.swing.UIManager"/>
+        <Method name="dark"/>
+        <Bug pattern="NP_BOOLEAN_RETURN_NULL"/>
+    </Match>
+
+    <!-- FlatLaf's API: the extra defaults are a map the application
+         hands over and reads back, per look and feel and for all of them,
+         and it is that map by FlatLaf's contract. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf"/>
+        <Or>
+            <Method name="getExtraDefaults"/>
+            <Method name="setExtraDefaults"/>
+            <Method name="getGlobalExtraDefaults"/>
+            <Method name="setGlobalExtraDefaults"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+            <Bug pattern="MS_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_STATIC_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- "public static int duration" and "resolution" are FlatLaf's own
+         fields, not final, which applications assign. Nothing reads them
+         here because a switch of palette is not animated. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.com.formdev.flatlaf.extras.FlatAnimatedLafChange"/>
+        <Or>
+            <Field name="duration"/>
+            <Field name="resolution"/>
+        </Or>
+        <Or>
+            <Bug pattern="MS_SHOULD_BE_FINAL"/>
+            <Bug pattern="URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD"/>
+        </Or>
+    </Match>
+
+    <!-- A Theme's fields are public in RSyntaxTextArea and applications
+         assign them; the line number font is kept for them to read back,
+         the gutter draws in the editor's font. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea.Theme"/>
+        <Bug pattern="URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD"/>
+    </Match>
+
+    <!-- A gutter belongs to the editor it numbers, a scroll pane hands
+         out its gutter, an editor its marked ranges and a search result
+         the range it was given: each is that object by the library's
+         contract, as with the components of the JDK packages above. -->
+    <Match>
+        <Or>
+            <Class name="com.codename1.desktopcompat.org.fife.ui.rtextarea.Gutter"/>
+            <Class name="com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextScrollPane"/>
+            <Class name="com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextArea"/>
+            <Class name="com.codename1.desktopcompat.org.fife.ui.rtextarea.SearchResult"/>
+        </Or>
+        <Or>
+            <Bug pattern="EI_EXPOSE_REP"/>
+            <Bug pattern="EI_EXPOSE_REP2"/>
+        </Or>
+    </Match>
+
+    <!-- SearchContext.clone() is public API of the library, where the
+         class is Cloneable. Here it copies field by field: Object.clone()
+         answers null on a device, so the class must not rely on it and
+         does not declare the interface the device has no use for. -->
+    <Match>
+        <Class name="com.codename1.desktopcompat.org.fife.ui.rtextarea.SearchContext"/>
+        <Method name="clone"/>
+        <Bug pattern="CN_IMPLEMENTS_CLONE_BUT_NOT_CLONEABLE"/>
+    </Match>
+
+    <!-- END look-and-feel slice -->
+</FindBugsFilter>
diff --git a/maven/swing-compat/src/main/java/.gitkeep b/maven/swing-compat/src/main/java/.gitkeep
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/SwingInterop.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/SwingInterop.java
new file mode 100644
index 00000000000..e22a66b2b22
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/SwingInterop.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.rt.EmbedHost;
+import com.codename1.desktopcompat.rt.WindowHosts;
+
+/// Swing inside a Codename One application: the one call that turns a
+/// Swing component tree into a Codename One component.
+///
+/// ```java
+/// // in src/main/desktop/java
+/// public class ReportPanel {
+///     public static com.codename1.ui.Component create() {
+///         JPanel panel = new JPanel(new BorderLayout());
+///         panel.add(new JScrollPane(new JTable(rows, columns)));
+///         return SwingInterop.asComponent(panel);
+///     }
+/// }
+///
+/// // anywhere in the Codename One application
+/// form.add(BorderLayout.CENTER, ReportPanel.create());
+/// ```
+///
+/// Windows need nothing from this class. `JFrame.setVisible(true)` shows
+/// the frame as a form over the current one, with a back command;
+/// closing it returns to the form it was shown over, and a `JDialog` or
+/// `JOptionPane` floats over whatever form is showing and blocks its caller
+/// as on a desktop. In an application with a main class of its own,
+/// `EXIT_ON_CLOSE` closes the Swing windows and leaves the application
+/// running.
+public final class SwingInterop {
+
+    private SwingInterop() {
+    }
+
+    /// Answers a Codename One component that shows `awtComponent` -- a
+    /// `java.awt.Component` that is not a window -- laid out to the size
+    /// the answered component is given, painted with it, and receiving the
+    /// pointer input that falls on it. Its preferred size is the Swing
+    /// component's, scaled to the display.
+    ///
+    /// The parameter is declared as `Object` because the build relocates
+    /// the Swing classes: the caller's `java.awt.Component` is this layer's
+    /// class by the time the code runs, and no single declared type is
+    /// right both when the caller compiles and when it runs.
+    ///
+    /// The Swing component leaves the container it was in. Call this on the
+    /// event dispatch thread, as for all Swing and Codename One UI work.
+    ///
+    /// #### Parameters
+    ///
+    /// - `awtComponent`: the `java.awt.Component` to show
+    ///
+    /// #### Returns
+    ///
+    /// the Codename One component that shows it
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: `awtComponent` is not a Swing or AWT
+    ///   component, or is a window. Show a window with `setVisible(true)`,
+    ///   or embed its content pane.
+    public static com.codename1.ui.Component asComponent(Object awtComponent) {
+        // Library mode has no lifecycle to install the application's
+        // resources, bundles and services first; the first desktop
+        // component it wraps or window it shows does. Idempotent.
+        com.codename1.generated.compat.CompatRegistry.cn1Install();
+        if (awtComponent instanceof Window) {
+            throw new IllegalArgumentException("A window cannot be embedded; show it with setVisible(true), or "
+                    + "embed its content pane");
+        }
+        if (!(awtComponent instanceof Component)) {
+            throw new IllegalArgumentException("Not a java.awt.Component: "
+                    + (awtComponent == null ? "null" : awtComponent.getClass().getName()));
+        }
+        return new EmbedHost((Component) awtComponent);
+    }
+
+    /// Says whether the windows after the first open as windows of the
+    /// platform's window manager where it has one, which is the default.
+    /// With `false` every window stays inside the application's own
+    /// window: a frame is a form, and a dialog or a `JOptionPane` floats
+    /// over the current form, as on a phone.
+    ///
+    /// #### Parameters
+    ///
+    /// - `nativeWindows`: `false` to keep every window inside the
+    ///   application's window
+    public static void setNativeWindows(boolean nativeWindows) {
+        WindowHosts.setNativeWindows(nativeWindows);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatClientProperties.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatClientProperties.java
new file mode 100644
index 00000000000..f2542657e5c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatClientProperties.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+
+/// The names and values of FlatLaf's client properties, so that
+/// `component.putClientProperty(FlatClientProperties.PLACEHOLDER_TEXT, ...)`
+/// compiles and means what it says.
+///
+/// What this layer does with each property is in the description of
+/// [ClientProps][com.codename1.desktopcompat.rt.ClientProps]: the ones a
+/// Codename One widget can honour change the widget, the others are
+/// kept on the component and change nothing.
+public interface FlatClientProperties {
+
+    String BUTTON_TYPE = "JButton.buttonType";
+    String BUTTON_TYPE_SQUARE = "square";
+    String BUTTON_TYPE_ROUND_RECT = "roundRect";
+    String BUTTON_TYPE_TAB = "tab";
+    String BUTTON_TYPE_HELP = "help";
+    String BUTTON_TYPE_TOOLBAR_BUTTON = "toolBarButton";
+    String BUTTON_TYPE_BORDERLESS = "borderless";
+    String SQUARE_SIZE = "JButton.squareSize";
+    String SELECTED_STATE = "JButton.selectedState";
+    String SELECTED_STATE_INDETERMINATE = "indeterminate";
+    String STYLE = "FlatLaf.style";
+    String STYLE_CLASS = "FlatLaf.styleClass";
+    String MINIMUM_WIDTH = "JComponent.minimumWidth";
+    String MINIMUM_HEIGHT = "JComponent.minimumHeight";
+    String COMPONENT_ROUND_RECT = "JComponent.roundRect";
+    String OUTLINE = "JComponent.outline";
+    String OUTLINE_ERROR = "error";
+    String OUTLINE_WARNING = "warning";
+    String OUTLINE_SUCCESS = "success";
+    String COMPONENT_FOCUS_OWNER = "JComponent.focusOwner";
+    String COMPONENT_TITLE_BAR_CAPTION = "JComponent.titleBarCaption";
+    String FULL_WINDOW_CONTENT_BUTTONS_PLACEHOLDER = "FlatLaf.fullWindowContent.buttonsPlaceholder";
+    String POPUP_BORDER_CORNER_RADIUS = "Popup.borderCornerRadius";
+    String POPUP_ROUNDED_BORDER_WIDTH = "Popup.roundedBorderWidth";
+    String POPUP_DROP_SHADOW_PAINTED = "Popup.dropShadowPainted";
+    String POPUP_FORCE_HEAVY_WEIGHT = "Popup.forceHeavyWeight";
+    String PROGRESS_BAR_LARGE_HEIGHT = "JProgressBar.largeHeight";
+    String PROGRESS_BAR_SQUARE = "JProgressBar.square";
+    String USE_WINDOW_DECORATIONS = "JRootPane.useWindowDecorations";
+    String MENU_BAR_EMBEDDED = "JRootPane.menuBarEmbedded";
+    String FULL_WINDOW_CONTENT = "FlatLaf.fullWindowContent";
+    String FULL_WINDOW_CONTENT_BUTTONS_BOUNDS = "FlatLaf.fullWindowContent.buttonsBounds";
+    String TITLE_BAR_SHOW_ICON = "JRootPane.titleBarShowIcon";
+    String TITLE_BAR_SHOW_TITLE = "JRootPane.titleBarShowTitle";
+    String TITLE_BAR_SHOW_ICONIFFY = "JRootPane.titleBarShowIconify";
+    String TITLE_BAR_SHOW_MAXIMIZE = "JRootPane.titleBarShowMaximize";
+    String TITLE_BAR_SHOW_CLOSE = "JRootPane.titleBarShowClose";
+    String TITLE_BAR_BACKGROUND = "JRootPane.titleBarBackground";
+    String TITLE_BAR_FOREGROUND = "JRootPane.titleBarForeground";
+    String TITLE_BAR_HEIGHT = "JRootPane.titleBarHeight";
+    String GLASS_PANE_FULL_HEIGHT = "JRootPane.glassPaneFullHeight";
+    String WINDOW_STYLE = "Window.style";
+    String WINDOW_STYLE_SMALL = "small";
+    String SCROLL_BAR_SHOW_BUTTONS = "JScrollBar.showButtons";
+    String SCROLL_PANE_SMOOTH_SCROLLING = "JScrollPane.smoothScrolling";
+    String SPLIT_PANE_EXPANDABLE_SIDE = "JSplitPane.expandableSide";
+    String SPLIT_PANE_EXPANDABLE_SIDE_LEFT = "left";
+    String SPLIT_PANE_EXPANDABLE_SIDE_RIGHT = "right";
+    String TABBED_PANE_TAB_TYPE = "JTabbedPane.tabType";
+    String TABBED_PANE_TAB_TYPE_UNDERLINED = "underlined";
+    String TABBED_PANE_TAB_TYPE_CARD = "card";
+    String TABBED_PANE_SHOW_TAB_SEPARATORS = "JTabbedPane.showTabSeparators";
+    String TABBED_PANE_SHOW_CONTENT_SEPARATOR = "JTabbedPane.showContentSeparator";
+    String TABBED_PANE_HAS_FULL_BORDER = "JTabbedPane.hasFullBorder";
+    String TABBED_PANE_HIDE_TAB_AREA_WITH_ONE_TAB = "JTabbedPane.hideTabAreaWithOneTab";
+    String TABBED_PANE_MINIMUM_TAB_WIDTH = "JTabbedPane.minimumTabWidth";
+    String TABBED_PANE_MAXIMUM_TAB_WIDTH = "JTabbedPane.maximumTabWidth";
+    String TABBED_PANE_TAB_HEIGHT = "JTabbedPane.tabHeight";
+    String TABBED_PANE_TAB_INSETS = "JTabbedPane.tabInsets";
+    String TABBED_PANE_TAB_AREA_INSETS = "JTabbedPane.tabAreaInsets";
+    String TABBED_PANE_TAB_CLOSABLE = "JTabbedPane.tabClosable";
+    String TABBED_PANE_TAB_CLOSE_TOOLTIPTEXT = "JTabbedPane.tabCloseToolTipText";
+    String TABBED_PANE_TAB_CLOSE_CALLBACK = "JTabbedPane.tabCloseCallback";
+    String TABBED_PANE_TABS_POPUP_POLICY = "JTabbedPane.tabsPopupPolicy";
+    String TABBED_PANE_SCROLL_BUTTONS_POLICY = "JTabbedPane.scrollButtonsPolicy";
+    String TABBED_PANE_POLICY_NEVER = "never";
+    String TABBED_PANE_POLICY_AS_NEEDED = "asNeeded";
+    String TABBED_PANE_POLICY_AS_NEEDED_SINGLE = "asNeededSingle";
+    String TABBED_PANE_SCROLL_BUTTONS_PLACEMENT = "JTabbedPane.scrollButtonsPlacement";
+    String TABBED_PANE_PLACEMENT_BOTH = "both";
+    String TABBED_PANE_PLACEMENT_TRAILING = "trailing";
+    String TABBED_PANE_TAB_AREA_ALIGNMENT = "JTabbedPane.tabAreaAlignment";
+    String TABBED_PANE_TAB_ALIGNMENT = "JTabbedPane.tabAlignment";
+    String TABBED_PANE_ALIGN_LEADING = "leading";
+    String TABBED_PANE_ALIGN_TRAILING = "trailing";
+    String TABBED_PANE_ALIGN_CENTER = "center";
+    String TABBED_PANE_ALIGN_FILL = "fill";
+    String TABBED_PANE_TAB_WIDTH_MODE = "JTabbedPane.tabWidthMode";
+    String TABBED_PANE_TAB_WIDTH_MODE_PREFERRED = "preferred";
+    String TABBED_PANE_TAB_WIDTH_MODE_EQUAL = "equal";
+    String TABBED_PANE_TAB_WIDTH_MODE_COMPACT = "compact";
+    String TABBED_PANE_TAB_WIDTH_MODE_ICON_ONLY = "iconOnly";
+    String TABBED_PANE_TAB_ICON_PLACEMENT = "JTabbedPane.tabIconPlacement";
+    String TABBED_PANE_TAB_ROTATION = "JTabbedPane.tabRotation";
+    String TABBED_PANE_TAB_ROTATION_NONE = "none";
+    String TABBED_PANE_TAB_ROTATION_AUTO = "auto";
+    String TABBED_PANE_TAB_ROTATION_LEFT = "left";
+    String TABBED_PANE_TAB_ROTATION_RIGHT = "right";
+    String TABBED_PANE_LEADING_COMPONENT = "JTabbedPane.leadingComponent";
+    String TABBED_PANE_TRAILING_COMPONENT = "JTabbedPane.trailingComponent";
+    String SELECT_ALL_ON_FOCUS_POLICY = "JTextField.selectAllOnFocusPolicy";
+    String SELECT_ALL_ON_FOCUS_POLICY_NEVER = "never";
+    String SELECT_ALL_ON_FOCUS_POLICY_ONCE = "once";
+    String SELECT_ALL_ON_FOCUS_POLICY_ALWAYS = "always";
+    String SELECT_ALL_ON_MOUSE_CLICK = "JTextField.selectAllOnMouseClick";
+    String PLACEHOLDER_TEXT = "JTextField.placeholderText";
+    String TEXT_FIELD_PADDING = "JTextField.padding";
+    String TEXT_FIELD_LEADING_ICON = "JTextField.leadingIcon";
+    String TEXT_FIELD_TRAILING_ICON = "JTextField.trailingIcon";
+    String TEXT_FIELD_LEADING_COMPONENT = "JTextField.leadingComponent";
+    String TEXT_FIELD_TRAILING_COMPONENT = "JTextField.trailingComponent";
+    String TEXT_FIELD_SHOW_CLEAR_BUTTON = "JTextField.showClearButton";
+    String TEXT_FIELD_CLEAR_CALLBACK = "JTextField.clearCallback";
+    String TAB_BUTTON_UNDERLINE_PLACEMENT = "JToggleButton.tab.underlinePlacement";
+    String TAB_BUTTON_UNDERLINE_HEIGHT = "JToggleButton.tab.underlineHeight";
+    String TAB_BUTTON_UNDERLINE_COLOR = "JToggleButton.tab.underlineColor";
+    String TAB_BUTTON_SELECTED_BACKGROUND = "JToggleButton.tab.selectedBackground";
+    String TREE_WIDE_SELECTION = "JTree.wideSelection";
+    String TREE_WIDE_CELL_RENDERER = "JTree.wideCellRenderer";
+    String TREE_PAINT_SELECTION = "JTree.paintSelection";
+    String MACOS_WINDOW_BUTTONS_SPACING = "FlatLaf.macOS.windowButtonsSpacing";
+    String MACOS_WINDOW_BUTTONS_SPACING_MEDIUM = "medium";
+    String MACOS_WINDOW_BUTTONS_SPACING_LARGE = "large";
+
+    /// The client property `key` of `c` when it is a `type`, else `def`.
+    @SuppressWarnings("unchecked")
+    static <T> T clientProperty(JComponent c, String key, T def, Class<T> type) {
+        Object value = c.getClientProperty(key);
+        return type.isInstance(value) ? (T) value : def;
+    }
+
+    static boolean clientPropertyEquals(JComponent c, String key, Object value) {
+        Object v = c.getClientProperty(key);
+        return v == null ? value == null : v.equals(value);
+    }
+
+    static boolean clientPropertyBoolean(JComponent c, String key, boolean defaultValue) {
+        Object value = c.getClientProperty(key);
+        return value instanceof Boolean ? ((Boolean) value).booleanValue() : defaultValue;
+    }
+
+    static Boolean clientPropertyBooleanStrict(JComponent c, String key, Boolean defaultValue) {
+        Object value = c.getClientProperty(key);
+        return value instanceof Boolean ? (Boolean) value : defaultValue;
+    }
+
+    static int clientPropertyInt(JComponent c, String key, int defaultValue) {
+        Object value = c.getClientProperty(key);
+        return value instanceof Integer ? ((Integer) value).intValue() : defaultValue;
+    }
+
+    static Color clientPropertyColor(JComponent c, String key, Color defaultValue) {
+        Object value = c.getClientProperty(key);
+        return value instanceof Color ? (Color) value : defaultValue;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatDarculaLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatDarculaLaf.java
new file mode 100644
index 00000000000..60c0022b83b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatDarculaLaf.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+/// FlatLaf's "FlatLaf Darcula" look: on this layer, the dark palette. See
+/// [FlatLaf][com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf].
+public class FlatDarculaLaf extends FlatDarkLaf {
+
+    public static final String NAME = "FlatLaf Darcula";
+
+    public FlatDarculaLaf() {
+    }
+
+    /// Sets this look and feel and answers whether that worked.
+    public static boolean setup() {
+        return setup(new FlatDarculaLaf());
+    }
+
+    /// The same as [#setup], under its older name.
+    public static boolean install() {
+        return setup();
+    }
+
+    /// Adds this look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo() {
+        installLafInfo(NAME, FlatDarculaLaf.class);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getDescription() {
+        return "FlatLaf Darcula Look and Feel";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatDarkLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatDarkLaf.java
new file mode 100644
index 00000000000..59b3078211c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatDarkLaf.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+/// FlatLaf's "FlatLaf Dark" look: on this layer, the dark palette. See
+/// [FlatLaf][com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf].
+public class FlatDarkLaf extends FlatLaf {
+
+    public static final String NAME = "FlatLaf Dark";
+
+    public FlatDarkLaf() {
+    }
+
+    /// Sets this look and feel and answers whether that worked.
+    public static boolean setup() {
+        return setup(new FlatDarkLaf());
+    }
+
+    /// The same as [#setup], under its older name.
+    public static boolean install() {
+        return setup();
+    }
+
+    /// Adds this look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo() {
+        installLafInfo(NAME, FlatDarkLaf.class);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getDescription() {
+        return "FlatLaf Dark Look and Feel";
+    }
+
+    @Override
+    public boolean isDark() {
+        return true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatIntelliJLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatIntelliJLaf.java
new file mode 100644
index 00000000000..9e6e3fc5013
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatIntelliJLaf.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+/// FlatLaf's "FlatLaf IntelliJ" look: on this layer, the light palette. See
+/// [FlatLaf][com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf].
+public class FlatIntelliJLaf extends FlatLightLaf {
+
+    public static final String NAME = "FlatLaf IntelliJ";
+
+    public FlatIntelliJLaf() {
+    }
+
+    /// Sets this look and feel and answers whether that worked.
+    public static boolean setup() {
+        return setup(new FlatIntelliJLaf());
+    }
+
+    /// The same as [#setup], under its older name.
+    public static boolean install() {
+        return setup();
+    }
+
+    /// Adds this look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo() {
+        installLafInfo(NAME, FlatIntelliJLaf.class);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getDescription() {
+        return "FlatLaf IntelliJ Look and Feel";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLaf.java
new file mode 100644
index 00000000000..427cd6c37d0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLaf.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.LookAndFeel;
+import com.codename1.desktopcompat.javax.swing.UIDefaults;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.UnsupportedLookAndFeelException;
+import com.codename1.desktopcompat.rt.LafTheme;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/// The FlatLaf look and feel under its own name, as this layer has it: a
+/// choice of palette.
+///
+/// The widgets are Codename One components drawn with the Codename One
+/// theme, so nothing of FlatLaf's own drawing is here. Setting one of
+/// its subclasses selects the light or the dark palette, as [#isDark]
+/// says, and restyles every open window; the colors, fonts and metrics
+/// applications read back from `UIManager` under FlatLaf's keys answer
+/// from that palette. See
+/// [UIManager][com.codename1.desktopcompat.javax.swing.UIManager].
+///
+/// What differs from the desktop:
+///
+///  - Extra defaults ([#setGlobalExtraDefaults], [#setExtraDefaults])
+///    are read for plain values: a color as `#rgb`, `#rrggbb` or
+///    `#rrggbbaa`, a whole number, `true` or `false`, insets as four
+///    numbers. `@accentColor` sets the accent of the palette. A value in
+///    FlatLaf's expression language (`lighten(...)`, `$Other.key`) is
+///    skipped.
+///  - A custom defaults source that is registered is recorded and not
+///    read: there are no properties files of a look and feel on a device.
+///  - There are no window decorations of the look and feel, no mnemonics
+///    to show and no font families to prefer; those calls are recorded.
+public abstract class FlatLaf extends LookAndFeel {
+
+    private static Map<String, String> globalExtraDefaults;
+    private static boolean useNativeWindowDecorations;
+    private static String preferredFontFamily;
+    private static String preferredLightFontFamily;
+    private static String preferredSemiboldFontFamily;
+    private static String preferredMonospacedFontFamily;
+    private static boolean sourceLogged;
+
+    private Map<String, String> extraDefaults;
+
+    public FlatLaf() {
+    }
+
+    /// Sets the look and feel and answers whether that worked.
+    public static boolean setup(LookAndFeel newLookAndFeel) {
+        try {
+            UIManager.setLookAndFeel(newLookAndFeel);
+            return true;
+        } catch (UnsupportedLookAndFeelException e) {
+            com.codename1.io.Log.p("desktopcompat.laf: " + e.getMessage());
+            return false;
+        }
+    }
+
+    /// The same as [#setup], under its older name.
+    public static boolean install(LookAndFeel newLookAndFeel) {
+        return setup(newLookAndFeel);
+    }
+
+    /// Adds the look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo(String lafName, Class<? extends LookAndFeel> lafClass) {
+        UIManager.installLookAndFeel(new UIManager.LookAndFeelInfo(lafName, lafClass.getName()));
+    }
+
+    @Override
+    public String getID() {
+        return "FlatLaf - " + getName();
+    }
+
+    /// Whether this look and feel selects the dark palette.
+    public abstract boolean isDark();
+
+    /// Whether the look and feel that is set now is a dark FlatLaf.
+    public static boolean isLafDark() {
+        LookAndFeel laf = UIManager.getLookAndFeel();
+        return laf instanceof FlatLaf && ((FlatLaf) laf).isDark();
+    }
+
+    @Override
+    public boolean getSupportsWindowDecorations() {
+        return false;
+    }
+
+    @Override
+    public boolean isNativeLookAndFeel() {
+        return false;
+    }
+
+    @Override
+    public boolean isSupportedLookAndFeel() {
+        return true;
+    }
+
+    @Override
+    public void initialize() {
+    }
+
+    @Override
+    public void uninitialize() {
+    }
+
+    /// The extra defaults, the global ones and then this look's own, as
+    /// far as their values are plain; everything else of the palette is
+    /// answered by `UIManager` from the theme.
+    @Override
+    public UIDefaults getDefaults() {
+        UIDefaults d = new UIDefaults();
+        LafTheme.setAccent(null);
+        read(globalExtraDefaults, d);
+        read(extraDefaults, d);
+        return d;
+    }
+
+    private static void read(Map<String, String> from, UIDefaults into) {
+        if (from == null) {
+            return;
+        }
+        Iterator<Map.Entry<String, String>> it = from.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<String, String> e = it.next();
+            String key = e.getKey();
+            Object v = plain(e.getValue());
+            if (key == null || v == null) {
+                continue;
+            }
+            if ("@accentColor".equals(key)) {
+                if (v instanceof Color) {
+                    LafTheme.setAccent((Color) v);
+                }
+            } else if (!key.startsWith("@")) {
+                into.put(key, v);
+            }
+        }
+    }
+
+    private static int hexDigit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        } else if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        } else if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    private static Color color(String s) {
+        int n = s.length() - 1;
+        if (n != 3 && n != 4 && n != 6 && n != 8) {
+            return null;
+        }
+        int[] d = new int[8];
+        boolean brief = n <= 4;
+        int count = 0;
+        for (int i = 1; i < s.length(); i++) {
+            int h = hexDigit(s.charAt(i));
+            if (h < 0) {
+                return null;
+            }
+            d[count++] = h;
+            if (brief) {
+                d[count++] = h;
+            }
+        }
+        int r = d[0] * 16 + d[1];
+        int g = d[2] * 16 + d[3];
+        int b = d[4] * 16 + d[5];
+        return count == 8 ? new Color(r, g, b, d[6] * 16 + d[7]) : new Color(r, g, b);
+    }
+
+    private static Integer whole(String s) {
+        if (s.length() == 0 || s.length() > 9) {
+            return null;
+        }
+        int v = 0;
+        int start = s.charAt(0) == '-' ? 1 : 0;
+        if (start == s.length()) {
+            return null;
+        }
+        for (int i = start; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c < '0' || c > '9') {
+                return null;
+            }
+            v = v * 10 + (c - '0');
+        }
+        return Integer.valueOf(start == 1 ? -v : v);
+    }
+
+    /// A value written plainly, or `null` for anything else.
+    private static Object plain(String text) {
+        if (text == null) {
+            return null;
+        }
+        String s = text.trim();
+        if (s.length() == 0) {
+            return null;
+        }
+        if (s.charAt(0) == '#') {
+            return color(s);
+        }
+        if ("true".equals(s)) {
+            return Boolean.TRUE;
+        } else if ("false".equals(s)) {
+            return Boolean.FALSE;
+        }
+        Integer n = whole(s);
+        if (n != null) {
+            return n;
+        }
+        if (s.indexOf(',') > 0) {
+            int[] parts = new int[4];
+            int count = 0;
+            int from = 0;
+            while (from <= s.length()) {
+                int comma = s.indexOf(',', from);
+                int to = comma < 0 ? s.length() : comma;
+                Integer part = whole(s.substring(from, to).trim());
+                if (part == null || count == 4) {
+                    return null;
+                }
+                parts[count++] = part.intValue();
+                from = to + 1;
+            }
+            return count == 4 ? new Insets(parts[0], parts[1], parts[2], parts[3]) : null;
+        }
+        return null;
+    }
+
+    /// The value a defaults file would give `value` when it is plain: a
+    /// color, a whole number, a boolean or insets; a string otherwise.
+    /// `valueType` narrows nothing here.
+    public static Object parseDefaultsValue(String key, String value, Class<?> valueType)
+            throws IllegalArgumentException {
+        Object v = plain(value);
+        return v != null ? v : value;
+    }
+
+    private static void sourceIgnored(String what) {
+        if (!sourceLogged) {
+            sourceLogged = true;
+            com.codename1.io.Log.p("desktopcompat.laf: custom defaults source " + what
+                    + " is recorded and not read; put the values with FlatLaf.setGlobalExtraDefaults or UIManager.put");
+        }
+    }
+
+    /// Recorded and not read; see the class description.
+    public static void registerCustomDefaultsSource(String packageName) {
+        sourceIgnored(packageName);
+    }
+
+    public static void unregisterCustomDefaultsSource(String packageName) {
+    }
+
+    /// The extra defaults of every FlatLaf look, or `null`.
+    public static Map<String, String> getGlobalExtraDefaults() {
+        return globalExtraDefaults;
+    }
+
+    /// Sets defaults that every FlatLaf look gets on top of its own. They
+    /// take effect when a look and feel is next set.
+    public static void setGlobalExtraDefaults(Map<String, String> globalExtraDefaults) {
+        FlatLaf.globalExtraDefaults = globalExtraDefaults == null ? null
+                : new HashMap<String, String>(globalExtraDefaults);
+    }
+
+    public Map<String, String> getExtraDefaults() {
+        return extraDefaults;
+    }
+
+    /// Sets defaults this look gets on top of its own, when it is next
+    /// set.
+    public void setExtraDefaults(Map<String, String> extraDefaults) {
+        this.extraDefaults = extraDefaults == null ? null : new HashMap<String, String>(extraDefaults);
+    }
+
+    /// `[light]` or `[dark]`, the prefix of a key for one palette only.
+    public static String getUIKeyLightOrDarkPrefix(boolean dark) {
+        return dark ? "[dark]" : "[light]";
+    }
+
+    /// Restyles every open window from the look and feel that is set.
+    public static void updateUI() {
+        LafTheme.restyleAll();
+    }
+
+    /// The same as [#updateUI], after the events that are waiting.
+    public static void updateUILater() {
+        com.codename1.ui.Display.getInstance().callSerially(new Runnable() {
+            @Override
+            public void run() {
+                LafTheme.restyleAll();
+            }
+        });
+    }
+
+    /// False: the windows of this layer are Codename One forms.
+    public static boolean supportsNativeWindowDecorations() {
+        return false;
+    }
+
+    public static boolean isUseNativeWindowDecorations() {
+        return useNativeWindowDecorations;
+    }
+
+    /// Recorded only.
+    public static void setUseNativeWindowDecorations(boolean enabled) {
+        useNativeWindowDecorations = enabled;
+    }
+
+    public static void revalidateAndRepaintAllFramesAndDialogs() {
+        LafTheme.restyleAll();
+    }
+
+    public static void repaintAllFramesAndDialogs() {
+        LafTheme.restyleAll();
+    }
+
+    /// False: there are no mnemonics to underline.
+    public static boolean isShowMnemonics() {
+        return false;
+    }
+
+    /// Does nothing.
+    public static void showMnemonics(Component c) {
+    }
+
+    /// Does nothing.
+    public static void hideMnemonics() {
+    }
+
+    @Override
+    public final boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    @Override
+    public final int hashCode() {
+        return super.hashCode();
+    }
+
+    public static String getPreferredFontFamily() {
+        return preferredFontFamily;
+    }
+
+    /// Recorded only: the font of the layer is the theme's.
+    public static void setPreferredFontFamily(String preferredFontFamily) {
+        FlatLaf.preferredFontFamily = preferredFontFamily;
+    }
+
+    public static String getPreferredLightFontFamily() {
+        return preferredLightFontFamily;
+    }
+
+    /// Recorded only.
+    public static void setPreferredLightFontFamily(String preferredLightFontFamily) {
+        FlatLaf.preferredLightFontFamily = preferredLightFontFamily;
+    }
+
+    public static String getPreferredSemiboldFontFamily() {
+        return preferredSemiboldFontFamily;
+    }
+
+    /// Recorded only.
+    public static void setPreferredSemiboldFontFamily(String preferredSemiboldFontFamily) {
+        FlatLaf.preferredSemiboldFontFamily = preferredSemiboldFontFamily;
+    }
+
+    public static String getPreferredMonospacedFontFamily() {
+        return preferredMonospacedFontFamily;
+    }
+
+    /// Recorded only.
+    public static void setPreferredMonospacedFontFamily(String preferredMonospacedFontFamily) {
+        FlatLaf.preferredMonospacedFontFamily = preferredMonospacedFontFamily;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLightLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLightLaf.java
new file mode 100644
index 00000000000..11d7f41c4e3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLightLaf.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+/// FlatLaf's "FlatLaf Light" look: on this layer, the light palette. See
+/// [FlatLaf][com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf].
+public class FlatLightLaf extends FlatLaf {
+
+    public static final String NAME = "FlatLaf Light";
+
+    public FlatLightLaf() {
+    }
+
+    /// Sets this look and feel and answers whether that worked.
+    public static boolean setup() {
+        return setup(new FlatLightLaf());
+    }
+
+    /// The same as [#setup], under its older name.
+    public static boolean install() {
+        return setup();
+    }
+
+    /// Adds this look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo() {
+        installLafInfo(NAME, FlatLightLaf.class);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getDescription() {
+        return "FlatLaf Light Look and Feel";
+    }
+
+    @Override
+    public boolean isDark() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatSystemProperties.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatSystemProperties.java
new file mode 100644
index 00000000000..bac3a7c5cb6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatSystemProperties.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+/// The names of the system properties FlatLaf reads on a desktop. They are
+/// names only: this layer reads none of them.
+public interface FlatSystemProperties {
+
+    String UI_SCALE = "flatlaf.uiScale";
+    String UI_SCALE_ENABLED = "flatlaf.uiScale.enabled";
+    String UI_SCALE_ALLOW_SCALE_DOWN = "flatlaf.uiScale.allowScaleDown";
+    String USE_UBUNTU_FONT = "flatlaf.useUbuntuFont";
+    String USE_WINDOW_DECORATIONS = "flatlaf.useWindowDecorations";
+    String USE_JETBRAINS_CUSTOM_DECORATIONS = "flatlaf.useJetBrainsCustomDecorations";
+    String MENUBAR_EMBEDDED = "flatlaf.menuBarEmbedded";
+    String ANIMATION = "flatlaf.animation";
+    String USE_ROUNDED_POPUP_BORDER = "flatlaf.useRoundedPopupBorder";
+    String REUSE_VISIBLE_POPUP_WINDOW = "flatlaf.reuseVisiblePopupWindow";
+    String USE_TEXT_Y_CORRECTION = "flatlaf.useTextYCorrection";
+    String UPDATE_UI_ON_SYSTEM_FONT_CHANGE = "flatlaf.updateUIOnSystemFontChange";
+    String USE_NATIVE_LIBRARY = "flatlaf.useNativeLibrary";
+    String NATIVE_LIBRARY_PATH = "flatlaf.nativeLibraryPath";
+    String USE_SUB_MENU_SAFE_TRIANGLE = "flatlaf.useSubMenuSafeTriangle";
+    String USE_SYSTEM_FILE_CHOOSER = "flatlaf.useSystemFileChooser";
+
+    /// `defaultValue`: the layer reads no system property of FlatLaf.
+    static boolean getBoolean(String key, boolean defaultValue) {
+        return defaultValue;
+    }
+
+    /// `defaultValue`; see [#getBoolean].
+    static Boolean getBooleanStrict(String key, Boolean defaultValue) {
+        return defaultValue;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/extras/FlatAnimatedLafChange.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/extras/FlatAnimatedLafChange.java
new file mode 100644
index 00000000000..ccf94041f81
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/extras/FlatAnimatedLafChange.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf.extras;
+
+import com.codename1.desktopcompat.rt.LafTheme;
+
+/// FlatLaf's animated change of look and feel, without the animation.
+///
+/// On the desktop a snapshot of every window is faded out over the new
+/// look. Here the change is immediate: [#showSnapshot] does nothing, and
+/// [#hideSnapshotWithAnimation] restyles the open windows from the look
+/// and feel that is set now, which is what the usual sequence -- show the
+/// snapshot, set the look and feel, update the UI, hide the snapshot --
+/// ends with anyway.
+public class FlatAnimatedLafChange {
+
+    /// Recorded only: there is no animation to time.
+    public static int duration = 160;
+    /// Recorded only.
+    public static int resolution = 30;
+
+    public FlatAnimatedLafChange() {
+    }
+
+    /// Does nothing; see the class description.
+    public static void showSnapshot() {
+    }
+
+    /// Restyles every open window; see the class description.
+    public static void hideSnapshotWithAnimation() {
+        LafTheme.restyleAll();
+    }
+
+    /// Does nothing: there is never an animation running.
+    public static void stop() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/extras/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/extras/package-info.java
new file mode 100644
index 00000000000..abcf3aa4d06
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/extras/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// FlatLaf extras: the snapshot animation of a look and feel change, which here is no animation.
+package com.codename1.desktopcompat.com.formdev.flatlaf.extras;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/package-info.java
new file mode 100644
index 00000000000..45b34a5ec6e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The FlatLaf look and feel under its own names: a choice of the light or the dark palette of this layer,
+/// and the names of its client properties.
+package com.codename1.desktopcompat.com.formdev.flatlaf;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/FlatMacDarkLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/FlatMacDarkLaf.java
new file mode 100644
index 00000000000..68d95b4c994
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/FlatMacDarkLaf.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf.themes;
+
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatDarkLaf;
+
+/// FlatLaf's "FlatLaf macOS Dark" look: on this layer, the dark palette. See
+/// [FlatLaf][com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf].
+public class FlatMacDarkLaf extends FlatDarkLaf {
+
+    public static final String NAME = "FlatLaf macOS Dark";
+
+    public FlatMacDarkLaf() {
+    }
+
+    /// Sets this look and feel and answers whether that worked.
+    public static boolean setup() {
+        return setup(new FlatMacDarkLaf());
+    }
+
+    /// Adds this look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo() {
+        installLafInfo(NAME, FlatMacDarkLaf.class);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getDescription() {
+        return "FlatLaf macOS Dark Look and Feel";
+    }
+
+    @Override
+    public boolean isDark() {
+        return true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/FlatMacLightLaf.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/FlatMacLightLaf.java
new file mode 100644
index 00000000000..152f14e8c11
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/FlatMacLightLaf.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf.themes;
+
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatLightLaf;
+
+/// FlatLaf's "FlatLaf macOS Light" look: on this layer, the light palette. See
+/// [FlatLaf][com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf].
+public class FlatMacLightLaf extends FlatLightLaf {
+
+    public static final String NAME = "FlatLaf macOS Light";
+
+    public FlatMacLightLaf() {
+    }
+
+    /// Sets this look and feel and answers whether that worked.
+    public static boolean setup() {
+        return setup(new FlatMacLightLaf());
+    }
+
+    /// Adds this look and feel to those `UIManager` lists as installed.
+    public static void installLafInfo() {
+        installLafInfo(NAME, FlatMacLightLaf.class);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getDescription() {
+        return "FlatLaf macOS Light Look and Feel";
+    }
+
+    @Override
+    public boolean isDark() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/package-info.java
new file mode 100644
index 00000000000..55f647f2248
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/themes/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The macOS flavours of FlatLaf, which select the same two palettes.
+package com.codename1.desktopcompat.com.formdev.flatlaf.themes;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/SystemInfo.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/SystemInfo.java
new file mode 100644
index 00000000000..1a5d0793e6e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/SystemInfo.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf.util;
+
+import com.codename1.ui.Display;
+
+/// What FlatLaf knows about the system it runs on, answered truthfully
+/// for where a Codename One application runs.
+///
+/// `isWindows`, `isMacOS` and `isLinux` are true only for a desktop build
+/// on that system; on a phone, a tablet or in a browser all three are
+/// false and `isUnknownOS` is true. The versions are zero, which makes
+/// every "this version or later" answer false. The Java answers are those
+/// of the language level applications are built at.
+public class SystemInfo {
+
+    public static final boolean isWindows = cn1Platform("win");
+    public static final boolean isMacOS = cn1Platform("mac");
+    public static final boolean isLinux = cn1Platform("linux");
+    public static final boolean isUnknownOS = !isWindows && !isMacOS && !isLinux;
+    public static final long osVersion = 0;
+    public static final boolean isWindows_10_orLater = false;
+    public static final boolean isWindows_11_orLater = false;
+    public static final boolean isMacOS_10_11_ElCapitan_orLater = false;
+    public static final boolean isMacOS_10_14_Mojave_orLater = false;
+    public static final boolean isMacOS_10_15_Catalina_orLater = false;
+    public static final boolean isX86 = false;
+    public static final boolean isX86_64 = false;
+    public static final boolean isAARCH64 = false;
+    public static final long javaVersion = toVersion(17, 0, 0, 0);
+    public static final boolean isJava_9_orLater = true;
+    public static final boolean isJava_11_orLater = true;
+    public static final boolean isJava_12_orLater = true;
+    public static final boolean isJava_15_orLater = true;
+    public static final boolean isJava_17_orLater = true;
+    public static final boolean isJava_18_orLater = false;
+    public static final boolean isJetBrainsJVM = false;
+    public static final boolean isJetBrainsJVM_11_orLater = false;
+    public static final boolean isGNOME = false;
+    public static final boolean isKDE = false;
+    public static final boolean isProjector = false;
+    public static final boolean isWebswing = false;
+    public static final boolean isWinPE = false;
+    public static final boolean isMacFullWindowContentSupported = false;
+
+    public SystemInfo() {
+    }
+
+    private static boolean cn1Platform(String name) {
+        if (!Display.isInitialized()) {
+            return false;
+        }
+        String platform = Display.getInstance().getPlatformName();
+        if (name.equals(platform)) {
+            return true;
+        }
+        // A desktop build that runs on a Java runtime says which system
+        // through the usual property.
+        String os = "se".equals(platform) ? System.getProperty("os.name") : null;
+        return os != null && os.regionMatches(true, 0, name, 0, name.length());
+    }
+
+    /// The version in `s` -- up to four numbers with dots between them --
+    /// as one number, the way [#toVersion] packs it.
+    public static long scanVersion(String s) {
+        int[] parts = new int[4];
+        int count = 0;
+        int value = 0;
+        boolean digits = false;
+        for (int i = 0; s != null && i <= s.length() && count < 4; i++) {
+            char c = i < s.length() ? s.charAt(i) : '.';
+            if (c >= '0' && c <= '9') {
+                value = Math.min(value * 10 + (c - '0'), 0xffff);
+                digits = true;
+            } else if (digits) {
+                parts[count++] = value;
+                value = 0;
+                digits = false;
+                if (c != '.' && c != '_') {
+                    break;
+                }
+            } else {
+                break;
+            }
+        }
+        return toVersion(parts[0], parts[1], parts[2], parts[3]);
+    }
+
+    public static long toVersion(int major, int minor, int micro, int patch) {
+        return ((long) major << 48) + ((long) minor << 32) + ((long) micro << 16) + patch;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/UIScale.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/UIScale.java
new file mode 100644
index 00000000000..0c314021650
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/UIScale.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf.util;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// FlatLaf's user scale factor, which on this layer is always one.
+///
+/// A Swing coordinate here is a logical pixel, 1/96 inch, and the layer
+/// itself turns it into device pixels at the density of the display.
+/// Code that multiplies its sizes with `UIScale.scale(...)` therefore gets
+/// them back unchanged and is scaled exactly once.
+public class UIScale {
+
+    public static final String PROP_USER_SCALE_FACTOR = "userScaleFactor";
+    public static final String PROP_ZOOM_FACTOR = "zoomFactor";
+
+    public UIScale() {
+    }
+
+    /// True: the display is scaled for the application, by the layer.
+    public static boolean isSystemScalingEnabled() {
+        return true;
+    }
+
+    /// One; see the class description.
+    public static float getUserScaleFactor() {
+        return 1f;
+    }
+
+    public static float scale(float value) {
+        return value;
+    }
+
+    public static int scale(int value) {
+        return value;
+    }
+
+    public static int scale2(int value) {
+        return value;
+    }
+
+    public static float unscale(float value) {
+        return value;
+    }
+
+    public static int unscale(int value) {
+        return value;
+    }
+
+    public static Dimension scale(Dimension dimension) {
+        return dimension;
+    }
+
+    public static Insets scale(Insets insets) {
+        return insets;
+    }
+
+    /// One: there is no zoom of the look and feel.
+    public static float getZoomFactor() {
+        return 1f;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/package-info.java
new file mode 100644
index 00000000000..7ae0add3742
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/com/formdev/flatlaf/util/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// FlatLaf utilities applications call: the user scale factor and what the system is.
+package com.codename1.desktopcompat.com.formdev.flatlaf.util;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTError.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTError.java
new file mode 100644
index 00000000000..3dac8a113b7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTError.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Thrown when the toolkit fails in a way an application cannot handle.
+public class AWTError extends Error {
+
+    public AWTError(String msg) {
+        super(msg);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTEvent.java
new file mode 100644
index 00000000000..be1c6d41a38
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTEvent.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import java.util.EventObject;
+
+/// The root of every event the AWT and Swing layers deliver.
+///
+/// An event carries the object it came from, an integer id that tells the
+/// event kinds of one class apart, and a consumed flag that lets a listener
+/// stop the default handling. The legacy `java.awt.Event` based constructor
+/// and the serialization support of the JDK class are not provided.
+public abstract class AWTEvent extends EventObject {
+
+    public static final long COMPONENT_EVENT_MASK = 0x01;
+
+    public static final long CONTAINER_EVENT_MASK = 0x02;
+
+    public static final long FOCUS_EVENT_MASK = 0x04;
+
+    public static final long KEY_EVENT_MASK = 0x08;
+
+    public static final long MOUSE_EVENT_MASK = 0x10;
+
+    public static final long MOUSE_MOTION_EVENT_MASK = 0x20;
+
+    public static final long WINDOW_EVENT_MASK = 0x40;
+
+    public static final long ACTION_EVENT_MASK = 0x80;
+
+    public static final long ADJUSTMENT_EVENT_MASK = 0x100;
+
+    public static final long ITEM_EVENT_MASK = 0x200;
+
+    public static final long TEXT_EVENT_MASK = 0x400;
+
+    public static final long INPUT_METHOD_EVENT_MASK = 0x800;
+
+    public static final long PAINT_EVENT_MASK = 0x2000;
+
+    public static final long INVOCATION_EVENT_MASK = 0x4000;
+
+    public static final long HIERARCHY_EVENT_MASK = 0x8000;
+
+    public static final long HIERARCHY_BOUNDS_EVENT_MASK = 0x10000;
+
+    public static final long MOUSE_WHEEL_EVENT_MASK = 0x20000;
+
+    public static final long WINDOW_STATE_EVENT_MASK = 0x40000;
+
+    public static final long WINDOW_FOCUS_EVENT_MASK = 0x80000;
+
+    public static final int RESERVED_ID_MAX = 1999;
+
+    /// The event kind within the event class.
+    protected int id;
+
+    /// Whether a listener consumed the event.
+    protected boolean consumed;
+
+    public AWTEvent(Object source, int id) {
+        super(source);
+        this.id = id;
+    }
+
+    public void setSource(Object newSource) {
+        if (source == newSource) {
+            return;
+        }
+        source = newSource;
+    }
+
+    public int getID() {
+        return id;
+    }
+
+    public String paramString() {
+        return "";
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[" + paramString() + "] on " + source;
+    }
+
+    protected void consume() {
+        consumed = true;
+    }
+
+    protected boolean isConsumed() {
+        return consumed;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTException.java
new file mode 100644
index 00000000000..e0071d19410
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTException.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Signals that a toolkit operation failed.
+public class AWTException extends Exception {
+
+    public AWTException(String msg) {
+        super(msg);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTKeyStroke.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTKeyStroke.java
new file mode 100644
index 00000000000..ccc160cd6c0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AWTKeyStroke.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.rt.KeyMap;
+
+/// A key action: a key pressed or released with a set of modifiers, or a
+/// character typed.
+///
+/// Like the JDK's, a stroke keeps its modifiers in both encodings, so one
+/// made with `CTRL_MASK` equals one made with `CTRL_DOWN_MASK`. Strokes are
+/// not cached: compare them with `equals`. Strokes are made by the static
+/// factory methods; `registerSubclass` and serialization are absent.
+public class AWTKeyStroke {
+
+    private static final int ALL = InputEvent.SHIFT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK
+            | InputEvent.META_DOWN_MASK | InputEvent.ALT_DOWN_MASK | InputEvent.ALT_GRAPH_DOWN_MASK
+            | InputEvent.BUTTON1_DOWN_MASK | InputEvent.BUTTON2_DOWN_MASK | InputEvent.BUTTON3_DOWN_MASK
+            | InputEvent.SHIFT_MASK | InputEvent.CTRL_MASK | InputEvent.META_MASK | InputEvent.ALT_MASK
+            | InputEvent.ALT_GRAPH_MASK | InputEvent.BUTTON1_MASK;
+
+    private final char keyChar;
+    private final int keyCode;
+    private final int modifiers;
+    private final boolean onKeyRelease;
+
+    protected AWTKeyStroke() {
+        this(KeyEvent.CHAR_UNDEFINED, KeyEvent.VK_UNDEFINED, 0, false);
+    }
+
+    protected AWTKeyStroke(char keyChar, int keyCode, int modifiers, boolean onKeyRelease) {
+        this.keyChar = keyChar;
+        this.keyCode = keyCode;
+        this.modifiers = cn1Normalize(modifiers);
+        this.onKeyRelease = onKeyRelease;
+    }
+
+    /// Completes a set of modifiers so that it carries both the old and
+    /// the extended mask of every modifier in it.
+    static int cn1Normalize(int m) {
+        int r = m & ALL;
+        if ((r & (InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK)) != 0) {
+            r |= InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK;
+        }
+        if ((r & (InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK)) != 0) {
+            r |= InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK;
+        }
+        if ((r & (InputEvent.META_MASK | InputEvent.META_DOWN_MASK)) != 0) {
+            r |= InputEvent.META_MASK | InputEvent.META_DOWN_MASK;
+        }
+        if ((r & (InputEvent.ALT_MASK | InputEvent.ALT_DOWN_MASK)) != 0) {
+            r |= InputEvent.ALT_MASK | InputEvent.ALT_DOWN_MASK;
+        }
+        if ((r & (InputEvent.ALT_GRAPH_MASK | InputEvent.ALT_GRAPH_DOWN_MASK)) != 0) {
+            r |= InputEvent.ALT_GRAPH_MASK | InputEvent.ALT_GRAPH_DOWN_MASK;
+        }
+        if ((r & (InputEvent.BUTTON1_MASK | InputEvent.BUTTON1_DOWN_MASK)) != 0) {
+            r |= InputEvent.BUTTON1_MASK | InputEvent.BUTTON1_DOWN_MASK;
+        }
+        return r;
+    }
+
+    public static AWTKeyStroke getAWTKeyStroke(char keyChar) {
+        return new AWTKeyStroke(keyChar, KeyEvent.VK_UNDEFINED, 0, false);
+    }
+
+    public static AWTKeyStroke getAWTKeyStroke(Character keyChar, int modifiers) {
+        if (keyChar == null) {
+            throw new IllegalArgumentException("keyChar cannot be null");
+        }
+        return new AWTKeyStroke(keyChar.charValue(), KeyEvent.VK_UNDEFINED, modifiers, false);
+    }
+
+    public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers, boolean onKeyRelease) {
+        return new AWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, onKeyRelease);
+    }
+
+    public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers) {
+        return new AWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, false);
+    }
+
+    public static AWTKeyStroke getAWTKeyStrokeForEvent(KeyEvent anEvent) {
+        int[] p = cn1ForEvent(anEvent);
+        return p.length == 0 ? null : new AWTKeyStroke((char) p[0], p[1], p[2], p[3] != 0);
+    }
+
+    /// The parts of the stroke a key event is: character, key code,
+    /// modifiers and whether it is a release; empty for another event.
+    static int[] cn1ForEvent(KeyEvent e) {
+        int mods = e.getModifiers() | e.getModifiersEx();
+        switch (e.getID()) {
+            case KeyEvent.KEY_PRESSED:
+                return new int[]{KeyEvent.CHAR_UNDEFINED, e.getKeyCode(), mods, 0};
+            case KeyEvent.KEY_RELEASED:
+                return new int[]{KeyEvent.CHAR_UNDEFINED, e.getKeyCode(), mods, 1};
+            case KeyEvent.KEY_TYPED:
+                return new int[]{e.getKeyChar(), KeyEvent.VK_UNDEFINED, mods, 0};
+            default:
+                return new int[0];
+        }
+    }
+
+    /// Parses `<modifiers>* (<typedID> | <pressedReleasedID>)`: modifiers
+    /// are `shift`, `control`, `ctrl`, `meta`, `alt`, `altGraph`, `button1`
+    /// to `button3`; then `typed <char>`, or an optional `pressed` or
+    /// `released` and the name of a `VK_` constant without the prefix.
+    public static AWTKeyStroke getAWTKeyStroke(String s) {
+        int[] p = cn1Parse(s);
+        return new AWTKeyStroke((char) p[0], p[1], p[2], p[3] != 0);
+    }
+
+    /// The parts of the stroke a string describes, as [#cn1ForEvent]
+    /// answers them.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if the string is null or not a stroke
+    static int[] cn1Parse(String s) {
+        if (s == null) {
+            throw new IllegalArgumentException("String cannot be null");
+        }
+        int mask = 0;
+        boolean released = false;
+        boolean typed = false;
+        boolean pressed = false;
+        int n = s.length();
+        int i = 0;
+        while (i < n) {
+            while (i < n && s.charAt(i) == ' ') {
+                i++;
+            }
+            int start = i;
+            while (i < n && s.charAt(i) != ' ') {
+                i++;
+            }
+            if (start == i) {
+                break;
+            }
+            String token = s.substring(start, i);
+            boolean last = true;
+            for (int j = i; j < n; j++) {
+                if (s.charAt(j) != ' ') {
+                    last = false;
+                    break;
+                }
+            }
+            if (typed) {
+                if (token.length() != 1 || !last) {
+                    throw new IllegalArgumentException("String formatted incorrectly");
+                }
+                return new int[]{token.charAt(0), KeyEvent.VK_UNDEFINED, mask, 0};
+            }
+            if (pressed || released || last) {
+                if (!last) {
+                    throw new IllegalArgumentException("String formatted incorrectly");
+                }
+                int code = KeyMap.codeOf(token);
+                if (code == KeyEvent.VK_UNDEFINED) {
+                    throw new IllegalArgumentException("String formatted incorrectly");
+                }
+                return new int[]{KeyEvent.CHAR_UNDEFINED, code, mask, released ? 1 : 0};
+            }
+            if ("released".equals(token)) {
+                released = true;
+            } else if ("pressed".equals(token)) {
+                pressed = true;
+            } else if ("typed".equals(token)) {
+                typed = true;
+            } else if ("shift".equals(token)) {
+                mask |= InputEvent.SHIFT_DOWN_MASK;
+            } else if ("control".equals(token) || "ctrl".equals(token)) {
+                mask |= InputEvent.CTRL_DOWN_MASK;
+            } else if ("meta".equals(token)) {
+                mask |= InputEvent.META_DOWN_MASK;
+            } else if ("alt".equals(token)) {
+                mask |= InputEvent.ALT_DOWN_MASK;
+            } else if ("altGraph".equals(token)) {
+                mask |= InputEvent.ALT_GRAPH_DOWN_MASK;
+            } else if ("button1".equals(token)) {
+                mask |= InputEvent.BUTTON1_DOWN_MASK;
+            } else if ("button2".equals(token)) {
+                mask |= InputEvent.BUTTON2_DOWN_MASK;
+            } else if ("button3".equals(token)) {
+                mask |= InputEvent.BUTTON3_DOWN_MASK;
+            } else {
+                throw new IllegalArgumentException("String formatted incorrectly");
+            }
+        }
+        throw new IllegalArgumentException("String formatted incorrectly");
+    }
+
+    public final char getKeyChar() {
+        return keyChar;
+    }
+
+    public final int getKeyCode() {
+        return keyCode;
+    }
+
+    public final int getModifiers() {
+        return modifiers;
+    }
+
+    public final boolean isOnKeyRelease() {
+        return onKeyRelease;
+    }
+
+    public final int getKeyEventType() {
+        if (keyCode == KeyEvent.VK_UNDEFINED) {
+            return KeyEvent.KEY_TYPED;
+        }
+        return onKeyRelease ? KeyEvent.KEY_RELEASED : KeyEvent.KEY_PRESSED;
+    }
+
+    @Override
+    public int hashCode() {
+        return ((keyChar + 1) * (2 * (keyCode + 1)) * (modifiers + 1)) + (onKeyRelease ? 1 : 2);
+    }
+
+    @Override
+    public final boolean equals(Object anObject) {
+        if (anObject instanceof AWTKeyStroke) {
+            AWTKeyStroke ks = (AWTKeyStroke) anObject;
+            return ks.keyChar == keyChar && ks.keyCode == keyCode && ks.onKeyRelease == onKeyRelease
+                    && ks.modifiers == modifiers;
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        if ((modifiers & InputEvent.SHIFT_DOWN_MASK) != 0) {
+            sb.append("shift ");
+        }
+        if ((modifiers & InputEvent.CTRL_DOWN_MASK) != 0) {
+            sb.append("ctrl ");
+        }
+        if ((modifiers & InputEvent.META_DOWN_MASK) != 0) {
+            sb.append("meta ");
+        }
+        if ((modifiers & InputEvent.ALT_DOWN_MASK) != 0) {
+            sb.append("alt ");
+        }
+        if ((modifiers & InputEvent.ALT_GRAPH_DOWN_MASK) != 0) {
+            sb.append("altGraph ");
+        }
+        if ((modifiers & InputEvent.BUTTON1_DOWN_MASK) != 0) {
+            sb.append("button1 ");
+        }
+        if ((modifiers & InputEvent.BUTTON2_DOWN_MASK) != 0) {
+            sb.append("button2 ");
+        }
+        if ((modifiers & InputEvent.BUTTON3_DOWN_MASK) != 0) {
+            sb.append("button3 ");
+        }
+        if (keyCode == KeyEvent.VK_UNDEFINED) {
+            return sb.append("typed ").append(keyChar).toString();
+        }
+        String name = KeyMap.nameOf(keyCode);
+        return sb.append(onKeyRelease ? "released " : "pressed ").append(name == null ? "UNKNOWN" : name).toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ActiveEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ActiveEvent.java
new file mode 100644
index 00000000000..f116a50650a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ActiveEvent.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// An event that knows how to dispatch itself.
+public interface ActiveEvent {
+
+    void dispatch();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Adjustable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Adjustable.java
new file mode 100644
index 00000000000..1fa84cc1807
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Adjustable.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.event.AdjustmentListener;
+
+/// A numeric value that can be adjusted within a range, such as a scroll bar.
+public interface Adjustable {
+
+    int HORIZONTAL = 0;
+
+    int VERTICAL = 1;
+
+    int NO_ORIENTATION = 2;
+
+    int getOrientation();
+
+    void setMinimum(int min);
+
+    int getMinimum();
+
+    void setMaximum(int max);
+
+    int getMaximum();
+
+    void setUnitIncrement(int u);
+
+    int getUnitIncrement();
+
+    void setBlockIncrement(int b);
+
+    int getBlockIncrement();
+
+    void setVisibleAmount(int v);
+
+    int getVisibleAmount();
+
+    void setValue(int v);
+
+    int getValue();
+
+    void addAdjustmentListener(AdjustmentListener l);
+
+    void removeAdjustmentListener(AdjustmentListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AlphaComposite.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AlphaComposite.java
new file mode 100644
index 00000000000..29b3a393783
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/AlphaComposite.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// A Porter-Duff rule with an extra alpha.
+///
+/// Every rule can be named and carried around, but a `Graphics2D` only
+/// draws with `SRC_OVER` (and `SRC` at full alpha onto an opaque surface,
+/// which is the same thing); `setComposite` throws
+/// `UnsupportedOperationException` for the others.
+public final class AlphaComposite implements Composite {
+
+    public static final int CLEAR = 1;
+    public static final int SRC = 2;
+    public static final int DST = 9;
+    public static final int SRC_OVER = 3;
+    public static final int DST_OVER = 4;
+    public static final int SRC_IN = 5;
+    public static final int DST_IN = 6;
+    public static final int SRC_OUT = 7;
+    public static final int DST_OUT = 8;
+    public static final int SRC_ATOP = 10;
+    public static final int DST_ATOP = 11;
+    public static final int XOR = 12;
+
+    public static final AlphaComposite Clear = new AlphaComposite(CLEAR, 1f);
+    public static final AlphaComposite Src = new AlphaComposite(SRC, 1f);
+    public static final AlphaComposite Dst = new AlphaComposite(DST, 1f);
+    public static final AlphaComposite SrcOver = new AlphaComposite(SRC_OVER, 1f);
+    public static final AlphaComposite DstOver = new AlphaComposite(DST_OVER, 1f);
+    public static final AlphaComposite SrcIn = new AlphaComposite(SRC_IN, 1f);
+    public static final AlphaComposite DstIn = new AlphaComposite(DST_IN, 1f);
+    public static final AlphaComposite SrcOut = new AlphaComposite(SRC_OUT, 1f);
+    public static final AlphaComposite DstOut = new AlphaComposite(DST_OUT, 1f);
+    public static final AlphaComposite SrcAtop = new AlphaComposite(SRC_ATOP, 1f);
+    public static final AlphaComposite DstAtop = new AlphaComposite(DST_ATOP, 1f);
+    public static final AlphaComposite Xor = new AlphaComposite(XOR, 1f);
+
+    private final int rule;
+    private final float extraAlpha;
+
+    private AlphaComposite(int rule, float alpha) {
+        if (rule < CLEAR || rule > XOR) {
+            throw new IllegalArgumentException("unknown composite rule");
+        }
+        if (!(alpha >= 0.0f && alpha <= 1.0f)) {
+            throw new IllegalArgumentException("alpha value out of range");
+        }
+        this.rule = rule;
+        this.extraAlpha = alpha;
+    }
+
+    public static AlphaComposite getInstance(int rule) {
+        return new AlphaComposite(rule, 1f);
+    }
+
+    public static AlphaComposite getInstance(int rule, float alpha) {
+        return new AlphaComposite(rule, alpha);
+    }
+
+    public float getAlpha() {
+        return extraAlpha;
+    }
+
+    public int getRule() {
+        return rule;
+    }
+
+    public AlphaComposite derive(int rule) {
+        return new AlphaComposite(rule, extraAlpha);
+    }
+
+    public AlphaComposite derive(float alpha) {
+        return new AlphaComposite(rule, alpha);
+    }
+
+    @Override
+    public int hashCode() {
+        return Float.floatToIntBits(extraAlpha) * 31 + rule;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AlphaComposite)) {
+            return false;
+        }
+        AlphaComposite ac = (AlphaComposite) obj;
+        return rule == ac.rule && Float.floatToIntBits(extraAlpha) == Float.floatToIntBits(ac.extraAlpha);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/BasicStroke.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/BasicStroke.java
new file mode 100644
index 00000000000..58e07327fbb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/BasicStroke.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// A pen of a given width, with caps, joins and an optional dash pattern.
+///
+/// A `Graphics2D` strokes with it directly: width, cap and join map onto
+/// the Codename One stroke and a dash pattern is laid out along the
+/// flattened path. [#createStrokedShape(Shape)] -- turning the stroke into
+/// an outline to fill -- is not implemented and throws.
+public class BasicStroke implements Stroke {
+
+    public static final int JOIN_MITER = 0;
+    public static final int JOIN_ROUND = 1;
+    public static final int JOIN_BEVEL = 2;
+    public static final int CAP_BUTT = 0;
+    public static final int CAP_ROUND = 1;
+    public static final int CAP_SQUARE = 2;
+
+    private final float width;
+    private final int join;
+    private final int cap;
+    private final float miterlimit;
+    private final float[] dash;
+    private final float dashPhase;
+
+    public BasicStroke(float width, int cap, int join, float miterlimit, float[] dash, float dashPhase) {
+        if (width < 0.0f) {
+            throw new IllegalArgumentException("negative width");
+        }
+        if (cap != CAP_BUTT && cap != CAP_ROUND && cap != CAP_SQUARE) {
+            throw new IllegalArgumentException("illegal end cap value");
+        }
+        if (join == JOIN_MITER) {
+            if (miterlimit < 1.0f) {
+                throw new IllegalArgumentException("miter limit < 1");
+            }
+        } else if (join != JOIN_ROUND && join != JOIN_BEVEL) {
+            throw new IllegalArgumentException("illegal line join value");
+        }
+        if (dash != null) {
+            if (dashPhase < 0.0f) {
+                throw new IllegalArgumentException("negative dash phase");
+            }
+            boolean allzero = true;
+            for (float d : dash) {
+                if (d > 0.0) {
+                    allzero = false;
+                } else if (d < 0.0) {
+                    throw new IllegalArgumentException("negative dash length");
+                }
+            }
+            if (allzero) {
+                throw new IllegalArgumentException("dash lengths all zero");
+            }
+        }
+        this.width = width;
+        this.cap = cap;
+        this.join = join;
+        this.miterlimit = miterlimit;
+        this.dash = dash == null ? null : copy(dash);
+        this.dashPhase = dashPhase;
+    }
+
+    public BasicStroke(float width, int cap, int join, float miterlimit) {
+        this(width, cap, join, miterlimit, null, 0.0f);
+    }
+
+    public BasicStroke(float width, int cap, int join) {
+        this(width, cap, join, 10.0f, null, 0.0f);
+    }
+
+    public BasicStroke(float width) {
+        this(width, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);
+    }
+
+    public BasicStroke() {
+        this(1.0f, CAP_SQUARE, JOIN_MITER, 10.0f, null, 0.0f);
+    }
+
+    private static float[] copy(float[] in) {
+        float[] out = new float[in.length];
+        System.arraycopy(in, 0, out, 0, in.length);
+        return out;
+    }
+
+    /// Not implemented: the layer strokes shapes itself and has no stroker
+    /// that returns the outline.
+    @Override
+    public Shape createStrokedShape(Shape s) {
+        throw new UnsupportedOperationException(
+                "BasicStroke.createStrokedShape is not supported; draw the shape with Graphics2D.draw instead");
+    }
+
+    public float getLineWidth() {
+        return width;
+    }
+
+    public int getEndCap() {
+        return cap;
+    }
+
+    public int getLineJoin() {
+        return join;
+    }
+
+    public float getMiterLimit() {
+        return miterlimit;
+    }
+
+    public float[] getDashArray() {
+        return dash == null ? null : copy(dash);
+    }
+
+    public float getDashPhase() {
+        return dashPhase;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = Float.floatToIntBits(width);
+        hash = hash * 31 + join;
+        hash = hash * 31 + cap;
+        hash = hash * 31 + Float.floatToIntBits(miterlimit);
+        if (dash != null) {
+            hash = hash * 31 + Float.floatToIntBits(dashPhase);
+            for (float d : dash) {
+                hash = hash * 31 + Float.floatToIntBits(d);
+            }
+        }
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof BasicStroke)) {
+            return false;
+        }
+        BasicStroke bs = (BasicStroke) obj;
+        if (Float.floatToIntBits(width) != Float.floatToIntBits(bs.width) || join != bs.join || cap != bs.cap
+                || Float.floatToIntBits(miterlimit) != Float.floatToIntBits(bs.miterlimit)) {
+            return false;
+        }
+        if (dash == null || bs.dash == null) {
+            return dash == null && bs.dash == null;
+        }
+        if (Float.floatToIntBits(dashPhase) != Float.floatToIntBits(bs.dashPhase) || dash.length != bs.dash.length) {
+            return false;
+        }
+        for (int i = 0; i < dash.length; i++) {
+            if (Float.floatToIntBits(dash[i]) != Float.floatToIntBits(bs.dash[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/BorderLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/BorderLayout.java
new file mode 100644
index 00000000000..977a983bcf1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/BorderLayout.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Lays a container out as a centre surrounded by up to four edge
+/// components.
+///
+/// There is no component orientation in this layer, so the relative
+/// positions resolve as they do left to right: `PAGE_START` is the north
+/// edge, `PAGE_END` the south, `LINE_START` the west and `LINE_END` the
+/// east. A component added under a relative name takes precedence over one
+/// added under the absolute name of the same edge.
+public class BorderLayout implements LayoutManager2 {
+
+    public static final String NORTH = "North";
+
+    public static final String SOUTH = "South";
+
+    public static final String EAST = "East";
+
+    public static final String WEST = "West";
+
+    public static final String CENTER = "Center";
+
+    public static final String BEFORE_FIRST_LINE = "First";
+
+    public static final String AFTER_LAST_LINE = "Last";
+
+    public static final String BEFORE_LINE_BEGINS = "Before";
+
+    public static final String AFTER_LINE_ENDS = "After";
+
+    public static final String PAGE_START = BEFORE_FIRST_LINE;
+
+    public static final String PAGE_END = AFTER_LAST_LINE;
+
+    public static final String LINE_START = BEFORE_LINE_BEGINS;
+
+    public static final String LINE_END = AFTER_LINE_ENDS;
+
+    private static final int N = 0;
+    private static final int S = 1;
+    private static final int E = 2;
+    private static final int W = 3;
+    private static final int C = 4;
+    private static final int FIRST_LINE = 5;
+    private static final int LAST_LINE = 6;
+    private static final int FIRST_ITEM = 7;
+    private static final int LAST_ITEM = 8;
+    private static final String[] NAMES = {
+        NORTH, SOUTH, EAST, WEST, CENTER, BEFORE_FIRST_LINE, AFTER_LAST_LINE, BEFORE_LINE_BEGINS, AFTER_LINE_ENDS
+    };
+
+    private int hgap;
+    private int vgap;
+    private final Component[] slots = new Component[NAMES.length];
+
+    public BorderLayout() {
+        this(0, 0);
+    }
+
+    public BorderLayout(int hgap, int vgap) {
+        this.hgap = hgap;
+        this.vgap = vgap;
+    }
+
+    public int getHgap() {
+        return hgap;
+    }
+
+    public void setHgap(int hgap) {
+        this.hgap = hgap;
+    }
+
+    public int getVgap() {
+        return vgap;
+    }
+
+    public void setVgap(int vgap) {
+        this.vgap = vgap;
+    }
+
+    private static int slotOf(Object name) {
+        for (int i = 0; i < NAMES.length; i++) {
+            if (NAMES[i].equals(name)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public void addLayoutComponent(Component comp, Object constraints) {
+        if (constraints == null || constraints instanceof String) {
+            addLayoutComponent((String) constraints, comp);
+        } else {
+            throw new IllegalArgumentException("cannot add to layout: constraint must be a string (or null)");
+        }
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+        int slot = name == null ? C : slotOf(name);
+        if (slot < 0) {
+            throw new IllegalArgumentException("cannot add to layout: unknown constraint: " + name);
+        }
+        slots[slot] = comp;
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+        for (int i = 0; i < slots.length; i++) {
+            if (slots[i] == comp) {
+                slots[i] = null;
+            }
+        }
+    }
+
+    public Component getLayoutComponent(Object constraints) {
+        int slot = slotOf(constraints);
+        if (slot < 0) {
+            throw new IllegalArgumentException("cannot get component: unknown constraint: " + constraints);
+        }
+        return slots[slot];
+    }
+
+    public Component getLayoutComponent(Container target, Object constraints) {
+        int slot = slotOf(constraints);
+        if (slot < 0 || slot > C) {
+            throw new IllegalArgumentException("cannot get component: invalid constraint: " + constraints);
+        }
+        return resolve(slot);
+    }
+
+    public Object getConstraints(Component comp) {
+        if (comp == null) {
+            return null;
+        }
+        for (int i = 0; i < slots.length; i++) {
+            if (slots[i] == comp) {
+                return NAMES[i];
+            }
+        }
+        return null;
+    }
+
+    /// The component occupying an absolute edge, a relative name winning
+    /// over the absolute one.
+    private Component resolve(int edge) {
+        Component c = null;
+        switch (edge) {
+            case N:
+                c = slots[FIRST_LINE];
+                break;
+            case S:
+                c = slots[LAST_LINE];
+                break;
+            case W:
+                c = slots[FIRST_ITEM];
+                break;
+            case E:
+                c = slots[LAST_ITEM];
+                break;
+            default:
+                break;
+        }
+        return c != null ? c : slots[edge];
+    }
+
+    private Component visible(int edge) {
+        Component c = resolve(edge);
+        return c != null && c.isVisible() ? c : null;
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container target) {
+        return measure(target, false);
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container target) {
+        return measure(target, true);
+    }
+
+    private static Dimension sizeOf(Component c, boolean preferred) {
+        return preferred ? c.getPreferredSize() : c.getMinimumSize();
+    }
+
+    private Dimension measure(Container target, boolean preferred) {
+        int w = 0;
+        int h = 0;
+        Component c = visible(E);
+        if (c != null) {
+            Dimension d = sizeOf(c, preferred);
+            w += d.width + hgap;
+            h = Math.max(d.height, h);
+        }
+        c = visible(W);
+        if (c != null) {
+            Dimension d = sizeOf(c, preferred);
+            w += d.width + hgap;
+            h = Math.max(d.height, h);
+        }
+        c = visible(C);
+        if (c != null) {
+            Dimension d = sizeOf(c, preferred);
+            w += d.width;
+            h = Math.max(d.height, h);
+        }
+        c = visible(N);
+        if (c != null) {
+            Dimension d = sizeOf(c, preferred);
+            w = Math.max(d.width, w);
+            h += d.height + vgap;
+        }
+        c = visible(S);
+        if (c != null) {
+            Dimension d = sizeOf(c, preferred);
+            w = Math.max(d.width, w);
+            h += d.height + vgap;
+        }
+        Insets in = target.getInsets();
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    @Override
+    public Dimension maximumLayoutSize(Container target) {
+        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+    }
+
+    @Override
+    public float getLayoutAlignmentX(Container parent) {
+        return 0.5f;
+    }
+
+    @Override
+    public float getLayoutAlignmentY(Container parent) {
+        return 0.5f;
+    }
+
+    @Override
+    public void invalidateLayout(Container target) {
+    }
+
+    @Override
+    public void layoutContainer(Container target) {
+        Insets in = target.getInsets();
+        int top = in.top;
+        int bottom = target.getHeight() - in.bottom;
+        int left = in.left;
+        int right = target.getWidth() - in.right;
+
+        Component c = visible(N);
+        if (c != null) {
+            c.setSize(right - left, c.getHeight());
+            Dimension d = c.getPreferredSize();
+            c.setBounds(left, top, right - left, d.height);
+            top += d.height + vgap;
+        }
+        c = visible(S);
+        if (c != null) {
+            c.setSize(right - left, c.getHeight());
+            Dimension d = c.getPreferredSize();
+            c.setBounds(left, bottom - d.height, right - left, d.height);
+            bottom -= d.height + vgap;
+        }
+        c = visible(E);
+        if (c != null) {
+            c.setSize(c.getWidth(), bottom - top);
+            Dimension d = c.getPreferredSize();
+            c.setBounds(right - d.width, top, d.width, bottom - top);
+            right -= d.width + hgap;
+        }
+        c = visible(W);
+        if (c != null) {
+            c.setSize(c.getWidth(), bottom - top);
+            Dimension d = c.getPreferredSize();
+            c.setBounds(left, top, d.width, bottom - top);
+            left += d.width + hgap;
+        }
+        c = visible(C);
+        if (c != null) {
+            c.setBounds(left, top, right - left, bottom - top);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Button.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Button.java
new file mode 100644
index 00000000000..2c69c2c467d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Button.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `Button`, a push button drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JButton` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof Button` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class Button extends Component {
+
+    public Button() {
+        throw new UnsupportedOperationException("java.awt.Button is not available; use javax.swing.JButton");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Canvas.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Canvas.java
new file mode 100644
index 00000000000..9e280668e36
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Canvas.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// A blank rectangle an application paints by overriding `paint`. The
+/// background is cleared before each paint, as a desktop canvas is.
+public class Canvas extends Component {
+
+    public Canvas() {
+    }
+
+    @Override
+    public boolean isOpaque() {
+        return true;
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        g.clearRect(0, 0, getWidth(), getHeight());
+    }
+
+    @Override
+    public void update(Graphics g) {
+        g.clearRect(0, 0, getWidth(), getHeight());
+        paint(g);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/CardLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/CardLayout.java
new file mode 100644
index 00000000000..d16823947fe
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/CardLayout.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import java.util.ArrayList;
+
+/// Shows one child of a container at a time, each child filling the
+/// container like a card in a stack.
+public class CardLayout implements LayoutManager2 {
+
+    private final ArrayList<String> names = new ArrayList<String>();
+    private final ArrayList<Component> cards = new ArrayList<Component>();
+    private int hgap;
+    private int vgap;
+
+    public CardLayout() {
+        this(0, 0);
+    }
+
+    public CardLayout(int hgap, int vgap) {
+        this.hgap = hgap;
+        this.vgap = vgap;
+    }
+
+    public int getHgap() {
+        return hgap;
+    }
+
+    public void setHgap(int hgap) {
+        this.hgap = hgap;
+    }
+
+    public int getVgap() {
+        return vgap;
+    }
+
+    public void setVgap(int vgap) {
+        this.vgap = vgap;
+    }
+
+    @Override
+    public void addLayoutComponent(Component comp, Object constraints) {
+        if (constraints == null) {
+            constraints = "";
+        }
+        if (constraints instanceof String) {
+            addLayoutComponent((String) constraints, comp);
+        } else {
+            throw new IllegalArgumentException("cannot add to layout: constraint must be a string");
+        }
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+        if (!cards.isEmpty()) {
+            comp.setVisible(false);
+        }
+        for (int i = 0; i < names.size(); i++) {
+            if (names.get(i).equals(name)) {
+                cards.set(i, comp);
+                return;
+            }
+        }
+        names.add(name);
+        cards.add(comp);
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+        for (int i = 0; i < cards.size(); i++) {
+            if (cards.get(i) == comp) {
+                if (comp.isVisible() && comp.getParent() != null) {
+                    next(comp.getParent());
+                }
+                cards.remove(i);
+                names.remove(i);
+                break;
+            }
+        }
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        return measure(parent, true);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        return measure(parent, false);
+    }
+
+    private Dimension measure(Container parent, boolean preferred) {
+        Insets in = parent.getInsets();
+        int n = parent.getComponentCount();
+        int w = 0;
+        int h = 0;
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            Dimension d = preferred ? c.getPreferredSize() : c.getMinimumSize();
+            if (d.width > w) {
+                w = d.width;
+            }
+            if (d.height > h) {
+                h = d.height;
+            }
+        }
+        return new Dimension(in.left + in.right + w + hgap * 2, in.top + in.bottom + h + vgap * 2);
+    }
+
+    @Override
+    public Dimension maximumLayoutSize(Container target) {
+        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+    }
+
+    @Override
+    public float getLayoutAlignmentX(Container parent) {
+        return 0.5f;
+    }
+
+    @Override
+    public float getLayoutAlignmentY(Container parent) {
+        return 0.5f;
+    }
+
+    @Override
+    public void invalidateLayout(Container target) {
+    }
+
+    @Override
+    public void layoutContainer(Container parent) {
+        Insets in = parent.getInsets();
+        int n = parent.getComponentCount();
+        boolean shown = false;
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            c.setBounds(hgap + in.left, vgap + in.top, parent.getWidth() - (hgap * 2 + in.left + in.right),
+                    parent.getHeight() - (vgap * 2 + in.top + in.bottom));
+            if (c.isVisible()) {
+                shown = true;
+            }
+        }
+        if (!shown && n > 0) {
+            parent.getComponent(0).setVisible(true);
+        }
+    }
+
+    private void check(Container parent) {
+        if (parent.getLayout() != this) {
+            throw new IllegalArgumentException("wrong parent for CardLayout");
+        }
+    }
+
+    /// Hides whichever child is visible and shows the one at `index`,
+    /// counted from the visible child when `relative` is set.
+    private void flip(Container parent, int index, boolean relative) {
+        check(parent);
+        int n = parent.getComponentCount();
+        if (n == 0) {
+            return;
+        }
+        int target = index;
+        boolean found = false;
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            if (c.isVisible()) {
+                if (relative) {
+                    target = (i + index + n) % n;
+                }
+                c.setVisible(false);
+                found = true;
+                break;
+            }
+        }
+        if (relative && !found) {
+            target = index > 0 ? 0 : n - 1;
+        }
+        if (target < 0) {
+            target = n - 1;
+        }
+        parent.getComponent(target).setVisible(true);
+        parent.validate();
+    }
+
+    public void first(Container parent) {
+        flip(parent, 0, false);
+    }
+
+    public void next(Container parent) {
+        flip(parent, 1, true);
+    }
+
+    public void previous(Container parent) {
+        flip(parent, -1, true);
+    }
+
+    public void last(Container parent) {
+        flip(parent, -1, false);
+    }
+
+    public void show(Container parent, String name) {
+        check(parent);
+        Component next = null;
+        for (int i = 0; i < names.size(); i++) {
+            if (names.get(i).equals(name)) {
+                next = cards.get(i);
+                break;
+            }
+        }
+        if (next == null || next.isVisible()) {
+            return;
+        }
+        int n = parent.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            if (c.isVisible()) {
+                c.setVisible(false);
+                break;
+            }
+        }
+        next.setVisible(true);
+        parent.validate();
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Checkbox.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Checkbox.java
new file mode 100644
index 00000000000..8f7162a3864
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Checkbox.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `Checkbox`, a check box drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JCheckBox` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof Checkbox` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class Checkbox extends Component {
+
+    public Checkbox() {
+        throw new UnsupportedOperationException("java.awt.Checkbox is not available; use javax.swing.JCheckBox");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Choice.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Choice.java
new file mode 100644
index 00000000000..a83be428e84
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Choice.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `Choice`, a drop-down list drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JComboBox` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof Choice` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class Choice extends Component {
+
+    public Choice() {
+        throw new UnsupportedOperationException("java.awt.Choice is not available; use javax.swing.JComboBox");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Color.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Color.java
new file mode 100644
index 00000000000..0995c7ac9aa
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Color.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// An sRGB color with an alpha channel; immutable.
+public class Color implements Paint {
+
+    public static final Color white = new Color(255, 255, 255);
+    public static final Color WHITE = white;
+    public static final Color lightGray = new Color(192, 192, 192);
+    public static final Color LIGHT_GRAY = lightGray;
+    public static final Color gray = new Color(128, 128, 128);
+    public static final Color GRAY = gray;
+    public static final Color darkGray = new Color(64, 64, 64);
+    public static final Color DARK_GRAY = darkGray;
+    public static final Color black = new Color(0, 0, 0);
+    public static final Color BLACK = black;
+    public static final Color red = new Color(255, 0, 0);
+    public static final Color RED = red;
+    public static final Color pink = new Color(255, 175, 175);
+    public static final Color PINK = pink;
+    public static final Color orange = new Color(255, 200, 0);
+    public static final Color ORANGE = orange;
+    public static final Color yellow = new Color(255, 255, 0);
+    public static final Color YELLOW = yellow;
+    public static final Color green = new Color(0, 255, 0);
+    public static final Color GREEN = green;
+    public static final Color magenta = new Color(255, 0, 255);
+    public static final Color MAGENTA = magenta;
+    public static final Color cyan = new Color(0, 255, 255);
+    public static final Color CYAN = cyan;
+    public static final Color blue = new Color(0, 0, 255);
+    public static final Color BLUE = blue;
+
+    private static final double FACTOR = 0.7;
+
+    private final int value;
+
+    public Color(int r, int g, int b) {
+        this(r, g, b, 255);
+    }
+
+    public Color(int r, int g, int b, int a) {
+        check(r);
+        check(g);
+        check(b);
+        check(a);
+        value = (a << 24) | (r << 16) | (g << 8) | b;
+    }
+
+    public Color(int rgb) {
+        value = 0xff000000 | rgb;
+    }
+
+    public Color(int rgba, boolean hasalpha) {
+        value = hasalpha ? rgba : 0xff000000 | rgba;
+    }
+
+    public Color(float r, float g, float b) {
+        this((int) (r * 255 + 0.5), (int) (g * 255 + 0.5), (int) (b * 255 + 0.5));
+    }
+
+    public Color(float r, float g, float b, float a) {
+        this((int) (r * 255 + 0.5), (int) (g * 255 + 0.5), (int) (b * 255 + 0.5), (int) (a * 255 + 0.5));
+    }
+
+    private static void check(int component) {
+        if (component < 0 || component > 255) {
+            throw new IllegalArgumentException("Color parameter outside of expected range");
+        }
+    }
+
+    public int getRed() {
+        return (value >> 16) & 0xff;
+    }
+
+    public int getGreen() {
+        return (value >> 8) & 0xff;
+    }
+
+    public int getBlue() {
+        return value & 0xff;
+    }
+
+    public int getAlpha() {
+        return (value >> 24) & 0xff;
+    }
+
+    public int getRGB() {
+        return value;
+    }
+
+    public Color brighter() {
+        int r = getRed();
+        int g = getGreen();
+        int b = getBlue();
+        int alpha = getAlpha();
+        int i = (int) (1.0 / (1.0 - FACTOR));
+        if (r == 0 && g == 0 && b == 0) {
+            return new Color(i, i, i, alpha);
+        }
+        if (r > 0 && r < i) {
+            r = i;
+        }
+        if (g > 0 && g < i) {
+            g = i;
+        }
+        if (b > 0 && b < i) {
+            b = i;
+        }
+        return new Color(Math.min((int) (r / FACTOR), 255), Math.min((int) (g / FACTOR), 255),
+                Math.min((int) (b / FACTOR), 255), alpha);
+    }
+
+    public Color darker() {
+        return new Color(Math.max((int) (getRed() * FACTOR), 0), Math.max((int) (getGreen() * FACTOR), 0),
+                Math.max((int) (getBlue() * FACTOR), 0), getAlpha());
+    }
+
+    @Override
+    public int hashCode() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof Color && ((Color) obj).value == value;
+    }
+
+    @Override
+    public String toString() {
+        return "java.awt.Color[r=" + getRed() + ",g=" + getGreen() + ",b=" + getBlue() + "]";
+    }
+
+    /// Parses a decimal, `0x`/`#` hexadecimal or `0` octal number as an
+    /// opaque color, as `Integer.decode` reads it: an optional sign before
+    /// the prefix, and a value that fits a signed 32-bit int. A device has
+    /// no `Integer.decode`, so this is that method.
+    public static Color decode(String nm) throws NumberFormatException {
+        String s = nm;
+        if (s.length() == 0) {
+            throw new NumberFormatException("Zero length string");
+        }
+        boolean negative = false;
+        char first = s.charAt(0);
+        if (first == '-' || first == '+') {
+            negative = first == '-';
+            s = s.substring(1);
+        }
+        int radix = 10;
+        if (s.startsWith("0x") || s.startsWith("0X")) {
+            s = s.substring(2);
+            radix = 16;
+        } else if (s.startsWith("#")) {
+            s = s.substring(1);
+            radix = 16;
+        } else if (s.startsWith("0") && s.length() > 1) {
+            s = s.substring(1);
+            radix = 8;
+        }
+        if (s.length() == 0 || s.charAt(0) == '-' || s.charAt(0) == '+') {
+            throw new NumberFormatException("Sign character in wrong position: " + nm);
+        }
+        long v = Long.parseLong(s, radix);
+        if (negative) {
+            v = -v;
+        }
+        if (v < Integer.MIN_VALUE || v > Integer.MAX_VALUE) {
+            throw new NumberFormatException("For input string: \"" + nm + "\"");
+        }
+        int i = (int) v;
+        return new Color((i >> 16) & 0xff, (i >> 8) & 0xff, i & 0xff);
+    }
+
+    public static int HSBtoRGB(float hue, float saturation, float brightness) {
+        int r = 0;
+        int g = 0;
+        int b = 0;
+        if (saturation == 0) {
+            r = (int) (brightness * 255.0f + 0.5f);
+            g = r;
+            b = r;
+        } else {
+            float h = (hue - (float) Math.floor(hue)) * 6.0f;
+            float f = h - (float) Math.floor(h);
+            float p = brightness * (1.0f - saturation);
+            float q = brightness * (1.0f - saturation * f);
+            float t = brightness * (1.0f - (saturation * (1.0f - f)));
+            float fr;
+            float fg;
+            float fb;
+            switch ((int) h) {
+                case 0:
+                    fr = brightness;
+                    fg = t;
+                    fb = p;
+                    break;
+                case 1:
+                    fr = q;
+                    fg = brightness;
+                    fb = p;
+                    break;
+                case 2:
+                    fr = p;
+                    fg = brightness;
+                    fb = t;
+                    break;
+                case 3:
+                    fr = p;
+                    fg = q;
+                    fb = brightness;
+                    break;
+                case 4:
+                    fr = t;
+                    fg = p;
+                    fb = brightness;
+                    break;
+                default:
+                    fr = brightness;
+                    fg = p;
+                    fb = q;
+                    break;
+            }
+            r = (int) (fr * 255.0f + 0.5f);
+            g = (int) (fg * 255.0f + 0.5f);
+            b = (int) (fb * 255.0f + 0.5f);
+        }
+        return 0xff000000 | (r << 16) | (g << 8) | b;
+    }
+
+    public static float[] RGBtoHSB(int r, int g, int b, float[] hsbvals) {
+        float[] out = hsbvals == null ? new float[3] : hsbvals;
+        int cmax = Math.max(r, Math.max(g, b));
+        int cmin = Math.min(r, Math.min(g, b));
+        float brightness = cmax / 255.0f;
+        float saturation = cmax != 0 ? (cmax - cmin) / (float) cmax : 0;
+        float hue = 0;
+        if (saturation != 0) {
+            float span = cmax - cmin;
+            float redc = (cmax - r) / span;
+            float greenc = (cmax - g) / span;
+            float bluec = (cmax - b) / span;
+            if (r == cmax) {
+                hue = bluec - greenc;
+            } else if (g == cmax) {
+                hue = 2.0f + redc - bluec;
+            } else {
+                hue = 4.0f + greenc - redc;
+            }
+            hue = hue / 6.0f;
+            if (hue < 0) {
+                hue = hue + 1.0f;
+            }
+        }
+        out[0] = hue;
+        out[1] = saturation;
+        out[2] = brightness;
+        return out;
+    }
+
+    public static Color getHSBColor(float h, float s, float b) {
+        return new Color(HSBtoRGB(h, s, b));
+    }
+
+    public float[] getRGBComponents(float[] compArray) {
+        float[] f = compArray == null ? new float[4] : compArray;
+        f[0] = getRed() / 255f;
+        f[1] = getGreen() / 255f;
+        f[2] = getBlue() / 255f;
+        f[3] = getAlpha() / 255f;
+        return f;
+    }
+
+    public float[] getRGBColorComponents(float[] compArray) {
+        float[] f = compArray == null ? new float[3] : compArray;
+        f[0] = getRed() / 255f;
+        f[1] = getGreen() / 255f;
+        f[2] = getBlue() / 255f;
+        return f;
+    }
+
+    @Override
+    public int getTransparency() {
+        int alpha = getAlpha();
+        return alpha == 0xff ? OPAQUE : alpha == 0 ? BITMASK : TRANSLUCENT;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Component.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Component.java
new file mode 100644
index 00000000000..fc6ab8d16e1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Component.java
@@ -0,0 +1,1253 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.rt.AwtListeners;
+import com.codename1.desktopcompat.java.awt.dnd.DropTarget;
+import com.codename1.desktopcompat.java.awt.event.ComponentEvent;
+import com.codename1.desktopcompat.java.awt.event.ComponentListener;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.java.awt.event.FocusListener;
+import com.codename1.desktopcompat.java.awt.event.HierarchyEvent;
+import com.codename1.desktopcompat.java.awt.event.HierarchyListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseListener;
+import com.codename1.desktopcompat.java.awt.event.MouseMotionListener;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelListener;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+import com.codename1.desktopcompat.rt.CanvasPeer;
+import com.codename1.desktopcompat.rt.EventBridge;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.G2D;
+import com.codename1.desktopcompat.rt.Peer;
+import com.codename1.desktopcompat.rt.PeerSupport;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+
+/// The base of every AWT and Swing component.
+///
+/// A component keeps its own state -- bounds in logical pixels, colors,
+/// font, listeners -- and is shown through one Codename One component, its
+/// peer, which is made the first time something asks for it. The members
+/// whose names start with `cn1` are the contract between a component and
+/// its peer; they are not part of the desktop API.
+///
+/// Not supported: `getGraphics()` answers `null` (paint from `paint` or
+/// `paintComponent` and ask for it with `repaint`), the component
+/// orientation is recorded and nothing more, and there is no drag and
+/// drop and no input methods.
+public abstract class Component implements ImageObserver {
+
+    public static final float TOP_ALIGNMENT = 0.0f;
+    public static final float CENTER_ALIGNMENT = 0.5f;
+    public static final float BOTTOM_ALIGNMENT = 1.0f;
+    public static final float LEFT_ALIGNMENT = 0.0f;
+    public static final float RIGHT_ALIGNMENT = 1.0f;
+
+    private static final Object TREE_LOCK = new Object();
+
+    private int x;
+    private int y;
+    private int width;
+    private int height;
+    private Container parent;
+    private String name;
+    private boolean visible = true;
+    private boolean enabled = true;
+    private boolean valid;
+    private boolean displayable;
+    private boolean focusable = true;
+    private boolean focusableSet;
+    /// Whether the peer took the focus when it was made, which is what
+    /// it goes back to when this component is made focusable again.
+    private boolean peerTakesFocus;
+    private boolean ignoreRepaint;
+    private Color foreground;
+    private Color background;
+    private Font font;
+    private Cursor cursor;
+    private boolean focusTraversalKeys = true;
+    private ComponentOrientation orientation = ComponentOrientation.UNKNOWN;
+    private Dimension prefSize;
+    private Dimension minSize;
+    private Dimension maxSize;
+    private long eventMask;
+    private com.codename1.ui.Component peer;
+    private PropertyChangeSupport changeSupport;
+    private DropTarget dropTarget;
+    private ArrayList<ComponentListener> componentListeners;
+    private ArrayList<FocusListener> focusListeners;
+    private ArrayList<HierarchyListener> hierarchyListeners;
+    /// How many hierarchy listeners all components have together: a tree
+    /// is walked to tell them of a change only when there is one.
+    private static int hierarchyListenerCount;
+    private ArrayList<KeyListener> keyListeners;
+    private ArrayList<MouseListener> mouseListeners;
+    private ArrayList<MouseMotionListener> mouseMotionListeners;
+    private ArrayList<MouseWheelListener> mouseWheelListeners;
+
+    protected Component() {
+    }
+
+    // ------------------------------------------------------------ peer
+
+    /// The Codename One component that shows this one, made on first use.
+    public final com.codename1.ui.Component cn1Peer() {
+        if (peer == null) {
+            peer = cn1CreatePeer();
+            cn1SyncPeerBounds();
+            peer.setVisible(visible);
+            peer.setEnabled(enabled);
+            peerTakesFocus = peer.isFocusable();
+            if (!focusable) {
+                peer.setFocusable(false);
+            }
+            cn1PeerCreated();
+        }
+        return peer;
+    }
+
+    /// Gives up the peer and makes a new one in its place, for a component
+    /// whose kind of peer follows a property that changed after the first
+    /// was made. Nothing happens while there is no peer yet.
+    protected final void cn1RecreatePeer() {
+        com.codename1.ui.Component old = peer;
+        if (old == null) {
+            return;
+        }
+        com.codename1.ui.Container host = old.getParent();
+        peer = null;
+        com.codename1.ui.Component now = cn1Peer();
+        if (host != null) {
+            int at = host.getComponentIndex(old);
+            host.removeComponent(old);
+            host.addComponent(Math.max(0, Math.min(at, host.getComponentCount())), now);
+        }
+    }
+
+    /// The peer if it was made already, else `null`.
+    public final com.codename1.ui.Component cn1PeerOrNull() {
+        return peer;
+    }
+
+    /// Makes the peer. A widget overrides this to answer the Codename One
+    /// widget that backs it; the answer must implement
+    /// [com.codename1.desktopcompat.rt.Peer]. The default is a blank canvas.
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new CanvasPeer(this);
+    }
+
+    /// Called once, right after the peer was made and given this
+    /// component's bounds, visibility and enabled state.
+    protected void cn1PeerCreated() {
+        cn1PeerSupportApply();
+    }
+
+    private void cn1PeerSupportApply() {
+        if (peer instanceof Peer) {
+            ((Peer) peer).support().applyStyle();
+        }
+    }
+
+    /// Pushes this component's bounds to its peer, snapped to device pixels.
+    /// A window overrides it with nothing: its host places it.
+    public void cn1SyncPeerBounds() {
+        if (peer != null) {
+            peer.setX(Units.toDevice(x));
+            peer.setY(Units.toDevice(y));
+            peer.setWidth(Units.toDeviceSize(x, width));
+            peer.setHeight(Units.toDeviceSize(y, height));
+        }
+    }
+
+    /// Tells a component whose peer is placed by Codename One -- the root
+    /// of a peer tree -- the size its peer was given, in logical pixels.
+    public void cn1PeerResized(int w, int h) {
+        if (w != width || h != height) {
+            width = w;
+            height = h;
+            invalidate();
+            fireComponentEvent(ComponentEvent.COMPONENT_RESIZED);
+        }
+    }
+
+    /// The preferred size of the Codename One widget behind a component
+    /// that has a native look, in logical pixels; `null` for the others.
+    protected Dimension cn1NativePreferredSize() {
+        if (!com.codename1.ui.Display.isInitialized()) {
+            return null;
+        }
+        com.codename1.ui.Component p = cn1Peer();
+        if (p instanceof Peer && ((Peer) p).nativeLook()) {
+            return new Dimension(Units.toLogicalCeil(p.getPreferredW()), Units.toLogicalCeil(p.getPreferredH()));
+        }
+        return null;
+    }
+
+    /// Paints the Codename One widget behind this component into `g`, at
+    /// the origin, and answers `true`; answers `false` and paints nothing
+    /// when the component has no native look, there is no display, or `g`
+    /// is not a graphics of this layer.
+    public boolean cn1PaintNative(Graphics g) {
+        if (!(g instanceof G2D) || !com.codename1.ui.Display.isInitialized()) {
+            return false;
+        }
+        com.codename1.ui.Component p = cn1Peer();
+        if (p instanceof Peer && ((Peer) p).nativeLook()) {
+            ((Peer) p).support().paintNative((G2D) g);
+            return true;
+        }
+        return false;
+    }
+
+    /// Whether mouse events over this component are delivered to it rather
+    /// than to an ancestor: it has a mouse, mouse motion or mouse wheel
+    /// listener, or enabled those events.
+    public boolean cn1WantsMouse() {
+        return notEmpty(mouseListeners) || notEmpty(mouseMotionListeners) || notEmpty(mouseWheelListeners)
+                || (eventMask & (AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK
+                | AWTEvent.MOUSE_WHEEL_EVENT_MASK)) != 0;
+    }
+
+    private static boolean notEmpty(ArrayList<?> l) {
+        return l != null && !l.isEmpty();
+    }
+
+    /// The configuration of the one screen.
+    public GraphicsConfiguration getGraphicsConfiguration() {
+        return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
+    }
+
+    void cn1SetParent(Container p) {
+        parent = p;
+    }
+
+    /// Whether the tab key stops at this component: it is shown by a
+    /// Codename One widget that takes the focus, or has a key or a focus
+    /// listener. Swing components add their own key bindings to that.
+    public boolean cn1FocusTraversable() {
+        if (notEmpty(keyListeners) || notEmpty(focusListeners)) {
+            return true;
+        }
+        return peer instanceof Peer && ((Peer) peer).nativeLook() && peer.isFocusable();
+    }
+
+    /// Whether a window that opens may make this component its focus
+    /// owner: it is shown by a widget that takes the focus, or the
+    /// application said it is focusable.
+    ///
+    /// That is narrower than [#cn1FocusTraversable], as it is on the
+    /// desktop. A component the application draws is passed over there
+    /// unless `setFocusable` was called for it, whatever listens to it:
+    /// a panel with a key listener and nothing more leaves the keys with
+    /// the window.
+    public boolean cn1TakesInitialFocus() {
+        if (peer instanceof Peer && ((Peer) peer).nativeLook() && peer.isFocusable()) {
+            return true;
+        }
+        return focusableSet && focusable;
+    }
+
+    /// Gives the peer the pointer shape this component has, its own or
+    /// the one it inherits. Nothing happens on a port that cannot change
+    /// the pointer's shape, and for a custom cursor.
+    public void cn1ApplyCursor() {
+        if (peer != null && com.codename1.ui.Display.isInitialized()
+                && com.codename1.ui.Component.isSetCursorSupported()) {
+            int type = getCursor().getType();
+            peer.setCursor(type >= Cursor.DEFAULT_CURSOR && type <= Cursor.MOVE_CURSOR ? type
+                    : Cursor.DEFAULT_CURSOR);
+        }
+    }
+
+    // ------------------------------------------------------------ basics
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        String old = this.name;
+        this.name = name;
+        firePropertyChange("name", old, name);
+    }
+
+    public Container getParent() {
+        return parent;
+    }
+
+    public Toolkit getToolkit() {
+        return Toolkit.getDefaultToolkit();
+    }
+
+    /// A single object shared by every component. Nothing in this layer
+    /// locks it: the component tree belongs to the event dispatch thread.
+    public final Object getTreeLock() {
+        return TREE_LOCK;
+    }
+
+    public boolean isValid() {
+        return valid && displayable;
+    }
+
+    /// Whether the component is part of a window that was shown or packed.
+    public boolean isDisplayable() {
+        return displayable;
+    }
+
+    public boolean isVisible() {
+        return visible;
+    }
+
+    public boolean isShowing() {
+        return visible && displayable && parent != null && parent.isShowing();
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean b) {
+        if (enabled != b) {
+            enabled = b;
+            if (peer != null) {
+                peer.setEnabled(b);
+            }
+            firePropertyChange("enabled", !b, b);
+            repaint();
+        }
+    }
+
+    public void setVisible(boolean b) {
+        if (visible != b) {
+            boolean was = isShowing();
+            visible = b;
+            if (peer != null) {
+                peer.setVisible(b);
+            }
+            if (was != isShowing() && cn1HierarchyHeard()) {
+                cn1HierarchyChanged(this, parent, HierarchyEvent.SHOWING_CHANGED);
+            }
+            fireComponentEvent(b ? ComponentEvent.COMPONENT_SHOWN : ComponentEvent.COMPONENT_HIDDEN);
+            if (parent != null) {
+                parent.invalidate();
+                PeerSupport.scheduleLayout(this);
+            }
+        }
+    }
+
+    /// Always `true`: every component of this layer is drawn by its parent.
+    public boolean isLightweight() {
+        return true;
+    }
+
+    public boolean isOpaque() {
+        return false;
+    }
+
+    public boolean isDoubleBuffered() {
+        return false;
+    }
+
+    // ------------------------------------------------------------ look
+
+    public Color getForeground() {
+        if (foreground != null) {
+            return foreground;
+        }
+        return parent != null ? parent.getForeground() : null;
+    }
+
+    public void setForeground(Color c) {
+        Color old = foreground;
+        foreground = c;
+        cn1PeerSupportApply();
+        firePropertyChange("foreground", old, c);
+        repaint();
+    }
+
+    public boolean isForegroundSet() {
+        return foreground != null;
+    }
+
+    public Color getBackground() {
+        if (background != null) {
+            return background;
+        }
+        return parent != null ? parent.getBackground() : null;
+    }
+
+    public void setBackground(Color c) {
+        Color old = background;
+        background = c;
+        cn1PeerSupportApply();
+        firePropertyChange("background", old, c);
+        repaint();
+    }
+
+    public boolean isBackgroundSet() {
+        return background != null;
+    }
+
+    public Font getFont() {
+        if (font != null) {
+            return font;
+        }
+        return parent != null ? parent.getFont() : null;
+    }
+
+    public void setFont(Font f) {
+        Font old = font;
+        font = f;
+        cn1PeerSupportApply();
+        firePropertyChange("font", old, f);
+        if (f != old && (old == null || !old.equals(f))) {
+            invalidate();
+        }
+    }
+
+    public boolean isFontSet() {
+        return font != null;
+    }
+
+    /// Sets the pointer's shape over this component and the children that
+    /// set none of their own. The shape changes where the port can change
+    /// it -- the desktop ports -- and is only recorded elsewhere; a custom
+    /// cursor shows as the default one.
+    public void setCursor(Cursor cursor) {
+        this.cursor = cursor;
+        cn1ApplyCursor();
+    }
+
+    public ComponentOrientation getComponentOrientation() {
+        return orientation;
+    }
+
+    /// Recorded only: layout does not mirror for right to left.
+    public void setComponentOrientation(ComponentOrientation o) {
+        ComponentOrientation old = orientation;
+        orientation = o;
+        firePropertyChange("componentOrientation", old, o);
+    }
+
+    public void applyComponentOrientation(ComponentOrientation orientation) {
+        if (orientation == null) {
+            throw new NullPointerException();
+        }
+        setComponentOrientation(orientation);
+    }
+
+    public Cursor getCursor() {
+        if (cursor != null) {
+            return cursor;
+        }
+        return parent != null ? parent.getCursor() : Cursor.getDefaultCursor();
+    }
+
+    public boolean isCursorSet() {
+        return cursor != null;
+    }
+
+    public FontMetrics getFontMetrics(Font font) {
+        return Fonts.metrics(font);
+    }
+
+    // ------------------------------------------------------------ bounds
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public Point getLocation() {
+        return new Point(x, y);
+    }
+
+    public Point getLocation(Point rv) {
+        if (rv == null) {
+            return new Point(x, y);
+        }
+        rv.setLocation(x, y);
+        return rv;
+    }
+
+    public void setLocation(int x, int y) {
+        setBounds(x, y, width, height);
+    }
+
+    public void setLocation(Point p) {
+        setLocation(p.x, p.y);
+    }
+
+    public Dimension getSize() {
+        return new Dimension(width, height);
+    }
+
+    public Dimension getSize(Dimension rv) {
+        if (rv == null) {
+            return new Dimension(width, height);
+        }
+        rv.setSize(width, height);
+        return rv;
+    }
+
+    public void setSize(int width, int height) {
+        setBounds(x, y, width, height);
+    }
+
+    public void setSize(Dimension d) {
+        setSize(d.width, d.height);
+    }
+
+    public Rectangle getBounds() {
+        return new Rectangle(x, y, width, height);
+    }
+
+    public Rectangle getBounds(Rectangle rv) {
+        if (rv == null) {
+            return new Rectangle(x, y, width, height);
+        }
+        rv.setBounds(x, y, width, height);
+        return rv;
+    }
+
+    public void setBounds(Rectangle r) {
+        setBounds(r.x, r.y, r.width, r.height);
+    }
+
+    public void setBounds(int x, int y, int width, int height) {
+        boolean resized = this.width != width || this.height != height;
+        boolean moved = this.x != x || this.y != y;
+        if (!resized && !moved) {
+            return;
+        }
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        cn1SyncPeerBounds();
+        if (parent != null && !parent.cn1InLayout() && peer != null) {
+            // Moved or resized by the application, not by a layout pass
+            // that repaints when it is done: a frame dragged about a
+            // desktop pane, a piece of a game moved by a timer. Codename
+            // One does not repaint for a peer that changed place, so
+            // without this the screen keeps showing it where it was.
+            parent.repaint();
+        }
+        if (resized) {
+            invalidate();
+            fireComponentEvent(ComponentEvent.COMPONENT_RESIZED);
+        }
+        if (moved) {
+            fireComponentEvent(ComponentEvent.COMPONENT_MOVED);
+        }
+    }
+
+    public Point getLocationOnScreen() {
+        Point p = parent != null ? parent.getLocationOnScreen() : new Point(0, 0);
+        p.translate(x, y);
+        return p;
+    }
+
+    public boolean contains(int x, int y) {
+        return x >= 0 && x < width && y >= 0 && y < height;
+    }
+
+    public boolean contains(Point p) {
+        return contains(p.x, p.y);
+    }
+
+    public Component getComponentAt(int x, int y) {
+        return contains(x, y) ? this : null;
+    }
+
+    public Component getComponentAt(Point p) {
+        return getComponentAt(p.x, p.y);
+    }
+
+    // ------------------------------------------------------------ sizes
+
+    public void setPreferredSize(Dimension preferredSize) {
+        Dimension old = prefSize;
+        prefSize = preferredSize == null ? null : new Dimension(preferredSize);
+        firePropertyChange("preferredSize", old, preferredSize);
+    }
+
+    public boolean isPreferredSizeSet() {
+        return prefSize != null;
+    }
+
+    /// The size set with `setPreferredSize`; else the preferred size of
+    /// the Codename One widget behind a component with a native look; else
+    /// the minimum size.
+    public Dimension getPreferredSize() {
+        if (prefSize != null) {
+            return new Dimension(prefSize);
+        }
+        Dimension d = cn1NativePreferredSize();
+        return d != null ? d : getMinimumSize();
+    }
+
+    public void setMinimumSize(Dimension minimumSize) {
+        Dimension old = minSize;
+        minSize = minimumSize == null ? null : new Dimension(minimumSize);
+        firePropertyChange("minimumSize", old, minimumSize);
+    }
+
+    public boolean isMinimumSizeSet() {
+        return minSize != null;
+    }
+
+    public Dimension getMinimumSize() {
+        if (minSize != null) {
+            return new Dimension(minSize);
+        }
+        Dimension d = cn1NativePreferredSize();
+        if (d != null) {
+            return d;
+        }
+        // The desktop's answer is the size of the moment. Asked how small
+        // the window can get, that would be the size it was last given.
+        return com.codename1.desktopcompat.rt.RootPan.measuring() ? new Dimension(0, 0)
+                : new Dimension(width, height);
+    }
+
+    public void setMaximumSize(Dimension maximumSize) {
+        Dimension old = maxSize;
+        maxSize = maximumSize == null ? null : new Dimension(maximumSize);
+        firePropertyChange("maximumSize", old, maximumSize);
+    }
+
+    public boolean isMaximumSizeSet() {
+        return maxSize != null;
+    }
+
+    public Dimension getMaximumSize() {
+        if (maxSize != null) {
+            return new Dimension(maxSize);
+        }
+        return new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
+    }
+
+    public float getAlignmentX() {
+        return CENTER_ALIGNMENT;
+    }
+
+    public float getAlignmentY() {
+        return CENTER_ALIGNMENT;
+    }
+
+    public int getBaseline(int width, int height) {
+        if (width < 0 || height < 0) {
+            throw new IllegalArgumentException("Width and height must be >= 0");
+        }
+        return -1;
+    }
+
+    // ------------------------------------------------------------ layout
+
+    public void doLayout() {
+    }
+
+    public void validate() {
+        valid = true;
+    }
+
+    public void invalidate() {
+        valid = false;
+        if (peer != null) {
+            peer.setShouldCalcPreferredSize(true);
+        }
+        if (parent != null && parent.cn1Valid()) {
+            parent.invalidate();
+        }
+    }
+
+    /// Invalidates the component and has its window laid out again on the
+    /// next turn of the event dispatch thread.
+    public void revalidate() {
+        invalidate();
+        PeerSupport.scheduleLayout(this);
+    }
+
+    boolean cn1Valid() {
+        return valid;
+    }
+
+    void cn1SetValid(boolean v) {
+        valid = v;
+    }
+
+    /// Called when the component joins a tree that is shown.
+    public void addNotify() {
+        displayable = true;
+        if (getCursor().getType() != Cursor.DEFAULT_CURSOR) {
+            cn1ApplyCursor();
+        }
+    }
+
+    public void removeNotify() {
+        displayable = false;
+        EventBridge.forget(this);
+    }
+
+    // ------------------------------------------------------------ paint
+
+    /// Always `null`: a component is painted only from `paint`, with the
+    /// graphics it is handed. Codename One paints a screen in one pass
+    /// from the event dispatch thread and has no surface to draw on
+    /// between passes, so code that draws from `getGraphics()` must move
+    /// that drawing into `paint` or `paintComponent` and call `repaint()`.
+    public Graphics getGraphics() {
+        return null;
+    }
+
+    public void paint(Graphics g) {
+    }
+
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public void paintAll(Graphics g) {
+        paint(g);
+    }
+
+    public void print(Graphics g) {
+        paint(g);
+    }
+
+    public void printAll(Graphics g) {
+        paintAll(g);
+    }
+
+    public void repaint() {
+        repaint(0, 0, 0, width, height);
+    }
+
+    public void repaint(long tm) {
+        repaint(tm, 0, 0, width, height);
+    }
+
+    public void repaint(int x, int y, int width, int height) {
+        repaint(0, x, y, width, height);
+    }
+
+    /// Asks for the rectangle to be painted on the next paint cycle. The
+    /// delay is ignored.
+    public void repaint(long tm, int x, int y, int width, int height) {
+        if (peer != null && !ignoreRepaint && width > 0 && height > 0) {
+            PeerSupport.repaint(this, x, y, width, height);
+        }
+    }
+
+    public void setIgnoreRepaint(boolean ignoreRepaint) {
+        this.ignoreRepaint = ignoreRepaint;
+    }
+
+    public boolean getIgnoreRepaint() {
+        return ignoreRepaint;
+    }
+
+    @Override
+    public boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h) {
+        return false;
+    }
+
+    /// An off screen image of the given size, in image pixels.
+    public Image createImage(int width, int height) {
+        return new BufferedImage(Math.max(1, width), Math.max(1, height), BufferedImage.TYPE_INT_ARGB);
+    }
+
+    // ------------------------------------------------------------ focus
+
+    public boolean isFocusable() {
+        return focusable;
+    }
+
+    public void setFocusable(boolean focusable) {
+        boolean old = this.focusable;
+        this.focusable = focusable;
+        focusableSet = true;
+        // The widget that shows a component takes the focus of the form
+        // by itself, when the form is shown or the tab key is pressed, and
+        // draws itself as the one chosen: one that is not focusable must
+        // not be offered.
+        if (peer != null) {
+            peer.setFocusable(focusable && peerTakesFocus);
+        }
+        firePropertyChange("focusable", old, focusable);
+    }
+
+    /// Makes this component the focus owner: the component key events go
+    /// to. Focus is granted at once.
+    public void requestFocus() {
+        requestFocusInWindow();
+    }
+
+    public boolean requestFocusInWindow() {
+        if (!focusable || !visible || !enabled) {
+            return false;
+        }
+        EventBridge.setFocusOwner(this, true);
+        return true;
+    }
+
+    public boolean isFocusOwner() {
+        return EventBridge.focusOwner() == this;
+    }
+
+    /// Moves the focus to the next component in the traversal order of
+    /// this component's window.
+    public void transferFocus() {
+        KeyboardFocusManager.getCurrentKeyboardFocusManager().focusNextComponent(this);
+    }
+
+    public void transferFocusBackward() {
+        KeyboardFocusManager.getCurrentKeyboardFocusManager().focusPreviousComponent(this);
+    }
+
+    /// Whether the tab key moves the focus away from this component
+    /// instead of only reaching its key listeners.
+    public boolean getFocusTraversalKeysEnabled() {
+        return focusTraversalKeys;
+    }
+
+    public void setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled) {
+        boolean old = focusTraversalKeys;
+        focusTraversalKeys = focusTraversalKeysEnabled;
+        firePropertyChange("focusTraversalKeysEnabled", old, focusTraversalKeysEnabled);
+    }
+
+    public boolean hasFocus() {
+        return isFocusOwner();
+    }
+
+    // ------------------------------------------------------------ listeners
+
+    /// Hears when this component or one of its ancestors is added or
+    /// removed, becomes displayable or not, or starts or stops showing.
+    public void addHierarchyListener(HierarchyListener l) {
+        if (l != null) {
+            if (hierarchyListeners == null) {
+                hierarchyListeners = new ArrayList<HierarchyListener>();
+            }
+            hierarchyListeners.add(l);
+            cn1CountHierarchyListeners(1);
+        }
+    }
+
+    public void removeHierarchyListener(HierarchyListener l) {
+        if (hierarchyListeners != null && hierarchyListeners.remove(l)) {
+            cn1CountHierarchyListeners(-1);
+        }
+    }
+
+    public HierarchyListener[] getHierarchyListeners() {
+        return hierarchyListeners == null ? new HierarchyListener[0]
+                : hierarchyListeners.toArray(new HierarchyListener[hierarchyListeners.size()]);
+    }
+
+    private static void cn1CountHierarchyListeners(int by) {
+        hierarchyListenerCount += by;
+    }
+
+    /// Whether any component has a hierarchy listener.
+    static boolean cn1HierarchyHeard() {
+        return hierarchyListenerCount > 0;
+    }
+
+    /// Tells the hierarchy listeners of this component that `changed`
+    /// was added to or removed from `changedParent`, or started or
+    /// stopped showing there. A container passes it on to its children.
+    void cn1HierarchyChanged(Component changed, Container changedParent, long flags) {
+        if (hierarchyListeners == null || hierarchyListeners.isEmpty()) {
+            return;
+        }
+        HierarchyListener[] ls = getHierarchyListeners();
+        HierarchyEvent e = new HierarchyEvent(this, HierarchyEvent.HIERARCHY_CHANGED, changed, changedParent, flags);
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].hierarchyChanged(e);
+        }
+    }
+
+    public void addComponentListener(ComponentListener l) {
+        if (l != null) {
+            if (componentListeners == null) {
+                componentListeners = new ArrayList<ComponentListener>();
+            }
+            componentListeners.add(l);
+        }
+    }
+
+    public void removeComponentListener(ComponentListener l) {
+        if (componentListeners != null) {
+            componentListeners.remove(l);
+        }
+    }
+
+    public ComponentListener[] getComponentListeners() {
+        return componentListeners == null ? new ComponentListener[0]
+                : componentListeners.toArray(new ComponentListener[componentListeners.size()]);
+    }
+
+    public void addFocusListener(FocusListener l) {
+        if (l != null) {
+            if (focusListeners == null) {
+                focusListeners = new ArrayList<FocusListener>();
+            }
+            focusListeners.add(l);
+        }
+    }
+
+    public void removeFocusListener(FocusListener l) {
+        if (focusListeners != null) {
+            focusListeners.remove(l);
+        }
+    }
+
+    public FocusListener[] getFocusListeners() {
+        return focusListeners == null ? new FocusListener[0]
+                : focusListeners.toArray(new FocusListener[focusListeners.size()]);
+    }
+
+    public void addKeyListener(KeyListener l) {
+        if (l != null) {
+            if (keyListeners == null) {
+                keyListeners = new ArrayList<KeyListener>();
+            }
+            keyListeners.add(l);
+        }
+    }
+
+    public void removeKeyListener(KeyListener l) {
+        if (keyListeners != null) {
+            keyListeners.remove(l);
+        }
+    }
+
+    public KeyListener[] getKeyListeners() {
+        return keyListeners == null ? new KeyListener[0] : keyListeners.toArray(new KeyListener[keyListeners.size()]);
+    }
+
+    public void addMouseListener(MouseListener l) {
+        if (l != null) {
+            if (mouseListeners == null) {
+                mouseListeners = new ArrayList<MouseListener>();
+            }
+            mouseListeners.add(l);
+        }
+    }
+
+    public void removeMouseListener(MouseListener l) {
+        if (mouseListeners != null) {
+            mouseListeners.remove(l);
+        }
+    }
+
+    public MouseListener[] getMouseListeners() {
+        return mouseListeners == null ? new MouseListener[0]
+                : mouseListeners.toArray(new MouseListener[mouseListeners.size()]);
+    }
+
+    public void addMouseMotionListener(MouseMotionListener l) {
+        if (l != null) {
+            if (mouseMotionListeners == null) {
+                mouseMotionListeners = new ArrayList<MouseMotionListener>();
+            }
+            mouseMotionListeners.add(l);
+        }
+    }
+
+    public void removeMouseMotionListener(MouseMotionListener l) {
+        if (mouseMotionListeners != null) {
+            mouseMotionListeners.remove(l);
+        }
+    }
+
+    public MouseMotionListener[] getMouseMotionListeners() {
+        return mouseMotionListeners == null ? new MouseMotionListener[0]
+                : mouseMotionListeners.toArray(new MouseMotionListener[mouseMotionListeners.size()]);
+    }
+
+    public void addMouseWheelListener(MouseWheelListener l) {
+        if (l != null) {
+            if (mouseWheelListeners == null) {
+                mouseWheelListeners = new ArrayList<MouseWheelListener>();
+            }
+            mouseWheelListeners.add(l);
+        }
+    }
+
+    public void removeMouseWheelListener(MouseWheelListener l) {
+        if (mouseWheelListeners != null) {
+            mouseWheelListeners.remove(l);
+        }
+    }
+
+    public MouseWheelListener[] getMouseWheelListeners() {
+        return mouseWheelListeners == null ? new MouseWheelListener[0]
+                : mouseWheelListeners.toArray(new MouseWheelListener[mouseWheelListeners.size()]);
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (listener != null) {
+            if (changeSupport == null) {
+                changeSupport = new PropertyChangeSupport(this);
+            }
+            changeSupport.addPropertyChangeListener(listener);
+        }
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport != null) {
+            changeSupport.removePropertyChangeListener(listener);
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners() {
+        return changeSupport == null ? new PropertyChangeListener[0] : changeSupport.getPropertyChangeListeners();
+    }
+
+    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        if (listener != null) {
+            if (changeSupport == null) {
+                changeSupport = new PropertyChangeSupport(this);
+            }
+            changeSupport.addPropertyChangeListener(propertyName, listener);
+        }
+    }
+
+    public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        if (changeSupport != null) {
+            changeSupport.removePropertyChangeListener(propertyName, listener);
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
+        return changeSupport == null ? new PropertyChangeListener[0]
+                : changeSupport.getPropertyChangeListeners(propertyName);
+    }
+
+    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        if (changeSupport != null && (oldValue == null || newValue == null || !oldValue.equals(newValue))) {
+            changeSupport.firePropertyChange(propertyName, oldValue, newValue);
+        }
+    }
+
+    protected void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+        if (changeSupport != null && oldValue != newValue) {
+            changeSupport.firePropertyChange(propertyName, oldValue, newValue);
+        }
+    }
+
+    protected void firePropertyChange(String propertyName, int oldValue, int newValue) {
+        if (changeSupport != null && oldValue != newValue) {
+            changeSupport.firePropertyChange(propertyName, oldValue, newValue);
+        }
+    }
+
+    // ------------------------------------------------------------ events
+
+    protected final void enableEvents(long eventsToEnable) {
+        eventMask |= eventsToEnable;
+    }
+
+    protected final void disableEvents(long eventsToDisable) {
+        eventMask &= ~eventsToDisable;
+    }
+
+    private void fireComponentEvent(int id) {
+        if (notEmpty(componentListeners) || (eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0) {
+            dispatchEvent(new ComponentEvent(this, id));
+        }
+    }
+
+    /// Delivers the event to this component, at once.
+    public final void dispatchEvent(AWTEvent e) {
+        AwtListeners.dispatching(e);
+        processEvent(e);
+    }
+
+    protected void processEvent(AWTEvent e) {
+        if (e instanceof FocusEvent) {
+            processFocusEvent((FocusEvent) e);
+        } else if (e instanceof MouseWheelEvent) {
+            processMouseWheelEvent((MouseWheelEvent) e);
+        } else if (e instanceof MouseEvent) {
+            int id = e.getID();
+            if (id == MouseEvent.MOUSE_MOVED || id == MouseEvent.MOUSE_DRAGGED) {
+                processMouseMotionEvent((MouseEvent) e);
+            } else {
+                processMouseEvent((MouseEvent) e);
+            }
+        } else if (e instanceof KeyEvent) {
+            processKeyEvent((KeyEvent) e);
+        } else if (e instanceof ComponentEvent) {
+            processComponentEvent((ComponentEvent) e);
+        }
+    }
+
+    protected void processComponentEvent(ComponentEvent e) {
+        ComponentListener[] ls = getComponentListeners();
+        for (int i = 0; i < ls.length; i++) {
+            switch (e.getID()) {
+                case ComponentEvent.COMPONENT_RESIZED:
+                    ls[i].componentResized(e);
+                    break;
+                case ComponentEvent.COMPONENT_MOVED:
+                    ls[i].componentMoved(e);
+                    break;
+                case ComponentEvent.COMPONENT_SHOWN:
+                    ls[i].componentShown(e);
+                    break;
+                case ComponentEvent.COMPONENT_HIDDEN:
+                    ls[i].componentHidden(e);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    protected void processFocusEvent(FocusEvent e) {
+        FocusListener[] ls = getFocusListeners();
+        for (int i = 0; i < ls.length; i++) {
+            if (e.getID() == FocusEvent.FOCUS_GAINED) {
+                ls[i].focusGained(e);
+            } else {
+                ls[i].focusLost(e);
+            }
+        }
+    }
+
+    protected void processKeyEvent(KeyEvent e) {
+        KeyListener[] ls = getKeyListeners();
+        for (int i = 0; i < ls.length; i++) {
+            switch (e.getID()) {
+                case KeyEvent.KEY_TYPED:
+                    ls[i].keyTyped(e);
+                    break;
+                case KeyEvent.KEY_PRESSED:
+                    ls[i].keyPressed(e);
+                    break;
+                case KeyEvent.KEY_RELEASED:
+                    ls[i].keyReleased(e);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    protected void processMouseEvent(MouseEvent e) {
+        MouseListener[] ls = getMouseListeners();
+        for (int i = 0; i < ls.length; i++) {
+            switch (e.getID()) {
+                case MouseEvent.MOUSE_PRESSED:
+                    ls[i].mousePressed(e);
+                    break;
+                case MouseEvent.MOUSE_RELEASED:
+                    ls[i].mouseReleased(e);
+                    break;
+                case MouseEvent.MOUSE_CLICKED:
+                    ls[i].mouseClicked(e);
+                    break;
+                case MouseEvent.MOUSE_ENTERED:
+                    ls[i].mouseEntered(e);
+                    break;
+                case MouseEvent.MOUSE_EXITED:
+                    ls[i].mouseExited(e);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    protected void processMouseMotionEvent(MouseEvent e) {
+        MouseMotionListener[] ls = getMouseMotionListeners();
+        for (int i = 0; i < ls.length; i++) {
+            if (e.getID() == MouseEvent.MOUSE_MOVED) {
+                ls[i].mouseMoved(e);
+            } else {
+                ls[i].mouseDragged(e);
+            }
+        }
+    }
+
+    protected void processMouseWheelEvent(MouseWheelEvent e) {
+        MouseWheelListener[] ls = getMouseWheelListeners();
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].mouseWheelMoved(e);
+        }
+    }
+
+    protected String paramString() {
+        return (name == null ? "" : name) + "," + x + "," + y + "," + width + "x" + height
+                + (valid ? "" : ",invalid") + (visible ? "" : ",hidden") + (enabled ? "" : ",disabled");
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[" + paramString() + "]";
+    }
+
+    /// Makes this component a place to drop a drag, or with `null` stops
+    /// it being one. A target that belonged to another component moves
+    /// here.
+    public void setDropTarget(DropTarget dt) {
+        if (dt == dropTarget) {
+            return;
+        }
+        DropTarget old = dropTarget;
+        dropTarget = dt;
+        if (old != null && old.getComponent() == this) {
+            old.setComponent(null);
+        }
+        if (dt != null && dt.getComponent() != this) {
+            dt.setComponent(this);
+        }
+    }
+
+    public DropTarget getDropTarget() {
+        return dropTarget;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ComponentOrientation.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ComponentOrientation.java
new file mode 100644
index 00000000000..be656e45b6f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ComponentOrientation.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The direction a component's content runs in. It is recorded on
+/// components; the layout managers of this layer place leading content on
+/// the left whatever it says.
+public final class ComponentOrientation {
+
+    public static final ComponentOrientation LEFT_TO_RIGHT = new ComponentOrientation(true);
+    public static final ComponentOrientation RIGHT_TO_LEFT = new ComponentOrientation(false);
+    public static final ComponentOrientation UNKNOWN = new ComponentOrientation(true);
+
+    private final boolean leftToRight;
+
+    private ComponentOrientation(boolean leftToRight) {
+        this.leftToRight = leftToRight;
+    }
+
+    public boolean isHorizontal() {
+        return true;
+    }
+
+    public boolean isLeftToRight() {
+        return leftToRight;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Composite.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Composite.java
new file mode 100644
index 00000000000..d3b3db38cf8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Composite.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// How drawing is combined with what is already there. The only composite
+/// the layer draws with is [AlphaComposite] in its `SRC_OVER` rule.
+public interface Composite {
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Container.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Container.java
new file mode 100644
index 00000000000..8d1837ae89c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Container.java
@@ -0,0 +1,573 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.event.ContainerEvent;
+import com.codename1.desktopcompat.java.awt.event.ContainerListener;
+import com.codename1.desktopcompat.java.awt.event.HierarchyEvent;
+import com.codename1.desktopcompat.rt.ContainerPeer;
+import com.codename1.desktopcompat.rt.G2D;
+import com.codename1.desktopcompat.rt.Peer;
+import java.util.ArrayList;
+
+/// A component that holds other components and lays them out with a
+/// layout manager.
+///
+/// The peers of the children are children of this container's peer, in
+/// reverse order, so that the first child is painted on top as it is on the
+/// desktop.
+public class Container extends Component {
+
+    private final ArrayList<Component> children = new ArrayList<Component>();
+    private LayoutManager layoutMgr;
+    private boolean cn1Validating;
+    private FocusTraversalPolicy focusPolicy;
+    private ArrayList<ContainerListener> containerListeners;
+
+    public Container() {
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new ContainerPeer(this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof ContainerPeer) {
+            ContainerPeer cp = (ContainerPeer) p;
+            for (int i = children.size() - 1; i >= 0; i--) {
+                cp.addComponent(children.get(i).cn1Peer());
+            }
+        }
+    }
+
+    /// Paints the children: through the peers when `g` is the graphics
+    /// this container's peer is being painted with, else one by one into
+    /// `g`, the last child first.
+    protected void cn1PaintChildren(Graphics g) {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof Peer && g instanceof G2D && ((Peer) p).support().isPainting((G2D) g)) {
+            ((Peer) p).support().paintChildren((G2D) g);
+            return;
+        }
+        for (int i = children.size() - 1; i >= 0; i--) {
+            Component c = children.get(i);
+            if (c.isVisible()) {
+                Graphics cg = g.create(c.getX(), c.getY(), c.getWidth(), c.getHeight());
+                try {
+                    c.paint(cg);
+                } finally {
+                    cg.dispose();
+                }
+            }
+        }
+    }
+
+    public int getComponentCount() {
+        return children.size();
+    }
+
+    public Component getComponent(int n) {
+        if (n < 0 || n >= children.size()) {
+            throw new ArrayIndexOutOfBoundsException("No such child: " + n);
+        }
+        return children.get(n);
+    }
+
+    public Component[] getComponents() {
+        return children.toArray(new Component[children.size()]);
+    }
+
+    public Insets getInsets() {
+        return new Insets(0, 0, 0, 0);
+    }
+
+    public Component add(Component comp) {
+        addImpl(comp, null, -1);
+        return comp;
+    }
+
+    public Component add(String name, Component comp) {
+        addImpl(comp, name, -1);
+        return comp;
+    }
+
+    public Component add(Component comp, int index) {
+        addImpl(comp, null, index);
+        return comp;
+    }
+
+    public void add(Component comp, Object constraints) {
+        addImpl(comp, constraints, -1);
+    }
+
+    public void add(Component comp, Object constraints, int index) {
+        addImpl(comp, constraints, index);
+    }
+
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (index > children.size() || index < -1) {
+            throw new IllegalArgumentException("illegal component position");
+        }
+        if (comp == this) {
+            throw new IllegalArgumentException("adding container to itself");
+        }
+        if (comp instanceof Container) {
+            for (Container c = this; c != null; c = c.getParent()) {
+                if (c == comp) {
+                    throw new IllegalArgumentException("adding container's parent to itself");
+                }
+            }
+        }
+        if (comp instanceof Window) {
+            throw new IllegalArgumentException("adding a window to a container");
+        }
+        Container old = comp.getParent();
+        if (old != null) {
+            old.remove(comp);
+            if (old == this && index > children.size()) {
+                index = children.size();
+            }
+        }
+        int at = index == -1 ? children.size() : index;
+        children.add(at, comp);
+        comp.cn1SetParent(this);
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof ContainerPeer) {
+            ((ContainerPeer) p).addComponent(children.size() - 1 - at, comp.cn1Peer());
+        }
+        if (layoutMgr != null) {
+            if (layoutMgr instanceof LayoutManager2) {
+                ((LayoutManager2) layoutMgr).addLayoutComponent(comp, constraints);
+            } else if (constraints instanceof String) {
+                layoutMgr.addLayoutComponent((String) constraints, comp);
+            }
+        }
+        invalidate();
+        if (isDisplayable()) {
+            comp.addNotify();
+        }
+        if (cn1HierarchyHeard()) {
+            comp.cn1HierarchyChanged(comp, this, HierarchyEvent.PARENT_CHANGED
+                    | (comp.isDisplayable() ? HierarchyEvent.DISPLAYABILITY_CHANGED : 0)
+                    | (comp.isShowing() ? HierarchyEvent.SHOWING_CHANGED : 0));
+        }
+        if (containerListeners != null && !containerListeners.isEmpty()) {
+            dispatchEvent(new ContainerEvent(this, ContainerEvent.COMPONENT_ADDED, comp));
+        }
+    }
+
+    public void remove(int index) {
+        Component comp = getComponent(index);
+        long changes = HierarchyEvent.PARENT_CHANGED
+                | (comp.isDisplayable() ? HierarchyEvent.DISPLAYABILITY_CHANGED : 0)
+                | (comp.isShowing() ? HierarchyEvent.SHOWING_CHANGED : 0);
+        if (comp.isDisplayable()) {
+            comp.removeNotify();
+        }
+        if (layoutMgr != null) {
+            layoutMgr.removeLayoutComponent(comp);
+        }
+        children.remove(index);
+        comp.cn1SetParent(null);
+        if (cn1HierarchyHeard()) {
+            comp.cn1HierarchyChanged(comp, this, changes);
+        }
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        com.codename1.ui.Component cp = comp.cn1PeerOrNull();
+        if (p instanceof ContainerPeer && cp != null) {
+            ((ContainerPeer) p).removeComponent(cp);
+        }
+        invalidate();
+        if (containerListeners != null && !containerListeners.isEmpty()) {
+            dispatchEvent(new ContainerEvent(this, ContainerEvent.COMPONENT_REMOVED, comp));
+        }
+    }
+
+    public void remove(Component comp) {
+        int i = children.indexOf(comp);
+        if (i >= 0) {
+            remove(i);
+        }
+    }
+
+    public void removeAll() {
+        while (!children.isEmpty()) {
+            remove(children.size() - 1);
+        }
+    }
+
+    public int getComponentZOrder(Component comp) {
+        return children.indexOf(comp);
+    }
+
+    public void setComponentZOrder(Component comp, int index) {
+        int i = children.indexOf(comp);
+        if (i < 0) {
+            addImpl(comp, null, index);
+            return;
+        }
+        if (i == index) {
+            return;
+        }
+        children.remove(i);
+        children.add(index, comp);
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        com.codename1.ui.Component cp = comp.cn1PeerOrNull();
+        if (p instanceof ContainerPeer && cp != null) {
+            ((ContainerPeer) p).removeComponent(cp);
+            ((ContainerPeer) p).addComponent(children.size() - 1 - index, cp);
+        }
+        invalidate();
+    }
+
+    public LayoutManager getLayout() {
+        return layoutMgr;
+    }
+
+    public void setLayout(LayoutManager mgr) {
+        layoutMgr = mgr;
+        invalidate();
+    }
+
+    @Override
+    public void doLayout() {
+        if (layoutMgr != null) {
+            layoutMgr.layoutContainer(this);
+        }
+    }
+
+    public boolean isValidateRoot() {
+        return false;
+    }
+
+    /// Whether this container is in the middle of laying its children
+    /// out, and will repaint when it is done.
+    boolean cn1InLayout() {
+        return cn1Validating;
+    }
+
+    @Override
+    public void invalidate() {
+        if (layoutMgr instanceof LayoutManager2) {
+            ((LayoutManager2) layoutMgr).invalidateLayout(this);
+        }
+        super.invalidate();
+    }
+
+    @Override
+    public void validate() {
+        if (!cn1Valid() && !cn1Validating) {
+            validateTree();
+            repaint();
+        }
+    }
+
+    /// Lays this container out and then its invalid children.
+    ///
+    /// A pass that is asked for while this container is in the middle of
+    /// one does nothing. A layout may ask for something to be scrolled
+    /// into view, and showing a rectangle validates the viewport first so
+    /// that it scrolls within the view's new size: without this the
+    /// viewport's layout would start the viewport's layout, without end.
+    /// The pass under way reaches everything the second one would have.
+    protected void validateTree() {
+        if (cn1Validating) {
+            return;
+        }
+        cn1Validating = true;
+        try {
+            if (!cn1Valid()) {
+                doLayout();
+                for (int i = 0; i < children.size(); i++) {
+                    Component c = children.get(i);
+                    if (c instanceof Container) {
+                        if (!c.cn1Valid()) {
+                            ((Container) c).validateTree();
+                        }
+                    } else {
+                        c.validate();
+                    }
+                }
+            }
+            cn1SetValid(true);
+        } finally {
+            cn1Validating = false;
+        }
+    }
+
+    @Override
+    public void setFont(Font f) {
+        super.setFont(f);
+        invalidateTree();
+    }
+
+    private void invalidateTree() {
+        for (int i = 0; i < children.size(); i++) {
+            Component c = children.get(i);
+            if (c instanceof Container) {
+                ((Container) c).invalidateTree();
+            } else {
+                c.cn1SetValid(false);
+            }
+        }
+        cn1SetValid(false);
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet() || layoutMgr == null) {
+            return super.getPreferredSize();
+        }
+        return layoutMgr.preferredLayoutSize(this);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (!isMinimumSizeSet() && layoutMgr == null && com.codename1.desktopcompat.rt.RootPan.measuring()) {
+            Dimension own = super.getMinimumSize();
+            if (own.width == 0 && own.height == 0) {
+                // Children placed by hand: they need the room they are in.
+                return cn1Extent();
+            }
+            return own;
+        }
+        if (isMinimumSizeSet() || layoutMgr == null) {
+            return super.getMinimumSize();
+        }
+        return layoutMgr.minimumLayoutSize(this);
+    }
+
+    /// The far corner of the visible children, as they are placed now.
+    private Dimension cn1Extent() {
+        int w = 0;
+        int h = 0;
+        for (int i = 0; i < children.size(); i++) {
+            Component c = children.get(i);
+            if (c.isVisible()) {
+                w = Math.max(w, c.getX() + c.getWidth());
+                h = Math.max(h, c.getY() + c.getHeight());
+            }
+        }
+        return new Dimension(w, h);
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (!isMaximumSizeSet() && layoutMgr instanceof LayoutManager2) {
+            return ((LayoutManager2) layoutMgr).maximumLayoutSize(this);
+        }
+        return super.getMaximumSize();
+    }
+
+    @Override
+    public float getAlignmentX() {
+        if (layoutMgr instanceof LayoutManager2) {
+            return ((LayoutManager2) layoutMgr).getLayoutAlignmentX(this);
+        }
+        return super.getAlignmentX();
+    }
+
+    @Override
+    public float getAlignmentY() {
+        if (layoutMgr instanceof LayoutManager2) {
+            return ((LayoutManager2) layoutMgr).getLayoutAlignmentY(this);
+        }
+        return super.getAlignmentY();
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        cn1PaintChildren(g);
+    }
+
+    @Override
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public void paintComponents(Graphics g) {
+        cn1PaintChildren(g);
+    }
+
+    @Override
+    public Component getComponentAt(int x, int y) {
+        if (!contains(x, y)) {
+            return null;
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Component c = children.get(i);
+            if (c.contains(x - c.getX(), y - c.getY())) {
+                return c;
+            }
+        }
+        return this;
+    }
+
+    public Component findComponentAt(int x, int y) {
+        if (!contains(x, y) || !isVisible()) {
+            return null;
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Component c = children.get(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            int cx = x - c.getX();
+            int cy = y - c.getY();
+            if (c instanceof Container) {
+                Component found = ((Container) c).findComponentAt(cx, cy);
+                if (found != null) {
+                    return found;
+                }
+            } else if (c.contains(cx, cy)) {
+                return c;
+            }
+        }
+        return this;
+    }
+
+    public Component findComponentAt(Point p) {
+        return findComponentAt(p.x, p.y);
+    }
+
+    @Override
+    public void setCursor(Cursor cursor) {
+        super.setCursor(cursor);
+        cursorChanged();
+    }
+
+    private void cursorChanged() {
+        for (int i = 0; i < children.size(); i++) {
+            Component c = children.get(i);
+            if (!c.isCursorSet()) {
+                c.cn1ApplyCursor();
+                if (c instanceof Container) {
+                    ((Container) c).cursorChanged();
+                }
+            }
+        }
+    }
+
+    /// The order the tab key walks this container's components in, or
+    /// `null` when none was set and the keyboard focus manager's default
+    /// applies. Only the policy of a window is consulted.
+    public FocusTraversalPolicy getFocusTraversalPolicy() {
+        return focusPolicy;
+    }
+
+    public void setFocusTraversalPolicy(FocusTraversalPolicy policy) {
+        FocusTraversalPolicy old = focusPolicy;
+        focusPolicy = policy;
+        firePropertyChange("focusTraversalPolicy", old, policy);
+    }
+
+    public boolean isFocusTraversalPolicySet() {
+        return focusPolicy != null;
+    }
+
+    public boolean isAncestorOf(Component c) {
+        for (Container p = c == null ? null : c.getParent(); p != null; p = p.getParent()) {
+            if (p == this) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void addNotify() {
+        super.addNotify();
+        for (int i = 0; i < children.size(); i++) {
+            children.get(i).addNotify();
+        }
+    }
+
+    @Override
+    public void removeNotify() {
+        for (int i = children.size() - 1; i >= 0 && i < children.size(); i--) {
+            children.get(i).removeNotify();
+        }
+        super.removeNotify();
+    }
+
+    @Override
+    void cn1HierarchyChanged(Component changed, Container changedParent, long flags) {
+        super.cn1HierarchyChanged(changed, changedParent, flags);
+        for (int i = 0; i < children.size(); i++) {
+            children.get(i).cn1HierarchyChanged(changed, changedParent, flags);
+        }
+    }
+
+    public void addContainerListener(ContainerListener l) {
+        if (l != null) {
+            if (containerListeners == null) {
+                containerListeners = new ArrayList<ContainerListener>();
+            }
+            containerListeners.add(l);
+        }
+    }
+
+    public void removeContainerListener(ContainerListener l) {
+        if (containerListeners != null) {
+            containerListeners.remove(l);
+        }
+    }
+
+    public ContainerListener[] getContainerListeners() {
+        return containerListeners == null ? new ContainerListener[0]
+                : containerListeners.toArray(new ContainerListener[containerListeners.size()]);
+    }
+
+    @Override
+    protected void processEvent(AWTEvent e) {
+        if (e instanceof ContainerEvent) {
+            processContainerEvent((ContainerEvent) e);
+        } else {
+            super.processEvent(e);
+        }
+    }
+
+    protected void processContainerEvent(ContainerEvent e) {
+        ContainerListener[] ls = getContainerListeners();
+        for (int i = 0; i < ls.length; i++) {
+            if (e.getID() == ContainerEvent.COMPONENT_ADDED) {
+                ls[i].componentAdded(e);
+            } else {
+                ls[i].componentRemoved(e);
+            }
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        String s = super.paramString();
+        if (layoutMgr != null) {
+            s += ",layout=" + layoutMgr.getClass().getName();
+        }
+        return s;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ContainerOrderFocusTraversalPolicy.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ContainerOrderFocusTraversalPolicy.java
new file mode 100644
index 00000000000..a05cf8b14ec
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ContainerOrderFocusTraversalPolicy.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import java.util.ArrayList;
+
+/// Traverses the components of a container in the order they were added,
+/// depth first.
+///
+/// A component takes part when it is visible, enabled, focusable and
+/// answers `true` from `cn1FocusTraversable()`: it is shown by a Codename
+/// One widget that takes the focus, or has key or focus listeners, or key
+/// bindings of its own. Traversal wraps around at both ends; focus cycle
+/// roots below the container are not treated specially.
+public class ContainerOrderFocusTraversalPolicy extends FocusTraversalPolicy {
+
+    private boolean implicitDownCycleTraversal = true;
+
+    public ContainerOrderFocusTraversalPolicy() {
+    }
+
+    private void collect(Container c, ArrayList<Component> out) {
+        for (int i = 0; i < c.getComponentCount(); i++) {
+            Component k = c.getComponent(i);
+            if (!k.isVisible()) {
+                continue;
+            }
+            if (accept(k)) {
+                out.add(k);
+            }
+            if (k instanceof Container) {
+                collect((Container) k, out);
+            }
+        }
+    }
+
+    private ArrayList<Component> order(Container c) {
+        if (c == null) {
+            throw new IllegalArgumentException("aContainer cannot be null");
+        }
+        ArrayList<Component> out = new ArrayList<Component>();
+        collect(c, out);
+        return out;
+    }
+
+    @Override
+    public Component getComponentAfter(Container aContainer, Component aComponent) {
+        ArrayList<Component> l = order(aContainer);
+        if (l.isEmpty()) {
+            return null;
+        }
+        int i = l.indexOf(aComponent);
+        return l.get(i < 0 || i == l.size() - 1 ? 0 : i + 1);
+    }
+
+    @Override
+    public Component getComponentBefore(Container aContainer, Component aComponent) {
+        ArrayList<Component> l = order(aContainer);
+        if (l.isEmpty()) {
+            return null;
+        }
+        int i = l.indexOf(aComponent);
+        return l.get(i <= 0 ? l.size() - 1 : i - 1);
+    }
+
+    @Override
+    public Component getFirstComponent(Container aContainer) {
+        ArrayList<Component> l = order(aContainer);
+        return l.isEmpty() ? null : l.get(0);
+    }
+
+    @Override
+    public Component getLastComponent(Container aContainer) {
+        ArrayList<Component> l = order(aContainer);
+        return l.isEmpty() ? null : l.get(l.size() - 1);
+    }
+
+    @Override
+    public Component getDefaultComponent(Container aContainer) {
+        return getFirstComponent(aContainer);
+    }
+
+    public void setImplicitDownCycleTraversal(boolean implicitDownCycleTraversal) {
+        this.implicitDownCycleTraversal = implicitDownCycleTraversal;
+    }
+
+    public boolean getImplicitDownCycleTraversal() {
+        return implicitDownCycleTraversal;
+    }
+
+    protected boolean accept(Component aComponent) {
+        return aComponent.isVisible() && aComponent.isDisplayable() && aComponent.isEnabled()
+                && aComponent.isFocusable() && aComponent.cn1FocusTraversable();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Cursor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Cursor.java
new file mode 100644
index 00000000000..ab2a4b36b40
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Cursor.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// A pointer shape. Cursors are recorded on components but the pointer's
+/// shape is never changed.
+public class Cursor {
+
+    public static final int DEFAULT_CURSOR = 0;
+    public static final int CROSSHAIR_CURSOR = 1;
+    public static final int TEXT_CURSOR = 2;
+    public static final int WAIT_CURSOR = 3;
+    public static final int SW_RESIZE_CURSOR = 4;
+    public static final int SE_RESIZE_CURSOR = 5;
+    public static final int NW_RESIZE_CURSOR = 6;
+    public static final int NE_RESIZE_CURSOR = 7;
+    public static final int N_RESIZE_CURSOR = 8;
+    public static final int S_RESIZE_CURSOR = 9;
+    public static final int W_RESIZE_CURSOR = 10;
+    public static final int E_RESIZE_CURSOR = 11;
+    public static final int HAND_CURSOR = 12;
+    public static final int MOVE_CURSOR = 13;
+    public static final int CUSTOM_CURSOR = -1;
+
+    private static final String[] NAMES = {"Default Cursor", "Crosshair Cursor", "Text Cursor", "Wait Cursor",
+        "Southwest Resize Cursor", "Southeast Resize Cursor", "Northwest Resize Cursor", "Northeast Resize Cursor",
+        "North Resize Cursor", "South Resize Cursor", "West Resize Cursor", "East Resize Cursor", "Hand Cursor",
+        "Move Cursor"};
+
+    private static final Cursor[] PREDEFINED = new Cursor[14];
+
+    protected String name;
+    private final int type;
+
+    public Cursor(int type) {
+        if (type < DEFAULT_CURSOR || type > MOVE_CURSOR) {
+            throw new IllegalArgumentException("illegal cursor type");
+        }
+        this.type = type;
+        this.name = NAMES[type];
+    }
+
+    protected Cursor(String name) {
+        this.type = CUSTOM_CURSOR;
+        this.name = name;
+    }
+
+    public static Cursor getPredefinedCursor(int type) {
+        if (type < DEFAULT_CURSOR || type > MOVE_CURSOR) {
+            throw new IllegalArgumentException("illegal cursor type");
+        }
+        Cursor c = PREDEFINED[type];
+        if (c == null) {
+            c = new Cursor(type);
+            PREDEFINED[type] = c;
+        }
+        return c;
+    }
+
+    public static Cursor getDefaultCursor() {
+        return getPredefinedCursor(DEFAULT_CURSOR);
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[" + getName() + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/DefaultFocusTraversalPolicy.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/DefaultFocusTraversalPolicy.java
new file mode 100644
index 00000000000..daafd3f3e51
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/DefaultFocusTraversalPolicy.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The policy a window uses when none was set: container order.
+public class DefaultFocusTraversalPolicy extends ContainerOrderFocusTraversalPolicy {
+
+    public DefaultFocusTraversalPolicy() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/DefaultKeyboardFocusManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/DefaultKeyboardFocusManager.java
new file mode 100644
index 00000000000..e07e207933a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/DefaultKeyboardFocusManager.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The one keyboard focus manager of the layer.
+public class DefaultKeyboardFocusManager extends KeyboardFocusManager {
+
+    public DefaultKeyboardFocusManager() {
+    }
+
+    private static Container root(Component c) {
+        Container top = null;
+        for (Container p = c instanceof Container ? (Container) c : c.getParent(); p != null; p = p.getParent()) {
+            top = p;
+        }
+        return top;
+    }
+
+    private static FocusTraversalPolicy policy(Container root) {
+        FocusTraversalPolicy p = root.getFocusTraversalPolicy();
+        return p != null ? p : getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();
+    }
+
+    @Override
+    public void focusNextComponent(Component aComponent) {
+        if (aComponent == null) {
+            return;
+        }
+        Container root = root(aComponent);
+        if (root != null) {
+            Component next = policy(root).getComponentAfter(root, aComponent);
+            if (next != null) {
+                next.requestFocusInWindow();
+            }
+        }
+    }
+
+    @Override
+    public void focusPreviousComponent(Component aComponent) {
+        if (aComponent == null) {
+            return;
+        }
+        Container root = root(aComponent);
+        if (root != null) {
+            Component next = policy(root).getComponentBefore(root, aComponent);
+            if (next != null) {
+                next.requestFocusInWindow();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Desktop.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Desktop.java
new file mode 100644
index 00000000000..c37ec49184b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Desktop.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.desktop.PreferencesHandler;
+import com.codename1.desktopcompat.rt.Launcher;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+
+/// Opens a web page, a mail message or a file in the application the
+/// device has for it.
+///
+/// Each call hands a URL to Codename One's `Display.execute`. What happens
+/// then is the device's business: nothing reports whether an application
+/// took the URL, so no call here fails for want of one.
+///
+/// What differs from the desktop: `EDIT` and `PRINT` are not supported;
+/// `open` asks the device to show the file and cannot start a program; a
+/// file is not checked for existing first. None of the `APP_` actions is
+/// supported -- there is no application menu to put an About or a
+/// Preferences item in -- so [#isSupported] answers false for them and
+/// [#setPreferencesHandler] throws, as on a desktop without them.
+public class Desktop {
+
+    /// What a desktop can be asked to do.
+    public enum Action {
+        OPEN, EDIT, PRINT, MAIL, BROWSE,
+        APP_EVENT_FOREGROUND, APP_EVENT_HIDDEN, APP_EVENT_REOPENED, APP_EVENT_SCREEN_SLEEP,
+        APP_EVENT_SYSTEM_SLEEP, APP_EVENT_USER_SESSION, APP_ABOUT, APP_PREFERENCES, APP_OPEN_FILE,
+        APP_PRINT_FILE, APP_OPEN_URI, APP_QUIT_HANDLER, APP_QUIT_STRATEGY, APP_SUDDEN_TERMINATION,
+        APP_REQUEST_FOREGROUND, APP_HELP_VIEWER, APP_MENU_BAR, BROWSE_FILE_DIR, MOVE_TO_TRASH
+    }
+
+    private static final Desktop DESKTOP = new Desktop();
+
+    private Desktop() {
+    }
+
+    public static Desktop getDesktop() {
+        return DESKTOP;
+    }
+
+    /// Always true: every Codename One port can be asked to open a URL.
+    public static boolean isDesktopSupported() {
+        return true;
+    }
+
+    public boolean isSupported(Action action) {
+        return action == Action.OPEN || action == Action.MAIL || action == Action.BROWSE;
+    }
+
+    /// Opens a URI in the browser.
+    public void browse(URI uri) throws IOException {
+        if (uri == null) {
+            throw new NullPointerException("uri");
+        }
+        Launcher.open(uri.toString());
+    }
+
+    /// Opens the mail application with an empty message.
+    public void mail() throws IOException {
+        Launcher.open("mailto:");
+    }
+
+    /// Opens the mail application on a `mailto:` URI.
+    public void mail(URI mailtoURI) throws IOException {
+        if (mailtoURI == null) {
+            throw new NullPointerException("mailtoURI");
+        }
+        if (!"mailto".equalsIgnoreCase(mailtoURI.getScheme())) {
+            throw new IllegalArgumentException("URI scheme is not \"mailto\"");
+        }
+        Launcher.open(mailtoURI.toString());
+    }
+
+    /// Asks the device to show a file.
+    public void open(File file) throws IOException {
+        if (file == null) {
+            throw new NullPointerException("file");
+        }
+        String path = file.getAbsolutePath();
+        Launcher.open(path.indexOf("://") >= 0 ? path : "file://" + path);
+    }
+
+    /// Sets what the Preferences item of the application menu does.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedOperationException`: always: `APP_PREFERENCES` is not
+    ///   supported, which [#isSupported] says and a caller has to ask first
+    public void setPreferencesHandler(PreferencesHandler preferencesHandler) {
+        if (!isSupported(Action.APP_PREFERENCES)) {
+            throw new UnsupportedOperationException(Action.APP_PREFERENCES.name());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Dialog.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Dialog.java
new file mode 100644
index 00000000000..6a21df51b30
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Dialog.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.io.Util;
+import com.codename1.ui.Display;
+
+/// A titled window owned by another.
+///
+/// **A modal dialog blocks.** `setVisible(true)` on a modal dialog, called
+/// on the event dispatch thread, returns only once the dialog was hidden
+/// or disposed of. Meanwhile the event dispatch thread keeps running
+/// events -- painting, input, timers, `invokeLater` -- from inside that
+/// call, exactly as a nested event loop does on the desktop. The three
+/// modal modality types behave the same: other windows get no input.
+///
+/// Called on another thread, with no display, or on a modeless dialog,
+/// `setVisible(true)` returns at once.
+public class Dialog extends Window {
+
+    /// How a dialog keeps input from other windows. Everything but
+    /// `MODELESS` blocks the caller of `setVisible(true)`.
+    public enum ModalityType {
+        MODELESS,
+        DOCUMENT_MODAL,
+        APPLICATION_MODAL,
+        TOOLKIT_MODAL
+    }
+
+    /// Which windows a modal dialog leaves usable. Asked for with
+    /// `Window.setModalExclusionType`; see there for what is honoured.
+    public enum ModalExclusionType {
+        NO_EXCLUDE,
+        APPLICATION_EXCLUDE,
+        TOOLKIT_EXCLUDE
+    }
+
+    public static final ModalityType DEFAULT_MODALITY_TYPE = ModalityType.APPLICATION_MODAL;
+
+    private static final Runnable PAUSE = new Pause();
+
+    private String title;
+    private ModalityType modality;
+    private boolean resizable = true;
+    private boolean undecorated;
+
+    public Dialog(Frame owner) {
+        this(owner, "", false);
+    }
+
+    public Dialog(Frame owner, boolean modal) {
+        this(owner, "", modal);
+    }
+
+    public Dialog(Frame owner, String title) {
+        this(owner, title, false);
+    }
+
+    public Dialog(Frame owner, String title, boolean modal) {
+        this((Window) owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS);
+    }
+
+    public Dialog(Dialog owner) {
+        this(owner, "", false);
+    }
+
+    public Dialog(Dialog owner, String title) {
+        this(owner, title, false);
+    }
+
+    public Dialog(Dialog owner, String title, boolean modal) {
+        this((Window) owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS);
+    }
+
+    public Dialog(Window owner) {
+        this(owner, "", ModalityType.MODELESS);
+    }
+
+    public Dialog(Window owner, String title) {
+        this(owner, title, ModalityType.MODELESS);
+    }
+
+    public Dialog(Window owner, ModalityType modalityType) {
+        this(owner, "", modalityType);
+    }
+
+    public Dialog(Window owner, String title, ModalityType modalityType) {
+        super(owner);
+        this.title = title == null ? "" : title;
+        this.modality = modalityType == null ? ModalityType.MODELESS : modalityType;
+    }
+
+    @Override
+    public String cn1Title() {
+        return title;
+    }
+
+    @Override
+    protected boolean cn1Resizable() {
+        return resizable;
+    }
+
+    @Override
+    protected boolean cn1Decorated() {
+        return !undecorated;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        String old = this.title;
+        this.title = title == null ? "" : title;
+        if (cn1Host() != null) {
+            cn1Host().title(this.title);
+        }
+        firePropertyChange("title", old, this.title);
+    }
+
+    public boolean isModal() {
+        return modality != ModalityType.MODELESS;
+    }
+
+    /// Takes effect the next time the dialog is shown.
+    public void setModal(boolean modal) {
+        modality = modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS;
+    }
+
+    public ModalityType getModalityType() {
+        return modality;
+    }
+
+    /// Takes effect the next time the dialog is shown.
+    public void setModalityType(ModalityType type) {
+        modality = type == null ? ModalityType.MODELESS : type;
+    }
+
+    /// Shows or hides the dialog. Showing a modal dialog blocks; see the
+    /// class description.
+    @Override
+    public void setVisible(boolean b) {
+        boolean was = isVisible();
+        super.setVisible(b);
+        if (b && !was && isModal() && Display.isInitialized() && Display.getInstance().isEdt()) {
+            while (isVisible()) {
+                Display.getInstance().invokeAndBlock(PAUSE);
+            }
+        }
+    }
+
+    public boolean isResizable() {
+        return resizable;
+    }
+
+    public void setResizable(boolean resizable) {
+        this.resizable = resizable;
+        if (cn1Host() != null) {
+            cn1Host().resizable(resizable);
+        }
+    }
+
+    public boolean isUndecorated() {
+        return undecorated;
+    }
+
+    /// Takes effect the next time the dialog is shown.
+    public void setUndecorated(boolean undecorated) {
+        this.undecorated = undecorated;
+    }
+
+    /// What the blocked caller waits in between two looks at whether the
+    /// dialog is still showing; the event dispatch thread runs events
+    /// meanwhile.
+    private static final class Pause implements Runnable {
+        @Override
+        public void run() {
+            Util.sleep(15);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Dimension.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Dimension.java
new file mode 100644
index 00000000000..c489e3efe4e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Dimension.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.Dimension2D;
+
+/// A width and a height in integer units.
+public class Dimension extends Dimension2D {
+
+    public int width;
+
+    public int height;
+
+    public Dimension() {
+    }
+
+    public Dimension(Dimension d) {
+        this.width = d.width;
+        this.height = d.height;
+    }
+
+    public Dimension(int width, int height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public double getWidth() {
+        return width;
+    }
+
+    @Override
+    public double getHeight() {
+        return height;
+    }
+
+    /// Rounds each value up to an integer.
+    @Override
+    public void setSize(double width, double height) {
+        this.width = (int) Math.ceil(width);
+        this.height = (int) Math.ceil(height);
+    }
+
+    public Dimension getSize() {
+        return new Dimension(width, height);
+    }
+
+    public void setSize(Dimension d) {
+        this.width = d.width;
+        this.height = d.height;
+    }
+
+    public void setSize(int width, int height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Dimension) {
+            Dimension d = (Dimension) obj;
+            return width == d.width && height == d.height;
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return width * 31 + height;
+    }
+
+    @Override
+    public Object clone() {
+        return new Dimension(width, height);
+    }
+
+    @Override
+    public String toString() {
+        return "java.awt.Dimension[width=" + width + ",height=" + height + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/EventQueue.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/EventQueue.java
new file mode 100644
index 00000000000..ff123da3f8c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/EventQueue.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.ui.Display;
+import java.lang.reflect.InvocationTargetException;
+
+/// The event dispatch thread, which is Codename One's own.
+public class EventQueue {
+
+    public EventQueue() {
+    }
+
+    public static boolean isDispatchThread() {
+        return !Display.isInitialized() || Display.getInstance().isEdt();
+    }
+
+    /// Runs `runnable` on the event dispatch thread after the events
+    /// already queued. With no display running it runs at once.
+    public static void invokeLater(Runnable runnable) {
+        if (Display.isInitialized()) {
+            Display.getInstance().callSerially(runnable);
+        } else {
+            runnable.run();
+        }
+    }
+
+    /// Runs `runnable` on the event dispatch thread and returns when it
+    /// has.
+    ///
+    /// Called from another thread it is the desktop's: whatever the
+    /// runnable throws comes back wrapped in an
+    /// `InvocationTargetException`. Called on the event dispatch thread
+    /// -- where the desktop throws an error, and where a `main` method
+    /// runs in this layer -- it simply runs the runnable, and an exception
+    /// propagates as it is.
+    public static void invokeAndWait(final Runnable runnable)
+            throws InterruptedException, InvocationTargetException {
+        if (!Display.isInitialized() || Display.getInstance().isEdt()) {
+            runnable.run();
+            return;
+        }
+        final Throwable[] failure = new Throwable[1];
+        Display.getInstance().callSeriallyAndWait(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    runnable.run();
+                } catch (RuntimeException e) {
+                    failure[0] = e;
+                } catch (Error e) {
+                    failure[0] = e;
+                }
+            }
+        });
+        if (failure[0] != null) {
+            throw new InvocationTargetException(failure[0]);
+        }
+    }
+
+    public static long getMostRecentEventTime() {
+        return System.currentTimeMillis();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FlowLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FlowLayout.java
new file mode 100644
index 00000000000..8fb37043c21
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FlowLayout.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Arranges components in rows at their preferred sizes, starting a new row
+/// when the next component does not fit.
+///
+/// There is no component orientation in this layer: every container is laid
+/// out left to right, so `LEADING` is the left edge and `TRAILING` the right
+/// one. Baseline alignment is recorded but rows are always centred
+/// vertically.
+public class FlowLayout implements LayoutManager {
+
+    public static final int LEFT = 0;
+
+    public static final int CENTER = 1;
+
+    public static final int RIGHT = 2;
+
+    public static final int LEADING = 3;
+
+    public static final int TRAILING = 4;
+
+    private int align;
+    private int hgap;
+    private int vgap;
+    private boolean alignOnBaseline;
+    private int answeredRows;
+    private int askedAt = -1;
+
+    public FlowLayout() {
+        this(CENTER, 5, 5);
+    }
+
+    public FlowLayout(int align) {
+        this(align, 5, 5);
+    }
+
+    public FlowLayout(int align, int hgap, int vgap) {
+        this.align = align;
+        this.hgap = hgap;
+        this.vgap = vgap;
+    }
+
+    public int getAlignment() {
+        return align;
+    }
+
+    public void setAlignment(int align) {
+        this.align = align;
+    }
+
+    public int getHgap() {
+        return hgap;
+    }
+
+    public void setHgap(int hgap) {
+        this.hgap = hgap;
+    }
+
+    public int getVgap() {
+        return vgap;
+    }
+
+    public void setVgap(int vgap) {
+        this.vgap = vgap;
+    }
+
+    /// Recorded only: rows are centred vertically whatever this is set to.
+    public void setAlignOnBaseline(boolean alignOnBaseline) {
+        this.alignOnBaseline = alignOnBaseline;
+    }
+
+    public boolean getAlignOnBaseline() {
+        return alignOnBaseline;
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container target) {
+        return measure(target, true);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container target) {
+        return measure(target, false);
+    }
+
+    private Dimension measure(Container target, boolean preferred) {
+        int w = 0;
+        int h = 0;
+        boolean first = true;
+        int n = target.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = target.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            Dimension d = preferred ? c.getPreferredSize() : c.getMinimumSize();
+            if (d.height > h) {
+                h = d.height;
+            }
+            if (first) {
+                first = false;
+            } else {
+                w += hgap;
+            }
+            w += d.width;
+        }
+        Insets in = target.getInsets();
+        int across = in.left + in.right + hgap * 2;
+        int limit = wrapWidth(target);
+        if (w + across <= limit) {
+            answeredRows = first ? 0 : 1;
+            return new Dimension(w + across, h + in.top + in.bottom + vgap * 2);
+        }
+        // The row does not fit and will be wrapped: say how high the rows
+        // are, so the container is given the room and they are not cut.
+        int x = 0;
+        int y = 0;
+        int rowh = 0;
+        int widest = 0;
+        int rows = 1;
+        for (int i = 0; i < n; i++) {
+            Component c = target.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            Dimension d = preferred ? c.getPreferredSize() : c.getMinimumSize();
+            if (d.width > widest) {
+                widest = d.width;
+            }
+            if (x == 0 || x + hgap + d.width <= limit - across) {
+                x += (x == 0 ? 0 : hgap) + d.width;
+                rowh = Math.max(rowh, d.height);
+            } else {
+                y += rowh + vgap;
+                x = d.width;
+                rowh = d.height;
+                rows++;
+            }
+        }
+        answeredRows = rows;
+        // The width asked for stays that of one row, which is what the
+        // container is given wherever there is room; while a window asks
+        // how narrow it can be, it is the widest component.
+        int wide = !preferred && com.codename1.desktopcompat.rt.RootPan.measuring() ? widest : w;
+        return new Dimension(wide + across, y + rowh + in.top + in.bottom + vgap * 2);
+    }
+
+    /// The width rows are wrapped at when sizes are asked for: that of the
+    /// container once it has one, and never more than the display's.
+    ///
+    /// On a desktop a flow layout answers the size of a single row whatever
+    /// width it has, and the rows it wraps into a narrower container are
+    /// cut off. A window there is as wide as its content asks; on a phone
+    /// it is as wide as the display, so a row of buttons wraps routinely
+    /// and has to be given the height for it.
+    ///
+    /// That holds for a row narrower than the display as well. Three
+    /// radio buttons beside a label fit a phone and do not fit the column
+    /// the label leaves them: the second and third went into rows below
+    /// the container, which was one row high, and were not there at all.
+    /// So whatever width the container was last given is where the rows
+    /// are counted, and [#layoutContainer(Container)] has the container
+    /// measured again when it wraps into another number of rows than the
+    /// last answer was for.
+    ///
+    /// Only where the display decides the width, though, and only for a
+    /// container that is on it. A desktop window takes the size its content
+    /// asks for, so there the answer stays the desktop's one row; and a
+    /// container nothing shows has a width only because the application
+    /// set one, which is not a width anything wrapped it into.
+    private static int wrapWidth(Container target) {
+        int limit = com.codename1.desktopcompat.rt.RootPan.displayWidth();
+        int w = target.getWidth();
+        if (w > 0 && w < limit && followsItsWidth(target)) {
+            limit = w;
+        }
+        return limit;
+    }
+
+    private static boolean followsItsWidth(Container target) {
+        if (!target.isDisplayable() || !com.codename1.ui.Display.isInitialized()) {
+            return false;
+        }
+        // A page in a browser is as wide as the browser made it, on a
+        // desktop too: no window there takes the size its content asks for.
+        com.codename1.ui.Display d = com.codename1.ui.Display.getInstance();
+        return !d.isDesktop() || "HTML5".equals(d.getPlatformName());
+    }
+
+    @Override
+    public void layoutContainer(Container target) {
+        Insets in = target.getInsets();
+        int avail = target.getWidth() - (in.left + in.right + hgap * 2);
+        int n = target.getComponentCount();
+        int used = 0;
+        int y = in.top + vgap;
+        int rowHeight = 0;
+        int rowStart = 0;
+        int rows = 0;
+        for (int i = 0; i < n; i++) {
+            Component c = target.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            Dimension d = c.getPreferredSize();
+            c.setSize(d.width, d.height);
+            // The gap before the component is not part of the test, exactly as
+            // in the JDK's FlowLayout: a component that fits without it stays
+            // on the row and the gap is added after. Including it would wrap
+            // components that Swing keeps, and move every layout written
+            // against Swing by a row.
+            if (used == 0 || used + d.width <= avail) {
+                if (used > 0) {
+                    used += hgap;
+                }
+                used += d.width;
+                if (d.height > rowHeight) {
+                    rowHeight = d.height;
+                }
+            } else {
+                placeRow(target, in.left + hgap, y, avail - used, rowHeight, rowStart, i);
+                rows++;
+                y += vgap + rowHeight;
+                used = d.width;
+                rowHeight = d.height;
+                rowStart = i;
+            }
+        }
+        placeRow(target, in.left + hgap, y, avail - used, rowHeight, rowStart, n);
+        if (used > 0) {
+            rows++;
+        }
+        // The height this container was given is the one answered for the
+        // rows counted at the width it had then. In another number of rows
+        // it wants another height, and whatever placed it is asked again:
+        // once for a width, so that a container that cannot be given the
+        // height is not laid out for ever.
+        int width = target.getWidth();
+        if (rows != answeredRows && answeredRows > 0 && width != askedAt && followsItsWidth(target)) {
+            askedAt = width;
+            com.codename1.desktopcompat.rt.PeerSupport.layoutAgain(target);
+        } else if (rows == answeredRows) {
+            askedAt = -1;
+        }
+    }
+
+    private void placeRow(Container target, int x, int y, int spare, int rowHeight, int from, int to) {
+        switch (align) {
+            case CENTER:
+                x += spare / 2;
+                break;
+            case RIGHT:
+            case TRAILING:
+                x += spare;
+                break;
+            default:
+                break;
+        }
+        for (int i = from; i < to; i++) {
+            Component c = target.getComponent(i);
+            if (c.isVisible()) {
+                c.setLocation(x, y + (rowHeight - c.getHeight()) / 2);
+                x += c.getWidth() + hgap;
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        String a;
+        switch (align) {
+            case LEFT:
+                a = ",align=left";
+                break;
+            case CENTER:
+                a = ",align=center";
+                break;
+            case RIGHT:
+                a = ",align=right";
+                break;
+            case LEADING:
+                a = ",align=leading";
+                break;
+            case TRAILING:
+                a = ",align=trailing";
+                break;
+            default:
+                a = "";
+                break;
+        }
+        return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + a + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FocusTraversalPolicy.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FocusTraversalPolicy.java
new file mode 100644
index 00000000000..b3f5d5af366
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FocusTraversalPolicy.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The order in which the components of a container take the focus.
+public abstract class FocusTraversalPolicy {
+
+    public FocusTraversalPolicy() {
+    }
+
+    public abstract Component getComponentAfter(Container aContainer, Component aComponent);
+
+    public abstract Component getComponentBefore(Container aContainer, Component aComponent);
+
+    public abstract Component getFirstComponent(Container aContainer);
+
+    public abstract Component getLastComponent(Container aContainer);
+
+    public abstract Component getDefaultComponent(Container aContainer);
+
+    public Component getInitialComponent(Window window) {
+        if (window == null) {
+            throw new IllegalArgumentException("window cannot be equal to null.");
+        }
+        return getDefaultComponent(window);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Font.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Font.java
new file mode 100644
index 00000000000..a8806a9b328
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Font.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.FileInputStream;
+import java.io.File;
+
+/// A typeface, a style and a size in logical pixels.
+///
+/// The family is a request, not a file: a font is drawn with the
+/// platform's own typeface in the asked weight and slant, so a 12 pixel
+/// bold "Arial" is the device's 12 pixel bold font. Sizes follow the
+/// desktop convention of one point per pixel.
+///
+/// The exception is a font the application carries. [#createFont] makes
+/// a font of a TrueType or OpenType file that is among the application's
+/// resources, and that font -- and every font derived from it -- is drawn
+/// with the file's own glyphs, which is what an icon font needs. Once it
+/// is registered with `GraphicsEnvironment.registerFont`, a `new Font`
+/// that names its family is drawn with it too. The file has to be a
+/// resource of the application: a font is opened by the platform under
+/// the name the build shipped it as, so bytes from anywhere else make a
+/// font with the right names that is drawn with the platform's typeface.
+public class Font {
+
+    public static final String DIALOG = "Dialog";
+    public static final String DIALOG_INPUT = "DialogInput";
+    public static final String SANS_SERIF = "SansSerif";
+    public static final String SERIF = "Serif";
+    public static final String MONOSPACED = "Monospaced";
+    public static final int PLAIN = 0;
+    public static final int BOLD = 1;
+    public static final int ITALIC = 2;
+    public static final int ROMAN_BASELINE = 0;
+    public static final int CENTER_BASELINE = 1;
+    public static final int HANGING_BASELINE = 2;
+    public static final int TRUETYPE_FONT = 0;
+    public static final int TYPE1_FONT = 1;
+
+    protected String name;
+    protected int style;
+    protected int size;
+    protected float pointSize;
+    /// The file this font was created from, when it was.
+    private com.codename1.desktopcompat.rt.FontFiles.Face face;
+
+    public Font(String name, int style, int size) {
+        this.name = name != null ? name : "Default";
+        this.style = (style & ~0x03) == 0 ? style : 0;
+        this.size = size;
+        this.pointSize = size;
+    }
+
+    protected Font(Font font) {
+        this.name = font.name;
+        this.style = font.style;
+        this.size = font.size;
+        this.pointSize = font.pointSize;
+        this.face = font.face;
+    }
+
+    private Font(String name, int style, float sizePts, com.codename1.desktopcompat.rt.FontFiles.Face face) {
+        this.name = name;
+        this.style = (style & ~0x03) == 0 ? style : 0;
+        this.size = (int) (sizePts + 0.5);
+        this.pointSize = sizePts;
+        this.face = face;
+    }
+
+    /// Makes a font of the bytes of a TrueType or OpenType file: plain,
+    /// one point high, to be given a size with [#deriveFont(float)]. The
+    /// stream is read to its end and left open.
+    ///
+    /// #### Throws
+    ///
+    /// - `FontFormatException`: the bytes are no such file, or the format
+    ///   asked for is Type 1, which no platform here reads.
+    public static Font createFont(int fontFormat, InputStream fontStream) throws FontFormatException, IOException {
+        if (fontFormat != TRUETYPE_FONT && fontFormat != TYPE1_FONT) {
+            throw new IllegalArgumentException("font format not recognized");
+        }
+        if (fontFormat == TYPE1_FONT) {
+            throw new FontFormatException("Type 1 fonts are not supported");
+        }
+        com.codename1.desktopcompat.rt.FontFiles.Face made = com.codename1.desktopcompat.rt.FontFiles.fromBytes(
+                com.codename1.desktopcompat.rt.FontFiles.readAll(fontStream));
+        if (made == null) {
+            throw new FontFormatException("Unsupported sfnt");
+        }
+        return new Font(made.fullName(), PLAIN, 1f, made);
+    }
+
+    /// As [#createFont(int, InputStream)], of a file.
+    public static Font createFont(int fontFormat, File fontFile) throws FontFormatException, IOException {
+        InputStream in = new FileInputStream(fontFile);
+        try {
+            return createFont(fontFormat, in);
+        } finally {
+            in.close();
+        }
+    }
+
+    /// The font file this font is drawn with: the one it was created
+    /// from, or the registered one its name finds. `null` for a font of
+    /// the platform.
+    public com.codename1.desktopcompat.rt.FontFiles.Face cn1Face() {
+        return face != null ? face : com.codename1.desktopcompat.rt.FontFiles.registered(name);
+    }
+
+    public String getFamily() {
+        return face != null ? face.family() : name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getFontName() {
+        return name;
+    }
+
+    public int getStyle() {
+        return style;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public float getSize2D() {
+        return pointSize;
+    }
+
+    public boolean isPlain() {
+        return style == 0;
+    }
+
+    public boolean isBold() {
+        return (style & BOLD) != 0;
+    }
+
+    public boolean isItalic() {
+        return (style & ITALIC) != 0;
+    }
+
+    public Font deriveFont(int style, float size) {
+        return new Font(name, style, size, face);
+    }
+
+    public Font deriveFont(float size) {
+        return new Font(name, style, size, face);
+    }
+
+    public Font deriveFont(int style) {
+        return new Font(name, style, pointSize, face);
+    }
+
+    /// Whether the platform font can draw the character; the layer cannot
+    /// ask, so it answers true.
+    public boolean canDisplay(char c) {
+        return true;
+    }
+
+    /// Parses `family-style-size`, `family style size` and their shorter
+    /// forms; a missing style is plain and a missing size is 12.
+    public static Font decode(String str) {
+        if (str == null) {
+            return new Font(DIALOG, PLAIN, 12);
+        }
+        String s = str.trim().replace('-', ' ');
+        String fontName = s;
+        int fontStyle = PLAIN;
+        int fontSize = 12;
+        int last = s.lastIndexOf(' ');
+        if (last > 0) {
+            String tail = s.substring(last + 1);
+            try {
+                fontSize = Integer.parseInt(tail);
+                s = s.substring(0, last).trim();
+                fontName = s;
+                last = s.lastIndexOf(' ');
+            } catch (NumberFormatException e) {
+                fontSize = 12;
+            }
+        }
+        if (last > 0) {
+            String tail = s.substring(last + 1);
+            int parsed = -1;
+            if (tail.equalsIgnoreCase("bold")) {
+                parsed = BOLD;
+            } else if (tail.equalsIgnoreCase("italic")) {
+                parsed = ITALIC;
+            } else if (tail.equalsIgnoreCase("bolditalic")) {
+                parsed = BOLD | ITALIC;
+            } else if (tail.equalsIgnoreCase("plain")) {
+                parsed = PLAIN;
+            }
+            if (parsed >= 0) {
+                fontStyle = parsed;
+                fontName = s.substring(0, last).trim();
+            }
+        }
+        return new Font(fontName.length() == 0 ? DIALOG : fontName, fontStyle, fontSize);
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode() ^ style ^ Float.floatToIntBits(pointSize) ^ (face == null ? 0 : face.hashCode());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof Font)) {
+            return false;
+        }
+        Font font = (Font) obj;
+        return size == font.size && style == font.style
+                && Float.floatToIntBits(pointSize) == Float.floatToIntBits(font.pointSize) && name.equals(font.name)
+                && face == font.face;
+    }
+
+    @Override
+    public String toString() {
+        String strStyle = isBold() ? (isItalic() ? "bolditalic" : "bold") : (isItalic() ? "italic" : "plain");
+        return "java.awt.Font[family=" + getFamily() + ",name=" + name + ",style=" + strStyle + ",size=" + size + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FontFormatException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FontFormatException.java
new file mode 100644
index 00000000000..927152a7a47
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FontFormatException.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Thrown by `Font.createFont` for bytes that are not a font.
+public class FontFormatException extends Exception {
+
+    public FontFormatException(String reason) {
+        super(reason);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FontMetrics.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FontMetrics.java
new file mode 100644
index 00000000000..4de5a194e56
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/FontMetrics.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+
+/// The measurements of a font, in logical pixels.
+///
+/// This base class estimates from the font size alone; the metrics a
+/// component or a graphics hands out measure the platform font.
+public abstract class FontMetrics {
+
+    protected Font font;
+
+    protected FontMetrics(Font font) {
+        this.font = font;
+    }
+
+    public Font getFont() {
+        return font;
+    }
+
+    public int getLeading() {
+        return 0;
+    }
+
+    public int getAscent() {
+        return font.getSize();
+    }
+
+    public int getDescent() {
+        return 0;
+    }
+
+    public int getHeight() {
+        return getLeading() + getAscent() + getDescent();
+    }
+
+    public int getMaxAscent() {
+        return getAscent();
+    }
+
+    public int getMaxDescent() {
+        return getDescent();
+    }
+
+    public int getMaxAdvance() {
+        return -1;
+    }
+
+    public int charWidth(int codePoint) {
+        return charWidth((char) codePoint);
+    }
+
+    public int charWidth(char ch) {
+        return stringWidth(String.valueOf(ch));
+    }
+
+    public int stringWidth(String str) {
+        return Math.round(str.length() * font.getSize2D() * 0.6f);
+    }
+
+    public int charsWidth(char[] data, int off, int len) {
+        return stringWidth(new String(data, off, len));
+    }
+
+    public int[] getWidths() {
+        int[] widths = new int[256];
+        for (char ch = 0; ch < 256; ch++) {
+            widths[ch] = charWidth(ch);
+        }
+        return widths;
+    }
+
+    public boolean hasUniformLineMetrics() {
+        return true;
+    }
+
+    public Rectangle2D getStringBounds(String str, Graphics context) {
+        return new Rectangle2D.Float(0, -getAscent(), stringWidth(str), getHeight());
+    }
+
+    public Rectangle2D getStringBounds(String str, int beginIndex, int limit, Graphics context) {
+        return getStringBounds(str.substring(beginIndex, limit), context);
+    }
+
+    @Override
+    public String toString() {
+        return "FontMetrics[font=" + getFont() + "ascent=" + getAscent() + ", descent=" + getDescent()
+                + ", height=" + getHeight() + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Frame.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Frame.java
new file mode 100644
index 00000000000..9e3b8b5475b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Frame.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import java.util.ArrayList;
+
+/// A window with a title.
+///
+/// The title shows in the title area of the form, or the title bar of
+/// the window where there is a window manager. Resizability, decoration
+/// and the extended state -- iconified, maximized -- apply to a window of
+/// the window manager and are only recorded for a frame that fills a
+/// form, which is always the size of the screen.
+public class Frame extends Window {
+
+    public static final int NORMAL = 0;
+    public static final int ICONIFIED = 1;
+    public static final int MAXIMIZED_HORIZ = 2;
+    public static final int MAXIMIZED_VERT = 4;
+    public static final int MAXIMIZED_BOTH = 6;
+
+    private String title;
+    private boolean resizable = true;
+    private boolean undecorated;
+    private int state;
+
+    public Frame() {
+        this("");
+    }
+
+    public Frame(String title) {
+        super((Window) null);
+        this.title = title == null ? "" : title;
+    }
+
+    /// The frames that were shown or packed and not disposed of since.
+    public static Frame[] getFrames() {
+        Window[] all = Window.getWindows();
+        ArrayList<Frame> l = new ArrayList<Frame>();
+        for (int i = 0; i < all.length; i++) {
+            if (all[i] instanceof Frame) {
+                l.add((Frame) all[i]);
+            }
+        }
+        return l.toArray(new Frame[l.size()]);
+    }
+
+    @Override
+    public String cn1Title() {
+        return title;
+    }
+
+    @Override
+    protected boolean cn1Resizable() {
+        return resizable;
+    }
+
+    @Override
+    protected boolean cn1Decorated() {
+        return !undecorated;
+    }
+
+    @Override
+    protected int cn1State() {
+        return state;
+    }
+
+    @Override
+    public void cn1Iconified(boolean iconified) {
+        int old = state;
+        state = iconified ? state | ICONIFIED : state & ~ICONIFIED;
+        super.cn1Iconified(iconified);
+        if (old != state) {
+            dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_STATE_CHANGED, old, state));
+        }
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        String old = this.title;
+        this.title = title == null ? "" : title;
+        if (cn1Host() != null) {
+            cn1Host().title(this.title);
+        }
+        firePropertyChange("title", old, this.title);
+    }
+
+    public Image getIconImage() {
+        java.util.List<Image> l = getIconImages();
+        return l.isEmpty() ? null : l.get(0);
+    }
+
+    public boolean isResizable() {
+        return resizable;
+    }
+
+    public void setResizable(boolean resizable) {
+        boolean old = this.resizable;
+        this.resizable = resizable;
+        if (cn1Host() != null) {
+            cn1Host().resizable(resizable);
+        }
+        firePropertyChange("resizable", old, resizable);
+    }
+
+    public boolean isUndecorated() {
+        return undecorated;
+    }
+
+    /// Takes effect the next time the frame is shown.
+    public void setUndecorated(boolean undecorated) {
+        this.undecorated = undecorated;
+    }
+
+    public int getExtendedState() {
+        return state;
+    }
+
+    /// Minimizes, maximizes or restores a window of the window manager,
+    /// and tells the window state listeners. A frame that fills a form
+    /// records the state and stays as it is.
+    public void setExtendedState(int state) {
+        int old = this.state;
+        if (old == state) {
+            return;
+        }
+        this.state = state;
+        if (cn1Host() != null) {
+            cn1Host().state(state);
+        }
+        dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_STATE_CHANGED, old, state));
+    }
+
+    public int getState() {
+        return (state & ICONIFIED) != 0 ? ICONIFIED : NORMAL;
+    }
+
+    public void setState(int state) {
+        setExtendedState(state == ICONIFIED ? this.state | ICONIFIED : this.state & ~ICONIFIED);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GradientPaint.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GradientPaint.java
new file mode 100644
index 00000000000..68526aa34c5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GradientPaint.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+
+/// A linear gradient between two colors anchored at two points in user
+/// space; beyond the points it holds the end colors, or repeats back and
+/// forth when cyclic.
+public class GradientPaint implements Paint {
+
+    private final float x1;
+    private final float y1;
+    private final float x2;
+    private final float y2;
+    private final Color color1;
+    private final Color color2;
+    private final boolean cyclic;
+
+    public GradientPaint(float x1, float y1, Color color1, float x2, float y2, Color color2) {
+        this(x1, y1, color1, x2, y2, color2, false);
+    }
+
+    public GradientPaint(Point2D pt1, Color color1, Point2D pt2, Color color2) {
+        this((float) pt1.getX(), (float) pt1.getY(), color1, (float) pt2.getX(), (float) pt2.getY(), color2, false);
+    }
+
+    public GradientPaint(float x1, float y1, Color color1, float x2, float y2, Color color2, boolean cyclic) {
+        if (color1 == null || color2 == null) {
+            throw new NullPointerException("Colors cannot be null");
+        }
+        this.x1 = x1;
+        this.y1 = y1;
+        this.x2 = x2;
+        this.y2 = y2;
+        this.color1 = color1;
+        this.color2 = color2;
+        this.cyclic = cyclic;
+    }
+
+    public GradientPaint(Point2D pt1, Color color1, Point2D pt2, Color color2, boolean cyclic) {
+        this((float) pt1.getX(), (float) pt1.getY(), color1, (float) pt2.getX(), (float) pt2.getY(), color2, cyclic);
+    }
+
+    public Point2D getPoint1() {
+        return new Point2D.Float(x1, y1);
+    }
+
+    public Color getColor1() {
+        return color1;
+    }
+
+    public Point2D getPoint2() {
+        return new Point2D.Float(x2, y2);
+    }
+
+    public Color getColor2() {
+        return color2;
+    }
+
+    public boolean isCyclic() {
+        return cyclic;
+    }
+
+    @Override
+    public int getTransparency() {
+        return (color1.getAlpha() & color2.getAlpha()) == 0xff ? OPAQUE : TRANSLUCENT;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Graphics.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Graphics.java
new file mode 100644
index 00000000000..0b4fa50280c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Graphics.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+
+/// The drawing surface of a component or an image, in logical pixels.
+///
+/// Every graphics the layer hands out is a [Graphics2D]; see
+/// `com.codename1.desktopcompat.rt.G2D` for how it maps onto Codename One.
+public abstract class Graphics {
+
+    protected Graphics() {
+    }
+
+    public abstract Graphics create();
+
+    public Graphics create(int x, int y, int width, int height) {
+        Graphics g = create();
+        if (g == null) {
+            return null;
+        }
+        g.translate(x, y);
+        g.clipRect(0, 0, width, height);
+        return g;
+    }
+
+    public abstract void translate(int x, int y);
+
+    public abstract Color getColor();
+
+    public abstract void setColor(Color c);
+
+    public abstract void setPaintMode();
+
+    public abstract void setXORMode(Color c1);
+
+    public abstract Font getFont();
+
+    public abstract void setFont(Font font);
+
+    public FontMetrics getFontMetrics() {
+        return getFontMetrics(getFont());
+    }
+
+    public abstract FontMetrics getFontMetrics(Font f);
+
+    public abstract Rectangle getClipBounds();
+
+    public abstract void clipRect(int x, int y, int width, int height);
+
+    public abstract void setClip(int x, int y, int width, int height);
+
+    public abstract Shape getClip();
+
+    public abstract void setClip(Shape clip);
+
+    public abstract void copyArea(int x, int y, int width, int height, int dx, int dy);
+
+    public abstract void drawLine(int x1, int y1, int x2, int y2);
+
+    public abstract void fillRect(int x, int y, int width, int height);
+
+    public void drawRect(int x, int y, int width, int height) {
+        if (width < 0 || height < 0) {
+            return;
+        }
+        if (height == 0 || width == 0) {
+            drawLine(x, y, x + width, y + height);
+        } else {
+            drawLine(x, y, x + width - 1, y);
+            drawLine(x + width, y, x + width, y + height - 1);
+            drawLine(x + width, y + height, x + 1, y + height);
+            drawLine(x, y + height, x, y + 1);
+        }
+    }
+
+    public abstract void clearRect(int x, int y, int width, int height);
+
+    public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight);
+
+    public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight);
+
+    public void draw3DRect(int x, int y, int width, int height, boolean raised) {
+        Color c = getColor();
+        Color brighter = c.brighter();
+        Color darker = c.darker();
+        setColor(raised ? brighter : darker);
+        drawLine(x, y, x, y + height);
+        drawLine(x + 1, y, x + width - 1, y);
+        setColor(raised ? darker : brighter);
+        drawLine(x + 1, y + height, x + width, y + height);
+        drawLine(x + width, y, x + width, y + height - 1);
+        setColor(c);
+    }
+
+    public void fill3DRect(int x, int y, int width, int height, boolean raised) {
+        Color c = getColor();
+        Color brighter = c.brighter();
+        Color darker = c.darker();
+        if (!raised) {
+            setColor(darker);
+        }
+        fillRect(x + 1, y + 1, width - 2, height - 2);
+        setColor(raised ? brighter : darker);
+        drawLine(x, y, x, y + height - 1);
+        drawLine(x + 1, y, x + width - 2, y);
+        setColor(raised ? darker : brighter);
+        drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1);
+        drawLine(x + width - 1, y, x + width - 1, y + height - 2);
+        setColor(c);
+    }
+
+    public abstract void drawOval(int x, int y, int width, int height);
+
+    public abstract void fillOval(int x, int y, int width, int height);
+
+    public abstract void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle);
+
+    public abstract void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle);
+
+    public abstract void drawPolyline(int[] xPoints, int[] yPoints, int nPoints);
+
+    public abstract void drawPolygon(int[] xPoints, int[] yPoints, int nPoints);
+
+    public void drawPolygon(Polygon p) {
+        drawPolygon(p.xpoints, p.ypoints, p.npoints);
+    }
+
+    public abstract void fillPolygon(int[] xPoints, int[] yPoints, int nPoints);
+
+    public void fillPolygon(Polygon p) {
+        fillPolygon(p.xpoints, p.ypoints, p.npoints);
+    }
+
+    public abstract void drawString(String str, int x, int y);
+
+    public void drawChars(char[] data, int offset, int length, int x, int y) {
+        drawString(new String(data, offset, length), x, y);
+    }
+
+    public abstract boolean drawImage(Image img, int x, int y, ImageObserver observer);
+
+    public abstract boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer);
+
+    public abstract boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer);
+
+    public abstract boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor,
+                                      ImageObserver observer);
+
+    public abstract boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2,
+                                      int sy2, ImageObserver observer);
+
+    public abstract boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2,
+                                      int sy2, Color bgcolor, ImageObserver observer);
+
+    public abstract void dispose();
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[font=" + getFont() + ",color=" + getColor() + "]";
+    }
+
+    public boolean hitClip(int x, int y, int width, int height) {
+        Rectangle clipRect = getClipBounds();
+        if (clipRect == null) {
+            return true;
+        }
+        return clipRect.intersects(x, y, width, height);
+    }
+
+    public Rectangle getClipBounds(Rectangle r) {
+        Rectangle clipRect = getClipBounds();
+        if (clipRect != null) {
+            r.x = clipRect.x;
+            r.y = clipRect.y;
+            r.width = clipRect.width;
+            r.height = clipRect.height;
+        } else if (r == null) {
+            throw new NullPointerException("null rectangle parameter");
+        }
+        return r;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Graphics2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Graphics2D.java
new file mode 100644
index 00000000000..c14343fb076
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Graphics2D.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.java.awt.image.BufferedImageOp;
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+
+import java.util.Map;
+
+/// A graphics with shapes, strokes, paints and an affine transform.
+public abstract class Graphics2D extends Graphics {
+
+    protected Graphics2D() {
+    }
+
+    @Override
+    public void draw3DRect(int x, int y, int width, int height, boolean raised) {
+        Paint p = getPaint();
+        Color c = getColor();
+        Color brighter = c.brighter();
+        Color darker = c.darker();
+        setColor(raised ? brighter : darker);
+        fillRect(x, y, 1, height + 1);
+        fillRect(x + 1, y, width - 1, 1);
+        setColor(raised ? darker : brighter);
+        fillRect(x + 1, y + height, width, 1);
+        fillRect(x + width, y, 1, height);
+        setPaint(p);
+    }
+
+    @Override
+    public void fill3DRect(int x, int y, int width, int height, boolean raised) {
+        Paint p = getPaint();
+        Color c = getColor();
+        Color brighter = c.brighter();
+        Color darker = c.darker();
+        if (!raised) {
+            setColor(darker);
+        } else if (p != c) {
+            setColor(c);
+        }
+        fillRect(x + 1, y + 1, width - 2, height - 2);
+        setColor(raised ? brighter : darker);
+        fillRect(x, y, 1, height);
+        fillRect(x + 1, y, width - 2, 1);
+        setColor(raised ? darker : brighter);
+        fillRect(x + 1, y + height - 1, width - 1, 1);
+        fillRect(x + width - 1, y, 1, height - 1);
+        setPaint(p);
+    }
+
+    public abstract void draw(Shape s);
+
+    public abstract boolean drawImage(Image img, AffineTransform xform, ImageObserver obs);
+
+    /// Draws what `op` makes of the image, or the image itself when `op`
+    /// is `null`.
+    public void drawImage(BufferedImage img, BufferedImageOp op, int x, int y) {
+        BufferedImage shown = op == null ? img : op.filter(img, null);
+        if (shown != null) {
+            drawImage(shown, x, y, null);
+        }
+    }
+
+    @Override
+    public abstract void drawString(String str, int x, int y);
+
+    public abstract void drawString(String str, float x, float y);
+
+    public abstract void fill(Shape s);
+
+    public abstract void setComposite(Composite comp);
+
+    public abstract void setPaint(Paint paint);
+
+    public abstract void setStroke(Stroke s);
+
+    public abstract void setRenderingHint(RenderingHints.Key hintKey, Object hintValue);
+
+    public abstract Object getRenderingHint(RenderingHints.Key hintKey);
+
+    public abstract void setRenderingHints(Map<?, ?> hints);
+
+    public abstract void addRenderingHints(Map<?, ?> hints);
+
+    public abstract RenderingHints getRenderingHints();
+
+    @Override
+    public abstract void translate(int x, int y);
+
+    public abstract void translate(double tx, double ty);
+
+    public abstract void rotate(double theta);
+
+    public abstract void rotate(double theta, double x, double y);
+
+    public abstract void scale(double sx, double sy);
+
+    public abstract void shear(double shx, double shy);
+
+    public abstract void transform(AffineTransform Tx);
+
+    public abstract void setTransform(AffineTransform Tx);
+
+    public abstract AffineTransform getTransform();
+
+    public abstract Paint getPaint();
+
+    public abstract Composite getComposite();
+
+    public abstract void setBackground(Color color);
+
+    public abstract Color getBackground();
+
+    public abstract Stroke getStroke();
+
+    public abstract void clip(Shape s);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsConfiguration.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsConfiguration.java
new file mode 100644
index 00000000000..0eb34d13e8b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsConfiguration.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+
+/// The characteristics of a screen: its bounds in logical pixels.
+public abstract class GraphicsConfiguration {
+
+    protected GraphicsConfiguration() {
+    }
+
+    public abstract GraphicsDevice getDevice();
+
+    public abstract Rectangle getBounds();
+
+    public abstract AffineTransform getDefaultTransform();
+
+    public abstract AffineTransform getNormalizingTransform();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsDevice.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsDevice.java
new file mode 100644
index 00000000000..55c0f136285
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsDevice.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// A screen. Full screen mode is not offered: a window that fills a form
+/// already has the whole display.
+public abstract class GraphicsDevice {
+
+    public static final int TYPE_RASTER_SCREEN = 0;
+    public static final int TYPE_PRINTER = 1;
+    public static final int TYPE_IMAGE_BUFFER = 2;
+
+    private Window fullScreen;
+
+    protected GraphicsDevice() {
+    }
+
+    public abstract int getType();
+
+    public abstract String getIDstring();
+
+    public abstract GraphicsConfiguration[] getConfigurations();
+
+    public abstract GraphicsConfiguration getDefaultConfiguration();
+
+    public boolean isFullScreenSupported() {
+        return false;
+    }
+
+    /// Records the window and shows it; nothing else changes.
+    public void setFullScreenWindow(Window w) {
+        fullScreen = w;
+        if (w != null) {
+            w.setVisible(true);
+        }
+    }
+
+    public Window getFullScreenWindow() {
+        return fullScreen;
+    }
+
+    public boolean isDisplayChangeSupported() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsEnvironment.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsEnvironment.java
new file mode 100644
index 00000000000..1bb22ceb5dc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GraphicsEnvironment.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+
+/// The screens of the device: there is one, the display.
+public abstract class GraphicsEnvironment {
+
+    private static GraphicsEnvironment local;
+
+    protected GraphicsEnvironment() {
+    }
+
+    public static GraphicsEnvironment getLocalGraphicsEnvironment() {
+        if (local == null) {
+            local = new ScreenEnvironment();
+        }
+        return local;
+    }
+
+    /// Always `false`: there is a display, a pointer and, where the
+    /// device has one, a keyboard.
+    public static boolean isHeadless() {
+        return false;
+    }
+
+    public boolean isHeadlessInstance() {
+        return false;
+    }
+
+    public abstract GraphicsDevice[] getScreenDevices();
+
+    public abstract GraphicsDevice getDefaultScreenDevice();
+
+    /// The family names `Font` maps to Codename One fonts, and those of
+    /// the fonts that were registered.
+    public abstract String[] getAvailableFontFamilyNames();
+
+    /// A graphics that draws into `img`.
+    public abstract Graphics2D createGraphics(BufferedImage img);
+
+    /// Lets `new Font` find a font made by `Font.createFont` under its
+    /// family and its name. `false` for a font that was not created from
+    /// a file, and for one named as a font of the platform or as another
+    /// registered font is.
+    public boolean registerFont(Font font) {
+        com.codename1.desktopcompat.rt.FontFiles.Face face = font == null ? null : font.cn1Face();
+        if (face == null) {
+            return false;
+        }
+        String family = face.family();
+        if (family.equalsIgnoreCase(Font.DIALOG) || family.equalsIgnoreCase(Font.DIALOG_INPUT)
+                || family.equalsIgnoreCase(Font.MONOSPACED) || family.equalsIgnoreCase(Font.SANS_SERIF)
+                || family.equalsIgnoreCase(Font.SERIF)) {
+            return false;
+        }
+        return com.codename1.desktopcompat.rt.FontFiles.register(face);
+    }
+
+    /// The center of the display, in logical pixels.
+    public Point getCenterPoint() {
+        Rectangle r = getMaximumWindowBounds();
+        return new Point(r.x + r.width / 2, r.y + r.height / 2);
+    }
+
+    /// The whole display, in logical pixels.
+    public Rectangle getMaximumWindowBounds() {
+        return getDefaultScreenDevice().getDefaultConfiguration().getBounds();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridBagConstraints.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridBagConstraints.java
new file mode 100644
index 00000000000..3ecc04c1ab0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridBagConstraints.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The placement of one component in a [GridBagLayout]: its cell, how many
+/// cells it spans, how it shares spare space and how it sits inside its
+/// display area.
+public class GridBagConstraints implements Cloneable {
+
+    public static final int RELATIVE = -1;
+
+    public static final int REMAINDER = 0;
+
+    public static final int NONE = 0;
+
+    public static final int BOTH = 1;
+
+    public static final int HORIZONTAL = 2;
+
+    public static final int VERTICAL = 3;
+
+    public static final int CENTER = 10;
+
+    public static final int NORTH = 11;
+
+    public static final int NORTHEAST = 12;
+
+    public static final int EAST = 13;
+
+    public static final int SOUTHEAST = 14;
+
+    public static final int SOUTH = 15;
+
+    public static final int SOUTHWEST = 16;
+
+    public static final int WEST = 17;
+
+    public static final int NORTHWEST = 18;
+
+    public static final int PAGE_START = 19;
+
+    public static final int PAGE_END = 20;
+
+    public static final int LINE_START = 21;
+
+    public static final int LINE_END = 22;
+
+    public static final int FIRST_LINE_START = 23;
+
+    public static final int FIRST_LINE_END = 24;
+
+    public static final int LAST_LINE_START = 25;
+
+    public static final int LAST_LINE_END = 26;
+
+    public static final int BASELINE = 0x100;
+
+    public static final int BASELINE_LEADING = 0x200;
+
+    public static final int BASELINE_TRAILING = 0x300;
+
+    public static final int ABOVE_BASELINE = 0x400;
+
+    public static final int ABOVE_BASELINE_LEADING = 0x500;
+
+    public static final int ABOVE_BASELINE_TRAILING = 0x600;
+
+    public static final int BELOW_BASELINE = 0x700;
+
+    public static final int BELOW_BASELINE_LEADING = 0x800;
+
+    public static final int BELOW_BASELINE_TRAILING = 0x900;
+
+    public int gridx;
+
+    public int gridy;
+
+    public int gridwidth;
+
+    public int gridheight;
+
+    public double weightx;
+
+    public double weighty;
+
+    public int anchor;
+
+    public int fill;
+
+    public Insets insets;
+
+    public int ipadx;
+
+    public int ipady;
+
+    /// The resolved cell and span, written by the layout on each pass.
+    int tempX;
+    int tempY;
+    int tempWidth;
+    int tempHeight;
+    /// The component's own size as last measured by the layout.
+    int minWidth;
+    int minHeight;
+
+    // The baseline of the component at the size it was measured with,
+    // from the top of its display area, and what lies below it down to
+    // the bottom of the display area; -1 when it has no baseline or is
+    // not anchored to one.
+    int ascent = -1;
+
+    int descent;
+
+    public GridBagConstraints() {
+        gridx = RELATIVE;
+        gridy = RELATIVE;
+        gridwidth = 1;
+        gridheight = 1;
+        anchor = CENTER;
+        fill = NONE;
+        insets = new Insets(0, 0, 0, 0);
+    }
+
+    public GridBagConstraints(int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty,
+            int anchor, int fill, Insets insets, int ipadx, int ipady) {
+        this.gridx = gridx;
+        this.gridy = gridy;
+        this.gridwidth = gridwidth;
+        this.gridheight = gridheight;
+        this.weightx = weightx;
+        this.weighty = weighty;
+        this.anchor = anchor;
+        this.fill = fill;
+        this.insets = insets;
+        this.ipadx = ipadx;
+        this.ipady = ipady;
+    }
+
+    /// A copy of these constraints with its own `insets` object. Built field
+    /// by field, since `Object.clone()` is not available on a device.
+    @Override
+    public Object clone() {
+        Insets in = insets == null ? null : new Insets(insets.top, insets.left, insets.bottom, insets.right);
+        GridBagConstraints c = new GridBagConstraints(gridx, gridy, gridwidth, gridheight, weightx, weighty,
+                anchor, fill, in, ipadx, ipady);
+        c.tempX = tempX;
+        c.tempY = tempY;
+        c.tempWidth = tempWidth;
+        c.tempHeight = tempHeight;
+        c.minWidth = minWidth;
+        c.minHeight = minHeight;
+        return c;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridBagLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridBagLayout.java
new file mode 100644
index 00000000000..3fd5da1f959
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridBagLayout.java
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import java.util.Hashtable;
+
+/// Lays components out in a grid of rows and columns of differing sizes,
+/// each component described by a [GridBagConstraints].
+///
+/// Every container is laid out left to right, so the relative anchors
+/// resolve as they do in that orientation (`LINE_START` is the west edge).
+/// The baseline anchors line a row up on the baselines its components
+/// report through `getBaseline`; a component that reports none, or a row
+/// in which nothing does, is centred vertically. A component is asked for
+/// its baseline again at the size it ends up with, as one whose baseline
+/// follows no rule when it is resized.
+public class GridBagLayout implements LayoutManager2 {
+
+    protected static final int MAXGRIDSIZE = 512;
+
+    protected static final int MINSIZE = 1;
+
+    protected static final int PREFERREDSIZE = 2;
+
+    protected Hashtable<Component, GridBagConstraints> comptable;
+
+    protected GridBagConstraints defaultConstraints;
+
+    public int[] columnWidths;
+
+    public int[] rowHeights;
+
+    public double[] columnWeights;
+
+    public double[] rowWeights;
+
+    /// The grid computed by one measuring pass.
+    private static final class Grid {
+        int width;
+        int height;
+        int startx;
+        int starty;
+        int[] minWidth;
+        int[] minHeight;
+        double[] weightX;
+        double[] weightY;
+        // Whether any component is anchored to its baseline, and per row
+        // the furthest a baseline lies from the top, the most that hangs
+        // below one, and whether the row has a baseline at all.
+        boolean anchored;
+        int[] maxAscent;
+        int[] maxDescent;
+        boolean[] baselineRow;
+    }
+
+    private static boolean onBaseline(int anchor) {
+        return anchor == GridBagConstraints.BASELINE || anchor == GridBagConstraints.BASELINE_LEADING
+                || anchor == GridBagConstraints.BASELINE_TRAILING;
+    }
+
+    private static boolean aboveBaseline(int anchor) {
+        return anchor == GridBagConstraints.ABOVE_BASELINE || anchor == GridBagConstraints.ABOVE_BASELINE_LEADING
+                || anchor == GridBagConstraints.ABOVE_BASELINE_TRAILING;
+    }
+
+    private static boolean belowBaseline(int anchor) {
+        return anchor == GridBagConstraints.BELOW_BASELINE || anchor == GridBagConstraints.BELOW_BASELINE_LEADING
+                || anchor == GridBagConstraints.BELOW_BASELINE_TRAILING;
+    }
+
+    private Grid lastGrid;
+
+    public GridBagLayout() {
+        comptable = new Hashtable<Component, GridBagConstraints>();
+        defaultConstraints = new GridBagConstraints();
+    }
+
+    public void setConstraints(Component comp, GridBagConstraints constraints) {
+        Object copy = constraints.clone();
+        if (copy instanceof GridBagConstraints) {
+            comptable.put(comp, (GridBagConstraints) copy);
+        }
+    }
+
+    public GridBagConstraints getConstraints(Component comp) {
+        Object copy = lookupConstraints(comp).clone();
+        return copy instanceof GridBagConstraints ? (GridBagConstraints) copy : null;
+    }
+
+    protected GridBagConstraints lookupConstraints(Component comp) {
+        GridBagConstraints c = comptable.get(comp);
+        if (c == null) {
+            setConstraints(comp, defaultConstraints);
+            c = comptable.get(comp);
+        }
+        return c;
+    }
+
+    public Point getLayoutOrigin() {
+        Point origin = new Point(0, 0);
+        if (lastGrid != null) {
+            origin.x = lastGrid.startx;
+            origin.y = lastGrid.starty;
+        }
+        return origin;
+    }
+
+    public int[][] getLayoutDimensions() {
+        if (lastGrid == null) {
+            return new int[2][0];
+        }
+        int[][] dim = new int[2][];
+        dim[0] = new int[lastGrid.width];
+        dim[1] = new int[lastGrid.height];
+        System.arraycopy(lastGrid.minWidth, 0, dim[0], 0, lastGrid.width);
+        System.arraycopy(lastGrid.minHeight, 0, dim[1], 0, lastGrid.height);
+        return dim;
+    }
+
+    public double[][] getLayoutWeights() {
+        if (lastGrid == null) {
+            return new double[2][0];
+        }
+        double[][] weights = new double[2][];
+        weights[0] = new double[lastGrid.width];
+        weights[1] = new double[lastGrid.height];
+        System.arraycopy(lastGrid.weightX, 0, weights[0], 0, lastGrid.width);
+        System.arraycopy(lastGrid.weightY, 0, weights[1], 0, lastGrid.height);
+        return weights;
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+
+    @Override
+    public void addLayoutComponent(Component comp, Object constraints) {
+        if (constraints instanceof GridBagConstraints) {
+            setConstraints(comp, (GridBagConstraints) constraints);
+        } else if (constraints != null) {
+            throw new IllegalArgumentException("cannot add to layout: constraints must be a GridBagConstraint");
+        }
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+        comptable.remove(comp);
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        return total(parent, measure(parent, PREFERREDSIZE));
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        return total(parent, measure(parent, MINSIZE));
+    }
+
+    @Override
+    public Dimension maximumLayoutSize(Container target) {
+        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+    }
+
+    @Override
+    public float getLayoutAlignmentX(Container parent) {
+        return 0.5f;
+    }
+
+    @Override
+    public float getLayoutAlignmentY(Container parent) {
+        return 0.5f;
+    }
+
+    @Override
+    public void invalidateLayout(Container target) {
+    }
+
+    @Override
+    public void layoutContainer(Container parent) {
+        arrange(parent);
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName();
+    }
+
+    private static int[] room(int[] a, int size) {
+        if (a.length >= size) {
+            return a;
+        }
+        int[] grown = new int[Math.max(size, a.length * 2)];
+        System.arraycopy(a, 0, grown, 0, a.length);
+        return grown;
+    }
+
+    private static int highest(int[] a, int from, int to) {
+        int m = 0;
+        for (int i = from; i < to; i++) {
+            if (a[i] > m) {
+                m = a[i];
+            }
+        }
+        return m;
+    }
+
+    private static void mark(int[] a, int from, int to, int value) {
+        for (int i = from; i < to; i++) {
+            a[i] = value;
+        }
+    }
+
+    /// Works out the grid for the visible children of `parent`: which cells
+    /// each one occupies, and the size and weight of every column and row
+    /// before any spare space is shared out.
+    private Grid measure(Container parent, int sizeflag) {
+        Component[] comps = parent.getComponents();
+        Grid grid = new Grid();
+        int gridW = 0;
+        int gridH = 0;
+        int[] rowEnd = new int[16];
+        int[] colEnd = new int[16];
+        int curRow = -1;
+        int curCol = -1;
+
+        // First pass: the extent of the grid, every open-ended span counted
+        // as a single cell.
+        for (int n = 0; n < comps.length; n++) {
+            Component comp = comps[n];
+            if (!comp.isVisible()) {
+                continue;
+            }
+            GridBagConstraints gc = lookupConstraints(comp);
+            int cx = gc.gridx;
+            int cy = gc.gridy;
+            int cw = gc.gridwidth <= 0 ? 1 : gc.gridwidth;
+            int ch = gc.gridheight <= 0 ? 1 : gc.gridheight;
+            if (cx < 0 && cy < 0) {
+                if (curRow >= 0) {
+                    cy = curRow;
+                } else if (curCol >= 0) {
+                    cx = curCol;
+                } else {
+                    cy = 0;
+                }
+            }
+            if (cx < 0) {
+                rowEnd = room(rowEnd, cy + ch);
+                cx = highest(rowEnd, cy, cy + ch) - cx - 1;
+                if (cx < 0) {
+                    cx = 0;
+                }
+            } else if (cy < 0) {
+                colEnd = room(colEnd, cx + cw);
+                cy = highest(colEnd, cx, cx + cw) - cy - 1;
+                if (cy < 0) {
+                    cy = 0;
+                }
+            }
+            int px = cx + cw;
+            int py = cy + ch;
+            if (gridW < px) {
+                gridW = px;
+            }
+            if (gridH < py) {
+                gridH = py;
+            }
+            colEnd = room(colEnd, px);
+            rowEnd = room(rowEnd, py);
+            mark(colEnd, cx, px, py);
+            mark(rowEnd, cy, py, px);
+
+            Dimension d = sizeflag == PREFERREDSIZE ? comp.getPreferredSize() : comp.getMinimumSize();
+            gc.minWidth = d.width;
+            gc.minHeight = d.height;
+            gc.ascent = -1;
+            if (onBaseline(gc.anchor)) {
+                // The padding is part of the component when it is asked.
+                int h = d.height + gc.ipady;
+                gc.ascent = comp.getBaseline(d.width + gc.ipadx, h);
+                if (gc.ascent >= 0) {
+                    gc.descent = h - gc.ascent + gc.insets.bottom;
+                    gc.ascent += gc.insets.top;
+                }
+                grid.anchored = true;
+            }
+
+            if (gc.gridheight == 0 && gc.gridwidth == 0) {
+                curRow = -1;
+                curCol = -1;
+            }
+            if (gc.gridheight == 0 && curRow < 0) {
+                curCol = cx + cw;
+            } else if (gc.gridwidth == 0 && curCol < 0) {
+                curRow = cy + ch;
+            }
+        }
+        if (columnWidths != null && gridW < columnWidths.length) {
+            gridW = columnWidths.length;
+        }
+        if (rowHeights != null && gridH < rowHeights.length) {
+            gridH = rowHeights.length;
+        }
+        grid.width = gridW;
+        grid.height = gridH;
+        grid.minWidth = new int[gridW];
+        grid.minHeight = new int[gridH];
+        grid.weightX = new double[gridW];
+        grid.weightY = new double[gridH];
+        grid.maxAscent = new int[gridH];
+        grid.maxDescent = new int[gridH];
+        grid.baselineRow = new boolean[gridH];
+        if (columnWidths != null) {
+            System.arraycopy(columnWidths, 0, grid.minWidth, 0, columnWidths.length);
+        }
+        if (rowHeights != null) {
+            System.arraycopy(rowHeights, 0, grid.minHeight, 0, rowHeights.length);
+        }
+        if (columnWeights != null) {
+            System.arraycopy(columnWeights, 0, grid.weightX, 0, Math.min(gridW, columnWeights.length));
+        }
+        if (rowWeights != null) {
+            System.arraycopy(rowWeights, 0, grid.weightY, 0, Math.min(gridH, rowWeights.length));
+        }
+
+        // Second pass: the same walk with the grid's extent known, so the
+        // open-ended spans reach the last column or row.
+        int longest = 1;
+        curRow = -1;
+        curCol = -1;
+        rowEnd = new int[Math.max(gridH, 1)];
+        colEnd = new int[Math.max(gridW, 1)];
+        for (int n = 0; n < comps.length; n++) {
+            Component comp = comps[n];
+            if (!comp.isVisible()) {
+                continue;
+            }
+            GridBagConstraints gc = lookupConstraints(comp);
+            int cx = gc.gridx;
+            int cy = gc.gridy;
+            int cw = gc.gridwidth;
+            int ch = gc.gridheight;
+            if (cx < 0 && cy < 0) {
+                if (curRow >= 0) {
+                    cy = curRow;
+                } else if (curCol >= 0) {
+                    cx = curCol;
+                } else {
+                    cy = 0;
+                }
+            }
+            if (cx < 0) {
+                if (ch <= 0) {
+                    ch += gridH - cy;
+                    if (ch < 1) {
+                        ch = 1;
+                    }
+                }
+                rowEnd = room(rowEnd, cy + ch);
+                cx = highest(rowEnd, cy, cy + ch) - cx - 1;
+                if (cx < 0) {
+                    cx = 0;
+                }
+            } else if (cy < 0) {
+                if (cw <= 0) {
+                    cw += gridW - cx;
+                    if (cw < 1) {
+                        cw = 1;
+                    }
+                }
+                colEnd = room(colEnd, cx + cw);
+                cy = highest(colEnd, cx, cx + cw) - cy - 1;
+                if (cy < 0) {
+                    cy = 0;
+                }
+            }
+            if (cw <= 0) {
+                cw += gridW - cx;
+                if (cw < 1) {
+                    cw = 1;
+                }
+            }
+            if (ch <= 0) {
+                ch += gridH - cy;
+                if (ch < 1) {
+                    ch = 1;
+                }
+            }
+            int px = cx + cw;
+            int py = cy + ch;
+            colEnd = room(colEnd, px);
+            rowEnd = room(rowEnd, py);
+            mark(colEnd, cx, px, py);
+            mark(rowEnd, cy, py, px);
+            if (gc.gridheight == 0 && gc.gridwidth == 0) {
+                curRow = -1;
+                curCol = -1;
+            }
+            if (gc.gridheight == 0 && curRow < 0) {
+                curCol = cx + cw;
+            } else if (gc.gridwidth == 0 && curCol < 0) {
+                curRow = cy + ch;
+            }
+            gc.tempX = cx;
+            gc.tempY = cy;
+            gc.tempWidth = cw;
+            gc.tempHeight = ch;
+            // A relative position resolved in this pass can land past the
+            // extent the first pass counted. Such a cell gets a size and a
+            // place, but as in the JDK it is not part of the grid: it adds
+            // nothing to the layout's size and takes no spare space.
+            if (px > grid.minWidth.length || py > grid.minHeight.length) {
+                grow(grid, Math.max(px, grid.minWidth.length), Math.max(py, grid.minHeight.length));
+            }
+            if (grid.anchored) {
+                Insets in = gc.insets;
+                if (onBaseline(gc.anchor)) {
+                    if (gc.ascent >= 0) {
+                        grid.maxAscent[cy] = Math.max(grid.maxAscent[cy], gc.ascent);
+                        if (ch == 1) {
+                            grid.maxDescent[cy] = Math.max(grid.maxDescent[cy], gc.descent);
+                        }
+                        grid.baselineRow[cy] = true;
+                    }
+                } else if (aboveBaseline(gc.anchor)) {
+                    // Its bottom edge sits on the baseline.
+                    grid.maxAscent[cy] = Math.max(grid.maxAscent[cy], gc.minHeight + in.top + gc.ipady);
+                    grid.maxDescent[cy] = Math.max(grid.maxDescent[cy], in.bottom);
+                } else if (belowBaseline(gc.anchor)) {
+                    // Its top edge sits on the baseline.
+                    grid.maxDescent[cy] = Math.max(grid.maxDescent[cy], gc.minHeight + in.bottom + gc.ipady);
+                    grid.maxAscent[cy] = Math.max(grid.maxAscent[cy], in.top);
+                }
+            }
+            if (cw > longest) {
+                longest = cw;
+            }
+            if (ch > longest) {
+                longest = ch;
+            }
+        }
+
+        // Third pass: sizes and weights, components spanning fewer cells
+        // first so a wide one only adds what its cells still lack.
+        for (int span = 1; span <= longest; span++) {
+            for (int n = 0; n < comps.length; n++) {
+                Component comp = comps[n];
+                if (!comp.isVisible()) {
+                    continue;
+                }
+                GridBagConstraints gc = lookupConstraints(comp);
+                Insets in = gc.insets;
+                if (gc.tempWidth == span) {
+                    share(grid.minWidth, grid.weightX, gc.tempX, gc.tempX + span, gc.weightx,
+                            gc.minWidth + gc.ipadx + in.left + in.right);
+                }
+                if (gc.tempHeight == span) {
+                    int want = -1;
+                    if (grid.anchored) {
+                        if (onBaseline(gc.anchor)) {
+                            if (gc.ascent >= 0) {
+                                want = grid.maxAscent[gc.tempY]
+                                        + (span == 1 ? grid.maxDescent[gc.tempY] : gc.descent);
+                            }
+                        } else if (aboveBaseline(gc.anchor)) {
+                            want = in.top + gc.minHeight + gc.ipady + grid.maxDescent[gc.tempY];
+                        } else if (belowBaseline(gc.anchor)) {
+                            want = grid.maxAscent[gc.tempY] + gc.minHeight + in.bottom + gc.ipady;
+                        }
+                    }
+                    if (want == -1) {
+                        want = gc.minHeight + gc.ipady + in.top + in.bottom;
+                    }
+                    share(grid.minHeight, grid.weightY, gc.tempY, gc.tempY + span, gc.weighty, want);
+                }
+            }
+        }
+        return grid;
+    }
+
+    /// Makes room in the arrays for cells beyond the grid's extent, which
+    /// itself stays as it is.
+    private static void grow(Grid grid, int w, int h) {
+        int[] mw = new int[w];
+        int[] mh = new int[h];
+        double[] wx = new double[w];
+        double[] wy = new double[h];
+        int[] ma = new int[h];
+        int[] md = new int[h];
+        boolean[] br = new boolean[h];
+        System.arraycopy(grid.maxAscent, 0, ma, 0, grid.maxAscent.length);
+        System.arraycopy(grid.maxDescent, 0, md, 0, grid.maxDescent.length);
+        System.arraycopy(grid.baselineRow, 0, br, 0, grid.baselineRow.length);
+        grid.maxAscent = ma;
+        grid.maxDescent = md;
+        grid.baselineRow = br;
+        System.arraycopy(grid.minWidth, 0, mw, 0, grid.minWidth.length);
+        System.arraycopy(grid.minHeight, 0, mh, 0, grid.minHeight.length);
+        System.arraycopy(grid.weightX, 0, wx, 0, grid.weightX.length);
+        System.arraycopy(grid.weightY, 0, wy, 0, grid.weightY.length);
+        grid.minWidth = mw;
+        grid.minHeight = mh;
+        grid.weightX = wx;
+        grid.weightY = wy;
+    }
+
+    /// Raises the weights and sizes of the cells `from` to `to` until
+    /// together they carry `wantWeight` and `wantPixels`. What is missing
+    /// goes to the cells in proportion to their weight, the last cell
+    /// taking the rounding and, when none has weight, all of it.
+    private static void share(int[] size, double[] weights, int from, int to, double wantWeight, int wantPixels) {
+        double missing = wantWeight;
+        for (int k = from; k < to; k++) {
+            missing -= weights[k];
+        }
+        if (missing > 0.0) {
+            double weight = 0.0;
+            for (int k = from; k < to; k++) {
+                weight += weights[k];
+            }
+            for (int k = from; weight > 0.0 && k < to; k++) {
+                double wt = weights[k];
+                double dx = (wt * missing) / weight;
+                weights[k] += dx;
+                missing -= dx;
+                weight -= wt;
+            }
+            weights[to - 1] += missing;
+        }
+        int pixels = wantPixels;
+        for (int k = from; k < to; k++) {
+            pixels -= size[k];
+        }
+        if (pixels > 0) {
+            double weight = 0.0;
+            for (int k = from; k < to; k++) {
+                weight += weights[k];
+            }
+            for (int k = from; weight > 0.0 && k < to; k++) {
+                double wt = weights[k];
+                int dx = (int) ((wt * (double) pixels) / weight);
+                size[k] += dx;
+                pixels -= dx;
+                weight -= wt;
+            }
+            size[to - 1] += pixels;
+        }
+    }
+
+    private static Dimension total(Container parent, Grid grid) {
+        Insets in = parent.getInsets();
+        int w = 0;
+        for (int i = 0; i < grid.width; i++) {
+            w += grid.minWidth[i];
+        }
+        int h = 0;
+        for (int i = 0; i < grid.height; i++) {
+            h += grid.minHeight[i];
+        }
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    /// Shares `spare` pixels over the cells by weight and answers the width
+    /// the cells then add up to, given they added up to `used` before. A
+    /// cell squeezed below nothing is held at zero.
+    private static int stretch(int[] size, double[] weights, int count, int spare, int used) {
+        double weight = 0.0;
+        for (int i = 0; i < count; i++) {
+            weight += weights[i];
+        }
+        if (weight > 0.0) {
+            for (int i = 0; i < count; i++) {
+                int dx = (int) (((double) spare * weights[i]) / weight);
+                size[i] += dx;
+                used += dx;
+                if (size[i] < 0) {
+                    used -= size[i];
+                    size[i] = 0;
+                }
+            }
+        }
+        return used;
+    }
+
+    private void arrange(Container parent) {
+        Component[] comps = parent.getComponents();
+        if (comps.length == 0 && (columnWidths == null || columnWidths.length == 0)
+                && (rowHeights == null || rowHeights.length == 0)) {
+            return;
+        }
+        Insets pin = parent.getInsets();
+        int pw = parent.getWidth();
+        int ph = parent.getHeight();
+        Grid grid = measure(parent, PREFERREDSIZE);
+        Dimension d = total(parent, grid);
+        if (pw < d.width || ph < d.height) {
+            grid = measure(parent, MINSIZE);
+            d = total(parent, grid);
+        }
+        lastGrid = grid;
+
+        int spareW = pw - d.width;
+        if (spareW != 0) {
+            spareW = pw - stretch(grid.minWidth, grid.weightX, grid.width, spareW, d.width);
+        }
+        int spareH = ph - d.height;
+        if (spareH != 0) {
+            spareH = ph - stretch(grid.minHeight, grid.weightY, grid.height, spareH, d.height);
+        }
+        grid.startx = spareW / 2 + pin.left;
+        grid.starty = spareH / 2 + pin.top;
+
+        Rectangle r = new Rectangle();
+        for (int n = 0; n < comps.length; n++) {
+            Component comp = comps[n];
+            if (!comp.isVisible()) {
+                continue;
+            }
+            GridBagConstraints gc = lookupConstraints(comp);
+            r.x = grid.startx;
+            for (int i = 0; i < gc.tempX; i++) {
+                r.x += grid.minWidth[i];
+            }
+            r.y = grid.starty;
+            for (int i = 0; i < gc.tempY; i++) {
+                r.y += grid.minHeight[i];
+            }
+            r.width = 0;
+            for (int i = gc.tempX; i < gc.tempX + gc.tempWidth; i++) {
+                r.width += grid.minWidth[i];
+            }
+            r.height = 0;
+            for (int i = gc.tempY; i < gc.tempY + gc.tempHeight; i++) {
+                r.height += grid.minHeight[i];
+            }
+            settle(grid, comp, gc, r);
+            if (r.x < 0) {
+                r.width += r.x;
+                r.x = 0;
+            }
+            if (r.y < 0) {
+                r.height += r.y;
+                r.y = 0;
+            }
+            if (r.width <= 0 || r.height <= 0) {
+                comp.setBounds(0, 0, 0, 0);
+            } else if (comp.getX() != r.x || comp.getY() != r.y || comp.getWidth() != r.width
+                    || comp.getHeight() != r.height) {
+                comp.setBounds(r.x, r.y, r.width, r.height);
+            }
+        }
+    }
+
+    /// The baseline of a component at a size, from the top of its display
+    /// area, or -1. A cell squeezed to less than nothing leaves a size no
+    /// component can be asked about (the JDK's throw for it), so there the
+    /// baseline it was measured with stands in.
+    private static int baselineAt(Component comp, GridBagConstraints gc, int width, int height) {
+        if (width < 0 || height < 0) {
+            return gc.ascent;
+        }
+        int ascent = comp.getBaseline(width, height);
+        return ascent < 0 ? ascent : ascent + gc.insets.top;
+    }
+
+    /// Shrinks a display area to the component's bounds: insets off, then
+    /// the component's own size unless it fills, then the anchor.
+    private static void settle(Grid grid, Component comp, GridBagConstraints gc, Rectangle r) {
+        Insets in = gc.insets;
+        int cellY = r.y;
+        int cellHeight = r.height;
+        r.x += in.left;
+        r.width -= in.left + in.right;
+        r.y += in.top;
+        r.height -= in.top + in.bottom;
+
+        int freeX = 0;
+        int ownW = gc.minWidth + gc.ipadx;
+        if (gc.fill != GridBagConstraints.HORIZONTAL && gc.fill != GridBagConstraints.BOTH && r.width > ownW) {
+            freeX = r.width - ownW;
+            r.width = ownW;
+        }
+        int freeY = 0;
+        int ownH = gc.minHeight + gc.ipady;
+        if (gc.fill != GridBagConstraints.VERTICAL && gc.fill != GridBagConstraints.BOTH && r.height > ownH) {
+            freeY = r.height - ownH;
+            r.height = ownH;
+        }
+
+        // 0 = start, 1 = middle, 2 = end, on each axis; 3 to 5 are on,
+        // above and below the baseline of the row.
+        int h;
+        int v;
+        switch (gc.anchor) {
+            case GridBagConstraints.NORTH:
+            case GridBagConstraints.PAGE_START:
+                h = 1;
+                v = 0;
+                break;
+            case GridBagConstraints.NORTHEAST:
+            case GridBagConstraints.FIRST_LINE_END:
+                h = 2;
+                v = 0;
+                break;
+            case GridBagConstraints.EAST:
+            case GridBagConstraints.LINE_END:
+                h = 2;
+                v = 1;
+                break;
+            case GridBagConstraints.SOUTHEAST:
+            case GridBagConstraints.LAST_LINE_END:
+                h = 2;
+                v = 2;
+                break;
+            case GridBagConstraints.SOUTH:
+            case GridBagConstraints.PAGE_END:
+                h = 1;
+                v = 2;
+                break;
+            case GridBagConstraints.SOUTHWEST:
+            case GridBagConstraints.LAST_LINE_START:
+                h = 0;
+                v = 2;
+                break;
+            case GridBagConstraints.WEST:
+            case GridBagConstraints.LINE_START:
+                h = 0;
+                v = 1;
+                break;
+            case GridBagConstraints.NORTHWEST:
+            case GridBagConstraints.FIRST_LINE_START:
+                h = 0;
+                v = 0;
+                break;
+            case GridBagConstraints.CENTER:
+                h = 1;
+                v = 1;
+                break;
+            case GridBagConstraints.BASELINE:
+                h = 1;
+                v = 3;
+                break;
+            case GridBagConstraints.BASELINE_LEADING:
+                h = 0;
+                v = 3;
+                break;
+            case GridBagConstraints.BASELINE_TRAILING:
+                h = 2;
+                v = 3;
+                break;
+            case GridBagConstraints.ABOVE_BASELINE:
+                h = 1;
+                v = 4;
+                break;
+            case GridBagConstraints.ABOVE_BASELINE_LEADING:
+                h = 0;
+                v = 4;
+                break;
+            case GridBagConstraints.ABOVE_BASELINE_TRAILING:
+                h = 2;
+                v = 4;
+                break;
+            case GridBagConstraints.BELOW_BASELINE:
+                h = 1;
+                v = 5;
+                break;
+            case GridBagConstraints.BELOW_BASELINE_LEADING:
+                h = 0;
+                v = 5;
+                break;
+            case GridBagConstraints.BELOW_BASELINE_TRAILING:
+                h = 2;
+                v = 5;
+                break;
+            default:
+                throw new IllegalArgumentException("illegal anchor value");
+        }
+        if (h == 1) {
+            r.x += freeX / 2;
+        } else if (h == 2) {
+            r.x += freeX;
+        }
+        boolean tall = gc.fill == GridBagConstraints.VERTICAL || gc.fill == GridBagConstraints.BOTH;
+        boolean rowHasBaseline = grid.anchored && grid.baselineRow[gc.tempY];
+        if (v == 1) {
+            r.y += freeY / 2;
+        } else if (v == 2) {
+            r.y += freeY;
+        } else if (v == 3 && gc.ascent >= 0) {
+            // The baseline moves with the size in no known way, so the
+            // component is asked again at the size it is about to get.
+            int baseline = grid.maxAscent[gc.tempY];
+            boolean fits = false;
+            int ascent = baselineAt(comp, gc, r.width, r.height);
+            if (ascent >= 0 && ascent <= baseline) {
+                if (baseline + (r.height - ascent - in.top) <= cellHeight - in.bottom) {
+                    fits = true;
+                } else if (tall) {
+                    // It would hang out of the cell; try the height that
+                    // just reaches the bottom of it.
+                    int height = cellHeight - in.bottom - baseline + ascent;
+                    int ascent2 = baselineAt(comp, gc, r.width, height);
+                    if (ascent2 >= 0 && ascent2 <= ascent) {
+                        r.height = height;
+                        ascent = ascent2;
+                        fits = true;
+                    }
+                }
+            }
+            if (!fits) {
+                ascent = gc.ascent;
+                r.width = gc.minWidth;
+                r.height = gc.minHeight;
+            }
+            r.y = cellY + baseline - ascent + in.top;
+        } else if (v == 4 && rowHasBaseline) {
+            int bottom = cellY + grid.maxAscent[gc.tempY];
+            if (tall) {
+                r.y = cellY + in.top;
+                r.height = bottom - r.y;
+            } else {
+                r.height = gc.minHeight + gc.ipady;
+                r.y = bottom - r.height;
+            }
+        } else if (v == 5 && rowHasBaseline) {
+            r.y = cellY + grid.maxAscent[gc.tempY];
+            if (tall) {
+                r.height = cellY + cellHeight - r.y - in.bottom;
+            }
+        } else if (v >= 3 && !tall) {
+            // Anchored to a baseline that is not there.
+            r.y += Math.max(0, (cellHeight - in.top - in.bottom - gc.minHeight - gc.ipady) / 2);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridLayout.java
new file mode 100644
index 00000000000..1bdd188f9f0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/GridLayout.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Divides a container into a grid of equally sized cells, one component to
+/// a cell, filled row by row from the top left.
+public class GridLayout implements LayoutManager {
+
+    private int hgap;
+    private int vgap;
+    private int rows;
+    private int cols;
+
+    public GridLayout() {
+        this(1, 0, 0, 0);
+    }
+
+    public GridLayout(int rows, int cols) {
+        this(rows, cols, 0, 0);
+    }
+
+    public GridLayout(int rows, int cols, int hgap, int vgap) {
+        if (rows == 0 && cols == 0) {
+            throw new IllegalArgumentException("rows and cols cannot both be zero");
+        }
+        this.rows = rows;
+        this.cols = cols;
+        this.hgap = hgap;
+        this.vgap = vgap;
+    }
+
+    public int getRows() {
+        return rows;
+    }
+
+    public void setRows(int rows) {
+        if (rows == 0 && this.cols == 0) {
+            throw new IllegalArgumentException("rows and cols cannot both be zero");
+        }
+        this.rows = rows;
+    }
+
+    public int getColumns() {
+        return cols;
+    }
+
+    public void setColumns(int cols) {
+        if (cols == 0 && this.rows == 0) {
+            throw new IllegalArgumentException("rows and cols cannot both be zero");
+        }
+        this.cols = cols;
+    }
+
+    public int getHgap() {
+        return hgap;
+    }
+
+    public void setHgap(int hgap) {
+        this.hgap = hgap;
+    }
+
+    public int getVgap() {
+        return vgap;
+    }
+
+    public void setVgap(int vgap) {
+        this.vgap = vgap;
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        return measure(parent, true);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        return measure(parent, false);
+    }
+
+    private Dimension measure(Container parent, boolean preferred) {
+        Insets in = parent.getInsets();
+        int n = parent.getComponentCount();
+        int nrows = rows;
+        int ncols = cols;
+        if (nrows > 0) {
+            ncols = (n + nrows - 1) / nrows;
+        } else {
+            nrows = (n + ncols - 1) / ncols;
+        }
+        int w = 0;
+        int h = 0;
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            Dimension d = preferred ? c.getPreferredSize() : c.getMinimumSize();
+            if (w < d.width) {
+                w = d.width;
+            }
+            if (h < d.height) {
+                h = d.height;
+            }
+        }
+        return new Dimension(in.left + in.right + ncols * w + (ncols - 1) * hgap,
+                in.top + in.bottom + nrows * h + (nrows - 1) * vgap);
+    }
+
+    @Override
+    public void layoutContainer(Container parent) {
+        Insets in = parent.getInsets();
+        int n = parent.getComponentCount();
+        if (n == 0) {
+            return;
+        }
+        int nrows = rows;
+        int ncols = cols;
+        if (nrows > 0) {
+            ncols = (n + nrows - 1) / nrows;
+        } else {
+            nrows = (n + ncols - 1) / ncols;
+        }
+        int gapsW = (ncols - 1) * hgap;
+        int innerW = parent.getWidth() - (in.left + in.right);
+        int cellW = (innerW - gapsW) / ncols;
+        int spareW = (innerW - (cellW * ncols + gapsW)) / 2;
+        int gapsH = (nrows - 1) * vgap;
+        int innerH = parent.getHeight() - (in.top + in.bottom);
+        int cellH = (innerH - gapsH) / nrows;
+        int spareH = (innerH - (cellH * nrows + gapsH)) / 2;
+        for (int i = 0; i < n; i++) {
+            int r = i / ncols;
+            int c = i % ncols;
+            if (r >= nrows) {
+                break;
+            }
+            parent.getComponent(i).setBounds(in.left + spareW + c * (cellW + hgap),
+                    in.top + spareH + r * (cellH + vgap), cellW, cellH);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + ",rows=" + rows + ",cols=" + cols + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/HeadlessException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/HeadlessException.java
new file mode 100644
index 00000000000..633e14eebd1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/HeadlessException.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Thrown by code that needs a display where there is none. This layer
+/// never throws it: `GraphicsEnvironment.isHeadless()` is always `false`.
+public class HeadlessException extends UnsupportedOperationException {
+
+    public HeadlessException() {
+    }
+
+    public HeadlessException(String msg) {
+        super(msg);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Image.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Image.java
new file mode 100644
index 00000000000..d7568c8e968
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Image.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+import com.codename1.desktopcompat.rt.NativeImage;
+
+/// A picture that can be drawn. One image pixel is one logical pixel.
+///
+/// Every image of the layer is backed by a Codename One image, which
+/// [#cn1Image()] answers; that is what `Graphics.drawImage` draws.
+public abstract class Image {
+
+    public static final Object UndefinedProperty = new Object();
+    public static final int SCALE_DEFAULT = 1;
+    public static final int SCALE_FAST = 2;
+    public static final int SCALE_SMOOTH = 4;
+    public static final int SCALE_REPLICATE = 8;
+    public static final int SCALE_AREA_AVERAGING = 16;
+
+    public abstract int getWidth(ImageObserver observer);
+
+    public abstract int getHeight(ImageObserver observer);
+
+    public abstract Graphics getGraphics();
+
+    /// The Codename One image holding this image's pixels as they are now,
+    /// or null for an image that has none.
+    public com.codename1.ui.Image cn1Image() {
+        return null;
+    }
+
+    public Image getScaledInstance(int width, int height, int hints) {
+        com.codename1.ui.Image src = cn1Image();
+        if (src == null) {
+            return this;
+        }
+        int w = width;
+        int h = height;
+        if (w < 0 && h < 0) {
+            w = src.getWidth();
+            h = src.getHeight();
+        } else if (w < 0) {
+            w = Math.max(1, src.getWidth() * h / Math.max(1, src.getHeight()));
+        } else if (h < 0) {
+            h = Math.max(1, src.getHeight() * w / Math.max(1, src.getWidth()));
+        }
+        return new NativeImage(src.scaled(w, h));
+    }
+
+    public void flush() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Insets.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Insets.java
new file mode 100644
index 00000000000..a047d8e4da1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Insets.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The space a container leaves free along each of its four edges.
+public class Insets implements Cloneable {
+
+    public int top;
+
+    public int left;
+
+    public int bottom;
+
+    public int right;
+
+    public Insets(int top, int left, int bottom, int right) {
+        this.top = top;
+        this.left = left;
+        this.bottom = bottom;
+        this.right = right;
+    }
+
+    public void set(int top, int left, int bottom, int right) {
+        this.top = top;
+        this.left = left;
+        this.bottom = bottom;
+        this.right = right;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Insets) {
+            Insets i = (Insets) obj;
+            return top == i.top && left == i.left && bottom == i.bottom && right == i.right;
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return ((top * 31 + left) * 31 + bottom) * 31 + right;
+    }
+
+    @Override
+    public String toString() {
+        return "java.awt.Insets[top=" + top + ",left=" + left + ",bottom=" + bottom + ",right=" + right + "]";
+    }
+
+    @Override
+    public Object clone() {
+        return new Insets(top, left, bottom, right);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ItemSelectable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ItemSelectable.java
new file mode 100644
index 00000000000..9b99628403e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ItemSelectable.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+
+/// A component or model that has a set of selected items and reports changes
+/// of that selection to item listeners.
+public interface ItemSelectable {
+
+    Object[] getSelectedObjects();
+
+    void addItemListener(ItemListener l);
+
+    void removeItemListener(ItemListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/KeyboardFocusManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/KeyboardFocusManager.java
new file mode 100644
index 00000000000..e4b8f679db5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/KeyboardFocusManager.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+import com.codename1.desktopcompat.rt.EventBridge;
+import com.codename1.desktopcompat.rt.WindowHosts;
+
+/// Answers who owns the keyboard focus and moves it along the traversal
+/// order.
+///
+/// A minimal manager: the focus owner, the focused and active window (the
+/// same window), next and previous traversal, the default traversal
+/// policy, and the `"focusOwner"` property change. Key event dispatchers
+/// and post processors, vetoable changes and focus cycle roots are absent.
+public abstract class KeyboardFocusManager {
+
+    public static final int FORWARD_TRAVERSAL_KEYS = 0;
+    public static final int BACKWARD_TRAVERSAL_KEYS = 1;
+    public static final int UP_CYCLE_TRAVERSAL_KEYS = 2;
+    public static final int DOWN_CYCLE_TRAVERSAL_KEYS = 3;
+
+    private static KeyboardFocusManager current;
+
+    private FocusTraversalPolicy defaultPolicy = new DefaultFocusTraversalPolicy();
+    private PropertyChangeSupport changeSupport;
+
+    public KeyboardFocusManager() {
+    }
+
+    public static KeyboardFocusManager getCurrentKeyboardFocusManager() {
+        if (current == null) {
+            current = new DefaultKeyboardFocusManager();
+        }
+        return current;
+    }
+
+    /// Tells the manager the focus moved, so that it can tell its
+    /// listeners. Called by the event bridge.
+    public static void cn1FocusChanged(Component oldOwner, Component newOwner) {
+        if (current != null && current.changeSupport != null) {
+            current.changeSupport.firePropertyChange("focusOwner", oldOwner, newOwner);
+            current.changeSupport.firePropertyChange("permanentFocusOwner", oldOwner, newOwner);
+        }
+    }
+
+    public Component getFocusOwner() {
+        return EventBridge.focusOwner();
+    }
+
+    public Component getPermanentFocusOwner() {
+        return EventBridge.focusOwner();
+    }
+
+    public void clearGlobalFocusOwner() {
+        EventBridge.setFocusOwner(null, false);
+    }
+
+    public Window getFocusedWindow() {
+        return WindowHosts.active();
+    }
+
+    public Window getActiveWindow() {
+        return WindowHosts.active();
+    }
+
+    public FocusTraversalPolicy getDefaultFocusTraversalPolicy() {
+        return defaultPolicy;
+    }
+
+    public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy) {
+        if (defaultPolicy == null) {
+            throw new IllegalArgumentException("default focus traversal policy cannot be null");
+        }
+        this.defaultPolicy = defaultPolicy;
+    }
+
+    public abstract void focusNextComponent(Component aComponent);
+
+    public abstract void focusPreviousComponent(Component aComponent);
+
+    /// Moves the focus to the component after the focus owner, or to the
+    /// first component of the active window when nothing owns the focus.
+    public final void focusNextComponent() {
+        Component c = getFocusOwner();
+        focusNextComponent(c != null ? c : getActiveWindow());
+    }
+
+    public final void focusPreviousComponent() {
+        Component c = getFocusOwner();
+        focusPreviousComponent(c != null ? c : getActiveWindow());
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (listener != null) {
+            if (changeSupport == null) {
+                changeSupport = new PropertyChangeSupport(this);
+            }
+            changeSupport.addPropertyChangeListener(listener);
+        }
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport != null) {
+            changeSupport.removePropertyChangeListener(listener);
+        }
+    }
+
+    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        if (listener != null) {
+            if (changeSupport == null) {
+                changeSupport = new PropertyChangeSupport(this);
+            }
+            changeSupport.addPropertyChangeListener(propertyName, listener);
+        }
+    }
+
+    public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        if (changeSupport != null) {
+            changeSupport.removePropertyChangeListener(propertyName, listener);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Label.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Label.java
new file mode 100644
index 00000000000..7e680ebad52
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Label.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `Label`, a line of text drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JLabel` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof Label` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class Label extends Component {
+
+    public Label() {
+        throw new UnsupportedOperationException("java.awt.Label is not available; use javax.swing.JLabel");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/LayoutManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/LayoutManager.java
new file mode 100644
index 00000000000..0b543c37799
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/LayoutManager.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The contract of a class that positions the children of a [Container].
+public interface LayoutManager {
+
+    void addLayoutComponent(String name, Component comp);
+
+    void removeLayoutComponent(Component comp);
+
+    Dimension preferredLayoutSize(Container parent);
+
+    Dimension minimumLayoutSize(Container parent);
+
+    void layoutContainer(Container parent);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/LayoutManager2.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/LayoutManager2.java
new file mode 100644
index 00000000000..a7a19c829f8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/LayoutManager2.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// A [LayoutManager] that takes a constraints object for each child and can
+/// answer a maximum size and an alignment for the container it lays out.
+public interface LayoutManager2 extends LayoutManager {
+
+    void addLayoutComponent(Component comp, Object constraints);
+
+    Dimension maximumLayoutSize(Container target);
+
+    float getLayoutAlignmentX(Container target);
+
+    float getLayoutAlignmentY(Container target);
+
+    void invalidateLayout(Container target);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/List.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/List.java
new file mode 100644
index 00000000000..95663b903e2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/List.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `List`, a scrolling list drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JList` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof List` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class List extends Component {
+
+    public List() {
+        throw new UnsupportedOperationException("java.awt.List is not available; use javax.swing.JList");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Paint.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Paint.java
new file mode 100644
index 00000000000..669216ea7b3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Paint.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// What a `Graphics2D` fills and strokes with.
+///
+/// The two paints the layer can draw are [Color] and [GradientPaint]; a
+/// `Graphics2D` refuses any other with an `UnsupportedOperationException`
+/// rather than draw the wrong thing. The JDK's `createContext` is not part
+/// of this interface: nothing here rasterizes through paint contexts.
+public interface Paint extends Transparency {
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Panel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Panel.java
new file mode 100644
index 00000000000..2d4d2ba7fa4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Panel.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The plain AWT container; a flow layout unless told otherwise.
+public class Panel extends Container {
+
+    public Panel() {
+        this(new FlowLayout());
+    }
+
+    public Panel(LayoutManager layout) {
+        setLayout(layout);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Point.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Point.java
new file mode 100644
index 00000000000..edbce235998
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Point.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+
+/// A location in integer coordinates.
+public class Point extends Point2D {
+
+    public int x;
+
+    public int y;
+
+    public Point() {
+    }
+
+    public Point(Point p) {
+        this.x = p.x;
+        this.y = p.y;
+    }
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public double getX() {
+        return x;
+    }
+
+    @Override
+    public double getY() {
+        return y;
+    }
+
+    public Point getLocation() {
+        return new Point(x, y);
+    }
+
+    public void setLocation(Point p) {
+        this.x = p.x;
+        this.y = p.y;
+    }
+
+    public void setLocation(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /// Moves to the nearest integer location.
+    @Override
+    public void setLocation(double x, double y) {
+        this.x = (int) Math.floor(x + 0.5);
+        this.y = (int) Math.floor(y + 0.5);
+    }
+
+    public void move(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void translate(int dx, int dy) {
+        this.x += dx;
+        this.y += dy;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Point) {
+            Point p = (Point) obj;
+            return x == p.x && y == p.y;
+        }
+        return super.equals(obj);
+    }
+
+    @Override
+    public Object clone() {
+        return new Point(x, y);
+    }
+
+    @Override
+    public String toString() {
+        return "java.awt.Point[x=" + x + ",y=" + y + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Polygon.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Polygon.java
new file mode 100644
index 00000000000..bcf00133d3a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Polygon.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.Path2D;
+import com.codename1.desktopcompat.java.awt.geom.PathIterator;
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+
+/// A closed region bounded by straight edges between integer points,
+/// filled by the even-odd rule.
+public class Polygon implements Shape {
+
+    public int npoints;
+    public int[] xpoints;
+    public int[] ypoints;
+    protected Rectangle bounds;
+
+    public Polygon() {
+        xpoints = new int[4];
+        ypoints = new int[4];
+    }
+
+    public Polygon(int[] xpoints, int[] ypoints, int npoints) {
+        if (npoints > xpoints.length || npoints > ypoints.length) {
+            throw new IndexOutOfBoundsException("npoints > xpoints.length || npoints > ypoints.length");
+        }
+        if (npoints < 0) {
+            throw new NegativeArraySizeException("npoints < 0");
+        }
+        this.npoints = npoints;
+        this.xpoints = new int[npoints];
+        this.ypoints = new int[npoints];
+        System.arraycopy(xpoints, 0, this.xpoints, 0, npoints);
+        System.arraycopy(ypoints, 0, this.ypoints, 0, npoints);
+    }
+
+    public void reset() {
+        npoints = 0;
+        bounds = null;
+    }
+
+    public void invalidate() {
+        bounds = null;
+    }
+
+    public void translate(int deltaX, int deltaY) {
+        for (int i = 0; i < npoints; i++) {
+            xpoints[i] += deltaX;
+            ypoints[i] += deltaY;
+        }
+        if (bounds != null) {
+            bounds.translate(deltaX, deltaY);
+        }
+    }
+
+    public void addPoint(int x, int y) {
+        if (npoints >= xpoints.length || npoints >= ypoints.length) {
+            int size = Math.max(4, npoints * 2);
+            int[] nx = new int[size];
+            int[] ny = new int[size];
+            System.arraycopy(xpoints, 0, nx, 0, npoints);
+            System.arraycopy(ypoints, 0, ny, 0, npoints);
+            xpoints = nx;
+            ypoints = ny;
+        }
+        xpoints[npoints] = x;
+        ypoints[npoints] = y;
+        npoints++;
+        bounds = null;
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        if (npoints == 0) {
+            return new Rectangle();
+        }
+        if (bounds == null) {
+            int minX = Integer.MAX_VALUE;
+            int minY = Integer.MAX_VALUE;
+            int maxX = Integer.MIN_VALUE;
+            int maxY = Integer.MIN_VALUE;
+            for (int i = 0; i < npoints; i++) {
+                minX = Math.min(minX, xpoints[i]);
+                maxX = Math.max(maxX, xpoints[i]);
+                minY = Math.min(minY, ypoints[i]);
+                maxY = Math.max(maxY, ypoints[i]);
+            }
+            bounds = new Rectangle(minX, minY, maxX - minX, maxY - minY);
+        }
+        return new Rectangle(bounds.x, bounds.y, bounds.width, bounds.height);
+    }
+
+    public boolean contains(Point p) {
+        return contains(p.x, p.y);
+    }
+
+    public boolean contains(int x, int y) {
+        return contains((double) x, (double) y);
+    }
+
+    @Override
+    public Rectangle2D getBounds2D() {
+        return getBounds();
+    }
+
+    private Path2D.Double path() {
+        Path2D.Double p = new Path2D.Double(Path2D.WIND_EVEN_ODD);
+        for (int i = 0; i < npoints; i++) {
+            if (i == 0) {
+                p.moveTo(xpoints[i], ypoints[i]);
+            } else {
+                p.lineTo(xpoints[i], ypoints[i]);
+            }
+        }
+        if (npoints > 0) {
+            p.closePath();
+        }
+        return p;
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        return npoints > 2 && path().contains(x, y);
+    }
+
+    @Override
+    public boolean contains(Point2D p) {
+        return contains(p.getX(), p.getY());
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        return npoints > 0 && path().intersects(x, y, w, h);
+    }
+
+    @Override
+    public boolean intersects(Rectangle2D r) {
+        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        return npoints > 2 && path().contains(x, y, w, h);
+    }
+
+    @Override
+    public boolean contains(Rectangle2D r) {
+        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        return path().getPathIterator(at);
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return path().getPathIterator(at);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Rectangle.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Rectangle.java
new file mode 100644
index 00000000000..e627ace20c5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Rectangle.java
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+
+/// A rectangle in integer coordinates.
+///
+/// A rectangle with a zero width or height is empty and contains nothing; one
+/// with a negative width or height does not exist at all, and is ignored by
+/// `union` and `add`. Sums that would not fit an `int` are worked out in
+/// `long` and clamped.
+public class Rectangle extends Rectangle2D implements Shape {
+
+    public int x;
+
+    public int y;
+
+    public int width;
+
+    public int height;
+
+    public Rectangle() {
+    }
+
+    public Rectangle(Rectangle r) {
+        this.x = r.x;
+        this.y = r.y;
+        this.width = r.width;
+        this.height = r.height;
+    }
+
+    public Rectangle(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public Rectangle(int width, int height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    public Rectangle(Point p, Dimension d) {
+        this.x = p.x;
+        this.y = p.y;
+        this.width = d.width;
+        this.height = d.height;
+    }
+
+    public Rectangle(Point p) {
+        this.x = p.x;
+        this.y = p.y;
+    }
+
+    public Rectangle(Dimension d) {
+        this.width = d.width;
+        this.height = d.height;
+    }
+
+    @Override
+    public double getX() {
+        return x;
+    }
+
+    @Override
+    public double getY() {
+        return y;
+    }
+
+    @Override
+    public double getWidth() {
+        return width;
+    }
+
+    @Override
+    public double getHeight() {
+        return height;
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return new Rectangle(x, y, width, height);
+    }
+
+    @Override
+    public Rectangle2D getBounds2D() {
+        return new Rectangle(x, y, width, height);
+    }
+
+    public void setBounds(Rectangle r) {
+        setBounds(r.x, r.y, r.width, r.height);
+    }
+
+    public void setBounds(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    /// Sets the smallest integer rectangle that encloses the given one.
+    @Override
+    public void setRect(double x, double y, double width, double height) {
+        int newX = (int) Math.floor(x);
+        int newY = (int) Math.floor(y);
+        // a cast clamps to the int range, so far-off values stay far off
+        this.width = width >= 0.0 ? (int) Math.ceil(width + (x - newX)) : (int) Math.floor(width);
+        this.height = height >= 0.0 ? (int) Math.ceil(height + (y - newY)) : (int) Math.floor(height);
+        this.x = newX;
+        this.y = newY;
+    }
+
+    public Point getLocation() {
+        return new Point(x, y);
+    }
+
+    public void setLocation(Point p) {
+        setLocation(p.x, p.y);
+    }
+
+    public void setLocation(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void translate(int dx, int dy) {
+        this.x = clamp((long) x + dx);
+        this.y = clamp((long) y + dy);
+    }
+
+    public Dimension getSize() {
+        return new Dimension(width, height);
+    }
+
+    public void setSize(Dimension d) {
+        setSize(d.width, d.height);
+    }
+
+    public void setSize(int width, int height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    public boolean contains(Point p) {
+        return contains(p.x, p.y);
+    }
+
+    public boolean contains(int px, int py) {
+        if (width < 0 || height < 0 || px < x || py < y) {
+            return false;
+        }
+        return px < (long) x + width && py < (long) y + height;
+    }
+
+    public boolean contains(Rectangle r) {
+        return contains(r.x, r.y, r.width, r.height);
+    }
+
+    /// Whether the given rectangle lies wholly inside this one. An empty
+    /// rectangle on either side gives false.
+    public boolean contains(int rx, int ry, int rw, int rh) {
+        if (width <= 0 || height <= 0 || rw <= 0 || rh <= 0 || rx < x || ry < y) {
+            return false;
+        }
+        return (long) rx + rw <= (long) x + width && (long) ry + rh <= (long) y + height;
+    }
+
+    public boolean intersects(Rectangle r) {
+        if (width <= 0 || height <= 0 || r.width <= 0 || r.height <= 0) {
+            return false;
+        }
+        return (long) r.x + r.width > x && (long) r.y + r.height > y
+                && (long) x + width > r.x && (long) y + height > r.y;
+    }
+
+    /// The overlap of the two rectangles. When they do not overlap the
+    /// result has a negative or zero width or height.
+    public Rectangle intersection(Rectangle r) {
+        int x1 = Math.max(x, r.x);
+        int y1 = Math.max(y, r.y);
+        long x2 = Math.min((long) x + width, (long) r.x + r.width);
+        long y2 = Math.min((long) y + height, (long) r.y + r.height);
+        return new Rectangle(x1, y1, clamp(x2 - x1), clamp(y2 - y1));
+    }
+
+    /// The smallest rectangle enclosing both. When this rectangle has a
+    /// negative size the other is returned, and the other way round.
+    public Rectangle union(Rectangle r) {
+        if (width < 0 || height < 0) {
+            return new Rectangle(r);
+        }
+        Rectangle result = new Rectangle(this);
+        result.add(r);
+        return result;
+    }
+
+    /// Grows the rectangle to reach a point. A rectangle with a negative
+    /// size becomes the empty rectangle at that point.
+    public void add(int newx, int newy) {
+        if (width < 0 || height < 0) {
+            this.x = newx;
+            this.y = newy;
+            this.width = 0;
+            this.height = 0;
+            return;
+        }
+        long x2 = Math.max((long) x + width, (long) newx);
+        long y2 = Math.max((long) y + height, (long) newy);
+        this.x = Math.min(x, newx);
+        this.y = Math.min(y, newy);
+        this.width = clamp(x2 - this.x);
+        this.height = clamp(y2 - this.y);
+    }
+
+    public void add(Point pt) {
+        add(pt.x, pt.y);
+    }
+
+    /// Grows the rectangle to enclose another, ignoring one that has a
+    /// negative size. A rectangle that itself has a negative size first
+    /// moves to the other one; as in the JDK its own width and height still
+    /// take part from there, so a positive one of the two can survive.
+    public void add(Rectangle r) {
+        long w = width;
+        long h = height;
+        if (width < 0 || height < 0) {
+            setBounds(r.x, r.y, r.width, r.height);
+        }
+        if (r.width < 0 || r.height < 0) {
+            return;
+        }
+        long x2 = Math.max(x + w, (long) r.x + r.width);
+        long y2 = Math.max(y + h, (long) r.y + r.height);
+        this.x = Math.min(x, r.x);
+        this.y = Math.min(y, r.y);
+        this.width = clamp(x2 - this.x);
+        this.height = clamp(y2 - this.y);
+    }
+
+    /// Moves each side outwards by the given amounts; negative amounts
+    /// shrink the rectangle and can leave it with a negative size.
+    public void grow(int h, int v) {
+        long x1 = (long) x - h;
+        long y1 = (long) y - v;
+        long x2 = (long) x + width + h;
+        long y2 = (long) y + height + v;
+        this.x = clamp(x1);
+        this.y = clamp(y1);
+        this.width = clamp(x2 - this.x);
+        this.height = clamp(y2 - this.y);
+    }
+
+    private static int clamp(long v) {
+        if (v > Integer.MAX_VALUE) {
+            return Integer.MAX_VALUE;
+        }
+        if (v < Integer.MIN_VALUE) {
+            return Integer.MIN_VALUE;
+        }
+        return (int) v;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return width <= 0 || height <= 0;
+    }
+
+    @Override
+    public int outcode(double x, double y) {
+        int out = 0;
+        if (width <= 0) {
+            out |= OUT_LEFT | OUT_RIGHT;
+        } else if (x < this.x) {
+            out |= OUT_LEFT;
+        } else if (x > this.x + (double) width) {
+            out |= OUT_RIGHT;
+        }
+        if (height <= 0) {
+            out |= OUT_TOP | OUT_BOTTOM;
+        } else if (y < this.y) {
+            out |= OUT_TOP;
+        } else if (y > this.y + (double) height) {
+            out |= OUT_BOTTOM;
+        }
+        return out;
+    }
+
+    @Override
+    public Rectangle2D createIntersection(Rectangle2D r) {
+        if (r instanceof Rectangle) {
+            return intersection((Rectangle) r);
+        }
+        Rectangle2D dest = new Rectangle2D.Double();
+        Rectangle2D.intersect(this, r, dest);
+        return dest;
+    }
+
+    @Override
+    public Rectangle2D createUnion(Rectangle2D r) {
+        if (r instanceof Rectangle) {
+            return union((Rectangle) r);
+        }
+        Rectangle2D dest = new Rectangle2D.Double();
+        Rectangle2D.union(this, r, dest);
+        return dest;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Rectangle) {
+            Rectangle r = (Rectangle) obj;
+            return x == r.x && y == r.y && width == r.width && height == r.height;
+        }
+        return super.equals(obj);
+    }
+
+    @Override
+    public Object clone() {
+        return new Rectangle(x, y, width, height);
+    }
+
+    @Override
+    public String toString() {
+        return "java.awt.Rectangle[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/RenderingHints.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/RenderingHints.java
new file mode 100644
index 00000000000..a50244c08d1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/RenderingHints.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/// Preferences for how a `Graphics2D` renders, keyed by the `KEY_`
+/// constants. The antialiasing hints switch Codename One's antialiasing;
+/// the others are remembered and answered back but change nothing.
+public class RenderingHints implements Map<Object, Object>, Cloneable {
+
+    /// The identity of one hint.
+    public abstract static class Key {
+
+        private final int privatekey;
+
+        protected Key(int privatekey) {
+            this.privatekey = privatekey;
+        }
+
+        public abstract boolean isCompatibleValue(Object val);
+
+        protected final int intKey() {
+            return privatekey;
+        }
+
+        @Override
+        public final int hashCode() {
+            return super.hashCode();
+        }
+
+        @Override
+        public final boolean equals(Object o) {
+            return this == o;
+        }
+    }
+
+    private static final class HintKey extends Key {
+
+        private final String description;
+
+        HintKey(int number, String description) {
+            super(number);
+            this.description = description;
+        }
+
+        @Override
+        public boolean isCompatibleValue(Object val) {
+            return val instanceof HintValue && ((HintValue) val).key == this;
+        }
+
+        @Override
+        public String toString() {
+            return description;
+        }
+    }
+
+    private static final class HintValue {
+
+        final Key key;
+        private final String description;
+
+        HintValue(Key key, String description) {
+            this.key = key;
+            this.description = description;
+        }
+
+        @Override
+        public String toString() {
+            return description;
+        }
+    }
+
+    public static final Key KEY_ANTIALIASING = new HintKey(1, "Global antialiasing enable key");
+    public static final Object VALUE_ANTIALIAS_ON = new HintValue(KEY_ANTIALIASING, "Antialiased rendering mode");
+    public static final Object VALUE_ANTIALIAS_OFF = new HintValue(KEY_ANTIALIASING, "Nonantialiased rendering mode");
+    public static final Object VALUE_ANTIALIAS_DEFAULT = new HintValue(KEY_ANTIALIASING,
+            "Default antialiasing rendering mode");
+
+    public static final Key KEY_RENDERING = new HintKey(2, "Global rendering quality key");
+    public static final Object VALUE_RENDER_SPEED = new HintValue(KEY_RENDERING, "Fastest rendering methods");
+    public static final Object VALUE_RENDER_QUALITY = new HintValue(KEY_RENDERING,
+            "Highest quality rendering methods");
+    public static final Object VALUE_RENDER_DEFAULT = new HintValue(KEY_RENDERING, "Default rendering methods");
+
+    public static final Key KEY_DITHERING = new HintKey(3, "Dithering quality key");
+    public static final Object VALUE_DITHER_DISABLE = new HintValue(KEY_DITHERING, "Nondithered rendering mode");
+    public static final Object VALUE_DITHER_ENABLE = new HintValue(KEY_DITHERING, "Dithered rendering mode");
+    public static final Object VALUE_DITHER_DEFAULT = new HintValue(KEY_DITHERING, "Default dithering mode");
+
+    public static final Key KEY_TEXT_ANTIALIASING = new HintKey(4, "Text-specific antialiasing enable key");
+    public static final Object VALUE_TEXT_ANTIALIAS_ON = new HintValue(KEY_TEXT_ANTIALIASING,
+            "Antialiased text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_OFF = new HintValue(KEY_TEXT_ANTIALIASING,
+            "Nonantialiased text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_DEFAULT = new HintValue(KEY_TEXT_ANTIALIASING,
+            "Default antialiasing text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_GASP = new HintValue(KEY_TEXT_ANTIALIASING,
+            "GASP antialiasing text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_LCD_HRGB = new HintValue(KEY_TEXT_ANTIALIASING,
+            "LCD HRGB antialiasing text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_LCD_HBGR = new HintValue(KEY_TEXT_ANTIALIASING,
+            "LCD HBGR antialiasing text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_LCD_VRGB = new HintValue(KEY_TEXT_ANTIALIASING,
+            "LCD VRGB antialiasing text mode");
+    public static final Object VALUE_TEXT_ANTIALIAS_LCD_VBGR = new HintValue(KEY_TEXT_ANTIALIASING,
+            "LCD VBGR antialiasing text mode");
+
+    public static final Key KEY_FRACTIONALMETRICS = new HintKey(5, "Fractional metrics enable key");
+    public static final Object VALUE_FRACTIONALMETRICS_OFF = new HintValue(KEY_FRACTIONALMETRICS,
+            "Integer text metrics mode");
+    public static final Object VALUE_FRACTIONALMETRICS_ON = new HintValue(KEY_FRACTIONALMETRICS,
+            "Fractional text metrics mode");
+    public static final Object VALUE_FRACTIONALMETRICS_DEFAULT = new HintValue(KEY_FRACTIONALMETRICS,
+            "Default fractional text metrics mode");
+
+    public static final Key KEY_INTERPOLATION = new HintKey(6, "Image interpolation method key");
+    public static final Object VALUE_INTERPOLATION_NEAREST_NEIGHBOR = new HintValue(KEY_INTERPOLATION,
+            "Nearest Neighbor image interpolation mode");
+    public static final Object VALUE_INTERPOLATION_BILINEAR = new HintValue(KEY_INTERPOLATION,
+            "Bilinear image interpolation mode");
+    public static final Object VALUE_INTERPOLATION_BICUBIC = new HintValue(KEY_INTERPOLATION,
+            "Bicubic image interpolation mode");
+
+    public static final Key KEY_ALPHA_INTERPOLATION = new HintKey(7, "Alpha blending interpolation method key");
+    public static final Object VALUE_ALPHA_INTERPOLATION_SPEED = new HintValue(KEY_ALPHA_INTERPOLATION,
+            "Fastest alpha blending methods");
+    public static final Object VALUE_ALPHA_INTERPOLATION_QUALITY = new HintValue(KEY_ALPHA_INTERPOLATION,
+            "Highest quality alpha blending methods");
+    public static final Object VALUE_ALPHA_INTERPOLATION_DEFAULT = new HintValue(KEY_ALPHA_INTERPOLATION,
+            "Default alpha blending methods");
+
+    public static final Key KEY_COLOR_RENDERING = new HintKey(8, "Color rendering quality key");
+    public static final Object VALUE_COLOR_RENDER_SPEED = new HintValue(KEY_COLOR_RENDERING,
+            "Fastest color rendering methods");
+    public static final Object VALUE_COLOR_RENDER_QUALITY = new HintValue(KEY_COLOR_RENDERING,
+            "Highest quality color rendering methods");
+    public static final Object VALUE_COLOR_RENDER_DEFAULT = new HintValue(KEY_COLOR_RENDERING,
+            "Default color rendering methods");
+
+    public static final Key KEY_STROKE_CONTROL = new HintKey(9, "Stroke normalization control key");
+    public static final Object VALUE_STROKE_DEFAULT = new HintValue(KEY_STROKE_CONTROL,
+            "Default stroke normalization");
+    public static final Object VALUE_STROKE_NORMALIZE = new HintValue(KEY_STROKE_CONTROL,
+            "Stroke normalization for consistency");
+    public static final Object VALUE_STROKE_PURE = new HintValue(KEY_STROKE_CONTROL,
+            "Pure stroke conversion for accurate paths");
+
+    private final HashMap<Object, Object> hintmap = new HashMap<Object, Object>();
+
+    public RenderingHints(Map<Key, ?> init) {
+        if (init != null) {
+            for (Map.Entry<Key, ?> e : init.entrySet()) {
+                hintmap.put(e.getKey(), e.getValue());
+            }
+        }
+    }
+
+    public RenderingHints(Key key, Object value) {
+        hintmap.put(key, value);
+    }
+
+    @Override
+    public int size() {
+        return hintmap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return hintmap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return hintmap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return hintmap.containsValue(value);
+    }
+
+    @Override
+    public Object get(Object key) {
+        return hintmap.get(key);
+    }
+
+    @Override
+    public Object put(Object key, Object value) {
+        if (!(key instanceof Key)) {
+            throw new IllegalArgumentException("a rendering hint key must be a RenderingHints.Key");
+        }
+        if (!((Key) key).isCompatibleValue(value)) {
+            throw new IllegalArgumentException(value + " incompatible with " + key);
+        }
+        return hintmap.put(key, value);
+    }
+
+    public void add(RenderingHints hints) {
+        hintmap.putAll(hints.hintmap);
+    }
+
+    @Override
+    public void clear() {
+        hintmap.clear();
+    }
+
+    @Override
+    public Object remove(Object key) {
+        return hintmap.remove(key);
+    }
+
+    @Override
+    public void putAll(Map<?, ?> m) {
+        for (Map.Entry<?, ?> e : m.entrySet()) {
+            put(e.getKey(), e.getValue());
+        }
+    }
+
+    @Override
+    public Set<Object> keySet() {
+        return hintmap.keySet();
+    }
+
+    @Override
+    public Collection<Object> values() {
+        return hintmap.values();
+    }
+
+    @Override
+    public Set<Map.Entry<Object, Object>> entrySet() {
+        return hintmap.entrySet();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o instanceof RenderingHints) {
+            return hintmap.equals(((RenderingHints) o).hintmap);
+        }
+        return o instanceof Map && hintmap.equals(o);
+    }
+
+    @Override
+    public int hashCode() {
+        return hintmap.hashCode();
+    }
+
+    /// A copy holding the same hints.
+    @Override
+    public Object clone() {
+        RenderingHints copy = new RenderingHints(null);
+        copy.hintmap.putAll(hintmap);
+        return copy;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "@" + Integer.toHexString(hashCode()) + " (" + hintmap.size() + " hints)";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ScreenEnvironment.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ScreenEnvironment.java
new file mode 100644
index 00000000000..77e0cc5c16a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ScreenEnvironment.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+
+/// The one graphics environment, with its one device and configuration.
+final class ScreenEnvironment extends GraphicsEnvironment {
+
+    private final Device device = new Device();
+
+    @Override
+    public GraphicsDevice[] getScreenDevices() {
+        return new GraphicsDevice[]{device};
+    }
+
+    @Override
+    public GraphicsDevice getDefaultScreenDevice() {
+        return device;
+    }
+
+    @Override
+    public String[] getAvailableFontFamilyNames() {
+        String[] own = {Font.DIALOG, Font.DIALOG_INPUT, Font.MONOSPACED, Font.SANS_SERIF, Font.SERIF};
+        String[] added = com.codename1.desktopcompat.rt.FontFiles.families();
+        String[] all = new String[own.length + added.length];
+        System.arraycopy(own, 0, all, 0, own.length);
+        System.arraycopy(added, 0, all, own.length, added.length);
+        return all;
+    }
+
+    @Override
+    public Graphics2D createGraphics(com.codename1.desktopcompat.java.awt.image.BufferedImage img) {
+        if (img == null) {
+            throw new NullPointerException("BufferedImage cannot be null");
+        }
+        return img.createGraphics();
+    }
+
+    /// The display.
+    static final class Device extends GraphicsDevice {
+
+        private final Configuration configuration = new Configuration(this);
+
+        @Override
+        public int getType() {
+            return TYPE_RASTER_SCREEN;
+        }
+
+        @Override
+        public String getIDstring() {
+            return "Display0";
+        }
+
+        @Override
+        public GraphicsConfiguration[] getConfigurations() {
+            return new GraphicsConfiguration[]{configuration};
+        }
+
+        @Override
+        public GraphicsConfiguration getDefaultConfiguration() {
+            return configuration;
+        }
+    }
+
+    /// The display's one configuration: its bounds are the screen size in
+    /// logical pixels, and its transform is the identity because a
+    /// logical pixel is already 1/96 inch.
+    static final class Configuration extends GraphicsConfiguration {
+
+        private final GraphicsDevice device;
+
+        Configuration(GraphicsDevice device) {
+            this.device = device;
+        }
+
+        @Override
+        public GraphicsDevice getDevice() {
+            return device;
+        }
+
+        @Override
+        public Rectangle getBounds() {
+            Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
+            return new Rectangle(0, 0, d.width, d.height);
+        }
+
+        @Override
+        public AffineTransform getDefaultTransform() {
+            return new AffineTransform();
+        }
+
+        @Override
+        public AffineTransform getNormalizingTransform() {
+            return new AffineTransform();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ScrollPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ScrollPane.java
new file mode 100644
index 00000000000..33b36742746
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/ScrollPane.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `ScrollPane`, a scrolling container drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JScrollPane` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof ScrollPane` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class ScrollPane extends Container {
+
+    public ScrollPane() {
+        throw new UnsupportedOperationException("java.awt.ScrollPane is not available; use javax.swing.JScrollPane");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Scrollbar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Scrollbar.java
new file mode 100644
index 00000000000..6ea679ea523
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Scrollbar.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `Scrollbar`, a scroll bar drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JScrollBar` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof Scrollbar` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class Scrollbar extends Component {
+
+    public Scrollbar() {
+        throw new UnsupportedOperationException("java.awt.Scrollbar is not available; use javax.swing.JScrollBar");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Shape.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Shape.java
new file mode 100644
index 00000000000..e2c610e759e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Shape.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.PathIterator;
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+
+/// A geometric outline that can report its bounds, answer hit tests and
+/// describe itself as a sequence of path segments.
+public interface Shape {
+
+    Rectangle getBounds();
+
+    Rectangle2D getBounds2D();
+
+    boolean contains(double x, double y);
+
+    boolean contains(Point2D p);
+
+    boolean intersects(double x, double y, double w, double h);
+
+    boolean intersects(Rectangle2D r);
+
+    boolean contains(double x, double y, double w, double h);
+
+    boolean contains(Rectangle2D r);
+
+    PathIterator getPathIterator(AffineTransform at);
+
+    PathIterator getPathIterator(AffineTransform at, double flatness);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Stroke.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Stroke.java
new file mode 100644
index 00000000000..a812d9e9979
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Stroke.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// Turns the outline of a shape into the area a pen moving along it covers.
+public interface Stroke {
+    Shape createStrokedShape(Shape p);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Taskbar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Taskbar.java
new file mode 100644
index 00000000000..7787cd6c44a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Taskbar.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// The application's entry in the task bar or dock of a desktop.
+///
+/// No Codename One port gives an application one to draw on, so
+/// [#isTaskbarSupported()] answers false and [#getTaskbar()] throws, as on
+/// a desktop without a task bar. An application asks first.
+public class Taskbar {
+
+    /// What a task bar may be able to do.
+    public enum Feature {
+        ICON_BADGE_TEXT,
+        ICON_BADGE_NUMBER,
+        ICON_BADGE_IMAGE_WINDOW,
+        ICON_IMAGE,
+        MENU,
+        PROGRESS_STATE_WINDOW,
+        PROGRESS_VALUE,
+        PROGRESS_VALUE_WINDOW,
+        USER_ATTENTION,
+        USER_ATTENTION_WINDOW
+    }
+
+    /// The kinds of progress a task bar entry can show.
+    public enum State {
+        OFF,
+        NORMAL,
+        PAUSED,
+        INDETERMINATE,
+        ERROR
+    }
+
+    private Taskbar() {
+    }
+
+    /// Always false.
+    public static boolean isTaskbarSupported() {
+        return false;
+    }
+
+    /// #### Throws
+    ///
+    /// - `UnsupportedOperationException`: always; see [#isTaskbarSupported()]
+    public static Taskbar getTaskbar() {
+        throw new UnsupportedOperationException("Taskbar API is not supported on the current platform");
+    }
+
+    public boolean isSupported(Feature feature) {
+        return false;
+    }
+
+    private static UnsupportedOperationException unsupported(Feature f) {
+        return new UnsupportedOperationException("The " + f.name() + " feature is not supported on the current platform!");
+    }
+
+    public void requestUserAttention(boolean enabled, boolean critical) {
+        throw unsupported(Feature.USER_ATTENTION);
+    }
+
+    public void requestWindowUserAttention(Window w) {
+        throw unsupported(Feature.USER_ATTENTION_WINDOW);
+    }
+
+    public void setIconImage(Image image) {
+        throw unsupported(Feature.ICON_IMAGE);
+    }
+
+    public Image getIconImage() {
+        throw unsupported(Feature.ICON_IMAGE);
+    }
+
+    public void setIconBadge(String badge) {
+        throw unsupported(Feature.ICON_BADGE_TEXT);
+    }
+
+    public void setWindowIconBadge(Window w, Image badge) {
+        throw unsupported(Feature.ICON_BADGE_IMAGE_WINDOW);
+    }
+
+    public void setProgressValue(int value) {
+        throw unsupported(Feature.PROGRESS_VALUE);
+    }
+
+    public void setWindowProgressValue(Window w, int value) {
+        throw unsupported(Feature.PROGRESS_VALUE_WINDOW);
+    }
+
+    public void setWindowProgressState(Window w, State state) {
+        throw unsupported(Feature.PROGRESS_STATE_WINDOW);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/TextComponent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/TextComponent.java
new file mode 100644
index 00000000000..bc1b88d886c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/TextComponent.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// The base of AWT's heavyweight text widgets. Like [TextField] it exists so
+/// that `component instanceof TextComponent` links in a bundled library
+/// ([LinkOnly]); nothing extends it but [TextField], which cannot be
+/// constructed. The Swing text components descend from
+/// `javax.swing.text.JTextComponent` instead.
+@LinkOnly
+public class TextComponent extends Component {
+
+    TextComponent() {
+        // Package-private, as the JDK's constructor is.
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/TextField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/TextField.java
new file mode 100644
index 00000000000..bca76ded58a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/TextField.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.annotations.LinkOnly;
+
+/// AWT's heavyweight `TextField`, a one-line text field drawn by the desktop's own
+/// toolkit. There is no such widget here, and `javax.swing.JTextField` is the component
+/// to use.
+///
+/// The class exists for one reason: libraries written against Swing ask
+/// `component instanceof TextField` to tell the two families apart, and that
+/// question needs the type to exist. It is [LinkOnly], so the build accepts
+/// the reference from a bundled library and reports it from an application's
+/// own code. Nothing can construct one, which keeps the answer to that
+/// question `false` for every component there is.
+@LinkOnly
+public class TextField extends TextComponent {
+
+    public TextField() {
+        throw new UnsupportedOperationException("java.awt.TextField is not available; use javax.swing.JTextField");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Toolkit.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Toolkit.java
new file mode 100644
index 00000000000..8f039472bc4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Toolkit.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.rt.AwtListeners;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.AWTEventListener;
+import com.codename1.desktopcompat.java.awt.datatransfer.Clipboard;
+import com.codename1.desktopcompat.rt.DesktopToolkit;
+import java.net.URL;
+
+/// The few toolkit services this layer has: screen metrics, font metrics,
+/// image decoding and the event queue.
+public abstract class Toolkit {
+
+    private static Toolkit toolkit;
+
+    public Toolkit() {
+    }
+
+    public static Toolkit getDefaultToolkit() {
+        if (toolkit == null) {
+            toolkit = new DesktopToolkit();
+        }
+        return toolkit;
+    }
+
+    /// The display's size in logical pixels.
+    public abstract Dimension getScreenSize();
+
+    /// Always 96: a logical pixel is 1/96 inch.
+    public abstract int getScreenResolution();
+
+    public abstract FontMetrics getFontMetrics(Font font);
+
+    /// Does nothing: painting is flushed by Codename One.
+    public abstract void sync();
+
+    public abstract void beep();
+
+    /// Decodes an encoded image (PNG, JPEG) at once.
+    public abstract Image createImage(byte[] imagedata, int imageoffset, int imagelength);
+
+    /// The image a path names: the file, or else the application's
+    /// resource of the path's last name. It is read here and now; an image
+    /// that cannot be read has a width and height of -1.
+    public abstract Image getImage(String filename);
+
+    /// The image a URL names, read here and now.
+    public abstract Image getImage(URL url);
+
+    /// As [#getImage(String)]; no image is shared between callers either
+    /// way.
+    public abstract Image createImage(String filename);
+
+    public abstract Image createImage(URL url);
+
+    /// The device's clipboard. It carries text.
+    public abstract Clipboard getSystemClipboard();
+
+    public Image createImage(byte[] imagedata) {
+        return createImage(imagedata, 0, imagedata.length);
+    }
+
+    /// Always empty: the size a window gets is already the room it has.
+    public Insets getScreenInsets(GraphicsConfiguration gc) {
+        return new Insets(0, 0, 0, 0);
+    }
+
+    /// The control key everywhere. Menu accelerators given with it are
+    /// shown with the platform's own primary modifier in a native menu.
+    /// The modifier of the platform's menu shortcuts, as an old style
+    /// mask: the command key on an Apple system, control elsewhere.
+    public int getMenuShortcutKeyMask() {
+        return AwtListeners.commandKey() ? InputEvent.META_MASK : InputEvent.CTRL_MASK;
+    }
+
+    /// The modifier of the platform's menu shortcuts, as an extended
+    /// mask: `META_DOWN_MASK` on an Apple system, `CTRL_DOWN_MASK`
+    /// elsewhere.
+    public int getMenuShortcutKeyMaskEx() {
+        return AwtListeners.commandKey() ? InputEvent.META_DOWN_MASK : InputEvent.CTRL_DOWN_MASK;
+    }
+
+    /// Adds a listener that hears of every event in `eventMask`
+    /// dispatched to a component of the application, before the component
+    /// does.
+    public void addAWTEventListener(AWTEventListener listener, long eventMask) {
+        AwtListeners.add(listener, eventMask);
+    }
+
+    public void removeAWTEventListener(AWTEventListener listener) {
+        AwtListeners.remove(listener);
+    }
+
+    public AWTEventListener[] getAWTEventListeners() {
+        return AwtListeners.listeners(-1L);
+    }
+
+    public AWTEventListener[] getAWTEventListeners(long eventMask) {
+        return AwtListeners.listeners(eventMask);
+    }
+
+    /// Whether a window can stay usable while a modal dialog is open.
+    /// It cannot: a modal dialog takes all input, so only `NO_EXCLUDE` is
+    /// supported.
+    public boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType modalExclusionType) {
+        return modalExclusionType == Dialog.ModalExclusionType.NO_EXCLUDE;
+    }
+
+    /// Whether a frame can be put in a state; true for the normal state
+    /// everywhere, and for the others where there is a window manager.
+    public boolean isFrameStateSupported(int state) {
+        return state == Frame.NORMAL || com.codename1.ui.Desktop.isSupported();
+    }
+
+    protected abstract EventQueue getSystemEventQueueImpl();
+
+    public final EventQueue getSystemEventQueue() {
+        return getSystemEventQueueImpl();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Transparency.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Transparency.java
new file mode 100644
index 00000000000..28c0cd8c90b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Transparency.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+/// How much of what lies behind something shows through it.
+public interface Transparency {
+    int OPAQUE = 1;
+    int BITMASK = 2;
+    int TRANSLUCENT = 3;
+
+    int getTransparency();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Window.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Window.java
new file mode 100644
index 00000000000..2195936c33c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/Window.java
@@ -0,0 +1,693 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.event.HierarchyEvent;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import com.codename1.desktopcompat.java.awt.event.WindowFocusListener;
+import com.codename1.desktopcompat.java.awt.event.WindowListener;
+import com.codename1.desktopcompat.java.awt.event.WindowStateListener;
+import com.codename1.desktopcompat.rt.EventBridge;
+import com.codename1.desktopcompat.rt.FrameForm;
+import com.codename1.desktopcompat.rt.MenuBridge;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.desktopcompat.rt.WindowHost;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import java.util.ArrayList;
+
+/// A top level window.
+///
+/// What shows a window depends on the device; see
+/// [com.codename1.desktopcompat.rt.WindowHosts]. In short: the first
+/// window fills a form; where there is a window manager the others are
+/// windows of their own with the bounds the application set; on a phone
+/// a further frame is a form over the one before it, the size of the
+/// screen whatever was asked for, and a dialog floats over the current
+/// form. Windows start hidden.
+///
+/// The window on top is the active and the focused one. Showing a window
+/// puts it on top; `toBack` does nothing. `getWindows()` answers the
+/// windows that were shown or packed and not disposed of since -- there
+/// are no weak references to tell which of the others are still in use.
+public class Window extends Container {
+
+    private final Window owner;
+    private final ArrayList<Image> icons = new ArrayList<Image>();
+    private ArrayList<Window> owned;
+    private ArrayList<WindowListener> windowListeners;
+    private ArrayList<WindowFocusListener> windowFocusListeners;
+    private ArrayList<WindowStateListener> windowStateListeners;
+    private WindowHost host;
+    private Component lastFocus;
+    private boolean visible;
+    private boolean opened;
+    private boolean alwaysOnTop;
+    private boolean locationByPlatform;
+    private boolean focusableWindowState = true;
+    private boolean autoRequestFocus = true;
+    private boolean embedded;
+
+    public Window(Frame owner) {
+        this((Window) owner);
+    }
+
+    public Window(Window owner) {
+        this.owner = owner;
+        if (owner != null) {
+            if (owner.owned == null) {
+                owner.owned = new ArrayList<Window>();
+            }
+            owner.owned.add(this);
+        }
+        setLayout(new BorderLayout());
+    }
+
+    // ------------------------------------------------------------ host
+
+    /// The form showing this window when a form of its own does, else
+    /// `null`: before it is shown, for a dialog, and for a window of the
+    /// window manager.
+    public FrameForm cn1Form() {
+        return host instanceof FrameForm ? (FrameForm) host : null;
+    }
+
+    /// What shows this window, `null` until it is shown and with no
+    /// display.
+    public WindowHost cn1Host() {
+        return host;
+    }
+
+    /// The Codename One form this window is in -- its own form or the
+    /// dialog that floats it -- or `null`.
+    public com.codename1.ui.Form cn1HostForm() {
+        return host == null ? null : host.form();
+    }
+
+    /// Puts the window inside a host its caller owns, for good: a
+    /// Codename One component that shows a Swing tree inside a form of the
+    /// application (see `com.codename1.desktopcompat.SwingInterop`).
+    ///
+    /// Such a window is showing from here on and is never one of the
+    /// application's windows: it is not registered, it does not become the
+    /// active window, and hiding or disposing of it does nothing -- the
+    /// component that hosts it is what comes and goes.
+    public void cn1Embed(WindowHost h) {
+        embedded = true;
+        host = h;
+        visible = true;
+        if (!isDisplayable()) {
+            addNotify();
+        }
+        cn1ShowingChanged();
+        validate();
+    }
+
+    /// Tells the hierarchy listeners in the window that it was shown or
+    /// hidden.
+    private void cn1ShowingChanged() {
+        if (cn1HierarchyHeard()) {
+            cn1HierarchyChanged(this, null, HierarchyEvent.SHOWING_CHANGED | HierarchyEvent.DISPLAYABILITY_CHANGED);
+        }
+    }
+
+    /// Whether [#cn1Embed] put this window inside a component.
+    public boolean cn1Embedded() {
+        return embedded;
+    }
+
+    /// The title the host carries; frames and dialogs answer theirs.
+    public String cn1Title() {
+        return "";
+    }
+
+    /// Whether the user may resize the window; frames and dialogs answer
+    /// theirs.
+    protected boolean cn1Resizable() {
+        return true;
+    }
+
+    /// Whether the window has a title bar and a frame; a plain window has
+    /// neither.
+    protected boolean cn1Decorated() {
+        return false;
+    }
+
+    /// The extended state the window should be shown in; frames answer
+    /// theirs.
+    protected int cn1State() {
+        return Frame.NORMAL;
+    }
+
+    /// Runs what a user's request to close the window runs.
+    public void cn1Closing() {
+        dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSING));
+    }
+
+    /// The window became, or stopped being, the active one. Called by the
+    /// window registry; delivers the activation and window focus events
+    /// and moves the keyboard focus out of, or back into, the window.
+    public void cn1Activated(boolean active, Window opposite) {
+        if (active) {
+            dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_ACTIVATED, opposite));
+            dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_GAINED_FOCUS, opposite));
+            Component f = lastFocus;
+            lastFocus = null;
+            if (f != null && isAncestorOf(f) && f.isDisplayable()) {
+                f.requestFocusInWindow();
+            }
+            cn1InitialFocus();
+        } else {
+            Component f = EventBridge.focusOwner();
+            if (f != null && (f == this || isAncestorOf(f))) {
+                lastFocus = f;
+                EventBridge.setFocusOwner(null, false);
+            }
+            dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_LOST_FOCUS, opposite));
+            dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_DEACTIVATED, opposite));
+        }
+    }
+
+    /// Gives the keyboard focus to the component the traversal policy
+    /// names first, when nothing in this window has it.
+    ///
+    /// A window that becomes the focused one hands the focus to its
+    /// initial component. The form did that by itself for a component a
+    /// widget shows -- a button, a text field -- because the widget takes
+    /// the focus of the form. A component the application draws has no
+    /// such widget: a panel made focusable with a key listener, which is
+    /// how a game reads its keys, never became the focus owner, the keys
+    /// went to the window, and the game could not be played on any port.
+    /// See [Component#cn1TakesInitialFocus] for which components count.
+    private void cn1InitialFocus() {
+        Component f = EventBridge.focusOwner();
+        if (f != null && (f == this || isAncestorOf(f))) {
+            return;
+        }
+        FocusTraversalPolicy p = getFocusTraversalPolicy();
+        if (p == null) {
+            p = KeyboardFocusManager.getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();
+        }
+        Component first = p == null ? null : p.getInitialComponent(this);
+        Component c = first;
+        // The policy offers every component a key may be meant for, in
+        // order; the first of them a window may open on is the one.
+        for (int i = 0; c != null && c != this && i < 10000; i++) {
+            if (c.cn1TakesInitialFocus() && c.requestFocusInWindow()) {
+                return;
+            }
+            c = p.getComponentAfter(this, c);
+            if (c == first) {
+                return;
+            }
+        }
+    }
+
+    /// The window was minimized or restored, or the application went to
+    /// the background or came back.
+    public void cn1Iconified(boolean iconified) {
+        dispatchEvent(new WindowEvent(this, iconified ? WindowEvent.WINDOW_ICONIFIED
+                : WindowEvent.WINDOW_DEICONIFIED));
+    }
+
+    @Override
+    public void cn1SyncPeerBounds() {
+    }
+
+    // ------------------------------------------------------------ windows
+
+    public Window getOwner() {
+        return owner;
+    }
+
+    public Window[] getOwnedWindows() {
+        return owned == null ? new Window[0] : owned.toArray(new Window[owned.size()]);
+    }
+
+    /// The windows that were shown or packed and not disposed of since.
+    public static Window[] getWindows() {
+        return WindowHosts.windows();
+    }
+
+    public static Window[] getOwnerlessWindows() {
+        Window[] all = WindowHosts.windows();
+        ArrayList<Window> l = new ArrayList<Window>();
+        for (int i = 0; i < all.length; i++) {
+            if (all[i].owner == null) {
+                l.add(all[i]);
+            }
+        }
+        return l.toArray(new Window[l.size()]);
+    }
+
+    @Override
+    public Toolkit getToolkit() {
+        return Toolkit.getDefaultToolkit();
+    }
+
+    @Override
+    public boolean isVisible() {
+        return visible;
+    }
+
+    @Override
+    public boolean isShowing() {
+        return visible;
+    }
+
+    @Override
+    public boolean isValidateRoot() {
+        return true;
+    }
+
+    @Override
+    public Point getLocationOnScreen() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p == null) {
+            return new Point(getX(), getY());
+        }
+        return new Point(Units.toLogical(p.getAbsoluteX()), Units.toLogical(p.getAbsoluteY()));
+    }
+
+    @Override
+    public Color getBackground() {
+        Color c = super.getBackground();
+        return c != null ? c : EventBridge.defaultBackground();
+    }
+
+    @Override
+    public Color getForeground() {
+        Color c = super.getForeground();
+        return c != null ? c : EventBridge.defaultForeground();
+    }
+
+    @Override
+    public Font getFont() {
+        Font f = super.getFont();
+        return f != null ? f : com.codename1.desktopcompat.rt.Fonts.defaultFont();
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        g.setColor(getBackground());
+        g.fillRect(0, 0, getWidth(), getHeight());
+        super.paint(g);
+    }
+
+    @Override
+    public void addNotify() {
+        super.addNotify();
+        if (!embedded) {
+            WindowHosts.registered(this);
+        }
+    }
+
+    // ------------------------------------------------------------ bounds
+
+    /// Sizes the window to its preferred size and lays it out. A window
+    /// that fills a form keeps the size of the form.
+    public void pack() {
+        if (!isDisplayable()) {
+            addNotify();
+        }
+        if (host == null || !host.fillsDisplay()) {
+            Dimension d = getPreferredSize();
+            setSize(d.width, d.height);
+        }
+        validate();
+    }
+
+    @Override
+    public void setBounds(int x, int y, int width, int height) {
+        super.setBounds(x, y, width, height);
+        if (host != null) {
+            host.bounds();
+        }
+    }
+
+    /// Centers the window over `c`, or on the screen when `c` is `null`
+    /// or not showing. It has an effect only on a window of the window
+    /// manager; the others are placed by their host.
+    public void setLocationRelativeTo(Component c) {
+        if (host != null && host.fillsDisplay()) {
+            return;
+        }
+        Dimension s = getToolkit().getScreenSize();
+        int cx = s.width / 2;
+        int cy = s.height / 2;
+        if (c != null && c.isShowing()) {
+            Point p = c.getLocationOnScreen();
+            cx = p.x + c.getWidth() / 2;
+            cy = p.y + c.getHeight() / 2;
+        }
+        setLocation(Math.max(0, cx - getWidth() / 2), Math.max(0, cy - getHeight() / 2));
+    }
+
+    public boolean isLocationByPlatform() {
+        return locationByPlatform;
+    }
+
+    /// Recorded only: a window of the window manager that was never
+    /// moved is centered, whatever this says.
+    public void setLocationByPlatform(boolean locationByPlatform) {
+        this.locationByPlatform = locationByPlatform;
+    }
+
+    // ------------------------------------------------------------ showing
+
+    @Override
+    public void setVisible(boolean b) {
+        if (b == visible || embedded) {
+            return;
+        }
+        visible = b;
+        if (b) {
+            if (!isDisplayable()) {
+                addNotify();
+            }
+            cn1ShowingChanged();
+            host = WindowHosts.open(this, host);
+            if (host != null) {
+                host.title(cn1Title());
+                host.icon(icons.isEmpty() ? null : icons.get(0).cn1Image());
+                host.resizable(cn1Resizable());
+                host.decorated(cn1Decorated());
+                WindowHost opening = host;
+                opening.open();
+                if (!visible || host != opening) {
+                    // Hidden again by something that ran while it opened.
+                    return;
+                }
+                if (cn1State() != Frame.NORMAL) {
+                    host.state(cn1State());
+                }
+                MenuBridge.windowShown(this);
+            } else {
+                validate();
+            }
+            if (!opened) {
+                opened = true;
+                dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_OPENED));
+            }
+            WindowHosts.shown(this);
+        } else {
+            WindowHost h = host;
+            if (h != null) {
+                if (!h.reusable()) {
+                    host = null;
+                }
+                h.close();
+            }
+            cn1ShowingChanged();
+            WindowHosts.hidden(this);
+        }
+    }
+
+    /// Hides the window, disposes of the windows it owns and releases
+    /// what showed it. The window can be shown again.
+    public void dispose() {
+        if (embedded) {
+            return;
+        }
+        boolean was = isDisplayable();
+        if (owned != null) {
+            Window[] ws = getOwnedWindows();
+            for (int i = 0; i < ws.length; i++) {
+                ws[i].dispose();
+            }
+        }
+        setVisible(false);
+        if (was) {
+            if (host != null) {
+                host.release();
+                host = null;
+            }
+            removeNotify();
+            opened = false;
+            WindowHosts.released(this);
+            dispatchEvent(new WindowEvent(this, WindowEvent.WINDOW_CLOSED));
+        }
+    }
+
+    /// Puts the window on top of the others and makes it the active one.
+    public void toFront() {
+        if (visible && !embedded) {
+            if (host != null) {
+                host.open();
+            }
+            WindowHosts.shown(this);
+        }
+    }
+
+    /// Does nothing.
+    public void toBack() {
+    }
+
+    public boolean isActive() {
+        if (embedded) {
+            // Active while the form its component is on is the one showing.
+            com.codename1.ui.Form f = host == null ? null : host.form();
+            return f != null && com.codename1.ui.Display.isInitialized()
+                    && com.codename1.ui.Display.getInstance().getCurrent() == f;
+        }
+        return visible && WindowHosts.active() == this;
+    }
+
+    public boolean isFocused() {
+        return isActive();
+    }
+
+    public Component getFocusOwner() {
+        Component c = EventBridge.focusOwner();
+        return c != null && (c == this || isAncestorOf(c)) ? c : null;
+    }
+
+    public Component getMostRecentFocusOwner() {
+        Component c = getFocusOwner();
+        return c != null ? c : lastFocus;
+    }
+
+    public boolean isAlwaysOnTop() {
+        return alwaysOnTop;
+    }
+
+    /// Recorded only.
+    public final void setAlwaysOnTop(boolean alwaysOnTop) {
+        this.alwaysOnTop = alwaysOnTop;
+    }
+
+    public boolean getFocusableWindowState() {
+        return focusableWindowState;
+    }
+
+    /// Recorded only.
+    public void setFocusableWindowState(boolean focusableWindowState) {
+        this.focusableWindowState = focusableWindowState;
+    }
+
+    public boolean isAutoRequestFocus() {
+        return autoRequestFocus;
+    }
+
+    /// Recorded only: a window that shows always becomes the active one.
+    public void setAutoRequestFocus(boolean autoRequestFocus) {
+        this.autoRequestFocus = autoRequestFocus;
+    }
+
+    // ------------------------------------------------------------ icon
+
+    /// Sets the icon of the window. Only a window of the window manager
+    /// shows one.
+    public void setIconImage(Image image) {
+        icons.clear();
+        if (image != null) {
+            icons.add(image);
+        }
+        if (host != null) {
+            host.icon(image == null ? null : image.cn1Image());
+        }
+    }
+
+    public void setIconImages(java.util.List<? extends Image> icons) {
+        this.icons.clear();
+        if (icons != null) {
+            for (int i = 0; i < icons.size(); i++) {
+                if (icons.get(i) != null) {
+                    this.icons.add(icons.get(i));
+                }
+            }
+        }
+        if (host != null) {
+            host.icon(this.icons.isEmpty() ? null : this.icons.get(0).cn1Image());
+        }
+    }
+
+    public java.util.List<Image> getIconImages() {
+        return new ArrayList<Image>(icons);
+    }
+
+    // ------------------------------------------------------------ events
+
+    public void addWindowListener(WindowListener l) {
+        if (l != null) {
+            if (windowListeners == null) {
+                windowListeners = new ArrayList<WindowListener>();
+            }
+            windowListeners.add(l);
+        }
+    }
+
+    public void removeWindowListener(WindowListener l) {
+        if (windowListeners != null) {
+            windowListeners.remove(l);
+        }
+    }
+
+    public WindowListener[] getWindowListeners() {
+        return windowListeners == null ? new WindowListener[0]
+                : windowListeners.toArray(new WindowListener[windowListeners.size()]);
+    }
+
+    public void addWindowFocusListener(WindowFocusListener l) {
+        if (l != null) {
+            if (windowFocusListeners == null) {
+                windowFocusListeners = new ArrayList<WindowFocusListener>();
+            }
+            windowFocusListeners.add(l);
+        }
+    }
+
+    public void removeWindowFocusListener(WindowFocusListener l) {
+        if (windowFocusListeners != null) {
+            windowFocusListeners.remove(l);
+        }
+    }
+
+    public WindowFocusListener[] getWindowFocusListeners() {
+        return windowFocusListeners == null ? new WindowFocusListener[0]
+                : windowFocusListeners.toArray(new WindowFocusListener[windowFocusListeners.size()]);
+    }
+
+    public void addWindowStateListener(WindowStateListener l) {
+        if (l != null) {
+            if (windowStateListeners == null) {
+                windowStateListeners = new ArrayList<WindowStateListener>();
+            }
+            windowStateListeners.add(l);
+        }
+    }
+
+    public void removeWindowStateListener(WindowStateListener l) {
+        if (windowStateListeners != null) {
+            windowStateListeners.remove(l);
+        }
+    }
+
+    public WindowStateListener[] getWindowStateListeners() {
+        return windowStateListeners == null ? new WindowStateListener[0]
+                : windowStateListeners.toArray(new WindowStateListener[windowStateListeners.size()]);
+    }
+
+    @Override
+    protected void processEvent(AWTEvent e) {
+        if (e instanceof WindowEvent) {
+            int id = e.getID();
+            if (id == WindowEvent.WINDOW_GAINED_FOCUS || id == WindowEvent.WINDOW_LOST_FOCUS) {
+                processWindowFocusEvent((WindowEvent) e);
+            } else if (id == WindowEvent.WINDOW_STATE_CHANGED) {
+                processWindowStateEvent((WindowEvent) e);
+            } else {
+                processWindowEvent((WindowEvent) e);
+            }
+        } else {
+            super.processEvent(e);
+        }
+    }
+
+    protected void processWindowEvent(WindowEvent e) {
+        WindowListener[] ls = getWindowListeners();
+        for (int i = 0; i < ls.length; i++) {
+            switch (e.getID()) {
+                case WindowEvent.WINDOW_OPENED:
+                    ls[i].windowOpened(e);
+                    break;
+                case WindowEvent.WINDOW_CLOSING:
+                    ls[i].windowClosing(e);
+                    break;
+                case WindowEvent.WINDOW_CLOSED:
+                    ls[i].windowClosed(e);
+                    break;
+                case WindowEvent.WINDOW_ICONIFIED:
+                    ls[i].windowIconified(e);
+                    break;
+                case WindowEvent.WINDOW_DEICONIFIED:
+                    ls[i].windowDeiconified(e);
+                    break;
+                case WindowEvent.WINDOW_ACTIVATED:
+                    ls[i].windowActivated(e);
+                    break;
+                case WindowEvent.WINDOW_DEACTIVATED:
+                    ls[i].windowDeactivated(e);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    protected void processWindowFocusEvent(WindowEvent e) {
+        WindowFocusListener[] ls = getWindowFocusListeners();
+        for (int i = 0; i < ls.length; i++) {
+            if (e.getID() == WindowEvent.WINDOW_GAINED_FOCUS) {
+                ls[i].windowGainedFocus(e);
+            } else {
+                ls[i].windowLostFocus(e);
+            }
+        }
+    }
+
+    protected void processWindowStateEvent(WindowEvent e) {
+        WindowStateListener[] ls = getWindowStateListeners();
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].windowStateChanged(e);
+        }
+    }
+
+    private Dialog.ModalExclusionType modalExclusionType = Dialog.ModalExclusionType.NO_EXCLUDE;
+
+    /// Asks that this window stay usable while a modal dialog is open.
+    /// As on a desktop that cannot do it, a type the toolkit does not
+    /// support -- here every one but `NO_EXCLUDE`, see
+    /// `Toolkit.isModalExclusionTypeSupported` -- is taken as
+    /// `NO_EXCLUDE`, which is what [#getModalExclusionType()] then says.
+    public void setModalExclusionType(Dialog.ModalExclusionType exclusionType) {
+        Dialog.ModalExclusionType t = exclusionType;
+        if (t == null || !Toolkit.getDefaultToolkit().isModalExclusionTypeSupported(t)) {
+            t = Dialog.ModalExclusionType.NO_EXCLUDE;
+        }
+        modalExclusionType = t;
+    }
+
+    public Dialog.ModalExclusionType getModalExclusionType() {
+        return modalExclusionType;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/Clipboard.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/Clipboard.java
new file mode 100644
index 00000000000..91be3242214
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/Clipboard.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.datatransfer;
+
+import java.io.IOException;
+
+/// A place to put a [Transferable] for something else to take.
+///
+/// One made with `new Clipboard(name)` is private to the application and
+/// holds whatever it is given. The system clipboard, which
+/// `Toolkit.getDefaultToolkit().getSystemClipboard()` answers, is the
+/// device's: text put on it can be pasted into other applications, and
+/// text copied elsewhere is read from it as a [StringSelection].
+///
+/// What differs from the desktop: there are no flavor listeners, and the
+/// system clipboard carries text only.
+public class Clipboard {
+
+    protected ClipboardOwner owner;
+    protected Transferable contents;
+    private final String name;
+
+    public Clipboard(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /// Puts `contents` on the clipboard. The owner of what was there
+    /// before is told it lost it, unless it is the new owner too.
+    public void setContents(Transferable contents, ClipboardOwner owner) {
+        ClipboardOwner oldOwner = this.owner;
+        Transferable oldContents = this.contents;
+        this.owner = owner;
+        this.contents = contents;
+        if (oldOwner != null && oldOwner != owner) {
+            oldOwner.lostOwnership(this, oldContents);
+        }
+    }
+
+    /// What the clipboard holds, or `null` when it is empty. `requestor`
+    /// is not used.
+    public Transferable getContents(Object requestor) {
+        return contents;
+    }
+
+    public DataFlavor[] getAvailableDataFlavors() {
+        Transferable c = getContents(null);
+        return c == null ? new DataFlavor[0] : c.getTransferDataFlavors();
+    }
+
+    public boolean isDataFlavorAvailable(DataFlavor flavor) {
+        if (flavor == null) {
+            throw new NullPointerException("flavor");
+        }
+        Transferable c = getContents(null);
+        return c != null && c.isDataFlavorSupported(flavor);
+    }
+
+    /// What the clipboard holds, in one flavor.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedFlavorException`: if the clipboard is empty or does not
+    ///   hold `flavor`
+    ///
+    /// - `IOException`: if the data is no longer there to read
+    public Object getData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+        if (flavor == null) {
+            throw new NullPointerException("flavor");
+        }
+        Transferable c = getContents(null);
+        if (c == null) {
+            throw new UnsupportedFlavorException(flavor);
+        }
+        return c.getTransferData(flavor);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/ClipboardOwner.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/ClipboardOwner.java
new file mode 100644
index 00000000000..a2c9f633c8d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/ClipboardOwner.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.datatransfer;
+
+/// Whoever put something on a [Clipboard], told when something else
+/// replaces it.
+public interface ClipboardOwner {
+
+    /// `contents` is no longer what `clipboard` holds.
+    void lostOwnership(Clipboard clipboard, Transferable contents);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/DataFlavor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/DataFlavor.java
new file mode 100644
index 00000000000..44eedaaffb3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/DataFlavor.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.datatransfer;
+
+/// The kind of data a [Transferable] can hand over: a MIME type and the
+/// class of the object that carries it.
+///
+/// The system clipboard of the layer carries text, so [#stringFlavor] is
+/// the flavor that matters; others can be made and compared, and are
+/// carried only by a `Transferable` and a [Clipboard] of the application's
+/// own.
+public class DataFlavor {
+
+    /// A Java string.
+    public static final DataFlavor stringFlavor = new DataFlavor(String.class, "Unicode String");
+
+    /// A list of files, each a `java.io.File`: what a drag of files from
+    /// another application carries.
+    public static final DataFlavor javaFileListFlavor = new DataFlavor("application/x-java-file-list",
+            java.util.List.class, "application/x-java-file-list");
+
+    public static final String javaSerializedObjectMimeType = "application/x-java-serialized-object";
+
+    private final String primary;
+    private final Class<?> representationClass;
+    private String humanPresentableName;
+
+    public DataFlavor(Class<?> representationClass, String humanPresentableName) {
+        if (representationClass == null) {
+            throw new NullPointerException("representationClass");
+        }
+        this.primary = javaSerializedObjectMimeType;
+        this.representationClass = representationClass;
+        this.humanPresentableName = humanPresentableName == null ? primary : humanPresentableName;
+    }
+
+    private DataFlavor(String primary, Class<?> representationClass, String humanPresentableName) {
+        this.primary = primary;
+        this.representationClass = representationClass;
+        this.humanPresentableName = humanPresentableName;
+    }
+
+    /// A flavor for a MIME type whose data is read from a stream. The
+    /// parameters of the type, after the first `;`, are not kept.
+    public DataFlavor(String mimeType, String humanPresentableName) {
+        if (mimeType == null) {
+            throw new NullPointerException("mimeType");
+        }
+        int cut = mimeType.indexOf(';');
+        this.primary = fold(cut < 0 ? mimeType : mimeType.substring(0, cut));
+        this.representationClass = java.io.InputStream.class;
+        this.humanPresentableName = humanPresentableName == null ? primary : humanPresentableName;
+    }
+
+    /// A MIME type is ASCII and compared without regard to case; it is
+    /// folded here by hand because the platform's case folding follows the
+    /// device's language.
+    private static String fold(String s) {
+        StringBuilder sb = new StringBuilder(s.length());
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                c = (char) (c + ('a' - 'A'));
+            }
+            if (c != ' ' && c != '\t') {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    public String getMimeType() {
+        return primary + "; class=" + representationClass.getName();
+    }
+
+    public String getPrimaryType() {
+        int cut = primary.indexOf('/');
+        return cut < 0 ? primary : primary.substring(0, cut);
+    }
+
+    public String getSubType() {
+        int cut = primary.indexOf('/');
+        return cut < 0 ? "" : primary.substring(cut + 1);
+    }
+
+    public Class<?> getRepresentationClass() {
+        return representationClass;
+    }
+
+    public String getHumanPresentableName() {
+        return humanPresentableName;
+    }
+
+    public void setHumanPresentableName(String humanPresentableName) {
+        this.humanPresentableName = humanPresentableName;
+    }
+
+    /// Whether the type and subtype of `mimeType` are this flavor's.
+    public boolean isMimeTypeEqual(String mimeType) {
+        if (mimeType == null) {
+            throw new NullPointerException("mimeType");
+        }
+        int cut = mimeType.indexOf(';');
+        return primary.equals(fold(cut < 0 ? mimeType : mimeType.substring(0, cut)));
+    }
+
+    public final boolean isMimeTypeEqual(DataFlavor dataFlavor) {
+        return dataFlavor != null && primary.equals(dataFlavor.primary);
+    }
+
+    /// Whether this is the flavor of a list of files.
+    public boolean isFlavorJavaFileListType() {
+        return primary.equals(javaFileListFlavor.primary)
+                && java.util.List.class.equals(representationClass);
+    }
+
+    public boolean isFlavorTextType() {
+        return String.class.equals(representationClass) || "text".equals(getPrimaryType());
+    }
+
+    public boolean match(DataFlavor that) {
+        return equals(that);
+    }
+
+    /// Two flavors are equal when their MIME types and their
+    /// representation classes are.
+    public boolean equals(DataFlavor that) {
+        return that != null && primary.equals(that.primary)
+                && representationClass.equals(that.representationClass);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof DataFlavor && equals((DataFlavor) o);
+    }
+
+    @Override
+    public int hashCode() {
+        return primary.hashCode() * 31 + representationClass.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return "java.awt.datatransfer.DataFlavor[mimetype=" + primary + ";representationclass="
+                + representationClass.getName() + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/StringSelection.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/StringSelection.java
new file mode 100644
index 00000000000..9ddf7eeb9f3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/StringSelection.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.datatransfer;
+
+import java.io.IOException;
+
+/// A string to put on a clipboard, offered as [DataFlavor#stringFlavor].
+///
+/// What differs from the desktop: the deprecated plain text flavor, which
+/// hands the string over as a reader, is not offered.
+public class StringSelection implements Transferable, ClipboardOwner {
+
+    private final String data;
+
+    public StringSelection(String data) {
+        this.data = data;
+    }
+
+    @Override
+    public DataFlavor[] getTransferDataFlavors() {
+        return new DataFlavor[]{DataFlavor.stringFlavor};
+    }
+
+    @Override
+    public boolean isDataFlavorSupported(DataFlavor flavor) {
+        return DataFlavor.stringFlavor.equals(flavor);
+    }
+
+    @Override
+    public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+        if (!DataFlavor.stringFlavor.equals(flavor)) {
+            throw new UnsupportedFlavorException(flavor);
+        }
+        return data;
+    }
+
+    @Override
+    public void lostOwnership(Clipboard clipboard, Transferable contents) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/Transferable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/Transferable.java
new file mode 100644
index 00000000000..1ca4181d425
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/Transferable.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.datatransfer;
+
+import java.io.IOException;
+
+/// Data that can be put on a [Clipboard], in one or more flavors.
+public interface Transferable {
+
+    /// The flavors the data can be had in, the richest first.
+    DataFlavor[] getTransferDataFlavors();
+
+    boolean isDataFlavorSupported(DataFlavor flavor);
+
+    /// The data in one flavor.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedFlavorException`: if the data is not offered in `flavor`
+    ///
+    /// - `IOException`: if the data is no longer there to read
+    Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/UnsupportedFlavorException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/UnsupportedFlavorException.java
new file mode 100644
index 00000000000..7f79c834136
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/UnsupportedFlavorException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.datatransfer;
+
+/// Thrown when data is asked for in a flavor it is not offered in.
+public class UnsupportedFlavorException extends Exception {
+
+    private static final long serialVersionUID = 5383814944251665601L;
+
+    public UnsupportedFlavorException(DataFlavor flavor) {
+        super(flavor != null ? flavor.getHumanPresentableName() : null);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/package-info.java
new file mode 100644
index 00000000000..ec1d1cc1d05
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/datatransfer/package-info.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The clipboard: these classes stand in for the JDK's
+/// `java.awt.datatransfer` package once an application has been relocated
+/// onto the layer.
+///
+/// `Toolkit.getDefaultToolkit().getSystemClipboard()` answers a
+/// [Clipboard] over the device's clipboard. It carries text: a
+/// [StringSelection] put on it can be pasted elsewhere, and text copied
+/// elsewhere is read from it with `getData(DataFlavor.stringFlavor)`.
+/// Drag and drop, flavor maps and flavor listeners are not here.
+package com.codename1.desktopcompat.java.awt.datatransfer;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/AppEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/AppEvent.java
new file mode 100644
index 00000000000..5afd3120f58
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/AppEvent.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.desktop;
+
+import com.codename1.desktopcompat.java.awt.Desktop;
+import java.util.EventObject;
+
+/// What the events of the application menu have in common.
+public class AppEvent extends EventObject {
+
+    AppEvent() {
+        super(Desktop.getDesktop());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/PreferencesEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/PreferencesEvent.java
new file mode 100644
index 00000000000..ff5b95f081c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/PreferencesEvent.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.desktop;
+
+/// The user chose Preferences in the application menu.
+public final class PreferencesEvent extends AppEvent {
+
+    public PreferencesEvent() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/PreferencesHandler.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/PreferencesHandler.java
new file mode 100644
index 00000000000..678cd5a9ee5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/PreferencesHandler.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.desktop;
+
+/// Shows the application's preferences when the user asks for them in
+/// the application menu. Nothing calls it here: see
+/// `Desktop.setPreferencesHandler`.
+public interface PreferencesHandler {
+
+    void handlePreferences(PreferencesEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/package-info.java
new file mode 100644
index 00000000000..b729e41dac0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/desktop/package-info.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The handlers and events of the application menu a desktop gives an
+/// application. The layer has no such menu; the types are here so that
+/// code which asks `Desktop.isSupported` first compiles and takes its
+/// other branch.
+package com.codename1.desktopcompat.java.awt.desktop;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DnDConstants.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DnDConstants.java
new file mode 100644
index 00000000000..4542b695545
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DnDConstants.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+/// What a drag can do with its data when it is dropped.
+public final class DnDConstants {
+
+    public static final int ACTION_NONE = 0x0;
+
+    public static final int ACTION_COPY = 0x1;
+
+    public static final int ACTION_MOVE = 0x2;
+
+    public static final int ACTION_COPY_OR_MOVE = ACTION_COPY | ACTION_MOVE;
+
+    public static final int ACTION_LINK = 0x40000000;
+
+    public static final int ACTION_REFERENCE = ACTION_LINK;
+
+    private DnDConstants() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTarget.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTarget.java
new file mode 100644
index 00000000000..96a14b58137
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTarget.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.rt.Dnd;
+
+/// Makes a component a place where a drag can be dropped.
+///
+/// The drags it hears of are the ones that begin in this application --
+/// see `javax.swing.TransferHandler` -- and, where the platform reports
+/// them, files and text dragged in from another application. A file drag
+/// offers `DataFlavor.javaFileListFlavor`, a text drag
+/// `DataFlavor.stringFlavor`. On a platform that reports no drops from
+/// outside, the target is there and such a drag never reaches it.
+///
+/// A target has one listener, given when it is made.
+public class DropTarget implements DropTargetListener {
+
+    private final DropTargetContext context = new DropTargetContext(this);
+    private Component component;
+    private int actions = DnDConstants.ACTION_COPY_OR_MOVE;
+    private boolean active = true;
+    private DropTargetListener listener;
+
+    public DropTarget() {
+        this(null, DnDConstants.ACTION_COPY_OR_MOVE, null, true);
+    }
+
+    public DropTarget(Component c, DropTargetListener dtl) {
+        this(c, DnDConstants.ACTION_COPY_OR_MOVE, dtl, true);
+    }
+
+    public DropTarget(Component c, int ops, DropTargetListener dtl) {
+        this(c, ops, dtl, true);
+    }
+
+    /// Makes `c` a place to drop, taking the actions in `ops` and telling
+    /// `dtl`; `act` is whether the target starts out taking drops.
+    public DropTarget(Component c, int ops, DropTargetListener dtl, boolean act) {
+        listener = dtl;
+        actions = ops & (DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_REFERENCE);
+        active = act;
+        if (c != null) {
+            component = c;
+            c.setDropTarget(this);
+        }
+        Dnd.want();
+    }
+
+    /// Moves the target to another component, or to none.
+    public void setComponent(Component c) {
+        if (component == c) {
+            return;
+        }
+        Component old = component;
+        component = c;
+        if (old != null && old.getDropTarget() == this) {
+            old.setDropTarget(null);
+        }
+        if (c != null && c.getDropTarget() != this) {
+            c.setDropTarget(this);
+        }
+    }
+
+    public Component getComponent() {
+        return component;
+    }
+
+    public void setDefaultActions(int ops) {
+        cn1SetTargetActions(ops & (DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_REFERENCE));
+    }
+
+    /// Sets the actions without leaving any out. Not Swing API.
+    public void cn1SetTargetActions(int ops) {
+        actions = ops;
+    }
+
+    public int getDefaultActions() {
+        return actions;
+    }
+
+    public void setActive(boolean isActive) {
+        active = isActive;
+    }
+
+    public boolean isActive() {
+        return active;
+    }
+
+    public void removeDropTargetListener(DropTargetListener dtl) {
+        if (dtl != null && dtl == listener) {
+            listener = null;
+        }
+    }
+
+    @Override
+    public void dragEnter(DropTargetDragEvent dtde) {
+        if (!active) {
+            return;
+        }
+        if (listener != null) {
+            listener.dragEnter(dtde);
+        } else {
+            dtde.getDropTargetContext().setTargetActions(DnDConstants.ACTION_NONE);
+        }
+    }
+
+    @Override
+    public void dragOver(DropTargetDragEvent dtde) {
+        if (active && listener != null) {
+            listener.dragOver(dtde);
+        }
+    }
+
+    @Override
+    public void dropActionChanged(DropTargetDragEvent dtde) {
+        if (active && listener != null) {
+            listener.dropActionChanged(dtde);
+        }
+    }
+
+    @Override
+    public void dragExit(DropTargetEvent dte) {
+        if (active && listener != null) {
+            listener.dragExit(dte);
+        }
+    }
+
+    /// Hands the drop to the listener, and rejects it when the target is
+    /// not active or has none.
+    @Override
+    public void drop(DropTargetDropEvent dtde) {
+        if (listener != null && active) {
+            listener.drop(dtde);
+        } else {
+            dtde.rejectDrop();
+        }
+    }
+
+    public DropTargetContext getDropTargetContext() {
+        return context;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetAdapter.java
new file mode 100644
index 00000000000..899b284ac08
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetAdapter.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+/// A [DropTargetListener] that does nothing but for [#drop], which a
+/// subclass has to write.
+public abstract class DropTargetAdapter implements DropTargetListener {
+
+    protected DropTargetAdapter() {
+    }
+
+    @Override
+    public void dragEnter(DropTargetDragEvent dtde) {
+    }
+
+    @Override
+    public void dragOver(DropTargetDragEvent dtde) {
+    }
+
+    @Override
+    public void dropActionChanged(DropTargetDragEvent dtde) {
+    }
+
+    @Override
+    public void dragExit(DropTargetEvent dte) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetContext.java
new file mode 100644
index 00000000000..4784c3941d9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetContext.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import com.codename1.desktopcompat.rt.Dnd;
+import java.util.ArrayList;
+import java.util.List;
+
+/// What a [DropTarget] and its listener say to the drag that is over it.
+///
+/// There is one drag at a time, so every context speaks to the same one;
+/// an answer given when the context's target is not the one the drag is
+/// over is not heard.
+public class DropTargetContext {
+
+    private final DropTarget dropTarget;
+
+    DropTargetContext(DropTarget dt) {
+        dropTarget = dt;
+    }
+
+    public DropTarget getDropTarget() {
+        return dropTarget;
+    }
+
+    public Component getComponent() {
+        return dropTarget.getComponent();
+    }
+
+    /// Sets the actions the target takes, as [DropTarget#setDefaultActions].
+    protected void setTargetActions(int actions) {
+        dropTarget.cn1SetTargetActions(actions);
+    }
+
+    protected int getTargetActions() {
+        return dropTarget.getDefaultActions();
+    }
+
+    /// Reports whether the dropped data was taken.
+    ///
+    /// #### Throws
+    ///
+    /// - `InvalidDnDOperationException`: never; the class is not part of the
+    ///   layer and a report that comes when no drop is under way is ignored
+    public void dropComplete(boolean success) {
+        Dnd.complete(dropTarget, success);
+    }
+
+    protected void acceptDrag(int dragOperation) {
+        Dnd.answer(dropTarget, dragOperation);
+    }
+
+    protected void rejectDrag() {
+        Dnd.answer(dropTarget, DnDConstants.ACTION_NONE);
+    }
+
+    protected void acceptDrop(int dropOperation) {
+        Dnd.answer(dropTarget, dropOperation);
+    }
+
+    protected void rejectDrop() {
+        Dnd.answer(dropTarget, DnDConstants.ACTION_NONE);
+    }
+
+    protected DataFlavor[] getCurrentDataFlavors() {
+        Transferable t = Dnd.transferable();
+        return t == null ? new DataFlavor[0] : t.getTransferDataFlavors();
+    }
+
+    protected List<DataFlavor> getCurrentDataFlavorsAsList() {
+        DataFlavor[] all = getCurrentDataFlavors();
+        List<DataFlavor> out = new ArrayList<DataFlavor>(all.length);
+        for (DataFlavor f : all) {
+            out.add(f);
+        }
+        return out;
+    }
+
+    protected boolean isDataFlavorSupported(DataFlavor df) {
+        Transferable t = Dnd.transferable();
+        return t != null && t.isDataFlavorSupported(df);
+    }
+
+    /// The data of the drag.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalStateException`: if no drag is under way. The JDK throws its
+    ///   `InvalidDnDOperationException`, a subclass of this one
+    protected Transferable getTransferable() {
+        Transferable t = Dnd.transferable();
+        if (t == null) {
+            throw new IllegalStateException("No drag is under way");
+        }
+        return t;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetDragEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetDragEvent.java
new file mode 100644
index 00000000000..23709962e84
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetDragEvent.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import java.util.List;
+
+/// A drag that entered a [DropTarget] or moved over it.
+///
+/// A listener answers with [#acceptDrag(int)] or [#rejectDrag()]; one that
+/// does neither has accepted the action the event carries.
+public class DropTargetDragEvent extends DropTargetEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    private final Point location;
+    private final int actions;
+    private final int dropAction;
+
+    public DropTargetDragEvent(DropTargetContext dtc, Point cursorLocn, int dropAction, int srcActions) {
+        super(dtc);
+        if (cursorLocn == null) {
+            throw new NullPointerException("cursorLocn");
+        }
+        if (dropAction != DnDConstants.ACTION_NONE && dropAction != DnDConstants.ACTION_COPY
+                && dropAction != DnDConstants.ACTION_MOVE && dropAction != DnDConstants.ACTION_LINK) {
+            throw new IllegalArgumentException("dropAction" + dropAction);
+        }
+        if ((srcActions & ~(DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_LINK)) != 0) {
+            throw new IllegalArgumentException("srcActions");
+        }
+        location = cursorLocn;
+        actions = srcActions;
+        this.dropAction = dropAction;
+    }
+
+    /// Where the pointer is, in the coordinates of the target's component.
+    public Point getLocation() {
+        return location;
+    }
+
+    public DataFlavor[] getCurrentDataFlavors() {
+        return getDropTargetContext().getCurrentDataFlavors();
+    }
+
+    public List<DataFlavor> getCurrentDataFlavorsAsList() {
+        return getDropTargetContext().getCurrentDataFlavorsAsList();
+    }
+
+    public boolean isDataFlavorSupported(DataFlavor df) {
+        return getDropTargetContext().isDataFlavorSupported(df);
+    }
+
+    /// The actions the source of the drag allows.
+    public int getSourceActions() {
+        return actions;
+    }
+
+    /// The action the user asked for.
+    public int getDropAction() {
+        return dropAction;
+    }
+
+    /// The data being dragged. What a drag from another application
+    /// carries can be named while it hovers, and read once it is dropped.
+    public Transferable getTransferable() {
+        return getDropTargetContext().getTransferable();
+    }
+
+    public void acceptDrag(int dragOperation) {
+        getDropTargetContext().acceptDrag(dragOperation);
+    }
+
+    public void rejectDrag() {
+        getDropTargetContext().rejectDrag();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetDropEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetDropEvent.java
new file mode 100644
index 00000000000..91d90e283f5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetDropEvent.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import java.util.List;
+
+/// A drag that was dropped on a [DropTarget].
+///
+/// The listener calls [#acceptDrop(int)], reads the data, and reports how
+/// it went with [#dropComplete(boolean)]; or calls [#rejectDrop()].
+public class DropTargetDropEvent extends DropTargetEvent {
+
+    private static final long serialVersionUID = 1L;
+
+    private final Point location;
+    private final int actions;
+    private final int dropAction;
+    private final boolean isLocalTx;
+
+    public DropTargetDropEvent(DropTargetContext dtc, Point cursorLocn, int dropAction, int srcActions) {
+        this(dtc, cursorLocn, dropAction, srcActions, false);
+    }
+
+    public DropTargetDropEvent(DropTargetContext dtc, Point cursorLocn, int dropAction, int srcActions,
+            boolean isLocal) {
+        super(dtc);
+        if (cursorLocn == null) {
+            throw new NullPointerException("cursorLocn");
+        }
+        if (dropAction != DnDConstants.ACTION_NONE && dropAction != DnDConstants.ACTION_COPY
+                && dropAction != DnDConstants.ACTION_MOVE && dropAction != DnDConstants.ACTION_LINK) {
+            throw new IllegalArgumentException("dropAction = " + dropAction);
+        }
+        if ((srcActions & ~(DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_LINK)) != 0) {
+            throw new IllegalArgumentException("srcActions");
+        }
+        location = cursorLocn;
+        actions = srcActions;
+        this.dropAction = dropAction;
+        isLocalTx = isLocal;
+    }
+
+    /// Where the pointer was, in the coordinates of the target's component.
+    public Point getLocation() {
+        return location;
+    }
+
+    public DataFlavor[] getCurrentDataFlavors() {
+        return getDropTargetContext().getCurrentDataFlavors();
+    }
+
+    public List<DataFlavor> getCurrentDataFlavorsAsList() {
+        return getDropTargetContext().getCurrentDataFlavorsAsList();
+    }
+
+    public boolean isDataFlavorSupported(DataFlavor df) {
+        return getDropTargetContext().isDataFlavorSupported(df);
+    }
+
+    public int getSourceActions() {
+        return actions;
+    }
+
+    public int getDropAction() {
+        return dropAction;
+    }
+
+    public Transferable getTransferable() {
+        return getDropTargetContext().getTransferable();
+    }
+
+    public void acceptDrop(int dropAction) {
+        getDropTargetContext().acceptDrop(dropAction);
+    }
+
+    public void rejectDrop() {
+        getDropTargetContext().rejectDrop();
+    }
+
+    /// Reports whether the data was taken. The source of a drag that
+    /// began in this application hears of it, and so does the platform for
+    /// one that came from outside.
+    public void dropComplete(boolean success) {
+        getDropTargetContext().dropComplete(success);
+    }
+
+    /// Whether the drag began in this application.
+    public boolean isLocalTransfer() {
+        return isLocalTx;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetEvent.java
new file mode 100644
index 00000000000..c09e4d57e78
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetEvent.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+import java.util.EventObject;
+
+/// What the events of a [DropTarget] have in common: the context of the
+/// target they are about.
+public class DropTargetEvent extends EventObject {
+
+    private static final long serialVersionUID = 1L;
+
+    protected DropTargetContext context;
+
+    public DropTargetEvent(DropTargetContext dtc) {
+        super(dtc.getDropTarget());
+        context = dtc;
+    }
+
+    public DropTargetContext getDropTargetContext() {
+        return context;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetListener.java
new file mode 100644
index 00000000000..2a1379c1cb3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/DropTargetListener.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.dnd;
+
+import java.util.EventListener;
+
+/// Hears of a drag as it enters, moves over and leaves a [DropTarget], and
+/// of the drop.
+public interface DropTargetListener extends EventListener {
+
+    /// The pointer came over the target with a drag.
+    void dragEnter(DropTargetDragEvent dtde);
+
+    /// The pointer moved, still over the target.
+    void dragOver(DropTargetDragEvent dtde);
+
+    /// The user changed what the drag would do. Never called: an action
+    /// that changed is reported with the next [#dragOver].
+    void dropActionChanged(DropTargetDragEvent dtde);
+
+    /// The pointer left the target, or the drag was given up.
+    void dragExit(DropTargetEvent dte);
+
+    /// The drag was dropped on the target.
+    void drop(DropTargetDropEvent dtde);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/package-info.java
new file mode 100644
index 00000000000..244d5de32f6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/dnd/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Drop targets: the components of an application that a drag can be
+/// dropped on, and what they are told of it.
+package com.codename1.desktopcompat.java.awt.dnd;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AWTEventListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AWTEventListener.java
new file mode 100644
index 00000000000..c41b82793ef
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AWTEventListener.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import java.util.EventListener;
+
+/// Hears of the events dispatched to every component of the application,
+/// before the component itself does. Added with
+/// `Toolkit.addAWTEventListener`.
+public interface AWTEventListener extends EventListener {
+
+    void eventDispatched(AWTEvent event);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ActionEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ActionEvent.java
new file mode 100644
index 00000000000..cf304f1f0af
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ActionEvent.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+
+/// A component-defined action happened, such as a button being pressed.
+public class ActionEvent extends AWTEvent {
+
+    public static final int SHIFT_MASK = 1;
+
+    public static final int CTRL_MASK = 2;
+
+    public static final int META_MASK = 4;
+
+    public static final int ALT_MASK = 8;
+
+    public static final int ACTION_FIRST = 1001;
+
+    public static final int ACTION_LAST = 1001;
+
+    public static final int ACTION_PERFORMED = 1001;
+
+    private final String actionCommand;
+
+    private final long when;
+
+    private final int modifiers;
+
+    public ActionEvent(Object source, int id, String command) {
+        this(source, id, command, 0);
+    }
+
+    public ActionEvent(Object source, int id, String command, int modifiers) {
+        this(source, id, command, 0L, modifiers);
+    }
+
+    public ActionEvent(Object source, int id, String command, long when, int modifiers) {
+        super(source, id);
+        this.actionCommand = command;
+        this.when = when;
+        this.modifiers = modifiers;
+    }
+
+    public String getActionCommand() {
+        return actionCommand;
+    }
+
+    public long getWhen() {
+        return when;
+    }
+
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case ACTION_PERFORMED:
+                typeStr = "ACTION_PERFORMED";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        return typeStr + ",cmd=" + actionCommand + ",when=" + when + ",modifiers="
+                + KeyEvent.getKeyModifiersText(modifiers);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ActionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ActionListener.java
new file mode 100644
index 00000000000..4ac3b4ec9f1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ActionListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives action events.
+public interface ActionListener extends EventListener {
+
+    void actionPerformed(ActionEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AdjustmentEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AdjustmentEvent.java
new file mode 100644
index 00000000000..b1629d8ac78
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AdjustmentEvent.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Adjustable;
+
+/// An adjustable value, such as a scroll bar position, changed.
+public class AdjustmentEvent extends AWTEvent {
+
+    public static final int ADJUSTMENT_FIRST = 601;
+
+    public static final int ADJUSTMENT_LAST = 601;
+
+    public static final int ADJUSTMENT_VALUE_CHANGED = 601;
+
+    public static final int UNIT_INCREMENT = 1;
+
+    public static final int UNIT_DECREMENT = 2;
+
+    public static final int BLOCK_DECREMENT = 3;
+
+    public static final int BLOCK_INCREMENT = 4;
+
+    public static final int TRACK = 5;
+
+    private final int adjustmentType;
+
+    private final int value;
+
+    private final boolean isAdjusting;
+
+    public AdjustmentEvent(Adjustable source, int id, int type, int value) {
+        this(source, id, type, value, false);
+    }
+
+    public AdjustmentEvent(Adjustable source, int id, int type, int value, boolean isAdjusting) {
+        super(source, id);
+        this.adjustmentType = type;
+        this.value = value;
+        this.isAdjusting = isAdjusting;
+    }
+
+    public Adjustable getAdjustable() {
+        return source instanceof Adjustable ? (Adjustable) source : null;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public int getAdjustmentType() {
+        return adjustmentType;
+    }
+
+    public boolean getValueIsAdjusting() {
+        return isAdjusting;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case ADJUSTMENT_VALUE_CHANGED:
+                typeStr = "ADJUSTMENT_VALUE_CHANGED";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        String adjTypeStr;
+        switch (adjustmentType) {
+            case UNIT_INCREMENT:
+                adjTypeStr = "UNIT_INCREMENT";
+                break;
+            case UNIT_DECREMENT:
+                adjTypeStr = "UNIT_DECREMENT";
+                break;
+            case BLOCK_INCREMENT:
+                adjTypeStr = "BLOCK_INCREMENT";
+                break;
+            case BLOCK_DECREMENT:
+                adjTypeStr = "BLOCK_DECREMENT";
+                break;
+            case TRACK:
+                adjTypeStr = "TRACK";
+                break;
+            default:
+                adjTypeStr = "unknown type";
+                break;
+        }
+        return typeStr + ",adjType=" + adjTypeStr + ",value=" + value + ",isAdjusting=" + isAdjusting;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AdjustmentListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AdjustmentListener.java
new file mode 100644
index 00000000000..ef8a07a7679
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/AdjustmentListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives adjustment events.
+public interface AdjustmentListener extends EventListener {
+
+    void adjustmentValueChanged(AdjustmentEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentAdapter.java
new file mode 100644
index 00000000000..4df28b0e0dc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentAdapter.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A `ComponentListener` whose methods do nothing, to be subclassed for the
+/// few events of interest.
+public abstract class ComponentAdapter implements ComponentListener {
+
+    public void componentResized(ComponentEvent e) {
+    }
+
+    public void componentMoved(ComponentEvent e) {
+    }
+
+    public void componentShown(ComponentEvent e) {
+    }
+
+    public void componentHidden(ComponentEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentEvent.java
new file mode 100644
index 00000000000..31d255dcb44
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentEvent.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+
+/// A component was moved, resized, shown or hidden.
+public class ComponentEvent extends AWTEvent {
+
+    public static final int COMPONENT_FIRST = 100;
+
+    public static final int COMPONENT_LAST = 103;
+
+    public static final int COMPONENT_MOVED = 100;
+
+    public static final int COMPONENT_RESIZED = 101;
+
+    public static final int COMPONENT_SHOWN = 102;
+
+    public static final int COMPONENT_HIDDEN = 103;
+
+    public ComponentEvent(Component source, int id) {
+        super(source, id);
+    }
+
+    public Component getComponent() {
+        return source instanceof Component ? (Component) source : null;
+    }
+
+    @Override
+    public String paramString() {
+        String type;
+        Component c = getComponent();
+        Rectangle b = c == null ? new Rectangle() : c.getBounds();
+        switch (id) {
+            case COMPONENT_SHOWN:
+                type = "COMPONENT_SHOWN";
+                break;
+            case COMPONENT_HIDDEN:
+                type = "COMPONENT_HIDDEN";
+                break;
+            case COMPONENT_MOVED:
+                type = "COMPONENT_MOVED (" + b.x + "," + b.y + " " + b.width + "x" + b.height + ")";
+                break;
+            case COMPONENT_RESIZED:
+                type = "COMPONENT_RESIZED (" + b.x + "," + b.y + " " + b.width + "x" + b.height + ")";
+                break;
+            default:
+                type = "unknown type";
+                break;
+        }
+        return type;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentListener.java
new file mode 100644
index 00000000000..f287d6e7dff
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ComponentListener.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of a component being moved, resized, shown or hidden.
+public interface ComponentListener extends EventListener {
+
+    void componentResized(ComponentEvent e);
+
+    void componentMoved(ComponentEvent e);
+
+    void componentShown(ComponentEvent e);
+
+    void componentHidden(ComponentEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerAdapter.java
new file mode 100644
index 00000000000..4b83a1bfee8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A `ContainerListener` whose methods do nothing, to be subclassed for the
+/// few events of interest.
+public abstract class ContainerAdapter implements ContainerListener {
+
+    public void componentAdded(ContainerEvent e) {
+    }
+
+    public void componentRemoved(ContainerEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerEvent.java
new file mode 100644
index 00000000000..6508a89bd84
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerEvent.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+
+/// A component was added to or removed from a container.
+public class ContainerEvent extends ComponentEvent {
+
+    public static final int CONTAINER_FIRST = 300;
+
+    public static final int CONTAINER_LAST = 301;
+
+    public static final int COMPONENT_ADDED = 300;
+
+    public static final int COMPONENT_REMOVED = 301;
+
+    private final Component child;
+
+    public ContainerEvent(Component source, int id, Component child) {
+        super(source, id);
+        this.child = child;
+    }
+
+    public Container getContainer() {
+        return source instanceof Container ? (Container) source : null;
+    }
+
+    public Component getChild() {
+        return child;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case COMPONENT_ADDED:
+                typeStr = "COMPONENT_ADDED";
+                break;
+            case COMPONENT_REMOVED:
+                typeStr = "COMPONENT_REMOVED";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        return typeStr + ",child=" + child;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerListener.java
new file mode 100644
index 00000000000..0dead4cddbc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ContainerListener.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of components being added to or removed from a
+/// container.
+public interface ContainerListener extends EventListener {
+
+    void componentAdded(ContainerEvent e);
+
+    void componentRemoved(ContainerEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusAdapter.java
new file mode 100644
index 00000000000..74da537badc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A `FocusListener` whose methods do nothing, to be subclassed for the few
+/// events of interest.
+public abstract class FocusAdapter implements FocusListener {
+
+    public void focusGained(FocusEvent e) {
+    }
+
+    public void focusLost(FocusEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusEvent.java
new file mode 100644
index 00000000000..558130f9a2e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusEvent.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// A component gained or lost the keyboard focus.
+///
+/// The JDK 9 `Cause` of a focus change is not provided.
+public class FocusEvent extends ComponentEvent {
+
+    public static final int FOCUS_FIRST = 1004;
+
+    public static final int FOCUS_LAST = 1005;
+
+    public static final int FOCUS_GAINED = 1004;
+
+    public static final int FOCUS_LOST = 1005;
+
+    private final boolean temporary;
+
+    private final Component opposite;
+
+    public FocusEvent(Component source, int id, boolean temporary, Component opposite) {
+        super(source, id);
+        this.temporary = temporary;
+        this.opposite = opposite;
+    }
+
+    public FocusEvent(Component source, int id, boolean temporary) {
+        this(source, id, temporary, null);
+    }
+
+    public FocusEvent(Component source, int id) {
+        this(source, id, false);
+    }
+
+    public boolean isTemporary() {
+        return temporary;
+    }
+
+    public Component getOppositeComponent() {
+        return opposite;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case FOCUS_GAINED:
+                typeStr = "FOCUS_GAINED";
+                break;
+            case FOCUS_LOST:
+                typeStr = "FOCUS_LOST";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        return typeStr + (temporary ? ",temporary" : ",permanent") + ",opposite=" + opposite;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusListener.java
new file mode 100644
index 00000000000..290ac855adc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/FocusListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of a component gaining or losing the keyboard focus.
+public interface FocusListener extends EventListener {
+
+    void focusGained(FocusEvent e);
+
+    void focusLost(FocusEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/HierarchyEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/HierarchyEvent.java
new file mode 100644
index 00000000000..f76f12498d5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/HierarchyEvent.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+
+/// The hierarchy a component belongs to changed: a parent was swapped, or
+/// the component became displayable or showing.
+public class HierarchyEvent extends AWTEvent {
+
+    public static final int HIERARCHY_FIRST = 1400;
+
+    public static final int HIERARCHY_CHANGED = 1400;
+
+    public static final int ANCESTOR_MOVED = 1401;
+
+    public static final int ANCESTOR_RESIZED = 1402;
+
+    public static final int HIERARCHY_LAST = 1402;
+
+    public static final int PARENT_CHANGED = 0x1;
+
+    public static final int DISPLAYABILITY_CHANGED = 0x2;
+
+    public static final int SHOWING_CHANGED = 0x4;
+
+    private final Component changed;
+
+    private final Container changedParent;
+
+    private final long changeFlags;
+
+    public HierarchyEvent(Component source, int id, Component changed, Container changedParent) {
+        this(source, id, changed, changedParent, 0L);
+    }
+
+    public HierarchyEvent(Component source, int id, Component changed, Container changedParent,
+            long changeFlags) {
+        super(source, id);
+        this.changed = changed;
+        this.changedParent = changedParent;
+        this.changeFlags = changeFlags;
+    }
+
+    public Component getComponent() {
+        return source instanceof Component ? (Component) source : null;
+    }
+
+    public Component getChanged() {
+        return changed;
+    }
+
+    public Container getChangedParent() {
+        return changedParent;
+    }
+
+    public long getChangeFlags() {
+        return changeFlags;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case ANCESTOR_MOVED:
+                typeStr = "ANCESTOR_MOVED (" + changed + "," + changedParent + ")";
+                break;
+            case ANCESTOR_RESIZED:
+                typeStr = "ANCESTOR_RESIZED (" + changed + "," + changedParent + ")";
+                break;
+            case HIERARCHY_CHANGED:
+                typeStr = "HIERARCHY_CHANGED (" + changed + "," + changedParent + ")";
+                if ((changeFlags & PARENT_CHANGED) != 0) {
+                    typeStr += ",PARENT_CHANGED";
+                }
+                if ((changeFlags & DISPLAYABILITY_CHANGED) != 0) {
+                    typeStr += ",DISPLAYABILITY_CHANGED";
+                }
+                if ((changeFlags & SHOWING_CHANGED) != 0) {
+                    typeStr += ",SHOWING_CHANGED";
+                }
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        return typeStr;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/HierarchyListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/HierarchyListener.java
new file mode 100644
index 00000000000..84a697892df
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/HierarchyListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of the hierarchy a component belongs to changing.
+public interface HierarchyListener extends EventListener {
+
+    void hierarchyChanged(HierarchyEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/InputEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/InputEvent.java
new file mode 100644
index 00000000000..cc627c66c64
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/InputEvent.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// The root of the events that come from the keyboard and the mouse.
+///
+/// Modifiers exist in two encodings: the old masks (`SHIFT_MASK`, ...) and the
+/// extended "down" masks (`SHIFT_DOWN_MASK`, ...). Like the JDK, the key and
+/// mouse event constructors accept either and keep both, so `getModifiers()`
+/// and `getModifiersEx()` answer for the same event.
+public abstract class InputEvent extends ComponentEvent {
+
+    public static final int SHIFT_MASK = 1;
+
+    public static final int CTRL_MASK = 2;
+
+    public static final int META_MASK = 4;
+
+    public static final int ALT_MASK = 8;
+
+    public static final int ALT_GRAPH_MASK = 32;
+
+    public static final int BUTTON1_MASK = 16;
+
+    public static final int BUTTON2_MASK = 8;
+
+    public static final int BUTTON3_MASK = 4;
+
+    public static final int SHIFT_DOWN_MASK = 64;
+
+    public static final int CTRL_DOWN_MASK = 128;
+
+    public static final int META_DOWN_MASK = 256;
+
+    public static final int ALT_DOWN_MASK = 512;
+
+    public static final int BUTTON1_DOWN_MASK = 1024;
+
+    public static final int BUTTON2_DOWN_MASK = 2048;
+
+    public static final int BUTTON3_DOWN_MASK = 4096;
+
+    public static final int ALT_GRAPH_DOWN_MASK = 8192;
+
+    /// The old encoding occupies the bits below `SHIFT_DOWN_MASK`.
+    static final int JDK_1_3_MODIFIERS = SHIFT_DOWN_MASK - 1;
+
+    /// Bits from the fourteenth up are the extra mouse buttons, which have no
+    /// old encoding.
+    static final int HIGH_MODIFIERS = ~((1 << 14) - 1);
+
+    private static final int BUTTON_COUNT = 20;
+
+    private final long when;
+
+    int modifiers;
+
+    InputEvent(Component source, int id, long when, int modifiers) {
+        super(source, id);
+        this.when = when;
+        this.modifiers = modifiers;
+    }
+
+    /// Fills in whichever encoding of the modifiers the caller left out.
+    static int normalize(int m, boolean mouse) {
+        boolean old = (m & (JDK_1_3_MODIFIERS | HIGH_MODIFIERS)) != 0;
+        boolean extended = (m & ~JDK_1_3_MODIFIERS) != 0;
+        int r = m;
+        if (old && !extended) {
+            if ((m & SHIFT_MASK) != 0) {
+                r |= SHIFT_DOWN_MASK;
+            }
+            if ((m & CTRL_MASK) != 0) {
+                r |= CTRL_DOWN_MASK;
+            }
+            if ((m & ALT_GRAPH_MASK) != 0) {
+                r |= ALT_GRAPH_DOWN_MASK;
+            }
+            if (mouse) {
+                if ((m & BUTTON1_MASK) != 0) {
+                    r |= BUTTON1_DOWN_MASK;
+                }
+                if ((m & BUTTON2_MASK) != 0) {
+                    r |= BUTTON2_DOWN_MASK;
+                }
+                if ((m & BUTTON3_MASK) != 0) {
+                    r |= BUTTON3_DOWN_MASK;
+                }
+            } else {
+                if ((m & ALT_MASK) != 0) {
+                    r |= ALT_DOWN_MASK;
+                }
+                if ((m & META_MASK) != 0) {
+                    r |= META_DOWN_MASK;
+                }
+            }
+        } else if (extended && !old) {
+            if ((m & SHIFT_DOWN_MASK) != 0) {
+                r |= SHIFT_MASK;
+            }
+            if ((m & CTRL_DOWN_MASK) != 0) {
+                r |= CTRL_MASK;
+            }
+            if ((m & ALT_GRAPH_DOWN_MASK) != 0) {
+                r |= ALT_GRAPH_MASK;
+            }
+            if ((m & ALT_DOWN_MASK) != 0) {
+                r |= ALT_MASK;
+            }
+            if ((m & META_DOWN_MASK) != 0) {
+                r |= META_MASK;
+            }
+            if (mouse) {
+                if ((m & BUTTON1_DOWN_MASK) != 0) {
+                    r |= BUTTON1_MASK;
+                }
+                if ((m & BUTTON2_DOWN_MASK) != 0) {
+                    r |= BUTTON2_MASK;
+                }
+                if ((m & BUTTON3_DOWN_MASK) != 0) {
+                    r |= BUTTON3_MASK;
+                }
+            }
+        }
+        return r;
+    }
+
+    private static int buttonMask(int index) {
+        if (index == 0) {
+            return BUTTON1_DOWN_MASK;
+        }
+        if (index == 1) {
+            return BUTTON2_DOWN_MASK;
+        }
+        if (index == 2) {
+            return BUTTON3_DOWN_MASK;
+        }
+        return 1 << (11 + index);
+    }
+
+    public boolean isShiftDown() {
+        return (modifiers & SHIFT_DOWN_MASK) != 0;
+    }
+
+    public boolean isControlDown() {
+        return (modifiers & CTRL_DOWN_MASK) != 0;
+    }
+
+    public boolean isMetaDown() {
+        return (modifiers & META_DOWN_MASK) != 0;
+    }
+
+    public boolean isAltDown() {
+        return (modifiers & ALT_DOWN_MASK) != 0;
+    }
+
+    public boolean isAltGraphDown() {
+        return (modifiers & ALT_GRAPH_DOWN_MASK) != 0;
+    }
+
+    public long getWhen() {
+        return when;
+    }
+
+    public int getModifiers() {
+        return modifiers & (JDK_1_3_MODIFIERS | HIGH_MODIFIERS);
+    }
+
+    public int getModifiersEx() {
+        return modifiers & ~JDK_1_3_MODIFIERS;
+    }
+
+    @Override
+    public void consume() {
+        consumed = true;
+    }
+
+    @Override
+    public boolean isConsumed() {
+        return consumed;
+    }
+
+    /// The extended mask of a mouse button, counting from one.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if the button number is not positive or
+    ///   beyond the twenty buttons supported
+    public static int getMaskForButton(int button) {
+        if (button <= 0 || button > BUTTON_COUNT) {
+            throw new IllegalArgumentException("button doesn't exist " + button);
+        }
+        return buttonMask(button - 1);
+    }
+
+    public static String getModifiersExText(int modifiers) {
+        StringBuilder buf = new StringBuilder();
+        if ((modifiers & META_DOWN_MASK) != 0) {
+            add(buf, "Meta");
+        }
+        if ((modifiers & CTRL_DOWN_MASK) != 0) {
+            add(buf, "Ctrl");
+        }
+        if ((modifiers & ALT_DOWN_MASK) != 0) {
+            add(buf, "Alt");
+        }
+        if ((modifiers & SHIFT_DOWN_MASK) != 0) {
+            add(buf, "Shift");
+        }
+        if ((modifiers & ALT_GRAPH_DOWN_MASK) != 0) {
+            add(buf, "Alt Graph");
+        }
+        for (int i = 0; i < BUTTON_COUNT; i++) {
+            if ((modifiers & buttonMask(i)) != 0) {
+                add(buf, "Button" + (i + 1));
+            }
+        }
+        return buf.toString();
+    }
+
+    private static void add(StringBuilder buf, String name) {
+        if (buf.length() > 0) {
+            buf.append('+');
+        }
+        buf.append(name);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/InvocationEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/InvocationEvent.java
new file mode 100644
index 00000000000..19f3f360dd4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/InvocationEvent.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.ActiveEvent;
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+
+/// An event that runs a `Runnable` when it is dispatched.
+///
+/// The user interface is single threaded here, so the notifier of the JDK
+/// constructors is accepted but nobody waits on it.
+public class InvocationEvent extends AWTEvent implements ActiveEvent {
+
+    public static final int INVOCATION_FIRST = 1200;
+
+    public static final int INVOCATION_DEFAULT = 1200;
+
+    public static final int INVOCATION_LAST = 1200;
+
+    private final Runnable runnable;
+
+    private final boolean catchExceptions;
+
+    private final long when;
+
+    private Throwable throwable;
+
+    public InvocationEvent(Object source, Runnable runnable) {
+        this(source, INVOCATION_DEFAULT, runnable, null, false);
+    }
+
+    public InvocationEvent(Object source, Runnable runnable, Object notifier, boolean catchThrowables) {
+        this(source, INVOCATION_DEFAULT, runnable, notifier, catchThrowables);
+    }
+
+    protected InvocationEvent(Object source, int id, Runnable runnable, Object notifier,
+            boolean catchThrowables) {
+        super(source, id);
+        this.runnable = runnable;
+        this.catchExceptions = catchThrowables;
+        this.when = System.currentTimeMillis();
+    }
+
+    public void dispatch() {
+        if (catchExceptions) {
+            try {
+                runnable.run();
+            } catch (Throwable t) {
+                throwable = t;
+            }
+        } else {
+            runnable.run();
+        }
+    }
+
+    public Exception getException() {
+        return catchExceptions && throwable instanceof Exception ? (Exception) throwable : null;
+    }
+
+    public Throwable getThrowable() {
+        return catchExceptions ? throwable : null;
+    }
+
+    public long getWhen() {
+        return when;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case INVOCATION_DEFAULT:
+                typeStr = "INVOCATION_DEFAULT";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        return typeStr + ",runnable=" + runnable + ",when=" + when;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ItemEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ItemEvent.java
new file mode 100644
index 00000000000..f4ed8e2409d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ItemEvent.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.ItemSelectable;
+
+/// An item was selected or deselected.
+public class ItemEvent extends AWTEvent {
+
+    public static final int ITEM_FIRST = 701;
+
+    public static final int ITEM_LAST = 701;
+
+    public static final int ITEM_STATE_CHANGED = 701;
+
+    public static final int SELECTED = 1;
+
+    public static final int DESELECTED = 2;
+
+    private final Object item;
+
+    private final int stateChange;
+
+    public ItemEvent(ItemSelectable source, int id, Object item, int stateChange) {
+        super(source, id);
+        this.item = item;
+        this.stateChange = stateChange;
+    }
+
+    public ItemSelectable getItemSelectable() {
+        return source instanceof ItemSelectable ? (ItemSelectable) source : null;
+    }
+
+    public Object getItem() {
+        return item;
+    }
+
+    public int getStateChange() {
+        return stateChange;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case ITEM_STATE_CHANGED:
+                typeStr = "ITEM_STATE_CHANGED";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        String stateStr;
+        switch (stateChange) {
+            case SELECTED:
+                stateStr = "SELECTED";
+                break;
+            case DESELECTED:
+                stateStr = "DESELECTED";
+                break;
+            default:
+                stateStr = "unknown type";
+                break;
+        }
+        return typeStr + ",item=" + item + ",stateChange=" + stateStr;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ItemListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ItemListener.java
new file mode 100644
index 00000000000..6c8984f08e7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/ItemListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives item selection events.
+public interface ItemListener extends EventListener {
+
+    void itemStateChanged(ItemEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyAdapter.java
new file mode 100644
index 00000000000..4f006b00312
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyAdapter.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A `KeyListener` whose methods do nothing, to be subclassed for the few
+/// events of interest.
+public abstract class KeyAdapter implements KeyListener {
+
+    public void keyTyped(KeyEvent e) {
+    }
+
+    public void keyPressed(KeyEvent e) {
+    }
+
+    public void keyReleased(KeyEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyEvent.java
new file mode 100644
index 00000000000..904005dbb5b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyEvent.java
@@ -0,0 +1,1013 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// A keyboard event: a key was pressed, released or typed.
+///
+/// Key texts are English; the JDK looks them up in a localized resource
+/// bundle. The `FocusEvent` style cause and the input-method related members
+/// of the JDK class are not provided.
+public class KeyEvent extends InputEvent {
+
+    public static final int KEY_FIRST = 400;
+
+    public static final int KEY_LAST = 402;
+
+    public static final int KEY_TYPED = 400;
+
+    public static final int KEY_PRESSED = 401;
+
+    public static final int KEY_RELEASED = 402;
+
+    public static final char CHAR_UNDEFINED = 0xFFFF;
+
+    public static final int KEY_LOCATION_UNKNOWN = 0;
+
+    public static final int KEY_LOCATION_STANDARD = 1;
+
+    public static final int KEY_LOCATION_LEFT = 2;
+
+    public static final int KEY_LOCATION_RIGHT = 3;
+
+    public static final int KEY_LOCATION_NUMPAD = 4;
+
+    private static final int EXTENDED_FLAG = 0x01000000;
+
+    public static final int VK_UNDEFINED = 0x0;
+
+    public static final int VK_CANCEL = 0x3;
+
+    public static final int VK_BACK_SPACE = 0x8;
+
+    public static final int VK_TAB = 0x9;
+
+    public static final int VK_ENTER = 0xA;
+
+    public static final int VK_CLEAR = 0xC;
+
+    public static final int VK_SHIFT = 0x10;
+
+    public static final int VK_CONTROL = 0x11;
+
+    public static final int VK_ALT = 0x12;
+
+    public static final int VK_PAUSE = 0x13;
+
+    public static final int VK_CAPS_LOCK = 0x14;
+
+    public static final int VK_KANA = 0x15;
+
+    public static final int VK_FINAL = 0x18;
+
+    public static final int VK_KANJI = 0x19;
+
+    public static final int VK_ESCAPE = 0x1B;
+
+    public static final int VK_CONVERT = 0x1C;
+
+    public static final int VK_NONCONVERT = 0x1D;
+
+    public static final int VK_ACCEPT = 0x1E;
+
+    public static final int VK_MODECHANGE = 0x1F;
+
+    public static final int VK_SPACE = 0x20;
+
+    public static final int VK_PAGE_UP = 0x21;
+
+    public static final int VK_PAGE_DOWN = 0x22;
+
+    public static final int VK_END = 0x23;
+
+    public static final int VK_HOME = 0x24;
+
+    public static final int VK_LEFT = 0x25;
+
+    public static final int VK_UP = 0x26;
+
+    public static final int VK_RIGHT = 0x27;
+
+    public static final int VK_DOWN = 0x28;
+
+    public static final int VK_COMMA = 0x2C;
+
+    public static final int VK_MINUS = 0x2D;
+
+    public static final int VK_PERIOD = 0x2E;
+
+    public static final int VK_SLASH = 0x2F;
+
+    public static final int VK_0 = 0x30;
+
+    public static final int VK_1 = 0x31;
+
+    public static final int VK_2 = 0x32;
+
+    public static final int VK_3 = 0x33;
+
+    public static final int VK_4 = 0x34;
+
+    public static final int VK_5 = 0x35;
+
+    public static final int VK_6 = 0x36;
+
+    public static final int VK_7 = 0x37;
+
+    public static final int VK_8 = 0x38;
+
+    public static final int VK_9 = 0x39;
+
+    public static final int VK_SEMICOLON = 0x3B;
+
+    public static final int VK_EQUALS = 0x3D;
+
+    public static final int VK_A = 0x41;
+
+    public static final int VK_B = 0x42;
+
+    public static final int VK_C = 0x43;
+
+    public static final int VK_D = 0x44;
+
+    public static final int VK_E = 0x45;
+
+    public static final int VK_F = 0x46;
+
+    public static final int VK_G = 0x47;
+
+    public static final int VK_H = 0x48;
+
+    public static final int VK_I = 0x49;
+
+    public static final int VK_J = 0x4A;
+
+    public static final int VK_K = 0x4B;
+
+    public static final int VK_L = 0x4C;
+
+    public static final int VK_M = 0x4D;
+
+    public static final int VK_N = 0x4E;
+
+    public static final int VK_O = 0x4F;
+
+    public static final int VK_P = 0x50;
+
+    public static final int VK_Q = 0x51;
+
+    public static final int VK_R = 0x52;
+
+    public static final int VK_S = 0x53;
+
+    public static final int VK_T = 0x54;
+
+    public static final int VK_U = 0x55;
+
+    public static final int VK_V = 0x56;
+
+    public static final int VK_W = 0x57;
+
+    public static final int VK_X = 0x58;
+
+    public static final int VK_Y = 0x59;
+
+    public static final int VK_Z = 0x5A;
+
+    public static final int VK_OPEN_BRACKET = 0x5B;
+
+    public static final int VK_BACK_SLASH = 0x5C;
+
+    public static final int VK_CLOSE_BRACKET = 0x5D;
+
+    public static final int VK_NUMPAD0 = 0x60;
+
+    public static final int VK_NUMPAD1 = 0x61;
+
+    public static final int VK_NUMPAD2 = 0x62;
+
+    public static final int VK_NUMPAD3 = 0x63;
+
+    public static final int VK_NUMPAD4 = 0x64;
+
+    public static final int VK_NUMPAD5 = 0x65;
+
+    public static final int VK_NUMPAD6 = 0x66;
+
+    public static final int VK_NUMPAD7 = 0x67;
+
+    public static final int VK_NUMPAD8 = 0x68;
+
+    public static final int VK_NUMPAD9 = 0x69;
+
+    public static final int VK_MULTIPLY = 0x6A;
+
+    public static final int VK_ADD = 0x6B;
+
+    public static final int VK_SEPARATER = 0x6C;
+
+    public static final int VK_SEPARATOR = 0x6C;
+
+    public static final int VK_SUBTRACT = 0x6D;
+
+    public static final int VK_DECIMAL = 0x6E;
+
+    public static final int VK_DIVIDE = 0x6F;
+
+    public static final int VK_F1 = 0x70;
+
+    public static final int VK_F2 = 0x71;
+
+    public static final int VK_F3 = 0x72;
+
+    public static final int VK_F4 = 0x73;
+
+    public static final int VK_F5 = 0x74;
+
+    public static final int VK_F6 = 0x75;
+
+    public static final int VK_F7 = 0x76;
+
+    public static final int VK_F8 = 0x77;
+
+    public static final int VK_F9 = 0x78;
+
+    public static final int VK_F10 = 0x79;
+
+    public static final int VK_F11 = 0x7A;
+
+    public static final int VK_F12 = 0x7B;
+
+    public static final int VK_DELETE = 0x7F;
+
+    public static final int VK_DEAD_GRAVE = 0x80;
+
+    public static final int VK_DEAD_ACUTE = 0x81;
+
+    public static final int VK_DEAD_CIRCUMFLEX = 0x82;
+
+    public static final int VK_DEAD_TILDE = 0x83;
+
+    public static final int VK_DEAD_MACRON = 0x84;
+
+    public static final int VK_DEAD_BREVE = 0x85;
+
+    public static final int VK_DEAD_ABOVEDOT = 0x86;
+
+    public static final int VK_DEAD_DIAERESIS = 0x87;
+
+    public static final int VK_DEAD_ABOVERING = 0x88;
+
+    public static final int VK_DEAD_DOUBLEACUTE = 0x89;
+
+    public static final int VK_DEAD_CARON = 0x8A;
+
+    public static final int VK_DEAD_CEDILLA = 0x8B;
+
+    public static final int VK_DEAD_OGONEK = 0x8C;
+
+    public static final int VK_DEAD_IOTA = 0x8D;
+
+    public static final int VK_DEAD_VOICED_SOUND = 0x8E;
+
+    public static final int VK_DEAD_SEMIVOICED_SOUND = 0x8F;
+
+    public static final int VK_NUM_LOCK = 0x90;
+
+    public static final int VK_SCROLL_LOCK = 0x91;
+
+    public static final int VK_AMPERSAND = 0x96;
+
+    public static final int VK_ASTERISK = 0x97;
+
+    public static final int VK_QUOTEDBL = 0x98;
+
+    public static final int VK_LESS = 0x99;
+
+    public static final int VK_PRINTSCREEN = 0x9A;
+
+    public static final int VK_INSERT = 0x9B;
+
+    public static final int VK_HELP = 0x9C;
+
+    public static final int VK_META = 0x9D;
+
+    public static final int VK_GREATER = 0xA0;
+
+    public static final int VK_BRACELEFT = 0xA1;
+
+    public static final int VK_BRACERIGHT = 0xA2;
+
+    public static final int VK_BACK_QUOTE = 0xC0;
+
+    public static final int VK_QUOTE = 0xDE;
+
+    public static final int VK_KP_UP = 0xE0;
+
+    public static final int VK_KP_DOWN = 0xE1;
+
+    public static final int VK_KP_LEFT = 0xE2;
+
+    public static final int VK_KP_RIGHT = 0xE3;
+
+    public static final int VK_ALPHANUMERIC = 0xF0;
+
+    public static final int VK_KATAKANA = 0xF1;
+
+    public static final int VK_HIRAGANA = 0xF2;
+
+    public static final int VK_FULL_WIDTH = 0xF3;
+
+    public static final int VK_HALF_WIDTH = 0xF4;
+
+    public static final int VK_ROMAN_CHARACTERS = 0xF5;
+
+    public static final int VK_ALL_CANDIDATES = 0x100;
+
+    public static final int VK_PREVIOUS_CANDIDATE = 0x101;
+
+    public static final int VK_CODE_INPUT = 0x102;
+
+    public static final int VK_JAPANESE_KATAKANA = 0x103;
+
+    public static final int VK_JAPANESE_HIRAGANA = 0x104;
+
+    public static final int VK_JAPANESE_ROMAN = 0x105;
+
+    public static final int VK_KANA_LOCK = 0x106;
+
+    public static final int VK_INPUT_METHOD_ON_OFF = 0x107;
+
+    public static final int VK_AT = 0x200;
+
+    public static final int VK_COLON = 0x201;
+
+    public static final int VK_CIRCUMFLEX = 0x202;
+
+    public static final int VK_DOLLAR = 0x203;
+
+    public static final int VK_EURO_SIGN = 0x204;
+
+    public static final int VK_EXCLAMATION_MARK = 0x205;
+
+    public static final int VK_INVERTED_EXCLAMATION_MARK = 0x206;
+
+    public static final int VK_LEFT_PARENTHESIS = 0x207;
+
+    public static final int VK_NUMBER_SIGN = 0x208;
+
+    public static final int VK_PLUS = 0x209;
+
+    public static final int VK_RIGHT_PARENTHESIS = 0x20A;
+
+    public static final int VK_UNDERSCORE = 0x20B;
+
+    public static final int VK_WINDOWS = 0x20C;
+
+    public static final int VK_CONTEXT_MENU = 0x20D;
+
+    public static final int VK_F13 = 0xF000;
+
+    public static final int VK_F14 = 0xF001;
+
+    public static final int VK_F15 = 0xF002;
+
+    public static final int VK_F16 = 0xF003;
+
+    public static final int VK_F17 = 0xF004;
+
+    public static final int VK_F18 = 0xF005;
+
+    public static final int VK_F19 = 0xF006;
+
+    public static final int VK_F20 = 0xF007;
+
+    public static final int VK_F21 = 0xF008;
+
+    public static final int VK_F22 = 0xF009;
+
+    public static final int VK_F23 = 0xF00A;
+
+    public static final int VK_F24 = 0xF00B;
+
+    public static final int VK_COMPOSE = 0xFF20;
+
+    public static final int VK_BEGIN = 0xFF58;
+
+    public static final int VK_ALT_GRAPH = 0xFF7E;
+
+    public static final int VK_STOP = 0xFFC8;
+
+    public static final int VK_AGAIN = 0xFFC9;
+
+    public static final int VK_PROPS = 0xFFCA;
+
+    public static final int VK_UNDO = 0xFFCB;
+
+    public static final int VK_COPY = 0xFFCD;
+
+    public static final int VK_PASTE = 0xFFCF;
+
+    public static final int VK_FIND = 0xFFD0;
+
+    public static final int VK_CUT = 0xFFD1;
+
+    private int keyCode;
+
+    private char keyChar;
+
+    private final int keyLocation;
+
+    private final int extendedKeyCode;
+
+    public KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar,
+            int keyLocation) {
+        super(source, id, when, modifiers);
+        if (id == KEY_TYPED) {
+            if (keyChar == CHAR_UNDEFINED) {
+                throw new IllegalArgumentException("invalid keyChar");
+            }
+            if (keyCode != VK_UNDEFINED) {
+                throw new IllegalArgumentException("invalid keyCode");
+            }
+            if (keyLocation != KEY_LOCATION_UNKNOWN) {
+                throw new IllegalArgumentException("invalid keyLocation");
+            }
+        }
+        this.keyCode = keyCode;
+        this.keyChar = keyChar;
+        this.keyLocation = keyLocation >= KEY_LOCATION_UNKNOWN && keyLocation <= KEY_LOCATION_NUMPAD
+                ? keyLocation : KEY_LOCATION_UNKNOWN;
+        this.extendedKeyCode = keyCode == VK_UNDEFINED ? getExtendedKeyCodeForChar(keyChar) : keyCode;
+        this.modifiers = normalize(modifiers, false);
+    }
+
+    public KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar) {
+        this(source, id, when, modifiers, keyCode, keyChar, KEY_LOCATION_UNKNOWN);
+    }
+
+    @Deprecated
+    public KeyEvent(Component source, int id, long when, int modifiers, int keyCode) {
+        this(source, id, when, modifiers, keyCode, (char) keyCode);
+    }
+
+    public int getKeyCode() {
+        return keyCode;
+    }
+
+    public void setKeyCode(int keyCode) {
+        this.keyCode = keyCode;
+    }
+
+    public char getKeyChar() {
+        return keyChar;
+    }
+
+    public void setKeyChar(char keyChar) {
+        this.keyChar = keyChar;
+    }
+
+    @Deprecated
+    public void setModifiers(int modifiers) {
+        this.modifiers = normalize(modifiers, false);
+    }
+
+    public int getKeyLocation() {
+        return keyLocation;
+    }
+
+    public int getExtendedKeyCode() {
+        return extendedKeyCode;
+    }
+
+    /// The extended key code of a character: the virtual key code when the
+    /// character has an unambiguous one, otherwise the character with the
+    /// extended flag set.
+    public static int getExtendedKeyCodeForChar(int c) {
+        if (c >= 'a' && c <= 'z') {
+            return c - 'a' + 'A';
+        }
+        if (c >= 'A' && c <= 'Z' || c >= '0' && c <= '9') {
+            return c;
+        }
+        switch (c) {
+            case ' ':
+                return VK_SPACE;
+            case ',':
+                return VK_COMMA;
+            case '-':
+                return VK_MINUS;
+            case '.':
+                return VK_PERIOD;
+            case '/':
+                return VK_SLASH;
+            case ';':
+                return VK_SEMICOLON;
+            case '=':
+                return VK_EQUALS;
+            case '[':
+                return VK_OPEN_BRACKET;
+            case '\\':
+                return VK_BACK_SLASH;
+            case ']':
+                return VK_CLOSE_BRACKET;
+            case '`':
+                return VK_BACK_QUOTE;
+            case '\'':
+                return VK_QUOTE;
+            case '\t':
+                return VK_TAB;
+            case '\n':
+                return VK_ENTER;
+            case '\b':
+                return VK_BACK_SPACE;
+            case 0x1b:
+                return VK_ESCAPE;
+            case 0x7f:
+                return VK_DELETE;
+            default:
+                return c | EXTENDED_FLAG;
+        }
+    }
+
+    public boolean isActionKey() {
+        switch (keyCode) {
+            case VK_HOME:
+            case VK_END:
+            case VK_PAGE_UP:
+            case VK_PAGE_DOWN:
+            case VK_UP:
+            case VK_DOWN:
+            case VK_LEFT:
+            case VK_RIGHT:
+            case VK_BEGIN:
+            case VK_KP_LEFT:
+            case VK_KP_UP:
+            case VK_KP_RIGHT:
+            case VK_KP_DOWN:
+            case VK_F1:
+            case VK_F2:
+            case VK_F3:
+            case VK_F4:
+            case VK_F5:
+            case VK_F6:
+            case VK_F7:
+            case VK_F8:
+            case VK_F9:
+            case VK_F10:
+            case VK_F11:
+            case VK_F12:
+            case VK_F13:
+            case VK_F14:
+            case VK_F15:
+            case VK_F16:
+            case VK_F17:
+            case VK_F18:
+            case VK_F19:
+            case VK_F20:
+            case VK_F21:
+            case VK_F22:
+            case VK_F23:
+            case VK_F24:
+            case VK_PRINTSCREEN:
+            case VK_SCROLL_LOCK:
+            case VK_CAPS_LOCK:
+            case VK_NUM_LOCK:
+            case VK_PAUSE:
+            case VK_INSERT:
+            case VK_FINAL:
+            case VK_CONVERT:
+            case VK_NONCONVERT:
+            case VK_ACCEPT:
+            case VK_MODECHANGE:
+            case VK_KANA:
+            case VK_KANJI:
+            case VK_ALPHANUMERIC:
+            case VK_KATAKANA:
+            case VK_HIRAGANA:
+            case VK_FULL_WIDTH:
+            case VK_HALF_WIDTH:
+            case VK_ROMAN_CHARACTERS:
+            case VK_ALL_CANDIDATES:
+            case VK_PREVIOUS_CANDIDATE:
+            case VK_CODE_INPUT:
+            case VK_JAPANESE_KATAKANA:
+            case VK_JAPANESE_HIRAGANA:
+            case VK_JAPANESE_ROMAN:
+            case VK_KANA_LOCK:
+            case VK_INPUT_METHOD_ON_OFF:
+            case VK_AGAIN:
+            case VK_UNDO:
+            case VK_COPY:
+            case VK_PASTE:
+            case VK_CUT:
+            case VK_FIND:
+            case VK_PROPS:
+            case VK_STOP:
+            case VK_HELP:
+            case VK_WINDOWS:
+            case VK_CONTEXT_MENU:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /// The English name of a key code.
+    public static String getKeyText(int keyCode) {
+        if (keyCode >= VK_0 && keyCode <= VK_9 || keyCode >= VK_A && keyCode <= VK_Z) {
+            return String.valueOf((char) keyCode);
+        }
+        if (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) {
+            return "NumPad-" + (char) ('0' + keyCode - VK_NUMPAD0);
+        }
+        if (keyCode >= VK_F1 && keyCode <= VK_F12) {
+            return "F" + (keyCode - VK_F1 + 1);
+        }
+        if (keyCode >= VK_F13 && keyCode <= VK_F24) {
+            return "F" + (keyCode - VK_F13 + 13);
+        }
+        String name = namedKey(keyCode);
+        if (name != null) {
+            return name;
+        }
+        if ((keyCode & EXTENDED_FLAG) != 0) {
+            return String.valueOf((char) (keyCode ^ EXTENDED_FLAG));
+        }
+        return "Unknown keyCode: 0x" + Integer.toHexString(keyCode);
+    }
+
+    private static String namedKey(int keyCode) {
+        switch (keyCode) {
+            case VK_ENTER:
+                return "Enter";
+            case VK_BACK_SPACE:
+                return "Backspace";
+            case VK_TAB:
+                return "Tab";
+            case VK_CANCEL:
+                return "Cancel";
+            case VK_CLEAR:
+                return "Clear";
+            case VK_COMPOSE:
+                return "Compose";
+            case VK_PAUSE:
+                return "Pause";
+            case VK_CAPS_LOCK:
+                return "Caps Lock";
+            case VK_ESCAPE:
+                return "Escape";
+            case VK_SPACE:
+                return "Space";
+            case VK_PAGE_UP:
+                return "Page Up";
+            case VK_PAGE_DOWN:
+                return "Page Down";
+            case VK_END:
+                return "End";
+            case VK_HOME:
+                return "Home";
+            case VK_LEFT:
+                return "Left";
+            case VK_UP:
+                return "Up";
+            case VK_RIGHT:
+                return "Right";
+            case VK_DOWN:
+                return "Down";
+            case VK_BEGIN:
+                return "Begin";
+            case VK_SHIFT:
+                return "Shift";
+            case VK_CONTROL:
+                return "Control";
+            case VK_ALT:
+                return "Alt";
+            case VK_META:
+                return "Meta";
+            case VK_ALT_GRAPH:
+                return "Alt Graph";
+            case VK_COMMA:
+                return "Comma";
+            case VK_PERIOD:
+                return "Period";
+            case VK_SLASH:
+                return "Slash";
+            case VK_SEMICOLON:
+                return "Semicolon";
+            case VK_EQUALS:
+                return "Equals";
+            case VK_OPEN_BRACKET:
+                return "Open Bracket";
+            case VK_BACK_SLASH:
+                return "Back Slash";
+            case VK_CLOSE_BRACKET:
+                return "Close Bracket";
+            case VK_MULTIPLY:
+                return "NumPad *";
+            case VK_ADD:
+                return "NumPad +";
+            case VK_SEPARATOR:
+                return "NumPad ,";
+            case VK_SUBTRACT:
+                return "NumPad -";
+            case VK_DECIMAL:
+                return "NumPad .";
+            case VK_DIVIDE:
+                return "NumPad /";
+            case VK_DELETE:
+                return "Delete";
+            case VK_NUM_LOCK:
+                return "Num Lock";
+            case VK_SCROLL_LOCK:
+                return "Scroll Lock";
+            case VK_WINDOWS:
+                return "Windows";
+            case VK_CONTEXT_MENU:
+                return "Context Menu";
+            case VK_PRINTSCREEN:
+                return "Print Screen";
+            case VK_INSERT:
+                return "Insert";
+            case VK_HELP:
+                return "Help";
+            case VK_BACK_QUOTE:
+                return "Back Quote";
+            case VK_QUOTE:
+                return "Quote";
+            case VK_KP_UP:
+                return "NumPad Up";
+            case VK_KP_DOWN:
+                return "NumPad Down";
+            case VK_KP_LEFT:
+                return "NumPad Left";
+            case VK_KP_RIGHT:
+                return "NumPad Right";
+            case VK_DEAD_GRAVE:
+                return "Dead Grave";
+            case VK_DEAD_ACUTE:
+                return "Dead Acute";
+            case VK_DEAD_CIRCUMFLEX:
+                return "Dead Circumflex";
+            case VK_DEAD_TILDE:
+                return "Dead Tilde";
+            case VK_DEAD_MACRON:
+                return "Dead Macron";
+            case VK_DEAD_BREVE:
+                return "Dead Breve";
+            case VK_DEAD_ABOVEDOT:
+                return "Dead Above Dot";
+            case VK_DEAD_DIAERESIS:
+                return "Dead Diaeresis";
+            case VK_DEAD_ABOVERING:
+                return "Dead Above Ring";
+            case VK_DEAD_DOUBLEACUTE:
+                return "Dead Double Acute";
+            case VK_DEAD_CARON:
+                return "Dead Caron";
+            case VK_DEAD_CEDILLA:
+                return "Dead Cedilla";
+            case VK_DEAD_OGONEK:
+                return "Dead Ogonek";
+            case VK_DEAD_IOTA:
+                return "Dead Iota";
+            case VK_DEAD_VOICED_SOUND:
+                return "Dead Voiced Sound";
+            case VK_DEAD_SEMIVOICED_SOUND:
+                return "Dead Semivoiced Sound";
+            case VK_AMPERSAND:
+                return "Ampersand";
+            case VK_ASTERISK:
+                return "Asterisk";
+            case VK_QUOTEDBL:
+                return "Double Quote";
+            case VK_LESS:
+                return "Less";
+            case VK_GREATER:
+                return "Greater";
+            case VK_BRACELEFT:
+                return "Left Brace";
+            case VK_BRACERIGHT:
+                return "Right Brace";
+            case VK_AT:
+                return "At";
+            case VK_COLON:
+                return "Colon";
+            case VK_CIRCUMFLEX:
+                return "Circumflex";
+            case VK_DOLLAR:
+                return "Dollar";
+            case VK_EURO_SIGN:
+                return "Euro";
+            case VK_EXCLAMATION_MARK:
+                return "Exclamation Mark";
+            case VK_INVERTED_EXCLAMATION_MARK:
+                return "Inverted Exclamation Mark";
+            case VK_LEFT_PARENTHESIS:
+                return "Left Parenthesis";
+            case VK_NUMBER_SIGN:
+                return "Number Sign";
+            case VK_MINUS:
+                return "Minus";
+            case VK_PLUS:
+                return "Plus";
+            case VK_RIGHT_PARENTHESIS:
+                return "Right Parenthesis";
+            case VK_UNDERSCORE:
+                return "Underscore";
+            case VK_FINAL:
+                return "Final";
+            case VK_CONVERT:
+                return "Convert";
+            case VK_NONCONVERT:
+                return "No Convert";
+            case VK_ACCEPT:
+                return "Accept";
+            case VK_MODECHANGE:
+                return "Mode Change";
+            case VK_KANA:
+                return "Kana";
+            case VK_KANJI:
+                return "Kanji";
+            case VK_ALPHANUMERIC:
+                return "Alphanumeric";
+            case VK_KATAKANA:
+                return "Katakana";
+            case VK_HIRAGANA:
+                return "Hiragana";
+            case VK_FULL_WIDTH:
+                return "Full-Width";
+            case VK_HALF_WIDTH:
+                return "Half-Width";
+            case VK_ROMAN_CHARACTERS:
+                return "Roman Characters";
+            case VK_ALL_CANDIDATES:
+                return "All Candidates";
+            case VK_PREVIOUS_CANDIDATE:
+                return "Previous Candidate";
+            case VK_CODE_INPUT:
+                return "Code Input";
+            case VK_JAPANESE_KATAKANA:
+                return "Japanese Katakana";
+            case VK_JAPANESE_HIRAGANA:
+                return "Japanese Hiragana";
+            case VK_JAPANESE_ROMAN:
+                return "Japanese Roman";
+            case VK_KANA_LOCK:
+                return "Kana Lock";
+            case VK_INPUT_METHOD_ON_OFF:
+                return "Input Method On/Off";
+            case VK_AGAIN:
+                return "Again";
+            case VK_UNDO:
+                return "Undo";
+            case VK_COPY:
+                return "Copy";
+            case VK_PASTE:
+                return "Paste";
+            case VK_CUT:
+                return "Cut";
+            case VK_FIND:
+                return "Find";
+            case VK_PROPS:
+                return "Props";
+            case VK_STOP:
+                return "Stop";
+            default:
+                return null;
+        }
+    }
+
+    /// The English names of the old-style modifier bits, joined by plus
+    /// signs.
+    public static String getKeyModifiersText(int modifiers) {
+        StringBuilder buf = new StringBuilder();
+        if ((modifiers & META_MASK) != 0) {
+            add(buf, "Meta");
+        }
+        if ((modifiers & CTRL_MASK) != 0) {
+            add(buf, "Ctrl");
+        }
+        if ((modifiers & ALT_MASK) != 0) {
+            add(buf, "Alt");
+        }
+        if ((modifiers & SHIFT_MASK) != 0) {
+            add(buf, "Shift");
+        }
+        if ((modifiers & ALT_GRAPH_MASK) != 0) {
+            add(buf, "Alt Graph");
+        }
+        if ((modifiers & BUTTON1_MASK) != 0) {
+            add(buf, "Button1");
+        }
+        return buf.toString();
+    }
+
+    private static void add(StringBuilder buf, String name) {
+        if (buf.length() > 0) {
+            buf.append('+');
+        }
+        buf.append(name);
+    }
+
+    @Override
+    public String paramString() {
+        StringBuilder str = new StringBuilder(100);
+        switch (id) {
+            case KEY_PRESSED:
+                str.append("KEY_PRESSED");
+                break;
+            case KEY_RELEASED:
+                str.append("KEY_RELEASED");
+                break;
+            case KEY_TYPED:
+                str.append("KEY_TYPED");
+                break;
+            default:
+                str.append("unknown type");
+                break;
+        }
+        str.append(",keyCode=").append(keyCode);
+        str.append(",keyText=").append(getKeyText(keyCode));
+        str.append(",keyChar=");
+        switch (keyChar) {
+            case '\b':
+                str.append("Backspace");
+                break;
+            case '\t':
+                str.append("Tab");
+                break;
+            case '\n':
+                str.append("Newline");
+                break;
+            case 0x18:
+                str.append("Cancel");
+                break;
+            case 0x1b:
+                str.append("Escape");
+                break;
+            case 0x7f:
+                str.append("Delete");
+                break;
+            case CHAR_UNDEFINED:
+                str.append("Undefined");
+                break;
+            default:
+                if (keyChar < ' ') {
+                    str.append("Unknown keyChar 0x").append(Integer.toHexString(keyChar));
+                } else {
+                    str.append('\'').append(keyChar).append('\'');
+                }
+                break;
+        }
+        if (getModifiers() != 0) {
+            str.append(",modifiers=").append(getKeyModifiersText(modifiers));
+        }
+        if (getModifiersEx() != 0) {
+            str.append(",extModifiers=").append(getModifiersExText(modifiers));
+        }
+        str.append(",keyLocation=");
+        switch (keyLocation) {
+            case KEY_LOCATION_UNKNOWN:
+                str.append("KEY_LOCATION_UNKNOWN");
+                break;
+            case KEY_LOCATION_STANDARD:
+                str.append("KEY_LOCATION_STANDARD");
+                break;
+            case KEY_LOCATION_LEFT:
+                str.append("KEY_LOCATION_LEFT");
+                break;
+            case KEY_LOCATION_RIGHT:
+                str.append("KEY_LOCATION_RIGHT");
+                break;
+            case KEY_LOCATION_NUMPAD:
+                str.append("KEY_LOCATION_NUMPAD");
+                break;
+            default:
+                str.append("KEY_LOCATION_UNKNOWN");
+                break;
+        }
+        return str.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyListener.java
new file mode 100644
index 00000000000..b60f32523c1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/KeyListener.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives keyboard events.
+public interface KeyListener extends EventListener {
+
+    void keyTyped(KeyEvent e);
+
+    void keyPressed(KeyEvent e);
+
+    void keyReleased(KeyEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseAdapter.java
new file mode 100644
index 00000000000..9fa95f2280d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseAdapter.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A mouse, mouse motion and mouse wheel listener whose methods do nothing,
+/// to be subclassed for the few events of interest.
+public abstract class MouseAdapter implements MouseListener, MouseWheelListener, MouseMotionListener {
+
+    public void mouseClicked(MouseEvent e) {
+    }
+
+    public void mousePressed(MouseEvent e) {
+    }
+
+    public void mouseReleased(MouseEvent e) {
+    }
+
+    public void mouseEntered(MouseEvent e) {
+    }
+
+    public void mouseExited(MouseEvent e) {
+    }
+
+    public void mouseWheelMoved(MouseWheelEvent e) {
+    }
+
+    public void mouseDragged(MouseEvent e) {
+    }
+
+    public void mouseMoved(MouseEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseEvent.java
new file mode 100644
index 00000000000..6fed2c49cc1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseEvent.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Point;
+
+/// A mouse action in a component: press, release, click, move, drag, enter,
+/// exit or wheel.
+///
+/// The on-screen position is taken from the source component when it is
+/// showing, and is zero otherwise, unless the constructor that passes it
+/// explicitly is used.
+public class MouseEvent extends InputEvent {
+
+    public static final int MOUSE_FIRST = 500;
+
+    public static final int MOUSE_LAST = 507;
+
+    public static final int MOUSE_CLICKED = 500;
+
+    public static final int MOUSE_PRESSED = 501;
+
+    public static final int MOUSE_RELEASED = 502;
+
+    public static final int MOUSE_MOVED = 503;
+
+    public static final int MOUSE_ENTERED = 504;
+
+    public static final int MOUSE_EXITED = 505;
+
+    public static final int MOUSE_DRAGGED = 506;
+
+    public static final int MOUSE_WHEEL = 507;
+
+    public static final int NOBUTTON = 0;
+
+    public static final int BUTTON1 = 1;
+
+    public static final int BUTTON2 = 2;
+
+    public static final int BUTTON3 = 3;
+
+    private static final int MAX_BUTTON = 20;
+
+    private int x;
+
+    private int y;
+
+    private int xAbs;
+
+    private int yAbs;
+
+    private final int clickCount;
+
+    private final int button;
+
+    private final boolean popupTrigger;
+
+    public MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount,
+            boolean popupTrigger, int button) {
+        super(source, id, when, modifiers);
+        checkButton(button);
+        this.x = x;
+        this.y = y;
+        this.clickCount = clickCount;
+        this.popupTrigger = popupTrigger;
+        this.button = button;
+        if (source != null && source.isShowing()) {
+            Point p = source.getLocationOnScreen();
+            this.xAbs = p.x + x;
+            this.yAbs = p.y + y;
+        }
+        this.modifiers = normalize(modifiers, true);
+    }
+
+    public MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount,
+            boolean popupTrigger) {
+        this(source, id, when, modifiers, x, y, clickCount, popupTrigger, NOBUTTON);
+    }
+
+    public MouseEvent(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs,
+            int clickCount, boolean popupTrigger, int button) {
+        super(source, id, when, modifiers);
+        checkButton(button);
+        this.x = x;
+        this.y = y;
+        this.xAbs = xAbs;
+        this.yAbs = yAbs;
+        this.clickCount = clickCount;
+        this.popupTrigger = popupTrigger;
+        this.button = button;
+        this.modifiers = normalize(modifiers, true);
+    }
+
+    private static void checkButton(int button) {
+        if (button < NOBUTTON || button > MAX_BUTTON) {
+            throw new IllegalArgumentException("Invalid button value :" + button);
+        }
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public Point getPoint() {
+        return new Point(x, y);
+    }
+
+    public Point getLocationOnScreen() {
+        return new Point(xAbs, yAbs);
+    }
+
+    public int getXOnScreen() {
+        return xAbs;
+    }
+
+    public int getYOnScreen() {
+        return yAbs;
+    }
+
+    public void translatePoint(int dx, int dy) {
+        x += dx;
+        y += dy;
+    }
+
+    public int getClickCount() {
+        return clickCount;
+    }
+
+    public int getButton() {
+        return button;
+    }
+
+    public boolean isPopupTrigger() {
+        return popupTrigger;
+    }
+
+    public static String getMouseModifiersText(int modifiers) {
+        StringBuilder buf = new StringBuilder();
+        if ((modifiers & ALT_MASK) != 0) {
+            add(buf, "Alt");
+        }
+        if ((modifiers & META_MASK) != 0) {
+            add(buf, "Meta");
+        }
+        if ((modifiers & SHIFT_MASK) != 0) {
+            add(buf, "Shift");
+        }
+        if ((modifiers & CTRL_MASK) != 0) {
+            add(buf, "Ctrl");
+        }
+        if ((modifiers & ALT_GRAPH_MASK) != 0) {
+            add(buf, "Alt Graph");
+        }
+        if ((modifiers & BUTTON1_MASK) != 0) {
+            add(buf, "Button1");
+        }
+        return buf.toString();
+    }
+
+    private static void add(StringBuilder buf, String name) {
+        if (buf.length() > 0) {
+            buf.append('+');
+        }
+        buf.append(name);
+    }
+
+    @Override
+    public String paramString() {
+        StringBuilder str = new StringBuilder(80);
+        switch (id) {
+            case MOUSE_PRESSED:
+                str.append("MOUSE_PRESSED");
+                break;
+            case MOUSE_RELEASED:
+                str.append("MOUSE_RELEASED");
+                break;
+            case MOUSE_CLICKED:
+                str.append("MOUSE_CLICKED");
+                break;
+            case MOUSE_ENTERED:
+                str.append("MOUSE_ENTERED");
+                break;
+            case MOUSE_EXITED:
+                str.append("MOUSE_EXITED");
+                break;
+            case MOUSE_MOVED:
+                str.append("MOUSE_MOVED");
+                break;
+            case MOUSE_DRAGGED:
+                str.append("MOUSE_DRAGGED");
+                break;
+            case MOUSE_WHEEL:
+                str.append("MOUSE_WHEEL");
+                break;
+            default:
+                str.append("unknown type");
+                break;
+        }
+        str.append(",(").append(x).append(',').append(y).append(')');
+        str.append(",absolute(").append(xAbs).append(',').append(yAbs).append(')');
+        if (id != MOUSE_DRAGGED && id != MOUSE_MOVED) {
+            str.append(",button=").append(getButton());
+        }
+        if (getModifiers() != 0) {
+            str.append(",modifiers=").append(getMouseModifiersText(modifiers));
+        }
+        if (getModifiersEx() != 0) {
+            str.append(",extModifiers=").append(getModifiersExText(modifiers));
+        }
+        str.append(",clickCount=").append(clickCount);
+        return str.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseListener.java
new file mode 100644
index 00000000000..24f52645304
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseListener.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the presses, releases, clicks and crossings of the mouse.
+public interface MouseListener extends EventListener {
+
+    void mouseClicked(MouseEvent e);
+
+    void mousePressed(MouseEvent e);
+
+    void mouseReleased(MouseEvent e);
+
+    void mouseEntered(MouseEvent e);
+
+    void mouseExited(MouseEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseMotionAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseMotionAdapter.java
new file mode 100644
index 00000000000..9cee131a71b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseMotionAdapter.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A `MouseMotionListener` whose methods do nothing, to be subclassed for the
+/// few events of interest.
+public abstract class MouseMotionAdapter implements MouseMotionListener {
+
+    public void mouseDragged(MouseEvent e) {
+    }
+
+    public void mouseMoved(MouseEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseMotionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseMotionListener.java
new file mode 100644
index 00000000000..c40795df5e3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseMotionListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the moves and drags of the mouse.
+public interface MouseMotionListener extends EventListener {
+
+    void mouseDragged(MouseEvent e);
+
+    void mouseMoved(MouseEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseWheelEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseWheelEvent.java
new file mode 100644
index 00000000000..5df91fb6ecc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseWheelEvent.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// The mouse wheel was rotated in a component.
+public class MouseWheelEvent extends MouseEvent {
+
+    public static final int WHEEL_UNIT_SCROLL = 0;
+
+    public static final int WHEEL_BLOCK_SCROLL = 1;
+
+    private final int scrollType;
+
+    private final int scrollAmount;
+
+    private final int wheelRotation;
+
+    private final double preciseWheelRotation;
+
+    public MouseWheelEvent(Component source, int id, long when, int modifiers, int x, int y, int clickCount,
+            boolean popupTrigger, int scrollType, int scrollAmount, int wheelRotation) {
+        super(source, id, when, modifiers, x, y, clickCount, popupTrigger);
+        this.scrollType = scrollType;
+        this.scrollAmount = scrollAmount;
+        this.wheelRotation = wheelRotation;
+        this.preciseWheelRotation = wheelRotation;
+    }
+
+    public MouseWheelEvent(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs,
+            int clickCount, boolean popupTrigger, int scrollType, int scrollAmount, int wheelRotation) {
+        super(source, id, when, modifiers, x, y, xAbs, yAbs, clickCount, popupTrigger, NOBUTTON);
+        this.scrollType = scrollType;
+        this.scrollAmount = scrollAmount;
+        this.wheelRotation = wheelRotation;
+        this.preciseWheelRotation = wheelRotation;
+    }
+
+    public MouseWheelEvent(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs,
+            int clickCount, boolean popupTrigger, int scrollType, int scrollAmount, int wheelRotation,
+            double preciseWheelRotation) {
+        super(source, id, when, modifiers, x, y, xAbs, yAbs, clickCount, popupTrigger, NOBUTTON);
+        this.scrollType = scrollType;
+        this.scrollAmount = scrollAmount;
+        this.wheelRotation = wheelRotation;
+        this.preciseWheelRotation = preciseWheelRotation;
+    }
+
+    public int getScrollType() {
+        return scrollType;
+    }
+
+    public int getScrollAmount() {
+        return scrollAmount;
+    }
+
+    public int getWheelRotation() {
+        return wheelRotation;
+    }
+
+    public double getPreciseWheelRotation() {
+        return preciseWheelRotation;
+    }
+
+    public int getUnitsToScroll() {
+        return scrollAmount * wheelRotation;
+    }
+
+    @Override
+    public String paramString() {
+        return super.paramString() + ",scrollType="
+                + (scrollType == WHEEL_UNIT_SCROLL ? "WHEEL_UNIT_SCROLL" : scrollType == WHEEL_BLOCK_SCROLL
+                        ? "WHEEL_BLOCK_SCROLL" : "unknown scroll type")
+                + ",scrollAmount=" + scrollAmount + ",wheelRotation=" + wheelRotation
+                + ",preciseWheelRotation=" + preciseWheelRotation;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseWheelListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseWheelListener.java
new file mode 100644
index 00000000000..e63a6731198
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/MouseWheelListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the rotations of the mouse wheel.
+public interface MouseWheelListener extends EventListener {
+
+    void mouseWheelMoved(MouseWheelEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/TextEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/TextEvent.java
new file mode 100644
index 00000000000..abba72668c0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/TextEvent.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+
+/// The text of a text component changed.
+public class TextEvent extends AWTEvent {
+
+    public static final int TEXT_FIRST = 900;
+
+    public static final int TEXT_LAST = 900;
+
+    public static final int TEXT_VALUE_CHANGED = 900;
+
+    public TextEvent(Object source, int id) {
+        super(source, id);
+    }
+
+    @Override
+    public String paramString() {
+        return id == TEXT_VALUE_CHANGED ? "TEXT_VALUE_CHANGED" : "unknown type";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/TextListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/TextListener.java
new file mode 100644
index 00000000000..06692b6259b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/TextListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives text events.
+public interface TextListener extends EventListener {
+
+    void textValueChanged(TextEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowAdapter.java
new file mode 100644
index 00000000000..1bbc6140ac8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowAdapter.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+/// A window, window focus and window state listener whose methods do
+/// nothing, to be subclassed for the few events of interest.
+public abstract class WindowAdapter implements WindowListener, WindowStateListener, WindowFocusListener {
+
+    public void windowOpened(WindowEvent e) {
+    }
+
+    public void windowClosing(WindowEvent e) {
+    }
+
+    public void windowClosed(WindowEvent e) {
+    }
+
+    public void windowIconified(WindowEvent e) {
+    }
+
+    public void windowDeiconified(WindowEvent e) {
+    }
+
+    public void windowActivated(WindowEvent e) {
+    }
+
+    public void windowDeactivated(WindowEvent e) {
+    }
+
+    public void windowStateChanged(WindowEvent e) {
+    }
+
+    public void windowGainedFocus(WindowEvent e) {
+    }
+
+    public void windowLostFocus(WindowEvent e) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowEvent.java
new file mode 100644
index 00000000000..a73b998621d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowEvent.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import com.codename1.desktopcompat.java.awt.Window;
+
+/// A window was opened, closed, iconified, activated, focused or changed
+/// state.
+public class WindowEvent extends ComponentEvent {
+
+    public static final int WINDOW_FIRST = 200;
+
+    public static final int WINDOW_OPENED = 200;
+
+    public static final int WINDOW_CLOSING = 201;
+
+    public static final int WINDOW_CLOSED = 202;
+
+    public static final int WINDOW_ICONIFIED = 203;
+
+    public static final int WINDOW_DEICONIFIED = 204;
+
+    public static final int WINDOW_ACTIVATED = 205;
+
+    public static final int WINDOW_DEACTIVATED = 206;
+
+    public static final int WINDOW_GAINED_FOCUS = 207;
+
+    public static final int WINDOW_LOST_FOCUS = 208;
+
+    public static final int WINDOW_STATE_CHANGED = 209;
+
+    public static final int WINDOW_LAST = 209;
+
+    private final Window opposite;
+
+    private final int oldState;
+
+    private final int newState;
+
+    public WindowEvent(Window source, int id, Window opposite, int oldState, int newState) {
+        super(source, id);
+        this.opposite = opposite;
+        this.oldState = oldState;
+        this.newState = newState;
+    }
+
+    public WindowEvent(Window source, int id, Window opposite) {
+        this(source, id, opposite, 0, 0);
+    }
+
+    public WindowEvent(Window source, int id, int oldState, int newState) {
+        this(source, id, null, oldState, newState);
+    }
+
+    public WindowEvent(Window source, int id) {
+        this(source, id, null, 0, 0);
+    }
+
+    public Window getWindow() {
+        return source instanceof Window ? (Window) source : null;
+    }
+
+    public Window getOppositeWindow() {
+        return opposite;
+    }
+
+    public int getOldState() {
+        return oldState;
+    }
+
+    public int getNewState() {
+        return newState;
+    }
+
+    @Override
+    public String paramString() {
+        String typeStr;
+        switch (id) {
+            case WINDOW_OPENED:
+                typeStr = "WINDOW_OPENED";
+                break;
+            case WINDOW_CLOSING:
+                typeStr = "WINDOW_CLOSING";
+                break;
+            case WINDOW_CLOSED:
+                typeStr = "WINDOW_CLOSED";
+                break;
+            case WINDOW_ICONIFIED:
+                typeStr = "WINDOW_ICONIFIED";
+                break;
+            case WINDOW_DEICONIFIED:
+                typeStr = "WINDOW_DEICONIFIED";
+                break;
+            case WINDOW_ACTIVATED:
+                typeStr = "WINDOW_ACTIVATED";
+                break;
+            case WINDOW_DEACTIVATED:
+                typeStr = "WINDOW_DEACTIVATED";
+                break;
+            case WINDOW_GAINED_FOCUS:
+                typeStr = "WINDOW_GAINED_FOCUS";
+                break;
+            case WINDOW_LOST_FOCUS:
+                typeStr = "WINDOW_LOST_FOCUS";
+                break;
+            case WINDOW_STATE_CHANGED:
+                typeStr = "WINDOW_STATE_CHANGED";
+                break;
+            default:
+                typeStr = "unknown type";
+                break;
+        }
+        return typeStr + ",opposite=" + opposite + ",oldState=" + oldState + ",newState=" + newState;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowFocusListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowFocusListener.java
new file mode 100644
index 00000000000..3c8601b9817
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowFocusListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of a window gaining or losing the focus.
+public interface WindowFocusListener extends EventListener {
+
+    void windowGainedFocus(WindowEvent e);
+
+    void windowLostFocus(WindowEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowListener.java
new file mode 100644
index 00000000000..aa2b3f412a8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowListener.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of a window being opened, closed, iconified or
+/// activated.
+public interface WindowListener extends EventListener {
+
+    void windowOpened(WindowEvent e);
+
+    void windowClosing(WindowEvent e);
+
+    void windowClosed(WindowEvent e);
+
+    void windowIconified(WindowEvent e);
+
+    void windowDeiconified(WindowEvent e);
+
+    void windowActivated(WindowEvent e);
+
+    void windowDeactivated(WindowEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowStateListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowStateListener.java
new file mode 100644
index 00000000000..f0cd97377bb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/WindowStateListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.event;
+
+import java.util.EventListener;
+
+/// Receives the events of a window changing state.
+public interface WindowStateListener extends EventListener {
+
+    void windowStateChanged(WindowEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/package-info.java
new file mode 100644
index 00000000000..35d5264c2c2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/event/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The `java.awt.event` events, listeners and adapters.
+///
+/// Event ids, modifier masks and virtual key codes carry the values of the
+/// JDK, because applications inline them when they are compiled. Key and
+/// modifier texts are English only.
+package com.codename1.desktopcompat.java.awt.event;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/AffineTransform.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/AffineTransform.java
new file mode 100644
index 00000000000..1d521f8e6d9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/AffineTransform.java
@@ -0,0 +1,679 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// A linear mapping of the plane that keeps straight lines straight and
+/// parallel lines parallel: any mix of translation, scaling, rotation and
+/// shearing.
+///
+/// A point `(x, y)` maps to `(m00*x + m01*y + m02, m10*x + m11*y + m12)`.
+/// Rotations by an exact multiple of a quarter turn store exact zeros and
+/// ones, so [#getType()] reports them as quadrant rotations.
+public class AffineTransform implements Cloneable {
+
+    public static final int TYPE_IDENTITY = 0;
+    public static final int TYPE_TRANSLATION = 1;
+    public static final int TYPE_UNIFORM_SCALE = 2;
+    public static final int TYPE_GENERAL_SCALE = 4;
+    public static final int TYPE_MASK_SCALE = TYPE_UNIFORM_SCALE | TYPE_GENERAL_SCALE;
+    public static final int TYPE_FLIP = 64;
+    public static final int TYPE_QUADRANT_ROTATION = 8;
+    public static final int TYPE_GENERAL_ROTATION = 16;
+    public static final int TYPE_MASK_ROTATION = TYPE_QUADRANT_ROTATION | TYPE_GENERAL_ROTATION;
+    public static final int TYPE_GENERAL_TRANSFORM = 32;
+
+    private double m00;
+    private double m10;
+    private double m01;
+    private double m11;
+    private double m02;
+    private double m12;
+
+    public AffineTransform() {
+        m00 = 1.0;
+        m11 = 1.0;
+    }
+
+    public AffineTransform(AffineTransform tx) {
+        this(tx.m00, tx.m10, tx.m01, tx.m11, tx.m02, tx.m12);
+    }
+
+    public AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12) {
+        this((double) m00, (double) m10, (double) m01, (double) m11, (double) m02, (double) m12);
+    }
+
+    /// Reads four or six values in the order m00, m10, m01, m11, m02, m12.
+    public AffineTransform(float[] flatmatrix) {
+        m00 = flatmatrix[0];
+        m10 = flatmatrix[1];
+        m01 = flatmatrix[2];
+        m11 = flatmatrix[3];
+        if (flatmatrix.length > 5) {
+            m02 = flatmatrix[4];
+            m12 = flatmatrix[5];
+        }
+    }
+
+    public AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12) {
+        this.m00 = m00;
+        this.m10 = m10;
+        this.m01 = m01;
+        this.m11 = m11;
+        this.m02 = m02;
+        this.m12 = m12;
+    }
+
+    /// Reads four or six values in the order m00, m10, m01, m11, m02, m12.
+    public AffineTransform(double[] flatmatrix) {
+        m00 = flatmatrix[0];
+        m10 = flatmatrix[1];
+        m01 = flatmatrix[2];
+        m11 = flatmatrix[3];
+        if (flatmatrix.length > 5) {
+            m02 = flatmatrix[4];
+            m12 = flatmatrix[5];
+        }
+    }
+
+    public static AffineTransform getTranslateInstance(double tx, double ty) {
+        AffineTransform t = new AffineTransform();
+        t.setToTranslation(tx, ty);
+        return t;
+    }
+
+    public static AffineTransform getRotateInstance(double theta) {
+        AffineTransform t = new AffineTransform();
+        t.setToRotation(theta);
+        return t;
+    }
+
+    public static AffineTransform getRotateInstance(double theta, double anchorx, double anchory) {
+        AffineTransform t = new AffineTransform();
+        t.setToRotation(theta, anchorx, anchory);
+        return t;
+    }
+
+    public static AffineTransform getRotateInstance(double vecx, double vecy) {
+        AffineTransform t = new AffineTransform();
+        t.setToRotation(vecx, vecy);
+        return t;
+    }
+
+    public static AffineTransform getRotateInstance(double vecx, double vecy, double anchorx, double anchory) {
+        AffineTransform t = new AffineTransform();
+        t.setToRotation(vecx, vecy, anchorx, anchory);
+        return t;
+    }
+
+    public static AffineTransform getQuadrantRotateInstance(int numquadrants) {
+        AffineTransform t = new AffineTransform();
+        t.setToQuadrantRotation(numquadrants);
+        return t;
+    }
+
+    public static AffineTransform getQuadrantRotateInstance(int numquadrants, double anchorx, double anchory) {
+        AffineTransform t = new AffineTransform();
+        t.setToQuadrantRotation(numquadrants, anchorx, anchory);
+        return t;
+    }
+
+    public static AffineTransform getScaleInstance(double sx, double sy) {
+        AffineTransform t = new AffineTransform();
+        t.setToScale(sx, sy);
+        return t;
+    }
+
+    public static AffineTransform getShearInstance(double shx, double shy) {
+        AffineTransform t = new AffineTransform();
+        t.setToShear(shx, shy);
+        return t;
+    }
+
+    /// Classifies the matrix as a combination of the `TYPE_` flags. The
+    /// answer is computed from the six values on every call.
+    ///
+    /// As in the JDK, a mirrored rotation that is not a plain flip of one
+    /// axis always carries a scale flag, uniform when nothing else applies,
+    /// and `TYPE_GENERAL_TRANSFORM` is reported on its own, without the
+    /// translation flag.
+    ///
+    /// One deliberate difference: a rotation whose sine and cosine squares
+    /// sum to one only within rounding is a pure rotation here however the
+    /// matrix was made. The JDK remembers how a transform was built, so it
+    /// says the same of one made by a rotation method but reports a uniform
+    /// scale for the identical values passed to a constructor.
+    public int getType() {
+        if (m00 * m01 + m10 * m11 != 0.0) {
+            // the images of the two axes are no longer perpendicular
+            return TYPE_GENERAL_TRANSFORM;
+        }
+        int type = (m02 != 0.0 || m12 != 0.0) ? TYPE_TRANSLATION : TYPE_IDENTITY;
+        if (m01 == 0.0 && m10 == 0.0) {
+            boolean xPositive = m00 >= 0.0;
+            if (xPositive == (m11 >= 0.0)) {
+                if (!xPositive) {
+                    // both axes reversed: a half turn
+                    type |= TYPE_QUADRANT_ROTATION;
+                }
+                type |= scaleFlags(m00 != m11, m00);
+            } else {
+                type |= TYPE_FLIP | scaleFlags(m00 != -m11, m00);
+            }
+        } else if (m00 == 0.0 && m11 == 0.0) {
+            type |= TYPE_QUADRANT_ROTATION;
+            if ((m01 >= 0.0) != (m10 >= 0.0)) {
+                type |= scaleFlags(m01 != -m10, m01);
+            } else {
+                type |= TYPE_FLIP | (m01 != m10 ? TYPE_GENERAL_SCALE : TYPE_UNIFORM_SCALE);
+            }
+        } else {
+            type |= TYPE_GENERAL_ROTATION;
+            if ((m00 >= 0.0) == (m11 >= 0.0)) {
+                if (m00 != m11 || m01 != -m10) {
+                    type |= TYPE_GENERAL_SCALE;
+                } else if (Math.abs(m00 * m11 - m01 * m10 - 1.0) > ROUNDING) {
+                    type |= TYPE_UNIFORM_SCALE;
+                }
+            } else {
+                type |= TYPE_FLIP | (m00 != -m11 || m01 != m10 ? TYPE_GENERAL_SCALE : TYPE_UNIFORM_SCALE);
+            }
+        }
+        return type;
+    }
+
+    /// How far the determinant of a rotation may stray from one through
+    /// rounding of its sine and cosine alone.
+    private static final double ROUNDING = 1e-14;
+
+    private static int scaleFlags(boolean uneven, double factor) {
+        if (uneven) {
+            return TYPE_GENERAL_SCALE;
+        }
+        return factor != 1.0 && factor != -1.0 ? TYPE_UNIFORM_SCALE : 0;
+    }
+
+    public double getDeterminant() {
+        return m00 * m11 - m01 * m10;
+    }
+
+    /// Stores m00, m10, m01, m11 and, when the array has room for six
+    /// values, m02 and m12.
+    public void getMatrix(double[] flatmatrix) {
+        flatmatrix[0] = m00;
+        flatmatrix[1] = m10;
+        flatmatrix[2] = m01;
+        flatmatrix[3] = m11;
+        if (flatmatrix.length > 5) {
+            flatmatrix[4] = m02;
+            flatmatrix[5] = m12;
+        }
+    }
+
+    public double getScaleX() {
+        return m00;
+    }
+
+    public double getScaleY() {
+        return m11;
+    }
+
+    public double getShearX() {
+        return m01;
+    }
+
+    public double getShearY() {
+        return m10;
+    }
+
+    public double getTranslateX() {
+        return m02;
+    }
+
+    public double getTranslateY() {
+        return m12;
+    }
+
+    public void translate(double tx, double ty) {
+        m02 = tx * m00 + ty * m01 + m02;
+        m12 = tx * m10 + ty * m11 + m12;
+    }
+
+    public void rotate(double theta) {
+        rotateBy(sine(theta), cosine(theta));
+    }
+
+    public void rotate(double theta, double anchorx, double anchory) {
+        translate(anchorx, anchory);
+        rotate(theta);
+        translate(-anchorx, -anchory);
+    }
+
+    /// Rotates by the angle of the vector; a zero vector leaves the
+    /// transform unchanged.
+    public void rotate(double vecx, double vecy) {
+        double len = vectorLength(vecx, vecy);
+        if (len != 0.0) {
+            rotateBy(vectorSine(vecx, vecy, len), vectorCosine(vecx, vecy, len));
+        }
+    }
+
+    public void rotate(double vecx, double vecy, double anchorx, double anchory) {
+        translate(anchorx, anchory);
+        rotate(vecx, vecy);
+        translate(-anchorx, -anchory);
+    }
+
+    public void quadrantRotate(int numquadrants) {
+        rotateBy(QUADRANT_SINE[numquadrants & 3], QUADRANT_SINE[(numquadrants + 1) & 3]);
+    }
+
+    public void quadrantRotate(int numquadrants, double anchorx, double anchory) {
+        translate(anchorx, anchory);
+        quadrantRotate(numquadrants);
+        translate(-anchorx, -anchory);
+    }
+
+    public void scale(double sx, double sy) {
+        m00 *= sx;
+        m10 *= sx;
+        m01 *= sy;
+        m11 *= sy;
+    }
+
+    public void shear(double shx, double shy) {
+        double a = m00;
+        double b = m01;
+        m00 = a + b * shy;
+        m01 = a * shx + b;
+        a = m10;
+        b = m11;
+        m10 = a + b * shy;
+        m11 = a * shx + b;
+    }
+
+    public void setToIdentity() {
+        setTransform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
+    }
+
+    public void setToTranslation(double tx, double ty) {
+        setTransform(1.0, 0.0, 0.0, 1.0, tx, ty);
+    }
+
+    public void setToRotation(double theta) {
+        double sin = sine(theta);
+        double cos = cosine(theta);
+        setTransform(cos, sin, -sin, cos, 0.0, 0.0);
+    }
+
+    public void setToRotation(double theta, double anchorx, double anchory) {
+        setToRotation(theta);
+        anchor(anchorx, anchory);
+    }
+
+    /// Sets a rotation by the angle of the vector; a zero vector gives the
+    /// identity.
+    public void setToRotation(double vecx, double vecy) {
+        double len = vectorLength(vecx, vecy);
+        if (len == 0.0) {
+            setToIdentity();
+        } else {
+            double sin = vectorSine(vecx, vecy, len);
+            double cos = vectorCosine(vecx, vecy, len);
+            setTransform(cos, sin, -sin, cos, 0.0, 0.0);
+        }
+    }
+
+    public void setToRotation(double vecx, double vecy, double anchorx, double anchory) {
+        setToRotation(vecx, vecy);
+        anchor(anchorx, anchory);
+    }
+
+    public void setToQuadrantRotation(int numquadrants) {
+        double sin = QUADRANT_SINE[numquadrants & 3];
+        double cos = QUADRANT_SINE[(numquadrants + 1) & 3];
+        setTransform(cos, sin, -sin, cos, 0.0, 0.0);
+    }
+
+    public void setToQuadrantRotation(int numquadrants, double anchorx, double anchory) {
+        setToQuadrantRotation(numquadrants);
+        anchor(anchorx, anchory);
+    }
+
+    public void setToScale(double sx, double sy) {
+        setTransform(sx, 0.0, 0.0, sy, 0.0, 0.0);
+    }
+
+    public void setToShear(double shx, double shy) {
+        setTransform(1.0, shy, shx, 1.0, 0.0, 0.0);
+    }
+
+    public void setTransform(AffineTransform tx) {
+        setTransform(tx.m00, tx.m10, tx.m01, tx.m11, tx.m02, tx.m12);
+    }
+
+    public void setTransform(double m00, double m10, double m01, double m11, double m02, double m12) {
+        this.m00 = m00;
+        this.m10 = m10;
+        this.m01 = m01;
+        this.m11 = m11;
+        this.m02 = m02;
+        this.m12 = m12;
+    }
+
+    /// Makes this transform apply `tx` first and then what it did before.
+    public void concatenate(AffineTransform tx) {
+        setTransform(
+                m00 * tx.m00 + m01 * tx.m10,
+                m10 * tx.m00 + m11 * tx.m10,
+                m00 * tx.m01 + m01 * tx.m11,
+                m10 * tx.m01 + m11 * tx.m11,
+                m00 * tx.m02 + m01 * tx.m12 + m02,
+                m10 * tx.m02 + m11 * tx.m12 + m12);
+    }
+
+    /// Makes this transform do what it did before and then apply `tx`.
+    public void preConcatenate(AffineTransform tx) {
+        setTransform(
+                tx.m00 * m00 + tx.m01 * m10,
+                tx.m10 * m00 + tx.m11 * m10,
+                tx.m00 * m01 + tx.m01 * m11,
+                tx.m10 * m01 + tx.m11 * m11,
+                tx.m00 * m02 + tx.m01 * m12 + tx.m02,
+                tx.m10 * m02 + tx.m11 * m12 + tx.m12);
+    }
+
+    public AffineTransform createInverse() throws NoninvertibleTransformException {
+        AffineTransform t = new AffineTransform(this);
+        t.invert();
+        return t;
+    }
+
+    public void invert() throws NoninvertibleTransformException {
+        double det = invertibleDeterminant();
+        setTransform(
+                m11 / det,
+                -m10 / det,
+                -m01 / det,
+                m00 / det,
+                (m01 * m12 - m11 * m02) / det,
+                (m10 * m02 - m00 * m12) / det);
+    }
+
+    private double invertibleDeterminant() throws NoninvertibleTransformException {
+        double det = getDeterminant();
+        if (det == 0.0 || Double.isNaN(det)) {
+            throw new NoninvertibleTransformException("Determinant is " + det);
+        }
+        return det;
+    }
+
+    /// Maps a point. When `ptDst` is null a new point is created, double
+    /// precision if the source is and single precision otherwise.
+    public Point2D transform(Point2D ptSrc, Point2D ptDst) {
+        if (ptDst == null) {
+            ptDst = newPointLike(ptSrc);
+        }
+        double x = ptSrc.getX();
+        double y = ptSrc.getY();
+        ptDst.setLocation(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12);
+        return ptDst;
+    }
+
+    private static Point2D newPointLike(Point2D p) {
+        if (p instanceof Point2D.Double) {
+            return new Point2D.Double();
+        }
+        return new Point2D.Float();
+    }
+
+    /// Forwards, point by point, into the destination's own objects, as the
+    /// JDK does. Its documentation says that this overload takes no
+    /// precautions against a destination that is a later source -- unlike
+    /// the overloads over coordinate arrays, which copy -- and code written
+    /// against it sees exactly that result here.
+    public void transform(Point2D[] ptSrc, int srcOff, Point2D[] ptDst, int dstOff, int numPts) {
+        for (int i = 0; i < numPts; i++) {
+            Point2D src = ptSrc[srcOff + i];
+            ptDst[dstOff + i] = transform(src, ptDst[dstOff + i]);
+        }
+    }
+
+    public void transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts) {
+        if (dstPts == srcPts && dstOff > srcOff && dstOff < srcOff + numPts * 2) {
+            System.arraycopy(srcPts, srcOff, dstPts, dstOff, numPts * 2);
+            srcOff = dstOff;
+        }
+        for (int i = 0; i < numPts; i++) {
+            double x = srcPts[srcOff++];
+            double y = srcPts[srcOff++];
+            dstPts[dstOff++] = (float) (x * m00 + y * m01 + m02);
+            dstPts[dstOff++] = (float) (x * m10 + y * m11 + m12);
+        }
+    }
+
+    public void transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) {
+        if (dstPts == srcPts && dstOff > srcOff && dstOff < srcOff + numPts * 2) {
+            System.arraycopy(srcPts, srcOff, dstPts, dstOff, numPts * 2);
+            srcOff = dstOff;
+        }
+        for (int i = 0; i < numPts; i++) {
+            double x = srcPts[srcOff++];
+            double y = srcPts[srcOff++];
+            dstPts[dstOff++] = x * m00 + y * m01 + m02;
+            dstPts[dstOff++] = x * m10 + y * m11 + m12;
+        }
+    }
+
+    public void transform(float[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) {
+        for (int i = 0; i < numPts; i++) {
+            double x = srcPts[srcOff++];
+            double y = srcPts[srcOff++];
+            dstPts[dstOff++] = x * m00 + y * m01 + m02;
+            dstPts[dstOff++] = x * m10 + y * m11 + m12;
+        }
+    }
+
+    public void transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts) {
+        for (int i = 0; i < numPts; i++) {
+            double x = srcPts[srcOff++];
+            double y = srcPts[srcOff++];
+            dstPts[dstOff++] = (float) (x * m00 + y * m01 + m02);
+            dstPts[dstOff++] = (float) (x * m10 + y * m11 + m12);
+        }
+    }
+
+    public Point2D inverseTransform(Point2D ptSrc, Point2D ptDst) throws NoninvertibleTransformException {
+        double det = invertibleDeterminant();
+        if (ptDst == null) {
+            ptDst = newPointLike(ptSrc);
+        }
+        double x = ptSrc.getX() - m02;
+        double y = ptSrc.getY() - m12;
+        ptDst.setLocation((x * m11 - y * m01) / det, (y * m00 - x * m10) / det);
+        return ptDst;
+    }
+
+    public void inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
+            throws NoninvertibleTransformException {
+        double det = invertibleDeterminant();
+        if (dstPts == srcPts && dstOff > srcOff && dstOff < srcOff + numPts * 2) {
+            System.arraycopy(srcPts, srcOff, dstPts, dstOff, numPts * 2);
+            srcOff = dstOff;
+        }
+        for (int i = 0; i < numPts; i++) {
+            double x = srcPts[srcOff++] - m02;
+            double y = srcPts[srcOff++] - m12;
+            dstPts[dstOff++] = (x * m11 - y * m01) / det;
+            dstPts[dstOff++] = (y * m00 - x * m10) / det;
+        }
+    }
+
+    /// Maps a vector: like [#transform(Point2D, Point2D)] without the
+    /// translation.
+    public Point2D deltaTransform(Point2D ptSrc, Point2D ptDst) {
+        if (ptDst == null) {
+            ptDst = newPointLike(ptSrc);
+        }
+        double x = ptSrc.getX();
+        double y = ptSrc.getY();
+        ptDst.setLocation(x * m00 + y * m01, x * m10 + y * m11);
+        return ptDst;
+    }
+
+    public void deltaTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) {
+        if (dstPts == srcPts && dstOff > srcOff && dstOff < srcOff + numPts * 2) {
+            System.arraycopy(srcPts, srcOff, dstPts, dstOff, numPts * 2);
+            srcOff = dstOff;
+        }
+        for (int i = 0; i < numPts; i++) {
+            double x = srcPts[srcOff++];
+            double y = srcPts[srcOff++];
+            dstPts[dstOff++] = x * m00 + y * m01;
+            dstPts[dstOff++] = x * m10 + y * m11;
+        }
+    }
+
+    /// Returns the transformed outline of a shape as a double precision
+    /// path, or null for a null shape.
+    public Shape createTransformedShape(Shape pSrc) {
+        if (pSrc == null) {
+            return null;
+        }
+        return new Path2D.Double(pSrc, this);
+    }
+
+    @Override
+    public String toString() {
+        return "AffineTransform[[" + m00 + ", " + m01 + ", " + m02 + "], ["
+                + m10 + ", " + m11 + ", " + m12 + "]]";
+    }
+
+    public boolean isIdentity() {
+        return m00 == 1.0 && m11 == 1.0 && m01 == 0.0 && m10 == 0.0 && m02 == 0.0 && m12 == 0.0;
+    }
+
+    @Override
+    public Object clone() {
+        return new AffineTransform(this);
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = Double.doubleToLongBits(m00);
+        bits = bits * 31 + Double.doubleToLongBits(m01);
+        bits = bits * 31 + Double.doubleToLongBits(m02);
+        bits = bits * 31 + Double.doubleToLongBits(m10);
+        bits = bits * 31 + Double.doubleToLongBits(m11);
+        bits = bits * 31 + Double.doubleToLongBits(m12);
+        return (int) bits ^ (int) (bits >> 32);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AffineTransform)) {
+            return false;
+        }
+        AffineTransform a = (AffineTransform) obj;
+        return m00 == a.m00 && m01 == a.m01 && m02 == a.m02 && m10 == a.m10 && m11 == a.m11 && m12 == a.m12;
+    }
+
+    /// Sines of 0, 1, 2 and 3 quarter turns; the cosine of n quarter turns is
+    /// the sine of n + 1.
+    private static final double[] QUADRANT_SINE = {0.0, 1.0, 0.0, -1.0};
+
+    /// The sine of an angle, exactly zero when the angle is a half turn as
+    /// closely as a double can say.
+    private static double sine(double theta) {
+        double sin = Math.sin(theta);
+        if (sin != 1.0 && sin != -1.0) {
+            double cos = Math.cos(theta);
+            if (cos == 1.0 || cos == -1.0) {
+                return 0.0;
+            }
+        }
+        return sin;
+    }
+
+    /// The cosine of an angle, exactly zero when its sine is exactly one.
+    private static double cosine(double theta) {
+        double sin = Math.sin(theta);
+        if (sin == 1.0 || sin == -1.0) {
+            return 0.0;
+        }
+        return Math.cos(theta);
+    }
+
+    /// The length of a direction vector, or zero for a vector that names no
+    /// direction. An axis aligned vector has length one whatever its size, so
+    /// the sine and cosine derived from it are exact.
+    private static double vectorLength(double vecx, double vecy) {
+        if (vecy == 0.0) {
+            return vecx < 0.0 ? 1.0 : (vecx > 0.0 ? 1.0 : 0.0);
+        }
+        if (vecx == 0.0) {
+            return 1.0;
+        }
+        return Math.sqrt(vecx * vecx + vecy * vecy);
+    }
+
+    private static double vectorSine(double vecx, double vecy, double len) {
+        if (vecy == 0.0) {
+            return 0.0;
+        }
+        if (vecx == 0.0) {
+            return vecy > 0.0 ? 1.0 : -1.0;
+        }
+        return vecy / len;
+    }
+
+    private static double vectorCosine(double vecx, double vecy, double len) {
+        if (vecx == 0.0) {
+            return 0.0;
+        }
+        if (vecy == 0.0) {
+            return vecx > 0.0 ? 1.0 : -1.0;
+        }
+        return vecx / len;
+    }
+
+    /// Concatenates a rotation given by its sine and cosine.
+    private void rotateBy(double sin, double cos) {
+        double a = m00;
+        double b = m01;
+        m00 = cos * a + sin * b;
+        m01 = -sin * a + cos * b;
+        a = m10;
+        b = m11;
+        m10 = cos * a + sin * b;
+        m11 = -sin * a + cos * b;
+    }
+
+    /// Moves the fixed point of the current rotation from the origin to the
+    /// given anchor.
+    private void anchor(double x, double y) {
+        m02 = x - (m00 * x + m01 * y);
+        m12 = y - (m10 * x + m11 * y);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Arc2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Arc2D.java
new file mode 100644
index 00000000000..d65a9b214c7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Arc2D.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.util.MathUtil;
+
+/// Part of the ellipse inscribed in a rectangular frame, from a start angle
+/// through an extent, both in degrees.
+///
+/// Angles are measured from the positive x axis and grow towards the
+/// negative y axis, which is counter-clockwise on a screen. They are angles
+/// of the frame's parameter, so 45 degrees always points at the frame's
+/// corner however far the frame is from square. The arc is left open, closed
+/// with a chord, or closed through the centre as a pie slice.
+///
+/// `setArcByTangent` is not provided.
+public abstract class Arc2D extends RectangularShape {
+
+    /// No closing segment; hit tests treat the arc as if it had a chord.
+    public static final int OPEN = 0;
+
+    /// Closed by a straight line between the ends of the arc.
+    public static final int CHORD = 1;
+
+    /// Closed by lines from the ends of the arc to the centre.
+    public static final int PIE = 2;
+
+    /// An arc stored in single precision.
+    public static class Float extends Arc2D {
+
+        public float x;
+        public float y;
+        public float width;
+        public float height;
+        public float start;
+        public float extent;
+
+        public Float() {
+            super(OPEN);
+        }
+
+        public Float(int type) {
+            super(type);
+        }
+
+        public Float(float x, float y, float w, float h, float start, float extent, int type) {
+            super(type);
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.start = start;
+            this.extent = extent;
+        }
+
+        public Float(Rectangle2D ellipseBounds, float start, float extent, int type) {
+            super(type);
+            this.x = (float) ellipseBounds.getX();
+            this.y = (float) ellipseBounds.getY();
+            this.width = (float) ellipseBounds.getWidth();
+            this.height = (float) ellipseBounds.getHeight();
+            this.start = start;
+            this.extent = extent;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public double getAngleStart() {
+            return start;
+        }
+
+        @Override
+        public double getAngleExtent() {
+            return extent;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0f || height <= 0.0f;
+        }
+
+        @Override
+        public void setArc(double x, double y, double w, double h, double angSt, double angExt, int closure) {
+            setArcType(closure);
+            this.x = (float) x;
+            this.y = (float) y;
+            this.width = (float) w;
+            this.height = (float) h;
+            this.start = (float) angSt;
+            this.extent = (float) angExt;
+        }
+
+        @Override
+        public void setAngleStart(double angSt) {
+            this.start = (float) angSt;
+        }
+
+        @Override
+        public void setAngleExtent(double angExt) {
+            this.extent = (float) angExt;
+        }
+
+        @Override
+        protected Rectangle2D makeBounds(double x, double y, double w, double h) {
+            return new Rectangle2D.Float((float) x, (float) y, (float) w, (float) h);
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x, y, width, height, start, extent, getArcType());
+        }
+    }
+
+    /// An arc stored in double precision.
+    public static class Double extends Arc2D {
+
+        public double x;
+        public double y;
+        public double width;
+        public double height;
+        public double start;
+        public double extent;
+
+        public Double() {
+            super(OPEN);
+        }
+
+        public Double(int type) {
+            super(type);
+        }
+
+        public Double(double x, double y, double w, double h, double start, double extent, int type) {
+            super(type);
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.start = start;
+            this.extent = extent;
+        }
+
+        public Double(Rectangle2D ellipseBounds, double start, double extent, int type) {
+            super(type);
+            this.x = ellipseBounds.getX();
+            this.y = ellipseBounds.getY();
+            this.width = ellipseBounds.getWidth();
+            this.height = ellipseBounds.getHeight();
+            this.start = start;
+            this.extent = extent;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public double getAngleStart() {
+            return start;
+        }
+
+        @Override
+        public double getAngleExtent() {
+            return extent;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0 || height <= 0.0;
+        }
+
+        @Override
+        public void setArc(double x, double y, double w, double h, double angSt, double angExt, int closure) {
+            setArcType(closure);
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.start = angSt;
+            this.extent = angExt;
+        }
+
+        @Override
+        public void setAngleStart(double angSt) {
+            this.start = angSt;
+        }
+
+        @Override
+        public void setAngleExtent(double angExt) {
+            this.extent = angExt;
+        }
+
+        @Override
+        protected Rectangle2D makeBounds(double x, double y, double w, double h) {
+            return new Rectangle2D.Double(x, y, w, h);
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x, y, width, height, start, extent, getArcType());
+        }
+    }
+
+    private int type;
+
+    protected Arc2D() {
+        this(OPEN);
+    }
+
+    protected Arc2D(int type) {
+        this.type = checkType(type);
+    }
+
+    private static int checkType(int type) {
+        if (type < OPEN || type > PIE) {
+            throw new IllegalArgumentException("invalid type for Arc: " + type);
+        }
+        return type;
+    }
+
+    public abstract double getAngleStart();
+
+    public abstract double getAngleExtent();
+
+    public int getArcType() {
+        return type;
+    }
+
+    public Point2D getStartPoint() {
+        return pointAt(getAngleStart());
+    }
+
+    public Point2D getEndPoint() {
+        return pointAt(getAngleStart() + getAngleExtent());
+    }
+
+    private Point2D pointAt(double degrees) {
+        double a = Math.toRadians(-degrees);
+        return new Point2D.Double(getX() + (Math.cos(a) * 0.5 + 0.5) * getWidth(),
+                getY() + (Math.sin(a) * 0.5 + 0.5) * getHeight());
+    }
+
+    public abstract void setArc(double x, double y, double w, double h, double angSt, double angExt, int closure);
+
+    public void setArc(Point2D loc, Dimension2D size, double angSt, double angExt, int closure) {
+        setArc(loc.getX(), loc.getY(), size.getWidth(), size.getHeight(), angSt, angExt, closure);
+    }
+
+    public void setArc(Rectangle2D rect, double angSt, double angExt, int closure) {
+        setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(), angSt, angExt, closure);
+    }
+
+    public void setArc(Arc2D a) {
+        setArc(a.getX(), a.getY(), a.getWidth(), a.getHeight(), a.getAngleStart(), a.getAngleExtent(), a.type);
+    }
+
+    public void setArcByCenter(double x, double y, double radius, double angSt, double angExt, int closure) {
+        setArc(x - radius, y - radius, radius * 2.0, radius * 2.0, angSt, angExt, closure);
+    }
+
+    public abstract void setAngleStart(double angSt);
+
+    public abstract void setAngleExtent(double angExt);
+
+    /// Starts the arc where the ray from the centre through the point
+    /// leaves the ellipse.
+    public void setAngleStart(Point2D p) {
+        setAngleStart(Math.toDegrees(angleTo(p.getX(), p.getY())));
+    }
+
+    /// Runs the arc counter-clockwise from the direction of the first point
+    /// to the direction of the second.
+    public void setAngles(double x1, double y1, double x2, double y2) {
+        double a1 = angleTo(x1, y1);
+        double sweep = angleTo(x2, y2) - a1;
+        if (sweep <= 0.0) {
+            sweep += Math.PI * 2.0;
+        }
+        setAngleStart(Math.toDegrees(a1));
+        setAngleExtent(Math.toDegrees(sweep));
+    }
+
+    public void setAngles(Point2D p1, Point2D p2) {
+        setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY());
+    }
+
+    /// The arc angle, in radians, at which the ray from the centre through
+    /// a point crosses the ellipse.
+    private double angleTo(double px, double py) {
+        return MathUtil.atan2(getWidth() * (getCenterY() - py), getHeight() * (px - getCenterX()));
+    }
+
+    public void setArcType(int type) {
+        this.type = checkType(type);
+    }
+
+    /// Moves and resizes the frame, keeping the angles and the closure.
+    @Override
+    public void setFrame(double x, double y, double w, double h) {
+        setArc(x, y, w, h, getAngleStart(), getAngleExtent(), type);
+    }
+
+    /// The tight bounds of the arc and its closing lines, not the frame of
+    /// the whole ellipse.
+    @Override
+    public Rectangle2D getBounds2D() {
+        if (isEmpty()) {
+            return makeBounds(getX(), getY(), getWidth(), getHeight());
+        }
+        // in the frame where the ellipse is the unit circle about the origin
+        double a0 = Math.toRadians(-getAngleStart());
+        double a1 = Math.toRadians(-getAngleStart() - getAngleExtent());
+        double[] xs = {Math.cos(a0), Math.cos(a1), 0.0, 1.0, 0.0, -1.0, 0.0};
+        double[] ys = {Math.sin(a0), Math.sin(a1), 0.0, 0.0, -1.0, 0.0, 1.0};
+        double x1 = Math.min(xs[0], xs[1]);
+        double x2 = Math.max(xs[0], xs[1]);
+        double y1 = Math.min(ys[0], ys[1]);
+        double y2 = Math.max(ys[0], ys[1]);
+        for (int i = 2; i < 7; i++) {
+            // the centre counts for a pie, an axis end when the arc passes it
+            if (i == 2 ? type == PIE : containsAngle((i - 3) * 90.0)) {
+                x1 = Math.min(x1, xs[i]);
+                x2 = Math.max(x2, xs[i]);
+                y1 = Math.min(y1, ys[i]);
+                y2 = Math.max(y2, ys[i]);
+            }
+        }
+        double w = getWidth() / 2.0;
+        double h = getHeight() / 2.0;
+        return makeBounds(getX() + w + x1 * w, getY() + h + y1 * h, (x2 - x1) * w, (y2 - y1) * h);
+    }
+
+    protected abstract Rectangle2D makeBounds(double x, double y, double w, double h);
+
+    /// Brings an angle into the range above -180 up to and including 180.
+    private static double normalize(double degrees) {
+        if (degrees > 180.0) {
+            if (degrees <= 540.0) {
+                return degrees - 360.0;
+            }
+            degrees = degrees - Math.floor(degrees / 360.0) * 360.0;
+            return degrees > 180.0 ? degrees - 360.0 : degrees;
+        }
+        if (degrees <= -180.0) {
+            if (degrees > -540.0) {
+                return degrees + 360.0;
+            }
+            degrees = degrees - Math.floor(degrees / 360.0) * 360.0;
+            return degrees > 180.0 ? degrees - 360.0 : degrees;
+        }
+        return degrees;
+    }
+
+    /// Whether an angle in degrees falls within the arc: at or after the
+    /// start in the arc's direction and before its end.
+    public boolean containsAngle(double angle) {
+        double extent = getAngleExtent();
+        boolean backwards = extent < 0.0;
+        if (backwards) {
+            extent = -extent;
+        }
+        if (extent >= 360.0) {
+            return true;
+        }
+        angle = normalize(angle) - normalize(getAngleStart());
+        if (backwards) {
+            angle = -angle;
+        }
+        if (angle < 0.0) {
+            angle += 360.0;
+        }
+        return angle >= 0.0 && angle < extent;
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        double w = getWidth();
+        double h = getHeight();
+        if (w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        // in the frame where the ellipse is the circle of diameter one
+        // about the origin
+        double nx = (x - getX()) / w - 0.5;
+        double ny = (y - getY()) / h - 0.5;
+        if (nx * nx + ny * ny >= 0.25) {
+            return false;
+        }
+        double extent = Math.abs(getAngleExtent());
+        if (extent >= 360.0) {
+            return true;
+        }
+        boolean inSector = containsAngle(-Math.toDegrees(MathUtil.atan2(ny, nx)));
+        if (type == PIE) {
+            return inSector;
+        }
+        // closed by the chord: the sector with the centre triangle removed
+        // when the arc is under a half turn, added when it is over
+        if (inSector) {
+            if (extent >= 180.0) {
+                return true;
+            }
+        } else if (extent <= 180.0) {
+            return false;
+        }
+        double a0 = Math.toRadians(-getAngleStart());
+        double a1 = Math.toRadians(-getAngleStart() - getAngleExtent());
+        double sx = Math.cos(a0);
+        double sy = Math.sin(a0);
+        double ex = Math.cos(a1);
+        double ey = Math.sin(a1);
+        boolean centreSide = Line2D.relativeCCW(sx, sy, ex, ey, nx * 2.0, ny * 2.0)
+                * Line2D.relativeCCW(sx, sy, ex, ey, 0.0, 0.0) >= 0;
+        return inSector ? !centreSide : centreSide;
+    }
+
+    /// Tested over the flattened outline unless the arc is a whole ellipse.
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        if (isEmpty() || w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        if (Math.abs(getAngleExtent()) >= 360.0) {
+            return new Ellipse2D.Double(getX(), getY(), getWidth(), getHeight()).intersects(x, y, w, h);
+        }
+        return Outline.of(this).intersects(x, y, w, h, PathIterator.WIND_NON_ZERO);
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        if (!(contains(x, y) && contains(x + w, y) && contains(x, y + h) && contains(x + w, y + h))) {
+            return false;
+        }
+        // every closure is convex except a pie of more than a half turn,
+        // whose notch a rectangle can straddle with all four corners inside
+        if (type != PIE || Math.abs(getAngleExtent()) <= 180.0) {
+            return true;
+        }
+        Rectangle2D r = new Rectangle2D.Double(x, y, w, h);
+        double cx = getCenterX();
+        double cy = getCenterY();
+        Point2D s = getStartPoint();
+        Point2D e = getEndPoint();
+        return !r.intersectsLine(cx, cy, s.getX(), s.getY()) && !r.intersectsLine(cx, cy, e.getX(), e.getY());
+    }
+
+    @Override
+    public boolean contains(Rectangle2D r) {
+        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    /// The arc as at most four cubic Bezier curves, each spanning no more
+    /// than a quarter turn, followed by the closing lines of its type. A
+    /// frame with a negative size has no outline at all.
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 7);
+        double w = getWidth() / 2.0;
+        double h = getHeight() / 2.0;
+        if (w < 0.0 || h < 0.0) {
+            return it;
+        }
+        double cx = getX() + w;
+        double cy = getY() + h;
+        // device angles: y grows downwards, so the sign flips
+        double start = -Math.toRadians(getAngleStart());
+        double sweep = -getAngleExtent();
+        int pieces;
+        double step;
+        if (sweep >= 360.0 || sweep <= -360.0) {
+            pieces = 4;
+            step = sweep < 0.0 ? -Math.PI / 2.0 : Math.PI / 2.0;
+        } else {
+            pieces = (int) Math.ceil(Math.abs(sweep) / 90.0);
+            step = pieces == 0 ? 0.0 : Math.toRadians(sweep / pieces);
+        }
+        // control points sit on the tangents at each end, this far along
+        double k = 4.0 / 3.0 * Math.tan(step / 4.0);
+        double cos = Math.cos(start);
+        double sin = Math.sin(start);
+        it.move(cx + cos * w, cy + sin * h);
+        for (int i = 1; i <= pieces; i++) {
+            double a = start + step * i;
+            double cos2 = Math.cos(a);
+            double sin2 = Math.sin(a);
+            it.cubic(cx + (cos - k * sin) * w, cy + (sin + k * cos) * h,
+                    cx + (cos2 + k * sin2) * w, cy + (sin2 - k * cos2) * h,
+                    cx + cos2 * w, cy + sin2 * h);
+            cos = cos2;
+            sin = sin2;
+        }
+        if (type == PIE) {
+            it.line(cx, cy);
+        }
+        if (type != OPEN) {
+            it.close();
+        }
+        return it;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = java.lang.Double.doubleToLongBits(getX());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getY());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getWidth());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getHeight());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getAngleStart());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getAngleExtent());
+        bits = bits * 31 + type;
+        return (int) bits ^ (int) (bits >> 32);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Arc2D) {
+            Arc2D a = (Arc2D) obj;
+            return getX() == a.getX() && getY() == a.getY()
+                    && getWidth() == a.getWidth() && getHeight() == a.getHeight()
+                    && getAngleStart() == a.getAngleStart() && getAngleExtent() == a.getAngleExtent()
+                    && type == a.type;
+        }
+        return false;
+    }
+
+    /// Returns a copy of this arc. A subclass from elsewhere that does not
+    /// override it gets a double precision arc back.
+    @Override
+    public Object clone() {
+        return new Double(getX(), getY(), getWidth(), getHeight(), getAngleStart(), getAngleExtent(), type);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/CubicCurve2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/CubicCurve2D.java
new file mode 100644
index 00000000000..61e62b0ae82
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/CubicCurve2D.java
@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// A cubic Bezier curve: two end points and two control points.
+///
+/// The area tested by `contains` and `intersects` is the region between the
+/// curve and the straight line joining its ends, and is evaluated over the
+/// flattened curve. `getBounds2D` answers the bounds of the four defining
+/// points, which enclose the curve without being tight. `solveCubic` is not
+/// provided.
+public abstract class CubicCurve2D implements Shape, Cloneable {
+
+    /// A curve stored in single precision.
+    public static class Float extends CubicCurve2D {
+
+        public float x1;
+        public float y1;
+        public float ctrlx1;
+        public float ctrly1;
+        public float ctrlx2;
+        public float ctrly2;
+        public float x2;
+        public float y2;
+
+        public Float() {
+        }
+
+        public Float(float x1, float y1, float ctrlx1, float ctrly1,
+                float ctrlx2, float ctrly2, float x2, float y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx1 = ctrlx1;
+            this.ctrly1 = ctrly1;
+            this.ctrlx2 = ctrlx2;
+            this.ctrly2 = ctrly2;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public double getX1() {
+            return x1;
+        }
+
+        @Override
+        public double getY1() {
+            return y1;
+        }
+
+        @Override
+        public Point2D getP1() {
+            return new Point2D.Float(x1, y1);
+        }
+
+        @Override
+        public double getCtrlX1() {
+            return ctrlx1;
+        }
+
+        @Override
+        public double getCtrlY1() {
+            return ctrly1;
+        }
+
+        @Override
+        public Point2D getCtrlP1() {
+            return new Point2D.Float(ctrlx1, ctrly1);
+        }
+
+        @Override
+        public double getCtrlX2() {
+            return ctrlx2;
+        }
+
+        @Override
+        public double getCtrlY2() {
+            return ctrly2;
+        }
+
+        @Override
+        public Point2D getCtrlP2() {
+            return new Point2D.Float(ctrlx2, ctrly2);
+        }
+
+        @Override
+        public double getX2() {
+            return x2;
+        }
+
+        @Override
+        public double getY2() {
+            return y2;
+        }
+
+        @Override
+        public Point2D getP2() {
+            return new Point2D.Float(x2, y2);
+        }
+
+        @Override
+        public void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
+                double ctrlx2, double ctrly2, double x2, double y2) {
+            this.x1 = (float) x1;
+            this.y1 = (float) y1;
+            this.ctrlx1 = (float) ctrlx1;
+            this.ctrly1 = (float) ctrly1;
+            this.ctrlx2 = (float) ctrlx2;
+            this.ctrly2 = (float) ctrly2;
+            this.x2 = (float) x2;
+            this.y2 = (float) y2;
+        }
+
+        public void setCurve(float x1, float y1, float ctrlx1, float ctrly1,
+                float ctrlx2, float ctrly2, float x2, float y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx1 = ctrlx1;
+            this.ctrly1 = ctrly1;
+            this.ctrlx2 = ctrlx2;
+            this.ctrly2 = ctrly2;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            float left = Math.min(Math.min(x1, x2), Math.min(ctrlx1, ctrlx2));
+            float top = Math.min(Math.min(y1, y2), Math.min(ctrly1, ctrly2));
+            float right = Math.max(Math.max(x1, x2), Math.max(ctrlx1, ctrlx2));
+            float bottom = Math.max(Math.max(y1, y2), Math.max(ctrly1, ctrly2));
+            return new Rectangle2D.Float(left, top, right - left, bottom - top);
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2);
+        }
+    }
+
+    /// A curve stored in double precision.
+    public static class Double extends CubicCurve2D {
+
+        public double x1;
+        public double y1;
+        public double ctrlx1;
+        public double ctrly1;
+        public double ctrlx2;
+        public double ctrly2;
+        public double x2;
+        public double y2;
+
+        public Double() {
+        }
+
+        public Double(double x1, double y1, double ctrlx1, double ctrly1,
+                double ctrlx2, double ctrly2, double x2, double y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx1 = ctrlx1;
+            this.ctrly1 = ctrly1;
+            this.ctrlx2 = ctrlx2;
+            this.ctrly2 = ctrly2;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public double getX1() {
+            return x1;
+        }
+
+        @Override
+        public double getY1() {
+            return y1;
+        }
+
+        @Override
+        public Point2D getP1() {
+            return new Point2D.Double(x1, y1);
+        }
+
+        @Override
+        public double getCtrlX1() {
+            return ctrlx1;
+        }
+
+        @Override
+        public double getCtrlY1() {
+            return ctrly1;
+        }
+
+        @Override
+        public Point2D getCtrlP1() {
+            return new Point2D.Double(ctrlx1, ctrly1);
+        }
+
+        @Override
+        public double getCtrlX2() {
+            return ctrlx2;
+        }
+
+        @Override
+        public double getCtrlY2() {
+            return ctrly2;
+        }
+
+        @Override
+        public Point2D getCtrlP2() {
+            return new Point2D.Double(ctrlx2, ctrly2);
+        }
+
+        @Override
+        public double getX2() {
+            return x2;
+        }
+
+        @Override
+        public double getY2() {
+            return y2;
+        }
+
+        @Override
+        public Point2D getP2() {
+            return new Point2D.Double(x2, y2);
+        }
+
+        @Override
+        public void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
+                double ctrlx2, double ctrly2, double x2, double y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx1 = ctrlx1;
+            this.ctrly1 = ctrly1;
+            this.ctrlx2 = ctrlx2;
+            this.ctrly2 = ctrly2;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            double left = Math.min(Math.min(x1, x2), Math.min(ctrlx1, ctrlx2));
+            double top = Math.min(Math.min(y1, y2), Math.min(ctrly1, ctrly2));
+            double right = Math.max(Math.max(x1, x2), Math.max(ctrlx1, ctrlx2));
+            double bottom = Math.max(Math.max(y1, y2), Math.max(ctrly1, ctrly2));
+            return new Rectangle2D.Double(left, top, right - left, bottom - top);
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2);
+        }
+    }
+
+    protected CubicCurve2D() {
+    }
+
+    public abstract double getX1();
+
+    public abstract double getY1();
+
+    public abstract Point2D getP1();
+
+    public abstract double getCtrlX1();
+
+    public abstract double getCtrlY1();
+
+    public abstract Point2D getCtrlP1();
+
+    public abstract double getCtrlX2();
+
+    public abstract double getCtrlY2();
+
+    public abstract Point2D getCtrlP2();
+
+    public abstract double getX2();
+
+    public abstract double getY2();
+
+    public abstract Point2D getP2();
+
+    public abstract void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
+            double ctrlx2, double ctrly2, double x2, double y2);
+
+    public void setCurve(double[] coords, int offset) {
+        setCurve(coords[offset], coords[offset + 1], coords[offset + 2], coords[offset + 3],
+                coords[offset + 4], coords[offset + 5], coords[offset + 6], coords[offset + 7]);
+    }
+
+    public void setCurve(Point2D p1, Point2D cp1, Point2D cp2, Point2D p2) {
+        setCurve(p1.getX(), p1.getY(), cp1.getX(), cp1.getY(), cp2.getX(), cp2.getY(), p2.getX(), p2.getY());
+    }
+
+    public void setCurve(Point2D[] pts, int offset) {
+        setCurve(pts[offset].getX(), pts[offset].getY(), pts[offset + 1].getX(), pts[offset + 1].getY(),
+                pts[offset + 2].getX(), pts[offset + 2].getY(), pts[offset + 3].getX(), pts[offset + 3].getY());
+    }
+
+    public void setCurve(CubicCurve2D c) {
+        setCurve(c.getX1(), c.getY1(), c.getCtrlX1(), c.getCtrlY1(),
+                c.getCtrlX2(), c.getCtrlY2(), c.getX2(), c.getY2());
+    }
+
+    /// The square of the larger distance of the two control points from the
+    /// segment joining the end points.
+    public static double getFlatnessSq(double x1, double y1, double ctrlx1, double ctrly1,
+            double ctrlx2, double ctrly2, double x2, double y2) {
+        return Math.max(Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx1, ctrly1),
+                Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx2, ctrly2));
+    }
+
+    public static double getFlatness(double x1, double y1, double ctrlx1, double ctrly1,
+            double ctrlx2, double ctrly2, double x2, double y2) {
+        return Math.sqrt(getFlatnessSq(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2));
+    }
+
+    public static double getFlatnessSq(double[] coords, int offset) {
+        return getFlatnessSq(coords[offset], coords[offset + 1], coords[offset + 2], coords[offset + 3],
+                coords[offset + 4], coords[offset + 5], coords[offset + 6], coords[offset + 7]);
+    }
+
+    public static double getFlatness(double[] coords, int offset) {
+        return Math.sqrt(getFlatnessSq(coords, offset));
+    }
+
+    public double getFlatnessSq() {
+        return getFlatnessSq(getX1(), getY1(), getCtrlX1(), getCtrlY1(), getCtrlX2(), getCtrlY2(), getX2(), getY2());
+    }
+
+    public double getFlatness() {
+        return Math.sqrt(getFlatnessSq());
+    }
+
+    /// Splits this curve at its middle into two curves; either may be null
+    /// or this curve itself.
+    public void subdivide(CubicCurve2D left, CubicCurve2D right) {
+        subdivide(this, left, right);
+    }
+
+    public static void subdivide(CubicCurve2D src, CubicCurve2D left, CubicCurve2D right) {
+        double[] c = {src.getX1(), src.getY1(), src.getCtrlX1(), src.getCtrlY1(),
+            src.getCtrlX2(), src.getCtrlY2(), src.getX2(), src.getY2()};
+        double[] l = new double[8];
+        double[] r = new double[8];
+        subdivide(c, 0, l, 0, r, 0);
+        if (left != null) {
+            left.setCurve(l, 0);
+        }
+        if (right != null) {
+            right.setCurve(r, 0);
+        }
+    }
+
+    /// Splits eight coordinates into two curves of eight; a destination may
+    /// be null, and may be the source array where the ranges allow it.
+    public static void subdivide(double[] src, int srcoff, double[] left, int leftoff, double[] right, int rightoff) {
+        double x1 = src[srcoff];
+        double y1 = src[srcoff + 1];
+        double ax = src[srcoff + 2];
+        double ay = src[srcoff + 3];
+        double bx = src[srcoff + 4];
+        double by = src[srcoff + 5];
+        double x2 = src[srcoff + 6];
+        double y2 = src[srcoff + 7];
+        double midx = (ax + bx) / 2.0;
+        double midy = (ay + by) / 2.0;
+        double lax = (x1 + ax) / 2.0;
+        double lay = (y1 + ay) / 2.0;
+        double rbx = (bx + x2) / 2.0;
+        double rby = (by + y2) / 2.0;
+        double lbx = (lax + midx) / 2.0;
+        double lby = (lay + midy) / 2.0;
+        double rax = (midx + rbx) / 2.0;
+        double ray = (midy + rby) / 2.0;
+        double mx = (lbx + rax) / 2.0;
+        double my = (lby + ray) / 2.0;
+        if (left != null) {
+            left[leftoff] = x1;
+            left[leftoff + 1] = y1;
+            left[leftoff + 2] = lax;
+            left[leftoff + 3] = lay;
+            left[leftoff + 4] = lbx;
+            left[leftoff + 5] = lby;
+            left[leftoff + 6] = mx;
+            left[leftoff + 7] = my;
+        }
+        if (right != null) {
+            right[rightoff] = mx;
+            right[rightoff + 1] = my;
+            right[rightoff + 2] = rax;
+            right[rightoff + 3] = ray;
+            right[rightoff + 4] = rbx;
+            right[rightoff + 5] = rby;
+            right[rightoff + 6] = x2;
+            right[rightoff + 7] = y2;
+        }
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        return Outline.of(this).contains(x, y, PathIterator.WIND_EVEN_ODD);
+    }
+
+    @Override
+    public boolean contains(Point2D p) {
+        return contains(p.getX(), p.getY());
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        return Outline.of(this).intersects(x, y, w, h, PathIterator.WIND_EVEN_ODD);
+    }
+
+    @Override
+    public boolean intersects(Rectangle2D r) {
+        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        return Outline.of(this).contains(x, y, w, h, PathIterator.WIND_EVEN_ODD);
+    }
+
+    @Override
+    public boolean contains(Rectangle2D r) {
+        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return getBounds2D().getBounds();
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 2);
+        it.move(getX1(), getY1());
+        it.cubic(getCtrlX1(), getCtrlY1(), getCtrlX2(), getCtrlY2(), getX2(), getY2());
+        return it;
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return new FlatteningPathIterator(getPathIterator(at), flatness);
+    }
+
+    /// Returns a copy of this curve. A subclass from elsewhere that does not
+    /// override it gets a double precision curve back.
+    @Override
+    public Object clone() {
+        return new Double(getX1(), getY1(), getCtrlX1(), getCtrlY1(), getCtrlX2(), getCtrlY2(), getX2(), getY2());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Dimension2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Dimension2D.java
new file mode 100644
index 00000000000..8ea7ae1991c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Dimension2D.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// A width and a height, stored by a subclass in the precision it chooses.
+public abstract class Dimension2D implements Cloneable {
+
+    /// The copy handed out for a subclass that does not override `clone()`.
+    private static final class Copy extends Dimension2D {
+
+        private double width;
+        private double height;
+
+        Copy(double width, double height) {
+            this.width = width;
+            this.height = height;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public void setSize(double width, double height) {
+            this.width = width;
+            this.height = height;
+        }
+
+        @Override
+        public Object clone() {
+            return new Copy(width, height);
+        }
+    }
+
+    protected Dimension2D() {
+    }
+
+    public abstract double getWidth();
+
+    public abstract double getHeight();
+
+    public abstract void setSize(double width, double height);
+
+    public void setSize(Dimension2D d) {
+        setSize(d.getWidth(), d.getHeight());
+    }
+
+    /// Returns a copy of this size. A subclass that does not override it gets
+    /// a plain double precision size back rather than its own type.
+    @Override
+    public Object clone() {
+        return new Copy(getWidth(), getHeight());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Ellipse2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Ellipse2D.java
new file mode 100644
index 00000000000..5376638d67b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Ellipse2D.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// The ellipse inscribed in a rectangular frame.
+///
+/// Its outline is four cubic Bezier curves, one per quarter, starting at the
+/// middle of the right side and running through the bottom, left and top.
+public abstract class Ellipse2D extends RectangularShape {
+
+    /// How far a quarter-circle's control points sit from its ends, as a
+    /// fraction of the radius: four thirds of the tangent of a sixteenth of
+    /// a turn.
+    static final double KAPPA = 4.0 / 3.0 * (Math.sqrt(2.0) - 1.0);
+
+    /// An ellipse stored in single precision.
+    public static class Float extends Ellipse2D {
+
+        public float x;
+        public float y;
+        public float width;
+        public float height;
+
+        public Float() {
+        }
+
+        public Float(float x, float y, float w, float h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0f || height <= 0.0f;
+        }
+
+        public void setFrame(float x, float y, float w, float h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public void setFrame(double x, double y, double w, double h) {
+            this.x = (float) x;
+            this.y = (float) y;
+            this.width = (float) w;
+            this.height = (float) h;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Rectangle2D.Float(x, y, width, height);
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x, y, width, height);
+        }
+    }
+
+    /// An ellipse stored in double precision.
+    public static class Double extends Ellipse2D {
+
+        public double x;
+        public double y;
+        public double width;
+        public double height;
+
+        public Double() {
+        }
+
+        public Double(double x, double y, double w, double h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0 || height <= 0.0;
+        }
+
+        @Override
+        public void setFrame(double x, double y, double w, double h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Rectangle2D.Double(x, y, width, height);
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x, y, width, height);
+        }
+    }
+
+    protected Ellipse2D() {
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        double w = getWidth();
+        double h = getHeight();
+        if (w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        // in the frame where the ellipse is the circle of diameter one
+        // about the origin
+        double nx = (x - getX()) / w - 0.5;
+        double ny = (y - getY()) / h - 0.5;
+        return nx * nx + ny * ny < 0.25;
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        double ew = getWidth();
+        double eh = getHeight();
+        if (w <= 0.0 || h <= 0.0 || ew <= 0.0 || eh <= 0.0) {
+            return false;
+        }
+        // the rectangle in the unit-circle frame, then its point nearest
+        // the centre
+        double nx0 = (x - getX()) / ew - 0.5;
+        double nx1 = nx0 + w / ew;
+        double ny0 = (y - getY()) / eh - 0.5;
+        double ny1 = ny0 + h / eh;
+        double nearX = nx0 > 0.0 ? nx0 : (nx1 < 0.0 ? nx1 : 0.0);
+        double nearY = ny0 > 0.0 ? ny0 : (ny1 < 0.0 ? ny1 : 0.0);
+        return nearX * nearX + nearY * nearY < 0.25;
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        // an ellipse is convex, so the corners decide
+        return contains(x, y) && contains(x + w, y)
+                && contains(x, y + h) && contains(x + w, y + h);
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 6);
+        double x = getX();
+        double y = getY();
+        double w = getWidth();
+        double h = getHeight();
+        // A negative size has no outline, as in the JDK.
+        if (w < 0 || h < 0) {
+            return it;
+        }
+        double near = 0.5 - KAPPA / 2.0;
+        double far = 0.5 + KAPPA / 2.0;
+        it.move(x + w, y + h * 0.5);
+        it.cubic(x + w, y + h * far, x + w * far, y + h, x + w * 0.5, y + h);
+        it.cubic(x + w * near, y + h, x, y + h * far, x, y + h * 0.5);
+        it.cubic(x, y + h * near, x + w * near, y, x + w * 0.5, y);
+        it.cubic(x + w * far, y, x + w, y + h * near, x + w, y + h * 0.5);
+        it.close();
+        return it;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = java.lang.Double.doubleToLongBits(getX());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getY());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getWidth());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getHeight());
+        return (int) bits ^ (int) (bits >> 32);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Ellipse2D) {
+            Ellipse2D e = (Ellipse2D) obj;
+            return getX() == e.getX() && getY() == e.getY()
+                    && getWidth() == e.getWidth() && getHeight() == e.getHeight();
+        }
+        return false;
+    }
+
+    /// Returns a copy of this ellipse. A subclass from elsewhere that does
+    /// not override it gets a double precision ellipse back.
+    @Override
+    public Object clone() {
+        return new Double(getX(), getY(), getWidth(), getHeight());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/FlatteningPathIterator.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/FlatteningPathIterator.java
new file mode 100644
index 00000000000..2f52062de50
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/FlatteningPathIterator.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+/// Reads another path iterator and replaces every curve with straight lines
+/// that stay within a given distance of it.
+///
+/// A curve is halved until its control points are within the flatness of
+/// the chord joining its ends, or until it has been halved `limit` times.
+/// Every point returned lies on the original curve. The number of lines a
+/// curve becomes is not promised to match any other implementation.
+public class FlatteningPathIterator implements PathIterator {
+
+    private final PathIterator src;
+    private final double flatness;
+    private final double flatnessSq;
+    private final int limit;
+    private final double[] segment = new double[6];
+
+    /// End points of the lines the current curve became, not yet returned.
+    private double[] pending = new double[32];
+    private int pendingCount;
+    private int pendingIndex;
+
+    private double curX;
+    private double curY;
+    private double moveX;
+    private double moveY;
+    private int type;
+    private boolean done;
+
+    public FlatteningPathIterator(PathIterator src, double flatness) {
+        this(src, flatness, 10);
+    }
+
+    public FlatteningPathIterator(PathIterator src, double flatness, int limit) {
+        if (flatness < 0.0) {
+            throw new IllegalArgumentException("flatness must be >= 0");
+        }
+        if (limit < 0) {
+            throw new IllegalArgumentException("limit must be >= 0");
+        }
+        this.src = src;
+        this.flatness = flatness;
+        this.flatnessSq = flatness * flatness;
+        this.limit = limit;
+        advance();
+    }
+
+    public double getFlatness() {
+        return flatness;
+    }
+
+    public int getRecursionLimit() {
+        return limit;
+    }
+
+    @Override
+    public int getWindingRule() {
+        return src.getWindingRule();
+    }
+
+    @Override
+    public boolean isDone() {
+        return done;
+    }
+
+    @Override
+    public void next() {
+        advance();
+    }
+
+    private void advance() {
+        if (pendingIndex < pendingCount) {
+            curX = pending[pendingIndex++];
+            curY = pending[pendingIndex++];
+            type = SEG_LINETO;
+            return;
+        }
+        if (src.isDone()) {
+            done = true;
+            return;
+        }
+        int t = src.currentSegment(segment);
+        src.next();
+        switch (t) {
+            case SEG_MOVETO:
+                curX = segment[0];
+                curY = segment[1];
+                moveX = curX;
+                moveY = curY;
+                type = SEG_MOVETO;
+                break;
+            case SEG_LINETO:
+                curX = segment[0];
+                curY = segment[1];
+                type = SEG_LINETO;
+                break;
+            case SEG_QUADTO:
+                pendingCount = 0;
+                pendingIndex = 0;
+                quad(curX, curY, segment[0], segment[1], segment[2], segment[3], 0);
+                advance();
+                break;
+            case SEG_CUBICTO:
+                pendingCount = 0;
+                pendingIndex = 0;
+                cubic(curX, curY, segment[0], segment[1], segment[2], segment[3], segment[4], segment[5], 0);
+                advance();
+                break;
+            default:
+                curX = moveX;
+                curY = moveY;
+                type = SEG_CLOSE;
+                break;
+        }
+    }
+
+    private void push(double x, double y) {
+        if (pendingCount + 2 > pending.length) {
+            double[] p = new double[pending.length * 2];
+            System.arraycopy(pending, 0, p, 0, pendingCount);
+            pending = p;
+        }
+        pending[pendingCount++] = x;
+        pending[pendingCount++] = y;
+    }
+
+    private void quad(double x0, double y0, double cx, double cy, double x1, double y1, int level) {
+        if (level >= limit || Line2D.ptSegDistSq(x0, y0, x1, y1, cx, cy) <= flatnessSq) {
+            push(x1, y1);
+            return;
+        }
+        double lx = (x0 + cx) / 2.0;
+        double ly = (y0 + cy) / 2.0;
+        double rx = (cx + x1) / 2.0;
+        double ry = (cy + y1) / 2.0;
+        double mx = (lx + rx) / 2.0;
+        double my = (ly + ry) / 2.0;
+        quad(x0, y0, lx, ly, mx, my, level + 1);
+        quad(mx, my, rx, ry, x1, y1, level + 1);
+    }
+
+    private void cubic(double x0, double y0, double ax, double ay, double bx, double by,
+            double x1, double y1, int level) {
+        if (level >= limit || (Line2D.ptSegDistSq(x0, y0, x1, y1, ax, ay) <= flatnessSq
+                && Line2D.ptSegDistSq(x0, y0, x1, y1, bx, by) <= flatnessSq)) {
+            push(x1, y1);
+            return;
+        }
+        double lax = (x0 + ax) / 2.0;
+        double lay = (y0 + ay) / 2.0;
+        double midx = (ax + bx) / 2.0;
+        double midy = (ay + by) / 2.0;
+        double rbx = (bx + x1) / 2.0;
+        double rby = (by + y1) / 2.0;
+        double lbx = (lax + midx) / 2.0;
+        double lby = (lay + midy) / 2.0;
+        double rax = (midx + rbx) / 2.0;
+        double ray = (midy + rby) / 2.0;
+        double mx = (lbx + rax) / 2.0;
+        double my = (lby + ray) / 2.0;
+        cubic(x0, y0, lax, lay, lbx, lby, mx, my, level + 1);
+        cubic(mx, my, rax, ray, rbx, rby, x1, y1, level + 1);
+    }
+
+    @Override
+    public int currentSegment(float[] coords) {
+        if (done) {
+            throw new NoSuchElementException("flattening iterator out of bounds");
+        }
+        if (type != SEG_CLOSE) {
+            coords[0] = (float) curX;
+            coords[1] = (float) curY;
+        }
+        return type;
+    }
+
+    @Override
+    public int currentSegment(double[] coords) {
+        if (done) {
+            throw new NoSuchElementException("flattening iterator out of bounds");
+        }
+        if (type != SEG_CLOSE) {
+            coords[0] = curX;
+            coords[1] = curY;
+        }
+        return type;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/GeneralPath.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/GeneralPath.java
new file mode 100644
index 00000000000..91dd896c8ca
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/GeneralPath.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// The original name of the single precision path; identical to
+/// [Path2D.Float] apart from being final.
+public final class GeneralPath extends Path2D.Float {
+
+    public GeneralPath() {
+        super(WIND_NON_ZERO, 20);
+    }
+
+    public GeneralPath(int rule) {
+        super(rule, 20);
+    }
+
+    public GeneralPath(int rule, int initialCapacity) {
+        super(rule, initialCapacity);
+    }
+
+    public GeneralPath(Shape s) {
+        super(s, null);
+    }
+
+    @Override
+    public Object clone() {
+        return new GeneralPath(this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/IllegalPathStateException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/IllegalPathStateException.java
new file mode 100644
index 00000000000..8228ddebf90
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/IllegalPathStateException.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// Thrown when a path is asked for something its current state cannot give,
+/// such as a line before the first move.
+public class IllegalPathStateException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public IllegalPathStateException() {
+        super();
+    }
+
+    public IllegalPathStateException(String s) {
+        super(s);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Line2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Line2D.java
new file mode 100644
index 00000000000..a5c2c373667
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Line2D.java
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// A line segment between two points. It has no area, so it contains
+/// nothing, but it can be tested against rectangles and other segments.
+public abstract class Line2D implements Shape, Cloneable {
+
+    /// A segment stored in single precision.
+    public static class Float extends Line2D {
+
+        public float x1;
+        public float y1;
+        public float x2;
+        public float y2;
+
+        public Float() {
+        }
+
+        public Float(float x1, float y1, float x2, float y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        public Float(Point2D p1, Point2D p2) {
+            this.x1 = (float) p1.getX();
+            this.y1 = (float) p1.getY();
+            this.x2 = (float) p2.getX();
+            this.y2 = (float) p2.getY();
+        }
+
+        @Override
+        public double getX1() {
+            return x1;
+        }
+
+        @Override
+        public double getY1() {
+            return y1;
+        }
+
+        @Override
+        public Point2D getP1() {
+            return new Point2D.Float(x1, y1);
+        }
+
+        @Override
+        public double getX2() {
+            return x2;
+        }
+
+        @Override
+        public double getY2() {
+            return y2;
+        }
+
+        @Override
+        public Point2D getP2() {
+            return new Point2D.Float(x2, y2);
+        }
+
+        @Override
+        public void setLine(double x1, double y1, double x2, double y2) {
+            this.x1 = (float) x1;
+            this.y1 = (float) y1;
+            this.x2 = (float) x2;
+            this.y2 = (float) y2;
+        }
+
+        public void setLine(float x1, float y1, float x2, float y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Rectangle2D.Float(Math.min(x1, x2), Math.min(y1, y2),
+                    Math.abs(x2 - x1), Math.abs(y2 - y1));
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x1, y1, x2, y2);
+        }
+    }
+
+    /// A segment stored in double precision.
+    public static class Double extends Line2D {
+
+        public double x1;
+        public double y1;
+        public double x2;
+        public double y2;
+
+        public Double() {
+        }
+
+        public Double(double x1, double y1, double x2, double y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        public Double(Point2D p1, Point2D p2) {
+            this.x1 = p1.getX();
+            this.y1 = p1.getY();
+            this.x2 = p2.getX();
+            this.y2 = p2.getY();
+        }
+
+        @Override
+        public double getX1() {
+            return x1;
+        }
+
+        @Override
+        public double getY1() {
+            return y1;
+        }
+
+        @Override
+        public Point2D getP1() {
+            return new Point2D.Double(x1, y1);
+        }
+
+        @Override
+        public double getX2() {
+            return x2;
+        }
+
+        @Override
+        public double getY2() {
+            return y2;
+        }
+
+        @Override
+        public Point2D getP2() {
+            return new Point2D.Double(x2, y2);
+        }
+
+        @Override
+        public void setLine(double x1, double y1, double x2, double y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Rectangle2D.Double(Math.min(x1, x2), Math.min(y1, y2),
+                    Math.abs(x2 - x1), Math.abs(y2 - y1));
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x1, y1, x2, y2);
+        }
+    }
+
+    protected Line2D() {
+    }
+
+    public abstract double getX1();
+
+    public abstract double getY1();
+
+    public abstract Point2D getP1();
+
+    public abstract double getX2();
+
+    public abstract double getY2();
+
+    public abstract Point2D getP2();
+
+    public abstract void setLine(double x1, double y1, double x2, double y2);
+
+    public void setLine(Point2D p1, Point2D p2) {
+        setLine(p1.getX(), p1.getY(), p2.getX(), p2.getY());
+    }
+
+    public void setLine(Line2D l) {
+        setLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
+    }
+
+    /// Tells which way the segment from `(x1, y1)` to `(x2, y2)` has to turn
+    /// about its first end to point at `(px, py)`: 1 when that is the turn
+    /// taking the positive x axis towards the negative y axis, -1 for the
+    /// opposite turn. For a point on the segment's line the answer is 0 when
+    /// it lies between the ends, -1 when it lies before the first end and 1
+    /// when it lies past the second.
+    public static int relativeCCW(double x1, double y1, double x2, double y2, double px, double py) {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double rx = px - x1;
+        double ry = py - y1;
+        double side = rx * dy - ry * dx;
+        if (side == 0.0) {
+            // on the line: order the point along it instead
+            side = rx * dx + ry * dy;
+            if (side > 0.0) {
+                side = (rx - dx) * dx + (ry - dy) * dy;
+                if (side < 0.0) {
+                    side = 0.0;
+                }
+            }
+        }
+        return side < 0.0 ? -1 : (side > 0.0 ? 1 : 0);
+    }
+
+    public int relativeCCW(double px, double py) {
+        return relativeCCW(getX1(), getY1(), getX2(), getY2(), px, py);
+    }
+
+    public int relativeCCW(Point2D p) {
+        return relativeCCW(getX1(), getY1(), getX2(), getY2(), p.getX(), p.getY());
+    }
+
+    /// Whether two segments share a point: each must have the other's ends
+    /// on opposite sides of it, or on it.
+    public static boolean linesIntersect(double x1, double y1, double x2, double y2,
+            double x3, double y3, double x4, double y4) {
+        return relativeCCW(x1, y1, x2, y2, x3, y3) * relativeCCW(x1, y1, x2, y2, x4, y4) <= 0
+                && relativeCCW(x3, y3, x4, y4, x1, y1) * relativeCCW(x3, y3, x4, y4, x2, y2) <= 0;
+    }
+
+    public boolean intersectsLine(double x1, double y1, double x2, double y2) {
+        return linesIntersect(x1, y1, x2, y2, getX1(), getY1(), getX2(), getY2());
+    }
+
+    public boolean intersectsLine(Line2D l) {
+        return linesIntersect(l.getX1(), l.getY1(), l.getX2(), l.getY2(), getX1(), getY1(), getX2(), getY2());
+    }
+
+    /// The square of the distance from a point to the nearest point of a
+    /// segment.
+    public static double ptSegDistSq(double x1, double y1, double x2, double y2, double px, double py) {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double rx = px - x1;
+        double ry = py - y1;
+        double along = rx * dx + ry * dy;
+        double projSq;
+        if (along <= 0.0) {
+            // nearest to the first end
+            projSq = 0.0;
+        } else {
+            // measure from the second end instead
+            rx = dx - rx;
+            ry = dy - ry;
+            along = rx * dx + ry * dy;
+            projSq = along <= 0.0 ? 0.0 : along * along / (dx * dx + dy * dy);
+        }
+        double distSq = rx * rx + ry * ry - projSq;
+        return distSq < 0.0 ? 0.0 : distSq;
+    }
+
+    public static double ptSegDist(double x1, double y1, double x2, double y2, double px, double py) {
+        return Math.sqrt(ptSegDistSq(x1, y1, x2, y2, px, py));
+    }
+
+    public double ptSegDistSq(double px, double py) {
+        return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
+    }
+
+    public double ptSegDistSq(Point2D pt) {
+        return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), pt.getX(), pt.getY());
+    }
+
+    public double ptSegDist(double px, double py) {
+        return ptSegDist(getX1(), getY1(), getX2(), getY2(), px, py);
+    }
+
+    public double ptSegDist(Point2D pt) {
+        return ptSegDist(getX1(), getY1(), getX2(), getY2(), pt.getX(), pt.getY());
+    }
+
+    /// The square of the distance from a point to the infinite line through
+    /// two points.
+    public static double ptLineDistSq(double x1, double y1, double x2, double y2, double px, double py) {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double rx = px - x1;
+        double ry = py - y1;
+        double along = rx * dx + ry * dy;
+        double distSq = rx * rx + ry * ry - along * along / (dx * dx + dy * dy);
+        return distSq < 0.0 ? 0.0 : distSq;
+    }
+
+    public static double ptLineDist(double x1, double y1, double x2, double y2, double px, double py) {
+        return Math.sqrt(ptLineDistSq(x1, y1, x2, y2, px, py));
+    }
+
+    public double ptLineDistSq(double px, double py) {
+        return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
+    }
+
+    public double ptLineDistSq(Point2D pt) {
+        return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), pt.getX(), pt.getY());
+    }
+
+    public double ptLineDist(double px, double py) {
+        return ptLineDist(getX1(), getY1(), getX2(), getY2(), px, py);
+    }
+
+    public double ptLineDist(Point2D pt) {
+        return ptLineDist(getX1(), getY1(), getX2(), getY2(), pt.getX(), pt.getY());
+    }
+
+    /// Always false: a segment has no interior.
+    @Override
+    public boolean contains(double x, double y) {
+        return false;
+    }
+
+    /// Always false: a segment has no interior.
+    @Override
+    public boolean contains(Point2D p) {
+        return false;
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        return new Rectangle2D.Double(x, y, w, h).intersectsLine(getX1(), getY1(), getX2(), getY2());
+    }
+
+    @Override
+    public boolean intersects(Rectangle2D r) {
+        return r.intersectsLine(getX1(), getY1(), getX2(), getY2());
+    }
+
+    /// Always false: a segment has no interior.
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        return false;
+    }
+
+    /// Always false: a segment has no interior.
+    @Override
+    public boolean contains(Rectangle2D r) {
+        return false;
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return getBounds2D().getBounds();
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 2);
+        it.move(getX1(), getY1());
+        it.line(getX2(), getY2());
+        return it;
+    }
+
+    /// A segment is already flat, so this is the plain outline.
+    @Override
+    public PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return getPathIterator(at);
+    }
+
+    /// Returns a copy of this segment. A subclass from elsewhere that does
+    /// not override it gets a double precision segment back.
+    @Override
+    public Object clone() {
+        return new Double(getX1(), getY1(), getX2(), getY2());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/NoninvertibleTransformException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/NoninvertibleTransformException.java
new file mode 100644
index 00000000000..749b779957e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/NoninvertibleTransformException.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// Thrown when an operation needs the inverse of an [AffineTransform] whose
+/// determinant is zero.
+public class NoninvertibleTransformException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    public NoninvertibleTransformException(String s) {
+        super(s);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Outline.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Outline.java
new file mode 100644
index 00000000000..65a31825e3f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Outline.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// The flattened outline of a shape as a list of directed edges, with every
+/// subpath closed, for hit testing.
+///
+/// Point tests count the edges a ray towards positive x crosses, with an
+/// edge owning its upper end and not its lower one, so a point on a left or
+/// top boundary is inside and one on a right or bottom boundary is not.
+/// Rectangle tests are exact for polygons: the open interior of a rectangle
+/// that no edge passes through lies wholly inside or wholly outside.
+final class Outline {
+
+    private double[] edges = new double[64];
+    private int size;
+
+    /// Flattens a shape to within a hundred-thousandth of its larger side.
+    static Outline of(Shape s) {
+        Rectangle2D b = s.getBounds2D();
+        double flatness = Math.max(b.getWidth(), b.getHeight()) * 1e-5;
+        if (!(flatness > 0.0)) {
+            flatness = 0.0;
+        }
+        return new Outline(new FlatteningPathIterator(s.getPathIterator(null), flatness));
+    }
+
+    /// Reads an iterator that returns only moves, lines and closes.
+    private Outline(PathIterator pi) {
+        double[] c = new double[6];
+        double startX = 0.0;
+        double startY = 0.0;
+        double curX = 0.0;
+        double curY = 0.0;
+        while (!pi.isDone()) {
+            switch (pi.currentSegment(c)) {
+                case PathIterator.SEG_MOVETO:
+                    edge(curX, curY, startX, startY);
+                    startX = c[0];
+                    startY = c[1];
+                    curX = startX;
+                    curY = startY;
+                    break;
+                case PathIterator.SEG_LINETO:
+                    edge(curX, curY, c[0], c[1]);
+                    curX = c[0];
+                    curY = c[1];
+                    break;
+                default:
+                    edge(curX, curY, startX, startY);
+                    curX = startX;
+                    curY = startY;
+                    break;
+            }
+            pi.next();
+        }
+        edge(curX, curY, startX, startY);
+    }
+
+    private void edge(double x1, double y1, double x2, double y2) {
+        if (x1 == x2 && y1 == y2) {
+            return;
+        }
+        if (size + 4 > edges.length) {
+            double[] e = new double[edges.length * 2];
+            System.arraycopy(edges, 0, e, 0, size);
+            edges = e;
+        }
+        edges[size++] = x1;
+        edges[size++] = y1;
+        edges[size++] = x2;
+        edges[size++] = y2;
+    }
+
+    /// The signed number of edges a ray from the point towards positive x
+    /// crosses: downward edges count one way and upward edges the other.
+    private int crossings(double px, double py) {
+        int n = 0;
+        for (int i = 0; i < size; i += 4) {
+            double x1 = edges[i];
+            double y1 = edges[i + 1];
+            double x2 = edges[i + 2];
+            double y2 = edges[i + 3];
+            boolean down = y1 < y2;
+            if (down ? (py < y1 || py >= y2) : (py < y2 || py >= y1)) {
+                continue;
+            }
+            if (px >= x1 && px >= x2) {
+                continue;
+            }
+            if ((px < x1 && px < x2) || px < x1 + (py - y1) * (x2 - x1) / (y2 - y1)) {
+                n += down ? 1 : -1;
+            }
+        }
+        return n;
+    }
+
+    boolean contains(double x, double y, int rule) {
+        int n = crossings(x, y);
+        return rule == PathIterator.WIND_NON_ZERO ? n != 0 : (n & 1) != 0;
+    }
+
+    /// Whether any edge passes through the open interior of the rectangle.
+    private boolean entersInterior(double rx, double ry, double rw, double rh) {
+        double[] range = new double[2];
+        for (int i = 0; i < size; i += 4) {
+            double x1 = edges[i];
+            double y1 = edges[i + 1];
+            double dx = edges[i + 2] - x1;
+            double dy = edges[i + 3] - y1;
+            // the part of the edge inside the closed rectangle, as a
+            // parameter range along it
+            range[0] = 0.0;
+            range[1] = 1.0;
+            if (clip(-dx, x1 - rx, range) && clip(dx, rx + rw - x1, range)
+                    && clip(-dy, y1 - ry, range) && clip(dy, ry + rh - y1, range)
+                    && range[0] < range[1]) {
+                double t = (range[0] + range[1]) / 2.0;
+                double mx = x1 + dx * t;
+                double my = y1 + dy * t;
+                if (mx > rx && mx < rx + rw && my > ry && my < ry + rh) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /// Narrows a parameter range to the half plane `p * t <= q`; false when
+    /// nothing is left.
+    private static boolean clip(double p, double q, double[] range) {
+        if (p == 0.0) {
+            return q >= 0.0;
+        }
+        double t = q / p;
+        if (p < 0.0) {
+            if (t > range[1]) {
+                return false;
+            }
+            if (t > range[0]) {
+                range[0] = t;
+            }
+        } else {
+            if (t < range[0]) {
+                return false;
+            }
+            if (t < range[1]) {
+                range[1] = t;
+            }
+        }
+        return true;
+    }
+
+    boolean intersects(double x, double y, double w, double h, int rule) {
+        if (!(w > 0.0 && h > 0.0)) {
+            return false;
+        }
+        return entersInterior(x, y, w, h) || contains(x + w / 2.0, y + h / 2.0, rule);
+    }
+
+    boolean contains(double x, double y, double w, double h, int rule) {
+        if (!(w > 0.0 && h > 0.0)) {
+            return false;
+        }
+        return !entersInterior(x, y, w, h) && contains(x + w / 2.0, y + h / 2.0, rule);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Path2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Path2D.java
new file mode 100644
index 00000000000..c4e7814574c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Path2D.java
@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// An outline built from moves, lines, quadratic and cubic curves, with a
+/// winding rule that decides its interior.
+///
+/// Hit tests run over the flattened outline with every subpath closed. They
+/// are exact for polygons; for a rectangle test against a path that overlaps
+/// itself under the non-zero rule, `contains` may answer false and
+/// `intersects` true where the exact answer is the opposite. `getBounds2D`
+/// answers the bounds of every stored point, control points included.
+///
+/// A path is not safe to change from two threads at once.
+public abstract class Path2D implements Shape, Cloneable {
+
+    public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;
+
+    public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;
+
+    /// A path whose coordinates are held to single precision.
+    public static class Float extends Path2D {
+
+        public Float() {
+            this(WIND_NON_ZERO, 20);
+        }
+
+        public Float(int rule) {
+            this(rule, 20);
+        }
+
+        public Float(int rule, int initialCapacity) {
+            super(rule, initialCapacity, true);
+        }
+
+        public Float(Shape s) {
+            this(s, null);
+        }
+
+        public Float(Shape s, AffineTransform at) {
+            super(WIND_NON_ZERO, 20, true);
+            copy(s, at);
+        }
+
+        public final void moveTo(float x, float y) {
+            addMove(x, y);
+        }
+
+        public final void lineTo(float x, float y) {
+            addLine(x, y);
+        }
+
+        public final void quadTo(float x1, float y1, float x2, float y2) {
+            addQuad(x1, y1, x2, y2);
+        }
+
+        public final void curveTo(float x1, float y1, float x2, float y2, float x3, float y3) {
+            addCubic(x1, y1, x2, y2, x3, y3);
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(this);
+        }
+    }
+
+    /// A path whose coordinates are held to double precision.
+    public static class Double extends Path2D {
+
+        public Double() {
+            this(WIND_NON_ZERO, 20);
+        }
+
+        public Double(int rule) {
+            this(rule, 20);
+        }
+
+        public Double(int rule, int initialCapacity) {
+            super(rule, initialCapacity, false);
+        }
+
+        public Double(Shape s) {
+            this(s, null);
+        }
+
+        public Double(Shape s, AffineTransform at) {
+            super(WIND_NON_ZERO, 20, false);
+            copy(s, at);
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(this);
+        }
+    }
+
+    private byte[] types;
+    private double[] coords;
+    private int typeCount;
+    private int coordCount;
+    private int windingRule;
+
+    /// Whether every stored coordinate is rounded to a float first, which
+    /// is all that tells the two concrete paths apart.
+    private final boolean single;
+
+    Path2D(int rule, int initialCapacity, boolean single) {
+        checkRule(rule);
+        this.windingRule = rule;
+        this.single = single;
+        this.types = new byte[Math.max(initialCapacity, 1)];
+        this.coords = new double[Math.max(initialCapacity, 1) * 2];
+    }
+
+    private static void checkRule(int rule) {
+        if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO) {
+            throw new IllegalArgumentException("winding rule must be WIND_EVEN_ODD or WIND_NON_ZERO");
+        }
+    }
+
+    /// Fills a new path from a shape, optionally transformed.
+    final void copy(Shape s, AffineTransform at) {
+        if (s instanceof Path2D) {
+            Path2D p = (Path2D) s;
+            windingRule = p.windingRule;
+            typeCount = p.typeCount;
+            coordCount = p.coordCount;
+            types = new byte[Math.max(typeCount, 1)];
+            coords = new double[Math.max(coordCount, 2)];
+            System.arraycopy(p.types, 0, types, 0, typeCount);
+            System.arraycopy(p.coords, 0, coords, 0, coordCount);
+            if (at != null) {
+                at.transform(coords, 0, coords, 0, coordCount / 2);
+            }
+            round();
+        } else {
+            PathIterator pi = s.getPathIterator(at);
+            checkRule(pi.getWindingRule());
+            windingRule = pi.getWindingRule();
+            addAll(pi, false);
+        }
+    }
+
+    private void round() {
+        if (single) {
+            for (int i = 0; i < coordCount; i++) {
+                coords[i] = (float) coords[i];
+            }
+        }
+    }
+
+    private void room(int type, boolean needsMove) {
+        if (needsMove && typeCount == 0) {
+            throw new IllegalPathStateException("missing initial moveto in path definition");
+        }
+        if (typeCount == types.length) {
+            byte[] t = new byte[typeCount * 2];
+            System.arraycopy(types, 0, t, 0, typeCount);
+            types = t;
+        }
+        if (coordCount + 6 > coords.length) {
+            double[] c = new double[coords.length * 2 + 6];
+            System.arraycopy(coords, 0, c, 0, coordCount);
+            coords = c;
+        }
+        types[typeCount++] = (byte) type;
+    }
+
+    private void put(double v) {
+        coords[coordCount++] = single ? (double) (float) v : v;
+    }
+
+    final void addMove(double x, double y) {
+        if (typeCount > 0 && types[typeCount - 1] == PathIterator.SEG_MOVETO) {
+            // a move straight after a move replaces it
+            coordCount -= 2;
+        } else {
+            room(PathIterator.SEG_MOVETO, false);
+        }
+        put(x);
+        put(y);
+    }
+
+    final void addLine(double x, double y) {
+        room(PathIterator.SEG_LINETO, true);
+        put(x);
+        put(y);
+    }
+
+    final void addQuad(double x1, double y1, double x2, double y2) {
+        room(PathIterator.SEG_QUADTO, true);
+        put(x1);
+        put(y1);
+        put(x2);
+        put(y2);
+    }
+
+    final void addCubic(double x1, double y1, double x2, double y2, double x3, double y3) {
+        room(PathIterator.SEG_CUBICTO, true);
+        put(x1);
+        put(y1);
+        put(x2);
+        put(y2);
+        put(x3);
+        put(y3);
+    }
+
+    private void addAll(PathIterator pi, boolean connect) {
+        double[] c = new double[6];
+        while (!pi.isDone()) {
+            switch (pi.currentSegment(c)) {
+                case PathIterator.SEG_MOVETO:
+                    if (!connect || typeCount == 0 || coordCount == 0) {
+                        addMove(c[0], c[1]);
+                    } else if (types[typeCount - 1] == PathIterator.SEG_CLOSE
+                            || coords[coordCount - 2] != stored(c[0]) || coords[coordCount - 1] != stored(c[1])) {
+                        // joined to what is already here, unless the open
+                        // subpath ends on this very point
+                        addLine(c[0], c[1]);
+                    }
+                    break;
+                case PathIterator.SEG_LINETO:
+                    addLine(c[0], c[1]);
+                    break;
+                case PathIterator.SEG_QUADTO:
+                    addQuad(c[0], c[1], c[2], c[3]);
+                    break;
+                case PathIterator.SEG_CUBICTO:
+                    addCubic(c[0], c[1], c[2], c[3], c[4], c[5]);
+                    break;
+                default:
+                    closePath();
+                    break;
+            }
+            pi.next();
+            connect = false;
+        }
+    }
+
+    private double stored(double v) {
+        return single ? (double) (float) v : v;
+    }
+
+    /// Starts a new subpath. A move that directly follows another move
+    /// replaces it.
+    public void moveTo(double x, double y) {
+        addMove(x, y);
+    }
+
+    public void lineTo(double x, double y) {
+        addLine(x, y);
+    }
+
+    public void quadTo(double x1, double y1, double x2, double y2) {
+        addQuad(x1, y1, x2, y2);
+    }
+
+    public void curveTo(double x1, double y1, double x2, double y2, double x3, double y3) {
+        addCubic(x1, y1, x2, y2, x3, y3);
+    }
+
+    /// Closes the current subpath; does nothing when it is already closed.
+    public final void closePath() {
+        if (typeCount == 0 || types[typeCount - 1] != PathIterator.SEG_CLOSE) {
+            room(PathIterator.SEG_CLOSE, true);
+        }
+    }
+
+    public final void append(Shape s, boolean connect) {
+        addAll(s.getPathIterator(null), connect);
+    }
+
+    /// Adds every segment of an iterator. With `connect`, a leading move
+    /// becomes a line from the current point, or is dropped when the open
+    /// subpath already ends there.
+    public void append(PathIterator pi, boolean connect) {
+        addAll(pi, connect);
+    }
+
+    public final int getWindingRule() {
+        return windingRule;
+    }
+
+    public final void setWindingRule(int rule) {
+        checkRule(rule);
+        windingRule = rule;
+    }
+
+    /// The point the next segment starts from, or null for an empty path.
+    /// After a close that is the start of the subpath just closed.
+    public final Point2D getCurrentPoint() {
+        if (typeCount == 0 || coordCount == 0) {
+            return null;
+        }
+        int index = coordCount;
+        if (types[typeCount - 1] == PathIterator.SEG_CLOSE) {
+            // walk back to the move that opened the closed subpath
+            for (int i = typeCount - 2; i > 0; i--) {
+                int type = types[i];
+                if (type == PathIterator.SEG_MOVETO) {
+                    break;
+                }
+                index -= SegmentIterator.size(type);
+            }
+        }
+        return point(coords[index - 2], coords[index - 1]);
+    }
+
+    private Point2D point(double x, double y) {
+        if (single) {
+            return new Point2D.Float((float) x, (float) y);
+        }
+        return new Point2D.Double(x, y);
+    }
+
+    /// Empties the path, keeping its winding rule.
+    public final void reset() {
+        typeCount = 0;
+        coordCount = 0;
+    }
+
+    public void transform(AffineTransform at) {
+        at.transform(coords, 0, coords, 0, coordCount / 2);
+        round();
+    }
+
+    /// Returns a transformed copy of this path, of the same class.
+    public final Shape createTransformedShape(AffineTransform at) {
+        Object copy = clone();
+        if (!(copy instanceof Path2D)) {
+            return null;
+        }
+        Path2D p = (Path2D) copy;
+        if (at != null) {
+            p.transform(at);
+        }
+        return p;
+    }
+
+    @Override
+    public final Rectangle getBounds() {
+        return getBounds2D().getBounds();
+    }
+
+    /// The bounds of every stored point, in the precision of the path.
+    @Override
+    public Rectangle2D getBounds2D() {
+        double x1 = 0.0;
+        double y1 = 0.0;
+        double x2 = 0.0;
+        double y2 = 0.0;
+        for (int i = 0; i < coordCount; i += 2) {
+            double x = coords[i];
+            double y = coords[i + 1];
+            if (i == 0) {
+                x1 = x;
+                x2 = x;
+                y1 = y;
+                y2 = y;
+            } else {
+                x1 = Math.min(x1, x);
+                x2 = Math.max(x2, x);
+                y1 = Math.min(y1, y);
+                y2 = Math.max(y2, y);
+            }
+        }
+        if (single) {
+            return new Rectangle2D.Float((float) x1, (float) y1, (float) (x2 - x1), (float) (y2 - y1));
+        }
+        return new Rectangle2D.Double(x1, y1, x2 - x1, y2 - y1);
+    }
+
+    private static Path2D collect(PathIterator pi) {
+        Path2D p = new Double(pi.getWindingRule());
+        p.append(pi, false);
+        return p;
+    }
+
+    public static boolean contains(PathIterator pi, double x, double y) {
+        return collect(pi).contains(x, y);
+    }
+
+    public static boolean contains(PathIterator pi, Point2D p) {
+        return collect(pi).contains(p.getX(), p.getY());
+    }
+
+    @Override
+    public final boolean contains(double x, double y) {
+        if (typeCount < 2) {
+            return false;
+        }
+        return Outline.of(this).contains(x, y, windingRule);
+    }
+
+    @Override
+    public final boolean contains(Point2D p) {
+        return contains(p.getX(), p.getY());
+    }
+
+    public static boolean contains(PathIterator pi, double x, double y, double w, double h) {
+        return collect(pi).contains(x, y, w, h);
+    }
+
+    public static boolean contains(PathIterator pi, Rectangle2D r) {
+        return collect(pi).contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public final boolean contains(double x, double y, double w, double h) {
+        if (typeCount < 2) {
+            return false;
+        }
+        return Outline.of(this).contains(x, y, w, h, windingRule);
+    }
+
+    @Override
+    public final boolean contains(Rectangle2D r) {
+        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    public static boolean intersects(PathIterator pi, double x, double y, double w, double h) {
+        return collect(pi).intersects(x, y, w, h);
+    }
+
+    public static boolean intersects(PathIterator pi, Rectangle2D r) {
+        return collect(pi).intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public final boolean intersects(double x, double y, double w, double h) {
+        if (typeCount < 2) {
+            return false;
+        }
+        return Outline.of(this).intersects(x, y, w, h, windingRule);
+    }
+
+    @Override
+    public final boolean intersects(Rectangle2D r) {
+        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    /// The iterator reads this path's own storage: change the path while
+    /// iterating and what the iterator returns is undefined.
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        return new SegmentIterator(windingRule, at, types, typeCount, coords);
+    }
+
+    @Override
+    public final PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return new FlatteningPathIterator(getPathIterator(at), flatness);
+    }
+
+    @Override
+    public abstract Object clone();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/PathIterator.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/PathIterator.java
new file mode 100644
index 00000000000..fb06b8bc44d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/PathIterator.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// Walks the outline of a shape one segment at a time.
+///
+/// A segment is a move, a line, a quadratic or cubic Bezier curve, or the
+/// closing of the current subpath. `currentSegment` stores the points of the
+/// segment in the array it is handed and returns one of the `SEG_` constants.
+public interface PathIterator {
+
+    /// Interior rule: a point is inside when a ray from it crosses the
+    /// outline an odd number of times.
+    int WIND_EVEN_ODD = 0;
+
+    /// Interior rule: a point is inside when the signed count of outline
+    /// crossings of a ray from it is not zero.
+    int WIND_NON_ZERO = 1;
+
+    /// Starts a new subpath at one point.
+    int SEG_MOVETO = 0;
+
+    /// A straight line to one point.
+    int SEG_LINETO = 1;
+
+    /// A quadratic curve: one control point, then the end point.
+    int SEG_QUADTO = 2;
+
+    /// A cubic curve: two control points, then the end point.
+    int SEG_CUBICTO = 3;
+
+    /// Closes the current subpath back to its last move; stores no points.
+    int SEG_CLOSE = 4;
+
+    int getWindingRule();
+
+    boolean isDone();
+
+    void next();
+
+    int currentSegment(float[] coords);
+
+    int currentSegment(double[] coords);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Point2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Point2D.java
new file mode 100644
index 00000000000..d867205869f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Point2D.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// A location in two dimensional space, stored by a subclass in the
+/// precision it chooses.
+public abstract class Point2D implements Cloneable {
+
+    /// A point stored in single precision.
+    public static class Float extends Point2D {
+
+        public float x;
+
+        public float y;
+
+        public Float() {
+        }
+
+        public Float(float x, float y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public void setLocation(double x, double y) {
+            this.x = (float) x;
+            this.y = (float) y;
+        }
+
+        public void setLocation(float x, float y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x, y);
+        }
+
+        @Override
+        public String toString() {
+            return "Point2D.Float[" + x + ", " + y + "]";
+        }
+    }
+
+    /// A point stored in double precision.
+    public static class Double extends Point2D {
+
+        public double x;
+
+        public double y;
+
+        public Double() {
+        }
+
+        public Double(double x, double y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public void setLocation(double x, double y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x, y);
+        }
+
+        @Override
+        public String toString() {
+            return "Point2D.Double[" + x + ", " + y + "]";
+        }
+    }
+
+    protected Point2D() {
+    }
+
+    public abstract double getX();
+
+    public abstract double getY();
+
+    public abstract void setLocation(double x, double y);
+
+    public void setLocation(Point2D p) {
+        setLocation(p.getX(), p.getY());
+    }
+
+    public static double distanceSq(double x1, double y1, double x2, double y2) {
+        double dx = x1 - x2;
+        double dy = y1 - y2;
+        return dx * dx + dy * dy;
+    }
+
+    public static double distance(double x1, double y1, double x2, double y2) {
+        return Math.sqrt(distanceSq(x1, y1, x2, y2));
+    }
+
+    public double distanceSq(double px, double py) {
+        return distanceSq(getX(), getY(), px, py);
+    }
+
+    public double distanceSq(Point2D pt) {
+        return distanceSq(getX(), getY(), pt.getX(), pt.getY());
+    }
+
+    public double distance(double px, double py) {
+        return Math.sqrt(distanceSq(getX(), getY(), px, py));
+    }
+
+    public double distance(Point2D pt) {
+        return Math.sqrt(distanceSq(getX(), getY(), pt.getX(), pt.getY()));
+    }
+
+    /// Returns a copy of this point. A subclass outside this package that
+    /// does not override it gets a double precision point back.
+    @Override
+    public Object clone() {
+        return new Double(getX(), getY());
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = java.lang.Double.doubleToLongBits(getX()) * 31 + java.lang.Double.doubleToLongBits(getY());
+        return (int) bits ^ (int) (bits >> 32);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Point2D) {
+            Point2D p = (Point2D) obj;
+            return getX() == p.getX() && getY() == p.getY();
+        }
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/QuadCurve2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/QuadCurve2D.java
new file mode 100644
index 00000000000..cac15330157
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/QuadCurve2D.java
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// A quadratic Bezier curve: two end points and one control point.
+///
+/// The area tested by `contains` and `intersects` is the region between the
+/// curve and the straight line joining its ends, and is evaluated over the
+/// flattened curve. `getBounds2D` answers the bounds of the three defining
+/// points, which enclose the curve without being tight.
+public abstract class QuadCurve2D implements Shape, Cloneable {
+
+    /// A curve stored in single precision.
+    public static class Float extends QuadCurve2D {
+
+        public float x1;
+        public float y1;
+        public float ctrlx;
+        public float ctrly;
+        public float x2;
+        public float y2;
+
+        public Float() {
+        }
+
+        public Float(float x1, float y1, float ctrlx, float ctrly, float x2, float y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx = ctrlx;
+            this.ctrly = ctrly;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public double getX1() {
+            return x1;
+        }
+
+        @Override
+        public double getY1() {
+            return y1;
+        }
+
+        @Override
+        public Point2D getP1() {
+            return new Point2D.Float(x1, y1);
+        }
+
+        @Override
+        public double getCtrlX() {
+            return ctrlx;
+        }
+
+        @Override
+        public double getCtrlY() {
+            return ctrly;
+        }
+
+        @Override
+        public Point2D getCtrlPt() {
+            return new Point2D.Float(ctrlx, ctrly);
+        }
+
+        @Override
+        public double getX2() {
+            return x2;
+        }
+
+        @Override
+        public double getY2() {
+            return y2;
+        }
+
+        @Override
+        public Point2D getP2() {
+            return new Point2D.Float(x2, y2);
+        }
+
+        @Override
+        public void setCurve(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+            this.x1 = (float) x1;
+            this.y1 = (float) y1;
+            this.ctrlx = (float) ctrlx;
+            this.ctrly = (float) ctrly;
+            this.x2 = (float) x2;
+            this.y2 = (float) y2;
+        }
+
+        public void setCurve(float x1, float y1, float ctrlx, float ctrly, float x2, float y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx = ctrlx;
+            this.ctrly = ctrly;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            float left = Math.min(Math.min(x1, x2), ctrlx);
+            float top = Math.min(Math.min(y1, y2), ctrly);
+            float right = Math.max(Math.max(x1, x2), ctrlx);
+            float bottom = Math.max(Math.max(y1, y2), ctrly);
+            return new Rectangle2D.Float(left, top, right - left, bottom - top);
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x1, y1, ctrlx, ctrly, x2, y2);
+        }
+    }
+
+    /// A curve stored in double precision.
+    public static class Double extends QuadCurve2D {
+
+        public double x1;
+        public double y1;
+        public double ctrlx;
+        public double ctrly;
+        public double x2;
+        public double y2;
+
+        public Double() {
+        }
+
+        public Double(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx = ctrlx;
+            this.ctrly = ctrly;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public double getX1() {
+            return x1;
+        }
+
+        @Override
+        public double getY1() {
+            return y1;
+        }
+
+        @Override
+        public Point2D getP1() {
+            return new Point2D.Double(x1, y1);
+        }
+
+        @Override
+        public double getCtrlX() {
+            return ctrlx;
+        }
+
+        @Override
+        public double getCtrlY() {
+            return ctrly;
+        }
+
+        @Override
+        public Point2D getCtrlPt() {
+            return new Point2D.Double(ctrlx, ctrly);
+        }
+
+        @Override
+        public double getX2() {
+            return x2;
+        }
+
+        @Override
+        public double getY2() {
+            return y2;
+        }
+
+        @Override
+        public Point2D getP2() {
+            return new Point2D.Double(x2, y2);
+        }
+
+        @Override
+        public void setCurve(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.ctrlx = ctrlx;
+            this.ctrly = ctrly;
+            this.x2 = x2;
+            this.y2 = y2;
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            double left = Math.min(Math.min(x1, x2), ctrlx);
+            double top = Math.min(Math.min(y1, y2), ctrly);
+            double right = Math.max(Math.max(x1, x2), ctrlx);
+            double bottom = Math.max(Math.max(y1, y2), ctrly);
+            return new Rectangle2D.Double(left, top, right - left, bottom - top);
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x1, y1, ctrlx, ctrly, x2, y2);
+        }
+    }
+
+    protected QuadCurve2D() {
+    }
+
+    public abstract double getX1();
+
+    public abstract double getY1();
+
+    public abstract Point2D getP1();
+
+    public abstract double getCtrlX();
+
+    public abstract double getCtrlY();
+
+    public abstract Point2D getCtrlPt();
+
+    public abstract double getX2();
+
+    public abstract double getY2();
+
+    public abstract Point2D getP2();
+
+    public abstract void setCurve(double x1, double y1, double ctrlx, double ctrly, double x2, double y2);
+
+    public void setCurve(double[] coords, int offset) {
+        setCurve(coords[offset], coords[offset + 1], coords[offset + 2], coords[offset + 3],
+                coords[offset + 4], coords[offset + 5]);
+    }
+
+    public void setCurve(Point2D p1, Point2D cp, Point2D p2) {
+        setCurve(p1.getX(), p1.getY(), cp.getX(), cp.getY(), p2.getX(), p2.getY());
+    }
+
+    public void setCurve(Point2D[] pts, int offset) {
+        setCurve(pts[offset].getX(), pts[offset].getY(), pts[offset + 1].getX(), pts[offset + 1].getY(),
+                pts[offset + 2].getX(), pts[offset + 2].getY());
+    }
+
+    public void setCurve(QuadCurve2D c) {
+        setCurve(c.getX1(), c.getY1(), c.getCtrlX(), c.getCtrlY(), c.getX2(), c.getY2());
+    }
+
+    /// The square of the distance of the control point from the segment
+    /// joining the end points.
+    public static double getFlatnessSq(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+        return Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx, ctrly);
+    }
+
+    public static double getFlatness(double x1, double y1, double ctrlx, double ctrly, double x2, double y2) {
+        return Line2D.ptSegDist(x1, y1, x2, y2, ctrlx, ctrly);
+    }
+
+    public static double getFlatnessSq(double[] coords, int offset) {
+        return Line2D.ptSegDistSq(coords[offset], coords[offset + 1], coords[offset + 4], coords[offset + 5],
+                coords[offset + 2], coords[offset + 3]);
+    }
+
+    public static double getFlatness(double[] coords, int offset) {
+        return Line2D.ptSegDist(coords[offset], coords[offset + 1], coords[offset + 4], coords[offset + 5],
+                coords[offset + 2], coords[offset + 3]);
+    }
+
+    public double getFlatnessSq() {
+        return Line2D.ptSegDistSq(getX1(), getY1(), getX2(), getY2(), getCtrlX(), getCtrlY());
+    }
+
+    public double getFlatness() {
+        return Line2D.ptSegDist(getX1(), getY1(), getX2(), getY2(), getCtrlX(), getCtrlY());
+    }
+
+    /// Splits this curve at its middle into two curves; either may be null
+    /// or this curve itself.
+    public void subdivide(QuadCurve2D left, QuadCurve2D right) {
+        subdivide(this, left, right);
+    }
+
+    public static void subdivide(QuadCurve2D src, QuadCurve2D left, QuadCurve2D right) {
+        double x1 = src.getX1();
+        double y1 = src.getY1();
+        double x2 = src.getX2();
+        double y2 = src.getY2();
+        double lx = (x1 + src.getCtrlX()) / 2.0;
+        double ly = (y1 + src.getCtrlY()) / 2.0;
+        double rx = (src.getCtrlX() + x2) / 2.0;
+        double ry = (src.getCtrlY() + y2) / 2.0;
+        double mx = (lx + rx) / 2.0;
+        double my = (ly + ry) / 2.0;
+        if (left != null) {
+            left.setCurve(x1, y1, lx, ly, mx, my);
+        }
+        if (right != null) {
+            right.setCurve(mx, my, rx, ry, x2, y2);
+        }
+    }
+
+    /// Splits six coordinates into two curves of six; a destination may be
+    /// null, and may be the source array where the ranges allow it.
+    public static void subdivide(double[] src, int srcoff, double[] left, int leftoff, double[] right, int rightoff) {
+        double x1 = src[srcoff];
+        double y1 = src[srcoff + 1];
+        double x2 = src[srcoff + 4];
+        double y2 = src[srcoff + 5];
+        double lx = (x1 + src[srcoff + 2]) / 2.0;
+        double ly = (y1 + src[srcoff + 3]) / 2.0;
+        double rx = (src[srcoff + 2] + x2) / 2.0;
+        double ry = (src[srcoff + 3] + y2) / 2.0;
+        double mx = (lx + rx) / 2.0;
+        double my = (ly + ry) / 2.0;
+        if (left != null) {
+            left[leftoff] = x1;
+            left[leftoff + 1] = y1;
+            left[leftoff + 2] = lx;
+            left[leftoff + 3] = ly;
+            left[leftoff + 4] = mx;
+            left[leftoff + 5] = my;
+        }
+        if (right != null) {
+            right[rightoff] = mx;
+            right[rightoff + 1] = my;
+            right[rightoff + 2] = rx;
+            right[rightoff + 3] = ry;
+            right[rightoff + 4] = x2;
+            right[rightoff + 5] = y2;
+        }
+    }
+
+    public static int solveQuadratic(double[] eqn) {
+        return solveQuadratic(eqn, eqn);
+    }
+
+    /// Solves `eqn[2]*x*x + eqn[1]*x + eqn[0] = 0`, storing the real roots
+    /// and returning how many there are, or -1 when the equation is a
+    /// constant. A repeated root is stored twice, except a repeated root of
+    /// zero, which is stored once.
+    public static int solveQuadratic(double[] eqn, double[] res) {
+        double a = eqn[2];
+        double b = eqn[1];
+        double c = eqn[0];
+        if (a == 0.0) {
+            if (b == 0.0) {
+                return -1;
+            }
+            res[0] = -c / b;
+            return 1;
+        }
+        double d = b * b - 4.0 * a * c;
+        if (d < 0.0) {
+            return 0;
+        }
+        // add the root to b with matching sign so nothing cancels
+        double q = -(b + (b < 0.0 ? -Math.sqrt(d) : Math.sqrt(d))) / 2.0;
+        res[0] = q / a;
+        if (q == 0.0) {
+            return 1;
+        }
+        res[1] = c / q;
+        return 2;
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        return Outline.of(this).contains(x, y, PathIterator.WIND_EVEN_ODD);
+    }
+
+    @Override
+    public boolean contains(Point2D p) {
+        return contains(p.getX(), p.getY());
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        return Outline.of(this).intersects(x, y, w, h, PathIterator.WIND_EVEN_ODD);
+    }
+
+    @Override
+    public boolean intersects(Rectangle2D r) {
+        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        return Outline.of(this).contains(x, y, w, h, PathIterator.WIND_EVEN_ODD);
+    }
+
+    @Override
+    public boolean contains(Rectangle2D r) {
+        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return getBounds2D().getBounds();
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 2);
+        it.move(getX1(), getY1());
+        it.quad(getCtrlX(), getCtrlY(), getX2(), getY2());
+        return it;
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return new FlatteningPathIterator(getPathIterator(at), flatness);
+    }
+
+    /// Returns a copy of this curve. A subclass from elsewhere that does not
+    /// override it gets a double precision curve back.
+    @Override
+    public Object clone() {
+        return new Double(getX1(), getY1(), getCtrlX(), getCtrlY(), getX2(), getY2());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Rectangle2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Rectangle2D.java
new file mode 100644
index 00000000000..004531a2a83
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/Rectangle2D.java
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// A rectangle given by a corner and a size, stored by a subclass in the
+/// precision it chooses.
+///
+/// A point on the left or top edge is inside and one on the right or bottom
+/// edge is not; a rectangle with no area contains and intersects nothing.
+public abstract class Rectangle2D extends RectangularShape {
+
+    public static final int OUT_LEFT = 1;
+    public static final int OUT_TOP = 2;
+    public static final int OUT_RIGHT = 4;
+    public static final int OUT_BOTTOM = 8;
+
+    /// A rectangle stored in single precision.
+    public static class Float extends Rectangle2D {
+
+        public float x;
+        public float y;
+        public float width;
+        public float height;
+
+        public Float() {
+        }
+
+        public Float(float x, float y, float w, float h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0f || height <= 0.0f;
+        }
+
+        public void setRect(float x, float y, float w, float h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public void setRect(double x, double y, double w, double h) {
+            this.x = (float) x;
+            this.y = (float) y;
+            this.width = (float) w;
+            this.height = (float) h;
+        }
+
+        @Override
+        public void setRect(Rectangle2D r) {
+            setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+        }
+
+        @Override
+        public int outcode(double x, double y) {
+            return outcode(this.x, this.y, width, height, x, y);
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Float(x, y, width, height);
+        }
+
+        @Override
+        public Rectangle2D createIntersection(Rectangle2D r) {
+            Rectangle2D dest = r instanceof Float ? (Rectangle2D) new Float() : new Double();
+            Rectangle2D.intersect(this, r, dest);
+            return dest;
+        }
+
+        @Override
+        public Rectangle2D createUnion(Rectangle2D r) {
+            Rectangle2D dest = r instanceof Float ? (Rectangle2D) new Float() : new Double();
+            Rectangle2D.union(this, r, dest);
+            return dest;
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x, y, width, height);
+        }
+
+        @Override
+        public String toString() {
+            return "java.awt.geom.Rectangle2D$Float[x=" + x + ",y=" + y + ",w=" + width + ",h=" + height + "]";
+        }
+    }
+
+    /// A rectangle stored in double precision.
+    public static class Double extends Rectangle2D {
+
+        public double x;
+        public double y;
+        public double width;
+        public double height;
+
+        public Double() {
+        }
+
+        public Double(double x, double y, double w, double h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0 || height <= 0.0;
+        }
+
+        @Override
+        public void setRect(double x, double y, double w, double h) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+        }
+
+        @Override
+        public void setRect(Rectangle2D r) {
+            setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+        }
+
+        @Override
+        public int outcode(double x, double y) {
+            return outcode(this.x, this.y, width, height, x, y);
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Double(x, y, width, height);
+        }
+
+        @Override
+        public Rectangle2D createIntersection(Rectangle2D r) {
+            Rectangle2D dest = new Double();
+            Rectangle2D.intersect(this, r, dest);
+            return dest;
+        }
+
+        @Override
+        public Rectangle2D createUnion(Rectangle2D r) {
+            Rectangle2D dest = new Double();
+            Rectangle2D.union(this, r, dest);
+            return dest;
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x, y, width, height);
+        }
+
+        @Override
+        public String toString() {
+            return "java.awt.geom.Rectangle2D$Double[x=" + x + ",y=" + y + ",w=" + width + ",h=" + height + "]";
+        }
+    }
+
+    protected Rectangle2D() {
+    }
+
+    /// The `OUT_` flags of a point against a rectangle. A rectangle with no
+    /// extent on an axis puts every point outside on both sides of it.
+    static int outcode(double rx, double ry, double rw, double rh, double x, double y) {
+        int out = 0;
+        if (rw <= 0.0) {
+            out |= OUT_LEFT | OUT_RIGHT;
+        } else if (x < rx) {
+            out |= OUT_LEFT;
+        } else if (x > rx + rw) {
+            out |= OUT_RIGHT;
+        }
+        if (rh <= 0.0) {
+            out |= OUT_TOP | OUT_BOTTOM;
+        } else if (y < ry) {
+            out |= OUT_TOP;
+        } else if (y > ry + rh) {
+            out |= OUT_BOTTOM;
+        }
+        return out;
+    }
+
+    public abstract void setRect(double x, double y, double w, double h);
+
+    public void setRect(Rectangle2D r) {
+        setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    /// Whether a line segment touches this rectangle, edges included.
+    public boolean intersectsLine(double x1, double y1, double x2, double y2) {
+        int out2 = outcode(x2, y2);
+        if (out2 == 0) {
+            return true;
+        }
+        // walk the first end towards the second, one rectangle edge at a
+        // time, until it is inside or both ends are beyond the same edge
+        int out1 = outcode(x1, y1);
+        while (out1 != 0) {
+            if ((out1 & out2) != 0) {
+                return false;
+            }
+            if ((out1 & (OUT_LEFT | OUT_RIGHT)) != 0) {
+                double x = (out1 & OUT_RIGHT) != 0 ? getX() + getWidth() : getX();
+                y1 = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
+                x1 = x;
+            } else {
+                double y = (out1 & OUT_BOTTOM) != 0 ? getY() + getHeight() : getY();
+                x1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
+                y1 = y;
+            }
+            out1 = outcode(x1, y1);
+        }
+        return true;
+    }
+
+    public boolean intersectsLine(Line2D l) {
+        return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
+    }
+
+    public abstract int outcode(double x, double y);
+
+    public int outcode(Point2D p) {
+        return outcode(p.getX(), p.getY());
+    }
+
+    @Override
+    public void setFrame(double x, double y, double w, double h) {
+        setRect(x, y, w, h);
+    }
+
+    @Override
+    public Rectangle2D getBounds2D() {
+        return new Double(getX(), getY(), getWidth(), getHeight());
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        double x0 = getX();
+        double y0 = getY();
+        return x >= x0 && y >= y0 && x < x0 + getWidth() && y < y0 + getHeight();
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        if (isEmpty() || w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        double x0 = getX();
+        double y0 = getY();
+        return x + w > x0 && y + h > y0 && x < x0 + getWidth() && y < y0 + getHeight();
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        if (isEmpty() || w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        double x0 = getX();
+        double y0 = getY();
+        return x >= x0 && y >= y0 && x + w <= x0 + getWidth() && y + h <= y0 + getHeight();
+    }
+
+    public abstract Rectangle2D createIntersection(Rectangle2D r);
+
+    public abstract Rectangle2D createUnion(Rectangle2D r);
+
+    /// Stores the overlap of two rectangles. Rectangles that do not overlap
+    /// give a result with a negative width or height.
+    public static void intersect(Rectangle2D src1, Rectangle2D src2, Rectangle2D dest) {
+        double x1 = Math.max(src1.getMinX(), src2.getMinX());
+        double y1 = Math.max(src1.getMinY(), src2.getMinY());
+        double x2 = Math.min(src1.getMaxX(), src2.getMaxX());
+        double y2 = Math.min(src1.getMaxY(), src2.getMaxY());
+        dest.setFrame(x1, y1, x2 - x1, y2 - y1);
+    }
+
+    public static void union(Rectangle2D src1, Rectangle2D src2, Rectangle2D dest) {
+        double x1 = Math.min(src1.getMinX(), src2.getMinX());
+        double y1 = Math.min(src1.getMinY(), src2.getMinY());
+        double x2 = Math.max(src1.getMaxX(), src2.getMaxX());
+        double y2 = Math.max(src1.getMaxY(), src2.getMaxY());
+        dest.setFrameFromDiagonal(x1, y1, x2, y2);
+    }
+
+    public void add(double newx, double newy) {
+        double x1 = Math.min(getMinX(), newx);
+        double x2 = Math.max(getMaxX(), newx);
+        double y1 = Math.min(getMinY(), newy);
+        double y2 = Math.max(getMaxY(), newy);
+        setRect(x1, y1, x2 - x1, y2 - y1);
+    }
+
+    public void add(Point2D pt) {
+        add(pt.getX(), pt.getY());
+    }
+
+    public void add(Rectangle2D r) {
+        double x1 = Math.min(getMinX(), r.getMinX());
+        double x2 = Math.max(getMaxX(), r.getMaxX());
+        double y1 = Math.min(getMinY(), r.getMinY());
+        double y2 = Math.max(getMaxY(), r.getMaxY());
+        setRect(x1, y1, x2 - x1, y2 - y1);
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 6);
+        double x = getX();
+        double y = getY();
+        double w = getWidth();
+        double h = getHeight();
+        // A negative size has no outline -- the JDK's iterator is done at
+        // once. createIntersection answers one for two rectangles that do
+        // not meet, and drawing it drew an inverted rectangle.
+        if (w < 0 || h < 0) {
+            return it;
+        }
+        it.move(x, y);
+        it.line(x + w, y);
+        it.line(x + w, y + h);
+        it.line(x, y + h);
+        it.line(x, y);
+        it.close();
+        return it;
+    }
+
+    /// A rectangle is already flat, so this is the plain outline.
+    @Override
+    public PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return getPathIterator(at);
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = java.lang.Double.doubleToLongBits(getX());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getY());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getWidth());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getHeight());
+        return (int) bits ^ (int) (bits >> 32);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof Rectangle2D) {
+            Rectangle2D r = (Rectangle2D) obj;
+            return getX() == r.getX() && getY() == r.getY()
+                    && getWidth() == r.getWidth() && getHeight() == r.getHeight();
+        }
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/RectangularShape.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/RectangularShape.java
new file mode 100644
index 00000000000..b91a381e2a8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/RectangularShape.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// The base of every shape defined by a rectangular frame: rectangles,
+/// rounded rectangles, ellipses and arcs.
+public abstract class RectangularShape implements Shape, Cloneable {
+
+    protected RectangularShape() {
+    }
+
+    public abstract double getX();
+
+    public abstract double getY();
+
+    public abstract double getWidth();
+
+    public abstract double getHeight();
+
+    public double getMinX() {
+        return getX();
+    }
+
+    public double getMinY() {
+        return getY();
+    }
+
+    public double getMaxX() {
+        return getX() + getWidth();
+    }
+
+    public double getMaxY() {
+        return getY() + getHeight();
+    }
+
+    public double getCenterX() {
+        return getX() + getWidth() / 2.0;
+    }
+
+    public double getCenterY() {
+        return getY() + getHeight() / 2.0;
+    }
+
+    public Rectangle2D getFrame() {
+        return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight());
+    }
+
+    public abstract boolean isEmpty();
+
+    public abstract void setFrame(double x, double y, double w, double h);
+
+    public void setFrame(Point2D loc, Dimension2D size) {
+        setFrame(loc.getX(), loc.getY(), size.getWidth(), size.getHeight());
+    }
+
+    public void setFrame(Rectangle2D r) {
+        setFrame(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    public void setFrameFromDiagonal(double x1, double y1, double x2, double y2) {
+        setFrame(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1));
+    }
+
+    public void setFrameFromDiagonal(Point2D p1, Point2D p2) {
+        setFrameFromDiagonal(p1.getX(), p1.getY(), p2.getX(), p2.getY());
+    }
+
+    public void setFrameFromCenter(double centerX, double centerY, double cornerX, double cornerY) {
+        double halfW = Math.abs(cornerX - centerX);
+        double halfH = Math.abs(cornerY - centerY);
+        setFrame(centerX - halfW, centerY - halfH, halfW * 2.0, halfH * 2.0);
+    }
+
+    public void setFrameFromCenter(Point2D center, Point2D corner) {
+        setFrameFromCenter(center.getX(), center.getY(), corner.getX(), corner.getY());
+    }
+
+    @Override
+    public boolean contains(Point2D p) {
+        return contains(p.getX(), p.getY());
+    }
+
+    @Override
+    public boolean intersects(Rectangle2D r) {
+        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    @Override
+    public boolean contains(Rectangle2D r) {
+        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+    }
+
+    /// The smallest integer rectangle enclosing the frame, or an empty one at
+    /// the origin when the frame has a negative size.
+    @Override
+    public Rectangle getBounds() {
+        double w = getWidth();
+        double h = getHeight();
+        if (w < 0.0 || h < 0.0) {
+            return new Rectangle();
+        }
+        double x1 = Math.floor(getX());
+        double y1 = Math.floor(getY());
+        double x2 = Math.ceil(getX() + w);
+        double y2 = Math.ceil(getY() + h);
+        return new Rectangle((int) x1, (int) y1, (int) (x2 - x1), (int) (y2 - y1));
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at, double flatness) {
+        return new FlatteningPathIterator(getPathIterator(at), flatness);
+    }
+
+    /// Returns a copy of this shape. Every shape of this package returns its
+    /// own type; a subclass from elsewhere that does not override it gets a
+    /// rectangle with the same frame.
+    @Override
+    public Object clone() {
+        return new Rectangle2D.Double(getX(), getY(), getWidth(), getHeight());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/RoundRectangle2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/RoundRectangle2D.java
new file mode 100644
index 00000000000..294c7c3c40c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/RoundRectangle2D.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+/// A rectangle whose corners are quarter ellipses of a given width and
+/// height.
+///
+/// The arc size is the full width and height of the ellipse a corner is cut
+/// from, and is limited to the size of the rectangle. The outline starts on
+/// the left side below the top-left corner and runs through the bottom,
+/// right and top.
+public abstract class RoundRectangle2D extends RectangularShape {
+
+    /// How far a corner's control points sit from the corner of the frame,
+    /// as a fraction of the corner radius.
+    private static final double CORNER = 1.0 - Ellipse2D.KAPPA;
+
+    /// A rounded rectangle stored in single precision.
+    public static class Float extends RoundRectangle2D {
+
+        public float x;
+        public float y;
+        public float width;
+        public float height;
+        public float arcwidth;
+        public float archeight;
+
+        public Float() {
+        }
+
+        public Float(float x, float y, float w, float h, float arcw, float arch) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.arcwidth = arcw;
+            this.archeight = arch;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public double getArcWidth() {
+            return arcwidth;
+        }
+
+        @Override
+        public double getArcHeight() {
+            return archeight;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0f || height <= 0.0f;
+        }
+
+        public void setRoundRect(float x, float y, float w, float h, float arcw, float arch) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.arcwidth = arcw;
+            this.archeight = arch;
+        }
+
+        @Override
+        public void setRoundRect(double x, double y, double w, double h, double arcw, double arch) {
+            this.x = (float) x;
+            this.y = (float) y;
+            this.width = (float) w;
+            this.height = (float) h;
+            this.arcwidth = (float) arcw;
+            this.archeight = (float) arch;
+        }
+
+        @Override
+        public void setRoundRect(RoundRectangle2D rr) {
+            setRoundRect(rr.getX(), rr.getY(), rr.getWidth(), rr.getHeight(), rr.getArcWidth(), rr.getArcHeight());
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Rectangle2D.Float(x, y, width, height);
+        }
+
+        @Override
+        public Object clone() {
+            return new Float(x, y, width, height, arcwidth, archeight);
+        }
+    }
+
+    /// A rounded rectangle stored in double precision.
+    public static class Double extends RoundRectangle2D {
+
+        public double x;
+        public double y;
+        public double width;
+        public double height;
+        public double arcwidth;
+        public double archeight;
+
+        public Double() {
+        }
+
+        public Double(double x, double y, double w, double h, double arcw, double arch) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.arcwidth = arcw;
+            this.archeight = arch;
+        }
+
+        @Override
+        public double getX() {
+            return x;
+        }
+
+        @Override
+        public double getY() {
+            return y;
+        }
+
+        @Override
+        public double getWidth() {
+            return width;
+        }
+
+        @Override
+        public double getHeight() {
+            return height;
+        }
+
+        @Override
+        public double getArcWidth() {
+            return arcwidth;
+        }
+
+        @Override
+        public double getArcHeight() {
+            return archeight;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return width <= 0.0 || height <= 0.0;
+        }
+
+        @Override
+        public void setRoundRect(double x, double y, double w, double h, double arcw, double arch) {
+            this.x = x;
+            this.y = y;
+            this.width = w;
+            this.height = h;
+            this.arcwidth = arcw;
+            this.archeight = arch;
+        }
+
+        @Override
+        public void setRoundRect(RoundRectangle2D rr) {
+            setRoundRect(rr.getX(), rr.getY(), rr.getWidth(), rr.getHeight(), rr.getArcWidth(), rr.getArcHeight());
+        }
+
+        @Override
+        public Rectangle2D getBounds2D() {
+            return new Rectangle2D.Double(x, y, width, height);
+        }
+
+        @Override
+        public Object clone() {
+            return new Double(x, y, width, height, arcwidth, archeight);
+        }
+    }
+
+    protected RoundRectangle2D() {
+    }
+
+    public abstract double getArcWidth();
+
+    public abstract double getArcHeight();
+
+    public abstract void setRoundRect(double x, double y, double w, double h, double arcWidth, double arcHeight);
+
+    public void setRoundRect(RoundRectangle2D rr) {
+        setRoundRect(rr.getX(), rr.getY(), rr.getWidth(), rr.getHeight(), rr.getArcWidth(), rr.getArcHeight());
+    }
+
+    /// Moves and resizes the frame, keeping the arc size.
+    @Override
+    public void setFrame(double x, double y, double w, double h) {
+        setRoundRect(x, y, w, h, getArcWidth(), getArcHeight());
+    }
+
+    /// The horizontal corner radius actually used.
+    private double radiusX() {
+        return Math.min(getWidth(), Math.abs(getArcWidth())) / 2.0;
+    }
+
+    /// The vertical corner radius actually used.
+    private double radiusY() {
+        return Math.min(getHeight(), Math.abs(getArcHeight())) / 2.0;
+    }
+
+    /// How far outside the corner ellipses the nearest point of a box lies,
+    /// where the box overlaps the frame: below one it reaches the shape.
+    ///
+    /// The shape is every point within the corner ellipse of the core
+    /// rectangle left when the frame is inset by the radii, so the measure
+    /// is the box's gap to that core on each axis, scaled by the radius.
+    private double cornerMeasure(double x0, double y0, double x1, double y1) {
+        double rx = radiusX();
+        double ry = radiusY();
+        if (rx <= 0.0 || ry <= 0.0) {
+            return 0.0;
+        }
+        double coreX0 = getX() + rx;
+        double coreX1 = getX() + getWidth() - rx;
+        double coreY0 = getY() + ry;
+        double coreY1 = getY() + getHeight() - ry;
+        double gapX = Math.max(0.0, Math.max(coreX0 - x1, x0 - coreX1)) / rx;
+        double gapY = Math.max(0.0, Math.max(coreY0 - y1, y0 - coreY1)) / ry;
+        return gapX * gapX + gapY * gapY;
+    }
+
+    @Override
+    public boolean contains(double x, double y) {
+        if (isEmpty()) {
+            return false;
+        }
+        double x0 = getX();
+        double y0 = getY();
+        if (x < x0 || y < y0 || x >= x0 + getWidth() || y >= y0 + getHeight()) {
+            return false;
+        }
+        return cornerMeasure(x, y, x, y) <= 1.0;
+    }
+
+    @Override
+    public boolean intersects(double x, double y, double w, double h) {
+        if (isEmpty() || w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        double x0 = getX();
+        double y0 = getY();
+        if (x + w <= x0 || y + h <= y0 || x >= x0 + getWidth() || y >= y0 + getHeight()) {
+            return false;
+        }
+        return cornerMeasure(x, y, x + w, y + h) < 1.0;
+    }
+
+    @Override
+    public boolean contains(double x, double y, double w, double h) {
+        if (isEmpty() || w <= 0.0 || h <= 0.0) {
+            return false;
+        }
+        // the shape is convex, so the corners decide
+        return contains(x, y) && contains(x + w, y) && contains(x, y + h) && contains(x + w, y + h);
+    }
+
+    @Override
+    public PathIterator getPathIterator(AffineTransform at) {
+        SegmentIterator it = new SegmentIterator(PathIterator.WIND_NON_ZERO, at, 10);
+        double x0 = getX();
+        double y0 = getY();
+        // A negative size has no outline, as in the JDK.
+        if (getWidth() < 0 || getHeight() < 0) {
+            return it;
+        }
+        double x1 = x0 + getWidth();
+        double y1 = y0 + getHeight();
+        double rx = radiusX();
+        double ry = radiusY();
+        double cx = rx * CORNER;
+        double cy = ry * CORNER;
+        it.move(x0, y0 + ry);
+        it.line(x0, y1 - ry);
+        it.cubic(x0, y1 - cy, x0 + cx, y1, x0 + rx, y1);
+        it.line(x1 - rx, y1);
+        it.cubic(x1 - cx, y1, x1, y1 - cy, x1, y1 - ry);
+        it.line(x1, y0 + ry);
+        it.cubic(x1, y0 + cy, x1 - cx, y0, x1 - rx, y0);
+        it.line(x0 + rx, y0);
+        it.cubic(x0 + cx, y0, x0, y0 + cy, x0, y0 + ry);
+        it.close();
+        return it;
+    }
+
+    @Override
+    public int hashCode() {
+        long bits = java.lang.Double.doubleToLongBits(getX());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getY());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getWidth());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getHeight());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getArcWidth());
+        bits = bits * 31 + java.lang.Double.doubleToLongBits(getArcHeight());
+        return (int) bits ^ (int) (bits >> 32);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof RoundRectangle2D) {
+            RoundRectangle2D r = (RoundRectangle2D) obj;
+            return getX() == r.getX() && getY() == r.getY()
+                    && getWidth() == r.getWidth() && getHeight() == r.getHeight()
+                    && getArcWidth() == r.getArcWidth() && getArcHeight() == r.getArcHeight();
+        }
+        return false;
+    }
+
+    /// Returns a copy of this shape. A subclass from elsewhere that does not
+    /// override it gets a double precision rounded rectangle back.
+    @Override
+    public Object clone() {
+        return new Double(getX(), getY(), getWidth(), getHeight(), getArcWidth(), getArcHeight());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/SegmentIterator.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/SegmentIterator.java
new file mode 100644
index 00000000000..6ed247e964c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/SegmentIterator.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import java.util.NoSuchElementException;
+
+/// The one path iterator every shape of the package hands out: a list of
+/// segment types with their coordinates, mapped through an optional
+/// transform as they are read.
+///
+/// A shape either fills one through `move`, `line`, `quad`, `cubic` and
+/// `close` before returning it, or wraps the arrays it already keeps.
+final class SegmentIterator implements PathIterator {
+
+    private byte[] types;
+    private double[] coords;
+    private int count;
+    private int coordCount;
+    private final int rule;
+    private final AffineTransform at;
+    private int index;
+    private int coordIndex;
+
+    /// An empty iterator with room for the given number of segments.
+    SegmentIterator(int rule, AffineTransform at, int segments) {
+        this.rule = rule;
+        this.at = at;
+        this.types = new byte[segments];
+        this.coords = new double[segments * 6];
+    }
+
+    /// An iterator over segments a path already holds.
+    SegmentIterator(int rule, AffineTransform at, byte[] types, int count, double[] coords) {
+        this.rule = rule;
+        this.at = at;
+        this.types = types;
+        this.count = count;
+        this.coords = coords;
+    }
+
+    /// The number of coordinates a segment of the given type carries.
+    static int size(int type) {
+        switch (type) {
+            case SEG_MOVETO:
+            case SEG_LINETO:
+                return 2;
+            case SEG_QUADTO:
+                return 4;
+            case SEG_CUBICTO:
+                return 6;
+            default:
+                return 0;
+        }
+    }
+
+    private void add(int type) {
+        if (count == types.length) {
+            byte[] t = new byte[count * 2 + 4];
+            System.arraycopy(types, 0, t, 0, count);
+            types = t;
+        }
+        if (coordCount + 6 > coords.length) {
+            double[] c = new double[coords.length * 2 + 12];
+            System.arraycopy(coords, 0, c, 0, coordCount);
+            coords = c;
+        }
+        types[count++] = (byte) type;
+    }
+
+    void move(double x, double y) {
+        add(SEG_MOVETO);
+        coords[coordCount++] = x;
+        coords[coordCount++] = y;
+    }
+
+    void line(double x, double y) {
+        add(SEG_LINETO);
+        coords[coordCount++] = x;
+        coords[coordCount++] = y;
+    }
+
+    void quad(double cx, double cy, double x, double y) {
+        add(SEG_QUADTO);
+        coords[coordCount++] = cx;
+        coords[coordCount++] = cy;
+        coords[coordCount++] = x;
+        coords[coordCount++] = y;
+    }
+
+    void cubic(double cx1, double cy1, double cx2, double cy2, double x, double y) {
+        add(SEG_CUBICTO);
+        coords[coordCount++] = cx1;
+        coords[coordCount++] = cy1;
+        coords[coordCount++] = cx2;
+        coords[coordCount++] = cy2;
+        coords[coordCount++] = x;
+        coords[coordCount++] = y;
+    }
+
+    void close() {
+        add(SEG_CLOSE);
+    }
+
+    @Override
+    public int getWindingRule() {
+        return rule;
+    }
+
+    @Override
+    public boolean isDone() {
+        return index >= count;
+    }
+
+    @Override
+    public void next() {
+        if (index < count) {
+            coordIndex += size(types[index]);
+            index++;
+        }
+    }
+
+    @Override
+    public int currentSegment(float[] out) {
+        if (index >= count) {
+            throw new NoSuchElementException("path iterator out of bounds");
+        }
+        int type = types[index];
+        int n = size(type);
+        if (n > 0) {
+            if (at != null) {
+                at.transform(coords, coordIndex, out, 0, n / 2);
+            } else {
+                for (int i = 0; i < n; i++) {
+                    out[i] = (float) coords[coordIndex + i];
+                }
+            }
+        }
+        return type;
+    }
+
+    @Override
+    public int currentSegment(double[] out) {
+        if (index >= count) {
+            throw new NoSuchElementException("path iterator out of bounds");
+        }
+        int type = types[index];
+        int n = size(type);
+        if (n > 0) {
+            if (at != null) {
+                at.transform(coords, coordIndex, out, 0, n / 2);
+            } else {
+                System.arraycopy(coords, coordIndex, out, 0, n);
+            }
+        }
+        return type;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/package-info.java
new file mode 100644
index 00000000000..46fa0198212
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/geom/package-info.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Two dimensional geometry for the desktop compatibility layer: points,
+/// rectangles, lines, ellipses, arcs, Bezier curves, general paths and the
+/// affine transform that maps between coordinate spaces.
+///
+/// These classes stand in for the JDK's `java.awt.geom` package once an
+/// application has been relocated onto the layer. They are plain data and
+/// arithmetic with no dependency on a toolkit, and are written against the
+/// small class library a device has: trigonometry beyond sine, cosine and
+/// tangent goes through `com.codename1.util.MathUtil`, and every `clone()`
+/// builds its copy explicitly.
+///
+/// Curved outlines are answered through [PathIterator] as cubic Bezier
+/// segments. Hit testing of a [Path2D], a [QuadCurve2D], a [CubicCurve2D] and
+/// of an [Arc2D] against a rectangle is done over the flattened outline, so
+/// it is exact for polygons and accurate to a small fraction of the shape's
+/// size for curves.
+package com.codename1.desktopcompat.java.awt.geom;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/BufferedImage.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/BufferedImage.java
new file mode 100644
index 00000000000..43f623910dc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/BufferedImage.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.image;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.Transparency;
+import com.codename1.desktopcompat.rt.G2D;
+
+/// An image whose pixels are an array of ARGB integers.
+///
+/// Whatever type it is created with, it stores one `int` per pixel; the
+/// type only decides whether the alpha channel is kept (`TYPE_INT_ARGB` and
+/// the other alpha types) or every pixel is opaque. Drawing into it goes
+/// through a Codename One mutable image that is created the first time a
+/// graphics is asked for; pixels move between that image and the array only
+/// when the other side has changed and is then read, so a program that only
+/// calls `setRGB`, or only draws, never pays for the copy. There are no
+/// rasters, color models or sample models.
+public class BufferedImage extends Image implements RenderedImage, Transparency {
+
+    public static final int TYPE_CUSTOM = 0;
+    public static final int TYPE_INT_RGB = 1;
+    public static final int TYPE_INT_ARGB = 2;
+    public static final int TYPE_INT_ARGB_PRE = 3;
+    public static final int TYPE_INT_BGR = 4;
+    public static final int TYPE_3BYTE_BGR = 5;
+    public static final int TYPE_4BYTE_ABGR = 6;
+    public static final int TYPE_4BYTE_ABGR_PRE = 7;
+    public static final int TYPE_USHORT_565_RGB = 8;
+    public static final int TYPE_USHORT_555_RGB = 9;
+    public static final int TYPE_BYTE_GRAY = 10;
+    public static final int TYPE_USHORT_GRAY = 11;
+    public static final int TYPE_BYTE_BINARY = 12;
+    public static final int TYPE_BYTE_INDEXED = 13;
+
+    private final int width;
+    private final int height;
+    private final int type;
+    private final boolean alpha;
+    private final int[] pixels;
+    /// The mutable image drawing goes into, once a graphics was asked for.
+    private com.codename1.ui.Image surface;
+    /// An immutable image of [#pixels], for an image nobody draws into.
+    private com.codename1.ui.Image snapshot;
+    private boolean surfaceNewer;
+    private boolean pixelsNewer;
+
+    public BufferedImage(int width, int height, int imageType) {
+        if (width <= 0 || height <= 0) {
+            throw new IllegalArgumentException("Width (" + width + ") and height (" + height + ") cannot be <= 0");
+        }
+        this.width = width;
+        this.height = height;
+        this.type = imageType;
+        this.alpha = imageType == TYPE_INT_ARGB || imageType == TYPE_INT_ARGB_PRE || imageType == TYPE_4BYTE_ABGR
+                || imageType == TYPE_4BYTE_ABGR_PRE || imageType == TYPE_CUSTOM;
+        this.pixels = new int[width * height];
+        if (!alpha) {
+            for (int i = 0; i < pixels.length; i++) {
+                pixels[i] = 0xff000000;
+            }
+        }
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    @Override
+    public int getWidth() {
+        return width;
+    }
+
+    @Override
+    public int getHeight() {
+        return height;
+    }
+
+    @Override
+    public int getMinX() {
+        return 0;
+    }
+
+    @Override
+    public int getMinY() {
+        return 0;
+    }
+
+    @Override
+    public int getWidth(ImageObserver observer) {
+        return width;
+    }
+
+    @Override
+    public int getHeight(ImageObserver observer) {
+        return height;
+    }
+
+    private void pull() {
+        if (surfaceNewer && surface != null) {
+            surfaceNewer = false;
+            int[] rgb = surface.getRGB();
+            if (rgb != null && rgb.length == pixels.length) {
+                System.arraycopy(rgb, 0, pixels, 0, rgb.length);
+            }
+            if (!alpha) {
+                for (int i = 0; i < pixels.length; i++) {
+                    pixels[i] |= 0xff000000;
+                }
+            }
+        }
+    }
+
+    private void push() {
+        if (pixelsNewer && surface != null) {
+            pixelsNewer = false;
+            com.codename1.ui.Graphics g = surface.getGraphics();
+            g.clearRect(0, 0, width, height);
+            g.drawImage(com.codename1.ui.Image.createImage(pixels, width, height), 0, 0);
+        }
+    }
+
+    private void check(int x, int y) {
+        if (x < 0 || y < 0 || x >= width || y >= height) {
+            throw new ArrayIndexOutOfBoundsException("Coordinate out of bounds!");
+        }
+    }
+
+    public int getRGB(int x, int y) {
+        check(x, y);
+        pull();
+        return pixels[y * width + x];
+    }
+
+    public int[] getRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset, int scansize) {
+        int[] out = rgbArray == null ? new int[offset + h * scansize] : rgbArray;
+        if (w <= 0 || h <= 0) {
+            return out;
+        }
+        check(startX, startY);
+        check(startX + w - 1, startY + h - 1);
+        pull();
+        for (int row = 0; row < h; row++) {
+            System.arraycopy(pixels, (startY + row) * width + startX, out, offset + row * scansize, w);
+        }
+        return out;
+    }
+
+    public void setRGB(int x, int y, int rgb) {
+        check(x, y);
+        pull();
+        pixels[y * width + x] = alpha ? rgb : rgb | 0xff000000;
+        pixelsNewer = true;
+        snapshot = null;
+    }
+
+    public void setRGB(int startX, int startY, int w, int h, int[] rgbArray, int offset, int scansize) {
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        check(startX, startY);
+        check(startX + w - 1, startY + h - 1);
+        pull();
+        for (int row = 0; row < h; row++) {
+            int to = (startY + row) * width + startX;
+            int from = offset + row * scansize;
+            for (int col = 0; col < w; col++) {
+                pixels[to + col] = alpha ? rgbArray[from + col] : rgbArray[from + col] | 0xff000000;
+            }
+        }
+        pixelsNewer = true;
+        snapshot = null;
+    }
+
+    @Override
+    public Graphics getGraphics() {
+        return createGraphics();
+    }
+
+    public Graphics2D createGraphics() {
+        if (surface == null) {
+            surface = com.codename1.ui.Image.createImage(width, height, alpha ? 0 : 0xff000000);
+            pixelsNewer = true;
+            snapshot = null;
+        }
+        push();
+        return G2D.forImage(this, surface.getGraphics(), width, height);
+    }
+
+    /// Called by a graphics of this image before it draws: the surface now
+    /// holds pixels the array does not.
+    public void cn1Drawing() {
+        push();
+        surfaceNewer = true;
+    }
+
+    @Override
+    public com.codename1.ui.Image cn1Image() {
+        if (surface != null) {
+            push();
+            return surface;
+        }
+        if (snapshot == null) {
+            snapshot = com.codename1.ui.Image.createImage(pixels, width, height);
+        }
+        return snapshot;
+    }
+
+    /// A copy of the region. The JDK's subimage shares pixels with its
+    /// parent; this one does not.
+    public BufferedImage getSubimage(int x, int y, int w, int h) {
+        BufferedImage out = new BufferedImage(w, h, type);
+        getRGB(x, y, w, h, out.pixels, 0, w);
+        out.pixelsNewer = true;
+        return out;
+    }
+
+    public boolean isAlphaPremultiplied() {
+        return false;
+    }
+
+    @Override
+    public int getTransparency() {
+        return alpha ? TRANSLUCENT : OPAQUE;
+    }
+
+    @Override
+    public void flush() {
+        snapshot = null;
+    }
+
+    @Override
+    public String toString() {
+        return "BufferedImage@" + Integer.toHexString(hashCode()) + ": type = " + type + " " + width + "x" + height;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/BufferedImageOp.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/BufferedImageOp.java
new file mode 100644
index 00000000000..9c5cf64098f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/BufferedImageOp.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.image;
+
+/// An operation that makes one buffered image from another.
+public interface BufferedImageOp {
+
+    /// The image the operation makes of `src`, written to `dest` or, when
+    /// that is `null`, to a new image.
+    BufferedImage filter(BufferedImage src, BufferedImage dest);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/ImageObserver.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/ImageObserver.java
new file mode 100644
index 00000000000..2bd855f8d35
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/ImageObserver.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.image;
+
+import com.codename1.desktopcompat.java.awt.Image;
+
+/// Told as an image loads. Images of the layer are complete as soon as they
+/// exist, so an observer is accepted wherever the API takes one and never
+/// called.
+public interface ImageObserver {
+    int WIDTH = 1;
+    int HEIGHT = 2;
+    int PROPERTIES = 4;
+    int SOMEBITS = 8;
+    int FRAMEBITS = 16;
+    int ALLBITS = 32;
+    int ERROR = 64;
+    int ABORT = 128;
+
+    boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/RenderedImage.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/RenderedImage.java
new file mode 100644
index 00000000000..bb5884c5596
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/RenderedImage.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.image;
+
+/// An image whose pixels can be read, the kind `ImageIO.write` takes.
+/// [BufferedImage] is the one implementation; the raster and colour model
+/// of the desktop's interface are not here.
+public interface RenderedImage {
+
+    int getWidth();
+
+    int getHeight();
+
+    int getMinX();
+
+    int getMinY();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/package-info.java
new file mode 100644
index 00000000000..32cd8c377d2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/image/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Images whose pixels a program can read and write. `BufferedImage` keeps
+/// its pixels as ARGB integers and hands them to Codename One when drawn.
+package com.codename1.desktopcompat.java.awt.image;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/package-info.java
new file mode 100644
index 00000000000..512cca33da9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The AWT core: components and containers, graphics, colors, fonts,
+/// layout managers and windows, written over Codename One.
+///
+/// Coordinates are logical pixels of 1/96 inch, whatever the density of the
+/// display. Every component is shown through one Codename One component,
+/// its peer; see [com.codename1.desktopcompat.java.awt.Component].
+package com.codename1.desktopcompat.java.awt;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/print/PrinterException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/print/PrinterException.java
new file mode 100644
index 00000000000..48640f39a61
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/print/PrinterException.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.print;
+
+/// Printing could not be done.
+public class PrinterException extends Exception {
+
+    public PrinterException() {
+        super();
+    }
+
+    public PrinterException(String msg) {
+        super(msg);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/print/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/print/package-info.java
new file mode 100644
index 00000000000..a4a937804ed
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/awt/print/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// What is left of `java.awt.print` on a device that has no print
+/// service: the exception that says so.
+package com.codename1.desktopcompat.java.awt.print;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/BeanDescriptor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/BeanDescriptor.java
new file mode 100644
index 00000000000..87a84fa6f1d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/BeanDescriptor.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// Describes a bean class as a whole: the class, and the customizer class a
+/// GUI builder would configure it with.
+public class BeanDescriptor extends FeatureDescriptor {
+
+    private final Class<?> beanClass;
+    private final Class<?> customizerClass;
+
+    public BeanDescriptor(Class<?> beanClass) {
+        this(beanClass, null);
+    }
+
+    public BeanDescriptor(Class<?> beanClass, Class<?> customizerClass) {
+        this.beanClass = beanClass;
+        this.customizerClass = customizerClass;
+        String full = beanClass.getName();
+        setName(full.substring(full.lastIndexOf('.') + 1));
+    }
+
+    public Class<?> getBeanClass() {
+        return beanClass;
+    }
+
+    public Class<?> getCustomizerClass() {
+        return customizerClass;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/BeanInfo.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/BeanInfo.java
new file mode 100644
index 00000000000..d759b3d8f1b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/BeanInfo.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// What is known about a bean class. Only the class-level descriptor is: the
+/// property, event and method tables of the JDK's interface are built by
+/// reflection, which a device does not have, so those methods are absent and
+/// code calling them is reported at build time.
+public interface BeanInfo {
+
+    BeanDescriptor getBeanDescriptor();
+
+    int getDefaultPropertyIndex();
+
+    int getDefaultEventIndex();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Beans.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Beans.java
new file mode 100644
index 00000000000..6ca0fb130bd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Beans.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// The two environment questions of `java.beans.Beans`: whether the code is
+/// running inside a GUI builder, and whether it may show a user interface.
+///
+/// An application on a device is never inside a builder and always has a
+/// display, so those are the answers until something sets others. The bean
+/// instantiation half of the class (`instantiate`, `getInstanceOf`) loads
+/// classes by name and is not provided.
+public class Beans {
+
+    private static boolean designTime;
+    private static boolean guiAvailable = true;
+
+    public Beans() {
+        // The JDK's class is instantiable, though all its members are static.
+    }
+
+    public static boolean isDesignTime() {
+        return designTime;
+    }
+
+    public static void setDesignTime(boolean isDesignTime) {
+        designTime = isDesignTime;
+    }
+
+    public static boolean isGuiAvailable() {
+        return guiAvailable;
+    }
+
+    public static void setGuiAvailable(boolean isGuiAvailable) {
+        guiAvailable = isGuiAvailable;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Encoder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Encoder.java
new file mode 100644
index 00000000000..7eb8a0a2f2a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Encoder.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import com.codename1.annotations.LinkOnly;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/// Turns an object graph into the statements that rebuild it.
+///
+/// Long-term persistence writes an object as the calls that rebuild it and
+/// finds those calls by reflection, so nothing of it can run on a device. The
+/// class is [LinkOnly]: it exists for the libraries that offer to save
+/// themselves this way beside everything else they do, and an application's
+/// own use of it is reported at build time.
+///
+/// Delegates and the exception listener can be registered and read back;
+/// [#writeObject(Object)] throws `UnsupportedOperationException`.
+@LinkOnly
+public class Encoder {
+
+    private final Map<Class<?>, PersistenceDelegate> delegates = new HashMap<Class<?>, PersistenceDelegate>();
+    private ExceptionListener listener;
+
+    public Encoder() {
+        // Nothing to set up.
+    }
+
+    protected void writeObject(Object o) {
+        throw new UnsupportedOperationException("java.beans.Encoder needs reflection to write an object");
+    }
+
+    public void setExceptionListener(ExceptionListener exceptionListener) {
+        this.listener = exceptionListener;
+    }
+
+    public ExceptionListener getExceptionListener() {
+        return listener;
+    }
+
+    public PersistenceDelegate getPersistenceDelegate(Class<?> type) {
+        return type == null ? null : delegates.get(type);
+    }
+
+    public void setPersistenceDelegate(Class<?> type, PersistenceDelegate delegate) {
+        delegates.put(type, delegate);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/ExceptionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/ExceptionListener.java
new file mode 100644
index 00000000000..b418cb15abb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/ExceptionListener.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// Told about an exception something recovered from and carried on.
+public interface ExceptionListener {
+
+    void exceptionThrown(Exception e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Expression.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Expression.java
new file mode 100644
index 00000000000..2f21627f170
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Expression.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import com.codename1.annotations.LinkOnly;
+
+/// A [Statement] that yields a value.
+///
+/// Long-term persistence writes an object as the calls that rebuild it and
+/// finds those calls by reflection, so nothing of it can run on a device. The
+/// class is [LinkOnly]: it exists for the libraries that offer to save
+/// themselves this way beside everything else they do, and an application's
+/// own use of it is reported at build time.
+///
+/// A value given to the constructor or to [#setValue(Object)] is answered by
+/// [#getValue()]; one that would have to be computed by making the call is
+/// not, and `getValue` throws `UnsupportedOperationException`.
+@LinkOnly
+public class Expression extends Statement {
+
+    private Object value;
+    private boolean valueSet;
+
+    public Expression(Object target, String methodName, Object[] arguments) {
+        super(target, methodName, arguments);
+    }
+
+    public Expression(Object value, Object target, String methodName, Object[] arguments) {
+        super(target, methodName, arguments);
+        setValue(value);
+    }
+
+    public Object getValue() throws Exception {
+        if (!valueSet) {
+            execute();
+        }
+        return value;
+    }
+
+    public void setValue(Object value) {
+        this.value = value;
+        this.valueSet = true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/FeatureDescriptor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/FeatureDescriptor.java
new file mode 100644
index 00000000000..83785512788
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/FeatureDescriptor.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
+
+/// What every bean descriptor has in common: a name, a display name, a short
+/// description, and a table of named values a tool or a library may attach.
+public class FeatureDescriptor {
+
+    private String name;
+    private String displayName;
+    private String shortDescription;
+    private boolean expert;
+    private boolean hidden;
+    private boolean preferred;
+    private final Map<String, Object> values = new HashMap<String, Object>();
+
+    public FeatureDescriptor() {
+        // Named by its setters.
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDisplayName() {
+        return displayName == null ? getName() : displayName;
+    }
+
+    public void setDisplayName(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getShortDescription() {
+        return shortDescription == null ? getDisplayName() : shortDescription;
+    }
+
+    public void setShortDescription(String text) {
+        this.shortDescription = text;
+    }
+
+    public boolean isExpert() {
+        return expert;
+    }
+
+    public void setExpert(boolean expert) {
+        this.expert = expert;
+    }
+
+    public boolean isHidden() {
+        return hidden;
+    }
+
+    public void setHidden(boolean hidden) {
+        this.hidden = hidden;
+    }
+
+    public boolean isPreferred() {
+        return preferred;
+    }
+
+    public void setPreferred(boolean preferred) {
+        this.preferred = preferred;
+    }
+
+    public void setValue(String attributeName, Object value) {
+        if (attributeName == null || value == null) {
+            throw new NullPointerException();
+        }
+        values.put(attributeName, value);
+    }
+
+    public Object getValue(String attributeName) {
+        return attributeName == null ? null : values.get(attributeName);
+    }
+
+    public Enumeration<String> attributeNames() {
+        return Collections.enumeration(values.keySet());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/IndexedPropertyChangeEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/IndexedPropertyChangeEvent.java
new file mode 100644
index 00000000000..70df5676d5b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/IndexedPropertyChangeEvent.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// A bound property changed at one index of an indexed property.
+public class IndexedPropertyChangeEvent extends PropertyChangeEvent {
+
+    private final int index;
+
+    public IndexedPropertyChangeEvent(Object source, String propertyName, Object oldValue, Object newValue,
+            int index) {
+        super(source, propertyName, oldValue, newValue);
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    @Override
+    void appendTo(StringBuilder sb) {
+        sb.append("; index=").append(index);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/IntrospectionException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/IntrospectionException.java
new file mode 100644
index 00000000000..1595355ecc9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/IntrospectionException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// Thrown when a bean could not be examined.
+public class IntrospectionException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    public IntrospectionException(String mess) {
+        super(mess);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Introspector.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Introspector.java
new file mode 100644
index 00000000000..b98752eaa98
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Introspector.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/// Answers the [BeanInfo] of a class: one object per class for as long as the
+/// application runs, so a value a library attaches to a class's
+/// [BeanDescriptor] is there the next time it asks.
+///
+/// Nothing is discovered about the class. The JDK finds properties, events
+/// and methods by reflection; here the info holds the class-level descriptor
+/// and nothing else ([BeanInfo]).
+public class Introspector {
+
+    public static final int USE_ALL_BEANINFO = 1;
+    public static final int IGNORE_IMMEDIATE_BEANINFO = 2;
+    public static final int IGNORE_ALL_BEANINFO = 3;
+
+    private static final Map<Class<?>, BeanInfo> INFOS = new HashMap<Class<?>, BeanInfo>();
+
+    private Introspector() {
+    }
+
+    public static BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException {
+        if (beanClass == null) {
+            throw new IntrospectionException("null bean class");
+        }
+        BeanInfo info = INFOS.get(beanClass);
+        if (info == null) {
+            info = new ClassInfo(new BeanDescriptor(beanClass));
+            INFOS.put(beanClass, info);
+        }
+        return info;
+    }
+
+    /// The flags choose which explicit `BeanInfo` classes the JDK consults;
+    /// there are none to consult here, so they change nothing.
+    public static BeanInfo getBeanInfo(Class<?> beanClass, int flags) throws IntrospectionException {
+        if (flags < USE_ALL_BEANINFO || flags > IGNORE_ALL_BEANINFO) {
+            throw new IllegalArgumentException("flags must be USE_ALL_BEANINFO, IGNORE_IMMEDIATE_BEANINFO or "
+                    + "IGNORE_ALL_BEANINFO");
+        }
+        return getBeanInfo(beanClass);
+    }
+
+    /// `FooBah` becomes `fooBah` and `X` becomes `x`, while `URL` stays as it
+    /// is: a name whose first two characters are both upper case is an
+    /// acronym.
+    public static String decapitalize(String name) {
+        if (name == null || name.length() == 0) {
+            return name;
+        }
+        if (name.length() > 1 && isUpper(name.charAt(1)) && isUpper(name.charAt(0))) {
+            return name;
+        }
+        char first = name.charAt(0);
+        if (first >= 'A' && first <= 'Z') {
+            first = (char) (first - 'A' + 'a');
+        } else {
+            first = Character.toLowerCase(first);
+        }
+        return first + name.substring(1);
+    }
+
+    private static boolean isUpper(char c) {
+        return Character.isUpperCase(c);
+    }
+
+    public static void flushCaches() {
+        INFOS.clear();
+    }
+
+    public static void flushFromCaches(Class<?> clz) {
+        if (clz == null) {
+            throw new NullPointerException();
+        }
+        INFOS.remove(clz);
+    }
+
+    private static final class ClassInfo implements BeanInfo {
+        private final BeanDescriptor descriptor;
+
+        ClassInfo(BeanDescriptor descriptor) {
+            this.descriptor = descriptor;
+        }
+
+        @Override
+        public BeanDescriptor getBeanDescriptor() {
+            return descriptor;
+        }
+
+        @Override
+        public int getDefaultPropertyIndex() {
+            return -1;
+        }
+
+        @Override
+        public int getDefaultEventIndex() {
+            return -1;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PersistenceDelegate.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PersistenceDelegate.java
new file mode 100644
index 00000000000..e4c19923db6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PersistenceDelegate.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import com.codename1.annotations.LinkOnly;
+
+/// Tells an [Encoder] how to write the objects of one class.
+///
+/// Long-term persistence writes an object as the calls that rebuild it and
+/// finds those calls by reflection, so nothing of it can run on a device. The
+/// class is [LinkOnly]: it exists for the libraries that offer to save
+/// themselves this way beside everything else they do, and an application's
+/// own use of it is reported at build time.
+///
+/// A library can subclass it and register the subclass; no encoder ever
+/// calls it back.
+@LinkOnly
+public abstract class PersistenceDelegate {
+
+    public PersistenceDelegate() {
+        // Nothing to set up.
+    }
+
+    public void writeObject(Object oldInstance, Encoder out) {
+        throw new UnsupportedOperationException("java.beans.PersistenceDelegate needs reflection to write an object");
+    }
+
+    protected boolean mutatesTo(Object oldInstance, Object newInstance) {
+        return newInstance != null && oldInstance != null && oldInstance.getClass() == newInstance.getClass();
+    }
+
+    protected abstract Expression instantiate(Object oldInstance, Encoder out);
+
+    protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
+        // The JDK's default asks the superclass's delegate, and at the top
+        // of that chain does nothing.
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeEvent.java
new file mode 100644
index 00000000000..495403acf79
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeEvent.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.EventObject;
+
+/// A bound property changed.
+///
+/// A `null` property name means that several properties changed, and a
+/// `null` old or new value means that the value is unknown.
+public class PropertyChangeEvent extends EventObject {
+
+    private final String propertyName;
+
+    private final Object newValue;
+
+    private final Object oldValue;
+
+    private Object propagationId;
+
+    public PropertyChangeEvent(Object source, String propertyName, Object oldValue, Object newValue) {
+        super(source);
+        this.propertyName = propertyName;
+        this.newValue = newValue;
+        this.oldValue = oldValue;
+    }
+
+    public String getPropertyName() {
+        return propertyName;
+    }
+
+    public Object getNewValue() {
+        return newValue;
+    }
+
+    public Object getOldValue() {
+        return oldValue;
+    }
+
+    public void setPropagationId(Object propagationId) {
+        this.propagationId = propagationId;
+    }
+
+    public Object getPropagationId() {
+        return propagationId;
+    }
+
+    /// Lets a subclass add its own fields to the text of `toString()`.
+    void appendTo(StringBuilder sb) {
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder(getClass().getName());
+        sb.append("[propertyName=").append(propertyName);
+        appendTo(sb);
+        sb.append("; oldValue=").append(oldValue);
+        sb.append("; newValue=").append(newValue);
+        sb.append("; propagationId=").append(propagationId);
+        sb.append("; source=").append(getSource());
+        return sb.append(']').toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeListener.java
new file mode 100644
index 00000000000..fcd508884e9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.EventListener;
+
+/// Receives the changes of a bound property.
+public interface PropertyChangeListener extends EventListener {
+
+    void propertyChange(PropertyChangeEvent evt);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeListenerProxy.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeListenerProxy.java
new file mode 100644
index 00000000000..ea5fc99d930
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeListenerProxy.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.EventListenerProxy;
+
+/// A listener bound to one property name, wrapping the listener that
+/// receives that property's changes.
+///
+/// The device class library's `EventListenerProxy` is not generic, so this
+/// extends it as a raw type and `getListener()` answers the wrapped listener
+/// as a plain `EventListener`.
+public class PropertyChangeListenerProxy extends EventListenerProxy implements PropertyChangeListener {
+
+    private final String propertyName;
+
+    public PropertyChangeListenerProxy(String propertyName, PropertyChangeListener listener) {
+        super(listener);
+        this.propertyName = propertyName;
+    }
+
+    public void propertyChange(PropertyChangeEvent evt) {
+        PropertyChangeListener l = (PropertyChangeListener) getListener();
+        l.propertyChange(evt);
+    }
+
+    public String getPropertyName() {
+        return propertyName;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeSupport.java
new file mode 100644
index 00000000000..b72ba1f2aee
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyChangeSupport.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/// Keeps the listeners of a bean's bound properties and delivers events to
+/// them.
+///
+/// Listeners added with a property name receive only that property's events;
+/// the others receive all. A `PropertyChangeListenerProxy` passed to
+/// `addPropertyChangeListener(PropertyChangeListener)` is registered under
+/// the name it carries. No event is fired when the old and new values are
+/// both non-null and equal. The user interface is single threaded, so unlike
+/// the JDK class this does not synchronize.
+public class PropertyChangeSupport {
+
+    private final Object source;
+
+    private final ArrayList<PropertyChangeListener> common = new ArrayList<PropertyChangeListener>();
+
+    private final HashMap<String, ArrayList<PropertyChangeListener>> named =
+            new HashMap<String, ArrayList<PropertyChangeListener>>();
+
+    public PropertyChangeSupport(Object sourceBean) {
+        if (sourceBean == null) {
+            throw new NullPointerException();
+        }
+        source = sourceBean;
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (listener == null) {
+            return;
+        }
+        if (listener instanceof PropertyChangeListenerProxy) {
+            PropertyChangeListenerProxy proxy = (PropertyChangeListenerProxy) listener;
+            Object wrapped = proxy.getListener();
+            if (wrapped instanceof PropertyChangeListener) {
+                addPropertyChangeListener(proxy.getPropertyName(), (PropertyChangeListener) wrapped);
+            }
+        } else {
+            common.add(listener);
+        }
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (listener == null) {
+            return;
+        }
+        if (listener instanceof PropertyChangeListenerProxy) {
+            PropertyChangeListenerProxy proxy = (PropertyChangeListenerProxy) listener;
+            Object wrapped = proxy.getListener();
+            if (wrapped instanceof PropertyChangeListener) {
+                removePropertyChangeListener(proxy.getPropertyName(), (PropertyChangeListener) wrapped);
+            }
+        } else {
+            common.remove(listener);
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners() {
+        ArrayList<PropertyChangeListener> all = new ArrayList<PropertyChangeListener>(common);
+        for (Map.Entry<String, ArrayList<PropertyChangeListener>> e : named.entrySet()) {
+            for (PropertyChangeListener l : e.getValue()) {
+                all.add(new PropertyChangeListenerProxy(e.getKey(), l));
+            }
+        }
+        return all.toArray(new PropertyChangeListener[all.size()]);
+    }
+
+    public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        if (listener == null || propertyName == null) {
+            return;
+        }
+        if (listener instanceof PropertyChangeListenerProxy) {
+            addPropertyChangeListener(listener);
+            return;
+        }
+        ArrayList<PropertyChangeListener> list = named.get(propertyName);
+        if (list == null) {
+            list = new ArrayList<PropertyChangeListener>();
+            named.put(propertyName, list);
+        }
+        list.add(listener);
+    }
+
+    public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        if (listener == null || propertyName == null) {
+            return;
+        }
+        if (listener instanceof PropertyChangeListenerProxy) {
+            removePropertyChangeListener(listener);
+            return;
+        }
+        ArrayList<PropertyChangeListener> list = named.get(propertyName);
+        if (list != null) {
+            list.remove(listener);
+            if (list.isEmpty()) {
+                named.remove(propertyName);
+            }
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
+        ArrayList<PropertyChangeListener> list = propertyName == null ? null : named.get(propertyName);
+        if (list == null) {
+            return new PropertyChangeListener[0];
+        }
+        return list.toArray(new PropertyChangeListener[list.size()]);
+    }
+
+    public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        if (oldValue == null || newValue == null || !oldValue.equals(newValue)) {
+            firePropertyChange(new PropertyChangeEvent(source, propertyName, oldValue, newValue));
+        }
+    }
+
+    public void firePropertyChange(String propertyName, int oldValue, int newValue) {
+        if (oldValue != newValue) {
+            firePropertyChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue));
+        }
+    }
+
+    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+        if (oldValue != newValue) {
+            firePropertyChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
+        }
+    }
+
+    public void firePropertyChange(PropertyChangeEvent event) {
+        Object oldValue = event.getOldValue();
+        Object newValue = event.getNewValue();
+        if (oldValue != null && newValue != null && oldValue.equals(newValue)) {
+            return;
+        }
+        String name = event.getPropertyName();
+        PropertyChangeListener[] first = common.toArray(new PropertyChangeListener[common.size()]);
+        for (int i = 0; i < first.length; i++) {
+            first[i].propertyChange(event);
+        }
+        if (name != null) {
+            PropertyChangeListener[] second = getPropertyChangeListeners(name);
+            for (int i = 0; i < second.length; i++) {
+                second[i].propertyChange(event);
+            }
+        }
+    }
+
+    public void fireIndexedPropertyChange(String propertyName, int index, Object oldValue, Object newValue) {
+        if (oldValue == null || newValue == null || !oldValue.equals(newValue)) {
+            firePropertyChange(new IndexedPropertyChangeEvent(source, propertyName, oldValue, newValue, index));
+        }
+    }
+
+    public void fireIndexedPropertyChange(String propertyName, int index, int oldValue, int newValue) {
+        if (oldValue != newValue) {
+            fireIndexedPropertyChange(propertyName, index, Integer.valueOf(oldValue), Integer.valueOf(newValue));
+        }
+    }
+
+    public void fireIndexedPropertyChange(String propertyName, int index, boolean oldValue,
+            boolean newValue) {
+        if (oldValue != newValue) {
+            fireIndexedPropertyChange(propertyName, index, Boolean.valueOf(oldValue),
+                    Boolean.valueOf(newValue));
+        }
+    }
+
+    public boolean hasListeners(String propertyName) {
+        if (!common.isEmpty()) {
+            return true;
+        }
+        if (propertyName == null) {
+            return false;
+        }
+        ArrayList<PropertyChangeListener> list = named.get(propertyName);
+        return list != null && !list.isEmpty();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyVetoException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyVetoException.java
new file mode 100644
index 00000000000..219692c1920
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/PropertyVetoException.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+/// Thrown when a listener vetoes a change of a constrained property.
+public class PropertyVetoException extends Exception {
+
+    private final PropertyChangeEvent evt;
+
+    public PropertyVetoException(String mess, PropertyChangeEvent evt) {
+        super(mess);
+        this.evt = evt;
+    }
+
+    public PropertyChangeEvent getPropertyChangeEvent() {
+        return evt;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Statement.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Statement.java
new file mode 100644
index 00000000000..f20d16c9266
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/Statement.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import com.codename1.annotations.LinkOnly;
+
+/// One method call on one object, held as data: `target.methodName(args)`.
+///
+/// Long-term persistence writes an object as the calls that rebuild it and
+/// finds those calls by reflection, so nothing of it can run on a device. The
+/// class is [LinkOnly]: it exists for the libraries that offer to save
+/// themselves this way beside everything else they do, and an application's
+/// own use of it is reported at build time.
+///
+/// The parts can be read back; [#execute()] would have to call a method by
+/// its name and throws `UnsupportedOperationException`.
+@LinkOnly
+public class Statement {
+
+    private final Object target;
+    private final String methodName;
+    private final Object[] arguments;
+
+    public Statement(Object target, String methodName, Object[] arguments) {
+        this.target = target;
+        this.methodName = methodName;
+        this.arguments = arguments == null ? new Object[0] : copy(arguments);
+    }
+
+    private static Object[] copy(Object[] from) {
+        Object[] to = new Object[from.length];
+        System.arraycopy(from, 0, to, 0, from.length);
+        return to;
+    }
+
+    public Object getTarget() {
+        return target;
+    }
+
+    public String getMethodName() {
+        return methodName;
+    }
+
+    public Object[] getArguments() {
+        return copy(arguments);
+    }
+
+    public void execute() throws Exception {
+        throw new UnsupportedOperationException("java.beans.Statement.execute() calls " + methodName
+                + " by name, which needs reflection");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/VetoableChangeListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/VetoableChangeListener.java
new file mode 100644
index 00000000000..ec7e50ab259
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/VetoableChangeListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.EventListener;
+
+/// Receives the changes of a constrained property, and may veto them.
+public interface VetoableChangeListener extends EventListener {
+
+    void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/XMLDecoder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/XMLDecoder.java
new file mode 100644
index 00000000000..e09faf19e76
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/XMLDecoder.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import com.codename1.annotations.LinkOnly;
+
+import java.io.InputStream;
+
+/// Reads the beans an [XMLEncoder] wrote.
+///
+/// Long-term persistence writes an object as the calls that rebuild it and
+/// finds those calls by reflection, so nothing of it can run on a device. The
+/// class is [LinkOnly]: it exists for the libraries that offer to save
+/// themselves this way beside everything else they do, and an application's
+/// own use of it is reported at build time.
+///
+/// [#readObject()] throws `UnsupportedOperationException`; closing it leaves
+/// the stream alone, since nothing was read from it.
+@LinkOnly
+public class XMLDecoder implements AutoCloseable {
+
+    private ExceptionListener listener;
+
+    public XMLDecoder(InputStream in) {
+        // The stream is never read.
+    }
+
+    public Object readObject() {
+        throw new UnsupportedOperationException("java.beans.XMLDecoder needs reflection to read an object");
+    }
+
+    public void setExceptionListener(ExceptionListener exceptionListener) {
+        this.listener = exceptionListener;
+    }
+
+    public ExceptionListener getExceptionListener() {
+        return listener;
+    }
+
+    @Override
+    public void close() {
+        // Nothing was read.
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/XMLEncoder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/XMLEncoder.java
new file mode 100644
index 00000000000..08b99907502
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/XMLEncoder.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import com.codename1.annotations.LinkOnly;
+
+import java.io.OutputStream;
+
+/// Writes beans as an XML document.
+///
+/// Long-term persistence writes an object as the calls that rebuild it and
+/// finds those calls by reflection, so nothing of it can run on a device. The
+/// class is [LinkOnly]: it exists for the libraries that offer to save
+/// themselves this way beside everything else they do, and an application's
+/// own use of it is reported at build time.
+///
+/// It can be constructed and closed, so a library that creates one in a
+/// `try` block and writes nothing still works; [#writeObject(Object)] throws
+/// `UnsupportedOperationException`. Closing it leaves the stream alone: it
+/// was never written to.
+@LinkOnly
+public class XMLEncoder extends Encoder implements AutoCloseable {
+
+    public XMLEncoder(OutputStream out) {
+        if (out == null) {
+            throw new IllegalArgumentException("the output stream cannot be null");
+        }
+    }
+
+    @Override
+    public void writeObject(Object o) {
+        throw new UnsupportedOperationException("java.beans.XMLEncoder needs reflection to write an object");
+    }
+
+    public void flush() {
+        // Nothing was written.
+    }
+
+    @Override
+    public void close() {
+        // Nothing was written.
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/package-info.java
new file mode 100644
index 00000000000..bce6b14f97c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/java/beans/package-info.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The bound-property subset of `java.beans`: property change events, their
+/// listeners, the proxy that binds a listener to one property name, the
+/// support class that fires them, and the veto exception.
+///
+/// The support class does not synchronize.
+///
+/// [Beans] answers the two environment questions, and [Introspector] answers
+/// a [BeanInfo] that holds a class's [BeanDescriptor] and nothing discovered
+/// about it: properties, events and methods are found by reflection on a
+/// desktop, and a device has none.
+///
+/// Long-term persistence ([XMLEncoder], [XMLDecoder], [Encoder],
+/// [PersistenceDelegate], [Statement], [Expression]) is reflection from end
+/// to end and does not work. Those classes are here, marked
+/// `com.codename1.annotations.LinkOnly`, because libraries written against
+/// Swing offer to save themselves that way beside everything else they do
+/// and could not be bundled otherwise: the build accepts a reference from a
+/// bundled library and reports one from an application's own code, as it
+/// does for API that is absent.
+package com.codename1.desktopcompat.java.beans;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/Accessible.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/Accessible.java
new file mode 100644
index 00000000000..fa6862fc55b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/Accessible.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.accessibility;
+
+/// What a component that describes itself to assistive technology
+/// implements.
+public interface Accessible {
+
+    AccessibleContext getAccessibleContext();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleContext.java
new file mode 100644
index 00000000000..588f253af29
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleContext.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.accessibility;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+
+/// What a component tells assistive technology about itself: a name, a
+/// description, a parent and its relations to other components.
+public abstract class AccessibleContext {
+
+    public static final String ACCESSIBLE_NAME_PROPERTY = "AccessibleName";
+
+    public static final String ACCESSIBLE_DESCRIPTION_PROPERTY = "AccessibleDescription";
+
+    protected Accessible accessibleParent;
+
+    protected String accessibleName;
+
+    protected String accessibleDescription;
+
+    private PropertyChangeSupport changes;
+
+    private final AccessibleRelationSet relations = new AccessibleRelationSet();
+
+    public String getAccessibleName() {
+        return accessibleName;
+    }
+
+    public void setAccessibleName(String s) {
+        String old = accessibleName;
+        accessibleName = s;
+        firePropertyChange(ACCESSIBLE_NAME_PROPERTY, old, s);
+    }
+
+    public String getAccessibleDescription() {
+        return accessibleDescription;
+    }
+
+    public void setAccessibleDescription(String s) {
+        String old = accessibleDescription;
+        accessibleDescription = s;
+        firePropertyChange(ACCESSIBLE_DESCRIPTION_PROPERTY, old, s);
+    }
+
+    public Accessible getAccessibleParent() {
+        return accessibleParent;
+    }
+
+    public void setAccessibleParent(Accessible a) {
+        accessibleParent = a;
+    }
+
+    public AccessibleRelationSet getAccessibleRelationSet() {
+        return relations;
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (changes == null) {
+            changes = new PropertyChangeSupport(this);
+        }
+        changes.addPropertyChangeListener(listener);
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (changes != null) {
+            changes.removePropertyChangeListener(listener);
+        }
+    }
+
+    public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        if (changes != null) {
+            changes.firePropertyChange(propertyName, oldValue, newValue);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleRelation.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleRelation.java
new file mode 100644
index 00000000000..0c2d5ee05c4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleRelation.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.accessibility;
+
+/// A relation between the object that holds it and one or more targets,
+/// such as "this label is the label for that field".
+public class AccessibleRelation {
+
+    public static final String LABEL_FOR = "labelFor";
+
+    public static final String LABELED_BY = "labeledBy";
+
+    public static final String MEMBER_OF = "memberOf";
+
+    public static final String CONTROLLER_FOR = "controllerFor";
+
+    public static final String CONTROLLED_BY = "controlledBy";
+
+    public static final String FLOWS_TO = "flowsTo";
+
+    public static final String FLOWS_FROM = "flowsFrom";
+
+    public static final String SUBWINDOW_OF = "subwindowOf";
+
+    public static final String PARENT_WINDOW_OF = "parentWindowOf";
+
+    public static final String EMBEDS = "embeds";
+
+    public static final String EMBEDDED_BY = "embeddedBy";
+
+    public static final String CHILD_NODE_OF = "childNodeOf";
+
+    public static final String LABEL_FOR_PROPERTY = "labelForProperty";
+
+    public static final String LABELED_BY_PROPERTY = "labeledByProperty";
+
+    public static final String MEMBER_OF_PROPERTY = "memberOfProperty";
+
+    public static final String CONTROLLER_FOR_PROPERTY = "controllerForProperty";
+
+    public static final String CONTROLLED_BY_PROPERTY = "controlledByProperty";
+
+    private final String relationKey;
+
+    private Object[] target = new Object[0];
+
+    public AccessibleRelation(String key) {
+        relationKey = key;
+    }
+
+    public AccessibleRelation(String key, Object target) {
+        relationKey = key;
+        this.target = new Object[] {target};
+    }
+
+    public AccessibleRelation(String key, Object[] target) {
+        relationKey = key;
+        setTarget(target);
+    }
+
+    public String getKey() {
+        return relationKey;
+    }
+
+    /// A copy of the targets.
+    public Object[] getTarget() {
+        Object[] copy = new Object[target.length];
+        System.arraycopy(target, 0, copy, 0, copy.length);
+        return copy;
+    }
+
+    public void setTarget(Object target) {
+        this.target = new Object[] {target};
+    }
+
+    public void setTarget(Object[] target) {
+        Object[] from = target == null ? new Object[0] : target;
+        Object[] copy = new Object[from.length];
+        System.arraycopy(from, 0, copy, 0, copy.length);
+        this.target = copy;
+    }
+
+    @Override
+    public String toString() {
+        return relationKey;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleRelationSet.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleRelationSet.java
new file mode 100644
index 00000000000..59ac61a1088
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/AccessibleRelationSet.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.accessibility;
+
+import java.util.Vector;
+
+/// The relations of one object, at most one of each kind: adding a
+/// relation of a kind that is there already adds its targets to the one
+/// that is.
+public class AccessibleRelationSet {
+
+    protected Vector<AccessibleRelation> relations;
+
+    public AccessibleRelationSet() {
+        relations = null;
+    }
+
+    public AccessibleRelationSet(AccessibleRelation[] relations) {
+        if (relations.length != 0) {
+            this.relations = new Vector<AccessibleRelation>(relations.length);
+            for (int i = 0; i < relations.length; i++) {
+                add(relations[i]);
+            }
+        }
+    }
+
+    public boolean add(AccessibleRelation relation) {
+        if (relations == null) {
+            relations = new Vector<AccessibleRelation>();
+        }
+        AccessibleRelation existing = get(relation.getKey());
+        if (existing == null) {
+            relations.addElement(relation);
+            return true;
+        }
+        Object[] first = existing.getTarget();
+        Object[] second = relation.getTarget();
+        Object[] merged = new Object[first.length + second.length];
+        System.arraycopy(first, 0, merged, 0, first.length);
+        System.arraycopy(second, 0, merged, first.length, second.length);
+        existing.setTarget(merged);
+        return true;
+    }
+
+    public void addAll(AccessibleRelation[] relations) {
+        for (int i = 0; i < relations.length; i++) {
+            add(relations[i]);
+        }
+    }
+
+    public boolean remove(AccessibleRelation relation) {
+        return relations != null && relations.removeElement(relation);
+    }
+
+    public void clear() {
+        if (relations != null) {
+            relations.removeAllElements();
+        }
+    }
+
+    public int size() {
+        return relations == null ? 0 : relations.size();
+    }
+
+    public boolean contains(String key) {
+        return get(key) != null;
+    }
+
+    public AccessibleRelation get(String key) {
+        if (relations == null || key == null) {
+            return null;
+        }
+        for (int i = 0; i < relations.size(); i++) {
+            AccessibleRelation r = relations.elementAt(i);
+            if (key.equals(r.getKey())) {
+                return r;
+            }
+        }
+        return null;
+    }
+
+    public AccessibleRelation[] toArray() {
+        AccessibleRelation[] all = new AccessibleRelation[size()];
+        for (int i = 0; i < all.length; i++) {
+            all[i] = relations.elementAt(i);
+        }
+        return all;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < size(); i++) {
+            if (i > 0) {
+                sb.append(',');
+            }
+            sb.append(relations.elementAt(i).getKey());
+        }
+        return sb.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/package-info.java
new file mode 100644
index 00000000000..9f80cb0cbe7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/accessibility/package-info.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The part of `javax.accessibility` a Swing program writes to: the name
+/// and the description of a component, and its relations to others.
+///
+/// The accessible name of a component becomes the accessibility text of
+/// the Codename One widget that shows it, which is what a screen reader of
+/// the device reads. The description and the relations are kept and
+/// answered, and nothing reads them. Roles, states, actions, values and
+/// the tree of accessible children are not part of this layer.
+package com.codename1.desktopcompat.javax.accessibility;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/imageio/ImageIO.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/imageio/ImageIO.java
new file mode 100644
index 00000000000..d7444e57d47
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/imageio/ImageIO.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.imageio;
+
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.java.awt.image.RenderedImage;
+import com.codename1.desktopcompat.rt.ImageLoader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+
+/// Reads an encoded image into a [BufferedImage] and writes one out as
+/// PNG or JPEG.
+///
+/// Decoding and encoding are the device's, through Codename One's `Image`
+/// and its `ImageIO`. An image is read whole into memory, as type
+/// `TYPE_INT_ARGB`.
+///
+/// What differs from the desktop: the formats are the ones the device
+/// has, PNG and JPEG everywhere and usually nothing else to write; there
+/// are no readers, writers, streams or plugins to ask for, and no cache
+/// settings. `write` answers `false`, as it does on the desktop for a
+/// format without a writer, when the device cannot encode at all.
+public final class ImageIO {
+
+    private ImageIO() {
+    }
+
+    /// Decodes a stream, which is read to its end and left open.
+    ///
+    /// #### Returns
+    ///
+    /// the image, or `null` when the bytes are not an image the device
+    /// decodes
+    public static BufferedImage read(InputStream input) throws IOException {
+        if (input == null) {
+            throw new IllegalArgumentException("input == null!");
+        }
+        return toBuffered(ImageLoader.decode(input));
+    }
+
+    public static BufferedImage read(File input) throws IOException {
+        if (input == null) {
+            throw new IllegalArgumentException("input == null!");
+        }
+        if (!input.canRead()) {
+            throw new IOException("Can't read input file!");
+        }
+        InputStream in = new FileInputStream(input);
+        try {
+            return read(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    public static BufferedImage read(URL input) throws IOException {
+        if (input == null) {
+            throw new IllegalArgumentException("input == null!");
+        }
+        InputStream in;
+        try {
+            in = input.openStream();
+        } catch (IOException e) {
+            throw new IOException("Can't get input stream from URL!");
+        }
+        try {
+            return read(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    private static BufferedImage toBuffered(com.codename1.ui.Image decoded) {
+        if (decoded == null) {
+            return null;
+        }
+        int w = decoded.getWidth();
+        int h = decoded.getHeight();
+        int[] rgb = decoded.getRGB();
+        if (w <= 0 || h <= 0 || rgb == null || rgb.length < w * h) {
+            return null;
+        }
+        BufferedImage out = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+        out.setRGB(0, 0, w, h, rgb, 0, w);
+        return out;
+    }
+
+    /// The Codename One name of a format name, or `null` for one it does
+    /// not write. Format names are ASCII and compared without case.
+    private static String format(String formatName) {
+        if ("png".equalsIgnoreCase(formatName)) {
+            return com.codename1.ui.util.ImageIO.FORMAT_PNG;
+        }
+        if ("jpg".equalsIgnoreCase(formatName) || "jpeg".equalsIgnoreCase(formatName)) {
+            return com.codename1.ui.util.ImageIO.FORMAT_JPEG;
+        }
+        return null;
+    }
+
+    /// Encodes an image to a stream, which is left open.
+    ///
+    /// #### Returns
+    ///
+    /// `false` when nothing was written: the format is not `png`, `jpg` or
+    /// `jpeg`, the device has no encoder for it, or the image is not a
+    /// [BufferedImage]
+    public static boolean write(RenderedImage im, String formatName, OutputStream output) throws IOException {
+        if (im == null) {
+            throw new IllegalArgumentException("im == null!");
+        }
+        if (formatName == null) {
+            throw new IllegalArgumentException("formatName == null!");
+        }
+        if (output == null) {
+            throw new IllegalArgumentException("output == null!");
+        }
+        String format = format(formatName);
+        com.codename1.ui.util.ImageIO io = com.codename1.ui.util.ImageIO.getImageIO();
+        if (format == null || io == null || !io.isFormatSupported(format) || !(im instanceof BufferedImage)) {
+            return false;
+        }
+        com.codename1.ui.Image pixels = ((BufferedImage) im).cn1Image();
+        if (pixels == null) {
+            return false;
+        }
+        io.save(pixels, output, format, 0.9f);
+        output.flush();
+        return true;
+    }
+
+    /// Encodes an image to a file, replacing it. Nothing is written, and
+    /// an existing file is left as it was, when the answer is `false`.
+    public static boolean write(RenderedImage im, String formatName, File output) throws IOException {
+        if (output == null) {
+            throw new IllegalArgumentException("output == null!");
+        }
+        if (im == null) {
+            throw new IllegalArgumentException("im == null!");
+        }
+        if (formatName == null) {
+            throw new IllegalArgumentException("formatName == null!");
+        }
+        String format = format(formatName);
+        com.codename1.ui.util.ImageIO io = com.codename1.ui.util.ImageIO.getImageIO();
+        if (format == null || io == null || !io.isFormatSupported(format) || !(im instanceof BufferedImage)) {
+            return false;
+        }
+        OutputStream out = new FileOutputStream(output);
+        try {
+            return write(im, formatName, out);
+        } finally {
+            out.close();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/imageio/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/imageio/package-info.java
new file mode 100644
index 00000000000..20a876393fd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/imageio/package-info.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Reading and writing image files: [ImageIO] stands in for the JDK's
+/// `javax.imageio.ImageIO` once an application has been relocated onto the
+/// layer. Only the static `read` and `write` methods are here; the
+/// device's own decoder and encoder do the work.
+package com.codename1.desktopcompat.javax.imageio;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractAction.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractAction.java
new file mode 100644
index 00000000000..879cbcdee7d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractAction.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.SwingPropertyChangeSupport;
+
+import java.util.HashMap;
+
+/// A base for `Action` implementations that keeps the property map, the
+/// enabled state and the property change listeners.
+///
+/// Changing a property or the enabled state fires a property change event
+/// named after the key (`"enabled"` for the enabled state). `clone()` of the
+/// JDK class is not provided, because cloning does not work on the device.
+public abstract class AbstractAction implements Action {
+
+    /// Whether the action is enabled.
+    protected boolean enabled = true;
+
+    /// The listeners of the action, created on demand.
+    protected SwingPropertyChangeSupport changeSupport;
+
+    private final HashMap<String, Object> values = new HashMap<String, Object>();
+
+    public AbstractAction() {
+    }
+
+    public AbstractAction(String name) {
+        putValue(Action.NAME, name);
+    }
+
+    public AbstractAction(String name, Icon icon) {
+        this(name);
+        putValue(Action.SMALL_ICON, icon);
+    }
+
+    public Object getValue(String key) {
+        return values.get(key);
+    }
+
+    public void putValue(String key, Object newValue) {
+        Object oldValue = values.get(key);
+        if (newValue == null) {
+            values.remove(key);
+        } else {
+            values.put(key, newValue);
+        }
+        firePropertyChange(key, oldValue, newValue);
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean newValue) {
+        boolean oldValue = enabled;
+        if (oldValue != newValue) {
+            enabled = newValue;
+            firePropertyChange("enabled", Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
+        }
+    }
+
+    /// The keys with a value, or `null` when there are none.
+    public Object[] getKeys() {
+        if (values.isEmpty()) {
+            return null;
+        }
+        return values.keySet().toArray();
+    }
+
+    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        if (changeSupport == null || oldValue != null && newValue != null && oldValue.equals(newValue)) {
+            return;
+        }
+        changeSupport.firePropertyChange(propertyName, oldValue, newValue);
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport == null) {
+            changeSupport = new SwingPropertyChangeSupport(this);
+        }
+        changeSupport.addPropertyChangeListener(listener);
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport == null) {
+            return;
+        }
+        changeSupport.removePropertyChangeListener(listener);
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners() {
+        if (changeSupport == null) {
+            return new PropertyChangeListener[0];
+        }
+        return changeSupport.getPropertyChangeListeners();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractButton.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractButton.java
new file mode 100644
index 00000000000..e00384af5a3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractButton.java
@@ -0,0 +1,858 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.ItemSelectable;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.Align;
+import com.codename1.desktopcompat.rt.ButtonPeer;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.Icons;
+import com.codename1.desktopcompat.rt.MiniHtml;
+import com.codename1.desktopcompat.rt.Peer;
+import com.codename1.desktopcompat.rt.Units;
+
+/// The base of the buttons: text, icon, a button model and the action,
+/// item and change listeners.
+///
+/// The peer is a Codename One button of some kind. A click on it runs
+/// `doClick()`, which drives the model exactly as a mouse click drives it
+/// on the desktop, so listeners see the same events in the same order.
+///
+/// The pressed, disabled, rollover and selected icons, the alignment, the
+/// text position, the gap between icon and text and the margin are pushed
+/// to the Codename One button, each once the application sets it; until
+/// then the theme decides. Codename One places text on one of the four
+/// sides of the icon, so text centered over the icon is placed after it.
+/// A button that does not paint its border or fill its content area loses
+/// the theme's border and background. HTML text is shown without its
+/// tags, on one line. The mnemonic is recorded only, and components added
+/// to a button are not shown.
+public abstract class AbstractButton extends JComponent implements ItemSelectable, SwingConstants {
+
+    protected ButtonModel model;
+    protected ChangeEvent changeEvent;
+
+    private final Handler handler = new Handler();
+    private String text = "";
+    private Icon icon;
+    private Insets margin;
+    private Action action;
+    private int mnemonic;
+    private int horizontalAlignment = CENTER;
+    private int verticalAlignment = CENTER;
+    private int horizontalTextPosition = TRAILING;
+    private int verticalTextPosition = CENTER;
+    private boolean borderPainted = true;
+    private MiniHtml.Document html;
+    private boolean focusPainted = true;
+    private boolean contentAreaFilled = true;
+    private boolean rolloverEnabled;
+    private Icon pressedIcon;
+    private Icon selectedIcon;
+    private Icon disabledIcon;
+    private Icon disabledSelectedIcon;
+    private Icon rolloverIcon;
+    private Icon rolloverSelectedIcon;
+    private int iconTextGap = 4;
+    private boolean iconTextGapSet;
+    private boolean horizontalAlignmentSet;
+    private boolean verticalAlignmentSet;
+    private boolean textPositionSet;
+    private int displayedMnemonicIndex = -1;
+    private boolean hideActionText;
+    private boolean restyled;
+    private int styleSignature;
+    private final Icon[] iconKeys = new Icon[5];
+    private final com.codename1.ui.Image[] iconImages = new com.codename1.ui.Image[5];
+
+    public AbstractButton() {
+    }
+
+    protected void init(String text, Icon icon) {
+        if (text != null) {
+            setText(text);
+        }
+        if (icon != null) {
+            setIcon(icon);
+        }
+        setAlignmentX(LEFT_ALIGNMENT);
+        setAlignmentY(CENTER_ALIGNMENT);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.Button) {
+            ((com.codename1.ui.Button) p).addActionListener(
+                    new com.codename1.ui.events.ActionListener<com.codename1.ui.events.ActionEvent>() {
+                        @Override
+                        public void actionPerformed(com.codename1.ui.events.ActionEvent evt) {
+                            doClick();
+                        }
+                    });
+        }
+        restyle();
+        sync();
+    }
+
+    private void sync() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.Button) {
+            com.codename1.ui.Button b = (com.codename1.ui.Button) p;
+            b.setText(text == null || htmlOverlay() ? "" : MiniHtml.singleLine(text));
+            boolean selected = model != null && model.isSelected();
+            b.setIcon(nativeIcon(0, selected && selectedIcon != null ? selectedIcon : icon));
+            b.setPressedIcon(nativeIcon(1, pressedIcon));
+            b.setRolloverIcon(nativeIcon(2, selected && rolloverSelectedIcon != null ? rolloverSelectedIcon
+                    : rolloverIcon));
+            b.setDisabledIcon(nativeIcon(3, selected && disabledSelectedIcon != null ? disabledSelectedIcon
+                    : disabledIcon));
+            // A Codename One toggle shows this one while it is selected.
+            b.setRolloverPressedIcon(nativeIcon(4, selectedIcon));
+            if (horizontalAlignmentSet) {
+                com.codename1.desktopcompat.rt.PeerSupport.allStyles(b).setAlignment(Align.horizontal(horizontalAlignment));
+            }
+            if (verticalAlignmentSet) {
+                b.setVerticalAlignment(Align.vertical(verticalAlignment));
+            }
+            if (textPositionSet) {
+                b.setTextPosition(Align.textPosition(horizontalTextPosition, verticalTextPosition));
+            }
+            if (iconTextGapSet) {
+                b.setGap(Units.toDevice(iconTextGap));
+            }
+            if (p instanceof com.codename1.ui.CheckBox) {
+                ((com.codename1.ui.CheckBox) p).setSelected(selected);
+            } else if (p instanceof com.codename1.ui.RadioButton) {
+                ((com.codename1.ui.RadioButton) p).setSelected(selected);
+            }
+        }
+    }
+
+    /// The image of an icon, converted once for as long as the icon in
+    /// that slot stays the same.
+    private com.codename1.ui.Image nativeIcon(int slot, Icon i) {
+        if (i == null) {
+            iconKeys[slot] = null;
+            iconImages[slot] = null;
+            return null;
+        }
+        if (iconKeys[slot] != i || iconImages[slot] == null) {
+            iconKeys[slot] = i;
+            iconImages[slot] = Icons.toNative(i, this);
+        }
+        return iconImages[slot];
+    }
+
+    /// Pushes the margin and the border and content area switches to the
+    /// peer's styles, starting from the theme's whenever one was undone.
+    private void restyle() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!(p instanceof com.codename1.ui.Button)) {
+            return;
+        }
+        com.codename1.ui.Button b = (com.codename1.ui.Button) p;
+        boolean checkMark = (p instanceof com.codename1.ui.CheckBox || p instanceof com.codename1.ui.RadioButton)
+                && !b.isToggle();
+        boolean plain = !checkMark && cn1Plain();
+        boolean inBar = getParent() instanceof JToolBar;
+        boolean outline = plain && borderPainted && !inBar;
+        boolean noBorder = (!borderPainted || plain) && !checkMark;
+        boolean noFill = (!contentAreaFilled || plain) && !checkMark;
+        int signature = (margin == null ? 0 : 1 + margin.top * 31 + margin.left * 961 + margin.bottom * 29791
+                + margin.right * 923521) * 16 + (noBorder ? 1 : 0) + (noFill ? 2 : 0) + (plain ? 4 : 0)
+                + (outline ? 8 : 0);
+        if (signature == styleSignature && (restyled || signature == 0)) {
+            return;
+        }
+        styleSignature = signature;
+        if (restyled) {
+            b.setUIID(b.getUIID());
+            if (p instanceof Peer) {
+                ((Peer) p).support().applyStyle();
+            }
+        }
+        restyled = signature != 0;
+        if (p instanceof ButtonPeer) {
+            ((ButtonPeer) p).setPlain(plain);
+        }
+        if (!restyled) {
+            return;
+        }
+        com.codename1.ui.plaf.Style s = com.codename1.desktopcompat.rt.PeerSupport.allStyles(b);
+        int line = outline ? Math.max(1, Units.toDevice(1)) : 0;
+        if (margin != null || plain) {
+            // A button that is only its icon keeps the two pixels the
+            // icon needs to stand clear of a neighbour.
+            int t = margin == null ? 2 : margin.top;
+            int l = margin == null ? 2 : margin.left;
+            int bt = margin == null ? 2 : margin.bottom;
+            int r = margin == null ? 2 : margin.right;
+            int extra = plain ? line + Math.max(1, Units.toDevice(1)) : 0;
+            byte px = com.codename1.ui.plaf.Style.UNIT_TYPE_PIXELS;
+            s.setPaddingUnit(px, px, px, px);
+            s.setPadding(Units.toDevice(t) + extra, Units.toDevice(bt) + extra, Units.toDevice(l) + extra,
+                    Units.toDevice(r) + extra);
+        }
+        com.codename1.ui.plaf.Border border = b.getUnselectedStyle().getBorder();
+        if (outline) {
+            s.setBorder(com.codename1.ui.plaf.Border.createLineBorder(line,
+                    CellTheme.grid(null).getRGB() & 0xffffff));
+        } else if (noBorder || (noFill && border != null && border.isBackgroundPainter())) {
+            s.setBorder(com.codename1.ui.plaf.Border.createEmpty());
+        }
+        if (noFill) {
+            s.setBgTransparency(0);
+        }
+    }
+
+    /// Whether the button is drawn without the theme's button shape: one
+    /// that shows only an icon, and any button of a tool bar.
+    ///
+    /// A theme sizes and shapes its button for a caption -- a pill, or a
+    /// circle when the button is as wide as it is high -- and an icon put
+    /// in that shape is cut by it or spills out of it. A desktop look and
+    /// feel draws such a button as the icon in a thin rectangle, and a
+    /// tool bar button as the icon alone.
+    private boolean cn1Plain() {
+        Object o = this;
+        if (o instanceof JMenuItem) {
+            return false;
+        }
+        boolean iconOnly = icon != null && (text == null || text.length() == 0);
+        return iconOnly || getParent() instanceof JToolBar;
+    }
+
+    /// The shape of a button depends on where it is, which is known when
+    /// it is added.
+    @Override
+    public void addNotify() {
+        super.addNotify();
+        restyle();
+    }
+
+    private void changed() {
+        html = null;
+        restyle();
+        sync();
+        revalidate();
+        repaint();
+    }
+
+    // ------------------------------------------------------------ html
+
+    /// Whether the text is HTML that is drawn here, over the native
+    /// button, with its colors, sizes and styles: for a button without an
+    /// icon that is not a check box or radio button. The others show the
+    /// text of the HTML on one line, in the widget's own style, because
+    /// only the widget knows where it puts text beside a mark or an icon.
+    private boolean htmlOverlay() {
+        if (!MiniHtml.isHtml(text) || icon != null) {
+            return false;
+        }
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!(p instanceof com.codename1.ui.Button)) {
+            return false;
+        }
+        boolean mark = p instanceof com.codename1.ui.CheckBox || p instanceof com.codename1.ui.RadioButton;
+        return !mark || ((com.codename1.ui.Button) p).isToggle();
+    }
+
+    private MiniHtml.Document htmlDocument() {
+        if (html == null) {
+            html = MiniHtml.parse(text);
+        }
+        return html;
+    }
+
+    /// The font HTML text starts from: the one that was set, else the
+    /// font the theme gives the button.
+    private com.codename1.desktopcompat.java.awt.Font htmlFont() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!isFontSet() && p != null && p.getStyle().getFont() != null) {
+            return com.codename1.desktopcompat.rt.Fonts.fromNative(p.getStyle().getFont());
+        }
+        return getFont();
+    }
+
+    @Override
+    protected Dimension cn1NativePreferredSize() {
+        Dimension d = super.cn1NativePreferredSize();
+        if (d == null || !htmlOverlay()) {
+            return d;
+        }
+        com.codename1.ui.plaf.Style st = cn1Peer().getStyle();
+        Dimension t = MiniHtml.preferredSize(htmlDocument(), htmlFont());
+        int padV = Units.toLogicalCeil(st.getPaddingTop()) + Units.toLogicalCeil(st.getPaddingBottom());
+        return new Dimension(d.width + t.width, Math.max(d.height, t.height + padV));
+    }
+
+    /// The preferred size, except that a button whose text is HTML can
+    /// grow as wide as it is let. That is the desktop's doing -- the size
+    /// the view of an HTML text can take has no limit -- and layouts that
+    /// hand out spare room by maximum size, a box among them, give it to
+    /// such a button. The limit is the largest `int` and not the largest
+    /// `short` that glue has, so beside glue the button takes all of it.
+    @Override
+    public Dimension getMaximumSize() {
+        Dimension d = super.getMaximumSize();
+        if (!isMaximumSizeSet() && MiniHtml.isHtml(text) && d != null) {
+            return new Dimension(Integer.MAX_VALUE, d.height);
+        }
+        return d;
+    }
+
+    @Override
+    protected void paintComponent(com.codename1.desktopcompat.java.awt.Graphics g) {
+        super.paintComponent(g);
+        if (!htmlOverlay()) {
+            return;
+        }
+        com.codename1.ui.plaf.Style st = cn1Peer().getStyle();
+        int left = Units.toLogicalCeil(st.getPaddingLeftNoRTL());
+        int right = Units.toLogicalCeil(st.getPaddingRightNoRTL());
+        int top = Units.toLogicalCeil(st.getPaddingTop());
+        int bottom = Units.toLogicalCeil(st.getPaddingBottom());
+        com.codename1.desktopcompat.java.awt.Font f = htmlFont();
+        MiniHtml.Document doc = htmlDocument();
+        Dimension t = MiniHtml.preferredSize(doc, f);
+        int availW = Math.max(0, getWidth() - left - right);
+        int availH = Math.max(0, getHeight() - top - bottom);
+        int align = horizontalAlignmentSet ? horizontalAlignment : CENTER;
+        int x = left;
+        int lineAlign = MiniHtml.ALIGN_LEFT;
+        if (align == CENTER) {
+            x += (availW - t.width) / 2;
+            lineAlign = MiniHtml.ALIGN_CENTER;
+        } else if (align == RIGHT || align == TRAILING) {
+            x += availW - t.width;
+            lineAlign = MiniHtml.ALIGN_RIGHT;
+        }
+        int y = top + (availH - t.height) / 2;
+        g.setFont(f);
+        com.codename1.desktopcompat.java.awt.Color fg = isForegroundSet() ? getForeground()
+                : new com.codename1.desktopcompat.java.awt.Color(st.getFgColor() & 0xffffff);
+        if (!isEnabled()) {
+            fg = com.codename1.desktopcompat.java.awt.Color.GRAY;
+        }
+        g.setColor(fg);
+        MiniHtml.paint(g, doc, x, y, t.width, lineAlign);
+    }
+
+    private void styleChanged() {
+        restyle();
+        sync();
+        revalidate();
+        repaint();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        String old = this.text;
+        this.text = text;
+        firePropertyChange("text", old, text);
+        if (old == null ? text != null : !old.equals(text)) {
+            changed();
+        }
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    public void setIcon(Icon defaultIcon) {
+        Icon old = icon;
+        icon = defaultIcon;
+        firePropertyChange("icon", old, defaultIcon);
+        if (old != defaultIcon) {
+            changed();
+        }
+    }
+
+    public ButtonModel getModel() {
+        return model;
+    }
+
+    public void setModel(ButtonModel newModel) {
+        ButtonModel old = model;
+        if (old != null) {
+            old.removeChangeListener(handler);
+            old.removeActionListener(handler);
+            old.removeItemListener(handler);
+        }
+        model = newModel;
+        if (newModel != null) {
+            newModel.addChangeListener(handler);
+            newModel.addActionListener(handler);
+            newModel.addItemListener(handler);
+        }
+        firePropertyChange("model", old, newModel);
+        if (newModel != old) {
+            changed();
+        }
+    }
+
+    public boolean isSelected() {
+        return model.isSelected();
+    }
+
+    public void setSelected(boolean b) {
+        model.setSelected(b);
+    }
+
+    /// Clicks the button: arms and presses the model, then releases it,
+    /// which notifies the action listeners.
+    public void doClick() {
+        doClick(68);
+    }
+
+    /// As `doClick()`; the button is not shown pressed for `pressTime`.
+    public void doClick(int pressTime) {
+        model.setArmed(true);
+        model.setPressed(true);
+        model.setPressed(false);
+        model.setArmed(false);
+    }
+
+    @Override
+    public void setEnabled(boolean b) {
+        super.setEnabled(b);
+        model.setEnabled(b);
+    }
+
+    public String getActionCommand() {
+        String ac = model.getActionCommand();
+        return ac == null ? getText() : ac;
+    }
+
+    public void setActionCommand(String actionCommand) {
+        model.setActionCommand(actionCommand);
+    }
+
+    public Action getAction() {
+        return action;
+    }
+
+    /// Takes the action's name as the text, its enabled state, and makes
+    /// it an action listener. Later changes of the action's properties are
+    /// not followed.
+    public void setAction(Action a) {
+        Action old = action;
+        if (old == a) {
+            return;
+        }
+        if (old != null) {
+            removeActionListener(old);
+        }
+        action = a;
+        if (a != null) {
+            Object name = a.getValue(Action.NAME);
+            if (name instanceof String) {
+                setText((String) name);
+            }
+            Object cmd = a.getValue(Action.ACTION_COMMAND_KEY);
+            if (cmd instanceof String) {
+                setActionCommand((String) cmd);
+            }
+            setEnabled(a.isEnabled());
+            addActionListener(a);
+        }
+        firePropertyChange("action", old, a);
+    }
+
+    public void addActionListener(ActionListener l) {
+        listenerList.add(ActionListener.class, l);
+    }
+
+    public void removeActionListener(ActionListener l) {
+        listenerList.remove(ActionListener.class, l);
+    }
+
+    public ActionListener[] getActionListeners() {
+        return listenerList.getListeners(ActionListener.class);
+    }
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    @Override
+    public void addItemListener(ItemListener l) {
+        listenerList.add(ItemListener.class, l);
+    }
+
+    @Override
+    public void removeItemListener(ItemListener l) {
+        listenerList.remove(ItemListener.class, l);
+    }
+
+    public ItemListener[] getItemListeners() {
+        return listenerList.getListeners(ItemListener.class);
+    }
+
+    @Override
+    public Object[] getSelectedObjects() {
+        if (!isSelected()) {
+            return null;
+        }
+        return new Object[]{getText()};
+    }
+
+    protected void fireActionPerformed(ActionEvent event) {
+        ActionListener[] ls = getActionListeners();
+        ActionEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                String cmd = event.getActionCommand();
+                e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, cmd == null ? getActionCommand() : cmd,
+                        event.getWhen(), event.getModifiers());
+            }
+            ls[i].actionPerformed(e);
+        }
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    protected void fireItemStateChanged(ItemEvent event) {
+        ItemListener[] ls = getItemListeners();
+        ItemEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, this, event.getStateChange());
+            }
+            ls[i].itemStateChanged(e);
+        }
+    }
+
+    public int getMnemonic() {
+        return mnemonic;
+    }
+
+    public void setMnemonic(int mnemonic) {
+        this.mnemonic = mnemonic;
+        model.setMnemonic(mnemonic);
+    }
+
+    public void setMnemonic(char mnemonic) {
+        int vk = mnemonic;
+        if (vk >= 'a' && vk <= 'z') {
+            vk -= 'a' - 'A';
+        }
+        setMnemonic(vk);
+    }
+
+    public Insets getMargin() {
+        return margin == null ? null : new Insets(margin.top, margin.left, margin.bottom, margin.right);
+    }
+
+    public void setMargin(Insets m) {
+        Insets old = margin;
+        margin = m == null ? null : new Insets(m.top, m.left, m.bottom, m.right);
+        firePropertyChange("margin", old, margin);
+        if (old == null ? margin != null : !old.equals(margin)) {
+            styleChanged();
+        }
+    }
+
+    public boolean isBorderPainted() {
+        return borderPainted;
+    }
+
+    public void setBorderPainted(boolean b) {
+        boolean old = borderPainted;
+        borderPainted = b;
+        firePropertyChange("borderPainted", old, b);
+        if (old != b) {
+            styleChanged();
+        }
+    }
+
+    public boolean isFocusPainted() {
+        return focusPainted;
+    }
+
+    public void setFocusPainted(boolean b) {
+        focusPainted = b;
+    }
+
+    public boolean isContentAreaFilled() {
+        return contentAreaFilled;
+    }
+
+    public void setContentAreaFilled(boolean b) {
+        boolean old = contentAreaFilled;
+        contentAreaFilled = b;
+        firePropertyChange("contentAreaFilled", old, b);
+        if (old != b) {
+            styleChanged();
+        }
+    }
+
+    public boolean isRolloverEnabled() {
+        return rolloverEnabled;
+    }
+
+    public void setRolloverEnabled(boolean b) {
+        rolloverEnabled = b;
+    }
+
+    public int getHorizontalAlignment() {
+        return horizontalAlignment;
+    }
+
+    public void setHorizontalAlignment(int alignment) {
+        if (alignment != LEFT && alignment != CENTER && alignment != RIGHT && alignment != LEADING && alignment != TRAILING) {
+            throw new IllegalArgumentException("horizontalAlignment");
+        }
+        int old = horizontalAlignment;
+        horizontalAlignment = alignment;
+        horizontalAlignmentSet = true;
+        firePropertyChange("horizontalAlignment", old, alignment);
+        changed();
+    }
+
+    public int getVerticalAlignment() {
+        return verticalAlignment;
+    }
+
+    public void setVerticalAlignment(int alignment) {
+        if (alignment != TOP && alignment != CENTER && alignment != BOTTOM) {
+            throw new IllegalArgumentException("verticalAlignment");
+        }
+        int old = verticalAlignment;
+        verticalAlignment = alignment;
+        verticalAlignmentSet = true;
+        firePropertyChange("verticalAlignment", old, alignment);
+        changed();
+    }
+
+    public int getHorizontalTextPosition() {
+        return horizontalTextPosition;
+    }
+
+    public void setHorizontalTextPosition(int textPosition) {
+        if (textPosition != LEFT && textPosition != CENTER && textPosition != RIGHT && textPosition != LEADING && textPosition != TRAILING) {
+            throw new IllegalArgumentException("horizontalTextPosition");
+        }
+        int old = horizontalTextPosition;
+        horizontalTextPosition = textPosition;
+        textPositionSet = true;
+        firePropertyChange("horizontalTextPosition", old, textPosition);
+        changed();
+    }
+
+    public int getVerticalTextPosition() {
+        return verticalTextPosition;
+    }
+
+    public void setVerticalTextPosition(int textPosition) {
+        if (textPosition != TOP && textPosition != CENTER && textPosition != BOTTOM) {
+            throw new IllegalArgumentException("verticalTextPosition");
+        }
+        int old = verticalTextPosition;
+        verticalTextPosition = textPosition;
+        textPositionSet = true;
+        firePropertyChange("verticalTextPosition", old, textPosition);
+        changed();
+    }
+
+    public Icon getPressedIcon() {
+        return pressedIcon;
+    }
+
+    public void setPressedIcon(Icon pressedIcon) {
+        Icon old = this.pressedIcon;
+        this.pressedIcon = pressedIcon;
+        firePropertyChange("pressedIcon", old, pressedIcon);
+        if (old != pressedIcon) {
+            changed();
+        }
+    }
+
+    public Icon getSelectedIcon() {
+        return selectedIcon;
+    }
+
+    public void setSelectedIcon(Icon selectedIcon) {
+        Icon old = this.selectedIcon;
+        this.selectedIcon = selectedIcon;
+        firePropertyChange("selectedIcon", old, selectedIcon);
+        if (old != selectedIcon) {
+            changed();
+        }
+    }
+
+    public Icon getRolloverIcon() {
+        return rolloverIcon;
+    }
+
+    public void setRolloverIcon(Icon rolloverIcon) {
+        Icon old = this.rolloverIcon;
+        this.rolloverIcon = rolloverIcon;
+        firePropertyChange("rolloverIcon", old, rolloverIcon);
+        setRolloverEnabled(true);
+        if (old != rolloverIcon) {
+            changed();
+        }
+    }
+
+    public Icon getRolloverSelectedIcon() {
+        return rolloverSelectedIcon;
+    }
+
+    public void setRolloverSelectedIcon(Icon rolloverSelectedIcon) {
+        Icon old = this.rolloverSelectedIcon;
+        this.rolloverSelectedIcon = rolloverSelectedIcon;
+        firePropertyChange("rolloverSelectedIcon", old, rolloverSelectedIcon);
+        setRolloverEnabled(true);
+        if (old != rolloverSelectedIcon) {
+            changed();
+        }
+    }
+
+    /// The icon set with `setDisabledIcon`, or `null`: none is made from
+    /// the default icon, the Codename One button dims it.
+    public Icon getDisabledIcon() {
+        return disabledIcon;
+    }
+
+    public void setDisabledIcon(Icon disabledIcon) {
+        Icon old = this.disabledIcon;
+        this.disabledIcon = disabledIcon;
+        firePropertyChange("disabledIcon", old, disabledIcon);
+        if (old != disabledIcon) {
+            changed();
+        }
+    }
+
+    public Icon getDisabledSelectedIcon() {
+        return disabledSelectedIcon;
+    }
+
+    public void setDisabledSelectedIcon(Icon disabledSelectedIcon) {
+        Icon old = this.disabledSelectedIcon;
+        this.disabledSelectedIcon = disabledSelectedIcon;
+        firePropertyChange("disabledSelectedIcon", old, disabledSelectedIcon);
+        if (old != disabledSelectedIcon) {
+            changed();
+        }
+    }
+
+    public int getIconTextGap() {
+        return iconTextGap;
+    }
+
+    public void setIconTextGap(int iconTextGap) {
+        int old = this.iconTextGap;
+        this.iconTextGap = iconTextGap;
+        iconTextGapSet = true;
+        firePropertyChange("iconTextGap", old, iconTextGap);
+        if (old != iconTextGap) {
+            changed();
+        }
+    }
+
+    public int getDisplayedMnemonicIndex() {
+        return displayedMnemonicIndex;
+    }
+
+    /// Recorded only: no character is underlined.
+    public void setDisplayedMnemonicIndex(int index) {
+        int old = displayedMnemonicIndex;
+        if (index == -1) {
+            displayedMnemonicIndex = -1;
+        } else {
+            int length = text == null ? 0 : text.length();
+            if (index < -1 || index >= length) {
+                throw new IllegalArgumentException("index == " + index);
+            }
+            displayedMnemonicIndex = index;
+        }
+        firePropertyChange("displayedMnemonicIndex", old, index);
+    }
+
+    public boolean getHideActionText() {
+        return hideActionText;
+    }
+
+    /// Recorded only: `setAction` takes the action's name either way.
+    public void setHideActionText(boolean hideActionText) {
+        boolean old = this.hideActionText;
+        this.hideActionText = hideActionText;
+        firePropertyChange("hideActionText", old, hideActionText);
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",text=" + text;
+    }
+
+    /// Forwards the model's events as this button's.
+    private final class Handler implements ChangeListener, ActionListener, ItemListener {
+
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            sync();
+            fireStateChanged();
+            repaint();
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            fireActionPerformed(e);
+        }
+
+        @Override
+        public void itemStateChanged(ItemEvent e) {
+            fireItemStateChanged(e);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractCellEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractCellEditor.java
new file mode 100644
index 00000000000..44a05ca0db1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractCellEditor.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.CellEditorListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.EventObject;
+
+/// A cell editor with the listeners done: a subclass supplies the value.
+public abstract class AbstractCellEditor implements CellEditor {
+
+    protected EventListenerList listenerList = new EventListenerList();
+    protected transient ChangeEvent changeEvent;
+
+    public AbstractCellEditor() {
+    }
+
+    @Override
+    public boolean isCellEditable(EventObject e) {
+        return true;
+    }
+
+    @Override
+    public boolean shouldSelectCell(EventObject anEvent) {
+        return true;
+    }
+
+    @Override
+    public boolean stopCellEditing() {
+        fireEditingStopped();
+        return true;
+    }
+
+    @Override
+    public void cancelCellEditing() {
+        fireEditingCanceled();
+    }
+
+    @Override
+    public void addCellEditorListener(CellEditorListener l) {
+        listenerList.add(CellEditorListener.class, l);
+    }
+
+    @Override
+    public void removeCellEditorListener(CellEditorListener l) {
+        listenerList.remove(CellEditorListener.class, l);
+    }
+
+    public CellEditorListener[] getCellEditorListeners() {
+        return listenerList.getListeners(CellEditorListener.class);
+    }
+
+    protected void fireEditingStopped() {
+        CellEditorListener[] ls = getCellEditorListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].editingStopped(changeEvent);
+        }
+    }
+
+    protected void fireEditingCanceled() {
+        CellEditorListener[] ls = getCellEditorListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].editingCanceled(changeEvent);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractListModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractListModel.java
new file mode 100644
index 00000000000..de025a23b36
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractListModel.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ListDataEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListDataListener;
+import java.util.ArrayList;
+
+/// The listener half of a list model; a subclass supplies the elements and
+/// calls the `fire` methods after it changed them.
+public abstract class AbstractListModel<E> implements ListModel<E> {
+
+    private final ArrayList<ListDataListener> listeners = new ArrayList<ListDataListener>();
+
+    public AbstractListModel() {
+    }
+
+    @Override
+    public void addListDataListener(ListDataListener l) {
+        if (l != null) {
+            listeners.add(l);
+        }
+    }
+
+    @Override
+    public void removeListDataListener(ListDataListener l) {
+        // The most recently added registration goes first, as on the desktop.
+        int i = listeners.lastIndexOf(l);
+        if (i >= 0) {
+            listeners.remove(i);
+        }
+    }
+
+    public ListDataListener[] getListDataListeners() {
+        return listeners.toArray(new ListDataListener[listeners.size()]);
+    }
+
+    private void fire(Object source, int type, int index0, int index1) {
+        if (listeners.isEmpty()) {
+            return;
+        }
+        ListDataEvent e = new ListDataEvent(source, type, index0, index1);
+        ListDataListener[] all = getListDataListeners();
+        // Last registered first: the order desktop listeners are called in.
+        for (int i = all.length - 1; i >= 0; i--) {
+            if (type == ListDataEvent.CONTENTS_CHANGED) {
+                all[i].contentsChanged(e);
+            } else if (type == ListDataEvent.INTERVAL_ADDED) {
+                all[i].intervalAdded(e);
+            } else {
+                all[i].intervalRemoved(e);
+            }
+        }
+    }
+
+    protected void fireContentsChanged(Object source, int index0, int index1) {
+        fire(source, ListDataEvent.CONTENTS_CHANGED, index0, index1);
+    }
+
+    protected void fireIntervalAdded(Object source, int index0, int index1) {
+        fire(source, ListDataEvent.INTERVAL_ADDED, index0, index1);
+    }
+
+    protected void fireIntervalRemoved(Object source, int index0, int index1) {
+        fire(source, ListDataEvent.INTERVAL_REMOVED, index0, index1);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractSpinnerModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractSpinnerModel.java
new file mode 100644
index 00000000000..6ba78bbe3c1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/AbstractSpinnerModel.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.EventListener;
+
+/// The change listeners of a spinner model; a subclass supplies the
+/// sequence and calls `fireStateChanged` when its value changes.
+public abstract class AbstractSpinnerModel implements SpinnerModel {
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private ChangeEvent changeEvent;
+
+    public AbstractSpinnerModel() {
+    }
+
+    @Override
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    @Override
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Action.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Action.java
new file mode 100644
index 00000000000..1dab2306333
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Action.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+
+/// An `ActionListener` that also carries named properties and an enabled
+/// state, so that one action can drive several buttons and menu items.
+public interface Action extends ActionListener {
+
+    String DEFAULT = "Default";
+
+    String NAME = "Name";
+
+    String SHORT_DESCRIPTION = "ShortDescription";
+
+    String LONG_DESCRIPTION = "LongDescription";
+
+    String SMALL_ICON = "SmallIcon";
+
+    String ACTION_COMMAND_KEY = "ActionCommandKey";
+
+    String ACCELERATOR_KEY = "AcceleratorKey";
+
+    String MNEMONIC_KEY = "MnemonicKey";
+
+    String SELECTED_KEY = "SwingSelectedKey";
+
+    String DISPLAYED_MNEMONIC_INDEX_KEY = "SwingDisplayedMnemonicIndexKey";
+
+    String LARGE_ICON_KEY = "SwingLargeIconKey";
+
+    Object getValue(String key);
+
+    void putValue(String key, Object value);
+
+    void setEnabled(boolean b);
+
+    boolean isEnabled();
+
+    void addPropertyChangeListener(PropertyChangeListener listener);
+
+    void removePropertyChangeListener(PropertyChangeListener listener);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ActionMap.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ActionMap.java
new file mode 100644
index 00000000000..23b951e29cd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ActionMap.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// Maps the names an input map answers to actions, with a parent that is
+/// asked for the names this map does not hold.
+public class ActionMap {
+
+    private HashMap<Object, Action> table;
+    private ActionMap parent;
+
+    public ActionMap() {
+    }
+
+    public void setParent(ActionMap map) {
+        parent = map;
+    }
+
+    public ActionMap getParent() {
+        return parent;
+    }
+
+    /// Binds the name to the action; a `null` action removes the binding.
+    public void put(Object key, Action action) {
+        if (key == null) {
+            return;
+        }
+        if (action == null) {
+            remove(key);
+            return;
+        }
+        if (table == null) {
+            table = new HashMap<Object, Action>();
+        }
+        table.put(key, action);
+    }
+
+    public Action get(Object key) {
+        Action v = table == null ? null : table.get(key);
+        if (v == null && parent != null) {
+            return parent.get(key);
+        }
+        return v;
+    }
+
+    public void remove(Object key) {
+        if (table != null) {
+            table.remove(key);
+        }
+    }
+
+    public void clear() {
+        if (table != null) {
+            table.clear();
+        }
+    }
+
+    /// The names bound in this map itself, or `null` when there are none.
+    public Object[] keys() {
+        if (table == null || table.isEmpty()) {
+            return null;
+        }
+        return table.keySet().toArray();
+    }
+
+    public int size() {
+        return table == null ? 0 : table.size();
+    }
+
+    /// The names bound in this map and its parents, or `null` when there
+    /// are none.
+    public Object[] allKeys() {
+        ArrayList<Object> all = new ArrayList<Object>();
+        for (ActionMap m = this; m != null; m = m.parent) {
+            Object[] ks = m.keys();
+            if (ks != null) {
+                for (int i = 0; i < ks.length; i++) {
+                    if (!all.contains(ks[i])) {
+                        all.add(ks[i]);
+                    }
+                }
+            }
+        }
+        return all.isEmpty() ? null : all.toArray();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BorderFactory.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BorderFactory.java
new file mode 100644
index 00000000000..095375ee752
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BorderFactory.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.border.BevelBorder;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.border.CompoundBorder;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+import com.codename1.desktopcompat.javax.swing.border.EtchedBorder;
+import com.codename1.desktopcompat.javax.swing.border.LineBorder;
+import com.codename1.desktopcompat.javax.swing.border.MatteBorder;
+import com.codename1.desktopcompat.javax.swing.border.TitledBorder;
+
+/// Factory methods for the standard borders.
+///
+/// The soft bevel, stroke and dashed borders are not provided.
+public class BorderFactory {
+
+    private static final Border EMPTY = new EmptyBorder(0, 0, 0, 0);
+    private static final Border RAISED_BEVEL = new BevelBorder(BevelBorder.RAISED);
+    private static final Border LOWERED_BEVEL = new BevelBorder(BevelBorder.LOWERED);
+    private static final Border ETCHED = new EtchedBorder();
+
+    private BorderFactory() {
+    }
+
+    public static Border createLineBorder(Color color) {
+        return new LineBorder(color, 1);
+    }
+
+    public static Border createLineBorder(Color color, int thickness) {
+        return new LineBorder(color, thickness);
+    }
+
+    public static Border createLineBorder(Color color, int thickness, boolean rounded) {
+        return new LineBorder(color, thickness, rounded);
+    }
+
+    public static Border createRaisedBevelBorder() {
+        return RAISED_BEVEL;
+    }
+
+    public static Border createLoweredBevelBorder() {
+        return LOWERED_BEVEL;
+    }
+
+    public static Border createBevelBorder(int type) {
+        if (type == BevelBorder.RAISED) {
+            return RAISED_BEVEL;
+        }
+        if (type == BevelBorder.LOWERED) {
+            return LOWERED_BEVEL;
+        }
+        return null;
+    }
+
+    public static Border createBevelBorder(int type, Color highlight, Color shadow) {
+        return new BevelBorder(type, highlight, shadow);
+    }
+
+    public static Border createBevelBorder(int type, Color highlightOuter, Color highlightInner, Color shadowOuter,
+            Color shadowInner) {
+        return new BevelBorder(type, highlightOuter, highlightInner, shadowOuter, shadowInner);
+    }
+
+    public static Border createEtchedBorder() {
+        return ETCHED;
+    }
+
+    public static Border createEtchedBorder(Color highlight, Color shadow) {
+        return new EtchedBorder(highlight, shadow);
+    }
+
+    public static Border createEtchedBorder(int type) {
+        if (type != EtchedBorder.RAISED && type != EtchedBorder.LOWERED) {
+            throw new IllegalArgumentException("type must be one of EtchedBorder.RAISED or EtchedBorder.LOWERED");
+        }
+        return type == EtchedBorder.LOWERED ? ETCHED : new EtchedBorder(EtchedBorder.RAISED);
+    }
+
+    public static Border createEtchedBorder(int type, Color highlight, Color shadow) {
+        return new EtchedBorder(type, highlight, shadow);
+    }
+
+    public static TitledBorder createTitledBorder(String title) {
+        return new TitledBorder(title);
+    }
+
+    public static TitledBorder createTitledBorder(Border border) {
+        return new TitledBorder(border);
+    }
+
+    public static TitledBorder createTitledBorder(Border border, String title) {
+        return new TitledBorder(border, title);
+    }
+
+    public static TitledBorder createTitledBorder(Border border, String title, int titleJustification,
+            int titlePosition) {
+        return new TitledBorder(border, title, titleJustification, titlePosition);
+    }
+
+    public static TitledBorder createTitledBorder(Border border, String title, int titleJustification,
+            int titlePosition, Font titleFont) {
+        return new TitledBorder(border, title, titleJustification, titlePosition, titleFont);
+    }
+
+    public static TitledBorder createTitledBorder(Border border, String title, int titleJustification,
+            int titlePosition, Font titleFont, Color titleColor) {
+        return new TitledBorder(border, title, titleJustification, titlePosition, titleFont, titleColor);
+    }
+
+    public static Border createEmptyBorder() {
+        return EMPTY;
+    }
+
+    public static Border createEmptyBorder(int top, int left, int bottom, int right) {
+        return new EmptyBorder(top, left, bottom, right);
+    }
+
+    public static CompoundBorder createCompoundBorder() {
+        return new CompoundBorder();
+    }
+
+    public static CompoundBorder createCompoundBorder(Border outsideBorder, Border insideBorder) {
+        return new CompoundBorder(outsideBorder, insideBorder);
+    }
+
+    public static MatteBorder createMatteBorder(int top, int left, int bottom, int right, Color color) {
+        return new MatteBorder(top, left, bottom, right, color);
+    }
+
+    public static MatteBorder createMatteBorder(int top, int left, int bottom, int right, Icon tileIcon) {
+        return new MatteBorder(top, left, bottom, right, tileIcon);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BoundedRangeModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BoundedRangeModel.java
new file mode 100644
index 00000000000..9013dca4441
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BoundedRangeModel.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// The model of a slider, a progress bar or a scroll bar: a value and an
+/// extent held inside a minimum and a maximum, so that
+/// `minimum <= value <= value + extent <= maximum`.
+public interface BoundedRangeModel {
+
+    int getMinimum();
+
+    void setMinimum(int newMinimum);
+
+    int getMaximum();
+
+    void setMaximum(int newMaximum);
+
+    int getValue();
+
+    void setValue(int newValue);
+
+    void setValueIsAdjusting(boolean b);
+
+    boolean getValueIsAdjusting();
+
+    int getExtent();
+
+    void setExtent(int newExtent);
+
+    void setRangeProperties(int value, int extent, int min, int max, boolean adjusting);
+
+    void addChangeListener(ChangeListener x);
+
+    void removeChangeListener(ChangeListener x);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Box.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Box.java
new file mode 100644
index 00000000000..f9dd0b94f8f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Box.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+
+/// A container that lays its children out with a [BoxLayout], and the
+/// factory of the invisible struts, rigid areas and glue that space them.
+public class Box extends JComponent {
+
+    public Box(int axis) {
+        super();
+        super.setLayout(new BoxLayout(this, axis));
+    }
+
+    public static Box createHorizontalBox() {
+        return new Box(BoxLayout.X_AXIS);
+    }
+
+    public static Box createVerticalBox() {
+        return new Box(BoxLayout.Y_AXIS);
+    }
+
+    public static Component createRigidArea(Dimension d) {
+        return new Filler(d, d, d);
+    }
+
+    public static Component createHorizontalStrut(int width) {
+        return new Filler(new Dimension(width, 0), new Dimension(width, 0), new Dimension(width, Short.MAX_VALUE));
+    }
+
+    public static Component createVerticalStrut(int height) {
+        return new Filler(new Dimension(0, height), new Dimension(0, height), new Dimension(Short.MAX_VALUE, height));
+    }
+
+    public static Component createGlue() {
+        return new Filler(new Dimension(0, 0), new Dimension(0, 0), new Dimension(Short.MAX_VALUE, Short.MAX_VALUE));
+    }
+
+    public static Component createHorizontalGlue() {
+        return new Filler(new Dimension(0, 0), new Dimension(0, 0), new Dimension(Short.MAX_VALUE, 0));
+    }
+
+    public static Component createVerticalGlue() {
+        return new Filler(new Dimension(0, 0), new Dimension(0, 0), new Dimension(0, Short.MAX_VALUE));
+    }
+
+    /// A box keeps the layout it was built with. The JDK throws `AWTError`
+    /// here; this throws an `IllegalArgumentException`.
+    @Override
+    public void setLayout(LayoutManager l) {
+        throw new IllegalArgumentException("Illegal request");
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (isOpaque()) {
+            Color bg = getBackground();
+            if (bg != null) {
+                g.setColor(bg);
+                g.fillRect(0, 0, getWidth(), getHeight());
+            }
+        }
+    }
+
+    /// An invisible component with fixed minimum, preferred and maximum
+    /// sizes, used to take up space in a layout.
+    public static class Filler extends JComponent {
+
+        public Filler(Dimension min, Dimension pref, Dimension max) {
+            setMinimumSize(min);
+            setPreferredSize(pref);
+            setMaximumSize(max);
+        }
+
+        public void changeShape(Dimension min, Dimension pref, Dimension max) {
+            setMinimumSize(min);
+            setPreferredSize(pref);
+            setMaximumSize(max);
+            revalidate();
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            if (isOpaque()) {
+                Color bg = getBackground();
+                if (bg != null) {
+                    g.setColor(bg);
+                    g.fillRect(0, 0, getWidth(), getHeight());
+                }
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BoxLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BoxLayout.java
new file mode 100644
index 00000000000..75a2f1f5275
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/BoxLayout.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager2;
+
+/// Places components in a single row or a single column, honouring each
+/// one's minimum, preferred and maximum size and its alignment across the
+/// row.
+///
+/// There is no component orientation in this layer: `LINE_AXIS` is the same
+/// as `X_AXIS` and `PAGE_AXIS` the same as `Y_AXIS`. Where the JDK throws
+/// `AWTError` -- an axis that is none of the four, or a layout handed a
+/// container other than its own -- this throws an `IllegalArgumentException`.
+public class BoxLayout implements LayoutManager2 {
+
+    public static final int X_AXIS = 0;
+
+    public static final int Y_AXIS = 1;
+
+    public static final int LINE_AXIS = 2;
+
+    public static final int PAGE_AXIS = 3;
+
+    private final int axis;
+    private final Container target;
+
+    public BoxLayout(Container target, int axis) {
+        if (axis != X_AXIS && axis != Y_AXIS && axis != LINE_AXIS && axis != PAGE_AXIS) {
+            throw new IllegalArgumentException("Invalid axis");
+        }
+        this.axis = axis;
+        this.target = target;
+    }
+
+    public final Container getTarget() {
+        return target;
+    }
+
+    public final int getAxis() {
+        return axis;
+    }
+
+    @Override
+    public void invalidateLayout(Container target) {
+        check(target);
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    @Override
+    public void addLayoutComponent(Component comp, Object constraints) {
+    }
+
+    private void check(Container c) {
+        if (target != c) {
+            throw new IllegalArgumentException("BoxLayout can't be shared");
+        }
+    }
+
+    private boolean horizontal() {
+        return axis == X_AXIS || axis == LINE_AXIS;
+    }
+
+    /// The requirements of every child along one axis; a hidden child asks
+    /// for nothing but keeps its alignment.
+    private SizeRequirements[] requests(boolean x) {
+        int n = target.getComponentCount();
+        SizeRequirements[] out = new SizeRequirements[n];
+        for (int i = 0; i < n; i++) {
+            Component c = target.getComponent(i);
+            if (!c.isVisible()) {
+                out[i] = new SizeRequirements(0, 0, 0, x ? c.getAlignmentX() : c.getAlignmentY());
+                continue;
+            }
+            Dimension min = c.getMinimumSize();
+            Dimension pref = c.getPreferredSize();
+            Dimension max = c.getMaximumSize();
+            out[i] = x ? new SizeRequirements(min.width, pref.width, max.width, c.getAlignmentX())
+                    : new SizeRequirements(min.height, pref.height, max.height, c.getAlignmentY());
+        }
+        return out;
+    }
+
+    private SizeRequirements total(SizeRequirements[] children, boolean x) {
+        return x == horizontal() ? SizeRequirements.getTiledSizeRequirements(children)
+                : SizeRequirements.getAlignedSizeRequirements(children);
+    }
+
+    private static int clamp(long v) {
+        return v > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) v;
+    }
+
+    private Dimension size(Container c, int which) {
+        check(c);
+        SizeRequirements xt = total(requests(true), true);
+        SizeRequirements yt = total(requests(false), false);
+        int w = which == 0 ? xt.minimum : which == 1 ? xt.preferred : xt.maximum;
+        int h = which == 0 ? yt.minimum : which == 1 ? yt.preferred : yt.maximum;
+        Insets in = c.getInsets();
+        return new Dimension(clamp((long) w + (long) in.left + (long) in.right),
+                clamp((long) h + (long) in.top + (long) in.bottom));
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container target) {
+        return size(target, 1);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container target) {
+        return size(target, 0);
+    }
+
+    @Override
+    public Dimension maximumLayoutSize(Container target) {
+        return size(target, 2);
+    }
+
+    @Override
+    public float getLayoutAlignmentX(Container target) {
+        check(target);
+        return total(requests(true), true).alignment;
+    }
+
+    @Override
+    public float getLayoutAlignmentY(Container target) {
+        check(target);
+        return total(requests(false), false).alignment;
+    }
+
+    @Override
+    public void layoutContainer(Container target) {
+        check(target);
+        int n = target.getComponentCount();
+        int[] xo = new int[n];
+        int[] xs = new int[n];
+        int[] yo = new int[n];
+        int[] ys = new int[n];
+        SizeRequirements[] xc = requests(true);
+        SizeRequirements[] yc = requests(false);
+        SizeRequirements xt = total(xc, true);
+        SizeRequirements yt = total(yc, false);
+        Insets in = target.getInsets();
+        int w = target.getWidth() - in.left - in.right;
+        int h = target.getHeight() - in.top - in.bottom;
+        if (horizontal()) {
+            SizeRequirements.calculateTiledPositions(w, xt, xc, xo, xs, true);
+            SizeRequirements.calculateAlignedPositions(h, yt, yc, yo, ys);
+        } else {
+            SizeRequirements.calculateAlignedPositions(w, xt, xc, xo, xs, true);
+            SizeRequirements.calculateTiledPositions(h, yt, yc, yo, ys);
+        }
+        for (int i = 0; i < n; i++) {
+            target.getComponent(i).setBounds(clamp((long) in.left + (long) xo[i]),
+                    clamp((long) in.top + (long) yo[i]), xs[i], ys[i]);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ButtonGroup.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ButtonGroup.java
new file mode 100644
index 00000000000..e3236fd2fba
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ButtonGroup.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/// Makes a set of buttons mutually exclusive: at most one of them is
+/// selected, and selecting another deselects it.
+///
+/// Once a button of the group is selected the group cannot be left without a
+/// selection by deselecting that button, only by `clearSelection()`.
+public class ButtonGroup {
+
+    /// The buttons in the group.
+    protected Vector<AbstractButton> buttons = new Vector<AbstractButton>();
+
+    private ButtonModel selection;
+
+    public ButtonGroup() {
+    }
+
+    public void add(AbstractButton b) {
+        if (b == null) {
+            return;
+        }
+        buttons.addElement(b);
+        if (b.isSelected()) {
+            if (selection == null) {
+                selection = b.getModel();
+            } else {
+                b.setSelected(false);
+            }
+        }
+        b.getModel().setGroup(this);
+    }
+
+    public void remove(AbstractButton b) {
+        if (b == null) {
+            return;
+        }
+        buttons.removeElement(b);
+        if (b.getModel() == selection) {
+            selection = null;
+        }
+        b.getModel().setGroup(null);
+    }
+
+    public void clearSelection() {
+        if (selection != null) {
+            ButtonModel oldSelection = selection;
+            selection = null;
+            oldSelection.setSelected(false);
+        }
+    }
+
+    public Enumeration<AbstractButton> getElements() {
+        return buttons.elements();
+    }
+
+    public ButtonModel getSelection() {
+        return selection;
+    }
+
+    public void setSelected(ButtonModel m, boolean b) {
+        if (b && m != null && m != selection) {
+            ButtonModel oldSelection = selection;
+            selection = m;
+            if (oldSelection != null) {
+                oldSelection.setSelected(false);
+            }
+            m.setSelected(true);
+        }
+    }
+
+    public boolean isSelected(ButtonModel m) {
+        return m == selection;
+    }
+
+    public int getButtonCount() {
+        return buttons.size();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ButtonModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ButtonModel.java
new file mode 100644
index 00000000000..fcd762febfb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ButtonModel.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.ItemSelectable;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// The state of a button: armed, selected, pressed, enabled and rolled over.
+public interface ButtonModel extends ItemSelectable {
+
+    boolean isArmed();
+
+    boolean isSelected();
+
+    boolean isEnabled();
+
+    boolean isPressed();
+
+    boolean isRollover();
+
+    void setArmed(boolean b);
+
+    void setSelected(boolean b);
+
+    void setEnabled(boolean b);
+
+    void setPressed(boolean b);
+
+    void setRollover(boolean b);
+
+    void setMnemonic(int key);
+
+    int getMnemonic();
+
+    void setActionCommand(String s);
+
+    String getActionCommand();
+
+    void setGroup(ButtonGroup group);
+
+    void addActionListener(ActionListener l);
+
+    void removeActionListener(ActionListener l);
+
+    void addItemListener(ItemListener l);
+
+    void removeItemListener(ItemListener l);
+
+    void addChangeListener(ChangeListener l);
+
+    void removeChangeListener(ChangeListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/CellEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/CellEditor.java
new file mode 100644
index 00000000000..743e6183d69
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/CellEditor.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.CellEditorListener;
+import java.util.EventObject;
+
+/// What a table or tree asks of the thing that edits one of its cells.
+public interface CellEditor {
+
+    Object getCellEditorValue();
+
+    boolean isCellEditable(EventObject anEvent);
+
+    boolean shouldSelectCell(EventObject anEvent);
+
+    boolean stopCellEditing();
+
+    void cancelCellEditing();
+
+    void addCellEditorListener(CellEditorListener l);
+
+    void removeCellEditorListener(CellEditorListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComboBoxEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComboBoxEditor.java
new file mode 100644
index 00000000000..b9c8ab748fe
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComboBoxEditor.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+
+/// The editor of an editable [JComboBox]: a component the user types
+/// into, and the item that text stands for.
+public interface ComboBoxEditor {
+
+    /// The component the combo box shows as its editing area.
+    Component getEditorComponent();
+
+    /// Shows an item; `null` clears the editor.
+    void setItem(Object anObject);
+
+    /// The item being edited.
+    Object getItem();
+
+    /// Selects everything in the editor.
+    void selectAll();
+
+    /// The listener hears when an edit is finished.
+    void addActionListener(ActionListener l);
+
+    void removeActionListener(ActionListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComboBoxModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComboBoxModel.java
new file mode 100644
index 00000000000..763b886e327
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComboBoxModel.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// A list model that also has one selected item, which need not be one of
+/// its elements.
+public interface ComboBoxModel<E> extends ListModel<E> {
+
+    void setSelectedItem(Object anItem);
+
+    Object getSelectedItem();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComponentInputMap.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComponentInputMap.java
new file mode 100644
index 00000000000..b002bcd665c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ComponentInputMap.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// The input map of a component's `WHEN_IN_FOCUSED_WINDOW` bindings; it
+/// knows the component it belongs to.
+public class ComponentInputMap extends InputMap {
+
+    private final JComponent component;
+
+    public ComponentInputMap(JComponent component) {
+        if (component == null) {
+            throw new IllegalArgumentException("ComponentInputMaps must be associated with a non-null JComponent");
+        }
+        this.component = component;
+    }
+
+    @Override
+    public void setParent(InputMap map) {
+        if (map != null && (!(map instanceof ComponentInputMap)
+                || ((ComponentInputMap) map).getComponent() != component)) {
+            throw new IllegalArgumentException(
+                    "ComponentInputMaps must have a parent ComponentInputMap associated with the same component");
+        }
+        super.setParent(map);
+    }
+
+    public JComponent getComponent() {
+        return component;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultBoundedRangeModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultBoundedRangeModel.java
new file mode 100644
index 00000000000..c4fc5f83a1c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultBoundedRangeModel.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.EventListener;
+
+/// The bounded range model every slider, progress bar and scroll bar
+/// starts with. A value outside the range is moved into it; a change of
+/// any property notifies the change listeners once.
+public class DefaultBoundedRangeModel implements BoundedRangeModel {
+
+    protected transient ChangeEvent changeEvent;
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private int value;
+    private int extent;
+    private int min;
+    private int max = 100;
+    private boolean isAdjusting;
+
+    public DefaultBoundedRangeModel() {
+    }
+
+    public DefaultBoundedRangeModel(int value, int extent, int min, int max) {
+        if (max >= min && value >= min && value + extent >= value && value + extent <= max) {
+            this.value = value;
+            this.extent = extent;
+            this.min = min;
+            this.max = max;
+        } else {
+            throw new IllegalArgumentException("invalid range properties");
+        }
+    }
+
+    @Override
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public int getExtent() {
+        return extent;
+    }
+
+    @Override
+    public int getMinimum() {
+        return min;
+    }
+
+    @Override
+    public int getMaximum() {
+        return max;
+    }
+
+    @Override
+    public void setValue(int n) {
+        n = Math.min(n, Integer.MAX_VALUE - extent);
+        int newValue = Math.max(n, min);
+        if (newValue + extent > max) {
+            newValue = max - extent;
+        }
+        setRangeProperties(newValue, extent, min, max, isAdjusting);
+    }
+
+    @Override
+    public void setExtent(int n) {
+        int newExtent = Math.max(0, n);
+        if (value + newExtent > max) {
+            newExtent = max - value;
+        }
+        setRangeProperties(value, newExtent, min, max, isAdjusting);
+    }
+
+    @Override
+    public void setMinimum(int n) {
+        int newMax = Math.max(n, max);
+        int newValue = Math.max(n, value);
+        int newExtent = Math.min(newMax - newValue, extent);
+        setRangeProperties(newValue, newExtent, n, newMax, isAdjusting);
+    }
+
+    @Override
+    public void setMaximum(int n) {
+        int newMin = Math.min(n, min);
+        int newExtent = Math.min(n - newMin, extent);
+        int newValue = Math.min(n - newExtent, value);
+        setRangeProperties(newValue, newExtent, newMin, n, isAdjusting);
+    }
+
+    @Override
+    public void setValueIsAdjusting(boolean b) {
+        setRangeProperties(value, extent, min, max, b);
+    }
+
+    @Override
+    public boolean getValueIsAdjusting() {
+        return isAdjusting;
+    }
+
+    @Override
+    public void setRangeProperties(int newValue, int newExtent, int newMin, int newMax, boolean adjusting) {
+        if (newMin > newMax) {
+            newMin = newMax;
+        }
+        if (newValue > newMax) {
+            newMax = newValue;
+        }
+        if (newValue < newMin) {
+            newMin = newValue;
+        }
+        if ((long) newExtent + (long) newValue > newMax) {
+            newExtent = newMax - newValue;
+        }
+        if (newExtent < 0) {
+            newExtent = 0;
+        }
+        boolean changed = newValue != value || newExtent != extent || newMin != min || newMax != max
+                || adjusting != isAdjusting;
+        if (changed) {
+            value = newValue;
+            extent = newExtent;
+            min = newMin;
+            max = newMax;
+            isAdjusting = adjusting;
+            fireStateChanged();
+        }
+    }
+
+    @Override
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    @Override
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[value=" + value + ", extent=" + extent + ", min=" + min + ", max=" + max
+                + ", adj=" + isAdjusting + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultButtonModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultButtonModel.java
new file mode 100644
index 00000000000..26f5fdedd91
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultButtonModel.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+
+import java.util.EventListener;
+
+/// The default state holder of a button.
+///
+/// Every change of state fires a `ChangeEvent`, a change of selection also
+/// fires an `ItemEvent`, and releasing the button while it is armed fires an
+/// `ActionEvent`. The modifiers of the action event are always zero, because
+/// there is no current event to take them from. A model in a `ButtonGroup`
+/// lets the group decide whether it can be selected.
+public class DefaultButtonModel implements ButtonModel {
+
+    public static final int ARMED = 1 << 0;
+
+    public static final int SELECTED = 1 << 1;
+
+    public static final int PRESSED = 1 << 2;
+
+    public static final int ENABLED = 1 << 3;
+
+    public static final int ROLLOVER = 1 << 4;
+
+    /// The bit set of the state constants.
+    protected int stateMask;
+
+    protected String actionCommand;
+
+    protected ButtonGroup group;
+
+    protected int mnemonic;
+
+    protected ChangeEvent changeEvent;
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    public DefaultButtonModel() {
+        stateMask = 0;
+        mnemonic = 0;
+        actionCommand = null;
+        setEnabled(true);
+    }
+
+    public void setActionCommand(String actionCommand) {
+        this.actionCommand = actionCommand;
+    }
+
+    public String getActionCommand() {
+        return actionCommand;
+    }
+
+    public boolean isArmed() {
+        return (stateMask & ARMED) != 0;
+    }
+
+    public boolean isSelected() {
+        return (stateMask & SELECTED) != 0;
+    }
+
+    public boolean isEnabled() {
+        return (stateMask & ENABLED) != 0;
+    }
+
+    public boolean isPressed() {
+        return (stateMask & PRESSED) != 0;
+    }
+
+    public boolean isRollover() {
+        return (stateMask & ROLLOVER) != 0;
+    }
+
+    public void setArmed(boolean b) {
+        if (isArmed() == b || !isEnabled()) {
+            return;
+        }
+        if (b) {
+            stateMask |= ARMED;
+        } else {
+            stateMask &= ~ARMED;
+        }
+        fireStateChanged();
+    }
+
+    public void setEnabled(boolean b) {
+        if (isEnabled() == b) {
+            return;
+        }
+        if (b) {
+            stateMask |= ENABLED;
+        } else {
+            stateMask &= ~(ENABLED | ARMED | PRESSED);
+        }
+        fireStateChanged();
+    }
+
+    public void setSelected(boolean b) {
+        boolean selected = b;
+        if (group != null) {
+            group.setSelected(this, selected);
+            selected = group.isSelected(this);
+        }
+        if (isSelected() == selected) {
+            return;
+        }
+        if (selected) {
+            stateMask |= SELECTED;
+        } else {
+            stateMask &= ~SELECTED;
+        }
+        fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, this,
+                selected ? ItemEvent.SELECTED : ItemEvent.DESELECTED));
+        fireStateChanged();
+    }
+
+    public void setPressed(boolean b) {
+        if (isPressed() == b || !isEnabled()) {
+            return;
+        }
+        if (b) {
+            stateMask |= PRESSED;
+        } else {
+            stateMask &= ~PRESSED;
+        }
+        if (!isPressed() && isArmed()) {
+            fireActionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, getActionCommand(),
+                    System.currentTimeMillis(), 0));
+        }
+        fireStateChanged();
+    }
+
+    public void setRollover(boolean b) {
+        if (isRollover() == b || !isEnabled()) {
+            return;
+        }
+        if (b) {
+            stateMask |= ROLLOVER;
+        } else {
+            stateMask &= ~ROLLOVER;
+        }
+        fireStateChanged();
+    }
+
+    public void setMnemonic(int key) {
+        mnemonic = key;
+        fireStateChanged();
+    }
+
+    public int getMnemonic() {
+        return mnemonic;
+    }
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i] == ChangeListener.class) {
+                if (changeEvent == null) {
+                    changeEvent = new ChangeEvent(this);
+                }
+                ((ChangeListener) listeners[i + 1]).stateChanged(changeEvent);
+            }
+        }
+    }
+
+    public void addActionListener(ActionListener l) {
+        listenerList.add(ActionListener.class, l);
+    }
+
+    public void removeActionListener(ActionListener l) {
+        listenerList.remove(ActionListener.class, l);
+    }
+
+    public ActionListener[] getActionListeners() {
+        return listenerList.getListeners(ActionListener.class);
+    }
+
+    protected void fireActionPerformed(ActionEvent e) {
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i] == ActionListener.class) {
+                ((ActionListener) listeners[i + 1]).actionPerformed(e);
+            }
+        }
+    }
+
+    public void addItemListener(ItemListener l) {
+        listenerList.add(ItemListener.class, l);
+    }
+
+    public void removeItemListener(ItemListener l) {
+        listenerList.remove(ItemListener.class, l);
+    }
+
+    public ItemListener[] getItemListeners() {
+        return listenerList.getListeners(ItemListener.class);
+    }
+
+    protected void fireItemStateChanged(ItemEvent e) {
+        Object[] listeners = listenerList.getListenerList();
+        for (int i = listeners.length - 2; i >= 0; i -= 2) {
+            if (listeners[i] == ItemListener.class) {
+                ((ItemListener) listeners[i + 1]).itemStateChanged(e);
+            }
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+
+    public Object[] getSelectedObjects() {
+        return null;
+    }
+
+    public void setGroup(ButtonGroup group) {
+        this.group = group;
+    }
+
+    public ButtonGroup getGroup() {
+        return group;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultCellEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultCellEditor.java
new file mode 100644
index 00000000000..1db78217a49
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultCellEditor.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.table.TableCellEditor;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellEditor;
+import java.util.EventObject;
+
+/// The editor of table and tree cells: a text field, a check box or a
+/// combo box, each of them the Codename One widget, placed over the cell
+/// while it is edited.
+///
+/// A text field starts editing on the second click, the other two on the
+/// first. The text field's value is always a string; the table's default
+/// editors for numbers convert it.
+public class DefaultCellEditor extends AbstractCellEditor implements TableCellEditor, TreeCellEditor {
+
+    protected JComponent editorComponent;
+    protected EditorDelegate delegate;
+    protected int clickCountToStart = 1;
+
+    public DefaultCellEditor(final JTextField textField) {
+        editorComponent = textField;
+        clickCountToStart = 2;
+        delegate = new EditorDelegate() {
+            @Override
+            public void setValue(Object value) {
+                textField.setText(value != null ? value.toString() : "");
+            }
+
+            @Override
+            public Object getCellEditorValue() {
+                return textField.getText();
+            }
+        };
+        textField.addActionListener(delegate);
+    }
+
+    public DefaultCellEditor(final JCheckBox checkBox) {
+        editorComponent = checkBox;
+        delegate = new EditorDelegate() {
+            @Override
+            public void setValue(Object value) {
+                boolean selected = false;
+                if (value instanceof Boolean) {
+                    selected = ((Boolean) value).booleanValue();
+                } else if (value instanceof String) {
+                    selected = "true".equals(value);
+                }
+                loading = true;
+                try {
+                    checkBox.setSelected(selected);
+                } finally {
+                    loading = false;
+                }
+            }
+
+            @Override
+            public Object getCellEditorValue() {
+                return Boolean.valueOf(checkBox.isSelected());
+            }
+        };
+        checkBox.addActionListener(delegate);
+    }
+
+    public DefaultCellEditor(final JComboBox comboBox) {
+        editorComponent = comboBox;
+        delegate = new EditorDelegate() {
+            @Override
+            public void setValue(Object value) {
+                loading = true;
+                try {
+                    comboBox.setSelectedItem(value);
+                } finally {
+                    loading = false;
+                }
+            }
+
+            @Override
+            public Object getCellEditorValue() {
+                return comboBox.getSelectedItem();
+            }
+
+            @Override
+            public boolean shouldSelectCell(EventObject anEvent) {
+                if (anEvent instanceof MouseEvent) {
+                    return ((MouseEvent) anEvent).getID() != MouseEvent.MOUSE_DRAGGED;
+                }
+                return true;
+            }
+        };
+        comboBox.addActionListener(delegate);
+    }
+
+    /// The component that edits.
+    public Component getComponent() {
+        return editorComponent;
+    }
+
+    public void setClickCountToStart(int count) {
+        clickCountToStart = count;
+    }
+
+    public int getClickCountToStart() {
+        return clickCountToStart;
+    }
+
+    @Override
+    public Object getCellEditorValue() {
+        return delegate.getCellEditorValue();
+    }
+
+    @Override
+    public boolean isCellEditable(EventObject anEvent) {
+        return delegate.isCellEditable(anEvent);
+    }
+
+    @Override
+    public boolean shouldSelectCell(EventObject anEvent) {
+        return delegate.shouldSelectCell(anEvent);
+    }
+
+    @Override
+    public boolean stopCellEditing() {
+        return delegate.stopCellEditing();
+    }
+
+    @Override
+    public void cancelCellEditing() {
+        delegate.cancelCellEditing();
+    }
+
+    @Override
+    public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded,
+            boolean leaf, int row) {
+        String text = tree == null ? String.valueOf(value)
+                : tree.convertValueToText(value, isSelected, expanded, leaf, row, false);
+        delegate.setValue(text);
+        return editorComponent;
+    }
+
+    @Override
+    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row,
+            int column) {
+        delegate.setValue(value);
+        return editorComponent;
+    }
+
+    /// Carries the value between the cell and the editing component; each
+    /// constructor makes one for its kind of component.
+    protected class EditorDelegate implements ActionListener, ItemListener {
+
+        protected Object value;
+
+        /// Set while the delegate itself puts a value into the component,
+        /// so that the action this may fire is not taken for the user's.
+        boolean loading;
+
+        public Object getCellEditorValue() {
+            return value;
+        }
+
+        public void setValue(Object value) {
+            this.value = value;
+        }
+
+        public boolean isCellEditable(EventObject anEvent) {
+            if (anEvent instanceof MouseEvent) {
+                return ((MouseEvent) anEvent).getClickCount() >= clickCountToStart;
+            }
+            return true;
+        }
+
+        public boolean shouldSelectCell(EventObject anEvent) {
+            return true;
+        }
+
+        public boolean startCellEditing(EventObject anEvent) {
+            return true;
+        }
+
+        public boolean stopCellEditing() {
+            fireEditingStopped();
+            return true;
+        }
+
+        public void cancelCellEditing() {
+            fireEditingCanceled();
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            if (!loading) {
+                DefaultCellEditor.this.stopCellEditing();
+            }
+        }
+
+        @Override
+        public void itemStateChanged(ItemEvent e) {
+            if (!loading) {
+                DefaultCellEditor.this.stopCellEditing();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultComboBoxModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultComboBoxModel.java
new file mode 100644
index 00000000000..145187a854b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultComboBoxModel.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.Vector;
+
+/// The model a combo box has unless it is given another.
+///
+/// The first element added to an empty model becomes the selection, and
+/// removing the selected element selects a neighbour.
+public class DefaultComboBoxModel<E> extends AbstractListModel<E> implements MutableComboBoxModel<E> {
+
+    private final Vector<E> objects;
+    private Object selectedObject;
+
+    public DefaultComboBoxModel() {
+        objects = new Vector<E>();
+    }
+
+    public DefaultComboBoxModel(E[] items) {
+        objects = new Vector<E>(items.length);
+        for (int i = 0; i < items.length; i++) {
+            objects.addElement(items[i]);
+        }
+        if (items.length > 0) {
+            selectedObject = items[0];
+        }
+    }
+
+    /// Uses `v` itself, not a copy of it, as the desktop does.
+    public DefaultComboBoxModel(Vector<E> v) {
+        objects = v;
+        if (v.size() > 0) {
+            selectedObject = v.elementAt(0);
+        }
+    }
+
+    @Override
+    public void setSelectedItem(Object anObject) {
+        if ((selectedObject != null && !selectedObject.equals(anObject))
+                || (selectedObject == null && anObject != null)) {
+            selectedObject = anObject;
+            fireContentsChanged(this, -1, -1);
+        }
+    }
+
+    @Override
+    public Object getSelectedItem() {
+        return selectedObject;
+    }
+
+    @Override
+    public int getSize() {
+        return objects.size();
+    }
+
+    @Override
+    public E getElementAt(int index) {
+        if (index >= 0 && index < objects.size()) {
+            return objects.elementAt(index);
+        }
+        return null;
+    }
+
+    public int getIndexOf(Object anObject) {
+        return objects.indexOf(anObject);
+    }
+
+    @Override
+    public void addElement(E anObject) {
+        objects.addElement(anObject);
+        fireIntervalAdded(this, objects.size() - 1, objects.size() - 1);
+        if (objects.size() == 1 && selectedObject == null && anObject != null) {
+            setSelectedItem(anObject);
+        }
+    }
+
+    @Override
+    public void insertElementAt(E anObject, int index) {
+        objects.insertElementAt(anObject, index);
+        fireIntervalAdded(this, index, index);
+    }
+
+    @Override
+    public void removeElementAt(int index) {
+        // Identity on purpose: the element removed is the selection itself,
+        // not merely one equal to it.
+        Object removed = getElementAt(index);
+        if (removed == selectedObject) {
+            if (index == 0) {
+                setSelectedItem(getSize() == 1 ? null : getElementAt(index + 1));
+            } else {
+                setSelectedItem(getElementAt(index - 1));
+            }
+        }
+        objects.removeElementAt(index);
+        fireIntervalRemoved(this, index, index);
+    }
+
+    @Override
+    public void removeElement(Object anObject) {
+        int index = objects.indexOf(anObject);
+        if (index != -1) {
+            removeElementAt(index);
+        }
+    }
+
+    public void removeAllElements() {
+        if (objects.size() > 0) {
+            int lastIndex = objects.size() - 1;
+            objects.removeAllElements();
+            selectedObject = null;
+            fireIntervalRemoved(this, 0, lastIndex);
+        } else {
+            selectedObject = null;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListCellRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListCellRenderer.java
new file mode 100644
index 00000000000..8a48a1f7638
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListCellRenderer.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+
+/// The renderer a list uses unless it is given another: a label showing
+/// the icon, when the value is one, or its `toString()`.
+public class DefaultListCellRenderer extends JLabel implements ListCellRenderer<Object> {
+
+    public DefaultListCellRenderer() {
+        setOpaque(true);
+        setName("List.cellRenderer");
+    }
+
+    @Override
+    public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected,
+            boolean cellHasFocus) {
+        if (isSelected) {
+            setBackground(list.getSelectionBackground());
+            setForeground(list.getSelectionForeground());
+        } else {
+            setBackground(list.getBackground());
+            setForeground(list.getForeground());
+        }
+        if (value instanceof Icon) {
+            setIcon((Icon) value);
+            setText("");
+        } else {
+            setIcon(null);
+            setText(value == null ? "" : value.toString());
+        }
+        setEnabled(list.isEnabled());
+        setFont(list.getFont());
+        return this;
+    }
+
+    /// The background first: the label behind this renderer is drawn by
+    /// Codename One, which leaves the row's color to its owner.
+    @Override
+    protected void paintComponent(Graphics g) {
+        Color bg = getBackground();
+        if (isOpaque() && bg != null) {
+            g.setColor(bg);
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        super.paintComponent(g);
+    }
+
+    /// The renderer the look and feel installs, as opposed to one an
+    /// application set.
+    public static class UIResource extends DefaultListCellRenderer {
+
+        public UIResource() {
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListModel.java
new file mode 100644
index 00000000000..3a676ad5d12
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListModel.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/// A list model that is a vector of elements and tells its listeners about
+/// every change.
+public class DefaultListModel<E> extends AbstractListModel<E> {
+
+    private final Vector<E> delegate = new Vector<E>();
+
+    public DefaultListModel() {
+    }
+
+    @Override
+    public int getSize() {
+        return delegate.size();
+    }
+
+    @Override
+    public E getElementAt(int index) {
+        return delegate.elementAt(index);
+    }
+
+    public void copyInto(Object[] anArray) {
+        delegate.copyInto(anArray);
+    }
+
+    public void trimToSize() {
+        delegate.trimToSize();
+    }
+
+    public void ensureCapacity(int minCapacity) {
+        delegate.ensureCapacity(minCapacity);
+    }
+
+    public void setSize(int newSize) {
+        int oldSize = delegate.size();
+        delegate.setSize(newSize);
+        if (oldSize > newSize) {
+            fireIntervalRemoved(this, newSize, oldSize - 1);
+        } else if (oldSize < newSize) {
+            fireIntervalAdded(this, oldSize, newSize - 1);
+        }
+    }
+
+    public int capacity() {
+        return delegate.capacity();
+    }
+
+    public int size() {
+        return delegate.size();
+    }
+
+    public boolean isEmpty() {
+        return delegate.isEmpty();
+    }
+
+    public Enumeration<E> elements() {
+        return delegate.elements();
+    }
+
+    public boolean contains(Object elem) {
+        return delegate.contains(elem);
+    }
+
+    public int indexOf(Object elem) {
+        return delegate.indexOf(elem);
+    }
+
+    public int indexOf(Object elem, int index) {
+        return delegate.indexOf(elem, index);
+    }
+
+    public int lastIndexOf(Object elem) {
+        return delegate.lastIndexOf(elem);
+    }
+
+    public int lastIndexOf(Object elem, int index) {
+        return delegate.lastIndexOf(elem, index);
+    }
+
+    public E elementAt(int index) {
+        return delegate.elementAt(index);
+    }
+
+    public E firstElement() {
+        return delegate.firstElement();
+    }
+
+    public E lastElement() {
+        return delegate.lastElement();
+    }
+
+    public void setElementAt(E element, int index) {
+        delegate.setElementAt(element, index);
+        fireContentsChanged(this, index, index);
+    }
+
+    public void removeElementAt(int index) {
+        delegate.removeElementAt(index);
+        fireIntervalRemoved(this, index, index);
+    }
+
+    public void insertElementAt(E element, int index) {
+        delegate.insertElementAt(element, index);
+        fireIntervalAdded(this, index, index);
+    }
+
+    public void addElement(E element) {
+        int index = delegate.size();
+        delegate.addElement(element);
+        fireIntervalAdded(this, index, index);
+    }
+
+    public boolean removeElement(Object obj) {
+        int index = indexOf(obj);
+        boolean rv = delegate.removeElement(obj);
+        if (index >= 0) {
+            fireIntervalRemoved(this, index, index);
+        }
+        return rv;
+    }
+
+    public void removeAllElements() {
+        int index1 = delegate.size() - 1;
+        delegate.removeAllElements();
+        if (index1 >= 0) {
+            fireIntervalRemoved(this, 0, index1);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return delegate.toString();
+    }
+
+    public Object[] toArray() {
+        Object[] rv = new Object[delegate.size()];
+        delegate.copyInto(rv);
+        return rv;
+    }
+
+    public E get(int index) {
+        return delegate.elementAt(index);
+    }
+
+    public E set(int index, E element) {
+        E rv = delegate.elementAt(index);
+        delegate.setElementAt(element, index);
+        fireContentsChanged(this, index, index);
+        return rv;
+    }
+
+    public void add(int index, E element) {
+        delegate.insertElementAt(element, index);
+        fireIntervalAdded(this, index, index);
+    }
+
+    public E remove(int index) {
+        E rv = delegate.elementAt(index);
+        delegate.removeElementAt(index);
+        fireIntervalRemoved(this, index, index);
+        return rv;
+    }
+
+    public void clear() {
+        removeAllElements();
+    }
+
+    public void removeRange(int fromIndex, int toIndex) {
+        if (fromIndex > toIndex) {
+            throw new IllegalArgumentException("fromIndex must be <= toIndex");
+        }
+        for (int i = toIndex; i >= fromIndex; i--) {
+            delegate.removeElementAt(i);
+        }
+        fireIntervalRemoved(this, fromIndex, toIndex);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListSelectionModel.java
new file mode 100644
index 00000000000..7afcde10fbe
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultListSelectionModel.java
@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import java.util.ArrayList;
+
+/// The selection of a list in its three modes.
+///
+/// Every operation reports one event covering the rows whose state changed
+/// and, while [#isLeadAnchorNotificationEnabled()], the old and new places
+/// of the anchor and the lead. While the value is adjusting the events say
+/// so, and ending the adjustment reports the whole range touched since it
+/// began.
+public class DefaultListSelectionModel implements ListSelectionModel {
+
+    private static final int NONE_MIN = Integer.MAX_VALUE;
+    private static final int NONE_MAX = -1;
+
+    private int selectionMode = MULTIPLE_INTERVAL_SELECTION;
+    private int minIndex = NONE_MIN;
+    private int maxIndex = NONE_MAX;
+    private int anchorIndex = -1;
+    private int leadIndex = -1;
+    private int firstAdjustedIndex = NONE_MIN;
+    private int lastAdjustedIndex = NONE_MAX;
+    private boolean isAdjusting;
+    private int firstChangedIndex = NONE_MIN;
+    private int lastChangedIndex = NONE_MAX;
+    private boolean[] value = new boolean[32];
+    private final ArrayList<ListSelectionListener> listeners = new ArrayList<ListSelectionListener>();
+
+    protected boolean leadAnchorNotificationEnabled = true;
+
+    public DefaultListSelectionModel() {
+    }
+
+    @Override
+    public int getMinSelectionIndex() {
+        return isSelectionEmpty() ? -1 : minIndex;
+    }
+
+    @Override
+    public int getMaxSelectionIndex() {
+        return maxIndex;
+    }
+
+    @Override
+    public boolean getValueIsAdjusting() {
+        return isAdjusting;
+    }
+
+    @Override
+    public int getSelectionMode() {
+        return selectionMode;
+    }
+
+    @Override
+    public void setSelectionMode(int selectionMode) {
+        if (selectionMode != SINGLE_SELECTION && selectionMode != SINGLE_INTERVAL_SELECTION
+                && selectionMode != MULTIPLE_INTERVAL_SELECTION) {
+            throw new IllegalArgumentException("invalid selectionMode");
+        }
+        this.selectionMode = selectionMode;
+    }
+
+    @Override
+    public boolean isSelectedIndex(int index) {
+        return index >= minIndex && index <= maxIndex && get(index);
+    }
+
+    @Override
+    public boolean isSelectionEmpty() {
+        return minIndex > maxIndex;
+    }
+
+    @Override
+    public void addListSelectionListener(ListSelectionListener l) {
+        if (l != null) {
+            listeners.add(l);
+        }
+    }
+
+    @Override
+    public void removeListSelectionListener(ListSelectionListener l) {
+        int i = listeners.lastIndexOf(l);
+        if (i >= 0) {
+            listeners.remove(i);
+        }
+    }
+
+    public ListSelectionListener[] getListSelectionListeners() {
+        return listeners.toArray(new ListSelectionListener[listeners.size()]);
+    }
+
+    protected void fireValueChanged(boolean isAdjusting) {
+        if (lastChangedIndex == NONE_MAX) {
+            return;
+        }
+        int oldFirst = firstChangedIndex;
+        int oldLast = lastChangedIndex;
+        firstChangedIndex = NONE_MIN;
+        lastChangedIndex = NONE_MAX;
+        fireValueChanged(oldFirst, oldLast, isAdjusting);
+    }
+
+    protected void fireValueChanged(int firstIndex, int lastIndex) {
+        fireValueChanged(firstIndex, lastIndex, getValueIsAdjusting());
+    }
+
+    protected void fireValueChanged(int firstIndex, int lastIndex, boolean isAdjusting) {
+        if (listeners.isEmpty()) {
+            return;
+        }
+        ListSelectionEvent e = new ListSelectionEvent(this, firstIndex, lastIndex, isAdjusting);
+        ListSelectionListener[] all = getListSelectionListeners();
+        for (int i = all.length - 1; i >= 0; i--) {
+            all[i].valueChanged(e);
+        }
+    }
+
+    private void fireValueChanged() {
+        if (lastAdjustedIndex == NONE_MAX) {
+            return;
+        }
+        if (getValueIsAdjusting()) {
+            firstChangedIndex = Math.min(firstChangedIndex, firstAdjustedIndex);
+            lastChangedIndex = Math.max(lastChangedIndex, lastAdjustedIndex);
+        }
+        int oldFirst = firstAdjustedIndex;
+        int oldLast = lastAdjustedIndex;
+        firstAdjustedIndex = NONE_MIN;
+        lastAdjustedIndex = NONE_MAX;
+        fireValueChanged(oldFirst, oldLast);
+    }
+
+    private boolean get(int i) {
+        return i >= 0 && i < value.length && value[i];
+    }
+
+    private void markAsDirty(int r) {
+        if (r == -1) {
+            return;
+        }
+        firstAdjustedIndex = Math.min(firstAdjustedIndex, r);
+        lastAdjustedIndex = Math.max(lastAdjustedIndex, r);
+    }
+
+    private void set(int r) {
+        if (get(r)) {
+            return;
+        }
+        if (r >= value.length) {
+            boolean[] grown = new boolean[Math.max(r + 1, value.length * 2)];
+            System.arraycopy(value, 0, grown, 0, value.length);
+            value = grown;
+        }
+        value[r] = true;
+        markAsDirty(r);
+        minIndex = Math.min(minIndex, r);
+        maxIndex = Math.max(maxIndex, r);
+    }
+
+    private void clear(int r) {
+        if (!get(r)) {
+            return;
+        }
+        value[r] = false;
+        markAsDirty(r);
+        if (r == minIndex) {
+            for (minIndex = minIndex + 1; minIndex <= maxIndex; minIndex++) {
+                if (get(minIndex)) {
+                    break;
+                }
+            }
+        }
+        if (r == maxIndex) {
+            for (maxIndex = maxIndex - 1; minIndex <= maxIndex; maxIndex--) {
+                if (get(maxIndex)) {
+                    break;
+                }
+            }
+        }
+        if (isSelectionEmpty()) {
+            minIndex = NONE_MIN;
+            maxIndex = NONE_MAX;
+        }
+    }
+
+    public void setLeadAnchorNotificationEnabled(boolean flag) {
+        leadAnchorNotificationEnabled = flag;
+    }
+
+    public boolean isLeadAnchorNotificationEnabled() {
+        return leadAnchorNotificationEnabled;
+    }
+
+    private void updateLeadAnchorIndices(int anchor, int lead) {
+        if (leadAnchorNotificationEnabled) {
+            if (anchorIndex != anchor) {
+                markAsDirty(anchorIndex);
+                markAsDirty(anchor);
+            }
+            if (leadIndex != lead) {
+                markAsDirty(leadIndex);
+                markAsDirty(lead);
+            }
+        }
+        anchorIndex = anchor;
+        leadIndex = lead;
+    }
+
+    private static boolean contains(int a, int b, int i) {
+        return i >= a && i <= b;
+    }
+
+    private void changeSelection(int clearMin, int clearMax, int setMin, int setMax, boolean clearFirst) {
+        for (int i = Math.min(setMin, clearMin); i <= Math.max(setMax, clearMax); i++) {
+            boolean shouldClear = contains(clearMin, clearMax, i);
+            boolean shouldSet = contains(setMin, setMax, i);
+            if (shouldSet && shouldClear) {
+                if (clearFirst) {
+                    shouldClear = false;
+                } else {
+                    shouldSet = false;
+                }
+            }
+            if (shouldSet) {
+                set(i);
+            }
+            if (shouldClear) {
+                clear(i);
+            }
+        }
+        fireValueChanged();
+    }
+
+    @Override
+    public void clearSelection() {
+        // With nothing selected maxIndex is -1, and removeSelectionIntervalImpl
+        // returns at once on a -1 end, as the JDK's does: an empty
+        // selection never reaches the loop over Integer.MAX_VALUE..-1.
+        removeSelectionIntervalImpl(minIndex, maxIndex, false);
+    }
+
+    @Override
+    public void setSelectionInterval(int index0, int index1) {
+        if (index0 == -1 || index1 == -1) {
+            return;
+        }
+        if (getSelectionMode() == SINGLE_SELECTION) {
+            index0 = index1;
+        }
+        updateLeadAnchorIndices(index0, index1);
+        changeSelection(minIndex, maxIndex, Math.min(index0, index1), Math.max(index0, index1), true);
+    }
+
+    @Override
+    public void addSelectionInterval(int index0, int index1) {
+        if (index0 == -1 || index1 == -1) {
+            return;
+        }
+        if (getSelectionMode() == SINGLE_SELECTION) {
+            setSelectionInterval(index0, index1);
+            return;
+        }
+        updateLeadAnchorIndices(index0, index1);
+        int clearMin = NONE_MIN;
+        int clearMax = NONE_MAX;
+        int setMin = Math.min(index0, index1);
+        int setMax = Math.max(index0, index1);
+        // One interval only: a range that neither touches nor overlaps the
+        // selection replaces it.
+        if (getSelectionMode() == SINGLE_INTERVAL_SELECTION && (setMax < minIndex - 1 || setMin > maxIndex + 1)) {
+            clearMin = minIndex;
+            clearMax = maxIndex;
+        }
+        changeSelection(clearMin, clearMax, setMin, setMax, true);
+    }
+
+    @Override
+    public void removeSelectionInterval(int index0, int index1) {
+        removeSelectionIntervalImpl(index0, index1, true);
+    }
+
+    private void removeSelectionIntervalImpl(int index0, int index1, boolean changeLeadAnchor) {
+        if (index0 == -1 || index1 == -1) {
+            return;
+        }
+        if (changeLeadAnchor) {
+            updateLeadAnchorIndices(index0, index1);
+        }
+        int clearMin = Math.min(index0, index1);
+        int clearMax = Math.max(index0, index1);
+        // Taking the middle out of a single interval would leave two.
+        if (getSelectionMode() != MULTIPLE_INTERVAL_SELECTION && clearMin > minIndex && clearMax < maxIndex) {
+            clearMax = maxIndex;
+        }
+        changeSelection(clearMin, clearMax, NONE_MIN, NONE_MAX, true);
+    }
+
+    private void setState(int index, boolean state) {
+        if (state) {
+            set(index);
+        } else {
+            clear(index);
+        }
+    }
+
+    @Override
+    public void insertIndexInterval(int index, int length, boolean before) {
+        int insMinIndex = before ? index : index + 1;
+        int insMaxIndex = insMinIndex + length - 1;
+        for (int i = maxIndex; i >= insMinIndex; i--) {
+            setState(i + length, get(i));
+        }
+        boolean setInsertedValues = getSelectionMode() != SINGLE_SELECTION && get(index);
+        for (int i = insMinIndex; i <= insMaxIndex; i++) {
+            setState(i, setInsertedValues);
+        }
+        int lead = leadIndex;
+        if (lead > index || (before && lead == index)) {
+            lead = leadIndex + length;
+        }
+        int anchor = anchorIndex;
+        if (anchor > index || (before && anchor == index)) {
+            anchor = anchorIndex + length;
+        }
+        if (lead != leadIndex || anchor != anchorIndex) {
+            updateLeadAnchorIndices(anchor, lead);
+        }
+        fireValueChanged();
+    }
+
+    @Override
+    public void removeIndexInterval(int index0, int index1) {
+        int rmMinIndex = Math.min(index0, index1);
+        int rmMaxIndex = Math.max(index0, index1);
+        int gapLength = rmMaxIndex - rmMinIndex + 1;
+        for (int i = rmMinIndex; i <= maxIndex; i++) {
+            setState(i, get(i + gapLength));
+        }
+        int lead = leadIndex;
+        if (lead == 0 && rmMinIndex == 0) {
+            // Stays on the first row.
+            lead = 0;
+        } else if (lead > rmMaxIndex) {
+            lead = leadIndex - gapLength;
+        } else if (lead >= rmMinIndex) {
+            lead = rmMinIndex - 1;
+        }
+        int anchor = anchorIndex;
+        if (anchor == 0 && rmMinIndex == 0) {
+            anchor = 0;
+        } else if (anchor > rmMaxIndex) {
+            anchor = anchorIndex - gapLength;
+        } else if (anchor >= rmMinIndex) {
+            anchor = rmMinIndex - 1;
+        }
+        if (lead != leadIndex || anchor != anchorIndex) {
+            updateLeadAnchorIndices(anchor, lead);
+        }
+        fireValueChanged();
+    }
+
+    @Override
+    public void setValueIsAdjusting(boolean isAdjusting) {
+        if (isAdjusting != this.isAdjusting) {
+            this.isAdjusting = isAdjusting;
+            this.fireValueChanged(isAdjusting);
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(getValueIsAdjusting() ? "~" : "=").append('{');
+        boolean first = true;
+        for (int i = minIndex; i <= maxIndex; i++) {
+            if (get(i)) {
+                if (!first) {
+                    sb.append(' ');
+                }
+                sb.append(i);
+                first = false;
+            }
+        }
+        return sb.append('}').toString();
+    }
+
+    @Override
+    public int getAnchorSelectionIndex() {
+        return anchorIndex;
+    }
+
+    @Override
+    public int getLeadSelectionIndex() {
+        return leadIndex;
+    }
+
+    @Override
+    public void setAnchorSelectionIndex(int anchorIndex) {
+        updateLeadAnchorIndices(anchorIndex, this.leadIndex);
+        fireValueChanged();
+    }
+
+    /// Moves the lead without changing the selection.
+    public void moveLeadSelectionIndex(int leadIndex) {
+        if (leadIndex == -1 && this.anchorIndex != -1) {
+            return;
+        }
+        updateLeadAnchorIndices(this.anchorIndex, leadIndex);
+        fireValueChanged();
+    }
+
+    /// Moves the lead and makes the rows between the anchor and it match
+    /// the state of the anchor row, the way a shift click does.
+    @Override
+    public void setLeadSelectionIndex(int leadIndex) {
+        int anchor = this.anchorIndex;
+        if (leadIndex == -1) {
+            if (anchor == -1) {
+                updateLeadAnchorIndices(anchor, leadIndex);
+                fireValueChanged();
+            }
+            return;
+        } else if (anchor == -1) {
+            return;
+        }
+        if (this.leadIndex == -1) {
+            this.leadIndex = leadIndex;
+        }
+        boolean shouldSelect = get(this.anchorIndex);
+        if (getSelectionMode() == SINGLE_SELECTION) {
+            anchor = leadIndex;
+            shouldSelect = true;
+        }
+        int oldMin = Math.min(this.anchorIndex, this.leadIndex);
+        int oldMax = Math.max(this.anchorIndex, this.leadIndex);
+        int newMin = Math.min(anchor, leadIndex);
+        int newMax = Math.max(anchor, leadIndex);
+        updateLeadAnchorIndices(anchor, leadIndex);
+        if (shouldSelect) {
+            changeSelection(oldMin, oldMax, newMin, newMax, true);
+        } else {
+            changeSelection(newMin, newMax, oldMin, oldMax, false);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultRowSorter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultRowSorter.java
new file mode 100644
index 00000000000..b8bd1f074c7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultRowSorter.java
@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.rt.Comparators;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/// A row sorter that sorts by up to three columns and filters, reading
+/// the model through a [ModelWrapper].
+///
+/// Values are compared by the column's comparator. The default one never
+/// trusts two values to be of one type: numbers are compared as numbers,
+/// two values of the same comparable class by `compareTo`, and anything
+/// else by its string. Strings are compared by `String.compareTo`; there
+/// is no locale collation on a device.
+///
+/// Every change of the rows sorts all of them again.
+public abstract class DefaultRowSorter<M, I> extends RowSorter<M> {
+
+    private ModelWrapper<M, I> modelWrapper;
+    private int[] viewToModel;
+    private int[] modelToView;
+    private List<SortKey> sortKeys = new ArrayList<SortKey>();
+    private Comparator<?>[] comparators;
+    private boolean[] unsortable;
+    private RowFilter<? super M, ? super I> filter;
+    private int maxSortKeys = 3;
+    private boolean sortsOnUpdates;
+    private int modelRowCount;
+
+    public DefaultRowSorter() {
+    }
+
+    protected final void setModelWrapper(ModelWrapper<M, I> modelWrapper) {
+        if (modelWrapper == null) {
+            throw new IllegalArgumentException("modelWrapper most be non-null");
+        }
+        ModelWrapper<M, I> last = this.modelWrapper;
+        this.modelWrapper = modelWrapper;
+        if (last != null) {
+            modelStructureChanged();
+        } else {
+            modelRowCount = modelWrapper.getRowCount();
+        }
+    }
+
+    protected final ModelWrapper<M, I> getModelWrapper() {
+        return modelWrapper;
+    }
+
+    @Override
+    public final M getModel() {
+        return modelWrapper == null ? null : modelWrapper.getModel();
+    }
+
+    private void checkColumn(int column) {
+        if (modelWrapper == null || column < 0 || column >= modelWrapper.getColumnCount()) {
+            throw new IndexOutOfBoundsException("column beyond range of TableModel");
+        }
+    }
+
+    public void setSortable(int column, boolean sortable) {
+        checkColumn(column);
+        if (unsortable == null) {
+            unsortable = new boolean[modelWrapper.getColumnCount()];
+        }
+        unsortable[column] = !sortable;
+    }
+
+    public boolean isSortable(int column) {
+        checkColumn(column);
+        return unsortable == null || column >= unsortable.length || !unsortable[column];
+    }
+
+    @Override
+    public void setSortKeys(List<? extends SortKey> sortKeys) {
+        List<SortKey> old = this.sortKeys;
+        List<SortKey> now = new ArrayList<SortKey>();
+        if (sortKeys != null) {
+            for (int i = 0; i < sortKeys.size(); i++) {
+                SortKey key = sortKeys.get(i);
+                if (key == null) {
+                    throw new IllegalArgumentException("Invalid SortKey");
+                }
+                checkColumn(key.getColumn());
+                now.add(key);
+            }
+        }
+        this.sortKeys = now;
+        if (!now.equals(old)) {
+            fireSortOrderChanged();
+            sort();
+        }
+    }
+
+    @Override
+    public List<? extends SortKey> getSortKeys() {
+        return Collections.unmodifiableList(sortKeys);
+    }
+
+    public void setMaxSortKeys(int max) {
+        if (max < 1) {
+            throw new IllegalArgumentException("Invalid max");
+        }
+        maxSortKeys = max;
+    }
+
+    public int getMaxSortKeys() {
+        return maxSortKeys;
+    }
+
+    public void setSortsOnUpdates(boolean sortsOnUpdates) {
+        this.sortsOnUpdates = sortsOnUpdates;
+    }
+
+    public boolean getSortsOnUpdates() {
+        return sortsOnUpdates;
+    }
+
+    public void setRowFilter(RowFilter<? super M, ? super I> filter) {
+        this.filter = filter;
+        sort();
+    }
+
+    public RowFilter<? super M, ? super I> getRowFilter() {
+        return filter;
+    }
+
+    /// Makes `column` the first sort key: ascending, or the other way
+    /// round if it was the first key already.
+    @Override
+    public void toggleSortOrder(int column) {
+        checkColumn(column);
+        if (!isSortable(column)) {
+            return;
+        }
+        List<SortKey> keys = new ArrayList<SortKey>(sortKeys);
+        int at = -1;
+        for (int i = 0; i < keys.size(); i++) {
+            if (keys.get(i).getColumn() == column) {
+                at = i;
+                break;
+            }
+        }
+        if (at == 0) {
+            SortOrder flipped = keys.get(0).getSortOrder() == SortOrder.ASCENDING
+                    ? SortOrder.DESCENDING : SortOrder.ASCENDING;
+            keys.set(0, new SortKey(column, flipped));
+        } else {
+            if (at > 0) {
+                keys.remove(at);
+            }
+            keys.add(0, new SortKey(column, SortOrder.ASCENDING));
+        }
+        while (keys.size() > maxSortKeys) {
+            keys.remove(keys.size() - 1);
+        }
+        setSortKeys(keys);
+    }
+
+    @Override
+    public int convertRowIndexToView(int index) {
+        if (modelToView == null) {
+            if (index < 0 || index >= modelRowCount) {
+                throw new IndexOutOfBoundsException("Invalid index");
+            }
+            return index;
+        }
+        return modelToView[index];
+    }
+
+    @Override
+    public int convertRowIndexToModel(int index) {
+        if (viewToModel == null) {
+            if (index < 0 || index >= modelRowCount) {
+                throw new IndexOutOfBoundsException("Invalid index");
+            }
+            return index;
+        }
+        return viewToModel[index];
+    }
+
+    private boolean sorted() {
+        for (int i = 0; i < sortKeys.size(); i++) {
+            if (sortKeys.get(i).getSortOrder() != SortOrder.UNSORTED) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Filters and sorts every row again, and tells the listeners if the
+    /// rows shown or their order may have changed.
+    public void sort() {
+        if (modelWrapper == null) {
+            return;
+        }
+        int[] before = viewToModel;
+        modelRowCount = modelWrapper.getRowCount();
+        if (filter == null && !sorted()) {
+            viewToModel = null;
+            modelToView = null;
+            if (before != null) {
+                fireRowSorterChanged(before);
+            }
+            return;
+        }
+        List<Integer> rows = new ArrayList<Integer>(modelRowCount);
+        Row entry = filter == null ? null : new Row();
+        for (int i = 0; i < modelRowCount; i++) {
+            if (entry != null) {
+                entry.modelIndex = i;
+                if (!filter.include(entry)) {
+                    continue;
+                }
+            }
+            rows.add(Integer.valueOf(i));
+        }
+        if (sorted()) {
+            Collections.sort(rows, new Comparator<Integer>() {
+                @Override
+                public int compare(Integer a, Integer b) {
+                    return compareRows(a.intValue(), b.intValue());
+                }
+            });
+        }
+        viewToModel = new int[rows.size()];
+        modelToView = new int[modelRowCount];
+        for (int i = 0; i < modelToView.length; i++) {
+            modelToView[i] = -1;
+        }
+        for (int i = 0; i < viewToModel.length; i++) {
+            viewToModel[i] = rows.get(i).intValue();
+            modelToView[viewToModel[i]] = i;
+        }
+        fireRowSorterChanged(before);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private int compareRows(int model1, int model2) {
+        for (int i = 0; i < sortKeys.size(); i++) {
+            SortKey key = sortKeys.get(i);
+            SortOrder order = key.getSortOrder();
+            if (order == SortOrder.UNSORTED) {
+                continue;
+            }
+            int column = key.getColumn();
+            Object v1;
+            Object v2;
+            Comparator comparator;
+            if (useToString(column)) {
+                v1 = modelWrapper.getStringValueAt(model1, column);
+                v2 = modelWrapper.getStringValueAt(model2, column);
+                comparator = Comparators.STRINGS;
+            } else {
+                v1 = modelWrapper.getValueAt(model1, column);
+                v2 = modelWrapper.getValueAt(model2, column);
+                comparator = getComparator(column);
+            }
+            int result;
+            if (v1 == null) {
+                result = v2 == null ? 0 : -1;
+            } else if (v2 == null) {
+                result = 1;
+            } else {
+                result = comparator.compare(v1, v2);
+            }
+            if (result != 0) {
+                return order == SortOrder.DESCENDING ? -result : result;
+            }
+        }
+        return model1 - model2;
+    }
+
+    /// Whether the column's values are compared by their strings.
+    protected boolean useToString(int column) {
+        return getComparator(column) == Comparators.STRINGS;
+    }
+
+    public void setComparator(int column, Comparator<?> comparator) {
+        checkColumn(column);
+        if (comparators == null) {
+            comparators = new Comparator<?>[modelWrapper.getColumnCount()];
+        }
+        comparators[column] = comparator;
+    }
+
+    /// The comparator set for the column, or the one that compares
+    /// strings.
+    public Comparator<?> getComparator(int column) {
+        checkColumn(column);
+        if (comparators != null && column < comparators.length && comparators[column] != null) {
+            return comparators[column];
+        }
+        return Comparators.STRINGS;
+    }
+
+    @Override
+    public int getViewRowCount() {
+        return viewToModel != null ? viewToModel.length : modelRowCount;
+    }
+
+    @Override
+    public int getModelRowCount() {
+        return modelWrapper == null ? 0 : modelWrapper.getRowCount();
+    }
+
+    /// The columns are different: comparators and sortable flags are
+    /// forgotten, and so are the sort keys of columns that are gone.
+    @Override
+    public void modelStructureChanged() {
+        comparators = null;
+        unsortable = null;
+        int columns = modelWrapper == null ? 0 : modelWrapper.getColumnCount();
+        List<SortKey> kept = new ArrayList<SortKey>();
+        for (int i = 0; i < sortKeys.size(); i++) {
+            if (sortKeys.get(i).getColumn() < columns) {
+                kept.add(sortKeys.get(i));
+            }
+        }
+        boolean keysChanged = kept.size() != sortKeys.size();
+        sortKeys = kept;
+        if (keysChanged) {
+            fireSortOrderChanged();
+        }
+        sort();
+    }
+
+    @Override
+    public void allRowsChanged() {
+        sort();
+    }
+
+    private void checkRange(int firstRow, int endRow) {
+        if (firstRow > endRow || firstRow < 0 || endRow < 0) {
+            throw new IndexOutOfBoundsException("Invalid range");
+        }
+    }
+
+    @Override
+    public void rowsInserted(int firstRow, int endRow) {
+        checkRange(firstRow, endRow);
+        if (endRow >= getModelRowCount()) {
+            throw new IndexOutOfBoundsException("Invalid range");
+        }
+        sort();
+    }
+
+    @Override
+    public void rowsDeleted(int firstRow, int endRow) {
+        checkRange(firstRow, endRow);
+        if (firstRow >= modelRowCount) {
+            throw new IndexOutOfBoundsException("Invalid range");
+        }
+        sort();
+    }
+
+    @Override
+    public void rowsUpdated(int firstRow, int endRow) {
+        checkRange(firstRow, endRow);
+        if (firstRow >= modelRowCount) {
+            throw new IndexOutOfBoundsException("Invalid range");
+        }
+        if (sortsOnUpdates) {
+            sort();
+        }
+    }
+
+    @Override
+    public void rowsUpdated(int firstRow, int endRow, int column) {
+        checkColumn(column);
+        rowsUpdated(firstRow, endRow);
+    }
+
+    /// The row a filter is shown.
+    private final class Row extends RowFilter.Entry<M, I> {
+
+        int modelIndex;
+
+        @Override
+        public M getModel() {
+            return modelWrapper.getModel();
+        }
+
+        @Override
+        public int getValueCount() {
+            return modelWrapper.getColumnCount();
+        }
+
+        @Override
+        public Object getValue(int index) {
+            return modelWrapper.getValueAt(modelIndex, index);
+        }
+
+        @Override
+        public String getStringValue(int index) {
+            return modelWrapper.getStringValueAt(modelIndex, index);
+        }
+
+        @Override
+        public I getIdentifier() {
+            return modelWrapper.getIdentifier(modelIndex);
+        }
+    }
+
+    /// How the sorter reads its model.
+    protected abstract static class ModelWrapper<M, I> {
+
+        protected ModelWrapper() {
+        }
+
+        public abstract M getModel();
+
+        public abstract int getColumnCount();
+
+        public abstract int getRowCount();
+
+        public abstract Object getValueAt(int row, int column);
+
+        public String getStringValueAt(int row, int column) {
+            Object o = getValueAt(row, column);
+            if (o == null) {
+                return "";
+            }
+            return o.toString();
+        }
+
+        public abstract I getIdentifier(int row);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultSingleSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultSingleSelectionModel.java
new file mode 100644
index 00000000000..2af81d9ee0f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DefaultSingleSelectionModel.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.EventListener;
+
+/// The usual single selection model: an index, -1 for none, and a change
+/// event each time it becomes a different one.
+public class DefaultSingleSelectionModel implements SingleSelectionModel {
+
+    protected ChangeEvent changeEvent;
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private int index = -1;
+
+    public DefaultSingleSelectionModel() {
+    }
+
+    @Override
+    public int getSelectedIndex() {
+        return index;
+    }
+
+    @Override
+    public void setSelectedIndex(int index) {
+        if (this.index != index) {
+            this.index = index;
+            fireStateChanged();
+        }
+    }
+
+    @Override
+    public void clearSelection() {
+        setSelectedIndex(-1);
+    }
+
+    @Override
+    public boolean isSelected() {
+        return index != -1;
+    }
+
+    @Override
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    @Override
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DropMode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DropMode.java
new file mode 100644
index 00000000000..b5a22393af8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/DropMode.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// How a component shows where a drag would be dropped on it, and what a
+/// `TransferHandler.DropLocation` of it says.
+public enum DropMode {
+
+    /// The selection follows the pointer and says where the drop goes.
+    USE_SELECTION,
+
+    /// The drop goes on an item.
+    ON,
+
+    /// The drop goes between items.
+    INSERT,
+
+    /// The drop goes between rows.
+    INSERT_ROWS,
+
+    /// The drop goes between columns.
+    INSERT_COLS,
+
+    /// The drop goes on an item or between items.
+    ON_OR_INSERT,
+
+    /// The drop goes on a cell or between rows.
+    ON_OR_INSERT_ROWS,
+
+    /// The drop goes on a cell or between columns.
+    ON_OR_INSERT_COLS
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/GroupLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/GroupLayout.java
new file mode 100644
index 00000000000..e7a3f8f924b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/GroupLayout.java
@@ -0,0 +1,2580 @@
+/*
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores
+ * CA 94065 USA or visit www.oracle.com if you need additional information or
+ * have any questions.
+ */
+/*
+ * Adapted for the Swing compatibility layer from
+ * CodenameOne/src/com/codename1/ui/layouts/GroupLayout.java, Codename One's
+ * port of the group layout: the method names, the alignment and placement
+ * enumerations and the size sources follow the javax.swing API, and the
+ * layout targets the layer's own java.awt component classes.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager2;
+
+/// Lays components out through two independent trees of groups, one per
+/// axis: a sequential group places its elements one after another, a
+/// parallel group places them over the same span and aligns them in it.
+///
+/// Gaps may be explicit, or asked of the [LayoutStyle] -- between two named
+/// components, between whatever components end up next to each other
+/// (`addPreferredGap(ComponentPlacement)` and `setAutoCreateGaps`), and
+/// between components and the container edge (`addContainerGap` and
+/// `setAutoCreateContainerGaps`).
+///
+/// Not supported: right to left orientation -- the horizontal axis always
+/// runs left to right. A component's baseline is honoured when
+/// `getBaseline` answers one, but a component is never stretched along its
+/// baseline: every component is treated as having the `OTHER` baseline
+/// resize behaviour, which is what a plain `java.awt.Component` reports.
+public class GroupLayout implements LayoutManager2 {
+    /// Indicates the size from the component or gap should be used.
+    public static final int DEFAULT_SIZE = -1;
+
+    /// Indicates the preferred size from the component or gap should be
+    /// used.
+    public static final int PREFERRED_SIZE = -2;
+
+    // Used in size calculations
+    private static final int MIN_SIZE = 0;
+    private static final int PREF_SIZE = 1;
+    private static final int MAX_SIZE = 2;
+    // Used by prepare, indicates min, pref or max isn't going to be used.
+    private static final int SPECIFIC_SIZE = 3;
+    private static final int UNSET = Integer.MIN_VALUE;
+
+    // The axes, as the groups know them.
+    private static final int HORIZONTAL = 1;
+    private static final int VERTICAL = 2;
+
+    // How a baseline moves as its owner is resized. The kernel's components
+    // do not say, so a component is always BRB_OTHER; the groups derive the
+    // other answers from their structure.
+    private static final int BRB_NONE = 0;
+    private static final int BRB_CONSTANT_ASCENT = 1;
+    private static final int BRB_CONSTANT_DESCENT = 2;
+    private static final int BRB_OTHER = 4;
+
+    // The gap between two components, or a component and the edge, when
+    // either is not a JComponent and the layout style cannot be asked.
+    private static final int PLAIN_COMPONENT_GAP = 10;
+
+    // Maps from Component to ComponentInfo.  This is used for tracking
+    // information specific to a Component.
+    private final Map<Component, ComponentInfo> componentInfos;
+    // Container we're doing layout for.
+    private final Container host;
+    // Used by areParallelSiblings, cached to avoid excessive garbage.
+    private final ArrayList<Spring> tmpParallelSet;
+    // Whether or not we automatically try and create the preferred
+    // padding between components.
+    private boolean autocreatePadding;
+    // Whether or not we automatically try and create the preferred
+    // padding between containers
+    private boolean autocreateContainerPadding;
+    // Group responsible for layout along the horizontal axis.  This is NOT
+    // the user specified group, use getHorizontalGroup to dig that out.
+    private Group horizontalGroup;
+    // Group responsible for layout along the vertical axis.  This is NOT
+    // the user specified group, use getVerticalGroup to dig that out.
+    private Group verticalGroup;
+    // Indicates Springs have changed in some way since last change.
+    private boolean springsChanged;
+    // Indicates invalidateLayout has been invoked.
+    private boolean isValid;
+    // Whether or not any preferred padding (or container padding) springs
+    // exist
+    private boolean hasPreferredPaddingSprings;
+    // The LayoutStyle instance to use, if null the shared instance is used.
+    private LayoutStyle layoutStyle;
+    // If true, components that are not visible are treated as though they
+    // aren't there.
+    private boolean honorsVisibility;
+
+    /// The ways a parallel group can align its elements.
+    public enum Alignment {
+        /// Aligned to the origin: the left, or the top.
+        LEADING,
+        /// Aligned to the end: the right, or the bottom.
+        TRAILING,
+        /// Centred in the span.
+        CENTER,
+        /// Aligned along the baseline; vertical axis only.
+        BASELINE
+    }
+
+    /// Creates a `GroupLayout` for the specified `Container`.
+    public GroupLayout(Container host) {
+        if (host == null) {
+            throw new IllegalArgumentException("Container must be non-null");
+        }
+        honorsVisibility = true;
+        this.host = host;
+        componentInfos = new HashMap<Component, ComponentInfo>();
+        tmpParallelSet = new ArrayList<Spring>();
+        horizontalGroup = createTopLevelGroup(createParallelGroup(Alignment.LEADING, true));
+        verticalGroup = createTopLevelGroup(createParallelGroup(Alignment.LEADING, true));
+    }
+
+    private static void checkSize(int min, int pref, int max, boolean isComponentSpring) {
+        checkResizeType(min, isComponentSpring);
+        if (!isComponentSpring && pref < 0) {
+            throw new IllegalArgumentException("Pref must be >= 0");
+        } else if (isComponentSpring) {
+            checkResizeType(pref, true);
+        }
+        checkResizeType(max, isComponentSpring);
+        checkLessThan(min, pref);
+        checkLessThan(pref, max);
+    }
+
+    private static void checkResizeType(int type, boolean isComponentSpring) {
+        if (type < 0 && ((isComponentSpring && type != DEFAULT_SIZE && type != PREFERRED_SIZE)
+                || (!isComponentSpring && type != PREFERRED_SIZE))) {
+            throw new IllegalArgumentException("Invalid size");
+        }
+    }
+
+    private static void checkLessThan(int min, int max) {
+        if (min >= 0 && max >= 0 && min > max) {
+            throw new IllegalArgumentException("Following is not met: min<=pref<=max");
+        }
+    }
+
+    /// Sets whether component visibility is considered when sizing and
+    /// positioning components. `true`, the default, leaves a component that
+    /// is not visible out of the layout.
+    public void setHonorsVisibility(boolean honorsVisibility) {
+        if (this.honorsVisibility != honorsVisibility) {
+            this.honorsVisibility = honorsVisibility;
+            springsChanged = true;
+            isValid = false;
+            invalidateHost();
+        }
+    }
+
+    /// Returns whether component visibility is considered when sizing and
+    /// positioning components.
+    public boolean getHonorsVisibility() {
+        return honorsVisibility;
+    }
+
+    /// Sets whether the visibility of one component is considered; `null`
+    /// returns the component to the value of the layout as a whole.
+    public void setHonorsVisibility(Component component, Boolean honorsVisibility) {
+        if (component == null) {
+            throw new IllegalArgumentException("Component must be non-null");
+        }
+        getComponentInfo(component).setHonorsVisibility(honorsVisibility);
+        springsChanged = true;
+        isValid = false;
+        invalidateHost();
+    }
+
+    /// Sets whether a gap between components that end up next to each
+    /// other is created automatically.
+    public void setAutoCreateGaps(boolean autoCreatePadding) {
+        if (this.autocreatePadding != autoCreatePadding) {
+            this.autocreatePadding = autoCreatePadding;
+            invalidateHost();
+        }
+    }
+
+    /// Returns `true` if gaps between components are automatically
+    /// created.
+    public boolean getAutoCreateGaps() {
+        return autocreatePadding;
+    }
+
+    /// Sets whether a gap between the container and the components that
+    /// touch its border is created automatically.
+    public void setAutoCreateContainerGaps(boolean autoCreateContainerPadding) {
+        if (this.autocreateContainerPadding != autoCreateContainerPadding) {
+            this.autocreateContainerPadding = autoCreateContainerPadding;
+            horizontalGroup = createTopLevelGroup(getHorizontalGroup());
+            verticalGroup = createTopLevelGroup(getVerticalGroup());
+            invalidateHost();
+        }
+    }
+
+    /// Returns `true` if gaps between the container and the components
+    /// that border it are automatically created.
+    public boolean getAutoCreateContainerGaps() {
+        return autocreateContainerPadding;
+    }
+
+    /// Sets the `Group` that positions and sizes components along the
+    /// horizontal axis.
+    public void setHorizontalGroup(Group group) {
+        if (group == null) {
+            throw new IllegalArgumentException("Group must be non-null");
+        }
+        horizontalGroup = createTopLevelGroup(group);
+        invalidateHost();
+    }
+
+    private Group getHorizontalGroup() {
+        int index = 0;
+        if (horizontalGroup.springs.size() > 1) {
+            index = 1;
+        }
+        return asGroup(horizontalGroup.springs.get(index));
+    }
+
+    /// Sets the `Group` that positions and sizes components along the
+    /// vertical axis.
+    public void setVerticalGroup(Group group) {
+        if (group == null) {
+            throw new IllegalArgumentException("Group must be non-null");
+        }
+        verticalGroup = createTopLevelGroup(group);
+        invalidateHost();
+    }
+
+    private Group getVerticalGroup() {
+        int index = 0;
+        if (verticalGroup.springs.size() > 1) {
+            index = 1;
+        }
+        return asGroup(verticalGroup.springs.get(index));
+    }
+
+    private static Group asGroup(Spring spring) {
+        if (spring instanceof Group) {
+            return (Group) spring;
+        }
+        throw new IllegalStateException("Not a group");
+    }
+
+    /// Wraps the user specified group in a sequential group.  If
+    /// container gaps should be generated the necessary springs are
+    /// added.
+    private Group createTopLevelGroup(Group specifiedGroup) {
+        SequentialGroup group = createSequentialGroup();
+        if (getAutoCreateContainerGaps()) {
+            group.addSpring(new ContainerAutoPreferredGapSpring());
+            group.addGroup(specifiedGroup);
+            group.addSpring(new ContainerAutoPreferredGapSpring());
+        } else {
+            group.addGroup(specifiedGroup);
+        }
+        return group;
+    }
+
+    /// Creates and returns a `SequentialGroup`.
+    public SequentialGroup createSequentialGroup() {
+        return new SequentialGroup();
+    }
+
+    /// Creates and returns a resizable `ParallelGroup` with an alignment
+    /// of `Alignment.LEADING`.
+    public ParallelGroup createParallelGroup() {
+        return createParallelGroup(Alignment.LEADING);
+    }
+
+    /// Creates and returns a resizable `ParallelGroup` with the specified
+    /// alignment.
+    public ParallelGroup createParallelGroup(Alignment alignment) {
+        return createParallelGroup(alignment, true);
+    }
+
+    /// Creates and returns a `ParallelGroup` with the specified alignment
+    /// and resize behaviour. A group that is not resizable has its
+    /// preferred size for a minimum and a maximum.
+    public ParallelGroup createParallelGroup(Alignment alignment, boolean resizable) {
+        if (alignment == null) {
+            throw new IllegalArgumentException("alignment must be non null");
+        }
+        if (alignment == Alignment.BASELINE) {
+            return new BaselineGroup(resizable);
+        }
+        return new ParallelGroup(alignment, resizable);
+    }
+
+    /// Creates and returns a `ParallelGroup` that aligns its elements
+    /// along the baseline.
+    public ParallelGroup createBaselineGroup(boolean resizable, boolean anchorBaselineToTop) {
+        return new BaselineGroup(resizable, anchorBaselineToTop);
+    }
+
+    /// Forces the specified components to have the same size regardless
+    /// of their preferred, minimum or maximum sizes: all take the largest
+    /// preferred size among them.
+    public void linkSize(Component... components) {
+        linkSize(SwingConstants.HORIZONTAL, components);
+        linkSize(SwingConstants.VERTICAL, components);
+    }
+
+    /// Forces the specified components to have the same size along the
+    /// specified axis, `SwingConstants.HORIZONTAL` or
+    /// `SwingConstants.VERTICAL`.
+    public void linkSize(int axis, Component... components) {
+        if (components == null) {
+            throw new IllegalArgumentException("Components must be non-null");
+        }
+        for (int counter = components.length - 1; counter >= 0; counter--) {
+            Component c = components[counter];
+            if (c == null) {
+                throw new IllegalArgumentException("Components must be non-null");
+            }
+            // Force the component to be added
+            getComponentInfo(c);
+        }
+        int glAxis;
+        if (axis == SwingConstants.HORIZONTAL) {
+            glAxis = HORIZONTAL;
+        } else if (axis == SwingConstants.VERTICAL) {
+            glAxis = VERTICAL;
+        } else {
+            throw new IllegalArgumentException(
+                    "Axis must be one of SwingConstants.HORIZONTAL or SwingConstants.VERTICAL");
+        }
+        if (components.length == 0) {
+            return;
+        }
+        LinkInfo master = getComponentInfo(components[components.length - 1]).getLinkInfo(glAxis);
+        for (int counter = components.length - 2; counter >= 0; counter--) {
+            master.add(getComponentInfo(components[counter]));
+        }
+        invalidateHost();
+    }
+
+    /// Replaces an existing component with a new one.
+    public void replace(Component existingComponent, Component newComponent) {
+        if (existingComponent == null || newComponent == null) {
+            throw new IllegalArgumentException("Components must be non-null");
+        }
+        // Make sure all the components have been registered, otherwise we may
+        // not update the correct Springs.
+        if (springsChanged) {
+            registerComponents(horizontalGroup, HORIZONTAL);
+            registerComponents(verticalGroup, VERTICAL);
+        }
+        ComponentInfo info = componentInfos.remove(existingComponent);
+        if (info == null) {
+            throw new IllegalArgumentException("Component must already exist");
+        }
+        host.remove(existingComponent);
+        if (newComponent.getParent() != host) {
+            host.add(newComponent);
+        }
+        info.setComponent(newComponent);
+        componentInfos.put(newComponent, info);
+        invalidateHost();
+    }
+
+    /// Sets the `LayoutStyle` used to calculate the preferred gaps between
+    /// components. `null` means the shared instance of `LayoutStyle`.
+    public void setLayoutStyle(LayoutStyle layoutStyle) {
+        this.layoutStyle = layoutStyle;
+        invalidateHost();
+    }
+
+    /// Returns the `LayoutStyle` used for calculating the preferred gap
+    /// between components, or `null` when the shared instance is used.
+    public LayoutStyle getLayoutStyle() {
+        return layoutStyle;
+    }
+
+    private LayoutStyle getLayoutStyle0() {
+        LayoutStyle style = getLayoutStyle();
+        if (style == null) {
+            style = LayoutStyle.getInstance();
+        }
+        return style;
+    }
+
+    private void invalidateHost() {
+        if (host instanceof JComponent) {
+            ((JComponent) host).revalidate();
+        } else {
+            host.invalidate();
+        }
+        host.repaint();
+    }
+
+    //
+    // LayoutManager
+    //
+
+    /// Does nothing: components are added through the groups.
+    @Override
+    public void addLayoutComponent(String name, Component component) {
+    }
+
+    /// Notification that a `Component` has been removed from the parent
+    /// container.
+    @Override
+    public void removeLayoutComponent(Component component) {
+        ComponentInfo info = componentInfos.remove(component);
+        if (info != null) {
+            info.dispose();
+            springsChanged = true;
+            isValid = false;
+        }
+    }
+
+    /// Returns the preferred size for the specified container.
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        checkParent(parent);
+        prepare(PREF_SIZE);
+        return adjustSize(horizontalGroup.getPreferredSize(HORIZONTAL), verticalGroup.getPreferredSize(VERTICAL));
+    }
+
+    /// Returns the minimum size for the specified container.
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        checkParent(parent);
+        prepare(MIN_SIZE);
+        return adjustSize(horizontalGroup.getMinimumSize(HORIZONTAL), verticalGroup.getMinimumSize(VERTICAL));
+    }
+
+    /// Lays out the specified container.
+    @Override
+    public void layoutContainer(Container parent) {
+        // Step 1: Prepare for layout.
+        prepare(SPECIFIC_SIZE);
+        Insets insets = parent.getInsets();
+        int width = parent.getWidth() - insets.left - insets.right;
+        int height = parent.getHeight() - insets.top - insets.bottom;
+        if (getAutoCreateGaps() || getAutoCreateContainerGaps() || hasPreferredPaddingSprings) {
+            // Step 2: Calculate autopadding springs
+            calculateAutopadding(horizontalGroup, HORIZONTAL, SPECIFIC_SIZE, 0, width);
+            calculateAutopadding(verticalGroup, VERTICAL, SPECIFIC_SIZE, 0, height);
+        }
+        // Step 3: set the size of the groups.
+        horizontalGroup.setSize(HORIZONTAL, 0, width);
+        verticalGroup.setSize(VERTICAL, 0, height);
+        // Step 4: apply the size to the components.
+        for (ComponentInfo info : componentInfos.values()) {
+            info.setBounds(insets);
+        }
+    }
+
+    //
+    // LayoutManager2
+    //
+
+    /// Does nothing: components are added through the groups.
+    @Override
+    public void addLayoutComponent(Component component, Object constraints) {
+    }
+
+    /// Returns the maximum size for the specified container.
+    @Override
+    public Dimension maximumLayoutSize(Container parent) {
+        checkParent(parent);
+        prepare(MAX_SIZE);
+        return adjustSize(horizontalGroup.getMaximumSize(HORIZONTAL), verticalGroup.getMaximumSize(VERTICAL));
+    }
+
+    /// Returns the alignment along the x axis, always the centre.
+    @Override
+    public float getLayoutAlignmentX(Container parent) {
+        checkParent(parent);
+        return .5f;
+    }
+
+    /// Returns the alignment along the y axis, always the centre.
+    @Override
+    public float getLayoutAlignmentY(Container parent) {
+        checkParent(parent);
+        return .5f;
+    }
+
+    /// Invalidates the layout, discarding the sizes it cached.
+    @Override
+    public void invalidateLayout(Container parent) {
+        checkParent(parent);
+        isValid = false;
+    }
+
+    private void prepare(int sizeType) {
+        boolean visChanged = false;
+        // Step 1: If not-valid, clear springs and update visibility.
+        if (!isValid) {
+            isValid = true;
+            horizontalGroup.setSize(HORIZONTAL, UNSET, UNSET);
+            verticalGroup.setSize(VERTICAL, UNSET, UNSET);
+            for (ComponentInfo ci : componentInfos.values()) {
+                if (ci.updateVisibility()) {
+                    visChanged = true;
+                }
+                ci.clearCachedSize();
+            }
+        }
+        // Step 2: Make sure components are bound to ComponentInfos
+        if (springsChanged) {
+            registerComponents(horizontalGroup, HORIZONTAL);
+            registerComponents(verticalGroup, VERTICAL);
+        }
+        // Step 3: Adjust the autopadding. This removes existing
+        // autopadding, then recalculates where it should go.
+        if (springsChanged || visChanged) {
+            checkComponents();
+            horizontalGroup.removeAutopadding();
+            verticalGroup.removeAutopadding();
+            if (getAutoCreateGaps()) {
+                insertAutopadding(true);
+            } else if (hasPreferredPaddingSprings || getAutoCreateContainerGaps()) {
+                insertAutopadding(false);
+            }
+            springsChanged = false;
+        }
+        // Step 4: (for min/pref/max size calculations only) calculate the
+        // autopadding. This invokes for unsetting the calculated values, then
+        // recalculating them.
+        // If sizeType == SPECIFIC_SIZE, it indicates we're doing layout, this
+        // step will be done later on.
+        if (sizeType != SPECIFIC_SIZE
+                && (getAutoCreateGaps() || getAutoCreateContainerGaps() || hasPreferredPaddingSprings)) {
+            calculateAutopadding(horizontalGroup, HORIZONTAL, sizeType, 0, 0);
+            calculateAutopadding(verticalGroup, VERTICAL, sizeType, 0, 0);
+        }
+    }
+
+    private void calculateAutopadding(Group group, int axis, int sizeType, int origin, int size) {
+        group.unsetAutopadding();
+        switch (sizeType) {
+            case MIN_SIZE:
+                size = group.getMinimumSize(axis);
+                break;
+            case PREF_SIZE:
+                size = group.getPreferredSize(axis);
+                break;
+            case MAX_SIZE:
+                size = group.getMaximumSize(axis);
+                break;
+            default:
+                break;
+        }
+        group.setSize(axis, origin, size);
+        group.calculateAutopadding(axis);
+    }
+
+    private void checkComponents() {
+        for (ComponentInfo info : componentInfos.values()) {
+            if (info.horizontalSpring == null) {
+                throw new IllegalStateException(info.component + " is not attached to a horizontal group");
+            }
+            if (info.verticalSpring == null) {
+                throw new IllegalStateException(info.component + " is not attached to a vertical group");
+            }
+        }
+    }
+
+    private void registerComponents(Group group, int axis) {
+        List<Spring> springs = group.springs;
+        for (int counter = springs.size() - 1; counter >= 0; counter--) {
+            Spring spring = springs.get(counter);
+            if (spring instanceof ComponentSpring) {
+                ((ComponentSpring) spring).installIfNecessary(axis);
+            } else if (spring instanceof Group) {
+                registerComponents((Group) spring, axis);
+            }
+        }
+    }
+
+    private Dimension adjustSize(int width, int height) {
+        Insets insets = host.getInsets();
+        return new Dimension(width + insets.left + insets.right, height + insets.top + insets.bottom);
+    }
+
+    private void checkParent(Container parent) {
+        if (parent != host) {
+            throw new IllegalArgumentException("GroupLayout can only be used with one Container at a time");
+        }
+    }
+
+    /// Returns the `ComponentInfo` for the specified Component,
+    /// creating one if necessary.
+    private ComponentInfo getComponentInfo(Component component) {
+        ComponentInfo info = componentInfos.get(component);
+        if (info == null) {
+            info = new ComponentInfo(component);
+            componentInfos.put(component, info);
+            if (component.getParent() != host) {
+                host.add(component);
+            }
+        }
+        return info;
+    }
+
+    /// Adjusts the autopadding springs for the horizontal and vertical
+    /// groups.  If `insert` is true this will insert auto padding
+    /// springs, otherwise this will only adjust the springs that
+    /// comprise auto preferred padding springs.
+    private void insertAutopadding(boolean insert) {
+        horizontalGroup.insertAutopadding(HORIZONTAL, new ArrayList<AutoPreferredGapSpring>(1),
+                new ArrayList<AutoPreferredGapSpring>(1), new ArrayList<ComponentSpring>(1),
+                new ArrayList<ComponentSpring>(1), insert);
+        verticalGroup.insertAutopadding(VERTICAL, new ArrayList<AutoPreferredGapSpring>(1),
+                new ArrayList<AutoPreferredGapSpring>(1), new ArrayList<ComponentSpring>(1),
+                new ArrayList<ComponentSpring>(1), insert);
+    }
+
+    /// Returns true if the two Components have a common ParallelGroup
+    /// ancestor along the particular axis.
+    private boolean areParallelSiblings(Component source, Component target, int axis) {
+        ComponentInfo sourceInfo = getComponentInfo(source);
+        ComponentInfo targetInfo = getComponentInfo(target);
+        Spring sourceSpring;
+        Spring targetSpring;
+        if (axis == HORIZONTAL) {
+            sourceSpring = sourceInfo.horizontalSpring;
+            targetSpring = targetInfo.horizontalSpring;
+        } else {
+            sourceSpring = sourceInfo.verticalSpring;
+            targetSpring = targetInfo.verticalSpring;
+        }
+        ArrayList<Spring> sourcePath = tmpParallelSet;
+        sourcePath.clear();
+        Spring spring = sourceSpring.getParent();
+        while (spring != null) {
+            sourcePath.add(spring);
+            spring = spring.getParent();
+        }
+        spring = targetSpring.getParent();
+        while (spring != null) {
+            if (containsIdentical(sourcePath, spring)) {
+                sourcePath.clear();
+                while (spring != null) {
+                    if (spring instanceof ParallelGroup) {
+                        return true;
+                    }
+                    spring = spring.getParent();
+                }
+                return false;
+            }
+            spring = spring.getParent();
+        }
+        sourcePath.clear();
+        return false;
+    }
+
+    private static boolean containsIdentical(ArrayList<Spring> list, Spring spring) {
+        for (int i = list.size() - 1; i >= 0; i--) {
+            if (list.get(i) == spring) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Used in figuring out how much space to give resizable springs.
+    private static final class SpringDelta {
+        // Original index.
+        final int index;
+        // Delta, one of pref - min or max - pref.
+        int delta;
+
+        SpringDelta(int index, int delta) {
+            this.index = index;
+            this.delta = delta;
+        }
+    }
+
+    /// Represents two springs that should have autopadding inserted between
+    /// them.
+    private static final class AutoPreferredGapMatch {
+        final ComponentSpring source;
+        final ComponentSpring target;
+
+        AutoPreferredGapMatch(ComponentSpring source, ComponentSpring target) {
+            this.source = source;
+            this.target = target;
+        }
+    }
+
+    // LinkInfo contains the set of ComponentInfos that are linked along a
+    // particular axis.
+    private static final class LinkInfo {
+        private final int axis;
+        private final List<ComponentInfo> linked;
+        private int size;
+
+        LinkInfo(int axis) {
+            linked = new ArrayList<ComponentInfo>();
+            size = UNSET;
+            this.axis = axis;
+        }
+
+        void add(ComponentInfo child) {
+            LinkInfo childMaster = child.getLinkInfo(axis, false);
+            if (childMaster == null) {
+                linked.add(child);
+                child.setLinkInfo(axis, this);
+            } else if (childMaster != this) {
+                linked.addAll(childMaster.linked);
+                for (int i = 0; i < childMaster.linked.size(); i++) {
+                    childMaster.linked.get(i).setLinkInfo(axis, this);
+                }
+            }
+            clearCachedSize();
+        }
+
+        void remove(ComponentInfo info) {
+            linked.remove(info);
+            info.setLinkInfo(axis, null);
+            if (linked.size() == 1) {
+                linked.get(0).setLinkInfo(axis, null);
+            }
+            clearCachedSize();
+        }
+
+        void clearCachedSize() {
+            size = UNSET;
+        }
+
+        int getSize(int axis) {
+            if (size == UNSET) {
+                size = calculateLinkedSize(axis);
+            }
+            return size;
+        }
+
+        private int calculateLinkedSize(int axis) {
+            int size = 0;
+            for (int i = 0; i < linked.size(); i++) {
+                ComponentInfo info = linked.get(i);
+                ComponentSpring spring;
+                if (axis == HORIZONTAL) {
+                    spring = info.horizontalSpring;
+                } else {
+                    spring = info.verticalSpring;
+                }
+                size = Math.max(size, spring.calculateNonlinkedPreferredSize(axis));
+            }
+            return size;
+        }
+    }
+
+    /// Spring consists of a range: min, pref and max, a value some where in
+    /// the middle of that, and a location.  Spring caches the
+    /// min/max/pref.  If the min/pref/max has internally changes, or needs
+    /// to be updated you must invoke clear.
+    private abstract class Spring {
+        private int size;
+        private int min;
+        private int max;
+        private int pref;
+        private Spring parent;
+
+        // Null when the spring takes the alignment of its parallel group.
+        private Alignment alignment;
+
+        Spring() {
+            min = pref = max = UNSET;
+        }
+
+        abstract int calculateMinimumSize(int axis);
+
+        abstract int calculatePreferredSize(int axis);
+
+        abstract int calculateMaximumSize(int axis);
+
+        Spring getParent() {
+            return parent;
+        }
+
+        void setParent(Spring parent) {
+            this.parent = parent;
+        }
+
+        Alignment getAlignment() {
+            return alignment;
+        }
+
+        // This is here purely as a convenience for ParallelGroup to avoid
+        // having to track alignment separately.
+        void setAlignment(Alignment alignment) {
+            this.alignment = alignment;
+        }
+
+        final int getMinimumSize(int axis) {
+            if (min == UNSET) {
+                min = constrain(calculateMinimumSize(axis));
+            }
+            return min;
+        }
+
+        final int getPreferredSize(int axis) {
+            if (pref == UNSET) {
+                pref = constrain(calculatePreferredSize(axis));
+            }
+            return pref;
+        }
+
+        final int getMaximumSize(int axis) {
+            if (max == UNSET) {
+                max = constrain(calculateMaximumSize(axis));
+            }
+            return max;
+        }
+
+        /// Resets the cached min/max/pref.
+        void unset() {
+            size = min = pref = max = UNSET;
+        }
+
+        /// Sets the value and location of the spring.  Subclasses
+        /// will want to invoke super, then do any additional sizing.
+        void setSize(int axis, int origin, int size) {
+            this.size = size;
+            if (size == UNSET) {
+                unset();
+            }
+        }
+
+        int getSize() {
+            return size;
+        }
+
+        int constrain(int value) {
+            return Math.min(value, Short.MAX_VALUE);
+        }
+
+        int getBaseline() {
+            return -1;
+        }
+
+        int getBaselineResizeBehavior() {
+            return BRB_OTHER;
+        }
+
+        final boolean isResizable(int axis) {
+            int min = getMinimumSize(axis);
+            int pref = getPreferredSize(axis);
+            return min != pref || pref != getMaximumSize(axis);
+        }
+
+        /// Returns true if this Spring will ALWAYS have a zero size. This
+        /// should NOT check the current size, rather it's meant to
+        /// quickly test if this Spring will always have a zero size.
+        abstract boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized);
+    }
+
+    /// What the two kinds of group have in common: a list of components,
+    /// gaps and other groups. Created by `createSequentialGroup` and
+    /// `createParallelGroup`.
+    public abstract class Group extends Spring {
+        List<Spring> springs;
+
+        Group() {
+            springs = new ArrayList<Spring>();
+        }
+
+        /// Adds a `Group` to this `Group`.
+        public Group addGroup(Group group) {
+            return addSpring(group);
+        }
+
+        /// Adds a `Component` to this `Group`.
+        public Group addComponent(Component component) {
+            return addComponent(component, DEFAULT_SIZE, DEFAULT_SIZE, DEFAULT_SIZE);
+        }
+
+        /// Adds a `Component` to this `Group` with the specified sizes,
+        /// each a size, `DEFAULT_SIZE` or `PREFERRED_SIZE`.
+        public Group addComponent(Component component, int min, int pref, int max) {
+            return addSpring(new ComponentSpring(component, min, pref, max));
+        }
+
+        /// Adds a rigid gap to this `Group`.
+        public Group addGap(int size) {
+            return addGap(size, size, size);
+        }
+
+        /// Adds a gap to this `Group` with the specified sizes.
+        public Group addGap(int min, int pref, int max) {
+            return addSpring(new GapSpring(min, pref, max));
+        }
+
+        Spring getSpring(int index) {
+            return springs.get(index);
+        }
+
+        int indexOf(Spring spring) {
+            return springs.indexOf(spring);
+        }
+
+        /// Adds the Spring to the list of `Spring`s and returns
+        /// the receiver.
+        Group addSpring(Spring spring) {
+            springs.add(spring);
+            spring.setParent(this);
+            if (!(spring instanceof AutoPreferredGapSpring) || !((AutoPreferredGapSpring) spring).getUserCreated()) {
+                springsChanged = true;
+            }
+            return this;
+        }
+
+        //
+        // Spring methods
+        //
+
+        @Override
+        void setSize(int axis, int origin, int size) {
+            super.setSize(axis, origin, size);
+            if (size == UNSET) {
+                for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                    getSpring(counter).setSize(axis, origin, size);
+                }
+            } else {
+                setValidSize(axis, origin, size);
+            }
+        }
+
+        /// This is invoked from `setSize` if passed a value
+        /// other than UNSET.
+        abstract void setValidSize(int axis, int origin, int size);
+
+        @Override
+        int calculateMinimumSize(int axis) {
+            return calculateSize(axis, MIN_SIZE);
+        }
+
+        @Override
+        int calculatePreferredSize(int axis) {
+            return calculateSize(axis, PREF_SIZE);
+        }
+
+        @Override
+        int calculateMaximumSize(int axis) {
+            return calculateSize(axis, MAX_SIZE);
+        }
+
+        /// Used to compute how the two values representing two springs
+        /// will be combined.  For example, a group that layed things out
+        /// one after the next would return `a + b`.
+        abstract int operator(int a, int b);
+
+        /// Calculates the specified size, combining the springs with
+        /// `operator`.
+        int calculateSize(int axis, int type) {
+            int count = springs.size();
+            if (count == 0) {
+                return 0;
+            }
+            if (count == 1) {
+                return getSpringSize(getSpring(0), axis, type);
+            }
+            int size = constrain(
+                    operator(getSpringSize(getSpring(0), axis, type), getSpringSize(getSpring(1), axis, type)));
+            for (int counter = 2; counter < count; counter++) {
+                size = constrain(operator(size, getSpringSize(getSpring(counter), axis, type)));
+            }
+            return size;
+        }
+
+        int getSpringSize(Spring spring, int axis, int type) {
+            switch (type) {
+                case MIN_SIZE:
+                    return spring.getMinimumSize(axis);
+                case PREF_SIZE:
+                    return spring.getPreferredSize(axis);
+                case MAX_SIZE:
+                    return spring.getMaximumSize(axis);
+                default:
+                    break;
+            }
+            return 0;
+        }
+
+        // Padding
+
+        /// Adjusts the autopadding springs in this group and its children.
+        /// If `insert` is true this will insert auto padding
+        /// springs, otherwise this will only adjust the springs that
+        /// comprise auto preferred padding springs.
+        ///
+        /// `leadingPadding` holds the padding springs that occur before
+        /// this group and `leading` the component springs that do; on exit
+        /// the trailing ones of this group have been added to
+        /// `trailingPadding` and `trailing`.
+        abstract void insertAutopadding(int axis, List<AutoPreferredGapSpring> leadingPadding,
+                List<AutoPreferredGapSpring> trailingPadding, List<ComponentSpring> leading,
+                List<ComponentSpring> trailing, boolean insert);
+
+        /// Removes any AutoPreferredGapSprings the layout inserted, and
+        /// resets the ones the user created.
+        void removeAutopadding() {
+            unset();
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = springs.get(counter);
+                if (spring instanceof AutoPreferredGapSpring) {
+                    if (((AutoPreferredGapSpring) spring).getUserCreated()) {
+                        ((AutoPreferredGapSpring) spring).reset();
+                    } else {
+                        springs.remove(counter);
+                    }
+                } else if (spring instanceof Group) {
+                    ((Group) spring).removeAutopadding();
+                }
+            }
+        }
+
+        void unsetAutopadding() {
+            // Clear cached pref/min/max.
+            unset();
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = springs.get(counter);
+                if (spring instanceof AutoPreferredGapSpring) {
+                    spring.unset();
+                } else if (spring instanceof Group) {
+                    ((Group) spring).unsetAutopadding();
+                }
+            }
+        }
+
+        void calculateAutopadding(int axis) {
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = springs.get(counter);
+                if (spring instanceof AutoPreferredGapSpring) {
+                    // Force size to be reset.
+                    spring.unset();
+                    ((AutoPreferredGapSpring) spring).calculatePadding(axis);
+                } else if (spring instanceof Group) {
+                    ((Group) spring).calculateAutopadding(axis);
+                }
+            }
+            // Clear cached pref/min/max.
+            unset();
+        }
+
+        @Override
+        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {
+            for (int i = springs.size() - 1; i >= 0; i--) {
+                Spring spring = springs.get(i);
+                if (!spring.willHaveZeroSize(treatAutopaddingAsZeroSized)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    /// A `Group` that positions and sizes its elements sequentially, one
+    /// after another. Created by `createSequentialGroup`.
+    public class SequentialGroup extends Group {
+        private Spring baselineSpring;
+
+        SequentialGroup() {
+        }
+
+        @Override
+        public SequentialGroup addGroup(Group group) {
+            super.addGroup(group);
+            return this;
+        }
+
+        /// Adds a `Group` to this `Group`, optionally as the element this
+        /// group takes its baseline from.
+        public SequentialGroup addGroup(boolean useAsBaseline, Group group) {
+            super.addGroup(group);
+            if (useAsBaseline) {
+                baselineSpring = group;
+            }
+            return this;
+        }
+
+        @Override
+        public SequentialGroup addComponent(Component component) {
+            super.addComponent(component);
+            return this;
+        }
+
+        /// Adds a `Component` to this `Group`, optionally as the element
+        /// this group takes its baseline from.
+        public SequentialGroup addComponent(boolean useAsBaseline, Component component) {
+            super.addComponent(component);
+            if (useAsBaseline) {
+                baselineSpring = springs.get(springs.size() - 1);
+            }
+            return this;
+        }
+
+        @Override
+        public SequentialGroup addComponent(Component component, int min, int pref, int max) {
+            super.addComponent(component, min, pref, max);
+            return this;
+        }
+
+        /// Adds a `Component` to this `Group` with the specified sizes,
+        /// optionally as the element this group takes its baseline from.
+        public SequentialGroup addComponent(boolean useAsBaseline, Component component, int min, int pref,
+                int max) {
+            super.addComponent(component, min, pref, max);
+            if (useAsBaseline) {
+                baselineSpring = springs.get(springs.size() - 1);
+            }
+            return this;
+        }
+
+        @Override
+        public SequentialGroup addGap(int size) {
+            super.addGap(size);
+            return this;
+        }
+
+        @Override
+        public SequentialGroup addGap(int min, int pref, int max) {
+            super.addGap(min, pref, max);
+            return this;
+        }
+
+        /// Adds an element representing the preferred gap between two
+        /// components, as the layout style gives it.
+        public SequentialGroup addPreferredGap(JComponent comp1, JComponent comp2,
+                LayoutStyle.ComponentPlacement type) {
+            return addPreferredGap(comp1, comp2, type, DEFAULT_SIZE, PREFERRED_SIZE);
+        }
+
+        /// Adds an element representing the preferred gap between two
+        /// components, with a preferred and a maximum size of its own.
+        public SequentialGroup addPreferredGap(JComponent comp1, JComponent comp2,
+                LayoutStyle.ComponentPlacement type, int pref, int max) {
+            if (type == null) {
+                throw new IllegalArgumentException("Type must be non-null");
+            }
+            if (comp1 == null || comp2 == null) {
+                throw new IllegalArgumentException("Components must be non-null");
+            }
+            checkPreferredGapValues(pref, max);
+            addSpring(new PreferredGapSpring(comp1, comp2, type, pref, max));
+            return this;
+        }
+
+        /// Adds an element representing the preferred gap between the
+        /// nearest components, whichever they turn out to be.
+        public SequentialGroup addPreferredGap(LayoutStyle.ComponentPlacement type) {
+            return addPreferredGap(type, DEFAULT_SIZE, DEFAULT_SIZE);
+        }
+
+        /// Adds an element representing the preferred gap between the
+        /// nearest components, with a preferred and a maximum size of its
+        /// own.
+        public SequentialGroup addPreferredGap(LayoutStyle.ComponentPlacement type, int pref, int max) {
+            if (type != LayoutStyle.ComponentPlacement.RELATED && type != LayoutStyle.ComponentPlacement.UNRELATED) {
+                throw new IllegalArgumentException(
+                        "Type must be one of LayoutStyle.ComponentPlacement.RELATED or "
+                                + "LayoutStyle.ComponentPlacement.UNRELATED");
+            }
+            checkPreferredGapValues(pref, max);
+            hasPreferredPaddingSprings = true;
+            addSpring(new AutoPreferredGapSpring(type, pref, max));
+            return this;
+        }
+
+        /// Adds an element representing the preferred gap between an edge
+        /// of the container and the components that touch it.
+        public SequentialGroup addContainerGap() {
+            return addContainerGap(DEFAULT_SIZE, DEFAULT_SIZE);
+        }
+
+        /// Adds a container gap with a preferred and a maximum size of
+        /// its own.
+        public SequentialGroup addContainerGap(int pref, int max) {
+            if ((pref < 0 && pref != DEFAULT_SIZE) || (max < 0 && max != DEFAULT_SIZE && max != PREFERRED_SIZE)
+                    || (pref >= 0 && max >= 0 && pref > max)) {
+                throw new IllegalArgumentException(
+                        "Pref and max must be either DEFAULT_VALUE or >= 0 and pref <= max");
+            }
+            hasPreferredPaddingSprings = true;
+            addSpring(new ContainerAutoPreferredGapSpring(pref, max));
+            return this;
+        }
+
+        private void checkPreferredGapValues(int pref, int max) {
+            if ((pref < 0 && pref != DEFAULT_SIZE && pref != PREFERRED_SIZE)
+                    || (max < 0 && max != DEFAULT_SIZE && max != PREFERRED_SIZE)
+                    || (pref >= 0 && max >= 0 && pref > max)) {
+                throw new IllegalArgumentException(
+                        "Pref and max must be either DEFAULT_SIZE, PREFERRED_SIZE, or >= 0 and pref <= max");
+            }
+        }
+
+        @Override
+        int operator(int a, int b) {
+            return constrain(a) + constrain(b);
+        }
+
+        @Override
+        void setValidSize(int axis, int origin, int size) {
+            int pref = getPreferredSize(axis);
+            if (size == pref) {
+                // Layout at preferred size
+                for (int counter = 0, max = springs.size(); counter < max; counter++) {
+                    Spring spring = getSpring(counter);
+                    int springPref = spring.getPreferredSize(axis);
+                    spring.setSize(axis, origin, springPref);
+                    origin += springPref;
+                }
+            } else if (springs.size() == 1) {
+                Spring spring = getSpring(0);
+                spring.setSize(axis, origin,
+                        Math.min(Math.max(size, spring.getMinimumSize(axis)), spring.getMaximumSize(axis)));
+            } else if (springs.size() > 1) {
+                // Adjust between min/pref
+                setValidSizeNotPreferred(axis, origin, size);
+            }
+        }
+
+        private void setValidSizeNotPreferred(int axis, int origin, int size) {
+            int delta = size - getPreferredSize(axis);
+            boolean useMin = delta < 0;
+            int springCount = springs.size();
+            if (useMin) {
+                delta *= -1;
+            }
+            // The following algorithm if used for resizing springs:
+            // 1. Calculate the resizability of each spring (pref - min or
+            //    max - pref) into a list.
+            // 2. Sort the list in ascending order
+            // 3. Iterate through each of the resizable Springs, attempting
+            //    to give them (pref - size) / resizeCount
+            // 4. For any Springs that can not accommodate that much space
+            //    add the remainder back to the amount to distribute and
+            //    recalculate how must space the remaining springs will get.
+            // 5. Set the size of the springs.
+
+            // First pass, sort the resizable springs into resizable
+            List<SpringDelta> resizable = buildResizableList(axis, useMin);
+            int resizableCount = resizable.size();
+            if (resizableCount > 0) {
+                // How much we would like to give each Spring.
+                int sDelta = delta / resizableCount;
+                // Remaining space.
+                int slop = delta - sDelta * resizableCount;
+                int[] sizes = new int[springCount];
+                int sign = useMin ? -1 : 1;
+                // Second pass, accumulate the resulting deltas (relative to
+                // preferred) into sizes.
+                for (int counter = 0; counter < resizableCount; counter++) {
+                    SpringDelta springDelta = resizable.get(counter);
+                    if ((counter + 1) == resizableCount) {
+                        sDelta += slop;
+                    }
+                    springDelta.delta = Math.min(sDelta, springDelta.delta);
+                    delta -= springDelta.delta;
+                    if (springDelta.delta != sDelta && counter + 1 < resizableCount) {
+                        // Spring didn't take all the space, reset how much
+                        // each spring will get.
+                        int left = resizableCount - counter - 1;
+                        sDelta = delta / left;
+                        slop = delta - sDelta * left;
+                    }
+                    sizes[springDelta.index] = sign * springDelta.delta;
+                }
+                // And finally set the size of each spring
+                for (int counter = 0; counter < springCount; counter++) {
+                    Spring spring = getSpring(counter);
+                    int sSize = spring.getPreferredSize(axis) + sizes[counter];
+                    spring.setSize(axis, origin, sSize);
+                    origin += sSize;
+                }
+            } else {
+                // Nothing resizable, use the min or max of each of the
+                // springs.
+                for (int counter = 0; counter < springCount; counter++) {
+                    Spring spring = getSpring(counter);
+                    int sSize;
+                    if (useMin) {
+                        sSize = spring.getMinimumSize(axis);
+                    } else {
+                        sSize = spring.getMaximumSize(axis);
+                    }
+                    spring.setSize(axis, origin, sSize);
+                    origin += sSize;
+                }
+            }
+        }
+
+        /// Returns the sorted list of SpringDelta's for the current set of
+        /// Springs. The list is ordered by how much each can give, least
+        /// first, and springs that give equally keep their order.
+        private List<SpringDelta> buildResizableList(int axis, boolean useMin) {
+            // First pass, figure out what is resizable
+            int size = springs.size();
+            List<SpringDelta> sorted = new ArrayList<SpringDelta>(size);
+            for (int counter = 0; counter < size; counter++) {
+                Spring spring = getSpring(counter);
+                int sDelta;
+                if (useMin) {
+                    sDelta = spring.getPreferredSize(axis) - spring.getMinimumSize(axis);
+                } else {
+                    sDelta = spring.getMaximumSize(axis) - spring.getPreferredSize(axis);
+                }
+                if (sDelta > 0) {
+                    sorted.add(new SpringDelta(counter, sDelta));
+                }
+            }
+            // A stable insertion sort; the list is short.
+            for (int i = 1; i < sorted.size(); i++) {
+                SpringDelta moving = sorted.get(i);
+                int j = i - 1;
+                while (j >= 0 && sorted.get(j).delta > moving.delta) {
+                    sorted.set(j + 1, sorted.get(j));
+                    j--;
+                }
+                sorted.set(j + 1, moving);
+            }
+            return sorted;
+        }
+
+        private int indexOfNextNonZeroSpring(int index, boolean treatAutopaddingAsZeroSized) {
+            while (index < springs.size()) {
+                Spring spring = springs.get(index);
+                if (!spring.willHaveZeroSize(treatAutopaddingAsZeroSized)) {
+                    return index;
+                }
+                index++;
+            }
+            return index;
+        }
+
+        @Override
+        void insertAutopadding(int axis, List<AutoPreferredGapSpring> leadingPadding,
+                List<AutoPreferredGapSpring> trailingPadding, List<ComponentSpring> leading,
+                List<ComponentSpring> trailing, boolean insert) {
+            List<AutoPreferredGapSpring> newLeadingPadding = new ArrayList<AutoPreferredGapSpring>(leadingPadding);
+            List<AutoPreferredGapSpring> newTrailingPadding = new ArrayList<AutoPreferredGapSpring>(1);
+            List<ComponentSpring> newLeading = new ArrayList<ComponentSpring>(leading);
+            List<ComponentSpring> newTrailing = null;
+            int counter = 0;
+            // Warning, this must use springs.size, as it may change during the
+            // loop.
+            while (counter < springs.size()) {
+                Spring spring = getSpring(counter);
+                if (spring instanceof AutoPreferredGapSpring) {
+                    if (newLeadingPadding.isEmpty()) {
+                        // Autopadding spring. Set the sources of the
+                        // autopadding spring based on newLeading.
+                        AutoPreferredGapSpring padding = (AutoPreferredGapSpring) spring;
+                        padding.setSources(newLeading);
+                        newLeading.clear();
+                        counter = indexOfNextNonZeroSpring(counter + 1, true);
+                        if (counter == springs.size()) {
+                            // Last spring in the list, add it to
+                            // trailingPadding.
+                            if (!(padding instanceof ContainerAutoPreferredGapSpring)) {
+                                trailingPadding.add(padding);
+                            }
+                        } else {
+                            newLeadingPadding.clear();
+                            newLeadingPadding.add(padding);
+                        }
+                    } else {
+                        counter = indexOfNextNonZeroSpring(counter + 1, true);
+                    }
+                } else {
+                    // Not a padding spring
+                    if (!newLeading.isEmpty() && insert) {
+                        // There's leading ComponentSprings, create an
+                        // autopadding spring.
+                        AutoPreferredGapSpring padding = new AutoPreferredGapSpring();
+                        // Force the newly created spring to be considered
+                        // by NOT incrementing counter
+                        springs.add(counter, padding);
+                        continue;
+                    }
+                    if (spring instanceof ComponentSpring) {
+                        // Spring is a Component, make it the target of any
+                        // leading AutopaddingSpring.
+                        ComponentSpring cSpring = (ComponentSpring) spring;
+                        if (!cSpring.isVisible()) {
+                            counter++;
+                            continue;
+                        }
+                        for (int i = 0; i < newLeadingPadding.size(); i++) {
+                            newLeadingPadding.get(i).addTarget(cSpring, axis);
+                        }
+                        newLeading.clear();
+                        newLeadingPadding.clear();
+                        counter = indexOfNextNonZeroSpring(counter + 1, false);
+                        if (counter == springs.size()) {
+                            // Last Spring, add it to trailing
+                            trailing.add(cSpring);
+                        } else {
+                            // Not that last Spring, add it to leading
+                            newLeading.add(cSpring);
+                        }
+                    } else if (spring instanceof Group) {
+                        // Forward call to child Group
+                        if (newTrailing == null) {
+                            newTrailing = new ArrayList<ComponentSpring>(1);
+                        } else {
+                            newTrailing.clear();
+                        }
+                        newTrailingPadding.clear();
+                        ((Group) spring).insertAutopadding(axis, newLeadingPadding, newTrailingPadding, newLeading,
+                                newTrailing, insert);
+                        newLeading.clear();
+                        newLeadingPadding.clear();
+                        counter = indexOfNextNonZeroSpring(counter + 1, newTrailing.isEmpty());
+                        if (counter == springs.size()) {
+                            trailing.addAll(newTrailing);
+                            trailingPadding.addAll(newTrailingPadding);
+                        } else {
+                            newLeading.addAll(newTrailing);
+                            newLeadingPadding.addAll(newTrailingPadding);
+                        }
+                    } else {
+                        // Gap
+                        newLeadingPadding.clear();
+                        newLeading.clear();
+                        counter++;
+                    }
+                }
+            }
+        }
+
+        @Override
+        int getBaseline() {
+            if (baselineSpring != null) {
+                int baseline = baselineSpring.getBaseline();
+                if (baseline >= 0) {
+                    int size = 0;
+                    for (int i = 0, max = springs.size(); i < max; i++) {
+                        Spring spring = getSpring(i);
+                        if (spring == baselineSpring) {
+                            return size + baseline;
+                        } else {
+                            size += spring.getPreferredSize(VERTICAL);
+                        }
+                    }
+                }
+            }
+            return -1;
+        }
+
+        @Override
+        int getBaselineResizeBehavior() {
+            if (isResizable(VERTICAL)) {
+                if (baselineSpring != null && !baselineSpring.isResizable(VERTICAL)) {
+                    // Spring to use for baseline isn't resizable. In this case
+                    // baseline resize behavior can be determined based on how
+                    // preceding springs resize.
+                    boolean leadingResizable = false;
+                    for (int i = 0, max = springs.size(); i < max; i++) {
+                        Spring spring = getSpring(i);
+                        if (spring == baselineSpring) {
+                            break;
+                        } else if (spring.isResizable(VERTICAL)) {
+                            leadingResizable = true;
+                            break;
+                        }
+                    }
+                    boolean trailingResizable = false;
+                    for (int i = springs.size() - 1; i >= 0; i--) {
+                        Spring spring = getSpring(i);
+                        if (spring == baselineSpring) {
+                            break;
+                        }
+                        if (spring.isResizable(VERTICAL)) {
+                            trailingResizable = true;
+                            break;
+                        }
+                    }
+                    if (leadingResizable && !trailingResizable) {
+                        return BRB_CONSTANT_DESCENT;
+                    } else if (!leadingResizable && trailingResizable) {
+                        return BRB_CONSTANT_ASCENT;
+                    }
+                    // If we get here, both leading and trailing springs are
+                    // resizable. Fall through to OTHER.
+                } else {
+                    int brb = BRB_NONE;
+                    if (baselineSpring != null) {
+                        brb = baselineSpring.getBaselineResizeBehavior();
+                    }
+                    if (brb == BRB_CONSTANT_ASCENT) {
+                        for (int i = 0, max = springs.size(); i < max; i++) {
+                            Spring spring = getSpring(i);
+                            if (spring == baselineSpring) {
+                                return BRB_CONSTANT_ASCENT;
+                            }
+                            if (spring.isResizable(VERTICAL)) {
+                                return BRB_OTHER;
+                            }
+                        }
+                    } else if (brb == BRB_CONSTANT_DESCENT) {
+                        for (int i = springs.size() - 1; i >= 0; i--) {
+                            Spring spring = getSpring(i);
+                            if (spring == baselineSpring) {
+                                return BRB_CONSTANT_DESCENT;
+                            }
+                            if (spring.isResizable(VERTICAL)) {
+                                return BRB_OTHER;
+                            }
+                        }
+                    }
+                }
+                return BRB_OTHER;
+            }
+            // Not resizable, treat as constant_ascent
+            return BRB_CONSTANT_ASCENT;
+        }
+    }
+
+    /// A `Group` that aligns and sizes its children over the same span.
+    /// Created by `createParallelGroup` and `createBaselineGroup`.
+    public class ParallelGroup extends Group {
+        // How children are layed out.
+        private final Alignment childAlignment;
+        // Whether or not we're resizable.
+        private final boolean resizable;
+
+        ParallelGroup(Alignment childAlignment, boolean resizable) {
+            this.childAlignment = childAlignment;
+            this.resizable = resizable;
+        }
+
+        @Override
+        public ParallelGroup addGroup(Group group) {
+            super.addGroup(group);
+            return this;
+        }
+
+        @Override
+        public ParallelGroup addComponent(Component component) {
+            super.addComponent(component);
+            return this;
+        }
+
+        @Override
+        public ParallelGroup addComponent(Component component, int min, int pref, int max) {
+            super.addComponent(component, min, pref, max);
+            return this;
+        }
+
+        @Override
+        public ParallelGroup addGap(int pref) {
+            super.addGap(pref);
+            return this;
+        }
+
+        @Override
+        public ParallelGroup addGap(int min, int pref, int max) {
+            super.addGap(min, pref, max);
+            return this;
+        }
+
+        /// Adds a `Group` to this `ParallelGroup` with an alignment of
+        /// its own.
+        public ParallelGroup addGroup(Alignment alignment, Group group) {
+            checkChildAlignment(alignment);
+            group.setAlignment(alignment);
+            addSpring(group);
+            return this;
+        }
+
+        /// Adds a `Component` to this `ParallelGroup` with an alignment
+        /// of its own.
+        public ParallelGroup addComponent(Component component, Alignment alignment) {
+            return addComponent(component, alignment, DEFAULT_SIZE, DEFAULT_SIZE, DEFAULT_SIZE);
+        }
+
+        /// Adds a `Component` to this `ParallelGroup` with an alignment
+        /// and sizes of its own.
+        public ParallelGroup addComponent(Component component, Alignment alignment, int min, int pref, int max) {
+            checkChildAlignment(alignment);
+            ComponentSpring spring = new ComponentSpring(component, min, pref, max);
+            spring.setAlignment(alignment);
+            addSpring(spring);
+            return this;
+        }
+
+        boolean isResizable() {
+            return resizable;
+        }
+
+        @Override
+        int operator(int a, int b) {
+            return Math.max(a, b);
+        }
+
+        @Override
+        int calculateMinimumSize(int axis) {
+            if (!isResizable()) {
+                return getPreferredSize(axis);
+            }
+            return super.calculateMinimumSize(axis);
+        }
+
+        @Override
+        int calculateMaximumSize(int axis) {
+            if (!isResizable()) {
+                return getPreferredSize(axis);
+            }
+            return super.calculateMaximumSize(axis);
+        }
+
+        @Override
+        void setValidSize(int axis, int origin, int size) {
+            for (int i = 0, max = springs.size(); i < max; i++) {
+                setChildSize(getSpring(i), axis, origin, size);
+            }
+        }
+
+        void setChildSize(Spring spring, int axis, int origin, int size) {
+            Alignment alignment = spring.getAlignment();
+            int springSize = Math.min(Math.max(spring.getMinimumSize(axis), size), spring.getMaximumSize(axis));
+            if (alignment == null) {
+                alignment = childAlignment;
+            }
+            if (alignment == Alignment.TRAILING) {
+                spring.setSize(axis, origin + size - springSize, springSize);
+            } else if (alignment == Alignment.CENTER) {
+                spring.setSize(axis, origin + (size - springSize) / 2, springSize);
+            } else {
+                // LEADING, or BASELINE
+                spring.setSize(axis, origin, springSize);
+            }
+        }
+
+        @Override
+        void insertAutopadding(int axis, List<AutoPreferredGapSpring> leadingPadding,
+                List<AutoPreferredGapSpring> trailingPadding, List<ComponentSpring> leading,
+                List<ComponentSpring> trailing, boolean insert) {
+            for (int counter = 0, max = springs.size(); counter < max; counter++) {
+                Spring spring = getSpring(counter);
+                if (spring instanceof ComponentSpring) {
+                    ComponentSpring cSpring = (ComponentSpring) spring;
+                    if (cSpring.isVisible()) {
+                        for (int i = 0; i < leadingPadding.size(); i++) {
+                            leadingPadding.get(i).addTarget(cSpring, axis);
+                        }
+                        trailing.add(cSpring);
+                    }
+                } else if (spring instanceof Group) {
+                    ((Group) spring).insertAutopadding(axis, leadingPadding, trailingPadding, leading, trailing,
+                            insert);
+                } else if (spring instanceof AutoPreferredGapSpring) {
+                    AutoPreferredGapSpring padding = (AutoPreferredGapSpring) spring;
+                    padding.setSources(leading);
+                    trailingPadding.add(padding);
+                }
+            }
+        }
+
+        private void checkChildAlignment(Alignment alignment) {
+            boolean allowsBaseline = this instanceof BaselineGroup;
+            if (alignment == null) {
+                throw new IllegalArgumentException("Alignment must be non-null");
+            }
+            if (!allowsBaseline && alignment == Alignment.BASELINE) {
+                throw new IllegalArgumentException("Alignment must be one of:LEADING, TRAILING or CENTER");
+            }
+        }
+    }
+
+    /// An extension of `ParallelGroup` that aligns its
+    /// constituent `Spring`s along the baseline.
+    private class BaselineGroup extends ParallelGroup {
+        // Whether or not all child springs have a baseline
+        private boolean allSpringsHaveBaseline;
+        // max(spring.getBaseline()) of all springs aligned along the baseline
+        // that have a baseline
+        private int prefAscent;
+        // max(spring.getPreferredSize().height - spring.getBaseline()) of all
+        // springs aligned along the baseline that have a baseline
+        private int prefDescent;
+        // Whether baselineAnchoredToTop was explicitly set
+        private boolean baselineAnchorSet;
+        // Whether the baseline is anchored to the top or the bottom.
+        // If anchored to the top the baseline is always at prefAscent,
+        // otherwise the baseline is at (height - prefDescent)
+        private boolean baselineAnchoredToTop;
+        // Whether or not the baseline has been calculated.
+        private boolean calcedBaseline;
+
+        BaselineGroup(boolean resizable) {
+            super(Alignment.LEADING, resizable);
+            prefAscent = prefDescent = -1;
+            calcedBaseline = false;
+        }
+
+        BaselineGroup(boolean resizable, boolean baselineAnchoredToTop) {
+            this(resizable);
+            this.baselineAnchoredToTop = baselineAnchoredToTop;
+            baselineAnchorSet = true;
+        }
+
+        @Override
+        void unset() {
+            super.unset();
+            prefAscent = prefDescent = -1;
+            calcedBaseline = false;
+        }
+
+        @Override
+        void setValidSize(int axis, int origin, int size) {
+            checkAxis(axis);
+            if (prefAscent == -1) {
+                super.setValidSize(axis, origin, size);
+            } else {
+                // do baseline layout
+                baselineLayout(origin, size);
+            }
+        }
+
+        @Override
+        int calculateSize(int axis, int type) {
+            checkAxis(axis);
+            if (!calcedBaseline) {
+                calculateBaselineAndResizeBehavior();
+            }
+            if (type == MIN_SIZE) {
+                return calculateMinSize();
+            }
+            if (type == MAX_SIZE) {
+                return calculateMaxSize();
+            }
+            if (allSpringsHaveBaseline) {
+                return prefAscent + prefDescent;
+            }
+            return Math.max(prefAscent + prefDescent, super.calculateSize(axis, type));
+        }
+
+        private boolean alignsOnBaseline(Spring spring) {
+            return spring.getAlignment() == null || spring.getAlignment() == Alignment.BASELINE;
+        }
+
+        private void calculateBaselineAndResizeBehavior() {
+            // calculate baseline
+            prefAscent = 0;
+            prefDescent = 0;
+            int baselineSpringCount = 0;
+            int resizeBehavior = BRB_NONE;
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = getSpring(counter);
+                if (alignsOnBaseline(spring)) {
+                    int baseline = spring.getBaseline();
+                    if (baseline >= 0) {
+                        if (spring.isResizable(VERTICAL)) {
+                            int brb = spring.getBaselineResizeBehavior();
+                            if (resizeBehavior == BRB_NONE) {
+                                resizeBehavior = brb;
+                            } else if (brb != resizeBehavior) {
+                                resizeBehavior = BRB_CONSTANT_ASCENT;
+                            }
+                        }
+                        prefAscent = Math.max(prefAscent, baseline);
+                        prefDescent = Math.max(prefDescent, spring.getPreferredSize(VERTICAL) - baseline);
+                        baselineSpringCount++;
+                    }
+                }
+            }
+            if (!baselineAnchorSet) {
+                this.baselineAnchoredToTop = resizeBehavior != BRB_CONSTANT_DESCENT;
+            }
+            allSpringsHaveBaseline = baselineSpringCount == springs.size();
+            calcedBaseline = true;
+        }
+
+        private int calculateMaxSize() {
+            int maxAscent = prefAscent;
+            int maxDescent = prefDescent;
+            int nonBaselineMax = 0;
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = getSpring(counter);
+                int springMax = spring.getMaximumSize(VERTICAL);
+                int baseline = alignsOnBaseline(spring) ? spring.getBaseline() : -1;
+                if (baseline >= 0) {
+                    int springPref = spring.getPreferredSize(VERTICAL);
+                    if (springPref != springMax) {
+                        int brb = spring.getBaselineResizeBehavior();
+                        if (brb == BRB_CONSTANT_ASCENT) {
+                            if (baselineAnchoredToTop) {
+                                maxDescent = Math.max(maxDescent, springMax - baseline);
+                            }
+                        } else if (brb == BRB_CONSTANT_DESCENT) {
+                            if (!baselineAnchoredToTop) {
+                                maxAscent = Math.max(maxAscent, springMax - springPref + baseline);
+                            }
+                        }
+                        // CENTER_OFFSET and OTHER, not resizable
+                    }
+                } else {
+                    // Not aligned along the baseline, or no baseline.
+                    nonBaselineMax = Math.max(nonBaselineMax, springMax);
+                }
+            }
+            return Math.max(nonBaselineMax, maxAscent + maxDescent);
+        }
+
+        private int calculateMinSize() {
+            int minAscent = 0;
+            int minDescent = 0;
+            int nonBaselineMin = 0;
+            if (baselineAnchoredToTop) {
+                minAscent = prefAscent;
+            } else {
+                minDescent = prefDescent;
+            }
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = getSpring(counter);
+                int springMin = spring.getMinimumSize(VERTICAL);
+                int baseline = alignsOnBaseline(spring) ? spring.getBaseline() : -1;
+                if (baseline >= 0) {
+                    int springPref = spring.getPreferredSize(VERTICAL);
+                    int brb = spring.getBaselineResizeBehavior();
+                    if (brb == BRB_CONSTANT_ASCENT) {
+                        if (baselineAnchoredToTop) {
+                            minDescent = Math.max(springMin - baseline, minDescent);
+                        } else {
+                            minAscent = Math.max(baseline, minAscent);
+                        }
+                    } else if (brb == BRB_CONSTANT_DESCENT) {
+                        if (!baselineAnchoredToTop) {
+                            minAscent = Math.max(baseline - (springPref - springMin), minAscent);
+                        } else {
+                            minDescent = Math.max(springPref - baseline, minDescent);
+                        }
+                    } else {
+                        // CENTER_OFFSET and OTHER are !resizable, use
+                        // the preferred size.
+                        minAscent = Math.max(baseline, minAscent);
+                        minDescent = Math.max(springPref - baseline, minDescent);
+                    }
+                } else {
+                    // Not aligned along the baseline, or no baseline.
+                    nonBaselineMin = Math.max(nonBaselineMin, springMin);
+                }
+            }
+            return Math.max(nonBaselineMin, minAscent + minDescent);
+        }
+
+        /// Lays out springs that have a baseline along the baseline.  All
+        /// others are centered.
+        private void baselineLayout(int origin, int size) {
+            int ascent;
+            int descent;
+            if (baselineAnchoredToTop) {
+                ascent = prefAscent;
+                descent = size - ascent;
+            } else {
+                ascent = size - prefDescent;
+                descent = prefDescent;
+            }
+            for (int counter = springs.size() - 1; counter >= 0; counter--) {
+                Spring spring = getSpring(counter);
+                int baseline = alignsOnBaseline(spring) ? spring.getBaseline() : -1;
+                if (baseline >= 0) {
+                    int springMax = spring.getMaximumSize(VERTICAL);
+                    int springPref = spring.getPreferredSize(VERTICAL);
+                    int height = springPref;
+                    int y;
+                    int brb = spring.getBaselineResizeBehavior();
+                    if (brb == BRB_CONSTANT_ASCENT) {
+                        y = origin + ascent - baseline;
+                        height = Math.min(descent, springMax - baseline) + baseline;
+                    } else if (brb == BRB_CONSTANT_DESCENT) {
+                        height = Math.min(ascent, springMax - springPref + baseline) + (springPref - baseline);
+                        y = origin + ascent + (springPref - baseline) - height;
+                    } else {
+                        // CENTER_OFFSET & OTHER, not resizable
+                        y = origin + ascent - baseline;
+                    }
+                    spring.setSize(VERTICAL, y, height);
+                } else {
+                    setChildSize(spring, VERTICAL, origin, size);
+                }
+            }
+        }
+
+        @Override
+        int getBaseline() {
+            if (springs.size() > 1) {
+                // Force the baseline to be calculated
+                getPreferredSize(VERTICAL);
+                return prefAscent;
+            } else if (springs.size() == 1) {
+                return getSpring(0).getBaseline();
+            }
+            return -1;
+        }
+
+        @Override
+        int getBaselineResizeBehavior() {
+            if (springs.size() == 1) {
+                return getSpring(0).getBaselineResizeBehavior();
+            }
+            if (baselineAnchoredToTop) {
+                return BRB_CONSTANT_ASCENT;
+            }
+            return BRB_CONSTANT_DESCENT;
+        }
+
+        // If the axis is HORIZONTAL, throws an IllegalStateException
+        private void checkAxis(int axis) {
+            if (axis == HORIZONTAL) {
+                throw new IllegalStateException("Baseline must be used along vertical axis");
+            }
+        }
+    }
+
+    private final class ComponentSpring extends Spring {
+        // min/pref/max are either a value >= 0 or one of
+        // DEFAULT_SIZE or PREFERRED_SIZE
+        private final int min;
+        private final int pref;
+        private final int max;
+        private Component component;
+        private int origin;
+        // Baseline for the component, computed as necessary.
+        private int baseline = -1;
+        // Whether or not the size has been requested yet.
+        private boolean installed;
+
+        ComponentSpring(Component component, int min, int pref, int max) {
+            this.component = component;
+            if (component == null) {
+                throw new IllegalArgumentException("Component must be non-null");
+            }
+            checkSize(min, pref, max, true);
+            this.min = min;
+            this.max = max;
+            this.pref = pref;
+            // getComponentInfo makes sure component is a child of the
+            // Container GroupLayout is the LayoutManager for.
+            getComponentInfo(component);
+        }
+
+        @Override
+        int calculateMinimumSize(int axis) {
+            if (isLinked(axis)) {
+                return getLinkSize(axis);
+            }
+            return calculateNonlinkedMinimumSize(axis);
+        }
+
+        @Override
+        int calculatePreferredSize(int axis) {
+            if (isLinked(axis)) {
+                return getLinkSize(axis);
+            }
+            int min = getMinimumSize(axis);
+            int pref = calculateNonlinkedPreferredSize(axis);
+            int max = getMaximumSize(axis);
+            return Math.min(max, Math.max(min, pref));
+        }
+
+        @Override
+        int calculateMaximumSize(int axis) {
+            if (isLinked(axis)) {
+                return getLinkSize(axis);
+            }
+            return Math.max(getMinimumSize(axis), calculateNonlinkedMaximumSize(axis));
+        }
+
+        boolean isVisible() {
+            return getComponentInfo(getComponent()).isVisible();
+        }
+
+        int calculateNonlinkedMinimumSize(int axis) {
+            if (!isVisible()) {
+                return 0;
+            }
+            if (min >= 0) {
+                return min;
+            }
+            if (min == PREFERRED_SIZE) {
+                return calculateNonlinkedPreferredSize(axis);
+            }
+            return getSizeAlongAxis(axis, component.getMinimumSize());
+        }
+
+        int calculateNonlinkedPreferredSize(int axis) {
+            if (!isVisible()) {
+                return 0;
+            }
+            if (pref >= 0) {
+                return pref;
+            }
+            return getSizeAlongAxis(axis, component.getPreferredSize());
+        }
+
+        int calculateNonlinkedMaximumSize(int axis) {
+            if (!isVisible()) {
+                return 0;
+            }
+            if (max >= 0) {
+                return max;
+            }
+            if (max == PREFERRED_SIZE) {
+                return calculateNonlinkedPreferredSize(axis);
+            }
+            return getSizeAlongAxis(axis, component.getMaximumSize());
+        }
+
+        private int getSizeAlongAxis(int axis, Dimension size) {
+            return (axis == HORIZONTAL) ? size.width : size.height;
+        }
+
+        private int getLinkSize(int axis) {
+            if (!isVisible()) {
+                return 0;
+            }
+            return getComponentInfo(component).getLinkSize(axis);
+        }
+
+        @Override
+        void setSize(int axis, int origin, int size) {
+            super.setSize(axis, origin, size);
+            this.origin = origin;
+            if (size == UNSET) {
+                baseline = -1;
+            }
+        }
+
+        int getOrigin() {
+            return origin;
+        }
+
+        Component getComponent() {
+            return component;
+        }
+
+        void setComponent(Component component) {
+            this.component = component;
+        }
+
+        @Override
+        int getBaseline() {
+            if (baseline == -1) {
+                Spring horizontalSpring = getComponentInfo(component).horizontalSpring;
+                int width = horizontalSpring.getPreferredSize(HORIZONTAL);
+                int height = getPreferredSize(VERTICAL);
+                if (width > 0 && height > 0) {
+                    baseline = component.getBaseline(width, height);
+                }
+            }
+            return baseline;
+        }
+
+        private boolean isLinked(int axis) {
+            return getComponentInfo(component).isLinked(axis);
+        }
+
+        void installIfNecessary(int axis) {
+            if (!installed) {
+                installed = true;
+                if (axis == HORIZONTAL) {
+                    getComponentInfo(component).horizontalSpring = this;
+                } else {
+                    getComponentInfo(component).verticalSpring = this;
+                }
+            }
+        }
+
+        @Override
+        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {
+            return !isVisible();
+        }
+    }
+
+    /// Spring representing the preferred distance between two components.
+    private final class PreferredGapSpring extends Spring {
+        private final JComponent source;
+        private final JComponent target;
+        private final LayoutStyle.ComponentPlacement type;
+        private final int pref;
+        private final int max;
+
+        PreferredGapSpring(JComponent source, JComponent target, LayoutStyle.ComponentPlacement type, int pref,
+                int max) {
+            this.source = source;
+            this.target = target;
+            this.type = type;
+            this.pref = pref;
+            this.max = max;
+        }
+
+        @Override
+        int calculateMinimumSize(int axis) {
+            return getPadding(axis);
+        }
+
+        @Override
+        int calculatePreferredSize(int axis) {
+            if (pref == DEFAULT_SIZE || pref == PREFERRED_SIZE) {
+                return getMinimumSize(axis);
+            }
+            int min = getMinimumSize(axis);
+            int max = getMaximumSize(axis);
+            return Math.min(max, Math.max(min, pref));
+        }
+
+        @Override
+        int calculateMaximumSize(int axis) {
+            if (max == PREFERRED_SIZE || max == DEFAULT_SIZE) {
+                return getPadding(axis);
+            }
+            return Math.max(getMinimumSize(axis), max);
+        }
+
+        private int getPadding(int axis) {
+            int position;
+            if (axis == HORIZONTAL) {
+                position = SwingConstants.EAST;
+            } else {
+                position = SwingConstants.SOUTH;
+            }
+            return getLayoutStyle0().getPreferredGap(source, target, type, position, host);
+        }
+
+        @Override
+        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {
+            return false;
+        }
+    }
+
+    /// Spring represented a certain amount of space.
+    private final class GapSpring extends Spring {
+        private final int min;
+        private final int pref;
+        private final int max;
+
+        GapSpring(int min, int pref, int max) {
+            checkSize(min, pref, max, false);
+            this.min = min;
+            this.pref = pref;
+            this.max = max;
+        }
+
+        @Override
+        int calculateMinimumSize(int axis) {
+            if (min == PREFERRED_SIZE) {
+                return getPreferredSize(axis);
+            }
+            return min;
+        }
+
+        @Override
+        int calculatePreferredSize(int axis) {
+            return pref;
+        }
+
+        @Override
+        int calculateMaximumSize(int axis) {
+            if (max == PREFERRED_SIZE) {
+                return getPreferredSize(axis);
+            }
+            return max;
+        }
+
+        @Override
+        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {
+            return false;
+        }
+    }
+
+    /// Spring reprensenting the distance between any number of sources and
+    /// targets.  The targets and sources are computed during layout.  An
+    /// instance of this can either be dynamically created when
+    /// autocreatePadding is true, or explicitly created by the developer.
+    private class AutoPreferredGapSpring extends Spring {
+        private final int pref;
+        private final int max;
+        List<ComponentSpring> sources;
+        int size;
+        int lastSize;
+        private List<AutoPreferredGapMatch> matches;
+        private LayoutStyle.ComponentPlacement type;
+        private boolean userCreated;
+
+        AutoPreferredGapSpring() {
+            this.pref = PREFERRED_SIZE;
+            this.max = PREFERRED_SIZE;
+            this.type = LayoutStyle.ComponentPlacement.RELATED;
+        }
+
+        AutoPreferredGapSpring(int pref, int max) {
+            this.pref = pref;
+            this.max = max;
+        }
+
+        AutoPreferredGapSpring(LayoutStyle.ComponentPlacement type, int pref, int max) {
+            this.type = type;
+            this.pref = pref;
+            this.max = max;
+            this.userCreated = true;
+        }
+
+        void setSources(List<ComponentSpring> sources) {
+            this.sources = new ArrayList<ComponentSpring>(sources);
+        }
+
+        boolean getUserCreated() {
+            return userCreated;
+        }
+
+        void setUserCreated(boolean userCreated) {
+            this.userCreated = userCreated;
+        }
+
+        @Override
+        void unset() {
+            lastSize = getSize();
+            super.unset();
+            size = 0;
+        }
+
+        void reset() {
+            size = 0;
+            sources = null;
+            matches = null;
+        }
+
+        void calculatePadding(int axis) {
+            size = UNSET;
+            int maxPadding = UNSET;
+            if (matches != null) {
+                LayoutStyle p = getLayoutStyle0();
+                int position;
+                if (axis == HORIZONTAL) {
+                    position = SwingConstants.EAST;
+                } else {
+                    position = SwingConstants.SOUTH;
+                }
+                for (int i = matches.size() - 1; i >= 0; i--) {
+                    AutoPreferredGapMatch match = matches.get(i);
+                    maxPadding = Math.max(maxPadding, calculatePadding(p, position, match.source, match.target));
+                }
+            }
+            if (size == UNSET) {
+                size = 0;
+            }
+            if (maxPadding == UNSET) {
+                maxPadding = 0;
+            }
+            if (lastSize != UNSET) {
+                size += Math.min(maxPadding, lastSize);
+            }
+        }
+
+        private int calculatePadding(LayoutStyle p, int position, ComponentSpring source, ComponentSpring target) {
+            int delta = target.getOrigin() - (source.getOrigin() + source.getSize());
+            if (delta >= 0) {
+                int padding;
+                Component a = source.getComponent();
+                Component b = target.getComponent();
+                if (a instanceof JComponent && b instanceof JComponent) {
+                    padding = p.getPreferredGap((JComponent) a, (JComponent) b, type, position, host);
+                } else {
+                    padding = PLAIN_COMPONENT_GAP;
+                }
+                if (padding > delta) {
+                    size = Math.max(size, padding - delta);
+                }
+                return padding;
+            }
+            return 0;
+        }
+
+        void addTarget(ComponentSpring spring, int axis) {
+            int oAxis = (axis == HORIZONTAL) ? VERTICAL : HORIZONTAL;
+            List<ComponentSpring> from = sources;
+            if (from == null) {
+                return;
+            }
+            Component component = spring.getComponent();
+            for (int counter = from.size() - 1; counter >= 0; counter--) {
+                ComponentSpring candidate = from.get(counter);
+                if (areParallelSiblings(candidate.getComponent(), component, oAxis)) {
+                    addValidTarget(candidate, spring);
+                }
+            }
+        }
+
+        private void addValidTarget(ComponentSpring source, ComponentSpring target) {
+            if (matches == null) {
+                matches = new ArrayList<AutoPreferredGapMatch>(1);
+            }
+            matches.add(new AutoPreferredGapMatch(source, target));
+        }
+
+        @Override
+        int calculateMinimumSize(int axis) {
+            return size;
+        }
+
+        @Override
+        int calculatePreferredSize(int axis) {
+            if (pref == PREFERRED_SIZE || pref == DEFAULT_SIZE) {
+                return size;
+            }
+            return Math.max(size, pref);
+        }
+
+        @Override
+        int calculateMaximumSize(int axis) {
+            if (max >= 0) {
+                return Math.max(getPreferredSize(axis), max);
+            }
+            return size;
+        }
+
+        @Override
+        boolean willHaveZeroSize(boolean treatAutopaddingAsZeroSized) {
+            return treatAutopaddingAsZeroSized;
+        }
+    }
+
+    /// An extension of AutoPreferredGapSpring used for container level
+    /// padding.
+    private final class ContainerAutoPreferredGapSpring extends AutoPreferredGapSpring {
+        private List<ComponentSpring> targets;
+
+        ContainerAutoPreferredGapSpring() {
+            super();
+            setUserCreated(true);
+        }
+
+        ContainerAutoPreferredGapSpring(int pref, int max) {
+            super(pref, max);
+            setUserCreated(true);
+        }
+
+        @Override
+        void addTarget(ComponentSpring spring, int axis) {
+            if (targets == null) {
+                targets = new ArrayList<ComponentSpring>(1);
+            }
+            targets.add(spring);
+        }
+
+        @Override
+        void calculatePadding(int axis) {
+            LayoutStyle p = getLayoutStyle0();
+            int maxPadding = 0;
+            int position;
+            size = 0;
+            if (targets != null) {
+                // Leading. The vertical axis asks for the SOUTH gap at
+                // the top edge too, as the JDK does.
+                if (axis == HORIZONTAL) {
+                    position = SwingConstants.WEST;
+                } else {
+                    position = SwingConstants.SOUTH;
+                }
+                for (int i = targets.size() - 1; i >= 0; i--) {
+                    ComponentSpring targetSpring = targets.get(i);
+                    int padding = PLAIN_COMPONENT_GAP;
+                    Component c = targetSpring.getComponent();
+                    if (c instanceof JComponent) {
+                        padding = p.getContainerGap((JComponent) c, position, host);
+                        maxPadding = Math.max(padding, maxPadding);
+                        padding -= targetSpring.getOrigin();
+                    } else {
+                        maxPadding = Math.max(padding, maxPadding);
+                    }
+                    size = Math.max(size, padding);
+                }
+            } else {
+                // Trailing
+                if (axis == HORIZONTAL) {
+                    position = SwingConstants.EAST;
+                } else {
+                    position = SwingConstants.SOUTH;
+                }
+                if (sources != null) {
+                    for (int i = sources.size() - 1; i >= 0; i--) {
+                        maxPadding = Math.max(maxPadding, updateSize(p, sources.get(i), position));
+                    }
+                }
+            }
+            if (lastSize != UNSET) {
+                size += Math.min(maxPadding, lastSize);
+            }
+        }
+
+        private int updateSize(LayoutStyle p, ComponentSpring sourceSpring, int position) {
+            int padding = PLAIN_COMPONENT_GAP;
+            Component c = sourceSpring.getComponent();
+            if (c instanceof JComponent) {
+                padding = p.getContainerGap((JComponent) c, position, host);
+            }
+            int delta = Math.max(0, getParent().getSize() - sourceSpring.getSize() - sourceSpring.getOrigin());
+            size = Math.max(size, padding - delta);
+            return padding;
+        }
+    }
+
+    /// Tracks the horizontal and vertical spring of a Component, and what
+    /// it is linked to.
+    private final class ComponentInfo {
+        ComponentSpring horizontalSpring;
+        ComponentSpring verticalSpring;
+        // Component being layed out
+        private Component component;
+        // If the component's size is linked to other components, the
+        // horizontalMaster and/or verticalMaster reference the group of
+        // linked components.
+        private LinkInfo horizontalMaster;
+        private LinkInfo verticalMaster;
+        private boolean visible;
+        private Boolean honorsVisibility;
+
+        ComponentInfo(Component component) {
+            this.component = component;
+            updateVisibility();
+        }
+
+        void dispose() {
+            // Remove horizontal/vertical springs
+            removeSpring(horizontalSpring);
+            horizontalSpring = null;
+            removeSpring(verticalSpring);
+            verticalSpring = null;
+            // Clean up links
+            if (horizontalMaster != null) {
+                horizontalMaster.remove(this);
+            }
+            if (verticalMaster != null) {
+                verticalMaster.remove(this);
+            }
+        }
+
+        void setHonorsVisibility(Boolean honorsVisibility) {
+            this.honorsVisibility = honorsVisibility;
+        }
+
+        private void removeSpring(Spring spring) {
+            if (spring != null) {
+                Spring parent = spring.getParent();
+                if (parent instanceof Group) {
+                    ((Group) parent).springs.remove(spring);
+                }
+            }
+        }
+
+        boolean isVisible() {
+            return visible;
+        }
+
+        /// Updates the cached visibility.
+        ///
+        /// #### Returns
+        ///
+        /// true if the visibility changed
+        boolean updateVisibility() {
+            boolean honors;
+            if (this.honorsVisibility == null) {
+                honors = GroupLayout.this.getHonorsVisibility();
+            } else {
+                honors = this.honorsVisibility.booleanValue();
+            }
+            boolean newVisible = !honors || component.isVisible();
+            if (visible != newVisible) {
+                visible = newVisible;
+                return true;
+            }
+            return false;
+        }
+
+        void setBounds(Insets insets) {
+            int x = horizontalSpring.getOrigin();
+            int w = horizontalSpring.getSize();
+            int y = verticalSpring.getOrigin();
+            int h = verticalSpring.getSize();
+            component.setBounds(x + insets.left, y + insets.top, w, h);
+        }
+
+        void setComponent(Component component) {
+            this.component = component;
+            if (horizontalSpring != null) {
+                horizontalSpring.setComponent(component);
+            }
+            if (verticalSpring != null) {
+                verticalSpring.setComponent(component);
+            }
+        }
+
+        boolean isLinked(int axis) {
+            if (axis == HORIZONTAL) {
+                return horizontalMaster != null;
+            }
+            return verticalMaster != null;
+        }
+
+        void setLinkInfo(int axis, LinkInfo linkInfo) {
+            if (axis == HORIZONTAL) {
+                horizontalMaster = linkInfo;
+            } else {
+                verticalMaster = linkInfo;
+            }
+        }
+
+        LinkInfo getLinkInfo(int axis) {
+            return getLinkInfo(axis, true);
+        }
+
+        LinkInfo getLinkInfo(int axis, boolean create) {
+            if (axis == HORIZONTAL) {
+                if (horizontalMaster == null && create) {
+                    // horizontalMaster field is directly set by adding
+                    // us to the LinkInfo.
+                    new LinkInfo(HORIZONTAL).add(this);
+                }
+                return horizontalMaster;
+            } else {
+                if (verticalMaster == null && create) {
+                    // verticalMaster field is directly set by adding
+                    // us to the LinkInfo.
+                    new LinkInfo(VERTICAL).add(this);
+                }
+                return verticalMaster;
+            }
+        }
+
+        void clearCachedSize() {
+            if (horizontalMaster != null) {
+                horizontalMaster.clearCachedSize();
+            }
+            if (verticalMaster != null) {
+                verticalMaster.clearCachedSize();
+            }
+        }
+
+        int getLinkSize(int axis) {
+            if (axis == HORIZONTAL) {
+                return horizontalMaster.getSize(axis);
+            } else {
+                return verticalMaster.getSize(axis);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Icon.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Icon.java
new file mode 100644
index 00000000000..3deec4caea6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Icon.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+
+/// A small fixed-size picture.
+public interface Icon {
+
+    void paintIcon(Component c, Graphics g, int x, int y);
+
+    int getIconWidth();
+
+    int getIconHeight();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ImageIcon.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ImageIcon.java
new file mode 100644
index 00000000000..30c4991344c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ImageIcon.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.accessibility.AccessibleContext;
+import com.codename1.desktopcompat.rt.ImageLoader;
+import com.codename1.desktopcompat.rt.NativeImage;
+import java.net.URL;
+
+/// An icon that paints an image, drawn at one logical pixel per image
+/// pixel.
+///
+/// A file name is read as a file when there is one, and is otherwise
+/// looked up among the application's resources by its last path element:
+/// the pictures a desktop application keeps beside it are resources once
+/// it is built for a device. A URL is read before the constructor returns.
+public class ImageIcon implements Icon, Accessible {
+
+    private AccessibleContext cn1Accessible;
+
+    private Image image;
+    private String description;
+    private int width = -1;
+    private int height = -1;
+    private ImageObserver imageObserver;
+
+    public ImageIcon() {
+    }
+
+    public ImageIcon(Image image) {
+        setImage(image);
+    }
+
+    public ImageIcon(Image image, String description) {
+        setImage(image);
+        this.description = description;
+    }
+
+    public ImageIcon(byte[] imageData) {
+        cn1Loaded(imageData == null ? null : ImageLoader.decode(imageData, 0, imageData.length));
+    }
+
+    public ImageIcon(byte[] imageData, String description) {
+        this(imageData);
+        this.description = description;
+    }
+
+    public ImageIcon(String filename) {
+        this(filename, filename);
+    }
+
+    /// The image a path names: the file when there is one, else the
+    /// application's resource of the path's last name.
+    public ImageIcon(String filename, String description) {
+        this.description = description;
+        cn1Loaded(ImageLoader.fromPath(filename));
+    }
+
+    /// The image a URL names, read before the constructor returns.
+    public ImageIcon(URL location) {
+        this(location, location == null ? null : location.toExternalForm());
+    }
+
+    public ImageIcon(URL location, String description) {
+        this.description = description;
+        cn1Loaded(ImageLoader.fromUrl(location));
+    }
+
+    /// An icon whose image could not be read has no image, and a width and
+    /// height of -1.
+    private void cn1Loaded(com.codename1.ui.Image decoded) {
+        if (decoded != null) {
+            setImage(new NativeImage(decoded));
+        }
+    }
+
+    public Image getImage() {
+        return image;
+    }
+
+    public void setImage(Image image) {
+        this.image = image;
+        width = image == null ? -1 : image.getWidth(imageObserver);
+        height = image == null ? -1 : image.getHeight(imageObserver);
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    @Override
+    public void paintIcon(Component c, Graphics g, int x, int y) {
+        if (image != null) {
+            g.drawImage(image, x, y, imageObserver != null ? imageObserver : c);
+        }
+    }
+
+    @Override
+    public int getIconWidth() {
+        return width;
+    }
+
+    @Override
+    public int getIconHeight() {
+        return height;
+    }
+
+    public void setImageObserver(ImageObserver observer) {
+        imageObserver = observer;
+    }
+
+    public ImageObserver getImageObserver() {
+        return imageObserver;
+    }
+
+    @Override
+    public String toString() {
+        return description != null ? description : super.toString();
+    }
+
+    /// The accessible context of the icon. Its description starts as the
+    /// description of the icon.
+    @Override
+    public AccessibleContext getAccessibleContext() {
+        if (cn1Accessible == null) {
+            cn1Accessible = new Cn1AccessibleIcon();
+            cn1Accessible.setAccessibleDescription(description);
+        }
+        return cn1Accessible;
+    }
+
+    private static final class Cn1AccessibleIcon extends AccessibleContext {
+
+        Cn1AccessibleIcon() {
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/InputMap.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/InputMap.java
new file mode 100644
index 00000000000..c032a1c683c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/InputMap.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// Maps key strokes to the names of actions, with a parent that is asked
+/// for the strokes this map does not hold.
+public class InputMap {
+
+    private HashMap<KeyStroke, Object> table;
+    private InputMap parent;
+
+    public InputMap() {
+    }
+
+    public void setParent(InputMap map) {
+        parent = map;
+    }
+
+    public InputMap getParent() {
+        return parent;
+    }
+
+    /// Binds the stroke to the name; a `null` name removes the binding.
+    public void put(KeyStroke keyStroke, Object actionMapKey) {
+        if (keyStroke == null) {
+            return;
+        }
+        if (actionMapKey == null) {
+            remove(keyStroke);
+            return;
+        }
+        if (table == null) {
+            table = new HashMap<KeyStroke, Object>();
+        }
+        table.put(keyStroke, actionMapKey);
+    }
+
+    public Object get(KeyStroke keyStroke) {
+        Object v = table == null ? null : table.get(keyStroke);
+        if (v == null && parent != null) {
+            return parent.get(keyStroke);
+        }
+        return v;
+    }
+
+    public void remove(KeyStroke key) {
+        if (table != null) {
+            table.remove(key);
+        }
+    }
+
+    public void clear() {
+        if (table != null) {
+            table.clear();
+        }
+    }
+
+    /// The strokes bound in this map itself, or `null` when there are none.
+    public KeyStroke[] keys() {
+        if (table == null || table.isEmpty()) {
+            return null;
+        }
+        return table.keySet().toArray(new KeyStroke[table.size()]);
+    }
+
+    public int size() {
+        return table == null ? 0 : table.size();
+    }
+
+    /// The strokes bound in this map and its parents, or `null` when
+    /// there are none.
+    public KeyStroke[] allKeys() {
+        ArrayList<KeyStroke> all = new ArrayList<KeyStroke>();
+        for (InputMap m = this; m != null; m = m.parent) {
+            KeyStroke[] ks = m.keys();
+            if (ks != null) {
+                for (int i = 0; i < ks.length; i++) {
+                    if (!all.contains(ks[i])) {
+                        all.add(ks[i]);
+                    }
+                }
+            }
+        }
+        return all.isEmpty() ? null : all.toArray(new KeyStroke[all.size()]);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/InputVerifier.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/InputVerifier.java
new file mode 100644
index 00000000000..0a4b001734a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/InputVerifier.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// Decides whether what a component holds is acceptable before the focus
+/// leaves it. Only the text components consult one.
+public abstract class InputVerifier {
+
+    public InputVerifier() {
+    }
+
+    public abstract boolean verify(JComponent input);
+
+    public boolean shouldYieldFocus(JComponent input) {
+        return verify(input);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JButton.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JButton.java
new file mode 100644
index 00000000000..858798cb06b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JButton.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.rt.ButtonPeer;
+
+/// A push button, shown by a Codename One button.
+public class JButton extends AbstractButton implements Accessible {
+
+    public JButton() {
+        this(null, null);
+    }
+
+    public JButton(Icon icon) {
+        this(null, icon);
+    }
+
+    public JButton(String text) {
+        this(text, null);
+    }
+
+    public JButton(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JButton(String text, Icon icon) {
+        setModel(new DefaultButtonModel());
+        init(text, icon);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new ButtonPeer(this);
+    }
+
+    public boolean isDefaultButton() {
+        JRootPane root = SwingUtilities.getRootPane(this);
+        return root != null && root.getDefaultButton() == this;
+    }
+
+    public boolean isDefaultCapable() {
+        return true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JCheckBox.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JCheckBox.java
new file mode 100644
index 00000000000..d57bad5402a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JCheckBox.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.rt.CheckBoxPeer;
+
+/// A check box, shown by a Codename One check box.
+public class JCheckBox extends JToggleButton {
+
+    public JCheckBox() {
+        this(null, null, false);
+    }
+
+    public JCheckBox(Icon icon) {
+        this(null, icon, false);
+    }
+
+    public JCheckBox(Icon icon, boolean selected) {
+        this(null, icon, selected);
+    }
+
+    public JCheckBox(String text) {
+        this(text, null, false);
+    }
+
+    public JCheckBox(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JCheckBox(String text, boolean selected) {
+        this(text, null, selected);
+    }
+
+    public JCheckBox(String text, Icon icon) {
+        this(text, icon, false);
+    }
+
+    public JCheckBox(String text, Icon icon, boolean selected) {
+        super(text, icon, selected);
+        setBorderPainted(false);
+        setHorizontalAlignment(LEADING);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new CheckBoxPeer(this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JCheckBoxMenuItem.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JCheckBoxMenuItem.java
new file mode 100644
index 00000000000..23b2aa6f6ab
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JCheckBoxMenuItem.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.rt.CheckBoxPeer;
+
+/// A menu item that is checked or not: a Codename One check box in a
+/// popup menu, a command whose name carries a check mark in a menu bar.
+public class JCheckBoxMenuItem extends JMenuItem {
+
+    public JCheckBoxMenuItem() {
+        this(null, null, false);
+    }
+
+    public JCheckBoxMenuItem(Icon icon) {
+        this(null, icon, false);
+    }
+
+    public JCheckBoxMenuItem(String text) {
+        this(text, null, false);
+    }
+
+    public JCheckBoxMenuItem(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JCheckBoxMenuItem(String text, Icon icon) {
+        this(text, icon, false);
+    }
+
+    public JCheckBoxMenuItem(String text, boolean b) {
+        this(text, null, b);
+    }
+
+    public JCheckBoxMenuItem(String text, Icon icon, boolean b) {
+        super(text, icon);
+        setModel(new JToggleButton.ToggleButtonModel());
+        setSelected(b);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new CheckBoxPeer(this);
+    }
+
+    public boolean getState() {
+        return isSelected();
+    }
+
+    public void setState(boolean b) {
+        setSelected(b);
+    }
+
+    @Override
+    public Object[] getSelectedObjects() {
+        return isSelected() ? new Object[]{getText()} : null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JColorChooser.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JColorChooser.java
new file mode 100644
index 00000000000..20d4b57c680
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JColorChooser.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// `javax.swing.JColorChooser`: picks a color.
+///
+/// The pane is a preview above three sliders, one each for red, green and
+/// blue. The swatch, HSV, HSL and CMYK panels of the desktop, the color
+/// selection model and custom chooser panels are not provided, and the
+/// alpha of a color is not editable: the chosen color is opaque.
+public class JColorChooser extends JComponent implements Accessible {
+
+    public static final String SELECTION_MODEL_PROPERTY = "selectionModel";
+    public static final String PREVIEW_PANEL_PROPERTY = "previewPanel";
+    public static final String CHOOSER_PANELS_PROPERTY = "chooserPanels";
+
+    private final JSlider[] sliders = new JSlider[3];
+    private final JPanel preview = new JPanel();
+    private Color color;
+    private boolean adjusting;
+
+    public JColorChooser() {
+        this(new Color(255, 255, 255));
+    }
+
+    public JColorChooser(Color initialColor) {
+        color = initialColor == null ? new Color(255, 255, 255) : initialColor;
+        setLayout(new BorderLayout(8, 8));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        preview.setOpaque(true);
+        preview.setPreferredSize(new Dimension(160, 40));
+        preview.setBackground(color);
+        add(preview, BorderLayout.NORTH);
+        JPanel rows = new JPanel();
+        rows.setLayout(new BoxLayout(rows, BoxLayout.Y_AXIS));
+        String[] names = {"Red", "Green", "Blue"};
+        int[] parts = {color.getRed(), color.getGreen(), color.getBlue()};
+        ChangeListener moved = new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                if (!adjusting) {
+                    setColor(sliders[0].getValue(), sliders[1].getValue(), sliders[2].getValue());
+                }
+            }
+        };
+        for (int i = 0; i < 3; i++) {
+            JPanel row = new JPanel(new BorderLayout(6, 0));
+            row.add(new JLabel(names[i]), BorderLayout.WEST);
+            sliders[i] = new JSlider(0, 255, parts[i]);
+            sliders[i].addChangeListener(moved);
+            row.add(sliders[i], BorderLayout.CENTER);
+            rows.add(row);
+        }
+        add(rows, BorderLayout.CENTER);
+    }
+
+    /// Shows a modal color dialog and waits for it: the color chosen, or
+    /// `null` when the user cancelled or closed the dialog.
+    public static Color showDialog(Component component, String title, Color initialColor) {
+        final JColorChooser pane = new JColorChooser(initialColor);
+        final Color[] chosen = new Color[1];
+        JDialog dialog = createDialog(component, title, true, pane, new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                chosen[0] = pane.getColor();
+            }
+        }, null);
+        dialog.setVisible(true);
+        dialog.dispose();
+        return chosen[0];
+    }
+
+    public static JDialog createDialog(Component c, String title, boolean modal, JColorChooser chooserPane,
+            final ActionListener okListener, final ActionListener cancelListener) {
+        Window owner = null;
+        if (c instanceof Window) {
+            owner = (Window) c;
+        } else if (c != null) {
+            owner = SwingUtilities.getWindowAncestor(c);
+        }
+        final JDialog dialog = new JDialog(owner, title,
+                modal ? Dialog.ModalityType.APPLICATION_MODAL : Dialog.ModalityType.MODELESS);
+        Container content = dialog.getContentPane();
+        content.setLayout(new BorderLayout());
+        if (chooserPane != null) {
+            content.add(chooserPane, BorderLayout.CENTER);
+        }
+        JPanel buttons = new JPanel();
+        JButton ok = new JButton(label("ColorChooser.okText", "OK"));
+        ok.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                dialog.setVisible(false);
+                if (okListener != null) {
+                    okListener.actionPerformed(e);
+                }
+            }
+        });
+        JButton cancel = new JButton(label("ColorChooser.cancelText", "Cancel"));
+        cancel.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                dialog.setVisible(false);
+                if (cancelListener != null) {
+                    cancelListener.actionPerformed(e);
+                }
+            }
+        });
+        buttons.add(ok);
+        buttons.add(cancel);
+        content.add(buttons, BorderLayout.SOUTH);
+        dialog.getRootPane().setDefaultButton(ok);
+        dialog.pack();
+        dialog.setLocationRelativeTo(c);
+        return dialog;
+    }
+
+    private static String label(String key, String fallback) {
+        String s = UIManager.getString(key);
+        return s == null ? fallback : s;
+    }
+
+    public Color getColor() {
+        return color;
+    }
+
+    public void setColor(Color color) {
+        if (color == null) {
+            return;
+        }
+        Color old = this.color;
+        this.color = color;
+        adjusting = true;
+        sliders[0].setValue(color.getRed());
+        sliders[1].setValue(color.getGreen());
+        sliders[2].setValue(color.getBlue());
+        adjusting = false;
+        preview.setBackground(color);
+        preview.repaint();
+        firePropertyChange("color", old, color);
+    }
+
+    public void setColor(int r, int g, int b) {
+        setColor(new Color(r, g, b));
+    }
+
+    public void setColor(int c) {
+        setColor((c >> 16) & 0xFF, (c >> 8) & 0xFF, c & 0xFF);
+    }
+
+    // ------------------------------------------------------------ drag
+
+    /// Records whether dragging out of the component is wanted. The layer
+    /// starts no drag of its own, so this is a property and nothing more.
+    public void setDragEnabled(boolean b) {
+        cn1DragEnabled = b;
+    }
+
+    public boolean getDragEnabled() {
+        return cn1DragEnabled;
+    }
+
+    private boolean cn1DragEnabled;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JComboBox.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JComboBox.java
new file mode 100644
index 00000000000..589b6567da3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JComboBox.java
@@ -0,0 +1,921 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.ItemSelectable;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ListDataEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListDataListener;
+import com.codename1.desktopcompat.javax.swing.plaf.basic.BasicComboBoxEditor;
+import com.codename1.desktopcompat.rt.CellStamp;
+import com.codename1.desktopcompat.rt.ComboPeer;
+import com.codename1.ui.events.DataChangedListener;
+import com.codename1.ui.events.SelectionListener;
+import java.util.ArrayList;
+import java.util.Vector;
+
+/// A box showing one item of a model, with a popup to pick another.
+///
+/// The widget and its popup are a Codename One combo box, so the popup is
+/// whatever the platform shows for one. The model, the selection and the
+/// events are this class's, and they follow the desktop: selecting through
+/// [#setSelectedItem] tells the item listeners about the item given up and
+/// the item taken, when they differ, and then always the action listeners.
+/// What the user highlights in an open popup is not a selection: the
+/// listeners hear once, when the popup closes with a row picked, and not
+/// at all when it is dismissed.
+///
+/// ## Editable
+///
+/// An editable combo box is a text field, the component of its
+/// [ComboBoxEditor], with an arrow button beside it. Enter in the field
+/// makes the text the selected item, in the model or not, and tells the
+/// action listeners, the last time with the command `comboBoxEdited`. The
+/// arrow opens a popup menu of the model's items.
+///
+/// ## What differs from the desktop
+///
+///  - The popup of an editable combo box is a menu showing each item's
+///    `toString()`; the renderer draws only the popup of one that is not
+///    editable.
+///  - The popup of a combo box that is not editable is modal. `showPopup`
+///    opens it after the current event, and `hidePopup` closes it without
+///    a selection, as a click outside it does.
+///  - Typing does not select as it goes; there is no key selection manager
+///    and no `ComboBoxUI`.
+public class JComboBox<E> extends JComponent
+        implements Accessible, ItemSelectable, ListDataListener, ActionListener {
+
+    private ComboBoxModel<E> dataModel;
+    private ListCellRenderer<? super E> renderer = new DefaultListCellRenderer.UIResource();
+    private boolean isEditable;
+    private int maximumRowCount = 8;
+    private Object selectedItemReminder;
+    private E prototypeDisplayValue;
+    private String actionCommand = "comboBoxChanged";
+    private boolean firingActionEvent;
+    private boolean selectingItem;
+    private final ArrayList<ItemListener> itemListeners = new ArrayList<ItemListener>();
+    private final ArrayList<ActionListener> actionListeners = new ArrayList<ActionListener>();
+    private final Bridge bridge = new Bridge();
+    private JList<E> rendererList;
+    private ComboBoxEditor editor;
+    private JButton arrow;
+    private JPopupMenu menu;
+
+    public JComboBox(ComboBoxModel<E> aModel) {
+        setModel(aModel);
+    }
+
+    public JComboBox(E[] items) {
+        setModel(new DefaultComboBoxModel<E>(items));
+    }
+
+    public JComboBox(Vector<E> items) {
+        setModel(new DefaultComboBoxModel<E>(items));
+    }
+
+    public JComboBox() {
+        setModel(new DefaultComboBoxModel<E>());
+    }
+
+    // ------------------------------------------------------------ peer
+
+    /// The model of this combo box as the Codename One widget sees it.
+    private final class Bridge implements com.codename1.ui.list.ListModel<Object> {
+        final ArrayList<DataChangedListener> data = new ArrayList<DataChangedListener>();
+        final ArrayList<SelectionListener> selection = new ArrayList<SelectionListener>();
+        int shownIndex = -1;
+
+        @Override
+        public Object getItemAt(int index) {
+            return index >= 0 && index < dataModel.getSize() ? dataModel.getElementAt(index) : null;
+        }
+
+        @Override
+        public int getSize() {
+            return dataModel.getSize();
+        }
+
+        /// While the popup is open the widget sees the row highlighted
+        /// in it; the combo box's own selection has not moved yet.
+        boolean popupOpen;
+        int highlighted = -1;
+
+        @Override
+        public int getSelectedIndex() {
+            return popupOpen ? highlighted : JComboBox.this.getSelectedIndex();
+        }
+
+        /// The widget moved its selection. With the popup open that is
+        /// only the highlight following the pointer or the keys, and a
+        /// dismissed popup puts it back where it was; the row is taken
+        /// when the popup has closed.
+        @Override
+        public void setSelectedIndex(int index) {
+            if (popupOpen) {
+                if (index >= 0 && index < dataModel.getSize() && index != highlighted) {
+                    int old = highlighted;
+                    highlighted = index;
+                    tell(old, index);
+                }
+                return;
+            }
+            if (index >= 0 && index < dataModel.getSize() && index != JComboBox.this.getSelectedIndex()) {
+                JComboBox.this.setSelectedIndex(index);
+            }
+        }
+
+        void tell(int old, int now) {
+            SelectionListener[] all = selection.toArray(new SelectionListener[selection.size()]);
+            for (int i = 0; i < all.length; i++) {
+                all[i].selectionChanged(old, now);
+            }
+        }
+
+        @Override
+        public void addDataChangedListener(DataChangedListener l) {
+            data.add(l);
+        }
+
+        @Override
+        public void removeDataChangedListener(DataChangedListener l) {
+            data.remove(l);
+        }
+
+        @Override
+        public void addSelectionListener(SelectionListener l) {
+            selection.add(l);
+        }
+
+        @Override
+        public void removeSelectionListener(SelectionListener l) {
+            selection.remove(l);
+        }
+
+        @Override
+        public void addItem(Object item) {
+            // The widget never adds rows; the model is the application's.
+        }
+
+        @Override
+        public void removeItem(int index) {
+        }
+
+        void dataChanged(int type, int index) {
+            DataChangedListener[] all = data.toArray(new DataChangedListener[data.size()]);
+            for (int i = 0; i < all.length; i++) {
+                all[i].dataChanged(type, index);
+            }
+        }
+
+        void selectionMoved() {
+            int now = JComboBox.this.getSelectedIndex();
+            if (now == shownIndex) {
+                return;
+            }
+            int old = shownIndex;
+            shownIndex = now;
+            if (!popupOpen) {
+                tell(old, now);
+            }
+        }
+    }
+
+    /// Paints the rows of the Codename One widget with this combo box's
+    /// renderer.
+    private final class Stamps implements com.codename1.ui.list.ListCellRenderer<Object> {
+        private final CellStamp stamp = new CellStamp();
+
+        @Override
+        public com.codename1.ui.Component getListCellRendererComponent(com.codename1.ui.List list, Object value,
+                int index, boolean isSelected) {
+            stamp.setCell(cn1Cell(value, index, isSelected));
+            return stamp;
+        }
+
+        @Override
+        public com.codename1.ui.Component getListFocusComponent(com.codename1.ui.List list) {
+            return null;
+        }
+    }
+
+    /// The renderer's component for one value. The value comes back from
+    /// the model this combo box handed out, so it is one of its elements.
+    @SuppressWarnings("unchecked")
+    private Component cn1Cell(Object value, int index, boolean selected) {
+        if (renderer == null) {
+            return null;
+        }
+        if (rendererList == null) {
+            rendererList = new JList<E>();
+        }
+        rendererList.setFont(getFont());
+        // A row is drawn inside the box, in the colour of the box, and not
+        // in that of a list standing on its own.
+        Color box = getBackground();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!isBackgroundSet() && p != null) {
+            com.codename1.ui.plaf.Style s = p.getUnselectedStyle();
+            com.codename1.ui.plaf.Border b = s.getBorder();
+            if ((s.getBgTransparency() & 0xff) != 0 || (b != null && b.isBackgroundPainter())) {
+                box = new Color(s.getBgColor() & 0xffffff);
+            }
+        }
+        rendererList.setBackground(box);
+        if (getForeground() != null) {
+            rendererList.setForeground(getForeground());
+        }
+        return renderer.getListCellRendererComponent(rendererList, (E) value, index, selected, false);
+    }
+
+    /// An editable combo box is a container of its editor and its arrow;
+    /// one that is not is the Codename One combo box.
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        if (isEditable) {
+            return super.cn1CreatePeer();
+        }
+        return new ComboPeer(this, bridge);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof ComboPeer) {
+            ComboPeer combo = (ComboPeer) p;
+            combo.setRenderer(new Stamps());
+            combo.setPopupWatcher(new ComboPeer.PopupWatcher() {
+                @Override
+                public void popupOpening() {
+                    cn1PopupOpening();
+                }
+
+                @Override
+                public void popupClosed(boolean cancelled) {
+                    cn1PopupClosed(cancelled);
+                }
+            });
+        }
+        bridge.shownIndex = getSelectedIndex();
+    }
+
+    /// The popup of the Codename One widget is about to open.
+    void cn1PopupOpening() {
+        bridge.highlighted = getSelectedIndex();
+        bridge.popupOpen = true;
+    }
+
+    /// The popup has closed. The row highlighted in it becomes the
+    /// selection, unless the popup was closed from code; a popup the user
+    /// dismissed has had its highlight put back already.
+    void cn1PopupClosed(boolean cancelled) {
+        if (!bridge.popupOpen) {
+            return;
+        }
+        int picked = bridge.highlighted;
+        bridge.popupOpen = false;
+        int current = getSelectedIndex();
+        bridge.shownIndex = picked;
+        if (!cancelled && picked >= 0 && picked < dataModel.getSize() && picked != current) {
+            setSelectedIndex(picked);
+        }
+        bridge.selectionMoved();
+    }
+
+    // ------------------------------------------------------------ editable
+
+    /// The arrow of an editable combo box.
+    private static final class Arrow implements Icon {
+        private static final int WIDTH = 9;
+        private static final int HEIGHT = 6;
+
+        @Override
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+            Color fg = c == null ? null : c.getForeground();
+            g.setColor(fg != null ? fg : Color.DARK_GRAY);
+            int[] xs = {x, x + WIDTH - 1, x + WIDTH / 2};
+            int[] ys = {y, y, y + HEIGHT - 1};
+            g.fillPolygon(xs, ys, 3);
+        }
+
+        @Override
+        public int getIconWidth() {
+            return WIDTH;
+        }
+
+        @Override
+        public int getIconHeight() {
+            return HEIGHT;
+        }
+    }
+
+    /// The editor fills the box and the arrow stands at its end.
+    private final class EditableRow implements LayoutManager {
+        private static final int ARROW_WIDTH = 24;
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        private Dimension size(boolean minimum) {
+            Component e = editor == null ? null : editor.getEditorComponent();
+            Dimension ed = e == null ? new Dimension(0, 0) : minimum ? e.getMinimumSize() : e.getPreferredSize();
+            Insets in = getInsets();
+            int w = ed.width;
+            if (!minimum) {
+                // Wide enough for the longest item, as the desktop sizes it.
+                w = Math.max(w, cn1WidestItem());
+            }
+            return new Dimension(w + ARROW_WIDTH + in.left + in.right, ed.height + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            return size(false);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return size(true);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            Insets in = getInsets();
+            int w = Math.max(0, getWidth() - in.left - in.right);
+            int h = Math.max(0, getHeight() - in.top - in.bottom);
+            int aw = Math.min(ARROW_WIDTH, w / 2);
+            Component e = editor == null ? null : editor.getEditorComponent();
+            if (e != null) {
+                e.setBounds(in.left, in.top, w - aw, h);
+            }
+            if (arrow != null) {
+                arrow.setBounds(in.left + w - aw, in.top, aw, h);
+            }
+        }
+    }
+
+    /// The width the longest item of the model needs in the editor's font.
+    private int cn1WidestItem() {
+        Component e = editor == null ? null : editor.getEditorComponent();
+        if (e == null || e.getFont() == null) {
+            return 0;
+        }
+        com.codename1.desktopcompat.java.awt.FontMetrics fm = e.getFontMetrics(e.getFont());
+        int widest = 0;
+        for (int i = 0; i < dataModel.getSize(); i++) {
+            E item = dataModel.getElementAt(i);
+            if (item != null) {
+                widest = Math.max(widest, fm.stringWidth(item.toString()));
+            }
+        }
+        Insets in = e instanceof Container ? ((Container) e).getInsets() : null;
+        return widest + (in == null ? 0 : in.left + in.right) + fm.charWidth('W');
+    }
+
+    /// Makes this combo box the container of an editor and an arrow.
+    private void cn1BuildEditable() {
+        if (arrow == null) {
+            arrow = new JButton(new Arrow());
+            arrow.setName("ComboBox.arrowButton");
+            arrow.setFocusable(false);
+            arrow.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    setPopupVisible(!isPopupVisible());
+                }
+            });
+        }
+        if (editor == null) {
+            editor = createDefaultEditor();
+            editor.addActionListener(this);
+        }
+        removeAll();
+        setLayout(new EditableRow());
+        Component ec = editor.getEditorComponent();
+        if (ec != null) {
+            add(ec);
+            ec.setEnabled(isEnabled());
+        }
+        add(arrow);
+        arrow.setEnabled(isEnabled());
+        configureEditor(editor, getSelectedItem());
+    }
+
+    private ComboBoxEditor createDefaultEditor() {
+        return new BasicComboBoxEditor();
+    }
+
+    /// The popup menu of an editable combo box, made over from the model
+    /// each time it opens.
+    private JPopupMenu cn1Menu() {
+        if (menu == null) {
+            menu = new JPopupMenu();
+        }
+        menu.removeAll();
+        for (int i = 0; i < dataModel.getSize(); i++) {
+            final E item = dataModel.getElementAt(i);
+            JMenuItem row = new JMenuItem(item == null ? "" : item.toString());
+            row.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    setSelectedItem(item);
+                }
+            });
+            menu.add(row);
+        }
+        return menu;
+    }
+
+    /// The editor of an editable combo box. One is made when the combo
+    /// box becomes editable, so a combo box that never was has none.
+    public ComboBoxEditor getEditor() {
+        return editor;
+    }
+
+    public void setEditor(ComboBoxEditor anEditor) {
+        ComboBoxEditor old = editor;
+        if (old != null) {
+            old.removeActionListener(this);
+            Component oc = old.getEditorComponent();
+            if (oc != null && oc.getParent() == this) {
+                remove(oc);
+            }
+        }
+        editor = anEditor;
+        if (editor != null) {
+            editor.addActionListener(this);
+        }
+        if (isEditable) {
+            cn1BuildEditable();
+            revalidate();
+            repaint();
+        }
+        firePropertyChange("editor", old, editor);
+    }
+
+    /// Shows an item in an editor.
+    public void configureEditor(ComboBoxEditor anEditor, Object anItem) {
+        if (anEditor != null) {
+            anEditor.setItem(anItem);
+        }
+    }
+
+    /// The editor finished an edit: its item becomes the selected item,
+    /// and the action listeners hear the command `comboBoxEdited`.
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        setPopupVisible(false);
+        if (editor != null) {
+            getModel().setSelectedItem(editor.getItem());
+        }
+        String oldCommand = getActionCommand();
+        setActionCommand("comboBoxEdited");
+        fireActionEvent();
+        setActionCommand(oldCommand);
+    }
+
+    @Override
+    public void setEnabled(boolean b) {
+        super.setEnabled(b);
+        if (arrow != null) {
+            arrow.setEnabled(b);
+        }
+        Component ec = editor == null ? null : editor.getEditorComponent();
+        if (ec != null) {
+            ec.setEnabled(b);
+        }
+    }
+
+    private void cn1Refresh() {
+        bridge.selectionMoved();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p != null) {
+            p.setShouldCalcPreferredSize(true);
+            revalidate();
+            repaint();
+        }
+    }
+
+    // ------------------------------------------------------------ model
+
+    public void setModel(ComboBoxModel<E> aModel) {
+        ComboBoxModel<E> oldModel = dataModel;
+        if (oldModel != null) {
+            oldModel.removeListDataListener(this);
+        }
+        dataModel = aModel;
+        dataModel.addListDataListener(this);
+        selectedItemReminder = dataModel.getSelectedItem();
+        firePropertyChange("model", oldModel, dataModel);
+        bridge.dataChanged(DataChangedListener.CHANGED, -1);
+        cn1Refresh();
+    }
+
+    public ComboBoxModel<E> getModel() {
+        return dataModel;
+    }
+
+    public void setEditable(boolean aFlag) {
+        boolean old = isEditable;
+        isEditable = aFlag;
+        if (old != aFlag) {
+            if (aFlag) {
+                cn1BuildEditable();
+            } else {
+                if (menu != null) {
+                    menu.setVisible(false);
+                }
+                removeAll();
+                setLayout(null);
+            }
+            // The two kinds have different peers; one made already is
+            // made again.
+            cn1RecreatePeer();
+            revalidate();
+            repaint();
+        }
+        firePropertyChange("editable", old, isEditable);
+    }
+
+    public boolean isEditable() {
+        return isEditable;
+    }
+
+    public void setMaximumRowCount(int count) {
+        int old = maximumRowCount;
+        maximumRowCount = count;
+        firePropertyChange("maximumRowCount", old, maximumRowCount);
+    }
+
+    public int getMaximumRowCount() {
+        return maximumRowCount;
+    }
+
+    public void setRenderer(ListCellRenderer<? super E> aRenderer) {
+        ListCellRenderer<? super E> old = renderer;
+        renderer = aRenderer;
+        firePropertyChange("renderer", old, renderer);
+        cn1Refresh();
+    }
+
+    public ListCellRenderer<? super E> getRenderer() {
+        return renderer;
+    }
+
+    public E getPrototypeDisplayValue() {
+        return prototypeDisplayValue;
+    }
+
+    public void setPrototypeDisplayValue(E prototypeDisplayValue) {
+        Object old = this.prototypeDisplayValue;
+        this.prototypeDisplayValue = prototypeDisplayValue;
+        firePropertyChange("prototypeDisplayValue", old, prototypeDisplayValue);
+    }
+
+    // ------------------------------------------------------------ selection
+
+    /// Selects an item. An item that is not in the model is ignored unless
+    /// the combo box is editable. The action listeners hear about every
+    /// call that gets as far as the model, a change or not.
+    public void setSelectedItem(Object anObject) {
+        Object oldSelection = selectedItemReminder;
+        Object objectToSelect = anObject;
+        if (oldSelection == null || !oldSelection.equals(anObject)) {
+            if (anObject != null && !isEditable()) {
+                boolean found = false;
+                for (int i = 0; i < dataModel.getSize(); i++) {
+                    E element = dataModel.getElementAt(i);
+                    if (anObject.equals(element)) {
+                        found = true;
+                        objectToSelect = element;
+                        break;
+                    }
+                }
+                if (!found) {
+                    return;
+                }
+            }
+            selectingItem = true;
+            dataModel.setSelectedItem(objectToSelect);
+            selectingItem = false;
+            // A model that told nobody still changed.
+            if (selectedItemReminder != dataModel.getSelectedItem()) {
+                selectedItemChanged();
+            }
+        }
+        fireActionEvent();
+    }
+
+    public Object getSelectedItem() {
+        return dataModel.getSelectedItem();
+    }
+
+    public void setSelectedIndex(int anIndex) {
+        int size = dataModel.getSize();
+        if (anIndex == -1) {
+            setSelectedItem(null);
+        } else if (anIndex < -1 || anIndex >= size) {
+            throw new IllegalArgumentException("setSelectedIndex: " + anIndex + " out of bounds");
+        } else {
+            setSelectedItem(dataModel.getElementAt(anIndex));
+        }
+    }
+
+    public int getSelectedIndex() {
+        Object sObject = dataModel.getSelectedItem();
+        for (int i = 0, c = dataModel.getSize(); i < c; i++) {
+            E obj = dataModel.getElementAt(i);
+            if (obj != null && obj.equals(sObject)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public Object[] getSelectedObjects() {
+        Object selected = getSelectedItem();
+        return selected == null ? new Object[0] : new Object[]{selected};
+    }
+
+    // ------------------------------------------------------------ items
+
+    private MutableComboBoxModel<E> mutable() {
+        if (!(dataModel instanceof MutableComboBoxModel)) {
+            throw new RuntimeException("Cannot use this method with a non-Mutable data model.");
+        }
+        return (MutableComboBoxModel<E>) dataModel;
+    }
+
+    public void addItem(E item) {
+        mutable().addElement(item);
+    }
+
+    public void insertItemAt(E item, int index) {
+        mutable().insertElementAt(item, index);
+    }
+
+    public void removeItem(Object anObject) {
+        mutable().removeElement(anObject);
+    }
+
+    public void removeItemAt(int anIndex) {
+        mutable().removeElementAt(anIndex);
+    }
+
+    public void removeAllItems() {
+        MutableComboBoxModel<E> model = mutable();
+        if (model instanceof DefaultComboBoxModel) {
+            ((DefaultComboBoxModel<E>) model).removeAllElements();
+        } else {
+            int size = model.getSize();
+            for (int i = 0; i < size; ++i) {
+                model.removeElement(model.getElementAt(0));
+            }
+        }
+        selectedItemReminder = null;
+        cn1Refresh();
+    }
+
+    public int getItemCount() {
+        return dataModel.getSize();
+    }
+
+    public E getItemAt(int index) {
+        return dataModel.getElementAt(index);
+    }
+
+    // ------------------------------------------------------------ popup
+
+    public void showPopup() {
+        setPopupVisible(true);
+    }
+
+    public void hidePopup() {
+        setPopupVisible(false);
+    }
+
+    /// Opens or closes the popup. The popup of a combo box that is not
+    /// editable is modal the way Codename One shows it, so it is opened
+    /// after the current event and not inside this call; closing it takes
+    /// nothing from it.
+    public void setPopupVisible(boolean v) {
+        if (isEditable) {
+            if (v == isPopupVisible()) {
+                return;
+            }
+            if (v) {
+                if (isEnabled() && cn1PeerOrNull() != null) {
+                    cn1Menu().show(this, 0, getHeight());
+                }
+            } else {
+                menu.setVisible(false);
+            }
+            return;
+        }
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!(p instanceof ComboPeer) || !com.codename1.ui.Display.isInitialized()) {
+            return;
+        }
+        final ComboPeer combo = (ComboPeer) p;
+        if (v) {
+            com.codename1.ui.Display.getInstance().callSerially(new Runnable() {
+                @Override
+                public void run() {
+                    combo.openPopup();
+                }
+            });
+        } else {
+            combo.closePopup();
+        }
+    }
+
+    public boolean isPopupVisible() {
+        if (isEditable) {
+            return menu != null && menu.isVisible();
+        }
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        return p instanceof ComboPeer && ((ComboPeer) p).isShowingPopupDialog();
+    }
+
+    // ------------------------------------------------------------ listeners
+
+    @Override
+    public void addItemListener(ItemListener aListener) {
+        if (aListener != null) {
+            itemListeners.add(aListener);
+        }
+    }
+
+    @Override
+    public void removeItemListener(ItemListener aListener) {
+        int i = itemListeners.lastIndexOf(aListener);
+        if (i >= 0) {
+            itemListeners.remove(i);
+        }
+    }
+
+    public ItemListener[] getItemListeners() {
+        return itemListeners.toArray(new ItemListener[itemListeners.size()]);
+    }
+
+    public void addActionListener(ActionListener l) {
+        if (l != null) {
+            actionListeners.add(l);
+        }
+    }
+
+    public void removeActionListener(ActionListener l) {
+        int i = actionListeners.lastIndexOf(l);
+        if (i >= 0) {
+            actionListeners.remove(i);
+        }
+    }
+
+    public ActionListener[] getActionListeners() {
+        return actionListeners.toArray(new ActionListener[actionListeners.size()]);
+    }
+
+    public void setActionCommand(String aCommand) {
+        actionCommand = aCommand;
+    }
+
+    public String getActionCommand() {
+        return actionCommand;
+    }
+
+    protected void fireItemStateChanged(ItemEvent e) {
+        ItemListener[] all = getItemListeners();
+        for (int i = all.length - 1; i >= 0; i--) {
+            all[i].itemStateChanged(e);
+        }
+    }
+
+    /// Tells the action listeners; a listener that selects again from
+    /// inside the notification does not start a second round.
+    protected void fireActionEvent() {
+        if (firingActionEvent) {
+            return;
+        }
+        firingActionEvent = true;
+        try {
+            ActionListener[] all = getActionListeners();
+            ActionEvent e = null;
+            for (int i = all.length - 1; i >= 0; i--) {
+                if (e == null) {
+                    e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, getActionCommand());
+                }
+                all[i].actionPerformed(e);
+            }
+        } finally {
+            firingActionEvent = false;
+        }
+    }
+
+    /// The selection moved: the item given up is reported deselected and
+    /// the item taken selected, each only when there is one.
+    protected void selectedItemChanged() {
+        if (selectedItemReminder != null) {
+            fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, selectedItemReminder,
+                    ItemEvent.DESELECTED));
+        }
+        selectedItemReminder = dataModel.getSelectedItem();
+        if (isEditable && editor != null) {
+            configureEditor(editor, selectedItemReminder);
+        }
+        if (selectedItemReminder != null) {
+            fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, selectedItemReminder,
+                    ItemEvent.SELECTED));
+        }
+        cn1Refresh();
+    }
+
+    // ------------------------------------------------------------ model events
+
+    @Override
+    public void contentsChanged(ListDataEvent e) {
+        Object oldSelection = selectedItemReminder;
+        Object newSelection = dataModel.getSelectedItem();
+        if (oldSelection == null || !oldSelection.equals(newSelection)) {
+            selectedItemChanged();
+            if (!selectingItem) {
+                fireActionEvent();
+            }
+        }
+        if (e.getIndex0() >= 0) {
+            bridge.dataChanged(DataChangedListener.CHANGED, e.getIndex0());
+        }
+        cn1Refresh();
+    }
+
+    @Override
+    public void intervalAdded(ListDataEvent e) {
+        // Identity on purpose, as on the desktop: the reminder is the very
+        // object the model answered last time.
+        Object now = dataModel.getSelectedItem();
+        if (selectedItemReminder != now) {
+            selectedItemChanged();
+        }
+        bridge.dataChanged(DataChangedListener.ADDED, e.getIndex0());
+        cn1Refresh();
+    }
+
+    @Override
+    public void intervalRemoved(ListDataEvent e) {
+        Object oldSelection = selectedItemReminder;
+        Object newSelection = dataModel.getSelectedItem();
+        if (oldSelection == null || !oldSelection.equals(newSelection)) {
+            selectedItemChanged();
+            if (!selectingItem) {
+                fireActionEvent();
+            }
+        }
+        bridge.dataChanged(DataChangedListener.REMOVED, e.getIndex0());
+        cn1Refresh();
+    }
+
+    /// A combo box takes the room a layout has to give, as the JDK's
+    /// does: in a column of them all are as wide as the column.
+    @Override
+    public Dimension getMaximumSize() {
+        return isMaximumSizeSet() ? super.getMaximumSize() : new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JComponent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JComponent.java
new file mode 100644
index 00000000000..84ef1875b0e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JComponent.java
@@ -0,0 +1,872 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.plaf.UIResource;
+import com.codename1.desktopcompat.java.awt.dnd.DropTarget;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.accessibility.AccessibleContext;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.rt.EventBridge;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// The base of the Swing components.
+///
+/// Painting follows Swing: `paint` calls `paintComponent`, `paintBorder`
+/// and `paintChildren`. The default `paintComponent` draws the Codename
+/// One widget behind a component that has one (a button, a label) and
+/// otherwise fills the background of an opaque component; an override that
+/// does not call `super.paintComponent` therefore starts from what its
+/// parent painted. There are no UI delegates: `updateUI` does nothing.
+///
+/// Key bindings work as in Swing. A key event that no key listener
+/// consumed is looked up in the input map of the focused component
+/// (`WHEN_FOCUSED`), then in those of it and its ancestors
+/// (`WHEN_ANCESTOR_OF_FOCUSED_COMPONENT`), then in those every visible,
+/// enabled component of the window registered for the whole window
+/// (`WHEN_IN_FOCUSED_WINDOW`); the first enabled action found runs and
+/// the event is consumed. A component with a `WHEN_FOCUSED` binding is a
+/// stop of the tab key.
+///
+/// The tool tip is the tool tip of the Codename One widget behind the
+/// component, so a component without one shows none, and it appears
+/// only where the port has a pointer that hovers.
+///
+/// Every component has an accessible context. Its name becomes the
+/// accessibility text of the widget behind the component; see
+/// `javax.accessibility` for what else is kept.
+public abstract class JComponent extends Container {
+
+    public static final int WHEN_FOCUSED = 0;
+    public static final int WHEN_ANCESTOR_OF_FOCUSED_COMPONENT = 1;
+    public static final int WHEN_IN_FOCUSED_WINDOW = 2;
+    public static final int UNDEFINED_CONDITION = -1;
+    public static final String TOOL_TIP_TEXT_KEY = "ToolTipText";
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private Border border;
+    private boolean opaque;
+    private float alignmentX = -1;
+    private float alignmentY = -1;
+    private String toolTipText;
+    private AccessibleContext cn1Accessible;
+    private HashMap<Object, Object> clientProperties;
+    private InputMap focusInputMap;
+    private InputMap ancestorInputMap;
+    private ComponentInputMap windowInputMap;
+    private ActionMap actionMap;
+    private JPopupMenu popupMenu;
+    private boolean inheritsPopupMenu;
+    private InputVerifier inputVerifier;
+    private boolean verifyInputWhenFocusTarget = true;
+    /// Whether this is a component a look and feel gives colors to: 0 not
+    /// asked yet, 1 yes, 2 no.
+    private byte lookAndFeelColors;
+
+    public JComponent() {
+    }
+
+    /// Does nothing: there are no UI delegates to refresh.
+    public void updateUI() {
+    }
+
+    // ------------------------------------------------------------ paint
+
+    @Override
+    public void paint(Graphics g) {
+        if (getWidth() <= 0 || getHeight() <= 0) {
+            return;
+        }
+        Graphics co = g.create();
+        try {
+            paintComponent(co);
+        } finally {
+            co.dispose();
+        }
+        co = g.create();
+        try {
+            paintBorder(co);
+        } finally {
+            co.dispose();
+        }
+        paintChildren(g);
+    }
+
+    @Override
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    /// Draws the Codename One widget behind this component if it has one;
+    /// otherwise fills the background when the component is opaque.
+    protected void paintComponent(Graphics g) {
+        if (cn1PaintNative(g)) {
+            return;
+        }
+        if (isOpaque()) {
+            Color bg = getBackground();
+            if (bg != null) {
+                g.setColor(bg);
+                g.fillRect(0, 0, getWidth(), getHeight());
+            }
+        }
+    }
+
+    protected void paintBorder(Graphics g) {
+        if (border != null) {
+            border.paintBorder(this, g, 0, 0, getWidth(), getHeight());
+        }
+    }
+
+    protected void paintChildren(Graphics g) {
+        cn1PaintChildren(g);
+    }
+
+    public void repaint(Rectangle r) {
+        repaint(0, r.x, r.y, r.width, r.height);
+    }
+
+    /// Asks for a repaint; nothing is painted before this returns.
+    public void paintImmediately(int x, int y, int w, int h) {
+        repaint(0, x, y, w, h);
+    }
+
+    public void paintImmediately(Rectangle r) {
+        repaint(0, r.x, r.y, r.width, r.height);
+    }
+
+    /// The font this component draws with, which is never null. On a desktop
+    /// every Swing component has the font its look and feel installed, so
+    /// `getFont().deriveFont(Font.BOLD)` is written everywhere, a cell
+    /// renderer included -- and a renderer is in no window to inherit a font
+    /// from. One that was given none answers the theme's default, which is
+    /// what a window answers for everything shown in it.
+    @Override
+    public com.codename1.desktopcompat.java.awt.Font getFont() {
+        com.codename1.desktopcompat.java.awt.Font f = super.getFont();
+        return f != null ? f : com.codename1.desktopcompat.rt.Fonts.defaultFont();
+    }
+
+    /// Whether this is one of the components whose look and feel installs
+    /// a background and a foreground. On a desktop every Swing widget is,
+    /// so none of them takes its colors from the container around it; a
+    /// class that extends `JComponent` directly, a `Box` or a layered pane
+    /// has no look and feel and inherits them, as any AWT component does.
+    private boolean cn1LookAndFeelColors() {
+        if (lookAndFeelColors == 0) {
+            Object o = this;
+            boolean has = o instanceof JPanel || o instanceof JLabel || o instanceof AbstractButton
+                    || o instanceof JScrollPane || o instanceof JViewport || o instanceof JScrollBar
+                    || o instanceof JSplitPane || o instanceof JTabbedPane || o instanceof JToolBar
+                    || o instanceof JMenuBar || o instanceof JPopupMenu || o instanceof JSlider
+                    || o instanceof JProgressBar || o instanceof JComboBox || o instanceof JInternalFrame
+                    || o instanceof JRootPane || o instanceof JOptionPane || o instanceof JSeparator
+                    || o instanceof JSpinner || o instanceof JColorChooser || o instanceof JFileChooser
+                    || o instanceof JList || o instanceof JTable || o instanceof JTree || o instanceof JDesktopPane
+                    || o instanceof com.codename1.desktopcompat.javax.swing.text.JTextComponent
+                    || o instanceof com.codename1.desktopcompat.javax.swing.table.JTableHeader;
+            lookAndFeelColors = (byte) (has ? 1 : 2);
+        }
+        return lookAndFeelColors == 1;
+    }
+
+    /// The background that was set, and otherwise the one the look and
+    /// feel gives a widget -- the `control` color of [UIManager], which is
+    /// the theme's window background unless the application put another.
+    /// Only a component without a look and feel answers the background of
+    /// its parent.
+    @Override
+    public Color getBackground() {
+        if (!isBackgroundSet() && cn1LookAndFeelColors()) {
+            Object o = this;
+            // A content area is not the colour of the window around it.
+            String key = o instanceof JDesktopPane ? "Desktop.background"
+                    : o instanceof com.codename1.desktopcompat.javax.swing.text.JTextComponent ? "text" : "control";
+            Color c = UIManager.getColor(key);
+            if (c != null) {
+                return c;
+            }
+        }
+        return super.getBackground();
+    }
+
+    /// The foreground that was set, and otherwise the `controlText` color
+    /// of [UIManager] for a widget; see [#getBackground].
+    @Override
+    public Color getForeground() {
+        if (!isForegroundSet() && cn1LookAndFeelColors()) {
+            Color c = UIManager.getColor("controlText");
+            if (c != null) {
+                return c;
+            }
+        }
+        return super.getForeground();
+    }
+
+    @Override
+    public boolean isOpaque() {
+        return opaque;
+    }
+
+    public void setOpaque(boolean isOpaque) {
+        boolean old = opaque;
+        opaque = isOpaque;
+        firePropertyChange("opaque", old, isOpaque);
+        repaint();
+    }
+
+    @Override
+    public boolean isDoubleBuffered() {
+        return true;
+    }
+
+    public void setDoubleBuffered(boolean aFlag) {
+    }
+
+    public Rectangle getVisibleRect() {
+        return new Rectangle(0, 0, getWidth(), getHeight());
+    }
+
+    // ------------------------------------------------------------ border
+
+    public void setBorder(Border border) {
+        Border old = this.border;
+        this.border = border;
+        firePropertyChange("border", old, border);
+        if (border != old) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    public Border getBorder() {
+        return border;
+    }
+
+    @Override
+    public Insets getInsets() {
+        if (border != null) {
+            return border.getBorderInsets(this);
+        }
+        return super.getInsets();
+    }
+
+    public Insets getInsets(Insets insets) {
+        Insets i = getInsets();
+        if (insets == null) {
+            return i;
+        }
+        insets.top = i.top;
+        insets.left = i.left;
+        insets.bottom = i.bottom;
+        insets.right = i.right;
+        return insets;
+    }
+
+    // ------------------------------------------------------------ sizes
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (!isMaximumSizeSet()) {
+            Dimension d = cn1NativePreferredSize();
+            if (d != null) {
+                return d;
+            }
+        }
+        return super.getMaximumSize();
+    }
+
+    @Override
+    public float getAlignmentX() {
+        return alignmentX >= 0 ? alignmentX : super.getAlignmentX();
+    }
+
+    public void setAlignmentX(float alignmentX) {
+        this.alignmentX = alignmentX > 1.0f ? 1.0f : alignmentX < 0.0f ? 0.0f : alignmentX;
+    }
+
+    @Override
+    public float getAlignmentY() {
+        return alignmentY >= 0 ? alignmentY : super.getAlignmentY();
+    }
+
+    public void setAlignmentY(float alignmentY) {
+        this.alignmentY = alignmentY > 1.0f ? 1.0f : alignmentY < 0.0f ? 0.0f : alignmentY;
+    }
+
+    // ------------------------------------------------------------ misc
+
+    /// Sets the tool tip of the Codename One widget behind this
+    /// component. A text that is not `null` registers the component with
+    /// the `ToolTipManager`, as in Swing, and `null` takes it out again.
+    public void setToolTipText(String text) {
+        String old = toolTipText;
+        toolTipText = text;
+        if (text != null) {
+            if (old == null) {
+                ToolTipManager.sharedInstance().registerComponent(this);
+            }
+        } else if (old != null) {
+            ToolTipManager.sharedInstance().unregisterComponent(this);
+        }
+        cn1ApplyToolTip();
+        firePropertyChange(TOOL_TIP_TEXT_KEY, old, text);
+    }
+
+    /// The tool tip for where the pointer of `event` is. As it comes it
+    /// is the text that was set; a component with a tip per place
+    /// overrides this, and is asked whenever the pointer moves over it.
+    public String getToolTipText(MouseEvent event) {
+        return getToolTipText();
+    }
+
+    /// Gives the widget the tool tip, or none while the tool tip manager
+    /// is disabled.
+    void cn1ApplyToolTip() {
+        cn1Tip(toolTipText);
+    }
+
+    /// The pointer is over the component: the widget gets the tip for
+    /// that place.
+    void cn1ToolTipAt(MouseEvent e) {
+        cn1Tip(getToolTipText(e));
+    }
+
+    private void cn1Tip(String text) {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p != null) {
+            // An empty text shows no tip, in Swing as here.
+            boolean show = text != null && text.length() > 0 && ToolTipManager.sharedInstance().isEnabled();
+            p.setTooltip(show ? text : null);
+        }
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        if (toolTipText != null) {
+            cn1ApplyToolTip();
+        }
+        cn1ApplyAccessibleName();
+    }
+
+    /// What this component tells assistive technology about itself.
+    public AccessibleContext getAccessibleContext() {
+        if (cn1Accessible == null) {
+            cn1Accessible = new Cn1Accessible(this);
+        }
+        return cn1Accessible;
+    }
+
+    /// Gives the widget the accessible name as its accessibility text.
+    void cn1ApplyAccessibleName() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        String name = cn1Accessible == null ? null : cn1Accessible.getAccessibleName();
+        if (p != null && name != null) {
+            p.setAccessibilityText(name);
+        }
+    }
+
+    /// The context of a component: the name goes on to the widget.
+    private static final class Cn1Accessible extends AccessibleContext {
+
+        private final JComponent owner;
+
+        Cn1Accessible(JComponent owner) {
+            this.owner = owner;
+        }
+
+        @Override
+        public void setAccessibleName(String s) {
+            super.setAccessibleName(s);
+            owner.cn1ApplyAccessibleName();
+        }
+    }
+
+    public String getToolTipText() {
+        return toolTipText;
+    }
+
+    // ------------------------------------------------------------ transfer
+
+    private TransferHandler cn1TransferHandler;
+
+    /// Sets what moves data into and out of this component. With a
+    /// handler the component is a drop target, unless the application
+    /// gave it a `DropTarget` of its own.
+    public void setTransferHandler(TransferHandler newHandler) {
+        TransferHandler old = cn1TransferHandler;
+        cn1TransferHandler = newHandler;
+        DropTarget target = getDropTarget();
+        if (target == null || target instanceof UIResource) {
+            setDropTarget(newHandler == null ? null : TransferHandler.cn1DropTarget(this));
+        }
+        firePropertyChange("transferHandler", old, newHandler);
+    }
+
+    public TransferHandler getTransferHandler() {
+        return cn1TransferHandler;
+    }
+
+    /// Where a drop at `p` would go, in this component's own terms; `null`
+    /// for a component that has none.
+    TransferHandler.DropLocation dropLocationForPoint(Point p) {
+        return null;
+    }
+
+    /// Shows where a drop would go, or with `null` stops showing it.
+    /// `state` is what the last call answered, and `forDrop` whether the
+    /// drop happened and was taken.
+    Object setDropLocation(TransferHandler.DropLocation location, Object state, boolean forDrop) {
+        return null;
+    }
+
+    public final Object getClientProperty(Object key) {
+        return clientProperties == null ? null : clientProperties.get(key);
+    }
+
+    public final void putClientProperty(Object key, Object value) {
+        if (clientProperties == null) {
+            if (value == null) {
+                return;
+            }
+            clientProperties = new HashMap<Object, Object>();
+        }
+        Object old = clientProperties.get(key);
+        if (value == null) {
+            clientProperties.remove(key);
+        } else {
+            clientProperties.put(key, value);
+        }
+        // The FlatLaf vocabulary (placeholder text, button types, style
+        // classes) is honoured where the property is set, not swallowed.
+        com.codename1.desktopcompat.rt.ClientProps.changed(this, key, value);
+        firePropertyChange(String.valueOf(key), old, value);
+    }
+
+    public void grabFocus() {
+        requestFocus();
+    }
+
+    public void setRequestFocusEnabled(boolean requestFocusEnabled) {
+    }
+
+    public JRootPane getRootPane() {
+        return SwingUtilities.getRootPane(this);
+    }
+
+    public Container getTopLevelAncestor() {
+        for (Container p = this; p != null; p = p.getParent()) {
+            if (p instanceof com.codename1.desktopcompat.java.awt.Window) {
+                return p;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+        super.firePropertyChange(propertyName, oldValue, newValue);
+    }
+
+    @Override
+    public void firePropertyChange(String propertyName, int oldValue, int newValue) {
+        super.firePropertyChange(propertyName, oldValue, newValue);
+    }
+
+    // ------------------------------------------------------------ scroll
+
+    /// Scrolls the viewports this component is in, innermost first, so
+    /// that a rectangle of it is visible. Nothing happens outside a
+    /// viewport.
+    public void scrollRectToVisible(Rectangle aRect) {
+        JViewport.cn1ScrollRectToVisible(this, aRect);
+    }
+
+    // ------------------------------------------------------------ verifier
+
+    /// Sets what decides whether the focus may leave this component.
+    ///
+    /// It is asked when another Swing component requests the focus, and
+    /// the request is refused when it does not yield. It cannot hold the
+    /// focus against the platform: when the Codename One widget behind
+    /// this component loses the focus by itself, it is gone.
+    public void setInputVerifier(InputVerifier inputVerifier) {
+        InputVerifier old = this.inputVerifier;
+        this.inputVerifier = inputVerifier;
+        firePropertyChange("inputVerifier", old, inputVerifier);
+    }
+
+    public InputVerifier getInputVerifier() {
+        return inputVerifier;
+    }
+
+    /// Whether the input verifier of the focus owner is asked before
+    /// this component takes the focus; true unless set otherwise, and
+    /// false is what a cancel button wants.
+    public void setVerifyInputWhenFocusTarget(boolean verifyInputWhenFocusTarget) {
+        boolean old = this.verifyInputWhenFocusTarget;
+        this.verifyInputWhenFocusTarget = verifyInputWhenFocusTarget;
+        firePropertyChange("verifyInputWhenFocusTarget", old, verifyInputWhenFocusTarget);
+    }
+
+    public boolean getVerifyInputWhenFocusTarget() {
+        return verifyInputWhenFocusTarget;
+    }
+
+    /// Takes the focus unless the input verifier of the component that
+    /// has it objects.
+    @Override
+    public boolean requestFocusInWindow() {
+        Component owner = EventBridge.focusOwner();
+        if (verifyInputWhenFocusTarget && owner != this && owner instanceof JComponent) {
+            JComponent from = (JComponent) owner;
+            InputVerifier v = from.getInputVerifier();
+            if (v != null && !v.shouldYieldFocus(from)) {
+                return false;
+            }
+        }
+        return super.requestFocusInWindow();
+    }
+
+    // ------------------------------------------------------------ popup
+
+    /// Sets the popup menu that opens on the popup trigger over this
+    /// component: a press of the secondary mouse button, or a long press
+    /// of a finger.
+    public void setComponentPopupMenu(JPopupMenu popup) {
+        JPopupMenu old = popupMenu;
+        popupMenu = popup;
+        firePropertyChange("componentPopupMenu", old, popup);
+    }
+
+    public JPopupMenu getComponentPopupMenu() {
+        if (!inheritsPopupMenu || popupMenu != null) {
+            return popupMenu;
+        }
+        for (Container p = getParent(); p != null; p = p.getParent()) {
+            if (p instanceof JComponent) {
+                return ((JComponent) p).getComponentPopupMenu();
+            }
+            if (p instanceof Window) {
+                break;
+            }
+        }
+        return null;
+    }
+
+    public void setInheritsPopupMenu(boolean value) {
+        boolean old = inheritsPopupMenu;
+        inheritsPopupMenu = value;
+        firePropertyChange("inheritsPopupMenu", old, value);
+    }
+
+    public boolean getInheritsPopupMenu() {
+        return inheritsPopupMenu;
+    }
+
+    // ------------------------------------------------------------ keys
+
+    public final InputMap getInputMap() {
+        return getInputMap(WHEN_FOCUSED);
+    }
+
+    /// The input map of a condition, created on first use.
+    public final InputMap getInputMap(int condition) {
+        switch (condition) {
+            case WHEN_FOCUSED:
+                if (focusInputMap == null) {
+                    focusInputMap = new InputMap();
+                }
+                return focusInputMap;
+            case WHEN_ANCESTOR_OF_FOCUSED_COMPONENT:
+                if (ancestorInputMap == null) {
+                    ancestorInputMap = new InputMap();
+                }
+                return ancestorInputMap;
+            case WHEN_IN_FOCUSED_WINDOW:
+                if (windowInputMap == null) {
+                    windowInputMap = new ComponentInputMap(this);
+                }
+                return windowInputMap;
+            default:
+                throw new IllegalArgumentException("condition must be one of JComponent.WHEN_IN_FOCUSED_WINDOW, "
+                        + "JComponent.WHEN_FOCUSED or JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT");
+        }
+    }
+
+    public final void setInputMap(int condition, InputMap map) {
+        switch (condition) {
+            case WHEN_FOCUSED:
+                focusInputMap = map;
+                break;
+            case WHEN_ANCESTOR_OF_FOCUSED_COMPONENT:
+                ancestorInputMap = map;
+                break;
+            case WHEN_IN_FOCUSED_WINDOW:
+                if (map == null) {
+                    windowInputMap = null;
+                } else if (map instanceof ComponentInputMap) {
+                    windowInputMap = (ComponentInputMap) map;
+                } else {
+                    throw new IllegalArgumentException(
+                            "WHEN_IN_FOCUSED_WINDOW InputMaps must be of type ComponentInputMap");
+                }
+                break;
+            default:
+                throw new IllegalArgumentException("condition must be one of JComponent.WHEN_IN_FOCUSED_WINDOW, "
+                        + "JComponent.WHEN_FOCUSED or JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT");
+        }
+    }
+
+    private InputMap inputMapOrNull(int condition) {
+        return condition == WHEN_FOCUSED ? focusInputMap
+                : condition == WHEN_ANCESTOR_OF_FOCUSED_COMPONENT ? ancestorInputMap
+                : condition == WHEN_IN_FOCUSED_WINDOW ? windowInputMap : null;
+    }
+
+    public final ActionMap getActionMap() {
+        if (actionMap == null) {
+            actionMap = new ActionMap();
+        }
+        return actionMap;
+    }
+
+    public final void setActionMap(ActionMap am) {
+        actionMap = am;
+    }
+
+    public void registerKeyboardAction(ActionListener anAction, String aCommand, KeyStroke aKeyStroke,
+            int aCondition) {
+        InputMap im = getInputMap(aCondition);
+        Standin standin = new Standin(anAction, aCommand);
+        im.put(aKeyStroke, standin);
+        getActionMap().put(standin, standin);
+    }
+
+    public void registerKeyboardAction(ActionListener anAction, KeyStroke aKeyStroke, int aCondition) {
+        registerKeyboardAction(anAction, null, aKeyStroke, aCondition);
+    }
+
+    public void unregisterKeyboardAction(KeyStroke aKeyStroke) {
+        for (int c = WHEN_FOCUSED; c <= WHEN_IN_FOCUSED_WINDOW; c++) {
+            InputMap im = inputMapOrNull(c);
+            if (im != null) {
+                Object key = im.get(aKeyStroke);
+                if (key != null && actionMap != null) {
+                    actionMap.remove(key);
+                }
+                im.remove(aKeyStroke);
+            }
+        }
+    }
+
+    public KeyStroke[] getRegisteredKeyStrokes() {
+        ArrayList<KeyStroke> l = new ArrayList<KeyStroke>();
+        for (int c = WHEN_FOCUSED; c <= WHEN_IN_FOCUSED_WINDOW; c++) {
+            InputMap im = inputMapOrNull(c);
+            KeyStroke[] ks = im == null ? null : im.allKeys();
+            if (ks != null) {
+                for (int i = 0; i < ks.length; i++) {
+                    l.add(ks[i]);
+                }
+            }
+        }
+        return l.toArray(new KeyStroke[l.size()]);
+    }
+
+    public int getConditionForKeyStroke(KeyStroke aKeyStroke) {
+        for (int c = WHEN_FOCUSED; c <= WHEN_IN_FOCUSED_WINDOW; c++) {
+            InputMap im = inputMapOrNull(c);
+            if (im != null && im.get(aKeyStroke) != null) {
+                return c;
+            }
+        }
+        return UNDEFINED_CONDITION;
+    }
+
+    public ActionListener getActionForKeyStroke(KeyStroke aKeyStroke) {
+        if (actionMap == null) {
+            return null;
+        }
+        for (int c = WHEN_FOCUSED; c <= WHEN_IN_FOCUSED_WINDOW; c++) {
+            InputMap im = inputMapOrNull(c);
+            Object key = im == null ? null : im.get(aKeyStroke);
+            Action a = key == null ? null : actionMap.get(key);
+            if (a != null) {
+                return a instanceof Standin ? ((Standin) a).listener : a;
+            }
+        }
+        return null;
+    }
+
+    public void resetKeyboardActions() {
+        for (int c = WHEN_FOCUSED; c <= WHEN_IN_FOCUSED_WINDOW; c++) {
+            InputMap im = inputMapOrNull(c);
+            if (im != null) {
+                im.clear();
+            }
+        }
+        if (actionMap != null) {
+            actionMap.clear();
+        }
+    }
+
+    /// Runs the action bound to a key stroke under one condition, if this
+    /// component is enabled and has one. Answers whether an action ran.
+    protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed) {
+        InputMap im = inputMapOrNull(condition);
+        if (im == null || actionMap == null || !isEnabled()) {
+            return false;
+        }
+        Object key = im.get(ks);
+        Action a = key == null ? null : actionMap.get(key);
+        return a != null && SwingUtilities.notifyAction(a, ks, e, this, e.getModifiers());
+    }
+
+    /// After the key listeners, looks the event up in the key bindings.
+    @Override
+    protected void processKeyEvent(KeyEvent e) {
+        super.processKeyEvent(e);
+        if (!e.isConsumed()) {
+            cn1KeyBindings(this, e);
+        }
+    }
+
+    /// A stop of the tab key also when it has `WHEN_FOCUSED` bindings.
+    @Override
+    public boolean cn1FocusTraversable() {
+        return super.cn1FocusTraversable() || (focusInputMap != null && focusInputMap.size() > 0);
+    }
+
+    /// Looks a key event up in the key bindings that apply to `target`,
+    /// the component it is for, and consumes it when an action ran.
+    public static boolean cn1KeyBindings(Component target, KeyEvent e) {
+        KeyStroke ks = KeyStroke.getKeyStrokeForEvent(e);
+        if (ks == null) {
+            return false;
+        }
+        boolean pressed = e.getID() == KeyEvent.KEY_PRESSED;
+        boolean done = target instanceof JComponent
+                && ((JComponent) target).processKeyBinding(ks, e, WHEN_FOCUSED, pressed);
+        Component top = target;
+        for (Component c = target; c != null && !done; c = c.getParent()) {
+            top = c;
+            if (c instanceof Window) {
+                break;
+            }
+            if (c instanceof JComponent) {
+                done = ((JComponent) c).processKeyBinding(ks, e, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, pressed);
+            }
+        }
+        if (!done) {
+            done = windowBindings(top, ks, e, pressed);
+        }
+        if (done) {
+            e.consume();
+        }
+        return done;
+    }
+
+    private static boolean windowBindings(Component c, KeyStroke ks, KeyEvent e, boolean pressed) {
+        if (!c.isVisible() || !c.isEnabled()) {
+            return false;
+        }
+        if (c instanceof JComponent
+                && ((JComponent) c).processKeyBinding(ks, e, WHEN_IN_FOCUSED_WINDOW, pressed)) {
+            return true;
+        }
+        if (c instanceof Container) {
+            Component[] cs = ((Container) c).getComponents();
+            for (int i = 0; i < cs.length; i++) {
+                if (windowBindings(cs[i], ks, e, pressed)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /// The action a listener registered with `registerKeyboardAction`
+    /// becomes: it runs the listener with the command it was given.
+    private static final class Standin implements Action {
+
+        final ActionListener listener;
+        private final String command;
+
+        Standin(ActionListener listener, String command) {
+            this.listener = listener;
+            this.command = command;
+        }
+
+        @Override
+        public Object getValue(String key) {
+            if (ACTION_COMMAND_KEY.equals(key)) {
+                return command;
+            }
+            return listener instanceof Action ? ((Action) listener).getValue(key) : null;
+        }
+
+        @Override
+        public void putValue(String key, Object value) {
+        }
+
+        @Override
+        public void setEnabled(boolean b) {
+        }
+
+        @Override
+        public boolean isEnabled() {
+            return listener != null && (!(listener instanceof Action) || ((Action) listener).isEnabled());
+        }
+
+        @Override
+        public void addPropertyChangeListener(PropertyChangeListener l) {
+        }
+
+        @Override
+        public void removePropertyChangeListener(PropertyChangeListener l) {
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+            listener.actionPerformed(ae);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JDesktopPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JDesktopPane.java
new file mode 100644
index 00000000000..8a2cdf71814
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JDesktopPane.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import java.util.ArrayList;
+
+/// The desk internal frames lie on: a layered pane that knows its frames
+/// and which of them is selected.
+///
+/// Frames are drawn and moved by [JInternalFrame] itself; there is no
+/// desktop manager to replace. A frame is always moved and resized live,
+/// whatever the drag mode says.
+public class JDesktopPane extends JLayeredPane {
+
+    public static final int LIVE_DRAG_MODE = 0;
+
+    public static final int OUTLINE_DRAG_MODE = 1;
+
+    private JInternalFrame selectedFrame;
+    private int dragMode = LIVE_DRAG_MODE;
+
+    public JDesktopPane() {
+        setOpaque(true);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (isOpaque()) {
+            g.setColor(getBackground());
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+    }
+
+    /// Kept and answered; frames are always dragged live.
+    public void setDragMode(int dragMode) {
+        int old = this.dragMode;
+        this.dragMode = dragMode;
+        firePropertyChange("dragMode", old, dragMode);
+    }
+
+    public int getDragMode() {
+        return dragMode;
+    }
+
+    /// Every internal frame on the desk, the one on top first.
+    public JInternalFrame[] getAllFrames() {
+        ArrayList<JInternalFrame> found = new ArrayList<JInternalFrame>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c instanceof JInternalFrame) {
+                found.add((JInternalFrame) c);
+            }
+        }
+        return found.toArray(new JInternalFrame[found.size()]);
+    }
+
+    public JInternalFrame[] getAllFramesInLayer(int layer) {
+        ArrayList<JInternalFrame> found = new ArrayList<JInternalFrame>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c instanceof JInternalFrame && getLayer(c) == layer) {
+                found.add((JInternalFrame) c);
+            }
+        }
+        return found.toArray(new JInternalFrame[found.size()]);
+    }
+
+    public JInternalFrame getSelectedFrame() {
+        return selectedFrame;
+    }
+
+    /// Records which frame is the selected one. It does not select it:
+    /// that is `JInternalFrame.setSelected`.
+    public void setSelectedFrame(JInternalFrame f) {
+        selectedFrame = f;
+    }
+
+    @Override
+    public void remove(int index) {
+        Component c = getComponent(index);
+        super.remove(index);
+        if (c == selectedFrame) {
+            selectedFrame = null;
+        }
+    }
+
+    @Override
+    public void removeAll() {
+        super.removeAll();
+        selectedFrame = null;
+    }
+
+    /// Nothing, unless a minimum size was set: as on the desktop, a
+    /// desktop pane can be any size and its frames stay where they are.
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return new Dimension(0, 0);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JDialog.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JDialog.java
new file mode 100644
index 00000000000..5e9212190dc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JDialog.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+
+/// The Swing dialog: a dialog with a root pane and a content pane like a
+/// frame's. Showing a modal one blocks its caller; see `Dialog`.
+///
+/// A request to close it runs the default close operation after the
+/// window listeners: `HIDE_ON_CLOSE` (the default), `DISPOSE_ON_CLOSE` or
+/// `DO_NOTHING_ON_CLOSE`.
+public class JDialog extends Dialog implements WindowConstants, RootPaneContainer {
+
+    protected JRootPane rootPane;
+    protected boolean rootPaneCheckingEnabled;
+
+    private int defaultCloseOperation = HIDE_ON_CLOSE;
+
+    public JDialog() {
+        this((Frame) null, "", false);
+    }
+
+    public JDialog(Frame owner) {
+        this(owner, "", false);
+    }
+
+    public JDialog(Frame owner, boolean modal) {
+        this(owner, "", modal);
+    }
+
+    public JDialog(Frame owner, String title) {
+        this(owner, title, false);
+    }
+
+    public JDialog(Frame owner, String title, boolean modal) {
+        super(owner, title, modal);
+        dialogInit();
+    }
+
+    public JDialog(Dialog owner) {
+        this(owner, "", false);
+    }
+
+    public JDialog(Dialog owner, boolean modal) {
+        this(owner, "", modal);
+    }
+
+    public JDialog(Dialog owner, String title) {
+        this(owner, title, false);
+    }
+
+    public JDialog(Dialog owner, String title, boolean modal) {
+        super(owner, title, modal);
+        dialogInit();
+    }
+
+    public JDialog(Window owner) {
+        this(owner, "", ModalityType.MODELESS);
+    }
+
+    public JDialog(Window owner, ModalityType modalityType) {
+        this(owner, "", modalityType);
+    }
+
+    public JDialog(Window owner, String title) {
+        this(owner, title, ModalityType.MODELESS);
+    }
+
+    public JDialog(Window owner, String title, ModalityType modalityType) {
+        super(owner, title, modalityType);
+        dialogInit();
+    }
+
+    protected void dialogInit() {
+        setRootPane(createRootPane());
+        setRootPaneCheckingEnabled(true);
+    }
+
+    protected JRootPane createRootPane() {
+        return new JRootPane();
+    }
+
+    @Override
+    public JRootPane getRootPane() {
+        return rootPane;
+    }
+
+    protected void setRootPane(JRootPane root) {
+        boolean checking = rootPaneCheckingEnabled;
+        rootPaneCheckingEnabled = false;
+        try {
+            if (rootPane != null) {
+                remove(rootPane);
+            }
+            rootPane = root;
+            if (root != null) {
+                add(root, BorderLayout.CENTER);
+            }
+        } finally {
+            rootPaneCheckingEnabled = checking;
+        }
+    }
+
+    @Override
+    public Container getContentPane() {
+        return rootPane.getContentPane();
+    }
+
+    @Override
+    public void setContentPane(Container contentPane) {
+        rootPane.setContentPane(contentPane);
+    }
+
+    @Override
+    public JLayeredPane getLayeredPane() {
+        return rootPane.getLayeredPane();
+    }
+
+    @Override
+    public void setLayeredPane(JLayeredPane layeredPane) {
+        rootPane.setLayeredPane(layeredPane);
+    }
+
+    @Override
+    public Component getGlassPane() {
+        return rootPane.getGlassPane();
+    }
+
+    @Override
+    public void setGlassPane(Component glassPane) {
+        rootPane.setGlassPane(glassPane);
+    }
+
+    public JMenuBar getJMenuBar() {
+        return rootPane.getJMenuBar();
+    }
+
+    public void setJMenuBar(JMenuBar menu) {
+        rootPane.setJMenuBar(menu);
+    }
+
+    protected boolean isRootPaneCheckingEnabled() {
+        return rootPaneCheckingEnabled;
+    }
+
+    protected void setRootPaneCheckingEnabled(boolean enabled) {
+        rootPaneCheckingEnabled = enabled;
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().add(comp, constraints, index);
+        } else {
+            super.addImpl(comp, constraints, index);
+        }
+    }
+
+    @Override
+    public void remove(Component comp) {
+        if (comp == rootPane || !rootPaneCheckingEnabled) {
+            super.remove(comp);
+        } else {
+            getContentPane().remove(comp);
+        }
+    }
+
+    @Override
+    public void setLayout(LayoutManager manager) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().setLayout(manager);
+        } else {
+            super.setLayout(manager);
+        }
+    }
+
+    @Override
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public int getDefaultCloseOperation() {
+        return defaultCloseOperation;
+    }
+
+    public void setDefaultCloseOperation(int operation) {
+        if (operation != DO_NOTHING_ON_CLOSE && operation != HIDE_ON_CLOSE && operation != DISPOSE_ON_CLOSE) {
+            throw new IllegalArgumentException("defaultCloseOperation must be one of: DO_NOTHING_ON_CLOSE, "
+                    + "HIDE_ON_CLOSE, or DISPOSE_ON_CLOSE");
+        }
+        int old = defaultCloseOperation;
+        defaultCloseOperation = operation;
+        firePropertyChange("defaultCloseOperation", old, operation);
+    }
+
+    @Override
+    protected void processWindowEvent(WindowEvent e) {
+        super.processWindowEvent(e);
+        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
+            if (defaultCloseOperation == HIDE_ON_CLOSE) {
+                setVisible(false);
+            } else if (defaultCloseOperation == DISPOSE_ON_CLOSE) {
+                dispose();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JEditorPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JEditorPane.java
new file mode 100644
index 00000000000..496e83ffd26
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JEditorPane.java
@@ -0,0 +1,486 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.event.HyperlinkEvent;
+import com.codename1.desktopcompat.javax.swing.event.HyperlinkListener;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.rt.MiniHtml;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/// A multi-line text component with a content type.
+///
+/// With the content type `text/plain` it is a text area. With `text/html`
+/// the markup is shown formatted, by the reader the labels use: bold,
+/// italic, underline, `font` colors and sizes, headings, paragraphs, line
+/// breaks, lists as dashed lines, centered and aligned blocks, the common
+/// entities, and links. Lines are wrapped at the pane's width. Anything
+/// else in the markup -- tables, images, style sheets -- is read as the
+/// text it contains.
+///
+/// A click on a link fires a `HyperlinkEvent` of the type `ACTIVATED` to
+/// the pane's `HyperlinkListener`s, with the link's `href` as its
+/// description and, when the `href` is an absolute URL, as its URL.
+///
+/// ## What differs from the desktop
+///
+///  - A pane that shows HTML is never edited by the user, whatever
+///    `setEditable` says; on the desktop links work only in a pane that is
+///    not editable, and that is the one kind there is here. Its document
+///    holds the text without the tags, and [#getText()] answers the markup
+///    that was set.
+///  - There are no editor kits. Styled documents are shown by
+///    [JTextPane].
+///  - [#setPage(URL)] reads the whole page before it returns, where the
+///    desktop may load it in the background. A link relative to the page
+///    is resolved against it.
+///  - Only `ACTIVATED` is fired; there is no `ENTERED` and `EXITED` as
+///    the pointer moves over a link.
+public class JEditorPane extends JTextComponent {
+
+    private static final int PAD = 3;
+
+    private String contentType = "text/plain";
+    private String markup;
+    private String shown;
+    private MiniHtml.Document page;
+    private URL pageUrl;
+
+    public JEditorPane() {
+        setDocument(new PlainDocument());
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK);
+    }
+
+    public JEditorPane(String type, String text) {
+        this();
+        setContentType(type);
+        setText(text);
+    }
+
+    /// A pane that shows the page at `initialPage`.
+    public JEditorPane(URL initialPage) throws IOException {
+        this();
+        setPage(initialPage);
+    }
+
+    public JEditorPane(String url) throws IOException {
+        this();
+        setPage(url);
+    }
+
+    public void setPage(String url) throws IOException {
+        if (url == null) {
+            throw new IOException("invalid url");
+        }
+        setPage(new URL(url));
+    }
+
+    /// Reads the page and shows it: as HTML when its name ends in `.html`
+    /// or `.htm`, and as plain text otherwise. The text is read as UTF-8.
+    public void setPage(URL page) throws IOException {
+        if (page == null) {
+            throw new IOException("invalid url");
+        }
+        InputStream in = page.openStream();
+        if (in == null) {
+            throw new IOException("cannot read " + page);
+        }
+        String text;
+        try {
+            ByteArrayOutputStream all = new ByteArrayOutputStream();
+            byte[] chunk = new byte[4096];
+            for (int n = in.read(chunk); n >= 0; n = in.read(chunk)) {
+                all.write(chunk, 0, n);
+            }
+            text = new String(all.toByteArray(), "UTF-8");
+        } finally {
+            in.close();
+        }
+        String name = page.getPath();
+        int len = name == null ? 0 : name.length();
+        boolean html = len >= 5 && name.regionMatches(true, len - 5, ".html", 0, 5)
+                || len >= 4 && name.regionMatches(true, len - 4, ".htm", 0, 4);
+        URL old = pageUrl;
+        // Before the text is read: its pictures are found against it.
+        pageUrl = page;
+        setContentType(html ? "text/html" : "text/plain");
+        setText(text);
+        firePropertyChange("page", old, page);
+    }
+
+    /// The page [#setPage(URL)] showed last, or `null`.
+    public URL getPage() {
+        return pageUrl;
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new com.codename1.desktopcompat.rt.TextAreaPeer(this);
+    }
+
+    @Override
+    protected boolean cn1GrowsWithText() {
+        return true;
+    }
+
+    public final String getContentType() {
+        return contentType;
+    }
+
+    /// Sets the type of the content. Parameters after a `;`, such as a
+    /// character set, are dropped.
+    public final void setContentType(String type) {
+        if (type == null) {
+            throw new NullPointerException();
+        }
+        int semi = type.indexOf(';');
+        String bare = (semi >= 0 ? type.substring(0, semi) : type).trim();
+        String old = contentType;
+        contentType = bare;
+        firePropertyChange("contentType", old, bare);
+        cn1ApplyMode();
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        cn1ApplyMode();
+    }
+
+    @Override
+    public void setEditable(boolean b) {
+        super.setEditable(b);
+        cn1ApplyMode();
+    }
+
+    /// Keeps the widget from being edited while the pane shows a page.
+    void cn1ApplyMode() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.TextArea) {
+            ((com.codename1.ui.TextArea) p).setEditable(isEditable() && !html() && !cn1Styled());
+        }
+    }
+
+    /// Whether the pane draws its text itself because the document has
+    /// attributes; a text pane does.
+    boolean cn1Styled() {
+        return false;
+    }
+
+    /// The page that is showing, or `null` when the pane shows plain
+    /// text: its type is not HTML, or the text was changed through the
+    /// document since the markup was set.
+    private MiniHtml.Document cn1Page() {
+        if (!html() || markup == null || page == null) {
+            return null;
+        }
+        String now = super.getText();
+        return now != null && now.equals(shown) ? page : null;
+    }
+
+    Insets cn1TextInsets() {
+        Insets in = getInsets();
+        Insets m = getMargin();
+        int t = m == null ? PAD : m.top;
+        int l = m == null ? PAD : m.left;
+        int b = m == null ? PAD : m.bottom;
+        int r = m == null ? PAD : m.right;
+        return new Insets(in.top + t, in.left + l, in.bottom + b, in.right + r);
+    }
+
+    /// A page is as wide as its longest line and, once the pane has a
+    /// width, as high as its lines are when broken at that width.
+    @Override
+    public Dimension getPreferredSize() {
+        MiniHtml.Document doc = isPreferredSizeSet() ? null : cn1Page();
+        if (doc == null) {
+            return super.getPreferredSize();
+        }
+        Insets in = cn1TextInsets();
+        Font f = getFont();
+        Dimension whole = MiniHtml.preferredSize(doc, f);
+        int room = getWidth() - in.left - in.right;
+        int h = room > 0 ? MiniHtml.wrappedSize(doc, f, room).height : whole.height;
+        return new Dimension(whole.width + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        MiniHtml.Document doc = cn1Page();
+        if (doc == null) {
+            super.paintComponent(g);
+            return;
+        }
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (isOpaque()) {
+            Color bg = getBackground();
+            if (bg != null) {
+                g.setColor(bg);
+                g.fillRect(0, 0, getWidth(), getHeight());
+            }
+        }
+        Color fg = isForegroundSet() || p == null ? getForeground() : new Color(p.getStyle().getFgColor() & 0xffffff);
+        if (fg != null) {
+            g.setColor(fg);
+        }
+        g.setFont(getFont());
+        Insets in = cn1TextInsets();
+        MiniHtml.paint(g, doc, in.left, in.top, Math.max(1, getWidth() - in.left - in.right), MiniHtml.ALIGN_LEFT);
+    }
+
+    // ------------------------------------------------------------ links
+
+    public void addHyperlinkListener(HyperlinkListener listener) {
+        listenerList.add(HyperlinkListener.class, listener);
+    }
+
+    public void removeHyperlinkListener(HyperlinkListener listener) {
+        listenerList.remove(HyperlinkListener.class, listener);
+    }
+
+    public HyperlinkListener[] getHyperlinkListeners() {
+        return listenerList.getListeners(HyperlinkListener.class);
+    }
+
+    public void fireHyperlinkUpdate(HyperlinkEvent e) {
+        HyperlinkListener[] ls = getHyperlinkListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].hyperlinkUpdate(e);
+        }
+    }
+
+    /// The `href` of the link at a point of the pane, or `null`.
+    String cn1LinkAt(int x, int y) {
+        MiniHtml.Document doc = cn1Page();
+        if (doc == null) {
+            return null;
+        }
+        Insets in = cn1TextInsets();
+        return MiniHtml.hrefAt(doc, getFont(), Math.max(1, getWidth() - in.left - in.right), MiniHtml.ALIGN_LEFT,
+                x - in.left, y - in.top);
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        super.processMouseEvent(e);
+        if (e.getID() != MouseEvent.MOUSE_CLICKED || e.isConsumed() || !isEnabled()
+                || e.getButton() != MouseEvent.BUTTON1) {
+            return;
+        }
+        String href = cn1LinkAt(e.getX(), e.getY());
+        if (href == null) {
+            return;
+        }
+        URL url = null;
+        try {
+            url = new URL(href);
+        } catch (MalformedURLException notAbsolute) {
+            url = cn1Relative(href);
+        }
+        fireHyperlinkUpdate(new HyperlinkEvent(this, HyperlinkEvent.EventType.ACTIVATED, url, href));
+    }
+
+    /// A relative link against the page that is showing; `null` when the
+    /// text was not read from a page, and the listener then gets the link
+    /// as the description alone.
+    private URL cn1Relative(String href) {
+        if (pageUrl == null) {
+            return null;
+        }
+        try {
+            return new URL(pageUrl, href);
+        } catch (MalformedURLException unusable) {
+            return null;
+        }
+    }
+
+    /// The picture an `<img>` of the page names: an absolute URL as it
+    /// is, anything else against the page that is showing. A page read
+    /// from a resource of the application finds its pictures among the
+    /// resources the same way it finds the pages it links to.
+    private com.codename1.desktopcompat.java.awt.Image cn1Image(String src) {
+        URL url;
+        try {
+            url = new URL(src);
+        } catch (MalformedURLException notAbsolute) {
+            url = cn1Relative(src);
+        }
+        com.codename1.ui.Image img = com.codename1.desktopcompat.rt.ImageLoader.fromUrl(url);
+        return img == null ? null : com.codename1.desktopcompat.rt.ImageLoader.wrap(img);
+    }
+
+    private boolean html() {
+        return "text/html".equalsIgnoreCase(contentType);
+    }
+
+    @Override
+    public void setText(String t) {
+        if (html() && t != null) {
+            markup = t;
+            page = MiniHtml.parse(t, new MiniHtml.ImageSource() {
+                @Override
+                public com.codename1.desktopcompat.java.awt.Image image(String src) {
+                    return cn1Image(src);
+                }
+            });
+            shown = cn1PlainText(t);
+            super.setText(shown);
+        } else {
+            markup = null;
+            shown = null;
+            page = null;
+            super.setText(t);
+        }
+        revalidate();
+        repaint();
+    }
+
+    /// The markup that was set, for as long as the text it was shown as
+    /// was not edited; otherwise the text.
+    @Override
+    public String getText() {
+        String now = super.getText();
+        if (markup != null && now != null && now.equals(shown)) {
+            return markup;
+        }
+        return now;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        return true;
+    }
+
+    private static boolean breaks(String tag) {
+        return "br".equals(tag) || "p".equals(tag) || "/p".equals(tag) || "div".equals(tag) || "/div".equals(tag)
+                || "li".equals(tag) || "tr".equals(tag) || "/tr".equals(tag) || (tag.length() == 3
+                && tag.charAt(0) == '/' && tag.charAt(1) == 'h' && tag.charAt(2) >= '1' && tag.charAt(2) <= '6')
+                || (tag.length() == 2 && tag.charAt(0) == 'h' && tag.charAt(1) >= '1' && tag.charAt(1) <= '6');
+    }
+
+    /// The text a page of simple markup reads as.
+    static String cn1PlainText(String html) {
+        StringBuilder out = new StringBuilder();
+        int n = html.length();
+        boolean space = false;
+        boolean skip = false;
+        for (int i = 0; i < n; i++) {
+            char c = html.charAt(i);
+            if (c == '<') {
+                int end = html.indexOf('>', i);
+                if (end < 0) {
+                    break;
+                }
+                StringBuilder name = new StringBuilder();
+                for (int j = i + 1; j < end; j++) {
+                    char t = html.charAt(j);
+                    if (t == ' ' || t == '\t' || t == '\n' || t == '\r' || (t == '/' && j > i + 1)) {
+                        break;
+                    }
+                    // Tag names are ASCII; folded by hand, not by locale.
+                    name.append(t >= 'A' && t <= 'Z' ? (char) (t + 32) : t);
+                }
+                String tag = name.toString();
+                if ("head".equals(tag) || "style".equals(tag) || "script".equals(tag)) {
+                    skip = true;
+                } else if ("/head".equals(tag) || "/style".equals(tag) || "/script".equals(tag)) {
+                    skip = false;
+                } else if (!skip && breaks(tag)) {
+                    // A break before any text, or right after another one
+                    // from a closing tag, adds nothing.
+                    int len = out.length();
+                    if (len > 0 && ("br".equals(tag) || out.charAt(len - 1) != '\n')) {
+                        out.append('\n');
+                    }
+                    space = false;
+                }
+                i = end;
+            } else if (skip) {
+                continue;
+            } else if (c == ' ' || c == '\n' || c == '\r' || c == '\t') {
+                space = out.length() > 0 && out.charAt(out.length() - 1) != '\n';
+            } else {
+                if (space) {
+                    out.append(' ');
+                    space = false;
+                }
+                if (c == '&') {
+                    int end = html.indexOf(';', i);
+                    String entity = end > i && end - i <= 8 ? html.substring(i + 1, end) : null;
+                    String decoded = entity == null ? null : decode(entity);
+                    if (decoded != null) {
+                        out.append(decoded);
+                        i = end;
+                        continue;
+                    }
+                }
+                out.append(c);
+            }
+        }
+        int len = out.length();
+        while (len > 0 && out.charAt(len - 1) == '\n') {
+            len--;
+        }
+        out.setLength(len);
+        return out.toString();
+    }
+
+    private static String decode(String entity) {
+        if ("amp".equals(entity)) {
+            return "&";
+        } else if ("lt".equals(entity)) {
+            return "<";
+        } else if ("gt".equals(entity)) {
+            return ">";
+        } else if ("quot".equals(entity)) {
+            return "\"";
+        } else if ("apos".equals(entity)) {
+            return "'";
+        } else if ("nbsp".equals(entity)) {
+            return " ";
+        } else if (entity.length() > 1 && entity.charAt(0) == '#') {
+            try {
+                boolean hex = entity.charAt(1) == 'x' || entity.charAt(1) == 'X';
+                int code = hex ? Integer.parseInt(entity.substring(2), 16) : Integer.parseInt(entity.substring(1));
+                if (code > 0 && code <= 0xffff) {
+                    return String.valueOf((char) code);
+                }
+            } catch (NumberFormatException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFileChooser.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFileChooser.java
new file mode 100644
index 00000000000..237ad7f20e8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFileChooser.java
@@ -0,0 +1,888 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.WindowAdapter;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import com.codename1.desktopcompat.javax.swing.filechooser.FileFilter;
+import com.codename1.desktopcompat.javax.swing.filechooser.FileNameExtensionFilter;
+import com.codename1.desktopcompat.javax.swing.filechooser.FileView;
+import com.codename1.desktopcompat.rt.FilePicker;
+import com.codename1.io.FileSystemStorage;
+import java.io.File;
+import java.util.ArrayList;
+
+/// `javax.swing.JFileChooser`: asks the user for a file. Each `show...`
+/// method blocks its caller until the user answered.
+///
+/// **Two ways of asking.**
+///
+/// - Opening a file goes to the platform's own picker
+///   (`Display.openFileChooser`): the document picker of a phone, the file
+///   dialog of a desktop. That is the only way to reach a file outside the
+///   application's own storage on a phone. It answers with one file, also
+///   when multiple selection is enabled, and it takes the extensions of a
+///   `FileNameExtensionFilter` only; any other filter is not applied to it.
+/// - Saving, and choosing a directory, show a dialog of this layer that
+///   lists the directories the file API can reach, starting at the current
+///   directory, which is the application's home directory unless one was
+///   set. On a phone that is the application's own storage.
+///
+/// The platform's picker has no place for an accessory and does not ask a
+/// file view, so a chooser that has either shows the dialog of this layer
+/// for opening too. That dialog names and draws each file as the file
+/// view says, puts the accessory to the right of the list, and makes the
+/// file selected in the list the selected file as it is selected.
+///
+/// A chooser can also be added to a container like any component: it then
+/// shows the same list and fields there, without the approve and cancel
+/// buttons when `setControlButtonsAreShown(false)` took them away.
+///
+/// The file system view is not provided.
+public class JFileChooser extends JComponent implements Accessible {
+
+    public static final int OPEN_DIALOG = 0;
+    public static final int SAVE_DIALOG = 1;
+    public static final int CUSTOM_DIALOG = 2;
+
+    public static final int CANCEL_OPTION = 1;
+    public static final int APPROVE_OPTION = 0;
+    public static final int ERROR_OPTION = -1;
+
+    public static final int FILES_ONLY = 0;
+    public static final int DIRECTORIES_ONLY = 1;
+    public static final int FILES_AND_DIRECTORIES = 2;
+
+    public static final String CANCEL_SELECTION = "CancelSelection";
+    public static final String APPROVE_SELECTION = "ApproveSelection";
+
+    public static final String APPROVE_BUTTON_TEXT_CHANGED_PROPERTY = "ApproveButtonTextChangedProperty";
+    public static final String DIRECTORY_CHANGED_PROPERTY = "directoryChanged";
+    public static final String SELECTED_FILE_CHANGED_PROPERTY = "SelectedFileChangedProperty";
+    public static final String SELECTED_FILES_CHANGED_PROPERTY = "SelectedFilesChangedProperty";
+    public static final String MULTI_SELECTION_ENABLED_CHANGED_PROPERTY = "MultiSelectionEnabledChangedProperty";
+    public static final String FILE_FILTER_CHANGED_PROPERTY = "fileFilterChanged";
+    public static final String FILE_SELECTION_MODE_CHANGED_PROPERTY = "fileSelectionChanged";
+    public static final String FILE_HIDING_CHANGED_PROPERTY = "FileHidingChanged";
+    public static final String DIALOG_TITLE_CHANGED_PROPERTY = "DialogTitleChangedProperty";
+    public static final String DIALOG_TYPE_CHANGED_PROPERTY = "DialogTypeChangedProperty";
+    public static final String CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY = "ChoosableFileFilterChangedProperty";
+    public static final String ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY = "acceptAllFileFilterUsedChanged";
+    public static final String ACCESSORY_CHANGED_PROPERTY = "AccessoryChangedProperty";
+    public static final String FILE_VIEW_CHANGED_PROPERTY = "fileViewChanged";
+    public static final String CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY = "ControlButtonsAreShownChangedProperty";
+
+    private final FileFilter acceptAll = new AcceptAll();
+    private final ArrayList<FileFilter> filters = new ArrayList<FileFilter>();
+    private final ArrayList<ActionListener> listeners = new ArrayList<ActionListener>();
+
+    private File currentDirectory;
+    private File selectedFile;
+    private File[] selectedFiles;
+    private int dialogType = OPEN_DIALOG;
+    private String dialogTitle;
+    private String approveButtonText;
+    private int mode = FILES_ONLY;
+    private boolean multi;
+    private boolean hiding = true;
+    private boolean useAcceptAll = true;
+    private FileFilter fileFilter;
+    private int returnValue = ERROR_OPTION;
+    private FileView fileView;
+    private JComponent accessory;
+    private boolean controlButtonsShown = true;
+
+    private JDialog dialog;
+    private JList<String> listing;
+    private JLabel where;
+    private JTextField nameField;
+    private File[] entries = new File[0];
+
+    public JFileChooser() {
+        this((File) null);
+    }
+
+    public JFileChooser(String currentDirectoryPath) {
+        this(currentDirectoryPath == null ? null : new File(currentDirectoryPath));
+    }
+
+    public JFileChooser(File currentDirectory) {
+        filters.add(acceptAll);
+        fileFilter = acceptAll;
+        if (currentDirectory != null) {
+            setCurrentDirectory(currentDirectory);
+        }
+    }
+
+    private static final class AcceptAll extends FileFilter {
+        AcceptAll() {
+        }
+
+        @Override
+        public boolean accept(File f) {
+            return true;
+        }
+
+        @Override
+        public String getDescription() {
+            String s = UIManager.getString("FileChooser.acceptAllFileFilterText");
+            return s == null ? "All Files" : s;
+        }
+    }
+
+    // ---- the selection ----
+
+    public File getSelectedFile() {
+        return selectedFile;
+    }
+
+    public void setSelectedFile(File file) {
+        File old = selectedFile;
+        selectedFile = file;
+        if (file != null) {
+            File parent = file.getParentFile();
+            if (parent != null && file.isAbsolute()) {
+                currentDirectory = parent;
+            }
+            if (nameField != null) {
+                nameField.setText(file.getName());
+            }
+        }
+        firePropertyChange(SELECTED_FILE_CHANGED_PROPERTY, old, selectedFile);
+    }
+
+    public File[] getSelectedFiles() {
+        if (selectedFiles == null) {
+            return new File[0];
+        }
+        File[] r = new File[selectedFiles.length];
+        System.arraycopy(selectedFiles, 0, r, 0, r.length);
+        return r;
+    }
+
+    public void setSelectedFiles(File[] files) {
+        File[] old = selectedFiles;
+        if (files == null || files.length == 0) {
+            selectedFiles = null;
+            setSelectedFile(null);
+        } else {
+            selectedFiles = new File[files.length];
+            System.arraycopy(files, 0, selectedFiles, 0, files.length);
+            setSelectedFile(selectedFiles[0]);
+        }
+        firePropertyChange(SELECTED_FILES_CHANGED_PROPERTY, old, selectedFiles);
+    }
+
+    public File getCurrentDirectory() {
+        if (currentDirectory == null) {
+            currentDirectory = home();
+        }
+        return currentDirectory;
+    }
+
+    private static File home() {
+        String home = null;
+        if (com.codename1.ui.Display.isInitialized()) {
+            home = FileSystemStorage.getInstance().getAppHomePath();
+        }
+        return new File(home == null || home.length() == 0 ? "/" : home);
+    }
+
+    public void setCurrentDirectory(File dir) {
+        File old = currentDirectory;
+        File d = dir;
+        // As on the desktop, a file that is not a directory stands for the
+        // closest directory above it.
+        while (d != null && !d.isDirectory()) {
+            d = d.getParentFile();
+        }
+        currentDirectory = d == null ? home() : d;
+        firePropertyChange(DIRECTORY_CHANGED_PROPERTY, old, currentDirectory);
+        rescanCurrentDirectory();
+    }
+
+    public void changeToParentDirectory() {
+        File parent = getCurrentDirectory().getParentFile();
+        if (parent != null) {
+            setCurrentDirectory(parent);
+        }
+    }
+
+    /// Lists the current directory again: the directories first, then the
+    /// files the filter accepts, each group by name.
+    public void rescanCurrentDirectory() {
+        if (listing == null) {
+            return;
+        }
+        File dir = getCurrentDirectory();
+        File[] all = dir.listFiles();
+        ArrayList<File> shown = new ArrayList<File>();
+        if (all != null) {
+            for (int pass = 0; pass < 2; pass++) {
+                int first = shown.size();
+                for (int i = 0; i < all.length; i++) {
+                    File f = all[i];
+                    if (f == null || hiding && f.isHidden()) {
+                        continue;
+                    }
+                    boolean isDir = f.isDirectory();
+                    if (isDir != (pass == 0) || !isDir && (mode == DIRECTORIES_ONLY || !accept(f))) {
+                        continue;
+                    }
+                    int at = shown.size();
+                    while (at > first && shown.get(at - 1).getName().compareTo(f.getName()) > 0) {
+                        at--;
+                    }
+                    shown.add(at, f);
+                }
+            }
+        }
+        entries = shown.toArray(new File[shown.size()]);
+        String[] names = new String[entries.length];
+        for (int i = 0; i < names.length; i++) {
+            names[i] = entries[i].isDirectory() ? getName(entries[i]) + "/" : getName(entries[i]);
+        }
+        listing.setListData(names);
+        where.setText(dir.getPath());
+    }
+
+    public void ensureFileIsVisible(File f) {
+        if (listing == null || f == null) {
+            return;
+        }
+        for (int i = 0; i < entries.length; i++) {
+            if (entries[i].equals(f)) {
+                listing.ensureIndexIsVisible(i);
+                return;
+            }
+        }
+    }
+
+    // ---- showing ----
+
+    public int showOpenDialog(Component parent) {
+        setDialogType(OPEN_DIALOG);
+        return showDialog(parent, null);
+    }
+
+    public int showSaveDialog(Component parent) {
+        setDialogType(SAVE_DIALOG);
+        return showDialog(parent, null);
+    }
+
+    public int showDialog(Component parent, String approveButtonText) {
+        if (approveButtonText != null) {
+            setApproveButtonText(approveButtonText);
+            setDialogType(CUSTOM_DIALOG);
+        }
+        returnValue = CANCEL_OPTION;
+        if (dialogType == OPEN_DIALOG && mode != DIRECTORIES_ONLY && accessory == null && fileView == null
+                && FilePicker.available()) {
+            String path = FilePicker.pick(pickerAccept());
+            if (path == null) {
+                cancelSelection();
+            } else {
+                File f = new File(path);
+                setSelectedFiles(new File[] {f});
+                File parentDir = f.getParentFile();
+                if (parentDir != null) {
+                    currentDirectory = parentDir;
+                }
+                approveSelection();
+            }
+            return returnValue;
+        }
+        JDialog d = createDialog(parent);
+        dialog = d;
+        rescanCurrentDirectory();
+        d.setVisible(true);
+        d.dispose();
+        dialog = null;
+        listing = null;
+        where = null;
+        nameField = null;
+        return returnValue;
+    }
+
+    /// What the platform's picker is asked to offer: the extensions of an
+    /// extension filter, or every file.
+    private String pickerAccept() {
+        if (!(fileFilter instanceof FileNameExtensionFilter)) {
+            return null;
+        }
+        String[] ext = ((FileNameExtensionFilter) fileFilter).getExtensions();
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < ext.length; i++) {
+            if (i > 0) {
+                sb.append(',');
+            }
+            sb.append(ext[i]);
+        }
+        return sb.toString();
+    }
+
+    private String approveText() {
+        if (approveButtonText != null) {
+            return approveButtonText;
+        }
+        String key = dialogType == SAVE_DIALOG ? "FileChooser.saveButtonText" : "FileChooser.openButtonText";
+        String s = UIManager.getString(key);
+        if (s != null) {
+            return s;
+        }
+        return dialogType == SAVE_DIALOG ? "Save" : "Open";
+    }
+
+    protected JDialog createDialog(Component parent) {
+        Window owner = null;
+        if (parent instanceof Window) {
+            owner = (Window) parent;
+        } else if (parent != null) {
+            owner = SwingUtilities.getWindowAncestor(parent);
+        }
+        String title = dialogTitle != null ? dialogTitle : approveText();
+        JDialog d = new JDialog(owner, title, Dialog.ModalityType.APPLICATION_MODAL);
+        JButton approve = cn1BuildUi();
+
+        Container content = d.getContentPane();
+        content.setLayout(new BorderLayout());
+        content.add(this, BorderLayout.CENTER);
+        if (approve != null) {
+            d.getRootPane().setDefaultButton(approve);
+        }
+        d.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                returnValue = CANCEL_OPTION;
+            }
+        });
+        d.setSize(accessory == null ? 380 : 520, 420);
+        d.setLocationRelativeTo(parent);
+        return d;
+    }
+
+    /// A chooser that was added to a container shows its list there.
+    @Override
+    public void addNotify() {
+        if (listing == null) {
+            cn1BuildUi();
+            super.addNotify();
+            rescanCurrentDirectory();
+        } else {
+            super.addNotify();
+        }
+    }
+
+    /// Draws each entry with the icon the file view has for it.
+    private final class EntryRenderer extends DefaultListCellRenderer {
+
+        EntryRenderer() {
+        }
+
+        @Override
+        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected,
+                boolean cellHasFocus) {
+            Component c = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if (c instanceof JLabel) {
+                ((JLabel) c).setIcon(JFileChooser.this.getIcon(entryAt(index)));
+            }
+            return c;
+        }
+    }
+
+    /// Builds the list, the fields and the buttons inside this component
+    /// and answers the approve button, or `null` when the buttons are not
+    /// shown.
+    private JButton cn1BuildUi() {
+        removeAll();
+        setLayout(new BorderLayout(6, 6));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+
+        JPanel top = new JPanel(new BorderLayout(6, 0));
+        JButton up = new JButton("..");
+        up.setToolTipText("Up one level");
+        up.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                changeToParentDirectory();
+            }
+        });
+        where = new JLabel(" ");
+        top.add(up, BorderLayout.WEST);
+        top.add(where, BorderLayout.CENTER);
+        add(top, BorderLayout.NORTH);
+
+        listing = new JList<String>();
+        if (fileView != null) {
+            listing.setCellRenderer(new EntryRenderer());
+        }
+        listing.addListSelectionListener(new ListSelectionListener() {
+            @Override
+            public void valueChanged(ListSelectionEvent e) {
+                File f = entryAt(listing == null ? -1 : listing.getSelectedIndex());
+                if (f != null && nameField != null && (mode != FILES_ONLY || !f.isDirectory())) {
+                    if (!f.equals(selectedFile)) {
+                        setSelectedFile(f);
+                    }
+                    nameField.setText(f.getName());
+                }
+            }
+        });
+        listing.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                if (e.getClickCount() >= 2 && listing != null) {
+                    open(entryAt(listing.getSelectedIndex()));
+                }
+            }
+        });
+        add(new JScrollPane(listing), BorderLayout.CENTER);
+        if (accessory != null) {
+            add(accessory, BorderLayout.EAST);
+        }
+
+        JPanel bottom = new JPanel();
+        bottom.setLayout(new BoxLayout(bottom, BoxLayout.Y_AXIS));
+        nameField = new JTextField(20);
+        if (selectedFile != null) {
+            nameField.setText(selectedFile.getName());
+        }
+        nameField.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                approvePressed();
+            }
+        });
+        bottom.add(nameField);
+        if (filters.size() > 1) {
+            String[] names = new String[filters.size()];
+            for (int i = 0; i < names.length; i++) {
+                names[i] = filters.get(i).getDescription();
+            }
+            final JComboBox<String> choice = new JComboBox<String>(names);
+            int current = filters.indexOf(fileFilter);
+            if (current >= 0) {
+                choice.setSelectedItem(names[current]);
+            }
+            choice.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    int i = choice.getSelectedIndex();
+                    if (i >= 0 && i < filters.size() && filters.get(i) != fileFilter) {
+                        setFileFilter(filters.get(i));
+                    }
+                }
+            });
+            bottom.add(choice);
+        }
+        if (!controlButtonsShown) {
+            add(bottom, BorderLayout.SOUTH);
+            return null;
+        }
+        JPanel buttons = new JPanel();
+        JButton approve = new JButton(approveText());
+        approve.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                approvePressed();
+            }
+        });
+        JButton cancel = new JButton(cancelText());
+        cancel.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                cancelSelection();
+            }
+        });
+        buttons.add(approve);
+        buttons.add(cancel);
+        bottom.add(buttons);
+        add(bottom, BorderLayout.SOUTH);
+        return approve;
+    }
+
+    private static String cancelText() {
+        String s = UIManager.getString("FileChooser.cancelButtonText");
+        return s == null ? "Cancel" : s;
+    }
+
+    private File entryAt(int i) {
+        return i >= 0 && i < entries.length ? entries[i] : null;
+    }
+
+    /// A double click on an entry: into a directory, or approve a file.
+    private void open(File f) {
+        if (f == null) {
+            return;
+        }
+        if (f.isDirectory()) {
+            if (nameField != null) {
+                nameField.setText("");
+            }
+            setCurrentDirectory(f);
+        } else {
+            setSelectedFiles(new File[] {f});
+            approveSelection();
+        }
+    }
+
+    /// The approve button: the name typed, taken against the current
+    /// directory. A directory named where only files can be chosen is
+    /// entered instead of chosen.
+    private void approvePressed() {
+        String name = nameField == null ? "" : nameField.getText().trim();
+        File chosen = null;
+        if (name.length() > 0) {
+            chosen = name.startsWith("/") || name.startsWith("file:") ? new File(name)
+                    : new File(getCurrentDirectory(), name);
+        } else if (mode != FILES_ONLY) {
+            chosen = getCurrentDirectory();
+        }
+        if (chosen == null) {
+            return;
+        }
+        if (mode == FILES_ONLY && chosen.isDirectory()) {
+            nameField.setText("");
+            setCurrentDirectory(chosen);
+            return;
+        }
+        File[] many = null;
+        if (multi && listing != null) {
+            int[] picked = listing.getSelectedIndices();
+            if (picked.length > 1) {
+                many = new File[picked.length];
+                for (int i = 0; i < picked.length; i++) {
+                    File f = entryAt(picked[i]);
+                    many[i] = f == null ? chosen : f;
+                }
+            }
+        }
+        selectedFile = chosen;
+        selectedFiles = many != null ? many : new File[] {chosen};
+        approveSelection();
+    }
+
+    public void approveSelection() {
+        returnValue = APPROVE_OPTION;
+        if (dialog != null) {
+            dialog.setVisible(false);
+        }
+        fireActionPerformed(APPROVE_SELECTION);
+    }
+
+    public void cancelSelection() {
+        returnValue = CANCEL_OPTION;
+        if (dialog != null) {
+            dialog.setVisible(false);
+        }
+        fireActionPerformed(CANCEL_SELECTION);
+    }
+
+    public void addActionListener(ActionListener l) {
+        if (l != null) {
+            listeners.add(l);
+        }
+    }
+
+    public void removeActionListener(ActionListener l) {
+        listeners.remove(l);
+    }
+
+    public ActionListener[] getActionListeners() {
+        return listeners.toArray(new ActionListener[listeners.size()]);
+    }
+
+    protected void fireActionPerformed(String command) {
+        ActionListener[] ls = getActionListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        ActionEvent e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, command);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].actionPerformed(e);
+        }
+    }
+
+    // ---- properties ----
+
+    public int getDialogType() {
+        return dialogType;
+    }
+
+    public void setDialogType(int dialogType) {
+        if (dialogType != OPEN_DIALOG && dialogType != SAVE_DIALOG && dialogType != CUSTOM_DIALOG) {
+            throw new IllegalArgumentException("Incorrect Dialog Type: " + dialogType);
+        }
+        int old = this.dialogType;
+        this.dialogType = dialogType;
+        if (dialogType != CUSTOM_DIALOG && old != dialogType) {
+            approveButtonText = null;
+        }
+        firePropertyChange(DIALOG_TYPE_CHANGED_PROPERTY, old, dialogType);
+    }
+
+    public void setDialogTitle(String dialogTitle) {
+        String old = this.dialogTitle;
+        this.dialogTitle = dialogTitle;
+        if (dialog != null) {
+            dialog.setTitle(dialogTitle);
+        }
+        firePropertyChange(DIALOG_TITLE_CHANGED_PROPERTY, old, dialogTitle);
+    }
+
+    public String getDialogTitle() {
+        return dialogTitle;
+    }
+
+    public void setApproveButtonText(String approveButtonText) {
+        String old = this.approveButtonText;
+        this.approveButtonText = approveButtonText;
+        firePropertyChange(APPROVE_BUTTON_TEXT_CHANGED_PROPERTY, old, approveButtonText);
+    }
+
+    public String getApproveButtonText() {
+        return approveButtonText;
+    }
+
+    public void setFileSelectionMode(int mode) {
+        if (mode != FILES_ONLY && mode != DIRECTORIES_ONLY && mode != FILES_AND_DIRECTORIES) {
+            throw new IllegalArgumentException("Incorrect Mode for file selection: " + mode);
+        }
+        int old = this.mode;
+        this.mode = mode;
+        firePropertyChange(FILE_SELECTION_MODE_CHANGED_PROPERTY, old, mode);
+        rescanCurrentDirectory();
+    }
+
+    public int getFileSelectionMode() {
+        return mode;
+    }
+
+    public boolean isFileSelectionEnabled() {
+        return mode == FILES_ONLY || mode == FILES_AND_DIRECTORIES;
+    }
+
+    public boolean isDirectorySelectionEnabled() {
+        return mode == DIRECTORIES_ONLY || mode == FILES_AND_DIRECTORIES;
+    }
+
+    public void setMultiSelectionEnabled(boolean b) {
+        boolean old = multi;
+        multi = b;
+        firePropertyChange(MULTI_SELECTION_ENABLED_CHANGED_PROPERTY, old, b);
+    }
+
+    public boolean isMultiSelectionEnabled() {
+        return multi;
+    }
+
+    public boolean isFileHidingEnabled() {
+        return hiding;
+    }
+
+    public void setFileHidingEnabled(boolean b) {
+        boolean old = hiding;
+        hiding = b;
+        firePropertyChange(FILE_HIDING_CHANGED_PROPERTY, old, b);
+        rescanCurrentDirectory();
+    }
+
+    // ---- filters ----
+
+    public void setFileFilter(FileFilter filter) {
+        FileFilter old = fileFilter;
+        fileFilter = filter;
+        if (filter != null && !filters.contains(filter)) {
+            filters.add(filter);
+        }
+        firePropertyChange(FILE_FILTER_CHANGED_PROPERTY, old, fileFilter);
+        rescanCurrentDirectory();
+    }
+
+    public FileFilter getFileFilter() {
+        return fileFilter;
+    }
+
+    public FileFilter[] getChoosableFileFilters() {
+        return filters.toArray(new FileFilter[filters.size()]);
+    }
+
+    public void addChoosableFileFilter(FileFilter filter) {
+        if (filter != null && !filters.contains(filter)) {
+            filters.add(filter);
+            firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, null, filter);
+            if (fileFilter == null && filters.size() == 1) {
+                setFileFilter(filter);
+            }
+        }
+    }
+
+    public boolean removeChoosableFileFilter(FileFilter f) {
+        if (!filters.remove(f)) {
+            return false;
+        }
+        if (fileFilter == f) {
+            setFileFilter(useAcceptAll ? acceptAll : filters.isEmpty() ? null : filters.get(0));
+        }
+        firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, f, null);
+        return true;
+    }
+
+    public void resetChoosableFileFilters() {
+        filters.clear();
+        fileFilter = null;
+        if (useAcceptAll) {
+            filters.add(acceptAll);
+            fileFilter = acceptAll;
+        }
+        firePropertyChange(CHOOSABLE_FILE_FILTER_CHANGED_PROPERTY, null, null);
+        rescanCurrentDirectory();
+    }
+
+    public FileFilter getAcceptAllFileFilter() {
+        return acceptAll;
+    }
+
+    public boolean isAcceptAllFileFilterUsed() {
+        return useAcceptAll;
+    }
+
+    public void setAcceptAllFileFilterUsed(boolean b) {
+        boolean old = useAcceptAll;
+        useAcceptAll = b;
+        if (!b) {
+            removeChoosableFileFilter(acceptAll);
+        } else if (!filters.contains(acceptAll)) {
+            filters.add(0, acceptAll);
+        }
+        firePropertyChange(ACCEPT_ALL_FILE_FILTER_USED_CHANGED_PROPERTY, old, b);
+    }
+
+    public boolean accept(File f) {
+        return fileFilter == null || fileFilter.accept(f);
+    }
+
+    /// The name a file is listed under: the file view's, or the file's
+    /// own.
+    public String getName(File f) {
+        if (f == null) {
+            return null;
+        }
+        String name = fileView == null ? null : fileView.getName(f);
+        return name != null ? name : f.getName();
+    }
+
+    /// What the file view says about the file, or `null`.
+    public String getDescription(File f) {
+        return f == null || fileView == null ? null : fileView.getDescription(f);
+    }
+
+    public String getTypeDescription(File f) {
+        return f == null || fileView == null ? null : fileView.getTypeDescription(f);
+    }
+
+    /// The icon the file view has for the file, or `null`: this layer has
+    /// no icons of its own for files.
+    public Icon getIcon(File f) {
+        return f == null || fileView == null ? null : fileView.getIcon(f);
+    }
+
+    public boolean isTraversable(File f) {
+        if (f == null) {
+            return false;
+        }
+        Boolean says = fileView == null ? null : fileView.isTraversable(f);
+        return says != null ? says.booleanValue() : f.isDirectory();
+    }
+
+    // ---- file view, accessory, control buttons ----
+
+    public void setFileView(FileView fileView) {
+        FileView old = this.fileView;
+        this.fileView = fileView;
+        firePropertyChange(FILE_VIEW_CHANGED_PROPERTY, old, fileView);
+        if (listing != null) {
+            listing.setCellRenderer(fileView == null ? new DefaultListCellRenderer() : new EntryRenderer());
+            rescanCurrentDirectory();
+        }
+    }
+
+    public FileView getFileView() {
+        return fileView;
+    }
+
+    /// Sets the component shown beside the list of files, usually a
+    /// preview of the selected file. It is placed when the chooser is
+    /// next shown.
+    public void setAccessory(JComponent newAccessory) {
+        JComponent old = accessory;
+        accessory = newAccessory;
+        firePropertyChange(ACCESSORY_CHANGED_PROPERTY, old, accessory);
+    }
+
+    public JComponent getAccessory() {
+        return accessory;
+    }
+
+    /// Whether the chooser has its own approve and cancel buttons; a
+    /// chooser placed in a dialog that has buttons of its own does
+    /// without. It applies when the chooser is next shown.
+    public void setControlButtonsAreShown(boolean b) {
+        if (controlButtonsShown == b) {
+            return;
+        }
+        boolean old = controlButtonsShown;
+        controlButtonsShown = b;
+        firePropertyChange(CONTROL_BUTTONS_ARE_SHOWN_CHANGED_PROPERTY, old, b);
+    }
+
+    public boolean getControlButtonsAreShown() {
+        return controlButtonsShown;
+    }
+
+    // ------------------------------------------------------------ drag
+
+    /// Records whether dragging out of the component is wanted. The layer
+    /// starts no drag of its own, so this is a property and nothing more.
+    public void setDragEnabled(boolean b) {
+        cn1DragEnabled = b;
+    }
+
+    public boolean getDragEnabled() {
+        return cn1DragEnabled;
+    }
+
+    private boolean cn1DragEnabled;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFormattedTextField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFormattedTextField.java
new file mode 100644
index 00000000000..911faf6d4a4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFormattedTextField.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.javax.swing.text.AbstractDocument;
+import com.codename1.desktopcompat.javax.swing.text.DefaultFormatter;
+import com.codename1.desktopcompat.javax.swing.text.DefaultFormatterFactory;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.DocumentFilter;
+import com.codename1.desktopcompat.javax.swing.text.NumberFormatter;
+import java.text.ParseException;
+
+/// A text field that holds a value and shows it through a formatter.
+///
+/// The text is turned back into the value when the edit is committed: by
+/// [#commitEdit()], by finishing the edit, or when the field loses the
+/// focus, according to [#setFocusLostBehavior(int)].
+///
+/// ## What differs from the desktop
+///
+/// A formatter is built from the value's type: a number gets a
+/// [NumberFormatter], anything else a [DefaultFormatter]. There is no
+/// constructor taking a `java.text.Format`, which the devices do not have
+/// in a usable form; wrap a number format in a [NumberFormatter] instead.
+public class JFormattedTextField extends JTextField {
+
+    public static final int COMMIT = 0;
+
+    public static final int COMMIT_OR_REVERT = 1;
+
+    public static final int REVERT = 2;
+
+    public static final int PERSIST = 3;
+
+    private AbstractFormatterFactory factory;
+    private AbstractFormatter format;
+    private Object value;
+    private boolean editValid = true;
+    private int focusLostBehavior = COMMIT_OR_REVERT;
+
+    public JFormattedTextField() {
+    }
+
+    public JFormattedTextField(Object value) {
+        setValue(value);
+    }
+
+    public JFormattedTextField(AbstractFormatter formatter) {
+        this(new DefaultFormatterFactory(formatter));
+    }
+
+    public JFormattedTextField(AbstractFormatterFactory factory) {
+        setFormatterFactory(factory);
+    }
+
+    public JFormattedTextField(AbstractFormatterFactory factory, Object currentValue) {
+        this(currentValue);
+        setFormatterFactory(factory);
+    }
+
+    public void setFocusLostBehavior(int behavior) {
+        if (behavior != COMMIT && behavior != COMMIT_OR_REVERT && behavior != PERSIST && behavior != REVERT) {
+            throw new IllegalArgumentException("setFocusLostBehavior must be one of: "
+                    + "JFormattedTextField.COMMIT, JFormattedTextField.COMMIT_OR_REVERT, "
+                    + "JFormattedTextField.PERSIST or JFormattedTextField.REVERT");
+        }
+        focusLostBehavior = behavior;
+    }
+
+    public int getFocusLostBehavior() {
+        return focusLostBehavior;
+    }
+
+    public void setFormatterFactory(AbstractFormatterFactory tf) {
+        AbstractFormatterFactory old = factory;
+        factory = tf;
+        firePropertyChange("formatterFactory", old, tf);
+        setValue(getValue(), true, false);
+    }
+
+    public AbstractFormatterFactory getFormatterFactory() {
+        return factory;
+    }
+
+    /// Installs a formatter, which writes the current value into the
+    /// field. Usually the factory decides; this is for a subclass.
+    protected void setFormatter(AbstractFormatter format) {
+        AbstractFormatter old = this.format;
+        if (old != null) {
+            old.uninstall();
+        }
+        editValid = true;
+        this.format = format;
+        if (format != null) {
+            format.install(this);
+        }
+        firePropertyChange("textFormatter", old, format);
+    }
+
+    public AbstractFormatter getFormatter() {
+        return format;
+    }
+
+    public void setValue(Object value) {
+        if (value != null && getFormatterFactory() == null) {
+            setFormatterFactory(cn1DefaultFactory(value));
+        }
+        setValue(value, true, true);
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    /// Turns the text into the value. The text itself is left as typed.
+    public void commitEdit() throws ParseException {
+        AbstractFormatter f = getFormatter();
+        if (f != null) {
+            setValue(f.stringToValue(getText()), false, true);
+        }
+    }
+
+    /// Whether the text, as it stands, is something the formatter accepts.
+    public boolean isEditValid() {
+        AbstractFormatter f = getFormatter();
+        if (f == null || !editValid) {
+            return editValid;
+        }
+        try {
+            f.stringToValue(getText());
+            return true;
+        } catch (ParseException e) {
+            return false;
+        }
+    }
+
+    /// Called when the text could not be turned into a value. The desktop
+    /// beeps; a device says nothing.
+    protected void invalidEdit() {
+    }
+
+    @Override
+    public void setDocument(Document doc) {
+        super.setDocument(doc);
+        AbstractFormatter f = format;
+        if (f != null && doc instanceof AbstractDocument) {
+            DocumentFilter filter = f.getDocumentFilter();
+            if (filter != null) {
+                ((AbstractDocument) doc).setDocumentFilter(filter);
+            }
+        }
+    }
+
+    /// Finishing the edit commits it first; text that is no value keeps
+    /// the action listeners from hearing about it.
+    @Override
+    public void postActionEvent() {
+        if (getFormatter() != null) {
+            try {
+                commitEdit();
+            } catch (ParseException e) {
+                invalidEdit();
+                return;
+            }
+        }
+        super.postActionEvent();
+    }
+
+    @Override
+    protected void processFocusEvent(FocusEvent e) {
+        super.processFocusEvent(e);
+        if (e.isTemporary()) {
+            return;
+        }
+        if (e.getID() == FocusEvent.FOCUS_LOST && isEditable()) {
+            if (focusLostBehavior == COMMIT || focusLostBehavior == COMMIT_OR_REVERT) {
+                try {
+                    commitEdit();
+                    // Shows the value the way the formatter writes it.
+                    setValue(getValue(), true, true);
+                } catch (ParseException pe) {
+                    if (focusLostBehavior == COMMIT_OR_REVERT) {
+                        setValue(getValue(), true, true);
+                    }
+                }
+            } else if (focusLostBehavior == REVERT) {
+                setValue(getValue(), true, true);
+            }
+        } else if (e.getID() == FocusEvent.FOCUS_GAINED || e.getID() == FocusEvent.FOCUS_LOST) {
+            // The factory may have one formatter for editing and another
+            // for display.
+            setValue(getValue(), true, false);
+        }
+    }
+
+    private void setValue(Object value, boolean createFormat, boolean firePC) {
+        Object oldValue = this.value;
+        this.value = value;
+        if (createFormat) {
+            AbstractFormatterFactory f = getFormatterFactory();
+            setFormatter(f != null ? f.getFormatter(this) : null);
+        } else {
+            editValid = true;
+        }
+        if (firePC) {
+            firePropertyChange("value", oldValue, value);
+        }
+    }
+
+    private static AbstractFormatterFactory cn1DefaultFactory(Object type) {
+        if (type instanceof Number) {
+            NumberFormatter display = new NumberFormatter();
+            display.setValueClass(type.getClass());
+            NumberFormatter edit = new NumberFormatter();
+            edit.setValueClass(type.getClass());
+            return new DefaultFormatterFactory(display, display, edit);
+        }
+        return new DefaultFormatterFactory(new DefaultFormatter());
+    }
+
+    /// Makes the formatter a field uses at the moment it asks.
+    public abstract static class AbstractFormatterFactory {
+
+        public AbstractFormatterFactory() {
+        }
+
+        public abstract AbstractFormatter getFormatter(JFormattedTextField tf);
+    }
+
+    /// Turns a value into the text a field shows, and the text back.
+    public abstract static class AbstractFormatter {
+
+        private JFormattedTextField ftf;
+
+        public AbstractFormatter() {
+        }
+
+        /// Attaches this formatter to a field: writes the field's value
+        /// into it as text and installs the document filter, if there is
+        /// one. A value that cannot be written leaves the field empty and
+        /// its edit invalid.
+        public void install(JFormattedTextField ftf) {
+            if (this.ftf != null) {
+                uninstall();
+            }
+            this.ftf = ftf;
+            if (ftf != null) {
+                try {
+                    ftf.setText(valueToString(ftf.getValue()));
+                } catch (ParseException pe) {
+                    ftf.setText("");
+                    setEditValid(false);
+                }
+                Document doc = ftf.getDocument();
+                DocumentFilter filter = getDocumentFilter();
+                if (filter != null && doc instanceof AbstractDocument) {
+                    ((AbstractDocument) doc).setDocumentFilter(filter);
+                }
+            }
+        }
+
+        public void uninstall() {
+            if (ftf != null) {
+                Document doc = ftf.getDocument();
+                if (doc instanceof AbstractDocument && getDocumentFilter() != null) {
+                    ((AbstractDocument) doc).setDocumentFilter(null);
+                }
+            }
+        }
+
+        public abstract Object stringToValue(String text) throws ParseException;
+
+        public abstract String valueToString(Object value) throws ParseException;
+
+        protected JFormattedTextField getFormattedTextField() {
+            return ftf;
+        }
+
+        protected void invalidEdit() {
+            if (ftf != null) {
+                ftf.invalidEdit();
+            }
+        }
+
+        protected void setEditValid(boolean valid) {
+            if (ftf != null) {
+                ftf.editValid = valid;
+            }
+        }
+
+        /// A filter to restrict what can be typed; none by default.
+        protected DocumentFilter getDocumentFilter() {
+            return null;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFrame.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFrame.java
new file mode 100644
index 00000000000..4d03b3698ff
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JFrame.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.GraphicsConfiguration;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import com.codename1.desktopcompat.rt.WindowHosts;
+
+/// The Swing frame: a frame whose single child is a root pane, so that
+/// adding to the frame adds to its content pane.
+///
+/// A request to close the frame -- the back command of its form, the
+/// close box of its window, the platform ending the application -- runs
+/// the default close operation after the window listeners:
+/// `HIDE_ON_CLOSE` (the default) hides it, `DISPOSE_ON_CLOSE` disposes of
+/// it, `DO_NOTHING_ON_CLOSE` leaves it to the listeners and
+/// `EXIT_ON_CLOSE` exits the application.
+public class JFrame extends Frame implements WindowConstants, RootPaneContainer {
+
+    public static final int EXIT_ON_CLOSE = 3;
+
+    protected JRootPane rootPane;
+    protected boolean rootPaneCheckingEnabled;
+
+    private int defaultCloseOperation = HIDE_ON_CLOSE;
+
+    public JFrame() {
+        this("");
+    }
+
+    public JFrame(String title) {
+        super(title);
+        frameInit();
+    }
+
+    /// A frame on the screen of `gc`. There is one screen, so this is a
+    /// frame like any other.
+    public JFrame(GraphicsConfiguration gc) {
+        this("");
+    }
+
+    public JFrame(String title, GraphicsConfiguration gc) {
+        this(title);
+    }
+
+    protected void frameInit() {
+        setRootPane(createRootPane());
+        setRootPaneCheckingEnabled(true);
+    }
+
+    protected JRootPane createRootPane() {
+        return new JRootPane();
+    }
+
+    @Override
+    public JRootPane getRootPane() {
+        return rootPane;
+    }
+
+    protected void setRootPane(JRootPane root) {
+        boolean checking = rootPaneCheckingEnabled;
+        rootPaneCheckingEnabled = false;
+        try {
+            if (rootPane != null) {
+                remove(rootPane);
+            }
+            rootPane = root;
+            if (root != null) {
+                add(root, BorderLayout.CENTER);
+            }
+        } finally {
+            rootPaneCheckingEnabled = checking;
+        }
+    }
+
+    @Override
+    public Container getContentPane() {
+        return rootPane.getContentPane();
+    }
+
+    @Override
+    public void setContentPane(Container contentPane) {
+        rootPane.setContentPane(contentPane);
+    }
+
+    @Override
+    public JLayeredPane getLayeredPane() {
+        return rootPane.getLayeredPane();
+    }
+
+    @Override
+    public void setLayeredPane(JLayeredPane layeredPane) {
+        rootPane.setLayeredPane(layeredPane);
+    }
+
+    @Override
+    public Component getGlassPane() {
+        return rootPane.getGlassPane();
+    }
+
+    @Override
+    public void setGlassPane(Component glassPane) {
+        rootPane.setGlassPane(glassPane);
+    }
+
+    public JMenuBar getJMenuBar() {
+        return rootPane.getJMenuBar();
+    }
+
+    /// Sets the menu bar; see `JRootPane.setJMenuBar` for how it shows.
+    public void setJMenuBar(JMenuBar menubar) {
+        rootPane.setJMenuBar(menubar);
+    }
+
+    protected boolean isRootPaneCheckingEnabled() {
+        return rootPaneCheckingEnabled;
+    }
+
+    protected void setRootPaneCheckingEnabled(boolean enabled) {
+        rootPaneCheckingEnabled = enabled;
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().add(comp, constraints, index);
+        } else {
+            super.addImpl(comp, constraints, index);
+        }
+    }
+
+    @Override
+    public void remove(Component comp) {
+        if (comp == rootPane || !rootPaneCheckingEnabled) {
+            super.remove(comp);
+        } else {
+            getContentPane().remove(comp);
+        }
+    }
+
+    @Override
+    public void setLayout(LayoutManager manager) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().setLayout(manager);
+        } else {
+            super.setLayout(manager);
+        }
+    }
+
+    @Override
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public int getDefaultCloseOperation() {
+        return defaultCloseOperation;
+    }
+
+    public void setDefaultCloseOperation(int operation) {
+        if (operation != DO_NOTHING_ON_CLOSE && operation != HIDE_ON_CLOSE && operation != DISPOSE_ON_CLOSE
+                && operation != EXIT_ON_CLOSE) {
+            throw new IllegalArgumentException("defaultCloseOperation must be one of: DO_NOTHING_ON_CLOSE, "
+                    + "HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, or EXIT_ON_CLOSE");
+        }
+        int old = defaultCloseOperation;
+        defaultCloseOperation = operation;
+        firePropertyChange("defaultCloseOperation", old, operation);
+    }
+
+    @Override
+    protected void processWindowEvent(WindowEvent e) {
+        super.processWindowEvent(e);
+        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
+            switch (defaultCloseOperation) {
+                case HIDE_ON_CLOSE:
+                    setVisible(false);
+                    break;
+                case DISPOSE_ON_CLOSE:
+                    dispose();
+                    break;
+                case EXIT_ON_CLOSE:
+                    WindowHosts.exit();
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JInternalFrame.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JInternalFrame.java
new file mode 100644
index 00000000000..b3d0ec9945a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JInternalFrame.java
@@ -0,0 +1,1020 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.beans.PropertyVetoException;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.InternalFrameEvent;
+import com.codename1.desktopcompat.javax.swing.event.InternalFrameListener;
+
+/// A window inside a window: a frame with a title bar that lives on a
+/// [JDesktopPane], or in any container, and is drawn by this layer.
+///
+/// It has a root pane like a frame, with a content pane, a menu bar place
+/// and a glass pane. The title bar shows the frame icon, the title and a
+/// button each for closing, maximizing and iconifying, for those of the
+/// three that are allowed. Dragging the title bar moves the frame,
+/// dragging its edge resizes it when it is resizable, and a press anywhere
+/// in it selects it and brings it to the front of its layer. A double
+/// click on the title bar maximizes or restores a maximizable frame.
+///
+/// ## What differs from the desktop
+///
+///  - An iconified frame is not replaced by a desktop icon: the frame
+///    itself shrinks to its title bar and moves to the bottom of its
+///    parent, and its iconify button, or a double click, restores it.
+///  - The frame is drawn with the colors of the theme. There is no UI
+///    delegate, no desktop manager and no system menu; a palette
+///    (`JInternalFrame.isPalette`) is drawn like any other frame.
+///  - The setters that can be vetoed on the desktop are not vetoed by
+///    anything here: there are no vetoable change listeners.
+///  - A frame is not a focus cycle root and keeps no "most recent focus
+///    owner".
+public class JInternalFrame extends JComponent implements Accessible, WindowConstants, RootPaneContainer {
+
+    public static final String CONTENT_PANE_PROPERTY = "contentPane";
+    public static final String MENU_BAR_PROPERTY = "JMenuBar";
+    public static final String TITLE_PROPERTY = "title";
+    public static final String LAYERED_PANE_PROPERTY = "layeredPane";
+    public static final String ROOT_PANE_PROPERTY = "rootPane";
+    public static final String GLASS_PANE_PROPERTY = "glassPane";
+    public static final String FRAME_ICON_PROPERTY = "frameIcon";
+    public static final String IS_SELECTED_PROPERTY = "selected";
+    public static final String IS_CLOSED_PROPERTY = "closed";
+    public static final String IS_MAXIMUM_PROPERTY = "maximum";
+    public static final String IS_ICON_PROPERTY = "icon";
+
+    private static final int EDGE = 4;
+    private static final int BAR = 24;
+    private static final int ICON_WIDTH = 160;
+    private static final int MIN_WIDTH = 100;
+
+    private static final int NORTH = 1;
+    private static final int SOUTH = 2;
+    private static final int WEST = 4;
+    private static final int EAST = 8;
+
+    private static final int CLOSE = 0;
+    private static final int MAXIMIZE = 1;
+    private static final int ICONIFY = 2;
+
+    protected JRootPane rootPane;
+    protected boolean rootPaneCheckingEnabled;
+    protected boolean closable;
+    protected boolean isClosed;
+    protected boolean maximizable;
+    protected boolean isMaximum;
+    protected boolean iconable;
+    protected boolean isIcon;
+    protected boolean resizable;
+    protected boolean isSelected;
+    protected Icon frameIcon;
+    protected String title;
+
+    private int defaultCloseOperation = DISPOSE_ON_CLOSE;
+    private Rectangle normalBounds;
+    private boolean opened;
+    /// What a drag that began on the chrome does: nothing, move, or
+    /// resize by the edges in `dragEdges`.
+    private int dragKind;
+    private int dragEdges;
+    private int pressX;
+    private int pressY;
+    private int pressedButton = -1;
+
+    public JInternalFrame() {
+        this("", false, false, false, false);
+    }
+
+    public JInternalFrame(String title) {
+        this(title, false, false, false, false);
+    }
+
+    public JInternalFrame(String title, boolean resizable) {
+        this(title, resizable, false, false, false);
+    }
+
+    public JInternalFrame(String title, boolean resizable, boolean closable) {
+        this(title, resizable, closable, false, false);
+    }
+
+    public JInternalFrame(String title, boolean resizable, boolean closable, boolean maximizable) {
+        this(title, resizable, closable, maximizable, false);
+    }
+
+    public JInternalFrame(String title, boolean resizable, boolean closable, boolean maximizable,
+            boolean iconifiable) {
+        this.title = title;
+        this.resizable = resizable;
+        this.closable = closable;
+        this.maximizable = maximizable;
+        this.iconable = iconifiable;
+        setRootPane(createRootPane());
+        setLayout(null);
+        setRootPaneCheckingEnabled(true);
+        setVisible(false);
+        setOpaque(true);
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
+    }
+
+    // ------------------------------------------------------------ root pane
+
+    protected JRootPane createRootPane() {
+        return new JRootPane();
+    }
+
+    @Override
+    public JRootPane getRootPane() {
+        return rootPane;
+    }
+
+    protected void setRootPane(JRootPane root) {
+        boolean checking = rootPaneCheckingEnabled;
+        rootPaneCheckingEnabled = false;
+        JRootPane old = rootPane;
+        try {
+            if (old != null) {
+                remove(old);
+            }
+            rootPane = root;
+            if (root != null) {
+                add(root);
+            }
+        } finally {
+            rootPaneCheckingEnabled = checking;
+        }
+        firePropertyChange(ROOT_PANE_PROPERTY, old, root);
+    }
+
+    protected boolean isRootPaneCheckingEnabled() {
+        return rootPaneCheckingEnabled;
+    }
+
+    protected void setRootPaneCheckingEnabled(boolean enabled) {
+        rootPaneCheckingEnabled = enabled;
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().add(comp, constraints, index);
+        } else {
+            super.addImpl(comp, constraints, index);
+        }
+    }
+
+    @Override
+    public void remove(Component comp) {
+        if (comp == rootPane || !rootPaneCheckingEnabled) {
+            super.remove(comp);
+        } else {
+            getContentPane().remove(comp);
+        }
+    }
+
+    @Override
+    public void setLayout(LayoutManager manager) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().setLayout(manager);
+        } else {
+            super.setLayout(manager);
+        }
+    }
+
+    @Override
+    public Container getContentPane() {
+        return rootPane.getContentPane();
+    }
+
+    @Override
+    public void setContentPane(Container c) {
+        Container old = getContentPane();
+        rootPane.setContentPane(c);
+        firePropertyChange(CONTENT_PANE_PROPERTY, old, c);
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public JLayeredPane getLayeredPane() {
+        return rootPane.getLayeredPane();
+    }
+
+    @Override
+    public void setLayeredPane(JLayeredPane layered) {
+        JLayeredPane old = getLayeredPane();
+        rootPane.setLayeredPane(layered);
+        firePropertyChange(LAYERED_PANE_PROPERTY, old, layered);
+    }
+
+    @Override
+    public Component getGlassPane() {
+        return rootPane.getGlassPane();
+    }
+
+    @Override
+    public void setGlassPane(Component glass) {
+        Component old = getGlassPane();
+        rootPane.setGlassPane(glass);
+        firePropertyChange(GLASS_PANE_PROPERTY, old, glass);
+    }
+
+    public JMenuBar getJMenuBar() {
+        return rootPane.getJMenuBar();
+    }
+
+    public void setJMenuBar(JMenuBar m) {
+        JMenuBar old = getJMenuBar();
+        rootPane.setJMenuBar(m);
+        firePropertyChange(MENU_BAR_PROPERTY, old, m);
+    }
+
+    // ------------------------------------------------------------ properties
+
+    public boolean isClosable() {
+        return closable;
+    }
+
+    public void setClosable(boolean b) {
+        boolean old = closable;
+        closable = b;
+        firePropertyChange("closable", old, b);
+        repaint();
+    }
+
+    public boolean isClosed() {
+        return isClosed;
+    }
+
+    /// Closes the frame: it is told it is closing, taken off its parent
+    /// and told it is closed. `false` does nothing to a closed frame.
+    ///
+    /// #### Throws
+    ///
+    /// - `PropertyVetoException`: never; see the class description
+    public void setClosed(boolean b) throws PropertyVetoException {
+        if (isClosed == b) {
+            return;
+        }
+        if (b) {
+            fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+        }
+        isClosed = b;
+        firePropertyChange(IS_CLOSED_PROPERTY, !b, b);
+        if (b) {
+            dispose();
+        }
+    }
+
+    public boolean isResizable() {
+        return !isMaximum && resizable;
+    }
+
+    public void setResizable(boolean b) {
+        boolean old = resizable;
+        resizable = b;
+        firePropertyChange("resizable", old, b);
+    }
+
+    public boolean isIconifiable() {
+        return iconable;
+    }
+
+    public void setIconifiable(boolean b) {
+        boolean old = iconable;
+        iconable = b;
+        firePropertyChange("iconable", old, b);
+        repaint();
+    }
+
+    public boolean isIcon() {
+        return isIcon;
+    }
+
+    /// Iconifies the frame or restores it; see the class description for
+    /// what an iconified frame looks like.
+    ///
+    /// #### Throws
+    ///
+    /// - `PropertyVetoException`: never; see the class description
+    public void setIcon(boolean b) throws PropertyVetoException {
+        if (isIcon == b) {
+            return;
+        }
+        if (b) {
+            if (!isMaximum) {
+                normalBounds = getBounds();
+            }
+            isIcon = true;
+            Container p = getParent();
+            int at = 0;
+            int bottom = 0;
+            if (p != null) {
+                bottom = Math.max(0, p.getHeight() - (BAR + 2 * EDGE));
+                for (int i = 0; i < p.getComponentCount(); i++) {
+                    Component c = p.getComponent(i);
+                    if (c != this && c instanceof JInternalFrame && ((JInternalFrame) c).isIcon()) {
+                        at++;
+                    }
+                }
+            }
+            setBounds(at * ICON_WIDTH, bottom, ICON_WIDTH, BAR + 2 * EDGE);
+        } else {
+            isIcon = false;
+            if (isMaximum) {
+                cn1FillParent();
+            } else if (normalBounds != null) {
+                setBounds(normalBounds);
+            }
+        }
+        firePropertyChange(IS_ICON_PROPERTY, !b, b);
+        fireInternalFrameEvent(b ? InternalFrameEvent.INTERNAL_FRAME_ICONIFIED
+                : InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
+        revalidate();
+        repaint();
+    }
+
+    public boolean isMaximizable() {
+        return maximizable;
+    }
+
+    public void setMaximizable(boolean b) {
+        boolean old = maximizable;
+        maximizable = b;
+        firePropertyChange("maximizable", old, b);
+        repaint();
+    }
+
+    public boolean isMaximum() {
+        return isMaximum;
+    }
+
+    /// Makes the frame as large as its parent, or gives it back the
+    /// bounds it had before.
+    ///
+    /// #### Throws
+    ///
+    /// - `PropertyVetoException`: never; see the class description
+    public void setMaximum(boolean b) throws PropertyVetoException {
+        if (isMaximum == b) {
+            return;
+        }
+        if (b) {
+            if (!isIcon) {
+                normalBounds = getBounds();
+            }
+            isMaximum = true;
+            if (!isIcon) {
+                cn1FillParent();
+            }
+        } else {
+            isMaximum = false;
+            if (!isIcon && normalBounds != null) {
+                setBounds(normalBounds);
+            }
+        }
+        firePropertyChange(IS_MAXIMUM_PROPERTY, !b, b);
+        revalidate();
+        repaint();
+    }
+
+    private void cn1FillParent() {
+        Container p = getParent();
+        if (p != null) {
+            setBounds(0, 0, p.getWidth(), p.getHeight());
+        }
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        String old = this.title;
+        this.title = title;
+        firePropertyChange(TITLE_PROPERTY, old, title);
+        repaint();
+    }
+
+    public boolean isSelected() {
+        return isSelected;
+    }
+
+    /// Selects the frame, which takes the selection from the frame of
+    /// its desk that had it and brings this one to the front, or takes
+    /// the selection from it. A frame that is not showing, or is closed
+    /// or iconified, is not selected.
+    ///
+    /// #### Throws
+    ///
+    /// - `PropertyVetoException`: never; see the class description
+    public void setSelected(boolean selected) throws PropertyVetoException {
+        if (selected && (isIcon || isClosed || !isShowing())) {
+            return;
+        }
+        if (isSelected == selected) {
+            return;
+        }
+        JDesktopPane desk = getDesktopPane();
+        if (selected) {
+            Container p = getParent();
+            if (p != null) {
+                for (int i = 0; i < p.getComponentCount(); i++) {
+                    Component c = p.getComponent(i);
+                    if (c != this && c instanceof JInternalFrame && ((JInternalFrame) c).isSelected()) {
+                        ((JInternalFrame) c).setSelected(false);
+                    }
+                }
+            }
+        }
+        isSelected = selected;
+        firePropertyChange(IS_SELECTED_PROPERTY, !selected, selected);
+        if (selected) {
+            if (desk != null) {
+                desk.setSelectedFrame(this);
+            }
+            moveToFront();
+            fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);
+        } else {
+            if (desk != null && desk.getSelectedFrame() == this) {
+                desk.setSelectedFrame(null);
+            }
+            fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);
+        }
+        repaint();
+    }
+
+    public void setFrameIcon(Icon icon) {
+        Icon old = frameIcon;
+        frameIcon = icon;
+        firePropertyChange(FRAME_ICON_PROPERTY, old, icon);
+        repaint();
+    }
+
+    public Icon getFrameIcon() {
+        return frameIcon;
+    }
+
+    /// The bounds the frame has when it is neither maximized nor
+    /// iconified.
+    public Rectangle getNormalBounds() {
+        if (normalBounds != null && (isMaximum || isIcon)) {
+            return new Rectangle(normalBounds.x, normalBounds.y, normalBounds.width, normalBounds.height);
+        }
+        return getBounds();
+    }
+
+    public void setNormalBounds(Rectangle r) {
+        normalBounds = r == null ? null : new Rectangle(r.x, r.y, r.width, r.height);
+    }
+
+    public void setDefaultCloseOperation(int operation) {
+        defaultCloseOperation = operation;
+    }
+
+    public int getDefaultCloseOperation() {
+        return defaultCloseOperation;
+    }
+
+    // ------------------------------------------------------------ layers
+
+    public void moveToFront() {
+        Container p = getParent();
+        if (p instanceof JLayeredPane) {
+            ((JLayeredPane) p).moveToFront(this);
+        }
+    }
+
+    public void moveToBack() {
+        Container p = getParent();
+        if (p instanceof JLayeredPane) {
+            ((JLayeredPane) p).moveToBack(this);
+        }
+    }
+
+    public void toFront() {
+        moveToFront();
+    }
+
+    public void toBack() {
+        moveToBack();
+    }
+
+    public void setLayer(Integer layer) {
+        setLayer(layer.intValue());
+    }
+
+    public void setLayer(int layer) {
+        Container p = getParent();
+        if (p instanceof JLayeredPane) {
+            ((JLayeredPane) p).setLayer(this, layer, ((JLayeredPane) p).getPosition(this));
+        } else {
+            JLayeredPane.putLayer(this, layer);
+        }
+    }
+
+    public int getLayer() {
+        return JLayeredPane.getLayer(this);
+    }
+
+    /// The desk the frame lies on, or `null` when its parent is not one.
+    public JDesktopPane getDesktopPane() {
+        for (Container p = getParent(); p != null; p = p.getParent()) {
+            if (p instanceof JDesktopPane) {
+                return (JDesktopPane) p;
+            }
+        }
+        return null;
+    }
+
+    // ------------------------------------------------------------ showing
+
+    /// Shows the frame: the first time it is told it was opened, and it
+    /// comes to the front and is selected unless another frame is.
+    public void show() {
+        if (isVisible()) {
+            return;
+        }
+        if (!opened) {
+            opened = true;
+            fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
+        }
+        setVisible(true);
+        toFront();
+        JDesktopPane desk = getDesktopPane();
+        if (!isIcon && !isClosed && (desk == null || desk.getSelectedFrame() == null)) {
+            try {
+                setSelected(true);
+            } catch (PropertyVetoException notVetoedHere) {
+                repaint();
+            }
+        }
+    }
+
+    public void hide() {
+        if (isIcon && isVisible()) {
+            repaint();
+        }
+        setVisible(false);
+    }
+
+    /// Takes the frame off its parent for good and tells it it is
+    /// closed.
+    public void dispose() {
+        if (isVisible()) {
+            setVisible(false);
+        }
+        if (isSelected) {
+            try {
+                setSelected(false);
+            } catch (PropertyVetoException notVetoedHere) {
+                isSelected = false;
+            }
+        }
+        if (!isClosed) {
+            isClosed = true;
+            firePropertyChange(IS_CLOSED_PROPERTY, false, true);
+        }
+        Container p = getParent();
+        if (p != null) {
+            p.remove(this);
+            p.repaint();
+        }
+        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
+    }
+
+    /// What the close button does: tells the frame it is closing, then
+    /// hides it, disposes of it or leaves it, as the default close
+    /// operation says.
+    public void doDefaultCloseAction() {
+        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+        switch (defaultCloseOperation) {
+            case HIDE_ON_CLOSE:
+                setVisible(false);
+                if (isSelected) {
+                    try {
+                        setSelected(false);
+                    } catch (PropertyVetoException notVetoedHere) {
+                        isSelected = false;
+                    }
+                }
+                break;
+            case DISPOSE_ON_CLOSE:
+                dispose();
+                break;
+            default:
+                break;
+        }
+    }
+
+    /// Sizes the frame to the preferred size of what it holds.
+    public void pack() {
+        Dimension d = getPreferredSize();
+        setSize(d.width, d.height);
+        validate();
+    }
+
+    // ------------------------------------------------------------ events
+
+    public void addInternalFrameListener(InternalFrameListener l) {
+        listenerList.add(InternalFrameListener.class, l);
+    }
+
+    public void removeInternalFrameListener(InternalFrameListener l) {
+        listenerList.remove(InternalFrameListener.class, l);
+    }
+
+    public InternalFrameListener[] getInternalFrameListeners() {
+        return listenerList.getListeners(InternalFrameListener.class);
+    }
+
+    protected void fireInternalFrameEvent(int id) {
+        InternalFrameListener[] ls = getInternalFrameListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        InternalFrameEvent e = new InternalFrameEvent(this, id);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            switch (id) {
+                case InternalFrameEvent.INTERNAL_FRAME_OPENED:
+                    ls[i].internalFrameOpened(e);
+                    break;
+                case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
+                    ls[i].internalFrameClosing(e);
+                    break;
+                case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
+                    ls[i].internalFrameClosed(e);
+                    break;
+                case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
+                    ls[i].internalFrameIconified(e);
+                    break;
+                case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
+                    ls[i].internalFrameDeiconified(e);
+                    break;
+                case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
+                    ls[i].internalFrameActivated(e);
+                    break;
+                case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
+                    ls[i].internalFrameDeactivated(e);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ layout
+
+    @Override
+    public void doLayout() {
+        if (rootPane != null) {
+            rootPane.setBounds(EDGE, EDGE + BAR, Math.max(0, getWidth() - 2 * EDGE),
+                    Math.max(0, getHeight() - 2 * EDGE - BAR));
+        }
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet() || rootPane == null) {
+            return super.getPreferredSize();
+        }
+        Dimension d = rootPane.getPreferredSize();
+        return new Dimension(Math.max(MIN_WIDTH, d.width + 2 * EDGE), d.height + 2 * EDGE + BAR);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return new Dimension(MIN_WIDTH, BAR + 2 * EDGE);
+    }
+
+    // ------------------------------------------------------------ paint
+
+    /// `c` moved toward black by `by` in each channel; a middle gray for
+    /// no color.
+    /// Whether two colours are too close in brightness to tell two title
+    /// bars apart.
+    private static boolean cn1Near(Color a, Color b) {
+        int la = a.getRed() * 3 + a.getGreen() * 6 + a.getBlue();
+        int lb = b.getRed() * 3 + b.getGreen() * 6 + b.getBlue();
+        return Math.abs(la - lb) < 480;
+    }
+
+    static Color cn1Shade(Color c, int by) {
+        if (c == null) {
+            return new Color(160, 160, 160);
+        }
+        return new Color(Math.max(0, c.getRed() - by), Math.max(0, c.getGreen() - by),
+                Math.max(0, c.getBlue() - by));
+    }
+
+    /// Where the title bar button `which` is, or `null` when the frame
+    /// has none: the buttons run from the right, close first.
+    private Rectangle cn1Button(int which) {
+        int size = BAR - 6;
+        int x = getWidth() - EDGE - 3 - size;
+        int y = EDGE + 3;
+        if (closable) {
+            if (which == CLOSE) {
+                return new Rectangle(x, y, size, size);
+            }
+            x -= size + 3;
+        }
+        if (maximizable && !isIcon) {
+            if (which == MAXIMIZE) {
+                return new Rectangle(x, y, size, size);
+            }
+            x -= size + 3;
+        }
+        if (iconable && which == ICONIFY) {
+            return new Rectangle(x, y, size, size);
+        }
+        return null;
+    }
+
+    private int cn1ButtonAt(int x, int y) {
+        for (int i = CLOSE; i <= ICONIFY; i++) {
+            Rectangle r = cn1Button(i);
+            if (r != null && r.contains(x, y)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        int w = getWidth();
+        int h = getHeight();
+        Color face = isBackgroundSet() ? getBackground() : UIManager.getColor("control");
+        if (face == null) {
+            face = new Color(238, 238, 238);
+        }
+        Color line = cn1Shade(face, 96);
+        g.setColor(face);
+        g.fillRect(0, 0, w, h);
+        g.setColor(line);
+        g.drawRect(0, 0, w - 1, h - 1);
+
+        Color plain = cn1Shade(face, 16);
+        Color bar = isSelected ? UIManager.getColor("textHighlight") : plain;
+        Color ink = isSelected ? UIManager.getColor("textHighlightText") : UIManager.getColor("controlText");
+        if (ink == null) {
+            ink = Color.BLACK;
+        }
+        if (bar == null || (isSelected && cn1Near(bar, plain))) {
+            // A theme without a selection colour of its own answers a
+            // faint tint of the window, which beside the bar of a frame
+            // that is not selected cannot be told from it. The selected
+            // frame is the one the keyboard goes to; it has to show.
+            Color text = UIManager.getColor("controlText");
+            bar = com.codename1.desktopcompat.rt.CellTheme.mix(face, text == null ? Color.BLACK : text, 0.38f);
+            ink = face;
+        }
+        g.setColor(bar);
+        g.fillRect(EDGE, EDGE, Math.max(0, w - 2 * EDGE), BAR);
+
+        int right = w - EDGE - 3;
+        for (int i = CLOSE; i <= ICONIFY; i++) {
+            Rectangle r = cn1Button(i);
+            if (r == null) {
+                continue;
+            }
+            right = Math.min(right, r.x - 3);
+            g.setColor(face);
+            g.fillRect(r.x, r.y, r.width, r.height);
+            g.setColor(line);
+            g.drawRect(r.x, r.y, r.width - 1, r.height - 1);
+            int a = 4;
+            int x0 = r.x + a;
+            int y0 = r.y + a;
+            int x1 = r.x + r.width - 1 - a;
+            int y1 = r.y + r.height - 1 - a;
+            if (i == CLOSE) {
+                g.drawLine(x0, y0, x1, y1);
+                g.drawLine(x0, y1, x1, y0);
+            } else if (i == MAXIMIZE) {
+                g.drawRect(x0, y0, x1 - x0, y1 - y0);
+                g.drawLine(x0, y0 + 1, x1, y0 + 1);
+                if (isMaximum) {
+                    g.drawLine(x0 + 3, y1 - 3, x1 - 3, y1 - 3);
+                }
+            } else {
+                g.drawLine(x0, y1, x1, y1);
+                g.drawLine(x0, y1 - 1, x1, y1 - 1);
+            }
+        }
+
+        int x = EDGE + 4;
+        if (frameIcon != null) {
+            int ih = frameIcon.getIconHeight();
+            if (ih > 0 && ih <= BAR) {
+                frameIcon.paintIcon(this, g, x, EDGE + (BAR - ih) / 2);
+                x += frameIcon.getIconWidth() + 4;
+            }
+        }
+        if (title != null && title.length() > 0 && right > x) {
+            g.setFont(getFont());
+            FontMetrics fm = g.getFontMetrics();
+            String shown = title;
+            while (shown.length() > 1 && fm.stringWidth(shown) > right - x) {
+                shown = shown.substring(0, shown.length() - 1);
+            }
+            if (fm.stringWidth(shown) <= right - x) {
+                g.setColor(ink);
+                g.drawString(shown, x, EDGE + (BAR - fm.getHeight()) / 2 + fm.getAscent());
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ pointer
+
+    /// A press landed on `hit`: the internal frame it is in, if any and
+    /// not selected yet, becomes the selected one. Called for every
+    /// press, before the press is delivered.
+    public static void cn1PressedIn(Component hit) {
+        for (Component c = hit; c != null; c = c.getParent()) {
+            if (c instanceof JInternalFrame) {
+                JInternalFrame f = (JInternalFrame) c;
+                if (!f.isSelected() && !f.isIcon()) {
+                    try {
+                        f.setSelected(true);
+                    } catch (PropertyVetoException notVetoedHere) {
+                        f.repaint();
+                    }
+                }
+                return;
+            }
+        }
+    }
+
+    private int cn1EdgesAt(int x, int y) {
+        if (!isResizable() || isIcon) {
+            return 0;
+        }
+        int grip = EDGE + 4;
+        int edges = 0;
+        if (y < EDGE) {
+            edges |= NORTH;
+        } else if (y >= getHeight() - EDGE) {
+            edges |= SOUTH;
+        }
+        if (x < EDGE) {
+            edges |= WEST;
+        } else if (x >= getWidth() - EDGE) {
+            edges |= EAST;
+        }
+        if (edges != 0) {
+            // Near a corner an edge is the corner.
+            if (y < grip) {
+                edges |= NORTH;
+            } else if (y >= getHeight() - grip) {
+                edges |= SOUTH;
+            }
+            if (x < grip) {
+                edges |= WEST;
+            } else if (x >= getWidth() - grip) {
+                edges |= EAST;
+            }
+        }
+        return edges;
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        super.processMouseEvent(e);
+        if (e.isConsumed() || e.getButton() != MouseEvent.BUTTON1) {
+            return;
+        }
+        int x = e.getX();
+        int y = e.getY();
+        if (e.getID() == MouseEvent.MOUSE_PRESSED) {
+            dragKind = 0;
+            pressedButton = cn1ButtonAt(x, y);
+            if (pressedButton >= 0) {
+                return;
+            }
+            pressX = x;
+            pressY = y;
+            dragEdges = cn1EdgesAt(x, y);
+            if (dragEdges != 0) {
+                dragKind = 2;
+            } else if (y < EDGE + BAR && !isMaximum) {
+                dragKind = 1;
+            }
+        } else if (e.getID() == MouseEvent.MOUSE_RELEASED) {
+            int was = pressedButton;
+            pressedButton = -1;
+            dragKind = 0;
+            if (was >= 0 && was == cn1ButtonAt(x, y)) {
+                cn1Press(was);
+            }
+        } else if (e.getID() == MouseEvent.MOUSE_CLICKED && e.getClickCount() == 2 && y < EDGE + BAR
+                && cn1ButtonAt(x, y) < 0) {
+            if (isIcon) {
+                cn1Press(ICONIFY);
+            } else if (maximizable) {
+                cn1Press(MAXIMIZE);
+            }
+        }
+    }
+
+    private void cn1Press(int which) {
+        try {
+            if (which == CLOSE) {
+                doDefaultCloseAction();
+            } else if (which == MAXIMIZE) {
+                setMaximum(!isMaximum);
+            } else if (which == ICONIFY) {
+                setIcon(!isIcon);
+                if (!isIcon) {
+                    setSelected(true);
+                }
+            }
+        } catch (PropertyVetoException notVetoedHere) {
+            repaint();
+        }
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        super.processMouseMotionEvent(e);
+        if (e.getID() != MouseEvent.MOUSE_DRAGGED || dragKind == 0 || e.isConsumed()) {
+            return;
+        }
+        int dx = e.getX() - pressX;
+        int dy = e.getY() - pressY;
+        if (dragKind == 1) {
+            if (dx != 0 || dy != 0) {
+                setLocation(getX() + dx, getY() + dy);
+            }
+            return;
+        }
+        int nx = getX();
+        int ny = getY();
+        int nw = getWidth();
+        int nh = getHeight();
+        int minH = BAR + 2 * EDGE;
+        if ((dragEdges & EAST) != 0) {
+            nw = Math.max(MIN_WIDTH, nw + dx);
+            pressX += nw - getWidth();
+        } else if ((dragEdges & WEST) != 0) {
+            int w = Math.max(MIN_WIDTH, nw - dx);
+            nx += nw - w;
+            nw = w;
+        }
+        if ((dragEdges & SOUTH) != 0) {
+            nh = Math.max(minH, nh + dy);
+            pressY += nh - getHeight();
+        } else if ((dragEdges & NORTH) != 0) {
+            int h = Math.max(minH, nh - dy);
+            ny += nh - h;
+            nh = h;
+        }
+        if (nx != getX() || ny != getY() || nw != getWidth() || nh != getHeight()) {
+            setBounds(nx, ny, nw, nh);
+            revalidate();
+            Container p = getParent();
+            if (p != null) {
+                p.repaint();
+            }
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",title=" + title;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JLabel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JLabel.java
new file mode 100644
index 00000000000..1f6e4f25c2d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JLabel.java
@@ -0,0 +1,576 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.rt.Align;
+import com.codename1.desktopcompat.rt.LabelPeer;
+import com.codename1.desktopcompat.rt.MiniHtml;
+import com.codename1.desktopcompat.rt.Units;
+
+/// A line of text, an icon, or both, shown by a Codename One label.
+///
+/// The alignments and the text position relative to the icon are
+/// honoured, with one limit: Codename One places text on one of the four
+/// sides of the icon, so text centered over the icon is placed after it.
+/// A disabled label shows its disabled icon if it was given one.
+///
+/// A text that starts with `<html>` is drawn by the label itself from
+/// what [com.codename1.desktopcompat.rt.MiniHtml] makes of it: bold,
+/// italic, underline, colors, sizes, line breaks, paragraphs and
+/// centering. Its preferred size is that of its unwrapped lines; in a
+/// narrower label the lines wrap at spaces.
+///
+/// The displayed mnemonic is recorded only. A click on a label focuses
+/// the component it was made the label for.
+public class JLabel extends JComponent implements Accessible, SwingConstants {
+
+    private String text;
+    private Icon icon;
+    private Icon disabledIcon;
+    private int horizontalAlignment;
+    private int verticalAlignment = CENTER;
+    private int horizontalTextPosition = TRAILING;
+    private int verticalTextPosition = CENTER;
+    private int iconTextGap = 4;
+    private Component labelFor;
+    private int mnemonic;
+    private int mnemonicIndex = -1;
+    private MiniHtml.Document html;
+
+    public JLabel(String text, Icon icon, int horizontalAlignment) {
+        this.text = text;
+        this.icon = icon;
+        setHorizontalAlignment(horizontalAlignment);
+        setAlignmentX(LEFT_ALIGNMENT);
+    }
+
+    public JLabel(String text, int horizontalAlignment) {
+        this(text, null, horizontalAlignment);
+    }
+
+    public JLabel(String text) {
+        this(text, null, LEADING);
+    }
+
+    public JLabel(Icon image, int horizontalAlignment) {
+        this(null, image, horizontalAlignment);
+    }
+
+    public JLabel(Icon image) {
+        this(null, image, CENTER);
+    }
+
+    public JLabel() {
+        this("", null, LEADING);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new LabelPeer(this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        sync();
+    }
+
+    private void sync() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.Label) {
+            com.codename1.ui.Label l = (com.codename1.ui.Label) p;
+            boolean own = paintsItself();
+            l.setText(text == null || own ? "" : text);
+            l.setIcon(null);
+            l.setAlignment(nativeAlignment(horizontalAlignment));
+            l.setVerticalAlignment(Align.vertical(verticalAlignment));
+            l.setTextPosition(Align.textPosition(horizontalTextPosition, verticalTextPosition));
+            l.setGap(Units.toDevice(iconTextGap));
+        }
+    }
+
+    private Icon shownIcon() {
+        return !isEnabled() && disabledIcon != null ? disabledIcon : icon;
+    }
+
+    // ------------------------------------------------------------ html
+
+    /// Whether the label is drawn here instead of by the Codename One
+    /// label behind it: when its text is HTML, and when it has an icon.
+    /// An icon is asked to paint itself on this component each time, as on
+    /// the desktop, because an icon may draw from the state of the
+    /// component it is given -- its size, whether it is enabled -- and one
+    /// larger than the label is clipped, not scaled.
+    private boolean paintsItself() {
+        return MiniHtml.isHtml(text) || shownIcon() != null;
+    }
+
+    /// The size of the text of a label that is not HTML.
+    private Dimension plainSize(Font f) {
+        if (text == null || text.length() == 0) {
+            return new Dimension(0, 0);
+        }
+        com.codename1.desktopcompat.java.awt.FontMetrics fm = com.codename1.desktopcompat.rt.Fonts.metrics(f);
+        return new Dimension(fm.stringWidth(text), fm.getHeight());
+    }
+
+    private MiniHtml.Document document() {
+        if (html == null) {
+            html = MiniHtml.parse(text);
+        }
+        return html;
+    }
+
+    private Font htmlFont() {
+        return getFont();
+    }
+
+    /// The space around the content of an HTML label: the border's, and
+    /// the padding the theme gives a label, so that it lines up with the
+    /// labels Codename One draws.
+    private Insets htmlInsets() {
+        Insets in = getInsets();
+        Insets out = new Insets(in.top, in.left, in.bottom, in.right);
+        if (com.codename1.ui.Display.isInitialized()) {
+            com.codename1.ui.plaf.Style st = cn1Peer().getStyle();
+            out.top += Units.toLogicalCeil(st.getPaddingTop());
+            out.bottom += Units.toLogicalCeil(st.getPaddingBottom());
+            out.left += Units.toLogicalCeil(st.getPaddingLeftNoRTL());
+            out.right += Units.toLogicalCeil(st.getPaddingRightNoRTL());
+        }
+        return out;
+    }
+
+    private boolean iconBeside() {
+        return horizontalTextPosition != CENTER || verticalTextPosition == CENTER;
+    }
+
+    /// The size of the icon and the text together, given the text's.
+    private Dimension htmlContent(Dimension textSize) {
+        Icon ic = shownIcon();
+        if (ic == null) {
+            return textSize;
+        }
+        if (textSize.width == 0) {
+            return new Dimension(ic.getIconWidth(), ic.getIconHeight());
+        }
+        if (iconBeside()) {
+            return new Dimension(ic.getIconWidth() + iconTextGap + textSize.width,
+                    Math.max(ic.getIconHeight(), textSize.height));
+        }
+        return new Dimension(Math.max(ic.getIconWidth(), textSize.width),
+                ic.getIconHeight() + iconTextGap + textSize.height);
+    }
+
+    @Override
+    protected Dimension cn1NativePreferredSize() {
+        if (!paintsItself()) {
+            return super.cn1NativePreferredSize();
+        }
+        boolean isHtml = MiniHtml.isHtml(text);
+        Dimension text = isHtml ? MiniHtml.preferredSize(document(), htmlFont()) : plainSize(htmlFont());
+        int wrap = isHtml ? wrapWidth() : 0;
+        if (wrap > 0) {
+            text = new Dimension(text.width, MiniHtml.wrappedSize(document(), htmlFont(), wrap).height);
+        }
+        Dimension d = htmlContent(text);
+        Insets in = htmlInsets();
+        return new Dimension(d.width + in.left + in.right, d.height + in.top + in.bottom);
+    }
+
+    /// The preferred size, except that an HTML text can be as narrow as
+    /// its longest word: as on the desktop, where the minimum of an HTML
+    /// label is its preferred size less what its text gives up by
+    /// wrapping.
+    @Override
+    public Dimension getMinimumSize() {
+        Dimension d = super.getMinimumSize();
+        if (isMinimumSizeSet() || !MiniHtml.isHtml(text)) {
+            return d;
+        }
+        int unbroken = MiniHtml.preferredSize(document(), htmlFont()).width;
+        int word = MiniHtml.wrappedSize(document(), htmlFont(), 1).width;
+        return new Dimension(Math.max(0, d.width - Math.max(0, unbroken - word)), d.height);
+    }
+
+    /// The width the HTML text is broken to, or 0 while the label is wide
+    /// enough for its longest line, has no size yet or is not HTML.
+    ///
+    /// As on the desktop, an HTML label that was given less room than its
+    /// text wants on one line wraps, and from then on prefers the height of
+    /// the wrapped text; its preferred width stays that of the unbroken
+    /// text. A layout that measured it before it had a size therefore lays
+    /// it out a second time, which [#setBounds(int, int, int, int)] asks
+    /// for.
+    private int wrapWidth() {
+        if (!MiniHtml.isHtml(text) || getWidth() <= 0) {
+            return 0;
+        }
+        Insets in = htmlInsets();
+        int avail = getWidth() - in.left - in.right;
+        Icon ic = shownIcon();
+        if (ic != null && iconBeside()) {
+            avail -= ic.getIconWidth() + iconTextGap;
+        }
+        if (avail <= 0) {
+            return 0;
+        }
+        return avail < MiniHtml.preferredSize(document(), htmlFont()).width ? avail : 0;
+    }
+
+    @Override
+    public void setBounds(int x, int y, int width, int height) {
+        if (width == getWidth() || !MiniHtml.isHtml(text)) {
+            super.setBounds(x, y, width, height);
+            return;
+        }
+        int was = wrapWidth();
+        super.setBounds(x, y, width, height);
+        if (wrapWidth() != was) {
+            com.codename1.desktopcompat.rt.PeerSupport.layoutAgain(this);
+        }
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (!paintsItself()) {
+            super.paintComponent(g);
+            return;
+        }
+        boolean isHtml = MiniHtml.isHtml(text);
+        if (isOpaque()) {
+            Color bg = getBackground();
+            if (bg != null) {
+                g.setColor(bg);
+                g.fillRect(0, 0, getWidth(), getHeight());
+            }
+        }
+        Insets in = htmlInsets();
+        int availW = Math.max(0, getWidth() - in.left - in.right);
+        int availH = Math.max(0, getHeight() - in.top - in.bottom);
+        Font f = htmlFont();
+        Icon ic = shownIcon();
+        boolean beside = iconBeside();
+        int textAvail = ic != null && beside ? Math.max(1, availW - ic.getIconWidth() - iconTextGap) : availW;
+        MiniHtml.Document doc = isHtml ? MiniHtml.wrap(document(), f, textAvail) : null;
+        Dimension textSize = isHtml ? MiniHtml.preferredSize(doc, f) : plainSize(f);
+        int iconTextGap = textSize.width == 0 ? 0 : this.iconTextGap;
+        Dimension content = htmlContent(textSize);
+        int x = in.left;
+        int nativeAlign = nativeAlignment(horizontalAlignment);
+        if (nativeAlign == com.codename1.ui.Component.CENTER) {
+            x += (availW - content.width) / 2;
+        } else if (nativeAlign == com.codename1.ui.Component.RIGHT) {
+            x += availW - content.width;
+        }
+        int y = in.top;
+        if (verticalAlignment == CENTER) {
+            y += (availH - content.height) / 2;
+        } else if (verticalAlignment == BOTTOM) {
+            y += availH - content.height;
+        }
+        int textX = x;
+        int textY = y;
+        if (ic != null) {
+            int iconX = x;
+            int iconY = y;
+            if (beside) {
+                boolean textFirst = horizontalTextPosition == LEFT || horizontalTextPosition == LEADING;
+                if (textFirst) {
+                    iconX = x + textSize.width + iconTextGap;
+                } else {
+                    textX = x + ic.getIconWidth() + iconTextGap;
+                }
+                iconY = y + (content.height - ic.getIconHeight()) / 2;
+                textY = y + (content.height - textSize.height) / 2;
+            } else {
+                iconX = x + (content.width - ic.getIconWidth()) / 2;
+                textX = x + (content.width - textSize.width) / 2;
+                if (verticalTextPosition == TOP) {
+                    iconY = y + textSize.height + iconTextGap;
+                } else {
+                    textY = y + ic.getIconHeight() + iconTextGap;
+                }
+            }
+            ic.paintIcon(this, g, iconX, iconY);
+        }
+        g.setFont(f);
+        Color fg = getForeground();
+        if (!isEnabled()) {
+            fg = Color.GRAY;
+        }
+        if (fg != null) {
+            g.setColor(fg);
+        }
+        int lineAlign = nativeAlign == com.codename1.ui.Component.CENTER ? MiniHtml.ALIGN_CENTER
+                : nativeAlign == com.codename1.ui.Component.RIGHT ? MiniHtml.ALIGN_RIGHT : MiniHtml.ALIGN_LEFT;
+        if (isHtml) {
+            MiniHtml.paint(g, doc, textX, textY, textSize.width, lineAlign);
+        } else if (textSize.width > 0) {
+            g.drawString(text, textX, textY + com.codename1.desktopcompat.rt.Fonts.metrics(f).getAscent());
+        }
+    }
+
+    @Override
+    public void setEnabled(boolean b) {
+        boolean old = isEnabled();
+        super.setEnabled(b);
+        if (old != b && disabledIcon != null) {
+            sync();
+        }
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        if (e.getID() == MouseEvent.MOUSE_CLICKED && labelFor != null) {
+            labelFor.requestFocus();
+        }
+        super.processMouseEvent(e);
+    }
+
+    static int nativeAlignment(int alignment) {
+        switch (alignment) {
+            case CENTER:
+                return com.codename1.ui.Component.CENTER;
+            case RIGHT:
+            case TRAILING:
+                return com.codename1.ui.Component.RIGHT;
+            default:
+                return com.codename1.ui.Component.LEFT;
+        }
+    }
+
+    private void changed() {
+        sync();
+        revalidate();
+        repaint();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        String old = this.text;
+        this.text = text;
+        html = null;
+        firePropertyChange("text", old, text);
+        setDisplayedMnemonicIndex(findMnemonic(text, mnemonic));
+        if (old == null ? text != null : !old.equals(text)) {
+            changed();
+        }
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    public void setIcon(Icon icon) {
+        Icon old = this.icon;
+        this.icon = icon;
+        firePropertyChange("icon", old, icon);
+        if (old != icon) {
+            changed();
+        }
+    }
+
+    public Icon getDisabledIcon() {
+        return disabledIcon;
+    }
+
+    /// Shown in place of the icon while the label is disabled.
+    public void setDisabledIcon(Icon disabledIcon) {
+        Icon old = this.disabledIcon;
+        this.disabledIcon = disabledIcon;
+        firePropertyChange("disabledIcon", old, disabledIcon);
+        if (old != disabledIcon && !isEnabled()) {
+            changed();
+        }
+    }
+
+    public int getHorizontalAlignment() {
+        return horizontalAlignment;
+    }
+
+    public void setHorizontalAlignment(int alignment) {
+        if (alignment != LEFT && alignment != CENTER && alignment != RIGHT && alignment != LEADING
+                && alignment != TRAILING) {
+            throw new IllegalArgumentException("horizontalAlignment");
+        }
+        if (alignment != horizontalAlignment) {
+            int old = horizontalAlignment;
+            horizontalAlignment = alignment;
+            firePropertyChange("horizontalAlignment", old, alignment);
+            sync();
+            repaint();
+        }
+    }
+
+    public int getVerticalAlignment() {
+        return verticalAlignment;
+    }
+
+    public void setVerticalAlignment(int alignment) {
+        if (alignment != TOP && alignment != CENTER && alignment != BOTTOM) {
+            throw new IllegalArgumentException("verticalAlignment");
+        }
+        if (alignment != verticalAlignment) {
+            int old = verticalAlignment;
+            verticalAlignment = alignment;
+            firePropertyChange("verticalAlignment", old, alignment);
+            sync();
+            repaint();
+        }
+    }
+
+    public int getHorizontalTextPosition() {
+        return horizontalTextPosition;
+    }
+
+    public void setHorizontalTextPosition(int textPosition) {
+        if (textPosition != LEFT && textPosition != CENTER && textPosition != RIGHT && textPosition != LEADING
+                && textPosition != TRAILING) {
+            throw new IllegalArgumentException("horizontalTextPosition");
+        }
+        int old = horizontalTextPosition;
+        horizontalTextPosition = textPosition;
+        firePropertyChange("horizontalTextPosition", old, textPosition);
+        if (old != textPosition) {
+            changed();
+        }
+    }
+
+    public int getVerticalTextPosition() {
+        return verticalTextPosition;
+    }
+
+    public void setVerticalTextPosition(int textPosition) {
+        if (textPosition != TOP && textPosition != CENTER && textPosition != BOTTOM) {
+            throw new IllegalArgumentException("verticalTextPosition");
+        }
+        int old = verticalTextPosition;
+        verticalTextPosition = textPosition;
+        firePropertyChange("verticalTextPosition", old, textPosition);
+        if (old != textPosition) {
+            changed();
+        }
+    }
+
+    public int getIconTextGap() {
+        return iconTextGap;
+    }
+
+    public void setIconTextGap(int iconTextGap) {
+        if (iconTextGap != this.iconTextGap) {
+            this.iconTextGap = iconTextGap;
+            changed();
+        }
+    }
+
+    public Component getLabelFor() {
+        return labelFor;
+    }
+
+    /// Remembers the component this label names; a click on the label
+    /// then moves the focus to it.
+    public void setLabelFor(Component c) {
+        Component old = labelFor;
+        labelFor = c;
+        if (c != null) {
+            enableEvents(AWTEvent.MOUSE_EVENT_MASK);
+        } else {
+            disableEvents(AWTEvent.MOUSE_EVENT_MASK);
+        }
+        firePropertyChange("labelFor", old, c);
+    }
+
+    public int getDisplayedMnemonic() {
+        return mnemonic;
+    }
+
+    /// Recorded only: no character is underlined and no key is bound.
+    public void setDisplayedMnemonic(int key) {
+        int old = mnemonic;
+        mnemonic = key;
+        firePropertyChange("displayedMnemonic", old, key);
+        setDisplayedMnemonicIndex(findMnemonic(text, key));
+    }
+
+    /// The first place the mnemonic's letter stands in the text, in either
+    /// case, or -1.
+    private static int findMnemonic(String text, int key) {
+        if (text == null || key <= 0 || key > 0xffff) {
+            return -1;
+        }
+        int upper = key >= 'a' && key <= 'z' ? key - ('a' - 'A') : key;
+        int lower = key >= 'A' && key <= 'Z' ? key + ('a' - 'A') : key;
+        int u = text.indexOf((char) upper);
+        int l = text.indexOf((char) lower);
+        if (u < 0) {
+            return l;
+        }
+        if (l < 0) {
+            return u;
+        }
+        return Math.min(u, l);
+    }
+
+    public void setDisplayedMnemonic(char aChar) {
+        int vk = aChar;
+        if (vk >= 'a' && vk <= 'z') {
+            vk -= 'a' - 'A';
+        }
+        setDisplayedMnemonic(vk);
+    }
+
+    public int getDisplayedMnemonicIndex() {
+        return mnemonicIndex;
+    }
+
+    /// Recorded only.
+    public void setDisplayedMnemonicIndex(int index) {
+        int old = mnemonicIndex;
+        if (index != -1) {
+            int length = text == null ? 0 : text.length();
+            if (index < -1 || index >= length) {
+                throw new IllegalArgumentException("index == " + index);
+            }
+        }
+        mnemonicIndex = index;
+        firePropertyChange("displayedMnemonicIndex", old, index);
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",text=" + text;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JLayeredPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JLayeredPane.java
new file mode 100644
index 00000000000..e9dd9c77d0f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JLayeredPane.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// A container whose children overlap in layers: a child in a higher
+/// layer is painted over, and takes the pointer before, a child in a
+/// lower one, and within a layer the child at the lower position is on
+/// top. It has no layout manager; children keep the bounds they are
+/// given.
+public class JLayeredPane extends JComponent implements Accessible {
+
+    public static final Integer DEFAULT_LAYER = Integer.valueOf(0);
+    public static final Integer PALETTE_LAYER = Integer.valueOf(100);
+    public static final Integer MODAL_LAYER = Integer.valueOf(200);
+    public static final Integer POPUP_LAYER = Integer.valueOf(300);
+    public static final Integer DRAG_LAYER = Integer.valueOf(400);
+    public static final Integer FRAME_CONTENT_LAYER = Integer.valueOf(-30000);
+    public static final String LAYER_PROPERTY = "layeredContainerLayer";
+
+    private final HashMap<Component, Integer> layers = new HashMap<Component, Integer>();
+
+    public JLayeredPane() {
+        setLayout(null);
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        int layer;
+        if (constraints instanceof Integer) {
+            layer = ((Integer) constraints).intValue();
+            setLayer(comp, layer);
+        } else {
+            layer = getLayer(comp);
+        }
+        super.addImpl(comp, constraints, insertIndexForLayer(comp, layer, index));
+        comp.validate();
+        comp.repaint();
+    }
+
+    @Override
+    public void remove(int index) {
+        Component c = getComponent(index);
+        super.remove(index);
+        if (!(c instanceof JComponent)) {
+            layers.remove(c);
+        }
+    }
+
+    @Override
+    public void removeAll() {
+        super.removeAll();
+        layers.clear();
+    }
+
+    public boolean isOptimizedDrawingEnabled() {
+        return false;
+    }
+
+    /// Records the layer of a component that is not in a layered pane
+    /// yet.
+    public static void putLayer(JComponent c, int layer) {
+        c.putClientProperty(LAYER_PROPERTY, Integer.valueOf(layer));
+    }
+
+    public static int getLayer(JComponent c) {
+        Object i = c.getClientProperty(LAYER_PROPERTY);
+        return i instanceof Integer ? ((Integer) i).intValue() : DEFAULT_LAYER.intValue();
+    }
+
+    public static JLayeredPane getLayeredPaneAbove(Component c) {
+        if (c == null) {
+            return null;
+        }
+        for (Container p = c.getParent(); p != null; p = p.getParent()) {
+            if (p instanceof JLayeredPane) {
+                return (JLayeredPane) p;
+            }
+        }
+        return null;
+    }
+
+    public void setLayer(Component c, int layer) {
+        setLayer(c, layer, -1);
+    }
+
+    public void setLayer(Component c, int layer, int position) {
+        if (c.getParent() == this && layer == getLayer(c) && position == getPosition(c)) {
+            return;
+        }
+        if (c instanceof JComponent) {
+            ((JComponent) c).putClientProperty(LAYER_PROPERTY, Integer.valueOf(layer));
+        } else {
+            layers.put(c, Integer.valueOf(layer));
+        }
+        if (c.getParent() != this) {
+            return;
+        }
+        setComponentZOrder(c, insertIndexForLayer(c, layer, position));
+        repaint();
+    }
+
+    public int getLayer(Component c) {
+        Object i = c instanceof JComponent ? ((JComponent) c).getClientProperty(LAYER_PROPERTY) : layers.get(c);
+        return i instanceof Integer ? ((Integer) i).intValue() : DEFAULT_LAYER.intValue();
+    }
+
+    public int getIndexOf(Component c) {
+        return getComponentZOrder(c);
+    }
+
+    public void moveToFront(Component c) {
+        setPosition(c, 0);
+    }
+
+    public void moveToBack(Component c) {
+        setPosition(c, -1);
+    }
+
+    public void setPosition(Component c, int position) {
+        setLayer(c, getLayer(c), position);
+    }
+
+    /// The position of the component within its layer, 0 being on top;
+    /// -1 when it is not a child.
+    public int getPosition(Component c) {
+        int index = getIndexOf(c);
+        if (index < 0) {
+            return -1;
+        }
+        int layer = getLayer(c);
+        int pos = 0;
+        for (int i = index - 1; i >= 0; i--) {
+            if (getLayer(getComponent(i)) == layer) {
+                pos++;
+            } else {
+                break;
+            }
+        }
+        return pos;
+    }
+
+    public int highestLayer() {
+        return getComponentCount() > 0 ? getLayer(getComponent(0)) : 0;
+    }
+
+    public int lowestLayer() {
+        int n = getComponentCount();
+        return n > 0 ? getLayer(getComponent(n - 1)) : 0;
+    }
+
+    public int getComponentCountInLayer(int layer) {
+        int count = 0;
+        for (int i = 0; i < getComponentCount(); i++) {
+            if (getLayer(getComponent(i)) == layer) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public Component[] getComponentsInLayer(int layer) {
+        ArrayList<Component> l = new ArrayList<Component>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (getLayer(c) == layer) {
+                l.add(c);
+            }
+        }
+        return l.toArray(new Component[l.size()]);
+    }
+
+    protected int insertIndexForLayer(int layer, int position) {
+        return insertIndexForLayer(null, layer, position);
+    }
+
+    /// The child index that puts a component at `position` of `layer`,
+    /// counting the children without `comp` itself.
+    private int insertIndexForLayer(Component comp, int layer, int position) {
+        ArrayList<Component> list = new ArrayList<Component>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c != comp) {
+                list.add(c);
+            }
+        }
+        int n = list.size();
+        int start = -1;
+        int end = -1;
+        for (int i = 0; i < n; i++) {
+            int cur = getLayer(list.get(i));
+            if (start == -1 && cur == layer) {
+                start = i;
+            }
+            if (cur < layer) {
+                if (i == 0) {
+                    start = 0;
+                }
+                end = i;
+                break;
+            }
+        }
+        if (start == -1 && end == -1) {
+            return n;
+        }
+        if (end == -1) {
+            end = n;
+        }
+        if (start == -1) {
+            start = end;
+        }
+        if (position > -1 && start + position <= end) {
+            return start + position;
+        }
+        return end;
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",layers";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JList.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JList.java
new file mode 100644
index 00000000000..c06cf109dba
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JList.java
@@ -0,0 +1,1022 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ListDataEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListDataListener;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+/// A list of rows, each painted by a cell renderer.
+///
+/// ## How the rows are painted
+///
+/// The list draws itself: for every row in the clip it asks the renderer
+/// for a component, gives it the bounds of the row and paints it there, as
+/// the desktop does. The renderer's component is never added to the list,
+/// so any component works, including one that draws in `paintComponent`.
+///
+/// ## What differs from the desktop
+///
+/// A row is selected by a click, not by the press that starts it, because
+/// on a touch screen a press is also how a scroll begins.
+///
+/// ## Layout orientations
+///
+/// `VERTICAL` is one column of rows, each as high as its renderer asks.
+/// The two wrapping orientations are a grid of cells of one size, the
+/// widest by the highest of the renderer's sizes or the fixed cell size:
+/// `HORIZONTAL_WRAP` fills a row and goes on in the next, `VERTICAL_WRAP`
+/// fills a column and goes on in the next. A visible row count above zero
+/// is the number of rows of the grid; with zero or less the grid takes as
+/// many columns (or rows) as the list's width (or height) holds, and a
+/// scroll pane then scrolls it only the other way. Left and right move
+/// the selection by a column in a grid, up and down by a row.
+public class JList<E> extends JComponent implements Accessible, Scrollable {
+
+    public static final int VERTICAL = 0;
+
+    public static final int VERTICAL_WRAP = 1;
+
+    public static final int HORIZONTAL_WRAP = 2;
+
+    private ListModel<E> dataModel;
+    private ListSelectionModel selectionModel;
+    private ListCellRenderer<? super E> cellRenderer = new DefaultListCellRenderer.UIResource();
+    private final ArrayList<ListSelectionListener> selectionListeners = new ArrayList<ListSelectionListener>();
+    private int fixedCellWidth = -1;
+    private int fixedCellHeight = -1;
+    private int visibleRowCount = 8;
+    private int layoutOrientation = VERTICAL;
+    private E prototypeCellValue;
+    private Color selectionForeground;
+    private Color selectionBackground;
+
+    /// The top of every row and, last, the bottom of the list; `null` when
+    /// the rows have to be measured again.
+    private int[] rowTops;
+    private int cellWidth;
+    /// The height of the highest row, the height of a cell of the grid.
+    private int cellHeight;
+
+    private final ListDataListener dataHandler = new ListDataListener() {
+        @Override
+        public void intervalAdded(ListDataEvent e) {
+            int min = e.getIndex0();
+            int max = e.getIndex1();
+            if (min >= 0 && max >= min) {
+                selectionModel.insertIndexInterval(min, max - min + 1, true);
+            }
+            cn1RowsChanged();
+        }
+
+        @Override
+        public void intervalRemoved(ListDataEvent e) {
+            if (e.getIndex0() >= 0) {
+                selectionModel.removeIndexInterval(e.getIndex0(), e.getIndex1());
+            }
+            cn1RowsChanged();
+        }
+
+        @Override
+        public void contentsChanged(ListDataEvent e) {
+            cn1RowsChanged();
+        }
+    };
+
+    private final ListSelectionListener selectionHandler = new ListSelectionListener() {
+        @Override
+        public void valueChanged(ListSelectionEvent e) {
+            fireSelectionValueChanged(e.getFirstIndex(), e.getLastIndex(), e.getValueIsAdjusting());
+            repaint();
+        }
+    };
+
+    public JList(ListModel<E> dataModel) {
+        if (dataModel == null) {
+            throw new IllegalArgumentException("dataModel must be non null");
+        }
+        this.dataModel = dataModel;
+        dataModel.addListDataListener(dataHandler);
+        selectionModel = createSelectionModel();
+        selectionModel.addListSelectionListener(selectionHandler);
+        setOpaque(true);
+        Color bg = UIManager.getColor("List.background");
+        setBackground(bg == null ? Color.WHITE : bg);
+        Color fg = UIManager.getColor("List.foreground");
+        setForeground(fg == null ? Color.BLACK : fg);
+        Color sb = UIManager.cn1PutColor("List.selectionBackground");
+        selectionBackground = sb == null ? new Color(0x38, 0x75, 0xd7) : sb;
+        Color sf = UIManager.cn1PutColor("List.selectionForeground");
+        selectionForeground = sf == null ? Color.WHITE : sf;
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK);
+        bind(KeyEvent.VK_UP, "selectPreviousRow", Move.PREVIOUS);
+        bind(KeyEvent.VK_DOWN, "selectNextRow", Move.NEXT);
+        bind(KeyEvent.VK_HOME, "selectFirstRow", Move.FIRST);
+        bind(KeyEvent.VK_END, "selectLastRow", Move.LAST);
+        bind(KeyEvent.VK_PAGE_UP, "scrollUp", Move.PAGE_UP);
+        bind(KeyEvent.VK_PAGE_DOWN, "scrollDown", Move.PAGE_DOWN);
+        bind(KeyEvent.VK_LEFT, "selectPreviousColumn", Move.LEFT);
+        bind(KeyEvent.VK_RIGHT, "selectNextColumn", Move.RIGHT);
+    }
+
+    private void bind(int key, String name, int kind) {
+        getInputMap(WHEN_FOCUSED).put(KeyStroke.getKeyStroke(key, 0), name);
+        getActionMap().put(name, new Move(this, kind));
+    }
+
+    /// Moves the selection with the keyboard: one row, one page, or to
+    /// either end. The bindings are in the input map under the names the
+    /// desktop uses (`selectNextRow` and so on).
+    private static final class Move extends AbstractAction {
+
+        static final int PREVIOUS = 0;
+        static final int NEXT = 1;
+        static final int FIRST = 2;
+        static final int LAST = 3;
+        static final int PAGE_UP = 4;
+        static final int PAGE_DOWN = 5;
+        static final int LEFT = 6;
+        static final int RIGHT = 7;
+
+        private final JList<?> list;
+        private final int kind;
+
+        Move(JList<?> list, int kind) {
+            this.list = list;
+            this.kind = kind;
+        }
+
+        @Override
+        public void actionPerformed(com.codename1.desktopcompat.java.awt.event.ActionEvent e) {
+            int n = list.getModel().getSize();
+            if (n == 0) {
+                return;
+            }
+            int lead = list.getLeadSelectionIndex();
+            int page = Math.max(1, list.getLastVisibleIndex() - list.getFirstVisibleIndex());
+            // In a grid one step up or down, or left or right, is this
+            // many indices; in a column there are no steps sideways.
+            int[] grid = list.cn1Wrapped() ? list.grid() : null;
+            int down = grid == null ? 1 : list.getLayoutOrientation() == HORIZONTAL_WRAP ? grid[1] : 1;
+            int across = grid == null ? 0 : list.getLayoutOrientation() == HORIZONTAL_WRAP ? 1 : grid[0];
+            int to;
+            switch (kind) {
+                case PREVIOUS:
+                    to = lead < 0 ? n - 1 : lead - down < 0 ? lead : lead - down;
+                    break;
+                case NEXT:
+                    to = lead < 0 ? 0 : lead + down >= n ? lead : lead + down;
+                    break;
+                case LEFT:
+                    if (across == 0) {
+                        return;
+                    }
+                    to = lead < 0 ? 0 : lead - across < 0 ? lead : lead - across;
+                    break;
+                case RIGHT:
+                    if (across == 0) {
+                        return;
+                    }
+                    to = lead < 0 ? 0 : lead + across >= n ? lead : lead + across;
+                    break;
+                case FIRST:
+                    to = 0;
+                    break;
+                case LAST:
+                    to = n - 1;
+                    break;
+                case PAGE_UP:
+                    to = lead < 0 ? 0 : lead - page;
+                    break;
+                default:
+                    to = lead < 0 ? 0 : lead + page;
+                    break;
+            }
+            to = Math.max(0, Math.min(n - 1, to));
+            list.setSelectedIndex(to);
+            list.ensureIndexIsVisible(to);
+        }
+    }
+
+    public JList(final E[] listData) {
+        this(new AbstractListModel<E>() {
+            @Override
+            public int getSize() {
+                return listData.length;
+            }
+
+            @Override
+            public E getElementAt(int i) {
+                return listData[i];
+            }
+        });
+    }
+
+    public JList(final Vector<? extends E> listData) {
+        this(new AbstractListModel<E>() {
+            @Override
+            public int getSize() {
+                return listData.size();
+            }
+
+            @Override
+            public E getElementAt(int i) {
+                return listData.elementAt(i);
+            }
+        });
+    }
+
+    public JList() {
+        this(new AbstractListModel<E>() {
+            @Override
+            public int getSize() {
+                return 0;
+            }
+
+            @Override
+            public E getElementAt(int i) {
+                throw new IndexOutOfBoundsException("No Data Model");
+            }
+        });
+    }
+
+    // ------------------------------------------------------------ model
+
+    public ListModel<E> getModel() {
+        return dataModel;
+    }
+
+    public void setModel(ListModel<E> model) {
+        if (model == null) {
+            throw new IllegalArgumentException("model must be non null");
+        }
+        ListModel<E> old = dataModel;
+        old.removeListDataListener(dataHandler);
+        dataModel = model;
+        model.addListDataListener(dataHandler);
+        clearSelection();
+        firePropertyChange("model", old, model);
+        cn1RowsChanged();
+    }
+
+    public void setListData(final E[] listData) {
+        setModel(new AbstractListModel<E>() {
+            @Override
+            public int getSize() {
+                return listData.length;
+            }
+
+            @Override
+            public E getElementAt(int i) {
+                return listData[i];
+            }
+        });
+    }
+
+    public void setListData(final Vector<? extends E> listData) {
+        setModel(new AbstractListModel<E>() {
+            @Override
+            public int getSize() {
+                return listData.size();
+            }
+
+            @Override
+            public E getElementAt(int i) {
+                return listData.elementAt(i);
+            }
+        });
+    }
+
+    // ------------------------------------------------------------ rendering
+
+    public ListCellRenderer<? super E> getCellRenderer() {
+        return cellRenderer;
+    }
+
+    public void setCellRenderer(ListCellRenderer<? super E> cellRenderer) {
+        ListCellRenderer<? super E> old = this.cellRenderer;
+        this.cellRenderer = cellRenderer;
+        if (prototypeCellValue != null) {
+            cn1MeasurePrototype();
+        }
+        firePropertyChange("cellRenderer", old, cellRenderer);
+        cn1RowsChanged();
+    }
+
+    public E getPrototypeCellValue() {
+        return prototypeCellValue;
+    }
+
+    /// Measures the renderer once with this value and uses the result as
+    /// the fixed width and height of every cell.
+    public void setPrototypeCellValue(E prototypeCellValue) {
+        E old = this.prototypeCellValue;
+        this.prototypeCellValue = prototypeCellValue;
+        if (prototypeCellValue != null) {
+            cn1MeasurePrototype();
+        }
+        firePropertyChange("prototypeCellValue", old, prototypeCellValue);
+        cn1RowsChanged();
+    }
+
+    private void cn1MeasurePrototype() {
+        if (cellRenderer == null) {
+            return;
+        }
+        Component c = cellRenderer.getListCellRendererComponent(this, prototypeCellValue, 0, false, false);
+        Dimension d = c.getPreferredSize();
+        fixedCellWidth = d.width;
+        fixedCellHeight = d.height;
+    }
+
+    public int getFixedCellWidth() {
+        return fixedCellWidth;
+    }
+
+    public void setFixedCellWidth(int width) {
+        int old = fixedCellWidth;
+        fixedCellWidth = width;
+        firePropertyChange("fixedCellWidth", old, width);
+        cn1RowsChanged();
+    }
+
+    public int getFixedCellHeight() {
+        return fixedCellHeight;
+    }
+
+    public void setFixedCellHeight(int height) {
+        int old = fixedCellHeight;
+        fixedCellHeight = height;
+        firePropertyChange("fixedCellHeight", old, height);
+        cn1RowsChanged();
+    }
+
+    public int getVisibleRowCount() {
+        return visibleRowCount;
+    }
+
+    public void setVisibleRowCount(int visibleRowCount) {
+        int old = this.visibleRowCount;
+        this.visibleRowCount = Math.max(0, visibleRowCount);
+        firePropertyChange("visibleRowCount", old, visibleRowCount);
+        revalidate();
+    }
+
+    public int getLayoutOrientation() {
+        return layoutOrientation;
+    }
+
+    public void setLayoutOrientation(int layoutOrientation) {
+        if (layoutOrientation != VERTICAL && layoutOrientation != VERTICAL_WRAP
+                && layoutOrientation != HORIZONTAL_WRAP) {
+            throw new IllegalArgumentException("layoutOrientation must be one of: VERTICAL, HORIZONTAL_WRAP or VERTICAL_WRAP");
+        }
+        int old = this.layoutOrientation;
+        this.layoutOrientation = layoutOrientation;
+        firePropertyChange("layoutOrientation", old, layoutOrientation);
+        if (old != layoutOrientation) {
+            cn1RowsChanged();
+        }
+    }
+
+    public Color getSelectionForeground() {
+        return selectionForeground;
+    }
+
+    public void setSelectionForeground(Color selectionForeground) {
+        Color old = this.selectionForeground;
+        this.selectionForeground = selectionForeground;
+        firePropertyChange("selectionForeground", old, selectionForeground);
+        repaint();
+    }
+
+    public Color getSelectionBackground() {
+        return selectionBackground;
+    }
+
+    public void setSelectionBackground(Color selectionBackground) {
+        Color old = this.selectionBackground;
+        this.selectionBackground = selectionBackground;
+        firePropertyChange("selectionBackground", old, selectionBackground);
+        repaint();
+    }
+
+    // ------------------------------------------------------------ geometry
+
+    private void cn1RowsChanged() {
+        rowTops = null;
+        revalidate();
+        repaint();
+    }
+
+    /// Measures the rows if something changed since they were measured.
+    private int[] rows() {
+        if (rowTops != null) {
+            return rowTops;
+        }
+        int n = dataModel.getSize();
+        int[] tops = new int[n + 1];
+        int widest = 0;
+        int highest = 0;
+        boolean measure = fixedCellHeight <= 0 || fixedCellWidth <= 0;
+        int y = 0;
+        for (int i = 0; i < n; i++) {
+            tops[i] = y;
+            int h = fixedCellHeight;
+            if (measure && cellRenderer != null) {
+                Component c = cellRenderer.getListCellRendererComponent(this, dataModel.getElementAt(i), i, false,
+                        false);
+                Dimension d = c.getPreferredSize();
+                widest = Math.max(widest, d.width);
+                if (fixedCellHeight <= 0) {
+                    h = d.height;
+                }
+            }
+            y += Math.max(0, h);
+            highest = Math.max(highest, h);
+        }
+        tops[n] = y;
+        cellWidth = fixedCellWidth > 0 ? fixedCellWidth : widest;
+        cellHeight = fixedCellHeight > 0 ? fixedCellHeight : highest;
+        rowTops = tops;
+        return tops;
+    }
+
+    /// Whether the cells are laid out as a grid.
+    boolean cn1Wrapped() {
+        return layoutOrientation != VERTICAL;
+    }
+
+    /// The grid of a wrapping orientation: the rows in a column, then the
+    /// columns. The desktop's rule: a visible row count above zero is the
+    /// number of rows, and the columns follow from the number of cells;
+    /// otherwise the list's own width or height says how many fit.
+    int[] grid() {
+        rows();
+        int n = dataModel.getSize();
+        Insets in = getInsets();
+        int rowsPer;
+        int cols;
+        if (visibleRowCount > 0) {
+            rowsPer = visibleRowCount;
+            cols = Math.max(1, n / rowsPer);
+            if (n > rowsPer && n % rowsPer != 0) {
+                cols++;
+            }
+            if (layoutOrientation == HORIZONTAL_WRAP) {
+                rowsPer = n / cols;
+                if (n % cols > 0) {
+                    rowsPer++;
+                }
+            }
+        } else if (layoutOrientation == HORIZONTAL_WRAP) {
+            cols = Math.max(1, (getWidth() - in.left - in.right) / Math.max(1, cellWidth));
+            rowsPer = n / cols;
+            if (n % cols > 0) {
+                rowsPer++;
+            }
+        } else {
+            rowsPer = Math.max(1, (getHeight() - in.top - in.bottom) / Math.max(1, cellHeight));
+            cols = n / rowsPer;
+            if (n % rowsPer > 0) {
+                cols++;
+            }
+        }
+        return new int[]{Math.max(1, rowsPer), Math.max(1, cols)};
+    }
+
+    /// The bounds of one cell of the grid.
+    private Rectangle gridCell(int index, int[] grid) {
+        Insets in = getInsets();
+        int row;
+        int col;
+        if (layoutOrientation == HORIZONTAL_WRAP) {
+            row = index / grid[1];
+            col = index % grid[1];
+        } else {
+            col = index / grid[0];
+            row = index % grid[0];
+        }
+        return new Rectangle(in.left + col * cellWidth, in.top + row * cellHeight, cellWidth, cellHeight);
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        int[] tops = rows();
+        Insets in = getInsets();
+        if (cn1Wrapped()) {
+            if (tops.length == 1) {
+                return new Dimension(in.left + in.right, in.top + in.bottom);
+            }
+            int[] grid = grid();
+            return new Dimension(grid[1] * cellWidth + in.left + in.right,
+                    grid[0] * cellHeight + in.top + in.bottom);
+        }
+        return new Dimension(cellWidth + in.left + in.right, tops[tops.length - 1] + in.top + in.bottom);
+    }
+
+    /// The row at a point of the list, or the nearest one; `-1` only when
+    /// the list is empty.
+    public int locationToIndex(Point location) {
+        int[] tops = rows();
+        int n = tops.length - 1;
+        if (n == 0) {
+            return -1;
+        }
+        if (cn1Wrapped()) {
+            int[] grid = grid();
+            Insets in = getInsets();
+            int col = Math.max(0, Math.min(grid[1] - 1, (location.x - in.left) / Math.max(1, cellWidth)));
+            int row = Math.max(0, (location.y - in.top) / Math.max(1, cellHeight));
+            // The desktop's rule: below the last row of a grid filled row
+            // by row is the last cell, while a grid filled column by
+            // column answers the last row of the column under the point.
+            if (layoutOrientation == HORIZONTAL_WRAP) {
+                return Math.min(n - 1, Math.min(row, n - 1) * grid[1] + col);
+            }
+            return Math.min(n - 1, col * grid[0] + Math.min(row, grid[0] - 1));
+        }
+        int y = location.y - getInsets().top;
+        if (y < 0) {
+            return 0;
+        }
+        for (int i = 0; i < n; i++) {
+            if (y < tops[i + 1]) {
+                return i;
+            }
+        }
+        return n - 1;
+    }
+
+    public Point indexToLocation(int index) {
+        Rectangle r = getCellBounds(index, index);
+        return r == null ? null : new Point(r.x, r.y);
+    }
+
+    /// The bounds of the rows from one index to the other, whichever is
+    /// the smaller; `null` when either is not a row.
+    public Rectangle getCellBounds(int index0, int index1) {
+        int[] tops = rows();
+        int n = tops.length - 1;
+        int min = Math.min(index0, index1);
+        int max = Math.max(index0, index1);
+        if (min < 0 || max >= n) {
+            return null;
+        }
+        if (cn1Wrapped()) {
+            int[] grid = grid();
+            Rectangle a = gridCell(min, grid);
+            return min == max ? a : a.union(gridCell(max, grid));
+        }
+        Insets in = getInsets();
+        int w = Math.max(cellWidth, getWidth() - in.left - in.right);
+        return new Rectangle(in.left, in.top + tops[min], w, tops[max + 1] - tops[min]);
+    }
+
+    private Rectangle cn1VisibleRect() {
+        Container p = getParent();
+        if (p instanceof JViewport) {
+            return ((JViewport) p).getViewRect();
+        }
+        return new Rectangle(0, 0, getWidth(), getHeight());
+    }
+
+    public int getFirstVisibleIndex() {
+        Rectangle r = cn1VisibleRect();
+        int first = locationToIndex(new Point(r.x, r.y));
+        if (first >= 0) {
+            Rectangle b = getCellBounds(first, first);
+            if (b == null || !b.intersects(r)) {
+                return -1;
+            }
+        }
+        return first;
+    }
+
+    public int getLastVisibleIndex() {
+        Rectangle r = cn1VisibleRect();
+        int last = locationToIndex(new Point(r.x + r.width - 1, r.y + r.height - 1));
+        if (last >= 0) {
+            Rectangle b = getCellBounds(last, last);
+            if (b == null || !b.intersects(r)) {
+                return -1;
+            }
+        }
+        return last;
+    }
+
+    public void ensureIndexIsVisible(int index) {
+        Rectangle r = getCellBounds(index, index);
+        if (r != null) {
+            scrollRectToVisible(r);
+        }
+    }
+
+    /// Asks the viewport this list is in, if any, to show `r`.
+    public void scrollRectToVisible(Rectangle r) {
+        JViewport.cn1ScrollRectToVisible(this, r);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        int w = getWidth();
+        int h = getHeight();
+        Color bg = getBackground();
+        if (isOpaque() && bg != null) {
+            g.setColor(bg);
+            g.fillRect(0, 0, w, h);
+        }
+        if (cellRenderer == null) {
+            return;
+        }
+        int[] tops = rows();
+        int n = Math.min(tops.length - 1, dataModel.getSize());
+        Insets in = getInsets();
+        int cw = w - in.left - in.right;
+        Rectangle clip = g.getClipBounds();
+        int lead = selectionModel.getLeadSelectionIndex();
+        boolean focused = hasFocus();
+        int[] grid = cn1Wrapped() ? grid() : null;
+        int x = in.left;
+        for (int i = 0; i < n; i++) {
+            int y = in.top + tops[i];
+            int ch = tops[i + 1] - tops[i];
+            if (grid != null) {
+                Rectangle cell = gridCell(i, grid);
+                x = cell.x;
+                y = cell.y;
+                cw = cell.width;
+                ch = cell.height;
+                if (clip != null && !clip.intersects(cell)) {
+                    continue;
+                }
+            } else if (clip != null) {
+                if (y + ch <= clip.y) {
+                    continue;
+                }
+                if (y >= clip.y + clip.height) {
+                    break;
+                }
+            }
+            if (ch <= 0 || cw <= 0) {
+                continue;
+            }
+            Component c = cellRenderer.getListCellRendererComponent(this, dataModel.getElementAt(i), i,
+                    selectionModel.isSelectedIndex(i), focused && i == lead);
+            if (c == null) {
+                continue;
+            }
+            c.setBounds(x, y, cw, ch);
+            c.validate();
+            Graphics cg = g.create(x, y, cw, ch);
+            try {
+                c.paint(cg);
+            } finally {
+                cg.dispose();
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ input
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        if (e.getID() == MouseEvent.MOUSE_PRESSED && isEnabled()) {
+            requestFocusInWindow();
+            int index = locationToIndex(e.getPoint());
+            if (index >= 0) {
+                int anchor = selectionModel.getAnchorSelectionIndex();
+                if (e.isControlDown() || e.isMetaDown()) {
+                    if (selectionModel.isSelectedIndex(index)) {
+                        selectionModel.removeSelectionInterval(index, index);
+                    } else {
+                        selectionModel.addSelectionInterval(index, index);
+                    }
+                } else if (e.isShiftDown() && anchor >= 0) {
+                    selectionModel.setSelectionInterval(anchor, index);
+                } else {
+                    selectionModel.setSelectionInterval(index, index);
+                }
+            }
+        }
+        super.processMouseEvent(e);
+    }
+
+    // ------------------------------------------------------------ selection
+
+    protected ListSelectionModel createSelectionModel() {
+        return new DefaultListSelectionModel();
+    }
+
+    public ListSelectionModel getSelectionModel() {
+        return selectionModel;
+    }
+
+    public void setSelectionModel(ListSelectionModel selectionModel) {
+        if (selectionModel == null) {
+            throw new IllegalArgumentException("selectionModel must be non null");
+        }
+        ListSelectionModel old = this.selectionModel;
+        old.removeListSelectionListener(selectionHandler);
+        this.selectionModel = selectionModel;
+        selectionModel.addListSelectionListener(selectionHandler);
+        firePropertyChange("selectionModel", old, selectionModel);
+        repaint();
+    }
+
+    /// Tells the listeners of the list, with the list as the source.
+    protected void fireSelectionValueChanged(int firstIndex, int lastIndex, boolean isAdjusting) {
+        if (selectionListeners.isEmpty()) {
+            return;
+        }
+        ListSelectionEvent e = new ListSelectionEvent(this, firstIndex, lastIndex, isAdjusting);
+        ListSelectionListener[] all = getListSelectionListeners();
+        for (int i = all.length - 1; i >= 0; i--) {
+            all[i].valueChanged(e);
+        }
+    }
+
+    public void addListSelectionListener(ListSelectionListener listener) {
+        if (listener != null) {
+            selectionListeners.add(listener);
+        }
+    }
+
+    public void removeListSelectionListener(ListSelectionListener listener) {
+        int i = selectionListeners.lastIndexOf(listener);
+        if (i >= 0) {
+            selectionListeners.remove(i);
+        }
+    }
+
+    public ListSelectionListener[] getListSelectionListeners() {
+        return selectionListeners.toArray(new ListSelectionListener[selectionListeners.size()]);
+    }
+
+    public void setSelectionMode(int selectionMode) {
+        selectionModel.setSelectionMode(selectionMode);
+    }
+
+    public int getSelectionMode() {
+        return selectionModel.getSelectionMode();
+    }
+
+    public int getAnchorSelectionIndex() {
+        return selectionModel.getAnchorSelectionIndex();
+    }
+
+    public int getLeadSelectionIndex() {
+        return selectionModel.getLeadSelectionIndex();
+    }
+
+    public int getMinSelectionIndex() {
+        return selectionModel.getMinSelectionIndex();
+    }
+
+    public int getMaxSelectionIndex() {
+        return selectionModel.getMaxSelectionIndex();
+    }
+
+    public boolean isSelectedIndex(int index) {
+        return selectionModel.isSelectedIndex(index);
+    }
+
+    public boolean isSelectionEmpty() {
+        return selectionModel.isSelectionEmpty();
+    }
+
+    public void clearSelection() {
+        selectionModel.clearSelection();
+    }
+
+    public void setSelectionInterval(int anchor, int lead) {
+        selectionModel.setSelectionInterval(anchor, lead);
+    }
+
+    public void addSelectionInterval(int anchor, int lead) {
+        selectionModel.addSelectionInterval(anchor, lead);
+    }
+
+    public void removeSelectionInterval(int index0, int index1) {
+        selectionModel.removeSelectionInterval(index0, index1);
+    }
+
+    public void setValueIsAdjusting(boolean b) {
+        selectionModel.setValueIsAdjusting(b);
+    }
+
+    public boolean getValueIsAdjusting() {
+        return selectionModel.getValueIsAdjusting();
+    }
+
+    public int[] getSelectedIndices() {
+        int min = selectionModel.getMinSelectionIndex();
+        int max = selectionModel.getMaxSelectionIndex();
+        if (min < 0 || max < 0) {
+            return new int[0];
+        }
+        int[] tmp = new int[1 + (max - min)];
+        int n = 0;
+        for (int i = min; i <= max; i++) {
+            if (selectionModel.isSelectedIndex(i)) {
+                tmp[n++] = i;
+            }
+        }
+        int[] rv = new int[n];
+        System.arraycopy(tmp, 0, rv, 0, n);
+        return rv;
+    }
+
+    public void setSelectedIndex(int index) {
+        if (index >= dataModel.getSize()) {
+            return;
+        }
+        selectionModel.setSelectionInterval(index, index);
+    }
+
+    public void setSelectedIndices(int[] indices) {
+        selectionModel.clearSelection();
+        int size = dataModel.getSize();
+        for (int i = 0; i < indices.length; i++) {
+            if (indices[i] < size) {
+                selectionModel.addSelectionInterval(indices[i], indices[i]);
+            }
+        }
+    }
+
+    /// The selected values as an array; [#getSelectedValuesList()] is the
+    /// typed form.
+    public Object[] getSelectedValues() {
+        List<E> all = getSelectedValuesList();
+        return all.toArray(new Object[all.size()]);
+    }
+
+    public List<E> getSelectedValuesList() {
+        ArrayList<E> out = new ArrayList<E>();
+        int[] indices = getSelectedIndices();
+        int size = dataModel.getSize();
+        for (int i = 0; i < indices.length; i++) {
+            if (indices[i] < size) {
+                out.add(dataModel.getElementAt(indices[i]));
+            }
+        }
+        return out;
+    }
+
+    public int getSelectedIndex() {
+        return getMinSelectionIndex();
+    }
+
+    public E getSelectedValue() {
+        int i = getMinSelectionIndex();
+        return i == -1 || i >= dataModel.getSize() ? null : dataModel.getElementAt(i);
+    }
+
+    public void setSelectedValue(Object anObject, boolean shouldScroll) {
+        if (anObject == null) {
+            setSelectedIndex(-1);
+        } else if (!anObject.equals(getSelectedValue())) {
+            int n = dataModel.getSize();
+            for (int i = 0; i < n; i++) {
+                if (anObject.equals(dataModel.getElementAt(i))) {
+                    setSelectedIndex(i);
+                    if (shouldScroll) {
+                        ensureIndexIsVisible(i);
+                    }
+                    repaint();
+                    return;
+                }
+            }
+            setSelectedIndex(-1);
+        }
+        repaint();
+    }
+
+    // ------------------------------------------------------------ scrolling
+
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        Insets in = getInsets();
+        int dx = in.left + in.right;
+        int dy = in.top + in.bottom;
+        int[] tops = rows();
+        int n = tops.length - 1;
+        if (cn1Wrapped()) {
+            // The whole grid when the row count fixes it; else one cell,
+            // and the list grows the way it does not track.
+            if (visibleRowCount > 0) {
+                return getPreferredSize();
+            }
+            return new Dimension((n == 0 && fixedCellWidth <= 0 ? 256 : cellWidth) + dx,
+                    (n == 0 && fixedCellHeight <= 0 ? 16 : cellHeight) + dy);
+        }
+        int width = n == 0 && fixedCellWidth <= 0 ? 256 : cellWidth;
+        int rowHeight;
+        if (fixedCellHeight > 0) {
+            rowHeight = fixedCellHeight;
+        } else if (n > 0) {
+            rowHeight = tops[1] - tops[0];
+        } else {
+            rowHeight = 16;
+        }
+        return new Dimension(width + dx, visibleRowCount * rowHeight + dy);
+    }
+
+    @Override
+    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+        if (orientation != SwingConstants.VERTICAL) {
+            return cn1Wrapped() && cellWidth > 0 ? cellWidth : 10;
+        }
+        int row = locationToIndex(new Point(visibleRect.x, visibleRect.y));
+        Rectangle r = row < 0 ? null : getCellBounds(row, row);
+        if (r == null) {
+            return 0;
+        }
+        if (direction > 0) {
+            return r.height - (visibleRect.y - r.y);
+        }
+        if (r.y == visibleRect.y) {
+            Rectangle prev = row == 0 ? null : getCellBounds(row - 1, row - 1);
+            return prev == null ? 0 : prev.height;
+        }
+        return visibleRect.y - r.y;
+    }
+
+    @Override
+    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
+        return orientation == SwingConstants.VERTICAL ? Math.max(1, visibleRect.height)
+                : Math.max(1, visibleRect.width);
+    }
+
+    /// A list narrower than its viewport is stretched to fill it.
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        if (layoutOrientation == HORIZONTAL_WRAP && visibleRowCount <= 0) {
+            return true;
+        }
+        Container p = getParent();
+        return p instanceof JViewport && p.getWidth() > getPreferredSize().width;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportHeight() {
+        if (layoutOrientation == VERTICAL_WRAP && visibleRowCount <= 0) {
+            return true;
+        }
+        Container p = getParent();
+        return p instanceof JViewport && p.getHeight() > getPreferredSize().height;
+    }
+
+    // ------------------------------------------------------------ drag
+
+    /// Records whether dragging out of the component is wanted. The layer
+    /// starts no drag of its own, so this is a property and nothing more.
+    public void setDragEnabled(boolean b) {
+        cn1DragEnabled = b;
+    }
+
+    public boolean getDragEnabled() {
+        return cn1DragEnabled;
+    }
+
+    private boolean cn1DragEnabled;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenu.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenu.java
new file mode 100644
index 00000000000..2c7411ac143
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenu.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.event.MenuEvent;
+import com.codename1.desktopcompat.javax.swing.event.MenuListener;
+import com.codename1.desktopcompat.rt.MenuBridge;
+import java.util.ArrayList;
+
+/// A menu: an item that opens a popup menu of further items.
+///
+/// Drawn in a window -- in a menu bar that is a component, or as a
+/// submenu in a popup -- a click opens the popup below a top level menu
+/// and beside a submenu, and a second click closes it. In the menu bar of
+/// a frame the menu is not drawn: its items become commands under its
+/// name.
+public class JMenu extends JMenuItem {
+
+    private JPopupMenu popupMenu;
+    private int delay;
+
+    public JMenu() {
+        this("");
+    }
+
+    public JMenu(String s) {
+        super(s);
+    }
+
+    public JMenu(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JMenu(String s, boolean b) {
+        this(s);
+    }
+
+    private JPopupMenu ensurePopupMenu() {
+        if (popupMenu == null) {
+            popupMenu = new JPopupMenu();
+            popupMenu.setInvoker(this);
+        }
+        return popupMenu;
+    }
+
+    public JPopupMenu getPopupMenu() {
+        return ensurePopupMenu();
+    }
+
+    public boolean isPopupMenuVisible() {
+        return popupMenu != null && popupMenu.isVisible();
+    }
+
+    public void setPopupMenuVisible(boolean b) {
+        if (b == isPopupMenuVisible()) {
+            return;
+        }
+        if (b) {
+            if (!isShowing() || !isEnabled()) {
+                return;
+            }
+            MenuSelectionManager.defaultManager().cn1CloseOthers(this);
+            if (isTopLevelMenu()) {
+                ensurePopupMenu().show(this, 0, getHeight());
+            } else {
+                ensurePopupMenu().show(this, getWidth(), 0);
+            }
+            if (isPopupMenuVisible()) {
+                getModel().setSelected(true);
+                fireMenuSelected();
+            }
+        } else {
+            popupMenu.setVisible(false);
+        }
+    }
+
+    /// The popup of this menu closed.
+    void cn1PopupClosed() {
+        getModel().setSelected(false);
+        fireMenuDeselected();
+    }
+
+    /// Opens or closes the popup; a menu has no action of its own.
+    @Override
+    public void doClick(int pressTime) {
+        setPopupMenuVisible(!isPopupMenuVisible());
+    }
+
+    public boolean isTopLevelMenu() {
+        return getParent() instanceof JMenuBar;
+    }
+
+    public int getDelay() {
+        return delay;
+    }
+
+    /// Recorded only: popups open at once.
+    public void setDelay(int d) {
+        if (d < 0) {
+            throw new IllegalArgumentException("Delay must be a positive integer");
+        }
+        delay = d;
+    }
+
+    public JMenuItem add(JMenuItem menuItem) {
+        ensurePopupMenu().add(menuItem);
+        return menuItem;
+    }
+
+    @Override
+    public Component add(Component c) {
+        ensurePopupMenu().add(c);
+        return c;
+    }
+
+    @Override
+    public Component add(Component c, int index) {
+        ensurePopupMenu().add(c, index);
+        return c;
+    }
+
+    public JMenuItem add(String s) {
+        return add(new JMenuItem(s));
+    }
+
+    public JMenuItem add(Action a) {
+        JMenuItem mi = createActionComponent(a);
+        mi.setAction(a);
+        add(mi);
+        return mi;
+    }
+
+    protected JMenuItem createActionComponent(Action a) {
+        return new JMenuItem();
+    }
+
+    public void addSeparator() {
+        ensurePopupMenu().addSeparator();
+    }
+
+    public void insert(String s, int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        ensurePopupMenu().insert(new JMenuItem(s), pos);
+    }
+
+    public JMenuItem insert(JMenuItem mi, int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        ensurePopupMenu().insert(mi, pos);
+        return mi;
+    }
+
+    public JMenuItem insert(Action a, int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        JMenuItem mi = new JMenuItem(a);
+        ensurePopupMenu().insert(mi, pos);
+        return mi;
+    }
+
+    public void insertSeparator(int index) {
+        if (index < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        ensurePopupMenu().insert(new JPopupMenu.Separator(), index);
+    }
+
+    public JMenuItem getItem(int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        Component c = getMenuComponent(pos);
+        return c instanceof JMenuItem ? (JMenuItem) c : null;
+    }
+
+    public int getItemCount() {
+        return getMenuComponentCount();
+    }
+
+    public boolean isTearOff() {
+        throw new Error("boolean isTearOff() {} not yet implemented");
+    }
+
+    public void remove(JMenuItem item) {
+        if (popupMenu != null) {
+            popupMenu.remove(item);
+        }
+    }
+
+    @Override
+    public void remove(int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        if (pos > getItemCount()) {
+            throw new IllegalArgumentException("index greater than the number of items.");
+        }
+        if (popupMenu != null) {
+            popupMenu.remove(pos);
+        }
+    }
+
+    @Override
+    public void remove(Component c) {
+        if (popupMenu != null) {
+            popupMenu.remove(c);
+        }
+    }
+
+    @Override
+    public void removeAll() {
+        if (popupMenu != null) {
+            popupMenu.removeAll();
+        }
+    }
+
+    public int getMenuComponentCount() {
+        return popupMenu == null ? 0 : popupMenu.getComponentCount();
+    }
+
+    public Component getMenuComponent(int n) {
+        return popupMenu == null ? null : popupMenu.getComponent(n);
+    }
+
+    public Component[] getMenuComponents() {
+        return popupMenu == null ? new Component[0] : popupMenu.getComponents();
+    }
+
+    public boolean isMenuComponent(Component c) {
+        if (c == this) {
+            return true;
+        }
+        Component[] cs = getMenuComponents();
+        for (int i = 0; i < cs.length; i++) {
+            if (cs[i] == c || (cs[i] instanceof JMenu && ((JMenu) cs[i]).isMenuComponent(c))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// A menu has no accelerator.
+    @Override
+    public void setAccelerator(KeyStroke keyStroke) {
+        throw new Error("setAccelerator() is not defined for JMenu.  Use setMnemonic() instead.");
+    }
+
+    public void addMenuListener(MenuListener l) {
+        listenerList.add(MenuListener.class, l);
+    }
+
+    public void removeMenuListener(MenuListener l) {
+        listenerList.remove(MenuListener.class, l);
+    }
+
+    public MenuListener[] getMenuListeners() {
+        return listenerList.getListeners(MenuListener.class);
+    }
+
+    protected void fireMenuSelected() {
+        MenuListener[] ls = getMenuListeners();
+        MenuEvent e = ls.length == 0 ? null : new MenuEvent(this);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].menuSelected(e);
+        }
+    }
+
+    protected void fireMenuDeselected() {
+        MenuListener[] ls = getMenuListeners();
+        MenuEvent e = ls.length == 0 ? null : new MenuEvent(this);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].menuDeselected(e);
+        }
+    }
+
+    protected void fireMenuCanceled() {
+        MenuListener[] ls = getMenuListeners();
+        MenuEvent e = ls.length == 0 ? null : new MenuEvent(this);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].menuCanceled(e);
+        }
+    }
+
+    @Override
+    public void menuSelectionChanged(boolean isIncluded) {
+        setSelected(isIncluded);
+    }
+
+    @Override
+    public MenuElement[] getSubElements() {
+        return popupMenu == null ? new MenuElement[0] : new MenuElement[]{popupMenu};
+    }
+
+    @Override
+    public Component getComponent() {
+        return this;
+    }
+
+    @Override
+    public void setText(String text) {
+        super.setText(text);
+        MenuBridge.changed(this);
+    }
+
+    /// The items of this menu and its submenus, in order.
+    void cn1Items(ArrayList<JMenuItem> out) {
+        Component[] cs = getMenuComponents();
+        for (int i = 0; i < cs.length; i++) {
+            if (cs[i] instanceof JMenu) {
+                ((JMenu) cs[i]).cn1Items(out);
+            } else if (cs[i] instanceof JMenuItem) {
+                out.add((JMenuItem) cs[i]);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenuBar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenuBar.java
new file mode 100644
index 00000000000..69f4bdbe221
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenuBar.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.rt.MenuBridge;
+import com.codename1.desktopcompat.rt.WindowHost;
+import java.util.ArrayList;
+
+/// A row of menus.
+///
+/// Set on a frame with `setJMenuBar` it is not drawn: the frame's host
+/// shows its items as Codename One commands, which reach the native menu
+/// bar on the desktop ports and the overflow menu elsewhere; see
+/// [com.codename1.desktopcompat.rt.MenuBridge]. Added to a container like
+/// any component, or set on a dialog that floats over a form, it is a row
+/// of menus that open popups.
+///
+/// The accelerators of its items work while its window is the focused
+/// one, drawn or not.
+public class JMenuBar extends JComponent implements Accessible, MenuElement {
+
+    private boolean paintBorder = true;
+    private Insets margin;
+
+    public JMenuBar() {
+        setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
+        setFocusable(false);
+    }
+
+    public JMenu add(JMenu c) {
+        super.add(c);
+        return c;
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        super.addImpl(comp, constraints, index);
+        MenuBridge.changed(this);
+    }
+
+    @Override
+    public void remove(int index) {
+        super.remove(index);
+        MenuBridge.changed(this);
+    }
+
+    public JMenu getMenu(int index) {
+        Component c = getComponent(index);
+        return c instanceof JMenu ? (JMenu) c : null;
+    }
+
+    public int getMenuCount() {
+        return getComponentCount();
+    }
+
+    public void setHelpMenu(JMenu menu) {
+        throw new Error("setHelpMenu() not yet implemented.");
+    }
+
+    public JMenu getHelpMenu() {
+        throw new Error("getHelpMenu() not yet implemented.");
+    }
+
+    public int getComponentIndex(Component c) {
+        return getComponentZOrder(c);
+    }
+
+    public void setSelected(Component sel) {
+        if (sel instanceof JMenu) {
+            ((JMenu) sel).setPopupMenuVisible(true);
+        }
+    }
+
+    public boolean isSelected() {
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c instanceof JMenu && ((JMenu) c).isPopupMenuVisible()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean isBorderPainted() {
+        return paintBorder;
+    }
+
+    public void setBorderPainted(boolean b) {
+        paintBorder = b;
+        repaint();
+    }
+
+    public void setMargin(Insets m) {
+        margin = m == null ? null : new Insets(m.top, m.left, m.bottom, m.right);
+        revalidate();
+    }
+
+    public Insets getMargin() {
+        return margin == null ? new Insets(0, 0, 0, 0) : new Insets(margin.top, margin.left, margin.bottom,
+                margin.right);
+    }
+
+    /// Whether the host of the window this bar is the menu bar of shows
+    /// it as commands, so that it takes no room in the window.
+    public boolean cn1Bridged() {
+        JRootPane root = SwingUtilities.getRootPane(this);
+        if (root == null || root.getJMenuBar() != this) {
+            return false;
+        }
+        Window w = SwingUtilities.getWindowAncestor(root);
+        WindowHost h = w == null ? null : w.cn1Host();
+        return h != null && h.takesCommands();
+    }
+
+    /// The items of every menu and submenu, in order.
+    public JMenuItem[] cn1Items() {
+        ArrayList<JMenuItem> out = new ArrayList<JMenuItem>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c instanceof JMenu) {
+                ((JMenu) c).cn1Items(out);
+            } else if (c instanceof JMenuItem) {
+                out.add((JMenuItem) c);
+            }
+        }
+        return out.toArray(new JMenuItem[out.size()]);
+    }
+
+    /// Runs the first enabled item whose accelerator is the key stroke.
+    @Override
+    protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed) {
+        if (super.processKeyBinding(ks, e, condition, pressed)) {
+            return true;
+        }
+        if (condition != WHEN_IN_FOCUSED_WINDOW) {
+            return false;
+        }
+        JMenuItem[] items = cn1Items();
+        for (int i = 0; i < items.length; i++) {
+            if (ks.equals(items[i].getAccelerator()) && items[i].isEnabled()) {
+                items[i].cn1Choose();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void processMouseEvent(MouseEvent event, MenuElement[] path, MenuSelectionManager manager) {
+    }
+
+    @Override
+    public void processKeyEvent(KeyEvent e, MenuElement[] path, MenuSelectionManager manager) {
+    }
+
+    @Override
+    public void menuSelectionChanged(boolean isIncluded) {
+    }
+
+    @Override
+    public MenuElement[] getSubElements() {
+        ArrayList<MenuElement> l = new ArrayList<MenuElement>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c instanceof MenuElement) {
+                l.add((MenuElement) c);
+            }
+        }
+        return l.toArray(new MenuElement[l.size()]);
+    }
+
+    @Override
+    public Component getComponent() {
+        return this;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenuItem.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenuItem.java
new file mode 100644
index 00000000000..d5f4eab5d7a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JMenuItem.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.rt.MenuBridge;
+import com.codename1.desktopcompat.rt.MenuItemPeer;
+
+/// An item of a menu.
+///
+/// In a popup menu it is a Codename One button without a frame; in the
+/// menu bar of a frame it is a Codename One command, see
+/// [com.codename1.desktopcompat.rt.MenuBridge]. Either way choosing it
+/// closes the open popups and runs `doClick()`.
+///
+/// An item made from an action follows it: the action's name, icon,
+/// enabled state and accelerator are the item's, and stay so when the
+/// action changes. The accelerator works while the item is in the menu
+/// bar of the focused window. The mnemonic is recorded only.
+public class JMenuItem extends AbstractButton implements Accessible, MenuElement {
+
+    private KeyStroke accelerator;
+    private PropertyChangeListener actionFollower;
+    private long lastChosen;
+
+    public JMenuItem() {
+        this(null, (Icon) null);
+    }
+
+    public JMenuItem(Icon icon) {
+        this(null, icon);
+    }
+
+    public JMenuItem(String text) {
+        this(text, (Icon) null);
+    }
+
+    public JMenuItem(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JMenuItem(String text, Icon icon) {
+        setModel(new DefaultButtonModel());
+        init(text, icon);
+        outOfTheFocus();
+    }
+
+    public JMenuItem(String text, int mnemonic) {
+        setModel(new DefaultButtonModel());
+        init(text, null);
+        setMnemonic(mnemonic);
+        outOfTheFocus();
+    }
+
+    /// A menu and its items are not part of the keyboard focus, as in
+    /// Swing, where a menu item is made not focusable: the focus stays
+    /// with the component that had it while a menu is open. The widget
+    /// that draws an item would take it otherwise, and the window of an
+    /// application opened with the last menu of its bar drawn as chosen,
+    /// since the form gave its first focus to it.
+    private void outOfTheFocus() {
+        setFocusable(false);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new MenuItemPeer(this);
+    }
+
+    public KeyStroke getAccelerator() {
+        return accelerator;
+    }
+
+    public void setAccelerator(KeyStroke keyStroke) {
+        KeyStroke old = accelerator;
+        accelerator = keyStroke;
+        firePropertyChange("accelerator", old, keyStroke);
+        MenuBridge.changed(this);
+    }
+
+    public boolean isArmed() {
+        return getModel().isArmed();
+    }
+
+    public void setArmed(boolean b) {
+        getModel().setArmed(b);
+    }
+
+    /// Closes the open popup menus, then clicks.
+    @Override
+    public void doClick(int pressTime) {
+        MenuSelectionManager.defaultManager().clearSelectedPath();
+        super.doClick(pressTime);
+    }
+
+    /// Chooses the item on behalf of a command or an accelerator.
+    ///
+    /// On a desktop port the same key press can arrive twice, once
+    /// through the native menu's shortcut and once as a key event; two
+    /// calls within a quarter of a second count as one.
+    public void cn1Choose() {
+        long now = System.currentTimeMillis();
+        if (!isEnabled() || (now - lastChosen >= 0 && now - lastChosen < 250)) {
+            return;
+        }
+        lastChosen = now;
+        doClick();
+    }
+
+    @Override
+    public void setText(String text) {
+        super.setText(text);
+        MenuBridge.changed(this);
+    }
+
+    @Override
+    public void setIcon(Icon defaultIcon) {
+        super.setIcon(defaultIcon);
+        MenuBridge.changed(this);
+    }
+
+    @Override
+    public void setEnabled(boolean b) {
+        boolean old = isEnabled();
+        super.setEnabled(b);
+        if (old != b) {
+            MenuBridge.changed(this);
+        }
+    }
+
+    @Override
+    public void setVisible(boolean b) {
+        boolean old = isVisible();
+        super.setVisible(b);
+        if (old != b) {
+            MenuBridge.changed(this);
+        }
+    }
+
+    @Override
+    protected void fireItemStateChanged(ItemEvent event) {
+        super.fireItemStateChanged(event);
+        MenuBridge.changed(this);
+    }
+
+    /// Takes the action's name, icon, enabled state, command and
+    /// accelerator, makes it an action listener, and follows its later
+    /// changes.
+    @Override
+    public void setAction(Action a) {
+        Action old = getAction();
+        if (old != null && actionFollower != null) {
+            old.removePropertyChangeListener(actionFollower);
+        }
+        super.setAction(a);
+        if (a != null) {
+            Object icon = a.getValue(Action.SMALL_ICON);
+            if (icon instanceof Icon) {
+                setIcon((Icon) icon);
+            }
+            Object ks = a.getValue(Action.ACCELERATOR_KEY);
+            if (ks instanceof KeyStroke) {
+                setAccelerator((KeyStroke) ks);
+            }
+            if (actionFollower == null) {
+                actionFollower = new ActionFollower(this);
+            }
+            a.addPropertyChangeListener(actionFollower);
+        }
+    }
+
+    @Override
+    public void processMouseEvent(MouseEvent event, MenuElement[] path, MenuSelectionManager manager) {
+    }
+
+    @Override
+    public void processKeyEvent(KeyEvent event, MenuElement[] path, MenuSelectionManager manager) {
+    }
+
+    @Override
+    public void menuSelectionChanged(boolean isIncluded) {
+        setArmed(isIncluded);
+    }
+
+    @Override
+    public MenuElement[] getSubElements() {
+        return new MenuElement[0];
+    }
+
+    @Override
+    public Component getComponent() {
+        return this;
+    }
+
+    /// Copies an action's changes to the item made from it.
+    private static final class ActionFollower implements PropertyChangeListener {
+
+        private final JMenuItem item;
+
+        ActionFollower(JMenuItem item) {
+            this.item = item;
+        }
+
+        @Override
+        public void propertyChange(PropertyChangeEvent evt) {
+            String name = evt.getPropertyName();
+            Object v = evt.getNewValue();
+            if ("enabled".equals(name)) {
+                item.setEnabled(Boolean.TRUE.equals(v));
+            } else if (Action.NAME.equals(name)) {
+                item.setText(v instanceof String ? (String) v : "");
+            } else if (Action.SMALL_ICON.equals(name)) {
+                item.setIcon(v instanceof Icon ? (Icon) v : null);
+            } else if (Action.ACCELERATOR_KEY.equals(name)) {
+                item.setAccelerator(v instanceof KeyStroke ? (KeyStroke) v : null);
+            } else if (Action.ACTION_COMMAND_KEY.equals(name)) {
+                item.setActionCommand(v instanceof String ? (String) v : null);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JOptionPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JOptionPane.java
new file mode 100644
index 00000000000..48e16d2257b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JOptionPane.java
@@ -0,0 +1,673 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.WindowAdapter;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+
+/// `javax.swing.JOptionPane`: the standard message, confirmation, input
+/// and option dialogs.
+///
+/// Every `show...Dialog` method blocks its caller until the user answered,
+/// as on the desktop, while events keep running. On a phone the dialog
+/// floats over the current form at its packed size.
+///
+/// The pane lays itself out when [#createDialog(Component, String)] is
+/// called: the message to the right of the icon of the message type, the
+/// text field or the combo box of an input dialog below the message, and a
+/// row of buttons at the bottom. A set of selection values is always
+/// offered in a combo box, however many there are. The internal-frame
+/// variants are not provided.
+public class JOptionPane extends JComponent implements Accessible {
+
+    public static final Object UNINITIALIZED_VALUE = "uninitializedValue";
+
+    public static final int DEFAULT_OPTION = -1;
+    public static final int YES_NO_OPTION = 0;
+    public static final int YES_NO_CANCEL_OPTION = 1;
+    public static final int OK_CANCEL_OPTION = 2;
+
+    public static final int YES_OPTION = 0;
+    public static final int NO_OPTION = 1;
+    public static final int CANCEL_OPTION = 2;
+    public static final int OK_OPTION = 0;
+    public static final int CLOSED_OPTION = -1;
+
+    public static final int ERROR_MESSAGE = 0;
+    public static final int INFORMATION_MESSAGE = 1;
+    public static final int WARNING_MESSAGE = 2;
+    public static final int QUESTION_MESSAGE = 3;
+    public static final int PLAIN_MESSAGE = -1;
+
+    public static final String ICON_PROPERTY = "icon";
+    public static final String MESSAGE_PROPERTY = "message";
+    public static final String VALUE_PROPERTY = "value";
+    public static final String OPTIONS_PROPERTY = "options";
+    public static final String INITIAL_VALUE_PROPERTY = "initialValue";
+    public static final String MESSAGE_TYPE_PROPERTY = "messageType";
+    public static final String OPTION_TYPE_PROPERTY = "optionType";
+    public static final String SELECTION_VALUES_PROPERTY = "selectionValues";
+    public static final String INITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";
+    public static final String INPUT_VALUE_PROPERTY = "inputValue";
+    public static final String WANTS_INPUT_PROPERTY = "wantsInput";
+
+    private static Frame rootFrame;
+
+    protected Icon icon;
+    protected Object message;
+    protected Object[] options;
+    protected Object initialValue;
+    protected int messageType;
+    protected int optionType;
+    protected Object value;
+    protected Object[] selectionValues;
+    protected Object inputValue;
+    protected Object initialSelectionValue;
+    protected boolean wantsInput;
+
+    private JDialog shownIn;
+    private JButton defaultChoice;
+    private Component initialFocus;
+    private JTextField inputField;
+    private JComboBox<Object> inputChoice;
+
+    public JOptionPane() {
+        this("JOptionPane message");
+    }
+
+    public JOptionPane(Object message) {
+        this(message, PLAIN_MESSAGE);
+    }
+
+    public JOptionPane(Object message, int messageType) {
+        this(message, messageType, DEFAULT_OPTION);
+    }
+
+    public JOptionPane(Object message, int messageType, int optionType) {
+        this(message, messageType, optionType, null);
+    }
+
+    public JOptionPane(Object message, int messageType, int optionType, Icon icon) {
+        this(message, messageType, optionType, icon, null);
+    }
+
+    public JOptionPane(Object message, int messageType, int optionType, Icon icon, Object[] options) {
+        this(message, messageType, optionType, icon, options, null);
+    }
+
+    public JOptionPane(Object message, int messageType, int optionType, Icon icon, Object[] options,
+            Object initialValue) {
+        this.message = message;
+        this.options = options == null ? null : copy(options);
+        this.initialValue = initialValue;
+        this.icon = icon;
+        this.messageType = messageType;
+        this.optionType = optionType;
+        this.value = UNINITIALIZED_VALUE;
+        this.inputValue = UNINITIALIZED_VALUE;
+    }
+
+    /// Identity, not equality: the sentinel is one particular object,
+    /// and a value that merely reads the same is an answer.
+    private static boolean same(Object a, Object b) {
+        return a == b;
+    }
+
+    private static Object[] copy(Object[] a) {
+        Object[] r = new Object[a.length];
+        System.arraycopy(a, 0, r, 0, a.length);
+        return r;
+    }
+
+    private static String text(String key, String fallback) {
+        String s = UIManager.getString(key);
+        return s == null ? fallback : s;
+    }
+
+    // ---- the static dialogs ----
+
+    public static String showInputDialog(Object message) {
+        return showInputDialog(null, message);
+    }
+
+    public static String showInputDialog(Object message, Object initialSelectionValue) {
+        return showInputDialog(null, message, initialSelectionValue);
+    }
+
+    public static String showInputDialog(Component parentComponent, Object message) {
+        return showInputDialog(parentComponent, message, text("OptionPane.inputDialogTitle", "Input"),
+                QUESTION_MESSAGE);
+    }
+
+    public static String showInputDialog(Component parentComponent, Object message, Object initialSelectionValue) {
+        Object v = showInputDialog(parentComponent, message, text("OptionPane.inputDialogTitle", "Input"),
+                QUESTION_MESSAGE, null, null, initialSelectionValue);
+        return v instanceof String ? (String) v : null;
+    }
+
+    public static String showInputDialog(Component parentComponent, Object message, String title, int messageType) {
+        Object v = showInputDialog(parentComponent, message, title, messageType, null, null, null);
+        return v instanceof String ? (String) v : null;
+    }
+
+    public static Object showInputDialog(Component parentComponent, Object message, String title, int messageType,
+            Icon icon, Object[] selectionValues, Object initialSelectionValue) {
+        JOptionPane pane = new JOptionPane(message, messageType, OK_CANCEL_OPTION, icon, null, null);
+        pane.setWantsInput(true);
+        pane.setSelectionValues(selectionValues);
+        pane.setInitialSelectionValue(initialSelectionValue);
+        JDialog dialog = pane.createDialog(parentComponent, title);
+        pane.selectInitialValue();
+        dialog.setVisible(true);
+        dialog.dispose();
+        Object v = pane.getInputValue();
+        return same(v, UNINITIALIZED_VALUE) ? null : v;
+    }
+
+    public static void showMessageDialog(Component parentComponent, Object message) {
+        showMessageDialog(parentComponent, message, text("OptionPane.messageDialogTitle", "Message"),
+                INFORMATION_MESSAGE);
+    }
+
+    public static void showMessageDialog(Component parentComponent, Object message, String title, int messageType) {
+        showMessageDialog(parentComponent, message, title, messageType, null);
+    }
+
+    public static void showMessageDialog(Component parentComponent, Object message, String title, int messageType,
+            Icon icon) {
+        showOptionDialog(parentComponent, message, title, DEFAULT_OPTION, messageType, icon, null, null);
+    }
+
+    public static int showConfirmDialog(Component parentComponent, Object message) {
+        return showConfirmDialog(parentComponent, message, text("OptionPane.titleText", "Select an Option"),
+                YES_NO_CANCEL_OPTION);
+    }
+
+    public static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType) {
+        return showConfirmDialog(parentComponent, message, title, optionType, QUESTION_MESSAGE);
+    }
+
+    public static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType,
+            int messageType) {
+        return showConfirmDialog(parentComponent, message, title, optionType, messageType, null);
+    }
+
+    public static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType,
+            int messageType, Icon icon) {
+        return showOptionDialog(parentComponent, message, title, optionType, messageType, icon, null, null);
+    }
+
+    public static int showOptionDialog(Component parentComponent, Object message, String title, int optionType,
+            int messageType, Icon icon, Object[] options, Object initialValue) {
+        JOptionPane pane = new JOptionPane(message, messageType, optionType, icon, options, initialValue);
+        JDialog dialog = pane.createDialog(parentComponent, title);
+        pane.selectInitialValue();
+        dialog.setVisible(true);
+        dialog.dispose();
+        Object chosen = pane.getValue();
+        if (chosen == null) {
+            return CLOSED_OPTION;
+        }
+        if (options == null) {
+            return chosen instanceof Integer ? ((Integer) chosen).intValue() : CLOSED_OPTION;
+        }
+        for (int i = 0; i < options.length; i++) {
+            if (options[i] != null && options[i].equals(chosen)) {
+                return i;
+            }
+        }
+        return CLOSED_OPTION;
+    }
+
+    public static Frame getFrameForComponent(Component parentComponent) {
+        for (Component c = parentComponent; c != null; c = c.getParent()) {
+            if (c instanceof Frame) {
+                return (Frame) c;
+            }
+        }
+        return getRootFrame();
+    }
+
+    public static void setRootFrame(Frame newRootFrame) {
+        rootFrame = newRootFrame;
+    }
+
+    /// The frame dialogs without a parent belong to. It is never shown.
+    public static Frame getRootFrame() {
+        if (rootFrame == null) {
+            rootFrame = new Frame();
+        }
+        return rootFrame;
+    }
+
+    // ---- the dialog ----
+
+    public JDialog createDialog(String title) {
+        return createDialog(null, title);
+    }
+
+    public JDialog createDialog(Component parentComponent, String title) {
+        Window owner = null;
+        if (parentComponent instanceof Window) {
+            owner = (Window) parentComponent;
+        } else if (parentComponent != null) {
+            owner = SwingUtilities.getWindowAncestor(parentComponent);
+        }
+        shownIn = null;
+        setValue(UNINITIALIZED_VALUE);
+        build();
+        JDialog dialog = new JDialog(owner, title, Dialog.ModalityType.APPLICATION_MODAL);
+        Container content = dialog.getContentPane();
+        content.setLayout(new BorderLayout());
+        content.add(this, BorderLayout.CENTER);
+        dialog.setResizable(false);
+        dialog.getRootPane().setDefaultButton(defaultChoice);
+        dialog.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                setValue(null);
+            }
+        });
+        dialog.pack();
+        dialog.setLocationRelativeTo(parentComponent);
+        shownIn = dialog;
+        return dialog;
+    }
+
+    /// Lays out the message, the input component and the buttons from the
+    /// properties as they are now.
+    private void build() {
+        removeAll();
+        defaultChoice = null;
+        initialFocus = null;
+        inputField = null;
+        inputChoice = null;
+        setLayout(new BorderLayout(10, 10));
+        setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+        Icon shown = icon != null ? icon : typeIcon(messageType);
+        if (shown != null) {
+            JPanel side = new JPanel(new BorderLayout());
+            side.add(new JLabel(shown), BorderLayout.NORTH);
+            add(side, BorderLayout.WEST);
+        }
+        JPanel body = new JPanel();
+        body.setLayout(new BoxLayout(body, BoxLayout.Y_AXIS));
+        addMessage(body, message);
+        if (wantsInput) {
+            if (selectionValues != null) {
+                inputChoice = new JComboBox<Object>(copy(selectionValues));
+                if (initialSelectionValue != null) {
+                    inputChoice.setSelectedItem(initialSelectionValue);
+                }
+                inputChoice.setAlignmentX(0f);
+                body.add(inputChoice);
+                initialFocus = inputChoice;
+            } else {
+                inputField = new JTextField(20);
+                if (initialSelectionValue != null) {
+                    inputField.setText(String.valueOf(initialSelectionValue));
+                }
+                inputField.addActionListener(new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        choose(Integer.valueOf(OK_OPTION));
+                    }
+                });
+                inputField.setAlignmentX(0f);
+                body.add(inputField);
+                initialFocus = inputField;
+            }
+        }
+        add(body, BorderLayout.CENTER);
+        JPanel buttons = new JPanel();
+        if (options != null) {
+            for (int i = 0; i < options.length; i++) {
+                final Object option = options[i];
+                if (option instanceof Component) {
+                    // A component among the options answers by itself,
+                    // calling setValue when it is used.
+                    buttons.add((Component) option);
+                    continue;
+                }
+                JButton b = option instanceof Icon ? new JButton((Icon) option) : new JButton(String.valueOf(option));
+                b.addActionListener(new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        choose(option);
+                    }
+                });
+                buttons.add(b);
+                if (defaultChoice == null && option != null && option.equals(initialValue)) {
+                    defaultChoice = b;
+                }
+            }
+        } else if (optionType == YES_NO_OPTION) {
+            standard(buttons, text("OptionPane.yesButtonText", "Yes"), YES_OPTION);
+            standard(buttons, text("OptionPane.noButtonText", "No"), NO_OPTION);
+        } else if (optionType == YES_NO_CANCEL_OPTION) {
+            standard(buttons, text("OptionPane.yesButtonText", "Yes"), YES_OPTION);
+            standard(buttons, text("OptionPane.noButtonText", "No"), NO_OPTION);
+            standard(buttons, text("OptionPane.cancelButtonText", "Cancel"), CANCEL_OPTION);
+        } else if (optionType == OK_CANCEL_OPTION) {
+            standard(buttons, text("OptionPane.okButtonText", "OK"), OK_OPTION);
+            standard(buttons, text("OptionPane.cancelButtonText", "Cancel"), CANCEL_OPTION);
+        } else {
+            standard(buttons, text("OptionPane.okButtonText", "OK"), OK_OPTION);
+        }
+        add(buttons, BorderLayout.SOUTH);
+    }
+
+    private void standard(JPanel buttons, String label, final int option) {
+        JButton b = new JButton(label);
+        b.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                choose(Integer.valueOf(option));
+            }
+        });
+        buttons.add(b);
+        Integer boxed = Integer.valueOf(option);
+        if (boxed.equals(initialValue) || defaultChoice == null && initialValue == null) {
+            defaultChoice = b;
+        }
+    }
+
+    /// The user picked `choice`: take what was typed or selected when the
+    /// dialog asks for input and it was confirmed, then answer.
+    private void choose(Object choice) {
+        if (wantsInput && options == null) {
+            if (choice instanceof Integer && ((Integer) choice).intValue() == OK_OPTION) {
+                if (inputChoice != null) {
+                    setInputValue(inputChoice.getSelectedItem());
+                } else if (inputField != null) {
+                    setInputValue(inputField.getText());
+                }
+            } else {
+                setInputValue(UNINITIALIZED_VALUE);
+            }
+        }
+        setValue(choice);
+    }
+
+    private static void addMessage(JPanel body, Object msg) {
+        if (msg == null) {
+            return;
+        }
+        if (msg instanceof Component) {
+            if (msg instanceof JComponent) {
+                ((JComponent) msg).setAlignmentX(0f);
+            }
+            body.add((Component) msg);
+        } else if (msg instanceof Object[]) {
+            Object[] parts = (Object[]) msg;
+            for (int i = 0; i < parts.length; i++) {
+                addMessage(body, parts[i]);
+            }
+        } else if (msg instanceof Icon) {
+            JLabel l = new JLabel((Icon) msg);
+            l.setAlignmentX(0f);
+            body.add(l);
+        } else {
+            String s = String.valueOf(msg);
+            int from = 0;
+            while (from <= s.length()) {
+                int nl = s.indexOf('\n', from);
+                String line = nl < 0 ? s.substring(from) : s.substring(from, nl);
+                JLabel l = new JLabel(line.length() == 0 ? " " : line);
+                l.setAlignmentX(0f);
+                body.add(l);
+                if (nl < 0) {
+                    break;
+                }
+                from = nl + 1;
+            }
+        }
+    }
+
+    private static Icon typeIcon(int type) {
+        String key;
+        switch (type) {
+            case ERROR_MESSAGE:
+                key = "OptionPane.errorIcon";
+                break;
+            case INFORMATION_MESSAGE:
+                key = "OptionPane.informationIcon";
+                break;
+            case WARNING_MESSAGE:
+                key = "OptionPane.warningIcon";
+                break;
+            case QUESTION_MESSAGE:
+                key = "OptionPane.questionIcon";
+                break;
+            default:
+                return null;
+        }
+        Icon i = UIManager.getIcon(key);
+        return i != null ? i : new TypeIcon(type);
+    }
+
+    /// The icon of a message type when the look and feel has none: a
+    /// colored disc with the sign of the type on it.
+    private static final class TypeIcon implements Icon {
+        private static final int SIZE = 32;
+        private final int type;
+
+        TypeIcon(int type) {
+            this.type = type;
+        }
+
+        @Override
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+            String sign;
+            int rgb;
+            if (type == ERROR_MESSAGE) {
+                sign = "x";
+                rgb = 0xC62828;
+            } else if (type == WARNING_MESSAGE) {
+                sign = "!";
+                rgb = 0xEF6C00;
+            } else if (type == QUESTION_MESSAGE) {
+                sign = "?";
+                rgb = 0x2E7D32;
+            } else {
+                sign = "i";
+                rgb = 0x1565C0;
+            }
+            g.setColor(new Color(rgb));
+            g.fillOval(x, y, SIZE, SIZE);
+            g.setColor(new Color(0xFFFFFF));
+            FontMetrics fm = g.getFontMetrics();
+            int w = fm == null ? 0 : fm.stringWidth(sign);
+            int asc = fm == null ? 0 : fm.getAscent();
+            int desc = fm == null ? 0 : fm.getDescent();
+            g.drawString(sign, x + (SIZE - w) / 2, y + (SIZE + asc - desc) / 2);
+        }
+
+        @Override
+        public int getIconWidth() {
+            return SIZE;
+        }
+
+        @Override
+        public int getIconHeight() {
+            return SIZE;
+        }
+    }
+
+    // ---- properties ----
+
+    public void setMessage(Object newMessage) {
+        Object old = message;
+        message = newMessage;
+        firePropertyChange(MESSAGE_PROPERTY, old, message);
+    }
+
+    public Object getMessage() {
+        return message;
+    }
+
+    public void setIcon(Icon newIcon) {
+        Icon old = icon;
+        icon = newIcon;
+        firePropertyChange(ICON_PROPERTY, old, icon);
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    /// Sets what the user chose. While the pane's dialog is showing, this
+    /// closes it, which is what lets a blocked caller go on.
+    public void setValue(Object newValue) {
+        Object old = value;
+        value = newValue;
+        firePropertyChange(VALUE_PROPERTY, old, value);
+        JDialog d = shownIn;
+        if (d != null && !same(newValue, UNINITIALIZED_VALUE) && d.isVisible()) {
+            d.setVisible(false);
+        }
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public void setOptions(Object[] newOptions) {
+        Object[] old = options;
+        options = newOptions == null ? null : copy(newOptions);
+        firePropertyChange(OPTIONS_PROPERTY, old, options);
+    }
+
+    public Object[] getOptions() {
+        return options == null ? null : copy(options);
+    }
+
+    public void setInitialValue(Object newInitialValue) {
+        Object old = initialValue;
+        initialValue = newInitialValue;
+        firePropertyChange(INITIAL_VALUE_PROPERTY, old, initialValue);
+    }
+
+    public Object getInitialValue() {
+        return initialValue;
+    }
+
+    public void setMessageType(int newType) {
+        if (newType != ERROR_MESSAGE && newType != INFORMATION_MESSAGE && newType != WARNING_MESSAGE
+                && newType != QUESTION_MESSAGE && newType != PLAIN_MESSAGE) {
+            throw new RuntimeException("JOptionPane: type must be one of JOptionPane.ERROR_MESSAGE, "
+                    + "JOptionPane.INFORMATION_MESSAGE, JOptionPane.WARNING_MESSAGE, "
+                    + "JOptionPane.QUESTION_MESSAGE or JOptionPane.PLAIN_MESSAGE");
+        }
+        int old = messageType;
+        messageType = newType;
+        firePropertyChange(MESSAGE_TYPE_PROPERTY, old, messageType);
+    }
+
+    public int getMessageType() {
+        return messageType;
+    }
+
+    public void setOptionType(int newType) {
+        if (newType != DEFAULT_OPTION && newType != YES_NO_OPTION && newType != YES_NO_CANCEL_OPTION
+                && newType != OK_CANCEL_OPTION) {
+            throw new RuntimeException("JOptionPane: option type must be one of JOptionPane.DEFAULT_OPTION, "
+                    + "JOptionPane.YES_NO_OPTION, JOptionPane.YES_NO_CANCEL_OPTION or "
+                    + "JOptionPane.OK_CANCEL_OPTION");
+        }
+        int old = optionType;
+        optionType = newType;
+        firePropertyChange(OPTION_TYPE_PROPERTY, old, optionType);
+    }
+
+    public int getOptionType() {
+        return optionType;
+    }
+
+    public void setSelectionValues(Object[] newValues) {
+        Object[] old = selectionValues;
+        selectionValues = newValues == null ? null : copy(newValues);
+        firePropertyChange(SELECTION_VALUES_PROPERTY, old, selectionValues);
+        if (selectionValues != null) {
+            setWantsInput(true);
+        }
+    }
+
+    public Object[] getSelectionValues() {
+        return selectionValues == null ? null : copy(selectionValues);
+    }
+
+    public void setInitialSelectionValue(Object newValue) {
+        Object old = initialSelectionValue;
+        initialSelectionValue = newValue;
+        firePropertyChange(INITIAL_SELECTION_VALUE_PROPERTY, old, newValue);
+    }
+
+    public Object getInitialSelectionValue() {
+        return initialSelectionValue;
+    }
+
+    public void setInputValue(Object newValue) {
+        Object old = inputValue;
+        inputValue = newValue;
+        firePropertyChange(INPUT_VALUE_PROPERTY, old, newValue);
+    }
+
+    public Object getInputValue() {
+        return inputValue;
+    }
+
+    public int getMaxCharactersPerLineCount() {
+        return Integer.MAX_VALUE;
+    }
+
+    public void setWantsInput(boolean newValue) {
+        boolean old = wantsInput;
+        wantsInput = newValue;
+        firePropertyChange(WANTS_INPUT_PROPERTY, old, newValue);
+    }
+
+    public boolean getWantsInput() {
+        return wantsInput;
+    }
+
+    /// Gives the focus to the input component, or to the default button.
+    public void selectInitialValue() {
+        Component c = initialFocus != null ? initialFocus : defaultChoice;
+        if (c != null) {
+            c.requestFocusInWindow();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPanel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPanel.java
new file mode 100644
index 00000000000..673c3ad4a84
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPanel.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+
+/// The plain Swing container: opaque, with a flow layout unless told
+/// otherwise. Subclasses paint in `paintComponent`.
+public class JPanel extends JComponent implements Accessible {
+
+    public JPanel(LayoutManager layout, boolean isDoubleBuffered) {
+        setLayout(layout);
+        setOpaque(true);
+    }
+
+    public JPanel(LayoutManager layout) {
+        this(layout, true);
+    }
+
+    public JPanel(boolean isDoubleBuffered) {
+        this(new FlowLayout(), isDoubleBuffered);
+    }
+
+    public JPanel() {
+        this(true);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPasswordField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPasswordField.java
new file mode 100644
index 00000000000..715dff20aa1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPasswordField.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.text.Document;
+
+/// A single line field that hides what is typed, shown by a Codename One
+/// text field in its password mode.
+///
+/// The character the platform masks with is the platform's own; the echo
+/// character set here is recorded, and setting it to 0 shows the text.
+/// Cut and copy do nothing.
+public class JPasswordField extends JTextField {
+
+    private char echoChar = '*';
+    private boolean echoCharSet;
+
+    public JPasswordField() {
+        this(null, null, 0);
+    }
+
+    public JPasswordField(String text) {
+        this(null, text, 0);
+    }
+
+    public JPasswordField(int columns) {
+        this(null, null, columns);
+    }
+
+    public JPasswordField(String text, int columns) {
+        this(null, text, columns);
+    }
+
+    public JPasswordField(Document doc, String txt, int columns) {
+        super(doc, txt, columns);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        applyEcho();
+    }
+
+    private void applyEcho() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.TextArea) {
+            ((com.codename1.ui.TextArea) p).setConstraint(echoChar != 0 ? com.codename1.ui.TextArea.PASSWORD
+                    : com.codename1.ui.TextArea.ANY);
+        }
+    }
+
+    public char getEchoChar() {
+        return echoChar;
+    }
+
+    public void setEchoChar(char c) {
+        echoChar = c;
+        echoCharSet = true;
+        applyEcho();
+        repaint();
+    }
+
+    public boolean echoCharIsSet() {
+        return echoChar != 0;
+    }
+
+    /// The characters typed. The caller may wipe the array; it is a copy.
+    public char[] getPassword() {
+        String s = getText();
+        char[] out = new char[s.length()];
+        s.getChars(0, out.length, out, 0);
+        return out;
+    }
+
+    @Override
+    public void cut() {
+    }
+
+    @Override
+    public void copy() {
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",echoChar=" + (echoCharSet ? String.valueOf(echoChar) : "default");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPopupMenu.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPopupMenu.java
new file mode 100644
index 00000000000..92e4c95de80
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JPopupMenu.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.PopupMenuEvent;
+import com.codename1.desktopcompat.javax.swing.event.PopupMenuListener;
+import com.codename1.desktopcompat.rt.MenuBridge;
+
+/// A menu that pops up over a window.
+///
+/// The popup is a component of the window it opens in: `show` puts it in
+/// the popup layer of that window's layered pane, at the given point of
+/// the invoker, moved as far as needed to stay inside the window. It can
+/// therefore not extend beyond its window, and it needs a Swing window --
+/// one with a root pane -- to open in. A press outside the open popups
+/// closes them and is not delivered; so does the escape key.
+///
+/// Set as the component popup menu of a component it opens on the popup
+/// trigger: a press of the secondary mouse button, or a long press of a
+/// finger.
+public class JPopupMenu extends JComponent implements Accessible, MenuElement {
+
+    private Component invoker;
+    private String label;
+    private boolean showing;
+    private boolean paintBorder = true;
+    private int desiredX;
+    private int desiredY;
+
+    public JPopupMenu() {
+        this(null);
+    }
+
+    public JPopupMenu(String label) {
+        this.label = label;
+        setLayout(new MenuLayout());
+        setOpaque(true);
+        setBorder(BorderFactory.createLineBorder(Color.GRAY));
+    }
+
+    public JMenuItem add(JMenuItem menuItem) {
+        super.add(menuItem);
+        return menuItem;
+    }
+
+    public JMenuItem add(String s) {
+        return add(new JMenuItem(s));
+    }
+
+    public JMenuItem add(Action a) {
+        JMenuItem mi = createActionComponent(a);
+        mi.setAction(a);
+        add(mi);
+        return mi;
+    }
+
+    protected JMenuItem createActionComponent(Action a) {
+        return new JMenuItem();
+    }
+
+    public void addSeparator() {
+        add(new JPopupMenu.Separator());
+    }
+
+    public void insert(Action a, int index) {
+        JMenuItem mi = createActionComponent(a);
+        mi.setAction(a);
+        insert(mi, index);
+    }
+
+    public void insert(Component component, int index) {
+        if (index < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        add(component, Math.min(index, getComponentCount()));
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        super.addImpl(comp, constraints, index);
+        MenuBridge.changed(this);
+    }
+
+    @Override
+    public void remove(int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException("index less than zero.");
+        }
+        if (pos > getComponentCount() - 1) {
+            throw new IllegalArgumentException("index greater than the number of items.");
+        }
+        super.remove(pos);
+        MenuBridge.changed(this);
+    }
+
+    public int getComponentIndex(Component c) {
+        return getComponentZOrder(c);
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        String old = this.label;
+        this.label = label;
+        firePropertyChange("label", old, label);
+    }
+
+    public Component getInvoker() {
+        return invoker;
+    }
+
+    public void setInvoker(Component invoker) {
+        this.invoker = invoker;
+    }
+
+    public boolean isBorderPainted() {
+        return paintBorder;
+    }
+
+    public void setBorderPainted(boolean b) {
+        paintBorder = b;
+        repaint();
+    }
+
+    public Insets getMargin() {
+        return new Insets(0, 0, 0, 0);
+    }
+
+    public boolean isPopupTrigger(MouseEvent e) {
+        return e.isPopupTrigger();
+    }
+
+    public void pack() {
+        if (showing) {
+            Dimension d = getPreferredSize();
+            setSize(d.width, d.height);
+            validate();
+        }
+    }
+
+    public void setPopupSize(Dimension d) {
+        setPreferredSize(d);
+    }
+
+    public void setPopupSize(int width, int height) {
+        setPopupSize(new Dimension(width, height));
+    }
+
+    /// Opens the popup at a point of `invoker`.
+    public void show(Component invoker, int x, int y) {
+        if (showing) {
+            setVisible(false);
+        }
+        setInvoker(invoker);
+        desiredX = x;
+        desiredY = y;
+        setVisible(true);
+    }
+
+    /// Whether the popup is open.
+    @Override
+    public boolean isVisible() {
+        return showing;
+    }
+
+    /// Opens the popup at the point last given to `show`, or closes it.
+    @Override
+    public void setVisible(boolean b) {
+        if (b == showing) {
+            return;
+        }
+        if (b) {
+            JRootPane root = invoker == null ? null : SwingUtilities.getRootPane(invoker);
+            if (root == null) {
+                return;
+            }
+            JLayeredPane lp = root.getLayeredPane();
+            firePopupMenuWillBecomeVisible();
+            showing = true;
+            lp.add(this, JLayeredPane.POPUP_LAYER, 0);
+            Dimension d = getPreferredSize();
+            Point p = SwingUtilities.convertPoint(invoker, desiredX, desiredY, lp);
+            int w = Math.min(d.width, lp.getWidth());
+            int h = Math.min(d.height, lp.getHeight());
+            setBounds(Math.max(0, Math.min(p.x, lp.getWidth() - w)), Math.max(0, Math.min(p.y, lp.getHeight() - h)),
+                    w, h);
+            validate();
+            MenuSelectionManager.defaultManager().cn1Opened(this);
+            lp.repaint();
+        } else {
+            for (int i = 0; i < getComponentCount(); i++) {
+                Component c = getComponent(i);
+                if (c instanceof JMenu) {
+                    ((JMenu) c).setPopupMenuVisible(false);
+                }
+            }
+            firePopupMenuWillBecomeInvisible();
+            showing = false;
+            Container parent = getParent();
+            if (parent != null) {
+                parent.remove(this);
+                parent.repaint();
+            }
+            MenuSelectionManager.defaultManager().cn1Closed(this);
+            if (invoker instanceof JMenu) {
+                ((JMenu) invoker).cn1PopupClosed();
+            }
+        }
+    }
+
+    public void addPopupMenuListener(PopupMenuListener l) {
+        listenerList.add(PopupMenuListener.class, l);
+    }
+
+    public void removePopupMenuListener(PopupMenuListener l) {
+        listenerList.remove(PopupMenuListener.class, l);
+    }
+
+    public PopupMenuListener[] getPopupMenuListeners() {
+        return listenerList.getListeners(PopupMenuListener.class);
+    }
+
+    protected void firePopupMenuWillBecomeVisible() {
+        PopupMenuListener[] ls = getPopupMenuListeners();
+        PopupMenuEvent e = ls.length == 0 ? null : new PopupMenuEvent(this);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].popupMenuWillBecomeVisible(e);
+        }
+    }
+
+    protected void firePopupMenuWillBecomeInvisible() {
+        PopupMenuListener[] ls = getPopupMenuListeners();
+        PopupMenuEvent e = ls.length == 0 ? null : new PopupMenuEvent(this);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].popupMenuWillBecomeInvisible(e);
+        }
+    }
+
+    protected void firePopupMenuCanceled() {
+        PopupMenuListener[] ls = getPopupMenuListeners();
+        PopupMenuEvent e = ls.length == 0 ? null : new PopupMenuEvent(this);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].popupMenuCanceled(e);
+        }
+    }
+
+    @Override
+    public void processMouseEvent(MouseEvent event, MenuElement[] path, MenuSelectionManager manager) {
+    }
+
+    @Override
+    public void processKeyEvent(KeyEvent e, MenuElement[] path, MenuSelectionManager manager) {
+    }
+
+    @Override
+    public void menuSelectionChanged(boolean isIncluded) {
+    }
+
+    @Override
+    public MenuElement[] getSubElements() {
+        java.util.ArrayList<MenuElement> l = new java.util.ArrayList<MenuElement>();
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c instanceof MenuElement) {
+                l.add((MenuElement) c);
+            }
+        }
+        return l.toArray(new MenuElement[l.size()]);
+    }
+
+    @Override
+    public Component getComponent() {
+        return this;
+    }
+
+    /// The line between two groups of items of a popup menu.
+    public static class Separator extends JSeparator {
+
+        public Separator() {
+            super(JSeparator.HORIZONTAL);
+        }
+    }
+
+    /// Stacks the items, each as wide as the widest.
+    private static final class MenuLayout implements LayoutManager {
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            Insets in = parent.getInsets();
+            int w = 0;
+            int h = 0;
+            for (int i = 0; i < parent.getComponentCount(); i++) {
+                Component c = parent.getComponent(i);
+                if (c.isVisible()) {
+                    Dimension d = c.getPreferredSize();
+                    w = Math.max(w, d.width);
+                    h += d.height;
+                }
+            }
+            return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return preferredLayoutSize(parent);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            Insets in = parent.getInsets();
+            int w = parent.getWidth() - in.left - in.right;
+            int y = in.top;
+            for (int i = 0; i < parent.getComponentCount(); i++) {
+                Component c = parent.getComponent(i);
+                if (c.isVisible()) {
+                    int h = c.getPreferredSize().height;
+                    c.setBounds(in.left, y, w, h);
+                    y += h;
+                }
+            }
+        }
+    }
+
+    private static boolean defaultLightWeightPopupEnabled = true;
+    private boolean lightWeightPopup = defaultLightWeightPopupEnabled;
+
+    /// Records whether the popup may be drawn inside its window. It
+    /// always is, see the class description, so this is a hint that is
+    /// kept and changes nothing.
+    public void setLightWeightPopupEnabled(boolean aFlag) {
+        lightWeightPopup = aFlag;
+    }
+
+    public boolean isLightWeightPopupEnabled() {
+        return lightWeightPopup;
+    }
+
+    public static void setDefaultLightWeightPopupEnabled(boolean aFlag) {
+        defaultLightWeightPopupEnabled = aFlag;
+    }
+
+    public static boolean getDefaultLightWeightPopupEnabled() {
+        return defaultLightWeightPopupEnabled;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JProgressBar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JProgressBar.java
new file mode 100644
index 00000000000..d9be2a423a6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JProgressBar.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.ProgressPeer;
+
+/// A progress bar over a bounded range model, shown by a Codename One
+/// slider the user cannot move. An indeterminate bar is that slider in its
+/// infinite mode, which animates by itself. The progress string is drawn
+/// by this class, centred over the bar.
+///
+/// Not supported: the string of a vertical bar is drawn upright, not
+/// rotated; there is no UI delegate, so `getUI` and `setUI` are absent.
+public class JProgressBar extends JComponent implements Accessible, SwingConstants {
+
+    private static final int LENGTH = 146;
+    private static final int MINIMUM_LENGTH = 10;
+    private static final int FALLBACK_THICKNESS = 12;
+
+    protected int orientation;
+    protected boolean paintBorder = true;
+    protected BoundedRangeModel model;
+    protected String progressString;
+    protected boolean paintString;
+    protected ChangeEvent changeEvent;
+    protected ChangeListener changeListener;
+
+    private final ChangeListener bridge = new Bridge();
+    private boolean indeterminate;
+
+    public JProgressBar() {
+        this(HORIZONTAL);
+    }
+
+    public JProgressBar(int orient) {
+        this(orient, 0, 100);
+    }
+
+    public JProgressBar(int min, int max) {
+        this(HORIZONTAL, min, max);
+    }
+
+    public JProgressBar(int orient, int min, int max) {
+        checkOrientation(orient);
+        orientation = orient;
+        model = new DefaultBoundedRangeModel(min, 0, min, max);
+        model.addChangeListener(bridge);
+    }
+
+    public JProgressBar(BoundedRangeModel newModel) {
+        orientation = HORIZONTAL;
+        model = newModel;
+        if (newModel != null) {
+            newModel.addChangeListener(bridge);
+        }
+    }
+
+    private static void checkOrientation(int orientation) {
+        if (orientation != VERTICAL && orientation != HORIZONTAL) {
+            throw new IllegalArgumentException(orientation + " is not a legal orientation");
+        }
+    }
+
+    // ------------------------------------------------------------- peer
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new ProgressPeer(this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        cn1Sync();
+    }
+
+    private void cn1Sync() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!(p instanceof ProgressPeer) || model == null) {
+            return;
+        }
+        ProgressPeer s = (ProgressPeer) p;
+        long span = (long) model.getMaximum() - (long) model.getMinimum();
+        int range = span <= 0 ? 1 : span > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) span;
+        long pos = (long) model.getValue() - (long) model.getMinimum();
+        s.setVertical(orientation == VERTICAL);
+        s.setMinValue(0);
+        s.setMaxValue(range);
+        s.setInfinite(indeterminate);
+        if (!indeterminate) {
+            s.setProgress(pos < 0 ? 0 : pos > range ? range : (int) pos);
+        }
+    }
+
+    private void changed() {
+        cn1Sync();
+        revalidate();
+        repaint();
+    }
+
+    // ------------------------------------------------------------ sizes
+
+    private int thickness() {
+        Dimension d = super.cn1NativePreferredSize();
+        int t = d == null ? FALLBACK_THICKNESS : orientation == VERTICAL ? d.width : d.height;
+        if (paintString) {
+            t = Math.max(t, getFontMetrics(getFont()).getHeight() + 2);
+        }
+        return t;
+    }
+
+    /// The preferred size: 146 logical pixels along the bar, and across it
+    /// what the native bar wants, or the height of the string if that is
+    /// painted and taller.
+    @Override
+    protected Dimension cn1NativePreferredSize() {
+        return orientation == VERTICAL ? new Dimension(thickness(), LENGTH) : new Dimension(LENGTH, thickness());
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return orientation == VERTICAL ? new Dimension(thickness(), MINIMUM_LENGTH)
+                : new Dimension(MINIMUM_LENGTH, thickness());
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (isMaximumSizeSet()) {
+            return super.getMaximumSize();
+        }
+        return orientation == VERTICAL ? new Dimension(thickness(), Short.MAX_VALUE)
+                : new Dimension(Short.MAX_VALUE, thickness());
+    }
+
+    // ------------------------------------------------------------ paint
+
+    /// Paints the native bar and, when the string is painted, the string
+    /// centred over it.
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        if (!paintString) {
+            return;
+        }
+        String s = getString();
+        if (s.length() == 0) {
+            return;
+        }
+        FontMetrics fm = g.getFontMetrics();
+        Color fg = getForeground();
+        g.setColor(fg != null ? fg : Color.BLACK);
+        g.drawString(s, (getWidth() - fm.stringWidth(s)) / 2, (getHeight() - fm.getHeight()) / 2 + fm.getAscent());
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+        if (isBorderPainted()) {
+            super.paintBorder(g);
+        }
+    }
+
+    // ------------------------------------------------------- properties
+
+    public int getOrientation() {
+        return orientation;
+    }
+
+    public void setOrientation(int newOrientation) {
+        if (orientation != newOrientation) {
+            checkOrientation(newOrientation);
+            int old = orientation;
+            orientation = newOrientation;
+            firePropertyChange("orientation", old, newOrientation);
+            changed();
+        }
+    }
+
+    public boolean isStringPainted() {
+        return paintString;
+    }
+
+    public void setStringPainted(boolean b) {
+        boolean old = paintString;
+        paintString = b;
+        firePropertyChange("stringPainted", old, b);
+        if (b != old) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    /// The string set with `setString`, or the progress made as a whole
+    /// percentage, such as `42%`.
+    public String getString() {
+        if (progressString != null) {
+            return progressString;
+        }
+        long span = (long) model.getMaximum() - (long) model.getMinimum();
+        if (span <= 0) {
+            return "0%";
+        }
+        long done = ((long) model.getValue() - (long) model.getMinimum()) * 100;
+        long whole = done / span;
+        long twice = 2 * (done % span);
+        // Half way rounds to the even percentage, as the desktop's percent
+        // format does.
+        if (twice > span || (twice == span && (whole & 1) == 1)) {
+            whole++;
+        }
+        return whole + "%";
+    }
+
+    public void setString(String s) {
+        String old = progressString;
+        progressString = s;
+        firePropertyChange("string", old, s);
+        if (s == null ? old != null : !s.equals(old)) {
+            repaint();
+        }
+    }
+
+    public double getPercentComplete() {
+        long span = (long) model.getMaximum() - (long) model.getMinimum();
+        double currentValue = model.getValue();
+        return (currentValue - model.getMinimum()) / span;
+    }
+
+    public boolean isBorderPainted() {
+        return paintBorder;
+    }
+
+    public void setBorderPainted(boolean b) {
+        boolean old = paintBorder;
+        paintBorder = b;
+        firePropertyChange("borderPainted", old, b);
+        if (b != old) {
+            repaint();
+        }
+    }
+
+    public void setIndeterminate(boolean newValue) {
+        boolean old = indeterminate;
+        indeterminate = newValue;
+        firePropertyChange("indeterminate", old, newValue);
+        if (newValue != old) {
+            cn1Sync();
+            repaint();
+        }
+    }
+
+    public boolean isIndeterminate() {
+        return indeterminate;
+    }
+
+    // ------------------------------------------------------------ model
+
+    /// The listener that turns the model's changes into this bar's.
+    protected ChangeListener createChangeListener() {
+        return new ModelListener();
+    }
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    public BoundedRangeModel getModel() {
+        return model;
+    }
+
+    /// Fires no "model" property change: in the JDK the progress bar's model
+    /// is not a bound property (unlike JSlider's), and its setModel tells
+    /// only the accessibility context.
+    public void setModel(BoundedRangeModel newModel) {
+        BoundedRangeModel old = model;
+        if (newModel != old) {
+            if (old != null) {
+                old.removeChangeListener(bridge);
+            }
+            model = newModel;
+            if (newModel != null) {
+                newModel.addChangeListener(bridge);
+            }
+            if (model != null) {
+                model.setExtent(0);
+            }
+            cn1Sync();
+            repaint();
+        }
+    }
+
+    public int getValue() {
+        return model.getValue();
+    }
+
+    public int getMinimum() {
+        return model.getMinimum();
+    }
+
+    public int getMaximum() {
+        return model.getMaximum();
+    }
+
+    public void setValue(int n) {
+        model.setValue(n);
+    }
+
+    public void setMinimum(int n) {
+        model.setMinimum(n);
+    }
+
+    public void setMaximum(int n) {
+        model.setMaximum(n);
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",orientation=" + (orientation == HORIZONTAL ? "HORIZONTAL" : "VERTICAL")
+                + ",paintBorder=" + paintBorder + ",paintString=" + paintString + ",progressString="
+                + (progressString != null ? progressString : "") + ",indeterminateString=" + indeterminate;
+    }
+
+    /// Listens to the model for as long as it is this bar's, and hands
+    /// what it hears to the listener `createChangeListener` makes.
+    private final class Bridge implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            if (changeListener == null) {
+                changeListener = createChangeListener();
+            }
+            cn1Sync();
+            if (changeListener != null) {
+                changeListener.stateChanged(e);
+            }
+            repaint();
+        }
+    }
+
+    private final class ModelListener implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            fireStateChanged();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRadioButton.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRadioButton.java
new file mode 100644
index 00000000000..609b5f1c44a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRadioButton.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.rt.RadioButtonPeer;
+
+/// A radio button, shown by a Codename One radio button; put several in a
+/// `ButtonGroup` to make them exclusive.
+public class JRadioButton extends JToggleButton {
+
+    public JRadioButton() {
+        this(null, null, false);
+    }
+
+    public JRadioButton(Icon icon) {
+        this(null, icon, false);
+    }
+
+    public JRadioButton(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JRadioButton(Icon icon, boolean selected) {
+        this(null, icon, selected);
+    }
+
+    public JRadioButton(String text) {
+        this(text, null, false);
+    }
+
+    public JRadioButton(String text, boolean selected) {
+        this(text, null, selected);
+    }
+
+    public JRadioButton(String text, Icon icon) {
+        this(text, icon, false);
+    }
+
+    public JRadioButton(String text, Icon icon, boolean selected) {
+        super(text, icon, selected);
+        setBorderPainted(false);
+        setHorizontalAlignment(LEADING);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new RadioButtonPeer(this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRadioButtonMenuItem.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRadioButtonMenuItem.java
new file mode 100644
index 00000000000..55ba5bc0929
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRadioButtonMenuItem.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.rt.RadioButtonPeer;
+
+/// A menu item that is one of a group of which one is selected; put the
+/// items of a group in a `ButtonGroup`. It is a Codename One radio button
+/// in a popup menu, a command whose name carries a mark in a menu bar.
+public class JRadioButtonMenuItem extends JMenuItem {
+
+    public JRadioButtonMenuItem() {
+        this(null, null, false);
+    }
+
+    public JRadioButtonMenuItem(Icon icon) {
+        this(null, icon, false);
+    }
+
+    public JRadioButtonMenuItem(String text) {
+        this(text, null, false);
+    }
+
+    public JRadioButtonMenuItem(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JRadioButtonMenuItem(String text, Icon icon) {
+        this(text, icon, false);
+    }
+
+    public JRadioButtonMenuItem(String text, boolean selected) {
+        this(text, null, selected);
+    }
+
+    public JRadioButtonMenuItem(Icon icon, boolean selected) {
+        this(null, icon, selected);
+    }
+
+    public JRadioButtonMenuItem(String text, Icon icon, boolean selected) {
+        super(text, icon);
+        setModel(new JToggleButton.ToggleButtonModel());
+        setSelected(selected);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new RadioButtonPeer(this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRootPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRootPane.java
new file mode 100644
index 00000000000..e9b7a56e6a7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JRootPane.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.rt.MenuBridge;
+
+/// The single child of a Swing window.
+///
+/// It holds a layered pane, which fills it and carries the menu bar and
+/// the content pane in its lowest layer, and a glass pane over
+/// everything, which is invisible until an application shows it. Popup
+/// menus open in the popup layer of the layered pane.
+///
+/// The default button is clicked by the enter key when no listener and
+/// no key binding used the key. A visible glass pane keeps mouse events
+/// from the components under it; the Codename One widgets under it still
+/// react to the pointer.
+public class JRootPane extends JComponent implements Accessible {
+
+    public static final int NONE = 0;
+    public static final int FRAME = 1;
+    public static final int PLAIN_DIALOG = 2;
+    public static final int INFORMATION_DIALOG = 3;
+    public static final int ERROR_DIALOG = 4;
+    public static final int COLOR_CHOOSER_DIALOG = 5;
+    public static final int FILE_CHOOSER_DIALOG = 6;
+    public static final int QUESTION_DIALOG = 7;
+    public static final int WARNING_DIALOG = 8;
+
+    protected JMenuBar menuBar;
+    protected Container contentPane;
+    protected JLayeredPane layeredPane;
+    protected Component glassPane;
+    protected JButton defaultButton;
+
+    private int windowDecorationStyle;
+
+    public JRootPane() {
+        setGlassPane(createGlassPane());
+        setLayeredPane(createLayeredPane());
+        setContentPane(createContentPane());
+        setLayout(createRootLayout());
+    }
+
+    protected JLayeredPane createLayeredPane() {
+        JLayeredPane p = new JLayeredPane();
+        p.setName(getName() + ".layeredPane");
+        return p;
+    }
+
+    protected Container createContentPane() {
+        JPanel p = new JPanel(new BorderLayout());
+        p.setName(getName() + ".contentPane");
+        return p;
+    }
+
+    protected Component createGlassPane() {
+        JPanel p = new JPanel();
+        p.setName(getName() + ".glassPane");
+        p.setVisible(false);
+        p.setOpaque(false);
+        return p;
+    }
+
+    protected LayoutManager createRootLayout() {
+        return new RootLayout(this);
+    }
+
+    public int getWindowDecorationStyle() {
+        return windowDecorationStyle;
+    }
+
+    /// Recorded only: windows are decorated by their host.
+    public void setWindowDecorationStyle(int windowDecorationStyle) {
+        if (windowDecorationStyle < NONE || windowDecorationStyle > WARNING_DIALOG) {
+            throw new IllegalArgumentException("Invalid decoration style");
+        }
+        this.windowDecorationStyle = windowDecorationStyle;
+    }
+
+    public JMenuBar getJMenuBar() {
+        return menuBar;
+    }
+
+    /// Sets the menu bar of the window.
+    ///
+    /// Where the window's host takes commands -- a frame on any device --
+    /// the menus are not drawn in the window. Every enabled or disabled
+    /// item becomes one Codename One command, see
+    /// [com.codename1.desktopcompat.rt.MenuBridge]. In a dialog that
+    /// floats over a form the menu bar is drawn as a row of menus above
+    /// the content pane.
+    public void setJMenuBar(JMenuBar menu) {
+        if (menuBar != null && menuBar.getParent() == layeredPane) {
+            layeredPane.remove(menuBar);
+        }
+        menuBar = menu;
+        if (menu != null) {
+            layeredPane.add(menu, JLayeredPane.FRAME_CONTENT_LAYER);
+        }
+        MenuBridge.barChanged(this);
+        revalidate();
+    }
+
+    public Container getContentPane() {
+        return contentPane;
+    }
+
+    public void setContentPane(Container content) {
+        if (content == null) {
+            throw new IllegalArgumentException("contentPane cannot be set to null.");
+        }
+        if (contentPane != null && contentPane.getParent() == layeredPane) {
+            layeredPane.remove(contentPane);
+        }
+        contentPane = content;
+        layeredPane.add(content, JLayeredPane.FRAME_CONTENT_LAYER);
+        revalidate();
+    }
+
+    public JLayeredPane getLayeredPane() {
+        return layeredPane;
+    }
+
+    public void setLayeredPane(JLayeredPane layered) {
+        if (layered == null) {
+            throw new IllegalArgumentException("layeredPane cannot be set to null.");
+        }
+        if (layeredPane != null && layeredPane.getParent() == this) {
+            remove(layeredPane);
+        }
+        layeredPane = layered;
+        add(layered, -1);
+    }
+
+    public Component getGlassPane() {
+        return glassPane;
+    }
+
+    public void setGlassPane(Component glass) {
+        if (glass == null) {
+            throw new NullPointerException("glassPane cannot be set to null.");
+        }
+        boolean visible = false;
+        if (glassPane != null && glassPane.getParent() == this) {
+            remove(glassPane);
+            visible = glassPane.isVisible();
+        }
+        glass.setVisible(visible);
+        glassPane = glass;
+        add(glass, 0);
+        if (visible) {
+            repaint();
+        }
+    }
+
+    public JButton getDefaultButton() {
+        return defaultButton;
+    }
+
+    /// Sets the button the enter key clicks.
+    public void setDefaultButton(JButton defaultButton) {
+        JButton old = this.defaultButton;
+        this.defaultButton = defaultButton;
+        firePropertyChange("defaultButton", old, defaultButton);
+    }
+
+    @Override
+    public boolean isValidateRoot() {
+        return true;
+    }
+
+    @Override
+    protected boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed) {
+        if (super.processKeyBinding(ks, e, condition, pressed)) {
+            return true;
+        }
+        if (condition == WHEN_IN_FOCUSED_WINDOW && pressed && e.getID() == KeyEvent.KEY_PRESSED
+                && e.getKeyCode() == KeyEvent.VK_ENTER && e.getModifiersEx() == 0) {
+            JButton b = defaultButton;
+            if (b != null && b.isEnabled() && b.isShowing()) {
+                b.doClick();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The layered pane and the glass pane fill the root pane; the menu
+    /// bar takes its preferred height at the top unless the host shows it
+    /// as commands, and the content pane takes the rest.
+    private static final class RootLayout implements LayoutManager {
+
+        private final JRootPane root;
+
+        RootLayout(JRootPane root) {
+            this.root = root;
+        }
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        private int barHeight() {
+            JMenuBar mb = root.menuBar;
+            if (mb == null || !mb.isVisible() || mb.cn1Bridged()) {
+                return 0;
+            }
+            return mb.getPreferredSize().height;
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            return size(true);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return size(false);
+        }
+
+        private Dimension size(boolean preferred) {
+            Insets in = root.getInsets();
+            Container cp = root.contentPane;
+            Dimension d = cp == null ? new Dimension(0, 0) : preferred ? cp.getPreferredSize() : cp.getMinimumSize();
+            int w = d.width;
+            int h = d.height;
+            int bh = barHeight();
+            if (bh > 0) {
+                w = Math.max(w, root.menuBar.getPreferredSize().width);
+                h += bh;
+            }
+            return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            Insets in = root.getInsets();
+            int w = root.getWidth() - in.left - in.right;
+            int h = root.getHeight() - in.top - in.bottom;
+            if (root.layeredPane != null) {
+                root.layeredPane.setBounds(in.left, in.top, w, h);
+            }
+            if (root.glassPane != null) {
+                root.glassPane.setBounds(in.left, in.top, w, h);
+            }
+            int bh = barHeight();
+            if (root.menuBar != null) {
+                root.menuBar.setBounds(0, 0, bh > 0 ? w : 0, bh);
+            }
+            if (root.contentPane != null) {
+                root.contentPane.setBounds(0, bh, w, Math.max(0, h - bh));
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JScrollBar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JScrollBar.java
new file mode 100644
index 00000000000..96fa41a33e5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JScrollBar.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Adjustable;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.event.AdjustmentEvent;
+import com.codename1.desktopcompat.java.awt.event.AdjustmentListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// A scroll bar over a [BoundedRangeModel].
+///
+/// A track with a thumb, drawn here, that the user drags; a press on the
+/// track moves the value by a block. There are no arrow buttons.
+///
+/// The scroll bars of a [JScrollPane] are these too. A desktop port gives
+/// them room beside the viewport; on a touch device they have no size,
+/// the user scrolls the content itself and Codename One draws its own
+/// scroll indicator, while the bar's model still follows and steers the
+/// view.
+public class JScrollBar extends JComponent implements Accessible, Adjustable {
+
+    private static final int THICKNESS = 12;
+
+    protected BoundedRangeModel model;
+
+    protected int orientation;
+
+    protected int unitIncrement;
+
+    protected int blockIncrement;
+
+    private final ChangeListener forward = new ChangeListener() {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            fireAdjustmentValueChanged(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED, AdjustmentEvent.TRACK,
+                    model.getValue(), model.getValueIsAdjusting());
+            repaint();
+        }
+    };
+    private int dragOffset = -1;
+
+    public JScrollBar(int orientation, int value, int extent, int min, int max) {
+        checkOrientation(orientation);
+        this.unitIncrement = 1;
+        this.blockIncrement = extent == 0 ? 1 : extent;
+        this.orientation = orientation;
+        this.model = new DefaultBoundedRangeModel(value, extent, min, max);
+        this.model.addChangeListener(forward);
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
+    }
+
+    public JScrollBar(int orientation) {
+        this(orientation, 0, 10, 0, 100);
+    }
+
+    public JScrollBar() {
+        this(VERTICAL);
+    }
+
+    private static void checkOrientation(int orientation) {
+        if (orientation != VERTICAL && orientation != HORIZONTAL) {
+            throw new IllegalArgumentException("orientation must be one of: VERTICAL, HORIZONTAL");
+        }
+    }
+
+    @Override
+    public int getOrientation() {
+        return orientation;
+    }
+
+    public void setOrientation(int orientation) {
+        checkOrientation(orientation);
+        int old = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange("orientation", old, orientation);
+        if (old != orientation) {
+            revalidate();
+        }
+    }
+
+    public BoundedRangeModel getModel() {
+        return model;
+    }
+
+    public void setModel(BoundedRangeModel newModel) {
+        BoundedRangeModel old = model;
+        if (old != null) {
+            old.removeChangeListener(forward);
+        }
+        model = newModel;
+        if (newModel != null) {
+            newModel.addChangeListener(forward);
+        }
+        firePropertyChange("model", old, newModel);
+        repaint();
+    }
+
+    public int getUnitIncrement(int direction) {
+        return unitIncrement;
+    }
+
+    @Override
+    public void setUnitIncrement(int unitIncrement) {
+        int old = this.unitIncrement;
+        this.unitIncrement = unitIncrement;
+        firePropertyChange("unitIncrement", old, unitIncrement);
+    }
+
+    public int getBlockIncrement(int direction) {
+        return blockIncrement;
+    }
+
+    @Override
+    public void setBlockIncrement(int blockIncrement) {
+        int old = this.blockIncrement;
+        this.blockIncrement = blockIncrement;
+        firePropertyChange("blockIncrement", old, blockIncrement);
+    }
+
+    @Override
+    public int getUnitIncrement() {
+        return unitIncrement;
+    }
+
+    @Override
+    public int getBlockIncrement() {
+        return blockIncrement;
+    }
+
+    @Override
+    public int getValue() {
+        return model.getValue();
+    }
+
+    @Override
+    public void setValue(int value) {
+        model.setValue(value);
+    }
+
+    @Override
+    public int getVisibleAmount() {
+        return model.getExtent();
+    }
+
+    @Override
+    public void setVisibleAmount(int extent) {
+        model.setExtent(extent);
+    }
+
+    @Override
+    public int getMinimum() {
+        return model.getMinimum();
+    }
+
+    @Override
+    public void setMinimum(int minimum) {
+        model.setMinimum(minimum);
+    }
+
+    @Override
+    public int getMaximum() {
+        return model.getMaximum();
+    }
+
+    @Override
+    public void setMaximum(int maximum) {
+        model.setMaximum(maximum);
+    }
+
+    public boolean getValueIsAdjusting() {
+        return model.getValueIsAdjusting();
+    }
+
+    public void setValueIsAdjusting(boolean b) {
+        model.setValueIsAdjusting(b);
+    }
+
+    public void setValues(int newValue, int newExtent, int newMin, int newMax) {
+        model.setRangeProperties(newValue, newExtent, newMin, newMax, model.getValueIsAdjusting());
+    }
+
+    @Override
+    public void addAdjustmentListener(AdjustmentListener l) {
+        listenerList.add(AdjustmentListener.class, l);
+    }
+
+    @Override
+    public void removeAdjustmentListener(AdjustmentListener l) {
+        listenerList.remove(AdjustmentListener.class, l);
+    }
+
+    public AdjustmentListener[] getAdjustmentListeners() {
+        return listenerList.getListeners(AdjustmentListener.class);
+    }
+
+    protected void fireAdjustmentValueChanged(int id, int type, int value) {
+        fireAdjustmentValueChanged(id, type, value, getValueIsAdjusting());
+    }
+
+    private void fireAdjustmentValueChanged(int id, int type, int value, boolean isAdjusting) {
+        AdjustmentListener[] ls = getAdjustmentListeners();
+        AdjustmentEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new AdjustmentEvent(this, id, type, value, isAdjusting);
+            }
+            ls[i].adjustmentValueChanged(e);
+        }
+    }
+
+    // ------------------------------------------------------------ look
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        return orientation == VERTICAL ? new Dimension(THICKNESS, 48) : new Dimension(48, THICKNESS);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return orientation == VERTICAL ? new Dimension(THICKNESS, 5) : new Dimension(5, THICKNESS);
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (isMaximumSizeSet()) {
+            return super.getMaximumSize();
+        }
+        return orientation == VERTICAL ? new Dimension(THICKNESS, Short.MAX_VALUE)
+                : new Dimension(Short.MAX_VALUE, THICKNESS);
+    }
+
+    private int trackLength() {
+        return orientation == VERTICAL ? getHeight() : getWidth();
+    }
+
+    /// The thumb as `{start, length}` along the track.
+    private int[] thumb() {
+        int track = trackLength();
+        int range = model.getMaximum() - model.getMinimum();
+        if (range <= 0 || track <= 0) {
+            return new int[]{0, track};
+        }
+        int len = Math.max(Math.min(track, 16), (int) ((long) track * model.getExtent() / range));
+        if (len > track) {
+            len = track;
+        }
+        int free = range - model.getExtent();
+        int start = free <= 0 ? 0 : (int) ((long) (track - len) * (model.getValue() - model.getMinimum()) / free);
+        return new int[]{start, len};
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        Color fg = getForeground();
+        if (fg == null) {
+            fg = Color.GRAY;
+        }
+        g.setColor(new Color(fg.getRed(), fg.getGreen(), fg.getBlue(), 40));
+        g.fillRect(0, 0, getWidth(), getHeight());
+        int[] t = thumb();
+        g.setColor(new Color(fg.getRed(), fg.getGreen(), fg.getBlue(), isEnabled() ? 150 : 70));
+        if (orientation == VERTICAL) {
+            g.fillRoundRect(2, t[0], Math.max(1, getWidth() - 4), t[1], 6, 6);
+        } else {
+            g.fillRoundRect(t[0], 2, t[1], Math.max(1, getHeight() - 4), 6, 6);
+        }
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        super.processMouseEvent(e);
+        if (!isEnabled()) {
+            return;
+        }
+        int at = orientation == VERTICAL ? e.getY() : e.getX();
+        if (e.getID() == MouseEvent.MOUSE_PRESSED) {
+            int[] t = thumb();
+            if (at >= t[0] && at < t[0] + t[1]) {
+                dragOffset = at - t[0];
+                model.setValueIsAdjusting(true);
+            } else {
+                dragOffset = -1;
+                model.setValue(model.getValue() + (at < t[0] ? -blockIncrement : blockIncrement));
+            }
+        } else if (e.getID() == MouseEvent.MOUSE_RELEASED && dragOffset >= 0) {
+            dragOffset = -1;
+            model.setValueIsAdjusting(false);
+        }
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        super.processMouseMotionEvent(e);
+        if (e.getID() == MouseEvent.MOUSE_DRAGGED && dragOffset >= 0) {
+            int at = (orientation == VERTICAL ? e.getY() : e.getX()) - dragOffset;
+            int[] t = thumb();
+            int room = trackLength() - t[1];
+            int free = model.getMaximum() - model.getMinimum() - model.getExtent();
+            if (room > 0 && free > 0) {
+                model.setValue(model.getMinimum() + (int) ((long) at * free / room));
+            }
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",orientation=" + (orientation == HORIZONTAL ? "HORIZONTAL" : "VERTICAL");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JScrollPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JScrollPane.java
new file mode 100644
index 00000000000..1418eaf2603
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JScrollPane.java
@@ -0,0 +1,710 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import java.util.HashMap;
+
+/// Shows a component larger than itself and lets the user scroll it.
+///
+/// The view sits in a [JViewport] whose peer is a scrollable Codename One
+/// container, so the user scrolls by dragging and flinging the content --
+/// or with the mouse wheel on a desktop.
+///
+/// The two scroll bars are children of the pane and their models follow
+/// the view: `getVerticalScrollBar().setValue(n)` scrolls, and a listener
+/// on the bar hears the user scrolling. Where they are shown depends on
+/// the device:
+///
+///  - On a desktop port they take room beside the viewport and are dragged
+///    with the mouse. "As needed" shows a bar while the view is larger
+///    than the viewport, "always" shows it whatever the size of the view.
+///  - On a touch device they take no room and have no size. The user
+///    drags the content, and Codename One draws its own thin indicator
+///    over it while it moves.
+///
+/// The policy "never" stops the user scrolling that axis everywhere. Row
+/// and column header views are shown and follow the view. A corner
+/// component is shown in the corner it was set for whenever that corner
+/// exists; the upper trailing corner is also shown with no scroll bar
+/// below it, at its preferred width beside a column header, so that the
+/// column control of a table has a place on a touch device too.
+///
+/// A wheel movement scrolls the viewport natively, once. It is delivered
+/// as a `MouseWheelEvent` first to the nearest component under the
+/// pointer that has a `MouseWheelListener`, and when there is one the
+/// native scrolling does not happen -- as on the desktop, where a wheel
+/// listener on the view replaces the pane's scrolling. A listener that
+/// only wants some of the events passes the others on with
+/// `getParent().dispatchEvent(e)`; a wheel event that reaches this pane
+/// that way scrolls it.
+public class JScrollPane extends JComponent implements Accessible, ScrollPaneConstants {
+
+    protected int verticalScrollBarPolicy = VERTICAL_SCROLLBAR_AS_NEEDED;
+
+    protected int horizontalScrollBarPolicy = HORIZONTAL_SCROLLBAR_AS_NEEDED;
+
+    protected JViewport viewport;
+
+    protected JScrollBar verticalScrollBar;
+
+    protected JScrollBar horizontalScrollBar;
+
+    protected JViewport rowHeader;
+
+    protected JViewport columnHeader;
+
+    private final Follow follow = new Follow();
+    private HashMap<String, Component> corners;
+    private Border viewportBorder;
+    private boolean wheelScrollState = true;
+    private boolean syncing;
+
+    public JScrollPane(Component view, int vsbPolicy, int hsbPolicy) {
+        setLayout(new ScrollPaneLayout.UIResource());
+        setVerticalScrollBarPolicy(vsbPolicy);
+        setHorizontalScrollBarPolicy(hsbPolicy);
+        setViewport(createViewport());
+        setVerticalScrollBar(createVerticalScrollBar());
+        setHorizontalScrollBar(createHorizontalScrollBar());
+        setBorder(UIManager.getBorder("ScrollPane.border"));
+        if (view != null) {
+            setViewportView(view);
+        }
+    }
+
+    public JScrollPane(Component view) {
+        this(view, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
+    }
+
+    public JScrollPane(int vsbPolicy, int hsbPolicy) {
+        this(null, vsbPolicy, hsbPolicy);
+    }
+
+    public JScrollPane() {
+        this(null, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
+    }
+
+    @Override
+    public boolean isValidateRoot() {
+        return true;
+    }
+
+    // ------------------------------------------------------------ policies
+
+    public int getVerticalScrollBarPolicy() {
+        return verticalScrollBarPolicy;
+    }
+
+    public void setVerticalScrollBarPolicy(int policy) {
+        switch (policy) {
+            case VERTICAL_SCROLLBAR_AS_NEEDED:
+            case VERTICAL_SCROLLBAR_NEVER:
+            case VERTICAL_SCROLLBAR_ALWAYS:
+                break;
+            default:
+                throw new IllegalArgumentException("invalid verticalScrollBarPolicy");
+        }
+        int old = verticalScrollBarPolicy;
+        verticalScrollBarPolicy = policy;
+        firePropertyChange("verticalScrollBarPolicy", old, policy);
+        applyPolicies();
+        if (old != policy) {
+            revalidate();
+        }
+    }
+
+    public int getHorizontalScrollBarPolicy() {
+        return horizontalScrollBarPolicy;
+    }
+
+    public void setHorizontalScrollBarPolicy(int policy) {
+        switch (policy) {
+            case HORIZONTAL_SCROLLBAR_AS_NEEDED:
+            case HORIZONTAL_SCROLLBAR_NEVER:
+            case HORIZONTAL_SCROLLBAR_ALWAYS:
+                break;
+            default:
+                throw new IllegalArgumentException("invalid horizontalScrollBarPolicy");
+        }
+        int old = horizontalScrollBarPolicy;
+        horizontalScrollBarPolicy = policy;
+        firePropertyChange("horizontalScrollBarPolicy", old, policy);
+        applyPolicies();
+        if (old != policy) {
+            revalidate();
+        }
+    }
+
+    private void applyPolicies() {
+        if (viewport != null) {
+            viewport.cn1SetScrollable(horizontalScrollBarPolicy != HORIZONTAL_SCROLLBAR_NEVER,
+                    verticalScrollBarPolicy != VERTICAL_SCROLLBAR_NEVER);
+        }
+    }
+
+    // ------------------------------------------------------------ viewport
+
+    protected JViewport createViewport() {
+        return new JViewport();
+    }
+
+    public JViewport getViewport() {
+        return viewport;
+    }
+
+    public void setViewport(JViewport viewport) {
+        JViewport old = this.viewport;
+        if (old != null) {
+            old.removeChangeListener(follow);
+            remove(old);
+        }
+        this.viewport = viewport;
+        if (viewport != null) {
+            add(viewport);
+            viewport.addChangeListener(follow);
+            applyPolicies();
+        }
+        firePropertyChange("viewport", old, viewport);
+        revalidate();
+        repaint();
+    }
+
+    public void setViewportView(Component view) {
+        if (getViewport() == null) {
+            setViewport(createViewport());
+        }
+        getViewport().setView(view);
+    }
+
+    public Border getViewportBorder() {
+        return viewportBorder;
+    }
+
+    /// Recorded, and its insets are left free around the viewport; the
+    /// border itself is not drawn.
+    public void setViewportBorder(Border viewportBorder) {
+        Border old = this.viewportBorder;
+        this.viewportBorder = viewportBorder;
+        firePropertyChange("viewportBorder", old, viewportBorder);
+        revalidate();
+    }
+
+    public Rectangle getViewportBorderBounds() {
+        Insets insets = getInsets();
+        Rectangle r = new Rectangle(insets.left, insets.top, getWidth() - insets.left - insets.right,
+                getHeight() - insets.top - insets.bottom);
+        if (columnHeader != null && columnHeader.getView() != null) {
+            int h = columnHeader.getHeight();
+            r.y += h;
+            r.height -= h;
+        }
+        if (rowHeader != null && rowHeader.getView() != null) {
+            int w = rowHeader.getWidth();
+            r.x += w;
+            r.width -= w;
+        }
+        return r;
+    }
+
+    // ------------------------------------------------------------ bars
+
+    public JScrollBar createVerticalScrollBar() {
+        return new JScrollBar(JScrollBar.VERTICAL);
+    }
+
+    public JScrollBar createHorizontalScrollBar() {
+        return new JScrollBar(JScrollBar.HORIZONTAL);
+    }
+
+    public JScrollBar getVerticalScrollBar() {
+        return verticalScrollBar;
+    }
+
+    public void setVerticalScrollBar(JScrollBar verticalScrollBar) {
+        JScrollBar old = this.verticalScrollBar;
+        if (old != null) {
+            old.getModel().removeChangeListener(follow);
+            remove(old);
+        }
+        this.verticalScrollBar = verticalScrollBar;
+        if (verticalScrollBar != null) {
+            verticalScrollBar.getModel().addChangeListener(follow);
+            add(verticalScrollBar);
+        }
+        revalidate();
+        firePropertyChange("verticalScrollBar", old, verticalScrollBar);
+        syncBars();
+    }
+
+    public JScrollBar getHorizontalScrollBar() {
+        return horizontalScrollBar;
+    }
+
+    public void setHorizontalScrollBar(JScrollBar horizontalScrollBar) {
+        JScrollBar old = this.horizontalScrollBar;
+        if (old != null) {
+            old.getModel().removeChangeListener(follow);
+            remove(old);
+        }
+        this.horizontalScrollBar = horizontalScrollBar;
+        if (horizontalScrollBar != null) {
+            horizontalScrollBar.getModel().addChangeListener(follow);
+            add(horizontalScrollBar);
+        }
+        revalidate();
+        firePropertyChange("horizontalScrollBar", old, horizontalScrollBar);
+        syncBars();
+    }
+
+    /// Writes the viewport's position, extent and view size into the
+    /// models of the bars, and moves the headers along.
+    private void syncBars() {
+        if (viewport == null || syncing) {
+            return;
+        }
+        syncing = true;
+        try {
+            Point p = viewport.getViewPosition();
+            Dimension extent = viewport.getExtentSize();
+            Component view = viewport.getView();
+            Dimension size = view == null ? new Dimension(0, 0) : view.getSize();
+            if (verticalScrollBar != null) {
+                int e = Math.min(extent.height, size.height);
+                verticalScrollBar.getModel().setRangeProperties(Math.min(p.y, Math.max(0, size.height - e)), e, 0,
+                        size.height, verticalScrollBar.getModel().getValueIsAdjusting());
+                int unit = unit(view, extent, SwingConstants.VERTICAL);
+                verticalScrollBar.unitIncrement = unit;
+                verticalScrollBar.blockIncrement = Math.max(1, extent.height);
+            }
+            if (horizontalScrollBar != null) {
+                int e = Math.min(extent.width, size.width);
+                horizontalScrollBar.getModel().setRangeProperties(Math.min(p.x, Math.max(0, size.width - e)), e, 0,
+                        size.width, horizontalScrollBar.getModel().getValueIsAdjusting());
+                horizontalScrollBar.unitIncrement = unit(view, extent, SwingConstants.HORIZONTAL);
+                horizontalScrollBar.blockIncrement = Math.max(1, extent.width);
+            }
+            if (columnHeader != null) {
+                columnHeader.setViewPosition(new Point(p.x, 0));
+            }
+            if (rowHeader != null) {
+                rowHeader.setViewPosition(new Point(0, p.y));
+            }
+        } finally {
+            syncing = false;
+        }
+    }
+
+    private int unit(Component view, Dimension extent, int orientation) {
+        if (view instanceof Scrollable && viewport != null) {
+            return Math.max(1, ((Scrollable) view).getScrollableUnitIncrement(viewport.getViewRect(), orientation, 1));
+        }
+        return Math.max(1, (orientation == SwingConstants.VERTICAL ? extent.height : extent.width) / 10);
+    }
+
+    private final class Follow implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            if (syncing || viewport == null) {
+                return;
+            }
+            if (e.getSource() == viewport) {
+                syncBars();
+                return;
+            }
+            Point p = viewport.getViewPosition();
+            int x = horizontalScrollBar == null ? p.x : horizontalScrollBar.getValue();
+            int y = verticalScrollBar == null ? p.y : verticalScrollBar.getValue();
+            if (x != p.x || y != p.y) {
+                viewport.setViewPosition(new Point(x, y));
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ headers
+
+    public JViewport getRowHeader() {
+        return rowHeader;
+    }
+
+    public void setRowHeader(JViewport rowHeader) {
+        JViewport old = this.rowHeader;
+        if (old != null) {
+            remove(old);
+        }
+        this.rowHeader = rowHeader;
+        if (rowHeader != null) {
+            rowHeader.cn1SetNativeScrolling(false);
+            add(rowHeader);
+        }
+        firePropertyChange("rowHeader", old, rowHeader);
+        revalidate();
+        repaint();
+    }
+
+    public void setRowHeaderView(Component view) {
+        if (getRowHeader() == null) {
+            setRowHeader(createViewport());
+        }
+        getRowHeader().setView(view);
+    }
+
+    public JViewport getColumnHeader() {
+        return columnHeader;
+    }
+
+    public void setColumnHeader(JViewport columnHeader) {
+        JViewport old = this.columnHeader;
+        if (old != null) {
+            remove(old);
+        }
+        this.columnHeader = columnHeader;
+        if (columnHeader != null) {
+            columnHeader.cn1SetNativeScrolling(false);
+            add(columnHeader);
+        }
+        firePropertyChange("columnHeader", old, columnHeader);
+        revalidate();
+        repaint();
+    }
+
+    public void setColumnHeaderView(Component view) {
+        if (getColumnHeader() == null) {
+            setColumnHeader(createViewport());
+        }
+        getColumnHeader().setView(view);
+    }
+
+    public Component getCorner(String key) {
+        return corners == null ? null : corners.get(key);
+    }
+
+    /// Puts a component in one of the four corners; `null` empties it.
+    /// See the class description for when a corner has room.
+    public void setCorner(String key, Component corner) {
+        if (!LOWER_LEFT_CORNER.equals(key) && !LOWER_RIGHT_CORNER.equals(key) && !UPPER_LEFT_CORNER.equals(key)
+                && !UPPER_RIGHT_CORNER.equals(key) && !LOWER_LEADING_CORNER.equals(key)
+                && !LOWER_TRAILING_CORNER.equals(key) && !UPPER_LEADING_CORNER.equals(key)
+                && !UPPER_TRAILING_CORNER.equals(key)) {
+            throw new IllegalArgumentException("invalid corner key");
+        }
+        if (corners == null) {
+            corners = new HashMap<String, Component>();
+        }
+        Component old = corner == null ? corners.remove(key) : corners.put(key, corner);
+        if (old != null && old != corner) {
+            remove(old);
+        }
+        if (corner != null && old != corner) {
+            add(corner);
+        }
+        firePropertyChange(key, old, corner);
+        revalidate();
+        repaint();
+    }
+
+    /// The component of a corner, by either of its two names: the layer
+    /// lays out left to right, so leading is left and trailing is right.
+    private Component corner(String side, String edge) {
+        if (corners == null) {
+            return null;
+        }
+        Component c = corners.get(side);
+        return c != null ? c : corners.get(edge);
+    }
+
+    public boolean isWheelScrollingEnabled() {
+        return wheelScrollState;
+    }
+
+    /// With `false` a wheel movement over the pane scrolls nothing.
+    public void setWheelScrollingEnabled(boolean handleWheel) {
+        boolean old = wheelScrollState;
+        wheelScrollState = handleWheel;
+        firePropertyChange("wheelScrollingEnabled", old, handleWheel);
+    }
+
+    /// Scrolls for a wheel event that was sent to the pane itself: one
+    /// that a listener on the view passed on, or one that arrived because
+    /// the pane has a wheel listener of its own. The wheel over a pane
+    /// nobody listens on never comes here; Codename One scrolls for it.
+    @Override
+    protected void processMouseWheelEvent(MouseWheelEvent e) {
+        super.processMouseWheelEvent(e);
+        if (e.isConsumed() || !wheelScrollState || !isEnabled() || e.getWheelRotation() == 0) {
+            return;
+        }
+        JScrollBar bar = verticalScrollBar;
+        boolean vertical = bar != null && verticalScrollBarPolicy != VERTICAL_SCROLLBAR_NEVER && !e.isShiftDown()
+                && bar.getMaximum() - bar.getVisibleAmount() > bar.getMinimum();
+        if (!vertical) {
+            bar = horizontalScrollBarPolicy == HORIZONTAL_SCROLLBAR_NEVER ? null : horizontalScrollBar;
+        }
+        if (bar == null) {
+            return;
+        }
+        int direction = e.getWheelRotation() < 0 ? -1 : 1;
+        int step;
+        if (e.getScrollType() == MouseWheelEvent.WHEEL_BLOCK_SCROLL) {
+            step = bar.getBlockIncrement(direction) * direction;
+        } else {
+            step = bar.getUnitIncrement(direction) * e.getUnitsToScroll();
+        }
+        bar.setValue(bar.getValue() + step);
+        e.consume();
+    }
+
+    // ------------------------------------------------------------ layout
+
+    private Insets space() {
+        Insets i = getInsets();
+        Insets out = new Insets(i.top, i.left, i.bottom, i.right);
+        if (viewportBorder != null) {
+            Insets b = viewportBorder.getBorderInsets(this);
+            out.top += b.top;
+            out.left += b.left;
+            out.bottom += b.bottom;
+            out.right += b.right;
+        }
+        return out;
+    }
+
+    private static boolean has(JViewport v) {
+        return v != null && v.isVisible() && v.getView() != null;
+    }
+
+    /// Which bars to show, as `{vertical, horizontal}`, for bars `t`
+    /// thick. `laidOut` reads the size the view has now instead of the
+    /// one it would like, which is the only way to know how high a view
+    /// is whose height follows its width.
+    private boolean[] barsFor(int t, boolean laidOut) {
+        if (t <= 0) {
+            return new boolean[]{false, false};
+        }
+        boolean v = verticalScrollBarPolicy == VERTICAL_SCROLLBAR_ALWAYS;
+        boolean h = horizontalScrollBarPolicy == HORIZONTAL_SCROLLBAR_ALWAYS;
+        Component view = viewport == null ? null : viewport.getView();
+        if (view == null) {
+            return new boolean[]{v, h};
+        }
+        Insets in = space();
+        int availW = Math.max(0, getWidth() - in.left - in.right)
+                - (has(rowHeader) ? rowHeader.getPreferredSize().width : 0);
+        int availH = Math.max(0, getHeight() - in.top - in.bottom)
+                - (has(columnHeader) ? columnHeader.getPreferredSize().height : 0);
+        boolean tracksW = false;
+        boolean tracksH = false;
+        if (view instanceof Scrollable) {
+            tracksW = ((Scrollable) view).getScrollableTracksViewportWidth();
+            tracksH = ((Scrollable) view).getScrollableTracksViewportHeight();
+        }
+        Dimension size = laidOut ? view.getSize() : view.getPreferredSize();
+        boolean vAsNeeded = verticalScrollBarPolicy == VERTICAL_SCROLLBAR_AS_NEEDED && !tracksH;
+        boolean hAsNeeded = horizontalScrollBarPolicy == HORIZONTAL_SCROLLBAR_AS_NEEDED && !tracksW;
+        if (vAsNeeded) {
+            v = size.height > availH;
+        }
+        if (hAsNeeded) {
+            h = size.width > availW - (v ? t : 0);
+        }
+        if (vAsNeeded && !v && h) {
+            v = size.height > availH - t;
+        }
+        return new boolean[]{v, h};
+    }
+
+    private static void bounds(Component c, int x, int y, int w, int h) {
+        if (c != null) {
+            c.setBounds(x, y, Math.max(0, w), Math.max(0, h));
+        }
+    }
+
+    /// A bar that has no room is not visible, which is how a layout of
+    /// the application's knows whether there is one.
+    private static void shown(JScrollBar bar, boolean visible) {
+        if (bar != null && bar.isVisible() != visible) {
+            bar.setVisible(visible);
+        }
+    }
+
+    private void place(boolean vsb, boolean hsb, int t) {
+        Insets in = space();
+        int x = in.left;
+        int y = in.top;
+        int w = Math.max(0, getWidth() - in.left - in.right);
+        int h = Math.max(0, getHeight() - in.top - in.bottom);
+        int headH = has(columnHeader) ? Math.min(h, columnHeader.getPreferredSize().height) : 0;
+        int headW = has(rowHeader) ? Math.min(w, rowHeader.getPreferredSize().width) : 0;
+        int barW = vsb ? Math.min(t, w - headW) : 0;
+        int barH = hsb ? Math.min(t, h - headH) : 0;
+        Component upperRight = corner(UPPER_RIGHT_CORNER, UPPER_TRAILING_CORNER);
+        int cornerW = barW;
+        if (barW == 0 && upperRight != null && headH > 0) {
+            // No bar to sit above: the corner takes its room from the end
+            // of the column header instead.
+            cornerW = Math.max(0, Math.min(upperRight.getPreferredSize().width, (w - headW) / 2));
+        }
+        bounds(columnHeader, x + headW, y, w - headW - cornerW, headH);
+        bounds(rowHeader, x, y + headH, headW, h - headH - barH);
+        bounds(viewport, x + headW, y + headH, w - headW - barW, h - headH - barH);
+        bounds(verticalScrollBar, x + w - barW, y + headH, barW, barW == 0 ? 0 : h - headH - barH);
+        bounds(horizontalScrollBar, x + headW, y + h - barH, barH == 0 ? 0 : w - headW - barW, barH);
+        shown(verticalScrollBar, barW > 0);
+        shown(horizontalScrollBar, barH > 0);
+        bounds(upperRight, x + w - cornerW, y, cornerW, cornerW == 0 ? 0 : headH);
+        bounds(corner(UPPER_LEFT_CORNER, UPPER_LEADING_CORNER), x, y, headW, headW == 0 ? 0 : headH);
+        bounds(corner(LOWER_LEFT_CORNER, LOWER_LEADING_CORNER), x, y + h - barH, headW, headW == 0 ? 0 : barH);
+        bounds(corner(LOWER_RIGHT_CORNER, LOWER_TRAILING_CORNER), x + w - barW, y + h - barH, barW,
+                barW == 0 ? 0 : barH);
+    }
+
+    /// Sets the layout, which has to be a [ScrollPaneLayout].
+    ///
+    /// #### Throws
+    ///
+    /// - `ClassCastException`: if `layout` is neither `null` nor a
+    ///   `ScrollPaneLayout`
+    @Override
+    public void setLayout(LayoutManager layout) {
+        if (layout != null && !(layout instanceof ScrollPaneLayout)) {
+            throw new ClassCastException("layout of JScrollPane must be a ScrollPaneLayout");
+        }
+        super.setLayout(layout);
+        cn1SyncLayout();
+    }
+
+    /// Tells the layout of the parts the pane has now.
+    private void cn1SyncLayout() {
+        LayoutManager l = getLayout();
+        if (l instanceof ScrollPaneLayout) {
+            ((ScrollPaneLayout) l).syncWithScrollPane(this);
+        }
+    }
+
+    @Override
+    public void revalidate() {
+        // Every change of a part comes through here.
+        cn1SyncLayout();
+        super.revalidate();
+    }
+
+    @Override
+    public void doLayout() {
+        LayoutManager l = getLayout();
+        if (l instanceof ScrollPaneLayout) {
+            l.layoutContainer(this);
+        } else {
+            cn1Layout();
+        }
+    }
+
+    /// The standard placement, which is what `ScrollPaneLayout` does.
+    void cn1Layout() {
+        int t = ScrollDelegate.barThickness();
+        boolean[] bars = barsFor(t, false);
+        place(bars[0], bars[1], t);
+        if (t > 0 && viewport != null && viewport.getView() != null) {
+            // The view is laid out now, so that a view whose height follows
+            // its width is measured at the width it really got.
+            viewport.validate();
+            boolean[] measured = barsFor(t, true);
+            if (measured[0] != bars[0] || measured[1] != bars[1]) {
+                place(measured[0], measured[1], t);
+                viewport.validate();
+            }
+        }
+    }
+
+    @Override
+    protected void validateTree() {
+        super.validateTree();
+        syncBars();
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        LayoutManager l = getLayout();
+        return l instanceof ScrollPaneLayout ? l.preferredLayoutSize(this) : cn1PreferredSize();
+    }
+
+    Dimension cn1PreferredSize() {
+        Insets in = space();
+        Dimension d = viewport == null ? new Dimension(0, 0) : viewport.getPreferredSize();
+        int w = d.width;
+        int h = d.height;
+        if (has(columnHeader)) {
+            h += columnHeader.getPreferredSize().height;
+        }
+        if (has(rowHeader)) {
+            w += rowHeader.getPreferredSize().width;
+        }
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        LayoutManager l = getLayout();
+        return l instanceof ScrollPaneLayout ? l.minimumLayoutSize(this) : cn1MinimumSize();
+    }
+
+    Dimension cn1MinimumSize() {
+        Insets in = space();
+        int w = 4;
+        int h = 4;
+        if (has(columnHeader)) {
+            h += columnHeader.getPreferredSize().height;
+        }
+        if (has(rowHeader)) {
+            w += rowHeader.getPreferredSize().width;
+        }
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        return isMaximumSizeSet() ? super.getMaximumSize() : new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",verticalScrollBarPolicy=" + verticalScrollBarPolicy
+                + ",horizontalScrollBarPolicy=" + horizontalScrollBarPolicy;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSeparator.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSeparator.java
new file mode 100644
index 00000000000..0cc2f577ec0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSeparator.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+
+/// A dividing line, horizontal or vertical, drawn by this class one
+/// logical pixel thick in a gray half way between the foreground and the
+/// background. It has no Codename One widget behind it.
+///
+/// Not supported: there is no UI delegate, so `getUI` and `setUI` are
+/// absent and the line has no highlight beside it.
+public class JSeparator extends JComponent implements Accessible, SwingConstants {
+
+    private int orientation;
+
+    public JSeparator() {
+        this(HORIZONTAL);
+    }
+
+    public JSeparator(int orientation) {
+        checkOrientation(orientation);
+        this.orientation = orientation;
+    }
+
+    private static void checkOrientation(int orientation) {
+        if (orientation != VERTICAL && orientation != HORIZONTAL) {
+            throw new IllegalArgumentException("orientation must be one of: VERTICAL, HORIZONTAL");
+        }
+    }
+
+    public int getOrientation() {
+        return orientation;
+    }
+
+    public void setOrientation(int orientation) {
+        if (this.orientation == orientation) {
+            return;
+        }
+        int old = this.orientation;
+        checkOrientation(orientation);
+        this.orientation = orientation;
+        firePropertyChange("orientation", old, orientation);
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        return orientation == VERTICAL ? new Dimension(2, 0) : new Dimension(0, 2);
+    }
+
+    /// The colour of the line: half way from the foreground to the
+    /// background, where a missing foreground is black and a missing
+    /// background white.
+    private Color lineColor() {
+        Color fg = getForeground();
+        Color bg = getBackground();
+        if (fg == null) {
+            fg = Color.BLACK;
+        }
+        if (bg == null) {
+            bg = Color.WHITE;
+        }
+        return new Color((fg.getRed() + bg.getRed()) / 2, (fg.getGreen() + bg.getGreen()) / 2,
+                (fg.getBlue() + bg.getBlue()) / 2);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        g.setColor(lineColor());
+        if (orientation == VERTICAL) {
+            g.fillRect(0, 0, 1, getHeight());
+        } else {
+            g.fillRect(0, 0, getWidth(), 1);
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",orientation=" + (orientation == HORIZONTAL ? "HORIZONTAL" : "VERTICAL");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSlider.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSlider.java
new file mode 100644
index 00000000000..0e0fce78579
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSlider.java
@@ -0,0 +1,785 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.rt.CellTheme;
+import java.util.Dictionary;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+/// A slider over a bounded range model, painted and dragged by this
+/// class.
+///
+/// It is drawn here -- a track, the part of it up to the value in the
+/// theme's accent color, and a round thumb -- and not by a Codename One
+/// slider, whose thumb is an image only some themes have and whose vertical
+/// form draws no track at all. The colors are the theme's, so it still
+/// belongs to the widgets around it; a color put into [UIManager] under
+/// `Slider.foreground` (the thumb and the filled part) or
+/// `Slider.trackColor` wins.
+///
+/// Pressing anywhere on the slider moves the thumb there and dragging
+/// follows the pointer, setting the model's value with `valueIsAdjusting`
+/// true and ending with it false, as on the desktop. The arrow keys, Page
+/// Up, Page Down, Home and End move a focused slider. The thumb's centre
+/// travels between half a thumb from either end, and the tick marks and
+/// the labels of the label table are painted below the track (to its right
+/// when vertical) at those same positions, so `paintTicks`, `paintLabels`,
+/// `paintTrack`, `inverted` and `snapToTicks` all take effect.
+///
+/// Not supported: the standard labels made by `createStandardLabels` are
+/// made once and do not follow later changes of the range; there is no UI
+/// delegate, so `getUI`, `setUI` and the client property
+/// `JSlider.isFilled` are absent.
+public class JSlider extends JComponent implements Accessible, SwingConstants {
+
+    private static final int LENGTH = 200;
+    private static final int MINIMUM_LENGTH = 36;
+    private static final int THUMB = 16;
+    private static final int TOUCH_THUMB = 24;
+    private static final int TRACK = 4;
+    private static final int MAJOR_TICK = 8;
+    private static final int MINOR_TICK = 4;
+    private static final int MAX_TICKS = 2000;
+
+    protected BoundedRangeModel sliderModel;
+    protected int majorTickSpacing;
+    protected int minorTickSpacing;
+    protected boolean snapToTicks;
+    protected int orientation;
+    protected ChangeListener changeListener;
+    protected ChangeEvent changeEvent;
+
+    private final ChangeListener bridge = new Bridge();
+    private boolean paintTicks;
+    private boolean paintTrack = true;
+    private boolean paintLabels;
+    private boolean inverted;
+    @SuppressWarnings("rawtypes")
+    private Dictionary labelTable;
+    private boolean dragging;
+
+    public JSlider() {
+        this(HORIZONTAL, 0, 100, 50);
+    }
+
+    public JSlider(int orientation) {
+        this(orientation, 0, 100, 50);
+    }
+
+    public JSlider(int min, int max) {
+        this(HORIZONTAL, min, max, (min + max) / 2);
+    }
+
+    public JSlider(int min, int max, int value) {
+        this(HORIZONTAL, min, max, value);
+    }
+
+    public JSlider(int orientation, int min, int max, int value) {
+        checkOrientation(orientation);
+        this.orientation = orientation;
+        sliderModel = new DefaultBoundedRangeModel(value, 0, min, max);
+        sliderModel.addChangeListener(bridge);
+        cn1Listen();
+    }
+
+    public JSlider(BoundedRangeModel brm) {
+        cn1Listen();
+        orientation = HORIZONTAL;
+        sliderModel = brm;
+        if (brm != null) {
+            brm.addChangeListener(bridge);
+        }
+    }
+
+    private static void checkOrientation(int orientation) {
+        if (orientation != VERTICAL && orientation != HORIZONTAL) {
+            throw new IllegalArgumentException("orientation must be one of: VERTICAL, HORIZONTAL");
+        }
+    }
+
+    // ------------------------------------------------------------ input
+
+    private void cn1Listen() {
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
+        setFocusable(true);
+    }
+
+    /// The diameter of the thumb, which is also how thick the band of
+    /// the track is: larger where the pointer is a finger.
+    private static int thumbSize() {
+        return CellTheme.touch() ? TOUCH_THUMB : THUMB;
+    }
+
+    /// The length of the slider and how far in from either end the
+    /// thumb's centre stops.
+    private int length() {
+        return orientation == VERTICAL ? getHeight() : getWidth();
+    }
+
+    private int inset() {
+        return Math.min(thumbSize() / 2, Math.max(0, length() / 2));
+    }
+
+    /// Moves the value to where the pointer is, `at` logical pixels along
+    /// the slider.
+    private void cn1MoveTo(int at, boolean adjusting) {
+        BoundedRangeModel m = sliderModel;
+        if (m == null) {
+            return;
+        }
+        int min = m.getMinimum();
+        int max = m.getMaximum();
+        int inset = inset();
+        int room = length() - 2 * inset;
+        double f = room <= 0 ? 0 : (double) (at - inset) / (double) room;
+        f = f < 0 ? 0 : f > 1 ? 1 : f;
+        if (orientation == VERTICAL) {
+            f = 1 - f;
+        }
+        if (inverted) {
+            f = 1 - f;
+        }
+        long v = min + Math.round(f * ((double) max - (double) min));
+        cn1Set(v, adjusting);
+    }
+
+    private void cn1Set(long value, boolean adjusting) {
+        BoundedRangeModel m = sliderModel;
+        int min = m.getMinimum();
+        int max = m.getMaximum();
+        int extent = m.getExtent();
+        long v = value;
+        if (snapToTicks) {
+            v = snap(v, min);
+        }
+        if (v > (long) max - extent) {
+            v = (long) max - extent;
+        }
+        if (v < min) {
+            v = min;
+        }
+        m.setRangeProperties((int) v, extent, min, max, adjusting);
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        super.processMouseEvent(e);
+        if (!isEnabled() || sliderModel == null) {
+            return;
+        }
+        int at = orientation == VERTICAL ? e.getY() : e.getX();
+        if (e.getID() == MouseEvent.MOUSE_PRESSED) {
+            dragging = true;
+            requestFocusInWindow();
+            cn1MoveTo(at, true);
+        } else if (e.getID() == MouseEvent.MOUSE_RELEASED && dragging) {
+            dragging = false;
+            sliderModel.setValueIsAdjusting(false);
+        }
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        super.processMouseMotionEvent(e);
+        if (e.getID() == MouseEvent.MOUSE_DRAGGED && dragging && isEnabled() && sliderModel != null) {
+            cn1MoveTo(orientation == VERTICAL ? e.getY() : e.getX(), true);
+        }
+    }
+
+    @Override
+    protected void processKeyEvent(KeyEvent e) {
+        super.processKeyEvent(e);
+        if (e.getID() != KeyEvent.KEY_PRESSED || e.isConsumed() || !isEnabled() || sliderModel == null) {
+            return;
+        }
+        long span = (long) getMaximum() - (long) getMinimum();
+        long unit = snapToTicks && minorTickSpacing > 0 ? minorTickSpacing
+                : snapToTicks && majorTickSpacing > 0 ? majorTickSpacing : 1;
+        long block = Math.max(unit, majorTickSpacing > 0 ? majorTickSpacing : span / 10);
+        long dir = inverted ? -1 : 1;
+        long v = getValue();
+        int code = e.getKeyCode();
+        if (code == KeyEvent.VK_RIGHT || code == KeyEvent.VK_UP) {
+            v += dir * unit;
+        } else if (code == KeyEvent.VK_LEFT || code == KeyEvent.VK_DOWN) {
+            v -= dir * unit;
+        } else if (code == KeyEvent.VK_PAGE_UP) {
+            v += dir * block;
+        } else if (code == KeyEvent.VK_PAGE_DOWN) {
+            v -= dir * block;
+        } else if (code == KeyEvent.VK_HOME) {
+            v = getMinimum();
+        } else if (code == KeyEvent.VK_END) {
+            v = getMaximum();
+        } else {
+            return;
+        }
+        cn1Set(v, false);
+        e.consume();
+    }
+
+    private long snap(long value, int min) {
+        int spacing = minorTickSpacing > 0 ? minorTickSpacing : majorTickSpacing;
+        if (spacing <= 0) {
+            return value;
+        }
+        long off = value - min;
+        long down = off - off % spacing;
+        return min + (off - down >= spacing - (off - down) ? down + spacing : down);
+    }
+
+    // ------------------------------------------------------------ sizes
+
+    private int nativeThickness() {
+        return thumbSize() + 4;
+    }
+
+    /// The width (for a vertical slider) or height of the largest label,
+    /// or zero when labels are not painted.
+    private int labelExtent() {
+        if (!paintLabels || labelTable == null) {
+            return 0;
+        }
+        int most = 0;
+        Enumeration<?> e = labelTable.elements();
+        while (e.hasMoreElements()) {
+            Object o = e.nextElement();
+            if (o instanceof Component) {
+                Dimension d = ((Component) o).getPreferredSize();
+                most = Math.max(most, orientation == VERTICAL ? d.width : d.height);
+            }
+        }
+        return most;
+    }
+
+    private int across() {
+        return nativeThickness() + (paintTicks ? MAJOR_TICK : 0) + labelExtent();
+    }
+
+    /// The preferred size: 200 logical pixels along the slider, and across
+    /// it the native track, the tick marks and the labels.
+    @Override
+    protected Dimension cn1NativePreferredSize() {
+        return orientation == VERTICAL ? new Dimension(across(), LENGTH) : new Dimension(LENGTH, across());
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return orientation == VERTICAL ? new Dimension(across(), MINIMUM_LENGTH)
+                : new Dimension(MINIMUM_LENGTH, across());
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (isMaximumSizeSet()) {
+            return super.getMaximumSize();
+        }
+        return orientation == VERTICAL ? new Dimension(across(), Short.MAX_VALUE)
+                : new Dimension(Short.MAX_VALUE, across());
+    }
+
+    // ------------------------------------------------------------ paint
+
+    private static Color put(String key) {
+        return UIManager.cn1PutColor(key);
+    }
+
+    /// The color of the thumb and of the track up to it: the one put
+    /// under `Slider.foreground`, else the background the theme gives the
+    /// filled part of its own slider, else the text color.
+    private Color accent() {
+        Color c = put("Slider.foreground");
+        if (c != null) {
+            return c;
+        }
+        if (com.codename1.ui.Display.isInitialized()) {
+            com.codename1.ui.plaf.Style st =
+                    com.codename1.ui.plaf.UIManager.getInstance().getComponentStyle("SliderFull");
+            Color bg = getBackground();
+            int rgb = st.getBgColor() & 0xffffff;
+            if ((st.getBgTransparency() & 0xff) != 0 && (bg == null || (bg.getRGB() & 0xffffff) != rgb)) {
+                return new Color(rgb);
+            }
+        }
+        return CellTheme.mix(base(), ink(), 0.75f);
+    }
+
+    private Color base() {
+        Color bg = getBackground();
+        return bg != null ? bg : Color.WHITE;
+    }
+
+    private Color ink() {
+        Color fg = getForeground();
+        return fg != null ? fg : Color.BLACK;
+    }
+
+    /// Paints the track in its band with the thumb on it, then the tick
+    /// marks and the labels beside it.
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (isOpaque()) {
+            g.setColor(base());
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        boolean vertical = orientation == VERTICAL;
+        int thick = nativeThickness();
+        int room = vertical ? getWidth() : getHeight();
+        int start = Math.max(0, (room - across()) / 2);
+        int thumb = Math.min(thumbSize(), Math.max(1, Math.min(room, length())));
+        int centre = start + Math.min(thick, room) / 2;
+        int inset = inset();
+        int len = length();
+        int pos = sliderModel == null ? inset : position(getValue());
+        Color track = put("Slider.trackColor");
+        if (track == null) {
+            track = CellTheme.mix(base(), ink(), 0.22f);
+        }
+        Color accent = isEnabled() ? accent() : CellTheme.mix(base(), ink(), 0.35f);
+        if (paintTrack) {
+            int t = Math.min(TRACK, thumb);
+            g.setColor(track);
+            // The filled part runs from the end the minimum is at.
+            boolean fromStart = vertical == inverted;
+            if (vertical) {
+                g.fillRoundRect(centre - t / 2, inset, t, Math.max(0, len - 2 * inset), t, t);
+                g.setColor(accent);
+                if (fromStart) {
+                    g.fillRoundRect(centre - t / 2, inset, t, Math.max(0, pos - inset), t, t);
+                } else {
+                    g.fillRoundRect(centre - t / 2, pos, t, Math.max(0, len - inset - pos), t, t);
+                }
+            } else {
+                g.fillRoundRect(inset, centre - t / 2, Math.max(0, len - 2 * inset), t, t, t);
+                g.setColor(accent);
+                if (fromStart) {
+                    g.fillRoundRect(inset, centre - t / 2, Math.max(0, pos - inset), t, t, t);
+                } else {
+                    g.fillRoundRect(pos, centre - t / 2, Math.max(0, len - inset - pos), t, t, t);
+                }
+            }
+        }
+        int tx = (vertical ? centre : pos) - thumb / 2;
+        int ty = (vertical ? pos : centre) - thumb / 2;
+        // An outline in the background color keeps the thumb apart from
+        // the track on either side of it.
+        g.setColor(base());
+        g.fillOval(tx - 1, ty - 1, thumb + 2, thumb + 2);
+        g.setColor(accent);
+        g.fillOval(tx, ty, thumb, thumb);
+        int at = start + thick;
+        if (paintTicks) {
+            g.setColor(CellTheme.mix(base(), ink(), isEnabled() ? 0.7f : 0.35f));
+            paintTickMarks(g, at, minorTickSpacing, MINOR_TICK);
+            paintTickMarks(g, at, majorTickSpacing, MAJOR_TICK);
+            at += MAJOR_TICK;
+        }
+        if (paintLabels && labelTable != null) {
+            paintLabelTable(g, at);
+        }
+    }
+
+    /// Where along the slider `value` is, in logical pixels.
+    private int position(long value) {
+        int inset = inset();
+        int length = length() - 2 * inset;
+        long min = getMinimum();
+        long span = (long) getMaximum() - min;
+        double f = span <= 0 ? 0 : (double) (value - min) / (double) span;
+        if (inverted) {
+            f = 1 - f;
+        }
+        if (orientation == VERTICAL) {
+            f = 1 - f;
+        }
+        return inset + (int) Math.round(f * Math.max(0, length));
+    }
+
+    private void paintTickMarks(Graphics g, int at, int spacing, int length) {
+        if (spacing <= 0) {
+            return;
+        }
+        long min = getMinimum();
+        long max = getMaximum();
+        if ((max - min) / spacing > MAX_TICKS) {
+            return;
+        }
+        for (long v = min; v <= max; v += spacing) {
+            int pos = position(v);
+            if (orientation == VERTICAL) {
+                g.drawLine(at, pos, at + length - 1, pos);
+            } else {
+                g.drawLine(pos, at, pos, at + length - 1);
+            }
+        }
+    }
+
+    private void paintLabelTable(Graphics g, int at) {
+        Enumeration<?> keys = labelTable.keys();
+        while (keys.hasMoreElements()) {
+            Object key = keys.nextElement();
+            Object label = labelTable.get(key);
+            if (!(key instanceof Number) || !(label instanceof Component)) {
+                continue;
+            }
+            Component c = (Component) label;
+            Dimension d = c.getPreferredSize();
+            if (c.getWidth() != d.width || c.getHeight() != d.height) {
+                c.setSize(d.width, d.height);
+            }
+            int pos = position(((Number) key).longValue());
+            int x;
+            int y;
+            if (orientation == VERTICAL) {
+                x = at;
+                y = clamp(pos - d.height / 2, getHeight() - d.height);
+            } else {
+                x = clamp(pos - d.width / 2, getWidth() - d.width);
+                y = at;
+            }
+            Graphics lg = g.create(x, y, d.width, d.height);
+            try {
+                c.paint(lg);
+            } finally {
+                lg.dispose();
+            }
+        }
+    }
+
+    private static int clamp(int v, int most) {
+        return v > most ? Math.max(0, most) : v < 0 ? 0 : v;
+    }
+
+    // ------------------------------------------------------------ model
+
+    /// The listener that turns the model's changes into this slider's.
+    protected ChangeListener createChangeListener() {
+        return new ModelListener();
+    }
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    public BoundedRangeModel getModel() {
+        return sliderModel;
+    }
+
+    public void setModel(BoundedRangeModel newModel) {
+        BoundedRangeModel old = sliderModel;
+        if (old != null) {
+            old.removeChangeListener(bridge);
+        }
+        sliderModel = newModel;
+        if (newModel != null) {
+            newModel.addChangeListener(bridge);
+        }
+        firePropertyChange("model", old, newModel);
+        repaint();
+    }
+
+    public int getValue() {
+        return sliderModel.getValue();
+    }
+
+    public void setValue(int n) {
+        BoundedRangeModel m = sliderModel;
+        if (m.getValue() != n) {
+            m.setValue(n);
+        }
+    }
+
+    public int getMinimum() {
+        return sliderModel.getMinimum();
+    }
+
+    public void setMinimum(int minimum) {
+        int old = sliderModel.getMinimum();
+        sliderModel.setMinimum(minimum);
+        firePropertyChange("minimum", old, minimum);
+    }
+
+    public int getMaximum() {
+        return sliderModel.getMaximum();
+    }
+
+    public void setMaximum(int maximum) {
+        int old = sliderModel.getMaximum();
+        sliderModel.setMaximum(maximum);
+        firePropertyChange("maximum", old, maximum);
+    }
+
+    public boolean getValueIsAdjusting() {
+        return sliderModel.getValueIsAdjusting();
+    }
+
+    public void setValueIsAdjusting(boolean b) {
+        sliderModel.setValueIsAdjusting(b);
+    }
+
+    public int getExtent() {
+        return sliderModel.getExtent();
+    }
+
+    public void setExtent(int extent) {
+        sliderModel.setExtent(extent);
+    }
+
+    // ------------------------------------------------------- properties
+
+    public int getOrientation() {
+        return orientation;
+    }
+
+    public void setOrientation(int orientation) {
+        checkOrientation(orientation);
+        int old = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange("orientation", old, orientation);
+        if (orientation != old) {
+            changed();
+        }
+    }
+
+    private void changed() {
+        revalidate();
+        repaint();
+    }
+
+    @SuppressWarnings("rawtypes")
+    public Dictionary getLabelTable() {
+        return labelTable;
+    }
+
+    /// Sets what is drawn at which value: a dictionary from `Integer` to
+    /// component, usually a label.
+    @SuppressWarnings("rawtypes")
+    public void setLabelTable(Dictionary labels) {
+        Dictionary old = labelTable;
+        labelTable = labels;
+        updateLabelUIs();
+        firePropertyChange("labelTable", old, labels);
+        if (labels != old) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    /// Gives every label of the label table its preferred size.
+    protected void updateLabelUIs() {
+        if (labelTable == null) {
+            return;
+        }
+        Enumeration<?> e = labelTable.elements();
+        while (e.hasMoreElements()) {
+            Object o = e.nextElement();
+            if (o instanceof JComponent) {
+                JComponent c = (JComponent) o;
+                Dimension d = c.getPreferredSize();
+                c.setSize(d.width, d.height);
+            }
+        }
+    }
+
+    @SuppressWarnings("rawtypes")
+    public Hashtable createStandardLabels(int increment) {
+        return createStandardLabels(increment, getMinimum());
+    }
+
+    /// A label table with a text label for `start` and every `increment`
+    /// after it up to the maximum.
+    @SuppressWarnings("rawtypes")
+    public Hashtable createStandardLabels(int increment, int start) {
+        if (start > getMaximum() || start < getMinimum()) {
+            throw new IllegalArgumentException("Slider label start point out of range.");
+        }
+        if (increment <= 0) {
+            throw new IllegalArgumentException("Label incremement must be > 0");
+        }
+        Hashtable<Integer, JComponent> table = new Hashtable<Integer, JComponent>();
+        long max = getMaximum();
+        for (long v = start; v <= max; v += increment) {
+            table.put(Integer.valueOf((int) v), new JLabel(String.valueOf(v), CENTER));
+        }
+        return table;
+    }
+
+    public boolean getInverted() {
+        return inverted;
+    }
+
+    public void setInverted(boolean b) {
+        boolean old = inverted;
+        inverted = b;
+        firePropertyChange("inverted", old, b);
+        if (b != old) {
+            repaint();
+        }
+    }
+
+    public int getMajorTickSpacing() {
+        return majorTickSpacing;
+    }
+
+    public void setMajorTickSpacing(int n) {
+        int old = majorTickSpacing;
+        majorTickSpacing = n;
+        if (labelTable == null && n > 0 && paintLabels) {
+            setLabelTable(createStandardLabels(n));
+        }
+        firePropertyChange("majorTickSpacing", old, n);
+        if (n != old && paintTicks) {
+            repaint();
+        }
+    }
+
+    public int getMinorTickSpacing() {
+        return minorTickSpacing;
+    }
+
+    public void setMinorTickSpacing(int n) {
+        int old = minorTickSpacing;
+        minorTickSpacing = n;
+        firePropertyChange("minorTickSpacing", old, n);
+        if (n != old && paintTicks) {
+            repaint();
+        }
+    }
+
+    public boolean getSnapToTicks() {
+        return snapToTicks;
+    }
+
+    public void setSnapToTicks(boolean b) {
+        boolean old = snapToTicks;
+        snapToTicks = b;
+        firePropertyChange("snapToTicks", old, b);
+    }
+
+    public boolean getPaintTicks() {
+        return paintTicks;
+    }
+
+    public void setPaintTicks(boolean b) {
+        boolean old = paintTicks;
+        paintTicks = b;
+        firePropertyChange("paintTicks", old, b);
+        if (b != old) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    public boolean getPaintTrack() {
+        return paintTrack;
+    }
+
+    public void setPaintTrack(boolean b) {
+        boolean old = paintTrack;
+        paintTrack = b;
+        firePropertyChange("paintTrack", old, b);
+        if (b != old) {
+            repaint();
+        }
+    }
+
+    public boolean getPaintLabels() {
+        return paintLabels;
+    }
+
+    public void setPaintLabels(boolean b) {
+        boolean old = paintLabels;
+        paintLabels = b;
+        if (labelTable == null && majorTickSpacing > 0) {
+            setLabelTable(createStandardLabels(majorTickSpacing));
+        }
+        firePropertyChange("paintLabels", old, b);
+        if (b != old) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",isInverted=" + inverted + ",majorTickSpacing=" + majorTickSpacing
+                + ",minorTickSpacing=" + minorTickSpacing + ",orientation="
+                + (orientation == HORIZONTAL ? "HORIZONTAL" : "VERTICAL") + ",paintLabels=" + paintLabels
+                + ",paintTicks=" + paintTicks + ",paintTrack=" + paintTrack + ",snapToTicks=" + snapToTicks
+                + ",snapToValue=true";
+    }
+
+    /// Listens to the model for as long as it is this slider's, and hands
+    /// what it hears to the listener `createChangeListener` makes.
+    private final class Bridge implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            if (changeListener == null) {
+                changeListener = createChangeListener();
+            }
+            if (changeListener != null) {
+                changeListener.stateChanged(e);
+            }
+            repaint();
+        }
+    }
+
+    private final class ModelListener implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            fireStateChanged();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSpinner.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSpinner.java
new file mode 100644
index 00000000000..5b0acbf4944
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSpinner.java
@@ -0,0 +1,808 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import java.text.DecimalFormat;
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+
+/// A value stepped through the sequence of a spinner model: an editor
+/// showing the value, and two buttons that go to the previous and the next
+/// one.
+///
+/// The spinner is a container of three children laid out in a row, the
+/// editor first and the two buttons after it, side by side so each is a
+/// touch target of its own. The editor holds a text field; finishing an
+/// edit there (Enter) parses the text back into the model for the number,
+/// list and date models, and text that does not parse, or parses to a value
+/// outside the model's range, is replaced by the current value.
+///
+/// Not supported: the editors hold a plain text field, not a formatted
+/// one, so `DefaultEditor.getTextField()` is absent and `propertyChange`
+/// has nothing to react to; the date editor's default pattern is
+/// `M/d/yy h:mm a` whatever the locale; a list editor does not complete
+/// what is typed; the editor is made when it is first needed, not in the
+/// constructor; there is no UI delegate.
+public class JSpinner extends JComponent implements Accessible {
+
+    private static final String NUMBER_PATTERN = "#,##0.###";
+    private static final String DATE_PATTERN = "M/d/yy h:mm a";
+    private static final int BUTTON_WIDTH = 24;
+    private static final int BUTTON_HEIGHT = 20;
+
+    private SpinnerModel model;
+    private JComponent editor;
+    private boolean editorExplicitlySet;
+    private ChangeEvent changeEvent;
+    private final ChangeListener modelListener = new ModelListener();
+    private final JButton nextButton = new JButton(new Arrow(true));
+    private final JButton previousButton = new JButton(new Arrow(false));
+
+    public JSpinner(SpinnerModel model) {
+        if (model == null) {
+            throw new NullPointerException("model cannot be null");
+        }
+        this.model = model;
+        model.addChangeListener(modelListener);
+        nextButton.setName("Spinner.nextButton");
+        previousButton.setName("Spinner.previousButton");
+        nextButton.addActionListener(new Step(true));
+        previousButton.addActionListener(new Step(false));
+        setLayout(new Row());
+        add(previousButton);
+        add(nextButton);
+    }
+
+    public JSpinner() {
+        this(new SpinnerNumberModel());
+    }
+
+    /// The editor, made by `createEditor` the first time it is needed.
+    private JComponent editor() {
+        if (editor == null) {
+            editor = createEditor(model);
+            add(editor, 0);
+        }
+        return editor;
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        // The editor has to be a child before the children get their peers.
+        editor();
+        return super.cn1CreatePeer();
+    }
+
+    /// Makes the editor that suits the model: a date, list or number
+    /// editor for those models, else one that only shows the value.
+    protected JComponent createEditor(SpinnerModel model) {
+        if (model instanceof SpinnerDateModel) {
+            return new DateEditor(this);
+        } else if (model instanceof SpinnerListModel) {
+            return new ListEditor(this);
+        } else if (model instanceof SpinnerNumberModel) {
+            return new NumberEditor(this);
+        }
+        return new DefaultEditor(this);
+    }
+
+    public void setModel(SpinnerModel model) {
+        if (model == null) {
+            throw new IllegalArgumentException("null model");
+        }
+        if (!model.equals(this.model)) {
+            SpinnerModel old = this.model;
+            this.model = model;
+            old.removeChangeListener(modelListener);
+            model.addChangeListener(modelListener);
+            firePropertyChange("model", old, model);
+            if (!editorExplicitlySet) {
+                setEditor(createEditor(model));
+                editorExplicitlySet = false;
+            }
+            revalidate();
+            repaint();
+        }
+    }
+
+    public SpinnerModel getModel() {
+        return model;
+    }
+
+    public Object getValue() {
+        return model.getValue();
+    }
+
+    public void setValue(Object value) {
+        model.setValue(value);
+    }
+
+    public Object getNextValue() {
+        return model.getNextValue();
+    }
+
+    public Object getPreviousValue() {
+        return model.getPreviousValue();
+    }
+
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+
+    public void removeChangeListener(ChangeListener listener) {
+        listenerList.remove(ChangeListener.class, listener);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    /// Replaces the editor. A default editor that is replaced stops
+    /// listening to this spinner.
+    public void setEditor(JComponent editor) {
+        if (editor == null) {
+            throw new IllegalArgumentException("null editor");
+        }
+        if (!editor.equals(this.editor)) {
+            JComponent old = this.editor;
+            this.editor = editor;
+            if (old != null) {
+                remove(old);
+            }
+            if (old instanceof DefaultEditor) {
+                ((DefaultEditor) old).dismiss(this);
+            }
+            add(editor, 0);
+            editorExplicitlySet = true;
+            firePropertyChange("editor", old, editor);
+            revalidate();
+            repaint();
+        }
+    }
+
+    public JComponent getEditor() {
+        return editor();
+    }
+
+    /// Parses the text being edited into the model. Text that does not
+    /// parse throws and leaves the model as it is.
+    public void commitEdit() throws ParseException {
+        JComponent e = editor();
+        if (e instanceof DefaultEditor) {
+            ((DefaultEditor) e).commitEdit();
+        }
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        super.setEnabled(enabled);
+        nextButton.setEnabled(enabled);
+        previousButton.setEnabled(enabled);
+        JComponent e = editor();
+        e.setEnabled(enabled);
+        if (e instanceof DefaultEditor) {
+            ((DefaultEditor) e).field.setEnabled(enabled);
+        }
+    }
+
+    /// Goes to the next or the previous value, after taking in what was
+    /// being typed; text that does not parse is dropped.
+    private void step(boolean up) {
+        JComponent e = editor();
+        try {
+            commitEdit();
+        } catch (ParseException ex) {
+            if (e instanceof DefaultEditor) {
+                ((DefaultEditor) e).show(getValue());
+            }
+        }
+        Object v = up ? getNextValue() : getPreviousValue();
+        if (v != null) {
+            try {
+                setValue(v);
+            } catch (IllegalArgumentException refused) {
+                // The model refused its own next value; stay where we are.
+                repaint();
+            }
+        }
+    }
+
+    private final class Step implements ActionListener {
+        private final boolean up;
+
+        Step(boolean up) {
+            this.up = up;
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            step(up);
+        }
+    }
+
+    private final class ModelListener implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            fireStateChanged();
+        }
+    }
+
+    /// The editor, then the previous and the next button, in a row as
+    /// high as the highest of them.
+    private final class Row implements LayoutManager {
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        /// A button is never narrower or lower than a pointer can hit,
+        /// whatever the theme gives a button that has only an icon.
+        private Dimension buttonSize(JButton b) {
+            Dimension d = b.getPreferredSize();
+            return new Dimension(Math.max(d.width, BUTTON_WIDTH), Math.max(d.height, BUTTON_HEIGHT));
+        }
+
+        private Dimension size(boolean minimum) {
+            JComponent e = editor();
+            Dimension ed = minimum ? e.getMinimumSize() : e.getPreferredSize();
+            Dimension p = buttonSize(previousButton);
+            Dimension n = buttonSize(nextButton);
+            Insets in = getInsets();
+            return new Dimension(ed.width + p.width + n.width + in.left + in.right,
+                    Math.max(ed.height, Math.max(p.height, n.height)) + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            return size(false);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return size(true);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            JComponent e = editor();
+            Insets in = getInsets();
+            int x = in.left;
+            int y = in.top;
+            int w = Math.max(0, getWidth() - in.left - in.right);
+            int h = Math.max(0, getHeight() - in.top - in.bottom);
+            int pw = Math.min(buttonSize(previousButton).width, w / 3);
+            int nw = Math.min(buttonSize(nextButton).width, w / 3);
+            e.setBounds(x, y, w - pw - nw, h);
+            previousButton.setBounds(x + w - pw - nw, y, pw, h);
+            nextButton.setBounds(x + w - nw, y, nw, h);
+        }
+    }
+
+    /// A small triangle pointing up or down, in the button's foreground.
+    private static final class Arrow implements Icon {
+        private static final int WIDTH = 9;
+        private static final int HEIGHT = 6;
+        private final boolean up;
+
+        Arrow(boolean up) {
+            this.up = up;
+        }
+
+        @Override
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+            Color fg = c == null ? null : c.getForeground();
+            g.setColor(fg != null ? fg : Color.DARK_GRAY);
+            int[] xs = {x, x + WIDTH - 1, x + WIDTH / 2};
+            int[] ys = up ? new int[]{y + HEIGHT - 1, y + HEIGHT - 1, y} : new int[]{y, y, y + HEIGHT - 1};
+            g.fillPolygon(xs, ys, 3);
+        }
+
+        @Override
+        public int getIconWidth() {
+            return WIDTH;
+        }
+
+        @Override
+        public int getIconHeight() {
+            return HEIGHT;
+        }
+    }
+
+    // ---------------------------------------------------------- editors
+
+    /// Refuses a spinner whose model an editor cannot edit, before the
+    /// editor has started listening to it.
+    private static JSpinner checked(JSpinner spinner, boolean suits, String message) {
+        if (!suits) {
+            throw new IllegalArgumentException(message);
+        }
+        return spinner;
+    }
+
+    /// How an editor turns a value into text and text into a value.
+    private static class Codec {
+
+        boolean editable() {
+            return false;
+        }
+
+        String format(Object value) {
+            return value == null ? "" : String.valueOf(value);
+        }
+
+        /// The value `text` stands for; throws when it stands for none.
+        Object parse(String text, SpinnerModel model) throws ParseException {
+            return model.getValue();
+        }
+
+        /// How many characters the field should have room for.
+        int columns(SpinnerModel model) {
+            return format(model.getValue()).length();
+        }
+    }
+
+    private static final class NumberCodec extends Codec {
+        private final DecimalFormat format;
+
+        NumberCodec(DecimalFormat format) {
+            this.format = format;
+        }
+
+        @Override
+        boolean editable() {
+            return true;
+        }
+
+        private static boolean integral(Object o) {
+            return o instanceof Integer || o instanceof Long || o instanceof Short || o instanceof Byte;
+        }
+
+        @Override
+        String format(Object value) {
+            if (integral(value)) {
+                return format.format(((Number) value).longValue());
+            }
+            if (value instanceof Number) {
+                return format.format(((Number) value).doubleValue());
+            }
+            return super.format(value);
+        }
+
+        @Override
+        Object parse(String text, SpinnerModel model) throws ParseException {
+            String t = text.trim();
+            ParsePosition pos = new ParsePosition(0);
+            Number n = t.length() == 0 ? null : format.parse(t, pos);
+            if (n == null || pos.getIndex() != t.length()) {
+                throw new ParseException(text, pos.getIndex());
+            }
+            Object current = model.getValue();
+            Number v;
+            if (current instanceof Integer) {
+                v = Integer.valueOf(n.intValue());
+            } else if (current instanceof Long) {
+                v = Long.valueOf(n.longValue());
+            } else if (current instanceof Float) {
+                v = Float.valueOf(n.floatValue());
+            } else if (current instanceof Short) {
+                v = Short.valueOf(n.shortValue());
+            } else if (current instanceof Byte) {
+                v = Byte.valueOf(n.byteValue());
+            } else {
+                v = Double.valueOf(n.doubleValue());
+            }
+            if (model instanceof SpinnerNumberModel) {
+                SpinnerNumberModel m = (SpinnerNumberModel) model;
+                if ((m.getMinimum() != null && SpinnerNumberModel.compare(m.getMinimum(), v) > 0)
+                        || (m.getMaximum() != null && SpinnerNumberModel.compare(m.getMaximum(), v) < 0)) {
+                    throw new ParseException(text, 0);
+                }
+            }
+            return v;
+        }
+
+        @Override
+        int columns(SpinnerModel model) {
+            int most = format(model.getValue()).length();
+            if (model instanceof SpinnerNumberModel) {
+                SpinnerNumberModel m = (SpinnerNumberModel) model;
+                if (m.getMinimum() instanceof Number) {
+                    most = Math.max(most, format(m.getMinimum()).length());
+                }
+                if (m.getMaximum() instanceof Number) {
+                    most = Math.max(most, format(m.getMaximum()).length());
+                }
+            }
+            return most;
+        }
+    }
+
+    private static final class ListCodec extends Codec {
+
+        @Override
+        boolean editable() {
+            return true;
+        }
+
+        @Override
+        Object parse(String text, SpinnerModel model) throws ParseException {
+            if (model instanceof SpinnerListModel) {
+                List<?> list = ((SpinnerListModel) model).getList();
+                for (int i = 0; i < list.size(); i++) {
+                    Object o = list.get(i);
+                    if (format(o).equals(text)) {
+                        return o;
+                    }
+                }
+            }
+            throw new ParseException(text, 0);
+        }
+
+        @Override
+        int columns(SpinnerModel model) {
+            int most = 0;
+            if (model instanceof SpinnerListModel) {
+                List<?> list = ((SpinnerListModel) model).getList();
+                for (int i = 0; i < list.size(); i++) {
+                    most = Math.max(most, format(list.get(i)).length());
+                }
+            }
+            return most;
+        }
+    }
+
+    private static final class DateCodec extends Codec {
+        private final SimpleDateFormat format;
+
+        DateCodec(SimpleDateFormat format) {
+            this.format = format;
+        }
+
+        @Override
+        boolean editable() {
+            return true;
+        }
+
+        @Override
+        String format(Object value) {
+            if (value instanceof Date) {
+                return format.format((Date) value);
+            }
+            return super.format(value);
+        }
+
+        @Override
+        Object parse(String text, SpinnerModel model) throws ParseException {
+            Date d = format.parse(text.trim());
+            if (d == null) {
+                throw new ParseException(text, 0);
+            }
+            if (model instanceof SpinnerDateModel) {
+                SpinnerDateModel m = (SpinnerDateModel) model;
+                if ((m.getStart() instanceof Date && ((Date) m.getStart()).getTime() > d.getTime())
+                        || (m.getEnd() instanceof Date && ((Date) m.getEnd()).getTime() < d.getTime())) {
+                    throw new ParseException(text, 0);
+                }
+            }
+            return d;
+        }
+    }
+
+    /// The editor of a spinner whose model is none of the three kinds the
+    /// other editors know: a text field that shows the value and cannot be
+    /// edited. It follows the spinner's value until it is dismissed.
+    public static class DefaultEditor extends JPanel implements PropertyChangeListener, ChangeListener,
+            LayoutManager {
+
+        private final JFormattedTextField field = new JFormattedTextField();
+        private final Codec codec;
+        private final Relay relay = new Relay(this);
+
+        public DefaultEditor(JSpinner spinner) {
+            this(spinner, new Codec());
+        }
+
+        DefaultEditor(JSpinner spinner, Codec codec) {
+            super(null);
+            this.codec = codec;
+            setOpaque(false);
+            field.setName("Spinner.formattedTextField");
+            field.setEditable(codec.editable());
+            field.setColumns(Math.max(3, codec.columns(spinner.getModel())));
+            field.setText(codec.format(spinner.getValue()));
+            field.addActionListener(new Commit(this));
+            add(field);
+            // Handing out the editor itself from its constructor would let
+            // a subclass be called before it is built, so both go through
+            // a relay.
+            setLayout(relay);
+            spinner.addChangeListener(relay);
+        }
+
+        /// The field the value is shown and typed in. It has no formatter of
+        /// its own: the editor formats and parses the value.
+        public JFormattedTextField getTextField() {
+            return field;
+        }
+
+        /// The text field, for the spinner and the tests.
+        JTextField cn1Field() {
+            return field;
+        }
+
+        void show(Object value) {
+            field.setText(codec.format(value));
+        }
+
+        /// Stops following `spinner`.
+        public void dismiss(JSpinner spinner) {
+            spinner.removeChangeListener(relay);
+        }
+
+        /// The spinner this editor is in, or `null`.
+        public JSpinner getSpinner() {
+            for (Component c = this; c != null; c = c.getParent()) {
+                if (c instanceof JSpinner) {
+                    return (JSpinner) c;
+                }
+            }
+            return null;
+        }
+
+        /// Shows the spinner's new value.
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            Object source = e.getSource();
+            if (source instanceof JSpinner) {
+                show(((JSpinner) source).getValue());
+            }
+        }
+
+        /// Does nothing: the text field reports no property changes.
+        @Override
+        public void propertyChange(PropertyChangeEvent e) {
+        }
+
+        @Override
+        public void addLayoutComponent(String name, Component child) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component child) {
+        }
+
+        private Dimension grown(Dimension d) {
+            Insets in = getInsets();
+            return new Dimension(d.width + in.left + in.right, d.height + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            return grown(field.getPreferredSize());
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return grown(field.getMinimumSize());
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            Insets in = getInsets();
+            field.setBounds(in.left, in.top, Math.max(0, getWidth() - in.left - in.right),
+                    Math.max(0, getHeight() - in.top - in.bottom));
+        }
+
+        /// Parses the text into the spinner's model and shows the value
+        /// the model then has. A value the model refuses is dropped.
+        public void commitEdit() throws ParseException {
+            JSpinner spinner = getSpinner();
+            if (spinner == null || !codec.editable()) {
+                return;
+            }
+            Object v = codec.parse(field.getText(), spinner.getModel());
+            try {
+                spinner.setValue(v);
+            } catch (IllegalArgumentException refused) {
+                show(spinner.getValue());
+                return;
+            }
+            show(spinner.getValue());
+        }
+
+        /// Enter in the text field: take the text in, or put the value
+        /// back when the text stands for none.
+        void cn1Accept() {
+            try {
+                commitEdit();
+            } catch (ParseException e) {
+                JSpinner spinner = getSpinner();
+                if (spinner != null) {
+                    show(spinner.getValue());
+                }
+            }
+        }
+    }
+
+    /// Passes the spinner's changes and the editor's layout on to an
+    /// editor.
+    private static final class Relay implements ChangeListener, LayoutManager {
+        private final DefaultEditor target;
+
+        Relay(DefaultEditor target) {
+            this.target = target;
+        }
+
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            target.stateChanged(e);
+        }
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+            target.addLayoutComponent(name, comp);
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+            target.removeLayoutComponent(comp);
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            return target.preferredLayoutSize(parent);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return target.minimumLayoutSize(parent);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            target.layoutContainer(parent);
+        }
+    }
+
+    private static final class Commit implements ActionListener {
+        private final DefaultEditor target;
+
+        Commit(DefaultEditor target) {
+            this.target = target;
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            target.cn1Accept();
+        }
+    }
+
+    /// The editor of a spinner over numbers: the number in a decimal
+    /// format, by default with grouping and up to three fraction digits.
+    public static class NumberEditor extends DefaultEditor {
+
+        private final DecimalFormat format;
+
+        public NumberEditor(JSpinner spinner) {
+            this(spinner, NUMBER_PATTERN);
+        }
+
+        public NumberEditor(JSpinner spinner, String decimalFormatPattern) {
+            this(spinner, new DecimalFormat(decimalFormatPattern));
+        }
+
+        private NumberEditor(JSpinner spinner, DecimalFormat format) {
+            super(checked(spinner, spinner.getModel() instanceof SpinnerNumberModel,
+                    "model not a SpinnerNumberModel"), new NumberCodec(format));
+            this.format = format;
+        }
+
+        public DecimalFormat getFormat() {
+            return format;
+        }
+
+        public SpinnerNumberModel getModel() {
+            JSpinner spinner = getSpinner();
+            SpinnerModel m = spinner == null ? null : spinner.getModel();
+            return m instanceof SpinnerNumberModel ? (SpinnerNumberModel) m : null;
+        }
+    }
+
+    /// The editor of a spinner over dates: the date in a simple date
+    /// format.
+    public static class DateEditor extends DefaultEditor {
+
+        private final SimpleDateFormat format;
+
+        public DateEditor(JSpinner spinner) {
+            this(spinner, DATE_PATTERN);
+        }
+
+        public DateEditor(JSpinner spinner, String dateFormatPattern) {
+            this(spinner, new SimpleDateFormat(dateFormatPattern));
+        }
+
+        private DateEditor(JSpinner spinner, SimpleDateFormat format) {
+            super(checked(spinner, spinner.getModel() instanceof SpinnerDateModel,
+                    "model not a SpinnerDateModel"), new DateCodec(format));
+            this.format = format;
+        }
+
+        public SimpleDateFormat getFormat() {
+            return format;
+        }
+
+        public SpinnerDateModel getModel() {
+            JSpinner spinner = getSpinner();
+            SpinnerModel m = spinner == null ? null : spinner.getModel();
+            return m instanceof SpinnerDateModel ? (SpinnerDateModel) m : null;
+        }
+    }
+
+    /// The editor of a spinner over a list: the text of the element, and
+    /// text typed is taken when it is the text of an element.
+    public static class ListEditor extends DefaultEditor {
+
+        public ListEditor(JSpinner spinner) {
+            super(checked(spinner, spinner.getModel() instanceof SpinnerListModel,
+                    "model not a SpinnerListModel"), new ListCodec());
+        }
+
+        public SpinnerListModel getModel() {
+            JSpinner spinner = getSpinner();
+            SpinnerModel m = spinner == null ? null : spinner.getModel();
+            return m instanceof SpinnerListModel ? (SpinnerListModel) m : null;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSplitPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSplitPane.java
new file mode 100644
index 00000000000..874e4d42fc7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JSplitPane.java
@@ -0,0 +1,805 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+
+/// Two components side by side, or one above the other, with a divider
+/// between them that the user drags.
+///
+/// The divider is drawn and dragged by this component itself. Layout
+/// follows the desktop: until a location is set the first component gets
+/// its preferred size, a resize hands the extra space out by the resize
+/// weight, a location set by the program is limited only by the pane, and
+/// a drag stops at the components' minimum sizes. After a layout
+/// `getDividerLocation()` answers where the divider is. Without continuous
+/// layout a drag shows a line and the components move on release.
+///
+/// The divider is as wide as `getDividerSize()` says; a press within a
+/// few pixels of it also grabs it when no component there takes the
+/// press, since a finger is wider than a mouse pointer. With one touch
+/// expansion two arrows are drawn on the divider, and pressing one
+/// collapses a side or brings the divider back.
+///
+/// Not supported: a look and feel divider component, key bindings, and
+/// nested split panes sharing one border.
+public class JSplitPane extends JComponent implements Accessible {
+
+    public static final int VERTICAL_SPLIT = 0;
+    public static final int HORIZONTAL_SPLIT = 1;
+    public static final String LEFT = "left";
+    public static final String RIGHT = "right";
+    public static final String TOP = "top";
+    public static final String BOTTOM = "bottom";
+    public static final String DIVIDER = "divider";
+    public static final String ORIENTATION_PROPERTY = "orientation";
+    public static final String CONTINUOUS_LAYOUT_PROPERTY = "continuousLayout";
+    public static final String DIVIDER_SIZE_PROPERTY = "dividerSize";
+    public static final String ONE_TOUCH_EXPANDABLE_PROPERTY = "oneTouchExpandable";
+    public static final String LAST_DIVIDER_LOCATION_PROPERTY = "lastDividerLocation";
+    public static final String DIVIDER_LOCATION_PROPERTY = "dividerLocation";
+    public static final String RESIZE_WEIGHT_PROPERTY = "resizeWeight";
+
+    private static final int GRAB_SLOP = 6;
+    private static final int ARROW = 6;
+
+    protected int orientation;
+    protected boolean continuousLayout;
+    protected Component leftComponent;
+    protected Component rightComponent;
+    protected int dividerSize = cn1DefaultDividerSize();
+
+    /// The look and feel's width of a divider: one to press with a finger
+    /// on a touch screen, a thin one to drag with a mouse.
+    private static int cn1DefaultDividerSize() {
+        Object v = com.codename1.desktopcompat.rt.LafTheme.value("SplitPane.dividerSize");
+        return v instanceof Integer ? ((Integer) v).intValue() : 10;
+    }
+    protected boolean oneTouchExpandable;
+    protected int lastDividerLocation;
+
+    private double resizeWeight;
+    private int dividerLocation = -1;
+
+    /// Whether the location is to be applied by the next layout.
+    private boolean locationPending;
+    /// The size of the first component and the space both shared in the
+    /// last layout; -1 before the first one.
+    private int firstSize = -1;
+    private int lastAvailable = -1;
+    /// Where the divider is drawn: its offset along the split axis.
+    private int dividerAt;
+
+    private boolean dragging;
+    private int dragOffset;
+    private int dragLocation = -1;
+
+    public JSplitPane() {
+        this(HORIZONTAL_SPLIT, false, new JButton("left button"), new JButton("right button"));
+    }
+
+    public JSplitPane(int newOrientation) {
+        this(newOrientation, false);
+    }
+
+    public JSplitPane(int newOrientation, boolean newContinuousLayout) {
+        this(newOrientation, newContinuousLayout, null, null);
+    }
+
+    public JSplitPane(int newOrientation, Component newLeftComponent, Component newRightComponent) {
+        this(newOrientation, false, newLeftComponent, newRightComponent);
+    }
+
+    public JSplitPane(int newOrientation, boolean newContinuousLayout, Component newLeftComponent,
+            Component newRightComponent) {
+        if (newOrientation != HORIZONTAL_SPLIT && newOrientation != VERTICAL_SPLIT) {
+            throw new IllegalArgumentException("cannot create JSplitPane, orientation must be one of "
+                    + "JSplitPane.HORIZONTAL_SPLIT or JSplitPane.VERTICAL_SPLIT");
+        }
+        orientation = newOrientation;
+        continuousLayout = newContinuousLayout;
+        // A split pane fills its own area, as every look and feel has it:
+        // a side smaller than its half is surrounded by the pane's
+        // background, not by whatever the pane happens to stand on.
+        setOpaque(true);
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
+        if (newLeftComponent != null) {
+            setLeftComponent(newLeftComponent);
+        }
+        if (newRightComponent != null) {
+            setRightComponent(newRightComponent);
+        }
+        bind(KeyEvent.VK_LEFT, "negativeIncrement", Nudge.BACK);
+        bind(KeyEvent.VK_UP, "negativeIncrement", Nudge.BACK);
+        bind(KeyEvent.VK_RIGHT, "positiveIncrement", Nudge.FORWARD);
+        bind(KeyEvent.VK_DOWN, "positiveIncrement", Nudge.FORWARD);
+        bind(KeyEvent.VK_HOME, "selectMin", Nudge.MIN);
+        bind(KeyEvent.VK_END, "selectMax", Nudge.MAX);
+    }
+
+    private void bind(int key, String name, int kind) {
+        getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(KeyStroke.getKeyStroke(key, 0), name);
+        if (getActionMap().get(name) == null) {
+            getActionMap().put(name, new Nudge(this, kind));
+        }
+    }
+
+    /// Moves the divider with the keyboard. As on the desktop the keys
+    /// are the pane's only while the pane itself has the focus, which it
+    /// gets from `requestFocusInWindow()`; a focused child keeps its
+    /// arrow keys.
+    private static final class Nudge extends AbstractAction {
+
+        static final int BACK = 0;
+        static final int FORWARD = 1;
+        static final int MIN = 2;
+        static final int MAX = 3;
+        private static final int STEP = 10;
+
+        private final JSplitPane pane;
+        private final int kind;
+
+        Nudge(JSplitPane pane, int kind) {
+            this.pane = pane;
+            this.kind = kind;
+        }
+
+        @Override
+        public boolean isEnabled() {
+            return pane.isFocusOwner();
+        }
+
+        @Override
+        public void actionPerformed(com.codename1.desktopcompat.java.awt.event.ActionEvent e) {
+            int min = pane.getMinimumDividerLocation();
+            int max = pane.getMaximumDividerLocation();
+            int at = pane.getDividerLocation();
+            int to = kind == MIN ? min : kind == MAX ? max : kind == BACK ? at - STEP : at + STEP;
+            pane.setDividerLocation(Math.max(min, Math.min(max, to)));
+        }
+    }
+
+    // ------------------------------------------------------------ children
+
+    public void setLeftComponent(Component comp) {
+        if (comp == null) {
+            if (leftComponent != null) {
+                remove(leftComponent);
+                leftComponent = null;
+            }
+        } else {
+            add(comp, LEFT);
+        }
+    }
+
+    public Component getLeftComponent() {
+        return leftComponent;
+    }
+
+    public void setTopComponent(Component comp) {
+        setLeftComponent(comp);
+    }
+
+    public Component getTopComponent() {
+        return leftComponent;
+    }
+
+    public void setRightComponent(Component comp) {
+        if (comp == null) {
+            if (rightComponent != null) {
+                remove(rightComponent);
+                rightComponent = null;
+            }
+        } else {
+            add(comp, RIGHT);
+        }
+    }
+
+    public Component getRightComponent() {
+        return rightComponent;
+    }
+
+    public void setBottomComponent(Component comp) {
+        setRightComponent(comp);
+    }
+
+    public Component getBottomComponent() {
+        return rightComponent;
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (constraints != null && !(constraints instanceof String)) {
+            throw new IllegalArgumentException("cannot add to layout: constraint must be a string (or null)");
+        }
+        Object where = constraints;
+        if (where == null) {
+            if (leftComponent == null) {
+                where = LEFT;
+            } else if (rightComponent == null) {
+                where = RIGHT;
+            }
+        }
+        int at = index;
+        if (LEFT.equals(where) || TOP.equals(where)) {
+            Component toRemove = leftComponent;
+            if (toRemove != null) {
+                remove(toRemove);
+            }
+            leftComponent = comp;
+            at = -1;
+        } else if (RIGHT.equals(where) || BOTTOM.equals(where)) {
+            Component toRemove = rightComponent;
+            if (toRemove != null) {
+                remove(toRemove);
+            }
+            rightComponent = comp;
+            at = -1;
+        }
+        super.addImpl(comp, where, at);
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public void remove(Component component) {
+        if (component == leftComponent) {
+            leftComponent = null;
+        } else if (component == rightComponent) {
+            rightComponent = null;
+        }
+        super.remove(component);
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public void remove(int index) {
+        Component comp = getComponent(index);
+        if (comp == leftComponent) {
+            leftComponent = null;
+        } else if (comp == rightComponent) {
+            rightComponent = null;
+        }
+        super.remove(index);
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public void removeAll() {
+        leftComponent = null;
+        rightComponent = null;
+        super.removeAll();
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public boolean isValidateRoot() {
+        return true;
+    }
+
+    // ------------------------------------------------------------ properties
+
+    public void setDividerSize(int newSize) {
+        int old = dividerSize;
+        if (old != newSize) {
+            dividerSize = newSize;
+            firePropertyChange(DIVIDER_SIZE_PROPERTY, old, newSize);
+            revalidate();
+            repaint();
+        }
+    }
+
+    public int getDividerSize() {
+        return dividerSize;
+    }
+
+    public void setOneTouchExpandable(boolean newValue) {
+        boolean old = oneTouchExpandable;
+        oneTouchExpandable = newValue;
+        firePropertyChange(ONE_TOUCH_EXPANDABLE_PROPERTY, old, newValue);
+        repaint();
+    }
+
+    public boolean isOneTouchExpandable() {
+        return oneTouchExpandable;
+    }
+
+    public void setLastDividerLocation(int newLastLocation) {
+        int old = lastDividerLocation;
+        lastDividerLocation = newLastLocation;
+        firePropertyChange(LAST_DIVIDER_LOCATION_PROPERTY, old, newLastLocation);
+    }
+
+    public int getLastDividerLocation() {
+        return lastDividerLocation;
+    }
+
+    public void setOrientation(int orientation) {
+        if (orientation != VERTICAL_SPLIT && orientation != HORIZONTAL_SPLIT) {
+            throw new IllegalArgumentException("JSplitPane: orientation must be one of "
+                    + "JSplitPane.VERTICAL_SPLIT or JSplitPane.HORIZONTAL_SPLIT");
+        }
+        int old = this.orientation;
+        this.orientation = orientation;
+        firePropertyChange(ORIENTATION_PROPERTY, old, orientation);
+        if (old != orientation) {
+            firstSize = -1;
+            lastAvailable = -1;
+            locationPending = dividerLocation >= 0;
+            revalidate();
+            repaint();
+        }
+    }
+
+    public int getOrientation() {
+        return orientation;
+    }
+
+    public void setContinuousLayout(boolean newContinuousLayout) {
+        boolean old = continuousLayout;
+        continuousLayout = newContinuousLayout;
+        firePropertyChange(CONTINUOUS_LAYOUT_PROPERTY, old, newContinuousLayout);
+    }
+
+    public boolean isContinuousLayout() {
+        return continuousLayout;
+    }
+
+    public void setResizeWeight(double value) {
+        if (value < 0 || value > 1) {
+            throw new IllegalArgumentException("JSplitPane weight must be between 0 and 1");
+        }
+        double old = resizeWeight;
+        resizeWeight = value;
+        firePropertyChange(RESIZE_WEIGHT_PROPERTY, Double.valueOf(old), Double.valueOf(value));
+    }
+
+    public double getResizeWeight() {
+        return resizeWeight;
+    }
+
+    /// Forgets the divider location: the next layout gives the components
+    /// their preferred sizes again.
+    public void resetToPreferredSizes() {
+        firstSize = -1;
+        lastAvailable = -1;
+        locationPending = false;
+        dividerLocation = -1;
+        revalidate();
+        repaint();
+    }
+
+    public void setDividerLocation(double proportionalLocation) {
+        if (proportionalLocation < 0.0 || proportionalLocation > 1.0) {
+            throw new IllegalArgumentException("proportional location must be between 0.0 and 1.0.");
+        }
+        if (orientation == VERTICAL_SPLIT) {
+            setDividerLocation((int) ((double) (getHeight() - getDividerSize()) * proportionalLocation));
+        } else {
+            setDividerLocation((int) ((double) (getWidth() - getDividerSize()) * proportionalLocation));
+        }
+    }
+
+    public void setDividerLocation(int location) {
+        int old = dividerLocation;
+        dividerLocation = location;
+        locationPending = location >= 0;
+        if (location < 0) {
+            firstSize = -1;
+            lastAvailable = -1;
+        }
+        revalidate();
+        repaint();
+        firePropertyChange(DIVIDER_LOCATION_PROPERTY, old, location);
+        setLastDividerLocation(old);
+    }
+
+    public int getDividerLocation() {
+        return dividerLocation;
+    }
+
+    public int getMinimumDividerLocation() {
+        int min = 0;
+        if (leftComponent != null && leftComponent.isVisible()) {
+            Insets in = getInsets();
+            Dimension d = leftComponent.getMinimumSize();
+            min = horizontal() ? d.width + in.left : d.height + in.top;
+        }
+        return min;
+    }
+
+    public int getMaximumDividerLocation() {
+        int max = 0;
+        if (rightComponent != null) {
+            Insets in = getInsets();
+            Dimension d = rightComponent.isVisible() ? rightComponent.getMinimumSize() : new Dimension(0, 0);
+            if (horizontal()) {
+                max = getWidth() - d.width - dividerSize - in.right;
+            } else {
+                max = getHeight() - d.height - dividerSize - in.bottom;
+            }
+        }
+        return Math.max(getMinimumDividerLocation(), max);
+    }
+
+    // ------------------------------------------------------------ layout
+
+    private boolean horizontal() {
+        return orientation == HORIZONTAL_SPLIT;
+    }
+
+    private static int along(Dimension d, boolean horizontal) {
+        return horizontal ? d.width : d.height;
+    }
+
+    private static boolean shown(Component c) {
+        return c != null && c.isVisible();
+    }
+
+    /// Hands `space`, which may be negative, to the two sizes by the
+    /// resize weight, keeping each at its minimum where both can be.
+    private int[] distribute(int first, int second, int space) {
+        boolean h = horizontal();
+        boolean lv = shown(leftComponent);
+        boolean rv = shown(rightComponent);
+        int[] sizes = {first, second};
+        if (lv && rv) {
+            int lExtra = (int) (resizeWeight * (double) space);
+            int rExtra = space - lExtra;
+            sizes[0] += lExtra;
+            sizes[1] += rExtra;
+            int lMin = along(leftComponent.getMinimumSize(), h);
+            int rMin = along(rightComponent.getMinimumSize(), h);
+            boolean lOk = sizes[0] >= lMin;
+            boolean rOk = sizes[1] >= rMin;
+            if (!lOk && !rOk) {
+                if (sizes[0] < 0) {
+                    sizes[1] += sizes[0];
+                    sizes[0] = 0;
+                } else if (sizes[1] < 0) {
+                    sizes[0] += sizes[1];
+                    sizes[1] = 0;
+                }
+            } else if (!lOk) {
+                if (sizes[1] - (lMin - sizes[0]) < rMin) {
+                    if (sizes[0] < 0) {
+                        sizes[1] += sizes[0];
+                        sizes[0] = 0;
+                    }
+                } else {
+                    sizes[1] -= lMin - sizes[0];
+                    sizes[0] = lMin;
+                }
+            } else if (!rOk) {
+                if (sizes[0] - (rMin - sizes[1]) < lMin) {
+                    if (sizes[1] < 0) {
+                        sizes[0] += sizes[1];
+                        sizes[1] = 0;
+                    }
+                } else {
+                    sizes[0] -= rMin - sizes[1];
+                    sizes[1] = rMin;
+                }
+            }
+            if (sizes[0] < 0) {
+                sizes[0] = 0;
+            }
+            if (sizes[1] < 0) {
+                sizes[1] = 0;
+            }
+        } else if (lv) {
+            sizes[0] = Math.max(0, first + space);
+        } else if (rv) {
+            sizes[1] = Math.max(0, second + space);
+        }
+        return sizes;
+    }
+
+    @Override
+    public void doLayout() {
+        if (getWidth() <= 0 || getHeight() <= 0) {
+            // Not sized yet: nothing to share out, and nothing to remember.
+            return;
+        }
+        boolean h = horizontal();
+        Insets in = getInsets();
+        int start = h ? in.left : in.top;
+        int total = h ? getWidth() - in.left - in.right : getHeight() - in.top - in.bottom;
+        int across = h ? getHeight() - in.top - in.bottom : getWidth() - in.left - in.right;
+        int available = Math.max(0, total - dividerSize);
+        boolean lv = shown(leftComponent);
+        boolean rv = shown(rightComponent);
+        int first;
+        int second;
+        if (locationPending) {
+            int want = Math.max(0, Math.min(dividerLocation - start, available));
+            if (lv && rv) {
+                first = want;
+                second = available - want;
+            } else if (lv) {
+                first = available;
+                second = 0;
+            } else {
+                first = 0;
+                second = rv ? available : 0;
+            }
+        } else if (firstSize < 0) {
+            first = lv ? along(leftComponent.getPreferredSize(), h) : 0;
+            second = rv ? along(rightComponent.getPreferredSize(), h) : 0;
+            int[] sizes = distribute(first, second, available - first - second);
+            first = sizes[0];
+            second = sizes[1];
+        } else if (available != lastAvailable) {
+            int[] sizes = distribute(firstSize, Math.max(0, lastAvailable - firstSize), available - lastAvailable);
+            first = sizes[0];
+            second = sizes[1];
+        } else {
+            first = firstSize;
+            second = Math.max(0, available - first);
+        }
+        locationPending = false;
+        firstSize = first;
+        lastAvailable = available;
+        dividerAt = start + first;
+        int secondAt = dividerAt + dividerSize;
+        if (leftComponent != null) {
+            if (h) {
+                leftComponent.setBounds(start, in.top, first, Math.max(0, across));
+            } else {
+                leftComponent.setBounds(in.left, start, Math.max(0, across), first);
+            }
+        }
+        if (rightComponent != null) {
+            if (h) {
+                rightComponent.setBounds(secondAt, in.top, second, Math.max(0, across));
+            } else {
+                rightComponent.setBounds(in.left, secondAt, Math.max(0, across), second);
+            }
+        }
+        if (dividerLocation != dividerAt) {
+            int old = dividerLocation;
+            dividerLocation = dividerAt;
+            firePropertyChange(DIVIDER_LOCATION_PROPERTY, old, dividerAt);
+        }
+    }
+
+    private Dimension size(boolean minimum) {
+        boolean h = horizontal();
+        int main = 0;
+        int cross = 0;
+        Component[] both = {leftComponent, rightComponent};
+        for (int i = 0; i < both.length; i++) {
+            if (shown(both[i])) {
+                Dimension d = minimum ? both[i].getMinimumSize() : both[i].getPreferredSize();
+                main += along(d, h);
+                cross = Math.max(cross, along(d, !h));
+            }
+        }
+        main += dividerSize;
+        Insets in = getInsets();
+        if (h) {
+            return new Dimension(main + in.left + in.right, cross + in.top + in.bottom);
+        }
+        return new Dimension(cross + in.left + in.right, main + in.top + in.bottom);
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        return size(false);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return size(true);
+    }
+
+    // ------------------------------------------------------------ painting
+
+    private static void triangle(Graphics g, int cx, int cy, int dx, int dy) {
+        int s = ARROW / 2;
+        int[] xs;
+        int[] ys;
+        if (dx != 0) {
+            xs = new int[]{cx + dx * s, cx - dx * s, cx - dx * s};
+            ys = new int[]{cy, cy - s, cy + s};
+        } else {
+            xs = new int[]{cx, cx - s, cx + s};
+            ys = new int[]{cy + dy * s, cy - dy * s, cy - dy * s};
+        }
+        g.fillPolygon(xs, ys, 3);
+    }
+
+    private Color dividerColor() {
+        Color bg = getBackground();
+        if (bg == null) {
+            return Color.LIGHT_GRAY;
+        }
+        if (!com.codename1.desktopcompat.rt.CellTheme.touch()) {
+            // A divider dragged with a mouse is a gap between the two
+            // sides with a grip in it, not a bar.
+            return bg;
+        }
+        int lum = (bg.getRed() * 3 + bg.getGreen() * 6 + bg.getBlue()) / 10;
+        return lum > 128 ? bg.darker() : bg.brighter();
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        if (dividerSize <= 0) {
+            return;
+        }
+        boolean h = horizontal();
+        Insets in = getInsets();
+        Color c = dividerColor();
+        g.setColor(c);
+        int x = h ? dividerAt : in.left;
+        int y = h ? in.top : dividerAt;
+        int w = h ? dividerSize : getWidth() - in.left - in.right;
+        int hh = h ? getHeight() - in.top - in.bottom : dividerSize;
+        g.fillRect(x, y, w, hh);
+        int lum = (c.getRed() * 3 + c.getGreen() * 6 + c.getBlue()) / 10;
+        g.setColor(com.codename1.desktopcompat.rt.CellTheme.touch()
+                ? (lum > 128 ? c.darker().darker() : c.brighter().brighter())
+                : com.codename1.desktopcompat.rt.LafTheme.disabledText());
+        // A grip in the middle of the divider.
+        int mx = x + w / 2;
+        int my = y + hh / 2;
+        for (int i = -1; i <= 1; i++) {
+            if (h) {
+                g.fillRect(mx - 1, my + i * 6 - 1, 2, 2);
+            } else {
+                g.fillRect(mx + i * 6 - 1, my - 1, 2, 2);
+            }
+        }
+        if (oneTouchExpandable) {
+            if (h) {
+                triangle(g, mx, y + 2 + ARROW / 2, -1, 0);
+                triangle(g, mx, y + 4 + ARROW + ARROW / 2, 1, 0);
+            } else {
+                triangle(g, x + 2 + ARROW / 2, my, 0, -1);
+                triangle(g, x + 4 + ARROW + ARROW / 2, my, 0, 1);
+            }
+        }
+    }
+
+    @Override
+    protected void paintChildren(Graphics g) {
+        super.paintChildren(g);
+        if (dragging && !continuousLayout && dragLocation >= 0) {
+            g.setColor(Color.DARK_GRAY);
+            if (horizontal()) {
+                g.fillRect(dragLocation, 0, Math.max(1, dividerSize), getHeight());
+            } else {
+                g.fillRect(0, dragLocation, getWidth(), Math.max(1, dividerSize));
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ dragging
+
+    /// Which one touch arrow is at a point of the divider: -1 for the one
+    /// toward the first component, 1 for the other, 0 for neither.
+    private int arrowAt(int x, int y) {
+        if (!oneTouchExpandable) {
+            return 0;
+        }
+        Insets in = getInsets();
+        int p = horizontal() ? y - in.top : x - in.left;
+        if (p >= 0 && p < 3 + ARROW) {
+            return -1;
+        }
+        if (p >= 3 + ARROW && p < 6 + 2 * ARROW) {
+            return 1;
+        }
+        return 0;
+    }
+
+    private void oneTouch(int arrow) {
+        Insets in = getInsets();
+        boolean h = horizontal();
+        int start = h ? in.left : in.top;
+        int end = (h ? getWidth() - in.right : getHeight() - in.bottom) - dividerSize;
+        int current = dividerAt;
+        int max = getMaximumDividerLocation();
+        int to;
+        if (arrow < 0) {
+            to = current >= end ? Math.min(lastDividerLocation, max) : start;
+        } else {
+            to = current <= start ? Math.min(lastDividerLocation, max) : end;
+        }
+        if (to != current) {
+            setDividerLocation(Math.max(start, to));
+            validate();
+        }
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        boolean h = horizontal();
+        int p = h ? e.getX() : e.getY();
+        if (e.getID() == MouseEvent.MOUSE_PRESSED && isEnabled()) {
+            if (p >= dividerAt - GRAB_SLOP && p < dividerAt + dividerSize + GRAB_SLOP) {
+                int arrow = p >= dividerAt && p < dividerAt + dividerSize ? arrowAt(e.getX(), e.getY()) : 0;
+                if (arrow != 0) {
+                    oneTouch(arrow);
+                } else {
+                    dragging = true;
+                    dragOffset = p - dividerAt;
+                    dragLocation = dividerAt;
+                }
+            }
+        } else if (e.getID() == MouseEvent.MOUSE_RELEASED && dragging) {
+            dragging = false;
+            int to = dragLocation;
+            dragLocation = -1;
+            if (!continuousLayout && to >= 0 && to != dividerAt) {
+                setDividerLocation(to);
+                validate();
+            }
+            repaint();
+        }
+        super.processMouseEvent(e);
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        if (e.getID() == MouseEvent.MOUSE_DRAGGED && dragging) {
+            int p = horizontal() ? e.getX() : e.getY();
+            int to = Math.max(getMinimumDividerLocation(), Math.min(getMaximumDividerLocation(), p - dragOffset));
+            if (to != dragLocation) {
+                dragLocation = to;
+                if (continuousLayout) {
+                    setDividerLocation(to);
+                    validate();
+                } else {
+                    repaint();
+                }
+            }
+        }
+        super.processMouseMotionEvent(e);
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",orientation=" + (horizontal() ? "HORIZONTAL_SPLIT" : "VERTICAL_SPLIT")
+                + ",dividerSize=" + dividerSize;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTabbedPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTabbedPane.java
new file mode 100644
index 00000000000..f55aa6b013a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTabbedPane.java
@@ -0,0 +1,870 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.Icons;
+import com.codename1.desktopcompat.rt.MiniHtml;
+import com.codename1.desktopcompat.rt.TabbedPanePeer;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+
+/// Pages behind a row of tabs, one page showing at a time.
+///
+/// The tabs are Codename One tab buttons, so they look and respond to
+/// touch as the platform's tabs do; the pages are ordinary children of
+/// this component, all given the area beside the tabs, with only the
+/// selected one visible. Selection goes through the model and fires one
+/// change event per change, whether the application or the user made it.
+///
+/// Not supported: the tab layout policy is recorded and the tabs always
+/// scroll when they do not fit; a tab component is not shown in the tab,
+/// though a `JLabel` given as one lends the tab its text and icon; tool
+/// tips, mnemonics and the per tab colors and disabled icons are recorded
+/// only; HTML titles are shown without their tags.
+public class JTabbedPane extends JComponent implements Accessible, SwingConstants {
+
+    public static final int WRAP_TAB_LAYOUT = 0;
+    public static final int SCROLL_TAB_LAYOUT = 1;
+
+    protected int tabPlacement = TOP;
+    protected SingleSelectionModel model;
+    protected ChangeEvent changeEvent;
+
+    private final ArrayList<Page> pages = new ArrayList<Page>();
+    private final ModelHandler handler = new ModelHandler();
+    private int tabLayoutPolicy;
+    private Component visComp;
+
+    /// What is known about one tab.
+    private static final class Page {
+        String title;
+        Icon icon;
+        Icon disabledIcon;
+        Component component;
+        Component tabComponent;
+        String tip;
+        boolean enabled = true;
+        Color background;
+        Color foreground;
+        int mnemonic = -1;
+        int mnemonicIndex = -1;
+        Icon nativeIconFor;
+        com.codename1.ui.Image nativeIcon;
+    }
+
+    public JTabbedPane() {
+        this(TOP, WRAP_TAB_LAYOUT);
+    }
+
+    public JTabbedPane(int tabPlacement) {
+        this(tabPlacement, WRAP_TAB_LAYOUT);
+    }
+
+    public JTabbedPane(int tabPlacement, int tabLayoutPolicy) {
+        setTabPlacement(tabPlacement);
+        setTabLayoutPolicy(tabLayoutPolicy);
+        setModel(new DefaultSingleSelectionModel());
+    }
+
+    // ------------------------------------------------------------ peer
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new TabbedPanePeer(this, new TabbedPanePeer.Listener() {
+            @Override
+            public void tabChosen(int index) {
+                if (index >= 0 && index < pages.size() && pages.get(index).enabled) {
+                    setSelectedIndex(index);
+                }
+            }
+        });
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof TabbedPanePeer) {
+            ((TabbedPanePeer) p).attachStrip();
+        }
+        syncTabs();
+    }
+
+    private TabbedPanePeer peer() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        return p instanceof TabbedPanePeer ? (TabbedPanePeer) p : null;
+    }
+
+    private String shownTitle(Page page) {
+        String t = page.title;
+        if (page.tabComponent instanceof JLabel) {
+            String lt = ((JLabel) page.tabComponent).getText();
+            if (lt != null) {
+                t = lt;
+            }
+        }
+        return t == null ? "" : MiniHtml.singleLine(t);
+    }
+
+    /// The color a tab's title is written in when it is not the theme's:
+    /// the one set for the tab, and otherwise the first one an HTML title
+    /// asks for. -1 for a tab that leaves it to the theme.
+    private int shownInk(Page page) {
+        if (page.foreground != null) {
+            return page.foreground.getRGB() & 0xffffff;
+        }
+        String t = page.title;
+        if (page.tabComponent instanceof JLabel) {
+            JLabel label = (JLabel) page.tabComponent;
+            if (label.isForegroundSet()) {
+                return label.getForeground().getRGB() & 0xffffff;
+            }
+            if (label.getText() != null) {
+                t = label.getText();
+            }
+        }
+        if (!MiniHtml.isHtml(t)) {
+            return -1;
+        }
+        MiniHtml.Document d = MiniHtml.parse(t);
+        for (int i = 0; i < d.lineCount(); i++) {
+            MiniHtml.Line line = d.line(i);
+            for (int r = 0; r < line.runCount(); r++) {
+                Color c = line.run(r).color();
+                if (c != null) {
+                    return c.getRGB() & 0xffffff;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private Icon shownIcon(Page page) {
+        if (page.tabComponent instanceof JLabel) {
+            Icon li = ((JLabel) page.tabComponent).getIcon();
+            if (li != null) {
+                return li;
+            }
+        }
+        return page.icon;
+    }
+
+    /// Makes the strip of tab buttons show the tabs as they now are.
+    private void syncTabs() {
+        TabbedPanePeer p = peer();
+        if (p == null) {
+            return;
+        }
+        int n = pages.size();
+        String[] titles = new String[n];
+        com.codename1.ui.Image[] icons = new com.codename1.ui.Image[n];
+        boolean[] enabled = new boolean[n];
+        int[] inks = new int[n];
+        for (int i = 0; i < n; i++) {
+            Page page = pages.get(i);
+            titles[i] = shownTitle(page);
+            inks[i] = shownInk(page);
+            Icon ic = shownIcon(page);
+            if (ic == null) {
+                page.nativeIconFor = null;
+                page.nativeIcon = null;
+            } else if (page.nativeIconFor != ic || page.nativeIcon == null) {
+                page.nativeIconFor = ic;
+                page.nativeIcon = Icons.toNative(ic, this);
+            }
+            icons[i] = page.nativeIcon;
+            enabled[i] = page.enabled;
+        }
+        p.setTabs(titles, icons, enabled, inks, getSelectedIndex(), tabPlacement);
+    }
+
+    private void tabsChanged() {
+        syncTabs();
+        revalidate();
+        repaint();
+    }
+
+    // ------------------------------------------------------------ model
+
+    /// Forwards the model's change as this component's.
+    private final class ModelHandler implements ChangeListener {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            fireStateChanged();
+        }
+    }
+
+    public SingleSelectionModel getModel() {
+        return model;
+    }
+
+    public void setModel(SingleSelectionModel model) {
+        SingleSelectionModel old = this.model;
+        if (old != null) {
+            old.removeChangeListener(handler);
+        }
+        this.model = model;
+        if (model != null) {
+            model.addChangeListener(handler);
+        }
+        firePropertyChange("model", old, model);
+        showSelected();
+        repaint();
+    }
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    /// Shows the page of the selected tab and hides the one that was
+    /// showing, then tells the strip.
+    private void showSelected() {
+        int sel = getSelectedIndex();
+        if (sel < 0 || sel >= pages.size()) {
+            if (visComp != null && visComp.isVisible()) {
+                visComp.setVisible(false);
+            }
+            visComp = null;
+        } else {
+            Component now = pages.get(sel).component;
+            if (now != null && now != visComp) {
+                if (visComp != null && visComp.isVisible()) {
+                    visComp.setVisible(false);
+                }
+                if (!now.isVisible()) {
+                    now.setVisible(true);
+                }
+                visComp = now;
+            }
+        }
+        TabbedPanePeer p = peer();
+        if (p != null) {
+            p.select(sel);
+        }
+    }
+
+    protected void fireStateChanged() {
+        showSelected();
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+        revalidate();
+        repaint();
+    }
+
+    public int getSelectedIndex() {
+        return model == null ? -1 : model.getSelectedIndex();
+    }
+
+    public void setSelectedIndex(int index) {
+        if (index != -1) {
+            checkIndex(index);
+        }
+        model.setSelectedIndex(index);
+    }
+
+    public Component getSelectedComponent() {
+        int index = getSelectedIndex();
+        if (index == -1) {
+            return null;
+        }
+        return getComponentAt(index);
+    }
+
+    public void setSelectedComponent(Component c) {
+        int index = indexOfComponent(c);
+        if (index == -1) {
+            throw new IllegalArgumentException("component not found in tabbed pane");
+        }
+        setSelectedIndex(index);
+    }
+
+    private void checkIndex(int index) {
+        if (index < 0 || index >= pages.size()) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Tab count: " + pages.size());
+        }
+    }
+
+    // ------------------------------------------------------------ tabs
+
+    public void insertTab(String title, Icon icon, Component component, String tip, int index) {
+        int newIndex = index;
+        int removeIndex = indexOfComponent(component);
+        if (component != null && removeIndex != -1) {
+            removeTabAt(removeIndex);
+            if (newIndex > removeIndex) {
+                newIndex--;
+            }
+        }
+        int selectedIndex = getSelectedIndex();
+        Page page = new Page();
+        page.title = title != null ? title : "";
+        page.icon = icon;
+        page.component = component;
+        page.tip = tip;
+        pages.add(newIndex, page);
+        if (component != null) {
+            addImpl(component, null, -1);
+            component.setVisible(false);
+        } else {
+            firePropertyChange("indexForNullComponent", -1, index);
+        }
+        if (pages.size() == 1) {
+            setSelectedIndex(0);
+        }
+        if (selectedIndex >= newIndex) {
+            model.setSelectedIndex(selectedIndex + 1);
+        }
+        tabsChanged();
+    }
+
+    public void addTab(String title, Icon icon, Component component, String tip) {
+        insertTab(title, icon, component, tip, pages.size());
+    }
+
+    public void addTab(String title, Icon icon, Component component) {
+        insertTab(title, icon, component, null, pages.size());
+    }
+
+    public void addTab(String title, Component component) {
+        insertTab(title, null, component, null, pages.size());
+    }
+
+    @Override
+    public Component add(Component component) {
+        addTab(component.getName(), component);
+        return component;
+    }
+
+    @Override
+    public Component add(String title, Component component) {
+        addTab(title, component);
+        return component;
+    }
+
+    @Override
+    public Component add(Component component, int index) {
+        insertTab(component.getName(), null, component, null, index == -1 ? getTabCount() : index);
+        return component;
+    }
+
+    @Override
+    public void add(Component component, Object constraints) {
+        if (constraints instanceof String) {
+            addTab((String) constraints, component);
+        } else if (constraints instanceof Icon) {
+            addTab(null, (Icon) constraints, component);
+        } else {
+            add(component);
+        }
+    }
+
+    @Override
+    public void add(Component component, Object constraints, int index) {
+        Icon icon = constraints instanceof Icon ? (Icon) constraints : null;
+        String title = constraints instanceof String ? (String) constraints : null;
+        insertTab(title, icon, component, null, index == -1 ? getTabCount() : index);
+    }
+
+    public void removeTabAt(int index) {
+        checkIndex(index);
+        Component component = getComponentAt(index);
+        int selected = getSelectedIndex();
+        if (component == visComp) {
+            visComp = null;
+        }
+        pages.remove(index);
+        if (selected > index) {
+            model.setSelectedIndex(selected - 1);
+        } else if (selected >= getTabCount()) {
+            model.setSelectedIndex(selected - 1);
+        } else if (index == selected) {
+            fireStateChanged();
+        }
+        if (component != null) {
+            for (int i = getComponentCount() - 1; i >= 0; i--) {
+                if (getComponent(i) == component) {
+                    super.remove(i);
+                    component.setVisible(true);
+                    break;
+                }
+            }
+        }
+        tabsChanged();
+    }
+
+    @Override
+    public void remove(Component component) {
+        int index = indexOfComponent(component);
+        if (index != -1) {
+            removeTabAt(index);
+        } else {
+            for (int i = 0; i < getComponentCount(); i++) {
+                if (getComponent(i) == component) {
+                    super.remove(i);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void remove(int index) {
+        removeTabAt(index);
+    }
+
+    @Override
+    public void removeAll() {
+        model.setSelectedIndex(-1);
+        int tabCount = getTabCount();
+        while (tabCount-- > 0) {
+            removeTabAt(tabCount);
+        }
+    }
+
+    public int getTabCount() {
+        return pages.size();
+    }
+
+    /// Always 1: the tabs are in one row or column, which scrolls.
+    public int getTabRunCount() {
+        return pages.isEmpty() ? 0 : 1;
+    }
+
+    public String getTitleAt(int index) {
+        return pages.get(index).title;
+    }
+
+    public void setTitleAt(int index, String title) {
+        Page page = pages.get(index);
+        String old = page.title;
+        page.title = title;
+        if (title == null ? old != null : !title.equals(old)) {
+            firePropertyChange("indexForTitle", -1, index);
+            tabsChanged();
+        }
+    }
+
+    public Icon getIconAt(int index) {
+        return pages.get(index).icon;
+    }
+
+    public void setIconAt(int index, Icon icon) {
+        Page page = pages.get(index);
+        Icon old = page.icon;
+        page.icon = icon;
+        if (old != icon) {
+            tabsChanged();
+        }
+    }
+
+    public Icon getDisabledIconAt(int index) {
+        return pages.get(index).disabledIcon;
+    }
+
+    /// Recorded only: a disabled tab dims the icon it has.
+    public void setDisabledIconAt(int index, Icon disabledIcon) {
+        pages.get(index).disabledIcon = disabledIcon;
+    }
+
+    public String getToolTipTextAt(int index) {
+        return pages.get(index).tip;
+    }
+
+    /// Recorded only; no tool tip is shown.
+    public void setToolTipTextAt(int index, String toolTipText) {
+        pages.get(index).tip = toolTipText;
+    }
+
+    public Color getBackgroundAt(int index) {
+        Color c = pages.get(index).background;
+        return c != null ? c : getBackground();
+    }
+
+    /// Recorded only: the theme colors the tabs.
+    public void setBackgroundAt(int index, Color background) {
+        pages.get(index).background = background;
+    }
+
+    public Color getForegroundAt(int index) {
+        Color c = pages.get(index).foreground;
+        return c != null ? c : getForeground();
+    }
+
+    /// The color of one tab's title; `null` gives it back to the theme.
+    public void setForegroundAt(int index, Color foreground) {
+        pages.get(index).foreground = foreground;
+        syncTabs();
+    }
+
+    public boolean isEnabledAt(int index) {
+        return pages.get(index).enabled;
+    }
+
+    public void setEnabledAt(int index, boolean enabled) {
+        Page page = pages.get(index);
+        if (page.enabled != enabled) {
+            page.enabled = enabled;
+            tabsChanged();
+        }
+    }
+
+    public int getMnemonicAt(int tabIndex) {
+        checkIndex(tabIndex);
+        return pages.get(tabIndex).mnemonic;
+    }
+
+    /// Recorded only.
+    public void setMnemonicAt(int tabIndex, int mnemonic) {
+        checkIndex(tabIndex);
+        pages.get(tabIndex).mnemonic = mnemonic;
+        firePropertyChange("mnemonicAt", null, null);
+    }
+
+    public int getDisplayedMnemonicIndexAt(int tabIndex) {
+        checkIndex(tabIndex);
+        return pages.get(tabIndex).mnemonicIndex;
+    }
+
+    /// Recorded only.
+    public void setDisplayedMnemonicIndexAt(int tabIndex, int mnemonicIndex) {
+        checkIndex(tabIndex);
+        pages.get(tabIndex).mnemonicIndex = mnemonicIndex;
+    }
+
+    public Component getComponentAt(int index) {
+        return pages.get(index).component;
+    }
+
+    public void setComponentAt(int index, Component component) {
+        Page page = pages.get(index);
+        if (component != page.component) {
+            if (page.component != null) {
+                for (int i = getComponentCount() - 1; i >= 0; i--) {
+                    if (getComponent(i) == page.component) {
+                        super.remove(i);
+                        break;
+                    }
+                }
+            }
+            page.component = component;
+            boolean selectedPage = getSelectedIndex() == index;
+            if (selectedPage) {
+                visComp = component;
+            }
+            if (component != null) {
+                component.setVisible(selectedPage);
+                addImpl(component, null, -1);
+            } else {
+                repaint();
+            }
+            revalidate();
+        }
+    }
+
+    public Component getTabComponentAt(int index) {
+        return pages.get(index).tabComponent;
+    }
+
+    /// Records the component. It is not shown in the tab; a `JLabel`
+    /// lends the tab its text and icon as they are when this is called.
+    public void setTabComponentAt(int index, Component component) {
+        if (component != null && indexOfComponent(component) != -1) {
+            throw new IllegalArgumentException("Component is already added to this JTabbedPane");
+        }
+        Component old = getTabComponentAt(index);
+        if (component != old) {
+            int tabComponentIndex = indexOfTabComponent(component);
+            if (tabComponentIndex != -1) {
+                setTabComponentAt(tabComponentIndex, null);
+            }
+            pages.get(index).tabComponent = component;
+            firePropertyChange("indexForTabComponent", -1, index);
+            tabsChanged();
+        }
+    }
+
+    public int indexOfTab(String title) {
+        for (int i = 0; i < pages.size(); i++) {
+            String t = pages.get(i).title;
+            if (t == null ? title == null : t.equals(title)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public int indexOfTab(Icon icon) {
+        for (int i = 0; i < pages.size(); i++) {
+            Icon tabIcon = pages.get(i).icon;
+            if ((tabIcon != null && tabIcon.equals(icon)) || (tabIcon == null && icon == null)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public int indexOfComponent(Component component) {
+        for (int i = 0; i < pages.size(); i++) {
+            Component c = pages.get(i).component;
+            if ((c != null && c.equals(component)) || (c == null && component == null)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public int indexOfTabComponent(Component tabComponent) {
+        for (int i = 0; i < pages.size(); i++) {
+            if (pages.get(i).tabComponent == tabComponent) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /// The bounds of a tab's button, or `null` before the component is
+    /// displayed.
+    public Rectangle getBoundsAt(int index) {
+        checkIndex(index);
+        TabbedPanePeer p = peer();
+        if (p == null || index >= p.tabCount()) {
+            return null;
+        }
+        int[] b = p.tabBounds(index);
+        int x = Units.toLogical(b[0]);
+        int y = Units.toLogical(b[1]);
+        return new Rectangle(x, y, Units.toLogicalCeil(b[0] + b[2]) - x, Units.toLogicalCeil(b[1] + b[3]) - y);
+    }
+
+    public int indexAtLocation(int x, int y) {
+        TabbedPanePeer p = peer();
+        if (p == null) {
+            return -1;
+        }
+        int dx = Units.toDevice(x);
+        int dy = Units.toDevice(y);
+        for (int i = 0; i < p.tabCount(); i++) {
+            int[] b = p.tabBounds(i);
+            if (dx >= b[0] && dx < b[0] + b[2] && dy >= b[1] && dy < b[1] + b[3]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    // ------------------------------------------------------------ placement
+
+    public int getTabPlacement() {
+        return tabPlacement;
+    }
+
+    public void setTabPlacement(int tabPlacement) {
+        if (tabPlacement != TOP && tabPlacement != LEFT && tabPlacement != BOTTOM && tabPlacement != RIGHT) {
+            throw new IllegalArgumentException("illegal tab placement: must be TOP, BOTTOM, LEFT, or RIGHT");
+        }
+        if (this.tabPlacement != tabPlacement) {
+            int old = this.tabPlacement;
+            this.tabPlacement = tabPlacement;
+            firePropertyChange("tabPlacement", old, tabPlacement);
+            tabsChanged();
+        }
+    }
+
+    public int getTabLayoutPolicy() {
+        return tabLayoutPolicy;
+    }
+
+    /// Recorded only: tabs that do not fit scroll.
+    public void setTabLayoutPolicy(int tabLayoutPolicy) {
+        if (tabLayoutPolicy != WRAP_TAB_LAYOUT && tabLayoutPolicy != SCROLL_TAB_LAYOUT) {
+            throw new IllegalArgumentException("illegal tab layout policy: must be WRAP_TAB_LAYOUT or SCROLL_TAB_LAYOUT");
+        }
+        if (this.tabLayoutPolicy != tabLayoutPolicy) {
+            int old = this.tabLayoutPolicy;
+            this.tabLayoutPolicy = tabLayoutPolicy;
+            firePropertyChange("tabLayoutPolicy", old, tabLayoutPolicy);
+        }
+    }
+
+    // ------------------------------------------------------------ layout
+
+    private boolean across() {
+        return tabPlacement == TOP || tabPlacement == BOTTOM;
+    }
+
+    /// The size the strip of tabs wants, in logical pixels: the Codename
+    /// One strip's, or an estimate from the font before a display exists.
+    private Dimension stripSize() {
+        if (pages.isEmpty()) {
+            return new Dimension(0, 0);
+        }
+        if (com.codename1.ui.Display.isInitialized()) {
+            com.codename1.ui.Component cp = cn1Peer();
+            if (cp instanceof TabbedPanePeer) {
+                com.codename1.ui.geom.Dimension d = ((TabbedPanePeer) cp).stripPreferredSize();
+                return new Dimension(Units.toLogicalCeil(d.getWidth()), Units.toLogicalCeil(d.getHeight()));
+            }
+        }
+        FontMetrics fm = Fonts.metrics(getFont());
+        int w = 0;
+        int h = 0;
+        for (int i = 0; i < pages.size(); i++) {
+            Page page = pages.get(i);
+            int tw = fm.stringWidth(shownTitle(page)) + 16;
+            int th = fm.getHeight() + 8;
+            Icon ic = shownIcon(page);
+            if (ic != null) {
+                tw += ic.getIconWidth() + 4;
+                th = Math.max(th, ic.getIconHeight() + 8);
+            }
+            if (across()) {
+                w += tw;
+                h = Math.max(h, th);
+            } else {
+                w = Math.max(w, tw);
+                h += th;
+            }
+        }
+        return new Dimension(w, h);
+    }
+
+    private Dimension size(boolean minimum) {
+        int pw = 0;
+        int ph = 0;
+        for (int i = 0; i < pages.size(); i++) {
+            Component c = pages.get(i).component;
+            if (c != null) {
+                Dimension d = minimum ? c.getMinimumSize() : c.getPreferredSize();
+                pw = Math.max(pw, d.width);
+                ph = Math.max(ph, d.height);
+            }
+        }
+        Dimension strip = stripSize();
+        Insets in = getInsets();
+        int w;
+        int h;
+        if (across()) {
+            w = minimum ? pw : Math.max(pw, strip.width);
+            h = ph + strip.height;
+        } else {
+            w = pw + strip.width;
+            h = minimum ? ph : Math.max(ph, strip.height);
+        }
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    /// The strip's preferred size along the side it is on plus the
+    /// largest preferred size among the pages.
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        return size(false);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return size(true);
+    }
+
+    /// Places the strip on its side and gives every page the rest.
+    @Override
+    public void doLayout() {
+        Insets in = getInsets();
+        int x = in.left;
+        int y = in.top;
+        int w = Math.max(0, getWidth() - in.left - in.right);
+        int h = Math.max(0, getHeight() - in.top - in.bottom);
+        Dimension strip = stripSize();
+        int sx = x;
+        int sy = y;
+        int sw = w;
+        int sh = h;
+        int cx = x;
+        int cy = y;
+        int cw = w;
+        int ch = h;
+        switch (tabPlacement) {
+            case BOTTOM:
+                sh = Math.min(strip.height, h);
+                sy = y + h - sh;
+                ch = h - sh;
+                break;
+            case LEFT:
+                sw = Math.min(strip.width, w);
+                cx = x + sw;
+                cw = w - sw;
+                break;
+            case RIGHT:
+                sw = Math.min(strip.width, w);
+                sx = x + w - sw;
+                cw = w - sw;
+                break;
+            default:
+                sh = Math.min(strip.height, h);
+                cy = y + sh;
+                ch = h - sh;
+                break;
+        }
+        TabbedPanePeer p = peer();
+        if (p != null) {
+            p.placeStrip(Units.toDevice(sx), Units.toDevice(sy), Units.toDeviceSize(sx, sw),
+                    Units.toDeviceSize(sy, sh));
+        }
+        for (int i = 0; i < getComponentCount(); i++) {
+            getComponent(i).setBounds(cx, cy, cw, ch);
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",tabPlacement=" + tabPlacement;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTable.java
new file mode 100644
index 00000000000..1d8b1d387c2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTable.java
@@ -0,0 +1,2726 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.rt.Dnd;
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.KeyAdapter;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.print.PrinterException;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.CellEditorListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import com.codename1.desktopcompat.javax.swing.event.RowSorterEvent;
+import com.codename1.desktopcompat.javax.swing.event.RowSorterListener;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+import com.codename1.desktopcompat.javax.swing.event.TableModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableModelListener;
+import com.codename1.desktopcompat.javax.swing.table.AbstractTableModel;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableColumnModel;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.javax.swing.table.JTableHeader;
+import com.codename1.desktopcompat.javax.swing.table.TableCellEditor;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.javax.swing.table.TableColumnModel;
+import com.codename1.desktopcompat.javax.swing.table.TableModel;
+import com.codename1.desktopcompat.javax.swing.table.TableRowSorter;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.rt.CellPainter;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import com.codename1.desktopcompat.rt.Units;
+import java.text.MessageFormat;
+import java.util.Enumeration;
+import java.util.EventObject;
+import java.util.Hashtable;
+import java.util.Vector;
+
+/// A grid of cells over a [TableModel], with the JDK's column model,
+/// selection, renderers, editors and row sorter.
+///
+/// ## How it is drawn
+///
+/// The table paints itself. For every cell that meets the clip it asks
+/// the cell's [TableCellRenderer] for a component, gives it the cell's
+/// bounds and paints it there; the default renderers are a label and a
+/// check box, so a cell is drawn by the Codename One widget in the theme's
+/// colors. Nothing is created per cell, and a table of any size costs
+/// what its visible part costs.
+///
+/// ## How it is edited
+///
+/// An editor's component is a real child of the table, placed over the
+/// cell while it is edited: a Codename One text field, check box or combo
+/// box. Enter in it, or its own "done", commits; Escape cancels.
+///
+/// ## What differs from a desktop
+///
+///  - Rows are sized for a finger on a touch screen unless
+///    [#setRowHeight(int)] was called; [#getRowHeight()] answers the
+///    height in use.
+///  - On a touch screen a press selects when it is released without
+///    having moved; a drag is handed to the enclosing scroll pane to
+///    scroll. With a mouse a press selects and a drag extends.
+///  - Default renderers and editors are found by assignability, because a
+///    device class cannot be asked for its superclass: the most specific
+///    registered class the column class can be assigned to wins.
+///  - Numbers and dates are shown by `toString`. A number cell is edited
+///    as text and parsed for the column class; text that does not parse
+///    keeps the editor open.
+///  - Keys are handled as plain key events: the arrows, Enter, Tab and
+///    Escape work on every port, and typing over an editable cell starts
+///    editing with the typed character. Home, End, Page Up, Page Down and
+///    F2 are handled when a key event carries them, which no port does
+///    today: `KeyMap` cannot tell them from the printable character whose
+///    code they share, so they arrive as that character.
+///  - There is no print service, and `print` says so with the
+///    `PrinterException` a desktop without a printer throws. Tool tips
+///    per cell are absent, and no drag starts from the table
+///    (`setDragEnabled` is kept as a property).
+public class JTable extends JComponent implements Accessible, TableModelListener, Scrollable, TableColumnModelListener,
+        ListSelectionListener, CellEditorListener, RowSorterListener {
+
+    public static final int AUTO_RESIZE_OFF = 0;
+    public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
+    public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
+    public static final int AUTO_RESIZE_LAST_COLUMN = 3;
+    public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
+
+    protected TableModel dataModel;
+    protected TableColumnModel columnModel;
+    protected ListSelectionModel selectionModel;
+    protected JTableHeader tableHeader;
+    protected int rowHeight;
+    protected int rowMargin;
+    protected Color gridColor;
+    protected boolean showHorizontalLines;
+    protected boolean showVerticalLines;
+    protected int autoResizeMode;
+    protected boolean autoCreateColumnsFromModel;
+    protected Dimension preferredViewportSize;
+    protected boolean rowSelectionAllowed;
+    protected boolean cellSelectionEnabled;
+    protected transient Component editorComp;
+    protected transient TableCellEditor cellEditor;
+    protected transient int editingColumn;
+    protected transient int editingRow;
+    protected transient Hashtable defaultRenderersByColumnClass;
+    protected transient Hashtable defaultEditorsByColumnClass;
+    protected Color selectionForeground;
+    protected Color selectionBackground;
+
+    private RowSorter<? extends TableModel> sorter;
+    private boolean autoCreateRowSorter;
+    private boolean updateSelectionOnSort = true;
+    private boolean fillsViewportHeight;
+    private boolean surrendersFocusOnKeystroke;
+    private boolean rowHeightSet;
+    private int themeRowHeight;
+    private Font themeRowHeightFont;
+    private float themeRowHeightScale;
+    private int[] rowHeights;
+    private int[] rowTops;
+    private boolean inLayout;
+    private boolean ignoreSorter;
+    private int pressRow = -1;
+    private int pressColumn = -1;
+    private int clickBase;
+    private boolean pressOnCell;
+    private boolean pressTouch;
+    private KeyListener editorKeys;
+
+    public JTable() {
+        this(null, null, null);
+    }
+
+    public JTable(TableModel dm) {
+        this(dm, null, null);
+    }
+
+    public JTable(TableModel dm, TableColumnModel cm) {
+        this(dm, cm, null);
+    }
+
+    public JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm) {
+        setLayout(null);
+        editingColumn = -1;
+        editingRow = -1;
+        TableColumnModel columns = cm;
+        if (columns == null) {
+            columns = createDefaultColumnModel();
+            autoCreateColumnsFromModel = true;
+        }
+        setColumnModel(columns);
+        setSelectionModel(sm != null ? sm : createDefaultSelectionModel());
+        setModel(dm != null ? dm : createDefaultDataModel());
+        initializeLocalVars();
+    }
+
+    public JTable(int numRows, int numColumns) {
+        this(new DefaultTableModel(numRows, numColumns));
+    }
+
+    public JTable(Vector rowData, Vector columnNames) {
+        this(new DefaultTableModel(rowData, columnNames));
+    }
+
+    /// Shows the arrays themselves: every cell is editable and an edit
+    /// writes into `rowData`.
+    public JTable(final Object[][] rowData, final Object[] columnNames) {
+        this(new AbstractTableModel() {
+            @Override
+            public String getColumnName(int column) {
+                return String.valueOf(columnNames[column]);
+            }
+
+            @Override
+            public int getRowCount() {
+                return rowData.length;
+            }
+
+            @Override
+            public int getColumnCount() {
+                return columnNames.length;
+            }
+
+            @Override
+            public Object getValueAt(int row, int col) {
+                return rowData[row][col];
+            }
+
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                return true;
+            }
+
+            @Override
+            public void setValueAt(Object value, int row, int col) {
+                rowData[row][col] = value;
+                fireTableCellUpdated(row, col);
+            }
+        });
+    }
+
+    // ------------------------------------------------------------ set up
+
+    protected void initializeLocalVars() {
+        setOpaque(true);
+        createDefaultRenderers();
+        createDefaultEditors();
+        setTableHeader(createDefaultTableHeader());
+        showHorizontalLines = true;
+        showVerticalLines = true;
+        autoResizeMode = AUTO_RESIZE_SUBSEQUENT_COLUMNS;
+        rowMargin = 1;
+        rowSelectionAllowed = true;
+        cellEditor = null;
+        editingColumn = -1;
+        editingRow = -1;
+        preferredViewportSize = new Dimension(450, 400);
+        setBackground(CellTheme.background("Table.background"));
+        setForeground(CellTheme.foreground("Table.foreground"));
+        setFont(CellTheme.font());
+        selectionBackground = CellTheme.selectionBackground("Table.selectionBackground");
+        selectionForeground = CellTheme.selectionForeground("Table.selectionForeground");
+        gridColor = CellTheme.grid("Table.gridColor");
+        setFocusable(true);
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
+    }
+
+    protected TableModel createDefaultDataModel() {
+        return new DefaultTableModel();
+    }
+
+    protected TableColumnModel createDefaultColumnModel() {
+        return new DefaultTableColumnModel();
+    }
+
+    protected ListSelectionModel createDefaultSelectionModel() {
+        return new DefaultListSelectionModel();
+    }
+
+    protected JTableHeader createDefaultTableHeader() {
+        return new JTableHeader(columnModel);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected void createDefaultRenderers() {
+        defaultRenderersByColumnClass = new Hashtable();
+        defaultRenderersByColumnClass.put(Object.class, new DefaultTableCellRenderer());
+        defaultRenderersByColumnClass.put(Number.class, new NumberRenderer());
+        defaultRenderersByColumnClass.put(Float.class, new DoubleRenderer());
+        defaultRenderersByColumnClass.put(Double.class, new DoubleRenderer());
+        defaultRenderersByColumnClass.put(java.util.Date.class, new DateRenderer());
+        defaultRenderersByColumnClass.put(Icon.class, new IconRenderer());
+        defaultRenderersByColumnClass.put(ImageIcon.class, new IconRenderer());
+        defaultRenderersByColumnClass.put(Boolean.class, new BooleanRenderer());
+    }
+
+    @SuppressWarnings("unchecked")
+    protected void createDefaultEditors() {
+        defaultEditorsByColumnClass = new Hashtable();
+        defaultEditorsByColumnClass.put(Object.class, new ValueEditor(false));
+        defaultEditorsByColumnClass.put(Number.class, new ValueEditor(true));
+        defaultEditorsByColumnClass.put(Boolean.class, new DefaultCellEditor(new JCheckBox()));
+    }
+
+    /// The entry of the most specific registered class `c` can be
+    /// assigned to. A device class has no `getSuperclass`, so the walk up
+    /// the hierarchy the JDK does is replaced by this search; interfaces
+    /// count too.
+    private static Object bySuperclass(Hashtable table, Class<?> c) {
+        Class<?> wanted = c == null ? Object.class : c;
+        Object direct = table.get(wanted);
+        if (direct != null) {
+            return direct;
+        }
+        Class<?> best = null;
+        for (Enumeration e = table.keys(); e.hasMoreElements();) {
+            Object k = e.nextElement();
+            if (k instanceof Class) {
+                Class<?> kc = (Class<?>) k;
+                if (kc.isAssignableFrom(wanted) && (best == null || best.isAssignableFrom(kc))) {
+                    best = kc;
+                }
+            }
+        }
+        return best == null ? null : table.get(best);
+    }
+
+    @SuppressWarnings("unchecked")
+    public void setDefaultRenderer(Class<?> columnClass, TableCellRenderer renderer) {
+        if (renderer != null) {
+            defaultRenderersByColumnClass.put(columnClass, renderer);
+        } else {
+            defaultRenderersByColumnClass.remove(columnClass);
+        }
+        repaint();
+    }
+
+    public TableCellRenderer getDefaultRenderer(Class<?> columnClass) {
+        Object r = bySuperclass(defaultRenderersByColumnClass, columnClass);
+        return r instanceof TableCellRenderer ? (TableCellRenderer) r : null;
+    }
+
+    @SuppressWarnings("unchecked")
+    public void setDefaultEditor(Class<?> columnClass, TableCellEditor editor) {
+        if (editor != null) {
+            defaultEditorsByColumnClass.put(columnClass, editor);
+        } else {
+            defaultEditorsByColumnClass.remove(columnClass);
+        }
+    }
+
+    public TableCellEditor getDefaultEditor(Class<?> columnClass) {
+        Object r = bySuperclass(defaultEditorsByColumnClass, columnClass);
+        return r instanceof TableCellEditor ? (TableCellEditor) r : null;
+    }
+
+    // ------------------------------------------------------------ scroll pane
+
+    @Override
+    public void addNotify() {
+        super.addNotify();
+        configureEnclosingScrollPane();
+    }
+
+    @Override
+    public void removeNotify() {
+        unconfigureEnclosingScrollPane();
+        super.removeNotify();
+    }
+
+    private JScrollPane scrollPaneOfThis() {
+        Container parent = getParent();
+        if (parent instanceof JViewport) {
+            Container gp = parent.getParent();
+            if (gp instanceof JScrollPane) {
+                JScrollPane pane = (JScrollPane) gp;
+                JViewport viewport = pane.getViewport();
+                if (viewport != null && viewport.getView() == this) {
+                    return pane;
+                }
+            }
+        }
+        return null;
+    }
+
+    /// Makes the table header the column header of the scroll pane this
+    /// table is the view of.
+    protected void configureEnclosingScrollPane() {
+        JScrollPane pane = scrollPaneOfThis();
+        if (pane != null && tableHeader != null) {
+            pane.setColumnHeaderView(tableHeader);
+        }
+    }
+
+    protected void unconfigureEnclosingScrollPane() {
+        JScrollPane pane = scrollPaneOfThis();
+        if (pane != null) {
+            JViewport header = pane.getColumnHeader();
+            if (header != null && header.getView() == tableHeader && tableHeader != null) {
+                pane.setColumnHeaderView(null);
+            }
+        }
+    }
+
+    /// Scrolls the viewport this table is in so that the rectangle shows.
+    public void scrollRectToVisible(Rectangle aRect) {
+        ScrollDelegate.reveal(this, aRect);
+    }
+
+    // ------------------------------------------------------------ properties
+
+    public void setTableHeader(JTableHeader tableHeader) {
+        JTableHeader old = this.tableHeader;
+        if (old != tableHeader) {
+            if (old != null && old.getTable() == this) {
+                old.setTable(null);
+            }
+            this.tableHeader = tableHeader;
+            if (tableHeader != null) {
+                tableHeader.setTable(this);
+            }
+            firePropertyChange("tableHeader", old, tableHeader);
+        }
+    }
+
+    public JTableHeader getTableHeader() {
+        return tableHeader;
+    }
+
+    /// Sets the height of every row, in logical pixels, and stops the
+    /// table from sizing its rows for the device.
+    public void setRowHeight(int rowHeight) {
+        if (rowHeight <= 0) {
+            throw new IllegalArgumentException("New row height less than 1");
+        }
+        int old = this.rowHeight;
+        this.rowHeight = rowHeight;
+        rowHeightSet = true;
+        rowHeights = null;
+        rowTops = null;
+        resizeAndRepaint();
+        firePropertyChange("rowHeight", old, rowHeight);
+    }
+
+    /// The height of a row: the one that was set, or else one that fits
+    /// the font, and a finger on a touch screen.
+    public int getRowHeight() {
+        if (rowHeightSet) {
+            return rowHeight;
+        }
+        Font f = getFont();
+        float scale = Units.scale();
+        if (themeRowHeight <= 0 || f != themeRowHeightFont || Float.compare(scale, themeRowHeightScale) != 0) {
+            themeRowHeight = Math.max(1, CellTheme.rowHeight(f, 16, 28));
+            themeRowHeightFont = f;
+            themeRowHeightScale = scale;
+        }
+        return themeRowHeight;
+    }
+
+    /// Sets the height of one row. Heights of single rows are forgotten
+    /// when rows are inserted, removed or sorted.
+    public void setRowHeight(int row, int rowHeight) {
+        if (rowHeight <= 0) {
+            throw new IllegalArgumentException("New row height less than 1");
+        }
+        int n = getRowCount();
+        if (row < 0 || row >= n) {
+            return;
+        }
+        if (rowHeights == null || rowHeights.length != n) {
+            rowHeights = new int[n];
+            int h = getRowHeight();
+            for (int i = 0; i < n; i++) {
+                rowHeights[i] = h;
+            }
+        }
+        rowHeights[row] = rowHeight;
+        rowTops = null;
+        resizeAndRepaint();
+    }
+
+    public int getRowHeight(int row) {
+        int[] hs = heights();
+        return hs != null && row >= 0 && row < hs.length ? hs[row] : getRowHeight();
+    }
+
+    /// The heights of single rows, or `null` when all rows are alike.
+    private int[] heights() {
+        if (rowHeights != null && rowHeights.length != getRowCount()) {
+            rowHeights = null;
+            rowTops = null;
+        }
+        return rowHeights;
+    }
+
+    /// Where each row of single heights starts, and where the last ends.
+    private int[] tops(int[] hs) {
+        if (rowTops == null) {
+            rowTops = new int[hs.length + 1];
+            for (int i = 0; i < hs.length; i++) {
+                rowTops[i + 1] = rowTops[i] + hs[i];
+            }
+        }
+        return rowTops;
+    }
+
+    private int rowY(int row) {
+        int[] hs = heights();
+        if (hs == null) {
+            return row * getRowHeight();
+        }
+        int[] t = tops(hs);
+        return t[Math.max(0, Math.min(row, t.length - 1))];
+    }
+
+    /// The row that covers `y`, which may be past the last row.
+    private int rowAtY(int y) {
+        int[] hs = heights();
+        if (hs == null) {
+            int h = getRowHeight();
+            return h <= 0 ? 0 : y / h;
+        }
+        int[] t = tops(hs);
+        int lo = 0;
+        int hi = t.length - 1;
+        if (y >= t[hi]) {
+            return hi;
+        }
+        while (hi - lo > 1) {
+            int mid = (lo + hi) >>> 1;
+            if (t[mid] <= y) {
+                lo = mid;
+            } else {
+                hi = mid;
+            }
+        }
+        return lo;
+    }
+
+    private int totalRowHeight() {
+        return rowY(getRowCount());
+    }
+
+    public void setRowMargin(int rowMargin) {
+        int old = this.rowMargin;
+        this.rowMargin = rowMargin;
+        resizeAndRepaint();
+        firePropertyChange("rowMargin", old, rowMargin);
+    }
+
+    public int getRowMargin() {
+        return rowMargin;
+    }
+
+    public void setIntercellSpacing(Dimension intercellSpacing) {
+        setRowMargin(intercellSpacing.height);
+        getColumnModel().setColumnMargin(intercellSpacing.width);
+        resizeAndRepaint();
+    }
+
+    public Dimension getIntercellSpacing() {
+        return new Dimension(getColumnModel().getColumnMargin(), rowMargin);
+    }
+
+    public void setGridColor(Color gridColor) {
+        if (gridColor == null) {
+            throw new IllegalArgumentException("New color is null");
+        }
+        Color old = this.gridColor;
+        this.gridColor = gridColor;
+        firePropertyChange("gridColor", old, gridColor);
+        repaint();
+    }
+
+    public Color getGridColor() {
+        return gridColor;
+    }
+
+    public void setShowGrid(boolean showGrid) {
+        setShowHorizontalLines(showGrid);
+        setShowVerticalLines(showGrid);
+        repaint();
+    }
+
+    public void setShowHorizontalLines(boolean showHorizontalLines) {
+        boolean old = this.showHorizontalLines;
+        this.showHorizontalLines = showHorizontalLines;
+        firePropertyChange("showHorizontalLines", old, showHorizontalLines);
+        repaint();
+    }
+
+    public void setShowVerticalLines(boolean showVerticalLines) {
+        boolean old = this.showVerticalLines;
+        this.showVerticalLines = showVerticalLines;
+        firePropertyChange("showVerticalLines", old, showVerticalLines);
+        repaint();
+    }
+
+    public boolean getShowHorizontalLines() {
+        return showHorizontalLines;
+    }
+
+    public boolean getShowVerticalLines() {
+        return showVerticalLines;
+    }
+
+    public void setAutoResizeMode(int mode) {
+        if (mode < AUTO_RESIZE_OFF || mode > AUTO_RESIZE_ALL_COLUMNS) {
+            return;
+        }
+        int old = autoResizeMode;
+        autoResizeMode = mode;
+        resizeAndRepaint();
+        if (tableHeader != null) {
+            tableHeader.resizeAndRepaint();
+        }
+        firePropertyChange("autoResizeMode", old, autoResizeMode);
+    }
+
+    public int getAutoResizeMode() {
+        return autoResizeMode;
+    }
+
+    public void setAutoCreateColumnsFromModel(boolean autoCreateColumnsFromModel) {
+        if (this.autoCreateColumnsFromModel != autoCreateColumnsFromModel) {
+            boolean old = this.autoCreateColumnsFromModel;
+            this.autoCreateColumnsFromModel = autoCreateColumnsFromModel;
+            if (autoCreateColumnsFromModel) {
+                createDefaultColumnsFromModel();
+            }
+            firePropertyChange("autoCreateColumnsFromModel", old, autoCreateColumnsFromModel);
+        }
+    }
+
+    public boolean getAutoCreateColumnsFromModel() {
+        return autoCreateColumnsFromModel;
+    }
+
+    /// Replaces the columns by one per column of the model, in its order.
+    public void createDefaultColumnsFromModel() {
+        TableModel m = getModel();
+        if (m == null) {
+            return;
+        }
+        TableColumnModel cm = getColumnModel();
+        while (cm.getColumnCount() > 0) {
+            cm.removeColumn(cm.getColumn(0));
+        }
+        for (int i = 0; i < m.getColumnCount(); i++) {
+            addColumn(new TableColumn(i));
+        }
+    }
+
+    public void setAutoCreateRowSorter(boolean autoCreateRowSorter) {
+        boolean old = this.autoCreateRowSorter;
+        this.autoCreateRowSorter = autoCreateRowSorter;
+        if (autoCreateRowSorter) {
+            setRowSorter(new TableRowSorter<TableModel>(getModel()));
+        }
+        firePropertyChange("autoCreateRowSorter", old, autoCreateRowSorter);
+    }
+
+    public boolean getAutoCreateRowSorter() {
+        return autoCreateRowSorter;
+    }
+
+    public void setUpdateSelectionOnSort(boolean update) {
+        boolean old = updateSelectionOnSort;
+        updateSelectionOnSort = update;
+        firePropertyChange("updateSelectionOnSort", old, update);
+    }
+
+    public boolean getUpdateSelectionOnSort() {
+        return updateSelectionOnSort;
+    }
+
+    public void setRowSorter(RowSorter<? extends TableModel> sorter) {
+        RowSorter<? extends TableModel> old = this.sorter;
+        if (old != null) {
+            old.removeRowSorterListener(this);
+        }
+        this.sorter = sorter;
+        if (sorter != null) {
+            sorter.addRowSorterListener(this);
+        }
+        rowHeights = null;
+        rowTops = null;
+        if (selectionModel != null) {
+            selectionModel.clearSelection();
+        }
+        firePropertyChange("rowSorter", old, sorter);
+        resizeAndRepaint();
+        if (tableHeader != null) {
+            tableHeader.repaint();
+        }
+    }
+
+    public RowSorter<? extends TableModel> getRowSorter() {
+        return sorter;
+    }
+
+    public void setFillsViewportHeight(boolean fillsViewportHeight) {
+        boolean old = this.fillsViewportHeight;
+        this.fillsViewportHeight = fillsViewportHeight;
+        resizeAndRepaint();
+        firePropertyChange("fillsViewportHeight", old, fillsViewportHeight);
+    }
+
+    public boolean getFillsViewportHeight() {
+        return fillsViewportHeight;
+    }
+
+    public void setSurrendersFocusOnKeystroke(boolean surrendersFocusOnKeystroke) {
+        this.surrendersFocusOnKeystroke = surrendersFocusOnKeystroke;
+    }
+
+    public boolean getSurrendersFocusOnKeystroke() {
+        return surrendersFocusOnKeystroke;
+    }
+
+    // ------------------------------------------------------------ selection
+
+    public void setSelectionMode(int selectionMode) {
+        clearSelection();
+        getSelectionModel().setSelectionMode(selectionMode);
+        getColumnModel().getSelectionModel().setSelectionMode(selectionMode);
+    }
+
+    public void setRowSelectionAllowed(boolean rowSelectionAllowed) {
+        boolean old = this.rowSelectionAllowed;
+        this.rowSelectionAllowed = rowSelectionAllowed;
+        if (old != rowSelectionAllowed) {
+            repaint();
+        }
+        firePropertyChange("rowSelectionAllowed", old, rowSelectionAllowed);
+    }
+
+    public boolean getRowSelectionAllowed() {
+        return rowSelectionAllowed;
+    }
+
+    public void setColumnSelectionAllowed(boolean columnSelectionAllowed) {
+        boolean old = columnModel.getColumnSelectionAllowed();
+        columnModel.setColumnSelectionAllowed(columnSelectionAllowed);
+        if (old != columnSelectionAllowed) {
+            repaint();
+        }
+        firePropertyChange("columnSelectionAllowed", old, columnSelectionAllowed);
+    }
+
+    public boolean getColumnSelectionAllowed() {
+        return columnModel.getColumnSelectionAllowed();
+    }
+
+    public void setCellSelectionEnabled(boolean cellSelectionEnabled) {
+        setRowSelectionAllowed(cellSelectionEnabled);
+        setColumnSelectionAllowed(cellSelectionEnabled);
+        boolean old = this.cellSelectionEnabled;
+        this.cellSelectionEnabled = cellSelectionEnabled;
+        firePropertyChange("cellSelectionEnabled", old, cellSelectionEnabled);
+    }
+
+    public boolean getCellSelectionEnabled() {
+        return getRowSelectionAllowed() && getColumnSelectionAllowed();
+    }
+
+    public void selectAll() {
+        if (isEditing()) {
+            removeEditor();
+        }
+        int rows = getRowCount();
+        int columns = getColumnCount();
+        if (rows > 0 && columns > 0) {
+            selectionModel.setSelectionInterval(0, rows - 1);
+            columnModel.getSelectionModel().setSelectionInterval(0, columns - 1);
+        }
+    }
+
+    public void clearSelection() {
+        selectionModel.clearSelection();
+        columnModel.getSelectionModel().clearSelection();
+    }
+
+    private int boundRow(int row) {
+        if (row < 0 || row >= getRowCount()) {
+            throw new IllegalArgumentException("Row index out of range");
+        }
+        return row;
+    }
+
+    private int boundColumn(int col) {
+        if (col < 0 || col >= getColumnCount()) {
+            throw new IllegalArgumentException("Column index out of range");
+        }
+        return col;
+    }
+
+    public void setRowSelectionInterval(int index0, int index1) {
+        selectionModel.setSelectionInterval(boundRow(index0), boundRow(index1));
+    }
+
+    public void setColumnSelectionInterval(int index0, int index1) {
+        columnModel.getSelectionModel().setSelectionInterval(boundColumn(index0), boundColumn(index1));
+    }
+
+    public void addRowSelectionInterval(int index0, int index1) {
+        selectionModel.addSelectionInterval(boundRow(index0), boundRow(index1));
+    }
+
+    public void addColumnSelectionInterval(int index0, int index1) {
+        columnModel.getSelectionModel().addSelectionInterval(boundColumn(index0), boundColumn(index1));
+    }
+
+    public void removeRowSelectionInterval(int index0, int index1) {
+        selectionModel.removeSelectionInterval(boundRow(index0), boundRow(index1));
+    }
+
+    public void removeColumnSelectionInterval(int index0, int index1) {
+        columnModel.getSelectionModel().removeSelectionInterval(boundColumn(index0), boundColumn(index1));
+    }
+
+    public int getSelectedRow() {
+        return selectionModel.getMinSelectionIndex();
+    }
+
+    public int getSelectedColumn() {
+        return columnModel.getSelectionModel().getMinSelectionIndex();
+    }
+
+    public int[] getSelectedRows() {
+        int min = selectionModel.getMinSelectionIndex();
+        int max = selectionModel.getMaxSelectionIndex();
+        if (min < 0 || max < 0) {
+            return new int[0];
+        }
+        int[] tmp = new int[max - min + 1];
+        int n = 0;
+        for (int i = min; i <= max; i++) {
+            if (selectionModel.isSelectedIndex(i)) {
+                tmp[n++] = i;
+            }
+        }
+        int[] out = new int[n];
+        System.arraycopy(tmp, 0, out, 0, n);
+        return out;
+    }
+
+    public int[] getSelectedColumns() {
+        return columnModel.getSelectedColumns();
+    }
+
+    public int getSelectedRowCount() {
+        return getSelectedRows().length;
+    }
+
+    public int getSelectedColumnCount() {
+        return columnModel.getSelectedColumnCount();
+    }
+
+    public boolean isRowSelected(int row) {
+        return selectionModel.isSelectedIndex(row);
+    }
+
+    public boolean isColumnSelected(int column) {
+        return columnModel.getSelectionModel().isSelectedIndex(column);
+    }
+
+    public boolean isCellSelected(int row, int column) {
+        if (!getRowSelectionAllowed() && !getColumnSelectionAllowed()) {
+            return false;
+        }
+        return (!getRowSelectionAllowed() || isRowSelected(row))
+                && (!getColumnSelectionAllowed() || isColumnSelected(column));
+    }
+
+    private static void change(ListSelectionModel sm, int index, boolean toggle, boolean extend, boolean selected) {
+        if (extend) {
+            if (toggle) {
+                sm.setAnchorSelectionIndex(index);
+            } else {
+                int anchor = sm.getAnchorSelectionIndex();
+                sm.setSelectionInterval(anchor < 0 ? index : anchor, index);
+            }
+        } else if (toggle) {
+            if (selected) {
+                sm.removeSelectionInterval(index, index);
+            } else {
+                sm.addSelectionInterval(index, index);
+            }
+        } else {
+            sm.setSelectionInterval(index, index);
+        }
+    }
+
+    /// Moves the selection to a cell the way a click or a key does:
+    /// `toggle` as with Control held, `extend` as with Shift held. The
+    /// cell is scrolled into view.
+    public void changeSelection(int rowIndex, int columnIndex, boolean toggle, boolean extend) {
+        boolean selected = isCellSelected(rowIndex, columnIndex);
+        change(columnModel.getSelectionModel(), columnIndex, toggle, extend, selected);
+        change(selectionModel, rowIndex, toggle, extend, selected);
+        Rectangle cell = getCellRect(rowIndex, columnIndex, true);
+        if (cell.width > 0 && cell.height > 0) {
+            scrollRectToVisible(cell);
+        }
+    }
+
+    public Color getSelectionForeground() {
+        return selectionForeground;
+    }
+
+    public void setSelectionForeground(Color selectionForeground) {
+        Color old = this.selectionForeground;
+        this.selectionForeground = selectionForeground;
+        firePropertyChange("selectionForeground", old, selectionForeground);
+        repaint();
+    }
+
+    public Color getSelectionBackground() {
+        return selectionBackground;
+    }
+
+    public void setSelectionBackground(Color selectionBackground) {
+        Color old = this.selectionBackground;
+        this.selectionBackground = selectionBackground;
+        firePropertyChange("selectionBackground", old, selectionBackground);
+        repaint();
+    }
+
+    // ------------------------------------------------------------ indexes
+
+    public TableColumn getColumn(Object identifier) {
+        TableColumnModel cm = getColumnModel();
+        return cm.getColumn(cm.getColumnIndex(identifier));
+    }
+
+    public int convertColumnIndexToModel(int viewColumnIndex) {
+        if (viewColumnIndex < 0) {
+            return viewColumnIndex;
+        }
+        return getColumnModel().getColumn(viewColumnIndex).getModelIndex();
+    }
+
+    public int convertColumnIndexToView(int modelColumnIndex) {
+        if (modelColumnIndex < 0) {
+            return modelColumnIndex;
+        }
+        TableColumnModel cm = getColumnModel();
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            if (cm.getColumn(i).getModelIndex() == modelColumnIndex) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public int convertRowIndexToView(int modelRowIndex) {
+        return sorter != null ? sorter.convertRowIndexToView(modelRowIndex) : modelRowIndex;
+    }
+
+    public int convertRowIndexToModel(int viewRowIndex) {
+        return sorter != null ? sorter.convertRowIndexToModel(viewRowIndex) : viewRowIndex;
+    }
+
+    public int getRowCount() {
+        if (sorter != null) {
+            return sorter.getViewRowCount();
+        }
+        return dataModel == null ? 0 : dataModel.getRowCount();
+    }
+
+    public int getColumnCount() {
+        return getColumnModel().getColumnCount();
+    }
+
+    public String getColumnName(int column) {
+        return getModel().getColumnName(convertColumnIndexToModel(column));
+    }
+
+    public Class<?> getColumnClass(int column) {
+        return getModel().getColumnClass(convertColumnIndexToModel(column));
+    }
+
+    public Object getValueAt(int row, int column) {
+        return getModel().getValueAt(convertRowIndexToModel(row), convertColumnIndexToModel(column));
+    }
+
+    public void setValueAt(Object aValue, int row, int column) {
+        getModel().setValueAt(aValue, convertRowIndexToModel(row), convertColumnIndexToModel(column));
+    }
+
+    public boolean isCellEditable(int row, int column) {
+        return getModel().isCellEditable(convertRowIndexToModel(row), convertColumnIndexToModel(column));
+    }
+
+    public void addColumn(TableColumn aColumn) {
+        if (aColumn.getHeaderValue() == null) {
+            aColumn.setHeaderValue(getModel().getColumnName(aColumn.getModelIndex()));
+        }
+        getColumnModel().addColumn(aColumn);
+    }
+
+    public void removeColumn(TableColumn aColumn) {
+        getColumnModel().removeColumn(aColumn);
+    }
+
+    public void moveColumn(int column, int targetColumn) {
+        getColumnModel().moveColumn(column, targetColumn);
+    }
+
+    // ------------------------------------------------------------ geometry
+
+    /// The view column at a point in logical pixels, or -1.
+    public int columnAtPoint(Point point) {
+        return getColumnModel().getColumnIndexAtX(point.x);
+    }
+
+    /// The view row at a point in logical pixels, or -1.
+    public int rowAtPoint(Point point) {
+        if (point.y < 0) {
+            return -1;
+        }
+        int row = rowAtY(point.y);
+        return row < getRowCount() ? row : -1;
+    }
+
+    private int columnX(int column) {
+        TableColumnModel cm = getColumnModel();
+        int x = 0;
+        for (int i = 0; i < column; i++) {
+            x += cm.getColumn(i).getWidth();
+        }
+        return x;
+    }
+
+    /// The rectangle of a cell in logical pixels: the whole cell with
+    /// `includeSpacing`, else the part inside the gaps between cells,
+    /// which is what a renderer or editor is given.
+    public Rectangle getCellRect(int row, int column, boolean includeSpacing) {
+        Rectangle r = new Rectangle();
+        boolean valid = true;
+        if (row < 0) {
+            valid = false;
+        } else if (row >= getRowCount()) {
+            r.y = getHeight();
+            valid = false;
+        } else {
+            r.height = getRowHeight(row);
+            r.y = rowY(row);
+        }
+        if (column < 0) {
+            valid = false;
+        } else if (column >= getColumnCount()) {
+            r.x = getWidth();
+            valid = false;
+        } else {
+            r.x = columnX(column);
+            r.width = getColumnModel().getColumn(column).getWidth();
+        }
+        if (valid && !includeSpacing) {
+            int rm = Math.min(getRowMargin(), r.height);
+            int cm = Math.min(getColumnModel().getColumnMargin(), r.width);
+            r.setBounds(r.x + cm / 2, r.y + rm / 2, r.width - cm, r.height - rm);
+        }
+        return r;
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        TableColumnModel cm = getColumnModel();
+        long w = 0;
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            w += cm.getColumn(i).getPreferredWidth();
+        }
+        return new Dimension((int) Math.min(w, Integer.MAX_VALUE), totalRowHeight());
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        TableColumnModel cm = getColumnModel();
+        long w = 0;
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            w += cm.getColumn(i).getMinWidth();
+        }
+        return new Dimension((int) Math.min(w, Integer.MAX_VALUE), totalRowHeight());
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (isMaximumSizeSet()) {
+            return super.getMaximumSize();
+        }
+        TableColumnModel cm = getColumnModel();
+        long w = 0;
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            w += cm.getColumn(i).getMaxWidth();
+        }
+        return new Dimension((int) Math.min(w, Integer.MAX_VALUE), totalRowHeight());
+    }
+
+    /// Spreads `target` over the columns `from` up to `to`, starting from
+    /// the preferred widths (or the current ones): each column takes the
+    /// share of the difference that its own room between its limits is of
+    /// all the room. The widths add up to `target` exactly whenever the
+    /// limits allow.
+    private void spread(long target, int from, int to, boolean fromPreferred) {
+        TableColumnModel cm = getColumnModel();
+        long total = 0;
+        long totalMin = 0;
+        long totalMax = 0;
+        for (int i = from; i < to; i++) {
+            TableColumn c = cm.getColumn(i);
+            total += fromPreferred ? c.getPreferredWidth() : c.getWidth();
+            totalMin += c.getMinWidth();
+            totalMax += c.getMaxWidth();
+        }
+        boolean shrink = target < total;
+        long lowerSum = shrink ? totalMin : total;
+        long upperSum = shrink ? total : totalMax;
+        long left = target;
+        for (int i = from; i < to; i++) {
+            TableColumn c = cm.getColumn(i);
+            int size = fromPreferred ? c.getPreferredWidth() : c.getWidth();
+            long lower = shrink ? c.getMinWidth() : size;
+            long upper = shrink ? size : c.getMaxWidth();
+            long span = upperSum - lowerSum;
+            long now;
+            if (span <= 0) {
+                now = lower;
+            } else {
+                now = Math.round(lower + (double) (left - lowerSum) / (double) span * (upper - lower));
+            }
+            c.setWidth((int) Math.max(0, Math.min(now, Integer.MAX_VALUE)));
+            left -= c.getWidth();
+            lowerSum -= lower;
+            upperSum -= upper;
+        }
+    }
+
+    /// Gives the columns their widths. Without a column being dragged the
+    /// table's width is shared out from the preferred widths (or, with
+    /// [#AUTO_RESIZE_OFF], every column simply gets its preferred width).
+    /// While the header drags a column, the columns the resize mode names
+    /// take up the difference and the widths become the preferred ones.
+    @Override
+    public void doLayout() {
+        inLayout = true;
+        try {
+            TableColumnModel cm = getColumnModel();
+            int n = cm.getColumnCount();
+            TableColumn resizing = tableHeader == null ? null : tableHeader.getResizingColumn();
+            if (resizing == null) {
+                if (autoResizeMode == AUTO_RESIZE_OFF) {
+                    for (int i = 0; i < n; i++) {
+                        TableColumn c = cm.getColumn(i);
+                        c.setWidth(c.getPreferredWidth());
+                    }
+                } else if (getWidth() > 0 && n > 0) {
+                    spread(getWidth(), 0, n, true);
+                }
+            } else {
+                int at = -1;
+                for (int i = 0; i < n; i++) {
+                    if (cm.getColumn(i) == resizing) {
+                        at = i;
+                        break;
+                    }
+                }
+                if (autoResizeMode != AUTO_RESIZE_OFF && at >= 0 && getWidth() > 0) {
+                    int from = at + 1;
+                    int to = n;
+                    switch (autoResizeMode) {
+                        case AUTO_RESIZE_NEXT_COLUMN:
+                            to = Math.min(from + 1, n);
+                            break;
+                        case AUTO_RESIZE_LAST_COLUMN:
+                            from = Math.max(from, n - 1);
+                            break;
+                        case AUTO_RESIZE_ALL_COLUMNS:
+                            from = 0;
+                            break;
+                        default:
+                            break;
+                    }
+                    long delta = (long) getWidth() - cm.getTotalColumnWidth();
+                    if (from < to && delta != 0) {
+                        long range = 0;
+                        for (int i = from; i < to; i++) {
+                            range += cm.getColumn(i).getWidth();
+                        }
+                        spread(range + delta, from, to, false);
+                    }
+                    delta = (long) getWidth() - cm.getTotalColumnWidth();
+                    if (delta != 0) {
+                        // The others could not take it all: the dragged
+                        // column gives back what is left.
+                        resizing.setWidth((int) (resizing.getWidth() + delta));
+                    }
+                }
+                for (int i = 0; i < n; i++) {
+                    TableColumn c = cm.getColumn(i);
+                    c.setPreferredWidth(c.getWidth());
+                }
+            }
+            if (isEditing() && editorComp != null) {
+                editorComp.setBounds(getCellRect(editingRow, editingColumn, false));
+            }
+        } finally {
+            inLayout = false;
+        }
+        super.doLayout();
+    }
+
+    /// Lays the columns out as [#doLayout()] does; the argument is ignored.
+    public void sizeColumnsToFit(int resizingColumn) {
+        doLayout();
+        repaint();
+    }
+
+    protected void resizeAndRepaint() {
+        revalidate();
+        repaint();
+    }
+
+    // ------------------------------------------------------------ paint
+
+    private boolean focusCell(int row, int column) {
+        return selectionModel.getLeadSelectionIndex() == row
+                && columnModel.getSelectionModel().getLeadSelectionIndex() == column && isFocusOwner();
+    }
+
+    public TableCellRenderer getCellRenderer(int row, int column) {
+        TableColumn c = getColumnModel().getColumn(column);
+        TableCellRenderer r = c.getCellRenderer();
+        return r != null ? r : getDefaultRenderer(getColumnClass(column));
+    }
+
+    /// Asks the renderer for the component that paints a cell, telling it
+    /// the cell's value, whether the cell is selected and whether it is
+    /// the focused cell of a table that has the focus.
+    public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
+        return renderer.getTableCellRendererComponent(this, getValueAt(row, column), isCellSelected(row, column),
+                focusCell(row, column), row, column);
+    }
+
+    /// Paints the cells that meet the clip, and the grid over them.
+    @Override
+    protected void paintComponent(Graphics g) {
+        Rectangle clip = g.getClipBounds();
+        if (clip == null) {
+            clip = new Rectangle(0, 0, getWidth(), getHeight());
+        }
+        if (isOpaque() && getBackground() != null) {
+            g.setColor(getBackground());
+            g.fillRect(clip.x, clip.y, clip.width, clip.height);
+        }
+        int rows = getRowCount();
+        TableColumnModel cm = getColumnModel();
+        int columns = cm.getColumnCount();
+        if (rows <= 0 || columns <= 0 || clip.width <= 0 || clip.height <= 0) {
+            return;
+        }
+        int rMin = Math.max(0, rowAtY(Math.max(0, clip.y)));
+        int rMax = Math.min(rows - 1, rowAtY(Math.max(0, clip.y + clip.height - 1)));
+        int cMin = -1;
+        int cMax = -1;
+        int[] xs = new int[columns + 1];
+        for (int i = 0; i < columns; i++) {
+            int w = cm.getColumn(i).getWidth();
+            xs[i + 1] = xs[i] + w;
+            if (xs[i + 1] > clip.x && xs[i] < clip.x + clip.width) {
+                if (cMin < 0) {
+                    cMin = i;
+                }
+                cMax = i;
+            }
+        }
+        if (cMin < 0 || rMin > rMax) {
+            return;
+        }
+        int cmargin = cm.getColumnMargin();
+        for (int row = rMin; row <= rMax; row++) {
+            int y = rowY(row);
+            int h = getRowHeight(row);
+            int rm = Math.min(rowMargin, h);
+            for (int col = cMin; col <= cMax; col++) {
+                if (row == editingRow && col == editingColumn && editorComp != null) {
+                    continue;
+                }
+                int w = xs[col + 1] - xs[col];
+                int m = Math.min(cmargin, w);
+                TableCellRenderer renderer = getCellRenderer(row, col);
+                if (renderer == null) {
+                    continue;
+                }
+                Component c = prepareRenderer(renderer, row, col);
+                CellPainter.paint(g, c, xs[col] + m / 2, y + rm / 2, w - m, h - rm);
+            }
+        }
+        if (gridColor != null && (showHorizontalLines || showVerticalLines)) {
+            g.setColor(gridColor);
+            int right = xs[cMax + 1] - 1;
+            int bottom = rowY(rMax) + getRowHeight(rMax) - 1;
+            if (showHorizontalLines) {
+                for (int row = rMin; row <= rMax; row++) {
+                    int y = rowY(row) + getRowHeight(row) - 1;
+                    g.drawLine(xs[cMin], y, right, y);
+                }
+            }
+            if (showVerticalLines) {
+                for (int col = cMin; col <= cMax; col++) {
+                    int x = xs[col + 1] - 1;
+                    g.drawLine(x, rowY(rMin), x, bottom);
+                }
+            }
+        }
+    }
+
+    private void repaintRows(int first, int last) {
+        int rows = getRowCount();
+        if (rows <= 0) {
+            repaint();
+            return;
+        }
+        int a = Math.max(0, Math.min(first, last));
+        int b = Math.min(rows - 1, Math.max(first, last));
+        if (a > b) {
+            return;
+        }
+        int y = rowY(a);
+        repaint(0, y, getWidth(), rowY(b) + getRowHeight(b) - y);
+    }
+
+    // ------------------------------------------------------------ editing
+
+    public boolean editCellAt(int row, int column) {
+        return editCellAt(row, column, null);
+    }
+
+    /// Starts editing a cell if the model and the editor allow it for the
+    /// event: the editor's component is placed over the cell as a child
+    /// of the table. An edit in progress is stopped first.
+    public boolean editCellAt(int row, int column, EventObject e) {
+        if (cellEditor != null && !cellEditor.stopCellEditing()) {
+            return false;
+        }
+        if (row < 0 || row >= getRowCount() || column < 0 || column >= getColumnCount()) {
+            return false;
+        }
+        if (!isCellEditable(row, column)) {
+            return false;
+        }
+        TableCellEditor editor = getCellEditor(row, column);
+        if (editor == null || !editor.isCellEditable(e)) {
+            return false;
+        }
+        Component c = prepareEditor(editor, row, column);
+        if (c == null) {
+            removeEditor();
+            return false;
+        }
+        editorComp = c;
+        c.setBounds(getCellRect(row, column, false));
+        add(c);
+        setCellEditor(editor);
+        setEditingRow(row);
+        setEditingColumn(column);
+        editor.addCellEditorListener(this);
+        if (editorKeys == null) {
+            editorKeys = new EditorKeys();
+        }
+        c.addKeyListener(editorKeys);
+        revalidate();
+        repaint();
+        return true;
+    }
+
+    public boolean isEditing() {
+        return cellEditor != null;
+    }
+
+    public Component getEditorComponent() {
+        return editorComp;
+    }
+
+    public int getEditingColumn() {
+        return editingColumn;
+    }
+
+    public int getEditingRow() {
+        return editingRow;
+    }
+
+    public void setEditingColumn(int aColumn) {
+        editingColumn = aColumn;
+    }
+
+    public void setEditingRow(int aRow) {
+        editingRow = aRow;
+    }
+
+    public TableCellEditor getCellEditor() {
+        return cellEditor;
+    }
+
+    public void setCellEditor(TableCellEditor anEditor) {
+        TableCellEditor old = cellEditor;
+        cellEditor = anEditor;
+        firePropertyChange("tableCellEditor", old, anEditor);
+    }
+
+    public TableCellEditor getCellEditor(int row, int column) {
+        TableColumn c = getColumnModel().getColumn(column);
+        TableCellEditor editor = c.getCellEditor();
+        return editor != null ? editor : getDefaultEditor(getColumnClass(column));
+    }
+
+    public Component prepareEditor(TableCellEditor editor, int row, int column) {
+        return editor.getTableCellEditorComponent(this, getValueAt(row, column), isCellSelected(row, column), row,
+                column);
+    }
+
+    /// Takes the editor's component off the table and forgets the edit,
+    /// without storing anything.
+    public void removeEditor() {
+        TableCellEditor editor = getCellEditor();
+        if (editor == null) {
+            return;
+        }
+        editor.removeCellEditorListener(this);
+        Component c = editorComp;
+        int row = editingRow;
+        setCellEditor(null);
+        setEditingColumn(-1);
+        setEditingRow(-1);
+        editorComp = null;
+        if (c != null) {
+            if (editorKeys != null) {
+                c.removeKeyListener(editorKeys);
+            }
+            boolean focused = c.isFocusOwner();
+            remove(c);
+            if (focused) {
+                requestFocusInWindow();
+            }
+        }
+        if (row >= 0 && row < getRowCount()) {
+            repaintRows(row, row);
+        } else {
+            repaint();
+        }
+    }
+
+    /// The editor finished: its value goes to the model.
+    @Override
+    public void editingStopped(ChangeEvent e) {
+        TableCellEditor editor = getCellEditor();
+        if (editor != null) {
+            Object value = editor.getCellEditorValue();
+            int row = editingRow;
+            int column = editingColumn;
+            removeEditor();
+            if (row >= 0 && row < getRowCount() && column >= 0 && column < getColumnCount()) {
+                setValueAt(value, row, column);
+            }
+        }
+    }
+
+    @Override
+    public void editingCanceled(ChangeEvent e) {
+        removeEditor();
+    }
+
+    // ------------------------------------------------------------ model events
+
+    public void setModel(TableModel dataModel) {
+        if (dataModel == null) {
+            throw new IllegalArgumentException("Cannot set a null TableModel");
+        }
+        if (this.dataModel != dataModel) {
+            TableModel old = this.dataModel;
+            if (old != null) {
+                old.removeTableModelListener(this);
+            }
+            this.dataModel = dataModel;
+            dataModel.addTableModelListener(this);
+            tableChanged(new TableModelEvent(dataModel, TableModelEvent.HEADER_ROW));
+            firePropertyChange("model", old, dataModel);
+            if (autoCreateRowSorter) {
+                setRowSorter(new TableRowSorter<TableModel>(dataModel));
+            }
+        }
+    }
+
+    public TableModel getModel() {
+        return dataModel;
+    }
+
+    public void setColumnModel(TableColumnModel columnModel) {
+        if (columnModel == null) {
+            throw new IllegalArgumentException("Cannot set a null ColumnModel");
+        }
+        TableColumnModel old = this.columnModel;
+        if (columnModel != old) {
+            if (old != null) {
+                old.removeColumnModelListener(this);
+            }
+            this.columnModel = columnModel;
+            columnModel.addColumnModelListener(this);
+            if (tableHeader != null) {
+                tableHeader.setColumnModel(columnModel);
+            }
+            firePropertyChange("columnModel", old, columnModel);
+            resizeAndRepaint();
+        }
+    }
+
+    public TableColumnModel getColumnModel() {
+        return columnModel;
+    }
+
+    public void setSelectionModel(ListSelectionModel newModel) {
+        if (newModel == null) {
+            throw new IllegalArgumentException("Cannot set a null SelectionModel");
+        }
+        ListSelectionModel old = selectionModel;
+        if (newModel != old) {
+            if (old != null) {
+                old.removeListSelectionListener(this);
+            }
+            selectionModel = newModel;
+            newModel.addListSelectionListener(this);
+            firePropertyChange("selectionModel", old, newModel);
+            repaint();
+        }
+    }
+
+    public ListSelectionModel getSelectionModel() {
+        return selectionModel;
+    }
+
+    /// The model rows that are selected, read through the sorter as it is
+    /// now.
+    private int[] selectedModelRows() {
+        int[] view = getSelectedRows();
+        int[] out = new int[view.length];
+        int n = 0;
+        for (int i = 0; i < view.length; i++) {
+            if (view[i] < getRowCount()) {
+                out[n++] = convertRowIndexToModel(view[i]);
+            }
+        }
+        if (n == out.length) {
+            return out;
+        }
+        int[] cut = new int[n];
+        System.arraycopy(out, 0, cut, 0, n);
+        return cut;
+    }
+
+    /// Selects the view rows that show the given model rows; a negative
+    /// entry is a row that is gone.
+    private void selectModelRows(int[] modelRows) {
+        selectionModel.setValueIsAdjusting(true);
+        try {
+            selectionModel.clearSelection();
+            for (int i = 0; i < modelRows.length; i++) {
+                int m = modelRows[i];
+                if (m < 0 || m >= dataModel.getRowCount()) {
+                    continue;
+                }
+                int v = convertRowIndexToView(m);
+                if (v >= 0) {
+                    selectionModel.addSelectionInterval(v, v);
+                }
+            }
+        } finally {
+            selectionModel.setValueIsAdjusting(false);
+        }
+    }
+
+    /// The model changed while a sorter stands between it and the view:
+    /// the sorter is told, and the selection follows the model rows it
+    /// was on.
+    private void sortedTableChanged(TableModelEvent e) {
+        int first = e.getFirstRow();
+        int last = e.getLastRow();
+        int type = e.getType();
+        boolean all = type == TableModelEvent.UPDATE && last == Integer.MAX_VALUE;
+        int[] selected = all ? new int[0] : selectedModelRows();
+        ignoreSorter = true;
+        try {
+            if (all) {
+                sorter.allRowsChanged();
+            } else if (type == TableModelEvent.INSERT) {
+                int length = last - first + 1;
+                for (int i = 0; i < selected.length; i++) {
+                    if (selected[i] >= first) {
+                        selected[i] += length;
+                    }
+                }
+                sorter.rowsInserted(first, last);
+            } else if (type == TableModelEvent.DELETE) {
+                int length = last - first + 1;
+                for (int i = 0; i < selected.length; i++) {
+                    if (selected[i] > last) {
+                        selected[i] -= length;
+                    } else if (selected[i] >= first) {
+                        selected[i] = -1;
+                    }
+                }
+                sorter.rowsDeleted(first, last);
+            } else if (e.getColumn() == TableModelEvent.ALL_COLUMNS) {
+                sorter.rowsUpdated(first, last);
+            } else {
+                sorter.rowsUpdated(first, last, e.getColumn());
+            }
+        } finally {
+            ignoreSorter = false;
+        }
+        rowHeights = null;
+        rowTops = null;
+        selectModelRows(selected);
+        resizeAndRepaint();
+    }
+
+    /// The table's model changed: rows are redrawn, the selection is
+    /// shifted with inserted and removed rows, and after a change of
+    /// structure the columns are made again if the table makes its own.
+    @Override
+    public void tableChanged(TableModelEvent e) {
+        if (e == null || e.getFirstRow() == TableModelEvent.HEADER_ROW) {
+            if (isEditing()) {
+                removeEditor();
+            }
+            if (selectionModel != null) {
+                clearSelection();
+            }
+            rowHeights = null;
+            rowTops = null;
+            if (sorter != null) {
+                if (autoCreateRowSorter) {
+                    setRowSorter(new TableRowSorter<TableModel>(dataModel));
+                } else {
+                    ignoreSorter = true;
+                    try {
+                        sorter.modelStructureChanged();
+                    } finally {
+                        ignoreSorter = false;
+                    }
+                }
+            }
+            if (getAutoCreateColumnsFromModel()) {
+                createDefaultColumnsFromModel();
+            }
+            resizeAndRepaint();
+            if (tableHeader != null) {
+                tableHeader.resizeAndRepaint();
+            }
+            return;
+        }
+        int first = e.getFirstRow();
+        int last = e.getLastRow();
+        int type = e.getType();
+        if (isEditing() && (type != TableModelEvent.UPDATE || last == Integer.MAX_VALUE)) {
+            removeEditor();
+        }
+        if (sorter != null) {
+            sortedTableChanged(e);
+            return;
+        }
+        if (type == TableModelEvent.INSERT) {
+            int start = Math.max(0, first);
+            int end = last < 0 ? getRowCount() - 1 : last;
+            selectionModel.insertIndexInterval(start, end - start + 1, true);
+            rowHeights = null;
+            rowTops = null;
+            resizeAndRepaint();
+        } else if (type == TableModelEvent.DELETE) {
+            int start = Math.max(0, first);
+            int end = last < 0 ? getRowCount() - 1 : last;
+            selectionModel.removeIndexInterval(start, end);
+            rowHeights = null;
+            rowTops = null;
+            resizeAndRepaint();
+        } else if (last == Integer.MAX_VALUE) {
+            clearSelection();
+            rowHeights = null;
+            rowTops = null;
+            resizeAndRepaint();
+        } else {
+            repaintRows(first, last);
+        }
+    }
+
+    /// The sorter changed the order or the set of rows: the selection is
+    /// moved to where its rows went, and the table is drawn again.
+    @Override
+    public void sorterChanged(RowSorterEvent e) {
+        if (e.getType() == RowSorterEvent.Type.SORT_ORDER_CHANGED) {
+            if (tableHeader != null) {
+                tableHeader.repaint();
+            }
+            return;
+        }
+        if (ignoreSorter) {
+            return;
+        }
+        if (isEditing()) {
+            removeEditor();
+        }
+        int[] view = getSelectedRows();
+        int[] model = new int[view.length];
+        for (int i = 0; i < view.length; i++) {
+            model[i] = updateSelectionOnSort ? e.convertPreviousRowIndexToModel(view[i]) : -1;
+        }
+        rowHeights = null;
+        rowTops = null;
+        selectModelRows(model);
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnAdded(TableColumnModelEvent e) {
+        if (isEditing()) {
+            removeEditor();
+        }
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnRemoved(TableColumnModelEvent e) {
+        if (isEditing()) {
+            removeEditor();
+        }
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnMoved(TableColumnModelEvent e) {
+        if (isEditing() && e.getFromIndex() != e.getToIndex()) {
+            removeEditor();
+        }
+        repaint();
+    }
+
+    /// A column's width or the gap between columns changed. Outside the
+    /// table's own layout this asks for a new layout; a column the header
+    /// is dragging keeps its width as its preferred one when the table
+    /// does not resize the others.
+    @Override
+    public void columnMarginChanged(ChangeEvent e) {
+        if (inLayout) {
+            repaint();
+            return;
+        }
+        TableColumn resizing = tableHeader == null ? null : tableHeader.getResizingColumn();
+        if (resizing != null && autoResizeMode == AUTO_RESIZE_OFF) {
+            resizing.setPreferredWidth(resizing.getWidth());
+        }
+        if (isEditing() && editorComp != null) {
+            editorComp.setBounds(getCellRect(editingRow, editingColumn, false));
+        }
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnSelectionChanged(ListSelectionEvent e) {
+        repaint();
+    }
+
+    /// The row selection changed: the rows concerned are drawn again.
+    @Override
+    public void valueChanged(ListSelectionEvent e) {
+        if (getColumnCount() <= 0 || getRowCount() <= 0) {
+            return;
+        }
+        repaintRows(e.getFirstIndex(), e.getLastIndex());
+    }
+
+    // ------------------------------------------------------------ pointer
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        if (isEnabled()) {
+            pointer(e);
+        }
+        super.processMouseEvent(e);
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        if (isEnabled() && e.getID() == MouseEvent.MOUSE_DRAGGED) {
+            if (dndArmed != null || dndStarted) {
+                // A drag of the data, which neither scrolls the table nor
+                // moves its selection.
+                dragDnd(e);
+            } else if (pressTouch) {
+                ScrollDelegate.forward(this, e);
+            } else if (pressOnCell && !isEditing()) {
+                int row = rowAtPoint(e.getPoint());
+                int col = columnAtPoint(e.getPoint());
+                if (row >= 0 && col >= 0 && !isCellSelectedAsLead(row, col)) {
+                    changeSelection(row, col, false, true);
+                }
+            }
+        }
+        super.processMouseMotionEvent(e);
+    }
+
+    private boolean isCellSelectedAsLead(int row, int col) {
+        return selectionModel.getLeadSelectionIndex() == row
+                && columnModel.getSelectionModel().getLeadSelectionIndex() == col;
+    }
+
+    private boolean overEditor(MouseEvent e) {
+        return editorComp != null && editorComp.getBounds().contains(e.getX(), e.getY());
+    }
+
+    private void pointer(MouseEvent e) {
+        switch (e.getID()) {
+            case MouseEvent.MOUSE_PRESSED:
+                pressTouch = CellTheme.touch();
+                pressOnCell = false;
+                dndArmed = null;
+                dndStarted = false;
+                dndTouch = false;
+                if (overEditor(e)) {
+                    return;
+                }
+                if (pressTouch) {
+                    if (cn1DragEnabled && !isEditing()
+                            && canStartDrag(rowAtPoint(e.getPoint()), columnAtPoint(e.getPoint()), true)
+                            && dragAction(e) != TransferHandler.NONE) {
+                        // A finger on a selected cell drags it; the tap
+                        // that follows when it does not is a click.
+                        dndArmed = e;
+                        dndTouch = true;
+                    } else {
+                        ScrollDelegate.forward(this, e);
+                    }
+                } else if (e.getButton() == MouseEvent.BUTTON1) {
+                    if (cn1DragEnabled) {
+                        pressDnd(e);
+                    } else {
+                        select(e);
+                    }
+                }
+                break;
+            case MouseEvent.MOUSE_RELEASED:
+                if (pressTouch) {
+                    if (!dndTouch) {
+                        ScrollDelegate.forward(this, e);
+                    }
+                    dndArmed = null;
+                } else if (dndArmed != null) {
+                    MouseEvent armed = dndArmed;
+                    dndArmed = null;
+                    if (!dndPressSelected) {
+                        select(armed);
+                    }
+                }
+                break;
+            case MouseEvent.MOUSE_CLICKED:
+                if (pressTouch && !overEditor(e)) {
+                    select(e);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    /// What a press with a mouse, or a tap with a finger, does to the cell
+    /// under it: starts editing if the editor wants to for this event,
+    /// and moves the selection there.
+    private void select(MouseEvent event) {
+        MouseEvent e = event;
+        int row = rowAtPoint(e.getPoint());
+        int col = columnAtPoint(e.getPoint());
+        if (row < 0 || col < 0) {
+            if (isEditing() && !getCellEditor().stopCellEditing()) {
+                getCellEditor().cancelCellEditing();
+            }
+            requestFocusInWindow();
+            return;
+        }
+        // Clicks are counted by time alone, so a quick press on another
+        // cell arrives as a second click: count from the cell's own first.
+        int clicks = e.getClickCount();
+        if (row != pressRow || col != pressColumn || clicks <= 1) {
+            clickBase = clicks - 1;
+        }
+        pressRow = row;
+        pressColumn = col;
+        pressOnCell = true;
+        if (clickBase > 0) {
+            e = new MouseEvent(this, e.getID(), e.getWhen(), e.getModifiers(), e.getX(), e.getY(),
+                    clicks - clickBase, e.isPopupTrigger(), e.getButton());
+        }
+        boolean editing = editCellAt(row, col, e);
+        TableCellEditor editor = getCellEditor();
+        if (!editing) {
+            requestFocusInWindow();
+        }
+        if (!editing || editor == null || editor.shouldSelectCell(e)) {
+            changeSelection(row, col, e.isControlDown() || e.isMetaDown(), e.isShiftDown());
+        }
+        if (editing && editorComp != null) {
+            startedBy(null);
+        }
+    }
+
+    /// Hands a freshly placed editor the input that started it: a check
+    /// box is clicked, a text field gets the typed character, and the
+    /// component is focused so that the keyboard goes to it.
+    private void startedBy(String typed) {
+        Component c = editorComp;
+        if (c instanceof JCheckBox) {
+            ((JCheckBox) c).doClick();
+            return;
+        }
+        if (typed != null && c instanceof JTextComponent) {
+            ((JTextComponent) c).setText(typed);
+        }
+        c.requestFocus();
+        com.codename1.ui.Component peer = c.cn1PeerOrNull();
+        if (peer instanceof com.codename1.ui.TextArea && peer.getComponentForm() != null && CellTheme.touch()) {
+            ((com.codename1.ui.TextArea) peer).startEditingAsync();
+        }
+    }
+
+    // ------------------------------------------------------------ keys
+
+    @Override
+    protected void processKeyEvent(KeyEvent e) {
+        if (isEnabled() && !e.isConsumed()) {
+            if (e.getID() == KeyEvent.KEY_PRESSED) {
+                keyPressed(e);
+            } else if (e.getID() == KeyEvent.KEY_TYPED) {
+                keyTyped(e);
+            }
+        }
+        super.processKeyEvent(e);
+    }
+
+    private int visibleRows() {
+        Container p = getParent();
+        int h = p instanceof JViewport ? p.getHeight() : getHeight();
+        int rh = getRowHeight();
+        return rh <= 0 ? 1 : Math.max(1, h / rh);
+    }
+
+    /// Moves the lead cell by a number of rows and columns; past the last
+    /// column a move wraps to the next row when `wrap` is set.
+    private void move(int dRow, int dCol, boolean wrap, boolean extend) {
+        int rows = getRowCount();
+        int columns = getColumnCount();
+        if (rows <= 0 || columns <= 0) {
+            return;
+        }
+        int row = selectionModel.getLeadSelectionIndex();
+        int col = columnModel.getSelectionModel().getLeadSelectionIndex();
+        if (row < 0 || col < 0) {
+            row = Math.max(0, row);
+            col = Math.max(0, col);
+            dRow = 0;
+            dCol = 0;
+        }
+        row += dRow;
+        col += dCol;
+        if (wrap) {
+            if (col >= columns) {
+                col = 0;
+                row++;
+            } else if (col < 0) {
+                col = columns - 1;
+                row--;
+            }
+            if (row >= rows) {
+                row = 0;
+            } else if (row < 0) {
+                row = rows - 1;
+            }
+        }
+        row = Math.max(0, Math.min(row, rows - 1));
+        col = Math.max(0, Math.min(col, columns - 1));
+        changeSelection(row, col, false, extend);
+    }
+
+    private void keyPressed(KeyEvent e) {
+        boolean shift = e.isShiftDown();
+        switch (e.getKeyCode()) {
+            case KeyEvent.VK_UP:
+                move(-1, 0, false, shift);
+                break;
+            case KeyEvent.VK_DOWN:
+                move(1, 0, false, shift);
+                break;
+            case KeyEvent.VK_LEFT:
+                move(0, -1, false, shift);
+                break;
+            case KeyEvent.VK_RIGHT:
+                move(0, 1, false, shift);
+                break;
+            case KeyEvent.VK_HOME:
+                move(0, -getColumnCount(), false, shift);
+                break;
+            case KeyEvent.VK_END:
+                move(0, getColumnCount(), false, shift);
+                break;
+            case KeyEvent.VK_PAGE_UP:
+                move(-visibleRows(), 0, false, shift);
+                break;
+            case KeyEvent.VK_PAGE_DOWN:
+                move(visibleRows(), 0, false, shift);
+                break;
+            case KeyEvent.VK_ENTER:
+                if (isEditing() && !getCellEditor().stopCellEditing()) {
+                    break;
+                }
+                move(shift ? -1 : 1, 0, false, false);
+                break;
+            case KeyEvent.VK_TAB:
+                if (isEditing() && !getCellEditor().stopCellEditing()) {
+                    break;
+                }
+                move(0, shift ? -1 : 1, true, false);
+                break;
+            case KeyEvent.VK_ESCAPE:
+                if (isEditing()) {
+                    getCellEditor().cancelCellEditing();
+                }
+                break;
+            case KeyEvent.VK_F2:
+                editLead(null);
+                break;
+            default:
+                return;
+        }
+        e.consume();
+    }
+
+    private void editLead(String typed) {
+        int row = selectionModel.getLeadSelectionIndex();
+        int col = columnModel.getSelectionModel().getLeadSelectionIndex();
+        if (row < 0 || col < 0 || isEditing()) {
+            return;
+        }
+        if (editCellAt(row, col, null) && editorComp != null) {
+            startedBy(typed);
+        }
+    }
+
+    private void keyTyped(KeyEvent e) {
+        char ch = e.getKeyChar();
+        if (ch == KeyEvent.CHAR_UNDEFINED || ch < ' ' || ch == 127 || isEditing() || e.isControlDown()
+                || e.isMetaDown() || e.isAltDown()) {
+            return;
+        }
+        editLead(String.valueOf(ch));
+        if (isEditing()) {
+            e.consume();
+        }
+    }
+
+    /// The keys that end an edit, heard on the editor's component: the
+    /// component has the focus while it edits.
+    private final class EditorKeys extends KeyAdapter {
+        @Override
+        public void keyPressed(KeyEvent e) {
+            if (!isEditing()) {
+                return;
+            }
+            int code = e.getKeyCode();
+            if (code == KeyEvent.VK_ESCAPE) {
+                getCellEditor().cancelCellEditing();
+                e.consume();
+            } else if (code == KeyEvent.VK_ENTER || code == KeyEvent.VK_TAB) {
+                if (getCellEditor().stopCellEditing()) {
+                    if (code == KeyEvent.VK_TAB) {
+                        move(0, e.isShiftDown() ? -1 : 1, true, false);
+                    }
+                }
+                e.consume();
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ Scrollable
+
+    public void setPreferredScrollableViewportSize(Dimension size) {
+        if (size == null) {
+            throw new IllegalArgumentException("size must be non-null");
+        }
+        preferredViewportSize = size;
+    }
+
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        return preferredViewportSize;
+    }
+
+    /// A row, or the width of the column at the edge.
+    @Override
+    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+        if (orientation == SwingConstants.VERTICAL) {
+            return getRowHeight();
+        }
+        int col = getColumnModel().getColumnIndexAtX(direction < 0 ? Math.max(0, visibleRect.x - 1) : visibleRect.x);
+        if (col < 0) {
+            return 100;
+        }
+        return Math.max(1, getColumnModel().getColumn(col).getWidth());
+    }
+
+    /// The visible height less a row, or the visible width.
+    @Override
+    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
+        if (orientation == SwingConstants.VERTICAL) {
+            int rh = getRowHeight();
+            return Math.max(rh, visibleRect.height - rh);
+        }
+        return Math.max(1, visibleRect.width);
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        return autoResizeMode != AUTO_RESIZE_OFF;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportHeight() {
+        Container parent = getParent();
+        return getFillsViewportHeight() && parent instanceof JViewport
+                && parent.getHeight() > getPreferredSize().height;
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",autoResizeMode=" + autoResizeMode + ",rowHeight=" + getRowHeight();
+    }
+
+    // ------------------------------------------------------------ defaults
+
+    /// Numbers: the value's string, at the trailing edge.
+    private static final class NumberRenderer extends DefaultTableCellRenderer {
+        NumberRenderer() {
+            setHorizontalAlignment(SwingConstants.RIGHT);
+        }
+    }
+
+    /// Floats and doubles: the number as the default number format
+    /// writes it -- grouped, with at most three fraction digits and none
+    /// that are zero, so 44.0 is `44` -- at the trailing edge.
+    private static final class DoubleRenderer extends DefaultTableCellRenderer {
+        private java.text.NumberFormat format;
+
+        DoubleRenderer() {
+            setHorizontalAlignment(SwingConstants.RIGHT);
+        }
+
+        @Override
+        protected void setValue(Object value) {
+            if (value instanceof Number) {
+                if (format == null) {
+                    format = java.text.NumberFormat.getInstance();
+                }
+                setText(format.format(((Number) value).doubleValue()));
+            } else {
+                setText(value == null ? "" : value.toString());
+            }
+        }
+    }
+
+    /// Dates: the date in the default date format.
+    private static final class DateRenderer extends DefaultTableCellRenderer {
+        private java.text.DateFormat format;
+
+        @Override
+        protected void setValue(Object value) {
+            if (value instanceof java.util.Date) {
+                if (format == null) {
+                    format = java.text.DateFormat.getDateInstance();
+                }
+                setText(format.format((java.util.Date) value));
+            } else {
+                setText(value == null ? "" : value.toString());
+            }
+        }
+    }
+
+    /// Icons: the icon, centered, and no text.
+    private static final class IconRenderer extends DefaultTableCellRenderer {
+        IconRenderer() {
+            setHorizontalAlignment(SwingConstants.CENTER);
+        }
+
+        @Override
+        protected void setValue(Object value) {
+            setIcon(value instanceof Icon ? (Icon) value : null);
+            setText("");
+        }
+    }
+
+    /// Booleans: a check box.
+    private static final class BooleanRenderer extends JCheckBox implements TableCellRenderer {
+        BooleanRenderer() {
+            setHorizontalAlignment(SwingConstants.CENTER);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                boolean hasFocus, int row, int column) {
+            Color fg = isSelected ? table.getSelectionForeground() : table.getForeground();
+            Color bg = isSelected ? table.getSelectionBackground() : table.getBackground();
+            if (fg != null && !fg.equals(isForegroundSet() ? getForeground() : null)) {
+                setForeground(fg);
+            }
+            if (bg != null && !bg.equals(isBackgroundSet() ? getBackground() : null)) {
+                setBackground(bg);
+            }
+            boolean on = value instanceof Boolean && ((Boolean) value).booleanValue();
+            if (on != isSelected()) {
+                setSelected(on);
+            }
+            return this;
+        }
+
+        @Override
+        public void revalidate() {
+        }
+
+        @Override
+        public void repaint(long tm, int x, int y, int width, int height) {
+        }
+
+        @Override
+        public void repaint() {
+        }
+    }
+
+    /// The text editor of the default editors. Its value is the text, or
+    /// for a column of a number class the number the text parses to; text
+    /// that is no such number keeps the editor open.
+    private static final class ValueEditor extends DefaultCellEditor {
+
+        private Class<?> type;
+        private Object parsed;
+
+        ValueEditor(boolean number) {
+            super(new JTextField());
+            if (number && editorComponent instanceof JTextField) {
+                ((JTextField) editorComponent).setHorizontalAlignment(SwingConstants.RIGHT);
+            }
+        }
+
+        @Override
+        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row,
+                int column) {
+            type = table.getColumnClass(column);
+            parsed = null;
+            return super.getTableCellEditorComponent(table, value, isSelected, row, column);
+        }
+
+        private static Object parse(Class<?> type, String s) {
+            if (type == null || type == Object.class || type == String.class) {
+                return s;
+            }
+            String t = s.trim();
+            if (type == Integer.class) {
+                return Integer.valueOf(t);
+            }
+            if (type == Long.class) {
+                return Long.valueOf(t);
+            }
+            if (type == Double.class || type == Number.class) {
+                return Double.valueOf(t);
+            }
+            if (type == Float.class) {
+                return Float.valueOf(t);
+            }
+            if (type == Short.class) {
+                return Short.valueOf(t);
+            }
+            if (type == Byte.class) {
+                return Byte.valueOf(t);
+            }
+            return s;
+        }
+
+        @Override
+        public boolean stopCellEditing() {
+            Object text = super.getCellEditorValue();
+            String s = text == null ? "" : text.toString();
+            if (s.length() == 0 && type != null && type != String.class && type != Object.class) {
+                parsed = null;
+                return super.stopCellEditing();
+            }
+            try {
+                parsed = parse(type, s);
+            } catch (NumberFormatException e) {
+                return false;
+            }
+            return super.stopCellEditing();
+        }
+
+        @Override
+        public Object getCellEditorValue() {
+            return parsed;
+        }
+    }
+
+    // ------------------------------------------------------------ drag
+
+    /// Whether dragging a row begins a drag of the data of the table's
+    /// `TransferHandler`. As in Swing a drag begins on a cell that is
+    /// already selected, or on any cell when one row and one column at
+    /// most can be selected; a press elsewhere selects. With a finger it
+    /// is always a selected cell, and a drag anywhere else scrolls.
+    public void setDragEnabled(boolean b) {
+        cn1DragEnabled = b;
+    }
+
+    public boolean getDragEnabled() {
+        return cn1DragEnabled;
+    }
+
+    private boolean cn1DragEnabled;
+    private DropMode dropMode = DropMode.USE_SELECTION;
+    private transient DropLocation dropLocation;
+    private MouseEvent dndArmed;
+    private boolean dndStarted;
+    private boolean dndPressSelected;
+
+    /// Sets how the table shows where a drop would go.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `dropMode` is `null`
+    public final void setDropMode(DropMode dropMode) {
+        if (dropMode == null) {
+            throw new IllegalArgumentException("null: Unsupported drop mode for table");
+        }
+        this.dropMode = dropMode;
+    }
+
+    public final DropMode getDropMode() {
+        return dropMode;
+    }
+
+    /// Where a drag over the table would be dropped, `null` when there is
+    /// none or its place is not to be shown.
+    public final DropLocation getDropLocation() {
+        return dropLocation;
+    }
+
+    /// Where in a table a drop would go.
+    public static final class DropLocation extends TransferHandler.DropLocation {
+
+        private final int row;
+        private final int col;
+        private final boolean isInsertRow;
+        private final boolean isInsertCol;
+
+        private DropLocation(Point p, int row, int col, boolean isInsertRow, boolean isInsertCol) {
+            super(p);
+            this.row = row;
+            this.col = col;
+            this.isInsertRow = isInsertRow;
+            this.isInsertCol = isInsertCol;
+        }
+
+        /// The row of the cell the drop goes on, or the row it goes
+        /// before; the number of rows for the end of the table.
+        public int getRow() {
+            return row;
+        }
+
+        public int getColumn() {
+            return col;
+        }
+
+        public boolean isInsertRow() {
+            return isInsertRow;
+        }
+
+        public boolean isInsertColumn() {
+            return isInsertCol;
+        }
+
+        @Override
+        public String toString() {
+            return getClass().getName() + "[dropPoint=" + getDropPoint() + ",row=" + row + ",column=" + col
+                    + ",insertRow=" + isInsertRow + ",insertColumn=" + isInsertCol + "]";
+        }
+    }
+
+    private static final int LEADING_PART = 0;
+    private static final int MIDDLE_PART = 1;
+    private static final int TRAILING_PART = 2;
+
+    /// Which part of a cell a coordinate lies in: of three, where the
+    /// outer two are a third of the cell and ten pixels at most, or of
+    /// two halves.
+    private static int part(int p0, int length, int p, boolean three) {
+        if (three) {
+            int boundary = length >= 30 ? 10 : length / 3;
+            if (p < p0 + boundary) {
+                return LEADING_PART;
+            }
+            if (p >= p0 + length - boundary) {
+                return TRAILING_PART;
+            }
+            return MIDDLE_PART;
+        }
+        return p >= p0 + length / 2 ? TRAILING_PART : LEADING_PART;
+    }
+
+    @Override
+    TransferHandler.DropLocation dropLocationForPoint(Point p) {
+        int row = rowAtPoint(p);
+        int col = columnAtPoint(p);
+        Rectangle rect = getCellRect(row, col, true);
+        boolean between = false;
+        int xs;
+        int ys;
+        switch (dropMode) {
+            case INSERT:
+                if (row == -1 && col == -1) {
+                    return new DropLocation(p, 0, 0, true, true);
+                }
+                xs = part(rect.x, rect.width, p.x, true);
+                if (row == -1) {
+                    if (xs == LEADING_PART) {
+                        return new DropLocation(p, getRowCount(), col, true, true);
+                    }
+                    if (xs == TRAILING_PART) {
+                        return new DropLocation(p, getRowCount(), col + 1, true, true);
+                    }
+                    return new DropLocation(p, getRowCount(), col, true, false);
+                }
+                if (xs == LEADING_PART || xs == TRAILING_PART) {
+                    ys = part(rect.y, rect.height, p.y, true);
+                    if (ys == LEADING_PART) {
+                        between = true;
+                    } else if (ys == TRAILING_PART) {
+                        row++;
+                        between = true;
+                    }
+                    return new DropLocation(p, row, xs == TRAILING_PART ? col + 1 : col, between, true);
+                }
+                if (part(rect.y, rect.height, p.y, false) == TRAILING_PART) {
+                    row++;
+                }
+                return new DropLocation(p, row, col, true, false);
+            case INSERT_ROWS:
+                if (row == -1 && col == -1) {
+                    return new DropLocation(p, -1, -1, false, false);
+                }
+                if (row == -1) {
+                    return new DropLocation(p, getRowCount(), col, true, false);
+                }
+                if (part(rect.y, rect.height, p.y, false) == TRAILING_PART) {
+                    row++;
+                }
+                return new DropLocation(p, row, col, true, false);
+            case ON_OR_INSERT_ROWS:
+                if (row == -1 && col == -1) {
+                    return new DropLocation(p, -1, -1, false, false);
+                }
+                if (row == -1) {
+                    return new DropLocation(p, getRowCount(), col, true, false);
+                }
+                ys = part(rect.y, rect.height, p.y, true);
+                if (ys == LEADING_PART) {
+                    between = true;
+                } else if (ys == TRAILING_PART) {
+                    row++;
+                    between = true;
+                }
+                return new DropLocation(p, row, col, between, false);
+            case INSERT_COLS:
+                if (row == -1) {
+                    return new DropLocation(p, -1, -1, false, false);
+                }
+                if (col == -1) {
+                    return new DropLocation(p, getColumnCount(), col, false, true);
+                }
+                if (part(rect.x, rect.width, p.x, false) == TRAILING_PART) {
+                    col++;
+                }
+                return new DropLocation(p, row, col, false, true);
+            case ON_OR_INSERT_COLS:
+                if (row == -1) {
+                    return new DropLocation(p, -1, -1, false, false);
+                }
+                if (col == -1) {
+                    return new DropLocation(p, row, getColumnCount(), false, true);
+                }
+                xs = part(rect.x, rect.width, p.x, true);
+                if (xs == LEADING_PART) {
+                    between = true;
+                } else if (xs == TRAILING_PART) {
+                    col++;
+                    between = true;
+                }
+                return new DropLocation(p, row, col, false, between);
+            case ON_OR_INSERT:
+                if (row == -1 && col == -1) {
+                    return new DropLocation(p, 0, 0, true, true);
+                }
+                xs = part(rect.x, rect.width, p.x, true);
+                if (row == -1) {
+                    if (xs == LEADING_PART) {
+                        return new DropLocation(p, getRowCount(), col, true, true);
+                    }
+                    if (xs == TRAILING_PART) {
+                        return new DropLocation(p, getRowCount(), col + 1, true, true);
+                    }
+                    return new DropLocation(p, getRowCount(), col, true, false);
+                }
+                ys = part(rect.y, rect.height, p.y, true);
+                if (ys == LEADING_PART) {
+                    between = true;
+                } else if (ys == TRAILING_PART) {
+                    row++;
+                    between = true;
+                }
+                return new DropLocation(p, row, xs == TRAILING_PART ? col + 1 : col, between, xs != MIDDLE_PART);
+            case USE_SELECTION:
+            case ON:
+            default:
+                if (row == -1 || col == -1) {
+                    return new DropLocation(p, -1, -1, false, false);
+                }
+                return new DropLocation(p, row, col, false, false);
+        }
+    }
+
+    @Override
+    Object setDropLocation(TransferHandler.DropLocation location, Object state, boolean forDrop) {
+        Object retVal = null;
+        DropLocation tableLocation = location instanceof DropLocation ? (DropLocation) location : null;
+        if (dropMode == DropMode.USE_SELECTION) {
+            if (tableLocation == null) {
+                if (!forDrop && state instanceof int[][]) {
+                    // The drag left without a drop: the selection it
+                    // moved about goes back to what it was.
+                    int[][] saved = (int[][]) state;
+                    clearSelection();
+                    for (int r : saved[0]) {
+                        if (r < getRowCount()) {
+                            addRowSelectionInterval(r, r);
+                        }
+                    }
+                    for (int c : saved[1]) {
+                        if (c < getColumnCount()) {
+                            addColumnSelectionInterval(c, c);
+                        }
+                    }
+                }
+            } else {
+                retVal = dropLocation == null ? new int[][]{getSelectedRows(), getSelectedColumns()} : state;
+                if (tableLocation.getRow() == -1) {
+                    clearSelection();
+                } else {
+                    setRowSelectionInterval(tableLocation.getRow(), tableLocation.getRow());
+                    setColumnSelectionInterval(tableLocation.getColumn(), tableLocation.getColumn());
+                }
+            }
+        }
+        DropLocation old = dropLocation;
+        dropLocation = tableLocation;
+        firePropertyChange("dropLocation", old, dropLocation);
+        if (old != dropLocation) {
+            repaint();
+        }
+        return retVal;
+    }
+
+    /// Draws the line that says between which rows or columns a drop
+    /// would go. A drop on a cell is shown by the cell, which its
+    /// renderer draws as it draws a selected one.
+    private void paintDropLines(Graphics g) {
+        DropLocation loc = dropLocation;
+        if (loc == null || (!loc.isInsertRow() && !loc.isInsertColumn())) {
+            return;
+        }
+        Color line = UIManager.getColor("Table.dropLineColor");
+        if (line == null) {
+            line = getSelectionBackground();
+        }
+        if (line == null) {
+            line = getForeground();
+        }
+        g.setColor(line);
+        if (loc.isInsertRow()) {
+            int rows = getRowCount();
+            int y;
+            if (rows == 0) {
+                y = 0;
+            } else if (loc.getRow() >= rows) {
+                Rectangle last = getCellRect(rows - 1, 0, true);
+                y = last.y + last.height;
+            } else {
+                y = getCellRect(loc.getRow(), 0, true).y;
+            }
+            y = y == 0 ? -1 : y - 2;
+            g.fillRect(0, y, getWidth(), 3);
+        }
+        if (loc.isInsertColumn()) {
+            int columns = getColumnCount();
+            int x;
+            if (columns == 0) {
+                x = 0;
+            } else if (loc.getColumn() >= columns) {
+                Rectangle last = getCellRect(0, columns - 1, true);
+                x = last.x + last.width;
+            } else {
+                x = getCellRect(0, loc.getColumn(), true).x;
+            }
+            x = x == 0 ? -1 : x - 2;
+            g.fillRect(x, 0, 3, getHeight());
+        }
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        super.paint(g);
+        paintDropLines(g);
+    }
+
+    /// The action a drag begun by `e` would ask for, [TransferHandler#NONE]
+    /// when it would begin none.
+    private int dragAction(MouseEvent e) {
+        TransferHandler th = getTransferHandler();
+        if (th == null || e.getButton() != MouseEvent.BUTTON1) {
+            return TransferHandler.NONE;
+        }
+        return Dnd.userAction(e.getModifiers() | e.getModifiersEx(), th.getSourceActions(this));
+    }
+
+    private boolean canStartDrag(int row, int col, boolean touch) {
+        if (row < 0 || col < 0) {
+            return false;
+        }
+        if (!touch && getSelectionModel().getSelectionMode() == ListSelectionModel.SINGLE_SELECTION
+                && getColumnModel().getSelectionModel().getSelectionMode() == ListSelectionModel.SINGLE_SELECTION) {
+            return true;
+        }
+        return isCellSelected(row, col);
+    }
+
+    /// A press with the mouse on a table that drags. A press on a
+    /// selected cell may be the start of a drag of the selection, which
+    /// is then left as it is until the button is let go without one.
+    private void pressDnd(MouseEvent e) {
+        int row = rowAtPoint(e.getPoint());
+        int col = columnAtPoint(e.getPoint());
+        dndPressSelected = true;
+        if (canStartDrag(row, col, false) && dragAction(e) != TransferHandler.NONE) {
+            dndArmed = e;
+            if (!e.isShiftDown() && !e.isControlDown() && !e.isMetaDown() && isCellSelected(row, col)) {
+                getSelectionModel().addSelectionInterval(row, row);
+                getColumnModel().getSelectionModel().addSelectionInterval(col, col);
+                dndPressSelected = false;
+                return;
+            }
+        }
+        select(e);
+    }
+
+    /// The pointer moved with a drag armed: past a few pixels the
+    /// handler's data is dragged.
+    private void dragDnd(MouseEvent e) {
+        MouseEvent armed = dndArmed;
+        if (armed == null) {
+            return;
+        }
+        if (Math.abs(e.getX() - armed.getX()) <= DRAG_THRESHOLD && Math.abs(e.getY() - armed.getY()) <= DRAG_THRESHOLD) {
+            return;
+        }
+        dndArmed = null;
+        TransferHandler th = getTransferHandler();
+        int action = dragAction(armed);
+        if (th != null && action != TransferHandler.NONE) {
+            dndStarted = true;
+            th.exportAsDrag(this, armed, action);
+        }
+    }
+
+    private static final int DRAG_THRESHOLD = 5;
+    private boolean dndTouch;
+
+    // ------------------------------------------------------------ print
+
+    /// How a table is fitted to the pages it is printed on.
+    public enum PrintMode {
+        /// At its own size, across as many pages as its width takes.
+        NORMAL,
+        /// Scaled down, if it must be, to the width of one page.
+        FIT_WIDTH
+    }
+
+    /// Always throws: see [#print(PrintMode, MessageFormat, MessageFormat)].
+    public boolean print() throws PrinterException {
+        return print(PrintMode.FIT_WIDTH);
+    }
+
+    public boolean print(PrintMode printMode) throws PrinterException {
+        return print(printMode, null, null);
+    }
+
+    /// Prints the table. A device has no print service to print to, so
+    /// this always ends the way it does on a desktop without a printer:
+    /// with a `PrinterException`.
+    public boolean print(PrintMode printMode, MessageFormat headerFormat, MessageFormat footerFormat)
+            throws PrinterException {
+        throw new PrinterException("No print service found.");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextArea.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextArea.java
new file mode 100644
index 00000000000..b0f741f266b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextArea.java
@@ -0,0 +1,473 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.Element;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.rt.TextAreaPeer;
+import com.codename1.desktopcompat.rt.Units;
+
+/// Several lines of plain text, shown and edited by a Codename One text
+/// area over a [PlainDocument].
+///
+/// The area grows with its text; put it in a [JScrollPane] to scroll it.
+/// Moving the caret brings its line into view, so the usual
+/// `setCaretPosition(getDocument().getLength())` after `append` follows a
+/// log to its end.
+///
+/// Lines are not wrapped unless `setLineWrap(true)` asks for it, as on
+/// the desktop: the area is then as wide as its longest line, and a scroll
+/// pane scrolls it sideways. With line wrap on it is as wide as the
+/// viewport and lines break at its width.
+///
+/// What differs from the desktop:
+///
+///  - The Codename One widget has no way of its own to leave a long line
+///    unbroken; it is kept from wrapping by being made wide enough. An
+///    unwrapped area that a layout makes narrower than its longest line,
+///    outside a scroll pane, wraps where the desktop would cut the line
+///    off.
+///  - Wrapped lines always break at word boundaries, and inside a word
+///    only when the word alone is longer than the line: that is what
+///    `setWrapStyleWord(true)` asks for, and `false` is recorded only.
+///  - A tab character is not expanded to a column; tab size is recorded
+///    only.
+public class JTextArea extends JTextComponent {
+
+    private int rows;
+    private int columns;
+    private boolean wrap;
+    private boolean word;
+    private boolean revealPending;
+    /// The width of the longest line in device pixels, or -1 when the
+    /// text or the font changed since it was measured.
+    private int widest = -1;
+    private com.codename1.ui.Font widestFont;
+    private final DocumentListener measureAgain = new DocumentListener() {
+        @Override
+        public void insertUpdate(DocumentEvent e) {
+            widest = -1;
+        }
+
+        @Override
+        public void removeUpdate(DocumentEvent e) {
+            widest = -1;
+        }
+
+        @Override
+        public void changedUpdate(DocumentEvent e) {
+            widest = -1;
+        }
+    };
+
+    public JTextArea() {
+        this(null, null, 0, 0);
+    }
+
+    public JTextArea(String text) {
+        this(null, text, 0, 0);
+    }
+
+    public JTextArea(int rows, int columns) {
+        this(null, null, rows, columns);
+    }
+
+    public JTextArea(String text, int rows, int columns) {
+        this(null, text, rows, columns);
+    }
+
+    public JTextArea(Document doc) {
+        this(doc, null, 0, 0);
+    }
+
+    public JTextArea(Document doc, String text, int rows, int columns) {
+        if (rows < 0) {
+            throw new IllegalArgumentException("rows: " + rows);
+        }
+        if (columns < 0) {
+            throw new IllegalArgumentException("columns: " + columns);
+        }
+        this.rows = rows;
+        this.columns = columns;
+        if (doc == null) {
+            doc = createDefaultModel();
+        }
+        setDocument(doc);
+        if (text != null) {
+            setText(text);
+            select(0, 0);
+        }
+    }
+
+    protected Document createDefaultModel() {
+        return new PlainDocument();
+    }
+
+    @Override
+    public void setDocument(Document doc) {
+        Document old = getDocument();
+        if (old != null && measureAgain != null) {
+            old.removeDocumentListener(measureAgain);
+        }
+        super.setDocument(doc);
+        widest = -1;
+        if (doc != null && measureAgain != null) {
+            doc.addDocumentListener(measureAgain);
+        }
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        TextAreaPeer p = new TextAreaPeer(this);
+        if (rows > 0) {
+            p.setRows(rows);
+        }
+        if (columns > 0) {
+            p.setColumns(columns);
+        }
+        return p;
+    }
+
+    @Override
+    protected boolean cn1GrowsWithText() {
+        return true;
+    }
+
+    // ------------------------------------------------------------ caret
+
+    /// Asks for the caret's line to be shown in the viewport this area is
+    /// in. A viewport that is waiting for a layout is laid out first, and
+    /// that layout shows the caret within the size the text has now; one
+    /// that is not is scrolled at once.
+    @Override
+    protected void cn1CaretMoved(int dot) {
+        java.lang.Object p = getParent();
+        if (!(p instanceof JViewport)) {
+            return;
+        }
+        revealPending = true;
+        JViewport viewport = (JViewport) p;
+        if (viewport.getWidth() > 0 && viewport.getHeight() > 0) {
+            // Does nothing when the viewport is laid out already, or is in
+            // the middle of the layout this was called from.
+            viewport.validate();
+        }
+        if (revealPending && cn1RevealCaret() && viewport.isValid()) {
+            revealPending = false;
+        }
+    }
+
+    /// Scrolls the viewport so that the caret's line shows, if that was
+    /// asked for and the area has a size; answers whether it did. Called
+    /// by the viewport once it gave the area its new size. The line's
+    /// place is estimated from the hard line breaks; the end of the text
+    /// is exact.
+    public boolean cn1RevealCaret() {
+        if (!revealPending || !(getParent() instanceof JViewport) || getHeight() <= 0) {
+            return false;
+        }
+        Document doc = getDocument();
+        int lines = getLineCount();
+        int dot = getCaretPosition();
+        int rowHeight = Math.max(1, getHeight() / Math.max(1, lines));
+        int y;
+        if (doc != null && dot >= doc.getLength()) {
+            y = Math.max(0, getHeight() - rowHeight);
+        } else {
+            y = doc == null ? 0 : doc.getDefaultRootElement().getElementIndex(dot) * rowHeight;
+        }
+        JViewport.cn1ScrollRectToVisible(this, new Rectangle(0, y, 1, rowHeight));
+        return true;
+    }
+
+    /// Forgets the pending request to show the caret, after a layout
+    /// honoured it.
+    public void cn1RevealDone() {
+        revealPending = false;
+    }
+
+    // ------------------------------------------------------------ text
+
+    public void insert(String str, int pos) {
+        Document doc = getDocument();
+        if (doc != null) {
+            try {
+                doc.insertString(pos, str, null);
+            } catch (BadLocationException e) {
+                throw new IllegalArgumentException(e.getMessage());
+            }
+        }
+    }
+
+    public void append(String str) {
+        Document doc = getDocument();
+        if (doc != null) {
+            try {
+                doc.insertString(doc.getLength(), str, null);
+            } catch (BadLocationException e) {
+                // The end of the document is always a valid position.
+                repaint();
+            }
+        }
+    }
+
+    public void replaceRange(String str, int start, int end) {
+        if (end < start) {
+            throw new IllegalArgumentException("end before start");
+        }
+        Document doc = getDocument();
+        if (doc != null) {
+            try {
+                if (doc instanceof com.codename1.desktopcompat.javax.swing.text.AbstractDocument) {
+                    ((com.codename1.desktopcompat.javax.swing.text.AbstractDocument) doc).replace(start,
+                            end - start, str, null);
+                } else {
+                    doc.remove(start, end - start);
+                    doc.insertString(start, str, null);
+                }
+            } catch (BadLocationException e) {
+                throw new IllegalArgumentException(e.getMessage());
+            }
+        }
+    }
+
+    public int getLineCount() {
+        Document doc = getDocument();
+        return doc == null ? 0 : doc.getDefaultRootElement().getElementCount();
+    }
+
+    public int getLineOfOffset(int offset) throws BadLocationException {
+        Document doc = getDocument();
+        if (offset < 0) {
+            throw new BadLocationException("Can't translate offset to line", -1);
+        } else if (doc == null || offset > doc.getLength()) {
+            throw new BadLocationException("Can't translate offset to line", doc == null ? 0 : doc.getLength() + 1);
+        }
+        return doc.getDefaultRootElement().getElementIndex(offset);
+    }
+
+    public int getLineStartOffset(int line) throws BadLocationException {
+        Element e = line(line);
+        return e.getStartOffset();
+    }
+
+    public int getLineEndOffset(int line) throws BadLocationException {
+        Element e = line(line);
+        int end = e.getEndOffset();
+        return line == getLineCount() - 1 ? end - 1 : end;
+    }
+
+    private Element line(int line) throws BadLocationException {
+        int count = getLineCount();
+        if (line < 0) {
+            throw new BadLocationException("Negative line", -1);
+        } else if (line >= count) {
+            throw new BadLocationException("No such line", getDocument() == null ? 0 : getDocument().getLength() + 1);
+        }
+        return getDocument().getDefaultRootElement().getElement(line);
+    }
+
+    // ------------------------------------------------------------ shape
+
+    public int getRows() {
+        return rows;
+    }
+
+    public void setRows(int rows) {
+        if (rows < 0) {
+            throw new IllegalArgumentException("rows less than zero.");
+        }
+        if (rows != this.rows) {
+            this.rows = rows;
+            com.codename1.ui.Component p = cn1PeerOrNull();
+            if (p instanceof com.codename1.ui.TextArea && rows > 0) {
+                ((com.codename1.ui.TextArea) p).setRows(rows);
+            }
+            revalidate();
+        }
+    }
+
+    public int getColumns() {
+        return columns;
+    }
+
+    public void setColumns(int columns) {
+        if (columns < 0) {
+            throw new IllegalArgumentException("columns less than zero.");
+        }
+        if (columns != this.columns) {
+            this.columns = columns;
+            com.codename1.ui.Component p = cn1PeerOrNull();
+            if (p instanceof com.codename1.ui.TextArea && columns > 0) {
+                ((com.codename1.ui.TextArea) p).setColumns(columns);
+            }
+            revalidate();
+        }
+    }
+
+    protected int getRowHeight() {
+        return getFontMetrics(getFont()).getHeight();
+    }
+
+    protected int getColumnWidth() {
+        return getFontMetrics(getFont()).charWidth('m');
+    }
+
+    public boolean getLineWrap() {
+        return wrap;
+    }
+
+    public void setLineWrap(boolean wrap) {
+        boolean old = this.wrap;
+        this.wrap = wrap;
+        firePropertyChange("lineWrap", old, wrap);
+        if (old != wrap) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    public boolean getWrapStyleWord() {
+        return word;
+    }
+
+    /// Recorded; see the class description.
+    public void setWrapStyleWord(boolean word) {
+        boolean old = this.word;
+        this.word = word;
+        firePropertyChange("wrapStyleWord", old, word);
+    }
+
+    /// The width in device pixels of the longest line between two line
+    /// breaks, in the widget's font.
+    private int cn1WidestLine(com.codename1.ui.Font f) {
+        if (widest >= 0 && widestFont == f) {
+            return widest;
+        }
+        String text = getText();
+        int best = 0;
+        int n = text.length();
+        int start = 0;
+        while (start <= n) {
+            int end = text.indexOf('\n', start);
+            if (end < 0) {
+                end = n;
+            }
+            if (end > start) {
+                best = Math.max(best, f.substringWidth(text, start, end - start));
+            }
+            start = end + 1;
+        }
+        widest = best;
+        widestFont = f;
+        return best;
+    }
+
+    /// An area that does not wrap is as wide as its longest line and as
+    /// high as its lines; one that wraps asks the widget, whose height
+    /// follows the width it has.
+    @Override
+    public Dimension getPreferredSize() {
+        Dimension d = super.getPreferredSize();
+        com.codename1.ui.Component p = wrap || isPreferredSizeSet() ? null : cn1PeerOrNull();
+        if (!(p instanceof com.codename1.ui.TextArea) || !com.codename1.ui.Display.isInitialized()) {
+            return d;
+        }
+        com.codename1.ui.TextArea t = (com.codename1.ui.TextArea) p;
+        com.codename1.ui.plaf.Style style = t.getStyle();
+        com.codename1.ui.Font f = style.getFont();
+        if (f == null) {
+            return d;
+        }
+        // One character of room more than the line needs: the widget
+        // breaks a line that only just fits.
+        int lineW = cn1WidestLine(f) + f.charWidth('W') + style.getHorizontalPadding();
+        int w = Units.toLogicalCeil(lineW);
+        if (columns > 0) {
+            w = Math.max(w, Units.toLogicalCeil(columns * f.charWidth('W') + style.getHorizontalPadding()));
+        } else if (getLineCount() <= 1 && getDocument() != null && getDocument().getLength() == 0) {
+            w = Math.max(w, d.width);
+        }
+        int lines = Math.max(1, Math.max(rows, getLineCount()));
+        int h = Units.toLogicalCeil(lines * (f.getHeight() + t.getRowsGap()) + style.getVerticalPadding());
+        return new Dimension(w, h);
+    }
+
+    public int getTabSize() {
+        Document doc = getDocument();
+        Object size = doc == null ? null : doc.getProperty(PlainDocument.tabSizeAttribute);
+        return size instanceof Integer ? ((Integer) size).intValue() : 8;
+    }
+
+    public void setTabSize(int size) {
+        Document doc = getDocument();
+        if (doc != null) {
+            int old = getTabSize();
+            doc.putProperty(PlainDocument.tabSizeAttribute, Integer.valueOf(size));
+            firePropertyChange("tabSize", old, size);
+        }
+    }
+
+    // ------------------------------------------------------------ scrolling
+
+    /// With line wrap the area is as wide as the viewport and scrolls only
+    /// vertically; without, it is at least as wide as the viewport and
+    /// wider when a line is.
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        return wrap || super.getScrollableTracksViewportWidth();
+    }
+
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        Dimension d = getPreferredSize();
+        if (rows > 0 && getRowHeight() > 0) {
+            d.height = rows * getRowHeight();
+        }
+        if (!wrap && columns > 0 && getColumnWidth() > 0) {
+            // The columns asked for, however long the lines are.
+            d.width = Math.min(d.width, columns * getColumnWidth() + 8);
+        }
+        return d;
+    }
+
+    @Override
+    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+        int h = getRowHeight();
+        return orientation == SwingConstants.VERTICAL && h > 0 ? h
+                : super.getScrollableUnitIncrement(visibleRect, orientation, direction);
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",columns=" + columns + ",rows=" + rows;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextField.java
new file mode 100644
index 00000000000..48530db3fe7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextField.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.rt.TextFieldPeer;
+
+/// A single line of editable text, shown and edited by a Codename One
+/// text field over a [PlainDocument].
+///
+/// Finishing the edit -- the Enter or Done key of the device's keyboard
+/// -- notifies the action listeners. The columns size the field and the
+/// horizontal alignment is honoured. Line breaks in inserted text become
+/// spaces. Not supported: the scroll offset and horizontal visibility
+/// model, and binding an `Action`.
+public class JTextField extends JTextComponent implements SwingConstants {
+
+    public static final String notifyAction = "notify-field-accept";
+
+    private int columns;
+    private int horizontalAlignment = LEADING;
+    private String command;
+
+    public JTextField() {
+        this(null, null, 0);
+    }
+
+    public JTextField(String text) {
+        this(null, text, 0);
+    }
+
+    public JTextField(int columns) {
+        this(null, null, columns);
+    }
+
+    public JTextField(String text, int columns) {
+        this(null, text, columns);
+    }
+
+    public JTextField(Document doc, String text, int columns) {
+        if (columns < 0) {
+            throw new IllegalArgumentException("columns less than zero.");
+        }
+        this.columns = columns;
+        if (doc == null) {
+            doc = createDefaultModel();
+        }
+        setDocument(doc);
+        if (text != null) {
+            setText(text);
+        }
+    }
+
+    /// The document a field starts with: plain text without line breaks.
+    protected Document createDefaultModel() {
+        return new PlainDocument();
+    }
+
+    @Override
+    public void setDocument(Document doc) {
+        if (doc != null) {
+            doc.putProperty("filterNewlines", Boolean.TRUE);
+        }
+        super.setDocument(doc);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        TextFieldPeer p = new TextFieldPeer(this);
+        p.setSingleLineTextArea(true);
+        if (columns > 0) {
+            p.setColumns(columns);
+        }
+        p.setAlignment(JLabel.nativeAlignment(horizontalAlignment));
+        p.addActionListener(new com.codename1.ui.events.ActionListener<com.codename1.ui.events.ActionEvent>() {
+            @Override
+            public void actionPerformed(com.codename1.ui.events.ActionEvent evt) {
+                cn1PullText();
+                postActionEvent();
+            }
+        });
+        return p;
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        if (isMaximumSizeSet()) {
+            return super.getMaximumSize();
+        }
+        return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+    }
+
+    /// As on the desktop a field can be far narrower than it prefers --
+    /// there its minimum is little more than its own edges, here it is as
+    /// wide as it is tall -- so a row that is short of room narrows its
+    /// fields before it pushes anything out of sight.
+    @Override
+    public Dimension getMinimumSize() {
+        Dimension d = super.getMinimumSize();
+        if (isMinimumSizeSet()) {
+            return d;
+        }
+        return new Dimension(Math.min(d.width, d.height), d.height);
+    }
+
+    public int getColumns() {
+        return columns;
+    }
+
+    public void setColumns(int columns) {
+        if (columns < 0) {
+            throw new IllegalArgumentException("columns less than zero.");
+        }
+        if (columns != this.columns) {
+            this.columns = columns;
+            com.codename1.ui.Component p = cn1PeerOrNull();
+            if (p instanceof com.codename1.ui.TextArea && columns > 0) {
+                ((com.codename1.ui.TextArea) p).setColumns(columns);
+            }
+            revalidate();
+        }
+    }
+
+    /// The width of one column: that of the letter m in the field's font.
+    protected int getColumnWidth() {
+        return getFontMetrics(getFont()).charWidth('m');
+    }
+
+    public int getHorizontalAlignment() {
+        return horizontalAlignment;
+    }
+
+    public void setHorizontalAlignment(int alignment) {
+        if (alignment == horizontalAlignment) {
+            return;
+        }
+        if (alignment != LEFT && alignment != CENTER && alignment != RIGHT && alignment != LEADING
+                && alignment != TRAILING) {
+            throw new IllegalArgumentException("horizontalAlignment");
+        }
+        int old = horizontalAlignment;
+        horizontalAlignment = alignment;
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.TextArea) {
+            ((com.codename1.ui.TextArea) p).setAlignment(JLabel.nativeAlignment(alignment));
+        }
+        firePropertyChange("horizontalAlignment", old, alignment);
+        repaint();
+    }
+
+    public void addActionListener(ActionListener l) {
+        listenerList.add(ActionListener.class, l);
+    }
+
+    public void removeActionListener(ActionListener l) {
+        listenerList.remove(ActionListener.class, l);
+    }
+
+    public ActionListener[] getActionListeners() {
+        return listenerList.getListeners(ActionListener.class);
+    }
+
+    public void setActionCommand(String command) {
+        this.command = command;
+    }
+
+    protected void fireActionPerformed() {
+        ActionListener[] ls = getActionListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        ActionEvent e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, command != null ? command : getText(),
+                System.currentTimeMillis(), 0);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].actionPerformed(e);
+        }
+    }
+
+    public void postActionEvent() {
+        fireActionPerformed();
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",columns=" + columns;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextPane.java
new file mode 100644
index 00000000000..87a0a6224b0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTextPane.java
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.text.AbstractDocument;
+import com.codename1.desktopcompat.javax.swing.text.AttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.DefaultStyledDocument;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.MutableAttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.SimpleAttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.Style;
+import com.codename1.desktopcompat.javax.swing.text.StyledDocument;
+import com.codename1.desktopcompat.rt.StyledText;
+
+/// An editor pane for styled text: its document is a [StyledDocument],
+/// and the pane draws every run of it in the color, weight, slant, family
+/// and size its attributes ask for, underlined or struck through, on the
+/// background they name, in paragraphs aligned as theirs ask.
+///
+/// ## What differs from the desktop
+///
+///  - While the document has no attribute that changes how text looks,
+///    the pane is the plain text area [JEditorPane] is, edited by the
+///    platform's widget. Once it has one the pane draws the text itself
+///    and the user can no longer type in it or select in it, whatever
+///    `setEditable` says: the platform's widget edits text of one look.
+///    The application changes the text as before, through the document
+///    and through the pane.
+///  - A paragraph asked to be justified is aligned left.
+///  - Icons and components cannot be put in the text.
+public class JTextPane extends JEditorPane {
+
+    private final MutableAttributeSet input = new SimpleAttributeSet();
+    private final Watch watch = new Watch();
+    private StyledText layout;
+    private int layoutRoom;
+    private Font layoutFont;
+    private Color layoutColor;
+    /// Whether the document asks to be drawn styled; `null` until it is
+    /// looked at again after a change.
+    private Boolean styled;
+
+    public JTextPane() {
+        setDocument(new DefaultStyledDocument());
+    }
+
+    public JTextPane(StyledDocument doc) {
+        setDocument(doc);
+    }
+
+    private final class Watch implements DocumentListener {
+
+        @Override
+        public void insertUpdate(DocumentEvent e) {
+            changed();
+        }
+
+        @Override
+        public void removeUpdate(DocumentEvent e) {
+            changed();
+        }
+
+        @Override
+        public void changedUpdate(DocumentEvent e) {
+            changed();
+        }
+
+        private void changed() {
+            boolean was = styled != null && styled.booleanValue();
+            styled = null;
+            layout = null;
+            if (cn1Styled() != was) {
+                cn1ApplyMode();
+            }
+            revalidate();
+            repaint();
+        }
+    }
+
+    /// Sets the document, which has to be a [StyledDocument].
+    @Override
+    public void setDocument(Document doc) {
+        // The constructor of JEditorPane sets a plain one first, before
+        // this class has its fields.
+        if (watch != null && !(doc instanceof StyledDocument)) {
+            throw new IllegalArgumentException("Model must be StyledDocument");
+        }
+        Document old = getDocument();
+        if (old != null && watch != null) {
+            old.removeDocumentListener(watch);
+        }
+        super.setDocument(doc);
+        // Null while the constructor of JEditorPane sets its own.
+        if (watch != null) {
+            doc.addDocumentListener(watch);
+            styled = null;
+            layout = null;
+            cn1ApplyMode();
+        }
+    }
+
+    public void setStyledDocument(StyledDocument doc) {
+        setDocument(doc);
+    }
+
+    public StyledDocument getStyledDocument() {
+        Document doc = getDocument();
+        return doc instanceof StyledDocument ? (StyledDocument) doc : null;
+    }
+
+    public Style addStyle(String nm, Style parent) {
+        return getStyledDocument().addStyle(nm, parent);
+    }
+
+    public void removeStyle(String nm) {
+        getStyledDocument().removeStyle(nm);
+    }
+
+    public Style getStyle(String nm) {
+        return getStyledDocument().getStyle(nm);
+    }
+
+    public void setLogicalStyle(Style s) {
+        getStyledDocument().setLogicalStyle(getCaretPosition(), s);
+    }
+
+    public Style getLogicalStyle() {
+        return getStyledDocument().getLogicalStyle(getCaretPosition());
+    }
+
+    /// The attributes of the character at the caret.
+    public AttributeSet getCharacterAttributes() {
+        StyledDocument doc = getStyledDocument();
+        return doc.getCharacterElement(getCaretPosition()).getAttributes();
+    }
+
+    /// Gives the selection the attributes; with nothing selected they
+    /// become the attributes text is inserted with.
+    public void setCharacterAttributes(AttributeSet attr, boolean replace) {
+        int p0 = getSelectionStart();
+        int p1 = getSelectionEnd();
+        if (p0 != p1) {
+            getStyledDocument().setCharacterAttributes(p0, p1 - p0, attr, replace);
+        } else {
+            if (replace) {
+                input.removeAttributes(input);
+            }
+            input.addAttributes(attr);
+        }
+    }
+
+    public AttributeSet getParagraphAttributes() {
+        return getStyledDocument().getParagraphElement(getCaretPosition()).getAttributes();
+    }
+
+    /// Gives the paragraphs the selection touches the attributes.
+    public void setParagraphAttributes(AttributeSet attr, boolean replace) {
+        int p0 = getSelectionStart();
+        int p1 = getSelectionEnd();
+        getStyledDocument().setParagraphAttributes(p0, p1 - p0, attr, replace);
+    }
+
+    /// The attributes text is inserted with by [#replaceSelection].
+    public MutableAttributeSet getInputAttributes() {
+        return input;
+    }
+
+    /// Puts `content` in place of the selection, with the input
+    /// attributes.
+    @Override
+    public void replaceSelection(String content) {
+        Document doc = getDocument();
+        if (doc == null || !isEditable()) {
+            return;
+        }
+        int p0 = getSelectionStart();
+        int p1 = getSelectionEnd();
+        AttributeSet a = input.getAttributeCount() == 0 ? null : input.copyAttributes();
+        try {
+            if (doc instanceof AbstractDocument) {
+                ((AbstractDocument) doc).replace(p0, p1 - p0, content, a);
+            } else {
+                if (p0 != p1) {
+                    doc.remove(p0, p1 - p0);
+                }
+                if (content != null && content.length() > 0) {
+                    doc.insertString(p0, content, a);
+                }
+            }
+        } catch (BadLocationException e) {
+            // The selection is always inside the document.
+            repaint();
+        }
+    }
+
+    // ------------------------------------------------------------ drawing
+
+    @Override
+    boolean cn1Styled() {
+        if (styled == null) {
+            StyledDocument doc = getStyledDocument();
+            styled = Boolean.valueOf(doc != null && StyledText.styled(doc));
+        }
+        return styled.booleanValue();
+    }
+
+    private Color cn1Ink() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        return isForegroundSet() || p == null ? getForeground() : new Color(p.getStyle().getFgColor() & 0xffffff);
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    /// The lines of the document at the width the pane has.
+    private StyledText cn1Layout() {
+        Insets in = cn1TextInsets();
+        int room = Math.max(0, getWidth() - in.left - in.right);
+        Font f = getFont();
+        Color ink = cn1Ink();
+        if (layout == null || room != layoutRoom || !same(f, layoutFont) || !same(ink, layoutColor)) {
+            layout = new StyledText(getStyledDocument(), f, ink, room);
+            layoutRoom = room;
+            layoutFont = f;
+            layoutColor = ink;
+        }
+        return layout;
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet() || !cn1Styled()) {
+            return super.getPreferredSize();
+        }
+        Insets in = cn1TextInsets();
+        StyledText whole = new StyledText(getStyledDocument(), getFont(), cn1Ink(), 0);
+        int h = getWidth() - in.left - in.right > 0 ? cn1Layout().getHeight() : whole.getHeight();
+        return new Dimension(whole.getWidth() + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (!cn1Styled()) {
+            super.paintComponent(g);
+            return;
+        }
+        if (isOpaque()) {
+            Color bg = getBackground();
+            if (bg != null) {
+                g.setColor(bg);
+                g.fillRect(0, 0, getWidth(), getHeight());
+            }
+        }
+        Insets in = cn1TextInsets();
+        cn1Layout().paint(g, in.left, in.top);
+    }
+
+    @Override
+    protected int cn1ViewToModel(int x, int y) {
+        if (!cn1Styled()) {
+            return super.cn1ViewToModel(x, y);
+        }
+        if (getWidth() <= 0 || getHeight() <= 0) {
+            return -1;
+        }
+        Insets in = cn1TextInsets();
+        return cn1Layout().offsetAt(x - in.left, y - in.top);
+    }
+
+    @Override
+    protected Rectangle cn1ModelToView(int pos) {
+        if (!cn1Styled()) {
+            return super.cn1ModelToView(pos);
+        }
+        if (getWidth() <= 0 || getHeight() <= 0) {
+            return null;
+        }
+        Insets in = cn1TextInsets();
+        Rectangle r = cn1Layout().caretAt(pos);
+        r.x += in.left;
+        r.y += in.top;
+        return r;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JToggleButton.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JToggleButton.java
new file mode 100644
index 00000000000..8dc5d4caec0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JToggleButton.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.rt.CheckBoxPeer;
+
+/// A button that stays selected until clicked again, shown by a Codename
+/// One toggle button.
+public class JToggleButton extends AbstractButton implements Accessible {
+
+    public JToggleButton() {
+        this(null, null, false);
+    }
+
+    public JToggleButton(Icon icon) {
+        this(null, icon, false);
+    }
+
+    public JToggleButton(Icon icon, boolean selected) {
+        this(null, icon, selected);
+    }
+
+    public JToggleButton(String text) {
+        this(text, null, false);
+    }
+
+    public JToggleButton(String text, boolean selected) {
+        this(text, null, selected);
+    }
+
+    public JToggleButton(Action a) {
+        this();
+        setAction(a);
+    }
+
+    public JToggleButton(String text, Icon icon) {
+        this(text, icon, false);
+    }
+
+    public JToggleButton(String text, Icon icon, boolean selected) {
+        setModel(new ToggleButtonModel());
+        model.setSelected(selected);
+        init(text, icon);
+    }
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        CheckBoxPeer p = new CheckBoxPeer(this);
+        p.setToggle(true);
+        return p;
+    }
+
+    /// The model of the toggle buttons: a click flips the selection, and
+    /// a button group may refuse to deselect.
+    public static class ToggleButtonModel extends DefaultButtonModel {
+
+        public ToggleButtonModel() {
+        }
+
+        @Override
+        public void setPressed(boolean b) {
+            if (isPressed() != b && isEnabled() && !b && isArmed()) {
+                setSelected(!isSelected());
+            }
+            super.setPressed(b);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JToolBar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JToolBar.java
new file mode 100644
index 00000000000..b4597000cb9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JToolBar.java
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+
+/// A row or column of buttons and other components.
+///
+/// It is an ordinary container laid out along its orientation; it cannot
+/// be dragged out of its window, and the floatable and rollover
+/// properties are recorded only. A button made from an action shows the
+/// action's icon, or its name when it has none, takes its short
+/// description as the tool tip, and follows the action's later changes.
+public class JToolBar extends JComponent implements Accessible, SwingConstants {
+
+    private int orientation;
+    private boolean floatable = true;
+    private boolean rollover;
+    private boolean paintBorder = true;
+    private Insets margin;
+    /// The layout this tool bar gave itself. Rows are only made under it:
+    /// a layout the application set is the application's to run.
+    private LayoutManager ownLayout;
+
+    public JToolBar() {
+        this(null, HORIZONTAL);
+    }
+
+    public JToolBar(int orientation) {
+        this(null, orientation);
+    }
+
+    public JToolBar(String name) {
+        this(name, HORIZONTAL);
+    }
+
+    public JToolBar(String name, int orientation) {
+        setName(name);
+        check(orientation);
+        this.orientation = orientation;
+        ownLayout = new BoxLayout(this, orientation == VERTICAL ? BoxLayout.Y_AXIS : BoxLayout.X_AXIS);
+        setLayout(ownLayout);
+    }
+
+    // ------------------------------------------------------------ rows
+
+    /// Whether this is a horizontal bar, under its own layout, that was
+    /// given less width than its components want side by side.
+    ///
+    /// On the desktop such a bar cuts its last components off, and the
+    /// user widens the window. Where the window is the display that
+    /// cannot be done, so the bar goes on in a further row instead: it
+    /// then prefers the height of its rows, and its minimum width is that
+    /// of its widest component. A bar that is wide enough is the one row
+    /// its layout makes.
+    private boolean rows() {
+        if (orientation != HORIZONTAL || getLayout() != ownLayout || ownLayout == null || getWidth() <= 0) {
+            return false;
+        }
+        return super.getPreferredSize().width > getWidth();
+    }
+
+    /// Places the components in rows no wider than `width` when `place`
+    /// is set, and answers the height the rows take with the insets.
+    private int rows(int width, boolean place) {
+        Insets in = getInsets();
+        int right = Math.max(in.left + 1, width - in.right);
+        int x = in.left;
+        int y = in.top;
+        int rowHeight = 0;
+        int first = 0;
+        int n = getComponentCount();
+        for (int i = 0; i <= n; i++) {
+            Dimension d = null;
+            if (i < n) {
+                Component c = getComponent(i);
+                if (!c.isVisible()) {
+                    continue;
+                }
+                d = c.getPreferredSize();
+            }
+            if (d == null || (x > in.left && x + d.width > right)) {
+                if (place) {
+                    // A row is as tall as its tallest component, and the
+                    // others stand in the middle of it.
+                    int rx = in.left;
+                    for (int j = first; j < i; j++) {
+                        Component c = getComponent(j);
+                        if (c.isVisible()) {
+                            Dimension cd = c.getPreferredSize();
+                            c.setBounds(rx, y + (rowHeight - cd.height) / 2, cd.width, cd.height);
+                            rx += cd.width;
+                        }
+                    }
+                }
+                y += rowHeight;
+                x = in.left;
+                rowHeight = 0;
+                first = i;
+            }
+            if (d != null) {
+                x += d.width;
+                rowHeight = Math.max(rowHeight, d.height);
+            }
+        }
+        return y + in.bottom;
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        Dimension d = super.getPreferredSize();
+        if (!isPreferredSizeSet() && rows()) {
+            return new Dimension(d.width, rows(getWidth(), false));
+        }
+        return d;
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        Dimension d = super.getMinimumSize();
+        if (isMinimumSizeSet() || orientation != HORIZONTAL || getLayout() != ownLayout) {
+            return d;
+        }
+        Insets in = getInsets();
+        int w = 0;
+        for (int i = 0; i < getComponentCount(); i++) {
+            Component c = getComponent(i);
+            if (c.isVisible()) {
+                w = Math.max(w, c.getPreferredSize().width);
+            }
+        }
+        return new Dimension(Math.min(d.width, w + in.left + in.right),
+                rows() ? rows(getWidth(), false) : d.height);
+    }
+
+    @Override
+    public void doLayout() {
+        if (rows()) {
+            rows(getWidth(), true);
+        } else {
+            super.doLayout();
+        }
+    }
+
+    /// A change of width changes the number of rows, and with it the
+    /// height this bar prefers: the container that measured it before is
+    /// asked to lay it out again.
+    @Override
+    public void setBounds(int x, int y, int width, int height) {
+        if (width == getWidth()) {
+            super.setBounds(x, y, width, height);
+            return;
+        }
+        int was = getPreferredSize().height;
+        super.setBounds(x, y, width, height);
+        if (getPreferredSize().height != was) {
+            com.codename1.desktopcompat.rt.PeerSupport.layoutAgain(this);
+        }
+    }
+
+    private static void check(int orientation) {
+        if (orientation != HORIZONTAL && orientation != VERTICAL) {
+            throw new IllegalArgumentException("orientation must be either HORIZONTAL or VERTICAL");
+        }
+    }
+
+    public int getOrientation() {
+        return orientation;
+    }
+
+    public void setOrientation(int o) {
+        check(o);
+        if (orientation != o) {
+            int old = orientation;
+            orientation = o;
+            ownLayout = new BoxLayout(this, o == VERTICAL ? BoxLayout.Y_AXIS : BoxLayout.X_AXIS);
+            setLayout(ownLayout);
+            firePropertyChange("orientation", old, o);
+            revalidate();
+            repaint();
+        }
+    }
+
+    public boolean isFloatable() {
+        return floatable;
+    }
+
+    public void setFloatable(boolean b) {
+        floatable = b;
+    }
+
+    public boolean isRollover() {
+        return rollover;
+    }
+
+    public void setRollover(boolean rollover) {
+        this.rollover = rollover;
+    }
+
+    public boolean isBorderPainted() {
+        return paintBorder;
+    }
+
+    public void setBorderPainted(boolean b) {
+        paintBorder = b;
+        repaint();
+    }
+
+    public void setMargin(Insets m) {
+        margin = m == null ? null : new Insets(m.top, m.left, m.bottom, m.right);
+        revalidate();
+    }
+
+    public Insets getMargin() {
+        return margin == null ? new Insets(0, 0, 0, 0) : new Insets(margin.top, margin.left, margin.bottom,
+                margin.right);
+    }
+
+    public int getComponentIndex(Component c) {
+        return getComponentZOrder(c);
+    }
+
+    public Component getComponentAtIndex(int i) {
+        return i < 0 || i >= getComponentCount() ? null : getComponent(i);
+    }
+
+    public void addSeparator() {
+        addSeparator(null);
+    }
+
+    public void addSeparator(Dimension size) {
+        add(new JToolBar.Separator(size));
+    }
+
+    /// Adds a button that runs the action and follows it.
+    public JButton add(Action a) {
+        JButton b = createActionComponent(a);
+        b.addActionListener(a);
+        PropertyChangeListener l = createActionChangeListener(b);
+        if (a != null) {
+            a.addPropertyChangeListener(l);
+        }
+        add(b);
+        return b;
+    }
+
+    protected JButton createActionComponent(Action a) {
+        JButton b = new JButton();
+        if (a != null) {
+            Object icon = a.getValue(Action.SMALL_ICON);
+            Object name = a.getValue(Action.NAME);
+            if (icon instanceof Icon) {
+                b.setIcon((Icon) icon);
+            } else if (name instanceof String) {
+                b.setText((String) name);
+            }
+            Object tip = a.getValue(Action.SHORT_DESCRIPTION);
+            if (tip instanceof String) {
+                b.setToolTipText((String) tip);
+            }
+            Object cmd = a.getValue(Action.ACTION_COMMAND_KEY);
+            if (cmd instanceof String) {
+                b.setActionCommand((String) cmd);
+            }
+            b.setEnabled(a.isEnabled());
+        }
+        return b;
+    }
+
+    protected PropertyChangeListener createActionChangeListener(JButton b) {
+        return new Follower(b);
+    }
+
+    /// Copies an action's changes to the button made from it.
+    private static final class Follower implements PropertyChangeListener {
+
+        private final JButton button;
+
+        Follower(JButton button) {
+            this.button = button;
+        }
+
+        @Override
+        public void propertyChange(PropertyChangeEvent evt) {
+            String name = evt.getPropertyName();
+            Object v = evt.getNewValue();
+            if ("enabled".equals(name)) {
+                button.setEnabled(Boolean.TRUE.equals(v));
+            } else if (Action.NAME.equals(name)) {
+                if (button.getIcon() == null) {
+                    button.setText(v instanceof String ? (String) v : "");
+                }
+            } else if (Action.SMALL_ICON.equals(name)) {
+                button.setIcon(v instanceof Icon ? (Icon) v : null);
+                if (v instanceof Icon) {
+                    button.setText("");
+                }
+            } else if (Action.SHORT_DESCRIPTION.equals(name)) {
+                button.setToolTipText(v instanceof String ? (String) v : null);
+            }
+        }
+    }
+
+    /// The gap between two groups of components of a tool bar.
+    public static class Separator extends JSeparator {
+
+        private Dimension separatorSize;
+
+        public Separator() {
+            this(null);
+        }
+
+        public Separator(Dimension size) {
+            super(JSeparator.HORIZONTAL);
+            setSeparatorSize(size);
+        }
+
+        public void setSeparatorSize(Dimension size) {
+            separatorSize = size == null ? new Dimension(10, 10) : new Dimension(size);
+            revalidate();
+        }
+
+        public Dimension getSeparatorSize() {
+            return new Dimension(separatorSize);
+        }
+
+        @Override
+        public Dimension getMinimumSize() {
+            return getSeparatorSize();
+        }
+
+        /// As wide as the gap along the tool bar and as long as the bar
+        /// across it, so the line it draws runs the bar's whole height.
+        @Override
+        public Dimension getMaximumSize() {
+            Dimension d = getSeparatorSize();
+            if (cn1AcrossHorizontalBar()) {
+                d.height = Short.MAX_VALUE;
+            } else {
+                d.width = Short.MAX_VALUE;
+            }
+            return d;
+        }
+
+        private boolean cn1AcrossHorizontalBar() {
+            java.lang.Object p = getParent();
+            return !(p instanceof JToolBar) || ((JToolBar) p).getOrientation() == HORIZONTAL;
+        }
+
+        /// A line across the tool bar in the middle of the gap, where the
+        /// separator of a menu draws one along its top.
+        @Override
+        protected void paintComponent(com.codename1.desktopcompat.java.awt.Graphics g) {
+            g.setColor(com.codename1.desktopcompat.rt.LafTheme.line());
+            int w = getWidth();
+            int h = getHeight();
+            if (cn1AcrossHorizontalBar()) {
+                int pad = Math.min(4, h / 4);
+                g.fillRect(w / 2, pad, 1, Math.max(0, h - 2 * pad));
+            } else {
+                int pad = Math.min(4, w / 4);
+                g.fillRect(pad, h / 2, Math.max(0, w - 2 * pad), 1);
+            }
+        }
+
+        @Override
+        public Dimension getPreferredSize() {
+            return getSeparatorSize();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTree.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTree.java
new file mode 100644
index 00000000000..e802e61c8a3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JTree.java
@@ -0,0 +1,1830 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.plaf.basic.BasicTreeUI;
+import com.codename1.desktopcompat.javax.swing.plaf.TreeUI;
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.KeyAdapter;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.CellEditorListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeWillExpandListener;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellEditor;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeSelectionModel;
+import com.codename1.desktopcompat.javax.swing.tree.ExpandVetoException;
+import com.codename1.desktopcompat.javax.swing.tree.RowMapper;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellEditor;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.TreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.javax.swing.tree.TreeSelectionModel;
+import com.codename1.desktopcompat.rt.CellPainter;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.ListEnumeration;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Vector;
+
+/// A tree of rows over a [TreeModel], with the JDK's paths, expansion,
+/// selection, renderers and editors.
+///
+/// ## How it is drawn
+///
+/// The tree paints itself. Every row that meets the clip is painted by
+/// the component its [TreeCellRenderer] answers -- by default a label,
+/// and so a Codename One label in the theme's colors -- at the row's
+/// indent, with an arrow before it for a node that has children. A
+/// selected row is tinted across the whole width of the tree.
+///
+/// ## What the model is asked
+///
+/// Only the children of expanded nodes. A collapsed node is asked
+/// whether it is a leaf, to decide whether it gets an arrow, and for
+/// nothing else, so a model that makes its children on demand stays
+/// lazy. Expansion is remembered by path and survives changes of the
+/// model around it.
+///
+/// ## What differs from a desktop
+///
+///  - All rows have one height: the one set with [#setRowHeight(int)],
+///    or one that fits the font and, on a touch screen, a finger.
+///    [#getRowHeight()] answers the height in use.
+///  - On a touch screen a tap selects and a drag scrolls the enclosing
+///    scroll pane; the arrow's zone is the whole indent step, which is
+///    wider there. With a mouse a press selects.
+///  - A press anywhere from the start of a row's text to the right edge
+///    of the tree counts as on the row, so [#getPathForLocation] answers
+///    the path there too. [#getPathBounds] is the JDK's rectangle: the
+///    text's own width.
+///  - There are no lines between nodes.
+///  - Editing is the plain kind: a text field over the row, started by
+///    [#startEditingAtPath], F2 or a third click.
+///  - No drag starts from the tree (`setDragEnabled` is kept as a property);
+///    tool tips per row and type-ahead search are absent.
+public class JTree extends JComponent implements Accessible, Scrollable {
+
+    public static final String CELL_RENDERER_PROPERTY = "cellRenderer";
+    public static final String TREE_MODEL_PROPERTY = "model";
+    public static final String ROOT_VISIBLE_PROPERTY = "rootVisible";
+    public static final String SHOWS_ROOT_HANDLES_PROPERTY = "showsRootHandles";
+    public static final String ROW_HEIGHT_PROPERTY = "rowHeight";
+    public static final String CELL_EDITOR_PROPERTY = "cellEditor";
+    public static final String EDITABLE_PROPERTY = "editable";
+    public static final String LARGE_MODEL_PROPERTY = "largeModel";
+    public static final String SELECTION_MODEL_PROPERTY = "selectionModel";
+    public static final String VISIBLE_ROW_COUNT_PROPERTY = "visibleRowCount";
+    public static final String INVOKES_STOP_CELL_EDITING_PROPERTY = "invokesStopCellEditing";
+    public static final String SCROLLS_ON_EXPAND_PROPERTY = "scrollsOnExpand";
+    public static final String TOGGLE_CLICK_COUNT_PROPERTY = "toggleClickCount";
+    public static final String LEAD_SELECTION_PATH_PROPERTY = "leadSelectionPath";
+    public static final String ANCHOR_SELECTION_PATH_PROPERTY = "anchorSelectionPath";
+    public static final String EXPANDS_SELECTED_PATHS_PROPERTY = "expandsSelectedPaths";
+
+    protected transient TreeModel treeModel;
+    protected transient TreeSelectionModel selectionModel;
+    protected boolean rootVisible;
+    protected transient TreeCellRenderer cellRenderer;
+    protected int rowHeight;
+    protected boolean showsRootHandles;
+    protected transient TreeCellEditor cellEditor;
+    protected boolean editable;
+    protected boolean largeModel;
+    protected int visibleRowCount;
+    protected boolean invokesStopCellEditing;
+    protected boolean scrollsOnExpand;
+    protected int toggleClickCount;
+    protected transient TreeModelListener treeModelListener;
+
+    private final HashMap<TreePath, Boolean> expandedState = new HashMap<TreePath, Boolean>();
+    private final TreeSelectionListener selectionRelay = new SelectionRelay();
+    private final RowMapper rowMapper = new Rows();
+    private ArrayList<TreePath> rows;
+    private HashMap<TreePath, Integer> rowIndex;
+    private int preferredWidth = -1;
+    private boolean rowHeightSet;
+    private boolean expandsSelectedPaths = true;
+    private TreePath anchorPath;
+    private TreePath leadPath;
+    private boolean pressTouch;
+    private TreePath clickPath;
+    private int clickBase;
+    private TreePath editingPath;
+    private Component editorComp;
+    private TreeCellEditor activeEditor;
+    private CellEditorListener editorListener;
+    private KeyListener editorKeys;
+
+    /// A tree over a small sample model.
+    public JTree() {
+        this(getDefaultTreeModel());
+    }
+
+    public JTree(Object[] value) {
+        this(createTreeModel(value));
+        setRootVisible(false);
+        setShowsRootHandles(true);
+        expandRoot();
+    }
+
+    public JTree(Vector<?> value) {
+        this(createTreeModel(value));
+        setRootVisible(false);
+        setShowsRootHandles(true);
+        expandRoot();
+    }
+
+    public JTree(Hashtable<?, ?> value) {
+        this(createTreeModel(value));
+        setRootVisible(false);
+        setShowsRootHandles(true);
+        expandRoot();
+    }
+
+    public JTree(TreeNode root) {
+        this(root, false);
+    }
+
+    public JTree(TreeNode root, boolean asksAllowsChildren) {
+        this(new DefaultTreeModel(root, asksAllowsChildren));
+    }
+
+    public JTree(TreeModel newModel) {
+        setLayout(null);
+        rowHeight = 16;
+        visibleRowCount = 20;
+        rootVisible = true;
+        toggleClickCount = 2;
+        scrollsOnExpand = true;
+        setOpaque(true);
+        setBackground(CellTheme.background("Tree.background"));
+        setForeground(CellTheme.foreground("Tree.foreground"));
+        setFont(CellTheme.font());
+        cellRenderer = new DefaultTreeCellRenderer();
+        setSelectionModel(new DefaultTreeSelectionModel());
+        setModel(newModel);
+        setFocusable(true);
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
+    }
+
+    // ------------------------------------------------------------ models
+
+    private static DefaultMutableTreeNode branch(String name, String[] leaves) {
+        DefaultMutableTreeNode parent = new DefaultMutableTreeNode(name);
+        for (int i = 0; i < leaves.length; i++) {
+            parent.add(new DefaultMutableTreeNode(leaves[i]));
+        }
+        return parent;
+    }
+
+    /// A small sample model, for a tree made without one.
+    protected static TreeModel getDefaultTreeModel() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("JTree");
+        root.add(branch("colors", new String[]{"blue", "violet", "red", "yellow"}));
+        root.add(branch("sports", new String[]{"basketball", "soccer", "football", "hockey"}));
+        root.add(branch("food", new String[]{"hot dogs", "pizza", "ravioli", "bananas"}));
+        return new DefaultTreeModel(root);
+    }
+
+    /// A model over an array, a vector or a hash table: one node per
+    /// element, under a root named "root".
+    protected static TreeModel createTreeModel(Object value) {
+        DefaultMutableTreeNode root;
+        if (value instanceof Object[] || value instanceof Hashtable || value instanceof Vector) {
+            root = new DefaultMutableTreeNode("root");
+            DynamicUtilTreeNode.createChildren(root, value);
+        } else {
+            root = new DynamicUtilTreeNode("root", value);
+        }
+        return new DefaultTreeModel(root, false);
+    }
+
+    private void expandRoot() {
+        TreeModel m = getModel();
+        if (m != null && m.getRoot() != null) {
+            expandPath(new TreePath(m.getRoot()));
+        }
+    }
+
+    public TreeModel getModel() {
+        return treeModel;
+    }
+
+    public void setModel(TreeModel newModel) {
+        cancelEditing();
+        clearSelection();
+        TreeModel old = treeModel;
+        if (old != null && treeModelListener != null) {
+            old.removeTreeModelListener(treeModelListener);
+        }
+        treeModel = newModel;
+        clearToggledPaths();
+        if (newModel != null) {
+            if (treeModelListener == null) {
+                treeModelListener = createTreeModelListener();
+            }
+            newModel.addTreeModelListener(treeModelListener);
+            Object root = newModel.getRoot();
+            if (root != null && !newModel.isLeaf(root)) {
+                expandedState.put(new TreePath(root), Boolean.TRUE);
+            }
+        }
+        firePropertyChange(TREE_MODEL_PROPERTY, old, newModel);
+        treeDidChange();
+    }
+
+    protected TreeModelListener createTreeModelListener() {
+        return new ModelChanges();
+    }
+
+    public TreeCellRenderer getCellRenderer() {
+        return cellRenderer;
+    }
+
+    public void setCellRenderer(TreeCellRenderer x) {
+        TreeCellRenderer old = cellRenderer;
+        cellRenderer = x;
+        firePropertyChange(CELL_RENDERER_PROPERTY, old, x);
+        treeDidChange();
+    }
+
+    public void setEditable(boolean flag) {
+        boolean old = editable;
+        editable = flag;
+        firePropertyChange(EDITABLE_PROPERTY, old, flag);
+    }
+
+    public boolean isEditable() {
+        return editable;
+    }
+
+    public void setCellEditor(TreeCellEditor cellEditor) {
+        TreeCellEditor old = this.cellEditor;
+        cancelEditing();
+        this.cellEditor = cellEditor;
+        firePropertyChange(CELL_EDITOR_PROPERTY, old, cellEditor);
+    }
+
+    public TreeCellEditor getCellEditor() {
+        return cellEditor;
+    }
+
+    public boolean isRootVisible() {
+        return rootVisible;
+    }
+
+    /// Shows or hides the root's own row. A hidden root is expanded, so
+    /// that its children show.
+    public void setRootVisible(boolean rootVisible) {
+        boolean old = this.rootVisible;
+        this.rootVisible = rootVisible;
+        if (!rootVisible && treeModel != null && treeModel.getRoot() != null) {
+            expandedState.put(new TreePath(treeModel.getRoot()), Boolean.TRUE);
+        }
+        firePropertyChange(ROOT_VISIBLE_PROPERTY, old, rootVisible);
+        treeDidChange();
+    }
+
+    /// Whether the nodes of the first level get an arrow and the indent
+    /// it needs.
+    public void setShowsRootHandles(boolean newValue) {
+        boolean old = showsRootHandles;
+        showsRootHandles = newValue;
+        firePropertyChange(SHOWS_ROOT_HANDLES_PROPERTY, old, newValue);
+        treeDidChange();
+    }
+
+    public boolean getShowsRootHandles() {
+        return showsRootHandles;
+    }
+
+    /// Sets the height of every row in logical pixels and stops the tree
+    /// from sizing its rows for the device. A height below 1 gives the
+    /// sizing back to the tree.
+    public void setRowHeight(int rowHeight) {
+        int old = this.rowHeight;
+        this.rowHeight = rowHeight;
+        rowHeightSet = rowHeight > 0;
+        firePropertyChange(ROW_HEIGHT_PROPERTY, old, rowHeight);
+        treeDidChange();
+    }
+
+    /// The height of a row: the one that was set, or else one that fits
+    /// the font, and a finger on a touch screen.
+    public int getRowHeight() {
+        if (rowHeightSet) {
+            return rowHeight;
+        }
+        return Math.max(1, CellTheme.rowHeight(getFont(), 18, 32));
+    }
+
+    public boolean isFixedRowHeight() {
+        return true;
+    }
+
+    public void setLargeModel(boolean newValue) {
+        boolean old = largeModel;
+        largeModel = newValue;
+        firePropertyChange(LARGE_MODEL_PROPERTY, old, newValue);
+    }
+
+    public boolean isLargeModel() {
+        return largeModel;
+    }
+
+    public void setInvokesStopCellEditing(boolean newValue) {
+        boolean old = invokesStopCellEditing;
+        invokesStopCellEditing = newValue;
+        firePropertyChange(INVOKES_STOP_CELL_EDITING_PROPERTY, old, newValue);
+    }
+
+    public boolean getInvokesStopCellEditing() {
+        return invokesStopCellEditing;
+    }
+
+    public void setScrollsOnExpand(boolean newValue) {
+        boolean old = scrollsOnExpand;
+        scrollsOnExpand = newValue;
+        firePropertyChange(SCROLLS_ON_EXPAND_PROPERTY, old, newValue);
+    }
+
+    public boolean getScrollsOnExpand() {
+        return scrollsOnExpand;
+    }
+
+    public void setToggleClickCount(int clickCount) {
+        int old = toggleClickCount;
+        toggleClickCount = clickCount;
+        firePropertyChange(TOGGLE_CLICK_COUNT_PROPERTY, old, clickCount);
+    }
+
+    public int getToggleClickCount() {
+        return toggleClickCount;
+    }
+
+    public void setExpandsSelectedPaths(boolean newValue) {
+        boolean old = expandsSelectedPaths;
+        expandsSelectedPaths = newValue;
+        firePropertyChange(EXPANDS_SELECTED_PATHS_PROPERTY, old, newValue);
+    }
+
+    public boolean getExpandsSelectedPaths() {
+        return expandsSelectedPaths;
+    }
+
+    public void setVisibleRowCount(int newCount) {
+        int old = visibleRowCount;
+        visibleRowCount = newCount;
+        firePropertyChange(VISIBLE_ROW_COUNT_PROPERTY, old, newCount);
+    }
+
+    public int getVisibleRowCount() {
+        return visibleRowCount;
+    }
+
+    public boolean isPathEditable(TreePath path) {
+        return isEditable();
+    }
+
+    /// The text shown for a node: its `toString`.
+    public String convertValueToText(Object value, boolean selected, boolean expanded, boolean leaf, int row,
+            boolean hasFocus) {
+        return value == null ? "" : value.toString();
+    }
+
+    // ------------------------------------------------------------ rows
+
+    /// The paths that have a row, top to bottom. Only expanded nodes are
+    /// asked for their children.
+    private ArrayList<TreePath> rows() {
+        if (rows == null) {
+            ArrayList<TreePath> out = new ArrayList<TreePath>();
+            TreeModel m = treeModel;
+            Object root = m == null ? null : m.getRoot();
+            if (root != null) {
+                TreePath rootPath = new TreePath(root);
+                if (rootVisible) {
+                    out.add(rootPath);
+                }
+                if (Boolean.TRUE.equals(expandedState.get(rootPath))) {
+                    addChildren(m, rootPath, out);
+                }
+            }
+            rows = out;
+            rowIndex = null;
+            preferredWidth = -1;
+        }
+        return rows;
+    }
+
+    private void addChildren(TreeModel m, TreePath parent, ArrayList<TreePath> out) {
+        Object node = parent.getLastPathComponent();
+        int n = m.getChildCount(node);
+        for (int i = 0; i < n; i++) {
+            Object child = m.getChild(node, i);
+            if (child == null) {
+                continue;
+            }
+            TreePath path = parent.pathByAddingChild(child);
+            out.add(path);
+            if (Boolean.TRUE.equals(expandedState.get(path))) {
+                addChildren(m, path, out);
+            }
+        }
+    }
+
+    private HashMap<TreePath, Integer> rowIndex() {
+        ArrayList<TreePath> all = rows();
+        if (rowIndex == null) {
+            HashMap<TreePath, Integer> map = new HashMap<TreePath, Integer>();
+            for (int i = 0; i < all.size(); i++) {
+                map.put(all.get(i), Integer.valueOf(i));
+            }
+            rowIndex = map;
+        }
+        return rowIndex;
+    }
+
+    /// Called when the rows may have changed: they are worked out again
+    /// when next needed, and the tree is laid out and painted again.
+    public void treeDidChange() {
+        rows = null;
+        rowIndex = null;
+        preferredWidth = -1;
+        if (selectionModel != null) {
+            selectionModel.resetRowSelection();
+        }
+        if (editorComp != null && editingPath != null) {
+            Rectangle r = editorBounds(editingPath);
+            if (r == null) {
+                cancelEditing();
+            } else {
+                editorComp.setBounds(r);
+            }
+        }
+        revalidate();
+        repaint();
+    }
+
+    public int getRowCount() {
+        return rows().size();
+    }
+
+    public TreePath getPathForRow(int row) {
+        ArrayList<TreePath> all = rows();
+        return row >= 0 && row < all.size() ? all.get(row) : null;
+    }
+
+    public int getRowForPath(TreePath path) {
+        if (path == null) {
+            return -1;
+        }
+        Integer at = rowIndex().get(path);
+        return at == null ? -1 : at.intValue();
+    }
+
+    private int indent() {
+        return CellTheme.touch() ? 28 : 20;
+    }
+
+    /// How many steps a path's row is indented.
+    private int depth(TreePath path) {
+        return path.getPathCount() - 1 - (rootVisible ? 0 : 1) + (showsRootHandles ? 1 : 0);
+    }
+
+    private int labelX(TreePath path) {
+        return Math.max(0, depth(path)) * indent();
+    }
+
+    private boolean leaf(TreePath path) {
+        return treeModel == null || treeModel.isLeaf(path.getLastPathComponent());
+    }
+
+    private Component rendererFor(TreePath path, int row) {
+        TreeCellRenderer r = cellRenderer;
+        if (r == null) {
+            return null;
+        }
+        boolean lead = isFocusOwner() && path.equals(getLeadSelectionPath());
+        return r.getTreeCellRendererComponent(this, path.getLastPathComponent(), isPathSelected(path),
+                isExpanded(path), leaf(path), row, lead);
+    }
+
+    private int labelWidth(TreePath path, int row) {
+        Component c = rendererFor(path, row);
+        if (c == null) {
+            return 0;
+        }
+        Dimension d = c.getPreferredSize();
+        return d == null ? 0 : d.width;
+    }
+
+    /// The rectangle of a path's text in logical pixels: from its indent,
+    /// as wide as the renderer wants. `null` for a path without a row.
+    public Rectangle getPathBounds(TreePath path) {
+        int row = getRowForPath(path);
+        if (row < 0) {
+            return null;
+        }
+        int rh = getRowHeight();
+        return new Rectangle(labelX(path), row * rh, labelWidth(path, row), rh);
+    }
+
+    public Rectangle getRowBounds(int row) {
+        return getPathBounds(getPathForRow(row));
+    }
+
+    /// Where an editor goes: from the text's start to the tree's right
+    /// edge, or the text's width if that is more.
+    private Rectangle editorBounds(TreePath path) {
+        Rectangle r = getPathBounds(path);
+        if (r != null) {
+            r.width = Math.max(Math.max(r.width, getWidth() - r.x), 40);
+        }
+        return r;
+    }
+
+    private int rowAtY(int y) {
+        int rh = getRowHeight();
+        if (y < 0 || rh <= 0) {
+            return -1;
+        }
+        int row = y / rh;
+        return row < getRowCount() ? row : -1;
+    }
+
+    /// The row at a point in logical pixels, or -1 when the point is
+    /// below the last row or before the row's text.
+    public int getRowForLocation(int x, int y) {
+        int row = rowAtY(y);
+        if (row < 0) {
+            return -1;
+        }
+        return x >= labelX(getPathForRow(row)) ? row : -1;
+    }
+
+    public TreePath getPathForLocation(int x, int y) {
+        return getPathForRow(getRowForLocation(x, y));
+    }
+
+    /// The row nearest to a point, whatever its x; -1 for an empty tree.
+    public int getClosestRowForLocation(int x, int y) {
+        int n = getRowCount();
+        int rh = getRowHeight();
+        if (n == 0 || rh <= 0) {
+            return -1;
+        }
+        return Math.max(0, Math.min(n - 1, y / rh));
+    }
+
+    public TreePath getClosestPathForLocation(int x, int y) {
+        return getPathForRow(getClosestRowForLocation(x, y));
+    }
+
+    /// Whether a point is on the arrow of a path's row: in the indent
+    /// step before the text of a node that has children.
+    private boolean onHandle(TreePath path, int x) {
+        int lx = labelX(path);
+        return lx > 0 && x < lx && x >= lx - indent() && !leaf(path);
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        ArrayList<TreePath> all = rows();
+        if (preferredWidth < 0) {
+            int w = 0;
+            for (int i = 0; i < all.size(); i++) {
+                TreePath p = all.get(i);
+                w = Math.max(w, labelX(p) + labelWidth(p, i));
+            }
+            preferredWidth = w;
+        }
+        return new Dimension(preferredWidth, all.size() * getRowHeight());
+    }
+
+    // ------------------------------------------------------------ expansion
+
+    public boolean isExpanded(TreePath path) {
+        if (path == null) {
+            return false;
+        }
+        for (TreePath p = path; p != null; p = p.getParentPath()) {
+            if (!Boolean.TRUE.equals(expandedState.get(p))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean isExpanded(int row) {
+        TreePath path = getPathForRow(row);
+        return path != null && Boolean.TRUE.equals(expandedState.get(path));
+    }
+
+    public boolean isCollapsed(TreePath path) {
+        return !isExpanded(path);
+    }
+
+    public boolean isCollapsed(int row) {
+        return !isExpanded(row);
+    }
+
+    public boolean hasBeenExpanded(TreePath path) {
+        return path != null && expandedState.get(path) != null;
+    }
+
+    /// The expanded paths at and below `parent`, if it is expanded.
+    public Enumeration<TreePath> getExpandedDescendants(TreePath parent) {
+        if (!isExpanded(parent)) {
+            return null;
+        }
+        ArrayList<TreePath> out = new ArrayList<TreePath>();
+        for (Iterator<TreePath> it = expandedState.keySet().iterator(); it.hasNext();) {
+            TreePath p = it.next();
+            if (!p.equals(parent) && parent.isDescendant(p) && isExpanded(p)) {
+                out.add(p);
+            }
+        }
+        out.add(parent);
+        return new ListEnumeration<TreePath>(out, false);
+    }
+
+    /// Expands the nodes above a path so that the path has a row.
+    public void makeVisible(TreePath path) {
+        if (path != null) {
+            TreePath parent = path.getParentPath();
+            if (parent != null) {
+                expandPath(parent);
+            }
+        }
+    }
+
+    public boolean isVisible(TreePath path) {
+        if (path != null) {
+            TreePath parent = path.getParentPath();
+            return parent == null || isExpanded(parent);
+        }
+        return false;
+    }
+
+    public void expandPath(TreePath path) {
+        TreeModel m = getModel();
+        if (path != null && m != null && !m.isLeaf(path.getLastPathComponent())) {
+            setExpandedState(path, true);
+        }
+    }
+
+    public void expandRow(int row) {
+        expandPath(getPathForRow(row));
+    }
+
+    public void collapsePath(TreePath path) {
+        setExpandedState(path, false);
+    }
+
+    public void collapseRow(int row) {
+        collapsePath(getPathForRow(row));
+    }
+
+    /// Expands or collapses a node, asking the will-expand listeners
+    /// first; one that objects stops it. Expanding also expands the nodes
+    /// above. Collapsing a node moves a selection below it onto it.
+    protected void setExpandedState(TreePath path, boolean state) {
+        if (path == null) {
+            return;
+        }
+        boolean opened = false;
+        ArrayList<TreePath> above = new ArrayList<TreePath>();
+        for (TreePath p = path.getParentPath(); p != null; p = p.getParentPath()) {
+            above.add(p);
+        }
+        for (int i = above.size() - 1; i >= 0; i--) {
+            TreePath p = above.get(i);
+            if (!Boolean.TRUE.equals(expandedState.get(p))) {
+                if (!state) {
+                    // Collapsing below a collapsed node: nothing shows it,
+                    // the state alone changes.
+                    break;
+                }
+                try {
+                    fireTreeWillExpand(p);
+                } catch (ExpandVetoException e) {
+                    return;
+                }
+                expandedState.put(p, Boolean.TRUE);
+                opened = true;
+                fireTreeExpanded(p);
+            }
+        }
+        boolean was = Boolean.TRUE.equals(expandedState.get(path));
+        if (state) {
+            if (!was) {
+                try {
+                    fireTreeWillExpand(path);
+                } catch (ExpandVetoException e) {
+                    treeDidChange();
+                    return;
+                }
+                expandedState.put(path, Boolean.TRUE);
+                treeDidChange();
+                fireTreeExpanded(path);
+            } else if (opened) {
+                treeDidChange();
+            }
+        } else if (was) {
+            try {
+                fireTreeWillCollapse(path);
+            } catch (ExpandVetoException e) {
+                return;
+            }
+            expandedState.put(path, Boolean.FALSE);
+            if (editingPath != null && path.isDescendant(editingPath) && !path.equals(editingPath)) {
+                cancelEditing();
+            }
+            treeDidChange();
+            if (removeDescendantSelectedPaths(path, false) && !isPathSelected(path)) {
+                addSelectionPath(path);
+            }
+            fireTreeCollapsed(path);
+        }
+    }
+
+    /// Forgets which nodes are, or ever were, expanded.
+    protected void clearToggledPaths() {
+        expandedState.clear();
+        rows = null;
+        rowIndex = null;
+    }
+
+    private void forgetExpandedBelow(TreePath parent, boolean includeParent) {
+        for (Iterator<TreePath> it = expandedState.keySet().iterator(); it.hasNext();) {
+            TreePath p = it.next();
+            if (parent.isDescendant(p) && (includeParent || !parent.equals(p))) {
+                it.remove();
+            }
+        }
+    }
+
+    /// Takes the selected paths below `path`, and `path` itself if asked,
+    /// out of the selection. Answers whether there were any.
+    protected boolean removeDescendantSelectedPaths(TreePath path, boolean includePath) {
+        TreePath[] selected = getSelectionPaths();
+        if (selected == null) {
+            return false;
+        }
+        ArrayList<TreePath> gone = new ArrayList<TreePath>();
+        for (int i = 0; i < selected.length; i++) {
+            if (path.isDescendant(selected[i]) && (includePath || !path.equals(selected[i]))) {
+                gone.add(selected[i]);
+            }
+        }
+        if (gone.isEmpty()) {
+            return false;
+        }
+        getSelectionModel().removeSelectionPaths(gone.toArray(new TreePath[gone.size()]));
+        return true;
+    }
+
+    public void addTreeExpansionListener(TreeExpansionListener tel) {
+        listenerList.add(TreeExpansionListener.class, tel);
+    }
+
+    public void removeTreeExpansionListener(TreeExpansionListener tel) {
+        listenerList.remove(TreeExpansionListener.class, tel);
+    }
+
+    public TreeExpansionListener[] getTreeExpansionListeners() {
+        return listenerList.getListeners(TreeExpansionListener.class);
+    }
+
+    public void addTreeWillExpandListener(TreeWillExpandListener tel) {
+        listenerList.add(TreeWillExpandListener.class, tel);
+    }
+
+    public void removeTreeWillExpandListener(TreeWillExpandListener tel) {
+        listenerList.remove(TreeWillExpandListener.class, tel);
+    }
+
+    public TreeWillExpandListener[] getTreeWillExpandListeners() {
+        return listenerList.getListeners(TreeWillExpandListener.class);
+    }
+
+    public void fireTreeExpanded(TreePath path) {
+        TreeExpansionListener[] ls = getTreeExpansionListeners();
+        TreeExpansionEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeExpansionEvent(this, path);
+            }
+            ls[i].treeExpanded(e);
+        }
+    }
+
+    public void fireTreeCollapsed(TreePath path) {
+        TreeExpansionListener[] ls = getTreeExpansionListeners();
+        TreeExpansionEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeExpansionEvent(this, path);
+            }
+            ls[i].treeCollapsed(e);
+        }
+    }
+
+    public void fireTreeWillExpand(TreePath path) throws ExpandVetoException {
+        TreeWillExpandListener[] ls = getTreeWillExpandListeners();
+        TreeExpansionEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeExpansionEvent(this, path);
+            }
+            ls[i].treeWillExpand(e);
+        }
+    }
+
+    public void fireTreeWillCollapse(TreePath path) throws ExpandVetoException {
+        TreeWillExpandListener[] ls = getTreeWillExpandListeners();
+        TreeExpansionEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeExpansionEvent(this, path);
+            }
+            ls[i].treeWillCollapse(e);
+        }
+    }
+
+    // ------------------------------------------------------------ selection
+
+    public void setSelectionModel(TreeSelectionModel selectionModel) {
+        TreeSelectionModel next = selectionModel != null ? selectionModel : new DefaultTreeSelectionModel();
+        TreeSelectionModel old = this.selectionModel;
+        if (old != null) {
+            old.removeTreeSelectionListener(selectionRelay);
+            old.setRowMapper(null);
+        }
+        this.selectionModel = next;
+        next.setRowMapper(rowMapper);
+        next.addTreeSelectionListener(selectionRelay);
+        firePropertyChange(SELECTION_MODEL_PROPERTY, old, next);
+        repaint();
+    }
+
+    public TreeSelectionModel getSelectionModel() {
+        return selectionModel;
+    }
+
+    public void setSelectionPath(TreePath path) {
+        getSelectionModel().setSelectionPath(path);
+    }
+
+    public void setSelectionPaths(TreePath[] paths) {
+        getSelectionModel().setSelectionPaths(paths);
+    }
+
+    public void setLeadSelectionPath(TreePath newPath) {
+        TreePath old = leadPath;
+        leadPath = newPath;
+        firePropertyChange(LEAD_SELECTION_PATH_PROPERTY, old, newPath);
+        repaint();
+    }
+
+    public void setAnchorSelectionPath(TreePath newPath) {
+        TreePath old = anchorPath;
+        anchorPath = newPath;
+        firePropertyChange(ANCHOR_SELECTION_PATH_PROPERTY, old, newPath);
+    }
+
+    public void setSelectionRow(int row) {
+        setSelectionRows(new int[]{row});
+    }
+
+    private TreePath[] pathsOf(int[] rowsWanted) {
+        ArrayList<TreePath> out = new ArrayList<TreePath>();
+        if (rowsWanted != null) {
+            for (int i = 0; i < rowsWanted.length; i++) {
+                TreePath p = getPathForRow(rowsWanted[i]);
+                if (p != null) {
+                    out.add(p);
+                }
+            }
+        }
+        return out.toArray(new TreePath[out.size()]);
+    }
+
+    public void setSelectionRows(int[] rows) {
+        setSelectionPaths(pathsOf(rows));
+    }
+
+    public void addSelectionPath(TreePath path) {
+        getSelectionModel().addSelectionPath(path);
+    }
+
+    public void addSelectionPaths(TreePath[] paths) {
+        getSelectionModel().addSelectionPaths(paths);
+    }
+
+    public void addSelectionRow(int row) {
+        addSelectionRows(new int[]{row});
+    }
+
+    public void addSelectionRows(int[] rows) {
+        addSelectionPaths(pathsOf(rows));
+    }
+
+    public Object getLastSelectedPathComponent() {
+        TreePath path = getSelectionModel().getSelectionPath();
+        return path == null ? null : path.getLastPathComponent();
+    }
+
+    public TreePath getLeadSelectionPath() {
+        return leadPath;
+    }
+
+    public TreePath getAnchorSelectionPath() {
+        return anchorPath;
+    }
+
+    public TreePath getSelectionPath() {
+        return getSelectionModel().getSelectionPath();
+    }
+
+    public TreePath[] getSelectionPaths() {
+        TreePath[] paths = getSelectionModel().getSelectionPaths();
+        return paths != null && paths.length > 0 ? paths : null;
+    }
+
+    public int[] getSelectionRows() {
+        return getSelectionModel().getSelectionRows();
+    }
+
+    public int getSelectionCount() {
+        return getSelectionModel().getSelectionCount();
+    }
+
+    public int getMinSelectionRow() {
+        return getSelectionModel().getMinSelectionRow();
+    }
+
+    public int getMaxSelectionRow() {
+        return getSelectionModel().getMaxSelectionRow();
+    }
+
+    public int getLeadSelectionRow() {
+        return getRowForPath(getLeadSelectionPath());
+    }
+
+    public boolean isPathSelected(TreePath path) {
+        return getSelectionModel().isPathSelected(path);
+    }
+
+    public boolean isRowSelected(int row) {
+        return getSelectionModel().isRowSelected(row);
+    }
+
+    /// The paths of the rows from `index0` to `index1`, both included and
+    /// in either order.
+    protected TreePath[] getPathBetweenRows(int index0, int index1) {
+        int n = getRowCount();
+        if (n == 0) {
+            return null;
+        }
+        int a = Math.max(0, Math.min(index0, index1));
+        int b = Math.min(n - 1, Math.max(index0, index1));
+        if (a > b) {
+            return null;
+        }
+        TreePath[] out = new TreePath[b - a + 1];
+        for (int i = a; i <= b; i++) {
+            out[i - a] = getPathForRow(i);
+        }
+        return out;
+    }
+
+    public void setSelectionInterval(int index0, int index1) {
+        getSelectionModel().setSelectionPaths(getPathBetweenRows(index0, index1));
+    }
+
+    public void addSelectionInterval(int index0, int index1) {
+        TreePath[] paths = getPathBetweenRows(index0, index1);
+        if (paths != null && paths.length > 0) {
+            getSelectionModel().addSelectionPaths(paths);
+        }
+    }
+
+    public void removeSelectionInterval(int index0, int index1) {
+        TreePath[] paths = getPathBetweenRows(index0, index1);
+        if (paths != null && paths.length > 0) {
+            getSelectionModel().removeSelectionPaths(paths);
+        }
+    }
+
+    public void removeSelectionPath(TreePath path) {
+        getSelectionModel().removeSelectionPath(path);
+    }
+
+    public void removeSelectionPaths(TreePath[] paths) {
+        getSelectionModel().removeSelectionPaths(paths);
+    }
+
+    public void removeSelectionRow(int row) {
+        removeSelectionRows(new int[]{row});
+    }
+
+    public void removeSelectionRows(int[] rows) {
+        removeSelectionPaths(pathsOf(rows));
+    }
+
+    public void clearSelection() {
+        if (selectionModel != null) {
+            selectionModel.clearSelection();
+        }
+    }
+
+    public boolean isSelectionEmpty() {
+        return getSelectionModel().isSelectionEmpty();
+    }
+
+    public void addTreeSelectionListener(TreeSelectionListener tsl) {
+        listenerList.add(TreeSelectionListener.class, tsl);
+    }
+
+    public void removeTreeSelectionListener(TreeSelectionListener tsl) {
+        listenerList.remove(TreeSelectionListener.class, tsl);
+    }
+
+    public TreeSelectionListener[] getTreeSelectionListeners() {
+        return listenerList.getListeners(TreeSelectionListener.class);
+    }
+
+    protected void fireValueChanged(TreeSelectionEvent e) {
+        TreeSelectionListener[] ls = getTreeSelectionListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].valueChanged(e);
+        }
+    }
+
+    /// Passes the selection model's events on as the tree's own, shows
+    /// newly selected paths and follows the lead.
+    private final class SelectionRelay implements TreeSelectionListener {
+        @Override
+        public void valueChanged(TreeSelectionEvent e) {
+            TreePath[] paths = e.getPaths();
+            boolean[] added = new boolean[paths.length];
+            for (int i = 0; i < paths.length; i++) {
+                added[i] = e.isAddedPath(i);
+                if (added[i] && expandsSelectedPaths) {
+                    makeVisible(paths[i]);
+                }
+            }
+            TreePath lead = e.getNewLeadSelectionPath();
+            if (lead == null ? leadPath != null : !lead.equals(leadPath)) {
+                setLeadSelectionPath(lead);
+            }
+            if (isSelectionEmpty()) {
+                anchorPath = null;
+            } else if (anchorPath == null || getSelectionCount() == 1) {
+                anchorPath = lead;
+            }
+            repaint();
+            fireValueChanged(new TreeSelectionEvent(JTree.this, paths, added, e.getOldLeadSelectionPath(), lead));
+        }
+    }
+
+    private final class Rows implements RowMapper {
+        @Override
+        public int[] getRowsForPaths(TreePath[] path) {
+            if (path == null) {
+                return new int[0];
+            }
+            int[] out = new int[path.length];
+            for (int i = 0; i < path.length; i++) {
+                out[i] = getRowForPath(path[i]);
+            }
+            return out;
+        }
+    }
+
+    // ------------------------------------------------------------ model events
+
+    /// Keeps the rows, the expansion and the selection in step with the
+    /// model. Expansion is kept by path, so whatever the change did not
+    /// remove stays as it was.
+    private final class ModelChanges implements TreeModelListener {
+
+        @Override
+        public void treeNodesChanged(TreeModelEvent e) {
+            preferredWidth = -1;
+            revalidate();
+            repaint();
+        }
+
+        @Override
+        public void treeNodesInserted(TreeModelEvent e) {
+            treeDidChange();
+        }
+
+        @Override
+        public void treeNodesRemoved(TreeModelEvent e) {
+            TreePath parent = e.getTreePath();
+            Object[] children = e.getChildren();
+            if (parent != null && children != null) {
+                for (int i = 0; i < children.length; i++) {
+                    if (children[i] == null) {
+                        continue;
+                    }
+                    TreePath gone = parent.pathByAddingChild(children[i]);
+                    forgetExpandedBelow(gone, true);
+                    removeDescendantSelectedPaths(gone, true);
+                    if (editingPath != null && gone.isDescendant(editingPath)) {
+                        cancelEditing();
+                    }
+                }
+            }
+            treeDidChange();
+        }
+
+        @Override
+        public void treeStructureChanged(TreeModelEvent e) {
+            TreePath parent = e.getTreePath();
+            cancelEditing();
+            Object root = treeModel == null ? null : treeModel.getRoot();
+            if (parent == null || parent.getPathCount() == 1) {
+                clearToggledPaths();
+                clearSelection();
+                if (root != null && (!rootVisible || !treeModel.isLeaf(root))) {
+                    expandedState.put(new TreePath(root), Boolean.TRUE);
+                }
+            } else {
+                forgetExpandedBelow(parent, false);
+                removeDescendantSelectedPaths(parent, false);
+            }
+            treeDidChange();
+        }
+    }
+
+    // ------------------------------------------------------------ scrolling
+
+    /// Scrolls the viewport this tree is in so that the rectangle shows.
+    public void scrollRectToVisible(Rectangle aRect) {
+        ScrollDelegate.reveal(this, aRect);
+    }
+
+    /// Expands what is above a path and scrolls its row into view.
+    public void scrollPathToVisible(TreePath path) {
+        if (path != null) {
+            makeVisible(path);
+            Rectangle bounds = getPathBounds(path);
+            if (bounds != null) {
+                scrollRectToVisible(bounds);
+            }
+        }
+    }
+
+    public void scrollRowToVisible(int row) {
+        scrollPathToVisible(getPathForRow(row));
+    }
+
+    /// As wide as the rows want and as high as the visible row count.
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        return new Dimension(getPreferredSize().width, Math.max(0, visibleRowCount) * getRowHeight());
+    }
+
+    @Override
+    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+        return orientation == SwingConstants.VERTICAL ? getRowHeight() : 4;
+    }
+
+    @Override
+    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
+        return Math.max(1, orientation == SwingConstants.VERTICAL ? visibleRect.height : visibleRect.width);
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        Container parent = getParent();
+        return parent instanceof JViewport && parent.getWidth() > getPreferredSize().width;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportHeight() {
+        Container parent = getParent();
+        return parent instanceof JViewport && parent.getHeight() > getPreferredSize().height;
+    }
+
+    // ------------------------------------------------------------ paint
+
+    private Color rowSelectionColor() {
+        if (cellRenderer instanceof DefaultTreeCellRenderer) {
+            Color c = ((DefaultTreeCellRenderer) cellRenderer).getBackgroundSelectionColor();
+            if (c != null) {
+                return c;
+            }
+        }
+        return CellTheme.selectionBackground("Tree.selectionBackground");
+    }
+
+    /// Paints the rows that meet the clip: the tint of a selected row,
+    /// the arrow of a node with children, and the renderer's component.
+    @Override
+    protected void paintComponent(Graphics g) {
+        Rectangle clip = g.getClipBounds();
+        if (clip == null) {
+            clip = new Rectangle(0, 0, getWidth(), getHeight());
+        }
+        if (isOpaque() && getBackground() != null) {
+            g.setColor(getBackground());
+            g.fillRect(clip.x, clip.y, clip.width, clip.height);
+        }
+        ArrayList<TreePath> all = rows();
+        int rh = getRowHeight();
+        if (all.isEmpty() || rh <= 0 || clip.height <= 0) {
+            return;
+        }
+        int first = Math.max(0, clip.y / rh);
+        int last = Math.min(all.size() - 1, (clip.y + clip.height - 1) / rh);
+        int step = indent();
+        for (int row = first; row <= last; row++) {
+            TreePath path = all.get(row);
+            int y = row * rh;
+            int lx = labelX(path);
+            boolean selected = isPathSelected(path);
+            if (cn1TreeUi instanceof BasicTreeUI) {
+                ((BasicTreeUI) cn1TreeUi).cn1PaintRow(g, clip, getInsets(), getPathBounds(path), path, row,
+                        isExpanded(path), hasBeenExpanded(path), leaf(path));
+            } else {
+                cn1PaintRow(g, path, row);
+            }
+            if (lx > 0 && !leaf(path)) {
+                paintHandle(g, lx - step / 2, y + rh / 2, isExpanded(path), selected);
+            }
+        }
+    }
+
+    /// Paints what a row has but for its arrow: the tint of a selected
+    /// row across the tree, and the renderer's component. Called for each
+    /// row, by the tree or by the `paintRow` of a delegate set with
+    /// [#setUI]. Not Swing API.
+    public void cn1PaintRow(Graphics g, TreePath path, int row) {
+        int rh = getRowHeight();
+        int y = row * rh;
+        int width = getWidth();
+        if (isPathSelected(path)) {
+            g.setColor(rowSelectionColor());
+            g.fillRect(0, y, width, rh);
+        }
+        if (path.equals(editingPath) && editorComp != null) {
+            return;
+        }
+        Component c = rendererFor(path, row);
+        if (c != null) {
+            int lx = labelX(path);
+            int w = Math.max(width - lx, c.getPreferredSize().width);
+            CellPainter.paint(g, c, lx, y, w, rh);
+        }
+    }
+
+    private TreeUI cn1TreeUi;
+
+    /// Sets a delegate. The tree goes on measuring, laying out and
+    /// handling input itself; what a delegate decides is how a row is
+    /// painted, when it is a `BasicTreeUI`: see its `paintRow`.
+    public void setUI(TreeUI ui) {
+        TreeUI old = cn1TreeUi;
+        if (old == ui) {
+            return;
+        }
+        if (old != null) {
+            old.uninstallUI(this);
+        }
+        cn1TreeUi = ui;
+        if (ui != null) {
+            ui.installUI(this);
+        }
+        firePropertyChange("UI", old, ui);
+        revalidate();
+        repaint();
+    }
+
+    /// The arrow of a node with children: pointing down when it is
+    /// expanded, towards the text when it is not.
+    private void paintHandle(Graphics g, int cx, int cy, boolean expanded, boolean selected) {
+        Color fg = getForeground();
+        Color bg = getBackground();
+        Color c = fg == null ? Color.GRAY : bg == null ? fg : CellTheme.mix(bg, fg, 0.65f);
+        g.setColor(c);
+        int s = CellTheme.touch() ? 5 : 4;
+        int[] xs;
+        int[] ys;
+        if (expanded) {
+            xs = new int[]{cx - s, cx + s, cx};
+            ys = new int[]{cy - s / 2, cy - s / 2, cy + s - s / 2};
+        } else {
+            xs = new int[]{cx - s / 2, cx - s / 2, cx + s - s / 2};
+            ys = new int[]{cy - s, cy + s, cy};
+        }
+        g.fillPolygon(xs, ys, 3);
+    }
+
+    // ------------------------------------------------------------ pointer
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        if (isEnabled()) {
+            switch (e.getID()) {
+                case MouseEvent.MOUSE_PRESSED:
+                    pressTouch = CellTheme.touch();
+                    if (overEditor(e)) {
+                        break;
+                    }
+                    if (pressTouch) {
+                        ScrollDelegate.forward(this, e);
+                    } else if (e.getButton() == MouseEvent.BUTTON1) {
+                        pointed(e);
+                    }
+                    break;
+                case MouseEvent.MOUSE_RELEASED:
+                    if (pressTouch) {
+                        ScrollDelegate.forward(this, e);
+                    }
+                    break;
+                case MouseEvent.MOUSE_CLICKED:
+                    if (pressTouch && !overEditor(e)) {
+                        pointed(e);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        super.processMouseEvent(e);
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        if (isEnabled() && pressTouch && e.getID() == MouseEvent.MOUSE_DRAGGED) {
+            ScrollDelegate.forward(this, e);
+        }
+        super.processMouseMotionEvent(e);
+    }
+
+    private boolean overEditor(MouseEvent e) {
+        return editorComp != null && editorComp.getBounds().contains(e.getX(), e.getY());
+    }
+
+    private void toggle(TreePath path) {
+        if (Boolean.TRUE.equals(expandedState.get(path))) {
+            collapsePath(path);
+        } else {
+            expandPath(path);
+            if (scrollsOnExpand && isExpanded(path)) {
+                int row = getRowForPath(path);
+                int n = treeModel == null ? 0 : treeModel.getChildCount(path.getLastPathComponent());
+                if (row >= 0) {
+                    int rh = getRowHeight();
+                    scrollRectToVisible(new Rectangle(labelX(path), row * rh, 1, rh * (n + 1)));
+                }
+            }
+        }
+    }
+
+    /// What a press with a mouse, or a tap with a finger, does: on an
+    /// arrow it expands or collapses, on a row it selects, starts an edit
+    /// or -- on the click the toggle count names -- expands or collapses.
+    private void pointed(MouseEvent e) {
+        int row = rowAtY(e.getY());
+        if (isEditing() && !stopEditing()) {
+            cancelEditing();
+        }
+        if (row < 0) {
+            requestFocusInWindow();
+            return;
+        }
+        TreePath path = getPathForRow(row);
+        if (onHandle(path, e.getX())) {
+            toggle(path);
+            return;
+        }
+        if (e.getX() < labelX(path)) {
+            return;
+        }
+        requestFocusInWindow();
+        // Clicks are counted by time alone, so a quick press on another
+        // row arrives as a second click: count from the row's own first.
+        if (!path.equals(clickPath) || e.getClickCount() <= 1) {
+            clickBase = e.getClickCount() - 1;
+            clickPath = path;
+        }
+        int clicks = e.getClickCount() - clickBase;
+        if (e.isControlDown() || e.isMetaDown()) {
+            if (isPathSelected(path)) {
+                removeSelectionPath(path);
+            } else {
+                addSelectionPath(path);
+            }
+            anchorPath = path;
+        } else if (e.isShiftDown() && anchorPath != null && getRowForPath(anchorPath) >= 0) {
+            TreePath anchor = anchorPath;
+            setSelectionInterval(getRowForPath(anchor), row);
+            anchorPath = anchor;
+            setLeadSelectionPath(path);
+        } else {
+            setSelectionPath(path);
+            anchorPath = path;
+        }
+        if (isEditable() && isPathEditable(path)) {
+            TreeCellEditor editor = editorInUse();
+            MouseEvent counted = clicks == e.getClickCount() ? e : new MouseEvent(this, e.getID(), e.getWhen(),
+                    e.getModifiers(), e.getX(), e.getY(), clicks, e.isPopupTrigger(), e.getButton());
+            if (editor.isCellEditable(counted)) {
+                startEditingAtPath(path);
+                return;
+            }
+        }
+        if (toggleClickCount > 0 && clicks == toggleClickCount && !leaf(path)) {
+            toggle(path);
+        }
+    }
+
+    // ------------------------------------------------------------ keys
+
+    @Override
+    protected void processKeyEvent(KeyEvent e) {
+        if (isEnabled() && !e.isConsumed() && e.getID() == KeyEvent.KEY_PRESSED) {
+            keyPressed(e);
+        }
+        super.processKeyEvent(e);
+    }
+
+    private void lead(int row, boolean extend) {
+        int n = getRowCount();
+        if (n == 0) {
+            return;
+        }
+        int at = Math.max(0, Math.min(row, n - 1));
+        TreePath path = getPathForRow(at);
+        if (extend && anchorPath != null && getRowForPath(anchorPath) >= 0) {
+            TreePath anchor = anchorPath;
+            setSelectionInterval(getRowForPath(anchor), at);
+            anchorPath = anchor;
+            setLeadSelectionPath(path);
+        } else {
+            setSelectionPath(path);
+            anchorPath = path;
+        }
+        scrollPathToVisible(path);
+    }
+
+    private void keyPressed(KeyEvent e) {
+        int row = getLeadSelectionRow();
+        TreePath path = getPathForRow(row);
+        boolean shift = e.isShiftDown();
+        int page = 1;
+        Container p = getParent();
+        int rh = getRowHeight();
+        if (rh > 0) {
+            page = Math.max(1, (p instanceof JViewport ? p.getHeight() : getHeight()) / rh - 1);
+        }
+        switch (e.getKeyCode()) {
+            case KeyEvent.VK_UP:
+                lead(row < 0 ? 0 : row - 1, shift);
+                break;
+            case KeyEvent.VK_DOWN:
+                lead(row + 1, shift);
+                break;
+            case KeyEvent.VK_HOME:
+                lead(0, shift);
+                break;
+            case KeyEvent.VK_END:
+                lead(getRowCount() - 1, shift);
+                break;
+            case KeyEvent.VK_PAGE_UP:
+                lead(Math.max(0, row - page), shift);
+                break;
+            case KeyEvent.VK_PAGE_DOWN:
+                lead(row + page, shift);
+                break;
+            case KeyEvent.VK_RIGHT:
+                if (path != null && !leaf(path)) {
+                    if (Boolean.TRUE.equals(expandedState.get(path))) {
+                        lead(row + 1, false);
+                    } else {
+                        expandPath(path);
+                    }
+                }
+                break;
+            case KeyEvent.VK_LEFT:
+                if (path != null) {
+                    if (!leaf(path) && Boolean.TRUE.equals(expandedState.get(path))) {
+                        collapsePath(path);
+                    } else {
+                        int parent = getRowForPath(path.getParentPath());
+                        if (parent >= 0) {
+                            lead(parent, false);
+                        }
+                    }
+                }
+                break;
+            case KeyEvent.VK_ENTER:
+                if (path != null && !leaf(path)) {
+                    toggle(path);
+                }
+                break;
+            case KeyEvent.VK_F2:
+                if (path != null) {
+                    startEditingAtPath(path);
+                }
+                break;
+            default:
+                return;
+        }
+        e.consume();
+    }
+
+    // ------------------------------------------------------------ editing
+
+    private TreeCellEditor editorInUse() {
+        if (cellEditor == null) {
+            DefaultTreeCellRenderer r = cellRenderer instanceof DefaultTreeCellRenderer
+                    ? (DefaultTreeCellRenderer) cellRenderer : null;
+            cellEditor = new DefaultTreeCellEditor(this, r);
+        }
+        return cellEditor;
+    }
+
+    public boolean isEditing() {
+        return editingPath != null;
+    }
+
+    public TreePath getEditingPath() {
+        return editingPath;
+    }
+
+    /// Ends an edit and stores its value in the model. Answers whether
+    /// there was an edit and it ended.
+    public boolean stopEditing() {
+        TreeCellEditor editor = activeEditor;
+        return editor != null && editor.stopCellEditing();
+    }
+
+    /// Ends an edit without storing anything.
+    public void cancelEditing() {
+        TreeCellEditor editor = activeEditor;
+        if (editor != null) {
+            editor.cancelCellEditing();
+        }
+        // An editor that does not answer still must not stay on the tree.
+        finishEditing(false);
+    }
+
+    /// Starts editing a node, if the tree is editable and the node has a
+    /// row: the editor's component is placed over the row as a child of
+    /// the tree.
+    public void startEditingAtPath(TreePath path) {
+        if (path == null || !isEditable() || !isPathEditable(path)) {
+            return;
+        }
+        if (isEditing() && !stopEditing()) {
+            cancelEditing();
+        }
+        makeVisible(path);
+        int row = getRowForPath(path);
+        TreeCellEditor editor = editorInUse();
+        if (row < 0) {
+            return;
+        }
+        Component c = editor.getTreeCellEditorComponent(this, path.getLastPathComponent(), isPathSelected(path),
+                isExpanded(path), leaf(path), row);
+        Rectangle bounds = editorBounds(path);
+        if (c == null || bounds == null) {
+            return;
+        }
+        editingPath = path;
+        editorComp = c;
+        activeEditor = editor;
+        c.setBounds(bounds);
+        add(c);
+        if (editorListener == null) {
+            editorListener = new EditorEnds();
+        }
+        editor.addCellEditorListener(editorListener);
+        if (editorKeys == null) {
+            editorKeys = new EditorKeys();
+        }
+        c.addKeyListener(editorKeys);
+        revalidate();
+        repaint();
+        c.requestFocus();
+        com.codename1.ui.Component peer = c.cn1PeerOrNull();
+        if (c instanceof JTextComponent && peer instanceof com.codename1.ui.TextArea
+                && peer.getComponentForm() != null && CellTheme.touch()) {
+            ((com.codename1.ui.TextArea) peer).startEditingAsync();
+        }
+    }
+
+    private void finishEditing(boolean store) {
+        TreeCellEditor editor = activeEditor;
+        TreePath path = editingPath;
+        Component c = editorComp;
+        if (editor == null && c == null) {
+            return;
+        }
+        Object value = store && editor != null ? editor.getCellEditorValue() : null;
+        activeEditor = null;
+        editingPath = null;
+        editorComp = null;
+        if (editor != null && editorListener != null) {
+            editor.removeCellEditorListener(editorListener);
+        }
+        if (c != null) {
+            if (editorKeys != null) {
+                c.removeKeyListener(editorKeys);
+            }
+            boolean focused = c.isFocusOwner();
+            remove(c);
+            if (focused) {
+                requestFocusInWindow();
+            }
+        }
+        if (store && path != null && treeModel != null) {
+            treeModel.valueForPathChanged(path, value);
+        }
+        preferredWidth = -1;
+        revalidate();
+        repaint();
+    }
+
+    private final class EditorEnds implements CellEditorListener {
+        @Override
+        public void editingStopped(ChangeEvent e) {
+            finishEditing(true);
+        }
+
+        @Override
+        public void editingCanceled(ChangeEvent e) {
+            finishEditing(false);
+        }
+    }
+
+    /// Escape in the editor's component cancels; Enter is the text
+    /// field's own action and stops the edit through the editor.
+    private final class EditorKeys extends KeyAdapter {
+        @Override
+        public void keyPressed(KeyEvent e) {
+            if (!isEditing()) {
+                return;
+            }
+            if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
+                cancelEditing();
+                e.consume();
+            } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+                stopEditing();
+                e.consume();
+            }
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",rootVisible=" + rootVisible + ",rowHeight=" + getRowHeight()
+                + ",showsRootHandles=" + showsRootHandles + ",scale=" + Units.scale();
+    }
+
+    // ------------------------------------------------------------ nodes
+
+    /// A node over an array, a vector or a hash table that makes its
+    /// children from the elements the first time it is asked for them.
+    public static class DynamicUtilTreeNode extends DefaultMutableTreeNode {
+
+        protected Object childValue;
+        protected boolean loadedChildren;
+
+        /// Adds a node per element of `children` to `parent`, if it is an
+        /// array, a vector or a hash table; the keys of a table name its
+        /// nodes and the values are their children.
+        public static void createChildren(DefaultMutableTreeNode parent, Object children) {
+            if (children instanceof Vector) {
+                Vector<?> v = (Vector<?>) children;
+                for (int i = 0; i < v.size(); i++) {
+                    parent.add(new DynamicUtilTreeNode(v.elementAt(i), v.elementAt(i)));
+                }
+            } else if (children instanceof Hashtable) {
+                Hashtable<?, ?> t = (Hashtable<?, ?>) children;
+                for (Enumeration<?> keys = t.keys(); keys.hasMoreElements();) {
+                    Object key = keys.nextElement();
+                    parent.add(new DynamicUtilTreeNode(key, t.get(key)));
+                }
+            } else if (children instanceof Object[]) {
+                Object[] a = (Object[]) children;
+                for (int i = 0; i < a.length; i++) {
+                    parent.add(new DynamicUtilTreeNode(a[i], a[i]));
+                }
+            }
+        }
+
+        public DynamicUtilTreeNode(Object value, Object children) {
+            super(value);
+            loadedChildren = false;
+            childValue = children;
+            boolean container = children instanceof Vector || children instanceof Hashtable
+                    || children instanceof Object[];
+            setAllowsChildren(container);
+        }
+
+        @Override
+        public boolean isLeaf() {
+            return !getAllowsChildren();
+        }
+
+        @Override
+        public int getChildCount() {
+            if (!loadedChildren) {
+                loadChildren();
+            }
+            return super.getChildCount();
+        }
+
+        protected void loadChildren() {
+            loadedChildren = true;
+            createChildren(this, childValue);
+        }
+
+        @Override
+        public TreeNode getChildAt(int index) {
+            if (!loadedChildren) {
+                loadChildren();
+            }
+            return super.getChildAt(index);
+        }
+
+        @Override
+        public Enumeration children() {
+            if (!loadedChildren) {
+                loadChildren();
+            }
+            return super.children();
+        }
+    }
+
+    // ------------------------------------------------------------ drag
+
+    /// Records whether dragging out of the component is wanted. The layer
+    /// starts no drag of its own, so this is a property and nothing more.
+    public void setDragEnabled(boolean b) {
+        cn1DragEnabled = b;
+    }
+
+    public boolean getDragEnabled() {
+        return cn1DragEnabled;
+    }
+
+    private boolean cn1DragEnabled;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JViewport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JViewport.java
new file mode 100644
index 00000000000..56f497aa831
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JViewport.java
@@ -0,0 +1,494 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.desktopcompat.rt.ViewportPeer;
+
+/// The window a scroll pane looks at its view through.
+///
+/// The view position, the extent and the view size are logical pixels, as
+/// everywhere in this layer, and as on the desktop the view's location is
+/// the negated view position, so hit testing and `getLocationOnScreen`
+/// see the view where it is drawn. The scrolling itself is Codename
+/// One's: the viewport's peer is a scrollable container, the user drags
+/// and flings it natively, and each native movement arrives here as a
+/// change of the view position with a change event.
+///
+/// A view that is not [Scrollable] is stretched to fill a larger
+/// viewport; one that is follows what its `getScrollableTracks...`
+/// methods answer. Scroll modes and the backing store are recorded only.
+public class JViewport extends JComponent implements Accessible {
+
+    public static final int BLIT_SCROLL_MODE = 1;
+
+    public static final int BACKINGSTORE_SCROLL_MODE = 2;
+
+    public static final int SIMPLE_SCROLL_MODE = 0;
+
+    protected boolean isViewSizeSet;
+
+    protected boolean scrollUnderway;
+
+    private transient ChangeEvent changeEvent;
+    private int scrollMode = BLIT_SCROLL_MODE;
+    private int viewX;
+    private int viewY;
+    private boolean nativeScrolling = true;
+    private boolean scrollableX = true;
+    private boolean scrollableY = true;
+    private boolean layingOut;
+
+    public JViewport() {
+        setOpaque(true);
+    }
+
+    // ------------------------------------------------------------ peer
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new ViewportPeer(this, new ViewportPeer.Listener() {
+            @Override
+            public void scrolled(int x, int y) {
+                cn1NativeScrolled(x, y);
+            }
+        });
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        applyScrollable();
+    }
+
+    private void applyScrollable() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof ViewportPeer) {
+            ViewportPeer v = (ViewportPeer) p;
+            v.setScrollableX(nativeScrolling && scrollableX);
+            v.setScrollableY(nativeScrolling && scrollableY);
+            // Codename One's own indicator is for a device that gives the
+            // scroll bars no room. Where they have room they show the
+            // position, and a second bar drawn over the content beside
+            // them says the same thing twice.
+            v.setScrollVisible(com.codename1.desktopcompat.rt.ScrollDelegate.barThickness() == 0);
+        }
+    }
+
+    /// Which axes the user may scroll; a scroll pane turns one off for
+    /// the policy "never".
+    public void cn1SetScrollable(boolean x, boolean y) {
+        scrollableX = x;
+        scrollableY = y;
+        applyScrollable();
+    }
+
+    /// With `false` the viewport is only moved by `setViewPosition`, as
+    /// the header viewports of a scroll pane are, and its view's peer is
+    /// placed at the negated view position instead of being scrolled.
+    public void cn1SetNativeScrolling(boolean b) {
+        nativeScrolling = b;
+        applyScrollable();
+        placeView();
+    }
+
+    /// The peer was scrolled by the user, to a position in device pixels.
+    protected void cn1NativeScrolled(int deviceX, int deviceY) {
+        if (!nativeScrolling) {
+            return;
+        }
+        Dimension size = viewSize();
+        Dimension extent = getExtentSize();
+        int x = Math.max(0, Math.min(Units.toLogical(deviceX), size.width - extent.width));
+        int y = Math.max(0, Math.min(Units.toLogical(deviceY), size.height - extent.height));
+        if (x != viewX || y != viewY) {
+            viewX = x;
+            viewY = y;
+            scrollUnderway = true;
+            try {
+                placeView();
+                fireStateChanged();
+            } finally {
+                scrollUnderway = false;
+            }
+        }
+    }
+
+    /// Gives the view its location and, when the peer scrolls natively,
+    /// keeps the view's peer at the origin for Codename One to scroll.
+    private void placeView() {
+        Component view = getView();
+        if (view == null) {
+            return;
+        }
+        view.setLocation(-viewX, -viewY);
+        com.codename1.ui.Component vp = view.cn1PeerOrNull();
+        if (nativeScrolling && vp != null) {
+            vp.setX(0);
+            vp.setY(0);
+        }
+    }
+
+    private void pushPosition() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (nativeScrolling && p instanceof ViewportPeer) {
+            ((ViewportPeer) p).scrollTo(Units.toDevice(viewX), Units.toDevice(viewY));
+        }
+    }
+
+    // ------------------------------------------------------------ view
+
+    public Component getView() {
+        return getComponentCount() > 0 ? getComponent(0) : null;
+    }
+
+    public void setView(Component view) {
+        for (int i = getComponentCount() - 1; i >= 0; i--) {
+            remove(i);
+        }
+        isViewSizeSet = false;
+        if (view != null) {
+            super.addImpl(view, null, -1);
+        }
+        viewX = 0;
+        viewY = 0;
+        pushPosition();
+        revalidate();
+        repaint();
+        fireStateChanged();
+    }
+
+    /// A viewport has one child: adding a component makes it the view.
+    @Override
+    protected void addImpl(Component child, Object constraints, int index) {
+        setView(child);
+    }
+
+    private Dimension viewSize() {
+        Component view = getView();
+        return view == null ? new Dimension(0, 0) : view.getSize();
+    }
+
+    public Dimension getViewSize() {
+        Component view = getView();
+        if (view == null) {
+            return new Dimension(0, 0);
+        } else if (isViewSizeSet) {
+            return view.getSize();
+        }
+        return view.getPreferredSize();
+    }
+
+    public void setViewSize(Dimension newSize) {
+        Component view = getView();
+        if (view != null && !newSize.equals(view.getSize())) {
+            scrollUnderway = false;
+            view.setSize(newSize);
+            isViewSizeSet = true;
+            fireStateChanged();
+        }
+    }
+
+    public Point getViewPosition() {
+        return new Point(viewX, viewY);
+    }
+
+    public void setViewPosition(Point p) {
+        if (p.x == viewX && p.y == viewY) {
+            return;
+        }
+        viewX = p.x;
+        viewY = p.y;
+        scrollUnderway = true;
+        try {
+            pushPosition();
+            placeView();
+            repaint();
+            fireStateChanged();
+        } finally {
+            scrollUnderway = false;
+        }
+    }
+
+    public Dimension getExtentSize() {
+        Insets i = getInsets();
+        return new Dimension(Math.max(0, getWidth() - i.left - i.right), Math.max(0, getHeight() - i.top - i.bottom));
+    }
+
+    public void setExtentSize(Dimension newExtent) {
+        Dimension old = getExtentSize();
+        if (!old.equals(newExtent)) {
+            setSize(newExtent);
+            fireStateChanged();
+        }
+    }
+
+    public Rectangle getViewRect() {
+        Dimension e = getExtentSize();
+        return new Rectangle(viewX, viewY, e.width, e.height);
+    }
+
+    public Dimension toViewCoordinates(Dimension size) {
+        return new Dimension(size);
+    }
+
+    public Point toViewCoordinates(Point p) {
+        return new Point(p);
+    }
+
+    public int getScrollMode() {
+        return scrollMode;
+    }
+
+    public void setScrollMode(int mode) {
+        scrollMode = mode;
+    }
+
+    @Deprecated
+    public boolean isBackingStoreEnabled() {
+        return scrollMode == BACKINGSTORE_SCROLL_MODE;
+    }
+
+    @Deprecated
+    public void setBackingStoreEnabled(boolean enabled) {
+        scrollMode = enabled ? BACKINGSTORE_SCROLL_MODE : BLIT_SCROLL_MODE;
+    }
+
+    // ------------------------------------------------------------ scrolling
+
+    private static int adjust(int parentWidth, int childWidth, int childAt) {
+        if (childAt >= 0 && childWidth + childAt <= parentWidth) {
+            return 0;
+        }
+        if (childAt <= 0 && childWidth + childAt >= parentWidth) {
+            return 0;
+        }
+        if (childAt > 0 && childWidth <= parentWidth) {
+            return -childAt + parentWidth - childWidth;
+        }
+        if (childAt >= 0 && childWidth >= parentWidth) {
+            return -childAt;
+        }
+        if (childAt <= 0 && childWidth <= parentWidth) {
+            return -childAt;
+        }
+        if (childAt < 0 && childWidth >= parentWidth) {
+            return -childAt + parentWidth - childWidth;
+        }
+        return 0;
+    }
+
+    /// Scrolls so that the rectangle, given in this viewport's own
+    /// coordinates, shows.
+    public void scrollRectToVisible(Rectangle contentRect) {
+        Component view = getView();
+        if (view == null) {
+            return;
+        }
+        if (!layingOut && !view.isValid()) {
+            // The view may just have grown: scroll within its new size.
+            // Not from this viewport's own layout, which is what gives the
+            // view that size and would otherwise be started again.
+            validate();
+        }
+        Dimension extent = getExtentSize();
+        int dx = adjust(extent.width, contentRect.width, contentRect.x);
+        int dy = adjust(extent.height, contentRect.height, contentRect.y);
+        if (dx == 0 && dy == 0) {
+            return;
+        }
+        Dimension size = view.getSize();
+        int x = Math.max(0, Math.min(viewX - dx, Math.max(0, size.width - extent.width)));
+        int y = Math.max(0, Math.min(viewY - dy, Math.max(0, size.height - extent.height)));
+        setViewPosition(new Point(x, y));
+    }
+
+    /// Scrolls every viewport above `c` so that the rectangle, given in
+    /// the coordinates of `c`, shows. This is what
+    /// `JComponent.scrollRectToVisible` does on the desktop.
+    public static void cn1ScrollRectToVisible(Component c, Rectangle aRect) {
+        int dx = c.getX();
+        int dy = c.getY();
+        Container parent = c.getParent();
+        while (parent != null && !(parent instanceof JViewport)) {
+            dx += parent.getX();
+            dy += parent.getY();
+            parent = parent.getParent();
+        }
+        if (parent != null) {
+            Rectangle r = new Rectangle(aRect.x + dx, aRect.y + dy, aRect.width, aRect.height);
+            ((JViewport) parent).scrollRectToVisible(r);
+            cn1ScrollRectToVisible(parent, new Rectangle(r.x, r.y, r.width, r.height));
+        }
+    }
+
+    // ------------------------------------------------------------ layout
+
+    @Override
+    public void doLayout() {
+        if (layingOut) {
+            return;
+        }
+        layingOut = true;
+        try {
+            layOutView();
+        } finally {
+            layingOut = false;
+        }
+    }
+
+    private void layOutView() {
+        Component view = getView();
+        if (view == null) {
+            return;
+        }
+        Insets insets = getInsets();
+        Dimension pref = view.getPreferredSize();
+        Dimension extent = getExtentSize();
+        int w = pref.width;
+        int h = pref.height;
+        if (view instanceof Scrollable) {
+            Scrollable s = (Scrollable) view;
+            if (s.getScrollableTracksViewportWidth()) {
+                w = extent.width;
+            }
+            if (s.getScrollableTracksViewportHeight()) {
+                h = extent.height;
+            }
+            if (w != pref.width && view instanceof JComponent) {
+                // A view whose height follows its width (wrapped text) is
+                // asked again once it has the width it will be shown at.
+                view.setSize(w, view.getHeight());
+                int again = view.getPreferredSize().height;
+                if (!s.getScrollableTracksViewportHeight()) {
+                    h = again;
+                }
+            }
+        } else {
+            if (w < extent.width) {
+                w = extent.width;
+            }
+            if (h < extent.height) {
+                h = extent.height;
+            }
+        }
+        viewX = Math.max(0, Math.min(viewX, w - extent.width));
+        viewY = Math.max(0, Math.min(viewY, h - extent.height));
+        view.setBounds(insets.left - viewX, insets.top - viewY, w, h);
+        // From here on the size of the view is what the layout gave it, the
+        // way the desktop's ViewportLayout leaves it through setViewSize.
+        isViewSizeSet = true;
+        com.codename1.ui.Component vp = view.cn1PeerOrNull();
+        if (nativeScrolling && vp != null) {
+            vp.setX(0);
+            vp.setY(0);
+        }
+        pushPosition();
+        if (view instanceof JTextArea) {
+            JTextArea area = (JTextArea) view;
+            area.cn1RevealCaret();
+            area.cn1RevealDone();
+        }
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        Component view = getView();
+        if (view == null) {
+            return new Dimension(0, 0);
+        }
+        if (view instanceof Scrollable) {
+            return ((Scrollable) view).getPreferredScrollableViewportSize();
+        }
+        return view.getPreferredSize();
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        return isMinimumSizeSet() ? super.getMinimumSize() : new Dimension(4, 4);
+    }
+
+    @Override
+    public Dimension getMaximumSize() {
+        return isMaximumSizeSet() ? super.getMaximumSize() : new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+    }
+
+    /// Fills the viewport with the view's background, or its own when it
+    /// has no view, so the area a short view leaves free is not blank.
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (isOpaque()) {
+            Component view = getView();
+            Color bg = view != null && (view.isBackgroundSet()
+                    || view instanceof com.codename1.desktopcompat.javax.swing.text.JTextComponent)
+                    ? view.getBackground() : getBackground();
+            if (bg != null) {
+                g.setColor(bg);
+                g.fillRect(0, 0, getWidth(), getHeight());
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ listeners
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",isViewSizeSet=" + isViewSizeSet + ",scrollUnderway=" + scrollUnderway;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JWindow.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JWindow.java
new file mode 100644
index 00000000000..a3f5367b69f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/JWindow.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Window;
+
+/// A Swing window without a title bar: a splash screen, a custom popup.
+/// Shown first it fills a form like a frame; shown over another window it
+/// floats over it like a dialog, or is an undecorated window where there
+/// is a window manager.
+public class JWindow extends Window implements RootPaneContainer {
+
+    protected JRootPane rootPane;
+    protected boolean rootPaneCheckingEnabled;
+
+    public JWindow() {
+        this((Frame) null);
+    }
+
+    public JWindow(Frame owner) {
+        super(owner);
+        windowInit();
+    }
+
+    public JWindow(Window owner) {
+        super(owner);
+        windowInit();
+    }
+
+    protected void windowInit() {
+        setRootPane(createRootPane());
+        setRootPaneCheckingEnabled(true);
+    }
+
+    protected JRootPane createRootPane() {
+        return new JRootPane();
+    }
+
+    @Override
+    public JRootPane getRootPane() {
+        return rootPane;
+    }
+
+    protected void setRootPane(JRootPane root) {
+        boolean checking = rootPaneCheckingEnabled;
+        rootPaneCheckingEnabled = false;
+        try {
+            if (rootPane != null) {
+                remove(rootPane);
+            }
+            rootPane = root;
+            if (root != null) {
+                add(root, BorderLayout.CENTER);
+            }
+        } finally {
+            rootPaneCheckingEnabled = checking;
+        }
+    }
+
+    @Override
+    public Container getContentPane() {
+        return rootPane.getContentPane();
+    }
+
+    @Override
+    public void setContentPane(Container contentPane) {
+        rootPane.setContentPane(contentPane);
+    }
+
+    @Override
+    public JLayeredPane getLayeredPane() {
+        return rootPane.getLayeredPane();
+    }
+
+    @Override
+    public void setLayeredPane(JLayeredPane layeredPane) {
+        rootPane.setLayeredPane(layeredPane);
+    }
+
+    @Override
+    public Component getGlassPane() {
+        return rootPane.getGlassPane();
+    }
+
+    @Override
+    public void setGlassPane(Component glassPane) {
+        rootPane.setGlassPane(glassPane);
+    }
+
+    protected boolean isRootPaneCheckingEnabled() {
+        return rootPaneCheckingEnabled;
+    }
+
+    protected void setRootPaneCheckingEnabled(boolean enabled) {
+        rootPaneCheckingEnabled = enabled;
+    }
+
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().add(comp, constraints, index);
+        } else {
+            super.addImpl(comp, constraints, index);
+        }
+    }
+
+    @Override
+    public void remove(Component comp) {
+        if (comp == rootPane || !rootPaneCheckingEnabled) {
+            super.remove(comp);
+        } else {
+            getContentPane().remove(comp);
+        }
+    }
+
+    @Override
+    public void setLayout(LayoutManager manager) {
+        if (rootPaneCheckingEnabled) {
+            getContentPane().setLayout(manager);
+        } else {
+            super.setLayout(manager);
+        }
+    }
+
+    @Override
+    public void update(Graphics g) {
+        paint(g);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/KeyStroke.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/KeyStroke.java
new file mode 100644
index 00000000000..275cdd39d82
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/KeyStroke.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.AWTKeyStroke;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+
+/// A key action used as the key of an input map and as the accelerator of
+/// a menu item. See `AWTKeyStroke` for the string form and for how the
+/// modifiers are kept.
+public class KeyStroke extends AWTKeyStroke {
+
+    private KeyStroke(char keyChar, int keyCode, int modifiers, boolean onKeyRelease) {
+        super(keyChar, keyCode, modifiers, onKeyRelease);
+    }
+
+    public static KeyStroke getKeyStroke(char keyChar) {
+        return new KeyStroke(keyChar, KeyEvent.VK_UNDEFINED, 0, false);
+    }
+
+    public static KeyStroke getKeyStroke(Character keyChar, int modifiers) {
+        if (keyChar == null) {
+            throw new IllegalArgumentException("keyChar cannot be null");
+        }
+        return new KeyStroke(keyChar.charValue(), KeyEvent.VK_UNDEFINED, modifiers, false);
+    }
+
+    public static KeyStroke getKeyStroke(int keyCode, int modifiers, boolean onKeyRelease) {
+        return new KeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, onKeyRelease);
+    }
+
+    public static KeyStroke getKeyStroke(int keyCode, int modifiers) {
+        return new KeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, false);
+    }
+
+    /// The stroke a key event is, or `null` for an event of another kind.
+    public static KeyStroke getKeyStrokeForEvent(KeyEvent anEvent) {
+        AWTKeyStroke k = AWTKeyStroke.getAWTKeyStrokeForEvent(anEvent);
+        return k == null ? null : new KeyStroke(k.getKeyChar(), k.getKeyCode(), k.getModifiers(), k.isOnKeyRelease());
+    }
+
+    /// Parses a stroke; unlike `getAWTKeyStroke(String)` it answers
+    /// `null` for a string that is null, empty or not a stroke.
+    public static KeyStroke getKeyStroke(String s) {
+        if (s == null || s.length() == 0) {
+            return null;
+        }
+        AWTKeyStroke k;
+        try {
+            k = AWTKeyStroke.getAWTKeyStroke(s);
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+        return new KeyStroke(k.getKeyChar(), k.getKeyCode(), k.getModifiers(), k.isOnKeyRelease());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/LayoutStyle.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/LayoutStyle.java
new file mode 100644
index 00000000000..eece1b223d9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/LayoutStyle.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Container;
+
+/// Answers how much space belongs between two components, and between a
+/// component and the edge of its container. [GroupLayout] asks it for
+/// every preferred gap.
+///
+/// The shared instance is the one given to `setInstance`, or a default
+/// that answers 6 pixels between related components and for the container
+/// edge, and 12 between unrelated ones -- the JDK's values for a look and
+/// feel that brings no style of its own.
+///
+/// Not supported: the look and feel is never asked for a style, and the
+/// default does not widen an `INDENT` gap by the width of a check box or
+/// radio button indicator; it answers the related gap for it.
+public abstract class LayoutStyle {
+
+    /// The kinds of gap a component placement can ask for.
+    public enum ComponentPlacement {
+        /// The two components are logically related.
+        RELATED,
+        /// The two components are not logically related.
+        UNRELATED,
+        /// One component is indented under the other.
+        INDENT
+    }
+
+    private static LayoutStyle instance;
+
+    /// Creates a new `LayoutStyle`.
+    public LayoutStyle() {
+    }
+
+    /// Sets the shared instance; `null` restores the default.
+    public static void setInstance(LayoutStyle style) {
+        instance = style;
+    }
+
+    /// Returns the shared instance.
+    public static LayoutStyle getInstance() {
+        LayoutStyle style = instance;
+        if (style == null) {
+            style = DefaultStyle.INSTANCE;
+        }
+        return style;
+    }
+
+    /// Returns the amount of space to use between two components.
+    /// `position` is where `component2` sits relative to `component1`,
+    /// one of the `SwingConstants` compass points `NORTH`, `SOUTH`, `EAST`
+    /// and `WEST`.
+    public abstract int getPreferredGap(JComponent component1, JComponent component2, ComponentPlacement type,
+            int position, Container parent);
+
+    /// Returns the amount of space to place between a component and the
+    /// edge of its parent that `position` names.
+    public abstract int getContainerGap(JComponent component, int position, Container parent);
+
+    private static final class DefaultStyle extends LayoutStyle {
+        static final LayoutStyle INSTANCE = new DefaultStyle();
+
+        private static void checkPosition(int position) {
+            if (position != SwingConstants.NORTH && position != SwingConstants.SOUTH
+                    && position != SwingConstants.WEST && position != SwingConstants.EAST) {
+                throw new IllegalArgumentException();
+            }
+        }
+
+        @Override
+        public int getPreferredGap(JComponent component1, JComponent component2, ComponentPlacement type,
+                int position, Container parent) {
+            if (component1 == null || component2 == null || type == null) {
+                throw new NullPointerException();
+            }
+            checkPosition(position);
+            return type == ComponentPlacement.UNRELATED ? 12 : 6;
+        }
+
+        @Override
+        public int getContainerGap(JComponent component, int position, Container parent) {
+            if (component == null) {
+                throw new NullPointerException();
+            }
+            checkPosition(position);
+            return 6;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListCellRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListCellRenderer.java
new file mode 100644
index 00000000000..64c1cf1234f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListCellRenderer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// Supplies the component a list paints each of its rows with.
+///
+/// The component is used as a stamp: the list gives it the bounds of the
+/// row, paints it there and asks again for the next row, so one instance
+/// can serve every row.
+public interface ListCellRenderer<E> {
+
+    Component getListCellRendererComponent(JList<? extends E> list, E value, int index, boolean isSelected,
+            boolean cellHasFocus);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListModel.java
new file mode 100644
index 00000000000..553ea7b7777
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListModel.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ListDataListener;
+
+/// The elements a list shows.
+public interface ListModel<E> {
+
+    int getSize();
+
+    E getElementAt(int index);
+
+    void addListDataListener(ListDataListener l);
+
+    void removeListDataListener(ListDataListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListSelectionModel.java
new file mode 100644
index 00000000000..472fce1b2cc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ListSelectionModel.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+
+/// Which rows of a list are selected.
+public interface ListSelectionModel {
+
+    int SINGLE_SELECTION = 0;
+
+    int SINGLE_INTERVAL_SELECTION = 1;
+
+    int MULTIPLE_INTERVAL_SELECTION = 2;
+
+    void setSelectionInterval(int index0, int index1);
+
+    void addSelectionInterval(int index0, int index1);
+
+    void removeSelectionInterval(int index0, int index1);
+
+    int getMinSelectionIndex();
+
+    int getMaxSelectionIndex();
+
+    boolean isSelectedIndex(int index);
+
+    int getAnchorSelectionIndex();
+
+    void setAnchorSelectionIndex(int index);
+
+    int getLeadSelectionIndex();
+
+    void setLeadSelectionIndex(int index);
+
+    void clearSelection();
+
+    boolean isSelectionEmpty();
+
+    void insertIndexInterval(int index, int length, boolean before);
+
+    void removeIndexInterval(int index0, int index1);
+
+    void setValueIsAdjusting(boolean valueIsAdjusting);
+
+    boolean getValueIsAdjusting();
+
+    void setSelectionMode(int selectionMode);
+
+    int getSelectionMode();
+
+    void addListSelectionListener(ListSelectionListener x);
+
+    void removeListSelectionListener(ListSelectionListener x);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/LookAndFeel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/LookAndFeel.java
new file mode 100644
index 00000000000..7a327b4a409
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/LookAndFeel.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// The type of a look and feel, so that code which names one, asks
+/// [UIManager] for the current one or passes its own compiles and runs.
+///
+/// The widgets of the layer are drawn by Codename One with its theme, so a
+/// look and feel installs no UI delegates. What it does choose is the
+/// palette, light or dark, and its defaults: see [UIManager].
+public abstract class LookAndFeel {
+
+    public LookAndFeel() {
+    }
+
+    public abstract String getName();
+
+    public abstract String getID();
+
+    public abstract String getDescription();
+
+    public abstract boolean isNativeLookAndFeel();
+
+    public abstract boolean isSupportedLookAndFeel();
+
+    /// Called by [UIManager] when this look and feel is set.
+    public void initialize() {
+    }
+
+    /// Called by [UIManager] when another look and feel replaces this one.
+    public void uninitialize() {
+    }
+
+    /// The defaults of this look and feel; `null` unless a subclass has
+    /// some. [UIManager] copies them into the look and feel defaults when
+    /// this look and feel is set.
+    public UIDefaults getDefaults() {
+        return null;
+    }
+
+    public boolean getSupportsWindowDecorations() {
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + getDescription() + " - " + getClass().getName() + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MenuElement.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MenuElement.java
new file mode 100644
index 00000000000..99451a40e02
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MenuElement.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+
+/// A node of a menu tree: a menu bar, a menu, a popup menu or an item.
+/// The two event methods are never called by this layer, which routes
+/// input to menus through their Codename One widgets.
+public interface MenuElement {
+
+    void processMouseEvent(MouseEvent event, MenuElement[] path, MenuSelectionManager manager);
+
+    void processKeyEvent(KeyEvent event, MenuElement[] path, MenuSelectionManager manager);
+
+    void menuSelectionChanged(boolean isIncluded);
+
+    MenuElement[] getSubElements();
+
+    Component getComponent();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MenuSelectionManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MenuSelectionManager.java
new file mode 100644
index 00000000000..f8f9a34e4d8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MenuSelectionManager.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.ArrayList;
+
+/// Knows which popup menus are open and closes them together.
+///
+/// The selected path is the chain of open popup menus, each preceded by
+/// the menu that opened it. `setSelectedPath` with an empty path closes
+/// every popup; any other path is ignored, because menus open and close
+/// through their own components here.
+public class MenuSelectionManager {
+
+    private static final MenuSelectionManager INSTANCE = new MenuSelectionManager();
+
+    protected ChangeEvent changeEvent;
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private final ArrayList<JPopupMenu> open = new ArrayList<JPopupMenu>();
+
+    public MenuSelectionManager() {
+    }
+
+    public static MenuSelectionManager defaultManager() {
+        return INSTANCE;
+    }
+
+    public void setSelectedPath(MenuElement[] path) {
+        if (path == null || path.length == 0) {
+            clearSelectedPath();
+        }
+    }
+
+    public MenuElement[] getSelectedPath() {
+        ArrayList<MenuElement> l = new ArrayList<MenuElement>();
+        for (int i = 0; i < open.size(); i++) {
+            JPopupMenu p = open.get(i);
+            if (p.getInvoker() instanceof JMenu) {
+                l.add((JMenu) p.getInvoker());
+            }
+            l.add(p);
+        }
+        return l.toArray(new MenuElement[l.size()]);
+    }
+
+    /// Closes every open popup menu.
+    public void clearSelectedPath() {
+        while (!open.isEmpty()) {
+            JPopupMenu p = open.get(open.size() - 1);
+            p.setVisible(false);
+            open.remove(p);
+        }
+    }
+
+    public boolean isComponentPartOfCurrentMenu(Component c) {
+        return !open.isEmpty() && cn1Inside(c);
+    }
+
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    /// Whether any popup menu is open.
+    public boolean cn1PopupShowing() {
+        return !open.isEmpty();
+    }
+
+    /// Whether `c` is part of an open popup menu or of a menu bar, so
+    /// that a press on it is the menu's business and does not close the
+    /// popups.
+    public boolean cn1Inside(Component c) {
+        Component k = c;
+        while (k != null) {
+            if (k instanceof JMenuBar || (k instanceof JPopupMenu && open.contains(k))) {
+                return true;
+            }
+            k = k.getParent();
+        }
+        return false;
+    }
+
+    /// A popup menu opened.
+    public void cn1Opened(JPopupMenu p) {
+        if (!open.contains(p)) {
+            open.add(p);
+            fireStateChanged();
+        }
+    }
+
+    /// A popup menu closed.
+    public void cn1Closed(JPopupMenu p) {
+        if (open.remove(p)) {
+            fireStateChanged();
+        }
+    }
+
+    /// Closes the open popup menus that `menu` is not in.
+    public void cn1CloseOthers(JMenu menu) {
+        JPopupMenu[] all = open.toArray(new JPopupMenu[open.size()]);
+        for (int i = all.length - 1; i >= 0; i--) {
+            boolean related = false;
+            Component k = menu;
+            while (k != null) {
+                if (k == all[i]) {
+                    related = true;
+                    break;
+                }
+                k = k instanceof JPopupMenu ? ((JPopupMenu) k).getInvoker() : k.getParent();
+            }
+            if (!related) {
+                all[i].setVisible(false);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MutableComboBoxModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MutableComboBoxModel.java
new file mode 100644
index 00000000000..f06886e52f6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/MutableComboBoxModel.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// A combo box model whose elements can be added and removed.
+public interface MutableComboBoxModel<E> extends ComboBoxModel<E> {
+
+    void addElement(E item);
+
+    void removeElement(Object obj);
+
+    void insertElementAt(E item, int index);
+
+    void removeElementAt(int index);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/OverlayLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/OverlayLayout.java
new file mode 100644
index 00000000000..b7238a1a49a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/OverlayLayout.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager2;
+
+/// Stacks components over one another, lining up the alignment point of
+/// each on both axes.
+///
+/// A layout handed a container other than its own throws an
+/// `IllegalArgumentException` where the JDK throws `AWTError`.
+public class OverlayLayout implements LayoutManager2 {
+
+    private final Container target;
+
+    public OverlayLayout(Container target) {
+        this.target = target;
+    }
+
+    public final Container getTarget() {
+        return target;
+    }
+
+    @Override
+    public void invalidateLayout(Container target) {
+        check(target);
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    @Override
+    public void addLayoutComponent(Component comp, Object constraints) {
+    }
+
+    private void check(Container c) {
+        if (target != c) {
+            throw new IllegalArgumentException("OverlayLayout can't be shared");
+        }
+    }
+
+    private SizeRequirements[] requests(boolean x) {
+        int n = target.getComponentCount();
+        SizeRequirements[] out = new SizeRequirements[n];
+        for (int i = 0; i < n; i++) {
+            Component c = target.getComponent(i);
+            Dimension min = c.getMinimumSize();
+            Dimension pref = c.getPreferredSize();
+            Dimension max = c.getMaximumSize();
+            out[i] = x ? new SizeRequirements(min.width, pref.width, max.width, c.getAlignmentX())
+                    : new SizeRequirements(min.height, pref.height, max.height, c.getAlignmentY());
+        }
+        return out;
+    }
+
+    private Dimension size(Container c, int which) {
+        check(c);
+        SizeRequirements xt = SizeRequirements.getAlignedSizeRequirements(requests(true));
+        SizeRequirements yt = SizeRequirements.getAlignedSizeRequirements(requests(false));
+        int w = which == 0 ? xt.minimum : which == 1 ? xt.preferred : xt.maximum;
+        int h = which == 0 ? yt.minimum : which == 1 ? yt.preferred : yt.maximum;
+        Insets in = c.getInsets();
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container target) {
+        return size(target, 1);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container target) {
+        return size(target, 0);
+    }
+
+    @Override
+    public Dimension maximumLayoutSize(Container target) {
+        return size(target, 2);
+    }
+
+    @Override
+    public float getLayoutAlignmentX(Container target) {
+        check(target);
+        return SizeRequirements.getAlignedSizeRequirements(requests(true)).alignment;
+    }
+
+    @Override
+    public float getLayoutAlignmentY(Container target) {
+        check(target);
+        return SizeRequirements.getAlignedSizeRequirements(requests(false)).alignment;
+    }
+
+    @Override
+    public void layoutContainer(Container target) {
+        check(target);
+        int n = target.getComponentCount();
+        int[] xo = new int[n];
+        int[] xs = new int[n];
+        int[] yo = new int[n];
+        int[] ys = new int[n];
+        SizeRequirements[] xc = requests(true);
+        SizeRequirements[] yc = requests(false);
+        Insets in = target.getInsets();
+        SizeRequirements.calculateAlignedPositions(target.getWidth() - in.left - in.right,
+                SizeRequirements.getAlignedSizeRequirements(xc), xc, xo, xs);
+        SizeRequirements.calculateAlignedPositions(target.getHeight() - in.top - in.bottom,
+                SizeRequirements.getAlignedSizeRequirements(yc), yc, yo, ys);
+        for (int i = 0; i < n; i++) {
+            target.getComponent(i).setBounds(in.left + xo[i], in.top + yo[i], xs[i], ys[i]);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ProgressMonitor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ProgressMonitor.java
new file mode 100644
index 00000000000..fc1d2b01d6b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ProgressMonitor.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.WindowAdapter;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+
+/// `javax.swing.ProgressMonitor`: shows a dialog with a progress bar once
+/// an operation turns out to take long, and lets the user cancel it.
+///
+/// The dialog does not block its caller. On a phone it floats over the
+/// current form and takes the input while it is showing.
+public class ProgressMonitor {
+
+    private final Component parent;
+    private final Object message;
+    private String note;
+    private int min;
+    private int max;
+    private int millisToDecideToPopup = 500;
+    private int millisToPopup = 2000;
+    private final long started;
+    private boolean canceled;
+    private boolean closed;
+    private JDialog dialog;
+    private JProgressBar bar;
+    private JLabel noteLabel;
+
+    public ProgressMonitor(Component parentComponent, Object message, String note, int min, int max) {
+        this.parent = parentComponent;
+        this.message = message;
+        this.note = note;
+        this.min = min;
+        this.max = max;
+        this.started = System.currentTimeMillis();
+    }
+
+    public void setProgress(int nv) {
+        if (closed) {
+            return;
+        }
+        if (nv >= max) {
+            close();
+            return;
+        }
+        if (dialog != null) {
+            bar.setValue(nv);
+            return;
+        }
+        long elapsed = System.currentTimeMillis() - started;
+        if (elapsed < millisToDecideToPopup) {
+            return;
+        }
+        long predicted = millisToPopup;
+        int done = nv - min;
+        if (done > 0) {
+            predicted = elapsed * (max - min) / done;
+        }
+        if (predicted >= millisToPopup) {
+            open(nv);
+        }
+    }
+
+    private void open(int nv) {
+        Window owner = null;
+        if (parent instanceof Window) {
+            owner = (Window) parent;
+        } else if (parent != null) {
+            owner = SwingUtilities.getWindowAncestor(parent);
+        }
+        String title = UIManager.getString("ProgressMonitor.progressText");
+        dialog = new JDialog(owner, title == null ? "Progress..." : title);
+        JPanel body = new JPanel();
+        body.setLayout(new BoxLayout(body, BoxLayout.Y_AXIS));
+        body.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+        if (message instanceof Component) {
+            body.add((Component) message);
+        } else if (message != null) {
+            body.add(new JLabel(String.valueOf(message)));
+        }
+        noteLabel = new JLabel(note == null ? " " : note);
+        body.add(noteLabel);
+        bar = new JProgressBar(min, max);
+        bar.setValue(nv);
+        body.add(bar);
+        JPanel buttons = new JPanel();
+        String cancelText = UIManager.getString("OptionPane.cancelButtonText");
+        JButton cancel = new JButton(cancelText == null ? "Cancel" : cancelText);
+        cancel.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                canceled = true;
+                hide();
+            }
+        });
+        buttons.add(cancel);
+        dialog.getContentPane().setLayout(new BorderLayout());
+        dialog.getContentPane().add(body, BorderLayout.CENTER);
+        dialog.getContentPane().add(buttons, BorderLayout.SOUTH);
+        dialog.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                canceled = true;
+            }
+        });
+        dialog.pack();
+        dialog.setLocationRelativeTo(parent);
+        dialog.setVisible(true);
+    }
+
+    private void hide() {
+        JDialog d = dialog;
+        dialog = null;
+        bar = null;
+        noteLabel = null;
+        if (d != null) {
+            d.setVisible(false);
+            d.dispose();
+        }
+    }
+
+    public void close() {
+        closed = true;
+        hide();
+    }
+
+    public int getMinimum() {
+        return min;
+    }
+
+    public void setMinimum(int m) {
+        min = m;
+        if (bar != null) {
+            bar.setMinimum(m);
+        }
+    }
+
+    public int getMaximum() {
+        return max;
+    }
+
+    public void setMaximum(int m) {
+        max = m;
+        if (bar != null) {
+            bar.setMaximum(m);
+        }
+    }
+
+    public boolean isCanceled() {
+        return canceled;
+    }
+
+    public void setMillisToDecideToPopup(int millisToDecideToPopup) {
+        this.millisToDecideToPopup = millisToDecideToPopup;
+    }
+
+    public int getMillisToDecideToPopup() {
+        return millisToDecideToPopup;
+    }
+
+    public void setMillisToPopup(int millisToPopup) {
+        this.millisToPopup = millisToPopup;
+    }
+
+    public int getMillisToPopup() {
+        return millisToPopup;
+    }
+
+    public void setNote(String note) {
+        this.note = note;
+        if (noteLabel != null) {
+            noteLabel.setText(note == null ? " " : note);
+        }
+    }
+
+    public String getNote() {
+        return note;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RootPaneContainer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RootPaneContainer.java
new file mode 100644
index 00000000000..0f4ad6a3d1d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RootPaneContainer.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+
+/// What the Swing windows share: one root pane that holds the content
+/// pane, the layered pane and the glass pane.
+public interface RootPaneContainer {
+
+    JRootPane getRootPane();
+
+    void setContentPane(Container contentPane);
+
+    Container getContentPane();
+
+    void setLayeredPane(JLayeredPane layeredPane);
+
+    JLayeredPane getLayeredPane();
+
+    void setGlassPane(Component glassPane);
+
+    Component getGlassPane();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RowFilter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RowFilter.java
new file mode 100644
index 00000000000..3a502652e1a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RowFilter.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/// Decides which rows of a model a sorter shows.
+///
+/// The filters by number, by date and the combinations are here; the
+/// JDK's regular expression filter is not, because a device has no
+/// regular expressions.
+public abstract class RowFilter<M, I> {
+
+    /// How a value is compared with the filter's.
+    public enum ComparisonType {
+        BEFORE,
+        AFTER,
+        EQUAL,
+        NOT_EQUAL
+    }
+
+    public RowFilter() {
+    }
+
+    private static void check(int[] columns) {
+        for (int i = columns.length - 1; i >= 0; i--) {
+            if (columns[i] < 0) {
+                throw new IllegalArgumentException("Index must be >= 0");
+            }
+        }
+    }
+
+    /// Shows the rows with a date value that compares to `date` as asked,
+    /// in one of the given columns or, without any, in any column.
+    public static <M, I> RowFilter<M, I> dateFilter(ComparisonType type, Date date, int... indices) {
+        if (date == null || type == null) {
+            throw new IllegalArgumentException("type and date must be non-null");
+        }
+        check(indices);
+        return new ValueFilter<M, I>(type, null, date.getTime(), indices);
+    }
+
+    /// Shows the rows with a number that compares to `number` as asked,
+    /// in one of the given columns or, without any, in any column.
+    public static <M, I> RowFilter<M, I> numberFilter(ComparisonType type, Number number, int... indices) {
+        if (number == null || type == null) {
+            throw new IllegalArgumentException("type and number must be non-null");
+        }
+        check(indices);
+        return new ValueFilter<M, I>(type, number, 0L, indices);
+    }
+
+    public static <M, I> RowFilter<M, I> orFilter(Iterable<? extends RowFilter<? super M, ? super I>> filters) {
+        return new Combined<M, I>(filters, false);
+    }
+
+    public static <M, I> RowFilter<M, I> andFilter(Iterable<? extends RowFilter<? super M, ? super I>> filters) {
+        return new Combined<M, I>(filters, true);
+    }
+
+    public static <M, I> RowFilter<M, I> notFilter(RowFilter<M, I> filter) {
+        if (filter == null) {
+            throw new IllegalArgumentException("filter must be non-null");
+        }
+        return new Not<M, I>(filter);
+    }
+
+    public abstract boolean include(Entry<? extends M, ? extends I> entry);
+
+    /// One row as a filter sees it.
+    public abstract static class Entry<M, I> {
+
+        public Entry() {
+        }
+
+        public abstract M getModel();
+
+        public abstract int getValueCount();
+
+        public abstract Object getValue(int index);
+
+        public String getStringValue(int index) {
+            Object value = getValue(index);
+            return value == null ? "" : value.toString();
+        }
+
+        public abstract I getIdentifier();
+    }
+
+    /// Compares numbers by magnitude, or dates by their time.
+    private static final class ValueFilter<M, I> extends RowFilter<M, I> {
+
+        private final ComparisonType type;
+        private final Number number;
+        private final long time;
+        private final int[] columns;
+
+        ValueFilter(ComparisonType type, Number number, long time, int[] columns) {
+            this.type = type;
+            this.number = number;
+            this.time = time;
+            this.columns = new int[columns.length];
+            System.arraycopy(columns, 0, this.columns, 0, columns.length);
+        }
+
+        private boolean matches(Object v) {
+            int c;
+            if (number != null) {
+                if (!(v instanceof Number)) {
+                    return false;
+                }
+                Number n = (Number) v;
+                if (n.getClass() == number.getClass() && number instanceof Comparable) {
+                    // Two numbers of one class compare as that class does, as
+                    // Swing compares them: a BigInteger or BigDecimal beyond
+                    // what a long or a double holds stays exact.
+                    @SuppressWarnings("unchecked")
+                    Comparable<Object> own = (Comparable<Object>) number;
+                    c = -Integer.signum(own.compareTo(n));
+                } else if (isWhole(n) && isWhole(number)) {
+                    long a = n.longValue();
+                    long b = number.longValue();
+                    c = a < b ? -1 : a > b ? 1 : 0;
+                } else {
+                    c = Double.compare(n.doubleValue(), number.doubleValue());
+                }
+            } else {
+                if (!(v instanceof Date)) {
+                    return false;
+                }
+                long t = ((Date) v).getTime();
+                c = t < time ? -1 : t > time ? 1 : 0;
+            }
+            switch (type) {
+                case BEFORE:
+                    return c < 0;
+                case AFTER:
+                    return c > 0;
+                case EQUAL:
+                    return c == 0;
+                default:
+                    return c != 0;
+            }
+        }
+
+        private static boolean isWhole(Number n) {
+            return n instanceof Integer || n instanceof Long || n instanceof Short || n instanceof Byte;
+        }
+
+        @Override
+        public boolean include(Entry<? extends M, ? extends I> entry) {
+            int count = entry.getValueCount();
+            if (columns.length == 0) {
+                for (int i = 0; i < count; i++) {
+                    if (matches(entry.getValue(i))) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            for (int i = 0; i < columns.length; i++) {
+                if (columns[i] < count && matches(entry.getValue(columns[i]))) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    private static final class Combined<M, I> extends RowFilter<M, I> {
+
+        private final List<RowFilter<? super M, ? super I>> filters =
+                new ArrayList<RowFilter<? super M, ? super I>>();
+        private final boolean all;
+
+        Combined(Iterable<? extends RowFilter<? super M, ? super I>> source, boolean all) {
+            this.all = all;
+            for (RowFilter<? super M, ? super I> f : source) {
+                if (f == null) {
+                    throw new IllegalArgumentException("Filter must be non-null");
+                }
+                filters.add(f);
+            }
+        }
+
+        @Override
+        public boolean include(Entry<? extends M, ? extends I> entry) {
+            for (int i = 0; i < filters.size(); i++) {
+                if (filters.get(i).include(entry) != all) {
+                    return !all;
+                }
+            }
+            return all;
+        }
+    }
+
+    private static final class Not<M, I> extends RowFilter<M, I> {
+
+        private final RowFilter<M, I> filter;
+
+        Not(RowFilter<M, I> filter) {
+            this.filter = filter;
+        }
+
+        @Override
+        public boolean include(Entry<? extends M, ? extends I> entry) {
+            return !filter.include(entry);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RowSorter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RowSorter.java
new file mode 100644
index 00000000000..f775f9057f9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/RowSorter.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.RowSorterEvent;
+import com.codename1.desktopcompat.javax.swing.event.RowSorterListener;
+import java.util.List;
+
+/// Maps the rows a table shows to the rows of its model, so that the
+/// table can show them sorted and filtered while the model stays as it
+/// is. The table tells the sorter about every model change.
+public abstract class RowSorter<M> {
+
+    private final EventListenerList listenerList = new EventListenerList();
+
+    public RowSorter() {
+    }
+
+    public abstract M getModel();
+
+    public abstract void toggleSortOrder(int column);
+
+    public abstract int convertRowIndexToModel(int index);
+
+    public abstract int convertRowIndexToView(int index);
+
+    public abstract void setSortKeys(List<? extends SortKey> keys);
+
+    public abstract List<? extends SortKey> getSortKeys();
+
+    public abstract int getViewRowCount();
+
+    public abstract int getModelRowCount();
+
+    public abstract void modelStructureChanged();
+
+    public abstract void allRowsChanged();
+
+    public abstract void rowsInserted(int firstRow, int endRow);
+
+    public abstract void rowsDeleted(int firstRow, int endRow);
+
+    public abstract void rowsUpdated(int firstRow, int endRow);
+
+    public abstract void rowsUpdated(int firstRow, int endRow, int column);
+
+    public void addRowSorterListener(RowSorterListener l) {
+        listenerList.add(RowSorterListener.class, l);
+    }
+
+    public void removeRowSorterListener(RowSorterListener l) {
+        listenerList.remove(RowSorterListener.class, l);
+    }
+
+    protected void fireSortOrderChanged() {
+        fire(new RowSorterEvent(this));
+    }
+
+    protected void fireRowSorterChanged(int[] lastRowIndexToModel) {
+        fire(new RowSorterEvent(this, RowSorterEvent.Type.SORTED, lastRowIndexToModel));
+    }
+
+    private void fire(RowSorterEvent e) {
+        RowSorterListener[] ls = listenerList.getListeners(RowSorterListener.class);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].sorterChanged(e);
+        }
+    }
+
+    /// A column and the direction it is sorted in.
+    public static class SortKey {
+
+        private final int column;
+        private final SortOrder sortOrder;
+
+        public SortKey(int column, SortOrder sortOrder) {
+            if (sortOrder == null) {
+                throw new IllegalArgumentException("sort order must be non-null");
+            }
+            this.column = column;
+            this.sortOrder = sortOrder;
+        }
+
+        public final int getColumn() {
+            return column;
+        }
+
+        public final SortOrder getSortOrder() {
+            return sortOrder;
+        }
+
+        @Override
+        public int hashCode() {
+            return 17 * (37 * 17 + column) + sortOrder.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == this) {
+                return true;
+            }
+            if (o instanceof SortKey) {
+                SortKey k = (SortKey) o;
+                return k.column == column && k.sortOrder == sortOrder;
+            }
+            return false;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ScrollPaneConstants.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ScrollPaneConstants.java
new file mode 100644
index 00000000000..df386a8e3b0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ScrollPaneConstants.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// The names and policies a scroll pane uses.
+public interface ScrollPaneConstants {
+
+    String VIEWPORT = "VIEWPORT";
+    String VERTICAL_SCROLLBAR = "VERTICAL_SCROLLBAR";
+    String HORIZONTAL_SCROLLBAR = "HORIZONTAL_SCROLLBAR";
+    String ROW_HEADER = "ROW_HEADER";
+    String COLUMN_HEADER = "COLUMN_HEADER";
+    String LOWER_LEFT_CORNER = "LOWER_LEFT_CORNER";
+    String LOWER_RIGHT_CORNER = "LOWER_RIGHT_CORNER";
+    String UPPER_LEFT_CORNER = "UPPER_LEFT_CORNER";
+    String UPPER_RIGHT_CORNER = "UPPER_RIGHT_CORNER";
+    String LOWER_LEADING_CORNER = "LOWER_LEADING_CORNER";
+    String LOWER_TRAILING_CORNER = "LOWER_TRAILING_CORNER";
+    String UPPER_LEADING_CORNER = "UPPER_LEADING_CORNER";
+    String UPPER_TRAILING_CORNER = "UPPER_TRAILING_CORNER";
+    String VERTICAL_SCROLLBAR_POLICY = "VERTICAL_SCROLLBAR_POLICY";
+    String HORIZONTAL_SCROLLBAR_POLICY = "HORIZONTAL_SCROLLBAR_POLICY";
+    int VERTICAL_SCROLLBAR_AS_NEEDED = 20;
+    int VERTICAL_SCROLLBAR_NEVER = 21;
+    int VERTICAL_SCROLLBAR_ALWAYS = 22;
+    int HORIZONTAL_SCROLLBAR_AS_NEEDED = 30;
+    int HORIZONTAL_SCROLLBAR_NEVER = 31;
+    int HORIZONTAL_SCROLLBAR_ALWAYS = 32;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ScrollPaneLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ScrollPaneLayout.java
new file mode 100644
index 00000000000..e62c94c3fdd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ScrollPaneLayout.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+
+/// The layout of a `JScrollPane`: the viewport, the two bars, the two
+/// headers and the four corners.
+///
+/// A scroll pane has one from the start. An application replaces it with
+/// a subclass to move the parts about: it overrides [#layoutContainer],
+/// calls `super.layoutContainer` for the standard placement and then sets
+/// the bounds of [#viewport], [#vsb], [#rowHead] and the others as it
+/// likes. Those fields are the scroll pane's own parts, read from it
+/// whenever one of them changes and before every layout.
+///
+/// A bar that is not needed is made invisible, as in Swing, so
+/// `vsb.isVisible()` says whether there is one.
+public class ScrollPaneLayout implements LayoutManager, ScrollPaneConstants {
+
+    protected JViewport viewport;
+
+    protected JScrollBar vsb;
+
+    protected JScrollBar hsb;
+
+    protected JViewport rowHead;
+
+    protected JViewport colHead;
+
+    protected Component lowerLeft;
+
+    protected Component lowerRight;
+
+    protected Component upperLeft;
+
+    protected Component upperRight;
+
+    protected int vsbPolicy = VERTICAL_SCROLLBAR_AS_NEEDED;
+
+    protected int hsbPolicy = HORIZONTAL_SCROLLBAR_AS_NEEDED;
+
+    public ScrollPaneLayout() {
+    }
+
+    /// Reads the parts and the policies of `sp` into the fields.
+    public void syncWithScrollPane(JScrollPane sp) {
+        viewport = sp.getViewport();
+        vsb = sp.getVerticalScrollBar();
+        hsb = sp.getHorizontalScrollBar();
+        rowHead = sp.getRowHeader();
+        colHead = sp.getColumnHeader();
+        lowerLeft = sp.getCorner(LOWER_LEFT_CORNER);
+        lowerRight = sp.getCorner(LOWER_RIGHT_CORNER);
+        upperLeft = sp.getCorner(UPPER_LEFT_CORNER);
+        upperRight = sp.getCorner(UPPER_RIGHT_CORNER);
+        vsbPolicy = sp.getVerticalScrollBarPolicy();
+        hsbPolicy = sp.getHorizontalScrollBarPolicy();
+    }
+
+    /// Does nothing: the parts of a scroll pane are set on the scroll
+    /// pane, which tells its layout.
+    @Override
+    public void addLayoutComponent(String s, Component c) {
+    }
+
+    @Override
+    public void removeLayoutComponent(Component c) {
+        if (c == viewport) {
+            viewport = null;
+        } else if (c == vsb) {
+            vsb = null;
+        } else if (c == hsb) {
+            hsb = null;
+        } else if (c == rowHead) {
+            rowHead = null;
+        } else if (c == colHead) {
+            colHead = null;
+        } else if (c == lowerLeft) {
+            lowerLeft = null;
+        } else if (c == lowerRight) {
+            lowerRight = null;
+        } else if (c == upperLeft) {
+            upperLeft = null;
+        } else if (c == upperRight) {
+            upperRight = null;
+        }
+    }
+
+    public int getVerticalScrollBarPolicy() {
+        return vsbPolicy;
+    }
+
+    public int getHorizontalScrollBarPolicy() {
+        return hsbPolicy;
+    }
+
+    public JViewport getViewport() {
+        return viewport;
+    }
+
+    public JScrollBar getHorizontalScrollBar() {
+        return hsb;
+    }
+
+    public JScrollBar getVerticalScrollBar() {
+        return vsb;
+    }
+
+    public JViewport getRowHeader() {
+        return rowHead;
+    }
+
+    public JViewport getColumnHeader() {
+        return colHead;
+    }
+
+    public Component getCorner(String key) {
+        if (LOWER_LEFT_CORNER.equals(key)) {
+            return lowerLeft;
+        }
+        if (LOWER_RIGHT_CORNER.equals(key)) {
+            return lowerRight;
+        }
+        if (UPPER_LEFT_CORNER.equals(key)) {
+            return upperLeft;
+        }
+        if (UPPER_RIGHT_CORNER.equals(key)) {
+            return upperRight;
+        }
+        return null;
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        if (parent instanceof JScrollPane) {
+            return ((JScrollPane) parent).cn1PreferredSize();
+        }
+        return new Dimension(0, 0);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        if (parent instanceof JScrollPane) {
+            return ((JScrollPane) parent).cn1MinimumSize();
+        }
+        return new Dimension(0, 0);
+    }
+
+    /// Places the parts of the scroll pane `parent`: the headers along the
+    /// top and the leading side, the bars that are needed along the
+    /// bottom and the trailing side, the viewport in what is left.
+    @Override
+    public void layoutContainer(Container parent) {
+        if (parent instanceof JScrollPane) {
+            JScrollPane sp = (JScrollPane) parent;
+            syncWithScrollPane(sp);
+            sp.cn1Layout();
+        }
+    }
+
+    /// The layout a scroll pane has until the application gives it one.
+    public static class UIResource extends ScrollPaneLayout
+            implements com.codename1.desktopcompat.javax.swing.plaf.UIResource {
+
+        public UIResource() {
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Scrollable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Scrollable.java
new file mode 100644
index 00000000000..8860b5a4ec9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Scrollable.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+
+/// What a component tells the scroll pane it is shown in: how large a
+/// viewport it would like, how far a step scrolls, and whether it wants to
+/// be as wide or as high as the viewport rather than scroll.
+public interface Scrollable {
+
+    Dimension getPreferredScrollableViewportSize();
+
+    int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction);
+
+    int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction);
+
+    boolean getScrollableTracksViewportWidth();
+
+    boolean getScrollableTracksViewportHeight();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SingleSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SingleSelectionModel.java
new file mode 100644
index 00000000000..0d3fba741d6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SingleSelectionModel.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// A model that holds at most one selected index, as a tabbed pane uses.
+public interface SingleSelectionModel {
+
+    int getSelectedIndex();
+
+    void setSelectedIndex(int index);
+
+    void clearSelection();
+
+    boolean isSelected();
+
+    void addChangeListener(ChangeListener listener);
+
+    void removeChangeListener(ChangeListener listener);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SizeRequirements.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SizeRequirements.java
new file mode 100644
index 00000000000..556c16399a4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SizeRequirements.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// The minimum, preferred and maximum extent of a component along one axis
+/// together with its alignment, and the arithmetic layouts use to place a
+/// row of such components end to end or over one another.
+public class SizeRequirements {
+
+    public int minimum;
+
+    public int preferred;
+
+    public int maximum;
+
+    public float alignment;
+
+    public SizeRequirements() {
+        minimum = 0;
+        preferred = 0;
+        maximum = 0;
+        alignment = 0.5f;
+    }
+
+    public SizeRequirements(int min, int pref, int max, float a) {
+        minimum = min;
+        preferred = pref;
+        maximum = max;
+        alignment = a > 1.0f ? 1.0f : a < 0.0f ? 0.0f : a;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + minimum + "," + preferred + "," + maximum + "]@" + alignment;
+    }
+
+    private static int clamp(long v) {
+        return v > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) v;
+    }
+
+    public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] children) {
+        SizeRequirements total = new SizeRequirements();
+        long min = 0;
+        long pref = 0;
+        long max = 0;
+        for (int i = 0; i < children.length; i++) {
+            SizeRequirements req = children[i];
+            min += req.minimum;
+            pref += req.preferred;
+            max += req.maximum;
+        }
+        total.minimum = clamp(min);
+        total.preferred = clamp(pref);
+        total.maximum = clamp(max);
+        return total;
+    }
+
+    public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] children) {
+        int minAbove = 0;
+        int minBelow = 0;
+        int prefAbove = 0;
+        int prefBelow = 0;
+        int maxAbove = 0;
+        int maxBelow = 0;
+        for (int i = 0; i < children.length; i++) {
+            SizeRequirements req = children[i];
+            int above = (int) (req.alignment * req.minimum);
+            int below = req.minimum - above;
+            minAbove = Math.max(above, minAbove);
+            minBelow = Math.max(below, minBelow);
+            above = (int) (req.alignment * req.preferred);
+            below = req.preferred - above;
+            prefAbove = Math.max(above, prefAbove);
+            prefBelow = Math.max(below, prefBelow);
+            above = (int) (req.alignment * req.maximum);
+            below = req.maximum - above;
+            maxAbove = Math.max(above, maxAbove);
+            maxBelow = Math.max(below, maxBelow);
+        }
+        int min = clamp((long) minAbove + (long) minBelow);
+        int pref = clamp((long) prefAbove + (long) prefBelow);
+        int max = clamp((long) maxAbove + (long) maxBelow);
+        float alignment = 0.0f;
+        if (min > 0) {
+            alignment = (float) minAbove / min;
+            alignment = alignment > 1.0f ? 1.0f : alignment < 0.0f ? 0.0f : alignment;
+        }
+        return new SizeRequirements(min, pref, max, alignment);
+    }
+
+    public static void calculateTiledPositions(int allocated, SizeRequirements total, SizeRequirements[] children,
+            int[] offsets, int[] spans) {
+        calculateTiledPositions(allocated, total, children, offsets, spans, true);
+    }
+
+    public static void calculateTiledPositions(int allocated, SizeRequirements total, SizeRequirements[] children,
+            int[] offsets, int[] spans, boolean forward) {
+        long min = 0;
+        long pref = 0;
+        long max = 0;
+        for (int i = 0; i < children.length; i++) {
+            min += children[i].minimum;
+            pref += children[i].preferred;
+            max += children[i].maximum;
+        }
+        boolean grow = allocated >= pref;
+        // The fraction of each child's slack (towards its maximum when
+        // growing, towards its minimum when shrinking) that is taken up.
+        float play;
+        float range;
+        if (grow) {
+            play = (float) Math.min(allocated - pref, max - pref);
+            range = (float) (max - pref);
+        } else {
+            play = (float) Math.min(pref - allocated, pref - min);
+            range = (float) (pref - min);
+        }
+        float factor = (grow ? max - pref : pref - min) == 0 ? 0.0f : play / range;
+        int at = forward ? 0 : allocated;
+        for (int i = 0; i < children.length; i++) {
+            SizeRequirements req = children[i];
+            if (grow) {
+                int extra = (int) (factor * (req.maximum - req.preferred));
+                spans[i] = clamp((long) req.preferred + (long) extra);
+            } else {
+                float less = factor * (req.preferred - req.minimum);
+                spans[i] = (int) (req.preferred - less);
+            }
+            if (forward) {
+                offsets[i] = at;
+                at = clamp((long) at + (long) spans[i]);
+            } else {
+                offsets[i] = at - spans[i];
+                at = (int) Math.max((long) at - (long) spans[i], 0L);
+            }
+        }
+    }
+
+    public static void calculateAlignedPositions(int allocated, SizeRequirements total, SizeRequirements[] children,
+            int[] offsets, int[] spans) {
+        calculateAlignedPositions(allocated, total, children, offsets, spans, true);
+    }
+
+    public static void calculateAlignedPositions(int allocated, SizeRequirements total, SizeRequirements[] children,
+            int[] offsets, int[] spans, boolean normal) {
+        float align = normal ? total.alignment : 1.0f - total.alignment;
+        int above = (int) (allocated * align);
+        int below = allocated - above;
+        for (int i = 0; i < children.length; i++) {
+            SizeRequirements req = children[i];
+            float a = normal ? req.alignment : 1.0f - req.alignment;
+            int maxAbove = (int) (req.maximum * a);
+            int maxBelow = req.maximum - maxAbove;
+            int up = Math.min(above, maxAbove);
+            int down = Math.min(below, maxBelow);
+            offsets[i] = above - up;
+            spans[i] = clamp((long) up + (long) down);
+        }
+    }
+
+    public static int[] adjustSizes(int delta, SizeRequirements[] children) {
+        return new int[0];
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SortOrder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SortOrder.java
new file mode 100644
index 00000000000..7b37f549f60
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SortOrder.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// The direction a column is sorted in.
+public enum SortOrder {
+    ASCENDING,
+    DESCENDING,
+    UNSORTED
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerDateModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerDateModel.java
new file mode 100644
index 00000000000..ce0c08d81bb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerDateModel.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.Calendar;
+import java.util.Date;
+
+/// A spinner model over dates: a value, an optional earliest and latest
+/// date, and the calendar field one step changes, such as
+/// `Calendar.DAY_OF_MONTH`.
+///
+/// Stepping is `Calendar.add` on the default calendar, so a field the
+/// platform's calendar cannot add to does not step. A bound that is a date
+/// is compared by its time.
+@SuppressWarnings("rawtypes")
+public class SpinnerDateModel extends AbstractSpinnerModel {
+
+    private static final int LAST_FIELD = Calendar.MILLISECOND;
+
+    private Comparable start;
+    private Comparable end;
+    private final Calendar value;
+    private int calendarField;
+
+    public SpinnerDateModel(Date value, Comparable start, Comparable end, int calendarField) {
+        if (value == null) {
+            throw new IllegalArgumentException("value is null");
+        }
+        if (!validField(calendarField)) {
+            throw new IllegalArgumentException("invalid calendarField");
+        }
+        if (!((start == null || compare(start, value) <= 0) && (end == null || compare(end, value) >= 0))) {
+            throw new IllegalArgumentException("(start <= value <= end) is false");
+        }
+        this.value = Calendar.getInstance();
+        this.start = start;
+        this.end = end;
+        this.calendarField = calendarField;
+        this.value.setTime(value);
+    }
+
+    public SpinnerDateModel() {
+        this(new Date(), null, null, Calendar.DAY_OF_MONTH);
+    }
+
+    /// The fields run from the era, zero, to the millisecond.
+    private static boolean validField(int field) {
+        return field >= 0 && field <= LAST_FIELD;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static int compare(Comparable bound, Date d) {
+        if (bound instanceof Date) {
+            long x = ((Date) bound).getTime();
+            long y = d.getTime();
+            return x < y ? -1 : x == y ? 0 : 1;
+        }
+        return bound.compareTo(d);
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    public void setStart(Comparable start) {
+        if (!same(start, this.start)) {
+            this.start = start;
+            fireStateChanged();
+        }
+    }
+
+    public Comparable getStart() {
+        return start;
+    }
+
+    public void setEnd(Comparable end) {
+        if (!same(end, this.end)) {
+            this.end = end;
+            fireStateChanged();
+        }
+    }
+
+    public Comparable getEnd() {
+        return end;
+    }
+
+    public void setCalendarField(int calendarField) {
+        if (!validField(calendarField)) {
+            throw new IllegalArgumentException("invalid calendarField");
+        }
+        if (calendarField != this.calendarField) {
+            this.calendarField = calendarField;
+            fireStateChanged();
+        }
+    }
+
+    public int getCalendarField() {
+        return calendarField;
+    }
+
+    private Date step(int dir) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(value.getTime());
+        cal.add(calendarField, dir);
+        return cal.getTime();
+    }
+
+    @Override
+    public Object getNextValue() {
+        Date next = step(1);
+        return end == null || compare(end, next) >= 0 ? next : null;
+    }
+
+    @Override
+    public Object getPreviousValue() {
+        Date prev = step(-1);
+        return start == null || compare(start, prev) <= 0 ? prev : null;
+    }
+
+    public Date getDate() {
+        return value.getTime();
+    }
+
+    @Override
+    public Object getValue() {
+        return value.getTime();
+    }
+
+    @Override
+    public void setValue(Object value) {
+        if (!(value instanceof Date)) {
+            throw new IllegalArgumentException("illegal value");
+        }
+        if (!value.equals(this.value.getTime())) {
+            this.value.setTime((Date) value);
+            fireStateChanged();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerListModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerListModel.java
new file mode 100644
index 00000000000..1598ef435d9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerListModel.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.Arrays;
+import java.util.List;
+
+/// A spinner model over the elements of a list, which the model keeps and
+/// does not copy. The sequence ends at both ends of the list.
+public class SpinnerListModel extends AbstractSpinnerModel {
+
+    private List<?> list;
+    private int index;
+
+    public SpinnerListModel(List<?> values) {
+        if (values == null || values.size() == 0) {
+            throw new IllegalArgumentException("SpinnerListModel(List) expects non-null non-empty List");
+        }
+        list = values;
+    }
+
+    public SpinnerListModel(Object[] values) {
+        if (values == null || values.length == 0) {
+            throw new IllegalArgumentException("SpinnerListModel(Object[]) expects non-null non-empty Object[]");
+        }
+        list = Arrays.asList(values);
+    }
+
+    public SpinnerListModel() {
+        this(new Object[]{"empty"});
+    }
+
+    public List<?> getList() {
+        return list;
+    }
+
+    public void setList(List<?> list) {
+        if (list == null || list.size() == 0) {
+            throw new IllegalArgumentException("invalid list");
+        }
+        if (!list.equals(this.list)) {
+            this.list = list;
+            index = 0;
+            fireStateChanged();
+        }
+    }
+
+    @Override
+    public Object getValue() {
+        return list.get(index);
+    }
+
+    /// Makes `elt` the current value; an object that is not in the list is
+    /// refused.
+    @Override
+    public void setValue(Object elt) {
+        int at = list.indexOf(elt);
+        if (at == -1) {
+            throw new IllegalArgumentException("invalid sequence element");
+        }
+        if (at != index) {
+            index = at;
+            fireStateChanged();
+        }
+    }
+
+    @Override
+    public Object getNextValue() {
+        return index >= list.size() - 1 ? null : list.get(index + 1);
+    }
+
+    @Override
+    public Object getPreviousValue() {
+        return index <= 0 ? null : list.get(index - 1);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerModel.java
new file mode 100644
index 00000000000..5b6cd2f242d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerModel.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// A sequence of values with a current one, which a spinner steps
+/// through. `getNextValue` and `getPreviousValue` answer `null` at the
+/// ends of the sequence.
+public interface SpinnerModel {
+
+    Object getValue();
+
+    void setValue(Object value);
+
+    Object getNextValue();
+
+    Object getPreviousValue();
+
+    void addChangeListener(ChangeListener l);
+
+    void removeChangeListener(ChangeListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerNumberModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerNumberModel.java
new file mode 100644
index 00000000000..a4852a1f8b8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpinnerNumberModel.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// A spinner model over numbers: a value, a step, and an optional minimum
+/// and maximum. The value keeps its type: an `Integer` steps to an
+/// `Integer`, a `Double` to a `Double`.
+///
+/// A bound that is a number is compared with the value by magnitude
+/// whatever the two types are, where the desktop fails on a bound of
+/// another type than the value. `setValue` does not check the bounds, as
+/// on the desktop.
+@SuppressWarnings("rawtypes")
+public class SpinnerNumberModel extends AbstractSpinnerModel {
+
+    private Number stepSize;
+    private Number value;
+    private Comparable minimum;
+    private Comparable maximum;
+
+    public SpinnerNumberModel(Number value, Comparable minimum, Comparable maximum, Number stepSize) {
+        if (value == null || stepSize == null) {
+            throw new IllegalArgumentException("value and stepSize must be non-null");
+        }
+        if (!((minimum == null || compare(minimum, value) <= 0)
+                && (maximum == null || compare(maximum, value) >= 0))) {
+            throw new IllegalArgumentException("(minimum <= value <= maximum) is false");
+        }
+        this.value = value;
+        this.minimum = minimum;
+        this.maximum = maximum;
+        this.stepSize = stepSize;
+    }
+
+    public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize) {
+        this(Integer.valueOf(value), Integer.valueOf(minimum), Integer.valueOf(maximum), Integer.valueOf(stepSize));
+    }
+
+    public SpinnerNumberModel(double value, double minimum, double maximum, double stepSize) {
+        this(Double.valueOf(value), Double.valueOf(minimum), Double.valueOf(maximum), Double.valueOf(stepSize));
+    }
+
+    public SpinnerNumberModel() {
+        this(Integer.valueOf(0), null, null, Integer.valueOf(1));
+    }
+
+    private static boolean integral(Object o) {
+        return o instanceof Integer || o instanceof Long || o instanceof Short || o instanceof Byte;
+    }
+
+    /// Compares a bound with a number: numbers by magnitude, anything else
+    /// by the bound's own `compareTo`.
+    @SuppressWarnings("unchecked")
+    static int compare(Comparable bound, Number n) {
+        if (bound instanceof Number) {
+            Number b = (Number) bound;
+            if (integral(b) && integral(n)) {
+                long x = b.longValue();
+                long y = n.longValue();
+                return x < y ? -1 : x == y ? 0 : 1;
+            }
+            double x = b.doubleValue();
+            double y = n.doubleValue();
+            return x < y ? -1 : x == y ? 0 : 1;
+        }
+        return bound.compareTo(n);
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    public void setMinimum(Comparable minimum) {
+        if (!same(minimum, this.minimum)) {
+            this.minimum = minimum;
+            fireStateChanged();
+        }
+    }
+
+    public Comparable getMinimum() {
+        return minimum;
+    }
+
+    public void setMaximum(Comparable maximum) {
+        if (!same(maximum, this.maximum)) {
+            this.maximum = maximum;
+            fireStateChanged();
+        }
+    }
+
+    public Comparable getMaximum() {
+        return maximum;
+    }
+
+    public void setStepSize(Number stepSize) {
+        if (stepSize == null) {
+            throw new IllegalArgumentException("null stepSize");
+        }
+        if (!stepSize.equals(this.stepSize)) {
+            this.stepSize = stepSize;
+            fireStateChanged();
+        }
+    }
+
+    public Number getStepSize() {
+        return stepSize;
+    }
+
+    private Number step(int dir) {
+        Number next;
+        if (value instanceof Float || value instanceof Double) {
+            double v = value.doubleValue() + stepSize.doubleValue() * dir;
+            if (value instanceof Double) {
+                next = Double.valueOf(v);
+            } else {
+                next = Float.valueOf((float) v);
+            }
+        } else {
+            long v = value.longValue() + stepSize.longValue() * dir;
+            if (value instanceof Long) {
+                next = Long.valueOf(v);
+            } else if (value instanceof Integer) {
+                next = Integer.valueOf((int) v);
+            } else if (value instanceof Short) {
+                next = Short.valueOf((short) v);
+            } else {
+                next = Byte.valueOf((byte) v);
+            }
+        }
+        if (maximum != null && compare(maximum, next) < 0) {
+            return null;
+        }
+        if (minimum != null && compare(minimum, next) > 0) {
+            return null;
+        }
+        return next;
+    }
+
+    @Override
+    public Object getNextValue() {
+        return step(1);
+    }
+
+    @Override
+    public Object getPreviousValue() {
+        return step(-1);
+    }
+
+    public Number getNumber() {
+        return value;
+    }
+
+    @Override
+    public Object getValue() {
+        return value;
+    }
+
+    @Override
+    public void setValue(Object value) {
+        if (!(value instanceof Number)) {
+            throw new IllegalArgumentException("illegal value");
+        }
+        if (!value.equals(this.value)) {
+            this.value = (Number) value;
+            fireStateChanged();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Spring.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Spring.java
new file mode 100644
index 00000000000..b4d9e9263dc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Spring.java
@@ -0,0 +1,488 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// A length that can stretch and shrink: a minimum, a preferred and a
+/// maximum value, and a current value somewhere around them.
+/// [SpringLayout] describes every edge and size of a component as one.
+///
+/// Springs are combined arithmetically. A sum spreads a value it is
+/// given over its two operands in proportion to how far each can move
+/// from its preferred value; a maximum hands the value to both; a
+/// negation and a scale map it back through their arithmetic.
+///
+/// Setting the value to `UNSET` clears it, after which the value reads as
+/// the preferred value again.
+public abstract class Spring {
+
+    /// The value of a spring that has none.
+    public static final int UNSET = Integer.MIN_VALUE;
+
+    /// Used by the factory methods.
+    protected Spring() {
+    }
+
+    /// Returns the minimum value of this spring.
+    public abstract int getMinimumValue();
+
+    /// Returns the preferred value of this spring.
+    public abstract int getPreferredValue();
+
+    /// Returns the maximum value of this spring.
+    public abstract int getMaximumValue();
+
+    /// Returns the current value of this spring.
+    public abstract int getValue();
+
+    /// Sets the current value of this spring; `UNSET` clears it.
+    public abstract void setValue(int value);
+
+    // How far the spring can move from its preferred value, towards its
+    // minimum when contracting and towards its maximum otherwise.
+    private int cn1Range(boolean contract) {
+        return contract ? getPreferredValue() - getMinimumValue() : getMaximumValue() - getPreferredValue();
+    }
+
+    // The distance of the value from the preferred value, as a fraction
+    // of the range on that side.
+    double cn1Strain() {
+        double delta = getValue() - getPreferredValue();
+        double range = cn1Range(getValue() < getPreferredValue());
+        if (range == 0) {
+            // What the division answers in IEEE arithmetic, spelled out so
+            // that no platform has to agree on dividing by zero.
+            if (delta == 0) {
+                return Double.NaN;
+            }
+            return delta > 0 ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+        }
+        return delta / range;
+    }
+
+    void cn1SetStrain(double strain) {
+        setValue(getPreferredValue() + cn1ToInt(strain * cn1Range(strain < 0)));
+    }
+
+    // A narrowing conversion with the Java language's answers for the
+    // values a native cast leaves undefined.
+    private static int cn1ToInt(double d) {
+        if (d != d) {
+            return 0;
+        }
+        if (d >= Integer.MAX_VALUE) {
+            return Integer.MAX_VALUE;
+        }
+        if (d <= Integer.MIN_VALUE) {
+            return Integer.MIN_VALUE;
+        }
+        return (int) d;
+    }
+
+    // Whether this spring is defined, however indirectly, in terms of
+    // itself. Only springs built from others can be.
+    boolean cn1IsCyclic(SpringLayout layout) {
+        return false;
+    }
+
+    /// Returns a spring whose minimum, preferred and maximum values are
+    /// all `pref`.
+    public static Spring constant(int pref) {
+        return constant(pref, pref, pref);
+    }
+
+    /// Returns a spring with the given minimum, preferred and maximum
+    /// values.
+    public static Spring constant(int min, int pref, int max) {
+        return new Fixed(min, pref, max);
+    }
+
+    /// Returns `-s`: a spring running in the opposite direction.
+    public static Spring minus(Spring s) {
+        return new Negated(s);
+    }
+
+    /// Returns `s1 + s2`. A value set on the sum is divided between the
+    /// two so that both are strained equally.
+    public static Spring sum(Spring s1, Spring s2) {
+        return new Sum(s1, s2);
+    }
+
+    /// Returns `max(s1, s2)`: a spring whose every property is the larger
+    /// of the two.
+    public static Spring max(Spring s1, Spring s2) {
+        return new Larger(s1, s2);
+    }
+
+    /// Returns a spring whose properties are those of `s` multiplied by
+    /// `factor`; a negative factor swaps the minimum and the maximum.
+    public static Spring scale(Spring s, float factor) {
+        if (s == null) {
+            throw new NullPointerException("Argument must not be null");
+        }
+        return new Scaled(s, factor);
+    }
+
+    /// Returns a spring that follows the minimum, preferred and maximum
+    /// width of a component.
+    public static Spring width(Component c) {
+        if (c == null) {
+            throw new NullPointerException("Argument must not be null");
+        }
+        return new SizeOf(c, true);
+    }
+
+    /// Returns a spring that follows the minimum, preferred and maximum
+    /// height of a component.
+    public static Spring height(Component c) {
+        if (c == null) {
+            throw new NullPointerException("Argument must not be null");
+        }
+        return new SizeOf(c, false);
+    }
+
+    /// A spring that keeps a value of its own.
+    abstract static class Valued extends Spring {
+        int size = UNSET;
+
+        @Override
+        public int getValue() {
+            return size != UNSET ? size : getPreferredValue();
+        }
+
+        @Override
+        public final void setValue(int value) {
+            if (size == value) {
+                return;
+            }
+            if (value == UNSET) {
+                cleared();
+            } else {
+                assigned(value);
+            }
+        }
+
+        void cleared() {
+            size = UNSET;
+        }
+
+        void assigned(int value) {
+            size = value;
+        }
+    }
+
+    private static final class Fixed extends Valued {
+        private final int min;
+        private final int pref;
+        private final int max;
+
+        Fixed(int min, int pref, int max) {
+            this.min = min;
+            this.pref = pref;
+            this.max = max;
+        }
+
+        @Override
+        public int getMinimumValue() {
+            return min;
+        }
+
+        @Override
+        public int getPreferredValue() {
+            return pref;
+        }
+
+        @Override
+        public int getMaximumValue() {
+            return max;
+        }
+
+        @Override
+        public String toString() {
+            return "StaticSpring [" + min + ", " + pref + ", " + max + "]";
+        }
+    }
+
+    /// The width or the height of a component.
+    static final class SizeOf extends Valued {
+        final Component c;
+        private final boolean horizontal;
+
+        SizeOf(Component c, boolean horizontal) {
+            this.c = c;
+            this.horizontal = horizontal;
+        }
+
+        @Override
+        public int getMinimumValue() {
+            return horizontal ? c.getMinimumSize().width : c.getMinimumSize().height;
+        }
+
+        @Override
+        public int getPreferredValue() {
+            return horizontal ? c.getPreferredSize().width : c.getPreferredSize().height;
+        }
+
+        @Override
+        public int getMaximumValue() {
+            // A component with no maximum answers a huge one; capped so
+            // that sums of several stay in range.
+            return Math.min(Short.MAX_VALUE, horizontal ? c.getMaximumSize().width : c.getMaximumSize().height);
+        }
+    }
+
+    private static final class Negated extends Spring {
+        private final Spring s;
+
+        Negated(Spring s) {
+            this.s = s;
+        }
+
+        @Override
+        public int getMinimumValue() {
+            return -s.getMaximumValue();
+        }
+
+        @Override
+        public int getPreferredValue() {
+            return -s.getPreferredValue();
+        }
+
+        @Override
+        public int getMaximumValue() {
+            return -s.getMinimumValue();
+        }
+
+        @Override
+        public int getValue() {
+            return -s.getValue();
+        }
+
+        @Override
+        public void setValue(int size) {
+            // The negation of UNSET is UNSET, so clearing passes through.
+            s.setValue(-size);
+        }
+
+        @Override
+        boolean cn1IsCyclic(SpringLayout layout) {
+            return s.cn1IsCyclic(layout);
+        }
+    }
+
+    private static final class Scaled extends Spring {
+        private final Spring s;
+        private final float factor;
+
+        Scaled(Spring s, float factor) {
+            this.s = s;
+            this.factor = factor;
+        }
+
+        @Override
+        public int getMinimumValue() {
+            return Math.round((factor < 0 ? s.getMaximumValue() : s.getMinimumValue()) * factor);
+        }
+
+        @Override
+        public int getPreferredValue() {
+            return Math.round(s.getPreferredValue() * factor);
+        }
+
+        @Override
+        public int getMaximumValue() {
+            return Math.round((factor < 0 ? s.getMinimumValue() : s.getMaximumValue()) * factor);
+        }
+
+        @Override
+        public int getValue() {
+            return Math.round(s.getValue() * factor);
+        }
+
+        @Override
+        public void setValue(int value) {
+            if (value == UNSET) {
+                s.setValue(UNSET);
+            } else {
+                s.setValue(Math.round(value / factor));
+            }
+        }
+
+        @Override
+        boolean cn1IsCyclic(SpringLayout layout) {
+            return s.cn1IsCyclic(layout);
+        }
+    }
+
+    /// A spring seen through a pair of functions that are each other's
+    /// inverse: the properties read through `map`, a value set goes back
+    /// through `inv`.
+    abstract static class Mapped extends Spring {
+        private final Spring s;
+
+        Mapped(Spring s) {
+            this.s = s;
+        }
+
+        abstract int map(int i);
+
+        abstract int inv(int i);
+
+        @Override
+        public int getMinimumValue() {
+            return map(s.getMinimumValue());
+        }
+
+        @Override
+        public int getPreferredValue() {
+            return map(s.getPreferredValue());
+        }
+
+        @Override
+        public int getMaximumValue() {
+            return Math.min(Short.MAX_VALUE, map(s.getMaximumValue()));
+        }
+
+        @Override
+        public int getValue() {
+            return map(s.getValue());
+        }
+
+        @Override
+        public void setValue(int value) {
+            if (value == UNSET) {
+                s.setValue(UNSET);
+            } else {
+                s.setValue(inv(value));
+            }
+        }
+
+        @Override
+        boolean cn1IsCyclic(SpringLayout layout) {
+            return s.cn1IsCyclic(layout);
+        }
+    }
+
+    /// A spring computed from two others. The properties are computed
+    /// once and kept until the value is cleared.
+    private abstract static class Pair extends Valued {
+        final Spring s1;
+        final Spring s2;
+        private int min = UNSET;
+        private int pref = UNSET;
+        private int max = UNSET;
+
+        Pair(Spring s1, Spring s2) {
+            this.s1 = s1;
+            this.s2 = s2;
+        }
+
+        abstract int op(int x, int y);
+
+        @Override
+        void cleared() {
+            super.cleared();
+            min = UNSET;
+            pref = UNSET;
+            max = UNSET;
+            s1.setValue(UNSET);
+            s2.setValue(UNSET);
+        }
+
+        @Override
+        public int getMinimumValue() {
+            if (min == UNSET) {
+                min = op(s1.getMinimumValue(), s2.getMinimumValue());
+            }
+            return min;
+        }
+
+        @Override
+        public int getPreferredValue() {
+            if (pref == UNSET) {
+                pref = op(s1.getPreferredValue(), s2.getPreferredValue());
+            }
+            return pref;
+        }
+
+        @Override
+        public int getMaximumValue() {
+            if (max == UNSET) {
+                max = op(s1.getMaximumValue(), s2.getMaximumValue());
+            }
+            return max;
+        }
+
+        @Override
+        public int getValue() {
+            if (size == UNSET) {
+                size = op(s1.getValue(), s2.getValue());
+            }
+            return size;
+        }
+
+        @Override
+        boolean cn1IsCyclic(SpringLayout layout) {
+            return layout.cn1IsCyclic(s1) || layout.cn1IsCyclic(s2);
+        }
+    }
+
+    private static final class Sum extends Pair {
+        Sum(Spring s1, Spring s2) {
+            super(s1, s2);
+        }
+
+        @Override
+        int op(int x, int y) {
+            return x + y;
+        }
+
+        @Override
+        void assigned(int value) {
+            super.assigned(value);
+            // The second operand takes what the first leaves, so that the
+            // two add up to the value exactly whatever the rounding.
+            s1.cn1SetStrain(cn1Strain());
+            s2.setValue(value - s1.getValue());
+        }
+    }
+
+    private static final class Larger extends Pair {
+        Larger(Spring s1, Spring s2) {
+            super(s1, s2);
+        }
+
+        @Override
+        int op(int x, int y) {
+            return Math.max(x, y);
+        }
+
+        @Override
+        void assigned(int value) {
+            super.assigned(value);
+            s1.setValue(value);
+            s2.setValue(value);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpringLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpringLayout.java
new file mode 100644
index 00000000000..642a0334fe4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SpringLayout.java
@@ -0,0 +1,773 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager2;
+
+/// Lays components out by tying their edges to one another with
+/// [Spring]s: `putConstraint` says that one edge of a component sits a
+/// distance from an edge of another component, or of the container.
+///
+/// Each axis of a component is fixed by two of its edges and sizes. A
+/// component starts out at the origin with the size it asks for; of the
+/// constraints given for an axis the two most recent stand and an older
+/// one is dropped.
+///
+/// A constraint that depends on itself is reported once on the error
+/// stream and treated as unset, as in the JDK.
+///
+/// Not supported: a height cannot be derived from a `BASELINE` constraint
+/// unless the baseline asked for is the one the component has at its
+/// preferred size, since the layer's components do not say how their
+/// baseline moves when they are resized. For the same reason a component
+/// held by its `BASELINE` and by `SOUTH` or `VERTICAL_CENTER` alone keeps
+/// the height it asks for.
+public class SpringLayout implements LayoutManager2 {
+
+    /// The top edge of a component's bounding rectangle.
+    public static final String NORTH = "North";
+
+    /// The bottom edge of a component's bounding rectangle.
+    public static final String SOUTH = "South";
+
+    /// The right edge of a component's bounding rectangle.
+    public static final String EAST = "East";
+
+    /// The left edge of a component's bounding rectangle.
+    public static final String WEST = "West";
+
+    /// The horizontal centre of a component's bounding rectangle.
+    public static final String HORIZONTAL_CENTER = "HorizontalCenter";
+
+    /// The vertical centre of a component's bounding rectangle.
+    public static final String VERTICAL_CENTER = "VerticalCenter";
+
+    /// The baseline of a component.
+    public static final String BASELINE = "Baseline";
+
+    /// The width of a component's bounding rectangle.
+    public static final String WIDTH = "Width";
+
+    /// The height of a component's bounding rectangle.
+    public static final String HEIGHT = "Height";
+
+    private static final String[] ALL_HORIZONTAL = {WEST, WIDTH, EAST, HORIZONTAL_CENTER};
+
+    private static final String[] ALL_VERTICAL = {NORTH, HEIGHT, SOUTH, VERTICAL_CENTER, BASELINE};
+
+    private final Map<Component, Constraints> componentConstraints = new HashMap<Component, Constraints>();
+
+    // What a spring that depends on itself is replaced with.
+    private final Spring cyclicReference = Spring.constant(Spring.UNSET);
+    // Springs being examined, or found to be cyclic, and springs found
+    // not to be; compared by identity.
+    private List<Spring> cyclicSprings = new ArrayList<Spring>();
+    private List<Spring> acyclicSprings = new ArrayList<Spring>();
+
+    /// Constructs a new `SpringLayout`.
+    public SpringLayout() {
+    }
+
+    /// The springs that position and size one component: for each axis
+    /// any two of the edges, the centre and the size, from which the
+    /// others follow.
+    public static class Constraints {
+        private Spring x;
+        private Spring y;
+        private Spring width;
+        private Spring height;
+        private Spring east;
+        private Spring south;
+        private Spring horizontalCenter;
+        private Spring verticalCenter;
+        private Spring baseline;
+
+        // The names constrained on each axis, oldest first; never more
+        // than two.
+        private final List<String> horizontalHistory = new ArrayList<String>(2);
+        private final List<String> verticalHistory = new ArrayList<String>(2);
+
+        // The component these constraints are being applied to.
+        private Component c;
+
+        /// Creates empty constraints.
+        public Constraints() {
+        }
+
+        /// Creates constraints with the given `x` and `y`.
+        public Constraints(Spring x, Spring y) {
+            setX(x);
+            setY(y);
+        }
+
+        /// Creates constraints with the given position and size.
+        public Constraints(Spring x, Spring y, Spring width, Spring height) {
+            setX(x);
+            setY(y);
+            setWidth(width);
+            setHeight(height);
+        }
+
+        /// Creates constraints that keep a component where it is now, at
+        /// the size it asks for.
+        public Constraints(Component c) {
+            this.c = c;
+            setX(Spring.constant(c.getX()));
+            setY(Spring.constant(c.getY()));
+            setWidth(Spring.width(c));
+            setHeight(Spring.height(c));
+        }
+
+        // Records that `name` was constrained. A name set again moves to
+        // the front; a third name on an axis pushes the oldest out, and
+        // every spring that no longer has a name behind it is forgotten
+        // so that it is derived from the remaining two.
+        private void pushConstraint(String name, Spring value, boolean horizontal) {
+            boolean valid = true;
+            List<String> history = horizontal ? horizontalHistory : verticalHistory;
+            if (history.contains(name)) {
+                history.remove(name);
+                valid = false;
+            } else if (history.size() == 2 && value != null) {
+                history.remove(0);
+                valid = false;
+            }
+            if (value != null) {
+                history.add(name);
+            }
+            if (!valid) {
+                String[] all = horizontal ? ALL_HORIZONTAL : ALL_VERTICAL;
+                for (int i = 0; i < all.length; i++) {
+                    if (!history.contains(all[i])) {
+                        setConstraint(all[i], null);
+                    }
+                }
+            }
+        }
+
+        private static Spring sum(Spring s1, Spring s2) {
+            return (s1 == null || s2 == null) ? null : Spring.sum(s1, s2);
+        }
+
+        private static Spring difference(Spring s1, Spring s2) {
+            return (s1 == null || s2 == null) ? null : Spring.sum(s1, Spring.minus(s2));
+        }
+
+        private static Spring scale(Spring s, float factor) {
+            return s == null ? null : Spring.scale(s, factor);
+        }
+
+        private int baselineFromHeight(int h) {
+            if (h < 0) {
+                // A negated height asks for the baseline measured the
+                // other way round.
+                return -c.getBaseline(c.getPreferredSize().width, -h);
+            }
+            return c.getBaseline(c.getPreferredSize().width, h);
+        }
+
+        private int heightFromBaseline(int b) {
+            Dimension pref = c.getPreferredSize();
+            if (c.getBaseline(pref.width, pref.height) == b) {
+                return pref.height;
+            }
+            // How the baseline moves with the height is not known.
+            return Spring.UNSET;
+        }
+
+        private Spring heightToRelativeBaseline(Spring s) {
+            return new Spring.Mapped(s) {
+                @Override
+                int map(int i) {
+                    return baselineFromHeight(i);
+                }
+
+                @Override
+                int inv(int i) {
+                    return heightFromBaseline(i);
+                }
+            };
+        }
+
+        private Spring relativeBaselineToHeight(Spring s) {
+            return new Spring.Mapped(s) {
+                @Override
+                int map(int i) {
+                    return heightFromBaseline(i);
+                }
+
+                @Override
+                int inv(int i) {
+                    return baselineFromHeight(i);
+                }
+            };
+        }
+
+        // Two constraints that name neither the origin nor the size of an
+        // axis would each be derived from the other. A far edge and the
+        // centre give the origin directly: the centre lies half way
+        // between the two edges. The size then follows from the far edge.
+        private void deriveWidthFromPair() {
+            if (width == null && x == null && horizontalHistory.contains(EAST)
+                    && horizontalHistory.contains(HORIZONTAL_CENTER)) {
+                x = difference(scale(horizontalCenter, 2f), east);
+            }
+        }
+
+        private void deriveHeightFromPair() {
+            if (height != null || y != null || verticalHistory.size() < 2 || verticalHistory.contains(NORTH)
+                    || verticalHistory.contains(HEIGHT)) {
+                return;
+            }
+            if (verticalHistory.contains(SOUTH) && verticalHistory.contains(VERTICAL_CENTER)) {
+                y = difference(scale(verticalCenter, 2f), south);
+            } else {
+                // One of the two is the baseline, and how it moves with
+                // the height is not known: the component keeps the height
+                // it asks for and the older constraint gives way.
+                height = c == null ? Spring.constant(0) : Spring.height(c);
+            }
+        }
+
+        /// Sets the spring controlling the left edge.
+        public void setX(Spring x) {
+            this.x = x;
+            pushConstraint(WEST, x, true);
+        }
+
+        /// Returns the spring controlling the left edge, derived from
+        /// the other horizontal constraints when it was not set.
+        public Spring getX() {
+            deriveWidthFromPair();
+            if (x == null) {
+                if (horizontalHistory.contains(EAST)) {
+                    x = difference(east, getWidth());
+                } else if (horizontalHistory.contains(HORIZONTAL_CENTER)) {
+                    x = difference(horizontalCenter, scale(getWidth(), 0.5f));
+                }
+            }
+            return x;
+        }
+
+        /// Sets the spring controlling the top edge.
+        public void setY(Spring y) {
+            this.y = y;
+            pushConstraint(NORTH, y, false);
+        }
+
+        /// Returns the spring controlling the top edge, derived from the
+        /// other vertical constraints when it was not set.
+        public Spring getY() {
+            deriveHeightFromPair();
+            if (y == null) {
+                if (verticalHistory.contains(SOUTH)) {
+                    y = difference(south, getHeight());
+                } else if (verticalHistory.contains(VERTICAL_CENTER)) {
+                    y = difference(verticalCenter, scale(getHeight(), 0.5f));
+                } else if (verticalHistory.contains(BASELINE)) {
+                    y = difference(baseline, heightToRelativeBaseline(getHeight()));
+                }
+            }
+            return y;
+        }
+
+        /// Sets the spring controlling the width.
+        public void setWidth(Spring width) {
+            this.width = width;
+            pushConstraint(WIDTH, width, true);
+        }
+
+        /// Returns the spring controlling the width, derived from the
+        /// other horizontal constraints when it was not set.
+        public Spring getWidth() {
+            deriveWidthFromPair();
+            if (width == null) {
+                if (horizontalHistory.contains(EAST)) {
+                    width = difference(east, getX());
+                } else if (horizontalHistory.contains(HORIZONTAL_CENTER)) {
+                    width = scale(difference(horizontalCenter, getX()), 2f);
+                }
+            }
+            return width;
+        }
+
+        /// Sets the spring controlling the height.
+        public void setHeight(Spring height) {
+            this.height = height;
+            pushConstraint(HEIGHT, height, false);
+        }
+
+        /// Returns the spring controlling the height, derived from the
+        /// other vertical constraints when it was not set.
+        public Spring getHeight() {
+            deriveHeightFromPair();
+            if (height == null) {
+                if (verticalHistory.contains(SOUTH)) {
+                    height = difference(south, getY());
+                } else if (verticalHistory.contains(VERTICAL_CENTER)) {
+                    height = scale(difference(verticalCenter, getY()), 2f);
+                } else if (verticalHistory.contains(BASELINE)) {
+                    height = relativeBaselineToHeight(difference(baseline, getY()));
+                }
+            }
+            return height;
+        }
+
+        private void setEast(Spring east) {
+            this.east = east;
+            pushConstraint(EAST, east, true);
+        }
+
+        private Spring getEast() {
+            if (east == null) {
+                east = sum(getX(), getWidth());
+            }
+            return east;
+        }
+
+        private void setSouth(Spring south) {
+            this.south = south;
+            pushConstraint(SOUTH, south, false);
+        }
+
+        private Spring getSouth() {
+            if (south == null) {
+                south = sum(getY(), getHeight());
+            }
+            return south;
+        }
+
+        private void setHorizontalCenter(Spring horizontalCenter) {
+            this.horizontalCenter = horizontalCenter;
+            pushConstraint(HORIZONTAL_CENTER, horizontalCenter, true);
+        }
+
+        private Spring getHorizontalCenter() {
+            if (horizontalCenter == null) {
+                horizontalCenter = sum(getX(), scale(getWidth(), 0.5f));
+            }
+            return horizontalCenter;
+        }
+
+        private void setVerticalCenter(Spring verticalCenter) {
+            this.verticalCenter = verticalCenter;
+            pushConstraint(VERTICAL_CENTER, verticalCenter, false);
+        }
+
+        private Spring getVerticalCenter() {
+            if (verticalCenter == null) {
+                verticalCenter = sum(getY(), scale(getHeight(), 0.5f));
+            }
+            return verticalCenter;
+        }
+
+        private void setBaseline(Spring baseline) {
+            this.baseline = baseline;
+            pushConstraint(BASELINE, baseline, false);
+        }
+
+        private Spring getBaseline() {
+            if (baseline == null) {
+                baseline = sum(getY(), heightToRelativeBaseline(getHeight()));
+            }
+            return baseline;
+        }
+
+        /// Sets the spring controlling the named edge or size; a name
+        /// that is none of the constants is ignored.
+        public void setConstraint(String edgeName, Spring s) {
+            if (WEST.equals(edgeName)) {
+                setX(s);
+            } else if (NORTH.equals(edgeName)) {
+                setY(s);
+            } else if (EAST.equals(edgeName)) {
+                setEast(s);
+            } else if (SOUTH.equals(edgeName)) {
+                setSouth(s);
+            } else if (HORIZONTAL_CENTER.equals(edgeName)) {
+                setHorizontalCenter(s);
+            } else if (WIDTH.equals(edgeName)) {
+                setWidth(s);
+            } else if (HEIGHT.equals(edgeName)) {
+                setHeight(s);
+            } else if (VERTICAL_CENTER.equals(edgeName)) {
+                setVerticalCenter(s);
+            } else if (BASELINE.equals(edgeName)) {
+                setBaseline(s);
+            }
+        }
+
+        /// Returns the spring controlling the named edge or size, or
+        /// `null` for a name that is none of the constants.
+        public Spring getConstraint(String edgeName) {
+            if (WEST.equals(edgeName)) {
+                return getX();
+            } else if (NORTH.equals(edgeName)) {
+                return getY();
+            } else if (EAST.equals(edgeName)) {
+                return getEast();
+            } else if (SOUTH.equals(edgeName)) {
+                return getSouth();
+            } else if (WIDTH.equals(edgeName)) {
+                return getWidth();
+            } else if (HEIGHT.equals(edgeName)) {
+                return getHeight();
+            } else if (HORIZONTAL_CENTER.equals(edgeName)) {
+                return getHorizontalCenter();
+            } else if (VERTICAL_CENTER.equals(edgeName)) {
+                return getVerticalCenter();
+            } else if (BASELINE.equals(edgeName)) {
+                return getBaseline();
+            }
+            return null;
+        }
+
+        void cn1Reset() {
+            cn1Clear(x);
+            cn1Clear(y);
+            cn1Clear(width);
+            cn1Clear(height);
+            cn1Clear(east);
+            cn1Clear(south);
+            cn1Clear(horizontalCenter);
+            cn1Clear(verticalCenter);
+            cn1Clear(baseline);
+        }
+
+        private static void cn1Clear(Spring s) {
+            if (s != null) {
+                s.setValue(Spring.UNSET);
+            }
+        }
+    }
+
+    /// An edge of a component, looked up each time it is asked: the
+    /// constraint behind an edge may be replaced after another constraint
+    /// was tied to it.
+    private static final class EdgeSpring extends Spring {
+        private final String edgeName;
+        private final Component c;
+        private final SpringLayout layout;
+
+        EdgeSpring(String edgeName, Component c, SpringLayout layout) {
+            this.edgeName = edgeName;
+            this.c = c;
+            this.layout = layout;
+        }
+
+        private Spring target() {
+            return layout.getConstraints(c).getConstraint(edgeName);
+        }
+
+        @Override
+        public int getMinimumValue() {
+            return target().getMinimumValue();
+        }
+
+        @Override
+        public int getPreferredValue() {
+            return target().getPreferredValue();
+        }
+
+        @Override
+        public int getMaximumValue() {
+            return target().getMaximumValue();
+        }
+
+        @Override
+        public int getValue() {
+            return target().getValue();
+        }
+
+        @Override
+        public void setValue(int size) {
+            target().setValue(size);
+        }
+
+        @Override
+        boolean cn1IsCyclic(SpringLayout l) {
+            return l.cn1IsCyclic(target());
+        }
+
+        @Override
+        public String toString() {
+            return "SpringProxy for " + edgeName + " edge of " + c.getName() + ".";
+        }
+    }
+
+    private void resetCyclicStatuses() {
+        cyclicSprings = new ArrayList<Spring>();
+        acyclicSprings = new ArrayList<Spring>();
+    }
+
+    private static boolean containsIdentical(List<Spring> list, Spring s) {
+        for (int i = list.size() - 1; i >= 0; i--) {
+            if (list.get(i) == s) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void removeIdentical(List<Spring> list, Spring s) {
+        for (int i = list.size() - 1; i >= 0; i--) {
+            if (list.get(i) == s) {
+                list.remove(i);
+                return;
+            }
+        }
+    }
+
+    private void setParent(Container p) {
+        resetCyclicStatuses();
+        Constraints pc = getConstraints(p);
+        pc.setX(Spring.constant(0));
+        pc.setY(Spring.constant(0));
+        // The default width and height of a component ask the component
+        // for its sizes. For the container that would come straight back
+        // here, so they are replaced with springs free to take any value.
+        Spring width = pc.getWidth();
+        if (width instanceof Spring.SizeOf && ((Spring.SizeOf) width).c == p) {
+            pc.setWidth(Spring.constant(0, 0, Integer.MAX_VALUE));
+        }
+        Spring height = pc.getHeight();
+        if (height instanceof Spring.SizeOf && ((Spring.SizeOf) height).c == p) {
+            pc.setHeight(Spring.constant(0, 0, Integer.MAX_VALUE));
+        }
+    }
+
+    boolean cn1IsCyclic(Spring s) {
+        if (s == null) {
+            return false;
+        }
+        if (containsIdentical(cyclicSprings, s)) {
+            return true;
+        }
+        if (containsIdentical(acyclicSprings, s)) {
+            return false;
+        }
+        cyclicSprings.add(s);
+        boolean result = s.cn1IsCyclic(this);
+        if (!result) {
+            acyclicSprings.add(s);
+            removeIdentical(cyclicSprings, s);
+        } else {
+            System.err.println(s + " is cyclic. ");
+        }
+        return result;
+    }
+
+    private Spring abandonCycles(Spring s) {
+        return cn1IsCyclic(s) ? cyclicReference : s;
+    }
+
+    /// Has no effect: this layout does not use a string per component.
+    @Override
+    public void addLayoutComponent(String name, Component c) {
+    }
+
+    /// Removes the constraints associated with the component.
+    @Override
+    public void removeLayoutComponent(Component c) {
+        componentConstraints.remove(c);
+    }
+
+    private static Dimension addInsets(int width, int height, Container p) {
+        Insets i = p.getInsets();
+        return new Dimension(width + i.left + i.right, height + i.top + i.bottom);
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        setParent(parent);
+        Constraints pc = getConstraints(parent);
+        return addInsets(abandonCycles(pc.getWidth()).getMinimumValue(),
+                abandonCycles(pc.getHeight()).getMinimumValue(), parent);
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        setParent(parent);
+        Constraints pc = getConstraints(parent);
+        return addInsets(abandonCycles(pc.getWidth()).getPreferredValue(),
+                abandonCycles(pc.getHeight()).getPreferredValue(), parent);
+    }
+
+    @Override
+    public Dimension maximumLayoutSize(Container parent) {
+        setParent(parent);
+        Constraints pc = getConstraints(parent);
+        return addInsets(abandonCycles(pc.getWidth()).getMaximumValue(),
+                abandonCycles(pc.getHeight()).getMaximumValue(), parent);
+    }
+
+    /// Associates `constraints` with the component when it is a
+    /// [SpringLayout.Constraints]; anything else is ignored.
+    @Override
+    public void addLayoutComponent(Component component, Object constraints) {
+        if (constraints instanceof Constraints) {
+            putConstraints(component, (Constraints) constraints);
+        }
+    }
+
+    /// Returns 0.5f, centred.
+    @Override
+    public float getLayoutAlignmentX(Container p) {
+        return 0.5f;
+    }
+
+    /// Returns 0.5f, centred.
+    @Override
+    public float getLayoutAlignmentY(Container p) {
+        return 0.5f;
+    }
+
+    @Override
+    public void invalidateLayout(Container p) {
+    }
+
+    /// Ties edge `e1` of `c1` to edge `e2` of `c2` with a fixed distance
+    /// between them: `value(e1, c1) = value(e2, c2) + pad`.
+    public void putConstraint(String e1, Component c1, int pad, String e2, Component c2) {
+        putConstraint(e1, c1, Spring.constant(pad), e2, c2);
+    }
+
+    /// Ties edge `e1` of `c1` to edge `e2` of `c2` with the spring `s`
+    /// between them.
+    public void putConstraint(String e1, Component c1, Spring s, String e2, Component c2) {
+        putConstraint(e1, c1, Spring.sum(s, getConstraint(e2, c2)));
+    }
+
+    private void putConstraint(String e, Component c, Spring s) {
+        if (s != null) {
+            getConstraints(c).setConstraint(e, s);
+        }
+    }
+
+    // Completes an axis that has fewer than two constraints: the origin
+    // and the size the component asks for, leaving whatever was given
+    // the most recent.
+    private Constraints applyDefaults(Component c, Constraints given) {
+        Constraints constraints = given;
+        if (constraints == null) {
+            constraints = new Constraints();
+        }
+        if (constraints.c == null) {
+            constraints.c = c;
+        }
+        if (constraints.horizontalHistory.size() < 2) {
+            applyDefaults(constraints, WEST, Spring.constant(0), WIDTH, Spring.width(c),
+                    constraints.horizontalHistory);
+        }
+        if (constraints.verticalHistory.size() < 2) {
+            applyDefaults(constraints, NORTH, Spring.constant(0), HEIGHT, Spring.height(c),
+                    constraints.verticalHistory);
+        }
+        return constraints;
+    }
+
+    private static void applyDefaults(Constraints constraints, String name1, Spring spring1, String name2,
+            Spring spring2, List<String> history) {
+        if (history.isEmpty()) {
+            constraints.setConstraint(name1, spring1);
+            constraints.setConstraint(name2, spring2);
+        } else {
+            // Exactly one constraint is defined. The size is the default
+            // of choice; if it is the one defined, the origin is.
+            if (constraints.getConstraint(name2) == null) {
+                constraints.setConstraint(name2, spring2);
+            } else {
+                constraints.setConstraint(name1, spring1);
+            }
+            // Either way the given constraint stays the most recent.
+            if (history.size() == 2) {
+                String first = history.remove(0);
+                history.add(first);
+            }
+        }
+    }
+
+    private void putConstraints(Component component, Constraints constraints) {
+        componentConstraints.put(component, applyDefaults(component, constraints));
+    }
+
+    /// Returns the constraints of a component, creating them when it has
+    /// none. Changing them changes the layout.
+    public Constraints getConstraints(Component c) {
+        Constraints result = componentConstraints.get(c);
+        if (result == null) {
+            if (c instanceof JComponent) {
+                Object given = ((JComponent) c).getClientProperty(SpringLayout.class);
+                if (given instanceof Constraints) {
+                    return applyDefaults(c, (Constraints) given);
+                }
+            }
+            result = new Constraints();
+            putConstraints(c, result);
+        }
+        return result;
+    }
+
+    /// Returns a spring that follows the named edge of a component,
+    /// whatever constraint ends up behind that edge.
+    public Spring getConstraint(String edgeName, Component c) {
+        return new EdgeSpring(edgeName, c, this);
+    }
+
+    @Override
+    public void layoutContainer(Container parent) {
+        setParent(parent);
+
+        int n = parent.getComponentCount();
+        getConstraints(parent).cn1Reset();
+        for (int i = 0; i < n; i++) {
+            getConstraints(parent.getComponent(i)).cn1Reset();
+        }
+
+        Insets insets = parent.getInsets();
+        Constraints pc = getConstraints(parent);
+        abandonCycles(pc.getX()).setValue(0);
+        abandonCycles(pc.getY()).setValue(0);
+        abandonCycles(pc.getWidth()).setValue(parent.getWidth() - insets.left - insets.right);
+        abandonCycles(pc.getHeight()).setValue(parent.getHeight() - insets.top - insets.bottom);
+
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            Constraints cc = getConstraints(c);
+            int x = abandonCycles(cc.getX()).getValue();
+            int y = abandonCycles(cc.getY()).getValue();
+            int width = abandonCycles(cc.getWidth()).getValue();
+            int height = abandonCycles(cc.getHeight()).getValue();
+            c.setBounds(insets.left + x, insets.top + y, width, height);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingConstants.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingConstants.java
new file mode 100644
index 00000000000..b543a0b8471
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingConstants.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// Positions, orientations and directions shared by Swing components.
+public interface SwingConstants {
+
+    int CENTER = 0;
+
+    int TOP = 1;
+
+    int LEFT = 2;
+
+    int BOTTOM = 3;
+
+    int RIGHT = 4;
+
+    int NORTH = 1;
+
+    int NORTH_EAST = 2;
+
+    int EAST = 3;
+
+    int SOUTH_EAST = 4;
+
+    int SOUTH = 5;
+
+    int SOUTH_WEST = 6;
+
+    int WEST = 7;
+
+    int NORTH_WEST = 8;
+
+    int HORIZONTAL = 0;
+
+    int VERTICAL = 1;
+
+    int LEADING = 10;
+
+    int TRAILING = 11;
+
+    int NEXT = 12;
+
+    int PREVIOUS = 13;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingUtilities.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingUtilities.java
new file mode 100644
index 00000000000..48b0e90ae53
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingUtilities.java
@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.EventQueue;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import java.lang.reflect.InvocationTargetException;
+
+/// The Swing helpers for the event dispatch thread and the component
+/// tree.
+public class SwingUtilities implements SwingConstants {
+
+    private SwingUtilities() {
+    }
+
+    public static void invokeLater(Runnable doRun) {
+        EventQueue.invokeLater(doRun);
+    }
+
+    /// See `EventQueue.invokeAndWait`: on the event dispatch thread the
+    /// runnable simply runs.
+    public static void invokeAndWait(Runnable doRun) throws InterruptedException, InvocationTargetException {
+        EventQueue.invokeAndWait(doRun);
+    }
+
+    /// Runs the key bindings for a key event whose target is not a Swing
+    /// component: the bindings of its Swing ancestors, then those any
+    /// component of its window registered for the whole window.
+    public static boolean processKeyBindings(KeyEvent event) {
+        if (event == null || event.isConsumed()) {
+            return false;
+        }
+        Component c = event.getComponent();
+        if (c == null) {
+            return false;
+        }
+        return JComponent.cn1KeyBindings(c, event);
+    }
+
+    /// Runs `action` for a key binding. The action command is the
+    /// action's own, or else the character of the key.
+    public static boolean notifyAction(Action action, KeyStroke ks, KeyEvent event, Object sender, int modifiers) {
+        if (action == null || !action.isEnabled()) {
+            return false;
+        }
+        Object cmd = action.getValue(Action.ACTION_COMMAND_KEY);
+        String command = null;
+        if (cmd != null) {
+            command = cmd.toString();
+        } else if (event != null && event.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
+            command = String.valueOf(event.getKeyChar());
+        }
+        action.actionPerformed(new ActionEvent(sender, ActionEvent.ACTION_PERFORMED, command,
+                event == null ? 0 : event.getWhen(), modifiers));
+        return true;
+    }
+
+    public static Rectangle convertRectangle(Component source, Rectangle aRectangle, Component destination) {
+        Point p = convertPoint(source, aRectangle.x, aRectangle.y, destination);
+        return new Rectangle(p.x, p.y, aRectangle.width, aRectangle.height);
+    }
+
+    public static MouseEvent convertMouseEvent(Component source, MouseEvent sourceEvent, Component destination) {
+        Point p = convertPoint(source, sourceEvent.getX(), sourceEvent.getY(), destination);
+        Component newSource = destination != null ? destination : source;
+        return new MouseEvent(newSource, sourceEvent.getID(), sourceEvent.getWhen(),
+                sourceEvent.getModifiers() | sourceEvent.getModifiersEx(), p.x, p.y, sourceEvent.getClickCount(),
+                sourceEvent.isPopupTrigger(), sourceEvent.getButton());
+    }
+
+    public static Container getAncestorNamed(String name, Component comp) {
+        if (comp == null || name == null) {
+            return null;
+        }
+        Container parent = comp.getParent();
+        while (parent != null && !name.equals(parent.getName())) {
+            parent = parent.getParent();
+        }
+        return parent;
+    }
+
+    public static Container getUnwrappedParent(Component component) {
+        return component.getParent();
+    }
+
+    public static boolean isRectangleContainingRectangle(Rectangle a, Rectangle b) {
+        return b.x >= a.x && b.x + b.width <= a.x + a.width && b.y >= a.y && b.y + b.height <= a.y + a.height;
+    }
+
+    public static Rectangle getLocalBounds(Component aComponent) {
+        return new Rectangle(0, 0, aComponent.getWidth(), aComponent.getHeight());
+    }
+
+    public static Rectangle calculateInnerArea(JComponent c, Rectangle r) {
+        if (c == null) {
+            return null;
+        }
+        Rectangle rect = r == null ? new Rectangle() : r;
+        Insets in = c.getInsets();
+        rect.x = in.left;
+        rect.y = in.top;
+        rect.width = c.getWidth() - in.left - in.right;
+        rect.height = c.getHeight() - in.top - in.bottom;
+        return rect;
+    }
+
+    /// Places the icon and the text of a label or a button inside
+    /// `viewR`, storing where each goes in `iconR` and `textR`, and
+    /// returns the text to draw: the text itself, or a clipped copy that
+    /// ends in three dots when it is wider than the room it has.
+    public static String layoutCompoundLabel(FontMetrics fm, String text, Icon icon, int verticalAlignment,
+            int horizontalAlignment, int verticalTextPosition, int horizontalTextPosition, Rectangle viewR,
+            Rectangle iconR, Rectangle textR, int textIconGap) {
+        if (icon != null) {
+            iconR.width = icon.getIconWidth();
+            iconR.height = icon.getIconHeight();
+        } else {
+            iconR.width = 0;
+            iconR.height = 0;
+        }
+        boolean empty = text == null || text.length() == 0;
+        String out = text;
+        int gap = empty || icon == null ? 0 : textIconGap;
+        if (empty) {
+            textR.width = 0;
+            textR.height = 0;
+            out = "";
+        } else {
+            int avail = horizontalTextPosition == CENTER ? viewR.width : viewR.width - (iconR.width + gap);
+            textR.width = fm.stringWidth(text);
+            textR.height = fm.getHeight();
+            if (textR.width > avail) {
+                out = clip(fm, text, avail);
+                textR.width = fm.stringWidth(out);
+            }
+        }
+        if (verticalTextPosition == TOP) {
+            textR.y = horizontalTextPosition != CENTER ? 0 : -(textR.height + gap);
+        } else if (verticalTextPosition == CENTER) {
+            textR.y = iconR.height / 2 - textR.height / 2;
+        } else {
+            textR.y = horizontalTextPosition != CENTER ? iconR.height - textR.height : iconR.height + gap;
+        }
+        if (horizontalTextPosition == LEFT || horizontalTextPosition == LEADING) {
+            textR.x = -(textR.width + gap);
+        } else if (horizontalTextPosition == CENTER) {
+            textR.x = iconR.width / 2 - textR.width / 2;
+        } else {
+            textR.x = iconR.width + gap;
+        }
+        int labelX = Math.min(iconR.x, textR.x);
+        int labelW = Math.max(iconR.x + iconR.width, textR.x + textR.width) - labelX;
+        int labelY = Math.min(iconR.y, textR.y);
+        int labelH = Math.max(iconR.y + iconR.height, textR.y + textR.height) - labelY;
+        int dx;
+        int dy;
+        if (verticalAlignment == TOP) {
+            dy = viewR.y - labelY;
+        } else if (verticalAlignment == CENTER) {
+            dy = viewR.y + viewR.height / 2 - (labelY + labelH / 2);
+        } else {
+            dy = viewR.y + viewR.height - (labelY + labelH);
+        }
+        if (horizontalAlignment == LEFT || horizontalAlignment == LEADING) {
+            dx = viewR.x - labelX;
+        } else if (horizontalAlignment == RIGHT || horizontalAlignment == TRAILING) {
+            dx = viewR.x + viewR.width - (labelX + labelW);
+        } else {
+            dx = viewR.x + viewR.width / 2 - (labelX + labelW / 2);
+        }
+        textR.x += dx;
+        textR.y += dy;
+        iconR.x += dx;
+        iconR.y += dy;
+        return out;
+    }
+
+    public static String layoutCompoundLabel(JComponent c, FontMetrics fm, String text, Icon icon,
+            int verticalAlignment, int horizontalAlignment, int verticalTextPosition, int horizontalTextPosition,
+            Rectangle viewR, Rectangle iconR, Rectangle textR, int textIconGap) {
+        return layoutCompoundLabel(fm, text, icon, verticalAlignment, horizontalAlignment, verticalTextPosition,
+                horizontalTextPosition, viewR, iconR, textR, textIconGap);
+    }
+
+    private static String clip(FontMetrics fm, String text, int avail) {
+        String dots = "...";
+        int room = avail - fm.stringWidth(dots);
+        if (room <= 0) {
+            return dots;
+        }
+        int n = 0;
+        int w = 0;
+        while (n < text.length()) {
+            int cw = fm.charWidth(text.charAt(n));
+            if (w + cw > room) {
+                break;
+            }
+            w += cw;
+            n++;
+        }
+        return text.substring(0, n) + dots;
+    }
+
+    public static boolean isEventDispatchThread() {
+        return EventQueue.isDispatchThread();
+    }
+
+    public static Window getWindowAncestor(Component c) {
+        for (Container p = c.getParent(); p != null; p = p.getParent()) {
+            if (p instanceof Window) {
+                return (Window) p;
+            }
+        }
+        return null;
+    }
+
+    public static Window windowForComponent(Component c) {
+        return getWindowAncestor(c);
+    }
+
+    public static Component getRoot(Component c) {
+        for (Component p = c; p != null; p = p.getParent()) {
+            if (p instanceof Window) {
+                return p;
+            }
+        }
+        return null;
+    }
+
+    public static JRootPane getRootPane(Component c) {
+        for (Component p = c; p != null; p = p.getParent()) {
+            if (p instanceof JRootPane) {
+                return (JRootPane) p;
+            }
+            if (p instanceof RootPaneContainer) {
+                return ((RootPaneContainer) p).getRootPane();
+            }
+        }
+        return null;
+    }
+
+    public static Container getAncestorOfClass(Class<?> c, Component comp) {
+        if (comp == null || c == null) {
+            return null;
+        }
+        Container parent = comp.getParent();
+        while (parent != null && !c.isInstance(parent)) {
+            parent = parent.getParent();
+        }
+        return parent;
+    }
+
+    public static boolean isDescendingFrom(Component a, Component b) {
+        if (a == b) {
+            return true;
+        }
+        for (Container p = a.getParent(); p != null; p = p.getParent()) {
+            if (p == b) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static Component getDeepestComponentAt(Component parent, int x, int y) {
+        if (!parent.contains(x, y)) {
+            return null;
+        }
+        if (parent instanceof Container) {
+            return ((Container) parent).findComponentAt(x, y);
+        }
+        return parent;
+    }
+
+    public static void convertPointToScreen(Point p, Component c) {
+        Point s = c.getLocationOnScreen();
+        p.x += s.x;
+        p.y += s.y;
+    }
+
+    public static void convertPointFromScreen(Point p, Component c) {
+        Point s = c.getLocationOnScreen();
+        p.x -= s.x;
+        p.y -= s.y;
+    }
+
+    public static Point convertPoint(Component source, int x, int y, Component destination) {
+        Point p = new Point(x, y);
+        if (source != null) {
+            convertPointToScreen(p, source);
+        }
+        if (destination != null) {
+            convertPointFromScreen(p, destination);
+        }
+        return p;
+    }
+
+    public static Point convertPoint(Component source, Point aPoint, Component destination) {
+        return convertPoint(source, aPoint.x, aPoint.y, destination);
+    }
+
+    public static boolean isLeftMouseButton(MouseEvent anEvent) {
+        return anEvent.getButton() == MouseEvent.BUTTON1;
+    }
+
+    public static boolean isMiddleMouseButton(MouseEvent anEvent) {
+        return anEvent.getButton() == MouseEvent.BUTTON2;
+    }
+
+    public static boolean isRightMouseButton(MouseEvent anEvent) {
+        return anEvent.getButton() == MouseEvent.BUTTON3;
+    }
+
+    public static int computeStringWidth(FontMetrics fm, String str) {
+        return str == null ? 0 : fm.stringWidth(str);
+    }
+
+    /// Restyles `c` and everything under it with the current look and
+    /// feel's palette: there are no UI delegates to replace.
+    public static void updateComponentTreeUI(Component c) {
+        com.codename1.desktopcompat.rt.LafTheme.restyle(c);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingWorker.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingWorker.java
new file mode 100644
index 00000000000..96811b3fb10
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/SwingWorker.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.EventQueue;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+import com.codename1.ui.Display;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/// Runs a long task off the event dispatch thread and reports back on it.
+///
+/// `execute()` starts a thread that runs `doInBackground()`. What that
+/// publishes reaches `process` on the event dispatch thread, with every
+/// chunk published before that thread got to it in one list; `done()` and
+/// the `state` and `progress` property changes are delivered there too.
+/// `get()` called on the event dispatch thread before the task ended keeps
+/// that thread dispatching while it waits; on any other thread it waits by
+/// polling.
+///
+/// Not supported: the class is a `Future` and a `Runnable` but not a
+/// `RunnableFuture`; each worker has a thread of its own instead of the ten
+/// thread pool of the desktop; every `progress` change is delivered, where
+/// the desktop may merge several into one event.
+public abstract class SwingWorker<T, V> implements Future<T>, Runnable {
+
+    private static final int RUNNING = 0;
+    private static final int VALUE = 1;
+    private static final int FAILED = 2;
+    private static final int CANCELLED = 3;
+    private static final int POLL_MILLIS = 5;
+
+    private final AtomicInteger outcome = new AtomicInteger(RUNNING);
+    private final AtomicReference<StateValue> state = new AtomicReference<StateValue>(StateValue.PENDING);
+    private final AtomicInteger progress = new AtomicInteger();
+    private final AtomicBoolean executed = new AtomicBoolean();
+    private final AtomicBoolean ran = new AtomicBoolean();
+    private final AtomicReference<T> result = new AtomicReference<T>();
+    private final AtomicReference<Throwable> failure = new AtomicReference<Throwable>();
+    private final AtomicReference<Thread> runner = new AtomicReference<Thread>();
+    private final AtomicReference<ArrayList<V>> pending = new AtomicReference<ArrayList<V>>();
+    private final PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
+
+    /// The stages of a worker's life, the values of its `state` property.
+    public enum StateValue {
+        PENDING,
+        STARTED,
+        DONE
+    }
+
+    public SwingWorker() {
+    }
+
+    protected abstract T doInBackground() throws Exception;
+
+    /// Runs the task on the calling thread, unless it ran or was cancelled
+    /// already. `execute()` calls this on the worker's thread.
+    @Override
+    public final void run() {
+        if (!ran.compareAndSet(false, true) || outcome.get() != RUNNING) {
+            return;
+        }
+        runner.set(Thread.currentThread());
+        if (outcome.get() != RUNNING) {
+            // Cancelled between the check above and the line before this: the
+            // cancel saw no thread to interrupt, so it is this thread that
+            // must notice. Nothing has started.
+            runner.set(null);
+            return;
+        }
+        if (state.compareAndSet(StateValue.PENDING, StateValue.STARTED)) {
+            firePropertyChange("state", StateValue.PENDING, StateValue.STARTED);
+        }
+        try {
+            result.set(doInBackground());
+            complete(VALUE);
+        } catch (Throwable t) {
+            failure.set(t);
+            complete(FAILED);
+        } finally {
+            runner.set(null);
+        }
+    }
+
+    /// Hands chunks to `process`, which runs later on the event dispatch
+    /// thread with everything published until then.
+    @SafeVarargs
+    protected final void publish(V... chunks) {
+        if (chunks == null || chunks.length == 0) {
+            return;
+        }
+        while (true) {
+            ArrayList<V> old = pending.get();
+            ArrayList<V> grown = old == null ? new ArrayList<V>() : new ArrayList<V>(old);
+            for (int i = 0; i < chunks.length; i++) {
+                grown.add(chunks[i]);
+            }
+            if (pending.compareAndSet(old, grown)) {
+                if (old == null) {
+                    later(new Flush<V>(this));
+                }
+                return;
+            }
+        }
+    }
+
+    protected void process(List<V> chunks) {
+    }
+
+    protected void done() {
+    }
+
+    protected final void setProgress(int progress) {
+        if (progress < 0 || progress > 100) {
+            throw new IllegalArgumentException("the value should be from 0 to 100");
+        }
+        int old = this.progress.getAndSet(progress);
+        if (old != progress) {
+            firePropertyChange("progress", Integer.valueOf(old), Integer.valueOf(progress));
+        }
+    }
+
+    public final int getProgress() {
+        return progress.get();
+    }
+
+    /// Starts the task on a thread of its own. A second call does nothing.
+    public final void execute() {
+        if (executed.compareAndSet(false, true)) {
+            new Thread(this, "SwingWorker").start();
+        }
+    }
+
+    /// Cancels the task. A task that did not start never runs; one that is
+    /// running has its thread interrupted when `mayInterruptIfRunning`, and
+    /// its result is dropped either way.
+    @Override
+    public final boolean cancel(boolean mayInterruptIfRunning) {
+        if (!outcome.compareAndSet(RUNNING, CANCELLED)) {
+            return false;
+        }
+        if (mayInterruptIfRunning) {
+            Thread t = runner.get();
+            if (t != null) {
+                t.interrupt();
+            }
+        }
+        finished();
+        return true;
+    }
+
+    @Override
+    public final boolean isCancelled() {
+        return outcome.get() == CANCELLED;
+    }
+
+    @Override
+    public final boolean isDone() {
+        return outcome.get() != RUNNING;
+    }
+
+    @Override
+    public final T get() throws InterruptedException, ExecutionException {
+        await(-1);
+        return report();
+    }
+
+    @Override
+    public final T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
+            TimeoutException {
+        long millis = unit.toMillis(timeout);
+        await(millis < 0 ? 0 : millis);
+        if (outcome.get() == RUNNING) {
+            throw new TimeoutException();
+        }
+        return report();
+    }
+
+    public final void addPropertyChangeListener(PropertyChangeListener listener) {
+        propertyChangeSupport.addPropertyChangeListener(listener);
+    }
+
+    public final void removePropertyChangeListener(PropertyChangeListener listener) {
+        propertyChangeSupport.removePropertyChangeListener(listener);
+    }
+
+    /// Notifies the listeners on the event dispatch thread: at once when
+    /// called there, else after the events already queued.
+    public final void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        if (EventQueue.isDispatchThread()) {
+            propertyChangeSupport.firePropertyChange(propertyName, oldValue, newValue);
+        } else {
+            later(new Fire(propertyChangeSupport,
+                    new PropertyChangeEvent(this, propertyName, oldValue, newValue)));
+        }
+    }
+
+    public final PropertyChangeSupport getPropertyChangeSupport() {
+        return propertyChangeSupport;
+    }
+
+    public final StateValue getState() {
+        if (isDone()) {
+            return StateValue.DONE;
+        }
+        return state.get();
+    }
+
+    private void complete(int how) {
+        if (outcome.compareAndSet(RUNNING, how)) {
+            finished();
+        }
+    }
+
+    /// The task ended one way or another: the state becomes `DONE` and
+    /// `done()` runs on the event dispatch thread.
+    private void finished() {
+        StateValue old = state.getAndSet(StateValue.DONE);
+        if (old != StateValue.DONE) {
+            firePropertyChange("state", old, StateValue.DONE);
+        }
+        Runnable r = new Done(this);
+        if (EventQueue.isDispatchThread()) {
+            r.run();
+        } else {
+            later(r);
+        }
+    }
+
+    private static void later(Runnable r) {
+        EventQueue.invokeLater(r);
+    }
+
+    private T report() throws ExecutionException {
+        int how = outcome.get();
+        if (how == CANCELLED) {
+            throw new CancellationException();
+        }
+        if (how == FAILED) {
+            throw new ExecutionException(failure.get());
+        }
+        return result.get();
+    }
+
+    /// Waits until the task ended, or for `millis` when that is not
+    /// negative.
+    private void await(long millis) throws InterruptedException {
+        if (outcome.get() != RUNNING) {
+            return;
+        }
+        long deadline = millis < 0 ? -1 : System.currentTimeMillis() + millis;
+        if (Display.isInitialized() && Display.getInstance().isEdt()) {
+            Display.getInstance().invokeAndBlock(new Waiter(outcome, deadline));
+            return;
+        }
+        while (outcome.get() == RUNNING && (deadline < 0 || System.currentTimeMillis() < deadline)) {
+            Thread.sleep(POLL_MILLIS);
+        }
+    }
+
+    void cn1Flush() {
+        ArrayList<V> chunks = pending.getAndSet(null);
+        if (chunks != null && !chunks.isEmpty()) {
+            process(chunks);
+        }
+    }
+
+    void cn1Done() {
+        done();
+    }
+
+    /// Polls for the end of the task off the event dispatch thread while
+    /// that thread goes on dispatching.
+    private static final class Waiter implements Runnable {
+        private final AtomicInteger outcome;
+        private final long deadline;
+
+        Waiter(AtomicInteger outcome, long deadline) {
+            this.outcome = outcome;
+            this.deadline = deadline;
+        }
+
+        @Override
+        public void run() {
+            while (outcome.get() == RUNNING && (deadline < 0 || System.currentTimeMillis() < deadline)) {
+                try {
+                    Thread.sleep(POLL_MILLIS);
+                } catch (InterruptedException e) {
+                    return;
+                }
+            }
+        }
+    }
+
+    private static final class Flush<V> implements Runnable {
+        private final SwingWorker<?, V> worker;
+
+        Flush(SwingWorker<?, V> worker) {
+            this.worker = worker;
+        }
+
+        @Override
+        public void run() {
+            worker.cn1Flush();
+        }
+    }
+
+    private static final class Done implements Runnable {
+        private final SwingWorker<?, ?> worker;
+
+        Done(SwingWorker<?, ?> worker) {
+            this.worker = worker;
+        }
+
+        @Override
+        public void run() {
+            worker.cn1Done();
+        }
+    }
+
+    private static final class Fire implements Runnable {
+        private final PropertyChangeSupport support;
+        private final PropertyChangeEvent event;
+
+        Fire(PropertyChangeSupport support, PropertyChangeEvent event) {
+            this.support = support;
+            this.event = event;
+        }
+
+        @Override
+        public void run() {
+            support.firePropertyChange(event);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Timer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Timer.java
new file mode 100644
index 00000000000..c4aa53fa497
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/Timer.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.EventQueue;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.TimerTask;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/// Fires action events on the event dispatch thread after a delay, once
+/// or repeatedly. Start and stop it from the event dispatch thread.
+public class Timer {
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private int delay;
+    private int initialDelay;
+    private boolean repeats = true;
+    private boolean coalesce = true;
+    private String actionCommand;
+    private java.util.Timer timer;
+    private int run;
+    // The running timer's schedule, kept so a new delay can be applied
+    // without moving the firing that is already due.
+    private long firstDue;
+    private int period;
+    private Hop hop;
+
+    public Timer(int delay, ActionListener listener) {
+        this.delay = delay;
+        this.initialDelay = delay;
+        if (listener != null) {
+            addActionListener(listener);
+        }
+    }
+
+    public void addActionListener(ActionListener listener) {
+        listenerList.add(ActionListener.class, listener);
+    }
+
+    public void removeActionListener(ActionListener listener) {
+        listenerList.remove(ActionListener.class, listener);
+    }
+
+    public ActionListener[] getActionListeners() {
+        return listenerList.getListeners(ActionListener.class);
+    }
+
+    protected void fireActionPerformed(ActionEvent e) {
+        ActionListener[] ls = getActionListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].actionPerformed(e);
+        }
+    }
+
+    public int getDelay() {
+        return delay;
+    }
+
+    /// On a running timer, as in Swing, the firing already due keeps its
+    /// time and the new delay applies from there on.
+    public void setDelay(int delay) {
+        if (delay < 0) {
+            throw new IllegalArgumentException("Invalid delay: " + delay);
+        }
+        this.delay = delay;
+        if (timer != null && Math.max(1, delay) != period) {
+            long now = System.currentTimeMillis();
+            long next = now < firstDue ? firstDue - now : period - (now - firstDue) % period;
+            timer.cancel();
+            schedule(hop.tick, hop.pending, next);
+        }
+    }
+
+    public int getInitialDelay() {
+        return initialDelay;
+    }
+
+    public void setInitialDelay(int initialDelay) {
+        if (initialDelay < 0) {
+            throw new IllegalArgumentException("Invalid initial delay: " + initialDelay);
+        }
+        this.initialDelay = initialDelay;
+    }
+
+    public boolean isRepeats() {
+        return repeats;
+    }
+
+    public void setRepeats(boolean flag) {
+        repeats = flag;
+    }
+
+    public boolean isCoalesce() {
+        return coalesce;
+    }
+
+    public void setCoalesce(boolean flag) {
+        coalesce = flag;
+    }
+
+    public String getActionCommand() {
+        return actionCommand;
+    }
+
+    public void setActionCommand(String command) {
+        actionCommand = command;
+    }
+
+    public boolean isRunning() {
+        return timer != null;
+    }
+
+    public void start() {
+        if (timer != null) {
+            return;
+        }
+        run++;
+        final int mine = run;
+        final AtomicInteger pending = new AtomicInteger();
+        final Runnable tick = new Runnable() {
+            @Override
+            public void run() {
+                tick(mine, pending.getAndSet(0));
+            }
+        };
+        schedule(tick, pending, initialDelay);
+    }
+
+    /// Always periodic: whether the timer repeats is asked at each firing,
+    /// so setRepeats(true) on a running one-shot timer takes effect, as it
+    /// does in Swing. A timer that does not repeat stops itself at its
+    /// first tick. The ticket stays the same across a reschedule, so ticks
+    /// already queued by the previous schedule still count.
+    private void schedule(Runnable tick, AtomicInteger pending, long initial) {
+        period = Math.max(1, delay);
+        firstDue = System.currentTimeMillis() + initial;
+        hop = new Hop(tick, pending);
+        timer = new java.util.Timer();
+        timer.schedule(hop, initial, period);
+    }
+
+    /// Runs on the event dispatch thread; a tick queued before the timer
+    /// was stopped or restarted is dropped. `due` is how many periods
+    /// elapsed since the last one ran: a busy event dispatch thread gets
+    /// one event for all of them unless coalescing is off.
+    private void tick(int ticket, int due) {
+        int fire = coalesce ? 1 : due;
+        for (int i = 0; i < fire; i++) {
+            if (timer == null || ticket != run) {
+                return;
+            }
+            if (!repeats) {
+                stop();
+            }
+            fireActionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, actionCommand,
+                    System.currentTimeMillis(), 0));
+        }
+    }
+
+    public void stop() {
+        if (timer != null) {
+            timer.cancel();
+            timer = null;
+            hop = null;
+        }
+    }
+
+    public void restart() {
+        stop();
+        start();
+    }
+
+    /// Carries a tick from the timer's thread to the event dispatch thread.
+    /// It counts the periods that elapsed and queues one runnable for all
+    /// of those the event dispatch thread has not got to yet, so a slow
+    /// listener cannot build a backlog. The count is the only state the
+    /// two threads share.
+    private static final class Hop extends TimerTask {
+        private final Runnable tick;
+        private final AtomicInteger pending;
+
+        Hop(Runnable tick, AtomicInteger pending) {
+            this.tick = tick;
+            this.pending = pending;
+        }
+
+        @Override
+        public void run() {
+            if (pending.getAndIncrement() == 0) {
+                EventQueue.invokeLater(tick);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ToolTipManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ToolTipManager.java
new file mode 100644
index 00000000000..77f2ca826e6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/ToolTipManager.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.event.MouseMotionListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Window;
+
+/// The one switch for every tool tip of the application.
+///
+/// A tool tip is shown by the Codename One widget behind a component, with
+/// the delays of the Codename One tool tip manager. Disabling here takes
+/// the tips off the widgets and enabling puts them back; the delays are
+/// kept and answered and do not change when a tip appears.
+public class ToolTipManager {
+
+    private static final ToolTipManager SHARED = new ToolTipManager();
+
+    private boolean enabled = true;
+    private int initialDelay = 750;
+    private int dismissDelay = 4000;
+    private int reshowDelay = 500;
+
+    ToolTipManager() {
+    }
+
+    public static ToolTipManager sharedInstance() {
+        return SHARED;
+    }
+
+    public void setEnabled(boolean flag) {
+        if (enabled == flag) {
+            return;
+        }
+        enabled = flag;
+        Window[] all = Window.getWindows();
+        for (int i = 0; i < all.length; i++) {
+            apply(all[i]);
+        }
+    }
+
+    private static void apply(Component c) {
+        if (c instanceof JComponent) {
+            ((JComponent) c).cn1ApplyToolTip();
+        }
+        if (c instanceof Container) {
+            Container p = (Container) c;
+            for (int i = 0; i < p.getComponentCount(); i++) {
+                apply(p.getComponent(i));
+            }
+        }
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setInitialDelay(int milliseconds) {
+        initialDelay = milliseconds;
+    }
+
+    public int getInitialDelay() {
+        return initialDelay;
+    }
+
+    public void setDismissDelay(int milliseconds) {
+        dismissDelay = milliseconds;
+    }
+
+    public int getDismissDelay() {
+        return dismissDelay;
+    }
+
+    public void setReshowDelay(int milliseconds) {
+        reshowDelay = milliseconds;
+    }
+
+    public int getReshowDelay() {
+        return reshowDelay;
+    }
+
+    private final Tips tips = new Tips();
+
+    /// Makes `component` show a tool tip: from here on the pointer
+    /// entering it or moving over it asks its
+    /// `getToolTipText(MouseEvent)` for the text at that place. As in
+    /// Swing this is done with a mouse listener, so the component gets
+    /// the mouse events over it from then on.
+    public void registerComponent(JComponent component) {
+        component.removeMouseListener(tips);
+        component.addMouseListener(tips);
+        component.removeMouseMotionListener(tips);
+        component.addMouseMotionListener(tips);
+        component.cn1ApplyToolTip();
+    }
+
+    public void unregisterComponent(JComponent component) {
+        component.removeMouseListener(tips);
+        component.removeMouseMotionListener(tips);
+        component.cn1ApplyToolTip();
+    }
+
+    /// Asks a component for the tool tip at the pointer as it moves.
+    private static final class Tips extends MouseAdapter {
+
+        private static void ask(MouseEvent e) {
+            Object src = e.getSource();
+            if (src instanceof JComponent) {
+                ((JComponent) src).cn1ToolTipAt(e);
+            }
+        }
+
+        @Override
+        public void mouseEntered(MouseEvent e) {
+            ask(e);
+        }
+
+        @Override
+        public void mouseMoved(MouseEvent e) {
+            ask(e);
+        }
+
+        @Override
+        public void mouseDragged(MouseEvent e) {
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/TransferHandler.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/TransferHandler.java
new file mode 100644
index 00000000000..b446e1ff857
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/TransferHandler.java
@@ -0,0 +1,501 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Toolkit;
+import com.codename1.desktopcompat.java.awt.datatransfer.Clipboard;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import com.codename1.desktopcompat.java.awt.dnd.DnDConstants;
+import com.codename1.desktopcompat.java.awt.dnd.DropTarget;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetDragEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetDropEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetListener;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.plaf.UIResource;
+import com.codename1.desktopcompat.rt.Dnd;
+
+/// Moves data out of a component and into one: by drag and drop, and by
+/// cut, copy and paste.
+///
+/// A subclass says what it exports ([#getSourceActions],
+/// [#createTransferable], [#exportDone]) and what it takes
+/// ([#canImport(TransferSupport)], [#importData(TransferSupport)]).
+/// Installing one on a component with `JComponent.setTransferHandler`
+/// makes the component a drop target; a `JTable` with `setDragEnabled`
+/// begins a drag of its handler's data when a selected row is dragged.
+///
+/// A drag begun this way stays inside the application: it is followed by
+/// the layer and never handed to the platform, so it cannot be dropped on
+/// another application. Drags from another application do arrive, see
+/// `java.awt.dnd.DropTarget`.
+///
+/// The constructor that names a bean property is not here: it reads and
+/// writes the property by reflection, which a device does not have.
+public class TransferHandler {
+
+    public static final int NONE = 0;
+
+    public static final int COPY = 1;
+
+    public static final int MOVE = 2;
+
+    public static final int COPY_OR_MOVE = 3;
+
+    public static final int LINK = 1 << 30;
+
+    private static final Action CUT = new TransferAction("cut");
+    private static final Action COPY_ACTION = new TransferAction("copy");
+    private static final Action PASTE = new TransferAction("paste");
+
+    private Image dragImage;
+    private Point dragImageOffset;
+
+    protected TransferHandler() {
+    }
+
+    /// An action that cuts from the component that is the source of its
+    /// event to the system clipboard.
+    public static Action getCutAction() {
+        return CUT;
+    }
+
+    public static Action getCopyAction() {
+        return COPY_ACTION;
+    }
+
+    /// An action that hands the contents of the system clipboard to the
+    /// handler of the component that is the source of its event.
+    public static Action getPasteAction() {
+        return PASTE;
+    }
+
+    /// Records an image for the drag. The layer draws none: where a drop
+    /// would go is shown by the target.
+    public void setDragImage(Image img) {
+        dragImage = img;
+    }
+
+    public Image getDragImage() {
+        return dragImage;
+    }
+
+    public void setDragImageOffset(Point p) {
+        dragImageOffset = new Point(p);
+    }
+
+    public Point getDragImageOffset() {
+        return dragImageOffset == null ? new Point(0, 0) : new Point(dragImageOffset);
+    }
+
+    /// Begins a drag of the data of `comp`. `e` is the event that began
+    /// it, which has to be a mouse event, and `action` one of [#COPY],
+    /// [#MOVE] and [#LINK] that [#getSourceActions] allows; otherwise no
+    /// drag begins and [#exportDone] is told so.
+    public void exportAsDrag(JComponent comp, InputEvent e, int action) {
+        final JComponent c = comp;
+        int srcActions = getSourceActions(comp);
+        int a = action;
+        if (!(e instanceof MouseEvent) || !(a == COPY || a == MOVE || a == LINK) || (srcActions & a) == 0) {
+            a = NONE;
+        }
+        if (a == NONE) {
+            exportDone(comp, null, NONE);
+            return;
+        }
+        final Transferable t = createTransferable(comp);
+        if (t == null) {
+            exportDone(comp, null, NONE);
+            return;
+        }
+        Dnd.begin(t, srcActions, new Dnd.Source() {
+            @Override
+            public void done(int result) {
+                exportDone(c, t, result);
+            }
+        });
+    }
+
+    /// Puts the data of `comp` on `clip`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalStateException`: if the clipboard cannot be written
+    public void exportToClipboard(JComponent comp, Clipboard clip, int action) throws IllegalStateException {
+        if ((action == COPY || action == MOVE) && (getSourceActions(comp) & action) != 0) {
+            Transferable t = createTransferable(comp);
+            if (t != null) {
+                try {
+                    clip.setContents(t, null);
+                } catch (IllegalStateException ise) {
+                    exportDone(comp, t, NONE);
+                    throw ise;
+                }
+                exportDone(comp, t, action);
+                return;
+            }
+        }
+        exportDone(comp, null, NONE);
+    }
+
+    /// Takes the data of a drop or a paste. As it comes it hands the
+    /// component and the data to [#importData(JComponent, Transferable)].
+    public boolean importData(TransferSupport support) {
+        Component c = support.getComponent();
+        return c instanceof JComponent && importData((JComponent) c, support.getTransferable());
+    }
+
+    /// Takes data into `comp`; as it comes, takes nothing.
+    public boolean importData(JComponent comp, Transferable t) {
+        return false;
+    }
+
+    /// Whether the data of a drop or a paste would be taken. Asked again
+    /// and again while a drag is over the component.
+    public boolean canImport(TransferSupport support) {
+        Component c = support.getComponent();
+        return c instanceof JComponent && canImport((JComponent) c, support.getDataFlavors());
+    }
+
+    public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
+        return false;
+    }
+
+    /// The actions a drag out of `c` can ask for; as it comes, none.
+    public int getSourceActions(JComponent c) {
+        return NONE;
+    }
+
+    public Icon getVisualRepresentation(Transferable t) {
+        return null;
+    }
+
+    /// The data to export from `c`; `null`, as it comes, exports nothing.
+    protected Transferable createTransferable(JComponent c) {
+        return null;
+    }
+
+    /// The export is over. `action` is what was done with the data,
+    /// [#NONE] when nothing was; a source that moved its data removes it
+    /// here.
+    protected void exportDone(JComponent source, Transferable data, int action) {
+    }
+
+    /// The drop target a component has while it has a handler and no
+    /// target of the application's own. Not Swing API.
+    static DropTarget cn1DropTarget(JComponent c) {
+        return new SwingDropTarget(c);
+    }
+
+    /// Where on a component a drop would go.
+    public static class DropLocation {
+
+        private final Point dropPoint;
+
+        protected DropLocation(Point dropPoint) {
+            if (dropPoint == null) {
+                throw new IllegalArgumentException("Point cannot be null");
+            }
+            this.dropPoint = new Point(dropPoint);
+        }
+
+        public final Point getDropPoint() {
+            return new Point(dropPoint);
+        }
+
+        @Override
+        public String toString() {
+            return getClass().getName() + "[dropPoint=" + dropPoint + "]";
+        }
+    }
+
+    /// What a handler is asked about: a drop, or a paste.
+    public static final class TransferSupport {
+
+        private final boolean isDrop;
+        private Component component;
+        private Transferable transferable;
+        private Point point;
+        private int userAction;
+        private int sourceActions;
+        private boolean showDropLocationIsSet;
+        private boolean showDropLocation;
+        private int dropAction = -1;
+        private DropLocation dropLocation;
+
+        /// A transfer that is not a drop: a paste of `transferable` into
+        /// `component`.
+        public TransferSupport(Component component, Transferable transferable) {
+            if (component == null) {
+                throw new NullPointerException("component is null");
+            }
+            if (transferable == null) {
+                throw new NullPointerException("transferable is null");
+            }
+            isDrop = false;
+            this.component = component;
+            this.transferable = transferable;
+        }
+
+        TransferSupport() {
+            isDrop = true;
+        }
+
+        void drag(Component c, DropTargetDragEvent e) {
+            set(c, e.getLocation(), e.getDropAction(), e.getSourceActions(), e.getTransferable());
+        }
+
+        void drop(Component c, DropTargetDropEvent e) {
+            set(c, e.getLocation(), e.getDropAction(), e.getSourceActions(), e.getTransferable());
+        }
+
+        private void set(Component c, Point p, int user, int source, Transferable t) {
+            component = c;
+            point = p;
+            userAction = user;
+            sourceActions = source;
+            transferable = t;
+            dropLocation = null;
+            dropAction = -1;
+            showDropLocationIsSet = false;
+        }
+
+        boolean showLocation(boolean otherwise) {
+            return showDropLocationIsSet ? showDropLocation : otherwise;
+        }
+
+        public boolean isDrop() {
+            return isDrop;
+        }
+
+        public Component getComponent() {
+            return component;
+        }
+
+        private void assureIsDrop() {
+            if (!isDrop) {
+                throw new IllegalStateException("Not a drop");
+            }
+        }
+
+        /// Where the drop would go, as the component sees it: a
+        /// `JTable.DropLocation` for a table.
+        ///
+        /// #### Throws
+        ///
+        /// - `IllegalStateException`: if this is not a drop
+        public DropLocation getDropLocation() {
+            assureIsDrop();
+            if (dropLocation == null) {
+                if (component instanceof JComponent) {
+                    dropLocation = ((JComponent) component).dropLocationForPoint(point);
+                }
+                if (dropLocation == null) {
+                    dropLocation = new DropLocation(point);
+                }
+            }
+            return dropLocation;
+        }
+
+        /// Whether the component shows where the drop would go, said from
+        /// `canImport`; unsaid, it shows it when the drop would be taken.
+        public void setShowDropLocation(boolean showDropLocation) {
+            assureIsDrop();
+            this.showDropLocation = showDropLocation;
+            showDropLocationIsSet = true;
+        }
+
+        /// Chooses the action of the drop, one the source allows.
+        ///
+        /// #### Throws
+        ///
+        /// - `IllegalArgumentException`: if the source does not allow it
+        public void setDropAction(int dropAction) {
+            assureIsDrop();
+            int action = dropAction & getSourceDropActions();
+            if (!(action == COPY || action == MOVE || action == LINK)) {
+                throw new IllegalArgumentException("unsupported drop action: " + dropAction);
+            }
+            this.dropAction = dropAction;
+        }
+
+        public int getDropAction() {
+            return dropAction == -1 ? getUserDropAction() : dropAction;
+        }
+
+        public int getUserDropAction() {
+            assureIsDrop();
+            return userAction;
+        }
+
+        public int getSourceDropActions() {
+            assureIsDrop();
+            return sourceActions;
+        }
+
+        public DataFlavor[] getDataFlavors() {
+            return transferable == null ? new DataFlavor[0] : transferable.getTransferDataFlavors();
+        }
+
+        public boolean isDataFlavorSupported(DataFlavor df) {
+            return transferable != null && transferable.isDataFlavorSupported(df);
+        }
+
+        public Transferable getTransferable() {
+            return transferable;
+        }
+    }
+
+    /// The target that asks the component's handler. It is a
+    /// `UIResource`, which is how setting another handler knows it may
+    /// replace it and leaves a target of the application's alone.
+    private static final class SwingDropTarget extends DropTarget implements UIResource {
+
+        SwingDropTarget(JComponent c) {
+            super(c, COPY_OR_MOVE | LINK, new DropHandler(c), true);
+        }
+    }
+
+    private static final class DropHandler implements DropTargetListener {
+
+        private final JComponent component;
+        private final TransferSupport support = new TransferSupport();
+        private Object state;
+
+        DropHandler(JComponent c) {
+            component = c;
+        }
+
+        private void location(boolean show, boolean forDrop) {
+            state = component.setDropLocation(show ? support.getDropLocation() : null, state, forDrop);
+        }
+
+        private void handleDrag(DropTargetDragEvent e) {
+            TransferHandler importer = component.getTransferHandler();
+            if (importer == null) {
+                e.rejectDrag();
+                location(false, false);
+                return;
+            }
+            support.drag(component, e);
+            boolean canImport = importer.canImport(support);
+            if (canImport) {
+                e.acceptDrag(support.getDropAction());
+            } else {
+                e.rejectDrag();
+            }
+            location(support.showLocation(canImport), false);
+        }
+
+        @Override
+        public void dragEnter(DropTargetDragEvent e) {
+            state = null;
+            handleDrag(e);
+        }
+
+        @Override
+        public void dragOver(DropTargetDragEvent e) {
+            handleDrag(e);
+        }
+
+        @Override
+        public void dropActionChanged(DropTargetDragEvent e) {
+            handleDrag(e);
+        }
+
+        @Override
+        public void dragExit(DropTargetEvent e) {
+            cleanup(false);
+        }
+
+        @Override
+        public void drop(DropTargetDropEvent e) {
+            TransferHandler importer = component.getTransferHandler();
+            if (importer == null) {
+                e.rejectDrop();
+                cleanup(false);
+                return;
+            }
+            support.drop(component, e);
+            if (!importer.canImport(support)) {
+                e.rejectDrop();
+                cleanup(false);
+                return;
+            }
+            e.acceptDrop(support.getDropAction());
+            location(support.showLocation(true), false);
+            boolean success;
+            try {
+                success = importer.importData(support);
+            } catch (RuntimeException re) {
+                success = false;
+            }
+            e.dropComplete(success);
+            cleanup(success);
+        }
+
+        private void cleanup(boolean forDrop) {
+            location(false, forDrop);
+            state = null;
+        }
+    }
+
+    /// Cut, copy and paste, done by the handler of the event's source.
+    private static final class TransferAction extends AbstractAction implements UIResource {
+
+        TransferAction(String name) {
+            super(name);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            Object src = e.getSource();
+            if (!(src instanceof JComponent)) {
+                return;
+            }
+            JComponent c = (JComponent) src;
+            TransferHandler th = c.getTransferHandler();
+            Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+            if (th == null || clipboard == null) {
+                return;
+            }
+            Object name = getValue(Action.NAME);
+            if ("cut".equals(name)) {
+                th.exportToClipboard(c, clipboard, MOVE);
+            } else if ("copy".equals(name)) {
+                th.exportToClipboard(c, clipboard, COPY);
+            } else if ("paste".equals(name)) {
+                Transferable trans = clipboard.getContents(null);
+                if (trans != null) {
+                    th.importData(new TransferSupport(c, trans));
+                }
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UIDefaults.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UIDefaults.java
new file mode 100644
index 00000000000..c9c2bce8571
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UIDefaults.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import java.util.Hashtable;
+
+/// A table of defaults by key, with a getter for each type of value that
+/// answers `null` (or zero, or false) when the key holds something else.
+///
+/// The table [UIManager#getDefaults] answers also knows the values the
+/// Codename One theme stands in for; see [UIManager]. One made with `new`
+/// holds only what is put into it.
+///
+/// What differs from the desktop: there are no lazy or active values, no
+/// resource bundles and no UI classes; putting `null` removes the key, as
+/// it does there.
+public class UIDefaults extends Hashtable<Object, Object> {
+
+    private static final long serialVersionUID = 7341222528856548117L;
+
+    public UIDefaults() {
+        super();
+    }
+
+    /// A table holding the pairs of `keyValueList`: a key, its value, the
+    /// next key, and so on.
+    public UIDefaults(Object[] keyValueList) {
+        super();
+        putDefaults(keyValueList);
+    }
+
+    @Override
+    public Object put(Object key, Object value) {
+        return value == null ? super.remove(key) : super.put(key, value);
+    }
+
+    public void putDefaults(Object[] keyValueList) {
+        for (int i = 0; i + 1 < keyValueList.length; i += 2) {
+            put(keyValueList[i], keyValueList[i + 1]);
+        }
+    }
+
+    public Font getFont(Object key) {
+        Object v = get(key);
+        return v instanceof Font ? (Font) v : null;
+    }
+
+    public Color getColor(Object key) {
+        Object v = get(key);
+        return v instanceof Color ? (Color) v : null;
+    }
+
+    public Icon getIcon(Object key) {
+        Object v = get(key);
+        return v instanceof Icon ? (Icon) v : null;
+    }
+
+    public Border getBorder(Object key) {
+        Object v = get(key);
+        return v instanceof Border ? (Border) v : null;
+    }
+
+    public String getString(Object key) {
+        Object v = get(key);
+        return v instanceof String ? (String) v : null;
+    }
+
+    public int getInt(Object key) {
+        Object v = get(key);
+        return v instanceof Integer ? ((Integer) v).intValue() : 0;
+    }
+
+    public boolean getBoolean(Object key) {
+        Object v = get(key);
+        return v instanceof Boolean && ((Boolean) v).booleanValue();
+    }
+
+    public Insets getInsets(Object key) {
+        Object v = get(key);
+        return v instanceof Insets ? (Insets) v : null;
+    }
+
+    public Dimension getDimension(Object key) {
+        Object v = get(key);
+        return v instanceof Dimension ? (Dimension) v : null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UIManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UIManager.java
new file mode 100644
index 00000000000..1f6708d2910
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UIManager.java
@@ -0,0 +1,551 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.EventBridge;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.LafTheme;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+
+/// A table of look and feel defaults, and the look and feel itself.
+///
+/// ## The look and feel
+///
+/// The widgets of the layer are Codename One components drawn with the
+/// Codename One theme; there are no UI delegates. What a look and feel
+/// chooses here is the *palette*: light or dark. Setting one never fails
+/// for a name, restyles every open window at once, and fires the
+/// `lookAndFeel` property change:
+///
+///  - a dark one -- FlatLaf's `FlatDarkLaf`, `FlatDarculaLaf`,
+///    `FlatMacDarkLaf`, any subclass of `FlatLaf` whose `isDark()` answers
+///    true, any class whose name says dark (`Dark`, `Darcula`, `Dracula`,
+///    `Night`, `Monokai` and the like) -- selects the dark palette
+///  - a light one -- the other FlatLaf classes, Metal, Nimbus, Motif, the
+///    Windows, Aqua and GTK names, a name that says light -- the light one
+///  - the built-in look, which is what both `get...ClassName` methods
+///    name, and `null`, follow the platform's own dark mode
+///  - any other keeps the palette as it is and says so once in the log
+///
+/// The object that was set is answered by [#getLookAndFeel]; a class name
+/// is answered by an instance of that class when the application has it,
+/// and otherwise by a stand-in that carries the name. `initialize` and
+/// `uninitialize` are called as on the desktop, and what a look and feel
+/// of the application's own answers from `getDefaults` becomes the look
+/// and feel defaults.
+///
+/// ## The defaults
+///
+/// There are two tables, as on the desktop. What an application `put`
+/// is in the developer defaults, wins, and stays when the look and feel
+/// changes. [#getLookAndFeelDefaults] is the table of the look and feel,
+/// emptied when another is set. A key in neither answers from the theme
+/// and the palette:
+///
+///  - a key ending in `.background`, and `control`, `window`, `menu`: the
+///    window background; content areas (`text`, `List.background`,
+///    `TextField.background` ...) the field background
+///  - a key ending in `.foreground`, and `controlText`, `windowText`,
+///    `menuText`, `textText`: the color of a label's text
+///  - a key ending in `.font`: the default font; `defaultFont`, and
+///    FlatLaf's `h1.font` ... `h4.font`, `large.font`, `small.font`,
+///    `mini.font`, `monospaced.font`
+///  - a key ending in `.selectionBackground` or `.selectionForeground`,
+///    and `textHighlight`, `textHighlightText`: the colors of a selected
+///    table cell
+///  - a key ending in `.gridColor`, `.borderColor`, and
+///    `Separator.foreground`, `controlShadow`: the color of lines
+///  - a key ending in `.disabledForeground`, `.inactiveForeground`:
+///    the color of disabled text
+///  - FlatLaf's `Component.accentColor`, `Component.focusColor`,
+///    `Component.linkColor`, `Component.error...`, `Actions.Red` and the
+///    other `Actions.`/`Objects.` colors, `laf.dark`
+///  - `TextField.border`, `Button.border`, `ScrollPane.border` and their
+///    kin: a line in the palette's line color that follows the palette
+///  - the margins and metrics `Button.margin`, `TextField.margin`,
+///    `Component.arc`, `Table.rowHeight` and the like
+///  - `ScrollBar.width`: the room a scroll pane gives a scroll bar, zero
+///    on a touch device
+///
+/// Any other key gives `null`, or zero or false from the typed getters.
+/// The widgets read what was put for the keys they know
+/// (`Table.gridColor`, `List.selectionBackground` and so on) when they are
+/// made; there are no icons or strings of a look and feel to find here
+/// unless the application put them.
+public class UIManager {
+
+    /// The defaults: what was put, and behind it the theme.
+    private static final class ThemeDefaults extends UIDefaults {
+        private static final long serialVersionUID = 1L;
+
+        Object raw(Object key) {
+            return key == null ? null : super.get(key);
+        }
+
+        @Override
+        public Object get(Object key) {
+            Object v = raw(key);
+            if (v != null || key == null) {
+                return v;
+            }
+            return LAF.get(key);
+        }
+    }
+
+    /// The defaults of the look and feel: what it or the application put
+    /// there, and behind that the theme.
+    private static final class LafDefaults extends UIDefaults {
+        private static final long serialVersionUID = 1L;
+
+        Object raw(Object key) {
+            return key == null ? null : super.get(key);
+        }
+
+        @Override
+        public Object get(Object key) {
+            Object v = raw(key);
+            if (v != null || !(key instanceof String)) {
+                return v;
+            }
+            return fromTheme((String) key);
+        }
+    }
+
+    /// A look and feel known by its name alone.
+    private static final class NamedLookAndFeel extends LookAndFeel {
+        private final String name;
+        private final String className;
+
+        NamedLookAndFeel(String name, String className) {
+            this.name = name;
+            this.className = className;
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public String getID() {
+            return name;
+        }
+
+        @Override
+        public String getDescription() {
+            return name + " (" + className + "), as a palette of the Codename One theme";
+        }
+
+        @Override
+        public boolean isNativeLookAndFeel() {
+            return false;
+        }
+
+        @Override
+        public boolean isSupportedLookAndFeel() {
+            return true;
+        }
+    }
+
+    /// The one look and feel there is, answered until another is set.
+    private static final class ThemeLookAndFeel extends LookAndFeel {
+        @Override
+        public String getName() {
+            return LOOK_NAME;
+        }
+
+        @Override
+        public String getID() {
+            return "CodenameOne";
+        }
+
+        @Override
+        public String getDescription() {
+            return "The Codename One theme";
+        }
+
+        @Override
+        public boolean isNativeLookAndFeel() {
+            return true;
+        }
+
+        @Override
+        public boolean isSupportedLookAndFeel() {
+            return true;
+        }
+
+        @Override
+        public UIDefaults getDefaults() {
+            return LAF;
+        }
+    }
+
+    /// The name and class name of a look and feel that is installed.
+    public static class LookAndFeelInfo {
+        private final String name;
+        private final String className;
+
+        public LookAndFeelInfo(String name, String className) {
+            this.name = name;
+            this.className = className;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getClassName() {
+            return className;
+        }
+
+        @Override
+        public String toString() {
+            return getClass().getName() + "[" + getName() + " " + getClassName() + "]";
+        }
+    }
+
+    private static final String LOOK_NAME = "Codename One";
+    /// The class name of the built-in look and feel, so that the one
+    /// reported installed is the one [#getLookAndFeel] answers: programs
+    /// find the current look and feel among the installed ones by it.
+    private static final String LOOK_CLASS = ThemeLookAndFeel.class.getName();
+    private static final LafDefaults LAF = new LafDefaults();
+    private static final ThemeDefaults VALUES = new ThemeDefaults();
+    private static final PropertyChangeSupport CHANGES = new PropertyChangeSupport(UIManager.class);
+    private static final String LAYER = "com.codename1.desktopcompat.";
+    /// Words in a class name that say a look is dark, and that it is
+    /// light; the dark ones are asked first.
+    private static final String[] DARK_WORDS = {"dark", "darcula", "dracula", "night", "monokai", "carbon", "cobalt",
+        "nord", "gruvbox", "hiberbee", "spacegray", "vuesion", "oceanic", "contrast", "black", "onedark"};
+    private static final String[] LIGHT_WORDS = {"light", "metal", "nimbus", "windows", "aqua", "gtk", "motif",
+        "intellij", "synth", "basic", "multi", "white", "cyan", "gray", "grey"};
+    private static final LookAndFeel BUILT_IN = new ThemeLookAndFeel();
+    /// The look and feel that was set, or `null` for the built-in one.
+    private static LookAndFeel current;
+    private static LookAndFeelInfo[] installed = {new LookAndFeelInfo(LOOK_NAME, LOOK_CLASS)};
+
+    public UIManager() {
+    }
+
+    /// What the theme has for a key nobody put.
+    private static Object fromTheme(String k) {
+        Object known = LafTheme.value(k);
+        if (known != null) {
+            return known;
+        }
+        if (k.endsWith(".selectionBackground") || "textHighlight".equals(k)) {
+            return CellTheme.selectionBackground(null);
+        }
+        if (k.endsWith(".selectionForeground") || "textHighlightText".equals(k)) {
+            return CellTheme.selectionForeground(null);
+        }
+        if (k.endsWith(".gridColor")) {
+            return CellTheme.grid(null);
+        }
+        if ("List.background".equals(k) || "Tree.background".equals(k) || "Table.background".equals(k)) {
+            return CellTheme.background(null);
+        }
+        if ("Desktop.background".equals(k) || "desktop".equals(k)) {
+            return CellTheme.desktopBackground();
+        }
+        if ("text".equals(k) || "TextArea.background".equals(k) || "TextField.background".equals(k)
+                || "EditorPane.background".equals(k) || "TextPane.background".equals(k)
+                || "FormattedTextField.background".equals(k) || "PasswordField.background".equals(k)) {
+            return CellTheme.fieldBackground();
+        }
+        if (k.endsWith(".background") || "control".equals(k) || "window".equals(k) || "menu".equals(k)) {
+            return EventBridge.defaultBackground();
+        }
+        if (k.endsWith(".foreground") || "controlText".equals(k) || "windowText".equals(k) || "menuText".equals(k)
+                || "textText".equals(k)) {
+            return EventBridge.defaultForeground();
+        }
+        if (k.endsWith(".font")) {
+            return Fonts.defaultFont();
+        }
+        if ("ScrollBar.width".equals(k)) {
+            return Integer.valueOf(ScrollDelegate.barThickness());
+        }
+        return null;
+    }
+
+    /// The color an application put under a key, or `null`: never a value
+    /// of the theme. This is what a widget asks, so that its own reading
+    /// of the theme applies when the application said nothing.
+    public static Color cn1PutColor(Object key) {
+        Object v = VALUES.raw(key);
+        if (v == null) {
+            v = LAF.raw(key);
+        }
+        return v instanceof Color ? (Color) v : null;
+    }
+
+    /// The font an application or its look and feel put under a key, or
+    /// `null`: never a value of the theme.
+    public static Font cn1PutFont(Object key) {
+        Object v = VALUES.raw(key);
+        if (v == null) {
+            v = LAF.raw(key);
+        }
+        return v instanceof Font ? (Font) v : null;
+    }
+
+    public static Object get(Object key) {
+        return VALUES.get(key);
+    }
+
+    public static Object put(Object key, Object value) {
+        return VALUES.put(key, value);
+    }
+
+    /// The table behind `get` and `put`.
+    public static UIDefaults getDefaults() {
+        return VALUES;
+    }
+
+    /// The defaults of the look and feel, beneath what the application
+    /// put into [#getDefaults]. They are emptied when a look and feel is
+    /// set; what is put here does not survive that.
+    public static UIDefaults getLookAndFeelDefaults() {
+        return LAF;
+    }
+
+    public static Color getColor(Object key) {
+        return VALUES.getColor(key);
+    }
+
+    public static Font getFont(Object key) {
+        return VALUES.getFont(key);
+    }
+
+    public static String getString(Object key) {
+        return VALUES.getString(key);
+    }
+
+    public static int getInt(Object key) {
+        return VALUES.getInt(key);
+    }
+
+    public static boolean getBoolean(Object key) {
+        return VALUES.getBoolean(key);
+    }
+
+    public static Icon getIcon(Object key) {
+        return VALUES.getIcon(key);
+    }
+
+    public static Border getBorder(Object key) {
+        return VALUES.getBorder(key);
+    }
+
+    public static Insets getInsets(Object key) {
+        return VALUES.getInsets(key);
+    }
+
+    public static Dimension getDimension(Object key) {
+        return VALUES.getDimension(key);
+    }
+
+    private static boolean says(String name, String[] words) {
+        for (int w = 0; w < words.length; w++) {
+            String word = words[w];
+            for (int i = 0; i + word.length() <= name.length(); i++) {
+                if (name.regionMatches(true, i, word, 0, word.length())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /// Whether a look and feel is dark, light, or not known: `TRUE`,
+    /// `FALSE`, `null`.
+    private static Boolean dark(LookAndFeel laf, String className) {
+        if (laf instanceof FlatLaf) {
+            return Boolean.valueOf(((FlatLaf) laf).isDark());
+        }
+        String simple = className.substring(className.lastIndexOf('.') + 1);
+        if (says(simple, DARK_WORDS)) {
+            return Boolean.TRUE;
+        }
+        if (says(simple, LIGHT_WORDS) || says(className, LIGHT_WORDS)) {
+            return Boolean.FALSE;
+        }
+        return null;
+    }
+
+    private static LookAndFeel instance(String className) {
+        // The layer's own class of that name first: an application names
+        // a look and feel by the name it has on the desktop.
+        String[] names = {LAYER + className, className};
+        for (int i = 0; i < names.length; i++) {
+            try {
+                Object o = Class.forName(names[i]).newInstance();
+                if (o instanceof LookAndFeel) {
+                    return (LookAndFeel) o;
+                }
+            } catch (ClassNotFoundException e) {
+                continue;
+            } catch (InstantiationException e) {
+                continue;
+            } catch (IllegalAccessException e) {
+                continue;
+            } catch (LinkageError e) {
+                continue;
+            }
+        }
+        return null;
+    }
+
+    /// Sets the look and feel of that class name and never fails for a
+    /// name; see the class description for what each name selects.
+    public static void setLookAndFeel(String className) {
+        if (className == null || LOOK_CLASS.equals(className)) {
+            install(null, LOOK_CLASS);
+            return;
+        }
+        LookAndFeel laf = instance(className);
+        if (laf == null) {
+            String simple = className.substring(className.lastIndexOf('.') + 1);
+            if (simple.endsWith("LookAndFeel") && simple.length() > 11) {
+                simple = simple.substring(0, simple.length() - 11);
+            }
+            laf = new NamedLookAndFeel(simple, className);
+        } else if (!laf.isSupportedLookAndFeel()) {
+            return;
+        }
+        install(laf, className);
+    }
+
+    /// Sets the look and feel; `null` puts the built-in one back, which
+    /// follows the platform's dark mode. See the class description.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedLookAndFeelException`: if the look and feel itself
+    ///   answers false from `isSupportedLookAndFeel`
+    public static void setLookAndFeel(LookAndFeel newLookAndFeel) throws UnsupportedLookAndFeelException {
+        if (newLookAndFeel != null && !newLookAndFeel.isSupportedLookAndFeel()) {
+            throw new UnsupportedLookAndFeelException(newLookAndFeel + " not supported on this platform");
+        }
+        install(newLookAndFeel == BUILT_IN ? null : newLookAndFeel,
+                newLookAndFeel == null ? LOOK_CLASS : newLookAndFeel.getClass().getName());
+    }
+
+    private static void install(LookAndFeel laf, String className) {
+        LookAndFeel old = getLookAndFeel();
+        if (current != null && current != laf) {
+            current.uninitialize();
+        }
+        LAF.clear();
+        if (laf != null && laf != current) {
+            laf.initialize();
+        }
+        current = laf;
+        boolean select = true;
+        Boolean dark = null;
+        if (laf != null) {
+            UIDefaults own = laf.getDefaults();
+            if (own != null && own != LAF && own != VALUES) {
+                LAF.putAll(own);
+            }
+            dark = dark(laf, className);
+            if (dark == null) {
+                select = false;
+                LafTheme.unknown(className);
+            }
+        }
+        if (select) {
+            LafTheme.select(dark);
+        } else {
+            LafTheme.restyleAll();
+        }
+        LookAndFeel now = getLookAndFeel();
+        if (old != now) {
+            CHANGES.firePropertyChange("lookAndFeel", old, now);
+        }
+    }
+
+    public static void addPropertyChangeListener(PropertyChangeListener listener) {
+        CHANGES.addPropertyChangeListener(listener);
+    }
+
+    public static void removePropertyChangeListener(PropertyChangeListener listener) {
+        CHANGES.removePropertyChangeListener(listener);
+    }
+
+    public static PropertyChangeListener[] getPropertyChangeListeners() {
+        return CHANGES.getPropertyChangeListeners();
+    }
+
+    public static LookAndFeel getLookAndFeel() {
+        return current == null ? BUILT_IN : current;
+    }
+
+    public static String getSystemLookAndFeelClassName() {
+        return LOOK_CLASS;
+    }
+
+    public static String getCrossPlatformLookAndFeelClassName() {
+        return LOOK_CLASS;
+    }
+
+    /// The look and feels there are to choose from: one, unless the
+    /// application installed more names. The array is a copy.
+    public static LookAndFeelInfo[] getInstalledLookAndFeels() {
+        LookAndFeelInfo[] copy = new LookAndFeelInfo[installed.length];
+        System.arraycopy(installed, 0, copy, 0, installed.length);
+        return copy;
+    }
+
+    /// Replaces the list [#getInstalledLookAndFeels] answers.
+    public static void setInstalledLookAndFeels(LookAndFeelInfo[] infos) {
+        if (infos == null) {
+            throw new NullPointerException("infos");
+        }
+        LookAndFeelInfo[] copy = new LookAndFeelInfo[infos.length];
+        System.arraycopy(infos, 0, copy, 0, infos.length);
+        installed = copy;
+    }
+
+    public static void installLookAndFeel(LookAndFeelInfo info) {
+        LookAndFeelInfo[] now = getInstalledLookAndFeels();
+        LookAndFeelInfo[] more = new LookAndFeelInfo[now.length + 1];
+        System.arraycopy(now, 0, more, 0, now.length);
+        more[now.length] = info;
+        installed = more;
+    }
+
+    public static void installLookAndFeel(String name, String className) {
+        installLookAndFeel(new LookAndFeelInfo(name, className));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UnsupportedLookAndFeelException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UnsupportedLookAndFeelException.java
new file mode 100644
index 00000000000..39fdb7a5897
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/UnsupportedLookAndFeelException.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// Declared so that code catching it links; nothing throws it.
+public class UnsupportedLookAndFeelException extends Exception {
+
+    public UnsupportedLookAndFeelException(String s) {
+        super(s);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/WindowConstants.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/WindowConstants.java
new file mode 100644
index 00000000000..b377359add6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/WindowConstants.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+/// The operations a window can perform when the user closes it.
+public interface WindowConstants {
+
+    int DO_NOTHING_ON_CLOSE = 0;
+
+    int HIDE_ON_CLOSE = 1;
+
+    int DISPOSE_ON_CLOSE = 2;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/AbstractBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/AbstractBorder.java
new file mode 100644
index 00000000000..20a7b0a035b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/AbstractBorder.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+
+/// A border that takes no space and paints nothing, as the base the other
+/// borders build on.
+public abstract class AbstractBorder implements Border {
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c) {
+        return getBorderInsets(c, new Insets(0, 0, 0, 0));
+    }
+
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.left = 0;
+        insets.top = 0;
+        insets.right = 0;
+        insets.bottom = 0;
+        return insets;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return false;
+    }
+
+    public Rectangle getInteriorRectangle(Component c, int x, int y, int width, int height) {
+        return getInteriorRectangle(c, this, x, y, width, height);
+    }
+
+    public static Rectangle getInteriorRectangle(Component c, Border b, int x, int y, int width, int height) {
+        Insets in = b != null ? b.getBorderInsets(c) : new Insets(0, 0, 0, 0);
+        return new Rectangle(x + in.left, y + in.top, width - in.right - in.left, height - in.top - in.bottom);
+    }
+
+    public int getBaseline(Component c, int width, int height) {
+        if (width < 0 || height < 0) {
+            throw new IllegalArgumentException("Width and height must be >= 0");
+        }
+        return -1;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/BevelBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/BevelBorder.java
new file mode 100644
index 00000000000..fcec5f7bb7a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/BevelBorder.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// A two pixel bevel that makes its component look raised or sunken.
+///
+/// Colours not given are derived from the background of the component the
+/// border is painted on, or from light gray when it has none.
+public class BevelBorder extends AbstractBorder {
+
+    public static final int RAISED = 0;
+
+    public static final int LOWERED = 1;
+
+    protected int bevelType;
+
+    protected Color highlightOuter;
+
+    protected Color highlightInner;
+
+    protected Color shadowInner;
+
+    protected Color shadowOuter;
+
+    public BevelBorder(int bevelType) {
+        this.bevelType = bevelType;
+    }
+
+    public BevelBorder(int bevelType, Color highlight, Color shadow) {
+        this(bevelType, highlight.brighter(), highlight, shadow, shadow.brighter());
+    }
+
+    public BevelBorder(int bevelType, Color highlightOuterColor, Color highlightInnerColor, Color shadowOuterColor,
+            Color shadowInnerColor) {
+        this(bevelType);
+        this.highlightOuter = highlightOuterColor;
+        this.highlightInner = highlightInnerColor;
+        this.shadowOuter = shadowOuterColor;
+        this.shadowInner = shadowInnerColor;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        if (bevelType == RAISED) {
+            paintRaisedBevel(c, g, x, y, width, height);
+        } else if (bevelType == LOWERED) {
+            paintLoweredBevel(c, g, x, y, width, height);
+        }
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.set(2, 2, 2, 2);
+        return insets;
+    }
+
+    public Color getHighlightOuterColor(Component c) {
+        return highlightOuter != null ? highlightOuter : EtchedBorder.highlight(c, 2);
+    }
+
+    public Color getHighlightInnerColor(Component c) {
+        return highlightInner != null ? highlightInner : EtchedBorder.highlight(c, 1);
+    }
+
+    public Color getShadowInnerColor(Component c) {
+        return shadowInner != null ? shadowInner : EtchedBorder.base(c).darker();
+    }
+
+    public Color getShadowOuterColor(Component c) {
+        return shadowOuter != null ? shadowOuter : EtchedBorder.base(c).darker().darker();
+    }
+
+    public Color getHighlightOuterColor() {
+        return highlightOuter;
+    }
+
+    public Color getHighlightInnerColor() {
+        return highlightInner;
+    }
+
+    public Color getShadowInnerColor() {
+        return shadowInner;
+    }
+
+    public Color getShadowOuterColor() {
+        return shadowOuter;
+    }
+
+    public int getBevelType() {
+        return bevelType;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return true;
+    }
+
+    /// Two nested L shapes on the top left and two on the bottom right.
+    private static void bevel(Graphics g, int x, int y, int w, int h, Color topOuter, Color topInner,
+            Color bottomOuter, Color bottomInner) {
+        Color old = g.getColor();
+        g.setColor(topOuter);
+        g.drawLine(x, y, x, y + h - 2);
+        g.drawLine(x + 1, y, x + w - 2, y);
+        g.setColor(topInner);
+        g.drawLine(x + 1, y + 1, x + 1, y + h - 3);
+        g.drawLine(x + 2, y + 1, x + w - 3, y + 1);
+        g.setColor(bottomOuter);
+        g.drawLine(x, y + h - 1, x + w - 1, y + h - 1);
+        g.drawLine(x + w - 1, y, x + w - 1, y + h - 2);
+        g.setColor(bottomInner);
+        g.drawLine(x + 1, y + h - 2, x + w - 2, y + h - 2);
+        g.drawLine(x + w - 2, y + 1, x + w - 2, y + h - 3);
+        g.setColor(old);
+    }
+
+    protected void paintRaisedBevel(Component c, Graphics g, int x, int y, int width, int height) {
+        bevel(g, x, y, width, height, getHighlightOuterColor(c), getHighlightInnerColor(c), getShadowOuterColor(c),
+                getShadowInnerColor(c));
+    }
+
+    protected void paintLoweredBevel(Component c, Graphics g, int x, int y, int width, int height) {
+        bevel(g, x, y, width, height, getShadowInnerColor(c), getShadowOuterColor(c), getHighlightOuterColor(c),
+                getHighlightInnerColor(c));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/Border.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/Border.java
new file mode 100644
index 00000000000..e7b71eb0ffa
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/Border.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// The decoration drawn around the edge of a component, and the space it
+/// takes from the component's interior.
+public interface Border {
+
+    void paintBorder(Component c, Graphics g, int x, int y, int width, int height);
+
+    Insets getBorderInsets(Component c);
+
+    boolean isBorderOpaque();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/CompoundBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/CompoundBorder.java
new file mode 100644
index 00000000000..4836c5deaaf
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/CompoundBorder.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// Two borders nested, the inside one drawn within the insets of the
+/// outside one.
+public class CompoundBorder extends AbstractBorder {
+
+    protected Border outsideBorder;
+
+    protected Border insideBorder;
+
+    public CompoundBorder() {
+        this.outsideBorder = null;
+        this.insideBorder = null;
+    }
+
+    public CompoundBorder(Border outsideBorder, Border insideBorder) {
+        this.outsideBorder = outsideBorder;
+        this.insideBorder = insideBorder;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return (outsideBorder == null || outsideBorder.isBorderOpaque())
+                && (insideBorder == null || insideBorder.isBorderOpaque());
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        int px = x;
+        int py = y;
+        int pw = width;
+        int ph = height;
+        if (outsideBorder != null) {
+            outsideBorder.paintBorder(c, g, px, py, pw, ph);
+            Insets in = outsideBorder.getBorderInsets(c);
+            px += in.left;
+            py += in.top;
+            pw = pw - in.right - in.left;
+            ph = ph - in.bottom - in.top;
+        }
+        if (insideBorder != null) {
+            insideBorder.paintBorder(c, g, px, py, pw, ph);
+        }
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.top = 0;
+        insets.left = 0;
+        insets.right = 0;
+        insets.bottom = 0;
+        if (outsideBorder != null) {
+            Insets in = outsideBorder.getBorderInsets(c);
+            insets.top += in.top;
+            insets.left += in.left;
+            insets.right += in.right;
+            insets.bottom += in.bottom;
+        }
+        if (insideBorder != null) {
+            Insets in = insideBorder.getBorderInsets(c);
+            insets.top += in.top;
+            insets.left += in.left;
+            insets.right += in.right;
+            insets.bottom += in.bottom;
+        }
+        return insets;
+    }
+
+    public Border getOutsideBorder() {
+        return outsideBorder;
+    }
+
+    public Border getInsideBorder() {
+        return insideBorder;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/EmptyBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/EmptyBorder.java
new file mode 100644
index 00000000000..4b22e286cab
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/EmptyBorder.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// A border that takes space and paints nothing.
+public class EmptyBorder extends AbstractBorder {
+
+    protected int left;
+
+    protected int right;
+
+    protected int top;
+
+    protected int bottom;
+
+    public EmptyBorder(int top, int left, int bottom, int right) {
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.left = left;
+    }
+
+    public EmptyBorder(Insets borderInsets) {
+        this.top = borderInsets.top;
+        this.right = borderInsets.right;
+        this.bottom = borderInsets.bottom;
+        this.left = borderInsets.left;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.left = left;
+        insets.top = top;
+        insets.right = right;
+        insets.bottom = bottom;
+        return insets;
+    }
+
+    public Insets getBorderInsets() {
+        return new Insets(top, left, bottom, right);
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/EtchedBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/EtchedBorder.java
new file mode 100644
index 00000000000..8a486a8437f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/EtchedBorder.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// A two pixel groove (or ridge) drawn in a highlight and a shadow colour.
+///
+/// Colours not given are derived from the background of the component the
+/// border is painted on, or from light gray when it has none.
+public class EtchedBorder extends AbstractBorder {
+
+    public static final int RAISED = 0;
+
+    public static final int LOWERED = 1;
+
+    protected int etchType;
+
+    protected Color highlight;
+
+    protected Color shadow;
+
+    public EtchedBorder() {
+        this(LOWERED);
+    }
+
+    public EtchedBorder(int etchType) {
+        this(etchType, null, null);
+    }
+
+    public EtchedBorder(Color highlight, Color shadow) {
+        this(LOWERED, highlight, shadow);
+    }
+
+    public EtchedBorder(int etchType, Color highlight, Color shadow) {
+        this.etchType = etchType;
+        this.highlight = highlight;
+        this.shadow = shadow;
+    }
+
+    /// The colour highlights and shadows are derived from.
+    static Color base(Component c) {
+        Color bg = c == null ? null : c.getBackground();
+        return bg == null ? Color.lightGray : bg;
+    }
+
+    /// The highlight derived from a component's background, `steps` shades
+    /// up.
+    ///
+    /// A background that is already as bright as a colour gets has nothing
+    /// brighter to offer, and a highlight equal to it would leave those
+    /// sides of the border unpainted. The highlight is then a light tint
+    /// towards the shadow instead, so every side stays visible and the lit
+    /// sides still read as lighter than the shaded ones.
+    static Color highlight(Component c, int steps) {
+        Color b = base(c);
+        Color up = b;
+        for (int i = 0; i < steps; i++) {
+            up = up.brighter();
+        }
+        if (apart(up, b)) {
+            return up;
+        }
+        return com.codename1.desktopcompat.rt.CellTheme.mix(b, b.darker(), steps > 1 ? 0.25f : 0.5f);
+    }
+
+    private static boolean apart(Color a, Color b) {
+        return Math.abs(a.getRed() - b.getRed()) + Math.abs(a.getGreen() - b.getGreen())
+                + Math.abs(a.getBlue() - b.getBlue()) >= 24;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        Color old = g.getColor();
+        Color light = getHighlightColor(c);
+        Color dark = getShadowColor(c);
+        int w = width;
+        int h = height;
+        g.setColor(etchType == LOWERED ? dark : light);
+        g.drawRect(x, y, w - 2, h - 2);
+        g.setColor(etchType == LOWERED ? light : dark);
+        g.drawLine(x + 1, y + h - 3, x + 1, y + 1);
+        g.drawLine(x + 1, y + 1, x + w - 3, y + 1);
+        g.drawLine(x, y + h - 1, x + w - 1, y + h - 1);
+        g.drawLine(x + w - 1, y + h - 1, x + w - 1, y);
+        g.setColor(old);
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.set(2, 2, 2, 2);
+        return insets;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return true;
+    }
+
+    public int getEtchType() {
+        return etchType;
+    }
+
+    public Color getHighlightColor(Component c) {
+        return highlight != null ? highlight : highlight(c, 1);
+    }
+
+    public Color getHighlightColor() {
+        return highlight;
+    }
+
+    public Color getShadowColor(Component c) {
+        return shadow != null ? shadow : base(c).darker();
+    }
+
+    public Color getShadowColor() {
+        return shadow;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/LineBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/LineBorder.java
new file mode 100644
index 00000000000..bebbd6b55b0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/LineBorder.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// A border of one colour and a fixed thickness, with square or rounded
+/// corners.
+///
+/// The line is drawn as filled bands, or for rounded corners as nested one
+/// pixel outlines, so it is not antialiased.
+public class LineBorder extends AbstractBorder {
+
+    private static final Border BLACK_LINE = new LineBorder(Color.black, 1);
+    private static final Border GRAY_LINE = new LineBorder(Color.gray, 1);
+
+    protected int thickness;
+
+    protected Color lineColor;
+
+    protected boolean roundedCorners;
+
+    public static Border createBlackLineBorder() {
+        return BLACK_LINE;
+    }
+
+    public static Border createGrayLineBorder() {
+        return GRAY_LINE;
+    }
+
+    public LineBorder(Color color) {
+        this(color, 1, false);
+    }
+
+    public LineBorder(Color color, int thickness) {
+        this(color, thickness, false);
+    }
+
+    public LineBorder(Color color, int thickness, boolean roundedCorners) {
+        lineColor = color;
+        this.thickness = thickness;
+        this.roundedCorners = roundedCorners;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        if (thickness <= 0 || lineColor == null) {
+            return;
+        }
+        Color old = g.getColor();
+        g.setColor(lineColor);
+        if (roundedCorners) {
+            for (int i = 0; i < thickness; i++) {
+                int arc = (thickness - i) * 2;
+                g.drawRoundRect(x + i, y + i, width - i - i - 1, height - i - i - 1, arc, arc);
+            }
+        } else if (thickness * 2 >= Math.min(width, height)) {
+            g.fillRect(x, y, width, height);
+        } else {
+            g.fillRect(x, y, width, thickness);
+            g.fillRect(x, y + height - thickness, width, thickness);
+            g.fillRect(x, y + thickness, thickness, height - thickness * 2);
+            g.fillRect(x + width - thickness, y + thickness, thickness, height - thickness * 2);
+        }
+        g.setColor(old);
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.set(thickness, thickness, thickness, thickness);
+        return insets;
+    }
+
+    public Color getLineColor() {
+        return lineColor;
+    }
+
+    public int getThickness() {
+        return thickness;
+    }
+
+    public boolean getRoundedCorners() {
+        return roundedCorners;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return !roundedCorners;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/MatteBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/MatteBorder.java
new file mode 100644
index 00000000000..9294240a9f1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/MatteBorder.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.Icon;
+
+/// A border filled with a solid colour or tiled with an icon.
+///
+/// The icon variant paints by repeating `Icon.paintIcon` across each edge,
+/// clipped to it; the tiles start at the border's top left corner.
+public class MatteBorder extends EmptyBorder {
+
+    protected Color color;
+
+    protected Icon tileIcon;
+
+    public MatteBorder(int top, int left, int bottom, int right, Color matteColor) {
+        super(top, left, bottom, right);
+        this.color = matteColor;
+    }
+
+    public MatteBorder(Insets borderInsets, Color matteColor) {
+        super(borderInsets);
+        this.color = matteColor;
+    }
+
+    public MatteBorder(int top, int left, int bottom, int right, Icon tileIcon) {
+        super(top, left, bottom, right);
+        this.tileIcon = tileIcon;
+    }
+
+    public MatteBorder(Insets borderInsets, Icon tileIcon) {
+        super(borderInsets);
+        this.tileIcon = tileIcon;
+    }
+
+    public MatteBorder(Icon tileIcon) {
+        this(-1, -1, -1, -1, tileIcon);
+    }
+
+    /// The insets in force: those given, or the icon's size on every side
+    /// for a border built from an icon alone.
+    private Insets current() {
+        if (tileIcon != null && top == -1 && bottom == -1 && left == -1 && right == -1) {
+            int w = tileIcon.getIconWidth();
+            int h = tileIcon.getIconHeight();
+            return new Insets(h, w, h, w);
+        }
+        return new Insets(top, left, bottom, right);
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        Insets in = current();
+        if (color != null) {
+            Color old = g.getColor();
+            g.setColor(color);
+            g.fillRect(x, y, width - in.right, in.top);
+            g.fillRect(x, y + in.top, in.left, height - in.top);
+            g.fillRect(x + in.left, y + height - in.bottom, width - in.left, in.bottom);
+            g.fillRect(x + width - in.right, y, in.right, height - in.bottom);
+            g.setColor(old);
+        } else if (tileIcon != null) {
+            tile(c, g, x, y, x, y, width - in.right, in.top);
+            tile(c, g, x, y, x, y + in.top, in.left, height - in.top);
+            tile(c, g, x, y, x + in.left, y + height - in.bottom, width - in.left, in.bottom);
+            tile(c, g, x, y, x + width - in.right, y, in.right, height - in.bottom);
+        }
+    }
+
+    /// Paints the tiles that touch one edge rectangle, on the grid that
+    /// starts at the border's origin.
+    private void tile(Component c, Graphics g, int x, int y, int rx, int ry, int rw, int rh) {
+        int tw = tileIcon.getIconWidth();
+        int th = tileIcon.getIconHeight();
+        if (rw <= 0 || rh <= 0 || tw <= 0 || th <= 0) {
+            return;
+        }
+        Graphics clipped = g.create();
+        clipped.clipRect(rx, ry, rw, rh);
+        int firstX = x + ((rx - x) / tw) * tw;
+        int firstY = y + ((ry - y) / th) * th;
+        for (int ty = firstY; ty < ry + rh; ty += th) {
+            for (int tx = firstX; tx < rx + rw; tx += tw) {
+                tileIcon.paintIcon(c, clipped, tx, ty);
+            }
+        }
+        clipped.dispose();
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        Insets in = current();
+        insets.set(in.top, in.left, in.bottom, in.right);
+        return insets;
+    }
+
+    @Override
+    public Insets getBorderInsets() {
+        return current();
+    }
+
+    public Color getMatteColor() {
+        return color;
+    }
+
+    public Icon getTileIcon() {
+        return tileIcon;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return color != null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/SoftBevelBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/SoftBevelBorder.java
new file mode 100644
index 00000000000..8c83f2e6ca0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/SoftBevelBorder.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// A bevel whose corners are softened: three pixels wide, with the corner
+/// pixels left to the background.
+public class SoftBevelBorder extends BevelBorder {
+
+    public SoftBevelBorder(int bevelType) {
+        super(bevelType);
+    }
+
+    public SoftBevelBorder(int bevelType, Color highlight, Color shadow) {
+        super(bevelType, highlight, shadow);
+    }
+
+    public SoftBevelBorder(int bevelType, Color highlightOuterColor, Color highlightInnerColor,
+            Color shadowOuterColor, Color shadowInnerColor) {
+        super(bevelType, highlightOuterColor, highlightInnerColor, shadowOuterColor, shadowInnerColor);
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        Color old = g.getColor();
+        boolean raised = bevelType == RAISED;
+        Color outerTop = raised ? getHighlightOuterColor(c) : getShadowOuterColor(c);
+        Color innerTop = raised ? getHighlightInnerColor(c) : getShadowInnerColor(c);
+        Color outerBottom = raised ? getShadowOuterColor(c) : getHighlightOuterColor(c);
+        Color innerBottom = raised ? getShadowInnerColor(c) : getHighlightInnerColor(c);
+        g.translate(x, y);
+        g.setColor(outerTop);
+        g.drawLine(0, 0, width - 2, 0);
+        g.drawLine(0, 0, 0, height - 2);
+        g.drawLine(1, 1, 1, 1);
+        g.setColor(innerTop);
+        g.drawLine(2, 1, width - 2, 1);
+        g.drawLine(1, 2, 1, height - 2);
+        g.drawLine(2, 2, 2, 2);
+        g.drawLine(0, height - 1, 0, height - 2);
+        g.drawLine(width - 1, 0, width - 1, 0);
+        g.setColor(outerBottom);
+        g.drawLine(2, height - 1, width - 1, height - 1);
+        g.drawLine(width - 1, 2, width - 1, height - 1);
+        g.setColor(innerBottom);
+        g.drawLine(width - 2, height - 2, width - 2, height - 2);
+        g.translate(-x, -y);
+        g.setColor(old);
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        insets.top = 3;
+        insets.left = 3;
+        insets.bottom = 3;
+        insets.right = 3;
+        return insets;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/TitledBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/TitledBorder.java
new file mode 100644
index 00000000000..9b4dfc84572
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/TitledBorder.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+
+/// A border with a title drawn on or beside its top or bottom edge, the
+/// edge broken where the text crosses it.
+///
+/// There is no look and feel here, so the defaults are fixed: a border
+/// without one of its own draws a lowered [EtchedBorder], and a title
+/// without a font or colour takes those of the component it is painted on.
+/// Every container is laid out left to right, so `LEADING` is the left and
+/// `TRAILING` the right. A title too long for the border is clipped rather
+/// than shortened with an ellipsis.
+public class TitledBorder extends AbstractBorder {
+
+    public static final int DEFAULT_POSITION = 0;
+
+    public static final int ABOVE_TOP = 1;
+
+    public static final int TOP = 2;
+
+    public static final int BELOW_TOP = 3;
+
+    public static final int ABOVE_BOTTOM = 4;
+
+    public static final int BOTTOM = 5;
+
+    public static final int BELOW_BOTTOM = 6;
+
+    public static final int DEFAULT_JUSTIFICATION = 0;
+
+    public static final int LEFT = 1;
+
+    public static final int CENTER = 2;
+
+    public static final int RIGHT = 3;
+
+    public static final int LEADING = 4;
+
+    public static final int TRAILING = 5;
+
+    protected static final int EDGE_SPACING = 2;
+
+    protected static final int TEXT_SPACING = 2;
+
+    protected static final int TEXT_INSET_H = 5;
+
+    private static final Border FALLBACK = new EtchedBorder(EtchedBorder.LOWERED);
+
+    protected String title;
+
+    protected Border border;
+
+    protected int titlePosition;
+
+    protected int titleJustification;
+
+    protected Font titleFont;
+
+    protected Color titleColor;
+
+    public TitledBorder(String title) {
+        this(null, title, LEADING, DEFAULT_POSITION, null, null);
+    }
+
+    public TitledBorder(Border border) {
+        this(border, "", LEADING, DEFAULT_POSITION, null, null);
+    }
+
+    public TitledBorder(Border border, String title) {
+        this(border, title, LEADING, DEFAULT_POSITION, null, null);
+    }
+
+    public TitledBorder(Border border, String title, int titleJustification, int titlePosition) {
+        this(border, title, titleJustification, titlePosition, null, null);
+    }
+
+    public TitledBorder(Border border, String title, int titleJustification, int titlePosition, Font titleFont) {
+        this(border, title, titleJustification, titlePosition, titleFont, null);
+    }
+
+    public TitledBorder(Border border, String title, int titleJustification, int titlePosition, Font titleFont,
+            Color titleColor) {
+        this.title = title;
+        this.border = border;
+        this.titleFont = titleFont;
+        this.titleColor = titleColor;
+        checkJustification(titleJustification);
+        checkPosition(titlePosition);
+        this.titleJustification = titleJustification;
+        this.titlePosition = titlePosition;
+    }
+
+    private static void checkPosition(int titlePosition) {
+        if (titlePosition < DEFAULT_POSITION || titlePosition > BELOW_BOTTOM) {
+            throw new IllegalArgumentException(titlePosition + " is not a valid title position.");
+        }
+    }
+
+    private static void checkJustification(int titleJustification) {
+        if (titleJustification < DEFAULT_JUSTIFICATION || titleJustification > TRAILING) {
+            throw new IllegalArgumentException(titleJustification + " is not a valid title justification.");
+        }
+    }
+
+    private boolean hasTitle() {
+        return title != null && title.length() > 0;
+    }
+
+    private int position() {
+        return titlePosition == DEFAULT_POSITION ? TOP : titlePosition;
+    }
+
+    private Border frame() {
+        return border != null ? border : FALLBACK;
+    }
+
+    private static FontMetrics metrics(Component c, Font f) {
+        return c == null || f == null ? null : c.getFontMetrics(f);
+    }
+
+    /// The height of a line of the title, estimated from the font size when
+    /// the component cannot measure it.
+    private static int lineHeight(FontMetrics fm, Font f) {
+        if (fm != null) {
+            return fm.getHeight();
+        }
+        return f != null ? f.getSize() + f.getSize() / 4 : 15;
+    }
+
+    private int textWidth(FontMetrics fm, Font f) {
+        if (fm != null) {
+            return fm.stringWidth(title);
+        }
+        return title.length() * (f != null ? f.getSize() : 12) / 2;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        Border frame = frame();
+        if (!hasTitle()) {
+            frame.paintBorder(c, g, x, y, width, height);
+            return;
+        }
+        Font font = getFont(c);
+        FontMetrics fm = metrics(c, font);
+        if (fm == null) {
+            fm = g.getFontMetrics(font);
+        }
+        int th = lineHeight(fm, font);
+        int ascent = fm != null ? fm.getAscent() : th * 4 / 5;
+        Insets bi = frame.getBorderInsets(c);
+
+        // The frame, inset from the component's edge, and the top of the
+        // line of text.
+        int bx = x + EDGE_SPACING;
+        int by = y + EDGE_SPACING;
+        int bw = width - EDGE_SPACING * 2;
+        int bh = height - EDGE_SPACING * 2;
+        int textTop;
+        int pos = position();
+        switch (pos) {
+            case ABOVE_TOP:
+                textTop = by;
+                by += th;
+                bh -= th;
+                break;
+            case BELOW_TOP:
+                textTop = by + bi.top + TEXT_SPACING;
+                break;
+            case ABOVE_BOTTOM:
+                textTop = by + bh - bi.bottom - TEXT_SPACING - th;
+                break;
+            case BOTTOM: {
+                int drop = th > bi.bottom ? (th - bi.bottom) / 2 : 0;
+                bh -= drop;
+                textTop = by + bh - bi.bottom + (bi.bottom - th) / 2;
+                break;
+            }
+            case BELOW_BOTTOM:
+                bh -= th;
+                textTop = by + bh;
+                break;
+            default: {
+                int drop = th > bi.top ? (th - bi.top) / 2 : 0;
+                by += drop;
+                bh -= drop;
+                textTop = by + (bi.top - th) / 2;
+                break;
+            }
+        }
+
+        int room = bw - bi.left - bi.right - TEXT_INSET_H * 2;
+        int tw = Math.min(textWidth(fm, font), Math.max(room, 0));
+        int tx;
+        switch (titleJustification) {
+            case CENTER:
+                tx = bx + (bw - tw) / 2;
+                break;
+            case RIGHT:
+            case TRAILING:
+                tx = bx + bw - bi.right - TEXT_INSET_H - tw;
+                break;
+            default:
+                tx = bx + bi.left + TEXT_INSET_H;
+                break;
+        }
+
+        if (pos == TOP || pos == BOTTOM) {
+            // The frame in three pieces, leaving out the stretch of edge
+            // the text sits on.
+            int gapLeft = tx - TEXT_SPACING;
+            int gapRight = tx + tw + TEXT_SPACING;
+            paintClipped(frame, c, g, bx, by, bw, bh, x, y, gapLeft - x, height);
+            paintClipped(frame, c, g, bx, by, bw, bh, gapRight, y, x + width - gapRight, height);
+            if (pos == TOP) {
+                int below = textTop + th;
+                paintClipped(frame, c, g, bx, by, bw, bh, gapLeft, below, gapRight - gapLeft, y + height - below);
+            } else {
+                paintClipped(frame, c, g, bx, by, bw, bh, gapLeft, y, gapRight - gapLeft, textTop - y);
+            }
+        } else {
+            frame.paintBorder(c, g, bx, by, bw, bh);
+        }
+
+        Color color = getColor(c);
+        Graphics text = g.create();
+        text.clipRect(tx, textTop, tw, th);
+        text.setFont(font);
+        if (color != null) {
+            text.setColor(color);
+        }
+        text.drawString(title, tx, textTop + ascent);
+        text.dispose();
+    }
+
+    private static void paintClipped(Border frame, Component c, Graphics g, int bx, int by, int bw, int bh, int cx,
+            int cy, int cw, int ch) {
+        if (cw <= 0 || ch <= 0) {
+            return;
+        }
+        Graphics part = g.create();
+        part.clipRect(cx, cy, cw, ch);
+        frame.paintBorder(c, part, bx, by, bw, bh);
+        part.dispose();
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c, Insets insets) {
+        Insets bi = frame().getBorderInsets(c);
+        int top = bi.top;
+        int bottom = bi.bottom;
+        if (hasTitle()) {
+            Font font = getFont(c);
+            int th = lineHeight(metrics(c, font), font);
+            switch (position()) {
+                case ABOVE_TOP:
+                    top += th;
+                    break;
+                case BELOW_TOP:
+                    top += th + TEXT_SPACING;
+                    break;
+                case ABOVE_BOTTOM:
+                    bottom += th + TEXT_SPACING;
+                    break;
+                case BOTTOM:
+                    bottom = Math.max(bottom, th);
+                    break;
+                case BELOW_BOTTOM:
+                    bottom += th;
+                    break;
+                default:
+                    top = Math.max(top, th);
+                    break;
+            }
+        }
+        int pad = EDGE_SPACING + TEXT_SPACING;
+        insets.set(top + pad, bi.left + pad, bottom + pad, bi.right + pad);
+        return insets;
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return false;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    /// The border drawn around the title. Without a look and feel there is
+    /// no default to hand out, so this is null until one is set; painting
+    /// then uses a lowered etched border.
+    public Border getBorder() {
+        return border;
+    }
+
+    public int getTitlePosition() {
+        return titlePosition;
+    }
+
+    public int getTitleJustification() {
+        return titleJustification;
+    }
+
+    /// The font set on this border, or null when the title takes the font
+    /// of the component it is painted on.
+    public Font getTitleFont() {
+        return titleFont;
+    }
+
+    /// The colour set on this border, or null when the title takes the
+    /// foreground of the component it is painted on.
+    public Color getTitleColor() {
+        return titleColor;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public void setBorder(Border border) {
+        this.border = border;
+    }
+
+    public void setTitlePosition(int titlePosition) {
+        checkPosition(titlePosition);
+        this.titlePosition = titlePosition;
+    }
+
+    public void setTitleJustification(int titleJustification) {
+        checkJustification(titleJustification);
+        this.titleJustification = titleJustification;
+    }
+
+    public void setTitleFont(Font titleFont) {
+        this.titleFont = titleFont;
+    }
+
+    public void setTitleColor(Color titleColor) {
+        this.titleColor = titleColor;
+    }
+
+    public Dimension getMinimumSize(Component c) {
+        Insets in = getBorderInsets(c);
+        Dimension min = new Dimension(in.right + in.left, in.top + in.bottom);
+        if (hasTitle()) {
+            Font font = getFont(c);
+            int tw = textWidth(metrics(c, font), font);
+            int pos = position();
+            if (pos == ABOVE_TOP || pos == BELOW_BOTTOM) {
+                if (min.width < tw) {
+                    min.width = tw;
+                }
+            } else {
+                min.width += tw;
+            }
+        }
+        return min;
+    }
+
+    protected Font getFont(Component c) {
+        if (titleFont != null) {
+            return titleFont;
+        }
+        Font f = c == null ? null : c.getFont();
+        return f != null ? f : new Font("Dialog", Font.PLAIN, 12);
+    }
+
+    private Color getColor(Component c) {
+        if (titleColor != null) {
+            return titleColor;
+        }
+        return c == null ? null : c.getForeground();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/package-info.java
new file mode 100644
index 00000000000..cad7cca41d2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/border/package-info.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The borders a Swing component can be given: empty space, lines, bevels,
+/// etched grooves, matte edges, titled frames and compounds of those.
+///
+/// These classes stand in for the JDK's `javax.swing.border` package once an
+/// application has been relocated onto the layer. A [Border] answers the
+/// insets it takes from its component and paints itself into the edge of
+/// the component's bounds; all coordinates are the same plain pixels the
+/// desktop uses. There is no look and feel to supply defaults, so a
+/// [TitledBorder] without a border of its own draws an etched one, and its
+/// title takes the font and foreground of the component it decorates.
+package com.codename1.desktopcompat.javax.swing.border;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CaretEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CaretEvent.java
new file mode 100644
index 00000000000..cd73ee85a8f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CaretEvent.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventObject;
+
+/// The caret of a text component moved, or its selection changed.
+public abstract class CaretEvent extends EventObject {
+
+    public CaretEvent(Object source) {
+        super(source);
+    }
+
+    /// The position of the caret.
+    public abstract int getDot();
+
+    /// The other end of the selection; the same as the dot when nothing
+    /// is selected.
+    public abstract int getMark();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CaretListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CaretListener.java
new file mode 100644
index 00000000000..b555d6c4f81
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CaretListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about the caret of a text component moving.
+public interface CaretListener extends EventListener {
+
+    void caretUpdate(CaretEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CellEditorListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CellEditorListener.java
new file mode 100644
index 00000000000..7911235dc7c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/CellEditorListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears when a cell editor finishes: with its value kept, or dropped.
+public interface CellEditorListener extends EventListener {
+
+    void editingStopped(ChangeEvent e);
+
+    void editingCanceled(ChangeEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ChangeEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ChangeEvent.java
new file mode 100644
index 00000000000..b6ba46b1333
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ChangeEvent.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventObject;
+
+/// A model's state changed.
+public class ChangeEvent extends EventObject {
+
+    public ChangeEvent(Object source) {
+        super(source);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ChangeListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ChangeListener.java
new file mode 100644
index 00000000000..73c9995b9b9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ChangeListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Receives the changes of a model's state.
+public interface ChangeListener extends EventListener {
+
+    void stateChanged(ChangeEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/DocumentEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/DocumentEvent.java
new file mode 100644
index 00000000000..eae81ba4846
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/DocumentEvent.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.Element;
+
+/// A change of a document: where it happened, how many characters it
+/// covers and of what kind it was. Element changes are never reported.
+public interface DocumentEvent {
+
+    int getOffset();
+
+    int getLength();
+
+    Document getDocument();
+
+    EventType getType();
+
+    ElementChange getChange(Element elem);
+
+    /// The kind of a document change.
+    final class EventType {
+
+        public static final EventType INSERT = new EventType("INSERT");
+
+        public static final EventType REMOVE = new EventType("REMOVE");
+
+        public static final EventType CHANGE = new EventType("CHANGE");
+
+        private final String typeString;
+
+        private EventType(String s) {
+            typeString = s;
+        }
+
+        @Override
+        public String toString() {
+            return typeString;
+        }
+    }
+
+    /// The change made to one element of a document's structure.
+    interface ElementChange {
+
+        Element getElement();
+
+        int getIndex();
+
+        Element[] getChildrenRemoved();
+
+        Element[] getChildrenAdded();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/DocumentListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/DocumentListener.java
new file mode 100644
index 00000000000..ec63820371b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/DocumentListener.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about text inserted into, removed from or restyled in a document.
+public interface DocumentListener extends EventListener {
+
+    void insertUpdate(DocumentEvent e);
+
+    void removeUpdate(DocumentEvent e);
+
+    void changedUpdate(DocumentEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/EventListenerList.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/EventListenerList.java
new file mode 100644
index 00000000000..3cb3086d015
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/EventListenerList.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.AdjustmentListener;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+
+import java.lang.reflect.Array;
+import java.util.EventListener;
+
+/// A list of listeners of mixed types, stored as alternating class and
+/// listener entries.
+///
+/// The array behind `getListenerList()` is handed out as it is, as in the
+/// JDK, so that firing code can walk it without copying; an add or remove
+/// replaces it rather than editing it in place. The JDK class synchronizes
+/// and serializes; this one does neither.
+public class EventListenerList {
+
+    private static final Object[] NULL_ARRAY = new Object[0];
+
+    /// The array class of every listener type this layer itself passes to
+    /// `getListeners`, named so that it exists on a device.
+    ///
+    /// ParparVM has an array class only for a type some bytecode creates an
+    /// array of -- an `anewarray`, or a class literal like the ones below. A
+    /// method that merely *returns* `DocumentListener[]`, or casts to it, does
+    /// not count, so `Array.newInstance(DocumentListener.class, n)` threw
+    /// "the component class has no registered array class" and a native build
+    /// of any application with a text field opened on an error dialog. The
+    /// simulator and Android create array classes on demand and never showed
+    /// it.
+    ///
+    /// A type an application defines and passes here itself is covered only if
+    /// the application creates such an array somewhere, which the usual
+    /// `new FooListener[0]` or `toArray` idiom does.
+    private static final Class<?>[] LISTENER_ARRAYS = {
+        ActionListener[].class, AdjustmentListener[].class, ItemListener[].class,
+        CaretListener[].class, CellEditorListener[].class, ChangeListener[].class,
+        DocumentListener[].class, HyperlinkListener[].class, InternalFrameListener[].class,
+        ListDataListener[].class, ListSelectionListener[].class, MenuListener[].class,
+        PopupMenuListener[].class, RowSorterListener[].class, TableColumnModelListener[].class,
+        TableModelListener[].class, TreeExpansionListener[].class, TreeModelListener[].class,
+        TreeSelectionListener[].class, TreeWillExpandListener[].class, UndoableEditListener[].class
+    };
+
+    /// For the test that holds the table above against the layer's call sites.
+    static Class<?>[] listenerArrayTypes() {
+        return LISTENER_ARRAYS;
+    }
+
+    protected Object[] listenerList = NULL_ARRAY;
+
+    public Object[] getListenerList() {
+        return listenerList;
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends EventListener> T[] getListeners(Class<T> t) {
+        int count = getListenerCount(t);
+        T[] result = (T[]) Array.newInstance(t, count);
+        int j = 0;
+        for (int i = listenerList.length - 2; i >= 0; i -= 2) {
+            if (listenerList[i] == t) {
+                result[j++] = (T) listenerList[i + 1];
+            }
+        }
+        return result;
+    }
+
+    public int getListenerCount() {
+        return listenerList.length / 2;
+    }
+
+    public int getListenerCount(Class<?> t) {
+        int count = 0;
+        for (int i = 0; i < listenerList.length; i += 2) {
+            if (t == listenerList[i]) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public <T extends EventListener> void add(Class<T> t, T l) {
+        if (l == null) {
+            return;
+        }
+        if (!t.isInstance(l)) {
+            throw new IllegalArgumentException("Listener " + l + " is not of type " + t);
+        }
+        int length = listenerList.length;
+        Object[] tmp = new Object[length + 2];
+        System.arraycopy(listenerList, 0, tmp, 0, length);
+        tmp[length] = t;
+        tmp[length + 1] = l;
+        listenerList = tmp;
+    }
+
+    public <T extends EventListener> void remove(Class<T> t, T l) {
+        if (l == null) {
+            return;
+        }
+        if (!t.isInstance(l)) {
+            throw new IllegalArgumentException("Listener " + l + " is not of type " + t);
+        }
+        int index = -1;
+        for (int i = listenerList.length - 2; i >= 0; i -= 2) {
+            if (listenerList[i] == t && listenerList[i + 1].equals(l)) {
+                index = i;
+                break;
+            }
+        }
+        if (index == -1) {
+            return;
+        }
+        Object[] tmp = new Object[listenerList.length - 2];
+        System.arraycopy(listenerList, 0, tmp, 0, index);
+        if (index < tmp.length) {
+            System.arraycopy(listenerList, index + 2, tmp, index, tmp.length - index);
+        }
+        listenerList = tmp.length == 0 ? NULL_ARRAY : tmp;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder("EventListenerList: ");
+        s.append(listenerList.length / 2).append(" listeners: ");
+        for (int i = 0; i <= listenerList.length - 2; i += 2) {
+            s.append(" type ").append(((Class<?>) listenerList[i]).getName());
+            s.append(" listener ").append(listenerList[i + 1]);
+        }
+        return s.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/HyperlinkEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/HyperlinkEvent.java
new file mode 100644
index 00000000000..9f6b02cd77d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/HyperlinkEvent.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import java.net.URL;
+import java.util.EventObject;
+
+/// Something happened to a link of an editor pane. This layer fires the
+/// type [EventType#ACTIVATED] only, when a link is clicked.
+public class HyperlinkEvent extends EventObject {
+
+    private static final long serialVersionUID = 1L;
+
+    private final EventType type;
+    private final URL u;
+    private final String desc;
+    private final InputEvent inputEvent;
+
+    public HyperlinkEvent(Object source, EventType type, URL u) {
+        this(source, type, u, null);
+    }
+
+    public HyperlinkEvent(Object source, EventType type, URL u, String desc) {
+        this(source, type, u, desc, null, null);
+    }
+
+    public HyperlinkEvent(Object source, EventType type, URL u, String desc,
+            com.codename1.desktopcompat.javax.swing.text.Element sourceElement) {
+        this(source, type, u, desc, sourceElement, null);
+    }
+
+    public HyperlinkEvent(Object source, EventType type, URL u, String desc,
+            com.codename1.desktopcompat.javax.swing.text.Element sourceElement, InputEvent inputEvent) {
+        super(source);
+        this.type = type;
+        this.u = u;
+        this.desc = desc;
+        this.inputEvent = inputEvent;
+    }
+
+    public EventType getEventType() {
+        return type;
+    }
+
+    /// What the link's `href` says, as it was written.
+    public String getDescription() {
+        return desc;
+    }
+
+    /// The link as a URL, or `null` when its `href` is not an absolute
+    /// URL.
+    public URL getURL() {
+        return u;
+    }
+
+    /// Always `null`: there are no styled documents in this layer.
+    public com.codename1.desktopcompat.javax.swing.text.Element getSourceElement() {
+        return null;
+    }
+
+    public InputEvent getInputEvent() {
+        return inputEvent;
+    }
+
+    /// The kinds of event, compared by identity as on the desktop.
+    public static final class EventType {
+
+        public static final EventType ENTERED = new EventType("ENTERED");
+
+        public static final EventType EXITED = new EventType("EXITED");
+
+        public static final EventType ACTIVATED = new EventType("ACTIVATED");
+
+        private final String typeString;
+
+        private EventType(String s) {
+            typeString = s;
+        }
+
+        @Override
+        public String toString() {
+            return typeString;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/HyperlinkListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/HyperlinkListener.java
new file mode 100644
index 00000000000..0858f986625
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/HyperlinkListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about the links of an editor pane being used.
+public interface HyperlinkListener extends EventListener {
+
+    void hyperlinkUpdate(HyperlinkEvent e);
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilterOutputStream.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameAdapter.java
similarity index 60%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilterOutputStream.java
rename to maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameAdapter.java
index 968a0f5ef05..be59f179feb 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilterOutputStream.java
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameAdapter.java
@@ -20,48 +20,37 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package com.codename1.desktopcompat.javax.swing.event;
 
-import java.io.IOException;
-import java.io.OutputStream;
+/// An internal frame listener that does nothing, to override the
+/// methods of interest in.
+public abstract class InternalFrameAdapter implements InternalFrameListener {
 
-/// `java.io.FilterOutputStream` for the Codename One runtime.
-public class FilterOutputStream extends OutputStream {
-
-    protected OutputStream out;
+    @Override
+    public void internalFrameOpened(InternalFrameEvent e) {
+    }
 
-    public FilterOutputStream(OutputStream out) {
-        this.out = out;
+    @Override
+    public void internalFrameClosing(InternalFrameEvent e) {
     }
 
     @Override
-    public void write(int b) throws IOException {
-        out.write(b);
+    public void internalFrameClosed(InternalFrameEvent e) {
     }
 
     @Override
-    public void write(byte[] b) throws IOException {
-        write(b, 0, b.length);
+    public void internalFrameIconified(InternalFrameEvent e) {
     }
 
     @Override
-    public void write(byte[] b, int off, int len) throws IOException {
-        for (int i = 0; i < len; i++) {
-            write(b[off + i]);
-        }
+    public void internalFrameDeiconified(InternalFrameEvent e) {
     }
 
     @Override
-    public void flush() throws IOException {
-        out.flush();
+    public void internalFrameActivated(InternalFrameEvent e) {
     }
 
     @Override
-    public void close() throws IOException {
-        try {
-            flush();
-        } finally {
-            out.close();
-        }
+    public void internalFrameDeactivated(InternalFrameEvent e) {
     }
 }
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameEvent.java
new file mode 100644
index 00000000000..47b908175b4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameEvent.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.javax.swing.JInternalFrame;
+
+/// Something that happened to an internal frame.
+public class InternalFrameEvent extends AWTEvent {
+
+    public static final int INTERNAL_FRAME_FIRST = 25549;
+
+    public static final int INTERNAL_FRAME_LAST = 25555;
+
+    public static final int INTERNAL_FRAME_OPENED = INTERNAL_FRAME_FIRST;
+
+    public static final int INTERNAL_FRAME_CLOSING = 1 + INTERNAL_FRAME_FIRST;
+
+    public static final int INTERNAL_FRAME_CLOSED = 2 + INTERNAL_FRAME_FIRST;
+
+    public static final int INTERNAL_FRAME_ICONIFIED = 3 + INTERNAL_FRAME_FIRST;
+
+    public static final int INTERNAL_FRAME_DEICONIFIED = 4 + INTERNAL_FRAME_FIRST;
+
+    public static final int INTERNAL_FRAME_ACTIVATED = 5 + INTERNAL_FRAME_FIRST;
+
+    public static final int INTERNAL_FRAME_DEACTIVATED = 6 + INTERNAL_FRAME_FIRST;
+
+    public InternalFrameEvent(JInternalFrame source, int id) {
+        super(source, id);
+    }
+
+    /// The frame the event is about, or `null` when the source is none.
+    public JInternalFrame getInternalFrame() {
+        Object s = getSource();
+        return s instanceof JInternalFrame ? (JInternalFrame) s : null;
+    }
+
+    @Override
+    public String paramString() {
+        switch (getID()) {
+            case INTERNAL_FRAME_OPENED:
+                return "INTERNAL_FRAME_OPENED";
+            case INTERNAL_FRAME_CLOSING:
+                return "INTERNAL_FRAME_CLOSING";
+            case INTERNAL_FRAME_CLOSED:
+                return "INTERNAL_FRAME_CLOSED";
+            case INTERNAL_FRAME_ICONIFIED:
+                return "INTERNAL_FRAME_ICONIFIED";
+            case INTERNAL_FRAME_DEICONIFIED:
+                return "INTERNAL_FRAME_DEICONIFIED";
+            case INTERNAL_FRAME_ACTIVATED:
+                return "INTERNAL_FRAME_ACTIVATED";
+            case INTERNAL_FRAME_DEACTIVATED:
+                return "INTERNAL_FRAME_DEACTIVATED";
+            default:
+                return "unknown type";
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameListener.java
new file mode 100644
index 00000000000..4467a9e55e8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/InternalFrameListener.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears what happens to an internal frame, the way a window listener
+/// hears about a window.
+public interface InternalFrameListener extends EventListener {
+
+    void internalFrameOpened(InternalFrameEvent e);
+
+    void internalFrameClosing(InternalFrameEvent e);
+
+    void internalFrameClosed(InternalFrameEvent e);
+
+    void internalFrameIconified(InternalFrameEvent e);
+
+    void internalFrameDeiconified(InternalFrameEvent e);
+
+    void internalFrameActivated(InternalFrameEvent e);
+
+    void internalFrameDeactivated(InternalFrameEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListDataEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListDataEvent.java
new file mode 100644
index 00000000000..a3a366f0bb8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListDataEvent.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventObject;
+
+/// A range of a list model changed. The two indices are inclusive and in
+/// ascending order whichever way round they were given.
+public class ListDataEvent extends EventObject {
+
+    public static final int CONTENTS_CHANGED = 0;
+
+    public static final int INTERVAL_ADDED = 1;
+
+    public static final int INTERVAL_REMOVED = 2;
+
+    private final int type;
+    private final int index0;
+    private final int index1;
+
+    public ListDataEvent(Object source, int type, int index0, int index1) {
+        super(source);
+        this.type = type;
+        this.index0 = Math.min(index0, index1);
+        this.index1 = Math.max(index0, index1);
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public int getIndex0() {
+        return index0;
+    }
+
+    public int getIndex1() {
+        return index1;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[type=" + type + ",index0=" + index0 + ",index1=" + index1 + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListDataListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListDataListener.java
new file mode 100644
index 00000000000..911584dc547
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListDataListener.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about elements added to, removed from or replaced in a list model.
+public interface ListDataListener extends EventListener {
+
+    void intervalAdded(ListDataEvent e);
+
+    void intervalRemoved(ListDataEvent e);
+
+    void contentsChanged(ListDataEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListSelectionEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListSelectionEvent.java
new file mode 100644
index 00000000000..d70f00fcf19
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListSelectionEvent.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventObject;
+
+/// The selection of a list changed over a range of indexes.
+public class ListSelectionEvent extends EventObject {
+
+    private final int firstIndex;
+
+    private final int lastIndex;
+
+    private final boolean isAdjusting;
+
+    public ListSelectionEvent(Object source, int firstIndex, int lastIndex, boolean isAdjusting) {
+        super(source);
+        this.firstIndex = firstIndex;
+        this.lastIndex = lastIndex;
+        this.isAdjusting = isAdjusting;
+    }
+
+    public int getFirstIndex() {
+        return firstIndex;
+    }
+
+    public int getLastIndex() {
+        return lastIndex;
+    }
+
+    public boolean getValueIsAdjusting() {
+        return isAdjusting;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + " source=" + getSource() + " firstIndex= " + firstIndex
+                + " lastIndex= " + lastIndex + " isAdjusting= " + isAdjusting + " ";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListSelectionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListSelectionListener.java
new file mode 100644
index 00000000000..fcbb604ed0f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/ListSelectionListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Receives the changes of a list selection.
+public interface ListSelectionListener extends EventListener {
+
+    void valueChanged(ListSelectionEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/MenuEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/MenuEvent.java
new file mode 100644
index 00000000000..2c060b780c1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/MenuEvent.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventObject;
+
+/// Tells that a menu was opened, closed or canceled.
+public class MenuEvent extends EventObject {
+
+    public MenuEvent(Object source) {
+        super(source);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/MenuListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/MenuListener.java
new file mode 100644
index 00000000000..987d1079e8b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/MenuListener.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears a menu open and close.
+public interface MenuListener extends EventListener {
+
+    void menuSelected(MenuEvent e);
+
+    void menuDeselected(MenuEvent e);
+
+    void menuCanceled(MenuEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/PopupMenuEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/PopupMenuEvent.java
new file mode 100644
index 00000000000..6e43fd04765
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/PopupMenuEvent.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventObject;
+
+/// Tells that a popup menu is about to open or close.
+public class PopupMenuEvent extends EventObject {
+
+    public PopupMenuEvent(Object source) {
+        super(source);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/PopupMenuListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/PopupMenuListener.java
new file mode 100644
index 00000000000..a956d629aca
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/PopupMenuListener.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears a popup menu open and close.
+public interface PopupMenuListener extends EventListener {
+
+    void popupMenuWillBecomeVisible(PopupMenuEvent e);
+
+    void popupMenuWillBecomeInvisible(PopupMenuEvent e);
+
+    void popupMenuCanceled(PopupMenuEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/RowSorterEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/RowSorterEvent.java
new file mode 100644
index 00000000000..8f523841f5d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/RowSorterEvent.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import java.util.EventObject;
+
+/// A row sorter changed: either the keys it sorts by, or the order and
+/// number of the rows it shows. The second kind carries the mapping from
+/// view rows to model rows as it was before.
+public class RowSorterEvent extends EventObject {
+
+    /// The two things a sorter reports.
+    public enum Type {
+        SORT_ORDER_CHANGED,
+        SORTED
+    }
+
+    private final Type type;
+    private final int[] oldViewToModel;
+
+    public RowSorterEvent(RowSorter source) {
+        this(source, Type.SORT_ORDER_CHANGED, null);
+    }
+
+    public RowSorterEvent(RowSorter source, Type type, int[] previousRowIndexToModel) {
+        super(source);
+        if (type == null) {
+            throw new IllegalArgumentException("type must be non-null");
+        }
+        this.type = type;
+        this.oldViewToModel = previousRowIndexToModel;
+    }
+
+    @Override
+    public RowSorter getSource() {
+        Object s = super.getSource();
+        return s instanceof RowSorter ? (RowSorter) s : null;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    /// The model row a view row showed before the change; the row itself
+    /// when the rows were in model order then.
+    public int convertPreviousRowIndexToModel(int index) {
+        if (oldViewToModel != null && index >= 0 && index < oldViewToModel.length) {
+            return oldViewToModel[index];
+        }
+        return index;
+    }
+
+    public int getPreviousRowCount() {
+        return oldViewToModel == null ? 0 : oldViewToModel.length;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/RowSorterListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/RowSorterListener.java
new file mode 100644
index 00000000000..1812a261db9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/RowSorterListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears when a row sorter changes its sort keys or the order of the rows.
+public interface RowSorterListener extends EventListener {
+
+    void sorterChanged(RowSorterEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/SwingPropertyChangeSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/SwingPropertyChangeSupport.java
new file mode 100644
index 00000000000..26b5c09f7a1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/SwingPropertyChangeSupport.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+
+/// A `PropertyChangeSupport` that is meant to fire on the event thread.
+///
+/// The user interface has a single thread here, so events are always
+/// delivered synchronously on the caller, whatever the `notifyOnEDT` flag
+/// says.
+public final class SwingPropertyChangeSupport extends PropertyChangeSupport {
+
+    public SwingPropertyChangeSupport(Object sourceBean) {
+        super(sourceBean);
+    }
+
+    public SwingPropertyChangeSupport(Object sourceBean, boolean notifyOnEDT) {
+        super(sourceBean);
+    }
+
+    @Override
+    public void firePropertyChange(PropertyChangeEvent evt) {
+        super.firePropertyChange(evt);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableColumnModelEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableColumnModelEvent.java
new file mode 100644
index 00000000000..9824e6a7e32
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableColumnModelEvent.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.table.TableColumnModel;
+import java.util.EventObject;
+
+/// A column was added to, removed from or moved within a column model.
+public class TableColumnModelEvent extends EventObject {
+
+    protected int fromIndex;
+    protected int toIndex;
+
+    public TableColumnModelEvent(TableColumnModel source, int from, int to) {
+        super(source);
+        fromIndex = from;
+        toIndex = to;
+    }
+
+    public int getFromIndex() {
+        return fromIndex;
+    }
+
+    public int getToIndex() {
+        return toIndex;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableColumnModelListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableColumnModelListener.java
new file mode 100644
index 00000000000..2e2d34e2849
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableColumnModelListener.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about the changes of a table's column model.
+public interface TableColumnModelListener extends EventListener {
+
+    void columnAdded(TableColumnModelEvent e);
+
+    void columnRemoved(TableColumnModelEvent e);
+
+    void columnMoved(TableColumnModelEvent e);
+
+    void columnMarginChanged(ChangeEvent e);
+
+    void columnSelectionChanged(ListSelectionEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableModelEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableModelEvent.java
new file mode 100644
index 00000000000..f29e349d077
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableModelEvent.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.table.TableModel;
+import java.util.EventObject;
+
+/// What changed in a table model: a range of rows, the column (or all of
+/// them), and whether the rows were updated, inserted or deleted.
+///
+/// A first row of [#HEADER_ROW] says the structure of the table changed:
+/// the columns themselves are different.
+public class TableModelEvent extends EventObject {
+
+    public static final int INSERT = 1;
+    public static final int UPDATE = 0;
+    public static final int DELETE = -1;
+    public static final int HEADER_ROW = -1;
+    public static final int ALL_COLUMNS = -1;
+
+    protected int type;
+    protected int firstRow;
+    protected int lastRow;
+    protected int column;
+
+    /// Every row changed, and their number may have too.
+    public TableModelEvent(TableModel source) {
+        this(source, 0, Integer.MAX_VALUE, ALL_COLUMNS, UPDATE);
+    }
+
+    public TableModelEvent(TableModel source, int row) {
+        this(source, row, row, ALL_COLUMNS, UPDATE);
+    }
+
+    public TableModelEvent(TableModel source, int firstRow, int lastRow) {
+        this(source, firstRow, lastRow, ALL_COLUMNS, UPDATE);
+    }
+
+    public TableModelEvent(TableModel source, int firstRow, int lastRow, int column) {
+        this(source, firstRow, lastRow, column, UPDATE);
+    }
+
+    public TableModelEvent(TableModel source, int firstRow, int lastRow, int column, int type) {
+        super(source);
+        this.firstRow = firstRow;
+        this.lastRow = lastRow;
+        this.column = column;
+        this.type = type;
+    }
+
+    public int getFirstRow() {
+        return firstRow;
+    }
+
+    public int getLastRow() {
+        return lastRow;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+
+    public int getType() {
+        return type;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableModelListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableModelListener.java
new file mode 100644
index 00000000000..09504a74f1f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TableModelListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about the changes of a table model.
+public interface TableModelListener extends EventListener {
+
+    void tableChanged(TableModelEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeExpansionEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeExpansionEvent.java
new file mode 100644
index 00000000000..b83007514c1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeExpansionEvent.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import java.util.EventObject;
+
+/// The path of a tree node that is expanded or collapsed.
+public class TreeExpansionEvent extends EventObject {
+
+    protected TreePath path;
+
+    public TreeExpansionEvent(Object source, TreePath path) {
+        super(source);
+        this.path = path;
+    }
+
+    public TreePath getPath() {
+        return path;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeExpansionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeExpansionListener.java
new file mode 100644
index 00000000000..4055d8fe813
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeExpansionListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears when a node of a tree was expanded or collapsed.
+public interface TreeExpansionListener extends EventListener {
+
+    void treeExpanded(TreeExpansionEvent event);
+
+    void treeCollapsed(TreeExpansionEvent event);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeModelEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeModelEvent.java
new file mode 100644
index 00000000000..4e51d6c6abf
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeModelEvent.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import java.util.EventObject;
+
+/// What changed in a tree model: the path to a parent node and, unless
+/// everything below it changed, the children concerned with the indexes
+/// they have (or had, for a removal) in that parent.
+public class TreeModelEvent extends EventObject {
+
+    protected TreePath path;
+    protected int[] childIndices;
+    protected Object[] children;
+
+    public TreeModelEvent(Object source, Object[] path, int[] childIndices, Object[] children) {
+        this(source, path == null ? null : new TreePath(path), childIndices, children);
+    }
+
+    public TreeModelEvent(Object source, TreePath path, int[] childIndices, Object[] children) {
+        super(source);
+        this.path = path;
+        this.childIndices = childIndices;
+        this.children = children;
+    }
+
+    public TreeModelEvent(Object source, Object[] path) {
+        this(source, path == null ? null : new TreePath(path));
+    }
+
+    public TreeModelEvent(Object source, TreePath path) {
+        super(source);
+        this.path = path;
+        this.childIndices = new int[0];
+    }
+
+    public TreePath getTreePath() {
+        return path;
+    }
+
+    public Object[] getPath() {
+        return path == null ? null : path.getPath();
+    }
+
+    public Object[] getChildren() {
+        if (children == null) {
+            return null;
+        }
+        Object[] copy = new Object[children.length];
+        System.arraycopy(children, 0, copy, 0, children.length);
+        return copy;
+    }
+
+    public int[] getChildIndices() {
+        if (childIndices == null) {
+            return null;
+        }
+        int[] copy = new int[childIndices.length];
+        System.arraycopy(childIndices, 0, copy, 0, childIndices.length);
+        return copy;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(getClass().getName()).append(' ').append(hashCode());
+        if (path != null) {
+            sb.append(" path ").append(path);
+        }
+        if (childIndices != null) {
+            sb.append(" indices [ ");
+            for (int i = 0; i < childIndices.length; i++) {
+                sb.append(childIndices[i]).append(' ');
+            }
+            sb.append(']');
+        }
+        if (children != null) {
+            sb.append(" children [ ");
+            for (int i = 0; i < children.length; i++) {
+                sb.append(children[i]).append(' ');
+            }
+            sb.append(']');
+        }
+        return sb.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeModelListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeModelListener.java
new file mode 100644
index 00000000000..bd1638657d9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeModelListener.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about the changes of a tree model.
+public interface TreeModelListener extends EventListener {
+
+    void treeNodesChanged(TreeModelEvent e);
+
+    void treeNodesInserted(TreeModelEvent e);
+
+    void treeNodesRemoved(TreeModelEvent e);
+
+    void treeStructureChanged(TreeModelEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeSelectionEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeSelectionEvent.java
new file mode 100644
index 00000000000..5db767c1465
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeSelectionEvent.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import java.util.EventObject;
+
+/// The paths that joined or left the selection of a tree, and the lead
+/// path before and after.
+public class TreeSelectionEvent extends EventObject {
+
+    protected TreePath[] paths;
+    protected boolean[] areNew;
+    protected TreePath oldLeadSelectionPath;
+    protected TreePath newLeadSelectionPath;
+
+    public TreeSelectionEvent(Object source, TreePath[] paths, boolean[] areNew, TreePath oldLeadSelectionPath,
+            TreePath newLeadSelectionPath) {
+        super(source);
+        this.paths = paths;
+        this.areNew = areNew;
+        this.oldLeadSelectionPath = oldLeadSelectionPath;
+        this.newLeadSelectionPath = newLeadSelectionPath;
+    }
+
+    public TreeSelectionEvent(Object source, TreePath path, boolean isNew, TreePath oldLeadSelectionPath,
+            TreePath newLeadSelectionPath) {
+        super(source);
+        this.paths = new TreePath[]{path};
+        this.areNew = new boolean[]{isNew};
+        this.oldLeadSelectionPath = oldLeadSelectionPath;
+        this.newLeadSelectionPath = newLeadSelectionPath;
+    }
+
+    public TreePath[] getPaths() {
+        TreePath[] copy = new TreePath[paths.length];
+        System.arraycopy(paths, 0, copy, 0, paths.length);
+        return copy;
+    }
+
+    /// The first path that changed.
+    public TreePath getPath() {
+        return paths[0];
+    }
+
+    /// Whether the first path was added to the selection.
+    public boolean isAddedPath() {
+        return areNew[0];
+    }
+
+    public boolean isAddedPath(TreePath path) {
+        for (int i = paths.length - 1; i >= 0; i--) {
+            if (paths[i].equals(path)) {
+                return areNew[i];
+            }
+        }
+        throw new IllegalArgumentException("path is not a path identified by the TreeSelectionEvent");
+    }
+
+    public boolean isAddedPath(int index) {
+        if (paths == null || index < 0 || index >= paths.length) {
+            throw new IllegalArgumentException("index is beyond range of added paths identified by TreeSelectionEvent");
+        }
+        return areNew[index];
+    }
+
+    public TreePath getOldLeadSelectionPath() {
+        return oldLeadSelectionPath;
+    }
+
+    public TreePath getNewLeadSelectionPath() {
+        return newLeadSelectionPath;
+    }
+
+    /// The same event with another source.
+    public Object cloneWithSource(Object newSource) {
+        return new TreeSelectionEvent(newSource, paths, areNew, oldLeadSelectionPath, newLeadSelectionPath);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeSelectionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeSelectionListener.java
new file mode 100644
index 00000000000..60c60e7efe4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeSelectionListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears when the selection of a tree changes.
+public interface TreeSelectionListener extends EventListener {
+
+    void valueChanged(TreeSelectionEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeWillExpandListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeWillExpandListener.java
new file mode 100644
index 00000000000..408119e4904
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/TreeWillExpandListener.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.tree.ExpandVetoException;
+import java.util.EventListener;
+
+/// Hears before a node of a tree expands or collapses, and stops it by
+/// throwing.
+public interface TreeWillExpandListener extends EventListener {
+
+    void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException;
+
+    void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/UndoableEditEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/UndoableEditEvent.java
new file mode 100644
index 00000000000..14a02f3f63d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/UndoableEditEvent.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import com.codename1.desktopcompat.javax.swing.undo.UndoableEdit;
+
+import java.util.EventObject;
+
+/// An operation that can be undone took place.
+public class UndoableEditEvent extends EventObject {
+
+    private final UndoableEdit myEdit;
+
+    public UndoableEditEvent(Object source, UndoableEdit edit) {
+        super(source);
+        myEdit = edit;
+    }
+
+    public UndoableEdit getEdit() {
+        return myEdit;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/UndoableEditListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/UndoableEditListener.java
new file mode 100644
index 00000000000..b58152f159a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/UndoableEditListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.util.EventListener;
+
+/// Hears about each undoable edit as it is made.
+public interface UndoableEditListener extends EventListener {
+
+    void undoableEditHappened(UndoableEditEvent e);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/package-info.java
new file mode 100644
index 00000000000..87737a449aa
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/event/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The `javax.swing.event` change, selection and listener-list classes shared
+/// by the model and component classes of the Swing layer.
+package com.codename1.desktopcompat.javax.swing.event;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileFilter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileFilter.java
new file mode 100644
index 00000000000..be477d2d348
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileFilter.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.filechooser;
+
+import java.io.File;
+
+/// `javax.swing.filechooser.FileFilter`: decides which files a
+/// `JFileChooser` lists.
+public abstract class FileFilter {
+
+    public FileFilter() {
+    }
+
+    public abstract boolean accept(File f);
+
+    public abstract String getDescription();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileNameExtensionFilter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileNameExtensionFilter.java
new file mode 100644
index 00000000000..af780b9ad8b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileNameExtensionFilter.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.filechooser;
+
+import java.io.File;
+
+/// `javax.swing.filechooser.FileNameExtensionFilter`: accepts every
+/// directory, and the files whose name ends in one of a set of extensions,
+/// whatever their case.
+public final class FileNameExtensionFilter extends FileFilter {
+
+    private final String description;
+    private final String[] extensions;
+
+    public FileNameExtensionFilter(String description, String... extensions) {
+        if (extensions == null || extensions.length == 0) {
+            throw new IllegalArgumentException("Extensions must be non-null and not empty");
+        }
+        this.description = description;
+        this.extensions = new String[extensions.length];
+        for (int i = 0; i < extensions.length; i++) {
+            if (extensions[i] == null || extensions[i].length() == 0) {
+                throw new IllegalArgumentException("Each extension must be non-null and not empty");
+            }
+            this.extensions[i] = extensions[i];
+        }
+    }
+
+    @Override
+    public boolean accept(File f) {
+        if (f == null) {
+            return false;
+        }
+        if (f.isDirectory()) {
+            return true;
+        }
+        String name = f.getName();
+        int dot = name.lastIndexOf('.');
+        if (dot <= 0 || dot == name.length() - 1) {
+            return false;
+        }
+        String ext = name.substring(dot + 1);
+        for (int i = 0; i < extensions.length; i++) {
+            // An extension is ASCII; this comparison does not depend on
+            // the device's locale the way folding the case would.
+            if (ext.equalsIgnoreCase(extensions[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public String getDescription() {
+        return description;
+    }
+
+    public String[] getExtensions() {
+        String[] r = new String[extensions.length];
+        System.arraycopy(extensions, 0, r, 0, r.length);
+        return r;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("FileNameExtensionFilter[description=");
+        sb.append(description).append(" extensions=[");
+        for (int i = 0; i < extensions.length; i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(extensions[i]);
+        }
+        return sb.append("]]").toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileView.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileView.java
new file mode 100644
index 00000000000..742fb4f2f51
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/FileView.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.filechooser;
+
+import com.codename1.desktopcompat.javax.swing.Icon;
+import java.io.File;
+
+/// How a file chooser names and draws a file. Every method answers
+/// `null` for "no opinion", and the chooser then uses its own.
+public abstract class FileView {
+
+    public String getName(File f) {
+        return null;
+    }
+
+    public String getDescription(File f) {
+        return null;
+    }
+
+    public String getTypeDescription(File f) {
+        return null;
+    }
+
+    public Icon getIcon(File f) {
+        return null;
+    }
+
+    public Boolean isTraversable(File f) {
+        return null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/package-info.java
new file mode 100644
index 00000000000..9993a7a7c9b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/filechooser/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The `javax.swing.filechooser` file filters `JFileChooser` narrows its
+/// listing with.
+package com.codename1.desktopcompat.javax.swing.filechooser;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/package-info.java
new file mode 100644
index 00000000000..7e4058f1884
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The Swing kernel: the component base class, the panel, label, button
+/// and text field widgets backed by their Codename One counterparts, the
+/// frame, borders, timers and the event dispatch thread helpers.
+///
+/// A widget with a counterpart is drawn by it; see
+/// [com.codename1.desktopcompat.javax.swing.JComponent] for how custom
+/// painting combines with that.
+package com.codename1.desktopcompat.javax.swing;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/BorderUIResource.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/BorderUIResource.java
new file mode 100644
index 00000000000..43d54b476de
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/BorderUIResource.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+
+/// A border that a look and feel installed: it draws as the border it
+/// wraps.
+public class BorderUIResource implements Border, UIResource {
+
+    private final Border delegate;
+
+    public BorderUIResource(Border delegate) {
+        if (delegate == null) {
+            throw new IllegalArgumentException("null border delegate argument");
+        }
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        delegate.paintBorder(c, g, x, y, width, height);
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c) {
+        return delegate.getBorderInsets(c);
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return delegate.isBorderOpaque();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/ColorUIResource.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/ColorUIResource.java
new file mode 100644
index 00000000000..f9ad4f001c6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/ColorUIResource.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf;
+
+import com.codename1.desktopcompat.java.awt.Color;
+
+/// A color that a look and feel installed.
+public class ColorUIResource extends Color implements UIResource {
+
+    public ColorUIResource(int r, int g, int b) {
+        super(r, g, b);
+    }
+
+    public ColorUIResource(int rgb) {
+        super(rgb);
+    }
+
+    public ColorUIResource(float r, float g, float b) {
+        super(r, g, b);
+    }
+
+    public ColorUIResource(Color c) {
+        super(c.getRGB(), (c.getRGB() & 0xFF000000) != 0xFF000000);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/ComponentUI.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/ComponentUI.java
new file mode 100644
index 00000000000..ea92543bb26
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/ComponentUI.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+
+/// What the UI delegates of Swing have in common.
+///
+/// The layer draws its components itself and has no delegates of its
+/// own. The class is here for the one place an application's delegate is
+/// honoured: a `BasicTreeUI` set on a `JTree`, whose `paintRow` draws the
+/// rows.
+public abstract class ComponentUI {
+
+    public ComponentUI() {
+    }
+
+    /// The delegate was set on `c`.
+    public void installUI(JComponent c) {
+    }
+
+    /// The delegate was taken off `c`.
+    public void uninstallUI(JComponent c) {
+    }
+
+    /// Not called: the component paints itself.
+    public void paint(Graphics g, JComponent c) {
+    }
+
+    /// Not called: the component paints itself.
+    public void update(Graphics g, JComponent c) {
+        paint(g, c);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/FontUIResource.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/FontUIResource.java
new file mode 100644
index 00000000000..ddbd3fa8eeb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/FontUIResource.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf;
+
+import com.codename1.desktopcompat.java.awt.Font;
+
+/// A font that a look and feel installed.
+public class FontUIResource extends Font implements UIResource {
+
+    public FontUIResource(String name, int style, int size) {
+        super(name, style, size);
+    }
+
+    public FontUIResource(Font font) {
+        super(font.getName(), font.getStyle(), font.getSize());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/TreeUI.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/TreeUI.java
new file mode 100644
index 00000000000..cc02fb37d68
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/TreeUI.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+
+/// The delegate of a `JTree`. See `BasicTreeUI`, the one an application
+/// subclasses.
+public abstract class TreeUI extends ComponentUI {
+
+    public abstract Rectangle getPathBounds(JTree tree, TreePath path);
+
+    public abstract TreePath getPathForRow(JTree tree, int row);
+
+    public abstract int getRowForPath(JTree tree, TreePath path);
+
+    public abstract int getRowCount(JTree tree);
+
+    public abstract TreePath getClosestPathForLocation(JTree tree, int x, int y);
+
+    public abstract boolean isEditing(JTree tree);
+
+    public abstract boolean stopEditing(JTree tree);
+
+    public abstract void cancelEditing(JTree tree);
+
+    public abstract void startEditingAtPath(JTree tree, TreePath path);
+
+    public abstract TreePath getEditingPath(JTree tree);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/UIResource.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/UIResource.java
new file mode 100644
index 00000000000..e3c9addcbfc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/UIResource.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf;
+
+/// Marks a value that a look and feel installed.
+public interface UIResource {
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicBorders.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicBorders.java
new file mode 100644
index 00000000000..4d1a5668ad2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicBorders.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.basic;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.JToolBar;
+import com.codename1.desktopcompat.javax.swing.border.AbstractBorder;
+import com.codename1.desktopcompat.javax.swing.plaf.UIResource;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+
+/// The one border of the basic look and feel a program composes its own
+/// borders with.
+public class BasicBorders {
+
+    /// An empty border as wide as the margin of the button, tool bar or
+    /// text component it is set on, and zero on anything else.
+    public static class MarginBorder extends AbstractBorder implements UIResource {
+
+        @Override
+        public Insets getBorderInsets(Component c, Insets insets) {
+            Insets margin = null;
+            if (c instanceof AbstractButton) {
+                margin = ((AbstractButton) c).getMargin();
+            } else if (c instanceof JToolBar) {
+                margin = ((JToolBar) c).getMargin();
+            } else if (c instanceof JTextComponent) {
+                margin = ((JTextComponent) c).getMargin();
+            }
+            insets.top = margin != null ? margin.top : 0;
+            insets.left = margin != null ? margin.left : 0;
+            insets.bottom = margin != null ? margin.bottom : 0;
+            insets.right = margin != null ? margin.right : 0;
+            return insets;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicComboBoxEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicComboBoxEditor.java
new file mode 100644
index 00000000000..ae6fa9d85c7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicComboBoxEditor.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.basic;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.java.awt.event.FocusListener;
+import com.codename1.desktopcompat.javax.swing.ComboBoxEditor;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+
+/// The editor an editable combo box has unless it is given another: a
+/// text field showing the item's `toString()`.
+///
+/// What differs from the desktop: an item that is not a string comes back
+/// from `getItem` as itself only while the text still reads as it did when
+/// the item was set; edited text comes back as a `String`, where the
+/// desktop looks for a static `valueOf(String)` on the item's class.
+public class BasicComboBoxEditor implements ComboBoxEditor, FocusListener {
+
+    protected JTextField editor;
+    private Object oldValue;
+
+    public BasicComboBoxEditor() {
+        editor = createEditorComponent();
+    }
+
+    @Override
+    public Component getEditorComponent() {
+        return editor;
+    }
+
+    /// Makes the text field. A subclass answers its own.
+    protected JTextField createEditorComponent() {
+        JTextField field = new JTextField("", 9);
+        field.setName("ComboBox.textField");
+        return field;
+    }
+
+    @Override
+    public void setItem(Object anObject) {
+        String text;
+        if (anObject != null) {
+            text = anObject.toString();
+            oldValue = anObject;
+        } else {
+            text = "";
+        }
+        // Text that reads the same is left alone, and with it the caret.
+        if (!text.equals(editor.getText())) {
+            editor.setText(text);
+        }
+    }
+
+    @Override
+    public Object getItem() {
+        String newValue = editor.getText();
+        if (oldValue != null && !(oldValue instanceof String) && newValue != null
+                && newValue.equals(oldValue.toString())) {
+            return oldValue;
+        }
+        return newValue;
+    }
+
+    @Override
+    public void selectAll() {
+        editor.selectAll();
+        editor.requestFocus();
+    }
+
+    @Override
+    public void focusGained(FocusEvent e) {
+    }
+
+    @Override
+    public void focusLost(FocusEvent e) {
+    }
+
+    @Override
+    public void addActionListener(ActionListener l) {
+        editor.addActionListener(l);
+    }
+
+    @Override
+    public void removeActionListener(ActionListener l) {
+        editor.removeActionListener(l);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicTreeUI.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicTreeUI.java
new file mode 100644
index 00000000000..717e7c2803e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/BasicTreeUI.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.basic;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.plaf.TreeUI;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+
+/// The delegate of a tree, as far as an application reaches into it: a
+/// subclass overrides [#paintRow] to draw behind or instead of a row.
+///
+/// Set on a tree with `JTree.setUI`, its `paintRow` is called for every
+/// row the tree paints, with the rectangle of the row's text. What it does
+/// as it comes is what the tree does without a delegate: the tint of a
+/// selected row across the tree and the renderer's component. The arrow
+/// of a node with children is drawn by the tree afterwards, over the row.
+///
+/// Nothing else of the JDK's class is here. The tree measures, lays out
+/// and handles input itself, so the many protected fields and hooks the
+/// JDK's delegate has for that would be read and never honoured.
+public class BasicTreeUI extends TreeUI {
+
+    /// The tree this delegate is set on, `null` when it is on none.
+    protected JTree tree;
+
+    public BasicTreeUI() {
+    }
+
+    @Override
+    public void installUI(JComponent c) {
+        if (c == null) {
+            throw new NullPointerException("null component passed to BasicTreeUI.installUI()");
+        }
+        if (c instanceof JTree) {
+            tree = (JTree) c;
+        }
+    }
+
+    @Override
+    public void uninstallUI(JComponent c) {
+        tree = null;
+    }
+
+    /// Paints one row. `bounds` is the rectangle of the row's text, as
+    /// `JTree.getPathBounds` answers it; `clipBounds` what is being
+    /// painted and `insets` the tree's.
+    protected void paintRow(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path,
+            int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf) {
+        if (tree != null) {
+            tree.cn1PaintRow(g, path, row);
+        }
+    }
+
+    /// Called by the tree for each row it paints. Not Swing API.
+    public void cn1PaintRow(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path,
+            int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf) {
+        paintRow(g, clipBounds, insets, bounds, path, row, isExpanded, hasBeenExpanded, isLeaf);
+    }
+
+    @Override
+    public Rectangle getPathBounds(JTree tree, TreePath path) {
+        return tree == null ? null : tree.getPathBounds(path);
+    }
+
+    @Override
+    public TreePath getPathForRow(JTree tree, int row) {
+        return tree == null ? null : tree.getPathForRow(row);
+    }
+
+    @Override
+    public int getRowForPath(JTree tree, TreePath path) {
+        return tree == null ? -1 : tree.getRowForPath(path);
+    }
+
+    @Override
+    public int getRowCount(JTree tree) {
+        return tree == null ? 0 : tree.getRowCount();
+    }
+
+    @Override
+    public TreePath getClosestPathForLocation(JTree tree, int x, int y) {
+        return tree == null ? null : tree.getClosestPathForLocation(x, y);
+    }
+
+    @Override
+    public boolean isEditing(JTree tree) {
+        return tree != null && tree.isEditing();
+    }
+
+    @Override
+    public boolean stopEditing(JTree tree) {
+        return tree != null && tree.stopEditing();
+    }
+
+    @Override
+    public void cancelEditing(JTree tree) {
+        if (tree != null) {
+            tree.cancelEditing();
+        }
+    }
+
+    @Override
+    public void startEditingAtPath(JTree tree, TreePath path) {
+        if (tree != null) {
+            tree.startEditingAtPath(path);
+        }
+    }
+
+    @Override
+    public TreePath getEditingPath(JTree tree) {
+        return tree == null ? null : tree.getEditingPath();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/package-info.java
new file mode 100644
index 00000000000..3020ab4d519
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/basic/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The few classes of the basic look and feel an application names
+/// directly, such as the default editor of an editable combo box. There are
+/// no UI delegates here: the widgets are drawn by Codename One.
+package com.codename1.desktopcompat.javax.swing.plaf.basic;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/DefaultMetalTheme.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/DefaultMetalTheme.java
new file mode 100644
index 00000000000..a75e43e0a4b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/DefaultMetalTheme.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.metal;
+
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.plaf.ColorUIResource;
+import com.codename1.desktopcompat.javax.swing.plaf.FontUIResource;
+
+/// The theme called "Steel": the blue-violet and gray of the first Metal.
+public class DefaultMetalTheme extends MetalTheme {
+
+    private static final ColorUIResource PRIMARY1 = new ColorUIResource(102, 102, 153);
+    private static final ColorUIResource PRIMARY2 = new ColorUIResource(153, 153, 204);
+    private static final ColorUIResource PRIMARY3 = new ColorUIResource(204, 204, 255);
+    private static final ColorUIResource SECONDARY1 = new ColorUIResource(102, 102, 102);
+    private static final ColorUIResource SECONDARY2 = new ColorUIResource(153, 153, 153);
+    private static final ColorUIResource SECONDARY3 = new ColorUIResource(204, 204, 204);
+
+    public DefaultMetalTheme() {
+    }
+
+    @Override
+    public String getName() {
+        return "Steel";
+    }
+
+    @Override
+    protected ColorUIResource getPrimary1() {
+        return PRIMARY1;
+    }
+
+    @Override
+    protected ColorUIResource getPrimary2() {
+        return PRIMARY2;
+    }
+
+    @Override
+    protected ColorUIResource getPrimary3() {
+        return PRIMARY3;
+    }
+
+    @Override
+    protected ColorUIResource getSecondary1() {
+        return SECONDARY1;
+    }
+
+    @Override
+    protected ColorUIResource getSecondary2() {
+        return SECONDARY2;
+    }
+
+    @Override
+    protected ColorUIResource getSecondary3() {
+        return SECONDARY3;
+    }
+
+    @Override
+    public FontUIResource getControlTextFont() {
+        return new FontUIResource("Dialog", Font.BOLD, 12);
+    }
+
+    @Override
+    public FontUIResource getSystemTextFont() {
+        return new FontUIResource("Dialog", Font.PLAIN, 12);
+    }
+
+    @Override
+    public FontUIResource getUserTextFont() {
+        return new FontUIResource("Dialog", Font.PLAIN, 12);
+    }
+
+    @Override
+    public FontUIResource getMenuTextFont() {
+        return new FontUIResource("Dialog", Font.BOLD, 12);
+    }
+
+    @Override
+    public FontUIResource getWindowTitleFont() {
+        return new FontUIResource("Dialog", Font.BOLD, 12);
+    }
+
+    @Override
+    public FontUIResource getSubTextFont() {
+        return new FontUIResource("Dialog", Font.PLAIN, 10);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/MetalLookAndFeel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/MetalLookAndFeel.java
new file mode 100644
index 00000000000..d16db71be53
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/MetalLookAndFeel.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.metal;
+
+import com.codename1.desktopcompat.javax.swing.LookAndFeel;
+
+/// The Metal look and feel, as far as a program names it: its identity and
+/// its current theme.
+///
+/// It is not the look and feel of this layer and it does not draw: see the
+/// package description. A theme set here is answered by
+/// [#getCurrentTheme()] and changes no component.
+public class MetalLookAndFeel extends LookAndFeel {
+
+    private static MetalTheme currentTheme = new OceanTheme();
+
+    public MetalLookAndFeel() {
+    }
+
+    @Override
+    public String getName() {
+        return "Metal";
+    }
+
+    @Override
+    public String getID() {
+        return "Metal";
+    }
+
+    @Override
+    public String getDescription() {
+        return "The Java(tm) Look and Feel";
+    }
+
+    @Override
+    public boolean isNativeLookAndFeel() {
+        return false;
+    }
+
+    @Override
+    public boolean isSupportedLookAndFeel() {
+        return true;
+    }
+
+    public static void setCurrentTheme(MetalTheme theme) {
+        if (theme == null) {
+            throw new NullPointerException("Can't have null theme");
+        }
+        currentTheme = theme;
+    }
+
+    public static MetalTheme getCurrentTheme() {
+        return currentTheme;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/MetalTheme.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/MetalTheme.java
new file mode 100644
index 00000000000..f3baab4d04c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/MetalTheme.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.metal;
+
+import com.codename1.desktopcompat.javax.swing.UIDefaults;
+import com.codename1.desktopcompat.javax.swing.plaf.ColorUIResource;
+import com.codename1.desktopcompat.javax.swing.plaf.FontUIResource;
+
+/// The colors and fonts of the Metal look and feel, each derived from
+/// three primary and three secondary colors unless a theme says
+/// otherwise.
+public abstract class MetalTheme {
+
+    private static final ColorUIResource WHITE = new ColorUIResource(255, 255, 255);
+
+    private static final ColorUIResource BLACK = new ColorUIResource(0, 0, 0);
+
+    public abstract String getName();
+
+    protected abstract ColorUIResource getPrimary1();
+
+    protected abstract ColorUIResource getPrimary2();
+
+    protected abstract ColorUIResource getPrimary3();
+
+    protected abstract ColorUIResource getSecondary1();
+
+    protected abstract ColorUIResource getSecondary2();
+
+    protected abstract ColorUIResource getSecondary3();
+
+    public abstract FontUIResource getControlTextFont();
+
+    public abstract FontUIResource getSystemTextFont();
+
+    public abstract FontUIResource getUserTextFont();
+
+    public abstract FontUIResource getMenuTextFont();
+
+    public abstract FontUIResource getWindowTitleFont();
+
+    public abstract FontUIResource getSubTextFont();
+
+    protected ColorUIResource getWhite() {
+        return WHITE;
+    }
+
+    protected ColorUIResource getBlack() {
+        return BLACK;
+    }
+
+    public ColorUIResource getFocusColor() {
+        return getPrimary2();
+    }
+
+    public ColorUIResource getDesktopColor() {
+        return getPrimary2();
+    }
+
+    public ColorUIResource getControl() {
+        return getSecondary3();
+    }
+
+    public ColorUIResource getControlShadow() {
+        return getSecondary2();
+    }
+
+    public ColorUIResource getControlDarkShadow() {
+        return getSecondary1();
+    }
+
+    public ColorUIResource getControlInfo() {
+        return getBlack();
+    }
+
+    public ColorUIResource getControlHighlight() {
+        return getWhite();
+    }
+
+    public ColorUIResource getControlDisabled() {
+        return getSecondary2();
+    }
+
+    public ColorUIResource getPrimaryControl() {
+        return getPrimary3();
+    }
+
+    public ColorUIResource getPrimaryControlShadow() {
+        return getPrimary2();
+    }
+
+    public ColorUIResource getPrimaryControlDarkShadow() {
+        return getPrimary1();
+    }
+
+    public ColorUIResource getPrimaryControlInfo() {
+        return getBlack();
+    }
+
+    public ColorUIResource getPrimaryControlHighlight() {
+        return getWhite();
+    }
+
+    public ColorUIResource getSystemTextColor() {
+        return getBlack();
+    }
+
+    public ColorUIResource getControlTextColor() {
+        return getControlInfo();
+    }
+
+    public ColorUIResource getInactiveControlTextColor() {
+        return getControlDisabled();
+    }
+
+    public ColorUIResource getInactiveSystemTextColor() {
+        return getSecondary2();
+    }
+
+    public ColorUIResource getUserTextColor() {
+        return getBlack();
+    }
+
+    public ColorUIResource getTextHighlightColor() {
+        return getPrimary3();
+    }
+
+    public ColorUIResource getHighlightedTextColor() {
+        return getControlTextColor();
+    }
+
+    public ColorUIResource getWindowBackground() {
+        return getWhite();
+    }
+
+    public ColorUIResource getWindowTitleBackground() {
+        return getPrimary3();
+    }
+
+    public ColorUIResource getWindowTitleForeground() {
+        return getBlack();
+    }
+
+    public ColorUIResource getWindowTitleInactiveBackground() {
+        return getSecondary3();
+    }
+
+    public ColorUIResource getWindowTitleInactiveForeground() {
+        return getBlack();
+    }
+
+    public ColorUIResource getMenuBackground() {
+        return getSecondary3();
+    }
+
+    public ColorUIResource getMenuForeground() {
+        return getBlack();
+    }
+
+    public ColorUIResource getMenuSelectedBackground() {
+        return getPrimary2();
+    }
+
+    public ColorUIResource getMenuSelectedForeground() {
+        return getBlack();
+    }
+
+    public ColorUIResource getMenuDisabledForeground() {
+        return getSecondary2();
+    }
+
+    public ColorUIResource getSeparatorBackground() {
+        return getWhite();
+    }
+
+    public ColorUIResource getSeparatorForeground() {
+        return getPrimary1();
+    }
+
+    public ColorUIResource getAcceleratorForeground() {
+        return getPrimary1();
+    }
+
+    public ColorUIResource getAcceleratorSelectedForeground() {
+        return getBlack();
+    }
+
+    /// Where a theme adds its own entries to the defaults of the Metal
+    /// look and feel. That look and feel is never installed here, so this
+    /// is not called by the layer.
+    public void addCustomEntriesToTable(UIDefaults table) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/OceanTheme.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/OceanTheme.java
new file mode 100644
index 00000000000..609b04aa190
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/OceanTheme.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.plaf.metal;
+
+import com.codename1.desktopcompat.javax.swing.plaf.ColorUIResource;
+
+/// The theme called "Ocean": the pale blue Metal.
+public class OceanTheme extends DefaultMetalTheme {
+
+    private static final ColorUIResource PRIMARY1 = new ColorUIResource(0x6382BF);
+    private static final ColorUIResource PRIMARY2 = new ColorUIResource(0xA3B8CC);
+    private static final ColorUIResource PRIMARY3 = new ColorUIResource(0xB8CFE5);
+    private static final ColorUIResource SECONDARY1 = new ColorUIResource(0x7A8A99);
+    private static final ColorUIResource SECONDARY2 = new ColorUIResource(0xB8CFE5);
+    private static final ColorUIResource SECONDARY3 = new ColorUIResource(0xEEEEEE);
+    private static final ColorUIResource CONTROL_TEXT_COLOR = new ColorUIResource(0x333333);
+    private static final ColorUIResource INACTIVE_CONTROL_TEXT_COLOR = new ColorUIResource(0x999999);
+    private static final ColorUIResource MENU_DISABLED_FOREGROUND = new ColorUIResource(0x999999);
+    private static final ColorUIResource OCEAN_BLACK = new ColorUIResource(0x333333);
+
+    public OceanTheme() {
+    }
+
+    @Override
+    public String getName() {
+        return "Ocean";
+    }
+
+    @Override
+    protected ColorUIResource getPrimary1() {
+        return PRIMARY1;
+    }
+
+    @Override
+    protected ColorUIResource getPrimary2() {
+        return PRIMARY2;
+    }
+
+    @Override
+    protected ColorUIResource getPrimary3() {
+        return PRIMARY3;
+    }
+
+    @Override
+    protected ColorUIResource getSecondary1() {
+        return SECONDARY1;
+    }
+
+    @Override
+    protected ColorUIResource getSecondary2() {
+        return SECONDARY2;
+    }
+
+    @Override
+    protected ColorUIResource getSecondary3() {
+        return SECONDARY3;
+    }
+
+    @Override
+    protected ColorUIResource getBlack() {
+        return OCEAN_BLACK;
+    }
+
+    @Override
+    public ColorUIResource getDesktopColor() {
+        return getWhite();
+    }
+
+    @Override
+    public ColorUIResource getInactiveControlTextColor() {
+        return INACTIVE_CONTROL_TEXT_COLOR;
+    }
+
+    @Override
+    public ColorUIResource getControlTextColor() {
+        return CONTROL_TEXT_COLOR;
+    }
+
+    @Override
+    public ColorUIResource getMenuDisabledForeground() {
+        return MENU_DISABLED_FOREGROUND;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/package-info.java
new file mode 100644
index 00000000000..8f81bc2a497
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/metal/package-info.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The Metal look and feel as data: its themes and the place the current
+/// one is kept.
+///
+/// The components of this layer are drawn by the Codename One theme. The
+/// look and feel the `UIManager` reports is that one, never Metal, so a
+/// Metal theme set here is the theme of a look and feel that is not
+/// installed: it is kept and answered and changes no component, exactly
+/// as setting it does on a desktop that runs another look and feel.
+package com.codename1.desktopcompat.javax.swing.plaf.metal;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/package-info.java
new file mode 100644
index 00000000000..39df00c1755
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/plaf/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The marker types of `javax.swing.plaf`: a color, a font or a border
+/// that a look and feel installed, as opposed to one the application set.
+///
+/// The components of this layer are drawn by the Codename One theme and
+/// have no UI delegates, so nothing here installs or replaces these
+/// values; the types exist so that a program can make them, keep them in
+/// the `UIManager` table and test for them.
+package com.codename1.desktopcompat.javax.swing.plaf;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/AbstractTableModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/AbstractTableModel.java
new file mode 100644
index 00000000000..dd178e3106e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/AbstractTableModel.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.TableModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableModelListener;
+import java.util.EventListener;
+
+/// A table model with the listeners and the events done: a subclass
+/// supplies the row count, the column count and the values.
+public abstract class AbstractTableModel implements TableModel {
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    public AbstractTableModel() {
+    }
+
+    /// Spreadsheet names: A to Z, then AA, AB and so on.
+    @Override
+    public String getColumnName(int column) {
+        StringBuilder sb = new StringBuilder();
+        for (int c = column; c >= 0; c = c / 26 - 1) {
+            sb.insert(0, (char) ('A' + c % 26));
+        }
+        return sb.toString();
+    }
+
+    public int findColumn(String columnName) {
+        for (int i = 0; i < getColumnCount(); i++) {
+            if (columnName.equals(getColumnName(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public Class<?> getColumnClass(int columnIndex) {
+        return Object.class;
+    }
+
+    @Override
+    public boolean isCellEditable(int rowIndex, int columnIndex) {
+        return false;
+    }
+
+    @Override
+    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
+    }
+
+    @Override
+    public void addTableModelListener(TableModelListener l) {
+        listenerList.add(TableModelListener.class, l);
+    }
+
+    @Override
+    public void removeTableModelListener(TableModelListener l) {
+        listenerList.remove(TableModelListener.class, l);
+    }
+
+    public TableModelListener[] getTableModelListeners() {
+        return listenerList.getListeners(TableModelListener.class);
+    }
+
+    public void fireTableDataChanged() {
+        fireTableChanged(new TableModelEvent(this));
+    }
+
+    public void fireTableStructureChanged() {
+        fireTableChanged(new TableModelEvent(this, TableModelEvent.HEADER_ROW));
+    }
+
+    public void fireTableRowsInserted(int firstRow, int lastRow) {
+        fireTableChanged(new TableModelEvent(this, firstRow, lastRow, TableModelEvent.ALL_COLUMNS,
+                TableModelEvent.INSERT));
+    }
+
+    public void fireTableRowsUpdated(int firstRow, int lastRow) {
+        fireTableChanged(new TableModelEvent(this, firstRow, lastRow, TableModelEvent.ALL_COLUMNS,
+                TableModelEvent.UPDATE));
+    }
+
+    public void fireTableRowsDeleted(int firstRow, int lastRow) {
+        fireTableChanged(new TableModelEvent(this, firstRow, lastRow, TableModelEvent.ALL_COLUMNS,
+                TableModelEvent.DELETE));
+    }
+
+    public void fireTableCellUpdated(int row, int column) {
+        fireTableChanged(new TableModelEvent(this, row, row, column));
+    }
+
+    public void fireTableChanged(TableModelEvent e) {
+        TableModelListener[] ls = getTableModelListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].tableChanged(e);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableCellRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableCellRenderer.java
new file mode 100644
index 00000000000..8c1ff400183
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableCellRenderer.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+import com.codename1.desktopcompat.javax.swing.border.LineBorder;
+import com.codename1.desktopcompat.rt.CellTheme;
+
+/// The renderer of table cells: a label, and so a Codename One label,
+/// showing the value's string in the table's colors -- the selection
+/// colors for a selected cell -- with a line around the cell that has the
+/// focus.
+///
+/// One renderer paints every cell of its kind, so the methods that would
+/// lay out or repaint a real component do nothing here. A subclass
+/// changes what is shown by overriding [#setValue(Object)], or
+/// `paintComponent` to draw the cell itself.
+public class DefaultTableCellRenderer extends JLabel implements TableCellRenderer {
+
+    protected static Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);
+
+    private Color unselectedForeground;
+    private Color unselectedBackground;
+    private Border focusBorder;
+    private Color focusColor;
+
+    public DefaultTableCellRenderer() {
+        super();
+        setOpaque(true);
+        setBorder(noFocusBorder);
+        setName("Table.cellRenderer");
+    }
+
+    /// Sets the text color of unselected cells.
+    @Override
+    public void setForeground(Color c) {
+        super.setForeground(c);
+        unselectedForeground = c;
+    }
+
+    /// Sets the background of unselected cells.
+    @Override
+    public void setBackground(Color c) {
+        super.setBackground(c);
+        unselectedBackground = c;
+    }
+
+    @Override
+    public void updateUI() {
+        super.updateUI();
+        setForeground(null);
+        setBackground(null);
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    @Override
+    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+            int row, int column) {
+        if (table == null) {
+            setValue(value);
+            return this;
+        }
+        Color fg;
+        Color bg;
+        JTable.DropLocation drop = table.getDropLocation();
+        if (drop != null && !drop.isInsertRow() && !drop.isInsertColumn() && drop.getRow() == row
+                && drop.getColumn() == column) {
+            // The cell a drag would be dropped on is drawn as a selected one.
+            isSelected = true;
+        }
+        if (isSelected) {
+            fg = table.getSelectionForeground();
+            bg = table.getSelectionBackground();
+        } else {
+            fg = unselectedForeground != null ? unselectedForeground : table.getForeground();
+            bg = unselectedBackground != null ? unselectedBackground : table.getBackground();
+        }
+        // Each of these reaches the Codename One label's style, so none is
+        // repeated for a cell that looks like the one before it.
+        if (!same(fg, isForegroundSet() ? getForeground() : null)) {
+            super.setForeground(fg);
+        }
+        if (!same(bg, isBackgroundSet() ? getBackground() : null)) {
+            super.setBackground(bg);
+        }
+        Font f = table.getFont();
+        if (!same(f, isFontSet() ? getFont() : null)) {
+            setFont(f);
+        }
+        if (hasFocus) {
+            Color line = fg != null && bg != null ? CellTheme.mix(bg, fg, 0.6f) : Color.GRAY;
+            if (focusBorder == null || !line.equals(focusColor)) {
+                focusColor = line;
+                focusBorder = new LineBorder(line, 1);
+            }
+            setBorder(focusBorder);
+        } else {
+            setBorder(noFocusBorder);
+        }
+        setValue(value);
+        return this;
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void invalidate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void validate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void revalidate() {
+    }
+
+    /// Does nothing: the table paints the renderer when it paints itself.
+    @Override
+    public void repaint(long tm, int x, int y, int width, int height) {
+    }
+
+    /// Does nothing: the table paints the renderer when it paints itself.
+    @Override
+    public void repaint(Rectangle r) {
+    }
+
+    /// Does nothing: the table paints the renderer when it paints itself.
+    @Override
+    public void repaint() {
+    }
+
+    /// Does nothing: nobody listens to a renderer's properties.
+    @Override
+    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+    }
+
+    /// Does nothing: nobody listens to a renderer's properties.
+    @Override
+    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+    }
+
+    /// Shows the value: its string, or nothing for `null`.
+    protected void setValue(Object value) {
+        setText(value == null ? "" : value.toString());
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableColumnModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableColumnModel.java
new file mode 100644
index 00000000000..7f9abafcceb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableColumnModel.java
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.DefaultListSelectionModel;
+import com.codename1.desktopcompat.javax.swing.ListSelectionModel;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+import java.util.Enumeration;
+import java.util.EventListener;
+import java.util.Vector;
+
+/// The usual column model: a vector of columns and a list selection model.
+public class DefaultTableColumnModel
+        implements TableColumnModel, PropertyChangeListener, ListSelectionListener {
+
+    protected Vector<TableColumn> tableColumns = new Vector<TableColumn>();
+    protected ListSelectionModel selectionModel;
+    protected int columnMargin = 1;
+    protected EventListenerList listenerList = new EventListenerList();
+    protected transient ChangeEvent changeEvent;
+    protected boolean columnSelectionAllowed;
+    protected int totalColumnWidth = -1;
+
+    public DefaultTableColumnModel() {
+        setSelectionModel(createSelectionModel());
+    }
+
+    @Override
+    public void addColumn(TableColumn aColumn) {
+        if (aColumn == null) {
+            throw new IllegalArgumentException("Object is null");
+        }
+        tableColumns.addElement(aColumn);
+        aColumn.addPropertyChangeListener(this);
+        totalColumnWidth = -1;
+        fireColumnAdded(new TableColumnModelEvent(this, 0, getColumnCount() - 1));
+    }
+
+    @Override
+    public void removeColumn(TableColumn column) {
+        int index = tableColumns.indexOf(column);
+        if (index < 0) {
+            return;
+        }
+        if (selectionModel != null) {
+            selectionModel.removeIndexInterval(index, index);
+        }
+        column.removePropertyChangeListener(this);
+        tableColumns.removeElementAt(index);
+        totalColumnWidth = -1;
+        fireColumnRemoved(new TableColumnModelEvent(this, index, 0));
+    }
+
+    @Override
+    public void moveColumn(int columnIndex, int newIndex) {
+        int n = getColumnCount();
+        if (columnIndex < 0 || columnIndex >= n || newIndex < 0 || newIndex >= n) {
+            throw new IllegalArgumentException("moveColumn() - Index out of range");
+        }
+        if (columnIndex != newIndex) {
+            TableColumn c = tableColumns.elementAt(columnIndex);
+            tableColumns.removeElementAt(columnIndex);
+            boolean selected = selectionModel.isSelectedIndex(columnIndex);
+            selectionModel.removeIndexInterval(columnIndex, columnIndex);
+            tableColumns.insertElementAt(c, newIndex);
+            selectionModel.insertIndexInterval(newIndex, 1, true);
+            if (selected) {
+                selectionModel.addSelectionInterval(newIndex, newIndex);
+            } else {
+                selectionModel.removeSelectionInterval(newIndex, newIndex);
+            }
+        }
+        fireColumnMoved(new TableColumnModelEvent(this, columnIndex, newIndex));
+    }
+
+    @Override
+    public void setColumnMargin(int newMargin) {
+        if (newMargin != columnMargin) {
+            columnMargin = newMargin;
+            fireColumnMarginChanged();
+        }
+    }
+
+    @Override
+    public int getColumnCount() {
+        return tableColumns.size();
+    }
+
+    @Override
+    public Enumeration<TableColumn> getColumns() {
+        return tableColumns.elements();
+    }
+
+    @Override
+    public int getColumnIndex(Object identifier) {
+        if (identifier == null) {
+            throw new IllegalArgumentException("Identifier is null");
+        }
+        for (int i = 0; i < tableColumns.size(); i++) {
+            if (identifier.equals(tableColumns.elementAt(i).getIdentifier())) {
+                return i;
+            }
+        }
+        throw new IllegalArgumentException("Identifier not found");
+    }
+
+    @Override
+    public TableColumn getColumn(int columnIndex) {
+        return tableColumns.elementAt(columnIndex);
+    }
+
+    @Override
+    public int getColumnMargin() {
+        return columnMargin;
+    }
+
+    @Override
+    public int getColumnIndexAtX(int x) {
+        if (x < 0) {
+            return -1;
+        }
+        int right = 0;
+        for (int i = 0; i < tableColumns.size(); i++) {
+            right += tableColumns.elementAt(i).getWidth();
+            if (x < right) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public int getTotalColumnWidth() {
+        if (totalColumnWidth < 0) {
+            recalcWidthCache();
+        }
+        return totalColumnWidth;
+    }
+
+    @Override
+    public void setSelectionModel(ListSelectionModel newModel) {
+        if (newModel == null) {
+            throw new IllegalArgumentException("Cannot set a null SelectionModel");
+        }
+        if (newModel != selectionModel) {
+            if (selectionModel != null) {
+                selectionModel.removeListSelectionListener(this);
+            }
+            selectionModel = newModel;
+            newModel.addListSelectionListener(this);
+        }
+    }
+
+    @Override
+    public ListSelectionModel getSelectionModel() {
+        return selectionModel;
+    }
+
+    @Override
+    public void setColumnSelectionAllowed(boolean flag) {
+        columnSelectionAllowed = flag;
+    }
+
+    @Override
+    public boolean getColumnSelectionAllowed() {
+        return columnSelectionAllowed;
+    }
+
+    @Override
+    public int[] getSelectedColumns() {
+        int n = getSelectedColumnCount();
+        int[] out = new int[n];
+        if (n > 0) {
+            int at = 0;
+            int max = selectionModel.getMaxSelectionIndex();
+            for (int i = selectionModel.getMinSelectionIndex(); i <= max; i++) {
+                if (selectionModel.isSelectedIndex(i)) {
+                    out[at++] = i;
+                }
+            }
+        }
+        return out;
+    }
+
+    @Override
+    public int getSelectedColumnCount() {
+        if (selectionModel == null) {
+            return 0;
+        }
+        int min = selectionModel.getMinSelectionIndex();
+        int max = selectionModel.getMaxSelectionIndex();
+        int count = 0;
+        if (min >= 0) {
+            for (int i = min; i <= max; i++) {
+                if (selectionModel.isSelectedIndex(i)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    @Override
+    public void addColumnModelListener(TableColumnModelListener x) {
+        listenerList.add(TableColumnModelListener.class, x);
+    }
+
+    @Override
+    public void removeColumnModelListener(TableColumnModelListener x) {
+        listenerList.remove(TableColumnModelListener.class, x);
+    }
+
+    public TableColumnModelListener[] getColumnModelListeners() {
+        return listenerList.getListeners(TableColumnModelListener.class);
+    }
+
+    protected void fireColumnAdded(TableColumnModelEvent e) {
+        TableColumnModelListener[] ls = getColumnModelListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].columnAdded(e);
+        }
+    }
+
+    protected void fireColumnRemoved(TableColumnModelEvent e) {
+        TableColumnModelListener[] ls = getColumnModelListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].columnRemoved(e);
+        }
+    }
+
+    protected void fireColumnMoved(TableColumnModelEvent e) {
+        TableColumnModelListener[] ls = getColumnModelListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].columnMoved(e);
+        }
+    }
+
+    protected void fireColumnSelectionChanged(ListSelectionEvent e) {
+        TableColumnModelListener[] ls = getColumnModelListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].columnSelectionChanged(e);
+        }
+    }
+
+    protected void fireColumnMarginChanged() {
+        TableColumnModelListener[] ls = getColumnModelListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        if (changeEvent == null) {
+            changeEvent = new ChangeEvent(this);
+        }
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].columnMarginChanged(changeEvent);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+
+    /// A column's width changed: the total is stale and the table must lay
+    /// its cells out again.
+    @Override
+    public void propertyChange(PropertyChangeEvent evt) {
+        String name = evt.getPropertyName();
+        if ("width".equals(name) || "preferredWidth".equals(name)) {
+            totalColumnWidth = -1;
+            fireColumnMarginChanged();
+        }
+    }
+
+    @Override
+    public void valueChanged(ListSelectionEvent e) {
+        fireColumnSelectionChanged(e);
+    }
+
+    protected ListSelectionModel createSelectionModel() {
+        return new DefaultListSelectionModel();
+    }
+
+    protected void recalcWidthCache() {
+        int total = 0;
+        for (int i = 0; i < tableColumns.size(); i++) {
+            total += tableColumns.elementAt(i).getWidth();
+        }
+        totalColumnWidth = total;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableModel.java
new file mode 100644
index 00000000000..4fc91bbea58
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/DefaultTableModel.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.javax.swing.event.TableModelEvent;
+import java.util.Vector;
+
+/// A table model that keeps its values in a vector of row vectors, and
+/// its column names in another. Every cell is editable.
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class DefaultTableModel extends AbstractTableModel {
+
+    protected Vector dataVector;
+    protected Vector columnIdentifiers;
+
+    public DefaultTableModel() {
+        this(0, 0);
+    }
+
+    public DefaultTableModel(int rowCount, int columnCount) {
+        this(sized(columnCount), rowCount);
+    }
+
+    public DefaultTableModel(Vector columnNames, int rowCount) {
+        setDataVector(sized(rowCount), columnNames);
+    }
+
+    public DefaultTableModel(Object[] columnNames, int rowCount) {
+        this(convertToVector(columnNames), rowCount);
+    }
+
+    public DefaultTableModel(Vector data, Vector columnNames) {
+        setDataVector(data, columnNames);
+    }
+
+    public DefaultTableModel(Object[][] data, Object[] columnNames) {
+        setDataVector(data, columnNames);
+    }
+
+    private static Vector sized(int size) {
+        Vector v = new Vector(size);
+        v.setSize(size);
+        return v;
+    }
+
+    private static Vector orEmpty(Vector v) {
+        return v != null ? v : new Vector();
+    }
+
+    /// The vector of row vectors itself, not a copy.
+    public Vector getDataVector() {
+        return dataVector;
+    }
+
+    public void setDataVector(Vector dataVector, Vector columnIdentifiers) {
+        this.dataVector = orEmpty(dataVector);
+        this.columnIdentifiers = orEmpty(columnIdentifiers);
+        justifyRows(0, getRowCount());
+        fireTableStructureChanged();
+    }
+
+    public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) {
+        setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers));
+    }
+
+    public void newDataAvailable(TableModelEvent event) {
+        fireTableChanged(event);
+    }
+
+    /// Gives every row from `from` up to `to` a vector exactly as long as
+    /// there are columns.
+    private void justifyRows(int from, int to) {
+        dataVector.setSize(getRowCount());
+        for (int i = from; i < to; i++) {
+            Object row = dataVector.elementAt(i);
+            if (!(row instanceof Vector)) {
+                row = new Vector();
+                dataVector.setElementAt(row, i);
+            }
+            ((Vector) row).setSize(getColumnCount());
+        }
+    }
+
+    public void newRowsAdded(TableModelEvent e) {
+        justifyRows(e.getFirstRow(), e.getLastRow() + 1);
+        fireTableChanged(e);
+    }
+
+    public void rowsRemoved(TableModelEvent event) {
+        fireTableChanged(event);
+    }
+
+    public void setNumRows(int rowCount) {
+        int old = getRowCount();
+        if (old == rowCount) {
+            return;
+        }
+        dataVector.setSize(rowCount);
+        if (rowCount <= old) {
+            fireTableRowsDeleted(rowCount, old - 1);
+        } else {
+            justifyRows(old, rowCount);
+            fireTableRowsInserted(old, rowCount - 1);
+        }
+    }
+
+    public void setRowCount(int rowCount) {
+        setNumRows(rowCount);
+    }
+
+    public void addRow(Vector rowData) {
+        insertRow(getRowCount(), rowData);
+    }
+
+    public void addRow(Object[] rowData) {
+        addRow(convertToVector(rowData));
+    }
+
+    public void insertRow(int row, Vector rowData) {
+        dataVector.insertElementAt(rowData, row);
+        justifyRows(row, row + 1);
+        fireTableRowsInserted(row, row);
+    }
+
+    public void insertRow(int row, Object[] rowData) {
+        insertRow(row, convertToVector(rowData));
+    }
+
+    /// Moves the rows `start` to `end` so that the first of them ends up
+    /// at `to`.
+    public void moveRow(int start, int end, int to) {
+        int count = end - start + 1;
+        int size = getRowCount();
+        if (start < 0 || end >= size || count <= 0 || to < 0 || to + count > size) {
+            throw new ArrayIndexOutOfBoundsException("moveRow " + start + ".." + end + " to " + to);
+        }
+        if (to == start) {
+            return;
+        }
+        Object[] moved = new Object[count];
+        for (int i = 0; i < count; i++) {
+            moved[i] = dataVector.elementAt(start);
+            dataVector.removeElementAt(start);
+        }
+        for (int i = 0; i < count; i++) {
+            dataVector.insertElementAt(moved[i], to + i);
+        }
+        fireTableRowsUpdated(Math.min(start, to), Math.max(end, to + count - 1));
+    }
+
+    public void removeRow(int row) {
+        dataVector.removeElementAt(row);
+        fireTableRowsDeleted(row, row);
+    }
+
+    public void setColumnIdentifiers(Vector columnIdentifiers) {
+        setDataVector(dataVector, columnIdentifiers);
+    }
+
+    public void setColumnIdentifiers(Object[] newIdentifiers) {
+        setColumnIdentifiers(convertToVector(newIdentifiers));
+    }
+
+    public void setColumnCount(int columnCount) {
+        columnIdentifiers.setSize(columnCount);
+        justifyRows(0, getRowCount());
+        fireTableStructureChanged();
+    }
+
+    public void addColumn(Object columnName) {
+        addColumn(columnName, (Vector) null);
+    }
+
+    public void addColumn(Object columnName, Vector columnData) {
+        columnIdentifiers.addElement(columnName);
+        if (columnData != null) {
+            int n = columnData.size();
+            if (n > getRowCount()) {
+                dataVector.setSize(n);
+            }
+            justifyRows(0, getRowCount());
+            int column = getColumnCount() - 1;
+            for (int i = 0; i < n; i++) {
+                ((Vector) dataVector.elementAt(i)).setElementAt(columnData.elementAt(i), column);
+            }
+        } else {
+            justifyRows(0, getRowCount());
+        }
+        fireTableStructureChanged();
+    }
+
+    public void addColumn(Object columnName, Object[] columnData) {
+        addColumn(columnName, convertToVector(columnData));
+    }
+
+    @Override
+    public int getRowCount() {
+        return dataVector.size();
+    }
+
+    @Override
+    public int getColumnCount() {
+        return columnIdentifiers.size();
+    }
+
+    @Override
+    public String getColumnName(int column) {
+        Object id = column >= 0 && column < columnIdentifiers.size() ? columnIdentifiers.elementAt(column) : null;
+        return id == null ? super.getColumnName(column) : id.toString();
+    }
+
+    @Override
+    public boolean isCellEditable(int row, int column) {
+        return true;
+    }
+
+    @Override
+    public Object getValueAt(int row, int column) {
+        Object r = dataVector.elementAt(row);
+        return r instanceof Vector ? ((Vector) r).elementAt(column) : null;
+    }
+
+    @Override
+    public void setValueAt(Object aValue, int row, int column) {
+        Object r = dataVector.elementAt(row);
+        if (r instanceof Vector) {
+            ((Vector) r).setElementAt(aValue, column);
+            fireTableCellUpdated(row, column);
+        }
+    }
+
+    protected static Vector convertToVector(Object[] anArray) {
+        if (anArray == null) {
+            return null;
+        }
+        Vector v = new Vector(anArray.length);
+        for (int i = 0; i < anArray.length; i++) {
+            v.addElement(anArray[i]);
+        }
+        return v;
+    }
+
+    protected static Vector convertToVector(Object[][] anArray) {
+        if (anArray == null) {
+            return null;
+        }
+        Vector v = new Vector(anArray.length);
+        for (int i = 0; i < anArray.length; i++) {
+            v.addElement(convertToVector(anArray[i]));
+        }
+        return v;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/JTableHeader.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/JTableHeader.java
new file mode 100644
index 00000000000..c8f8ef35ead
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/JTableHeader.java
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+import com.codename1.desktopcompat.rt.CellPainter;
+import com.codename1.desktopcompat.rt.CellTheme;
+import java.util.List;
+
+/// The row of column titles above a table.
+///
+/// A click on a title sorts by that column when the table has a row
+/// sorter, and an arrow shows the direction. A drag that starts on the
+/// line between two titles resizes the column before it; a drag that
+/// starts on a title moves the column. The header paints itself the way
+/// the table does, with a renderer per column.
+public class JTableHeader extends JComponent implements Accessible, TableColumnModelListener {
+
+    protected JTable table;
+    protected TableColumnModel columnModel;
+    protected boolean reorderingAllowed;
+    protected boolean resizingAllowed;
+    protected boolean updateTableInRealTime;
+    protected transient TableColumn resizingColumn;
+    protected transient TableColumn draggedColumn;
+    protected transient int draggedDistance;
+
+    private TableCellRenderer defaultRenderer;
+    private int pressX;
+    private int pressWidth;
+    private int pressIndex = -1;
+    private boolean pressOnLine;
+    private boolean moved;
+
+    public JTableHeader() {
+        this(null);
+    }
+
+    public JTableHeader(TableColumnModel cm) {
+        setLayout(null);
+        setColumnModel(cm != null ? cm : createDefaultColumnModel());
+        initializeLocalVars();
+    }
+
+    protected TableColumnModel createDefaultColumnModel() {
+        return new DefaultTableColumnModel();
+    }
+
+    protected TableCellRenderer createDefaultRenderer() {
+        return new TitleRenderer();
+    }
+
+    protected void initializeLocalVars() {
+        setOpaque(true);
+        table = null;
+        reorderingAllowed = true;
+        resizingAllowed = true;
+        draggedColumn = null;
+        draggedDistance = 0;
+        resizingColumn = null;
+        updateTableInRealTime = true;
+        setBackground(CellTheme.headerBackground("TableHeader.background"));
+        setForeground(CellTheme.headerForeground("TableHeader.foreground"));
+        setFont(CellTheme.headerFont());
+        setDefaultRenderer(createDefaultRenderer());
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
+    }
+
+    public void setTable(JTable table) {
+        JTable old = this.table;
+        this.table = table;
+        firePropertyChange("table", old, table);
+    }
+
+    public JTable getTable() {
+        return table;
+    }
+
+    public void setReorderingAllowed(boolean reorderingAllowed) {
+        boolean old = this.reorderingAllowed;
+        this.reorderingAllowed = reorderingAllowed;
+        firePropertyChange("reorderingAllowed", old, reorderingAllowed);
+    }
+
+    public boolean getReorderingAllowed() {
+        return reorderingAllowed;
+    }
+
+    public void setResizingAllowed(boolean resizingAllowed) {
+        boolean old = this.resizingAllowed;
+        this.resizingAllowed = resizingAllowed;
+        firePropertyChange("resizingAllowed", old, resizingAllowed);
+    }
+
+    public boolean getResizingAllowed() {
+        return resizingAllowed;
+    }
+
+    public TableColumn getDraggedColumn() {
+        return draggedColumn;
+    }
+
+    public int getDraggedDistance() {
+        return draggedDistance;
+    }
+
+    public TableColumn getResizingColumn() {
+        return resizingColumn;
+    }
+
+    public void setUpdateTableInRealTime(boolean flag) {
+        updateTableInRealTime = flag;
+    }
+
+    public boolean getUpdateTableInRealTime() {
+        return updateTableInRealTime;
+    }
+
+    public void setDefaultRenderer(TableCellRenderer defaultRenderer) {
+        this.defaultRenderer = defaultRenderer;
+    }
+
+    public TableCellRenderer getDefaultRenderer() {
+        return defaultRenderer;
+    }
+
+    public int columnAtPoint(Point point) {
+        if (point.y < 0 || point.y >= getHeight()) {
+            return -1;
+        }
+        return getColumnModel().getColumnIndexAtX(point.x);
+    }
+
+    public Rectangle getHeaderRect(int column) {
+        Rectangle r = new Rectangle();
+        TableColumnModel cm = getColumnModel();
+        r.height = getHeight();
+        if (column < 0) {
+            return r;
+        }
+        if (column >= cm.getColumnCount()) {
+            r.x = getWidth();
+            return r;
+        }
+        for (int i = 0; i < column; i++) {
+            r.x += cm.getColumn(i).getWidth();
+        }
+        r.width = cm.getColumn(column).getWidth();
+        return r;
+    }
+
+    public void setColumnModel(TableColumnModel columnModel) {
+        if (columnModel == null) {
+            throw new IllegalArgumentException("Cannot set a null ColumnModel");
+        }
+        TableColumnModel old = this.columnModel;
+        if (columnModel != old) {
+            if (old != null) {
+                old.removeColumnModelListener(this);
+            }
+            this.columnModel = columnModel;
+            columnModel.addColumnModelListener(this);
+            firePropertyChange("columnModel", old, columnModel);
+            resizeAndRepaint();
+        }
+    }
+
+    public TableColumnModel getColumnModel() {
+        return columnModel;
+    }
+
+    @Override
+    public void columnAdded(TableColumnModelEvent e) {
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnRemoved(TableColumnModelEvent e) {
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnMoved(TableColumnModelEvent e) {
+        repaint();
+    }
+
+    @Override
+    public void columnMarginChanged(ChangeEvent e) {
+        resizeAndRepaint();
+    }
+
+    @Override
+    public void columnSelectionChanged(ListSelectionEvent e) {
+    }
+
+    public void resizeAndRepaint() {
+        revalidate();
+        repaint();
+    }
+
+    public void setDraggedColumn(TableColumn aColumn) {
+        draggedColumn = aColumn;
+    }
+
+    public void setDraggedDistance(int distance) {
+        draggedDistance = distance;
+    }
+
+    public void setResizingColumn(TableColumn aColumn) {
+        resizingColumn = aColumn;
+    }
+
+    /// As wide as the columns, and one row of title text high: sized for
+    /// a finger on a touch screen.
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        TableColumnModel cm = getColumnModel();
+        long w = 0;
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            w += cm.getColumn(i).getPreferredWidth();
+        }
+        return new Dimension((int) Math.min(w, Integer.MAX_VALUE), CellTheme.rowHeight(getFont(), 20, 32));
+    }
+
+    // ------------------------------------------------------------ paint
+
+    private SortOrder sortOrderOf(int viewColumn) {
+        if (table == null || table.getRowSorter() == null) {
+            return SortOrder.UNSORTED;
+        }
+        List<? extends RowSorter.SortKey> keys = table.getRowSorter().getSortKeys();
+        if (keys == null || keys.isEmpty()) {
+            return SortOrder.UNSORTED;
+        }
+        RowSorter.SortKey first = keys.get(0);
+        return first.getColumn() == getColumnModel().getColumn(viewColumn).getModelIndex()
+                ? first.getSortOrder() : SortOrder.UNSORTED;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        Rectangle clip = g.getClipBounds();
+        if (clip == null) {
+            clip = new Rectangle(0, 0, getWidth(), getHeight());
+        }
+        Color bg = getBackground();
+        if (isOpaque() && bg != null) {
+            g.setColor(bg);
+            g.fillRect(clip.x, clip.y, clip.width, clip.height);
+        }
+        TableColumnModel cm = getColumnModel();
+        int h = getHeight();
+        Color fg = getForeground();
+        Color line = bg != null && fg != null ? CellTheme.mix(bg, fg, 0.25f) : Color.GRAY;
+        int x = 0;
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            TableColumn column = cm.getColumn(i);
+            int w = column.getWidth();
+            if (x + w > clip.x && x < clip.x + clip.width && w > 0) {
+                TableCellRenderer r = column.getHeaderRenderer();
+                if (r == null) {
+                    r = defaultRenderer;
+                }
+                if (r != null) {
+                    Component c = r.getTableCellRendererComponent(table, column.getHeaderValue(), false, false, -1, i);
+                    CellPainter.paint(g, c, x, 0, w - 1, h - 1);
+                }
+                SortOrder order = sortOrderOf(i);
+                if (order != SortOrder.UNSORTED && w > 16) {
+                    g.setColor(fg != null ? fg : Color.BLACK);
+                    int ax = x + w - 12;
+                    int ay = h / 2;
+                    int[] px = {ax, ax + 8, ax + 4};
+                    int[] py = order == SortOrder.ASCENDING ? new int[]{ay + 2, ay + 2, ay - 3}
+                            : new int[]{ay - 2, ay - 2, ay + 3};
+                    g.fillPolygon(px, py, 3);
+                }
+                g.setColor(line);
+                g.drawLine(x + w - 1, 0, x + w - 1, h - 1);
+            }
+            x += w;
+        }
+        g.setColor(line);
+        g.drawLine(clip.x, h - 1, clip.x + clip.width - 1, h - 1);
+    }
+
+    // ------------------------------------------------------------ pointer
+
+    /// The column whose trailing line is within reach of `x`, or -1.
+    private int lineAt(int x) {
+        int reach = CellTheme.touch() ? 10 : 4;
+        TableColumnModel cm = getColumnModel();
+        int right = 0;
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            right += cm.getColumn(i).getWidth();
+            if (Math.abs(x - right) <= reach) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private int indexOf(TableColumn c) {
+        TableColumnModel cm = getColumnModel();
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            if (cm.getColumn(i) == c) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        if (isEnabled()) {
+            switch (e.getID()) {
+                case MouseEvent.MOUSE_PRESSED:
+                    pressed(e);
+                    break;
+                case MouseEvent.MOUSE_RELEASED:
+                    released();
+                    break;
+                case MouseEvent.MOUSE_CLICKED:
+                    clicked(e);
+                    break;
+                default:
+                    break;
+            }
+        }
+        super.processMouseEvent(e);
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        if (isEnabled() && e.getID() == MouseEvent.MOUSE_DRAGGED) {
+            dragged(e);
+        }
+        super.processMouseMotionEvent(e);
+    }
+
+    private void pressed(MouseEvent e) {
+        pressX = e.getX();
+        moved = false;
+        pressOnLine = false;
+        pressIndex = -1;
+        resizingColumn = null;
+        draggedColumn = null;
+        draggedDistance = 0;
+        int line = resizingAllowed ? lineAt(e.getX()) : -1;
+        if (line >= 0 && getColumnModel().getColumn(line).getResizable()) {
+            pressOnLine = true;
+            resizingColumn = getColumnModel().getColumn(line);
+            pressWidth = resizingColumn.getWidth();
+            return;
+        }
+        pressIndex = columnAtPoint(new Point(e.getX(), Math.max(0, Math.min(e.getY(), getHeight() - 1))));
+    }
+
+    private void dragged(MouseEvent e) {
+        int dx = e.getX() - pressX;
+        if (resizingColumn != null) {
+            moved = true;
+            resizingColumn.setWidth(pressWidth + dx);
+            if (table != null) {
+                // Now, not on the next layout pass: the other columns
+                // must follow the one under the finger.
+                table.doLayout();
+                table.repaint();
+            }
+            repaint();
+            return;
+        }
+        if (!reorderingAllowed || pressIndex < 0) {
+            return;
+        }
+        if (draggedColumn == null) {
+            if (Math.abs(dx) < 6) {
+                return;
+            }
+            draggedColumn = getColumnModel().getColumn(pressIndex);
+        }
+        moved = true;
+        draggedDistance = dx;
+        int from = indexOf(draggedColumn);
+        int to = getColumnModel().getColumnIndexAtX(Math.max(0, e.getX()));
+        if (from >= 0 && to >= 0 && to != from) {
+            getColumnModel().moveColumn(from, to);
+        }
+        repaint();
+    }
+
+    private void released() {
+        boolean was = resizingColumn != null || draggedColumn != null;
+        resizingColumn = null;
+        draggedColumn = null;
+        draggedDistance = 0;
+        if (was) {
+            resizeAndRepaint();
+            if (table != null) {
+                table.repaint();
+            }
+        }
+    }
+
+    private void clicked(MouseEvent e) {
+        if (moved || pressOnLine || table == null) {
+            return;
+        }
+        RowSorter<? extends TableModel> sorter = table.getRowSorter();
+        int column = columnAtPoint(e.getPoint());
+        if (sorter != null && column >= 0) {
+            sorter.toggleSortOrder(table.convertColumnIndexToModel(column));
+            repaint();
+        }
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",reorderingAllowed=" + reorderingAllowed + ",resizingAllowed=" + resizingAllowed;
+    }
+
+    /// The renderer of titles: a centered label in the header's colors
+    /// and font.
+    private final class TitleRenderer extends DefaultTableCellRenderer {
+
+        TitleRenderer() {
+            setHorizontalAlignment(SwingConstants.CENTER);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable t, Object value, boolean isSelected, boolean hasFocus,
+                int row, int column) {
+            Color fg = JTableHeader.this.getForeground();
+            Color bg = JTableHeader.this.getBackground();
+            Font f = JTableHeader.this.getFont();
+            if (fg != null && !fg.equals(isForegroundSet() ? getForeground() : null)) {
+                super.setForeground(fg);
+            }
+            if (bg != null && !bg.equals(isBackgroundSet() ? getBackground() : null)) {
+                super.setBackground(bg);
+            }
+            if (!f.equals(isFontSet() ? getFont() : null)) {
+                setFont(f);
+            }
+            setValue(value);
+            return this;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableCellEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableCellEditor.java
new file mode 100644
index 00000000000..8b96e26706f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableCellEditor.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.CellEditor;
+import com.codename1.desktopcompat.javax.swing.JTable;
+
+/// Supplies the component a table places over a cell to edit it.
+public interface TableCellEditor extends CellEditor {
+
+    Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableCellRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableCellRenderer.java
new file mode 100644
index 00000000000..74f4537732b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableCellRenderer.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JTable;
+
+/// Supplies the component a table paints a cell with. The table sets the
+/// component's bounds to the cell and calls its `paint`; one component is
+/// normally reused for every cell.
+public interface TableCellRenderer {
+
+    Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row,
+            int column);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableColumn.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableColumn.java
new file mode 100644
index 00000000000..7105ab3d2b2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableColumn.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.javax.swing.event.SwingPropertyChangeSupport;
+
+/// One column of a table as it is shown: the model column it takes its
+/// values from, its width and the limits of it, its header value and the
+/// renderers and editor that replace the table's defaults.
+///
+/// Widths are logical pixels.
+public class TableColumn {
+
+    public static final String COLUMN_WIDTH_PROPERTY = "columWidth";
+    public static final String HEADER_VALUE_PROPERTY = "headerValue";
+    public static final String HEADER_RENDERER_PROPERTY = "headerRenderer";
+    public static final String CELL_RENDERER_PROPERTY = "cellRenderer";
+
+    protected int modelIndex;
+    protected Object identifier;
+    protected int width;
+    protected int minWidth;
+    protected int maxWidth;
+    protected TableCellRenderer headerRenderer;
+    protected Object headerValue;
+    protected TableCellRenderer cellRenderer;
+    protected TableCellEditor cellEditor;
+    protected boolean isResizable;
+
+    private int preferredWidth;
+    private SwingPropertyChangeSupport changeSupport;
+
+    public TableColumn() {
+        this(0);
+    }
+
+    public TableColumn(int modelIndex) {
+        this(modelIndex, 75, null, null);
+    }
+
+    public TableColumn(int modelIndex, int width) {
+        this(modelIndex, width, null, null);
+    }
+
+    public TableColumn(int modelIndex, int width, TableCellRenderer cellRenderer, TableCellEditor cellEditor) {
+        this.modelIndex = modelIndex;
+        this.width = Math.max(width, 0);
+        this.preferredWidth = this.width;
+        this.cellRenderer = cellRenderer;
+        this.cellEditor = cellEditor;
+        this.minWidth = Math.min(15, this.width);
+        this.maxWidth = Integer.MAX_VALUE;
+        this.isResizable = true;
+    }
+
+    private void fire(String name, Object old, Object now) {
+        if (changeSupport != null) {
+            changeSupport.firePropertyChange(name, old, now);
+        }
+    }
+
+    private void fire(String name, int old, int now) {
+        if (changeSupport != null && old != now) {
+            changeSupport.firePropertyChange(name, Integer.valueOf(old), Integer.valueOf(now));
+        }
+    }
+
+    public void setModelIndex(int modelIndex) {
+        int old = this.modelIndex;
+        this.modelIndex = modelIndex;
+        fire("modelIndex", old, modelIndex);
+    }
+
+    public int getModelIndex() {
+        return modelIndex;
+    }
+
+    public void setIdentifier(Object identifier) {
+        Object old = this.identifier;
+        this.identifier = identifier;
+        fire("identifier", old, identifier);
+    }
+
+    /// The identifier, or the header value when none was set.
+    public Object getIdentifier() {
+        return identifier != null ? identifier : getHeaderValue();
+    }
+
+    public void setHeaderValue(Object headerValue) {
+        Object old = this.headerValue;
+        this.headerValue = headerValue;
+        fire(HEADER_VALUE_PROPERTY, old, headerValue);
+    }
+
+    public Object getHeaderValue() {
+        return headerValue;
+    }
+
+    public void setHeaderRenderer(TableCellRenderer headerRenderer) {
+        Object old = this.headerRenderer;
+        this.headerRenderer = headerRenderer;
+        fire(HEADER_RENDERER_PROPERTY, old, headerRenderer);
+    }
+
+    public TableCellRenderer getHeaderRenderer() {
+        return headerRenderer;
+    }
+
+    public void setCellRenderer(TableCellRenderer cellRenderer) {
+        Object old = this.cellRenderer;
+        this.cellRenderer = cellRenderer;
+        fire(CELL_RENDERER_PROPERTY, old, cellRenderer);
+    }
+
+    public TableCellRenderer getCellRenderer() {
+        return cellRenderer;
+    }
+
+    public void setCellEditor(TableCellEditor cellEditor) {
+        Object old = this.cellEditor;
+        this.cellEditor = cellEditor;
+        fire("cellEditor", old, cellEditor);
+    }
+
+    public TableCellEditor getCellEditor() {
+        return cellEditor;
+    }
+
+    private int clamp(int w) {
+        return Math.min(Math.max(w, minWidth), maxWidth);
+    }
+
+    /// Sets the width the column has now; the table's layout overwrites
+    /// it. Use [#setPreferredWidth(int)] to ask for a width.
+    public void setWidth(int width) {
+        int old = this.width;
+        this.width = clamp(width);
+        fire("width", old, this.width);
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public void setPreferredWidth(int preferredWidth) {
+        int old = this.preferredWidth;
+        this.preferredWidth = clamp(preferredWidth);
+        fire("preferredWidth", old, this.preferredWidth);
+    }
+
+    public int getPreferredWidth() {
+        return preferredWidth;
+    }
+
+    public void setMinWidth(int minWidth) {
+        int old = this.minWidth;
+        this.minWidth = Math.max(Math.min(minWidth, maxWidth), 0);
+        if (width < this.minWidth) {
+            setWidth(this.minWidth);
+        }
+        if (preferredWidth < this.minWidth) {
+            setPreferredWidth(this.minWidth);
+        }
+        fire("minWidth", old, this.minWidth);
+    }
+
+    public int getMinWidth() {
+        return minWidth;
+    }
+
+    public void setMaxWidth(int maxWidth) {
+        int old = this.maxWidth;
+        this.maxWidth = Math.max(minWidth, maxWidth);
+        if (width > this.maxWidth) {
+            setWidth(this.maxWidth);
+        }
+        if (preferredWidth > this.maxWidth) {
+            setPreferredWidth(this.maxWidth);
+        }
+        fire("maxWidth", old, this.maxWidth);
+    }
+
+    public int getMaxWidth() {
+        return maxWidth;
+    }
+
+    public void setResizable(boolean isResizable) {
+        boolean old = this.isResizable;
+        this.isResizable = isResizable;
+        fire("isResizable", Boolean.valueOf(old), Boolean.valueOf(isResizable));
+    }
+
+    public boolean getResizable() {
+        return isResizable;
+    }
+
+    /// Fits the column to its header cell, if it has a header renderer of
+    /// its own; does nothing otherwise.
+    public void sizeWidthToFit() {
+        if (headerRenderer == null) {
+            return;
+        }
+        Component c = headerRenderer.getTableCellRendererComponent(null, getHeaderValue(), false, false, 0, 0);
+        if (c == null) {
+            return;
+        }
+        Dimension min = c.getMinimumSize();
+        Dimension max = c.getMaximumSize();
+        Dimension pref = c.getPreferredSize();
+        setMinWidth(min.width);
+        setMaxWidth(max.width);
+        setPreferredWidth(pref.width);
+        setWidth(getPreferredWidth());
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport == null) {
+            changeSupport = new SwingPropertyChangeSupport(this);
+        }
+        changeSupport.addPropertyChangeListener(listener);
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport != null) {
+            changeSupport.removePropertyChangeListener(listener);
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners() {
+        if (changeSupport == null) {
+            return new PropertyChangeListener[0];
+        }
+        return changeSupport.getPropertyChangeListeners();
+    }
+
+    /// A renderer that centers the header value. A column has no header
+    /// renderer until one is set; the table header's default is used.
+    protected TableCellRenderer createDefaultHeaderRenderer() {
+        DefaultTableCellRenderer r = new DefaultTableCellRenderer();
+        r.setHorizontalAlignment(SwingConstants.CENTER);
+        return r;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableColumnModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableColumnModel.java
new file mode 100644
index 00000000000..e6c2c955d01
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableColumnModel.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.javax.swing.ListSelectionModel;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+import java.util.Enumeration;
+
+/// The columns of a table in the order they are shown, the gap between
+/// them, and which of them are selected.
+public interface TableColumnModel {
+
+    void addColumn(TableColumn aColumn);
+
+    void removeColumn(TableColumn column);
+
+    void moveColumn(int columnIndex, int newIndex);
+
+    void setColumnMargin(int newMargin);
+
+    int getColumnCount();
+
+    Enumeration<TableColumn> getColumns();
+
+    int getColumnIndex(Object columnIdentifier);
+
+    TableColumn getColumn(int columnIndex);
+
+    int getColumnMargin();
+
+    int getColumnIndexAtX(int xPosition);
+
+    int getTotalColumnWidth();
+
+    void setColumnSelectionAllowed(boolean flag);
+
+    boolean getColumnSelectionAllowed();
+
+    int[] getSelectedColumns();
+
+    int getSelectedColumnCount();
+
+    void setSelectionModel(ListSelectionModel newModel);
+
+    ListSelectionModel getSelectionModel();
+
+    void addColumnModelListener(TableColumnModelListener x);
+
+    void removeColumnModelListener(TableColumnModelListener x);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableModel.java
new file mode 100644
index 00000000000..d86924b5de6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableModel.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.javax.swing.event.TableModelListener;
+
+/// The data a table shows: a grid of values, the name and class of each
+/// column, and whether a cell may be edited.
+public interface TableModel {
+
+    int getRowCount();
+
+    int getColumnCount();
+
+    String getColumnName(int columnIndex);
+
+    Class<?> getColumnClass(int columnIndex);
+
+    boolean isCellEditable(int rowIndex, int columnIndex);
+
+    Object getValueAt(int rowIndex, int columnIndex);
+
+    void setValueAt(Object aValue, int rowIndex, int columnIndex);
+
+    void addTableModelListener(TableModelListener l);
+
+    void removeTableModelListener(TableModelListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableRowSorter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableRowSorter.java
new file mode 100644
index 00000000000..892ae48c0c4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableRowSorter.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+import com.codename1.desktopcompat.javax.swing.DefaultRowSorter;
+import com.codename1.desktopcompat.rt.Comparators;
+import java.util.Comparator;
+
+/// Sorts and filters the rows of a table model.
+///
+/// A column is compared by the comparator set for it; else, when the
+/// model declares its class to be `String` or a `Comparable`, by the
+/// values themselves; else by the strings the values (or the string
+/// converter) give. Values are compared safely whatever the model
+/// declares: see [DefaultRowSorter].
+public class TableRowSorter<M extends TableModel> extends DefaultRowSorter<M, Integer> {
+
+    private M tableModel;
+    private TableStringConverter stringConverter;
+
+    public TableRowSorter() {
+        this(null);
+    }
+
+    public TableRowSorter(M model) {
+        setModel(model);
+    }
+
+    public void setModel(M model) {
+        tableModel = model;
+        setModelWrapper(new Wrapper());
+    }
+
+    public void setStringConverter(TableStringConverter stringConverter) {
+        this.stringConverter = stringConverter;
+    }
+
+    public TableStringConverter getStringConverter() {
+        return stringConverter;
+    }
+
+    private Class<?> columnClass(int column) {
+        Class<?> c = tableModel == null ? null : tableModel.getColumnClass(column);
+        return c == null ? Object.class : c;
+    }
+
+    /// The comparator set for the column, or `null`.
+    private Comparator<?> explicit(int column) {
+        Comparator<?> c = super.getComparator(column);
+        return c == Comparators.STRINGS ? null : c;
+    }
+
+    @Override
+    public Comparator<?> getComparator(int column) {
+        Comparator<?> set = explicit(column);
+        if (set != null) {
+            return set;
+        }
+        Class<?> c = columnClass(column);
+        if (c != String.class && Comparable.class.isAssignableFrom(c)) {
+            return Comparators.VALUES;
+        }
+        return Comparators.STRINGS;
+    }
+
+    @Override
+    protected boolean useToString(int column) {
+        if (explicit(column) != null) {
+            return false;
+        }
+        Class<?> c = columnClass(column);
+        return c != String.class && !Comparable.class.isAssignableFrom(c);
+    }
+
+    private final class Wrapper extends ModelWrapper<M, Integer> {
+
+        @Override
+        public M getModel() {
+            return tableModel;
+        }
+
+        @Override
+        public int getColumnCount() {
+            return tableModel == null ? 0 : tableModel.getColumnCount();
+        }
+
+        @Override
+        public int getRowCount() {
+            return tableModel == null ? 0 : tableModel.getRowCount();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return tableModel.getValueAt(row, column);
+        }
+
+        @Override
+        public String getStringValueAt(int row, int column) {
+            if (stringConverter != null) {
+                String s = stringConverter.toString(tableModel, row, column);
+                return s == null ? "" : s;
+            }
+            Object o = getValueAt(row, column);
+            if (o == null) {
+                return "";
+            }
+            return o.toString();
+        }
+
+        @Override
+        public Integer getIdentifier(int row) {
+            return Integer.valueOf(row);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableStringConverter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableStringConverter.java
new file mode 100644
index 00000000000..1b207a486a5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/TableStringConverter.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.table;
+
+/// Turns the values of a table model into the strings a sorter compares
+/// and filters by.
+public abstract class TableStringConverter {
+
+    public TableStringConverter() {
+    }
+
+    public abstract String toString(TableModel model, int row, int column);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/package-info.java
new file mode 100644
index 00000000000..d4b2eca1c04
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/table/package-info.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The models, columns, renderers and editors of
+/// [com.codename1.desktopcompat.javax.swing.JTable], standing in for
+/// `javax.swing.table`.
+///
+/// The classes keep the JDK's contracts. Two things differ on a device and
+/// shape the code: a class cannot be asked for its superclass, so a default
+/// renderer or editor is found by assignability, and values are never cast
+/// before their type was checked, because a failed cast does not throw
+/// there.
+package com.codename1.desktopcompat.javax.swing.table;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/AbstractDocument.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/AbstractDocument.java
new file mode 100644
index 00000000000..d942372fa9d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/AbstractDocument.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditEvent;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditListener;
+import com.codename1.desktopcompat.javax.swing.undo.CannotRedoException;
+import com.codename1.desktopcompat.javax.swing.undo.CannotUndoException;
+import com.codename1.desktopcompat.javax.swing.undo.CompoundEdit;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.EventListener;
+import java.util.HashMap;
+
+/// The working part of a document: the characters, the listeners, the
+/// positions that follow the text and the filter every change goes
+/// through.
+///
+/// The text is one string buffer. There is no content interface, no
+/// locking (documents belong to the event dispatch thread), no undo and no
+/// attribute context, and a document cannot be made with a storage of the
+/// caller's choosing; subclass [PlainDocument] rather than this class.
+public abstract class AbstractDocument implements Document {
+
+    protected static final String BAD_LOCATION = "document location failure";
+
+    public static final String ParagraphElementName = "paragraph";
+
+    public static final String ContentElementName = "content";
+
+    public static final String SectionElementName = "section";
+
+    public static final String BidiElementName = "bidi level";
+
+    public static final String ElementNameAttribute = "$ename";
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    private final StringBuilder text = new StringBuilder();
+    private final ArrayList<WeakReference<Sticky>> positions = new ArrayList<WeakReference<Sticky>>();
+    private HashMap<Object, Object> properties;
+    private DocumentFilter documentFilter;
+    private DocumentFilter.FilterBypass filterBypass;
+    private int modCount;
+    /// An undo or a redo is changing the text.
+    private boolean replaying;
+
+    AbstractDocument() {
+    }
+
+    /// Counts the changes made so far; the line structure is computed
+    /// again when it moved.
+    int cn1ModCount() {
+        return modCount;
+    }
+
+    /// The characters, for the classes of this package.
+    CharSequence cn1Chars() {
+        return text;
+    }
+
+    @Override
+    public int getLength() {
+        return text.length();
+    }
+
+    @Override
+    public String getText(int offset, int length) throws BadLocationException {
+        if (length < 0) {
+            throw new BadLocationException("Length must be positive", length);
+        }
+        if (offset < 0 || offset + length > text.length()) {
+            throw new BadLocationException("Invalid location", offset < 0 ? offset : offset + length);
+        }
+        return text.substring(offset, offset + length);
+    }
+
+    @Override
+    public void getText(int offset, int length, Segment txt) throws BadLocationException {
+        String s = getText(offset, length);
+        txt.array = s.toCharArray();
+        txt.offset = 0;
+        txt.count = txt.array.length;
+    }
+
+    // ------------------------------------------------------------ changes
+
+    @Override
+    public void insertString(int offs, String str, AttributeSet a) throws BadLocationException {
+        if (str == null || str.length() == 0) {
+            return;
+        }
+        if (documentFilter != null) {
+            documentFilter.insertString(getFilterBypass(), offs, str, a);
+        } else {
+            handleInsertString(offs, str, a);
+        }
+    }
+
+    @Override
+    public void remove(int offs, int len) throws BadLocationException {
+        if (documentFilter != null) {
+            documentFilter.remove(getFilterBypass(), offs, len);
+        } else {
+            handleRemove(offs, len);
+        }
+    }
+
+    /// Removes `length` characters at `offset` and puts `text` there, as
+    /// one pass through the filter.
+    public void replace(int offset, int length, String text, AttributeSet attrs) throws BadLocationException {
+        if (length == 0 && (text == null || text.length() == 0)) {
+            return;
+        }
+        if (documentFilter != null) {
+            documentFilter.replace(getFilterBypass(), offset, length, text, attrs);
+        } else {
+            if (length > 0) {
+                handleRemove(offset, length);
+            }
+            if (text != null && text.length() > 0) {
+                handleInsertString(offset, text, attrs);
+            }
+        }
+    }
+
+    /// The text that really goes in for an insertion of `str`; the same
+    /// length, so offsets computed before it stay right.
+    String cn1FilterInsert(String str) {
+        return str;
+    }
+
+    void handleInsertString(int offs, String str, AttributeSet a) throws BadLocationException {
+        if (str == null || str.length() == 0) {
+            return;
+        }
+        if (offs < 0 || offs > text.length()) {
+            throw new BadLocationException("Invalid insert", offs);
+        }
+        str = cn1FilterInsert(str);
+        text.insert(offs, str);
+        modCount++;
+        int len = str.length();
+        for (int i = positions.size() - 1; i >= 0; i--) {
+            Sticky p = positions.get(i).get();
+            if (p == null) {
+                positions.remove(i);
+            } else if (p.offset > offs || (p.offset == offs && offs != 0)) {
+                p.offset += len;
+            }
+        }
+        DefaultDocumentEvent e = new DefaultDocumentEvent(offs, len, DocumentEvent.EventType.INSERT);
+        e.cn1Text = str;
+        insertUpdate(e, a);
+        e.end();
+        fireInsertUpdate(e);
+        cn1PostEdit(e);
+    }
+
+    void handleRemove(int offs, int len) throws BadLocationException {
+        if (len <= 0) {
+            return;
+        }
+        if (offs < 0 || offs + len > text.length()) {
+            throw new BadLocationException("Invalid remove", offs < 0 ? offs : offs + len);
+        }
+        DefaultDocumentEvent e = new DefaultDocumentEvent(offs, len, DocumentEvent.EventType.REMOVE);
+        e.cn1Text = text.substring(offs, offs + len);
+        removeUpdate(e);
+        text.delete(offs, offs + len);
+        modCount++;
+        for (int i = positions.size() - 1; i >= 0; i--) {
+            Sticky p = positions.get(i).get();
+            if (p == null) {
+                positions.remove(i);
+            } else if (p.offset >= offs + len) {
+                p.offset -= len;
+            } else if (p.offset > offs) {
+                p.offset = offs;
+            }
+        }
+        postRemoveUpdate(e);
+        e.end();
+        fireRemoveUpdate(e);
+        cn1PostEdit(e);
+    }
+
+    /// Posts the edit of a change to the undoable edit listeners, unless
+    /// the change is itself an undo or a redo.
+    private void cn1PostEdit(DefaultDocumentEvent e) {
+        if (!replaying && listenerList.getListenerCount(UndoableEditListener.class) > 0) {
+            fireUndoableEditUpdate(new UndoableEditEvent(this, e));
+        }
+    }
+
+    /// Takes an edit back or applies it again: the plain insertion or
+    /// removal, with the document listeners told and no new edit posted.
+    void cn1Replay(boolean insert, int offs, String str) {
+        boolean was = replaying;
+        replaying = true;
+        try {
+            if (insert) {
+                handleInsertString(Math.min(offs, text.length()), str, null);
+            } else {
+                int from = Math.min(offs, text.length());
+                handleRemove(from, Math.min(str.length(), text.length() - from));
+            }
+        } catch (BadLocationException e) {
+            // The offsets were clamped to the document above.
+            throw new IllegalStateException(e.getMessage());
+        } finally {
+            replaying = was;
+        }
+    }
+
+    /// Called after text went in and before the listeners hear of it.
+    protected void insertUpdate(DefaultDocumentEvent chng, AttributeSet attr) {
+    }
+
+    /// Called before text is taken out.
+    protected void removeUpdate(DefaultDocumentEvent chng) {
+    }
+
+    /// Called after text was taken out and before the listeners hear of
+    /// it.
+    protected void postRemoveUpdate(DefaultDocumentEvent chng) {
+    }
+
+    // ------------------------------------------------------------ filter
+
+    public void setDocumentFilter(DocumentFilter filter) {
+        documentFilter = filter;
+    }
+
+    public DocumentFilter getDocumentFilter() {
+        return documentFilter;
+    }
+
+    private DocumentFilter.FilterBypass getFilterBypass() {
+        if (filterBypass == null) {
+            filterBypass = new Bypass();
+        }
+        return filterBypass;
+    }
+
+    private final class Bypass extends DocumentFilter.FilterBypass {
+
+        @Override
+        public Document getDocument() {
+            return AbstractDocument.this;
+        }
+
+        @Override
+        public void remove(int offset, int length) throws BadLocationException {
+            handleRemove(offset, length);
+        }
+
+        @Override
+        public void insertString(int offset, String string, AttributeSet attr) throws BadLocationException {
+            handleInsertString(offset, string, attr);
+        }
+
+        @Override
+        public void replace(int offset, int length, String string, AttributeSet attrs) throws BadLocationException {
+            handleRemove(offset, length);
+            handleInsertString(offset, string, attrs);
+        }
+    }
+
+    // ------------------------------------------------------------ positions
+
+    private static final class Sticky implements Position {
+        int offset;
+
+        Sticky(int offset) {
+            this.offset = offset;
+        }
+
+        @Override
+        public int getOffset() {
+            return offset;
+        }
+
+        @Override
+        public String toString() {
+            return Integer.toString(offset);
+        }
+    }
+
+    @Override
+    public Position createPosition(int offs) throws BadLocationException {
+        if (offs < 0 || offs > text.length()) {
+            throw new BadLocationException("Invalid position", offs);
+        }
+        Sticky p = new Sticky(offs);
+        positions.add(new WeakReference<Sticky>(p));
+        return p;
+    }
+
+    @Override
+    public final Position getStartPosition() {
+        return new Sticky(0);
+    }
+
+    /// The position after the last character, which follows the end of the
+    /// text. Unlike on the desktop there is no implied line break behind
+    /// the text, so this is the length and not one more.
+    @Override
+    public final Position getEndPosition() {
+        return new Position() {
+            @Override
+            public int getOffset() {
+                return getLength();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ structure
+
+    @Override
+    public Element[] getRootElements() {
+        return new Element[]{getDefaultRootElement()};
+    }
+
+    @Override
+    public abstract Element getDefaultRootElement();
+
+    public abstract Element getParagraphElement(int pos);
+
+    // ------------------------------------------------------------ properties
+
+    @Override
+    public final Object getProperty(Object key) {
+        return properties == null ? null : properties.get(key);
+    }
+
+    @Override
+    public final void putProperty(Object key, Object value) {
+        if (properties == null) {
+            properties = new HashMap<Object, Object>();
+        }
+        if (value == null) {
+            properties.remove(key);
+        } else {
+            properties.put(key, value);
+        }
+    }
+
+    // ------------------------------------------------------------ listeners
+
+    @Override
+    public void addDocumentListener(DocumentListener listener) {
+        listenerList.add(DocumentListener.class, listener);
+    }
+
+    @Override
+    public void removeDocumentListener(DocumentListener listener) {
+        listenerList.remove(DocumentListener.class, listener);
+    }
+
+    @Override
+    public void addUndoableEditListener(UndoableEditListener listener) {
+        listenerList.add(UndoableEditListener.class, listener);
+    }
+
+    @Override
+    public void removeUndoableEditListener(UndoableEditListener listener) {
+        listenerList.remove(UndoableEditListener.class, listener);
+    }
+
+    public UndoableEditListener[] getUndoableEditListeners() {
+        return listenerList.getListeners(UndoableEditListener.class);
+    }
+
+    protected void fireUndoableEditUpdate(UndoableEditEvent e) {
+        UndoableEditListener[] ls = listenerList.getListeners(UndoableEditListener.class);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].undoableEditHappened(e);
+        }
+    }
+
+    public DocumentListener[] getDocumentListeners() {
+        return listenerList.getListeners(DocumentListener.class);
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+
+    protected void fireInsertUpdate(DocumentEvent e) {
+        DocumentListener[] ls = getDocumentListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].insertUpdate(e);
+        }
+    }
+
+    protected void fireRemoveUpdate(DocumentEvent e) {
+        DocumentListener[] ls = getDocumentListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].removeUpdate(e);
+        }
+    }
+
+    protected void fireChangedUpdate(DocumentEvent e) {
+        DocumentListener[] ls = getDocumentListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].changedUpdate(e);
+        }
+    }
+
+    /// The event a document sends for one change. It is also the edit
+    /// that takes the change back: undoing an insertion removes the text
+    /// again and undoing a removal puts it back, and the document
+    /// listeners hear of either as an ordinary change.
+    public class DefaultDocumentEvent extends CompoundEdit implements DocumentEvent {
+
+        private final int offset;
+        private final int length;
+        private final DocumentEvent.EventType type;
+        /// The characters that went in or came out.
+        String cn1Text = "";
+
+        public DefaultDocumentEvent(int offs, int len, DocumentEvent.EventType type) {
+            offset = offs;
+            length = len;
+            this.type = type;
+        }
+
+        @Override
+        public int getOffset() {
+            return offset;
+        }
+
+        @Override
+        public int getLength() {
+            return length;
+        }
+
+        @Override
+        public Document getDocument() {
+            return AbstractDocument.this;
+        }
+
+        @Override
+        public DocumentEvent.EventType getType() {
+            return type;
+        }
+
+        @Override
+        public DocumentEvent.ElementChange getChange(Element elem) {
+            return null;
+        }
+
+        @Override
+        public void undo() throws CannotUndoException {
+            super.undo();
+            if (type == DocumentEvent.EventType.INSERT) {
+                cn1Replay(false, offset, cn1Text);
+            } else if (type == DocumentEvent.EventType.REMOVE) {
+                cn1Replay(true, offset, cn1Text);
+            }
+        }
+
+        @Override
+        public void redo() throws CannotRedoException {
+            super.redo();
+            if (type == DocumentEvent.EventType.INSERT) {
+                cn1Replay(true, offset, cn1Text);
+            } else if (type == DocumentEvent.EventType.REMOVE) {
+                cn1Replay(false, offset, cn1Text);
+            }
+        }
+
+        @Override
+        public boolean isSignificant() {
+            return true;
+        }
+
+        @Override
+        public String getPresentationName() {
+            if (type == DocumentEvent.EventType.INSERT) {
+                return "addition";
+            }
+            if (type == DocumentEvent.EventType.REMOVE) {
+                return "deletion";
+            }
+            return "style change";
+        }
+
+        @Override
+        public String getUndoPresentationName() {
+            return UndoName + " " + getPresentationName();
+        }
+
+        @Override
+        public String getRedoPresentationName() {
+            return RedoName + " " + getPresentationName();
+        }
+
+        @Override
+        public String toString() {
+            return type + " offset=" + offset + " length=" + length;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/AttributeSet.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/AttributeSet.java
new file mode 100644
index 00000000000..d01129a80fc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/AttributeSet.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import java.util.Enumeration;
+
+/// A read only set of attributes: of an element of a document, or made by
+/// the application to style text with, see [SimpleAttributeSet] and
+/// [StyleConstants].
+public interface AttributeSet {
+
+    Object NameAttribute = "name";
+
+    Object ResolveAttribute = "resolver";
+
+    int getAttributeCount();
+
+    boolean isDefined(Object attrName);
+
+    boolean isEqual(AttributeSet attr);
+
+    AttributeSet copyAttributes();
+
+    Object getAttribute(Object key);
+
+    Enumeration<?> getAttributeNames();
+
+    boolean containsAttribute(Object name, Object value);
+
+    boolean containsAttributes(AttributeSet attributes);
+
+    AttributeSet getResolveParent();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/BadLocationException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/BadLocationException.java
new file mode 100644
index 00000000000..128936b568f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/BadLocationException.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+/// A position that is not inside the document was named.
+public class BadLocationException extends Exception {
+
+    private final int offs;
+
+    public BadLocationException(String s, int offs) {
+        super(s);
+        this.offs = offs;
+    }
+
+    public int offsetRequested() {
+        return offs;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Caret.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Caret.java
new file mode 100644
index 00000000000..3f577230172
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Caret.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// The insertion point of a text component, and with its mark the
+/// selection.
+public interface Caret {
+
+    void install(JTextComponent c);
+
+    void deinstall(JTextComponent c);
+
+    void paint(Graphics g);
+
+    void addChangeListener(ChangeListener l);
+
+    void removeChangeListener(ChangeListener l);
+
+    boolean isVisible();
+
+    void setVisible(boolean v);
+
+    boolean isSelectionVisible();
+
+    void setSelectionVisible(boolean v);
+
+    void setMagicCaretPosition(Point p);
+
+    Point getMagicCaretPosition();
+
+    void setBlinkRate(int rate);
+
+    int getBlinkRate();
+
+    int getDot();
+
+    int getMark();
+
+    void setDot(int dot);
+
+    void moveDot(int dot);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultCaret.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultCaret.java
new file mode 100644
index 00000000000..fb130a7b391
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultCaret.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+
+/// The caret every text component starts with: a dot and a mark.
+///
+/// It paints nothing. The insertion point the user sees is the one the
+/// Codename One text widget draws while it is being edited, and a
+/// selection made here is known to the component (`getSelectedText`,
+/// `replaceSelection`, cut, copy and paste) but not highlighted.
+public class DefaultCaret implements Caret {
+
+    public static final int UPDATE_WHEN_ON_EDT = 0;
+
+    public static final int NEVER_UPDATE = 1;
+
+    public static final int ALWAYS_UPDATE = 2;
+
+    protected EventListenerList listenerList = new EventListenerList();
+
+    protected transient ChangeEvent changeEvent;
+
+    private JTextComponent component;
+    private int dot;
+    private int mark;
+    private boolean visible;
+    private boolean selectionVisible;
+    private int blinkRate;
+    private int updatePolicy;
+    private Point magic;
+
+    public DefaultCaret() {
+    }
+
+    @Override
+    public void install(JTextComponent c) {
+        component = c;
+    }
+
+    @Override
+    public void deinstall(JTextComponent c) {
+        component = null;
+    }
+
+    protected final JTextComponent getComponent() {
+        return component;
+    }
+
+    @Override
+    public void paint(Graphics g) {
+    }
+
+    @Override
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+
+    @Override
+    public void removeChangeListener(ChangeListener l) {
+        listenerList.remove(ChangeListener.class, l);
+    }
+
+    public ChangeListener[] getChangeListeners() {
+        return listenerList.getListeners(ChangeListener.class);
+    }
+
+    protected void fireStateChanged() {
+        ChangeListener[] ls = getChangeListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (changeEvent == null) {
+                changeEvent = new ChangeEvent(this);
+            }
+            ls[i].stateChanged(changeEvent);
+        }
+    }
+
+    @Override
+    public boolean isVisible() {
+        return visible;
+    }
+
+    @Override
+    public void setVisible(boolean v) {
+        visible = v;
+    }
+
+    @Override
+    public boolean isSelectionVisible() {
+        return selectionVisible;
+    }
+
+    @Override
+    public void setSelectionVisible(boolean v) {
+        selectionVisible = v;
+    }
+
+    @Override
+    public void setMagicCaretPosition(Point p) {
+        magic = p == null ? null : new Point(p);
+    }
+
+    @Override
+    public Point getMagicCaretPosition() {
+        return magic == null ? null : new Point(magic);
+    }
+
+    @Override
+    public void setBlinkRate(int rate) {
+        blinkRate = rate;
+    }
+
+    @Override
+    public int getBlinkRate() {
+        return blinkRate;
+    }
+
+    public void setUpdatePolicy(int policy) {
+        updatePolicy = policy;
+    }
+
+    public int getUpdatePolicy() {
+        return updatePolicy;
+    }
+
+    @Override
+    public int getDot() {
+        return dot;
+    }
+
+    @Override
+    public int getMark() {
+        return mark;
+    }
+
+    private int clamp(int d) {
+        int len = 0;
+        if (component != null && component.getDocument() != null) {
+            len = component.getDocument().getLength();
+        }
+        return d < 0 ? 0 : d > len ? len : d;
+    }
+
+    @Override
+    public void setDot(int dot) {
+        int d = clamp(dot);
+        if (d != this.dot || d != mark) {
+            this.dot = d;
+            mark = d;
+            fireStateChanged();
+        }
+    }
+
+    @Override
+    public void moveDot(int dot) {
+        int d = clamp(dot);
+        if (d != this.dot) {
+            this.dot = d;
+            fireStateChanged();
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "Dot=(" + dot + ", Forward) Mark=(" + mark + ", Forward)";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultEditorKit.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultEditorKit.java
new file mode 100644
index 00000000000..4f9fdc9043f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultEditorKit.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.javax.swing.Action;
+
+/// The names of the editing actions a text component offers, and the
+/// actions themselves for the ones this layer carries out: cut, copy, paste,
+/// select all and the two that insert a line break or a tab.
+///
+/// Reading and writing a document through the kit, the caret movement
+/// actions and the view factory are not part of this layer; the platform's
+/// text editor moves the caret.
+public class DefaultEditorKit {
+
+    public static final String EndOfLineStringProperty = "__EndOfLine__";
+
+    public static final String insertContentAction = "insert-content";
+
+    public static final String insertBreakAction = "insert-break";
+
+    public static final String insertTabAction = "insert-tab";
+
+    public static final String deletePrevCharAction = "delete-previous";
+
+    public static final String deleteNextCharAction = "delete-next";
+
+    public static final String readOnlyAction = "set-read-only";
+
+    public static final String writableAction = "set-writable";
+
+    public static final String cutAction = "cut-to-clipboard";
+
+    public static final String copyAction = "copy-to-clipboard";
+
+    public static final String pasteAction = "paste-from-clipboard";
+
+    public static final String beepAction = "beep";
+
+    public static final String selectAllAction = "select-all";
+
+    public static final String defaultKeyTypedAction = "default-typed";
+
+    public DefaultEditorKit() {
+    }
+
+    /// The actions this layer carries out, a new array each time.
+    public Action[] getActions() {
+        return new Action[] {
+            new CutAction(), new CopyAction(), new PasteAction(), new Cn1SelectAll(),
+            new InsertBreakAction(), new InsertTabAction()
+        };
+    }
+
+    /// Moves the selection to the clipboard.
+    public static class CutAction extends TextAction {
+
+        public CutAction() {
+            super(cutAction);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            JTextComponent target = getTextComponent(e);
+            if (target != null) {
+                target.cut();
+            }
+        }
+    }
+
+    /// Copies the selection to the clipboard.
+    public static class CopyAction extends TextAction {
+
+        public CopyAction() {
+            super(copyAction);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            JTextComponent target = getTextComponent(e);
+            if (target != null) {
+                target.copy();
+            }
+        }
+    }
+
+    /// Replaces the selection with the clipboard's text.
+    public static class PasteAction extends TextAction {
+
+        public PasteAction() {
+            super(pasteAction);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            JTextComponent target = getTextComponent(e);
+            if (target != null) {
+                target.paste();
+            }
+        }
+    }
+
+    /// Replaces the selection with a line break.
+    public static class InsertBreakAction extends TextAction {
+
+        public InsertBreakAction() {
+            super(insertBreakAction);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            JTextComponent target = getTextComponent(e);
+            if (target != null && target.isEditable() && target.isEnabled()) {
+                target.replaceSelection("\n");
+            }
+        }
+    }
+
+    /// Replaces the selection with a tab.
+    public static class InsertTabAction extends TextAction {
+
+        public InsertTabAction() {
+            super(insertTabAction);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            JTextComponent target = getTextComponent(e);
+            if (target != null && target.isEditable() && target.isEnabled()) {
+                target.replaceSelection("\t");
+            }
+        }
+    }
+
+    /// Selects everything; the JDK keeps its class for this package private
+    /// too.
+    static final class Cn1SelectAll extends TextAction {
+
+        Cn1SelectAll() {
+            super(selectAllAction);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            JTextComponent target = getTextComponent(e);
+            if (target != null) {
+                target.selectAll();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultFormatter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultFormatter.java
new file mode 100644
index 00000000000..8ca572d9cb1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultFormatter.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.javax.swing.JFormattedTextField;
+import java.text.ParseException;
+
+/// Formats any value through its `toString()` and reads it back as an
+/// instance of the value class.
+///
+/// ## What differs from the desktop
+///
+/// The desktop builds the value by calling, through reflection, whatever
+/// constructor of the value class takes a string. A device has no such
+/// reflection, so the classes that can be read back are `String`, the
+/// boxed numbers and `Boolean`; text for any other class comes back as
+/// the string itself.
+public class DefaultFormatter extends JFormattedTextField.AbstractFormatter {
+
+    private boolean allowsInvalid = true;
+    private boolean overwriteMode = true;
+    private boolean commitOnEdit;
+    private Class<?> valueClass;
+
+    public DefaultFormatter() {
+    }
+
+    public void setCommitsOnValidEdit(boolean commit) {
+        commitOnEdit = commit;
+    }
+
+    public boolean getCommitsOnValidEdit() {
+        return commitOnEdit;
+    }
+
+    public void setOverwriteMode(boolean overwriteMode) {
+        this.overwriteMode = overwriteMode;
+    }
+
+    public boolean getOverwriteMode() {
+        return overwriteMode;
+    }
+
+    public void setAllowsInvalid(boolean allowsInvalid) {
+        this.allowsInvalid = allowsInvalid;
+    }
+
+    public boolean getAllowsInvalid() {
+        return allowsInvalid;
+    }
+
+    public void setValueClass(Class<?> valueClass) {
+        this.valueClass = valueClass;
+    }
+
+    public Class<?> getValueClass() {
+        return valueClass;
+    }
+
+    @Override
+    public Object stringToValue(String string) throws ParseException {
+        Class<?> vc = getValueClass();
+        JFormattedTextField ftf = getFormattedTextField();
+        if (vc == null && ftf != null) {
+            Object value = ftf.getValue();
+            if (value != null) {
+                vc = value.getClass();
+            }
+        }
+        if (vc == null || string == null || vc == String.class) {
+            return string;
+        }
+        try {
+            if (vc == Integer.class) {
+                return Integer.valueOf(Integer.parseInt(string));
+            } else if (vc == Long.class) {
+                return Long.valueOf(Long.parseLong(string));
+            } else if (vc == Double.class) {
+                return Double.valueOf(Double.parseDouble(string));
+            } else if (vc == Float.class) {
+                return Float.valueOf(Float.parseFloat(string));
+            } else if (vc == Short.class) {
+                return Short.valueOf(Short.parseShort(string));
+            } else if (vc == Byte.class) {
+                return Byte.valueOf(Byte.parseByte(string));
+            }
+        } catch (NumberFormatException nfe) {
+            throw new ParseException("Error creating instance", 0);
+        }
+        if (vc == Boolean.class) {
+            return Boolean.valueOf("true".equalsIgnoreCase(string));
+        }
+        return string;
+    }
+
+    @Override
+    public String valueToString(Object value) throws ParseException {
+        return value == null ? "" : value.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultFormatterFactory.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultFormatterFactory.java
new file mode 100644
index 00000000000..e2e5bb9b739
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultFormatterFactory.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.javax.swing.JFormattedTextField;
+
+/// A factory with up to four formatters: one for a field that has the
+/// focus, one for a field that does not, one for a `null` value, and a
+/// default that stands in for whichever of those is missing.
+public class DefaultFormatterFactory extends JFormattedTextField.AbstractFormatterFactory {
+
+    private JFormattedTextField.AbstractFormatter defaultFormat;
+    private JFormattedTextField.AbstractFormatter displayFormat;
+    private JFormattedTextField.AbstractFormatter editFormat;
+    private JFormattedTextField.AbstractFormatter nullFormat;
+
+    public DefaultFormatterFactory() {
+    }
+
+    public DefaultFormatterFactory(JFormattedTextField.AbstractFormatter defaultFormat) {
+        this(defaultFormat, null);
+    }
+
+    public DefaultFormatterFactory(JFormattedTextField.AbstractFormatter defaultFormat,
+            JFormattedTextField.AbstractFormatter displayFormat) {
+        this(defaultFormat, displayFormat, null);
+    }
+
+    public DefaultFormatterFactory(JFormattedTextField.AbstractFormatter defaultFormat,
+            JFormattedTextField.AbstractFormatter displayFormat, JFormattedTextField.AbstractFormatter editFormat) {
+        this(defaultFormat, displayFormat, editFormat, null);
+    }
+
+    public DefaultFormatterFactory(JFormattedTextField.AbstractFormatter defaultFormat,
+            JFormattedTextField.AbstractFormatter displayFormat, JFormattedTextField.AbstractFormatter editFormat,
+            JFormattedTextField.AbstractFormatter nullFormat) {
+        this.defaultFormat = defaultFormat;
+        this.displayFormat = displayFormat;
+        this.editFormat = editFormat;
+        this.nullFormat = nullFormat;
+    }
+
+    public void setDefaultFormatter(JFormattedTextField.AbstractFormatter atf) {
+        defaultFormat = atf;
+    }
+
+    public JFormattedTextField.AbstractFormatter getDefaultFormatter() {
+        return defaultFormat;
+    }
+
+    public void setDisplayFormatter(JFormattedTextField.AbstractFormatter atf) {
+        displayFormat = atf;
+    }
+
+    public JFormattedTextField.AbstractFormatter getDisplayFormatter() {
+        return displayFormat;
+    }
+
+    public void setEditFormatter(JFormattedTextField.AbstractFormatter atf) {
+        editFormat = atf;
+    }
+
+    public JFormattedTextField.AbstractFormatter getEditFormatter() {
+        return editFormat;
+    }
+
+    public void setNullFormatter(JFormattedTextField.AbstractFormatter atf) {
+        nullFormat = atf;
+    }
+
+    public JFormattedTextField.AbstractFormatter getNullFormatter() {
+        return nullFormat;
+    }
+
+    @Override
+    public JFormattedTextField.AbstractFormatter getFormatter(JFormattedTextField source) {
+        JFormattedTextField.AbstractFormatter format = null;
+        if (source == null) {
+            return null;
+        }
+        Object value = source.getValue();
+        if (value == null) {
+            format = getNullFormatter();
+        }
+        if (format == null) {
+            format = source.hasFocus() ? getEditFormatter() : getDisplayFormatter();
+            if (format == null) {
+                format = getDefaultFormatter();
+            }
+        }
+        return format;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultStyledDocument.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultStyledDocument.java
new file mode 100644
index 00000000000..5ddfeee041a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DefaultStyledDocument.java
@@ -0,0 +1,653 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import java.util.ArrayList;
+import java.util.Enumeration;
+
+/// Text with attributes.
+///
+/// The characters are kept in runs, each a stretch with one set of
+/// attributes, and every paragraph -- the text up to and including a
+/// line break -- has a set of its own. Text that is inserted takes the
+/// attributes it is inserted with, none when they are `null`; a paragraph
+/// that is split passes its attributes on to both halves, and two that
+/// are joined keep those of the first.
+///
+/// The element tree is the JDK's: a section, its paragraphs, and in each
+/// the runs that lie in it. An attribute a run lacks is looked up in its
+/// paragraph, and one the paragraph lacks in its logical style, which is
+/// the context's default style until another is set. Elements are made
+/// when they are asked for and describe the document as it was then; ask
+/// again after changing it.
+public class DefaultStyledDocument extends AbstractDocument implements StyledDocument {
+
+    public static final int BUFFER_SIZE_DEFAULT = 4096;
+
+    private final StyleContext context;
+    private final ArrayList<Run> runs = new ArrayList<Run>();
+    private final ArrayList<MutableAttributeSet> paragraphs = new ArrayList<MutableAttributeSet>();
+    private final ChangeListener styleListener = new ChangeListener() {
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            styleChanged();
+        }
+    };
+    private final Section section = new Section();
+
+    public DefaultStyledDocument() {
+        this(new StyleContext());
+    }
+
+    public DefaultStyledDocument(StyleContext styles) {
+        context = styles;
+        paragraphs.add(newParagraph(null));
+        Style def = styles.getStyle(StyleContext.DEFAULT_STYLE);
+        if (def != null) {
+            def.removeChangeListener(styleListener);
+            def.addChangeListener(styleListener);
+        }
+    }
+
+    private static final class Run {
+        int length;
+        AttributeSet attributes;
+
+        Run(int length, AttributeSet attributes) {
+            this.length = length;
+            this.attributes = attributes;
+        }
+    }
+
+    private MutableAttributeSet newParagraph(AttributeSet like) {
+        SimpleAttributeSet p = new SimpleAttributeSet();
+        if (like != null) {
+            p.addAttributes(like);
+        } else {
+            Style def = context.getStyle(StyleContext.DEFAULT_STYLE);
+            if (def != null) {
+                p.setResolveParent(def);
+            }
+        }
+        return p;
+    }
+
+    /// A style of this document changed: everything is drawn again.
+    private void styleChanged() {
+        changed(0, getLength());
+    }
+
+    private void changed(int offset, int length) {
+        DefaultDocumentEvent e = new DefaultDocumentEvent(offset, length, DocumentEvent.EventType.CHANGE);
+        e.end();
+        fireChangedUpdate(e);
+    }
+
+    // ------------------------------------------------------------ styles
+
+    @Override
+    public Style addStyle(String nm, Style parent) {
+        Style s = context.addStyle(nm, parent);
+        s.addChangeListener(styleListener);
+        return s;
+    }
+
+    @Override
+    public void removeStyle(String nm) {
+        Style s = context.getStyle(nm);
+        if (s != null) {
+            s.removeChangeListener(styleListener);
+        }
+        context.removeStyle(nm);
+    }
+
+    @Override
+    public Style getStyle(String nm) {
+        return context.getStyle(nm);
+    }
+
+    public Enumeration<?> getStyleNames() {
+        return context.getStyleNames();
+    }
+
+    @Override
+    public Color getForeground(AttributeSet attr) {
+        return context.getForeground(attr);
+    }
+
+    @Override
+    public Color getBackground(AttributeSet attr) {
+        return context.getBackground(attr);
+    }
+
+    @Override
+    public Font getFont(AttributeSet attr) {
+        return context.getFont(attr);
+    }
+
+    // ------------------------------------------------------------ text
+
+    private static int breaks(CharSequence s, int from, int to) {
+        int n = 0;
+        for (int i = from; i < to; i++) {
+            if (s.charAt(i) == '\n') {
+                n++;
+            }
+        }
+        return n;
+    }
+
+    /// Cuts the runs so that one begins at `offset`, and answers its
+    /// index; the number of runs when `offset` is the end of the text.
+    private int splitAt(int offset) {
+        int at = 0;
+        for (int i = 0; i < runs.size(); i++) {
+            Run r = runs.get(i);
+            if (at == offset) {
+                return i;
+            }
+            if (offset < at + r.length) {
+                int head = offset - at;
+                runs.add(i + 1, new Run(r.length - head, r.attributes));
+                r.length = head;
+                return i + 1;
+            }
+            at += r.length;
+        }
+        return runs.size();
+    }
+
+    /// Joins neighbours with equal attributes, and drops empty runs.
+    private void tidy() {
+        for (int i = runs.size() - 1; i >= 0; i--) {
+            Run r = runs.get(i);
+            if (r.length <= 0) {
+                runs.remove(i);
+            } else if (i + 1 < runs.size() && runs.get(i + 1).attributes.isEqual(r.attributes)) {
+                r.length += runs.get(i + 1).length;
+                runs.remove(i + 1);
+            }
+        }
+    }
+
+    @Override
+    protected void insertUpdate(DefaultDocumentEvent chng, AttributeSet attr) {
+        // The text is in already.
+        int offs = chng.getOffset();
+        int len = chng.getLength();
+        CharSequence text = cn1Chars();
+        AttributeSet a = attr == null || attr.getAttributeCount() == 0 ? SimpleAttributeSet.EMPTY
+                : attr.copyAttributes();
+        runs.add(splitAt(offs), new Run(len, a));
+        tidy();
+        int para = Math.min(breaks(text, 0, offs), paragraphs.size() - 1);
+        int added = breaks(text, offs, offs + len);
+        for (int i = 0; i < added; i++) {
+            paragraphs.add(para + 1, newParagraph(paragraphs.get(para)));
+        }
+        super.insertUpdate(chng, attr);
+    }
+
+    @Override
+    protected void removeUpdate(DefaultDocumentEvent chng) {
+        // The text is still there.
+        int offs = chng.getOffset();
+        int len = chng.getLength();
+        CharSequence text = cn1Chars();
+        int from = splitAt(offs);
+        int to = splitAt(offs + len);
+        for (int i = to - 1; i >= from; i--) {
+            runs.remove(i);
+        }
+        tidy();
+        int para = breaks(text, 0, offs);
+        int gone = breaks(text, offs, offs + len);
+        for (int i = 0; i < gone && para + 1 < paragraphs.size(); i++) {
+            paragraphs.remove(para + 1);
+        }
+        super.removeUpdate(chng);
+    }
+
+    @Override
+    public void setCharacterAttributes(int offset, int length, AttributeSet s, boolean replace) {
+        if (length <= 0 || s == null) {
+            return;
+        }
+        int end = Math.min(getLength(), offset + length);
+        int start = Math.max(0, offset);
+        if (start >= end) {
+            return;
+        }
+        int from = splitAt(start);
+        int to = splitAt(end);
+        for (int i = from; i < to; i++) {
+            Run r = runs.get(i);
+            SimpleAttributeSet now = new SimpleAttributeSet();
+            if (!replace) {
+                now.addAttributes(r.attributes);
+            }
+            now.addAttributes(s);
+            r.attributes = now;
+        }
+        tidy();
+        changed(start, end - start);
+    }
+
+    @Override
+    public void setParagraphAttributes(int offset, int length, AttributeSet s, boolean replace) {
+        if (s == null) {
+            return;
+        }
+        int first = paragraphIndex(offset);
+        int last = paragraphIndex(offset + (length > 0 ? length - 1 : 0));
+        for (int i = first; i <= last; i++) {
+            MutableAttributeSet p = paragraphs.get(i);
+            if (replace) {
+                p.removeAttributes(p);
+            }
+            p.addAttributes(s);
+        }
+        int start = paragraphStart(first);
+        changed(start, Math.max(0, paragraphEnd(last) - start));
+    }
+
+    @Override
+    public void setLogicalStyle(int pos, Style s) {
+        MutableAttributeSet p = paragraphs.get(paragraphIndex(pos));
+        if (s != null) {
+            p.setResolveParent(s);
+            s.removeChangeListener(styleListener);
+            s.addChangeListener(styleListener);
+        } else {
+            p.removeAttribute(StyleConstants.ResolveAttribute);
+        }
+        int i = paragraphIndex(pos);
+        int start = paragraphStart(i);
+        changed(start, Math.max(0, paragraphEnd(i) - start));
+    }
+
+    @Override
+    public Style getLogicalStyle(int p) {
+        AttributeSet a = paragraphs.get(paragraphIndex(p)).getResolveParent();
+        return a instanceof Style ? (Style) a : null;
+    }
+
+    // ------------------------------------------------------------ structure
+
+    /// The paragraph an offset is in; one past the end is in the last.
+    private int paragraphIndex(int pos) {
+        CharSequence text = cn1Chars();
+        int p = Math.max(0, Math.min(pos, text.length()));
+        return Math.min(breaks(text, 0, p), paragraphs.size() - 1);
+    }
+
+    private int paragraphStart(int index) {
+        CharSequence text = cn1Chars();
+        int n = 0;
+        for (int i = 0; i < text.length() && n < index; i++) {
+            if (text.charAt(i) == '\n') {
+                n++;
+                if (n == index) {
+                    return i + 1;
+                }
+            }
+        }
+        return index <= 0 ? 0 : text.length();
+    }
+
+    /// One past the paragraph: past its line break, or past the break
+    /// that is taken to end the document.
+    private int paragraphEnd(int index) {
+        CharSequence text = cn1Chars();
+        for (int i = paragraphStart(index); i < text.length(); i++) {
+            if (text.charAt(i) == '\n') {
+                return i + 1;
+            }
+        }
+        return text.length() + 1;
+    }
+
+    @Override
+    public Element getDefaultRootElement() {
+        return section;
+    }
+
+    @Override
+    public Element getParagraphElement(int pos) {
+        return new Paragraph(paragraphIndex(pos));
+    }
+
+    @Override
+    public Element getCharacterElement(int pos) {
+        Paragraph p = new Paragraph(paragraphIndex(pos));
+        int clamped = Math.max(0, Math.min(pos, getLength()));
+        return p.getElement(p.getElementIndex(clamped));
+    }
+
+    /// What an element answers for its attributes: its own, and what
+    /// they lack looked up in the element above.
+    private static final class Attributes implements AttributeSet {
+
+        private final AttributeSet own;
+        private final AttributeSet parent;
+
+        Attributes(AttributeSet own, AttributeSet parent) {
+            this.own = own;
+            this.parent = parent;
+        }
+
+        @Override
+        public int getAttributeCount() {
+            return own.getAttributeCount();
+        }
+
+        @Override
+        public boolean isDefined(Object attrName) {
+            return own.isDefined(attrName);
+        }
+
+        @Override
+        public boolean isEqual(AttributeSet attr) {
+            return attr != null && getAttributeCount() == attr.getAttributeCount() && containsAttributes(attr);
+        }
+
+        @Override
+        public AttributeSet copyAttributes() {
+            return new SimpleAttributeSet(own);
+        }
+
+        @Override
+        public Object getAttribute(Object key) {
+            Object v = own.getAttribute(key);
+            if (v == null && parent != null) {
+                v = parent.getAttribute(key);
+            }
+            return v;
+        }
+
+        @Override
+        public Enumeration<?> getAttributeNames() {
+            return own.getAttributeNames();
+        }
+
+        @Override
+        public boolean containsAttribute(Object name, Object value) {
+            return value != null && value.equals(getAttribute(name));
+        }
+
+        @Override
+        public boolean containsAttributes(AttributeSet attributes) {
+            Enumeration<?> names = attributes.getAttributeNames();
+            while (names.hasMoreElements()) {
+                Object name = names.nextElement();
+                Object v = attributes.getAttribute(name);
+                if (v == null || !v.equals(getAttribute(name))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override
+        public AttributeSet getResolveParent() {
+            AttributeSet set = own.getResolveParent();
+            return set != null ? set : parent;
+        }
+    }
+
+    private final class Section implements Element {
+
+        @Override
+        public Document getDocument() {
+            return DefaultStyledDocument.this;
+        }
+
+        @Override
+        public Element getParentElement() {
+            return null;
+        }
+
+        @Override
+        public String getName() {
+            return SectionElementName;
+        }
+
+        @Override
+        public AttributeSet getAttributes() {
+            return SimpleAttributeSet.EMPTY;
+        }
+
+        @Override
+        public int getStartOffset() {
+            return 0;
+        }
+
+        @Override
+        public int getEndOffset() {
+            return getLength() + 1;
+        }
+
+        @Override
+        public int getElementIndex(int offset) {
+            return paragraphIndex(offset);
+        }
+
+        @Override
+        public int getElementCount() {
+            return paragraphs.size();
+        }
+
+        @Override
+        public Element getElement(int index) {
+            return index < 0 || index >= paragraphs.size() ? null : new Paragraph(index);
+        }
+
+        @Override
+        public boolean isLeaf() {
+            return false;
+        }
+    }
+
+    private final class Paragraph implements Element {
+
+        private final int index;
+        private final int start;
+        private final int end;
+        private final AttributeSet attributes;
+        private final int[] bounds;
+        private final AttributeSet[] sets;
+
+        Paragraph(int index) {
+            this.index = index;
+            start = paragraphStart(index);
+            end = paragraphEnd(index);
+            attributes = paragraphs.get(index);
+            // The runs that lie in the paragraph, cut to it. The break
+            // taken to end the document belongs to the last run.
+            ArrayList<int[]> cuts = new ArrayList<int[]>();
+            ArrayList<AttributeSet> attrs = new ArrayList<AttributeSet>();
+            int at = 0;
+            for (int i = 0; i < runs.size(); i++) {
+                Run r = runs.get(i);
+                int a = Math.max(at, start);
+                int b = Math.min(at + r.length, end);
+                if (a < b) {
+                    cuts.add(new int[]{a, b});
+                    attrs.add(r.attributes);
+                }
+                at += r.length;
+            }
+            if (cuts.isEmpty()) {
+                cuts.add(new int[]{start, end});
+                attrs.add(SimpleAttributeSet.EMPTY);
+            } else {
+                cuts.get(cuts.size() - 1)[1] = end;
+            }
+            bounds = new int[cuts.size() + 1];
+            sets = new AttributeSet[cuts.size()];
+            for (int i = 0; i < cuts.size(); i++) {
+                bounds[i] = cuts.get(i)[0];
+                sets[i] = attrs.get(i);
+            }
+            bounds[cuts.size()] = end;
+        }
+
+        @Override
+        public Document getDocument() {
+            return DefaultStyledDocument.this;
+        }
+
+        @Override
+        public Element getParentElement() {
+            return section;
+        }
+
+        @Override
+        public String getName() {
+            return ParagraphElementName;
+        }
+
+        @Override
+        public AttributeSet getAttributes() {
+            return attributes;
+        }
+
+        @Override
+        public int getStartOffset() {
+            return start;
+        }
+
+        @Override
+        public int getEndOffset() {
+            return end;
+        }
+
+        @Override
+        public int getElementIndex(int offset) {
+            for (int i = 0; i < sets.length; i++) {
+                if (offset < bounds[i + 1]) {
+                    return i;
+                }
+            }
+            return sets.length - 1;
+        }
+
+        @Override
+        public int getElementCount() {
+            return sets.length;
+        }
+
+        @Override
+        public Element getElement(int i) {
+            if (i < 0 || i >= sets.length) {
+                return null;
+            }
+            return new Content(this, bounds[i], bounds[i + 1], new Attributes(sets[i], attributes));
+        }
+
+        @Override
+        public boolean isLeaf() {
+            return false;
+        }
+
+        @Override
+        public String toString() {
+            return "BranchElement(" + getName() + ") " + start + "," + end + " #" + index;
+        }
+    }
+
+    private final class Content implements Element {
+
+        private final Element parent;
+        private final int start;
+        private final int end;
+        private final AttributeSet attributes;
+
+        Content(Element parent, int start, int end, AttributeSet attributes) {
+            this.parent = parent;
+            this.start = start;
+            this.end = end;
+            this.attributes = attributes;
+        }
+
+        @Override
+        public Document getDocument() {
+            return DefaultStyledDocument.this;
+        }
+
+        @Override
+        public Element getParentElement() {
+            return parent;
+        }
+
+        @Override
+        public String getName() {
+            return ContentElementName;
+        }
+
+        @Override
+        public AttributeSet getAttributes() {
+            return attributes;
+        }
+
+        @Override
+        public int getStartOffset() {
+            return start;
+        }
+
+        @Override
+        public int getEndOffset() {
+            return end;
+        }
+
+        @Override
+        public int getElementIndex(int offset) {
+            return -1;
+        }
+
+        @Override
+        public int getElementCount() {
+            return 0;
+        }
+
+        @Override
+        public Element getElement(int i) {
+            return null;
+        }
+
+        @Override
+        public boolean isLeaf() {
+            return true;
+        }
+
+        @Override
+        public String toString() {
+            return "LeafElement(" + getName() + ") " + start + "," + end;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Document.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Document.java
new file mode 100644
index 00000000000..2c23111f071
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Document.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditListener;
+
+/// The text a text component shows and edits.
+///
+/// Rendering under a read lock is not part of this layer, so `render` is
+/// absent: every document here is read and written on the event dispatch
+/// thread.
+public interface Document {
+
+    String StreamDescriptionProperty = "stream";
+
+    String TitleProperty = "title";
+
+    int getLength();
+
+    void addDocumentListener(DocumentListener listener);
+
+    void removeDocumentListener(DocumentListener listener);
+
+    /// Hears about every insertion and removal as an edit that can be
+    /// undone.
+    void addUndoableEditListener(UndoableEditListener listener);
+
+    void removeUndoableEditListener(UndoableEditListener listener);
+
+    Object getProperty(Object key);
+
+    void putProperty(Object key, Object value);
+
+    void remove(int offs, int len) throws BadLocationException;
+
+    void insertString(int offset, String str, AttributeSet a) throws BadLocationException;
+
+    String getText(int offset, int length) throws BadLocationException;
+
+    /// Fills `txt` with `length` characters from `offset`.
+    void getText(int offset, int length, Segment txt) throws BadLocationException;
+
+    Position getStartPosition();
+
+    Position getEndPosition();
+
+    Position createPosition(int offs) throws BadLocationException;
+
+    Element[] getRootElements();
+
+    Element getDefaultRootElement();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DocumentFilter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DocumentFilter.java
new file mode 100644
index 00000000000..2cad978b7a6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/DocumentFilter.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+/// Sees every change before it reaches a document and may let it through,
+/// change it or drop it. Text typed into the Codename One widget behind a
+/// text component passes through the filter too: what the filter refuses
+/// is taken back out of the widget.
+public class DocumentFilter {
+
+    public DocumentFilter() {
+    }
+
+    public void remove(FilterBypass fb, int offset, int length) throws BadLocationException {
+        fb.remove(offset, length);
+    }
+
+    public void insertString(FilterBypass fb, int offset, String string, AttributeSet attr)
+            throws BadLocationException {
+        fb.insertString(offset, string, attr);
+    }
+
+    public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attrs)
+            throws BadLocationException {
+        fb.replace(offset, length, text, attrs);
+    }
+
+    /// The way around the filter, for the filter itself.
+    public abstract static class FilterBypass {
+
+        public FilterBypass() {
+        }
+
+        public abstract Document getDocument();
+
+        public abstract void remove(int offset, int length) throws BadLocationException;
+
+        public abstract void insertString(int offset, String string, AttributeSet attr) throws BadLocationException;
+
+        public abstract void replace(int offset, int length, String string, AttributeSet attrs)
+                throws BadLocationException;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Element.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Element.java
new file mode 100644
index 00000000000..7cd8b6887f3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Element.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+/// A piece of a document's structure. A plain document has a root whose
+/// children are its lines.
+public interface Element {
+
+    Document getDocument();
+
+    Element getParentElement();
+
+    String getName();
+
+    AttributeSet getAttributes();
+
+    int getStartOffset();
+
+    int getEndOffset();
+
+    int getElementIndex(int offset);
+
+    int getElementCount();
+
+    Element getElement(int index);
+
+    boolean isLeaf();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/JTextComponent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/JTextComponent.java
new file mode 100644
index 00000000000..a058791e144
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/JTextComponent.java
@@ -0,0 +1,861 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.InputVerifier;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JViewport;
+import com.codename1.desktopcompat.javax.swing.Scrollable;
+import com.codename1.desktopcompat.javax.swing.event.CaretEvent;
+import com.codename1.desktopcompat.javax.swing.event.CaretListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.ui.Display;
+import com.codename1.ui.events.DataChangedListener;
+
+/// The base of the text components.
+///
+/// The [Document] is the model and the Codename One text widget is the
+/// editor, and the two are kept the same in both directions. A change of
+/// the document is written to the widget. What the user types into the
+/// widget is compared with the document and applied to it as one
+/// replacement of the characters that differ, through the document's
+/// [DocumentFilter]; when the filter refused or altered the edit the
+/// widget is set back to what the document then holds. Document listeners
+/// therefore see insert and remove events with real offsets for native
+/// typing.
+///
+/// The caret is a dot and a mark kept on this side. It follows the text
+/// (an insertion at or before it pushes it along), and the selection it
+/// describes drives `getSelectedText`, `replaceSelection`, cut, copy and
+/// paste -- through the Codename One clipboard -- but is not highlighted
+/// in the widget. [#getActions] answers the editing actions of
+/// [DefaultEditorKit] that this layer carries out. Not supported: key maps,
+/// highlighters, `modelToView`/`viewToModel`, reading and writing streams,
+/// input methods and printing. [#setDragEnabled] is kept as a property: no
+/// drag starts from the text on its own. The input verifier, which the
+/// desktop keeps on `JComponent`, is implemented here.
+public abstract class JTextComponent extends JComponent implements Accessible, Scrollable {
+
+    public static final String FOCUS_ACCELERATOR_KEY = "focusAcceleratorKey";
+
+    public static final String DEFAULT_KEYMAP = "default";
+
+    private final Sync sync = new Sync();
+    private Document model;
+    private Caret caret;
+    private boolean editable = true;
+    private Insets margin;
+    private Color caretColor;
+    private Color selectionColor;
+    private Color selectedTextColor;
+    private Color disabledTextColor;
+    private char focusAccelerator;
+    /// The document is being written to the widget.
+    private boolean pushing;
+    /// The widget's text is being applied to the document.
+    private boolean pulling;
+    private boolean dragEnabled;
+    /// The text component that had the focus last; a menu's actions work
+    /// on it while the menu is open.
+    private static JTextComponent lastFocused;
+
+    public JTextComponent() {
+        setCaret(new DefaultCaret());
+    }
+
+    // ------------------------------------------------------------ peer
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (p instanceof com.codename1.ui.TextArea) {
+            com.codename1.ui.TextArea t = (com.codename1.ui.TextArea) p;
+            pushing = true;
+            try {
+                t.setText(getText());
+            } finally {
+                pushing = false;
+            }
+            t.setEditable(editable);
+            t.addDataChangedListener(new DataChangedListener() {
+                @Override
+                public void dataChanged(int type, int index) {
+                    cn1PullText();
+                }
+            });
+            applyMargin();
+        }
+    }
+
+    private com.codename1.ui.TextArea nativeText() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        return p instanceof com.codename1.ui.TextArea ? (com.codename1.ui.TextArea) p : null;
+    }
+
+    /// Whether the widget's preferred size follows its text, so that a
+    /// change of the text needs a new layout.
+    protected boolean cn1GrowsWithText() {
+        return false;
+    }
+
+    /// Called when the caret moved; a text area brings it into view.
+    protected void cn1CaretMoved(int dot) {
+    }
+
+    /// Writes the document to the widget if they differ.
+    private void pushText() {
+        com.codename1.ui.TextArea t = nativeText();
+        if (t != null) {
+            String s = getText();
+            String shown = t.getText();
+            if (!s.equals(shown == null ? "" : shown)) {
+                pushing = true;
+                try {
+                    t.setText(s);
+                } finally {
+                    pushing = false;
+                }
+            }
+        }
+        if (cn1GrowsWithText()) {
+            revalidate();
+        }
+        repaint();
+    }
+
+    /// Applies what the widget shows to the document: the characters
+    /// between the common start and the common end of the two texts are
+    /// replaced, through the document filter.
+    protected void cn1PullText() {
+        com.codename1.ui.TextArea t = nativeText();
+        if (pushing || pulling || t == null || model == null) {
+            return;
+        }
+        String shown = t.getText();
+        if (shown == null) {
+            shown = "";
+        }
+        String old = getText();
+        if (shown.equals(old)) {
+            return;
+        }
+        int oldLen = old.length();
+        int newLen = shown.length();
+        int max = Math.min(oldLen, newLen);
+        int prefix = 0;
+        while (prefix < max && old.charAt(prefix) == shown.charAt(prefix)) {
+            prefix++;
+        }
+        int suffix = 0;
+        while (suffix < max - prefix && old.charAt(oldLen - 1 - suffix) == shown.charAt(newLen - 1 - suffix)) {
+            suffix++;
+        }
+        String inserted = shown.substring(prefix, newLen - suffix);
+        int removed = oldLen - prefix - suffix;
+        pulling = true;
+        try {
+            if (model instanceof AbstractDocument) {
+                ((AbstractDocument) model).replace(prefix, removed, inserted, null);
+            } else {
+                if (removed > 0) {
+                    model.remove(prefix, removed);
+                }
+                if (inserted.length() > 0) {
+                    model.insertString(prefix, inserted, null);
+                }
+            }
+        } catch (BadLocationException e) {
+            // The document refused the edit; the widget is set back below.
+            repaint();
+        } finally {
+            pulling = false;
+        }
+        String now = getText();
+        if (now.equals(shown)) {
+            caret.setDot(prefix + inserted.length());
+            if (cn1GrowsWithText()) {
+                revalidate();
+            }
+        } else {
+            pushText();
+        }
+    }
+
+    // ------------------------------------------------------------ document
+
+    public Document getDocument() {
+        return model;
+    }
+
+    public void setDocument(Document doc) {
+        Document old = model;
+        if (old != null) {
+            old.removeDocumentListener(sync);
+        }
+        model = doc;
+        if (doc != null) {
+            doc.addDocumentListener(sync);
+        }
+        firePropertyChange("document", old, doc);
+        if (caret != null) {
+            caret.setDot(0);
+        }
+        pushText();
+    }
+
+    public String getText() {
+        Document doc = model;
+        if (doc == null) {
+            return "";
+        }
+        try {
+            return doc.getText(0, doc.getLength());
+        } catch (BadLocationException e) {
+            return "";
+        }
+    }
+
+    public String getText(int offs, int len) throws BadLocationException {
+        if (model == null) {
+            throw new BadLocationException("No document", offs);
+        }
+        return model.getText(offs, len);
+    }
+
+    public void setText(String t) {
+        Document doc = model;
+        if (doc == null) {
+            return;
+        }
+        try {
+            if (doc instanceof AbstractDocument) {
+                ((AbstractDocument) doc).replace(0, doc.getLength(), t, null);
+            } else {
+                doc.remove(0, doc.getLength());
+                if (t != null && t.length() > 0) {
+                    doc.insertString(0, t, null);
+                }
+            }
+        } catch (BadLocationException e) {
+            // Positions 0..length are always inside the document.
+            repaint();
+        }
+    }
+
+    private final class Sync implements DocumentListener, ChangeListener {
+
+        /// The caret is being moved by an edit whose text the widget does
+        /// not have yet.
+        private boolean deferReveal;
+        private boolean revealOwed;
+
+        @Override
+        public void insertUpdate(DocumentEvent e) {
+            int offs = e.getOffset();
+            int len = e.getLength();
+            int dot = caret.getDot();
+            int mark = caret.getMark();
+            deferReveal = true;
+            try {
+                moveCaret(mark >= offs ? mark + len : mark, dot >= offs ? dot + len : dot);
+            } finally {
+                deferReveal = false;
+            }
+            changed();
+            revealDeferred();
+        }
+
+        /// Tells the component that the caret moved once the widget has
+        /// the text that moved it. Showing the caret before that would
+        /// scroll within the size of the old text, one line short of the
+        /// end of a log that is being appended to.
+        private void revealDeferred() {
+            if (revealOwed) {
+                revealOwed = false;
+                cn1CaretMoved(caret.getDot());
+            }
+        }
+
+        @Override
+        public void removeUpdate(DocumentEvent e) {
+            int offs = e.getOffset();
+            int len = e.getLength();
+            deferReveal = true;
+            try {
+                moveCaret(after(caret.getMark(), offs, len), after(caret.getDot(), offs, len));
+            } finally {
+                deferReveal = false;
+            }
+            changed();
+            revealDeferred();
+        }
+
+        private int after(int p, int offs, int len) {
+            return p >= offs + len ? p - len : p > offs ? offs : p;
+        }
+
+        private void moveCaret(int mark, int dot) {
+            if (mark != caret.getMark() || dot != caret.getDot()) {
+                caret.setDot(mark);
+                if (dot != mark) {
+                    caret.moveDot(dot);
+                }
+            }
+        }
+
+        @Override
+        public void changedUpdate(DocumentEvent e) {
+            changed();
+        }
+
+        private void changed() {
+            if (!pulling) {
+                pushText();
+            }
+        }
+
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            int dot = caret.getDot();
+            com.codename1.ui.Component p = cn1PeerOrNull();
+            if (!pulling && p instanceof com.codename1.ui.TextField) {
+                com.codename1.ui.TextField f = (com.codename1.ui.TextField) p;
+                String s = f.getText();
+                if (dot <= (s == null ? 0 : s.length()) && f.getCursorPosition() != dot) {
+                    f.setCursorPosition(dot);
+                }
+            }
+            fireCaretUpdate(new Moved(JTextComponent.this, dot, caret.getMark()));
+            if (deferReveal) {
+                revealOwed = true;
+            } else {
+                cn1CaretMoved(dot);
+            }
+        }
+    }
+
+    private static final class Moved extends CaretEvent {
+        private static final long serialVersionUID = 1L;
+        private final int dot;
+        private final int mark;
+
+        Moved(Object source, int dot, int mark) {
+            super(source);
+            this.dot = dot;
+            this.mark = mark;
+        }
+
+        @Override
+        public int getDot() {
+            return dot;
+        }
+
+        @Override
+        public int getMark() {
+            return mark;
+        }
+    }
+
+    // ------------------------------------------------------------ caret
+
+    public Caret getCaret() {
+        return caret;
+    }
+
+    public void setCaret(Caret c) {
+        Caret old = caret;
+        if (old != null) {
+            old.removeChangeListener(sync);
+            old.deinstall(this);
+        }
+        caret = c;
+        if (c != null) {
+            c.install(this);
+            c.addChangeListener(sync);
+        }
+        firePropertyChange("caret", old, c);
+    }
+
+    public void addCaretListener(CaretListener listener) {
+        listenerList.add(CaretListener.class, listener);
+    }
+
+    public void removeCaretListener(CaretListener listener) {
+        listenerList.remove(CaretListener.class, listener);
+    }
+
+    public CaretListener[] getCaretListeners() {
+        return listenerList.getListeners(CaretListener.class);
+    }
+
+    protected void fireCaretUpdate(CaretEvent e) {
+        CaretListener[] ls = getCaretListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].caretUpdate(e);
+        }
+    }
+
+    private int length() {
+        return model == null ? 0 : model.getLength();
+    }
+
+    public int getCaretPosition() {
+        return caret.getDot();
+    }
+
+    public void setCaretPosition(int position) {
+        if (position > length() || position < 0) {
+            throw new IllegalArgumentException("bad position: " + position);
+        }
+        caret.setDot(position);
+    }
+
+    public void moveCaretPosition(int pos) {
+        if (pos > length() || pos < 0) {
+            throw new IllegalArgumentException("bad position: " + pos);
+        }
+        caret.moveDot(pos);
+    }
+
+    public int getSelectionStart() {
+        return Math.min(caret.getDot(), caret.getMark());
+    }
+
+    public void setSelectionStart(int selectionStart) {
+        select(selectionStart, getSelectionEnd());
+    }
+
+    public int getSelectionEnd() {
+        return Math.max(caret.getDot(), caret.getMark());
+    }
+
+    public void setSelectionEnd(int selectionEnd) {
+        select(getSelectionStart(), selectionEnd);
+    }
+
+    public void select(int selectionStart, int selectionEnd) {
+        int len = length();
+        if (selectionStart < 0) {
+            selectionStart = 0;
+        }
+        if (selectionStart > len) {
+            selectionStart = len;
+        }
+        if (selectionEnd > len) {
+            selectionEnd = len;
+        }
+        if (selectionEnd < selectionStart) {
+            selectionEnd = selectionStart;
+        }
+        setCaretPosition(selectionStart);
+        moveCaretPosition(selectionEnd);
+    }
+
+    public void selectAll() {
+        if (model != null) {
+            setCaretPosition(0);
+            moveCaretPosition(model.getLength());
+        }
+    }
+
+    public String getSelectedText() {
+        int p0 = getSelectionStart();
+        int p1 = getSelectionEnd();
+        if (p0 == p1 || model == null) {
+            return null;
+        }
+        try {
+            return model.getText(p0, p1 - p0);
+        } catch (BadLocationException e) {
+            throw new IllegalArgumentException(e.getMessage());
+        }
+    }
+
+    /// Puts `content` in place of the selection, or at the caret when
+    /// nothing is selected. Nothing happens when the component is not
+    /// editable.
+    public void replaceSelection(String content) {
+        Document doc = model;
+        if (doc == null || !editable) {
+            return;
+        }
+        int p0 = getSelectionStart();
+        int p1 = getSelectionEnd();
+        try {
+            if (doc instanceof AbstractDocument) {
+                ((AbstractDocument) doc).replace(p0, p1 - p0, content, null);
+            } else {
+                if (p0 != p1) {
+                    doc.remove(p0, p1 - p0);
+                }
+                if (content != null && content.length() > 0) {
+                    doc.insertString(p0, content, null);
+                }
+            }
+        } catch (BadLocationException e) {
+            // The selection is always inside the document.
+            repaint();
+        }
+    }
+
+    // ------------------------------------------------------------ geometry
+
+    /// The offset in the document nearest a point of the component: the
+    /// character whose nearer half the point is in. `-1` while the
+    /// component has no size.
+    public int viewToModel(Point pt) {
+        return cn1ViewToModel(pt.x, pt.y);
+    }
+
+    public int viewToModel2D(Point2D pt) {
+        return cn1ViewToModel((int) pt.getX(), (int) pt.getY());
+    }
+
+    /// Where the caret stands before the character at `pos`, in the
+    /// coordinates of the component: a rectangle one pixel wide and as
+    /// high as the line. `null` while the component has no size.
+    public Rectangle modelToView(int pos) throws BadLocationException {
+        if (pos < 0 || pos > length()) {
+            throw new BadLocationException("Invalid position", pos);
+        }
+        return cn1ModelToView(pos);
+    }
+
+    public Rectangle2D modelToView2D(int pos) throws BadLocationException {
+        return modelToView(pos);
+    }
+
+    /// The rows the widget shows the text in, as the offsets they start
+    /// at, with the length of the text after the last. `null` when there
+    /// is no widget that tells.
+    private int[] cn1Rows(com.codename1.ui.TextArea t, String text) {
+        if (t.isSingleLineTextArea()) {
+            return new int[]{0, text.length()};
+        }
+        int n = Math.max(1, t.getLines());
+        int[] starts = new int[n + 1];
+        int cursor = 0;
+        for (int i = 0; i < n; i++) {
+            String row = t.getTextAt(i);
+            int len = row == null ? 0 : row.length();
+            if (len > 0) {
+                int found = text.indexOf(row, cursor);
+                if (found >= 0) {
+                    cursor = found;
+                }
+            }
+            starts[i] = Math.min(cursor, text.length());
+            cursor = Math.min(text.length(), cursor + len);
+            if (cursor < text.length() && text.charAt(cursor) == '\n') {
+                cursor++;
+            }
+        }
+        starts[n] = text.length();
+        return starts;
+    }
+
+    /// One past the last character a row shows: before the line break
+    /// that ends it.
+    private static int cn1RowEnd(int[] starts, int row, String text) {
+        int end = row + 2 < starts.length ? starts[row + 1] : text.length();
+        while (end > starts[row] && end <= text.length() && text.charAt(end - 1) == '\n') {
+            end--;
+        }
+        return Math.max(starts[row], end);
+    }
+
+    /// The offset for a point; what [#viewToModel] answers. The rows are
+    /// the widget's own, so the answer follows its wrapping, and the
+    /// columns are measured with the component's font.
+    protected int cn1ViewToModel(int x, int y) {
+        com.codename1.ui.TextArea t = nativeText();
+        if (t == null || getWidth() <= 0 || getHeight() <= 0) {
+            return -1;
+        }
+        String text = getText();
+        int[] starts = cn1Rows(t, text);
+        FontMetrics fm = getFontMetrics(getFont());
+        int rowHeight = Math.max(1, cn1RowHeight(t, fm));
+        int top = Units.toLogical(t.getStyle().getPaddingTop());
+        int left = Units.toLogical(t.getStyle().getPaddingLeftNoRTL());
+        int rows = starts.length - 1;
+        int row = t.isSingleLineTextArea() ? 0 : Math.max(0, Math.min(rows - 1, (y - top) / rowHeight));
+        int end = cn1RowEnd(starts, row, text);
+        int at = left;
+        for (int i = starts[row]; i < end; i++) {
+            int cw = fm.charWidth(text.charAt(i));
+            if (x < at + cw / 2 + (cw & 1)) {
+                return i;
+            }
+            at += cw;
+        }
+        return end;
+    }
+
+    /// The caret's place for an offset; what [#modelToView] answers.
+    protected Rectangle cn1ModelToView(int pos) {
+        com.codename1.ui.TextArea t = nativeText();
+        if (t == null || getWidth() <= 0 || getHeight() <= 0) {
+            return null;
+        }
+        String text = getText();
+        int[] starts = cn1Rows(t, text);
+        FontMetrics fm = getFontMetrics(getFont());
+        int rowHeight = Math.max(1, cn1RowHeight(t, fm));
+        int top = Units.toLogical(t.getStyle().getPaddingTop());
+        int left = Units.toLogical(t.getStyle().getPaddingLeftNoRTL());
+        int row = 0;
+        for (int i = 0; i + 1 < starts.length - 1; i++) {
+            if (pos >= starts[i + 1]) {
+                row = i + 1;
+            }
+        }
+        int upTo = Math.max(starts[row], Math.min(pos, cn1RowEnd(starts, row, text)));
+        int x = left + fm.stringWidth(text.substring(starts[row], upTo));
+        if (t.isSingleLineTextArea()) {
+            return new Rectangle(x, Math.max(0, (getHeight() - fm.getHeight()) / 2), 1, fm.getHeight());
+        }
+        return new Rectangle(x, top + row * rowHeight, 1, rowHeight);
+    }
+
+    /// The distance from one row of the widget to the next.
+    private static int cn1RowHeight(com.codename1.ui.TextArea t, FontMetrics fm) {
+        com.codename1.ui.Font f = t.getStyle().getFont();
+        if (f == null) {
+            return fm.getHeight();
+        }
+        return Units.toLogical(f.getHeight() + t.getRowsGap());
+    }
+
+    // ------------------------------------------------------------ actions
+
+    /// The editing commands of this component: cut, copy, paste, select
+    /// all, insert break and insert tab, under their `DefaultEditorKit`
+    /// names. Each works on the text component it is fired from, or on the
+    /// one that had the focus last.
+    public Action[] getActions() {
+        return new DefaultEditorKit().getActions();
+    }
+
+    /// Records whether dragging the selection out of the component is
+    /// wanted. No drag is started by the layer.
+    public void setDragEnabled(boolean b) {
+        dragEnabled = b;
+    }
+
+    public boolean getDragEnabled() {
+        return dragEnabled;
+    }
+
+    /// The text component that has, or last had, the focus; null when
+    /// none did or it is no longer showing.
+    static JTextComponent cn1LastFocused() {
+        JTextComponent c = lastFocused;
+        return c != null && c.isShowing() ? c : null;
+    }
+
+    private static void cn1RememberFocus(JTextComponent c) {
+        lastFocused = c;
+    }
+
+    // ------------------------------------------------------------ clipboard
+
+    public void copy() {
+        String s = getSelectedText();
+        if (s != null && Display.isInitialized()) {
+            Display.getInstance().copyToClipboard(s);
+        }
+    }
+
+    public void cut() {
+        if (editable && isEnabled() && getSelectedText() != null) {
+            copy();
+            replaceSelection("");
+        }
+    }
+
+    public void paste() {
+        if (editable && isEnabled() && Display.isInitialized()) {
+            Object o = Display.getInstance().getPasteDataFromClipboard();
+            if (o instanceof String) {
+                replaceSelection((String) o);
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ properties
+
+    public boolean isEditable() {
+        return editable;
+    }
+
+    public void setEditable(boolean b) {
+        if (b != editable) {
+            boolean old = editable;
+            editable = b;
+            com.codename1.ui.TextArea t = nativeText();
+            if (t != null) {
+                t.setEditable(b);
+            }
+            firePropertyChange("editable", old, b);
+            repaint();
+        }
+    }
+
+    public Insets getMargin() {
+        return margin;
+    }
+
+    /// The space between the text and the edge of the widget, which
+    /// becomes the widget's padding.
+    public void setMargin(Insets m) {
+        Insets old = margin;
+        margin = m;
+        firePropertyChange("margin", old, m);
+        applyMargin();
+        revalidate();
+    }
+
+    private void applyMargin() {
+        com.codename1.ui.TextArea t = nativeText();
+        if (t != null && margin != null) {
+            com.codename1.ui.plaf.Style s = com.codename1.desktopcompat.rt.PeerSupport.allStyles(t);
+            s.setPaddingUnit(com.codename1.ui.plaf.Style.UNIT_TYPE_PIXELS);
+            s.setPadding(Units.toDevice(margin.top), Units.toDevice(margin.bottom), Units.toDevice(margin.left),
+                    Units.toDevice(margin.right));
+        }
+    }
+
+    public Color getCaretColor() {
+        return caretColor;
+    }
+
+    /// Recorded only.
+    public void setCaretColor(Color c) {
+        caretColor = c;
+    }
+
+    public Color getSelectionColor() {
+        return selectionColor;
+    }
+
+    /// Recorded only.
+    public void setSelectionColor(Color c) {
+        selectionColor = c;
+    }
+
+    public Color getSelectedTextColor() {
+        return selectedTextColor;
+    }
+
+    /// Recorded only.
+    public void setSelectedTextColor(Color c) {
+        selectedTextColor = c;
+    }
+
+    public Color getDisabledTextColor() {
+        return disabledTextColor;
+    }
+
+    /// Recorded only.
+    public void setDisabledTextColor(Color c) {
+        disabledTextColor = c;
+    }
+
+    /// Recorded only.
+    public void setFocusAccelerator(char aKey) {
+        focusAccelerator = aKey;
+    }
+
+    public char getFocusAccelerator() {
+        return focusAccelerator;
+    }
+
+    // ------------------------------------------------------------ verifier
+
+    /// Asks the input verifier before the focus leaves: when it does not
+    /// yield, the focus comes back here.
+    @Override
+    protected void processFocusEvent(FocusEvent e) {
+        super.processFocusEvent(e);
+        if (e.getID() == FocusEvent.FOCUS_GAINED) {
+            cn1RememberFocus(this);
+        }
+        InputVerifier inputVerifier = getInputVerifier();
+        if (e.getID() == FocusEvent.FOCUS_LOST && e.getOppositeComponent() == null && inputVerifier != null
+                && !inputVerifier.shouldYieldFocus(this)) {
+            requestFocusInWindow();
+        }
+    }
+
+    // ------------------------------------------------------------ scrollable
+
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        return getPreferredSize();
+    }
+
+    @Override
+    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+        int span = orientation == com.codename1.desktopcompat.javax.swing.SwingConstants.VERTICAL
+                ? visibleRect.height : visibleRect.width;
+        return Math.max(1, span / 10);
+    }
+
+    @Override
+    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
+        return orientation == com.codename1.desktopcompat.javax.swing.SwingConstants.VERTICAL
+                ? visibleRect.height : visibleRect.width;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        return getParent() instanceof JViewport && getParent().getWidth() > getPreferredSize().width;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportHeight() {
+        return getParent() instanceof JViewport && getParent().getHeight() > getPreferredSize().height;
+    }
+
+    @Override
+    protected String paramString() {
+        return super.paramString() + ",editable=" + editable;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/MutableAttributeSet.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/MutableAttributeSet.java
new file mode 100644
index 00000000000..7f004f7cc04
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/MutableAttributeSet.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import java.util.Enumeration;
+
+/// A set of attributes that can be changed.
+public interface MutableAttributeSet extends AttributeSet {
+
+    void addAttribute(Object name, Object value);
+
+    void addAttributes(AttributeSet attributes);
+
+    void removeAttribute(Object name);
+
+    void removeAttributes(Enumeration<?> names);
+
+    /// Removes the attributes that `attributes` has with the same value.
+    void removeAttributes(AttributeSet attributes);
+
+    /// Sets the set an attribute is looked up in when this one lacks it.
+    void setResolveParent(AttributeSet parent);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/NumberFormatter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/NumberFormatter.java
new file mode 100644
index 00000000000..736a87fa31d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/NumberFormatter.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import java.text.NumberFormat;
+import java.text.ParseException;
+
+/// Formats numbers through a `NumberFormat`, keeps them inside an optional
+/// range, and reads them back as the value class.
+///
+/// On the desktop this class sits two levels further down, under a
+/// formatter for any `java.text.Format`; here it holds the number format
+/// itself.
+public class NumberFormatter extends DefaultFormatter {
+
+    private NumberFormat numberFormat;
+    private Comparable<?> min;
+    private Comparable<?> max;
+
+    public NumberFormatter() {
+        this(NumberFormat.getNumberInstance());
+    }
+
+    public NumberFormatter(NumberFormat format) {
+        numberFormat = format;
+        setOverwriteMode(false);
+    }
+
+    public void setMinimum(Comparable minimum) {
+        min = minimum;
+    }
+
+    public Comparable getMinimum() {
+        return min;
+    }
+
+    public void setMaximum(Comparable max) {
+        this.max = max;
+    }
+
+    public Comparable getMaximum() {
+        return max;
+    }
+
+    @Override
+    public Object stringToValue(String text) throws ParseException {
+        if (text == null || text.length() == 0) {
+            return null;
+        }
+        NumberFormat f = numberFormat;
+        Object parsed = f == null ? (Object) text : f.parse(text);
+        Object value = parsed instanceof Number ? convert((Number) parsed) : parsed;
+        if (!inRange(value)) {
+            throw new ParseException("Value not within min/max range", 0);
+        }
+        return value;
+    }
+
+    @Override
+    public String valueToString(Object value) throws ParseException {
+        if (value == null) {
+            return "";
+        }
+        NumberFormat f = numberFormat;
+        if (f == null || !(value instanceof Number)) {
+            return value.toString();
+        }
+        if (value instanceof Double || value instanceof Float) {
+            return f.format(((Number) value).doubleValue());
+        }
+        return f.format(((Number) value).longValue());
+    }
+
+    private Object convert(Number n) {
+        Class<?> vc = getValueClass();
+        if (vc == null && getFormattedTextField() != null) {
+            Object current = getFormattedTextField().getValue();
+            if (current != null) {
+                vc = current.getClass();
+            }
+        }
+        if (vc == Integer.class) {
+            return Integer.valueOf(n.intValue());
+        } else if (vc == Long.class) {
+            return Long.valueOf(n.longValue());
+        } else if (vc == Double.class) {
+            return Double.valueOf(n.doubleValue());
+        } else if (vc == Float.class) {
+            return Float.valueOf(n.floatValue());
+        } else if (vc == Short.class) {
+            return Short.valueOf(n.shortValue());
+        } else if (vc == Byte.class) {
+            return Byte.valueOf(n.byteValue());
+        }
+        return n;
+    }
+
+    private static int compare(Object value, Object bound) {
+        if (value instanceof Number && bound instanceof Number) {
+            double a = ((Number) value).doubleValue();
+            double b = ((Number) bound).doubleValue();
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
+        return 0;
+    }
+
+    private boolean inRange(Object value) {
+        if (value == null) {
+            return true;
+        }
+        return (min == null || compare(value, min) >= 0) && (max == null || compare(value, max) <= 0);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/PlainDocument.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/PlainDocument.java
new file mode 100644
index 00000000000..1e7358a8c31
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/PlainDocument.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+/// A document of plain text whose structure is its lines.
+///
+/// With the property `filterNewlines` set to `Boolean.TRUE`, as a single
+/// line field sets it, line breaks in inserted text become spaces.
+public class PlainDocument extends AbstractDocument {
+
+    public static final String tabSizeAttribute = "tabSize";
+
+    public static final String lineLimitAttribute = "lineLimit";
+
+    private final Root root = new Root();
+    private int[] lineStarts;
+    private int lineStartsAt = -1;
+
+    public PlainDocument() {
+        putProperty(tabSizeAttribute, Integer.valueOf(8));
+    }
+
+    /// Applied to every insertion whichever way it arrives -- `insertString`,
+    /// `replace` or the filter's bypass -- the way the desktop does it in
+    /// its `insertUpdate`.
+    @Override
+    String cn1FilterInsert(String str) {
+        Object filter = getProperty("filterNewlines");
+        if (Boolean.TRUE.equals(filter) && str.indexOf('\n') >= 0) {
+            StringBuilder filtered = new StringBuilder(str);
+            for (int i = 0; i < filtered.length(); i++) {
+                if (filtered.charAt(i) == '\n') {
+                    filtered.setCharAt(i, ' ');
+                }
+            }
+            return filtered.toString();
+        }
+        return str;
+    }
+
+    /// The offsets the lines start at; always at least one line.
+    private int[] lines() {
+        if (lineStarts == null || lineStartsAt != cn1ModCount()) {
+            CharSequence s = cn1Chars();
+            int n = 1;
+            for (int i = 0; i < s.length(); i++) {
+                if (s.charAt(i) == '\n') {
+                    n++;
+                }
+            }
+            int[] starts = new int[n];
+            int at = 1;
+            for (int i = 0; i < s.length(); i++) {
+                if (s.charAt(i) == '\n') {
+                    starts[at++] = i + 1;
+                }
+            }
+            lineStarts = starts;
+            lineStartsAt = cn1ModCount();
+        }
+        return lineStarts;
+    }
+
+    private int lineOf(int offset) {
+        int[] starts = lines();
+        int lo = 0;
+        int hi = starts.length - 1;
+        while (lo < hi) {
+            int mid = (lo + hi + 1) >>> 1;
+            if (starts[mid] <= offset) {
+                lo = mid;
+            } else {
+                hi = mid - 1;
+            }
+        }
+        return lo;
+    }
+
+    @Override
+    public Element getDefaultRootElement() {
+        return root;
+    }
+
+    @Override
+    public Element getParagraphElement(int pos) {
+        return root.getElement(lineOf(pos));
+    }
+
+    /// The attribute set of an element: nothing but its name.
+    private static final class Name implements AttributeSet {
+        private final String name;
+
+        Name(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public int getAttributeCount() {
+            return 1;
+        }
+
+        @Override
+        public boolean isDefined(Object attrName) {
+            return ElementNameAttribute.equals(attrName);
+        }
+
+        @Override
+        public boolean isEqual(AttributeSet attr) {
+            return attr != null && attr.getAttributeCount() == 1
+                    && name.equals(attr.getAttribute(ElementNameAttribute));
+        }
+
+        @Override
+        public AttributeSet copyAttributes() {
+            return this;
+        }
+
+        @Override
+        public Object getAttribute(Object key) {
+            return ElementNameAttribute.equals(key) ? name : null;
+        }
+
+        @Override
+        public Enumeration<?> getAttributeNames() {
+            Vector<Object> v = new Vector<Object>();
+            v.addElement(ElementNameAttribute);
+            return v.elements();
+        }
+
+        @Override
+        public boolean containsAttribute(Object key, Object value) {
+            return ElementNameAttribute.equals(key) && name.equals(value);
+        }
+
+        @Override
+        public boolean containsAttributes(AttributeSet attributes) {
+            return attributes == null || attributes.getAttributeCount() == 0 || isEqual(attributes);
+        }
+
+        @Override
+        public AttributeSet getResolveParent() {
+            return null;
+        }
+    }
+
+    private final class Root implements Element {
+        private final AttributeSet attributes = new Name(ParagraphElementName);
+
+        @Override
+        public Document getDocument() {
+            return PlainDocument.this;
+        }
+
+        @Override
+        public Element getParentElement() {
+            return null;
+        }
+
+        @Override
+        public String getName() {
+            return ParagraphElementName;
+        }
+
+        @Override
+        public AttributeSet getAttributes() {
+            return attributes;
+        }
+
+        @Override
+        public int getStartOffset() {
+            return 0;
+        }
+
+        @Override
+        public int getEndOffset() {
+            return getLength() + 1;
+        }
+
+        @Override
+        public int getElementIndex(int offset) {
+            return lineOf(offset < 0 ? 0 : offset);
+        }
+
+        @Override
+        public int getElementCount() {
+            return lines().length;
+        }
+
+        @Override
+        public Element getElement(int index) {
+            if (index < 0 || index >= lines().length) {
+                return null;
+            }
+            return new Line(index);
+        }
+
+        @Override
+        public boolean isLeaf() {
+            return false;
+        }
+    }
+
+    /// One line. Its end is the offset after its line break, and for the
+    /// last line one past the end of the text, as on the desktop.
+    private final class Line implements Element {
+        private final int index;
+        private final AttributeSet attributes = new Name(ContentElementName);
+
+        Line(int index) {
+            this.index = index;
+        }
+
+        @Override
+        public Document getDocument() {
+            return PlainDocument.this;
+        }
+
+        @Override
+        public Element getParentElement() {
+            return root;
+        }
+
+        @Override
+        public String getName() {
+            return ContentElementName;
+        }
+
+        @Override
+        public AttributeSet getAttributes() {
+            return attributes;
+        }
+
+        @Override
+        public int getStartOffset() {
+            int[] starts = lines();
+            return index < starts.length ? starts[index] : getLength();
+        }
+
+        @Override
+        public int getEndOffset() {
+            int[] starts = lines();
+            return index + 1 < starts.length ? starts[index + 1] : getLength() + 1;
+        }
+
+        @Override
+        public int getElementIndex(int offset) {
+            return -1;
+        }
+
+        @Override
+        public int getElementCount() {
+            return 0;
+        }
+
+        @Override
+        public Element getElement(int i) {
+            return null;
+        }
+
+        @Override
+        public boolean isLeaf() {
+            return true;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Position.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Position.java
new file mode 100644
index 00000000000..ebbc40e241c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Position.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+/// A place in a document that moves with the text around it.
+public interface Position {
+
+    int getOffset();
+
+    /// Which of the two characters around a position it belongs to.
+    final class Bias {
+
+        public static final Bias Forward = new Bias("Forward");
+
+        public static final Bias Backward = new Bias("Backward");
+
+        private final String name;
+
+        private Bias(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Segment.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Segment.java
new file mode 100644
index 00000000000..80109a80e53
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Segment.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+/// A run of characters inside an array: `count` characters of `array`
+/// starting at `offset`. A document fills one in for
+/// `getText(int, int, Segment)`; the array then belongs to the caller.
+///
+/// The character iterator of the JDK class is not part of this layer.
+public class Segment implements CharSequence {
+
+    /// The array the characters are in.
+    public char[] array;
+
+    /// Where in the array the run starts.
+    public int offset;
+
+    /// How many characters the run has.
+    public int count;
+
+    private boolean partialReturn;
+
+    public Segment() {
+        this(null, 0, 0);
+    }
+
+    public Segment(char[] array, int offset, int count) {
+        this.array = array;
+        this.offset = offset;
+        this.count = count;
+    }
+
+    /// Asks the document for whatever part of a request it can give
+    /// without copying. The documents here always fill the whole request.
+    public void setPartialReturn(boolean p) {
+        partialReturn = p;
+    }
+
+    public boolean isPartialReturn() {
+        return partialReturn;
+    }
+
+    @Override
+    public String toString() {
+        if (array != null) {
+            return new String(array, offset, count);
+        }
+        return "";
+    }
+
+    @Override
+    public char charAt(int index) {
+        if (index < 0 || index >= count) {
+            throw new StringIndexOutOfBoundsException(index);
+        }
+        return array[offset + index];
+    }
+
+    @Override
+    public int length() {
+        return count;
+    }
+
+    @Override
+    public CharSequence subSequence(int start, int end) {
+        if (start < 0) {
+            throw new StringIndexOutOfBoundsException(start);
+        }
+        if (end > count) {
+            throw new StringIndexOutOfBoundsException(end);
+        }
+        if (start > end) {
+            throw new StringIndexOutOfBoundsException(end - start);
+        }
+        Segment segment = new Segment();
+        segment.array = this.array;
+        segment.offset = this.offset + start;
+        segment.count = end - start;
+        return segment;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/SimpleAttributeSet.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/SimpleAttributeSet.java
new file mode 100644
index 00000000000..877a4a831b5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/SimpleAttributeSet.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.LinkedHashMap;
+
+/// A set of attributes kept in a table.
+///
+/// An attribute this set lacks is looked up in its resolve parent, when
+/// it has one; the count, the names and [#isDefined] are of this set
+/// alone.
+public class SimpleAttributeSet implements MutableAttributeSet {
+
+    /// A set with nothing in it, which cannot be changed.
+    public static final AttributeSet EMPTY = new EmptyAttributeSet();
+
+    private final LinkedHashMap<Object, Object> table = new LinkedHashMap<Object, Object>(3);
+
+    public SimpleAttributeSet() {
+    }
+
+    /// A set with the attributes of `source`.
+    public SimpleAttributeSet(AttributeSet source) {
+        addAttributes(source);
+    }
+
+    public boolean isEmpty() {
+        return table.isEmpty();
+    }
+
+    @Override
+    public int getAttributeCount() {
+        return table.size();
+    }
+
+    @Override
+    public boolean isDefined(Object attrName) {
+        return table.containsKey(attrName);
+    }
+
+    @Override
+    public boolean isEqual(AttributeSet attr) {
+        return getAttributeCount() == attr.getAttributeCount() && containsAttributes(attr);
+    }
+
+    @Override
+    public AttributeSet copyAttributes() {
+        return new SimpleAttributeSet(this);
+    }
+
+    @Override
+    public Enumeration<?> getAttributeNames() {
+        return new Names(new ArrayList<Object>(table.keySet()));
+    }
+
+    @Override
+    public Object getAttribute(Object name) {
+        Object value = table.get(name);
+        if (value == null) {
+            AttributeSet parent = getResolveParent();
+            if (parent != null) {
+                value = parent.getAttribute(name);
+            }
+        }
+        return value;
+    }
+
+    @Override
+    public boolean containsAttribute(Object name, Object value) {
+        return value.equals(getAttribute(name));
+    }
+
+    @Override
+    public boolean containsAttributes(AttributeSet attributes) {
+        boolean result = true;
+        Enumeration<?> names = attributes.getAttributeNames();
+        while (result && names.hasMoreElements()) {
+            Object name = names.nextElement();
+            result = attributes.getAttribute(name).equals(getAttribute(name));
+        }
+        return result;
+    }
+
+    @Override
+    public void addAttribute(Object name, Object value) {
+        table.put(name, value);
+    }
+
+    @Override
+    public void addAttributes(AttributeSet attributes) {
+        Enumeration<?> names = attributes.getAttributeNames();
+        while (names.hasMoreElements()) {
+            Object name = names.nextElement();
+            addAttribute(name, attributes.getAttribute(name));
+        }
+    }
+
+    @Override
+    public void removeAttribute(Object name) {
+        table.remove(name);
+    }
+
+    @Override
+    public void removeAttributes(Enumeration<?> names) {
+        while (names.hasMoreElements()) {
+            removeAttribute(names.nextElement());
+        }
+    }
+
+    @Override
+    public void removeAttributes(AttributeSet attributes) {
+        if (attributes == this) {
+            table.clear();
+            return;
+        }
+        Enumeration<?> names = attributes.getAttributeNames();
+        while (names.hasMoreElements()) {
+            Object name = names.nextElement();
+            Object value = attributes.getAttribute(name);
+            if (value.equals(getAttribute(name))) {
+                removeAttribute(name);
+            }
+        }
+    }
+
+    @Override
+    public AttributeSet getResolveParent() {
+        Object parent = table.get(StyleConstants.ResolveAttribute);
+        return parent instanceof AttributeSet ? (AttributeSet) parent : null;
+    }
+
+    @Override
+    public void setResolveParent(AttributeSet parent) {
+        addAttribute(StyleConstants.ResolveAttribute, parent);
+    }
+
+    @Override
+    public int hashCode() {
+        return table.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        return obj instanceof AttributeSet && isEqual((AttributeSet) obj);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder();
+        for (java.util.Map.Entry<Object, Object> e : table.entrySet()) {
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (value instanceof AttributeSet) {
+                // A resolve parent is named, not written out in full.
+                s.append(key).append("=**AttributeSet** ");
+            } else {
+                s.append(key).append('=').append(value).append(' ');
+            }
+        }
+        return s.toString();
+    }
+
+    /// The names of a set, as they were when it was asked.
+    static final class Names implements Enumeration<Object> {
+
+        private final ArrayList<Object> names;
+        private int next;
+
+        Names(ArrayList<Object> names) {
+            this.names = names;
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return next < names.size();
+        }
+
+        @Override
+        public Object nextElement() {
+            if (next >= names.size()) {
+                throw new java.util.NoSuchElementException();
+            }
+            return names.get(next++);
+        }
+    }
+
+    private static final class EmptyAttributeSet implements AttributeSet {
+
+        @Override
+        public int getAttributeCount() {
+            return 0;
+        }
+
+        @Override
+        public boolean isDefined(Object attrName) {
+            return false;
+        }
+
+        @Override
+        public boolean isEqual(AttributeSet attr) {
+            return attr.getAttributeCount() == 0;
+        }
+
+        @Override
+        public AttributeSet copyAttributes() {
+            return this;
+        }
+
+        @Override
+        public Object getAttribute(Object key) {
+            return null;
+        }
+
+        @Override
+        public Enumeration<?> getAttributeNames() {
+            return new Names(new ArrayList<Object>());
+        }
+
+        @Override
+        public boolean containsAttribute(Object name, Object value) {
+            return false;
+        }
+
+        @Override
+        public boolean containsAttributes(AttributeSet attributes) {
+            return attributes.getAttributeCount() == 0;
+        }
+
+        @Override
+        public AttributeSet getResolveParent() {
+            return null;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            return obj instanceof AttributeSet && ((AttributeSet) obj).getAttributeCount() == 0;
+        }
+
+        @Override
+        public int hashCode() {
+            return 0;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Style.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Style.java
new file mode 100644
index 00000000000..60a5bce3352
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/Style.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// A named set of attributes, kept by a [StyleContext] or a
+/// [StyledDocument], that tells its listeners when it changes.
+public interface Style extends MutableAttributeSet {
+
+    String getName();
+
+    void addChangeListener(ChangeListener l);
+
+    void removeChangeListener(ChangeListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyleConstants.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyleConstants.java
new file mode 100644
index 00000000000..9ceb04a9f78
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyleConstants.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Color;
+
+/// The well known attribute names of styled text, and the typed way to
+/// read and set each.
+///
+/// The attributes here are the ones a `JTextPane` draws: the color of the
+/// text and behind it, bold, italic, underline, strike through, the font
+/// family and size, and the alignment of a paragraph. A font family is
+/// honoured as far as fonts are in this layer: a monospaced family, a
+/// font the application made with `Font.createFont`, or the platform's
+/// font for everything else. `ALIGN_JUSTIFIED` is drawn as `ALIGN_LEFT`.
+/// The rest of Swing's -- superscript, indents, spacing, tab sets, icons
+/// and components in the text -- is not here, so that code asking for it
+/// does not compile rather than draws something else.
+public class StyleConstants {
+
+    /// The font family, a `String`.
+    public static final Object FontFamily = new StyleConstants("family");
+
+    public static final Object Family = FontFamily;
+
+    /// The font size in points, an `Integer`.
+    public static final Object FontSize = new StyleConstants("size");
+
+    public static final Object Size = FontSize;
+
+    public static final Object Bold = new StyleConstants("bold");
+
+    public static final Object Italic = new StyleConstants("italic");
+
+    public static final Object Underline = new StyleConstants("underline");
+
+    public static final Object StrikeThrough = new StyleConstants("strikethrough");
+
+    /// The color of the text, a `Color`.
+    public static final Object Foreground = new StyleConstants("foreground");
+
+    /// The color behind the text, a `Color`.
+    public static final Object Background = new StyleConstants("background");
+
+    /// The alignment of a paragraph, an `Integer`: one of the `ALIGN_`
+    /// constants.
+    public static final Object Alignment = new StyleConstants("Alignment");
+
+    public static final int ALIGN_LEFT = 0;
+
+    public static final int ALIGN_CENTER = 1;
+
+    public static final int ALIGN_RIGHT = 2;
+
+    public static final int ALIGN_JUSTIFIED = 3;
+
+    /// The font family of `a`; `Monospaced` when it names none.
+    public static String getFontFamily(AttributeSet a) {
+        Object family = a.getAttribute(FontFamily);
+        return family instanceof String ? (String) family : "Monospaced";
+    }
+
+    public static void setFontFamily(MutableAttributeSet a, String fam) {
+        a.addAttribute(FontFamily, fam);
+    }
+
+    /// The font size of `a`; 12 when it names none.
+    public static int getFontSize(AttributeSet a) {
+        Object size = a.getAttribute(FontSize);
+        return size instanceof Integer ? ((Integer) size).intValue() : 12;
+    }
+
+    public static void setFontSize(MutableAttributeSet a, int s) {
+        a.addAttribute(FontSize, Integer.valueOf(s));
+    }
+
+    private static boolean flag(AttributeSet a, Object key) {
+        Object v = a.getAttribute(key);
+        return v instanceof Boolean && ((Boolean) v).booleanValue();
+    }
+
+    public static boolean isBold(AttributeSet a) {
+        return flag(a, Bold);
+    }
+
+    public static void setBold(MutableAttributeSet a, boolean b) {
+        a.addAttribute(Bold, Boolean.valueOf(b));
+    }
+
+    public static boolean isItalic(AttributeSet a) {
+        return flag(a, Italic);
+    }
+
+    public static void setItalic(MutableAttributeSet a, boolean b) {
+        a.addAttribute(Italic, Boolean.valueOf(b));
+    }
+
+    public static boolean isUnderline(AttributeSet a) {
+        return flag(a, Underline);
+    }
+
+    public static void setUnderline(MutableAttributeSet a, boolean b) {
+        a.addAttribute(Underline, Boolean.valueOf(b));
+    }
+
+    public static boolean isStrikeThrough(AttributeSet a) {
+        return flag(a, StrikeThrough);
+    }
+
+    public static void setStrikeThrough(MutableAttributeSet a, boolean b) {
+        a.addAttribute(StrikeThrough, Boolean.valueOf(b));
+    }
+
+    /// The color of the text of `a`; black when it names none.
+    public static Color getForeground(AttributeSet a) {
+        Object fg = a.getAttribute(Foreground);
+        return fg instanceof Color ? (Color) fg : Color.black;
+    }
+
+    public static void setForeground(MutableAttributeSet a, Color fg) {
+        a.addAttribute(Foreground, fg);
+    }
+
+    /// The color behind the text of `a`; black when it names none, which
+    /// is why a caller asks `isDefined` first.
+    public static Color getBackground(AttributeSet a) {
+        Object bg = a.getAttribute(Background);
+        return bg instanceof Color ? (Color) bg : Color.black;
+    }
+
+    public static void setBackground(MutableAttributeSet a, Color bg) {
+        a.addAttribute(Background, bg);
+    }
+
+    public static int getAlignment(AttributeSet a) {
+        Object align = a.getAttribute(Alignment);
+        return align instanceof Integer ? ((Integer) align).intValue() : ALIGN_LEFT;
+    }
+
+    public static void setAlignment(MutableAttributeSet a, int align) {
+        a.addAttribute(Alignment, Integer.valueOf(align));
+    }
+
+    /// The name of an element that stands for a component.
+    public static final String ComponentElementName = "component";
+
+    /// The name of an element that stands for an icon.
+    public static final String IconElementName = "icon";
+
+    /// The attribute that holds an element's name.
+    public static final Object NameAttribute = AttributeSet.NameAttribute;
+
+    /// The attribute that holds the set attributes are inherited from.
+    public static final Object ResolveAttribute = AttributeSet.ResolveAttribute;
+
+    private final String representation;
+
+    StyleConstants(String representation) {
+        this.representation = representation;
+    }
+
+    @Override
+    public String toString() {
+        return representation;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyleContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyleContext.java
new file mode 100644
index 00000000000..94180ff964a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyleContext.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.EventListener;
+import java.util.LinkedHashMap;
+
+/// The named styles of one or more documents.
+///
+/// A context starts with one style, [#DEFAULT_STYLE], which is what the
+/// paragraphs of a `DefaultStyledDocument` resolve their attributes in
+/// until they are given another.
+public class StyleContext {
+
+    public static final String DEFAULT_STYLE = "default";
+
+    private static StyleContext defaultContext;
+
+    private final LinkedHashMap<String, Style> styles = new LinkedHashMap<String, Style>();
+
+    public StyleContext() {
+        addStyle(DEFAULT_STYLE, null);
+    }
+
+    /// The context documents share when they are not given one.
+    public static final StyleContext getDefaultStyleContext() {
+        if (defaultContext == null) {
+            defaultContext = new StyleContext();
+        }
+        return defaultContext;
+    }
+
+    /// Makes a style that resolves in `parent`. A style with a name is
+    /// kept under it, in place of one that had the name; with `null` for
+    /// a name the style is the caller's alone.
+    public Style addStyle(String nm, Style parent) {
+        Style style = new NamedStyle(nm, parent);
+        if (nm != null) {
+            styles.put(nm, style);
+        }
+        return style;
+    }
+
+    public void removeStyle(String nm) {
+        styles.remove(nm);
+    }
+
+    public Style getStyle(String nm) {
+        return nm == null ? null : styles.get(nm);
+    }
+
+    public Enumeration<?> getStyleNames() {
+        return new SimpleAttributeSet.Names(new ArrayList<Object>(styles.keySet()));
+    }
+
+    /// The font the attributes in `attr` ask for.
+    public Font getFont(AttributeSet attr) {
+        int style = Font.PLAIN;
+        if (StyleConstants.isBold(attr)) {
+            style |= Font.BOLD;
+        }
+        if (StyleConstants.isItalic(attr)) {
+            style |= Font.ITALIC;
+        }
+        return getFont(StyleConstants.getFontFamily(attr), style, StyleConstants.getFontSize(attr));
+    }
+
+    public Font getFont(String family, int style, int size) {
+        return new Font(family, style, size);
+    }
+
+    public Color getForeground(AttributeSet attr) {
+        return StyleConstants.getForeground(attr);
+    }
+
+    public Color getBackground(AttributeSet attr) {
+        return StyleConstants.getBackground(attr);
+    }
+
+    public AttributeSet getEmptySet() {
+        return SimpleAttributeSet.EMPTY;
+    }
+
+    /// A set of attributes with a name, that tells its listeners when it
+    /// changes.
+    public class NamedStyle implements Style {
+
+        protected EventListenerList listenerList = new EventListenerList();
+
+        protected transient ChangeEvent changeEvent;
+
+        private final SimpleAttributeSet attributes = new SimpleAttributeSet();
+
+        public NamedStyle(String name, Style parent) {
+            if (name != null) {
+                setName(name);
+            }
+            if (parent != null) {
+                setResolveParent(parent);
+            }
+        }
+
+        public NamedStyle(Style parent) {
+            this(null, parent);
+        }
+
+        public NamedStyle() {
+        }
+
+        @Override
+        public String toString() {
+            return "NamedStyle:" + getName() + " " + attributes;
+        }
+
+        @Override
+        public String getName() {
+            if (isDefined(StyleConstants.NameAttribute)) {
+                return String.valueOf(getAttribute(StyleConstants.NameAttribute));
+            }
+            return null;
+        }
+
+        public void setName(String name) {
+            if (name != null) {
+                addAttribute(StyleConstants.NameAttribute, name);
+            }
+        }
+
+        @Override
+        public void addChangeListener(ChangeListener l) {
+            listenerList.add(ChangeListener.class, l);
+        }
+
+        @Override
+        public void removeChangeListener(ChangeListener l) {
+            listenerList.remove(ChangeListener.class, l);
+        }
+
+        public ChangeListener[] getChangeListeners() {
+            return listenerList.getListeners(ChangeListener.class);
+        }
+
+        protected void fireStateChanged() {
+            ChangeListener[] ls = getChangeListeners();
+            for (int i = ls.length - 1; i >= 0; i--) {
+                if (changeEvent == null) {
+                    changeEvent = new ChangeEvent(this);
+                }
+                ls[i].stateChanged(changeEvent);
+            }
+        }
+
+        public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+            return listenerList.getListeners(listenerType);
+        }
+
+        @Override
+        public int getAttributeCount() {
+            return attributes.getAttributeCount();
+        }
+
+        @Override
+        public boolean isDefined(Object attrName) {
+            return attributes.isDefined(attrName);
+        }
+
+        @Override
+        public boolean isEqual(AttributeSet attr) {
+            return attributes.isEqual(attr);
+        }
+
+        @Override
+        public AttributeSet copyAttributes() {
+            NamedStyle a = new NamedStyle();
+            a.attributes.addAttributes(attributes);
+            return a;
+        }
+
+        @Override
+        public Object getAttribute(Object attrName) {
+            return attributes.getAttribute(attrName);
+        }
+
+        @Override
+        public Enumeration<?> getAttributeNames() {
+            return attributes.getAttributeNames();
+        }
+
+        @Override
+        public boolean containsAttribute(Object name, Object value) {
+            return attributes.containsAttribute(name, value);
+        }
+
+        @Override
+        public boolean containsAttributes(AttributeSet attrs) {
+            return attributes.containsAttributes(attrs);
+        }
+
+        @Override
+        public AttributeSet getResolveParent() {
+            return attributes.getResolveParent();
+        }
+
+        @Override
+        public void addAttribute(Object name, Object value) {
+            attributes.addAttribute(name, value);
+            fireStateChanged();
+        }
+
+        @Override
+        public void addAttributes(AttributeSet attr) {
+            attributes.addAttributes(attr);
+            fireStateChanged();
+        }
+
+        @Override
+        public void removeAttribute(Object name) {
+            attributes.removeAttribute(name);
+            fireStateChanged();
+        }
+
+        @Override
+        public void removeAttributes(Enumeration<?> names) {
+            attributes.removeAttributes(names);
+            fireStateChanged();
+        }
+
+        @Override
+        public void removeAttributes(AttributeSet attrs) {
+            if (attrs == this) {
+                attributes.removeAttributes(attributes);
+            } else {
+                attributes.removeAttributes(attrs);
+            }
+            fireStateChanged();
+        }
+
+        @Override
+        public void setResolveParent(AttributeSet parent) {
+            if (parent != null) {
+                attributes.setResolveParent(parent);
+            } else {
+                attributes.removeAttribute(StyleConstants.ResolveAttribute);
+            }
+            fireStateChanged();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyledDocument.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyledDocument.java
new file mode 100644
index 00000000000..79e722a8cc1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/StyledDocument.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+
+/// A document whose text has attributes: by stretch of characters, and
+/// by paragraph.
+public interface StyledDocument extends Document {
+
+    Style addStyle(String nm, Style parent);
+
+    void removeStyle(String nm);
+
+    Style getStyle(String nm);
+
+    /// Gives the characters from `offset` on the attributes in `s`, in
+    /// place of the ones they have with `replace` and added to them
+    /// without.
+    void setCharacterAttributes(int offset, int length, AttributeSet s, boolean replace);
+
+    /// As [#setCharacterAttributes], for the paragraphs the range touches.
+    void setParagraphAttributes(int offset, int length, AttributeSet s, boolean replace);
+
+    /// Sets the style the paragraph at `pos` resolves its attributes in.
+    void setLogicalStyle(int pos, Style s);
+
+    Style getLogicalStyle(int p);
+
+    Element getParagraphElement(int pos);
+
+    /// The stretch of characters with the same attributes that `pos` is
+    /// in.
+    Element getCharacterElement(int pos);
+
+    Color getForeground(AttributeSet attr);
+
+    Color getBackground(AttributeSet attr);
+
+    Font getFont(AttributeSet attr);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/TextAction.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/TextAction.java
new file mode 100644
index 00000000000..54bf513e3ef
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/TextAction.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.KeyboardFocusManager;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.Action;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// An action that works on whichever text component it is fired from: the
+/// source of the event when that is a text component, the focused text
+/// component otherwise. This is what lets one "copy" action serve every
+/// text field of an application's menu.
+public abstract class TextAction extends AbstractAction {
+
+    public TextAction(String name) {
+        super(name);
+    }
+
+    /// The text component the action should work on, or null.
+    protected final JTextComponent getTextComponent(ActionEvent e) {
+        if (e != null) {
+            Object o = e.getSource();
+            if (o instanceof JTextComponent) {
+                return (JTextComponent) o;
+            }
+        }
+        return getFocusedComponent();
+    }
+
+    /// `list1` with every action of `list2` added, an action of `list2`
+    /// taking the place of one of the same name.
+    public static final Action[] augmentList(Action[] list1, Action[] list2) {
+        HashMap<String, Action> byName = new HashMap<String, Action>();
+        ArrayList<String> order = new ArrayList<String>();
+        cn1Collect(list1, byName, order);
+        cn1Collect(list2, byName, order);
+        Action[] out = new Action[order.size()];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = byName.get(order.get(i));
+        }
+        return out;
+    }
+
+    private static void cn1Collect(Action[] list, HashMap<String, Action> byName, ArrayList<String> order) {
+        for (int i = 0; list != null && i < list.length; i++) {
+            Action a = list[i];
+            Object value = a.getValue(Action.NAME);
+            String name = value instanceof String ? (String) value : "";
+            if (!byName.containsKey(name)) {
+                order.add(name);
+            }
+            byName.put(name, a);
+        }
+    }
+
+    /// The text component that has the focus, or null.
+    protected final JTextComponent getFocusedComponent() {
+        Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
+        if (owner instanceof JTextComponent) {
+            return (JTextComponent) owner;
+        }
+        return JTextComponent.cn1LastFocused();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/HTMLDocument.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/HTMLDocument.java
new file mode 100644
index 00000000000..e0f904f2870
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/HTMLDocument.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text.html;
+
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditListener;
+import com.codename1.desktopcompat.javax.swing.text.AttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.Element;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.javax.swing.text.Position;
+import com.codename1.desktopcompat.javax.swing.text.Segment;
+
+/// The type of an HTML document, for code that tests for it. This layer
+/// builds none -- see the package description -- so there is no public
+/// constructor, no pane hands one out, and the test is false.
+public class HTMLDocument implements Document {
+
+    /// The text, should the layer ever make one of these.
+    private final PlainDocument text = new PlainDocument();
+
+    HTMLDocument() {
+    }
+
+    /// Shows the target of a link in the frame it names. There are no
+    /// frames in a document here, so there is no frame to change.
+    public void processHTMLFrameHyperlinkEvent(HTMLFrameHyperlinkEvent e) {
+        if (e == null) {
+            throw new NullPointerException();
+        }
+    }
+
+    @Override
+    public int getLength() {
+        return text.getLength();
+    }
+
+    @Override
+    public void addDocumentListener(DocumentListener listener) {
+        text.addDocumentListener(listener);
+    }
+
+    @Override
+    public void removeDocumentListener(DocumentListener listener) {
+        text.removeDocumentListener(listener);
+    }
+
+    @Override
+    public void addUndoableEditListener(UndoableEditListener listener) {
+        text.addUndoableEditListener(listener);
+    }
+
+    @Override
+    public void removeUndoableEditListener(UndoableEditListener listener) {
+        text.removeUndoableEditListener(listener);
+    }
+
+    @Override
+    public Object getProperty(Object key) {
+        return text.getProperty(key);
+    }
+
+    @Override
+    public void putProperty(Object key, Object value) {
+        text.putProperty(key, value);
+    }
+
+    @Override
+    public void remove(int offs, int len) throws BadLocationException {
+        text.remove(offs, len);
+    }
+
+    @Override
+    public void insertString(int offset, String str, AttributeSet a) throws BadLocationException {
+        text.insertString(offset, str, a);
+    }
+
+    @Override
+    public String getText(int offset, int length) throws BadLocationException {
+        return text.getText(offset, length);
+    }
+
+    @Override
+    public void getText(int offset, int length, Segment txt) throws BadLocationException {
+        text.getText(offset, length, txt);
+    }
+
+    @Override
+    public Position getStartPosition() {
+        return text.getStartPosition();
+    }
+
+    @Override
+    public Position getEndPosition() {
+        return text.getEndPosition();
+    }
+
+    @Override
+    public Position createPosition(int offs) throws BadLocationException {
+        return text.createPosition(offs);
+    }
+
+    @Override
+    public Element[] getRootElements() {
+        return text.getRootElements();
+    }
+
+    @Override
+    public Element getDefaultRootElement() {
+        return text.getDefaultRootElement();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/HTMLFrameHyperlinkEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/HTMLFrameHyperlinkEvent.java
new file mode 100644
index 00000000000..b0cd45b4d54
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/HTMLFrameHyperlinkEvent.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.text.html;
+
+import com.codename1.desktopcompat.javax.swing.event.HyperlinkEvent;
+import java.net.URL;
+
+/// A link activated inside a frame of a frame set, with the frame it is
+/// to be shown in. No pane of this layer fires one.
+public class HTMLFrameHyperlinkEvent extends HyperlinkEvent {
+
+    private final String targetFrame;
+
+    public HTMLFrameHyperlinkEvent(Object source, HyperlinkEvent.EventType type, URL targetURL,
+            String targetFrame) {
+        super(source, type, targetURL);
+        this.targetFrame = targetFrame;
+    }
+
+    public HTMLFrameHyperlinkEvent(Object source, HyperlinkEvent.EventType type, URL targetURL, String desc,
+            String targetFrame) {
+        super(source, type, targetURL, desc);
+        this.targetFrame = targetFrame;
+    }
+
+    public String getTarget() {
+        return targetFrame;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/package-info.java
new file mode 100644
index 00000000000..5a24c0025ba
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/html/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The two types of `javax.swing.text.html` a hyperlink listener is
+/// written against.
+///
+/// An editor pane of this layer shows HTML with its own reader and builds
+/// no HTML document and no frames, so a pane never hands out an
+/// `HTMLDocument` and never fires an `HTMLFrameHyperlinkEvent`: a
+/// listener's test for either is false.
+package com.codename1.desktopcompat.javax.swing.text.html;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/package-info.java
new file mode 100644
index 00000000000..5d44c29501f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/text/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The base class of the Swing text components. Documents, carets,
+/// highlighters and editor kits are not part of this layer.
+package com.codename1.desktopcompat.javax.swing.text;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultMutableTreeNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultMutableTreeNode.java
new file mode 100644
index 00000000000..29d938e0d8b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultMutableTreeNode.java
@@ -0,0 +1,636 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.rt.ListEnumeration;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.NoSuchElementException;
+import java.util.Vector;
+
+/// The general tree node: a user object, a parent and a list of children,
+/// with the JDK's ways of walking the tree around it.
+///
+/// [#clone()] answers a plain `DefaultMutableTreeNode` with the same user
+/// object and no parent or children, also for a subclass: a device cannot
+/// copy an object of an unknown class.
+public class DefaultMutableTreeNode implements Cloneable, MutableTreeNode {
+
+    /// An enumeration with nothing in it.
+    public static final Enumeration<TreeNode> EMPTY_ENUMERATION = new Enumeration<TreeNode>() {
+        @Override
+        public boolean hasMoreElements() {
+            return false;
+        }
+
+        @Override
+        public TreeNode nextElement() {
+            throw new NoSuchElementException("No more elements");
+        }
+    };
+
+    protected MutableTreeNode parent;
+    protected Vector children;
+    protected transient Object userObject;
+    protected boolean allowsChildren;
+
+    public DefaultMutableTreeNode() {
+        this(null);
+    }
+
+    public DefaultMutableTreeNode(Object userObject) {
+        this(userObject, true);
+    }
+
+    public DefaultMutableTreeNode(Object userObject, boolean allowsChildren) {
+        parent = null;
+        this.allowsChildren = allowsChildren;
+        this.userObject = userObject;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void insert(MutableTreeNode newChild, int childIndex) {
+        if (!allowsChildren) {
+            throw new IllegalStateException("node does not allow children");
+        } else if (newChild == null) {
+            throw new IllegalArgumentException("new child is null");
+        } else if (isNodeAncestor(newChild)) {
+            throw new IllegalArgumentException("new child is an ancestor");
+        }
+        TreeNode oldParent = newChild.getParent();
+        if (oldParent instanceof MutableTreeNode) {
+            ((MutableTreeNode) oldParent).remove(newChild);
+        }
+        newChild.setParent(this);
+        if (children == null) {
+            children = new Vector();
+        }
+        children.insertElementAt(newChild, childIndex);
+    }
+
+    @Override
+    public void remove(int childIndex) {
+        TreeNode child = getChildAt(childIndex);
+        children.removeElementAt(childIndex);
+        if (child instanceof MutableTreeNode) {
+            ((MutableTreeNode) child).setParent(null);
+        }
+    }
+
+    @Override
+    public void setParent(MutableTreeNode newParent) {
+        parent = newParent;
+    }
+
+    @Override
+    public TreeNode getParent() {
+        return parent;
+    }
+
+    @Override
+    public TreeNode getChildAt(int index) {
+        if (children == null) {
+            throw new ArrayIndexOutOfBoundsException("node has no children");
+        }
+        Object c = children.elementAt(index);
+        return c instanceof TreeNode ? (TreeNode) c : null;
+    }
+
+    @Override
+    public int getChildCount() {
+        return children == null ? 0 : children.size();
+    }
+
+    @Override
+    public int getIndex(TreeNode aChild) {
+        if (aChild == null) {
+            throw new IllegalArgumentException("argument is null");
+        }
+        if (!isNodeChild(aChild)) {
+            return -1;
+        }
+        return children.indexOf(aChild);
+    }
+
+    @Override
+    public Enumeration children() {
+        return children == null ? EMPTY_ENUMERATION : children.elements();
+    }
+
+    public void setAllowsChildren(boolean allows) {
+        if (allows != allowsChildren) {
+            allowsChildren = allows;
+            if (!allowsChildren) {
+                removeAllChildren();
+            }
+        }
+    }
+
+    @Override
+    public boolean getAllowsChildren() {
+        return allowsChildren;
+    }
+
+    @Override
+    public void setUserObject(Object userObject) {
+        this.userObject = userObject;
+    }
+
+    public Object getUserObject() {
+        return userObject;
+    }
+
+    @Override
+    public void removeFromParent() {
+        MutableTreeNode p = parent;
+        if (p != null) {
+            p.remove(this);
+        }
+    }
+
+    @Override
+    public void remove(MutableTreeNode aChild) {
+        if (aChild == null) {
+            throw new IllegalArgumentException("argument is null");
+        }
+        if (!isNodeChild(aChild)) {
+            throw new IllegalArgumentException("argument is not a child");
+        }
+        remove(getIndex(aChild));
+    }
+
+    public void removeAllChildren() {
+        for (int i = getChildCount() - 1; i >= 0; i--) {
+            remove(i);
+        }
+    }
+
+    public void add(MutableTreeNode newChild) {
+        if (newChild != null && newChild.getParent() == this) {
+            insert(newChild, getChildCount() - 1);
+        } else {
+            insert(newChild, getChildCount());
+        }
+    }
+
+    // ------------------------------------------------------------ relations
+
+    public boolean isNodeAncestor(TreeNode anotherNode) {
+        if (anotherNode == null) {
+            return false;
+        }
+        TreeNode ancestor = this;
+        do {
+            if (ancestor == anotherNode) {
+                return true;
+            }
+            ancestor = ancestor.getParent();
+        } while (ancestor != null);
+        return false;
+    }
+
+    public boolean isNodeDescendant(DefaultMutableTreeNode anotherNode) {
+        return anotherNode != null && anotherNode.isNodeAncestor(this);
+    }
+
+    public TreeNode getSharedAncestor(DefaultMutableTreeNode aNode) {
+        if (aNode == this) {
+            return this;
+        } else if (aNode == null) {
+            return null;
+        }
+        TreeNode a = this;
+        TreeNode b = aNode;
+        int la = getLevel();
+        int lb = aNode.getLevel();
+        while (la > lb && a != null) {
+            a = a.getParent();
+            la--;
+        }
+        while (lb > la && b != null) {
+            b = b.getParent();
+            lb--;
+        }
+        while (a != null && b != null) {
+            if (a == b) {
+                return a;
+            }
+            a = a.getParent();
+            b = b.getParent();
+        }
+        return null;
+    }
+
+    public boolean isNodeRelated(DefaultMutableTreeNode aNode) {
+        return aNode != null && getRoot() == aNode.getRoot();
+    }
+
+    /// The length of the longest way down from this node to a leaf.
+    public int getDepth() {
+        int deepest = 0;
+        ArrayList<TreeNode> level = new ArrayList<TreeNode>();
+        level.add(this);
+        int depth = -1;
+        while (!level.isEmpty()) {
+            depth++;
+            ArrayList<TreeNode> next = new ArrayList<TreeNode>();
+            for (int i = 0; i < level.size(); i++) {
+                TreeNode n = level.get(i);
+                for (int j = 0; j < n.getChildCount(); j++) {
+                    next.add(n.getChildAt(j));
+                }
+            }
+            level = next;
+        }
+        deepest = Math.max(deepest, depth);
+        return deepest;
+    }
+
+    /// The number of nodes above this one.
+    public int getLevel() {
+        int levels = 0;
+        TreeNode ancestor = this;
+        while ((ancestor = ancestor.getParent()) != null) {
+            levels++;
+        }
+        return levels;
+    }
+
+    public TreeNode[] getPath() {
+        return getPathToRoot(this, 0);
+    }
+
+    protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) {
+        int n = depth;
+        for (TreeNode t = aNode; t != null; t = t.getParent()) {
+            n++;
+        }
+        if (n == 0) {
+            return null;
+        }
+        TreeNode[] out = new TreeNode[n];
+        int at = n - depth;
+        for (TreeNode t = aNode; t != null; t = t.getParent()) {
+            out[--at] = t;
+        }
+        return out;
+    }
+
+    public Object[] getUserObjectPath() {
+        TreeNode[] real = getPath();
+        Object[] out = new Object[real.length];
+        for (int i = 0; i < real.length; i++) {
+            out[i] = real[i] instanceof DefaultMutableTreeNode ? ((DefaultMutableTreeNode) real[i]).getUserObject()
+                    : null;
+        }
+        return out;
+    }
+
+    public TreeNode getRoot() {
+        TreeNode ancestor = this;
+        TreeNode previous;
+        do {
+            previous = ancestor;
+            ancestor = ancestor.getParent();
+        } while (ancestor != null);
+        return previous;
+    }
+
+    public boolean isRoot() {
+        return getParent() == null;
+    }
+
+    private static DefaultMutableTreeNode own(Object n) {
+        return n instanceof DefaultMutableTreeNode ? (DefaultMutableTreeNode) n : null;
+    }
+
+    /// The node after this one in a preorder walk of the whole tree.
+    public DefaultMutableTreeNode getNextNode() {
+        if (getChildCount() == 0) {
+            DefaultMutableTreeNode next = getNextSibling();
+            if (next == null) {
+                DefaultMutableTreeNode p = own(getParent());
+                while (p != null) {
+                    next = p.getNextSibling();
+                    if (next != null) {
+                        return next;
+                    }
+                    p = own(p.getParent());
+                }
+                return null;
+            }
+            return next;
+        }
+        return own(getChildAt(0));
+    }
+
+    /// The node before this one in a preorder walk of the whole tree.
+    public DefaultMutableTreeNode getPreviousNode() {
+        DefaultMutableTreeNode p = own(getParent());
+        if (p == null) {
+            return null;
+        }
+        DefaultMutableTreeNode previous = getPreviousSibling();
+        if (previous == null) {
+            return p;
+        }
+        return previous.getChildCount() == 0 ? previous : previous.getLastLeaf();
+    }
+
+    // ------------------------------------------------------------ walks
+
+    /// This node, then each child's whole subtree in turn.
+    public Enumeration preorderEnumeration() {
+        return new Preorder(this);
+    }
+
+    /// Each child's whole subtree in turn, then this node.
+    public Enumeration postorderEnumeration() {
+        return new Postorder(this);
+    }
+
+    /// This node, then its children, then theirs: level by level.
+    public Enumeration breadthFirstEnumeration() {
+        return new BreadthFirst(this);
+    }
+
+    /// The same walk as [#postorderEnumeration()].
+    public Enumeration depthFirstEnumeration() {
+        return postorderEnumeration();
+    }
+
+    /// The nodes from `ancestor` down to this node.
+    public Enumeration pathFromAncestorEnumeration(TreeNode ancestor) {
+        if (ancestor == null || !isNodeAncestor(ancestor)) {
+            throw new IllegalArgumentException("node " + ancestor + " is not an ancestor of " + this);
+        }
+        ArrayList<TreeNode> way = new ArrayList<TreeNode>();
+        for (TreeNode t = this; t != null; t = t.getParent()) {
+            way.add(t);
+            if (t == ancestor) {
+                break;
+            }
+        }
+        return new ListEnumeration<TreeNode>(way, true);
+    }
+
+    private static final class Preorder implements Enumeration<TreeNode> {
+
+        private final ArrayList<TreeNode> stack = new ArrayList<TreeNode>();
+
+        Preorder(TreeNode root) {
+            stack.add(root);
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return !stack.isEmpty();
+        }
+
+        @Override
+        public TreeNode nextElement() {
+            if (stack.isEmpty()) {
+                throw new NoSuchElementException("No more elements");
+            }
+            TreeNode n = stack.remove(stack.size() - 1);
+            for (int i = n.getChildCount() - 1; i >= 0; i--) {
+                stack.add(n.getChildAt(i));
+            }
+            return n;
+        }
+    }
+
+    private static final class Postorder implements Enumeration<TreeNode> {
+
+        private final ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();
+        private final ArrayList<int[]> next = new ArrayList<int[]>();
+
+        Postorder(TreeNode root) {
+            nodes.add(root);
+            next.add(new int[]{0});
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return !nodes.isEmpty();
+        }
+
+        @Override
+        public TreeNode nextElement() {
+            if (nodes.isEmpty()) {
+                throw new NoSuchElementException("No more elements");
+            }
+            while (true) {
+                int top = nodes.size() - 1;
+                TreeNode n = nodes.get(top);
+                int[] at = next.get(top);
+                if (at[0] < n.getChildCount()) {
+                    nodes.add(n.getChildAt(at[0]++));
+                    next.add(new int[]{0});
+                } else {
+                    nodes.remove(top);
+                    next.remove(top);
+                    return n;
+                }
+            }
+        }
+    }
+
+    private static final class BreadthFirst implements Enumeration<TreeNode> {
+
+        private final ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
+        private int head;
+
+        BreadthFirst(TreeNode root) {
+            queue.add(root);
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return head < queue.size();
+        }
+
+        @Override
+        public TreeNode nextElement() {
+            if (head >= queue.size()) {
+                throw new NoSuchElementException("No more elements");
+            }
+            TreeNode n = queue.get(head);
+            queue.set(head++, null);
+            for (int i = 0; i < n.getChildCount(); i++) {
+                queue.add(n.getChildAt(i));
+            }
+            return n;
+        }
+    }
+
+    // ------------------------------------------------------------ children
+
+    public boolean isNodeChild(TreeNode aNode) {
+        return aNode != null && getChildCount() != 0 && aNode.getParent() == this;
+    }
+
+    public TreeNode getFirstChild() {
+        if (getChildCount() == 0) {
+            throw new NoSuchElementException("node has no children");
+        }
+        return getChildAt(0);
+    }
+
+    public TreeNode getLastChild() {
+        if (getChildCount() == 0) {
+            throw new NoSuchElementException("node has no children");
+        }
+        return getChildAt(getChildCount() - 1);
+    }
+
+    public TreeNode getChildAfter(TreeNode aChild) {
+        if (aChild == null) {
+            throw new IllegalArgumentException("argument is null");
+        }
+        int index = getIndex(aChild);
+        if (index == -1) {
+            throw new IllegalArgumentException("node is not a child");
+        }
+        return index < getChildCount() - 1 ? getChildAt(index + 1) : null;
+    }
+
+    public TreeNode getChildBefore(TreeNode aChild) {
+        if (aChild == null) {
+            throw new IllegalArgumentException("argument is null");
+        }
+        int index = getIndex(aChild);
+        if (index == -1) {
+            throw new IllegalArgumentException("node is not a child");
+        }
+        return index > 0 ? getChildAt(index - 1) : null;
+    }
+
+    // ------------------------------------------------------------ siblings
+
+    public boolean isNodeSibling(TreeNode anotherNode) {
+        if (anotherNode == null) {
+            return false;
+        }
+        if (anotherNode == this) {
+            return true;
+        }
+        TreeNode p = getParent();
+        return p != null && p == anotherNode.getParent();
+    }
+
+    public int getSiblingCount() {
+        TreeNode p = getParent();
+        return p == null ? 1 : p.getChildCount();
+    }
+
+    public DefaultMutableTreeNode getNextSibling() {
+        DefaultMutableTreeNode p = own(getParent());
+        return p == null ? null : own(p.getChildAfter(this));
+    }
+
+    public DefaultMutableTreeNode getPreviousSibling() {
+        DefaultMutableTreeNode p = own(getParent());
+        return p == null ? null : own(p.getChildBefore(this));
+    }
+
+    // ------------------------------------------------------------ leaves
+
+    @Override
+    public boolean isLeaf() {
+        return getChildCount() == 0;
+    }
+
+    public DefaultMutableTreeNode getFirstLeaf() {
+        DefaultMutableTreeNode node = this;
+        while (!node.isLeaf()) {
+            DefaultMutableTreeNode first = own(node.getFirstChild());
+            if (first == null) {
+                break;
+            }
+            node = first;
+        }
+        return node;
+    }
+
+    public DefaultMutableTreeNode getLastLeaf() {
+        DefaultMutableTreeNode node = this;
+        while (!node.isLeaf()) {
+            DefaultMutableTreeNode last = own(node.getLastChild());
+            if (last == null) {
+                break;
+            }
+            node = last;
+        }
+        return node;
+    }
+
+    public DefaultMutableTreeNode getNextLeaf() {
+        DefaultMutableTreeNode p = own(getParent());
+        if (p == null) {
+            return null;
+        }
+        DefaultMutableTreeNode next = getNextSibling();
+        if (next != null) {
+            return next.getFirstLeaf();
+        }
+        return p.getNextLeaf();
+    }
+
+    public DefaultMutableTreeNode getPreviousLeaf() {
+        DefaultMutableTreeNode p = own(getParent());
+        if (p == null) {
+            return null;
+        }
+        DefaultMutableTreeNode previous = getPreviousSibling();
+        if (previous != null) {
+            return previous.getLastLeaf();
+        }
+        return p.getPreviousLeaf();
+    }
+
+    public int getLeafCount() {
+        int count = 0;
+        Enumeration e = breadthFirstEnumeration();
+        while (e.hasMoreElements()) {
+            Object n = e.nextElement();
+            if (n instanceof TreeNode && ((TreeNode) n).isLeaf()) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    @Override
+    public String toString() {
+        return userObject == null ? "" : userObject.toString();
+    }
+
+    /// A new plain node with this node's user object, and neither parent
+    /// nor children.
+    @Override
+    public Object clone() {
+        return new DefaultMutableTreeNode(userObject, allowsChildren);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeCellEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeCellEditor.java
new file mode 100644
index 00000000000..3cf8081d248
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeCellEditor.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.DefaultCellEditor;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.event.CellEditorListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionListener;
+import java.util.EventObject;
+
+/// The editor of tree nodes: a text field over the node's row.
+///
+/// This is the plain part of the JDK's editor. Editing starts on a third
+/// click, or when the tree is asked to with no event; the "click, wait,
+/// click again" start and the node's icon beside the field are absent.
+public class DefaultTreeCellEditor implements ActionListener, TreeCellEditor, TreeSelectionListener {
+
+    protected TreeCellEditor realEditor;
+    protected DefaultTreeCellRenderer renderer;
+    protected transient Component editingComponent;
+    protected boolean canEdit;
+    protected transient JTree tree;
+    protected Color borderSelectionColor;
+    protected Font font;
+
+    public DefaultTreeCellEditor(JTree tree, DefaultTreeCellRenderer renderer) {
+        this(tree, renderer, null);
+    }
+
+    public DefaultTreeCellEditor(JTree tree, DefaultTreeCellRenderer renderer, TreeCellEditor editor) {
+        this.renderer = renderer;
+        realEditor = editor;
+        if (realEditor == null) {
+            realEditor = createTreeCellEditor();
+        }
+        setTree(tree);
+    }
+
+    public void setBorderSelectionColor(Color newColor) {
+        borderSelectionColor = newColor;
+    }
+
+    public Color getBorderSelectionColor() {
+        return borderSelectionColor;
+    }
+
+    public void setFont(Font font) {
+        this.font = font;
+    }
+
+    public Font getFont() {
+        return font;
+    }
+
+    @Override
+    public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded,
+            boolean leaf, int row) {
+        setTree(tree);
+        editingComponent = realEditor.getTreeCellEditorComponent(tree, value, isSelected, expanded, leaf, row);
+        if (editingComponent != null) {
+            Font f = font != null ? font : renderer != null && renderer.isFontSet() ? renderer.getFont()
+                    : this.tree != null ? this.tree.getFont() : null;
+            if (f != null && !f.equals(editingComponent.getFont())) {
+                editingComponent.setFont(f);
+            }
+        }
+        return editingComponent;
+    }
+
+    @Override
+    public Object getCellEditorValue() {
+        return realEditor.getCellEditorValue();
+    }
+
+    @Override
+    public boolean isCellEditable(EventObject event) {
+        canEdit = realEditor.isCellEditable(event) && canEditImmediately(event);
+        return canEdit;
+    }
+
+    @Override
+    public boolean shouldSelectCell(EventObject event) {
+        return realEditor.shouldSelectCell(event);
+    }
+
+    @Override
+    public boolean stopCellEditing() {
+        if (realEditor.stopCellEditing()) {
+            editingComponent = null;
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void cancelCellEditing() {
+        realEditor.cancelCellEditing();
+        editingComponent = null;
+    }
+
+    @Override
+    public void addCellEditorListener(CellEditorListener l) {
+        realEditor.addCellEditorListener(l);
+    }
+
+    @Override
+    public void removeCellEditorListener(CellEditorListener l) {
+        realEditor.removeCellEditorListener(l);
+    }
+
+    /// Does nothing: an edit never starts from a change of selection.
+    @Override
+    public void valueChanged(TreeSelectionEvent e) {
+    }
+
+    /// Does nothing: there is no timed start of an edit.
+    @Override
+    public void actionPerformed(ActionEvent e) {
+    }
+
+    protected void setTree(JTree newTree) {
+        tree = newTree;
+    }
+
+    /// Whether the event starts an edit at once: no event at all, or a
+    /// third click.
+    protected boolean canEditImmediately(EventObject event) {
+        if (event instanceof MouseEvent) {
+            return ((MouseEvent) event).getClickCount() > 2;
+        }
+        return event == null;
+    }
+
+    protected TreeCellEditor createTreeCellEditor() {
+        DefaultCellEditor editor = new DefaultCellEditor(new JTextField());
+        editor.setClickCountToStart(1);
+        return editor;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeCellRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeCellRenderer.java
new file mode 100644
index 00000000000..0e415cb15b9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeCellRenderer.java
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.rt.CellTheme;
+
+/// The renderer of tree rows: a label, and so a Codename One label,
+/// showing the node's text in the theme's colors.
+///
+/// A node has a folder before its text, open while it is expanded, and
+/// a leaf a sheet of paper, until an application sets other icons; one set
+/// to `null` leaves the row with its text alone. The tree draws the expand
+/// handles itself.
+public class DefaultTreeCellRenderer extends JLabel implements TreeCellRenderer {
+
+    protected boolean selected;
+    protected boolean hasFocus;
+    protected transient Icon closedIcon;
+    protected transient Icon leafIcon;
+    protected transient Icon openIcon;
+    protected Color textSelectionColor;
+    protected Color textNonSelectionColor;
+    protected Color backgroundSelectionColor;
+    protected Color backgroundNonSelectionColor;
+    protected Color borderSelectionColor;
+
+    private Color shownForeground;
+
+    /// A subclass that colours one row leaves the colour on the renderer,
+    /// which is shared by every row: what is shown is tracked here, so the
+    /// next row gets its own colour back.
+    @Override
+    public void setForeground(Color fg) {
+        shownForeground = fg;
+        super.setForeground(fg);
+    }
+
+    public DefaultTreeCellRenderer() {
+        setOpaque(false);
+        textSelectionColor = CellTheme.selectionForeground("Tree.selectionForeground");
+        textNonSelectionColor = CellTheme.foreground("Tree.textForeground");
+        backgroundSelectionColor = CellTheme.selectionBackground("Tree.selectionBackground");
+        backgroundNonSelectionColor = null;
+        borderSelectionColor = CellTheme.mix(backgroundSelectionColor, textSelectionColor, 0.6f);
+        setName("Tree.cellRenderer");
+        openIcon = getDefaultOpenIcon();
+        closedIcon = getDefaultClosedIcon();
+        leafIcon = getDefaultLeafIcon();
+    }
+
+    /// The icon of an expanded node unless one is set: the one put into
+    /// [com.codename1.desktopcompat.javax.swing.UIManager] under
+    /// `Tree.openIcon`, else an open folder drawn in the theme's colors.
+    public Icon getDefaultOpenIcon() {
+        Icon i = com.codename1.desktopcompat.javax.swing.UIManager.getIcon("Tree.openIcon");
+        return i != null ? i : com.codename1.desktopcompat.rt.TreeIcons.OPEN;
+    }
+
+    /// The icon of a collapsed node: `Tree.closedIcon`, else a folder.
+    public Icon getDefaultClosedIcon() {
+        Icon i = com.codename1.desktopcompat.javax.swing.UIManager.getIcon("Tree.closedIcon");
+        return i != null ? i : com.codename1.desktopcompat.rt.TreeIcons.CLOSED;
+    }
+
+    /// The icon of a leaf: `Tree.leafIcon`, else a sheet of paper.
+    public Icon getDefaultLeafIcon() {
+        Icon i = com.codename1.desktopcompat.javax.swing.UIManager.getIcon("Tree.leafIcon");
+        return i != null ? i : com.codename1.desktopcompat.rt.TreeIcons.LEAF;
+    }
+
+    public void setOpenIcon(Icon newIcon) {
+        openIcon = newIcon;
+    }
+
+    public Icon getOpenIcon() {
+        return openIcon;
+    }
+
+    public void setClosedIcon(Icon newIcon) {
+        closedIcon = newIcon;
+    }
+
+    public Icon getClosedIcon() {
+        return closedIcon;
+    }
+
+    public void setLeafIcon(Icon newIcon) {
+        leafIcon = newIcon;
+    }
+
+    public Icon getLeafIcon() {
+        return leafIcon;
+    }
+
+    public void setTextSelectionColor(Color newColor) {
+        textSelectionColor = newColor;
+    }
+
+    public Color getTextSelectionColor() {
+        return textSelectionColor;
+    }
+
+    public void setTextNonSelectionColor(Color newColor) {
+        textNonSelectionColor = newColor;
+    }
+
+    public Color getTextNonSelectionColor() {
+        return textNonSelectionColor;
+    }
+
+    public void setBackgroundSelectionColor(Color newColor) {
+        backgroundSelectionColor = newColor;
+    }
+
+    public Color getBackgroundSelectionColor() {
+        return backgroundSelectionColor;
+    }
+
+    public void setBackgroundNonSelectionColor(Color newColor) {
+        backgroundNonSelectionColor = newColor;
+    }
+
+    public Color getBackgroundNonSelectionColor() {
+        return backgroundNonSelectionColor;
+    }
+
+    public void setBorderSelectionColor(Color newColor) {
+        borderSelectionColor = newColor;
+    }
+
+    public Color getBorderSelectionColor() {
+        return borderSelectionColor;
+    }
+
+    @Override
+    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded,
+            boolean leaf, int row, boolean hasFocus) {
+        String text = tree == null ? String.valueOf(value)
+                : tree.convertValueToText(value, sel, expanded, leaf, row, hasFocus);
+        this.hasFocus = hasFocus;
+        this.selected = sel;
+        if (!text.equals(getText())) {
+            setText(text);
+        }
+        Color fg = sel ? textSelectionColor : textNonSelectionColor;
+        // This reaches the Codename One label's style, so it is not
+        // repeated for a row that looks like the one before it.
+        if (fg != null && !fg.equals(shownForeground)) {
+            shownForeground = fg;
+            super.setForeground(fg);
+        }
+        if (tree != null) {
+            Font f = tree.getFont();
+            if (!f.equals(isFontSet() ? getFont() : null)) {
+                setFont(f);
+            }
+            if (isEnabled() != tree.isEnabled()) {
+                setEnabled(tree.isEnabled());
+            }
+        }
+        Icon icon = leaf ? leafIcon : expanded ? openIcon : closedIcon;
+        if (icon != getIcon()) {
+            setIcon(icon);
+        }
+        return this;
+    }
+
+    /// Fills the row with the background color of its state, if there is
+    /// one, and paints the label over it.
+    @Override
+    public void paint(Graphics g) {
+        Color bg = selected ? backgroundSelectionColor : backgroundNonSelectionColor;
+        if (bg != null) {
+            g.setColor(bg);
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        super.paint(g);
+        if (hasFocus && selected && borderSelectionColor != null) {
+            g.setColor(borderSelectionColor);
+            g.drawRect(0, 0, getWidth() - 1, getHeight() - 1);
+        }
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void validate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void invalidate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void revalidate() {
+    }
+
+    /// Does nothing: the tree paints the renderer when it paints itself.
+    @Override
+    public void repaint(long tm, int x, int y, int width, int height) {
+    }
+
+    /// Does nothing: the tree paints the renderer when it paints itself.
+    @Override
+    public void repaint(Rectangle r) {
+    }
+
+    /// Does nothing: the tree paints the renderer when it paints itself.
+    @Override
+    public void repaint() {
+    }
+
+    /// Does nothing: nobody listens to a renderer's properties.
+    @Override
+    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+    }
+
+    /// Does nothing: nobody listens to a renderer's properties.
+    @Override
+    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeModel.java
new file mode 100644
index 00000000000..e2bd0603633
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeModel.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import java.util.EventListener;
+
+/// A tree model over [TreeNode]s. Change the nodes through
+/// [#insertNodeInto] and [#removeNodeFromParent], or change them directly
+/// and then say so with one of the `node...` methods, so that the tree
+/// hears of it.
+public class DefaultTreeModel implements TreeModel {
+
+    protected TreeNode root;
+    protected EventListenerList listenerList = new EventListenerList();
+    protected boolean asksAllowsChildren;
+
+    public DefaultTreeModel(TreeNode root) {
+        this(root, false);
+    }
+
+    public DefaultTreeModel(TreeNode root, boolean asksAllowsChildren) {
+        this.root = root;
+        this.asksAllowsChildren = asksAllowsChildren;
+    }
+
+    public void setAsksAllowsChildren(boolean newValue) {
+        asksAllowsChildren = newValue;
+    }
+
+    public boolean asksAllowsChildren() {
+        return asksAllowsChildren;
+    }
+
+    public void setRoot(TreeNode root) {
+        Object oldRoot = this.root;
+        this.root = root;
+        if (root == null && oldRoot != null) {
+            fireTreeStructureChanged(this, null);
+        } else {
+            nodeStructureChanged(root);
+        }
+    }
+
+    @Override
+    public Object getRoot() {
+        return root;
+    }
+
+    @Override
+    public int getIndexOfChild(Object parent, Object child) {
+        if (!(parent instanceof TreeNode) || !(child instanceof TreeNode)) {
+            return -1;
+        }
+        return ((TreeNode) parent).getIndex((TreeNode) child);
+    }
+
+    @Override
+    public Object getChild(Object parent, int index) {
+        return parent instanceof TreeNode ? ((TreeNode) parent).getChildAt(index) : null;
+    }
+
+    @Override
+    public int getChildCount(Object parent) {
+        return parent instanceof TreeNode ? ((TreeNode) parent).getChildCount() : 0;
+    }
+
+    @Override
+    public boolean isLeaf(Object node) {
+        if (!(node instanceof TreeNode)) {
+            return true;
+        }
+        if (asksAllowsChildren) {
+            return !((TreeNode) node).getAllowsChildren();
+        }
+        return ((TreeNode) node).isLeaf();
+    }
+
+    /// Everything below the root may have changed.
+    public void reload() {
+        reload(root);
+    }
+
+    @Override
+    public void valueForPathChanged(TreePath path, Object newValue) {
+        Object node = path.getLastPathComponent();
+        if (node instanceof MutableTreeNode) {
+            ((MutableTreeNode) node).setUserObject(newValue);
+            nodeChanged((MutableTreeNode) node);
+        }
+    }
+
+    public void insertNodeInto(MutableTreeNode newChild, MutableTreeNode parent, int index) {
+        parent.insert(newChild, index);
+        nodesWereInserted(parent, new int[]{index});
+    }
+
+    public void removeNodeFromParent(MutableTreeNode node) {
+        TreeNode parent = node.getParent();
+        if (!(parent instanceof MutableTreeNode)) {
+            throw new IllegalArgumentException("node does not have a parent.");
+        }
+        int[] childIndex = {parent.getIndex(node)};
+        Object[] removed = {node};
+        ((MutableTreeNode) parent).remove(childIndex[0]);
+        nodesWereRemoved(parent, childIndex, removed);
+    }
+
+    public void nodeChanged(TreeNode node) {
+        if (listenerList != null && node != null) {
+            TreeNode parent = node.getParent();
+            if (parent != null) {
+                int index = parent.getIndex(node);
+                if (index != -1) {
+                    nodesChanged(parent, new int[]{index});
+                }
+            } else if (node == getRoot()) {
+                nodesChanged(node, null);
+            }
+        }
+    }
+
+    /// Everything below `node` may have changed.
+    public void reload(TreeNode node) {
+        if (node != null) {
+            fireTreeStructureChanged(this, getPathToRoot(node), null, null);
+        }
+    }
+
+    public void nodesWereInserted(TreeNode node, int[] childIndices) {
+        if (listenerList != null && node != null && childIndices != null && childIndices.length > 0) {
+            Object[] newChildren = new Object[childIndices.length];
+            for (int i = 0; i < childIndices.length; i++) {
+                newChildren[i] = node.getChildAt(childIndices[i]);
+            }
+            fireTreeNodesInserted(this, getPathToRoot(node), childIndices, newChildren);
+        }
+    }
+
+    public void nodesWereRemoved(TreeNode node, int[] childIndices, Object[] removedChildren) {
+        if (node != null && childIndices != null) {
+            fireTreeNodesRemoved(this, getPathToRoot(node), childIndices, removedChildren);
+        }
+    }
+
+    public void nodesChanged(TreeNode node, int[] childIndices) {
+        if (node != null) {
+            if (childIndices != null) {
+                if (childIndices.length > 0) {
+                    Object[] changed = new Object[childIndices.length];
+                    for (int i = 0; i < childIndices.length; i++) {
+                        changed[i] = node.getChildAt(childIndices[i]);
+                    }
+                    fireTreeNodesChanged(this, getPathToRoot(node), childIndices, changed);
+                }
+            } else if (node == getRoot()) {
+                fireTreeNodesChanged(this, getPathToRoot(node), null, null);
+            }
+        }
+    }
+
+    public void nodeStructureChanged(TreeNode node) {
+        if (node != null) {
+            fireTreeStructureChanged(this, getPathToRoot(node), null, null);
+        }
+    }
+
+    public TreeNode[] getPathToRoot(TreeNode aNode) {
+        return getPathToRoot(aNode, 0);
+    }
+
+    /// The nodes from the model's root down to `aNode`, with `depth` free
+    /// places after them.
+    protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) {
+        int n = 0;
+        boolean reached = false;
+        for (TreeNode t = aNode; t != null; t = t.getParent()) {
+            n++;
+            if (t == root) {
+                reached = true;
+                break;
+            }
+        }
+        if (aNode == null) {
+            return depth == 0 ? null : new TreeNode[depth];
+        }
+        TreeNode[] out = new TreeNode[n + depth];
+        int at = n;
+        for (TreeNode t = aNode; t != null && at > 0; t = t.getParent()) {
+            out[--at] = t;
+            if (reached && t == root) {
+                break;
+            }
+        }
+        return out;
+    }
+
+    @Override
+    public void addTreeModelListener(TreeModelListener l) {
+        listenerList.add(TreeModelListener.class, l);
+    }
+
+    @Override
+    public void removeTreeModelListener(TreeModelListener l) {
+        listenerList.remove(TreeModelListener.class, l);
+    }
+
+    public TreeModelListener[] getTreeModelListeners() {
+        return listenerList.getListeners(TreeModelListener.class);
+    }
+
+    protected void fireTreeNodesChanged(Object source, Object[] path, int[] childIndices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        TreeModelEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeModelEvent(source, path, childIndices, children);
+            }
+            ls[i].treeNodesChanged(e);
+        }
+    }
+
+    protected void fireTreeNodesInserted(Object source, Object[] path, int[] childIndices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        TreeModelEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeModelEvent(source, path, childIndices, children);
+            }
+            ls[i].treeNodesInserted(e);
+        }
+    }
+
+    protected void fireTreeNodesRemoved(Object source, Object[] path, int[] childIndices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        TreeModelEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeModelEvent(source, path, childIndices, children);
+            }
+            ls[i].treeNodesRemoved(e);
+        }
+    }
+
+    protected void fireTreeStructureChanged(Object source, Object[] path, int[] childIndices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        TreeModelEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeModelEvent(source, path, childIndices, children);
+            }
+            ls[i].treeStructureChanged(e);
+        }
+    }
+
+    private void fireTreeStructureChanged(Object source, TreePath path) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        TreeModelEvent e = null;
+        for (int i = ls.length - 1; i >= 0; i--) {
+            if (e == null) {
+                e = new TreeModelEvent(source, path);
+            }
+            ls[i].treeStructureChanged(e);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeSelectionModel.java
new file mode 100644
index 00000000000..7e77fb55ebb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/DefaultTreeSelectionModel.java
@@ -0,0 +1,468 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.SwingPropertyChangeSupport;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionListener;
+import java.util.ArrayList;
+import java.util.EventListener;
+
+/// The selection of a tree: a set of paths, kept to one path or to one
+/// run of rows when the mode asks for it.
+///
+/// A run of rows can only be checked with a [RowMapper], which a tree
+/// gives its selection model. In the contiguous mode a selection that
+/// would not be one run is replaced: setting such paths selects the first
+/// of them, adding paths that do not join the run selects just the added
+/// ones, and removing from the middle of the run clears it.
+public class DefaultTreeSelectionModel implements Cloneable, TreeSelectionModel {
+
+    public static final String SELECTION_MODE_PROPERTY = "selectionMode";
+
+    protected SwingPropertyChangeSupport changeSupport;
+    protected TreePath[] selection;
+    protected EventListenerList listenerList = new EventListenerList();
+    protected transient RowMapper rowMapper;
+    protected int selectionMode;
+    protected TreePath leadPath;
+    protected int leadIndex;
+    protected int leadRow;
+
+    public DefaultTreeSelectionModel() {
+        selectionMode = DISCONTIGUOUS_TREE_SELECTION;
+        leadIndex = -1;
+        leadRow = -1;
+    }
+
+    @Override
+    public void setRowMapper(RowMapper newMapper) {
+        rowMapper = newMapper;
+        resetRowSelection();
+    }
+
+    @Override
+    public RowMapper getRowMapper() {
+        return rowMapper;
+    }
+
+    @Override
+    public void setSelectionMode(int mode) {
+        int old = selectionMode;
+        selectionMode = mode;
+        if (selectionMode != SINGLE_TREE_SELECTION && selectionMode != CONTIGUOUS_TREE_SELECTION
+                && selectionMode != DISCONTIGUOUS_TREE_SELECTION) {
+            selectionMode = DISCONTIGUOUS_TREE_SELECTION;
+        }
+        if (old != selectionMode && changeSupport != null) {
+            changeSupport.firePropertyChange(SELECTION_MODE_PROPERTY, Integer.valueOf(old),
+                    Integer.valueOf(selectionMode));
+        }
+    }
+
+    @Override
+    public int getSelectionMode() {
+        return selectionMode;
+    }
+
+    @Override
+    public void setSelectionPath(TreePath path) {
+        if (path == null) {
+            setSelectionPaths(null);
+        } else {
+            setSelectionPaths(new TreePath[]{path});
+        }
+    }
+
+    private static boolean has(ArrayList<TreePath> list, TreePath p) {
+        for (int i = 0; i < list.size(); i++) {
+            if (list.get(i).equals(p)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The paths without nulls and repeats.
+    private static ArrayList<TreePath> clean(TreePath[] paths) {
+        ArrayList<TreePath> out = new ArrayList<TreePath>();
+        if (paths != null) {
+            for (int i = 0; i < paths.length; i++) {
+                if (paths[i] != null && !has(out, paths[i])) {
+                    out.add(paths[i]);
+                }
+            }
+        }
+        return out;
+    }
+
+    private ArrayList<TreePath> current() {
+        return clean(selection);
+    }
+
+    /// Makes `wanted` the selection and tells the listeners what joined
+    /// and what left.
+    private void become(ArrayList<TreePath> wanted, TreePath lead) {
+        ArrayList<TreePath> old = current();
+        ArrayList<TreePath> changed = new ArrayList<TreePath>();
+        ArrayList<Boolean> added = new ArrayList<Boolean>();
+        for (int i = 0; i < old.size(); i++) {
+            if (!has(wanted, old.get(i))) {
+                changed.add(old.get(i));
+                added.add(Boolean.FALSE);
+            }
+        }
+        for (int i = 0; i < wanted.size(); i++) {
+            if (!has(old, wanted.get(i))) {
+                changed.add(wanted.get(i));
+                added.add(Boolean.TRUE);
+            }
+        }
+        TreePath oldLead = leadPath;
+        selection = wanted.isEmpty() ? null : wanted.toArray(new TreePath[wanted.size()]);
+        leadPath = wanted.isEmpty() ? null : lead != null && has(wanted, lead) ? lead : wanted.get(wanted.size() - 1);
+        updateLeadIndex();
+        resetRowSelection();
+        if (!changed.isEmpty()) {
+            TreePath[] paths = changed.toArray(new TreePath[changed.size()]);
+            boolean[] areNew = new boolean[paths.length];
+            for (int i = 0; i < areNew.length; i++) {
+                areNew[i] = added.get(i).booleanValue();
+            }
+            fireValueChanged(new TreeSelectionEvent(this, paths, areNew, oldLead, leadPath));
+        }
+    }
+
+    @Override
+    public void setSelectionPaths(TreePath[] pPaths) {
+        ArrayList<TreePath> wanted = clean(pPaths);
+        if (wanted.size() > 1) {
+            boolean one = selectionMode == SINGLE_TREE_SELECTION
+                    || (selectionMode == CONTIGUOUS_TREE_SELECTION && !contiguous(wanted));
+            if (one) {
+                TreePath first = wanted.get(0);
+                wanted = new ArrayList<TreePath>();
+                wanted.add(first);
+            }
+        }
+        become(wanted, null);
+    }
+
+    @Override
+    public void addSelectionPath(TreePath path) {
+        if (path != null) {
+            addSelectionPaths(new TreePath[]{path});
+        }
+    }
+
+    @Override
+    public void addSelectionPaths(TreePath[] paths) {
+        ArrayList<TreePath> more = clean(paths);
+        if (more.isEmpty()) {
+            return;
+        }
+        if (selectionMode == SINGLE_TREE_SELECTION) {
+            setSelectionPaths(paths);
+            return;
+        }
+        ArrayList<TreePath> all = current();
+        for (int i = 0; i < more.size(); i++) {
+            if (!has(all, more.get(i))) {
+                all.add(more.get(i));
+            }
+        }
+        if (selectionMode == CONTIGUOUS_TREE_SELECTION && !contiguous(all)) {
+            setSelectionPaths(paths);
+            return;
+        }
+        become(all, more.get(more.size() - 1));
+    }
+
+    @Override
+    public void removeSelectionPath(TreePath path) {
+        if (path != null) {
+            removeSelectionPaths(new TreePath[]{path});
+        }
+    }
+
+    @Override
+    public void removeSelectionPaths(TreePath[] paths) {
+        ArrayList<TreePath> gone = clean(paths);
+        if (gone.isEmpty() || selection == null) {
+            return;
+        }
+        ArrayList<TreePath> old = current();
+        ArrayList<TreePath> left = new ArrayList<TreePath>();
+        for (int i = 0; i < old.size(); i++) {
+            if (!has(gone, old.get(i))) {
+                left.add(old.get(i));
+            }
+        }
+        if (left.size() == old.size()) {
+            return;
+        }
+        if (selectionMode == CONTIGUOUS_TREE_SELECTION && !contiguous(left)) {
+            left = new ArrayList<TreePath>();
+        }
+        become(left, leadPath);
+    }
+
+    @Override
+    public TreePath getSelectionPath() {
+        return selection != null && selection.length > 0 ? selection[0] : null;
+    }
+
+    @Override
+    public TreePath[] getSelectionPaths() {
+        if (selection == null) {
+            return null;
+        }
+        TreePath[] out = new TreePath[selection.length];
+        System.arraycopy(selection, 0, out, 0, selection.length);
+        return out;
+    }
+
+    @Override
+    public int getSelectionCount() {
+        return selection == null ? 0 : selection.length;
+    }
+
+    @Override
+    public boolean isPathSelected(TreePath path) {
+        if (path == null || selection == null) {
+            return false;
+        }
+        for (int i = 0; i < selection.length; i++) {
+            if (selection[i].equals(path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isSelectionEmpty() {
+        return selection == null || selection.length == 0;
+    }
+
+    @Override
+    public void clearSelection() {
+        if (selection != null && selection.length > 0) {
+            become(new ArrayList<TreePath>(), null);
+        }
+    }
+
+    @Override
+    public void addTreeSelectionListener(TreeSelectionListener x) {
+        listenerList.add(TreeSelectionListener.class, x);
+    }
+
+    @Override
+    public void removeTreeSelectionListener(TreeSelectionListener x) {
+        listenerList.remove(TreeSelectionListener.class, x);
+    }
+
+    public TreeSelectionListener[] getTreeSelectionListeners() {
+        return listenerList.getListeners(TreeSelectionListener.class);
+    }
+
+    protected void fireValueChanged(TreeSelectionEvent e) {
+        TreeSelectionListener[] ls = getTreeSelectionListeners();
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].valueChanged(e);
+        }
+    }
+
+    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
+        return listenerList.getListeners(listenerType);
+    }
+
+    /// The rows of the selected paths that are shown, in no set order.
+    @Override
+    public int[] getSelectionRows() {
+        if (rowMapper == null || selection == null || selection.length == 0) {
+            return new int[0];
+        }
+        int[] rows = rowMapper.getRowsForPaths(getSelectionPaths());
+        if (rows == null) {
+            return new int[0];
+        }
+        int n = 0;
+        for (int i = 0; i < rows.length; i++) {
+            if (rows[i] >= 0) {
+                n++;
+            }
+        }
+        int[] out = new int[n];
+        n = 0;
+        for (int i = 0; i < rows.length; i++) {
+            if (rows[i] >= 0) {
+                out[n++] = rows[i];
+            }
+        }
+        return out;
+    }
+
+    @Override
+    public int getMinSelectionRow() {
+        int[] rows = getSelectionRows();
+        int min = -1;
+        for (int i = 0; i < rows.length; i++) {
+            if (min < 0 || rows[i] < min) {
+                min = rows[i];
+            }
+        }
+        return min;
+    }
+
+    @Override
+    public int getMaxSelectionRow() {
+        int[] rows = getSelectionRows();
+        int max = -1;
+        for (int i = 0; i < rows.length; i++) {
+            max = Math.max(max, rows[i]);
+        }
+        return max;
+    }
+
+    @Override
+    public boolean isRowSelected(int row) {
+        int[] rows = getSelectionRows();
+        for (int i = 0; i < rows.length; i++) {
+            if (rows[i] == row) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// The rows of the paths changed: the lead row is looked up again.
+    @Override
+    public void resetRowSelection() {
+        leadRow = -1;
+        if (rowMapper != null && leadPath != null) {
+            int[] rows = rowMapper.getRowsForPaths(new TreePath[]{leadPath});
+            if (rows != null && rows.length > 0) {
+                leadRow = rows[0];
+            }
+        }
+    }
+
+    @Override
+    public int getLeadSelectionRow() {
+        return leadRow;
+    }
+
+    @Override
+    public TreePath getLeadSelectionPath() {
+        return leadPath;
+    }
+
+    @Override
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport == null) {
+            changeSupport = new SwingPropertyChangeSupport(this);
+        }
+        changeSupport.addPropertyChangeListener(listener);
+    }
+
+    @Override
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        if (changeSupport != null) {
+            changeSupport.removePropertyChangeListener(listener);
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners() {
+        if (changeSupport == null) {
+            return new PropertyChangeListener[0];
+        }
+        return changeSupport.getPropertyChangeListeners();
+    }
+
+    /// Whether the paths are shown on rows that follow one another. Paths
+    /// are taken for one run when there is no row mapper to ask.
+    private boolean contiguous(ArrayList<TreePath> paths) {
+        if (rowMapper == null || paths.size() < 2) {
+            return true;
+        }
+        int[] rows = rowMapper.getRowsForPaths(paths.toArray(new TreePath[paths.size()]));
+        if (rows == null) {
+            return true;
+        }
+        int min = Integer.MAX_VALUE;
+        int max = -1;
+        for (int i = 0; i < rows.length; i++) {
+            if (rows[i] < 0) {
+                return false;
+            }
+            min = Math.min(min, rows[i]);
+            max = Math.max(max, rows[i]);
+        }
+        return max - min + 1 == rows.length;
+    }
+
+    protected boolean arePathsContiguous(TreePath[] paths) {
+        return contiguous(clean(paths));
+    }
+
+    protected void updateLeadIndex() {
+        leadIndex = -1;
+        if (leadPath != null && selection != null) {
+            for (int i = selection.length - 1; i >= 0; i--) {
+                if (selection[i].equals(leadPath)) {
+                    leadIndex = i;
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(getClass().getName()).append(' ').append(hashCode()).append(" [ ");
+        if (selection != null) {
+            for (int i = 0; i < selection.length; i++) {
+                sb.append(selection[i]).append(' ');
+            }
+        }
+        sb.append(']');
+        return sb.toString();
+    }
+
+    /// A new model with the same mode and selected paths, and no
+    /// listeners or row mapper.
+    @Override
+    public Object clone() {
+        DefaultTreeSelectionModel copy = new DefaultTreeSelectionModel();
+        copy.selectionMode = selectionMode;
+        copy.selection = getSelectionPaths();
+        copy.leadPath = leadPath;
+        copy.leadIndex = leadIndex;
+        copy.leadRow = leadRow;
+        return copy;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/ExpandVetoException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/ExpandVetoException.java
new file mode 100644
index 00000000000..40e4fa4118f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/ExpandVetoException.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionEvent;
+
+/// Thrown by a listener to stop a node from expanding or collapsing.
+public class ExpandVetoException extends Exception {
+
+    protected TreeExpansionEvent event;
+
+    public ExpandVetoException(TreeExpansionEvent event) {
+        this(event, null);
+    }
+
+    public ExpandVetoException(TreeExpansionEvent event, String message) {
+        super(message);
+        this.event = event;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/MutableTreeNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/MutableTreeNode.java
new file mode 100644
index 00000000000..8d4a860aae6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/MutableTreeNode.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+/// A tree node whose children, parent and user object can be changed.
+public interface MutableTreeNode extends TreeNode {
+
+    void insert(MutableTreeNode child, int index);
+
+    void remove(int index);
+
+    void remove(MutableTreeNode node);
+
+    void setUserObject(Object object);
+
+    void removeFromParent();
+
+    void setParent(MutableTreeNode newParent);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/RowMapper.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/RowMapper.java
new file mode 100644
index 00000000000..700171549bd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/RowMapper.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+/// Answers the rows at which paths are shown; -1 for one that is not.
+public interface RowMapper {
+
+    int[] getRowsForPaths(TreePath[] path);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeCellEditor.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeCellEditor.java
new file mode 100644
index 00000000000..7d6a3ba5a02
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeCellEditor.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.CellEditor;
+import com.codename1.desktopcompat.javax.swing.JTree;
+
+/// Supplies the component that edits a node of a tree; the tree places it
+/// over the node's row.
+public interface TreeCellEditor extends CellEditor {
+
+    Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded,
+            boolean leaf, int row);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeCellRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeCellRenderer.java
new file mode 100644
index 00000000000..5a746fb3822
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeCellRenderer.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JTree;
+
+/// Supplies the component that paints a row of a tree. The tree gives it
+/// the row's bounds and paints it; the same component may be answered
+/// for every row.
+public interface TreeCellRenderer {
+
+    Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
+            boolean leaf, int row, boolean hasFocus);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeModel.java
new file mode 100644
index 00000000000..1250ed571ea
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeModel.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+
+/// The data of a tree: a root, and for every node its children. The tree
+/// asks for the children of a node only once the node is expanded.
+public interface TreeModel {
+
+    Object getRoot();
+
+    Object getChild(Object parent, int index);
+
+    int getChildCount(Object parent);
+
+    boolean isLeaf(Object node);
+
+    void valueForPathChanged(TreePath path, Object newValue);
+
+    int getIndexOfChild(Object parent, Object child);
+
+    void addTreeModelListener(TreeModelListener l);
+
+    void removeTreeModelListener(TreeModelListener l);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeNode.java
new file mode 100644
index 00000000000..98e7e0547a3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeNode.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import java.util.Enumeration;
+
+/// A node of a tree that knows its parent and its children.
+public interface TreeNode {
+
+    TreeNode getChildAt(int childIndex);
+
+    int getChildCount();
+
+    TreeNode getParent();
+
+    int getIndex(TreeNode node);
+
+    boolean getAllowsChildren();
+
+    boolean isLeaf();
+
+    Enumeration children();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreePath.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreePath.java
new file mode 100644
index 00000000000..b1cf1aa616b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreePath.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+/// The nodes from the root of a tree down to one node. Two paths are
+/// equal when their nodes are, one by one, so a path identifies a node
+/// whatever object was used to name it.
+public class TreePath {
+
+    private TreePath parentPath;
+    private Object lastPathComponent;
+
+    public TreePath(Object[] path) {
+        if (path == null || path.length == 0) {
+            throw new IllegalArgumentException("path in TreePath must be non null and not empty.");
+        }
+        lastPathComponent = path[path.length - 1];
+        if (lastPathComponent == null) {
+            throw new IllegalArgumentException("Last path component must be non-null");
+        }
+        if (path.length > 1) {
+            parentPath = new TreePath(path, path.length - 1);
+        }
+    }
+
+    public TreePath(Object lastPathComponent) {
+        if (lastPathComponent == null) {
+            throw new IllegalArgumentException("path in TreePath must be non null.");
+        }
+        this.lastPathComponent = lastPathComponent;
+        parentPath = null;
+    }
+
+    protected TreePath(TreePath parent, Object lastPathComponent) {
+        if (lastPathComponent == null) {
+            throw new IllegalArgumentException("path in TreePath must be non null.");
+        }
+        parentPath = parent;
+        this.lastPathComponent = lastPathComponent;
+    }
+
+    protected TreePath(Object[] path, int length) {
+        lastPathComponent = path[length - 1];
+        if (lastPathComponent == null) {
+            throw new IllegalArgumentException("Path elements must be non-null");
+        }
+        if (length > 1) {
+            parentPath = new TreePath(path, length - 1);
+        }
+    }
+
+    protected TreePath() {
+    }
+
+    public Object[] getPath() {
+        int i = getPathCount();
+        Object[] result = new Object[i--];
+        for (TreePath path = this; path != null; path = path.getParentPath()) {
+            result[i--] = path.getLastPathComponent();
+        }
+        return result;
+    }
+
+    public Object getLastPathComponent() {
+        return lastPathComponent;
+    }
+
+    public int getPathCount() {
+        int result = 0;
+        for (TreePath path = this; path != null; path = path.getParentPath()) {
+            result++;
+        }
+        return result;
+    }
+
+    public Object getPathComponent(int index) {
+        int count = getPathCount();
+        if (index < 0 || index >= count) {
+            throw new IllegalArgumentException("Index " + index + " is out of the specified range");
+        }
+        TreePath path = this;
+        for (int i = count - 1; i != index; i--) {
+            path = path.getParentPath();
+        }
+        return path.getLastPathComponent();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof TreePath)) {
+            return false;
+        }
+        TreePath a = this;
+        TreePath b = (TreePath) o;
+        if (a.getPathCount() != b.getPathCount()) {
+            return false;
+        }
+        while (a != null && b != null) {
+            if (a == b) {
+                return true;
+            }
+            Object x = a.getLastPathComponent();
+            Object y = b.getLastPathComponent();
+            if (x == null ? y != null : !x.equals(y)) {
+                return false;
+            }
+            a = a.getParentPath();
+            b = b.getParentPath();
+        }
+        return a == null && b == null;
+    }
+
+    @Override
+    public int hashCode() {
+        return lastPathComponent == null ? 0 : lastPathComponent.hashCode();
+    }
+
+    /// Whether `aTreePath` is this path or one that continues it.
+    public boolean isDescendant(TreePath aTreePath) {
+        if (aTreePath == this) {
+            return true;
+        }
+        if (aTreePath == null) {
+            return false;
+        }
+        int count = getPathCount();
+        int other = aTreePath.getPathCount();
+        if (other < count) {
+            return false;
+        }
+        TreePath p = aTreePath;
+        while (other-- > count) {
+            p = p.getParentPath();
+        }
+        return equals(p);
+    }
+
+    public TreePath pathByAddingChild(Object child) {
+        if (child == null) {
+            throw new NullPointerException("Null child not allowed");
+        }
+        return new TreePath(this, child);
+    }
+
+    public TreePath getParentPath() {
+        return parentPath;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("[");
+        Object[] all = getPath();
+        for (int i = 0; i < all.length; i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(all[i]);
+        }
+        sb.append(']');
+        return sb.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeSelectionModel.java
new file mode 100644
index 00000000000..5beae9ae564
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/TreeSelectionModel.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionListener;
+
+/// The selected paths of a tree.
+public interface TreeSelectionModel {
+
+    int SINGLE_TREE_SELECTION = 1;
+    int CONTIGUOUS_TREE_SELECTION = 2;
+    int DISCONTIGUOUS_TREE_SELECTION = 4;
+
+    void setSelectionMode(int mode);
+
+    int getSelectionMode();
+
+    void setSelectionPath(TreePath path);
+
+    void setSelectionPaths(TreePath[] paths);
+
+    void addSelectionPath(TreePath path);
+
+    void addSelectionPaths(TreePath[] paths);
+
+    void removeSelectionPath(TreePath path);
+
+    void removeSelectionPaths(TreePath[] paths);
+
+    TreePath getSelectionPath();
+
+    TreePath[] getSelectionPaths();
+
+    int getSelectionCount();
+
+    boolean isPathSelected(TreePath path);
+
+    boolean isSelectionEmpty();
+
+    void clearSelection();
+
+    void setRowMapper(RowMapper newMapper);
+
+    RowMapper getRowMapper();
+
+    int[] getSelectionRows();
+
+    int getMinSelectionRow();
+
+    int getMaxSelectionRow();
+
+    boolean isRowSelected(int row);
+
+    void resetRowSelection();
+
+    int getLeadSelectionRow();
+
+    TreePath getLeadSelectionPath();
+
+    void addPropertyChangeListener(PropertyChangeListener listener);
+
+    void removePropertyChangeListener(PropertyChangeListener listener);
+
+    void addTreeSelectionListener(TreeSelectionListener x);
+
+    void removeTreeSelectionListener(TreeSelectionListener x);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/package-info.java
new file mode 100644
index 00000000000..7a73b5e5a8f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/tree/package-info.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The models, paths, selection and cell drawing of
+/// [com.codename1.desktopcompat.javax.swing.JTree], under the names of
+/// `javax.swing.tree`.
+///
+/// The tree paints itself and asks a
+/// [com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer] for the
+/// component of every visible row, as on a desktop. A model is only asked
+/// for the children of nodes that are expanded, so a model that produces
+/// its children when asked stays lazy.
+package com.codename1.desktopcompat.javax.swing.tree;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/AbstractUndoableEdit.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/AbstractUndoableEdit.java
new file mode 100644
index 00000000000..08813276772
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/AbstractUndoableEdit.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+/// An edit that keeps track of whether it is done, undone or dead, and
+/// leaves the change itself to its subclass.
+public class AbstractUndoableEdit implements UndoableEdit {
+
+    /// The word [#getUndoPresentationName] starts with.
+    protected static final String UndoName = "Undo";
+
+    /// The word [#getRedoPresentationName] starts with.
+    protected static final String RedoName = "Redo";
+
+    private boolean hasBeenDone = true;
+    private boolean alive = true;
+
+    public AbstractUndoableEdit() {
+    }
+
+    @Override
+    public void die() {
+        alive = false;
+    }
+
+    @Override
+    public void undo() throws CannotUndoException {
+        if (!canUndo()) {
+            throw new CannotUndoException();
+        }
+        hasBeenDone = false;
+    }
+
+    @Override
+    public boolean canUndo() {
+        return alive && hasBeenDone;
+    }
+
+    @Override
+    public void redo() throws CannotRedoException {
+        if (!canRedo()) {
+            throw new CannotRedoException();
+        }
+        hasBeenDone = true;
+    }
+
+    @Override
+    public boolean canRedo() {
+        return alive && !hasBeenDone;
+    }
+
+    @Override
+    public boolean addEdit(UndoableEdit anEdit) {
+        return false;
+    }
+
+    @Override
+    public boolean replaceEdit(UndoableEdit anEdit) {
+        return false;
+    }
+
+    @Override
+    public boolean isSignificant() {
+        return true;
+    }
+
+    @Override
+    public String getPresentationName() {
+        return "";
+    }
+
+    @Override
+    public String getUndoPresentationName() {
+        String name = getPresentationName();
+        if (name != null && name.length() > 0) {
+            return UndoName + " " + name;
+        }
+        return UndoName;
+    }
+
+    @Override
+    public String getRedoPresentationName() {
+        String name = getPresentationName();
+        if (name != null && name.length() > 0) {
+            return RedoName + " " + name;
+        }
+        return RedoName;
+    }
+
+    @Override
+    public String toString() {
+        return "AbstractUndoableEdit hasBeenDone: " + hasBeenDone + " alive: " + alive;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CannotRedoException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CannotRedoException.java
new file mode 100644
index 00000000000..16fbf9dd634
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CannotRedoException.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+/// Thrown by an edit that cannot be applied again.
+public class CannotRedoException extends RuntimeException {
+
+    public CannotRedoException() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CannotUndoException.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CannotUndoException.java
new file mode 100644
index 00000000000..805347caff0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CannotUndoException.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+/// Thrown by an edit that cannot be taken back.
+public class CannotUndoException extends RuntimeException {
+
+    public CannotUndoException() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CompoundEdit.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CompoundEdit.java
new file mode 100644
index 00000000000..2081c51934b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/CompoundEdit.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+import java.util.Vector;
+
+/// Several edits that are undone and redone as one. Edits are collected
+/// until [#end] is called; only then can the compound be undone.
+public class CompoundEdit extends AbstractUndoableEdit {
+
+    /// The edits collected so far, oldest first.
+    protected Vector<UndoableEdit> edits = new Vector<UndoableEdit>();
+
+    private boolean inProgress = true;
+
+    public CompoundEdit() {
+    }
+
+    @Override
+    public void undo() throws CannotUndoException {
+        super.undo();
+        for (int i = edits.size() - 1; i >= 0; i--) {
+            edits.elementAt(i).undo();
+        }
+    }
+
+    @Override
+    public void redo() throws CannotRedoException {
+        super.redo();
+        for (int i = 0; i < edits.size(); i++) {
+            edits.elementAt(i).redo();
+        }
+    }
+
+    /// The edit added last, or null.
+    protected UndoableEdit lastEdit() {
+        int count = edits.size();
+        return count > 0 ? edits.elementAt(count - 1) : null;
+    }
+
+    @Override
+    public void die() {
+        for (int i = edits.size() - 1; i >= 0; i--) {
+            edits.elementAt(i).die();
+        }
+        super.die();
+    }
+
+    @Override
+    public boolean addEdit(UndoableEdit anEdit) {
+        if (!inProgress) {
+            return false;
+        }
+        UndoableEdit last = lastEdit();
+        if (last == null) {
+            edits.addElement(anEdit);
+        } else if (!last.addEdit(anEdit)) {
+            if (anEdit.replaceEdit(last)) {
+                edits.removeElementAt(edits.size() - 1);
+            }
+            edits.addElement(anEdit);
+        }
+        return true;
+    }
+
+    /// Stops collecting; the compound can be undone from now on.
+    public void end() {
+        inProgress = false;
+    }
+
+    @Override
+    public boolean canUndo() {
+        return !isInProgress() && super.canUndo();
+    }
+
+    @Override
+    public boolean canRedo() {
+        return !isInProgress() && super.canRedo();
+    }
+
+    public boolean isInProgress() {
+        return inProgress;
+    }
+
+    @Override
+    public boolean isSignificant() {
+        for (int i = 0; i < edits.size(); i++) {
+            if (edits.elementAt(i).isSignificant()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public String getPresentationName() {
+        UndoableEdit last = lastEdit();
+        return last != null ? last.getPresentationName() : super.getPresentationName();
+    }
+
+    @Override
+    public String getUndoPresentationName() {
+        UndoableEdit last = lastEdit();
+        return last != null ? last.getUndoPresentationName() : super.getUndoPresentationName();
+    }
+
+    @Override
+    public String getRedoPresentationName() {
+        UndoableEdit last = lastEdit();
+        return last != null ? last.getRedoPresentationName() : super.getRedoPresentationName();
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " inProgress: " + inProgress + " edits: " + edits;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoManager.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoManager.java
new file mode 100644
index 00000000000..9fb76eac87e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoManager.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditEvent;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditListener;
+
+import java.util.Vector;
+
+/// A history of edits with a position in it: `undo` steps back over the
+/// last significant edit, `redo` steps forward again, and adding an edit
+/// drops everything that had been undone. The history holds at most
+/// [#getLimit] edits, a hundred unless set otherwise.
+///
+/// Once [#end] is called the manager behaves as the single compound edit it
+/// extends.
+public class UndoManager extends CompoundEdit implements UndoableEditListener {
+
+    private int indexOfNextAdd;
+    private int limit = 100;
+
+    public UndoManager() {
+        edits.ensureCapacity(limit);
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    /// Empties the history, telling every edit it is dead.
+    public void discardAllEdits() {
+        for (int i = 0; i < edits.size(); i++) {
+            edits.elementAt(i).die();
+        }
+        edits = new Vector<UndoableEdit>();
+        indexOfNextAdd = 0;
+    }
+
+    /// Drops the edits furthest from the current position until the history
+    /// fits the limit.
+    protected void trimForLimit() {
+        if (limit >= 0) {
+            int size = edits.size();
+            if (size > limit) {
+                int halfLimit = limit / 2;
+                int keepFrom = indexOfNextAdd - 1 - halfLimit;
+                int keepTo = indexOfNextAdd - 1 + halfLimit;
+                if (keepTo - keepFrom + 1 > limit) {
+                    keepFrom++;
+                }
+                if (keepFrom < 0) {
+                    keepTo -= keepFrom;
+                    keepFrom = 0;
+                }
+                if (keepTo >= size) {
+                    int delta = size - keepTo - 1;
+                    keepTo += delta;
+                    keepFrom += delta;
+                }
+                trimEdits(keepTo + 1, size - 1);
+                trimEdits(0, keepFrom - 1);
+            }
+        }
+    }
+
+    /// Removes the edits from `from` to `to`, both included, newest first.
+    protected void trimEdits(int from, int to) {
+        if (from <= to) {
+            for (int i = to; from <= i; i--) {
+                UndoableEdit e = edits.elementAt(i);
+                e.die();
+                edits.removeElementAt(i);
+            }
+            if (indexOfNextAdd > to) {
+                indexOfNextAdd -= to - from + 1;
+            } else if (indexOfNextAdd >= from) {
+                indexOfNextAdd = from;
+            }
+        }
+    }
+
+    public void setLimit(int l) {
+        if (!isInProgress()) {
+            throw new RuntimeException("Attempt to call UndoManager.setLimit() after UndoManager.end() has been called");
+        }
+        limit = l;
+        trimForLimit();
+    }
+
+    /// The significant edit `undo` would take back, or null.
+    protected UndoableEdit editToBeUndone() {
+        int i = indexOfNextAdd;
+        while (i > 0) {
+            UndoableEdit edit = edits.elementAt(--i);
+            if (edit.isSignificant()) {
+                return edit;
+            }
+        }
+        return null;
+    }
+
+    /// The significant edit `redo` would apply again, or null.
+    protected UndoableEdit editToBeRedone() {
+        int count = edits.size();
+        int i = indexOfNextAdd;
+        while (i < count) {
+            UndoableEdit edit = edits.elementAt(i++);
+            if (edit.isSignificant()) {
+                return edit;
+            }
+        }
+        return null;
+    }
+
+    /// Undoes every edit back to `edit`, included.
+    protected void undoTo(UndoableEdit edit) throws CannotUndoException {
+        boolean done = false;
+        while (!done) {
+            UndoableEdit next = edits.elementAt(--indexOfNextAdd);
+            next.undo();
+            done = next == edit;
+        }
+    }
+
+    /// Redoes every edit up to `edit`, included.
+    protected void redoTo(UndoableEdit edit) throws CannotRedoException {
+        boolean done = false;
+        while (!done) {
+            UndoableEdit next = edits.elementAt(indexOfNextAdd++);
+            next.redo();
+            done = next == edit;
+        }
+    }
+
+    /// Undoes when the position is at the end of the history, redoes
+    /// otherwise: what a single "undo" key that toggles does.
+    public void undoOrRedo() throws CannotRedoException, CannotUndoException {
+        if (indexOfNextAdd == edits.size()) {
+            undo();
+        } else {
+            redo();
+        }
+    }
+
+    public boolean canUndoOrRedo() {
+        if (indexOfNextAdd == edits.size()) {
+            return canUndo();
+        }
+        return canRedo();
+    }
+
+    @Override
+    public void undo() throws CannotUndoException {
+        if (isInProgress()) {
+            UndoableEdit edit = editToBeUndone();
+            if (edit == null) {
+                throw new CannotUndoException();
+            }
+            undoTo(edit);
+        } else {
+            super.undo();
+        }
+    }
+
+    @Override
+    public boolean canUndo() {
+        if (isInProgress()) {
+            UndoableEdit edit = editToBeUndone();
+            return edit != null && edit.canUndo();
+        }
+        return super.canUndo();
+    }
+
+    @Override
+    public void redo() throws CannotRedoException {
+        if (isInProgress()) {
+            UndoableEdit edit = editToBeRedone();
+            if (edit == null) {
+                throw new CannotRedoException();
+            }
+            redoTo(edit);
+        } else {
+            super.redo();
+        }
+    }
+
+    @Override
+    public boolean canRedo() {
+        if (isInProgress()) {
+            UndoableEdit edit = editToBeRedone();
+            return edit != null && edit.canRedo();
+        }
+        return super.canRedo();
+    }
+
+    @Override
+    public boolean addEdit(UndoableEdit anEdit) {
+        // Whatever had been undone is gone for good.
+        trimEdits(indexOfNextAdd, edits.size() - 1);
+        boolean retVal = super.addEdit(anEdit);
+        if (isInProgress()) {
+            retVal = true;
+        }
+        // The compound may have merged the edit into the last one.
+        indexOfNextAdd = edits.size();
+        trimForLimit();
+        return retVal;
+    }
+
+    @Override
+    public void end() {
+        super.end();
+        trimEdits(indexOfNextAdd, edits.size() - 1);
+    }
+
+    public String getUndoOrRedoPresentationName() {
+        if (indexOfNextAdd == edits.size()) {
+            return getUndoPresentationName();
+        }
+        return getRedoPresentationName();
+    }
+
+    @Override
+    public String getUndoPresentationName() {
+        if (isInProgress()) {
+            if (canUndo()) {
+                UndoableEdit edit = editToBeUndone();
+                if (edit != null) {
+                    return edit.getUndoPresentationName();
+                }
+            }
+            return UndoName;
+        }
+        return super.getUndoPresentationName();
+    }
+
+    @Override
+    public String getRedoPresentationName() {
+        if (isInProgress()) {
+            if (canRedo()) {
+                UndoableEdit edit = editToBeRedone();
+                if (edit != null) {
+                    return edit.getRedoPresentationName();
+                }
+            }
+            return RedoName;
+        }
+        return super.getRedoPresentationName();
+    }
+
+    @Override
+    public void undoableEditHappened(UndoableEditEvent e) {
+        addEdit(e.getEdit());
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " limit: " + limit + " indexOfNextAdd: " + indexOfNextAdd;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoableEdit.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoableEdit.java
new file mode 100644
index 00000000000..629f67f0ca1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoableEdit.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+/// A change that can be taken back and applied again.
+public interface UndoableEdit {
+
+    /// Takes the change back.
+    void undo() throws CannotUndoException;
+
+    boolean canUndo();
+
+    /// Applies the change again after it was taken back.
+    void redo() throws CannotRedoException;
+
+    boolean canRedo();
+
+    /// Tells the edit it will never be used again.
+    void die();
+
+    /// Absorbs `anEdit` into this one; true when it was absorbed.
+    boolean addEdit(UndoableEdit anEdit);
+
+    /// Takes the place of `anEdit`; true when this edit now stands for both.
+    boolean replaceEdit(UndoableEdit anEdit);
+
+    /// False for an edit that should be undone together with its
+    /// neighbours rather than on its own.
+    boolean isSignificant();
+
+    String getPresentationName();
+
+    String getUndoPresentationName();
+
+    String getRedoPresentationName();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoableEditSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoableEditSupport.java
new file mode 100644
index 00000000000..347f42c78a6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/UndoableEditSupport.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.undo;
+
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditEvent;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditListener;
+
+import java.util.Vector;
+
+/// Keeps the undoable edit listeners of an object and posts edits to them,
+/// optionally gathering the edits made between [#beginUpdate] and
+/// [#endUpdate] into one compound edit.
+public class UndoableEditSupport {
+
+    /// How many `beginUpdate` calls are still open.
+    protected int updateLevel;
+
+    /// The compound being gathered, or null outside an update.
+    protected CompoundEdit compoundEdit;
+
+    protected Vector<UndoableEditListener> listeners = new Vector<UndoableEditListener>();
+
+    /// The object events name as their source.
+    protected Object realSource;
+
+    public UndoableEditSupport() {
+        this(null);
+    }
+
+    public UndoableEditSupport(Object r) {
+        realSource = r == null ? this : r;
+    }
+
+    public void addUndoableEditListener(UndoableEditListener l) {
+        listeners.addElement(l);
+    }
+
+    public void removeUndoableEditListener(UndoableEditListener l) {
+        listeners.removeElement(l);
+    }
+
+    public UndoableEditListener[] getUndoableEditListeners() {
+        UndoableEditListener[] out = new UndoableEditListener[listeners.size()];
+        listeners.copyInto(out);
+        return out;
+    }
+
+    /// Tells every listener about `e`, bypassing any update in progress.
+    protected void _postEdit(UndoableEdit e) {
+        UndoableEditEvent ev = new UndoableEditEvent(realSource, e);
+        UndoableEditListener[] all = getUndoableEditListeners();
+        for (int i = 0; i < all.length; i++) {
+            all[i].undoableEditHappened(ev);
+        }
+    }
+
+    /// Posts `e` to the listeners, or adds it to the compound of the update
+    /// in progress.
+    public void postEdit(UndoableEdit e) {
+        if (updateLevel == 0) {
+            _postEdit(e);
+        } else {
+            compoundEdit.addEdit(e);
+        }
+    }
+
+    public int getUpdateLevel() {
+        return updateLevel;
+    }
+
+    public void beginUpdate() {
+        if (updateLevel == 0) {
+            compoundEdit = createCompoundEdit();
+        }
+        updateLevel++;
+    }
+
+    protected CompoundEdit createCompoundEdit() {
+        return new CompoundEdit();
+    }
+
+    public void endUpdate() {
+        updateLevel--;
+        if (updateLevel == 0) {
+            compoundEdit.end();
+            _postEdit(compoundEdit);
+            compoundEdit = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + " updateLevel: " + updateLevel + " listeners: " + listeners
+                + " compoundEdit: " + compoundEdit;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/package-info.java
new file mode 100644
index 00000000000..5c7047e7167
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/undo/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Undo and redo: the edit an operation leaves behind, compound edits and
+/// the manager that keeps a history of them. The documents of
+/// `javax.swing.text` post one edit for each insertion and removal.
+package com.codename1.desktopcompat.javax.swing.undo;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/DocumentRange.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/DocumentRange.java
new file mode 100644
index 00000000000..d438d4764d4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/DocumentRange.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+/// A range of a document: from a start offset up to, and not including,
+/// an end offset.
+public class DocumentRange implements Comparable<DocumentRange> {
+
+    private int startOffs;
+    private int endOffs;
+
+    public DocumentRange(int startOffs, int endOffs) {
+        set(startOffs, endOffs);
+    }
+
+    @Override
+    public int compareTo(DocumentRange other) {
+        if (other == null) {
+            return 1;
+        }
+        int diff = startOffs - other.startOffs;
+        if (diff != 0) {
+            return diff;
+        }
+        return endOffs - other.endOffs;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other == this) {
+            return true;
+        }
+        if (other instanceof DocumentRange) {
+            return compareTo((DocumentRange) other) == 0;
+        }
+        return false;
+    }
+
+    public int getEndOffset() {
+        return endOffs;
+    }
+
+    public int getStartOffset() {
+        return startOffs;
+    }
+
+    @Override
+    public int hashCode() {
+        return startOffs + endOffs;
+    }
+
+    public boolean isZeroLength() {
+        return startOffs == endOffs;
+    }
+
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if the start is negative or after
+    ///   the end
+    public void set(int start, int end) {
+        if (start < 0 || end < 0) {
+            throw new IllegalArgumentException("start and end must be >= 0 (" + start + "-" + end + ")");
+        }
+        if (end < start) {
+            throw new IllegalArgumentException("'end' cannot be less than 'start' (" + start + "-" + end + ")");
+        }
+        this.startOffs = start;
+        this.endOffs = end;
+    }
+
+    @Override
+    public String toString() {
+        return "[DocumentRange: " + startOffs + "-" + endOffs + "]";
+    }
+
+    /// Moves this range by `amount` and answers this range.
+    public DocumentRange translate(int amount) {
+        startOffs += amount;
+        endOffs += amount;
+        return this;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/Lexer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/Lexer.java
new file mode 100644
index 00000000000..983090f23ba
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/Lexer.java
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+import java.util.HashSet;
+
+/// The small tokenizer behind the colors of [RSyntaxTextArea].
+///
+/// It knows four shapes of language rather than each language: the C
+/// family (line and block comments, quoted strings, numbers, keywords),
+/// the languages whose comments start with a hash, SQL, and markup. That
+/// is enough to tell comments, strings, numbers and keywords apart, which
+/// is what reading code needs; it is not a parser, and a construct it
+/// does not know is painted as plain text.
+final class Lexer {
+
+    static final int NONE = 0;
+    static final int C_LIKE = 1;
+    static final int HASH = 2;
+    static final int SQL = 3;
+    static final int MARKUP = 4;
+
+    private static final HashSet<String> KEYWORDS = set(
+            "abstract as assert async await break case catch class const continue debugger default defer"
+            + " delete do else enum export extends extern final finally fn for foreach from func function"
+            + " go goto if impl implements import in instanceof interface internal is let match mod native"
+            + " namespace new object of operator override package private protected pub public return"
+            + " sealed select static strictfp struct super switch synchronized this throw throws trait"
+            + " transient try type typedef typeof use using val var virtual volatile when where while"
+            + " with yield");
+    private static final HashSet<String> TYPES = set(
+            "boolean bool byte char double float int long short void string String Object var auto"
+            + " unsigned signed size_t i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 usize isize str number any");
+    private static final HashSet<String> LITERALS = set("true false null nil None True False undefined");
+    private static final HashSet<String> HASH_KEYWORDS = set(
+            "and as assert async await begin break case class continue def del do done elif else elsif"
+            + " end esac except export fi finally for from function global if import in is lambda local"
+            + " module nonlocal not or pass raise require rescue return then try unless until while"
+            + " with yield echo exit set unset source");
+    private static final HashSet<String> SQL_KEYWORDS = set(
+            "ADD ALL ALTER AND AS ASC BEGIN BETWEEN BY CASE COLUMN COMMIT CONSTRAINT CREATE DATABASE"
+            + " DEFAULT DELETE DESC DISTINCT DROP ELSE END EXISTS FOREIGN FROM FULL GROUP HAVING IN INDEX"
+            + " INNER INSERT INTO IS JOIN KEY LEFT LIKE LIMIT NOT NULL OFFSET ON OR ORDER OUTER PRIMARY"
+            + " REFERENCES RIGHT ROLLBACK SELECT SET TABLE THEN UNION UNIQUE UPDATE VALUES VIEW WHEN"
+            + " WHERE WITH");
+
+    /// The runs of the line scanned last: the end of each and its type.
+    int[] ends = new int[32];
+    int[] types = new int[32];
+    int count;
+
+    private static HashSet<String> set(String words) {
+        HashSet<String> out = new HashSet<String>();
+        int start = 0;
+        for (int i = 0; i <= words.length(); i++) {
+            if (i == words.length() || words.charAt(i) == ' ') {
+                if (i > start) {
+                    out.add(words.substring(start, i));
+                }
+                start = i + 1;
+            }
+        }
+        return out;
+    }
+
+    /// The shape of language a syntax style names.
+    static int family(String style) {
+        if (style == null || style.length() < 6 || SyntaxConstants.SYNTAX_STYLE_NONE.equals(style)) {
+            return NONE;
+        }
+        String s = style.substring(5);
+        if ("python".equals(s) || "unix".equals(s) || "yaml".equals(s) || "properties".equals(s)
+                || "ruby".equals(s) || "perl".equals(s) || "dockerfile".equals(s) || "makefile".equals(s)
+                || "ini".equals(s) || "hosts".equals(s) || "htaccess".equals(s) || "tcl".equals(s)) {
+            return HASH;
+        }
+        if ("sql".equals(s)) {
+            return SQL;
+        }
+        if ("xml".equals(s) || "html".equals(s) || "jsp".equals(s) || "mxml".equals(s) || "dtd".equals(s)
+                || "handlebars".equals(s) || "php".equals(s)) {
+            return MARKUP;
+        }
+        if ("markdown".equals(s) || "csv".equals(s) || "bbcode".equals(s) || "latex".equals(s)
+                || "bat".equals(s) || "asm".equals(s) || "asm6502".equals(s) || "fortran".equals(s)
+                || "lisp".equals(s) || "clojure".equals(s) || "vb".equals(s) || "vhdl".equals(s)
+                || "sas".equals(s) || "nsis".equals(s) || "lua".equals(s) || "delphi".equals(s)) {
+            return NONE;
+        }
+        return C_LIKE;
+    }
+
+    private void run(int end, int type) {
+        if (count > 0 && types[count - 1] == type) {
+            ends[count - 1] = end;
+            return;
+        }
+        if (count == ends.length) {
+            int[] e = new int[count * 2];
+            int[] t = new int[count * 2];
+            System.arraycopy(ends, 0, e, 0, count);
+            System.arraycopy(types, 0, t, 0, count);
+            ends = e;
+            types = t;
+        }
+        ends[count] = end;
+        types[count] = type;
+        count++;
+    }
+
+    private static boolean wordStart(char c) {
+        return c == '_' || c == '$' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c > 127;
+    }
+
+    private static boolean digit(char c) {
+        return c >= '0' && c <= '9';
+    }
+
+    private static String upper(String s) {
+        char[] out = new char[s.length()];
+        for (int i = 0; i < out.length; i++) {
+            char c = s.charAt(i);
+            out[i] = c >= 'a' && c <= 'z' ? (char) (c - 32) : c;
+        }
+        return new String(out);
+    }
+
+    /// Scans one line into [#ends] and [#types].
+    ///
+    /// #### Parameters
+    ///
+    /// - `s`: the line, without its line end
+    ///
+    /// - `family`: the shape of the language
+    ///
+    /// - `state`: 1 when the line starts inside a block comment, else 0
+    ///
+    /// #### Returns
+    ///
+    /// 1 when the line ends inside a block comment, else 0
+    int scan(String s, int family, int state) {
+        count = 0;
+        int n = s.length();
+        if (family == NONE) {
+            if (n > 0) {
+                run(n, TokenTypes.IDENTIFIER);
+            }
+            return 0;
+        }
+        String open = family == MARKUP ? "<!--" : "/*";
+        String close = family == MARKUP ? "-->" : "*/";
+        int commentType = family == MARKUP ? TokenTypes.MARKUP_COMMENT : TokenTypes.COMMENT_MULTILINE;
+        boolean blocks = family != HASH;
+        boolean inTag = false;
+        int i = 0;
+        while (i < n) {
+            if (state == 1) {
+                int end = s.indexOf(close, i);
+                if (end < 0) {
+                    run(n, commentType);
+                    return 1;
+                }
+                i = end + close.length();
+                run(i, commentType);
+                state = 0;
+                continue;
+            }
+            char c = s.charAt(i);
+            if (blocks && s.startsWith(open, i)) {
+                state = 1;
+                run(i + open.length(), commentType);
+                i += open.length();
+                continue;
+            }
+            if (family == MARKUP) {
+                if (c == '<') {
+                    int j = i + 1;
+                    if (j < n && (s.charAt(j) == '/' || s.charAt(j) == '?' || s.charAt(j) == '!')) {
+                        j++;
+                    }
+                    run(j, TokenTypes.MARKUP_TAG_DELIMITER);
+                    int k = j;
+                    while (k < n && (wordStart(s.charAt(k)) || digit(s.charAt(k)) || s.charAt(k) == ':'
+                            || s.charAt(k) == '-' || s.charAt(k) == '.')) {
+                        k++;
+                    }
+                    if (k > j) {
+                        run(k, TokenTypes.MARKUP_TAG_NAME);
+                    }
+                    i = k;
+                    inTag = true;
+                    continue;
+                }
+                if (!inTag) {
+                    int end = s.indexOf('<', i);
+                    i = end < 0 ? n : end;
+                    run(i, TokenTypes.IDENTIFIER);
+                    continue;
+                }
+                if (c == '>' || (c == '/' || c == '?') && i + 1 < n && s.charAt(i + 1) == '>') {
+                    i += c == '>' ? 1 : 2;
+                    run(i, TokenTypes.MARKUP_TAG_DELIMITER);
+                    inTag = false;
+                    continue;
+                }
+                if (c == '"' || c == '\'') {
+                    int end = s.indexOf(c, i + 1);
+                    i = end < 0 ? n : end + 1;
+                    run(i, TokenTypes.MARKUP_TAG_ATTRIBUTE_VALUE);
+                    continue;
+                }
+                if (wordStart(c)) {
+                    int k = i + 1;
+                    while (k < n && (wordStart(s.charAt(k)) || digit(s.charAt(k)) || s.charAt(k) == ':'
+                            || s.charAt(k) == '-')) {
+                        k++;
+                    }
+                    i = k;
+                    run(i, TokenTypes.MARKUP_TAG_ATTRIBUTE);
+                    continue;
+                }
+                i++;
+                run(i, c == ' ' ? TokenTypes.WHITESPACE : TokenTypes.OPERATOR);
+                continue;
+            }
+            if (family == C_LIKE && c == '/' && i + 1 < n && s.charAt(i + 1) == '/'
+                    || family == HASH && c == '#'
+                    || family == SQL && c == '-' && i + 1 < n && s.charAt(i + 1) == '-') {
+                run(n, TokenTypes.COMMENT_EOL);
+                return 0;
+            }
+            if (c == '"' || c == '\'' || c == '`') {
+                int k = i + 1;
+                while (k < n && s.charAt(k) != c) {
+                    k += s.charAt(k) == '\\' ? 2 : 1;
+                }
+                i = Math.min(n, k + 1);
+                run(i, c == '"' ? TokenTypes.LITERAL_STRING_DOUBLE_QUOTE
+                        : c == '`' ? TokenTypes.LITERAL_BACKQUOTE : TokenTypes.LITERAL_CHAR);
+                continue;
+            }
+            if (digit(c)) {
+                int k = i + 1;
+                boolean hex = c == '0' && k < n && (s.charAt(k) == 'x' || s.charAt(k) == 'X');
+                while (k < n && (digit(s.charAt(k)) || wordStart(s.charAt(k)) || s.charAt(k) == '.')) {
+                    k++;
+                }
+                i = k;
+                run(i, hex ? TokenTypes.LITERAL_NUMBER_HEXADECIMAL : TokenTypes.LITERAL_NUMBER_DECIMAL_INT);
+                continue;
+            }
+            if (wordStart(c)) {
+                int k = i + 1;
+                while (k < n && (wordStart(s.charAt(k)) || digit(s.charAt(k)))) {
+                    k++;
+                }
+                String word = s.substring(i, k);
+                int type = TokenTypes.IDENTIFIER;
+                if (family == SQL) {
+                    if (SQL_KEYWORDS.contains(upper(word))) {
+                        type = TokenTypes.RESERVED_WORD;
+                    }
+                } else if (LITERALS.contains(word)) {
+                    type = TokenTypes.LITERAL_BOOLEAN;
+                } else if (family == HASH ? HASH_KEYWORDS.contains(word) : KEYWORDS.contains(word)) {
+                    type = TokenTypes.RESERVED_WORD;
+                } else if (family == C_LIKE && TYPES.contains(word)) {
+                    type = TokenTypes.DATA_TYPE;
+                }
+                i = k;
+                run(i, type);
+                continue;
+            }
+            if (c == '@' && family == C_LIKE) {
+                int k = i + 1;
+                while (k < n && (wordStart(s.charAt(k)) || digit(s.charAt(k)) || s.charAt(k) == '.')) {
+                    k++;
+                }
+                i = k;
+                run(i, TokenTypes.ANNOTATION);
+                continue;
+            }
+            i++;
+            run(i, c == ' ' ? TokenTypes.WHITESPACE
+                    : c == '(' || c == ')' || c == '{' || c == '}' || c == '[' || c == ']' || c == ';'
+                            || c == ',' ? TokenTypes.SEPARATOR : TokenTypes.OPERATOR);
+        }
+        return state;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/RSyntaxTextArea.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/RSyntaxTextArea.java
new file mode 100644
index 00000000000..cb0efa17ef1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/RSyntaxTextArea.java
@@ -0,0 +1,623 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextArea;
+import com.codename1.desktopcompat.rt.LafTheme;
+import java.util.ArrayList;
+import java.util.List;
+
+/// RSyntaxTextArea in a reduced form: a code view, not a code editor.
+///
+/// #### What is provided
+///
+///  - The text in a monospaced font, tabs expanded, one row per line, so
+///    line highlights, line numbers and `modelToView` are exact (see
+///    [com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextAreaBase]).
+///  - Colors for comments, strings, numbers, keywords and markup tags,
+///    by the shape of the language the syntax style names: the C family,
+///    languages with hash comments, SQL and markup. Other styles are
+///    shown as plain text.
+///  - Line highlights, the current line highlight and marked occurrences.
+///  - Colors that follow the light or dark palette, or a [Theme].
+///
+/// #### What is recorded only
+///
+/// Every switch of the editor the library is: anti-aliasing, code
+/// folding, bracket matching and its animation, auto indent, closing of
+/// braces and tags, mark occurrences, visible whitespace and line ends,
+/// tab lines, hyperlinks, templates and the parser delay. Each setter
+/// keeps its value for its getter and changes nothing on screen.
+///
+/// #### What is absent
+///
+/// Parsers and their notices, folds, tokens as objects, auto completion,
+/// the syntax scheme class, the popup menu, and undo. [#forceReparsing]
+/// does nothing and [#getParserCount] is zero.
+public class RSyntaxTextArea extends RTextArea implements SyntaxConstants {
+
+    public static final String ANIMATE_BRACKET_MATCHING_PROPERTY = "RSTA.animateBracketMatching";
+    public static final String ANTIALIAS_PROPERTY = "RSTA.antiAlias";
+    public static final String AUTO_INDENT_PROPERTY = "RSTA.autoIndent";
+    public static final String BRACKET_MATCHING_PROPERTY = "RSTA.bracketMatching";
+    public static final String CLEAR_WHITESPACE_LINES_PROPERTY = "RSTA.clearWhitespaceLines";
+    public static final String CLOSE_CURLY_BRACES_PROPERTY = "RSTA.closeCurlyBraces";
+    public static final String CLOSE_MARKUP_TAGS_PROPERTY = "RSTA.closeMarkupTags";
+    public static final String CODE_FOLDING_PROPERTY = "RSTA.codeFolding";
+    public static final String EOL_VISIBLE_PROPERTY = "RSTA.eolMarkersVisible";
+    public static final String FOCUSABLE_TIPS_PROPERTY = "RSTA.focusableTips";
+    public static final String FRACTIONAL_FONTMETRICS_PROPERTY = "RSTA.fractionalFontMetrics";
+    public static final String HIGHLIGHT_SECONDARY_LANGUAGES_PROPERTY = "RSTA.highlightSecondaryLanguages";
+    public static final String HYPERLINKS_ENABLED_PROPERTY = "RSTA.hyperlinksEnabled";
+    public static final String INSERT_PAIRED_CHARS_PROPERTY = "RSTA.insertPairedChars";
+    public static final String MARK_OCCURRENCES_PROPERTY = "RSTA.markOccurrences";
+    public static final String MARKED_OCCURRENCES_CHANGED_PROPERTY = "RSTA.markedOccurrencesChanged";
+    public static final String PAINT_MATCHED_BRACKET_PAIR_PROPERTY = "RSTA.paintMatchedBracketPair";
+    public static final String PARSER_NOTICES_PROPERTY = "RSTA.parserNotices";
+    public static final String SYNTAX_SCHEME_PROPERTY = "RSTA.syntaxScheme";
+    public static final String SYNTAX_STYLE_PROPERTY = "RSTA.syntaxStyle";
+    public static final String TAB_LINE_COLOR_PROPERTY = "RSTA.tabLineColor";
+    public static final String TAB_LINES_PROPERTY = "RSTA.tabLines";
+    public static final String USE_SELECTED_TEXT_COLOR_PROPERTY = "RSTA.useSelectedTextColor";
+    public static final String VISIBLE_WHITESPACE_PROPERTY = "RSTA.visibleWhitespace";
+
+    /// The colors of the token types in a light and in a dark palette;
+    /// zero is the color of plain text.
+    private static final int[] LIGHT = new int[TokenTypes.DEFAULT_NUM_TOKEN_TYPES];
+    private static final int[] DARK = new int[TokenTypes.DEFAULT_NUM_TOKEN_TYPES];
+
+    static {
+        both(TokenTypes.COMMENT_EOL, 0x4f7f4f, 0x808080);
+        both(TokenTypes.COMMENT_MULTILINE, 0x4f7f4f, 0x808080);
+        both(TokenTypes.COMMENT_DOCUMENTATION, 0x4f7f4f, 0x629755);
+        both(TokenTypes.MARKUP_COMMENT, 0x4f7f4f, 0x808080);
+        both(TokenTypes.RESERVED_WORD, 0x0033b3, 0xcc7832);
+        both(TokenTypes.RESERVED_WORD_2, 0x0033b3, 0xcc7832);
+        both(TokenTypes.LITERAL_BOOLEAN, 0x0033b3, 0xcc7832);
+        both(TokenTypes.DATA_TYPE, 0x007a8a, 0xffc66d);
+        both(TokenTypes.LITERAL_NUMBER_DECIMAL_INT, 0x1750eb, 0x6897bb);
+        both(TokenTypes.LITERAL_NUMBER_FLOAT, 0x1750eb, 0x6897bb);
+        both(TokenTypes.LITERAL_NUMBER_HEXADECIMAL, 0x1750eb, 0x6897bb);
+        both(TokenTypes.LITERAL_STRING_DOUBLE_QUOTE, 0xa31515, 0x6a8759);
+        both(TokenTypes.LITERAL_CHAR, 0xa31515, 0x6a8759);
+        both(TokenTypes.LITERAL_BACKQUOTE, 0xa31515, 0x6a8759);
+        both(TokenTypes.ANNOTATION, 0x808000, 0xbbb529);
+        both(TokenTypes.PREPROCESSOR, 0x808000, 0xbbb529);
+        both(TokenTypes.MARKUP_TAG_DELIMITER, 0x7f0055, 0xe8bf6a);
+        both(TokenTypes.MARKUP_TAG_NAME, 0x7f0055, 0xe8bf6a);
+        both(TokenTypes.MARKUP_TAG_ATTRIBUTE, 0x174ad4, 0xbababa);
+        both(TokenTypes.MARKUP_TAG_ATTRIBUTE_VALUE, 0xa31515, 0x6a8759);
+    }
+
+    private final Lexer lexer = new Lexer();
+    /// A color per token type from a [Theme]; null entries follow the
+    /// palette.
+    private Color[] tokenColors;
+    private String syntaxStyle = SYNTAX_STYLE_NONE;
+    private int family;
+    /// For each line, whether it starts inside a block comment.
+    private boolean[] inComment;
+    private String scanned;
+
+    private boolean animateBracketMatching = true;
+    private boolean antiAliasing = true;
+    private boolean autoIndent = true;
+    private boolean bracketMatching = true;
+    private boolean clearWhitespaceLines = true;
+    private boolean closeCurlyBraces = true;
+    private boolean closeMarkupTags = true;
+    private boolean codeFolding;
+    private boolean eolMarkersVisible;
+    private boolean fractionalFontMetrics;
+    private boolean highlightSecondaryLanguages = true;
+    private boolean hyperlinksEnabled = true;
+    private boolean insertPairedCharacters = true;
+    private boolean markOccurrences;
+    private boolean paintMarkOccurrencesBorder;
+    private boolean paintMatchedBracketPair;
+    private boolean paintTabLines;
+    private boolean showMatchedBracketPopup = true;
+    private boolean useFocusableTips = true;
+    private boolean useSelectedTextColor;
+    private boolean whitespaceVisible;
+    private int markOccurrencesDelay = 1000;
+    private int parserDelay = 1250;
+    private int rightHandSideCorrection;
+    private Color hyperlinkForeground = Color.BLUE;
+    private Color markOccurrencesColor;
+    private Color matchedBracketBGColor = getDefaultBracketMatchBGColor();
+    private Color matchedBracketBorderColor = getDefaultBracketMatchBorderColor();
+    private Color tabLineColor = Color.GRAY;
+
+    public RSyntaxTextArea() {
+        super();
+    }
+
+    public RSyntaxTextArea(String text) {
+        super(text);
+    }
+
+    public RSyntaxTextArea(int rows, int cols) {
+        super(rows, cols);
+    }
+
+    public RSyntaxTextArea(String text, int rows, int cols) {
+        super(text, rows, cols);
+    }
+
+    public RSyntaxTextArea(int textMode) {
+        super(textMode);
+    }
+
+    private static void both(int type, int light, int dark) {
+        LIGHT[type] = light;
+        DARK[type] = dark;
+    }
+
+    // ------------------------------------------------------------ syntax
+
+    public String getSyntaxEditingStyle() {
+        return syntaxStyle;
+    }
+
+    /// Chooses how the text is colored, by one of the names in
+    /// [SyntaxConstants]. Null means plain text.
+    public void setSyntaxEditingStyle(String styleKey) {
+        String now = styleKey == null ? SYNTAX_STYLE_NONE : styleKey;
+        if (!now.equals(syntaxStyle)) {
+            String old = syntaxStyle;
+            syntaxStyle = now;
+            family = Lexer.family(now);
+            scanned = null;
+            firePropertyChange(SYNTAX_STYLE_PROPERTY, old, now);
+            repaint();
+        }
+    }
+
+    /// The color tokens of this type are painted in.
+    public Color getForegroundForTokenType(int type) {
+        if (tokenColors != null && type >= 0 && type < tokenColors.length && tokenColors[type] != null) {
+            return tokenColors[type];
+        }
+        int[] palette = LafTheme.isDark() ? DARK : LIGHT;
+        if (type > 0 && type < palette.length && palette[type] != 0) {
+            return new Color(palette[type]);
+        }
+        return getForeground();
+    }
+
+    /// The colors a [Theme] gives the token types; null entries, and a
+    /// null array, follow the palette.
+    void cn1TokenColors(Color[] colors) {
+        tokenColors = colors;
+        repaint();
+    }
+
+    Color[] cn1TokenColors() {
+        return tokenColors;
+    }
+
+    /// Finds, for every line, whether it starts inside a block comment.
+    private void scanStates(String all) {
+        int lines = Math.max(1, getLineCount());
+        boolean[] states = new boolean[lines];
+        int state = 0;
+        if (family != Lexer.NONE && family != Lexer.HASH) {
+            for (int line = 0; line < lines; line++) {
+                states[line] = state == 1;
+                state = lexer.scan(cn1LineText(all, line), family, state);
+            }
+        }
+        inComment = states;
+        scanned = all;
+    }
+
+    @Override
+    protected void cn1PaintLine(Graphics g, String shown, int line, int x, int baseline) {
+        if (family == Lexer.NONE || !isEnabled()) {
+            super.cn1PaintLine(g, shown, line, x, baseline);
+            return;
+        }
+        String all = getText();
+        if (all == null) {
+            all = "";
+        }
+        if (inComment == null || scanned == null || !scanned.equals(all)) {
+            scanStates(all);
+        }
+        boolean[] states = inComment;
+        lexer.scan(shown, family, states != null && line < states.length && states[line] ? 1 : 0);
+        FontMetrics fm = getFontMetrics(getFont());
+        int from = 0;
+        int at = x;
+        for (int i = 0; i < lexer.count; i++) {
+            int end = Math.min(shown.length(), lexer.ends[i]);
+            if (end <= from) {
+                continue;
+            }
+            String run = shown.substring(from, end);
+            if (lexer.types[i] != TokenTypes.WHITESPACE) {
+                g.setColor(getForegroundForTokenType(lexer.types[i]));
+                g.drawString(run, at, baseline);
+            }
+            at += fm.stringWidth(run);
+            from = end;
+        }
+    }
+
+    // ------------------------------------------------------------ parsing: absent
+
+    /// Does nothing: there are no parsers.
+    public void forceReparsing(int parser) {
+    }
+
+    /// Always zero: there are no parsers.
+    public int getParserCount() {
+        return 0;
+    }
+
+    /// Does nothing: there are no parsers.
+    public void clearParsers() {
+    }
+
+    public int getParserDelay() {
+        return parserDelay;
+    }
+
+    /// Recorded only.
+    public void setParserDelay(int millis) {
+        parserDelay = millis;
+    }
+
+    /// The marked occurrences: the ranges of
+    /// [com.codename1.desktopcompat.org.fife.ui.rtextarea.SearchEngine#markAll].
+    public List<DocumentRange> getMarkAllHighlightRanges() {
+        return new ArrayList<DocumentRange>(cn1Marked());
+    }
+
+    /// Always empty: occurrences of the word at the caret are not marked.
+    public List<DocumentRange> getMarkedOccurrences() {
+        return new ArrayList<DocumentRange>();
+    }
+
+    // ------------------------------------------------------------ recorded only
+
+    public static Color getDefaultBracketMatchBGColor() {
+        return new Color(234, 234, 255);
+    }
+
+    public static Color getDefaultBracketMatchBorderColor() {
+        return new Color(0, 0, 128);
+    }
+
+    public static Color getDefaultSelectionColor() {
+        return new Color(200, 200, 255);
+    }
+
+    public boolean getAnimateBracketMatching() {
+        return animateBracketMatching;
+    }
+
+    /// Recorded only.
+    public void setAnimateBracketMatching(boolean animate) {
+        boolean old = animateBracketMatching;
+        animateBracketMatching = animate;
+        firePropertyChange(ANIMATE_BRACKET_MATCHING_PROPERTY, old, animate);
+    }
+
+    public boolean getAntiAliasingEnabled() {
+        return antiAliasing;
+    }
+
+    /// Recorded only: text is drawn as the platform draws it.
+    public void setAntiAliasingEnabled(boolean enabled) {
+        boolean old = antiAliasing;
+        antiAliasing = enabled;
+        firePropertyChange(ANTIALIAS_PROPERTY, old, enabled);
+    }
+
+    public boolean isAutoIndentEnabled() {
+        return autoIndent;
+    }
+
+    /// Recorded only.
+    public void setAutoIndentEnabled(boolean enabled) {
+        boolean old = autoIndent;
+        autoIndent = enabled;
+        firePropertyChange(AUTO_INDENT_PROPERTY, old, enabled);
+    }
+
+    public final boolean isBracketMatchingEnabled() {
+        return bracketMatching;
+    }
+
+    /// Recorded only.
+    public void setBracketMatchingEnabled(boolean enabled) {
+        boolean old = bracketMatching;
+        bracketMatching = enabled;
+        firePropertyChange(BRACKET_MATCHING_PROPERTY, old, enabled);
+    }
+
+    public boolean isClearWhitespaceLinesEnabled() {
+        return clearWhitespaceLines;
+    }
+
+    /// Recorded only.
+    public void setClearWhitespaceLinesEnabled(boolean enabled) {
+        boolean old = clearWhitespaceLines;
+        clearWhitespaceLines = enabled;
+        firePropertyChange(CLEAR_WHITESPACE_LINES_PROPERTY, old, enabled);
+    }
+
+    public boolean getCloseCurlyBraces() {
+        return closeCurlyBraces;
+    }
+
+    /// Recorded only.
+    public void setCloseCurlyBraces(boolean close) {
+        boolean old = closeCurlyBraces;
+        closeCurlyBraces = close;
+        firePropertyChange(CLOSE_CURLY_BRACES_PROPERTY, old, close);
+    }
+
+    public boolean getCloseMarkupTags() {
+        return closeMarkupTags;
+    }
+
+    /// Recorded only.
+    public void setCloseMarkupTags(boolean close) {
+        boolean old = closeMarkupTags;
+        closeMarkupTags = close;
+        firePropertyChange(CLOSE_MARKUP_TAGS_PROPERTY, old, close);
+    }
+
+    public boolean isCodeFoldingEnabled() {
+        return codeFolding;
+    }
+
+    /// Recorded only: there is no code folding.
+    public void setCodeFoldingEnabled(boolean enabled) {
+        boolean old = codeFolding;
+        codeFolding = enabled;
+        firePropertyChange(CODE_FOLDING_PROPERTY, old, enabled);
+    }
+
+    public boolean getEOLMarkersVisible() {
+        return eolMarkersVisible;
+    }
+
+    /// Recorded only.
+    public void setEOLMarkersVisible(boolean visible) {
+        boolean old = eolMarkersVisible;
+        eolMarkersVisible = visible;
+        firePropertyChange(EOL_VISIBLE_PROPERTY, old, visible);
+    }
+
+    public boolean getFractionalFontMetricsEnabled() {
+        return fractionalFontMetrics;
+    }
+
+    /// Recorded only.
+    public void setFractionalFontMetricsEnabled(boolean enabled) {
+        boolean old = fractionalFontMetrics;
+        fractionalFontMetrics = enabled;
+        firePropertyChange(FRACTIONAL_FONTMETRICS_PROPERTY, old, enabled);
+    }
+
+    public boolean getHighlightSecondaryLanguages() {
+        return highlightSecondaryLanguages;
+    }
+
+    /// Recorded only.
+    public void setHighlightSecondaryLanguages(boolean highlight) {
+        boolean old = highlightSecondaryLanguages;
+        highlightSecondaryLanguages = highlight;
+        firePropertyChange(HIGHLIGHT_SECONDARY_LANGUAGES_PROPERTY, old, highlight);
+    }
+
+    public Color getHyperlinkForeground() {
+        return hyperlinkForeground;
+    }
+
+    /// Recorded only.
+    public void setHyperlinkForeground(Color fg) {
+        if (fg == null) {
+            throw new NullPointerException("fg cannot be null");
+        }
+        hyperlinkForeground = fg;
+    }
+
+    public boolean getHyperlinksEnabled() {
+        return hyperlinksEnabled;
+    }
+
+    /// Recorded only.
+    public void setHyperlinksEnabled(boolean enabled) {
+        boolean old = hyperlinksEnabled;
+        hyperlinksEnabled = enabled;
+        firePropertyChange(HYPERLINKS_ENABLED_PROPERTY, old, enabled);
+    }
+
+    public boolean getInsertPairedCharacters() {
+        return insertPairedCharacters;
+    }
+
+    /// Recorded only.
+    public void setInsertPairedCharacters(boolean insert) {
+        boolean old = insertPairedCharacters;
+        insertPairedCharacters = insert;
+        firePropertyChange(INSERT_PAIRED_CHARS_PROPERTY, old, insert);
+    }
+
+    public boolean getMarkOccurrences() {
+        return markOccurrences;
+    }
+
+    /// Recorded only.
+    public void setMarkOccurrences(boolean mark) {
+        boolean old = markOccurrences;
+        markOccurrences = mark;
+        firePropertyChange(MARK_OCCURRENCES_PROPERTY, old, mark);
+    }
+
+    public Color getMarkOccurrencesColor() {
+        return markOccurrencesColor != null ? markOccurrencesColor : getMarkAllHighlightColor();
+    }
+
+    /// Recorded only.
+    public void setMarkOccurrencesColor(Color color) {
+        markOccurrencesColor = color;
+    }
+
+    public int getMarkOccurrencesDelay() {
+        return markOccurrencesDelay;
+    }
+
+    /// Recorded only.
+    public void setMarkOccurrencesDelay(int millis) {
+        markOccurrencesDelay = millis;
+    }
+
+    public boolean getPaintMarkOccurrencesBorder() {
+        return paintMarkOccurrencesBorder;
+    }
+
+    /// Recorded only.
+    public void setPaintMarkOccurrencesBorder(boolean paint) {
+        paintMarkOccurrencesBorder = paint;
+    }
+
+    public Color getMatchedBracketBGColor() {
+        return matchedBracketBGColor;
+    }
+
+    /// Recorded only.
+    public void setMatchedBracketBGColor(Color color) {
+        matchedBracketBGColor = color;
+    }
+
+    public Color getMatchedBracketBorderColor() {
+        return matchedBracketBorderColor;
+    }
+
+    /// Recorded only.
+    public void setMatchedBracketBorderColor(Color color) {
+        matchedBracketBorderColor = color;
+    }
+
+    public boolean getPaintMatchedBracketPair() {
+        return paintMatchedBracketPair;
+    }
+
+    /// Recorded only.
+    public void setPaintMatchedBracketPair(boolean paint) {
+        boolean old = paintMatchedBracketPair;
+        paintMatchedBracketPair = paint;
+        firePropertyChange(PAINT_MATCHED_BRACKET_PAIR_PROPERTY, old, paint);
+    }
+
+    public boolean getPaintTabLines() {
+        return paintTabLines;
+    }
+
+    /// Recorded only.
+    public void setPaintTabLines(boolean paint) {
+        boolean old = paintTabLines;
+        paintTabLines = paint;
+        firePropertyChange(TAB_LINES_PROPERTY, old, paint);
+    }
+
+    public Color getTabLineColor() {
+        return tabLineColor;
+    }
+
+    /// Recorded only.
+    public void setTabLineColor(Color color) {
+        Color old = tabLineColor;
+        tabLineColor = color;
+        firePropertyChange(TAB_LINE_COLOR_PROPERTY, old, color);
+    }
+
+    public int getRightHandSideCorrection() {
+        return rightHandSideCorrection;
+    }
+
+    /// Recorded only.
+    public void setRightHandSideCorrection(int correction) {
+        rightHandSideCorrection = correction;
+    }
+
+    public boolean getShowMatchedBracketPopup() {
+        return showMatchedBracketPopup;
+    }
+
+    /// Recorded only.
+    public void setShowMatchedBracketPopup(boolean show) {
+        showMatchedBracketPopup = show;
+    }
+
+    public boolean getUseFocusableTips() {
+        return useFocusableTips;
+    }
+
+    /// Recorded only.
+    public void setUseFocusableTips(boolean use) {
+        boolean old = useFocusableTips;
+        useFocusableTips = use;
+        firePropertyChange(FOCUSABLE_TIPS_PROPERTY, old, use);
+    }
+
+    public boolean getUseSelectedTextColor() {
+        return useSelectedTextColor;
+    }
+
+    /// Recorded only: selected text keeps its colors.
+    public void setUseSelectedTextColor(boolean use) {
+        boolean old = useSelectedTextColor;
+        useSelectedTextColor = use;
+        firePropertyChange(USE_SELECTED_TEXT_COLOR_PROPERTY, old, use);
+    }
+
+    public boolean isWhitespaceVisible() {
+        return whitespaceVisible;
+    }
+
+    /// Recorded only.
+    public void setWhitespaceVisible(boolean visible) {
+        boolean old = whitespaceVisible;
+        whitespaceVisible = visible;
+        firePropertyChange(VISIBLE_WHITESPACE_PROPERTY, old, visible);
+    }
+
+    /// Does nothing: there is no line range to show in the gutter.
+    public void setActiveLineRange(int min, int max) {
+    }
+
+    /// Drops the token colors a theme gave, so they follow the palette.
+    public void restoreDefaultSyntaxScheme() {
+        cn1TokenColors(null);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/SyntaxConstants.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/SyntaxConstants.java
new file mode 100644
index 00000000000..8eae9b40734
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/SyntaxConstants.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+/// The names of the syntax styles a [RSyntaxTextArea] can be told to use.
+///
+/// Every name is accepted. This layer colors by the shape of a language
+/// rather than by each language, as [RSyntaxTextArea] describes, and a
+/// style it has no shape for is shown as plain text.
+public interface SyntaxConstants {
+
+    String SYNTAX_STYLE_NONE = "text/plain";
+    String SYNTAX_STYLE_ACTIONSCRIPT = "text/actionscript";
+    String SYNTAX_STYLE_ASSEMBLER_X86 = "text/asm";
+    String SYNTAX_STYLE_ASSEMBLER_6502 = "text/asm6502";
+    String SYNTAX_STYLE_BBCODE = "text/bbcode";
+    String SYNTAX_STYLE_C = "text/c";
+    String SYNTAX_STYLE_CLOJURE = "text/clojure";
+    String SYNTAX_STYLE_CPLUSPLUS = "text/cpp";
+    String SYNTAX_STYLE_CSHARP = "text/cs";
+    String SYNTAX_STYLE_CSS = "text/css";
+    String SYNTAX_STYLE_CSV = "text/csv";
+    String SYNTAX_STYLE_D = "text/d";
+    String SYNTAX_STYLE_DOCKERFILE = "text/dockerfile";
+    String SYNTAX_STYLE_DART = "text/dart";
+    String SYNTAX_STYLE_DELPHI = "text/delphi";
+    String SYNTAX_STYLE_DTD = "text/dtd";
+    String SYNTAX_STYLE_FORTRAN = "text/fortran";
+    String SYNTAX_STYLE_GO = "text/golang";
+    String SYNTAX_STYLE_GROOVY = "text/groovy";
+    String SYNTAX_STYLE_HANDLEBARS = "text/handlebars";
+    String SYNTAX_STYLE_HOSTS = "text/hosts";
+    String SYNTAX_STYLE_HTACCESS = "text/htaccess";
+    String SYNTAX_STYLE_HTML = "text/html";
+    String SYNTAX_STYLE_INI = "text/ini";
+    String SYNTAX_STYLE_JAVA = "text/java";
+    String SYNTAX_STYLE_JAVASCRIPT = "text/javascript";
+    String SYNTAX_STYLE_JSON = "text/json";
+    String SYNTAX_STYLE_JSON_WITH_COMMENTS = "text/jshintrc";
+    String SYNTAX_STYLE_JSP = "text/jsp";
+    String SYNTAX_STYLE_KOTLIN = "text/kotlin";
+    String SYNTAX_STYLE_LATEX = "text/latex";
+    String SYNTAX_STYLE_LESS = "text/less";
+    String SYNTAX_STYLE_LISP = "text/lisp";
+    String SYNTAX_STYLE_LUA = "text/lua";
+    String SYNTAX_STYLE_MAKEFILE = "text/makefile";
+    String SYNTAX_STYLE_MARKDOWN = "text/markdown";
+    String SYNTAX_STYLE_MXML = "text/mxml";
+    String SYNTAX_STYLE_NSIS = "text/nsis";
+    String SYNTAX_STYLE_PERL = "text/perl";
+    String SYNTAX_STYLE_PHP = "text/php";
+    String SYNTAX_STYLE_PROTO = "text/proto";
+    String SYNTAX_STYLE_PROPERTIES_FILE = "text/properties";
+    String SYNTAX_STYLE_PYTHON = "text/python";
+    String SYNTAX_STYLE_RUBY = "text/ruby";
+    String SYNTAX_STYLE_RUST = "text/rust";
+    String SYNTAX_STYLE_SAS = "text/sas";
+    String SYNTAX_STYLE_SCALA = "text/scala";
+    String SYNTAX_STYLE_SQL = "text/sql";
+    String SYNTAX_STYLE_TCL = "text/tcl";
+    String SYNTAX_STYLE_TYPESCRIPT = "text/typescript";
+    String SYNTAX_STYLE_UNIX_SHELL = "text/unix";
+    String SYNTAX_STYLE_VISUAL_BASIC = "text/vb";
+    String SYNTAX_STYLE_VHDL = "text/vhdl";
+    String SYNTAX_STYLE_WINDOWS_BATCH = "text/bat";
+    String SYNTAX_STYLE_XML = "text/xml";
+    String SYNTAX_STYLE_YAML = "text/yaml";
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/Theme.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/Theme.java
new file mode 100644
index 00000000000..66a13f0545c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/Theme.java
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.Gutter;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextAreaBase;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextScrollPane;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/// The colors of a [RSyntaxTextArea] and its gutter, read from a theme
+/// file in the library's XML format or taken from a text area.
+///
+/// What a theme carries here is what this layer paints: the background,
+/// the caret, the selection, the current line highlight, the mark-all
+/// color, the gutter background, border and line number colors, the font
+/// size, and a foreground color per token type. Bold, italic and
+/// underlined token styles, and the remaining colors, are read into their
+/// fields where a field exists and are not painted.
+///
+/// The theme files of the library itself live in its jar, which an
+/// application built with this layer does not ship. Reading one of them
+/// therefore hands [#load] a null stream, which fails with a
+/// `NullPointerException` exactly as on the desktop; an application that
+/// catches it, as the common idiom does, keeps the default colors, which
+/// follow the light or dark palette.
+public class Theme {
+
+    public Font baseFont;
+    public Color bgColor;
+    public Color caretColor;
+    public boolean useSelectionFG;
+    public Color selectionFG;
+    public Color selectionBG;
+    public boolean selectionRoundedEdges;
+    public Color currentLineHighlight;
+    public boolean fadeCurrentLineHighlight;
+    public Color tabLineColor;
+    public Color marginLineColor;
+    public Color markAllHighlightColor;
+    public Color markOccurrencesColor;
+    public boolean markOccurrencesBorder;
+    public Color matchedBracketFG;
+    public Color matchedBracketBG;
+    public boolean matchedBracketHighlightBoth;
+    public boolean matchedBracketAnimate;
+    public Color hyperlinkFG;
+    public Color gutterBackgroundColor;
+    public Color gutterBorderColor;
+    public Color activeLineRangeColor;
+    public boolean iconRowHeaderInheritsGutterBG;
+    public Color lineNumberColor;
+    public Color currentLineNumberColor;
+    public String lineNumberFont;
+    public int lineNumberFontSize;
+    public Color foldIndicatorFG;
+    public Color foldIndicatorArmedFG;
+    public Color foldBG;
+    public Color armedFoldBG;
+
+    /// The text color, and a color per token type; null follows the
+    /// palette.
+    private Color foreground;
+    private Color[] tokenColors;
+
+    private Theme(Font baseFont) {
+        this.baseFont = baseFont;
+    }
+
+    /// A theme of the colors a text area has now.
+    public Theme(RSyntaxTextArea textArea) {
+        baseFont = textArea.getFont();
+        bgColor = textArea.getBackground();
+        caretColor = textArea.getCaretColor();
+        useSelectionFG = textArea.getUseSelectedTextColor();
+        selectionFG = textArea.getSelectedTextColor();
+        selectionBG = textArea.getSelectionColor();
+        selectionRoundedEdges = textArea.getRoundedSelectionEdges();
+        currentLineHighlight = textArea.getCurrentLineHighlightColor();
+        fadeCurrentLineHighlight = textArea.getFadeCurrentLineHighlight();
+        tabLineColor = textArea.getTabLineColor();
+        marginLineColor = textArea.getMarginLineColor();
+        markAllHighlightColor = textArea.getMarkAllHighlightColor();
+        markOccurrencesColor = textArea.getMarkOccurrencesColor();
+        markOccurrencesBorder = textArea.getPaintMarkOccurrencesBorder();
+        matchedBracketBG = textArea.getMatchedBracketBGColor();
+        matchedBracketFG = textArea.getMatchedBracketBorderColor();
+        matchedBracketHighlightBoth = textArea.getPaintMatchedBracketPair();
+        matchedBracketAnimate = textArea.getAnimateBracketMatching();
+        hyperlinkFG = textArea.getHyperlinkForeground();
+        foreground = textArea.isForegroundSet() ? textArea.getForeground() : null;
+        Color[] colors = textArea.cn1TokenColors();
+        if (colors != null) {
+            tokenColors = new Color[colors.length];
+            System.arraycopy(colors, 0, tokenColors, 0, colors.length);
+        }
+        Gutter gutter = gutter(textArea);
+        if (gutter != null) {
+            gutterBackgroundColor = gutter.isBackgroundSet() ? gutter.getBackground() : null;
+            gutterBorderColor = gutter.getBorderColor();
+            activeLineRangeColor = gutter.getActiveLineRangeColor();
+            iconRowHeaderInheritsGutterBG = gutter.getIconRowHeaderInheritsGutterBackground();
+            lineNumberColor = gutter.getLineNumberColor();
+            currentLineNumberColor = gutter.getCurrentLineNumberColor();
+            lineNumberFont = gutter.getLineNumberFont().getFamily();
+            lineNumberFontSize = gutter.getLineNumberFont().getSize();
+            foldIndicatorFG = gutter.getFoldIndicatorForeground();
+            foldIndicatorArmedFG = gutter.getFoldIndicatorArmedForeground();
+            foldBG = gutter.getFoldBackground();
+            armedFoldBG = gutter.getArmedFoldBackground();
+        }
+    }
+
+    /// The gutter of the scroll pane a text area is in, or null.
+    private static Gutter gutter(RSyntaxTextArea textArea) {
+        Component c = textArea.getParent();
+        for (int depth = 0; c != null && depth < 3; depth++) {
+            if (c instanceof RTextScrollPane) {
+                return ((RTextScrollPane) c).getGutter();
+            }
+            c = c.getParent();
+        }
+        return null;
+    }
+
+    /// Gives a text area, and the gutter of its scroll pane, the colors
+    /// of this theme. A color the theme does not carry is left as it is.
+    public void apply(RSyntaxTextArea textArea) {
+        if (baseFont != null) {
+            textArea.setFont(baseFont);
+        }
+        if (bgColor != null) {
+            textArea.setBackground(bgColor);
+        }
+        if (foreground != null) {
+            textArea.setForeground(foreground);
+        }
+        if (caretColor != null) {
+            textArea.setCaretColor(caretColor);
+        }
+        textArea.setUseSelectedTextColor(useSelectionFG);
+        if (selectionFG != null) {
+            textArea.setSelectedTextColor(selectionFG);
+        }
+        if (selectionBG != null) {
+            textArea.setSelectionColor(selectionBG);
+        }
+        textArea.setRoundedSelectionEdges(selectionRoundedEdges);
+        if (currentLineHighlight != null) {
+            textArea.setCurrentLineHighlightColor(currentLineHighlight);
+        }
+        textArea.setFadeCurrentLineHighlight(fadeCurrentLineHighlight);
+        if (tabLineColor != null) {
+            textArea.setTabLineColor(tabLineColor);
+        }
+        if (marginLineColor != null) {
+            textArea.setMarginLineColor(marginLineColor);
+        }
+        if (markAllHighlightColor != null) {
+            textArea.setMarkAllHighlightColor(markAllHighlightColor);
+        }
+        if (markOccurrencesColor != null) {
+            textArea.setMarkOccurrencesColor(markOccurrencesColor);
+        }
+        textArea.setPaintMarkOccurrencesBorder(markOccurrencesBorder);
+        if (matchedBracketBG != null) {
+            textArea.setMatchedBracketBGColor(matchedBracketBG);
+        }
+        if (matchedBracketFG != null) {
+            textArea.setMatchedBracketBorderColor(matchedBracketFG);
+        }
+        textArea.setPaintMatchedBracketPair(matchedBracketHighlightBoth);
+        textArea.setAnimateBracketMatching(matchedBracketAnimate);
+        if (hyperlinkFG != null) {
+            textArea.setHyperlinkForeground(hyperlinkFG);
+        }
+        textArea.cn1TokenColors(tokenColors);
+        Gutter gutter = gutter(textArea);
+        if (gutter != null) {
+            if (gutterBackgroundColor != null) {
+                gutter.setBackground(gutterBackgroundColor);
+            }
+            if (gutterBorderColor != null) {
+                gutter.setBorderColor(gutterBorderColor);
+            }
+            if (activeLineRangeColor != null) {
+                gutter.setActiveLineRangeColor(activeLineRangeColor);
+            }
+            gutter.setIconRowHeaderInheritsGutterBackground(iconRowHeaderInheritsGutterBG);
+            if (lineNumberColor != null) {
+                gutter.setLineNumberColor(lineNumberColor);
+            }
+            if (currentLineNumberColor != null) {
+                gutter.setCurrentLineNumberColor(currentLineNumberColor);
+            }
+            if (lineNumberFontSize > 0 && baseFont != null) {
+                gutter.setLineNumberFont(baseFont.deriveFont((float) lineNumberFontSize));
+            }
+            gutter.setFoldIndicatorForeground(foldIndicatorFG);
+            gutter.setFoldIndicatorArmedForeground(foldIndicatorArmedFG);
+            gutter.setFoldBackground(foldBG);
+            gutter.setArmedFoldBackground(armedFoldBG);
+        }
+        textArea.repaint();
+    }
+
+    /// Reads a theme file.
+    ///
+    /// #### Throws
+    ///
+    /// - `IOException`: if the stream cannot be read
+    ///
+    /// - `NullPointerException`: if the stream is null, which is what a
+    ///   theme file that is not on the class path gives
+    public static Theme load(InputStream in) throws IOException {
+        return load(in, null);
+    }
+
+    /// Reads a theme file. The font is always monospaced; `baseFont`
+    /// gives its size unless the file names one.
+    public static Theme load(InputStream in, Font baseFont) throws IOException {
+        if (in == null) {
+            throw new NullPointerException("No theme to read");
+        }
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        byte[] buf = new byte[4096];
+        int n;
+        while ((n = in.read(buf)) > 0) {
+            bytes.write(buf, 0, n);
+        }
+        String xml = new String(bytes.toByteArray(), "UTF-8");
+        Font font = RTextAreaBase.getDefaultFont();
+        if (baseFont != null) {
+            font = font.deriveFont((float) baseFont.getSize());
+        }
+        Theme theme = new Theme(font);
+        int at = 0;
+        while ((at = xml.indexOf('<', at)) >= 0) {
+            int end = xml.indexOf('>', at);
+            if (end < 0) {
+                break;
+            }
+            char first = at + 1 < xml.length() ? xml.charAt(at + 1) : ' ';
+            if (first != '/' && first != '?' && first != '!') {
+                theme.element(xml.substring(at + 1, end));
+            }
+            at = end + 1;
+        }
+        return theme;
+    }
+
+    /// The value of an attribute of an element's text, or null.
+    private static String attr(String element, String name) {
+        int at = 0;
+        while ((at = element.indexOf(name + "=", at)) >= 0) {
+            boolean whole = at == 0 || element.charAt(at - 1) <= ' ';
+            int open = at + name.length() + 1;
+            if (whole && open < element.length()
+                    && (element.charAt(open) == '"' || element.charAt(open) == '\'')) {
+                int close = element.indexOf(element.charAt(open), open + 1);
+                return close < 0 ? null : element.substring(open + 1, close);
+            }
+            at = open;
+        }
+        return null;
+    }
+
+    private static int hex(String s) {
+        int v = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            int d = c >= '0' && c <= '9' ? c - '0'
+                    : c >= 'a' && c <= 'f' ? c - 'a' + 10
+                    : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
+            if (d < 0) {
+                return -1;
+            }
+            v = v << 4 | d;
+        }
+        return v;
+    }
+
+    /// A color as a theme file writes one: six hex digits, or eight with
+    /// the opacity first, with or without a leading dollar sign or hash.
+    /// Null for no value, for "default" and for anything else.
+    private static Color color(String s) {
+        if (s == null) {
+            return null;
+        }
+        if (s.length() > 0 && (s.charAt(0) == '$' || s.charAt(0) == '#')) {
+            s = s.substring(1);
+        }
+        if (s.length() != 6 && s.length() != 8) {
+            return null;
+        }
+        int rgb = hex(s.substring(s.length() - 6));
+        if (rgb < 0) {
+            return null;
+        }
+        if (s.length() == 8) {
+            int alpha = hex(s.substring(0, 2));
+            if (alpha < 0) {
+                return null;
+            }
+            return new Color(rgb >> 16 & 0xff, rgb >> 8 & 0xff, rgb & 0xff, alpha);
+        }
+        return new Color(rgb);
+    }
+
+    private static boolean flag(String s) {
+        return "true".equals(s);
+    }
+
+    private static int number(String s) {
+        if (s == null || s.length() == 0 || s.length() > 4) {
+            return -1;
+        }
+        int v = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c < '0' || c > '9') {
+                return -1;
+            }
+            v = v * 10 + (c - '0');
+        }
+        return v;
+    }
+
+    /// Takes what one element of a theme file says; `element` is the
+    /// text between its angle brackets.
+    private void element(String element) {
+        int nameEnd = 0;
+        while (nameEnd < element.length() && element.charAt(nameEnd) > ' ' && element.charAt(nameEnd) != '/') {
+            nameEnd++;
+        }
+        String name = element.substring(0, nameEnd);
+        if ("baseFont".equals(name)) {
+            int size = number(attr(element, "size"));
+            if (size > 0 && baseFont != null) {
+                baseFont = baseFont.deriveFont((float) size);
+            }
+        } else if ("background".equals(name)) {
+            bgColor = color(attr(element, "color"));
+        } else if ("caret".equals(name)) {
+            caretColor = color(attr(element, "color"));
+        } else if ("selection".equals(name)) {
+            useSelectionFG = flag(attr(element, "useFG"));
+            selectionFG = color(attr(element, "fg"));
+            selectionBG = color(attr(element, "bg"));
+            selectionRoundedEdges = flag(attr(element, "roundedEdges"));
+        } else if ("currentLineHighlight".equals(name)) {
+            currentLineHighlight = color(attr(element, "color"));
+            fadeCurrentLineHighlight = flag(attr(element, "fade"));
+        } else if ("tabLine".equals(name)) {
+            tabLineColor = color(attr(element, "color"));
+        } else if ("marginLine".equals(name)) {
+            marginLineColor = color(attr(element, "fg"));
+        } else if ("markAllHighlight".equals(name)) {
+            markAllHighlightColor = color(attr(element, "color"));
+        } else if ("markOccurrencesHighlight".equals(name)) {
+            markOccurrencesColor = color(attr(element, "color"));
+            markOccurrencesBorder = flag(attr(element, "border"));
+        } else if ("matchedBracket".equals(name)) {
+            matchedBracketFG = color(attr(element, "fg"));
+            matchedBracketBG = color(attr(element, "bg"));
+            matchedBracketHighlightBoth = flag(attr(element, "highlightBoth"));
+            matchedBracketAnimate = flag(attr(element, "animate"));
+        } else if ("hyperlinks".equals(name)) {
+            hyperlinkFG = color(attr(element, "fg"));
+        } else if ("gutterBackground".equals(name)) {
+            gutterBackgroundColor = color(attr(element, "color"));
+        } else if ("gutterBorder".equals(name)) {
+            gutterBorderColor = color(attr(element, "color"));
+        } else if ("lineNumbers".equals(name)) {
+            lineNumberColor = color(attr(element, "fg"));
+            currentLineNumberColor = color(attr(element, "currentFG"));
+            lineNumberFont = attr(element, "fontFamily");
+            lineNumberFontSize = Math.max(0, number(attr(element, "fontSize")));
+        } else if ("foldIndicator".equals(name)) {
+            foldIndicatorFG = color(attr(element, "fg"));
+            foldIndicatorArmedFG = color(attr(element, "armedFg"));
+            foldBG = color(attr(element, "iconBg"));
+            armedFoldBG = color(attr(element, "iconArmedBg"));
+        } else if ("iconRowHeader".equals(name)) {
+            activeLineRangeColor = color(attr(element, "activeLineRange"));
+            iconRowHeaderInheritsGutterBG = flag(attr(element, "inheritsGutterBG"));
+        } else if ("style".equals(name)) {
+            int type = TokenNames.of(attr(element, "token"));
+            Color fg = color(attr(element, "fg"));
+            if (type >= 0 && fg != null) {
+                if (tokenColors == null) {
+                    tokenColors = new Color[TokenTypes.DEFAULT_NUM_TOKEN_TYPES];
+                }
+                tokenColors[type] = fg;
+                if (type == TokenTypes.IDENTIFIER) {
+                    foreground = fg;
+                }
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/TokenNames.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/TokenNames.java
new file mode 100644
index 00000000000..76254f0b34b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/TokenNames.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+/// The name of each token type, in the order of [TokenTypes], as a
+/// [Theme] file spells them.
+final class TokenNames {
+
+    static final String[] NAMES = {
+        "NULL",
+        "COMMENT_EOL",
+        "COMMENT_MULTILINE",
+        "COMMENT_DOCUMENTATION",
+        "COMMENT_KEYWORD",
+        "COMMENT_MARKUP",
+        "RESERVED_WORD",
+        "RESERVED_WORD_2",
+        "FUNCTION",
+        "LITERAL_BOOLEAN",
+        "LITERAL_NUMBER_DECIMAL_INT",
+        "LITERAL_NUMBER_FLOAT",
+        "LITERAL_NUMBER_HEXADECIMAL",
+        "LITERAL_STRING_DOUBLE_QUOTE",
+        "LITERAL_CHAR",
+        "LITERAL_BACKQUOTE",
+        "DATA_TYPE",
+        "VARIABLE",
+        "REGEX",
+        "ANNOTATION",
+        "IDENTIFIER",
+        "WHITESPACE",
+        "SEPARATOR",
+        "OPERATOR",
+        "PREPROCESSOR",
+        "MARKUP_TAG_DELIMITER",
+        "MARKUP_TAG_NAME",
+        "MARKUP_TAG_ATTRIBUTE",
+        "MARKUP_TAG_ATTRIBUTE_VALUE",
+        "MARKUP_COMMENT",
+        "MARKUP_DTD",
+        "MARKUP_PROCESSING_INSTRUCTION",
+        "MARKUP_CDATA_DELIMITER",
+        "MARKUP_CDATA",
+        "MARKUP_ENTITY_REFERENCE",
+        "ERROR_IDENTIFIER",
+        "ERROR_NUMBER_FORMAT",
+        "ERROR_STRING_DOUBLE",
+        "ERROR_CHAR"
+    };
+
+    private TokenNames() {
+    }
+
+    /// The token type with this name, or -1.
+    static int of(String name) {
+        for (int i = 0; i < NAMES.length; i++) {
+            if (NAMES[i].equals(name)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/TokenTypes.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/TokenTypes.java
new file mode 100644
index 00000000000..ca2bffd279c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/TokenTypes.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+/// The kinds of token a [RSyntaxTextArea] tells apart, by number. A
+/// [Theme] names them when it gives each a color.
+public interface TokenTypes {
+
+    int NULL = 0;
+    int COMMENT_EOL = 1;
+    int COMMENT_MULTILINE = 2;
+    int COMMENT_DOCUMENTATION = 3;
+    int COMMENT_KEYWORD = 4;
+    int COMMENT_MARKUP = 5;
+    int RESERVED_WORD = 6;
+    int RESERVED_WORD_2 = 7;
+    int FUNCTION = 8;
+    int LITERAL_BOOLEAN = 9;
+    int LITERAL_NUMBER_DECIMAL_INT = 10;
+    int LITERAL_NUMBER_FLOAT = 11;
+    int LITERAL_NUMBER_HEXADECIMAL = 12;
+    int LITERAL_STRING_DOUBLE_QUOTE = 13;
+    int LITERAL_CHAR = 14;
+    int LITERAL_BACKQUOTE = 15;
+    int DATA_TYPE = 16;
+    int VARIABLE = 17;
+    int REGEX = 18;
+    int ANNOTATION = 19;
+    int IDENTIFIER = 20;
+    int WHITESPACE = 21;
+    int SEPARATOR = 22;
+    int OPERATOR = 23;
+    int PREPROCESSOR = 24;
+    int MARKUP_TAG_DELIMITER = 25;
+    int MARKUP_TAG_NAME = 26;
+    int MARKUP_TAG_ATTRIBUTE = 27;
+    int MARKUP_TAG_ATTRIBUTE_VALUE = 28;
+    int MARKUP_COMMENT = 29;
+    int MARKUP_DTD = 30;
+    int MARKUP_PROCESSING_INSTRUCTION = 31;
+    int MARKUP_CDATA_DELIMITER = 32;
+    int MARKUP_CDATA = 33;
+    int MARKUP_ENTITY_REFERENCE = 34;
+    int ERROR_IDENTIFIER = 35;
+    int ERROR_NUMBER_FORMAT = 36;
+    int ERROR_STRING_DOUBLE = 37;
+    int ERROR_CHAR = 38;
+    int DEFAULT_NUM_TOKEN_TYPES = 39;
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/package-info.java
new file mode 100644
index 00000000000..cc8b921f297
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/package-info.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// RSyntaxTextArea under its own names, in a reduced form: a code view
+/// with a monospaced font, colors for comments, strings, numbers and
+/// keywords, real line highlights and themes.
+///
+/// The classes are written for this layer and share only their names with
+/// the library. [RSyntaxTextArea] says what is and is not provided; code
+/// folding, parsers, auto completion, templates and regular expression
+/// search are not.
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/Gutter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/Gutter.java
new file mode 100644
index 00000000000..18633d168d5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/Gutter.java
@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+
+/// The strip left of the text of a [RTextScrollPane], which paints the
+/// line numbers.
+///
+/// Each number is painted in the row of its line, with the line height of
+/// the text area, and the strip scrolls with the text, so a number stays
+/// beside its line. The strip is as wide as the highest line number needs.
+///
+/// Line numbers are what it paints. The fold indicator, bookmarks and
+/// tracking icons are not provided: their switches and colors are
+/// recorded and take no room.
+public class Gutter extends JPanel {
+
+    public static final Color DEFAULT_ACTIVE_LINE_RANGE_COLOR = new Color(51, 153, 255);
+
+    /// Room left and right of the numbers, in logical pixels.
+    private static final int PAD = 6;
+
+    private RTextArea textArea;
+    private Document listened;
+    private boolean lineNumbersEnabled = true;
+    private boolean foldIndicatorEnabled;
+    private boolean iconRowHeaderEnabled;
+    private boolean bookmarkingEnabled;
+    private boolean iconRowHeaderInheritsGutterBackground;
+    private int lineNumberingStartIndex = 1;
+    private Color lineNumberColor;
+    private Color currentLineNumberColor;
+    private Color borderColor;
+    private Color activeLineRangeColor = DEFAULT_ACTIVE_LINE_RANGE_COLOR;
+    private Color foldBackground;
+    private Color armedFoldBackground;
+    private Color foldIndicatorForeground;
+    private Color foldIndicatorArmedForeground;
+    private Font lineNumberFont;
+    private int lines = -1;
+
+    private final DocumentListener changes = new DocumentListener() {
+        @Override
+        public void insertUpdate(DocumentEvent e) {
+            textChanged();
+        }
+
+        @Override
+        public void removeUpdate(DocumentEvent e) {
+            textChanged();
+        }
+
+        @Override
+        public void changedUpdate(DocumentEvent e) {
+            textChanged();
+        }
+    };
+
+    public Gutter(RTextArea textArea) {
+        setTextArea(textArea);
+    }
+
+    /// The text area whose lines are numbered.
+    public void setTextArea(RTextArea textArea) {
+        if (listened != null) {
+            listened.removeDocumentListener(changes);
+            listened = null;
+        }
+        this.textArea = textArea;
+        if (textArea != null) {
+            listened = textArea.getDocument();
+            if (listened != null) {
+                listened.addDocumentListener(changes);
+            }
+        }
+        lines = -1;
+        revalidate();
+        repaint();
+    }
+
+    private void textChanged() {
+        int now = textArea == null ? 0 : textArea.getLineCount();
+        if (now != lines) {
+            lines = now;
+            revalidate();
+        }
+        repaint();
+    }
+
+    private Font font() {
+        if (lineNumberFont != null) {
+            return lineNumberFont;
+        }
+        return textArea != null ? textArea.getFont() : RTextAreaBase.getDefaultFont();
+    }
+
+    private static int digits(int n) {
+        int d = 1;
+        while (n >= 10) {
+            n /= 10;
+            d++;
+        }
+        return d;
+    }
+
+    /// As wide as the highest line number, and as high as the text.
+    @Override
+    public Dimension getPreferredSize() {
+        if (textArea == null || !lineNumbersEnabled) {
+            return new Dimension(0, 0);
+        }
+        FontMetrics fm = getFontMetrics(font());
+        int highest = Math.max(1, textArea.getLineCount()) + lineNumberingStartIndex - 1;
+        int w = Math.max(2, digits(Math.max(1, highest))) * Math.max(1, fm.charWidth('0')) + 2 * PAD;
+        return new Dimension(w, Math.max(textArea.getPreferredSize().height, textArea.getHeight()));
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        int w = getWidth();
+        int h = getHeight();
+        Color bg = isBackgroundSet() ? getBackground()
+                : textArea != null ? textArea.getBackground() : UIManager.getColor("Panel.background");
+        if (bg != null) {
+            g.setColor(bg);
+            g.fillRect(0, 0, w, h);
+        }
+        Color line = borderColor != null ? borderColor : UIManager.getColor("Component.borderColor");
+        if (line != null) {
+            g.setColor(line);
+            g.fillRect(w - 1, 0, 1, h);
+        }
+        if (textArea == null || !lineNumbersEnabled) {
+            return;
+        }
+        Font f = font();
+        FontMetrics fm = getFontMetrics(f);
+        g.setFont(f);
+        int lineHeight = textArea.getLineHeight();
+        int count = Math.max(1, textArea.getLineCount());
+        int first = 0;
+        int last = count - 1;
+        Rectangle clip = g.getClipBounds();
+        if (clip != null) {
+            first = Math.max(0, clip.y / lineHeight);
+            last = Math.min(last, (clip.y + clip.height) / lineHeight);
+        }
+        Color normal = lineNumberColor != null ? lineNumberColor : UIManager.getColor("Label.disabledForeground");
+        Color current = currentLineNumberColor != null ? currentLineNumberColor : normal;
+        int caretLine = textArea.getCaretLineNumber();
+        int top = textArea.getInsets() == null ? 0 : textArea.getInsets().top;
+        for (int i = first; i <= last; i++) {
+            String number = String.valueOf(i + lineNumberingStartIndex);
+            g.setColor(i == caretLine ? current : normal);
+            g.drawString(number, w - PAD - fm.stringWidth(number), top + i * lineHeight + fm.getAscent());
+        }
+    }
+
+    public boolean getLineNumbersEnabled() {
+        return lineNumbersEnabled;
+    }
+
+    public void setLineNumbersEnabled(boolean enabled) {
+        if (lineNumbersEnabled != enabled) {
+            lineNumbersEnabled = enabled;
+            revalidate();
+            repaint();
+        }
+    }
+
+    public Color getLineNumberColor() {
+        return lineNumberColor != null ? lineNumberColor : UIManager.getColor("Label.disabledForeground");
+    }
+
+    public void setLineNumberColor(Color color) {
+        lineNumberColor = color;
+        repaint();
+    }
+
+    public Color getCurrentLineNumberColor() {
+        return currentLineNumberColor;
+    }
+
+    public void setCurrentLineNumberColor(Color color) {
+        currentLineNumberColor = color;
+        repaint();
+    }
+
+    public Font getLineNumberFont() {
+        return font();
+    }
+
+    public void setLineNumberFont(Font font) {
+        lineNumberFont = font;
+        revalidate();
+        repaint();
+    }
+
+    public int getLineNumberingStartIndex() {
+        return lineNumberingStartIndex;
+    }
+
+    public void setLineNumberingStartIndex(int index) {
+        lineNumberingStartIndex = index;
+        revalidate();
+        repaint();
+    }
+
+    public Color getBorderColor() {
+        return borderColor != null ? borderColor : UIManager.getColor("Component.borderColor");
+    }
+
+    public void setBorderColor(Color color) {
+        borderColor = color;
+        repaint();
+    }
+
+    public boolean isFoldIndicatorEnabled() {
+        return foldIndicatorEnabled;
+    }
+
+    /// Recorded only: there is no code folding.
+    public void setFoldIndicatorEnabled(boolean enabled) {
+        foldIndicatorEnabled = enabled;
+    }
+
+    public boolean isIconRowHeaderEnabled() {
+        return iconRowHeaderEnabled;
+    }
+
+    /// Recorded only: there are no gutter icons.
+    public void setIconRowHeaderEnabled(boolean enabled) {
+        iconRowHeaderEnabled = enabled;
+    }
+
+    public boolean isBookmarkingEnabled() {
+        return bookmarkingEnabled;
+    }
+
+    /// Recorded only: there are no bookmarks.
+    public void setBookmarkingEnabled(boolean enabled) {
+        bookmarkingEnabled = enabled;
+    }
+
+    public boolean getIconRowHeaderInheritsGutterBackground() {
+        return iconRowHeaderInheritsGutterBackground;
+    }
+
+    /// Recorded only.
+    public void setIconRowHeaderInheritsGutterBackground(boolean inherits) {
+        iconRowHeaderInheritsGutterBackground = inherits;
+    }
+
+    public Color getActiveLineRangeColor() {
+        return activeLineRangeColor;
+    }
+
+    /// Recorded only.
+    public void setActiveLineRangeColor(Color color) {
+        activeLineRangeColor = color;
+    }
+
+    public Color getFoldBackground() {
+        return foldBackground;
+    }
+
+    /// Recorded only.
+    public void setFoldBackground(Color color) {
+        foldBackground = color;
+    }
+
+    public Color getArmedFoldBackground() {
+        return armedFoldBackground;
+    }
+
+    /// Recorded only.
+    public void setArmedFoldBackground(Color color) {
+        armedFoldBackground = color;
+    }
+
+    public Color getFoldIndicatorForeground() {
+        return foldIndicatorForeground;
+    }
+
+    /// Recorded only.
+    public void setFoldIndicatorForeground(Color color) {
+        foldIndicatorForeground = color;
+    }
+
+    public Color getFoldIndicatorArmedForeground() {
+        return foldIndicatorArmedForeground;
+    }
+
+    /// Recorded only.
+    public void setFoldIndicatorArmedForeground(Color color) {
+        foldIndicatorArmedForeground = color;
+    }
+
+    /// Always false: there is no fold indicator to arm.
+    public boolean isArmed() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextArea.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextArea.java
new file mode 100644
index 00000000000..9fc373a84b4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextArea.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea.DocumentRange;
+import com.codename1.desktopcompat.rt.CellTheme;
+import java.util.ArrayList;
+import java.util.List;
+
+/// The text area of RSyntaxTextArea's `rtextarea` package: [RTextAreaBase]
+/// with line highlights and marked occurrences, both really painted.
+///
+/// A line highlight is a band the width of the component behind one line,
+/// which is how a diff or a blame view colors its lines. A marked
+/// occurrence is the background of a range of characters, which is what
+/// [SearchEngine#markAll] produces.
+///
+/// A line highlight stays with the line number it was given for; it does
+/// not follow its text when lines are inserted above it. Undo, redo,
+/// macros, the popup menu and the overwrite caret are not provided: the
+/// methods that exist for them are recorded or do nothing, as each says.
+public class RTextArea extends RTextAreaBase {
+
+    public static final int INSERT_MODE = 0;
+    public static final int OVERWRITE_MODE = 1;
+    public static final String MARK_ALL_COLOR_PROPERTY = "RTA.markAllColor";
+    public static final String MARK_ALL_ON_OCCURRENCE_SEARCHES_PROPERTY = "RTA.markAllOnOccurrenceSearches";
+    public static final String MARK_ALL_OCCURRENCES_CHANGED_PROPERTY = "RTA.markAllOccurrencesChanged";
+    public static final int COPY_ACTION = 0;
+    public static final int CUT_ACTION = 1;
+    public static final int DELETE_ACTION = 2;
+    public static final int PASTE_ACTION = 3;
+    public static final int REDO_ACTION = 4;
+    public static final int SELECT_ALL_ACTION = 5;
+    public static final int UNDO_ACTION = 6;
+
+    /// One highlighted line; the object [#addLineHighlight] hands back.
+    private static final class LineMark {
+        final int line;
+        final Color color;
+
+        LineMark(int line, Color color) {
+            this.line = line;
+            this.color = color;
+        }
+    }
+
+    private static String selectedOccurrenceText;
+
+    private final ArrayList<LineMark> lineMarks = new ArrayList<LineMark>();
+    private List<DocumentRange> marked = new ArrayList<DocumentRange>();
+    /// Null follows the palette.
+    private Color markAllHighlightColor;
+    private boolean markAllOnOccurrenceSearches = true;
+    private int textMode;
+
+    public RTextArea() {
+        super();
+    }
+
+    public RTextArea(String text) {
+        super(text);
+    }
+
+    public RTextArea(int rows, int cols) {
+        super(rows, cols);
+    }
+
+    public RTextArea(String text, int rows, int cols) {
+        super(text, rows, cols);
+    }
+
+    public RTextArea(int textMode) {
+        super();
+        setTextMode(textMode);
+    }
+
+    // ------------------------------------------------------------ line highlights
+
+    /// Paints a band of `color` behind a line.
+    ///
+    /// #### Parameters
+    ///
+    /// - `line`: the line, counted from zero
+    ///
+    /// #### Returns
+    ///
+    /// the object to hand to [#removeLineHighlight]
+    ///
+    /// #### Throws
+    ///
+    /// - `BadLocationException`: if there is no such line
+    public Object addLineHighlight(int line, Color color) throws BadLocationException {
+        if (line < 0 || line >= Math.max(1, getLineCount())) {
+            throw new BadLocationException("No such line", line);
+        }
+        LineMark mark = new LineMark(line, color);
+        lineMarks.add(mark);
+        repaint();
+        return mark;
+    }
+
+    public void removeLineHighlight(Object tag) {
+        if (lineMarks.remove(tag)) {
+            repaint();
+        }
+    }
+
+    public void removeAllLineHighlights() {
+        if (!lineMarks.isEmpty()) {
+            lineMarks.clear();
+            repaint();
+        }
+    }
+
+    @Override
+    protected void cn1PaintLineBackgrounds(Graphics g, int first, int last) {
+        int h = getLineHeight();
+        int w = getWidth();
+        for (int i = 0; i < lineMarks.size(); i++) {
+            LineMark mark = lineMarks.get(i);
+            if (mark.line < first || mark.line > last || mark.color == null) {
+                continue;
+            }
+            try {
+                g.setColor(mark.color);
+                g.fillRect(0, yForLine(mark.line), w, h);
+            } catch (BadLocationException e) {
+                continue;
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ marked occurrences
+
+    /// A tint of the accent color, which reads in a light and in a dark
+    /// palette.
+    public static Color getDefaultMarkAllHighlightColor() {
+        Color bg = UIManager.getColor("TextArea.background");
+        Color accent = UIManager.getColor("Component.accentColor");
+        if (bg == null || accent == null) {
+            return new Color(0xff, 0xc8, 0x00);
+        }
+        return CellTheme.mix(bg, accent, 0.45f);
+    }
+
+    public Color getMarkAllHighlightColor() {
+        return markAllHighlightColor != null ? markAllHighlightColor : getDefaultMarkAllHighlightColor();
+    }
+
+    public void setMarkAllHighlightColor(Color color) {
+        Color old = getMarkAllHighlightColor();
+        markAllHighlightColor = color;
+        firePropertyChange(MARK_ALL_COLOR_PROPERTY, old, color);
+        repaint();
+    }
+
+    public boolean getMarkAllOnOccurrenceSearches() {
+        return markAllOnOccurrenceSearches;
+    }
+
+    public void setMarkAllOnOccurrenceSearches(boolean markAll) {
+        boolean old = markAllOnOccurrenceSearches;
+        markAllOnOccurrenceSearches = markAll;
+        firePropertyChange(MARK_ALL_ON_OCCURRENCE_SEARCHES_PROPERTY, old, markAll);
+    }
+
+    /// Marks these ranges, in place of the ranges marked before.
+    public void markAll(List<DocumentRange> ranges) {
+        marked = new ArrayList<DocumentRange>();
+        if (ranges != null) {
+            marked.addAll(ranges);
+        }
+        firePropertyChange(MARK_ALL_OCCURRENCES_CHANGED_PROPERTY, null, null);
+        repaint();
+    }
+
+    public void clearMarkAllHighlights() {
+        if (!marked.isEmpty()) {
+            markAll(null);
+        }
+    }
+
+    /// The ranges that are marked, for the classes of this layer.
+    public List<DocumentRange> cn1Marked() {
+        return marked;
+    }
+
+    @Override
+    protected void cn1PaintMarks(Graphics g, String all, int first, int last) {
+        if (marked.isEmpty()) {
+            return;
+        }
+        g.setColor(getMarkAllHighlightColor());
+        for (int i = 0; i < marked.size(); i++) {
+            DocumentRange r = marked.get(i);
+            cn1FillRange(g, all, r.getStartOffset(), Math.min(all.length(), r.getEndOffset()), first, last);
+        }
+    }
+
+    public static String getSelectedOccurrenceText() {
+        return selectedOccurrenceText;
+    }
+
+    public static void setSelectedOccurrenceText(String text) {
+        selectedOccurrenceText = text;
+    }
+
+    // ------------------------------------------------------------ recorded or absent
+
+    public final int getTextMode() {
+        return textMode;
+    }
+
+    /// Recorded only: text is always inserted.
+    public void setTextMode(int mode) {
+        textMode = mode == OVERWRITE_MODE ? OVERWRITE_MODE : INSERT_MODE;
+    }
+
+    /// Always false: there is no undo history.
+    public boolean canUndo() {
+        return false;
+    }
+
+    /// Always false: there is no undo history.
+    public boolean canRedo() {
+        return false;
+    }
+
+    /// Does nothing: there is no undo history.
+    public void undoLastAction() {
+    }
+
+    /// Does nothing: there is no undo history.
+    public void redoLastAction() {
+    }
+
+    /// Does nothing: there is no undo history.
+    public void discardAllEdits() {
+    }
+
+    /// Does nothing: there is no undo history to group edits in.
+    public void beginAtomicEdit() {
+    }
+
+    /// Does nothing: there is no undo history to group edits in.
+    public void endAtomicEdit() {
+    }
+
+    public int getMaxAscent() {
+        return getFontMetrics(getFont()).getAscent();
+    }
+
+    @Override
+    public void setRoundedSelectionEdges(boolean rounded) {
+        super.setRoundedSelectionEdges(rounded);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextAreaBase.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextAreaBase.java
new file mode 100644
index 00000000000..1bc5a29b9b4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextAreaBase.java
@@ -0,0 +1,566 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+
+/// The base of the RSyntaxTextArea text components as this layer has
+/// them: a text area that paints its own text.
+///
+/// The real library is a complete text UI of its own, which cannot run on
+/// Codename One widgets. What is here instead is a [JTextArea] that draws
+/// its lines itself, in a monospaced font, one row per line of the
+/// document. That is what makes the rest exact: a line has a known place,
+/// so [#yForLine], `modelToView`, `viewToModel`, the line highlights of
+/// [RTextArea] and the line numbers of [RTextScrollPane] all agree with
+/// what is painted, and a tab is expanded to the next tab stop.
+///
+/// What differs from the desktop:
+///
+///  - Lines are never wrapped; `setLineWrap(true)` is recorded only.
+///  - The current line highlight follows the caret as the program moves
+///    it and as the user clicks. While the user is typing, the text is
+///    edited by the platform's own editor, which shows the text plainly
+///    until the edit ends.
+///  - Margin lines, background images and rounded or faded selections
+///    are recorded and not drawn.
+public abstract class RTextAreaBase extends JTextArea {
+
+    public static final String BACKGROUND_IMAGE_PROPERTY = "background.image";
+    public static final String CURRENT_LINE_HIGHLIGHT_COLOR_PROPERTY = "RTA.currentLineHighlightColor";
+    public static final String CURRENT_LINE_HIGHLIGHT_FADE_PROPERTY = "RTA.currentLineHighlightFade";
+    public static final String HIGHLIGHT_CURRENT_LINE_PROPERTY = "RTA.currentLineHighlight";
+    public static final String ROUNDED_SELECTION_PROPERTY = "RTA.roundedSelection";
+
+    /// Room left and right of the text, in logical pixels.
+    private static final int PAD = 3;
+
+    private boolean tabsEmulated;
+    private boolean highlightCurrentLine = true;
+    private boolean fadeCurrentLineHighlight;
+    private boolean roundedSelectionEdges;
+    private boolean marginLineEnabled;
+    private int marginLinePosition = getDefaultMarginLinePosition();
+    private Color marginLineColor = getDefaultMarginLineColor();
+    /// Null follows the palette.
+    private Color currentLineHighlightColor;
+    /// The widest line in columns, or -1 when the text changed.
+    private int widestColumns = -1;
+    private String measuredText;
+
+    public RTextAreaBase() {
+        this(null, 0, 0);
+    }
+
+    public RTextAreaBase(String text) {
+        this(text, 0, 0);
+    }
+
+    public RTextAreaBase(int rows, int cols) {
+        this(null, rows, cols);
+    }
+
+    public RTextAreaBase(String text, int rows, int cols) {
+        super(text, rows, cols);
+        setFont(getDefaultFont());
+        super.setTabSize(getDefaultTabSize());
+        addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                setCaretPosition(viewToModel(e.getPoint()));
+                repaint();
+            }
+        });
+    }
+
+    // ------------------------------------------------------------ defaults
+
+    public static Color getDefaultCaretColor() {
+        return UIManager.getColor("TextArea.foreground");
+    }
+
+    /// A tint of the text color over the background, which reads in a
+    /// light and in a dark palette.
+    public static Color getDefaultCurrentLineHighlightColor() {
+        Color bg = UIManager.getColor("TextArea.background");
+        Color fg = UIManager.getColor("TextArea.foreground");
+        if (bg == null || fg == null) {
+            return new Color(255, 255, 170);
+        }
+        return com.codename1.desktopcompat.rt.CellTheme.mix(bg, fg, 0.07f);
+    }
+
+    public static Font getDefaultFont() {
+        return new Font(Font.MONOSPACED, Font.PLAIN, 13);
+    }
+
+    public static Color getDefaultForeground() {
+        return UIManager.getColor("TextArea.foreground");
+    }
+
+    public static Color getDefaultMarginLineColor() {
+        return new Color(255, 224, 224);
+    }
+
+    public static int getDefaultMarginLinePosition() {
+        return 80;
+    }
+
+    public static int getDefaultTabSize() {
+        return 4;
+    }
+
+    /// Whether this is a Mac: a desktop build running on one.
+    public static boolean isOSX() {
+        return com.codename1.desktopcompat.com.formdev.flatlaf.util.SystemInfo.isMacOS;
+    }
+
+    // ------------------------------------------------------------ properties
+
+    public Color getCurrentLineHighlightColor() {
+        return currentLineHighlightColor != null ? currentLineHighlightColor
+                : getDefaultCurrentLineHighlightColor();
+    }
+
+    public void setCurrentLineHighlightColor(Color color) {
+        if (color == null) {
+            throw new NullPointerException();
+        }
+        Color old = getCurrentLineHighlightColor();
+        currentLineHighlightColor = color;
+        firePropertyChange(CURRENT_LINE_HIGHLIGHT_COLOR_PROPERTY, old, color);
+        repaint();
+    }
+
+    public boolean getHighlightCurrentLine() {
+        return highlightCurrentLine;
+    }
+
+    public void setHighlightCurrentLine(boolean highlight) {
+        boolean old = highlightCurrentLine;
+        highlightCurrentLine = highlight;
+        firePropertyChange(HIGHLIGHT_CURRENT_LINE_PROPERTY, old, highlight);
+        repaint();
+    }
+
+    public boolean getFadeCurrentLineHighlight() {
+        return fadeCurrentLineHighlight;
+    }
+
+    /// Recorded only.
+    public void setFadeCurrentLineHighlight(boolean fade) {
+        fadeCurrentLineHighlight = fade;
+    }
+
+    public boolean getRoundedSelectionEdges() {
+        return roundedSelectionEdges;
+    }
+
+    /// Recorded only.
+    public void setRoundedSelectionEdges(boolean rounded) {
+        roundedSelectionEdges = rounded;
+    }
+
+    public boolean isMarginLineEnabled() {
+        return marginLineEnabled;
+    }
+
+    /// Recorded only: no margin line is drawn.
+    public void setMarginLineEnabled(boolean enabled) {
+        marginLineEnabled = enabled;
+    }
+
+    public int getMarginLinePosition() {
+        return marginLinePosition;
+    }
+
+    public void setMarginLinePosition(int size) {
+        marginLinePosition = size;
+    }
+
+    public Color getMarginLineColor() {
+        return marginLineColor;
+    }
+
+    public void setMarginLineColor(Color color) {
+        marginLineColor = color;
+    }
+
+    public boolean getTabsEmulated() {
+        return tabsEmulated;
+    }
+
+    /// Recorded only: typing is the platform editor's.
+    public void setTabsEmulated(boolean areEmulated) {
+        tabsEmulated = areEmulated;
+    }
+
+    @Override
+    public void setTabSize(int size) {
+        super.setTabSize(size);
+        widestColumns = -1;
+        revalidate();
+        repaint();
+    }
+
+    @Override
+    public void setBackground(Color bg) {
+        super.setBackground(bg);
+        repaint();
+    }
+
+    // ------------------------------------------------------------ geometry
+
+    private FontMetrics metrics() {
+        return getFontMetrics(getFont());
+    }
+
+    /// The height of one line of text, in logical pixels.
+    public int getLineHeight() {
+        return Math.max(1, metrics().getHeight());
+    }
+
+    private int charWidth() {
+        return Math.max(1, metrics().charWidth('m'));
+    }
+
+    /// The text of a line with every tab replaced by the spaces that
+    /// reach the next tab stop.
+    protected String cn1Expand(String line) {
+        if (line.indexOf('\t') < 0) {
+            return line;
+        }
+        int tab = Math.max(1, getTabSize());
+        StringBuilder sb = new StringBuilder(line.length() + 16);
+        for (int i = 0; i < line.length(); i++) {
+            char c = line.charAt(i);
+            if (c == '\t') {
+                int n = tab - sb.length() % tab;
+                for (int k = 0; k < n; k++) {
+                    sb.append(' ');
+                }
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    /// The column on screen of character `index` of a line, tabs counted
+    /// as the spaces they are drawn as.
+    private int column(String line, int index) {
+        int tab = Math.max(1, getTabSize());
+        int col = 0;
+        int n = Math.min(index, line.length());
+        for (int i = 0; i < n; i++) {
+            col += line.charAt(i) == '\t' ? tab - col % tab : 1;
+        }
+        return col;
+    }
+
+    /// The text of line `line` without its line end, or the empty string.
+    protected String cn1LineText(String all, int line) {
+        try {
+            int start = getLineStartOffset(line);
+            int end = Math.min(all.length(), getLineEndOffset(line));
+            while (end > start && (all.charAt(end - 1) == '\n' || all.charAt(end - 1) == '\r')) {
+                end--;
+            }
+            return start >= end ? "" : all.substring(start, end);
+        } catch (BadLocationException e) {
+            return "";
+        }
+    }
+
+    /// The left edge of the text, in logical pixels.
+    protected int cn1TextX() {
+        Insets in = getInsets();
+        return (in == null ? 0 : in.left) + PAD;
+    }
+
+    private int top() {
+        Insets in = getInsets();
+        return in == null ? 0 : in.top;
+    }
+
+    /// The y coordinate of the top of a line.
+    ///
+    /// #### Throws
+    ///
+    /// - `BadLocationException`: if there is no such line
+    public int yForLine(int line) throws BadLocationException {
+        if (line < 0 || line >= Math.max(1, getLineCount())) {
+            throw new BadLocationException("No such line", line);
+        }
+        return top() + line * getLineHeight();
+    }
+
+    /// The y coordinate of the top of the line that holds `offs`.
+    public int yForLineContaining(int offs) throws BadLocationException {
+        return yForLine(getLineOfOffset(offs));
+    }
+
+    /// Where the character at `pos` is drawn: a rectangle one pixel wide
+    /// and one line high at its left edge.
+    public Rectangle modelToView(int pos) throws BadLocationException {
+        int line = getLineOfOffset(pos);
+        String text = cn1LineText(getText(), line);
+        int col = column(text, pos - getLineStartOffset(line));
+        String shown = cn1Expand(text);
+        int x = cn1TextX() + metrics().stringWidth(shown.substring(0, Math.min(col, shown.length())));
+        return new Rectangle(x, yForLine(line), 1, getLineHeight());
+    }
+
+    /// The offset of the character drawn at `pt`: the nearest one of the
+    /// line there, the end of the text below the last line.
+    public int viewToModel(Point pt) {
+        int lines = getLineCount();
+        if (lines <= 0) {
+            return 0;
+        }
+        int line = Math.max(0, Math.min(lines - 1, (pt.y - top()) / getLineHeight()));
+        try {
+            int start = getLineStartOffset(line);
+            String text = cn1LineText(getText(), line);
+            int want = Math.max(0, (pt.x - cn1TextX() + charWidth() / 2) / charWidth());
+            int tab = Math.max(1, getTabSize());
+            int col = 0;
+            int i = 0;
+            while (i < text.length()) {
+                int w = text.charAt(i) == '\t' ? tab - col % tab : 1;
+                if (col + w > want) {
+                    break;
+                }
+                col += w;
+                i++;
+            }
+            return start + i;
+        } catch (BadLocationException e) {
+            return 0;
+        }
+    }
+
+    public final int getCaretLineNumber() {
+        try {
+            return getLineOfOffset(Math.max(0, Math.min(getCaretPosition(), cn1Length())));
+        } catch (BadLocationException e) {
+            return 0;
+        }
+    }
+
+    public final int getCaretOffsetFromLineStart() {
+        return getCaretPosition() - getLineStartOffsetOfCurrentLine();
+    }
+
+    public final int getLineStartOffsetOfCurrentLine() {
+        try {
+            return getLineStartOffset(getCaretLineNumber());
+        } catch (BadLocationException e) {
+            return 0;
+        }
+    }
+
+    public final int getLineEndOffsetOfCurrentLine() {
+        try {
+            return getLineEndOffset(getCaretLineNumber());
+        } catch (BadLocationException e) {
+            return 0;
+        }
+    }
+
+    private int cn1Length() {
+        Document d = getDocument();
+        return d == null ? 0 : d.getLength();
+    }
+
+    /// As wide as the longest line and as high as all lines, and never
+    /// less than the rows and columns that were asked for.
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        String all = getText();
+        if (all == null) {
+            all = "";
+        }
+        if (widestColumns < 0 || !all.equals(measuredText)) {
+            int widest = 0;
+            int tab = Math.max(1, getTabSize());
+            int col = 0;
+            for (int i = 0; i < all.length(); i++) {
+                char c = all.charAt(i);
+                if (c == '\n') {
+                    widest = Math.max(widest, col);
+                    col = 0;
+                } else {
+                    col += c == '\t' ? tab - col % tab : 1;
+                }
+            }
+            widestColumns = Math.max(widest, col);
+            measuredText = all;
+        }
+        Insets in = getInsets();
+        int extraW = in == null ? 0 : in.left + in.right;
+        int extraH = in == null ? 0 : in.top + in.bottom;
+        int cols = Math.max(widestColumns + 1, getColumns());
+        int rows = Math.max(Math.max(1, getLineCount()), getRows());
+        return new Dimension(cols * charWidth() + 2 * PAD + extraW, rows * getLineHeight() + extraH);
+    }
+
+    // ------------------------------------------------------------ paint
+
+    /// Paints what lies behind the text of the lines `first` to `last`:
+    /// nothing here, the line highlights in [RTextArea].
+    protected void cn1PaintLineBackgrounds(Graphics g, int first, int last) {
+    }
+
+    /// Paints the text of one line with its left end at `x` and its
+    /// baseline at `baseline`. `shown` is the line with tabs expanded.
+    protected void cn1PaintLine(Graphics g, String shown, int line, int x, int baseline) {
+        g.setColor(isEnabled() ? getForeground() : getDisabledColor());
+        g.drawString(shown, x, baseline);
+    }
+
+    private Color getDisabledColor() {
+        Color c = UIManager.getColor("TextArea.inactiveForeground");
+        return c != null ? c : getForeground();
+    }
+
+    private void fillRange(Graphics g, String all, int from, int to, int first, int last) {
+        FontMetrics fm = metrics();
+        int h = getLineHeight();
+        for (int line = first; line <= last; line++) {
+            try {
+                int start = getLineStartOffset(line);
+                int end = getLineEndOffset(line);
+                if (to <= start || from >= end && !(from == end && line == last)) {
+                    continue;
+                }
+                String text = cn1LineText(all, line);
+                String shown = cn1Expand(text);
+                int a = Math.min(shown.length(), column(text, Math.max(from, start) - start));
+                int b = Math.min(shown.length(), column(text, Math.min(to, end) - start));
+                int x0 = cn1TextX() + fm.stringWidth(shown.substring(0, a));
+                int x1 = cn1TextX() + fm.stringWidth(shown.substring(0, b));
+                if (to > end - 1 && to > start + text.length()) {
+                    // The line end is selected too.
+                    x1 += charWidth() / 2;
+                }
+                if (x1 > x0) {
+                    g.fillRect(x0, yForLine(line), x1 - x0, h);
+                }
+            } catch (BadLocationException e) {
+                continue;
+            }
+        }
+    }
+
+    /// Fills the background of the characters from `from` to `to` within
+    /// the lines `first` to `last`, in the color of `g`.
+    protected void cn1FillRange(Graphics g, String all, int from, int to, int first, int last) {
+        if (to > from) {
+            fillRange(g, all, from, to, first, last);
+        }
+    }
+
+    /// Paints what lies between the line backgrounds and the text of the
+    /// lines `first` to `last`: nothing here, the marked occurrences in
+    /// [RTextArea].
+    protected void cn1PaintMarks(Graphics g, String all, int first, int last) {
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        int w = getWidth();
+        int h = getHeight();
+        Color bg = getBackground();
+        if (bg != null) {
+            g.setColor(bg);
+            g.fillRect(0, 0, w, h);
+        }
+        int lines = getLineCount();
+        int lineHeight = getLineHeight();
+        Rectangle clip = g.getClipBounds();
+        int first = 0;
+        int last = lines - 1;
+        if (clip != null) {
+            first = Math.max(0, (clip.y - top()) / lineHeight);
+            last = Math.min(last, (clip.y + clip.height - top()) / lineHeight);
+        }
+        if (lines <= 0 || last < first) {
+            return;
+        }
+        String all = getText();
+        if (all == null) {
+            all = "";
+        }
+        int caretLine = getCaretLineNumber();
+        if (highlightCurrentLine && caretLine >= first && caretLine <= last
+                && getSelectionStart() == getSelectionEnd()) {
+            g.setColor(getCurrentLineHighlightColor());
+            g.fillRect(0, top() + caretLine * lineHeight, w, lineHeight);
+        }
+        cn1PaintLineBackgrounds(g, first, last);
+        cn1PaintMarks(g, all, first, last);
+        int from = getSelectionStart();
+        int to = getSelectionEnd();
+        if (to > from) {
+            Color sel = getSelectionColor();
+            g.setColor(sel != null ? sel : UIManager.getColor("textHighlight"));
+            fillRange(g, all, from, to, first, last);
+        }
+        FontMetrics fm = metrics();
+        g.setFont(getFont());
+        int x = cn1TextX();
+        for (int line = first; line <= last; line++) {
+            String text = cn1LineText(all, line);
+            if (text.length() > 0) {
+                cn1PaintLine(g, cn1Expand(text), line, x, top() + line * lineHeight + fm.getAscent());
+            }
+        }
+        if (isFocusOwner() && isEditable() && from == to) {
+            try {
+                Rectangle r = modelToView(Math.max(0, Math.min(getCaretPosition(), cn1Length())));
+                Color caret = getCaretColor();
+                g.setColor(caret != null ? caret : getForeground());
+                g.fillRect(r.x, r.y, 1, r.height);
+            } catch (BadLocationException e) {
+                return;
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextScrollPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextScrollPane.java
new file mode 100644
index 00000000000..60e570ba910
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/RTextScrollPane.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+
+/// A scroll pane for a [RTextArea] with a [Gutter] of line numbers at its
+/// left, which scrolls with the text.
+public class RTextScrollPane extends JScrollPane {
+
+    private Gutter gutter;
+
+    public RTextScrollPane() {
+        this(null, true);
+    }
+
+    public RTextScrollPane(RTextArea textArea) {
+        this(textArea, true);
+    }
+
+    public RTextScrollPane(Component comp) {
+        this(comp, true);
+    }
+
+    public RTextScrollPane(RTextArea textArea, boolean lineNumbers) {
+        this(textArea, lineNumbers, null);
+    }
+
+    public RTextScrollPane(Component comp, boolean lineNumbers) {
+        this(comp, lineNumbers, null);
+    }
+
+    /// #### Parameters
+    ///
+    /// - `comp`: the text area, or a component that is not one, which
+    ///   then gets no line numbers
+    ///
+    /// - `lineNumbers`: whether line numbers are shown
+    ///
+    /// - `lineNumberColor`: their color, or null for the color of
+    ///   disabled text
+    public RTextScrollPane(Component comp, boolean lineNumbers, Color lineNumberColor) {
+        super();
+        gutter = new Gutter(comp instanceof RTextArea ? (RTextArea) comp : null);
+        gutter.setLineNumbersEnabled(lineNumbers);
+        if (lineNumberColor != null) {
+            gutter.setLineNumberColor(lineNumberColor);
+        }
+        if (comp != null) {
+            setViewportView(comp);
+        }
+        cn1Header();
+    }
+
+    private void cn1Header() {
+        boolean wanted = gutter.getLineNumbersEnabled();
+        boolean shown = getRowHeader() != null && getRowHeader().getView() != null;
+        if (wanted != shown) {
+            setRowHeaderView(wanted ? gutter : null);
+        }
+    }
+
+    public Gutter getGutter() {
+        return gutter;
+    }
+
+    public boolean getLineNumbersEnabled() {
+        return gutter.getLineNumbersEnabled();
+    }
+
+    public void setLineNumbersEnabled(boolean enabled) {
+        gutter.setLineNumbersEnabled(enabled);
+        cn1Header();
+        revalidate();
+        repaint();
+    }
+
+    /// The text area in the viewport, or null when the view is not one.
+    public RTextArea getTextArea() {
+        Component view = getViewport() == null ? null : getViewport().getView();
+        return view instanceof RTextArea ? (RTextArea) view : null;
+    }
+
+    public boolean isFoldIndicatorEnabled() {
+        return gutter.isFoldIndicatorEnabled();
+    }
+
+    /// Recorded only: there is no code folding.
+    public void setFoldIndicatorEnabled(boolean enabled) {
+        gutter.setFoldIndicatorEnabled(enabled);
+    }
+
+    public boolean isIconRowHeaderEnabled() {
+        return gutter.isIconRowHeaderEnabled();
+    }
+
+    /// Recorded only: there are no gutter icons.
+    public void setIconRowHeaderEnabled(boolean enabled) {
+        gutter.setIconRowHeaderEnabled(enabled);
+    }
+
+    @Override
+    public void setViewportView(Component view) {
+        super.setViewportView(view);
+        if (gutter != null) {
+            gutter.setTextArea(view instanceof RTextArea ? (RTextArea) view : null);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchContext.java
new file mode 100644
index 00000000000..71b42919874
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchContext.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+
+/// What a search looks for and how: the text, and whether case matters,
+/// whole words only, forward or backward, wrapping, and marking every
+/// occurrence. [SearchEngine] reads it.
+///
+/// A regular expression search is not available in this layer: with
+/// [#setRegularExpression] on, a search finds nothing and says so once in
+/// the log.
+public class SearchContext {
+
+    public static final String PROPERTY_SEARCH_FOR = "Search.searchFor";
+    public static final String PROPERTY_REPLACE_WITH = "Search.replaceWith";
+    public static final String PROPERTY_MATCH_CASE = "Search.MatchCase";
+    public static final String PROPERTY_MATCH_WHOLE_WORD = "Search.MatchWholeWord";
+    public static final String PROPERTY_SEARCH_FORWARD = "Search.Forward";
+    public static final String PROPERTY_SEARCH_WRAP = "Search.Wrap";
+    public static final String PROPERTY_SELECTION_ONLY = "Search.SelectionOnly";
+    public static final String PROPERTY_USE_REGEX = "Search.UseRegex";
+    public static final String PROPERTY_MARK_ALL = "Search.MarkAll";
+
+    private String searchFor;
+    private String replaceWith;
+    private boolean matchCase;
+    private boolean wholeWord;
+    private boolean forward = true;
+    private boolean wrap;
+    private boolean selectionOnly;
+    private boolean regex;
+    private boolean markAll = true;
+    private final PropertyChangeSupport support = new PropertyChangeSupport(this);
+
+    public SearchContext() {
+        this(null);
+    }
+
+    public SearchContext(String searchFor) {
+        this(searchFor, false);
+    }
+
+    public SearchContext(String searchFor, boolean matchCase) {
+        this.searchFor = searchFor;
+        this.matchCase = matchCase;
+    }
+
+    public void addPropertyChangeListener(PropertyChangeListener l) {
+        support.addPropertyChangeListener(l);
+    }
+
+    public void removePropertyChangeListener(PropertyChangeListener l) {
+        support.removePropertyChangeListener(l);
+    }
+
+    protected void firePropertyChange(String property, boolean oldValue, boolean newValue) {
+        support.firePropertyChange(property, oldValue, newValue);
+    }
+
+    protected void firePropertyChange(String property, String oldValue, String newValue) {
+        support.firePropertyChange(property, oldValue, newValue);
+    }
+
+    /// A copy with the same settings and no listeners.
+    @Override
+    public SearchContext clone() {
+        SearchContext copy = new SearchContext(searchFor, matchCase);
+        copy.replaceWith = replaceWith;
+        copy.wholeWord = wholeWord;
+        copy.forward = forward;
+        copy.wrap = wrap;
+        copy.selectionOnly = selectionOnly;
+        copy.regex = regex;
+        copy.markAll = markAll;
+        return copy;
+    }
+
+    public boolean getMarkAll() {
+        return markAll;
+    }
+
+    public boolean getMatchCase() {
+        return matchCase;
+    }
+
+    public String getReplaceWith() {
+        return replaceWith;
+    }
+
+    public String getSearchFor() {
+        return searchFor;
+    }
+
+    public boolean getSearchForward() {
+        return forward;
+    }
+
+    public boolean getSearchWrap() {
+        return wrap;
+    }
+
+    public boolean getSearchSelectionOnly() {
+        return selectionOnly;
+    }
+
+    public boolean getWholeWord() {
+        return wholeWord;
+    }
+
+    public boolean isRegularExpression() {
+        return regex;
+    }
+
+    public void setMarkAll(boolean markAll) {
+        boolean old = this.markAll;
+        this.markAll = markAll;
+        firePropertyChange(PROPERTY_MARK_ALL, old, markAll);
+    }
+
+    public void setMatchCase(boolean matchCase) {
+        boolean old = this.matchCase;
+        this.matchCase = matchCase;
+        firePropertyChange(PROPERTY_MATCH_CASE, old, matchCase);
+    }
+
+    /// Recorded, and then every search finds nothing: regular expressions
+    /// are not available.
+    public void setRegularExpression(boolean regex) {
+        boolean old = this.regex;
+        this.regex = regex;
+        firePropertyChange(PROPERTY_USE_REGEX, old, regex);
+    }
+
+    public void setReplaceWith(String replaceWith) {
+        String old = this.replaceWith;
+        this.replaceWith = replaceWith;
+        firePropertyChange(PROPERTY_REPLACE_WITH, old, replaceWith);
+    }
+
+    public void setSearchFor(String searchFor) {
+        String old = this.searchFor;
+        this.searchFor = searchFor;
+        firePropertyChange(PROPERTY_SEARCH_FOR, old, searchFor);
+    }
+
+    public void setSearchForward(boolean forward) {
+        boolean old = this.forward;
+        this.forward = forward;
+        firePropertyChange(PROPERTY_SEARCH_FORWARD, old, forward);
+    }
+
+    public void setSearchWrap(boolean wrap) {
+        boolean old = this.wrap;
+        this.wrap = wrap;
+        firePropertyChange(PROPERTY_SEARCH_WRAP, old, wrap);
+    }
+
+    /// Recorded only: a search always covers the whole text.
+    public void setSearchSelectionOnly(boolean selectionOnly) {
+        boolean old = this.selectionOnly;
+        this.selectionOnly = selectionOnly;
+        firePropertyChange(PROPERTY_SELECTION_ONLY, old, selectionOnly);
+    }
+
+    public void setWholeWord(boolean wholeWord) {
+        boolean old = this.wholeWord;
+        this.wholeWord = wholeWord;
+        firePropertyChange(PROPERTY_MATCH_WHOLE_WORD, old, wholeWord);
+    }
+
+    @Override
+    public String toString() {
+        return "[SearchContext: searchFor=" + searchFor + ", replaceWith=" + replaceWith
+                + ", matchCase=" + matchCase + ", wholeWord=" + wholeWord + ", regex=" + regex
+                + ", markAll=" + markAll + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchEngine.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchEngine.java
new file mode 100644
index 00000000000..23a2b966ac0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchEngine.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea.DocumentRange;
+import com.codename1.io.Log;
+import java.util.ArrayList;
+import java.util.List;
+
+/// Find, replace and mark in a text area, by a [SearchContext].
+///
+/// Plain text searches work as on the desktop: with or without case,
+/// whole words only, forward or backward from the caret, and wrapping
+/// around the end. A regular expression search finds nothing and says so
+/// once in the log.
+public final class SearchEngine {
+
+    private static boolean regexLogged;
+
+    private SearchEngine() {
+    }
+
+    /// Whether this search can run; a regular expression cannot.
+    private static boolean possible(SearchContext context) {
+        String what = context.getSearchFor();
+        if (what == null || what.length() == 0) {
+            return false;
+        }
+        if (context.isRegularExpression()) {
+            if (!regexLogged) {
+                regexLogged = true;
+                Log.p("Regular expression search is not available in the RSyntaxTextArea of this layer;"
+                        + " such a search finds nothing.");
+            }
+            return false;
+        }
+        return true;
+    }
+
+    private static boolean wordChar(char c) {
+        return c == '_' || c >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c > 127;
+    }
+
+    private static boolean isWord(String in, int at, int length) {
+        if (at > 0 && wordChar(in.charAt(at - 1))) {
+            return false;
+        }
+        int end = at + length;
+        return end >= in.length() || !wordChar(in.charAt(end));
+    }
+
+    /// The first match at or after `from` going forward, or the last one
+    /// that ends at or before `from` going backward; -1 for none.
+    private static int next(String what, String in, int from, boolean forward, boolean matchCase,
+            boolean wholeWord) {
+        int n = what.length();
+        if (forward) {
+            for (int i = Math.max(0, from); i + n <= in.length(); i++) {
+                if (in.regionMatches(!matchCase, i, what, 0, n) && (!wholeWord || isWord(in, i, n))) {
+                    return i;
+                }
+            }
+        } else {
+            for (int i = Math.min(from, in.length()) - n; i >= 0; i--) {
+                if (in.regionMatches(!matchCase, i, what, 0, n) && (!wholeWord || isWord(in, i, n))) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    /// The position of the next match of `searchFor` in `searchIn`: the
+    /// first one going forward, the last one going backward, -1 for none.
+    public static int getNextMatchPos(String searchFor, String searchIn, boolean forward,
+            boolean matchCase, boolean wholeWord) {
+        if (searchFor == null || searchIn == null || searchFor.length() == 0) {
+            return -1;
+        }
+        return next(searchFor, searchIn, forward ? 0 : searchIn.length(), forward, matchCase, wholeWord);
+    }
+
+    private static String text(JTextArea area) {
+        String s = area.getText();
+        return s == null ? "" : s;
+    }
+
+    private static int markAll(JTextArea area, SearchContext context, String in) {
+        if (!(area instanceof RTextArea)) {
+            return 0;
+        }
+        RTextArea rta = (RTextArea) area;
+        if (!context.getMarkAll() || !possible(context)) {
+            rta.clearMarkAllHighlights();
+            return 0;
+        }
+        String what = context.getSearchFor();
+        List<DocumentRange> ranges = new ArrayList<DocumentRange>();
+        int at = 0;
+        while ((at = next(what, in, at, true, context.getMatchCase(), context.getWholeWord())) >= 0) {
+            ranges.add(new DocumentRange(at, at + what.length()));
+            at += what.length();
+        }
+        rta.markAll(ranges);
+        return ranges.size();
+    }
+
+    /// Finds the next occurrence from the caret and selects it. With
+    /// [SearchContext#getMarkAll] on, and a [RTextArea], every occurrence
+    /// is marked as well.
+    public static SearchResult find(JTextArea textArea, SearchContext context) {
+        String in = text(textArea);
+        int marked = markAll(textArea, context, in);
+        if (!possible(context)) {
+            return new SearchResult(null, 0, marked);
+        }
+        String what = context.getSearchFor();
+        boolean forward = context.getSearchForward();
+        int from = forward ? Math.max(textArea.getSelectionEnd(), textArea.getCaretPosition())
+                : Math.min(textArea.getSelectionStart(), textArea.getCaretPosition());
+        if (textArea.getSelectionStart() == textArea.getSelectionEnd()) {
+            from = textArea.getCaretPosition();
+        }
+        int at = next(what, in, from, forward, context.getMatchCase(), context.getWholeWord());
+        boolean wrapped = false;
+        if (at < 0 && context.getSearchWrap()) {
+            at = next(what, in, forward ? 0 : in.length(), forward, context.getMatchCase(),
+                    context.getWholeWord());
+            wrapped = at >= 0;
+        }
+        if (at < 0) {
+            return new SearchResult(null, 0, marked);
+        }
+        textArea.setCaretPosition(at);
+        textArea.moveCaretPosition(at + what.length());
+        SearchResult result = new SearchResult(new DocumentRange(at, at + what.length()), 1, marked);
+        result.setWrapped(wrapped);
+        return result;
+    }
+
+    /// Marks every occurrence, or clears the marks when the context does
+    /// not ask for marking or names nothing to look for.
+    public static SearchResult markAll(RTextArea textArea, SearchContext context) {
+        return new SearchResult(null, 0, markAll(textArea, context, text(textArea)));
+    }
+
+    /// Replaces the occurrence at the selection, when the selection is
+    /// one, and selects the next occurrence.
+    public static SearchResult replace(RTextArea textArea, SearchContext context) {
+        if (!possible(context)) {
+            return new SearchResult(null, 0, markAll(textArea, context, text(textArea)));
+        }
+        String what = context.getSearchFor();
+        String with = context.getReplaceWith() == null ? "" : context.getReplaceWith();
+        String in = text(textArea);
+        int start = textArea.getSelectionStart();
+        int end = textArea.getSelectionEnd();
+        boolean forward = context.getSearchForward();
+        int at = -1;
+        if (end - start == what.length() && start >= 0 && end <= in.length()
+                && in.regionMatches(!context.getMatchCase(), start, what, 0, what.length())
+                && (!context.getWholeWord() || isWord(in, start, what.length()))) {
+            at = start;
+        } else {
+            at = next(what, in, forward ? start : end, forward, context.getMatchCase(), context.getWholeWord());
+            if (at < 0 && context.getSearchWrap()) {
+                at = next(what, in, forward ? 0 : in.length(), forward, context.getMatchCase(),
+                        context.getWholeWord());
+            }
+        }
+        if (at < 0) {
+            return new SearchResult(null, 0, markAll(textArea, context, in));
+        }
+        textArea.replaceRange(with, at, at + what.length());
+        textArea.setCaretPosition(forward ? at + with.length() : at);
+        SearchResult following = find(textArea, context);
+        DocumentRange range = following.getMatchRange() != null ? following.getMatchRange()
+                : new DocumentRange(at, at + with.length());
+        SearchResult result = new SearchResult(range, 1, following.getMarkedCount());
+        result.setWrapped(following.isWrapped());
+        return result;
+    }
+
+    /// Replaces every occurrence in the text.
+    public static SearchResult replaceAll(RTextArea textArea, SearchContext context) {
+        if (!possible(context)) {
+            return new SearchResult(null, 0, markAll(textArea, context, text(textArea)));
+        }
+        String what = context.getSearchFor();
+        String with = context.getReplaceWith() == null ? "" : context.getReplaceWith();
+        String in = text(textArea);
+        StringBuilder out = new StringBuilder(in.length());
+        int count = 0;
+        int from = 0;
+        int last = -1;
+        int at;
+        while ((at = next(what, in, from, true, context.getMatchCase(), context.getWholeWord())) >= 0) {
+            out.append(in.substring(from, at)).append(with);
+            last = out.length() - with.length();
+            from = at + what.length();
+            count++;
+        }
+        if (count == 0) {
+            return new SearchResult(null, 0, markAll(textArea, context, in));
+        }
+        out.append(in.substring(from));
+        textArea.setText(out.toString());
+        textArea.setCaretPosition(Math.min(out.length(), last + with.length()));
+        textArea.clearMarkAllHighlights();
+        return new SearchResult(new DocumentRange(last, last + with.length()), count, 0);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchResult.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchResult.java
new file mode 100644
index 00000000000..d28ceefbd7c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/SearchResult.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
+
+import com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea.DocumentRange;
+
+/// What a [SearchEngine] operation did: the range it selected, how many
+/// occurrences it found or replaced, and how many it marked.
+public class SearchResult implements Comparable<SearchResult> {
+
+    private DocumentRange matchRange;
+    private int count;
+    private int markedCount;
+    private boolean wrapped;
+
+    public SearchResult() {
+        this(null, 0, 0);
+    }
+
+    public SearchResult(DocumentRange range, int count, int markedCount) {
+        this.matchRange = range;
+        this.count = count;
+        this.markedCount = markedCount;
+    }
+
+    @Override
+    public int compareTo(SearchResult other) {
+        if (other == null) {
+            return 1;
+        }
+        if (other == this) {
+            return 0;
+        }
+        int diff = count - other.count;
+        if (diff != 0) {
+            return diff;
+        }
+        diff = markedCount - other.markedCount;
+        if (diff != 0) {
+            return diff;
+        }
+        if (matchRange == null) {
+            return other.matchRange == null ? 0 : -1;
+        }
+        return matchRange.compareTo(other.matchRange);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other == this) {
+            return true;
+        }
+        if (other instanceof SearchResult) {
+            return compareTo((SearchResult) other) == 0;
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = count + markedCount;
+        if (matchRange != null) {
+            hash += matchRange.hashCode();
+        }
+        return hash;
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    public int getMarkedCount() {
+        return markedCount;
+    }
+
+    public DocumentRange getMatchRange() {
+        return matchRange;
+    }
+
+    public void setCount(int count) {
+        this.count = count;
+    }
+
+    public void setMarkedCount(int markedCount) {
+        this.markedCount = markedCount;
+    }
+
+    public void setMatchRange(DocumentRange range) {
+        this.matchRange = range;
+    }
+
+    public void setWrapped(boolean wrapped) {
+        this.wrapped = wrapped;
+    }
+
+    /// Whether the search reached the end of the text and went on from
+    /// the other end.
+    public boolean isWrapped() {
+        return wrapped;
+    }
+
+    @Override
+    public String toString() {
+        return "[SearchResult: count=" + count + ", markedCount=" + markedCount
+                + ", matchRange=" + matchRange + "]";
+    }
+
+    /// Whether anything was found or replaced.
+    public boolean wasFound() {
+        return count > 0;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/package-info.java
new file mode 100644
index 00000000000..0bfaf0d4e27
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/fife/ui/rtextarea/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The text area, scroll pane, gutter and search classes of
+/// RSyntaxTextArea's `rtextarea` package, in a reduced form.
+///
+/// [RTextAreaBase] paints its own text, one row per line, which is what
+/// makes line highlights, line numbers and `modelToView` exact.
+/// [SearchEngine] finds, replaces and marks plain text.
+package com.codename1.desktopcompat.org.fife.ui.rtextarea;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/beans/AbstractBean.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/beans/AbstractBean.java
new file mode 100644
index 00000000000..3f1ccb09cc8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/beans/AbstractBean.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.beans;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeSupport;
+import com.codename1.desktopcompat.java.beans.PropertyVetoException;
+import com.codename1.desktopcompat.java.beans.VetoableChangeListener;
+import java.util.ArrayList;
+
+/// A base class that carries the property change and vetoable change
+/// listener lists of a bean.
+///
+/// `clone()` is absent: a device cannot copy an object it knows nothing
+/// about. Vetoable listeners registered for one property name are told of
+/// changes to that property only, as in the JDK.
+public abstract class AbstractBean {
+
+    private final PropertyChangeSupport pcs;
+    private final ArrayList<Object[]> vetoers = new ArrayList<Object[]>();
+
+    protected AbstractBean() {
+        pcs = new PropertyChangeSupport(this);
+    }
+
+    public final void addPropertyChangeListener(PropertyChangeListener listener) {
+        pcs.addPropertyChangeListener(listener);
+    }
+
+    public final void removePropertyChangeListener(PropertyChangeListener listener) {
+        pcs.removePropertyChangeListener(listener);
+    }
+
+    public final PropertyChangeListener[] getPropertyChangeListeners() {
+        return pcs.getPropertyChangeListeners();
+    }
+
+    public final void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        pcs.addPropertyChangeListener(propertyName, listener);
+    }
+
+    public final void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
+        pcs.removePropertyChangeListener(propertyName, listener);
+    }
+
+    public final PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
+        return pcs.getPropertyChangeListeners(propertyName);
+    }
+
+    protected final void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        pcs.firePropertyChange(propertyName, oldValue, newValue);
+    }
+
+    protected final void firePropertyChange(PropertyChangeEvent evt) {
+        pcs.firePropertyChange(evt);
+    }
+
+    protected final void fireIndexedPropertyChange(String propertyName, int index, Object oldValue,
+            Object newValue) {
+        pcs.fireIndexedPropertyChange(propertyName, index, oldValue, newValue);
+    }
+
+    protected final boolean hasPropertyChangeListeners(String propertyName) {
+        return pcs.hasListeners(propertyName);
+    }
+
+    protected final boolean hasVetoableChangeListeners(String propertyName) {
+        for (int i = 0; i < vetoers.size(); i++) {
+            Object name = vetoers.get(i)[0];
+            if (name == null || name.equals(propertyName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final void addVetoableChangeListener(VetoableChangeListener listener) {
+        addVetoableChangeListener(null, listener);
+    }
+
+    public final void removeVetoableChangeListener(VetoableChangeListener listener) {
+        removeVetoableChangeListener(null, listener);
+    }
+
+    public final VetoableChangeListener[] getVetoableChangeListeners() {
+        VetoableChangeListener[] out = new VetoableChangeListener[vetoers.size()];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = (VetoableChangeListener) vetoers.get(i)[1];
+        }
+        return out;
+    }
+
+    public final void addVetoableChangeListener(String propertyName, VetoableChangeListener listener) {
+        if (listener != null) {
+            vetoers.add(new Object[]{propertyName, listener});
+        }
+    }
+
+    public final void removeVetoableChangeListener(String propertyName, VetoableChangeListener listener) {
+        for (int i = 0; i < vetoers.size(); i++) {
+            Object[] v = vetoers.get(i);
+            boolean sameName = propertyName == null ? v[0] == null : propertyName.equals(v[0]);
+            if (sameName && v[1] == listener) {
+                vetoers.remove(i);
+                return;
+            }
+        }
+    }
+
+    public final VetoableChangeListener[] getVetoableChangeListeners(String propertyName) {
+        ArrayList<VetoableChangeListener> out = new ArrayList<VetoableChangeListener>();
+        for (int i = 0; i < vetoers.size(); i++) {
+            Object[] v = vetoers.get(i);
+            if (propertyName != null && propertyName.equals(v[0])) {
+                out.add((VetoableChangeListener) v[1]);
+            }
+        }
+        return out.toArray(new VetoableChangeListener[out.size()]);
+    }
+
+    protected final void fireVetoableChange(String propertyName, Object oldValue, Object newValue)
+            throws PropertyVetoException {
+        fireVetoableChange(new PropertyChangeEvent(this, propertyName, oldValue, newValue));
+    }
+
+    /// Tells every vetoable listener of the property. When one vetoes, the
+    /// listeners already told are told of the change back, and the veto is
+    /// thrown on.
+    protected final void fireVetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {
+        Object oldValue = evt.getOldValue();
+        Object newValue = evt.getNewValue();
+        if (oldValue != null && oldValue.equals(newValue)) {
+            return;
+        }
+        Object[][] all = vetoers.toArray(new Object[vetoers.size()][]);
+        String name = evt.getPropertyName();
+        int told = 0;
+        try {
+            for (; told < all.length; told++) {
+                if (all[told][0] == null || all[told][0].equals(name)) {
+                    ((VetoableChangeListener) all[told][1]).vetoableChange(evt);
+                }
+            }
+        } catch (PropertyVetoException veto) {
+            PropertyChangeEvent back = new PropertyChangeEvent(this, name, newValue, oldValue);
+            for (int i = 0; i < told; i++) {
+                if (all[i][0] == null || all[i][0].equals(name)) {
+                    try {
+                        ((VetoableChangeListener) all[i][1]).vetoableChange(back);
+                    } catch (PropertyVetoException ignored) {
+                        // A veto of the roll back changes nothing.
+                        continue;
+                    }
+                }
+            }
+            throw veto;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/beans/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/beans/package-info.java
new file mode 100644
index 00000000000..5d8969cde2a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/beans/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The bean base class SwingX models and painters extend.
+package com.codename1.desktopcompat.org.jdesktop.beans;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/HorizontalLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/HorizontalLayout.java
new file mode 100644
index 00000000000..54c8d8df7d3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/HorizontalLayout.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+
+/// Places the visible children side by side from the left, each as high
+/// as the container and as wide as it prefers, with a gap between them.
+public class HorizontalLayout implements LayoutManager {
+
+    private int gap;
+
+    public HorizontalLayout() {
+        this(0);
+    }
+
+    public HorizontalLayout(int gap) {
+        this.gap = gap;
+    }
+
+    public int getGap() {
+        return gap;
+    }
+
+    public void setGap(int gap) {
+        this.gap = gap;
+    }
+
+    @Override
+    public void layoutContainer(Container parent) {
+        Insets in = parent.getInsets();
+        int height = Math.max(0, parent.getHeight() - in.top - in.bottom);
+        int x = in.left;
+        int n = parent.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            int w = c.getPreferredSize().width;
+            c.setBounds(x, in.top, w, height);
+            x += w + gap;
+        }
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        Insets in = parent.getInsets();
+        int width = 0;
+        int height = 0;
+        int shown = 0;
+        int n = parent.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            Dimension d = c.getPreferredSize();
+            height = Math.max(height, d.height);
+            width += d.width;
+            shown++;
+        }
+        if (shown > 1) {
+            width += gap * (shown - 1);
+        }
+        return new Dimension(width + in.left + in.right, height + in.top + in.bottom);
+    }
+
+    /// The preferred size: a row does not shrink its columns.
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        return preferredLayoutSize(parent);
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXBusyLabel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXBusyLabel.java
new file mode 100644
index 00000000000..5c18f348495
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXBusyLabel.java
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.Timer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.BusyPainter;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.MiniHtml;
+import com.codename1.desktopcompat.rt.Units;
+
+/// A label with a "busy" wheel where its icon would be, turning while the
+/// label is busy.
+///
+/// The wheel is drawn by a [BusyPainter] over the place of an empty icon
+/// of the wheel's size, so the label's text sits beside it as beside any
+/// icon. While the label is busy and shown, a Swing timer advances the
+/// painter one point per tick and repaints; an idle label shows the wheel
+/// at rest, every point in the base color.
+///
+/// ## What differs from SwingX
+///
+///  - Calling `setIcon` with an icon of the application's replaces the
+///    wheel for good.
+///  - The wheel is placed for an icon beside the text; with the text set
+///    to be above or below the icon it is drawn where a leading icon
+///    would be.
+public class JXBusyLabel extends JLabel {
+
+    private BusyPainter busyPainter;
+    private Timer busy;
+    private int delay = 100;
+    private boolean busyState;
+    private final Dimension size;
+    private Icon space;
+    private int frame = -1;
+    private BusyPainter.Direction direction;
+
+    /// A wheel of 26 by 26 pixels.
+    public JXBusyLabel() {
+        this(null);
+    }
+
+    /// A wheel of the given size; `null` is 26 by 26.
+    public JXBusyLabel(Dimension dim) {
+        super();
+        size = dim == null ? new Dimension(26, 26) : new Dimension(dim.width, dim.height);
+        space = new Space(size.width, size.height);
+        setIcon(space);
+    }
+
+    /// An icon that reserves the wheel's place and draws nothing.
+    private static final class Space implements Icon {
+        private final int width;
+        private final int height;
+
+        Space(int width, int height) {
+            this.width = width;
+            this.height = height;
+        }
+
+        @Override
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+        }
+
+        @Override
+        public int getIconWidth() {
+            return width;
+        }
+
+        @Override
+        public int getIconHeight() {
+            return height;
+        }
+    }
+
+    /// Sets the way the wheel turns.
+    public void setDirection(BusyPainter.Direction dir) {
+        direction = dir;
+        getBusyPainter().setDirection(dir);
+        repaint();
+    }
+
+    /// Makes the painter for a wheel of the given size, unless there is
+    /// one already.
+    protected void initPainter(Dimension dim) {
+        if (busyPainter == null) {
+            busyPainter = createBusyPainter(dim);
+            adopt(busyPainter, direction);
+        }
+    }
+
+    /// Brings a painter to the frame the label is at.
+    private void adopt(BusyPainter p, BusyPainter.Direction dir) {
+        if (p != null) {
+            p.setFrame(frame);
+            if (dir != null) {
+                p.setDirection(dir);
+            }
+        }
+    }
+
+    /// The painter a new label draws its wheel with: the default wheel,
+    /// scaled to the height of `dim`.
+    protected BusyPainter createBusyPainter(Dimension dim) {
+        BusyPainter p = dim == null ? new BusyPainter() : new BusyPainter(Math.max(1, dim.height));
+        p.setPaintCentered(true);
+        return p;
+    }
+
+    public boolean isBusy() {
+        return busyState;
+    }
+
+    /// Starts or stops the wheel. A busy label that is not in a shown
+    /// window starts turning when it gets into one.
+    public void setBusy(boolean busy) {
+        boolean old = busyState;
+        busyState = busy;
+        if (old != busy) {
+            if (busy) {
+                startAnimation();
+            } else {
+                stopAnimation();
+            }
+            firePropertyChange("busy", old, busy);
+            repaint();
+        }
+    }
+
+    private void startAnimation() {
+        if (busy != null || !isDisplayable()) {
+            return;
+        }
+        busy = new Timer(delay, new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                cn1Tick();
+            }
+        });
+        busy.start();
+    }
+
+    private void stopAnimation() {
+        if (busy != null) {
+            busy.stop();
+            busy = null;
+        }
+        frame = -1;
+        if (busyPainter != null) {
+            busyPainter.setFrame(-1);
+        }
+    }
+
+    /// One step of the animation, as the timer takes it: the highlight
+    /// moves on by one point. Does nothing while the label is not busy.
+    public void cn1Tick() {
+        if (!busyState) {
+            return;
+        }
+        BusyPainter p = getBusyPainter();
+        if (p == null) {
+            return;
+        }
+        int points = p.getPoints();
+        frame = points > 0 ? (frame + 1) % points : 0;
+        p.setFrame(frame);
+        frameChanged();
+    }
+
+    /// Whether the timer that turns the wheel is running.
+    public boolean cn1Animating() {
+        return busy != null && busy.isRunning();
+    }
+
+    @Override
+    public void removeNotify() {
+        if (busy != null) {
+            busy.stop();
+            busy = null;
+        }
+        super.removeNotify();
+    }
+
+    @Override
+    public void addNotify() {
+        super.addNotify();
+        if (busyState) {
+            startAnimation();
+        }
+    }
+
+    /// Called after every step of the animation; repaints the label.
+    protected void frameChanged() {
+        repaint();
+    }
+
+    /// The painter of the wheel.
+    public final BusyPainter getBusyPainter() {
+        if (busyPainter == null) {
+            initPainter(size);
+        }
+        return busyPainter;
+    }
+
+    public final void setBusyPainter(BusyPainter busyPainter) {
+        BusyPainter old = this.busyPainter;
+        this.busyPainter = busyPainter;
+        adopt(busyPainter, null);
+        firePropertyChange("busyPainter", old, busyPainter);
+        repaint();
+    }
+
+    public int getDelay() {
+        return delay;
+    }
+
+    /// Sets the time between two steps, in milliseconds.
+    public void setDelay(int delay) {
+        int old = this.delay;
+        this.delay = delay;
+        if (old != delay) {
+            if (busy != null) {
+                busy.setDelay(delay);
+                busy.setInitialDelay(delay);
+            }
+            firePropertyChange("delay", old, delay);
+        }
+    }
+
+    /// Where the wheel is drawn: the place of the empty icon.
+    Rectangle cn1WheelBounds() {
+        Insets b = getInsets();
+        int left = b.left;
+        int right = b.right;
+        int top = b.top;
+        int bottom = b.bottom;
+        if (com.codename1.ui.Display.isInitialized()) {
+            com.codename1.ui.plaf.Style st = cn1Peer().getStyle();
+            top += Units.toLogicalCeil(st.getPaddingTop());
+            bottom += Units.toLogicalCeil(st.getPaddingBottom());
+            left += Units.toLogicalCeil(st.getPaddingLeftNoRTL());
+            right += Units.toLogicalCeil(st.getPaddingRightNoRTL());
+        }
+        String text = getText();
+        Font f = getFont();
+        FontMetrics fm = Fonts.metrics(f);
+        boolean hasText = text != null && text.length() > 0 && !MiniHtml.isHtml(text);
+        int tw = hasText ? fm.stringWidth(text) : 0;
+        int gap = hasText ? getIconTextGap() : 0;
+        int cw = size.width + gap + tw;
+        int ch = Math.max(size.height, hasText ? fm.getHeight() : 0);
+        int availW = getWidth() - left - right;
+        int availH = getHeight() - top - bottom;
+        int x = left;
+        int ha = getHorizontalAlignment();
+        if (ha == CENTER) {
+            x += (availW - cw) / 2;
+        } else if (ha == RIGHT || ha == TRAILING) {
+            x += availW - cw;
+        }
+        int y = top;
+        int va = getVerticalAlignment();
+        if (va == CENTER) {
+            y += (availH - ch) / 2;
+        } else if (va == BOTTOM) {
+            y += availH - ch;
+        }
+        int ht = getHorizontalTextPosition();
+        if (ht == LEFT || ht == LEADING) {
+            x += tw + gap;
+        }
+        return new Rectangle(x, y + (ch - size.height) / 2, size.width, size.height);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        BusyPainter p = getBusyPainter();
+        if (p == null || getIcon() != space) {
+            return;
+        }
+        Rectangle r = cn1WheelBounds();
+        Graphics copy = g.create();
+        try {
+            if (copy instanceof Graphics2D) {
+                Graphics2D g2 = (Graphics2D) copy;
+                g2.translate(r.x, r.y);
+                p.paint(g2, this, r.width, r.height);
+            }
+        } finally {
+            copy.dispose();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXButton.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXButton.java
new file mode 100644
index 00000000000..516fce0b395
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXButton.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.G2D;
+import com.codename1.desktopcompat.rt.Peer;
+
+/// A button whose background and content can be drawn by painters.
+///
+/// Without painters it is the Codename One button of [JButton]. Otherwise
+/// it is drawn in two layers:
+///
+///  - the background: the background painter, or without one the
+///    button's own background and border from the theme;
+///  - the content: the foreground painter, or without one the button's
+///    icon and text, centered, in the button's font and text color.
+///
+/// The button keeps the size of the Codename One button, and it is still
+/// that button that takes the clicks.
+///
+/// ## What differs from SwingX
+///
+///  - The content drawn over a background painter is always centered,
+///    with the icon before the text; the alignment and text position
+///    properties apply to the unpainted button only.
+///  - A painter that changes is not observed: call `repaint()`.
+public class JXButton extends JButton {
+
+    private Painter backgroundPainter;
+    private Painter foregroundPainter;
+    private boolean paintBorderInsets = true;
+
+    public JXButton() {
+        super();
+    }
+
+    public JXButton(String text) {
+        super(text);
+    }
+
+    public JXButton(Action a) {
+        super(a);
+    }
+
+    public JXButton(Icon icon) {
+        super(icon);
+    }
+
+    public JXButton(String text, Icon icon) {
+        super(text, icon);
+    }
+
+    public Painter getBackgroundPainter() {
+        return backgroundPainter;
+    }
+
+    public void setBackgroundPainter(Painter p) {
+        Painter old = backgroundPainter;
+        backgroundPainter = p;
+        firePropertyChange("backgroundPainter", old, p);
+        repaint();
+    }
+
+    public Painter getForegroundPainter() {
+        return foregroundPainter;
+    }
+
+    public void setForegroundPainter(Painter painter) {
+        Painter old = foregroundPainter;
+        foregroundPainter = painter;
+        firePropertyChange("foregroundPainter", old, painter);
+        repaint();
+    }
+
+    public boolean isPaintBorderInsets() {
+        return paintBorderInsets;
+    }
+
+    /// Whether the painters draw under the border too.
+    public void setPaintBorderInsets(boolean paintBorderInsets) {
+        boolean old = this.paintBorderInsets;
+        this.paintBorderInsets = paintBorderInsets;
+        firePropertyChange("paintBorderInsets", old, paintBorderInsets);
+        if (old != paintBorderInsets) {
+            repaint();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void run(Painter p, Graphics g) {
+        Graphics copy = g.create();
+        try {
+            if (copy instanceof Graphics2D) {
+                Graphics2D g2 = (Graphics2D) copy;
+                int w = getWidth();
+                int h = getHeight();
+                if (!paintBorderInsets) {
+                    Insets i = getInsets();
+                    g2.translate(i.left, i.top);
+                    w -= i.left + i.right;
+                    h -= i.top + i.bottom;
+                }
+                if (w > 0 && h > 0) {
+                    p.paint(g2, this, w, h);
+                }
+            }
+        } finally {
+            copy.dispose();
+        }
+    }
+
+    /// Draws the background and border the theme gives the button, without
+    /// its icon and text.
+    private void paintThemeBackground(Graphics g) {
+        if (!(g instanceof G2D) || !com.codename1.ui.Display.isInitialized()) {
+            return;
+        }
+        com.codename1.ui.Component p = cn1Peer();
+        if (!(p instanceof Peer)) {
+            return;
+        }
+        ((G2D) g).paintNative(p.getX(), p.getY(), new ThemeBackground(p, (Peer) p));
+    }
+
+    /// Paints a peer's styled background and its border.
+    private static final class ThemeBackground implements G2D.NativePainter {
+        private final com.codename1.ui.Component component;
+        private final Peer peer;
+
+        ThemeBackground(com.codename1.ui.Component component, Peer peer) {
+            this.component = component;
+            this.peer = peer;
+        }
+
+        @Override
+        public void paint(com.codename1.ui.Graphics ng) {
+            peer.support().paintStyleBackground(ng);
+            com.codename1.ui.plaf.Border b = component.getStyle().getBorder();
+            if (b != null && !b.isBackgroundPainter()) {
+                b.paint(ng, component);
+            }
+        }
+    }
+
+    private Color textColor() {
+        if (!isEnabled()) {
+            return Color.GRAY;
+        }
+        if (!isForegroundSet() && com.codename1.ui.Display.isInitialized()) {
+            return new Color(cn1Peer().getStyle().getFgColor() & 0xffffff);
+        }
+        return getForeground();
+    }
+
+    private void paintContent(Graphics g) {
+        String text = getText();
+        Icon icon = getIcon();
+        Font f = getFont();
+        FontMetrics fm = Fonts.metrics(f);
+        boolean hasText = text != null && text.length() > 0;
+        int tw = hasText ? fm.stringWidth(text) : 0;
+        int iw = icon != null ? icon.getIconWidth() : 0;
+        int gap = icon != null && hasText ? getIconTextGap() : 0;
+        int x = (getWidth() - iw - gap - tw) / 2;
+        if (icon != null) {
+            icon.paintIcon(this, g, x, (getHeight() - icon.getIconHeight()) / 2);
+        }
+        if (hasText) {
+            g.setFont(f);
+            Color c = textColor();
+            if (c != null) {
+                g.setColor(c);
+            }
+            g.drawString(text, x + iw + gap, (getHeight() - fm.getHeight()) / 2 + fm.getAscent());
+        }
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (backgroundPainter == null && foregroundPainter == null) {
+            super.paintComponent(g);
+            return;
+        }
+        if (backgroundPainter != null) {
+            run(backgroundPainter, g);
+        } else {
+            paintThemeBackground(g);
+        }
+        if (foregroundPainter != null) {
+            run(foregroundPainter, g);
+        } else {
+            Graphics copy = g.create();
+            try {
+                paintContent(copy);
+            } finally {
+                copy.dispose();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXCollapsiblePane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXCollapsiblePane.java
new file mode 100644
index 00000000000..4162e28d9e1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXCollapsiblePane.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.Timer;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+
+/// A panel that hides its content by shrinking to nothing along one axis,
+/// in steps when animated.
+///
+/// Components added to the pane, and the layout set on it, go to its
+/// content pane, a [JXPanel] with a [VerticalLayout] of gap 2. The pane's
+/// preferred size is the content pane's, with the length along the
+/// collapse axis scaled by how far open the pane is; the content keeps
+/// its full size and is cut off by the pane, so it slides rather than
+/// squeezes. Once fully collapsed the content pane is made invisible.
+///
+/// An animated change runs in eight steps of 30 milliseconds on a
+/// [Timer]. The `collapsed` property changes when [#setCollapsed(boolean)]
+/// is called, and the `animationState` property is fired with `reinit`
+/// when a change starts and `expanded` or `collapsed` when it has
+/// finished.
+///
+/// The pane's action map holds, under [#TOGGLE_ACTION], an action that
+/// flips the collapsed state. Icons stored in that action under
+/// [#EXPAND_ICON] and [#COLLAPSE_ICON] become its small icon in turn: the
+/// expand icon while the pane is collapsed, the collapse icon while it is
+/// open.
+///
+/// ## What differs from SwingX
+///
+///  - Component orientation is absent: `LEADING` and `START` are left
+///    and top, `TRAILING` and `END` are right and bottom.
+///  - A border, opacity and minimum or preferred size set on the pane
+///    stay on the pane; only the border is handed to the content pane.
+public class JXCollapsiblePane extends JXPanel {
+
+    public static final String TOGGLE_ACTION = "toggle";
+    public static final String COLLAPSE_ICON = "collapseIcon";
+    public static final String EXPAND_ICON = "expandIcon";
+
+    private static final int STEPS = 8;
+    private static final int STEP_MILLIS = 30;
+
+    /// The side the pane shrinks toward.
+    public enum Direction {
+        LEFT(false),
+        RIGHT(false),
+        UP(true),
+        DOWN(true),
+        LEADING(false),
+        TRAILING(false),
+        START(true),
+        END(true) {
+            @Override
+            boolean far() {
+                return true;
+            }
+        };
+
+        private final boolean vertical;
+
+        Direction(boolean vertical) {
+            this.vertical = vertical;
+        }
+
+        /// Whether the pane collapses along the vertical axis.
+        public boolean isVertical() {
+            return vertical;
+        }
+
+        /// Whether the content stays put at the pane's origin while the
+        /// pane shrinks, rather than sliding out through it.
+        boolean far() {
+            return this == RIGHT || this == DOWN || this == TRAILING;
+        }
+    }
+
+    /// Implemented by an ancestor that wants to be the one laid out again
+    /// while a collapsible pane inside it changes size.
+    public interface CollapsiblePaneContainer {
+
+        Container getValidatingContainer();
+    }
+
+    private Container contentPane;
+    private boolean constructed;
+    private boolean collapsed;
+    private boolean animated = true;
+    private Direction direction = Direction.UP;
+    /// How far open the pane is, from 0 to `STEPS`.
+    private int step = STEPS;
+    private Timer timer;
+
+    public JXCollapsiblePane() {
+        this(Direction.UP);
+    }
+
+    public JXCollapsiblePane(Direction direction) {
+        super.setLayout(new Slide());
+        this.direction = direction == null ? Direction.UP : direction;
+        constructed = true;
+        setContentPane(createContentPane());
+        getActionMap().put(TOGGLE_ACTION, new ToggleAction());
+    }
+
+    /// Flips the collapsed state, and shows as its small icon the one
+    /// stored for the state the pane would change to.
+    private final class ToggleAction extends AbstractAction {
+
+        ToggleAction() {
+            super(TOGGLE_ACTION);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            setCollapsed(!isCollapsed());
+        }
+
+        @Override
+        public void putValue(String key, Object newValue) {
+            super.putValue(key, newValue);
+            if (EXPAND_ICON.equals(key) || COLLAPSE_ICON.equals(key)) {
+                cn1UpdateIcon();
+            }
+        }
+
+        void cn1UpdateIcon() {
+            super.putValue(Action.SMALL_ICON, getValue(isCollapsed() ? EXPAND_ICON : COLLAPSE_ICON));
+        }
+    }
+
+    /// Lays the content pane out at its full size, shifted so that the
+    /// part still showing is the one next to the edge the pane does not
+    /// shrink toward.
+    private final class Slide implements LayoutManager {
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            Container c = contentPane;
+            return c == null ? new Dimension(0, 0) : scaled(c.getPreferredSize());
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return new Dimension(0, 0);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            Container c = contentPane;
+            if (c == null) {
+                return;
+            }
+            Dimension d = c.getPreferredSize();
+            int w = getWidth();
+            int h = getHeight();
+            if (direction.isVertical()) {
+                int full = step >= STEPS ? Math.max(h, 0) : d.height;
+                c.setBounds(0, direction.far() ? 0 : h - full, w, full);
+            } else {
+                int full = step >= STEPS ? Math.max(w, 0) : d.width;
+                c.setBounds(direction.far() ? 0 : w - full, 0, full, h);
+            }
+        }
+    }
+
+    /// Makes the pane components are added to: a [JXPanel] with a
+    /// [VerticalLayout] of gap 2.
+    protected Container createContentPane() {
+        return new JXPanel(new VerticalLayout(2));
+    }
+
+    public Container getContentPane() {
+        return contentPane;
+    }
+
+    /// Replaces the pane components are added to. The components of the
+    /// old one are not moved over.
+    public void setContentPane(Container contentPanel) {
+        if (contentPanel == null) {
+            throw new IllegalArgumentException("Content pane can't be null");
+        }
+        if (contentPane != null) {
+            super.remove(contentPane);
+        }
+        contentPane = contentPanel;
+        contentPane.setVisible(step > 0);
+        super.addImpl(contentPane, null, -1);
+        revalidate();
+    }
+
+    /// Sets the layout of the content pane.
+    @Override
+    public void setLayout(LayoutManager mgr) {
+        if (contentPane != null) {
+            contentPane.setLayout(mgr);
+        }
+    }
+
+    /// Adds to the content pane.
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (!constructed || contentPane == null) {
+            super.addImpl(comp, constraints, index);
+            return;
+        }
+        contentPane.add(comp, constraints, index);
+    }
+
+    /// Removes from the content pane.
+    @Override
+    public void remove(Component comp) {
+        if (contentPane != null) {
+            contentPane.remove(comp);
+        }
+    }
+
+    /// Removes from the content pane.
+    @Override
+    public void remove(int index) {
+        if (contentPane != null) {
+            contentPane.remove(index);
+        }
+    }
+
+    /// Empties the content pane.
+    @Override
+    public void removeAll() {
+        if (contentPane != null) {
+            contentPane.removeAll();
+        }
+    }
+
+    /// Sets whether a change of the collapsed state runs in steps.
+    public void setAnimated(boolean animated) {
+        boolean old = this.animated;
+        this.animated = animated;
+        if (old != animated) {
+            firePropertyChange("animated", old, animated);
+        }
+    }
+
+    public boolean isAnimated() {
+        return animated;
+    }
+
+    public void setDirection(Direction direction) {
+        if (timer != null && timer.isRunning()) {
+            throw new IllegalStateException("cannot be change direction while collapsing.");
+        }
+        Direction old = this.direction;
+        this.direction = direction == null ? Direction.UP : direction;
+        if (old != this.direction) {
+            revalidate();
+            firePropertyChange("direction", old, this.direction);
+        }
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public boolean isCollapsed() {
+        return collapsed;
+    }
+
+    /// Hides or shows the content, in steps when animated and showing.
+    public void setCollapsed(boolean val) {
+        if (collapsed == val) {
+            return;
+        }
+        collapsed = val;
+        firePropertyChange("animationState", null, "reinit");
+        if (animated && isShowing()) {
+            if (!val) {
+                contentPane.setVisible(true);
+            }
+            if (timer == null) {
+                timer = new Timer(STEP_MILLIS, new ActionListener() {
+                    @Override
+                    public void actionPerformed(ActionEvent e) {
+                        cn1AnimationStep();
+                    }
+                });
+            }
+            if (!timer.isRunning()) {
+                timer.start();
+            }
+        } else {
+            cn1Finish();
+        }
+        Action toggle = getActionMap().get(TOGGLE_ACTION);
+        if (toggle instanceof ToggleAction) {
+            ((ToggleAction) toggle).cn1UpdateIcon();
+        }
+        firePropertyChange("collapsed", !val, val);
+    }
+
+    /// Moves a running change one step on, and ends it at the last. The
+    /// timer calls this; so may a test.
+    void cn1AnimationStep() {
+        int goal = collapsed ? 0 : STEPS;
+        if (step == goal) {
+            cn1Finish();
+            return;
+        }
+        step += collapsed ? -1 : 1;
+        if (step == goal) {
+            cn1Finish();
+        } else {
+            cn1Relayout();
+        }
+    }
+
+    /// Whether a change is still running.
+    boolean cn1Animating() {
+        return step != (collapsed ? 0 : STEPS);
+    }
+
+    private void cn1Finish() {
+        if (timer != null) {
+            timer.stop();
+        }
+        step = collapsed ? 0 : STEPS;
+        contentPane.setVisible(!collapsed);
+        cn1Relayout();
+        firePropertyChange("animationState", null, collapsed ? "collapsed" : "expanded");
+    }
+
+    private void cn1Relayout() {
+        invalidate();
+        Container validating = null;
+        for (Container p = getParent(); p != null; p = p.getParent()) {
+            if (p instanceof CollapsiblePaneContainer) {
+                validating = ((CollapsiblePaneContainer) p).getValidatingContainer();
+                break;
+            }
+        }
+        if (validating instanceof JComponent) {
+            ((JComponent) validating).revalidate();
+        }
+        revalidate();
+        repaint();
+    }
+
+    /// The content pane's border.
+    @Override
+    public Border getBorder() {
+        if (contentPane instanceof JComponent) {
+            return ((JComponent) contentPane).getBorder();
+        }
+        return null;
+    }
+
+    /// Sets the border on the content pane.
+    @Override
+    public void setBorder(Border border) {
+        if (contentPane instanceof JComponent) {
+            ((JComponent) contentPane).setBorder(border);
+        }
+    }
+
+    /// The content's minimum size, with nothing along the collapse axis.
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet() || contentPane == null) {
+            return super.getMinimumSize();
+        }
+        Dimension d = contentPane.getMinimumSize();
+        if (direction.isVertical()) {
+            return new Dimension(d.width, 0);
+        }
+        return new Dimension(0, d.height);
+    }
+
+    /// The content's preferred size, with the length along the collapse
+    /// axis scaled by how far open the pane is.
+    @Override
+    public Dimension getPreferredSize() {
+        if (contentPane == null) {
+            return new Dimension(0, 0);
+        }
+        return scaled(isPreferredSizeSet() ? super.getPreferredSize() : contentPane.getPreferredSize());
+    }
+
+    private Dimension scaled(Dimension d) {
+        if (direction.isVertical()) {
+            return new Dimension(d.width, d.height * step / STEPS);
+        }
+        return new Dimension(d.width * step / STEPS, d.height);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDatePicker.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDatePicker.java
new file mode 100644
index 00000000000..a777ec8fb7c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDatePicker.java
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.CalendarUtils;
+import com.codename1.desktopcompat.rt.DatePickerPeer;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+/// A date shown as text that the user changes with the platform's date
+/// chooser.
+///
+/// ## How it is shown
+///
+/// The picker is a Codename One `Picker` of dates: a button that carries
+/// the date, formatted with the first of the picker's formats, and opens
+/// the native date chooser (or Codename One's own wheels where there is
+/// none) when tapped. Choosing a date there sets it and tells the action
+/// listeners [#COMMIT_KEY].
+///
+/// ## What differs from SwingX
+///
+///  - There is no text editor, so a date cannot be typed:
+///    `getEditor`, `setEditor` and the link panel are absent,
+///    [#isEditValid()] is always true, and the formats after the first
+///    serve only an application that parses with [#getFormats()] itself.
+///  - There is no popup with the month view. The view answered by
+///    [#getMonthView()] is kept in step with the picker -- it carries the
+///    selection, the bounds and the time zone, and committing it sets the
+///    picker's date -- but it is shown only if the application adds it
+///    somewhere.
+///  - A picker that is not editable does not open the chooser.
+///  - The default formats are the device's long, medium and short date
+///    styles.
+public class JXDatePicker extends JComponent {
+
+    public static final String uiClassID = "DatePickerUI";
+    public static final String EDITOR = "editor";
+    public static final String MONTH_VIEW = "monthView";
+    public static final String LINK_PANEL = "linkPanel";
+    public static final String COMMIT_KEY = "datePickerCommit";
+    public static final String CANCEL_KEY = "datePickerCancel";
+    public static final String HOME_NAVIGATE_KEY = "navigateHome";
+    public static final String HOME_COMMIT_KEY = "commitHome";
+
+    protected boolean lightWeightPopupEnabled = true;
+
+    private Date date;
+    private DateFormat[] formats;
+    private JXMonthView monthView;
+    private boolean editable = true;
+    private boolean pushing;
+    private final ActionListener monthViewListener = new ActionListener() {
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            if (JXMonthView.COMMIT_KEY.equals(e.getActionCommand())) {
+                cn1Chosen(monthView.getSelectionDate());
+            } else if (JXMonthView.CANCEL_KEY.equals(e.getActionCommand())) {
+                cancelEdit();
+            }
+        }
+    };
+
+    public JXDatePicker() {
+        this(null, null);
+    }
+
+    public JXDatePicker(Date selected) {
+        this(selected, null);
+    }
+
+    public JXDatePicker(Locale locale) {
+        this(null, locale);
+    }
+
+    /// A picker showing `selection`, or no date for `null`. The locale is
+    /// handed to the month view, which records it.
+    public JXDatePicker(Date selection, Locale locale) {
+        formats = new DateFormat[]{DateFormat.getDateInstance(DateFormat.LONG),
+            DateFormat.getDateInstance(DateFormat.MEDIUM), DateFormat.getDateInstance(DateFormat.SHORT)};
+        monthView = new JXMonthView(locale);
+        monthView.setTraversable(true);
+        monthView.addActionListener(monthViewListener);
+        if (selection != null) {
+            date = monthView.getSelectionModel().getNormalizedDate(selection);
+            monthView.setSelectionDate(date);
+            monthView.ensureDateVisible(date);
+        }
+    }
+
+    // ------------------------------------------------------------ peer
+
+    @Override
+    protected com.codename1.ui.Component cn1CreatePeer() {
+        return new DatePickerPeer(this, new DatePickerPeer.Host() {
+            @Override
+            public String text(Date d) {
+                return cn1Format(d);
+            }
+
+            @Override
+            public void valueChanged(Date d) {
+                if (!pushing) {
+                    cn1Chosen(d);
+                }
+            }
+        });
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        push();
+    }
+
+    /// Writes the date, the bounds and whether the chooser may open to
+    /// the picker.
+    private void push() {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        if (!(p instanceof DatePickerPeer)) {
+            return;
+        }
+        DatePickerPeer picker = (DatePickerPeer) p;
+        pushing = true;
+        try {
+            picker.setStartDate(monthView.getLowerBound());
+            picker.setEndDate(monthView.getUpperBound());
+            picker.setDate(date == null ? null : new Date(date.getTime()));
+            picker.setEnabled(isEnabled() && editable);
+        } finally {
+            pushing = false;
+        }
+    }
+
+    /// The text that shows a date: the first format's, and nothing for no
+    /// date.
+    private String cn1Format(Date d) {
+        if (d == null || formats.length == 0) {
+            return "";
+        }
+        return formats[0].format(d);
+    }
+
+    /// Takes a date chosen by the user and tells the action listeners.
+    private void cn1Chosen(Date d) {
+        Date n = d == null ? null : monthView.getSelectionModel().getNormalizedDate(d);
+        if (!CalendarUtils.areEqual(n, date)) {
+            setDate(n);
+        }
+        fireActionPerformed(COMMIT_KEY);
+    }
+
+    // ------------------------------------------------------------ date
+
+    /// Sets the date, as the first millisecond of its day, or no date for
+    /// `null`.
+    public void setDate(Date date) {
+        Date old = this.date;
+        Date n = date == null ? null : monthView.getSelectionModel().getNormalizedDate(date);
+        this.date = n;
+        monthView.setSelectionDate(n);
+        if (n != null) {
+            monthView.ensureDateVisible(n);
+        }
+        push();
+        if (!CalendarUtils.areEqual(old, n)) {
+            firePropertyChange("date", old, getDate());
+            revalidate();
+            repaint();
+        }
+    }
+
+    public Date getDate() {
+        return date == null ? null : new Date(date.getTime());
+    }
+
+    /// Does nothing: there are no UI delegates.
+    @Override
+    public void updateUI() {
+    }
+
+    public String getUIClassID() {
+        return uiClassID;
+    }
+
+    // ------------------------------------------------------------ formats
+
+    /// Sets the formats from date patterns; the first one shows the date.
+    /// No patterns, or `null`, restores nothing: the picker then shows no
+    /// text.
+    public void setFormats(String... formats) {
+        DateFormat[] made = new DateFormat[formats == null ? 0 : formats.length];
+        for (int i = 0; i < made.length; i++) {
+            if (formats[i] == null) {
+                throw new NullPointerException("the array of format strings must not contain null elements");
+            }
+            made[i] = new SimpleDateFormat(formats[i]);
+        }
+        setFormats(made);
+    }
+
+    /// Sets the formats; the first one shows the date.
+    public void setFormats(DateFormat... formats) {
+        DateFormat[] made = new DateFormat[formats == null ? 0 : formats.length];
+        for (int i = 0; i < made.length; i++) {
+            if (formats[i] == null) {
+                throw new NullPointerException("the array of formats must not contain null elements");
+            }
+            made[i] = formats[i];
+        }
+        DateFormat[] old = getFormats();
+        this.formats = made;
+        push();
+        firePropertyChange("formats", old, getFormats());
+        revalidate();
+        repaint();
+    }
+
+    public DateFormat[] getFormats() {
+        DateFormat[] out = new DateFormat[formats.length];
+        System.arraycopy(formats, 0, out, 0, formats.length);
+        return out;
+    }
+
+    // ------------------------------------------------------------ month view
+
+    public JXMonthView getMonthView() {
+        return monthView;
+    }
+
+    /// Replaces the month view. The new view is given the picker's date.
+    public void setMonthView(JXMonthView monthView) {
+        if (monthView == null) {
+            throw new NullPointerException("monthView must not be null");
+        }
+        JXMonthView old = this.monthView;
+        if (old == monthView) {
+            return;
+        }
+        old.removeActionListener(monthViewListener);
+        this.monthView = monthView;
+        monthView.addActionListener(monthViewListener);
+        Date d = date;
+        date = d == null ? null : monthView.getSelectionModel().getNormalizedDate(d);
+        monthView.setSelectionDate(date);
+        push();
+        firePropertyChange(MONTH_VIEW, old, monthView);
+    }
+
+    public TimeZone getTimeZone() {
+        return monthView.getTimeZone();
+    }
+
+    /// Sets the time zone of the month view. The date keeps its instant
+    /// and is read as a day of the new zone.
+    public void setTimeZone(TimeZone tz) {
+        TimeZone old = getTimeZone();
+        Date d = date;
+        monthView.setTimeZone(tz);
+        if (d != null) {
+            setDate(d);
+        }
+        firePropertyChange("timeZone", old, getTimeZone());
+    }
+
+    // ------------------------------------------------------------ editing
+
+    /// Always `true`: there is no text to be invalid.
+    public boolean isEditValid() {
+        return true;
+    }
+
+    /// Takes the date the chooser holds and tells the action listeners
+    /// [#COMMIT_KEY]. Nothing is parsed, so nothing is thrown.
+    public void commitEdit() throws ParseException {
+        com.codename1.ui.Component p = cn1PeerOrNull();
+        Date d = date;
+        if (p instanceof DatePickerPeer) {
+            Object v = ((DatePickerPeer) p).getValue();
+            d = v instanceof Date ? (Date) v : null;
+        }
+        cn1Chosen(d);
+    }
+
+    /// Puts the picker's date back into the chooser and the month view
+    /// and tells the action listeners [#CANCEL_KEY].
+    public void cancelEdit() {
+        monthView.setSelectionDate(date);
+        push();
+        fireActionPerformed(CANCEL_KEY);
+    }
+
+    /// Whether tapping the picker opens the chooser.
+    public void setEditable(boolean value) {
+        boolean old = editable;
+        editable = value;
+        push();
+        firePropertyChange("editable", old, value);
+    }
+
+    public boolean isEditable() {
+        return editable;
+    }
+
+    @Override
+    public void setEnabled(boolean b) {
+        super.setEnabled(b);
+        push();
+    }
+
+    /// Recorded only: the chooser is the platform's.
+    public void setLightWeightPopupEnabled(boolean aFlag) {
+        boolean old = lightWeightPopupEnabled;
+        lightWeightPopupEnabled = aFlag;
+        firePropertyChange("lightWeightPopupEnabled", old, aFlag);
+    }
+
+    public boolean isLightWeightPopupEnabled() {
+        return lightWeightPopupEnabled;
+    }
+
+    // ------------------------------------------------------------ actions
+
+    public void addActionListener(ActionListener l) {
+        listenerList.add(ActionListener.class, l);
+    }
+
+    public void removeActionListener(ActionListener l) {
+        listenerList.remove(ActionListener.class, l);
+    }
+
+    protected void fireActionPerformed(String actionCommand) {
+        ActionListener[] ls = listenerList.getListeners(ActionListener.class);
+        if (ls.length == 0) {
+            return;
+        }
+        ActionEvent e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, actionCommand);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].actionPerformed(e);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDialog.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDialog.java
new file mode 100644
index 00000000000..9a415970462
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDialog.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JDialog;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+
+/// A dialog around one content component, with a row of buttons under it
+/// taken from the content's action map.
+///
+/// The action the content keeps under [#EXECUTE_ACTION_COMMAND], if any,
+/// becomes the first button and the dialog's default button. The action
+/// under [#CLOSE_ACTION_COMMAND] becomes the close button; without one
+/// the close button calls [#doClose()]. The escape key presses the close
+/// button. The dialog's title is the content's name, and the dialog is
+/// packed when built. It is not modal unless made so.
+///
+/// ## What differs from SwingX
+///
+///  - There is no extended root pane, so the status bar and the tool bar
+///    are absent, and [#getRootPane()] answers a plain root pane.
+///  - The button texts come from the `XDialog.Close` and
+///    `XDialog.Execute` values of the UI manager, and are `Close` and
+///    `Execute` when those are not set; the locale members are absent.
+public class JXDialog extends JDialog {
+
+    public static final String EXECUTE_ACTION_COMMAND = "execute";
+    public static final String CLOSE_ACTION_COMMAND = "close";
+    public static final String UIPREFIX = "XDialog.";
+
+    protected JComponent content;
+
+    public JXDialog(JComponent content) {
+        this((Frame) null, content);
+    }
+
+    public JXDialog(Frame frame, JComponent content) {
+        super(frame);
+        cn1Build(content);
+    }
+
+    public JXDialog(Dialog dialog, JComponent content) {
+        super(dialog);
+        cn1Build(content);
+    }
+
+    public JXDialog(Window window, JComponent content) {
+        super(window);
+        cn1Build(content);
+    }
+
+    private void cn1Build(JComponent c) {
+        if (c == null) {
+            throw new IllegalArgumentException("content must not be null");
+        }
+        content = c;
+        super.getContentPane().setLayout(new BorderLayout());
+        super.getContentPane().add(c, BorderLayout.CENTER);
+        super.getContentPane().add(cn1Buttons(), BorderLayout.SOUTH);
+        String name = c.getName();
+        if (name != null) {
+            super.setTitle(name);
+        }
+        super.pack();
+    }
+
+    /// Sets the title to the content's name, when it has one.
+    protected void setTitleFromContent() {
+        if (content != null && content.getName() != null) {
+            setTitle(content.getName());
+        }
+    }
+
+    /// Closes the dialog and releases its window.
+    public void doClose() {
+        dispose();
+    }
+
+    /// The row of buttons under the content: the execute button, when the
+    /// content has an execute action, and the close button.
+    protected JComponent createButtonPanel() {
+        return cn1Buttons();
+    }
+
+    private JComponent cn1Buttons() {
+        JPanel panel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+        Action execute = content.getActionMap().get(EXECUTE_ACTION_COMMAND);
+        Action close = content.getActionMap().get(CLOSE_ACTION_COMMAND);
+        if (close == null) {
+            close = new AbstractAction(cn1Text("Close")) {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    doClose();
+                }
+            };
+        }
+        JButton closeButton = new JButton(close);
+        if (closeButton.getText() == null || closeButton.getText().length() == 0) {
+            closeButton.setText(cn1Text("Close"));
+        }
+        if (execute != null) {
+            JButton executeButton = new JButton(execute);
+            if (executeButton.getText() == null || executeButton.getText().length() == 0) {
+                executeButton.setText(cn1Text("Execute"));
+            }
+            panel.add(executeButton);
+            super.getRootPane().setDefaultButton(executeButton);
+        }
+        panel.add(closeButton);
+        super.getRootPane().registerKeyboardAction(new Press(closeButton), KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_IN_FOCUSED_WINDOW);
+        return panel;
+    }
+
+    /// Presses a button, if it is enabled.
+    private static final class Press implements ActionListener {
+
+        private final JButton button;
+
+        Press(JButton button) {
+            this.button = button;
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            if (button.isEnabled()) {
+                button.doClick();
+            }
+        }
+    }
+
+    private static String cn1Text(String key) {
+        String s = UIManager.getString(UIPREFIX + key);
+        return s == null ? key : s;
+    }
+
+    /// The UI manager's string for `key` under [#UIPREFIX], or null when
+    /// there is none.
+    protected String getUIString(String key) {
+        return UIManager.getString(UIPREFIX + key);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXErrorPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXErrorPane.java
new file mode 100644
index 00000000000..27e5816b77f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXErrorPane.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JDialog;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+
+/// A pane that reports a throwable: its message beside an error icon, a
+/// button that opens and closes the stack trace, and a button that closes
+/// the window the pane is in.
+///
+/// [#showDialog(Throwable)] is the usual entry: it shows the pane in a
+/// modal dialog titled `Error` and returns once the dialog is closed.
+///
+/// ## What differs from SwingX
+///
+///  - The error-info accessors, the reporter accessors and the overloads
+///    that take an `ErrorInfo` are absent, because `ErrorInfo` is built on
+///    `java.util.logging.Level`, which a device does not have. A pane
+///    made with the constructor therefore reports nothing; only
+///    [#showDialog(Throwable)] gives it something to show.
+///  - There is no report button and no fatal state, so the actions named
+///    by [#REPORT_ACTION_KEY] and [#FATAL_ACTION_KEY] are not in the
+///    action map.
+///  - The frame and internal-frame variants are absent.
+///  - The stack trace has the frames the platform records, which on a
+///    device may be none; the chain of causes is always listed.
+public class JXErrorPane extends JComponent {
+
+    public static final String REPORT_ACTION_KEY = "report-action";
+    public static final String FATAL_ACTION_KEY = "fatal-action";
+    public static final String uiClassID = "ErrorPaneUI";
+
+    private final JLabel message;
+    private final JTextArea details;
+    private final JScrollPane detailsScroll;
+    private final JButton detailsButton;
+    private final JButton closeButton;
+    private Icon icon;
+
+    public JXErrorPane() {
+        message = new JLabel();
+        details = new JTextArea(8, 40);
+        details.setEditable(false);
+        detailsScroll = new JScrollPane(details);
+        detailsScroll.setVisible(false);
+        detailsButton = new JButton("Details >>");
+        closeButton = new JButton("Close");
+        cn1Build();
+    }
+
+    private void cn1Build() {
+        super.setLayout(new BorderLayout(8, 8));
+        icon = UIManager.getIcon("OptionPane.errorIcon");
+        message.setIcon(icon);
+        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+        buttons.add(closeButton);
+        buttons.add(detailsButton);
+        JPanel top = new JPanel(new BorderLayout(8, 8));
+        top.add(message, BorderLayout.CENTER);
+        top.add(buttons, BorderLayout.SOUTH);
+        super.add(top, BorderLayout.NORTH);
+        super.add(detailsScroll, BorderLayout.CENTER);
+        detailsButton.setEnabled(false);
+        detailsButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                cn1ToggleDetails();
+            }
+        });
+        closeButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                Window w = SwingUtilities.getWindowAncestor(JXErrorPane.this);
+                if (w != null) {
+                    w.setVisible(false);
+                    w.dispose();
+                }
+            }
+        });
+    }
+
+    private void cn1ToggleDetails() {
+        boolean open = !detailsScroll.isVisible();
+        detailsScroll.setVisible(open);
+        detailsButton.setText(open ? "Details <<" : "Details >>");
+        revalidate();
+        Window w = SwingUtilities.getWindowAncestor(this);
+        if (w != null) {
+            w.pack();
+        }
+    }
+
+    private void cn1Report(Throwable t) {
+        String text = t.getMessage();
+        if (text == null || text.length() == 0) {
+            text = t.toString();
+        }
+        message.setText(text);
+        StringBuilder sb = new StringBuilder();
+        Throwable at = t;
+        // A chain of causes that loops back on itself ends at 20.
+        for (int depth = 0; at != null && depth < 20; depth++) {
+            if (depth > 0) {
+                sb.append("Caused by: ");
+            }
+            sb.append(at.toString()).append('\n');
+            StackTraceElement[] frames = at.getStackTrace();
+            for (int i = 0; i < frames.length; i++) {
+                sb.append("    at ").append(String.valueOf(frames[i])).append('\n');
+            }
+            at = at.getCause();
+        }
+        details.setText(sb.toString());
+        detailsButton.setEnabled(true);
+    }
+
+    public String getUIClassID() {
+        return uiClassID;
+    }
+
+    /// Sets the icon shown beside the message.
+    public void setIcon(Icon icon) {
+        Icon old = this.icon;
+        this.icon = icon;
+        message.setIcon(icon);
+        firePropertyChange("icon", old, icon);
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    /// Reports `e` in a modal dialog with no owner, and returns when the
+    /// dialog is closed.
+    public static void showDialog(Throwable e) {
+        JXErrorPane pane = new JXErrorPane();
+        if (e != null) {
+            pane.cn1Report(e);
+        }
+        showDialog(null, pane);
+    }
+
+    /// Shows `pane` in a modal dialog over the window of `owner`, and
+    /// returns when the dialog is closed.
+    public static void showDialog(Component owner, JXErrorPane pane) {
+        JDialog dialog = createDialog(owner, pane);
+        dialog.setVisible(true);
+        dialog.dispose();
+    }
+
+    /// A modal dialog titled `Error` with `pane` as its content, packed
+    /// and placed over `owner`, not yet showing. The close button of the
+    /// pane is the dialog's default button.
+    public static JDialog createDialog(Component owner, JXErrorPane pane) {
+        Window w = null;
+        if (owner instanceof Window) {
+            w = (Window) owner;
+        } else if (owner != null) {
+            w = SwingUtilities.getWindowAncestor(owner);
+        }
+        JDialog dialog = new JDialog(w, "Error", Dialog.ModalityType.APPLICATION_MODAL);
+        dialog.getContentPane().setLayout(new BorderLayout());
+        dialog.getContentPane().add(pane, BorderLayout.CENTER);
+        dialog.getRootPane().setDefaultButton(pane.closeButton);
+        dialog.pack();
+        dialog.setLocationRelativeTo(owner);
+        return dialog;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXFormattedTextField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXFormattedTextField.java
new file mode 100644
index 00000000000..c213e4ce45b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXFormattedTextField.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JFormattedTextField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport.FocusBehavior;
+
+/// A formatted text field with a prompt: text shown while the field is
+/// empty.
+///
+/// The prompt is the hint of the Codename One text field; see
+/// [PromptSupport] for what of its looks is honored. Buddy components and the outer margin are absent.
+public class JXFormattedTextField extends JFormattedTextField {
+
+    public JXFormattedTextField() {
+        this(null);
+    }
+
+    public JXFormattedTextField(String promptText) {
+        this(promptText, null);
+    }
+
+    public JXFormattedTextField(String promptText, Color promptForeground) {
+        this(promptText, promptForeground, null);
+    }
+
+    public JXFormattedTextField(String promptText, Color promptForeground, Color promptBackground) {
+        PromptSupport.init(promptText, promptForeground, promptBackground, this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        PromptSupport.cn1Push(this);
+    }
+
+    public FocusBehavior getFocusBehavior() {
+        return PromptSupport.getFocusBehavior(this);
+    }
+
+    public String getPrompt() {
+        return PromptSupport.getPrompt(this);
+    }
+
+    public Color getPromptForeground() {
+        return PromptSupport.getForeground(this);
+    }
+
+    public Color getPromptBackground() {
+        return PromptSupport.getBackground(this);
+    }
+
+    public Integer getPromptFontStyle() {
+        return PromptSupport.getFontStyle(this);
+    }
+
+    public void setFocusBehavior(FocusBehavior focusBehavior) {
+        PromptSupport.setFocusBehavior(focusBehavior, this);
+    }
+
+    public void setPrompt(String labelText) {
+        PromptSupport.setPrompt(labelText, this);
+    }
+
+    public void setPromptForeground(Color promptTextColor) {
+        PromptSupport.setForeground(promptTextColor, this);
+    }
+
+    /// Recorded only. The name is SwingX's own spelling.
+    public void setPromptBackround(Color color) {
+        PromptSupport.setBackground(color, this);
+    }
+
+    public void setPromptFontStyle(Integer fontStyle) {
+        PromptSupport.setFontStyle(fontStyle, this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXFrame.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXFrame.java
new file mode 100644
index 00000000000..636e78d03b0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXFrame.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Cursor;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JRootPane;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+
+/// A frame with a cancel button the escape key presses, a place to start
+/// at, and a waiting state that swaps in a wait pane and a wait cursor.
+///
+/// ## What differs from SwingX
+///
+///  - There is no extended root pane, so the status bar, the tool bar and
+///    `getRootPaneExt` are absent. Add a status bar or a tool bar to the
+///    content pane instead.
+///  - Key preview is absent.
+///  - The idle state is what [#setIdle(boolean)] was last given; nothing
+///    watches the input for it, and the threshold is only kept.
+///  - The constructors that take a graphics configuration are absent.
+public class JXFrame extends JFrame {
+
+    /// Where the frame is put when it is first shown.
+    public enum StartPosition {
+        CenterInScreen,
+        CenterInParent,
+        Manual
+    }
+
+    private JButton cancelButton;
+    private boolean cancelBound;
+    private StartPosition startPosition;
+    private boolean placed;
+    private boolean waitCursorVisible;
+    private Cursor realCursor;
+    private Component waitPane;
+    private Component glassPaneBefore;
+    private boolean waitPaneVisible;
+    private boolean waiting;
+    private boolean idle;
+    private long idleThreshold;
+
+    public JXFrame() {
+        this(null, false);
+    }
+
+    public JXFrame(String title) {
+        this(title, false);
+    }
+
+    /// A frame that ends the application when closed, if `exitOnClose`.
+    public JXFrame(String title, boolean exitOnClose) {
+        super(title);
+        if (exitOnClose) {
+            super.setDefaultCloseOperation(EXIT_ON_CLOSE);
+        }
+    }
+
+    /// Sets the button the escape key presses while this frame has the
+    /// focus, or null for none.
+    public void setCancelButton(JButton button) {
+        JButton old = cancelButton;
+        cancelButton = button;
+        JRootPane root = getRootPane();
+        if (!cancelBound && root != null) {
+            cancelBound = true;
+            root.registerKeyboardAction(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    JButton b = cancelButton;
+                    if (b != null && b.isEnabled()) {
+                        b.doClick();
+                    }
+                }
+            }, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_IN_FOCUSED_WINDOW);
+        }
+        firePropertyChange("cancelButton", old, button);
+    }
+
+    public JButton getCancelButton() {
+        return cancelButton;
+    }
+
+    /// Sets the root pane's default button.
+    public void setDefaultButton(JButton button) {
+        JButton old = getDefaultButton();
+        getRootPane().setDefaultButton(button);
+        firePropertyChange("defaultButton", old, button);
+    }
+
+    public JButton getDefaultButton() {
+        return getRootPane().getDefaultButton();
+    }
+
+    /// Sets where the frame is put the first time it is shown.
+    public void setStartPosition(StartPosition position) {
+        StartPosition old = getStartPosition();
+        startPosition = position;
+        firePropertyChange("startPosition", old, getStartPosition());
+    }
+
+    /// Where the frame is put the first time it is shown, `Manual` unless
+    /// set.
+    public StartPosition getStartPosition() {
+        return startPosition == null ? StartPosition.Manual : startPosition;
+    }
+
+    /// Shows or hides the frame, placing it by the start position the
+    /// first time it is shown.
+    @Override
+    public void setVisible(boolean visible) {
+        if (visible && !placed) {
+            placed = true;
+            StartPosition p = getStartPosition();
+            if (p == StartPosition.CenterInScreen) {
+                setLocationRelativeTo(null);
+            } else if (p == StartPosition.CenterInParent) {
+                setLocationRelativeTo(getOwner());
+            }
+        }
+        super.setVisible(visible);
+    }
+
+    /// Shows the wait cursor over the frame, or goes back to the cursor
+    /// last set with [#setCursor(Cursor)].
+    public void setWaitCursorVisible(boolean flag) {
+        boolean old = waitCursorVisible;
+        if (flag != old) {
+            if (flag) {
+                realCursor = isCursorSet() ? getCursor() : null;
+                super.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
+                waitCursorVisible = true;
+            } else {
+                waitCursorVisible = false;
+                super.setCursor(realCursor);
+            }
+            firePropertyChange("waitCursorVisible", old, flag);
+        }
+    }
+
+    public boolean isWaitCursorVisible() {
+        return waitCursorVisible;
+    }
+
+    /// Sets the frame's cursor; while the wait cursor shows, the cursor
+    /// is kept and takes effect when the wait cursor goes.
+    @Override
+    public void setCursor(Cursor cursor) {
+        if (waitCursorVisible) {
+            realCursor = cursor;
+        } else {
+            super.setCursor(cursor);
+        }
+    }
+
+    /// Sets the component that takes the place of the glass pane while
+    /// the wait pane is visible.
+    public void setWaitPane(Component c) {
+        Component old = waitPane;
+        boolean shown = waitPaneVisible;
+        if (shown) {
+            setWaitPaneVisible(false);
+        }
+        waitPane = c;
+        if (shown) {
+            setWaitPaneVisible(true);
+        }
+        firePropertyChange("waitPane", old, c);
+    }
+
+    public Component getWaitPane() {
+        return waitPane;
+    }
+
+    /// Puts the wait pane in as the glass pane and shows it, or hides it
+    /// and puts the glass pane back. Without a wait pane only the flag
+    /// changes.
+    public void setWaitPaneVisible(boolean flag) {
+        boolean old = waitPaneVisible;
+        if (flag != old) {
+            waitPaneVisible = flag;
+            Component wp = waitPane;
+            if (wp != null) {
+                if (flag) {
+                    glassPaneBefore = getGlassPane();
+                    setGlassPane(wp);
+                    wp.setVisible(true);
+                } else {
+                    wp.setVisible(false);
+                    if (glassPaneBefore != null) {
+                        setGlassPane(glassPaneBefore);
+                    }
+                    glassPaneBefore = null;
+                }
+            }
+            firePropertyChange("waitPaneVisible", old, flag);
+        }
+    }
+
+    public boolean isWaitPaneVisible() {
+        return waitPaneVisible;
+    }
+
+    /// Shows or hides both the wait cursor and the wait pane.
+    public void setWaiting(boolean waiting) {
+        boolean old = this.waiting;
+        this.waiting = waiting;
+        firePropertyChange("waiting", old, waiting);
+        setWaitPaneVisible(waiting);
+        setWaitCursorVisible(waiting);
+    }
+
+    public boolean isWaiting() {
+        return waiting;
+    }
+
+    public boolean isIdle() {
+        return idle;
+    }
+
+    public void setIdle(boolean idle) {
+        boolean old = this.idle;
+        this.idle = idle;
+        firePropertyChange("idle", old, idle);
+    }
+
+    public void setIdleThreshold(long threshold) {
+        long old = idleThreshold;
+        idleThreshold = threshold;
+        firePropertyChange("idleThreshold", Long.valueOf(old), Long.valueOf(threshold));
+    }
+
+    public long getIdleThreshold() {
+        return idleThreshold;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXHeader.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXHeader.java
new file mode 100644
index 00000000000..59b3752a6a1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXHeader.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.rt.Fonts;
+
+/// The banner at the top of a form or dialog: a bold title, a description
+/// under it, and an icon at one end.
+///
+/// The three parts are Codename One labels laid out by the header: the
+/// icon at the right or left end and centered vertically, the title at
+/// the top, the description under it and indented.
+///
+/// ## What differs from SwingX
+///
+///  - There is no look and feel delegate, so no gradient is drawn behind
+///    the header; set a background painter for one.
+///  - The description is one line and is cut off when it does not fit;
+///    it does not wrap.
+public class JXHeader extends JXPanel {
+
+    /// The end of the header the icon is at.
+    public enum IconPosition {
+        LEFT,
+        RIGHT
+    }
+
+    private static final int PAD = 12;
+
+    private final JLabel titleLabel = new JLabel();
+    private final JLabel descriptionLabel = new JLabel();
+    private final JLabel iconLabel = new JLabel();
+    private String title;
+    private String description;
+    private Icon icon;
+    private Font titleFont;
+    private Font descriptionFont;
+    private Color titleForeground;
+    private Color descriptionForeground;
+    private IconPosition iconPosition = IconPosition.RIGHT;
+
+    public JXHeader() {
+        this(null, null);
+    }
+
+    public JXHeader(String title, String description) {
+        this(title, description, null);
+    }
+
+    public JXHeader(String title, String description, Icon icon) {
+        super(new Banner());
+        titleLabel.setFont(Fonts.defaultFont().deriveFont(Font.BOLD));
+        titleLabel.setHorizontalAlignment(SwingConstants.LEFT);
+        descriptionLabel.setHorizontalAlignment(SwingConstants.LEFT);
+        add(titleLabel);
+        add(descriptionLabel);
+        add(iconLabel);
+        setTitle(title);
+        setDescription(description);
+        setIcon(icon);
+    }
+
+    /// Lays out the title, the description and the icon, which are the
+    /// header's first three children in that order.
+    private static final class Banner implements LayoutManager {
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        private static Dimension size(Container parent, int index) {
+            if (parent.getComponentCount() <= index || !parent.getComponent(index).isVisible()) {
+                return new Dimension(0, 0);
+            }
+            return parent.getComponent(index).getPreferredSize();
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            Insets in = parent.getInsets();
+            Dimension t = size(parent, 0);
+            Dimension d = size(parent, 1);
+            Dimension i = size(parent, 2);
+            int text = Math.max(t.width, d.width + PAD);
+            int w = text + (i.width > 0 ? i.width + PAD : 0);
+            int h = Math.max(t.height + d.height, i.height);
+            return new Dimension(w + 2 * PAD + in.left + in.right, h + 2 * PAD + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return preferredLayoutSize(parent);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            if (parent.getComponentCount() < 3 || !(parent instanceof JXHeader)) {
+                return;
+            }
+            Insets in = parent.getInsets();
+            int left = in.left + PAD;
+            int right = parent.getWidth() - in.right - PAD;
+            int top = in.top + PAD;
+            int height = Math.max(0, parent.getHeight() - in.top - in.bottom - 2 * PAD);
+            Dimension i = size(parent, 2);
+            if (i.width > 0) {
+                int ih = Math.min(height, i.height);
+                int iy = top + (height - ih) / 2;
+                if (((JXHeader) parent).iconPosition == IconPosition.LEFT) {
+                    parent.getComponent(2).setBounds(left, iy, i.width, ih);
+                    left += i.width + PAD;
+                } else {
+                    right -= i.width;
+                    parent.getComponent(2).setBounds(right, iy, i.width, ih);
+                    right -= PAD;
+                }
+            }
+            int width = Math.max(0, right - left);
+            Dimension t = size(parent, 0);
+            parent.getComponent(0).setBounds(left, top, width, t.height);
+            Dimension d = size(parent, 1);
+            parent.getComponent(1).setBounds(left + PAD, top + t.height, Math.max(0, width - PAD), d.height);
+        }
+    }
+
+    public void setTitle(String title) {
+        String old = this.title;
+        this.title = title;
+        titleLabel.setText(title == null ? "" : title);
+        firePropertyChange("title", old, title);
+        revalidate();
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setDescription(String description) {
+        String old = this.description;
+        this.description = description;
+        descriptionLabel.setText(description == null ? "" : description);
+        firePropertyChange("description", old, description);
+        revalidate();
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setIcon(Icon icon) {
+        Icon old = this.icon;
+        this.icon = icon;
+        iconLabel.setIcon(icon);
+        iconLabel.setVisible(icon != null);
+        firePropertyChange("icon", old, icon);
+        revalidate();
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    public void setTitleFont(Font font) {
+        Font old = titleFont;
+        titleFont = font;
+        titleLabel.setFont(font != null ? font : Fonts.defaultFont().deriveFont(Font.BOLD));
+        firePropertyChange("titleFont", old, font);
+        revalidate();
+    }
+
+    /// The font set for the title, or `null` for the default bold one.
+    public Font getTitleFont() {
+        return titleFont;
+    }
+
+    public void setDescriptionFont(Font font) {
+        Font old = descriptionFont;
+        descriptionFont = font;
+        descriptionLabel.setFont(font);
+        firePropertyChange("descriptionFont", old, font);
+        revalidate();
+    }
+
+    /// The font set for the description, or `null` for the default one.
+    public Font getDescriptionFont() {
+        return descriptionFont;
+    }
+
+    /// The color set for the title, or `null` for the theme's.
+    public Color getTitleForeground() {
+        return titleForeground;
+    }
+
+    public void setTitleForeground(Color titleForeground) {
+        Color old = this.titleForeground;
+        this.titleForeground = titleForeground;
+        titleLabel.setForeground(titleForeground);
+        firePropertyChange("titleForeground", old, titleForeground);
+    }
+
+    /// The color set for the description, or `null` for the theme's.
+    public Color getDescriptionForeground() {
+        return descriptionForeground;
+    }
+
+    public void setDescriptionForeground(Color descriptionForeground) {
+        Color old = this.descriptionForeground;
+        this.descriptionForeground = descriptionForeground;
+        descriptionLabel.setForeground(descriptionForeground);
+        firePropertyChange("descriptionForeground", old, descriptionForeground);
+    }
+
+    public IconPosition getIconPosition() {
+        return iconPosition;
+    }
+
+    public void setIconPosition(IconPosition iconPosition) {
+        IconPosition old = this.iconPosition;
+        this.iconPosition = iconPosition == null ? IconPosition.RIGHT : iconPosition;
+        firePropertyChange("iconPosition", old, this.iconPosition);
+        revalidate();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXHyperlink.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXHyperlink.java
new file mode 100644
index 00000000000..2280d8fc890
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXHyperlink.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink.AbstractHyperlinkAction;
+import com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink.HyperlinkAction;
+import java.net.URI;
+
+/// A button that looks like a link: no border, no fill, and text in one
+/// color before it was clicked and another after.
+///
+/// The link is a Codename One button with its border and background
+/// switched off and its text color set. With an
+/// [AbstractHyperlinkAction] the clicked state follows the action's
+/// visited flag, and its name; with any other action, or none, a click
+/// sets it.
+///
+/// ## What differs from SwingX
+///
+///  - The text is not underlined, neither always nor under the pointer.
+///  - [#setURI(URI)] opens the address through Codename One; see
+///    [HyperlinkAction].
+///  - Setting a foreground is overwritten by the next change of the
+///    clicked state, as the two link colors are the foreground.
+public class JXHyperlink extends JButton {
+
+    private Color unclickedColor = new Color(0, 0x33, 0xFF);
+    private Color clickedColor = new Color(0x99, 0, 0x99);
+    private boolean clicked;
+    private boolean overrulesActionOnClick;
+    private PropertyChangeListener actionFollower;
+
+    public JXHyperlink() {
+        this(null);
+    }
+
+    public JXHyperlink(Action action) {
+        super();
+        setBorderPainted(false);
+        setContentAreaFilled(false);
+        setFocusPainted(false);
+        setAction(action);
+        cn1ApplyColor();
+    }
+
+    /// Makes the link open `uri`, with the address as its text. `null`
+    /// leaves a disabled link without text.
+    public void setURI(URI uri) {
+        setAction(HyperlinkAction.createHyperlinkAction(uri));
+    }
+
+    @Override
+    public void setAction(Action a) {
+        Action old = getAction();
+        if (old != null && actionFollower != null) {
+            old.removePropertyChangeListener(actionFollower);
+        }
+        super.setAction(a);
+        if (a != null) {
+            if (actionFollower == null) {
+                actionFollower = createActionPropertyChangeListener(a);
+            }
+            a.addPropertyChangeListener(actionFollower);
+        }
+        configurePropertiesFromAction(a);
+    }
+
+    public Color getUnclickedColor() {
+        return unclickedColor;
+    }
+
+    public void setClickedColor(Color color) {
+        Color old = clickedColor;
+        clickedColor = color;
+        if (clicked) {
+            cn1ApplyColor();
+        }
+        firePropertyChange("clickedColor", old, color);
+    }
+
+    public Color getClickedColor() {
+        return clickedColor;
+    }
+
+    public void setUnclickedColor(Color color) {
+        Color old = unclickedColor;
+        unclickedColor = color;
+        if (!clicked) {
+            cn1ApplyColor();
+        }
+        firePropertyChange("unclickedColor", old, color);
+    }
+
+    /// Sets whether the link shows as followed.
+    public void setClicked(boolean clicked) {
+        boolean old = this.clicked;
+        this.clicked = clicked;
+        if (old != clicked) {
+            cn1ApplyColor();
+        }
+        firePropertyChange("clicked", old, clicked);
+    }
+
+    public boolean isClicked() {
+        return clicked;
+    }
+
+    /// With `true` a click marks the link as clicked whatever its action
+    /// says about having been visited.
+    public void setOverrulesActionOnClick(boolean overrule) {
+        boolean old = overrulesActionOnClick;
+        overrulesActionOnClick = overrule;
+        firePropertyChange("overrulesActionOnClick", old, overrule);
+    }
+
+    public boolean getOverrulesActionOnClick() {
+        return overrulesActionOnClick;
+    }
+
+    @Override
+    protected void fireActionPerformed(ActionEvent event) {
+        super.fireActionPerformed(event);
+        if (isAutoSetClicked()) {
+            setClicked(true);
+        }
+    }
+
+    /// Whether a click marks the link as clicked by itself: always when
+    /// the action is overruled, else unless the action keeps a visited
+    /// flag of its own.
+    protected boolean isAutoSetClicked() {
+        return getOverrulesActionOnClick() || !(getAction() instanceof AbstractHyperlinkAction);
+    }
+
+    /// The listener that keeps the link's text and clicked state those of
+    /// its action.
+    protected PropertyChangeListener createActionPropertyChangeListener(final Action a) {
+        return new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent evt) {
+                Action current = getAction();
+                if (current == null || evt.getSource() != current) {
+                    return;
+                }
+                String name = evt.getPropertyName();
+                if (AbstractHyperlinkAction.VISITED_KEY.equals(name)) {
+                    cn1FollowVisited(current);
+                } else if (Action.NAME.equals(name)) {
+                    Object text = current.getValue(Action.NAME);
+                    setText(text instanceof String ? (String) text : "");
+                } else if ("enabled".equals(name)) {
+                    setEnabled(current.isEnabled());
+                }
+            }
+        };
+    }
+
+    /// Takes the clicked state from the action's visited flag.
+    protected void configurePropertiesFromAction(Action a) {
+        cn1FollowVisited(a);
+    }
+
+    private void cn1FollowVisited(Action a) {
+        if (a instanceof AbstractHyperlinkAction) {
+            setClicked(((AbstractHyperlinkAction<?>) a).isVisited());
+        }
+    }
+
+    private void cn1ApplyColor() {
+        setForeground(clicked ? clickedColor : unclickedColor);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXLabel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXLabel.java
new file mode 100644
index 00000000000..ef1c449b548
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXLabel.java
@@ -0,0 +1,489 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.MiniHtml;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+
+/// A label that can wrap its text over several lines, draw it rotated,
+/// and have its background and its content drawn by painters.
+///
+/// ## How it is drawn
+///
+/// A label that neither wraps nor rotates is the Codename One label of
+/// [JLabel]. With line wrap or a rotation the label draws the icon and the
+/// text itself, in the label's font and foreground, inside the border and
+/// the padding the theme gives a label.
+///
+///  - The background painter draws first, under everything.
+///  - A foreground painter, when set, draws *instead of* the icon and
+///    text.
+///
+/// ## Line wrap
+///
+/// Lines break at spaces and at line feeds. The width they wrap to is the
+/// label's current width, or the maximum line span when one is set, and
+/// before the label has a width the text is measured unwrapped -- so a
+/// wrapping label reports its real height only once it has been laid out,
+/// as in SwingX.
+///
+/// ## What differs from SwingX
+///
+///  - A text that starts with `<html>` is drawn by [JLabel], which wraps
+///    it by itself; it is not rotated.
+///  - `JUSTIFY` aligns to the left: words are not spread.
+///  - The rotated text keeps its unrotated layout and is turned about the
+///    center of the label; the preferred size is the box that holds it.
+///  - A painter that changes is not observed: call `repaint()`.
+public class JXLabel extends JLabel {
+
+    /// No rotation.
+    public static final double NORMAL = 0;
+    /// Upside down.
+    public static final double INVERTED = Math.PI;
+    /// Reading bottom to top.
+    public static final double VERTICAL_LEFT = 3 * Math.PI / 2;
+    /// Reading top to bottom.
+    public static final double VERTICAL_RIGHT = Math.PI / 2;
+
+    /// How the lines of a wrapped text are aligned among themselves.
+    public enum TextAlignment {
+        LEFT(0),
+        CENTER(1),
+        RIGHT(2),
+        JUSTIFY(3);
+
+        private final int value;
+
+        TextAlignment(int value) {
+            this.value = value;
+        }
+
+        /// The paragraph alignment constant of the Swing text package
+        /// this alignment stands for.
+        public int getValue() {
+            return value;
+        }
+    }
+
+    private Painter foregroundPainter;
+    private Painter backgroundPainter;
+    private boolean paintBorderInsets = true;
+    private double textRotation = NORMAL;
+    private boolean multiLine;
+    private int maxLineSpan = -1;
+    private TextAlignment textAlignment = TextAlignment.LEFT;
+
+    public JXLabel() {
+        super();
+    }
+
+    public JXLabel(Icon image) {
+        super(image);
+    }
+
+    public JXLabel(Icon image, int horizontalAlignment) {
+        super(image, horizontalAlignment);
+    }
+
+    public JXLabel(String text) {
+        super(text);
+    }
+
+    public JXLabel(String text, Icon image, int horizontalAlignment) {
+        super(text, image, horizontalAlignment);
+    }
+
+    public JXLabel(String text, int horizontalAlignment) {
+        super(text, horizontalAlignment);
+    }
+
+    // ------------------------------------------------------------ painters
+
+    public final Painter getForegroundPainter() {
+        return foregroundPainter;
+    }
+
+    /// Sets the painter that draws the label's content in place of the
+    /// icon and text; `null` goes back to those.
+    public void setForegroundPainter(Painter painter) {
+        Painter old = foregroundPainter;
+        foregroundPainter = painter;
+        firePropertyChange("foregroundPainter", old, painter);
+        repaint();
+    }
+
+    public void setBackgroundPainter(Painter p) {
+        Painter old = backgroundPainter;
+        backgroundPainter = p;
+        firePropertyChange("backgroundPainter", old, p);
+        repaint();
+    }
+
+    public final Painter getBackgroundPainter() {
+        return backgroundPainter;
+    }
+
+    public boolean isPaintBorderInsets() {
+        return paintBorderInsets;
+    }
+
+    /// Whether the painters draw under the border too.
+    public void setPaintBorderInsets(boolean paintBorderInsets) {
+        boolean old = this.paintBorderInsets;
+        this.paintBorderInsets = paintBorderInsets;
+        firePropertyChange("paintBorderInsets", old, paintBorderInsets);
+        if (old != paintBorderInsets) {
+            repaint();
+        }
+    }
+
+    // ------------------------------------------------------------ text
+
+    public double getTextRotation() {
+        return textRotation;
+    }
+
+    /// Sets the angle, in radians and clockwise, the content is turned by.
+    public void setTextRotation(double textOrientation) {
+        double old = textRotation;
+        textRotation = textOrientation;
+        if (old != textOrientation) {
+            firePropertyChange("textRotation", Double.valueOf(old), Double.valueOf(textOrientation));
+            revalidate();
+            repaint();
+        }
+    }
+
+    public int getMaxLineSpan() {
+        return maxLineSpan;
+    }
+
+    /// Sets the width, in pixels, lines wrap to whatever the label's
+    /// width; -1 wraps to the label.
+    public void setMaxLineSpan(int maxLineSpan) {
+        int old = this.maxLineSpan;
+        this.maxLineSpan = maxLineSpan;
+        firePropertyChange("maxLineSpan", old, maxLineSpan);
+        if (old != maxLineSpan) {
+            revalidate();
+            repaint();
+        }
+    }
+
+    public void setLineWrap(boolean b) {
+        boolean old = multiLine;
+        multiLine = b;
+        if (old != b) {
+            firePropertyChange("lineWrap", old, b);
+            revalidate();
+            repaint();
+        }
+    }
+
+    public boolean isLineWrap() {
+        return multiLine;
+    }
+
+    public TextAlignment getTextAlignment() {
+        return textAlignment;
+    }
+
+    /// Sets how wrapped lines are aligned; `null` is to the left.
+    public void setTextAlignment(TextAlignment alignment) {
+        TextAlignment old = textAlignment;
+        textAlignment = alignment == null ? TextAlignment.LEFT : alignment;
+        firePropertyChange("textAlignment", old, textAlignment);
+        if (old != textAlignment) {
+            repaint();
+        }
+    }
+
+    // ------------------------------------------------------------ layout
+
+    /// Whether the label draws its own text rather than leaving it to the
+    /// Codename One label.
+    private boolean selfDrawn() {
+        return (multiLine || cn1Rotated()) && !MiniHtml.isHtml(getText());
+    }
+
+    private boolean cn1Rotated() {
+        double full = 2 * Math.PI;
+        double a = textRotation % full;
+        if (a < 0) {
+            a += full;
+        }
+        return a > 1e-9 && full - a > 1e-9;
+    }
+
+    private Font textFont() {
+        return getFont();
+    }
+
+    /// The border's insets and the padding the theme gives a label.
+    private Insets contentInsets() {
+        Insets in = getInsets();
+        Insets out = new Insets(in.top, in.left, in.bottom, in.right);
+        if (com.codename1.ui.Display.isInitialized()) {
+            com.codename1.ui.plaf.Style st = cn1Peer().getStyle();
+            out.top += Units.toLogicalCeil(st.getPaddingTop());
+            out.bottom += Units.toLogicalCeil(st.getPaddingBottom());
+            out.left += Units.toLogicalCeil(st.getPaddingLeftNoRTL());
+            out.right += Units.toLogicalCeil(st.getPaddingRightNoRTL());
+        }
+        return out;
+    }
+
+    /// The text broken into lines no wider than `limit`; a limit of 0 or
+    /// less breaks at line feeds only.
+    static ArrayList<String> cn1Wrap(String text, FontMetrics fm, int limit) {
+        ArrayList<String> lines = new ArrayList<String>();
+        if (text == null || text.length() == 0) {
+            return lines;
+        }
+        int start = 0;
+        int n = text.length();
+        while (start <= n) {
+            int end = text.indexOf('\n', start);
+            if (end < 0) {
+                end = n;
+            }
+            wrapParagraph(text.substring(start, end), fm, limit, lines);
+            start = end + 1;
+        }
+        return lines;
+    }
+
+    private static void wrapParagraph(String p, FontMetrics fm, int limit, ArrayList<String> lines) {
+        if (limit <= 0 || fm.stringWidth(p) <= limit) {
+            lines.add(p);
+            return;
+        }
+        StringBuilder line = new StringBuilder();
+        int i = 0;
+        int n = p.length();
+        while (i < n) {
+            int space = p.indexOf(' ', i);
+            if (space < 0) {
+                space = n;
+            }
+            String word = p.substring(i, space);
+            i = space + 1;
+            if (line.length() == 0) {
+                line.append(word);
+            } else if (fm.stringWidth(line.toString() + " " + word) <= limit) {
+                line.append(' ').append(word);
+            } else {
+                lines.add(line.toString());
+                line.setLength(0);
+                line.append(word);
+            }
+        }
+        lines.add(line.toString());
+    }
+
+    private Dimension iconSize() {
+        Icon ic = getIcon();
+        if (ic == null) {
+            return new Dimension(0, 0);
+        }
+        int gap = getText() == null || getText().length() == 0 ? 0 : getIconTextGap();
+        return new Dimension(ic.getIconWidth() + gap, ic.getIconHeight());
+    }
+
+    /// The width lines wrap to, or 0 for no wrapping.
+    private int wrapLimit(Insets in) {
+        if (!multiLine) {
+            return 0;
+        }
+        int icon = iconSize().width;
+        if (maxLineSpan > 0) {
+            return maxLineSpan;
+        }
+        boolean sideways = Math.abs(Math.sin(textRotation)) > 0.7071;
+        int across = sideways ? getHeight() - in.top - in.bottom : getWidth() - in.left - in.right;
+        return across > icon ? across - icon : 0;
+    }
+
+    /// The size of the unrotated content: icon, gap and text block.
+    private Dimension contentSize(ArrayList<String> lines, FontMetrics fm) {
+        int tw = 0;
+        for (int i = 0; i < lines.size(); i++) {
+            tw = Math.max(tw, fm.stringWidth(lines.get(i)));
+        }
+        int th = lines.size() * fm.getHeight();
+        Dimension icon = iconSize();
+        return new Dimension(icon.width + tw, Math.max(icon.height, th));
+    }
+
+    /// The preferred size of a label that draws itself: the box that
+    /// holds its wrapped and rotated content. Otherwise the Codename One
+    /// label's.
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet() || !selfDrawn()) {
+            return super.getPreferredSize();
+        }
+        Insets in = contentInsets();
+        FontMetrics fm = Fonts.metrics(textFont());
+        Dimension c = contentSize(cn1Wrap(getText(), fm, wrapLimit(in)), fm);
+        double sin = Math.abs(Math.sin(textRotation));
+        double cos = Math.abs(Math.cos(textRotation));
+        int w = (int) Math.ceil(c.width * cos + c.height * sin - 1e-6);
+        int h = (int) Math.ceil(c.width * sin + c.height * cos - 1e-6);
+        return new Dimension(w + in.left + in.right, h + in.top + in.bottom);
+    }
+
+    // ------------------------------------------------------------ paint
+
+    @SuppressWarnings("unchecked")
+    private void run(Painter p, Graphics g) {
+        if (p == null || !(g instanceof Graphics2D)) {
+            return;
+        }
+        Graphics copy = g.create();
+        try {
+            if (copy instanceof Graphics2D) {
+                Graphics2D g2 = (Graphics2D) copy;
+                int w = getWidth();
+                int h = getHeight();
+                if (!paintBorderInsets) {
+                    Insets i = getInsets();
+                    g2.translate(i.left, i.top);
+                    w -= i.left + i.right;
+                    h -= i.top + i.bottom;
+                }
+                if (w > 0 && h > 0) {
+                    p.paint(g2, this, w, h);
+                }
+            }
+        } finally {
+            copy.dispose();
+        }
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (backgroundPainter == null && foregroundPainter == null && !selfDrawn()) {
+            super.paintComponent(g);
+            return;
+        }
+        if (isOpaque() && getBackground() != null) {
+            g.setColor(getBackground());
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        run(backgroundPainter, g);
+        if (foregroundPainter != null) {
+            run(foregroundPainter, g);
+        } else if (selfDrawn()) {
+            paintContent(g);
+        } else {
+            // The Codename One label, which draws no background of its own
+            // unless the theme gives labels one.
+            super.paintComponent(g);
+        }
+    }
+
+    private void paintContent(Graphics g) {
+        Insets in = contentInsets();
+        Font f = textFont();
+        FontMetrics fm = Fonts.metrics(f);
+        ArrayList<String> lines = cn1Wrap(getText(), fm, wrapLimit(in));
+        Dimension c = contentSize(lines, fm);
+        int availW = getWidth() - in.left - in.right;
+        int availH = getHeight() - in.top - in.bottom;
+        Graphics copy = g.create();
+        try {
+            int x;
+            int y;
+            if (cn1Rotated() && copy instanceof Graphics2D) {
+                ((Graphics2D) copy).rotate(textRotation, in.left + availW / 2.0, in.top + availH / 2.0);
+                x = in.left + (availW - c.width) / 2;
+                y = in.top + (availH - c.height) / 2;
+            } else {
+                int ha = getHorizontalAlignment();
+                x = in.left;
+                if (ha == CENTER) {
+                    x += (availW - c.width) / 2;
+                } else if (ha == RIGHT || ha == TRAILING) {
+                    x += availW - c.width;
+                }
+                int va = getVerticalAlignment();
+                y = in.top;
+                if (va == CENTER) {
+                    y += (availH - c.height) / 2;
+                } else if (va == BOTTOM) {
+                    y += availH - c.height;
+                }
+            }
+            Icon ic = getIcon();
+            if (!isEnabled() && getDisabledIcon() != null) {
+                ic = getDisabledIcon();
+            }
+            Dimension icon = iconSize();
+            int textWidth = c.width - icon.width;
+            int textX = x;
+            int ht = getHorizontalTextPosition();
+            if (ic != null) {
+                int iconX = x;
+                if (ht == LEFT || ht == LEADING) {
+                    iconX = x + c.width - ic.getIconWidth();
+                } else {
+                    textX = x + icon.width;
+                }
+                ic.paintIcon(this, copy, iconX, y + (c.height - ic.getIconHeight()) / 2);
+            }
+            copy.setFont(f);
+            Color fg = isEnabled() ? getForeground() : Color.GRAY;
+            if (fg != null) {
+                copy.setColor(fg);
+            }
+            int lineY = y + (c.height - lines.size() * fm.getHeight()) / 2 + fm.getAscent();
+            for (int i = 0; i < lines.size(); i++) {
+                String line = lines.get(i);
+                int lx = textX;
+                if (textAlignment == TextAlignment.CENTER) {
+                    lx += (textWidth - fm.stringWidth(line)) / 2;
+                } else if (textAlignment == TextAlignment.RIGHT) {
+                    lx += textWidth - fm.stringWidth(line);
+                }
+                copy.drawString(line, lx, lineY);
+                lineY += fm.getHeight();
+            }
+        } finally {
+            copy.dispose();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXList.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXList.java
new file mode 100644
index 00000000000..eb445a425f6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXList.java
@@ -0,0 +1,784 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.AbstractListModel;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.ListCellRenderer;
+import com.codename1.desktopcompat.javax.swing.ListModel;
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.ListDataEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListDataListener;
+import com.codename1.desktopcompat.javax.swing.event.RowSorterEvent;
+import com.codename1.desktopcompat.javax.swing.event.RowSorterListener;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.CompoundHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.Highlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultListRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValues;
+import com.codename1.desktopcompat.org.jdesktop.swingx.rollover.RolloverProducer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.ListSortController;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.SortController;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.StringValueRegistry;
+import java.util.Comparator;
+import java.util.Vector;
+
+/// A list with highlighters, sorting and filtering, and rollover.
+///
+/// ## Sorting and filtering
+///
+/// A row sorter stands between the model and what the list shows. It is
+/// off until [#setAutoCreateRowSorter(boolean)] or
+/// [#setRowSorter(RowSorter)] gives the list one. From then on the
+/// indexes of the list -- of its selection, of [#getElementAt(int)], of
+/// a cell renderer -- are view indexes, [#getElementCount()] is the
+/// number of elements shown, and [#convertIndexToModel(int)] leads back
+/// to the model, which [#getModel()] still answers unchanged.
+///
+/// The selection follows its elements through a change of order or
+/// filter; elements that are filtered away leave it.
+///
+/// ## Highlighters
+///
+/// The renderer set is wrapped: [#getCellRenderer()] answers the wrapper
+/// that applies the highlighters and [#getWrappedCellRenderer()] the
+/// renderer that was set. The default is a SwingX renderer.
+///
+/// ## Not here
+///
+/// Searching and the look and feel hooks are absent.
+public class JXList extends JList {
+
+    public static final String EXECUTE_BUTTON_ACTIONCOMMAND = "executeButtonAction";
+
+    protected CompoundHighlighter compoundHighlighter;
+    protected ComponentAdapter dataAdapter;
+
+    private boolean cn1Ready;
+    private ViewModel cn1View;
+    private ListModel cn1Model;
+    private RowSorter<? extends ListModel> cn1Sorter;
+    private boolean cn1AutoSorter;
+    private boolean cn1Sortable;
+    private boolean cn1SortsOnUpdates;
+    private SortOrder[] cn1SortCycle;
+    private Comparator<?> cn1Comparator;
+    private RowFilter<?, ?> cn1RowFilter;
+    private boolean cn1InModelEvent;
+    private StringValueRegistry cn1Registry;
+    private ChangeListener cn1HighlighterListener;
+    private DelegatingRenderer cn1Renderer;
+    private boolean cn1Rollover;
+    private RolloverProducer cn1RolloverProducer;
+
+    private final ListDataListener cn1ModelListener = new ListDataListener() {
+        @Override
+        public void intervalAdded(ListDataEvent e) {
+            cn1ModelChanged(e);
+        }
+
+        @Override
+        public void intervalRemoved(ListDataEvent e) {
+            cn1ModelChanged(e);
+        }
+
+        @Override
+        public void contentsChanged(ListDataEvent e) {
+            cn1ModelChanged(e);
+        }
+    };
+
+    private final RowSorterListener cn1SorterListener = new RowSorterListener() {
+        @Override
+        public void sorterChanged(RowSorterEvent e) {
+            cn1SorterChanged(e);
+        }
+    };
+
+    public JXList() {
+        this(false);
+    }
+
+    public JXList(ListModel dataModel) {
+        this(dataModel, false);
+    }
+
+    public JXList(Object[] listData) {
+        this(listData, false);
+    }
+
+    public JXList(Vector<?> listData) {
+        this(listData, false);
+    }
+
+    @SuppressWarnings("unchecked")
+    public JXList(boolean autoCreateRowSorter) {
+        super(new ViewModel());
+        cn1Init(autoCreateRowSorter);
+    }
+
+    @SuppressWarnings("unchecked")
+    public JXList(ListModel dataModel, boolean autoCreateRowSorter) {
+        super(new ViewModel());
+        if (dataModel == null) {
+            throw new IllegalArgumentException("dataModel must be non null");
+        }
+        cn1Init(autoCreateRowSorter);
+        setModel(dataModel);
+    }
+
+    @SuppressWarnings("unchecked")
+    public JXList(Object[] listData, boolean autoCreateRowSorter) {
+        super(new ViewModel());
+        if (listData == null) {
+            throw new IllegalArgumentException("listData must be non null");
+        }
+        cn1Init(autoCreateRowSorter);
+        setListData(listData);
+    }
+
+    @SuppressWarnings("unchecked")
+    public JXList(Vector<?> listData, boolean autoCreateRowSorter) {
+        super(new ViewModel());
+        if (listData == null) {
+            throw new IllegalArgumentException("listData must be non null");
+        }
+        cn1Init(autoCreateRowSorter);
+        setListData(listData);
+    }
+
+    private void cn1Init(boolean autoCreateRowSorter) {
+        ListModel view = super.getModel();
+        if (view instanceof ViewModel) {
+            cn1View = (ViewModel) view;
+        }
+        cn1Sortable = true;
+        cn1SortsOnUpdates = true;
+        cn1Ready = true;
+        setModel(new EmptyModel());
+        setCellRenderer(createDefaultCellRenderer());
+        setAutoCreateRowSorter(autoCreateRowSorter);
+    }
+
+    private static final class EmptyModel extends AbstractListModel<Object> {
+        @Override
+        public int getSize() {
+            return 0;
+        }
+
+        @Override
+        public Object getElementAt(int index) {
+            return null;
+        }
+    }
+
+    /// What the plain list underneath shows: the model through the
+    /// sorter.
+    private static final class ViewModel extends AbstractListModel<Object> {
+        private ListModel source;
+        private RowSorter<? extends ListModel> sorter;
+
+        @Override
+        public int getSize() {
+            if (source == null) {
+                return 0;
+            }
+            return sorter != null ? sorter.getViewRowCount() : source.getSize();
+        }
+
+        @Override
+        public Object getElementAt(int index) {
+            if (source == null) {
+                return null;
+            }
+            int model = sorter != null ? sorter.convertRowIndexToModel(index) : index;
+            return model >= 0 && model < source.getSize() ? source.getElementAt(model) : null;
+        }
+
+        void changed() {
+            fireContentsChanged(this, 0, Math.max(0, getSize() - 1));
+        }
+
+        void forward(ListDataEvent e) {
+            if (e.getType() == ListDataEvent.INTERVAL_ADDED) {
+                fireIntervalAdded(this, e.getIndex0(), e.getIndex1());
+            } else if (e.getType() == ListDataEvent.INTERVAL_REMOVED) {
+                fireIntervalRemoved(this, e.getIndex0(), e.getIndex1());
+            } else {
+                fireContentsChanged(this, e.getIndex0(), e.getIndex1());
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ model
+
+    /// The model that was set, whatever the sorter makes of it.
+    @Override
+    public ListModel getModel() {
+        return cn1Model != null ? cn1Model : super.getModel();
+    }
+
+    @Override
+    public void setModel(ListModel model) {
+        if (model == null) {
+            throw new IllegalArgumentException("model must be non null");
+        }
+        if (!cn1Ready || cn1View == null) {
+            return;
+        }
+        ListModel old = cn1Model;
+        if (old != null) {
+            old.removeListDataListener(cn1ModelListener);
+        }
+        cn1Model = model;
+        model.addListDataListener(cn1ModelListener);
+        cn1View.source = model;
+        if (cn1AutoSorter) {
+            setRowSorter(createDefaultRowSorter());
+        }
+        clearSelection();
+        cn1View.changed();
+        firePropertyChange("model", old, model);
+    }
+
+    private void cn1ModelChanged(ListDataEvent e) {
+        if (cn1Sorter == null) {
+            cn1View.forward(e);
+            return;
+        }
+        cn1InModelEvent = true;
+        try {
+            int first = e.getIndex0();
+            int last = e.getIndex1();
+            if (first > last) {
+                int t = first;
+                first = last;
+                last = t;
+            }
+            if (e.getType() == ListDataEvent.INTERVAL_ADDED && first >= 0) {
+                cn1Sorter.rowsInserted(first, last);
+            } else if (e.getType() == ListDataEvent.INTERVAL_REMOVED && first >= 0) {
+                cn1Sorter.rowsDeleted(first, last);
+            } else {
+                cn1Sorter.allRowsChanged();
+            }
+        } finally {
+            cn1InModelEvent = false;
+        }
+        clearSelection();
+        cn1View.changed();
+    }
+
+    private void cn1SorterChanged(RowSorterEvent e) {
+        if (cn1InModelEvent || e.getType() != RowSorterEvent.Type.SORTED) {
+            return;
+        }
+        int[] selected = getSelectedIndices();
+        int[] model = new int[selected.length];
+        for (int i = 0; i < selected.length; i++) {
+            model[i] = e.convertPreviousRowIndexToModel(selected[i]);
+        }
+        clearSelection();
+        cn1View.changed();
+        int count = getModel().getSize();
+        for (int i = 0; i < model.length; i++) {
+            if (model[i] >= 0 && model[i] < count) {
+                int view = cn1Sorter.convertRowIndexToView(model[i]);
+                if (view >= 0) {
+                    addSelectionInterval(view, view);
+                }
+            }
+        }
+    }
+
+    /// The element shown at a view index.
+    public Object getElementAt(int viewIndex) {
+        return cn1View.getElementAt(viewIndex);
+    }
+
+    /// The number of elements shown.
+    public int getElementCount() {
+        return cn1View.getSize();
+    }
+
+    public int convertIndexToModel(int viewIndex) {
+        return cn1Sorter != null ? cn1Sorter.convertRowIndexToModel(viewIndex) : viewIndex;
+    }
+
+    /// The view index of a model index, -1 when it is filtered away.
+    public int convertIndexToView(int modelIndex) {
+        return cn1Sorter != null ? cn1Sorter.convertRowIndexToView(modelIndex) : modelIndex;
+    }
+
+    // ------------------------------------------------------------ sorting
+
+    public boolean getAutoCreateRowSorter() {
+        return cn1AutoSorter;
+    }
+
+    /// Whether the list makes a sort controller of its own for every
+    /// model it is given.
+    public void setAutoCreateRowSorter(boolean autoCreateRowSorter) {
+        boolean old = cn1AutoSorter;
+        cn1AutoSorter = autoCreateRowSorter;
+        if (autoCreateRowSorter) {
+            setRowSorter(createDefaultRowSorter());
+        }
+        firePropertyChange("autoCreateRowSorter", old, autoCreateRowSorter);
+    }
+
+    protected RowSorter<? extends ListModel> createDefaultRowSorter() {
+        return new ListSortController<ListModel>(getModel());
+    }
+
+    public RowSorter<? extends ListModel> getRowSorter() {
+        return cn1Sorter;
+    }
+
+    /// Sets the sorter, which must be one of this list's model; `null`
+    /// shows the model as it is.
+    public void setRowSorter(RowSorter<? extends ListModel> sorter) {
+        RowSorter<? extends ListModel> old = cn1Sorter;
+        if (old != null) {
+            old.removeRowSorterListener(cn1SorterListener);
+        }
+        cn1Sorter = sorter;
+        if (sorter != null) {
+            sorter.addRowSorterListener(cn1SorterListener);
+        }
+        cn1View.sorter = sorter;
+        configureSorterProperties();
+        clearSelection();
+        cn1View.changed();
+        firePropertyChange("rowSorter", old, sorter);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    protected void configureSorterProperties() {
+        if (!getControlsSorterProperties()) {
+            return;
+        }
+        SortController controller = getSortController();
+        controller.setStringValueProvider(getStringValueRegistry());
+        controller.setSortable(cn1Sortable);
+        controller.setSortsOnUpdates(cn1SortsOnUpdates);
+        controller.setComparator(0, cn1Comparator);
+        if (cn1SortCycle != null) {
+            controller.setSortOrderCycle(cn1SortCycle);
+        }
+        controller.setRowFilter(cn1RowFilter);
+    }
+
+    public void setSortable(boolean sortable) {
+        boolean old = cn1Sortable;
+        cn1Sortable = sortable;
+        if (getControlsSorterProperties()) {
+            getSortController().setSortable(sortable);
+        }
+        firePropertyChange("sortable", old, sortable);
+    }
+
+    public boolean isSortable() {
+        return cn1Sortable;
+    }
+
+    public void setSortsOnUpdates(boolean sortsOnUpdates) {
+        boolean old = cn1SortsOnUpdates;
+        cn1SortsOnUpdates = sortsOnUpdates;
+        if (getControlsSorterProperties()) {
+            getSortController().setSortsOnUpdates(sortsOnUpdates);
+        }
+        firePropertyChange("sortsOnUpdates", old, sortsOnUpdates);
+    }
+
+    public boolean getSortsOnUpdates() {
+        return cn1SortsOnUpdates;
+    }
+
+    public void setSortOrderCycle(SortOrder... cycle) {
+        SortOrder[] copy = new SortOrder[cycle == null ? 0 : cycle.length];
+        for (int i = 0; i < copy.length; i++) {
+            copy[i] = cycle[i];
+        }
+        cn1SortCycle = copy;
+        if (getControlsSorterProperties()) {
+            getSortController().setSortOrderCycle(copy);
+        }
+    }
+
+    public SortOrder[] getSortOrderCycle() {
+        SortOrder[] from = cn1SortCycle;
+        if (from == null) {
+            return ListSortController.getDefaultSortOrderCycle();
+        }
+        SortOrder[] copy = new SortOrder[from.length];
+        for (int i = 0; i < copy.length; i++) {
+            copy[i] = from[i];
+        }
+        return copy;
+    }
+
+    public Comparator<?> getComparator() {
+        return cn1Comparator;
+    }
+
+    /// Sets what the elements are compared by; `null` goes back to
+    /// their natural order, or their strings when they have none.
+    public void setComparator(Comparator<?> comparator) {
+        Comparator<?> old = cn1Comparator;
+        cn1Comparator = comparator;
+        updateSortAfterComparatorChange();
+        firePropertyChange("comparator", old, comparator);
+    }
+
+    /// Hands the comparator to the sort controller and sorts again.
+    protected void updateSortAfterComparatorChange() {
+        if (!getControlsSorterProperties()) {
+            return;
+        }
+        getSortController().setComparator(0, cn1Comparator);
+        RowSorter<? extends ListModel> sorter = getRowSorter();
+        if (sorter != null) {
+            sorter.allRowsChanged();
+        }
+    }
+
+    /// Shows only the elements the filter includes; `null` shows all.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public <R extends ListModel> void setRowFilter(RowFilter<? super R, ? super Integer> filter) {
+        cn1RowFilter = filter;
+        if (hasSortController()) {
+            SortController controller = getSortController();
+            controller.setRowFilter(filter);
+        }
+    }
+
+    public RowFilter<?, ?> getRowFilter() {
+        return hasSortController() ? getSortController().getRowFilter() : cn1RowFilter;
+    }
+
+    public void resetSortOrder() {
+        if (hasSortController()) {
+            getSortController().resetSortOrders();
+        }
+    }
+
+    /// Moves the list to its next sort order.
+    public void toggleSortOrder() {
+        if (hasSortController()) {
+            getSortController().toggleSortOrder(0);
+        }
+    }
+
+    public void setSortOrder(SortOrder sortOrder) {
+        if (hasSortController()) {
+            getSortController().setSortOrder(0, sortOrder);
+        }
+    }
+
+    public SortOrder getSortOrder() {
+        if (hasSortController()) {
+            return getSortController().getSortOrder(0);
+        }
+        return SortOrder.UNSORTED;
+    }
+
+    @SuppressWarnings("unchecked")
+    protected SortController<? extends ListModel> getSortController() {
+        if (cn1Sorter instanceof SortController) {
+            return (SortController<? extends ListModel>) cn1Sorter;
+        }
+        return null;
+    }
+
+    protected boolean hasSortController() {
+        return cn1Sorter instanceof SortController;
+    }
+
+    protected boolean getControlsSorterProperties() {
+        return hasSortController() && getAutoCreateRowSorter();
+    }
+
+    // ------------------------------------------------------------ rollover
+
+    public void setRolloverEnabled(boolean rolloverEnabled) {
+        boolean old = cn1Rollover;
+        if (old == rolloverEnabled) {
+            return;
+        }
+        cn1Rollover = rolloverEnabled;
+        if (rolloverEnabled) {
+            cn1RolloverProducer = createRolloverProducer();
+            cn1RolloverProducer.install(this);
+        } else {
+            if (cn1RolloverProducer != null) {
+                cn1RolloverProducer.release(this);
+                cn1RolloverProducer = null;
+            }
+            putClientProperty(RolloverProducer.ROLLOVER_KEY, null);
+            repaint();
+        }
+        firePropertyChange("rolloverEnabled", old, rolloverEnabled);
+    }
+
+    public boolean isRolloverEnabled() {
+        return cn1Rollover;
+    }
+
+    protected RolloverProducer createRolloverProducer() {
+        return new RolloverProducer() {
+            @Override
+            protected void updateRolloverPoint(JComponent component, Point mousePoint) {
+                int row = locationToIndex(mousePoint);
+                if (row >= 0) {
+                    Rectangle cell = getCellBounds(row, row);
+                    if (cell == null || !cell.contains(mousePoint)) {
+                        row = -1;
+                    }
+                }
+                rollover.setLocation(row >= 0 ? 0 : -1, row);
+            }
+
+            @Override
+            protected void updateClientProperty(JComponent component, String property, boolean fireAlways) {
+                Object before = component.getClientProperty(property);
+                super.updateClientProperty(component, property, fireAlways);
+                Object after = component.getClientProperty(property);
+                if (before == null ? after != null : !before.equals(after)) {
+                    component.repaint();
+                }
+            }
+
+            @Override
+            public void mouseExited(com.codename1.desktopcompat.java.awt.event.MouseEvent e) {
+                super.mouseExited(e);
+                repaint();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ highlighters
+
+    protected ComponentAdapter getComponentAdapter() {
+        if (dataAdapter == null) {
+            dataAdapter = new ListAdapter(this);
+        }
+        return dataAdapter;
+    }
+
+    /// The adapter, pointed at a view index.
+    protected ComponentAdapter getComponentAdapter(int index) {
+        ComponentAdapter adapter = getComponentAdapter();
+        adapter.column = 0;
+        adapter.row = index;
+        return adapter;
+    }
+
+    public void setHighlighters(Highlighter... highlighters) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().setHighlighters(highlighters);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public Highlighter[] getHighlighters() {
+        return getCompoundHighlighter().getHighlighters();
+    }
+
+    public void addHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().addHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public void removeHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().removeHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    protected CompoundHighlighter getCompoundHighlighter() {
+        if (compoundHighlighter == null) {
+            compoundHighlighter = new CompoundHighlighter();
+            compoundHighlighter.addChangeListener(getHighlighterChangeListener());
+        }
+        return compoundHighlighter;
+    }
+
+    protected ChangeListener getHighlighterChangeListener() {
+        if (cn1HighlighterListener == null) {
+            cn1HighlighterListener = createHighlighterChangeListener();
+        }
+        return cn1HighlighterListener;
+    }
+
+    protected ChangeListener createHighlighterChangeListener() {
+        return new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                repaint();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ strings and renderer
+
+    protected StringValueRegistry getStringValueRegistry() {
+        if (cn1Registry == null) {
+            cn1Registry = createDefaultStringValueRegistry();
+        }
+        return cn1Registry;
+    }
+
+    protected StringValueRegistry createDefaultStringValueRegistry() {
+        return new StringValueRegistry();
+    }
+
+    /// The text the list shows for the element at a view index.
+    public String getStringAt(int row) {
+        Object value = getElementAt(row);
+        ListCellRenderer renderer = getWrappedCellRenderer();
+        if (renderer instanceof StringValue) {
+            return ((StringValue) renderer).getString(value);
+        }
+        return StringValues.TO_STRING.getString(value);
+    }
+
+    protected ListCellRenderer createDefaultCellRenderer() {
+        return new DefaultListRenderer();
+    }
+
+    /// The renderer the list paints with: a wrapper that applies the
+    /// highlighters to what the renderer that was set answers.
+    @Override
+    public ListCellRenderer getCellRenderer() {
+        return cn1Renderer != null ? cn1Renderer : super.getCellRenderer();
+    }
+
+    /// The renderer that was set.
+    public ListCellRenderer getWrappedCellRenderer() {
+        return cn1Renderer != null ? cn1Renderer.delegate : super.getCellRenderer();
+    }
+
+    /// Sets the renderer; `null` is the default one.
+    @Override
+    @SuppressWarnings("unchecked")
+    public void setCellRenderer(ListCellRenderer renderer) {
+        if (!cn1Ready) {
+            super.setCellRenderer(renderer);
+            return;
+        }
+        ListCellRenderer delegate = renderer != null ? renderer : createDefaultCellRenderer();
+        if (cn1Renderer == null) {
+            cn1Renderer = new DelegatingRenderer();
+        }
+        cn1Renderer.delegate = delegate;
+        getStringValueRegistry().setStringValue(delegate instanceof StringValue ? (StringValue) delegate : null, 0);
+        super.setCellRenderer(cn1Renderer);
+    }
+
+    private final class DelegatingRenderer implements ListCellRenderer<Object> {
+        private ListCellRenderer delegate;
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,
+                boolean cellHasFocus) {
+            Component stamp = delegate.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if (stamp != null && compoundHighlighter != null && index >= 0) {
+                stamp = compoundHighlighter.highlight(stamp, getComponentAdapter(index));
+            }
+            return stamp;
+        }
+    }
+
+    // ------------------------------------------------------------ adapter
+
+    private static final class ListAdapter extends ComponentAdapter {
+
+        private final JXList list;
+
+        ListAdapter(JXList list) {
+            super(list);
+            this.list = list;
+        }
+
+        @Override
+        public int getRowCount() {
+            return list.getModel().getSize();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return list.getModel().getElementAt(row);
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            return false;
+        }
+
+        @Override
+        public String getStringAt(int row, int column) {
+            return list.getStringValueRegistry().getStringValue(row, column).getString(getValueAt(row, column));
+        }
+
+        @Override
+        public Rectangle getCellBounds() {
+            return list.getCellBounds(row, row);
+        }
+
+        @Override
+        public boolean hasFocus() {
+            return list.isFocusOwner() && row == list.getLeadSelectionIndex();
+        }
+
+        @Override
+        public boolean isSelected() {
+            return list.isSelectedIndex(row);
+        }
+
+        @Override
+        public boolean isEditable() {
+            return false;
+        }
+
+        @Override
+        public int convertRowIndexToView(int rowModelIndex) {
+            return list.convertIndexToView(rowModelIndex);
+        }
+
+        @Override
+        public int convertRowIndexToModel(int rowViewIndex) {
+            return list.convertIndexToModel(rowViewIndex);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXMonthView.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXMonthView.java
new file mode 100644
index 00000000000..d56d54f7c61
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXMonthView.java
@@ -0,0 +1,1176 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.CalendarUtils;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DateSelectionModel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DateSelectionModel.SelectionMode;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DaySelectionModel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionListener;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.SortedSet;
+import java.util.TimeZone;
+import java.util.TreeSet;
+
+/// One month as a grid of days, with a selection of dates.
+///
+/// ## How it is drawn
+///
+/// The view paints itself in the colors of the Codename One theme: a
+/// title row with the month and year and, when the view is traversable, an
+/// arrow at each end; a row of day names; six rows of days. The eight rows
+/// and seven columns divide the component's size evenly, and the preferred
+/// size gives every box room for a finger on a touch screen.
+///
+/// ## Input
+///
+/// With a mouse a press selects the day under it and a drag extends the
+/// selection in the interval modes; the release commits. Shift extends
+/// from the last pressed day, and Control or Meta adds or removes a day in
+/// the multiple interval mode. On a touch screen a tap selects and
+/// commits, and a drag is handed to the enclosing scroll pane. The arrows
+/// move a month. The arrow keys move the selected day, Page Up and Page
+/// Down move a month, Enter commits and Escape cancels.
+///
+/// ## What differs from SwingX
+///
+///  - One month is shown whatever the preferred row and column counts,
+///    which are recorded only, as are the zoomable flag and the week
+///    number flag: there is no month zoom and no week number column.
+///  - The first day of the week starts as Sunday whatever the locale, and
+///    the locale is recorded only; month and day names come from the
+///    device's date formatter.
+///  - There is no UI delegate, and "today" is not advanced by a timer:
+///    it is the day the view was created or last told.
+///  - A day beyond the bounds or among the unselectable dates is drawn
+///    dimmed and ignores the pointer.
+public class JXMonthView extends JComponent {
+
+    public static final String COMMIT_KEY = "monthViewCommit";
+    public static final String CANCEL_KEY = "monthViewCancel";
+    public static final String BOX_PADDING_X = "boxPaddingX";
+    public static final String BOX_PADDING_Y = "boxPaddingY";
+    public static final String DAYS_OF_THE_WEEK = "daysOfTheWeek";
+    public static final String SELECTION_MODEL = "selectionModel";
+    public static final String TRAVERSABLE = "traversable";
+    public static final String FLAGGED_DATES = "flaggedDates";
+    public static final String uiClassID = "MonthViewUI";
+    public static final int DAYS_IN_WEEK = 7;
+    public static final int MONTHS_IN_YEAR = 12;
+
+    private static final int ROWS = 8;
+    private static final int TOUCH_BOX = 40;
+
+    private DateSelectionModel model;
+    private final DateSelectionListener modelListener = new DateSelectionListener() {
+        @Override
+        public void valueChanged(DateSelectionEvent ev) {
+            repaint();
+        }
+    };
+    private Date firstDisplayedDay;
+    private Date today;
+    private final TreeSet<Date> flagged = new TreeSet<Date>();
+    private boolean traversable;
+    private boolean zoomable;
+    private boolean showingLeadingDays;
+    private boolean showingTrailingDays;
+    private boolean showingWeekNumber;
+    private boolean componentInputMapEnabled;
+    private String[] daysOfTheWeek;
+    private int boxPaddingX = 3;
+    private int boxPaddingY = 3;
+    private Color selectionBackground;
+    private Color selectionForeground;
+    private Color todayBackground;
+    private Color monthStringBackground;
+    private Color monthStringForeground;
+    private Color daysOfTheWeekForeground;
+    private Color flaggedDayForeground;
+    private final Color[] dayForeground = new Color[DAYS_IN_WEEK + 1];
+    private Insets monthStringInsets = new Insets(0, 0, 0, 0);
+    private int preferredColumnCount = 1;
+    private int preferredRowCount = 1;
+    private Date anchor;
+    private boolean pressTouch;
+    private boolean pressOnDay;
+
+    public JXMonthView() {
+        this(null, null, null);
+    }
+
+    public JXMonthView(Locale locale) {
+        this(null, null, locale);
+    }
+
+    public JXMonthView(Date firstDisplayedDay) {
+        this(firstDisplayedDay, null, null);
+    }
+
+    public JXMonthView(Date firstDisplayedDay, DateSelectionModel model) {
+        this(firstDisplayedDay, model, null);
+    }
+
+    /// Shows the month of `firstDisplayedDay`, or the current month for
+    /// `null`, over `model`, or a new [DaySelectionModel] for `null`.
+    public JXMonthView(Date firstDisplayedDay, DateSelectionModel model, Locale locale) {
+        this.model = model != null ? model : new DaySelectionModel(locale);
+        this.model.addDateSelectionListener(modelListener);
+        Date now = new Date();
+        today = startOfDay(now);
+        this.firstDisplayedDay = startOfMonth(firstDisplayedDay != null ? firstDisplayedDay : now);
+        setFocusable(true);
+        enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
+    }
+
+    // ------------------------------------------------------------ calendar
+
+    private Date startOfDay(Date d) {
+        return CalendarUtils.startOfDay(model.getCalendar(), d);
+    }
+
+    private Date startOfMonth(Date d) {
+        Calendar c = model.getCalendar();
+        c.setTime(d);
+        CalendarUtils.startOfMonth(c);
+        return c.getTime();
+    }
+
+    /// The first millisecond of the given day of the displayed month.
+    private Date dayOfMonth(int day) {
+        Calendar c = model.getCalendar();
+        c.setTime(firstDisplayedDay);
+        c.set(Calendar.DAY_OF_MONTH, day);
+        CalendarUtils.startOfDay(c);
+        return c.getTime();
+    }
+
+    private int daysInMonth() {
+        Calendar c = model.getCalendar();
+        c.setTime(firstDisplayedDay);
+        CalendarUtils.endOfMonth(c);
+        return c.get(Calendar.DAY_OF_MONTH);
+    }
+
+    /// How many boxes of the first week row come before day one.
+    private int leadingBoxes() {
+        Calendar c = model.getCalendar();
+        c.setTime(firstDisplayedDay);
+        int dow = c.get(Calendar.DAY_OF_WEEK);
+        return (dow - model.getFirstDayOfWeek() + DAYS_IN_WEEK) % DAYS_IN_WEEK;
+    }
+
+    private Date addMonths(Date from, int months) {
+        Calendar c = model.getCalendar();
+        c.setTime(startOfMonth(from));
+        c.add(Calendar.MONTH, months);
+        CalendarUtils.startOfMonth(c);
+        return c.getTime();
+    }
+
+    private Date addDays(Date from, int days) {
+        Calendar c = model.getCalendar();
+        c.setTime(from);
+        c.add(Calendar.DAY_OF_MONTH, days);
+        CalendarUtils.startOfDay(c);
+        return c.getTime();
+    }
+
+    /// Records the locale in the selection model; names are not
+    /// translated by it.
+    public void setLocale(Locale locale) {
+        model.setLocale(locale);
+        repaint();
+    }
+
+    /// A calendar of the model's time zone, set to the first displayed
+    /// day. It is a new object on every call.
+    public Calendar getCalendar() {
+        Calendar c = model.getCalendar();
+        c.setTime(firstDisplayedDay);
+        return c;
+    }
+
+    public TimeZone getTimeZone() {
+        return model.getTimeZone();
+    }
+
+    public void setTimeZone(TimeZone tz) {
+        TimeZone old = getTimeZone();
+        if (tz == null || tz.equals(old)) {
+            return;
+        }
+        Date shown = firstDisplayedDay;
+        model.setTimeZone(tz);
+        firstDisplayedDay = shown;
+        updateDatesAfterTimeZoneChange(old);
+        firePropertyChange("timeZone", old, tz);
+        repaint();
+    }
+
+    public int getFirstDayOfWeek() {
+        return model.getFirstDayOfWeek();
+    }
+
+    /// Sets the day the week rows start with, one of the `Calendar` day
+    /// constants.
+    public void setFirstDayOfWeek(int firstDayOfWeek) {
+        int old = getFirstDayOfWeek();
+        model.setFirstDayOfWeek(firstDayOfWeek);
+        firePropertyChange("firstDayOfWeek", old, getFirstDayOfWeek());
+        repaint();
+    }
+
+    /// The date the displayed month was last asked for with.
+    protected Date getAnchorDate() {
+        return new Date(firstDisplayedDay.getTime());
+    }
+
+    /// Reads the displayed month and today again in the new time zone and
+    /// forgets the flagged dates, which meant days of the old one.
+    protected void updateDatesAfterTimeZoneChange(TimeZone oldTimeZone) {
+        firstDisplayedDay = startOfMonth(firstDisplayedDay);
+        today = startOfDay(today);
+        flagged.clear();
+    }
+
+    /// The first millisecond of the last day of the displayed month.
+    public Date getLastDisplayedDay() {
+        return dayOfMonth(daysInMonth());
+    }
+
+    /// The first millisecond of the displayed month.
+    public Date getFirstDisplayedDay() {
+        return new Date(firstDisplayedDay.getTime());
+    }
+
+    /// Shows the month `date` falls in.
+    public void setFirstDisplayedDay(Date date) {
+        Date old = firstDisplayedDay;
+        Date first = startOfMonth(date);
+        if (first.equals(old)) {
+            return;
+        }
+        firstDisplayedDay = first;
+        firePropertyChange("firstDisplayedDay", old, getFirstDisplayedDay());
+        repaint();
+    }
+
+    /// Shows the month of `date` if it is not the one displayed.
+    public void ensureDateVisible(Date date) {
+        if (date.getTime() < firstDisplayedDay.getTime()
+                || date.getTime() >= addMonths(firstDisplayedDay, 1).getTime()) {
+            setFirstDisplayedDay(date);
+        }
+    }
+
+    // ------------------------------------------------------------ geometry
+
+    private Font font() {
+        return getFont();
+    }
+
+    /// `{x, y, boxWidth, boxHeight}` of the grid of seven columns and
+    /// eight rows inside the insets.
+    private int[] grid() {
+        Insets in = getInsets();
+        int w = Math.max(0, getWidth() - in.left - in.right);
+        int h = Math.max(0, getHeight() - in.top - in.bottom);
+        int bw = Math.max(1, w / DAYS_IN_WEEK);
+        int bh = Math.max(1, h / ROWS);
+        return new int[]{in.left + (w - bw * DAYS_IN_WEEK) / 2, in.top, bw, bh};
+    }
+
+    /// The day under a point of the component, or `null` over the title,
+    /// the day names, a box of another month or outside the grid.
+    public Date getDayAtLocation(int x, int y) {
+        int[] g = grid();
+        if (x < g[0] || y < g[1] + 2 * g[3]) {
+            return null;
+        }
+        int col = (x - g[0]) / g[2];
+        int row = (y - g[1]) / g[3] - 2;
+        if (col >= DAYS_IN_WEEK || row >= ROWS - 2) {
+            return null;
+        }
+        int day = row * DAYS_IN_WEEK + col - leadingBoxes() + 1;
+        if (day < 1 || day > daysInMonth()) {
+            return null;
+        }
+        return dayOfMonth(day);
+    }
+
+    /// The box of a day of the displayed month, or `null` for a date of
+    /// another month.
+    public Rectangle cn1DayBounds(Date date) {
+        if (date.getTime() < firstDisplayedDay.getTime()
+                || date.getTime() >= addMonths(firstDisplayedDay, 1).getTime()) {
+            return null;
+        }
+        Calendar c = model.getCalendar();
+        c.setTime(date);
+        int index = c.get(Calendar.DAY_OF_MONTH) - 1 + leadingBoxes();
+        int[] g = grid();
+        return new Rectangle(g[0] + (index % DAYS_IN_WEEK) * g[2], g[1] + (2 + index / DAYS_IN_WEEK) * g[3], g[2],
+                g[3]);
+    }
+
+    /// The box of the arrow to the previous month, or to the next one.
+    public Rectangle cn1ArrowBounds(boolean next) {
+        int[] g = grid();
+        return new Rectangle(next ? g[0] + (DAYS_IN_WEEK - 1) * g[2] : g[0], g[1], g[2], g[3]);
+    }
+
+    @Override
+    public Dimension getPreferredSize() {
+        if (isPreferredSizeSet()) {
+            return super.getPreferredSize();
+        }
+        FontMetrics fm = Fonts.metrics(font());
+        int bw = fm.stringWidth("00");
+        String[] names = getDaysOfTheWeek();
+        for (int i = 0; i < names.length; i++) {
+            bw = Math.max(bw, fm.stringWidth(names[i]));
+        }
+        bw += 2 * boxPaddingX;
+        int bh = fm.getHeight() + 2 * boxPaddingY;
+        if (CellTheme.touch()) {
+            bw = Math.max(bw, TOUCH_BOX);
+            bh = Math.max(bh, TOUCH_BOX);
+        }
+        Insets in = getInsets();
+        return new Dimension(bw * DAYS_IN_WEEK + in.left + in.right, bh * ROWS + in.top + in.bottom);
+    }
+
+    @Override
+    public Dimension getMinimumSize() {
+        if (isMinimumSizeSet()) {
+            return super.getMinimumSize();
+        }
+        return getPreferredSize();
+    }
+
+    // ------------------------------------------------------------ paint
+
+    private static void centered(Graphics g, FontMetrics fm, String s, int x, int y, int w, int h) {
+        g.drawString(s, x + (w - fm.stringWidth(s)) / 2, y + (h - fm.getHeight()) / 2 + fm.getAscent());
+    }
+
+    private static void arrow(Graphics g, int x, int y, int w, int h, boolean next) {
+        int s = Math.max(3, Math.min(w, h) / 4);
+        int cx = x + w / 2;
+        int cy = y + h / 2;
+        int tip = next ? cx + s / 2 : cx - s / 2;
+        int back = next ? cx - s / 2 : cx + s / 2;
+        g.fillPolygon(new int[]{tip, back, back}, new int[]{cy, cy - s, cy + s}, 3);
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        Color bg = getBackground();
+        if (!isBackgroundSet() || bg == null) {
+            bg = CellTheme.background("JXMonthView.background");
+        }
+        if (isOpaque()) {
+            g.setColor(bg);
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        Color fg = isForegroundSet() && getForeground() != null ? getForeground()
+                : CellTheme.foreground("JXMonthView.foreground");
+        Font f = font();
+        g.setFont(f);
+        FontMetrics fm = Fonts.metrics(f);
+        int[] gr = grid();
+        int x0 = gr[0];
+        int y0 = gr[1];
+        int bw = gr[2];
+        int bh = gr[3];
+
+        // Title.
+        g.setColor(getMonthStringBackground());
+        g.fillRect(x0, y0, bw * DAYS_IN_WEEK, bh);
+        g.setColor(getMonthStringForeground());
+        Insets mi = monthStringInsets;
+        centered(g, fm, cn1Title(), x0 + mi.left, y0 + mi.top, bw * DAYS_IN_WEEK - mi.left - mi.right,
+                bh - mi.top - mi.bottom);
+        if (traversable) {
+            arrow(g, x0, y0, bw, bh, false);
+            arrow(g, x0 + (DAYS_IN_WEEK - 1) * bw, y0, bw, bh, true);
+        }
+
+        // Day names.
+        g.setColor(getDaysOfTheWeekForeground());
+        int first = model.getFirstDayOfWeek();
+        for (int col = 0; col < DAYS_IN_WEEK; col++) {
+            int dow = (first - 1 + col) % DAYS_IN_WEEK + 1;
+            centered(g, fm, getDayOfTheWeek(dow), x0 + col * bw, y0 + bh, bw, bh);
+        }
+        g.setColor(CellTheme.grid(null));
+        g.drawLine(x0, y0 + 2 * bh - 1, x0 + DAYS_IN_WEEK * bw - 1, y0 + 2 * bh - 1);
+
+        // Days.
+        int lead = leadingBoxes();
+        int count = daysInMonth();
+        Color dim = CellTheme.mix(bg, fg, 0.4f);
+        for (int i = 0; i < DAYS_IN_WEEK * (ROWS - 2); i++) {
+            int day = i - lead + 1;
+            int x = x0 + (i % DAYS_IN_WEEK) * bw;
+            int y = y0 + (2 + i / DAYS_IN_WEEK) * bh;
+            boolean inMonth = day >= 1 && day <= count;
+            if (!inMonth) {
+                if ((day < 1 && showingLeadingDays) || (day > count && showingTrailingDays)) {
+                    Calendar c = model.getCalendar();
+                    c.setTime(addDays(firstDisplayedDay, day - 1));
+                    g.setColor(dim);
+                    centered(g, fm, String.valueOf(c.get(Calendar.DAY_OF_MONTH)), x, y, bw, bh);
+                }
+                continue;
+            }
+            Date date = dayOfMonth(day);
+            boolean selected = model.isSelected(date);
+            int dow = (first - 1 + i % DAYS_IN_WEEK) % DAYS_IN_WEEK + 1;
+            Color c;
+            if (model.isUnselectableDate(date)) {
+                c = dim;
+            } else if (selected) {
+                g.setColor(getSelectionBackground());
+                g.fillRect(x, y, bw, bh);
+                c = getSelectionForeground();
+            } else if (flagged.contains(date)) {
+                c = getFlaggedDayForeground();
+            } else {
+                c = dayForeground[dow] != null ? dayForeground[dow] : fg;
+            }
+            if (date.equals(today)) {
+                g.setColor(getTodayBackground());
+                g.drawRect(x, y, bw - 1, bh - 1);
+            }
+            g.setColor(c);
+            centered(g, fm, String.valueOf(day), x, y, bw, bh);
+        }
+    }
+
+    /// The title: the displayed month's name and year.
+    public String cn1Title() {
+        return new SimpleDateFormat("MMMM yyyy").format(firstDisplayedDay);
+    }
+
+    // ------------------------------------------------------------ today
+
+    protected void updateTodayFromCurrentTime() {
+        setToday(new Date());
+    }
+
+    protected void incrementToday() {
+        setToday(addDays(today, 1));
+    }
+
+    protected void setToday(Date date) {
+        Date old = today;
+        today = startOfDay(date);
+        firePropertyChange("today", old, getToday());
+        repaint();
+    }
+
+    /// The first millisecond of the day drawn as today.
+    public Date getToday() {
+        return new Date(today.getTime());
+    }
+
+    /// Does nothing: there are no UI delegates.
+    @Override
+    public void updateUI() {
+    }
+
+    public String getUIClassID() {
+        return uiClassID;
+    }
+
+    // ------------------------------------------------------------ selection
+
+    public DateSelectionModel getSelectionModel() {
+        return model;
+    }
+
+    public void setSelectionModel(DateSelectionModel model) {
+        if (model == null) {
+            throw new NullPointerException("date selection model must not be null");
+        }
+        DateSelectionModel old = this.model;
+        if (old == model) {
+            return;
+        }
+        old.removeDateSelectionListener(modelListener);
+        this.model = model;
+        model.addDateSelectionListener(modelListener);
+        firstDisplayedDay = startOfMonth(firstDisplayedDay);
+        today = startOfDay(today);
+        firePropertyChange(SELECTION_MODEL, old, model);
+        repaint();
+    }
+
+    public void clearSelection() {
+        model.clearSelection();
+    }
+
+    public boolean isSelectionEmpty() {
+        return model.isSelectionEmpty();
+    }
+
+    public SortedSet<Date> getSelection() {
+        return model.getSelection();
+    }
+
+    public void addSelectionInterval(Date startDate, Date endDate) {
+        if (startDate != null && endDate != null) {
+            model.addSelectionInterval(startDate, endDate);
+        }
+    }
+
+    public void setSelectionInterval(Date startDate, Date endDate) {
+        if (startDate != null && endDate != null) {
+            model.setSelectionInterval(startDate, endDate);
+        }
+    }
+
+    public void removeSelectionInterval(Date startDate, Date endDate) {
+        if (startDate != null && endDate != null) {
+            model.removeSelectionInterval(startDate, endDate);
+        }
+    }
+
+    public SelectionMode getSelectionMode() {
+        return model.getSelectionMode();
+    }
+
+    public void setSelectionMode(SelectionMode selectionMode) {
+        model.setSelectionMode(selectionMode);
+    }
+
+    public Date getFirstSelectionDate() {
+        return model.getFirstSelectionDate();
+    }
+
+    public Date getLastSelectionDate() {
+        return model.getLastSelectionDate();
+    }
+
+    public Date getSelectionDate() {
+        return model.getFirstSelectionDate();
+    }
+
+    /// Selects one date, or clears the selection for `null`.
+    public void setSelectionDate(Date newDate) {
+        if (newDate == null) {
+            clearSelection();
+        } else {
+            setSelectionInterval(newDate, newDate);
+        }
+    }
+
+    public boolean isSelected(Date date) {
+        return model.isSelected(date);
+    }
+
+    public void setLowerBound(Date lowerBound) {
+        model.setLowerBound(lowerBound);
+    }
+
+    public void setUpperBound(Date upperBound) {
+        model.setUpperBound(upperBound);
+    }
+
+    public Date getLowerBound() {
+        return model.getLowerBound();
+    }
+
+    public Date getUpperBound() {
+        return model.getUpperBound();
+    }
+
+    public boolean isUnselectableDate(Date date) {
+        return model.isUnselectableDate(date);
+    }
+
+    /// Sets the dates that cannot be selected; none for `null` or no
+    /// arguments.
+    public void setUnselectableDates(Date... unselectableDates) {
+        TreeSet<Date> set = new TreeSet<Date>();
+        if (unselectableDates != null) {
+            for (int i = 0; i < unselectableDates.length; i++) {
+                if (unselectableDates[i] != null) {
+                    set.add(unselectableDates[i]);
+                }
+            }
+        }
+        model.setUnselectableDates(set);
+        repaint();
+    }
+
+    // ------------------------------------------------------------ flagged
+
+    public boolean isFlaggedDate(Date date) {
+        return date != null && flagged.contains(startOfDay(date));
+    }
+
+    public void setFlaggedDates(Date... flaggedDates) {
+        SortedSet<Date> old = getFlaggedDates();
+        flagged.clear();
+        addAll(flaggedDates);
+        firePropertyChange(FLAGGED_DATES, old, getFlaggedDates());
+        repaint();
+    }
+
+    private void addAll(Date[] dates) {
+        if (dates != null) {
+            for (int i = 0; i < dates.length; i++) {
+                if (dates[i] != null) {
+                    flagged.add(startOfDay(dates[i]));
+                }
+            }
+        }
+    }
+
+    public void addFlaggedDates(Date... flaggedDates) {
+        SortedSet<Date> old = getFlaggedDates();
+        addAll(flaggedDates);
+        firePropertyChange(FLAGGED_DATES, old, getFlaggedDates());
+        repaint();
+    }
+
+    public void removeFlaggedDates(Date... flaggedDates) {
+        SortedSet<Date> old = getFlaggedDates();
+        if (flaggedDates != null) {
+            for (int i = 0; i < flaggedDates.length; i++) {
+                if (flaggedDates[i] != null) {
+                    flagged.remove(startOfDay(flaggedDates[i]));
+                }
+            }
+        }
+        firePropertyChange(FLAGGED_DATES, old, getFlaggedDates());
+        repaint();
+    }
+
+    public void clearFlaggedDates() {
+        SortedSet<Date> old = getFlaggedDates();
+        flagged.clear();
+        firePropertyChange(FLAGGED_DATES, old, getFlaggedDates());
+        repaint();
+    }
+
+    /// A copy of the flagged dates, each the first millisecond of its day.
+    public SortedSet<Date> getFlaggedDates() {
+        TreeSet<Date> out = new TreeSet<Date>();
+        Iterator<Date> it = flagged.iterator();
+        while (it.hasNext()) {
+            out.add(new Date(it.next().getTime()));
+        }
+        return out;
+    }
+
+    public boolean hasFlaggedDates() {
+        return !flagged.isEmpty();
+    }
+
+    // ------------------------------------------------------------ properties
+
+    /// Whether the last days of the month before are drawn, dimmed, in
+    /// the boxes ahead of day one.
+    public void setShowingLeadingDays(boolean value) {
+        boolean old = showingLeadingDays;
+        showingLeadingDays = value;
+        firePropertyChange("showingLeadingDays", old, value);
+        repaint();
+    }
+
+    public boolean isShowingLeadingDays() {
+        return showingLeadingDays;
+    }
+
+    /// Whether the first days of the month after are drawn, dimmed, in
+    /// the boxes behind the last day.
+    public void setShowingTrailingDays(boolean value) {
+        boolean old = showingTrailingDays;
+        showingTrailingDays = value;
+        firePropertyChange("showingTrailingDays", old, value);
+        repaint();
+    }
+
+    public boolean isShowingTrailingDays() {
+        return showingTrailingDays;
+    }
+
+    public boolean isTraversable() {
+        return traversable;
+    }
+
+    /// Whether the title has arrows that move to the month before and
+    /// after.
+    public void setTraversable(boolean traversable) {
+        boolean old = this.traversable;
+        this.traversable = traversable;
+        firePropertyChange(TRAVERSABLE, old, traversable);
+        repaint();
+    }
+
+    public boolean isZoomable() {
+        return zoomable;
+    }
+
+    /// Recorded; a zoomable view is traversable and nothing more.
+    public void setZoomable(boolean zoomable) {
+        boolean old = this.zoomable;
+        this.zoomable = zoomable;
+        if (zoomable) {
+            setTraversable(true);
+        }
+        firePropertyChange("zoomable", old, zoomable);
+    }
+
+    public boolean isShowingWeekNumber() {
+        return showingWeekNumber;
+    }
+
+    /// Recorded only: no week number column is drawn.
+    public void setShowingWeekNumber(boolean showWeekNumber) {
+        boolean old = showingWeekNumber;
+        showingWeekNumber = showWeekNumber;
+        firePropertyChange("showingWeekNumber", old, showWeekNumber);
+    }
+
+    /// Sets the names in the day name row, seven of them starting with
+    /// Sunday; `null` goes back to the formatter's short names.
+    public void setDaysOfTheWeek(String[] days) {
+        if (days != null && days.length != DAYS_IN_WEEK) {
+            throw new IllegalArgumentException("Array of days is not of length " + DAYS_IN_WEEK + " as expected.");
+        }
+        String[] old = getDaysOfTheWeek();
+        if (days == null) {
+            daysOfTheWeek = null;
+        } else {
+            daysOfTheWeek = new String[DAYS_IN_WEEK];
+            System.arraycopy(days, 0, daysOfTheWeek, 0, DAYS_IN_WEEK);
+        }
+        firePropertyChange(DAYS_OF_THE_WEEK, old, getDaysOfTheWeek());
+        revalidate();
+        repaint();
+    }
+
+    /// The seven day names, starting with Sunday.
+    public String[] getDaysOfTheWeek() {
+        String[] out = new String[DAYS_IN_WEEK];
+        if (daysOfTheWeek != null) {
+            System.arraycopy(daysOfTheWeek, 0, out, 0, DAYS_IN_WEEK);
+            return out;
+        }
+        String[] names = new SimpleDateFormat().getDateFormatSymbols().getShortWeekdays();
+        for (int i = 0; i < DAYS_IN_WEEK; i++) {
+            // The formatter's names are indexed by the Calendar day constants.
+            String n = names != null && names.length > i + 1 ? names[i + 1] : null;
+            out[i] = n != null ? n : "";
+        }
+        return out;
+    }
+
+    /// The name of a day given as a `Calendar` day constant.
+    public String getDayOfTheWeek(int dayOfWeek) {
+        return getDaysOfTheWeek()[dayOfWeek - 1];
+    }
+
+    public int getBoxPaddingX() {
+        return boxPaddingX;
+    }
+
+    public void setBoxPaddingX(int boxPaddingX) {
+        int old = this.boxPaddingX;
+        this.boxPaddingX = boxPaddingX;
+        firePropertyChange(BOX_PADDING_X, old, boxPaddingX);
+        revalidate();
+    }
+
+    public int getBoxPaddingY() {
+        return boxPaddingY;
+    }
+
+    public void setBoxPaddingY(int boxPaddingY) {
+        int old = this.boxPaddingY;
+        this.boxPaddingY = boxPaddingY;
+        firePropertyChange(BOX_PADDING_Y, old, boxPaddingY);
+        revalidate();
+    }
+
+    public Color getSelectionBackground() {
+        return selectionBackground != null ? selectionBackground
+                : CellTheme.selectionBackground("JXMonthView.selectedBackground");
+    }
+
+    public void setSelectionBackground(Color c) {
+        Color old = selectionBackground;
+        selectionBackground = c;
+        firePropertyChange("selectionBackground", old, c);
+        repaint();
+    }
+
+    public Color getSelectionForeground() {
+        return selectionForeground != null ? selectionForeground
+                : CellTheme.selectionForeground("JXMonthView.selectedForeground");
+    }
+
+    public void setSelectionForeground(Color c) {
+        Color old = selectionForeground;
+        selectionForeground = c;
+        firePropertyChange("selectionForeground", old, c);
+        repaint();
+    }
+
+    /// The color of the frame around today.
+    public Color getTodayBackground() {
+        return todayBackground != null ? todayBackground : CellTheme.foreground("JXMonthView.todayBackground");
+    }
+
+    public void setTodayBackground(Color c) {
+        Color old = todayBackground;
+        todayBackground = c;
+        firePropertyChange("todayBackground", old, c);
+        repaint();
+    }
+
+    public Color getMonthStringBackground() {
+        return monthStringBackground != null ? monthStringBackground
+                : CellTheme.headerBackground("JXMonthView.monthStringBackground");
+    }
+
+    public void setMonthStringBackground(Color c) {
+        Color old = monthStringBackground;
+        monthStringBackground = c;
+        firePropertyChange("monthStringBackground", old, c);
+        repaint();
+    }
+
+    public Color getMonthStringForeground() {
+        return monthStringForeground != null ? monthStringForeground
+                : CellTheme.headerForeground("JXMonthView.monthStringForeground");
+    }
+
+    public void setMonthStringForeground(Color c) {
+        Color old = monthStringForeground;
+        monthStringForeground = c;
+        firePropertyChange("monthStringForeground", old, c);
+        repaint();
+    }
+
+    public void setDaysOfTheWeekForeground(Color c) {
+        Color old = daysOfTheWeekForeground;
+        daysOfTheWeekForeground = c;
+        firePropertyChange("daysOfTheWeekForeground", old, c);
+        repaint();
+    }
+
+    public Color getDaysOfTheWeekForeground() {
+        return daysOfTheWeekForeground != null ? daysOfTheWeekForeground
+                : CellTheme.foreground("JXMonthView.daysOfTheWeekForeground");
+    }
+
+    /// Sets the text color of one day of the week, given as a `Calendar`
+    /// day constant; `null` goes back to the foreground.
+    public void setDayForeground(int dayOfWeek, Color c) {
+        if (dayOfWeek >= Calendar.SUNDAY && dayOfWeek <= Calendar.SATURDAY) {
+            dayForeground[dayOfWeek] = c;
+            repaint();
+        }
+    }
+
+    public Color getDayForeground(int dayOfWeek) {
+        Color c = getPerDayOfWeekForeground(dayOfWeek);
+        return c != null ? c : getForeground();
+    }
+
+    /// The color set for that day of the week alone, or `null`.
+    public Color getPerDayOfWeekForeground(int dayOfWeek) {
+        return dayOfWeek >= Calendar.SUNDAY && dayOfWeek <= Calendar.SATURDAY ? dayForeground[dayOfWeek] : null;
+    }
+
+    public void setFlaggedDayForeground(Color c) {
+        Color old = flaggedDayForeground;
+        flaggedDayForeground = c;
+        firePropertyChange("flaggedDayForeground", old, c);
+        repaint();
+    }
+
+    public Color getFlaggedDayForeground() {
+        return flaggedDayForeground != null ? flaggedDayForeground : Color.RED;
+    }
+
+    public Insets getMonthStringInsets() {
+        Insets i = monthStringInsets;
+        return new Insets(i.top, i.left, i.bottom, i.right);
+    }
+
+    public void setMonthStringInsets(Insets insets) {
+        Insets old = getMonthStringInsets();
+        monthStringInsets = insets == null ? new Insets(0, 0, 0, 0)
+                : new Insets(insets.top, insets.left, insets.bottom, insets.right);
+        firePropertyChange("monthStringInsets", old, getMonthStringInsets());
+        repaint();
+    }
+
+    public int getPreferredColumnCount() {
+        return preferredColumnCount;
+    }
+
+    /// Recorded only: one month is shown.
+    public void setPreferredColumnCount(int cols) {
+        if (cols > 0) {
+            int old = preferredColumnCount;
+            preferredColumnCount = cols;
+            firePropertyChange("preferredColumnCount", old, cols);
+        }
+    }
+
+    public int getPreferredRowCount() {
+        return preferredRowCount;
+    }
+
+    /// Recorded only: one month is shown.
+    public void setPreferredRowCount(int rows) {
+        if (rows > 0) {
+            int old = preferredRowCount;
+            preferredRowCount = rows;
+            firePropertyChange("preferredRowCount", old, rows);
+        }
+    }
+
+    // ------------------------------------------------------------ actions
+
+    /// Ends an adjusting selection and tells the action listeners
+    /// [#COMMIT_KEY].
+    public void commitSelection() {
+        model.setAdjusting(false);
+        fireActionPerformed(COMMIT_KEY);
+    }
+
+    /// Ends an adjusting selection and tells the action listeners
+    /// [#CANCEL_KEY]. The selection stays as it is.
+    public void cancelSelection() {
+        model.setAdjusting(false);
+        fireActionPerformed(CANCEL_KEY);
+    }
+
+    /// Whether the keys work when the view does not own the focus;
+    /// recorded only, the keys always need the focus.
+    public void setComponentInputMapEnabled(boolean enabled) {
+        boolean old = componentInputMapEnabled;
+        componentInputMapEnabled = enabled;
+        firePropertyChange("componentInputMapEnabled", old, enabled);
+    }
+
+    public boolean isComponentInputMapEnabled() {
+        return componentInputMapEnabled;
+    }
+
+    public void addActionListener(ActionListener l) {
+        listenerList.add(ActionListener.class, l);
+    }
+
+    public void removeActionListener(ActionListener l) {
+        listenerList.remove(ActionListener.class, l);
+    }
+
+    protected void fireActionPerformed(String actionCommand) {
+        ActionListener[] ls = listenerList.getListeners(ActionListener.class);
+        if (ls.length == 0) {
+            return;
+        }
+        ActionEvent e = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, actionCommand);
+        for (int i = ls.length - 1; i >= 0; i--) {
+            ls[i].actionPerformed(e);
+        }
+    }
+
+    // ------------------------------------------------------------ input
+
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        if (isEnabled()) {
+            switch (e.getID()) {
+                case MouseEvent.MOUSE_PRESSED:
+                    pressTouch = CellTheme.touch();
+                    pressOnDay = false;
+                    if (pressTouch) {
+                        ScrollDelegate.forward(this, e);
+                    } else if (e.getButton() == MouseEvent.BUTTON1) {
+                        requestFocusInWindow();
+                        pressOnDay = pick(e, true);
+                    }
+                    break;
+                case MouseEvent.MOUSE_RELEASED:
+                    if (pressTouch) {
+                        ScrollDelegate.forward(this, e);
+                    } else if (pressOnDay) {
+                        pressOnDay = false;
+                        commitSelection();
+                    }
+                    break;
+                case MouseEvent.MOUSE_CLICKED:
+                    if (pressTouch && pick(e, false)) {
+                        commitSelection();
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        super.processMouseEvent(e);
+    }
+
+    @Override
+    protected void processMouseMotionEvent(MouseEvent e) {
+        if (isEnabled() && e.getID() == MouseEvent.MOUSE_DRAGGED) {
+            if (pressTouch) {
+                ScrollDelegate.forward(this, e);
+            } else if (pressOnDay && anchor != null && model.getSelectionMode() != SelectionMode.SINGLE_SELECTION) {
+                Date d = getDayAtLocation(e.getX(), e.getY());
+                if (d != null && !model.isUnselectableDate(d)) {
+                    span(anchor, d);
+                }
+            }
+        }
+        super.processMouseMotionEvent(e);
+    }
+
+    private void span(Date a, Date b) {
+        if (a.getTime() <= b.getTime()) {
+            model.setSelectionInterval(a, b);
+        } else {
+            model.setSelectionInterval(b, a);
+        }
+    }
+
+    /// What a press or tap does: moves a month over an arrow, selects
+    /// over a day. Answers whether a day was selected.
+    private boolean pick(MouseEvent e, boolean adjusting) {
+        if (traversable) {
+            if (cn1ArrowBounds(false).contains(e.getX(), e.getY())) {
+                setFirstDisplayedDay(addMonths(firstDisplayedDay, -1));
+                return false;
+            }
+            if (cn1ArrowBounds(true).contains(e.getX(), e.getY())) {
+                setFirstDisplayedDay(addMonths(firstDisplayedDay, 1));
+                return false;
+            }
+        }
+        Date d = getDayAtLocation(e.getX(), e.getY());
+        if (d == null || model.isUnselectableDate(d)) {
+            return false;
+        }
+        SelectionMode mode = model.getSelectionMode();
+        if (adjusting) {
+            model.setAdjusting(true);
+        }
+        if (e.isShiftDown() && anchor != null && mode != SelectionMode.SINGLE_SELECTION) {
+            span(anchor, d);
+        } else if ((e.isControlDown() || e.isMetaDown()) && mode == SelectionMode.MULTIPLE_INTERVAL_SELECTION) {
+            if (model.isSelected(d)) {
+                model.removeSelectionInterval(d, d);
+            } else {
+                model.addSelectionInterval(d, d);
+            }
+            anchor = d;
+        } else {
+            model.setSelectionInterval(d, d);
+            anchor = d;
+        }
+        return true;
+    }
+
+    @Override
+    protected void processKeyEvent(KeyEvent e) {
+        if (isEnabled() && e.getID() == KeyEvent.KEY_PRESSED && !e.isConsumed()) {
+            int days = 0;
+            switch (e.getKeyCode()) {
+                case KeyEvent.VK_LEFT:
+                    days = -1;
+                    break;
+                case KeyEvent.VK_RIGHT:
+                    days = 1;
+                    break;
+                case KeyEvent.VK_UP:
+                    days = -DAYS_IN_WEEK;
+                    break;
+                case KeyEvent.VK_DOWN:
+                    days = DAYS_IN_WEEK;
+                    break;
+                case KeyEvent.VK_PAGE_UP:
+                    setFirstDisplayedDay(addMonths(firstDisplayedDay, -1));
+                    e.consume();
+                    break;
+                case KeyEvent.VK_PAGE_DOWN:
+                    setFirstDisplayedDay(addMonths(firstDisplayedDay, 1));
+                    e.consume();
+                    break;
+                case KeyEvent.VK_ENTER:
+                    commitSelection();
+                    e.consume();
+                    break;
+                case KeyEvent.VK_ESCAPE:
+                    cancelSelection();
+                    e.consume();
+                    break;
+                default:
+                    break;
+            }
+            if (days != 0) {
+                Date from = model.getFirstSelectionDate();
+                Date to = from != null ? addDays(from, days) : firstDisplayedDay;
+                if (!model.isUnselectableDate(to)) {
+                    model.setSelectionInterval(to, to);
+                    anchor = to;
+                    ensureDateVisible(to);
+                }
+                e.consume();
+            }
+        }
+        super.processKeyEvent(e);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXPanel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXPanel.java
new file mode 100644
index 00000000000..763c8513252
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXPanel.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.AlphaComposite;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Composite;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.Scrollable;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+
+/// A panel that can be translucent, can have its background drawn by a
+/// [Painter], and says how it wants to be sized inside a scroll pane.
+///
+/// ## Alpha
+///
+/// With an alpha below 1 the panel and everything in it is painted through
+/// a composite of that opacity. Child widgets are drawn by Codename One,
+/// which honors the opacity for what it draws through the same graphics.
+///
+/// ## Background painter
+///
+/// A painter replaces nothing: an opaque panel still fills its background
+/// first, and the painter draws over that. It is given the panel's size,
+/// or the size inside the border when
+/// [#setPaintBorderInsets(boolean)] is off.
+///
+/// A painter that changes is not observed: call `repaint()` after
+/// changing one.
+public class JXPanel extends JPanel implements Scrollable {
+
+    private float alpha = 1f;
+    private boolean inheritAlpha = true;
+    private Painter backgroundPainter;
+    private boolean paintBorderInsets = true;
+    private ScrollableSizeHint widthHint = ScrollableSizeHint.FIT;
+    private ScrollableSizeHint heightHint = ScrollableSizeHint.FIT;
+
+    public JXPanel() {
+        super();
+    }
+
+    public JXPanel(boolean isDoubleBuffered) {
+        super(isDoubleBuffered);
+    }
+
+    public JXPanel(LayoutManager layout) {
+        super(layout);
+    }
+
+    public JXPanel(LayoutManager layout, boolean isDoubleBuffered) {
+        super(layout, isDoubleBuffered);
+    }
+
+    // ------------------------------------------------------------ alpha
+
+    public float getAlpha() {
+        return alpha;
+    }
+
+    /// Sets the opacity, from 0 (invisible) to 1.
+    public void setAlpha(float alpha) {
+        if (alpha < 0f || alpha > 1f) {
+            throw new IllegalArgumentException("invalid alpha value " + alpha);
+        }
+        float old = this.alpha;
+        this.alpha = alpha;
+        if (old != alpha) {
+            firePropertyChange("alpha", Float.valueOf(old), Float.valueOf(alpha));
+            repaint();
+        }
+    }
+
+    /// The opacity in use: this panel's, or the smaller of it and that of
+    /// the nearest enclosing `JXPanel` when alpha is inherited.
+    public float getEffectiveAlpha() {
+        float a = alpha;
+        if (inheritAlpha) {
+            for (Container p = getParent(); p != null; p = p.getParent()) {
+                if (p instanceof JXPanel) {
+                    a = Math.min(((JXPanel) p).getEffectiveAlpha(), a);
+                    break;
+                }
+            }
+        }
+        return a;
+    }
+
+    public boolean isInheritAlpha() {
+        return inheritAlpha;
+    }
+
+    public void setInheritAlpha(boolean inheritAlpha) {
+        boolean old = this.inheritAlpha;
+        this.inheritAlpha = inheritAlpha;
+        firePropertyChange("inheritAlpha", old, inheritAlpha);
+        if (old != inheritAlpha) {
+            repaint();
+        }
+    }
+
+    // ------------------------------------------------------------ scrollable
+
+    public final void setScrollableWidthHint(ScrollableSizeHint hint) {
+        if (hint == null) {
+            throw new NullPointerException("hint must not be null");
+        }
+        ScrollableSizeHint old = widthHint;
+        widthHint = hint;
+        if (old != hint) {
+            revalidate();
+            firePropertyChange("scrollableWidthHint", old, hint);
+        }
+    }
+
+    public final void setScrollableHeightHint(ScrollableSizeHint hint) {
+        if (hint == null) {
+            throw new NullPointerException("hint must not be null");
+        }
+        ScrollableSizeHint old = heightHint;
+        heightHint = hint;
+        if (old != hint) {
+            revalidate();
+            firePropertyChange("scrollableHeightHint", old, hint);
+        }
+    }
+
+    protected ScrollableSizeHint getScrollableWidthHint() {
+        return widthHint;
+    }
+
+    protected ScrollableSizeHint getScrollableHeightHint() {
+        return heightHint;
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportHeight() {
+        return heightHint.getTracksParentSize(this, SwingConstants.VERTICAL);
+    }
+
+    @Override
+    public boolean getScrollableTracksViewportWidth() {
+        return widthHint.getTracksParentSize(this, SwingConstants.HORIZONTAL);
+    }
+
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        return getPreferredSize();
+    }
+
+    /// The visible length along the axis: one screenful.
+    @Override
+    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
+        if (orientation == SwingConstants.VERTICAL) {
+            return Math.max(1, visibleRect.height);
+        }
+        return Math.max(1, visibleRect.width);
+    }
+
+    /// The first child's length along the axis, so that a unit is about
+    /// one row of the panel; ten pixels when there is no child.
+    @Override
+    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
+        int unit = 10;
+        if (getComponentCount() > 0) {
+            Component first = getComponent(0);
+            int l = orientation == SwingConstants.VERTICAL ? first.getHeight() : first.getWidth();
+            if (l > 0) {
+                unit = l;
+            }
+        }
+        return unit;
+    }
+
+    /// `true` is [ScrollableSizeHint#FIT], `false` is
+    /// [ScrollableSizeHint#NONE].
+    public void setScrollableTracksViewportHeight(boolean scrollableTracksViewportHeight) {
+        setScrollableHeightHint(scrollableTracksViewportHeight ? ScrollableSizeHint.FIT : ScrollableSizeHint.NONE);
+    }
+
+    /// `true` is [ScrollableSizeHint#FIT], `false` is
+    /// [ScrollableSizeHint#NONE].
+    public void setScrollableTracksViewportWidth(boolean scrollableTracksViewportWidth) {
+        setScrollableWidthHint(scrollableTracksViewportWidth ? ScrollableSizeHint.FIT : ScrollableSizeHint.NONE);
+    }
+
+    // ------------------------------------------------------------ painter
+
+    /// Sets the painter of the background, or `null` for none.
+    public void setBackgroundPainter(Painter p) {
+        Painter old = backgroundPainter;
+        backgroundPainter = p;
+        firePropertyChange("backgroundPainter", old, p);
+        repaint();
+    }
+
+    public Painter getBackgroundPainter() {
+        return backgroundPainter;
+    }
+
+    public boolean isPaintBorderInsets() {
+        return paintBorderInsets;
+    }
+
+    /// Whether the background painter draws under the border too.
+    public void setPaintBorderInsets(boolean paintBorderInsets) {
+        boolean old = this.paintBorderInsets;
+        this.paintBorderInsets = paintBorderInsets;
+        firePropertyChange("paintBorderInsets", old, paintBorderInsets);
+        if (old != paintBorderInsets) {
+            repaint();
+        }
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        float a = getEffectiveAlpha();
+        if (a >= 1f || !(g instanceof Graphics2D)) {
+            super.paint(g);
+            return;
+        }
+        if (a <= 0f) {
+            return;
+        }
+        Graphics2D g2 = (Graphics2D) g;
+        Composite saved = g2.getComposite();
+        float base = 1f;
+        if (saved instanceof AlphaComposite) {
+            base = ((AlphaComposite) saved).getAlpha();
+        }
+        g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, base * a));
+        try {
+            super.paint(g2);
+        } finally {
+            g2.setComposite(saved);
+        }
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Painter p = backgroundPainter;
+        if (p == null || !(g instanceof Graphics2D)) {
+            return;
+        }
+        Graphics2D g2 = (Graphics2D) g.create();
+        try {
+            int w = getWidth();
+            int h = getHeight();
+            if (!paintBorderInsets) {
+                Insets i = getInsets();
+                g2.translate(i.left, i.top);
+                w -= i.left + i.right;
+                h -= i.top + i.bottom;
+            }
+            if (w > 0 && h > 0) {
+                cn1Paint(p, g2, w, h);
+            }
+        } finally {
+            g2.dispose();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void cn1Paint(Painter p, Graphics2D g2, int w, int h) {
+        p.paint(g2, this, w, h);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXSearchField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXSearchField.java
new file mode 100644
index 00000000000..99218afdc08
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXSearchField.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.Timer;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+
+/// A text field for search text. It tells its action listeners when to
+/// search: in the regular mode when the edit is finished with Enter or
+/// the keyboard's Done, in the instant mode a short while after every
+/// change of the text.
+///
+/// The cancel action runs when Escape is pressed, where the platform
+/// delivers that key to a text field; the one a field starts with clears
+/// the text.
+///
+/// ## What differs from SwingX
+///
+/// The field is a plain Codename One text field with a "Search" prompt.
+/// It has no find, cancel or popup buttons, so everything about them is
+/// absent: the buttons, the find action, the layout style, the find popup
+/// menu and the recent searches.
+public class JXSearchField extends JXTextField {
+
+    /// When the action listeners are told to search.
+    public enum SearchMode {
+        /// When the edit is finished.
+        REGULAR,
+        /// After every change of the text, once the instant search delay
+        /// has passed without another one.
+        INSTANT
+    }
+
+    private SearchMode searchMode = SearchMode.INSTANT;
+    private int instantSearchDelay = 180;
+    private ActionListener cancelAction;
+    // No initializers: the superclass constructor sets the document, and
+    // with it these, before this class's initializers would run.
+    private DocumentListener changes;
+    private Timer instantSearchTimer;
+
+    public JXSearchField() {
+        this("Search");
+    }
+
+    public JXSearchField(String prompt) {
+        super(prompt);
+        enableEvents(AWTEvent.KEY_EVENT_MASK);
+    }
+
+    @Override
+    public void setDocument(Document doc) {
+        if (changes == null) {
+            changes = new DocumentListener() {
+                @Override
+                public void insertUpdate(DocumentEvent e) {
+                    cn1TextChanged();
+                }
+
+                @Override
+                public void removeUpdate(DocumentEvent e) {
+                    cn1TextChanged();
+                }
+
+                @Override
+                public void changedUpdate(DocumentEvent e) {
+                    cn1TextChanged();
+                }
+            };
+        }
+        Document old = getDocument();
+        if (old != null) {
+            old.removeDocumentListener(changes);
+        }
+        super.setDocument(doc);
+        if (doc != null) {
+            doc.addDocumentListener(changes);
+        }
+    }
+
+    private void cn1TextChanged() {
+        if (searchMode != SearchMode.INSTANT) {
+            return;
+        }
+        Timer t = getInstantSearchTimer();
+        if (instantSearchDelay > 0) {
+            t.setInitialDelay(instantSearchDelay);
+            t.restart();
+        } else {
+            postActionEvent();
+        }
+    }
+
+    public SearchMode getSearchMode() {
+        return searchMode;
+    }
+
+    public boolean isInstantSearchMode() {
+        return searchMode == SearchMode.INSTANT;
+    }
+
+    public boolean isRegularSearchMode() {
+        return searchMode == SearchMode.REGULAR;
+    }
+
+    public void setSearchMode(SearchMode searchMode) {
+        if (searchMode == null) {
+            throw new NullPointerException("searchMode must not be null");
+        }
+        SearchMode old = this.searchMode;
+        this.searchMode = searchMode;
+        if (searchMode != SearchMode.INSTANT && instantSearchTimer != null) {
+            instantSearchTimer.stop();
+        }
+        firePropertyChange("searchMode", old, searchMode);
+    }
+
+    public int getInstantSearchDelay() {
+        return instantSearchDelay;
+    }
+
+    /// Sets how many milliseconds the text must rest in the instant mode
+    /// before the action listeners are told; 0 tells them at once.
+    public void setInstantSearchDelay(int instantSearchDelay) {
+        int old = this.instantSearchDelay;
+        this.instantSearchDelay = instantSearchDelay;
+        firePropertyChange("instantSearchDelay", old, instantSearchDelay);
+    }
+
+    /// The action Escape runs; the one a field starts with clears the
+    /// text.
+    public final ActionListener getCancelAction() {
+        if (cancelAction == null) {
+            cancelAction = new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    setText(null);
+                    requestFocusInWindow();
+                }
+            };
+        }
+        return cancelAction;
+    }
+
+    /// Sets the action Escape runs; `null` goes back to clearing the
+    /// text.
+    public final void setCancelAction(ActionListener cancelAction) {
+        ActionListener old = this.cancelAction;
+        this.cancelAction = cancelAction;
+        firePropertyChange("cancelAction", old, cancelAction);
+    }
+
+    /// The timer that waits out the instant search delay. It does not
+    /// repeat and tells the action listeners when it fires.
+    public Timer getInstantSearchTimer() {
+        if (instantSearchTimer == null) {
+            instantSearchTimer = new Timer(0, new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    postActionEvent();
+                }
+            });
+            instantSearchTimer.setRepeats(false);
+        }
+        return instantSearchTimer;
+    }
+
+    /// Tells the action listeners to search now, and stops a pending
+    /// instant search.
+    @Override
+    public void postActionEvent() {
+        if (instantSearchTimer != null) {
+            instantSearchTimer.stop();
+        }
+        super.postActionEvent();
+    }
+
+    @Override
+    protected void processKeyEvent(KeyEvent e) {
+        if (isEnabled() && e.getID() == KeyEvent.KEY_PRESSED && e.getKeyCode() == KeyEvent.VK_ESCAPE
+                && !e.isConsumed()) {
+            getCancelAction().actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "cancel"));
+            e.consume();
+        }
+        super.processKeyEvent(e);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXStatusBar.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXStatusBar.java
new file mode 100644
index 00000000000..09c9478f62e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXStatusBar.java
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager2;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.rt.CellTheme;
+import java.util.HashMap;
+
+/// The bar along the bottom of a window: a row of components, each added
+/// with a [Constraint] that says whether it keeps a fixed width or shares
+/// what is left over.
+///
+/// The bar lays its children out itself, from the left. A component
+/// added with a `FIXED` constraint is as wide as the constraint's fixed
+/// width, or as it prefers when that is negative; the `FILL` components
+/// divide the remaining width equally. A component added without a
+/// constraint is fixed at its preferred width, and one added with an
+/// `Insets` object is that with those insets around it. The bar draws a
+/// line along its top and a short separator before every component but
+/// the first, in the theme's grid color.
+///
+/// ## What differs from SwingX
+///
+///  - There is no look and feel delegate, and the layout is not
+///    replaceable: a layout manager set on the bar takes over and the
+///    constraints stop meaning anything.
+///  - The resize handle is recorded and never drawn; a device window is
+///    not resized by a corner.
+public class JXStatusBar extends JComponent {
+
+    private static final int HPAD = 4;
+    private static final int VPAD = 3;
+    private static final int GAP = 9;
+
+    private boolean resizeHandleEnabled = true;
+
+    public JXStatusBar() {
+        setLayout(new Row());
+    }
+
+    /// How a component of a status bar is sized.
+    public static class Constraint {
+
+        /// Whether a component keeps its width or takes a share of what
+        /// the fixed ones leave.
+        public enum ResizeBehavior {
+            FILL,
+            FIXED
+        }
+
+        private Insets insets;
+        private ResizeBehavior resizeBehavior;
+        private int fixedWidth;
+
+        /// A fixed component at its preferred width.
+        public Constraint() {
+            this(ResizeBehavior.FIXED, null);
+        }
+
+        public Constraint(Insets insets) {
+            this(ResizeBehavior.FIXED, insets);
+        }
+
+        /// A fixed component of the given width.
+        public Constraint(int fixedWidth) {
+            this(fixedWidth, null);
+        }
+
+        public Constraint(int fixedWidth, Insets insets) {
+            if (fixedWidth < 0) {
+                throw new IllegalArgumentException("fixedWidth must be >= 0");
+            }
+            this.fixedWidth = fixedWidth;
+            this.insets = cn1Copy(insets);
+            this.resizeBehavior = ResizeBehavior.FIXED;
+        }
+
+        public Constraint(ResizeBehavior resizeBehavior) {
+            this(resizeBehavior, null);
+        }
+
+        public Constraint(ResizeBehavior resizeBehavior, Insets insets) {
+            this.resizeBehavior = resizeBehavior == null ? ResizeBehavior.FIXED : resizeBehavior;
+            this.insets = cn1Copy(insets);
+            this.fixedWidth = -1;
+        }
+
+        /// Sets the width of a fixed component, or with a negative value
+        /// its preferred width. A fill component ignores it.
+        public void setFixedWidth(int width) {
+            fixedWidth = width;
+        }
+
+        public ResizeBehavior getResizeBehavior() {
+            return resizeBehavior;
+        }
+
+        public Insets getInsets() {
+            return cn1Copy(insets);
+        }
+
+        /// The width of a fixed component; negative for its preferred
+        /// width.
+        public int getFixedWidth() {
+            return fixedWidth;
+        }
+
+        private static Insets cn1Copy(Insets i) {
+            return i == null ? new Insets(0, 0, 0, 0) : new Insets(i.top, i.left, i.bottom, i.right);
+        }
+    }
+
+    /// The row layout described in the class comment.
+    private static final class Row implements LayoutManager2 {
+
+        private final HashMap<Component, Constraint> constraints = new HashMap<Component, Constraint>();
+
+        @Override
+        public void addLayoutComponent(Component comp, Object constraint) {
+            if (constraint instanceof Constraint) {
+                constraints.put(comp, (Constraint) constraint);
+            } else if (constraint instanceof Insets) {
+                constraints.put(comp, new Constraint((Insets) constraint));
+            } else {
+                constraints.remove(comp);
+            }
+        }
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+            constraints.remove(comp);
+        }
+
+        @Override
+        public Dimension maximumLayoutSize(Container target) {
+            return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+        }
+
+        @Override
+        public float getLayoutAlignmentX(Container target) {
+            return 0.5f;
+        }
+
+        @Override
+        public float getLayoutAlignmentY(Container target) {
+            return 0.5f;
+        }
+
+        @Override
+        public void invalidateLayout(Container target) {
+        }
+
+        private static boolean fills(Constraint c) {
+            return c != null && c.resizeBehavior == Constraint.ResizeBehavior.FILL;
+        }
+
+        /// The width a component asks for before the fill components
+        /// share out the rest, without its insets.
+        private static int wanted(Component comp, Constraint c) {
+            if (c != null && !fills(c) && c.fixedWidth >= 0) {
+                return c.fixedWidth;
+            }
+            return comp.getPreferredSize().width;
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            Insets in = parent.getInsets();
+            int w = 0;
+            int h = 0;
+            int shown = 0;
+            int n = parent.getComponentCount();
+            for (int i = 0; i < n; i++) {
+                Component comp = parent.getComponent(i);
+                if (!comp.isVisible()) {
+                    continue;
+                }
+                Constraint c = constraints.get(comp);
+                int extraW = c == null ? 0 : c.insets.left + c.insets.right;
+                int extraH = c == null ? 0 : c.insets.top + c.insets.bottom;
+                w += wanted(comp, c) + extraW;
+                h = Math.max(h, comp.getPreferredSize().height + extraH);
+                shown++;
+            }
+            if (shown > 1) {
+                w += GAP * (shown - 1);
+            }
+            return new Dimension(w + 2 * HPAD + in.left + in.right, h + 2 * VPAD + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            return preferredLayoutSize(parent);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            Insets in = parent.getInsets();
+            int n = parent.getComponentCount();
+            int available = parent.getWidth() - in.left - in.right - 2 * HPAD;
+            int fillCount = 0;
+            int shown = 0;
+            for (int i = 0; i < n; i++) {
+                Component comp = parent.getComponent(i);
+                if (!comp.isVisible()) {
+                    continue;
+                }
+                shown++;
+                Constraint c = constraints.get(comp);
+                if (c != null) {
+                    available -= c.insets.left + c.insets.right;
+                }
+                if (fills(c)) {
+                    fillCount++;
+                } else {
+                    available -= wanted(comp, c);
+                }
+            }
+            if (shown > 1) {
+                available -= GAP * (shown - 1);
+            }
+            available = Math.max(0, available);
+            int share = fillCount > 0 ? available / fillCount : 0;
+            int spare = fillCount > 0 ? available - share * fillCount : 0;
+            int x = in.left + HPAD;
+            int top = in.top + VPAD;
+            int height = parent.getHeight() - in.top - in.bottom - 2 * VPAD;
+            for (int i = 0; i < n; i++) {
+                Component comp = parent.getComponent(i);
+                if (!comp.isVisible()) {
+                    continue;
+                }
+                Constraint c = constraints.get(comp);
+                int w;
+                if (fills(c)) {
+                    fillCount--;
+                    w = share + (fillCount == 0 ? spare : 0);
+                } else {
+                    w = wanted(comp, c);
+                }
+                int l = c == null ? 0 : c.insets.left;
+                int r = c == null ? 0 : c.insets.right;
+                int t = c == null ? 0 : c.insets.top;
+                int b = c == null ? 0 : c.insets.bottom;
+                comp.setBounds(x + l, top + t, w, Math.max(0, height - t - b));
+                x += l + w + r + GAP;
+            }
+        }
+    }
+
+    /// Recorded only; no handle is drawn.
+    public void setResizeHandleEnabled(boolean resizeHandleEnabled) {
+        boolean old = this.resizeHandleEnabled;
+        this.resizeHandleEnabled = resizeHandleEnabled;
+        firePropertyChange("resizeHandleEnabled", old, resizeHandleEnabled);
+    }
+
+    public boolean isResizeHandleEnabled() {
+        return resizeHandleEnabled;
+    }
+
+    /// Fills the background of an opaque bar, and draws the line along
+    /// the top and the separators between the components.
+    @Override
+    protected void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        Color line = CellTheme.grid(null);
+        g.setColor(line);
+        g.drawLine(0, 0, getWidth() - 1, 0);
+        boolean first = true;
+        int n = getComponentCount();
+        Object layout = getLayout();
+        for (int i = 0; i < n; i++) {
+            Component comp = getComponent(i);
+            if (!comp.isVisible()) {
+                continue;
+            }
+            if (!first) {
+                int left = 0;
+                if (layout instanceof Row) {
+                    Constraint c = ((Row) layout).constraints.get(comp);
+                    left = c == null ? 0 : c.insets.left;
+                }
+                int x = comp.getX() - left - GAP / 2 - 1;
+                g.drawLine(x, VPAD + 1, x, getHeight() - VPAD - 1);
+            }
+            first = false;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTable.java
new file mode 100644
index 00000000000..5bf58133425
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTable.java
@@ -0,0 +1,1256 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.JViewport;
+import com.codename1.desktopcompat.javax.swing.ListSelectionModel;
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import com.codename1.desktopcompat.javax.swing.ScrollPaneConstants;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableModelEvent;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.javax.swing.table.TableColumnModel;
+import com.codename1.desktopcompat.javax.swing.table.TableModel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.CompoundHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.Highlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.TableColumnModelExtListener;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.CheckBoxProvider;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultTableRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValues;
+import com.codename1.desktopcompat.org.jdesktop.swingx.rollover.RolloverProducer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.SortController;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.SortUtils;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.StringValueRegistry;
+import com.codename1.desktopcompat.org.jdesktop.swingx.sort.TableSortController;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.ColumnControlButton;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.ColumnFactory;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.DefaultTableColumnModelExt;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.TableColumnExt;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.TableColumnModelExt;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Vector;
+
+/// A table with highlighters, columns that can be hidden, sorting and
+/// filtering switches of its own, packing of columns to their content
+/// and a size in rows for its scroll pane.
+///
+/// ## Highlighters
+///
+/// Every cell's renderer component passes through the table's
+/// highlighters, in the order they were added, and then through those of
+/// the cell's column. The table's default renderers are SwingX renderers,
+/// which set every visual property for every cell; a
+/// `DefaultTableCellRenderer` remembers a color set on it, so the table
+/// puts the colors it had first back before each cell.
+///
+/// ## Sorting
+///
+/// The table makes its own row sorter, a
+/// [com.codename1.desktopcompat.org.jdesktop.swingx.sort.TableSortController],
+/// and drives it: [#setSortable(boolean)], the sort order of a column by
+/// view index or by identifier, [#setRowFilter(RowFilter)]. A column
+/// model index is what the sorter is given, so sorting by a hidden
+/// column's identifier works.
+///
+/// ## Columns
+///
+/// Columns are [TableColumnExt]s in a [DefaultTableColumnModelExt].
+/// Hiding one removes it from the view: view indexes then count the
+/// visible columns only and `convertColumnIndexToView` answers -1 for
+/// it.
+///
+/// ## Rollover
+///
+/// With rollover enabled the cell under the pointer is kept in the
+/// client property `swingx.rollover` for the rollover predicates. On a
+/// touch screen that is the cell last touched.
+///
+/// ## Not here
+///
+/// The column control is a button with a popup menu; see
+/// [ColumnControlButton] for where it can be shown. Searching, the
+/// focus-lost editor hack, the look and feel hooks and
+/// column sequences are absent.
+public class JXTable extends JTable implements TableColumnModelExtListener {
+
+    public static final String FOCUS_PREVIOUS_COMPONENT = "focusPreviousComponent";
+    public static final String FOCUS_NEXT_COMPONENT = "focusNextComponent";
+    public static final String HORIZONTALSCROLL_ACTION_COMMAND = "column.horizontalScroll";
+    public static final String PACKALL_ACTION_COMMAND = "column.packAll";
+    public static final String PACKSELECTED_ACTION_COMMAND = "column.packSelected";
+    public static final String UIPREFIX = "JXTable.";
+    public static final String MATCH_HIGHLIGHTER = "match.highlighter";
+    public static final String USE_DTCR_COLORMEMORY_HACK = "useDTCRColorMemoryHack";
+
+    protected CompoundHighlighter compoundHighlighter;
+    protected ComponentAdapter dataAdapter;
+
+    // None of these has an initializer: the superclass constructor sets
+    // the model and the columns, which reaches methods overridden here
+    // before an initializer would run and undo what they did.
+    private ChangeListener cn1HighlighterListener;
+    private StringValueRegistry cn1Registry;
+    private ColumnFactory cn1ColumnFactory;
+    private boolean cn1Ready;
+    private boolean cn1Sortable;
+    private boolean cn1AutoSorter;
+    private boolean cn1SortsOnUpdates;
+    private SortOrder[] cn1SortCycle;
+    private RowFilter<?, ?> cn1RowFilter;
+    private boolean cn1Editable;
+    private boolean cn1Rollover;
+    private RolloverProducer cn1RolloverProducer;
+    private boolean cn1ColumnControlVisible;
+    private JComponent cn1ColumnControl;
+    private boolean cn1HorizontalScroll;
+    private int cn1OldResizeMode;
+    private int cn1VisibleRows;
+    private int cn1VisibleColumns;
+    private boolean cn1ViewportSizeSet;
+    private List<Memory> cn1Memories;
+
+    public JXTable() {
+        super();
+        cn1Init();
+    }
+
+    public JXTable(TableModel dm) {
+        super(dm);
+        cn1Init();
+    }
+
+    public JXTable(TableModel dm, TableColumnModel cm) {
+        super(dm, cm);
+        cn1Init();
+    }
+
+    public JXTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm) {
+        super(dm, cm, sm);
+        cn1Init();
+    }
+
+    public JXTable(int numRows, int numColumns) {
+        super(numRows, numColumns);
+        cn1Init();
+    }
+
+    public JXTable(Vector<?> rowData, Vector<?> columnNames) {
+        super(rowData, columnNames);
+        cn1Init();
+    }
+
+    public JXTable(Object[][] rowData, Object[] columnNames) {
+        super(rowData, columnNames);
+        cn1Init();
+    }
+
+    private void cn1Init() {
+        cn1Ready = true;
+        cn1Editable = true;
+        cn1Sortable = true;
+        cn1SortsOnUpdates = true;
+        cn1VisibleRows = 20;
+        cn1VisibleColumns = -1;
+        cn1OldResizeMode = getAutoResizeMode();
+        cn1UpdateRegistry();
+        setAutoCreateRowSorter(true);
+    }
+
+    // ------------------------------------------------------------ rollover
+
+    /// Switches tracking of the cell under the pointer on or off.
+    public void setRolloverEnabled(boolean rolloverEnabled) {
+        boolean old = cn1Rollover;
+        if (old == rolloverEnabled) {
+            return;
+        }
+        cn1Rollover = rolloverEnabled;
+        if (rolloverEnabled) {
+            cn1RolloverProducer = createRolloverProducer();
+            cn1RolloverProducer.install(this);
+        } else {
+            if (cn1RolloverProducer != null) {
+                cn1RolloverProducer.release(this);
+                cn1RolloverProducer = null;
+            }
+            putClientProperty(RolloverProducer.ROLLOVER_KEY, null);
+            repaint();
+        }
+        firePropertyChange("rolloverEnabled", old, rolloverEnabled);
+    }
+
+    public boolean isRolloverEnabled() {
+        return cn1Rollover;
+    }
+
+    protected RolloverProducer createRolloverProducer() {
+        return new RolloverProducer() {
+            @Override
+            protected void updateRolloverPoint(JComponent component, Point mousePoint) {
+                int col = columnAtPoint(mousePoint);
+                int row = rowAtPoint(mousePoint);
+                if (col < 0 || row < 0) {
+                    row = -1;
+                    col = -1;
+                }
+                rollover.setLocation(col, row);
+            }
+
+            @Override
+            protected void updateClientProperty(JComponent component, String property, boolean fireAlways) {
+                Object before = component.getClientProperty(property);
+                super.updateClientProperty(component, property, fireAlways);
+                Object after = component.getClientProperty(property);
+                if (before == null ? after != null : !before.equals(after)) {
+                    component.repaint();
+                }
+            }
+
+            @Override
+            public void mouseExited(com.codename1.desktopcompat.java.awt.event.MouseEvent e) {
+                super.mouseExited(e);
+                repaint();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ column control
+
+    public boolean isColumnControlVisible() {
+        return cn1ColumnControlVisible;
+    }
+
+    /// Makes the column control the upper trailing corner of the scroll
+    /// pane the table is in, or takes it out again. The layer's scroll
+    /// pane records its corners and shows none: see
+    /// [ColumnControlButton].
+    public void setColumnControlVisible(boolean visible) {
+        boolean old = cn1ColumnControlVisible;
+        if (old == visible) {
+            return;
+        }
+        cn1ColumnControlVisible = visible;
+        cn1ConfigureColumnControl();
+        firePropertyChange("columnControlVisible", old, visible);
+    }
+
+    private JScrollPane cn1ScrollPane() {
+        Container parent = getParent();
+        if (parent instanceof JViewport) {
+            Container pane = parent.getParent();
+            if (pane instanceof JScrollPane && ((JScrollPane) pane).getViewport() == parent) {
+                return (JScrollPane) pane;
+            }
+        }
+        return null;
+    }
+
+    private void cn1ConfigureColumnControl() {
+        JScrollPane pane = cn1ScrollPane();
+        if (pane == null) {
+            return;
+        }
+        if (cn1ColumnControlVisible) {
+            pane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, getColumnControl());
+        } else if (cn1ColumnControl != null
+                && pane.getCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER) == cn1ColumnControl) {
+            pane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, null);
+        }
+    }
+
+    @Override
+    protected void configureEnclosingScrollPane() {
+        super.configureEnclosingScrollPane();
+        if (cn1Ready) {
+            cn1ConfigureColumnControl();
+        }
+    }
+
+    /// The column control, made on first use.
+    public JComponent getColumnControl() {
+        if (cn1ColumnControl == null) {
+            cn1ColumnControl = createDefaultColumnControl();
+        }
+        return cn1ColumnControl;
+    }
+
+    public void setColumnControl(JComponent columnControl) {
+        JComponent old = cn1ColumnControl;
+        JScrollPane pane = cn1ScrollPane();
+        if (pane != null && old != null && pane.getCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER) == old) {
+            pane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, null);
+        }
+        cn1ColumnControl = columnControl;
+        cn1ConfigureColumnControl();
+        firePropertyChange("columnControl", old, columnControl);
+    }
+
+    protected JComponent createDefaultColumnControl() {
+        return new ColumnControlButton(this);
+    }
+
+    // ------------------------------------------------------------ packing
+
+    /// Packs every column with the default margin.
+    public void packAll() {
+        packTable(-1);
+    }
+
+    /// Packs the selected column, if there is one.
+    public void packSelected() {
+        int selected = getColumnModel().getSelectionModel().getLeadSelectionIndex();
+        if (selected >= 0 && selected < getColumnCount()) {
+            packColumn(selected, -1);
+        }
+    }
+
+    public void packTable(int margin) {
+        for (int c = 0; c < getColumnCount(); c++) {
+            packColumn(c, margin);
+        }
+    }
+
+    public void packColumn(int column, int margin) {
+        packColumn(column, margin, -1);
+    }
+
+    /// Gives a column, by view index, the preferred width its header and
+    /// cells need plus `margin` on both sides, at most `max` (-1: no
+    /// limit).
+    public void packColumn(int column, int margin, int max) {
+        TableColumnExt ext = getColumnExt(column);
+        if (ext == null) {
+            return;
+        }
+        getColumnFactory().packColumn(this, ext, margin, max);
+        resizeAndRepaint();
+    }
+
+    // ------------------------------------------------------------ horizontal scrolling
+
+    /// With `true` the columns keep their preferred widths and the
+    /// scroll pane scrolls them; with `false` the resize mode the table
+    /// had before comes back.
+    public void setHorizontalScrollEnabled(boolean enabled) {
+        boolean old = isHorizontalScrollEnabled();
+        if (enabled == old) {
+            return;
+        }
+        if (enabled) {
+            int mode = getAutoResizeMode();
+            cn1HorizontalScroll = true;
+            super.setAutoResizeMode(AUTO_RESIZE_OFF);
+            cn1OldResizeMode = mode;
+        } else {
+            cn1HorizontalScroll = false;
+            super.setAutoResizeMode(cn1OldResizeMode == AUTO_RESIZE_OFF ? AUTO_RESIZE_SUBSEQUENT_COLUMNS
+                    : cn1OldResizeMode);
+        }
+        firePropertyChange("horizontalScrollEnabled", old, isHorizontalScrollEnabled());
+    }
+
+    public boolean isHorizontalScrollEnabled() {
+        return cn1HorizontalScroll && getAutoResizeMode() == AUTO_RESIZE_OFF;
+    }
+
+    @Override
+    public void setAutoResizeMode(int mode) {
+        if (mode != AUTO_RESIZE_OFF) {
+            cn1OldResizeMode = mode;
+            cn1HorizontalScroll = false;
+        }
+        super.setAutoResizeMode(mode);
+    }
+
+    // ------------------------------------------------------------ model
+
+    @Override
+    public void setModel(TableModel dataModel) {
+        super.setModel(dataModel);
+        if (!cn1Ready) {
+            return;
+        }
+        cn1UpdateRegistry();
+        if (cn1AutoSorter) {
+            setRowSorter(createDefaultRowSorter());
+        } else {
+            configureSorterProperties();
+        }
+    }
+
+    @Override
+    public void tableChanged(TableModelEvent e) {
+        super.tableChanged(e);
+        if (cn1Ready && isStructureChanged(e)) {
+            cn1UpdateRegistry();
+            configureSorterProperties();
+        }
+    }
+
+    protected boolean isStructureChanged(TableModelEvent e) {
+        return e == null || e.getFirstRow() == TableModelEvent.HEADER_ROW;
+    }
+
+    protected boolean isDataChanged(TableModelEvent e) {
+        if (e == null) {
+            return false;
+        }
+        return e.getType() == TableModelEvent.UPDATE && e.getFirstRow() == 0
+                && e.getLastRow() == Integer.MAX_VALUE;
+    }
+
+    protected boolean isUpdate(TableModelEvent e) {
+        if (isStructureChanged(e)) {
+            return false;
+        }
+        return e.getType() == TableModelEvent.UPDATE && e.getLastRow() < Integer.MAX_VALUE;
+    }
+
+    // ------------------------------------------------------------ sorting
+
+    /// Whether the table makes a sort controller of its own for every
+    /// model it is given. On by default.
+    @Override
+    public void setAutoCreateRowSorter(boolean autoCreateRowSorter) {
+        boolean old = cn1AutoSorter;
+        cn1AutoSorter = autoCreateRowSorter;
+        if (autoCreateRowSorter) {
+            setRowSorter(createDefaultRowSorter());
+        }
+        firePropertyChange("autoCreateRowSorter", old, autoCreateRowSorter);
+    }
+
+    @Override
+    public boolean getAutoCreateRowSorter() {
+        return cn1AutoSorter;
+    }
+
+    @Override
+    public void setRowSorter(RowSorter<? extends TableModel> sorter) {
+        super.setRowSorter(sorter);
+        if (cn1Ready) {
+            configureSorterProperties();
+        }
+    }
+
+    protected RowSorter<? extends TableModel> createDefaultRowSorter() {
+        return new TableSortController<TableModel>(getModel());
+    }
+
+    /// Hands the table's sorting properties, and those of its columns,
+    /// to a sorter that is a sort controller.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    protected void configureSorterProperties() {
+        if (!getControlsSorterProperties()) {
+            return;
+        }
+        SortController controller = getSortController();
+        controller.setStringValueProvider(getStringValueRegistry());
+        controller.setSortable(cn1Sortable);
+        controller.setSortsOnUpdates(cn1SortsOnUpdates);
+        if (cn1SortCycle != null) {
+            controller.setSortOrderCycle(cn1SortCycle);
+        }
+        int modelColumns = getModel().getColumnCount();
+        List<TableColumn> columns = getColumns(true);
+        for (int i = 0; i < columns.size(); i++) {
+            TableColumn c = columns.get(i);
+            int index = c.getModelIndex();
+            if (c instanceof TableColumnExt && index >= 0 && index < modelColumns) {
+                TableColumnExt ext = (TableColumnExt) c;
+                controller.setSortable(index, ext.isSortable());
+                controller.setComparator(index, ext.getComparator());
+            }
+        }
+        controller.setRowFilter(cn1RowFilter);
+    }
+
+    /// Switches sorting by the user, and through the table's sort
+    /// methods, on or off.
+    public void setSortable(boolean sortable) {
+        boolean old = cn1Sortable;
+        cn1Sortable = sortable;
+        if (getControlsSorterProperties()) {
+            getSortController().setSortable(sortable);
+        }
+        firePropertyChange("sortable", old, sortable);
+    }
+
+    public boolean isSortable() {
+        return cn1Sortable;
+    }
+
+    public void setSortsOnUpdates(boolean sortsOnUpdates) {
+        boolean old = cn1SortsOnUpdates;
+        cn1SortsOnUpdates = sortsOnUpdates;
+        if (getControlsSorterProperties()) {
+            getSortController().setSortsOnUpdates(sortsOnUpdates);
+        }
+        firePropertyChange("sortsOnUpdates", old, sortsOnUpdates);
+    }
+
+    public boolean getSortsOnUpdates() {
+        return cn1SortsOnUpdates;
+    }
+
+    /// Sets the orders a click on a header steps a column through.
+    public void setSortOrderCycle(SortOrder... cycle) {
+        SortOrder[] copy = new SortOrder[cycle == null ? 0 : cycle.length];
+        for (int i = 0; i < copy.length; i++) {
+            copy[i] = cycle[i];
+        }
+        cn1SortCycle = copy;
+        if (getControlsSorterProperties()) {
+            getSortController().setSortOrderCycle(copy);
+        }
+    }
+
+    public SortOrder[] getSortOrderCycle() {
+        SortOrder[] from = cn1SortCycle;
+        if (from == null) {
+            return TableSortController.getDefaultSortOrderCycle();
+        }
+        SortOrder[] copy = new SortOrder[from.length];
+        for (int i = 0; i < copy.length; i++) {
+            copy[i] = from[i];
+        }
+        return copy;
+    }
+
+    /// Shows only the rows the filter includes; `null` shows all. Needs
+    /// a sort controller, which the table has unless it was taken away.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public <R extends TableModel> void setRowFilter(RowFilter<? super R, ? super Integer> filter) {
+        cn1RowFilter = filter;
+        if (hasSortController()) {
+            SortController controller = getSortController();
+            controller.setRowFilter(filter);
+        }
+    }
+
+    public RowFilter<?, ?> getRowFilter() {
+        return hasSortController() ? getSortController().getRowFilter() : cn1RowFilter;
+    }
+
+    /// Takes the sorting off every sortable column.
+    public void resetSortOrder() {
+        if (hasSortController()) {
+            getSortController().resetSortOrders();
+        }
+    }
+
+    /// Moves a column, by view index, to its next sort order.
+    public void toggleSortOrder(int columnIndex) {
+        if (hasSortController()) {
+            getSortController().toggleSortOrder(convertColumnIndexToModel(columnIndex));
+        }
+    }
+
+    public void setSortOrder(int columnIndex, SortOrder sortOrder) {
+        if (hasSortController()) {
+            getSortController().setSortOrder(convertColumnIndexToModel(columnIndex), sortOrder);
+        }
+    }
+
+    public SortOrder getSortOrder(int columnIndex) {
+        if (hasSortController()) {
+            return getSortController().getSortOrder(convertColumnIndexToModel(columnIndex));
+        }
+        return SortOrder.UNSORTED;
+    }
+
+    /// Moves the column with the identifier, visible or hidden, to its
+    /// next sort order.
+    public void toggleSortOrder(Object identifier) {
+        TableColumnExt column = getColumnExt(identifier);
+        if (column != null && hasSortController()) {
+            getSortController().toggleSortOrder(column.getModelIndex());
+        }
+    }
+
+    public void setSortOrder(Object identifier, SortOrder sortOrder) {
+        TableColumnExt column = getColumnExt(identifier);
+        if (column != null && hasSortController()) {
+            getSortController().setSortOrder(column.getModelIndex(), sortOrder);
+        }
+    }
+
+    public SortOrder getSortOrder(Object identifier) {
+        TableColumnExt column = getColumnExt(identifier);
+        if (column != null && hasSortController()) {
+            return getSortController().getSortOrder(column.getModelIndex());
+        }
+        return SortOrder.UNSORTED;
+    }
+
+    /// The row sorter when it is a sort controller, else `null`.
+    @SuppressWarnings("unchecked")
+    protected SortController<? extends TableModel> getSortController() {
+        RowSorter<? extends TableModel> sorter = getRowSorter();
+        if (sorter instanceof SortController) {
+            return (SortController<? extends TableModel>) sorter;
+        }
+        return null;
+    }
+
+    protected boolean hasSortController() {
+        return getRowSorter() instanceof SortController;
+    }
+
+    /// Whether the table writes its sorting properties into the sorter:
+    /// when the sorter is a sort controller the table made itself.
+    protected boolean getControlsSorterProperties() {
+        return hasSortController() && getAutoCreateRowSorter();
+    }
+
+    /// The column the rows are sorted by first, visible or hidden, or
+    /// `null`.
+    public TableColumn getSortedColumn() {
+        RowSorter<? extends TableModel> sorter = getRowSorter();
+        if (sorter == null) {
+            return null;
+        }
+        RowSorter.SortKey key = SortUtils.getFirstSortingKey(sorter.getSortKeys());
+        if (key == null) {
+            return null;
+        }
+        List<TableColumn> columns = getColumns(true);
+        for (int i = 0; i < columns.size(); i++) {
+            if (columns.get(i).getModelIndex() == key.getColumn()) {
+                return columns.get(i);
+            }
+        }
+        return null;
+    }
+
+    // ------------------------------------------------------------ columns
+
+    @Override
+    protected TableColumnModel createDefaultColumnModel() {
+        return new DefaultTableColumnModelExt();
+    }
+
+    @Override
+    public void columnAdded(TableColumnModelEvent e) {
+        super.columnAdded(e);
+        if (cn1Ready) {
+            cn1UpdateRegistry();
+            configureSorterProperties();
+        }
+    }
+
+    /// The visible column at a view index.
+    public TableColumn getColumn(int viewColumnIndex) {
+        return getColumnModel().getColumn(viewColumnIndex);
+    }
+
+    /// The visible columns in view order.
+    public List<TableColumn> getColumns() {
+        return getColumns(false);
+    }
+
+    public int getColumnMargin() {
+        return getColumnModel().getColumnMargin();
+    }
+
+    public void setColumnMargin(int value) {
+        getColumnModel().setColumnMargin(value);
+    }
+
+    /// The number of columns, hidden ones included when asked for.
+    public int getColumnCount(boolean includeHidden) {
+        TableColumnModel cm = getColumnModel();
+        if (cm instanceof TableColumnModelExt) {
+            return ((TableColumnModelExt) cm).getColumnCount(includeHidden);
+        }
+        return cm.getColumnCount();
+    }
+
+    /// The columns in order, hidden ones included when asked for.
+    public List<TableColumn> getColumns(boolean includeHidden) {
+        TableColumnModel cm = getColumnModel();
+        if (cm instanceof TableColumnModelExt) {
+            return ((TableColumnModelExt) cm).getColumns(includeHidden);
+        }
+        List<TableColumn> out = new ArrayList<TableColumn>();
+        for (int i = 0; i < cm.getColumnCount(); i++) {
+            out.add(cm.getColumn(i));
+        }
+        return out;
+    }
+
+    /// The column with the identifier, visible or hidden, when it is a
+    /// [TableColumnExt]; else `null`.
+    public TableColumnExt getColumnExt(Object identifier) {
+        if (identifier == null) {
+            return null;
+        }
+        List<TableColumn> columns = getColumns(true);
+        for (int i = 0; i < columns.size(); i++) {
+            TableColumn c = columns.get(i);
+            if (c instanceof TableColumnExt && identifier.equals(c.getIdentifier())) {
+                return (TableColumnExt) c;
+            }
+        }
+        return null;
+    }
+
+    /// The visible column at a view index when it is a [TableColumnExt];
+    /// else `null`.
+    public TableColumnExt getColumnExt(int viewColumnIndex) {
+        TableColumnModel cm = getColumnModel();
+        if (viewColumnIndex < 0 || viewColumnIndex >= cm.getColumnCount()) {
+            return null;
+        }
+        TableColumn c = cm.getColumn(viewColumnIndex);
+        return c instanceof TableColumnExt ? (TableColumnExt) c : null;
+    }
+
+    /// A property of a column changed.
+    @Override
+    public void columnPropertyChange(PropertyChangeEvent event) {
+        String name = event.getPropertyName();
+        if ("editable".equals(name)) {
+            if (isEditing()) {
+                removeEditor();
+            }
+        } else if ("sortable".equals(name) || "comparator".equals(name)) {
+            configureSorterProperties();
+        } else if (TableColumn.CELL_RENDERER_PROPERTY.equals(name)) {
+            cn1UpdateRegistry();
+        } else if (TableColumn.HEADER_VALUE_PROPERTY.equals(name) && getTableHeader() != null) {
+            getTableHeader().repaint();
+        }
+        repaint();
+    }
+
+    /// Replaces the columns, hidden ones too, by one per column of the
+    /// model, made by the column factory.
+    @Override
+    public final void createDefaultColumnsFromModel() {
+        TableModel m = getModel();
+        if (m == null) {
+            return;
+        }
+        TableColumnModel cm = getColumnModel();
+        List<TableColumn> all = getColumns(true);
+        for (int i = 0; i < all.size(); i++) {
+            cm.removeColumn(all.get(i));
+        }
+        ColumnFactory factory = getColumnFactory();
+        for (int i = 0; i < m.getColumnCount(); i++) {
+            TableColumnExt column = factory.createAndConfigureTableColumn(m, i);
+            if (column != null) {
+                cm.addColumn(column);
+            }
+        }
+    }
+
+    /// The table's own column factory, or the shared one.
+    public ColumnFactory getColumnFactory() {
+        return cn1ColumnFactory != null ? cn1ColumnFactory : ColumnFactory.getInstance();
+    }
+
+    /// Sets the factory that makes this table's columns; `null` goes
+    /// back to the shared one.
+    public void setColumnFactory(ColumnFactory columnFactory) {
+        ColumnFactory old = getColumnFactory();
+        cn1ColumnFactory = columnFactory;
+        firePropertyChange("columnFactory", old, getColumnFactory());
+    }
+
+    // ------------------------------------------------------------ viewport size
+
+    public int getVisibleRowCount() {
+        return cn1VisibleRows;
+    }
+
+    /// Sets how many rows the table asks its scroll pane to show.
+    public void setVisibleRowCount(int visibleRowCount) {
+        if (visibleRowCount < 0) {
+            throw new IllegalArgumentException("visible row count must not be negative " + visibleRowCount);
+        }
+        int old = cn1VisibleRows;
+        if (old == visibleRowCount) {
+            return;
+        }
+        cn1VisibleRows = visibleRowCount;
+        revalidate();
+        firePropertyChange("visibleRowCount", old, visibleRowCount);
+    }
+
+    public int getVisibleColumnCount() {
+        return cn1VisibleColumns;
+    }
+
+    /// Sets how many columns the table asks its scroll pane to show; a
+    /// negative count is all of them.
+    public void setVisibleColumnCount(int visibleColumnCount) {
+        int old = cn1VisibleColumns;
+        if (old == visibleColumnCount) {
+            return;
+        }
+        cn1VisibleColumns = visibleColumnCount;
+        revalidate();
+        firePropertyChange("visibleColumnCount", old, visibleColumnCount);
+    }
+
+    @Override
+    public void setPreferredScrollableViewportSize(Dimension size) {
+        cn1ViewportSizeSet = size != null;
+        if (size != null) {
+            super.setPreferredScrollableViewportSize(size);
+        }
+    }
+
+    /// The size set, or else the visible rows by the visible columns.
+    @Override
+    public Dimension getPreferredScrollableViewportSize() {
+        if (cn1ViewportSizeSet || !cn1Ready) {
+            return super.getPreferredScrollableViewportSize();
+        }
+        int w = getColumnFactory().getPreferredScrollableViewportWidth(this);
+        return new Dimension(w, cn1VisibleRows * getRowHeight());
+    }
+
+    public void scrollRowToVisible(int row) {
+        Rectangle cell = getCellRect(row, 0, false);
+        Rectangle visible = getVisibleRect();
+        cell.x = visible.x;
+        cell.width = visible.width;
+        scrollRectToVisible(cell);
+    }
+
+    public void scrollColumnToVisible(int column) {
+        Rectangle cell = getCellRect(0, column, false);
+        Rectangle visible = getVisibleRect();
+        cell.y = visible.y;
+        cell.height = visible.height;
+        scrollRectToVisible(cell);
+    }
+
+    public void scrollCellToVisible(int row, int column) {
+        scrollRectToVisible(getCellRect(row, column, false));
+    }
+
+    // ------------------------------------------------------------ highlighters
+
+    protected ComponentAdapter getComponentAdapter() {
+        if (dataAdapter == null) {
+            dataAdapter = new TableAdapter(this);
+        }
+        return dataAdapter;
+    }
+
+    /// The adapter, pointed at a cell in view coordinates.
+    protected ComponentAdapter getComponentAdapter(int row, int column) {
+        ComponentAdapter adapter = getComponentAdapter();
+        adapter.row = row;
+        adapter.column = column;
+        return adapter;
+    }
+
+    public void setHighlighters(Highlighter... highlighters) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().setHighlighters(highlighters);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public Highlighter[] getHighlighters() {
+        return getCompoundHighlighter().getHighlighters();
+    }
+
+    public void addHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().addHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public void removeHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().removeHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    protected CompoundHighlighter getCompoundHighlighter() {
+        if (compoundHighlighter == null) {
+            compoundHighlighter = new CompoundHighlighter();
+            compoundHighlighter.addChangeListener(getHighlighterChangeListener());
+        }
+        return compoundHighlighter;
+    }
+
+    protected ChangeListener getHighlighterChangeListener() {
+        if (cn1HighlighterListener == null) {
+            cn1HighlighterListener = createHighlighterChangeListener();
+        }
+        return cn1HighlighterListener;
+    }
+
+    /// A listener that repaints the table when a highlighter changes.
+    protected ChangeListener createHighlighterChangeListener() {
+        return new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                repaint();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ strings
+
+    protected StringValueRegistry getStringValueRegistry() {
+        if (cn1Registry == null) {
+            cn1Registry = createDefaultStringValueRegistry();
+        }
+        return cn1Registry;
+    }
+
+    protected StringValueRegistry createDefaultStringValueRegistry() {
+        return new StringValueRegistry();
+    }
+
+    /// Tells the registry the classes of the model's columns and the
+    /// converters of the columns whose renderer is one.
+    private void cn1UpdateRegistry() {
+        StringValueRegistry registry = getStringValueRegistry();
+        registry.clearColumnStringValues();
+        registry.setColumnClasses(null);
+        TableModel m = getModel();
+        if (m == null) {
+            return;
+        }
+        int n = m.getColumnCount();
+        for (int i = 0; i < n; i++) {
+            registry.setColumnClass(m.getColumnClass(i), i);
+        }
+        List<TableColumn> columns = getColumns(true);
+        for (int i = 0; i < columns.size(); i++) {
+            TableColumn c = columns.get(i);
+            TableCellRenderer r = c.getCellRenderer();
+            if (r instanceof StringValue && c.getModelIndex() >= 0 && c.getModelIndex() < n) {
+                registry.setStringValue((StringValue) r, c.getModelIndex());
+            }
+        }
+    }
+
+    @Override
+    public void setDefaultRenderer(Class<?> columnClass, TableCellRenderer renderer) {
+        super.setDefaultRenderer(columnClass, renderer);
+        getStringValueRegistry().setStringValue(renderer instanceof StringValue ? (StringValue) renderer : null,
+                columnClass);
+    }
+
+    /// The text the table shows for a cell, in view coordinates: what
+    /// the cell's renderer says when it is a `StringValue`, else the
+    /// value's `toString`.
+    public String getStringAt(int row, int column) {
+        TableCellRenderer renderer = getCellRenderer(row, column);
+        Object value = getValueAt(row, column);
+        if (renderer instanceof StringValue) {
+            return ((StringValue) renderer).getString(value);
+        }
+        return StringValues.TO_STRING.getString(value);
+    }
+
+    // ------------------------------------------------------------ rendering
+
+    private static final class Memory {
+        DefaultTableCellRenderer renderer;
+        Color background;
+        Color foreground;
+        boolean dirty;
+    }
+
+    private static boolean cn1Same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    private Memory cn1Memory(DefaultTableCellRenderer renderer, int row, int column, boolean make) {
+        if (cn1Memories == null) {
+            cn1Memories = new ArrayList<Memory>();
+        }
+        for (int i = 0; i < cn1Memories.size(); i++) {
+            if (cn1Memories.get(i).renderer == renderer) {
+                return cn1Memories.get(i);
+            }
+        }
+        if (!make) {
+            return null;
+        }
+        // First sight: ask for an unselected cell, which shows the
+        // colors set on the renderer, or the table's when none was.
+        renderer.getTableCellRendererComponent(this, getValueAt(row, column), false, false, row, column);
+        Memory m = new Memory();
+        m.renderer = renderer;
+        Color bg = renderer.getBackground();
+        Color fg = renderer.getForeground();
+        m.background = cn1Same(bg, getBackground()) ? null : bg;
+        m.foreground = cn1Same(fg, getForeground()) ? null : fg;
+        if (cn1Memories.size() >= 32) {
+            cn1Memories.remove(0);
+        }
+        cn1Memories.add(m);
+        return m;
+    }
+
+    /// Asks the renderer for the cell's component and passes that
+    /// through the table's highlighters and then the column's.
+    @Override
+    public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
+        Memory memory = null;
+        if (renderer instanceof DefaultTableCellRenderer) {
+            DefaultTableCellRenderer dtcr = (DefaultTableCellRenderer) renderer;
+            memory = cn1Memory(dtcr, row, column, true);
+            if (memory.dirty) {
+                resetDefaultTableCellRendererColors(dtcr, row, column);
+            }
+        }
+        Component stamp = super.prepareRenderer(renderer, row, column);
+        if (stamp == null) {
+            return null;
+        }
+        Color bg = stamp.getBackground();
+        Color fg = stamp.getForeground();
+        Component before = stamp;
+        ComponentAdapter adapter = getComponentAdapter(row, column);
+        if (compoundHighlighter != null) {
+            stamp = compoundHighlighter.highlight(stamp, adapter);
+        }
+        TableColumnExt ext = getColumnExt(column);
+        if (ext != null) {
+            stamp = ext.cn1Highlight(stamp, adapter);
+        }
+        if (memory != null && before == memory.renderer
+                && (!cn1Same(bg, before.getBackground()) || !cn1Same(fg, before.getForeground()))) {
+            memory.dirty = true;
+        }
+        return stamp;
+    }
+
+    /// The highlighted component of a cell with the cell's own renderer.
+    public Component prepareRenderer(int row, int column) {
+        return prepareRenderer(getCellRenderer(row, column), row, column);
+    }
+
+    /// Gives a `DefaultTableCellRenderer` back the colors it had before
+    /// a highlighter changed them, which it would otherwise use for
+    /// every unselected cell from then on.
+    protected void resetDefaultTableCellRendererColors(Component renderer, int row, int column) {
+        if (!(renderer instanceof DefaultTableCellRenderer)) {
+            return;
+        }
+        Memory memory = cn1Memory((DefaultTableCellRenderer) renderer, row, column, false);
+        if (memory != null) {
+            renderer.setBackground(memory.background);
+            renderer.setForeground(memory.foreground);
+            memory.dirty = false;
+        }
+    }
+
+    /// The SwingX renderers: text for objects, numbers at the trailing
+    /// edge, dates in the device's format and a check box for booleans.
+    /// Icons keep the renderer the plain table has.
+    @Override
+    protected void createDefaultRenderers() {
+        super.createDefaultRenderers();
+        setDefaultRenderer(Object.class, new DefaultTableRenderer());
+        setDefaultRenderer(Number.class, new DefaultTableRenderer(StringValues.NUMBER_TO_STRING,
+                SwingConstants.RIGHT));
+        setDefaultRenderer(Date.class, new DefaultTableRenderer(StringValues.DATE_TO_STRING));
+        setDefaultRenderer(Boolean.class, new DefaultTableRenderer(new CheckBoxProvider()));
+    }
+
+    // ------------------------------------------------------------ editing
+
+    public boolean isEditable() {
+        return cn1Editable;
+    }
+
+    /// Switches editing of the whole table on or off; a cell is editable
+    /// when the table, its column and the model all say so.
+    public void setEditable(boolean editable) {
+        boolean old = cn1Editable;
+        cn1Editable = editable;
+        if (!editable && isEditing()) {
+            removeEditor();
+        }
+        firePropertyChange("editable", old, editable);
+    }
+
+    @Override
+    public boolean isCellEditable(int row, int column) {
+        if (!cn1Editable) {
+            return false;
+        }
+        TableColumnExt ext = getColumnExt(column);
+        if (ext != null && !ext.isEditable()) {
+            return false;
+        }
+        return super.isCellEditable(row, column);
+    }
+
+    /// Shows or hides the horizontal and the vertical grid lines.
+    public void setShowGrid(boolean showHorizontalLines, boolean showVerticalLines) {
+        setShowHorizontalLines(showHorizontalLines);
+        setShowVerticalLines(showVerticalLines);
+    }
+
+    // ------------------------------------------------------------ adapter
+
+    private static final class TableAdapter extends ComponentAdapter {
+
+        private final JXTable table;
+
+        TableAdapter(JXTable table) {
+            super(table);
+            this.table = table;
+        }
+
+        @Override
+        public String getColumnName(int columnIndex) {
+            return table.getModel().getColumnName(columnIndex);
+        }
+
+        private TableColumn byModelIndex(int columnIndex) {
+            List<TableColumn> columns = table.getColumns(true);
+            for (int i = 0; i < columns.size(); i++) {
+                if (columns.get(i).getModelIndex() == columnIndex) {
+                    return columns.get(i);
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public Object getColumnIdentifierAt(int columnIndex) {
+            if (columnIndex < 0 || columnIndex >= getColumnCount()) {
+                throw new ArrayIndexOutOfBoundsException("invalid column index: " + columnIndex);
+            }
+            TableColumn c = byModelIndex(columnIndex);
+            return c != null ? c.getIdentifier() : null;
+        }
+
+        @Override
+        public int getColumnIndex(Object identifier) {
+            TableColumnExt c = table.getColumnExt(identifier);
+            return c != null ? c.getModelIndex() : -1;
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return table.getModel().getColumnClass(column);
+        }
+
+        @Override
+        public int getColumnCount() {
+            return table.getModel().getColumnCount();
+        }
+
+        @Override
+        public int getRowCount() {
+            return table.getModel().getRowCount();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return table.getModel().getValueAt(row, column);
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            int view = table.convertColumnIndexToView(column);
+            if (view >= 0) {
+                return table.isCellEditable(row, view);
+            }
+            return table.getModel().isCellEditable(table.convertRowIndexToModel(row), column);
+        }
+
+        @Override
+        public String getStringAt(int row, int column) {
+            return table.getStringValueRegistry().getStringValue(row, column).getString(getValueAt(row, column));
+        }
+
+        @Override
+        public Rectangle getCellBounds() {
+            return table.getCellRect(row, column, false);
+        }
+
+        @Override
+        public boolean hasFocus() {
+            return table.isFocusOwner() && table.getSelectionModel().getLeadSelectionIndex() == row
+                    && table.getColumnModel().getSelectionModel().getLeadSelectionIndex() == column;
+        }
+
+        @Override
+        public boolean isSelected() {
+            return table.isCellSelected(row, column);
+        }
+
+        @Override
+        public boolean isEditable() {
+            return table.isCellEditable(row, column);
+        }
+
+        @Override
+        public int convertColumnIndexToView(int columnModelIndex) {
+            return table.convertColumnIndexToView(columnModelIndex);
+        }
+
+        @Override
+        public int convertColumnIndexToModel(int columnViewIndex) {
+            return table.convertColumnIndexToModel(columnViewIndex);
+        }
+
+        @Override
+        public int convertRowIndexToView(int rowModelIndex) {
+            return table.convertRowIndexToView(rowModelIndex);
+        }
+
+        @Override
+        public int convertRowIndexToModel(int rowViewIndex) {
+            return table.convertRowIndexToModel(rowViewIndex);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTaskPane.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTaskPane.java
new file mode 100644
index 00000000000..6c29b50aa0d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTaskPane.java
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.BorderFactory;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+
+/// A titled group that opens and closes: a title bar with a chevron over
+/// a [JXCollapsiblePane].
+///
+/// A click or tap on the title bar toggles the group. Components added to
+/// the task pane, and the layout set on it, go to the content pane of the
+/// collapsible pane; [#add(Action)] adds a [JXHyperlink] for an action.
+///
+/// The title bar is drawn in the colors Codename One's theme gives a
+/// table header, stronger for a special pane, and the title itself is a
+/// Codename One label.
+///
+/// ## What differs from SwingX
+///
+///  - There is no look and feel delegate, so the bar does not take a
+///    platform's task pane look, and there is no rollover effect.
+///  - Mnemonics are absent, as is the keyboard toggle.
+public class JXTaskPane extends JPanel implements JXCollapsiblePane.CollapsiblePaneContainer {
+
+    public static final String SCROLL_ON_EXPAND_CHANGED_KEY = "scrollOnExpand";
+    public static final String TITLE_CHANGED_KEY = "title";
+    public static final String ICON_CHANGED_KEY = "icon";
+    public static final String SPECIAL_CHANGED_KEY = "special";
+    public static final String ANIMATED_CHANGED_KEY = "animated";
+
+    private static final int CHEVRON = 24;
+    private static final int PAD = 8;
+
+    private boolean constructed;
+    private JXCollapsiblePane collapsePane;
+    private TitleBar bar;
+    private String title;
+    private Icon icon;
+    private boolean special;
+    private boolean scrollOnExpand;
+
+    public JXTaskPane() {
+        this((String) null);
+    }
+
+    public JXTaskPane(String title) {
+        this(title, null);
+    }
+
+    public JXTaskPane(Icon icon) {
+        this(null, icon);
+    }
+
+    public JXTaskPane(String title, Icon icon) {
+        super.setLayout(new Stack());
+        setOpaque(false);
+        bar = new TitleBar();
+        collapsePane = new JXCollapsiblePane();
+        collapsePane.setOpaque(false);
+        collapsePane.setBorder(BorderFactory.createEmptyBorder(PAD, PAD, PAD, PAD));
+        super.addImpl(bar, null, -1);
+        super.addImpl(collapsePane, null, -1);
+        collapsePane.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent evt) {
+                String name = evt.getPropertyName();
+                if ("collapsed".equals(name)) {
+                    bar.repaint();
+                    firePropertyChange("collapsed", evt.getOldValue(), evt.getNewValue());
+                } else if ("animationState".equals(name) && "expanded".equals(evt.getNewValue())
+                        && scrollOnExpand) {
+                    ScrollDelegate.reveal(JXTaskPane.this, new Rectangle(0, 0, getWidth(),
+                            getPreferredSize().height));
+                }
+            }
+        });
+        constructed = true;
+        setTitle(title);
+        setIcon(icon);
+    }
+
+    /// The bar over the content: background, title label and chevron.
+    private final class TitleBar extends JComponent {
+
+        private final JLabel label = new JLabel();
+
+        TitleBar() {
+            label.setFont(Fonts.defaultFont().deriveFont(Font.BOLD));
+            label.setHorizontalAlignment(SwingConstants.LEFT);
+            add(label);
+            addMouseListener(new MouseAdapter() {
+                @Override
+                public void mouseClicked(MouseEvent e) {
+                    if (JXTaskPane.this.isEnabled()) {
+                        setCollapsed(!isCollapsed());
+                    }
+                }
+            });
+        }
+
+        @Override
+        public Dimension getPreferredSize() {
+            Dimension d = label.getPreferredSize();
+            int min = CellTheme.touch() ? 40 : 26;
+            return new Dimension(d.width + 2 * PAD + CHEVRON, Math.max(min, d.height + PAD));
+        }
+
+        @Override
+        public void doLayout() {
+            label.setBounds(PAD, 0, Math.max(0, getWidth() - 2 * PAD - CHEVRON), getHeight());
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            Color back = CellTheme.headerBackground(null);
+            Color text = CellTheme.headerForeground(null);
+            if (special) {
+                back = CellTheme.mix(back, text, 0.25f);
+            }
+            g.setColor(back);
+            g.fillRect(0, 0, getWidth(), getHeight());
+            g.setColor(text);
+            int cx = getWidth() - PAD - CHEVRON / 2;
+            int cy = getHeight() / 2;
+            int tip = isCollapsed() ? 3 : -3;
+            g.drawLine(cx - 5, cy - tip, cx, cy + tip);
+            g.drawLine(cx, cy + tip, cx + 5, cy - tip);
+        }
+    }
+
+    /// The bar on top at its preferred height, the collapsible pane under
+    /// it at its own.
+    private final class Stack implements LayoutManager {
+
+        @Override
+        public void addLayoutComponent(String name, Component comp) {
+        }
+
+        @Override
+        public void removeLayoutComponent(Component comp) {
+        }
+
+        @Override
+        public Dimension preferredLayoutSize(Container parent) {
+            Insets in = getInsets();
+            if (bar == null) {
+                return new Dimension(in.left + in.right, in.top + in.bottom);
+            }
+            Dimension b = bar.getPreferredSize();
+            Dimension c = collapsePane.getPreferredSize();
+            return new Dimension(Math.max(b.width, c.width) + in.left + in.right,
+                    b.height + c.height + in.top + in.bottom);
+        }
+
+        @Override
+        public Dimension minimumLayoutSize(Container parent) {
+            Insets in = getInsets();
+            if (bar == null) {
+                return new Dimension(in.left + in.right, in.top + in.bottom);
+            }
+            Dimension b = bar.getPreferredSize();
+            return new Dimension(b.width + in.left + in.right, b.height + in.top + in.bottom);
+        }
+
+        @Override
+        public void layoutContainer(Container parent) {
+            if (bar == null) {
+                return;
+            }
+            Insets in = getInsets();
+            int w = Math.max(0, getWidth() - in.left - in.right);
+            int bh = bar.getPreferredSize().height;
+            bar.setBounds(in.left, in.top, w, bh);
+            int ch = collapsePane.getPreferredSize().height;
+            collapsePane.setBounds(in.left, in.top + bh, w, ch);
+        }
+    }
+
+    /// The pane the components of the group are in.
+    public Container getContentPane() {
+        return collapsePane.getContentPane();
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        String old = this.title;
+        this.title = title;
+        bar.label.setText(title == null ? "" : title);
+        firePropertyChange(TITLE_CHANGED_KEY, old, title);
+        revalidate();
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    public void setIcon(Icon icon) {
+        Icon old = this.icon;
+        this.icon = icon;
+        bar.label.setIcon(icon);
+        firePropertyChange(ICON_CHANGED_KEY, old, icon);
+        revalidate();
+    }
+
+    public boolean isSpecial() {
+        return special;
+    }
+
+    /// Marks the group as the one that stands out; its bar is drawn
+    /// stronger.
+    public void setSpecial(boolean special) {
+        boolean old = this.special;
+        this.special = special;
+        if (old != special) {
+            firePropertyChange(SPECIAL_CHANGED_KEY, old, special);
+            bar.repaint();
+        }
+    }
+
+    /// Sets whether the enclosing scroll pane is scrolled to show the
+    /// whole group once it has opened.
+    public void setScrollOnExpand(boolean scrollOnExpand) {
+        boolean old = this.scrollOnExpand;
+        this.scrollOnExpand = scrollOnExpand;
+        if (old != scrollOnExpand) {
+            firePropertyChange(SCROLL_ON_EXPAND_CHANGED_KEY, old, scrollOnExpand);
+        }
+    }
+
+    public boolean isScrollOnExpand() {
+        return scrollOnExpand;
+    }
+
+    public void setCollapsed(boolean collapsed) {
+        collapsePane.setCollapsed(collapsed);
+    }
+
+    public boolean isCollapsed() {
+        return collapsePane.isCollapsed();
+    }
+
+    public void setAnimated(boolean animated) {
+        boolean old = isAnimated();
+        collapsePane.setAnimated(animated);
+        if (old != animated) {
+            firePropertyChange(ANIMATED_CHANGED_KEY, old, animated);
+        }
+    }
+
+    public boolean isAnimated() {
+        return collapsePane.isAnimated();
+    }
+
+    /// Adds a link that fires `action` and answers it.
+    public Component add(Action action) {
+        JXHyperlink link = new JXHyperlink(action);
+        link.setHorizontalAlignment(SwingConstants.LEFT);
+        add(link);
+        return link;
+    }
+
+    /// The parent, which is what has to be laid out again when the group
+    /// opens or closes.
+    @Override
+    public Container getValidatingContainer() {
+        return getParent();
+    }
+
+    /// Adds to the content pane.
+    @Override
+    protected void addImpl(Component comp, Object constraints, int index) {
+        if (!constructed) {
+            super.addImpl(comp, constraints, index);
+            return;
+        }
+        getContentPane().add(comp, constraints, index);
+    }
+
+    /// Sets the layout of the content pane.
+    @Override
+    public void setLayout(LayoutManager mgr) {
+        if (constructed) {
+            getContentPane().setLayout(mgr);
+        }
+    }
+
+    /// Removes from the content pane.
+    @Override
+    public void remove(Component comp) {
+        getContentPane().remove(comp);
+    }
+
+    /// Removes from the content pane.
+    @Override
+    public void remove(int index) {
+        getContentPane().remove(index);
+    }
+
+    /// Empties the content pane.
+    @Override
+    public void removeAll() {
+        getContentPane().removeAll();
+    }
+
+    /// The title bar; for the tests of this package.
+    JComponent cn1TitleBar() {
+        return bar;
+    }
+
+    /// The collapsible pane under the bar; for the tests of this package.
+    JXCollapsiblePane cn1CollapsiblePane() {
+        return collapsePane;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTaskPaneContainer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTaskPaneContainer.java
new file mode 100644
index 00000000000..c26225a47a3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTaskPaneContainer.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.javax.swing.BorderFactory;
+
+/// The column task panes are stacked in: a [JXPanel] with a
+/// [VerticalLayout] of gap 14 and a margin of the same width around it.
+///
+/// Inside a scroll pane it takes the viewport's width, and its height
+/// too until the task panes need more than that, when it scrolls.
+///
+/// There is no look and feel delegate: the background is the panel's
+/// own, and a gradient can be had with a background painter.
+public class JXTaskPaneContainer extends JXPanel {
+
+    public JXTaskPaneContainer() {
+        super(new VerticalLayout(14));
+        setBorder(BorderFactory.createEmptyBorder(14, 14, 14, 14));
+        setScrollableWidthHint(ScrollableSizeHint.FIT);
+        setScrollableHeightHint(ScrollableSizeHint.PREFERRED_STRETCH);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTextArea.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTextArea.java
new file mode 100644
index 00000000000..5b49e940b12
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTextArea.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport.FocusBehavior;
+
+/// A text area with a prompt: text shown while the area is empty.
+///
+/// The prompt is the hint of the Codename One text area; see
+/// [PromptSupport] for what of its looks is honored.
+public class JXTextArea extends JTextArea {
+
+    public JXTextArea() {
+        this(null);
+    }
+
+    public JXTextArea(String promptText) {
+        this(promptText, null);
+    }
+
+    public JXTextArea(String promptText, Color promptForeground) {
+        this(promptText, promptForeground, null);
+    }
+
+    public JXTextArea(String promptText, Color promptForeground, Color promptBackground) {
+        PromptSupport.init(promptText, promptForeground, promptBackground, this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        PromptSupport.cn1Push(this);
+    }
+
+    public FocusBehavior getFocusBehavior() {
+        return PromptSupport.getFocusBehavior(this);
+    }
+
+    public String getPrompt() {
+        return PromptSupport.getPrompt(this);
+    }
+
+    public Color getPromptForeground() {
+        return PromptSupport.getForeground(this);
+    }
+
+    public Color getPromptBackground() {
+        return PromptSupport.getBackground(this);
+    }
+
+    public Integer getPromptFontStyle() {
+        return PromptSupport.getFontStyle(this);
+    }
+
+    public void setFocusBehavior(FocusBehavior focusBehavior) {
+        PromptSupport.setFocusBehavior(focusBehavior, this);
+    }
+
+    public void setPrompt(String labelText) {
+        PromptSupport.setPrompt(labelText, this);
+    }
+
+    public void setPromptForeground(Color promptTextColor) {
+        PromptSupport.setForeground(promptTextColor, this);
+    }
+
+    /// Recorded only. The name is SwingX's own spelling.
+    public void setPromptBackround(Color color) {
+        PromptSupport.setBackground(color, this);
+    }
+
+    public void setPromptFontStyle(Integer fontStyle) {
+        PromptSupport.setFontStyle(fontStyle, this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTextField.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTextField.java
new file mode 100644
index 00000000000..182a3a95f70
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTextField.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport.FocusBehavior;
+
+/// A text field with a prompt: text shown while the field is empty.
+///
+/// The prompt is the hint of the Codename One text field; see
+/// [PromptSupport] for what of its looks is honored. Buddy components and
+/// the outer margin are absent.
+public class JXTextField extends JTextField {
+
+    public JXTextField() {
+        this(null);
+    }
+
+    public JXTextField(String promptText) {
+        this(promptText, null);
+    }
+
+    public JXTextField(String promptText, Color promptForeground) {
+        this(promptText, promptForeground, null);
+    }
+
+    public JXTextField(String promptText, Color promptForeground, Color promptBackground) {
+        PromptSupport.init(promptText, promptForeground, promptBackground, this);
+    }
+
+    @Override
+    protected void cn1PeerCreated() {
+        super.cn1PeerCreated();
+        PromptSupport.cn1Push(this);
+    }
+
+    public FocusBehavior getFocusBehavior() {
+        return PromptSupport.getFocusBehavior(this);
+    }
+
+    public String getPrompt() {
+        return PromptSupport.getPrompt(this);
+    }
+
+    public Color getPromptForeground() {
+        return PromptSupport.getForeground(this);
+    }
+
+    public Color getPromptBackground() {
+        return PromptSupport.getBackground(this);
+    }
+
+    public Integer getPromptFontStyle() {
+        return PromptSupport.getFontStyle(this);
+    }
+
+    public void setFocusBehavior(FocusBehavior focusBehavior) {
+        PromptSupport.setFocusBehavior(focusBehavior, this);
+    }
+
+    public void setPrompt(String labelText) {
+        PromptSupport.setPrompt(labelText, this);
+    }
+
+    public void setPromptForeground(Color promptTextColor) {
+        PromptSupport.setForeground(promptTextColor, this);
+    }
+
+    /// Recorded only. The name is SwingX's own spelling.
+    public void setPromptBackround(Color color) {
+        PromptSupport.setBackground(color, this);
+    }
+
+    public void setPromptFontStyle(Integer fontStyle) {
+        PromptSupport.setFontStyle(fontStyle, this);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTitledPanel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTitledPanel.java
new file mode 100644
index 00000000000..1af1d1ca1e3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTitledPanel.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import com.codename1.desktopcompat.rt.CellTheme;
+import com.codename1.desktopcompat.rt.Fonts;
+
+/// A panel with a title bar over a content container.
+///
+/// The bar holds an optional component on the left, the title, and an
+/// optional component on the right. Its background is the theme's table
+/// header color unless a title painter is set, which then draws the whole
+/// bar; the title is a Codename One label, bold unless a title font is
+/// set. The panel's own layout is a border layout with the bar in the
+/// north and the content container in the center, and is not to be
+/// replaced: add to [#getContentContainer()].
+///
+/// There is no look and feel delegate, so the bar has no platform
+/// gradient of its own.
+public class JXTitledPanel extends JXPanel {
+
+    public static final String LEFT_DECORATION = "JXTitledPanel.leftDecoration";
+    public static final String RIGHT_DECORATION = "JXTitledPanel.rightDecoration";
+
+    private static final int PAD = 6;
+
+    private final Bar bar = new Bar();
+    private String title = "";
+    private Container contentContainer;
+    private JComponent leftDecoration;
+    private JComponent rightDecoration;
+    private Font titleFont;
+    private Color titleForeground;
+    private Painter titlePainter;
+
+    public JXTitledPanel() {
+        this(" ");
+    }
+
+    public JXTitledPanel(String title) {
+        this(title, new JXPanel());
+    }
+
+    public JXTitledPanel(String title, Container content) {
+        super(new BorderLayout());
+        add(bar, BorderLayout.NORTH);
+        setTitle(title);
+        setContentContainer(content);
+    }
+
+    /// The title bar.
+    private final class Bar extends JComponent {
+
+        private final JLabel label = new JLabel();
+
+        Bar() {
+            label.setFont(Fonts.defaultFont().deriveFont(Font.BOLD));
+            label.setHorizontalAlignment(SwingConstants.LEFT);
+            add(label);
+        }
+
+        @Override
+        public Dimension getPreferredSize() {
+            Dimension d = label.getPreferredSize();
+            int w = d.width + 2 * PAD;
+            int h = d.height;
+            if (leftDecoration != null) {
+                Dimension l = leftDecoration.getPreferredSize();
+                w += l.width + PAD;
+                h = Math.max(h, l.height);
+            }
+            if (rightDecoration != null) {
+                Dimension r = rightDecoration.getPreferredSize();
+                w += r.width + PAD;
+                h = Math.max(h, r.height);
+            }
+            return new Dimension(w, Math.max(CellTheme.touch() ? 40 : 26, h + PAD));
+        }
+
+        @Override
+        public void doLayout() {
+            int left = PAD;
+            int right = getWidth() - PAD;
+            int h = getHeight();
+            if (leftDecoration != null) {
+                Dimension l = leftDecoration.getPreferredSize();
+                int lh = Math.min(h, l.height);
+                leftDecoration.setBounds(left, (h - lh) / 2, l.width, lh);
+                left += l.width + PAD;
+            }
+            if (rightDecoration != null) {
+                Dimension r = rightDecoration.getPreferredSize();
+                int rh = Math.min(h, r.height);
+                right -= r.width;
+                rightDecoration.setBounds(right, (h - rh) / 2, r.width, rh);
+                right -= PAD;
+            }
+            label.setBounds(left, 0, Math.max(0, right - left), h);
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            Painter p = titlePainter;
+            if (p != null && g instanceof Graphics2D) {
+                Graphics2D g2 = (Graphics2D) g.create();
+                try {
+                    paintWith(p, g2);
+                } finally {
+                    g2.dispose();
+                }
+                return;
+            }
+            g.setColor(CellTheme.headerBackground(null));
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+
+        @SuppressWarnings("unchecked")
+        private void paintWith(Painter p, Graphics2D g2) {
+            p.paint(g2, JXTitledPanel.this, getWidth(), getHeight());
+        }
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        String old = this.title;
+        this.title = title == null ? "" : title;
+        bar.label.setText(this.title);
+        firePropertyChange("title", old, this.title);
+        revalidate();
+    }
+
+    /// The container under the title bar; a [JXPanel] unless one was set.
+    public Container getContentContainer() {
+        if (contentContainer == null) {
+            setContentContainer(new JXPanel());
+        }
+        return contentContainer;
+    }
+
+    public void setContentContainer(Container contentPanel) {
+        Container old = contentContainer;
+        if (old != null) {
+            remove(old);
+        }
+        contentContainer = contentPanel;
+        if (contentPanel != null) {
+            add(contentPanel, BorderLayout.CENTER);
+        }
+        firePropertyChange("contentContainer", old, contentPanel);
+        revalidate();
+    }
+
+    /// Puts a component at the right end of the title bar; `null` removes
+    /// the one there.
+    public void setRightDecoration(JComponent decoration) {
+        JComponent old = rightDecoration;
+        if (old != null) {
+            bar.remove(old);
+        }
+        rightDecoration = decoration;
+        if (decoration != null) {
+            bar.add(decoration);
+        }
+        firePropertyChange("rightDecoration", old, decoration);
+        bar.revalidate();
+    }
+
+    public JComponent getRightDecoration() {
+        return rightDecoration;
+    }
+
+    /// Puts a component at the left end of the title bar, before the
+    /// title; `null` removes the one there.
+    public void setLeftDecoration(JComponent decoration) {
+        JComponent old = leftDecoration;
+        if (old != null) {
+            bar.remove(old);
+        }
+        leftDecoration = decoration;
+        if (decoration != null) {
+            bar.add(decoration);
+        }
+        firePropertyChange("leftDecoration", old, decoration);
+        bar.revalidate();
+    }
+
+    public JComponent getLeftDecoration() {
+        return leftDecoration;
+    }
+
+    /// The font set for the title, or `null` for the default bold one.
+    public Font getTitleFont() {
+        return titleFont;
+    }
+
+    public void setTitleFont(Font titleFont) {
+        Font old = this.titleFont;
+        this.titleFont = titleFont;
+        bar.label.setFont(titleFont != null ? titleFont : Fonts.defaultFont().deriveFont(Font.BOLD));
+        firePropertyChange("titleFont", old, titleFont);
+        revalidate();
+    }
+
+    /// Sets what draws the title bar's background, or `null` for the
+    /// theme's color.
+    public void setTitlePainter(Painter p) {
+        Painter old = titlePainter;
+        titlePainter = p;
+        firePropertyChange("titlePainter", old, p);
+        bar.repaint();
+    }
+
+    public Painter getTitlePainter() {
+        return titlePainter;
+    }
+
+    /// The color set for the title, or `null` for the theme's.
+    public Color getTitleForeground() {
+        return titleForeground;
+    }
+
+    public void setTitleForeground(Color titleForeground) {
+        Color old = this.titleForeground;
+        this.titleForeground = titleForeground;
+        bar.label.setForeground(titleForeground);
+        firePropertyChange("titleForeground", old, titleForeground);
+        bar.repaint();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTitledSeparator.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTitledSeparator.java
new file mode 100644
index 00000000000..e857aedd5b2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTitledSeparator.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.GridBagConstraints;
+import com.codename1.desktopcompat.java.awt.GridBagLayout;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JSeparator;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// A separator line with a title in it: a label, and a line that takes
+/// the rest of the width.
+///
+/// The title is at the left with the line after it, at the right with
+/// the line before it, or in the middle with a line on either side,
+/// following [#setHorizontalAlignment(int)].
+///
+/// ## What differs from SwingX
+///
+///  - `LEADING` and `TRAILING` are read as left and right: the layer has
+///    no component orientation, so the orientation members are absent.
+public class JXTitledSeparator extends JXPanel {
+
+    private JLabel label;
+    private JSeparator leftSeparator;
+    private JSeparator rightSeparator;
+
+    /// A separator titled "Untitled".
+    public JXTitledSeparator() {
+        this("Untitled");
+    }
+
+    public JXTitledSeparator(String title) {
+        this(title, SwingConstants.LEADING, null);
+    }
+
+    public JXTitledSeparator(String title, int horizontalAlignment) {
+        this(title, horizontalAlignment, null);
+    }
+
+    public JXTitledSeparator(String title, int horizontalAlignment, Icon icon) {
+        super();
+        setLayout(new GridBagLayout());
+        label = new JLabel(title);
+        label.setIcon(icon);
+        label.setHorizontalAlignment(horizontalAlignment);
+        leftSeparator = new JSeparator();
+        rightSeparator = new JSeparator();
+        layoutSeparator();
+        showTitle();
+        setOpaque(false);
+    }
+
+    private static GridBagConstraints at(int x, boolean line) {
+        GridBagConstraints c = new GridBagConstraints();
+        c.gridx = x;
+        c.gridy = 0;
+        c.anchor = GridBagConstraints.CENTER;
+        if (line) {
+            c.weightx = 1.0;
+            c.fill = GridBagConstraints.HORIZONTAL;
+        } else {
+            c.insets = new Insets(0, x == 0 ? 0 : 3, 0, 3);
+        }
+        return c;
+    }
+
+    private void layoutSeparator() {
+        removeAll();
+        int a = label.getHorizontalAlignment();
+        if (a == SwingConstants.CENTER) {
+            add(leftSeparator, at(0, true));
+            add(label, at(1, false));
+            add(rightSeparator, at(2, true));
+        } else if (a == SwingConstants.RIGHT || a == SwingConstants.TRAILING) {
+            add(rightSeparator, at(0, true));
+            add(label, at(1, false));
+        } else {
+            add(label, at(0, false));
+            add(rightSeparator, at(1, true));
+        }
+        revalidate();
+        repaint();
+    }
+
+    /// Hides the label of an empty title, so the line takes all the width.
+    protected void updateTitle() {
+        showTitle();
+    }
+
+    private void showTitle() {
+        if (label == null) {
+            return;
+        }
+        String t = label.getText();
+        label.setVisible((t != null && t.length() > 0) || label.getIcon() != null);
+    }
+
+    public void setTitle(String title) {
+        String old = getTitle();
+        label.setText(title);
+        updateTitle();
+        firePropertyChange("title", old, getTitle());
+    }
+
+    public String getTitle() {
+        return label.getText();
+    }
+
+    /// Sets where the title is: `LEFT`, `CENTER`, `RIGHT`, `LEADING` or
+    /// `TRAILING` of `SwingConstants`.
+    public void setHorizontalAlignment(int alignment) {
+        int old = getHorizontalAlignment();
+        label.setHorizontalAlignment(alignment);
+        if (old != getHorizontalAlignment()) {
+            layoutSeparator();
+        }
+        firePropertyChange("horizontalAlignment", old, getHorizontalAlignment());
+    }
+
+    public int getHorizontalAlignment() {
+        return label.getHorizontalAlignment();
+    }
+
+    /// Sets on which side of the icon the title's text is.
+    public void setHorizontalTextPosition(int position) {
+        int old = getHorizontalTextPosition();
+        label.setHorizontalTextPosition(position);
+        firePropertyChange("horizontalTextPosition", old, getHorizontalTextPosition());
+    }
+
+    public int getHorizontalTextPosition() {
+        return label.getHorizontalTextPosition();
+    }
+
+    public Icon getIcon() {
+        return label.getIcon();
+    }
+
+    public void setIcon(Icon icon) {
+        Icon old = getIcon();
+        label.setIcon(icon);
+        updateTitle();
+        firePropertyChange("icon", old, getIcon());
+    }
+
+    /// Sets the color of the title too.
+    @Override
+    public void setForeground(Color foreground) {
+        if (label != null) {
+            label.setForeground(foreground);
+        }
+        super.setForeground(foreground);
+    }
+
+    /// Sets the font of the title too.
+    @Override
+    public void setFont(Font font) {
+        if (label != null) {
+            label.setFont(font);
+        }
+        super.setFont(font);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTree.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTree.java
new file mode 100644
index 00000000000..205d6d46424
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTree.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.TreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.CompoundHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.Highlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultTreeRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.rollover.RolloverProducer;
+import java.util.Hashtable;
+import java.util.Vector;
+
+/// A tree with highlighters, rollover, and expanding or collapsing
+/// everything at once.
+///
+/// The renderer set is wrapped: [#getCellRenderer()] answers the wrapper
+/// that applies the highlighters and [#getWrappedCellRenderer()] the
+/// renderer that was set. The default is a SwingX renderer, whose label
+/// takes any color a highlighter gives it. In a highlight predicate a
+/// node has a depth, the root's being 0, and is a leaf or a folder.
+///
+/// Searching, the icon setters, the selection colors and the look and
+/// feel hooks are absent.
+public class JXTree extends JTree {
+
+    protected CompoundHighlighter compoundHighlighter;
+    protected ComponentAdapter dataAdapter;
+
+    private boolean cn1Ready;
+    private DelegatingRenderer cn1Renderer;
+    private ChangeListener cn1HighlighterListener;
+    private boolean cn1Rollover;
+    private RolloverProducer cn1RolloverProducer;
+
+    public JXTree() {
+        super();
+        cn1Init();
+    }
+
+    public JXTree(Object[] value) {
+        super(value);
+        cn1Init();
+    }
+
+    public JXTree(Vector<?> value) {
+        super(value);
+        cn1Init();
+    }
+
+    public JXTree(Hashtable<?, ?> value) {
+        super(value);
+        cn1Init();
+    }
+
+    public JXTree(TreeNode root) {
+        super(root);
+        cn1Init();
+    }
+
+    public JXTree(TreeNode root, boolean asksAllowsChildren) {
+        super(root, asksAllowsChildren);
+        cn1Init();
+    }
+
+    public JXTree(TreeModel newModel) {
+        super(newModel);
+        cn1Init();
+    }
+
+    private void cn1Init() {
+        cn1Ready = true;
+        setCellRenderer(createDefaultCellRenderer());
+    }
+
+    // ------------------------------------------------------------ rows
+
+    /// The text the tree shows for a row, or `null` for no such row.
+    public String getStringAt(int row) {
+        return getStringAt(getPathForRow(row));
+    }
+
+    /// The text the tree shows for the last node of a path.
+    public String getStringAt(TreePath path) {
+        if (path == null) {
+            return null;
+        }
+        Object node = path.getLastPathComponent();
+        TreeCellRenderer renderer = getWrappedCellRenderer();
+        if (renderer instanceof StringValue) {
+            return ((StringValue) renderer).getString(node);
+        }
+        TreeModel m = getModel();
+        return convertValueToText(node, isPathSelected(path), isExpanded(path), m != null && m.isLeaf(node),
+                getRowForPath(path), false);
+    }
+
+    /// Collapses every row, from the last up.
+    public void collapseAll() {
+        for (int i = getRowCount() - 1; i >= 0; i--) {
+            collapseRow(i);
+        }
+    }
+
+    /// Expands every row, including those that expanding brings up.
+    public void expandAll() {
+        for (int i = 0; i < getRowCount(); i++) {
+            expandRow(i);
+        }
+    }
+
+    // ------------------------------------------------------------ rollover
+
+    public void setRolloverEnabled(boolean rolloverEnabled) {
+        boolean old = cn1Rollover;
+        if (old == rolloverEnabled) {
+            return;
+        }
+        cn1Rollover = rolloverEnabled;
+        if (rolloverEnabled) {
+            cn1RolloverProducer = createRolloverProducer();
+            cn1RolloverProducer.install(this);
+        } else {
+            if (cn1RolloverProducer != null) {
+                cn1RolloverProducer.release(this);
+                cn1RolloverProducer = null;
+            }
+            putClientProperty(RolloverProducer.ROLLOVER_KEY, null);
+            repaint();
+        }
+        firePropertyChange("rolloverEnabled", old, rolloverEnabled);
+    }
+
+    public boolean isRolloverEnabled() {
+        return cn1Rollover;
+    }
+
+    protected RolloverProducer createRolloverProducer() {
+        return new RolloverProducer() {
+            @Override
+            protected void updateRolloverPoint(JComponent component, Point mousePoint) {
+                int row = getClosestRowForLocation(mousePoint.x, mousePoint.y);
+                if (row >= 0) {
+                    Rectangle bounds = getRowBounds(row);
+                    if (bounds == null || mousePoint.y < bounds.y || mousePoint.y >= bounds.y + bounds.height) {
+                        row = -1;
+                    }
+                }
+                rollover.setLocation(row >= 0 ? 0 : -1, row);
+            }
+
+            @Override
+            protected void updateClientProperty(JComponent component, String property, boolean fireAlways) {
+                Object before = component.getClientProperty(property);
+                super.updateClientProperty(component, property, fireAlways);
+                Object after = component.getClientProperty(property);
+                if (before == null ? after != null : !before.equals(after)) {
+                    component.repaint();
+                }
+            }
+
+            @Override
+            public void mouseExited(com.codename1.desktopcompat.java.awt.event.MouseEvent e) {
+                super.mouseExited(e);
+                repaint();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ highlighters
+
+    public void setHighlighters(Highlighter... highlighters) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().setHighlighters(highlighters);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public Highlighter[] getHighlighters() {
+        return getCompoundHighlighter().getHighlighters();
+    }
+
+    public void addHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().addHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public void removeHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().removeHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    protected CompoundHighlighter getCompoundHighlighter() {
+        if (compoundHighlighter == null) {
+            compoundHighlighter = new CompoundHighlighter();
+            compoundHighlighter.addChangeListener(getHighlighterChangeListener());
+        }
+        return compoundHighlighter;
+    }
+
+    protected ChangeListener getHighlighterChangeListener() {
+        if (cn1HighlighterListener == null) {
+            cn1HighlighterListener = createHighlighterChangeListener();
+        }
+        return cn1HighlighterListener;
+    }
+
+    protected ChangeListener createHighlighterChangeListener() {
+        return new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                repaint();
+            }
+        };
+    }
+
+    // ------------------------------------------------------------ renderer
+
+    protected TreeCellRenderer createDefaultCellRenderer() {
+        return new DefaultTreeRenderer();
+    }
+
+    /// The renderer the tree paints with: a wrapper that applies the
+    /// highlighters to what the renderer that was set answers.
+    @Override
+    public TreeCellRenderer getCellRenderer() {
+        return cn1Renderer != null ? cn1Renderer : super.getCellRenderer();
+    }
+
+    /// The renderer that was set.
+    public TreeCellRenderer getWrappedCellRenderer() {
+        return cn1Renderer != null ? cn1Renderer.delegate : super.getCellRenderer();
+    }
+
+    /// Sets the renderer; `null` is the default one.
+    @Override
+    public void setCellRenderer(TreeCellRenderer renderer) {
+        if (!cn1Ready) {
+            super.setCellRenderer(renderer);
+            return;
+        }
+        TreeCellRenderer delegate = renderer != null ? renderer : createDefaultCellRenderer();
+        DelegatingRenderer wrapper = new DelegatingRenderer();
+        wrapper.delegate = delegate;
+        cn1Renderer = wrapper;
+        super.setCellRenderer(wrapper);
+    }
+
+    private final class DelegatingRenderer implements TreeCellRenderer {
+        private TreeCellRenderer delegate;
+
+        @Override
+        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
+                boolean leaf, int row, boolean hasFocus) {
+            Component stamp = delegate.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row,
+                    hasFocus);
+            if (stamp != null && compoundHighlighter != null && row >= 0) {
+                stamp = compoundHighlighter.highlight(stamp, getComponentAdapter(row));
+            }
+            return stamp;
+        }
+    }
+
+    // ------------------------------------------------------------ adapter
+
+    protected ComponentAdapter getComponentAdapter() {
+        if (dataAdapter == null) {
+            dataAdapter = new TreeAdapter(this);
+        }
+        return dataAdapter;
+    }
+
+    /// The adapter, pointed at a row.
+    protected ComponentAdapter getComponentAdapter(int index) {
+        ComponentAdapter adapter = getComponentAdapter();
+        adapter.column = 0;
+        adapter.row = index;
+        return adapter;
+    }
+
+    private static final class TreeAdapter extends ComponentAdapter {
+
+        private final JXTree tree;
+
+        TreeAdapter(JXTree tree) {
+            super(tree);
+            this.tree = tree;
+        }
+
+        private TreePath path(int row) {
+            return row >= 0 && row < tree.getRowCount() ? tree.getPathForRow(row) : null;
+        }
+
+        @Override
+        public int getRowCount() {
+            return tree.getRowCount();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            TreePath path = path(row);
+            return path != null ? path.getLastPathComponent() : null;
+        }
+
+        @Override
+        public String getStringAt(int row, int column) {
+            String s = tree.getStringAt(row);
+            return s != null ? s : "";
+        }
+
+        @Override
+        public Rectangle getCellBounds() {
+            return tree.getRowBounds(row);
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            TreePath path = path(row);
+            return path != null && tree.isPathEditable(path);
+        }
+
+        @Override
+        public boolean isEditable() {
+            return isCellEditable(row, column);
+        }
+
+        @Override
+        public boolean isSelected() {
+            return tree.isRowSelected(row);
+        }
+
+        @Override
+        public boolean hasFocus() {
+            return tree.isFocusOwner() && tree.getLeadSelectionRow() == row;
+        }
+
+        @Override
+        public boolean isExpanded() {
+            return tree.isExpanded(row);
+        }
+
+        @Override
+        public int getDepth() {
+            TreePath path = path(row);
+            return path != null ? path.getPathCount() - 1 : 0;
+        }
+
+        @Override
+        public boolean isHierarchical() {
+            return true;
+        }
+
+        @Override
+        public boolean isLeaf() {
+            TreePath path = path(row);
+            TreeModel m = tree.getModel();
+            return path != null && m != null && m.isLeaf(path.getLastPathComponent());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTreeTable.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTreeTable.java
new file mode 100644
index 00000000000..6c313701c03
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTreeTable.java
@@ -0,0 +1,1157 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeWillExpandListener;
+import com.codename1.desktopcompat.javax.swing.table.AbstractTableModel;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableModel;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultTreeRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.TableColumnExt;
+import com.codename1.desktopcompat.org.jdesktop.swingx.treetable.DefaultTreeTableModel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.treetable.TreeTableModel;
+import com.codename1.desktopcompat.rt.CellPainter;
+import com.codename1.desktopcompat.rt.CellTheme;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.EventObject;
+import java.util.List;
+
+/// A table whose rows are the nodes of a tree: one column, the
+/// hierarchical one, indents each row by its depth and has the arrow
+/// that expands and collapses a node, and the others show the node's
+/// values.
+///
+/// ## Model
+///
+/// The model is a
+/// [com.codename1.desktopcompat.org.jdesktop.swingx.treetable.TreeTableModel],
+/// set with [#setTreeTableModel(TreeTableModel)]. The table model is an
+/// adapter the tree table makes itself and [#setModel(TableModel)] takes
+/// nothing else. A row is a node that shows: the children of the
+/// expanded nodes, from the root down. The root has no row unless
+/// [#setRootVisible(boolean)] gives it one, and a hidden root is always
+/// expanded.
+///
+/// ## The hierarchical column
+///
+/// The cell is drawn by a tree cell renderer, which is given the node
+/// and by default shows the model's value for the node in that column.
+/// A press on the arrow, or as many clicks on the cell as
+/// [#setToggleClickCount(int)] says when they do not start an edit,
+/// expands or collapses the node. A press on the arrow selects the row
+/// as well. An editor in this column is placed after the indent.
+///
+/// ## Highlighters
+///
+/// Highlighters see every cell through an adapter that knows the node:
+/// whether it is a leaf, whether it is expanded and how deep it is, the
+/// root being at depth 0. In the hierarchical column they decorate the
+/// tree cell renderer's component, and its background fills the indent.
+///
+/// ## Not here
+///
+/// A tree table is not sortable and not filterable. The tree selection
+/// model and its listeners, the icon setters, the large model and
+/// expands-selected-paths switches, tool tips of the hierarchical column
+/// and drag and drop are absent.
+public class JXTreeTable extends JXTable {
+
+    // None of these has an initializer: the superclass constructor
+    // reaches methods overridden here before one would run.
+    private Rows cn1Tree;
+    private TreeTableModelAdapter cn1Adapter;
+    private HierarchicalRenderer cn1Renderer;
+    private HierarchicalCell cn1Cell;
+    private List<TreeExpansionListener> cn1ExpansionListeners;
+    private boolean cn1LostSelection;
+    private TreePath cn1PressPath;
+    private int cn1ClickBase;
+
+    /// A tree table over an empty model without columns.
+    public JXTreeTable() {
+        this(new DefaultTreeTableModel());
+    }
+
+    /// A tree table over `treeModel`, which must not be `null`.
+    public JXTreeTable(TreeTableModel treeModel) {
+        this(new TreeTableModelAdapter(new Rows(cn1NotNull(treeModel)), treeModel));
+    }
+
+    private JXTreeTable(TreeTableModelAdapter adapter) {
+        super(adapter);
+        cn1Adapter = adapter;
+        cn1Tree = adapter.tree;
+        adapter.table = this;
+        cn1Renderer = new HierarchicalRenderer(this);
+        cn1Tree.addTreeExpansionListener(new ExpansionRelay());
+        super.setSortable(false);
+    }
+
+    private static TreeTableModel cn1NotNull(TreeTableModel treeModel) {
+        if (treeModel == null) {
+            throw new NullPointerException("treeModel must not be null");
+        }
+        return treeModel;
+    }
+
+    // ------------------------------------------------------------ sorting
+
+    /// Does nothing: a tree table is not sortable.
+    @Override
+    public void setSortable(boolean sortable) {
+    }
+
+    /// Does nothing: a tree table is not sortable.
+    @Override
+    public void setAutoCreateRowSorter(boolean autoCreateRowSorter) {
+    }
+
+    /// Does nothing: a tree table is not sortable.
+    @Override
+    public void setRowSorter(RowSorter<? extends TableModel> sorter) {
+    }
+
+    /// The table's own [#setAutoCreateRowSorter(boolean)], for a
+    /// subclass that sorts the rows in a way that keeps the tree.
+    protected void superSetAutoCreateRowSorter(boolean autoCreateRowSorter) {
+        super.setAutoCreateRowSorter(autoCreateRowSorter);
+    }
+
+    /// The table's own [#setSortable(boolean)].
+    protected void superSetSortable(boolean sortable) {
+        super.setSortable(sortable);
+    }
+
+    /// The table's own [#setRowSorter(RowSorter)].
+    protected void superSetRowSorter(RowSorter<? extends TableModel> sorter) {
+        super.setRowSorter(sorter);
+    }
+
+    // ------------------------------------------------------------ model
+
+    /// Replaces the tree table model, which must not be `null`. The
+    /// columns are made again and the expanded nodes forgotten.
+    public void setTreeTableModel(TreeTableModel treeModel) {
+        TreeTableModel old = getTreeTableModel();
+        cn1Adapter.setModel(cn1NotNull(treeModel));
+        firePropertyChange("treeTableModel", old, getTreeTableModel());
+    }
+
+    public TreeTableModel getTreeTableModel() {
+        return cn1Adapter != null ? cn1Adapter.model : null;
+    }
+
+    /// Takes only the adapter the tree table made over its tree table
+    /// model: the model is changed with
+    /// [#setTreeTableModel(TreeTableModel)].
+    @Override
+    public final void setModel(TableModel tableModel) {
+        if (!(tableModel instanceof TreeTableModelAdapter)) {
+            throw new IllegalArgumentException("unsupported model type");
+        }
+        super.setModel(tableModel);
+    }
+
+    // ------------------------------------------------------------ rows and paths
+
+    /// The path of a view row, or `null`.
+    private TreePath cn1Path(int row) {
+        if (cn1Tree == null || row < 0 || row >= getRowCount()) {
+            return null;
+        }
+        return cn1Tree.getPathForRow(convertRowIndexToModel(row));
+    }
+
+    /// The path of the node in a row, or `null` for no such row.
+    public TreePath getPathForRow(int row) {
+        return cn1Path(row);
+    }
+
+    /// The row of the node at the end of a path, or -1 when it has none.
+    public int getRowForPath(TreePath path) {
+        int row = cn1Tree.getRowForPath(path);
+        return row < 0 ? -1 : convertRowIndexToView(row);
+    }
+
+    /// The path of the node in the row at a point, or `null`.
+    public TreePath getPathForLocation(int x, int y) {
+        return cn1Path(rowAtPoint(new Point(x, y)));
+    }
+
+    public void expandAll() {
+        cn1Tree.expandAll();
+    }
+
+    /// Collapses every row, from the last up.
+    public void collapseAll() {
+        cn1Tree.collapseAll();
+    }
+
+    /// Expands the node at the end of the path and the nodes above it.
+    /// A leaf is left alone.
+    public void expandPath(TreePath path) {
+        cn1Tree.expandPath(path);
+    }
+
+    public void collapsePath(TreePath path) {
+        cn1Tree.collapsePath(path);
+    }
+
+    public void expandRow(int row) {
+        cn1Tree.expandPath(cn1Path(row));
+    }
+
+    public void collapseRow(int row) {
+        cn1Tree.collapsePath(cn1Path(row));
+    }
+
+    /// Whether the node at the end of the path has a row or would get
+    /// one from its parent: every node above it is expanded.
+    public boolean isVisible(TreePath path) {
+        return cn1Tree.isVisible(path);
+    }
+
+    /// Whether the node at the end of the path and every node above it
+    /// is expanded.
+    public boolean isExpanded(TreePath path) {
+        return cn1Tree.isExpanded(path);
+    }
+
+    public boolean isExpanded(int row) {
+        TreePath path = cn1Path(row);
+        return path != null && cn1Tree.isExpanded(path);
+    }
+
+    public boolean isCollapsed(TreePath path) {
+        return cn1Tree.isCollapsed(path);
+    }
+
+    public boolean isCollapsed(int row) {
+        return !isExpanded(row);
+    }
+
+    /// The expanded paths at and below `path`, or `null` when it is not
+    /// expanded itself.
+    public Enumeration<?> getExpandedDescendants(TreePath path) {
+        return cn1Tree.getExpandedDescendants(path);
+    }
+
+    /// Expands what is above the path and scrolls its row into view.
+    public void scrollPathToVisible(TreePath path) {
+        if (path == null) {
+            return;
+        }
+        cn1Tree.makeVisible(path);
+        int row = getRowForPath(path);
+        if (row >= 0) {
+            scrollRowToVisible(row);
+        }
+    }
+
+    /// Gives the root a row of its own or takes it away. A hidden root
+    /// is expanded.
+    public void setRootVisible(boolean visible) {
+        cn1Tree.setRootVisible(visible);
+    }
+
+    public boolean isRootVisible() {
+        return cn1Tree.isRootVisible();
+    }
+
+    /// Whether the nodes of the first level get an arrow and the indent
+    /// it needs. On by default.
+    public void setShowsRootHandles(boolean visible) {
+        cn1Tree.setShowsRootHandles(visible);
+    }
+
+    public boolean getShowsRootHandles() {
+        return cn1Tree.getShowsRootHandles();
+    }
+
+    /// Whether expanding a node scrolls the table to show its children.
+    /// On by default.
+    public void setScrollsOnExpand(boolean scroll) {
+        cn1Tree.setScrollsOnExpand(scroll);
+    }
+
+    public boolean getScrollsOnExpand() {
+        return cn1Tree.getScrollsOnExpand();
+    }
+
+    public int getToggleClickCount() {
+        return cn1Tree.getToggleClickCount();
+    }
+
+    /// Sets how many clicks on a node's hierarchical cell expand or
+    /// collapse it; 2 by default, and less than 1 for none.
+    public void setToggleClickCount(int clickCount) {
+        cn1Tree.setToggleClickCount(clickCount);
+    }
+
+    // ------------------------------------------------------------ listeners
+
+    /// Adds a listener that is told, with this table as the source,
+    /// after a node was expanded or collapsed.
+    public void addTreeExpansionListener(TreeExpansionListener tel) {
+        if (tel == null) {
+            return;
+        }
+        if (cn1ExpansionListeners == null) {
+            cn1ExpansionListeners = new ArrayList<TreeExpansionListener>();
+        }
+        cn1ExpansionListeners.add(tel);
+    }
+
+    public void removeTreeExpansionListener(TreeExpansionListener tel) {
+        if (cn1ExpansionListeners != null) {
+            cn1ExpansionListeners.remove(tel);
+        }
+    }
+
+    /// Adds a listener that is asked before a node is expanded or
+    /// collapsed and can refuse. The source of its events is the tree
+    /// inside the table, not the table.
+    public void addTreeWillExpandListener(TreeWillExpandListener tel) {
+        cn1Tree.addTreeWillExpandListener(tel);
+    }
+
+    public void removeTreeWillExpandListener(TreeWillExpandListener tel) {
+        cn1Tree.removeTreeWillExpandListener(tel);
+    }
+
+    private final class ExpansionRelay implements TreeExpansionListener {
+
+        private TreeExpansionListener[] listeners() {
+            List<TreeExpansionListener> all = cn1ExpansionListeners;
+            if (all == null) {
+                return new TreeExpansionListener[0];
+            }
+            return all.toArray(new TreeExpansionListener[all.size()]);
+        }
+
+        @Override
+        public void treeExpanded(TreeExpansionEvent event) {
+            TreePath path = event.getPath();
+            if (cn1Tree.getScrollsOnExpand()) {
+                cn1ShowChildren(path);
+            }
+            TreeExpansionListener[] ls = listeners();
+            if (ls.length > 0) {
+                TreeExpansionEvent own = new TreeExpansionEvent(JXTreeTable.this, path);
+                for (int i = ls.length - 1; i >= 0; i--) {
+                    ls[i].treeExpanded(own);
+                }
+            }
+        }
+
+        @Override
+        public void treeCollapsed(TreeExpansionEvent event) {
+            TreePath path = event.getPath();
+            if (cn1LostSelection) {
+                // A selected row went with the collapse: the selection
+                // moves up to the node that was collapsed.
+                cn1LostSelection = false;
+                int row = getRowForPath(path);
+                if (row >= 0) {
+                    addRowSelectionInterval(row, row);
+                }
+            }
+            TreeExpansionListener[] ls = listeners();
+            if (ls.length > 0) {
+                TreeExpansionEvent own = new TreeExpansionEvent(JXTreeTable.this, path);
+                for (int i = ls.length - 1; i >= 0; i--) {
+                    ls[i].treeCollapsed(own);
+                }
+            }
+        }
+    }
+
+    /// Scrolls so that the children of a node that was just expanded
+    /// show, as far as they fit below the node itself.
+    private void cn1ShowChildren(TreePath path) {
+        if (getParent() == null) {
+            return;
+        }
+        int row = getRowForPath(path);
+        if (row < 0) {
+            return;
+        }
+        int children = cn1Adapter.model.getChildCount(path.getLastPathComponent());
+        int last = Math.min(getRowCount() - 1, row + children);
+        if (last > row) {
+            scrollRowToVisible(last);
+            scrollRowToVisible(row);
+        }
+    }
+
+    // ------------------------------------------------------------ hierarchical column
+
+    /// Whether the column at a view index is the one that shows the
+    /// tree.
+    public boolean isHierarchical(int column) {
+        if (cn1Adapter == null || column < 0 || column >= getColumnCount()) {
+            return false;
+        }
+        return convertColumnIndexToModel(column) == cn1Adapter.model.getHierarchicalColumn();
+    }
+
+    /// The view index of the column that shows the tree, or -1 when the
+    /// model has none or it is hidden.
+    public int getHierarchicalColumn() {
+        return convertColumnIndexToView(cn1Adapter.model.getHierarchicalColumn());
+    }
+
+    /// Sets the renderer of the hierarchical column's cells; `null` is
+    /// the default one, which shows the model's value for the node.
+    public void setTreeCellRenderer(TreeCellRenderer cellRenderer) {
+        cn1Tree.setCellRenderer(cellRenderer);
+    }
+
+    /// The renderer the hierarchical column is drawn with: a wrapper
+    /// around the one that was set.
+    public TreeCellRenderer getTreeCellRenderer() {
+        return cn1Tree.getCellRenderer();
+    }
+
+    /// The renderer of a cell: in the hierarchical column the tree
+    /// table's own, whatever the column has.
+    @Override
+    public TableCellRenderer getCellRenderer(int row, int column) {
+        if (cn1Renderer != null && isHierarchical(column)) {
+            return cn1Renderer;
+        }
+        return super.getCellRenderer(row, column);
+    }
+
+    /// The text the table shows for a cell: in the hierarchical column
+    /// what the tree cell renderer says for the node.
+    @Override
+    public String getStringAt(int row, int column) {
+        if (isHierarchical(column)) {
+            TreePath path = cn1Path(row);
+            if (path != null) {
+                return cn1Tree.getStringAt(path);
+            }
+        }
+        return super.getStringAt(row, column);
+    }
+
+    private int cn1Step() {
+        return CellTheme.touch() ? 28 : 20;
+    }
+
+    /// Where a node's own component starts in its hierarchical cell.
+    private int cn1LabelX(TreePath path) {
+        int depth = path.getPathCount() - 1 - (cn1Tree.isRootVisible() ? 0 : 1)
+                + (cn1Tree.getShowsRootHandles() ? 1 : 0);
+        return Math.max(0, depth) * cn1Step();
+    }
+
+    private boolean cn1Leaf(TreePath path) {
+        return cn1Adapter.model.isLeaf(path.getLastPathComponent());
+    }
+
+    /// Whether `x`, counted from the left of the hierarchical cell, is
+    /// on the node's arrow.
+    private boolean cn1OnHandle(TreePath path, int x) {
+        int lx = cn1LabelX(path);
+        return lx > 0 && x < lx && x >= lx - cn1Step() && !cn1Leaf(path);
+    }
+
+    private static boolean cn1Same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    /// Makes the component of a hierarchical cell, without highlights.
+    private Component cn1Stamp(Object value, boolean selected, boolean focus, int row, int column) {
+        TreePath path = cn1Path(row);
+        if (path == null) {
+            // A prototype, measured outside any row.
+            TableCellRenderer plain = getDefaultRenderer(Object.class);
+            return plain == null ? null
+                    : plain.getTableCellRendererComponent(this, value, selected, focus, row, column);
+        }
+        Rows tree = cn1Tree;
+        if (!cn1Same(tree.getBackground(), getBackground())) {
+            tree.setBackground(getBackground());
+        }
+        if (!cn1Same(tree.getForeground(), getForeground())) {
+            tree.setForeground(getForeground());
+        }
+        if (!cn1Same(tree.getFont(), getFont())) {
+            tree.setFont(getFont());
+        }
+        Object node = path.getLastPathComponent();
+        boolean leaf = cn1Leaf(path);
+        boolean expanded = tree.isExpanded(path);
+        TreeCellRenderer renderer = tree.getCellRenderer();
+        Component inner = renderer == null ? null : renderer.getTreeCellRendererComponent(tree, node, selected,
+                expanded, leaf, tree.getRowForPath(path), focus);
+        if (inner != null && selected) {
+            // The row is a table row: it is selected in the table's
+            // colors, not the tree's.
+            if (getSelectionBackground() != null) {
+                inner.setBackground(getSelectionBackground());
+            }
+            if (getSelectionForeground() != null) {
+                inner.setForeground(getSelectionForeground());
+            }
+        }
+        if (cn1Cell == null) {
+            cn1Cell = new HierarchicalCell();
+        }
+        HierarchicalCell cell = cn1Cell;
+        int lx = cn1LabelX(path);
+        cell.inner = inner;
+        cell.labelX = lx;
+        cell.step = cn1Step();
+        cell.handle = lx > 0 && !leaf;
+        cell.expanded = expanded;
+        cell.fallback = selected && getSelectionBackground() != null ? getSelectionBackground() : getBackground();
+        cell.ink = getForeground();
+        return cell;
+    }
+
+    /// Asks the renderer for the cell's component and passes it through
+    /// the highlighters. In the hierarchical column that is the tree
+    /// cell renderer's component, inside the one that draws the indent
+    /// and the arrow.
+    @Override
+    public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
+        if (cn1Renderer == null || renderer != cn1Renderer) {
+            return super.prepareRenderer(renderer, row, column);
+        }
+        boolean focus = isFocusOwner() && getSelectionModel().getLeadSelectionIndex() == row
+                && getColumnModel().getSelectionModel().getLeadSelectionIndex() == column;
+        Component stamp = cn1Stamp(getValueAt(row, column), isCellSelected(row, column), focus, row, column);
+        ComponentAdapter adapter = getComponentAdapter(row, column);
+        if (stamp instanceof HierarchicalCell) {
+            HierarchicalCell cell = (HierarchicalCell) stamp;
+            cell.inner = applyRenderer(cell.inner, adapter);
+            return cell;
+        }
+        return applyRenderer(stamp, adapter);
+    }
+
+    /// Passes a component through the table's highlighters and then
+    /// those of the adapter's column, and answers what they made of it.
+    protected Component applyRenderer(Component componentToUse, ComponentAdapter adapter) {
+        Component stamp = componentToUse;
+        if (stamp == null || adapter == null) {
+            return stamp;
+        }
+        if (compoundHighlighter != null) {
+            stamp = compoundHighlighter.highlight(stamp, adapter);
+        }
+        TableColumnExt ext = getColumnExt(adapter.column);
+        if (ext != null) {
+            stamp = ext.cn1Highlight(stamp, adapter);
+        }
+        return stamp;
+    }
+
+    /// The renderer of the hierarchical column, for the code that asks
+    /// a renderer directly, as packing a column does.
+    private static final class HierarchicalRenderer implements TableCellRenderer {
+
+        private final JXTreeTable table;
+
+        HierarchicalRenderer(JXTreeTable table) {
+            this.table = table;
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable t, Object value, boolean isSelected,
+                boolean hasFocus, int row, int column) {
+            return table.cn1Stamp(value, isSelected, hasFocus, row, column);
+        }
+    }
+
+    /// Draws a hierarchical cell: the background over the whole cell,
+    /// the arrow of a node with children, and the tree cell renderer's
+    /// component after the indent.
+    private static final class HierarchicalCell extends JComponent {
+
+        private Component inner;
+        private int labelX;
+        private int step;
+        private boolean handle;
+        private boolean expanded;
+        private Color fallback;
+        private Color ink;
+
+        @Override
+        public Dimension getPreferredSize() {
+            Dimension d = inner == null ? null : inner.getPreferredSize();
+            return d == null ? new Dimension(labelX, 0) : new Dimension(d.width + labelX, d.height);
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            int w = getWidth();
+            int h = getHeight();
+            Color fill = fallback;
+            Color fg = ink;
+            if (inner != null) {
+                if (inner.isOpaque() && inner.getBackground() != null) {
+                    fill = inner.getBackground();
+                }
+                if (inner.getForeground() != null) {
+                    fg = inner.getForeground();
+                }
+            }
+            if (fill != null) {
+                g.setColor(fill);
+                g.fillRect(0, 0, w, h);
+            }
+            if (handle) {
+                g.setColor(fg == null ? Color.GRAY : fill == null ? fg : CellTheme.mix(fill, fg, 0.65f));
+                int cx = labelX - step / 2;
+                int cy = h / 2;
+                int s = CellTheme.touch() ? 5 : 4;
+                int[] xs;
+                int[] ys;
+                if (expanded) {
+                    xs = new int[]{cx - s, cx + s, cx};
+                    ys = new int[]{cy - s / 2, cy - s / 2, cy + s - s / 2};
+                } else {
+                    xs = new int[]{cx - s / 2, cx - s / 2, cx + s - s / 2};
+                    ys = new int[]{cy - s, cy + s, cy};
+                }
+                g.fillPolygon(xs, ys, 3);
+            }
+            if (inner != null && w > labelX) {
+                CellPainter.paint(g, inner, labelX, 0, w - labelX, h);
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ pointer and editing
+
+    /// A press on a node's arrow, or the toggle click count on its
+    /// hierarchical cell, expands or collapses the node once the table
+    /// has done with the event what it does with any.
+    @Override
+    protected void processMouseEvent(MouseEvent e) {
+        TreePath toggle = null;
+        if (cn1Tree != null && isEnabled()) {
+            boolean touch = CellTheme.touch();
+            if (e.getID() == (touch ? MouseEvent.MOUSE_CLICKED : MouseEvent.MOUSE_PRESSED)
+                    && (touch || e.getButton() == MouseEvent.BUTTON1)) {
+                toggle = cn1ToggleTarget(e);
+            }
+        }
+        super.processMouseEvent(e);
+        if (toggle != null && !isEditing()) {
+            if (cn1Tree.isExpanded(toggle)) {
+                cn1Tree.collapsePath(toggle);
+            } else {
+                cn1Tree.expandPath(toggle);
+            }
+        }
+    }
+
+    /// The node a pointer event asks to expand or collapse, or `null`.
+    private TreePath cn1ToggleTarget(MouseEvent e) {
+        int row = rowAtPoint(e.getPoint());
+        int column = columnAtPoint(e.getPoint());
+        TreePath path = row >= 0 && column >= 0 && isHierarchical(column) ? cn1Path(row) : null;
+        if (path == null) {
+            cn1PressPath = null;
+            return null;
+        }
+        // Clicks are counted by time alone, so a quick press on another
+        // node arrives as a second click: count from the node's own.
+        int clicks = e.getClickCount();
+        if (!path.equals(cn1PressPath) || clicks <= 1) {
+            cn1ClickBase = clicks - 1;
+        }
+        cn1PressPath = path;
+        if (cn1Leaf(path)) {
+            return null;
+        }
+        Rectangle cell = getCellRect(row, column, false);
+        if (cn1OnHandle(path, e.getX() - cell.x)) {
+            return path;
+        }
+        int wanted = cn1Tree.getToggleClickCount();
+        return wanted > 0 && clicks - cn1ClickBase == wanted ? path : null;
+    }
+
+    /// Starts editing a cell as the table does, except that a press on
+    /// a node's arrow never starts an edit and that the editor of a
+    /// hierarchical cell is placed after the indent.
+    @Override
+    public boolean editCellAt(int row, int column, EventObject e) {
+        if (cn1Tree != null && e instanceof MouseEvent && row >= 0 && isHierarchical(column)) {
+            TreePath path = cn1Path(row);
+            if (path != null) {
+                Rectangle cell = getCellRect(row, column, false);
+                if (cn1OnHandle(path, ((MouseEvent) e).getX() - cell.x)) {
+                    return false;
+                }
+            }
+        }
+        boolean editing = super.editCellAt(row, column, e);
+        if (editing) {
+            cn1PlaceEditor();
+        }
+        return editing;
+    }
+
+    /// Moves the editor of a hierarchical cell to after the indent.
+    private void cn1PlaceEditor() {
+        if (cn1Tree == null || !isEditing()) {
+            return;
+        }
+        int row = getEditingRow();
+        int column = getEditingColumn();
+        Component editor = getEditorComponent();
+        TreePath path = editor != null && isHierarchical(column) ? cn1Path(row) : null;
+        if (path == null) {
+            return;
+        }
+        Rectangle r = getCellRect(row, column, false);
+        int lx = Math.min(cn1LabelX(path), Math.max(0, r.width - 1));
+        editor.setBounds(r.x + lx, r.y, r.width - lx, r.height);
+    }
+
+    @Override
+    public void doLayout() {
+        super.doLayout();
+        cn1PlaceEditor();
+    }
+
+    @Override
+    public void columnMarginChanged(ChangeEvent e) {
+        super.columnMarginChanged(e);
+        cn1PlaceEditor();
+    }
+
+    // ------------------------------------------------------------ the tree
+
+    /// The text of a node in the default renderer: the model's value for
+    /// it in the hierarchical column.
+    private static final class HierarchicalText implements StringValue {
+
+        private final Rows tree;
+
+        HierarchicalText(Rows tree) {
+            this.tree = tree;
+        }
+
+        @Override
+        public String getString(Object value) {
+            TreeModel m = tree.getModel();
+            if (m instanceof TreeTableModel) {
+                TreeTableModel model = (TreeTableModel) m;
+                int column = model.getHierarchicalColumn();
+                if (column >= 0 && column < model.getColumnCount()) {
+                    Object shown = model.getValueAt(value, column);
+                    return shown == null ? "" : shown.toString();
+                }
+            }
+            return value == null ? "" : value.toString();
+        }
+    }
+
+    /// The tree that keeps which nodes are expanded and so which have a
+    /// row. It is never shown: the table draws its rows.
+    private static final class Rows extends JXTree {
+
+        private TreeTableModelAdapter adapter;
+        private boolean live;
+        private boolean fixing;
+
+        Rows(TreeTableModel model) {
+            super(model);
+            super.setRootVisible(false);
+            super.setShowsRootHandles(true);
+            live = true;
+        }
+
+        @Override
+        protected TreeCellRenderer createDefaultCellRenderer() {
+            return new DefaultTreeRenderer(new HierarchicalText(this));
+        }
+
+        /// The rows may have changed. A hidden root that got its first
+        /// children is expanded, or they would never show; then the
+        /// table is told.
+        @Override
+        public void treeDidChange() {
+            super.treeDidChange();
+            if (live && !fixing && !isRootVisible()) {
+                TreeModel m = getModel();
+                Object root = m == null ? null : m.getRoot();
+                if (root != null && !m.isLeaf(root)) {
+                    TreePath rootPath = new TreePath(root);
+                    if (!isExpanded(rootPath)) {
+                        fixing = true;
+                        try {
+                            expandPath(rootPath);
+                        } finally {
+                            fixing = false;
+                        }
+                    }
+                }
+            }
+            if (adapter != null) {
+                adapter.rowsChanged();
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ the table model
+
+    /// The table model over the tree: a row for every node that shows.
+    /// It follows the tree's rows and tells the table what went and what
+    /// came, so that the selection stays with its nodes.
+    private static final class TreeTableModelAdapter extends AbstractTableModel implements TreeModelListener {
+
+        private final Rows tree;
+        private TreeTableModel model;
+        private JXTreeTable table;
+        private ArrayList<TreePath> shown;
+        private boolean muted;
+
+        TreeTableModelAdapter(Rows tree, TreeTableModel model) {
+            this.tree = tree;
+            this.model = model;
+            shown = snapshot();
+            tree.adapter = this;
+            model.addTreeModelListener(this);
+        }
+
+        private ArrayList<TreePath> snapshot() {
+            int n = tree.getRowCount();
+            ArrayList<TreePath> out = new ArrayList<TreePath>(n);
+            for (int i = 0; i < n; i++) {
+                out.add(tree.getPathForRow(i));
+            }
+            return out;
+        }
+
+        void setModel(TreeTableModel newModel) {
+            model.removeTreeModelListener(this);
+            model = newModel;
+            muted = true;
+            try {
+                tree.setModel(newModel);
+            } finally {
+                muted = false;
+            }
+            newModel.addTreeModelListener(this);
+            shown = snapshot();
+            fireTableStructureChanged();
+        }
+
+        private Object node(int row) {
+            TreePath path = tree.getPathForRow(row);
+            return path == null ? null : path.getLastPathComponent();
+        }
+
+        @Override
+        public int getRowCount() {
+            return tree.getRowCount();
+        }
+
+        @Override
+        public int getColumnCount() {
+            return model.getColumnCount();
+        }
+
+        @Override
+        public String getColumnName(int column) {
+            return model.getColumnName(column);
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return model.getColumnClass(column);
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            Object node = node(row);
+            return node == null ? null : model.getValueAt(node, column);
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            Object node = node(row);
+            return node != null && model.isCellEditable(node, column);
+        }
+
+        @Override
+        public void setValueAt(Object value, int row, int column) {
+            Object node = node(row);
+            if (node != null) {
+                model.setValueAt(value, node, column);
+            }
+        }
+
+        /// The tree's rows may have changed: works out what went or came
+        /// between the rows the table knows and the rows there are now.
+        void rowsChanged() {
+            if (muted) {
+                return;
+            }
+            ArrayList<TreePath> old = shown;
+            ArrayList<TreePath> now = snapshot();
+            shown = now;
+            if (table != null) {
+                table.cn1LostSelection = false;
+            }
+            int on = old.size();
+            int nn = now.size();
+            int prefix = 0;
+            while (prefix < on && prefix < nn && old.get(prefix).equals(now.get(prefix))) {
+                prefix++;
+            }
+            int suffix = 0;
+            while (suffix < on - prefix && suffix < nn - prefix
+                    && old.get(on - 1 - suffix).equals(now.get(nn - 1 - suffix))) {
+                suffix++;
+            }
+            if (on == nn && prefix == on) {
+                if (nn > 0) {
+                    fireTableRowsUpdated(0, nn - 1);
+                }
+            } else if (prefix + suffix == on) {
+                fireTableRowsInserted(prefix, nn - suffix - 1);
+            } else if (prefix + suffix == nn) {
+                int last = on - suffix - 1;
+                if (table != null) {
+                    for (int row = prefix; row <= last; row++) {
+                        if (table.isRowSelected(row)) {
+                            table.cn1LostSelection = true;
+                            break;
+                        }
+                    }
+                }
+                fireTableRowsDeleted(prefix, last);
+            } else {
+                fireTableDataChanged();
+            }
+        }
+
+        /// A node's values changed; the tree's rows did not.
+        @Override
+        public void treeNodesChanged(TreeModelEvent e) {
+            int n = tree.getRowCount();
+            if (n > 0 && n == shown.size()) {
+                fireTableRowsUpdated(0, n - 1);
+            }
+        }
+
+        @Override
+        public void treeNodesInserted(TreeModelEvent e) {
+        }
+
+        @Override
+        public void treeNodesRemoved(TreeModelEvent e) {
+        }
+
+        /// A change at the root may be a change of the columns: the
+        /// table makes them again.
+        @Override
+        public void treeStructureChanged(TreeModelEvent e) {
+            TreePath path = e.getTreePath();
+            if (path == null || path.getPathCount() == 1) {
+                shown = snapshot();
+                fireTableStructureChanged();
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ highlighters
+
+    /// The adapter highlighters see a cell through: the table's own,
+    /// with what the tree knows of the cell's node.
+    @Override
+    protected ComponentAdapter getComponentAdapter() {
+        if (!(dataAdapter instanceof TreeTableDataAdapter)) {
+            dataAdapter = null;
+            dataAdapter = new TreeTableDataAdapter(this, super.getComponentAdapter());
+        }
+        return dataAdapter;
+    }
+
+    private static final class TreeTableDataAdapter extends ComponentAdapter {
+
+        private final JXTreeTable table;
+        private final ComponentAdapter plain;
+
+        TreeTableDataAdapter(JXTreeTable table, ComponentAdapter plain) {
+            super(table);
+            this.table = table;
+            this.plain = plain;
+        }
+
+        /// The table's adapter, pointed at this one's cell.
+        private ComponentAdapter cell() {
+            plain.row = row;
+            plain.column = column;
+            return plain;
+        }
+
+        @Override
+        public String getColumnName(int columnIndex) {
+            return plain.getColumnName(columnIndex);
+        }
+
+        @Override
+        public Object getColumnIdentifierAt(int columnIndex) {
+            return plain.getColumnIdentifierAt(columnIndex);
+        }
+
+        @Override
+        public int getColumnIndex(Object identifier) {
+            return plain.getColumnIndex(identifier);
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return plain.getColumnClass(column);
+        }
+
+        @Override
+        public int getColumnCount() {
+            return plain.getColumnCount();
+        }
+
+        @Override
+        public int getRowCount() {
+            return plain.getRowCount();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return plain.getValueAt(row, column);
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            return plain.isCellEditable(row, column);
+        }
+
+        /// The text at a model row and model column: in the hierarchical
+        /// column what the tree cell renderer says for the node.
+        @Override
+        public String getStringAt(int row, int column) {
+            TreeTableModel model = table.getTreeTableModel();
+            if (model != null && column == model.getHierarchicalColumn()) {
+                TreePath path = table.cn1Tree.getPathForRow(row);
+                if (path != null) {
+                    return table.cn1Tree.getStringAt(path);
+                }
+            }
+            return plain.getStringAt(row, column);
+        }
+
+        @Override
+        public Rectangle getCellBounds() {
+            return cell().getCellBounds();
+        }
+
+        @Override
+        public boolean hasFocus() {
+            return cell().hasFocus();
+        }
+
+        @Override
+        public boolean isSelected() {
+            return cell().isSelected();
+        }
+
+        @Override
+        public boolean isEditable() {
+            return cell().isEditable();
+        }
+
+        @Override
+        public boolean isExpanded() {
+            return table.isExpanded(row);
+        }
+
+        @Override
+        public boolean isLeaf() {
+            TreePath path = table.cn1Path(row);
+            return path != null && table.cn1Leaf(path);
+        }
+
+        @Override
+        public boolean isHierarchical() {
+            return table.isHierarchical(column);
+        }
+
+        /// How far below the root the cell's node is; the root is at 0.
+        @Override
+        public int getDepth() {
+            TreePath path = table.cn1Path(row);
+            return path == null ? 0 : path.getPathCount() - 1;
+        }
+
+        @Override
+        public int convertColumnIndexToView(int columnModelIndex) {
+            return plain.convertColumnIndexToView(columnModelIndex);
+        }
+
+        @Override
+        public int convertColumnIndexToModel(int columnViewIndex) {
+            return plain.convertColumnIndexToModel(columnViewIndex);
+        }
+
+        @Override
+        public int convertRowIndexToView(int rowModelIndex) {
+            return plain.convertRowIndexToView(rowModelIndex);
+        }
+
+        @Override
+        public int convertRowIndexToModel(int rowViewIndex) {
+            return plain.convertRowIndexToModel(rowViewIndex);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/ScrollableSizeHint.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/ScrollableSizeHint.java
new file mode 100644
index 00000000000..2609cb31a18
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/ScrollableSizeHint.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// How a scrollable component sizes itself along one axis inside a
+/// viewport.
+public enum ScrollableSizeHint {
+
+    /// The component keeps its preferred size and the viewport scrolls it.
+    NONE {
+        @Override
+        public boolean getTracksParentSize(JComponent component, int orientation) {
+            return false;
+        }
+    },
+
+    /// The component always has the size of the viewport.
+    FIT,
+
+    /// The component takes the viewport's size while that is larger than
+    /// its minimum size, and scrolls below it.
+    MINIMUM_STRETCH {
+        @Override
+        public boolean getTracksParentSize(JComponent component, int orientation) {
+            return parentLength(component, orientation) > length(component.getMinimumSize(), orientation);
+        }
+    },
+
+    /// The component takes the viewport's size while that is larger than
+    /// its preferred size, and scrolls below it.
+    PREFERRED_STRETCH {
+        @Override
+        public boolean getTracksParentSize(JComponent component, int orientation) {
+            return parentLength(component, orientation) > length(component.getPreferredSize(), orientation);
+        }
+    };
+
+    /// Whether `component` is to be given the size of its parent along
+    /// `orientation`, one of the [SwingConstants] `HORIZONTAL` and
+    /// `VERTICAL`.
+    public boolean getTracksParentSize(JComponent component, int orientation) {
+        return true;
+    }
+
+    private static int length(Dimension d, int orientation) {
+        if (d == null) {
+            return 0;
+        }
+        return orientation == SwingConstants.HORIZONTAL ? d.width : d.height;
+    }
+
+    private static int parentLength(JComponent component, int orientation) {
+        Container p = component.getParent();
+        if (p == null) {
+            return 0;
+        }
+        return orientation == SwingConstants.HORIZONTAL ? p.getWidth() : p.getHeight();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/VerticalLayout.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/VerticalLayout.java
new file mode 100644
index 00000000000..36d2bf79daf
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/VerticalLayout.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+
+/// Stacks the visible children from top to bottom, each as wide as the
+/// container and as high as it prefers, with a gap between them.
+public class VerticalLayout implements LayoutManager {
+
+    private int gap;
+
+    public VerticalLayout() {
+        this(0);
+    }
+
+    public VerticalLayout(int gap) {
+        this.gap = gap;
+    }
+
+    public int getGap() {
+        return gap;
+    }
+
+    public void setGap(int gap) {
+        this.gap = gap;
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container parent) {
+        Insets in = parent.getInsets();
+        int width = 0;
+        int height = 0;
+        int shown = 0;
+        int n = parent.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            Dimension d = c.getPreferredSize();
+            width = Math.max(width, d.width);
+            height += d.height;
+            shown++;
+        }
+        if (shown > 1) {
+            height += gap * (shown - 1);
+        }
+        return new Dimension(width + in.left + in.right, height + in.top + in.bottom);
+    }
+
+    @Override
+    public void layoutContainer(Container parent) {
+        Insets in = parent.getInsets();
+        int width = Math.max(0, parent.getWidth() - in.left - in.right);
+        int y = in.top;
+        int n = parent.getComponentCount();
+        for (int i = 0; i < n; i++) {
+            Component c = parent.getComponent(i);
+            if (!c.isVisible()) {
+                continue;
+            }
+            int h = c.getPreferredSize().height;
+            c.setBounds(in.left, y, width, h);
+            y += h + gap;
+        }
+    }
+
+    /// The preferred size: a stack does not shrink its rows.
+    @Override
+    public Dimension minimumLayoutSize(Container parent) {
+        return preferredLayoutSize(parent);
+    }
+
+    @Override
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    @Override
+    public void addLayoutComponent(String name, Component comp) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/action/AbstractActionExt.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/action/AbstractActionExt.java
new file mode 100644
index 00000000000..53c900f0a86
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/action/AbstractActionExt.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.action;
+
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+
+/// An action with typed accessors for the standard values, a group, and a
+/// selected state for actions that are toggles.
+///
+/// The copy constructor copies the values this class has
+/// accessors for; a device cannot enumerate more than
+/// [AbstractAction#getKeys()] offers, which it also copies.
+public abstract class AbstractActionExt extends AbstractAction implements ItemListener {
+
+    public static final String LARGE_ICON = "SwingLargeIconKey";
+    public static final String GROUP = "__Group__";
+    public static final String IS_STATE = "__State__";
+
+    public AbstractActionExt() {
+        this((String) null);
+    }
+
+    public AbstractActionExt(AbstractActionExt action) {
+        Object[] keys = action.getKeys();
+        if (keys != null) {
+            for (int i = 0; i < keys.length; i++) {
+                if (keys[i] instanceof String) {
+                    String key = (String) keys[i];
+                    putValue(key, action.getValue(key));
+                }
+            }
+        }
+        setEnabled(action.isEnabled());
+    }
+
+    public AbstractActionExt(String name) {
+        this(name, (Icon) null);
+    }
+
+    public AbstractActionExt(String name, Icon icon) {
+        super(name, icon);
+    }
+
+    public AbstractActionExt(String name, String command) {
+        this(name);
+        setActionCommand(command);
+    }
+
+    public AbstractActionExt(String name, String command, Icon icon) {
+        super(name, icon);
+        setActionCommand(command);
+    }
+
+    public String getShortDescription() {
+        return cn1String(Action.SHORT_DESCRIPTION);
+    }
+
+    public void setShortDescription(String desc) {
+        putValue(Action.SHORT_DESCRIPTION, desc);
+        if (desc != null && getLongDescription() == null) {
+            setLongDescription(desc);
+        }
+    }
+
+    public String getLongDescription() {
+        return cn1String(Action.LONG_DESCRIPTION);
+    }
+
+    public void setLongDescription(String desc) {
+        putValue(Action.LONG_DESCRIPTION, desc);
+        if (desc != null && getShortDescription() == null) {
+            setShortDescription(desc);
+        }
+    }
+
+    public Icon getSmallIcon() {
+        Object v = getValue(SMALL_ICON);
+        return v instanceof Icon ? (Icon) v : null;
+    }
+
+    public void setSmallIcon(Icon icon) {
+        putValue(SMALL_ICON, icon);
+    }
+
+    public Icon getLargeIcon() {
+        Object v = getValue(LARGE_ICON);
+        return v instanceof Icon ? (Icon) v : null;
+    }
+
+    public void setLargeIcon(Icon icon) {
+        putValue(LARGE_ICON, icon);
+    }
+
+    public void setName(String name) {
+        putValue(Action.NAME, name);
+    }
+
+    public String getName() {
+        return cn1String(Action.NAME);
+    }
+
+    /// Takes the first character of `mnemonic` as the mnemonic.
+    public void setMnemonic(String mnemonic) {
+        if (mnemonic != null && mnemonic.length() > 0) {
+            putValue(Action.MNEMONIC_KEY, Integer.valueOf(mnemonic.charAt(0)));
+        }
+    }
+
+    public void setMnemonic(int mnemonic) {
+        putValue(Action.MNEMONIC_KEY, Integer.valueOf(mnemonic));
+    }
+
+    /// The mnemonic, or 0 when there is none.
+    public int getMnemonic() {
+        Object v = getValue(Action.MNEMONIC_KEY);
+        return v instanceof Integer ? ((Integer) v).intValue() : 0;
+    }
+
+    public void setActionCommand(String key) {
+        putValue(Action.ACTION_COMMAND_KEY, key);
+    }
+
+    public String getActionCommand() {
+        return cn1String(Action.ACTION_COMMAND_KEY);
+    }
+
+    /// The key stroke stored under [Action#ACCELERATOR_KEY], or null.
+    public KeyStroke getAccelerator() {
+        Object v = getValue(Action.ACCELERATOR_KEY);
+        return v instanceof KeyStroke ? (KeyStroke) v : null;
+    }
+
+    public void setAccelerator(KeyStroke key) {
+        putValue(Action.ACCELERATOR_KEY, key);
+    }
+
+    public void setGroup(Object group) {
+        putValue(GROUP, group);
+    }
+
+    public Object getGroup() {
+        return getValue(GROUP);
+    }
+
+    /// Removes every property change listener.
+    public void dispose() {
+        PropertyChangeListener[] ls = getPropertyChangeListeners();
+        for (int i = 0; i < ls.length; i++) {
+            removePropertyChangeListener(ls[i]);
+        }
+    }
+
+    /// Whether the action is a toggle with a selected state.
+    public boolean isStateAction() {
+        return Boolean.TRUE.equals(getValue(IS_STATE));
+    }
+
+    public void setStateAction() {
+        setStateAction(true);
+    }
+
+    public void setStateAction(boolean state) {
+        putValue(IS_STATE, Boolean.valueOf(state));
+    }
+
+    public boolean isSelected() {
+        return Boolean.TRUE.equals(getValue(SELECTED_KEY));
+    }
+
+    public void setSelected(boolean newValue) {
+        putValue(SELECTED_KEY, Boolean.valueOf(newValue));
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("[");
+        sb.append(getClass().getName());
+        sb.append(":name=").append(getName());
+        sb.append(",command=").append(getActionCommand());
+        sb.append(",enabled=").append(isEnabled());
+        sb.append(']');
+        return sb.toString();
+    }
+
+    /// Does nothing; a state action overrides this to follow the toggle
+    /// it is attached to.
+    @Override
+    public void itemStateChanged(ItemEvent e) {
+    }
+
+    private String cn1String(String key) {
+        Object v = getValue(key);
+        return v instanceof String ? (String) v : null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/action/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/action/package-info.java
new file mode 100644
index 00000000000..3ddc1d4f681
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/action/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The extended action base class the SwingX hyperlink actions build on.
+/// The action manager, the action factories and the target mechanism are
+/// absent.
+package com.codename1.desktopcompat.org.jdesktop.swingx.action;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/AbstractDateSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/AbstractDateSelectionModel.java
new file mode 100644
index 00000000000..fba8ae64fa7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/AbstractDateSelectionModel.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent.EventType;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionListener;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+import java.util.TreeSet;
+
+/// The part of a date selection model that does not depend on how the
+/// selection is stored: the calendar, the bounds, the adjusting flag and
+/// the listeners.
+///
+/// ## What differs from SwingX
+///
+///  - The first day of the week and the minimal days in the first week are
+///    kept by the model; the calendar answered by [#getCalendar()] does
+///    not carry them, because the device's calendar has no such
+///    properties. The first day of the week starts as Sunday whatever the
+///    locale.
+///  - The locale is recorded and reported, nothing more.
+///  - The `listenerMap` field and the `EMPTY_DATES` constant are absent.
+public abstract class AbstractDateSelectionModel implements DateSelectionModel {
+
+    protected boolean adjusting;
+    protected Calendar calendar;
+    protected Date upperBound;
+    protected Date lowerBound;
+    protected Locale locale;
+
+    private int firstDayOfWeek = Calendar.SUNDAY;
+    private int minimalDaysInFirstWeek = 1;
+    private final ArrayList<DateSelectionListener> listeners = new ArrayList<DateSelectionListener>();
+
+    public AbstractDateSelectionModel() {
+        this(null);
+    }
+
+    public AbstractDateSelectionModel(Locale locale) {
+        this.locale = locale != null ? locale : Locale.getDefault();
+        this.calendar = Calendar.getInstance();
+    }
+
+    @Override
+    public Calendar getCalendar() {
+        Calendar c = Calendar.getInstance(calendar.getTimeZone());
+        c.setTime(calendar.getTime());
+        return c;
+    }
+
+    @Override
+    public int getFirstDayOfWeek() {
+        return firstDayOfWeek;
+    }
+
+    /// Sets the day a week starts with, one of the `Calendar` day
+    /// constants. Anything else is ignored.
+    @Override
+    public void setFirstDayOfWeek(int firstDayOfWeek) {
+        if (firstDayOfWeek < Calendar.SUNDAY || firstDayOfWeek > Calendar.SATURDAY
+                || firstDayOfWeek == this.firstDayOfWeek) {
+            return;
+        }
+        this.firstDayOfWeek = firstDayOfWeek;
+        fireValueChanged(EventType.CALENDAR_CHANGED);
+    }
+
+    @Override
+    public int getMinimalDaysInFirstWeek() {
+        return minimalDaysInFirstWeek;
+    }
+
+    @Override
+    public void setMinimalDaysInFirstWeek(int minimalDays) {
+        if (minimalDays == minimalDaysInFirstWeek) {
+            return;
+        }
+        minimalDaysInFirstWeek = minimalDays;
+        fireValueChanged(EventType.CALENDAR_CHANGED);
+    }
+
+    @Override
+    public TimeZone getTimeZone() {
+        return calendar.getTimeZone();
+    }
+
+    /// Changes the time zone dates are read in. What was selected, the
+    /// bounds and the unselectable dates meant days of the old zone and
+    /// are dropped.
+    @Override
+    public void setTimeZone(TimeZone timeZone) {
+        TimeZone old = calendar.getTimeZone();
+        if (timeZone == null || timeZone.equals(old)) {
+            return;
+        }
+        calendar.setTimeZone(timeZone);
+        adjustDatesToTimeZone(old);
+        fireValueChanged(EventType.CALENDAR_CHANGED);
+    }
+
+    /// Called when the time zone changed; `oldTimeZone` is the one before.
+    protected void adjustDatesToTimeZone(TimeZone oldTimeZone) {
+        clearSelection();
+        setLowerBound(null);
+        setUpperBound(null);
+        setUnselectableDates(new TreeSet<Date>());
+    }
+
+    @Override
+    public Locale getLocale() {
+        return locale;
+    }
+
+    @Override
+    public void setLocale(Locale locale) {
+        Locale l = locale != null ? locale : Locale.getDefault();
+        if (l.equals(this.locale)) {
+            return;
+        }
+        this.locale = l;
+        fireValueChanged(EventType.CALENDAR_CHANGED);
+    }
+
+    /// The first millisecond of the day `date` falls on.
+    protected Date startOfDay(Date date) {
+        return CalendarUtils.startOfDay(calendar, date);
+    }
+
+    /// The last millisecond of the day `date` falls on.
+    protected Date endOfDay(Date date) {
+        return CalendarUtils.endOfDay(calendar, date);
+    }
+
+    protected boolean isSameDay(Date selected, Date compare) {
+        return startOfDay(selected).equals(startOfDay(compare));
+    }
+
+    @Override
+    public Date getUpperBound() {
+        return copy(upperBound);
+    }
+
+    @Override
+    public void setUpperBound(Date upperBound) {
+        Date bound = upperBound != null ? getNormalizedDate(upperBound) : null;
+        if (CalendarUtils.areEqual(bound, this.upperBound)) {
+            return;
+        }
+        this.upperBound = bound;
+        dropOutside();
+        fireValueChanged(EventType.UPPER_BOUND_CHANGED);
+    }
+
+    @Override
+    public Date getLowerBound() {
+        return copy(lowerBound);
+    }
+
+    @Override
+    public void setLowerBound(Date lowerBound) {
+        Date bound = lowerBound != null ? getNormalizedDate(lowerBound) : null;
+        if (CalendarUtils.areEqual(bound, this.lowerBound)) {
+            return;
+        }
+        this.lowerBound = bound;
+        dropOutside();
+        fireValueChanged(EventType.LOWER_BOUND_CHANGED);
+    }
+
+    /// Unselects the dates the bounds no longer allow.
+    private void dropOutside() {
+        if (isSelectionEmpty()) {
+            return;
+        }
+        Iterator<Date> it = getSelection().iterator();
+        while (it.hasNext()) {
+            Date d = it.next();
+            boolean above = upperBound != null && d.getTime() > upperBound.getTime();
+            boolean below = lowerBound != null && d.getTime() < lowerBound.getTime();
+            if (above || below) {
+                removeSelectionInterval(d, d);
+            }
+        }
+    }
+
+    private static Date copy(Date d) {
+        return d == null ? null : new Date(d.getTime());
+    }
+
+    @Override
+    public boolean isAdjusting() {
+        return adjusting;
+    }
+
+    @Override
+    public void setAdjusting(boolean adjusting) {
+        if (adjusting == this.adjusting) {
+            return;
+        }
+        this.adjusting = adjusting;
+        fireValueChanged(adjusting ? EventType.ADJUSTING_STARTED : EventType.ADJUSTING_STOPPED);
+    }
+
+    @Override
+    public void addDateSelectionListener(DateSelectionListener l) {
+        if (l != null) {
+            listeners.add(l);
+        }
+    }
+
+    @Override
+    public void removeDateSelectionListener(DateSelectionListener l) {
+        listeners.remove(l);
+    }
+
+    public List<DateSelectionListener> getDateSelectionListeners() {
+        return new ArrayList<DateSelectionListener>(listeners);
+    }
+
+    protected void fireValueChanged(EventType eventType) {
+        if (listeners.isEmpty()) {
+            return;
+        }
+        DateSelectionListener[] all = listeners.toArray(new DateSelectionListener[listeners.size()]);
+        DateSelectionEvent e = new DateSelectionEvent(this, eventType, isAdjusting());
+        for (int i = 0; i < all.length; i++) {
+            all[i].valueChanged(e);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/CalendarUtils.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/CalendarUtils.java
new file mode 100644
index 00000000000..39666f91fb2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/CalendarUtils.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import java.util.Calendar;
+import java.util.Date;
+
+/// Static helpers that move a calendar to the start or end of a day,
+/// month, year or decade and compare dates by day.
+///
+/// Only what the device's calendar can do is here: it has `get`, `set`,
+/// `add`, `getTime` and `setTime` and nothing else, so the helpers that
+/// need the calendar's first day of the week (`startOfWeek`, `endOfWeek`),
+/// its daylight saving rules or its field ranges are absent. A month's
+/// length is computed by the Gregorian rule.
+public class CalendarUtils {
+
+    public static final int ONE_MINUTE = 60 * 1000;
+    public static final int ONE_HOUR = 60 * ONE_MINUTE;
+    public static final int THREE_HOURS = 3 * ONE_HOUR;
+    public static final int ONE_DAY = 24 * ONE_HOUR;
+    /// A pseudo calendar field: the decade.
+    public static final int DECADE = 5467;
+    /// A pseudo calendar field: the year within the decade.
+    public static final int YEAR_IN_DECADE = 5468;
+
+    public CalendarUtils() {
+    }
+
+    /// The number of days of a month, `month` counted from zero.
+    static int daysInMonth(int year, int month) {
+        switch (month) {
+            case Calendar.FEBRUARY:
+                boolean leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+                return leap ? 29 : 28;
+            case Calendar.APRIL:
+            case Calendar.JUNE:
+            case Calendar.SEPTEMBER:
+            case Calendar.NOVEMBER:
+                return 30;
+            default:
+                return 31;
+        }
+    }
+
+    public static boolean isStartOfDay(Calendar calendar) {
+        return calendar.get(Calendar.HOUR_OF_DAY) == 0 && calendar.get(Calendar.MINUTE) == 0
+                && calendar.get(Calendar.SECOND) == 0 && calendar.get(Calendar.MILLISECOND) == 0;
+    }
+
+    public static boolean isEndOfDay(Calendar calendar) {
+        return calendar.get(Calendar.HOUR_OF_DAY) == 23 && calendar.get(Calendar.MINUTE) == 59
+                && calendar.get(Calendar.SECOND) == 59 && calendar.get(Calendar.MILLISECOND) == 999;
+    }
+
+    public static boolean isStartOfMonth(Calendar calendar) {
+        return calendar.get(Calendar.DAY_OF_MONTH) == 1 && isStartOfDay(calendar);
+    }
+
+    public static boolean isEndOfMonth(Calendar calendar) {
+        int last = daysInMonth(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH));
+        return calendar.get(Calendar.DAY_OF_MONTH) == last && isEndOfDay(calendar);
+    }
+
+    /// Moves the calendar to the first millisecond of the first year of
+    /// its decade.
+    public static void startOfDecade(Calendar calendar) {
+        int year = calendar.get(Calendar.YEAR);
+        calendar.set(Calendar.YEAR, year - year % 10);
+        startOfYear(calendar);
+    }
+
+    public static Date startOfDecade(Calendar calendar, Date date) {
+        calendar.setTime(date);
+        startOfDecade(calendar);
+        return calendar.getTime();
+    }
+
+    public static boolean isStartOfDecade(Calendar calendar) {
+        return calendar.get(Calendar.YEAR) % 10 == 0 && isStartOfYear(calendar);
+    }
+
+    /// Moves the calendar to the first millisecond of its year.
+    public static void startOfYear(Calendar calendar) {
+        calendar.set(Calendar.DAY_OF_MONTH, 1);
+        calendar.set(Calendar.MONTH, Calendar.JANUARY);
+        startOfDay(calendar);
+    }
+
+    public static Date startOfYear(Calendar calendar, Date date) {
+        calendar.setTime(date);
+        startOfYear(calendar);
+        return calendar.getTime();
+    }
+
+    public static boolean isStartOfYear(Calendar calendar) {
+        return calendar.get(Calendar.MONTH) == Calendar.JANUARY && isStartOfMonth(calendar);
+    }
+
+    /// Moves the calendar to the first millisecond of its month.
+    public static void startOfMonth(Calendar calendar) {
+        calendar.set(Calendar.DAY_OF_MONTH, 1);
+        startOfDay(calendar);
+    }
+
+    /// Moves the calendar to the last millisecond of its month.
+    public static void endOfMonth(Calendar calendar) {
+        calendar.set(Calendar.DAY_OF_MONTH, daysInMonth(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH)));
+        endOfDay(calendar);
+    }
+
+    /// The first millisecond of the day of `date`; the calendar is left
+    /// there.
+    public static Date startOfDay(Calendar calendar, Date date) {
+        calendar.setTime(date);
+        startOfDay(calendar);
+        return calendar.getTime();
+    }
+
+    /// The last millisecond of the day of `date`; the calendar is left
+    /// there.
+    public static Date endOfDay(Calendar calendar, Date date) {
+        calendar.setTime(date);
+        endOfDay(calendar);
+        return calendar.getTime();
+    }
+
+    public static void startOfDay(Calendar calendar) {
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        // Reading the time settles the fields, as the device's calendar
+        // computes lazily.
+        calendar.getTime();
+    }
+
+    public static void endOfDay(Calendar calendar) {
+        calendar.set(Calendar.HOUR_OF_DAY, 23);
+        calendar.set(Calendar.MINUTE, 59);
+        calendar.set(Calendar.SECOND, 59);
+        calendar.set(Calendar.MILLISECOND, 999);
+        calendar.getTime();
+    }
+
+    /// Whether both are `null` or both name the same instant.
+    public static boolean areEqual(Date current, Date date) {
+        if (current == null) {
+            return date == null;
+        }
+        return date != null && current.getTime() == date.getTime();
+    }
+
+    /// Whether the calendar's time and `date` fall on the same day. The
+    /// calendar keeps its time.
+    public static boolean isSameDay(Calendar today, Date now) {
+        Date kept = today.getTime();
+        try {
+            int y = today.get(Calendar.YEAR);
+            int m = today.get(Calendar.MONTH);
+            int d = today.get(Calendar.DAY_OF_MONTH);
+            today.setTime(now);
+            return y == today.get(Calendar.YEAR) && m == today.get(Calendar.MONTH)
+                    && d == today.get(Calendar.DAY_OF_MONTH);
+        } finally {
+            today.setTime(kept);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSelectionModel.java
new file mode 100644
index 00000000000..c3f2f9968b8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSelectionModel.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionListener;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+import java.util.SortedSet;
+import java.util.TimeZone;
+
+/// The selected dates of a month view, the dates that cannot be selected
+/// and the calendar both are read with.
+public interface DateSelectionModel {
+
+    /// How many dates can be selected at once.
+    enum SelectionMode {
+        /// One date.
+        SINGLE_SELECTION,
+        /// One run of consecutive dates.
+        SINGLE_INTERVAL_SELECTION,
+        /// Any dates.
+        MULTIPLE_INTERVAL_SELECTION
+    }
+
+    SelectionMode getSelectionMode();
+
+    void setSelectionMode(SelectionMode mode);
+
+    /// A calendar set to the model's time zone. It is a new object on
+    /// every call and changing it does not change the model.
+    Calendar getCalendar();
+
+    int getFirstDayOfWeek();
+
+    void setFirstDayOfWeek(int firstDayOfWeek);
+
+    int getMinimalDaysInFirstWeek();
+
+    void setMinimalDaysInFirstWeek(int minimalDays);
+
+    TimeZone getTimeZone();
+
+    void setTimeZone(TimeZone timeZone);
+
+    Locale getLocale();
+
+    void setLocale(Locale locale);
+
+    void addSelectionInterval(Date startDate, Date endDate);
+
+    void setSelectionInterval(Date startDate, Date endDate);
+
+    void removeSelectionInterval(Date startDate, Date endDate);
+
+    void clearSelection();
+
+    SortedSet<Date> getSelection();
+
+    Date getFirstSelectionDate();
+
+    Date getLastSelectionDate();
+
+    boolean isSelected(Date date);
+
+    /// The date as the model would store it.
+    Date getNormalizedDate(Date date);
+
+    boolean isSelectionEmpty();
+
+    SortedSet<Date> getUnselectableDates();
+
+    void setUnselectableDates(SortedSet<Date> unselectableDates);
+
+    boolean isUnselectableDate(Date unselectableDate);
+
+    Date getUpperBound();
+
+    void setUpperBound(Date upperBound);
+
+    Date getLowerBound();
+
+    void setLowerBound(Date lowerBound);
+
+    void setAdjusting(boolean adjusting);
+
+    boolean isAdjusting();
+
+    void addDateSelectionListener(DateSelectionListener listener);
+
+    void removeDateSelectionListener(DateSelectionListener listener);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSet.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSet.java
new file mode 100644
index 00000000000..e3900129801
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSet.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DateSelectionModel.SelectionMode;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/// The storage the concrete selection models share: the selected dates,
+/// the unselectable dates and the selection mode, with the interval
+/// operations that honor the mode. A model normalizes the dates before it
+/// hands them over; an interval is walked a day at a time from its start.
+final class DateSet {
+
+    /// A hard stop for the walk over an interval, about 27 years, so that
+    /// a mistaken end date cannot hang the device.
+    private static final int MAX_DAYS = 10000;
+
+    private final TreeSet<Date> selected = new TreeSet<Date>();
+    private final TreeSet<Date> unselectable = new TreeSet<Date>();
+    SelectionMode mode = SelectionMode.SINGLE_SELECTION;
+
+    SortedSet<Date> selection() {
+        return copy(selected);
+    }
+
+    SortedSet<Date> unselectable() {
+        return copy(unselectable);
+    }
+
+    private static TreeSet<Date> copy(TreeSet<Date> from) {
+        TreeSet<Date> out = new TreeSet<Date>();
+        Iterator<Date> it = from.iterator();
+        while (it.hasNext()) {
+            out.add(new Date(it.next().getTime()));
+        }
+        return out;
+    }
+
+    boolean isEmpty() {
+        return selected.isEmpty();
+    }
+
+    Date first() {
+        return selected.isEmpty() ? null : new Date(selected.first().getTime());
+    }
+
+    Date last() {
+        return selected.isEmpty() ? null : new Date(selected.last().getTime());
+    }
+
+    boolean contains(Date d) {
+        return selected.contains(d);
+    }
+
+    boolean isUnselectable(Date d, Date lower, Date upper) {
+        if (upper != null && upper.getTime() < d.getTime()) {
+            return true;
+        }
+        if (lower != null && lower.getTime() > d.getTime()) {
+            return true;
+        }
+        return unselectable.contains(d);
+    }
+
+    /// Replaces the unselectable dates and drops them from the selection.
+    void setUnselectable(ArrayList<Date> dates) {
+        unselectable.clear();
+        for (int i = 0; i < dates.size(); i++) {
+            unselectable.add(dates.get(i));
+            selected.remove(dates.get(i));
+        }
+    }
+
+    /// Empties the selection; answers whether it held anything.
+    boolean clear() {
+        boolean had = !selected.isEmpty();
+        selected.clear();
+        return had;
+    }
+
+    /// The days from `start` to `end` that can be selected, each a day
+    /// after the one before.
+    private static ArrayList<Date> days(Calendar cal, Date start, Date end, DateSet set, Date lower, Date upper) {
+        ArrayList<Date> out = new ArrayList<Date>();
+        cal.setTime(start);
+        Date d = start;
+        for (int i = 0; i < MAX_DAYS && d.getTime() <= end.getTime(); i++) {
+            if (!set.isUnselectable(d, lower, upper)) {
+                out.add(d);
+            }
+            cal.add(Calendar.DAY_OF_MONTH, 1);
+            d = cal.getTime();
+        }
+        return out;
+    }
+
+    /// Makes the interval the selection; answers whether anything changed.
+    boolean set(Calendar cal, Date start, Date end, Date lower, Date upper) {
+        if (start.getTime() > end.getTime()) {
+            return false;
+        }
+        Date last = mode == SelectionMode.SINGLE_SELECTION ? start : end;
+        ArrayList<Date> days = days(cal, start, last, this, lower, upper);
+        if (days.size() == selected.size()) {
+            boolean same = true;
+            for (int i = 0; i < days.size() && same; i++) {
+                same = selected.contains(days.get(i));
+            }
+            if (same) {
+                return false;
+            }
+        }
+        selected.clear();
+        selected.addAll(days);
+        return true;
+    }
+
+    /// Adds the interval, or replaces the selection with it in the modes
+    /// that hold one date or one interval; answers whether anything
+    /// changed.
+    boolean add(Calendar cal, Date start, Date end, Date lower, Date upper) {
+        if (start.getTime() > end.getTime()) {
+            return false;
+        }
+        if (mode != SelectionMode.MULTIPLE_INTERVAL_SELECTION) {
+            return set(cal, start, end, lower, upper);
+        }
+        ArrayList<Date> days = days(cal, start, end, this, lower, upper);
+        boolean changed = false;
+        for (int i = 0; i < days.size(); i++) {
+            changed |= selected.add(days.get(i));
+        }
+        return changed;
+    }
+
+    /// Removes the selected dates from `start` to `end`, both included;
+    /// answers whether there were any.
+    boolean remove(Date start, Date end) {
+        if (start.getTime() > end.getTime()) {
+            return false;
+        }
+        ArrayList<Date> gone = new ArrayList<Date>();
+        Iterator<Date> it = selected.iterator();
+        while (it.hasNext()) {
+            Date d = it.next();
+            if (d.getTime() >= start.getTime() && d.getTime() <= end.getTime()) {
+                gone.add(d);
+            }
+        }
+        for (int i = 0; i < gone.size(); i++) {
+            selected.remove(gone.get(i));
+        }
+        return !gone.isEmpty();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DaySelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DaySelectionModel.java
new file mode 100644
index 00000000000..7fe6914adb9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DaySelectionModel.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent.EventType;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.SortedSet;
+
+/// A selection of whole days: every date handed in is stored as the first
+/// millisecond of its day in the model's time zone, so two instants of
+/// one day are the same selection. This is the model a month view starts
+/// with.
+///
+/// A date beyond the bounds or among the unselectable dates is left out
+/// of an interval that covers it.
+public class DaySelectionModel extends AbstractDateSelectionModel {
+
+    private final DateSet dates = new DateSet();
+
+    public DaySelectionModel() {
+        this(null);
+    }
+
+    public DaySelectionModel(Locale locale) {
+        super(locale);
+    }
+
+    @Override
+    public SelectionMode getSelectionMode() {
+        return dates.mode;
+    }
+
+    @Override
+    public void setSelectionMode(SelectionMode selectionMode) {
+        if (selectionMode == null) {
+            throw new NullPointerException("selectionMode must not be null");
+        }
+        dates.mode = selectionMode;
+        clearSelection();
+    }
+
+    @Override
+    public void addSelectionInterval(Date startDate, Date endDate) {
+        if (dates.add(calendar, startOfDay(startDate), startOfDay(endDate), lowerBound, upperBound)) {
+            fireValueChanged(EventType.DATES_ADDED);
+        }
+    }
+
+    @Override
+    public void setSelectionInterval(Date startDate, Date endDate) {
+        if (dates.set(calendar, startOfDay(startDate), startOfDay(endDate), lowerBound, upperBound)) {
+            fireValueChanged(EventType.DATES_SET);
+        }
+    }
+
+    @Override
+    public void removeSelectionInterval(Date startDate, Date endDate) {
+        if (dates.remove(startOfDay(startDate), startOfDay(endDate))) {
+            fireValueChanged(EventType.DATES_REMOVED);
+        }
+    }
+
+    @Override
+    public void clearSelection() {
+        if (dates.clear()) {
+            fireValueChanged(EventType.SELECTION_CLEARED);
+        }
+    }
+
+    @Override
+    public SortedSet<Date> getSelection() {
+        return dates.selection();
+    }
+
+    @Override
+    public Date getFirstSelectionDate() {
+        return dates.first();
+    }
+
+    @Override
+    public Date getLastSelectionDate() {
+        return dates.last();
+    }
+
+    @Override
+    public boolean isSelected(Date date) {
+        if (date == null) {
+            throw new NullPointerException("date must not be null");
+        }
+        return dates.contains(startOfDay(date));
+    }
+
+    @Override
+    public boolean isSelectionEmpty() {
+        return dates.isEmpty();
+    }
+
+    @Override
+    public SortedSet<Date> getUnselectableDates() {
+        return dates.unselectable();
+    }
+
+    @Override
+    public void setUnselectableDates(SortedSet<Date> unselectables) {
+        ArrayList<Date> days = new ArrayList<Date>();
+        if (unselectables != null) {
+            Iterator<Date> it = unselectables.iterator();
+            while (it.hasNext()) {
+                days.add(startOfDay(it.next()));
+            }
+        }
+        dates.setUnselectable(days);
+        fireValueChanged(EventType.UNSELECTED_DATES_CHANGED);
+    }
+
+    @Override
+    public boolean isUnselectableDate(Date date) {
+        return dates.isUnselectable(startOfDay(date), lowerBound, upperBound);
+    }
+
+    /// The first millisecond of the day of `date`.
+    @Override
+    public Date getNormalizedDate(Date date) {
+        return startOfDay(date);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DefaultDateSelectionModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DefaultDateSelectionModel.java
new file mode 100644
index 00000000000..fecf65e9719
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DefaultDateSelectionModel.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent.EventType;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.SortedSet;
+
+/// A selection of instants: dates are stored as they are handed in, time
+/// of day included, and an interval holds its start and every instant a
+/// whole number of days after it up to its end. Use [DaySelectionModel]
+/// to select days whatever their time.
+///
+/// A date beyond the bounds or among the unselectable dates is left out
+/// of an interval that covers it.
+public class DefaultDateSelectionModel extends AbstractDateSelectionModel {
+
+    private final DateSet dates = new DateSet();
+
+    public DefaultDateSelectionModel() {
+        this(null);
+    }
+
+    public DefaultDateSelectionModel(Locale locale) {
+        super(locale);
+    }
+
+    @Override
+    public SelectionMode getSelectionMode() {
+        return dates.mode;
+    }
+
+    @Override
+    public void setSelectionMode(SelectionMode selectionMode) {
+        if (selectionMode == null) {
+            throw new NullPointerException("selectionMode must not be null");
+        }
+        dates.mode = selectionMode;
+        clearSelection();
+    }
+
+    @Override
+    public void addSelectionInterval(Date startDate, Date endDate) {
+        if (dates.add(calendar, getNormalizedDate(startDate), getNormalizedDate(endDate), lowerBound, upperBound)) {
+            fireValueChanged(EventType.DATES_ADDED);
+        }
+    }
+
+    @Override
+    public void setSelectionInterval(Date startDate, Date endDate) {
+        if (dates.set(calendar, getNormalizedDate(startDate), getNormalizedDate(endDate), lowerBound, upperBound)) {
+            fireValueChanged(EventType.DATES_SET);
+        }
+    }
+
+    @Override
+    public void removeSelectionInterval(Date startDate, Date endDate) {
+        if (dates.remove(startDate, endDate)) {
+            fireValueChanged(EventType.DATES_REMOVED);
+        }
+    }
+
+    @Override
+    public void clearSelection() {
+        if (dates.clear()) {
+            fireValueChanged(EventType.SELECTION_CLEARED);
+        }
+    }
+
+    @Override
+    public SortedSet<Date> getSelection() {
+        return dates.selection();
+    }
+
+    @Override
+    public Date getFirstSelectionDate() {
+        return dates.first();
+    }
+
+    @Override
+    public Date getLastSelectionDate() {
+        return dates.last();
+    }
+
+    @Override
+    public boolean isSelected(Date date) {
+        if (date == null) {
+            throw new NullPointerException("date must not be null");
+        }
+        return dates.contains(date);
+    }
+
+    /// A copy of `date`: this model stores instants unchanged.
+    @Override
+    public Date getNormalizedDate(Date date) {
+        return new Date(date.getTime());
+    }
+
+    @Override
+    public boolean isSelectionEmpty() {
+        return dates.isEmpty();
+    }
+
+    @Override
+    public SortedSet<Date> getUnselectableDates() {
+        return dates.unselectable();
+    }
+
+    @Override
+    public void setUnselectableDates(SortedSet<Date> unselectables) {
+        ArrayList<Date> all = new ArrayList<Date>();
+        if (unselectables != null) {
+            Iterator<Date> it = unselectables.iterator();
+            while (it.hasNext()) {
+                all.add(getNormalizedDate(it.next()));
+            }
+        }
+        dates.setUnselectable(all);
+        fireValueChanged(EventType.UNSELECTED_DATES_CHANGED);
+    }
+
+    @Override
+    public boolean isUnselectableDate(Date date) {
+        return dates.isUnselectable(date, lowerBound, upperBound);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/package-info.java
new file mode 100644
index 00000000000..7c323f29eb0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The date selection models of the month view and the calendar helpers
+/// they are written with.
+///
+/// The device's `java.util.Calendar` knows no first day of the week and
+/// cannot be copied, so the models keep the first day of the week
+/// themselves and answer a new calendar for every `getCalendar()` call.
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/AbstractHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/AbstractHighlighter.java
new file mode 100644
index 00000000000..8f87e755b3c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/AbstractHighlighter.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import java.util.ArrayList;
+
+/// The base of the highlighters: a predicate, the listener list, and the
+/// rule that a cell is decorated when the predicate matches it and
+/// [#canHighlight(Component, ComponentAdapter)] agrees.
+///
+/// The listener list is private here; SwingX exposes it as a protected
+/// field of a weak list type this layer does not have.
+public abstract class AbstractHighlighter implements Highlighter {
+
+    private final ArrayList<ChangeListener> listeners = new ArrayList<ChangeListener>();
+    private HighlightPredicate predicate;
+
+    public AbstractHighlighter() {
+        this(null);
+    }
+
+    /// Makes a highlighter for the cells `predicate` matches; `null` is
+    /// [HighlightPredicate#ALWAYS].
+    public AbstractHighlighter(HighlightPredicate predicate) {
+        this.predicate = predicate == null ? HighlightPredicate.ALWAYS : predicate;
+    }
+
+    public void setHighlightPredicate(HighlightPredicate predicate) {
+        HighlightPredicate p = predicate == null ? HighlightPredicate.ALWAYS : predicate;
+        if (areEqual(p, this.predicate)) {
+            return;
+        }
+        this.predicate = p;
+        fireStateChanged();
+    }
+
+    public HighlightPredicate getHighlightPredicate() {
+        return predicate;
+    }
+
+    @Override
+    public Component highlight(Component component, ComponentAdapter adapter) {
+        if (canHighlight(component, adapter) && predicate.isHighlighted(component, adapter)) {
+            return doHighlight(component, adapter);
+        }
+        return component;
+    }
+
+    /// Whether this highlighter is able to decorate the component at all,
+    /// asked before the predicate.
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return true;
+    }
+
+    /// Decorates the component of a cell the predicate matched.
+    protected abstract Component doHighlight(Component component, ComponentAdapter adapter);
+
+    protected boolean areEqual(Object oneItem, Object anotherItem) {
+        return oneItem == null ? anotherItem == null : oneItem.equals(anotherItem);
+    }
+
+    @Override
+    public final void addChangeListener(ChangeListener l) {
+        if (l != null) {
+            listeners.add(l);
+        }
+    }
+
+    @Override
+    public final void removeChangeListener(ChangeListener l) {
+        listeners.remove(l);
+    }
+
+    @Override
+    public final ChangeListener[] getChangeListeners() {
+        return listeners.toArray(new ChangeListener[listeners.size()]);
+    }
+
+    protected final void fireStateChanged() {
+        if (listeners.isEmpty()) {
+            return;
+        }
+        ChangeEvent e = new ChangeEvent(this);
+        ChangeListener[] all = getChangeListeners();
+        for (int i = all.length - 1; i >= 0; i--) {
+            all[i].stateChanged(e);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/AlignmentHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/AlignmentHighlighter.java
new file mode 100644
index 00000000000..80959ba36b3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/AlignmentHighlighter.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// Sets the horizontal alignment of a cell's label, button or text field.
+public class AlignmentHighlighter extends AbstractHighlighter {
+
+    private int alignment;
+
+    public AlignmentHighlighter() {
+        this(SwingConstants.LEADING);
+    }
+
+    public AlignmentHighlighter(int alignment) {
+        this(null, alignment);
+    }
+
+    public AlignmentHighlighter(HighlightPredicate predicate) {
+        this(predicate, SwingConstants.LEADING);
+    }
+
+    public AlignmentHighlighter(HighlightPredicate predicate, int alignment) {
+        super(predicate);
+        this.alignment = cn1Check(alignment);
+    }
+
+    private static int cn1Check(int alignment) {
+        if (alignment == SwingConstants.LEFT || alignment == SwingConstants.CENTER
+                || alignment == SwingConstants.RIGHT || alignment == SwingConstants.LEADING
+                || alignment == SwingConstants.TRAILING) {
+            return alignment;
+        }
+        throw new IllegalArgumentException("invalid horizontal alignment, expected one of "
+                + "LEFT, CENTER, RIGHT, LEADING, TRAILING, but was: " + alignment);
+    }
+
+    public int getHorizontalAlignment() {
+        return alignment;
+    }
+
+    public void setHorizontalAlignment(int alignment) {
+        if (this.alignment == alignment) {
+            return;
+        }
+        this.alignment = cn1Check(alignment);
+        fireStateChanged();
+    }
+
+    @Override
+    protected Component doHighlight(Component renderer, ComponentAdapter adapter) {
+        if (renderer instanceof JLabel) {
+            ((JLabel) renderer).setHorizontalAlignment(alignment);
+        } else if (renderer instanceof AbstractButton) {
+            ((AbstractButton) renderer).setHorizontalAlignment(alignment);
+        } else if (renderer instanceof JTextField) {
+            ((JTextField) renderer).setHorizontalAlignment(alignment);
+        }
+        return renderer;
+    }
+
+    @Override
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return component instanceof JLabel || component instanceof AbstractButton
+                || component instanceof JTextField;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/BorderHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/BorderHighlighter.java
new file mode 100644
index 00000000000..b99fef8bd47
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/BorderHighlighter.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.border.CompoundBorder;
+
+/// Puts a border on the cell's component: around the border the renderer
+/// gave it, inside that border, or instead of it.
+public class BorderHighlighter extends AbstractHighlighter {
+
+    private Border paddingBorder;
+    private boolean inner;
+    private boolean compound;
+
+    public BorderHighlighter() {
+        this((HighlightPredicate) null, null);
+    }
+
+    public BorderHighlighter(HighlightPredicate predicate) {
+        this(predicate, null);
+    }
+
+    public BorderHighlighter(Border paddingBorder) {
+        this(null, paddingBorder);
+    }
+
+    public BorderHighlighter(HighlightPredicate predicate, Border paddingBorder) {
+        this(predicate, paddingBorder, true);
+    }
+
+    public BorderHighlighter(HighlightPredicate predicate, Border paddingBorder, boolean compound) {
+        this(predicate, paddingBorder, compound, false);
+    }
+
+    /// Makes a border highlighter. With `compound` the border is combined
+    /// with the component's own, inside it when `inner` and around it
+    /// otherwise; without, it replaces the component's border.
+    public BorderHighlighter(HighlightPredicate predicate, Border paddingBorder, boolean compound, boolean inner) {
+        super(predicate);
+        this.paddingBorder = paddingBorder;
+        this.compound = compound;
+        this.inner = inner;
+    }
+
+    @Override
+    protected Component doHighlight(Component renderer, ComponentAdapter adapter) {
+        if (!(renderer instanceof JComponent)) {
+            return renderer;
+        }
+        JComponent c = (JComponent) renderer;
+        Border own = c.getBorder();
+        if (compound && own != null) {
+            c.setBorder(inner ? new CompoundBorder(own, paddingBorder) : new CompoundBorder(paddingBorder, own));
+        } else {
+            c.setBorder(paddingBorder);
+        }
+        return renderer;
+    }
+
+    @Override
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return paddingBorder != null && component instanceof JComponent;
+    }
+
+    public void setCompound(boolean compound) {
+        if (this.compound == compound) {
+            return;
+        }
+        this.compound = compound;
+        fireStateChanged();
+    }
+
+    public boolean isCompound() {
+        return compound;
+    }
+
+    public void setInner(boolean inner) {
+        if (this.inner == inner) {
+            return;
+        }
+        this.inner = inner;
+        fireStateChanged();
+    }
+
+    public boolean isInner() {
+        return inner;
+    }
+
+    public void setBorder(Border padding) {
+        if (areEqual(padding, paddingBorder)) {
+            return;
+        }
+        paddingBorder = padding;
+        fireStateChanged();
+    }
+
+    public Border getBorder() {
+        return paddingBorder;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ColorHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ColorHighlighter.java
new file mode 100644
index 00000000000..b4ea68089fb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ColorHighlighter.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// Sets the background and the text color of a cell, with a second pair of
+/// colors for selected cells. A `null` color leaves that property as the
+/// renderer made it; a translucent one is mixed over what is there.
+public class ColorHighlighter extends AbstractHighlighter {
+
+    private Color background;
+    private Color foreground;
+    private Color selectedBackground;
+    private Color selectedForeground;
+
+    public ColorHighlighter() {
+        this(null);
+    }
+
+    public ColorHighlighter(HighlightPredicate predicate) {
+        this(predicate, null, null);
+    }
+
+    public ColorHighlighter(Color cellBackground, Color cellForeground) {
+        this(null, cellBackground, cellForeground);
+    }
+
+    public ColorHighlighter(HighlightPredicate predicate, Color cellBackground, Color cellForeground) {
+        this(predicate, cellBackground, cellForeground, null, null);
+    }
+
+    public ColorHighlighter(Color cellBackground, Color cellForeground, Color selectedBackground,
+            Color selectedForeground) {
+        this(null, cellBackground, cellForeground, selectedBackground, selectedForeground);
+    }
+
+    public ColorHighlighter(HighlightPredicate predicate, Color cellBackground, Color cellForeground,
+            Color selectedBackground, Color selectedForeground) {
+        super(predicate);
+        this.background = cellBackground;
+        this.foreground = cellForeground;
+        this.selectedBackground = selectedBackground;
+        this.selectedForeground = selectedForeground;
+    }
+
+    @Override
+    protected Component doHighlight(Component renderer, ComponentAdapter adapter) {
+        applyBackground(renderer, adapter);
+        applyForeground(renderer, adapter);
+        return renderer;
+    }
+
+    static Color cn1Blend(Color under, Color over) {
+        if (over == null) {
+            return under;
+        }
+        int a = over.getAlpha();
+        if (a >= 255 || under == null) {
+            return over;
+        }
+        float t = a / 255f;
+        float u = 1 - t;
+        return new Color(Math.round(under.getRed() * u + over.getRed() * t),
+                Math.round(under.getGreen() * u + over.getGreen() * t),
+                Math.round(under.getBlue() * u + over.getBlue() * t));
+    }
+
+    protected void applyBackground(Component renderer, ComponentAdapter adapter) {
+        Color color = adapter.isSelected() ? getSelectedBackground() : getBackground();
+        if (color != null) {
+            renderer.setBackground(cn1Blend(renderer.getBackground(), color));
+        }
+    }
+
+    protected void applyForeground(Component renderer, ComponentAdapter adapter) {
+        Color color = adapter.isSelected() ? getSelectedForeground() : getForeground();
+        if (color != null) {
+            renderer.setForeground(cn1Blend(renderer.getForeground(), color));
+        }
+    }
+
+    public Color getBackground() {
+        return background;
+    }
+
+    public void setBackground(Color color) {
+        if (areEqual(color, background)) {
+            return;
+        }
+        background = color;
+        fireStateChanged();
+    }
+
+    public Color getForeground() {
+        return foreground;
+    }
+
+    public void setForeground(Color color) {
+        if (areEqual(color, foreground)) {
+            return;
+        }
+        foreground = color;
+        fireStateChanged();
+    }
+
+    public Color getSelectedBackground() {
+        return selectedBackground;
+    }
+
+    public void setSelectedBackground(Color color) {
+        if (areEqual(color, selectedBackground)) {
+            return;
+        }
+        selectedBackground = color;
+        fireStateChanged();
+    }
+
+    public Color getSelectedForeground() {
+        return selectedForeground;
+    }
+
+    public void setSelectedForeground(Color color) {
+        if (areEqual(color, selectedForeground)) {
+            return;
+        }
+        selectedForeground = color;
+        fireStateChanged();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ComponentAdapter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ComponentAdapter.java
new file mode 100644
index 00000000000..f51fcf4f43e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ComponentAdapter.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+
+/// The cell a renderer component is being prepared for, in terms that are
+/// the same for a table, a list and a tree.
+///
+/// [#row] and [#column] are the cell in view coordinates. The methods that
+/// take a row and a column take model coordinates unless they say
+/// otherwise.
+public abstract class ComponentAdapter {
+
+    public static final Object DEFAULT_COLUMN_IDENTIFIER = "Column0";
+
+    /// The view row of the cell.
+    public int row = 0;
+
+    /// The view column of the cell.
+    public int column = 0;
+
+    protected final JComponent target;
+
+    public ComponentAdapter(JComponent component) {
+        target = component;
+    }
+
+    public JComponent getComponent() {
+        return target;
+    }
+
+    /// The name of the column at a model index.
+    public String getColumnName(int columnIndex) {
+        return null;
+    }
+
+    /// The identifier of the column at a model index.
+    public Object getColumnIdentifierAt(int columnIndex) {
+        if (columnIndex < 0 || columnIndex >= getColumnCount()) {
+            throw new ArrayIndexOutOfBoundsException("invalid column index: " + columnIndex);
+        }
+        return DEFAULT_COLUMN_IDENTIFIER;
+    }
+
+    /// The model index of the column with the identifier, or -1.
+    public int getColumnIndex(Object identifier) {
+        for (int i = 0; i < getColumnCount(); i++) {
+            if (identifier != null && identifier.equals(getColumnIdentifierAt(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /// Whether the model column can be shown, which a hidden one cannot.
+    public boolean isTestable(int column) {
+        return column >= 0 && column < getColumnCount();
+    }
+
+    public Class<?> getColumnClass(int column) {
+        return Object.class;
+    }
+
+    /// The class of the cell's column.
+    public Class<?> getColumnClass() {
+        return getColumnClass(convertColumnIndexToModel(column));
+    }
+
+    public int getColumnCount() {
+        return 1;
+    }
+
+    public int getRowCount() {
+        return 0;
+    }
+
+    /// The value at a model row and model column.
+    public abstract Object getValueAt(int row, int column);
+
+    /// Whether the cell at a model row and model column can be edited.
+    public abstract boolean isCellEditable(int row, int column);
+
+    /// The text of the cell.
+    public String getString() {
+        return getString(convertColumnIndexToModel(column));
+    }
+
+    /// The text of the cell in the same row at a model column.
+    public String getString(int modelColumnIndex) {
+        return getFilteredStringAt(row, modelColumnIndex);
+    }
+
+    /// The text at a view row and a model column.
+    public String getFilteredStringAt(int row, int column) {
+        return getStringAt(convertRowIndexToModel(row), column);
+    }
+
+    /// The text at a model row and model column: the value's `toString`.
+    public String getStringAt(int row, int column) {
+        Object value = getValueAt(row, column);
+        return value == null ? "" : value.toString();
+    }
+
+    /// The value of the cell.
+    public Object getValue() {
+        return getValue(convertColumnIndexToModel(column));
+    }
+
+    /// The value in the cell's row at a model column.
+    public Object getValue(int modelColumnIndex) {
+        return getFilteredValueAt(row, modelColumnIndex);
+    }
+
+    /// The value at a view row and a model column.
+    public Object getFilteredValueAt(int row, int column) {
+        return getValueAt(convertRowIndexToModel(row), column);
+    }
+
+    /// The bounds of the cell in its component.
+    public Rectangle getCellBounds() {
+        return target.getBounds();
+    }
+
+    public abstract boolean hasFocus();
+
+    public abstract boolean isSelected();
+
+    public abstract boolean isEditable();
+
+    public boolean isExpanded() {
+        return false;
+    }
+
+    public boolean isLeaf() {
+        return false;
+    }
+
+    /// Whether the cell is the one that shows the tree structure.
+    public boolean isHierarchical() {
+        return false;
+    }
+
+    /// The depth of the cell's node, 0 where there is no hierarchy.
+    public int getDepth() {
+        return 0;
+    }
+
+    public int convertColumnIndexToView(int columnModelIndex) {
+        return columnModelIndex;
+    }
+
+    public int convertColumnIndexToModel(int columnViewIndex) {
+        return columnViewIndex;
+    }
+
+    public int convertRowIndexToView(int rowModelIndex) {
+        return rowModelIndex;
+    }
+
+    public int convertRowIndexToModel(int rowViewIndex) {
+        return rowViewIndex;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/CompoundHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/CompoundHighlighter.java
new file mode 100644
index 00000000000..d4a9ca5d442
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/CompoundHighlighter.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import java.util.ArrayList;
+import java.util.List;
+
+/// Runs a list of highlighters in order, each on the component the one
+/// before it answered, so a later highlighter wins where two set the same
+/// property. A change of any of them is reported as a change of this one.
+public class CompoundHighlighter extends AbstractHighlighter {
+
+    public static final Highlighter[] EMPTY_HIGHLIGHTERS = new Highlighter[0];
+
+    protected List<Highlighter> highlighters;
+
+    private ChangeListener highlighterChangeListener;
+
+    public CompoundHighlighter(Highlighter... inList) {
+        this(null, inList);
+    }
+
+    public CompoundHighlighter(HighlightPredicate predicate, Highlighter... inList) {
+        super(predicate);
+        highlighters = new ArrayList<Highlighter>();
+        cn1Set(inList);
+    }
+
+    /// Replaces the list.
+    public void setHighlighters(Highlighter... inList) {
+        if (inList == null) {
+            throw new NullPointerException("highlighters must not be null");
+        }
+        if (highlighters.isEmpty() && inList.length == 0) {
+            return;
+        }
+        cn1Set(inList);
+        fireStateChanged();
+    }
+
+    private void cn1Set(Highlighter[] inList) {
+        if (inList == null) {
+            throw new NullPointerException("highlighters must not be null");
+        }
+        for (int i = 0; i < inList.length; i++) {
+            if (inList[i] == null) {
+                throw new NullPointerException("highlighter must not be null");
+            }
+        }
+        for (int i = 0; i < highlighters.size(); i++) {
+            highlighters.get(i).removeChangeListener(cn1Listener());
+        }
+        highlighters.clear();
+        for (int i = 0; i < inList.length; i++) {
+            highlighters.add(inList[i]);
+            inList[i].addChangeListener(cn1Listener());
+        }
+    }
+
+    /// Appends a highlighter.
+    public void addHighlighter(Highlighter highlighter) {
+        addHighlighter(highlighter, false);
+    }
+
+    /// Adds a highlighter at the start of the list or at its end.
+    public void addHighlighter(Highlighter highlighter, boolean prepend) {
+        if (highlighter == null) {
+            throw new NullPointerException("highlighter must not be null");
+        }
+        if (prepend) {
+            highlighters.add(0, highlighter);
+        } else {
+            highlighters.add(highlighter);
+        }
+        highlighter.addChangeListener(cn1Listener());
+        fireStateChanged();
+    }
+
+    public void removeHighlighter(Highlighter hl) {
+        if (highlighters.remove(hl)) {
+            hl.removeChangeListener(cn1Listener());
+            fireStateChanged();
+        }
+    }
+
+    public Highlighter[] getHighlighters() {
+        if (highlighters.isEmpty()) {
+            return EMPTY_HIGHLIGHTERS;
+        }
+        return highlighters.toArray(new Highlighter[highlighters.size()]);
+    }
+
+    private ChangeListener cn1Listener() {
+        if (highlighterChangeListener == null) {
+            highlighterChangeListener = new ChangeListener() {
+                @Override
+                public void stateChanged(ChangeEvent e) {
+                    fireStateChanged();
+                }
+            };
+        }
+        return highlighterChangeListener;
+    }
+
+    /// The listener this highlighter has on each of the ones it contains.
+    protected ChangeListener getHighlighterChangeListener() {
+        return cn1Listener();
+    }
+
+    @Override
+    protected Component doHighlight(Component component, ComponentAdapter adapter) {
+        Component c = component;
+        for (int i = 0; i < highlighters.size(); i++) {
+            c = highlighters.get(i).highlight(c, adapter);
+        }
+        return c;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/EnabledHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/EnabledHighlighter.java
new file mode 100644
index 00000000000..414fbea958b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/EnabledHighlighter.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// Enables or disables the cell's component, which grays out a cell.
+public class EnabledHighlighter extends AbstractHighlighter {
+
+    private boolean enabled;
+
+    public EnabledHighlighter() {
+        this(null);
+    }
+
+    public EnabledHighlighter(boolean enabled) {
+        this(null, enabled);
+    }
+
+    public EnabledHighlighter(HighlightPredicate predicate) {
+        this(predicate, false);
+    }
+
+    public EnabledHighlighter(HighlightPredicate predicate, boolean enabled) {
+        super(predicate);
+        this.enabled = enabled;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        if (this.enabled == enabled) {
+            return;
+        }
+        this.enabled = enabled;
+        fireStateChanged();
+    }
+
+    @Override
+    protected Component doHighlight(Component renderer, ComponentAdapter adapter) {
+        renderer.setEnabled(enabled);
+        return renderer;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/FontHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/FontHighlighter.java
new file mode 100644
index 00000000000..ae1498af298
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/FontHighlighter.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+
+/// Sets the font of the cell's component.
+public class FontHighlighter extends AbstractHighlighter {
+
+    private Font font;
+
+    public FontHighlighter() {
+        this((HighlightPredicate) null);
+    }
+
+    public FontHighlighter(Font font) {
+        this(null, font);
+    }
+
+    public FontHighlighter(HighlightPredicate predicate) {
+        this(predicate, null);
+    }
+
+    public FontHighlighter(HighlightPredicate predicate, Font font) {
+        super(predicate);
+        this.font = font;
+    }
+
+    public Font getFont() {
+        return font;
+    }
+
+    public void setFont(Font font) {
+        if (areEqual(font, this.font)) {
+            return;
+        }
+        this.font = font;
+        fireStateChanged();
+    }
+
+    @Override
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return font != null;
+    }
+
+    @Override
+    protected Component doHighlight(Component component, ComponentAdapter adapter) {
+        component.setFont(font);
+        return component;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlightPredicate.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlightPredicate.java
new file mode 100644
index 00000000000..b37b2c14a9e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlightPredicate.java
@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Point;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/// Decides whether a cell is to be highlighted.
+///
+/// The rollover predicates read the client property `swingx.rollover` of
+/// the cell's component, a point of view column and view row that the
+/// extended table, list and tree keep while a pointer hovers over them. A
+/// touch screen has no hover, so they match nothing there.
+///
+/// `BIG_DECIMAL_NEGATIVE` is absent because a device has no `BigDecimal`;
+/// the pattern and search predicates are absent because it has no
+/// `java.util.regex`.
+public interface HighlightPredicate {
+
+    HighlightPredicate ALWAYS = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return true;
+        }
+    };
+
+    HighlightPredicate NEVER = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return false;
+        }
+    };
+
+    /// The row the pointer is over.
+    HighlightPredicate ROLLOVER_ROW = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Object p = adapter.getComponent().getClientProperty("swingx.rollover");
+            return p instanceof Point && ((Point) p).y == adapter.row;
+        }
+    };
+
+    /// The column the pointer is over.
+    HighlightPredicate ROLLOVER_COLUMN = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Object p = adapter.getComponent().getClientProperty("swingx.rollover");
+            return p instanceof Point && ((Point) p).x == adapter.column;
+        }
+    };
+
+    /// The cell the pointer is over.
+    HighlightPredicate ROLLOVER_CELL = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Object p = adapter.getComponent().getClientProperty("swingx.rollover");
+            return p instanceof Point && ((Point) p).y == adapter.row && ((Point) p).x == adapter.column;
+        }
+    };
+
+    HighlightPredicate EDITABLE = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.isEditable();
+        }
+    };
+
+    HighlightPredicate READ_ONLY = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return !adapter.isEditable();
+        }
+    };
+
+    HighlightPredicate IS_LEAF = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.isLeaf();
+        }
+    };
+
+    HighlightPredicate IS_FOLDER = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return !adapter.isLeaf();
+        }
+    };
+
+    HighlightPredicate IS_SELECTED = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.isSelected();
+        }
+    };
+
+    /// The cells whose renderer component wants more width than the cell
+    /// has.
+    HighlightPredicate IS_TEXT_TRUNCATED = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            if (adapter.getComponent() == null || renderer == null) {
+                return false;
+            }
+            return renderer.getPreferredSize().width > adapter.getCellBounds().width;
+        }
+    };
+
+    HighlightPredicate HAS_FOCUS = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.hasFocus();
+        }
+    };
+
+    /// The rows with an even view index: the first, the third, ...
+    HighlightPredicate EVEN = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.row % 2 == 0;
+        }
+    };
+
+    /// The rows with an odd view index: the second, the fourth, ...
+    HighlightPredicate ODD = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.row % 2 != 0;
+        }
+    };
+
+    /// The cells whose value is a number below zero.
+    HighlightPredicate INTEGER_NEGATIVE = new HighlightPredicate() {
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Object v = adapter.getValue();
+            return v instanceof Number && ((Number) v).intValue() < 0;
+        }
+    };
+
+    HighlightPredicate[] EMPTY_PREDICATE_ARRAY = new HighlightPredicate[0];
+
+    Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+
+    Integer[] EMPTY_INTEGER_ARRAY = new Integer[0];
+
+    /// Whether the cell `adapter` describes, about to be drawn by
+    /// `renderer`, is to be highlighted.
+    boolean isHighlighted(Component renderer, ComponentAdapter adapter);
+
+    /// Negates a predicate.
+    class NotHighlightPredicate implements HighlightPredicate {
+
+        private final HighlightPredicate predicate;
+
+        public NotHighlightPredicate(HighlightPredicate predicate) {
+            if (predicate == null) {
+                throw new NullPointerException("predicate must not be null");
+            }
+            this.predicate = predicate;
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return !predicate.isHighlighted(renderer, adapter);
+        }
+
+        public HighlightPredicate getHighlightPredicate() {
+            return predicate;
+        }
+    }
+
+    /// Matches when every one of its predicates does; never with none.
+    class AndHighlightPredicate implements HighlightPredicate {
+
+        private final List<HighlightPredicate> predicates;
+
+        public AndHighlightPredicate(HighlightPredicate... predicate) {
+            predicates = new ArrayList<HighlightPredicate>();
+            for (int i = 0; i < predicate.length; i++) {
+                if (predicate[i] == null) {
+                    throw new NullPointerException("predicate must not be null");
+                }
+                predicates.add(predicate[i]);
+            }
+        }
+
+        public AndHighlightPredicate(Collection<HighlightPredicate> list) {
+            predicates = new ArrayList<HighlightPredicate>(list);
+            if (predicates.contains(null)) {
+                throw new NullPointerException("predicate must not be null");
+            }
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            for (int i = 0; i < predicates.size(); i++) {
+                if (!predicates.get(i).isHighlighted(renderer, adapter)) {
+                    return false;
+                }
+            }
+            return !predicates.isEmpty();
+        }
+
+        public HighlightPredicate[] getHighlightPredicates() {
+            return predicates.toArray(new HighlightPredicate[predicates.size()]);
+        }
+    }
+
+    /// Matches when at least one of its predicates does.
+    class OrHighlightPredicate implements HighlightPredicate {
+
+        private final List<HighlightPredicate> predicates;
+
+        public OrHighlightPredicate(HighlightPredicate... predicate) {
+            predicates = new ArrayList<HighlightPredicate>();
+            for (int i = 0; i < predicate.length; i++) {
+                if (predicate[i] == null) {
+                    throw new NullPointerException("predicate must not be null");
+                }
+                predicates.add(predicate[i]);
+            }
+        }
+
+        public OrHighlightPredicate(Collection<HighlightPredicate> list) {
+            predicates = new ArrayList<HighlightPredicate>(list);
+            if (predicates.contains(null)) {
+                throw new NullPointerException("predicate must not be null");
+            }
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            for (int i = 0; i < predicates.size(); i++) {
+                if (predicates.get(i).isHighlighted(renderer, adapter)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public HighlightPredicate[] getHighlightPredicates() {
+            return predicates.toArray(new HighlightPredicate[predicates.size()]);
+        }
+    }
+
+    /// Stripes: matches every second group of `linesPerGroup` rows,
+    /// starting with the second group.
+    class RowGroupHighlightPredicate implements HighlightPredicate {
+
+        private final int linesPerGroup;
+
+        public RowGroupHighlightPredicate(int linesPerGroup) {
+            if (linesPerGroup < 1) {
+                throw new IllegalArgumentException("a group contain at least 1 row, was: " + linesPerGroup);
+            }
+            this.linesPerGroup = linesPerGroup;
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return adapter.row >= 0 && (adapter.row / linesPerGroup) % 2 != 0;
+        }
+
+        public int getLinesPerGroup() {
+            return linesPerGroup;
+        }
+    }
+
+    /// Matches the cells of the given model columns.
+    class ColumnHighlightPredicate implements HighlightPredicate {
+
+        private final List<Integer> columnList;
+
+        public ColumnHighlightPredicate(int... columns) {
+            columnList = new ArrayList<Integer>();
+            for (int i = 0; i < columns.length; i++) {
+                columnList.add(Integer.valueOf(columns[i]));
+            }
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return columnList.contains(Integer.valueOf(adapter.convertColumnIndexToModel(adapter.column)));
+        }
+
+        public Integer[] getColumns() {
+            return columnList.toArray(new Integer[columnList.size()]);
+        }
+    }
+
+    /// Matches the cells of the columns with one of the given identifiers.
+    class IdentifierHighlightPredicate implements HighlightPredicate {
+
+        private final List<Object> identifierList;
+
+        public IdentifierHighlightPredicate(Object... identifiers) {
+            identifierList = new ArrayList<Object>();
+            for (int i = 0; i < identifiers.length; i++) {
+                identifierList.add(identifiers[i]);
+            }
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            int modelIndex = adapter.convertColumnIndexToModel(adapter.column);
+            return identifierList.contains(adapter.getColumnIdentifierAt(modelIndex));
+        }
+
+        public Object[] getIdentifiers() {
+            return identifierList.toArray();
+        }
+    }
+
+    /// Matches the cells of nodes at one of the given depths.
+    class DepthHighlightPredicate implements HighlightPredicate {
+
+        private final List<Integer> depthList;
+
+        public DepthHighlightPredicate(int... depths) {
+            depthList = new ArrayList<Integer>();
+            for (int i = 0; i < depths.length; i++) {
+                depthList.add(Integer.valueOf(depths[i]));
+            }
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            return depthList.contains(Integer.valueOf(adapter.getDepth()));
+        }
+
+        public Integer[] getDepths() {
+            return depthList.toArray(new Integer[depthList.size()]);
+        }
+    }
+
+    /// Matches the cells whose value equals a given one.
+    class EqualsHighlightPredicate implements HighlightPredicate {
+
+        private final Object compareValue;
+
+        public EqualsHighlightPredicate() {
+            this(null);
+        }
+
+        public EqualsHighlightPredicate(Object compareValue) {
+            this.compareValue = compareValue;
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Object value = adapter.getValue();
+            return compareValue == null ? value == null : compareValue.equals(value);
+        }
+
+        public Object getCompareValue() {
+            return compareValue;
+        }
+    }
+
+    /// Matches the cells whose value is an instance of a class.
+    class TypeHighlightPredicate implements HighlightPredicate {
+
+        private final Class<?> clazz;
+
+        public TypeHighlightPredicate() {
+            this(Object.class);
+        }
+
+        public TypeHighlightPredicate(Class<?> clazz) {
+            if (clazz == null) {
+                throw new NullPointerException("class must not be null");
+            }
+            this.clazz = clazz;
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Object value = adapter.getValue();
+            return value != null && clazz.isInstance(value);
+        }
+
+        public Class<?> getType() {
+            return clazz;
+        }
+    }
+
+    /// Matches the cells whose column class is assignable to a class.
+    class ColumnTypeHighlightPredicate implements HighlightPredicate {
+
+        private final Class<?> clazz;
+
+        public ColumnTypeHighlightPredicate() {
+            this(Object.class);
+        }
+
+        public ColumnTypeHighlightPredicate(Class<?> clazz) {
+            if (clazz == null) {
+                throw new NullPointerException("class must not be null");
+            }
+            this.clazz = clazz;
+        }
+
+        @Override
+        public boolean isHighlighted(Component renderer, ComponentAdapter adapter) {
+            Class<?> c = adapter.getColumnClass();
+            return c != null && clazz.isAssignableFrom(c);
+        }
+
+        public Class<?> getType() {
+            return clazz;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/Highlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/Highlighter.java
new file mode 100644
index 00000000000..25c0236716a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/Highlighter.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+/// Restyles a renderer component for one cell.
+public interface Highlighter {
+
+    /// Decorates `renderer` for the cell `adapter` describes and answers
+    /// the component to paint, usually the same one.
+    Component highlight(Component renderer, ComponentAdapter adapter);
+
+    /// Adds a listener told when the highlighter's settings change.
+    void addChangeListener(ChangeListener l);
+
+    void removeChangeListener(ChangeListener l);
+
+    ChangeListener[] getChangeListeners();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlighterFactory.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlighterFactory.java
new file mode 100644
index 00000000000..38ae75ae0f3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlighterFactory.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.rt.CellTheme;
+
+/// Ready made striping highlighters.
+///
+/// The striping made without a color takes its color from the component:
+/// the component's background with a little of its text color mixed in,
+/// so it reads in a light theme and in a dark one.
+public final class HighlighterFactory {
+
+    public static final Color BEIGE = new Color(245, 245, 220);
+    public static final Color LINE_PRINTER = new Color(0xCC, 0xCC, 0xFF);
+    public static final Color CLASSIC_LINE_PRINTER = new Color(0xCC, 0xFF, 0xCC);
+    public static final Color FLORAL_WHITE = new Color(255, 250, 240);
+    public static final Color QUICKSILVER = new Color(0xF0, 0xF0, 0xE0);
+    public static final Color GENERIC_GRAY = new Color(229, 229, 229);
+    public static final Color LEDGER = new Color(0xF5, 0xFF, 0xF5);
+    public static final Color NOTEPAD = new Color(0xFF, 0xFF, 0xCC);
+
+    public HighlighterFactory() {
+    }
+
+    /// A stripe on every second row, in a color taken from the component.
+    public static Highlighter createSimpleStriping() {
+        return new ThemeStripe(HighlightPredicate.ODD);
+    }
+
+    /// Stripes of `rowsPerGroup` rows, in a color taken from the component.
+    public static Highlighter createSimpleStriping(int rowsPerGroup) {
+        return new ThemeStripe(new HighlightPredicate.RowGroupHighlightPredicate(rowsPerGroup));
+    }
+
+    /// A stripe of the given color on every second row.
+    public static Highlighter createSimpleStriping(Color stripeBackground) {
+        return new ColorHighlighter(HighlightPredicate.ODD, stripeBackground, null);
+    }
+
+    /// Stripes of `rowsPerGroup` rows in the given color.
+    public static Highlighter createSimpleStriping(Color stripeBackground, int rowsPerGroup) {
+        return new ColorHighlighter(new HighlightPredicate.RowGroupHighlightPredicate(rowsPerGroup),
+                stripeBackground, null);
+    }
+
+    /// Rows alternating between white and a light gray.
+    public static Highlighter createAlternateStriping() {
+        return createAlternateStriping(Color.WHITE, GENERIC_GRAY);
+    }
+
+    /// Groups of `rowsPerGroup` rows alternating between white and a light
+    /// gray.
+    public static Highlighter createAlternateStriping(int rowsPerGroup) {
+        return createAlternateStriping(Color.WHITE, GENERIC_GRAY, rowsPerGroup);
+    }
+
+    /// Rows alternating between two colors, the first row in
+    /// `baseBackground`.
+    public static Highlighter createAlternateStriping(Color baseBackground, Color alternateBackground) {
+        ColorHighlighter base = new ColorHighlighter(HighlightPredicate.EVEN, baseBackground, null);
+        ColorHighlighter alternate = new ColorHighlighter(HighlightPredicate.ODD, alternateBackground, null);
+        return new CompoundHighlighter(base, alternate);
+    }
+
+    /// Groups of `linesPerStripe` rows alternating between two colors.
+    public static Highlighter createAlternateStriping(Color baseBackground, Color alternateBackground,
+            int linesPerStripe) {
+        HighlightPredicate predicate = new HighlightPredicate.RowGroupHighlightPredicate(linesPerStripe);
+        ColorHighlighter base = new ColorHighlighter(new HighlightPredicate.NotHighlightPredicate(predicate),
+                baseBackground, null);
+        ColorHighlighter alternate = new ColorHighlighter(predicate, alternateBackground, null);
+        return new CompoundHighlighter(base, alternate);
+    }
+
+    /// A stripe whose color follows the component's own colors.
+    private static final class ThemeStripe extends ColorHighlighter {
+
+        ThemeStripe(HighlightPredicate predicate) {
+            super(predicate);
+        }
+
+        @Override
+        protected void applyBackground(Component renderer, ComponentAdapter adapter) {
+            if (adapter.isSelected()) {
+                return;
+            }
+            Color bg = adapter.getComponent().getBackground();
+            Color fg = adapter.getComponent().getForeground();
+            if (bg != null && fg != null) {
+                renderer.setBackground(CellTheme.mix(bg, fg, 0.07f));
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/IconHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/IconHighlighter.java
new file mode 100644
index 00000000000..484ab602995
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/IconHighlighter.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.IconAware;
+
+/// Sets the icon of the cell's component, which has to be a label or
+/// another component that takes an icon.
+public class IconHighlighter extends AbstractHighlighter {
+
+    private Icon icon;
+
+    public IconHighlighter() {
+        this((HighlightPredicate) null);
+    }
+
+    public IconHighlighter(HighlightPredicate predicate) {
+        this(predicate, null);
+    }
+
+    public IconHighlighter(Icon icon) {
+        this(null, icon);
+    }
+
+    public IconHighlighter(HighlightPredicate predicate, Icon icon) {
+        super(predicate);
+        this.icon = icon;
+    }
+
+    public void setIcon(Icon icon) {
+        if (areEqual(icon, this.icon)) {
+            return;
+        }
+        this.icon = icon;
+        fireStateChanged();
+    }
+
+    public Icon getIcon() {
+        return icon;
+    }
+
+    @Override
+    protected Component doHighlight(Component component, ComponentAdapter adapter) {
+        if (component instanceof IconAware) {
+            ((IconAware) component).setIcon(icon);
+        } else if (component instanceof JLabel) {
+            ((JLabel) component).setIcon(icon);
+        }
+        return component;
+    }
+
+    @Override
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return icon != null && (component instanceof IconAware || component instanceof JLabel);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/PainterHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/PainterHighlighter.java
new file mode 100644
index 00000000000..9a335866d82
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/PainterHighlighter.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.PainterAware;
+
+/// Gives the cell's component a [Painter] to draw its background with.
+/// Only the renderer components of this subset's own renderers take one;
+/// any other component is left alone.
+///
+/// A painter that changes is not observed: call `repaint()` on the table,
+/// list or tree after changing one.
+public class PainterHighlighter extends AbstractHighlighter {
+
+    private Painter painter;
+
+    public PainterHighlighter() {
+        this((HighlightPredicate) null);
+    }
+
+    public PainterHighlighter(HighlightPredicate predicate) {
+        this(predicate, null);
+    }
+
+    public PainterHighlighter(Painter painter) {
+        this(null, painter);
+    }
+
+    public PainterHighlighter(HighlightPredicate predicate, Painter painter) {
+        super(predicate);
+        this.painter = painter;
+    }
+
+    public Painter getPainter() {
+        return painter;
+    }
+
+    public void setPainter(Painter painter) {
+        if (areEqual(painter, this.painter)) {
+            return;
+        }
+        this.painter = painter;
+        fireStateChanged();
+    }
+
+    @Override
+    protected Component doHighlight(Component component, ComponentAdapter adapter) {
+        if (component instanceof PainterAware) {
+            ((PainterAware) component).setPainter(painter);
+        }
+        return component;
+    }
+
+    @Override
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return painter != null && component instanceof PainterAware;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ToolTipHighlighter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ToolTipHighlighter.java
new file mode 100644
index 00000000000..c285e798969
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/ToolTipHighlighter.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+
+/// Sets the tool tip text of the cell's component to the cell's text, or
+/// to what a [StringValue] makes of the cell's value.
+///
+/// This layer records tool tip texts and shows none, so the effect is
+/// what `getToolTipText()` of the renderer component answers.
+public class ToolTipHighlighter extends AbstractHighlighter {
+
+    private StringValue toolTipValue;
+
+    public ToolTipHighlighter() {
+        this((HighlightPredicate) null);
+    }
+
+    public ToolTipHighlighter(StringValue toolTipValue) {
+        this(null, toolTipValue);
+    }
+
+    public ToolTipHighlighter(HighlightPredicate predicate) {
+        this(predicate, null);
+    }
+
+    public ToolTipHighlighter(HighlightPredicate predicate, StringValue toolTipValue) {
+        super(predicate);
+        this.toolTipValue = toolTipValue;
+    }
+
+    public StringValue getToolTipValue() {
+        return toolTipValue;
+    }
+
+    public void setToolTipValue(StringValue toolTipValue) {
+        if (areEqual(toolTipValue, this.toolTipValue)) {
+            return;
+        }
+        this.toolTipValue = toolTipValue;
+        fireStateChanged();
+    }
+
+    @Override
+    protected boolean canHighlight(Component component, ComponentAdapter adapter) {
+        return component instanceof JComponent;
+    }
+
+    @Override
+    protected Component doHighlight(Component component, ComponentAdapter adapter) {
+        if (component instanceof JComponent) {
+            String text = toolTipValue != null ? toolTipValue.getString(adapter.getValue()) : adapter.getString();
+            ((JComponent) component).setToolTipText(text);
+        }
+        return component;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/package-info.java
new file mode 100644
index 00000000000..e4be121e134
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Highlighters: objects that restyle the component a renderer hands out,
+/// cell by cell, for the cells a [HighlightPredicate] picks.
+///
+/// A [ComponentAdapter] describes the cell being rendered to both. The
+/// extended table, list and tree run their highlighters over every
+/// renderer component just before it is painted.
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorEvent.java
new file mode 100644
index 00000000000..89087b1ef84
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorEvent.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.error;
+
+import java.util.EventObject;
+
+/// An error a component met, with the component as the source.
+public class ErrorEvent extends EventObject {
+
+    private static final long serialVersionUID = 1L;
+
+    private final Throwable throwable;
+
+    public ErrorEvent(Throwable throwable, Object source) {
+        super(source);
+        this.throwable = throwable;
+    }
+
+    public Throwable getThrowable() {
+        return throwable;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorListener.java
new file mode 100644
index 00000000000..e21e22e87fb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.error;
+
+import java.util.EventListener;
+
+/// Told when a component met an error it wants reported.
+public interface ErrorListener extends EventListener {
+
+    void errorOccured(ErrorEvent event);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorSupport.java
new file mode 100644
index 00000000000..b9e60dfe0c9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/ErrorSupport.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.error;
+
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import java.util.ArrayList;
+import java.util.List;
+
+/// Keeps the error listeners of a component and tells them of an error,
+/// always on the event thread.
+public class ErrorSupport {
+
+    private final List<ErrorListener> listeners = new ArrayList<ErrorListener>();
+    private final Object source;
+
+    public ErrorSupport(Object source) {
+        this.source = source;
+    }
+
+    public void addErrorListener(ErrorListener listener) {
+        listeners.add(listener);
+    }
+
+    public void removeErrorListener(ErrorListener listener) {
+        listeners.remove(listener);
+    }
+
+    public ErrorListener[] getErrorListeners() {
+        return listeners.toArray(new ErrorListener[listeners.size()]);
+    }
+
+    /// Tells every listener of `throwable`, now when called on the event
+    /// thread and from it later otherwise.
+    public void fireErrorEvent(Throwable throwable) {
+        ErrorEvent event = new ErrorEvent(throwable, source);
+        ErrorListener[] ls = getErrorListeners();
+        if (SwingUtilities.isEventDispatchThread()) {
+            for (int i = 0; i < ls.length; i++) {
+                ls[i].errorOccured(event);
+            }
+            return;
+        }
+        SwingUtilities.invokeLater(new Tell(ls, event));
+    }
+
+    /// Tells the listeners there were when the error was fired.
+    private static final class Tell implements Runnable {
+
+        private final ErrorListener[] listeners;
+        private final ErrorEvent event;
+
+        Tell(ErrorListener[] listeners, ErrorEvent event) {
+            this.listeners = listeners;
+            this.event = event;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < listeners.length; i++) {
+                listeners[i].errorOccured(event);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/package-info.java
new file mode 100644
index 00000000000..1783ae44628
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/error/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The listener side of SwingX error reporting: [ErrorEvent],
+/// [ErrorListener] and [ErrorSupport].
+///
+/// `ErrorInfo`, `ErrorLevel` and `ErrorReporter` are absent. Each is built
+/// on `java.util.logging.Level`, which a device does not have.
+package com.codename1.desktopcompat.org.jdesktop.swingx.error;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/DateSelectionEvent.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/DateSelectionEvent.java
new file mode 100644
index 00000000000..905aa836ce2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/DateSelectionEvent.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.event;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DateSelectionModel;
+import java.util.Date;
+import java.util.EventObject;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/// A change of a date selection model: of the selected dates, of what can
+/// be selected, or of the calendar the model reads dates with.
+public class DateSelectionEvent extends EventObject {
+
+    /// What changed.
+    public enum EventType {
+        DATES_ADDED,
+        DATES_REMOVED,
+        DATES_SET,
+        SELECTION_CLEARED,
+        SELECTABLE_DATES_CHANGED,
+        SELECTABLE_RANGE_CHANGED,
+        UNSELECTED_DATES_CHANGED,
+        LOWER_BOUND_CHANGED,
+        UPPER_BOUND_CHANGED,
+        ADJUSTING_STARTED,
+        ADJUSTING_STOPPED,
+        CALENDAR_CHANGED
+    }
+
+    private final EventType eventType;
+    private final boolean adjusting;
+
+    /// `source` is the model that changed.
+    public DateSelectionEvent(Object source, EventType eventType, boolean adjusting) {
+        super(source);
+        this.eventType = eventType;
+        this.adjusting = adjusting;
+    }
+
+    /// The selection of the source model as it is now; empty when the
+    /// source is not a selection model.
+    public SortedSet<Date> getSelection() {
+        Object src = getSource();
+        if (src instanceof DateSelectionModel) {
+            return ((DateSelectionModel) src).getSelection();
+        }
+        return new TreeSet<Date>();
+    }
+
+    public final EventType getEventType() {
+        return eventType;
+    }
+
+    public boolean isAdjusting() {
+        return adjusting;
+    }
+
+    @Override
+    public String toString() {
+        return "DateSelectionEvent[type=" + eventType + ",adjusting=" + adjusting + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/DateSelectionListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/DateSelectionListener.java
new file mode 100644
index 00000000000..f47b964a71c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/DateSelectionListener.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.event;
+
+import java.util.EventListener;
+
+/// Receives the changes of a date selection model.
+public interface DateSelectionListener extends EventListener {
+
+    void valueChanged(DateSelectionEvent ev);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/TableColumnModelExtListener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/TableColumnModelExtListener.java
new file mode 100644
index 00000000000..e58e7c0af93
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/TableColumnModelExtListener.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.event;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+
+/// A column model listener that is also told when a property of one of
+/// the model's columns changes.
+public interface TableColumnModelExtListener extends TableColumnModelListener {
+
+    /// A property of a column changed; the event's source is the column.
+    void columnPropertyChange(PropertyChangeEvent event);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/package-info.java
new file mode 100644
index 00000000000..ad2b1cf94e2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/event/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The SwingX event types and listeners.
+package com.codename1.desktopcompat.org.jdesktop.swingx.event;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/AbstractHyperlinkAction.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/AbstractHyperlinkAction.java
new file mode 100644
index 00000000000..9d5601dc663
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/AbstractHyperlinkAction.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink;
+
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.action.AbstractActionExt;
+
+/// An action with a target -- the thing a link leads to -- and a visited
+/// flag kept under [#VISITED_KEY], which a hyperlink follows to change
+/// its color.
+///
+/// Setting a target names the action after it and clears the flag.
+public abstract class AbstractHyperlinkAction<T> extends AbstractActionExt {
+
+    public static final String VISITED_KEY = "visited";
+
+    protected T target;
+
+    public AbstractHyperlinkAction() {
+        this(null);
+    }
+
+    public AbstractHyperlinkAction(T target) {
+        setTarget(target);
+    }
+
+    public void setVisited(boolean visited) {
+        putValue(VISITED_KEY, Boolean.valueOf(visited));
+    }
+
+    public boolean isVisited() {
+        return Boolean.TRUE.equals(getValue(VISITED_KEY));
+    }
+
+    public T getTarget() {
+        return target;
+    }
+
+    public void setTarget(T target) {
+        T old = this.target;
+        uninstallTarget();
+        this.target = target;
+        installTarget();
+        firePropertyChange("target", old, target);
+    }
+
+    /// Called after the target changed: names the action after it and
+    /// marks it as not visited.
+    protected void installTarget() {
+        setName(target != null ? target.toString() : "");
+        setVisited(false);
+    }
+
+    /// Called before the target changes; does nothing.
+    protected void uninstallTarget() {
+    }
+
+    /// Does nothing: a link is not a toggle.
+    @Override
+    public void itemStateChanged(ItemEvent e) {
+    }
+
+    /// Does nothing: a link is not a toggle.
+    @Override
+    public void setStateAction(boolean state) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/HyperlinkAction.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/HyperlinkAction.java
new file mode 100644
index 00000000000..3be13c71186
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/HyperlinkAction.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.ui.Display;
+import java.net.URI;
+
+/// Opens its target address with whatever the device opens addresses
+/// with: the browser for `http`, the mail client for `mailto`.
+///
+/// The address goes to Codename One's `Display.execute`. There is no
+/// choice between browsing and mailing as on a desktop -- the scheme of
+/// the address decides -- so the constructors and the accessor that take
+/// a desktop action are absent. The action is marked visited once the
+/// address was handed over; whether anything opened is not known.
+public class HyperlinkAction extends AbstractHyperlinkAction<URI> {
+
+    private static UrlOpener opener;
+
+    /// An action for `uri`, which may be `null`.
+    public static HyperlinkAction createHyperlinkAction(URI uri) {
+        HyperlinkAction a = new HyperlinkAction();
+        a.setTarget(uri);
+        return a;
+    }
+
+    public HyperlinkAction() {
+        super();
+    }
+
+    /// Replaces what opens addresses; `null` goes back to Codename One.
+    static void setOpener(UrlOpener o) {
+        opener = o;
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        URI uri = getTarget();
+        if (uri == null) {
+            return;
+        }
+        String address = uri.toString();
+        UrlOpener o = opener;
+        if (o != null) {
+            o.open(address);
+        } else if (Display.isInitialized()) {
+            Display.getInstance().execute(address);
+        } else {
+            return;
+        }
+        setVisited(true);
+    }
+
+    /// Names the action after the address and enables it only while there
+    /// is one.
+    @Override
+    protected void installTarget() {
+        super.installTarget();
+        setEnabled(getTarget() != null);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/UrlOpener.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/UrlOpener.java
new file mode 100644
index 00000000000..83811fdead4
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/UrlOpener.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink;
+
+/// Opens an address outside the application. The one in use hands it to
+/// Codename One; tests put a recording one in its place.
+interface UrlOpener {
+
+    void open(String url);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/package-info.java
new file mode 100644
index 00000000000..7169a71d77f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The actions behind a hyperlink: one that remembers a target and whether
+/// it was visited, and one that opens an address with the device's
+/// browser.
+package com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/package-info.java
new file mode 100644
index 00000000000..2ccefbebc79
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/package-info.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The most used part of SwingX: the extended table, list and tree with
+/// their highlighters, the titled, collapsible and task panels, the
+/// hyperlink, busy label, date picker and month view.
+///
+/// As with the Swing classes of this layer an application keeps compiling
+/// against the real SwingX and its references are relocated here by the
+/// build. A class or member this subset lacks is a compile error at that
+/// step and never a different behavior. There are no look and feel
+/// add-ons and no UI delegates: every component draws itself, in the
+/// colors of the Codename One theme.
+package com.codename1.desktopcompat.org.jdesktop.swingx;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractAreaPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractAreaPainter.java
new file mode 100644
index 00000000000..3ed87bfed56
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractAreaPainter.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.BasicStroke;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.GradientPaint;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+
+/// A painter of a shape: an inside that is filled and an outline that is
+/// drawn, each with a paint of its own.
+///
+/// ## What differs from SwingX
+///
+///  - A paint is a color or a `GradientPaint`; the graphics of this layer
+///    draws with nothing else.
+///  - A stretched gradient is fitted to the painted area by its direction:
+///    a horizontal gradient runs across the width, a vertical one down the
+///    height and any other from corner to corner.
+///  - There are no area effects (shadows, glows), so their accessors are
+///    absent.
+public abstract class AbstractAreaPainter<T> extends AbstractLayoutPainter<T> {
+
+    /// Which parts of the shape are painted.
+    public enum Style {
+        BOTH,
+        FILLED,
+        OUTLINE,
+        NONE
+    }
+
+    private Paint fillPaint;
+    private Paint borderPaint;
+    private boolean paintStretched;
+    private Style style = Style.BOTH;
+    private float borderWidth;
+
+    /// A painter that fills with red, the SwingX default.
+    public AbstractAreaPainter() {
+        fillPaint = Color.RED;
+    }
+
+    public AbstractAreaPainter(Paint paint) {
+        fillPaint = paint;
+    }
+
+    public Paint getFillPaint() {
+        return fillPaint;
+    }
+
+    public void setFillPaint(Paint p) {
+        Paint old = fillPaint;
+        fillPaint = p;
+        setDirty(true);
+        firePropertyChange("fillPaint", old, p);
+    }
+
+    public boolean isPaintStretched() {
+        return paintStretched;
+    }
+
+    /// Whether a gradient is fitted to the area that is painted instead of
+    /// being used at the coordinates it was made with.
+    public void setPaintStretched(boolean paintStretched) {
+        boolean old = this.paintStretched;
+        this.paintStretched = paintStretched;
+        setDirty(true);
+        firePropertyChange("paintStretched", Boolean.valueOf(old), Boolean.valueOf(paintStretched));
+    }
+
+    public void setBorderPaint(Paint p) {
+        Paint old = borderPaint;
+        borderPaint = p;
+        setDirty(true);
+        firePropertyChange("borderPaint", old, p);
+    }
+
+    public Paint getBorderPaint() {
+        return borderPaint;
+    }
+
+    /// Sets what is painted; `null` is [Style#BOTH].
+    public void setStyle(Style s) {
+        Style old = style;
+        style = s == null ? Style.BOTH : s;
+        setDirty(true);
+        firePropertyChange("style", old, style);
+    }
+
+    public Style getStyle() {
+        return style;
+    }
+
+    public void setBorderWidth(float s) {
+        float old = borderWidth;
+        borderWidth = s;
+        setDirty(true);
+        firePropertyChange("borderWidth", Float.valueOf(old), Float.valueOf(s));
+    }
+
+    public float getBorderWidth() {
+        return borderWidth;
+    }
+
+    /// The outline of what this painter draws in an area of the given
+    /// size.
+    protected abstract Shape provideShape(Graphics2D g, T comp, int width, int height);
+
+    /// `p`, fitted to the area when it is a gradient and stretching is on.
+    Paint cn1Fitted(Paint p, int width, int height) {
+        if (!paintStretched || !(p instanceof GradientPaint)) {
+            return p;
+        }
+        GradientPaint gp = (GradientPaint) p;
+        Point2D a = gp.getPoint1();
+        Point2D b = gp.getPoint2();
+        double dx = b.getX() - a.getX();
+        double dy = b.getY() - a.getY();
+        float x1 = 0;
+        float y1 = 0;
+        float x2 = 0;
+        float y2 = 0;
+        if (dx > 0) {
+            x2 = width;
+        } else if (dx < 0) {
+            x1 = width;
+        }
+        if (dy > 0) {
+            y2 = height;
+        } else if (dy < 0) {
+            y1 = height;
+        }
+        if (x1 == x2 && y1 == y2) {
+            return gp.getColor1();
+        }
+        return new GradientPaint(x1, y1, gp.getColor1(), x2, y2, gp.getColor2(), gp.isCyclic());
+    }
+
+    boolean cn1Fills() {
+        return (style == Style.BOTH || style == Style.FILLED) && fillPaint != null;
+    }
+
+    boolean cn1Outlines() {
+        return (style == Style.BOTH || style == Style.OUTLINE) && borderPaint != null && borderWidth > 0;
+    }
+
+    /// Fills and outlines `shape` as the style and paints say.
+    void cn1PaintShape(Graphics2D g, Shape shape, int width, int height) {
+        if (shape == null) {
+            return;
+        }
+        if (cn1Fills()) {
+            g.setPaint(cn1Fitted(fillPaint, width, height));
+            g.fill(shape);
+        }
+        if (cn1Outlines()) {
+            g.setPaint(cn1Fitted(borderPaint, width, height));
+            g.setStroke(new BasicStroke(borderWidth));
+            g.draw(shape);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractLayoutPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractLayoutPainter.java
new file mode 100644
index 00000000000..02bbfc77fd1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractLayoutPainter.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+
+/// A painter whose content has a size of its own and is placed inside the
+/// painted area: aligned to an edge or centered, kept off the edges by
+/// insets, or stretched to fill.
+public abstract class AbstractLayoutPainter<T> extends AbstractPainter<T> {
+
+    /// Where the content sits from left to right.
+    public enum HorizontalAlignment {
+        LEFT,
+        CENTER,
+        RIGHT
+    }
+
+    /// Where the content sits from top to bottom.
+    public enum VerticalAlignment {
+        TOP,
+        CENTER,
+        BOTTOM
+    }
+
+    private VerticalAlignment verticalAlignment = VerticalAlignment.CENTER;
+    private HorizontalAlignment horizontalAlignment = HorizontalAlignment.CENTER;
+    private Insets insets = new Insets(0, 0, 0, 0);
+    private boolean fillVertical;
+    private boolean fillHorizontal;
+
+    public AbstractLayoutPainter() {
+    }
+
+    public HorizontalAlignment getHorizontalAlignment() {
+        return horizontalAlignment;
+    }
+
+    /// A copy of the insets.
+    public Insets getInsets() {
+        return new Insets(insets.top, insets.left, insets.bottom, insets.right);
+    }
+
+    public VerticalAlignment getVerticalAlignment() {
+        return verticalAlignment;
+    }
+
+    public boolean isFillHorizontal() {
+        return fillHorizontal;
+    }
+
+    public boolean isFillVertical() {
+        return fillVertical;
+    }
+
+    public void setHorizontalAlignment(HorizontalAlignment horizontal) {
+        HorizontalAlignment old = horizontalAlignment;
+        horizontalAlignment = horizontal == null ? HorizontalAlignment.CENTER : horizontal;
+        setDirty(true);
+        firePropertyChange("horizontalAlignment", old, horizontalAlignment);
+    }
+
+    /// Whether the content takes the whole width inside the insets.
+    public void setFillHorizontal(boolean fillHorizontal) {
+        boolean old = this.fillHorizontal;
+        this.fillHorizontal = fillHorizontal;
+        setDirty(true);
+        firePropertyChange("fillHorizontal", Boolean.valueOf(old), Boolean.valueOf(fillHorizontal));
+    }
+
+    /// Sets the distance the content keeps from the edges; `null` is none.
+    public void setInsets(Insets insets) {
+        Insets old = this.insets;
+        this.insets = insets == null ? new Insets(0, 0, 0, 0)
+                : new Insets(insets.top, insets.left, insets.bottom, insets.right);
+        setDirty(true);
+        firePropertyChange("insets", old, getInsets());
+    }
+
+    public void setVerticalAlignment(VerticalAlignment vertical) {
+        VerticalAlignment old = verticalAlignment;
+        verticalAlignment = vertical == null ? VerticalAlignment.CENTER : vertical;
+        setDirty(true);
+        firePropertyChange("verticalAlignment", old, verticalAlignment);
+    }
+
+    /// Whether the content takes the whole height inside the insets.
+    public void setFillVertical(boolean verticalStretch) {
+        boolean old = this.fillVertical;
+        this.fillVertical = verticalStretch;
+        setDirty(true);
+        firePropertyChange("fillVertical", Boolean.valueOf(old), Boolean.valueOf(verticalStretch));
+    }
+
+    /// The rectangle content of the given size takes in an area of
+    /// `width` by `height`: placed by the alignments and insets, and as
+    /// wide or tall as the area inside the insets along an axis that is
+    /// filled.
+    protected final Rectangle calculateLayout(int contentWidth, int contentHeight, int width, int height) {
+        Rectangle r = new Rectangle(0, 0, contentWidth, contentHeight);
+        if (horizontalAlignment == HorizontalAlignment.LEFT) {
+            r.x = insets.left;
+        } else if (horizontalAlignment == HorizontalAlignment.RIGHT) {
+            r.x = width - contentWidth - insets.right;
+        } else {
+            r.x = (width - contentWidth) / 2 + insets.left - insets.right;
+        }
+        if (verticalAlignment == VerticalAlignment.TOP) {
+            r.y = insets.top;
+        } else if (verticalAlignment == VerticalAlignment.BOTTOM) {
+            r.y = height - contentHeight - insets.bottom;
+        } else {
+            r.y = (height - contentHeight) / 2 + insets.top - insets.bottom;
+        }
+        if (fillHorizontal) {
+            r.x = insets.left;
+            r.width = width - insets.left - insets.right;
+        }
+        if (fillVertical) {
+            r.y = insets.top;
+            r.height = height - insets.top - insets.bottom;
+        }
+        return r;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractPainter.java
new file mode 100644
index 00000000000..2440a1c1487
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AbstractPainter.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.RenderingHints;
+import com.codename1.desktopcompat.org.jdesktop.beans.AbstractBean;
+
+/// The base of the painters: it carries the properties every painter has,
+/// prepares the graphics and leaves the drawing to [#doPaint].
+///
+/// ## What differs from SwingX
+///
+///  - Nothing is cached. [#setCacheable(boolean)] is recorded,
+///    [#shouldUseCache()] answers `false` and [#clearCache()] does nothing:
+///    a painter draws every time it is asked to.
+///  - There are no image filters, so the filter accessors are absent.
+///  - The painter is not copied before it is handed the graphics. `paint`
+///    draws with the graphics it is given, as the [Painter] contract
+///    allows; callers that need the state afterwards pass a copy.
+public abstract class AbstractPainter<T> extends AbstractBean implements Painter<T> {
+
+    /// How an image is resampled when it is drawn scaled.
+    public enum Interpolation {
+        Bicubic,
+        Bilinear,
+        NearestNeighbor
+    }
+
+    private boolean visible = true;
+    private boolean antialiasing = true;
+    private boolean cacheable;
+    private boolean dirty;
+    private Interpolation interpolation = Interpolation.NearestNeighbor;
+
+    public AbstractPainter() {
+    }
+
+    /// `cacheable` is recorded only; see the class comment.
+    public AbstractPainter(boolean cacheable) {
+        this.cacheable = cacheable;
+    }
+
+    public boolean isAntialiasing() {
+        return antialiasing;
+    }
+
+    public void setAntialiasing(boolean value) {
+        boolean old = antialiasing;
+        antialiasing = value;
+        if (old != value) {
+            setDirty(true);
+        }
+        firePropertyChange("antialiasing", Boolean.valueOf(old), Boolean.valueOf(value));
+    }
+
+    public Interpolation getInterpolation() {
+        return interpolation;
+    }
+
+    /// Sets the interpolation hint; `null` means nearest neighbor.
+    public void setInterpolation(Interpolation value) {
+        Interpolation old = interpolation;
+        interpolation = value == null ? Interpolation.NearestNeighbor : value;
+        if (old != interpolation) {
+            setDirty(true);
+        }
+        firePropertyChange("interpolation", old, interpolation);
+    }
+
+    public boolean isVisible() {
+        return visible;
+    }
+
+    /// An invisible painter paints nothing.
+    public void setVisible(boolean visible) {
+        boolean old = this.visible;
+        this.visible = visible;
+        if (old != visible) {
+            setDirty(true);
+        }
+        firePropertyChange("visible", Boolean.valueOf(old), Boolean.valueOf(visible));
+    }
+
+    public boolean isCacheable() {
+        return cacheable;
+    }
+
+    /// Recorded only: nothing is cached.
+    public void setCacheable(boolean cacheable) {
+        boolean old = this.cacheable;
+        this.cacheable = cacheable;
+        firePropertyChange("cacheable", Boolean.valueOf(old), Boolean.valueOf(cacheable));
+    }
+
+    /// Does nothing: there is no cache.
+    public void clearCache() {
+    }
+
+    /// Called before every paint; a subclass checks its state against
+    /// `object` here and calls [#setDirty(boolean)] when it changed.
+    protected void validate(T object) {
+    }
+
+    /// Whether a property changed since the painter last painted.
+    protected boolean isDirty() {
+        return dirty;
+    }
+
+    protected void setDirty(boolean d) {
+        boolean old = dirty;
+        dirty = d;
+        firePropertyChange("dirty", Boolean.valueOf(old), Boolean.valueOf(d));
+    }
+
+    /// Always `false`.
+    protected boolean shouldUseCache() {
+        return false;
+    }
+
+    /// Sets the rendering hints of the antialiasing and interpolation
+    /// properties on the graphics about to be painted with.
+    protected void configureGraphics(Graphics2D g) {
+        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                antialiasing ? RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
+        Object hint;
+        if (interpolation == Interpolation.Bicubic) {
+            hint = RenderingHints.VALUE_INTERPOLATION_BICUBIC;
+        } else if (interpolation == Interpolation.Bilinear) {
+            hint = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
+        } else {
+            hint = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
+        }
+        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
+    }
+
+    /// Draws into `(0, 0, width, height)`.
+    protected abstract void doPaint(Graphics2D g, T object, int width, int height);
+
+    @Override
+    public final void paint(Graphics2D g, T object, int width, int height) {
+        if (g == null) {
+            throw new NullPointerException("The Graphics2D must be supplied");
+        }
+        if (!visible || width < 1 || height < 1) {
+            return;
+        }
+        configureGraphics(g);
+        validate(object);
+        doPaint(g, object, width, height);
+        if (isDirty()) {
+            setDirty(false);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AlphaPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AlphaPainter.java
new file mode 100644
index 00000000000..24b2e0049c6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/AlphaPainter.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.AlphaComposite;
+import com.codename1.desktopcompat.java.awt.Composite;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+
+/// A compound painter whose painters draw through one opacity.
+///
+/// The opacity multiplies whatever the graphics already has.
+public class AlphaPainter<T> extends CompoundPainter<T> {
+
+    private float alpha = 1.0f;
+
+    public AlphaPainter() {
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, T component, int width, int height) {
+        if (alpha <= 0f) {
+            return;
+        }
+        Graphics copy = g.create();
+        try {
+            if (copy instanceof Graphics2D) {
+                Graphics2D g2 = (Graphics2D) copy;
+                if (alpha < 1f) {
+                    Composite current = g2.getComposite();
+                    float base = current instanceof AlphaComposite ? ((AlphaComposite) current).getAlpha() : 1f;
+                    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, base * alpha));
+                }
+                super.doPaint(g2, component, width, height);
+            }
+        } finally {
+            copy.dispose();
+        }
+    }
+
+    public float getAlpha() {
+        return alpha;
+    }
+
+    /// Sets the opacity; values outside 0 to 1 are brought into it.
+    public void setAlpha(float alpha) {
+        float old = this.alpha;
+        this.alpha = alpha < 0f ? 0f : alpha > 1f ? 1f : alpha;
+        setDirty(true);
+        firePropertyChange("alpha", Float.valueOf(old), Float.valueOf(this.alpha));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/BusyPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/BusyPainter.java
new file mode 100644
index 00000000000..270b513c046
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/BusyPainter.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.Ellipse2D;
+import com.codename1.desktopcompat.java.awt.geom.PathIterator;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.geom.RoundRectangle2D;
+
+/// Draws the "busy" indicator: a number of points spread evenly along a
+/// trajectory, one of them highlighted and a trail behind it fading back
+/// to the base color. Advancing the frame moves the highlight.
+///
+/// The default is the familiar wheel: bars that point outward along a
+/// circle. A frame of -1 highlights nothing.
+///
+/// ## What differs from SwingX
+///
+///  - The points are placed by walking the flattened outline of the
+///    trajectory at equal distances, and each point shape is turned to
+///    stand across the trajectory there. The default wheel comes out the
+///    same; an unusual trajectory may place its points slightly
+///    differently.
+///  - `getXY`, a curve helper of the original, is absent.
+public class BusyPainter extends AbstractPainter<Object> {
+
+    /// The way the highlight travels along the trajectory.
+    public enum Direction {
+        /// In the direction the trajectory was drawn.
+        RIGHT,
+        /// Against it.
+        LEFT
+    }
+
+    private int frame = -1;
+    private int points = 8;
+    private Color baseColor = new Color(200, 200, 200);
+    private Color highlightColor = Color.BLACK;
+    private int trailLength = 4;
+    private Shape pointShape;
+    private Shape trajectory;
+    private Direction direction = Direction.RIGHT;
+    private boolean paintCentered;
+
+    /// The wheel at its default height of 26 pixels.
+    public BusyPainter() {
+        this(26);
+    }
+
+    /// The wheel scaled to the given height.
+    public BusyPainter(int height) {
+        this(getScaledDefaultPoint(height), getScaledDefaultTrajectory(height));
+    }
+
+    public BusyPainter(Shape point, Shape trajectory) {
+        init(point, trajectory, new Color(200, 200, 200), Color.BLACK);
+    }
+
+    /// The circle the default wheel's bars are centered on, for a wheel of
+    /// the given height.
+    protected static Shape getScaledDefaultTrajectory(int height) {
+        float bar = height * 8 / 26f;
+        return new Ellipse2D.Float(bar / 2, bar / 2, height - bar, height - bar);
+    }
+
+    /// One bar of the default wheel of the given height.
+    protected static Shape getScaledDefaultPoint(int height) {
+        float bar = height * 8 / 26f;
+        float thick = height * 4 / 26f;
+        return new RoundRectangle2D.Float(0, 0, bar, thick, thick, thick);
+    }
+
+    /// Sets both shapes and both colors at once.
+    protected void init(Shape point, Shape trajectory, Color baseColor, Color highlightColor) {
+        this.baseColor = baseColor;
+        this.highlightColor = highlightColor;
+        this.pointShape = point;
+        this.trajectory = trajectory;
+    }
+
+    /// The trajectory as a polyline: `{x0, y0, x1, y1, ...}`.
+    private static float[] flatten(Shape s) {
+        float[] out = new float[64];
+        int n = 0;
+        float[] c = new float[6];
+        float startX = 0;
+        float startY = 0;
+        for (PathIterator it = s.getPathIterator(null, 0.25); !it.isDone(); it.next()) {
+            int type = it.currentSegment(c);
+            float x;
+            float y;
+            if (type == PathIterator.SEG_CLOSE) {
+                x = startX;
+                y = startY;
+            } else {
+                x = c[0];
+                y = c[1];
+                if (type == PathIterator.SEG_MOVETO) {
+                    startX = x;
+                    startY = y;
+                }
+            }
+            if (n >= 2 && out[n - 2] == x && out[n - 1] == y) {
+                continue;
+            }
+            if (n + 2 > out.length) {
+                float[] grown = new float[out.length * 2];
+                System.arraycopy(out, 0, grown, 0, n);
+                out = grown;
+            }
+            out[n++] = x;
+            out[n++] = y;
+        }
+        float[] exact = new float[n];
+        System.arraycopy(out, 0, exact, 0, n);
+        return exact;
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object t, int width, int height) {
+        if (pointShape == null || trajectory == null || points <= 0) {
+            return;
+        }
+        float[] line = flatten(trajectory);
+        int vertices = line.length / 2;
+        if (vertices < 2) {
+            return;
+        }
+        double total = 0;
+        double[] lengths = new double[vertices - 1];
+        for (int i = 0; i < vertices - 1; i++) {
+            double dx = line[2 * i + 2] - line[2 * i];
+            double dy = line[2 * i + 3] - line[2 * i + 1];
+            lengths[i] = Math.sqrt(dx * dx + dy * dy);
+            total += lengths[i];
+        }
+        if (total <= 0) {
+            return;
+        }
+        Rectangle2D pb = pointShape.getBounds2D();
+        double offsetX = 0;
+        double offsetY = 0;
+        if (paintCentered) {
+            Rectangle tb = trajectory.getBounds();
+            offsetX = (width - tb.width) / 2.0 - tb.x;
+            offsetY = (height - tb.height) / 2.0 - tb.y;
+        }
+        boolean closed = line[0] == line[line.length - 2] && line[1] == line[line.length - 1];
+        // Along an open trajectory the last point sits on its end.
+        double step = closed || points == 1 ? total / points : total / (points - 1);
+        int segment = 0;
+        double before = 0;
+        for (int i = 0; i < points; i++) {
+            double at = i * step;
+            while (segment < lengths.length - 1 && before + lengths[segment] < at) {
+                before += lengths[segment];
+                segment++;
+            }
+            double len = lengths[segment];
+            double f = len > 0 ? Math.min(1, (at - before) / len) : 0;
+            double x0 = line[2 * segment];
+            double y0 = line[2 * segment + 1];
+            double dx = line[2 * segment + 2] - x0;
+            double dy = line[2 * segment + 3] - y0;
+            Graphics copy = g.create();
+            try {
+                if (copy instanceof Graphics2D) {
+                    Graphics2D pg = (Graphics2D) copy;
+                    pg.translate(offsetX + x0 + dx * f, offsetY + y0 + dy * f);
+                    if (len > 0) {
+                        // Across the trajectory: its direction turned a
+                        // quarter.
+                        pg.transform(AffineTransform.getRotateInstance(-dy, dx));
+                    }
+                    pg.translate(-pb.getCenterX(), -pb.getCenterY());
+                    pg.setColor(colorOf(i));
+                    pg.fill(pointShape);
+                }
+            } finally {
+                copy.dispose();
+            }
+        }
+    }
+
+    /// The color of point `i` in the current frame.
+    private Color colorOf(int i) {
+        if (frame < 0 || baseColor == null || highlightColor == null) {
+            return baseColor != null ? baseColor : Color.GRAY;
+        }
+        int lead = cn1HighlightedPoint();
+        // How many points behind the highlighted one this point is.
+        int behind = direction == Direction.LEFT ? i - lead : lead - i;
+        if (behind < 0) {
+            behind += points;
+        }
+        if (behind == 0) {
+            return highlightColor;
+        }
+        if (behind >= trailLength || trailLength <= 0) {
+            return baseColor;
+        }
+        float terp = 1f - (float) (trailLength - behind) / (float) trailLength;
+        return new Color(mix(highlightColor.getRed(), baseColor.getRed(), terp),
+                mix(highlightColor.getGreen(), baseColor.getGreen(), terp),
+                mix(highlightColor.getBlue(), baseColor.getBlue(), terp),
+                mix(highlightColor.getAlpha(), baseColor.getAlpha(), terp));
+    }
+
+    private static int mix(int from, int to, float t) {
+        int v = Math.round(from + (to - from) * t);
+        return v < 0 ? 0 : v > 255 ? 255 : v;
+    }
+
+    /// The point the highlight is on in the current frame, or -1.
+    int cn1HighlightedPoint() {
+        if (frame < 0 || points <= 0) {
+            return -1;
+        }
+        int along = frame % points;
+        return direction == Direction.LEFT ? points - 1 - along : along;
+    }
+
+    /// The color point `i` is drawn in in the current frame.
+    Color cn1PointColor(int i) {
+        return colorOf(i);
+    }
+
+    public boolean isPaintCentered() {
+        return paintCentered;
+    }
+
+    /// Whether the trajectory is centered in the painted area rather than
+    /// drawn at its own coordinates.
+    public void setPaintCentered(boolean paintCentered) {
+        boolean old = this.paintCentered;
+        this.paintCentered = paintCentered;
+        setDirty(true);
+        firePropertyChange("paintCentered", Boolean.valueOf(old), Boolean.valueOf(paintCentered));
+    }
+
+    public int getFrame() {
+        return frame;
+    }
+
+    /// Sets the point the highlight is on; -1 highlights none.
+    public void setFrame(int frame) {
+        int old = this.frame;
+        this.frame = frame;
+        setDirty(true);
+        firePropertyChange("frame", Integer.valueOf(old), Integer.valueOf(frame));
+    }
+
+    public Color getBaseColor() {
+        return baseColor;
+    }
+
+    public void setBaseColor(Color baseColor) {
+        Color old = this.baseColor;
+        this.baseColor = baseColor;
+        setDirty(true);
+        firePropertyChange("baseColor", old, baseColor);
+    }
+
+    public Color getHighlightColor() {
+        return highlightColor;
+    }
+
+    public void setHighlightColor(Color highlightColor) {
+        Color old = this.highlightColor;
+        this.highlightColor = highlightColor;
+        setDirty(true);
+        firePropertyChange("highlightColor", old, highlightColor);
+    }
+
+    public int getPoints() {
+        return points;
+    }
+
+    public void setPoints(int points) {
+        int old = this.points;
+        this.points = points;
+        setDirty(true);
+        firePropertyChange("points", Integer.valueOf(old), Integer.valueOf(points));
+    }
+
+    public int getTrailLength() {
+        return trailLength;
+    }
+
+    /// The number of points behind the highlight that fade back to the
+    /// base color.
+    public void setTrailLength(int trailLength) {
+        int old = this.trailLength;
+        this.trailLength = trailLength;
+        setDirty(true);
+        firePropertyChange("trailLength", Integer.valueOf(old), Integer.valueOf(trailLength));
+    }
+
+    public final Shape getPointShape() {
+        return pointShape;
+    }
+
+    public final void setPointShape(Shape pointShape) {
+        Shape old = this.pointShape;
+        this.pointShape = pointShape;
+        setDirty(true);
+        firePropertyChange("pointShape", old, pointShape);
+    }
+
+    public final Shape getTrajectory() {
+        return trajectory;
+    }
+
+    public final void setTrajectory(Shape trajectory) {
+        Shape old = this.trajectory;
+        this.trajectory = trajectory;
+        setDirty(true);
+        firePropertyChange("trajectory", old, trajectory);
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    /// Sets the way the trail points; `null` is [Direction#RIGHT].
+    public void setDirection(Direction dir) {
+        Direction old = direction;
+        direction = dir == null ? Direction.RIGHT : dir;
+        setDirty(true);
+        firePropertyChange("direction", old, direction);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/CheckerboardPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/CheckerboardPainter.java
new file mode 100644
index 00000000000..850a732b625
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/CheckerboardPainter.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+
+/// Covers the area with a checkerboard of two paints. The square at the
+/// top left is a light one.
+public class CheckerboardPainter extends AbstractPainter<Object> {
+
+    private Paint darkPaint = new Color(204, 204, 204);
+    private Paint lightPaint = Color.WHITE;
+    private double squareSize = 8;
+
+    public CheckerboardPainter() {
+    }
+
+    public CheckerboardPainter(Paint darkPaint, Paint lightPaint) {
+        this(darkPaint, lightPaint, 8);
+    }
+
+    public CheckerboardPainter(Paint darkPaint, Paint lightPaint, double squareSize) {
+        this.darkPaint = darkPaint;
+        this.lightPaint = lightPaint;
+        this.squareSize = squareSize;
+    }
+
+    /// Sets the side of a square, which must be positive.
+    public void setSquareSize(double squareSize) {
+        if (squareSize <= 0) {
+            throw new IllegalArgumentException("Length must be > 0");
+        }
+        double old = this.squareSize;
+        this.squareSize = squareSize;
+        setDirty(true);
+        firePropertyChange("squareSize", Double.valueOf(old), Double.valueOf(squareSize));
+    }
+
+    public double getSquareSize() {
+        return squareSize;
+    }
+
+    public void setDarkPaint(Paint color) {
+        Paint old = darkPaint;
+        darkPaint = color;
+        setDirty(true);
+        firePropertyChange("darkPaint", old, color);
+    }
+
+    public Paint getDarkPaint() {
+        return darkPaint;
+    }
+
+    public void setLightPaint(Paint color) {
+        Paint old = lightPaint;
+        lightPaint = color;
+        setDirty(true);
+        firePropertyChange("lightPaint", old, color);
+    }
+
+    public Paint getLightPaint() {
+        return lightPaint;
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        if (lightPaint != null) {
+            g.setPaint(lightPaint);
+            g.fillRect(0, 0, width, height);
+        }
+        double size = squareSize;
+        if (darkPaint == null || size < 0.5) {
+            return;
+        }
+        g.clipRect(0, 0, width, height);
+        g.setPaint(darkPaint);
+        int rows = (int) Math.ceil(height / size);
+        int columns = (int) Math.ceil(width / size);
+        for (int row = 0; row < rows; row++) {
+            for (int column = (row + 1) % 2; column < columns; column += 2) {
+                g.fill(new Rectangle2D.Double(column * size, row * size, size, size));
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/CompoundPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/CompoundPainter.java
new file mode 100644
index 00000000000..3519acc0d1d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/CompoundPainter.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+
+/// Runs several painters one after the other, the first at the bottom.
+///
+/// Each painter gets a copy of the graphics, so what one does to its
+/// state does not reach the next -- unless the clip is preserved, in
+/// which case the clip one painter leaves is the clip the following ones
+/// draw in. A transform set on the compound applies to all of them.
+///
+/// Nothing is cached; see [AbstractPainter].
+public class CompoundPainter<T> extends AbstractPainter<T> {
+
+    private static final Painter[] NONE = new Painter[0];
+
+    private Painter[] painters = NONE;
+    private AffineTransform transform;
+    private boolean clipPreserved;
+    private boolean checkForDirtyChildPainters = true;
+
+    public CompoundPainter() {
+    }
+
+    public CompoundPainter(Painter... painters) {
+        this.painters = copy(painters);
+    }
+
+    private static Painter[] copy(Painter[] in) {
+        if (in == null || in.length == 0) {
+            return NONE;
+        }
+        Painter[] out = new Painter[in.length];
+        System.arraycopy(in, 0, out, 0, in.length);
+        return out;
+    }
+
+    /// Replaces the painters; `null` or none leaves the compound empty.
+    public void setPainters(Painter... painters) {
+        Painter[] old = getPainters();
+        this.painters = copy(painters);
+        setDirty(true);
+        firePropertyChange("painters", old, getPainters());
+    }
+
+    /// A copy of the painters, in painting order.
+    public final Painter[] getPainters() {
+        return copy(painters);
+    }
+
+    public boolean isClipPreserved() {
+        return clipPreserved;
+    }
+
+    /// Whether the clip a painter leaves behind confines the painters
+    /// after it.
+    public void setClipPreserved(boolean shouldRestoreState) {
+        boolean old = clipPreserved;
+        clipPreserved = shouldRestoreState;
+        setDirty(true);
+        firePropertyChange("clipPreserved", Boolean.valueOf(old), Boolean.valueOf(shouldRestoreState));
+    }
+
+    /// A copy of the transform, or `null`.
+    public AffineTransform getTransform() {
+        return transform == null ? null : new AffineTransform(transform);
+    }
+
+    /// Sets a transform applied before the painters run; `null` is none.
+    public void setTransform(AffineTransform transform) {
+        AffineTransform old = getTransform();
+        this.transform = transform == null ? null : new AffineTransform(transform);
+        setDirty(true);
+        firePropertyChange("transform", old, getTransform());
+    }
+
+    /// Validates every painter that is an [AbstractPainter] and becomes
+    /// dirty when one of them is.
+    @Override
+    @SuppressWarnings("unchecked")
+    protected void validate(T object) {
+        boolean dirty = false;
+        for (int i = 0; i < painters.length; i++) {
+            Painter p = painters[i];
+            if (p instanceof AbstractPainter) {
+                AbstractPainter ap = (AbstractPainter) p;
+                ap.validate(object);
+                if (ap.isDirty()) {
+                    dirty = true;
+                }
+            }
+        }
+        if (dirty) {
+            setDirty(true);
+        }
+    }
+
+    public boolean isCheckingDirtyChildPainters() {
+        return checkForDirtyChildPainters;
+    }
+
+    /// Whether [#isDirty()] looks at the painters too.
+    public void setCheckingDirtyChildPainters(boolean b) {
+        boolean old = checkForDirtyChildPainters;
+        checkForDirtyChildPainters = b;
+        firePropertyChange("checkingDirtyChildPainters", Boolean.valueOf(old), Boolean.valueOf(b));
+    }
+
+    @Override
+    protected boolean isDirty() {
+        if (super.isDirty()) {
+            return true;
+        }
+        if (checkForDirtyChildPainters) {
+            for (int i = 0; i < painters.length; i++) {
+                Painter p = painters[i];
+                if (p instanceof AbstractPainter && ((AbstractPainter) p).isDirty()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    protected void setDirty(boolean d) {
+        super.setDirty(d);
+    }
+
+    /// Does nothing here and in the painters: there is no cache.
+    @Override
+    public void clearCache() {
+        if (painters == null) {
+            return;
+        }
+        for (int i = 0; i < painters.length; i++) {
+            Painter p = painters[i];
+            if (p instanceof AbstractPainter) {
+                ((AbstractPainter) p).clearCache();
+            }
+        }
+    }
+
+    /// Does nothing: there is no cache.
+    public void clearLocalCache() {
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected void doPaint(Graphics2D g, T component, int width, int height) {
+        for (int i = 0; i < painters.length; i++) {
+            Painter p = painters[i];
+            if (p == null) {
+                continue;
+            }
+            Graphics copy = g.create();
+            try {
+                if (copy instanceof Graphics2D) {
+                    Graphics2D temp = (Graphics2D) copy;
+                    p.paint(temp, component, width, height);
+                    if (clipPreserved) {
+                        g.setClip(temp.getClip());
+                    }
+                }
+            } finally {
+                copy.dispose();
+            }
+        }
+    }
+
+    @Override
+    protected void configureGraphics(Graphics2D g) {
+        super.configureGraphics(g);
+        if (transform != null) {
+            g.transform(transform);
+        }
+    }
+
+    @Override
+    protected boolean shouldUseCache() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/GlossPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/GlossPainter.java
new file mode 100644
index 00000000000..ebe63c52b9b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/GlossPainter.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.geom.Ellipse2D;
+
+/// Lays a soft highlight over the top or bottom half of the area: the
+/// part of a wide ellipse that falls inside it, in a translucent paint.
+/// It is meant to be the last painter of a compound.
+public class GlossPainter extends AbstractPainter<Object> {
+
+    /// The half of the area the highlight covers.
+    public enum GlossPosition {
+        TOP,
+        BOTTOM
+    }
+
+    private Paint paint;
+    private GlossPosition position;
+
+    /// A white highlight of a fifth opacity at the top.
+    public GlossPainter() {
+        this(new Color(1.0f, 1.0f, 1.0f, 0.2f), GlossPosition.TOP);
+    }
+
+    public GlossPainter(Paint paint) {
+        this(paint, GlossPosition.TOP);
+    }
+
+    public GlossPainter(GlossPosition position) {
+        this(new Color(1.0f, 1.0f, 1.0f, 0.2f), position);
+    }
+
+    public GlossPainter(Paint paint, GlossPosition position) {
+        this.paint = paint;
+        this.position = position == null ? GlossPosition.TOP : position;
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        if (paint == null) {
+            return;
+        }
+        // An ellipse a third wider than the area on either side whose
+        // lower (or upper) edge crosses the middle of the area.
+        double w = width * 5.0 / 3.0;
+        double h = height * 1.2;
+        double x = -width / 3.0;
+        double y = position == GlossPosition.TOP ? height / 2.0 - h : height / 2.0;
+        g.clipRect(0, 0, width, height);
+        g.setPaint(paint);
+        g.fill(new Ellipse2D.Double(x, y, w, h));
+    }
+
+    public Paint getPaint() {
+        return paint;
+    }
+
+    public void setPaint(Paint paint) {
+        Paint old = this.paint;
+        this.paint = paint;
+        setDirty(true);
+        firePropertyChange("paint", old, paint);
+    }
+
+    public GlossPosition getPosition() {
+        return position;
+    }
+
+    /// Sets the half that is highlighted; `null` is the top.
+    public void setPosition(GlossPosition position) {
+        GlossPosition old = this.position;
+        this.position = position == null ? GlossPosition.TOP : position;
+        setDirty(true);
+        firePropertyChange("position", old, this.position);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/ImagePainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/ImagePainter.java
new file mode 100644
index 00000000000..af24675208f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/ImagePainter.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+
+/// Draws an image: at its own size placed by the layout properties,
+/// scaled by a factor, scaled to fit the area, or tiled along either
+/// axis.
+///
+/// The fill paint, if there is one, is painted behind the image over the
+/// rectangle the image takes; the border paint outlines that rectangle.
+/// A painter made by the constructors has no fill and no border.
+public class ImagePainter extends AbstractAreaPainter<Object> {
+
+    /// How an image that is scaled to fit meets the area.
+    public enum ScaleType {
+        /// The largest size that lies inside the area, in proportion.
+        InsideFit,
+        /// The smallest size that covers the area, in proportion.
+        OutsideFit,
+        /// The size of the area, whatever that does to the proportions.
+        Distort
+    }
+
+    private BufferedImage img;
+    private boolean horizontalRepeat;
+    private boolean verticalRepeat;
+    private boolean scaleToFit;
+    private ScaleType scaleType = ScaleType.InsideFit;
+    private double imageScale = 1.0;
+
+    public ImagePainter() {
+        this((BufferedImage) null);
+    }
+
+    public ImagePainter(BufferedImage image) {
+        this(image, HorizontalAlignment.CENTER, VerticalAlignment.CENTER);
+    }
+
+    public ImagePainter(BufferedImage image, HorizontalAlignment horizontal, VerticalAlignment vertical) {
+        super(null);
+        img = image;
+        setHorizontalAlignment(horizontal);
+        setVerticalAlignment(vertical);
+        setDirty(false);
+    }
+
+    public void setImage(BufferedImage image) {
+        if (image != img) {
+            BufferedImage old = img;
+            img = image;
+            setDirty(true);
+            firePropertyChange("image", old, image);
+        }
+    }
+
+    public BufferedImage getImage() {
+        return img;
+    }
+
+    private Rectangle imageBounds(int width, int height) {
+        if (img == null) {
+            return null;
+        }
+        int iw = img.getWidth();
+        int ih = img.getHeight();
+        if (iw <= 0 || ih <= 0) {
+            return null;
+        }
+        if (scaleToFit) {
+            if (scaleType == ScaleType.Distort) {
+                return calculateLayout(width, height, width, height);
+            }
+            double sx = width / (double) iw;
+            double sy = height / (double) ih;
+            double s = scaleType == ScaleType.OutsideFit ? Math.max(sx, sy) : Math.min(sx, sy);
+            return calculateLayout(Math.max(1, (int) Math.round(iw * s)), Math.max(1, (int) Math.round(ih * s)),
+                    width, height);
+        }
+        return calculateLayout(Math.max(1, (int) Math.round(iw * imageScale)),
+                Math.max(1, (int) Math.round(ih * imageScale)), width, height);
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        Rectangle r = imageBounds(width, height);
+        if (r == null || r.width <= 0 || r.height <= 0) {
+            return;
+        }
+        Rectangle area = new Rectangle(r);
+        if (horizontalRepeat) {
+            area.x = 0;
+            area.width = width;
+        }
+        if (verticalRepeat) {
+            area.y = 0;
+            area.height = height;
+        }
+        if (cn1Fills()) {
+            g.setPaint(cn1Fitted(getFillPaint(), width, height));
+            g.fill(area);
+        }
+        if (horizontalRepeat || verticalRepeat) {
+            Graphics2D tiles = (Graphics2D) g.create();
+            try {
+                tiles.clipRect(0, 0, width, height);
+                // The tiles keep the phase of the placed image: the first
+                // one starts at or before the edge.
+                int startX = r.x;
+                if (horizontalRepeat) {
+                    startX = r.x % r.width;
+                    if (startX > 0) {
+                        startX -= r.width;
+                    }
+                }
+                int startY = r.y;
+                if (verticalRepeat) {
+                    startY = r.y % r.height;
+                    if (startY > 0) {
+                        startY -= r.height;
+                    }
+                }
+                int endX = horizontalRepeat ? width : startX + 1;
+                int endY = verticalRepeat ? height : startY + 1;
+                for (int y = startY; y < endY; y += r.height) {
+                    for (int x = startX; x < endX; x += r.width) {
+                        tiles.drawImage(img, x, y, r.width, r.height, null);
+                    }
+                }
+            } finally {
+                tiles.dispose();
+            }
+        } else {
+            g.drawImage(img, r.x, r.y, r.width, r.height, null);
+        }
+        if (cn1Outlines()) {
+            Graphics2D outline = (Graphics2D) g.create();
+            try {
+                outline.setPaint(cn1Fitted(getBorderPaint(), width, height));
+                outline.setStroke(new com.codename1.desktopcompat.java.awt.BasicStroke(getBorderWidth()));
+                outline.draw(area);
+            } finally {
+                outline.dispose();
+            }
+        }
+    }
+
+    public boolean isScaleToFit() {
+        return scaleToFit;
+    }
+
+    /// Whether the image is scaled to the painted area, as the scale type
+    /// says.
+    public void setScaleToFit(boolean scaleToFit) {
+        boolean old = this.scaleToFit;
+        this.scaleToFit = scaleToFit;
+        setDirty(true);
+        firePropertyChange("scaleToFit", Boolean.valueOf(old), Boolean.valueOf(scaleToFit));
+    }
+
+    public ScaleType getScaleType() {
+        return scaleType;
+    }
+
+    public void setScaleType(ScaleType scaleType) {
+        ScaleType old = this.scaleType;
+        this.scaleType = scaleType == null ? ScaleType.InsideFit : scaleType;
+        setDirty(true);
+        firePropertyChange("scaleType", old, this.scaleType);
+    }
+
+    public double getImageScale() {
+        return imageScale;
+    }
+
+    /// The factor the image is drawn at when it is not scaled to fit.
+    public void setImageScale(double imageScale) {
+        double old = this.imageScale;
+        this.imageScale = imageScale;
+        setDirty(true);
+        firePropertyChange("imageScale", Double.valueOf(old), Double.valueOf(imageScale));
+    }
+
+    public boolean isHorizontalRepeat() {
+        return horizontalRepeat;
+    }
+
+    public void setHorizontalRepeat(boolean horizontalRepeat) {
+        boolean old = this.horizontalRepeat;
+        this.horizontalRepeat = horizontalRepeat;
+        setDirty(true);
+        firePropertyChange("horizontalRepeat", Boolean.valueOf(old), Boolean.valueOf(horizontalRepeat));
+    }
+
+    public boolean isVerticalRepeat() {
+        return verticalRepeat;
+    }
+
+    public void setVerticalRepeat(boolean verticalRepeat) {
+        boolean old = this.verticalRepeat;
+        this.verticalRepeat = verticalRepeat;
+        setDirty(true);
+        firePropertyChange("verticalRepeat", Boolean.valueOf(old), Boolean.valueOf(verticalRepeat));
+    }
+
+    /// The rectangle the image takes, or `null` without an image.
+    @Override
+    protected Shape provideShape(Graphics2D g, Object comp, int width, int height) {
+        return imageBounds(width, height);
+    }
+
+    @Override
+    public String toString() {
+        return "ImagePainter[image=" + img + "]";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/MattePainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/MattePainter.java
new file mode 100644
index 00000000000..354975449a6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/MattePainter.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+/// Fills the whole painted area with one paint: a color, or a gradient
+/// that can be stretched over the area.
+public class MattePainter extends AbstractAreaPainter<Object> {
+
+    public MattePainter() {
+    }
+
+    public MattePainter(Paint paint) {
+        super(paint);
+    }
+
+    public MattePainter(Paint paint, boolean paintStretched) {
+        super(paint);
+        setPaintStretched(paintStretched);
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        Paint p = getFillPaint();
+        if (p == null) {
+            return;
+        }
+        g.setPaint(cn1Fitted(p, width, height));
+        g.fillRect(0, 0, width, height);
+    }
+
+    @Override
+    protected Shape provideShape(Graphics2D g, Object comp, int width, int height) {
+        return new Rectangle(0, 0, width, height);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/Painter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/Painter.java
new file mode 100644
index 00000000000..f00611ed101
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/Painter.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+
+/// Draws into a graphics on behalf of an object, usually a component.
+///
+/// The painter may change the state of `g` freely; a caller that needs it
+/// afterwards hands over a copy. `object` may be `null`.
+public interface Painter<T> {
+
+    /// Paints into the rectangle `(0, 0, width, height)` of `g`.
+    void paint(Graphics2D g, T object, int width, int height);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/PinstripePainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/PinstripePainter.java
new file mode 100644
index 00000000000..baf69c627f1
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/PinstripePainter.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.BasicStroke;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.geom.Line2D;
+
+/// Covers the area with parallel stripes at an angle.
+///
+/// The angle is in degrees and turns clockwise from vertical stripes: 0
+/// draws vertical lines, 90 horizontal ones and 45 lines that rise to the
+/// right.
+public class PinstripePainter extends AbstractPainter<Object> {
+
+    private double angle = 45;
+    private double spacing = 8;
+    private double stripeWidth = 1;
+    private Paint paint;
+
+    public PinstripePainter() {
+    }
+
+    public PinstripePainter(Paint paint) {
+        this(paint, 45);
+    }
+
+    public PinstripePainter(double angle) {
+        this.angle = angle;
+    }
+
+    public PinstripePainter(Paint paint, double angle) {
+        this.paint = paint;
+        this.angle = angle;
+    }
+
+    public PinstripePainter(Paint paint, double angle, double stripeWidth, double spacing) {
+        this.paint = paint;
+        this.angle = angle;
+        this.stripeWidth = stripeWidth;
+        this.spacing = spacing;
+    }
+
+    public Paint getPaint() {
+        return paint;
+    }
+
+    /// Sets the paint of the stripes; with `null` they are drawn in the
+    /// color the graphics has, or the foreground of the component painted
+    /// for.
+    public void setPaint(Paint p) {
+        Paint old = paint;
+        paint = p;
+        setDirty(true);
+        firePropertyChange("paint", old, p);
+    }
+
+    public double getAngle() {
+        return angle;
+    }
+
+    /// Sets the angle in degrees; it is brought into 0 to 360.
+    public void setAngle(double angle) {
+        double a = angle;
+        if (a > 360) {
+            a = a % 360;
+        }
+        if (a < 0) {
+            a = 360 - ((a * -1) % 360);
+        }
+        double old = this.angle;
+        this.angle = a;
+        setDirty(true);
+        firePropertyChange("angle", Double.valueOf(old), Double.valueOf(a));
+    }
+
+    public double getStripeWidth() {
+        return stripeWidth;
+    }
+
+    public void setStripeWidth(double stripeWidth) {
+        double old = this.stripeWidth;
+        this.stripeWidth = stripeWidth;
+        setDirty(true);
+        firePropertyChange("stripeWidth", Double.valueOf(old), Double.valueOf(stripeWidth));
+    }
+
+    public double getSpacing() {
+        return spacing;
+    }
+
+    /// The distance between two stripes.
+    public void setSpacing(double spacing) {
+        double old = this.spacing;
+        this.spacing = spacing;
+        setDirty(true);
+        firePropertyChange("spacing", Double.valueOf(old), Double.valueOf(spacing));
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        double step = stripeWidth + spacing;
+        if (stripeWidth <= 0 || step < 0.5) {
+            return;
+        }
+        Paint p = paint;
+        if (p == null && component instanceof com.codename1.desktopcompat.java.awt.Component) {
+            Color fg = ((com.codename1.desktopcompat.java.awt.Component) component).getForeground();
+            p = fg;
+        }
+        if (p != null) {
+            g.setPaint(p);
+        }
+        g.clipRect(0, 0, width, height);
+        g.setStroke(new BasicStroke((float) stripeWidth));
+        // Vertical lines over a square that covers the area at any angle,
+        // turned about the center of the area.
+        double reach = Math.sqrt((double) width * width + (double) height * height) / 2 + step;
+        double cx = width / 2.0;
+        double cy = height / 2.0;
+        g.rotate(Math.toRadians(angle), cx, cy);
+        int count = (int) Math.ceil(reach / step);
+        for (int i = -count; i <= count; i++) {
+            double x = cx + i * step;
+            g.draw(new Line2D.Double(x, cy - reach, x, cy + reach));
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/RectanglePainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/RectanglePainter.java
new file mode 100644
index 00000000000..e8287b597bc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/RectanglePainter.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.geom.RectangularShape;
+import com.codename1.desktopcompat.java.awt.geom.RoundRectangle2D;
+
+/// Paints a rectangle, with square or rounded corners, filled, outlined
+/// or both.
+///
+/// A painter made without a size fills the painted area inside its
+/// insets. One made with a width and height keeps that size and is placed
+/// by its alignments. The outline is drawn inside the rectangle's bounds:
+/// the shape is drawn half a border width in from them.
+public class RectanglePainter extends AbstractAreaPainter<Object> {
+
+    private boolean rounded;
+    private int roundWidth = 20;
+    private int roundHeight = 20;
+    private int width = -1;
+    private int height = -1;
+
+    public RectanglePainter() {
+        this(0, 0, 0, 0);
+    }
+
+    public RectanglePainter(int top, int left, int bottom, int right) {
+        this(top, left, bottom, right, 0, 0);
+    }
+
+    public RectanglePainter(int top, int left, int bottom, int right, int roundWidth, int roundHeight) {
+        this(top, left, bottom, right, roundWidth, roundHeight, roundWidth != 0 || roundHeight != 0, Color.RED, 1f,
+                Color.BLACK);
+    }
+
+    public RectanglePainter(int top, int left, int bottom, int right, int roundWidth, int roundHeight,
+            boolean rounded, Paint fillPaint, float strokeWidth, Paint borderPaint) {
+        this(new Insets(top, left, bottom, right), -1, -1, roundWidth, roundHeight, rounded, fillPaint, strokeWidth,
+                borderPaint);
+    }
+
+    public RectanglePainter(Color fillPaint, Color borderPaint) {
+        this(fillPaint, borderPaint, 1f, null);
+    }
+
+    public RectanglePainter(Paint fillPaint, Paint borderPaint, float borderWidth, Style style) {
+        this(new Insets(0, 0, 0, 0), -1, -1, 0, 0, false, fillPaint, borderWidth, borderPaint);
+        setStyle(style);
+        setDirty(false);
+    }
+
+    public RectanglePainter(int width, int height, int cornerRadius, Paint fillPaint) {
+        this(new Insets(0, 0, 0, 0), width, height, cornerRadius, cornerRadius, true, fillPaint, 1f, Color.BLACK);
+    }
+
+    public RectanglePainter(Insets insets, int width, int height, int roundWidth, int roundHeight, boolean rounded,
+            Paint fillPaint, float strokeWidth, Paint borderPaint) {
+        this.width = width;
+        this.height = height;
+        setFillHorizontal(width < 0);
+        setFillVertical(height < 0);
+        setInsets(insets);
+        this.roundWidth = roundWidth;
+        this.roundHeight = roundHeight;
+        this.rounded = rounded;
+        setFillPaint(fillPaint);
+        setBorderWidth(strokeWidth);
+        setBorderPaint(borderPaint);
+        setDirty(false);
+    }
+
+    public boolean isRounded() {
+        return rounded;
+    }
+
+    public void setRounded(boolean rounded) {
+        boolean old = this.rounded;
+        this.rounded = rounded;
+        setDirty(true);
+        firePropertyChange("rounded", Boolean.valueOf(old), Boolean.valueOf(rounded));
+    }
+
+    public int getRoundWidth() {
+        return roundWidth;
+    }
+
+    public void setRoundWidth(int roundWidth) {
+        int old = this.roundWidth;
+        this.roundWidth = roundWidth;
+        setDirty(true);
+        firePropertyChange("roundWidth", Integer.valueOf(old), Integer.valueOf(roundWidth));
+    }
+
+    public int getRoundHeight() {
+        return roundHeight;
+    }
+
+    public void setRoundHeight(int roundHeight) {
+        int old = this.roundHeight;
+        this.roundHeight = roundHeight;
+        setDirty(true);
+        firePropertyChange("roundHeight", Integer.valueOf(old), Integer.valueOf(roundHeight));
+    }
+
+    /// The rectangle painted in an area of the given size.
+    protected RectangularShape calculateShape(int width, int height) {
+        Rectangle bounds = calculateLayout(Math.max(0, this.width), Math.max(0, this.height), width, height);
+        double inset = cn1Outlines() ? getBorderWidth() / 2.0 : 0;
+        double x = bounds.x + inset;
+        double y = bounds.y + inset;
+        double w = Math.max(0, bounds.width - 2 * inset);
+        double h = Math.max(0, bounds.height - 2 * inset);
+        if (rounded) {
+            return new RoundRectangle2D.Double(x, y, w, h, roundWidth, roundHeight);
+        }
+        return new Rectangle2D.Double(x, y, w, h);
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        Shape shape = provideShape(g, component, width, height);
+        if (getStyle() == Style.NONE) {
+            return;
+        }
+        cn1PaintShape(g, shape, width, height);
+    }
+
+    @Override
+    protected Shape provideShape(Graphics2D g, Object comp, int width, int height) {
+        return calculateShape(width, height);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/ShapePainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/ShapePainter.java
new file mode 100644
index 00000000000..2472e302ce0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/ShapePainter.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.Ellipse2D;
+import com.codename1.desktopcompat.java.awt.geom.Path2D;
+
+/// Paints any shape, filled, outlined or both, placed by the layout
+/// properties: the shape's bounds are what is aligned.
+///
+/// The shape is not scaled when an axis is filled; filling only moves it
+/// to the inset edge.
+public class ShapePainter extends AbstractAreaPainter<Object> {
+
+    private Shape shape;
+
+    /// A red circle of 100 pixels with a black outline 3 wide.
+    public ShapePainter() {
+        this(new Ellipse2D.Double(0, 0, 100, 100), Color.RED);
+    }
+
+    public ShapePainter(Shape shape) {
+        this(shape, Color.RED);
+    }
+
+    public ShapePainter(Shape shape, Paint paint) {
+        this(shape, paint, Style.BOTH);
+    }
+
+    public ShapePainter(Shape shape, Paint paint, Style style) {
+        super(paint);
+        this.shape = shape;
+        setBorderWidth(3);
+        setBorderPaint(Color.BLACK);
+        setStyle(style);
+        setDirty(false);
+    }
+
+    public void setShape(Shape s) {
+        Shape old = shape;
+        shape = s;
+        setDirty(true);
+        firePropertyChange("shape", old, s);
+    }
+
+    public Shape getShape() {
+        return shape;
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int w, int h) {
+        if (getStyle() == Style.NONE) {
+            return;
+        }
+        cn1PaintShape(g, provideShape(g, component, w, h), w, h);
+    }
+
+    /// The shape, moved to where the layout properties place it.
+    @Override
+    protected Shape provideShape(Graphics2D g, Object comp, int width, int height) {
+        if (shape == null) {
+            return null;
+        }
+        Rectangle bounds = shape.getBounds();
+        Rectangle at = calculateLayout(bounds.width, bounds.height, width, height);
+        return new Path2D.Double(shape, AffineTransform.getTranslateInstance(at.x - bounds.x, at.y - bounds.y));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/TextPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/TextPainter.java
new file mode 100644
index 00000000000..3dc5761a630
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/TextPainter.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+
+/// Draws one line of text, placed by the layout properties.
+///
+/// A painter without a text draws the text of the label, button or text
+/// component it paints for; without a font it uses that component's; and
+/// without a fill paint that component's foreground.
+///
+/// ## What differs from SwingX
+///
+///  - The text is drawn as a string, not as an outline: the border paint
+///    and width are ignored, and [#provideShape] answers the rectangle
+///    the text takes, not its glyphs.
+///  - A gradient colors the text only where the port can fill text with
+///    one; elsewhere its first color is used.
+public class TextPainter extends AbstractAreaPainter<Object> {
+
+    private String text = "";
+    private Font font;
+
+    public TextPainter() {
+        this("");
+    }
+
+    public TextPainter(String text) {
+        this(text, null, null);
+    }
+
+    public TextPainter(String text, Font font) {
+        this(text, font, null);
+    }
+
+    public TextPainter(String text, Paint paint) {
+        this(text, null, paint);
+    }
+
+    public TextPainter(String text, Font font, Paint paint) {
+        super(paint);
+        this.text = text;
+        this.font = font;
+    }
+
+    public void setFont(Font f) {
+        Font old = font;
+        font = f;
+        setDirty(true);
+        firePropertyChange("font", old, f);
+    }
+
+    public Font getFont() {
+        return font;
+    }
+
+    public void setText(String text) {
+        String old = this.text;
+        this.text = text == null ? "" : text;
+        setDirty(true);
+        firePropertyChange("text", old, this.text);
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    private Font fontFor(Graphics2D g, Object component) {
+        Font f = font;
+        if (f == null && component instanceof Component) {
+            f = ((Component) component).getFont();
+        }
+        if (f == null) {
+            f = g.getFont();
+        }
+        return f;
+    }
+
+    private String textFor(Object component) {
+        String t = text;
+        if (t == null || t.length() == 0) {
+            if (component instanceof JTextComponent) {
+                t = ((JTextComponent) component).getText();
+            } else if (component instanceof JLabel) {
+                t = ((JLabel) component).getText();
+            } else if (component instanceof AbstractButton) {
+                t = ((AbstractButton) component).getText();
+            }
+        }
+        return t;
+    }
+
+    private Rectangle bounds(Graphics2D g, Object component, int width, int height, String t, Font f) {
+        FontMetrics fm = f != null ? g.getFontMetrics(f) : g.getFontMetrics();
+        return calculateLayout(fm.stringWidth(t), fm.getHeight(), width, height);
+    }
+
+    @Override
+    protected void doPaint(Graphics2D g, Object component, int width, int height) {
+        String t = textFor(component);
+        if (t == null || t.length() == 0) {
+            return;
+        }
+        Font f = fontFor(g, component);
+        if (f != null) {
+            g.setFont(f);
+        }
+        Paint paint = getFillPaint();
+        if (paint == null && component instanceof Component) {
+            paint = ((Component) component).getForeground();
+        }
+        if (paint == null) {
+            paint = Color.BLACK;
+        }
+        Rectangle r = bounds(g, component, width, height, t, f);
+        g.setPaint(cn1Fitted(paint, width, height));
+        FontMetrics fm = g.getFontMetrics();
+        g.drawString(t, r.x, r.y + fm.getAscent());
+    }
+
+    /// The rectangle the text takes.
+    @Override
+    protected Shape provideShape(Graphics2D g, Object comp, int width, int height) {
+        String t = textFor(comp);
+        if (t == null) {
+            t = "";
+        }
+        return bounds(g, comp, width, height, t, fontFor(g, comp));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/package-info.java
new file mode 100644
index 00000000000..76bcbc3d947
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Painters: objects that draw into a graphics for a component, used as
+/// backgrounds of the SwingX panels, labels and buttons and by the painter
+/// highlighter.
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/PromptSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/PromptSupport.java
new file mode 100644
index 00000000000..11fbcf6d6e7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/PromptSupport.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.prompt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXFormattedTextField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTextArea;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTextField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import com.codename1.desktopcompat.rt.Fonts;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.ui.Display;
+import com.codename1.ui.Label;
+import com.codename1.ui.TextArea;
+
+/// Gives any text component a prompt: text shown while the component is
+/// empty.
+///
+/// The prompt and its looks are kept as client properties of the
+/// component, under the keys below, and shown by the hint of the Codename
+/// One text field behind it.
+///
+/// ## What differs from SwingX
+///
+///  - The hint is drawn by Codename One, which shows it whenever the field
+///    is empty: the focus behavior is recorded and reported but
+///    [FocusBehavior#HIDE_PROMPT] and [FocusBehavior#HIGHLIGHT_PROMPT]
+///    look like [FocusBehavior#SHOW_PROMPT].
+///  - The prompt background and background painter are recorded and
+///    reported, and not drawn.
+///  - A prompt set before the display exists reaches the field only if the
+///    component is one of the SwingX text components, which push it when
+///    their widget is made; on a plain text component set the prompt once
+///    the application has started.
+public final class PromptSupport {
+
+    public static final String PROMPT = "promptText";
+    public static final String FOREGROUND = "promptForeground";
+    public static final String BACKGROUND = "promptBackground";
+    public static final String BACKGROUND_PAINTER = "promptBackgroundPainter";
+    public static final String FOCUS_BEHAVIOR = "focusBehavior";
+    public static final String FONT_STYLE = "promptFontStyle";
+
+    /// What the prompt does while the empty component has the focus.
+    public enum FocusBehavior {
+        /// The prompt stays.
+        SHOW_PROMPT,
+        /// The prompt stays, drawn as selected text.
+        HIGHLIGHT_PROMPT,
+        /// The prompt goes.
+        HIDE_PROMPT
+    }
+
+    private PromptSupport() {
+    }
+
+    /// Sets the prompt and its colors in one call.
+    public static void init(String promptText, Color promptForeground, Color promptBackground,
+            JTextComponent textComponent) {
+        if (promptText != null && promptText.length() > 0) {
+            setPrompt(promptText, textComponent);
+        }
+        if (promptForeground != null) {
+            setForeground(promptForeground, textComponent);
+        }
+        if (promptBackground != null) {
+            setBackground(promptBackground, textComponent);
+        }
+    }
+
+    /// The focus behavior set on the component, [FocusBehavior#HIDE_PROMPT]
+    /// when none was.
+    public static FocusBehavior getFocusBehavior(JTextComponent textComponent) {
+        Object v = textComponent.getClientProperty(FOCUS_BEHAVIOR);
+        return v instanceof FocusBehavior ? (FocusBehavior) v : FocusBehavior.HIDE_PROMPT;
+    }
+
+    public static void setFocusBehavior(FocusBehavior focusBehavior, JTextComponent textComponent) {
+        textComponent.putClientProperty(FOCUS_BEHAVIOR, focusBehavior);
+    }
+
+    public static String getPrompt(JTextComponent textComponent) {
+        Object v = textComponent.getClientProperty(PROMPT);
+        return v instanceof String ? (String) v : null;
+    }
+
+    /// Sets the text shown while the component is empty; `null` removes
+    /// it.
+    public static void setPrompt(String promptText, JTextComponent textComponent) {
+        textComponent.putClientProperty(PROMPT, promptText);
+        cn1Push(textComponent);
+    }
+
+    /// The prompt's color: the one set, else the component's disabled
+    /// text color, else `null` for the theme's hint color.
+    public static Color getForeground(JTextComponent textComponent) {
+        Object v = textComponent.getClientProperty(FOREGROUND);
+        if (v instanceof Color) {
+            return (Color) v;
+        }
+        return textComponent.getDisabledTextColor();
+    }
+
+    public static void setForeground(Color promptTextColor, JTextComponent textComponent) {
+        textComponent.putClientProperty(FOREGROUND, promptTextColor);
+        cn1Push(textComponent);
+    }
+
+    /// The prompt background set, else the component's background.
+    public static Color getBackground(JTextComponent textComponent) {
+        Object v = textComponent.getClientProperty(BACKGROUND);
+        if (v instanceof Color) {
+            return (Color) v;
+        }
+        return textComponent.getBackground();
+    }
+
+    /// Recorded only.
+    public static void setBackground(Color background, JTextComponent textComponent) {
+        textComponent.putClientProperty(BACKGROUND, background);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T extends JTextComponent> Painter<? super T> getBackgroundPainter(T textComponent) {
+        Object v = textComponent.getClientProperty(BACKGROUND_PAINTER);
+        return v instanceof Painter ? (Painter<? super T>) v : null;
+    }
+
+    /// Recorded only.
+    public static <T extends JTextComponent> void setBackgroundPainter(Painter<? super T> background,
+            T textComponent) {
+        textComponent.putClientProperty(BACKGROUND_PAINTER, background);
+    }
+
+    /// Sets the style of the prompt's font, a combination of the `Font`
+    /// style constants; `null` is the component's own style.
+    public static void setFontStyle(Integer fontStyle, JTextComponent textComponent) {
+        textComponent.putClientProperty(FONT_STYLE, fontStyle);
+        cn1Push(textComponent);
+    }
+
+    public static Integer getFontStyle(JTextComponent textComponent) {
+        Object v = textComponent.getClientProperty(FONT_STYLE);
+        return v instanceof Integer ? (Integer) v : null;
+    }
+
+    /// Writes the prompt, its color and its font style to the hint of the
+    /// Codename One text field behind the component. Does nothing before
+    /// the display exists.
+    public static void cn1Push(JTextComponent textComponent) {
+        if (!Display.isInitialized()) {
+            return;
+        }
+        com.codename1.ui.Component p = textComponent.cn1PeerOrNull();
+        if (p == null) {
+            if (textComponent instanceof JXTextField || textComponent instanceof JXTextArea
+                    || textComponent instanceof JXFormattedTextField) {
+                // These push again when their widget is made.
+                return;
+            }
+            p = textComponent.cn1Peer();
+        }
+        if (!(p instanceof TextArea)) {
+            return;
+        }
+        TextArea t = (TextArea) p;
+        String prompt = getPrompt(textComponent);
+        if (prompt == null && t.getHintLabel() == null) {
+            return;
+        }
+        t.setHint(prompt == null ? "" : prompt);
+        Label hint = t.getHintLabel();
+        if (hint == null) {
+            return;
+        }
+        Object fg = textComponent.getClientProperty(FOREGROUND);
+        if (fg instanceof Color) {
+            hint.getAllStyles().setFgColor(((Color) fg).getRGB() & 0xffffff);
+        }
+        Integer style = getFontStyle(textComponent);
+        Font f = textComponent.getFont();
+        if (style != null) {
+            Font styled = f.deriveFont(style.intValue());
+            hint.getAllStyles().setFont(Fonts.nativeFont(styled, styled.getSize2D() * Units.scale()));
+        }
+        textComponent.repaint();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/package-info.java
new file mode 100644
index 00000000000..d706b1e7187
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Prompts: the text a text component shows while it is empty, drawn by
+/// the hint of the Codename One text field behind it.
+package com.codename1.desktopcompat.org.jdesktop.swingx.prompt;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/AbstractRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/AbstractRenderer.java
new file mode 100644
index 00000000000..c798aa02cac
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/AbstractRenderer.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.org.jdesktop.swingx.rollover.RolloverRenderer;
+
+/// What the table, list and tree renderers share: the component provider
+/// that does the work.
+public abstract class AbstractRenderer implements RolloverRenderer, StringValue {
+
+    protected ComponentProvider<?> componentController;
+
+    /// Makes a renderer around a provider, or around
+    /// [#createDefaultComponentProvider()] when it is `null`.
+    public AbstractRenderer(ComponentProvider<?> provider) {
+        componentController = provider != null ? provider : createDefaultComponentProvider();
+    }
+
+    public ComponentProvider<?> getComponentProvider() {
+        return componentController;
+    }
+
+    protected abstract ComponentProvider<?> createDefaultComponentProvider();
+
+    /// The text the renderer shows for a value.
+    @Override
+    public String getString(Object value) {
+        return componentController.getString(value);
+    }
+
+    @Override
+    public void doClick() {
+        if (isEnabled() && componentController instanceof RolloverRenderer) {
+            ((RolloverRenderer) componentController).doClick();
+        }
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return componentController instanceof RolloverRenderer
+                && ((RolloverRenderer) componentController).isEnabled();
+    }
+
+    /// Does nothing: there are no UI delegates to refresh.
+    public void updateUI() {
+    }
+
+    /// Fixes the background of unselected cells.
+    public void setBackground(Color background) {
+        componentController.getDefaultVisuals().setBackground(background);
+    }
+
+    /// Fixes the text color of unselected cells.
+    public void setForeground(Color foreground) {
+        componentController.getDefaultVisuals().setForeground(foreground);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/BooleanValue.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/BooleanValue.java
new file mode 100644
index 00000000000..1ca3fe321bc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/BooleanValue.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+/// Turns a cell value into the state of a check box.
+public interface BooleanValue {
+
+    boolean getBoolean(Object value);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/CellContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/CellContext.java
new file mode 100644
index 00000000000..b2f053a9cb5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/CellContext.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+import com.codename1.desktopcompat.javax.swing.border.LineBorder;
+import com.codename1.desktopcompat.rt.CellTheme;
+
+/// The cell a renderer is asked to draw: its component, value, position
+/// and state, and the colors, font and border the cell's kind of
+/// component wants for it.
+///
+/// Colors come from the component and, through it, from the Codename One
+/// theme; there is no look and feel table to read them from. The drop
+/// target colors are `null` because the layer has no drag and drop.
+public class CellContext {
+
+    protected static Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);
+
+    protected transient JComponent component;
+    protected transient Object value;
+    protected transient int row;
+    protected transient int column;
+    protected transient boolean selected;
+    protected transient boolean focused;
+    protected transient boolean expanded;
+    protected transient boolean leaf;
+    protected transient boolean dropOn;
+
+    private Border cn1FocusBorder;
+    private Color cn1FocusColor;
+
+    public CellContext() {
+    }
+
+    protected void installState(Object value, int row, int column, boolean selected, boolean focused,
+            boolean expanded, boolean leaf) {
+        this.value = value;
+        this.row = row;
+        this.column = column;
+        this.selected = selected;
+        this.focused = focused;
+        this.expanded = expanded;
+        this.leaf = leaf;
+    }
+
+    /// Puts another value in the context and answers the one it had.
+    public Object replaceValue(Object value) {
+        Object old = this.value;
+        this.value = value;
+        return old;
+    }
+
+    public JComponent getComponent() {
+        return component;
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public int getRow() {
+        return row;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+
+    public boolean isSelected() {
+        return selected;
+    }
+
+    public boolean isFocused() {
+        return focused;
+    }
+
+    public boolean isExpanded() {
+        return expanded;
+    }
+
+    public boolean isLeaf() {
+        return leaf;
+    }
+
+    public boolean isEditable() {
+        return false;
+    }
+
+    /// The icon the cell has by default; only a tree cell has one.
+    public Icon getIcon() {
+        return null;
+    }
+
+    protected boolean isDropOn() {
+        return dropOn;
+    }
+
+    protected Color getForeground() {
+        return component != null ? component.getForeground() : null;
+    }
+
+    protected Color getBackground() {
+        return component != null ? component.getBackground() : null;
+    }
+
+    protected Color getSelectionBackground() {
+        return null;
+    }
+
+    protected Color getSelectionForeground() {
+        return null;
+    }
+
+    /// A line in a color between the cell's text and background colors.
+    protected Border getFocusBorder() {
+        Color fg = selected ? getSelectionForeground() : getForeground();
+        Color bg = selected ? getSelectionBackground() : getBackground();
+        Color line = fg != null && bg != null ? CellTheme.mix(bg, fg, 0.6f) : Color.GRAY;
+        if (cn1FocusBorder == null || !line.equals(cn1FocusColor)) {
+            cn1FocusColor = line;
+            cn1FocusBorder = new LineBorder(line, 1);
+        }
+        return cn1FocusBorder;
+    }
+
+    protected Border getBorder() {
+        if (isFocused()) {
+            return getFocusBorder();
+        }
+        return noFocusBorder;
+    }
+
+    protected Color getFocusForeground() {
+        return null;
+    }
+
+    protected Color getFocusBackground() {
+        return null;
+    }
+
+    protected Color getDropCellForeground() {
+        return null;
+    }
+
+    protected Color getDropCellBackground() {
+        return null;
+    }
+
+    protected String getUIKey(String key) {
+        return getUIPrefix() + key;
+    }
+
+    protected String getUIPrefix() {
+        return "";
+    }
+
+    protected Font getFont() {
+        return component != null ? component.getFont() : null;
+    }
+
+    public String getCellRendererName() {
+        return getUIPrefix() + "cellRenderer";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/CheckBoxProvider.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/CheckBoxProvider.java
new file mode 100644
index 00000000000..12d51871bca
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/CheckBoxProvider.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// Shows a cell as a check box, checked for `Boolean.TRUE` or for what the
+/// converter says when it is a [BooleanValue]. The text is empty unless a
+/// converter is given.
+public class CheckBoxProvider extends ComponentProvider<AbstractButton> {
+
+    private boolean borderPainted;
+
+    public CheckBoxProvider() {
+        this(null);
+    }
+
+    public CheckBoxProvider(StringValue stringValue) {
+        this(stringValue, SwingConstants.CENTER);
+    }
+
+    public CheckBoxProvider(StringValue stringValue, int alignment) {
+        super(stringValue == null ? StringValues.EMPTY : stringValue, alignment);
+        borderPainted = true;
+    }
+
+    public boolean isBorderPainted() {
+        return borderPainted;
+    }
+
+    public void setBorderPainted(boolean borderPainted) {
+        this.borderPainted = borderPainted;
+    }
+
+    @Override
+    protected void format(CellContext context) {
+        boolean on = getValueAsBoolean(context);
+        if (rendererComponent.isSelected() != on) {
+            rendererComponent.setSelected(on);
+        }
+        String text = getValueAsString(context);
+        if (!text.equals(rendererComponent.getText())) {
+            rendererComponent.setText(text);
+        }
+    }
+
+    protected boolean getValueAsBoolean(CellContext context) {
+        if (formatter instanceof BooleanValue) {
+            return ((BooleanValue) formatter).getBoolean(context.getValue());
+        }
+        return Boolean.TRUE.equals(context.getValue());
+    }
+
+    @Override
+    protected void configureState(CellContext context) {
+        if (rendererComponent.getHorizontalAlignment() != getHorizontalAlignment()) {
+            rendererComponent.setHorizontalAlignment(getHorizontalAlignment());
+        }
+    }
+
+    @Override
+    protected AbstractButton createRendererComponent() {
+        return new JRendererCheckBox();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/ComponentProvider.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/ComponentProvider.java
new file mode 100644
index 00000000000..4abcda0dc9a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/ComponentProvider.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// Owns the one component a renderer paints its cells with, and sets it
+/// up for a cell: first the visuals every cell gets, then the content.
+public abstract class ComponentProvider<T extends JComponent> {
+
+    protected T rendererComponent;
+    protected DefaultVisuals<T> defaultVisuals;
+    protected int alignment;
+    protected StringValue formatter;
+
+    public ComponentProvider() {
+        this(null, SwingConstants.LEADING);
+    }
+
+    public ComponentProvider(StringValue converter) {
+        this(converter, SwingConstants.LEADING);
+    }
+
+    /// Makes a provider showing values through `converter`
+    /// ([StringValues#TO_STRING] when `null`) with the given horizontal
+    /// alignment.
+    public ComponentProvider(StringValue converter, int alignment) {
+        this.alignment = alignment;
+        this.formatter = converter != null ? converter : StringValues.TO_STRING;
+        rendererComponent = createRendererComponent();
+        defaultVisuals = createDefaultVisuals();
+    }
+
+    /// The component, set up for the cell `context` describes; with a
+    /// `null` context the component as it was left.
+    public T getRendererComponent(CellContext context) {
+        if (context != null) {
+            configureVisuals(context);
+            configureContent(context);
+        }
+        return rendererComponent;
+    }
+
+    public void setHorizontalAlignment(int alignment) {
+        this.alignment = alignment;
+    }
+
+    public int getHorizontalAlignment() {
+        return alignment;
+    }
+
+    public void setStringValue(StringValue formatter) {
+        this.formatter = formatter != null ? formatter : StringValues.TO_STRING;
+    }
+
+    public StringValue getStringValue() {
+        return formatter;
+    }
+
+    /// The text this provider shows for a value.
+    public String getString(Object value) {
+        return formatter.getString(value);
+    }
+
+    protected String getValueAsString(CellContext context) {
+        return getString(context.getValue());
+    }
+
+    /// The icon for the context's value when the converter is an
+    /// [IconValue], else `null`.
+    protected Icon getValueAsIcon(CellContext context) {
+        if (formatter instanceof IconValue) {
+            return ((IconValue) formatter).getIcon(context.getValue());
+        }
+        return null;
+    }
+
+    protected void configureVisuals(CellContext context) {
+        defaultVisuals.configureVisuals(rendererComponent, context);
+    }
+
+    protected void configureContent(CellContext context) {
+        configureState(context);
+        format(context);
+    }
+
+    /// Shows the context's value in the component.
+    protected abstract void format(CellContext context);
+
+    /// Sets the properties that are this provider's own, such as the
+    /// alignment.
+    protected abstract void configureState(CellContext context);
+
+    protected abstract T createRendererComponent();
+
+    protected DefaultVisuals<T> createDefaultVisuals() {
+        return new DefaultVisuals<T>();
+    }
+
+    protected DefaultVisuals<T> getDefaultVisuals() {
+        return defaultVisuals;
+    }
+
+    /// Does nothing: there are no UI delegates to refresh.
+    public void updateUI() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultListRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultListRenderer.java
new file mode 100644
index 00000000000..8dd1c434cff
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultListRenderer.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.ListCellRenderer;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// A list cell renderer that delegates to a [ComponentProvider]: a label
+/// showing the value's string unless another provider is given.
+public class DefaultListRenderer extends AbstractRenderer implements ListCellRenderer {
+
+    protected ListCellContext cellContext;
+
+    public DefaultListRenderer() {
+        this((ComponentProvider<?>) null);
+    }
+
+    public DefaultListRenderer(ComponentProvider<?> componentProvider) {
+        super(componentProvider);
+        this.cellContext = new ListCellContext();
+    }
+
+    public DefaultListRenderer(StringValue converter) {
+        this(new LabelProvider(converter));
+    }
+
+    public DefaultListRenderer(StringValue converter, int alignment) {
+        this(new LabelProvider(converter, alignment));
+    }
+
+    public DefaultListRenderer(StringValue stringValue, IconValue iconValue) {
+        this(stringValue, iconValue, SwingConstants.LEADING);
+    }
+
+    public DefaultListRenderer(StringValue stringValue, IconValue iconValue, int alignment) {
+        this(new MappedValue(stringValue, iconValue), alignment);
+    }
+
+    @Override
+    public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,
+            boolean cellHasFocus) {
+        cellContext.installContext(list, value, index, 0, isSelected, cellHasFocus, true, true);
+        return componentController.getRendererComponent(cellContext);
+    }
+
+    @Override
+    protected ComponentProvider<?> createDefaultComponentProvider() {
+        return new LabelProvider();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultTableRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultTableRenderer.java
new file mode 100644
index 00000000000..1a2bd4469fa
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultTableRenderer.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+
+/// A table cell renderer that delegates to a [ComponentProvider]: a
+/// label showing the value's string unless another provider is given.
+public class DefaultTableRenderer extends AbstractRenderer implements TableCellRenderer {
+
+    private final TableCellContext cellContext = new TableCellContext();
+
+    public DefaultTableRenderer() {
+        this((ComponentProvider<?>) null);
+    }
+
+    public DefaultTableRenderer(ComponentProvider<?> componentProvider) {
+        super(componentProvider);
+    }
+
+    public DefaultTableRenderer(StringValue converter) {
+        this(new LabelProvider(converter));
+    }
+
+    public DefaultTableRenderer(StringValue converter, int alignment) {
+        this(new LabelProvider(converter, alignment));
+    }
+
+    public DefaultTableRenderer(StringValue stringValue, IconValue iconValue) {
+        this(stringValue, iconValue, SwingConstants.LEADING);
+    }
+
+    public DefaultTableRenderer(StringValue stringValue, IconValue iconValue, int alignment) {
+        this(new MappedValue(stringValue, iconValue), alignment);
+    }
+
+    @Override
+    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+            int row, int column) {
+        cellContext.installContext(table, value, row, column, isSelected, hasFocus, true, true);
+        return componentController.getRendererComponent(cellContext);
+    }
+
+    @Override
+    protected ComponentProvider<?> createDefaultComponentProvider() {
+        return new LabelProvider();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultTreeRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultTreeRenderer.java
new file mode 100644
index 00000000000..0b98efc4248
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultTreeRenderer.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+
+/// A tree cell renderer that delegates to a [ComponentProvider].
+///
+/// The default provider is a label with the node's icon and text in one
+/// component, where SwingX wraps a second component next to the icon; the
+/// wrapping provider and its panel are absent. A node that is a
+/// [DefaultMutableTreeNode] is shown by its user object when the renderer
+/// was told to unwrap, which is the default.
+public class DefaultTreeRenderer extends AbstractRenderer implements TreeCellRenderer {
+
+    private final TreeCellContext cellContext = new TreeCellContext();
+
+    public DefaultTreeRenderer() {
+        this((ComponentProvider<?>) null);
+    }
+
+    public DefaultTreeRenderer(ComponentProvider<?> componentProvider) {
+        super(componentProvider);
+    }
+
+    public DefaultTreeRenderer(IconValue iv) {
+        this(iv, null);
+    }
+
+    public DefaultTreeRenderer(StringValue sv) {
+        this(null, sv);
+    }
+
+    public DefaultTreeRenderer(IconValue iv, StringValue sv) {
+        this(iv, sv, true);
+    }
+
+    public DefaultTreeRenderer(IconValue iv, StringValue sv, boolean unwrapUserObject) {
+        this(new NodeLabelProvider(iv, sv, unwrapUserObject));
+    }
+
+    @Override
+    public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
+            boolean leaf, int row, boolean hasFocus) {
+        cellContext.installContext(tree, value, row, 0, selected, hasFocus, expanded, leaf);
+        return componentController.getRendererComponent(cellContext);
+    }
+
+    @Override
+    protected ComponentProvider<?> createDefaultComponentProvider() {
+        return new NodeLabelProvider(null, null, true);
+    }
+
+    /// A label with the node's icon: the icon converter's, or the default
+    /// icon of the node's kind.
+    private static final class NodeLabelProvider extends LabelProvider {
+
+        private final IconValue icons;
+        private final boolean unwrap;
+
+        NodeLabelProvider(IconValue icons, StringValue strings, boolean unwrap) {
+            super(strings);
+            this.icons = icons;
+            this.unwrap = unwrap;
+        }
+
+        private Object plain(Object value) {
+            if (unwrap && value instanceof DefaultMutableTreeNode) {
+                return ((DefaultMutableTreeNode) value).getUserObject();
+            }
+            return value;
+        }
+
+        @Override
+        public String getString(Object value) {
+            return super.getString(plain(value));
+        }
+
+        @Override
+        protected Icon getValueAsIcon(CellContext context) {
+            Icon icon = icons != null ? icons.getIcon(plain(context.getValue())) : null;
+            if (icon == null) {
+                icon = super.getValueAsIcon(context);
+            }
+            return icon != null ? icon : context.getIcon();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultVisuals.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultVisuals.java
new file mode 100644
index 00000000000..172eb0329dc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/DefaultVisuals.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+
+/// Resets the visual properties of a renderer component for a cell: font,
+/// enabled state, colors and border, to what the cell's context says.
+///
+/// A property is written only when it differs from what the component
+/// has, because every write reaches the style of a Codename One widget.
+public class DefaultVisuals<T extends JComponent> {
+
+    private Color unselectedForeground;
+    private Color unselectedBackground;
+
+    public DefaultVisuals() {
+    }
+
+    /// Fixes the text color of unselected cells; `null` goes back to the
+    /// context's.
+    public void setForeground(Color c) {
+        unselectedForeground = c;
+    }
+
+    /// Fixes the background of unselected cells; `null` goes back to the
+    /// context's.
+    public void setBackground(Color c) {
+        unselectedBackground = c;
+    }
+
+    public void configureVisuals(T renderingComponent, CellContext context) {
+        configurePainter(renderingComponent, context);
+        configureState(renderingComponent, context);
+        configureColors(renderingComponent, context);
+        configureBorder(renderingComponent, context);
+    }
+
+    protected void configurePainter(T renderingComponent, CellContext context) {
+        if (renderingComponent instanceof PainterAware && ((PainterAware) renderingComponent).getPainter() != null) {
+            ((PainterAware) renderingComponent).setPainter(null);
+        }
+    }
+
+    private static boolean cn1Same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    protected void configureState(T renderingComponent, CellContext context) {
+        String name = context.getCellRendererName();
+        if (!cn1Same(name, renderingComponent.getName())) {
+            renderingComponent.setName(name);
+        }
+        if (renderingComponent.getToolTipText() != null) {
+            renderingComponent.setToolTipText(null);
+        }
+        Font f = context.getFont();
+        if (!cn1Same(f, renderingComponent.isFontSet() ? renderingComponent.getFont() : null)) {
+            renderingComponent.setFont(f);
+        }
+        boolean enabled = context.getComponent() == null || context.getComponent().isEnabled();
+        if (renderingComponent.isEnabled() != enabled) {
+            renderingComponent.setEnabled(enabled);
+        }
+    }
+
+    /// Does nothing: a renderer component of this layer has no preferred
+    /// size of its own to reset.
+    protected void configureSizes(T renderingComponent, CellContext context) {
+    }
+
+    protected void configureColors(T renderingComponent, CellContext context) {
+        Color fg;
+        Color bg;
+        if (context.isSelected()) {
+            fg = context.getSelectionForeground();
+            bg = context.getSelectionBackground();
+        } else {
+            fg = getForeground(context);
+            bg = getBackground(context);
+        }
+        if (!cn1Same(fg, renderingComponent.isForegroundSet() ? renderingComponent.getForeground() : null)) {
+            renderingComponent.setForeground(fg);
+        }
+        if (!cn1Same(bg, renderingComponent.isBackgroundSet() ? renderingComponent.getBackground() : null)) {
+            renderingComponent.setBackground(bg);
+        }
+        if (context.isFocused()) {
+            configureFocusColors(renderingComponent, context);
+        }
+    }
+
+    protected void configureFocusColors(T renderingComponent, CellContext context) {
+        if (!context.isSelected() && context.isEditable()) {
+            Color col = context.getFocusForeground();
+            if (col != null) {
+                renderingComponent.setForeground(col);
+            }
+            col = context.getFocusBackground();
+            if (col != null) {
+                renderingComponent.setBackground(col);
+            }
+        }
+    }
+
+    protected void configureBorder(T renderingComponent, CellContext context) {
+        Border b = context.getBorder();
+        if (renderingComponent.getBorder() != b) {
+            renderingComponent.setBorder(b);
+        }
+    }
+
+    protected Color getForeground(CellContext context) {
+        return unselectedForeground != null ? unselectedForeground : context.getForeground();
+    }
+
+    protected Color getBackground(CellContext context) {
+        return unselectedBackground != null ? unselectedBackground : context.getBackground();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/FormatStringValue.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/FormatStringValue.java
new file mode 100644
index 00000000000..90cd77cf833
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/FormatStringValue.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import java.text.Format;
+
+/// Converts a value through a `java.text.Format`; a value the format
+/// rejects, or any value when there is no format, is shown by `toString`.
+public class FormatStringValue implements StringValue {
+
+    protected Format format;
+
+    public FormatStringValue() {
+        this(null);
+    }
+
+    public FormatStringValue(Format format) {
+        this.format = format;
+    }
+
+    public Format getFormat() {
+        return format;
+    }
+
+    @Override
+    public String getString(Object value) {
+        if (value == null) {
+            return "";
+        }
+        if (format != null) {
+            try {
+                return format.format(value);
+            } catch (IllegalArgumentException e) {
+                return value.toString();
+            }
+        }
+        return value.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconAware.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconAware.java
new file mode 100644
index 00000000000..5e2507c830f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconAware.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.javax.swing.Icon;
+
+/// A renderer component that shows an icon.
+public interface IconAware {
+
+    void setIcon(Icon icon);
+
+    Icon getIcon();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconValue.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconValue.java
new file mode 100644
index 00000000000..c04aa072934
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconValue.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.swing.Icon;
+
+/// Turns a cell value into the icon shown for it.
+public interface IconValue {
+
+    /// An icon of no size that says "show no icon", as opposed to `null`,
+    /// which says "no opinion, show the default one".
+    Icon NULL_ICON = new Icon() {
+        @Override
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+        }
+
+        @Override
+        public int getIconWidth() {
+            return 0;
+        }
+
+        @Override
+        public int getIconHeight() {
+            return 0;
+        }
+    };
+
+    Icon getIcon(Object value);
+
+    /// The kinds of default icon a tree has.
+    enum IconType {
+        LEAF, OPEN_FOLDER, CLOSED_FOLDER
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconValues.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconValues.java
new file mode 100644
index 00000000000..dd20b1333be
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/IconValues.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.javax.swing.Icon;
+
+/// The usual icon converters. `FILE_ICON` is absent.
+public final class IconValues {
+
+    /// No icon for anything.
+    public static final IconValue NONE = new IconValue() {
+        @Override
+        public Icon getIcon(Object value) {
+            return IconValue.NULL_ICON;
+        }
+    };
+
+    /// The value itself where it is an icon, else no opinion.
+    public static final IconValue ICON = new IconValue() {
+        @Override
+        public Icon getIcon(Object value) {
+            return value instanceof Icon ? (Icon) value : null;
+        }
+    };
+
+    private IconValues() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/JRendererCheckBox.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/JRendererCheckBox.java
new file mode 100644
index 00000000000..611acbe297e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/JRendererCheckBox.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JCheckBox;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+
+/// The check box the check box provider renders with. A [Painter] set on
+/// it draws under the box.
+public class JRendererCheckBox extends JCheckBox implements PainterAware {
+
+    protected Painter painter;
+
+    public JRendererCheckBox() {
+        super();
+    }
+
+    @Override
+    public Painter getPainter() {
+        return painter;
+    }
+
+    @Override
+    public void setPainter(Painter painter) {
+        this.painter = painter;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (painter != null && g instanceof Graphics2D) {
+            paintComponentWithPainter((Graphics2D) g);
+        } else {
+            super.paintComponent(g);
+        }
+    }
+
+    protected void paintComponentWithPainter(Graphics2D g) {
+        Color bg = getBackground();
+        if (bg != null && isBackgroundSet()) {
+            g.setColor(bg);
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        Graphics2D scratch = (Graphics2D) g.create();
+        try {
+            cn1Paint(scratch);
+        } finally {
+            scratch.dispose();
+        }
+        if (bg != null) {
+            super.setBackground(new Color(bg.getRed(), bg.getGreen(), bg.getBlue(), 0));
+        }
+        try {
+            super.paintComponent(g);
+        } finally {
+            if (bg != null) {
+                super.setBackground(bg);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void cn1Paint(Graphics2D g) {
+        Painter p = painter;
+        if (p != null) {
+            p.paint(g, this, getWidth(), getHeight());
+        }
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void invalidate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void validate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void revalidate() {
+    }
+
+    /// Does nothing: the owner paints the renderer when it paints itself.
+    @Override
+    public void repaint(long tm, int x, int y, int width, int height) {
+    }
+
+    /// Does nothing: the owner paints the renderer when it paints itself.
+    @Override
+    public void repaint(Rectangle r) {
+    }
+
+    /// Does nothing: the owner paints the renderer when it paints itself.
+    @Override
+    public void repaint() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/JRendererLabel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/JRendererLabel.java
new file mode 100644
index 00000000000..e8d2058f58e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/JRendererLabel.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+
+/// The label the label provider renders with. It can have its background
+/// drawn by a [Painter], and like every rubber stamp it ignores the calls
+/// that would lay out or repaint a real component.
+public class JRendererLabel extends JLabel implements PainterAware, IconAware {
+
+    protected Painter painter;
+
+    public JRendererLabel() {
+        super();
+        setOpaque(true);
+    }
+
+    @Override
+    public void setPainter(Painter painter) {
+        this.painter = painter;
+    }
+
+    @Override
+    public Painter getPainter() {
+        return painter;
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        if (painter != null && g instanceof Graphics2D) {
+            paintComponentWithPainter((Graphics2D) g);
+        } else {
+            super.paintComponent(g);
+        }
+    }
+
+    /// Fills the background, lets the painter draw, and draws the label's
+    /// text and icon over both.
+    protected void paintComponentWithPainter(Graphics2D g) {
+        Color bg = getBackground();
+        if (isOpaque() && bg != null) {
+            g.setColor(bg);
+            g.fillRect(0, 0, getWidth(), getHeight());
+        }
+        Graphics2D scratch = (Graphics2D) g.create();
+        try {
+            cn1Paint(scratch);
+        } finally {
+            scratch.dispose();
+        }
+        // The Codename One label fills its own background unless that is
+        // fully transparent: make it so while the content is drawn.
+        if (bg != null) {
+            super.setBackground(new Color(bg.getRed(), bg.getGreen(), bg.getBlue(), 0));
+        }
+        try {
+            super.paintComponent(g);
+        } finally {
+            if (bg != null) {
+                super.setBackground(bg);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void cn1Paint(Graphics2D g) {
+        painter.paint(g, this, getWidth(), getHeight());
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void invalidate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void validate() {
+    }
+
+    /// Does nothing: the renderer is in no layout.
+    @Override
+    public void revalidate() {
+    }
+
+    /// Does nothing: the owner paints the renderer when it paints itself.
+    @Override
+    public void repaint(long tm, int x, int y, int width, int height) {
+    }
+
+    /// Does nothing: the owner paints the renderer when it paints itself.
+    @Override
+    public void repaint(Rectangle r) {
+    }
+
+    /// Does nothing: the owner paints the renderer when it paints itself.
+    @Override
+    public void repaint() {
+    }
+
+    /// Does nothing: nobody listens to a renderer's properties.
+    @Override
+    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+    }
+
+    /// Does nothing: nobody listens to a renderer's properties.
+    @Override
+    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/LabelProvider.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/LabelProvider.java
new file mode 100644
index 00000000000..7f94c8c5016
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/LabelProvider.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+
+/// Shows a cell as a label: the converter's text and, when the converter
+/// is an [IconValue], its icon.
+public class LabelProvider extends ComponentProvider<JLabel> {
+
+    public LabelProvider() {
+        this(null);
+    }
+
+    public LabelProvider(StringValue converter) {
+        this(converter, SwingConstants.LEADING);
+    }
+
+    public LabelProvider(int alignment) {
+        this(null, alignment);
+    }
+
+    public LabelProvider(StringValue converter, int alignment) {
+        super(converter, alignment);
+    }
+
+    @Override
+    protected JLabel createRendererComponent() {
+        return new JRendererLabel();
+    }
+
+    @Override
+    protected void configureState(CellContext context) {
+        if (rendererComponent.getHorizontalAlignment() != getHorizontalAlignment()) {
+            rendererComponent.setHorizontalAlignment(getHorizontalAlignment());
+        }
+    }
+
+    @Override
+    protected void format(CellContext context) {
+        Icon icon = getValueAsIcon(context);
+        if (icon == IconValue.NULL_ICON) {
+            icon = null;
+        }
+        if (rendererComponent.getIcon() != icon) {
+            rendererComponent.setIcon(icon);
+        }
+        String text = getValueAsString(context);
+        if (!text.equals(rendererComponent.getText())) {
+            rendererComponent.setText(text);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/ListCellContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/ListCellContext.java
new file mode 100644
index 00000000000..6cec6c2b183
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/ListCellContext.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JList;
+
+/// The context of a list cell.
+public class ListCellContext extends CellContext {
+
+    public ListCellContext() {
+    }
+
+    public void installContext(JList component, Object value, int row, int column, boolean selected,
+            boolean focused, boolean expanded, boolean leaf) {
+        this.component = component;
+        installState(value, row, column, selected, focused, expanded, leaf);
+    }
+
+    @Override
+    public JList getComponent() {
+        return component instanceof JList ? (JList) component : null;
+    }
+
+    @Override
+    protected Color getSelectionBackground() {
+        JList l = getComponent();
+        return l != null ? l.getSelectionBackground() : null;
+    }
+
+    @Override
+    protected Color getSelectionForeground() {
+        JList l = getComponent();
+        return l != null ? l.getSelectionForeground() : null;
+    }
+
+    @Override
+    protected String getUIPrefix() {
+        return "List.";
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/MappedValue.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/MappedValue.java
new file mode 100644
index 00000000000..25db2023b17
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/MappedValue.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.javax.swing.Icon;
+
+/// A text converter, an icon converter and a boolean converter in one
+/// object. A missing converter answers the empty string, no icon and
+/// `false`.
+public class MappedValue implements StringValue, IconValue, BooleanValue {
+
+    private final StringValue stringDelegate;
+    private final IconValue iconDelegate;
+    private final BooleanValue booleanDelegate;
+
+    public MappedValue(StringValue stringDelegate, IconValue iconDelegate) {
+        this(stringDelegate, iconDelegate, null);
+    }
+
+    public MappedValue(StringValue stringDelegate, IconValue iconDelegate, BooleanValue booleanDelegate) {
+        this.stringDelegate = stringDelegate;
+        this.iconDelegate = iconDelegate;
+        this.booleanDelegate = booleanDelegate;
+    }
+
+    @Override
+    public String getString(Object value) {
+        return stringDelegate != null ? stringDelegate.getString(value) : "";
+    }
+
+    @Override
+    public Icon getIcon(Object value) {
+        return iconDelegate != null ? iconDelegate.getIcon(value) : null;
+    }
+
+    @Override
+    public boolean getBoolean(Object value) {
+        return booleanDelegate != null && booleanDelegate.getBoolean(value);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/PainterAware.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/PainterAware.java
new file mode 100644
index 00000000000..94cf8a1441c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/PainterAware.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+
+/// A renderer component whose background a [Painter] can draw.
+public interface PainterAware {
+
+    void setPainter(Painter<?> painter);
+
+    Painter<?> getPainter();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/StringValue.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/StringValue.java
new file mode 100644
index 00000000000..fdee06fd0cc
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/StringValue.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+/// Turns a cell value into the text shown for it.
+public interface StringValue {
+
+    /// The text for `value`, never `null`.
+    String getString(Object value);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/StringValues.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/StringValues.java
new file mode 100644
index 00000000000..f9f3056447d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/StringValues.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import java.text.DateFormat;
+import java.util.Date;
+
+/// The usual converters.
+///
+/// `FILE_NAME`, `FILE_TYPE` and the look and feel variants are absent.
+/// `NUMBER_TO_STRING` shows a number by its `toString`, because the
+/// device's number formats are not `java.text.Format`s; its
+/// `getFormat()` answers `null`.
+public final class StringValues {
+
+    /// The empty string for everything.
+    public static final StringValue EMPTY = new StringValue() {
+        @Override
+        public String getString(Object value) {
+            return "";
+        }
+    };
+
+    /// The value's `toString`, the empty string for `null`. A value that
+    /// is itself a [StringValue] is asked to convert itself.
+    public static final StringValue TO_STRING = new StringValue() {
+        @Override
+        public String getString(Object value) {
+            return value != null ? value.toString() : "";
+        }
+    };
+
+    /// A date in the device's short date format; anything else by
+    /// `toString`.
+    public static final FormatStringValue DATE_TO_STRING = new FormatStringValue() {
+        private DateFormat dates;
+
+        @Override
+        public String getString(Object value) {
+            if (value instanceof Date) {
+                if (dates == null) {
+                    dates = DateFormat.getDateInstance();
+                }
+                return dates.format((Date) value);
+            }
+            return TO_STRING.getString(value);
+        }
+    };
+
+    /// A number, or anything else, by `toString`.
+    public static final FormatStringValue NUMBER_TO_STRING = new FormatStringValue() {
+        @Override
+        public String getString(Object value) {
+            return TO_STRING.getString(value);
+        }
+    };
+
+    private StringValues() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/TableCellContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/TableCellContext.java
new file mode 100644
index 00000000000..026b34b2953
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/TableCellContext.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JTable;
+
+/// The context of a table cell.
+public class TableCellContext extends CellContext {
+
+    public TableCellContext() {
+    }
+
+    public void installContext(JTable component, Object value, int row, int column, boolean selected,
+            boolean focused, boolean expanded, boolean leaf) {
+        this.component = component;
+        installState(value, row, column, selected, focused, expanded, leaf);
+    }
+
+    @Override
+    public JTable getComponent() {
+        return component instanceof JTable ? (JTable) component : null;
+    }
+
+    @Override
+    public boolean isEditable() {
+        JTable t = getComponent();
+        return t != null && isValidRow() && isValidColumn() && t.isCellEditable(getRow(), getColumn());
+    }
+
+    @Override
+    protected Color getSelectionBackground() {
+        JTable t = getComponent();
+        return t != null ? t.getSelectionBackground() : null;
+    }
+
+    @Override
+    protected Color getSelectionForeground() {
+        JTable t = getComponent();
+        return t != null ? t.getSelectionForeground() : null;
+    }
+
+    @Override
+    protected String getUIPrefix() {
+        return "Table.";
+    }
+
+    protected boolean isValidColumn() {
+        JTable t = getComponent();
+        return t != null && getColumn() >= 0 && getColumn() < t.getColumnCount();
+    }
+
+    protected boolean isValidRow() {
+        JTable t = getComponent();
+        return t != null && getRow() >= 0 && getRow() < t.getRowCount();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/TreeCellContext.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/TreeCellContext.java
new file mode 100644
index 00000000000..555c16a099a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/TreeCellContext.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.rt.CellTheme;
+
+/// The context of a tree cell, which also knows the node's default icon.
+public class TreeCellContext extends CellContext {
+
+    private static DefaultTreeCellRenderer cn1Defaults;
+
+    protected Icon leafIcon;
+    protected Icon closedIcon;
+    protected Icon openIcon;
+
+    public TreeCellContext() {
+    }
+
+    public void installContext(JTree component, Object value, int row, int column, boolean selected,
+            boolean focused, boolean expanded, boolean leaf) {
+        this.component = component;
+        installState(value, row, column, selected, focused, expanded, leaf);
+    }
+
+    @Override
+    public JTree getComponent() {
+        return component instanceof JTree ? (JTree) component : null;
+    }
+
+    /// The path of the cell's row, or `null`.
+    public TreePath getTreePath() {
+        JTree t = getComponent();
+        if (t == null || row < 0 || row >= t.getRowCount()) {
+            return null;
+        }
+        return t.getPathForRow(row);
+    }
+
+    @Override
+    public boolean isEditable() {
+        JTree t = getComponent();
+        TreePath path = getTreePath();
+        return t != null && path != null && t.isPathEditable(path);
+    }
+
+    @Override
+    protected Color getSelectionBackground() {
+        return CellTheme.selectionBackground("Tree.selectionBackground");
+    }
+
+    @Override
+    protected Color getSelectionForeground() {
+        return CellTheme.selectionForeground("Tree.selectionForeground");
+    }
+
+    @Override
+    protected String getUIPrefix() {
+        return "Tree.";
+    }
+
+    private static DefaultTreeCellRenderer cn1Defaults() {
+        if (cn1Defaults == null) {
+            cn1Defaults = new DefaultTreeCellRenderer();
+        }
+        return cn1Defaults;
+    }
+
+    protected Icon getLeafIcon() {
+        return leafIcon != null ? leafIcon : cn1Defaults().getDefaultLeafIcon();
+    }
+
+    protected Icon getOpenIcon() {
+        return openIcon != null ? openIcon : cn1Defaults().getDefaultOpenIcon();
+    }
+
+    protected Icon getClosedIcon() {
+        return closedIcon != null ? closedIcon : cn1Defaults().getDefaultClosedIcon();
+    }
+
+    @Override
+    public Icon getIcon() {
+        if (isLeaf()) {
+            return getLeafIcon();
+        }
+        return isExpanded() ? getOpenIcon() : getClosedIcon();
+    }
+
+    @Override
+    protected Border getFocusBorder() {
+        return super.getFocusBorder();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/package-info.java
new file mode 100644
index 00000000000..c779308bb2e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/renderer/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The SwingX renderers: one renderer class per kind of component -- table,
+/// list, tree -- that leaves the choice of text, icon and component to a
+/// [ComponentProvider] with a [StringValue].
+///
+/// Unlike the JDK's default renderers these reset every visual property
+/// for every cell, which is what lets a highlighter change one freely.
+/// The converters are not serializable here.
+package com.codename1.desktopcompat.org.jdesktop.swingx.renderer;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/RolloverProducer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/RolloverProducer.java
new file mode 100644
index 00000000000..e1edb606c4a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/RolloverProducer.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.rollover;
+
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseListener;
+import com.codename1.desktopcompat.java.awt.event.MouseMotionListener;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+
+/// Turns pointer events over a component into two client properties of
+/// it: [#ROLLOVER_KEY], the cell under the pointer, and [#CLICKED_KEY],
+/// the cell that was clicked. Both hold a `Point` whose `x` is the column
+/// and whose `y` is the row, `-1` for none.
+///
+/// A touch screen has no pointer to hover with, so there the rollover
+/// cell is the cell last touched.
+public abstract class RolloverProducer implements MouseListener, MouseMotionListener {
+
+    public static final String CLICKED_KEY = "swingx.clicked";
+    public static final String ROLLOVER_KEY = "swingx.rollover";
+
+    /// The cell under the pointer as of the last event.
+    protected Point rollover = new Point(-1, -1);
+
+    private Point cn1Pressed;
+    private boolean cn1Dragged;
+
+    public RolloverProducer() {
+    }
+
+    public void install(JComponent component) {
+        component.addMouseListener(this);
+        component.addMouseMotionListener(this);
+    }
+
+    public void release(JComponent component) {
+        component.removeMouseListener(this);
+        component.removeMouseMotionListener(this);
+    }
+
+    @Override
+    public void mouseReleased(MouseEvent e) {
+        Point pressed = cn1Pressed;
+        boolean dragged = cn1Dragged;
+        cn1Pressed = null;
+        cn1Dragged = false;
+        updateRollover(e, ROLLOVER_KEY, false);
+        if (isClick(e, pressed, dragged)) {
+            updateRollover(e, CLICKED_KEY, true);
+        }
+    }
+
+    /// Whether a release over the current cell is a click: the press was
+    /// on the same cell and the pointer was not dragged between.
+    protected boolean isClick(MouseEvent e, Point oldRollover, boolean wasDragging) {
+        return oldRollover != null && oldRollover.equals(rollover) && !wasDragging;
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e) {
+        updateRollover(e, ROLLOVER_KEY, false);
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e) {
+        rollover.setLocation(-1, -1);
+        Object source = e.getSource();
+        if (source instanceof JComponent) {
+            ((JComponent) source).putClientProperty(ROLLOVER_KEY, null);
+        }
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e) {
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e) {
+        updateRollover(e, ROLLOVER_KEY, false);
+        cn1Pressed = new Point(rollover);
+        cn1Dragged = false;
+    }
+
+    @Override
+    public void mouseDragged(MouseEvent e) {
+        cn1Dragged = true;
+    }
+
+    @Override
+    public void mouseMoved(MouseEvent e) {
+        updateRollover(e, ROLLOVER_KEY, false);
+    }
+
+    protected void updateRollover(MouseEvent e, String property, boolean fireAlways) {
+        Object source = e.getSource();
+        if (!(source instanceof JComponent)) {
+            return;
+        }
+        JComponent component = (JComponent) source;
+        updateRolloverPoint(component, e.getPoint());
+        updateClientProperty(component, property, fireAlways);
+    }
+
+    /// Writes the current cell into the property. Without `fireAlways`
+    /// nothing is written when the property already holds that cell.
+    protected void updateClientProperty(JComponent component, String property, boolean fireAlways) {
+        if (fireAlways) {
+            component.putClientProperty(property, null);
+            component.putClientProperty(property, new Point(rollover));
+            return;
+        }
+        Object old = component.getClientProperty(property);
+        if (rollover.equals(old)) {
+            return;
+        }
+        component.putClientProperty(property, new Point(rollover));
+    }
+
+    /// Sets [#rollover] to the cell of `component` at `mousePoint`.
+    protected abstract void updateRolloverPoint(JComponent component, Point mousePoint);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/RolloverRenderer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/RolloverRenderer.java
new file mode 100644
index 00000000000..c47c5f7c2fa
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/RolloverRenderer.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.rollover;
+
+/// A renderer whose cells can be clicked like a button: a hyperlink or a
+/// check box in a cell.
+public interface RolloverRenderer {
+
+    /// Whether a click on the cell does anything.
+    boolean isEnabled();
+
+    /// Does what a click on the cell last rendered does.
+    void doClick();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/package-info.java
new file mode 100644
index 00000000000..5fb0346cf13
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/rollover/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// What a renderer that reacts to the pointer implements.
+package com.codename1.desktopcompat.org.jdesktop.swingx.rollover;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/DefaultSortController.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/DefaultSortController.java
new file mode 100644
index 00000000000..6745da2ba7c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/DefaultSortController.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.javax.swing.DefaultRowSorter;
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValues;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// A row sorter that is a [SortController].
+///
+/// A column without a comparator of its own is compared by
+/// [#COMPARABLE_COMPARATOR].
+public abstract class DefaultSortController<M> extends DefaultRowSorter<M, Integer> implements SortController<M> {
+
+    /// Compares two values of the same comparable class by their natural
+    /// order, two numbers by their value, and anything else by their
+    /// strings. It never fails on values of different classes.
+    @SuppressWarnings("rawtypes")
+    public static final Comparator COMPARABLE_COMPARATOR = new ComparableComparator();
+
+    private static final SortOrder[] DEFAULT_CYCLE = {SortOrder.ASCENDING, SortOrder.DESCENDING};
+
+    private static final StringValueProvider TO_STRING_PROVIDER = new StringValueProvider() {
+        @Override
+        public StringValue getStringValue(int row, int column) {
+            return StringValues.TO_STRING;
+        }
+    };
+
+    private final Map<Integer, Comparator<?>> cn1Comparators = new HashMap<Integer, Comparator<?>>();
+    private boolean sortable = true;
+    private SortOrder[] sortCycle = getDefaultSortOrderCycle();
+    private StringValueProvider stringValueProvider = TO_STRING_PROVIDER;
+
+    public DefaultSortController() {
+        super();
+    }
+
+    @Override
+    public void setSortable(boolean sortable) {
+        this.sortable = sortable;
+    }
+
+    @Override
+    public boolean isSortable() {
+        return sortable;
+    }
+
+    @Override
+    public void setSortable(int column, boolean sortable) {
+        super.setSortable(column, sortable);
+    }
+
+    @Override
+    public boolean isSortable(int column) {
+        return sortable && super.isSortable(column);
+    }
+
+    @Override
+    public void setComparator(int column, Comparator<?> comparator) {
+        super.setComparator(column, comparator);
+        if (comparator == null) {
+            cn1Comparators.remove(Integer.valueOf(column));
+        } else {
+            cn1Comparators.put(Integer.valueOf(column), comparator);
+        }
+    }
+
+    /// The comparator set for a column, or `null`.
+    Comparator<?> cn1Comparator(int column) {
+        return cn1Comparators.get(Integer.valueOf(column));
+    }
+
+    @Override
+    public Comparator<?> getComparator(int column) {
+        Comparator<?> set = cn1Comparator(column);
+        return set != null ? set : COMPARABLE_COMPARATOR;
+    }
+
+    @Override
+    protected boolean useToString(int column) {
+        return false;
+    }
+
+    private List<RowSorter.SortKey> cn1KeysWithout(int column) {
+        List<RowSorter.SortKey> keys = new ArrayList<RowSorter.SortKey>();
+        List<? extends RowSorter.SortKey> now = getSortKeys();
+        for (int i = 0; i < now.size(); i++) {
+            if (now.get(i).getColumn() != column) {
+                keys.add(now.get(i));
+            }
+        }
+        return keys;
+    }
+
+    private void cn1SetFirst(int column, SortOrder order) {
+        List<RowSorter.SortKey> keys = cn1KeysWithout(column);
+        if (SortUtils.isSorted(order)) {
+            keys.add(0, new RowSorter.SortKey(column, order));
+        }
+        int max = Math.max(1, getMaxSortKeys());
+        while (keys.size() > max) {
+            keys.remove(keys.size() - 1);
+        }
+        setSortKeys(keys);
+    }
+
+    /// Moves a sortable column to the next order of the cycle and makes
+    /// it the first column sorted by. A column that is not the first one
+    /// sorted by starts the cycle over.
+    @Override
+    public void toggleSortOrder(int column) {
+        if (!isSortable(column) || sortCycle.length == 0) {
+            return;
+        }
+        SortOrder next = sortCycle[0];
+        List<? extends RowSorter.SortKey> keys = getSortKeys();
+        if (!keys.isEmpty() && keys.get(0).getColumn() == column) {
+            SortOrder current = keys.get(0).getSortOrder();
+            for (int i = 0; i < sortCycle.length; i++) {
+                if (sortCycle[i] == current) {
+                    next = sortCycle[(i + 1) % sortCycle.length];
+                    break;
+                }
+            }
+        }
+        cn1SetFirst(column, next);
+    }
+
+    @Override
+    public void setSortOrder(int column, SortOrder sortOrder) {
+        if (!isSortable(column)) {
+            return;
+        }
+        cn1SetFirst(column, sortOrder);
+    }
+
+    @Override
+    public SortOrder getSortOrder(int column) {
+        RowSorter.SortKey key = SortUtils.getFirstSortKeyForColumn(getSortKeys(), column);
+        return key != null ? key.getSortOrder() : SortOrder.UNSORTED;
+    }
+
+    @Override
+    public void resetSortOrders() {
+        if (!isSortable()) {
+            return;
+        }
+        List<RowSorter.SortKey> keys = new ArrayList<RowSorter.SortKey>();
+        List<? extends RowSorter.SortKey> now = getSortKeys();
+        for (int i = 0; i < now.size(); i++) {
+            if (!isSortable(now.get(i).getColumn())) {
+                keys.add(now.get(i));
+            }
+        }
+        setSortKeys(keys);
+    }
+
+    @Override
+    public SortOrder[] getSortOrderCycle() {
+        SortOrder[] copy = new SortOrder[sortCycle.length];
+        for (int i = 0; i < copy.length; i++) {
+            copy[i] = sortCycle[i];
+        }
+        return copy;
+    }
+
+    @Override
+    public void setSortOrderCycle(SortOrder... cycle) {
+        SortOrder[] copy = new SortOrder[cycle == null ? 0 : cycle.length];
+        for (int i = 0; i < copy.length; i++) {
+            copy[i] = cycle[i];
+        }
+        sortCycle = copy;
+    }
+
+    /// Sets where the strings of the cells come from; `null` goes back
+    /// to the values' `toString`.
+    @Override
+    public void setStringValueProvider(StringValueProvider registry) {
+        stringValueProvider = registry != null ? registry : TO_STRING_PROVIDER;
+    }
+
+    @Override
+    public StringValueProvider getStringValueProvider() {
+        return stringValueProvider;
+    }
+
+    /// Ascending, then descending.
+    public static SortOrder[] getDefaultSortOrderCycle() {
+        return new SortOrder[]{DEFAULT_CYCLE[0], DEFAULT_CYCLE[1]};
+    }
+
+    /// The comparators and sortable flags of the columns are forgotten
+    /// with the columns.
+    @Override
+    public void modelStructureChanged() {
+        if (cn1Comparators != null) {
+            cn1Comparators.clear();
+        }
+        super.modelStructureChanged();
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static final class ComparableComparator implements Comparator, java.io.Serializable {
+
+        private static final long serialVersionUID = 1L;
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public int compare(Object a, Object b) {
+            if (a == b) {
+                return 0;
+            }
+            if (a == null) {
+                return -1;
+            }
+            if (b == null) {
+                return 1;
+            }
+            if (a instanceof Comparable && a.getClass() == b.getClass()) {
+                return ((Comparable) a).compareTo(b);
+            }
+            if (a instanceof Number && b instanceof Number) {
+                double x = ((Number) a).doubleValue();
+                double y = ((Number) b).doubleValue();
+                return Double.compare(x, y);
+            }
+            return a.toString().compareTo(b.toString());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/ListSortController.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/ListSortController.java
new file mode 100644
index 00000000000..a473a054099
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/ListSortController.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.javax.swing.ListModel;
+
+/// The sort controller of a list: a model of one column, column 0.
+public class ListSortController<M extends ListModel> extends DefaultSortController<M> {
+
+    private M listModel;
+
+    public ListSortController(M model) {
+        super();
+        setModel(model);
+    }
+
+    public void setModel(M model) {
+        listModel = model;
+        setModelWrapper(new Wrapper());
+    }
+
+    private final class Wrapper extends ModelWrapper<M, Integer> {
+
+        @Override
+        public M getModel() {
+            return listModel;
+        }
+
+        @Override
+        public int getColumnCount() {
+            return 1;
+        }
+
+        @Override
+        public int getRowCount() {
+            return listModel == null ? 0 : listModel.getSize();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return listModel.getElementAt(row);
+        }
+
+        @Override
+        public String getStringValueAt(int row, int column) {
+            String s = getStringValueProvider().getStringValue(row, column).getString(getValueAt(row, column));
+            return s == null ? "" : s;
+        }
+
+        @Override
+        public Integer getIdentifier(int row) {
+            return Integer.valueOf(row);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/RowFilters.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/RowFilters.java
new file mode 100644
index 00000000000..4ce83b2eb5d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/RowFilters.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+
+/// Row filter building blocks. The regular expression filters are
+/// absent.
+public class RowFilters {
+
+    RowFilters() {
+    }
+
+    /// A filter that includes a row when one of a set of its values
+    /// passes [#include(RowFilter.Entry, int)]: the values of the
+    /// columns given, or every value when none is given.
+    public abstract static class GeneralFilter extends RowFilter<Object, Object> {
+
+        private final int[] columns;
+
+        protected GeneralFilter(int... columns) {
+            checkIndices(columns);
+            int[] copy = new int[columns == null ? 0 : columns.length];
+            for (int i = 0; i < copy.length; i++) {
+                copy[i] = columns[i];
+            }
+            this.columns = copy;
+        }
+
+        @Override
+        public boolean include(RowFilter.Entry<? extends Object, ? extends Object> value) {
+            int count = value.getValueCount();
+            if (columns.length > 0) {
+                for (int i = columns.length - 1; i >= 0; i--) {
+                    int index = columns[i];
+                    if (index < count && include(value, index)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            for (int i = count - 1; i >= 0; i--) {
+                if (include(value, i)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        protected abstract boolean include(RowFilter.Entry<? extends Object, ? extends Object> value, int index);
+
+        /// Rejects a negative column.
+        protected void checkIndices(int[] columns) {
+            if (columns == null) {
+                return;
+            }
+            for (int i = columns.length - 1; i >= 0; i--) {
+                if (columns[i] < 0) {
+                    throw new IllegalArgumentException("Index must be >= 0");
+                }
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/SortController.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/SortController.java
new file mode 100644
index 00000000000..c207a9fd23a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/SortController.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import java.util.Comparator;
+
+/// What a SwingX component asks of its row sorter beyond `RowSorter`.
+/// Columns are model columns.
+public interface SortController<M> {
+
+    /// Switches sorting by the user on or off as a whole; a column is
+    /// sortable when this is on and the column itself is.
+    void setSortable(boolean sortable);
+
+    boolean isSortable();
+
+    void setSortable(int column, boolean sortable);
+
+    boolean isSortable(int column);
+
+    void setComparator(int column, Comparator<?> comparator);
+
+    Comparator<?> getComparator(int column);
+
+    /// Sets the orders [#toggleSortOrder(int)] steps a column through.
+    void setSortOrderCycle(SortOrder... cycle);
+
+    SortOrder[] getSortOrderCycle();
+
+    void setSortsOnUpdates(boolean sortsOnUpdates);
+
+    boolean getSortsOnUpdates();
+
+    void setStringValueProvider(StringValueProvider registry);
+
+    StringValueProvider getStringValueProvider();
+
+    void toggleSortOrder(int column);
+
+    void setSortOrder(int column, SortOrder sortOrder);
+
+    SortOrder getSortOrder(int column);
+
+    void resetSortOrders();
+
+    void setRowFilter(RowFilter<? super M, ? super Integer> filter);
+
+    RowFilter<? super M, ? super Integer> getRowFilter();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/SortUtils.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/SortUtils.java
new file mode 100644
index 00000000000..d677728f9b9
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/SortUtils.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.javax.swing.RowSorter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import java.util.List;
+
+/// Helpers for sort keys and sort orders.
+public class SortUtils {
+
+    SortUtils() {
+    }
+
+    /// The first key that sorts at all, or `null`.
+    public static RowSorter.SortKey getFirstSortingKey(List<? extends RowSorter.SortKey> keys) {
+        if (keys == null) {
+            return null;
+        }
+        for (int i = 0; i < keys.size(); i++) {
+            RowSorter.SortKey key = keys.get(i);
+            if (isSorted(key.getSortOrder())) {
+                return key;
+            }
+        }
+        return null;
+    }
+
+    /// The first key of a model column, or `null`.
+    public static RowSorter.SortKey getFirstSortKeyForColumn(List<? extends RowSorter.SortKey> keys,
+            int modelColumn) {
+        if (keys == null) {
+            return null;
+        }
+        for (int i = 0; i < keys.size(); i++) {
+            RowSorter.SortKey key = keys.get(i);
+            if (key.getColumn() == modelColumn) {
+                return key;
+            }
+        }
+        return null;
+    }
+
+    /// Removes the first key of a model column from the list and answers
+    /// it, or `null`.
+    public static RowSorter.SortKey removeFirstSortKeyForColumn(List<? extends RowSorter.SortKey> keys,
+            int modelColumn) {
+        if (keys == null) {
+            return null;
+        }
+        for (int i = 0; i < keys.size(); i++) {
+            RowSorter.SortKey key = keys.get(i);
+            if (key.getColumn() == modelColumn) {
+                keys.remove(i);
+                return key;
+            }
+        }
+        return null;
+    }
+
+    public static boolean isSorted(SortOrder sortOrder) {
+        return sortOrder != null && sortOrder != SortOrder.UNSORTED;
+    }
+
+    public static boolean isAscending(SortOrder sortOrder) {
+        return sortOrder == SortOrder.ASCENDING;
+    }
+
+    /// Whether the order sorts in the given direction.
+    public static boolean isSorted(SortOrder sortOrder, boolean ascending) {
+        return isSorted(sortOrder) && ascending == isAscending(sortOrder);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/StringValueProvider.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/StringValueProvider.java
new file mode 100644
index 00000000000..d64960e0448
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/StringValueProvider.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+
+/// Says which converter makes the text of a cell, in model coordinates.
+public interface StringValueProvider {
+
+    /// The converter of the cell, never `null`.
+    StringValue getStringValue(int row, int column);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/StringValueRegistry.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/StringValueRegistry.java
new file mode 100644
index 00000000000..b07e358d1d0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/StringValueRegistry.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValues;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// The converters of a table's cells: one set for a column wins over one
+/// set for the column's class, which wins over the value's `toString`.
+///
+/// A class is matched exactly, then by the first registered class it can
+/// be assigned to; a device class cannot be asked for its superclass.
+public final class StringValueRegistry implements StringValueProvider {
+
+    private final Map<Integer, StringValue> perColumn = new HashMap<Integer, StringValue>();
+    private final Map<Class<?>, StringValue> perClass = new HashMap<Class<?>, StringValue>();
+    private final List<Class<?>> classOrder = new ArrayList<Class<?>>();
+    private final Map<Integer, Class<?>> classPerColumn = new HashMap<Integer, Class<?>>();
+
+    public StringValueRegistry() {
+    }
+
+    @Override
+    public StringValue getStringValue(int row, int column) {
+        StringValue sv = perColumn.get(Integer.valueOf(column));
+        if (sv == null) {
+            sv = getStringValue(classPerColumn.get(Integer.valueOf(column)));
+        }
+        return sv != null ? sv : StringValues.TO_STRING;
+    }
+
+    /// Sets the converter of a column; `null` removes it.
+    public void setStringValue(StringValue sv, int column) {
+        if (sv == null) {
+            perColumn.remove(Integer.valueOf(column));
+        } else {
+            perColumn.put(Integer.valueOf(column), sv);
+        }
+    }
+
+    public void clearColumnStringValues() {
+        perColumn.clear();
+    }
+
+    /// Sets the converter of a class; `null` removes it.
+    public void setStringValue(StringValue sv, Class<?> clazz) {
+        if (clazz == null) {
+            return;
+        }
+        if (sv == null) {
+            perClass.remove(clazz);
+            classOrder.remove(clazz);
+        } else {
+            if (perClass.put(clazz, sv) == null) {
+                classOrder.add(clazz);
+            }
+        }
+    }
+
+    /// The converter registered for a class or for one it extends or
+    /// implements, or `null`.
+    public StringValue getStringValue(Class<?> clazz) {
+        if (clazz == null) {
+            return null;
+        }
+        StringValue sv = perClass.get(clazz);
+        if (sv != null) {
+            return sv;
+        }
+        Class<?> best = null;
+        for (int i = 0; i < classOrder.size(); i++) {
+            Class<?> c = classOrder.get(i);
+            if (c != Object.class && c.isAssignableFrom(clazz) && (best == null || best.isAssignableFrom(c))) {
+                best = c;
+            }
+        }
+        if (best == null) {
+            return perClass.get(Object.class);
+        }
+        return perClass.get(best);
+    }
+
+    /// Says which class the values of a column have; `null` forgets it.
+    public void setColumnClass(Class<?> clazz, int column) {
+        if (clazz == null) {
+            classPerColumn.remove(Integer.valueOf(column));
+        } else {
+            classPerColumn.put(Integer.valueOf(column), clazz);
+        }
+    }
+
+    /// Replaces the classes of all columns; `null` forgets them all.
+    public void setColumnClasses(Map<Integer, Class<?>> classPerColumn) {
+        this.classPerColumn.clear();
+        if (classPerColumn != null) {
+            this.classPerColumn.putAll(classPerColumn);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/TableSortController.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/TableSortController.java
new file mode 100644
index 00000000000..c29809e8ead
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/TableSortController.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
+
+import com.codename1.desktopcompat.javax.swing.table.TableModel;
+import java.util.Comparator;
+
+/// The sort controller of a table.
+///
+/// A column is compared by the comparator set for it; else, when the
+/// model declares its class comparable, by the values; else by the
+/// strings the table shows for them.
+public class TableSortController<M extends TableModel> extends DefaultSortController<M> {
+
+    private M tableModel;
+
+    public TableSortController() {
+        this(null);
+    }
+
+    public TableSortController(M model) {
+        super();
+        setModel(model);
+    }
+
+    public void setModel(M model) {
+        tableModel = model;
+        setModelWrapper(new Wrapper());
+    }
+
+    private boolean cn1Comparable(int column) {
+        Class<?> c = tableModel == null ? null : tableModel.getColumnClass(column);
+        return c != null && Comparable.class.isAssignableFrom(c);
+    }
+
+    @Override
+    public Comparator<?> getComparator(int column) {
+        Comparator<?> set = cn1Comparator(column);
+        if (set != null) {
+            return set;
+        }
+        return COMPARABLE_COMPARATOR;
+    }
+
+    @Override
+    protected boolean useToString(int column) {
+        return cn1Comparator(column) == null && !cn1Comparable(column);
+    }
+
+    private final class Wrapper extends ModelWrapper<M, Integer> {
+
+        @Override
+        public M getModel() {
+            return tableModel;
+        }
+
+        @Override
+        public int getColumnCount() {
+            return tableModel == null ? 0 : tableModel.getColumnCount();
+        }
+
+        @Override
+        public int getRowCount() {
+            return tableModel == null ? 0 : tableModel.getRowCount();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return tableModel.getValueAt(row, column);
+        }
+
+        @Override
+        public String getStringValueAt(int row, int column) {
+            String s = getStringValueProvider().getStringValue(row, column).getString(getValueAt(row, column));
+            return s == null ? "" : s;
+        }
+
+        @Override
+        public Integer getIdentifier(int row) {
+            return Integer.valueOf(row);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/package-info.java
new file mode 100644
index 00000000000..388b065a45a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/sort/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Sorting and filtering as SwingX components drive it: a
+/// [SortController] is a row sorter that can be switched off as a whole,
+/// cycles a column through sort orders, and compares and filters by the
+/// strings the component shows.
+///
+/// The regular expression filters are absent, because a device has no
+/// `java.util.regex`.
+package com.codename1.desktopcompat.org.jdesktop.swingx.sort;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnControlButton.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnControlButton.java
new file mode 100644
index 00000000000..de16ece1de7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnControlButton.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JCheckBoxMenuItem;
+import com.codename1.desktopcompat.javax.swing.JMenuItem;
+import com.codename1.desktopcompat.javax.swing.JPopupMenu;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTable;
+import java.util.List;
+
+/// The button a `JXTable` offers as its column control. A press opens
+/// a popup menu with a check box item per hideable column, which shows
+/// or hides that column, and below them items that pack all columns and
+/// switch horizontal scrolling.
+///
+/// The table records this button as the upper trailing corner of its
+/// scroll pane, but the layer's scroll pane shows no corners: put the
+/// button, which [JXTable#getColumnControl()] answers, into a tool bar
+/// or wherever the application has room for it.
+///
+/// The last visible column cannot be hidden from the menu. The menu's
+/// texts are English.
+public class ColumnControlButton extends JButton {
+
+    public static final String COLUMN_CONTROL_MARKER = "column.";
+    public static final String COLUMN_CONTROL_BUTTON_ICON_KEY = "ColumnControlButton.actionIcon";
+    public static final String COLUMN_CONTROL_BUTTON_MARGIN_KEY = "ColumnControlButton.margin";
+
+    private final JXTable cn1Table;
+    private JPopupMenu cn1Popup;
+    private boolean cn1AdditionalActions = true;
+
+    public ColumnControlButton(JXTable table) {
+        this(table, null);
+    }
+
+    public ColumnControlButton(JXTable table, Icon icon) {
+        super();
+        cn1Table = table;
+        if (icon != null) {
+            setIcon(icon);
+        } else {
+            setText("...");
+        }
+        setFocusable(false);
+        addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                togglePopup();
+            }
+        });
+    }
+
+    /// Opens the menu under the button, or closes it when it is open.
+    public void togglePopup() {
+        if (cn1Popup != null && cn1Popup.isVisible()) {
+            cn1Popup.setVisible(false);
+            return;
+        }
+        if (!canControl()) {
+            return;
+        }
+        cn1Popup = cn1BuildPopup();
+        cn1Popup.show(this, 0, getHeight());
+    }
+
+    public boolean getAdditionalActionsVisible() {
+        return cn1AdditionalActions;
+    }
+
+    /// Whether the menu has the pack and scroll items below the columns.
+    public void setAdditionalActionsVisible(boolean additionalActionsVisible) {
+        boolean old = cn1AdditionalActions;
+        cn1AdditionalActions = additionalActionsVisible;
+        firePropertyChange("additionalActionsVisible", old, additionalActionsVisible);
+    }
+
+    /// Whether there is a table whose columns can be controlled.
+    protected boolean canControl() {
+        return cn1Table != null;
+    }
+
+    /// The menu as it would open now.
+    JPopupMenu cn1BuildPopup() {
+        JPopupMenu menu = new JPopupMenu();
+        List<TableColumn> columns = cn1Table.getColumns(true);
+        for (int i = 0; i < columns.size(); i++) {
+            TableColumn c = columns.get(i);
+            if (!(c instanceof TableColumnExt)) {
+                continue;
+            }
+            final TableColumnExt column = (TableColumnExt) c;
+            if (!column.isHideable()) {
+                continue;
+            }
+            String title = column.getTitle();
+            final JCheckBoxMenuItem item = new JCheckBoxMenuItem(title != null ? title : "", column.isVisible());
+            item.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    boolean show = item.getState();
+                    if (!show && column.isVisible() && cn1Table.getColumnCount() <= 1) {
+                        item.setState(true);
+                        return;
+                    }
+                    column.setVisible(show);
+                }
+            });
+            menu.add(item);
+        }
+        if (cn1AdditionalActions) {
+            if (menu.getComponentCount() > 0) {
+                menu.addSeparator();
+            }
+            final JCheckBoxMenuItem scroll = new JCheckBoxMenuItem("Horizontal Scroll",
+                    cn1Table.isHorizontalScrollEnabled());
+            scroll.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    cn1Table.setHorizontalScrollEnabled(scroll.getState());
+                }
+            });
+            menu.add(scroll);
+            JMenuItem packAll = new JMenuItem("Pack All Columns");
+            packAll.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    cn1Table.packAll();
+                }
+            });
+            menu.add(packAll);
+            JMenuItem packSelected = new JMenuItem("Pack Selected Column");
+            packSelected.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    cn1Table.packSelected();
+                }
+            });
+            menu.add(packSelected);
+        }
+        return menu;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnFactory.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnFactory.java
new file mode 100644
index 00000000000..f1634be154c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnFactory.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.table.JTableHeader;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.javax.swing.table.TableModel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTable;
+
+/// Makes the columns of a `JXTable`, gives them their header from the
+/// model, sizes them from a prototype value and packs them to their
+/// content.
+///
+/// A table uses the shared instance unless it is given its own; replace
+/// the shared instance to change how every table makes its columns.
+public class ColumnFactory {
+
+    private static ColumnFactory columnFactory;
+
+    private int packMargin = 4;
+
+    public ColumnFactory() {
+    }
+
+    public static ColumnFactory getInstance() {
+        if (columnFactory == null) {
+            columnFactory = new ColumnFactory();
+        }
+        return columnFactory;
+    }
+
+    public static void setInstance(ColumnFactory factory) {
+        columnFactory = factory;
+    }
+
+    /// Makes the column of a model column; `null` when
+    /// [#createTableColumn(int)] makes none.
+    public TableColumnExt createAndConfigureTableColumn(TableModel model, int modelIndex) {
+        TableColumnExt column = createTableColumn(modelIndex);
+        if (column != null) {
+            configureTableColumn(model, column);
+        }
+        return column;
+    }
+
+    public TableColumnExt createTableColumn(int modelIndex) {
+        return new TableColumnExt(modelIndex);
+    }
+
+    /// Gives the column the model's name of it as its header.
+    public void configureTableColumn(TableModel model, TableColumnExt columnExt) {
+        int index = columnExt.getModelIndex();
+        if (index < 0 || index >= model.getColumnCount()) {
+            throw new IllegalStateException("column must have valid modelIndex");
+        }
+        columnExt.setHeaderValue(model.getColumnName(index));
+    }
+
+    /// Gives a column with a prototype value the preferred width that
+    /// value, or the header if it is wider, needs. A column without one
+    /// is left alone.
+    public void configureColumnWidths(JXTable table, TableColumnExt columnExt) {
+        int prototype = calcPrototypeWidth(table, columnExt);
+        if (prototype < 0) {
+            return;
+        }
+        int width = Math.max(prototype, calcHeaderWidth(table, columnExt));
+        columnExt.setPreferredWidth(width + 2 * getDefaultPackMargin());
+    }
+
+    /// The preferred widths of the columns the table wants to show
+    /// added up: its visible column count, or all of them when that is
+    /// negative.
+    public int getPreferredScrollableViewportWidth(JXTable table) {
+        int count = table.getColumnCount();
+        int wanted = table.getVisibleColumnCount();
+        if (wanted >= 0 && wanted < count) {
+            count = wanted;
+        }
+        int w = 0;
+        for (int i = 0; i < count; i++) {
+            w += table.getColumn(i).getPreferredWidth();
+        }
+        if (wanted > table.getColumnCount()) {
+            w += (wanted - table.getColumnCount()) * 75;
+        }
+        return w;
+    }
+
+    /// The width the column's header wants, 0 without a header renderer.
+    protected int calcHeaderWidth(JXTable table, TableColumnExt columnExt) {
+        TableCellRenderer renderer = getHeaderRenderer(table, columnExt);
+        if (renderer == null) {
+            return 0;
+        }
+        Component c = renderer.getTableCellRendererComponent(table, columnExt.getHeaderValue(), false, false, -1,
+                -1);
+        return c != null ? c.getPreferredSize().width : 0;
+    }
+
+    /// The width the column's prototype value wants, -1 without one.
+    protected int calcPrototypeWidth(JXTable table, TableColumnExt columnExt) {
+        Object prototype = columnExt.getPrototypeValue();
+        if (prototype == null) {
+            return -1;
+        }
+        TableCellRenderer renderer = getCellRenderer(table, columnExt);
+        if (renderer == null) {
+            return -1;
+        }
+        Component c = renderer.getTableCellRendererComponent(table, prototype, false, false, -1, -1);
+        return c != null ? c.getPreferredSize().width : -1;
+    }
+
+    /// The renderer of the column's cells: the table's choice for a
+    /// visible column, else the column's own or the default one of the
+    /// model column's class.
+    protected TableCellRenderer getCellRenderer(JXTable table, TableColumnExt columnExt) {
+        int view = table.convertColumnIndexToView(columnExt.getModelIndex());
+        if (view >= 0) {
+            return table.getCellRenderer(0, view);
+        }
+        TableCellRenderer renderer = columnExt.getCellRenderer();
+        if (renderer == null) {
+            int model = columnExt.getModelIndex();
+            Class<?> c = model >= 0 && model < table.getModel().getColumnCount()
+                    ? table.getModel().getColumnClass(model) : Object.class;
+            renderer = table.getDefaultRenderer(c);
+        }
+        return renderer;
+    }
+
+    protected TableCellRenderer getHeaderRenderer(JXTable table, TableColumnExt columnExt) {
+        TableCellRenderer renderer = columnExt.getHeaderRenderer();
+        if (renderer == null) {
+            JTableHeader header = table.getTableHeader();
+            if (header != null) {
+                renderer = header.getDefaultRenderer();
+            }
+        }
+        return renderer;
+    }
+
+    /// Sets the preferred width of a visible column to what its header
+    /// and all of its cells need, plus `margin` on both sides, and at
+    /// most `max`. A negative margin is the default one; a `max` of -1
+    /// is no limit.
+    public void packColumn(JXTable table, TableColumnExt columnExt, int margin, int max) {
+        if (!columnExt.isVisible()) {
+            throw new IllegalStateException("column must be visible to pack");
+        }
+        int column = cn1ViewIndex(table, columnExt);
+        if (column < 0) {
+            return;
+        }
+        int width = calcHeaderWidth(table, columnExt);
+        TableCellRenderer renderer = getCellRenderer(table, columnExt);
+        if (renderer != null) {
+            int rows = getRowCount(table);
+            for (int r = 0; r < rows; r++) {
+                Component c = renderer.getTableCellRendererComponent(table, table.getValueAt(r, column), false,
+                        false, r, column);
+                if (c != null) {
+                    width = Math.max(width, c.getPreferredSize().width);
+                }
+            }
+        }
+        if (margin < 0) {
+            margin = getDefaultPackMargin();
+        }
+        width += 2 * margin;
+        if (max != -1 && width > max) {
+            width = max;
+        }
+        columnExt.setPreferredWidth(width);
+    }
+
+    private static int cn1ViewIndex(JTable table, TableColumn column) {
+        for (int i = 0; i < table.getColumnCount(); i++) {
+            if (table.getColumnModel().getColumn(i) == column) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /// The number of rows measured when packing.
+    protected int getRowCount(JXTable table) {
+        return table.getRowCount();
+    }
+
+    public int getDefaultPackMargin() {
+        return packMargin;
+    }
+
+    public void setDefaultPackMargin(int margin) {
+        this.packMargin = margin;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/DefaultTableColumnModelExt.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/DefaultTableColumnModelExt.java
new file mode 100644
index 00000000000..9ae29c27bac
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/DefaultTableColumnModelExt.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
+
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableColumnModel;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.TableColumnModelExtListener;
+import java.util.ArrayList;
+import java.util.List;
+
+/// The column model of a `JXTable`: hiding a [TableColumnExt] takes it
+/// out of the visible columns, as a removal the listeners see, and
+/// showing it again puts it back where it was among the others.
+///
+/// While a listener is told of such a removal or addition,
+/// [#isRemovedToInvisibleEvent(int)] or
+/// [#isAddedFromInvisibleEvent(int)] answers `true`.
+public class DefaultTableColumnModelExt extends DefaultTableColumnModel implements TableColumnModelExt {
+
+    /// Every column, hidden ones included, in order.
+    private final List<TableColumn> cn1All = new ArrayList<TableColumn>();
+    private boolean cn1Hiding;
+    private boolean cn1Showing;
+
+    private final PropertyChangeListener cn1Watch = new PropertyChangeListener() {
+        @Override
+        public void propertyChange(PropertyChangeEvent evt) {
+            Object source = evt.getSource();
+            if ("visible".equals(evt.getPropertyName()) && source instanceof TableColumnExt) {
+                TableColumnExt column = (TableColumnExt) source;
+                if (column.isVisible()) {
+                    moveToVisible(column);
+                } else {
+                    moveToInvisible(column);
+                }
+            }
+            fireColumnPropertyChange(evt);
+        }
+    };
+
+    public DefaultTableColumnModelExt() {
+        super();
+    }
+
+    @Override
+    public List<TableColumn> getColumns(boolean includeHidden) {
+        if (includeHidden) {
+            return new ArrayList<TableColumn>(cn1All);
+        }
+        return new ArrayList<TableColumn>(tableColumns);
+    }
+
+    @Override
+    public int getColumnCount(boolean includeHidden) {
+        return includeHidden ? cn1All.size() : getColumnCount();
+    }
+
+    @Override
+    public TableColumnExt getColumnExt(Object identifier) {
+        if (identifier == null) {
+            return null;
+        }
+        for (int i = 0; i < cn1All.size(); i++) {
+            TableColumn c = cn1All.get(i);
+            if (c instanceof TableColumnExt && identifier.equals(c.getIdentifier())) {
+                return (TableColumnExt) c;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public TableColumnExt getColumnExt(int columnIndex) {
+        if (columnIndex < 0 || columnIndex >= getColumnCount()) {
+            return null;
+        }
+        TableColumn c = getColumn(columnIndex);
+        return c instanceof TableColumnExt ? (TableColumnExt) c : null;
+    }
+
+    /// Whether a removal the listeners are being told of right now is a
+    /// column being hidden.
+    public boolean isRemovedToInvisibleEvent(int oldIndex) {
+        return cn1Hiding;
+    }
+
+    /// Whether an addition the listeners are being told of right now is
+    /// a hidden column being shown.
+    public boolean isAddedFromInvisibleEvent(int newIndex) {
+        return cn1Showing;
+    }
+
+    private static boolean cn1Hidden(TableColumn c) {
+        return c instanceof TableColumnExt && !((TableColumnExt) c).isVisible();
+    }
+
+    @Override
+    public void removeColumn(TableColumn column) {
+        if (!cn1All.remove(column)) {
+            return;
+        }
+        column.removePropertyChangeListener(cn1Watch);
+        super.removeColumn(column);
+    }
+
+    /// Adds a column at the end. One that is hidden already is kept
+    /// without becoming visible.
+    @Override
+    public void addColumn(TableColumn aColumn) {
+        if (aColumn == null) {
+            throw new IllegalArgumentException("Object is null");
+        }
+        cn1All.add(aColumn);
+        aColumn.addPropertyChangeListener(cn1Watch);
+        if (!cn1Hidden(aColumn)) {
+            super.addColumn(aColumn);
+        }
+    }
+
+    /// Moves a visible column among the visible ones; the hidden ones
+    /// keep their places between them.
+    @Override
+    public void moveColumn(int columnIndex, int newIndex) {
+        super.moveColumn(columnIndex, newIndex);
+        int next = 0;
+        for (int i = 0; i < cn1All.size(); i++) {
+            if (!cn1Hidden(cn1All.get(i)) && next < tableColumns.size()) {
+                cn1All.set(i, tableColumns.elementAt(next++));
+            }
+        }
+    }
+
+    protected void moveToInvisible(TableColumnExt col) {
+        if (!tableColumns.contains(col)) {
+            return;
+        }
+        cn1Hiding = true;
+        try {
+            super.removeColumn(col);
+        } finally {
+            cn1Hiding = false;
+        }
+    }
+
+    protected void moveToVisible(TableColumnExt col) {
+        if (tableColumns.contains(col) || !cn1All.contains(col)) {
+            return;
+        }
+        cn1Showing = true;
+        try {
+            super.addColumn(col);
+        } finally {
+            cn1Showing = false;
+        }
+        int target = 0;
+        for (int i = 0; i < cn1All.size(); i++) {
+            TableColumn c = cn1All.get(i);
+            if (c == col) {
+                break;
+            }
+            if (!cn1Hidden(c)) {
+                target++;
+            }
+        }
+        int last = getColumnCount() - 1;
+        if (target < last) {
+            super.moveColumn(last, target);
+        }
+    }
+
+    protected EventListenerList getEventListenerList() {
+        return listenerList;
+    }
+
+    @Override
+    public void propertyChange(PropertyChangeEvent evt) {
+        super.propertyChange(evt);
+    }
+
+    /// Tells the listeners that are [TableColumnModelExtListener]s of a
+    /// column's property.
+    protected void fireColumnPropertyChange(PropertyChangeEvent evt) {
+        TableColumnModelListener[] listeners = getColumnModelListeners();
+        for (int i = listeners.length - 1; i >= 0; i--) {
+            if (listeners[i] instanceof TableColumnModelExtListener) {
+                ((TableColumnModelExtListener) listeners[i]).columnPropertyChange(evt);
+            }
+        }
+    }
+
+    @Override
+    public void addColumnModelListener(TableColumnModelListener x) {
+        super.addColumnModelListener(x);
+    }
+
+    @Override
+    public void removeColumnModelListener(TableColumnModelListener x) {
+        super.removeColumnModelListener(x);
+    }
+
+    public TableColumnModelExtListener[] getTableColumnModelExtListeners() {
+        TableColumnModelListener[] listeners = getColumnModelListeners();
+        List<TableColumnModelExtListener> out = new ArrayList<TableColumnModelExtListener>();
+        for (int i = 0; i < listeners.length; i++) {
+            if (listeners[i] instanceof TableColumnModelExtListener) {
+                out.add((TableColumnModelExtListener) listeners[i]);
+            }
+        }
+        return out.toArray(new TableColumnModelExtListener[out.size()]);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/TableColumnExt.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/TableColumnExt.java
new file mode 100644
index 00000000000..afb85896695
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/TableColumnExt.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.table.TableCellEditor;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.CompoundHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.Highlighter;
+import java.util.Comparator;
+import java.util.Hashtable;
+
+/// A table column that can be hidden, has switches for sorting and
+/// editing, a comparator, a prototype value to size it by, client
+/// properties and highlighters that apply to its cells only.
+///
+/// Every property tells the column's property change listeners. The
+/// tool tip text is recorded and not shown.
+public class TableColumnExt extends TableColumn {
+
+    protected boolean visible = true;
+    protected boolean hideable = true;
+    protected Object prototypeValue;
+    protected Comparator<?> comparator;
+    protected boolean sortable = true;
+    protected boolean editable = true;
+    protected Hashtable<Object, Object> clientProperties;
+    protected CompoundHighlighter compoundHighlighter;
+
+    private String toolTipText;
+    private ChangeListener highlighterChangeListener;
+
+    public TableColumnExt() {
+        this(0);
+    }
+
+    public TableColumnExt(int modelIndex) {
+        this(modelIndex, 75);
+    }
+
+    public TableColumnExt(int modelIndex, int width) {
+        this(modelIndex, width, null, null);
+    }
+
+    public TableColumnExt(int modelIndex, int width, TableCellRenderer cellRenderer, TableCellEditor cellEditor) {
+        super(modelIndex, width, cellRenderer, cellEditor);
+    }
+
+    /// Makes a column with the properties of another.
+    public TableColumnExt(TableColumnExt columnExt) {
+        this(columnExt.getModelIndex(), columnExt.getWidth(), columnExt.getCellRenderer(),
+                columnExt.getCellEditor());
+        copyFrom(columnExt);
+    }
+
+    // ------------------------------------------------------------ highlighters
+
+    public void setHighlighters(Highlighter... highlighters) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().setHighlighters(highlighters);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public Highlighter[] getHighlighters() {
+        return getCompoundHighlighter().getHighlighters();
+    }
+
+    public void addHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().addHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    public void removeHighlighter(Highlighter highlighter) {
+        Highlighter[] old = getHighlighters();
+        getCompoundHighlighter().removeHighlighter(highlighter);
+        firePropertyChange("highlighters", old, getHighlighters());
+    }
+
+    protected CompoundHighlighter getCompoundHighlighter() {
+        if (compoundHighlighter == null) {
+            compoundHighlighter = new CompoundHighlighter();
+            compoundHighlighter.addChangeListener(getHighlighterChangeListener());
+        }
+        return compoundHighlighter;
+    }
+
+    protected ChangeListener getHighlighterChangeListener() {
+        if (highlighterChangeListener == null) {
+            highlighterChangeListener = createHighlighterChangeListener();
+        }
+        return highlighterChangeListener;
+    }
+
+    /// A listener that reports a highlighter's change as the property
+    /// `highlighterStateChanged`.
+    protected ChangeListener createHighlighterChangeListener() {
+        return new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                firePropertyChange("highlighterStateChanged", Boolean.FALSE, Boolean.TRUE);
+            }
+        };
+    }
+
+    /// Applies the column's highlighters to a cell's component.
+    public Component cn1Highlight(Component stamp, ComponentAdapter adapter) {
+        if (compoundHighlighter == null) {
+            return stamp;
+        }
+        return compoundHighlighter.highlight(stamp, adapter);
+    }
+
+    // ------------------------------------------------------------ properties
+
+    /// A column whose minimum and maximum widths are the same cannot be
+    /// resized whatever the flag says.
+    @Override
+    public boolean getResizable() {
+        return super.getResizable() && getMinWidth() < getMaxWidth();
+    }
+
+    public void setEditable(boolean editable) {
+        boolean old = this.editable;
+        this.editable = editable;
+        firePropertyChange("editable", Boolean.valueOf(old), Boolean.valueOf(editable));
+    }
+
+    public boolean isEditable() {
+        return editable;
+    }
+
+    /// Sets a value typical of the column's widest cell, used to size
+    /// the column.
+    public void setPrototypeValue(Object value) {
+        Object old = prototypeValue;
+        prototypeValue = value;
+        firePropertyChange("prototypeValue", old, value);
+    }
+
+    public Object getPrototypeValue() {
+        return prototypeValue;
+    }
+
+    public void setComparator(Comparator<?> comparator) {
+        Comparator<?> old = this.comparator;
+        this.comparator = comparator;
+        firePropertyChange("comparator", old, comparator);
+    }
+
+    public Comparator<?> getComparator() {
+        return comparator;
+    }
+
+    public void setSortable(boolean sortable) {
+        boolean old = this.sortable;
+        this.sortable = sortable;
+        firePropertyChange("sortable", Boolean.valueOf(old), Boolean.valueOf(sortable));
+    }
+
+    public boolean isSortable() {
+        return sortable;
+    }
+
+    public void setToolTipText(String toolTipText) {
+        String old = this.toolTipText;
+        this.toolTipText = toolTipText;
+        firePropertyChange("toolTipText", old, toolTipText);
+    }
+
+    public String getToolTipText() {
+        return toolTipText;
+    }
+
+    /// Sets the header value.
+    public void setTitle(String title) {
+        setHeaderValue(title);
+    }
+
+    /// The header value's string, or `null`.
+    public String getTitle() {
+        Object header = getHeaderValue();
+        return header != null ? header.toString() : null;
+    }
+
+    /// Shows or hides the column. A column model that is a
+    /// [TableColumnModelExt] takes a hidden column out of the columns
+    /// its table sees and keeps it for later.
+    public void setVisible(boolean visible) {
+        boolean old = this.visible;
+        this.visible = visible;
+        firePropertyChange("visible", Boolean.valueOf(old), Boolean.valueOf(visible));
+    }
+
+    public boolean isVisible() {
+        return visible;
+    }
+
+    /// Says whether the user may hide the column. The layer has no
+    /// control that hides columns, so this is recorded only.
+    public void setHideable(boolean hideable) {
+        boolean old = this.hideable;
+        this.hideable = hideable;
+        firePropertyChange("hideable", Boolean.valueOf(old), Boolean.valueOf(hideable));
+    }
+
+    public boolean isHideable() {
+        return hideable;
+    }
+
+    /// Sets a client property; `null` removes it.
+    public void putClientProperty(Object key, Object value) {
+        if (key == null) {
+            throw new IllegalArgumentException("null key");
+        }
+        if (value == null && getClientProperty(key) == null) {
+            return;
+        }
+        Object old = getClientProperty(key);
+        if (value == null) {
+            clientProperties.remove(key);
+        } else {
+            if (clientProperties == null) {
+                clientProperties = new Hashtable<Object, Object>();
+            }
+            clientProperties.put(key, value);
+        }
+        firePropertyChange(key.toString(), old, value);
+    }
+
+    public Object getClientProperty(Object key) {
+        return key == null || clientProperties == null ? null : clientProperties.get(key);
+    }
+
+    /// Takes over the properties of another column, client properties
+    /// included; highlighters are not copied.
+    protected void copyFrom(TableColumnExt original) {
+        setEditable(original.isEditable());
+        setHeaderValue(original.getHeaderValue());
+        setToolTipText(original.getToolTipText());
+        setIdentifier(original.getIdentifier());
+        setMaxWidth(original.getMaxWidth());
+        setMinWidth(original.getMinWidth());
+        setPreferredWidth(original.getPreferredWidth());
+        setPrototypeValue(original.getPrototypeValue());
+        setResizable(original.isResizable);
+        setVisible(original.isVisible());
+        setSortable(original.isSortable());
+        setComparator(original.getComparator());
+        setHideable(original.isHideable());
+        setHeaderRenderer(original.getHeaderRenderer());
+        copyClientPropertiesFrom(original);
+    }
+
+    protected void copyClientPropertiesFrom(TableColumnExt original) {
+        if (original.clientProperties == null) {
+            return;
+        }
+        Object[] keys = original.clientProperties.keySet().toArray();
+        for (int i = 0; i < keys.length; i++) {
+            putClientProperty(keys[i], original.getClientProperty(keys[i]));
+        }
+    }
+
+    /// Tells the property change listeners, unless both values are the
+    /// same non-null value.
+    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
+        if (oldValue != null && oldValue.equals(newValue)) {
+            return;
+        }
+        if (oldValue == null && newValue == null) {
+            return;
+        }
+        PropertyChangeListener[] listeners = getPropertyChangeListeners();
+        if (listeners.length == 0) {
+            return;
+        }
+        PropertyChangeEvent event = new PropertyChangeEvent(this, propertyName, oldValue, newValue);
+        for (int i = 0; i < listeners.length; i++) {
+            listeners[i].propertyChange(event);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/TableColumnModelExt.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/TableColumnModelExt.java
new file mode 100644
index 00000000000..b8ba2c803f0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/TableColumnModelExt.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
+
+import com.codename1.desktopcompat.javax.swing.event.TableColumnModelListener;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.javax.swing.table.TableColumnModel;
+import java.util.List;
+
+/// A column model that keeps columns that are hidden. The methods of
+/// `TableColumnModel` see the visible columns only.
+public interface TableColumnModelExt extends TableColumnModel {
+
+    /// The number of columns, hidden ones included when asked for.
+    int getColumnCount(boolean includeHidden);
+
+    /// The columns in their order, hidden ones included when asked for.
+    List<TableColumn> getColumns(boolean includeHidden);
+
+    /// The first column with the identifier, visible or hidden, when it
+    /// is a [TableColumnExt]; else `null`.
+    TableColumnExt getColumnExt(Object identifier);
+
+    /// The visible column at the index when it is a [TableColumnExt];
+    /// `null` for another kind of column or an index out of range.
+    TableColumnExt getColumnExt(int columnIndex);
+
+    /// Adds a listener; one that is a
+    /// `TableColumnModelExtListener` also hears of column properties.
+    @Override
+    void addColumnModelListener(TableColumnModelListener x);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/package-info.java
new file mode 100644
index 00000000000..d63438a0411
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/package-info.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The columns of a `JXTable`: a column that can be hidden, carries
+/// sorting and editing switches, a prototype value and highlighters of
+/// its own; the column model that keeps the hidden ones; and the factory
+/// that makes, configures and packs columns.
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/tree/TreeModelSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/tree/TreeModelSupport.java
new file mode 100644
index 00000000000..c2af6da5ecb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/tree/TreeModelSupport.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.tree;
+
+import com.codename1.desktopcompat.javax.swing.event.EventListenerList;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import com.codename1.desktopcompat.javax.swing.tree.TreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+
+/// Keeps the listeners of a tree model and sends them the model's
+/// events, each named for what happened to the model rather than for the
+/// event that says so.
+///
+/// The model is the source of every event. Listeners are told in the
+/// reverse of the order they were added in.
+public final class TreeModelSupport {
+
+    protected EventListenerList listeners;
+
+    private final TreeModel treeModel;
+
+    /// Support for the listeners of `model`, which must not be `null`.
+    public TreeModelSupport(TreeModel model) {
+        if (model == null) {
+            throw new NullPointerException("model must not be null");
+        }
+        listeners = new EventListenerList();
+        treeModel = model;
+    }
+
+    /// The model has another root, or everything below its root changed.
+    /// A model without a root sends an event without a path.
+    public void fireNewRoot() {
+        Object root = treeModel.getRoot();
+        fireTreeStructureChanged(root == null ? null : new TreePath(root));
+    }
+
+    /// The node at the end of the path became a leaf or stopped being
+    /// one. Sent as a change of structure below the node, the only event
+    /// that makes a tree ask again.
+    public void firePathLeafStateChanged(TreePath path) {
+        fireTreeStructureChanged(path);
+    }
+
+    /// Everything below the node at the end of the path changed; `null`
+    /// for a model that has lost its root.
+    public void fireTreeStructureChanged(TreePath subTreePath) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        TreeModelEvent e = new TreeModelEvent(treeModel, subTreePath);
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].treeStructureChanged(e);
+        }
+    }
+
+    /// The node at the end of the path changed, but not its children.
+    /// For the root that is an event with the root's path and no
+    /// children; for any other node it names the node as a child of its
+    /// parent.
+    public void firePathChanged(TreePath path) {
+        Object node = path.getLastPathComponent();
+        TreePath parentPath = path.getParentPath();
+        if (parentPath == null) {
+            fireChildrenChanged(path, null, null);
+        } else {
+            Object parent = parentPath.getLastPathComponent();
+            fireChildChanged(parentPath, treeModel.getIndexOfChild(parent, node), node);
+        }
+    }
+
+    /// One child of the node at the end of `parentPath` changed.
+    public void fireChildChanged(TreePath parentPath, int index, Object child) {
+        fireChildrenChanged(parentPath, new int[]{index}, new Object[]{child});
+    }
+
+    /// Children of the node at the end of `parentPath` changed; the
+    /// indices are in ascending order.
+    public void fireChildrenChanged(TreePath parentPath, int[] indices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        TreeModelEvent e = new TreeModelEvent(treeModel, parentPath, indices, children);
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].treeNodesChanged(e);
+        }
+    }
+
+    /// A child was added to the node at the end of `parentPath`, at
+    /// `index`.
+    public void fireChildAdded(TreePath parentPath, int index, Object child) {
+        fireChildrenAdded(parentPath, new int[]{index}, new Object[]{child});
+    }
+
+    /// A child that was at `index` was removed from the node at the end
+    /// of `parentPath`.
+    public void fireChildRemoved(TreePath parentPath, int index, Object child) {
+        fireChildrenRemoved(parentPath, new int[]{index}, new Object[]{child});
+    }
+
+    /// Children were added to the node at the end of `parentPath`; the
+    /// indices are where they are now, in ascending order.
+    public void fireChildrenAdded(TreePath parentPath, int[] indices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        TreeModelEvent e = new TreeModelEvent(treeModel, parentPath, indices, children);
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].treeNodesInserted(e);
+        }
+    }
+
+    /// Children were removed from the node at the end of `parentPath`;
+    /// the indices are where they were, in ascending order.
+    public void fireChildrenRemoved(TreePath parentPath, int[] indices, Object[] children) {
+        TreeModelListener[] ls = getTreeModelListeners();
+        if (ls.length == 0) {
+            return;
+        }
+        TreeModelEvent e = new TreeModelEvent(treeModel, parentPath, indices, children);
+        for (int i = 0; i < ls.length; i++) {
+            ls[i].treeNodesRemoved(e);
+        }
+    }
+
+    public void addTreeModelListener(TreeModelListener l) {
+        listeners.add(TreeModelListener.class, l);
+    }
+
+    public TreeModelListener[] getTreeModelListeners() {
+        return listeners.getListeners(TreeModelListener.class);
+    }
+
+    public void removeTreeModelListener(TreeModelListener l) {
+        listeners.remove(TreeModelListener.class, l);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/tree/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/tree/package-info.java
new file mode 100644
index 00000000000..db3ac33f562
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/tree/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Support for tree models: [TreeModelSupport] keeps a model's listeners
+/// and builds and sends its events.
+///
+/// The tree cell renderer and editor of this SwingX package, and its
+/// tree traversal utilities, are absent.
+package com.codename1.desktopcompat.org.jdesktop.swingx.tree;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/AbstractMutableTreeTableNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/AbstractMutableTreeTableNode.java
new file mode 100644
index 00000000000..e90d1fd6d8f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/AbstractMutableTreeTableNode.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreeNode;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+
+/// A mutable tree table node but for its columns: the parent, the list of
+/// children and the user object, kept consistent on both sides of every
+/// change.
+///
+/// A subclass says how many columns the node has and what is in them. As
+/// it is, no column is editable and setting a value does nothing.
+public abstract class AbstractMutableTreeTableNode implements MutableTreeTableNode {
+
+    protected MutableTreeTableNode parent;
+    protected final List<MutableTreeTableNode> children;
+    protected Object userObject;
+    protected boolean allowsChildren;
+
+    /// A node without a user object that takes children.
+    public AbstractMutableTreeTableNode() {
+        this(null);
+    }
+
+    /// A node that takes children.
+    public AbstractMutableTreeTableNode(Object userObject) {
+        this(userObject, true);
+    }
+
+    public AbstractMutableTreeTableNode(Object userObject, boolean allowsChildren) {
+        this.userObject = userObject;
+        this.allowsChildren = allowsChildren;
+        children = createChildrenList();
+    }
+
+    /// Makes the list the children are kept in; called once, while the
+    /// node is being constructed.
+    protected List<MutableTreeTableNode> createChildrenList() {
+        return new ArrayList<MutableTreeTableNode>();
+    }
+
+    /// Makes `child` the last child of this node.
+    public void add(MutableTreeTableNode child) {
+        insert(child, getChildCount());
+    }
+
+    /// Makes `child` the child at `index`, taking it from the parent it
+    /// had. A node that is a child of this one already is taken out
+    /// first, and `index` then counts one less.
+    @Override
+    public void insert(MutableTreeTableNode child, int index) {
+        if (!allowsChildren) {
+            throw new IllegalStateException("this node cannot accept children");
+        }
+        int at = index;
+        if (children.contains(child)) {
+            children.remove(child);
+            at--;
+        }
+        children.add(at, child);
+        if (child.getParent() != this) {
+            child.setParent(this);
+        }
+    }
+
+    @Override
+    public void remove(int index) {
+        children.remove(index).setParent(null);
+    }
+
+    /// Takes `node` out of the tree. A node that is another node's child
+    /// is taken from that one.
+    @Override
+    public void remove(MutableTreeTableNode node) {
+        children.remove(node);
+        node.setParent(null);
+    }
+
+    /// Takes this node out of its parent, which it must have.
+    @Override
+    public void removeFromParent() {
+        parent.remove(this);
+    }
+
+    /// Moves this node below `newParent`, as its last child, or out of
+    /// the tree for `null`.
+    @Override
+    public void setParent(MutableTreeTableNode newParent) {
+        if (newParent != null && !newParent.getAllowsChildren()) {
+            throw new IllegalArgumentException("newParent does not allow children");
+        }
+        if (parent != null && parent.getIndex(this) != -1) {
+            parent.remove(this);
+        }
+        parent = newParent;
+        if (parent != null && parent.getIndex(this) == -1) {
+            parent.insert(this, parent.getChildCount());
+        }
+    }
+
+    @Override
+    public Object getUserObject() {
+        return userObject;
+    }
+
+    @Override
+    public void setUserObject(Object object) {
+        userObject = object;
+    }
+
+    @Override
+    public TreeTableNode getChildAt(int childIndex) {
+        return children.get(childIndex);
+    }
+
+    /// The index of a child, or -1 for a node that is not one.
+    @Override
+    public int getIndex(TreeNode node) {
+        return children.indexOf(node);
+    }
+
+    @Override
+    public TreeTableNode getParent() {
+        return parent;
+    }
+
+    @Override
+    public Enumeration<? extends MutableTreeTableNode> children() {
+        return Collections.enumeration(children);
+    }
+
+    @Override
+    public boolean getAllowsChildren() {
+        return allowsChildren;
+    }
+
+    /// Says whether the node takes children. One that stops taking them
+    /// loses those it has.
+    public void setAllowsChildren(boolean allowsChildren) {
+        this.allowsChildren = allowsChildren;
+        if (!allowsChildren) {
+            children.clear();
+        }
+    }
+
+    @Override
+    public int getChildCount() {
+        return children.size();
+    }
+
+    /// A node without children is a leaf.
+    @Override
+    public boolean isLeaf() {
+        return getChildCount() == 0;
+    }
+
+    /// No column is editable.
+    @Override
+    public boolean isEditable(int column) {
+        return false;
+    }
+
+    /// Does nothing.
+    @Override
+    public void setValueAt(Object aValue, int column) {
+    }
+
+    /// The user object's text, or the empty string without one.
+    @Override
+    public String toString() {
+        return userObject == null ? "" : userObject.toString();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/AbstractTreeTableModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/AbstractTreeTableModel.java
new file mode 100644
index 00000000000..a9a80e89d04
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/AbstractTreeTableModel.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.org.jdesktop.swingx.tree.TreeModelSupport;
+
+/// The parts of a tree table model that do not depend on its nodes: the
+/// root, the listeners, and answers for a model that is not editable and
+/// whose columns are named like a spreadsheet's.
+///
+/// A subclass answers the tree questions -- child, child count, index of
+/// a child -- the column count and the value of a node in a column, and
+/// tells its listeners of changes through [#modelSupport].
+public abstract class AbstractTreeTableModel implements TreeTableModel {
+
+    /// The root, which may be `null` for an empty model.
+    protected Object root;
+
+    /// Keeps the listeners and sends the events.
+    protected TreeModelSupport modelSupport;
+
+    /// A model without a root.
+    public AbstractTreeTableModel() {
+        this(null);
+    }
+
+    public AbstractTreeTableModel(Object root) {
+        this.root = root;
+        this.modelSupport = new TreeModelSupport(this);
+    }
+
+    /// `Object` for every column.
+    @Override
+    public Class<?> getColumnClass(int column) {
+        return Object.class;
+    }
+
+    /// The name a spreadsheet gives the column: A to Z, then AA, AB and
+    /// so on.
+    @Override
+    public String getColumnName(int column) {
+        StringBuilder name = new StringBuilder();
+        int c = column;
+        while (c >= 0) {
+            name.insert(0, (char) ('A' + c % 26));
+            c = c / 26 - 1;
+        }
+        return name.toString();
+    }
+
+    /// The first column, or -1 for a model without columns.
+    @Override
+    public int getHierarchicalColumn() {
+        return getColumnCount() > 0 ? 0 : -1;
+    }
+
+    @Override
+    public Object getRoot() {
+        return root;
+    }
+
+    /// No cell is editable.
+    @Override
+    public boolean isCellEditable(Object node, int column) {
+        return false;
+    }
+
+    /// A node without children is a leaf.
+    @Override
+    public boolean isLeaf(Object node) {
+        return getChildCount(node) == 0;
+    }
+
+    /// Does nothing: the model is not editable.
+    @Override
+    public void setValueAt(Object value, Object node, int column) {
+    }
+
+    /// Does nothing: the model is not editable.
+    @Override
+    public void valueForPathChanged(TreePath path, Object newValue) {
+    }
+
+    @Override
+    public void addTreeModelListener(TreeModelListener l) {
+        modelSupport.addTreeModelListener(l);
+    }
+
+    @Override
+    public void removeTreeModelListener(TreeModelListener l) {
+        modelSupport.removeTreeModelListener(l);
+    }
+
+    public TreeModelListener[] getTreeModelListeners() {
+        return modelSupport.getTreeModelListeners();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/DefaultMutableTreeTableNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/DefaultMutableTreeTableNode.java
new file mode 100644
index 00000000000..0da728635cb
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/DefaultMutableTreeTableNode.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+/// A mutable tree table node with one column: its user object, which can
+/// be edited.
+public class DefaultMutableTreeTableNode extends AbstractMutableTreeTableNode {
+
+    public DefaultMutableTreeTableNode() {
+        super();
+    }
+
+    public DefaultMutableTreeTableNode(Object userObject) {
+        super(userObject);
+    }
+
+    public DefaultMutableTreeTableNode(Object userObject, boolean allowsChildren) {
+        super(userObject, allowsChildren);
+    }
+
+    /// The user object, whatever the column.
+    @Override
+    public Object getValueAt(int column) {
+        return getUserObject();
+    }
+
+    @Override
+    public int getColumnCount() {
+        return 1;
+    }
+
+    @Override
+    public boolean isEditable(int column) {
+        return true;
+    }
+
+    /// Makes the value the user object, whatever the column.
+    @Override
+    public void setValueAt(Object aValue, int column) {
+        setUserObject(aValue);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/DefaultTreeTableModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/DefaultTreeTableModel.java
new file mode 100644
index 00000000000..a625eeae544
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/DefaultTreeTableModel.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import java.util.ArrayList;
+import java.util.List;
+
+/// A tree table model over [TreeTableNode]s, with a list of column
+/// identifiers that names the columns and says how many there are.
+///
+/// A node may have fewer columns than the model: its cells in the others
+/// are empty and cannot be edited. Every method that takes a node wants
+/// one that is in this model, the root or below it, and throws an
+/// `IllegalArgumentException` for any other.
+///
+/// The list of identifiers is kept, not copied.
+public class DefaultTreeTableModel extends AbstractTreeTableModel {
+
+    protected List<?> columnIdentifiers;
+
+    /// A model without a root and without columns.
+    public DefaultTreeTableModel() {
+        this(null, new ArrayList<Object>());
+    }
+
+    /// A model with one unnamed column.
+    public DefaultTreeTableModel(TreeTableNode root) {
+        this(root, null);
+    }
+
+    /// A model with a column for each identifier; `null` is one unnamed
+    /// column.
+    public DefaultTreeTableModel(TreeTableNode root, List<?> columnNames) {
+        super(root);
+        columnIdentifiers = cn1Identifiers(columnNames);
+    }
+
+    private static List<?> cn1Identifiers(List<?> identifiers) {
+        if (identifiers != null) {
+            return identifiers;
+        }
+        List<Object> one = new ArrayList<Object>();
+        one.add(null);
+        return one;
+    }
+
+    /// Replaces the columns; `null` is one unnamed column. Listeners are
+    /// told that the whole model changed.
+    public void setColumnIdentifiers(List<?> columnIdentifiers) {
+        this.columnIdentifiers = cn1Identifiers(columnIdentifiers);
+        modelSupport.fireNewRoot();
+    }
+
+    @Override
+    public TreeTableNode getRoot() {
+        return root instanceof TreeTableNode ? (TreeTableNode) root : null;
+    }
+
+    /// Whether the node is the root or below it.
+    private boolean cn1Managed(Object node) {
+        if (!(node instanceof TreeTableNode)) {
+            return false;
+        }
+        TreeNode n = (TreeTableNode) node;
+        while (n != null) {
+            if (n == root) {
+                return true;
+            }
+            n = n.getParent();
+        }
+        return false;
+    }
+
+    private TreeTableNode cn1Cell(Object node, int column) {
+        if (!cn1Managed(node)) {
+            throw new IllegalArgumentException("node must be a valid node managed by this model");
+        }
+        if (column < 0 || column >= getColumnCount()) {
+            throw new IllegalArgumentException("column must be a valid index");
+        }
+        return (TreeTableNode) node;
+    }
+
+    /// The node's value in the column, or `null` in a column the node
+    /// does not have.
+    @Override
+    public Object getValueAt(Object node, int column) {
+        TreeTableNode n = cn1Cell(node, column);
+        return column >= n.getColumnCount() ? null : n.getValueAt(column);
+    }
+
+    /// Gives the node the value and tells the listeners that the node
+    /// changed; nothing in a column the node does not have.
+    @Override
+    public void setValueAt(Object value, Object node, int column) {
+        TreeTableNode n = cn1Cell(node, column);
+        if (column < n.getColumnCount()) {
+            n.setValueAt(value, column);
+            modelSupport.firePathChanged(new TreePath(getPathToRoot(n)));
+        }
+    }
+
+    @Override
+    public int getColumnCount() {
+        return columnIdentifiers.size();
+    }
+
+    /// The text of the column's identifier, or the spreadsheet name for a
+    /// column without one.
+    @Override
+    public String getColumnName(int column) {
+        Object id = column >= 0 && column < columnIdentifiers.size() ? columnIdentifiers.get(column) : null;
+        return id != null ? id.toString() : super.getColumnName(column);
+    }
+
+    @Override
+    public Object getChild(Object parent, int index) {
+        if (!cn1Managed(parent)) {
+            throw new IllegalArgumentException("parent must be a TreeTableNode managed by this model");
+        }
+        return ((TreeTableNode) parent).getChildAt(index);
+    }
+
+    @Override
+    public int getChildCount(Object parent) {
+        if (!cn1Managed(parent)) {
+            throw new IllegalArgumentException("parent must be a TreeTableNode managed by this model");
+        }
+        return ((TreeTableNode) parent).getChildCount();
+    }
+
+    /// The index of `child` in `parent`, or -1 when either is not a node
+    /// of this model.
+    @Override
+    public int getIndexOfChild(Object parent, Object child) {
+        if (cn1Managed(parent) && cn1Managed(child)) {
+            return ((TreeTableNode) parent).getIndex((TreeTableNode) child);
+        }
+        return -1;
+    }
+
+    /// Whether the node says the column is editable; never in a column
+    /// the node does not have.
+    @Override
+    public boolean isCellEditable(Object node, int column) {
+        TreeTableNode n = cn1Cell(node, column);
+        return column < n.getColumnCount() && n.isEditable(column);
+    }
+
+    @Override
+    public boolean isLeaf(Object node) {
+        if (!cn1Managed(node)) {
+            throw new IllegalArgumentException("node must be a TreeTableNode managed by this model");
+        }
+        return ((TreeTableNode) node).isLeaf();
+    }
+
+    /// The nodes from the root down to `aNode`, which must be in this
+    /// model.
+    public TreeTableNode[] getPathToRoot(TreeTableNode aNode) {
+        List<TreeTableNode> path = new ArrayList<TreeTableNode>();
+        TreeTableNode node = aNode;
+        while (node != root) {
+            path.add(0, node);
+            node = node.getParent();
+        }
+        path.add(0, node);
+        return path.toArray(new TreeTableNode[path.size()]);
+    }
+
+    /// Replaces the root, with `null` for an empty model, and tells the
+    /// listeners.
+    public void setRoot(TreeTableNode root) {
+        this.root = root;
+        modelSupport.fireNewRoot();
+    }
+
+    /// Puts `newChild` into `parent` at `index` and tells the listeners.
+    public void insertNodeInto(MutableTreeTableNode newChild, MutableTreeTableNode parent, int index) {
+        parent.insert(newChild, index);
+        modelSupport.fireChildAdded(new TreePath(getPathToRoot(parent)), index, newChild);
+    }
+
+    /// Takes `node` out of its parent, which it must have, and tells the
+    /// listeners.
+    public void removeNodeFromParent(MutableTreeTableNode node) {
+        TreeTableNode parent = node.getParent();
+        if (parent == null) {
+            throw new IllegalArgumentException("node does not have a parent.");
+        }
+        int index = parent.getIndex(node);
+        node.removeFromParent();
+        modelSupport.fireChildRemoved(new TreePath(getPathToRoot(parent)), index, node);
+    }
+
+    /// Makes `newValue` the user object of the node at the end of a path
+    /// that starts at this model's root, and tells the listeners.
+    @Override
+    public void valueForPathChanged(TreePath path, Object newValue) {
+        if (path.getPathComponent(0) != root) {
+            throw new IllegalArgumentException("invalid path");
+        }
+        Object last = path.getLastPathComponent();
+        if (last instanceof TreeTableNode) {
+            ((TreeTableNode) last).setUserObject(newValue);
+            modelSupport.firePathChanged(path);
+        }
+    }
+
+    /// Gives a node of this model another user object and tells the
+    /// listeners.
+    public void setUserObject(TreeTableNode node, Object userObject) {
+        node.setUserObject(userObject);
+        modelSupport.firePathChanged(new TreePath(getPathToRoot(node)));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/MutableTreeTableNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/MutableTreeTableNode.java
new file mode 100644
index 00000000000..1b64041506c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/MutableTreeTableNode.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import java.util.Enumeration;
+
+/// A tree table node whose children and parent can be changed.
+public interface MutableTreeTableNode extends TreeTableNode {
+
+    @Override
+    Enumeration<? extends MutableTreeTableNode> children();
+
+    /// Makes `child` the child at `index`, taking it from the parent it
+    /// had.
+    void insert(MutableTreeTableNode child, int index);
+
+    void remove(int index);
+
+    void remove(MutableTreeTableNode node);
+
+    void removeFromParent();
+
+    /// Moves this node below `newParent`, or out of the tree for `null`.
+    void setParent(MutableTreeTableNode newParent);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableModel.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableModel.java
new file mode 100644
index 00000000000..af676762b80
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableModel.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreeModel;
+
+/// A tree model whose nodes also have a value in each of a number of
+/// columns. One column, the hierarchical one, is where a tree table draws
+/// the tree.
+public interface TreeTableModel extends TreeModel {
+
+    /// The class of the values of a column.
+    Class<?> getColumnClass(int columnIndex);
+
+    int getColumnCount();
+
+    String getColumnName(int column);
+
+    /// The model index of the column that shows the tree, or -1.
+    int getHierarchicalColumn();
+
+    /// The value of a node in a column.
+    Object getValueAt(Object node, int column);
+
+    boolean isCellEditable(Object node, int column);
+
+    void setValueAt(Object value, Object node, int column);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableNode.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableNode.java
new file mode 100644
index 00000000000..b2d5f18288e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableNode.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import com.codename1.desktopcompat.javax.swing.tree.TreeNode;
+import java.util.Enumeration;
+
+/// A tree node with a value for each of a number of columns and a user
+/// object.
+public interface TreeTableNode extends TreeNode {
+
+    @Override
+    Enumeration<? extends TreeTableNode> children();
+
+    /// The node's value in a column.
+    Object getValueAt(int column);
+
+    @Override
+    TreeTableNode getChildAt(int childIndex);
+
+    /// How many columns this node has a value for, which may be fewer
+    /// than its model has.
+    int getColumnCount();
+
+    @Override
+    TreeTableNode getParent();
+
+    boolean isEditable(int column);
+
+    void setValueAt(Object aValue, int column);
+
+    Object getUserObject();
+
+    void setUserObject(Object userObject);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/package-info.java
new file mode 100644
index 00000000000..ad1713e6af8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/package-info.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The model of a tree table: a tree whose nodes have a value for every
+/// column of a table.
+///
+/// [TreeTableModel] is the model, with [AbstractTreeTableModel] to build
+/// one over any kind of node and [DefaultTreeTableModel] over
+/// [TreeTableNode]s, of which [DefaultMutableTreeTableNode] is the ready
+/// one.
+///
+/// The file system models of this SwingX package are absent, because
+/// they are written over `java.io.File`, and so are the tree table's
+/// editor and the model provider.
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/package-info.java
new file mode 100644
index 00000000000..e745701a34d
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// What a Codename One application calls to use Swing screens of its own:
+/// [com.codename1.desktopcompat.SwingInterop].
+///
+/// The packages below this one are the Swing layer itself -- `java.awt`,
+/// `javax.swing` and the rest as the build relocates them -- and its
+/// runtime; applications name those through the JDK's names, never these.
+package com.codename1.desktopcompat;
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Align.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Align.java
new file mode 100644
index 00000000000..59b21228796
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Align.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+/// Turns the Swing alignment and text position constants into the ones a
+/// Codename One label takes.
+public final class Align {
+
+    private static final int SWING_CENTER = 0;
+    private static final int SWING_TOP = 1;
+    private static final int SWING_LEFT = 2;
+    private static final int SWING_BOTTOM = 3;
+    private static final int SWING_RIGHT = 4;
+    private static final int SWING_LEADING = 10;
+    private static final int SWING_TRAILING = 11;
+
+    private Align() {
+    }
+
+    /// A horizontal alignment: `LEADING` is left and `TRAILING` right.
+    public static int horizontal(int swing) {
+        switch (swing) {
+            case SWING_CENTER:
+                return com.codename1.ui.Component.CENTER;
+            case SWING_RIGHT:
+            case SWING_TRAILING:
+                return com.codename1.ui.Component.RIGHT;
+            default:
+                return com.codename1.ui.Component.LEFT;
+        }
+    }
+
+    /// A vertical alignment.
+    public static int vertical(int swing) {
+        switch (swing) {
+            case SWING_TOP:
+                return com.codename1.ui.Component.TOP;
+            case SWING_BOTTOM:
+                return com.codename1.ui.Component.BOTTOM;
+            default:
+                return com.codename1.ui.Component.CENTER;
+        }
+    }
+
+    /// Where the text goes relative to the icon. Codename One has four
+    /// places where Swing has nine: text that is horizontally centered
+    /// goes above or below the icon as the vertical position says, and
+    /// any other text goes beside it.
+    public static int textPosition(int horizontal, int vertical) {
+        if (horizontal == SWING_CENTER) {
+            if (vertical == SWING_TOP) {
+                return com.codename1.ui.Component.TOP;
+            }
+            if (vertical == SWING_BOTTOM) {
+                return com.codename1.ui.Component.BOTTOM;
+            }
+            return com.codename1.ui.Component.RIGHT;
+        }
+        if (horizontal == SWING_LEFT || horizontal == SWING_LEADING) {
+            return com.codename1.ui.Component.LEFT;
+        }
+        return com.codename1.ui.Component.RIGHT;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/AwtListeners.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/AwtListeners.java
new file mode 100644
index 00000000000..90977efeae6
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/AwtListeners.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.AdjustmentEvent;
+import com.codename1.desktopcompat.java.awt.event.AWTEventListener;
+import com.codename1.desktopcompat.java.awt.event.ComponentEvent;
+import com.codename1.desktopcompat.java.awt.event.ContainerEvent;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.java.awt.event.HierarchyEvent;
+import com.codename1.desktopcompat.java.awt.event.InvocationEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelEvent;
+import com.codename1.desktopcompat.java.awt.event.TextEvent;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import java.util.ArrayList;
+
+/// The listeners added with `Toolkit.addAWTEventListener`, each with the
+/// mask of the events it asked for.
+///
+/// They hear of an event when it is dispatched to a component, before the
+/// component processes it, which is where AWT tells them too.
+public final class AwtListeners {
+
+    private static final ArrayList<AWTEventListener> LISTENERS = new ArrayList<AWTEventListener>();
+    private static final ArrayList<Long> MASKS = new ArrayList<Long>();
+
+    private AwtListeners() {
+    }
+
+    /// Adds `l` for the events in `mask`; a listener that is there
+    /// already hears of these as well.
+    public static void add(AWTEventListener l, long mask) {
+        if (l == null || mask == 0) {
+            return;
+        }
+        int i = LISTENERS.indexOf(l);
+        if (i >= 0) {
+            MASKS.set(i, Long.valueOf(MASKS.get(i).longValue() | mask));
+        } else {
+            LISTENERS.add(l);
+            MASKS.add(Long.valueOf(mask));
+        }
+    }
+
+    public static void remove(AWTEventListener l) {
+        int i = LISTENERS.indexOf(l);
+        if (i >= 0) {
+            LISTENERS.remove(i);
+            MASKS.remove(i);
+        }
+    }
+
+    /// Whether there is a listener at all.
+    public static boolean any() {
+        return !LISTENERS.isEmpty();
+    }
+
+    /// The listeners that asked for any of the events in `mask`.
+    public static AWTEventListener[] listeners(long mask) {
+        ArrayList<AWTEventListener> out = new ArrayList<AWTEventListener>();
+        for (int i = 0; i < LISTENERS.size(); i++) {
+            if ((MASKS.get(i).longValue() & mask) != 0) {
+                out.add(LISTENERS.get(i));
+            }
+        }
+        return out.toArray(new AWTEventListener[out.size()]);
+    }
+
+    /// The mask an event is asked for with.
+    static long maskOf(AWTEvent e) {
+        int id = e.getID();
+        if (e instanceof MouseWheelEvent) {
+            return AWTEvent.MOUSE_WHEEL_EVENT_MASK;
+        }
+        if (e instanceof MouseEvent) {
+            return id == MouseEvent.MOUSE_MOVED || id == MouseEvent.MOUSE_DRAGGED
+                    ? AWTEvent.MOUSE_MOTION_EVENT_MASK : AWTEvent.MOUSE_EVENT_MASK;
+        }
+        if (e instanceof KeyEvent) {
+            return AWTEvent.KEY_EVENT_MASK;
+        }
+        if (e instanceof FocusEvent) {
+            return AWTEvent.FOCUS_EVENT_MASK;
+        }
+        if (e instanceof WindowEvent) {
+            if (id == WindowEvent.WINDOW_GAINED_FOCUS || id == WindowEvent.WINDOW_LOST_FOCUS) {
+                return AWTEvent.WINDOW_FOCUS_EVENT_MASK;
+            }
+            return id == WindowEvent.WINDOW_STATE_CHANGED ? AWTEvent.WINDOW_STATE_EVENT_MASK
+                    : AWTEvent.WINDOW_EVENT_MASK;
+        }
+        if (e instanceof ContainerEvent) {
+            return AWTEvent.CONTAINER_EVENT_MASK;
+        }
+        if (e instanceof ComponentEvent) {
+            return AWTEvent.COMPONENT_EVENT_MASK;
+        }
+        if (e instanceof HierarchyEvent) {
+            return id == HierarchyEvent.ANCESTOR_MOVED || id == HierarchyEvent.ANCESTOR_RESIZED
+                    ? AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK : AWTEvent.HIERARCHY_EVENT_MASK;
+        }
+        if (e instanceof ActionEvent) {
+            return AWTEvent.ACTION_EVENT_MASK;
+        }
+        if (e instanceof ItemEvent) {
+            return AWTEvent.ITEM_EVENT_MASK;
+        }
+        if (e instanceof AdjustmentEvent) {
+            return AWTEvent.ADJUSTMENT_EVENT_MASK;
+        }
+        if (e instanceof TextEvent) {
+            return AWTEvent.TEXT_EVENT_MASK;
+        }
+        if (e instanceof InvocationEvent) {
+            return AWTEvent.INVOCATION_EVENT_MASK;
+        }
+        return 0;
+    }
+
+    /// Tells the listeners that asked for it of an event that is about to
+    /// be processed.
+    public static void dispatching(AWTEvent e) {
+        if (LISTENERS.isEmpty() || e == null) {
+            return;
+        }
+        long mask = maskOf(e);
+        if (mask == 0) {
+            return;
+        }
+        // A listener may remove itself, or add another, while it is told.
+        AWTEventListener[] told = listeners(mask);
+        for (AWTEventListener l : told) {
+            l.eventDispatched(e);
+        }
+    }
+
+    /// Whether the platform's menu shortcuts use the command key: an
+    /// Apple one. Elsewhere it is the control key.
+    public static boolean commandKey() {
+        if (appleForTests != null) {
+            return appleForTests.booleanValue();
+        }
+        String os = null;
+        if (com.codename1.ui.Display.isInitialized()) {
+            String p = com.codename1.ui.Display.getInstance().getPlatformName();
+            if ("ios".equals(p) || "mac".equals(p)) {
+                return true;
+            }
+            if ("and".equals(p) || "win".equals(p) || "linux".equals(p)) {
+                return false;
+            }
+            // The desktop port runs on a JDK and names the system it is on.
+            os = com.codename1.ui.Display.getInstance().getProperty("os.name", null);
+        }
+        if (os == null) {
+            os = System.getProperty("os.name");
+        }
+        return os != null && (os.startsWith("Mac") || os.startsWith("iOS") || os.startsWith("iPhone"));
+    }
+
+    private static Boolean appleForTests;
+
+    /// Says what [#commandKey()] answers; `null` asks the platform again.
+    /// For tests.
+    public static void setCommandKey(Boolean apple) {
+        appleForTests = apple;
+    }
+
+    /// Removes every listener. For tests.
+    public static void reset() {
+        LISTENERS.clear();
+        MASKS.clear();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ButtonPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ButtonPeer.java
new file mode 100644
index 00000000000..df5652c73d0
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ButtonPeer.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+
+/// The peer of a push button: a Codename One button.
+public class ButtonPeer extends com.codename1.ui.Button implements Peer {
+
+    private final PeerSupport support;
+    private boolean plain;
+
+    public ButtonPeer(Component owner) {
+        support = new PeerSupport(owner, this);
+        support.trackFocus();
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    /// Whether the button is drawn without the theme's shape, as an icon
+    /// in a tool bar is; a press then shows as a wash.
+    public void setPlain(boolean plain) {
+        this.plain = plain;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        if (plain && getState() == STATE_PRESSED) {
+            // Without the theme's shape nothing else shows the press.
+            int alpha = g.getAlpha();
+            int color = g.getColor();
+            g.setColor(getUnselectedStyle().getFgColor());
+            g.setAlpha(56);
+            g.fillRect(getX(), getY(), getWidth(), getHeight());
+            g.setAlpha(alpha);
+            g.setColor(color);
+        }
+        super.paint(g);
+        super.paintBorder(g);
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilterInputStream.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CanvasPeer.java
similarity index 56%
rename from maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilterInputStream.java
rename to maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CanvasPeer.java
index c12c509e14a..b877cfc6836 100644
--- a/maven/android-compat/src/main/java/com/codename1/androidcompat/jdk/FilterInputStream.java
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CanvasPeer.java
@@ -20,62 +20,53 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package com.codename1.desktopcompat.rt;
 
-import java.io.IOException;
-import java.io.InputStream;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
 
-/// `java.io.FilterInputStream` for the Codename One runtime.
-public class FilterInputStream extends InputStream {
+/// The peer of a component that draws everything itself.
+public class CanvasPeer extends com.codename1.ui.Component implements Peer {
 
-    protected InputStream in;
+    private final PeerSupport support;
 
-    protected FilterInputStream(InputStream in) {
-        this.in = in;
+    public CanvasPeer(Component owner) {
+        PeerSupport.strip(this);
+        setFocusable(false);
+        support = new PeerSupport(owner, this);
     }
 
     @Override
-    public int read() throws IOException {
-        return in.read();
+    public PeerSupport support() {
+        return support;
     }
 
     @Override
-    public int read(byte[] b) throws IOException {
-        return read(b, 0, b.length);
+    public boolean nativeLook() {
+        return false;
     }
 
     @Override
-    public int read(byte[] b, int off, int len) throws IOException {
-        return in.read(b, off, len);
+    public void paintNativeLook(Graphics g) {
     }
 
     @Override
-    public long skip(long n) throws IOException {
-        return in.skip(n);
+    public void paintNativeChildren(Graphics g) {
     }
 
     @Override
-    public int available() throws IOException {
-        return in.available();
+    public void paint(Graphics g) {
+        support.paintOwner(g);
     }
 
     @Override
-    public void close() throws IOException {
-        in.close();
+    protected void paintBorder(Graphics g) {
     }
 
     @Override
-    public void mark(int readlimit) {
-        in.mark(readlimit);
-    }
-
-    @Override
-    public void reset() throws IOException {
-        in.reset();
-    }
-
-    @Override
-    public boolean markSupported() {
-        return in.markSupported();
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
     }
 }
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellPainter.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellPainter.java
new file mode 100644
index 00000000000..c0e86d96842
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellPainter.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Graphics;
+
+/// Paints a renderer component -- one that is in no window and is used
+/// like a rubber stamp -- into a cell.
+///
+/// The component is given the cell's bounds, laid out if it has children,
+/// and its `paint` runs with a graphics moved and clipped to the cell.
+/// A renderer backed by a Codename One widget (a label, a check box)
+/// paints that widget; one that overrides `paintComponent` paints itself.
+public final class CellPainter {
+
+    private CellPainter() {
+    }
+
+    /// Paints `c` over the rectangle of `g` given in logical pixels.
+    public static void paint(Graphics g, Component c, int x, int y, int w, int h) {
+        if (c == null || w <= 0 || h <= 0) {
+            return;
+        }
+        c.setBounds(x, y, w, h);
+        if (c instanceof Container) {
+            ((Container) c).validate();
+        }
+        Graphics cg = g.create(x, y, w, h);
+        try {
+            c.paint(cg);
+        } finally {
+            cg.dispose();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellStamp.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellStamp.java
new file mode 100644
index 00000000000..e363f5d894c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellStamp.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.geom.Dimension;
+
+/// A Codename One component that paints a component of this layer, for the
+/// places where Codename One asks for a renderer of its own: the rows of a
+/// combo box popup.
+///
+/// The cell is never added to anything. It is given the size this stamp was
+/// laid out at, in logical pixels, and painted through the same graphics a
+/// peer paints its owner with.
+public final class CellStamp extends com.codename1.ui.Component {
+
+    private Component cell;
+
+    public CellStamp() {
+        PeerSupport.strip(this);
+        setFocusable(false);
+    }
+
+    /// The component to paint next; `null` paints nothing.
+    public void setCell(Component cell) {
+        this.cell = cell;
+        setShouldCalcPreferredSize(true);
+    }
+
+    @Override
+    protected Dimension calcPreferredSize() {
+        if (cell == null) {
+            return new Dimension(0, 0);
+        }
+        com.codename1.desktopcompat.java.awt.Dimension d = cell.getPreferredSize();
+        return new Dimension(Units.toDevice(d.width), Units.toDevice(d.height));
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        if (cell == null) {
+            return;
+        }
+        cell.setBounds(0, 0, Units.toLogical(getWidth()), Units.toLogical(getHeight()));
+        cell.validate();
+        G2D g2 = G2D.forPeer(g, getX(), getY(), getWidth(), getHeight());
+        try {
+            cell.paint(g2);
+        } finally {
+            g2.finish();
+        }
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellTheme.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellTheme.java
new file mode 100644
index 00000000000..676e4b924ec
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CellTheme.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.ui.Display;
+import com.codename1.ui.plaf.Style;
+import com.codename1.ui.plaf.UIManager;
+
+/// The colors, fonts and row sizes of the components that paint their own
+/// cells -- tables and trees -- taken from the Codename One theme so that
+/// they do not look foreign next to its widgets.
+///
+/// Cells take the `TableCell` style, headers the `TableHeader` style. A
+/// theme that gives a selected cell no background of its own gets a tint
+/// of the text color over the cell background, which reads in a light and
+/// in a dark theme alike. A color put into the Swing
+/// [com.codename1.desktopcompat.javax.swing.UIManager] under the JDK's key
+/// (`Table.selectionBackground`, `Table.gridColor`, ...) wins over all of
+/// this.
+public final class CellTheme {
+
+    private CellTheme() {
+    }
+
+    /// Whether rows are sized for a finger: a touch screen that is not a
+    /// desktop's. A desktop port answers that it has a touch screen, since
+    /// a pointer does all a finger does, and its rows are still a mouse's.
+    public static boolean touch() {
+        return Display.isInitialized() && Display.getInstance().isTouchScreenDevice()
+                && !Display.getInstance().isDesktop();
+    }
+
+    /// `a` with the fraction `t` of `b` mixed in.
+    public static Color mix(Color a, Color b, float t) {
+        float u = 1 - t;
+        return new Color(Math.round(a.getRed() * u + b.getRed() * t), Math.round(a.getGreen() * u + b.getGreen() * t),
+                Math.round(a.getBlue() * u + b.getBlue() * t));
+    }
+
+    private static Color put(String key) {
+        return key == null ? null : com.codename1.desktopcompat.javax.swing.UIManager.cn1PutColor(key);
+    }
+
+    private static Style style(String uiid, boolean selected) {
+        if (!Display.isInitialized()) {
+            return null;
+        }
+        UIManager m = UIManager.getInstance();
+        return selected ? m.getComponentSelectedStyle(uiid) : m.getComponentStyle(uiid);
+    }
+
+    private static boolean filled(Style s) {
+        return s != null && (s.getBgTransparency() & 0xff) != 0;
+    }
+
+    /// The background of cells: the cell style's if it has one, else the
+    /// one content areas have.
+    public static Color background(String key) {
+        Color c = put(key);
+        if (c != null) {
+            return c;
+        }
+        Style s = style("TableCell", false);
+        return filled(s) ? new Color(s.getBgColor() & 0xffffff) : fieldBackground();
+    }
+
+    /// The background of a content area -- a list, a tree, a table, a text
+    /// area -- as opposed to the window around it. A desktop look and feel
+    /// draws these white on a grey window, which is what tells a reader
+    /// where the content is; on a light theme that is white here too, and
+    /// on a dark one a shade off the window.
+    public static Color fieldBackground() {
+        Color w = EventBridge.defaultBackground();
+        if (w.getRed() + w.getGreen() + w.getBlue() >= 3 * 128) {
+            return Color.WHITE;
+        }
+        return mix(w, Color.WHITE, 0.1f);
+    }
+
+    /// The background of a desktop pane: that of a content area, which is
+    /// what the frames on it stand out from.
+    public static Color desktopBackground() {
+        return fieldBackground();
+    }
+
+    /// The color of cell text.
+    public static Color foreground(String key) {
+        Color c = put(key);
+        if (c != null) {
+            return c;
+        }
+        Style s = style("TableCell", false);
+        return s != null ? new Color(s.getFgColor() & 0xffffff) : EventBridge.defaultForeground();
+    }
+
+    private static boolean ownSelection() {
+        Style sel = style("TableCell", true);
+        Style plain = style("TableCell", false);
+        return filled(sel) && plain != null
+                && (!filled(plain) || (sel.getBgColor() & 0xffffff) != (plain.getBgColor() & 0xffffff));
+    }
+
+    /// The background of selected cells.
+    public static Color selectionBackground(String key) {
+        Color c = put(key);
+        if (c != null) {
+            return c;
+        }
+        if (ownSelection()) {
+            return new Color(style("TableCell", true).getBgColor() & 0xffffff);
+        }
+        return mix(background(null), foreground(null), 0.18f);
+    }
+
+    /// The text color of selected cells.
+    public static Color selectionForeground(String key) {
+        Color c = put(key);
+        if (c != null) {
+            return c;
+        }
+        if (ownSelection()) {
+            return new Color(style("TableCell", true).getFgColor() & 0xffffff);
+        }
+        return foreground(null);
+    }
+
+    /// The color of the lines between cells.
+    public static Color grid(String key) {
+        Color c = put(key);
+        return c != null ? c : mix(background(null), foreground(null), 0.2f);
+    }
+
+    /// The background of a table header.
+    public static Color headerBackground(String key) {
+        Color c = put(key);
+        if (c != null) {
+            return c;
+        }
+        Style s = style("TableHeader", false);
+        if (filled(s)) {
+            return new Color(s.getBgColor() & 0xffffff);
+        }
+        return mix(background(null), foreground(null), 0.08f);
+    }
+
+    /// The text color of a table header.
+    public static Color headerForeground(String key) {
+        Color c = put(key);
+        if (c != null) {
+            return c;
+        }
+        Style s = style("TableHeader", false);
+        return s != null ? new Color(s.getFgColor() & 0xffffff) : EventBridge.defaultForeground();
+    }
+
+    /// The font of a table header.
+    public static Font headerFont() {
+        Style s = style("TableHeader", false);
+        if (s != null && s.getFont() != null) {
+            return Fonts.fromNative(s.getFont());
+        }
+        return Fonts.defaultFont();
+    }
+
+    /// The font of cells.
+    public static Font font() {
+        Style s = style("TableCell", false);
+        if (s != null && s.getFont() != null) {
+            return Fonts.fromNative(s.getFont());
+        }
+        return Fonts.defaultFont();
+    }
+
+    /// The height of a row of text in `f`, in logical pixels: at least
+    /// `plain`, or on a touch screen at least `touch` and with room around
+    /// the text for a finger.
+    public static int rowHeight(Font f, int plain, int touch) {
+        int fh = Fonts.metrics(f != null ? f : Fonts.defaultFont()).getHeight();
+        if (touch()) {
+            return Math.max(touch, fh + 10);
+        }
+        return Math.max(plain, fh + 2);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CheckBoxPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CheckBoxPeer.java
new file mode 100644
index 00000000000..499abd2de84
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/CheckBoxPeer.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.plaf.Border;
+import com.codename1.ui.plaf.Style;
+
+/// The peer of a check box, and of a toggle button when made a toggle: a
+/// Codename One check box.
+public class CheckBoxPeer extends com.codename1.ui.CheckBox implements Peer {
+
+    private final PeerSupport support;
+
+    public CheckBoxPeer(Component owner) {
+        support = new PeerSupport(owner, this);
+        // The room between the mark and its text.
+        setGap(Units.toDevice(4));
+        support.trackFocus();
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    /// Whether the theme draws a toggle button that is on exactly as one
+    /// that is off. Codename One draws the first in the pressed style, or
+    /// in the selected one while it has the focus -- which it has right
+    /// after the click that turned it on -- and a theme that never styled
+    /// toggle buttons gives all of them the same background and border; a
+    /// different text colour does not show on a button that is only an
+    /// icon.
+    private boolean onLooksLikeOff() {
+        Style off = getUnselectedStyle();
+        Style on = getStyle();
+        if (on == off) {
+            return true;
+        }
+        if (off.getBgTransparency() != on.getBgTransparency() || off.getBgImage() != on.getBgImage()) {
+            return false;
+        }
+        // A colour that is not painted tells nothing apart.
+        if ((off.getBgTransparency() & 0xff) != 0 && off.getBgColor() != on.getBgColor()) {
+            return false;
+        }
+        Border a = off.getBorder();
+        Border b = on.getBorder();
+        if (a != b && (a == null || !a.equals(b))) {
+            return false;
+        }
+        String text = getText();
+        return text == null || text.length() == 0 || off.getFgColor() == on.getFgColor();
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        if (isToggle() && isSelected() && onLooksLikeOff()) {
+            // The state has to show: a wash of the text colour, as a
+            // pressed key looks in most themes.
+            int alpha = g.getAlpha();
+            int color = g.getColor();
+            int arc = Math.max(2, Units.toDevice(6));
+            g.setColor(getUnselectedStyle().getFgColor());
+            g.setAlpha(56);
+            g.fillRoundRect(getX(), getY(), getWidth(), getHeight(), arc, arc);
+            g.setAlpha(alpha);
+            g.setColor(color);
+        }
+        if (getIcon() != null || ownMark()) {
+            // In Swing an icon takes the place of the indicator; it is not
+            // drawn beside it. Without one the indicator is the mark drawn
+            // here, which the button shows as its icon.
+            if (ownMark()) {
+                Indicators.labelText(this, support);
+            }
+            getUIManager().getLookAndFeel().drawButton(g, this);
+        } else {
+            super.paint(g);
+        }
+        super.paintBorder(g);
+    }
+
+    /// Whether the indicator is the mark drawn here rather than the
+    /// theme's: always, unless the button is a toggle or shows an icon in
+    /// its place.
+    private boolean ownMark() {
+        return !isToggle() && getIcon() == null;
+    }
+
+    private com.codename1.ui.Image mark() {
+        return Indicators.mark(false, isSelected(), isEnabled(), Indicators.size(getUnselectedStyle()));
+    }
+
+    @Override
+    public com.codename1.ui.Image getIconFromState() {
+        return ownMark() ? mark() : super.getIconFromState();
+    }
+
+    @Override
+    public com.codename1.ui.Image getMaskedIcon() {
+        return ownMark() ? mark() : super.getMaskedIcon();
+    }
+
+    /// With an icon there is no indicator to make room for, and the mark
+    /// drawn here is measured as one.
+    @Override
+    protected com.codename1.ui.geom.Dimension calcPreferredSize() {
+        if (ownMark()) {
+            Indicators.labelText(this, support);
+        }
+        if (getIcon() != null || ownMark()) {
+            return getUIManager().getLookAndFeel().getButtonPreferredSize(this);
+        }
+        return super.calcPreferredSize();
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ClientProps.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ClientProps.java
new file mode 100644
index 00000000000..2a277f9ab77
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ClientProps.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.border.LineBorder;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+
+/// What a FlatLaf client property does to a component of this layer.
+///
+/// On the desktop FlatLaf's UI delegates read these properties when they
+/// paint. Here there are no delegates, so the few that have a counterpart
+/// are applied when the property is put; `JComponent.putClientProperty`
+/// calls [#changed] for that. Every property is kept and answered by
+/// `getClientProperty` whether or not it does anything.
+///
+/// #### Implemented
+///
+///  - `JTextField.placeholderText`: the hint of the text field or area.
+///  - `JButton.buttonType` of `borderless` or `toolBarButton`: a button
+///    with no border and no filled background. Other types are recorded.
+///  - `JComponent.outline` of `error`, `warning` or a color: a line in
+///    that color around the component; null takes it away.
+///  - `FlatLaf.styleClass`: the font of the first class that is one of
+///    `h00`, `h0`, `h1` to `h4` (and their `.regular` forms), `large`,
+///    `medium`, `small`, `mini`, `light`, `semibold` and `monospaced`.
+///  - `FlatLaf.style` given as a string: its `background`, `foreground`
+///    and `font` entries. A font is `bold`, `italic`, a size, a size
+///    change such as `+2`, or a combination.
+///  - `JComponent.minimumWidth` and `JComponent.minimumHeight`.
+///
+/// #### Recorded only
+///
+/// Everything else, among them `JComponent.roundRect`, the leading and
+/// trailing icons and components and the clear button of a text field,
+/// `JTextField.padding` and `selectAllOnFocusPolicy`, every
+/// `JTabbedPane.*`, `JScrollBar.*`, `JScrollPane.*`, `JTree.*`,
+/// `JProgressBar.*`, `JToggleButton.*` and `JSplitPane.*` property, the
+/// popup properties, and the title bar and native window properties.
+public final class ClientProps {
+
+    /// Where the border a component had before its outline is kept.
+    private static final String BEFORE_OUTLINE = "cn1.borderBeforeOutline";
+
+    private ClientProps() {
+    }
+
+    /// Applies a client property that was just put.
+    ///
+    /// #### Parameters
+    ///
+    /// - `c`: the component it was put on
+    ///
+    /// - `key`: its key
+    ///
+    /// - `value`: its new value, null when it was removed
+    public static void changed(JComponent c, Object key, Object value) {
+        if (c == null || !(key instanceof String)) {
+            return;
+        }
+        String k = (String) key;
+        if ("JTextField.placeholderText".equals(k)) {
+            placeholder(c, value);
+        } else if ("JButton.buttonType".equals(k)) {
+            if (c instanceof AbstractButton) {
+                boolean bare = "borderless".equals(value) || "toolBarButton".equals(value);
+                AbstractButton b = (AbstractButton) c;
+                b.setBorderPainted(!bare);
+                b.setContentAreaFilled(!bare);
+            }
+        } else if ("JComponent.outline".equals(k)) {
+            outline(c, value);
+        } else if ("FlatLaf.styleClass".equals(k)) {
+            if (value instanceof String) {
+                styleClass(c, (String) value);
+            }
+        } else if ("FlatLaf.style".equals(k)) {
+            if (value instanceof String) {
+                style(c, (String) value);
+            }
+        } else if ("JComponent.minimumWidth".equals(k) || "JComponent.minimumHeight".equals(k)) {
+            if (value instanceof Integer) {
+                Dimension min = c.getMinimumSize();
+                int n = ((Integer) value).intValue();
+                boolean width = "JComponent.minimumWidth".equals(k);
+                c.setMinimumSize(new Dimension(width ? n : min == null ? 0 : min.width,
+                        width ? min == null ? 0 : min.height : n));
+                c.revalidate();
+            }
+        }
+    }
+
+    private static void placeholder(JComponent c, Object value) {
+        if (!(c instanceof JTextComponent)) {
+            return;
+        }
+        com.codename1.ui.Component peer = c.cn1Peer();
+        if (peer instanceof com.codename1.ui.TextArea) {
+            ((com.codename1.ui.TextArea) peer).setHint(value == null ? "" : String.valueOf(value));
+            c.repaint();
+        }
+    }
+
+    private static void outline(JComponent c, Object value) {
+        Color color = null;
+        if ("error".equals(value)) {
+            color = UIManager.getColor("Component.error.focusedBorderColor");
+        } else if ("warning".equals(value)) {
+            color = UIManager.getColor("Component.warning.focusedBorderColor");
+        } else if (value instanceof Color) {
+            color = (Color) value;
+        } else if (value instanceof Color[] && ((Color[]) value).length > 0) {
+            color = ((Color[]) value)[0];
+        }
+        Object before = c.getClientProperty(BEFORE_OUTLINE);
+        if (color == null) {
+            if (before != null) {
+                c.putClientProperty(BEFORE_OUTLINE, null);
+                c.setBorder(before instanceof Border ? (Border) before : null);
+            }
+            return;
+        }
+        if (before == null) {
+            Border now = c.getBorder();
+            c.putClientProperty(BEFORE_OUTLINE, now != null ? (Object) now : (Object) Boolean.FALSE);
+        }
+        c.setBorder(new LineBorder(color, 2));
+    }
+
+    private static void styleClass(JComponent c, String classes) {
+        int start = 0;
+        for (int i = 0; i <= classes.length(); i++) {
+            if (i == classes.length() || classes.charAt(i) == ' ') {
+                if (i > start) {
+                    Font f = LafTheme.styleFont(classes.substring(start, i));
+                    if (f != null) {
+                        c.setFont(f);
+                        return;
+                    }
+                }
+                start = i + 1;
+            }
+        }
+    }
+
+    private static int hex(String s) {
+        int v = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            int d = ch >= '0' && ch <= '9' ? ch - '0'
+                    : ch >= 'a' && ch <= 'f' ? ch - 'a' + 10
+                    : ch >= 'A' && ch <= 'F' ? ch - 'A' + 10 : -1;
+            if (d < 0) {
+                return -1;
+            }
+            v = v << 4 | d;
+        }
+        return v;
+    }
+
+    /// A color written `#rgb` or `#rrggbb`, or null.
+    private static Color color(String s) {
+        if (s.length() == 4 && s.charAt(0) == '#') {
+            int v = hex(s.substring(1));
+            return v < 0 ? null : new Color((v >> 8 & 0xf) * 17, (v >> 4 & 0xf) * 17, (v & 0xf) * 17);
+        }
+        if (s.length() == 7 && s.charAt(0) == '#') {
+            int v = hex(s.substring(1));
+            return v < 0 ? null : new Color(v);
+        }
+        return null;
+    }
+
+    private static int number(String s) {
+        if (s.length() == 0 || s.length() > 3) {
+            return -1;
+        }
+        int v = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            if (ch < '0' || ch > '9') {
+                return -1;
+            }
+            v = v * 10 + (ch - '0');
+        }
+        return v;
+    }
+
+    private static void font(JComponent c, String value) {
+        Font f = c.getFont();
+        int style = f.getStyle();
+        float size = f.getSize2D();
+        int start = 0;
+        for (int i = 0; i <= value.length(); i++) {
+            if (i == value.length() || value.charAt(i) == ' ') {
+                String word = value.substring(start, i);
+                start = i + 1;
+                if ("bold".equals(word)) {
+                    style |= Font.BOLD;
+                } else if ("italic".equals(word)) {
+                    style |= Font.ITALIC;
+                } else if ("normal".equals(word)) {
+                    style = Font.PLAIN;
+                } else if (word.length() > 1 && (word.charAt(0) == '+' || word.charAt(0) == '-')) {
+                    int n = number(word.substring(1));
+                    if (n > 0) {
+                        size = Math.max(1f, word.charAt(0) == '+' ? size + n : size - n);
+                    }
+                } else {
+                    int n = number(word);
+                    if (n > 0) {
+                        size = n;
+                    }
+                }
+            }
+        }
+        c.setFont(f.deriveFont(style, size));
+    }
+
+    /// Applies the entries of a style string, `key: value; key: value`.
+    private static void style(JComponent c, String style) {
+        int start = 0;
+        for (int i = 0; i <= style.length(); i++) {
+            if (i == style.length() || style.charAt(i) == ';') {
+                String entry = style.substring(start, i);
+                start = i + 1;
+                int colon = entry.indexOf(':');
+                if (colon < 0) {
+                    continue;
+                }
+                String key = entry.substring(0, colon).trim();
+                String value = entry.substring(colon + 1).trim();
+                if ("background".equals(key)) {
+                    Color bg = color(value);
+                    if (bg != null) {
+                        c.setBackground(bg);
+                    }
+                } else if ("foreground".equals(key)) {
+                    Color fg = color(value);
+                    if (fg != null) {
+                        c.setForeground(fg);
+                    }
+                } else if ("font".equals(key)) {
+                    font(c, value);
+                }
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ComboPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ComboPeer.java
new file mode 100644
index 00000000000..d85381dcf6b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ComboPeer.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.list.ListModel;
+
+/// The peer of a combo box: a Codename One combo box, which draws the
+/// closed box and shows the popup the platform's way.
+public class ComboPeer extends com.codename1.ui.ComboBox<Object> implements Peer {
+
+    /// Told when the popup opens and when it has closed.
+    public interface PopupWatcher {
+        void popupOpening();
+
+        /// `cancelled` when the popup was closed from code rather than by
+        /// the user picking a row or dismissing it.
+        void popupClosed(boolean cancelled);
+    }
+
+    private final PeerSupport support;
+    private PopupWatcher watcher;
+    private com.codename1.ui.Dialog popup;
+    private boolean closedFromCode;
+
+    public ComboPeer(Component owner, ListModel<Object> model) {
+        super(model);
+        // Wide enough for the widest entry, not for the first few.
+        setListSizeCalculationSampleCount(200);
+        support = new PeerSupport(owner, this);
+        support.trackFocus();
+    }
+
+    public void setPopupWatcher(PopupWatcher watcher) {
+        this.watcher = watcher;
+    }
+
+    /// Opens the popup as a tap on the box would.
+    public void openPopup() {
+        if (isEnabled() && !isShowingPopupDialog()) {
+            fireClicked();
+        }
+    }
+
+    /// Closes an open popup without taking what was highlighted in it.
+    public void closePopup() {
+        com.codename1.ui.Dialog d = popup;
+        if (d != null && isShowingPopupDialog()) {
+            closedFromCode = true;
+            d.dispose();
+        }
+    }
+
+    @Override
+    protected com.codename1.ui.Dialog createPopupDialog(com.codename1.ui.List<Object> l) {
+        popup = super.createPopupDialog(l);
+        return popup;
+    }
+
+    /// The popup is modal: this returns when it has closed. The owner is
+    /// told on both sides, so what the user highlights on the way is not a
+    /// selection until the popup is closed with it.
+    @Override
+    protected void fireClicked() {
+        closedFromCode = false;
+        if (watcher != null) {
+            watcher.popupOpening();
+        }
+        try {
+            super.fireClicked();
+        } finally {
+            popup = null;
+            if (watcher != null) {
+                watcher.popupClosed(closedFromCode);
+            }
+        }
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        super.paint(g);
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Comparators.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Comparators.java
new file mode 100644
index 00000000000..fb3738bcc71
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Comparators.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import java.util.Comparator;
+
+/// The two comparators the row sorters fall back on.
+///
+/// A failed cast does not throw on a device, so a comparator that is
+/// handed two cell values may never cast one to the type of the other,
+/// and may never rely on `compareTo` rejecting a stranger. These check
+/// first.
+public final class Comparators {
+
+    /// Compares strings, and anything else by its string, with
+    /// `String.compareTo`: there is no locale collation on a device.
+    public static final Comparator<Object> STRINGS = new Comparator<Object>() {
+        @Override
+        public int compare(Object a, Object b) {
+            return a.toString().compareTo(b.toString());
+        }
+    };
+
+    /// Compares numbers as numbers, two values of one comparable class by
+    /// `compareTo`, and anything else by its string.
+    public static final Comparator<Object> VALUES = new Comparator<Object>() {
+        @Override
+        @SuppressWarnings({"unchecked", "rawtypes"})
+        public int compare(Object a, Object b) {
+            if (a instanceof Number && b instanceof Number) {
+                if (whole(a) && whole(b)) {
+                    long x = ((Number) a).longValue();
+                    long y = ((Number) b).longValue();
+                    return x < y ? -1 : x > y ? 1 : 0;
+                }
+                return Double.compare(((Number) a).doubleValue(), ((Number) b).doubleValue());
+            }
+            if (a instanceof Comparable && a.getClass() == b.getClass()) {
+                return ((Comparable) a).compareTo(b);
+            }
+            return a.toString().compareTo(b.toString());
+        }
+    };
+
+    private Comparators() {
+    }
+
+    static boolean whole(Object n) {
+        return n instanceof Integer || n instanceof Long || n instanceof Short || n instanceof Byte;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ContainerPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ContainerPeer.java
new file mode 100644
index 00000000000..016cb312c7b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ContainerPeer.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.ui.Graphics;
+
+/// The peer of a container: its children are the peers of the container's
+/// children, placed by a [LayoutBridge].
+public class ContainerPeer extends com.codename1.ui.Container implements Peer {
+
+    private final PeerSupport support;
+
+    public ContainerPeer(Container owner) {
+        super(new LayoutBridge(owner));
+        PeerSupport.strip(this);
+        setScrollableX(false);
+        setScrollableY(false);
+        support = new PeerSupport(owner, this);
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return false;
+    }
+
+    /// The peers are held in the order they are painted, which is the
+    /// reverse of the order of the container's children: the first child
+    /// of a Swing container is the one on top. The order of traversal is
+    /// the children's, so the indices are given from the last peer to the
+    /// first. A port asks the form for the component after the text field
+    /// it is editing when Tab is pressed there, and the answer was the
+    /// field before it -- or nothing, from the first field of a window.
+    @Override
+    public int updateTabIndices(int offset) {
+        int idx = offset;
+        for (int i = getComponentCount() - 1; i >= 0; i--) {
+            com.codename1.ui.Component c = getComponentAt(i);
+            int preferred = c.getPreferredTabIndex();
+            if (preferred == 0) {
+                c.setTabIndex(idx++);
+            } else {
+                c.setTabIndex(preferred);
+            }
+            if (c instanceof com.codename1.ui.Container) {
+                idx = ((com.codename1.ui.Container) c).updateTabIndices(idx);
+            }
+        }
+        return idx;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+        super.paint(g);
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DatePickerPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DatePickerPeer.java
new file mode 100644
index 00000000000..e40986d5c28
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DatePickerPeer.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Display;
+import com.codename1.ui.Graphics;
+import java.util.Date;
+
+/// The peer of a date picker: a Codename One picker of dates, which shows
+/// the date as a button and opens the platform's date chooser when it is
+/// tapped.
+///
+/// The text on the button is the owner's business: the picker asks its
+/// [Host] for it whenever its value changes, and tells the host of every
+/// value it takes, whether set by code or chosen by the user.
+public class DatePickerPeer extends com.codename1.ui.spinner.Picker implements Peer {
+
+    /// What the component behind the picker supplies.
+    public interface Host {
+
+        /// The text that shows `date`, which is `null` when nothing is
+        /// chosen.
+        String text(Date date);
+
+        /// The picker now holds `date`.
+        void valueChanged(Date date);
+    }
+
+    private final PeerSupport support;
+    private final Host host;
+
+    public DatePickerPeer(Component owner, Host host) {
+        setType(Display.PICKER_TYPE_DATE);
+        support = new PeerSupport(owner, this);
+        support.trackFocus();
+        this.host = host;
+    }
+
+    /// Shows the host's text for the value and reports the value. Called
+    /// by the picker for every change, the first time from its own
+    /// constructor, before there is a host.
+    @Override
+    protected void updateValue() {
+        if (host == null) {
+            super.updateValue();
+            return;
+        }
+        Object v = getValue();
+        Date d = v instanceof Date ? (Date) v : null;
+        setText(host.text(d));
+        host.valueChanged(d);
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        super.paint(g);
+        super.paintBorder(g);
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DesktopLifecycle.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DesktopLifecycle.java
new file mode 100644
index 00000000000..2d82795c382
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DesktopLifecycle.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.generated.compat.CompatRegistry;
+import com.codename1.io.Log;
+import com.codename1.system.Lifecycle;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Label;
+import com.codename1.ui.layouts.BorderLayout;
+
+/// The Codename One lifecycle of a Swing application.
+///
+/// The application's Codename One main class -- the class
+/// `codename1.packageName` and `codename1.mainName` name, an ordinary source
+/// file of the project -- extends it and implements the one abstract method
+/// by calling the Swing application's `main`. `cn1:import-desktop-project`
+/// writes that class:
+///
+/// ```java
+/// public class MyApp extends DesktopLifecycle {
+///     protected void runMain() throws Exception {
+///         com.example.Main.main(new String[0]);
+///     }
+/// }
+/// ```
+///
+/// Extending this class is what makes the Swing windows THE application:
+/// [#runApp()] installs the [WindowHosts#setExitHook(Runnable)] hook that
+/// exits it, so `EXIT_ON_CLOSE` and the last window being disposed of end
+/// the application, as they end a desktop JVM. A Codename One application
+/// that only uses some Swing screens (library mode) has a main class that
+/// does not extend it, installs no hook, and closing the last window shows
+/// the form it was shown over.
+///
+/// The contract, in the order things happen:
+///
+/// 1. **Start.** The first `start()` installs the application's resources
+///    (`CompatRegistry.cn1Install()`) and calls `runMain()` once, on the event
+///    dispatch thread -- the thread a Swing application is supposed to
+///    build its frames on, so `SwingUtilities.invokeLater` from `main`
+///    runs the runnable after `main` returns, and `invokeAndWait` runs it
+///    at once. `main` receives no arguments. An exception it throws is
+///    logged and the application goes on.
+/// 2. **After `main` returns** the application stays alive: nothing
+///    here depends on `main` blocking. Once the events `main` queued
+///    have run, if no window is showing, a blank form titled with the
+///    application's name is shown, so that the user never looks at an
+///    empty screen. It is replaced by the first window that shows.
+/// 3. **Stop** (the application goes to the background): every showing
+///    frame receives `windowIconified` and the active window
+///    `windowDeactivated`. A modal dialog that is showing stays open.
+/// 4. **Start again**: the same windows receive `windowDeiconified`, the
+///    active one `windowActivated`, and the screen shows what it showed.
+/// 5. **Destroy** (the platform ends the application): every showing
+///    window receives `windowClosing`, the one on top first, as if its
+///    close box was used. `EXIT_ON_CLOSE` does not exit a second time.
+/// 6. **Exit.** When the last window that was shown or packed is disposed
+///    of, the application exits, as a desktop JVM does once no
+///    displayable window and no other thread is left. Hiding the last
+///    window without disposing of it shows the blank form of step 2
+///    instead. `JFrame.EXIT_ON_CLOSE` exits at once.
+public abstract class DesktopLifecycle extends Lifecycle {
+
+    private boolean ran;
+    private boolean destroying;
+    private int showsBefore;
+    private Form blank;
+
+    /// Calls the application's `main`.
+    protected abstract void runMain() throws Exception;
+
+    @Override
+    public void start() {
+        if (ran) {
+            Form current = getCurrentForm();
+            if (current != null && Display.getInstance().getCurrent() != current) {
+                current.show();
+            }
+            background(false);
+            return;
+        }
+        runApp();
+    }
+
+    @Override
+    public void runApp() {
+        ran = true;
+        showsBefore = WindowHosts.shownCount();
+        WindowHosts.setIdleHook(new Runnable() {
+            @Override
+            public void run() {
+                idle();
+            }
+        });
+        WindowHosts.setExitHook(new Runnable() {
+            @Override
+            public void run() {
+                if (!destroying) {
+                    Display.getInstance().exitApplication();
+                }
+            }
+        });
+        // Before any application code: its resources and bundles.
+        CompatRegistry.cn1Install();
+        try {
+            runMain();
+        } catch (Exception e) {
+            Log.e(e);
+        }
+        Display.getInstance().callSerially(new Runnable() {
+            @Override
+            public void run() {
+                idle();
+            }
+        });
+    }
+
+    @Override
+    public void stop() {
+        setCurrentForm(Display.getInstance().getCurrent());
+        background(true);
+    }
+
+    @Override
+    public void destroy() {
+        destroying = true;
+        Window[] ws = WindowHosts.showing();
+        for (int i = ws.length - 1; i >= 0; i--) {
+            ws[i].cn1Closing();
+        }
+    }
+
+    private static void background(boolean iconified) {
+        Window[] ws = WindowHosts.showing();
+        Window active = WindowHosts.active();
+        if (iconified && active != null) {
+            active.cn1Activated(false, null);
+        }
+        for (int i = 0; i < ws.length; i++) {
+            ws[i].cn1Iconified(iconified);
+        }
+        if (!iconified && active != null) {
+            active.cn1Activated(true, null);
+        }
+    }
+
+    /// No window is showing: exit when none is left at all, else show the
+    /// blank form.
+    private void idle() {
+        if (destroying) {
+            return;
+        }
+        if (WindowHosts.showing().length > 0) {
+            return;
+        }
+        if (WindowHosts.shownCount() != showsBefore && WindowHosts.windows().length == 0) {
+            WindowHosts.exit();
+            return;
+        }
+        Form current = Display.getInstance().getCurrent();
+        if (current == null || current instanceof FrameForm) {
+            if (blank == null) {
+                String name = Display.getInstance().getProperty("AppName", "");
+                blank = new Form(name == null ? "" : name, new BorderLayout());
+                blank.add(BorderLayout.CENTER, new Label(""));
+            }
+            blank.show();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DesktopToolkit.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DesktopToolkit.java
new file mode 100644
index 00000000000..eaac10f0508
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DesktopToolkit.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.EventQueue;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.Toolkit;
+import com.codename1.desktopcompat.java.awt.datatransfer.Clipboard;
+import java.net.URL;
+import com.codename1.ui.Display;
+
+/// The one toolkit there is.
+public final class DesktopToolkit extends Toolkit {
+
+    private final EventQueue queue = new EventQueue();
+    private Clipboard clipboard;
+
+    @Override
+    public Dimension getScreenSize() {
+        if (!Display.isInitialized()) {
+            return new Dimension(0, 0);
+        }
+        Display d = Display.getInstance();
+        return new Dimension(Units.toLogical(d.getDisplayWidth()), Units.toLogical(d.getDisplayHeight()));
+    }
+
+    @Override
+    public int getScreenResolution() {
+        return 96;
+    }
+
+    @Override
+    public FontMetrics getFontMetrics(Font font) {
+        return Fonts.metrics(font);
+    }
+
+    @Override
+    public void sync() {
+    }
+
+    @Override
+    public void beep() {
+    }
+
+    @Override
+    public Image createImage(byte[] imagedata, int imageoffset, int imagelength) {
+        return ImageLoader.wrap(ImageLoader.decode(imagedata, imageoffset, imagelength));
+    }
+
+    @Override
+    public Image getImage(String filename) {
+        return ImageLoader.wrap(ImageLoader.fromPath(filename));
+    }
+
+    @Override
+    public Image getImage(URL url) {
+        return ImageLoader.wrap(ImageLoader.fromUrl(url));
+    }
+
+    @Override
+    public Image createImage(String filename) {
+        return getImage(filename);
+    }
+
+    @Override
+    public Image createImage(URL url) {
+        return getImage(url);
+    }
+
+    @Override
+    public Clipboard getSystemClipboard() {
+        if (clipboard == null) {
+            clipboard = new SystemClipboard();
+        }
+        return clipboard;
+    }
+
+    @Override
+    protected EventQueue getSystemEventQueueImpl() {
+        return queue;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DialogForm.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DialogForm.java
new file mode 100644
index 00000000000..1ba35f5914e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DialogForm.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.ui.Command;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.BorderLayout;
+import java.util.List;
+
+/// A Codename One dialog that shows an AWT dialog, or any window that is
+/// not a frame, floating over the current form.
+///
+/// The dialog takes the size the window has -- the one it was packed or
+/// set to -- no larger than the display allows; the position the
+/// application asked for is ignored and the dialog is centered. It is
+/// shown without blocking: a modal AWT dialog blocks its caller itself.
+/// The back command asks the window to close. A menu bar of such a window
+/// is shown as a row of menus, not as commands.
+public final class DialogForm extends com.codename1.ui.Dialog implements WindowHost {
+
+    private final Window window;
+    private final com.codename1.ui.Component peer;
+    private final int wantedWidth;
+    private final int wantedHeight;
+    private boolean open;
+    private boolean opening;
+    private boolean closeAsked;
+
+    public DialogForm(Window w) {
+        super(w.cn1Title(), new BorderLayout());
+        window = w;
+        // Read before the peer is laid out in this dialog, which resizes
+        // the window to whatever room the dialog has at that moment.
+        int ww = w.getWidth();
+        int wh = w.getHeight();
+        if (ww <= 0 || wh <= 0) {
+            com.codename1.desktopcompat.java.awt.Dimension d = w.getPreferredSize();
+            ww = d.width;
+            wh = d.height;
+        }
+        wantedWidth = ww;
+        wantedHeight = wh;
+        setScrollable(false);
+        // This host is the choice NOT to use a window of the window
+        // manager: WindowHosts takes a secondary window first where the
+        // port has them and the application left them on. A theme may ask
+        // for every Codename One dialog to open in a window of its own
+        // (the Windows native theme does), and the dialog then left the
+        // form an application had asked to keep it in.
+        setNativeWindowMode(false);
+        setAutoDispose(false);
+        setDisposeWhenPointerOutOfBounds(false);
+        setEnableCursors(true);
+        peer = w.cn1Peer();
+        peer.remove();
+        add(BorderLayout.CENTER, peer);
+        WindowHosts.listenWheel(w, peer);
+        setBackCommand(new Command("") {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                window.cn1Closing();
+            }
+        });
+    }
+
+    /// The window this dialog shows.
+    public Window window() {
+        return window;
+    }
+
+    @Override
+    public void open() {
+        if (open) {
+            return;
+        }
+        open = true;
+        Display d = Display.getInstance();
+        int dw = Math.min(Units.toDevice(wantedWidth), d.getDisplayWidth() * 9 / 10);
+        int dh = Math.min(Units.toDevice(wantedHeight), d.getDisplayHeight() * 8 / 10);
+        peer.setPreferredSize(new Dimension(Math.max(1, dw), Math.max(1, dh)));
+        // Showing a dialog first runs what is waiting on the event
+        // dispatch thread, and that may already hide this window again:
+        // the request is kept until the dialog is on the screen.
+        opening = true;
+        try {
+            showPacked(BorderLayout.CENTER, false);
+        } finally {
+            opening = false;
+        }
+        if (closeAsked) {
+            closeAsked = false;
+            open = true;
+            close();
+        }
+    }
+
+    @Override
+    public void close() {
+        if (opening) {
+            closeAsked = true;
+            return;
+        }
+        if (open) {
+            open = false;
+            dispose();
+            peer.remove();
+        }
+    }
+
+    @Override
+    public void release() {
+        close();
+    }
+
+    @Override
+    public void title(String title) {
+        setTitle(title);
+    }
+
+    @Override
+    public void icon(Image icon) {
+    }
+
+    @Override
+    public void bounds() {
+    }
+
+    @Override
+    public void resizable(boolean resizable) {
+    }
+
+    @Override
+    public void decorated(boolean decorated) {
+    }
+
+    @Override
+    public void state(int state) {
+    }
+
+    @Override
+    public void commands(List<Command> commands) {
+    }
+
+    @Override
+    public boolean takesCommands() {
+        return false;
+    }
+
+    @Override
+    public Form form() {
+        return this;
+    }
+
+    @Override
+    public boolean fillsDisplay() {
+        return false;
+    }
+
+    @Override
+    public boolean reusable() {
+        return false;
+    }
+
+    @Override
+    public void pointerPressed(int x, int y) {
+        if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_PRESSED, x, y)) {
+            super.pointerPressed(x, y);
+        }
+    }
+
+    @Override
+    public void pointerDragged(int x, int y) {
+        if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_DRAGGED, x, y)) {
+            super.pointerDragged(x, y);
+        }
+    }
+
+    /// The drag of a pointer as the display delivers it. A form has two
+    /// overloads and the display calls this one, which is an
+    /// implementation of its own and never reaches the one above; with
+    /// only that one overridden no drag got to a Swing component at all,
+    /// while presses and releases, which a form routes through the plain
+    /// overloads, did. More than one pointer is a gesture of Codename
+    /// One's.
+    @Override
+    public void pointerDragged(int[] x, int[] y) {
+        if (x != null && y != null && x.length == 1 && y.length == 1
+                && EventBridge.pointerEvent(window, MouseEvent.MOUSE_DRAGGED, x[0], y[0])) {
+            return;
+        }
+        super.pointerDragged(x, y);
+    }
+
+    @Override
+    public void pointerReleased(int x, int y) {
+        if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_RELEASED, x, y)) {
+            super.pointerReleased(x, y);
+        }
+    }
+
+    @Override
+    public void longPointerPress(int x, int y) {
+        EventBridge.longPress(window, x, y);
+        super.longPointerPress(x, y);
+    }
+
+    @Override
+    public void pointerHover(int[] x, int[] y) {
+        if (x != null && y != null && x.length > 0 && y.length > 0) {
+            EventBridge.pointerEvent(window, MouseEvent.MOUSE_MOVED, x[0], y[0]);
+        }
+        super.pointerHover(x, y);
+    }
+
+    @Override
+    public void keyPressed(int keyCode) {
+        if (!EventBridge.key(window, true, keyCode)) {
+            super.keyPressed(keyCode);
+        }
+    }
+
+    @Override
+    public void keyRepeated(int keyCode) {
+        if (!EventBridge.key(window, true, keyCode)) {
+            super.keyRepeated(keyCode);
+        }
+    }
+
+    @Override
+    public void keyReleased(int keyCode) {
+        if (!EventBridge.key(window, false, keyCode)) {
+            super.keyReleased(keyCode);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DisplayInputState.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DisplayInputState.java
new file mode 100644
index 00000000000..c3d82b26a81
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/DisplayInputState.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.ui.Display;
+import com.codename1.ui.events.PointerEvent;
+
+/// The input state the display reports.
+///
+/// The modifiers are the union of what the pointer event being delivered
+/// carries and what `Display.isShiftKeyDown()` and its siblings answer.
+/// Both are filled in by the desktop ports only: on a phone, and on any
+/// port whose implementation does not track the keyboard, no modifier is
+/// ever reported, for key events as for mouse events.
+final class DisplayInputState implements InputState {
+
+    @Override
+    public int modifiers() {
+        if (!Display.isInitialized()) {
+            return 0;
+        }
+        Display d = Display.getInstance();
+        PointerEvent pe = d.getCurrentPointerEvent();
+        int m = 0;
+        if (d.isShiftKeyDown() || (pe != null && pe.isShiftDown())) {
+            m |= InputEvent.SHIFT_DOWN_MASK;
+        }
+        if (d.isControlKeyDown() || (pe != null && pe.isControlDown())) {
+            m |= InputEvent.CTRL_DOWN_MASK;
+        }
+        if (d.isAltKeyDown() || (pe != null && pe.isAltDown())) {
+            m |= InputEvent.ALT_DOWN_MASK;
+        }
+        if (d.isMetaKeyDown() || (pe != null && pe.isMetaDown())) {
+            m |= InputEvent.META_DOWN_MASK;
+        }
+        if (d.isAltGraphKeyDown()) {
+            m |= InputEvent.ALT_GRAPH_DOWN_MASK;
+        }
+        return m;
+    }
+
+    @Override
+    public int button() {
+        if (!Display.isInitialized()) {
+            return MouseEvent.BUTTON1;
+        }
+        PointerEvent pe = Display.getInstance().getCurrentPointerEvent();
+        if (pe == null) {
+            return MouseEvent.BUTTON1;
+        }
+        switch (pe.getButton()) {
+            case PointerEvent.BUTTON_SECONDARY:
+                return MouseEvent.BUTTON3;
+            case PointerEvent.BUTTON_MIDDLE:
+                return MouseEvent.BUTTON2;
+            default:
+                return MouseEvent.BUTTON1;
+        }
+    }
+
+    @Override
+    public boolean touch() {
+        if (!Display.isInitialized()) {
+            return false;
+        }
+        PointerEvent pe = Display.getInstance().getCurrentPointerEvent();
+        return pe != null && !pe.isMouse();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Dnd.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Dnd.java
new file mode 100644
index 00000000000..bea8d0d2f33
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Dnd.java
@@ -0,0 +1,521 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import com.codename1.desktopcompat.java.awt.datatransfer.UnsupportedFlavorException;
+import com.codename1.desktopcompat.java.awt.dnd.DnDConstants;
+import com.codename1.desktopcompat.java.awt.dnd.DropTarget;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetDragEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetDropEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetEvent;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.ui.ClipboardContent;
+import com.codename1.ui.Display;
+import com.codename1.ui.NativeDragOperation;
+import com.codename1.ui.NativeDropEvent;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/// The one drag that can be under way, and the drop target it is over.
+///
+/// A drag comes from one of two places. One that begins in the layer,
+/// with `TransferHandler.exportAsDrag`, is followed here from the pointer
+/// events the [EventBridge] hands over: nothing leaves the application and
+/// the data is the `Transferable` the handler made. One that the platform
+/// reports -- files or text from another application -- arrives through
+/// Codename One's native drop events on the peer of the window.
+///
+/// Either way the target is the deepest component under the pointer that
+/// has an active `DropTarget`, as in AWT, and its listener is told of
+/// enter, over, exit and drop in the component's own coordinates. A
+/// listener that neither accepts nor rejects a drag has accepted the
+/// action the user asked for, when the target takes that action.
+public final class Dnd {
+
+    /// What hears that a drag begun in the layer is over.
+    public interface Source {
+
+        /// The drag ended; `action` is what the target did with the
+        /// data, `ACTION_NONE` when it was not dropped or not taken.
+        void done(int action);
+    }
+
+    private static final String LISTENER = "cn1.desktopcompat.dnd";
+
+    private static boolean wanted;
+
+    private static Transferable data;
+    private static int sourceActions;
+    private static boolean localDrag;
+    private static Source source;
+
+    private static DropTarget over;
+    private static int answer;
+    private static boolean dropping;
+    private static boolean completed;
+    private static boolean success;
+
+    private Dnd() {
+    }
+
+    // ------------------------------------------------------------ targets
+
+    /// Something in the application takes drops: from here on the windows
+    /// ask the platform for the drags it reports.
+    public static void want() {
+        if (wanted) {
+            return;
+        }
+        wanted = true;
+        Window[] all = WindowHosts.windows();
+        for (Window w : all) {
+            listen(w);
+        }
+    }
+
+    /// Whether anything in the application takes drops.
+    public static boolean wanted() {
+        return wanted;
+    }
+
+    /// Asks the platform for the drags over `w`, once it has a peer and
+    /// when something takes drops at all.
+    public static void listen(Window w) {
+        if (!wanted || w == null || !Display.isInitialized()) {
+            return;
+        }
+        com.codename1.ui.Component peer = w.cn1PeerOrNull();
+        if (peer == null || peer.getClientProperty(LISTENER) != null) {
+            return;
+        }
+        Drops d = new Drops(w);
+        peer.putClientProperty(LISTENER, d);
+        peer.setNativeDropTarget(true);
+        peer.addNativeDragOverListener(d);
+        peer.addNativeDropListener(d);
+    }
+
+    /// The data of the drag under way, or `null`.
+    public static Transferable transferable() {
+        return data;
+    }
+
+    /// The answer of the listener of `t` to the drag over it.
+    public static void answer(DropTarget t, int action) {
+        if (t != over) {
+            return;
+        }
+        answer = single(action);
+    }
+
+    /// The listener of `t` says whether it took the data dropped on it.
+    public static void complete(DropTarget t, boolean ok) {
+        if (t != over || !dropping) {
+            return;
+        }
+        completed = true;
+        success = ok;
+    }
+
+    /// The first of move, copy and link that is in `actions`.
+    private static int single(int actions) {
+        if ((actions & DnDConstants.ACTION_MOVE) != 0) {
+            return DnDConstants.ACTION_MOVE;
+        }
+        if ((actions & DnDConstants.ACTION_COPY) != 0) {
+            return DnDConstants.ACTION_COPY;
+        }
+        if ((actions & DnDConstants.ACTION_LINK) != 0) {
+            return DnDConstants.ACTION_LINK;
+        }
+        return DnDConstants.ACTION_NONE;
+    }
+
+    private static Point local(Window w, Component target, int x, int y) {
+        int lx = x;
+        int ly = y;
+        for (Component c = target; c != null && c != w; c = c.getParent()) {
+            lx -= c.getX();
+            ly -= c.getY();
+        }
+        return new Point(lx, ly);
+    }
+
+    private static DropTarget targetAt(Window w, int x, int y) {
+        if (w == null) {
+            return null;
+        }
+        for (Component c = w.findComponentAt(x, y); c != null; c = c.getParent()) {
+            DropTarget t = c.getDropTarget();
+            if (t != null && t.isActive() && t.getComponent() == c) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    private static void leave() {
+        DropTarget old = over;
+        if (old != null) {
+            try {
+                old.dragExit(new DropTargetEvent(old.getDropTargetContext()));
+            } finally {
+                over = null;
+                answer = DnDConstants.ACTION_NONE;
+            }
+        }
+    }
+
+    /// A drag is at `x`, `y` of `w`, in logical pixels. `t` is its data,
+    /// `allowed` the actions its source allows and `user` the one the
+    /// user asked for. Answers the action the target under the pointer
+    /// accepts, `ACTION_NONE` when there is none or it refused.
+    public static int over(Window w, int x, int y, Transferable t, int allowed, int user, boolean local) {
+        data = t;
+        sourceActions = allowed;
+        DropTarget target = targetAt(w, x, y);
+        boolean entered = target != over;
+        if (entered) {
+            leave();
+            over = target;
+        }
+        if (target == null) {
+            return DnDConstants.ACTION_NONE;
+        }
+        answer = user;
+        DropTargetDragEvent e = new DropTargetDragEvent(target.getDropTargetContext(),
+                local(w, target.getComponent(), x, y), user, allowed);
+        if (entered) {
+            target.dragEnter(e);
+        } else {
+            target.dragOver(e);
+        }
+        if (over != target || (answer & target.getDefaultActions()) == 0) {
+            return DnDConstants.ACTION_NONE;
+        }
+        return answer;
+    }
+
+    /// The drag left every window, or was given up.
+    public static void exit() {
+        try {
+            leave();
+        } finally {
+            if (!localDrag) {
+                data = null;
+            }
+        }
+    }
+
+    /// The drag was let go at `x`, `y` of `w`. Answers what the target
+    /// did with the data: the action it accepted when it reported
+    /// success, `ACTION_NONE` otherwise.
+    public static int drop(Window w, int x, int y, Transferable t, int allowed, int user, boolean local) {
+        int accepted = over(w, x, y, t, allowed, user, local);
+        DropTarget target = over;
+        if (target == null) {
+            data = null;
+            return DnDConstants.ACTION_NONE;
+        }
+        if (accepted == DnDConstants.ACTION_NONE) {
+            // As a platform does: a drag let go where it was refused
+            // leaves the target, it is not dropped on it.
+            try {
+                leave();
+            } finally {
+                data = null;
+            }
+            return DnDConstants.ACTION_NONE;
+        }
+        dropping = true;
+        completed = false;
+        success = false;
+        answer = DnDConstants.ACTION_NONE;
+        try {
+            target.drop(new DropTargetDropEvent(target.getDropTargetContext(),
+                    local(w, target.getComponent(), x, y), accepted, allowed, local));
+            return completed && success ? answer : DnDConstants.ACTION_NONE;
+        } finally {
+            dropping = false;
+            over = null;
+            answer = DnDConstants.ACTION_NONE;
+            data = null;
+        }
+    }
+
+    // ------------------------------------------------------------ drags of the layer's own
+
+    /// Begins a drag of `t` within the application. From now until the
+    /// pointer is let go its events are the drag's: see [#dragging()].
+    public static void begin(Transferable t, int actions, Source s) {
+        if (localDrag) {
+            cancel();
+        }
+        data = t;
+        sourceActions = actions;
+        source = s;
+        localDrag = true;
+    }
+
+    /// Whether a drag begun with [#begin] is under way.
+    public static boolean dragging() {
+        return localDrag;
+    }
+
+    /// The action a drag asks for: the one the modifier keys name, as on
+    /// a desktop, or the first of move, copy and link the source allows.
+    public static int userAction(int modifiers, int allowed) {
+        boolean ctrl = (modifiers & (InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK)) != 0;
+        boolean shift = (modifiers & (InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK)) != 0;
+        int asked;
+        if (ctrl && shift) {
+            asked = DnDConstants.ACTION_LINK;
+        } else if (ctrl) {
+            asked = DnDConstants.ACTION_COPY;
+        } else if (shift) {
+            asked = DnDConstants.ACTION_MOVE;
+        } else {
+            return single(allowed);
+        }
+        return asked & allowed;
+    }
+
+    /// The pointer moved during a drag of the layer's own.
+    static void localMove(Window w, int x, int y, int modifiers) {
+        over(w, x, y, data, sourceActions, userAction(modifiers, sourceActions), true);
+    }
+
+    /// The pointer was let go during a drag of the layer's own.
+    static void localDrop(Window w, int x, int y, int modifiers) {
+        int done = DnDConstants.ACTION_NONE;
+        try {
+            done = drop(w, x, y, data, sourceActions, userAction(modifiers, sourceActions), true);
+        } finally {
+            end(done);
+        }
+    }
+
+    /// Gives up a drag of the layer's own.
+    public static void cancel() {
+        if (!localDrag) {
+            return;
+        }
+        try {
+            leave();
+        } finally {
+            end(DnDConstants.ACTION_NONE);
+        }
+    }
+
+    private static void end(int action) {
+        Source s = source;
+        source = null;
+        localDrag = false;
+        data = null;
+        if (s != null) {
+            s.done(action);
+        }
+    }
+
+    // ------------------------------------------------------------ drags the platform reports
+
+    private static int fromNative(int actions) {
+        int out = DnDConstants.ACTION_NONE;
+        if ((actions & NativeDragOperation.ACTION_COPY) != 0) {
+            out |= DnDConstants.ACTION_COPY;
+        }
+        if ((actions & NativeDragOperation.ACTION_MOVE) != 0) {
+            out |= DnDConstants.ACTION_MOVE;
+        }
+        if ((actions & NativeDragOperation.ACTION_LINK) != 0) {
+            out |= DnDConstants.ACTION_LINK;
+        }
+        return out;
+    }
+
+    private static int toNative(int action) {
+        switch (action) {
+            case DnDConstants.ACTION_COPY:
+                return NativeDragOperation.ACTION_COPY;
+            case DnDConstants.ACTION_MOVE:
+                return NativeDragOperation.ACTION_MOVE;
+            case DnDConstants.ACTION_LINK:
+                return NativeDragOperation.ACTION_LINK;
+            default:
+                return NativeDragOperation.ACTION_NONE;
+        }
+    }
+
+    /// What a drag from outside asks for when it allows several actions:
+    /// a copy, which leaves the other application's data where it is.
+    private static int preferred(int allowed) {
+        if ((allowed & DnDConstants.ACTION_COPY) != 0) {
+            return DnDConstants.ACTION_COPY;
+        }
+        return single(allowed);
+    }
+
+    /// The listener on the peer of one window.
+    private static final class Drops implements ActionListener<ActionEvent> {
+
+        private final Window window;
+        private ClipboardContent seen;
+        private Transferable made;
+
+        Drops(Window w) {
+            window = w;
+        }
+
+        private Transferable dataOf(ClipboardContent c) {
+            if (c != seen || made == null) {
+                seen = c;
+                made = new Content(c);
+            }
+            return made;
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (!(evt instanceof NativeDropEvent) || localDrag) {
+                return;
+            }
+            NativeDropEvent ev = (NativeDropEvent) evt;
+            ActionEvent.Type type = ev.getEventType();
+            if (type == ActionEvent.Type.NativeDragExit) {
+                exit();
+                return;
+            }
+            com.codename1.ui.Component peer = window.cn1PeerOrNull();
+            if (peer == null) {
+                ev.reject();
+                return;
+            }
+            int x = Units.toLogical(ev.getX() - peer.getAbsoluteX());
+            int y = Units.toLogical(ev.getY() - peer.getAbsoluteY());
+            int allowed = fromNative(ev.getAllowedActions());
+            int user = preferred(allowed);
+            Transferable t = dataOf(ev.getContent());
+            int action;
+            if (type == ActionEvent.Type.NativeDrop) {
+                seen = null;
+                made = null;
+                action = drop(window, x, y, t, allowed, user, ev.isLocal());
+            } else {
+                action = over(window, x, y, t, allowed, user, ev.isLocal());
+            }
+            if (action == DnDConstants.ACTION_NONE) {
+                ev.reject();
+            } else {
+                ev.accept(toNative(action));
+            }
+        }
+    }
+
+    /// What the platform is dragging, as a `Transferable`: files as
+    /// `javaFileListFlavor`, text as `stringFlavor`.
+    private static final class Content implements Transferable {
+
+        private final ClipboardContent content;
+
+        Content(ClipboardContent c) {
+            content = c;
+        }
+
+        private boolean files() {
+            return content != null && content.hasMimeType(ClipboardContent.MIME_FILE);
+        }
+
+        private boolean text() {
+            return content != null && content.hasMimeType(ClipboardContent.MIME_TEXT);
+        }
+
+        @Override
+        public DataFlavor[] getTransferDataFlavors() {
+            boolean f = files();
+            boolean s = text();
+            if (f && s) {
+                return new DataFlavor[]{DataFlavor.javaFileListFlavor, DataFlavor.stringFlavor};
+            }
+            if (f) {
+                return new DataFlavor[]{DataFlavor.javaFileListFlavor};
+            }
+            if (s) {
+                return new DataFlavor[]{DataFlavor.stringFlavor};
+            }
+            return new DataFlavor[0];
+        }
+
+        @Override
+        public boolean isDataFlavorSupported(DataFlavor flavor) {
+            if (DataFlavor.javaFileListFlavor.equals(flavor)) {
+                return files();
+            }
+            return DataFlavor.stringFlavor.equals(flavor) && text();
+        }
+
+        @Override
+        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+            if (!isDataFlavorSupported(flavor)) {
+                throw new UnsupportedFlavorException(flavor);
+            }
+            if (DataFlavor.javaFileListFlavor.equals(flavor)) {
+                String[] paths = content.getFiles();
+                if (paths == null) {
+                    // A platform names what a drag carries while it
+                    // hovers and hands the values over with the drop.
+                    throw new IOException("The files of a drag can be read once it is dropped");
+                }
+                List<java.io.File> out = new ArrayList<java.io.File>(paths.length);
+                for (String p : paths) {
+                    if (p != null) {
+                        out.add(new java.io.File(p));
+                    }
+                }
+                return out;
+            }
+            String s = content.getText(ClipboardContent.MIME_TEXT);
+            if (s == null) {
+                throw new IOException("The text of a drag can be read once it is dropped");
+            }
+            return s;
+        }
+    }
+
+    /// Forgets the drag under way. For tests.
+    public static void reset() {
+        data = null;
+        source = null;
+        localDrag = false;
+        over = null;
+        answer = DnDConstants.ACTION_NONE;
+        dropping = false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/EmbedHost.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/EmbedHost.java
new file mode 100644
index 00000000000..1a527db19bd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/EmbedHost.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JWindow;
+import com.codename1.ui.Command;
+import com.codename1.ui.Container;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.layouts.BorderLayout;
+import java.util.List;
+
+/// A Codename One component that shows a Swing component tree inside a
+/// form of a Codename One application: what
+/// `com.codename1.desktopcompat.SwingInterop.asComponent` answers.
+///
+/// The tree is given a window of its own -- an undecorated `JWindow` that
+/// is never on the screen as a window -- because a Swing tree only lays
+/// out, paints, finds the layered pane of its popups and resolves
+/// `SwingUtilities.getWindowAncestor` under one. This component is that
+/// window's host: the window's peer fills it, so the tree is laid out to
+/// whatever size Codename One gives the component, and its preferred size
+/// is the tree's.
+///
+/// Pointer input is taken from the form the component is on, the way a
+/// form that shows a frame takes it ([FrameForm]), for as long as the
+/// component is on a showing form. Keys reach the text components through
+/// Codename One's own editing; a key binding or accelerator that depends on
+/// the window having the keyboard needs a window (`JFrame.setVisible`).
+public final class EmbedHost extends Container implements WindowHost {
+
+    private final JWindow window;
+    private Form listening;
+    private boolean pressedInside;
+
+    private final ActionListener<ActionEvent> pressed = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            pressedInside = contains(evt.getX(), evt.getY());
+            if (pressedInside) {
+                deliver(evt, MouseEvent.MOUSE_PRESSED);
+            }
+        }
+    };
+
+    private final ActionListener<ActionEvent> dragged = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (pressedInside) {
+                deliver(evt, MouseEvent.MOUSE_DRAGGED);
+            }
+        }
+    };
+
+    private final ActionListener<ActionEvent> released = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (pressedInside) {
+                pressedInside = false;
+                deliver(evt, MouseEvent.MOUSE_RELEASED);
+            }
+        }
+    };
+
+    private final ActionListener<ActionEvent> longPressed = new ActionListener<ActionEvent>() {
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            if (contains(evt.getX(), evt.getY())) {
+                EventBridge.longPress(window, evt.getX(), evt.getY());
+            }
+        }
+    };
+
+    /// Hosts `content`, which leaves whatever container it was in.
+    public EmbedHost(Component content) {
+        super(new BorderLayout());
+        PeerSupport.strip(this);
+        setScrollableX(false);
+        setScrollableY(false);
+        window = new JWindow();
+        window.getContentPane().add(content, com.codename1.desktopcompat.java.awt.BorderLayout.CENTER);
+        window.cn1Embed(this);
+        com.codename1.ui.Component p = window.cn1Peer();
+        p.remove();
+        add(BorderLayout.CENTER, p);
+        WindowHosts.listenWheel(window, p);
+    }
+
+    /// The window the tree is under.
+    public Window window() {
+        return window;
+    }
+
+    private void deliver(ActionEvent evt, int id) {
+        if (EventBridge.pointerEvent(window, id, evt.getX(), evt.getY())) {
+            evt.consume();
+        }
+    }
+
+    @Override
+    protected void initComponent() {
+        super.initComponent();
+        Form f = getComponentForm();
+        if (f != null && listening != f) {
+            unlisten();
+            listening = f;
+            f.addPointerPressedListener(pressed);
+            f.addPointerDraggedListener(dragged);
+            f.addPointerReleasedListener(released);
+            f.addLongPressListener(longPressed);
+        }
+    }
+
+    @Override
+    protected void deinitialize() {
+        unlisten();
+        super.deinitialize();
+    }
+
+    private void unlisten() {
+        Form f = listening;
+        if (f != null) {
+            listening = null;
+            pressedInside = false;
+            f.removePointerPressedListener(pressed);
+            f.removePointerDraggedListener(dragged);
+            f.removePointerReleasedListener(released);
+            f.removeLongPressListener(longPressed);
+        }
+    }
+
+    @Override
+    public void open() {
+    }
+
+    @Override
+    public void close() {
+    }
+
+    @Override
+    public void release() {
+    }
+
+    @Override
+    public void title(String title) {
+    }
+
+    @Override
+    public void icon(Image icon) {
+    }
+
+    @Override
+    public void bounds() {
+    }
+
+    @Override
+    public void resizable(boolean resizable) {
+    }
+
+    @Override
+    public void decorated(boolean decorated) {
+    }
+
+    @Override
+    public void state(int state) {
+    }
+
+    /// Nothing: a menu bar in the tree is drawn as a row of menus, which
+    /// open as popups, since this host has no toolbar of its own.
+    @Override
+    public void commands(List<Command> commands) {
+    }
+
+    @Override
+    public boolean takesCommands() {
+        return false;
+    }
+
+    @Override
+    public Form form() {
+        return getComponentForm();
+    }
+
+    @Override
+    public boolean fillsDisplay() {
+        return true;
+    }
+
+    @Override
+    public boolean reusable() {
+        return true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/EventBridge.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/EventBridge.java
new file mode 100644
index 00000000000..04835f9ea75
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/EventBridge.java
@@ -0,0 +1,621 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.KeyboardFocusManager;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelEvent;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JPopupMenu;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JInternalFrame;
+import com.codename1.desktopcompat.javax.swing.MenuSelectionManager;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.ui.Display;
+import com.codename1.ui.plaf.UIManager;
+
+/// Turns Codename One input into AWT events.
+///
+/// Pointer and key input enters at the host of a window (see
+/// [WindowHost]). A pointer event goes to the deepest visible component
+/// under the pointer that wants mouse events, or the nearest ancestor that
+/// does; when that component is disabled the event is dropped. The
+/// component pressed keeps receiving the drags and the release. Key events
+/// go to the focus owner, or to the window when no component of it owns
+/// the focus.
+///
+/// What an application can rely on:
+///
+/// - Modifiers and the button come from an [InputState]; see
+///   [DisplayInputState] for what the ports report.
+/// - A press with the secondary button is a popup trigger. So is the
+///   release that ends a long press of a finger or stylus, which produces
+///   no click. Either shows the component popup menu of the component
+///   under the pointer.
+/// - Clicks count up while they follow each other within half a second,
+///   on the same component, with the same button, without moving.
+/// - A press outside an open popup menu closes it and goes no further.
+/// - A key pressed that no listener or key binding consumed moves the
+///   focus when it is the tab key; escape closes an open popup menu.
+public final class EventBridge {
+
+    private static final int CLICK_INTERVAL = 500;
+
+    private static final InputState DISPLAY_STATE = new DisplayInputState();
+
+    private static InputState input = DISPLAY_STATE;
+    private static Component focusOwner;
+    private static Component pressTarget;
+    private static Component hoverTarget;
+    private static Component lastClickTarget;
+    private static long lastClickTime;
+    private static int lastClickButton;
+    private static int clickCount;
+    private static int pressX;
+    private static int pressY;
+    private static int pressButton;
+    private static boolean dragged;
+    private static boolean swallowed;
+    private static boolean longPressed;
+    private static boolean popupShown;
+
+    private EventBridge() {
+    }
+
+    /// Replaces the source of modifiers and buttons; `null` restores the
+    /// display's. For tests.
+    public static void setInputState(InputState state) {
+        input = state == null ? DISPLAY_STATE : state;
+    }
+
+    // ------------------------------------------------------------ focus
+
+    /// The component key events go to, or `null`.
+    public static Component focusOwner() {
+        return focusOwner;
+    }
+
+    /// Moves the focus to `c`, firing focus lost and focus gained.
+    /// `toPeer` also focuses the Codename One widget behind it.
+    public static void setFocusOwner(Component c, boolean toPeer) {
+        Component old = focusOwner;
+        if (old == c) {
+            return;
+        }
+        focusOwner = c;
+        if (old != null) {
+            old.dispatchEvent(new FocusEvent(old, FocusEvent.FOCUS_LOST, false, c));
+        }
+        if (c != null) {
+            c.dispatchEvent(new FocusEvent(c, FocusEvent.FOCUS_GAINED, false, old));
+            com.codename1.ui.Component p = c.cn1PeerOrNull();
+            if (toPeer && p instanceof Peer && ((Peer) p).nativeLook() && p.isFocusable()
+                    && p.getTopLevelContainer() != null) {
+                p.requestFocus();
+            }
+        }
+        KeyboardFocusManager.cn1FocusChanged(old, c);
+    }
+
+    /// The Codename One widget behind `c` lost the focus.
+    public static void nativeFocusLost(Component c) {
+        if (focusOwner == c) {
+            setFocusOwner(null, false);
+        }
+    }
+
+    /// Drops every reference to a component that left its window.
+    public static void forget(Component c) {
+        if (focusOwner == c) {
+            focusOwner = null;
+        }
+        if (pressTarget == c) {
+            pressTarget = null;
+        }
+        if (hoverTarget == c) {
+            hoverTarget = null;
+        }
+        if (lastClickTarget == c) {
+            lastClickTarget = null;
+        }
+    }
+
+    /// Forgets the last click, so that the next one counts as the first
+    /// wherever and whenever it lands. The count otherwise belongs to a
+    /// place and a button: a click within half a second of the last one,
+    /// with the same button and within a few pixels of it, counts up.
+    public static void resetClickCount() {
+        lastClickTarget = null;
+        lastClickTime = 0;
+        clickCount = 0;
+    }
+
+    // ------------------------------------------------------------ theme
+
+    /// The background a window has when none was set: the theme's form
+    /// background, white with no display.
+    public static Color defaultBackground() {
+        if (!Display.isInitialized()) {
+            return Color.WHITE;
+        }
+        return new Color(UIManager.getInstance().getComponentStyle("Form").getBgColor() & 0xffffff);
+    }
+
+    /// The foreground a window has when none was set: the theme's label
+    /// color, black with no display.
+    public static Color defaultForeground() {
+        if (!Display.isInitialized()) {
+            return Color.BLACK;
+        }
+        return new Color(UIManager.getInstance().getComponentStyle("Label").getFgColor() & 0xffffff);
+    }
+
+    // ------------------------------------------------------------ pointer
+
+    /// The component that receives a mouse event at `hit`: the nearest
+    /// component from `hit` up that wants mouse events, unless it is
+    /// disabled.
+    private static Component mouseTarget(Component hit) {
+        Component c = hit;
+        while (c != null && !c.cn1WantsMouse()) {
+            c = c.getParent();
+        }
+        return c != null && c.isEnabled() ? c : null;
+    }
+
+    private static int buttonMask(int button) {
+        switch (button) {
+            case MouseEvent.BUTTON1:
+                return InputEvent.BUTTON1_MASK;
+            case MouseEvent.BUTTON2:
+                return InputEvent.BUTTON2_MASK;
+            case MouseEvent.BUTTON3:
+                return InputEvent.BUTTON3_MASK;
+            default:
+                return 0;
+        }
+    }
+
+    private static int buttonDownMask(int button) {
+        switch (button) {
+            case MouseEvent.BUTTON1:
+                return InputEvent.BUTTON1_DOWN_MASK;
+            case MouseEvent.BUTTON2:
+                return InputEvent.BUTTON2_DOWN_MASK;
+            case MouseEvent.BUTTON3:
+                return InputEvent.BUTTON3_DOWN_MASK;
+            default:
+                return 0;
+        }
+    }
+
+    /// Both encodings of a set of extended keyboard modifiers.
+    private static int both(int ex) {
+        int m = ex;
+        if ((ex & InputEvent.SHIFT_DOWN_MASK) != 0) {
+            m |= InputEvent.SHIFT_MASK;
+        }
+        if ((ex & InputEvent.CTRL_DOWN_MASK) != 0) {
+            m |= InputEvent.CTRL_MASK;
+        }
+        if ((ex & InputEvent.ALT_DOWN_MASK) != 0) {
+            m |= InputEvent.ALT_MASK;
+        }
+        if ((ex & InputEvent.META_DOWN_MASK) != 0) {
+            m |= InputEvent.META_MASK;
+        }
+        if ((ex & InputEvent.ALT_GRAPH_DOWN_MASK) != 0) {
+            m |= InputEvent.ALT_GRAPH_MASK;
+        }
+        return m;
+    }
+
+    /// The position of a window relative point in `target`'s coordinates.
+    private static int[] local(Window w, Component target, int x, int y) {
+        int lx = x;
+        int ly = y;
+        for (Component c = target; c != null && c != w; c = c.getParent()) {
+            lx -= c.getX();
+            ly -= c.getY();
+        }
+        return new int[]{lx, ly};
+    }
+
+    private static void send(Window w, Component target, int id, int x, int y, int clicks, int button,
+            boolean trigger) {
+        int[] p = local(w, target, x, y);
+        boolean down = id == MouseEvent.MOUSE_PRESSED || id == MouseEvent.MOUSE_DRAGGED;
+        int mods = both(input.modifiers()) | buttonMask(button) | (down ? buttonDownMask(button) : 0);
+        target.dispatchEvent(new MouseEvent(target, id, System.currentTimeMillis(), mods, p[0], p[1], clicks,
+                trigger, id == MouseEvent.MOUSE_DRAGGED || id == MouseEvent.MOUSE_MOVED
+                || id == MouseEvent.MOUSE_ENTERED || id == MouseEvent.MOUSE_EXITED ? MouseEvent.NOBUTTON : button));
+    }
+
+    /// The component a press was on that takes no mouse events itself,
+    /// while the toolkit's listeners are told of them.
+    private static Component toldPress;
+
+    /// Tells the toolkit's listeners of a mouse event on a component that
+    /// handles the pointer in its widget and so is sent none: on the
+    /// desktop every widget has mouse listeners of its look and feel, and
+    /// an `AWTEventListener` hears of a click on a button.
+    private static void tell(Window w, Component hit, int id, int x, int y, int clicks, int button) {
+        if (hit == null || !AwtListeners.any()) {
+            return;
+        }
+        int[] p = local(w, hit, x, y);
+        boolean down = id == MouseEvent.MOUSE_PRESSED || id == MouseEvent.MOUSE_DRAGGED;
+        int mods = both(input.modifiers()) | buttonMask(button) | (down ? buttonDownMask(button) : 0);
+        AwtListeners.dispatching(new MouseEvent(hit, id, System.currentTimeMillis(), mods, p[0], p[1], clicks,
+                false, id == MouseEvent.MOUSE_DRAGGED || id == MouseEvent.MOUSE_MOVED ? MouseEvent.NOBUTTON : button));
+    }
+
+    private static void hover(Window w, Component target, int x, int y) {
+        if (target == hoverTarget) {
+            return;
+        }
+        Component old = hoverTarget;
+        hoverTarget = target;
+        if (old != null) {
+            Window ow = SwingUtilities.getRoot(old) instanceof Window ? (Window) SwingUtilities.getRoot(old) : w;
+            send(ow, old, MouseEvent.MOUSE_EXITED, x, y, 0, MouseEvent.NOBUTTON, false);
+        }
+        if (target != null) {
+            send(w, target, MouseEvent.MOUSE_ENTERED, x, y, 0, MouseEvent.NOBUTTON, false);
+        }
+    }
+
+    /// Shows the component popup menu that applies at `hit`, if any.
+    private static boolean showPopup(Window w, Component hit, int x, int y) {
+        for (Component c = hit; c != null; c = c.getParent()) {
+            if (c instanceof JComponent) {
+                JPopupMenu menu = ((JComponent) c).getComponentPopupMenu();
+                if (menu != null) {
+                    if (!c.isEnabled()) {
+                        return false;
+                    }
+                    int[] p = local(w, c, x, y);
+                    menu.show(c, p[0], p[1]);
+                    return true;
+                }
+            }
+            if (c.cn1WantsMouse() && c != hit) {
+                return false;
+            }
+        }
+        return false;
+    }
+
+    /// As [#pointerEvent]; kept for hosts that do not care whether the
+    /// event was swallowed.
+    public static void pointer(Window w, int id, int deviceX, int deviceY) {
+        pointerEvent(w, id, deviceX, deviceY);
+    }
+
+    /// Delivers pointer input that reached the host of `w`. `id` is one of
+    /// `MOUSE_PRESSED`, `MOUSE_RELEASED`, `MOUSE_DRAGGED` and
+    /// `MOUSE_MOVED`; the position is in display coordinates.
+    ///
+    /// Answers `true` when the layer used the event up -- it closed a
+    /// popup menu -- and the host must keep it from the Codename One
+    /// components under the pointer.
+    public static boolean pointerEvent(Window w, int id, int deviceX, int deviceY) {
+        com.codename1.ui.Component rp = w.cn1PeerOrNull();
+        if (rp == null) {
+            return false;
+        }
+        if (Display.isInitialized() && Display.getInstance().isScrollWheeling()) {
+            // A desktop port scrolls with the wheel by sending a press, a
+            // drag and a release; those are not the mouse's buttons.
+            return false;
+        }
+        int x = Units.toLogical(deviceX - rp.getAbsoluteX());
+        int y = Units.toLogical(deviceY - rp.getAbsoluteY());
+        switch (id) {
+            case MouseEvent.MOUSE_PRESSED: {
+                // A drag whose release never arrived is over.
+                Dnd.cancel();
+                Component hit = w.findComponentAt(x, y);
+                MenuSelectionManager menus = MenuSelectionManager.defaultManager();
+                if (menus.cn1PopupShowing() && !menus.cn1Inside(hit)) {
+                    menus.clearSelectedPath();
+                    pressTarget = null;
+                    swallowed = true;
+                    return true;
+                }
+                swallowed = false;
+                longPressed = false;
+                popupShown = false;
+                JInternalFrame.cn1PressedIn(hit);
+                Component target = mouseTarget(hit);
+                hover(w, target, x, y);
+                int button = input.button();
+                long now = System.currentTimeMillis();
+                int slop = Math.max(2, (int) (4 * Units.scale()));
+                // As on a desktop the count belongs to the place and the
+                // button, not to the component that happens to listen.
+                boolean again = target != null && lastClickTarget != null && button == lastClickButton
+                        && now - lastClickTime < CLICK_INTERVAL && Math.abs(deviceX - pressX) <= slop
+                        && Math.abs(deviceY - pressY) <= slop;
+                clickCount = again ? clickCount + 1 : 1;
+                pressTarget = target;
+                pressX = deviceX;
+                pressY = deviceY;
+                pressButton = button;
+                dragged = false;
+                boolean trigger = button == MouseEvent.BUTTON3;
+                toldPress = null;
+                if (target != null) {
+                    send(w, target, id, x, y, clickCount, button, trigger);
+                } else if (hit != null && hit.isEnabled()) {
+                    toldPress = hit;
+                    tell(w, hit, id, x, y, 1, button);
+                }
+                if (trigger) {
+                    popupShown = showPopup(w, hit, x, y);
+                }
+                return false;
+            }
+            case MouseEvent.MOUSE_DRAGGED: {
+                if (swallowed) {
+                    return true;
+                }
+                if (Dnd.dragging()) {
+                    Dnd.localMove(w, x, y, both(input.modifiers()));
+                    return true;
+                }
+                int slop = Math.max(2, (int) (3 * Units.scale()));
+                if (Math.abs(deviceX - pressX) > slop || Math.abs(deviceY - pressY) > slop) {
+                    dragged = true;
+                }
+                if (pressTarget != null) {
+                    send(w, pressTarget, id, x, y, 0, pressButton, false);
+                } else {
+                    tell(w, toldPress, id, x, y, 0, pressButton);
+                }
+                // The component may have begun a drag of its data with
+                // this very event; the pointer is the drag's from here on.
+                return Dnd.dragging();
+            }
+            case MouseEvent.MOUSE_RELEASED: {
+                if (swallowed) {
+                    swallowed = false;
+                    return true;
+                }
+                if (Dnd.dragging()) {
+                    // The press that began the drag gets no release and
+                    // no click, as on a desktop: the drop is what ends it.
+                    pressTarget = null;
+                    longPressed = false;
+                    Dnd.localDrop(w, x, y, both(input.modifiers()));
+                    return true;
+                }
+                Component target = pressTarget;
+                pressTarget = null;
+                boolean trigger = longPressed;
+                longPressed = false;
+                if (target != null) {
+                    send(w, target, id, x, y, clickCount, pressButton, trigger);
+                    if (!dragged && !trigger) {
+                        lastClickTime = System.currentTimeMillis();
+                        lastClickTarget = target;
+                        lastClickButton = pressButton;
+                        send(w, target, MouseEvent.MOUSE_CLICKED, x, y, clickCount, pressButton, false);
+                    }
+                } else if (toldPress != null) {
+                    Component told = toldPress;
+                    toldPress = null;
+                    tell(w, told, id, x, y, 1, pressButton);
+                    if (!dragged) {
+                        tell(w, told, MouseEvent.MOUSE_CLICKED, x, y, 1, pressButton);
+                    }
+                }
+                if (trigger && !popupShown) {
+                    showPopup(w, w.findComponentAt(x, y), x, y);
+                }
+                return false;
+            }
+            case MouseEvent.MOUSE_MOVED: {
+                Component target = mouseTarget(w.findComponentAt(x, y));
+                hover(w, target, x, y);
+                if (target != null) {
+                    send(w, target, id, x, y, 0, MouseEvent.NOBUTTON, false);
+                } else {
+                    tell(w, w.findComponentAt(x, y), id, x, y, 0, MouseEvent.NOBUTTON);
+                }
+                return false;
+            }
+            default:
+                return false;
+        }
+    }
+
+    /// The pointer left the host of `w`: the component it was over gets
+    /// mouse exited.
+    public static void pointerExit(Window w) {
+        if (hoverTarget != null && (hoverTarget == w || w.isAncestorOf(hoverTarget))) {
+            Component old = hoverTarget;
+            hoverTarget = null;
+            send(w, old, MouseEvent.MOUSE_EXITED, -1, -1, 0, MouseEvent.NOBUTTON, false);
+        }
+    }
+
+    /// The host of `w` reported a long press at a display position. With
+    /// a finger or a stylus that is a popup trigger: the component popup
+    /// menu under it shows at once, and the release that follows is
+    /// delivered as a popup trigger and makes no click.
+    public static void longPress(Window w, int deviceX, int deviceY) {
+        com.codename1.ui.Component rp = w.cn1PeerOrNull();
+        if (rp == null || !input.touch() || swallowed || dragged) {
+            return;
+        }
+        longPressed = true;
+        int x = Units.toLogical(deviceX - rp.getAbsoluteX());
+        int y = Units.toLogical(deviceY - rp.getAbsoluteY());
+        popupShown = showPopup(w, w.findComponentAt(x, y), x, y);
+    }
+
+    /// Delivers a wheel movement at a display position: `rotation` clicks,
+    /// positive toward the user. Answers whether a listener received it.
+    public static boolean wheel(Window w, int deviceX, int deviceY, int rotation) {
+        return wheel(w, deviceX, deviceY, rotation, 0);
+    }
+
+    /// As [#wheel(Window, int, int, int)] with extra extended modifiers,
+    /// which is how a horizontal movement is told apart: it carries
+    /// `SHIFT_DOWN_MASK`, as it does on the desktop.
+    ///
+    /// The event goes to the nearest component from the one under the
+    /// pointer up that has a `MouseWheelListener`. The answer is `true`
+    /// when there was one, enabled or not: the wheel is that component's
+    /// then, and nothing else may act on it.
+    public static boolean wheel(Window w, int deviceX, int deviceY, int rotation, int extraModifiers) {
+        com.codename1.ui.Component rp = w.cn1PeerOrNull();
+        if (rp == null || rotation == 0) {
+            return false;
+        }
+        int x = Units.toLogical(deviceX - rp.getAbsoluteX());
+        int y = Units.toLogical(deviceY - rp.getAbsoluteY());
+        Component target = w.findComponentAt(x, y);
+        while (target != null && target.getMouseWheelListeners().length == 0) {
+            target = target.getParent();
+        }
+        if (target == null) {
+            return false;
+        }
+        if (target.isEnabled()) {
+            int[] p = local(w, target, x, y);
+            target.dispatchEvent(new MouseWheelEvent(target, MouseEvent.MOUSE_WHEEL, System.currentTimeMillis(),
+                    both(input.modifiers() | extraModifiers), p[0], p[1], 0, false,
+                    MouseWheelEvent.WHEEL_UNIT_SCROLL, 3, rotation));
+        }
+        return true;
+    }
+
+    /// Whether the wheel at a display position is over a scroll pane that
+    /// was told not to scroll with it.
+    private static boolean wheelScrollingOff(Window w, int deviceX, int deviceY) {
+        com.codename1.ui.Component rp = w.cn1PeerOrNull();
+        if (rp == null) {
+            return false;
+        }
+        Component hit = w.findComponentAt(Units.toLogical(deviceX - rp.getAbsoluteX()),
+                Units.toLogical(deviceY - rp.getAbsoluteY()));
+        for (Component c = hit; c != null; c = c.getParent()) {
+            if (c instanceof JScrollPane) {
+                return !((JScrollPane) c).isWheelScrollingEnabled();
+            }
+        }
+        return false;
+    }
+
+    /// Delivers a Codename One wheel event. Codename One's vertical delta
+    /// is positive when the wheel turned away from the user, the opposite
+    /// of AWT's rotation, and so is its horizontal delta.
+    ///
+    /// Codename One fires its wheel listeners before it scrolls anything,
+    /// and scrolls the nearest scrollable container itself when nobody
+    /// consumed the event. So the event is consumed here exactly when the
+    /// scrolling must not happen: a `MouseWheelListener` of the application
+    /// received it -- on the desktop such a listener replaces the scroll
+    /// pane's own handling, and an application that zooms with the wheel
+    /// must not see the content scroll as well -- or the scroll pane under
+    /// the pointer has wheel scrolling turned off. Left alone, the wheel
+    /// scrolls the viewport once.
+    public static void wheel(Window w, com.codename1.ui.events.WheelEvent we) {
+        int dy = we.getDeltaY();
+        int dx = we.getDeltaX();
+        boolean taken = false;
+        if (dy != 0) {
+            taken = wheel(w, we.getX(), we.getY(), dy > 0 ? -1 : 1, 0);
+        } else if (dx != 0) {
+            taken = wheel(w, we.getX(), we.getY(), dx > 0 ? -1 : 1, InputEvent.SHIFT_DOWN_MASK);
+        }
+        if (taken || wheelScrollingOff(w, we.getX(), we.getY())) {
+            we.consume();
+        }
+    }
+
+    // ------------------------------------------------------------ keys
+
+    /// Delivers a key that reached the host of `w`: key pressed followed
+    /// by key typed where the key has a character and neither control,
+    /// alt nor meta is held, or key released. A key held down arrives as
+    /// further key pressed events.
+    ///
+    /// Answers whether the key is spoken for, in which case the host does
+    /// not hand it to the form as well. Tab is: the focus has moved by
+    /// the traversal policy, and the form of a desktop given the same key
+    /// moves the focus of its own components a second time, by an order
+    /// of its own.
+    public static boolean key(Window w, boolean pressed, int code) {
+        int vk = KeyMap.virtualKey(code);
+        MenuSelectionManager menus = MenuSelectionManager.defaultManager();
+        if (vk == KeyEvent.VK_ESCAPE && menus.cn1PopupShowing()) {
+            if (pressed) {
+                menus.clearSelectedPath();
+            }
+            return false;
+        }
+        Container c = w;
+        Component target = focusOwner != null && (focusOwner == w || c.isAncestorOf(focusOwner)) ? focusOwner : w;
+        long now = System.currentTimeMillis();
+        char ch = KeyMap.keyChar(code);
+        int mods = input.modifiers();
+        KeyEvent e = new KeyEvent(target, pressed ? KeyEvent.KEY_PRESSED : KeyEvent.KEY_RELEASED, now, mods, vk, ch);
+        deliver(target, e);
+        if (!pressed) {
+            return vk == KeyEvent.VK_TAB;
+        }
+        boolean command = (mods & (InputEvent.CTRL_DOWN_MASK | InputEvent.ALT_DOWN_MASK
+                | InputEvent.META_DOWN_MASK)) != 0;
+        if (ch != KeyEvent.CHAR_UNDEFINED && !command) {
+            deliver(target, new KeyEvent(target, KeyEvent.KEY_TYPED, now, mods, KeyEvent.VK_UNDEFINED, ch));
+        }
+        if (!e.isConsumed() && vk == KeyEvent.VK_TAB && !command && target.getFocusTraversalKeysEnabled()) {
+            KeyboardFocusManager m = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+            if ((mods & InputEvent.SHIFT_DOWN_MASK) != 0) {
+                m.focusPreviousComponent(target);
+            } else {
+                m.focusNextComponent(target);
+            }
+        }
+        return vk == KeyEvent.VK_TAB;
+    }
+
+    /// Hands the event to the target, and to the key bindings when the
+    /// target is not a Swing component, which looks them up itself.
+    private static void deliver(Component target, KeyEvent e) {
+        target.dispatchEvent(e);
+        if (!e.isConsumed() && !(target instanceof JComponent)) {
+            SwingUtilities.processKeyBindings(e);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FilePicker.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FilePicker.java
new file mode 100644
index 00000000000..041378f36dd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FilePicker.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.ui.Display;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+
+/// The platform's own file picker, as `JFileChooser` uses it to open a
+/// file: the document picker of a phone, the file dialog of a desktop.
+///
+/// The picker answers through a callback; [#pick(String)] waits for it the
+/// way a modal dialog waits, so events keep running while it is open.
+public final class FilePicker {
+
+    /// What opens the picker.
+    public interface Source {
+        /// Opens the picker; `response` receives an event whose source is
+        /// the path chosen, or `null` when the user cancelled. `accept` is
+        /// a comma separated list of extensions, or `null` for every file.
+        void open(ActionListener<ActionEvent> response, String accept);
+    }
+
+    private static final Source NATIVE = new Source() {
+        @Override
+        public void open(ActionListener<ActionEvent> response, String accept) {
+            Display.getInstance().openFileChooser(response, accept);
+        }
+    };
+
+    private static final Runnable PAUSE = new Runnable() {
+        @Override
+        public void run() {
+            try {
+                Thread.sleep(20);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    };
+
+    private static Source source = NATIVE;
+
+    private FilePicker() {
+    }
+
+    /// Replaces what opens the picker; `null` restores the platform's.
+    /// For tests.
+    public static void setSource(Source s) {
+        source = s == null ? NATIVE : s;
+    }
+
+    /// Whether there is a display to show a picker on.
+    public static boolean available() {
+        return Display.isInitialized() && Display.getInstance().isEdt();
+    }
+
+    /// Shows the picker and waits for the answer: the path chosen, or
+    /// `null` when the user cancelled.
+    public static String pick(String accept) {
+        final Object[] answer = new Object[2];
+        source.open(new ActionListener<ActionEvent>() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                Object src = evt == null ? null : evt.getSource();
+                answer[1] = src instanceof String ? src : null;
+                answer[0] = Boolean.TRUE;
+            }
+        }, accept);
+        while (answer[0] == null) {
+            Display.getInstance().invokeAndBlock(PAUSE);
+        }
+        return answer[1] instanceof String ? (String) answer[1] : null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FontFiles.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FontFiles.java
new file mode 100644
index 00000000000..5800c47a3f7
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FontFiles.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.impl.compat.ResourceNames;
+import com.codename1.impl.compat.Resources;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/// The font files an application carries: what `Font.createFont` makes a
+/// font of, and what `GraphicsEnvironment.registerFont` lets a family
+/// name find.
+///
+/// `Font.createFont` is handed bytes, and a platform opens a font by the
+/// name of its FILE -- the flat name the build shipped the resource
+/// under -- and, on iOS, by the name the font gives ITSELF. So the bytes
+/// are read for the names in their `name` table, and the application's
+/// font resources are read for the one that names itself the same way;
+/// that resource is the file the platform is asked to open.
+///
+/// Bytes that match no resource of the application -- a font read from
+/// the network or from the file system -- still make a font with the
+/// right names, which is drawn with the platform's own typeface, as is a
+/// font on a port that cannot open font files. The platform is asked for
+/// a file at the root of the bundle whose name ends in `.ttf`.
+public final class FontFiles {
+
+    /// One font file.
+    public static final class Face {
+
+        private final String family;
+        private final String fullName;
+        private final String postScriptName;
+        private String file;
+        private com.codename1.ui.Font base;
+        private boolean tried;
+
+        Face(String family, String fullName, String postScriptName) {
+            this.family = family;
+            this.fullName = fullName;
+            this.postScriptName = postScriptName;
+        }
+
+        /// The family, `Material Icons`.
+        public String family() {
+            return family;
+        }
+
+        /// The full name, `Material Icons Regular`.
+        public String fullName() {
+            return fullName;
+        }
+
+        /// The name the font is installed under, `MaterialIcons-Regular`.
+        public String postScriptName() {
+            return postScriptName;
+        }
+
+        /// The flat name of the file in the bundle; `null` for bytes no
+        /// resource was matched to.
+        public String file() {
+            return file;
+        }
+
+        /// The platform's font of this file, at no particular size;
+        /// `null` where there is none.
+        public com.codename1.ui.Font base() {
+            if (!tried) {
+                tried = true;
+                if (file != null && file.indexOf('/') < 0 && file.endsWith(".ttf")
+                        && com.codename1.ui.Font.isTrueTypeFileSupported()) {
+                    try {
+                        base = com.codename1.ui.Font.createTrueTypeFont(postScriptName, file);
+                    } catch (RuntimeException refused) {
+                        // The platform would not open the file: the text
+                        // is drawn with its own typeface.
+                        com.codename1.io.Log.p("Font " + file + ": " + refused.getMessage());
+                        base = null;
+                    }
+                }
+            }
+            return base;
+        }
+    }
+
+    private static final HashMap<String, Face> BY_PATH = new HashMap<String, Face>();
+    private static final HashMap<String, Face> REGISTERED = new HashMap<String, Face>();
+    private static final ArrayList<String> FAMILIES = new ArrayList<String>();
+    private static boolean scanned;
+
+    private FontFiles() {
+    }
+
+    /// Font names are compared without regard to case, folded by hand:
+    /// they are ASCII, and the locale must not come into it.
+    private static String fold(String s) {
+        StringBuilder out = new StringBuilder(s.length());
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            out.append(c >= 'A' && c <= 'Z' ? (char) (c + 32) : c);
+        }
+        return out.toString().trim();
+    }
+
+    private static int u16(byte[] d, int at) {
+        return ((d[at] & 0xff) << 8) | (d[at + 1] & 0xff);
+    }
+
+    private static int u32(byte[] d, int at) {
+        return (u16(d, at) << 16) | u16(d, at + 2);
+    }
+
+    /// Reads the names out of a TrueType or OpenType file (the first face
+    /// of a collection). `null` for bytes that are no such file.
+    public static Face parse(byte[] d) {
+        if (d == null || d.length < 12) {
+            return null;
+        }
+        int base = 0;
+        int magic = u32(d, 0);
+        if (magic == 0x74746366) {
+            // 'ttcf': a collection; the directory of its first face.
+            if (d.length < 16) {
+                return null;
+            }
+            base = u32(d, 12);
+            if (base < 0 || base + 12 > d.length) {
+                return null;
+            }
+            magic = u32(d, base);
+        }
+        if (magic != 0x00010000 && magic != 0x4f54544f && magic != 0x74727565) {
+            return null;
+        }
+        int tables = u16(d, base + 4);
+        int nameAt = -1;
+        for (int i = 0; i < tables; i++) {
+            int entry = base + 12 + 16 * i;
+            if (entry + 16 > d.length) {
+                return null;
+            }
+            if (u32(d, entry) == 0x6e616d65) {
+                nameAt = u32(d, entry + 8);
+            }
+        }
+        if (nameAt < 0 || nameAt + 6 > d.length) {
+            return null;
+        }
+        int count = u16(d, nameAt + 2);
+        int strings = nameAt + u16(d, nameAt + 4);
+        // Per name id: the string, and how good its record was. A Windows
+        // Unicode record in English beats any other Unicode one, which
+        // beats a Macintosh Roman one.
+        String[] found = new String[18];
+        int[] rank = new int[18];
+        for (int i = 0; i < count; i++) {
+            int record = nameAt + 6 + 12 * i;
+            if (record + 12 > d.length) {
+                break;
+            }
+            int platform = u16(d, record);
+            int encoding = u16(d, record + 2);
+            int language = u16(d, record + 4);
+            int id = u16(d, record + 6);
+            int length = u16(d, record + 8);
+            int at = strings + u16(d, record + 10);
+            if (id >= found.length || at < 0 || at + length > d.length) {
+                continue;
+            }
+            boolean wide = platform == 0 || (platform == 3 && (encoding == 0 || encoding == 1 || encoding == 10));
+            boolean roman = platform == 1 && encoding == 0;
+            if (!wide && !roman) {
+                continue;
+            }
+            int r = wide ? (platform == 3 && language == 0x409 ? 3 : 2) : 1;
+            if (r <= rank[id]) {
+                continue;
+            }
+            StringBuilder s = new StringBuilder();
+            if (wide) {
+                for (int k = 0; k + 1 < length; k += 2) {
+                    s.append((char) u16(d, at + k));
+                }
+            } else {
+                for (int k = 0; k < length; k++) {
+                    int b = d[at + k] & 0xff;
+                    s.append(b < 0x80 ? (char) b : '?');
+                }
+            }
+            if (s.length() > 0) {
+                found[id] = s.toString();
+                rank[id] = r;
+            }
+        }
+        String family = found[1] != null ? found[1] : found[16];
+        String full = found[4];
+        if (family == null) {
+            family = full;
+        }
+        if (family == null) {
+            return null;
+        }
+        if (full == null) {
+            String style = found[2] != null ? found[2] : found[17];
+            full = style == null || "Regular".equals(style) ? family : family + " " + style;
+        }
+        return new Face(family, full, found[6] != null ? found[6] : full);
+    }
+
+    /// Everything a stream has left.
+    public static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] chunk = new byte[8192];
+        for (int n = in.read(chunk); n >= 0; n = in.read(chunk)) {
+            out.write(chunk, 0, n);
+        }
+        return out.toByteArray();
+    }
+
+    private static boolean isFontPath(String path) {
+        int n = path.length();
+        return n > 4 && (path.regionMatches(true, n - 4, ".ttf", 0, 4) || path.regionMatches(true, n - 4, ".otf", 0, 4)
+                || path.regionMatches(true, n - 4, ".ttc", 0, 4));
+    }
+
+    private static void scan() {
+        if (scanned) {
+            return;
+        }
+        scanned = true;
+        String[] paths = Resources.cn1ResourcePaths();
+        for (int i = 0; i < paths.length; i++) {
+            if (!isFontPath(paths[i])) {
+                continue;
+            }
+            InputStream in = Resources.open(paths[i]);
+            if (in == null) {
+                continue;
+            }
+            Face face = null;
+            try {
+                face = parse(readAll(in));
+            } catch (IOException unreadable) {
+                face = null;
+            }
+            try {
+                in.close();
+            } catch (IOException ignored) {
+                // Nothing to do about a stream that will not close.
+                continue;
+            }
+            if (face != null) {
+                face.file = ResourceNames.flatName(paths[i]);
+                BY_PATH.put(paths[i], face);
+            }
+        }
+    }
+
+    /// The face these bytes are: the application's resource that names
+    /// itself as they do, or a face without a file. `null` for bytes that
+    /// are no font.
+    public static Face fromBytes(byte[] data) {
+        Face parsed = parse(data);
+        if (parsed == null) {
+            return null;
+        }
+        scan();
+        for (Face candidate : BY_PATH.values()) {
+            if (candidate.postScriptName.equals(parsed.postScriptName) && candidate.fullName.equals(parsed.fullName)) {
+                return candidate;
+            }
+        }
+        return parsed;
+    }
+
+    /// Lets the family, the full name and the PostScript name of a face
+    /// find it. `false` when one of them finds another face already.
+    public static boolean register(Face face) {
+        String[] names = {face.family, face.fullName, face.postScriptName};
+        for (int i = 0; i < names.length; i++) {
+            Face there = REGISTERED.get(fold(names[i]));
+            if (there != null && there != face && !there.postScriptName.equals(face.postScriptName)) {
+                return false;
+            }
+        }
+        for (int i = 0; i < names.length; i++) {
+            REGISTERED.put(fold(names[i]), face);
+        }
+        if (!FAMILIES.contains(face.family)) {
+            FAMILIES.add(face.family);
+        }
+        return true;
+    }
+
+    /// The registered face a font name finds, or `null`.
+    public static Face registered(String name) {
+        if (name == null || REGISTERED.isEmpty()) {
+            return null;
+        }
+        return REGISTERED.get(fold(name));
+    }
+
+    /// The families that were registered, in the order they were.
+    public static String[] families() {
+        return FAMILIES.toArray(new String[FAMILIES.size()]);
+    }
+
+    /// Forgets every face; for tests.
+    public static void reset() {
+        BY_PATH.clear();
+        REGISTERED.clear();
+        FAMILIES.clear();
+        scanned = false;
+        Fonts.forgetFaces();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Fonts.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Fonts.java
new file mode 100644
index 00000000000..879d7c67baf
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Fonts.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.ui.Display;
+
+import java.util.HashMap;
+
+/// Maps AWT fonts onto the platform's fonts and measures them.
+public final class Fonts {
+
+    private static final HashMap<Integer, com.codename1.ui.Font> CACHE = new HashMap<Integer, com.codename1.ui.Font>();
+
+    private static final HashMap<String, com.codename1.ui.Font> FACES = new HashMap<String, com.codename1.ui.Font>();
+
+    private Fonts() {
+    }
+
+    static void forgetFaces() {
+        FACES.clear();
+    }
+
+    /// The Codename One font that draws `font` at `devicePixels` high.
+    public static com.codename1.ui.Font nativeFont(Font font, float devicePixels) {
+        int quarter = Math.max(4, Math.round(devicePixels * 4));
+        FontFiles.Face own = font.cn1Face();
+        com.codename1.ui.Font file = own == null ? null : own.base();
+        if (file != null) {
+            // A font of the application's own file: its glyphs, at the
+            // size and in the style asked for.
+            String name = own.postScriptName() + '/' + quarter + '/' + (font.getStyle() & 3);
+            com.codename1.ui.Font sized = FACES.get(name);
+            if (sized == null) {
+                int style = (font.isBold() ? com.codename1.ui.Font.STYLE_BOLD : 0)
+                        | (font.isItalic() ? com.codename1.ui.Font.STYLE_ITALIC : 0);
+                sized = file.derive(quarter / 4f, style);
+                FACES.put(name, sized);
+            }
+            return sized;
+        }
+        boolean mono = monospaced(font);
+        Integer key = Integer.valueOf((quarter * 4 + (font.getStyle() & 3)) * 2 + (mono ? 1 : 0));
+        com.codename1.ui.Font f = CACHE.get(key);
+        if (f != null) {
+            return f;
+        }
+        if (mono) {
+            f = fixedWidth(font, quarter / 4f);
+        } else if (com.codename1.ui.Font.isNativeFontSchemeSupported()) {
+            String face;
+            if (font.isBold()) {
+                face = font.isItalic() ? "native:ItalicBold" : "native:MainBold";
+            } else {
+                face = font.isItalic() ? "native:ItalicRegular" : "native:MainRegular";
+            }
+            f = com.codename1.ui.Font.createTrueTypeFont(face, face)
+                    .derive(quarter / 4f, com.codename1.ui.Font.STYLE_PLAIN);
+        } else {
+            int style = (font.isBold() ? com.codename1.ui.Font.STYLE_BOLD : 0)
+                    | (font.isItalic() ? com.codename1.ui.Font.STYLE_ITALIC : 0);
+            f = com.codename1.ui.Font.createSystemFont(com.codename1.ui.Font.FACE_SYSTEM, style,
+                    com.codename1.ui.Font.SIZE_MEDIUM);
+        }
+        CACHE.put(key, f);
+        return f;
+    }
+
+    /// Whether `font` asks for a family whose characters are all one
+    /// width: text set in one is lined up in columns, which no other
+    /// family can stand in for.
+    static boolean monospaced(Font font) {
+        String family = font.getFamily();
+        return family != null && (family.equalsIgnoreCase(Font.MONOSPACED) || family.equalsIgnoreCase("Courier")
+                || family.equalsIgnoreCase("Courier New"));
+    }
+
+    /// A fixed width font of the size asked for.
+    ///
+    /// The platform's own comes in three sizes and no more: a system font
+    /// cannot be derived to a size, only a TrueType font can, and the
+    /// `native:` families that exist at every size have no fixed width
+    /// member. So the exact size is available when the application ships a
+    /// fixed width TrueType font and names it in the display property
+    /// `desktopcompat.monospaced`, as `Font Name|file.ttf`; otherwise this
+    /// is the platform's font nearest in height to what was asked for.
+    private static com.codename1.ui.Font fixedWidth(Font font, float devicePixels) {
+        int style = (font.isBold() ? com.codename1.ui.Font.STYLE_BOLD : 0)
+                | (font.isItalic() ? com.codename1.ui.Font.STYLE_ITALIC : 0);
+        String named = Display.getInstance().getProperty("desktopcompat.monospaced", null);
+        int bar = named == null ? -1 : named.indexOf('|');
+        if (bar > 0 && bar < named.length() - 1 && com.codename1.ui.Font.isTrueTypeFileSupported()) {
+            try {
+                return com.codename1.ui.Font.createTrueTypeFont(named.substring(0, bar), named.substring(bar + 1))
+                        .derive(devicePixels, style);
+            } catch (RuntimeException missing) {
+                // The font named is not in the application: the platform's.
+                com.codename1.io.Log.p("desktopcompat.monospaced: " + missing.getMessage());
+            }
+        }
+        int[] sizes = {com.codename1.ui.Font.SIZE_SMALL, com.codename1.ui.Font.SIZE_MEDIUM,
+            com.codename1.ui.Font.SIZE_LARGE};
+        // A font is about a fifth taller than its size says.
+        float want = devicePixels * 1.2f;
+        com.codename1.ui.Font best = null;
+        float off = 0;
+        for (int i = 0; i < sizes.length; i++) {
+            com.codename1.ui.Font c = com.codename1.ui.Font.createSystemFont(
+                    com.codename1.ui.Font.FACE_MONOSPACE, style, sizes[i]);
+            float d = Math.abs(c.getHeight() - want);
+            if (best == null || d < off) {
+                best = c;
+                off = d;
+            }
+        }
+        return best;
+    }
+
+    /// The AWT font nearest a Codename One one: its height in logical pixels.
+    public static Font fromNative(com.codename1.ui.Font f) {
+        float px = f.getPixelSize();
+        if (px <= 0) {
+            px = f.getHeight() * 0.8f;
+        }
+        return new Font(Font.DIALOG, Font.PLAIN, Math.max(1, Math.round(px / Units.scale())));
+    }
+
+    /// The font an application chose for everything by putting it under
+    /// `defaultFont`, the key the FlatLaf look and feels read, or `null`
+    /// when it put none.
+    public static Font applicationFont() {
+        return com.codename1.desktopcompat.javax.swing.UIManager.cn1PutFont("defaultFont");
+    }
+
+    /// The font of a component that was given none: the one the
+    /// application put under `defaultFont`, else the theme's label font,
+    /// or 12 pixel Dialog before a display exists.
+    public static Font defaultFont() {
+        Font chosen = applicationFont();
+        if (chosen != null) {
+            return chosen;
+        }
+        if (!Display.isInitialized()) {
+            return new Font(Font.DIALOG, Font.PLAIN, 12);
+        }
+        return fromNative(com.codename1.ui.plaf.UIManager.getInstance().getComponentStyle("Label").getFont());
+    }
+
+    public static FontMetrics metrics(Font font) {
+        return new Metrics(font);
+    }
+
+    /// Measures the platform font at the current scale and answers in
+    /// logical pixels, rounding widths to the nearest and heights up.
+    private static final class Metrics extends FontMetrics {
+
+        private final com.codename1.ui.Font cn1;
+        private final float scale;
+
+        Metrics(Font font) {
+            super(font);
+            scale = Units.scale();
+            cn1 = Display.isInitialized() ? nativeFont(font, font.getSize2D() * scale) : null;
+        }
+
+        @Override
+        public int getAscent() {
+            if (cn1 == null) {
+                return Math.round(font.getSize2D());
+            }
+            int a = cn1.getAscent();
+            return Math.round((a > 0 ? a : cn1.getHeight() * 0.8f) / scale);
+        }
+
+        @Override
+        public int getDescent() {
+            return getHeight() - getAscent();
+        }
+
+        @Override
+        public int getHeight() {
+            if (cn1 == null) {
+                return Math.round(font.getSize2D() * 1.25f);
+            }
+            return (int) Math.ceil(cn1.getHeight() / scale - 0.001f);
+        }
+
+        @Override
+        public int getMaxAdvance() {
+            return charWidth('W');
+        }
+
+        @Override
+        public int stringWidth(String str) {
+            if (cn1 == null) {
+                return super.stringWidth(str);
+            }
+            return Math.round(cn1.stringWidth(str) / scale);
+        }
+
+        @Override
+        public int charWidth(char ch) {
+            if (cn1 == null) {
+                return super.charWidth(ch);
+            }
+            return Math.round(cn1.charWidth(ch) / scale);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FrameForm.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FrameForm.java
new file mode 100644
index 00000000000..e850bf0477f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/FrameForm.java
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.ui.Command;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import com.codename1.ui.Toolbar;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.layouts.BorderLayout;
+import java.util.ArrayList;
+import java.util.List;
+
+/// The form that shows a window: the window's peer fills it, and the
+/// form's pointer and key input becomes the window's AWT events.
+///
+/// A form shown over another gets a back command, which asks the window
+/// to close the way the close box of a desktop window does. The commands
+/// that stand for the window's menu bar go to the overflow menu of the
+/// form's toolbar, from where Codename One publishes them to the native
+/// menu bar on the ports that have one.
+public final class FrameForm extends Form implements WindowHost {
+
+    private final Window window;
+    private final ArrayList<Command> commands = new ArrayList<Command>();
+    private Form previous;
+    /// The size the application gave the window and no window of the
+    /// operating system was asked for yet, in logical pixels; 0 when
+    /// there is none. See [#cn1Show].
+    private int askedWidth;
+    private int askedHeight;
+    /// The display size the last whole paint of this form was made for.
+    private int paintedWidth = -1;
+    private int paintedHeight = -1;
+    private int paintedAgain;
+    private final Runnable again = new Runnable() {
+        @Override
+        public void run() {
+            repaint();
+        }
+    };
+
+    public FrameForm(Window w) {
+        super(w.cn1Title(), new BorderLayout());
+        window = w;
+        // Before anything lays this form out: from then on the window has
+        // the size of the room the form gives it.
+        askedWidth = w.getWidth();
+        askedHeight = w.getHeight();
+        setScrollable(false);
+        setEnableCursors(true);
+        com.codename1.ui.Component p = w.cn1Peer();
+        p.remove();
+        add(BorderLayout.CENTER, new RootPan(w, p));
+        WindowHosts.listenWheel(w, p);
+    }
+
+    /// The window this form shows.
+    public Window window() {
+        return window;
+    }
+
+    /// The commands that stand for the window's menu bar at the moment.
+    public List<Command> cn1Commands() {
+        return new ArrayList<Command>(commands);
+    }
+
+    /// Shows the form, over the current one if there is one, and lays the
+    /// window out.
+    public void cn1Show() {
+        Form current = Display.getInstance().getCurrent();
+        if (current != this) {
+            if (current != null) {
+                previous = current;
+                setBackCommand(new Command("Back") {
+                    @Override
+                    public void actionPerformed(ActionEvent evt) {
+                        window.cn1Closing();
+                    }
+                });
+            }
+            // The window of a desktop application is the application's
+            // own: a frame that fills it gives it the size the application
+            // gave the frame, which the form is about to replace with the
+            // display's. A frame shown over a form that is not a frame's
+            // is a guest in that window and leaves its size alone.
+            //
+            // The size is the one recorded when the application gave it,
+            // not the window's at this moment. A form with a toolbar,
+            // which is every form under a desktop theme, is laid out
+            // when its title is set, before it is shown, and the layout
+            // gives the window the size of the display less the title
+            // area: asking for that made every application window open
+            // a title bar shorter than the port had made it, whatever
+            // size the frame had been packed to. A size is asked for
+            // once; a frame shown again as it is leaves the window the
+            // size its user may have given it since.
+            Display d = Display.getInstance();
+            boolean own = current == null || current instanceof FrameForm;
+            if (own && d.isDesktop() && askedWidth > 0 && askedHeight > 0) {
+                d.setWindowSize(Units.toDevice(askedWidth), Units.toDevice(askedHeight));
+            }
+            askedWidth = 0;
+            askedHeight = 0;
+            show();
+            nativeTitle();
+        }
+        revalidate();
+    }
+
+    /// Hands the title to the window of the operating system, on a port
+    /// that keeps the title of a form there. Codename One pushes a title
+    /// that is set on the form showing, and not the title a form already
+    /// has when it is shown: a frame titled before `setVisible`, which is
+    /// every frame, left the window with the port's own name.
+    private void nativeTitle() {
+        Display d = Display.getInstance();
+        if (d.getCurrent() == this && d.isNativeTitle()) {
+            d.refreshNativeTitle();
+        }
+    }
+
+    /// Paints the form, and asks for one more paint when the display has
+    /// a size that no paint of this form was made for yet.
+    ///
+    /// A port that draws into a buffer of the window's size may replace
+    /// the buffer when the frame ends: the native Linux port applies a
+    /// resize it has recorded right after the flush, and shows a buffer
+    /// nothing has drawn on. The first frame of a window whose menu bar
+    /// has just taken its strip is such a frame, and so is the frame that
+    /// follows any resize; the window stayed blank until an input event
+    /// made something paint. The frame after that flush is drawn on the
+    /// new buffer. It costs one paint for each size the display takes.
+    @Override
+    public void paint(com.codename1.ui.Graphics g) {
+        super.paint(g);
+        Display d = Display.getInstance();
+        int w = d.getDisplayWidth();
+        int h = d.getDisplayHeight();
+        if (w != paintedWidth || h != paintedHeight) {
+            paintedWidth = w;
+            paintedHeight = h;
+            paintedAgain++;
+            d.callSerially(again);
+        }
+    }
+
+    /// How many times a paint asked for another one; see [#paint].
+    public int cn1PaintedAgain() {
+        return paintedAgain;
+    }
+
+    /// Goes back to the form of the window below this one, or the form
+    /// this one was shown over, if this form is the one showing.
+    public void cn1Hide() {
+        if (Display.getInstance().getCurrent() == this) {
+            Form below = WindowHosts.formBelow(window, previous);
+            if (below != null) {
+                below.showBack();
+            }
+        }
+    }
+
+    @Override
+    public void open() {
+        cn1Show();
+    }
+
+    @Override
+    public void close() {
+        cn1Hide();
+    }
+
+    @Override
+    public void release() {
+        previous = null;
+    }
+
+    @Override
+    public void title(String title) {
+        setTitle(title);
+        nativeTitle();
+        // A title label keeps the width of the text it was laid out with:
+        // the title area alone is laid out again, never the content.
+        com.codename1.ui.Toolbar bar = getToolbar();
+        if (bar != null) {
+            bar.revalidate();
+        }
+    }
+
+    @Override
+    public void icon(Image icon) {
+    }
+
+    /// The application set the window's bounds. A layout never comes
+    /// here: it tells the window the size its peer was given without
+    /// going through `setBounds`. While the form is showing the window
+    /// fills it and the size is the form's to give, so only a size set
+    /// on a window that is not showing is kept, for [#cn1Show]. A window
+    /// that was only moved still has the size its peer was laid out
+    /// with, which nobody asked for.
+    @Override
+    public void bounds() {
+        if (Display.getInstance().getCurrent() == this) {
+            return;
+        }
+        com.codename1.ui.Component p = window.cn1Peer();
+        if (p == null || window.getWidth() != Units.toLogical(p.getWidth())
+                || window.getHeight() != Units.toLogical(p.getHeight())) {
+            askedWidth = window.getWidth();
+            askedHeight = window.getHeight();
+        }
+    }
+
+    @Override
+    public void resizable(boolean resizable) {
+    }
+
+    @Override
+    public void decorated(boolean decorated) {
+    }
+
+    @Override
+    public void state(int state) {
+    }
+
+    @Override
+    public void commands(List<Command> list) {
+        Toolbar tb = getToolbar();
+        if (tb == null) {
+            if (list.isEmpty()) {
+                return;
+            }
+            tb = new Toolbar();
+            setToolbar(tb);
+            setTitle(window.cn1Title());
+        }
+        for (int i = 0; i < commands.size(); i++) {
+            tb.removeOverflowCommand(commands.get(i));
+        }
+        commands.clear();
+        for (int i = 0; i < list.size(); i++) {
+            Command c = list.get(i);
+            commands.add(c);
+            tb.addCommandToOverflowMenu(c);
+        }
+        revalidate();
+    }
+
+    /// Whether the menu bar is shown as commands and not drawn in the
+    /// window.
+    ///
+    /// On a desktop it is drawn, as a row of menus above the content: a
+    /// window there has the room and its user looks for the menus there.
+    /// Anywhere else it becomes commands. The display property
+    /// `desktopcompat.menuBar` overrides either way, with `window` or
+    /// `commands`.
+    @Override
+    public boolean takesCommands() {
+        com.codename1.ui.Display d = com.codename1.ui.Display.getInstance();
+        String asked = d.getProperty("desktopcompat.menuBar", null);
+        if ("window".equals(asked)) {
+            return false;
+        }
+        if ("commands".equals(asked)) {
+            return true;
+        }
+        return !d.isDesktop();
+    }
+
+    @Override
+    public Form form() {
+        return this;
+    }
+
+    @Override
+    public boolean fillsDisplay() {
+        return true;
+    }
+
+    @Override
+    public boolean reusable() {
+        return true;
+    }
+
+    @Override
+    public void pointerPressed(int x, int y) {
+        if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_PRESSED, x, y)) {
+            super.pointerPressed(x, y);
+        }
+    }
+
+    @Override
+    public void pointerDragged(int x, int y) {
+        if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_DRAGGED, x, y)) {
+            super.pointerDragged(x, y);
+        }
+    }
+
+    /// The drag of a pointer as the display delivers it. A form has two
+    /// overloads and the display calls this one, which is an
+    /// implementation of its own and never reaches the one above; with
+    /// only that one overridden no drag got to a Swing component at all,
+    /// while presses and releases, which a form routes through the plain
+    /// overloads, did. More than one pointer is a gesture of Codename
+    /// One's.
+    @Override
+    public void pointerDragged(int[] x, int[] y) {
+        if (x != null && y != null && x.length == 1 && y.length == 1
+                && EventBridge.pointerEvent(window, MouseEvent.MOUSE_DRAGGED, x[0], y[0])) {
+            return;
+        }
+        super.pointerDragged(x, y);
+    }
+
+    @Override
+    public void pointerReleased(int x, int y) {
+        if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_RELEASED, x, y)) {
+            super.pointerReleased(x, y);
+        }
+    }
+
+    @Override
+    public void longPointerPress(int x, int y) {
+        EventBridge.longPress(window, x, y);
+        super.longPointerPress(x, y);
+    }
+
+    @Override
+    public void pointerHover(int[] x, int[] y) {
+        if (x != null && y != null && x.length > 0 && y.length > 0) {
+            EventBridge.pointerEvent(window, MouseEvent.MOUSE_MOVED, x[0], y[0]);
+        }
+        super.pointerHover(x, y);
+    }
+
+    @Override
+    public void keyPressed(int keyCode) {
+        if (!EventBridge.key(window, true, keyCode)) {
+            super.keyPressed(keyCode);
+        }
+    }
+
+    @Override
+    public void keyRepeated(int keyCode) {
+        if (!EventBridge.key(window, true, keyCode)) {
+            super.keyRepeated(keyCode);
+        }
+    }
+
+    @Override
+    public void keyReleased(int keyCode) {
+        if (!EventBridge.key(window, false, keyCode)) {
+            super.keyReleased(keyCode);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/G2D.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/G2D.java
new file mode 100644
index 00000000000..b90fde4d639
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/G2D.java
@@ -0,0 +1,1439 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.AlphaComposite;
+import com.codename1.desktopcompat.java.awt.BasicStroke;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Composite;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.GradientPaint;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.RenderingHints;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.Stroke;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.Arc2D;
+import com.codename1.desktopcompat.java.awt.geom.Ellipse2D;
+import com.codename1.desktopcompat.java.awt.geom.Line2D;
+import com.codename1.desktopcompat.java.awt.geom.Path2D;
+import com.codename1.desktopcompat.java.awt.geom.PathIterator;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.geom.RoundRectangle2D;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+import com.codename1.ui.LinearGradientPaint;
+import com.codename1.ui.MultipleGradientPaint;
+import com.codename1.ui.Transform;
+import com.codename1.ui.geom.GeneralPath;
+
+import java.util.Map;
+
+/// The layer's `Graphics2D`, drawing through a Codename One `Graphics`.
+///
+/// ## Coordinates
+///
+/// User space is logical pixels with the origin at the component's (or
+/// image's) corner. The graphics keeps the whole mapping to the Codename One
+/// context as one affine matrix -- the user transform, then the unit scale
+/// ([Units]), then the component's position -- and applies it to geometry
+/// *itself*: rectangles and straight lines are snapped to device pixels and
+/// drawn with the port's primitives, every other shape is rebuilt as a path
+/// in device coordinates. Nothing basic depends on the port's transform
+/// support, so a translated or scaled drawing looks the same everywhere and
+/// stays crisp at any density. Only what cannot be redrawn point by point
+/// -- text and images under a rotation or shear -- uses the context's
+/// transform, and falls back to drawing unrotated at the right place on a
+/// port without one.
+///
+/// ## State
+///
+/// A Codename One context has one color, one clip and one font; AWT hands
+/// out independent copies with `create()`. Each instance therefore keeps its
+/// own state and writes it to the context before it draws, when another
+/// instance drew last or something changed. [#finish()] puts the context
+/// back the way [#forPeer] found it, which the paint cycle relies on.
+///
+/// ## What is refused
+///
+/// Composites other than source-over, paints other than a color or a
+/// two-color gradient, XOR mode and `copyArea` throw
+/// `UnsupportedOperationException`: drawing something else in their place
+/// would be a bug nobody could see from the code.
+public final class G2D extends Graphics2D {
+
+    private static final BasicStroke DEFAULT_STROKE = new BasicStroke();
+
+    /// What every graphics created from one root shares: the context, which
+    /// of them wrote its state there last, and what to restore at the end.
+    private static final class Target {
+        final com.codename1.ui.Graphics g;
+        final BufferedImage image;
+        G2D active;
+        int alpha;
+        int clipX;
+        int clipY;
+        int clipW;
+        int clipH;
+        int color;
+        com.codename1.ui.Font font;
+
+        Target(com.codename1.ui.Graphics g, BufferedImage image) {
+            this.g = g;
+            this.image = image;
+        }
+    }
+
+    private final Target target;
+    private final com.codename1.ui.Graphics g;
+    private final float originX;
+    private final float originY;
+    private final float unit;
+    private final int baseX;
+    private final int baseY;
+    private final int baseW;
+    private final int baseH;
+
+    private AffineTransform tx = new AffineTransform();
+    // Device coordinates: X = a*x + c*y + e, Y = b*x + d*y + f.
+    private double a;
+    private double b;
+    private double c;
+    private double d;
+    private double e;
+    private double f;
+    /// Whether the matrix only scales and translates, without mirroring.
+    private boolean upright;
+
+    private Paint paint = Color.black;
+    private Color color = Color.black;
+    private Color background = Color.white;
+    private Font font;
+    private Stroke stroke = DEFAULT_STROKE;
+    private AlphaComposite composite = AlphaComposite.SrcOver;
+    private final RenderingHints hints = new RenderingHints(null);
+    private int antialias = -1;
+    private int textAntialias = -1;
+
+    private int clipX;
+    private int clipY;
+    private int clipW;
+    private int clipH;
+    private GeneralPath clipShape;
+    private boolean dirty = true;
+
+    private G2D(Target target, float originX, float originY, float unit, int bx, int by, int bw, int bh) {
+        this.target = target;
+        this.g = target.g;
+        this.originX = originX;
+        this.originY = originY;
+        this.unit = unit;
+        this.baseX = bx;
+        this.baseY = by;
+        this.baseW = bw;
+        this.baseH = bh;
+        this.clipX = bx;
+        this.clipY = by;
+        this.clipW = bw;
+        this.clipH = bh;
+        matrixChanged();
+    }
+
+    private G2D(G2D o) {
+        this.target = o.target;
+        this.g = o.g;
+        this.originX = o.originX;
+        this.originY = o.originY;
+        this.unit = o.unit;
+        this.baseX = o.baseX;
+        this.baseY = o.baseY;
+        this.baseW = o.baseW;
+        this.baseH = o.baseH;
+        this.tx = new AffineTransform(o.tx);
+        this.paint = o.paint;
+        this.color = o.color;
+        this.background = o.background;
+        this.font = o.font;
+        this.stroke = o.stroke;
+        this.composite = o.composite;
+        this.hints.add(o.hints);
+        this.antialias = o.antialias;
+        this.textAntialias = o.textAntialias;
+        this.clipX = o.clipX;
+        this.clipY = o.clipY;
+        this.clipW = o.clipW;
+        this.clipH = o.clipH;
+        this.clipShape = o.clipShape;
+        matrixChanged();
+    }
+
+    /// A graphics for a component whose peer Codename One is painting:
+    /// `g` as the peer's `paint` received it and the peer's bounds in that
+    /// context. Pair with [#finish()].
+    public static G2D forPeer(com.codename1.ui.Graphics g, int x, int y, int width, int height) {
+        Target t = new Target(g, null);
+        t.alpha = g.getAlpha();
+        t.clipX = g.getClipX();
+        t.clipY = g.getClipY();
+        t.clipW = g.getClipWidth();
+        t.clipH = g.getClipHeight();
+        t.color = g.getColor();
+        t.font = g.getFont();
+        int x1 = Math.max(x, t.clipX);
+        int y1 = Math.max(y, t.clipY);
+        int x2 = Math.min(x + width, t.clipX + t.clipW);
+        int y2 = Math.min(y + height, t.clipY + t.clipH);
+        return new G2D(t, x, y, Units.scale(), x1, y1, Math.max(0, x2 - x1), Math.max(0, y2 - y1));
+    }
+
+    /// A graphics that draws into a buffered image through `g`, the graphics
+    /// of the image's Codename One surface. Image pixels are user units.
+    public static G2D forImage(BufferedImage image, com.codename1.ui.Graphics g, int width, int height) {
+        Target t = new Target(g, image);
+        t.alpha = 255;
+        t.clipW = width;
+        t.clipH = height;
+        t.color = g.getColor();
+        t.font = g.getFont();
+        return new G2D(t, 0, 0, 1f, 0, 0, width, height);
+    }
+
+    /// Restores the context to the clip, color, alpha and font it had when
+    /// this graphics was made for a peer.
+    public void finish() {
+        g.setClip(target.clipX, target.clipY, target.clipW, target.clipH);
+        g.setColor(target.color);
+        g.setAlpha(target.alpha);
+        if (target.font != null) {
+            g.setFont(target.font);
+        }
+        target.active = null;
+    }
+
+    /// The Codename One context this graphics draws through.
+    public com.codename1.ui.Graphics nativeGraphics() {
+        return g;
+    }
+
+    // ------------------------------------------------------------ mapping
+
+    private void matrixChanged() {
+        a = unit * tx.getScaleX();
+        c = unit * tx.getShearX();
+        e = unit * tx.getTranslateX() + originX;
+        b = unit * tx.getShearY();
+        d = unit * tx.getScaleY();
+        f = unit * tx.getTranslateY() + originY;
+        upright = b == 0 && c == 0 && a > 0 && d > 0;
+    }
+
+    /// The matrix from user space to the context's coordinates as
+    /// `{m00, m10, m01, m11, m02, m12}`, the order of `AffineTransform`'s
+    /// constructor.
+    public double[] deviceMatrix() {
+        return new double[]{a, b, c, d, e, f};
+    }
+
+    private double mapX(double x, double y) {
+        return a * x + c * y + e;
+    }
+
+    private double mapY(double x, double y) {
+        return b * x + d * y + f;
+    }
+
+    /// How many device pixels a user unit of length covers.
+    private double lineScale() {
+        return Math.sqrt(Math.abs(a * d - b * c));
+    }
+
+    /// The device rectangle `{x, y, w, h}` a user rectangle snaps to: its
+    /// edges rounded one by one when upright, else the bounds of its four
+    /// corners.
+    public int[] deviceRect(double x, double y, double w, double h) {
+        if (upright) {
+            int x1 = (int) Math.round(a * x + e);
+            int y1 = (int) Math.round(d * y + f);
+            int x2 = (int) Math.round(a * (x + w) + e);
+            int y2 = (int) Math.round(d * (y + h) + f);
+            return new int[]{x1, y1, x2 - x1, y2 - y1};
+        }
+        double[] xs = {mapX(x, y), mapX(x + w, y), mapX(x, y + h), mapX(x + w, y + h)};
+        double[] ys = {mapY(x, y), mapY(x + w, y), mapY(x, y + h), mapY(x + w, y + h)};
+        double minX = xs[0];
+        double maxX = xs[0];
+        double minY = ys[0];
+        double maxY = ys[0];
+        for (int i = 1; i < 4; i++) {
+            minX = Math.min(minX, xs[i]);
+            maxX = Math.max(maxX, xs[i]);
+            minY = Math.min(minY, ys[i]);
+            maxY = Math.max(maxY, ys[i]);
+        }
+        int x1 = (int) Math.floor(minX);
+        int y1 = (int) Math.floor(minY);
+        return new int[]{x1, y1, (int) Math.ceil(maxX) - x1, (int) Math.ceil(maxY) - y1};
+    }
+
+    /// The shape in device coordinates, every point moved by `offset` user
+    /// units first (half a pixel for the integer outline calls, whose
+    /// coordinates name pixels rather than the lines between them).
+    private GeneralPath devicePath(Shape s, double offset) {
+        GeneralPath p = new GeneralPath();
+        PathIterator it = s.getPathIterator(null);
+        p.setWindingRule(it.getWindingRule() == PathIterator.WIND_EVEN_ODD
+                ? com.codename1.ui.geom.PathIterator.WIND_EVEN_ODD
+                : com.codename1.ui.geom.PathIterator.WIND_NON_ZERO);
+        double[] k = new double[6];
+        while (!it.isDone()) {
+            int type = it.currentSegment(k);
+            for (int i = 0; i < 6; i += 2) {
+                double x = k[i] + offset;
+                double y = k[i + 1] + offset;
+                k[i] = mapX(x, y);
+                k[i + 1] = mapY(x, y);
+            }
+            switch (type) {
+                case PathIterator.SEG_MOVETO:
+                    p.moveTo(k[0], k[1]);
+                    break;
+                case PathIterator.SEG_LINETO:
+                    p.lineTo(k[0], k[1]);
+                    break;
+                case PathIterator.SEG_QUADTO:
+                    p.quadTo(k[0], k[1], k[2], k[3]);
+                    break;
+                case PathIterator.SEG_CUBICTO:
+                    p.curveTo(k[0], k[1], k[2], k[3], k[4], k[5]);
+                    break;
+                default:
+                    p.closePath();
+                    break;
+            }
+            it.next();
+        }
+        return p;
+    }
+
+    // ------------------------------------------------------------ state
+
+    private int alphaOf(Color col) {
+        return Math.round(target.alpha * (col.getAlpha() / 255f) * composite.getAlpha());
+    }
+
+    private void applyColor(Color col) {
+        g.setColor(col.getRGB() & 0xffffff);
+        g.setAlpha(alphaOf(col));
+    }
+
+    /// Makes the context carry this graphics' state. Called before every
+    /// draw; cheap when this graphics drew last and nothing changed.
+    private void sync() {
+        if (target.image != null) {
+            target.image.cn1Drawing();
+        }
+        if (target.active == this && !dirty) {
+            return;
+        }
+        target.active = this;
+        dirty = false;
+        if (clipShape != null) {
+            g.setClip(clipShape);
+            g.clipRect(clipX, clipY, clipW, clipH);
+        } else {
+            g.setClip(clipX, clipY, clipW, clipH);
+        }
+        applyColor(color);
+        if (antialias >= 0) {
+            g.setAntiAliased(antialias == 1);
+        }
+        if (textAntialias >= 0) {
+            g.setAntiAliasedText(textAntialias == 1);
+        }
+    }
+
+    @Override
+    public Graphics create() {
+        return new G2D(this);
+    }
+
+    @Override
+    public void dispose() {
+        if (target.active == this) {
+            target.active = null;
+        }
+    }
+
+    @Override
+    public Color getColor() {
+        return color;
+    }
+
+    @Override
+    public void setColor(Color col) {
+        if (col == null) {
+            return;
+        }
+        color = col;
+        paint = col;
+        dirty = true;
+    }
+
+    @Override
+    public Paint getPaint() {
+        return paint;
+    }
+
+    /// Accepts a [Color] or a [GradientPaint]; null is ignored as in the JDK.
+    @Override
+    public void setPaint(Paint p) {
+        if (p == null) {
+            return;
+        }
+        if (p instanceof Color) {
+            setColor((Color) p);
+        } else if (p instanceof GradientPaint) {
+            paint = p;
+        } else {
+            throw new UnsupportedOperationException("Unsupported paint " + p.getClass().getName()
+                    + ": only Color and GradientPaint can be drawn");
+        }
+    }
+
+    @Override
+    public void setPaintMode() {
+    }
+
+    @Override
+    public void setXORMode(Color c1) {
+        throw new UnsupportedOperationException("XOR painting is not supported");
+    }
+
+    @Override
+    public Composite getComposite() {
+        return composite;
+    }
+
+    /// Accepts `AlphaComposite` in the `SRC_OVER` rule with any alpha, and
+    /// `SRC` at full alpha, which differs from it only for translucent
+    /// colors.
+    @Override
+    public void setComposite(Composite comp) {
+        if (comp == null) {
+            throw new IllegalArgumentException("null Composite");
+        }
+        if (comp instanceof AlphaComposite) {
+            AlphaComposite ac = (AlphaComposite) comp;
+            if (ac.getRule() == AlphaComposite.SRC_OVER
+                    || ac.getRule() == AlphaComposite.SRC && ac.getAlpha() >= 1f) {
+                composite = ac;
+                dirty = true;
+                return;
+            }
+        }
+        throw new UnsupportedOperationException(
+                "Unsupported composite: only AlphaComposite.SRC_OVER can be drawn with");
+    }
+
+    @Override
+    public Stroke getStroke() {
+        return stroke;
+    }
+
+    @Override
+    public void setStroke(Stroke s) {
+        if (s == null) {
+            throw new IllegalArgumentException("null Stroke");
+        }
+        stroke = s;
+    }
+
+    @Override
+    public void setBackground(Color col) {
+        background = col;
+    }
+
+    @Override
+    public Color getBackground() {
+        return background;
+    }
+
+    @Override
+    public Font getFont() {
+        if (font == null) {
+            font = Fonts.defaultFont();
+        }
+        return font;
+    }
+
+    @Override
+    public void setFont(Font fnt) {
+        if (fnt != null) {
+            font = fnt;
+        }
+    }
+
+    @Override
+    public FontMetrics getFontMetrics(Font fnt) {
+        return Fonts.metrics(fnt);
+    }
+
+    @Override
+    public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue) {
+        hints.put(hintKey, hintValue);
+        if (hintKey == RenderingHints.KEY_ANTIALIASING) {
+            antialias = hintValue == RenderingHints.VALUE_ANTIALIAS_ON ? 1
+                    : hintValue == RenderingHints.VALUE_ANTIALIAS_OFF ? 0 : -1;
+            dirty = true;
+        } else if (hintKey == RenderingHints.KEY_TEXT_ANTIALIASING) {
+            textAntialias = hintValue == RenderingHints.VALUE_TEXT_ANTIALIAS_OFF ? 0
+                    : hintValue == RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT ? -1 : 1;
+            dirty = true;
+        }
+    }
+
+    @Override
+    public Object getRenderingHint(RenderingHints.Key hintKey) {
+        return hints.get(hintKey);
+    }
+
+    @Override
+    public void setRenderingHints(Map<?, ?> newHints) {
+        hints.clear();
+        antialias = -1;
+        textAntialias = -1;
+        addRenderingHints(newHints);
+    }
+
+    @Override
+    public void addRenderingHints(Map<?, ?> newHints) {
+        for (Map.Entry<?, ?> en : newHints.entrySet()) {
+            Object key = en.getKey();
+            if (key instanceof RenderingHints.Key) {
+                setRenderingHint((RenderingHints.Key) key, en.getValue());
+            }
+        }
+    }
+
+    @Override
+    public RenderingHints getRenderingHints() {
+        RenderingHints copy = new RenderingHints(null);
+        copy.add(hints);
+        return copy;
+    }
+
+    // ------------------------------------------------------------ transform
+
+    @Override
+    public void translate(int x, int y) {
+        tx.translate(x, y);
+        matrixChanged();
+    }
+
+    @Override
+    public void translate(double x, double y) {
+        tx.translate(x, y);
+        matrixChanged();
+    }
+
+    @Override
+    public void rotate(double theta) {
+        tx.rotate(theta);
+        matrixChanged();
+    }
+
+    @Override
+    public void rotate(double theta, double x, double y) {
+        tx.rotate(theta, x, y);
+        matrixChanged();
+    }
+
+    @Override
+    public void scale(double sx, double sy) {
+        tx.scale(sx, sy);
+        matrixChanged();
+    }
+
+    @Override
+    public void shear(double shx, double shy) {
+        tx.shear(shx, shy);
+        matrixChanged();
+    }
+
+    @Override
+    public void transform(AffineTransform t) {
+        tx.concatenate(t);
+        matrixChanged();
+    }
+
+    /// Replaces the user transform. Identity is the component's own corner,
+    /// so the transform [#getTransform()] answered earlier restores it.
+    @Override
+    public void setTransform(AffineTransform t) {
+        tx = t == null ? new AffineTransform() : new AffineTransform(t);
+        matrixChanged();
+    }
+
+    @Override
+    public AffineTransform getTransform() {
+        return new AffineTransform(tx);
+    }
+
+    // ------------------------------------------------------------ clip
+
+    private void intersectClip(int[] r, int x, int y, int w, int h) {
+        int x1 = Math.max(r[0], x);
+        int y1 = Math.max(r[1], y);
+        int x2 = Math.min(r[0] + r[2], x + w);
+        int y2 = Math.min(r[1] + r[3], y + h);
+        clipX = x1;
+        clipY = y1;
+        clipW = Math.max(0, x2 - x1);
+        clipH = Math.max(0, y2 - y1);
+        dirty = true;
+    }
+
+    private GeneralPath shapeClip(Shape s) {
+        return g.isShapeClipSupported() ? devicePath(s, 0) : null;
+    }
+
+    private void clipTo(double x, double y, double w, double h, boolean replace) {
+        int[] r = deviceRect(x, y, Math.max(0, w), Math.max(0, h));
+        GeneralPath shape = upright ? null : shapeClip(new Rectangle2D.Double(x, y, w, h));
+        if (replace) {
+            intersectClip(r, baseX, baseY, baseW, baseH);
+            clipShape = shape;
+        } else {
+            intersectClip(r, clipX, clipY, clipW, clipH);
+            if (shape != null) {
+                clipShape = shape;
+            }
+        }
+    }
+
+    @Override
+    public void clipRect(int x, int y, int width, int height) {
+        clipTo(x, y, width, height, false);
+    }
+
+    @Override
+    public void setClip(int x, int y, int width, int height) {
+        clipTo(x, y, width, height, true);
+    }
+
+    /// Replaces the clip, never beyond the area the graphics was created
+    /// for; null goes back to that area. A shape that is not a rectangle
+    /// clips exactly where the port clips to shapes and to its bounds
+    /// elsewhere.
+    @Override
+    public void setClip(Shape clip) {
+        clipToShape(clip, true);
+    }
+
+    /// Narrows the clip to its intersection with the shape. When both the
+    /// current clip and the new one are shapes rather than rectangles, the
+    /// result is the new shape within the bounds of the old.
+    @Override
+    public void clip(Shape s) {
+        if (s == null) {
+            setClip(null);
+            return;
+        }
+        clipToShape(s, false);
+    }
+
+    private void clipToShape(Shape s, boolean replace) {
+        if (s == null) {
+            clipX = baseX;
+            clipY = baseY;
+            clipW = baseW;
+            clipH = baseH;
+            clipShape = null;
+            dirty = true;
+            return;
+        }
+        if (s instanceof Rectangle2D) {
+            Rectangle2D r = (Rectangle2D) s;
+            clipTo(r.getX(), r.getY(), r.getWidth(), r.getHeight(), replace);
+            return;
+        }
+        Rectangle2D bounds = s.getBounds2D();
+        int[] r = deviceRect(bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight());
+        if (replace) {
+            intersectClip(r, baseX, baseY, baseW, baseH);
+        } else {
+            intersectClip(r, clipX, clipY, clipW, clipH);
+        }
+        GeneralPath shape = shapeClip(s);
+        if (shape != null || replace) {
+            clipShape = shape;
+        }
+    }
+
+    /// The clip as a rectangle in user space: exact for a rectangular clip
+    /// under an upright transform, the bounding box otherwise.
+    @Override
+    public Shape getClip() {
+        return getClipBounds();
+    }
+
+    @Override
+    public Rectangle getClipBounds() {
+        if (upright) {
+            // A coordinate that was snapped to a device pixel comes back as
+            // the logical pixel it was, not its neighbor.
+            double slackX = 0.5 / a + 1e-6;
+            double slackY = 0.5 / d + 1e-6;
+            int x1 = (int) Math.floor((clipX - e) / a + slackX);
+            int y1 = (int) Math.floor((clipY - f) / d + slackY);
+            int x2 = (int) Math.ceil((clipX + clipW - e) / a - slackX);
+            int y2 = (int) Math.ceil((clipY + clipH - f) / d - slackY);
+            return new Rectangle(x1, y1, Math.max(0, x2 - x1), Math.max(0, y2 - y1));
+        }
+        double det = a * d - b * c;
+        if (det == 0) {
+            return new Rectangle();
+        }
+        double minX = 0;
+        double minY = 0;
+        double maxX = 0;
+        double maxY = 0;
+        for (int i = 0; i < 4; i++) {
+            double px = clipX + ((i & 1) == 0 ? 0 : clipW) - e;
+            double py = clipY + ((i & 2) == 0 ? 0 : clipH) - f;
+            double ux = (d * px - c * py) / det;
+            double uy = (a * py - b * px) / det;
+            if (i == 0) {
+                minX = ux;
+                maxX = ux;
+                minY = uy;
+                maxY = uy;
+            } else {
+                minX = Math.min(minX, ux);
+                maxX = Math.max(maxX, ux);
+                minY = Math.min(minY, uy);
+                maxY = Math.max(maxY, uy);
+            }
+        }
+        int x1 = (int) Math.floor(minX);
+        int y1 = (int) Math.floor(minY);
+        return new Rectangle(x1, y1, (int) Math.ceil(maxX) - x1, (int) Math.ceil(maxY) - y1);
+    }
+
+    @Override
+    public void copyArea(int x, int y, int width, int height, int dx, int dy) {
+        throw new UnsupportedOperationException("copyArea is not supported");
+    }
+
+    // ------------------------------------------------------------ fills
+
+    private boolean solid() {
+        return paint instanceof Color;
+    }
+
+    private void fillSnapped(double x, double y, double w, double h) {
+        int[] r = deviceRect(x, y, w, h);
+        g.fillRect(r[0], r[1], Math.max(1, r[2]), Math.max(1, r[3]));
+    }
+
+    /// Fills a rectangle with the gradient through the port's two-color
+    /// fill when the gradient runs straight across exactly that rectangle;
+    /// false when it does not and the general path must draw it.
+    private boolean fillAxisGradient(GradientPaint gp, double x, double y, double w, double h) {
+        if (!upright || gp.isCyclic()) {
+            return false;
+        }
+        double x1 = gp.getPoint1().getX();
+        double y1 = gp.getPoint1().getY();
+        double x2 = gp.getPoint2().getX();
+        double y2 = gp.getPoint2().getY();
+        boolean horizontal = y1 == y2 && x1 != x2;
+        boolean vertical = x1 == x2 && y1 != y2;
+        if (!horizontal && !vertical) {
+            return false;
+        }
+        double from = horizontal ? Math.min(x1, x2) : Math.min(y1, y2);
+        double to = horizontal ? Math.max(x1, x2) : Math.max(y1, y2);
+        double start = horizontal ? x : y;
+        double end = horizontal ? x + w : y + h;
+        if (Math.abs(from - start) > 1 || Math.abs(to - end) > 1) {
+            return false;
+        }
+        boolean forward = horizontal ? x1 < x2 : y1 < y2;
+        Color first = forward ? gp.getColor1() : gp.getColor2();
+        Color second = forward ? gp.getColor2() : gp.getColor1();
+        int[] r = deviceRect(x, y, w, h);
+        g.setAlpha(Math.round(target.alpha * composite.getAlpha()
+                * Math.min(first.getAlpha(), second.getAlpha()) / 255f));
+        g.fillLinearGradient(first.getRGB() & 0xffffff, second.getRGB() & 0xffffff, r[0], r[1], r[2], r[3],
+                horizontal);
+        dirty = true;
+        return true;
+    }
+
+    @Override
+    public void fillRect(int x, int y, int width, int height) {
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+        if (upright && solid()) {
+            sync();
+            fillSnapped(x, y, width, height);
+        } else {
+            fill(new Rectangle2D.Double(x, y, width, height));
+        }
+    }
+
+    /// Fills with the background color. On an image the area is erased
+    /// first, so a translucent background replaces what was there.
+    @Override
+    public void clearRect(int x, int y, int width, int height) {
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+        sync();
+        if (upright && target.image != null && background.getAlpha() < 255) {
+            int[] r = deviceRect(x, y, width, height);
+            g.clearRect(r[0], r[1], r[2], r[3]);
+        }
+        applyColor(background);
+        dirty = true;
+        if (upright) {
+            fillSnapped(x, y, width, height);
+        } else if (g.isShapeSupported()) {
+            g.fillShape(devicePath(new Rectangle2D.Double(x, y, width, height), 0));
+        }
+    }
+
+    @Override
+    public void fill(Shape s) {
+        sync();
+        if (s instanceof Rectangle2D) {
+            Rectangle2D r = (Rectangle2D) s;
+            if (upright && solid()) {
+                if (r.getWidth() > 0 && r.getHeight() > 0) {
+                    fillSnapped(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+                }
+                return;
+            }
+            if (paint instanceof GradientPaint
+                    && fillAxisGradient((GradientPaint) paint, r.getX(), r.getY(), r.getWidth(), r.getHeight())) {
+                return;
+            }
+        }
+        if (!g.isShapeSupported()) {
+            fillFlattened(s);
+            return;
+        }
+        GeneralPath p = devicePath(s, 0);
+        if (paint instanceof GradientPaint) {
+            GradientPaint gp = (GradientPaint) paint;
+            double x1 = gp.getPoint1().getX();
+            double y1 = gp.getPoint1().getY();
+            double x2 = gp.getPoint2().getX();
+            double y2 = gp.getPoint2().getY();
+            if (fillGradientPixels(p, gp, x1, y1, x2, y2)) {
+                dirty = true;
+                return;
+            }
+            // Only a fill too large to work out pixel by pixel gets here.
+            // The platform's paint is right for it on a port whose clipRect
+            // keeps a shape clip, and for a rectangle on every port; see
+            // GradientFill for what it did to a rounded shape elsewhere.
+            // It draws under a matrix of its own and throws on a graphics
+            // that has none, where the first color has to do.
+            if (!g.isTransformSupported()) {
+                applyColor(gp.getColor1());
+                g.fillShape(p);
+                dirty = true;
+                return;
+            }
+            g.setColor(new LinearGradientPaint(mapX(x1, y1), mapY(x1, y1), mapX(x2, y2), mapY(x2, y2),
+                    new float[]{0f, 1f},
+                    new int[]{gp.getColor1().getRGB() & 0xffffff, gp.getColor2().getRGB() & 0xffffff},
+                    gp.isCyclic() ? MultipleGradientPaint.CycleMethod.REFLECT
+                            : MultipleGradientPaint.CycleMethod.NO_CYCLE,
+                    MultipleGradientPaint.ColorSpaceType.SRGB, null));
+            g.setAlpha(Math.round(target.alpha * composite.getAlpha()
+                    * Math.min(gp.getColor1().getAlpha(), gp.getColor2().getAlpha()) / 255f));
+            g.fillShape(p);
+            dirty = true;
+        } else {
+            g.fillShape(p);
+        }
+    }
+
+    /// Draws the gradient through a path in device coordinates pixel by
+    /// pixel (see [GradientFill]); false when that could not be done.
+    private boolean fillGradientPixels(GeneralPath p, GradientPaint gp, double x1, double y1, double x2,
+                                       double y2) {
+        double det = a * d - b * c;
+        if (det == 0) {
+            return false;
+        }
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double length = dx * dx + dy * dy;
+        double ta = 0;
+        double tb = 0;
+        double tc = 0;
+        if (length > 0) {
+            // The place of a user point on the gradient is the foot of its
+            // perpendicular on the line from the first point to the second,
+            // which is measured in USER space: under a matrix that scales
+            // the two axes differently the bands are no longer square to the
+            // line on the device. A device point is taken back through the
+            // inverse of the matrix, and since both steps are affine the
+            // place is one linear expression in the device coordinates.
+            ta = (d * dx - b * dy) / (det * length);
+            tb = (a * dy - c * dx) / (det * length);
+            double ux = (c * f - d * e) / det;
+            double uy = (b * e - a * f) / det;
+            tc = ((ux - x1) * dx + (uy - y1) * dy) / length;
+        }
+        return GradientFill.fill(g, p, new int[] {clipX, clipY, clipW, clipH},
+                antialias >= 0 ? antialias == 1 : g.isAntiAliased(), ta, tb, tc, gp.getColor1().getRGB(),
+                gp.getColor2().getRGB(), gp.isCyclic(), Math.round(target.alpha * composite.getAlpha()));
+    }
+
+    /// Fills each subpath as a polygon, for a port without shapes. Holes
+    /// and curves finer than a device pixel are lost.
+    private void fillFlattened(Shape s) {
+        PathIterator it = s.getPathIterator(null, 0.5 / Math.max(0.01, lineScale()));
+        int[] xs = new int[16];
+        int[] ys = new int[16];
+        int n = 0;
+        double[] k = new double[6];
+        while (true) {
+            boolean done = it.isDone();
+            int type = done ? PathIterator.SEG_MOVETO : it.currentSegment(k);
+            if (type == PathIterator.SEG_MOVETO || type == PathIterator.SEG_CLOSE) {
+                if (n > 2) {
+                    g.fillPolygon(xs, ys, n);
+                }
+                if (type == PathIterator.SEG_CLOSE || done) {
+                    n = 0;
+                }
+            }
+            if (done) {
+                break;
+            }
+            if (type == PathIterator.SEG_MOVETO) {
+                n = 0;
+            }
+            if (type != PathIterator.SEG_CLOSE) {
+                if (n == xs.length) {
+                    int[] nx = new int[n * 2];
+                    int[] ny = new int[n * 2];
+                    System.arraycopy(xs, 0, nx, 0, n);
+                    System.arraycopy(ys, 0, ny, 0, n);
+                    xs = nx;
+                    ys = ny;
+                }
+                xs[n] = (int) Math.round(mapX(k[0], k[1]));
+                ys[n] = (int) Math.round(mapY(k[0], k[1]));
+                n++;
+            }
+            it.next();
+        }
+    }
+
+    // ------------------------------------------------------------ strokes
+
+    private BasicStroke plainStroke() {
+        if (stroke instanceof BasicStroke) {
+            BasicStroke bs = (BasicStroke) stroke;
+            if (bs.getDashArray() == null) {
+                return bs;
+            }
+        }
+        return null;
+    }
+
+    /// Whether outlines are a single device pixel wide, which the port's
+    /// own outline primitives draw exactly.
+    private boolean hairline() {
+        BasicStroke bs = plainStroke();
+        return bs != null && solid() && upright && bs.getLineWidth() * lineScale() < 1.5;
+    }
+
+    @Override
+    public void draw(Shape s) {
+        stroke(s, 0);
+    }
+
+    private void stroke(Shape s, double offset) {
+        if (!(stroke instanceof BasicStroke)) {
+            fill(stroke.createStrokedShape(s));
+            return;
+        }
+        sync();
+        BasicStroke bs = (BasicStroke) stroke;
+        if (paint instanceof GradientPaint) {
+            applyColor(((GradientPaint) paint).getColor1());
+            dirty = true;
+        }
+        Shape src = bs.getDashArray() == null ? s : dashed(s, bs);
+        if (!g.isShapeSupported()) {
+            drawFlattened(src, offset);
+            return;
+        }
+        int cap = bs.getEndCap() == BasicStroke.CAP_ROUND ? com.codename1.ui.Stroke.CAP_ROUND
+                : bs.getEndCap() == BasicStroke.CAP_SQUARE ? com.codename1.ui.Stroke.CAP_SQUARE
+                : com.codename1.ui.Stroke.CAP_BUTT;
+        int join = bs.getLineJoin() == BasicStroke.JOIN_ROUND ? com.codename1.ui.Stroke.JOIN_ROUND
+                : bs.getLineJoin() == BasicStroke.JOIN_BEVEL ? com.codename1.ui.Stroke.JOIN_BEVEL
+                : com.codename1.ui.Stroke.JOIN_MITER;
+        float width = (float) Math.max(1, bs.getLineWidth() * lineScale());
+        g.drawShape(devicePath(src, offset), new com.codename1.ui.Stroke(width, cap, join, bs.getMiterLimit()));
+    }
+
+    /// Draws the flattened outline segment by segment, one device pixel
+    /// wide, for a port without shapes.
+    private void drawFlattened(Shape s, double offset) {
+        PathIterator it = s.getPathIterator(null, 0.5 / Math.max(0.01, lineScale()));
+        double[] k = new double[6];
+        int startX = 0;
+        int startY = 0;
+        int lastX = 0;
+        int lastY = 0;
+        while (!it.isDone()) {
+            int type = it.currentSegment(k);
+            if (type == PathIterator.SEG_CLOSE) {
+                g.drawLine(lastX, lastY, startX, startY);
+                lastX = startX;
+                lastY = startY;
+            } else {
+                int x = (int) Math.round(mapX(k[0] + offset, k[1] + offset) - 0.5);
+                int y = (int) Math.round(mapY(k[0] + offset, k[1] + offset) - 0.5);
+                if (type == PathIterator.SEG_MOVETO) {
+                    startX = x;
+                    startY = y;
+                } else {
+                    g.drawLine(lastX, lastY, x, y);
+                }
+                lastX = x;
+                lastY = y;
+            }
+            it.next();
+        }
+    }
+
+    /// The dashes of `s` under `bs` as a path of separate segments: the
+    /// outline is flattened and the pattern walked along it, starting
+    /// `dashPhase` into the pattern at every subpath.
+    static Path2D.Double dashed(Shape s, BasicStroke bs) {
+        float[] dash = bs.getDashArray();
+        Path2D.Double out = new Path2D.Double();
+        PathIterator it = s.getPathIterator(null, 0.25);
+        double[] k = new double[6];
+        double startX = 0;
+        double startY = 0;
+        double lastX = 0;
+        double lastY = 0;
+        int index = 0;
+        double left = 0;
+        boolean on = true;
+        boolean pen = false;
+        while (!it.isDone()) {
+            int type = it.currentSegment(k);
+            double x = type == PathIterator.SEG_CLOSE ? startX : k[0];
+            double y = type == PathIterator.SEG_CLOSE ? startY : k[1];
+            if (type == PathIterator.SEG_MOVETO) {
+                startX = x;
+                startY = y;
+                index = 0;
+                on = true;
+                left = dash[0];
+                double phase = bs.getDashPhase();
+                while (phase > 0) {
+                    if (phase >= left) {
+                        phase -= left;
+                        index = (index + 1) % dash.length;
+                        left = dash[index];
+                        on = !on;
+                    } else {
+                        left -= phase;
+                        phase = 0;
+                    }
+                }
+                pen = false;
+            } else {
+                double dx = x - lastX;
+                double dy = y - lastY;
+                double length = Math.sqrt(dx * dx + dy * dy);
+                double done = 0;
+                while (length - done > 1e-9) {
+                    double step = Math.min(left, length - done);
+                    double t0 = done / length;
+                    double t1 = (done + step) / length;
+                    if (on && step > 0) {
+                        if (!pen) {
+                            out.moveTo(lastX + dx * t0, lastY + dy * t0);
+                            pen = true;
+                        }
+                        out.lineTo(lastX + dx * t1, lastY + dy * t1);
+                    }
+                    done += step;
+                    left -= step;
+                    if (left <= 1e-9) {
+                        index = (index + 1) % dash.length;
+                        left = dash[index];
+                        on = !on;
+                        pen = false;
+                    }
+                }
+            }
+            lastX = x;
+            lastY = y;
+            it.next();
+        }
+        return out;
+    }
+
+    /// A line names the pixels it passes through, each one logical pixel
+    /// square. Horizontal and vertical lines are filled as the snapped
+    /// rectangle those pixels cover, so they are crisp and exactly as wide as
+    /// the stroke at any density; the rest are stroked through pixel centers.
+    @Override
+    public void drawLine(int x1, int y1, int x2, int y2) {
+        BasicStroke bs = plainStroke();
+        if (bs != null && upright && solid() && (x1 == x2 || y1 == y2) && bs.getEndCap() != BasicStroke.CAP_ROUND) {
+            sync();
+            double w = Math.max(bs.getLineWidth(), 1 / lineScale());
+            double ext = bs.getEndCap() == BasicStroke.CAP_SQUARE ? w / 2 : 0;
+            double half = w / 2;
+            if (y1 == y2) {
+                fillSnapped(Math.min(x1, x2) + 0.5 - ext, y1 + 0.5 - half, Math.abs(x2 - x1) + 2 * ext, w);
+            } else {
+                fillSnapped(x1 + 0.5 - half, Math.min(y1, y2) + 0.5 - ext, w, Math.abs(y2 - y1) + 2 * ext);
+            }
+            return;
+        }
+        stroke(new Line2D.Double(x1, y1, x2, y2), 0.5);
+    }
+
+    @Override
+    public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
+        if (width < 0 || height < 0) {
+            return;
+        }
+        if (hairline() || !g.isShapeSupported()) {
+            sync();
+            int[] r = deviceRect(x, y, width, height);
+            g.drawRoundRect(r[0], r[1], r[2], r[3], (int) Math.round(arcWidth * a), (int) Math.round(arcHeight * d));
+            return;
+        }
+        stroke(new RoundRectangle2D.Double(x, y, width, height, arcWidth, arcHeight), 0.5);
+    }
+
+    @Override
+    public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+        if (upright && solid()) {
+            sync();
+            int[] r = deviceRect(x, y, width, height);
+            g.fillRoundRect(r[0], r[1], r[2], r[3], (int) Math.round(arcWidth * a), (int) Math.round(arcHeight * d));
+            return;
+        }
+        fill(new RoundRectangle2D.Double(x, y, width, height, arcWidth, arcHeight));
+    }
+
+    @Override
+    public void drawOval(int x, int y, int width, int height) {
+        if (width < 0 || height < 0) {
+            return;
+        }
+        if (hairline() || !g.isShapeSupported()) {
+            sync();
+            int[] r = deviceRect(x, y, width, height);
+            g.drawArc(r[0], r[1], r[2], r[3], 0, 360);
+            return;
+        }
+        stroke(new Ellipse2D.Double(x, y, width, height), 0.5);
+    }
+
+    @Override
+    public void fillOval(int x, int y, int width, int height) {
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+        if (upright && solid()) {
+            sync();
+            int[] r = deviceRect(x, y, width, height);
+            g.fillArc(r[0], r[1], r[2], r[3], 0, 360);
+            return;
+        }
+        fill(new Ellipse2D.Double(x, y, width, height));
+    }
+
+    @Override
+    public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
+        if (width < 0 || height < 0) {
+            return;
+        }
+        if (hairline() || !g.isShapeSupported()) {
+            sync();
+            int[] r = deviceRect(x, y, width, height);
+            g.drawArc(r[0], r[1], r[2], r[3], startAngle, arcAngle);
+            return;
+        }
+        stroke(new Arc2D.Double(x, y, width, height, startAngle, arcAngle, Arc2D.OPEN), 0.5);
+    }
+
+    @Override
+    public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+        if (upright && solid()) {
+            sync();
+            int[] r = deviceRect(x, y, width, height);
+            g.fillArc(r[0], r[1], r[2], r[3], startAngle, arcAngle);
+            return;
+        }
+        fill(new Arc2D.Double(x, y, width, height, startAngle, arcAngle, Arc2D.PIE));
+    }
+
+    private static Path2D.Double polygon(int[] xPoints, int[] yPoints, int nPoints, boolean close) {
+        Path2D.Double p = new Path2D.Double(Path2D.WIND_EVEN_ODD);
+        for (int i = 0; i < nPoints; i++) {
+            if (i == 0) {
+                p.moveTo(xPoints[i], yPoints[i]);
+            } else {
+                p.lineTo(xPoints[i], yPoints[i]);
+            }
+        }
+        if (close && nPoints > 0) {
+            p.closePath();
+        }
+        return p;
+    }
+
+    @Override
+    public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) {
+        if (nPoints > 1) {
+            stroke(polygon(xPoints, yPoints, nPoints, false), 0.5);
+        }
+    }
+
+    @Override
+    public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) {
+        if (nPoints > 1) {
+            stroke(polygon(xPoints, yPoints, nPoints, true), 0.5);
+        }
+    }
+
+    @Override
+    public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints) {
+        if (nPoints > 2) {
+            fill(polygon(xPoints, yPoints, nPoints, true));
+        }
+    }
+
+    // ------------------------------------------------------------ text
+
+    @Override
+    public void drawString(String str, int x, int y) {
+        drawString(str, (float) x, (float) y);
+    }
+
+    /// Draws with the left end of the baseline at the point. The font is
+    /// sized for the current scale; under a rotation the context's transform
+    /// turns it, and a port without transforms draws it unrotated there.
+    @Override
+    public void drawString(String str, float x, float y) {
+        if (str == null) {
+            throw new NullPointerException("String is null");
+        }
+        if (str.length() == 0) {
+            return;
+        }
+        sync();
+        if (paint instanceof GradientPaint) {
+            applyColor(((GradientPaint) paint).getColor1());
+            dirty = true;
+        }
+        Font fnt = getFont();
+        double ls = lineScale();
+        g.setFont(Fonts.nativeFont(fnt, (float) (fnt.getSize2D() * ls)));
+        double px = mapX(x, y);
+        double py = mapY(x, y);
+        if (upright || ls == 0 || !g.isTransformSupported()) {
+            g.drawStringBaseline(str, (int) Math.round(px), (int) Math.round(py));
+            return;
+        }
+        Transform saved = g.getTransform();
+        Transform t = saved.copy();
+        t.concatenate(Transform.makeAffine(a / ls, b / ls, c / ls, d / ls, px, py));
+        g.setTransform(t);
+        g.drawStringBaseline(str, 0, 0);
+        g.setTransform(saved);
+    }
+
+    // ------------------------------------------------------------ images
+
+    private boolean image(Image img, double x, double y, double w, double h, Color bg) {
+        if (img == null) {
+            return true;
+        }
+        com.codename1.ui.Image cn1 = img.cn1Image();
+        if (cn1 == null || w <= 0 || h <= 0) {
+            return false;
+        }
+        sync();
+        if (bg != null) {
+            applyColor(bg);
+            if (upright) {
+                fillSnapped(x, y, w, h);
+            }
+        }
+        g.setAlpha(Math.round(target.alpha * composite.getAlpha()));
+        dirty = true;
+        if (upright || !g.isTransformSupported()) {
+            int[] r = deviceRect(x, y, w, h);
+            if (r[2] == cn1.getWidth() && r[3] == cn1.getHeight()) {
+                g.drawImage(cn1, r[0], r[1]);
+            } else {
+                g.drawImage(cn1, r[0], r[1], Math.max(1, r[2]), Math.max(1, r[3]));
+            }
+            return true;
+        }
+        Transform saved = g.getTransform();
+        Transform t = saved.copy();
+        t.concatenate(Transform.makeAffine(a, b, c, d, mapX(x, y), mapY(x, y)));
+        g.setTransform(t);
+        g.drawImage(cn1, 0, 0, (int) Math.max(1, Math.round(w)), (int) Math.max(1, Math.round(h)));
+        g.setTransform(saved);
+        return true;
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
+        return img == null || image(img, x, y, img.getWidth(observer), img.getHeight(observer), null);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer) {
+        return image(img, x, y, width, height, null);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer) {
+        return img == null || image(img, x, y, img.getWidth(observer), img.getHeight(observer), bgcolor);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor,
+                             ImageObserver observer) {
+        return image(img, x, y, width, height, bgcolor);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
+                             ImageObserver observer) {
+        return drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null, observer);
+    }
+
+    /// Draws the source rectangle of the image scaled onto the destination
+    /// rectangle. A destination or source given right-to-left or
+    /// bottom-to-top is drawn unflipped.
+    @Override
+    public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
+                             Color bgcolor, ImageObserver observer) {
+        if (img == null) {
+            return true;
+        }
+        int dw = Math.abs(dx2 - dx1);
+        int dh = Math.abs(dy2 - dy1);
+        int sw = Math.abs(sx2 - sx1);
+        int sh = Math.abs(sy2 - sy1);
+        if (dw == 0 || dh == 0 || sw == 0 || sh == 0) {
+            return true;
+        }
+        int dx = Math.min(dx1, dx2);
+        int dy = Math.min(dy1, dy2);
+        double fx = dw / (double) sw;
+        double fy = dh / (double) sh;
+        G2D part = new G2D(this);
+        part.clipTo(dx, dy, dw, dh, false);
+        return part.image(img, dx - Math.min(sx1, sx2) * fx, dy - Math.min(sy1, sy2) * fy,
+                img.getWidth(observer) * fx, img.getHeight(observer) * fy, bgcolor);
+    }
+
+    @Override
+    public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs) {
+        if (img == null) {
+            return true;
+        }
+        G2D moved = new G2D(this);
+        if (xform != null) {
+            moved.transform(xform);
+        }
+        return moved.image(img, 0, 0, img.getWidth(obs), img.getHeight(obs), null);
+    }
+
+    // ------------------------------------------------------------ peers
+
+    /// Lets a Codename One component paint itself where this graphics has
+    /// its origin: `painter` runs with the context carrying this graphics'
+    /// clip and alpha and shifted so that the component, which paints at its
+    /// own position (`x`, `y`), lands on the origin. A scaled or rotated
+    /// user transform is applied through the context where it has one.
+    public void paintNative(int x, int y, NativePainter painter) {
+        sync();
+        g.setAlpha(Math.round(target.alpha * composite.getAlpha()));
+        double px = mapX(0, 0);
+        double py = mapY(0, 0);
+        boolean plain = upright && Math.abs(a - unit) < 1e-6 && Math.abs(d - unit) < 1e-6;
+        if (plain || !g.isTransformSupported()) {
+            int shiftX = (int) Math.round(px) - x;
+            int shiftY = (int) Math.round(py) - y;
+            g.translate(shiftX, shiftY);
+            painter.paint(g);
+            g.translate(-shiftX, -shiftY);
+        } else {
+            Transform saved = g.getTransform();
+            Transform t = saved.copy();
+            t.concatenate(Transform.makeAffine(a / unit, b / unit, c / unit, d / unit, px, py));
+            t.translate(-x, -y);
+            g.setTransform(t);
+            painter.paint(g);
+            g.setTransform(saved);
+        }
+        target.active = null;
+    }
+
+    /// Something that paints with a Codename One context; see
+    /// [#paintNative].
+    public interface NativePainter {
+        void paint(com.codename1.ui.Graphics g);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/GradientFill.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/GradientFill.java
new file mode 100644
index 00000000000..fab2a2bcc3a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/GradientFill.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+import com.codename1.ui.geom.GeneralPath;
+import com.codename1.ui.geom.PathIterator;
+
+/// A two-color gradient drawn through a shape pixel by pixel, for [G2D].
+///
+/// The shape is filled in one color on an image of its own, which says how
+/// much of every pixel it covers; each pixel then takes the color the
+/// gradient has there, and the image is drawn where the shape is.
+///
+/// ## Why not the platform's paint
+///
+/// `Graphics.setColor(Paint)` followed by `fillShape` is the obvious way and
+/// was the one used. It confines the paint by making the shape the clip and
+/// putting the rectangle that was the clip back on top with `clipRect`, then
+/// fills a band much larger than the shape under a matrix of its own. What a
+/// port does with a rectangle on top of a shape clip decided the picture: one
+/// dropped the shape, so the band covered the panel from its corner; two
+/// rebuilt a shape with a curved corner as slivers along its edges, so only an
+/// outline of the fill was left. Under a rotation the band is also made of
+/// one-pixel lines, which shows as a hatch. Nothing here uses a shape clip, a
+/// matrix or a paint object: filling a shape in one color, reading pixels and
+/// drawing an image is all a port has to get right.
+///
+/// ## What it costs
+///
+/// An image the size of the part of the shape inside the clip, four bytes a
+/// pixel, and a multiplication and a table look-up for each. The last few
+/// are kept, so a shape repainted where it was costs one image draw; a shape
+/// that changes every frame is worked out every frame. A gradient straight
+/// across exactly the rectangle it fills never comes here -- [G2D] hands that
+/// to the port's two-color fill, which is what a background usually is.
+final class GradientFill {
+
+    /// The most pixels worked out for one fill. Past it [G2D] falls back to
+    /// the platform's paint.
+    private static final int LIMIT = 4000000;
+
+    /// The longest path whose picture is kept, in coordinates.
+    private static final int KEY_LIMIT = 512;
+
+    private static final int TABLE = 256;
+
+    private static final class Entry {
+        double[] key;
+        Image image;
+    }
+
+    private static final Entry[] KEPT = new Entry[8];
+    private static int next;
+
+    private GradientFill() {
+    }
+
+    private static int mix(int from, int to, int shift, double t) {
+        int a = (from >>> shift) & 0xff;
+        int b = (to >>> shift) & 0xff;
+        return ((int) (a + (b - a) * t + 0.5)) << shift;
+    }
+
+    /// Draws the gradient through `path`, which is in the coordinates of
+    /// `g`. A point `(x, y)` there is at `ta * x + tb * y + tc` on the
+    /// gradient: 0 where the first color is and 1 where the second is.
+    /// Outside that the nearest color goes on, or with `cyclic` the colors
+    /// run back and forth. `clip` is the rectangle `{x, y, w, h}` nothing is
+    /// drawn outside of, and `alpha` what `g` draws the result with.
+    ///
+    /// Returns false when it drew nothing and the caller has to: the fill is
+    /// larger than [#LIMIT], or an image here has no shapes.
+    static boolean fill(Graphics g, GeneralPath path, int[] clip, boolean antialias, double ta, double tb,
+                        double tc, int argb1, int argb2, boolean cyclic, int alpha) {
+        float[] b = path.getBounds2D();
+        int left = (int) Math.floor(Math.max(b[0] - 1, clip[0]));
+        int top = (int) Math.floor(Math.max(b[1] - 1, clip[1]));
+        int right = (int) Math.ceil(Math.min(b[0] + (double) b[2] + 1, clip[0] + (double) clip[2]));
+        int bottom = (int) Math.ceil(Math.min(b[1] + (double) b[3] + 1, clip[1] + (double) clip[3]));
+        int w = right - left;
+        int h = bottom - top;
+        if (w <= 0 || h <= 0 || alpha <= 0) {
+            return true;
+        }
+        if ((long) w * h > LIMIT) {
+            return false;
+        }
+        // The path as the image sees it, and the same numbers as the key the
+        // picture is kept under: a shape drawn again somewhere else is the
+        // same picture when it moved by whole pixels.
+        GeneralPath local = new GeneralPath();
+        local.setWindingRule(path.getWindingRule());
+        double[] key = new double[KEY_LIMIT];
+        int n = 0;
+        key[n++] = w;
+        key[n++] = h;
+        key[n++] = ta;
+        key[n++] = tb;
+        // Where the middle of the image's first pixel is on the gradient.
+        double origin = ta * (left + 0.5) + tb * (top + 0.5) + tc;
+        key[n++] = origin;
+        key[n++] = argb1;
+        key[n++] = argb2;
+        key[n++] = (cyclic ? 1 : 0) + (antialias ? 2 : 0) + path.getWindingRule() * 4;
+        boolean keyed = true;
+        PathIterator it = path.getPathIterator();
+        float[] k = new float[6];
+        while (!it.isDone()) {
+            int type = it.currentSegment(k);
+            int count = type == PathIterator.SEG_CLOSE ? 0
+                    : (type == PathIterator.SEG_CUBICTO ? 6 : (type == PathIterator.SEG_QUADTO ? 4 : 2));
+            for (int i = 0; i < count; i += 2) {
+                k[i] -= left;
+                k[i + 1] -= top;
+            }
+            if (keyed && n + count + 1 <= KEY_LIMIT) {
+                key[n++] = type;
+                for (int i = 0; i < count; i++) {
+                    key[n++] = k[i];
+                }
+            } else {
+                keyed = false;
+            }
+            switch (type) {
+                case PathIterator.SEG_MOVETO:
+                    local.moveTo(k[0], k[1]);
+                    break;
+                case PathIterator.SEG_LINETO:
+                    local.lineTo(k[0], k[1]);
+                    break;
+                case PathIterator.SEG_QUADTO:
+                    local.quadTo(k[0], k[1], k[2], k[3]);
+                    break;
+                case PathIterator.SEG_CUBICTO:
+                    local.curveTo(k[0], k[1], k[2], k[3], k[4], k[5]);
+                    break;
+                default:
+                    local.closePath();
+                    break;
+            }
+            it.next();
+        }
+        Image image = null;
+        if (keyed) {
+            double[] exact = new double[n];
+            System.arraycopy(key, 0, exact, 0, n);
+            key = exact;
+            for (int i = 0; i < KEPT.length && image == null; i++) {
+                if (KEPT[i] != null && java.util.Arrays.equals(KEPT[i].key, key)) {
+                    image = KEPT[i].image;
+                }
+            }
+        }
+        if (image == null) {
+            Image mask = Image.createImage(w, h, 0);
+            Graphics mg = mask.getGraphics();
+            if (!mg.isShapeSupported()) {
+                return false;
+            }
+            mg.setColor(0xffffff);
+            mg.setAntiAliased(antialias);
+            mg.fillShape(local);
+            int[] pixels = mask.getRGB();
+            int[] table = new int[TABLE];
+            for (int i = 0; i < TABLE; i++) {
+                double t = i / (double) (TABLE - 1);
+                table[i] = mix(argb1, argb2, 24, t) | mix(argb1, argb2, 16, t) | mix(argb1, argb2, 8, t)
+                        | mix(argb1, argb2, 0, t);
+            }
+            for (int row = 0; row < h; row++) {
+                double t = origin + tb * row;
+                int at = row * w;
+                for (int column = 0; column < w; column++, at++, t += ta) {
+                    int cover = pixels[at] >>> 24;
+                    if (cover == 0) {
+                        pixels[at] = 0;
+                        continue;
+                    }
+                    double place = t;
+                    if (cyclic) {
+                        // Back and forth: 0 to 1 is the first color to the
+                        // second, 1 to 2 the way back.
+                        place = place / 2;
+                        place = (place - Math.floor(place)) * 2;
+                        if (place > 1) {
+                            place = 2 - place;
+                        }
+                    } else if (!(place > 0)) {
+                        place = 0;
+                    } else if (place > 1) {
+                        place = 1;
+                    }
+                    int c = table[(int) (place * (TABLE - 1) + 0.5)];
+                    pixels[at] = (((c >>> 24) * cover + 127) / 255 << 24) | (c & 0xffffff);
+                }
+            }
+            image = Image.createImage(pixels, w, h);
+            if (keyed) {
+                Entry e = new Entry();
+                e.key = key;
+                e.image = image;
+                KEPT[next] = e;
+                next = (next + 1) % KEPT.length;
+            }
+        }
+        g.setAlpha(alpha);
+        g.drawImage(image, left, top);
+        return true;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Icons.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Icons.java
new file mode 100644
index 00000000000..9b06da60068
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Icons.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.ImageIcon;
+
+/// Turns a Swing icon into the image a Codename One widget shows.
+public final class Icons {
+
+    private Icons() {
+    }
+
+    /// The icon as an image of its logical size in device pixels. An icon
+    /// that is not an image is painted once, at one image pixel per logical
+    /// pixel, and scaled.
+    public static com.codename1.ui.Image toNative(Icon icon, Component c) {
+        if (icon == null) {
+            return null;
+        }
+        int w = icon.getIconWidth();
+        int h = icon.getIconHeight();
+        if (w <= 0 || h <= 0) {
+            return null;
+        }
+        com.codename1.ui.Image img = null;
+        if (icon instanceof ImageIcon) {
+            Image i = ((ImageIcon) icon).getImage();
+            if (i != null) {
+                img = i.cn1Image();
+            }
+        }
+        if (img == null) {
+            BufferedImage b = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+            Graphics g = b.createGraphics();
+            try {
+                icon.paintIcon(c, g, 0, 0);
+            } finally {
+                g.dispose();
+            }
+            img = b.cn1Image();
+        }
+        if (img == null) {
+            return null;
+        }
+        int dw = Math.max(1, Units.toDevice(w));
+        int dh = Math.max(1, Units.toDevice(h));
+        if (img.getWidth() != dw || img.getHeight() != dh) {
+            img = img.scaled(dw, dh);
+        }
+        return img;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ImageLoader.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ImageLoader.java
new file mode 100644
index 00000000000..09087bd8f3e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ImageLoader.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.ui.Display;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+/// Reads encoded images (PNG, JPEG, whatever the device decodes) from the
+/// places a desktop application names them by: a file, a URL, a stream or
+/// bytes in memory.
+public final class ImageLoader {
+
+    private ImageLoader() {
+    }
+
+    /// Everything a stream holds; the stream is left open.
+    public static byte[] readAll(InputStream in) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] buffer = new byte[8192];
+        int n = in.read(buffer);
+        while (n >= 0) {
+            out.write(buffer, 0, n);
+            n = in.read(buffer);
+        }
+        return out.toByteArray();
+    }
+
+    /// Decodes an image, or answers `null` for bytes that are not one.
+    public static com.codename1.ui.Image decode(byte[] data, int offset, int length) {
+        if (data == null || length <= 0 || !Display.isInitialized()) {
+            return null;
+        }
+        com.codename1.ui.Image img;
+        try {
+            img = com.codename1.ui.Image.createImage(data, offset, length);
+        } catch (RuntimeException e) {
+            // A port reports bytes it cannot decode this way.
+            return null;
+        }
+        return img;
+    }
+
+    /// Reads a stream to its end and decodes it; the stream is left open.
+    public static com.codename1.ui.Image decode(InputStream in) throws IOException {
+        byte[] data = readAll(in);
+        return decode(data, 0, data.length);
+    }
+
+    /// The image a URL names, or `null` when it cannot be read or is not
+    /// an image.
+    public static com.codename1.ui.Image fromUrl(URL url) {
+        if (url == null) {
+            return null;
+        }
+        try {
+            InputStream in = url.openStream();
+            try {
+                return decode(in);
+            } finally {
+                in.close();
+            }
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    /// The image a path names: the file when there is one, else the
+    /// resource of the application with the path's last name. A desktop
+    /// application reads `images/logo.png` from its working directory; on
+    /// a device the same picture is a resource the build packaged.
+    public static com.codename1.ui.Image fromPath(String filename) {
+        if (filename == null || !Display.isInitialized()) {
+            return null;
+        }
+        try {
+            File file = new File(filename);
+            InputStream in = null;
+            if (file.isFile()) {
+                in = new FileInputStream(file);
+            } else {
+                String name = filename;
+                int cut = Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\'));
+                if (cut >= 0) {
+                    name = name.substring(cut + 1);
+                }
+                if (name.length() > 0) {
+                    in = Display.getInstance().getResourceAsStream(null, "/" + name);
+                }
+            }
+            if (in == null) {
+                return null;
+            }
+            try {
+                return decode(in);
+            } finally {
+                in.close();
+            }
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    /// An AWT image of a decoded one. An image that could not be read is
+    /// an image without pixels, of width and height -1, as on the desktop.
+    public static Image wrap(com.codename1.ui.Image image) {
+        return new NativeImage(image);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Indicators.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Indicators.java
new file mode 100644
index 00000000000..15d2886cf0b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Indicators.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.Image;
+import com.codename1.ui.plaf.Style;
+import java.util.HashMap;
+
+/// The marks of check boxes and radio buttons, drawn here.
+///
+/// A theme is free to draw both the same way -- a filled circle is a
+/// common check box on a phone -- and an application written for a desktop
+/// tells its options apart by the mark alone: a square that is ticked can
+/// be combined with others, a circle with a dot excludes its neighbours.
+/// So the square and the circle are drawn here on every theme, in the
+/// theme's colours.
+public final class Indicators {
+    private static final HashMap<String, Image> CACHE = new HashMap<String, Image>();
+
+    private Indicators() {
+    }
+
+    /// The side of the mark that goes with text in the style's font.
+    public static int size(Style s) {
+        int h = s.getFont() == null ? 0 : s.getFont().getHeight();
+        return Math.max(Units.toDevice(13), h * 4 / 5);
+    }
+
+    /// The mark, `round` for a radio button.
+    public static Image mark(boolean round, boolean on, boolean enabled, int size) {
+        int side = Math.max(6, size);
+        Color field = CellTheme.fieldBackground();
+        Color accent = CellTheme.selectionBackground(null);
+        Color tick = CellTheme.selectionForeground(null);
+        Color edge = CellTheme.mix(EventBridge.defaultBackground(), EventBridge.defaultForeground(), 0.5f);
+        String key = (round ? "r" : "c") + (on ? "1" : "0") + (enabled ? "e" : "d") + side + ':' + field.getRGB()
+                + ':' + accent.getRGB() + ':' + tick.getRGB() + ':' + edge.getRGB();
+        Image cached = CACHE.get(key);
+        if (cached != null) {
+            return cached;
+        }
+        if (CACHE.size() > 64) {
+            CACHE.clear();
+        }
+        Image img = Image.createImage(side, side, 0);
+        Graphics g = img.getGraphics();
+        g.setAntiAliased(true);
+        g.setAlpha(enabled ? 255 : 110);
+        int line = Math.max(1, side / 12);
+        int w = side - 1;
+        if (round) {
+            g.setColor((on ? accent : edge).getRGB() & 0xffffff);
+            g.fillArc(0, 0, w, w, 0, 360);
+            if (on) {
+                int dot = Math.max(2, side * 2 / 5);
+                int at = (w - dot) / 2;
+                g.setColor(tick.getRGB() & 0xffffff);
+                g.fillArc(at, at, dot, dot, 0, 360);
+            } else {
+                g.setColor(field.getRGB() & 0xffffff);
+                g.fillArc(line, line, w - 2 * line, w - 2 * line, 0, 360);
+            }
+        } else {
+            int arc = Math.max(2, side / 4);
+            g.setColor((on ? accent : edge).getRGB() & 0xffffff);
+            g.fillRoundRect(0, 0, w, w, arc, arc);
+            if (on) {
+                g.setColor(tick.getRGB() & 0xffffff);
+                int x1 = side * 22 / 100;
+                int y1 = side * 52 / 100;
+                int x2 = side * 42 / 100;
+                int y2 = side * 72 / 100;
+                int x3 = side * 78 / 100;
+                int y3 = side * 28 / 100;
+                int thick = Math.max(2, side / 7);
+                for (int i = 0; i < thick; i++) {
+                    g.drawLine(x1, y1 - i, x2, y2 - i);
+                    g.drawLine(x2, y2 - i, x3, y3 - i);
+                }
+            } else {
+                int in = Math.max(1, arc - line);
+                g.setColor(field.getRGB() & 0xffffff);
+                g.fillRoundRect(line, line, w - 2 * line, w - 2 * line, in, in);
+            }
+        }
+        if (img.getWidth() == side) {
+            CACHE.put(key, img);
+        }
+        return img;
+    }
+
+    /// Gives the text of a mark the colour of a label unless the
+    /// application set one: a theme may tint a check box as something to
+    /// tap, and beside a mark that reads as a link.
+    public static void labelText(com.codename1.ui.Button peer, PeerSupport support) {
+        // Room beside the mark, so that one option does not run into the
+        // text of the one before it where the theme gives a check box none.
+        int least = Units.toDevice(4);
+        Style any = peer.getUnselectedStyle();
+        if (any.getPaddingLeftNoRTL() < least || any.getPaddingRightNoRTL() < least) {
+            Style all = peer.getAllStyles();
+            byte px = Style.UNIT_TYPE_PIXELS;
+            int top = any.getPaddingTop();
+            int bottom = any.getPaddingBottom();
+            int left = Math.max(least, any.getPaddingLeftNoRTL());
+            int right = Math.max(least, any.getPaddingRightNoRTL());
+            all.setPaddingUnit(px, px, px, px);
+            all.setPadding(top, bottom, left, right);
+        }
+        if (support.owner().isForegroundSet()) {
+            return;
+        }
+        int want = EventBridge.defaultForeground().getRGB() & 0xffffff;
+        Style u = peer.getUnselectedStyle();
+        if (u.getFgColor() != want) {
+            u.setFgColor(want);
+            peer.getSelectedStyle().setFgColor(want);
+            peer.getPressedStyle().setFgColor(want);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/InputState.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/InputState.java
new file mode 100644
index 00000000000..6c46c7c1e71
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/InputState.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+/// What Codename One knows about the keyboard and the pointer while an
+/// input event is being delivered. [EventBridge] asks it for the modifiers
+/// and the button of every AWT event it makes.
+///
+/// The default reads the display. Tests install their own with
+/// [EventBridge#setInputState], because the headless implementation has
+/// neither a keyboard nor mouse buttons.
+public interface InputState {
+
+    /// The keyboard modifiers held, as the extended masks of `InputEvent`
+    /// (`SHIFT_DOWN_MASK`, `CTRL_DOWN_MASK`, `ALT_DOWN_MASK`,
+    /// `META_DOWN_MASK`).
+    int modifiers();
+
+    /// The `MouseEvent` button of the pointer event being delivered:
+    /// `BUTTON1`, `BUTTON2` or `BUTTON3`.
+    int button();
+
+    /// Whether the pointer is a finger or a stylus rather than a mouse. A
+    /// long press is a popup trigger only then.
+    boolean touch();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/KeyMap.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/KeyMap.java
new file mode 100644
index 00000000000..c8e942cabaf
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/KeyMap.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.ui.Display;
+import java.util.HashMap;
+
+/// The two key tables of the layer: Codename One key codes to AWT virtual
+/// keys, and the names `KeyStroke.getKeyStroke(String)` reads to virtual
+/// keys.
+///
+/// A Codename One key code is the character the key types, or a port
+/// specific code for a key that types none. What can be told apart on
+/// every port is mapped: letters, digits, punctuation (to the key that
+/// carries it on a US keyboard, so `?` is `VK_SLASH`), space, enter,
+/// backspace, tab, escape, delete, the modifier keys and the arrows.
+/// The function keys and the navigation block (home, end, page up, page
+/// down, insert) are not: the ports report them with a code that is also a
+/// printable character (F1 arrives as the code of `p`), so they come
+/// through as that character's key.
+public final class KeyMap {
+
+    private static final String SHIFTED = "!@#$%^&*()";
+    private static final String DIGITS = "1234567890";
+    private static final HashMap<String, Integer> names = new HashMap<String, Integer>();
+    private static final HashMap<Integer, String> codes = new HashMap<Integer, String>();
+
+    private KeyMap() {
+    }
+
+    /// The virtual key of a Codename One key code, `VK_UNDEFINED` when it
+    /// has none.
+    public static int virtualKey(int code) {
+        if (code >= 'a' && code <= 'z') {
+            return code - ('a' - 'A');
+        }
+        if ((code >= 'A' && code <= 'Z') || (code >= '0' && code <= '9')) {
+            return code;
+        }
+        switch (code) {
+            case ' ':
+                return KeyEvent.VK_SPACE;
+            case '\n':
+            case '\r':
+                return KeyEvent.VK_ENTER;
+            case 8:
+                return KeyEvent.VK_BACK_SPACE;
+            case '\t':
+                return KeyEvent.VK_TAB;
+            case 27:
+                return KeyEvent.VK_ESCAPE;
+            case 127:
+                return KeyEvent.VK_DELETE;
+            case 16:
+                return KeyEvent.VK_SHIFT;
+            case 17:
+                return KeyEvent.VK_CONTROL;
+            case 18:
+                return KeyEvent.VK_ALT;
+            case 20:
+                return KeyEvent.VK_CAPS_LOCK;
+            case 157:
+                return KeyEvent.VK_META;
+            case ',':
+            case '<':
+                return KeyEvent.VK_COMMA;
+            case '-':
+            case '_':
+                return KeyEvent.VK_MINUS;
+            case '.':
+            case '>':
+                return KeyEvent.VK_PERIOD;
+            case '/':
+            case '?':
+                return KeyEvent.VK_SLASH;
+            case ';':
+            case ':':
+                return KeyEvent.VK_SEMICOLON;
+            case '=':
+            case '+':
+                return KeyEvent.VK_EQUALS;
+            case '[':
+            case '{':
+                return KeyEvent.VK_OPEN_BRACKET;
+            case '\\':
+            case '|':
+                return KeyEvent.VK_BACK_SLASH;
+            case ']':
+            case '}':
+                return KeyEvent.VK_CLOSE_BRACKET;
+            case '`':
+            case '~':
+                return KeyEvent.VK_BACK_QUOTE;
+            case '\'':
+            case '"':
+                return KeyEvent.VK_QUOTE;
+            default:
+                break;
+        }
+        int shifted = code > 0 && code < 128 ? SHIFTED.indexOf((char) code) : -1;
+        if (shifted >= 0) {
+            return DIGITS.charAt(shifted);
+        }
+        if (code > 127 && code < 0xffff) {
+            return KeyEvent.getExtendedKeyCodeForChar(code);
+        }
+        if (Display.isInitialized()) {
+            Display d = Display.getInstance();
+            switch (d.getGameAction(code)) {
+                case Display.GAME_UP:
+                    return KeyEvent.VK_UP;
+                case Display.GAME_DOWN:
+                    return KeyEvent.VK_DOWN;
+                case Display.GAME_LEFT:
+                    return KeyEvent.VK_LEFT;
+                case Display.GAME_RIGHT:
+                    return KeyEvent.VK_RIGHT;
+                case Display.GAME_FIRE:
+                    return KeyEvent.VK_ENTER;
+                default:
+                    break;
+            }
+        }
+        return KeyEvent.VK_UNDEFINED;
+    }
+
+    /// The character a Codename One key code types, `CHAR_UNDEFINED` when
+    /// it types none.
+    public static char keyChar(int code) {
+        if (code == '\r') {
+            return '\n';
+        }
+        if (code == '\n' || code == '\t' || code == 8 || code == 27 || code == 127 || (code >= ' ' && code < 0xffff
+                && code != 157)) {
+            return (char) code;
+        }
+        if (Display.isInitialized() && Display.getInstance().getGameAction(code) == Display.GAME_FIRE) {
+            return '\n';
+        }
+        return KeyEvent.CHAR_UNDEFINED;
+    }
+
+    private static void name(String name, int code) {
+        names.put(name, Integer.valueOf(code));
+        codes.put(Integer.valueOf(code), name);
+    }
+
+    private static void init() {
+        if (!names.isEmpty()) {
+            return;
+        }
+        for (char c = 'A'; c <= 'Z'; c++) {
+            name(String.valueOf(c), c);
+        }
+        for (char c = '0'; c <= '9'; c++) {
+            name(String.valueOf(c), c);
+            name("NUMPAD" + c, KeyEvent.VK_NUMPAD0 + (c - '0'));
+        }
+        for (int i = 1; i <= 12; i++) {
+            name("F" + i, KeyEvent.VK_F1 + i - 1);
+        }
+        for (int i = 13; i <= 24; i++) {
+            name("F" + i, KeyEvent.VK_F13 + i - 13);
+        }
+        name("ENTER", KeyEvent.VK_ENTER);
+        name("BACK_SPACE", KeyEvent.VK_BACK_SPACE);
+        name("TAB", KeyEvent.VK_TAB);
+        name("CANCEL", KeyEvent.VK_CANCEL);
+        name("CLEAR", KeyEvent.VK_CLEAR);
+        name("SHIFT", KeyEvent.VK_SHIFT);
+        name("CONTROL", KeyEvent.VK_CONTROL);
+        name("ALT", KeyEvent.VK_ALT);
+        name("PAUSE", KeyEvent.VK_PAUSE);
+        name("CAPS_LOCK", KeyEvent.VK_CAPS_LOCK);
+        name("ESCAPE", KeyEvent.VK_ESCAPE);
+        name("SPACE", KeyEvent.VK_SPACE);
+        name("PAGE_UP", KeyEvent.VK_PAGE_UP);
+        name("PAGE_DOWN", KeyEvent.VK_PAGE_DOWN);
+        name("END", KeyEvent.VK_END);
+        name("HOME", KeyEvent.VK_HOME);
+        name("LEFT", KeyEvent.VK_LEFT);
+        name("UP", KeyEvent.VK_UP);
+        name("RIGHT", KeyEvent.VK_RIGHT);
+        name("DOWN", KeyEvent.VK_DOWN);
+        name("COMMA", KeyEvent.VK_COMMA);
+        name("MINUS", KeyEvent.VK_MINUS);
+        name("PERIOD", KeyEvent.VK_PERIOD);
+        name("SLASH", KeyEvent.VK_SLASH);
+        name("SEMICOLON", KeyEvent.VK_SEMICOLON);
+        name("EQUALS", KeyEvent.VK_EQUALS);
+        name("OPEN_BRACKET", KeyEvent.VK_OPEN_BRACKET);
+        name("BACK_SLASH", KeyEvent.VK_BACK_SLASH);
+        name("CLOSE_BRACKET", KeyEvent.VK_CLOSE_BRACKET);
+        name("MULTIPLY", KeyEvent.VK_MULTIPLY);
+        name("ADD", KeyEvent.VK_ADD);
+        name("SEPARATOR", KeyEvent.VK_SEPARATOR);
+        name("SUBTRACT", KeyEvent.VK_SUBTRACT);
+        name("DECIMAL", KeyEvent.VK_DECIMAL);
+        name("DIVIDE", KeyEvent.VK_DIVIDE);
+        name("DELETE", KeyEvent.VK_DELETE);
+        name("NUM_LOCK", KeyEvent.VK_NUM_LOCK);
+        name("SCROLL_LOCK", KeyEvent.VK_SCROLL_LOCK);
+        name("PRINTSCREEN", KeyEvent.VK_PRINTSCREEN);
+        name("INSERT", KeyEvent.VK_INSERT);
+        name("HELP", KeyEvent.VK_HELP);
+        name("META", KeyEvent.VK_META);
+        name("BACK_QUOTE", KeyEvent.VK_BACK_QUOTE);
+        name("QUOTE", KeyEvent.VK_QUOTE);
+        name("KP_UP", KeyEvent.VK_KP_UP);
+        name("KP_DOWN", KeyEvent.VK_KP_DOWN);
+        name("KP_LEFT", KeyEvent.VK_KP_LEFT);
+        name("KP_RIGHT", KeyEvent.VK_KP_RIGHT);
+        name("PLUS", KeyEvent.VK_PLUS);
+        name("WINDOWS", KeyEvent.VK_WINDOWS);
+        name("CONTEXT_MENU", KeyEvent.VK_CONTEXT_MENU);
+    }
+
+    /// The virtual key named by the part of a `VK_` constant after the
+    /// prefix (`"ENTER"`, `"F5"`, `"A"`), or `VK_UNDEFINED`.
+    public static int codeOf(String name) {
+        init();
+        Integer i = names.get(name);
+        return i == null ? KeyEvent.VK_UNDEFINED : i.intValue();
+    }
+
+    /// The name of a virtual key as [#codeOf] reads it, or `null`.
+    public static String nameOf(int code) {
+        init();
+        return codes.get(Integer.valueOf(code));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LabelPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LabelPeer.java
new file mode 100644
index 00000000000..757088b760f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LabelPeer.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+
+/// The peer of a label: a Codename One label.
+///
+/// It has the theme's font and colors and none of its spacing. A Swing
+/// label is exactly as large as its text and icon -- programs rely on it
+/// when they put an image in a scroll pane or line a label up with a
+/// field -- so the padding and margin a theme gives its labels, which
+/// are there to keep a finger's distance between widgets a Codename One
+/// layout stacks, are taken off.
+public class LabelPeer extends com.codename1.ui.Label implements Peer {
+
+    private final PeerSupport support;
+
+    public LabelPeer(Component owner) {
+        support = new PeerSupport(owner, this);
+        com.codename1.ui.plaf.Style s = getAllStyles();
+        s.setPadding(0, 0, 0, 0);
+        s.setMargin(0, 0, 0, 0);
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        super.paint(g);
+        super.paintBorder(g);
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LafBorder.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LafBorder.java
new file mode 100644
index 00000000000..5d4484ec960
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LafBorder.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+
+/// The border the defaults answer for a field, a button or a scroll pane:
+/// a line one pixel wide in the palette's line color, read when it is
+/// painted, with room inside it. A border object an application took from
+/// the defaults therefore follows a change of look and feel.
+public final class LafBorder implements Border {
+
+    private final int top;
+    private final int left;
+    private final int bottom;
+    private final int right;
+
+    /// A line with the given room inside it, in logical pixels.
+    public LafBorder(int top, int left, int bottom, int right) {
+        this.top = top;
+        this.left = left;
+        this.bottom = bottom;
+        this.right = right;
+    }
+
+    @Override
+    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
+        if (width <= 0 || height <= 0) {
+            return;
+        }
+        g.setColor(LafTheme.line());
+        g.drawRect(x, y, width - 1, height - 1);
+    }
+
+    @Override
+    public Insets getBorderInsets(Component c) {
+        return new Insets(top + 1, left + 1, bottom + 1, right + 1);
+    }
+
+    @Override
+    public boolean isBorderOpaque() {
+        return false;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LafTheme.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LafTheme.java
new file mode 100644
index 00000000000..4500c31bcbd
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LafTheme.java
@@ -0,0 +1,700 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.table.JTableHeader;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.plaf.Border;
+import com.codename1.ui.plaf.Style;
+import com.codename1.ui.plaf.UIManager;
+import java.util.Hashtable;
+
+/// What a look and feel is on this layer: a choice between a light and a
+/// dark palette.
+///
+/// The widgets are Codename One components drawn with the Codename One
+/// theme, and the colors the Swing `UIManager` answers are read from that
+/// theme. So a look and feel is not installed, it is *selected*: the
+/// display is told which mode to draw in, and a theme that has a dark
+/// variant of its own switches to it. A theme that has none -- its window
+/// stays light when dark was asked for, or the reverse -- gets the
+/// layer's own palette laid over it, for every widget family the layer
+/// uses. So does an application that has no theme to speak of, one whose
+/// fields still have the border Codename One draws when a theme says
+/// nothing, as soon as it names a look and feel: it asked for a look and
+/// has none. Either way there is one theming path: after the selection
+/// the theme is dark, and everything that reads it follows.
+///
+/// Open windows are restyled at once. A color the layer itself gave a
+/// list, a table or a tree when it was made is exchanged for its
+/// counterpart in the new palette; so is a color an application set that
+/// is equal to one of those. Any other color an application set, or
+/// read from the defaults and kept, stays as it is.
+public final class LafTheme {
+
+    /// The accent of the light palette, and of the dark one.
+    private static final int ACCENT_LIGHT = 0x2675bf;
+    private static final int ACCENT_DARK = 0x4b6eaf;
+
+    /// Whether the layer's own palette was laid over the theme. Once it
+    /// was, it is laid again on every selection: there is no taking theme
+    /// properties back.
+    private static boolean overlaid;
+    /// The accent an application chose, or `null`.
+    private static Color accent;
+    private static boolean unknownLogged;
+
+    private LafTheme() {
+    }
+
+    // ------------------------------------------------------------ state
+
+    private static int luminance(Color c) {
+        return (c.getRed() * 299 + c.getGreen() * 587 + c.getBlue() * 114) / 1000;
+    }
+
+    /// Whether the theme is dark now: its window background is.
+    public static boolean isDark() {
+        return luminance(EventBridge.defaultBackground()) < 128;
+    }
+
+    /// Whether the platform asks for dark mode, whatever was selected.
+    private static boolean platformDark() {
+        Display d = Display.getInstance();
+        d.setDarkMode(null);
+        Boolean b = d.isDarkMode();
+        return b != null && b.booleanValue();
+    }
+
+    /// The accent color: the application's, or the palette's.
+    public static Color accent() {
+        if (accent != null) {
+            return accent;
+        }
+        return new Color(isDark() ? ACCENT_DARK : ACCENT_LIGHT);
+    }
+
+    /// Sets the accent color; `null` gives the palette's back. Open
+    /// windows are not restyled by this alone.
+    public static void setAccent(Color c) {
+        accent = c;
+    }
+
+    /// The color of lines: borders, separators, the edges of fields.
+    public static Color line() {
+        return CellTheme.mix(EventBridge.defaultBackground(), EventBridge.defaultForeground(), isDark() ? 0.22f : 0.24f);
+    }
+
+    /// The color of text that is disabled.
+    public static Color disabledText() {
+        return CellTheme.mix(EventBridge.defaultForeground(), EventBridge.defaultBackground(), 0.5f);
+    }
+
+    /// The background of a push button.
+    public static Color buttonBackground() {
+        if (Display.isInitialized()) {
+            Style s = UIManager.getInstance().getComponentStyle("Button");
+            if (s != null && (s.getBgTransparency() & 0xff) == 255) {
+                return new Color(s.getBgColor() & 0xffffff);
+            }
+        }
+        return CellTheme.mix(CellTheme.fieldBackground(), EventBridge.defaultBackground(), isDark() ? 0.4f : 0f);
+    }
+
+    /// Says once that a look and feel is not one the layer knows.
+    public static void unknown(String name) {
+        if (!unknownLogged) {
+            unknownLogged = true;
+            com.codename1.io.Log.p("desktopcompat.laf: " + name
+                    + " is not a look and feel this layer knows as light or dark; the palette is unchanged");
+        }
+    }
+
+    /// Puts everything back the way it was before any look and feel was
+    /// selected: no mode forced on the display, no palette over the theme,
+    /// the theme itself emptied. For tests, which share one display.
+    public static void reset() {
+        accent = null;
+        unknownLogged = false;
+        if (!Display.isInitialized()) {
+            overlaid = false;
+            return;
+        }
+        Display.getInstance().setDarkMode(null);
+        if (overlaid) {
+            overlaid = false;
+            UIManager.getInstance().setThemeProps(new Hashtable<String, Object>());
+        }
+    }
+
+    // ------------------------------------------------------------ select
+
+    /// The colors the layer hands to widgets when they are made, in a
+    /// fixed order, as the theme has them now.
+    private static Color[] roles() {
+        return new Color[]{
+            CellTheme.background(null), CellTheme.foreground(null), CellTheme.selectionBackground(null),
+            CellTheme.selectionForeground(null), CellTheme.grid(null), CellTheme.headerBackground(null),
+            CellTheme.headerForeground(null), EventBridge.defaultBackground(), EventBridge.defaultForeground(),
+            CellTheme.fieldBackground()};
+    }
+
+    /// Selects the palette: dark, light, or with `null` whichever the
+    /// platform is in. Open windows are restyled. Does nothing before
+    /// there is a display.
+    public static void select(Boolean dark) {
+        if (!Display.isInitialized()) {
+            return;
+        }
+        Color[] before = roles();
+        boolean want = dark != null ? dark.booleanValue() : platformDark();
+        Display.getInstance().setDarkMode(dark);
+        UIManager m = UIManager.getInstance();
+        m.refreshTheme();
+        if (overlaid || isDark() != want || (dark != null && bare(m)) || inkIsLight() != want) {
+            m.addThemeProps(overlay(want));
+            overlaid = true;
+        }
+        Color[] after = roles();
+        Window[] all = Window.getWindows();
+        for (int i = 0; i < all.length; i++) {
+            exchange(all[i], before, after);
+            restyle(all[i]);
+        }
+    }
+
+    /// Whether rows are written in a light ink, which is what a dark theme
+    /// does. A theme can turn its windows dark and leave its rows as they
+    /// were, and their text is then dark on dark: such a theme gets the
+    /// layer's palette like one that has no dark side at all.
+    private static boolean inkIsLight() {
+        Color ink = CellTheme.foreground(null);
+        return (ink.getRed() * 3 + ink.getGreen() * 6 + ink.getBlue()) / 10 > 128;
+    }
+
+    /// Whether the theme styles nothing: a text field still has the
+    /// border Codename One gives one when no theme says otherwise.
+    private static boolean bare(UIManager m) {
+        Style s = m.getComponentStyle("TextField");
+        return s != null && s.getBorder() == Border.getDefaultBorder();
+    }
+
+    /// Gives the peers of `c` and of everything in it what was set on the
+    /// components again, after their styles were taken from the theme
+    /// anew: the colors and the font, and for a button what its border
+    /// and content area switches did to its style.
+    private static void reapply(Component c) {
+        com.codename1.ui.Component p = c.cn1PeerOrNull();
+        if (p instanceof Peer) {
+            ((Peer) p).support().applyStyle();
+        }
+        Object o = c;
+        if (o instanceof AbstractButton) {
+            // The button compares what it is asked for with what it last
+            // did, so it is asked for another margin and then for its own.
+            AbstractButton b = (AbstractButton) o;
+            Insets own = b.getMargin();
+            b.setMargin(own == null ? new Insets(1, 1, 1, 1) : null);
+            b.setMargin(own);
+        }
+        if (o instanceof Container) {
+            Component[] kids = ((Container) o).getComponents();
+            for (int i = 0; i < kids.length; i++) {
+                reapply(kids[i]);
+            }
+        }
+    }
+
+    /// Restyles every open window from the theme as it is now.
+    public static void restyleAll() {
+        if (!Display.isInitialized()) {
+            return;
+        }
+        Window[] all = Window.getWindows();
+        for (int i = 0; i < all.length; i++) {
+            restyle(all[i]);
+        }
+    }
+
+    /// Restyles the window `c` is in, or `c` itself when it is in none:
+    /// the Codename One widgets take their styles from the theme again,
+    /// and everything is laid out and painted.
+    public static void restyle(Component c) {
+        if (c == null || !Display.isInitialized()) {
+            return;
+        }
+        Component top = c;
+        while (!(top instanceof Window) && top.getParent() != null) {
+            top = top.getParent();
+        }
+        if (top instanceof Window) {
+            Form f = ((Window) top).cn1Form();
+            if (f != null) {
+                f.refreshTheme(false);
+                f.revalidate();
+            }
+        } else {
+            com.codename1.ui.Component p = top.cn1PeerOrNull();
+            if (p != null) {
+                p.refreshTheme(false);
+            }
+        }
+        reapply(top);
+        top.invalidate();
+        top.validate();
+        top.repaint();
+    }
+
+    /// The roles a background may have, a foreground, and so on.
+    private static final int[] BACK = {0, 5, 7, 9};
+    private static final int[] FORE = {1, 6, 8};
+    private static final int[] SEL_BACK = {2};
+    private static final int[] SEL_FORE = {3};
+    private static final int[] GRID = {4};
+
+    private static Color swap(Color c, Color[] before, Color[] after, int[] roles) {
+        if (c == null) {
+            return null;
+        }
+        for (int i = 0; i < roles.length; i++) {
+            int r = roles[i];
+            if (before[r].equals(c)) {
+                return after[r].equals(c) ? null : after[r];
+            }
+        }
+        return null;
+    }
+
+    /// Exchanges the colors of the old palette for those of the new one
+    /// in `c` and everything in it.
+    private static void exchange(Component c, Color[] before, Color[] after) {
+        if (c.isBackgroundSet()) {
+            Color n = swap(c.getBackground(), before, after, BACK);
+            if (n != null) {
+                c.setBackground(n);
+            }
+        }
+        if (c.isForegroundSet()) {
+            Color n = swap(c.getForeground(), before, after, FORE);
+            if (n != null) {
+                c.setForeground(n);
+            }
+        }
+        Object o = c;
+        if (o instanceof JTable) {
+            JTable t = (JTable) o;
+            Color n = swap(t.getSelectionBackground(), before, after, SEL_BACK);
+            if (n != null) {
+                t.setSelectionBackground(n);
+            }
+            n = swap(t.getSelectionForeground(), before, after, SEL_FORE);
+            if (n != null) {
+                t.setSelectionForeground(n);
+            }
+            n = swap(t.getGridColor(), before, after, GRID);
+            if (n != null) {
+                t.setGridColor(n);
+            }
+            JTableHeader h = t.getTableHeader();
+            if (h != null && h.getParent() == null) {
+                exchange(h, before, after);
+            }
+        } else if (o instanceof JList) {
+            JList<?> l = (JList<?>) o;
+            Color n = swap(l.getSelectionBackground(), before, after, SEL_BACK);
+            if (n != null) {
+                l.setSelectionBackground(n);
+            }
+            n = swap(l.getSelectionForeground(), before, after, SEL_FORE);
+            if (n != null) {
+                l.setSelectionForeground(n);
+            }
+        } else if (o instanceof JTree) {
+            TreeCellRenderer r = ((JTree) o).getCellRenderer();
+            if (r instanceof DefaultTreeCellRenderer) {
+                DefaultTreeCellRenderer d = (DefaultTreeCellRenderer) r;
+                Color n = swap(d.getTextSelectionColor(), before, after, SEL_FORE);
+                if (n != null) {
+                    d.setTextSelectionColor(n);
+                }
+                n = swap(d.getTextNonSelectionColor(), before, after, FORE);
+                if (n != null) {
+                    d.setTextNonSelectionColor(n);
+                }
+                n = swap(d.getBackgroundSelectionColor(), before, after, SEL_BACK);
+                if (n != null) {
+                    d.setBackgroundSelectionColor(n);
+                }
+                n = swap(d.getBackgroundNonSelectionColor(), before, after, BACK);
+                if (n != null) {
+                    d.setBackgroundNonSelectionColor(n);
+                }
+                n = swap(d.getBorderSelectionColor(), before, after, SEL_BACK);
+                if (n != null) {
+                    d.setBorderSelectionColor(n);
+                }
+            }
+        }
+        if (o instanceof Container) {
+            Component[] kids = ((Container) o).getComponents();
+            for (int i = 0; i < kids.length; i++) {
+                exchange(kids[i], before, after);
+            }
+        }
+    }
+
+    // ------------------------------------------------------------ overlay
+
+    private static String hex(int rgb) {
+        return Integer.toHexString(rgb & 0xffffff);
+    }
+
+    private static int mix(int a, int b, float t) {
+        return CellTheme.mix(new Color(a), new Color(b), t).getRGB() & 0xffffff;
+    }
+
+    /// One widget style in every state: background, text and whether the
+    /// background is filled.
+    private static void ui(Hashtable<String, Object> h, String id, int bg, int fg, int disabled, boolean filled) {
+        String[] states = {"", "sel#", "press#", "dis#"};
+        for (int i = 0; i < states.length; i++) {
+            String k = id + "." + states[i];
+            h.put(k + "bgColor", hex(bg));
+            h.put(k + "fgColor", hex(i == 3 ? disabled : fg));
+            h.put(k + "transparency", filled ? "255" : "0");
+        }
+    }
+
+    private static void edge(Hashtable<String, Object> h, String id, int line, int focus) {
+        h.put(id + ".border", Border.createLineBorder(1, line));
+        h.put(id + ".sel#border", Border.createLineBorder(1, focus));
+        h.put(id + ".press#border", Border.createLineBorder(1, focus));
+        h.put(id + ".dis#border", Border.createLineBorder(1, line));
+    }
+
+    /// The layer's palette as Codename One theme properties.
+    private static Hashtable<String, Object> overlay(boolean dark) {
+        int win = dark ? 0x3c3f41 : 0xf2f2f2;
+        int field = dark ? 0x46494b : 0xffffff;
+        int ink = dark ? 0xdddddd : 0x000000;
+        int button = dark ? 0x4e5052 : 0xffffff;
+        int sel = accent != null ? accent.getRGB() & 0xffffff : dark ? ACCENT_DARK : ACCENT_LIGHT;
+        int selInk = 0xffffff;
+        int off = 0x8c8c8c;
+        int line = dark ? 0x616365 : 0xc4c4c4;
+        int head = mix(field, ink, 0.08f);
+        Hashtable<String, Object> h = new Hashtable<String, Object>();
+        String[] window = {"Form", "ContentPane", "Dialog", "DialogBody", "DialogContentPane", "DialogTitle",
+            "PopupDialog", "PopupContentPane", "Title", "TitleArea", "Toolbar", "MenuBar", "Menu", "TabsContainer",
+            "TabbedPane", "SideNavigationPanel", "StatusBar", "CommandList", "Sheet"};
+        for (int i = 0; i < window.length; i++) {
+            ui(h, window[i], win, ink, off, true);
+        }
+        String[] clear = {"Label", "Container", "CheckBox", "RadioButton", "Command", "TitleCommand", "BackCommand",
+            "DialogCommandArea", "Slider", "SpanLabel", "SpanLabelText", "MultiLine1", "MultiLine2", "Separator",
+            "Scroll", "ScrollThumb", "HorizontalScroll", "HorizontalScrollThumb", "SpinnerRenderer", "Spinner",
+            "Calendar", "CalendarTitle", "CalendarDay", "CalendarDate", "PickerButton", "Picker"};
+        for (int i = 0; i < clear.length; i++) {
+            ui(h, clear[i], win, ink, off, false);
+        }
+        String[] fields = {"TextField", "TextArea", "ComboBox", "ComboBoxPopup", "ComboBoxList", "List", "TextHint"};
+        for (int i = 0; i < fields.length; i++) {
+            ui(h, fields[i], field, ink, off, true);
+            if (i < 3) {
+                edge(h, fields[i], line, sel);
+            }
+        }
+        h.put("TextHint.fgColor", hex(off));
+        h.put("TextHint.transparency", "0");
+        String[] buttons = {"Button", "RaisedButton", "DialogButton", "DialogCommand", "ToolTip", "Tooltip"};
+        for (int i = 0; i < buttons.length; i++) {
+            ui(h, buttons[i], button, ink, off, true);
+            h.put(buttons[i] + ".press#bgColor", hex(mix(button, ink, 0.15f)));
+            h.put(buttons[i] + ".border", Border.createLineBorder(1, line));
+            h.put(buttons[i] + ".sel#border", Border.createLineBorder(1, sel));
+            h.put(buttons[i] + ".press#border", Border.createLineBorder(1, sel));
+            h.put(buttons[i] + ".dis#border", Border.createLineBorder(1, line));
+        }
+        String[] rows = {"TableCell", "ListRenderer", "ComboBoxItem", "MenuItem"};
+        for (int i = 0; i < rows.length; i++) {
+            ui(h, rows[i], field, ink, off, true);
+            h.put(rows[i] + ".sel#bgColor", hex(sel));
+            h.put(rows[i] + ".sel#fgColor", hex(selInk));
+            h.put(rows[i] + ".press#bgColor", hex(sel));
+            h.put(rows[i] + ".press#fgColor", hex(selInk));
+        }
+        ui(h, "ToggleButton", button, ink, off, true);
+        h.put("ToggleButton.border", Border.createLineBorder(1, line));
+        h.put("ToggleButton.sel#border", Border.createLineBorder(1, sel));
+        h.put("ToggleButton.press#border", Border.createLineBorder(1, sel));
+        h.put("ToggleButton.dis#border", Border.createLineBorder(1, line));
+        h.put("ToggleButton.press#bgColor", hex(mix(button, ink, 0.22f)));
+        ui(h, "ListRendererFocus", sel, selInk, off, true);
+        ui(h, "ComboBoxFocus", sel, selInk, off, true);
+        ui(h, "TableHeader", head, ink, off, true);
+        ui(h, "Tab", win, ink, off, true);
+        ui(h, "UnselectedTab", win, ink, off, true);
+        ui(h, "SelectedTab", win, ink, off, true);
+        h.put("Tab.press#fgColor", hex(dark ? 0xffffff : sel));
+        h.put("Tab.sel#fgColor", hex(dark ? 0xffffff : sel));
+        ui(h, "SliderFull", sel, selInk, off, true);
+        h.put("Slider.bgColor", hex(mix(win, ink, 0.22f)));
+        h.put("Scroll.fgColor", hex(mix(win, ink, 0.1f)));
+        h.put("ScrollThumb.fgColor", hex(mix(win, ink, 0.4f)));
+        h.put("ScrollThumb.bgColor", hex(mix(win, ink, 0.4f)));
+        h.put("Separator.fgColor", hex(line));
+        return h;
+    }
+
+    // ------------------------------------------------------------ defaults
+
+    /// The font of a FlatLaf style class or typography key -- `h1`,
+    /// `small`, `monospaced` and so on -- derived from the default font;
+    /// `null` for a name that is none.
+    public static Font styleFont(String name) {
+        Font base = Fonts.defaultFont();
+        float size = base.getSize2D();
+        if ("h00".equals(name)) {
+            return base.deriveFont(Font.BOLD, size + 24);
+        } else if ("h0".equals(name)) {
+            return base.deriveFont(Font.BOLD, size + 18);
+        } else if ("h1".equals(name)) {
+            return base.deriveFont(Font.BOLD, size + 12);
+        } else if ("h2".equals(name)) {
+            return base.deriveFont(Font.BOLD, size + 6);
+        } else if ("h3".equals(name)) {
+            return base.deriveFont(Font.BOLD, size + 3);
+        } else if ("h4".equals(name) || "semibold".equals(name)) {
+            return base.deriveFont(Font.BOLD, size);
+        } else if ("h1.regular".equals(name)) {
+            return base.deriveFont(Font.PLAIN, size + 12);
+        } else if ("h2.regular".equals(name)) {
+            return base.deriveFont(Font.PLAIN, size + 6);
+        } else if ("h3.regular".equals(name)) {
+            return base.deriveFont(Font.PLAIN, size + 3);
+        } else if ("large".equals(name)) {
+            return base.deriveFont(Font.PLAIN, size + 2);
+        } else if ("medium".equals(name)) {
+            return base.deriveFont(Font.PLAIN, Math.max(6, size - 1));
+        } else if ("small".equals(name)) {
+            return base.deriveFont(Font.PLAIN, Math.max(6, size - 2));
+        } else if ("mini".equals(name)) {
+            return base.deriveFont(Font.PLAIN, Math.max(6, size - 3));
+        } else if ("light".equals(name) || "default".equals(name)) {
+            return base;
+        } else if ("monospaced".equals(name)) {
+            return new Font(Font.MONOSPACED, Font.PLAIN, Math.round(size));
+        }
+        return null;
+    }
+
+    private static Color action(String name, boolean dark) {
+        if ("Red".equals(name)) {
+            return new Color(dark ? 0xc75450 : 0xdb5860);
+        } else if ("Yellow".equals(name)) {
+            return new Color(dark ? 0xf0a732 : 0xeda200);
+        } else if ("Green".equals(name)) {
+            return new Color(dark ? 0x499c54 : 0x59a869);
+        } else if ("Blue".equals(name)) {
+            return new Color(dark ? 0x3592c4 : 0x389fd6);
+        } else if ("Grey".equals(name)) {
+            return new Color(dark ? 0xafb1b3 : 0x6e6e6e);
+        } else if ("GreyInline".equals(name)) {
+            return new Color(0x7f8b91);
+        } else if ("Purple".equals(name) || "Pink".equals(name)) {
+            return new Color("Pink".equals(name) ? 0xf98b9e : 0xb99bf8);
+        } else if ("BlackText".equals(name)) {
+            return new Color(0x231f20);
+        } else if ("RedStatus".equals(name)) {
+            return new Color(0xe05555);
+        } else if ("GreenAndroid".equals(name)) {
+            return new Color(0xa4c639);
+        } else if ("YellowDark".equals(name)) {
+            return new Color(0xd9a343);
+        }
+        return null;
+    }
+
+    /// What the palette has for a key of the Swing defaults that the
+    /// theme itself has no direct answer to: the keys of the desktop look
+    /// and feels and of FlatLaf that applications read. `null` for a key
+    /// that is not known.
+    public static Object value(String k) {
+        boolean dark = isDark();
+        Color win = EventBridge.defaultBackground();
+        Color ink = EventBridge.defaultForeground();
+        if ("laf.dark".equals(k)) {
+            return Boolean.valueOf(dark);
+        }
+        if (k.startsWith("Actions.")) {
+            return action(k.substring(8), dark);
+        }
+        if (k.startsWith("Objects.")) {
+            return action(k.substring(8), dark);
+        }
+        if ("Component.accentColor".equals(k) || "@accentColor".equals(k) || "Component.focusedBorderColor".equals(k)
+                || "ProgressBar.foreground".equals(k) || "TabbedPane.underlineColor".equals(k)
+                || "Button.default.background".equals(k) || "Slider.thumbColor".equals(k)
+                || "Slider.trackValueColor".equals(k) || "CheckBox.icon.selectedBackground".equals(k)) {
+            return accent();
+        }
+        if ("Component.focusColor".equals(k) || "Button.default.focusColor".equals(k)) {
+            return CellTheme.mix(accent(), win, 0.45f);
+        }
+        if ("Component.linkColor".equals(k) || "Hyperlink.linkColor".equals(k)) {
+            return accent != null ? accent : new Color(dark ? 0x589df6 : 0x2470b3);
+        }
+        if ("Button.default.foreground".equals(k)) {
+            return Color.WHITE;
+        }
+        if (k.startsWith("Component.error.") || "Component.errorColor".equals(k)) {
+            return new Color(dark ? 0x8b3c3c : 0xe53e4d);
+        }
+        if (k.startsWith("Component.warning.")) {
+            return new Color(dark ? 0xac7920 : 0xe2a53a);
+        }
+        if (k.startsWith("Component.success.")) {
+            return new Color(dark ? 0x499c54 : 0x59a869);
+        }
+        if ("Component.borderColor".equals(k) || "Separator.foreground".equals(k) || "controlShadow".equals(k)
+                || k.endsWith(".borderColor") || k.endsWith(".separatorColor") || "SplitPane.dividerColor".equals(k)
+                || "SplitPaneDivider.gripColor".equals(k) || "ToolBar.separatorColor".equals(k)
+                || k.endsWith(".shadow") || "TabbedPane.contentAreaColor".equals(k)) {
+            return line();
+        }
+        if ("controlDkShadow".equals(k) || k.endsWith(".darkShadow")) {
+            return CellTheme.mix(win, ink, 0.45f);
+        }
+        if ("controlHighlight".equals(k) || "controlLtHighlight".equals(k) || k.endsWith(".highlight")) {
+            return CellTheme.mix(win, dark ? ink : Color.WHITE, dark ? 0.12f : 0.8f);
+        }
+        if (k.endsWith(".disabledForeground") || k.endsWith(".inactiveForeground") || k.endsWith(".disabledText")
+                || "textInactiveText".equals(k) || k.endsWith(".placeholderForeground")
+                || k.endsWith(".disabledSelectedForeground") || "inactiveCaptionText".equals(k)) {
+            return disabledText();
+        }
+        if (k.endsWith(".inactiveBackground") || k.endsWith(".disabledBackground") || "inactiveCaption".equals(k)) {
+            return win;
+        }
+        if ("Button.background".equals(k) || "ToggleButton.background".equals(k) || "ComboBox.buttonBackground".equals(k)) {
+            return buttonBackground();
+        }
+        if (k.endsWith(".hoverBackground") || k.endsWith(".selectionInactiveBackground")
+                || k.endsWith(".alternateRowColor")) {
+            return CellTheme.mix(k.startsWith("Button.") ? buttonBackground() : CellTheme.fieldBackground(), ink, 0.08f);
+        }
+        if (k.endsWith(".pressedBackground")) {
+            return CellTheme.mix(k.startsWith("Button.") ? buttonBackground() : win, ink, 0.16f);
+        }
+        if (k.endsWith(".selectionInactiveForeground") || k.endsWith(".textForeground") || k.endsWith(".caretForeground")
+                || k.endsWith(".caretColor") || "infoText".equals(k)) {
+            return ink;
+        }
+        if ("info".equals(k) || "ToolTip.background".equals(k)) {
+            return CellTheme.mix(win, ink, dark ? 0.12f : 0.03f);
+        }
+        if ("defaultFont".equals(k)) {
+            return Fonts.defaultFont();
+        }
+        if (k.endsWith(".font")) {
+            return styleFont(k.substring(0, k.length() - 5));
+        }
+        if (k.endsWith(".border")) {
+            return border(k.substring(0, k.length() - 7));
+        }
+        if ("Button.margin".equals(k) || "ToggleButton.margin".equals(k)) {
+            return new Insets(2, 14, 2, 14);
+        }
+        if ("TextField.margin".equals(k) || "TextArea.margin".equals(k) || "PasswordField.margin".equals(k)
+                || "FormattedTextField.margin".equals(k) || "ComboBox.padding".equals(k) || "Table.cellMargins".equals(k)
+                || "EditorPane.margin".equals(k) || "TextPane.margin".equals(k)) {
+            return new Insets(2, 6, 2, 6);
+        }
+        if ("TabbedPane.tabInsets".equals(k)) {
+            return new Insets(4, 12, 4, 12);
+        }
+        if ("MenuItem.margin".equals(k) || "Menu.margin".equals(k)) {
+            return new Insets(3, 6, 3, 6);
+        }
+        if ("ToolBar.buttonMargins".equals(k)) {
+            return new Insets(3, 3, 3, 3);
+        }
+        if ("CheckBox.margin".equals(k) || "RadioButton.margin".equals(k)) {
+            return new Insets(2, 2, 2, 2);
+        }
+        if ("Component.arc".equals(k) || "CheckBox.arc".equals(k) || "ProgressBar.arc".equals(k)) {
+            return Integer.valueOf(4);
+        }
+        if ("Button.arc".equals(k)) {
+            return Integer.valueOf(6);
+        }
+        if ("TextComponent.arc".equals(k) || "Component.innerFocusWidth".equals(k)) {
+            return Integer.valueOf(0);
+        }
+        if ("Component.focusWidth".equals(k)) {
+            return Integer.valueOf(2);
+        }
+        if ("Component.borderWidth".equals(k)) {
+            return Integer.valueOf(1);
+        }
+        if ("Table.rowHeight".equals(k) || "Tree.rowHeight".equals(k) || "List.rowHeight".equals(k)) {
+            return Integer.valueOf(CellTheme.rowHeight(null, 20, 32));
+        }
+        if ("TabbedPane.tabHeight".equals(k)) {
+            return Integer.valueOf(CellTheme.touch() ? 40 : 32);
+        }
+        if ("SplitPane.dividerSize".equals(k)) {
+            return Integer.valueOf(CellTheme.touch() ? 10 : 5);
+        }
+        return null;
+    }
+
+    private static Object border(String owner) {
+        if ("TextField".equals(owner) || "FormattedTextField".equals(owner) || "PasswordField".equals(owner)
+                || "ComboBox".equals(owner) || "Spinner".equals(owner)) {
+            return new LafBorder(2, 6, 2, 6);
+        }
+        if ("Button".equals(owner) || "ToggleButton".equals(owner)) {
+            return new LafBorder(2, 14, 2, 14);
+        }
+        if ("ScrollPane".equals(owner) || "TitledBorder".equals(owner)
+                || "PopupMenu".equals(owner) || "ToolTip".equals(owner) || "Table".equals(owner)
+                || "TableHeader.cell".equals(owner)) {
+            return new LafBorder(0, 0, 0, 0);
+        }
+        return null;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Launcher.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Launcher.java
new file mode 100644
index 00000000000..3e0f972d432
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Launcher.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.ui.Display;
+
+/// Hands a URL to the device to open in whatever application handles it:
+/// a browser for `http`, the mail application for `mailto`, a viewer for a
+/// file.
+public final class Launcher {
+
+    /// What opens a URL.
+    public interface Opener {
+        void open(String url);
+    }
+
+    private static Opener opener;
+
+    private Launcher() {
+    }
+
+    /// Replaces what opens a URL, for a test that must not start another
+    /// application; `null` puts the device's back.
+    public static void setOpener(Opener o) {
+        opener = o;
+    }
+
+    public static void open(String url) {
+        Opener o = opener;
+        if (o != null) {
+            o.open(url);
+        } else if (Display.isInitialized()) {
+            Display.getInstance().execute(url);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LayoutBridge.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LayoutBridge.java
new file mode 100644
index 00000000000..fcfb272814b
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/LayoutBridge.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.Layout;
+
+/// The Codename One layout of a container peer: it runs the AWT layout,
+/// which places the child peers as it sets the children's bounds.
+///
+/// Only the root of a peer tree takes its size from Codename One; below
+/// it the AWT bounds are the truth and the peers follow.
+public final class LayoutBridge extends Layout {
+
+    private final Container owner;
+
+    public LayoutBridge(Container owner) {
+        this.owner = owner;
+    }
+
+    @Override
+    public void layoutContainer(com.codename1.ui.Container parent) {
+        if (!(parent.getParent() instanceof ContainerPeer)) {
+            owner.cn1PeerResized(Units.toLogical(parent.getWidth()), Units.toLogical(parent.getHeight()));
+        }
+        owner.validate();
+    }
+
+    @Override
+    public Dimension getPreferredSize(com.codename1.ui.Container parent) {
+        com.codename1.desktopcompat.java.awt.Dimension d = owner.getPreferredSize();
+        float s = Units.scale();
+        return new Dimension((int) Math.ceil(d.width * s), (int) Math.ceil(d.height * s));
+    }
+
+    @Override
+    public boolean isOverlapSupported() {
+        return true;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof LayoutBridge && ((LayoutBridge) o).owner == owner;
+    }
+
+    @Override
+    public int hashCode() {
+        return System.identityHashCode(owner);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ListEnumeration.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ListEnumeration.java
new file mode 100644
index 00000000000..94751606c3a
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ListEnumeration.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/// The elements of a list as the `Enumeration` the older JDK interfaces
+/// answer, in the list's order or from its end to its start. The elements
+/// are copied when it is made, so a list that changes afterwards does not
+/// disturb a walk already under way.
+public final class ListEnumeration<T> implements Enumeration<T> {
+
+    private final ArrayList<T> list;
+    private final boolean backwards;
+    private int done;
+
+    public ListEnumeration(List<? extends T> list, boolean backwards) {
+        this.list = new ArrayList<T>(list);
+        this.backwards = backwards;
+    }
+
+    @Override
+    public boolean hasMoreElements() {
+        return done < list.size();
+    }
+
+    @Override
+    public T nextElement() {
+        if (done >= list.size()) {
+            throw new NoSuchElementException("No more elements");
+        }
+        int at = backwards ? list.size() - 1 - done : done;
+        done++;
+        return list.get(at);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MenuBridge.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MenuBridge.java
new file mode 100644
index 00000000000..ea47697c545
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MenuBridge.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.javax.swing.JCheckBoxMenuItem;
+import com.codename1.desktopcompat.javax.swing.JMenu;
+import com.codename1.desktopcompat.javax.swing.JMenuBar;
+import com.codename1.desktopcompat.javax.swing.JMenuItem;
+import com.codename1.desktopcompat.javax.swing.JPopupMenu;
+import com.codename1.desktopcompat.javax.swing.JRadioButtonMenuItem;
+import com.codename1.desktopcompat.javax.swing.JRootPane;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+import com.codename1.desktopcompat.javax.swing.RootPaneContainer;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.ui.Command;
+import com.codename1.ui.events.ActionEvent;
+import java.util.ArrayList;
+import java.util.List;
+
+/// Shows the menu bar of a window as Codename One commands.
+///
+/// One mapping serves both form factors, because Codename One already
+/// has one model for both. Every visible item of every menu, however deep,
+/// becomes one command:
+///
+/// - Its name is the item's text; an item of a submenu is prefixed with
+///   the submenu's text and `" > "`; a selected check box or radio button
+///   item is prefixed with a check mark.
+/// - Its icon and enabled state are the item's, and stay so: any change to
+///   the menu bar rebuilds the commands.
+/// - Its desktop menu is the text of the top level menu it is under, so on
+///   a port with a native menu bar the commands appear under `File`,
+///   `Edit` and so on. An accelerator of a letter or a digit with the
+///   control or the meta key becomes the command's desktop shortcut with
+///   the platform's primary modifier.
+/// - Choosing the command chooses the item.
+///
+/// The host puts the commands in the overflow menu of the form's toolbar,
+/// from where Codename One publishes them to the native menu bar where
+/// there is one; on a phone the overflow menu is where the user finds
+/// them, as a flat list. Separators have no counterpart and are dropped.
+public final class MenuBridge {
+
+    private static final String CHECK = String.valueOf((char) 0x2713) + " ";
+
+    private MenuBridge() {
+    }
+
+    private static JMenuBar barOf(Window w) {
+        if (w instanceof RootPaneContainer) {
+            JRootPane root = ((RootPaneContainer) w).getRootPane();
+            return root == null ? null : root.getJMenuBar();
+        }
+        return null;
+    }
+
+    /// A window was put on the screen: its host gets its menu bar.
+    public static void windowShown(Window w) {
+        JMenuBar bar = barOf(w);
+        if (bar != null) {
+            sync(w, bar);
+            bar.revalidate();
+        }
+    }
+
+    /// The menu bar of a root pane was set or removed.
+    public static void barChanged(JRootPane root) {
+        Window w = SwingUtilities.getWindowAncestor(root);
+        WindowHost h = w == null ? null : w.cn1Host();
+        if (h != null && h.takesCommands()) {
+            JMenuBar bar = root.getJMenuBar();
+            h.commands(bar == null ? new ArrayList<Command>() : commands(bar));
+        }
+    }
+
+    /// A menu bar, a menu, a popup menu or an item changed: the commands
+    /// of the menu bar it belongs to, if any, are rebuilt.
+    public static void changed(Component c) {
+        JMenuBar found = null;
+        for (Component k = c; k != null && found == null;
+                k = k instanceof JPopupMenu ? ((JPopupMenu) k).getInvoker() : k.getParent()) {
+            if (k instanceof JMenuBar) {
+                found = (JMenuBar) k;
+            }
+        }
+        if (found != null) {
+            JMenuBar bar = found;
+            Window w = SwingUtilities.getWindowAncestor(bar);
+            if (w != null && barOf(w) == bar) {
+                sync(w, bar);
+            }
+        }
+    }
+
+    private static void sync(Window w, JMenuBar bar) {
+        WindowHost h = w.cn1Host();
+        if (h != null && h.takesCommands()) {
+            h.commands(commands(bar));
+        }
+    }
+
+    /// The commands that stand for a menu bar.
+    public static List<Command> commands(JMenuBar bar) {
+        ArrayList<Command> out = new ArrayList<Command>();
+        for (int i = 0; i < bar.getMenuCount(); i++) {
+            JMenu m = bar.getMenu(i);
+            if (m != null && m.isVisible()) {
+                String title = m.getText() == null ? "" : m.getText();
+                collect(m, title, "", out);
+            }
+        }
+        return out;
+    }
+
+    private static void collect(JMenu menu, String top, String prefix, ArrayList<Command> out) {
+        Component[] cs = menu.getMenuComponents();
+        for (int i = 0; i < cs.length; i++) {
+            Component c = cs[i];
+            if (!(c instanceof JMenuItem) || !isVisible((JMenuItem) c)) {
+                continue;
+            }
+            if (c instanceof JMenu) {
+                JMenu sub = (JMenu) c;
+                collect(sub, top, prefix + (sub.getText() == null ? "" : sub.getText()) + " > ", out);
+            } else {
+                out.add(command((JMenuItem) c, top, prefix));
+            }
+        }
+    }
+
+    /// The visibility an item was given; `isVisible()` of a component in
+    /// a closed popup says the same.
+    private static boolean isVisible(JMenuItem item) {
+        return item.isVisible();
+    }
+
+    private static Command command(final JMenuItem item, String top, String prefix) {
+        String text = item.getText() == null ? "" : item.getText();
+        boolean mark = (item instanceof JCheckBoxMenuItem || item instanceof JRadioButtonMenuItem)
+                && item.isSelected();
+        Command cmd = new Command((mark ? CHECK : "") + prefix + text, Icons.toNative(item.getIcon(), item)) {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                item.cn1Choose();
+            }
+        };
+        cmd.setEnabled(item.isEnabled());
+        cmd.setDesktopMenu(top);
+        cmd.putClientProperty("desktopcompat.item", item);
+        KeyStroke ks = item.getAccelerator();
+        if (ks != null) {
+            int code = ks.getKeyCode();
+            int m = ks.getModifiers();
+            boolean primary = (m & (InputEvent.CTRL_DOWN_MASK | InputEvent.META_DOWN_MASK | InputEvent.CTRL_MASK
+                    | InputEvent.META_MASK)) != 0;
+            if (primary && ((code >= 'A' && code <= 'Z') || (code >= '0' && code <= '9'))) {
+                int mods = Command.DESKTOP_SHORTCUT_MODIFIER_PRIMARY;
+                if ((m & (InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK)) != 0) {
+                    mods |= Command.DESKTOP_SHORTCUT_MODIFIER_SHIFT;
+                }
+                if ((m & (InputEvent.ALT_DOWN_MASK | InputEvent.ALT_MASK)) != 0) {
+                    mods |= Command.DESKTOP_SHORTCUT_MODIFIER_ALT;
+                }
+                cmd.setDesktopShortcut((char) code, mods);
+            }
+        }
+        return cmd;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MenuItemPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MenuItemPeer.java
new file mode 100644
index 00000000000..fec68e53cac
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MenuItemPeer.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// The peer of a menu item drawn in a window: a Codename One button with
+/// the look of a command instead of a framed button.
+public class MenuItemPeer extends ButtonPeer {
+
+    public MenuItemPeer(Component owner) {
+        super(owner);
+        setUIID("Command");
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MiniHtml.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MiniHtml.java
new file mode 100644
index 00000000000..785e52629c3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/MiniHtml.java
@@ -0,0 +1,1149 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import java.util.ArrayList;
+
+/// The small part of HTML that Swing applications put in labels, buttons,
+/// tab titles and tool tips.
+///
+/// A text is HTML when it starts with `<html>`, in any case. [#parse]
+/// turns it into lines of styled runs, [#preferredSize] measures them and
+/// [#paint] draws them, so a component needs three calls to show it.
+///
+/// Understood: `<b>` `<strong>` `<i>` `<em>` `<u>` `<br>` `<p>` `<div>`
+/// `<center>` `<font color= size=>` `<big>` `<small>` `<h1>` to `<h6>`
+/// `<li>`, `<img src= width= height=>` where the caller says how a source
+/// is found, the `align` attribute and a `color` in a `style` attribute, and
+/// the entities `&amp;` `&lt;` `&gt;` `&nbsp;` `&quot;` `&apos;`, the
+/// common named ones (`&plusmn;`, `&copy;`, `&hellip;`, `&rarr;` ...) and
+/// the numeric ones. Every other tag is dropped and its content kept, except
+/// `<head>`, `<style>`, `<script>` and `<title>`, whose content goes too.
+/// Malformed input never throws: what cannot be read as a tag is text.
+///
+/// An image stands on the baseline of its line like a word and is never
+/// broken; the attribute `align` does not float it to a side.
+///
+/// Not supported: tables, lists beyond a dash per item, style sheets and
+/// font faces.
+public final class MiniHtml {
+
+    /// The alignment of a line that asked for none.
+    public static final int ALIGN_DEFAULT = -1;
+    /// Values of [Line#alignment()] and of the `alignment` of [#paint];
+    /// the same numbers as the Swing constants `LEFT`, `CENTER`, `RIGHT`.
+    public static final int ALIGN_LEFT = 2;
+    public static final int ALIGN_CENTER = 0;
+    public static final int ALIGN_RIGHT = 4;
+    private static final int ALIGN_TRAILING = 11;
+
+    private static final float[] FONT_SIZES = {0.6f, 0.8f, 1f, 1.15f, 1.5f, 2f, 3f};
+    private static final float[] HEADING_SIZES = {2f, 1.5f, 1.17f, 1f, 0.83f, 0.67f};
+
+    private static final String[] COLOR_NAMES = {
+        "black", "white", "red", "green", "blue", "yellow", "gray", "grey", "silver", "maroon", "navy", "purple",
+        "teal", "olive", "lime", "aqua", "cyan", "fuchsia", "magenta", "orange", "pink", "darkgray", "darkgrey",
+        "lightgray", "lightgrey", "brown"
+    };
+    private static final int[] COLOR_VALUES = {
+        0x000000, 0xffffff, 0xff0000, 0x008000, 0x0000ff, 0xffff00, 0x808080, 0x808080, 0xc0c0c0, 0x800000,
+        0x000080, 0x800080, 0x008080, 0x808000, 0x00ff00, 0x00ffff, 0x00ffff, 0xff00ff, 0xff00ff, 0xffa500,
+        0xffc0cb, 0xa9a9a9, 0xa9a9a9, 0xd3d3d3, 0xd3d3d3, 0xa52a2a
+    };
+
+    private static final Color LINK = new Color(0x0000ee);
+
+    private MiniHtml() {
+    }
+
+    // ------------------------------------------------------------ model
+
+    /// Finds the picture an `<img>` names. A text parsed without one has
+    /// its images dropped.
+    public interface ImageSource {
+        /// The image for what `src` says, or `null` when there is none.
+        com.codename1.desktopcompat.java.awt.Image image(String src);
+    }
+
+    /// A stretch of text in one style.
+    public static final class Run {
+        private final String text;
+        private final boolean bold;
+        private final boolean italic;
+        private final boolean underline;
+        private final Color color;
+        private final float scale;
+        private final String href;
+        private com.codename1.desktopcompat.java.awt.Image image;
+        private int imageWidth;
+        private int imageHeight;
+
+        Run(String text, boolean bold, boolean italic, boolean underline, Color color, float scale) {
+            this(text, bold, italic, underline, color, scale, null);
+        }
+
+        Run(String text, boolean bold, boolean italic, boolean underline, Color color, float scale, String href) {
+            this.text = text;
+            this.bold = bold;
+            this.italic = italic;
+            this.underline = underline;
+            this.color = color;
+            this.scale = scale;
+            this.href = href;
+        }
+
+        /// What the `href` of the link this text is in says, or `null`
+        /// for text that is not in a link.
+        public String href() {
+            return href;
+        }
+
+        public String text() {
+            return text;
+        }
+
+        public boolean bold() {
+            return bold;
+        }
+
+        public boolean italic() {
+            return italic;
+        }
+
+        public boolean underline() {
+            return underline;
+        }
+
+        /// The color the text asked for, or `null` for the component's.
+        public Color color() {
+            return color;
+        }
+
+        /// The font size as a multiple of the component's.
+        public float scale() {
+            return scale;
+        }
+
+        Run withText(String t) {
+            return new Run(t, bold, italic, underline, color, scale, href);
+        }
+
+        /// The picture of an `<img>`, or `null` for text.
+        public com.codename1.desktopcompat.java.awt.Image image() {
+            return image;
+        }
+
+        /// The width an image is drawn at, in logical pixels.
+        public int imageWidth() {
+            return imageWidth;
+        }
+
+        /// The height an image is drawn at, in logical pixels.
+        public int imageHeight() {
+            return imageHeight;
+        }
+
+        int width(Font base) {
+            return image != null ? imageWidth : Fonts.metrics(font(base)).stringWidth(text);
+        }
+
+        boolean sameStyle(Run o) {
+            return image == null && o.image == null && bold == o.bold && italic == o.italic && underline == o.underline && Float.compare(scale, o.scale) == 0
+                    && (color == null ? o.color == null : color.equals(o.color))
+                    && (href == null ? o.href == null : href.equals(o.href));
+        }
+
+        Font font(Font base) {
+            int style = base.getStyle() | (bold ? Font.BOLD : 0) | (italic ? Font.ITALIC : 0);
+            if (style == base.getStyle() && Float.compare(scale, 1f) == 0) {
+                return base;
+            }
+            return base.deriveFont(style, base.getSize2D() * scale);
+        }
+    }
+
+    /// One line: runs side by side.
+    public static final class Line {
+        private final ArrayList<Run> runs = new ArrayList<Run>();
+        private int alignment = ALIGN_DEFAULT;
+        private boolean gapBefore;
+
+        Line() {
+        }
+
+        public int runCount() {
+            return runs.size();
+        }
+
+        public Run run(int index) {
+            return runs.get(index);
+        }
+
+        /// [#ALIGN_LEFT], [#ALIGN_CENTER], [#ALIGN_RIGHT] or
+        /// [#ALIGN_DEFAULT].
+        public int alignment() {
+            return alignment;
+        }
+
+        /// Whether the line starts a paragraph and is set off from the
+        /// line above it.
+        public boolean gapBefore() {
+            return gapBefore;
+        }
+
+        /// The text of the line without its styles.
+        public String text() {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < runs.size(); i++) {
+                sb.append(runs.get(i).text);
+            }
+            return sb.toString();
+        }
+
+        void add(Run r) {
+            if (!runs.isEmpty()) {
+                Run last = runs.get(runs.size() - 1);
+                if (last.sameStyle(r)) {
+                    runs.set(runs.size() - 1, last.withText(last.text + r.text));
+                    return;
+                }
+            }
+            runs.add(r);
+        }
+    }
+
+    /// A parsed text: lines from top to bottom.
+    public static final class Document {
+        private final ArrayList<Line> lines = new ArrayList<Line>();
+
+        Document() {
+        }
+
+        public int lineCount() {
+            return lines.size();
+        }
+
+        public Line line(int index) {
+            return lines.get(index);
+        }
+    }
+
+    // ------------------------------------------------------------ parsing
+
+    /// Whether Swing would read `s` as HTML: it starts with `<html>`.
+    public static boolean isHtml(String s) {
+        return s != null && s.length() >= 6 && s.regionMatches(true, 0, "<html>", 0, 6);
+    }
+
+    /// The text of `s` without its tags, lines separated by a line feed;
+    /// `s` itself when it is not HTML.
+    public static String plainText(String s) {
+        if (!isHtml(s)) {
+            return s;
+        }
+        Document d = parse(s);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < d.lineCount(); i++) {
+            if (i > 0) {
+                sb.append('\n');
+            }
+            sb.append(d.line(i).text());
+        }
+        return sb.toString();
+    }
+
+    /// As [#plainText] on one line: what a widget that shows a single
+    /// line of text gets.
+    public static String singleLine(String s) {
+        String t = plainText(s);
+        return t == null ? null : t.replace('\n', ' ');
+    }
+
+    /// The style in force at one point of the text.
+    private static final class State {
+        String tag;
+        boolean bold;
+        boolean italic;
+        boolean underline;
+        Color color;
+        float scale = 1f;
+        int align = ALIGN_DEFAULT;
+        String href;
+
+        State copy(String forTag) {
+            State s = new State();
+            s.tag = forTag;
+            s.bold = bold;
+            s.italic = italic;
+            s.underline = underline;
+            s.color = color;
+            s.scale = scale;
+            s.align = align;
+            s.href = href;
+            return s;
+        }
+    }
+
+    /// Builds the lines as the text is read.
+    private static final class Builder {
+        final Document doc = new Document();
+        final ArrayList<State> stack = new ArrayList<State>();
+        final StringBuilder text = new StringBuilder();
+        ImageSource images;
+        Line line = new Line();
+        boolean pendingGap;
+        boolean spacePending;
+
+        Builder() {
+            stack.add(new State());
+        }
+
+        State top() {
+            return stack.get(stack.size() - 1);
+        }
+
+        void flush() {
+            if (spacePending && lineHasText()) {
+                // The space belongs to the style it was written in.
+                text.append(' ');
+                spacePending = false;
+            }
+            if (text.length() > 0) {
+                State s = top();
+                if (line.runs.isEmpty()) {
+                    line.alignment = s.align;
+                }
+                line.add(new Run(text.toString(), s.bold, s.italic, s.underline, s.color, s.scale, s.href));
+                text.setLength(0);
+            }
+        }
+
+        /// Puts an image where the text is, as a word of its own.
+        void image(com.codename1.desktopcompat.java.awt.Image img, int w, int h) {
+            flush();
+            State s = top();
+            if (line.runs.isEmpty()) {
+                line.alignment = s.align;
+            }
+            Run r = new Run("", false, false, false, s.color, s.scale, s.href);
+            r.image = img;
+            r.imageWidth = w;
+            r.imageHeight = h;
+            line.runs.add(r);
+        }
+
+        boolean lineHasText() {
+            return text.length() > 0 || !line.runs.isEmpty();
+        }
+
+        void character(char c, boolean collapsible) {
+            if (collapsible && (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f')) {
+                if (lineHasText()) {
+                    spacePending = true;
+                }
+                return;
+            }
+            if (spacePending) {
+                text.append(' ');
+                spacePending = false;
+            }
+            text.append(c);
+        }
+
+        void endLine() {
+            spacePending = false;
+            flush();
+            if (pendingGap && !doc.lines.isEmpty()) {
+                line.gapBefore = true;
+            }
+            pendingGap = false;
+            doc.lines.add(line);
+            line = new Line();
+        }
+
+        /// The start or end of a block: ends the line if it has anything.
+        void block(boolean gap) {
+            if (lineHasText()) {
+                endLine();
+            }
+            if (gap) {
+                pendingGap = true;
+            }
+        }
+
+        void lineBreak() {
+            endLine();
+        }
+
+        void open(State s) {
+            flush();
+            stack.add(s);
+        }
+
+        void close(String tag) {
+            for (int i = stack.size() - 1; i > 0; i--) {
+                if (tag.equals(stack.get(i).tag)) {
+                    flush();
+                    while (stack.size() > i) {
+                        stack.remove(stack.size() - 1);
+                    }
+                    return;
+                }
+            }
+        }
+
+        Document finish() {
+            if (lineHasText()) {
+                endLine();
+            }
+            return doc;
+        }
+    }
+
+    /// Reads `html` into lines of runs. A text that is not HTML is read
+    /// the same way, so its tags, if it has any, are honoured too.
+    public static Document parse(String html) {
+        return parse(html, null);
+    }
+
+    /// Reads `html` as [#parse(String)] does, with the pictures of its
+    /// `<img>` tags found by `images`.
+    public static Document parse(String html, ImageSource images) {
+        Builder b = new Builder();
+        b.images = images;
+        if (html == null) {
+            return b.doc;
+        }
+        int n = html.length();
+        int i = 0;
+        while (i < n) {
+            char c = html.charAt(i);
+            if (c == '<') {
+                int next = tag(html, i, b);
+                if (next > i) {
+                    i = next;
+                    continue;
+                }
+                b.character(c, false);
+                i++;
+            } else if (c == '&') {
+                i = entity(html, i, b);
+            } else {
+                b.character(c, true);
+                i++;
+            }
+        }
+        return b.finish();
+    }
+
+    private static boolean letter(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+    }
+
+    private static String asciiLower(String s) {
+        StringBuilder sb = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                if (sb == null) {
+                    sb = new StringBuilder(s);
+                }
+                sb.setCharAt(i, (char) (c + ('a' - 'A')));
+            }
+        }
+        return sb == null ? s : sb.toString();
+    }
+
+    private static int indexOfIgnoreCase(String s, String what, int from) {
+        int last = s.length() - what.length();
+        for (int i = Math.max(0, from); i <= last; i++) {
+            if (s.regionMatches(true, i, what, 0, what.length())) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /// Reads the entity at `at` and answers the index after it; an
+    /// ampersand that starts none is text.
+    private static int entity(String s, int at, Builder b) {
+        int end = -1;
+        int limit = Math.min(s.length(), at + 12);
+        for (int i = at + 1; i < limit; i++) {
+            char c = s.charAt(i);
+            if (c == ';') {
+                end = i;
+                break;
+            }
+            if (!(letter(c) || (c >= '0' && c <= '9') || c == '#')) {
+                break;
+            }
+        }
+        if (end > at + 1) {
+            String name = s.substring(at + 1, end);
+            if ("nbsp".equals(name)) {
+                b.character(' ', false);
+                return end + 1;
+            }
+            int ch = -1;
+            if ("amp".equals(name)) {
+                ch = '&';
+            } else if ("lt".equals(name)) {
+                ch = '<';
+            } else if ("gt".equals(name)) {
+                ch = '>';
+            } else if ("quot".equals(name)) {
+                ch = '"';
+            } else if ("apos".equals(name)) {
+                ch = '\'';
+            } else if (name.charAt(0) != '#') {
+                ch = namedEntity(name);
+            } else if (name.length() > 1) {
+                try {
+                    if (name.charAt(1) == 'x' || name.charAt(1) == 'X') {
+                        ch = name.length() > 2 ? Integer.parseInt(name.substring(2), 16) : -1;
+                    } else {
+                        ch = Integer.parseInt(name.substring(1));
+                    }
+                } catch (NumberFormatException e) {
+                    ch = -1;
+                }
+                if (ch == 160) {
+                    b.character(' ', false);
+                    return end + 1;
+                }
+                if (ch <= 0 || ch > 0xffff) {
+                    ch = -1;
+                }
+            }
+            if (ch >= 0) {
+                b.character((char) ch, ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r');
+                return end + 1;
+            }
+        }
+        b.character('&', false);
+        return at + 1;
+    }
+
+    /// The character of a named entity beyond the five of XML, or -1: the
+    /// ones text in a label is written with.
+    private static int namedEntity(String name) {
+        for (int i = 0; i < ENTITY_NAMES.length; i++) {
+            if (ENTITY_NAMES[i].equals(name)) {
+                return ENTITY_CHARS[i];
+            }
+        }
+        return -1;
+    }
+
+    private static final String[] ENTITY_NAMES = {
+        "plusmn", "copy", "reg", "deg", "middot", "laquo", "raquo", "times", "divide", "sect", "para", "micro",
+        "frac12", "frac14", "frac34", "sup2", "sup3", "cent", "pound", "yen", "euro", "trade", "hellip", "mdash",
+        "ndash", "bull", "lsquo", "rsquo", "ldquo", "rdquo", "larr", "uarr", "rarr", "darr", "harr", "le", "ge",
+        "ne", "infin", "minus", "check", "cross", "iexcl", "iquest", "szlig", "dagger"
+    };
+
+    private static final int[] ENTITY_CHARS = {
+        177, 169, 174, 176, 183, 171, 187, 215, 247, 167, 182, 181,
+        189, 188, 190, 178, 179, 162, 163, 165, 8364, 8482, 8230, 8212,
+        8211, 8226, 8216, 8217, 8220, 8221, 8592, 8593, 8594, 8595, 8596, 8804, 8805,
+        8800, 8734, 8722, 10003, 10007, 161, 191, 223, 8224
+    };
+
+    /// Reads the tag at `at` and answers the index after it, or `at`
+    /// when what is there is not a tag.
+    private static int tag(String s, int at, Builder b) {
+        int n = s.length();
+        if (s.startsWith("<!--", at)) {
+            int end = s.indexOf("-->", at + 4);
+            return end < 0 ? n : end + 3;
+        }
+        int p = at + 1;
+        boolean closing = false;
+        if (p < n && s.charAt(p) == '/') {
+            closing = true;
+            p++;
+        }
+        if (p < n && s.charAt(p) == '!') {
+            int end = s.indexOf('>', p);
+            return end < 0 ? at : end + 1;
+        }
+        if (p >= n || !letter(s.charAt(p))) {
+            return at;
+        }
+        int end = s.indexOf('>', p);
+        if (end < 0) {
+            return at;
+        }
+        int nameEnd = p;
+        while (nameEnd < end && (letter(s.charAt(nameEnd)) || (s.charAt(nameEnd) >= '0' && s.charAt(nameEnd) <= '9'))) {
+            nameEnd++;
+        }
+        String name = asciiLower(s.substring(p, nameEnd));
+        String attrs = s.substring(nameEnd, end);
+        int after = end + 1;
+        if (closing) {
+            closeTag(name, b);
+            return after;
+        }
+        if ("head".equals(name) || "style".equals(name) || "script".equals(name) || "title".equals(name)) {
+            int close = indexOfIgnoreCase(s, "</" + name, after);
+            if (close < 0) {
+                return n;
+            }
+            int gt = s.indexOf('>', close);
+            return gt < 0 ? n : gt + 1;
+        }
+        openTag(name, attrs, b);
+        return after;
+    }
+
+    private static int headingLevel(String name) {
+        if (name.length() == 2 && name.charAt(0) == 'h' && name.charAt(1) >= '1' && name.charAt(1) <= '6') {
+            return name.charAt(1) - '0';
+        }
+        return 0;
+    }
+
+    private static void openTag(String name, String attrs, Builder b) {
+        if ("br".equals(name)) {
+            b.lineBreak();
+            return;
+        }
+        if ("html".equals(name) || "body".equals(name)) {
+            return;
+        }
+        if ("img".equals(name)) {
+            image(attrs, b);
+            return;
+        }
+        State s = b.top().copy(name);
+        int heading = headingLevel(name);
+        if ("b".equals(name) || "strong".equals(name)) {
+            s.bold = true;
+        } else if ("i".equals(name) || "em".equals(name)) {
+            s.italic = true;
+        } else if ("u".equals(name)) {
+            s.underline = true;
+        } else if ("a".equals(name)) {
+            String href = attribute(attrs, "href");
+            if (href != null) {
+                // A link looks like one, as it does on the desktop.
+                s.href = href;
+                s.underline = true;
+                s.color = LINK;
+            }
+        } else if ("big".equals(name)) {
+            s.scale *= 1.2f;
+        } else if ("small".equals(name)) {
+            s.scale *= 0.85f;
+        } else if ("font".equals(name)) {
+            Color c = color(attribute(attrs, "color"));
+            if (c != null) {
+                s.color = c;
+            }
+            s.scale = fontSize(attribute(attrs, "size"), s.scale);
+        } else if ("center".equals(name)) {
+            b.block(false);
+            s.align = ALIGN_CENTER;
+        } else if ("p".equals(name)) {
+            b.block(true);
+        } else if ("div".equals(name) || "tr".equals(name) || "ul".equals(name) || "ol".equals(name)) {
+            b.block(false);
+        } else if ("li".equals(name)) {
+            b.block(false);
+        } else if (heading > 0) {
+            b.block(true);
+            s.bold = true;
+            s.scale = HEADING_SIZES[heading - 1];
+        }
+        String align = attribute(attrs, "align");
+        if (align != null) {
+            if ("center".equalsIgnoreCase(align)) {
+                s.align = ALIGN_CENTER;
+            } else if ("right".equalsIgnoreCase(align)) {
+                s.align = ALIGN_RIGHT;
+            } else if ("left".equalsIgnoreCase(align)) {
+                s.align = ALIGN_LEFT;
+            }
+        }
+        String style = attribute(attrs, "style");
+        if (style != null) {
+            Color c = color(styleProperty(style, "color"));
+            if (c != null) {
+                s.color = c;
+            }
+        }
+        b.open(s);
+        if ("li".equals(name)) {
+            b.character('-', false);
+            b.character(' ', false);
+        }
+    }
+
+    /// An `<img>`: the picture its source names, at the size the tag
+    /// gives or else its own. A picture that is not found leaves nothing.
+    private static void image(String attrs, Builder b) {
+        String src = attribute(attrs, "src");
+        if (src == null || b.images == null) {
+            return;
+        }
+        com.codename1.desktopcompat.java.awt.Image img = b.images.image(src);
+        if (img == null) {
+            return;
+        }
+        int w = pixels(attribute(attrs, "width"));
+        int h = pixels(attribute(attrs, "height"));
+        int ownW = img.getWidth(null);
+        int ownH = img.getHeight(null);
+        if (w <= 0 && h <= 0) {
+            w = ownW;
+            h = ownH;
+        } else if (w <= 0) {
+            w = ownH > 0 ? (int) ((long) ownW * h / ownH) : h;
+        } else if (h <= 0) {
+            h = ownW > 0 ? (int) ((long) ownH * w / ownW) : w;
+        }
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        b.image(img, w, h);
+    }
+
+    /// A length in pixels as an attribute writes it, or 0 for none and
+    /// for one that is not a plain number, such as a percentage.
+    private static int pixels(String value) {
+        if (value == null) {
+            return 0;
+        }
+        String v = value.trim();
+        int n = 0;
+        if (v.length() == 0 || v.length() > 6) {
+            return 0;
+        }
+        for (int i = 0; i < v.length(); i++) {
+            char c = v.charAt(i);
+            if (c < '0' || c > '9') {
+                return 0;
+            }
+            n = n * 10 + (c - '0');
+        }
+        return n;
+    }
+
+    private static void closeTag(String name, Builder b) {
+        if ("html".equals(name) || "body".equals(name) || "br".equals(name)) {
+            return;
+        }
+        boolean heading = headingLevel(name) > 0;
+        boolean para = "p".equals(name) || heading;
+        boolean block = para || "center".equals(name) || "div".equals(name) || "tr".equals(name)
+                || "ul".equals(name) || "ol".equals(name) || "li".equals(name);
+        if (block) {
+            b.block(false);
+        }
+        b.close(name);
+        if (para) {
+            b.pendingGap = true;
+        }
+    }
+
+    /// The value of an attribute in the text between a tag's name and its
+    /// closing bracket, or `null`.
+    static String attribute(String attrs, String name) {
+        int n = attrs.length();
+        int i = 0;
+        while (i < n) {
+            while (i < n && !letter(attrs.charAt(i))) {
+                i++;
+            }
+            int start = i;
+            while (i < n && (letter(attrs.charAt(i)) || attrs.charAt(i) == '-')) {
+                i++;
+            }
+            if (i == start) {
+                break;
+            }
+            boolean match = i - start == name.length() && attrs.regionMatches(true, start, name, 0, name.length());
+            while (i < n && attrs.charAt(i) == ' ') {
+                i++;
+            }
+            if (i >= n || attrs.charAt(i) != '=') {
+                if (match) {
+                    return "";
+                }
+                continue;
+            }
+            i++;
+            while (i < n && attrs.charAt(i) == ' ') {
+                i++;
+            }
+            String value;
+            if (i < n && (attrs.charAt(i) == '"' || attrs.charAt(i) == '\'')) {
+                char q = attrs.charAt(i);
+                int close = attrs.indexOf(q, i + 1);
+                if (close < 0) {
+                    close = n;
+                }
+                value = attrs.substring(i + 1, close);
+                i = Math.min(n, close + 1);
+            } else {
+                int vs = i;
+                while (i < n && attrs.charAt(i) != ' ' && attrs.charAt(i) != '\t' && attrs.charAt(i) != '\n') {
+                    i++;
+                }
+                value = attrs.substring(vs, i);
+            }
+            if (match) {
+                return value.trim();
+            }
+        }
+        return null;
+    }
+
+    private static String styleProperty(String style, String name) {
+        int from = 0;
+        while (from < style.length()) {
+            int semi = style.indexOf(';', from);
+            if (semi < 0) {
+                semi = style.length();
+            }
+            int colon = style.indexOf(':', from);
+            if (colon > from && colon < semi && style.substring(from, colon).trim().equalsIgnoreCase(name)) {
+                return style.substring(colon + 1, semi).trim();
+            }
+            from = semi + 1;
+        }
+        return null;
+    }
+
+    private static float fontSize(String size, float current) {
+        if (size == null || size.length() == 0) {
+            return current;
+        }
+        try {
+            int index;
+            char first = size.charAt(0);
+            if (first == '+') {
+                index = 3 + Integer.parseInt(size.substring(1).trim());
+            } else if (first == '-') {
+                index = 3 - Integer.parseInt(size.substring(1).trim());
+            } else {
+                index = Integer.parseInt(size.trim());
+            }
+            index = Math.max(1, Math.min(FONT_SIZES.length, index));
+            return FONT_SIZES[index - 1];
+        } catch (NumberFormatException e) {
+            return current;
+        }
+    }
+
+    /// The color an attribute value names: `#rrggbb`, `#rgb`, a bare hex
+    /// number of six digits, `rgb(r, g, b)` or one of the HTML color
+    /// names. `null` when it names none.
+    public static Color color(String value) {
+        if (value == null) {
+            return null;
+        }
+        String v = asciiLower(value.trim());
+        if (v.length() == 0) {
+            return null;
+        }
+        for (int i = 0; i < COLOR_NAMES.length; i++) {
+            if (COLOR_NAMES[i].equals(v)) {
+                return new Color(COLOR_VALUES[i]);
+            }
+        }
+        try {
+            if (v.startsWith("rgb(") && v.endsWith(")")) {
+                String body = v.substring(4, v.length() - 1);
+                int c1 = body.indexOf(',');
+                int c2 = body.indexOf(',', c1 + 1);
+                if (c1 < 0 || c2 < 0) {
+                    return null;
+                }
+                int r = clamp(Integer.parseInt(body.substring(0, c1).trim()));
+                int g = clamp(Integer.parseInt(body.substring(c1 + 1, c2).trim()));
+                int bl = clamp(Integer.parseInt(body.substring(c2 + 1).trim()));
+                return new Color(r, g, bl);
+            }
+            String hex = v.charAt(0) == '#' ? v.substring(1) : v;
+            if (hex.length() == 3) {
+                int rgb = Integer.parseInt(hex, 16);
+                int r = (rgb >> 8) & 0xf;
+                int g = (rgb >> 4) & 0xf;
+                int bl = rgb & 0xf;
+                return new Color(r * 17, g * 17, bl * 17);
+            }
+            if (hex.length() == 6) {
+                return new Color(Integer.parseInt(hex, 16));
+            }
+        } catch (NumberFormatException e) {
+            return null;
+        }
+        return null;
+    }
+
+    private static int clamp(int v) {
+        return v < 0 ? 0 : v > 255 ? 255 : v;
+    }
+
+    // ------------------------------------------------------------ measuring
+
+    private static Font base(Font f) {
+        return f != null ? f : Fonts.defaultFont();
+    }
+
+    private static int lineWidth(Line l, Font base) {
+        int w = 0;
+        for (int i = 0; i < l.runs.size(); i++) {
+            w += l.runs.get(i).width(base);
+        }
+        return w;
+    }
+
+    /// The height of a line: its tallest text, and an image standing on
+    /// the baseline with the text's descent below it.
+    private static int lineHeight(Line l, Font base) {
+        int h = 0;
+        int descent = 0;
+        int image = 0;
+        for (int i = 0; i < l.runs.size(); i++) {
+            Run r = l.runs.get(i);
+            if (r.image != null) {
+                image = Math.max(image, r.imageHeight);
+                continue;
+            }
+            FontMetrics fm = Fonts.metrics(r.font(base));
+            h = Math.max(h, fm.getHeight());
+            descent = Math.max(descent, fm.getHeight() - fm.getAscent());
+        }
+        if (image > 0) {
+            return Math.max(h, image + descent);
+        }
+        return h > 0 ? h : Fonts.metrics(base).getHeight();
+    }
+
+    private static int lineAscent(Line l, Font base) {
+        int a = 0;
+        boolean any = false;
+        for (int i = 0; i < l.runs.size(); i++) {
+            Run r = l.runs.get(i);
+            any = true;
+            a = Math.max(a, r.image != null ? r.imageHeight : Fonts.metrics(r.font(base)).getAscent());
+        }
+        return any ? a : Fonts.metrics(base).getAscent();
+    }
+
+    private static int gap(Font base) {
+        return Fonts.metrics(base).getHeight() / 2;
+    }
+
+    /// The size the lines take in logical pixels when none is wrapped,
+    /// with `font` as the component's font.
+    public static Dimension preferredSize(Document doc, Font font) {
+        Font base = base(font);
+        int w = 0;
+        int h = 0;
+        for (int i = 0; i < doc.lines.size(); i++) {
+            Line l = doc.lines.get(i);
+            w = Math.max(w, lineWidth(l, base));
+            h += lineHeight(l, base);
+            if (l.gapBefore) {
+                h += gap(base);
+            }
+        }
+        return new Dimension(w, h);
+    }
+
+    /// The document with every line wider than `width` broken at spaces.
+    /// Answers `doc` itself when nothing has to be broken.
+    public static Document wrap(Document doc, Font font, int width) {
+        if (width <= 0) {
+            return doc;
+        }
+        Font base = base(font);
+        boolean needed = false;
+        for (int i = 0; i < doc.lines.size() && !needed; i++) {
+            needed = lineWidth(doc.lines.get(i), base) > width;
+        }
+        if (!needed) {
+            return doc;
+        }
+        Document out = new Document();
+        for (int i = 0; i < doc.lines.size(); i++) {
+            Line l = doc.lines.get(i);
+            if (lineWidth(l, base) <= width) {
+                out.lines.add(l);
+                continue;
+            }
+            Line cur = new Line();
+            cur.alignment = l.alignment;
+            cur.gapBefore = l.gapBefore;
+            int curWidth = 0;
+            for (int r = 0; r < l.runs.size(); r++) {
+                Run run = l.runs.get(r);
+                if (run.image != null) {
+                    // An image is one word.
+                    if (curWidth + run.imageWidth > width && !cur.runs.isEmpty()) {
+                        out.lines.add(cur);
+                        cur = new Line();
+                        cur.alignment = l.alignment;
+                        curWidth = 0;
+                    }
+                    cur.runs.add(run);
+                    curWidth += run.imageWidth;
+                    continue;
+                }
+                FontMetrics fm = Fonts.metrics(run.font(base));
+                String t = run.text;
+                int from = 0;
+                while (from < t.length()) {
+                    int sp = t.indexOf(' ', from);
+                    int to = sp < 0 ? t.length() : sp + 1;
+                    String chunk = t.substring(from, to);
+                    int visible = fm.stringWidth(sp < 0 ? chunk : t.substring(from, sp));
+                    if (curWidth + visible > width && !cur.runs.isEmpty()) {
+                        out.lines.add(cur);
+                        cur = new Line();
+                        cur.alignment = l.alignment;
+                        curWidth = 0;
+                    }
+                    cur.add(run.withText(chunk));
+                    curWidth += fm.stringWidth(chunk);
+                    from = to;
+                }
+            }
+            out.lines.add(cur);
+        }
+        return out;
+    }
+
+    /// The size the lines take when those wider than `width` are broken,
+    /// in logical pixels; a `width` of 0 or less breaks none.
+    public static Dimension wrappedSize(Document doc, Font font, int width) {
+        return preferredSize(wrap(doc, font, width), font);
+    }
+
+    /// The link at a point of a text that [#paint] drew with its top left
+    /// corner at the origin: the `href` of the run under `(px, py)`, or
+    /// `null` when there is no link there. `font`, `width` and
+    /// `alignment` are the ones the text was painted with.
+    public static String hrefAt(Document doc, Font font, int width, int alignment, int px, int py) {
+        Font base = base(font);
+        Document d = wrap(doc, base, width);
+        int top = 0;
+        for (int i = 0; i < d.lines.size(); i++) {
+            Line l = d.lines.get(i);
+            if (l.gapBefore) {
+                top += gap(base);
+            }
+            int height = lineHeight(l, base);
+            if (py >= top && py < top + height) {
+                int lx = lineStart(l, base, width, alignment);
+                for (int r = 0; r < l.runs.size(); r++) {
+                    Run run = l.runs.get(r);
+                    int rw = run.width(base);
+                    if (px >= lx && px < lx + rw) {
+                        return run.href;
+                    }
+                    lx += rw;
+                }
+                return null;
+            }
+            top += height;
+        }
+        return null;
+    }
+
+    /// Where a line starts, relative to the left edge of the text.
+    private static int lineStart(Line l, Font base, int width, int alignment) {
+        int align = l.alignment != ALIGN_DEFAULT ? l.alignment : alignment;
+        if (width > 0 && align != ALIGN_LEFT) {
+            int lw = lineWidth(l, base);
+            if (align == ALIGN_CENTER) {
+                return (width - lw) / 2;
+            } else if (align == ALIGN_RIGHT || align == ALIGN_TRAILING) {
+                return width - lw;
+            }
+        }
+        return 0;
+    }
+
+    // ------------------------------------------------------------ painting
+
+    /// Draws the lines with their top left corner at `(x, y)`, in the
+    /// font and color `g` has, which are the component's. A line that
+    /// names no alignment is placed in `width` by `alignment`; a line
+    /// wider than `width` is wrapped. A `width` of 0 or less neither
+    /// wraps nor aligns.
+    public static void paint(Graphics g, Document doc, int x, int y, int width, int alignment) {
+        Font base = base(g.getFont());
+        Color baseColor = g.getColor();
+        Document d = wrap(doc, base, width);
+        int top = y;
+        try {
+            for (int i = 0; i < d.lines.size(); i++) {
+                Line l = d.lines.get(i);
+                if (l.gapBefore) {
+                    top += gap(base);
+                }
+                int height = lineHeight(l, base);
+                int baseline = top + lineAscent(l, base);
+                int lx = x + lineStart(l, base, width, alignment);
+                for (int r = 0; r < l.runs.size(); r++) {
+                    Run run = l.runs.get(r);
+                    if (run.image != null) {
+                        g.drawImage(run.image, lx, baseline - run.imageHeight, run.imageWidth, run.imageHeight, null);
+                        lx += run.imageWidth;
+                        continue;
+                    }
+                    Font f = run.font(base);
+                    FontMetrics fm = Fonts.metrics(f);
+                    int rw = fm.stringWidth(run.text);
+                    g.setFont(f);
+                    Color c = run.color != null ? run.color : baseColor;
+                    if (c != null) {
+                        g.setColor(c);
+                    }
+                    g.drawString(run.text, lx, baseline);
+                    if (run.underline) {
+                        g.drawLine(lx, baseline + 1, lx + rw - 1, baseline + 1);
+                    }
+                    lx += rw;
+                }
+                top += height;
+            }
+        } finally {
+            g.setFont(base);
+            if (baseColor != null) {
+                g.setColor(baseColor);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/NativeImage.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/NativeImage.java
new file mode 100644
index 00000000000..8b9d2c1e547
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/NativeImage.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+
+/// An AWT image that is a Codename One image: one decoded from a file or a
+/// resource, or the result of scaling another. One made of `null` is an
+/// image that could not be read: it has no pixels, and its width and
+/// height are -1, which is how the desktop reports one.
+public final class NativeImage extends Image {
+
+    private final com.codename1.ui.Image image;
+
+    public NativeImage(com.codename1.ui.Image image) {
+        this.image = image;
+    }
+
+    @Override
+    public int getWidth(ImageObserver observer) {
+        return image == null ? -1 : image.getWidth();
+    }
+
+    @Override
+    public int getHeight(ImageObserver observer) {
+        return image == null ? -1 : image.getHeight();
+    }
+
+    /// Only an image created to be drawn into has a graphics, as in AWT.
+    @Override
+    public Graphics getGraphics() {
+        throw new UnsupportedOperationException("getGraphics() is only valid for images created off screen");
+    }
+
+    @Override
+    public com.codename1.ui.Image cn1Image() {
+        return image;
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/NativeWindows.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/NativeWindows.java
new file mode 100644
index 00000000000..6cd9c5b7f51
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/NativeWindows.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.ui.Command;
+import com.codename1.ui.Desktop;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import com.codename1.ui.TopLevelContainer;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.events.WindowEvent;
+import com.codename1.ui.layouts.BorderLayout;
+import java.util.List;
+
+/// Opens AWT windows as windows of Codename One's window manager, on the
+/// ports that have one.
+final class NativeWindows implements SecondaryWindows {
+
+    @Override
+    public boolean supported() {
+        return Display.isInitialized() && Desktop.isSupported();
+    }
+
+    @Override
+    public WindowHost open(Window w) {
+        return new Host(w);
+    }
+
+    /// One window of the window manager.
+    ///
+    /// It takes the size, position, title, icon, resizability and
+    /// decoration of the AWT window, is owned by the window of the AWT
+    /// owner, and keeps other windows from input while a modal dialog is
+    /// showing. Its close box asks the AWT window to close and does
+    /// nothing else. The commands of the menu bar are the window's
+    /// commands, which the port publishes to its native menu.
+    static final class Host extends com.codename1.ui.Window implements WindowHost {
+
+        private final Window window;
+        private boolean maximized;
+
+        Host(Window w) {
+            super(w.cn1Title(), new BorderLayout());
+            window = w;
+            com.codename1.ui.Component p = w.cn1Peer();
+            p.remove();
+            addComponent(BorderLayout.CENTER, p);
+            WindowHosts.listenWheel(w, p);
+            setEnableCursors(true);
+            setCloseOperation(DO_NOTHING_ON_CLOSE);
+            addCloseListener(new ActionListener<ActionEvent>() {
+                @Override
+                public void actionPerformed(ActionEvent evt) {
+                    evt.consume();
+                    window.cn1Closing();
+                }
+            });
+            addWindowListener(new ActionListener<ActionEvent>() {
+                @Override
+                public void actionPerformed(ActionEvent evt) {
+                    if (evt instanceof WindowEvent) {
+                        WindowEvent.Type t = ((WindowEvent) evt).getType();
+                        if (t == WindowEvent.Type.Minimized) {
+                            window.cn1Iconified(true);
+                        } else if (t == WindowEvent.Type.Restored) {
+                            window.cn1Iconified(false);
+                        }
+                    }
+                }
+            });
+            Window owner = w.getOwner();
+            WindowHost oh = owner == null ? null : owner.cn1Host();
+            if (oh instanceof TopLevelContainer) {
+                setOwnerWindow((TopLevelContainer) oh);
+            }
+            if (w instanceof Dialog && ((Dialog) w).isModal()) {
+                setModalityType(MODALITY_APPLICATION);
+            }
+        }
+
+        @Override
+        public void open() {
+            if (isWindowShowing()) {
+                requestWindowFocus();
+                return;
+            }
+            int w = window.getWidth();
+            int h = window.getHeight();
+            if (w > 0 && h > 0) {
+                // The size of an AWT window is its frame's, title bar and
+                // borders included, and so is this one.
+                setWindowSize(Units.toDevice(w), Units.toDevice(h));
+            }
+            if (window.getX() != 0 || window.getY() != 0) {
+                setWindowLocation(Units.toDevice(window.getX()), Units.toDevice(window.getY()));
+            } else {
+                centerOnDesktop();
+            }
+            show();
+        }
+
+        @Override
+        public void close() {
+            if (isWindowShowing()) {
+                hide();
+            }
+        }
+
+        @Override
+        public void release() {
+            if (!isWindowDisposed()) {
+                dispose();
+            }
+        }
+
+        @Override
+        public void title(String title) {
+            setTitle(title);
+        }
+
+        @Override
+        public void icon(Image icon) {
+            setWindowIcon(icon);
+        }
+
+        @Override
+        public void bounds() {
+            if (isWindowShowing() && window.getWidth() > 0 && window.getHeight() > 0) {
+                int dw = Units.toDevice(window.getWidth());
+                int dh = Units.toDevice(window.getHeight());
+                // The window has the size of what is inside the frame
+                // once it is showing: only a size the application set
+                // since is a new one for the frame.
+                if (Math.abs(dw - getWidth()) > 1 || Math.abs(dh - getHeight()) > 1) {
+                    setWindowSize(dw, dh);
+                }
+                setWindowLocation(Units.toDevice(window.getX()), Units.toDevice(window.getY()));
+            }
+        }
+
+        @Override
+        public void resizable(boolean resizable) {
+            setResizable(resizable);
+        }
+
+        @Override
+        public void decorated(boolean decorated) {
+            setDecorated(decorated);
+        }
+
+        @Override
+        public void state(int state) {
+            if ((state & Frame.ICONIFIED) != 0) {
+                minimize();
+                return;
+            }
+            restore();
+            boolean max = (state & Frame.MAXIMIZED_BOTH) == Frame.MAXIMIZED_BOTH;
+            if (max != maximized) {
+                maximized = max;
+                toggleMaximize();
+            }
+        }
+
+        @Override
+        public void commands(List<Command> commands) {
+            removeAllCommands();
+            for (int i = 0; i < commands.size(); i++) {
+                addCommand(commands.get(i));
+            }
+        }
+
+        @Override
+        public boolean takesCommands() {
+            return true;
+        }
+
+        @Override
+        public Form form() {
+            return null;
+        }
+
+        @Override
+        public boolean fillsDisplay() {
+            return false;
+        }
+
+        @Override
+        public boolean reusable() {
+            return !isWindowDisposed();
+        }
+
+        @Override
+        public void pointerPressed(int x, int y) {
+            if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_PRESSED, x, y)) {
+                super.pointerPressed(x, y);
+            }
+        }
+
+        @Override
+        public void pointerDragged(int x, int y) {
+            if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_DRAGGED, x, y)) {
+                super.pointerDragged(x, y);
+            }
+        }
+
+        /// The drag of a pointer as the display delivers it. A form has two
+        /// overloads and the display calls this one, which is an
+        /// implementation of its own and never reaches the one above; with
+        /// only that one overridden no drag got to a Swing component at all,
+        /// while presses and releases, which a form routes through the plain
+        /// overloads, did. More than one pointer is a gesture of Codename
+        /// One's.
+        @Override
+        public void pointerDragged(int[] x, int[] y) {
+            if (x != null && y != null && x.length == 1 && y.length == 1
+                    && EventBridge.pointerEvent(window, MouseEvent.MOUSE_DRAGGED, x[0], y[0])) {
+                return;
+            }
+            super.pointerDragged(x, y);
+        }
+
+        @Override
+        public void pointerReleased(int x, int y) {
+            if (!EventBridge.pointerEvent(window, MouseEvent.MOUSE_RELEASED, x, y)) {
+                super.pointerReleased(x, y);
+            }
+        }
+
+        @Override
+        public void longPointerPress(int x, int y) {
+            EventBridge.longPress(window, x, y);
+            super.longPointerPress(x, y);
+        }
+
+        @Override
+        public void pointerHover(int[] x, int[] y) {
+            if (x != null && y != null && x.length > 0 && y.length > 0) {
+                EventBridge.pointerEvent(window, MouseEvent.MOUSE_MOVED, x[0], y[0]);
+            }
+            super.pointerHover(x, y);
+        }
+
+        @Override
+        public void keyPressed(int keyCode) {
+            if (!EventBridge.key(window, true, keyCode)) {
+                super.keyPressed(keyCode);
+            }
+        }
+
+        @Override
+        public void keyRepeated(int keyCode) {
+            if (!EventBridge.key(window, true, keyCode)) {
+                super.keyRepeated(keyCode);
+            }
+        }
+
+        @Override
+        public void keyReleased(int keyCode) {
+            if (!EventBridge.key(window, false, keyCode)) {
+                super.keyReleased(keyCode);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Peer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Peer.java
new file mode 100644
index 00000000000..f29571183b5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Peer.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+/// What every Codename One component that shows an AWT component
+/// implements.
+///
+/// A peer never paints itself the way Codename One would: it is not
+/// opaque, its `paint` hands over to [PeerSupport#paintOwner], which runs
+/// the AWT component's `paint`, and its `paintBorder` does nothing. The
+/// AWT side then calls back for the two things only the peer can draw.
+public interface Peer {
+
+    /// The support object made in the peer's constructor.
+    PeerSupport support();
+
+    /// Whether the peer is a Codename One widget with a look of its own
+    /// (a button, a label), as opposed to a blank canvas or container.
+    boolean nativeLook();
+
+    /// Paints the widget as Codename One would: style background, content
+    /// and border. Nothing for a peer without a native look.
+    void paintNativeLook(com.codename1.ui.Graphics g);
+
+    /// Paints the child peers; nothing for a peer that has none.
+    void paintNativeChildren(com.codename1.ui.Graphics g);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/PeerSupport.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/PeerSupport.java
new file mode 100644
index 00000000000..a710ba313a3
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/PeerSupport.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.ui.Display;
+import com.codename1.ui.Painter;
+import com.codename1.ui.events.FocusListener;
+import com.codename1.ui.geom.Rectangle;
+import com.codename1.ui.plaf.Border;
+import com.codename1.ui.plaf.Style;
+
+/// The half of a peer that is the same for every peer: it connects one
+/// Codename One component to the AWT component it shows.
+public final class PeerSupport {
+
+    private final Component owner;
+    private final com.codename1.ui.Component peer;
+    private G2D painting;
+
+    public PeerSupport(Component owner, com.codename1.ui.Component peer) {
+        this.owner = owner;
+        this.peer = peer;
+        peer.setOpaque(false);
+        if (peer instanceof com.codename1.ui.Label) {
+            // A Codename One label a pixel short of its text scrolls it back and forth
+            // under the pointer or with the focus: a phone's answer to a narrow screen.
+            // Swing text never moves.
+            ((com.codename1.ui.Label) peer).setTickerEnabled(false);
+            // Text with no room ends in an ellipsis, as a Swing label or
+            // button draws it. A Codename One label takes that from the
+            // theme, where it is off unless the theme says otherwise.
+            ((com.codename1.ui.Label) peer).setEndsWith3Points(true);
+        }
+    }
+
+    /// The AWT component.
+    public Component owner() {
+        return owner;
+    }
+
+    /// Runs the owner's painting with `g`, the context the peer's `paint`
+    /// received. The graphics starts with the owner's foreground and font.
+    public void paintOwner(com.codename1.ui.Graphics g) {
+        G2D g2 = G2D.forPeer(g, peer.getX(), peer.getY(), peer.getWidth(), peer.getHeight());
+        G2D saved = painting;
+        painting = g2;
+        try {
+            Color fg = owner.getForeground();
+            if (fg != null) {
+                g2.setColor(fg);
+            }
+            Font f = owner.getFont();
+            if (f != null) {
+                g2.setFont(f);
+            }
+            owner.update(g2);
+        } finally {
+            painting = saved;
+            g2.finish();
+        }
+    }
+
+    /// Whether `g` draws to the context this peer is being painted with.
+    public boolean isPainting(G2D g) {
+        return painting != null && g.nativeGraphics() == painting.nativeGraphics();
+    }
+
+    /// Paints the peer's native look at the origin of `g`.
+    public void paintNative(G2D g) {
+        if (peer instanceof Peer && ((Peer) peer).nativeLook()) {
+            g.paintNative(peer.getX(), peer.getY(), new NativePass((Peer) peer, false));
+        }
+    }
+
+    /// Paints the peer's children at the origin of `g`.
+    public void paintChildren(G2D g) {
+        if (peer instanceof Peer) {
+            g.paintNative(peer.getX(), peer.getY(), new NativePass((Peer) peer, true));
+        }
+    }
+
+    /// One pass of a peer's own painting: its look, or its children.
+    private static final class NativePass implements G2D.NativePainter {
+        private final Peer target;
+        private final boolean children;
+
+        NativePass(Peer target, boolean children) {
+            this.target = target;
+            this.children = children;
+        }
+
+        @Override
+        public void paint(com.codename1.ui.Graphics ng) {
+            if (children) {
+                target.paintNativeChildren(ng);
+            } else {
+                target.paintNativeLook(ng);
+            }
+        }
+    }
+
+    /// Paints the background the peer's style describes, which Codename
+    /// One itself no longer paints because the peer is not opaque.
+    public void paintStyleBackground(com.codename1.ui.Graphics g) {
+        Style s = peer.getStyle();
+        Border b = s.getBorder();
+        if (b != null && b.isBackgroundPainter()) {
+            b.paintBorderBackground(g, peer);
+            return;
+        }
+        Painter p = s.getBgPainter();
+        if (p != null) {
+            p.paint(g, new Rectangle(peer.getX(), peer.getY(), peer.getWidth(), peer.getHeight()));
+        }
+    }
+
+    /// Gives a canvas or container peer a style that draws and reserves
+    /// nothing.
+    public static void strip(com.codename1.ui.Component c) {
+        c.setUIID("Container");
+        Style s = c.getAllStyles();
+        s.setBgTransparency(0);
+        s.setPadding(0, 0, 0, 0);
+        s.setMargin(0, 0, 0, 0);
+        s.setBorder(null);
+    }
+
+    /// Every style a native component is drawn with, as one: what is set
+    /// on the answer is set on each.
+    ///
+    /// `Component.getAllStyles()` is the styles at rest, selected, pressed
+    /// and disabled, and leaves out the one a theme may declare for a
+    /// component under the pointer. A font or a colour set through it was
+    /// therefore not the font or the colour of a hovered control, which
+    /// changed its text for as long as the pointer stayed over it.
+    public static Style allStyles(com.codename1.ui.Component c) {
+        Style hover = c.getHoverStyle();
+        if (hover == null) {
+            return c.getAllStyles();
+        }
+        return Style.createProxyStyle(c.getUnselectedStyle(), c.getSelectedStyle(), c.getPressedStyle(),
+                c.getDisabledStyle(), hover);
+    }
+
+    /// Pushes the foreground, background and font that were set on the
+    /// owner into the styles of a peer with a native look.
+    public void applyStyle() {
+        if (!(peer instanceof Peer) || !((Peer) peer).nativeLook()) {
+            return;
+        }
+        Style s = allStyles(peer);
+        if (owner.isForegroundSet()) {
+            s.setFgColor(owner.getForeground().getRGB() & 0xffffff);
+        }
+        if (owner.isBackgroundSet()) {
+            Color bg = owner.getBackground();
+            s.setBgColor(bg.getRGB() & 0xffffff);
+            s.setBgTransparency(bg.getAlpha());
+        }
+        // A font of the component's own, else the one the application
+        // chose for everything; with neither the theme's font for this
+        // kind of widget stays.
+        Font f = owner.isFontSet() ? owner.getFont() : Fonts.applicationFont();
+        if (f != null) {
+            s.setFont(Fonts.nativeFont(f, f.getSize2D() * Units.scale()));
+        } else {
+            restFontUnderThePointer();
+        }
+    }
+
+    /// Gives the style of the peer under the pointer the font the peer
+    /// has at rest.
+    ///
+    /// A Swing component has one font, and its size was worked out with
+    /// it. A theme styles the pointer state apart, and themes are layered:
+    /// the theme of an application sets the font of its buttons, which is
+    /// the font at rest, selected, pressed and disabled, while the pointer
+    /// state the platform theme under it declares keeps the platform's
+    /// own. A button then drew a larger text for as long as the pointer
+    /// was over it, in the room measured for the smaller one, and lost its
+    /// last letters to an ellipsis. Only that one style is written, so the
+    /// others still follow the theme when it changes.
+    private void restFontUnderThePointer() {
+        Style hover = peer.getHoverStyle();
+        if (hover == null) {
+            return;
+        }
+        com.codename1.ui.Font rest = peer.getUnselectedStyle().getFont();
+        if (rest != null && rest != hover.getFont()) {
+            hover.setFont(rest);
+        }
+    }
+
+    /// Reports the peer's focus changes to the owner as focus events.
+    public void trackFocus() {
+        peer.addFocusListener(new FocusListener() {
+            @Override
+            public void focusGained(com.codename1.ui.Component cmp) {
+                EventBridge.setFocusOwner(owner, false);
+            }
+
+            @Override
+            public void focusLost(com.codename1.ui.Component cmp) {
+                EventBridge.nativeFocusLost(owner);
+            }
+        });
+    }
+
+    /// Sends a repaint the peer asked for through the root of the peer
+    /// tree, because what lies behind a peer is painted by its ancestors.
+    /// Answers `false` when the peer is the root and must repaint itself.
+    public boolean routeRepaint() {
+        if (owner.getParent() == null || owner.getParent().cn1PeerOrNull() == null) {
+            return false;
+        }
+        repaint(owner, 0, 0, owner.getWidth(), owner.getHeight());
+        return true;
+    }
+
+    private static Component root(Component c) {
+        Component t = c;
+        while (t.getParent() != null && t.getParent().cn1PeerOrNull() != null) {
+            t = t.getParent();
+        }
+        return t;
+    }
+
+    /// Repaints a rectangle of `c`, given in its logical coordinates.
+    public static void repaint(Component c, int x, int y, int width, int height) {
+        com.codename1.ui.Component p = c.cn1PeerOrNull();
+        if (p == null || p.getTopLevelContainer() == null) {
+            return;
+        }
+        com.codename1.ui.Component rp = root(c).cn1PeerOrNull();
+        float s = Units.scale();
+        int x1 = (int) Math.floor(x * s);
+        int y1 = (int) Math.floor(y * s);
+        int x2 = (int) Math.ceil((x + width) * s);
+        int y2 = (int) Math.ceil((y + height) * s);
+        rp.repaint(p.getAbsoluteX() + x1, p.getAbsoluteY() + y1, x2 - x1, y2 - y1);
+    }
+
+    /// Invalidates `c` once the layout pass under way is over, and has
+    /// its window laid out again.
+    ///
+    /// For a component that learns, as it is given its bounds, that it
+    /// now prefers another size: a tool bar that goes into a second row,
+    /// a text that wraps. Invalidating at that moment is lost. The
+    /// containers above are in the middle of their own pass, so the
+    /// invalidation stops at the first of them, and each marks itself
+    /// valid as its pass ends.
+    public static void layoutAgain(final Component c) {
+        if (!Display.isInitialized()) {
+            c.invalidate();
+            return;
+        }
+        Display.getInstance().callSerially(new Runnable() {
+            @Override
+            public void run() {
+                c.revalidate();
+            }
+        });
+    }
+
+    /// Has the window `c` is in laid out again on the next turn of the
+    /// event dispatch thread, and repainted.
+    public static void scheduleLayout(Component c) {
+        if (!Display.isInitialized()) {
+            return;
+        }
+        com.codename1.ui.Component rp = root(c).cn1PeerOrNull();
+        if (rp instanceof com.codename1.ui.Container && rp.getTopLevelContainer() != null) {
+            com.codename1.ui.Container holder = rp.getParent();
+            if (holder instanceof RootPan) {
+                // What changed may have changed how small the window can
+                // get, and that is decided one level up.
+                holder.revalidateLater();
+            } else {
+                ((com.codename1.ui.Container) rp).revalidateLater();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ProgressPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ProgressPeer.java
new file mode 100644
index 00000000000..87ec64c0f6f
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ProgressPeer.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+
+/// The peer of a progress bar: a Codename One slider the user cannot
+/// move, which animates by itself while it is infinite.
+public class ProgressPeer extends SliderPeer {
+
+    public ProgressPeer(Component owner) {
+        super(owner, false);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/RadioButtonPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/RadioButtonPeer.java
new file mode 100644
index 00000000000..fca73be4528
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/RadioButtonPeer.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+
+/// The peer of a radio button: a Codename One radio button. Grouping is
+/// done by the Swing button group, not by Codename One.
+public class RadioButtonPeer extends com.codename1.ui.RadioButton implements Peer {
+
+    private final PeerSupport support;
+
+    public RadioButtonPeer(Component owner) {
+        support = new PeerSupport(owner, this);
+        // The room between the mark and its text.
+        setGap(Units.toDevice(4));
+        support.trackFocus();
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        if (getIcon() != null || ownMark()) {
+            // In Swing an icon takes the place of the indicator; it is not
+            // drawn beside it. Without one the indicator is the mark drawn
+            // here, which the button shows as its icon.
+            if (ownMark()) {
+                Indicators.labelText(this, support);
+            }
+            getUIManager().getLookAndFeel().drawButton(g, this);
+        } else {
+            super.paint(g);
+        }
+        super.paintBorder(g);
+    }
+
+    /// Whether the indicator is the mark drawn here rather than the
+    /// theme's: always, unless the button is a toggle or shows an icon in
+    /// its place.
+    private boolean ownMark() {
+        return !isToggle() && getIcon() == null;
+    }
+
+    private com.codename1.ui.Image mark() {
+        return Indicators.mark(true, isSelected(), isEnabled(), Indicators.size(getUnselectedStyle()));
+    }
+
+    @Override
+    public com.codename1.ui.Image getIconFromState() {
+        return ownMark() ? mark() : super.getIconFromState();
+    }
+
+    @Override
+    public com.codename1.ui.Image getMaskedIcon() {
+        return ownMark() ? mark() : super.getMaskedIcon();
+    }
+
+    /// With an icon there is no indicator to make room for, and the mark
+    /// drawn here is measured as one.
+    @Override
+    protected com.codename1.ui.geom.Dimension calcPreferredSize() {
+        if (ownMark()) {
+            Indicators.labelText(this, support);
+        }
+        if (getIcon() != null || ownMark()) {
+            return getUIManager().getLookAndFeel().getButtonPreferredSize(this);
+        }
+        return super.calcPreferredSize();
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/RootPan.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/RootPan.java
new file mode 100644
index 00000000000..a47738cd378
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/RootPan.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.javax.swing.JRootPane;
+import com.codename1.desktopcompat.javax.swing.RootPaneContainer;
+import com.codename1.ui.Component;
+import com.codename1.ui.Container;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.Layout;
+
+/// What holds the peer of a window that fills the display, and lets the
+/// user pan it when the display is smaller than the window can get.
+///
+/// A desktop window that is made smaller than the minimum size of its
+/// content cuts the content off, and the user makes it larger again. A
+/// display cannot be made larger, so here the window is never given less
+/// than that minimum: in an axis in which the display is smaller the
+/// window keeps its minimum size and this container scrolls, by dragging,
+/// flinging and the wheel as everything else on the device does. In an
+/// axis in which the content fits, which is every axis of a layout that
+/// can shrink, the window has exactly the size of the display and nothing
+/// scrolls.
+///
+/// The minimum is the one the root pane's layout answers, that is the
+/// content's and the menu bar's. A minimum size set on the window itself
+/// is a wish about a desktop window and is not read.
+///
+/// One answer of the desktop's is not taken as it is. A component with
+/// neither a layout nor a minimum size of its own answers the size it
+/// has at the moment, whatever that is; a window that was laid out once
+/// at the size the application asked for would then never be smaller
+/// again. While the least size is asked for, see [#measuring()], such a
+/// component answers what it needs instead: nothing when it has no
+/// children, and the extent of its children when it places them itself.
+public final class RootPan extends Container {
+
+    private static boolean measuring;
+
+    private final Window window;
+
+    public RootPan(Window w, Component peer) {
+        super(new Fit());
+        window = w;
+        setScrollableX(false);
+        setScrollableY(false);
+        getAllStyles().setPadding(0, 0, 0, 0);
+        getAllStyles().setMargin(0, 0, 0, 0);
+        getAllStyles().setBgTransparency(0);
+        add(peer);
+    }
+
+    /// Whether a least size is being asked for at the moment, which is
+    /// when a component with no minimum of its own answers what it needs
+    /// and not the size it happens to have.
+    public static boolean measuring() {
+        return measuring;
+    }
+
+    /// The width of the display in logical pixels: the widest a window
+    /// is laid out without being panned, which is where a row of
+    /// components that can wrap does so.
+    public static int displayWidth() {
+        if (!com.codename1.ui.Display.isInitialized()) {
+            return Integer.MAX_VALUE;
+        }
+        return Units.toLogical(com.codename1.ui.Display.getInstance().getDisplayWidth());
+    }
+
+    /// The least size the window is laid out at, in device pixels: the
+    /// minimum size of its content, or nothing when the window has none.
+    int[] least() {
+        com.codename1.desktopcompat.java.awt.Dimension d = null;
+        if (window instanceof RootPaneContainer) {
+            JRootPane root = ((RootPaneContainer) window).getRootPane();
+            if (root != null) {
+                d = minimumOf(root);
+            }
+        }
+        if (d == null) {
+            return new int[]{0, 0};
+        }
+        return new int[]{Units.toDevice(d.width), Units.toDevice(d.height)};
+    }
+
+    /// The minimum size of `root`, asked for with [#measuring()] on.
+    private static com.codename1.desktopcompat.java.awt.Dimension minimumOf(JRootPane root) {
+        boolean was = measuring;
+        measuring = true;
+        try {
+            return root.getMinimumSize();
+        } finally {
+            measuring = was;
+        }
+    }
+
+
+    @Override
+    public Dimension getScrollDimension() {
+        if (getComponentCount() > 0) {
+            Component c = getComponentAt(0);
+            return new Dimension(Math.max(getWidth(), c.getWidth()), Math.max(getHeight(), c.getHeight()));
+        }
+        return new Dimension(getWidth(), getHeight());
+    }
+
+    /// Gives the window's peer the size of this container or the least
+    /// size of the window, whichever is larger, axis by axis.
+    private static final class Fit extends Layout {
+
+        @Override
+        public void layoutContainer(Container parent) {
+            if (parent.getComponentCount() == 0 || !(parent instanceof RootPan)) {
+                return;
+            }
+            RootPan pan = (RootPan) parent;
+            int[] least = pan.least();
+            int w = Math.max(parent.getWidth(), least[0]);
+            int h = Math.max(parent.getHeight(), least[1]);
+            boolean x = w > parent.getWidth();
+            boolean y = h > parent.getHeight();
+            if (parent.isScrollableX() != x) {
+                parent.setScrollableX(x);
+            }
+            if (parent.isScrollableY() != y) {
+                parent.setScrollableY(y);
+            }
+            int sx = Math.max(0, Math.min(parent.getScrollX(), w - parent.getWidth()));
+            int sy = Math.max(0, Math.min(parent.getScrollY(), h - parent.getHeight()));
+            if (sx != parent.getScrollX() || sy != parent.getScrollY()) {
+                pan.panTo(sx, sy);
+            }
+            Component c = parent.getComponentAt(0);
+            c.setX(0);
+            c.setY(0);
+            c.setWidth(w);
+            c.setHeight(h);
+        }
+
+        @Override
+        public Dimension getPreferredSize(Container parent) {
+            if (parent.getComponentCount() == 0) {
+                return new Dimension(0, 0);
+            }
+            return parent.getComponentAt(0).getPreferredSize();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o == this;
+        }
+
+        @Override
+        public int hashCode() {
+            return System.identityHashCode(this);
+        }
+    }
+
+    /// Pans to a position in device pixels, as a drag would.
+    public void panTo(int x, int y) {
+        if (x != getScrollX()) {
+            setScrollX(x);
+        }
+        if (y != getScrollY()) {
+            setScrollY(y);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ScrollDelegate.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ScrollDelegate.java
new file mode 100644
index 00000000000..ef2e7bca573
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ScrollDelegate.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JViewport;
+
+/// What a component that handles its own pointer input needs from the
+/// scroll pane around it.
+///
+/// A table or tree takes the pointer events over it, so the scroll pane
+/// never sees a finger drag that starts on a row. On a touch screen such a
+/// drag means "scroll", not "extend the selection": the component leaves
+/// its selection alone and hands the events on with [#forward].
+public final class ScrollDelegate {
+
+    /// How thick the scroll bars of a scroll pane are on a desktop port.
+    private static final int DESKTOP_BAR = 14;
+
+    private static int forcedBar = -1;
+
+    private ScrollDelegate() {
+    }
+
+    /// How much room a scroll bar of a scroll pane takes, in logical
+    /// pixels: a bar to drag with the mouse on a desktop port, and none on
+    /// a touch device, where the content itself is dragged and Codename
+    /// One draws an indicator over it.
+    public static int barThickness() {
+        if (forcedBar >= 0) {
+            return forcedBar;
+        }
+        return com.codename1.ui.Display.isInitialized() && com.codename1.ui.Display.getInstance().isDesktop()
+                ? DESKTOP_BAR : 0;
+    }
+
+    /// Fixes the answer of [#barThickness]; a negative value lets the
+    /// device decide again. For tests.
+    public static void setBarThickness(int thickness) {
+        forcedBar = thickness;
+    }
+
+    /// The nearest scroll pane around `c`, or `null`.
+    public static JScrollPane enclosing(Component c) {
+        for (Container p = c.getParent(); p != null; p = p.getParent()) {
+            if (p instanceof JScrollPane) {
+                return (JScrollPane) p;
+            }
+        }
+        return null;
+    }
+
+    /// Sends a copy of a mouse event of `source` to the scroll pane around
+    /// it, in the pane's coordinates. Answers `false` when there is none.
+    public static boolean forward(Component source, MouseEvent e) {
+        JScrollPane pane = enclosing(source);
+        if (pane == null) {
+            return false;
+        }
+        int x = e.getX();
+        int y = e.getY();
+        for (Component c = source; c != null && c != pane; c = c.getParent()) {
+            x += c.getX();
+            y += c.getY();
+        }
+        pane.dispatchEvent(new MouseEvent(pane, e.getID(), e.getWhen(), e.getModifiers(), x, y, e.getClickCount(),
+                e.isPopupTrigger(), e.getButton()));
+        return true;
+    }
+
+    /// Scrolls the viewport around `c` as little as it takes to show the
+    /// rectangle, given in the coordinates of `c`. Does nothing when `c`
+    /// is in no viewport.
+    public static void reveal(Component c, Rectangle r) {
+        int x = r.x;
+        int y = r.y;
+        Component view = c;
+        Container parent = c.getParent();
+        while (parent != null && !(parent instanceof JViewport)) {
+            x += view.getX();
+            y += view.getY();
+            view = parent;
+            parent = parent.getParent();
+        }
+        if (parent == null) {
+            return;
+        }
+        JViewport viewport = (JViewport) parent;
+        if (!viewport.isValid()) {
+            // The view may just have grown: scroll within its new size.
+            viewport.validate();
+        }
+        Point at = viewport.getViewPosition();
+        Dimension extent = viewport.getExtentSize();
+        int nx = along(at.x, extent.width, x, r.width, view.getWidth());
+        int ny = along(at.y, extent.height, y, r.height, view.getHeight());
+        if (nx != at.x || ny != at.y) {
+            viewport.setViewPosition(new Point(nx, ny));
+        }
+    }
+
+    /// The scroll position along one axis that shows `[start, start +
+    /// length)`: unchanged if it shows already, else moved the shorter
+    /// way, and with the start winning when the span is longer than the
+    /// viewport.
+    private static int along(int position, int extent, int start, int length, int viewLength) {
+        int p = position;
+        if (start < p) {
+            p = start;
+        } else if (start + length > p + extent) {
+            p = Math.min(start, start + length - extent);
+        }
+        int max = Math.max(0, viewLength - extent);
+        return Math.max(0, Math.min(p, max));
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SecondaryWindows.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SecondaryWindows.java
new file mode 100644
index 00000000000..73320e398e8
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SecondaryWindows.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Window;
+
+/// Opens an AWT window as a window of its own beside the one the
+/// application started in.
+///
+/// The default asks Codename One's window manager, which exists on the
+/// desktop ports. A test installs its own with
+/// [WindowHosts#setSecondaryWindows] to exercise the multi window path
+/// where there is no window manager.
+public interface SecondaryWindows {
+
+    /// Whether windows can be opened beside the first one at all.
+    boolean supported();
+
+    /// The host for `w`, or `null` to show it the way a phone does.
+    WindowHost open(Window w);
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SliderPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SliderPeer.java
new file mode 100644
index 00000000000..aaa87b09432
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SliderPeer.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+
+/// The peer of a slider: an editable Codename One slider, dragged
+/// natively.
+///
+/// A Codename One slider draws itself as its background, which a peer does
+/// not have because it is not opaque; the look is therefore painted with
+/// the peer opaque for the length of that call. The owner may confine the
+/// look to a band of the peer, which leaves it room for the tick marks and
+/// labels it paints itself.
+public class SliderPeer extends com.codename1.ui.Slider implements Peer {
+
+    private final PeerSupport support;
+    private int bandOffset;
+    private int bandSize = -1;
+
+    public SliderPeer(Component owner) {
+        this(owner, true);
+    }
+
+    protected SliderPeer(Component owner, boolean editable) {
+        support = new PeerSupport(owner, this);
+        setEditable(editable);
+        if (editable) {
+            support.trackFocus();
+        }
+    }
+
+    /// Confines the native look to `size` device pixels across the
+    /// slider's direction, starting `offset` pixels in. A negative size
+    /// gives the look the whole peer.
+    public void setBand(int offset, int size) {
+        bandOffset = offset;
+        bandSize = size;
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        int w = getWidth();
+        int h = getHeight();
+        int dx = 0;
+        int dy = 0;
+        if (bandSize >= 0) {
+            if (isVertical()) {
+                dx = bandOffset;
+                setWidth(Math.min(bandSize, Math.max(0, w - dx)));
+            } else {
+                dy = bandOffset;
+                setHeight(Math.min(bandSize, Math.max(0, h - dy)));
+            }
+        }
+        setOpaque(true);
+        g.translate(dx, dy);
+        try {
+            super.paintComponentBackground(g);
+            super.paint(g);
+            super.paintBorder(g);
+        } finally {
+            g.translate(-dx, -dy);
+            setOpaque(false);
+            setWidth(w);
+            setHeight(h);
+        }
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    /// Nothing: the look is painted by `paintNativeLook`, when the owner
+    /// asks for it.
+    @Override
+    public void paintComponentBackground(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/StyledText.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/StyledText.java
new file mode 100644
index 00000000000..86cd043091e
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/StyledText.java
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Toolkit;
+import com.codename1.desktopcompat.javax.swing.text.AttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.Element;
+import com.codename1.desktopcompat.javax.swing.text.StyleConstants;
+import com.codename1.desktopcompat.javax.swing.text.StyledDocument;
+import java.util.ArrayList;
+
+/// The lines a styled document is drawn as.
+///
+/// Every run of the document is set in its own font and color; a
+/// paragraph is broken at its spaces where it would pass the width it is
+/// given, a word longer than the width is broken where it must be, and a
+/// line is as high as the tallest font in it. An attribute a run does not
+/// have -- neither itself, nor its paragraph, nor the paragraph's style --
+/// comes from the component: its font, and its foreground.
+///
+/// A layout describes the document as it was when it was made.
+public final class StyledText {
+
+    private static final class Seg {
+        int start;
+        int end;
+        int x;
+        int width;
+        Font font;
+        Color fg;
+        Color bg;
+        boolean underline;
+        boolean strike;
+    }
+
+    private static final class Line {
+        final ArrayList<Seg> segs = new ArrayList<Seg>();
+        /// The offsets the line stands for; `end` takes in the line break.
+        int start;
+        int end;
+        int x;
+        int y;
+        int width;
+        int height;
+        int ascent;
+    }
+
+    private final String text;
+    private final ArrayList<Line> lines = new ArrayList<Line>();
+    private int width;
+    private int height;
+
+    /// Whether any of `doc` asks to be drawn other than as the plain text
+    /// of the component.
+    public static boolean styled(StyledDocument doc) {
+        Element root = doc.getDefaultRootElement();
+        for (int p = 0; p < root.getElementCount(); p++) {
+            Element para = root.getElement(p);
+            if (para == null) {
+                continue;
+            }
+            if (para.getAttributes().getAttribute(StyleConstants.Alignment) != null) {
+                return true;
+            }
+            for (int i = 0; i < para.getElementCount(); i++) {
+                Element leaf = para.getElement(i);
+                if (leaf != null && rendering(leaf.getAttributes())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private static boolean rendering(AttributeSet a) {
+        return a.getAttribute(StyleConstants.Foreground) != null || a.getAttribute(StyleConstants.Background) != null
+                || a.getAttribute(StyleConstants.Bold) != null || a.getAttribute(StyleConstants.Italic) != null
+                || a.getAttribute(StyleConstants.Underline) != null
+                || a.getAttribute(StyleConstants.StrikeThrough) != null
+                || a.getAttribute(StyleConstants.FontFamily) != null
+                || a.getAttribute(StyleConstants.FontSize) != null;
+    }
+
+    /// Lays `doc` out in lines no wider than `room`; with `room` of zero
+    /// or less only the line breaks of the text end a line.
+    public StyledText(StyledDocument doc, Font base, Color foreground, int room) {
+        String all;
+        try {
+            all = doc.getText(0, doc.getLength());
+        } catch (BadLocationException e) {
+            all = "";
+        }
+        text = all;
+        Element root = doc.getDefaultRootElement();
+        int y = 0;
+        for (int p = 0; p < root.getElementCount(); p++) {
+            Element para = root.getElement(p);
+            if (para == null) {
+                continue;
+            }
+            int first = lines.size();
+            paragraph(para, base, foreground, room);
+            Object align = para.getAttributes().getAttribute(StyleConstants.Alignment);
+            int how = align instanceof Integer ? ((Integer) align).intValue() : StyleConstants.ALIGN_LEFT;
+            for (int i = first; i < lines.size(); i++) {
+                Line line = lines.get(i);
+                line.y = y;
+                y += line.height;
+                if (room > 0 && how == StyleConstants.ALIGN_CENTER) {
+                    line.x = Math.max(0, (room - line.width) / 2);
+                } else if (room > 0 && how == StyleConstants.ALIGN_RIGHT) {
+                    line.x = Math.max(0, room - line.width);
+                }
+                width = Math.max(width, line.width);
+            }
+        }
+        height = y;
+    }
+
+    private static Font font(AttributeSet a, Font base) {
+        Object family = a.getAttribute(StyleConstants.FontFamily);
+        Object size = a.getAttribute(StyleConstants.FontSize);
+        Object bold = a.getAttribute(StyleConstants.Bold);
+        Object italic = a.getAttribute(StyleConstants.Italic);
+        if (family == null && size == null && bold == null && italic == null) {
+            return base;
+        }
+        int style = base.getStyle();
+        if (bold instanceof Boolean) {
+            style = ((Boolean) bold).booleanValue() ? style | Font.BOLD : style & ~Font.BOLD;
+        }
+        if (italic instanceof Boolean) {
+            style = ((Boolean) italic).booleanValue() ? style | Font.ITALIC : style & ~Font.ITALIC;
+        }
+        float points = base.getSize2D();
+        if (size instanceof Integer) {
+            points = ((Integer) size).intValue();
+        }
+        if (family instanceof String) {
+            return new Font((String) family, style, Math.round(points));
+        }
+        return base.deriveFont(style, points);
+    }
+
+    private Line open(int at, Font base) {
+        Line line = new Line();
+        line.start = at;
+        line.end = at;
+        FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(base);
+        line.height = fm.getHeight();
+        line.ascent = fm.getAscent();
+        lines.add(line);
+        return line;
+    }
+
+    private void put(Line line, Seg like, int from, int to, FontMetrics fm) {
+        if (from >= to) {
+            return;
+        }
+        if (!line.segs.isEmpty()) {
+            // More of the run the line ends with: one stretch, drawn and
+            // measured as one string.
+            Seg last = line.segs.get(line.segs.size() - 1);
+            if (last.end == from && last.font == like.font && last.fg == like.fg && last.bg == like.bg
+                    && last.underline == like.underline && last.strike == like.strike) {
+                last.end = to;
+                last.width = fm.stringWidth(text.substring(last.start, to));
+                line.width = last.x + last.width;
+                line.end = to;
+                return;
+            }
+        }
+        Seg s = new Seg();
+        s.start = from;
+        s.end = to;
+        s.font = like.font;
+        s.fg = like.fg;
+        s.bg = like.bg;
+        s.underline = like.underline;
+        s.strike = like.strike;
+        s.x = line.width;
+        s.width = fm.stringWidth(text.substring(from, to));
+        line.width += s.width;
+        line.end = to;
+        // An empty line has the height of the component's font; one with
+        // text has that of the text.
+        if (line.segs.isEmpty()) {
+            line.height = fm.getHeight();
+            line.ascent = fm.getAscent();
+        } else {
+            int below = Math.max(line.height - line.ascent, fm.getHeight() - fm.getAscent());
+            line.ascent = Math.max(line.ascent, fm.getAscent());
+            line.height = line.ascent + below;
+        }
+        line.segs.add(s);
+    }
+
+    private static boolean space(char c) {
+        return c == ' ' || c == '\t';
+    }
+
+    private void paragraph(Element para, Font base, Color foreground, int room) {
+        int pStart = para.getStartOffset();
+        int pEnd = Math.min(para.getEndOffset(), text.length());
+        // The text without the break that ends it.
+        int stop = pEnd > pStart && text.charAt(pEnd - 1) == '\n' ? pEnd - 1 : pEnd;
+        // The runs, as stretches with one look each.
+        ArrayList<Seg> runs = new ArrayList<Seg>();
+        for (int i = 0; i < para.getElementCount(); i++) {
+            Element leaf = para.getElement(i);
+            if (leaf == null) {
+                continue;
+            }
+            Seg r = new Seg();
+            r.start = Math.max(pStart, leaf.getStartOffset());
+            r.end = Math.min(stop, leaf.getEndOffset());
+            if (r.start >= r.end) {
+                continue;
+            }
+            AttributeSet a = leaf.getAttributes();
+            r.font = font(a, base);
+            Object fg = a.getAttribute(StyleConstants.Foreground);
+            r.fg = fg instanceof Color ? (Color) fg : foreground;
+            Object bg = a.getAttribute(StyleConstants.Background);
+            r.bg = bg instanceof Color ? (Color) bg : null;
+            Object u = a.getAttribute(StyleConstants.Underline);
+            r.underline = u instanceof Boolean && ((Boolean) u).booleanValue();
+            Object s = a.getAttribute(StyleConstants.StrikeThrough);
+            r.strike = s instanceof Boolean && ((Boolean) s).booleanValue();
+            runs.add(r);
+        }
+        Line line = open(pStart, base);
+        // A word is taken whole: its characters through every run it
+        // crosses, and the spaces after it.
+        int at = pStart;
+        while (at < stop) {
+            int wordEnd = at;
+            while (wordEnd < stop && !space(text.charAt(wordEnd))) {
+                wordEnd++;
+            }
+            int next = wordEnd;
+            while (next < stop && space(text.charAt(next))) {
+                next++;
+            }
+            if (room > 0 && line.width > 0 && line.width + measure(runs, at, wordEnd) > room) {
+                line = open(at, base);
+            }
+            for (int i = 0; i < runs.size(); i++) {
+                Seg r = runs.get(i);
+                int from = Math.max(at, r.start);
+                int to = Math.min(next, r.end);
+                if (from >= to) {
+                    continue;
+                }
+                FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(r.font);
+                int part = Math.max(from, Math.min(to, wordEnd));
+                while (from < part) {
+                    if (room <= 0 || line.width + fm.stringWidth(text.substring(from, part)) <= room) {
+                        put(line, r, from, part, fm);
+                        from = part;
+                        break;
+                    }
+                    // A word wider than the line: as much of it as fits,
+                    // and one character where none does.
+                    int fit = from;
+                    int w = line.width;
+                    while (fit < part) {
+                        int cw = fm.charWidth(text.charAt(fit));
+                        if (w + cw > room && (fit > from || line.width > 0)) {
+                            break;
+                        }
+                        w += cw;
+                        fit++;
+                    }
+                    if (fit == from) {
+                        line = open(from, base);
+                        continue;
+                    }
+                    put(line, r, from, fit, fm);
+                    from = fit;
+                    if (from < part) {
+                        line = open(from, base);
+                    }
+                }
+                // The spaces after the word stay on its line.
+                put(line, r, from, to, fm);
+            }
+            at = next;
+        }
+        line.end = pEnd;
+    }
+
+    private int measure(ArrayList<Seg> runs, int from, int to) {
+        int w = 0;
+        for (int i = 0; i < runs.size(); i++) {
+            Seg r = runs.get(i);
+            int a = Math.max(from, r.start);
+            int b = Math.min(to, r.end);
+            if (a < b) {
+                w += Toolkit.getDefaultToolkit().getFontMetrics(r.font).stringWidth(text.substring(a, b));
+            }
+        }
+        return w;
+    }
+
+    /// The width of the widest line.
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public int getLineCount() {
+        return lines.size();
+    }
+
+    /// Draws the lines with their top left corner at `x0`, `y0`.
+    public void paint(Graphics g, int x0, int y0) {
+        for (int i = 0; i < lines.size(); i++) {
+            Line line = lines.get(i);
+            int base = y0 + line.y + line.ascent;
+            for (int j = 0; j < line.segs.size(); j++) {
+                Seg s = line.segs.get(j);
+                int x = x0 + line.x + s.x;
+                if (s.bg != null) {
+                    g.setColor(s.bg);
+                    g.fillRect(x, y0 + line.y, s.width, line.height);
+                }
+                if (s.fg != null) {
+                    g.setColor(s.fg);
+                }
+                g.setFont(s.font);
+                g.drawString(text.substring(s.start, s.end), x, base);
+                if (s.underline) {
+                    g.drawLine(x, base + 1, x + s.width - 1, base + 1);
+                }
+                if (s.strike) {
+                    int mid = base - Math.max(1, line.ascent / 3);
+                    g.drawLine(x, mid, x + s.width - 1, mid);
+                }
+            }
+        }
+    }
+
+    private Line lineAt(int pos) {
+        for (int i = 0; i < lines.size(); i++) {
+            Line line = lines.get(i);
+            if (pos < line.end || i == lines.size() - 1) {
+                return line;
+            }
+        }
+        return null;
+    }
+
+    /// The offset nearest a point, relative to the corner the lines are
+    /// drawn from: the character whose nearer half the point is in.
+    public int offsetAt(int x, int y) {
+        if (lines.isEmpty()) {
+            return 0;
+        }
+        Line line = lines.get(lines.size() - 1);
+        for (int i = 0; i < lines.size(); i++) {
+            Line l = lines.get(i);
+            if (y < l.y + l.height) {
+                line = l;
+                break;
+            }
+        }
+        int px = x - line.x;
+        int last = line.start;
+        for (int j = 0; j < line.segs.size(); j++) {
+            Seg s = line.segs.get(j);
+            last = s.end;
+            if (px >= s.x + s.width) {
+                continue;
+            }
+            FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(s.font);
+            int at = s.x;
+            for (int k = s.start; k < s.end; k++) {
+                int cw = fm.charWidth(text.charAt(k));
+                if (px < at + cw / 2 + (cw & 1)) {
+                    return k;
+                }
+                at += cw;
+            }
+            return s.end;
+        }
+        return last;
+    }
+
+    /// Where the caret stands before the character at `pos`: one pixel
+    /// wide and as high as its line.
+    public Rectangle caretAt(int pos) {
+        Line line = lineAt(pos);
+        if (line == null) {
+            return new Rectangle(0, 0, 1, 0);
+        }
+        int x = line.width;
+        for (int j = 0; j < line.segs.size(); j++) {
+            Seg s = line.segs.get(j);
+            if (pos <= s.start) {
+                x = s.x;
+                break;
+            }
+            if (pos < s.end) {
+                FontMetrics fm = Toolkit.getDefaultToolkit().getFontMetrics(s.font);
+                x = s.x + fm.stringWidth(text.substring(s.start, pos));
+                break;
+            }
+        }
+        return new Rectangle(line.x + x, line.y, 1, line.height);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SystemClipboard.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SystemClipboard.java
new file mode 100644
index 00000000000..4cae59e9c10
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/SystemClipboard.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.datatransfer.Clipboard;
+import com.codename1.desktopcompat.java.awt.datatransfer.ClipboardOwner;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.StringSelection;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import com.codename1.desktopcompat.java.awt.datatransfer.UnsupportedFlavorException;
+import com.codename1.ui.ClipboardContent;
+import com.codename1.ui.Display;
+import java.io.IOException;
+
+/// The system clipboard: the Codename One clipboard, seen as an AWT one.
+/// Text goes both ways; anything else an application puts here stays in
+/// the application.
+public final class SystemClipboard extends Clipboard {
+
+    /// The text last handed to the device, to tell the application's own
+    /// contents from something copied elsewhere since.
+    private String pushed;
+
+    public SystemClipboard() {
+        super("System");
+    }
+
+    @Override
+    public void setContents(Transferable contents, ClipboardOwner owner) {
+        super.setContents(contents, owner);
+        pushed = null;
+        if (contents == null || !contents.isDataFlavorSupported(DataFlavor.stringFlavor)
+                || !Display.isInitialized()) {
+            return;
+        }
+        Object text;
+        try {
+            text = contents.getTransferData(DataFlavor.stringFlavor);
+        } catch (UnsupportedFlavorException e) {
+            return;
+        } catch (IOException e) {
+            return;
+        }
+        if (text instanceof String) {
+            pushed = (String) text;
+            Display.getInstance().copyToClipboard(pushed);
+        }
+    }
+
+    /// What the device's clipboard holds now. While that is still the
+    /// text this application put there, the application's own transferable
+    /// is answered, with every flavor it has.
+    @Override
+    public Transferable getContents(Object requestor) {
+        if (!Display.isInitialized()) {
+            return contents;
+        }
+        Object now = Display.getInstance().getPasteDataFromClipboard();
+        String text = null;
+        if (now instanceof String) {
+            text = (String) now;
+        } else if (now instanceof ClipboardContent) {
+            text = ((ClipboardContent) now).getText("text/plain");
+        }
+        if (text == null) {
+            // Nothing the device can show as text: only what was put here
+            // and never reached the device is still ours to answer.
+            return pushed == null ? contents : null;
+        }
+        if (contents != null && text.equals(pushed)) {
+            return contents;
+        }
+        return new StringSelection(text);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TabbedPanePeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TabbedPanePeer.java
new file mode 100644
index 00000000000..28e08536551
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TabbedPanePeer.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.ui.Image;
+import com.codename1.ui.RadioButton;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.geom.Dimension;
+import com.codename1.ui.layouts.BoxLayout;
+import java.util.ArrayList;
+
+/// The peer of a tabbed pane: a container peer for the pages, plus a strip
+/// of Codename One tab buttons.
+///
+/// The pages are ordinary children, placed by the tabbed pane's own
+/// layout. The strip is one more Codename One child that the AWT side
+/// knows nothing of; it is kept last, which is on top, so the indexes the
+/// pages are added at never see it. The strip is styled as the tabs of a
+/// Codename One `Tabs` are: a `TabsContainer` of `Tab` toggle buttons.
+///
+/// Two things are Swing's and not the theme's. A tab is as wide as its
+/// title and the tabs start at the leading end of the strip, which scrolls
+/// when they do not fit: a theme that spreads its own tabs evenly over the
+/// width (`tabsGridBool`) is not followed, because programs written for
+/// the desktop count on short tabs beside each other. And the selected tab
+/// is marked with a bar in its text color along the edge that faces the
+/// page, so it can be told from the others in a theme whose selected tab
+/// differs by nothing but a shade.
+public class TabbedPanePeer extends ContainerPeer {
+
+    /// Placements, numbered as the Swing constants are.
+    public static final int TOP = 1;
+    public static final int LEFT = 2;
+    public static final int BOTTOM = 3;
+    public static final int RIGHT = 4;
+
+    /// Told when the user picks a tab.
+    public interface Listener {
+        void tabChosen(int index);
+    }
+
+    private final Strip strip;
+    private final ArrayList<TabButton> buttons = new ArrayList<TabButton>();
+    private final Listener listener;
+    private int placement = TOP;
+    private int selected = -1;
+
+    public TabbedPanePeer(Container owner, Listener listener) {
+        super(owner);
+        this.listener = listener;
+        strip = new Strip(this);
+        applyPlacement();
+    }
+
+    /// Adds the strip above the page peers. Called once, after the peers
+    /// of the pages that existed when this peer was made were added.
+    public void attachStrip() {
+        if (strip.getParent() == null) {
+            addComponent(strip);
+        }
+    }
+
+    public int tabCount() {
+        return buttons.size();
+    }
+
+    /// The button of a tab.
+    public com.codename1.ui.Button tab(int index) {
+        return buttons.get(index);
+    }
+
+    private void applyPlacement() {
+        boolean across = placement == TOP || placement == BOTTOM;
+        strip.setLayout(new BoxLayout(across ? BoxLayout.X_AXIS : BoxLayout.Y_AXIS));
+        strip.setScrollableX(across);
+        strip.setScrollableY(!across);
+    }
+
+    /// Makes the strip show these tabs, one per element, on the given
+    /// side. Buttons are reused, so a tab the user is pressing survives.
+    public void setTabs(String[] titles, Image[] icons, boolean[] enabled, int[] inks, int selectedIndex,
+            int tabPlacement) {
+        int n = titles.length;
+        while (buttons.size() > n) {
+            TabButton b = buttons.remove(buttons.size() - 1);
+            strip.removeComponent(b);
+        }
+        while (buttons.size() < n) {
+            TabButton b = new TabButton(this, buttons.size());
+            buttons.add(b);
+            strip.addComponent(b);
+        }
+        placement = tabPlacement;
+        applyPlacement();
+        for (int i = 0; i < n; i++) {
+            TabButton b = buttons.get(i);
+            b.setText(titles[i] == null ? "" : titles[i]);
+            b.setIcon(icons[i]);
+            b.setEnabled(enabled[i]);
+            b.ink(inks[i]);
+        }
+        strip.setShouldCalcPreferredSize(true);
+        select(selectedIndex);
+    }
+
+    /// Shows the tab at `index` as the selected one; -1 for none.
+    public void select(int index) {
+        selected = index;
+        for (int i = 0; i < buttons.size(); i++) {
+            TabButton b = buttons.get(i);
+            if (b.isSelected() != (i == index)) {
+                b.setSelected(i == index);
+            }
+        }
+        if (index >= 0 && index < buttons.size() && strip.getComponentForm() != null) {
+            strip.scrollComponentToVisible(buttons.get(index));
+        }
+    }
+
+    /// The size the strip wants, in device pixels; nothing without tabs.
+    public Dimension stripPreferredSize() {
+        if (buttons.isEmpty()) {
+            return new Dimension(0, 0);
+        }
+        return new Dimension(strip.getPreferredW(), strip.getPreferredH());
+    }
+
+    /// Places the strip, in device pixels relative to this peer, and lays
+    /// its buttons out.
+    public void placeStrip(int x, int y, int width, int height) {
+        strip.setX(x);
+        strip.setY(y);
+        strip.setWidth(width);
+        strip.setHeight(height);
+        strip.setVisible(width > 0 && height > 0);
+        strip.relayout();
+    }
+
+    /// The bounds of a tab's button in device pixels relative to this
+    /// peer: `{x, y, width, height}`.
+    public int[] tabBounds(int index) {
+        TabButton b = buttons.get(index);
+        return new int[]{strip.getX() + b.getX() - strip.getScrollX(), strip.getY() + b.getY() - strip.getScrollY(),
+            b.getWidth(), b.getHeight()};
+    }
+
+    void chosen(TabButton b) {
+        int index = buttons.indexOf(b);
+        if (index < 0) {
+            return;
+        }
+        listener.tabChosen(index);
+        // The owner decides; show what it decided, not what was pressed.
+        select(selected);
+    }
+
+    boolean routeRepaint() {
+        return support() != null && support().routeRepaint();
+    }
+
+    /// The row or column of tab buttons.
+    private static final class Strip extends com.codename1.ui.Container {
+        private final TabbedPanePeer peer;
+
+        Strip(TabbedPanePeer peer) {
+            this.peer = peer;
+            setUIID("TabsContainer");
+        }
+
+        void relayout() {
+            setShouldLayout(true);
+            layoutContainer();
+        }
+
+        @Override
+        public void repaint() {
+            if (peer == null || !peer.routeRepaint()) {
+                super.repaint();
+            }
+        }
+    }
+
+    /// One tab: a toggle button that reports being chosen.
+    private static final class TabButton extends RadioButton implements ActionListener<ActionEvent> {
+        private final TabbedPanePeer peer;
+        private int ink = -1;
+
+        TabButton(TabbedPanePeer peer, int index) {
+            this.peer = peer;
+            setToggle(true);
+            setUIID("Tab");
+            setName("tab" + index);
+            addActionListener(this);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent evt) {
+            peer.chosen(this);
+        }
+
+        /// Writes the title in `rgb` whatever the state of the tab, or in
+        /// the theme's colors again for -1.
+        void ink(int rgb) {
+            if (rgb == ink) {
+                return;
+            }
+            if (ink >= 0) {
+                // The styles hold the color that was asked for last; the
+                // theme's come back with the styles themselves.
+                setUIID("Tab");
+            }
+            ink = rgb;
+            if (rgb >= 0) {
+                getAllStyles().setFgColor(rgb);
+            }
+        }
+
+        /// The thickness of the bar that marks the selected tab.
+        private static int bar() {
+            return Math.max(2, Units.toDevice(3));
+        }
+
+        /// Room for the bar on the side it is on and as much opposite, so
+        /// that it does not strike through a title in a theme that gives
+        /// its tabs no padding and the title stays in the middle.
+        @Override
+        protected Dimension calcPreferredSize() {
+            Dimension d = super.calcPreferredSize();
+            int room = 2 * (bar() + Units.toDevice(1));
+            if (peer.placement == TabbedPanePeer.LEFT || peer.placement == TabbedPanePeer.RIGHT) {
+                return new Dimension(d.getWidth() + room, d.getHeight());
+            }
+            return new Dimension(d.getWidth(), d.getHeight() + room);
+        }
+
+        @Override
+        public void paint(com.codename1.ui.Graphics g) {
+            int cx = g.getClipX();
+            int cy = g.getClipY();
+            int cw = g.getClipWidth();
+            int ch = g.getClipHeight();
+            super.paint(g);
+            if (!isSelected()) {
+                return;
+            }
+            // Painting the text may leave the clip narrowed to it.
+            g.setClip(cx, cy, cw, ch);
+            int bar = bar();
+            int x = getX();
+            int y = getY();
+            int w = getWidth();
+            int h = getHeight();
+            // A toggled button is drawn in its pressed style. The names of
+            // the sides are qualified: a button inherits constants of the
+            // same names with other values.
+            g.setColor(getPressedStyle().getFgColor());
+            int alpha = g.getAlpha();
+            g.setAlpha(255);
+            if (peer.placement == TabbedPanePeer.BOTTOM) {
+                g.fillRect(x, y, w, Math.min(bar, h));
+            } else if (peer.placement == TabbedPanePeer.LEFT) {
+                g.fillRect(x + Math.max(0, w - bar), y, Math.min(bar, w), h);
+            } else if (peer.placement == TabbedPanePeer.RIGHT) {
+                g.fillRect(x, y, Math.min(bar, w), h);
+            } else {
+                g.fillRect(x, y + Math.max(0, h - bar), w, Math.min(bar, h));
+            }
+            g.setAlpha(alpha);
+        }
+
+        @Override
+        public void repaint() {
+            if (peer == null || !peer.routeRepaint()) {
+                super.repaint();
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TextAreaPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TextAreaPeer.java
new file mode 100644
index 00000000000..49198b19224
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TextAreaPeer.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+
+/// The peer of a multi line text component: a Codename One text area,
+/// edited natively, that grows with its text.
+public class TextAreaPeer extends com.codename1.ui.TextArea implements Peer {
+
+    private final PeerSupport support;
+
+    public TextAreaPeer(Component owner) {
+        setSingleLineTextArea(false);
+        setGrowByContent(true);
+        support = new PeerSupport(owner, this);
+        support.trackFocus();
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        super.paint(g);
+        super.paintBorder(g);
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TextFieldPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TextFieldPeer.java
new file mode 100644
index 00000000000..4d59d15393c
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TextFieldPeer.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.ui.Graphics;
+
+/// The peer of a text field: a Codename One text field, edited natively.
+public class TextFieldPeer extends com.codename1.ui.TextField implements Peer {
+
+    private final PeerSupport support;
+
+    public TextFieldPeer(Component owner) {
+        support = new PeerSupport(owner, this);
+        support.trackFocus();
+        // One line never scrolls down, and a desktop theme would draw
+        // its scroll bar down the side of the field all the same.
+        setScrollVisible(false);
+    }
+
+    @Override
+    public PeerSupport support() {
+        return support;
+    }
+
+    @Override
+    public boolean nativeLook() {
+        return true;
+    }
+
+    @Override
+    public void paintNativeLook(Graphics g) {
+        support.paintStyleBackground(g);
+        super.paint(g);
+        super.paintBorder(g);
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        support.paintOwner(g);
+    }
+
+    @Override
+    protected void paintBorder(Graphics g) {
+    }
+
+    @Override
+    public void repaint() {
+        if (support == null || !support.routeRepaint()) {
+            super.repaint();
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TreeIcons.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TreeIcons.java
new file mode 100644
index 00000000000..87a86fa9535
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/TreeIcons.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.swing.Icon;
+
+/// The icons a tree gives its nodes when the application sets none: a
+/// closed folder, an open folder and a sheet of paper for a leaf.
+///
+/// They are drawn, not loaded, in tones of the text color of the component
+/// they are painted on over its background, so they read in a light and in
+/// a dark theme and need no resource in the application.
+public final class TreeIcons implements Icon {
+
+    private static final int SIZE = 16;
+    private static final int CLOSED_KIND = 0;
+    private static final int OPEN_KIND = 1;
+    private static final int LEAF_KIND = 2;
+
+    /// A folder that is closed.
+    public static final Icon CLOSED = new TreeIcons(CLOSED_KIND);
+    /// A folder that is open.
+    public static final Icon OPEN = new TreeIcons(OPEN_KIND);
+    /// A sheet of paper.
+    public static final Icon LEAF = new TreeIcons(LEAF_KIND);
+
+    private final int kind;
+
+    private TreeIcons(int kind) {
+        this.kind = kind;
+    }
+
+    @Override
+    public int getIconWidth() {
+        return SIZE;
+    }
+
+    @Override
+    public int getIconHeight() {
+        return SIZE;
+    }
+
+    @Override
+    public void paintIcon(Component c, Graphics g, int x, int y) {
+        Color fg = c != null ? c.getForeground() : null;
+        Color bg = c != null ? c.getBackground() : null;
+        if (fg == null) {
+            fg = Color.DARK_GRAY;
+        }
+        if (bg == null) {
+            bg = Color.WHITE;
+        }
+        Color line = CellTheme.mix(bg, fg, 0.7f);
+        Color fill = CellTheme.mix(bg, fg, 0.3f);
+        Color saved = g.getColor();
+        if (kind == LEAF_KIND) {
+            // A sheet with its top right corner folded.
+            g.setColor(CellTheme.mix(bg, fg, 0.06f));
+            g.fillRect(x + 3, y + 1, 10, 14);
+            g.setColor(line);
+            g.drawLine(x + 3, y + 1, x + 9, y + 1);
+            g.drawLine(x + 3, y + 1, x + 3, y + 14);
+            g.drawLine(x + 3, y + 14, x + 12, y + 14);
+            g.drawLine(x + 12, y + 4, x + 12, y + 14);
+            g.drawLine(x + 9, y + 1, x + 12, y + 4);
+            g.drawLine(x + 9, y + 1, x + 9, y + 4);
+            g.drawLine(x + 9, y + 4, x + 12, y + 4);
+        } else {
+            // The tab, the back, and the front: lower when the folder is open.
+            g.setColor(line);
+            g.fillRect(x + 1, y + 2, 6, 3);
+            g.fillRect(x + 1, y + 4, 14, 10);
+            g.setColor(fill);
+            if (kind == OPEN_KIND) {
+                g.fillPolygon(new int[]{x + 3, x + 16, x + 14, x + 1}, new int[]{y + 8, y + 8, y + 14, y + 14}, 4);
+            } else {
+                g.fillRect(x + 2, y + 6, 12, 7);
+            }
+        }
+        g.setColor(saved);
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Units.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Units.java
new file mode 100644
index 00000000000..b40ae157ba2
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/Units.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.ui.Display;
+
+/// The size of an AWT pixel.
+///
+/// Desktop code lays itself out in pixels and assumes roughly 96 of them to
+/// the inch: a 24 pixel row, a 12 point font. A phone packs three or four
+/// device pixels into that distance, so every AWT coordinate is a *logical*
+/// pixel of 1/96 inch and this class holds the number of device pixels one
+/// of them covers. Component bounds, font sizes and everything drawn through
+/// [G2D] are multiplied by it on the way to Codename One, and peer bounds
+/// are snapped to whole device pixels edge by edge, so two components that
+/// touch in logical pixels touch on the screen too.
+///
+/// The scale comes from the display's density. The Display property
+/// `desktopcompat.scale` overrides it for an application that wants its
+/// pixels larger or smaller, and [#setScale(float)] overrides both -- that
+/// is what tests use to get round numbers.
+public final class Units {
+
+    private static float override;
+    private static float property = -1;
+
+    private Units() {
+    }
+
+    /// Device pixels per logical pixel.
+    public static float scale() {
+        if (override > 0) {
+            return override;
+        }
+        if (!Display.isInitialized()) {
+            return 1f;
+        }
+        Display d = Display.getInstance();
+        if (property < 0) {
+            property = 0;
+            String p = d.getProperty("desktopcompat.scale", null);
+            if (p != null && p.length() > 0) {
+                try {
+                    property = Float.parseFloat(p);
+                } catch (NumberFormatException e) {
+                    property = 0;
+                }
+            }
+        }
+        if (property > 0) {
+            return property;
+        }
+        // convertToPixels takes millimetres; a logical pixel is 25.4/96 of one.
+        float perMm = d.convertToPixels(1000, true) / 1000f;
+        float s = perMm * 25.4f / 96f;
+        return s > 0 ? s : 1f;
+    }
+
+    /// Fixes the scale, or with 0 goes back to the display's own. Also
+    /// forgets the `desktopcompat.scale` property so it is read again.
+    public static void setScale(float scale) {
+        override = scale;
+        property = -1;
+    }
+
+    /// The device pixel a logical coordinate snaps to.
+    public static int toDevice(float logical) {
+        return Math.round(logical * scale());
+    }
+
+    /// The device length of the logical span `[position, position + size)`:
+    /// the distance between its two snapped edges, not the snapped length,
+    /// so adjacent spans never gap or overlap.
+    public static int toDeviceSize(int position, int size) {
+        float s = scale();
+        return Math.round((position + size) * s) - Math.round(position * s);
+    }
+
+    /// The logical pixel a device coordinate falls in, and the largest
+    /// logical length that fits in `device` pixels.
+    public static int toLogical(int device) {
+        return (int) Math.floor(device / scale() + 0.001f);
+    }
+
+    /// The smallest logical length that covers `device` pixels; what a
+    /// preferred size measured by Codename One becomes.
+    public static int toLogicalCeil(int device) {
+        return (int) Math.ceil(device / scale() - 0.001f);
+    }
+
+    /// A device coordinate in logical pixels, unrounded.
+    public static float toLogicalExact(float device) {
+        return device / scale();
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ViewportPeer.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ViewportPeer.java
new file mode 100644
index 00000000000..f6abd69ba21
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/ViewportPeer.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.ui.Graphics;
+import com.codename1.ui.events.ScrollListener;
+import com.codename1.ui.geom.Dimension;
+
+/// The peer of a viewport: a Codename One container that scrolls the peer
+/// of the view, so dragging, flinging and the mouse wheel behave as they
+/// do everywhere else on the device.
+///
+/// The view's peer stays at the origin and Codename One's scroll position
+/// moves it; the area that can be scrolled is the size of that peer.
+/// Codename One hands `paint` a context already shifted by the scroll
+/// position, which is undone for the viewport's own painting and applied
+/// again for the children.
+public class ViewportPeer extends ContainerPeer {
+
+    /// Hears about the scroll position changing, in device pixels.
+    public interface Listener {
+        void scrolled(int x, int y);
+    }
+
+    private final Listener listener;
+    private boolean silent;
+
+    public ViewportPeer(Container owner, Listener l) {
+        super(owner);
+        listener = l;
+        addScrollListener(new ScrollListener() {
+            @Override
+            public void scrollChanged(int scrollX, int scrollY, int oldscrollX, int oldscrollY) {
+                if (!silent) {
+                    listener.scrolled(scrollX, scrollY);
+                }
+            }
+        });
+    }
+
+    /// Scrolls without telling the listener.
+    public void scrollTo(int x, int y) {
+        silent = true;
+        try {
+            if (x != getScrollX()) {
+                setScrollX(x);
+            }
+            if (y != getScrollY()) {
+                setScrollY(y);
+            }
+        } finally {
+            silent = false;
+        }
+    }
+
+    @Override
+    public Dimension getScrollDimension() {
+        if (getComponentCount() > 0) {
+            com.codename1.ui.Component view = getComponentAt(0);
+            return new Dimension(view.getWidth(), view.getHeight());
+        }
+        return new Dimension(getWidth(), getHeight());
+    }
+
+    @Override
+    public void paint(Graphics g) {
+        boolean scrolls = isScrollable();
+        int sx = scrolls ? getScrollX() : 0;
+        int sy = scrolls ? getScrollY() : 0;
+        g.translate(sx, sy);
+        try {
+            support().paintOwner(g);
+        } finally {
+            g.translate(-sx, -sy);
+        }
+    }
+
+    @Override
+    public void paintNativeChildren(Graphics g) {
+        boolean scrolls = isScrollable();
+        int sx = scrolls ? getScrollX() : 0;
+        int sy = scrolls ? getScrollY() : 0;
+        g.translate(-sx, -sy);
+        try {
+            super.paintNativeChildren(g);
+        } finally {
+            g.translate(sx, sy);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/WindowHost.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/WindowHost.java
new file mode 100644
index 00000000000..bb970858f51
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/WindowHost.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.ui.Command;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import java.util.List;
+
+/// What puts an AWT window on the screen.
+///
+/// There are three in the layer: a form that the window fills
+/// ([FrameForm]), a Codename One dialog floating over the current form
+/// ([DialogForm]), and a window of the platform's window manager where the
+/// port has one. [WindowHosts] picks; tests supply their own through
+/// [SecondaryWindows].
+public interface WindowHost {
+
+    /// Puts the window on the screen, or in front when it is there
+    /// already.
+    void open();
+
+    /// Takes the window off the screen.
+    void close();
+
+    /// The window was disposed of and will not use this host again.
+    void release();
+
+    void title(String title);
+
+    /// The icon of the window, `null` for none. Only a window of the
+    /// window manager shows one.
+    void icon(Image icon);
+
+    /// The application moved or resized the window; its bounds are the
+    /// new ones.
+    void bounds();
+
+    void resizable(boolean resizable);
+
+    void decorated(boolean decorated);
+
+    /// The extended state of a frame changed: a combination of the
+    /// `Frame` state bits.
+    void state(int state);
+
+    /// Replaces the commands that stand for the window's menu bar.
+    void commands(List<Command> commands);
+
+    /// Whether [#commands] puts the commands where the user can reach
+    /// them. When it does the menu bar itself is not shown.
+    boolean takesCommands();
+
+    /// The form, when the host is one; `null` for a window of the window
+    /// manager.
+    Form form();
+
+    /// Whether the host decides the size of the window: it fills the
+    /// display whatever size the application asked for.
+    boolean fillsDisplay();
+
+    /// Whether the host can be opened again after it was closed.
+    boolean reusable();
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/WindowHosts.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/WindowHosts.java
new file mode 100644
index 00000000000..15e781b88ee
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/WindowHosts.java
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import com.codename1.ui.events.WheelEvent;
+import java.util.ArrayList;
+
+/// The windows of the application: which exist, which are showing and in
+/// what order, and what shows each of them.
+///
+/// **Both form factors.** The first window an application shows always
+/// fills a form. What happens to the ones after it depends on the port:
+///
+/// - Where Codename One has a window manager
+///   (`com.codename1.ui.Desktop.isSupported()`), each further window is a
+///   window of its own, with the size, position, title and icon the
+///   application gave it.
+/// - Everywhere else a further frame is a form shown over the one before
+///   it, with a back command that asks it to close, and a dialog floats
+///   over the current form at the size it was packed to, clamped to the
+///   display. Only the window on top receives input, so on a phone every
+///   dialog behaves as a modal one for the user, whether or not it blocks
+///   its caller.
+public final class WindowHosts {
+
+    private static final ArrayList<Window> SHOWING = new ArrayList<Window>();
+    private static final ArrayList<Window> DISPLAYABLE = new ArrayList<Window>();
+    private static final SecondaryWindows NATIVE = new NativeWindows();
+
+    private static SecondaryWindows secondary = NATIVE;
+    private static Runnable idleHook;
+    private static Runnable exitHook;
+    private static int shows;
+    private static boolean idlePending;
+    private static boolean nativeWindows = true;
+
+    private WindowHosts() {
+    }
+
+    /// Replaces what opens the windows after the first; `null` restores
+    /// the window manager. For tests.
+    public static void setSecondaryWindows(SecondaryWindows s) {
+        secondary = s == null ? NATIVE : s;
+    }
+
+    /// Says whether the windows after the first are windows of the
+    /// platform's window manager where it has one, which is the default.
+    /// With `false` every window stays inside the application's own: a
+    /// frame is a form and a dialog floats over the current form, as on a
+    /// phone.
+    public static void setNativeWindows(boolean value) {
+        nativeWindows = value;
+    }
+
+    /// Whether [#setNativeWindows] left the window manager in use.
+    public static boolean isNativeWindows() {
+        return nativeWindows;
+    }
+
+    /// Sets what runs, a moment later, whenever the last showing window
+    /// was hidden or disposed of. The lifecycle uses it.
+    public static void setIdleHook(Runnable r) {
+        idleHook = r;
+    }
+
+    /// Replaces what `EXIT_ON_CLOSE` does; `null` restores the default,
+    /// which is library mode (see [#exit]). For tests and the lifecycle.
+    public static void setExitHook(Runnable r) {
+        exitHook = r;
+    }
+
+    /// Ends the Swing application: what `EXIT_ON_CLOSE` does, and the
+    /// last window being disposed of.
+    ///
+    /// Where the layer IS the application, [DesktopLifecycle] installs the
+    /// hook that exits it. With no hook the Swing windows are a part of a
+    /// Codename One application that has a main class of its own (library
+    /// mode), and ending them must not end that: every window is disposed
+    /// of, the one on top first, which shows the form the first of them was
+    /// shown over. The application goes on.
+    public static void exit() {
+        if (exitHook != null) {
+            exitHook.run();
+            return;
+        }
+        Window[] ws = windows();
+        for (int i = ws.length - 1; i >= 0; i--) {
+            ws[i].dispose();
+        }
+    }
+
+    /// The window on top of the others, which is the active one; `null`
+    /// when none is showing.
+    public static Window active() {
+        return SHOWING.isEmpty() ? null : SHOWING.get(SHOWING.size() - 1);
+    }
+
+    /// The showing windows, the one on top last.
+    public static Window[] showing() {
+        return SHOWING.toArray(new Window[SHOWING.size()]);
+    }
+
+    /// Every window that was shown or packed and not disposed of since.
+    public static Window[] windows() {
+        return DISPLAYABLE.toArray(new Window[DISPLAYABLE.size()]);
+    }
+
+    /// A window became displayable.
+    public static void registered(Window w) {
+        if (!DISPLAYABLE.contains(w)) {
+            DISPLAYABLE.add(w);
+        }
+    }
+
+    /// A window was disposed of.
+    public static void released(Window w) {
+        DISPLAYABLE.remove(w);
+        idle();
+    }
+
+    /// The host that shows `w`, given the one it had before, if any;
+    /// `null` when there is no display.
+    public static WindowHost open(Window w, WindowHost existing) {
+        // Library mode has no lifecycle to install the application's
+        // resources, bundles and services first; the first desktop
+        // component it wraps or window it shows does. Idempotent.
+        com.codename1.generated.compat.CompatRegistry.cn1Install();
+        if (!Display.isInitialized()) {
+            return null;
+        }
+        if (existing != null && existing.reusable()) {
+            return existing;
+        }
+        // The first window always fills the application's own form; only
+        // a window shown over another one is a secondary window or floats.
+        boolean over = !SHOWING.isEmpty() && !(SHOWING.size() == 1 && SHOWING.get(0) == w);
+        if (over && nativeWindows && secondary.supported()) {
+            WindowHost h = secondary.open(w);
+            if (h != null) {
+                return h;
+            }
+        }
+        boolean floats = w instanceof Dialog ? Display.getInstance().getCurrent() != null
+                : over && !(w instanceof Frame);
+        return floats ? new DialogForm(w) : new FrameForm(w);
+    }
+
+    /// How many times a window was put on the screen so far.
+    public static int shownCount() {
+        return shows;
+    }
+
+    /// `w` was put on the screen or brought to the front: it becomes the
+    /// active window.
+    public static void shown(Window w) {
+        shows++;
+        Window old = active();
+        SHOWING.remove(w);
+        SHOWING.add(w);
+        Dnd.listen(w);
+        if (old != w) {
+            if (old != null) {
+                old.cn1Activated(false, w);
+            }
+            w.cn1Activated(true, old);
+        }
+    }
+
+    /// `w` left the screen; the window below it, if any, becomes active.
+    public static void hidden(Window w) {
+        boolean was = active() == w;
+        if (!SHOWING.remove(w)) {
+            return;
+        }
+        if (was) {
+            Window next = active();
+            w.cn1Activated(false, next);
+            if (next != null) {
+                next.cn1Activated(true, w);
+            }
+        }
+        idle();
+    }
+
+    private static void idle() {
+        // Hiding a window and disposing of it both come here; one pass of
+        // the hook answers both.
+        if (!idlePending && SHOWING.isEmpty() && idleHook != null && Display.isInitialized()) {
+            idlePending = true;
+            Display.getInstance().callSerially(new Runnable() {
+                @Override
+                public void run() {
+                    idlePending = false;
+                    // The hook as it is now: it may have been replaced
+                    // since, and a window may have been shown.
+                    Runnable hook = idleHook;
+                    if (hook != null && SHOWING.isEmpty()) {
+                        hook.run();
+                    }
+                }
+            });
+        }
+    }
+
+    /// The form to go back to when the form of `w` leaves the screen: the
+    /// form of the topmost other showing window that fills one, else
+    /// `fallback` unless that is the form of a window too.
+    public static Form formBelow(Window w, Form fallback) {
+        for (int i = SHOWING.size() - 1; i >= 0; i--) {
+            Window o = SHOWING.get(i);
+            if (o != w && o.cn1Host() instanceof FrameForm) {
+                return (FrameForm) o.cn1Host();
+            }
+        }
+        return fallback instanceof FrameForm || fallback instanceof DialogForm ? null : fallback;
+    }
+
+    /// Sends the wheel events of a window's root peer to the window.
+    static void listenWheel(final Window w, com.codename1.ui.Component rootPeer) {
+        rootPeer.addMouseWheelListener(new ActionListener<ActionEvent>() {
+            @Override
+            public void actionPerformed(ActionEvent evt) {
+                if (evt instanceof WheelEvent) {
+                    EventBridge.wheel(w, (WheelEvent) evt);
+                }
+            }
+        });
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/package-info.java b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/package-info.java
new file mode 100644
index 00000000000..47f244e9c48
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/desktopcompat/rt/package-info.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The runtime under the AWT and Swing classes: unit conversion
+/// ([com.codename1.desktopcompat.rt.Units]), the graphics that draws
+/// through a Codename One context ([com.codename1.desktopcompat.rt.G2D]),
+/// the peers that show components, and the bridges that carry layout and
+/// input between the two toolkits.
+///
+/// Nothing here has a desktop counterpart; applications do not name these
+/// classes.
+package com.codename1.desktopcompat.rt;
diff --git a/maven/swing-compat/src/main/java/com/codename1/generated/compat/CompatRegistry.java b/maven/swing-compat/src/main/java/com/codename1/generated/compat/CompatRegistry.java
new file mode 100644
index 00000000000..5581d232472
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/generated/compat/CompatRegistry.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.generated.compat;
+
+/// A placeholder for the registry the build generates into every
+/// application with desktop sources, so that the layer's lifecycle, which
+/// installs it, compiles.
+///
+/// The build's remap step writes the real class under this name -- see
+/// `com.codename1.impl.compat.CompatRegistryBase` -- and never copies this
+/// one out of the jar. The Swing and JavaFX layers each carry one; neither
+/// ships.
+public final class CompatRegistry {
+
+    private CompatRegistry() {
+    }
+
+    /// Records what the application ships and installs the registry; here,
+    /// where nothing was generated, nothing.
+    public static void cn1Install() {
+    }
+}
diff --git a/maven/swing-compat/src/main/java/com/codename1/generated/compat/package-info.java b/maven/swing-compat/src/main/java/com/codename1/generated/compat/package-info.java
new file mode 100644
index 00000000000..fdcd39f3fc5
--- /dev/null
+++ b/maven/swing-compat/src/main/java/com/codename1/generated/compat/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The class the build generates into every application with desktop
+/// sources; this module carries only a placeholder of it, which never ships.
+package com.codename1.generated.compat;
diff --git a/maven/swing-compat/src/test/java/.gitkeep b/maven/swing-compat/src/test/java/.gitkeep
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ApiShapeTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ApiShapeTest.java
new file mode 100644
index 00000000000..9086f6db74d
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ApiShapeTest.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Holds every public class of the layer to the shape of the JDK class it
+/// stands in for.
+///
+/// An application is compiled against the JDK's `java.awt` and `javax.swing`
+/// and only then relocated onto this module, so a member that is spelled
+/// differently here -- another parameter type, another return type, a method
+/// the JDK never had -- is a link error on the device or an API nobody can
+/// reach. For each public class under `com.codename1.desktopcompat.java` and
+/// `.javax` the JDK class of the original name is loaded and compared:
+/// every public or protected constructor, method and field must exist there
+/// with the same descriptor once the package prefix is mapped back, the
+/// superclass must map to an ancestor of the JDK class and every interface
+/// to one the JDK class implements. Members named `cn1...` are the layer's
+/// own hooks and are exempt. "The JDK" in a message means the library
+/// the class was compared with, which for `org.jdesktop` is SwingX.
+///
+/// The directory read is `target/classes`, or the `swingcompat.classes`
+/// system property.
+public class ApiShapeTest {
+
+    private static final String PREFIX = "com.codename1.desktopcompat.";
+
+    /// JDK classes that a release after Java 8 declared final, by the JDK's
+    /// own name. An application may be compiled against any JDK, so the layer
+    /// keeps such a class as open as the most permissive of them has it: a
+    /// subclass that compiled must still link. The allowance is one way only.
+    /// A class named here that the running JDK has final may be open in the
+    /// layer; one the running JDK has open must be open here as ever.
+    private static final Set<String> FINAL_IN_LATER_JDKS = new HashSet<String>(Arrays.asList(
+            // Open in Java 8 and 17, final in Java 19 and later.
+            "javax.swing.GroupLayout$SequentialGroup"));
+
+    /// API the layer has that a release after Java 8 added, by the JDK's
+    /// own name: a class, a package (ending in a dot) or a member. This
+    /// test runs on Java 8, whose class library cannot vouch for them, so
+    /// on Java 8 -- and only there -- a problem that names one is dropped.
+    /// On a later JDK every one of them is compared like the rest.
+    private static final String[] AFTER_JAVA_8 = {
+        "java.awt.Taskbar", "java.awt.desktop.", "java.awt.Toolkit.getMenuShortcutKeyMaskEx()",
+        "java.awt.Desktop$Action.APP_", "java.awt.Desktop$Action.BROWSE_FILE_DIR",
+        "java.awt.Desktop$Action.MOVE_TO_TRASH", "java.awt.Desktop.setPreferencesHandler(",
+        "javax.swing.text.JTextComponent.viewToModel2D(", "javax.swing.text.JTextComponent.modelToView2D("};
+
+    private final List<String> problems = new ArrayList<String>() {
+        @Override
+        public boolean add(String problem) {
+            if (System.getProperty("java.specification.version", "").startsWith("1.")) {
+                for (String later : AFTER_JAVA_8) {
+                    if (problem.contains(PREFIX + later)) {
+                        return false;
+                    }
+                }
+            }
+            return super.add(problem);
+        }
+    };
+    private int checked;
+
+    @Test
+    public void everyPublicClassMatchesTheJdk() throws Exception {
+        File root = new File(System.getProperty("swingcompat.classes", "target/classes"));
+        File base = new File(root, "com/codename1/desktopcompat");
+        walk(new File(base, "java"), "com.codename1.desktopcompat.java");
+        walk(new File(base, "javax"), "com.codename1.desktopcompat.javax");
+        if (!problems.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(problems.size()).append(" API shape problem(s):\n");
+            for (String p : problems) {
+                sb.append("  ").append(p).append('\n');
+            }
+            fail(sb.toString());
+        }
+        assertTrue("no classes found under " + base, checked > 0);
+    }
+
+    /// The same comparison for the SwingX subset under
+    /// `com.codename1.desktopcompat.org.jdesktop`, against the real SwingX
+    /// jar, which is a test dependency of this module for that purpose
+    /// alone.
+    @Test
+    public void everySwingXClassMatchesSwingX() throws Exception {
+        File root = new File(System.getProperty("swingcompat.classes", "target/classes"));
+        File base = new File(root, "com/codename1/desktopcompat");
+        Class.forName("org.jdesktop.swingx.JXTable", false, ClassLoader.getSystemClassLoader());
+        walk(new File(base, "org"), "com.codename1.desktopcompat.org");
+        if (!problems.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(problems.size()).append(" SwingX API shape problem(s):\n");
+            for (String p : problems) {
+                sb.append("  ").append(p).append('\n');
+            }
+            fail(sb.toString());
+        }
+        assertTrue("no classes found under " + base + "/org", checked > 0);
+    }
+
+    private void walk(File dir, String pkg) throws Exception {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                walk(f, pkg + "." + f.getName());
+            } else if (f.getName().endsWith(".class") && !f.getName().equals("package-info.class")) {
+                String simple = f.getName().substring(0, f.getName().length() - 6);
+                check(Class.forName(pkg + "." + simple, false, ApiShapeTest.class.getClassLoader()));
+            }
+        }
+    }
+
+    private static boolean api(int modifiers) {
+        return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers);
+    }
+
+    /// Whether the class and every class it is nested in can be named by an
+    /// application.
+    private static boolean visible(Class<?> c) {
+        for (Class<?> k = c; k != null; k = k.getDeclaringClass()) {
+            if (!api(k.getModifiers())) {
+                return false;
+            }
+        }
+        return !c.isAnonymousClass() && !c.isLocalClass();
+    }
+
+    private void check(Class<?> ours) {
+        if (!visible(ours)) {
+            return;
+        }
+        checked++;
+        String name = ours.getName();
+        Class<?> real;
+        try {
+            real = Class.forName(name.substring(PREFIX.length()), false, ClassLoader.getSystemClassLoader());
+        } catch (ClassNotFoundException e) {
+            problems.add(name + ": the JDK has no such class");
+            return;
+        } catch (LinkageError e) {
+            problems.add(name + ": the JDK class does not load: " + e);
+            return;
+        }
+        if (ours.isInterface() != real.isInterface()) {
+            problems.add(name + ": interface here but not in the JDK, or the reverse");
+        }
+        boolean realFinal = Modifier.isFinal(real.getModifiers());
+        if (realFinal != Modifier.isFinal(ours.getModifiers())
+                && !(realFinal && FINAL_IN_LATER_JDKS.contains(real.getName()))) {
+            problems.add(name + ": final differs from the JDK");
+        }
+        if (Modifier.isAbstract(ours.getModifiers()) && !Modifier.isAbstract(real.getModifiers())) {
+            problems.add(name + ": abstract here but instantiable in the JDK");
+        }
+        Class<?> sup = ours.getSuperclass();
+        if (sup != null && sup != Object.class) {
+            Class<?> mapped = map(sup);
+            if (mapped == null || !mapped.isAssignableFrom(real) || mapped.isInterface()) {
+                problems.add(name + ": superclass " + sup.getName() + " is not an ancestor of the JDK class");
+            }
+        }
+        for (Class<?> i : ours.getInterfaces()) {
+            Class<?> mapped = map(i);
+            if (mapped == null || !mapped.isAssignableFrom(real)) {
+                problems.add(name + ": interface " + i.getName() + " is not implemented by the JDK class");
+            }
+        }
+        for (Constructor<?> c : ours.getDeclaredConstructors()) {
+            if (!api(c.getModifiers()) || c.isSynthetic()) {
+                continue;
+            }
+            Class<?>[] params = mapAll(c.getParameterTypes());
+            boolean found = false;
+            if (params != null) {
+                try {
+                    found = api(real.getDeclaredConstructor(params).getModifiers());
+                } catch (NoSuchMethodException e) {
+                    found = false;
+                }
+            }
+            if (!found) {
+                problems.add(name + ": constructor " + c + " is not in the JDK");
+            }
+        }
+        for (Method m : ours.getDeclaredMethods()) {
+            if (!api(m.getModifiers()) || m.isSynthetic() || m.isBridge() || m.getName().startsWith("cn1")) {
+                continue;
+            }
+            Class<?>[] params = mapAll(m.getParameterTypes());
+            Class<?> ret = map(m.getReturnType());
+            Method found = params == null || ret == null ? null : findMethod(real, m.getName(), params, ret);
+            if (found == null) {
+                problems.add(name + ": method " + m + " is not in the JDK");
+            } else if (Modifier.isStatic(found.getModifiers()) != Modifier.isStatic(m.getModifiers())) {
+                problems.add(name + ": method " + m + " is static here but not in the JDK, or the reverse");
+            } else if (Modifier.isAbstract(m.getModifiers()) && !Modifier.isAbstract(found.getModifiers())) {
+                problems.add(name + ": method " + m + " is abstract here but concrete in the JDK");
+            }
+        }
+        for (Field f : ours.getDeclaredFields()) {
+            if (!api(f.getModifiers()) || f.isSynthetic() || f.getName().startsWith("cn1")) {
+                continue;
+            }
+            Class<?> type = map(f.getType());
+            Field found = type == null ? null : findField(real, f.getName(), type);
+            if (found == null) {
+                problems.add(name + ": field " + f + " is not in the JDK");
+            } else if (Modifier.isStatic(found.getModifiers()) != Modifier.isStatic(f.getModifiers())) {
+                problems.add(name + ": field " + f + " is static here but not in the JDK, or the reverse");
+            }
+        }
+    }
+
+    private static Method findMethod(Class<?> real, String name, Class<?>[] params, Class<?> ret) {
+        if (real == null) {
+            return null;
+        }
+        for (Method m : real.getDeclaredMethods()) {
+            if (m.getName().equals(name) && api(m.getModifiers()) && m.getReturnType() == ret
+                    && java.util.Arrays.equals(m.getParameterTypes(), params)) {
+                return m;
+            }
+        }
+        Method up = findMethod(real.getSuperclass(), name, params, ret);
+        if (up != null) {
+            return up;
+        }
+        for (Class<?> i : real.getInterfaces()) {
+            up = findMethod(i, name, params, ret);
+            if (up != null) {
+                return up;
+            }
+        }
+        return null;
+    }
+
+    private static Field findField(Class<?> real, String name, Class<?> type) {
+        if (real == null) {
+            return null;
+        }
+        for (Field f : real.getDeclaredFields()) {
+            if (f.getName().equals(name) && api(f.getModifiers()) && f.getType() == type) {
+                return f;
+            }
+        }
+        Field up = findField(real.getSuperclass(), name, type);
+        if (up != null) {
+            return up;
+        }
+        for (Class<?> i : real.getInterfaces()) {
+            up = findField(i, name, type);
+            if (up != null) {
+                return up;
+            }
+        }
+        return null;
+    }
+
+    private static Class<?>[] mapAll(Class<?>[] types) {
+        Class<?>[] out = new Class<?>[types.length];
+        for (int i = 0; i < types.length; i++) {
+            out[i] = map(types[i]);
+            if (out[i] == null) {
+                return null;
+            }
+        }
+        return out;
+    }
+
+    /// The JDK type a type of ours stands for, or null when it is a layer
+    /// type the JDK has no counterpart of.
+    private static Class<?> map(Class<?> c) {
+        if (c.isArray()) {
+            Class<?> component = map(c.getComponentType());
+            return component == null ? null : java.lang.reflect.Array.newInstance(component, 0).getClass();
+        }
+        String name = c.getName();
+        if (!name.startsWith(PREFIX)) {
+            return c;
+        }
+        try {
+            return Class.forName(name.substring(PREFIX.length()), false, ClassLoader.getSystemClassLoader());
+        } catch (ClassNotFoundException e) {
+            return null;
+        } catch (LinkageError e) {
+            return null;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ApplicationWindowTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ApplicationWindowTest.java
new file mode 100644
index 00000000000..a55c45c4bf1
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ApplicationWindowTest.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.ui.Toolbar;
+import org.junit.After;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/// The frame that fills the application's own window on a desktop: the
+/// window takes the frame's title and size, and the first frame painted
+/// for a display size is followed by another.
+public class ApplicationWindowTest extends KernelTestBase {
+
+    @After
+    public void reset() {
+        HeadlessImplementation.setDesktop(false);
+        HeadlessImplementation.nativeTitle = false;
+        HeadlessImplementation.windowTitle = null;
+        HeadlessImplementation.windowSize = null;
+        Toolbar.setGlobalToolbar(false);
+    }
+
+    private static void desktop() {
+        HeadlessImplementation.setDesktop(true);
+        HeadlessImplementation.nativeTitle = true;
+        HeadlessImplementation.windowTitle = null;
+        HeadlessImplementation.windowSize = null;
+    }
+
+    /// The port pushes a title only when asked to, and Codename One asks
+    /// only for a title set on the form that is showing. A frame is titled
+    /// before it is shown.
+    @Test
+    public void theTitleGivenBeforeShowingReachesTheWindow() {
+        desktop();
+        JFrame f = new JFrame("Ledger");
+        f.getContentPane().add(new JLabel("content"));
+        f.setSize(640, 480);
+        show(f);
+        assertEquals("Ledger", HeadlessImplementation.windowTitle);
+        f.setTitle("Ledger - accounts.txt");
+        assertEquals("Ledger - accounts.txt", HeadlessImplementation.windowTitle);
+    }
+
+    @Test
+    public void theWindowIsAskedForTheSizeOfTheFrameInDevicePixels() {
+        desktop();
+        // A frame sizes the window only when the window is the
+        // application's own: nothing showing yet, or another frame. An
+        // earlier test of this JVM may have left a form that is no frame's,
+        // which would make this frame a guest, so a frame is shown first.
+        show(new JFrame("Earlier"));
+        HeadlessImplementation.windowSize = null;
+        JFrame f = new JFrame("Ledger");
+        f.getContentPane().add(new JLabel("content"));
+        f.setSize(400, 300);
+        show(f);
+        assertArrayEquals(new int[] {Units.toDevice(400), Units.toDevice(300)}, HeadlessImplementation.windowSize);
+    }
+
+    /// A desktop theme gives every form a toolbar, and a form with a
+    /// toolbar is laid out when its title is set, which is before it is
+    /// shown. That layout gives the frame the size of the display under
+    /// the title area: read then, the size of the frame was the room the
+    /// window already had less its title, and every application window
+    /// opened that much shorter than the last. The real port has the
+    /// toolbar; a test without one never saw it.
+    @Test
+    public void theSizeAskedForIsTheFramesAlsoUnderAThemeWithAToolbar() {
+        desktop();
+        Toolbar.setGlobalToolbar(true);
+        show(new JFrame("Earlier"));
+        HeadlessImplementation.windowSize = null;
+        JFrame f = new JFrame("Ledger");
+        f.getContentPane().add(new JLabel("content"));
+        f.setPreferredSize(new Dimension(400, 300));
+        f.pack();
+        show(f);
+        assertArrayEquals(new int[] {Units.toDevice(400), Units.toDevice(300)}, HeadlessImplementation.windowSize);
+    }
+
+    /// A frame hidden, given another size and shown again asks for that
+    /// size; shown again as it was, it asks for nothing, and leaves the
+    /// window the size its user may have dragged it to.
+    @Test
+    public void aFrameShownAgainAsksOnlyForASizeItWasGivenSince() {
+        desktop();
+        Toolbar.setGlobalToolbar(true);
+        show(new JFrame("Earlier"));
+        JFrame f = new JFrame("Ledger");
+        f.getContentPane().add(new JLabel("content"));
+        f.setSize(400, 300);
+        show(f);
+        f.setVisible(false);
+        HeadlessImplementation.windowSize = null;
+        f.setVisible(true);
+        assertNull(HeadlessImplementation.windowSize);
+        // Moved while hidden: the size it has is the one it was laid out
+        // with, not one the application chose.
+        f.setVisible(false);
+        f.setLocation(10, 10);
+        f.setVisible(true);
+        assertNull(HeadlessImplementation.windowSize);
+        f.setVisible(false);
+        f.setSize(500, 320);
+        f.setVisible(true);
+        assertArrayEquals(new int[] {Units.toDevice(500), Units.toDevice(320)}, HeadlessImplementation.windowSize);
+    }
+
+    /// Off a desktop the display is the screen, and nothing resizes it.
+    @Test
+    public void aScreenIsNotResized() {
+        HeadlessImplementation.windowSize = null;
+        JFrame f = new JFrame("Ledger");
+        f.setSize(400, 300);
+        show(f);
+        assertNull(HeadlessImplementation.windowSize);
+    }
+
+    /// The native Linux port shows an empty buffer after the first frame
+    /// of a window whose size it has just changed, so the first paint for
+    /// a display size asks for one more; a paint for the same size does
+    /// not, or the form would paint for ever.
+    @Test
+    public void theFirstPaintForADisplaySizeAsksForAnother() {
+        JFrame f = new JFrame("Ledger");
+        f.getContentPane().add(new JLabel("content"));
+        f.setSize(400, 300);
+        show(f);
+        paint(f);
+        assertEquals(1, f.cn1Form().cn1PaintedAgain());
+        paint(f);
+        paint(f);
+        assertEquals(1, f.cn1Form().cn1PaintedAgain());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ConstantParityTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ConstantParityTest.java
new file mode 100644
index 00000000000..0b575820f1f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ConstantParityTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Holds every constant of the layer to the value of the same constant in
+/// the JDK.
+///
+/// A compiler inlines a `public static final` primitive or `String` into the
+/// application that reads it, so a constant here that differs from the JDK
+/// does not take effect in code compiled against the JDK: the application
+/// keeps the JDK's number. For each public class under
+/// `com.codename1.desktopcompat.java` and `.javax` every such field is
+/// compared with the field of the same name of the JDK class. Classes the
+/// JDK lacks are left to `ApiShapeTest`, and fields named `cn1...` are the
+/// layer's own.
+///
+/// The directory read is `target/classes`, or the `swingcompat.classes`
+/// system property.
+public class ConstantParityTest {
+
+    private static final String PREFIX = "com.codename1.desktopcompat.";
+
+    private final List<String> problems = new ArrayList<String>();
+
+    private int compared;
+
+    @Test
+    public void constantsHaveTheValuesOfTheJdk() throws Exception {
+        File root = new File(System.getProperty("swingcompat.classes", "target/classes"));
+        File base = new File(root, "com/codename1/desktopcompat");
+        walk(new File(base, "java"), "com.codename1.desktopcompat.java");
+        walk(new File(base, "javax"), "com.codename1.desktopcompat.javax");
+        if (!problems.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(problems.size()).append(" constant(s) differ from the JDK:\n");
+            for (String p : problems) {
+                sb.append("  ").append(p).append('\n');
+            }
+            fail(sb.toString());
+        }
+        assertTrue("no constants compared under " + base, compared > 0);
+    }
+
+    private void walk(File dir, String pkg) throws Exception {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                walk(f, pkg + "." + f.getName());
+            } else if (f.getName().endsWith(".class") && !f.getName().equals("package-info.class")) {
+                String simple = f.getName().substring(0, f.getName().length() - 6);
+                check(Class.forName(pkg + "." + simple, false, ConstantParityTest.class.getClassLoader()));
+            }
+        }
+    }
+
+    private void check(Class<?> ours) throws Exception {
+        if (!Modifier.isPublic(ours.getModifiers())) {
+            return;
+        }
+        Class<?> real;
+        try {
+            real = Class.forName(ours.getName().substring(PREFIX.length()), false,
+                    ClassLoader.getSystemClassLoader());
+        } catch (ClassNotFoundException e) {
+            return;
+        } catch (LinkageError e) {
+            return;
+        }
+        for (Field f : ours.getDeclaredFields()) {
+            int m = f.getModifiers();
+            if (!Modifier.isPublic(m) || !Modifier.isStatic(m) || !Modifier.isFinal(m)
+                    || f.getName().startsWith("cn1")) {
+                continue;
+            }
+            Class<?> type = f.getType();
+            if (!type.isPrimitive() && type != String.class) {
+                continue;
+            }
+            Field other;
+            try {
+                other = real.getField(f.getName());
+            } catch (NoSuchFieldException e) {
+                continue;
+            }
+            if (!Modifier.isStatic(other.getModifiers()) || other.getType() != type) {
+                continue;
+            }
+            compared++;
+            Object mine = f.get(null);
+            Object theirs = other.get(null);
+            if (!mine.equals(theirs)) {
+                problems.add(ours.getName() + "." + f.getName() + " is " + mine + " but the JDK has " + theirs);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DesktopPaneAndFriendsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DesktopPaneAndFriendsTest.java
new file mode 100644
index 00000000000..11781647f94
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DesktopPaneAndFriendsTest.java
@@ -0,0 +1,621 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.event.HierarchyEvent;
+import com.codename1.desktopcompat.java.awt.event.HierarchyListener;
+import com.codename1.desktopcompat.java.awt.print.PrinterException;
+import com.codename1.desktopcompat.javax.accessibility.Accessible;
+import com.codename1.desktopcompat.javax.accessibility.AccessibleContext;
+import com.codename1.desktopcompat.javax.accessibility.AccessibleRelation;
+import com.codename1.desktopcompat.javax.accessibility.AccessibleRelationSet;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JDesktopPane;
+import com.codename1.desktopcompat.javax.swing.JFileChooser;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JInternalFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JRadioButton;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.ToolTipManager;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.border.BevelBorder;
+import com.codename1.desktopcompat.javax.swing.border.SoftBevelBorder;
+import com.codename1.desktopcompat.javax.swing.event.InternalFrameEvent;
+import com.codename1.desktopcompat.javax.swing.event.InternalFrameListener;
+import com.codename1.desktopcompat.javax.swing.filechooser.FileView;
+import com.codename1.desktopcompat.javax.swing.plaf.ColorUIResource;
+import com.codename1.desktopcompat.javax.swing.plaf.UIResource;
+import com.codename1.desktopcompat.javax.swing.plaf.metal.DefaultMetalTheme;
+import com.codename1.desktopcompat.javax.swing.plaf.metal.MetalLookAndFeel;
+import com.codename1.desktopcompat.javax.swing.plaf.metal.MetalTheme;
+import com.codename1.desktopcompat.javax.swing.plaf.metal.OceanTheme;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Internal frames on a desktop pane, and the smaller pieces a full Swing
+/// demo leans on: accessible names, hierarchy listeners, the tool tip
+/// manager, file views, the Metal theme data and printing's honest refusal.
+public class DesktopPaneAndFriendsTest extends KernelTestBase {
+
+    /// Records the events an internal frame fires, by id.
+    private static final class Log implements InternalFrameListener {
+        final List<Integer> ids = new ArrayList<Integer>();
+
+        private void add(InternalFrameEvent e) {
+            ids.add(Integer.valueOf(e.getID()));
+        }
+
+        @Override
+        public void internalFrameOpened(InternalFrameEvent e) {
+            add(e);
+        }
+
+        @Override
+        public void internalFrameClosing(InternalFrameEvent e) {
+            add(e);
+        }
+
+        @Override
+        public void internalFrameClosed(InternalFrameEvent e) {
+            add(e);
+        }
+
+        @Override
+        public void internalFrameIconified(InternalFrameEvent e) {
+            add(e);
+        }
+
+        @Override
+        public void internalFrameDeiconified(InternalFrameEvent e) {
+            add(e);
+        }
+
+        @Override
+        public void internalFrameActivated(InternalFrameEvent e) {
+            add(e);
+        }
+
+        @Override
+        public void internalFrameDeactivated(InternalFrameEvent e) {
+            add(e);
+        }
+
+        boolean saw(int id) {
+            return ids.contains(Integer.valueOf(id));
+        }
+    }
+
+    private JDesktopPane desktop;
+    private JFrame window;
+
+    private JInternalFrame frame(String title, int x, int y) {
+        JInternalFrame f = new JInternalFrame(title, true, true, true, true);
+        f.setBounds(x, y, 200, 150);
+        desktop.add(f);
+        f.setVisible(true);
+        return f;
+    }
+
+    private void desktop() {
+        window = new JFrame();
+        desktop = new JDesktopPane();
+        window.getContentPane().add(desktop, BorderLayout.CENTER);
+    }
+
+    @Test
+    public void selectingOneFrameDeselectsTheOther() throws Exception {
+        desktop();
+        JInternalFrame a = frame("A", 10, 10);
+        JInternalFrame b = frame("B", 250, 10);
+        show(window);
+        Log la = new Log();
+        Log lb = new Log();
+        a.addInternalFrameListener(la);
+        b.addInternalFrameListener(lb);
+        a.setSelected(true);
+        assertTrue(a.isSelected());
+        assertSame(a, desktop.getSelectedFrame());
+        b.setSelected(true);
+        assertTrue(b.isSelected());
+        assertFalse(a.isSelected());
+        assertSame(b, desktop.getSelectedFrame());
+        assertTrue(la.saw(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED));
+        assertTrue(lb.saw(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED));
+        assertEquals(2, desktop.getAllFrames().length);
+        assertSame(desktop, a.getDesktopPane());
+    }
+
+    @Test
+    public void aPressInsideAFrameSelectsIt() throws Exception {
+        desktop();
+        JInternalFrame a = frame("A", 10, 10);
+        JInternalFrame b = frame("B", 250, 10);
+        JButton inside = new JButton("Inside");
+        b.getContentPane().add(inside, BorderLayout.CENTER);
+        show(window);
+        a.setSelected(true);
+        JInternalFrame.cn1PressedIn(inside);
+        assertTrue(b.isSelected());
+        assertFalse(a.isSelected());
+    }
+
+    @Test
+    public void maximizingFillsTheDesktopAndRestoringPutsItBack() throws Exception {
+        desktop();
+        JInternalFrame a = frame("A", 10, 20);
+        show(window);
+        a.setMaximum(true);
+        assertTrue(a.isMaximum());
+        assertEquals(0, a.getX());
+        assertEquals(0, a.getY());
+        assertEquals(desktop.getWidth(), a.getWidth());
+        assertEquals(desktop.getHeight(), a.getHeight());
+        assertEquals(10, a.getNormalBounds().x);
+        assertEquals(200, a.getNormalBounds().width);
+        a.setMaximum(false);
+        assertEquals(10, a.getX());
+        assertEquals(20, a.getY());
+        assertEquals(200, a.getWidth());
+        assertEquals(150, a.getHeight());
+    }
+
+    @Test
+    public void iconifyingShrinksTheFrameAndTellsListeners() throws Exception {
+        desktop();
+        JInternalFrame a = frame("A", 10, 20);
+        show(window);
+        Log log = new Log();
+        a.addInternalFrameListener(log);
+        a.setIcon(true);
+        assertTrue(a.isIcon());
+        assertTrue(a.getHeight() < 150);
+        assertTrue(log.saw(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED));
+        a.setIcon(false);
+        assertFalse(a.isIcon());
+        assertEquals(150, a.getHeight());
+        assertEquals(20, a.getY());
+        assertTrue(log.saw(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED));
+    }
+
+    @Test
+    public void closingRemovesTheFrameFromTheDesktop() throws Exception {
+        desktop();
+        JInternalFrame a = frame("A", 10, 20);
+        show(window);
+        Log log = new Log();
+        a.addInternalFrameListener(log);
+        a.doDefaultCloseAction();
+        assertTrue(log.saw(InternalFrameEvent.INTERNAL_FRAME_CLOSING));
+        assertTrue(log.saw(InternalFrameEvent.INTERNAL_FRAME_CLOSED));
+        assertTrue(a.isClosed());
+        assertEquals(0, desktop.getAllFrames().length);
+        assertNull(a.getParent());
+    }
+
+    @Test
+    public void aFrameThatDoesNothingOnCloseStaysOpen() {
+        desktop();
+        JInternalFrame a = frame("A", 10, 20);
+        a.setDefaultCloseOperation(JInternalFrame.DO_NOTHING_ON_CLOSE);
+        show(window);
+        Log log = new Log();
+        a.addInternalFrameListener(log);
+        a.doDefaultCloseAction();
+        assertTrue(log.saw(InternalFrameEvent.INTERNAL_FRAME_CLOSING));
+        assertFalse(log.saw(InternalFrameEvent.INTERNAL_FRAME_CLOSED));
+        assertFalse(a.isClosed());
+        assertEquals(1, desktop.getAllFrames().length);
+    }
+
+    @Test
+    public void contentGoesToTheContentPaneBelowTheTitleBar() {
+        desktop();
+        JInternalFrame a = frame("A", 10, 20);
+        JLabel l = new JLabel("x");
+        a.add(l, BorderLayout.CENTER);
+        show(window);
+        assertSame(a.getContentPane(), l.getParent());
+        assertTrue(a.getRootPane().getY() > 0);
+        assertTrue(a.getRootPane().getHeight() < a.getHeight());
+        assertEquals("A", a.getTitle());
+    }
+
+    @Test
+    public void hierarchyListenersHearAddingRemovingAndShowing() {
+        JFrame f = new JFrame();
+        JPanel p = new JPanel();
+        JButton b = new JButton("b");
+        final List<HierarchyEvent> heard = new ArrayList<HierarchyEvent>();
+        HierarchyListener l = new HierarchyListener() {
+            @Override
+            public void hierarchyChanged(HierarchyEvent e) {
+                heard.add(e);
+            }
+        };
+        b.addHierarchyListener(l);
+        assertEquals(1, b.getHierarchyListeners().length);
+        p.add(b);
+        assertEquals(1, heard.size());
+        assertTrue((heard.get(0).getChangeFlags() & HierarchyEvent.PARENT_CHANGED) != 0);
+        assertSame(b, heard.get(0).getChanged());
+        assertSame(p, heard.get(0).getChangedParent());
+        heard.clear();
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        assertEquals(1, heard.size());
+        assertSame(p, heard.get(0).getChanged());
+        heard.clear();
+        show(f);
+        boolean showing = false;
+        for (HierarchyEvent e : heard) {
+            showing |= (e.getChangeFlags() & HierarchyEvent.SHOWING_CHANGED) != 0;
+        }
+        assertTrue(showing);
+        assertTrue(b.isShowing());
+        heard.clear();
+        b.removeHierarchyListener(l);
+        p.remove(b);
+        assertEquals(0, heard.size());
+        assertEquals(0, b.getHierarchyListeners().length);
+    }
+
+    @Test
+    public void theAccessibleNameReachesTheWidget() {
+        JFrame f = new JFrame();
+        JButton b = new JButton("Go");
+        f.getContentPane().add(b, BorderLayout.CENTER);
+        assertTrue(b instanceof Accessible);
+        AccessibleContext ctx = b.getAccessibleContext();
+        assertNotNull(ctx);
+        assertSame(ctx, b.getAccessibleContext());
+        ctx.setAccessibleName("Start the run");
+        ctx.setAccessibleDescription("Runs it");
+        show(f);
+        assertEquals("Start the run", ctx.getAccessibleName());
+        assertEquals("Runs it", ctx.getAccessibleDescription());
+        assertEquals("Start the run", b.cn1Peer().getAccessibilityText());
+        ctx.setAccessibleName("Stop");
+        assertEquals("Stop", b.cn1Peer().getAccessibilityText());
+    }
+
+    @Test
+    public void relationSetsKeepOneRelationPerKey() {
+        AccessibleRelationSet set = new AccessibleRelationSet();
+        JLabel a = new JLabel("a");
+        JLabel b = new JLabel("b");
+        assertTrue(set.add(new AccessibleRelation(AccessibleRelation.LABEL_FOR, a)));
+        set.add(new AccessibleRelation(AccessibleRelation.LABEL_FOR, b));
+        assertEquals(1, set.size());
+        assertTrue(set.contains(AccessibleRelation.LABEL_FOR));
+        assertEquals(2, set.get(AccessibleRelation.LABEL_FOR).getTarget().length);
+        assertNull(set.get(AccessibleRelation.MEMBER_OF));
+        assertTrue(set.remove(set.get(AccessibleRelation.LABEL_FOR)));
+        assertEquals(0, set.toArray().length);
+    }
+
+    @Test
+    public void disablingTheToolTipManagerTakesTipsOffWidgets() {
+        JFrame f = new JFrame();
+        JButton b = new JButton("Go");
+        b.setToolTipText("Goes");
+        f.getContentPane().add(b, BorderLayout.CENTER);
+        show(f);
+        ToolTipManager m = ToolTipManager.sharedInstance();
+        assertSame(m, ToolTipManager.sharedInstance());
+        try {
+            assertTrue(m.isEnabled());
+            assertEquals("Goes", b.cn1Peer().getTooltip());
+            m.setEnabled(false);
+            assertNull(b.cn1Peer().getTooltip());
+            assertEquals("Goes", b.getToolTipText());
+            m.setEnabled(true);
+            assertEquals("Goes", b.cn1Peer().getTooltip());
+        } finally {
+            m.setEnabled(true);
+        }
+    }
+
+    @Test
+    public void aFileViewNamesAndDescribesTheFilesOfAChooser() {
+        JFileChooser fc = new JFileChooser();
+        File f = new File("/a/picture.png");
+        fc.setFileView(new FileView() {
+            @Override
+            public String getDescription(File file) {
+                return "A picture";
+            }
+        });
+        assertNotNull(fc.getFileView());
+        assertEquals("A picture", fc.getDescription(f));
+        JLabel preview = new JLabel("preview");
+        fc.setAccessory(preview);
+        assertSame(preview, fc.getAccessory());
+        assertTrue(fc.getControlButtonsAreShown());
+        fc.setControlButtonsAreShown(false);
+        assertFalse(fc.getControlButtonsAreShown());
+    }
+
+    @Test
+    public void anEmbeddedChooserBuildsItsListAndAccessoryWhenAdded() {
+        JFrame f = new JFrame();
+        JFileChooser fc = new JFileChooser(new File("/files"));
+        JLabel preview = new JLabel("preview");
+        fc.setAccessory(preview);
+        f.getContentPane().add(fc, BorderLayout.CENTER);
+        show(f);
+        assertTrue(fc.getComponentCount() > 0);
+        assertNotNull(preview.getParent());
+        assertTrue(preview.isShowing());
+    }
+
+    @Test
+    public void printingATableSaysThereIsNoPrinter() {
+        JTable t = new JTable(2, 2);
+        try {
+            t.print();
+            fail("there is no print service here");
+        } catch (PrinterException e) {
+            assertNotNull(e.getMessage());
+        }
+        try {
+            t.print(JTable.PrintMode.FIT_WIDTH);
+            fail("there is no print service here");
+        } catch (PrinterException e) {
+            assertNotNull(e.getMessage());
+        }
+    }
+
+    @Test
+    public void aSoftBevelTakesThreePixelsASide() {
+        SoftBevelBorder b = new SoftBevelBorder(BevelBorder.RAISED);
+        Insets i = b.getBorderInsets(new JPanel(), new Insets(0, 0, 0, 0));
+        assertEquals(3, i.top);
+        assertEquals(3, i.left);
+        assertEquals(3, i.bottom);
+        assertEquals(3, i.right);
+        assertFalse(b.isBorderOpaque());
+        assertEquals(BevelBorder.RAISED, b.getBevelType());
+    }
+
+    @Test
+    public void metalThemesCarryTheJdkColours() {
+        MetalTheme was = MetalLookAndFeel.getCurrentTheme();
+        try {
+            assertNotNull(was);
+            DefaultMetalTheme steel = new DefaultMetalTheme();
+            assertEquals("Steel", steel.getName());
+            assertEquals(new Color(204, 204, 204), steel.getControl());
+            assertEquals(new Color(153, 153, 204), steel.getPrimaryControlShadow());
+            assertTrue(steel.getControl() instanceof UIResource);
+            assertNotNull(steel.getControlTextFont());
+            OceanTheme ocean = new OceanTheme();
+            assertEquals("Ocean", ocean.getName());
+            assertEquals(new Color(238, 238, 238), ocean.getControl());
+            MetalLookAndFeel.setCurrentTheme(steel);
+            assertSame(steel, MetalLookAndFeel.getCurrentTheme());
+            assertEquals("Metal", new MetalLookAndFeel().getName());
+            assertEquals(new Color(1, 2, 3), new ColorUIResource(1, 2, 3));
+        } finally {
+            MetalLookAndFeel.setCurrentTheme(was);
+        }
+    }
+
+    @Test
+    public void theInstalledLookAndFeelIsTheOneInUse() {
+        String current = UIManager.getLookAndFeel().getClass().getName();
+        boolean found = false;
+        for (UIManager.LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
+            found |= current.equals(info.getClassName());
+        }
+        assertTrue(found);
+    }
+
+    @Test
+    public void anIconTakesThePlaceOfARadioButtonsIndicator() {
+        JFrame f = new JFrame();
+        JRadioButton plain = new JRadioButton("");
+        JRadioButton iconed = new JRadioButton("");
+        iconed.setIcon(new Icon() {
+            @Override
+            public void paintIcon(com.codename1.desktopcompat.java.awt.Component c,
+                    com.codename1.desktopcompat.java.awt.Graphics g, int x, int y) {
+                g.setColor(Color.RED);
+                g.fillRect(x, y, 2, 2);
+            }
+
+            @Override
+            public int getIconWidth() {
+                return 2;
+            }
+
+            @Override
+            public int getIconHeight() {
+                return 2;
+            }
+        });
+        JPanel p = new JPanel();
+        p.add(plain);
+        p.add(iconed);
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        // The indicator is an image drawn by the layer, which has a size
+        // only where images are kept.
+        com.codename1.compat.testing.HeadlessImplementation.rasterImages = true;
+        try {
+            show(f);
+            assertTrue("an icon of two pixels leaves no room for an indicator: " + iconed.getPreferredSize().width
+                    + " against " + plain.getPreferredSize().width,
+                    iconed.getPreferredSize().width < plain.getPreferredSize().width);
+        } finally {
+            com.codename1.compat.testing.HeadlessImplementation.rasterImages = false;
+        }
+    }
+
+    /// The title bar, the edges and the three title buttons answer the
+    /// pointer: a press selects the frame and its title bar takes the
+    /// highlight colour, a drag of the bar moves it, a drag of an edge
+    /// resizes it, and the buttons iconify, maximise and close.
+    @Test
+    public void thePointerMovesResizesAndPressesTheTitleButtons() throws Exception {
+        UIManager.put("textHighlight", new Color(0x12, 0x34, 0xab));
+        try {
+            desktop();
+            JInternalFrame a = frame("A", 20, 20);
+            JInternalFrame b = frame("B", 300, 200);
+            window.setSize(540, 900);
+            show(window);
+            a.setSelected(true);
+            assertTrue(a.isSelected());
+
+            // Unselected, the bar of B is not the highlight; a press makes it so.
+            int[][] rows = raster(window);
+            assertEquals(0, count(rows, b, 4, 4, 100, 24, 0x1234ab));
+            assertTrue(count(rows, a, 4, 4, 100, 24, 0x1234ab) > 500);
+            press(window, b, 60, 14);
+            assertTrue(b.isSelected());
+            assertFalse(a.isSelected());
+            rows = raster(window);
+            assertTrue(count(rows, b, 4, 4, 100, 24, 0x1234ab) > 500);
+            assertEquals(0, count(rows, a, 4, 4, 100, 24, 0x1234ab));
+
+            // The same press, dragged, moves the frame by as much.
+            drag(window, b, 70, 34);
+            release(window, b, 60, 14);
+            assertEquals(310, b.getX());
+            assertEquals(220, b.getY());
+            assertEquals(200, b.getWidth());
+
+            // The right edge and the bottom edge resize; the corner both.
+            press(window, b, 198, 80);
+            drag(window, b, 228, 80);
+            release(window, b, 227, 80);
+            assertEquals(230, b.getWidth());
+            assertEquals(150, b.getHeight());
+            assertEquals(310, b.getX());
+            press(window, b, 228, 148);
+            drag(window, b, 208, 168);
+            release(window, b, 207, 167);
+            assertEquals(210, b.getWidth());
+            assertEquals(170, b.getHeight());
+            // The left edge moves the frame as it resizes it.
+            press(window, b, 1, 80);
+            drag(window, b, 11, 80);
+            release(window, b, 1, 80);
+            assertEquals(320, b.getX());
+            assertEquals(200, b.getWidth());
+
+            // From the right: close, maximise, iconify, 18 wide and 3 apart.
+            int close = 200 - 4 - 3 - 9;
+            press(window, b, close - 42, 16);
+            release(window, b, close - 42, 16);
+            assertTrue(b.isIcon());
+            b.setIcon(false);
+            assertFalse(b.isIcon());
+            assertEquals(200, b.getWidth());
+            press(window, b, close - 21, 16);
+            release(window, b, close - 21, 16);
+            assertTrue(b.isMaximum());
+            assertEquals(desktop.getWidth(), b.getWidth());
+            b.setMaximum(false);
+            assertEquals(200, b.getWidth());
+            assertEquals(320, b.getX());
+            // A press that leaves the button before it is let go does nothing.
+            press(window, b, close, 16);
+            release(window, b, close, 60);
+            assertFalse(b.isClosed());
+            press(window, b, close, 16);
+            release(window, b, close, 16);
+            assertTrue(b.isClosed());
+            assertNull(b.getParent());
+        } finally {
+            UIManager.put("textHighlight", null);
+        }
+    }
+
+    /// In the theme as it comes, where the selection colour is a faint
+    /// tint of the window, the title bar of the selected frame is still
+    /// clearly darker than that of the others.
+    @Test
+    public void theSelectedFrameShowsInAThemeWithoutASelectionColour() throws Exception {
+        desktop();
+        JInternalFrame a = frame("A", 20, 20);
+        JInternalFrame b = frame("B", 300, 200);
+        window.setSize(540, 900);
+        show(window);
+        a.setSelected(true);
+        int[][] rows = raster(window);
+        int on = pixel(rows, a, 100, 8);
+        int off = pixel(rows, b, 100, 8);
+        int lumaOn = ((on >> 16) & 0xff) * 3 + ((on >> 8) & 0xff) * 6 + (on & 0xff);
+        int lumaOff = ((off >> 16) & 0xff) * 3 + ((off >> 8) & 0xff) * 6 + (off & 0xff);
+        assertTrue(Integer.toHexString(on) + " against " + Integer.toHexString(off),
+                Math.abs(lumaOn - lumaOff) >= 480);
+        b.setSelected(true);
+        rows = raster(window);
+        assertEquals(off & 0xffffff, pixel(rows, a, 100, 8) & 0xffffff);
+        assertEquals(on & 0xffffff, pixel(rows, b, 100, 8) & 0xffffff);
+    }
+
+    /// A component the application moves or resizes is painted where it
+    /// now is: its container is asked to repaint, which a layout pass
+    /// does for itself and a call from the application has to ask for.
+    @Test
+    public void movingAComponentRepaintsItsContainer() {
+        final int[] repaints = {0};
+        JPanel holder = new JPanel(null) {
+            @Override
+            public void repaint() {
+                repaints[0]++;
+                super.repaint();
+            }
+        };
+        JLabel piece = new JLabel("x");
+        holder.add(piece);
+        piece.setBounds(10, 10, 40, 20);
+        JFrame f = new JFrame();
+        f.getContentPane().add(holder, BorderLayout.CENTER);
+        show(f);
+        int before = repaints[0];
+        piece.setLocation(60, 30);
+        assertEquals(before + 1, repaints[0]);
+        piece.setSize(50, 20);
+        assertEquals(before + 2, repaints[0]);
+        // Bounds that do not change ask for nothing.
+        piece.setBounds(60, 30, 50, 20);
+        assertEquals(before + 2, repaints[0]);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DesktopServicesTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DesktopServicesTest.java
new file mode 100644
index 00000000000..876876e7a60
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DesktopServicesTest.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.desktopcompat.java.awt.Desktop;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.Toolkit;
+import com.codename1.desktopcompat.java.awt.datatransfer.Clipboard;
+import com.codename1.desktopcompat.java.awt.datatransfer.ClipboardOwner;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.StringSelection;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import com.codename1.desktopcompat.java.awt.datatransfer.UnsupportedFlavorException;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.javax.imageio.ImageIO;
+import com.codename1.desktopcompat.javax.swing.ImageIcon;
+import com.codename1.desktopcompat.rt.Launcher;
+import com.codename1.ui.Display;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/// The services a desktop application takes from its toolkit: opening a
+/// URL elsewhere, the clipboard, and reading and writing image files.
+public class DesktopServicesTest extends KernelTestBase {
+
+    private final List<String> opened = new ArrayList<String>();
+    private File png;
+
+    @Before
+    public void seams() throws IOException {
+        Launcher.setOpener(new Launcher.Opener() {
+            @Override
+            public void open(String url) {
+                opened.add(url);
+            }
+        });
+        HeadlessImplementation.pixelImages = true;
+        File dir = new File("target/swing-hard-images");
+        dir.mkdirs();
+        png = new File(dir, "two-by-three.png");
+        FileOutputStream out = new FileOutputStream(png);
+        try {
+            out.write(pngBytes());
+        } finally {
+            out.close();
+        }
+    }
+
+    @After
+    public void reset() {
+        Launcher.setOpener(null);
+        HeadlessImplementation.pixelImages = false;
+        HeadlessImplementation.imageIO = null;
+    }
+
+    /// A 2 by 3 PNG, red but for one blue pixel at (1, 2), encoded by the
+    /// JDK.
+    private static byte[] pngBytes() throws IOException {
+        java.awt.image.BufferedImage img = new java.awt.image.BufferedImage(2, 3,
+                java.awt.image.BufferedImage.TYPE_INT_ARGB);
+        for (int y = 0; y < 3; y++) {
+            for (int x = 0; x < 2; x++) {
+                img.setRGB(x, y, 0xffff0000);
+            }
+        }
+        img.setRGB(1, 2, 0xff0000ff);
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        javax.imageio.ImageIO.write(img, "png", out);
+        return out.toByteArray();
+    }
+
+    // ---------------------------------------------------------- Desktop
+
+    @Test
+    public void theDesktopHandsUrlsToTheDevice() throws Exception {
+        assertTrue(Desktop.isDesktopSupported());
+        Desktop d = Desktop.getDesktop();
+        assertSame(d, Desktop.getDesktop());
+        assertTrue(d.isSupported(Desktop.Action.BROWSE));
+        assertTrue(d.isSupported(Desktop.Action.MAIL));
+        assertTrue(d.isSupported(Desktop.Action.OPEN));
+        assertFalse(d.isSupported(Desktop.Action.PRINT));
+        d.browse(new URI("https://example.com/a?b=c"));
+        d.mail(new URI("mailto:someone@example.com?subject=Hi"));
+        d.mail();
+        d.open(new File("/docs/report.pdf"));
+        assertEquals("[https://example.com/a?b=c, mailto:someone@example.com?subject=Hi, mailto:, "
+                + "file:///docs/report.pdf]", opened.toString());
+        try {
+            d.mail(new URI("https://example.com"));
+            fail("not a mailto URI");
+        } catch (IllegalArgumentException expected) {
+            assertEquals(4, opened.size());
+        }
+        try {
+            d.browse(null);
+            fail("null URI");
+        } catch (NullPointerException expected) {
+            assertEquals(4, opened.size());
+        }
+    }
+
+    // -------------------------------------------------------- clipboard
+
+    @Test
+    public void theSystemClipboardIsTheDevices() throws Exception {
+        Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
+        assertSame(c, Toolkit.getDefaultToolkit().getSystemClipboard());
+        final List<Transferable> lost = new ArrayList<Transferable>();
+        ClipboardOwner owner = new ClipboardOwner() {
+            @Override
+            public void lostOwnership(Clipboard clipboard, Transferable contents) {
+                lost.add(contents);
+            }
+        };
+        StringSelection mine = new StringSelection("copied here");
+        c.setContents(mine, owner);
+        assertEquals("the device has it", "copied here", Display.getInstance().getPasteDataFromClipboard());
+        assertEquals("copied here", c.getData(DataFlavor.stringFlavor));
+        assertSame(mine, c.getContents(null));
+        assertTrue(c.isDataFlavorAvailable(DataFlavor.stringFlavor));
+        assertEquals(1, c.getAvailableDataFlavors().length);
+
+        // Something copied elsewhere is what the clipboard holds then.
+        Display.getInstance().copyToClipboard("copied elsewhere");
+        assertEquals("copied elsewhere", c.getData(DataFlavor.stringFlavor));
+        assertTrue(c.getContents(null) instanceof StringSelection);
+
+        // Putting something else tells the owner of what was there.
+        StringSelection next = new StringSelection("next");
+        c.setContents(next, next);
+        assertEquals(1, lost.size());
+        assertSame(mine, lost.get(0));
+        assertEquals("next", Display.getInstance().getPasteDataFromClipboard());
+    }
+
+    @Test
+    public void aClipboardOfTheApplicationsOwnHoldsWhatItIsGiven() throws Exception {
+        Clipboard c = new Clipboard("mine");
+        assertEquals("mine", c.getName());
+        assertNull(c.getContents(this));
+        assertEquals(0, c.getAvailableDataFlavors().length);
+        try {
+            c.getData(DataFlavor.stringFlavor);
+            fail("empty");
+        } catch (UnsupportedFlavorException expected) {
+            assertNotNull(expected);
+        }
+        StringSelection s = new StringSelection("text");
+        c.setContents(s, null);
+        assertEquals("text", c.getData(DataFlavor.stringFlavor));
+        DataFlavor html = new DataFlavor("text/HTML; charset=utf-8", "HTML");
+        assertFalse(c.isDataFlavorAvailable(html));
+        assertTrue(html.isMimeTypeEqual("text/html"));
+        assertEquals("text", html.getPrimaryType());
+        assertEquals("html", html.getSubType());
+        try {
+            s.getTransferData(html);
+            fail("not offered");
+        } catch (UnsupportedFlavorException expected) {
+            assertEquals("HTML", expected.getMessage());
+        }
+        assertEquals(new java.awt.datatransfer.StringSelection("x").getTransferDataFlavors()[0]
+                .getHumanPresentableName(), DataFlavor.stringFlavor.getHumanPresentableName());
+        assertEquals(java.awt.datatransfer.DataFlavor.stringFlavor.getMimeType(),
+                DataFlavor.stringFlavor.getMimeType());
+    }
+
+    // ----------------------------------------------------------- images
+
+    @Test
+    public void imagesAreReadFromFilesUrlsAndBytes() throws Exception {
+        Toolkit tk = Toolkit.getDefaultToolkit();
+        Image fromFile = tk.getImage(png.getPath());
+        assertEquals(2, fromFile.getWidth(null));
+        assertEquals(3, fromFile.getHeight(null));
+        Image fromUrl = tk.getImage(png.toURI().toURL());
+        assertEquals(2, fromUrl.getWidth(null));
+        assertEquals(3, tk.createImage(png.getPath()).getHeight(null));
+        assertEquals(3, tk.createImage(png.toURI().toURL()).getHeight(null));
+        assertEquals(2, tk.createImage(pngBytes()).getWidth(null));
+
+        assertEquals(2, new ImageIcon(png.getPath()).getIconWidth());
+        assertEquals(3, new ImageIcon(png.toURI().toURL()).getIconHeight());
+        assertEquals(png.toURI().toURL().toExternalForm(), new ImageIcon(png.toURI().toURL()).getDescription());
+        assertEquals(2, new ImageIcon(pngBytes()).getIconWidth());
+
+        // What cannot be read is an image without a size, not an error.
+        Image missing = tk.getImage("target/swing-hard-images/no-such-file.png");
+        assertNotNull(missing);
+        assertEquals(-1, missing.getWidth(null));
+        assertEquals(-1, missing.getHeight(null));
+        ImageIcon none = new ImageIcon("target/swing-hard-images/no-such-file.png");
+        assertEquals(-1, none.getIconWidth());
+        assertNull(none.getImage());
+        assertEquals(-1, new ImageIcon(new File("target/swing-hard-images/none.png").toURI().toURL()).getIconWidth());
+    }
+
+    @Test
+    public void imageIoReadsABufferedImage() throws Exception {
+        BufferedImage fromFile = ImageIO.read(png);
+        assertEquals(2, fromFile.getWidth());
+        assertEquals(3, fromFile.getHeight());
+        assertEquals(0xffff0000, fromFile.getRGB(0, 0));
+        assertEquals(0xff0000ff, fromFile.getRGB(1, 2));
+        BufferedImage fromUrl = ImageIO.read(png.toURI().toURL());
+        assertEquals(0xff0000ff, fromUrl.getRGB(1, 2));
+        InputStream in = new ByteArrayInputStream(pngBytes());
+        BufferedImage fromStream = ImageIO.read(in);
+        assertEquals(0xffff0000, fromStream.getRGB(1, 1));
+
+        assertNull("not an image", ImageIO.read(new ByteArrayInputStream(new byte[]{1, 2, 3, 4})));
+        try {
+            ImageIO.read(new File("target/swing-hard-images/no-such-file.png"));
+            fail("no such file");
+        } catch (IOException expected) {
+            assertEquals("Can't read input file!", expected.getMessage());
+        }
+        try {
+            ImageIO.read((InputStream) null);
+            fail("null stream");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected);
+        }
+    }
+
+    @Test
+    public void imageIoWritesWithTheDevicesEncoder() throws Exception {
+        BufferedImage img = new BufferedImage(2, 2, BufferedImage.TYPE_INT_ARGB);
+        img.setRGB(0, 0, 0xff00ff00);
+        img.setRGB(1, 1, 0xff123456);
+        File out = new File("target/swing-hard-images/written.png");
+        out.delete();
+
+        // A device without an encoder writes nothing and says so.
+        assertFalse(ImageIO.write(img, "png", out));
+        assertFalse(out.exists());
+
+        final List<String> formats = new ArrayList<String>();
+        HeadlessImplementation.imageIO = new com.codename1.ui.util.ImageIO() {
+            @Override
+            public void save(InputStream image, OutputStream response, String format, int width, int height,
+                    float quality) throws IOException {
+                throw new IOException("not used");
+            }
+
+            @Override
+            protected void saveImage(com.codename1.ui.Image image, OutputStream response, String format,
+                    float quality) throws IOException {
+                formats.add(format);
+                int w = image.getWidth();
+                int h = image.getHeight();
+                java.awt.image.BufferedImage real = new java.awt.image.BufferedImage(w, h,
+                        java.awt.image.BufferedImage.TYPE_INT_ARGB);
+                real.setRGB(0, 0, w, h, image.getRGB(), 0, w);
+                javax.imageio.ImageIO.write(real, "png", response);
+            }
+
+            @Override
+            public boolean isFormatSupported(String format) {
+                return true;
+            }
+        };
+        assertTrue(ImageIO.write(img, "PNG", out));
+        assertTrue(out.length() > 0);
+        BufferedImage back = ImageIO.read(out);
+        assertEquals(0xff00ff00, back.getRGB(0, 0));
+        assertEquals(0xff123456, back.getRGB(1, 1));
+
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        assertTrue(ImageIO.write(img, "jpg", bytes));
+        assertTrue(ImageIO.write(img, "JPEG", bytes));
+        assertEquals("[png, jpeg, jpeg]", formats.toString());
+        assertTrue(bytes.size() > 0);
+
+        // A format nothing writes, as on the desktop.
+        assertFalse(ImageIO.write(img, "tiff-like", bytes));
+        try {
+            ImageIO.write(null, "png", bytes);
+            fail("null image");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DialogsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DialogsTest.java
new file mode 100644
index 00000000000..f865e69a40f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DialogsTest.java
@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JColorChooser;
+import com.codename1.desktopcompat.javax.swing.JComboBox;
+import com.codename1.desktopcompat.javax.swing.JDialog;
+import com.codename1.desktopcompat.javax.swing.JFileChooser;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.JOptionPane;
+import com.codename1.desktopcompat.javax.swing.JSlider;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.ProgressMonitor;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.desktopcompat.javax.swing.filechooser.FileNameExtensionFilter;
+import com.codename1.desktopcompat.rt.FilePicker;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import com.codename1.ui.Display;
+import com.codename1.ui.events.ActionEvent;
+import com.codename1.ui.events.ActionListener;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Test;
+
+/// The standard dialogs: each blocks its caller until it is answered, and
+/// answers with what the user did.
+public class DialogsTest extends WindowsTestBase {
+
+    private final List<String> order = new ArrayList<String>();
+
+    @After
+    public void restorePicker() {
+        FilePicker.setSource(null);
+    }
+
+    /// Runs `r` on the event thread once the dialog the test is about to
+    /// open is on the screen and the test is blocked in it.
+    private void whileBlocked(final Runnable r) {
+        Thread later = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(150);
+                } catch (InterruptedException e) {
+                    return;
+                }
+                Display.getInstance().callSerially(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            r.run();
+                            order.add("answered");
+                        } catch (RuntimeException e) {
+                            order.add("failed: " + e);
+                            closeTop();
+                        } catch (AssertionError e) {
+                            order.add("failed: " + e);
+                            closeTop();
+                        }
+                    }
+                });
+            }
+        });
+        later.start();
+    }
+
+    private static void closeTop() {
+        Window w = WindowHosts.active();
+        if (w instanceof JDialog) {
+            w.setVisible(false);
+        }
+    }
+
+    private static <T> T find(Component root, Class<T> type, String text) {
+        if (type.isInstance(root)) {
+            boolean match = text == null;
+            if (!match && root instanceof AbstractButton) {
+                match = text.equals(((AbstractButton) root).getText());
+            }
+            if (match) {
+                return type.cast(root);
+            }
+        }
+        if (root instanceof Container) {
+            Component[] kids = ((Container) root).getComponents();
+            for (int i = 0; i < kids.length; i++) {
+                T t = find(kids[i], type, text);
+                if (t != null) {
+                    return t;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static <T> T inDialog(Class<T> type, String text) {
+        Window top = WindowHosts.active();
+        assertTrue("a dialog is showing: " + top, top instanceof JDialog);
+        T t = find(top, type, text);
+        assertNotNull(type.getName() + " " + text, t);
+        return t;
+    }
+
+    private void press(final String button) {
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                inDialog(JButton.class, button).doClick();
+            }
+        });
+    }
+
+    private void answered() {
+        order.add("returned");
+        assertEquals("[answered, returned]", order.toString());
+        order.clear();
+    }
+
+    @Test
+    public void aConfirmDialogBlocksAndAnswersWithTheButton() {
+        JFrame f = show(new JFrame("owner"));
+        press("No");
+        int r = JOptionPane.showConfirmDialog(f, "Sure?", "Confirm", JOptionPane.YES_NO_OPTION);
+        answered();
+        assertEquals(JOptionPane.NO_OPTION, r);
+        assertTrue("the dialog is gone", f.isActive());
+
+        press("Yes");
+        assertEquals(JOptionPane.YES_OPTION, JOptionPane.showConfirmDialog(f, "Sure?"));
+        answered();
+
+        press("Cancel");
+        assertEquals(JOptionPane.CANCEL_OPTION,
+                JOptionPane.showConfirmDialog(f, "Sure?", "t", JOptionPane.YES_NO_CANCEL_OPTION));
+        answered();
+
+        press("OK");
+        assertEquals(JOptionPane.OK_OPTION,
+                JOptionPane.showConfirmDialog(f, "Sure?", "t", JOptionPane.OK_CANCEL_OPTION,
+                        JOptionPane.WARNING_MESSAGE));
+        answered();
+    }
+
+    @Test
+    public void closingAnOptionDialogAnswersClosed() {
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                assertNull("a yes/no dialog has no cancel", find(WindowHosts.active(), JButton.class, "Cancel"));
+                WindowHosts.active().cn1Closing();
+            }
+        });
+        assertEquals(JOptionPane.CLOSED_OPTION,
+                JOptionPane.showConfirmDialog(null, "Sure?", "t", JOptionPane.YES_NO_OPTION));
+        answered();
+    }
+
+    @Test
+    public void aMessageDialogBlocksUntilItIsDismissed() {
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                assertEquals("Oops", ((JDialog) WindowHosts.active()).getTitle());
+                JLabel icon = null;
+                List<JLabel> labels = new ArrayList<JLabel>();
+                collect(WindowHosts.active(), labels);
+                StringBuilder text = new StringBuilder();
+                for (JLabel l : labels) {
+                    if (l.getIcon() != null) {
+                        icon = l;
+                    } else {
+                        text.append(l.getText()).append('|');
+                    }
+                }
+                assertNotNull("an error message has an icon", icon);
+                assertEquals("one label a line", "It broke|badly|", text.toString());
+                inDialog(JButton.class, "OK").doClick();
+            }
+        });
+        JOptionPane.showMessageDialog(null, "It broke\nbadly", "Oops", JOptionPane.ERROR_MESSAGE);
+        answered();
+    }
+
+    private static void collect(Component root, List<JLabel> into) {
+        if (root instanceof JLabel) {
+            into.add((JLabel) root);
+        }
+        if (root instanceof Container) {
+            Component[] kids = ((Container) root).getComponents();
+            for (int i = 0; i < kids.length; i++) {
+                collect(kids[i], into);
+            }
+        }
+    }
+
+    @Test
+    public void anInputDialogAnswersWithTheText() {
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                JTextField t = inDialog(JTextField.class, null);
+                assertEquals("the initial value", "before", t.getText());
+                t.setText("hello");
+                inDialog(JButton.class, "OK").doClick();
+            }
+        });
+        assertEquals("hello", JOptionPane.showInputDialog(null, "Name?", "before"));
+        answered();
+
+        press("Cancel");
+        assertNull(JOptionPane.showInputDialog("Name?"));
+        answered();
+    }
+
+    @Test
+    public void anInputDialogWithSelectionValuesAnswersWithTheChoice() {
+        final Object[] values = {"a", "b", "c"};
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                JComboBox<?> c = inDialog(JComboBox.class, null);
+                assertEquals("c", c.getSelectedItem());
+                c.setSelectedItem("b");
+                inDialog(JButton.class, "OK").doClick();
+            }
+        });
+        Object r = JOptionPane.showInputDialog(null, "Which?", "Pick", JOptionPane.QUESTION_MESSAGE, null, values,
+                "c");
+        answered();
+        assertEquals("b", r);
+
+        press("Cancel");
+        assertNull(JOptionPane.showInputDialog(null, "Which?", "Pick", JOptionPane.PLAIN_MESSAGE, null, values,
+                "a"));
+        answered();
+    }
+
+    @Test
+    public void anOptionDialogAnswersWithTheIndexOfTheOption() {
+        Object[] options = {"Red", "Green", "Blue"};
+        press("Green");
+        int r = JOptionPane.showOptionDialog(null, "Color?", "Pick", JOptionPane.DEFAULT_OPTION,
+                JOptionPane.QUESTION_MESSAGE, null, options, "Blue");
+        answered();
+        assertEquals(1, r);
+    }
+
+    @Test
+    public void aPaneShowsComponentsAndArraysAndAnswersThroughItsValue() {
+        JLabel part = new JLabel("a component");
+        final JOptionPane pane = new JOptionPane(new Object[] {"a line", part}, JOptionPane.INFORMATION_MESSAGE);
+        assertSame(JOptionPane.UNINITIALIZED_VALUE, pane.getValue());
+        JDialog d = pane.createDialog(null, "instance");
+        assertTrue("the component is in the dialog", SwingUtilities.isDescendingFrom(part, d));
+        assertTrue(d.isModal());
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                pane.setValue("chosen");
+            }
+        });
+        d.setVisible(true);
+        answered();
+        assertFalse(d.isVisible());
+        assertEquals("chosen", pane.getValue());
+        d.dispose();
+        pane.setMessageType(JOptionPane.WARNING_MESSAGE);
+        assertEquals(JOptionPane.WARNING_MESSAGE, pane.getMessageType());
+        pane.setOptions(new Object[] {"x"});
+        assertArrayEquals(new Object[] {"x"}, pane.getOptions());
+    }
+
+    @Test
+    public void anExtensionFilterAcceptsDirectoriesAndItsExtensions() throws IOException {
+        File dir = scratch("filter");
+        FileNameExtensionFilter f = new FileNameExtensionFilter("Text", "txt", "md");
+        assertTrue(f.accept(dir));
+        assertTrue(f.accept(new File(dir, "a.TXT")));
+        assertTrue(f.accept(new File(dir, "a.md")));
+        assertFalse(f.accept(new File(dir, "a.png")));
+        assertFalse(f.accept(new File(dir, "txt")));
+        assertEquals("Text", f.getDescription());
+        assertArrayEquals(new String[] {"txt", "md"}, f.getExtensions());
+    }
+
+    private static File scratch(String name) throws IOException {
+        File dir = new File("target/swing-windows-files/" + name).getAbsoluteFile();
+        File sub = new File(dir, "sub");
+        assertTrue(sub.isDirectory() || sub.mkdirs());
+        new File(dir, "a.txt").createNewFile();
+        new File(dir, "b.png").createNewFile();
+        return dir;
+    }
+
+    @Test
+    public void aSaveDialogListsTheDirectoryAndAnswersWithTheNamedFile() throws IOException {
+        final File dir = scratch("save");
+        final JFileChooser fc = new JFileChooser(dir);
+        fc.setFileFilter(new FileNameExtensionFilter("Text", "txt"));
+        final List<String> commands = new ArrayList<String>();
+        fc.addActionListener(new com.codename1.desktopcompat.java.awt.event.ActionListener() {
+            @Override
+            public void actionPerformed(com.codename1.desktopcompat.java.awt.event.ActionEvent e) {
+                commands.add(e.getActionCommand());
+            }
+        });
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                JList<?> list = inDialog(JList.class, null);
+                StringBuilder names = new StringBuilder();
+                for (int i = 0; i < list.getModel().getSize(); i++) {
+                    names.append(list.getModel().getElementAt(i)).append(' ');
+                }
+                assertEquals("directories first, then the files the filter accepts", "sub/ a.txt ",
+                        names.toString());
+                list.setSelectedIndex(1);
+                JTextField name = inDialog(JTextField.class, null);
+                assertEquals("selecting a file names it", "a.txt", name.getText());
+                name.setText("out.txt");
+                inDialog(JButton.class, "Save").doClick();
+            }
+        });
+        int r = fc.showSaveDialog(null);
+        answered();
+        assertEquals(JFileChooser.APPROVE_OPTION, r);
+        assertEquals(new File(dir, "out.txt"), fc.getSelectedFile());
+        assertEquals(1, fc.getSelectedFiles().length);
+        assertEquals("[" + JFileChooser.APPROVE_SELECTION + "]", commands.toString());
+
+        press("Cancel");
+        assertEquals(JFileChooser.CANCEL_OPTION, fc.showSaveDialog(null));
+        answered();
+    }
+
+    @Test
+    public void namingADirectoryWhereOnlyFilesCanBeChosenEntersIt() throws IOException {
+        final File dir = scratch("enter");
+        final JFileChooser fc = new JFileChooser(dir.getPath());
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                inDialog(JTextField.class, null).setText("sub");
+                inDialog(JButton.class, "Save").doClick();
+                assertTrue("still open", WindowHosts.active() instanceof JDialog);
+                assertEquals(new File(dir, "sub"), fc.getCurrentDirectory());
+                assertEquals(0, inDialog(JList.class, null).getModel().getSize());
+                inDialog(JButton.class, "..").doClick();
+                assertEquals(dir, fc.getCurrentDirectory());
+                inDialog(JButton.class, "Cancel").doClick();
+            }
+        });
+        assertEquals(JFileChooser.CANCEL_OPTION, fc.showSaveDialog(null));
+        answered();
+    }
+
+    @Test
+    public void choosingADirectoryAnswersWithTheCurrentOne() throws IOException {
+        final File dir = scratch("dirs");
+        JFileChooser fc = new JFileChooser(dir);
+        fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                JList<?> list = inDialog(JList.class, null);
+                assertEquals("only directories are listed", 1, list.getModel().getSize());
+                inDialog(JButton.class, "Open").doClick();
+            }
+        });
+        assertEquals(JFileChooser.APPROVE_OPTION, fc.showOpenDialog(null));
+        answered();
+        assertEquals(dir, fc.getSelectedFile());
+    }
+
+    @Test
+    public void openingAFileAsksThePlatformPickerAndWaitsForIt() {
+        final String[] asked = new String[1];
+        final String[] answer = {"/docs/report.txt"};
+        FilePicker.setSource(new FilePicker.Source() {
+            @Override
+            public void open(final ActionListener<ActionEvent> response, String accept) {
+                asked[0] = accept;
+                Display.getInstance().callSerially(new Runnable() {
+                    @Override
+                    public void run() {
+                        order.add("picked");
+                        response.actionPerformed(new ActionEvent(answer[0]));
+                    }
+                });
+            }
+        });
+        JFileChooser fc = new JFileChooser();
+        fc.setFileFilter(new FileNameExtensionFilter("Text", "txt", "md"));
+        int r = fc.showOpenDialog(null);
+        order.add("returned");
+        assertEquals("[picked, returned]", order.toString());
+        assertEquals(JFileChooser.APPROVE_OPTION, r);
+        assertEquals("txt,md", asked[0]);
+        assertEquals("report.txt", fc.getSelectedFile().getName());
+        assertEquals(1, fc.getSelectedFiles().length);
+
+        answer[0] = null;
+        assertEquals(JFileChooser.CANCEL_OPTION, fc.showOpenDialog(null));
+    }
+
+    @Test
+    public void theFiltersOfAChooser() {
+        JFileChooser fc = new JFileChooser();
+        assertSame(fc.getAcceptAllFileFilter(), fc.getFileFilter());
+        FileNameExtensionFilter txt = new FileNameExtensionFilter("Text", "txt");
+        fc.addChoosableFileFilter(txt);
+        assertEquals(2, fc.getChoosableFileFilters().length);
+        fc.setFileFilter(txt);
+        assertFalse(fc.accept(new File("a.png")));
+        assertTrue(fc.removeChoosableFileFilter(txt));
+        assertSame(fc.getAcceptAllFileFilter(), fc.getFileFilter());
+        fc.setAcceptAllFileFilterUsed(false);
+        assertEquals(0, fc.getChoosableFileFilters().length);
+        fc.setMultiSelectionEnabled(true);
+        assertTrue(fc.isMultiSelectionEnabled());
+        final List<String> changes = new ArrayList<String>();
+        fc.addPropertyChangeListener(JFileChooser.SELECTED_FILES_CHANGED_PROPERTY,
+                new com.codename1.desktopcompat.java.beans.PropertyChangeListener() {
+                    @Override
+                    public void propertyChange(com.codename1.desktopcompat.java.beans.PropertyChangeEvent e) {
+                        Object v = e.getNewValue();
+                        changes.add(v instanceof File[] ? String.valueOf(((File[]) v).length) : String.valueOf(v));
+                    }
+                });
+        fc.setSelectedFiles(new File[] {new File("x"), new File("y")});
+        assertEquals(new File("x"), fc.getSelectedFile());
+        assertEquals(2, fc.getSelectedFiles().length);
+        fc.setSelectedFiles(null);
+        assertEquals(0, fc.getSelectedFiles().length);
+        assertEquals("[2, null]", changes.toString());
+    }
+
+    @Test
+    public void aColorDialogAnswersWithTheColor() {
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                List<JSlider> sliders = new ArrayList<JSlider>();
+                sliders(WindowHosts.active(), sliders);
+                assertEquals(3, sliders.size());
+                assertEquals("the initial color", 200, sliders.get(1).getValue());
+                sliders.get(0).setValue(10);
+                sliders.get(2).setValue(30);
+                inDialog(JButton.class, "OK").doClick();
+            }
+        });
+        Color c = JColorChooser.showDialog(null, "Pick", new Color(100, 200, 50));
+        answered();
+        assertEquals(new Color(10, 200, 30), c);
+
+        press("Cancel");
+        assertNull(JColorChooser.showDialog(null, "Pick", null));
+        answered();
+    }
+
+    private static void sliders(Component root, List<JSlider> into) {
+        if (root instanceof JSlider) {
+            into.add((JSlider) root);
+        }
+        if (root instanceof Container) {
+            Component[] kids = ((Container) root).getComponents();
+            for (int i = 0; i < kids.length; i++) {
+                sliders(kids[i], into);
+            }
+        }
+    }
+
+    @Test
+    public void aProgressMonitorPopsUpAndCanBeCancelled() {
+        JFrame f = show(new JFrame("owner"));
+        ProgressMonitor m = new ProgressMonitor(f, "Working", "step 1", 0, 100);
+        m.setMillisToDecideToPopup(0);
+        m.setMillisToPopup(0);
+        m.setProgress(10);
+        assertTrue("it does not block", WindowHosts.active() instanceof JDialog);
+        m.setNote("step 2");
+        assertEquals("step 2", m.getNote());
+        m.setProgress(50);
+        assertFalse(m.isCanceled());
+        inDialog(JButton.class, "Cancel").doClick();
+        assertTrue(m.isCanceled());
+        assertSame(f, WindowHosts.active());
+
+        ProgressMonitor done = new ProgressMonitor(f, "Working", null, 0, 100);
+        done.setMillisToDecideToPopup(0);
+        done.setMillisToPopup(0);
+        done.setProgress(10);
+        assertTrue(WindowHosts.active() instanceof JDialog);
+        done.setProgress(100);
+        assertSame("reaching the maximum closes it", f, WindowHosts.active());
+        assertFalse(done.isCanceled());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DragAndDropTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DragAndDropTest.java
new file mode 100644
index 00000000000..18299fa7095
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/DragAndDropTest.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.datatransfer.DataFlavor;
+import com.codename1.desktopcompat.java.awt.datatransfer.StringSelection;
+import com.codename1.desktopcompat.java.awt.datatransfer.Transferable;
+import com.codename1.desktopcompat.java.awt.datatransfer.UnsupportedFlavorException;
+import com.codename1.desktopcompat.java.awt.dnd.DnDConstants;
+import com.codename1.desktopcompat.java.awt.dnd.DropTarget;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetAdapter;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetDragEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetDropEvent;
+import com.codename1.desktopcompat.java.awt.dnd.DropTargetEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.DropMode;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.TransferHandler;
+import com.codename1.desktopcompat.rt.Dnd;
+import com.codename1.desktopcompat.rt.EventBridge;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.After;
+import org.junit.Test;
+
+/// Drag and drop: a drop target is told of a drag from outside the
+/// application as it enters, moves and is let go, and gets its files; a
+/// transfer handler turns a drag of a table's row into an import at the
+/// place the row was let go.
+public class DragAndDropTest extends WindowsTestBase {
+
+    @After
+    public void noDrag() {
+        Dnd.reset();
+    }
+
+    /// The files of a drag from the desktop.
+    private static final class Files implements Transferable {
+
+        private final List<File> files;
+
+        Files(File... files) {
+            this.files = Arrays.asList(files);
+        }
+
+        @Override
+        public DataFlavor[] getTransferDataFlavors() {
+            return new DataFlavor[]{DataFlavor.javaFileListFlavor};
+        }
+
+        @Override
+        public boolean isDataFlavorSupported(DataFlavor flavor) {
+            return DataFlavor.javaFileListFlavor.equals(flavor);
+        }
+
+        @Override
+        public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+            if (!isDataFlavorSupported(flavor)) {
+                throw new UnsupportedFlavorException(flavor);
+            }
+            return files;
+        }
+    }
+
+    /// The place of a point of `c` in its window.
+    private static int[] inWindow(Window w, Component c, int x, int y) {
+        int wx = x;
+        int wy = y;
+        for (Component p = c; p != null && p != w; p = p.getParent()) {
+            wx += p.getX();
+            wy += p.getY();
+        }
+        return new int[]{wx, wy};
+    }
+
+    @Test
+    public void aDropTargetGetsTheFilesLetGoOverIt() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JPanel target = new JPanel();
+        f.add(target, BorderLayout.CENTER);
+        final List<String> seen = new ArrayList<String>();
+        final List<Object> dropped = new ArrayList<Object>();
+        DropTarget dt = new DropTarget(target, DnDConstants.ACTION_COPY, new DropTargetAdapter() {
+            @Override
+            public void dragEnter(DropTargetDragEvent e) {
+                seen.add("enter");
+                assertTrue(e.isDataFlavorSupported(DataFlavor.javaFileListFlavor));
+                e.acceptDrag(DnDConstants.ACTION_COPY);
+            }
+
+            @Override
+            public void dragOver(DropTargetDragEvent e) {
+                seen.add("over " + e.getLocation().x + "," + e.getLocation().y);
+            }
+
+            @Override
+            public void dragExit(DropTargetEvent e) {
+                seen.add("exit");
+            }
+
+            @Override
+            public void drop(DropTargetDropEvent e) {
+                seen.add("drop");
+                e.acceptDrop(DnDConstants.ACTION_COPY);
+                try {
+                    dropped.add(e.getTransferable().getTransferData(DataFlavor.javaFileListFlavor));
+                    e.dropComplete(true);
+                } catch (UnsupportedFlavorException | IOException bad) {
+                    e.dropComplete(false);
+                }
+            }
+        });
+        show(f);
+        assertSame(dt, target.getDropTarget());
+        assertSame(target, dt.getComponent());
+        Files files = new Files(new File("a.txt"), new File("b.txt"));
+        int[] p = inWindow(f, target, 10, 12);
+        int both = DnDConstants.ACTION_COPY_OR_MOVE;
+        assertEquals(DnDConstants.ACTION_COPY, Dnd.over(f, p[0], p[1], files, both, DnDConstants.ACTION_COPY, false));
+        assertEquals(DnDConstants.ACTION_COPY, Dnd.over(f, p[0] + 5, p[1], files, both, DnDConstants.ACTION_COPY,
+                false));
+        assertEquals(Arrays.asList("enter", "over 15,12"), seen);
+        assertEquals(DnDConstants.ACTION_COPY, Dnd.drop(f, p[0] + 5, p[1], files, both, DnDConstants.ACTION_COPY,
+                false));
+        assertEquals("drop", seen.get(seen.size() - 1));
+        assertEquals(1, dropped.size());
+        assertEquals(Arrays.asList(new File("a.txt"), new File("b.txt")), dropped.get(0));
+    }
+
+    @Test
+    public void aRefusedDragIsNotDropped() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JPanel target = new JPanel();
+        f.add(target, BorderLayout.CENTER);
+        final List<String> seen = new ArrayList<String>();
+        new DropTarget(target, new DropTargetAdapter() {
+            @Override
+            public void dragEnter(DropTargetDragEvent e) {
+                e.rejectDrag();
+            }
+
+            @Override
+            public void dragOver(DropTargetDragEvent e) {
+                e.rejectDrag();
+            }
+
+            @Override
+            public void dragExit(DropTargetEvent e) {
+                seen.add("exit");
+            }
+
+            @Override
+            public void drop(DropTargetDropEvent e) {
+                seen.add("drop");
+            }
+        });
+        show(f);
+        int[] p = inWindow(f, target, 10, 12);
+        Files files = new Files(new File("a.txt"));
+        assertEquals(DnDConstants.ACTION_NONE, Dnd.over(f, p[0], p[1], files, DnDConstants.ACTION_COPY,
+                DnDConstants.ACTION_COPY, false));
+        assertEquals(DnDConstants.ACTION_NONE, Dnd.drop(f, p[0], p[1], files, DnDConstants.ACTION_COPY,
+                DnDConstants.ACTION_COPY, false));
+        assertEquals(Arrays.asList("exit"), seen);
+    }
+
+    @Test
+    public void anInactiveTargetAndATargetThatAllowsAnotherActionSeeNothing() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JPanel target = new JPanel();
+        f.add(target, BorderLayout.CENTER);
+        final int[] entered = {0};
+        DropTarget dt = new DropTarget(target, DnDConstants.ACTION_MOVE, new DropTargetAdapter() {
+            @Override
+            public void dragEnter(DropTargetDragEvent e) {
+                entered[0]++;
+            }
+
+            @Override
+            public void drop(DropTargetDropEvent e) {
+                e.rejectDrop();
+            }
+        });
+        show(f);
+        int[] p = inWindow(f, target, 10, 12);
+        Files files = new Files(new File("a.txt"));
+        // The source allows a copy alone, the target a move alone.
+        assertEquals(DnDConstants.ACTION_NONE, Dnd.over(f, p[0], p[1], files, DnDConstants.ACTION_COPY,
+                DnDConstants.ACTION_COPY, false));
+        Dnd.exit();
+        dt.setActive(false);
+        int before = entered[0];
+        assertEquals(DnDConstants.ACTION_NONE, Dnd.over(f, p[0], p[1], files, DnDConstants.ACTION_MOVE,
+                DnDConstants.ACTION_MOVE, false));
+        assertEquals(before, entered[0]);
+    }
+
+    /// Moves rows the way an application reorders a table.
+    private static final class Rows extends TransferHandler {
+
+        final List<String> log = new ArrayList<String>();
+        JTable.DropLocation at;
+        Object hovering;
+
+        @Override
+        public int getSourceActions(JComponent c) {
+            return MOVE;
+        }
+
+        @Override
+        protected Transferable createTransferable(JComponent c) {
+            return new StringSelection(String.valueOf(((JTable) c).getSelectedRow()));
+        }
+
+        @Override
+        public boolean canImport(TransferSupport support) {
+            if (support.isDrop() && support.getComponent() instanceof JTable) {
+                hovering = support.getDropLocation();
+            }
+            return support.isDrop() && support.isDataFlavorSupported(DataFlavor.stringFlavor);
+        }
+
+        @Override
+        public boolean importData(TransferSupport support) {
+            TransferHandler.DropLocation where = support.getDropLocation();
+            if (!(where instanceof JTable.DropLocation)) {
+                return false;
+            }
+            at = (JTable.DropLocation) where;
+            try {
+                log.add("import " + support.getTransferable().getTransferData(DataFlavor.stringFlavor) + " "
+                        + support.getDropAction());
+            } catch (UnsupportedFlavorException | IOException bad) {
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        protected void exportDone(JComponent source, Transferable data, int action) {
+            log.add("done " + action);
+        }
+    }
+
+    private static void pointer(JFrame f, int id, Component c, int x, int y) {
+        int[] p = at(c, x, y);
+        EventBridge.pointerEvent(f, id, p[0], p[1]);
+    }
+
+    @Test
+    public void aRowDraggedInATableIsImportedWhereItIsLetGo() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JTable table = new JTable(new Object[][]{{"a"}, {"b"}, {"c"}, {"d"}, {"e"}}, new Object[]{"name"});
+        Rows rows = new Rows();
+        table.setDragEnabled(true);
+        table.setDropMode(DropMode.INSERT_ROWS);
+        table.setTransferHandler(rows);
+        f.add(table, BorderLayout.CENTER);
+        show(f);
+        assertEquals(DropMode.INSERT_ROWS, table.getDropMode());
+        assertSame(rows, table.getTransferHandler());
+        assertNotNull("a transfer handler gives the component a drop target", table.getDropTarget());
+        table.setRowSelectionInterval(0, 0);
+        Rectangle from = table.getCellRect(0, 0, true);
+        Rectangle to = table.getCellRect(3, 0, true);
+        int x = from.x + 20;
+        pointer(f, MouseEvent.MOUSE_PRESSED, table, x, from.y + from.height / 2);
+        assertFalse(Dnd.dragging());
+        pointer(f, MouseEvent.MOUSE_DRAGGED, table, x, from.y + from.height / 2 + 12);
+        assertTrue("a drag past the threshold starts dragging the row", Dnd.dragging());
+        // The upper part of the fourth row: before it.
+        pointer(f, MouseEvent.MOUSE_DRAGGED, table, x, to.y + 2);
+        assertTrue(rows.hovering instanceof JTable.DropLocation);
+        assertNotNull("the place is shown while the drag is over it", table.getDropLocation());
+        assertEquals(3, table.getDropLocation().getRow());
+        pointer(f, MouseEvent.MOUSE_RELEASED, table, x, to.y + 2);
+        assertFalse(Dnd.dragging());
+        assertNull(table.getDropLocation());
+        assertEquals(Arrays.asList("import 0 " + TransferHandler.MOVE, "done " + TransferHandler.MOVE), rows.log);
+        assertTrue(rows.at.isInsertRow());
+        assertFalse(rows.at.isInsertColumn());
+        assertEquals(3, rows.at.getRow());
+        assertEquals("the selection is what was dragged, not what it was dragged over", 0, table.getSelectedRow());
+    }
+
+    @Test
+    public void aDropOnACellNamesTheCell() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JTable table = new JTable(new Object[][]{{"a"}, {"b"}, {"c"}}, new Object[]{"name"});
+        Rows rows = new Rows();
+        table.setDropMode(DropMode.ON);
+        table.setTransferHandler(rows);
+        f.add(table, BorderLayout.CENTER);
+        show(f);
+        Rectangle cell = table.getCellRect(1, 0, true);
+        int[] p = inWindow(f, table, cell.x + 10, cell.y + cell.height / 2);
+        StringSelection data = new StringSelection("x");
+        assertEquals(DnDConstants.ACTION_COPY, Dnd.drop(f, p[0], p[1], data, DnDConstants.ACTION_COPY,
+                DnDConstants.ACTION_COPY, false));
+        assertEquals(1, rows.at.getRow());
+        assertEquals(0, rows.at.getColumn());
+        assertFalse(rows.at.isInsertRow());
+        assertEquals(Arrays.asList("import x " + TransferHandler.COPY), rows.log);
+    }
+
+    @Test
+    public void theModifierKeysNameTheAction() {
+        int all = DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_LINK;
+        assertEquals(DnDConstants.ACTION_MOVE, Dnd.userAction(0, all));
+        assertEquals(DnDConstants.ACTION_COPY, Dnd.userAction(0, DnDConstants.ACTION_COPY));
+        assertEquals(DnDConstants.ACTION_COPY, Dnd.userAction(MouseEvent.CTRL_DOWN_MASK, all));
+        assertEquals(DnDConstants.ACTION_LINK,
+                Dnd.userAction(MouseEvent.CTRL_DOWN_MASK | MouseEvent.SHIFT_DOWN_MASK, all));
+        assertEquals(DnDConstants.ACTION_NONE, Dnd.userAction(MouseEvent.CTRL_DOWN_MASK, DnDConstants.ACTION_MOVE));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/EdtAndGraphicsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/EdtAndGraphicsTest.java
new file mode 100644
index 00000000000..7fcec34f662
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/EdtAndGraphicsTest.java
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.java.awt.AlphaComposite;
+import com.codename1.desktopcompat.java.awt.EventQueue;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.desktopcompat.javax.swing.Timer;
+import com.codename1.desktopcompat.rt.G2D;
+import com.codename1.ui.Image;
+import java.util.List;
+import org.junit.Test;
+
+/// The event dispatch thread helpers, and the transform and clip
+/// arithmetic of the graphics a peer paints with.
+public class EdtAndGraphicsTest extends KernelTestBase {
+
+    private static G2D graphics() {
+        Image target = Image.createImage(400, 400);
+        return G2D.forPeer(target.getGraphics(), 30, 40, 200, 100);
+    }
+
+    @Test
+    public void theTestRunsOnTheEventDispatchThread() {
+        assertTrue(SwingUtilities.isEventDispatchThread());
+        assertTrue(EventQueue.isDispatchThread());
+    }
+
+    @Test
+    public void invokeLaterRunsAfterTheCurrentEvent() {
+        final boolean[] ran = new boolean[1];
+        SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                ran[0] = true;
+            }
+        });
+        assertFalse(ran[0]);
+        MainThreadRule.drain();
+        assertTrue(ran[0]);
+    }
+
+    @Test
+    public void invokeAndWaitOnTheEventDispatchThreadRunsAtOnce() throws Exception {
+        final boolean[] ran = new boolean[1];
+        SwingUtilities.invokeAndWait(new Runnable() {
+            @Override
+            public void run() {
+                ran[0] = true;
+            }
+        });
+        assertTrue(ran[0]);
+    }
+
+    @Test
+    public void invokeAndWaitFromAnotherThreadRunsOnTheEventDispatchThread() throws Exception {
+        final boolean[] onEdt = new boolean[1];
+        final boolean[] done = new boolean[1];
+        Thread t = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    EventQueue.invokeAndWait(new Runnable() {
+                        @Override
+                        public void run() {
+                            onEdt[0] = EventQueue.isDispatchThread();
+                        }
+                    });
+                } catch (InterruptedException e) {
+                    return;
+                } catch (java.lang.reflect.InvocationTargetException e) {
+                    return;
+                }
+                done[0] = true;
+            }
+        });
+        t.start();
+        for (int i = 0; i < 400 && t.isAlive(); i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        t.join(2000);
+        assertTrue(done[0]);
+        assertTrue(onEdt[0]);
+    }
+
+    @Test
+    public void aTimerFiresOnTheEventDispatchThreadUntilStopped() throws Exception {
+        final int[] fired = new int[1];
+        final boolean[] onEdt = {true};
+        Timer timer = new Timer(5, new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                fired[0]++;
+                onEdt[0] &= EventQueue.isDispatchThread();
+            }
+        });
+        assertFalse(timer.isRunning());
+        timer.start();
+        assertTrue(timer.isRunning());
+        for (int i = 0; i < 400 && fired[0] < 3; i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        timer.stop();
+        assertFalse(timer.isRunning());
+        assertTrue(fired[0] >= 3);
+        assertTrue(onEdt[0]);
+        int after = fired[0];
+        Thread.sleep(30);
+        MainThreadRule.drain();
+        assertEquals(after, fired[0]);
+
+        final int[] once = new int[1];
+        Timer single = new Timer(1, new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                once[0]++;
+            }
+        });
+        single.setRepeats(false);
+        single.start();
+        for (int i = 0; i < 400 && once[0] == 0; i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        Thread.sleep(20);
+        MainThreadRule.drain();
+        assertEquals(1, once[0]);
+        assertFalse(single.isRunning());
+    }
+
+    /// Periods that elapse while the event dispatch thread is busy are one
+    /// event, unless coalescing is switched off.
+    @Test
+    public void aBusyEventDispatchThreadGetsOneCoalescedTimerEvent() throws Exception {
+        final int[] fired = new int[1];
+        ActionListener count = new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                fired[0]++;
+            }
+        };
+        Timer timer = new Timer(2, count);
+        timer.start();
+        // Nothing drains the queue: the event dispatch thread is "busy".
+        Thread.sleep(120);
+        timer.stop();
+        timer.start();
+        Thread.sleep(120);
+        MainThreadRule.drain();
+        timer.stop();
+        // Some sixty periods went by. A period that ends while the queue
+        // is being drained is a new event, so the count is not exactly one.
+        assertTrue("fired " + fired[0], fired[0] >= 1 && fired[0] <= 4);
+
+        fired[0] = 0;
+        Timer each = new Timer(2, count);
+        each.setCoalesce(false);
+        each.start();
+        Thread.sleep(120);
+        MainThreadRule.drain();
+        each.stop();
+        assertTrue("fired " + fired[0], fired[0] >= 10);
+    }
+
+    /// Whether the timer repeats is asked when it fires, not when it starts.
+    @Test
+    public void aRunningTimerHonoursAChangeOfRepeats() throws Exception {
+        final int[] fired = new int[1];
+        Timer timer = new Timer(2, new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                fired[0]++;
+            }
+        });
+        timer.setRepeats(false);
+        timer.start();
+        timer.setRepeats(true);
+        for (int i = 0; i < 400 && fired[0] < 3; i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        assertTrue(timer.isRunning());
+        assertTrue(fired[0] >= 3);
+
+        timer.setRepeats(false);
+        int before = fired[0];
+        for (int i = 0; i < 400 && timer.isRunning(); i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        assertFalse(timer.isRunning());
+        assertEquals(before + 1, fired[0]);
+    }
+
+    /// A new delay reaches a running timer: the firing already due keeps
+    /// its time, as in Swing, and the new period applies after it.
+    @Test
+    public void aRunningTimerTakesANewDelay() throws Exception {
+        final int[] fired = new int[1];
+        Timer timer = new Timer(2, new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                fired[0]++;
+            }
+        });
+        timer.start();
+        for (int i = 0; i < 400 && fired[0] < 2; i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        assertTrue(fired[0] >= 2);
+        timer.setDelay(60000);
+        assertEquals(60000, timer.getDelay());
+        assertTrue(timer.isRunning());
+        // Whatever was already due may still arrive; nothing after it.
+        for (int i = 0; i < 10; i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        int settled = fired[0];
+        for (int i = 0; i < 40; i++) {
+            MainThreadRule.drain();
+            Thread.sleep(5);
+        }
+        assertEquals(settled, fired[0]);
+        timer.stop();
+    }
+
+    @Test
+    public void userSpaceStartsAtThePeerOriginScaledToDevicePixels() {
+        G2D g = graphics();
+        assertArrayEquals(new double[]{2, 0, 0, 2, 30, 40}, g.deviceMatrix(), 1e-9);
+        assertTrue(g.getTransform().isIdentity());
+        assertArrayEquals(new int[]{30, 40, 20, 10}, g.deviceRect(0, 0, 10, 5));
+        g.finish();
+    }
+
+    @Test
+    public void translateAndScaleComposeLikeJava2D() {
+        G2D g = graphics();
+        g.translate(5, 6);
+        g.scale(3, 2);
+        assertArrayEquals(new double[]{6, 0, 0, 4, 40, 52}, g.deviceMatrix(), 1e-9);
+        assertArrayEquals(new int[]{46, 56, 12, 8}, g.deviceRect(1, 1, 2, 2));
+        AffineTransform t = g.getTransform();
+        assertEquals(5, t.getTranslateX(), 1e-9);
+        assertEquals(3, t.getScaleX(), 1e-9);
+        g.setTransform(new AffineTransform());
+        assertArrayEquals(new double[]{2, 0, 0, 2, 30, 40}, g.deviceMatrix(), 1e-9);
+        g.finish();
+    }
+
+    @Test
+    public void aCopyHasItsOwnTransform() {
+        G2D g = graphics();
+        G2D copy = (G2D) g.create();
+        copy.translate(10, 10);
+        assertArrayEquals(new double[]{2, 0, 0, 2, 30, 40}, g.deviceMatrix(), 1e-9);
+        assertArrayEquals(new double[]{2, 0, 0, 2, 50, 60}, copy.deviceMatrix(), 1e-9);
+        copy.dispose();
+        G2D moved = (G2D) g.create(10, 20, 30, 30);
+        assertArrayEquals(new double[]{2, 0, 0, 2, 50, 80}, moved.deviceMatrix(), 1e-9);
+        Rectangle clip = moved.getClipBounds();
+        assertTrue(clip.width <= 30 && clip.height <= 30);
+        g.finish();
+    }
+
+    @Test
+    public void aQuarterTurnMapsARectangleToItsRotatedBounds() {
+        G2D g = graphics();
+        g.rotate(Math.PI / 2);
+        int[] r = g.deviceRect(0, 0, 10, 5);
+        assertArrayEquals(new int[]{20, 40, 10, 20}, r);
+        g.finish();
+    }
+
+    @Test
+    public void clipsIntersectInUserSpace() {
+        G2D g = graphics();
+        g.setClip(10, 10, 50, 40);
+        assertEquals(new Rectangle(10, 10, 50, 40), g.getClipBounds());
+        g.clipRect(30, 0, 100, 20);
+        assertEquals(new Rectangle(30, 10, 30, 10), g.getClipBounds());
+        g.translate(30, 10);
+        assertEquals(new Rectangle(0, 0, 30, 10), g.getClipBounds());
+        g.finish();
+    }
+
+    @Test
+    public void theClipNeverLeavesThePeer() {
+        G2D g = graphics();
+        g.setClip(-50, -50, 1000, 1000);
+        Rectangle clip = g.getClipBounds();
+        assertEquals(new Rectangle(0, 0, 100, 50), clip);
+        g.finish();
+    }
+
+    @Test
+    public void unsupportedJava2DFeaturesSayNo() {
+        G2D g = graphics();
+        try {
+            g.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR));
+            assertTrue("expected an UnsupportedOperationException", false);
+        } catch (UnsupportedOperationException expected) {
+            assertTrue(expected.getMessage() != null);
+        }
+        g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
+        g.finish();
+    }
+
+    @Test
+    public void textIsDrawnAtTheScaledPosition() {
+        com.codename1.compat.testing.HeadlessImplementation.recordText = true;
+        G2D g = graphics();
+        g.drawString("where", 10, 20);
+        g.finish();
+        List<Object[]> text = com.codename1.compat.testing.HeadlessImplementation.drawnText;
+        Object[] drawn = find(text, "where");
+        assertTrue(drawn != null);
+        assertEquals(50, ((Integer) drawn[1]).intValue());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/EventDeliveryTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/EventDeliveryTest.java
new file mode 100644
index 00000000000..71957645d32
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/EventDeliveryTest.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.java.awt.event.FocusListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyListener;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseMotionAdapter;
+import com.codename1.desktopcompat.javax.swing.ButtonGroup;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JCheckBox;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JRadioButton;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Input reaching a frame's form arrives as action, mouse, key and focus
+/// events on the right component, in its logical coordinates.
+public class EventDeliveryTest extends KernelTestBase {
+
+    private static final class Mice extends MouseAdapter {
+        final List<String> log = new ArrayList<String>();
+        MouseEvent last;
+
+        private void add(String what, MouseEvent e) {
+            log.add(what);
+            last = e;
+        }
+
+        @Override
+        public void mousePressed(MouseEvent e) {
+            add("pressed", e);
+        }
+
+        @Override
+        public void mouseReleased(MouseEvent e) {
+            add("released", e);
+        }
+
+        @Override
+        public void mouseClicked(MouseEvent e) {
+            add("clicked", e);
+        }
+
+        @Override
+        public void mouseEntered(MouseEvent e) {
+            add("entered", e);
+        }
+
+        @Override
+        public void mouseExited(MouseEvent e) {
+            add("exited", e);
+        }
+    }
+
+    private static JPanel sized(int w, int h) {
+        JPanel p = new JPanel(null);
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+
+    @Test
+    public void clickingAButtonFiresOneActionEvent() {
+        JButton b = new JButton("Go");
+        final List<ActionEvent> events = new ArrayList<ActionEvent>();
+        b.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                events.add(e);
+            }
+        });
+        Mice mice = new Mice();
+        b.addMouseListener(mice);
+        JFrame f = new JFrame();
+        f.add(b, BorderLayout.SOUTH);
+        show(f);
+        press(f, b, 5, 5);
+        release(f, b, 5, 5);
+        assertEquals(1, events.size());
+        assertSame(b, events.get(0).getSource());
+        assertEquals("Go", events.get(0).getActionCommand());
+        assertTrue(mice.log.contains("pressed") && mice.log.contains("released") && mice.log.contains("clicked"));
+    }
+
+    @Test
+    public void doClickAndTheNativeClickDriveTheModel() {
+        JCheckBox box = new JCheckBox("Check");
+        final int[] items = new int[1];
+        final int[] actions = new int[1];
+        box.addItemListener(new ItemListener() {
+            @Override
+            public void itemStateChanged(ItemEvent e) {
+                items[0] = e.getStateChange();
+            }
+        });
+        box.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                actions[0]++;
+            }
+        });
+        JFrame f = new JFrame();
+        f.add(box, BorderLayout.SOUTH);
+        show(f);
+        box.doClick();
+        assertTrue(box.isSelected());
+        assertEquals(ItemEvent.SELECTED, items[0]);
+        assertEquals(1, actions[0]);
+        assertTrue(((com.codename1.ui.CheckBox) box.cn1Peer()).isSelected());
+        press(f, box, 5, 5);
+        release(f, box, 5, 5);
+        assertFalse(box.isSelected());
+        assertEquals(ItemEvent.DESELECTED, items[0]);
+        assertEquals(2, actions[0]);
+        assertFalse(((com.codename1.ui.CheckBox) box.cn1Peer()).isSelected());
+    }
+
+    @Test
+    public void aButtonGroupKeepsOneRadioButtonSelected() {
+        JRadioButton a = new JRadioButton("A", true);
+        JRadioButton b = new JRadioButton("B");
+        ButtonGroup group = new ButtonGroup();
+        group.add(a);
+        group.add(b);
+        JFrame f = new JFrame();
+        JPanel p = new JPanel(new FlowLayout());
+        p.add(a);
+        p.add(b);
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        press(f, b, 5, 5);
+        release(f, b, 5, 5);
+        assertTrue(b.isSelected());
+        assertFalse(a.isSelected());
+        assertFalse(((com.codename1.ui.RadioButton) a.cn1Peer()).isSelected());
+        press(f, b, 5, 5);
+        release(f, b, 5, 5);
+        assertTrue(b.isSelected());
+        assertTrue(((com.codename1.ui.RadioButton) b.cn1Peer()).isSelected());
+    }
+
+    @Test
+    public void mouseEventsCarryLogicalCoordinatesAndGoToTheListeningAncestor() {
+        JPanel outer = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+        JPanel pad = sized(30, 40);
+        JPanel inner = sized(100, 60);
+        outer.add(pad);
+        outer.add(inner);
+        Mice mice = new Mice();
+        outer.addMouseListener(mice);
+        JFrame f = new JFrame();
+        f.add(outer, BorderLayout.CENTER);
+        show(f);
+        assertEquals(30, inner.getX());
+        press(f, inner, 7, 9);
+        assertEquals("entered", mice.log.get(0));
+        assertEquals("pressed", mice.log.get(1));
+        assertSame(outer, mice.last.getSource());
+        assertEquals(37, mice.last.getX());
+        assertEquals(9, mice.last.getY());
+        assertEquals(MouseEvent.BUTTON1, mice.last.getButton());
+        assertEquals(1, mice.last.getClickCount());
+        release(f, inner, 7, 9);
+        assertEquals("clicked", mice.log.get(mice.log.size() - 1));
+
+        Mice innerMice = new Mice();
+        inner.addMouseListener(innerMice);
+        mice.log.clear();
+        press(f, inner, 7, 9);
+        assertSame(inner, innerMice.last.getSource());
+        assertEquals(7, innerMice.last.getX());
+        assertEquals(2, innerMice.last.getClickCount());
+        assertEquals("exited", mice.log.get(0));
+        release(f, inner, 7, 9);
+    }
+
+    @Test
+    public void aDragGoesToThePressedComponentAndEndsWithoutAClick() {
+        JPanel a = sized(50, 50);
+        JPanel b = sized(50, 50);
+        JPanel content = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+        content.add(a);
+        content.add(b);
+        Mice mice = new Mice();
+        a.addMouseListener(mice);
+        final List<MouseEvent> drags = new ArrayList<MouseEvent>();
+        a.addMouseMotionListener(new MouseMotionAdapter() {
+            @Override
+            public void mouseDragged(MouseEvent e) {
+                drags.add(e);
+            }
+        });
+        JFrame f = new JFrame();
+        f.add(content, BorderLayout.CENTER);
+        show(f);
+        press(f, a, 10, 10);
+        drag(f, b, 20, 30);
+        release(f, b, 20, 30);
+        assertEquals(1, drags.size());
+        assertSame(a, drags.get(0).getSource());
+        assertEquals(70, drags.get(0).getX());
+        assertEquals(30, drags.get(0).getY());
+        assertTrue(mice.log.contains("released"));
+        assertFalse(mice.log.contains("clicked"));
+    }
+
+    @Test
+    public void keysGoToTheFocusOwnerElseToTheWindow() {
+        final List<String> log = new ArrayList<String>();
+        KeyListener keys = new KeyListener() {
+            @Override
+            public void keyTyped(KeyEvent e) {
+                log.add("typed " + e.getKeyChar() + " " + name(e));
+            }
+
+            @Override
+            public void keyPressed(KeyEvent e) {
+                log.add("pressed " + e.getKeyCode() + " " + name(e));
+            }
+
+            @Override
+            public void keyReleased(KeyEvent e) {
+                log.add("released " + e.getKeyCode() + " " + name(e));
+            }
+
+            private String name(KeyEvent e) {
+                return e.getComponent().getName();
+            }
+        };
+        JFrame f = new JFrame();
+        f.setName("frame");
+        JPanel panel = new JPanel();
+        panel.setName("panel");
+        f.add(panel, BorderLayout.CENTER);
+        f.addKeyListener(keys);
+        panel.addKeyListener(keys);
+        show(f);
+        f.cn1Form().keyPressed('a');
+        f.cn1Form().keyReleased('a');
+        assertEquals("[pressed " + KeyEvent.VK_A + " frame, typed a frame, released " + KeyEvent.VK_A + " frame]",
+                log.toString());
+        log.clear();
+        assertTrue(panel.requestFocusInWindow());
+        assertTrue(panel.isFocusOwner());
+        f.cn1Form().keyPressed('7');
+        assertEquals("[pressed " + KeyEvent.VK_7 + " panel, typed 7 panel]", log.toString());
+    }
+
+    @Test
+    public void focusMovesWithFocusLostAndFocusGained() {
+        final List<String> log = new ArrayList<String>();
+        final JPanel a = new JPanel();
+        final JPanel b = new JPanel();
+        FocusListener l = new FocusListener() {
+            @Override
+            public void focusGained(FocusEvent e) {
+                log.add((e.getSource() == a ? "a" : "b") + " gained from "
+                        + (e.getOppositeComponent() == null ? "none" : e.getOppositeComponent() == a ? "a" : "b"));
+            }
+
+            @Override
+            public void focusLost(FocusEvent e) {
+                log.add((e.getSource() == a ? "a" : "b") + " lost");
+            }
+        };
+        a.addFocusListener(l);
+        b.addFocusListener(l);
+        JFrame f = new JFrame();
+        JPanel content = new JPanel();
+        content.add(a);
+        content.add(b);
+        f.add(content, BorderLayout.CENTER);
+        show(f);
+        a.requestFocus();
+        b.requestFocus();
+        assertEquals("[a gained from none, a lost, b gained from a]", log.toString());
+        assertSame(b, f.getFocusOwner());
+        content.remove(b);
+        assertNull(f.getFocusOwner());
+        b.setFocusable(false);
+        assertFalse(b.requestFocusInWindow());
+    }
+
+    @Test
+    public void aTextFieldKeepsItsTextInThePeerAndPostsActions() {
+        JTextField field = new JTextField("abc", 10);
+        final String[] command = new String[1];
+        field.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                command[0] = e.getActionCommand();
+            }
+        });
+        JFrame f = new JFrame();
+        f.add(field, BorderLayout.NORTH);
+        show(f);
+        com.codename1.ui.TextField peer = (com.codename1.ui.TextField) field.cn1Peer();
+        assertEquals("abc", peer.getText());
+        peer.setText("typed");
+        assertEquals("typed", field.getText());
+        field.postActionEvent();
+        assertEquals("typed", command[0]);
+        field.setText("set");
+        assertEquals("set", peer.getText());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FocusAndKeysFollowUpTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FocusAndKeysFollowUpTest.java
new file mode 100644
index 00000000000..c541e691f9f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FocusAndKeysFollowUpTest.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.InputVerifier;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JSplitPane;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+import com.codename1.desktopcompat.rt.EventBridge;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// What every component gets from `JComponent`: an input verifier that
+/// can hold the focus, scrolling itself into view, and the keys of the
+/// list and the split pane.
+public class FocusAndKeysFollowUpTest extends WindowsTestBase {
+
+    private static void key(Component target, int code) {
+        JComponent.cn1KeyBindings(target, new KeyEvent(target, KeyEvent.KEY_PRESSED, 0L, 0, code,
+                KeyEvent.CHAR_UNDEFINED));
+    }
+
+    @Test
+    public void anInputVerifierOfAnyComponentHoldsTheFocus() {
+        JFrame f = new JFrame("verify");
+        f.getContentPane().setLayout(new FlowLayout());
+        JButton a = new JButton("a");
+        JButton b = new JButton("b");
+        JButton help = new JButton("help");
+        f.getContentPane().add(a);
+        f.getContentPane().add(b);
+        f.getContentPane().add(help);
+        f.setSize(300, 200);
+        show(f);
+        final boolean[] valid = new boolean[1];
+        final int[] asked = new int[1];
+        InputVerifier v = new InputVerifier() {
+            @Override
+            public boolean verify(JComponent input) {
+                asked[0]++;
+                return valid[0];
+            }
+        };
+        a.setInputVerifier(v);
+        assertSame(v, a.getInputVerifier());
+        assertTrue(b.getVerifyInputWhenFocusTarget());
+        assertTrue(a.requestFocusInWindow());
+        assertTrue(a.isFocusOwner());
+
+        assertFalse("the verifier refuses", b.requestFocusInWindow());
+        assertTrue(a.isFocusOwner());
+        assertEquals(1, asked[0]);
+
+        help.setVerifyInputWhenFocusTarget(false);
+        assertTrue("a target that does not ask takes the focus", help.requestFocusInWindow());
+        assertTrue(help.isFocusOwner());
+        assertEquals(1, asked[0]);
+
+        assertTrue(a.requestFocusInWindow());
+        valid[0] = true;
+        assertTrue(b.requestFocusInWindow());
+        assertTrue(b.isFocusOwner());
+    }
+
+    @Test
+    public void aComponentScrollsItselfIntoView() {
+        JFrame f = new JFrame("scroll");
+        JPanel tall = new JPanel(null);
+        tall.setPreferredSize(new Dimension(200, 2000));
+        JButton far = new JButton("far");
+        far.setBounds(10, 1500, 80, 30);
+        tall.add(far);
+        JScrollPane sp = new JScrollPane(tall);
+        f.getContentPane().add(sp, BorderLayout.CENTER);
+        f.setSize(300, 300);
+        show(f);
+        assertEquals(0, sp.getViewport().getViewPosition().y);
+        far.scrollRectToVisible(new Rectangle(0, 0, 80, 30));
+        Rectangle seen = sp.getViewport().getViewRect();
+        assertTrue("the button is in view: " + seen, seen.y <= 1500 && seen.y + seen.height >= 1530);
+    }
+
+    @Test
+    public void aListFollowsTheArrowKeys() {
+        JFrame f = new JFrame("list");
+        JList<String> list = new JList<String>(new String[] {"a", "b", "c", "d"});
+        f.getContentPane().add(list, BorderLayout.CENTER);
+        f.setSize(200, 300);
+        show(f);
+        assertEquals("selectNextRow", list.getInputMap().get(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)));
+        list.setSelectedIndex(0);
+        key(list, KeyEvent.VK_DOWN);
+        key(list, KeyEvent.VK_DOWN);
+        assertEquals(2, list.getSelectedIndex());
+        key(list, KeyEvent.VK_UP);
+        assertEquals(1, list.getSelectedIndex());
+        key(list, KeyEvent.VK_END);
+        assertEquals(3, list.getSelectedIndex());
+        key(list, KeyEvent.VK_DOWN);
+        assertEquals("it stops at the last row", 3, list.getSelectedIndex());
+        key(list, KeyEvent.VK_HOME);
+        assertEquals(0, list.getSelectedIndex());
+    }
+
+    @Test
+    public void aListSelectsOnThePressAndTakesTheFocus() {
+        JFrame f = new JFrame("press");
+        JList<String> list = new JList<String>(new String[] {"a", "b", "c"});
+        f.getContentPane().add(list, BorderLayout.CENTER);
+        f.setSize(200, 300);
+        show(f);
+        Rectangle second = list.getCellBounds(1, 1);
+        pressOn(f, list, second.x + 5, second.y + second.height / 2);
+        assertEquals("selected before the release", 1, list.getSelectedIndex());
+        assertTrue(list.isFocusOwner());
+        releaseOn(f, list, second.x + 5, second.y + second.height / 2);
+        assertEquals(1, list.getSelectedIndex());
+    }
+
+    @Test
+    public void aSplitPaneMovesItsDividerWithTheKeysWhileItHasTheFocus() {
+        JFrame f = new JFrame("split");
+        JButton left = new JButton("left");
+        left.setMinimumSize(new Dimension(20, 20));
+        JButton right = new JButton("right");
+        right.setMinimumSize(new Dimension(20, 20));
+        JSplitPane sp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, left, right);
+        f.getContentPane().add(sp, BorderLayout.CENTER);
+        f.setSize(400, 200);
+        show(f);
+        sp.setDividerLocation(150);
+        left.requestFocusInWindow();
+        key(left, KeyEvent.VK_RIGHT);
+        assertEquals("a focused child keeps its arrow keys", 150, sp.getDividerLocation());
+        sp.setFocusable(true);
+        assertTrue(sp.requestFocusInWindow());
+        key(sp, KeyEvent.VK_RIGHT);
+        assertEquals(160, sp.getDividerLocation());
+        key(sp, KeyEvent.VK_LEFT);
+        key(sp, KeyEvent.VK_LEFT);
+        assertEquals(140, sp.getDividerLocation());
+        key(sp, KeyEvent.VK_HOME);
+        assertEquals(sp.getMinimumDividerLocation(), sp.getDividerLocation());
+        key(sp, KeyEvent.VK_END);
+        assertEquals(sp.getMaximumDividerLocation(), sp.getDividerLocation());
+    }
+
+    @Test
+    public void aClickCountBelongsToAPlaceAndCanBeReset() {
+        JFrame f = new JFrame("clicks");
+        JPanel p = new JPanel(null);
+        final List<Integer> counts = new ArrayList<Integer>();
+        p.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                counts.add(Integer.valueOf(e.getClickCount()));
+            }
+        });
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        f.setSize(300, 300);
+        show(f);
+        click(f, p, 20, 20);
+        click(f, p, 20, 20);
+        click(f, p, 200, 200);
+        assertEquals("a click somewhere else starts over", "[1, 2, 1]", counts.toString());
+        counts.clear();
+        click(f, p, 200, 200);
+        EventBridge.resetClickCount();
+        click(f, p, 200, 200);
+        assertEquals("[2, 1]", counts.toString());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FormattedFieldTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FormattedFieldTest.java
new file mode 100644
index 00000000000..4bda585508a
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FormattedFieldTest.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.FocusEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.InputVerifier;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JEditorPane;
+import com.codename1.desktopcompat.javax.swing.JFormattedTextField;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.JTextPane;
+import com.codename1.desktopcompat.javax.swing.text.DefaultFormatter;
+import com.codename1.desktopcompat.javax.swing.text.NumberFormatter;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Formatted fields commit and revert their value the way the desktop
+/// ones do; the editor pane shows markup as text.
+public class FormattedFieldTest extends KernelTestBase {
+
+    private JFormattedTextField shown(Object value) {
+        JFrame f = new JFrame();
+        f.setLayout(new FlowLayout());
+        JFormattedTextField t = new JFormattedTextField(value);
+        t.setColumns(10);
+        f.add(t);
+        show(f);
+        return t;
+    }
+
+    private static void typed(JFormattedTextField t, String text) {
+        ((com.codename1.ui.TextArea) t.cn1Peer()).setText(text);
+    }
+
+    @Test
+    public void aNumberValueIsShownAndReadBackAsItsClass() throws Exception {
+        JFormattedTextField t = shown(Integer.valueOf(42));
+        assertEquals("42", t.getText());
+        assertTrue(t.getFormatter() instanceof NumberFormatter);
+        typed(t, "57");
+        assertEquals(Integer.valueOf(42), t.getValue());
+        assertTrue(t.isEditValid());
+        final List<Object> changes = new ArrayList<Object>();
+        t.addPropertyChangeListener("value", new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                changes.add(e.getNewValue());
+            }
+        });
+        t.commitEdit();
+        assertEquals(Integer.valueOf(57), t.getValue());
+        assertEquals("[57]", changes.toString());
+        typed(t, "seven");
+        assertFalse(t.isEditValid());
+        try {
+            t.commitEdit();
+            fail();
+        } catch (ParseException expected) {
+            assertEquals(Integer.valueOf(57), t.getValue());
+        }
+    }
+
+    @Test
+    public void losingTheFocusCommitsOrReverts() {
+        JFormattedTextField t = shown(Integer.valueOf(1));
+        typed(t, "25");
+        t.dispatchEvent(new FocusEvent(t, FocusEvent.FOCUS_LOST));
+        assertEquals(Integer.valueOf(25), t.getValue());
+        typed(t, "junk");
+        t.dispatchEvent(new FocusEvent(t, FocusEvent.FOCUS_LOST));
+        assertEquals(Integer.valueOf(25), t.getValue());
+        assertEquals("25", t.getText());
+        t.setFocusLostBehavior(JFormattedTextField.PERSIST);
+        typed(t, "junk");
+        t.dispatchEvent(new FocusEvent(t, FocusEvent.FOCUS_LOST));
+        assertEquals("junk", t.getText());
+        t.setFocusLostBehavior(JFormattedTextField.REVERT);
+        typed(t, "99");
+        t.dispatchEvent(new FocusEvent(t, FocusEvent.FOCUS_LOST));
+        assertEquals("25", t.getText());
+        assertEquals(Integer.valueOf(25), t.getValue());
+        try {
+            t.setFocusLostBehavior(9);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(JFormattedTextField.REVERT, t.getFocusLostBehavior());
+        }
+    }
+
+    @Test
+    public void finishingTheEditCommitsBeforeTheListenersHear() {
+        final JFormattedTextField t = shown(Integer.valueOf(1));
+        final List<Object> seen = new ArrayList<Object>();
+        t.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                seen.add(t.getValue());
+            }
+        });
+        typed(t, "8");
+        t.postActionEvent();
+        assertEquals("[8]", seen.toString());
+        typed(t, "x");
+        t.postActionEvent();
+        assertEquals("[8]", seen.toString());
+    }
+
+    @Test
+    public void aNumberFormatterKeepsToItsRange() throws Exception {
+        NumberFormat nf = NumberFormat.getIntegerInstance();
+        nf.setGroupingUsed(false);
+        NumberFormatter f = new NumberFormatter(nf);
+        f.setValueClass(Integer.class);
+        f.setMinimum(Integer.valueOf(0));
+        f.setMaximum(Integer.valueOf(100));
+        assertEquals(Integer.valueOf(50), f.stringToValue("50"));
+        assertEquals("1234", f.valueToString(Integer.valueOf(1234)));
+        assertEquals("", f.valueToString(null));
+        assertNull(f.stringToValue(""));
+        try {
+            f.stringToValue("101");
+            fail();
+        } catch (ParseException expected) {
+            assertEquals(Integer.valueOf(100), f.getMaximum());
+        }
+        JFormattedTextField t = new JFormattedTextField(f);
+        t.setValue(Integer.valueOf(7));
+        assertEquals("7", t.getText());
+        assertEquals(f, t.getFormatter());
+    }
+
+    @Test
+    public void theDefaultFormatterReadsTheValueClassBack() throws Exception {
+        DefaultFormatter f = new DefaultFormatter();
+        assertEquals("abc", f.stringToValue("abc"));
+        f.setValueClass(Double.class);
+        assertEquals(Double.valueOf(1.5), f.stringToValue("1.5"));
+        assertEquals("2.5", f.valueToString(Double.valueOf(2.5)));
+        try {
+            f.stringToValue("abc");
+            fail();
+        } catch (ParseException expected) {
+            assertTrue(f.getAllowsInvalid());
+        }
+        JFormattedTextField text = new JFormattedTextField("hello");
+        assertEquals("hello", text.getText());
+        text.setText("bye");
+        text.commitEdit();
+        assertEquals("bye", text.getValue());
+    }
+
+    @Test
+    public void anInputVerifierKeepsTheFocus() {
+        JFrame f = new JFrame();
+        f.setLayout(new FlowLayout());
+        JTextField t = new JTextField("abc", 8);
+        f.add(t);
+        show(f);
+        final int[] asked = {0};
+        InputVerifier v = new InputVerifier() {
+            @Override
+            public boolean verify(JComponent input) {
+                asked[0]++;
+                return ((JTextField) input).getText().length() > 0;
+            }
+        };
+        t.setInputVerifier(v);
+        assertEquals(v, t.getInputVerifier());
+        t.dispatchEvent(new FocusEvent(t, FocusEvent.FOCUS_LOST));
+        assertEquals(1, asked[0]);
+        t.setText("");
+        t.dispatchEvent(new FocusEvent(t, FocusEvent.FOCUS_LOST));
+        assertEquals(2, asked[0]);
+    }
+
+    @Test
+    public void anEditorPaneShowsMarkupAsText() {
+        JEditorPane p = new JEditorPane("text/html; charset=utf-8",
+                "<html><head><title>t</title></head><body><h1>Title</h1>\n<p>One &amp; <b>two</b><br>three</p>"
+                + "<ul><li>a</li><li>b &lt; c</li></ul></body></html>");
+        assertEquals("text/html", p.getContentType());
+        assertEquals("Title\nOne & two\nthree\na\nb < c", p.getDocument().getLength() == 0 ? "" : docText(p));
+        assertTrue(p.getText().startsWith("<html>"));
+        p.setContentType("text/plain");
+        p.setText("<b>kept</b>");
+        assertEquals("<b>kept</b>", p.getText());
+        JTextPane pane = new JTextPane();
+        pane.setText("plain");
+        assertEquals("plain", pane.getText());
+        JFrame f = new JFrame();
+        f.add(pane);
+        show(f);
+        assertEquals("plain", ((com.codename1.ui.TextArea) pane.cn1Peer()).getText());
+    }
+
+    private static String docText(JEditorPane p) {
+        try {
+            return p.getDocument().getText(0, p.getDocument().getLength());
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FrameAndLayoutTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FrameAndLayoutTest.java
new file mode 100644
index 00000000000..b5f0fd27c7b
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/FrameAndLayoutTest.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.GridLayout;
+import com.codename1.desktopcompat.java.awt.event.WindowAdapter;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.rt.ContainerPeer;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.ui.Display;
+import org.junit.Test;
+
+/// Showing a frame, and the bounds the layout managers give components
+/// and their peers once it is shown.
+public class FrameAndLayoutTest extends KernelTestBase {
+
+    @Test
+    public void showingAFrameShowsItsFormAndSizesTheWindowToIt() {
+        JFrame f = new JFrame("Title");
+        final int[] opened = new int[1];
+        f.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowOpened(WindowEvent e) {
+                opened[0]++;
+            }
+        });
+        assertFalse(f.isVisible());
+        show(f);
+        assertTrue(f.isVisible());
+        assertTrue(f.isShowing());
+        assertSame(f.cn1Form(), Display.getInstance().getCurrent());
+        assertEquals("Title", f.cn1Form().getTitle());
+        assertEquals(1, opened[0]);
+        com.codename1.ui.Component peer = f.cn1Peer();
+        assertTrue(peer.getWidth() > 0 && peer.getHeight() > 0);
+        assertEquals(Units.toLogical(peer.getWidth()), f.getWidth());
+        assertEquals(Units.toLogical(peer.getHeight()), f.getHeight());
+        assertEquals(f.getWidth(), f.getContentPane().getWidth());
+        assertEquals(f.getHeight(), f.getContentPane().getHeight());
+    }
+
+    @Test
+    public void borderLayoutPlacesComponentsAndPeers() {
+        JFrame f = new JFrame();
+        JButton south = new JButton("South");
+        JPanel center = new JPanel();
+        JLabel north = new JLabel("North");
+        f.add(south, BorderLayout.SOUTH);
+        f.add(center, BorderLayout.CENTER);
+        f.getContentPane().add(north, BorderLayout.NORTH);
+        show(f);
+        int w = f.getContentPane().getWidth();
+        int h = f.getContentPane().getHeight();
+        Dimension sp = south.getPreferredSize();
+        Dimension np = north.getPreferredSize();
+        assertTrue(sp.height > 0 && np.height > 0);
+        assertEquals(0, north.getY());
+        assertEquals(w, north.getWidth());
+        assertEquals(np.height, north.getHeight());
+        assertEquals(h - sp.height, south.getY());
+        assertEquals(w, south.getWidth());
+        assertEquals(np.height, center.getY());
+        assertEquals(h - sp.height - np.height, center.getHeight());
+
+        com.codename1.ui.Component sPeer = south.cn1Peer();
+        assertEquals(Units.toDevice(south.getY()), sPeer.getY());
+        assertEquals(Units.toDeviceSize(south.getY(), south.getHeight()), sPeer.getHeight());
+        assertEquals(Units.toDevice(w), sPeer.getWidth());
+        assertSame(f.getContentPane().cn1Peer(), sPeer.getParent());
+    }
+
+    @Test
+    public void aWidgetsPreferredSizeIsItsPeersInLogicalPixels() {
+        JButton b = new JButton("Preferred");
+        com.codename1.ui.Component peer = b.cn1Peer();
+        Dimension d = b.getPreferredSize();
+        assertEquals(Units.toLogicalCeil(peer.getPreferredW()), d.width);
+        assertEquals(Units.toLogicalCeil(peer.getPreferredH()), d.height);
+        b.setPreferredSize(new Dimension(120, 30));
+        assertEquals(new Dimension(120, 30), b.getPreferredSize());
+    }
+
+    @Test
+    public void flowAndGridLayoutsWorkInLogicalPixels() {
+        JFrame f = new JFrame();
+        JPanel flow = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 7));
+        JPanel a = sized(40, 20);
+        JPanel b = sized(60, 30);
+        flow.add(a);
+        flow.add(b);
+        JPanel grid = new JPanel(new GridLayout(1, 2, 10, 0));
+        JPanel g1 = new JPanel();
+        JPanel g2 = new JPanel();
+        grid.add(g1);
+        grid.add(g2);
+        grid.setPreferredSize(new Dimension(100, 50));
+        f.add(flow, BorderLayout.CENTER);
+        f.add(grid, BorderLayout.SOUTH);
+        show(f);
+        assertEquals(5, a.getX());
+        assertEquals(40, a.getWidth());
+        assertEquals(50, b.getX());
+        assertEquals(60, b.getWidth());
+        assertEquals(7, b.getY());
+        assertEquals(12, a.getY());
+        assertEquals(50, grid.getHeight());
+        int cell = (grid.getWidth() - 10) / 2;
+        assertEquals(cell, g1.getWidth());
+        assertEquals(cell, g2.getWidth());
+        assertEquals(g1.getX() + cell + 10, g2.getX());
+        assertEquals(Units.toDevice(a.getX()), a.cn1Peer().getX());
+        assertEquals(Units.toDevice(40), a.cn1Peer().getWidth());
+    }
+
+    @Test
+    public void peersAreStackedWithTheFirstChildOnTop() {
+        JPanel p = new JPanel(null);
+        JPanel first = new JPanel();
+        JPanel second = new JPanel();
+        p.add(first);
+        p.add(second);
+        ContainerPeer peer = (ContainerPeer) p.cn1Peer();
+        assertSame(second.cn1Peer(), peer.getComponentAt(0));
+        assertSame(first.cn1Peer(), peer.getComponentAt(1));
+        JPanel third = new JPanel();
+        p.add(third, 0);
+        assertSame(third.cn1Peer(), peer.getComponentAt(2));
+        p.remove(first);
+        assertEquals(2, peer.getComponentCount());
+        assertNotNull(first.cn1Peer());
+    }
+
+    @Test
+    public void revalidateLaysOutAComponentAddedLater() {
+        JFrame f = new JFrame();
+        JPanel content = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+        f.setContentPane(content);
+        show(f);
+        JPanel late = sized(30, 10);
+        content.add(late);
+        assertEquals(0, late.getWidth());
+        content.revalidate();
+        com.codename1.compat.testing.MainThreadRule.drain();
+        f.cn1Form().revalidate();
+        assertEquals(30, late.getWidth());
+        assertEquals(Units.toDevice(30), late.cn1Peer().getWidth());
+    }
+
+    /// A row that fits the display need not fit the room it is given: three
+    /// options beside a label on a phone. The flow wraps them, and a flow
+    /// that answered the height of one row all the same was one row high,
+    /// with the options after the first row placed below it and never
+    /// seen. The rows are counted at the width the flow was given, and the
+    /// container above lays it out again at the height they take.
+    @Test
+    public void aFlowNarrowerThanItsRowIsGivenTheHeightOfTheRowsItWrapsInto() {
+        JFrame f = new JFrame();
+        JPanel flow = new JPanel(new FlowLayout(FlowLayout.LEFT, 6, 0));
+        JPanel[] options = {sized(90, 20), sized(90, 20), sized(90, 20)};
+        for (int i = 0; i < options.length; i++) {
+            flow.add(options[i]);
+        }
+        int row = flow.getPreferredSize().width;
+        assertTrue("the row fits the display", row < Units.toLogical(Display.getInstance().getDisplayWidth()));
+        assertEquals(20, flow.getPreferredSize().height);
+        JPanel column = new JPanel(new BorderLayout());
+        column.add(flow, BorderLayout.NORTH);
+        column.add(new JPanel(), BorderLayout.CENTER);
+        f.add(sized(f.getWidth() > 0 ? f.getWidth() - 200 : 340, 10), BorderLayout.WEST);
+        f.add(column, BorderLayout.CENTER);
+        show(f);
+        com.codename1.compat.testing.MainThreadRule.drain();
+        f.cn1Form().revalidate();
+        assertTrue("narrower than its row: " + flow.getWidth() + " < " + row, flow.getWidth() < row);
+        assertTrue("wide enough for one option", flow.getWidth() >= 90 + 12);
+        for (int i = 0; i < options.length; i++) {
+            assertTrue("option " + i + " at " + options[i].getBounds() + " is inside " + flow.getBounds(),
+                    options[i].getY() >= 0 && options[i].getY() + options[i].getHeight() <= flow.getHeight());
+        }
+        assertTrue("more rows than one", options[2].getY() > options[0].getY());
+        // The width it asks for is still that of the one row, so that it
+        // gets the room wherever there is some.
+        assertEquals(row, flow.getPreferredSize().width);
+    }
+
+    private static JPanel sized(int w, int h) {
+        JPanel p = new JPanel();
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/InputInfrastructureTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/InputInfrastructureTest.java
new file mode 100644
index 00000000000..55719885a21
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/InputInfrastructureTest.java
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.KeyboardFocusManager;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyAdapter;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelListener;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.desktopcompat.rt.EventBridge;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Modifiers, buttons, click counts, enter and exit, the wheel, key
+/// bindings under each condition, key typed, and focus traversal.
+public class InputInfrastructureTest extends WindowsTestBase {
+
+    private static JPanel sized(int w, int h) {
+        JPanel p = new JPanel();
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+
+    private static final class Mice extends MouseAdapter {
+        final List<String> log = new ArrayList<String>();
+        final List<MouseEvent> events = new ArrayList<MouseEvent>();
+
+        private void add(String s, MouseEvent e) {
+            log.add(s);
+            events.add(e);
+        }
+
+        @Override
+        public void mousePressed(MouseEvent e) {
+            add("pressed", e);
+        }
+
+        @Override
+        public void mouseReleased(MouseEvent e) {
+            add("released", e);
+        }
+
+        @Override
+        public void mouseClicked(MouseEvent e) {
+            add("clicked", e);
+        }
+
+        @Override
+        public void mouseEntered(MouseEvent e) {
+            add("entered", e);
+        }
+
+        @Override
+        public void mouseExited(MouseEvent e) {
+            add("exited", e);
+        }
+
+        MouseEvent last(String kind) {
+            for (int i = log.size() - 1; i >= 0; i--) {
+                if (kind.equals(log.get(i))) {
+                    return events.get(i);
+                }
+            }
+            return null;
+        }
+    }
+
+    private static final class Counter extends AbstractAction {
+        int count;
+        ActionEvent last;
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            count++;
+            last = e;
+        }
+    }
+
+    private JFrame frame(JPanel content) {
+        JFrame f = new JFrame("input");
+        f.add(content, BorderLayout.CENTER);
+        return show(f);
+    }
+
+    @Test
+    public void mouseEventsCarryTheModifiersAndTheButton() {
+        JPanel p = sized(100, 100);
+        Mice mice = new Mice();
+        p.addMouseListener(mice);
+        JFrame f = frame(p);
+        input.modifiers = InputEvent.SHIFT_DOWN_MASK | InputEvent.CTRL_DOWN_MASK;
+        input.button = 2;
+        click(f, p, 10, 10);
+        MouseEvent press = mice.last("pressed");
+        assertTrue(press.isShiftDown());
+        assertTrue(press.isControlDown());
+        assertFalse(press.isAltDown());
+        assertEquals(MouseEvent.BUTTON2, press.getButton());
+        assertTrue((press.getModifiersEx() & InputEvent.BUTTON2_DOWN_MASK) != 0);
+        assertTrue(SwingUtilities.isMiddleMouseButton(press));
+        assertFalse(SwingUtilities.isLeftMouseButton(press));
+        MouseEvent release = mice.last("released");
+        assertEquals(MouseEvent.BUTTON2, release.getButton());
+        assertEquals(0, release.getModifiersEx() & InputEvent.BUTTON2_DOWN_MASK);
+        assertTrue(mice.last("clicked").isShiftDown());
+    }
+
+    @Test
+    public void clicksInOnePlaceCountUpAndAClickElsewhereStartsAgain() {
+        JPanel p = sized(200, 200);
+        Mice mice = new Mice();
+        p.addMouseListener(mice);
+        JFrame f = frame(p);
+        click(f, p, 20, 20);
+        assertEquals(1, mice.last("clicked").getClickCount());
+        click(f, p, 20, 20);
+        assertEquals(2, mice.last("pressed").getClickCount());
+        assertEquals(2, mice.last("clicked").getClickCount());
+        click(f, p, 20, 20);
+        assertEquals(3, mice.last("clicked").getClickCount());
+        click(f, p, 120, 120);
+        assertEquals(1, mice.last("clicked").getClickCount());
+        input.button = 3;
+        click(f, p, 120, 120);
+        assertEquals(1, mice.last("clicked").getClickCount());
+    }
+
+    @Test
+    public void aDisabledComponentGetsNoMouseEvents() {
+        JPanel p = sized(100, 100);
+        Mice mice = new Mice();
+        p.addMouseListener(mice);
+        JFrame f = frame(p);
+        p.setEnabled(false);
+        click(f, p, 10, 10);
+        assertTrue(mice.log.toString(), mice.log.isEmpty());
+        p.setEnabled(true);
+        click(f, p, 10, 10);
+        assertTrue(mice.log.contains("clicked"));
+    }
+
+    @Test
+    public void thePointerEntersOneComponentAndExitsTheOther() {
+        JPanel outer = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+        JPanel a = sized(50, 50);
+        JPanel b = sized(50, 50);
+        outer.add(a);
+        outer.add(b);
+        Mice onA = new Mice();
+        Mice onB = new Mice();
+        a.addMouseListener(onA);
+        b.addMouseListener(onB);
+        JFrame f = frame(outer);
+        pressOn(f, a, 5, 5);
+        releaseOn(f, a, 5, 5);
+        assertEquals("entered", onA.log.get(0));
+        pressOn(f, b, 5, 5);
+        assertEquals("exited", onA.log.get(onA.log.size() - 1));
+        assertEquals("entered", onB.log.get(0));
+        assertEquals("pressed", onB.log.get(1));
+        releaseOn(f, b, 5, 5);
+        EventBridge.pointerExit(f);
+        assertEquals("exited", onB.log.get(onB.log.size() - 1));
+    }
+
+    @Test
+    public void theSecondaryButtonIsThePopupTrigger() {
+        JPanel p = sized(100, 100);
+        Mice mice = new Mice();
+        p.addMouseListener(mice);
+        JFrame f = frame(p);
+        click(f, p, 10, 10);
+        assertFalse(mice.last("pressed").isPopupTrigger());
+        input.button = 3;
+        click(f, p, 10, 10);
+        assertTrue(mice.last("pressed").isPopupTrigger());
+        assertTrue(SwingUtilities.isRightMouseButton(mice.last("pressed")));
+    }
+
+    @Test
+    public void theWheelTurnsTheWayCodenameOneReportsIt() {
+        JPanel p = sized(100, 100);
+        final List<MouseWheelEvent> got = new ArrayList<MouseWheelEvent>();
+        p.addMouseWheelListener(new MouseWheelListener() {
+            @Override
+            public void mouseWheelMoved(MouseWheelEvent e) {
+                got.add(e);
+            }
+        });
+        JFrame f = frame(p);
+        int[] at = at(p, 10, 10);
+        // Codename One: a positive vertical delta is the wheel turned
+        // away from the user, which AWT reports as a negative rotation.
+        EventBridge.wheel(f, new com.codename1.ui.events.WheelEvent(f.cn1Form(), at[0], at[1], 0, 30, false, 0));
+        assertEquals(1, got.size());
+        assertEquals(-1, got.get(0).getWheelRotation());
+        assertFalse(got.get(0).isShiftDown());
+        EventBridge.wheel(f, new com.codename1.ui.events.WheelEvent(f.cn1Form(), at[0], at[1], 0, -30, false, 0));
+        assertEquals(1, got.get(1).getWheelRotation());
+        EventBridge.wheel(f, new com.codename1.ui.events.WheelEvent(f.cn1Form(), at[0], at[1], 30, 0, false, 0));
+        assertTrue(got.get(2).isShiftDown());
+    }
+
+    @Test
+    public void aKeyIsPressedTypedAndReleasedWithItsVirtualKeyAndCharacter() {
+        JPanel p = sized(100, 100);
+        final List<String> log = new ArrayList<String>();
+        JFrame f = frame(p);
+        f.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                log.add("pressed " + e.getKeyCode() + " " + e.getKeyChar());
+            }
+
+            @Override
+            public void keyTyped(KeyEvent e) {
+                log.add("typed " + e.getKeyCode() + " " + e.getKeyChar());
+            }
+
+            @Override
+            public void keyReleased(KeyEvent e) {
+                log.add("released " + e.getKeyCode() + " " + e.isShiftDown());
+            }
+        });
+        type(f, 'a');
+        assertEquals("pressed " + KeyEvent.VK_A + " a", log.get(0));
+        assertEquals("typed " + KeyEvent.VK_UNDEFINED + " a", log.get(1));
+        assertEquals("released " + KeyEvent.VK_A + " false", log.get(2));
+        log.clear();
+        input.modifiers = InputEvent.SHIFT_DOWN_MASK;
+        type(f, 'A');
+        assertEquals("pressed " + KeyEvent.VK_A + " A", log.get(0));
+        assertEquals("released " + KeyEvent.VK_A + " true", log.get(2));
+        log.clear();
+        input.control();
+        type(f, 's');
+        assertEquals("no key typed with control held: " + log, 2, log.size());
+    }
+
+    @Test
+    public void aBindingRunsWhenItsComponentHasTheFocus() {
+        JPanel p = new JPanel(new FlowLayout());
+        JButton a = new JButton("A");
+        JButton b = new JButton("B");
+        p.add(a);
+        p.add(b);
+        JFrame f = frame(p);
+        Counter action = new Counter();
+        a.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_X, 0), "x");
+        a.getActionMap().put("x", action);
+        b.requestFocusInWindow();
+        type(f, 'x');
+        assertEquals(0, action.count);
+        a.requestFocusInWindow();
+        type(f, 'x');
+        assertEquals(1, action.count);
+        assertSame(a, action.last.getSource());
+        action.setEnabled(false);
+        type(f, 'x');
+        assertEquals(1, action.count);
+    }
+
+    @Test
+    public void aBindingOfAnAncestorRunsForAFocusedDescendant() {
+        JPanel left = new JPanel(new FlowLayout());
+        JPanel right = new JPanel(new FlowLayout());
+        JButton inLeft = new JButton("L");
+        JButton inRight = new JButton("R");
+        left.add(inLeft);
+        right.add(inRight);
+        JPanel both = new JPanel(new FlowLayout());
+        both.add(left);
+        both.add(right);
+        JFrame f = frame(both);
+        Counter action = new Counter();
+        left.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke(KeyEvent.VK_D, 0), "d");
+        left.getActionMap().put("d", action);
+        inRight.requestFocusInWindow();
+        type(f, 'd');
+        assertEquals(0, action.count);
+        inLeft.requestFocusInWindow();
+        type(f, 'd');
+        assertEquals(1, action.count);
+        assertSame(left, action.last.getSource());
+    }
+
+    @Test
+    public void aWindowBindingRunsWhereverTheFocusIsAndNeedsItsModifiers() {
+        JPanel p = new JPanel(new FlowLayout());
+        JButton a = new JButton("A");
+        JPanel other = sized(20, 20);
+        p.add(a);
+        p.add(other);
+        JFrame f = frame(p);
+        final List<String> commands = new ArrayList<String>();
+        other.registerKeyboardAction(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                commands.add(e.getActionCommand());
+            }
+        }, "save", KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK),
+                JComponent.WHEN_IN_FOCUSED_WINDOW);
+        assertEquals(JComponent.WHEN_IN_FOCUSED_WINDOW,
+                other.getConditionForKeyStroke(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK)));
+        assertEquals(1, other.getRegisteredKeyStrokes().length);
+        type(f, 's');
+        assertTrue(commands.isEmpty());
+        input.control();
+        type(f, 's');
+        assertEquals(1, commands.size());
+        assertEquals("save", commands.get(0));
+        a.requestFocusInWindow();
+        type(f, 's');
+        assertEquals(2, commands.size());
+        other.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));
+        type(f, 's');
+        assertEquals(2, commands.size());
+    }
+
+    @Test
+    public void aKeyListenerThatConsumesTheKeyKeepsItFromTheBindings() {
+        JPanel p = new JPanel(new FlowLayout());
+        JButton a = new JButton("A");
+        p.add(a);
+        JFrame f = frame(p);
+        Counter action = new Counter();
+        a.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_X, 0), "x");
+        a.getActionMap().put("x", action);
+        a.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                e.consume();
+            }
+        });
+        a.requestFocusInWindow();
+        type(f, 'x');
+        assertEquals(0, action.count);
+    }
+
+    @Test
+    public void aBindingOnTheReleaseOfAKeyAndOneOnATypedCharacter() {
+        JPanel p = sized(50, 50);
+        JFrame f = frame(p);
+        Counter released = new Counter();
+        Counter typed = new Counter();
+        p.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke(KeyEvent.VK_R, 0, true), "r");
+        p.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke('q'), "q");
+        p.getActionMap().put("r", released);
+        p.getActionMap().put("q", typed);
+        f.cn1Form().keyPressed('r');
+        assertEquals(0, released.count);
+        f.cn1Form().keyReleased('r');
+        assertEquals(1, released.count);
+        type(f, 'q');
+        assertEquals(1, typed.count);
+    }
+
+    @Test
+    public void theTabKeyMovesTheFocusForwardAndWithShiftBackward() {
+        JPanel p = new JPanel(new FlowLayout());
+        JButton a = new JButton("A");
+        JButton b = new JButton("B");
+        JButton c = new JButton("C");
+        p.add(a);
+        p.add(b);
+        p.add(c);
+        JFrame f = frame(p);
+        a.requestFocusInWindow();
+        KeyboardFocusManager m = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+        assertSame(a, m.getFocusOwner());
+        assertSame(f, m.getActiveWindow());
+        type(f, '\t');
+        assertSame(b, m.getFocusOwner());
+        b.setEnabled(true);
+        c.setEnabled(false);
+        type(f, '\t');
+        assertSame("a disabled component is skipped", a, m.getFocusOwner());
+        input.modifiers = InputEvent.SHIFT_DOWN_MASK;
+        type(f, '\t');
+        assertSame(b, m.getFocusOwner());
+        input.modifiers = 0;
+        b.transferFocus();
+        assertSame(a, m.getFocusOwner());
+        assertNotNull(m.getDefaultFocusTraversalPolicy());
+        assertNull(f.getFocusTraversalPolicy());
+        m.clearGlobalFocusOwner();
+        assertNull(m.getFocusOwner());
+    }
+
+    @Test
+    public void theToolTipIsTheToolTipOfTheCodenameOneWidget() {
+        JPanel p = new JPanel(new FlowLayout());
+        JButton a = new JButton("A");
+        a.setToolTipText("before");
+        p.add(a);
+        frame(p);
+        assertEquals("before", a.cn1Peer().getTooltip());
+        a.setToolTipText("after");
+        assertEquals("after", a.cn1Peer().getTooltip());
+        assertEquals("after", a.getToolTipText());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/KernelTestBase.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/KernelTestBase.java
new file mode 100644
index 00000000000..bf33adfdde8
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/KernelTestBase.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.rt.EventBridge;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.ui.Image;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+
+/// What the tests that need a display share: the headless Codename One
+/// implementation, the event dispatch thread, a scale of two device pixels
+/// per logical pixel, and helpers that paint a frame and send it input.
+public abstract class KernelTestBase {
+
+    @Rule
+    public final MainThreadRule edt = new MainThreadRule();
+
+    private final List<JFrame> shown = new ArrayList<JFrame>();
+
+    @BeforeClass
+    public static void boot() {
+        HeadlessImplementation.install();
+    }
+
+    @Before
+    public void scale() {
+        Units.setScale(2f);
+    }
+
+    @After
+    public void cleanUp() {
+        for (int i = shown.size() - 1; i >= 0; i--) {
+            shown.get(i).dispose();
+        }
+        HeadlessImplementation.recordText = false;
+        HeadlessImplementation.drawnText.clear();
+        Units.setScale(0);
+        EventBridge.resetClickCount();
+    }
+
+    /// Shows the frame and remembers to dispose of it.
+    protected JFrame show(JFrame f) {
+        shown.add(f);
+        f.setVisible(true);
+        return f;
+    }
+
+    /// Paints the frame's form and answers the strings drawn, each as
+    /// `{text, x, y}` in device pixels.
+    protected List<Object[]> paint(JFrame f) {
+        HeadlessImplementation.drawnText.clear();
+        HeadlessImplementation.recordText = true;
+        try {
+            Image target = Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+            f.cn1Form().paintComponent(target.getGraphics());
+            return new ArrayList<Object[]>(HeadlessImplementation.drawnText);
+        } finally {
+            HeadlessImplementation.recordText = false;
+            HeadlessImplementation.drawnText.clear();
+        }
+    }
+
+    /// Paints the frame's form into pixels and answers them as rows of
+    /// ARGB, in device pixels. Shapes are filled in their color inside the
+    /// clip; a string is a solid box of the size it measures.
+    protected int[][] raster(JFrame f) {
+        boolean clip = HeadlessImplementation.trackClip;
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.trackClip = true;
+        try {
+            Image target = Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT, 0xffffffff);
+            com.codename1.ui.Graphics g = target.getGraphics();
+            g.setClip(0, 0, HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+            f.cn1Form().paintComponent(g);
+            Object rows = target.getImage();
+            return rows instanceof int[][] ? (int[][]) rows : new int[0][0];
+        } finally {
+            HeadlessImplementation.rasterImages = false;
+            HeadlessImplementation.trackClip = clip;
+            HeadlessImplementation.resetRaster();
+        }
+    }
+
+    /// The pixel painted at a logical point of `c`, as RGB.
+    protected static int pixel(int[][] rows, Component c, int x, int y) {
+        int[] p = onDisplay(c, x, y);
+        return rows[p[1]][p[0]] & 0xffffff;
+    }
+
+    /// How many pixels inside the logical rectangle of `c` have the color.
+    protected static int count(int[][] rows, Component c, int x, int y, int w, int h, int rgb) {
+        int[] a = onDisplay(c, x, y);
+        int[] b = onDisplay(c, x + w, y + h);
+        int n = 0;
+        for (int row = Math.max(0, a[1]); row < Math.min(rows.length, b[1]); row++) {
+            for (int col = Math.max(0, a[0]); col < Math.min(rows[row].length, b[0]); col++) {
+                if ((rows[row][col] & 0xffffff) == (rgb & 0xffffff)) {
+                    n++;
+                }
+            }
+        }
+        return n;
+    }
+
+    protected static Object[] find(List<Object[]> text, String s) {
+        for (int i = 0; i < text.size(); i++) {
+            if (s.equals(text.get(i)[0])) {
+                return text.get(i);
+            }
+        }
+        return null;
+    }
+
+    /// The display position of a logical point of `c`.
+    protected static int[] onDisplay(Component c, int x, int y) {
+        com.codename1.ui.Component p = c.cn1Peer();
+        return new int[]{p.getAbsoluteX() + Units.toDevice(x), p.getAbsoluteY() + Units.toDevice(y)};
+    }
+
+    protected static void press(JFrame f, Component c, int x, int y) {
+        int[] p = onDisplay(c, x, y);
+        f.cn1Form().pointerPressed(p[0], p[1]);
+    }
+
+    /// Drags the pointer the way the display does: through the overload
+    /// of a form that takes arrays, which is the one a real drag arrives
+    /// at.
+    protected static void drag(JFrame f, Component c, int x, int y) {
+        int[] p = onDisplay(c, x, y);
+        f.cn1Form().pointerDragged(new int[]{p[0]}, new int[]{p[1]});
+    }
+
+    protected static void release(JFrame f, Component c, int x, int y) {
+        int[] p = onDisplay(c, x, y);
+        f.cn1Form().pointerReleased(p[0], p[1]);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/LayoutParityTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/LayoutParityTest.java
new file mode 100644
index 00000000000..59142b79b47
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/LayoutParityTest.java
@@ -0,0 +1,1235 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.Test;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.LayoutManager;
+import com.codename1.desktopcompat.java.awt.LayoutManager2;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/// Lays the same component tree out twice -- once with the JDK's own layout
+/// managers and once with this layer's -- and requires identical results.
+///
+/// A tree is described once, as [Node]s, and built from both class
+/// libraries. Leaves are bare lightweight components with fixed minimum,
+/// preferred and maximum sizes, so nothing depends on fonts, a look and feel
+/// or a display, and the JDK side runs headless. After the root is sized and
+/// every container laid out top down, the two trees are written out as text
+/// -- the bounds and visibility of every component, and what each
+/// container's layout manager answers for its preferred, minimum and maximum
+/// size -- and the two texts are compared.
+///
+/// Besides the hand written cases, `GridBagLayout` and `BoxLayout` are run
+/// over a few hundred trees drawn from a seeded random generator, since
+/// their arithmetic has far more paths than a handful of examples reach.
+public class LayoutParityTest {
+
+    /// The comparison is with a desktop, whose display holds the rows laid
+    /// out here: on one that is narrower a flow layout asks for the height
+    /// of the rows it wraps into, which no desktop does.
+    @org.junit.Before
+    public void aDisplayWideEnough() {
+        com.codename1.desktopcompat.rt.Units.setScale(1f);
+    }
+
+    @org.junit.After
+    public void theDisplaysOwnScale() {
+        com.codename1.desktopcompat.rt.Units.setScale(0);
+    }
+
+    static {
+        System.setProperty("java.awt.headless", "true");
+    }
+
+    private static final int LEAF = 0;
+    private static final int PANEL = 1;
+    private static final int HGLUE = 2;
+    private static final int VGLUE = 3;
+    private static final int GLUE = 4;
+    private static final int HSTRUT = 5;
+    private static final int VSTRUT = 6;
+    private static final int RIGID = 7;
+
+    private static final int FLOW = 0;
+    private static final int BORDER = 1;
+    private static final int GRID = 2;
+    private static final int CARD = 3;
+    private static final int BOX = 4;
+    private static final int GRIDBAG = 5;
+    private static final int OVERLAY = 6;
+
+    /// One component of a tree, independent of the class library it is
+    /// built from.
+    private static final class Node {
+        final int kind;
+        int pw;
+        int ph;
+        int minw;
+        int minh;
+        int maxw = -1;
+        int maxh = -1;
+        float ax = 0.5f;
+        float ay = 0.5f;
+        boolean hidden;
+        int base = -1;
+        int[] layout;
+        int[] border;
+        int[] colW;
+        int[] rowH;
+        double[] colWt;
+        double[] rowWt;
+        final List<Node> kids = new ArrayList<Node>();
+        final List<Object> cons = new ArrayList<Object>();
+
+        Node(int kind) {
+            this.kind = kind;
+        }
+
+        Node min(int w, int h) {
+            minw = w;
+            minh = h;
+            return this;
+        }
+
+        Node max(int w, int h) {
+            maxw = w;
+            maxh = h;
+            return this;
+        }
+
+        Node align(float x, float y) {
+            ax = x;
+            ay = y;
+            return this;
+        }
+
+        Node hide() {
+            hidden = true;
+            return this;
+        }
+
+        /// Gives the leaf a baseline that many pixels from its top,
+        /// whatever its size.
+        Node base(int b) {
+            base = b;
+            return this;
+        }
+
+        Node border(int top, int left, int bottom, int right) {
+            border = new int[] {top, left, bottom, right};
+            return this;
+        }
+
+        Node add(Node child) {
+            return add(child, null);
+        }
+
+        Node add(Node child, Object constraint) {
+            kids.add(child);
+            cons.add(constraint);
+            return this;
+        }
+    }
+
+    /// Grid bag constraints, independent of the class library.
+    private static final class G {
+        int gridx = -1;
+        int gridy = -1;
+        int gw = 1;
+        int gh = 1;
+        double wx;
+        double wy;
+        int anchor = 10;
+        int fill;
+        int top;
+        int left;
+        int bottom;
+        int right;
+        int ipadx;
+        int ipady;
+
+        G at(int x, int y) {
+            gridx = x;
+            gridy = y;
+            return this;
+        }
+
+        G span(int w, int h) {
+            gw = w;
+            gh = h;
+            return this;
+        }
+
+        G weight(double x, double y) {
+            wx = x;
+            wy = y;
+            return this;
+        }
+
+        G anchor(int a) {
+            anchor = a;
+            return this;
+        }
+
+        G fill(int f) {
+            fill = f;
+            return this;
+        }
+
+        G insets(int t, int l, int b, int r) {
+            top = t;
+            left = l;
+            bottom = b;
+            right = r;
+            return this;
+        }
+
+        G ipad(int x, int y) {
+            ipadx = x;
+            ipady = y;
+            return this;
+        }
+    }
+
+    private static Node leaf(int w, int h) {
+        Node n = new Node(LEAF);
+        n.pw = w;
+        n.ph = h;
+        n.minw = w;
+        n.minh = h;
+        return n;
+    }
+
+    private static Node filler(int kind, int w, int h) {
+        Node n = new Node(kind);
+        n.pw = w;
+        n.ph = h;
+        return n;
+    }
+
+    private static Node panel(int... layout) {
+        Node n = new Node(PANEL);
+        n.layout = layout;
+        return n;
+    }
+
+    private static G g() {
+        return new G();
+    }
+
+    // ------------------------------------------------------------------
+    // The JDK side
+
+    private static final class RealLeaf extends java.awt.Component {
+        private static final long serialVersionUID = 1L;
+        private final float ax;
+        private final float ay;
+
+        private final int base;
+
+        RealLeaf(float ax, float ay, int base) {
+            this.ax = ax;
+            this.ay = ay;
+            this.base = base;
+        }
+
+        @Override
+        public int getBaseline(int width, int height) {
+            return base;
+        }
+
+        @Override
+        public float getAlignmentX() {
+            return ax;
+        }
+
+        @Override
+        public float getAlignmentY() {
+            return ay;
+        }
+    }
+
+    private static java.awt.Component real(Node n) {
+        switch (n.kind) {
+            case LEAF: {
+                java.awt.Component c = new RealLeaf(n.ax, n.ay, n.base);
+                c.setPreferredSize(new java.awt.Dimension(n.pw, n.ph));
+                c.setMinimumSize(new java.awt.Dimension(n.minw, n.minh));
+                if (n.maxw >= 0) {
+                    c.setMaximumSize(new java.awt.Dimension(n.maxw, n.maxh));
+                }
+                c.setVisible(!n.hidden);
+                return c;
+            }
+            case HGLUE:
+                return javax.swing.Box.createHorizontalGlue();
+            case VGLUE:
+                return javax.swing.Box.createVerticalGlue();
+            case GLUE:
+                return javax.swing.Box.createGlue();
+            case HSTRUT:
+                return javax.swing.Box.createHorizontalStrut(n.pw);
+            case VSTRUT:
+                return javax.swing.Box.createVerticalStrut(n.ph);
+            case RIGID:
+                return javax.swing.Box.createRigidArea(new java.awt.Dimension(n.pw, n.ph));
+            default:
+                break;
+        }
+        java.awt.Container c;
+        if (n.border != null) {
+            javax.swing.JComponent jc = new javax.swing.JComponent() {
+                private static final long serialVersionUID = 1L;
+            };
+            jc.setBorder(javax.swing.BorderFactory.createEmptyBorder(n.border[0], n.border[1], n.border[2],
+                    n.border[3]));
+            c = jc;
+        } else {
+            c = new java.awt.Container();
+        }
+        int[] l = n.layout;
+        switch (l[0]) {
+            case FLOW:
+                c.setLayout(new java.awt.FlowLayout(l[1], l[2], l[3]));
+                break;
+            case BORDER:
+                c.setLayout(new java.awt.BorderLayout(l[1], l[2]));
+                break;
+            case GRID:
+                c.setLayout(new java.awt.GridLayout(l[1], l[2], l[3], l[4]));
+                break;
+            case CARD:
+                c.setLayout(new java.awt.CardLayout(l[1], l[2]));
+                break;
+            case BOX:
+                c.setLayout(new javax.swing.BoxLayout(c, l[1]));
+                break;
+            case OVERLAY:
+                c.setLayout(new javax.swing.OverlayLayout(c));
+                break;
+            default: {
+                java.awt.GridBagLayout gb = new java.awt.GridBagLayout();
+                gb.columnWidths = n.colW;
+                gb.rowHeights = n.rowH;
+                gb.columnWeights = n.colWt;
+                gb.rowWeights = n.rowWt;
+                c.setLayout(gb);
+                break;
+            }
+        }
+        for (int i = 0; i < n.kids.size(); i++) {
+            Object con = n.cons.get(i);
+            if (con instanceof G) {
+                G s = (G) con;
+                con = new java.awt.GridBagConstraints(s.gridx, s.gridy, s.gw, s.gh, s.wx, s.wy, s.anchor, s.fill,
+                        new java.awt.Insets(s.top, s.left, s.bottom, s.right), s.ipadx, s.ipady);
+            }
+            java.awt.Component kid = real(n.kids.get(i));
+            if (con == null) {
+                c.add(kid);
+            } else {
+                c.add(kid, con);
+            }
+        }
+        if (n.hidden) {
+            c.setVisible(false);
+        }
+        return c;
+    }
+
+    private static void layout(java.awt.Component c) {
+        if (c instanceof java.awt.Container && !(c instanceof javax.swing.Box.Filler)) {
+            java.awt.Container k = (java.awt.Container) c;
+            k.invalidate();
+            k.doLayout();
+            for (int i = 0; i < k.getComponentCount(); i++) {
+                layout(k.getComponent(i));
+            }
+        }
+    }
+
+    private static void dump(java.awt.Component c, String path, StringBuilder sb) {
+        sb.append(path).append(' ').append(c.getX()).append(',').append(c.getY()).append(' ').append(c.getWidth())
+                .append('x').append(c.getHeight()).append(c.isVisible() ? "" : " hidden");
+        if (c instanceof java.awt.Container && !(c instanceof javax.swing.Box.Filler)) {
+            java.awt.Container k = (java.awt.Container) c;
+            java.awt.LayoutManager lm = k.getLayout();
+            if (lm != null) {
+                java.awt.Dimension p = lm.preferredLayoutSize(k);
+                java.awt.Dimension m = lm.minimumLayoutSize(k);
+                sb.append(" pref=").append(p.width).append('x').append(p.height);
+                sb.append(" min=").append(m.width).append('x').append(m.height);
+                if (lm instanceof java.awt.LayoutManager2) {
+                    java.awt.Dimension x = ((java.awt.LayoutManager2) lm).maximumLayoutSize(k);
+                    sb.append(" max=").append(x.width).append('x').append(x.height);
+                }
+            }
+            java.awt.Insets in = k.getInsets();
+            sb.append(" in=").append(in.top).append(',').append(in.left).append(',').append(in.bottom).append(',')
+                    .append(in.right).append('\n');
+            for (int i = 0; i < k.getComponentCount(); i++) {
+                dump(k.getComponent(i), path + "/" + i, sb);
+            }
+        } else {
+            sb.append('\n');
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // This layer's side
+
+    private static final class OurLeaf extends Component {
+        private final float ax;
+        private final float ay;
+
+        private final int base;
+
+        OurLeaf(float ax, float ay, int base) {
+            this.ax = ax;
+            this.ay = ay;
+            this.base = base;
+        }
+
+        @Override
+        public int getBaseline(int width, int height) {
+            return base;
+        }
+
+        @Override
+        public float getAlignmentX() {
+            return ax;
+        }
+
+        @Override
+        public float getAlignmentY() {
+            return ay;
+        }
+    }
+
+    private static Component ours(Node n) {
+        switch (n.kind) {
+            case LEAF: {
+                Component c = new OurLeaf(n.ax, n.ay, n.base);
+                c.setPreferredSize(new Dimension(n.pw, n.ph));
+                c.setMinimumSize(new Dimension(n.minw, n.minh));
+                if (n.maxw >= 0) {
+                    c.setMaximumSize(new Dimension(n.maxw, n.maxh));
+                }
+                c.setVisible(!n.hidden);
+                return c;
+            }
+            case HGLUE:
+                return com.codename1.desktopcompat.javax.swing.Box.createHorizontalGlue();
+            case VGLUE:
+                return com.codename1.desktopcompat.javax.swing.Box.createVerticalGlue();
+            case GLUE:
+                return com.codename1.desktopcompat.javax.swing.Box.createGlue();
+            case HSTRUT:
+                return com.codename1.desktopcompat.javax.swing.Box.createHorizontalStrut(n.pw);
+            case VSTRUT:
+                return com.codename1.desktopcompat.javax.swing.Box.createVerticalStrut(n.ph);
+            case RIGID:
+                return com.codename1.desktopcompat.javax.swing.Box.createRigidArea(new Dimension(n.pw, n.ph));
+            default:
+                break;
+        }
+        Container c;
+        if (n.border != null) {
+            JComponent jc = new JComponent() {
+            };
+            jc.setBorder(new EmptyBorder(n.border[0], n.border[1], n.border[2], n.border[3]));
+            c = jc;
+        } else {
+            c = new Container();
+        }
+        int[] l = n.layout;
+        switch (l[0]) {
+            case FLOW:
+                c.setLayout(new com.codename1.desktopcompat.java.awt.FlowLayout(l[1], l[2], l[3]));
+                break;
+            case BORDER:
+                c.setLayout(new com.codename1.desktopcompat.java.awt.BorderLayout(l[1], l[2]));
+                break;
+            case GRID:
+                c.setLayout(new com.codename1.desktopcompat.java.awt.GridLayout(l[1], l[2], l[3], l[4]));
+                break;
+            case CARD:
+                c.setLayout(new com.codename1.desktopcompat.java.awt.CardLayout(l[1], l[2]));
+                break;
+            case BOX:
+                c.setLayout(new com.codename1.desktopcompat.javax.swing.BoxLayout(c, l[1]));
+                break;
+            case OVERLAY:
+                c.setLayout(new com.codename1.desktopcompat.javax.swing.OverlayLayout(c));
+                break;
+            default: {
+                com.codename1.desktopcompat.java.awt.GridBagLayout gb =
+                        new com.codename1.desktopcompat.java.awt.GridBagLayout();
+                gb.columnWidths = n.colW;
+                gb.rowHeights = n.rowH;
+                gb.columnWeights = n.colWt;
+                gb.rowWeights = n.rowWt;
+                c.setLayout(gb);
+                break;
+            }
+        }
+        for (int i = 0; i < n.kids.size(); i++) {
+            Object con = n.cons.get(i);
+            if (con instanceof G) {
+                G s = (G) con;
+                con = new com.codename1.desktopcompat.java.awt.GridBagConstraints(s.gridx, s.gridy, s.gw, s.gh, s.wx,
+                        s.wy, s.anchor, s.fill, new Insets(s.top, s.left, s.bottom, s.right), s.ipadx, s.ipady);
+            }
+            Component kid = ours(n.kids.get(i));
+            if (con == null) {
+                c.add(kid);
+            } else {
+                c.add(kid, con);
+            }
+        }
+        if (n.hidden) {
+            c.setVisible(false);
+        }
+        return c;
+    }
+
+    private static void layout(Component c) {
+        if (c instanceof Container && !(c instanceof com.codename1.desktopcompat.javax.swing.Box.Filler)) {
+            Container k = (Container) c;
+            k.invalidate();
+            k.doLayout();
+            for (int i = 0; i < k.getComponentCount(); i++) {
+                layout(k.getComponent(i));
+            }
+        }
+    }
+
+    private static void dump(Component c, String path, StringBuilder sb) {
+        sb.append(path).append(' ').append(c.getX()).append(',').append(c.getY()).append(' ').append(c.getWidth())
+                .append('x').append(c.getHeight()).append(c.isVisible() ? "" : " hidden");
+        if (c instanceof Container && !(c instanceof com.codename1.desktopcompat.javax.swing.Box.Filler)) {
+            Container k = (Container) c;
+            LayoutManager lm = k.getLayout();
+            if (lm != null) {
+                Dimension p = lm.preferredLayoutSize(k);
+                Dimension m = lm.minimumLayoutSize(k);
+                sb.append(" pref=").append(p.width).append('x').append(p.height);
+                sb.append(" min=").append(m.width).append('x').append(m.height);
+                if (lm instanceof LayoutManager2) {
+                    Dimension x = ((LayoutManager2) lm).maximumLayoutSize(k);
+                    sb.append(" max=").append(x.width).append('x').append(x.height);
+                }
+            }
+            Insets in = k.getInsets();
+            sb.append(" in=").append(in.top).append(',').append(in.left).append(',').append(in.bottom).append(',')
+                    .append(in.right).append('\n');
+            for (int i = 0; i < k.getComponentCount(); i++) {
+                dump(k.getComponent(i), path + "/" + i, sb);
+            }
+        } else {
+            sb.append('\n');
+        }
+    }
+
+    // ------------------------------------------------------------------
+
+    private static String dump(java.awt.Component c) {
+        StringBuilder sb = new StringBuilder();
+        dump(c, "", sb);
+        return sb.toString();
+    }
+
+    private static String dump(Component c) {
+        StringBuilder sb = new StringBuilder();
+        dump(c, "", sb);
+        return sb.toString();
+    }
+
+    /// Builds the tree from both libraries, lays it out at each of the
+    /// sizes given as width and height pairs, and compares.
+    private static void check(String what, Node tree, int... sizes) {
+        java.awt.Component r = real(tree);
+        Component o = ours(tree);
+        for (int i = 0; i < sizes.length; i += 2) {
+            r.setSize(sizes[i], sizes[i + 1]);
+            o.setSize(sizes[i], sizes[i + 1]);
+            layout(r);
+            layout(o);
+            String expected = dump(r);
+            String actual = dump(o);
+            if (!expected.equals(actual)) {
+                assertEquals(what + " at " + sizes[i] + "x" + sizes[i + 1] + "\n" + describe(tree, ""), expected,
+                        actual);
+            }
+        }
+    }
+
+    /// The tree as text, for the message of a failed comparison.
+    private static String describe(Node n, String indent) {
+        StringBuilder sb = new StringBuilder(indent);
+        sb.append("kind=").append(n.kind).append(" pref=").append(n.pw).append('x').append(n.ph).append(" min=")
+                .append(n.minw).append('x').append(n.minh).append(" max=").append(n.maxw).append('x').append(n.maxh)
+                .append(" align=").append(n.ax).append(',').append(n.ay).append(n.hidden ? " hidden" : "");
+        if (n.layout != null) {
+            sb.append(" layout=").append(java.util.Arrays.toString(n.layout));
+        }
+        if (n.border != null) {
+            sb.append(" border=").append(java.util.Arrays.toString(n.border));
+        }
+        if (n.colW != null || n.rowH != null || n.colWt != null || n.rowWt != null) {
+            sb.append(" overrides=").append(java.util.Arrays.toString(n.colW)).append(java.util.Arrays.toString(n.rowH))
+                    .append(java.util.Arrays.toString(n.colWt)).append(java.util.Arrays.toString(n.rowWt));
+        }
+        sb.append('\n');
+        for (int i = 0; i < n.kids.size(); i++) {
+            Object con = n.cons.get(i);
+            if (con instanceof G) {
+                G s = (G) con;
+                sb.append(indent).append("  at ").append(s.gridx).append(',').append(s.gridy).append(" span ")
+                        .append(s.gw).append(',').append(s.gh).append(" weight ").append(s.wx).append(',')
+                        .append(s.wy).append(" anchor ").append(s.anchor).append(" fill ").append(s.fill)
+                        .append(" insets ").append(s.top).append(',').append(s.left).append(',').append(s.bottom)
+                        .append(',').append(s.right).append(" ipad ").append(s.ipadx).append(',').append(s.ipady)
+                        .append('\n');
+            } else if (con != null) {
+                sb.append(indent).append("  at ").append(con).append('\n');
+            }
+            sb.append(describe(n.kids.get(i), indent + "  "));
+        }
+        return sb.toString();
+    }
+
+    private static Node sixLeaves(Node p) {
+        p.add(leaf(40, 20)).add(leaf(70, 35)).add(leaf(25, 10).hide()).add(leaf(55, 28)).add(leaf(90, 14))
+                .add(leaf(33, 41).min(10, 12));
+        return p;
+    }
+
+    @Test
+    public void flowLayout() {
+        int[][] gaps = {{5, 5}, {7, 3}, {0, 0}, {-2, 4}};
+        for (int align = 0; align <= 4; align++) {
+            for (int[] gap : gaps) {
+                check("flow align " + align + " gap " + gap[0], sixLeaves(panel(FLOW, align, gap[0], gap[1])), 400,
+                        200, 331, 90, 150, 300, 121, 77, 60, 60, 0, 0);
+                check("flow with insets, align " + align,
+                        sixLeaves(panel(FLOW, align, gap[0], gap[1]).border(3, 11, 6, 2)), 400, 200, 175, 80, 20, 20);
+            }
+        }
+        check("empty flow", panel(FLOW, 1, 5, 5), 100, 100);
+        check("all hidden", panel(FLOW, 0, 5, 5).add(leaf(10, 10).hide()).add(leaf(20, 20).hide()), 100, 100);
+    }
+
+    @Test
+    public void borderLayout() {
+        String[] names = {"North", "South", "East", "West", "Center"};
+        int[][] sizes = {{60, 20}, {80, 25}, {30, 50}, {35, 45}, {100, 70}};
+        int[][] gaps = {{0, 0}, {4, 6}};
+        for (int[] gap : gaps) {
+            for (int mask = 0; mask < 32; mask++) {
+                Node p = panel(BORDER, gap[0], gap[1]);
+                Node q = panel(BORDER, gap[0], gap[1]).border(5, 7, 9, 11);
+                for (int i = 0; i < 5; i++) {
+                    if ((mask & (1 << i)) != 0) {
+                        p.add(leaf(sizes[i][0], sizes[i][1]).min(sizes[i][0] / 2, sizes[i][1] / 3), names[i]);
+                        q.add(leaf(sizes[i][0], sizes[i][1]).min(sizes[i][0] / 2, sizes[i][1] / 3), names[i]);
+                    }
+                }
+                check("border regions " + mask, p, 300, 200, 50, 30, 301, 77);
+                check("border regions with insets " + mask, q, 300, 200, 50, 30);
+            }
+        }
+        check("relative names",
+                panel(BORDER, 3, 2).add(leaf(60, 20), "First").add(leaf(80, 25), "Last").add(leaf(30, 50), "Before")
+                        .add(leaf(35, 45), "After").add(leaf(10, 10), null),
+                300, 200);
+        check("relative names win over absolute ones",
+                panel(BORDER, 3, 2).add(leaf(60, 20), "North").add(leaf(61, 31), "First").add(leaf(30, 50), "West")
+                        .add(leaf(37, 50), "Before").add(leaf(10, 10), "Center"),
+                300, 200);
+        check("hidden edge",
+                panel(BORDER, 3, 2).add(leaf(60, 20).hide(), "North").add(leaf(80, 25), "South")
+                        .add(leaf(30, 50).hide(), "East").add(leaf(10, 10), "Center"),
+                300, 200);
+    }
+
+    @Test
+    public void gridLayout() {
+        int[][] shapes = {{2, 0}, {0, 3}, {3, 2}, {1, 0}, {0, 1}, {4, 7}};
+        int[][] gaps = {{0, 0}, {5, 3}, {-1, 2}};
+        int[] counts = {0, 1, 5, 7, 12};
+        for (int[] shape : shapes) {
+            for (int[] gap : gaps) {
+                for (int count : counts) {
+                    Node p = panel(GRID, shape[0], shape[1], gap[0], gap[1]);
+                    Node q = panel(GRID, shape[0], shape[1], gap[0], gap[1]).border(4, 1, 2, 9);
+                    for (int i = 0; i < count; i++) {
+                        Node a = leaf(20 + i * 7, 15 + (i * 5) % 13).min(3 + i, 9 - (i % 4));
+                        Node b = leaf(20 + i * 7, 15 + (i * 5) % 13).min(3 + i, 9 - (i % 4));
+                        if (i == 2) {
+                            a.hide();
+                            b.hide();
+                        }
+                        p.add(a);
+                        q.add(b);
+                    }
+                    String what = "grid " + shape[0] + "x" + shape[1] + " gap " + gap[0] + " count " + count;
+                    check(what, p, 301, 203, 100, 100, 17, 5);
+                    check(what + " with insets", q, 301, 203, 64, 31);
+                }
+            }
+        }
+    }
+
+    @Test
+    public void cardLayout() {
+        Node tree = panel(CARD, 4, 6).border(1, 2, 3, 4).add(leaf(50, 40), "a").add(leaf(90, 20).min(5, 6), "b")
+                .add(leaf(30, 80), "c").add(leaf(10, 10), "d");
+        java.awt.Container r = (java.awt.Container) real(tree);
+        Container o = (Container) ours(tree);
+        java.awt.CardLayout rl = (java.awt.CardLayout) r.getLayout();
+        com.codename1.desktopcompat.java.awt.CardLayout ol =
+                (com.codename1.desktopcompat.java.awt.CardLayout) o.getLayout();
+        r.setSize(200, 150);
+        o.setSize(200, 150);
+        for (int step = 0; step < 12; step++) {
+            switch (step) {
+                case 1:
+                case 2:
+                case 9:
+                    rl.next(r);
+                    ol.next(o);
+                    break;
+                case 3:
+                    rl.show(r, "a");
+                    ol.show(o, "a");
+                    break;
+                case 4:
+                case 10:
+                    rl.previous(r);
+                    ol.previous(o);
+                    break;
+                case 5:
+                    rl.first(r);
+                    ol.first(o);
+                    break;
+                case 6:
+                    rl.show(r, "c");
+                    ol.show(o, "c");
+                    break;
+                case 7:
+                    rl.show(r, "nothing by this name");
+                    ol.show(o, "nothing by this name");
+                    break;
+                case 8:
+                    rl.last(r);
+                    ol.last(o);
+                    break;
+                case 11:
+                    r.remove(r.getComponent(0));
+                    o.remove(o.getComponent(0));
+                    break;
+                default:
+                    break;
+            }
+            layout(r);
+            layout(o);
+            assertEquals("card step " + step, dump(r), dump(o));
+        }
+        check("empty card", panel(CARD, 0, 0), 100, 100);
+        check("all cards hidden before layout", panel(CARD, 0, 0).add(leaf(5, 5).hide(), "x").add(leaf(6, 6), "y"),
+                100, 100);
+    }
+
+    private static Node boxKids(Node p) {
+        p.add(leaf(40, 20).max(60, 30).align(0f, 0f));
+        p.add(filler(HSTRUT, 7, 0));
+        p.add(leaf(70, 35).min(20, 10).max(300, 400).align(1f, 1f));
+        p.add(filler(GLUE, 0, 0));
+        p.add(leaf(25, 10).hide().align(0.25f, 0.75f));
+        p.add(filler(VSTRUT, 0, 9));
+        p.add(leaf(55, 28).min(11, 7).align(0.3f, 0.8f));
+        p.add(filler(RIGID, 13, 17));
+        p.add(leaf(33, 41).min(33, 41).max(33, 41));
+        return p;
+    }
+
+    @Test
+    public void boxLayout() {
+        for (int axis = 0; axis <= 3; axis++) {
+            check("box axis " + axis, boxKids(panel(BOX, axis)), 600, 300, 300, 600, 243, 200, 200, 243, 120, 90, 90,
+                    120, 30, 30, 0, 0, 5000, 4000);
+            check("box with insets, axis " + axis, boxKids(panel(BOX, axis).border(6, 4, 2, 8)), 600, 300, 150, 150);
+        }
+        check("glue between",
+                panel(BOX, 0).add(leaf(30, 30)).add(filler(HGLUE, 0, 0)).add(leaf(40, 20)).add(filler(HGLUE, 0, 0))
+                        .add(leaf(10, 50).max(10, 50)),
+                401, 100, 80, 20);
+        check("vertical glue",
+                panel(BOX, 1).add(leaf(30, 30).align(0f, 0.5f)).add(filler(VGLUE, 0, 0))
+                        .add(leaf(40, 20).max(40, 20).align(0f, 0.5f)).add(filler(VSTRUT, 0, 12))
+                        .add(leaf(10, 50).max(1000, 50).align(0f, 0.5f)),
+                200, 400, 20, 80);
+        check("nested boxes",
+                panel(BOX, 0).border(2, 3, 4, 5)
+                        .add(panel(BOX, 1).add(leaf(30, 30).max(90, 40)).add(filler(VGLUE, 0, 0)).add(leaf(50, 20)))
+                        .add(filler(HSTRUT, 10, 0))
+                        .add(panel(BOX, 1).border(1, 1, 1, 1).add(leaf(60, 15).align(1f, 0f))
+                                .add(leaf(20, 15).align(0f, 0f).max(25, 15)))
+                        .add(leaf(44, 44).align(0.5f, 0.2f)),
+                500, 220, 140, 60);
+        check("empty box", panel(BOX, 1), 50, 50);
+        check("overlay", boxKids(panel(OVERLAY)), 300, 200, 40, 40);
+        check("overlay with insets", boxKids(panel(OVERLAY).border(3, 5, 7, 9)), 300, 200);
+    }
+
+    @Test
+    public void boxLayoutRandom() {
+        Random rnd = new Random(20240607L);
+        float[] aligns = {0f, 0.5f, 1f, 0.25f, 0.7f};
+        for (int round = 0; round < 300; round++) {
+            Node p = panel(BOX, rnd.nextInt(4));
+            if (rnd.nextInt(3) == 0) {
+                p.border(rnd.nextInt(6), rnd.nextInt(6), rnd.nextInt(6), rnd.nextInt(6));
+            }
+            int count = rnd.nextInt(7);
+            for (int i = 0; i < count; i++) {
+                int kind = rnd.nextInt(10);
+                if (kind == 0) {
+                    p.add(filler(GLUE, 0, 0));
+                } else if (kind == 1) {
+                    p.add(filler(HSTRUT, rnd.nextInt(30), 0));
+                } else if (kind == 2) {
+                    p.add(filler(VSTRUT, 0, rnd.nextInt(30)));
+                } else {
+                    int w = 5 + rnd.nextInt(90);
+                    int h = 5 + rnd.nextInt(90);
+                    Node n = leaf(w, h).min(rnd.nextInt(w + 1), rnd.nextInt(h + 1)).align(
+                            aligns[rnd.nextInt(aligns.length)], aligns[rnd.nextInt(aligns.length)]);
+                    if (rnd.nextInt(3) != 0) {
+                        n.max(w + rnd.nextInt(200), h + rnd.nextInt(200));
+                    }
+                    if (rnd.nextInt(9) == 0) {
+                        n.hide();
+                    }
+                    p.add(n);
+                }
+            }
+            check("random box " + round, p, rnd.nextInt(700), rnd.nextInt(500), rnd.nextInt(200), rnd.nextInt(200));
+        }
+    }
+
+    @Test
+    public void gridBagLayout() {
+        // 1: weights and fill
+        check("weights and fill",
+                panel(GRIDBAG).add(leaf(50, 20), g().at(0, 0).weight(1, 0).fill(2))
+                        .add(leaf(30, 20), g().at(1, 0).weight(2, 0).fill(1))
+                        .add(leaf(40, 30), g().at(0, 1).weight(0, 1).fill(3))
+                        .add(leaf(40, 30), g().at(1, 1).weight(0, 3)),
+                400, 300, 401, 299, 100, 40, 60, 30);
+        // 2: every anchor, in a grid of cells larger than the components
+        Node anchors = panel(GRIDBAG);
+        int cell = 0;
+        for (int a = 10; a <= 26; a++) {
+            anchors.add(leaf(20 + a, 10 + a / 2), g().at(cell % 5, cell / 5).weight(1, 1).anchor(a));
+            cell++;
+        }
+        check("anchors", anchors, 640, 480, 333, 257);
+        // 3: spans
+        check("spans",
+                panel(GRIDBAG).add(leaf(120, 20), g().at(0, 0).span(3, 1).fill(2))
+                        .add(leaf(30, 90), g().at(0, 1).span(1, 2).fill(3).weight(0, 1))
+                        .add(leaf(40, 25), g().at(1, 1).weight(1, 0)).add(leaf(45, 25), g().at(2, 1).weight(3, 0))
+                        .add(leaf(200, 31), g().at(1, 2).span(2, 1).weight(0, 2).anchor(14)),
+                500, 400, 230, 150, 90, 60);
+        // 4: REMAINDER and RELATIVE
+        check("remainder and relative",
+                panel(GRIDBAG).add(leaf(30, 20), g()).add(leaf(31, 21), g()).add(leaf(32, 22), g().span(0, 1))
+                        .add(leaf(90, 23), g().span(-1, 1).fill(2).weight(1, 0)).add(leaf(34, 24), g().span(0, 1))
+                        .add(leaf(35, 25), g().span(0, 1).weight(0, 1).fill(1)).add(leaf(36, 26), g().span(1, 0))
+                        .add(leaf(37, 27), g().span(0, 0).anchor(18)),
+                400, 300, 150, 120);
+        // 5: insets and internal padding
+        check("insets and ipad",
+                panel(GRIDBAG).border(3, 4, 5, 6)
+                        .add(leaf(50, 20), g().at(0, 0).insets(1, 2, 3, 4).ipad(10, 6))
+                        .add(leaf(30, 20), g().at(1, 0).insets(7, 0, 0, 9).weight(1, 1).fill(1).ipad(3, 0))
+                        .add(leaf(40, 30), g().at(0, 1).span(2, 1).insets(5, 5, 5, 5).fill(2))
+                        .add(leaf(20, 20).hide(), g().at(5, 5).weight(9, 9)),
+                300, 200, 301, 201, 110, 70);
+        // 6: shrinking below the preferred size falls back to minimum sizes
+        check("minimum sizes",
+                panel(GRIDBAG).add(leaf(100, 40).min(20, 10), g().at(0, 0).weight(1, 1).fill(1))
+                        .add(leaf(80, 40).min(30, 15), g().at(1, 0).weight(2, 0))
+                        .add(leaf(150, 30).min(40, 5), g().at(0, 1).span(2, 1).weight(0, 1).fill(2)),
+                400, 200, 179, 60, 60, 20, 30, 10);
+        // 7: the public override arrays
+        Node forced = panel(GRIDBAG).add(leaf(20, 20), g().at(0, 0)).add(leaf(30, 30), g().at(1, 1).fill(1))
+                .add(leaf(10, 10), g().at(3, 0).anchor(12));
+        forced.colW = new int[] {50, 10, 40, 0, 25};
+        forced.rowH = new int[] {5, 60};
+        forced.colWt = new double[] {0, 1, 0, 0.5};
+        forced.rowWt = new double[] {1, 0, 4};
+        check("override arrays", forced, 400, 300, 100, 50);
+        // 8: nothing has weight, so the grid is centred
+        check("centred", panel(GRIDBAG).border(1, 9, 3, 2).add(leaf(50, 20), g().at(0, 0))
+                .add(leaf(30, 60), g().at(1, 1)).add(leaf(10, 10), g().at(4, 0).span(1, 2).fill(3)), 301, 201, 60,
+                40);
+        // 9: relative position mixed with absolute
+        check("mixed positions",
+                panel(GRIDBAG).add(leaf(20, 20), g().at(2, -1)).add(leaf(21, 21), g().at(2, -1))
+                        .add(leaf(22, 22), g().at(-1, 1)).add(leaf(23, 23), g().at(-1, 0).span(2, 1))
+                        .add(leaf(24, 24), g().at(0, 3).span(0, 1).fill(2)).add(leaf(25, 25), g()),
+                300, 300);
+        check("empty grid bag", panel(GRIDBAG), 100, 100);
+    }
+
+    @Test
+    public void gridBagLayoutRandom() {
+        Random rnd = new Random(99173L);
+        for (int round = 0; round < 400; round++) {
+            Node p = panel(GRIDBAG);
+            if (rnd.nextInt(3) == 0) {
+                p.border(rnd.nextInt(8), rnd.nextInt(8), rnd.nextInt(8), rnd.nextInt(8));
+            }
+            if (rnd.nextInt(8) == 0) {
+                p.colW = new int[] {rnd.nextInt(40), rnd.nextInt(40), rnd.nextInt(40)};
+                p.rowWt = new double[] {rnd.nextInt(3), rnd.nextInt(3)};
+            }
+            int count = 1 + rnd.nextInt(8);
+            boolean relative = rnd.nextInt(4) == 0;
+            for (int i = 0; i < count; i++) {
+                int w = 5 + rnd.nextInt(90);
+                int h = 5 + rnd.nextInt(60);
+                Node n = leaf(w, h).min(rnd.nextInt(w + 1), rnd.nextInt(h + 1));
+                if (rnd.nextInt(10) == 0) {
+                    n.hide();
+                }
+                G c = g();
+                if (relative) {
+                    c.at(rnd.nextInt(3) == 0 ? rnd.nextInt(4) : -1, rnd.nextInt(5) == 0 ? rnd.nextInt(4) : -1);
+                    c.span(rnd.nextInt(4) == 0 ? rnd.nextInt(3) - 1 : 1, rnd.nextInt(9) == 0 ? rnd.nextInt(3) - 1 : 1);
+                } else {
+                    c.at(rnd.nextInt(5), rnd.nextInt(5));
+                    c.span(1 + rnd.nextInt(3), 1 + rnd.nextInt(3));
+                }
+                if (rnd.nextInt(2) == 0) {
+                    c.weight(rnd.nextInt(4) * 0.5, rnd.nextInt(4) * 0.25);
+                }
+                c.anchor(10 + rnd.nextInt(17)).fill(rnd.nextInt(4));
+                if (rnd.nextInt(3) == 0) {
+                    c.insets(rnd.nextInt(6), rnd.nextInt(6), rnd.nextInt(6), rnd.nextInt(6));
+                }
+                if (rnd.nextInt(4) == 0) {
+                    c.ipad(rnd.nextInt(9), rnd.nextInt(9));
+                }
+                p.add(n, c);
+            }
+            check("random grid bag " + round, p, 200 + rnd.nextInt(500), 150 + rnd.nextInt(400), rnd.nextInt(250),
+                    rnd.nextInt(200));
+        }
+    }
+
+    @Test
+    public void overlayLayout() {
+        check("corners",
+                panel(OVERLAY).add(leaf(40, 20).align(0f, 0f)).add(leaf(70, 35).align(1f, 1f))
+                        .add(leaf(30, 50).align(0f, 1f)).add(leaf(60, 10).align(1f, 0f)),
+                300, 200, 110, 85, 60, 40, 0, 0);
+        check("centred, growing to the maximum",
+                panel(OVERLAY).add(leaf(40, 20).max(1000, 1000)).add(leaf(70, 35).max(90, 500))
+                        .add(leaf(30, 50).max(30, 50)).add(leaf(60, 10)),
+                300, 200, 70, 50, 20, 20);
+        check("shrinking to the minimum",
+                panel(OVERLAY).border(2, 4, 6, 8).add(leaf(140, 120).min(10, 10).align(0.25f, 0.75f))
+                        .add(leaf(170, 135).min(60, 20).align(0.75f, 0.25f)).add(leaf(90, 90).min(90, 90).align(1f, 0f)),
+                400, 400, 200, 150, 100, 60, 12, 8);
+        check("hidden children still take part",
+                panel(OVERLAY).add(leaf(40, 20).align(0f, 0f)).add(leaf(170, 135).hide().align(1f, 1f))
+                        .add(leaf(30, 50).hide()),
+                300, 200, 50, 50);
+        check("one child", panel(OVERLAY).border(1, 2, 3, 4).add(leaf(40, 20).max(45, 300).align(0.3f, 0.6f)), 300,
+                200, 10, 10);
+        check("empty overlay", panel(OVERLAY).border(1, 2, 3, 4), 50, 50);
+        check("nested overlays",
+                panel(OVERLAY).border(3, 3, 3, 3)
+                        .add(panel(OVERLAY).add(leaf(40, 20).align(0f, 0f)).add(leaf(20, 60).align(1f, 0.5f)))
+                        .add(panel(BOX, 1).add(leaf(30, 30).max(90, 40)).add(filler(VGLUE, 0, 0)).add(leaf(50, 20)))
+                        .add(panel(FLOW, 1, 5, 5).add(leaf(33, 12)).add(leaf(44, 12))).add(leaf(10, 10).max(900, 900)),
+                400, 300, 120, 90, 30, 30);
+        check("an overlay inside other layouts",
+                panel(BORDER, 2, 2).add(panel(OVERLAY).add(leaf(40, 20).align(0f, 1f)).add(leaf(70, 35)), "North")
+                        .add(panel(OVERLAY).border(1, 1, 1, 1).add(leaf(55, 44).max(60, 400).align(1f, 0f))
+                                .add(leaf(22, 66).min(5, 5)), "West")
+                        .add(panel(OVERLAY).add(leaf(10, 10).max(5000, 5000)).add(leaf(80, 80).max(80, 80)), "Center"),
+                500, 400, 100, 100);
+    }
+
+    @Test
+    public void overlayLayoutRandom() {
+        Random rnd = new Random(551177L);
+        float[] aligns = {0f, 0.5f, 1f, 0.25f, 0.7f, 0.1f, 0.9f};
+        for (int round = 0; round < 400; round++) {
+            Node p = panel(OVERLAY);
+            if (rnd.nextInt(3) == 0) {
+                p.border(rnd.nextInt(6), rnd.nextInt(6), rnd.nextInt(6), rnd.nextInt(6));
+            }
+            int count = rnd.nextInt(6);
+            for (int i = 0; i < count; i++) {
+                int w = 5 + rnd.nextInt(90);
+                int h = 5 + rnd.nextInt(90);
+                Node n = leaf(w, h).min(rnd.nextInt(w + 1), rnd.nextInt(h + 1)).align(
+                        aligns[rnd.nextInt(aligns.length)], aligns[rnd.nextInt(aligns.length)]);
+                if (rnd.nextInt(3) != 0) {
+                    n.max(w + rnd.nextInt(200), h + rnd.nextInt(200));
+                }
+                if (rnd.nextInt(9) == 0) {
+                    n.hide();
+                }
+                p.add(n);
+            }
+            check("random overlay " + round, p, rnd.nextInt(500), rnd.nextInt(400), rnd.nextInt(120),
+                    rnd.nextInt(120), 0, 0);
+        }
+    }
+
+    /// The anchors that are relative to the baseline of a row, with
+    /// components that have a baseline and components that have none.
+    @Test
+    public void gridBagBaselineAnchors() {
+        int[] anchors = {0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700, 0x800, 0x900};
+        Node none = panel(GRIDBAG);
+        Node some = panel(GRIDBAG).border(2, 3, 4, 5);
+        Node filled = panel(GRIDBAG);
+        for (int i = 0; i < anchors.length; i++) {
+            none.add(leaf(20 + i, 10 + 3 * i), g().at(i % 3, i / 3).weight(1, 1).anchor(anchors[i]));
+            some.add(leaf(20 + i, 14 + 3 * i).base(4 + 2 * i), g().at(i % 3, i / 3).weight(1, 1).anchor(anchors[i])
+                    .insets(1, 2, 3, i));
+            filled.add(leaf(20 + i, 14 + 3 * i).base(i % 2 == 0 ? 5 + i : -1),
+                    g().at(i % 4, i / 4).weight(i % 2, 1).anchor(anchors[i]).fill(i % 4).ipad(i, 2));
+        }
+        check("baseline anchors without baselines", none, 400, 300, 90, 70, 30, 20);
+        check("baseline anchors", some, 400, 300, 401, 299, 90, 70, 30, 20);
+        check("baseline anchors with fill", filled, 400, 300, 120, 80);
+        check("a row on one baseline",
+                panel(GRIDBAG).add(leaf(40, 20).base(15), g().at(0, 0).anchor(0x100))
+                        .add(leaf(60, 30).base(22), g().at(1, 0).anchor(0x200).weight(1, 0))
+                        .add(leaf(30, 12).base(3), g().at(2, 0).anchor(0x300))
+                        .add(leaf(30, 40), g().at(3, 0).anchor(0x100))
+                        .add(leaf(30, 16).base(8), g().at(0, 1).anchor(0x400))
+                        .add(leaf(35, 26).base(20), g().at(1, 1).anchor(0x100))
+                        .add(leaf(30, 16).base(8), g().at(2, 1).anchor(0x700).weight(0, 1)),
+                400, 300, 200, 80, 50, 30);
+    }
+
+    /// Grid bag cases the other tests leave out: fractional and uneven
+    /// weights, negative padding, spans that reach past the last occupied
+    /// cell, and vertical runs placed relatively.
+    @Test
+    public void gridBagLayoutMore() {
+        check("uneven weights",
+                panel(GRIDBAG).add(leaf(50, 20), g().at(0, 0).weight(0.1, 0.3).fill(1))
+                        .add(leaf(30, 20), g().at(1, 0).weight(0.25, 0).fill(1))
+                        .add(leaf(40, 30), g().at(2, 0).weight(0.65, 0.7).fill(1))
+                        .add(leaf(40, 30), g().at(0, 1).span(3, 1).weight(7, 0.05).fill(2)),
+                400, 300, 403, 307, 997, 601, 121, 51, 50, 20);
+        check("weight on a spanning component only",
+                panel(GRIDBAG).add(leaf(50, 20), g().at(0, 0)).add(leaf(30, 20), g().at(1, 0))
+                        .add(leaf(40, 30), g().at(2, 0))
+                        .add(leaf(200, 30), g().at(0, 1).span(2, 1).weight(1, 1).fill(1))
+                        .add(leaf(10, 90), g().at(2, 1).span(1, 2).weight(0, 2).fill(3))
+                        .add(leaf(20, 20), g().at(0, 2)),
+                500, 400, 250, 140, 100, 60);
+        check("negative padding and insets",
+                panel(GRIDBAG).border(1, 1, 1, 1).add(leaf(50, 20), g().at(0, 0).ipad(-10, -4))
+                        .add(leaf(30, 20), g().at(1, 0).ipad(-40, 3).insets(-2, -3, 4, 5).fill(1).weight(1, 1))
+                        .add(leaf(40, 30).min(4, 4), g().at(0, 1).span(2, 1).insets(9, -5, -5, 9).fill(2)),
+                300, 200, 80, 40, 20, 10);
+        check("spans past the grid",
+                panel(GRIDBAG).add(leaf(50, 20), g().at(0, 0).span(4, 1).fill(2).weight(1, 0))
+                        .add(leaf(30, 20), g().at(1, 1).span(1, 5).fill(3).weight(0, 1))
+                        .add(leaf(40, 30), g().at(6, 3).anchor(14)),
+                300, 200, 100, 60);
+        check("a column placed relatively",
+                panel(GRIDBAG).add(leaf(30, 20), g().at(0, -1)).add(leaf(31, 21), g().at(0, -1))
+                        .add(leaf(32, 22), g().at(0, -1).span(1, 0))
+                        .add(leaf(33, 23), g().at(1, -1).span(1, -1).fill(3).weight(0, 1))
+                        .add(leaf(34, 24), g().at(1, -1).span(1, 0))
+                        .add(leaf(35, 25), g().at(-1, -1).span(0, 0).weight(1, 0).fill(1)),
+                400, 300, 120, 100);
+        check("hidden components leave their cells",
+                panel(GRIDBAG).add(leaf(50, 20), g().at(0, 0)).add(leaf(300, 200).hide(), g().at(1, 0).weight(5, 5))
+                        .add(leaf(40, 30), g().at(2, 0).weight(1, 0)).add(leaf(40, 30).hide(), g())
+                        .add(leaf(41, 31), g().span(0, 1)).add(leaf(42, 32), g()),
+                400, 300, 60, 40);
+        check("nested grid bags",
+                panel(GRIDBAG).border(2, 2, 2, 2)
+                        .add(panel(GRIDBAG).add(leaf(30, 20), g().at(0, 0).weight(1, 0).fill(2))
+                                .add(leaf(31, 21), g().at(1, 0)), g().at(0, 0).weight(1, 0).fill(2))
+                        .add(panel(GRIDBAG).border(1, 1, 1, 1).add(leaf(60, 40).min(6, 4), g().weight(1, 1).fill(1)),
+                                g().at(0, 1).weight(1, 1).fill(1).insets(3, 3, 3, 3))
+                        .add(panel(OVERLAY).add(leaf(20, 20)).add(leaf(44, 12)), g().at(1, 0).span(1, 2).anchor(11)),
+                500, 400, 130, 80, 40, 30);
+    }
+
+    @Test
+    public void gridBagLayoutRandomWide() {
+        Random rnd = new Random(4410882L);
+        int rejected = 0;
+        int[] anchors = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 0x100, 0x200, 0x300,
+            0x400, 0x500, 0x600, 0x700, 0x800, 0x900};
+        for (int round = 0; round < 500; round++) {
+            Node p = panel(GRIDBAG);
+            if (rnd.nextInt(3) == 0) {
+                p.border(rnd.nextInt(8), rnd.nextInt(8), rnd.nextInt(8), rnd.nextInt(8));
+            }
+            if (rnd.nextInt(6) == 0) {
+                p.colW = new int[1 + rnd.nextInt(4)];
+                for (int i = 0; i < p.colW.length; i++) {
+                    p.colW[i] = rnd.nextInt(60);
+                }
+            }
+            if (rnd.nextInt(6) == 0) {
+                p.rowH = new int[1 + rnd.nextInt(4)];
+                for (int i = 0; i < p.rowH.length; i++) {
+                    p.rowH[i] = rnd.nextInt(40);
+                }
+            }
+            if (rnd.nextInt(6) == 0) {
+                p.colWt = new double[1 + rnd.nextInt(4)];
+                for (int i = 0; i < p.colWt.length; i++) {
+                    p.colWt[i] = rnd.nextInt(5) * 0.3;
+                }
+            }
+            if (rnd.nextInt(6) == 0) {
+                p.rowWt = new double[1 + rnd.nextInt(4)];
+                for (int i = 0; i < p.rowWt.length; i++) {
+                    p.rowWt[i] = rnd.nextInt(5) * 0.7;
+                }
+            }
+            int count = 1 + rnd.nextInt(9);
+            int mode = rnd.nextInt(3);
+            for (int i = 0; i < count; i++) {
+                int w = 5 + rnd.nextInt(90);
+                int h = 5 + rnd.nextInt(60);
+                Node n = leaf(w, h).min(rnd.nextInt(w + 1), rnd.nextInt(h + 1));
+                if (rnd.nextInt(3) == 0) {
+                    n.base(rnd.nextInt(h));
+                }
+                if (rnd.nextInt(10) == 0) {
+                    n.hide();
+                }
+                G c = g();
+                if (mode == 0) {
+                    c.at(rnd.nextInt(3) == 0 ? rnd.nextInt(4) : -1, rnd.nextInt(5) == 0 ? rnd.nextInt(4) : -1);
+                    c.span(rnd.nextInt(4) == 0 ? rnd.nextInt(3) - 1 : 1, rnd.nextInt(9) == 0 ? rnd.nextInt(3) - 1 : 1);
+                } else if (mode == 1) {
+                    // Columns filled downwards.
+                    c.at(rnd.nextInt(3), -1);
+                    c.span(1, rnd.nextInt(4) == 0 ? rnd.nextInt(3) - 1 : 1);
+                } else {
+                    c.at(rnd.nextInt(6), rnd.nextInt(6));
+                    c.span(1 + rnd.nextInt(4), 1 + rnd.nextInt(4));
+                }
+                if (rnd.nextInt(2) == 0) {
+                    c.weight(rnd.nextInt(7) * 0.17, rnd.nextInt(7) * 0.31);
+                }
+                c.anchor(anchors[rnd.nextInt(anchors.length)]).fill(rnd.nextInt(4));
+                if (rnd.nextInt(3) == 0) {
+                    c.insets(rnd.nextInt(8) - 2, rnd.nextInt(8) - 2, rnd.nextInt(8) - 2, rnd.nextInt(8) - 2);
+                }
+                if (rnd.nextInt(4) == 0) {
+                    c.ipad(rnd.nextInt(14) - 5, rnd.nextInt(14) - 5);
+                }
+                p.add(n, c);
+            }
+            int[] sizes = {200 + rnd.nextInt(500), 150 + rnd.nextInt(400), rnd.nextInt(250), rnd.nextInt(200), 0, 0};
+            if (!realLaysOut(p, sizes)) {
+                rejected++;
+                continue;
+            }
+            check("random wide grid bag " + round, p, sizes);
+        }
+        assertTrue(rejected + " of 500 random grids were rejected by the JDK", rejected < 50);
+    }
+
+    /// Whether the JDK lays the tree out at all. Its grid bag layout indexes
+    /// past its per-row baseline arrays when a relatively placed component
+    /// lands beyond the rows it counted first and something in the grid is
+    /// anchored to a baseline; this layer lays such a grid out, and there
+    /// is nothing to compare it with.
+    private static boolean realLaysOut(Node tree, int[] sizes) {
+        java.awt.Component r = real(tree);
+        try {
+            for (int i = 0; i < sizes.length; i += 2) {
+                r.setSize(sizes[i], sizes[i + 1]);
+                layout(r);
+                dump(r);
+            }
+            return true;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return false;
+        }
+    }
+
+    @Test
+    public void nestedContainersWithBorders() {
+        Node form = panel(GRIDBAG).border(8, 8, 8, 8);
+        for (int row = 0; row < 4; row++) {
+            form.add(leaf(60 + row * 5, 16), g().at(0, row).anchor(13).insets(2, 2, 2, 6));
+            form.add(leaf(120, 22).min(40, 22), g().at(1, row).weight(1, 0).fill(2).insets(2, 0, 2, 2));
+        }
+        form.add(leaf(10, 10), g().at(0, 4).span(2, 1).weight(0, 1).fill(1));
+
+        Node buttons = panel(FLOW, 2, 6, 4).border(2, 0, 2, 0).add(leaf(70, 26)).add(leaf(70, 26)).add(leaf(90, 26));
+        Node side = panel(BOX, 1).border(4, 4, 4, 4).add(leaf(80, 24).max(200, 24).align(0f, 0.5f))
+                .add(filler(VSTRUT, 0, 5)).add(leaf(60, 24).max(200, 24).align(0f, 0.5f)).add(filler(VGLUE, 0, 0))
+                .add(leaf(80, 40).align(0f, 0.5f));
+        Node tiles = panel(GRID, 2, 3, 4, 4).border(1, 2, 3, 4);
+        for (int i = 0; i < 6; i++) {
+            tiles.add(panel(BORDER, 1, 1).border(1, 1, 1, 1).add(leaf(30, 10), "North").add(leaf(20 + i, 20), null));
+        }
+        Node centre = panel(BORDER, 5, 5).add(form, "Center").add(tiles, "South");
+        Node root = panel(BORDER, 6, 3).border(10, 12, 14, 16).add(leaf(200, 30), "North").add(side, "West")
+                .add(centre, "Center").add(buttons, "South");
+        check("nested", root, 800, 600, 640, 480, 320, 240, 100, 100);
+
+        Node cards = panel(CARD, 2, 2).border(5, 5, 5, 5).add(panel(FLOW, 1, 5, 5).add(leaf(40, 40)), "one")
+                .add(panel(GRID, 0, 2, 1, 1).add(leaf(10, 10)).add(leaf(20, 20)).add(leaf(30, 30)), "two");
+        check("cards of panels", cards, 300, 200);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/LibraryLinkageTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/LibraryLinkageTest.java
new file mode 100644
index 00000000000..c9ce8c21129
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/LibraryLinkageTest.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Label;
+import com.codename1.desktopcompat.java.awt.ScrollPane;
+import com.codename1.desktopcompat.java.awt.TextComponent;
+import com.codename1.desktopcompat.java.beans.BeanInfo;
+import com.codename1.desktopcompat.java.beans.Beans;
+import com.codename1.desktopcompat.java.beans.Encoder;
+import com.codename1.desktopcompat.java.beans.ExceptionListener;
+import com.codename1.desktopcompat.java.beans.Expression;
+import com.codename1.desktopcompat.java.beans.Introspector;
+import com.codename1.desktopcompat.java.beans.PersistenceDelegate;
+import com.codename1.desktopcompat.java.beans.XMLDecoder;
+import com.codename1.desktopcompat.java.beans.XMLEncoder;
+import com.codename1.desktopcompat.javax.swing.DefaultListCellRenderer;
+import com.codename1.desktopcompat.javax.swing.DefaultListModel;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// What the first complete application built on the layer needed that the
+/// layer's own tests had not asked for: the classes a bundled library names
+/// on paths a device never takes, and a font for a component that is in no
+/// window.
+public class LibraryLinkageTest extends KernelTestBase {
+
+    /// MigLayout asks every component whether it is one of AWT's heavyweight
+    /// widgets before it picks a baseline and a gap for it. The types exist
+    /// so that the question links; no Swing component is one, and none can
+    /// be made.
+    @Test
+    public void noSwingComponentIsAnAwtWidget() {
+        Component[] all = {new JLabel("a"), new JTextField("b"), new JScrollPane(new JPanel()), new JPanel()};
+        for (Component c : all) {
+            assertFalse(c instanceof Label);
+            assertFalse(c instanceof TextComponent);
+            assertFalse(c instanceof ScrollPane);
+        }
+        try {
+            new Label();
+            fail("There is no heavyweight label to make");
+        } catch (UnsupportedOperationException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("javax.swing.JLabel"));
+        }
+        try {
+            new ScrollPane();
+            fail("There is no heavyweight scroll pane to make");
+        } catch (UnsupportedOperationException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("javax.swing.JScrollPane"));
+        }
+    }
+
+    @Test
+    public void anApplicationIsNeverInsideAGuiBuilder() {
+        assertFalse(Beans.isDesignTime());
+        assertTrue(Beans.isGuiAvailable());
+        Beans.setDesignTime(true);
+        try {
+            assertTrue(Beans.isDesignTime());
+        } finally {
+            Beans.setDesignTime(false);
+        }
+    }
+
+    /// A library keeps per-class data in the bean descriptor: the same
+    /// descriptor has to come back for the same class.
+    @Test
+    public void aBeanDescriptorIsRememberedPerClass() throws Exception {
+        Introspector.flushCaches();
+        BeanInfo info = Introspector.getBeanInfo(JPanel.class, Introspector.IGNORE_ALL_BEANINFO);
+        assertEquals("JPanel", info.getBeanDescriptor().getName());
+        assertSame(JPanel.class, info.getBeanDescriptor().getBeanClass());
+        assertNull(info.getBeanDescriptor().getValue("persistenceDelegate"));
+        info.getBeanDescriptor().setValue("persistenceDelegate", "mine");
+        assertEquals("mine", Introspector.getBeanInfo(JPanel.class).getBeanDescriptor().getValue("persistenceDelegate"));
+        assertNull(Introspector.getBeanInfo(JLabel.class).getBeanDescriptor().getValue("persistenceDelegate"));
+        Introspector.flushFromCaches(JPanel.class);
+        assertNull(Introspector.getBeanInfo(JPanel.class).getBeanDescriptor().getValue("persistenceDelegate"));
+        try {
+            Introspector.getBeanInfo(JPanel.class, 9);
+            fail("9 is none of the three flags");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        assertEquals("fooBah", Introspector.decapitalize("FooBah"));
+        assertEquals("x", Introspector.decapitalize("X"));
+        assertEquals("URL", Introspector.decapitalize("URL"));
+        assertEquals("", Introspector.decapitalize(""));
+    }
+
+    /// Long-term persistence cannot run without reflection. What a library
+    /// does around it -- make an encoder, set a listener, register a
+    /// delegate, close it -- works, and the write itself says why it cannot.
+    @Test
+    public void persistenceCanBeSetUpAndSaysWhyItCannotRun() throws Exception {
+        XMLEncoder encoder = new XMLEncoder(new ByteArrayOutputStream());
+        ExceptionListener listener = new ExceptionListener() {
+            @Override
+            public void exceptionThrown(Exception e) {
+            }
+        };
+        encoder.setExceptionListener(listener);
+        assertSame(listener, encoder.getExceptionListener());
+        PersistenceDelegate delegate = new PersistenceDelegate() {
+            @Override
+            protected Expression instantiate(Object oldInstance, Encoder out) {
+                return new Expression(oldInstance, JPanel.class, "new", new Object[0]);
+            }
+        };
+        encoder.setPersistenceDelegate(JPanel.class, delegate);
+        assertSame(delegate, encoder.getPersistenceDelegate(JPanel.class));
+        try {
+            encoder.writeObject(new JPanel());
+            fail("Nothing can be written without reflection");
+        } catch (UnsupportedOperationException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("XMLEncoder"));
+        }
+        encoder.flush();
+        encoder.close();
+
+        Object value = new Object();
+        Expression known = new Expression(value, JPanel.class, "new", null);
+        assertSame(value, known.getValue());
+        assertEquals("new", known.getMethodName());
+        assertSame(JPanel.class, known.getTarget());
+        assertEquals(0, known.getArguments().length);
+        try {
+            new Expression(JPanel.class, "new", new Object[0]).getValue();
+            fail("A value that has to be computed needs the call");
+        } catch (UnsupportedOperationException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("reflection"));
+        }
+
+        XMLDecoder decoder = new XMLDecoder(new ByteArrayInputStream(new byte[0]));
+        try {
+            decoder.readObject();
+            fail("Nothing can be read without reflection");
+        } catch (UnsupportedOperationException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains("XMLDecoder"));
+        }
+        decoder.close();
+    }
+
+    /// `getFont().deriveFont(...)` in a cell renderer: on a desktop the look
+    /// and feel gave every Swing component a font, so the idiom is written
+    /// without a null check, and a renderer is in no window to inherit from.
+    @Test
+    public void aComponentInNoWindowHasAFont() {
+        JLabel alone = new JLabel("alone");
+        assertNotNull(alone.getFont());
+        assertFalse("Answering a default is not setting one", alone.isFontSet());
+        assertEquals(Font.BOLD, alone.getFont().deriveFont(Font.BOLD).getStyle());
+
+        DefaultListModel<String> model = new DefaultListModel<String>();
+        model.addElement("one");
+        model.addElement("two");
+        JList<String> list = new JList<String>(model);
+        final boolean[] called = new boolean[1];
+        list.setCellRenderer(new DefaultListCellRenderer() {
+            @Override
+            public Component getListCellRendererComponent(JList<?> l, Object value, int index, boolean selected,
+                                                          boolean focus) {
+                super.getListCellRendererComponent(l, value, index, selected, focus);
+                setFont(getFont().deriveFont(Font.BOLD));
+                called[0] = true;
+                return this;
+            }
+        });
+        // Measures the rows through the renderer, before anything is shown.
+        JScrollPane scroll = new JScrollPane(list);
+        assertNotNull(scroll.getPreferredSize());
+        assertTrue(list.getPreferredSize().height > 0);
+        assertTrue(called[0]);
+
+        Font mine = new Font(Font.DIALOG, Font.ITALIC, 17);
+        JPanel parent = new JPanel();
+        parent.setFont(mine);
+        parent.add(alone);
+        assertSame("A parent's font still wins over the default", mine, alone.getFont());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ListAndComboTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ListAndComboTest.java
new file mode 100644
index 00000000000..3c7e5621469
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ListAndComboTest.java
@@ -0,0 +1,628 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.javax.swing.DefaultComboBoxModel;
+import com.codename1.desktopcompat.javax.swing.DefaultListModel;
+import com.codename1.desktopcompat.javax.swing.DefaultListSelectionModel;
+import com.codename1.desktopcompat.javax.swing.JComboBox;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.ListCellRenderer;
+import com.codename1.desktopcompat.javax.swing.ListSelectionModel;
+import com.codename1.desktopcompat.javax.swing.event.ListDataEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListDataListener;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Lists and combo boxes: the models and their events against the desktop
+/// ones, the rows a custom renderer paints, and selection by clicking.
+public class ListAndComboTest extends KernelTestBase {
+
+    // ------------------------------------------------------------ selection model
+
+    private static String state(ListSelectionModel m) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 40; i++) {
+            sb.append(m.isSelectedIndex(i) ? '1' : '0');
+        }
+        return sb + " a" + m.getAnchorSelectionIndex() + " l" + m.getLeadSelectionIndex() + " min"
+                + m.getMinSelectionIndex() + " max" + m.getMaxSelectionIndex() + " e" + m.isSelectionEmpty();
+    }
+
+    private static String state(javax.swing.ListSelectionModel m) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 40; i++) {
+            sb.append(m.isSelectedIndex(i) ? '1' : '0');
+        }
+        return sb + " a" + m.getAnchorSelectionIndex() + " l" + m.getLeadSelectionIndex() + " min"
+                + m.getMinSelectionIndex() + " max" + m.getMaxSelectionIndex() + " e" + m.isSelectionEmpty();
+    }
+
+    /// Thousands of random operations in each mode; after every one the
+    /// selection, anchor, lead and the events fired are the desktop's.
+    @Test
+    public void theSelectionModelBehavesLikeTheDesktopOne() {
+        for (int mode = 0; mode < 3; mode++) {
+            final List<String> oursLog = new ArrayList<String>();
+            final List<String> realLog = new ArrayList<String>();
+            DefaultListSelectionModel ours = new DefaultListSelectionModel();
+            javax.swing.DefaultListSelectionModel real = new javax.swing.DefaultListSelectionModel();
+            ours.setSelectionMode(mode);
+            real.setSelectionMode(mode);
+            ours.addListSelectionListener(new ListSelectionListener() {
+                @Override
+                public void valueChanged(ListSelectionEvent e) {
+                    oursLog.add(e.getFirstIndex() + "-" + e.getLastIndex() + (e.getValueIsAdjusting() ? "~" : ""));
+                }
+            });
+            real.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
+                @Override
+                public void valueChanged(javax.swing.event.ListSelectionEvent e) {
+                    realLog.add(e.getFirstIndex() + "-" + e.getLastIndex() + (e.getValueIsAdjusting() ? "~" : ""));
+                }
+            });
+            Random r = new Random(42 + mode);
+            for (int step = 0; step < 3000; step++) {
+                int a = r.nextInt(22) - 1;
+                int b = r.nextInt(22) - 1;
+                int op = r.nextInt(11);
+                String what = "mode " + mode + " step " + step + " op " + op + " (" + a + "," + b + ")";
+                switch (op) {
+                    case 0:
+                        ours.setSelectionInterval(a, b);
+                        real.setSelectionInterval(a, b);
+                        break;
+                    case 1:
+                        ours.addSelectionInterval(a, b);
+                        real.addSelectionInterval(a, b);
+                        break;
+                    case 2:
+                        ours.removeSelectionInterval(a, b);
+                        real.removeSelectionInterval(a, b);
+                        break;
+                    case 3:
+                        ours.setLeadSelectionIndex(a);
+                        real.setLeadSelectionIndex(a);
+                        break;
+                    case 4:
+                        ours.setAnchorSelectionIndex(a);
+                        real.setAnchorSelectionIndex(a);
+                        break;
+                    case 5:
+                        if (r.nextInt(8) == 0) {
+                            ours.clearSelection();
+                            real.clearSelection();
+                        }
+                        break;
+                    case 6:
+                        if (a >= 0) {
+                            int len = 1 + r.nextInt(3);
+                            boolean before = r.nextBoolean();
+                            ours.insertIndexInterval(a, len, before);
+                            real.insertIndexInterval(a, len, before);
+                        }
+                        break;
+                    case 7:
+                        if (a >= 0 && b >= 0) {
+                            ours.removeIndexInterval(a, b);
+                            real.removeIndexInterval(a, b);
+                        }
+                        break;
+                    case 8:
+                        boolean adjusting = r.nextBoolean();
+                        ours.setValueIsAdjusting(adjusting);
+                        real.setValueIsAdjusting(adjusting);
+                        break;
+                    case 9:
+                        ours.moveLeadSelectionIndex(a);
+                        real.moveLeadSelectionIndex(a);
+                        break;
+                    default:
+                        if (r.nextInt(20) == 0) {
+                            ours.clearSelection();
+                            real.clearSelection();
+                            ours.setAnchorSelectionIndex(-1);
+                            real.setAnchorSelectionIndex(-1);
+                        }
+                        break;
+                }
+                assertEquals(what, state(real), state(ours));
+                assertEquals(what, realLog.toString(), oursLog.toString());
+                oursLog.clear();
+                realLog.clear();
+            }
+        }
+        // An empty selection clears, and changes mode, at once.
+        DefaultListSelectionModel empty = new DefaultListSelectionModel();
+        empty.clearSelection();
+        empty.clearSelection();
+        empty.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        assertTrue(empty.isSelectionEmpty());
+        try {
+            new DefaultListSelectionModel().setSelectionMode(7);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected);
+        }
+    }
+
+    // ------------------------------------------------------------ list model
+
+    private static final class DataLog implements ListDataListener, javax.swing.event.ListDataListener {
+        final List<String> events = new ArrayList<String>();
+
+        @Override
+        public void intervalAdded(ListDataEvent e) {
+            events.add("add " + e.getIndex0() + "-" + e.getIndex1());
+        }
+
+        @Override
+        public void intervalRemoved(ListDataEvent e) {
+            events.add("remove " + e.getIndex0() + "-" + e.getIndex1());
+        }
+
+        @Override
+        public void contentsChanged(ListDataEvent e) {
+            events.add("change " + e.getIndex0() + "-" + e.getIndex1());
+        }
+
+        @Override
+        public void intervalAdded(javax.swing.event.ListDataEvent e) {
+            events.add("add " + e.getIndex0() + "-" + e.getIndex1());
+        }
+
+        @Override
+        public void intervalRemoved(javax.swing.event.ListDataEvent e) {
+            events.add("remove " + e.getIndex0() + "-" + e.getIndex1());
+        }
+
+        @Override
+        public void contentsChanged(javax.swing.event.ListDataEvent e) {
+            events.add("change " + e.getIndex0() + "-" + e.getIndex1());
+        }
+    }
+
+    @Test
+    public void theListModelTellsItsListenersWhatTheDesktopOneDoes() {
+        DefaultListModel<String> ours = new DefaultListModel<String>();
+        javax.swing.DefaultListModel<String> real = new javax.swing.DefaultListModel<String>();
+        DataLog oursLog = new DataLog();
+        DataLog realLog = new DataLog();
+        ours.addListDataListener(oursLog);
+        real.addListDataListener(realLog);
+        ours.addElement("a");
+        real.addElement("a");
+        ours.add(0, "b");
+        real.add(0, "b");
+        ours.insertElementAt("c", 1);
+        real.insertElementAt("c", 1);
+        ours.set(2, "A");
+        real.set(2, "A");
+        ours.setElementAt("B", 0);
+        real.setElementAt("B", 0);
+        assertEquals(real.removeElement("zzz"), ours.removeElement("zzz"));
+        assertEquals(real.removeElement("c"), ours.removeElement("c"));
+        ours.addElement("d");
+        real.addElement("d");
+        ours.addElement("e");
+        real.addElement("e");
+        ours.removeRange(1, 2);
+        real.removeRange(1, 2);
+        assertEquals(real.remove(0), ours.remove(0));
+        ours.setSize(3);
+        real.setSize(3);
+        ours.clear();
+        real.clear();
+        ours.clear();
+        real.clear();
+        assertEquals(realLog.events.toString(), oursLog.events.toString());
+        assertEquals(real.toString(), ours.toString());
+        assertEquals(real.getSize(), ours.getSize());
+    }
+
+    // ------------------------------------------------------------ list
+
+    private static final int ROW = 20;
+
+    /// A renderer that is not a label: it draws its row itself.
+    private static final class Drawn extends JComponent implements ListCellRenderer<String> {
+        String text;
+        final List<String> asked = new ArrayList<String>();
+
+        @Override
+        public Component getListCellRendererComponent(JList<? extends String> list, String value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            asked.add(index + (isSelected ? "*" : ""));
+            text = (isSelected ? "[" + value + "]" : value) + "#" + index;
+            return this;
+        }
+
+        @Override
+        public Dimension getPreferredSize() {
+            return new Dimension(90, ROW);
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            g.drawString(text + " " + getWidth() + "x" + getHeight(), 0, 12);
+        }
+    }
+
+    private JList<String> list;
+    private DefaultListModel<String> model;
+    private Drawn drawn;
+
+    private JFrame listFrame(int rows, boolean scrolled) {
+        model = new DefaultListModel<String>();
+        for (int i = 0; i < rows; i++) {
+            model.addElement("row" + i);
+        }
+        list = new JList<String>(model);
+        drawn = new Drawn();
+        list.setCellRenderer(drawn);
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        f.add(scrolled ? new JScrollPane(list) : list, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    @Test
+    public void aCustomRendererPaintsEveryRowWhereItBelongs() {
+        JFrame f = listFrame(3, false);
+        list.setSelectedIndex(1);
+        drawn.asked.clear();
+        List<Object[]> text = paint(f);
+        int w = list.getWidth();
+        Object[] first = find(text, "row0#0 " + w + "x" + ROW);
+        Object[] second = find(text, "[row1]#1 " + w + "x" + ROW);
+        Object[] third = find(text, "row2#2 " + w + "x" + ROW);
+        assertNotNull(first);
+        assertNotNull(second);
+        assertNotNull(third);
+        int y0 = ((Number) first[2]).intValue();
+        assertEquals(y0 + Units.toDevice(ROW), ((Number) second[2]).intValue());
+        assertEquals(y0 + Units.toDevice(2 * ROW), ((Number) third[2]).intValue());
+        assertEquals(first[1], third[1]);
+        assertTrue(drawn.asked.containsAll(Arrays.asList("0", "1*", "2")));
+    }
+
+    @Test
+    public void theDefaultRendererShowsTheValues() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JList<String> plain = new JList<String>(new String[]{"alpha", "beta"});
+        f.add(plain, BorderLayout.CENTER);
+        show(f);
+        List<Object[]> text = paint(f);
+        Object[] a = find(text, "alpha");
+        Object[] b = find(text, "beta");
+        assertNotNull(a);
+        assertNotNull(b);
+        assertTrue(((Number) b[2]).intValue() > ((Number) a[2]).intValue());
+        assertEquals(plain.getCellBounds(0, 0).height, plain.getCellBounds(1, 1).height);
+        assertTrue(plain.getCellBounds(0, 0).height > 0);
+    }
+
+    @Test
+    public void rowGeometry() {
+        listFrame(5, false);
+        assertEquals(new Dimension(90, 5 * ROW), list.getPreferredSize());
+        assertEquals(new Rectangle(0, 2 * ROW, list.getWidth(), ROW), list.getCellBounds(2, 2));
+        assertEquals(new Rectangle(0, ROW, list.getWidth(), 3 * ROW), list.getCellBounds(3, 1));
+        assertNull(list.getCellBounds(0, 5));
+        assertEquals(new Point(0, 4 * ROW), list.indexToLocation(4));
+        assertEquals(0, list.locationToIndex(new Point(5, 0)));
+        assertEquals(1, list.locationToIndex(new Point(5, ROW)));
+        assertEquals(2, list.locationToIndex(new Point(5, 3 * ROW - 1)));
+        assertEquals(4, list.locationToIndex(new Point(5, 5000)));
+        assertEquals(-1, new JList<String>().locationToIndex(new Point(0, 0)));
+        list.setFixedCellHeight(30);
+        list.setFixedCellWidth(120);
+        assertEquals(new Dimension(120, 150), list.getPreferredSize());
+        list.setVisibleRowCount(4);
+        assertEquals(new Dimension(120, 120), list.getPreferredScrollableViewportSize());
+        model.remove(0);
+        assertEquals(new Dimension(120, 120), list.getPreferredSize());
+    }
+
+    @Test
+    public void clickingSelects() {
+        JFrame f = listFrame(5, false);
+        final List<String> events = new ArrayList<String>();
+        list.addListSelectionListener(new ListSelectionListener() {
+            @Override
+            public void valueChanged(ListSelectionEvent e) {
+                assertEquals(list, e.getSource());
+                events.add(e.getFirstIndex() + "-" + e.getLastIndex());
+            }
+        });
+        press(f, list, 10, 2 * ROW + 5);
+        release(f, list, 10, 2 * ROW + 5);
+        assertEquals(2, list.getSelectedIndex());
+        assertEquals("row2", list.getSelectedValue());
+        assertEquals("[2-2]", events.toString());
+        press(f, list, 10, 5);
+        release(f, list, 10, 5);
+        assertEquals(0, list.getSelectedIndex());
+        assertEquals("[2-2, 0-2]", events.toString());
+    }
+
+    @Test
+    public void selectionApi() {
+        listFrame(6, false);
+        list.setSelectedIndices(new int[]{1, 3, 4, 99});
+        assertArrayEquals(new int[]{1, 3, 4}, list.getSelectedIndices());
+        assertEquals(Arrays.asList("row1", "row3", "row4"), list.getSelectedValuesList());
+        assertEquals(3, list.getSelectedValues().length);
+        assertEquals(1, list.getMinSelectionIndex());
+        assertEquals(4, list.getMaxSelectionIndex());
+        list.setSelectedValue("row5", false);
+        assertEquals(5, list.getSelectedIndex());
+        list.setSelectedValue("nothing", false);
+        assertEquals(5, list.getSelectedIndex());
+        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        list.setSelectionInterval(1, 3);
+        assertArrayEquals(new int[]{3}, list.getSelectedIndices());
+        list.clearSelection();
+        assertTrue(list.isSelectionEmpty());
+        assertNull(list.getSelectedValue());
+    }
+
+    @Test
+    public void theSelectionFollowsRowsAddedAndRemoved() {
+        listFrame(4, false);
+        list.setSelectedIndex(2);
+        model.add(0, "new");
+        assertEquals(3, list.getSelectedIndex());
+        assertEquals("row2", list.getSelectedValue());
+        model.remove(1);
+        assertEquals(2, list.getSelectedIndex());
+        model.remove(2);
+        assertTrue(list.isSelectionEmpty());
+    }
+
+    @Test
+    public void aListInAScrollPaneScrollsToARow() {
+        listFrame(400, true);
+        JScrollPane pane = (JScrollPane) list.getParent().getParent();
+        int extent = pane.getViewport().getExtentSize().height;
+        assertEquals(400 * ROW, list.getHeight());
+        assertEquals(pane.getViewport().getExtentSize().width, list.getWidth());
+        assertEquals(0, list.getFirstVisibleIndex());
+        list.ensureIndexIsVisible(300);
+        assertEquals(301 * ROW - extent, pane.getViewport().getViewPosition().y);
+        assertEquals(300, list.getLastVisibleIndex());
+        list.ensureIndexIsVisible(300);
+        assertEquals(301 * ROW - extent, pane.getViewport().getViewPosition().y);
+        list.setSelectedValue("row2", true);
+        assertEquals(2 * ROW, pane.getViewport().getViewPosition().y);
+        assertEquals(2, list.getFirstVisibleIndex());
+    }
+
+    @Test
+    public void onlyTheRowsInViewArePainted() {
+        JFrame f = listFrame(400, true);
+        drawn.asked.clear();
+        paint(f);
+        assertTrue(drawn.asked.size() > 0);
+        assertTrue("asked for " + drawn.asked.size(), drawn.asked.size() < 100);
+    }
+
+    // ------------------------------------------------------------ combo box
+
+    /// One log of item and action events, fed by either toolkit.
+    private static final class ComboLog implements ItemListener, ActionListener, java.awt.event.ItemListener,
+            java.awt.event.ActionListener {
+        final List<String> events = new ArrayList<String>();
+
+        @Override
+        public void itemStateChanged(ItemEvent e) {
+            events.add((e.getStateChange() == ItemEvent.SELECTED ? "+" : "-") + e.getItem());
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            events.add("action:" + e.getActionCommand());
+        }
+
+        @Override
+        public void itemStateChanged(java.awt.event.ItemEvent e) {
+            events.add((e.getStateChange() == java.awt.event.ItemEvent.SELECTED ? "+" : "-") + e.getItem());
+        }
+
+        @Override
+        public void actionPerformed(java.awt.event.ActionEvent e) {
+            events.add("action:" + e.getActionCommand());
+        }
+    }
+
+    @Test
+    public void theComboBoxFiresWhatTheDesktopOneFires() {
+        JComboBox<String> ours = new JComboBox<String>();
+        javax.swing.JComboBox<String> real = new javax.swing.JComboBox<String>();
+        ComboLog oursLog = new ComboLog();
+        ComboLog realLog = new ComboLog();
+        ours.addItemListener(oursLog);
+        ours.addActionListener(oursLog);
+        real.addItemListener(realLog);
+        real.addActionListener(realLog);
+        Random r = new Random(7);
+        String[] names = {"a", "b", "c", "d", "e", "f"};
+        for (int step = 0; step < 2000; step++) {
+            String name = names[r.nextInt(names.length)];
+            int op = r.nextInt(9);
+            int count = real.getItemCount();
+            String what = "step " + step + " op " + op + " " + name;
+            switch (op) {
+                case 0:
+                    ours.addItem(name);
+                    real.addItem(name);
+                    break;
+                case 1:
+                    ours.setSelectedItem(name);
+                    real.setSelectedItem(name);
+                    break;
+                case 2:
+                    int index = r.nextInt(count + 1) - 1;
+                    ours.setSelectedIndex(index);
+                    real.setSelectedIndex(index);
+                    break;
+                case 3:
+                    ours.removeItem(name);
+                    real.removeItem(name);
+                    break;
+                case 4:
+                    if (count > 0) {
+                        int at = r.nextInt(count);
+                        ours.removeItemAt(at);
+                        real.removeItemAt(at);
+                    }
+                    break;
+                case 5:
+                    int where = r.nextInt(count + 1);
+                    ours.insertItemAt(name, where);
+                    real.insertItemAt(name, where);
+                    break;
+                case 6:
+                    if (r.nextInt(10) == 0) {
+                        ours.removeAllItems();
+                        real.removeAllItems();
+                    }
+                    break;
+                case 7:
+                    ours.setSelectedItem(null);
+                    real.setSelectedItem(null);
+                    break;
+                default:
+                    if (count > 6) {
+                        ours.removeItemAt(0);
+                        real.removeItemAt(0);
+                    }
+                    break;
+            }
+            assertEquals(what, realLog.events.toString(), oursLog.events.toString());
+            assertEquals(what, real.getSelectedItem(), ours.getSelectedItem());
+            assertEquals(what, real.getSelectedIndex(), ours.getSelectedIndex());
+            assertEquals(what, real.getItemCount(), ours.getItemCount());
+            oursLog.events.clear();
+            realLog.events.clear();
+        }
+        try {
+            ours.setSelectedIndex(999);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected);
+        }
+    }
+
+    @Test
+    public void anEditableComboBoxTakesAnItemItDoesNotList() {
+        JComboBox<String> ours = new JComboBox<String>(new String[]{"a", "b"});
+        javax.swing.JComboBox<String> real = new javax.swing.JComboBox<String>(new String[]{"a", "b"});
+        ours.setSelectedItem("typed");
+        real.setSelectedItem("typed");
+        assertEquals(real.getSelectedItem(), ours.getSelectedItem());
+        ours.setEditable(true);
+        real.setEditable(true);
+        ours.setSelectedItem("typed");
+        real.setSelectedItem("typed");
+        assertEquals(real.getSelectedItem(), ours.getSelectedItem());
+        assertEquals(real.getSelectedIndex(), ours.getSelectedIndex());
+        assertEquals(real.getActionCommand(), ours.getActionCommand());
+        assertEquals(real.getMaximumRowCount(), ours.getMaximumRowCount());
+    }
+
+    @Test
+    public void theWidgetFollowsTheModelAndThePopupSelects() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        DefaultComboBoxModel<String> m = new DefaultComboBoxModel<String>(new String[]{"one", "two", "three"});
+        JComboBox<String> combo = new JComboBox<String>(m);
+        f.add(combo, BorderLayout.NORTH);
+        show(f);
+        com.codename1.ui.ComboBox<?> peer = (com.codename1.ui.ComboBox<?>) combo.cn1Peer();
+        assertEquals(3, peer.getModel().getSize());
+        assertEquals(0, peer.getSelectedIndex());
+        assertTrue(combo.getHeight() > 0);
+        combo.setSelectedItem("three");
+        assertEquals(2, peer.getSelectedIndex());
+        assertEquals("three", peer.getSelectedItem());
+        m.addElement("four");
+        assertEquals(4, peer.getModel().getSize());
+        ComboLog log = new ComboLog();
+        combo.addItemListener(log);
+        combo.addActionListener(log);
+        // What the popup does when a row is picked.
+        peer.getModel().setSelectedIndex(1);
+        assertEquals("two", combo.getSelectedItem());
+        assertEquals("[-three, +two, action:comboBoxChanged]", log.events.toString());
+        log.events.clear();
+        peer.getModel().setSelectedIndex(1);
+        assertTrue(log.events.isEmpty());
+    }
+
+    @Test
+    public void theComboBoxIsPaintedWithItsRenderer() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"one", "two"});
+        final Drawn renderer = new Drawn();
+        combo.setRenderer(renderer);
+        f.add(combo, BorderLayout.NORTH);
+        show(f);
+        combo.setSelectedIndex(1);
+        List<Object[]> text = paint(f);
+        boolean found = false;
+        for (int i = 0; i < text.size(); i++) {
+            found |= String.valueOf(text.get(i)[0]).contains("two");
+        }
+        assertTrue(found);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/MenusTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/MenusTest.java
new file mode 100644
index 00000000000..3e18eed3c24
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/MenusTest.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.ButtonGroup;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JCheckBoxMenuItem;
+import com.codename1.desktopcompat.javax.swing.JDialog;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JMenu;
+import com.codename1.desktopcompat.javax.swing.JMenuBar;
+import com.codename1.desktopcompat.javax.swing.JMenuItem;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JPopupMenu;
+import com.codename1.desktopcompat.javax.swing.JRadioButtonMenuItem;
+import com.codename1.desktopcompat.javax.swing.JToolBar;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+import com.codename1.desktopcompat.javax.swing.MenuSelectionManager;
+import com.codename1.desktopcompat.javax.swing.event.PopupMenuEvent;
+import com.codename1.desktopcompat.javax.swing.event.PopupMenuListener;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import com.codename1.ui.Command;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Menu bars as commands, menus drawn in a window, popup menus, tool
+/// bars, and actions that keep their items in step.
+public class MenusTest extends WindowsTestBase {
+
+    private static final class Counter extends AbstractAction {
+        int count;
+
+        Counter(String name) {
+            super(name);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            count++;
+        }
+    }
+
+    private static final class Clicks implements ActionListener {
+        int count;
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            count++;
+        }
+    }
+
+    private static List<String> names(List<Command> cmds) {
+        List<String> out = new ArrayList<String>();
+        for (int i = 0; i < cmds.size(); i++) {
+            out.add(cmds.get(i).getCommandName());
+        }
+        return out;
+    }
+
+    private static void run(Command c) {
+        c.actionPerformed(new com.codename1.ui.events.ActionEvent(c));
+    }
+
+    private static final String CHECK = String.valueOf((char) 0x2713) + " ";
+
+    @Test
+    public void everyItemOfTheMenuBarOfAFrameIsOneCommandUnderItsMenu() {
+        JFrame f = new JFrame("menus");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        JMenu edit = new JMenu("Edit");
+        JMenuItem open = new JMenuItem("Open");
+        JMenuItem quit = new JMenuItem("Quit");
+        quit.setEnabled(false);
+        JMenu recent = new JMenu("Recent");
+        JMenuItem one = new JMenuItem("one.txt");
+        recent.add(one);
+        JCheckBoxMenuItem wrap = new JCheckBoxMenuItem("Wrap", true);
+        file.add(open);
+        file.add(recent);
+        file.addSeparator();
+        file.add(quit);
+        edit.add(wrap);
+        bar.add(file);
+        bar.add(edit);
+        Clicks opened = new Clicks();
+        Clicks oneClicked = new Clicks();
+        open.addActionListener(opened);
+        one.addActionListener(oneClicked);
+        f.setJMenuBar(bar);
+        show(f);
+
+        List<Command> cmds = f.cn1Form().cn1Commands();
+        assertEquals("[Open, Recent > one.txt, Quit, " + CHECK + "Wrap]", names(cmds).toString());
+        assertEquals("File", cmds.get(0).getDesktopMenu());
+        assertEquals("File", cmds.get(1).getDesktopMenu());
+        assertEquals("Edit", cmds.get(3).getDesktopMenu());
+        assertTrue(cmds.get(0).isEnabled());
+        assertFalse(cmds.get(2).isEnabled());
+        assertTrue("a bridged menu bar takes no room", bar.cn1Bridged());
+        assertEquals(0, bar.getHeight());
+        assertEquals(f.getRootPane().getHeight(), f.getContentPane().getHeight());
+
+        run(cmds.get(0));
+        assertEquals(1, opened.count);
+        run(cmds.get(1));
+        assertEquals(1, oneClicked.count);
+
+        run(cmds.get(3));
+        assertFalse(wrap.isSelected());
+        assertEquals("Wrap", f.cn1Form().cn1Commands().get(3).getCommandName());
+    }
+
+    @Test
+    public void commandsFollowTheMenuBarAsItChanges() {
+        JFrame f = new JFrame("menus");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        JMenuItem open = new JMenuItem("Open");
+        file.add(open);
+        bar.add(file);
+        f.setJMenuBar(bar);
+        show(f);
+        assertEquals("[Open]", names(f.cn1Form().cn1Commands()).toString());
+        open.setText("Open...");
+        file.add(new JMenuItem("Close"));
+        assertEquals("[Open..., Close]", names(f.cn1Form().cn1Commands()).toString());
+        open.setEnabled(false);
+        assertFalse(f.cn1Form().cn1Commands().get(0).isEnabled());
+        JMenu help = new JMenu("Help");
+        help.add(new JMenuItem("About"));
+        bar.add(help);
+        assertEquals("Help", f.cn1Form().cn1Commands().get(2).getDesktopMenu());
+        file.remove(open);
+        assertEquals("[Close, About]", names(f.cn1Form().cn1Commands()).toString());
+        f.setJMenuBar(null);
+        assertTrue(f.cn1Form().cn1Commands().isEmpty());
+    }
+
+    @Test
+    public void anActionKeepsItsItemAndItsCommandInStep() {
+        JFrame f = new JFrame("menus");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        Counter save = new Counter("Save");
+        save.putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));
+        JMenuItem item = file.add(save);
+        bar.add(file);
+        f.setJMenuBar(bar);
+        show(f);
+        assertEquals("Save", item.getText());
+        assertEquals(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK), item.getAccelerator());
+        Command cmd = f.cn1Form().cn1Commands().get(0);
+        assertEquals('S', cmd.getDesktopShortcutKeyChar());
+        assertEquals(Command.DESKTOP_SHORTCUT_MODIFIER_PRIMARY, cmd.getDesktopShortcutModifiers());
+        run(cmd);
+        assertEquals(1, save.count);
+
+        save.setEnabled(false);
+        assertFalse(item.isEnabled());
+        assertFalse(f.cn1Form().cn1Commands().get(0).isEnabled());
+        save.putValue(Action.NAME, "Save All");
+        assertEquals("Save All", item.getText());
+        assertEquals("Save All", f.cn1Form().cn1Commands().get(0).getCommandName());
+        save.setEnabled(true);
+        assertTrue(f.cn1Form().cn1Commands().get(0).isEnabled());
+    }
+
+    @Test
+    public void anAcceleratorRunsItsItemWhileTheWindowHasTheFocus() {
+        JFrame f = new JFrame("menus");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        JMenuItem open = new JMenuItem("Open");
+        open.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_DOWN_MASK));
+        Clicks clicks = new Clicks();
+        open.addActionListener(clicks);
+        file.add(open);
+        bar.add(file);
+        f.setJMenuBar(bar);
+        JButton b = new JButton("focus");
+        f.add(b, BorderLayout.CENTER);
+        show(f);
+        b.requestFocusInWindow();
+        type(f, 'o');
+        assertEquals(0, clicks.count);
+        input.control();
+        type(f, 'o');
+        assertEquals(1, clicks.count);
+        open.setEnabled(false);
+        type(f, 'o');
+        assertEquals(1, clicks.count);
+    }
+
+    @Test
+    public void onADesktopTheCommandsGoToTheWindowOfTheFrame() {
+        FakeDesktop desktop = new FakeDesktop();
+        WindowHosts.setSecondaryWindows(desktop);
+        show(new JFrame("first"));
+        JFrame second = new JFrame("second");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        Clicks clicks = new Clicks();
+        JMenuItem open = new JMenuItem("Open");
+        open.addActionListener(clicks);
+        file.add(open);
+        bar.add(file);
+        second.setJMenuBar(bar);
+        second.setSize(300, 200);
+        second.setVisible(true);
+        FakeHost host = desktop.hosts.get(0);
+        assertEquals("[Open]", names(host.commands).toString());
+        assertEquals("File", host.commands.get(0).getDesktopMenu());
+        run(host.commands.get(0));
+        assertEquals(1, clicks.count);
+        file.add(new JMenuItem("Close"));
+        assertEquals("[Open, Close]", names(host.commands).toString());
+    }
+
+    @Test
+    public void inADialogTheMenuBarIsDrawnAndItsMenusOpenPopups() {
+        JFrame f = show(new JFrame("owner"));
+        JDialog d = new JDialog(f, "dialog");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        JMenuItem open = new JMenuItem("Open");
+        Clicks clicks = new Clicks();
+        open.addActionListener(clicks);
+        file.add(open);
+        JMenu more = new JMenu("More");
+        JMenuItem deep = new JMenuItem("Deep");
+        Clicks deepClicks = new Clicks();
+        deep.addActionListener(deepClicks);
+        more.add(deep);
+        file.add(more);
+        bar.add(file);
+        d.setJMenuBar(bar);
+        d.add(new JPanel(), BorderLayout.CENTER);
+        d.setSize(300, 300);
+        d.setVisible(true);
+        assertFalse(bar.cn1Bridged());
+        assertTrue(bar.getHeight() > 0);
+        assertEquals(bar.getHeight(), d.getContentPane().getY());
+
+        assertFalse(file.isPopupMenuVisible());
+        click(d, file, 3, 3);
+        assertTrue(file.isPopupMenuVisible());
+        assertTrue(file.isSelected());
+        assertSame(d.getLayeredPane(), file.getPopupMenu().getParent());
+        assertEquals(0, d.getLayeredPane().getIndexOf(file.getPopupMenu()));
+        assertTrue(file.getPopupMenu().getHeight() > 0);
+
+        click(d, more, 3, 3);
+        assertTrue(more.isPopupMenuVisible());
+        assertTrue("the parent menu stays open", file.isPopupMenuVisible());
+        assertEquals(4, MenuSelectionManager.defaultManager().getSelectedPath().length);
+
+        click(d, deep, 3, 3);
+        assertEquals(1, deepClicks.count);
+        assertFalse(more.isPopupMenuVisible());
+        assertFalse(file.isPopupMenuVisible());
+        assertFalse(file.isSelected());
+        assertNull(file.getPopupMenu().getParent());
+
+        click(d, file, 3, 3);
+        click(d, open, 3, 3);
+        assertEquals(1, clicks.count);
+        click(d, file, 3, 3);
+        assertTrue(file.isPopupMenuVisible());
+        click(d, file, 3, 3);
+        assertFalse("a second click closes the menu", file.isPopupMenuVisible());
+    }
+
+    @Test
+    public void aPopupMenuOpensOnThePopupTriggerAndAPressOutsideClosesIt() {
+        JFrame f = new JFrame("popup");
+        JPanel p = new JPanel();
+        final int[] presses = new int[1];
+        p.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                presses[0]++;
+            }
+        });
+        f.add(p, BorderLayout.CENTER);
+        JPopupMenu menu = new JPopupMenu();
+        Clicks copy = new Clicks();
+        JMenuItem copyItem = menu.add("Copy");
+        copyItem.addActionListener(copy);
+        menu.addSeparator();
+        menu.add(new JMenuItem("Paste"));
+        final List<String> log = new ArrayList<String>();
+        menu.addPopupMenuListener(new PopupMenuListener() {
+            @Override
+            public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
+                log.add("visible");
+            }
+
+            @Override
+            public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
+                log.add("invisible");
+            }
+
+            @Override
+            public void popupMenuCanceled(PopupMenuEvent e) {
+                log.add("canceled");
+            }
+        });
+        p.setComponentPopupMenu(menu);
+        show(f);
+
+        click(f, p, 40, 50);
+        assertFalse(menu.isVisible());
+        input.button = 3;
+        click(f, p, 40, 50);
+        assertTrue(menu.isVisible());
+        assertSame(p, menu.getInvoker());
+        assertEquals("[visible]", log.toString());
+        assertEquals(40, menu.getX() - p.getX());
+        Dimension pref = menu.getPreferredSize();
+        assertEquals(pref.height, menu.getHeight());
+        assertTrue(MenuSelectionManager.defaultManager().isComponentPartOfCurrentMenu(copyItem));
+
+        input.button = 1;
+        int before = presses[0];
+        click(f, p, 5, 5);
+        assertFalse(menu.isVisible());
+        assertEquals("the press that closes a popup is not delivered", before, presses[0]);
+        assertEquals("[visible, invisible]", log.toString());
+
+        input.button = 3;
+        click(f, p, 40, 50);
+        input.button = 1;
+        click(f, copyItem, 3, 3);
+        assertEquals(1, copy.count);
+        assertFalse(menu.isVisible());
+
+        menu.show(p, 10, 10);
+        assertTrue(menu.isVisible());
+        type(f, 27);
+        assertFalse("escape closes the popup", menu.isVisible());
+    }
+
+    @Test
+    public void aLongPressOfAFingerIsAPopupTrigger() {
+        JFrame f = new JFrame("popup");
+        JPanel p = new JPanel();
+        final int[] clicked = new int[1];
+        p.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                clicked[0]++;
+            }
+        });
+        f.add(p, BorderLayout.CENTER);
+        JPopupMenu menu = new JPopupMenu();
+        menu.add("Copy");
+        p.setComponentPopupMenu(menu);
+        show(f);
+        input.touch = true;
+        int[] at = at(p, 30, 30);
+        f.cn1Form().pointerPressed(at[0], at[1]);
+        assertFalse(menu.isVisible());
+        f.cn1Form().longPointerPress(at[0], at[1]);
+        assertTrue(menu.isVisible());
+        f.cn1Form().pointerReleased(at[0], at[1]);
+        assertTrue("the release keeps the menu open", menu.isVisible());
+        assertEquals("a long press is not a click", 0, clicked[0]);
+    }
+
+    @Test
+    public void thePopupMenuOfAParentIsInheritedOnlyWhenAsked() {
+        JPanel parent = new JPanel();
+        JPanel child = new JPanel();
+        parent.add(child);
+        JPopupMenu menu = new JPopupMenu();
+        parent.setComponentPopupMenu(menu);
+        assertNull(child.getComponentPopupMenu());
+        child.setInheritsPopupMenu(true);
+        assertSame(menu, child.getComponentPopupMenu());
+    }
+
+    @Test
+    public void radioButtonItemsOfAGroupSelectOneAndMarkItsCommand() {
+        JFrame f = new JFrame("menus");
+        JMenuBar bar = new JMenuBar();
+        JMenu view = new JMenu("View");
+        JRadioButtonMenuItem small = new JRadioButtonMenuItem("Small", true);
+        JRadioButtonMenuItem large = new JRadioButtonMenuItem("Large");
+        ButtonGroup g = new ButtonGroup();
+        g.add(small);
+        g.add(large);
+        view.add(small);
+        view.add(large);
+        bar.add(view);
+        f.setJMenuBar(bar);
+        show(f);
+        assertEquals("[" + CHECK + "Small, Large]", names(f.cn1Form().cn1Commands()).toString());
+        run(f.cn1Form().cn1Commands().get(1));
+        assertTrue(large.isSelected());
+        assertFalse(small.isSelected());
+        assertEquals("[Small, " + CHECK + "Large]", names(f.cn1Form().cn1Commands()).toString());
+    }
+
+    @Test
+    public void aToolBarButtonRunsItsActionAndFollowsIt() {
+        JFrame f = new JFrame("tools");
+        JToolBar bar = new JToolBar();
+        Counter run = new Counter("Run");
+        run.putValue(Action.SHORT_DESCRIPTION, "Runs it");
+        JButton b = bar.add(run);
+        bar.addSeparator();
+        bar.add(new JButton("Stop"));
+        f.add(bar, BorderLayout.NORTH);
+        show(f);
+        assertEquals("Run", b.getText());
+        assertEquals("Runs it", b.getToolTipText());
+        assertEquals(3, bar.getComponentCount());
+        assertTrue(bar.getHeight() > 0);
+        assertTrue(bar.getComponent(2).getX() > b.getX() + b.getWidth());
+        click(f, b, 3, 3);
+        assertEquals(1, run.count);
+        run.setEnabled(false);
+        assertFalse(b.isEnabled());
+        run.putValue(Action.NAME, "Go");
+        assertEquals("Go", b.getText());
+        bar.setOrientation(JToolBar.VERTICAL);
+        f.validate();
+        assertTrue(bar.getComponent(2).getY() > b.getY());
+    }
+
+    /// A menu is not part of the keyboard focus. The widget that draws
+    /// one in the window took the first focus of the form, and the last
+    /// menu of the bar was drawn as chosen from the moment the window
+    /// opened; the first focus is the content's, as in Swing.
+    @Test
+    public void noMenuOfABarInTheWindowHasTheFocusWhenTheWindowOpens() {
+        com.codename1.compat.testing.HeadlessImplementation.setDesktop(true);
+        try {
+            JFrame f = new JFrame("menus");
+            JMenuBar bar = new JMenuBar();
+            String[] names = {"File", "View", "Help"};
+            JMenu[] menus = new JMenu[3];
+            for (int i = 0; i < 3; i++) {
+                menus[i] = new JMenu(names[i]);
+                menus[i].add(new JMenuItem("Item"));
+                bar.add(menus[i]);
+            }
+            f.setJMenuBar(bar);
+            JButton go = new JButton("Go");
+            f.add(go, BorderLayout.CENTER);
+            f.setSize(300, 200);
+            show(f);
+            paint(f);
+            assertFalse("the bar is drawn in the window", bar.cn1Bridged());
+            for (int i = 0; i < 3; i++) {
+                com.codename1.ui.Component p = menus[i].cn1Peer();
+                assertFalse(names[i], menus[i].isFocusable());
+                assertFalse(names[i], p.isFocusable());
+                assertFalse(names[i], p.hasFocus());
+                assertSame(names[i], p.getUnselectedStyle(), p.getStyle());
+            }
+            assertSame(go.cn1Peer(), f.cn1Form().getFocused());
+            // A menu still opens, and its items are still chosen.
+            click(f, menus[2], 3, 3);
+            assertTrue(menus[2].isPopupMenuVisible());
+            assertFalse(menus[2].cn1Peer().hasFocus());
+            MenuSelectionManager.defaultManager().clearSelectedPath();
+        } finally {
+            com.codename1.compat.testing.HeadlessImplementation.setDesktop(false);
+        }
+    }
+
+    /// What is set on a component after its widget was made reaches the
+    /// widget, and so does what is taken back.
+    @Test
+    public void aComponentMadeNotFocusableIsNotOfferedTheFocus() {
+        JFrame f = new JFrame("focus");
+        JButton b = new JButton("Go");
+        f.add(b, BorderLayout.CENTER);
+        show(f);
+        assertTrue(b.cn1Peer().isFocusable());
+        b.setFocusable(false);
+        assertFalse(b.cn1Peer().isFocusable());
+        b.setFocusable(true);
+        assertTrue(b.cn1Peer().isFocusable());
+        JButton never = new JButton("Never");
+        never.setFocusable(false);
+        assertFalse(never.cn1Peer().isFocusable());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/NoJdkDesktopReferenceTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/NoJdkDesktopReferenceTest.java
new file mode 100644
index 00000000000..39e9afd3350
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/NoJdkDesktopReferenceTest.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// No class the module ships may name the JDK's own desktop packages.
+///
+/// A device has no `java.awt`: a main source that imports the real
+/// `java.awt.Color` where the layer's was meant compiles on the build
+/// machine, where the JDK supplies it, and fails only when the application
+/// is translated. Every UTF-8 constant of every class is read -- class
+/// names, descriptors and generic signatures all live there -- and none may
+/// contain one of the relocated package paths except as part of the layer's
+/// own `com/codename1/desktopcompat/` name.
+public class NoJdkDesktopReferenceTest {
+
+    private static final String OWN = "com/codename1/desktopcompat/";
+    private static final String[] FORBIDDEN = {
+        "java/awt/", "javax/swing/", "java/beans/", "javax/accessibility/", "org/jdesktop/"
+    };
+
+    @Test
+    public void noClassNamesTheJdkDesktopPackages() throws IOException {
+        File root = new File(System.getProperty("swingcompat.classes", "target/classes"));
+        List<String> problems = new ArrayList<String>();
+        int count = walk(root, problems);
+        if (!problems.isEmpty()) {
+            StringBuilder sb = new StringBuilder("references to the JDK's desktop packages:\n");
+            for (String p : problems) {
+                sb.append("  ").append(p).append('\n');
+            }
+            fail(sb.toString());
+        }
+        assertTrue("no classes under " + root, count > 0);
+    }
+
+    private static int walk(File dir, List<String> problems) throws IOException {
+        File[] files = dir.listFiles();
+        int count = 0;
+        if (files == null) {
+            return 0;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                count += walk(f, problems);
+            } else if (f.getName().endsWith(".class")) {
+                count++;
+                scan(f, problems);
+            }
+        }
+        return count;
+    }
+
+    static boolean offends(String constant) {
+        for (String pkg : FORBIDDEN) {
+            int at = constant.indexOf(pkg);
+            while (at >= 0) {
+                boolean own = at >= OWN.length() && constant.startsWith(OWN, at - OWN.length());
+                // An 'L' in front is the type marker of a descriptor unless
+                // it ends a lower case word ("xmljava/awt/").
+                boolean descriptor = at > 0 && constant.charAt(at - 1) == 'L'
+                        && (at < 2 || !Character.isLowerCase(constant.charAt(at - 2)));
+                boolean partOfLongerName = at > 0 && !descriptor
+                        && (Character.isJavaIdentifierPart(constant.charAt(at - 1)) || constant.charAt(at - 1) == '/');
+                if (!own && !partOfLongerName) {
+                    return true;
+                }
+                at = constant.indexOf(pkg, at + 1);
+            }
+        }
+        return false;
+    }
+
+    private static void scan(File f, List<String> problems) throws IOException {
+        DataInputStream in = new DataInputStream(new FileInputStream(f));
+        try {
+            in.readInt();
+            in.readUnsignedShort();
+            in.readUnsignedShort();
+            int n = in.readUnsignedShort();
+            for (int i = 1; i < n; i++) {
+                int tag = in.readUnsignedByte();
+                switch (tag) {
+                    case 1:
+                        String s = in.readUTF();
+                        if (offends(s)) {
+                            problems.add(f.getPath() + ": " + s);
+                        }
+                        break;
+                    case 3: case 4: case 9: case 10: case 11: case 12: case 17: case 18:
+                        in.readInt();
+                        break;
+                    case 5: case 6:
+                        in.readLong();
+                        i++;
+                        break;
+                    case 7: case 8: case 16: case 19: case 20:
+                        in.readUnsignedShort();
+                        break;
+                    case 15:
+                        in.readUnsignedByte();
+                        in.readUnsignedShort();
+                        break;
+                    default:
+                        throw new IOException(f + ": constant pool tag " + tag);
+                }
+            }
+        } finally {
+            in.close();
+        }
+    }
+
+    @Test
+    public void theScanTellsTheLayerFromTheJdk() {
+        assertTrue(offends("Ljava/awt/Color;"));
+        assertTrue(offends("javax/swing/JButton"));
+        assertFalse(offends("Lcom/codename1/desktopcompat/java/awt/Color;"));
+        assertTrue(offends("(Lcom/codename1/desktopcompat/java/awt/Color;Ljava/awt/Font;)V"));
+        assertFalse(offends("java/lang/String"));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/PaintRoutingTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/PaintRoutingTest.java
new file mode 100644
index 00000000000..27da0437167
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/PaintRoutingTest.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Canvas;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import java.util.List;
+import org.junit.Test;
+
+/// Who paints what: custom `paintComponent` code, the Codename One widget
+/// behind a standard component, and neither when an override skips
+/// `super.paintComponent`.
+public class PaintRoutingTest extends KernelTestBase {
+
+    @Test
+    public void aCustomPaintComponentDrawsInLogicalCoordinates() {
+        final int[] paints = new int[1];
+        final boolean[] graphics2d = new boolean[1];
+        final Color[] start = new Color[1];
+        JPanel panel = new JPanel() {
+            @Override
+            protected void paintComponent(Graphics g) {
+                super.paintComponent(g);
+                paints[0]++;
+                graphics2d[0] = g instanceof Graphics2D;
+                start[0] = g.getColor();
+                g.drawString("custom", 10, 20);
+            }
+        };
+        panel.setForeground(Color.RED);
+        JFrame f = new JFrame();
+        f.add(panel, BorderLayout.CENTER);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertEquals(1, paints[0]);
+        assertTrue(graphics2d[0]);
+        Object[] drawn = find(text, "custom");
+        assertNotNull(drawn);
+        assertEquals(onDisplay(panel, 10, 0)[0], ((Integer) drawn[1]).intValue());
+    }
+
+    @Test
+    public void theDefaultPaintComponentDrawsTheWidget() {
+        JButton b = new JButton("Go");
+        JLabel l = new JLabel("Name");
+        JFrame f = new JFrame();
+        f.add(b, BorderLayout.SOUTH);
+        f.add(l, BorderLayout.NORTH);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertNotNull(find(text, "Go"));
+        Object[] name = find(text, "Name");
+        assertNotNull(name);
+        int x = ((Integer) name[1]).intValue();
+        assertTrue(x >= l.cn1Peer().getAbsoluteX() && x < l.cn1Peer().getAbsoluteX() + l.cn1Peer().getWidth());
+    }
+
+    @Test
+    public void skippingSuperPaintComponentLeavesTheWidgetOut() {
+        JButton b = new JButton("Go") {
+            @Override
+            protected void paintComponent(Graphics g) {
+                g.drawString("mine", 2, 12);
+            }
+        };
+        JFrame f = new JFrame();
+        f.add(b, BorderLayout.SOUTH);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertNull(find(text, "Go"));
+        assertNotNull(find(text, "mine"));
+    }
+
+    @Test
+    public void callingSuperPaintComponentDrawsTheWidgetUnderCustomPainting() {
+        JButton b = new JButton("Go") {
+            @Override
+            protected void paintComponent(Graphics g) {
+                super.paintComponent(g);
+                g.drawString("badge", 2, 12);
+            }
+        };
+        JFrame f = new JFrame();
+        f.add(b, BorderLayout.SOUTH);
+        show(f);
+        List<Object[]> text = paint(f);
+        int go = text.indexOf(find(text, "Go"));
+        int badge = text.indexOf(find(text, "badge"));
+        assertTrue(go >= 0 && badge > go);
+    }
+
+    @Test
+    public void childrenArePaintedAfterTheirParentAndCanvasPaintRuns() {
+        final StringBuilder order = new StringBuilder();
+        Canvas canvas = new Canvas() {
+            @Override
+            public void paint(Graphics g) {
+                order.append("canvas ");
+                g.drawString("canvas", 1, 10);
+            }
+        };
+        canvas.setPreferredSize(new Dimension(50, 20));
+        JPanel panel = new JPanel() {
+            @Override
+            protected void paintComponent(Graphics g) {
+                super.paintComponent(g);
+                order.append("panel ");
+            }
+        };
+        panel.add(canvas);
+        JFrame f = new JFrame();
+        f.add(panel, BorderLayout.CENTER);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertEquals("panel canvas ", order.toString());
+        Object[] drawn = find(text, "canvas");
+        assertNotNull(drawn);
+        assertEquals(onDisplay(canvas, 1, 0)[0], ((Integer) drawn[1]).intValue());
+    }
+
+    @Test
+    public void anInvisibleComponentIsNotPainted() {
+        JButton b = new JButton("Hidden");
+        b.setVisible(false);
+        JFrame f = new JFrame();
+        f.add(b, BorderLayout.SOUTH);
+        show(f);
+        assertNull(find(paint(f), "Hidden"));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/PortKeyboardTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/PortKeyboardTest.java
new file mode 100644
index 00000000000..ae3b6717d05
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/PortKeyboardTest.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.KeyAdapter;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JCheckBox;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.ui.Display;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/// The keyboard as the form of a desktop port delivers it: the key codes
+/// of that port, through the form, with the form free to do with the key
+/// what a form of a desktop does -- move the focus on Tab by its own
+/// rules. The focus has to end where Swing puts it, and a key has to act
+/// once.
+public class PortKeyboardTest extends WindowsTestBase {
+
+    private static final int FIRE = -90;
+    private static final int TAB = 9;
+
+    private final List<String> seen = new ArrayList<String>();
+
+    @Before
+    public void desk() {
+        HeadlessImplementation.setDesktop(true);
+    }
+
+    @After
+    public void noDesk() {
+        HeadlessImplementation.setDesktop(false);
+    }
+
+    private JButton button(final String name) {
+        JButton b = new JButton(name);
+        b.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                seen.add(name);
+            }
+        });
+        return b;
+    }
+
+    private static void key(JFrame f, int code) {
+        f.cn1Form().keyPressed(code);
+        f.cn1Form().keyReleased(code);
+        MainThreadRule.drain();
+    }
+
+    @Test
+    public void tabMovesTheFocusOneComponentOnAndTheKeyThatFiresActsOnce() {
+        JFrame f = new JFrame("keys");
+        f.getContentPane().setLayout(new FlowLayout());
+        JButton a = button("a");
+        JButton b = button("b");
+        JCheckBox c = new JCheckBox("c");
+        JButton d = button("d");
+        f.getContentPane().add(a);
+        f.getContentPane().add(b);
+        f.getContentPane().add(c);
+        f.getContentPane().add(d);
+        f.setSize(400, 200);
+        show(f);
+        assertTrue(a.requestFocusInWindow());
+        key(f, TAB);
+        assertTrue("one Tab is one step", b.isFocusOwner());
+        key(f, FIRE);
+        assertEquals("[b]", seen.toString());
+        key(f, TAB);
+        assertTrue(c.isFocusOwner());
+        key(f, FIRE);
+        assertTrue(c.isSelected());
+        key(f, TAB);
+        assertTrue(d.isFocusOwner());
+        key(f, 'q');
+        key(f, 16);
+        assertTrue("a key nothing wants leaves the focus alone", d.isFocusOwner());
+        key(f, FIRE);
+        assertEquals("[b, d]", seen.toString());
+    }
+
+    /// A text field is edited by the port's own editor, which takes Tab
+    /// itself and asks the form for the component after the one it edits.
+    /// The answer has to be the next component Swing would focus.
+    @Test
+    public void theComponentAfterATextFieldIsTheOneThePortEditsNext() {
+        JFrame f = new JFrame("fields");
+        f.getContentPane().setLayout(new FlowLayout());
+        com.codename1.desktopcompat.javax.swing.JLabel l = new com.codename1.desktopcompat.javax.swing.JLabel("Name");
+        com.codename1.desktopcompat.javax.swing.JTextField name =
+                new com.codename1.desktopcompat.javax.swing.JTextField("Ada", 10);
+        com.codename1.desktopcompat.javax.swing.JPasswordField pw =
+                new com.codename1.desktopcompat.javax.swing.JPasswordField(10);
+        f.getContentPane().add(l);
+        f.getContentPane().add(name);
+        f.getContentPane().add(pw);
+        f.getContentPane().add(button("ok"));
+        f.setSize(400, 200);
+        show(f);
+        com.codename1.ui.Component next = f.cn1Form().getNextComponent(name.cn1Peer());
+        assertTrue("after the name comes " + next, next == pw.cn1Peer());
+        assertTrue(f.cn1Form().getPreviousComponent(pw.cn1Peer()) == name.cn1Peer());
+    }
+
+    /// A button narrower than its text keeps the text still with the
+    /// focus on it; the native label scrolled it back and forth.
+    @Test
+    public void theTextOfANarrowButtonDoesNotScroll() {
+        JFrame f = new JFrame("narrow");
+        f.getContentPane().setLayout(null);
+        JButton b = button("A button with more text than room");
+        f.getContentPane().add(b);
+        b.setBounds(10, 10, 60, 30);
+        f.setSize(400, 200);
+        show(f);
+        assertTrue(b.cn1Peer() instanceof com.codename1.ui.Label);
+        com.codename1.ui.Label label = (com.codename1.ui.Label) b.cn1Peer();
+        assertTrue(b.requestFocusInWindow());
+        label.requestFocus();
+        MainThreadRule.drain();
+        assertTrue("the text is scrolling", !label.isTickerRunning());
+    }
+
+    @Test
+    public void enterFiresTheDefaultButton() {
+        JFrame f = new JFrame("default");
+        f.getContentPane().setLayout(new FlowLayout());
+        JCheckBox c = new JCheckBox("c");
+        JButton ok = button("ok");
+        f.getContentPane().add(c);
+        f.getContentPane().add(ok);
+        f.getRootPane().setDefaultButton(ok);
+        f.setSize(400, 200);
+        show(f);
+        assertTrue(c.requestFocusInWindow());
+        key(f, 10);
+        assertEquals("[ok]", seen.toString());
+    }
+
+    /// A game draws its board on a panel, makes the panel focusable and
+    /// reads the keyboard with a key listener on it. Nothing asks for the
+    /// focus: the window gives it to its first component when it opens.
+    @Test
+    public void aFocusablePanelWithAKeyListenerGetsTheKeysOfItsWindow() {
+        JFrame f = new JFrame("game");
+        JPanel board = new JPanel();
+        board.setFocusable(true);
+        board.addKeyListener(new KeyAdapter() {
+            @Override
+            public void keyPressed(KeyEvent e) {
+                seen.add(String.valueOf(e.getKeyCode()));
+            }
+        });
+        f.add(new JLabel(" 0"), BorderLayout.SOUTH);
+        f.add(board);
+        f.setSize(200, 400);
+        show(f);
+        assertTrue("the board is the focus owner of the window it opened in", board.isFocusOwner());
+        Display d = Display.getInstance();
+        key(f, d.getKeyCode(Display.GAME_LEFT));
+        key(f, d.getKeyCode(Display.GAME_RIGHT));
+        key(f, d.getKeyCode(Display.GAME_UP));
+        key(f, d.getKeyCode(Display.GAME_DOWN));
+        key(f, ' ');
+        assertEquals("[" + KeyEvent.VK_LEFT + ", " + KeyEvent.VK_RIGHT + ", " + KeyEvent.VK_UP + ", "
+                + KeyEvent.VK_DOWN + ", " + KeyEvent.VK_SPACE + "]", seen.toString());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ScrollPaneTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ScrollPaneTest.java
new file mode 100644
index 00000000000..e994a46192e
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ScrollPaneTest.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.BoundedRangeModel;
+import com.codename1.desktopcompat.javax.swing.DefaultBoundedRangeModel;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JScrollBar;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.JViewport;
+import com.codename1.desktopcompat.javax.swing.ScrollPaneConstants;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.Units;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The viewport arithmetic of a scroll pane, in logical units, and the
+/// way it follows the Codename One container that really scrolls.
+public class ScrollPaneTest extends KernelTestBase {
+
+    /// What is asserted here is the geometry of the pane's own layout, to
+    /// the pixel, so the line a pane has around it by default is taken
+    /// away, the way an application does.
+    @org.junit.Before
+    public void noPaneBorder() {
+        com.codename1.desktopcompat.javax.swing.UIManager.put("ScrollPane.border",
+                new com.codename1.desktopcompat.javax.swing.border.EmptyBorder(0, 0, 0, 0));
+    }
+
+    @org.junit.After
+    public void themePaneBorder() {
+        com.codename1.desktopcompat.javax.swing.UIManager.put("ScrollPane.border", null);
+    }
+
+    private JPanel view;
+    private JScrollPane pane;
+
+    private JViewport shown(int viewW, int viewH) {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        view = new JPanel();
+        view.setPreferredSize(new Dimension(viewW, viewH));
+        pane = new JScrollPane(view);
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        return pane.getViewport();
+    }
+
+    @Test
+    public void theViewKeepsItsPreferredSizeWhenItIsLarger() {
+        JViewport vp = shown(2000, 3000);
+        assertSame(view, vp.getView());
+        assertEquals(new Dimension(2000, 3000), vp.getViewSize());
+        Dimension extent = vp.getExtentSize();
+        assertTrue(extent.width > 0 && extent.width < 2000);
+        assertTrue(extent.height > 0 && extent.height < 3000);
+        assertEquals(new Point(0, 0), vp.getViewPosition());
+        assertEquals(new Rectangle(0, 0, extent.width, extent.height), vp.getViewRect());
+    }
+
+    @Test
+    public void aSmallViewIsStretchedToTheViewport() {
+        JViewport vp = shown(10, 10);
+        assertEquals(vp.getExtentSize(), vp.getViewSize());
+        assertEquals(vp.getExtentSize(), view.getSize());
+    }
+
+    @Test
+    public void movingTheViewMovesTheComponentAndTheNativeScroll() {
+        JViewport vp = shown(2000, 3000);
+        final int[] changes = {0};
+        vp.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                changes[0]++;
+            }
+        });
+        vp.setViewPosition(new Point(100, 250));
+        assertEquals(new Point(100, 250), vp.getViewPosition());
+        assertEquals(new Point(-100, -250), view.getLocation());
+        assertEquals(1, changes[0]);
+        com.codename1.ui.Component peer = vp.cn1Peer();
+        assertEquals(Units.toDevice(100), peer.getScrollX());
+        assertEquals(Units.toDevice(250), peer.getScrollY());
+        vp.setViewPosition(new Point(100, 250));
+        assertEquals(1, changes[0]);
+    }
+
+    @Test
+    public void theBarsDescribeTheViewport() {
+        JViewport vp = shown(2000, 3000);
+        Dimension extent = vp.getExtentSize();
+        JScrollBar v = pane.getVerticalScrollBar();
+        JScrollBar h = pane.getHorizontalScrollBar();
+        assertEquals(0, v.getMinimum());
+        assertEquals(3000, v.getMaximum());
+        assertEquals(extent.height, v.getVisibleAmount());
+        assertEquals(2000, h.getMaximum());
+        assertEquals(extent.width, h.getVisibleAmount());
+        vp.setViewPosition(new Point(40, 70));
+        assertEquals(70, v.getValue());
+        assertEquals(40, h.getValue());
+    }
+
+    @Test
+    public void movingABarMovesTheView() {
+        JViewport vp = shown(2000, 3000);
+        pane.getVerticalScrollBar().setValue(500);
+        assertEquals(new Point(0, 500), vp.getViewPosition());
+        pane.getHorizontalScrollBar().setValue(30);
+        assertEquals(new Point(30, 500), vp.getViewPosition());
+        pane.getVerticalScrollBar().setValue(999999);
+        assertEquals(3000 - vp.getExtentSize().height, vp.getViewPosition().y);
+    }
+
+    @Test
+    public void aNativeScrollMovesTheView() throws Exception {
+        JViewport vp = shown(2000, 3000);
+        // What a finger does: Codename One moves the scroll of the container
+        // itself, and nothing on the Swing side asked for it.
+        java.lang.reflect.Method x = com.codename1.ui.Component.class.getDeclaredMethod("setScrollX", int.class);
+        java.lang.reflect.Method y = com.codename1.ui.Component.class.getDeclaredMethod("setScrollY", int.class);
+        x.setAccessible(true);
+        y.setAccessible(true);
+        x.invoke(vp.cn1Peer(), Integer.valueOf(Units.toDevice(60)));
+        y.invoke(vp.cn1Peer(), Integer.valueOf(Units.toDevice(120)));
+        assertEquals(new Point(60, 120), vp.getViewPosition());
+        assertEquals(120, pane.getVerticalScrollBar().getValue());
+        assertEquals(new Point(-60, -120), view.getLocation());
+    }
+
+    @Test
+    public void scrollRectToVisibleMovesOnlyAsFarAsNeeded() {
+        JViewport vp = shown(2000, 3000);
+        Dimension extent = vp.getExtentSize();
+        vp.scrollRectToVisible(new Rectangle(0, 0, 10, 10));
+        assertEquals(new Point(0, 0), vp.getViewPosition());
+        vp.scrollRectToVisible(new Rectangle(0, extent.height + 90, 10, 10));
+        assertEquals(new Point(0, 100), vp.getViewPosition());
+        JViewport.cn1ScrollRectToVisible(view, new Rectangle(0, 0, 10, 10));
+        assertEquals(new Point(0, 0), vp.getViewPosition());
+        JViewport.cn1ScrollRectToVisible(view, new Rectangle(extent.width + 5, 2000, 10, 10));
+        assertEquals(new Point(15, 2010 - extent.height), vp.getViewPosition());
+    }
+
+    @Test
+    public void aPolicyOfNeverSwitchesTheAxisOff() {
+        JViewport vp = shown(2000, 3000);
+        com.codename1.ui.Component peer = vp.cn1Peer();
+        assertTrue(peer.isScrollableX());
+        assertTrue(peer.isScrollableY());
+        pane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+        assertFalse(peer.isScrollableX());
+        assertTrue(peer.isScrollableY());
+        assertEquals(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER, pane.getHorizontalScrollBarPolicy());
+        assertEquals(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, pane.getVerticalScrollBarPolicy());
+    }
+
+    @Test
+    public void headersTakeTheirPreferredStripAndFollowTheView() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        view = new JPanel();
+        view.setPreferredSize(new Dimension(2000, 3000));
+        pane = new JScrollPane(view);
+        JPanel column = new JPanel();
+        column.setPreferredSize(new Dimension(2000, 20));
+        JPanel row = new JPanel();
+        row.setPreferredSize(new Dimension(30, 3000));
+        pane.setColumnHeaderView(column);
+        pane.setRowHeaderView(row);
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        JViewport vp = pane.getViewport();
+        assertEquals(20, pane.getColumnHeader().getHeight());
+        assertEquals(30, pane.getRowHeader().getWidth());
+        assertEquals(30, vp.getX());
+        assertEquals(20, vp.getY());
+        assertEquals(pane.getWidth() - 30, vp.getWidth());
+        assertEquals(pane.getHeight() - 20, vp.getHeight());
+        vp.setViewPosition(new Point(50, 80));
+        assertEquals(new Point(50, 0), pane.getColumnHeader().getViewPosition());
+        assertEquals(new Point(0, 80), pane.getRowHeader().getViewPosition());
+    }
+
+    @Test
+    public void aTextAreaTracksTheWidthOfItsViewport() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JTextArea area = new JTextArea("x", 5, 20);
+        pane = new JScrollPane(area);
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        assertEquals(pane.getViewport().getExtentSize().width, area.getWidth());
+    }
+
+    @Test
+    public void theViewCanBeReplaced() {
+        JViewport vp = shown(2000, 3000);
+        vp.setViewPosition(new Point(0, 100));
+        JLabel other = new JLabel("other");
+        pane.setViewportView(other);
+        assertSame(other, vp.getView());
+        assertEquals(1, vp.getComponentCount());
+        assertEquals(null, view.getParent());
+    }
+
+    @Test
+    public void theRangeModelClampsLikeTheDesktopOne() {
+        BoundedRangeModel ours = new DefaultBoundedRangeModel(5, 10, 0, 100);
+        javax.swing.BoundedRangeModel real = new javax.swing.DefaultBoundedRangeModel(5, 10, 0, 100);
+        int[][] steps = {{95, 10, 0, 100}, {50, 80, 0, 100}, {-5, 10, 0, 100}, {20, 10, 30, 25}, {7, -1, 0, 5}};
+        for (int[] s : steps) {
+            ours.setRangeProperties(s[0], s[1], s[2], s[3], false);
+            real.setRangeProperties(s[0], s[1], s[2], s[3], false);
+            assertEquals(real.getValue(), ours.getValue());
+            assertEquals(real.getExtent(), ours.getExtent());
+            assertEquals(real.getMinimum(), ours.getMinimum());
+            assertEquals(real.getMaximum(), ours.getMaximum());
+        }
+        ours.setValue(1000);
+        real.setValue(1000);
+        assertEquals(real.getValue(), ours.getValue());
+        ours.setExtent(1000);
+        real.setExtent(1000);
+        assertEquals(real.getExtent(), ours.getExtent());
+        ours.setMinimum(500);
+        real.setMinimum(500);
+        assertEquals(real.getValue(), ours.getValue());
+        assertEquals(real.getMaximum(), ours.getMaximum());
+    }
+
+    @Test
+    public void aScrollBarStepsByItsIncrements() {
+        JScrollBar bar = new JScrollBar(JScrollBar.VERTICAL, 0, 10, 0, 100);
+        javax.swing.JScrollBar real = new javax.swing.JScrollBar(javax.swing.JScrollBar.VERTICAL, 0, 10, 0, 100);
+        assertEquals(real.getUnitIncrement(), bar.getUnitIncrement());
+        assertEquals(real.getBlockIncrement(), bar.getBlockIncrement());
+        bar.setValue(95);
+        real.setValue(95);
+        assertEquals(real.getValue(), bar.getValue());
+        assertEquals(real.getOrientation(), bar.getOrientation());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/SmallDisplayTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/SmallDisplayTest.java
new file mode 100644
index 00000000000..6c538e21d0a
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/SmallDisplayTest.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.JToolBar;
+import com.codename1.desktopcompat.rt.RootPan;
+import com.codename1.desktopcompat.rt.Units;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/// A window on a display that is smaller than a desktop: content that can
+/// shrink gets the size of the display, content that cannot is panned
+/// instead of cut off, and a tool bar goes on in a further row.
+///
+/// The test display is 1080 by 1920 device pixels at a scale of two, so
+/// 540 by 960 logical pixels.
+public class SmallDisplayTest extends KernelTestBase {
+
+    private static RootPan pan(JFrame f) {
+        com.codename1.ui.Component p = f.cn1Peer().getParent();
+        assertTrue(p instanceof RootPan);
+        return (RootPan) p;
+    }
+
+    /// A text area in a scroll pane can be any size: the window is as
+    /// wide as the display and nothing pans.
+    @Test
+    public void contentThatCanShrinkGetsTheSizeOfTheDisplay() {
+        JFrame f = new JFrame();
+        JTextArea area = new JTextArea(40, 200);
+        f.getContentPane().add(new JScrollPane(area), BorderLayout.CENTER);
+        f.setSize(1280, 800);
+        show(f);
+        RootPan pan = pan(f);
+        assertEquals(Units.toLogical(pan.getWidth()), f.getWidth());
+        assertEquals(Units.toLogical(pan.getHeight()), f.getHeight());
+        assertTrue(f.getWidth() <= 540);
+        assertFalse(pan.isScrollableX());
+        assertFalse(pan.isScrollableY());
+    }
+
+    /// Content with a minimum width beyond the display keeps that width
+    /// and the root pans across it; its height still follows the display.
+    /// A press at the far end, after panning there, reaches the component
+    /// that is there.
+    @Test
+    public void contentThatCannotShrinkIsPannedNotCutOff() {
+        JFrame f = new JFrame();
+        JPanel fixed = new JPanel(new BorderLayout());
+        fixed.setMinimumSize(new Dimension(900, 100));
+        final int[] presses = {0};
+        JButton far = new JButton("far");
+        far.addMouseListener(new com.codename1.desktopcompat.java.awt.event.MouseAdapter() {
+            @Override
+            public void mousePressed(com.codename1.desktopcompat.java.awt.event.MouseEvent e) {
+                presses[0]++;
+            }
+        });
+        fixed.add(far, BorderLayout.EAST);
+        f.getContentPane().add(fixed, BorderLayout.CENTER);
+        show(f);
+        RootPan pan = pan(f);
+        assertEquals(900, f.getWidth());
+        assertEquals(900, fixed.getWidth());
+        assertEquals(Units.toLogical(pan.getHeight()), f.getHeight());
+        assertTrue(pan.isScrollableX());
+        assertFalse(pan.isScrollableY());
+        assertEquals(Units.toDevice(900), pan.getScrollDimension().getWidth());
+        assertEquals(900, far.getX() + far.getWidth());
+
+        // Panned to the end, the button is under the right edge of the display.
+        int right = pan.getAbsoluteX() + pan.getWidth();
+        pan.panTo(Units.toDevice(900) - pan.getWidth(), 0);
+        int[] at = onDisplay(far, far.getWidth() - 2, 5);
+        assertTrue(at[0] < right);
+        assertTrue(at[0] > right - Units.toDevice(8));
+        press(f, far, far.getWidth() - 2, 5);
+        release(f, far, far.getWidth() - 2, 5);
+        assertEquals(1, presses[0]);
+
+        // Once the content can shrink again the window is the display's size.
+        fixed.setMinimumSize(new Dimension(10, 10));
+        fixed.revalidate();
+        MainThreadRule.drain();
+        assertEquals(Units.toLogical(pan.getWidth()), f.getWidth());
+        assertFalse(pan.isScrollableX());
+        assertEquals(0, pan.getScrollX());
+    }
+
+    /// A tool bar with more buttons than fit side by side does not hold
+    /// the window wide: it goes on in a second row, takes the height of
+    /// both, and every button is inside the window.
+    @Test
+    public void aToolBarGoesOnInAFurtherRow() {
+        JFrame f = new JFrame();
+        JToolBar bar = new JToolBar();
+        JButton[] buttons = new JButton[12];
+        for (int i = 0; i < buttons.length; i++) {
+            buttons[i] = new JButton("Button " + i);
+            bar.add(buttons[i]);
+        }
+        int one = buttons[0].getPreferredSize().height;
+        int wanted = bar.getPreferredSize().width;
+        assertTrue("the test needs a bar wider than the display", wanted > 540);
+        assertTrue(bar.getMinimumSize().width < 200);
+        f.getContentPane().add(bar, BorderLayout.NORTH);
+        f.getContentPane().add(new JScrollPane(new JTextArea()), BorderLayout.CENTER);
+        show(f);
+        // The bar learns its width in the first pass and asks for a second.
+        MainThreadRule.drain();
+        f.cn1Form().revalidate();
+        assertFalse(pan(f).isScrollableX());
+        assertEquals(f.getWidth(), bar.getWidth());
+        assertTrue(bar.getHeight() >= 2 * one);
+        assertEquals(bar.getPreferredSize().height, bar.getHeight());
+        // The width it would like in one row is still what it prefers.
+        assertEquals(wanted, bar.getPreferredSize().width);
+        int rows = 1;
+        for (int i = 0; i < buttons.length; i++) {
+            JButton b = buttons[i];
+            assertTrue(b.getX() >= 0 && b.getX() + b.getWidth() <= bar.getWidth());
+            assertTrue(b.getY() >= 0 && b.getY() + b.getHeight() <= bar.getHeight());
+            assertEquals(b.getPreferredSize().width, b.getWidth());
+            if (i > 0 && b.getY() > buttons[i - 1].getY()) {
+                rows++;
+                assertEquals(bar.getInsets().left, b.getX());
+            } else if (i > 0) {
+                assertEquals(buttons[i - 1].getX() + buttons[i - 1].getWidth(), b.getX());
+            }
+        }
+        assertTrue(rows >= 2);
+
+        // With room for all of it the bar is one row again.
+        JToolBar few = new JToolBar();
+        JButton a = new JButton("A");
+        JButton b = new JButton("B");
+        few.add(a);
+        few.add(b);
+        JFrame g = new JFrame();
+        g.getContentPane().add(few, BorderLayout.NORTH);
+        show(g);
+        MainThreadRule.drain();
+        g.cn1Form().revalidate();
+        assertEquals(a.getY(), b.getY());
+        assertEquals(few.getPreferredSize().height, few.getHeight());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/SwingInteropTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/SwingInteropTest.java
new file mode 100644
index 00000000000..b29322392ae
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/SwingInteropTest.java
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JMenu;
+import com.codename1.desktopcompat.javax.swing.JMenuBar;
+import com.codename1.desktopcompat.javax.swing.JMenuItem;
+import com.codename1.desktopcompat.javax.swing.JOptionPane;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.desktopcompat.javax.swing.WindowConstants;
+import com.codename1.desktopcompat.rt.DialogForm;
+import com.codename1.desktopcompat.rt.FrameForm;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import com.codename1.ui.Command;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import com.codename1.ui.Toolbar;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Swing inside a Codename One application that has a main class of its
+/// own (library mode): a component tree embedded in a form of the
+/// application, windows shown over its forms and closed back to them, and
+/// the menu bar of a frame reachable from the form's toolbar. No lifecycle
+/// of the layer runs in any of these, and none installs an exit hook: the
+/// application must survive every one of them.
+public class SwingInteropTest extends WindowsTestBase {
+
+    private static final class Clicks implements ActionListener {
+        int count;
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            count++;
+        }
+    }
+
+    private static Form home(String title) {
+        Form f = new Form(title, new com.codename1.ui.layouts.BorderLayout());
+        f.show();
+        return f;
+    }
+
+    private static List<Object[]> paint(Form f) {
+        HeadlessImplementation.drawnText.clear();
+        HeadlessImplementation.recordText = true;
+        try {
+            Image target = Image.createImage(HeadlessImplementation.WIDTH, HeadlessImplementation.HEIGHT);
+            f.paintComponent(target.getGraphics());
+            return new ArrayList<Object[]>(HeadlessImplementation.drawnText);
+        } finally {
+            HeadlessImplementation.recordText = false;
+            HeadlessImplementation.drawnText.clear();
+        }
+    }
+
+    private static void click(Form f, com.codename1.desktopcompat.java.awt.Component c, int x, int y) {
+        int[] p = at(c, x, y);
+        f.pointerPressed(p[0], p[1]);
+        f.pointerReleased(p[0], p[1]);
+    }
+
+    @Test
+    public void aSwingTreeIsAComponentOfACodenameOneForm() {
+        JPanel panel = new JPanel(new BorderLayout());
+        JLabel label = new JLabel("Embedded label");
+        JButton button = new JButton("Press");
+        Clicks clicks = new Clicks();
+        button.addActionListener(clicks);
+        panel.add(label, BorderLayout.NORTH);
+        panel.add(button, BorderLayout.CENTER);
+
+        com.codename1.ui.Component hosted = SwingInterop.asComponent(panel);
+        Dimension wanted = panel.getPreferredSize();
+        assertEquals("the preferred size is the tree's, in device pixels", Units.toDevice(wanted.width),
+                hosted.getPreferredW());
+        assertEquals(Units.toDevice(wanted.height), hosted.getPreferredH());
+
+        Form form = home("Host");
+        form.add(com.codename1.ui.layouts.BorderLayout.CENTER, hosted);
+        form.revalidate();
+        assertSame(form, Display.getInstance().getCurrent());
+        assertTrue(hosted.getWidth() > 0 && hosted.getHeight() > 0);
+        assertEquals("laid out to the size Codename One gave the component", Units.toLogical(hosted.getWidth()),
+                panel.getWidth());
+        assertEquals(Units.toLogical(hosted.getHeight()), panel.getHeight());
+        assertTrue(button.getWidth() > 0 && button.getHeight() > 0);
+        assertTrue(panel.isShowing());
+
+        List<Object[]> text = paint(form);
+        assertNotNull("the tree paints with the form", find(text, "Embedded label"));
+        assertNotNull(find(text, "Press"));
+
+        click(form, button, 5, 5);
+        assertEquals("pointer input on the form reaches the tree", 1, clicks.count);
+
+        // The tree has a window to answer for it, which is not one of the
+        // application's windows and cannot be closed from inside.
+        Window w = SwingUtilities.getWindowAncestor(button);
+        assertNotNull(w);
+        assertTrue(w.cn1Embedded());
+        assertSame(form, w.cn1HostForm());
+        assertEquals(0, Window.getWindows().length);
+        assertEquals(0, WindowHosts.showing().length);
+        assertTrue(w.isActive());
+        w.dispose();
+        w.setVisible(false);
+        assertTrue(panel.isShowing());
+        click(form, button, 5, 5);
+        assertEquals(2, clicks.count);
+
+        // Off the screen it takes no more input, and takes it again later.
+        Form other = home("Other");
+        assertFalse(w.isActive());
+        form.show();
+        click(form, button, 5, 5);
+        assertEquals(3, clicks.count);
+        assertSame(other, other.getComponentForm());
+    }
+
+    @Test
+    public void onlyAComponentThatIsNotAWindowIsEmbedded() {
+        try {
+            SwingInterop.asComponent(new JFrame("no"));
+            fail("a window is shown, not embedded");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("setVisible(true)"));
+        }
+        try {
+            SwingInterop.asComponent("text");
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("java.lang.String"));
+        }
+        try {
+            SwingInterop.asComponent(null);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage(), expected.getMessage().contains("null"));
+        }
+    }
+
+    @Test
+    public void aMenuBarInAnEmbeddedTreeIsDrawnAndItsMenusOpen() {
+        JPanel panel = new JPanel(new BorderLayout());
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        JMenuItem open = new JMenuItem("Open");
+        Clicks clicks = new Clicks();
+        open.addActionListener(clicks);
+        file.add(open);
+        bar.add(file);
+        panel.add(bar, BorderLayout.NORTH);
+        panel.add(new JLabel("body"), BorderLayout.CENTER);
+        Form form = home("Host");
+        form.add(com.codename1.ui.layouts.BorderLayout.CENTER, SwingInterop.asComponent(panel));
+        form.revalidate();
+
+        assertFalse(bar.cn1Bridged());
+        assertTrue(bar.getHeight() > 0);
+        assertNotNull(find(paint(form), "File"));
+        click(form, file, 3, 3);
+        assertTrue(file.isPopupMenuVisible());
+        click(form, open, 3, 3);
+        assertEquals(1, clicks.count);
+        assertFalse(file.isPopupMenuVisible());
+    }
+
+    @Test
+    public void aFrameShownFromACodenameOneFormClosesBackToIt() {
+        Form home = home("Home");
+        JFrame f = new JFrame("Swing screen");
+        f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        f.add(new JLabel("content"));
+        f.setVisible(true);
+        FrameForm shown = f.cn1Form();
+        assertSame(shown, Display.getInstance().getCurrent());
+        Command back = shown.getBackCommand();
+        assertNotNull("a frame shown over a form of the application has a way back", back);
+
+        back.actionPerformed(new com.codename1.ui.events.ActionEvent(back));
+        MainThreadRule.drain();
+        assertSame("closing the last Swing window shows the form it was shown over", home,
+                Display.getInstance().getCurrent());
+        assertEquals(0, Window.getWindows().length);
+        assertFalse(f.isDisplayable());
+    }
+
+    @Test
+    public void exitOnCloseClosesTheSwingWindowsAndLeavesTheApplicationRunning() {
+        Form home = home("Home");
+        JFrame first = new JFrame("first");
+        first.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        first.setVisible(true);
+        JFrame second = new JFrame("second");
+        second.setDefaultCloseOperation(WindowConstants.HIDE_ON_CLOSE);
+        second.setVisible(true);
+        assertSame(second.cn1Form(), Display.getInstance().getCurrent());
+        second.cn1Closing();
+        assertSame(first.cn1Form(), Display.getInstance().getCurrent());
+        second.setVisible(true);
+
+        // No lifecycle of the layer runs, so no exit hook is installed.
+        first.cn1Closing();
+        MainThreadRule.drain();
+        assertSame(home, Display.getInstance().getCurrent());
+        assertEquals(0, Window.getWindows().length);
+        assertEquals(0, WindowHosts.showing().length);
+        assertFalse(first.isVisible());
+        assertFalse(second.isVisible());
+        assertTrue("the display is still up", Display.isInitialized());
+    }
+
+    @Test
+    public void aLabelEndsInAnEllipsisWhateverTheThemeSays() {
+        com.codename1.ui.plaf.LookAndFeel laf = com.codename1.ui.plaf.UIManager.getInstance().getLookAndFeel();
+        boolean before = laf.isDefaultEndsWith3Points();
+        laf.setDefaultEndsWith3Points(false);
+        try {
+            com.codename1.ui.Component peer = new JLabel("Text with no room").cn1Peer();
+            assertTrue(peer instanceof com.codename1.ui.Label);
+            assertTrue(((com.codename1.ui.Label) peer).isEndsWith3Points());
+        } finally {
+            laf.setDefaultEndsWith3Points(before);
+        }
+    }
+
+    @Test
+    public void aModalDialogFloatsOverTheFormOfTheApplicationAndReturnsToIt() {
+        final Form home = home("Home");
+        final JPanel panel = new JPanel(new BorderLayout());
+        panel.add(new JLabel("asks"));
+        home.add(com.codename1.ui.layouts.BorderLayout.CENTER, SwingInterop.asComponent(panel));
+        home.revalidate();
+        final boolean[] floated = new boolean[1];
+        final boolean[] ownWindow = new boolean[1];
+        // A timer, not callSerially: showing a dialog first runs what is
+        // waiting on the event dispatch thread, before the dialog is up.
+        Display.getInstance().setTimeout(150, new Runnable() {
+            @Override
+            public void run() {
+                Window top = WindowHosts.active();
+                JOptionPane pane = top == null ? null : find(top);
+                if (pane == null) {
+                    Display.getInstance().setTimeout(50, this);
+                    return;
+                }
+                Form current = Display.getInstance().getCurrent();
+                floated[0] = current instanceof DialogForm;
+                ownWindow[0] = current instanceof DialogForm && ((DialogForm) current).isNativeWindowMode();
+                pane.setValue(Integer.valueOf(JOptionPane.YES_OPTION));
+            }
+        });
+        // A theme may ask for every Codename One dialog to open in a
+        // window of its own, as the Windows native theme does. A dialog
+        // the layer keeps in the application's form is not one of them.
+        boolean before = com.codename1.ui.Dialog.isDefaultNativeWindowMode();
+        com.codename1.ui.Dialog.setDefaultNativeWindowMode(true);
+        int answer;
+        try {
+            answer = JOptionPane.showConfirmDialog(panel, "Proceed?", "Confirm", JOptionPane.YES_NO_OPTION);
+        } finally {
+            com.codename1.ui.Dialog.setDefaultNativeWindowMode(before);
+        }
+        assertTrue("the dialog floated over the application's form", floated[0]);
+        assertFalse("the dialog asked for a window of its own", ownWindow[0]);
+        assertEquals(JOptionPane.YES_OPTION, answer);
+        MainThreadRule.drain();
+        assertSame(home, Display.getInstance().getCurrent());
+        assertEquals(0, WindowHosts.showing().length);
+    }
+
+    private static com.codename1.ui.Component named(com.codename1.ui.Container root, String name) {
+        for (int i = 0; i < root.getComponentCount(); i++) {
+            com.codename1.ui.Component c = root.getComponentAt(i);
+            if (name.equals(c.getName())) {
+                return c;
+            }
+            if (c instanceof com.codename1.ui.Container) {
+                com.codename1.ui.Component found = named((com.codename1.ui.Container) c, name);
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static JOptionPane find(com.codename1.desktopcompat.java.awt.Component c) {
+        if (c instanceof JOptionPane) {
+            return (JOptionPane) c;
+        }
+        if (c instanceof com.codename1.desktopcompat.java.awt.Container) {
+            com.codename1.desktopcompat.java.awt.Container k = (com.codename1.desktopcompat.java.awt.Container) c;
+            for (int i = 0; i < k.getComponentCount(); i++) {
+                JOptionPane found = find(k.getComponent(i));
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    /// The menus of a frame are reachable on a host without a menu bar of
+    /// its own: every item is a command in the overflow menu of the form's
+    /// toolbar, and choosing the command there fires the item's listeners.
+    @Test
+    public void theMenuBarOfAFrameIsInTheOverflowMenuOfItsFormsToolbar() {
+        JFrame f = new JFrame("menus");
+        JMenuBar bar = new JMenuBar();
+        JMenu file = new JMenu("File");
+        JMenu help = new JMenu("Help");
+        JMenuItem open = new JMenuItem("Open");
+        JMenuItem about = new JMenuItem("About");
+        Clicks opened = new Clicks();
+        Clicks abouts = new Clicks();
+        open.addActionListener(opened);
+        about.addActionListener(abouts);
+        file.add(open);
+        help.add(about);
+        bar.add(file);
+        bar.add(help);
+        f.setJMenuBar(bar);
+        show(f);
+
+        FrameForm form = f.cn1Form();
+        Toolbar tb = form.getToolbar();
+        assertNotNull("the form of a frame with a menu bar has a toolbar", tb);
+        List<Command> overflow = new ArrayList<Command>();
+        Iterable<Command> listed = tb.getOverflowCommands();
+        assertNotNull(listed);
+        for (Command c : listed) {
+            overflow.add(c);
+        }
+        assertEquals(2, overflow.size());
+        assertEquals("Open", overflow.get(0).getCommandName());
+        assertEquals("About", overflow.get(1).getCommandName());
+        assertEquals("File", overflow.get(0).getDesktopMenu());
+        assertEquals("Help", overflow.get(1).getDesktopMenu());
+        // Looked up in the form, not through Toolbar.getOverflowButton():
+        // the toolbar makes a button per command added and shows the first.
+        com.codename1.ui.Component button = named(form, "OverflowButton");
+        assertNotNull("the button that opens the overflow menu is on the toolbar", button);
+        assertSame(form, button.getComponentForm());
+        assertTrue(button.isVisible());
+
+        // As the overflow menu does when its entry is chosen.
+        form.dispatchCommand(overflow.get(0), new com.codename1.ui.events.ActionEvent(overflow.get(0)));
+        assertEquals(1, opened.count);
+        assertEquals(0, abouts.count);
+        form.dispatchCommand(overflow.get(1), new com.codename1.ui.events.ActionEvent(overflow.get(1)));
+        assertEquals(1, abouts.count);
+
+        // A menu added later is there too, and a removed bar leaves nothing.
+        JMenu view = new JMenu("View");
+        view.add(new JMenuItem("Zoom"));
+        bar.add(view);
+        int n = 0;
+        for (Command c : tb.getOverflowCommands()) {
+            n++;
+            assertNotNull(c);
+        }
+        assertEquals(3, n);
+        f.setJMenuBar(null);
+        n = 0;
+        for (Command c : tb.getOverflowCommands()) {
+            n++;
+            assertNull(c);
+        }
+        assertEquals(0, n);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/TextSyncTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/TextSyncTest.java
new file mode 100644
index 00000000000..b4d1ba0a9f9
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/TextSyncTest.java
@@ -0,0 +1,445 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPasswordField;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.event.CaretEvent;
+import com.codename1.desktopcompat.javax.swing.event.CaretListener;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.text.AbstractDocument;
+import com.codename1.desktopcompat.javax.swing.text.AttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.DocumentFilter;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.javax.swing.text.Position;
+import com.codename1.ui.Display;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The document of a text component and the Codename One widget behind it
+/// stay the same in both directions, the filter sees native typing, and
+/// the caret follows the text.
+public class TextSyncTest extends KernelTestBase {
+
+    /// Records document events as short strings naming kind, offset and length.
+    private static final class Log implements DocumentListener {
+        final List<String> events = new ArrayList<String>();
+
+        @Override
+        public void insertUpdate(DocumentEvent e) {
+            events.add("insert@" + e.getOffset() + "+" + e.getLength());
+        }
+
+        @Override
+        public void removeUpdate(DocumentEvent e) {
+            events.add("remove@" + e.getOffset() + "+" + e.getLength());
+        }
+
+        @Override
+        public void changedUpdate(DocumentEvent e) {
+            events.add("change");
+        }
+    }
+
+    private JTextField field(String text) {
+        JFrame f = new JFrame();
+        f.setLayout(new FlowLayout());
+        JTextField t = new JTextField(text, 10);
+        f.add(t);
+        show(f);
+        return t;
+    }
+
+    private static com.codename1.ui.TextArea peer(com.codename1.desktopcompat.java.awt.Component c) {
+        return (com.codename1.ui.TextArea) c.cn1Peer();
+    }
+
+    @Test
+    public void documentChangesReachTheWidget() throws Exception {
+        JTextField t = field("abc");
+        assertEquals("abc", peer(t).getText());
+        t.setText("hello");
+        assertEquals("hello", peer(t).getText());
+        t.getDocument().insertString(5, "!", null);
+        assertEquals("hello!", peer(t).getText());
+        t.getDocument().remove(0, 1);
+        assertEquals("ello!", peer(t).getText());
+    }
+
+    @Test
+    public void setTextFiresOneRemoveAndOneInsert() {
+        JTextField t = field("abc");
+        Log log = new Log();
+        t.getDocument().addDocumentListener(log);
+        t.setText("xy");
+        assertEquals("[remove@0+3, insert@0+2]", log.events.toString());
+        assertEquals("xy", peer(t).getText());
+    }
+
+    @Test
+    public void nativeTypingBecomesAnInsertAtItsOffset() {
+        JTextField t = field("abc");
+        Log log = new Log();
+        t.getDocument().addDocumentListener(log);
+        peer(t).setText("abXYc");
+        assertEquals("abXYc", t.getText());
+        assertEquals("[insert@2+2]", log.events.toString());
+        assertEquals(4, t.getCaretPosition());
+    }
+
+    @Test
+    public void nativeDeletionBecomesARemove() {
+        JTextField t = field("abcdef");
+        Log log = new Log();
+        t.getDocument().addDocumentListener(log);
+        peer(t).setText("abef");
+        assertEquals("abef", t.getText());
+        assertEquals("[remove@2+2]", log.events.toString());
+        assertEquals(2, t.getCaretPosition());
+    }
+
+    @Test
+    public void nativeReplacementIsARemoveAndAnInsert() {
+        JTextField t = field("one two");
+        Log log = new Log();
+        t.getDocument().addDocumentListener(log);
+        peer(t).setText("one 2");
+        assertEquals("[remove@4+3, insert@4+1]", log.events.toString());
+        assertEquals("one 2", t.getText());
+    }
+
+    /// Lets only digits into the document.
+    private static final class Digits extends DocumentFilter {
+        private static boolean ok(String s) {
+            for (int i = 0; s != null && i < s.length(); i++) {
+                if (s.charAt(i) < '0' || s.charAt(i) > '9') {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override
+        public void insertString(FilterBypass fb, int offset, String string, AttributeSet attr)
+                throws BadLocationException {
+            if (ok(string)) {
+                super.insertString(fb, offset, string, attr);
+            }
+        }
+
+        @Override
+        public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attrs)
+                throws BadLocationException {
+            if (ok(text)) {
+                super.replace(fb, offset, length, text, attrs);
+            }
+        }
+    }
+
+    @Test
+    public void aFilterVetoTakesTheTypingBackOutOfTheWidget() {
+        JTextField t = field("12");
+        ((AbstractDocument) t.getDocument()).setDocumentFilter(new Digits());
+        Log log = new Log();
+        t.getDocument().addDocumentListener(log);
+        peer(t).setText("12a");
+        assertEquals("12", t.getText());
+        assertEquals("12", peer(t).getText());
+        assertTrue(log.events.isEmpty());
+        peer(t).setText("123");
+        assertEquals("123", t.getText());
+        assertEquals("[insert@2+1]", log.events.toString());
+        t.setText("abc");
+        assertEquals("123", t.getText());
+    }
+
+    @Test
+    public void aFilterThatTransformsRewritesTheWidget() {
+        JTextField t = field("");
+        ((AbstractDocument) t.getDocument()).setDocumentFilter(new DocumentFilter() {
+            @Override
+            public void replace(FilterBypass fb, int offset, int length, String text, AttributeSet attrs)
+                    throws BadLocationException {
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; text != null && i < text.length(); i++) {
+                    char c = text.charAt(i);
+                    sb.append(c >= 'a' && c <= 'z' ? (char) (c - 32) : c);
+                }
+                fb.replace(offset, length, sb.toString(), attrs);
+            }
+
+            @Override
+            public void insertString(FilterBypass fb, int offset, String text, AttributeSet attrs)
+                    throws BadLocationException {
+                replace(fb, offset, 0, text, attrs);
+            }
+        });
+        peer(t).setText("ab");
+        assertEquals("AB", t.getText());
+        assertEquals("AB", peer(t).getText());
+        peer(t).setText("ABc");
+        assertEquals("ABC", peer(t).getText());
+    }
+
+    @Test
+    public void aListenerSeesEachChangeOnce() {
+        JTextField t = field("");
+        Log log = new Log();
+        t.getDocument().addDocumentListener(log);
+        t.setText("a");
+        peer(t).setText("ab");
+        t.replaceSelection("c");
+        assertEquals("[insert@0+1, insert@1+1, insert@2+1]", log.events.toString());
+        assertEquals("abc", peer(t).getText());
+    }
+
+    @Test
+    public void lineBreaksBecomeSpacesInAField() {
+        JTextField t = field("");
+        t.setText("a\nb");
+        assertEquals("a b", t.getText());
+    }
+
+    @Test
+    public void caretAndSelection() {
+        JTextField t = field("");
+        final List<String> carets = new ArrayList<String>();
+        t.addCaretListener(new CaretListener() {
+            @Override
+            public void caretUpdate(CaretEvent e) {
+                carets.add(e.getDot() + "/" + e.getMark());
+            }
+        });
+        t.setText("hello");
+        assertEquals(5, t.getCaretPosition());
+        assertNull(t.getSelectedText());
+        t.select(1, 3);
+        assertEquals("el", t.getSelectedText());
+        assertEquals(1, t.getSelectionStart());
+        assertEquals(3, t.getSelectionEnd());
+        assertEquals(3, t.getCaret().getDot());
+        assertEquals(1, t.getCaret().getMark());
+        t.replaceSelection("XY");
+        assertEquals("hXYlo", t.getText());
+        assertEquals(3, t.getCaretPosition());
+        assertNull(t.getSelectedText());
+        t.selectAll();
+        assertEquals("hXYlo", t.getSelectedText());
+        t.setCaretPosition(0);
+        t.moveCaretPosition(2);
+        assertEquals("hX", t.getSelectedText());
+        assertTrue(carets.contains("5/5"));
+        assertTrue(carets.contains("3/1"));
+        try {
+            t.setCaretPosition(99);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(2, t.getCaretPosition());
+        }
+        t.select(-5, 99);
+        assertEquals("hXYlo", t.getSelectedText());
+    }
+
+    @Test
+    public void theCaretFollowsTheText() throws Exception {
+        JTextField t = field("abcdef");
+        t.setCaretPosition(3);
+        t.getDocument().insertString(0, "xx", null);
+        assertEquals(5, t.getCaretPosition());
+        t.getDocument().insertString(8, "yy", null);
+        assertEquals(5, t.getCaretPosition());
+        t.getDocument().remove(0, 4);
+        assertEquals(1, t.getCaretPosition());
+        t.getDocument().remove(0, 3);
+        assertEquals(0, t.getCaretPosition());
+    }
+
+    @Test
+    public void cutCopyAndPasteUseTheClipboard() {
+        JTextField t = field("hello world");
+        t.select(0, 5);
+        t.copy();
+        assertEquals("hello", Display.getInstance().getPasteDataFromClipboard());
+        t.select(5, 11);
+        t.cut();
+        assertEquals("hello", t.getText());
+        assertEquals(" world", Display.getInstance().getPasteDataFromClipboard());
+        t.setCaretPosition(0);
+        t.paste();
+        assertEquals(" worldhello", t.getText());
+        t.setEditable(false);
+        t.selectAll();
+        t.cut();
+        t.paste();
+        t.replaceSelection("x");
+        assertEquals(" worldhello", t.getText());
+        assertTrue(!peer(t).isEditable());
+    }
+
+    @Test
+    public void theActionListenersHearTheCommand() {
+        JTextField t = field("go");
+        final List<String> commands = new ArrayList<String>();
+        t.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                commands.add(e.getActionCommand());
+            }
+        });
+        t.postActionEvent();
+        t.setActionCommand("search");
+        t.postActionEvent();
+        assertEquals("[go, search]", commands.toString());
+    }
+
+    @Test
+    public void alignmentAndColumnsReachTheWidget() {
+        JTextField t = field("x");
+        assertEquals(10, peer(t).getColumns());
+        t.setColumns(20);
+        assertEquals(20, peer(t).getColumns());
+        t.setHorizontalAlignment(JTextField.RIGHT);
+        assertEquals(com.codename1.ui.Component.RIGHT, peer(t).getAlignment());
+    }
+
+    @Test
+    public void passwordField() {
+        JFrame f = new JFrame();
+        JPasswordField p = new JPasswordField("secret", 8);
+        f.add(p);
+        show(f);
+        assertArrayEquals("secret".toCharArray(), p.getPassword());
+        assertEquals(com.codename1.ui.TextArea.PASSWORD, peer(p).getConstraint() & com.codename1.ui.TextArea.PASSWORD);
+        assertTrue(p.echoCharIsSet());
+        p.setEchoChar((char) 0);
+        assertEquals(0, peer(p).getConstraint() & com.codename1.ui.TextArea.PASSWORD);
+        Display.getInstance().copyToClipboard("kept");
+        p.selectAll();
+        p.copy();
+        assertEquals("kept", Display.getInstance().getPasteDataFromClipboard());
+    }
+
+    @Test
+    public void textAreaMatchesTheDesktopOne() throws Exception {
+        JTextArea ours = new JTextArea("one\ntwo", 3, 20);
+        javax.swing.JTextArea real = new javax.swing.JTextArea("one\ntwo", 3, 20);
+        ours.append("\nthree");
+        real.append("\nthree");
+        ours.insert("zero\n", 0);
+        real.insert("zero\n", 0);
+        ours.replaceRange("TWO", 9, 12);
+        real.replaceRange("TWO", 9, 12);
+        assertEquals(real.getText(), ours.getText());
+        assertEquals(real.getLineCount(), ours.getLineCount());
+        for (int i = 0; i < real.getLineCount(); i++) {
+            assertEquals(real.getLineStartOffset(i), ours.getLineStartOffset(i));
+            assertEquals(real.getLineEndOffset(i), ours.getLineEndOffset(i));
+        }
+        for (int i = 0; i <= real.getDocument().getLength(); i++) {
+            assertEquals(real.getLineOfOffset(i), ours.getLineOfOffset(i));
+        }
+        assertEquals(real.getRows(), ours.getRows());
+        assertEquals(real.getColumns(), ours.getColumns());
+        assertEquals(real.getTabSize(), ours.getTabSize());
+        try {
+            ours.getLineStartOffset(9);
+            fail();
+        } catch (BadLocationException expected) {
+            assertTrue(expected.offsetRequested() > 0);
+        }
+    }
+
+    @Test
+    public void textAreaSyncsWithItsWidget() {
+        JFrame f = new JFrame();
+        JTextArea a = new JTextArea("first", 4, 20);
+        f.add(a);
+        show(f);
+        assertEquals("first", peer(a).getText());
+        a.append("\nsecond");
+        assertEquals("first\nsecond", peer(a).getText());
+        peer(a).setText("first\nsecond\nthird");
+        assertEquals(3, a.getLineCount());
+        assertEquals("first\nsecond\nthird", a.getText());
+    }
+
+    @Test
+    public void positionsMoveWithTheText() throws Exception {
+        PlainDocument d = new PlainDocument();
+        d.insertString(0, "abcdef", null);
+        Position mid = d.createPosition(3);
+        Position end = d.createPosition(6);
+        d.insertString(0, "xx", null);
+        assertEquals(5, mid.getOffset());
+        assertEquals(8, end.getOffset());
+        d.remove(1, 6);
+        assertEquals(1, mid.getOffset());
+        assertEquals(2, end.getOffset());
+        try {
+            d.getText(1, 5);
+            fail();
+        } catch (BadLocationException expected) {
+            assertTrue(expected.offsetRequested() >= 0);
+        }
+        try {
+            d.insertString(9, "x", null);
+            fail();
+        } catch (BadLocationException expected) {
+            assertEquals(9, expected.offsetRequested());
+        }
+    }
+
+    @Test
+    public void theLinesAreTheElementsOfAPlainDocument() throws Exception {
+        PlainDocument ours = new PlainDocument();
+        javax.swing.text.PlainDocument real = new javax.swing.text.PlainDocument();
+        String text = "a\n\nbcd\nlast";
+        ours.insertString(0, text, null);
+        real.insertString(0, text, null);
+        com.codename1.desktopcompat.javax.swing.text.Element or = ours.getDefaultRootElement();
+        javax.swing.text.Element rr = real.getDefaultRootElement();
+        assertEquals(rr.getElementCount(), or.getElementCount());
+        for (int i = 0; i < rr.getElementCount(); i++) {
+            assertEquals(rr.getElement(i).getStartOffset(), or.getElement(i).getStartOffset());
+            assertEquals(rr.getElement(i).getEndOffset(), or.getElement(i).getEndOffset());
+        }
+        for (int i = 0; i <= text.length(); i++) {
+            assertEquals(rr.getElementIndex(i), or.getElementIndex(i));
+            assertEquals(real.getParagraphElement(i).getStartOffset(), ours.getParagraphElement(i).getStartOffset());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ToolkitListenersAndDesktopTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ToolkitListenersAndDesktopTest.java
new file mode 100644
index 00000000000..59d808eff34
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/ToolkitListenersAndDesktopTest.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.java.awt.AWTEvent;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Desktop;
+import com.codename1.desktopcompat.java.awt.Dialog;
+import com.codename1.desktopcompat.java.awt.Taskbar;
+import com.codename1.desktopcompat.java.awt.Toolkit;
+import com.codename1.desktopcompat.java.awt.desktop.PreferencesEvent;
+import com.codename1.desktopcompat.java.awt.desktop.PreferencesHandler;
+import com.codename1.desktopcompat.java.awt.event.AWTEventListener;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPopupMenu;
+import com.codename1.desktopcompat.rt.AwtListeners;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Test;
+
+/// The toolkit's event listeners and shortcut key, and the parts of the
+/// desktop a device does not have, which say so.
+public class ToolkitListenersAndDesktopTest extends WindowsTestBase {
+
+    @After
+    public void forget() {
+        AwtListeners.reset();
+        AwtListeners.setCommandKey(null);
+    }
+
+    @Test
+    public void aToolkitListenerSeesTheEventsOfItsMaskBeforeTheComponent() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        final JButton b = new JButton("go");
+        f.add(b, BorderLayout.CENTER);
+        show(f);
+        final List<Integer> ids = new ArrayList<Integer>();
+        AWTEventListener l = new AWTEventListener() {
+            @Override
+            public void eventDispatched(AWTEvent event) {
+                if (event.getSource() == b) {
+                    ids.add(Integer.valueOf(event.getID()));
+                }
+            }
+        };
+        Toolkit tk = Toolkit.getDefaultToolkit();
+        tk.addAWTEventListener(l, AWTEvent.MOUSE_EVENT_MASK);
+        assertEquals(1, tk.getAWTEventListeners().length);
+        assertEquals(1, tk.getAWTEventListeners(AWTEvent.MOUSE_EVENT_MASK).length);
+        assertEquals(0, tk.getAWTEventListeners(AWTEvent.KEY_EVENT_MASK).length);
+        click(f, b, 5, 5);
+        assertTrue(ids.toString(), ids.contains(Integer.valueOf(MouseEvent.MOUSE_PRESSED)));
+        assertTrue(ids.toString(), ids.contains(Integer.valueOf(MouseEvent.MOUSE_RELEASED)));
+        assertTrue(ids.toString(), ids.contains(Integer.valueOf(MouseEvent.MOUSE_CLICKED)));
+        for (int i = 0; i < ids.size(); i++) {
+            int id = ids.get(i).intValue();
+            assertTrue("only mouse events: " + id, id >= MouseEvent.MOUSE_FIRST && id <= MouseEvent.MOUSE_LAST);
+        }
+        tk.removeAWTEventListener(l);
+        ids.clear();
+        click(f, b, 5, 5);
+        assertTrue(ids.isEmpty());
+        assertEquals(0, tk.getAWTEventListeners().length);
+    }
+
+    @Test
+    public void theMenuShortcutKeyIsCommandOnApplePlatformsAndControlElsewhere() {
+        Toolkit tk = Toolkit.getDefaultToolkit();
+        AwtListeners.setCommandKey(Boolean.TRUE);
+        assertEquals(InputEvent.META_DOWN_MASK, tk.getMenuShortcutKeyMaskEx());
+        assertEquals(InputEvent.META_MASK, tk.getMenuShortcutKeyMask());
+        AwtListeners.setCommandKey(Boolean.FALSE);
+        assertEquals(InputEvent.CTRL_DOWN_MASK, tk.getMenuShortcutKeyMaskEx());
+        assertEquals(InputEvent.CTRL_MASK, tk.getMenuShortcutKeyMask());
+    }
+
+    @Test
+    public void whatADeviceLacksIsReportedUnsupported() {
+        assertFalse(Taskbar.isTaskbarSupported());
+        try {
+            Taskbar.getTaskbar();
+            fail("no taskbar");
+        } catch (UnsupportedOperationException expected) {
+            assertTrue(true);
+        }
+        Desktop d = Desktop.getDesktop();
+        assertFalse(d.isSupported(Desktop.Action.APP_PREFERENCES));
+        assertFalse(d.isSupported(Desktop.Action.MOVE_TO_TRASH));
+        try {
+            d.setPreferencesHandler(new PreferencesHandler() {
+                @Override
+                public void handlePreferences(PreferencesEvent e) {
+                    fail("never called");
+                }
+            });
+            fail("an action that is not supported throws");
+        } catch (UnsupportedOperationException expected) {
+            assertTrue(true);
+        }
+    }
+
+    @Test
+    public void aWindowIsNeverExcludedFromModality() {
+        Toolkit tk = Toolkit.getDefaultToolkit();
+        assertTrue(tk.isModalExclusionTypeSupported(Dialog.ModalExclusionType.NO_EXCLUDE));
+        assertFalse(tk.isModalExclusionTypeSupported(Dialog.ModalExclusionType.APPLICATION_EXCLUDE));
+        JFrame f = new JFrame();
+        f.setModalExclusionType(Dialog.ModalExclusionType.APPLICATION_EXCLUDE);
+        assertSame(Dialog.ModalExclusionType.NO_EXCLUDE, f.getModalExclusionType());
+    }
+
+    @Test
+    public void thePopupWeightIsKeptAsAHint() {
+        boolean was = JPopupMenu.getDefaultLightWeightPopupEnabled();
+        try {
+            JPopupMenu.setDefaultLightWeightPopupEnabled(false);
+            JPopupMenu menu = new JPopupMenu();
+            assertFalse(menu.isLightWeightPopupEnabled());
+            menu.setLightWeightPopupEnabled(true);
+            assertTrue(menu.isLightWeightPopupEnabled());
+        } finally {
+            JPopupMenu.setDefaultLightWeightPopupEnabled(was);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/UndoAndEditorKitTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/UndoAndEditorKitTest.java
new file mode 100644
index 00000000000..7ff3076f64e
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/UndoAndEditorKitTest.java
@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditEvent;
+import com.codename1.desktopcompat.javax.swing.event.UndoableEditListener;
+import com.codename1.desktopcompat.javax.swing.text.DefaultEditorKit;
+import com.codename1.desktopcompat.javax.swing.text.Document;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.javax.swing.text.Segment;
+import com.codename1.desktopcompat.javax.swing.text.TextAction;
+import com.codename1.desktopcompat.javax.swing.undo.AbstractUndoableEdit;
+import com.codename1.desktopcompat.javax.swing.undo.CannotRedoException;
+import com.codename1.desktopcompat.javax.swing.undo.CannotUndoException;
+import com.codename1.desktopcompat.javax.swing.undo.CompoundEdit;
+import com.codename1.desktopcompat.javax.swing.undo.UndoManager;
+import com.codename1.desktopcompat.javax.swing.undo.UndoableEditSupport;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Undo over a document, the editor kit's actions and the pieces of
+/// `javax.swing.undo` an editor is written against.
+public class UndoAndEditorKitTest extends KernelTestBase {
+
+    /// An edit that records what was done to it.
+    private static final class Marked extends AbstractUndoableEdit {
+        private final String name;
+        private final List<String> log;
+
+        Marked(String name, List<String> log) {
+            this.name = name;
+            this.log = log;
+        }
+
+        @Override
+        public void undo() {
+            super.undo();
+            log.add("undo " + name);
+        }
+
+        @Override
+        public void redo() {
+            super.redo();
+            log.add("redo " + name);
+        }
+
+        @Override
+        public String getPresentationName() {
+            return name;
+        }
+    }
+
+    @Test
+    public void aManagerUndoesTheLastEditFirstAndRedoesInOrder() {
+        List<String> log = new ArrayList<String>();
+        UndoManager m = new UndoManager();
+        assertFalse(m.canUndo());
+        assertFalse(m.canRedo());
+        m.addEdit(new Marked("a", log));
+        m.addEdit(new Marked("b", log));
+        assertTrue(m.canUndo());
+        assertEquals("Undo b", m.getUndoPresentationName());
+        m.undo();
+        assertEquals("Redo b", m.getRedoPresentationName());
+        assertEquals("Undo a", m.getUndoPresentationName());
+        m.undo();
+        assertFalse(m.canUndo());
+        m.redo();
+        m.redo();
+        assertFalse(m.canRedo());
+        assertEquals("[undo b, undo a, redo a, redo b]", log.toString());
+    }
+
+    @Test
+    public void undoingWithNothingToUndoThrows() {
+        UndoManager m = new UndoManager();
+        try {
+            m.undo();
+            fail("nothing to undo");
+        } catch (CannotUndoException expected) {
+            assertFalse(m.canUndo());
+        }
+        try {
+            m.redo();
+            fail("nothing to redo");
+        } catch (CannotRedoException expected) {
+            assertFalse(m.canRedo());
+        }
+    }
+
+    @Test
+    public void aNewEditDropsWhatCouldBeRedone() {
+        List<String> log = new ArrayList<String>();
+        UndoManager m = new UndoManager();
+        m.addEdit(new Marked("a", log));
+        m.addEdit(new Marked("b", log));
+        m.undo();
+        m.addEdit(new Marked("c", log));
+        assertFalse(m.canRedo());
+        assertEquals("Undo c", m.getUndoPresentationName());
+    }
+
+    @Test
+    public void theLimitKeepsTheNewestEdits() {
+        List<String> log = new ArrayList<String>();
+        UndoManager m = new UndoManager();
+        m.setLimit(2);
+        m.addEdit(new Marked("a", log));
+        m.addEdit(new Marked("b", log));
+        m.addEdit(new Marked("c", log));
+        m.undo();
+        m.undo();
+        assertFalse(m.canUndo());
+        assertEquals("[undo c, undo b]", log.toString());
+        m.discardAllEdits();
+        assertFalse(m.canRedo());
+    }
+
+    @Test
+    public void aCompoundEditUndoesItsPartsBackwardsOnceEnded() {
+        List<String> log = new ArrayList<String>();
+        CompoundEdit c = new CompoundEdit();
+        c.addEdit(new Marked("a", log));
+        c.addEdit(new Marked("b", log));
+        assertTrue(c.isInProgress());
+        assertFalse(c.canUndo());
+        c.end();
+        assertFalse(c.addEdit(new Marked("late", log)));
+        assertTrue(c.canUndo());
+        c.undo();
+        c.redo();
+        assertEquals("[undo b, undo a, redo a, redo b]", log.toString());
+        assertEquals("b", c.getPresentationName());
+    }
+
+    @Test
+    public void editSupportGroupsAnUpdateIntoOneEdit() {
+        final List<UndoableEditEvent> heard = new ArrayList<UndoableEditEvent>();
+        UndoableEditSupport s = new UndoableEditSupport(this);
+        s.addUndoableEditListener(new UndoableEditListener() {
+            @Override
+            public void undoableEditHappened(UndoableEditEvent e) {
+                heard.add(e);
+            }
+        });
+        List<String> log = new ArrayList<String>();
+        s.postEdit(new Marked("alone", log));
+        assertEquals(1, heard.size());
+        assertSame(this, heard.get(0).getSource());
+        s.beginUpdate();
+        s.postEdit(new Marked("a", log));
+        s.postEdit(new Marked("b", log));
+        assertEquals(1, heard.size());
+        s.endUpdate();
+        assertEquals(2, heard.size());
+        assertTrue(heard.get(1).getEdit() instanceof CompoundEdit);
+    }
+
+    @Test
+    public void aDocumentChangeIsAnEditThatTakesTheTextBack() throws Exception {
+        PlainDocument doc = new PlainDocument();
+        UndoManager m = new UndoManager();
+        doc.addUndoableEditListener(m);
+        doc.insertString(0, "hello", null);
+        doc.insertString(5, " world", null);
+        doc.remove(0, 6);
+        assertEquals("world", doc.getText(0, doc.getLength()));
+        assertEquals("Undo deletion", m.getUndoPresentationName());
+        m.undo();
+        assertEquals("hello world", doc.getText(0, doc.getLength()));
+        assertEquals("Undo addition", m.getUndoPresentationName());
+        m.undo();
+        assertEquals("hello", doc.getText(0, doc.getLength()));
+        m.undo();
+        assertEquals(0, doc.getLength());
+        assertFalse(m.canUndo());
+        m.redo();
+        m.redo();
+        m.redo();
+        assertEquals("world", doc.getText(0, doc.getLength()));
+        assertFalse(m.canRedo());
+    }
+
+    @Test
+    public void undoingPostsNoEditOfItsOwnAndStopsWithTheListener() throws Exception {
+        PlainDocument doc = new PlainDocument();
+        final int[] heard = new int[1];
+        UndoableEditListener count = new UndoableEditListener() {
+            @Override
+            public void undoableEditHappened(UndoableEditEvent e) {
+                heard[0]++;
+            }
+        };
+        UndoManager m = new UndoManager();
+        doc.addUndoableEditListener(m);
+        doc.addUndoableEditListener(count);
+        doc.insertString(0, "abc", null);
+        m.undo();
+        m.redo();
+        assertEquals(1, heard[0]);
+        assertEquals(2, doc.getUndoableEditListeners().length);
+        doc.removeUndoableEditListener(count);
+        doc.insertString(0, "x", null);
+        assertEquals(1, heard[0]);
+    }
+
+    @Test
+    public void typingInATextAreaIsUndoneInTheWidgetToo() throws Exception {
+        JTextArea area = new JTextArea();
+        UndoManager m = new UndoManager();
+        area.getDocument().addUndoableEditListener(m);
+        area.setText("one");
+        area.append(" two");
+        assertEquals("one two", area.getText());
+        m.undo();
+        assertEquals("one", area.getText());
+    }
+
+    @Test
+    public void aSegmentIsFilledWithTheRangeAskedFor() throws Exception {
+        Document doc = new PlainDocument();
+        doc.insertString(0, "0123456789", null);
+        Segment s = new Segment();
+        doc.getText(2, 5, s);
+        assertEquals("23456", s.toString());
+        assertEquals(5, s.length());
+        assertEquals('3', s.charAt(1));
+        assertEquals("34", s.subSequence(1, 3).toString());
+        assertEquals("bc", new Segment("abcd".toCharArray(), 1, 2).toString());
+        assertEquals("", new Segment().toString());
+    }
+
+    private static Action named(Action[] all, String name) {
+        for (Action a : all) {
+            if (name.equals(a.getValue(Action.NAME))) {
+                return a;
+            }
+        }
+        return null;
+    }
+
+    @Test
+    public void aTextComponentAnswersItsEditingActionsByName() {
+        JTextArea area = new JTextArea("some text");
+        Action[] all = area.getActions();
+        assertNotNull(named(all, DefaultEditorKit.cutAction));
+        assertNotNull(named(all, DefaultEditorKit.copyAction));
+        assertNotNull(named(all, DefaultEditorKit.pasteAction));
+        assertNotNull(named(all, DefaultEditorKit.selectAllAction));
+        assertNotNull(named(all, DefaultEditorKit.insertBreakAction));
+        assertNotNull(named(all, DefaultEditorKit.insertTabAction));
+    }
+
+    @Test
+    public void cutCopyAndPasteWorkOnTheComponentTheEventNames() {
+        JTextArea from = new JTextArea("alpha beta");
+        JTextArea to = new JTextArea("");
+        Action[] all = from.getActions();
+        from.select(0, 5);
+        named(all, DefaultEditorKit.copyAction).actionPerformed(new ActionEvent(from, ActionEvent.ACTION_PERFORMED, ""));
+        assertEquals("alpha beta", from.getText());
+        named(all, DefaultEditorKit.pasteAction).actionPerformed(new ActionEvent(to, ActionEvent.ACTION_PERFORMED, ""));
+        assertEquals("alpha", to.getText());
+        from.select(5, 10);
+        named(all, DefaultEditorKit.cutAction).actionPerformed(new ActionEvent(from, ActionEvent.ACTION_PERFORMED, ""));
+        assertEquals("alpha", from.getText());
+        named(all, DefaultEditorKit.selectAllAction).actionPerformed(new ActionEvent(to, ActionEvent.ACTION_PERFORMED, ""));
+        assertEquals("alpha", to.getSelectedText());
+    }
+
+    @Test
+    public void insertBreakAndTabReplaceTheSelection() {
+        JTextArea area = new JTextArea("ab");
+        Action[] all = area.getActions();
+        area.select(1, 1);
+        named(all, DefaultEditorKit.insertBreakAction).actionPerformed(new ActionEvent(area, ActionEvent.ACTION_PERFORMED, ""));
+        assertEquals("a\nb", area.getText());
+        area.select(0, 1);
+        named(all, DefaultEditorKit.insertTabAction).actionPerformed(new ActionEvent(area, ActionEvent.ACTION_PERFORMED, ""));
+        assertEquals("\t\nb", area.getText());
+    }
+
+    @Test
+    public void augmentingAListReplacesActionsOfTheSameName() {
+        Action[] kit = new DefaultEditorKit().getActions();
+        Action mine = new DefaultEditorKit.CopyAction();
+        Action[] merged = TextAction.augmentList(kit, new Action[] {mine});
+        assertEquals(kit.length, merged.length);
+        assertSame(mine, named(merged, DefaultEditorKit.copyAction));
+    }
+
+    @Test
+    public void dragEnabledIsAPropertyOfTheComponentsThatHaveIt() {
+        JTextArea area = new JTextArea();
+        assertFalse(area.getDragEnabled());
+        area.setDragEnabled(true);
+        assertTrue(area.getDragEnabled());
+        JTree tree = new JTree();
+        assertFalse(tree.getDragEnabled());
+        tree.setDragEnabled(true);
+        assertTrue(tree.getDragEnabled());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/WindowsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/WindowsTest.java
new file mode 100644
index 00000000000..f44a1dd0ed8
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/WindowsTest.java
@@ -0,0 +1,577 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Frame;
+import com.codename1.desktopcompat.java.awt.GraphicsEnvironment;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Toolkit;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.MouseAdapter;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.WindowEvent;
+import com.codename1.desktopcompat.java.awt.event.WindowListener;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JDialog;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JLayeredPane;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JWindow;
+import com.codename1.desktopcompat.javax.swing.SwingUtilities;
+import com.codename1.desktopcompat.javax.swing.WindowConstants;
+import com.codename1.desktopcompat.rt.DesktopLifecycle;
+import com.codename1.desktopcompat.rt.DialogForm;
+import com.codename1.desktopcompat.rt.FrameForm;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.ui.Display;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Frames, dialogs and plain windows on both form factors: the stack of
+/// forms, and the window manager behind its seam.
+public class WindowsTest extends WindowsTestBase {
+
+    private static final class Log implements WindowListener {
+        final List<String> log = new ArrayList<String>();
+
+        @Override
+        public void windowOpened(WindowEvent e) {
+            log.add("opened");
+        }
+
+        @Override
+        public void windowClosing(WindowEvent e) {
+            log.add("closing");
+        }
+
+        @Override
+        public void windowClosed(WindowEvent e) {
+            log.add("closed");
+        }
+
+        @Override
+        public void windowIconified(WindowEvent e) {
+            log.add("iconified");
+        }
+
+        @Override
+        public void windowDeiconified(WindowEvent e) {
+            log.add("deiconified");
+        }
+
+        @Override
+        public void windowActivated(WindowEvent e) {
+            log.add("activated");
+        }
+
+        @Override
+        public void windowDeactivated(WindowEvent e) {
+            log.add("deactivated");
+        }
+    }
+
+    @Test
+    public void aFrameIsOpenedActivatedAndClosedOnce() {
+        JFrame f = new JFrame("One");
+        Log log = new Log();
+        f.addWindowListener(log);
+        f.setVisible(true);
+        assertEquals("[opened, activated]", log.log.toString());
+        assertTrue(f.isActive());
+        assertSame(f.cn1Form(), Display.getInstance().getCurrent());
+        assertEquals("One", f.cn1Form().getTitle());
+        f.setTitle("Two");
+        assertEquals("Two", f.cn1Form().getTitle());
+        f.setVisible(false);
+        f.setVisible(true);
+        assertEquals("[opened, activated, deactivated, activated]", log.log.toString());
+        f.dispose();
+        assertEquals("closed", log.log.get(log.log.size() - 1));
+        assertFalse(f.isDisplayable());
+        assertEquals(0, Window.getWindows().length);
+    }
+
+    @Test
+    public void theFrameFillsTheScreen() {
+        JFrame f = new JFrame();
+        f.setSize(300, 200);
+        show(f);
+        Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
+        assertEquals(screen.width, f.getWidth());
+        assertTrue(f.getHeight() > 200);
+        Rectangle b = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice()
+                .getDefaultConfiguration().getBounds();
+        assertEquals(screen.width, b.width);
+        assertEquals(screen.height, b.height);
+        assertFalse(GraphicsEnvironment.isHeadless());
+        assertNotNull(f.getGraphicsConfiguration());
+        assertEquals(0, Toolkit.getDefaultToolkit().getScreenInsets(f.getGraphicsConfiguration()).top);
+    }
+
+    @Test
+    public void theCloseOperationsDoWhatTheySay() {
+        JFrame hide = show(new JFrame("hide"));
+        Log log = new Log();
+        hide.addWindowListener(log);
+        hide.cn1Closing();
+        assertFalse(hide.isVisible());
+        assertTrue(hide.isDisplayable());
+        assertTrue(log.log.contains("closing"));
+        assertFalse(log.log.contains("closed"));
+
+        JFrame dispose = new JFrame("dispose");
+        dispose.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        Log disposed = new Log();
+        dispose.addWindowListener(disposed);
+        show(dispose);
+        dispose.cn1Closing();
+        assertFalse(dispose.isDisplayable());
+        assertTrue(disposed.log.contains("closed"));
+
+        JFrame nothing = new JFrame("nothing");
+        nothing.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+        show(nothing);
+        nothing.cn1Closing();
+        assertTrue(nothing.isVisible());
+
+        final int[] exits = new int[1];
+        WindowHosts.setExitHook(new Runnable() {
+            @Override
+            public void run() {
+                exits[0]++;
+            }
+        });
+        JFrame exit = new JFrame("exit");
+        exit.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        show(exit);
+        assertEquals(0, exits[0]);
+        exit.cn1Closing();
+        assertEquals(1, exits[0]);
+    }
+
+    @Test
+    public void theBackCommandOfTheFormAsksTheFrameToClose() {
+        JFrame f = new JFrame("back");
+        f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        show(f);
+        FrameForm form = f.cn1Form();
+        assertNotNull(form.getBackCommand());
+        form.getBackCommand().actionPerformed(new com.codename1.ui.events.ActionEvent(form));
+        assertFalse(f.isDisplayable());
+    }
+
+    @Test
+    public void onAPhoneASecondFrameIsAFormOverTheFirstAndClosingItGoesBack() {
+        JFrame first = show(new JFrame("first"));
+        JFrame second = new JFrame("second");
+        Log firstLog = new Log();
+        first.addWindowListener(firstLog);
+        show(second);
+        assertSame(second.cn1Form(), Display.getInstance().getCurrent());
+        assertTrue(second.isActive());
+        assertFalse(first.isActive());
+        assertEquals("[deactivated]", firstLog.log.toString());
+        assertEquals(2, Window.getWindows().length);
+        assertEquals(2, Frame.getFrames().length);
+        second.dispose();
+        MainThreadRule.drain();
+        assertSame(first.cn1Form(), Display.getInstance().getCurrent());
+        assertTrue(first.isActive());
+        first.toFront();
+        assertTrue(first.isActive());
+    }
+
+    @Test
+    public void whereThereIsAWindowManagerLaterFramesAreWindowsOfIt() {
+        FakeDesktop desktop = new FakeDesktop();
+        WindowHosts.setSecondaryWindows(desktop);
+        JFrame first = show(new JFrame("first"));
+        assertNotNull("the first frame keeps the application's form", first.cn1Form());
+        assertEquals(0, desktop.hosts.size());
+
+        JFrame second = new JFrame("second");
+        second.setResizable(false);
+        second.setSize(320, 240);
+        second.setVisible(true);
+        assertEquals(1, desktop.hosts.size());
+        FakeHost host = desktop.hosts.get(0);
+        assertSame(second, host.window);
+        assertSame(host, second.cn1Host());
+        assertNull(second.cn1Form());
+        assertEquals("second", host.title);
+        assertTrue(host.open);
+        assertTrue(host.log.contains("resizable false"));
+        assertTrue(host.log.contains("decorated true"));
+        assertSame("the first frame stays where it is", first.cn1Form(), Display.getInstance().getCurrent());
+        assertEquals(320, second.getWidth());
+        assertEquals(240, second.getHeight());
+        assertTrue(second.isActive());
+
+        second.setSize(400, 300);
+        assertTrue(host.log.contains("bounds 400x300"));
+        second.setExtendedState(Frame.MAXIMIZED_BOTH);
+        assertTrue(host.log.contains("state " + Frame.MAXIMIZED_BOTH));
+        second.setTitle("renamed");
+        assertEquals("renamed", host.title);
+
+        second.setVisible(false);
+        assertFalse(host.open);
+        assertTrue(first.isActive());
+        second.setVisible(true);
+        assertEquals("the window is reused", 1, desktop.hosts.size());
+        second.dispose();
+        assertTrue(host.log.contains("release"));
+
+        JDialog d = new JDialog(first, "dialog", false);
+        d.setSize(100, 100);
+        d.setVisible(true);
+        assertEquals(2, desktop.hosts.size());
+        assertSame(d, desktop.hosts.get(1).window);
+        d.dispose();
+    }
+
+    @Test
+    public void aDialogFloatsOverTheFrameAtItsOwnSizeAndKnowsItsOwner() {
+        JFrame f = show(new JFrame("owner"));
+        JDialog d = new JDialog(f, "dialog", false);
+        d.add(new JLabel("content"), BorderLayout.CENTER);
+        d.setSize(200, 120);
+        d.setVisible(true);
+        assertTrue(d.cn1Host() instanceof DialogForm);
+        assertNull(d.cn1Form());
+        assertSame(f, d.getOwner());
+        assertEquals(1, f.getOwnedWindows().length);
+        assertSame(d, f.getOwnedWindows()[0]);
+        assertSame(d, WindowHosts.active());
+        assertNull(SwingUtilities.getWindowAncestor(d));
+        assertTrue("width " + d.getWidth(), d.getWidth() > 150 && d.getWidth() <= 200);
+        assertTrue("height " + d.getHeight(), d.getHeight() > 80 && d.getHeight() <= 120);
+        assertEquals(1, Window.getOwnerlessWindows().length);
+        f.dispose();
+        assertFalse("disposing of the owner disposes of the dialog", d.isDisplayable());
+    }
+
+    @Test
+    public void aModalDialogBlocksItsCallerUntilItIsDisposedOf() {
+        JFrame f = show(new JFrame("owner"));
+        final JDialog d = new JDialog(f, "modal", true);
+        JButton ok = new JButton("OK");
+        d.add(ok, BorderLayout.CENTER);
+        d.setSize(150, 100);
+        final List<String> order = new ArrayList<String>();
+        ok.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                order.add("clicked");
+                d.dispose();
+            }
+        });
+        Display.getInstance().callSerially(new Runnable() {
+            @Override
+            public void run() {
+                order.add(d.isVisible() ? "showing" : "not showing");
+                ((JButton) d.getContentPane().getComponent(0)).doClick();
+            }
+        });
+        order.add("before");
+        d.setVisible(true);
+        order.add("after");
+        assertEquals("[before, showing, clicked, after]", order.toString());
+        assertFalse(d.isVisible());
+        assertSame(f, WindowHosts.active());
+    }
+
+    @Test
+    public void whileAModalDialogBlocksEventsKeepRunning() {
+        JFrame f = show(new JFrame("owner"));
+        final JDialog d = new JDialog(f, "modal", true);
+        d.setSize(150, 100);
+        final List<String> order = new ArrayList<String>();
+        Thread later = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(150);
+                } catch (InterruptedException e) {
+                    return;
+                }
+                Display.getInstance().callSerially(new Runnable() {
+                    @Override
+                    public void run() {
+                        order.add(Display.getInstance().getCurrent() == d.cn1HostForm() ? "on screen" : "missing");
+                        order.add(d.isActive() ? "active" : "inactive");
+                        d.setVisible(false);
+                    }
+                });
+            }
+        });
+        later.start();
+        d.setVisible(true);
+        order.add("returned");
+        assertEquals("[on screen, active, returned]", order.toString());
+        assertTrue("hidden, not disposed of", d.isDisplayable());
+        assertTrue(f.isActive());
+    }
+
+    @Test
+    public void aModelessDialogDoesNotBlock() {
+        JFrame f = show(new JFrame("owner"));
+        JDialog d = new JDialog(f, "modeless");
+        d.setSize(100, 100);
+        d.setVisible(true);
+        assertTrue(d.isVisible());
+        d.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        d.cn1Closing();
+        assertFalse(d.isDisplayable());
+    }
+
+    @Test
+    public void aDialogGetsThePointerThroughItsOwnHost() {
+        JFrame f = show(new JFrame("owner"));
+        JDialog d = new JDialog(f, "dialog");
+        JPanel p = new JPanel();
+        final int[] clicks = new int[1];
+        p.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                clicks[0]++;
+            }
+        });
+        d.add(p, BorderLayout.CENTER);
+        d.setSize(200, 200);
+        d.setVisible(true);
+        click(d, p, 20, 20);
+        assertEquals(1, clicks[0]);
+    }
+
+    @Test
+    public void thePanesOfARootPaneStackInLayers() {
+        JFrame f = new JFrame("layers");
+        JPanel low = new JPanel();
+        JPanel high = new JPanel();
+        JPanel top = new JPanel();
+        JLayeredPane lp = f.getLayeredPane();
+        lp.add(low, JLayeredPane.DEFAULT_LAYER);
+        lp.add(top, JLayeredPane.POPUP_LAYER);
+        lp.add(high, JLayeredPane.MODAL_LAYER);
+        show(f);
+        assertSame(lp, f.getRootPane().getLayeredPane());
+        assertEquals(0, lp.getIndexOf(top));
+        assertEquals(1, lp.getIndexOf(high));
+        assertEquals(2, lp.getIndexOf(low));
+        assertTrue(lp.getIndexOf(f.getContentPane()) > 2);
+        assertEquals(JLayeredPane.POPUP_LAYER.intValue(), lp.highestLayer());
+        assertEquals(JLayeredPane.FRAME_CONTENT_LAYER.intValue(), lp.lowestLayer());
+        assertEquals(1, lp.getComponentCountInLayer(JLayeredPane.MODAL_LAYER.intValue()));
+        JPanel second = new JPanel();
+        lp.add(second, JLayeredPane.MODAL_LAYER);
+        assertEquals(1, lp.getPosition(second));
+        lp.moveToFront(second);
+        assertEquals(0, lp.getPosition(second));
+        assertEquals(1, lp.getPosition(high));
+        lp.setLayer(low, JLayeredPane.DRAG_LAYER.intValue());
+        assertEquals(0, lp.getIndexOf(low));
+        assertSame(f.getRootPane().getGlassPane(), f.getGlassPane());
+        assertFalse(f.getGlassPane().isVisible());
+        assertEquals(f.getRootPane().getWidth(), f.getGlassPane().getWidth());
+        assertEquals(f.getRootPane().getHeight(), f.getContentPane().getHeight());
+    }
+
+    @Test
+    public void aVisibleGlassPaneTakesThePointerFromTheContent() {
+        JFrame f = new JFrame("glass");
+        JPanel content = new JPanel();
+        final int[] contentClicks = new int[1];
+        final int[] glassClicks = new int[1];
+        content.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                contentClicks[0]++;
+            }
+        });
+        f.add(content, BorderLayout.CENTER);
+        JPanel glass = new JPanel();
+        glass.setOpaque(false);
+        glass.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                glassClicks[0]++;
+            }
+        });
+        f.setGlassPane(glass);
+        show(f);
+        click(f, content, 30, 30);
+        assertEquals(1, contentClicks[0]);
+        glass.setVisible(true);
+        f.validate();
+        click(f, content, 30, 30);
+        assertEquals(1, contentClicks[0]);
+        assertEquals(1, glassClicks[0]);
+    }
+
+    @Test
+    public void theEnterKeyClicksTheDefaultButton() {
+        JFrame f = new JFrame("default");
+        JButton ok = new JButton("OK");
+        final int[] clicks = new int[1];
+        ok.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                clicks[0]++;
+            }
+        });
+        f.add(ok, BorderLayout.SOUTH);
+        f.getRootPane().setDefaultButton(ok);
+        show(f);
+        type(f, '\n');
+        assertEquals(1, clicks[0]);
+        ok.setEnabled(false);
+        type(f, '\n');
+        assertEquals(1, clicks[0]);
+    }
+
+    @Test
+    public void aPlainWindowShownFirstFillsAFormAndOverAFrameFloats() {
+        JWindow splash = new JWindow();
+        splash.add(new JLabel("splash"), BorderLayout.CENTER);
+        splash.setVisible(true);
+        assertNotNull(splash.cn1Form());
+        splash.dispose();
+        JFrame f = show(new JFrame("main"));
+        JWindow tip = new JWindow(f);
+        tip.setSize(80, 40);
+        tip.setVisible(true);
+        assertTrue(tip.cn1Host() instanceof DialogForm);
+        tip.dispose();
+    }
+
+    @Test
+    public void iconifyingAndStateChangesAreReported() {
+        JFrame f = show(new JFrame("state"));
+        Log log = new Log();
+        f.addWindowListener(log);
+        f.cn1Iconified(true);
+        f.cn1Iconified(false);
+        assertEquals("[iconified, deiconified]", log.log.toString());
+        f.setExtendedState(Frame.MAXIMIZED_BOTH);
+        assertEquals(Frame.MAXIMIZED_BOTH, f.getExtendedState());
+    }
+
+    @Test
+    public void theLifecycleRunsMainKeepsRunningAndMapsThePlatformCalls() {
+        final JFrame[] made = new JFrame[1];
+        final Log log = new Log();
+        final int[] exits = new int[1];
+        DesktopLifecycle app = new DesktopLifecycle() {
+            @Override
+            protected void runMain() {
+                made[0] = new JFrame("app");
+                made[0].setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+                made[0].addWindowListener(log);
+                made[0].setVisible(true);
+            }
+        };
+        app.runApp();
+        WindowHosts.setExitHook(new Runnable() {
+            @Override
+            public void run() {
+                exits[0]++;
+            }
+        });
+        MainThreadRule.drain();
+        assertNotNull(made[0]);
+        assertSame(made[0].cn1Form(), Display.getInstance().getCurrent());
+        log.log.clear();
+        app.stop();
+        assertEquals("[deactivated, iconified]", log.log.toString());
+        log.log.clear();
+        app.start();
+        assertEquals("[deiconified, activated]", log.log.toString());
+        log.log.clear();
+        app.destroy();
+        assertEquals("[closing]", log.log.toString());
+        assertEquals(0, exits[0]);
+    }
+
+    @Test
+    public void aMainThatShowsNothingLeavesABlankFormOnTheScreen() {
+        new com.codename1.ui.Form("stale").show();
+        DesktopLifecycle app = new DesktopLifecycle() {
+            @Override
+            protected void runMain() {
+            }
+        };
+        final int[] exits = new int[1];
+        app.runApp();
+        WindowHosts.setExitHook(new Runnable() {
+            @Override
+            public void run() {
+                exits[0]++;
+            }
+        });
+        MainThreadRule.drain();
+        assertNotNull(Display.getInstance().getCurrent());
+        assertFalse(Display.getInstance().getCurrent() instanceof FrameForm);
+        assertEquals("an application that showed no window is not ended", 0, exits[0]);
+    }
+
+    @Test
+    public void disposingOfTheLastWindowEndsTheApplication() {
+        final JFrame[] made = new JFrame[1];
+        DesktopLifecycle app = new DesktopLifecycle() {
+            @Override
+            protected void runMain() {
+                made[0] = new JFrame("app");
+                made[0].setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+                made[0].setVisible(true);
+            }
+        };
+        final int[] exits = new int[1];
+        app.runApp();
+        WindowHosts.setExitHook(new Runnable() {
+            @Override
+            public void run() {
+                exits[0]++;
+            }
+        });
+        MainThreadRule.drain();
+        assertEquals(0, exits[0]);
+        made[0].cn1Closing();
+        MainThreadRule.drain();
+        assertEquals(1, exits[0]);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/WindowsTestBase.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/WindowsTestBase.java
new file mode 100644
index 00000000000..9988e961303
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/WindowsTestBase.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat;
+
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.javax.swing.MenuSelectionManager;
+import com.codename1.desktopcompat.rt.EventBridge;
+import com.codename1.desktopcompat.rt.InputState;
+import com.codename1.desktopcompat.rt.SecondaryWindows;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.desktopcompat.rt.WindowHost;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import com.codename1.ui.Command;
+import com.codename1.ui.Form;
+import com.codename1.ui.Image;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+
+/// What the window, menu and input tests share: a start with no window
+/// left over from another test, the input state and the window manager
+/// under the test's control, and both put back afterwards.
+public abstract class WindowsTestBase extends KernelTestBase {
+
+    /// The modifiers and the button the next events carry.
+    protected final FakeInput input = new FakeInput();
+
+    @Before
+    public void cleanWindows() {
+        disposeAll();
+        EventBridge.setInputState(input);
+    }
+
+    @After
+    public void restoreWindows() {
+        MenuSelectionManager.defaultManager().clearSelectedPath();
+        WindowHosts.setIdleHook(null);
+        disposeAll();
+        MainThreadRule.drain();
+        EventBridge.setInputState(null);
+        WindowHosts.setSecondaryWindows(null);
+        WindowHosts.setExitHook(null);
+    }
+
+    private static void disposeAll() {
+        Window[] ws = Window.getWindows();
+        for (int i = ws.length - 1; i >= 0; i--) {
+            ws[i].dispose();
+        }
+    }
+
+    /// The display position of a logical point of `c`.
+    protected static int[] at(Component c, int x, int y) {
+        com.codename1.ui.Component p = c.cn1Peer();
+        return new int[]{p.getAbsoluteX() + Units.toDevice(x), p.getAbsoluteY() + Units.toDevice(y)};
+    }
+
+    /// Presses and releases the pointer on a point of `c`, through the
+    /// form that hosts its window.
+    protected static void click(Window w, Component c, int x, int y) {
+        int[] p = at(c, x, y);
+        Form f = w.cn1HostForm();
+        f.pointerPressed(p[0], p[1]);
+        f.pointerReleased(p[0], p[1]);
+    }
+
+    protected static void pressOn(Window w, Component c, int x, int y) {
+        int[] p = at(c, x, y);
+        w.cn1HostForm().pointerPressed(p[0], p[1]);
+    }
+
+    protected static void releaseOn(Window w, Component c, int x, int y) {
+        int[] p = at(c, x, y);
+        w.cn1HostForm().pointerReleased(p[0], p[1]);
+    }
+
+    /// Sends a key press and its release to the window.
+    protected static void type(Window w, int code) {
+        Form f = w.cn1HostForm();
+        f.keyPressed(code);
+        f.keyReleased(code);
+    }
+
+    /// Input state a test sets.
+    public static final class FakeInput implements InputState {
+
+        public int modifiers;
+        public int button = 1;
+        public boolean touch;
+
+        @Override
+        public int modifiers() {
+            return modifiers;
+        }
+
+        @Override
+        public int button() {
+            return button;
+        }
+
+        @Override
+        public boolean touch() {
+            return touch;
+        }
+
+        public void control() {
+            modifiers = InputEvent.CTRL_DOWN_MASK;
+        }
+    }
+
+    /// A window manager that records what it was asked, standing for a
+    /// desktop port's.
+    public static final class FakeDesktop implements SecondaryWindows {
+
+        public final List<FakeHost> hosts = new ArrayList<FakeHost>();
+
+        @Override
+        public boolean supported() {
+            return true;
+        }
+
+        @Override
+        public WindowHost open(Window w) {
+            FakeHost h = new FakeHost(w);
+            hosts.add(h);
+            return h;
+        }
+    }
+
+    /// One window of the fake window manager.
+    public static final class FakeHost implements WindowHost {
+
+        public final Window window;
+        public final List<String> log = new ArrayList<String>();
+        public List<Command> commands = new ArrayList<Command>();
+        public String title;
+        public boolean open;
+
+        FakeHost(Window window) {
+            this.window = window;
+        }
+
+        @Override
+        public void open() {
+            open = true;
+            log.add("open");
+        }
+
+        @Override
+        public void close() {
+            open = false;
+            log.add("close");
+        }
+
+        @Override
+        public void release() {
+            log.add("release");
+        }
+
+        @Override
+        public void title(String t) {
+            title = t;
+        }
+
+        @Override
+        public void icon(Image icon) {
+        }
+
+        @Override
+        public void bounds() {
+            log.add("bounds " + window.getWidth() + "x" + window.getHeight());
+        }
+
+        @Override
+        public void resizable(boolean resizable) {
+            log.add("resizable " + resizable);
+        }
+
+        @Override
+        public void decorated(boolean decorated) {
+            log.add("decorated " + decorated);
+        }
+
+        @Override
+        public void state(int state) {
+            log.add("state " + state);
+        }
+
+        @Override
+        public void commands(List<Command> list) {
+            commands = new ArrayList<Command>(list);
+        }
+
+        @Override
+        public boolean takesCommands() {
+            return true;
+        }
+
+        @Override
+        public Form form() {
+            return null;
+        }
+
+        @Override
+        public boolean fillsDisplay() {
+            return false;
+        }
+
+        @Override
+        public boolean reusable() {
+            return true;
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatClientPropertiesTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatClientPropertiesTest.java
new file mode 100644
index 00000000000..92ccaa6180f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatClientPropertiesTest.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+import com.codename1.desktopcompat.rt.ClientProps;
+import org.junit.Test;
+
+/// The FlatLaf client properties that do something in this layer, each
+/// shown doing it, and one that is only recorded.
+public class FlatClientPropertiesTest extends KernelTestBase {
+
+    /// What `putClientProperty` does once it calls the layer's hook; done
+    /// by hand here so the test says the same thing either way.
+    private static void put(JComponent c, String key, Object value) {
+        c.putClientProperty(key, value);
+        ClientProps.changed(c, key, value);
+    }
+
+    @Test
+    public void thePlaceholderIsTheHintOfTheField() {
+        JTextField field = new JTextField(12);
+        put(field, FlatClientProperties.PLACEHOLDER_TEXT, "Search");
+        com.codename1.ui.Component peer = field.cn1Peer();
+        assertTrue(peer instanceof com.codename1.ui.TextArea);
+        assertEquals("Search", ((com.codename1.ui.TextArea) peer).getHint());
+        assertEquals("Search", field.getClientProperty("JTextField.placeholderText"));
+        put(field, FlatClientProperties.PLACEHOLDER_TEXT, null);
+        assertEquals("", ((com.codename1.ui.TextArea) peer).getHint());
+    }
+
+    @Test
+    public void aBorderlessOrToolBarButtonHasNoBorderAndNoFill() {
+        JButton button = new JButton("Go");
+        assertTrue(button.isBorderPainted());
+        put(button, FlatClientProperties.BUTTON_TYPE, FlatClientProperties.BUTTON_TYPE_BORDERLESS);
+        assertFalse(button.isBorderPainted());
+        assertFalse(button.isContentAreaFilled());
+        put(button, FlatClientProperties.BUTTON_TYPE, null);
+        assertTrue(button.isBorderPainted());
+        assertTrue(button.isContentAreaFilled());
+        put(button, FlatClientProperties.BUTTON_TYPE, FlatClientProperties.BUTTON_TYPE_TOOLBAR_BUTTON);
+        assertFalse(button.isBorderPainted());
+        // A shape is the theme's: recorded, and the button stays a button.
+        put(button, FlatClientProperties.BUTTON_TYPE, FlatClientProperties.BUTTON_TYPE_ROUND_RECT);
+        assertTrue(button.isBorderPainted());
+        assertEquals("roundRect", button.getClientProperty(FlatClientProperties.BUTTON_TYPE));
+    }
+
+    @Test
+    public void anOutlineIsALineAroundTheComponentAndGoesAgain() {
+        JPanel panel = new JPanel();
+        Border own = new EmptyBorder(1, 1, 1, 1);
+        panel.setBorder(own);
+        JFrame f = new JFrame();
+        f.add(panel, BorderLayout.CENTER);
+        f.setSize(200, 100);
+        show(f);
+        put(panel, FlatClientProperties.OUTLINE, FlatClientProperties.OUTLINE_ERROR);
+        int error = UIManager.getColor("Component.error.focusedBorderColor").getRGB() & 0xffffff;
+        int[][] rows = raster(f);
+        assertEquals(error, pixel(rows, panel, 0, panel.getHeight() / 2) & 0xffffff);
+        assertEquals(error, pixel(rows, panel, panel.getWidth() / 2, 1) & 0xffffff);
+        assertFalse(error == (pixel(rows, panel, panel.getWidth() / 2, panel.getHeight() / 2) & 0xffffff));
+
+        Color mine = new Color(10, 200, 30);
+        put(panel, FlatClientProperties.OUTLINE, mine);
+        rows = raster(f);
+        assertEquals(mine.getRGB() & 0xffffff, pixel(rows, panel, 0, panel.getHeight() / 2) & 0xffffff);
+        put(panel, FlatClientProperties.OUTLINE, FlatClientProperties.OUTLINE_WARNING);
+        rows = raster(f);
+        assertEquals(UIManager.getColor("Component.warning.focusedBorderColor").getRGB() & 0xffffff,
+                pixel(rows, panel, 0, panel.getHeight() / 2) & 0xffffff);
+
+        put(panel, FlatClientProperties.OUTLINE, null);
+        assertSame(own, panel.getBorder());
+        rows = raster(f);
+        assertFalse(error == (pixel(rows, panel, 0, panel.getHeight() / 2) & 0xffffff));
+    }
+
+    @Test
+    public void aStyleClassAndAStyleGiveTheFontAndColorsTheyName() {
+        JLabel plain = new JLabel("plain");
+        JLabel title = new JLabel("title");
+        float base = plain.getFont().getSize2D();
+        put(title, FlatClientProperties.STYLE_CLASS, "unknown h1");
+        assertTrue(title.getFont().getSize2D() > base);
+        assertTrue(title.getFont().isBold());
+        JLabel small = new JLabel("small");
+        put(small, FlatClientProperties.STYLE_CLASS, "small");
+        assertTrue(small.getFont().getSize2D() < base);
+        JLabel mono = new JLabel("mono");
+        put(mono, FlatClientProperties.STYLE_CLASS, "monospaced");
+        assertEquals(Font.MONOSPACED, mono.getFont().getFamily());
+
+        JLabel styled = new JLabel("styled");
+        put(styled, FlatClientProperties.STYLE, "background: #102030; foreground: #fff; font: bold 20; arc: 8");
+        assertEquals(0x102030, styled.getBackground().getRGB() & 0xffffff);
+        assertEquals(0xffffff, styled.getForeground().getRGB() & 0xffffff);
+        assertTrue(styled.getFont().isBold());
+        assertEquals(20, styled.getFont().getSize());
+        JLabel bigger = new JLabel("bigger");
+        put(bigger, FlatClientProperties.STYLE, "font: +4 italic");
+        assertTrue(bigger.getFont().getSize2D() > base);
+        assertTrue(bigger.getFont().isItalic());
+    }
+
+    @Test
+    public void aMinimumWidthIsTheMinimumSize() {
+        JButton button = new JButton("x");
+        put(button, FlatClientProperties.MINIMUM_WIDTH, Integer.valueOf(140));
+        assertEquals(140, button.getMinimumSize().width);
+        put(button, FlatClientProperties.MINIMUM_HEIGHT, Integer.valueOf(44));
+        assertEquals(44, button.getMinimumSize().height);
+        assertEquals(140, button.getMinimumSize().width);
+    }
+
+    @Test
+    public void everyOtherPropertyIsKeptAndChangesNothing() {
+        JTextField field = new JTextField("text");
+        Border before = field.getBorder();
+        Font font = field.getFont();
+        put(field, FlatClientProperties.TEXT_FIELD_SHOW_CLEAR_BUTTON, Boolean.TRUE);
+        put(field, FlatClientProperties.COMPONENT_ROUND_RECT, Boolean.TRUE);
+        put(field, FlatClientProperties.SELECT_ALL_ON_FOCUS_POLICY, FlatClientProperties.SELECT_ALL_ON_FOCUS_POLICY_ALWAYS);
+        assertEquals(Boolean.TRUE, field.getClientProperty(FlatClientProperties.TEXT_FIELD_SHOW_CLEAR_BUTTON));
+        assertTrue(FlatClientProperties.clientPropertyBoolean(field, FlatClientProperties.COMPONENT_ROUND_RECT, false));
+        assertTrue(FlatClientProperties.clientPropertyEquals(field, FlatClientProperties.SELECT_ALL_ON_FOCUS_POLICY,
+                "always"));
+        assertSame(before, field.getBorder());
+        assertEquals(font, field.getFont());
+        assertNull(field.getClientProperty(FlatClientProperties.OUTLINE));
+        assertEquals(7, FlatClientProperties.clientPropertyInt(field, "No.such", 7));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLafApiShapeTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLafApiShapeTest.java
new file mode 100644
index 00000000000..4b4c2e52b5c
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/com/formdev/flatlaf/FlatLafApiShapeTest.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.com.formdev.flatlaf;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import org.junit.Test;
+
+/// The layer's `com.formdev.flatlaf` classes held to the real FlatLaf and
+/// FlatLaf Extras, which are test dependencies of this module for that
+/// purpose alone.
+///
+/// An application compiles against the real jars and is then pointed at
+/// these classes, so a member here that the real class lacks, or has with
+/// another descriptor, is a member no application can reach, and a class
+/// here must be what the real one is: interface or class, with a
+/// superclass that is one of the real class's. Members named `cn1...`
+/// are the layer's own.
+///
+/// The other direction is checked too: every public class of the real
+/// jars is in the layer or is named in `flatlaf-absent.txt`, so leaving
+/// one out is a decision that was written down.
+public class FlatLafApiShapeTest {
+
+    private static final String PREFIX = "com.codename1.desktopcompat.";
+
+    private final List<String> problems = new ArrayList<String>();
+    private final Set<String> ours = new HashSet<String>();
+
+    private static boolean api(int modifiers) {
+        return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers);
+    }
+
+    private static Class<?> real(String name) {
+        try {
+            return Class.forName(name, false, ClassLoader.getSystemClassLoader());
+        } catch (ClassNotFoundException e) {
+            return null;
+        } catch (LinkageError e) {
+            return null;
+        }
+    }
+
+    /// The real type a type of ours stands for, or null when it is a
+    /// layer type with no counterpart.
+    private static Class<?> map(Class<?> c) {
+        if (c.isArray()) {
+            Class<?> component = map(c.getComponentType());
+            return component == null ? null : java.lang.reflect.Array.newInstance(component, 0).getClass();
+        }
+        return c.getName().startsWith(PREFIX) ? real(c.getName().substring(PREFIX.length())) : c;
+    }
+
+    private static Class<?>[] mapAll(Class<?>[] types) {
+        Class<?>[] out = new Class<?>[types.length];
+        for (int i = 0; i < types.length; i++) {
+            out[i] = map(types[i]);
+            if (out[i] == null) {
+                return null;
+            }
+        }
+        return out;
+    }
+
+    private static Method findMethod(Class<?> in, String name, Class<?>[] params, Class<?> ret) {
+        if (in == null) {
+            return null;
+        }
+        for (Method m : in.getDeclaredMethods()) {
+            if (m.getName().equals(name) && api(m.getModifiers()) && m.getReturnType() == ret
+                    && java.util.Arrays.equals(m.getParameterTypes(), params)) {
+                return m;
+            }
+        }
+        Method up = findMethod(in.getSuperclass(), name, params, ret);
+        for (Class<?> i : in.getInterfaces()) {
+            if (up == null) {
+                up = findMethod(i, name, params, ret);
+            }
+        }
+        return up;
+    }
+
+    private static Field findField(Class<?> in, String name, Class<?> type) {
+        if (in == null) {
+            return null;
+        }
+        for (Field f : in.getDeclaredFields()) {
+            if (f.getName().equals(name) && api(f.getModifiers()) && f.getType() == type) {
+                return f;
+            }
+        }
+        Field up = findField(in.getSuperclass(), name, type);
+        for (Class<?> i : in.getInterfaces()) {
+            if (up == null) {
+                up = findField(i, name, type);
+            }
+        }
+        return up;
+    }
+
+    private void walk(File dir, String pkg) throws Exception {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return;
+        }
+        for (File f : files) {
+            if (f.isDirectory()) {
+                walk(f, pkg + "." + f.getName());
+            } else if (f.getName().endsWith(".class") && !f.getName().equals("package-info.class")) {
+                String simple = f.getName().substring(0, f.getName().length() - 6);
+                check(Class.forName(pkg + "." + simple, false, FlatLafApiShapeTest.class.getClassLoader()));
+            }
+        }
+    }
+
+    private void check(Class<?> mine) {
+        for (Class<?> k = mine; k != null; k = k.getDeclaringClass()) {
+            if (!api(k.getModifiers())) {
+                return;
+            }
+        }
+        if (mine.isAnonymousClass() || mine.isLocalClass()) {
+            return;
+        }
+        String name = mine.getName();
+        ours.add(name.substring(PREFIX.length()));
+        Class<?> real = real(name.substring(PREFIX.length()));
+        if (real == null) {
+            problems.add(name + ": FlatLaf has no such class");
+            return;
+        }
+        if (mine.isInterface() != real.isInterface()) {
+            problems.add(name + ": interface here but not in FlatLaf, or the reverse");
+        }
+        if (Modifier.isFinal(real.getModifiers()) != Modifier.isFinal(mine.getModifiers())) {
+            problems.add(name + ": final differs from FlatLaf");
+        }
+        if (Modifier.isAbstract(mine.getModifiers()) && !Modifier.isAbstract(real.getModifiers())) {
+            problems.add(name + ": abstract here but instantiable in FlatLaf");
+        }
+        Class<?> sup = mine.getSuperclass();
+        if (sup != null && sup != Object.class) {
+            Class<?> mapped = map(sup);
+            if (mapped == null || !mapped.isAssignableFrom(real) || mapped.isInterface()) {
+                problems.add(name + ": superclass " + sup.getName() + " is not an ancestor of the FlatLaf class");
+            }
+        }
+        for (Class<?> i : mine.getInterfaces()) {
+            Class<?> mapped = map(i);
+            if (mapped == null || !mapped.isAssignableFrom(real)) {
+                problems.add(name + ": interface " + i.getName() + " is not implemented by the FlatLaf class");
+            }
+        }
+        for (Constructor<?> c : mine.getDeclaredConstructors()) {
+            if (!api(c.getModifiers()) || c.isSynthetic()) {
+                continue;
+            }
+            Class<?>[] params = mapAll(c.getParameterTypes());
+            boolean found = false;
+            if (params != null) {
+                try {
+                    found = api(real.getDeclaredConstructor(params).getModifiers());
+                } catch (NoSuchMethodException e) {
+                    found = false;
+                }
+            }
+            if (!found) {
+                problems.add(name + ": constructor " + c + " is not in FlatLaf");
+            }
+        }
+        for (Method m : mine.getDeclaredMethods()) {
+            if (!api(m.getModifiers()) || m.isSynthetic() || m.isBridge() || m.getName().startsWith("cn1")) {
+                continue;
+            }
+            Class<?>[] params = mapAll(m.getParameterTypes());
+            Class<?> ret = map(m.getReturnType());
+            Method found = params == null || ret == null ? null : findMethod(real, m.getName(), params, ret);
+            if (found == null) {
+                problems.add(name + ": method " + m + " is not in FlatLaf");
+            } else if (Modifier.isStatic(found.getModifiers()) != Modifier.isStatic(m.getModifiers())) {
+                problems.add(name + ": method " + m + " is static here but not in FlatLaf, or the reverse");
+            } else if (Modifier.isAbstract(m.getModifiers()) && !Modifier.isAbstract(found.getModifiers())) {
+                problems.add(name + ": method " + m + " is abstract here but concrete in FlatLaf");
+            }
+        }
+        for (Field f : mine.getDeclaredFields()) {
+            if (!api(f.getModifiers()) || f.isSynthetic() || f.getName().startsWith("cn1")) {
+                continue;
+            }
+            Class<?> type = map(f.getType());
+            Field found = type == null ? null : findField(real, f.getName(), type);
+            if (found == null) {
+                problems.add(name + ": field " + f + " is not in FlatLaf");
+            } else if (Modifier.isStatic(found.getModifiers()) != Modifier.isStatic(f.getModifiers())) {
+                problems.add(name + ": field " + f + " is static here but not in FlatLaf, or the reverse");
+            } else if (Modifier.isStatic(f.getModifiers()) && f.getType() == String.class
+                    && Modifier.isFinal(f.getModifiers())) {
+                constant(name, f, found);
+            }
+        }
+    }
+
+    /// A string constant is compiled into the application, so ours is
+    /// only ever read for the same value; it has to be that value.
+    private void constant(String name, Field mine, Field theirs) {
+        try {
+            mine.setAccessible(true);
+            theirs.setAccessible(true);
+            Object a = mine.get(null);
+            Object b = theirs.get(null);
+            if (a == null ? b != null : !a.equals(b)) {
+                problems.add(name + ": constant " + mine.getName() + " is \"" + a + "\" here and \"" + b
+                        + "\" in FlatLaf");
+            }
+        } catch (IllegalAccessException e) {
+            problems.add(name + ": constant " + mine.getName() + " cannot be read: " + e);
+        } catch (LinkageError e) {
+            problems.add(name + ": constant " + mine.getName() + " cannot be read: " + e);
+        }
+    }
+
+    private static File jarOf(String className) throws Exception {
+        Class<?> c = Class.forName(className, false, ClassLoader.getSystemClassLoader());
+        return new File(c.getProtectionDomain().getCodeSource().getLocation().toURI());
+    }
+
+    @Test
+    public void everyClassMatchesFlatLafAndEveryAbsentClassIsWrittenDown() throws Exception {
+        File root = new File(System.getProperty("swingcompat.classes", "target/classes"));
+        walk(new File(root, "com/codename1/desktopcompat/com/formdev"), PREFIX + "com.formdev");
+        assertTrue("no classes found", !ours.isEmpty());
+
+        Set<String> absent = new HashSet<String>();
+        List<String> packages = new ArrayList<String>();
+        InputStream in = FlatLafApiShapeTest.class.getResourceAsStream("flatlaf-absent.txt");
+        assertNotNull("flatlaf-absent.txt", in);
+        BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
+        try {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                line = line.trim();
+                if (line.length() == 0 || line.charAt(0) == '#') {
+                    continue;
+                }
+                if (line.endsWith(".*")) {
+                    packages.add(line.substring(0, line.length() - 1));
+                } else {
+                    absent.add(line);
+                }
+            }
+        } finally {
+            reader.close();
+        }
+        Set<String> theirs = new HashSet<String>();
+        File[] jars = {jarOf("com.formdev.flatlaf.FlatLaf"), jarOf("com.formdev.flatlaf.extras.FlatAnimatedLafChange")};
+        for (File jar : jars) {
+            ZipFile zip = new ZipFile(jar);
+            try {
+                Enumeration<? extends ZipEntry> entries = zip.entries();
+                while (entries.hasMoreElements()) {
+                    String entry = entries.nextElement().getName();
+                    if (entry.startsWith("com/formdev/") && entry.endsWith(".class") && entry.indexOf('$') < 0) {
+                        theirs.add(entry.substring(0, entry.length() - 6).replace('/', '.'));
+                    }
+                }
+            } finally {
+                zip.close();
+            }
+        }
+        assertTrue("the real jars were read", theirs.size() > 100);
+        for (String name : theirs) {
+            if (ours.contains(name) || absent.contains(name)) {
+                continue;
+            }
+            boolean whole = false;
+            for (String p : packages) {
+                whole |= name.startsWith(p) && name.indexOf('.', p.length()) < 0;
+            }
+            Class<?> c = whole ? null : real(name);
+            if (!whole && c != null && Modifier.isPublic(c.getModifiers())) {
+                problems.add(name + ": a public FlatLaf class that is neither in the layer nor in flatlaf-absent.txt");
+            }
+        }
+        for (String name : absent) {
+            if (ours.contains(name)) {
+                problems.add(name + ": named in flatlaf-absent.txt, and the layer has it");
+            } else if (!theirs.contains(name)) {
+                problems.add(name + ": named in flatlaf-absent.txt, and FlatLaf has no such class");
+            }
+        }
+        if (!problems.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(problems.size()).append(" FlatLaf API shape problem(s):\n");
+            for (String p : problems) {
+                sb.append("  ").append(p).append('\n');
+            }
+            fail(sb.toString());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/CreatedFontTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/CreatedFontTest.java
new file mode 100644
index 00000000000..cd40c5fd7a7
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/CreatedFontTest.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.impl.compat.Resources;
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.rt.FontFiles;
+import com.codename1.desktopcompat.rt.Fonts;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/// A font the application carries: `Font.createFont` reads a stream of
+/// it, finds the resource the bytes are, and the font -- at any size
+/// derived from it, and by its family once registered -- is drawn with
+/// the file. The font is the Material Icons file the framework ships.
+public class CreatedFontTest extends KernelTestBase {
+
+    private static final String PATH = "com/example/fonts/Icons.ttf";
+    private static final String FLAT = "com__example__fonts__Icons.ttf";
+
+    private final List<String> opened = new ArrayList<String>();
+
+    private static byte[] fontBytes() throws IOException {
+        InputStream in = CreatedFontTest.class.getResourceAsStream("/material-design-font.ttf");
+        assertNotNull("the framework's icon font is on the class path", in);
+        try {
+            return FontFiles.readAll(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    @Before
+    public void shipTheFont() throws IOException {
+        final byte[] font = fontBytes();
+        FontFiles.reset();
+        Resources.cn1BeginIndex();
+        Resources.cn1AddResource(PATH);
+        Resources.cn1AddResource("com/example/readme.txt");
+        Resources.cn1SetProvider(new Resources.Provider() {
+            @Override
+            public InputStream open(String flatName) {
+                opened.add(flatName);
+                return FLAT.equals(flatName) ? new ByteArrayInputStream(font) : null;
+            }
+        });
+    }
+
+    @After
+    public void forget() {
+        Resources.cn1SetProvider(null);
+        Resources.cn1ClearIndex();
+        FontFiles.reset();
+    }
+
+    @Test
+    public void aStreamOfAFontFileMakesAFontNamedAsTheFileNamesItself() throws Exception {
+        Font font = Font.createFont(Font.TRUETYPE_FONT, new ByteArrayInputStream(fontBytes()));
+        assertEquals("Material Icons", font.getFamily());
+        assertEquals(1, font.getSize());
+        assertTrue(font.isPlain());
+        FontFiles.Face face = font.cn1Face();
+        assertNotNull(face);
+        // The platform is handed the flat name the build shipped, and the
+        // name the font is installed under.
+        assertEquals(FLAT, face.file());
+        assertEquals("MaterialIcons-Regular", face.postScriptName());
+        assertNotNull("the platform opened the file", face.base());
+        assertEquals("only font resources are read", Arrays.asList(FLAT), opened);
+    }
+
+    @Test
+    public void aDerivedFontKeepsTheFaceAndASystemFontHasNone() throws Exception {
+        Font font = Font.createFont(Font.TRUETYPE_FONT, new ByteArrayInputStream(fontBytes()));
+        Font big = font.deriveFont(24f);
+        assertEquals(24, big.getSize());
+        assertSame(font.cn1Face(), big.cn1Face());
+        assertSame(font.cn1Face(), big.deriveFont(Font.BOLD).cn1Face());
+        assertSame(font.cn1Face(), big.deriveFont(Font.ITALIC, 30f).cn1Face());
+        assertEquals("Material Icons", big.getFamily());
+        assertNull(new Font("Dialog", Font.PLAIN, 24).cn1Face());
+        assertFalse(big.equals(new Font(big.getName(), Font.PLAIN, 24)));
+        assertEquals(big, font.deriveFont(24f));
+        // The same face at the same size is one platform font; another
+        // size is another.
+        com.codename1.ui.Font a = Fonts.nativeFont(big, 48);
+        assertNotNull(a);
+        assertSame(a, Fonts.nativeFont(font.deriveFont(24f), 48));
+        assertNotNull(Toolkit.getDefaultToolkit().getFontMetrics(big));
+    }
+
+    @Test
+    public void aRegisteredFontIsFoundByItsFamily() throws Exception {
+        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+        assertNull(new Font("Material Icons", Font.PLAIN, 16).cn1Face());
+        assertFalse("not a created font", ge.registerFont(new Font("Dialog", Font.PLAIN, 12)));
+        Font font = Font.createFont(Font.TRUETYPE_FONT, new ByteArrayInputStream(fontBytes()));
+        assertFalse(Arrays.asList(ge.getAvailableFontFamilyNames()).contains("Material Icons"));
+        assertTrue(ge.registerFont(font));
+        assertTrue(Arrays.asList(ge.getAvailableFontFamilyNames()).contains("Material Icons"));
+        assertSame(font.cn1Face(), new Font("Material Icons", Font.PLAIN, 16).cn1Face());
+        assertSame("names are matched without regard to case", font.cn1Face(),
+                new Font("material icons", Font.BOLD, 16).cn1Face());
+        assertTrue("again is no clash", ge.registerFont(font.deriveFont(9f)));
+    }
+
+    @Test
+    public void whatIsNoFontIsRefused() throws IOException {
+        try {
+            Font.createFont(Font.TRUETYPE_FONT, new ByteArrayInputStream(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+                11, 12, 13}));
+            fail("not a font");
+        } catch (FontFormatException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            Font.createFont(Font.TYPE1_FONT, new ByteArrayInputStream(fontBytes()));
+            fail("Type 1 is not read");
+        } catch (FontFormatException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            Font.createFont(7, new ByteArrayInputStream(fontBytes()));
+            fail("no such format");
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        } catch (FontFormatException wrong) {
+            fail("an unknown format is an argument error");
+        }
+        assertNull(FontFiles.parse(new byte[0]));
+        assertNull(FontFiles.parse(new byte[64]));
+    }
+
+    @Test
+    public void bytesNoResourceMatchesStillMakeAFontWithItsNames() throws Exception {
+        Resources.cn1ClearIndex();
+        FontFiles.reset();
+        Font font = Font.createFont(Font.TRUETYPE_FONT, new ByteArrayInputStream(fontBytes()));
+        assertEquals("Material Icons", font.getFamily());
+        assertNull(font.cn1Face().file());
+        assertNull("drawn with the platform's typeface", font.cn1Face().base());
+        assertNotNull(Fonts.nativeFont(font.deriveFont(20f), 40));
+    }
+
+    /// Paints one glyph of the font in red.
+    private static final class Glyph extends JPanel {
+
+        final Font font;
+        final String glyph = String.valueOf((char) 0xe5cd);
+
+        Glyph(Font font) {
+            this.font = font;
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            g.setColor(Color.white);
+            g.fillRect(0, 0, getWidth(), getHeight());
+            g.setFont(font);
+            g.setColor(Color.red);
+            g.drawString(glyph, 10, 40);
+        }
+    }
+
+    @Test
+    public void aGlyphOfTheFontIsDrawn() throws Exception {
+        Font icons = Font.createFont(Font.TRUETYPE_FONT, new ByteArrayInputStream(fontBytes())).deriveFont(24f);
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        Glyph panel = new Glyph(icons);
+        f.add(panel, BorderLayout.CENTER);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertNotNull("the glyph was handed to the platform", find(text, panel.glyph));
+        int[][] rows = raster(f);
+        assertTrue("and painted in the color set", count(rows, panel, 0, 0, 80, 60, 0xff0000) > 0);
+
+        // The graphics of an image, as an icon pack makes its icons.
+        BufferedImage img = new BufferedImage(32, 32, BufferedImage.TYPE_INT_ARGB);
+        Graphics2D g = GraphicsEnvironment.getLocalGraphicsEnvironment().createGraphics(img);
+        assertNotNull(g);
+        g.setFont(icons);
+        assertSame(icons, g.getFont());
+        g.setColor(Color.red);
+        g.drawString(panel.glyph, 0, 24);
+        g.dispose();
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/ValueParityTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/ValueParityTest.java
new file mode 100644
index 00000000000..e08e53d4960
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/ValueParityTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt;
+
+import com.codename1.desktopcompat.java.awt.geom.Ellipse2D;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.geom.RoundRectangle2D;
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/// Values the JDK's AWT and Swing classes answer, held against the real ones
+/// where this JDK has them.
+public class ValueParityTest {
+
+    private static String decoded(boolean jdk, String text) {
+        try {
+            if (jdk) {
+                java.awt.Color c = java.awt.Color.decode(text);
+                return c.getRed() + "," + c.getGreen() + "," + c.getBlue();
+            }
+            Color c = Color.decode(text);
+            return c.getRed() + "," + c.getGreen() + "," + c.getBlue();
+        } catch (NumberFormatException e) {
+            return "NumberFormatException";
+        }
+    }
+
+    /// `Color.decode` reads a number as `Integer.decode` does: a sign before
+    /// the prefix, and nothing beyond a signed 32-bit int.
+    @Test
+    public void decodeReadsNumbersAsTheJdkDoes() {
+        String[] cases = {"0xFF0000", "#00ff00", "255", "010", "0", "-0x1", "+0xFF0000", "-#10", "-1", "+12",
+            "0x100000000", "4294967296", "-0x80000000", "0x7fffffff", "--1", "-+1", "0x-1", "#", "-", "", "0x",
+            " 1", "1 ", "+"};
+        for (String c : cases) {
+            assertEquals("\"" + c + "\"", decoded(true, c), decoded(false, c));
+        }
+    }
+
+    private static final class Row extends RowFilter.Entry<Object, Integer> {
+        private final Object value;
+
+        Row(Object value) {
+            this.value = value;
+        }
+
+        @Override
+        public Object getModel() {
+            return null;
+        }
+
+        @Override
+        public int getValueCount() {
+            return 1;
+        }
+
+        @Override
+        public Object getValue(int index) {
+            return value;
+        }
+
+        @Override
+        public Integer getIdentifier() {
+            return 0;
+        }
+    }
+
+    /// Two numbers of one class compare as that class does: past 2^53 a
+    /// double no longer tells neighbours apart.
+    @Test
+    public void aNumberFilterComparesBigNumbersExactly() {
+        BigInteger big = new BigInteger("9007199254740992");
+        RowFilter<Object, Integer> equal = RowFilter.numberFilter(RowFilter.ComparisonType.EQUAL, big, 0);
+        assertTrue(equal.include(new Row(new BigInteger("9007199254740992"))));
+        assertFalse(equal.include(new Row(new BigInteger("9007199254740993"))));
+        RowFilter<Object, Integer> after = RowFilter.numberFilter(RowFilter.ComparisonType.AFTER,
+                new BigDecimal("0.10000000000000000001"), 0);
+        assertTrue(after.include(new Row(new BigDecimal("0.10000000000000000002"))));
+        assertFalse(after.include(new Row(new BigDecimal("0.1"))));
+        // Across classes the comparison is by magnitude, as before.
+        assertTrue(RowFilter.numberFilter(RowFilter.ComparisonType.BEFORE, 3, 0).include(new Row(2.5)));
+        assertTrue(RowFilter.numberFilter(RowFilter.ComparisonType.EQUAL, 3, 0).include(new Row(3L)));
+    }
+
+    /// A shape of negative size has no outline: the JDK's iterator is done
+    /// at once, and the empty intersection of two rectangles is one.
+    @Test
+    public void aNegativeSizeHasNoOutline() {
+        Rectangle2D none = new Rectangle2D.Double(0, 0, 10, 10)
+                .createIntersection(new Rectangle2D.Double(20, 20, 5, 5));
+        assertTrue(none.getWidth() < 0);
+        assertTrue(none.getPathIterator(null).isDone());
+        assertTrue(new Ellipse2D.Double(0, 0, -4, 4).getPathIterator(null).isDone());
+        assertTrue(new RoundRectangle2D.Double(0, 0, 4, -4, 1, 1).getPathIterator(null).isDone());
+        assertTrue(new java.awt.geom.Rectangle2D.Double(0, 0, 10, 10)
+                .createIntersection(new java.awt.geom.Rectangle2D.Double(20, 20, 5, 5))
+                .getPathIterator(null).isDone());
+        assertFalse(new Rectangle2D.Double(0, 0, 0, 0).getPathIterator(null).isDone());
+        assertFalse(new java.awt.geom.Rectangle2D.Double(0, 0, 0, 0).getPathIterator(null).isDone());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/geom/GeomParityTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/geom/GeomParityTest.java
new file mode 100644
index 00000000000..b6211a70f35
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/awt/geom/GeomParityTest.java
@@ -0,0 +1,1447 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.awt.geom;
+
+import com.codename1.compat.testing.ReferenceJdk;
+
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.Shape;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Holds the geometry classes of the layer to the behaviour of the JDK
+/// classes they stand in for.
+///
+/// Every check builds the same object twice, once from this package and once
+/// from the real `java.awt.geom`, feeds both the same deterministic inputs and
+/// compares what comes back: matrices and outline coordinates within a
+/// tolerance, classifications and hit tests exactly.
+public class GeomParityTest {
+
+    private static final double TOL = 1e-9;
+    private static final double FLOAT_TOL = 1e-4;
+
+    // ---------------------------------------------------------------- transforms
+
+    /// One step of a transform recipe, applied alike to both implementations.
+    private static final int TRANSLATE = 0;
+    private static final int SCALE = 1;
+    private static final int ROTATE = 2;
+    private static final int SHEAR = 3;
+    private static final int ROTATE_ABOUT = 4;
+    private static final int ROTATE_VEC = 5;
+    private static final int ROTATE_VEC_ABOUT = 6;
+    private static final int QUADRANT = 7;
+    private static final int QUADRANT_ABOUT = 8;
+    private static final int CONCAT = 9;
+    private static final int PRECONCAT = 10;
+    private static final int SET_ROTATION = 11;
+    private static final int SET_ROTATION_ABOUT = 12;
+    private static final int SET_ROTATION_VEC = 13;
+    private static final int SET_ROTATION_VEC_ABOUT = 14;
+    private static final int SET_QUADRANT = 15;
+    private static final int SET_QUADRANT_ABOUT = 16;
+    private static final int SET_SCALE = 17;
+    private static final int SET_SHEAR = 18;
+    private static final int SET_TRANSLATION = 19;
+    private static final int SET_MATRIX = 20;
+    private static final int INVERT = 21;
+
+    private static final double[][][] RECIPES = {
+        {},
+        {{TRANSLATE, 3, -4}},
+        {{TRANSLATE, 0, 0}},
+        {{SCALE, 2, 2}},
+        {{SCALE, 2, 3}},
+        {{SCALE, -1, 1}},
+        {{SCALE, 1, -1}},
+        {{SCALE, -1, -1}},
+        {{SCALE, -2, -2}},
+        {{SCALE, -2, 3}},
+        {{SCALE, 2, -2}},
+        {{SCALE, 1, 1}},
+        {{ROTATE, Math.PI / 2}},
+        {{ROTATE, Math.PI}},
+        {{ROTATE, -Math.PI / 2}},
+        {{ROTATE, 3 * Math.PI / 2}},
+        {{ROTATE, 2 * Math.PI}},
+        {{ROTATE, 0}},
+        {{ROTATE, 0.3}},
+        {{ROTATE, -2.1}},
+        {{ROTATE, 0.3}, {SCALE, 2, 2}},
+        {{ROTATE, 0.3}, {SCALE, 2, 3}},
+        {{ROTATE, 0.3}, {SCALE, -1, 1}},
+        {{ROTATE, 0.3}, {SCALE, -2, 2}},
+        {{ROTATE, 1.1}, {SCALE, 1, -3}},
+        {{ROTATE, Math.PI / 2}, {SCALE, 2, 2}},
+        {{ROTATE, Math.PI / 2}, {SCALE, 2, -2}},
+        {{ROTATE, Math.PI / 2}, {SCALE, 2, 5}},
+        {{ROTATE, Math.PI / 2}, {SCALE, -2, 5}},
+        {{SHEAR, 0.5, 0}},
+        {{SHEAR, 0.5, -0.25}},
+        {{SHEAR, 0, 0}},
+        {{TRANSLATE, 5, 6}, {ROTATE, 0.7}, {SCALE, 1.5, 0.5}, {SHEAR, 0.2, 0.1}},
+        {{ROTATE_ABOUT, 0.9, 4, 5}},
+        {{ROTATE_ABOUT, Math.PI / 2, 4, 5}},
+        {{TRANSLATE, 1, 2}, {ROTATE_ABOUT, -0.4, 7, -3}},
+        {{ROTATE_VEC, 3, 4}},
+        {{ROTATE_VEC, 0, 4}},
+        {{ROTATE_VEC, 0, -4}},
+        {{ROTATE_VEC, -2, 0}},
+        {{ROTATE_VEC, 2, 0}},
+        {{ROTATE_VEC, 0, 0}},
+        {{SCALE, 2, 3}, {ROTATE_VEC, -1, 2}},
+        {{ROTATE_VEC_ABOUT, 3, 4, 2, 9}},
+        {{ROTATE_VEC_ABOUT, 0, -1, 2, 9}},
+        {{QUADRANT, 0}},
+        {{QUADRANT, 1}},
+        {{QUADRANT, 2}},
+        {{QUADRANT, 3}},
+        {{QUADRANT, 5}},
+        {{QUADRANT, -1}},
+        {{SCALE, 2, 3}, {QUADRANT, 1}},
+        {{QUADRANT_ABOUT, 1, 5, 7}},
+        {{QUADRANT_ABOUT, 2, 5, 7}},
+        {{QUADRANT_ABOUT, 3, 5, 7}},
+        {{SHEAR, 0.3, 0.2}, {QUADRANT_ABOUT, 3, 5, 7}},
+        {{TRANSLATE, 2, 3}, {CONCAT, 1, 0.5, -0.25, 2, 4, 5}},
+        {{ROTATE, 0.4}, {PRECONCAT, 1, 0.5, -0.25, 2, 4, 5}},
+        {{SCALE, 3, 3}, {PRECONCAT, 0, 1, -1, 0, 0, 0}},
+        {{SHEAR, 1, 1}, {SET_ROTATION, 0.6}},
+        {{SET_ROTATION, Math.PI}},
+        {{SET_ROTATION_ABOUT, 0.6, 3, 2}},
+        {{SET_ROTATION_ABOUT, Math.PI, 3, 2}},
+        {{SET_ROTATION_VEC, 5, -12}},
+        {{SET_ROTATION_VEC, 0, 0}},
+        {{SET_ROTATION_VEC_ABOUT, 5, -12, 1, 1}},
+        {{SET_ROTATION_VEC_ABOUT, -7, 0, 1, 1}},
+        {{SET_QUADRANT, 1}},
+        {{SET_QUADRANT, 6}},
+        {{SET_QUADRANT_ABOUT, 1, 5, 7}},
+        {{SET_QUADRANT_ABOUT, 3, -5, 7}},
+        {{SET_SCALE, 4, 4}},
+        {{SET_SCALE, 4, 0.25}},
+        {{SET_SHEAR, 0.5, 2}},
+        {{SET_TRANSLATION, 8, 9}},
+        {{SET_MATRIX, 0, 1, 1, 0, 0, 0}},
+        {{SET_MATRIX, 0, 2, 2, 0, 0, 0}},
+        {{SET_MATRIX, 0, -3, 3, 0, 1, 0}},
+        {{SET_MATRIX, 0, 3, -3, 0, 0, 0}},
+        {{SET_MATRIX, 0, 2, -3, 0, 0, 0}},
+        {{SET_MATRIX, 0, -1, -1, 0, 0, 0}},
+        {{SET_MATRIX, 0, -2, -5, 0, 0, 0}},
+        {{SET_MATRIX, 0, 0, 0, 0, 0, 0}},
+        {{SET_MATRIX, 2, 0, 0, 0, 0, 0}},
+        {{SET_MATRIX, 0, 0, 0, 3, 0, 0}},
+        {{SET_MATRIX, 0, 0, 2, 0, 0, 0}},
+        {{SET_MATRIX, 1, 2, 3, 4, 5, 6}},
+        {{SET_MATRIX, 3, 4, -4, 3, 0, 0}},
+        {{SET_MATRIX, 3, 4, 4, -3, 0, 0}},
+        {{SET_MATRIX, 0.6, 0.8, -0.8, 0.6, 0, 0}},
+        {{SET_MATRIX, 0.6, 0.8, 0.8, -0.6, 0, 0}},
+        {{SET_MATRIX, 2, 1, -2, 4, 0, 0}},
+        {{SET_MATRIX, -2, 1, 2, 4, 0, 0}},
+        {{TRANSLATE, 5, 6}, {ROTATE, 0.7}, {SCALE, 1.5, 0.5}, {INVERT}},
+        {{SCALE, 4, 4}, {INVERT}},
+        {{QUADRANT_ABOUT, 1, 5, 7}, {INVERT}},
+    };
+
+    private static void apply(double[] op, AffineTransform ours, java.awt.geom.AffineTransform real)
+            throws Exception {
+        switch ((int) op[0]) {
+            case TRANSLATE:
+                ours.translate(op[1], op[2]);
+                real.translate(op[1], op[2]);
+                break;
+            case SCALE:
+                ours.scale(op[1], op[2]);
+                real.scale(op[1], op[2]);
+                break;
+            case ROTATE:
+                ours.rotate(op[1]);
+                real.rotate(op[1]);
+                break;
+            case SHEAR:
+                ours.shear(op[1], op[2]);
+                real.shear(op[1], op[2]);
+                break;
+            case ROTATE_ABOUT:
+                ours.rotate(op[1], op[2], op[3]);
+                real.rotate(op[1], op[2], op[3]);
+                break;
+            case ROTATE_VEC:
+                ours.rotate(op[1], op[2]);
+                real.rotate(op[1], op[2]);
+                break;
+            case ROTATE_VEC_ABOUT:
+                ours.rotate(op[1], op[2], op[3], op[4]);
+                real.rotate(op[1], op[2], op[3], op[4]);
+                break;
+            case QUADRANT:
+                ours.quadrantRotate((int) op[1]);
+                real.quadrantRotate((int) op[1]);
+                break;
+            case QUADRANT_ABOUT:
+                ours.quadrantRotate((int) op[1], op[2], op[3]);
+                real.quadrantRotate((int) op[1], op[2], op[3]);
+                break;
+            case CONCAT:
+                ours.concatenate(new AffineTransform(op[1], op[2], op[3], op[4], op[5], op[6]));
+                real.concatenate(new java.awt.geom.AffineTransform(op[1], op[2], op[3], op[4], op[5], op[6]));
+                break;
+            case PRECONCAT:
+                ours.preConcatenate(new AffineTransform(op[1], op[2], op[3], op[4], op[5], op[6]));
+                real.preConcatenate(new java.awt.geom.AffineTransform(op[1], op[2], op[3], op[4], op[5], op[6]));
+                break;
+            case SET_ROTATION:
+                ours.setToRotation(op[1]);
+                real.setToRotation(op[1]);
+                break;
+            case SET_ROTATION_ABOUT:
+                ours.setToRotation(op[1], op[2], op[3]);
+                real.setToRotation(op[1], op[2], op[3]);
+                break;
+            case SET_ROTATION_VEC:
+                ours.setToRotation(op[1], op[2]);
+                real.setToRotation(op[1], op[2]);
+                break;
+            case SET_ROTATION_VEC_ABOUT:
+                ours.setToRotation(op[1], op[2], op[3], op[4]);
+                real.setToRotation(op[1], op[2], op[3], op[4]);
+                break;
+            case SET_QUADRANT:
+                ours.setToQuadrantRotation((int) op[1]);
+                real.setToQuadrantRotation((int) op[1]);
+                break;
+            case SET_QUADRANT_ABOUT:
+                ours.setToQuadrantRotation((int) op[1], op[2], op[3]);
+                real.setToQuadrantRotation((int) op[1], op[2], op[3]);
+                break;
+            case SET_SCALE:
+                ours.setToScale(op[1], op[2]);
+                real.setToScale(op[1], op[2]);
+                break;
+            case SET_SHEAR:
+                ours.setToShear(op[1], op[2]);
+                real.setToShear(op[1], op[2]);
+                break;
+            case SET_TRANSLATION:
+                ours.setToTranslation(op[1], op[2]);
+                real.setToTranslation(op[1], op[2]);
+                break;
+            case SET_MATRIX:
+                ours.setTransform(op[1], op[2], op[3], op[4], op[5], op[6]);
+                real.setTransform(op[1], op[2], op[3], op[4], op[5], op[6]);
+                break;
+            case INVERT:
+                ours.invert();
+                real.invert();
+                break;
+            default:
+                fail("unknown recipe step " + op[0]);
+                break;
+        }
+    }
+
+    private static void assertSameMatrix(String label, AffineTransform ours, java.awt.geom.AffineTransform real) {
+        double[] a = new double[6];
+        double[] b = new double[6];
+        ours.getMatrix(a);
+        real.getMatrix(b);
+        for (int i = 0; i < 6; i++) {
+            assertEquals(label + " matrix[" + i + "]", b[i], a[i], TOL * Math.max(1.0, Math.abs(b[i])));
+        }
+        assertEquals(label + " scaleX", real.getScaleX(), ours.getScaleX(), TOL);
+        assertEquals(label + " scaleY", real.getScaleY(), ours.getScaleY(), TOL);
+        assertEquals(label + " shearX", real.getShearX(), ours.getShearX(), TOL);
+        assertEquals(label + " shearY", real.getShearY(), ours.getShearY(), TOL);
+        assertEquals(label + " translateX", real.getTranslateX(), ours.getTranslateX(), TOL);
+        assertEquals(label + " translateY", real.getTranslateY(), ours.getTranslateY(), TOL);
+    }
+
+    @Test
+    public void affineTransformMatchesTheJdk() throws Exception {
+        double[] pts = {0, 0, 1, 0, 0, 1, -3.5, 2.25, 100, -40, 0.001, 7};
+        for (int r = 0; r < RECIPES.length; r++) {
+            String label = "recipe " + r;
+            AffineTransform ours = new AffineTransform();
+            java.awt.geom.AffineTransform real = new java.awt.geom.AffineTransform();
+            for (double[] op : RECIPES[r]) {
+                apply(op, ours, real);
+            }
+            assertSameMatrix(label, ours, real);
+            assertEquals(label + " type", real.getType(), ours.getType());
+            assertEquals(label + " identity", real.isIdentity(), ours.isIdentity());
+            assertEquals(label + " determinant", real.getDeterminant(), ours.getDeterminant(),
+                    TOL * Math.max(1.0, Math.abs(real.getDeterminant())));
+
+            double[] a = new double[pts.length];
+            double[] b = new double[pts.length];
+            ours.transform(pts, 0, a, 0, pts.length / 2);
+            real.transform(pts, 0, b, 0, pts.length / 2);
+            assertArrayNear(label + " transform", b, a, TOL);
+            ours.deltaTransform(pts, 0, a, 0, pts.length / 2);
+            real.deltaTransform(pts, 0, b, 0, pts.length / 2);
+            assertArrayNear(label + " deltaTransform", b, a, TOL);
+
+            float[] fsrc = new float[pts.length];
+            for (int i = 0; i < pts.length; i++) {
+                fsrc[i] = (float) pts[i];
+            }
+            float[] fa = new float[pts.length];
+            float[] fb = new float[pts.length];
+            ours.transform(fsrc, 0, fa, 0, pts.length / 2);
+            real.transform(fsrc, 0, fb, 0, pts.length / 2);
+            for (int i = 0; i < pts.length; i++) {
+                assertEquals(label + " float transform " + i, fb[i], fa[i], FLOAT_TOL * Math.max(1f, Math.abs(fb[i])));
+            }
+            ours.transform(pts, 0, fa, 0, pts.length / 2);
+            real.transform(pts, 0, fb, 0, pts.length / 2);
+            for (int i = 0; i < pts.length; i++) {
+                assertEquals(label + " mixed transform " + i, fb[i], fa[i], FLOAT_TOL * Math.max(1f, Math.abs(fb[i])));
+            }
+            ours.transform(fsrc, 0, a, 0, pts.length / 2);
+            real.transform(fsrc, 0, b, 0, pts.length / 2);
+            assertArrayNear(label + " float to double transform", b, a, TOL);
+
+            Point2D p = ours.transform(new Point2D.Double(2.5, -1.5), null);
+            java.awt.geom.Point2D q = real.transform(new java.awt.geom.Point2D.Double(2.5, -1.5), null);
+            assertTrue(label, p instanceof Point2D.Double);
+            assertEquals(label + " point x", q.getX(), p.getX(), TOL);
+            assertEquals(label + " point y", q.getY(), p.getY(), TOL);
+            p = ours.deltaTransform(new Point2D.Float(2.5f, -1.5f), null);
+            q = real.deltaTransform(new java.awt.geom.Point2D.Float(2.5f, -1.5f), null);
+            assertTrue(label, p instanceof Point2D.Float);
+            assertEquals(label + " delta x", q.getX(), p.getX(), FLOAT_TOL);
+            assertEquals(label + " delta y", q.getY(), p.getY(), FLOAT_TOL);
+
+            boolean realInvertible = true;
+            java.awt.geom.AffineTransform realInverse = null;
+            try {
+                realInverse = real.createInverse();
+            } catch (java.awt.geom.NoninvertibleTransformException e) {
+                realInvertible = false;
+            }
+            boolean oursInvertible = true;
+            AffineTransform oursInverse = null;
+            try {
+                oursInverse = ours.createInverse();
+            } catch (NoninvertibleTransformException e) {
+                oursInvertible = false;
+            }
+            assertEquals(label + " invertible", realInvertible, oursInvertible);
+            if (realInvertible) {
+                assertSameMatrix(label + " inverse", oursInverse, realInverse);
+                ours.inverseTransform(pts, 0, a, 0, pts.length / 2);
+                real.inverseTransform(pts, 0, b, 0, pts.length / 2);
+                assertArrayNear(label + " inverseTransform", b, a, TOL);
+                p = ours.inverseTransform(new Point2D.Double(2.5, -1.5), null);
+                q = real.inverseTransform(new java.awt.geom.Point2D.Double(2.5, -1.5), null);
+                assertEquals(label + " inverse point x", q.getX(), p.getX(), TOL * Math.max(1.0, Math.abs(q.getX())));
+                assertEquals(label + " inverse point y", q.getY(), p.getY(), TOL * Math.max(1.0, Math.abs(q.getY())));
+            }
+        }
+    }
+
+    @Test
+    public void affineTransformFactoriesAndValueSemantics() throws Exception {
+        assertSameMatrix("translate", AffineTransform.getTranslateInstance(3, 4),
+                java.awt.geom.AffineTransform.getTranslateInstance(3, 4));
+        assertSameMatrix("rotate", AffineTransform.getRotateInstance(0.8),
+                java.awt.geom.AffineTransform.getRotateInstance(0.8));
+        assertSameMatrix("rotate about", AffineTransform.getRotateInstance(0.8, 5, 6),
+                java.awt.geom.AffineTransform.getRotateInstance(0.8, 5, 6));
+        assertSameMatrix("rotate vec", AffineTransform.getRotateInstance(2.0, -7.0),
+                java.awt.geom.AffineTransform.getRotateInstance(2.0, -7.0));
+        assertSameMatrix("rotate vec about", AffineTransform.getRotateInstance(2.0, -7.0, 5, 6),
+                java.awt.geom.AffineTransform.getRotateInstance(2.0, -7.0, 5, 6));
+        assertSameMatrix("quadrant", AffineTransform.getQuadrantRotateInstance(3),
+                java.awt.geom.AffineTransform.getQuadrantRotateInstance(3));
+        assertSameMatrix("quadrant about", AffineTransform.getQuadrantRotateInstance(3, 5, 6),
+                java.awt.geom.AffineTransform.getQuadrantRotateInstance(3, 5, 6));
+        assertSameMatrix("scale", AffineTransform.getScaleInstance(3, 4),
+                java.awt.geom.AffineTransform.getScaleInstance(3, 4));
+        assertSameMatrix("shear", AffineTransform.getShearInstance(3, 4),
+                java.awt.geom.AffineTransform.getShearInstance(3, 4));
+        assertSameMatrix("floats", new AffineTransform(new float[] {1, 2, 3, 4, 5, 6}),
+                new java.awt.geom.AffineTransform(new float[] {1, 2, 3, 4, 5, 6}));
+        assertSameMatrix("four doubles", new AffineTransform(new double[] {1, 2, 3, 4}),
+                new java.awt.geom.AffineTransform(new double[] {1, 2, 3, 4}));
+        assertSameMatrix("six floats", new AffineTransform(1f, 2f, 3f, 4f, 5f, 6f),
+                new java.awt.geom.AffineTransform(1f, 2f, 3f, 4f, 5f, 6f));
+
+        AffineTransform a = new AffineTransform(1, 2, 3, 4, 5, 6);
+        Object copy = a.clone();
+        assertTrue(copy instanceof AffineTransform);
+        assertEquals(a, copy);
+        assertEquals(a.hashCode(), copy.hashCode());
+        assertFalse(a.equals(new AffineTransform()));
+        assertEquals(new AffineTransform(a), a);
+        a.setToIdentity();
+        assertTrue(a.isIdentity());
+
+        // a destination that overlaps the source further along must not
+        // read values it has already overwritten
+        double[] ours = {1, 2, 3, 4, 5, 6, 0, 0};
+        double[] real = ours.clone();
+        new AffineTransform(2, 0, 0, 3, 1, 1).transform(ours, 0, ours, 2, 3);
+        new java.awt.geom.AffineTransform(2, 0, 0, 3, 1, 1).transform(real, 0, real, 2, 3);
+        assertArrayNear("overlap", real, ours, TOL);
+
+        Point2D[] src = {new Point2D.Double(1, 2), new Point2D.Float(3, 4)};
+        Point2D[] dst = new Point2D[2];
+        new AffineTransform(2, 0, 0, 3, 1, 1).transform(src, 0, dst, 0, 2);
+        assertEquals(new Point2D.Double(3, 7), dst[0]);
+        assertTrue(dst[1] instanceof Point2D.Float);
+        assertEquals(7.0, dst[1].getX(), 0.0);
+        assertEquals(13.0, dst[1].getY(), 0.0);
+
+        assertNull(new AffineTransform().createTransformedShape(null));
+        Shape moved = AffineTransform.getTranslateInstance(10, 20)
+                .createTransformedShape(new Rectangle2D.Double(1, 2, 3, 4));
+        java.awt.Shape realMoved = java.awt.geom.AffineTransform.getTranslateInstance(10, 20)
+                .createTransformedShape(new java.awt.geom.Rectangle2D.Double(1, 2, 3, 4));
+        assertSamePath("transformed shape", moved.getPathIterator(null), realMoved.getPathIterator(null), TOL);
+    }
+
+    private static void assertArrayNear(String label, double[] expected, double[] actual, double tol) {
+        assertEquals(label + " length", expected.length, actual.length);
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals(label + "[" + i + "]", expected[i], actual[i], tol * Math.max(1.0, Math.abs(expected[i])));
+        }
+    }
+
+    // ---------------------------------------------------------------- outlines
+
+    private static void assertSamePath(String label, PathIterator ours, java.awt.geom.PathIterator real, double tol) {
+        assertEquals(label + " winding rule", real.getWindingRule(), ours.getWindingRule());
+        double[] a = new double[6];
+        double[] b = new double[6];
+        float[] fa = new float[6];
+        int index = 0;
+        while (!real.isDone()) {
+            assertFalse(label + ": ours ended at segment " + index, ours.isDone());
+            int realType = real.currentSegment(b);
+            int oursType = ours.currentSegment(a);
+            assertEquals(label + " type of segment " + index, realType, oursType);
+            assertEquals(label + " float type of segment " + index, realType, ours.currentSegment(fa));
+            int n = realType == java.awt.geom.PathIterator.SEG_CLOSE ? 0
+                    : realType == java.awt.geom.PathIterator.SEG_QUADTO ? 4
+                    : realType == java.awt.geom.PathIterator.SEG_CUBICTO ? 6 : 2;
+            for (int i = 0; i < n; i++) {
+                assertEquals(label + " segment " + index + " value " + i, b[i], a[i], tol);
+                assertEquals(label + " segment " + index + " float value " + i, (float) a[i], fa[i],
+                        1e-6f * Math.max(1f, Math.abs(fa[i])));
+            }
+            real.next();
+            ours.next();
+            index++;
+        }
+        assertTrue(label + ": ours has more than " + index + " segments", ours.isDone());
+    }
+
+    private static AffineTransform[] oursTransforms() {
+        return new AffineTransform[] {null, new AffineTransform(1.5, 0.25, -0.5, 2.0, 7.0, -3.0)};
+    }
+
+    private static java.awt.geom.AffineTransform[] realTransforms() {
+        return new java.awt.geom.AffineTransform[] {null,
+            new java.awt.geom.AffineTransform(1.5, 0.25, -0.5, 2.0, 7.0, -3.0)};
+    }
+
+    private static void assertSameOutline(String label, Shape ours, java.awt.Shape real, double tol) {
+        AffineTransform[] a = oursTransforms();
+        java.awt.geom.AffineTransform[] b = realTransforms();
+        for (int i = 0; i < a.length; i++) {
+            assertSamePath(label + (i == 0 ? "" : " transformed"), ours.getPathIterator(a[i]),
+                    real.getPathIterator(b[i]), tol);
+        }
+    }
+
+    private static final double[][] FRAMES = {
+        {1, 2, 10, 6}, {-5.5, 3.25, 4, 9}, {0, 0, 1, 1}, {3, 3, 0, 5}, {2, 2, 7, 0}, {100, -200, 0.5, 300},
+    };
+
+    @Test
+    public void rectangleLineAndEllipseOutlinesMatchTheJdk() {
+        for (double[] f : FRAMES) {
+            String label = "frame " + f[0] + "," + f[1] + "," + f[2] + "," + f[3];
+            assertSameOutline("rectangle " + label, new Rectangle2D.Double(f[0], f[1], f[2], f[3]),
+                    new java.awt.geom.Rectangle2D.Double(f[0], f[1], f[2], f[3]), TOL);
+            assertSameOutline("float rectangle " + label,
+                    new Rectangle2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3]),
+                    new java.awt.geom.Rectangle2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3]),
+                    FLOAT_TOL);
+            assertSameOutline("ellipse " + label, new Ellipse2D.Double(f[0], f[1], f[2], f[3]),
+                    new java.awt.geom.Ellipse2D.Double(f[0], f[1], f[2], f[3]), TOL);
+            assertSameOutline("float ellipse " + label,
+                    new Ellipse2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3]),
+                    new java.awt.geom.Ellipse2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3]),
+                    FLOAT_TOL);
+            assertSameOutline("line " + label, new Line2D.Double(f[0], f[1], f[2], f[3]),
+                    new java.awt.geom.Line2D.Double(f[0], f[1], f[2], f[3]), TOL);
+            assertSameOutline("float line " + label,
+                    new Line2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3]),
+                    new java.awt.geom.Line2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3]),
+                    FLOAT_TOL);
+            assertSameOutline("integer rectangle " + label,
+                    new Rectangle((int) f[0], (int) f[1], (int) f[2], (int) f[3]),
+                    new java.awt.Rectangle((int) f[0], (int) f[1], (int) f[2], (int) f[3]), TOL);
+        }
+        assertSameOutline("quad", new QuadCurve2D.Double(1, 2, 3, 9, 8, 4),
+                new java.awt.geom.QuadCurve2D.Double(1, 2, 3, 9, 8, 4), TOL);
+        assertSameOutline("cubic", new CubicCurve2D.Double(1, 2, 3, 9, 8, 4, 6, -2),
+                new java.awt.geom.CubicCurve2D.Double(1, 2, 3, 9, 8, 4, 6, -2), TOL);
+    }
+
+    private static final double[][] CORNERS = {
+        {0, 0}, {2, 2}, {4, 1}, {1, 5}, {30, 2}, {2, 30}, {40, 40}, {-3, -2}, {-50, 3},
+    };
+
+    @Test
+    public void roundRectangleOutlinesMatchTheJdk() {
+        for (double[] f : FRAMES) {
+            for (double[] c : CORNERS) {
+                String label = "round rectangle " + f[0] + "," + f[1] + "," + f[2] + "," + f[3]
+                        + " arc " + c[0] + "," + c[1];
+                assertSameOutline(label, new RoundRectangle2D.Double(f[0], f[1], f[2], f[3], c[0], c[1]),
+                        new java.awt.geom.RoundRectangle2D.Double(f[0], f[1], f[2], f[3], c[0], c[1]), TOL);
+                assertSameOutline("float " + label,
+                        new RoundRectangle2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3],
+                                (float) c[0], (float) c[1]),
+                        new java.awt.geom.RoundRectangle2D.Float((float) f[0], (float) f[1], (float) f[2],
+                                (float) f[3], (float) c[0], (float) c[1]), FLOAT_TOL);
+            }
+        }
+    }
+
+    private static final double[] STARTS = {0, 30, 90, -45, 200, 370, -400, 180, 12.5};
+    private static final double[] EXTENTS = {90, 45, 135, 180, 270, 360, 400, -90, -200, -360, -500, 0, 10, 91, -179};
+    private static final int[] CLOSURES = {Arc2D.OPEN, Arc2D.CHORD, Arc2D.PIE};
+
+    @Test
+    public void arcOutlinesMatchTheJdk() {
+        assertEquals(java.awt.geom.Arc2D.OPEN, Arc2D.OPEN);
+        assertEquals(java.awt.geom.Arc2D.CHORD, Arc2D.CHORD);
+        assertEquals(java.awt.geom.Arc2D.PIE, Arc2D.PIE);
+        for (double[] f : FRAMES) {
+            for (double start : STARTS) {
+                for (double extent : EXTENTS) {
+                    for (int closure : CLOSURES) {
+                        String label = "arc " + f[0] + "," + f[1] + "," + f[2] + "," + f[3] + " from " + start
+                                + " by " + extent + " closure " + closure;
+                        Arc2D ours = new Arc2D.Double(f[0], f[1], f[2], f[3], start, extent, closure);
+                        java.awt.geom.Arc2D real =
+                                new java.awt.geom.Arc2D.Double(f[0], f[1], f[2], f[3], start, extent, closure);
+                        assertSameOutline(label, ours, real, TOL * Math.max(1.0, Math.abs(f[1])));
+                        assertSameOutline("float " + label,
+                                new Arc2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3],
+                                        (float) start, (float) extent, closure),
+                                new java.awt.geom.Arc2D.Float((float) f[0], (float) f[1], (float) f[2], (float) f[3],
+                                        (float) start, (float) extent, closure), FLOAT_TOL * Math.max(1.0, Math.abs(f[1])));
+                        assertSameRect(label + " bounds", real.getBounds2D(), ours.getBounds2D(), 1e-9);
+                        assertEquals(label + " start x", real.getStartPoint().getX(), ours.getStartPoint().getX(), TOL);
+                        assertEquals(label + " start y", real.getStartPoint().getY(), ours.getStartPoint().getY(), 1e-7);
+                        assertEquals(label + " end x", real.getEndPoint().getX(), ours.getEndPoint().getX(), TOL);
+                        assertEquals(label + " end y", real.getEndPoint().getY(), ours.getEndPoint().getY(), 1e-7);
+                        for (double angle = -725; angle <= 725; angle += 12.5) {
+                            assertEquals(label + " containsAngle " + angle, real.containsAngle(angle),
+                                    ours.containsAngle(angle));
+                        }
+                    }
+                }
+            }
+        }
+        // a frame with a negative size has no outline
+        assertSameOutline("negative arc", new Arc2D.Double(1, 2, -3, 4, 10, 80, Arc2D.PIE),
+                new java.awt.geom.Arc2D.Double(1, 2, -3, 4, 10, 80, java.awt.geom.Arc2D.PIE), TOL);
+    }
+
+    private static void assertSameRect(String label, java.awt.geom.Rectangle2D real, Rectangle2D ours, double tol) {
+        assertEquals(label + " x", real.getX(), ours.getX(), tol * Math.max(1.0, Math.abs(real.getX())));
+        assertEquals(label + " y", real.getY(), ours.getY(), tol * Math.max(1.0, Math.abs(real.getY())));
+        assertEquals(label + " width", real.getWidth(), ours.getWidth(), tol * Math.max(1.0, Math.abs(real.getWidth())));
+        assertEquals(label + " height", real.getHeight(), ours.getHeight(),
+                tol * Math.max(1.0, Math.abs(real.getHeight())));
+    }
+
+    @Test
+    public void arcAnglesFromPointsMatchTheJdk() {
+        double[][] pairs = {{12, 3, 4, 9}, {6, 0, 6, 20}, {-3, 5, 20, 5.5}, {7, 7, 7, 7}, {2, 8, 11, 1}};
+        for (double[] p : pairs) {
+            Arc2D ours = new Arc2D.Double(1, 2, 10, 6, 0, 90, Arc2D.PIE);
+            java.awt.geom.Arc2D real = new java.awt.geom.Arc2D.Double(1, 2, 10, 6, 0, 90, java.awt.geom.Arc2D.PIE);
+            ours.setAngles(p[0], p[1], p[2], p[3]);
+            real.setAngles(p[0], p[1], p[2], p[3]);
+            assertEquals("setAngles start", real.getAngleStart(), ours.getAngleStart(), 1e-7);
+            assertEquals("setAngles extent", real.getAngleExtent(), ours.getAngleExtent(), 1e-7);
+            ours.setAngleStart(new Point2D.Double(p[2], p[3]));
+            real.setAngleStart(new java.awt.geom.Point2D.Double(p[2], p[3]));
+            assertEquals("setAngleStart", real.getAngleStart(), ours.getAngleStart(), 1e-7);
+            ours.setArcByCenter(p[0], p[1], 5, 20, 100, Arc2D.CHORD);
+            real.setArcByCenter(p[0], p[1], 5, 20, 100, java.awt.geom.Arc2D.CHORD);
+            assertSameOutline("by centre", ours, real, TOL);
+            ours.setFrame(1, 1, 4, 4);
+            real.setFrame(1, 1, 4, 4);
+            assertSameOutline("re-framed", ours, real, TOL);
+        }
+        try {
+            new Arc2D.Double(7);
+            fail("an unknown closure must be refused");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage().length() > 0);
+        }
+    }
+
+    // ---------------------------------------------------------------- hit tests
+
+    /// Compares `contains(x, y)` over a grid that covers the shape and a
+    /// margin around it, and returns how many points were inside so a caller
+    /// can tell the grid really exercised the shape.
+    private static int assertSameContains(String label, Shape ours, java.awt.Shape real,
+            double x0, double y0, double x1, double y1) {
+        int inside = 0;
+        for (double y = y0; y <= y1; y += (y1 - y0) / 37.0) {
+            for (double x = x0; x <= x1; x += (x1 - x0) / 41.0) {
+                boolean expected = real.contains(x, y);
+                assertEquals(label + " contains " + x + "," + y, expected, ours.contains(x, y));
+                if (expected) {
+                    inside++;
+                }
+            }
+        }
+        return inside;
+    }
+
+    @Test
+    public void containsPointMatchesTheJdk() {
+        int inside = 0;
+        for (double[] f : FRAMES) {
+            double x0 = f[0] - 1.3;
+            double y0 = f[1] - 1.7;
+            double x1 = f[0] + f[2] + 1.1;
+            double y1 = f[1] + f[3] + 1.9;
+            String label = f[0] + "," + f[1] + "," + f[2] + "," + f[3];
+            inside += assertSameContains("rectangle " + label, new Rectangle2D.Double(f[0], f[1], f[2], f[3]),
+                    new java.awt.geom.Rectangle2D.Double(f[0], f[1], f[2], f[3]), x0, y0, x1, y1);
+            inside += assertSameContains("ellipse " + label, new Ellipse2D.Double(f[0], f[1], f[2], f[3]),
+                    new java.awt.geom.Ellipse2D.Double(f[0], f[1], f[2], f[3]), x0, y0, x1, y1);
+            inside += assertSameContains("line " + label, new Line2D.Double(f[0], f[1], f[2], f[3]),
+                    new java.awt.geom.Line2D.Double(f[0], f[1], f[2], f[3]), x0, y0, x1, y1);
+            for (double[] c : CORNERS) {
+                inside += assertSameContains("round rectangle " + label + " arc " + c[0] + "," + c[1],
+                        new RoundRectangle2D.Double(f[0], f[1], f[2], f[3], c[0], c[1]),
+                        new java.awt.geom.RoundRectangle2D.Double(f[0], f[1], f[2], f[3], c[0], c[1]),
+                        x0, y0, x1, y1);
+            }
+            for (double start : STARTS) {
+                for (double extent : EXTENTS) {
+                    for (int closure : CLOSURES) {
+                        inside += assertSameContains(
+                                "arc " + label + " from " + start + " by " + extent + " closure " + closure,
+                                new Arc2D.Double(f[0], f[1], f[2], f[3], start, extent, closure),
+                                new java.awt.geom.Arc2D.Double(f[0], f[1], f[2], f[3], start, extent, closure),
+                                x0, y0, x1, y1);
+                    }
+                }
+            }
+        }
+        assertTrue("the grids must land inside the shapes: " + inside, inside > 10000);
+        // boundary ownership: left and top edges in, right and bottom out
+        Rectangle2D r = new Rectangle2D.Double(1, 2, 3, 4);
+        assertTrue(r.contains(1, 2));
+        assertFalse(r.contains(4, 2));
+        assertFalse(r.contains(1, 6));
+    }
+
+    private static final double[][] STAR = {
+        {50, 5}, {79, 95}, {3, 39}, {97, 39}, {21, 95},
+    };
+
+    @Test
+    public void starPolygonContainsMatchesTheJdkUnderBothWindingRules() {
+        int[] rules = {Path2D.WIND_EVEN_ODD, Path2D.WIND_NON_ZERO};
+        int[] inside = new int[2];
+        for (int i = 0; i < rules.length; i++) {
+            Path2D ours = new Path2D.Double(rules[i]);
+            java.awt.geom.Path2D real = new java.awt.geom.Path2D.Double(rules[i]);
+            GeneralPath oursFloat = new GeneralPath(rules[i]);
+            java.awt.geom.GeneralPath realFloat = new java.awt.geom.GeneralPath(rules[i]);
+            for (int p = 0; p < STAR.length; p++) {
+                if (p == 0) {
+                    ours.moveTo(STAR[p][0], STAR[p][1]);
+                    real.moveTo(STAR[p][0], STAR[p][1]);
+                    oursFloat.moveTo((float) STAR[p][0], (float) STAR[p][1]);
+                    realFloat.moveTo((float) STAR[p][0], (float) STAR[p][1]);
+                } else {
+                    ours.lineTo(STAR[p][0], STAR[p][1]);
+                    real.lineTo(STAR[p][0], STAR[p][1]);
+                    oursFloat.lineTo((float) STAR[p][0], (float) STAR[p][1]);
+                    realFloat.lineTo((float) STAR[p][0], (float) STAR[p][1]);
+                }
+            }
+            ours.closePath();
+            real.closePath();
+            oursFloat.closePath();
+            realFloat.closePath();
+            assertEquals(real.getWindingRule(), ours.getWindingRule());
+            assertSameOutline("star rule " + rules[i], ours, real, TOL);
+            assertSameOutline("float star rule " + rules[i], oursFloat, realFloat, FLOAT_TOL);
+            inside[i] = assertSameContains("star rule " + rules[i], ours, real, -4.3, -3.1, 104.7, 103.3);
+            assertSameContains("float star rule " + rules[i], oursFloat, realFloat, -4.3, -3.1, 104.7, 103.3);
+            for (double y = -3.1; y <= 103.3; y += 7.9) {
+                for (double x = -4.3; x <= 104.7; x += 6.7) {
+                    assertEquals("static contains", real.contains(x, y), Path2D.contains(ours.getPathIterator(null), x, y));
+                }
+            }
+        }
+        // the pentagon in the middle of the star is what the two rules
+        // disagree about
+        assertTrue("even-odd " + inside[0] + " non-zero " + inside[1], inside[1] > inside[0] && inside[0] > 0);
+    }
+
+    @Test
+    public void pathRectangleTestsMatchTheJdkForRectanglesAndConvexPolygons() {
+        double[][][] polygons = {
+            {{10, 10}, {60, 10}, {60, 40}, {10, 40}},
+            {{35, 5}, {65, 30}, {50, 60}, {20, 60}, {5, 30}},
+            {{10, 10}, {61, 36}, {10, 60}},
+        };
+        int hits = 0;
+        int holds = 0;
+        for (double[][] polygon : polygons) {
+            Path2D ours = new Path2D.Double();
+            java.awt.geom.Path2D real = new java.awt.geom.Path2D.Double();
+            for (int p = 0; p < polygon.length; p++) {
+                if (p == 0) {
+                    ours.moveTo(polygon[p][0], polygon[p][1]);
+                    real.moveTo(polygon[p][0], polygon[p][1]);
+                } else {
+                    ours.lineTo(polygon[p][0], polygon[p][1]);
+                    real.lineTo(polygon[p][0], polygon[p][1]);
+                }
+            }
+            ours.closePath();
+            real.closePath();
+            assertSameRect("bounds", real.getBounds2D(), ours.getBounds2D(), TOL);
+            assertEquals(real.getBounds().x, ours.getBounds().x);
+            assertEquals(real.getBounds().width, ours.getBounds().width);
+            double[] sizes = {0.7, 3.3, 11.1, 27.9, 80.3};
+            for (double w : sizes) {
+                for (double h : sizes) {
+                    for (double y = -6.3; y <= 70; y += 4.7) {
+                        for (double x = -5.9; x <= 70; x += 5.3) {
+                            String label = "rect " + x + "," + y + "," + w + "," + h;
+                            boolean expected = real.intersects(x, y, w, h);
+                            assertEquals(label + " intersects", expected, ours.intersects(x, y, w, h));
+                            assertEquals(label + " intersects (rect)", expected,
+                                    ours.intersects(new Rectangle2D.Double(x, y, w, h)));
+                            boolean contained = real.contains(x, y, w, h);
+                            assertEquals(label + " contains", contained, ours.contains(x, y, w, h));
+                            assertEquals(label + " static contains", contained,
+                                    Path2D.contains(ours.getPathIterator(null), x, y, w, h));
+                            assertEquals(label + " static intersects", expected,
+                                    Path2D.intersects(ours.getPathIterator(null), new Rectangle2D.Double(x, y, w, h)));
+                            hits += expected ? 1 : 0;
+                            holds += contained ? 1 : 0;
+                        }
+                    }
+                }
+            }
+            // a rectangle that only shares an edge does not intersect, and
+            // empty rectangles never do
+            assertEquals(real.intersects(60, 10, 5, 5), ours.intersects(60, 10, 5, 5));
+            assertEquals(real.intersects(20, 20, 0, 5), ours.intersects(20, 20, 0, 5));
+            assertEquals(real.contains(20, 20, 0, 5), ours.contains(20, 20, 0, 5));
+        }
+        assertTrue("grid must exercise both answers: " + hits + " " + holds, hits > 100 && holds > 20);
+    }
+
+    @Test
+    public void pathBuildingMatchesTheJdk() {
+        Path2D ours = new Path2D.Double();
+        java.awt.geom.Path2D real = new java.awt.geom.Path2D.Double();
+        assertNull(ours.getCurrentPoint());
+        try {
+            ours.lineTo(1, 1);
+            fail("a line needs a move first");
+        } catch (IllegalPathStateException expected) {
+            assertTrue(expected.getMessage().length() > 0);
+        }
+        // a move directly after a move replaces it
+        ours.moveTo(1, 1);
+        real.moveTo(1, 1);
+        ours.moveTo(2, 3);
+        real.moveTo(2, 3);
+        ours.lineTo(10, 3);
+        real.lineTo(10, 3);
+        ours.quadTo(14, 8, 10, 12);
+        real.quadTo(14, 8, 10, 12);
+        ours.curveTo(8, 14, 4, 14, 2, 12);
+        real.curveTo(8, 14, 4, 14, 2, 12);
+        assertEquals(real.getCurrentPoint().getX(), ours.getCurrentPoint().getX(), 0.0);
+        ours.closePath();
+        real.closePath();
+        ours.closePath();
+        real.closePath();
+        assertEquals(real.getCurrentPoint().getX(), ours.getCurrentPoint().getX(), 0.0);
+        assertEquals(real.getCurrentPoint().getY(), ours.getCurrentPoint().getY(), 0.0);
+        ours.moveTo(20, 20);
+        real.moveTo(20, 20);
+        ours.lineTo(30, 25);
+        real.lineTo(30, 25);
+        // connected: the leading move becomes a line, or vanishes when the
+        // open subpath already ends there
+        ours.append(new Line2D.Double(30, 25, 40, 20), true);
+        real.append(new java.awt.geom.Line2D.Double(30, 25, 40, 20), true);
+        ours.append(new Rectangle2D.Double(50, 50, 5, 6), true);
+        real.append(new java.awt.geom.Rectangle2D.Double(50, 50, 5, 6), true);
+        ours.append(new Ellipse2D.Double(60, 60, 5, 6).getPathIterator(null), false);
+        real.append(new java.awt.geom.Ellipse2D.Double(60, 60, 5, 6).getPathIterator(null), false);
+        assertEquals(real.getCurrentPoint().getX(), ours.getCurrentPoint().getX(), TOL);
+        assertEquals(real.getCurrentPoint().getY(), ours.getCurrentPoint().getY(), TOL);
+        assertSameOutline("built path", ours, real, TOL);
+        assertSameRect("built bounds", real.getBounds2D(), ours.getBounds2D(), TOL);
+
+        Shape oursShape = ours.createTransformedShape(new AffineTransform(0, 2, -2, 0, 5, 5));
+        java.awt.Shape realShape = real.createTransformedShape(new java.awt.geom.AffineTransform(0, 2, -2, 0, 5, 5));
+        assertTrue(oursShape instanceof Path2D.Double);
+        assertSameOutline("transformed copy", oursShape, realShape, TOL);
+        assertSameOutline("original untouched", ours, real, TOL);
+
+        Path2D oursFloat = new Path2D.Float(ours, new AffineTransform(1.1, 0, 0, 0.9, 0.3, 0.7));
+        java.awt.geom.Path2D realFloat =
+                new java.awt.geom.Path2D.Float(real, new java.awt.geom.AffineTransform(1.1, 0, 0, 0.9, 0.3, 0.7));
+        assertSameOutline("float copy", oursFloat, realFloat, FLOAT_TOL);
+        assertTrue(oursFloat.getBounds2D() instanceof Rectangle2D.Float);
+        assertTrue(oursFloat.getCurrentPoint() instanceof Point2D.Float);
+        assertTrue(oursFloat.clone() instanceof Path2D.Float);
+        assertTrue(new GeneralPath(ours).clone() instanceof GeneralPath);
+
+        ours.transform(new AffineTransform(2, 0, 0, 2, 1, 1));
+        real.transform(new java.awt.geom.AffineTransform(2, 0, 0, 2, 1, 1));
+        assertSameOutline("transformed in place", ours, real, TOL);
+
+        Path2D fromShape = new Path2D.Double(new Arc2D.Double(1, 2, 10, 6, 30, 200, Arc2D.PIE));
+        java.awt.geom.Path2D realFromShape = new java.awt.geom.Path2D.Double(
+                new java.awt.geom.Arc2D.Double(1, 2, 10, 6, 30, 200, java.awt.geom.Arc2D.PIE));
+        assertSameOutline("from a shape", fromShape, realFromShape, TOL);
+
+        ours.reset();
+        assertNull(ours.getCurrentPoint());
+        assertTrue(ours.getPathIterator(null).isDone());
+        ours.setWindingRule(Path2D.WIND_EVEN_ODD);
+        assertEquals(Path2D.WIND_EVEN_ODD, ours.getWindingRule());
+        try {
+            ours.setWindingRule(5);
+            fail("an unknown winding rule must be refused");
+        } catch (IllegalArgumentException expected) {
+            assertEquals(Path2D.WIND_EVEN_ODD, ours.getWindingRule());
+        }
+    }
+
+    @Test
+    public void curvedShapesAgreeWithTheJdkAwayFromTheirEdges() {
+        ReferenceJdk.assume("answers the tight bounds of a curve, not the bounds of its control points");
+        // curves are hit-tested over a flattened outline, so points within a
+        // whisker of the edge are left out of the comparison
+        QuadCurve2D quad = new QuadCurve2D.Double(5, 5, 60, 90, 95, 10);
+        java.awt.geom.QuadCurve2D realQuad = new java.awt.geom.QuadCurve2D.Double(5, 5, 60, 90, 95, 10);
+        CubicCurve2D cubic = new CubicCurve2D.Double(5, 50, 30, -40, 70, 140, 95, 50);
+        java.awt.geom.CubicCurve2D realCubic = new java.awt.geom.CubicCurve2D.Double(5, 50, 30, -40, 70, 140, 95, 50);
+        Path2D blob = new Path2D.Double();
+        java.awt.geom.Path2D realBlob = new java.awt.geom.Path2D.Double();
+        blob.moveTo(10, 50);
+        realBlob.moveTo(10, 50);
+        blob.curveTo(10, 0, 90, 0, 90, 50);
+        realBlob.curveTo(10, 0, 90, 0, 90, 50);
+        blob.quadTo(50, 120, 10, 50);
+        realBlob.quadTo(50, 120, 10, 50);
+        Shape[] ours = {quad, cubic, blob, new Arc2D.Double(5, 5, 90, 70, 20, 250, Arc2D.PIE),
+            new Arc2D.Double(5, 5, 90, 70, 20, 250, Arc2D.CHORD), new Arc2D.Double(5, 5, 90, 70, -30, 100, Arc2D.OPEN)};
+        java.awt.Shape[] real = {realQuad, realCubic, realBlob,
+            new java.awt.geom.Arc2D.Double(5, 5, 90, 70, 20, 250, java.awt.geom.Arc2D.PIE),
+            new java.awt.geom.Arc2D.Double(5, 5, 90, 70, 20, 250, java.awt.geom.Arc2D.CHORD),
+            new java.awt.geom.Arc2D.Double(5, 5, 90, 70, -30, 100, java.awt.geom.Arc2D.OPEN)};
+        for (int s = 0; s < ours.length; s++) {
+            int inside = 0;
+            int hits = 0;
+            for (double y = -3.37; y <= 104; y += 2.71) {
+                for (double x = -4.11; x <= 104; x += 3.13) {
+                    if (nearOutline(real[s], x, y, 0.05)) {
+                        continue;
+                    }
+                    boolean expected = real[s].contains(x, y);
+                    assertEquals("shape " + s + " contains " + x + "," + y, expected, ours[s].contains(x, y));
+                    inside += expected ? 1 : 0;
+                }
+            }
+            for (double y = -3.37; y <= 104; y += 9.71) {
+                for (double x = -4.11; x <= 104; x += 8.13) {
+                    for (double size = 2.3; size < 60; size *= 2.9) {
+                        if (outlineNearRect(real[s], x, y, size, size, 0.05)) {
+                            continue;
+                        }
+                        boolean expected = real[s].intersects(x, y, size, size);
+                        assertEquals("shape " + s + " intersects " + x + "," + y + " size " + size, expected,
+                                ours[s].intersects(x, y, size, size));
+                        assertEquals("shape " + s + " contains " + x + "," + y + " size " + size,
+                                real[s].contains(x, y, size, size), ours[s].contains(x, y, size, size));
+                        hits += expected ? 1 : 0;
+                    }
+                }
+            }
+            assertTrue("shape " + s + " inside " + inside + " hits " + hits, inside > 20 && hits > 5);
+        }
+        assertSameRect("quad bounds", realQuad.getBounds2D(), quad.getBounds2D(), TOL);
+        assertSameRect("cubic bounds", realCubic.getBounds2D(), cubic.getBounds2D(), TOL);
+        assertEquals(realQuad.getFlatness(), quad.getFlatness(), TOL);
+        assertEquals(realCubic.getFlatness(), cubic.getFlatness(), TOL);
+        assertEquals(realCubic.getFlatnessSq(), cubic.getFlatnessSq(), 1e-7);
+
+        QuadCurve2D ql = new QuadCurve2D.Double();
+        QuadCurve2D qr = new QuadCurve2D.Float();
+        java.awt.geom.QuadCurve2D rql = new java.awt.geom.QuadCurve2D.Double();
+        java.awt.geom.QuadCurve2D rqr = new java.awt.geom.QuadCurve2D.Float();
+        quad.subdivide(ql, qr);
+        realQuad.subdivide(rql, rqr);
+        assertSameOutline("quad left", ql, rql, TOL);
+        assertSameOutline("quad right", qr, rqr, FLOAT_TOL);
+        CubicCurve2D cl = new CubicCurve2D.Double();
+        CubicCurve2D cr = new CubicCurve2D.Float();
+        java.awt.geom.CubicCurve2D rcl = new java.awt.geom.CubicCurve2D.Double();
+        java.awt.geom.CubicCurve2D rcr = new java.awt.geom.CubicCurve2D.Float();
+        cubic.subdivide(cl, cr);
+        realCubic.subdivide(rcl, rcr);
+        assertSameOutline("cubic left", cl, rcl, TOL);
+        assertSameOutline("cubic right", cr, rcr, FLOAT_TOL);
+
+        double[][] equations = {{2, -3, 1}, {1, 2, 1}, {5, 0, 1}, {4, 2, 0}, {3, 0, 0}, {-6, 1, 1}, {1e-3, -200, 1},
+            {0, 0, 1}, {0, 3, 1}, {0, 0, 0}, {4, 0, -1}};
+        for (double[] eqn : equations) {
+            double[] a = new double[2];
+            double[] b = new double[2];
+            int expected = java.awt.geom.QuadCurve2D.solveQuadratic(eqn, b);
+            assertEquals("root count", expected, QuadCurve2D.solveQuadratic(eqn, a));
+            if (expected == 2) {
+                java.util.Arrays.sort(a);
+                java.util.Arrays.sort(b);
+            }
+            for (int i = 0; i < expected; i++) {
+                assertEquals("root " + i, b[i], a[i], 1e-9 * Math.max(1.0, Math.abs(b[i])));
+            }
+        }
+    }
+
+    /// Whether a point is within `margin` of the JDK's flattened outline of a
+    /// shape, closing lines included.
+    private static boolean nearOutline(java.awt.Shape s, double x, double y, double margin) {
+        return outlineNearRect(s, x, y, 0, 0, margin);
+    }
+
+    /// Whether the outline of a shape comes within `margin` of the border of
+    /// a rectangle, which is where a flattened hit test may differ.
+    private static boolean outlineNearRect(java.awt.Shape s, double x, double y, double w, double h, double margin) {
+        java.awt.geom.PathIterator pi = s.getPathIterator(null, 0.001);
+        double[] c = new double[6];
+        double sx = 0;
+        double sy = 0;
+        double cx = 0;
+        double cy = 0;
+        double[][] border = {{x, y, x + w, y}, {x + w, y, x + w, y + h}, {x + w, y + h, x, y + h}, {x, y + h, x, y}};
+        while (true) {
+            double nx;
+            double ny;
+            boolean edge = true;
+            if (pi.isDone()) {
+                nx = sx;
+                ny = sy;
+            } else {
+                int type = pi.currentSegment(c);
+                if (type == java.awt.geom.PathIterator.SEG_MOVETO) {
+                    // the open subpath is closed back to its start first
+                    for (double[] b : border) {
+                        if (segmentsWithin(cx, cy, sx, sy, b, margin)) {
+                            return true;
+                        }
+                    }
+                    sx = c[0];
+                    sy = c[1];
+                    nx = sx;
+                    ny = sy;
+                    edge = false;
+                } else if (type == java.awt.geom.PathIterator.SEG_CLOSE) {
+                    nx = sx;
+                    ny = sy;
+                } else {
+                    nx = c[0];
+                    ny = c[1];
+                }
+            }
+            if (edge) {
+                for (double[] b : border) {
+                    if (segmentsWithin(cx, cy, nx, ny, b, margin)) {
+                        return true;
+                    }
+                }
+            }
+            cx = nx;
+            cy = ny;
+            if (pi.isDone()) {
+                return false;
+            }
+            pi.next();
+        }
+    }
+
+    private static boolean segmentsWithin(double x1, double y1, double x2, double y2, double[] b, double margin) {
+        if (x1 == x2 && y1 == y2) {
+            return false;
+        }
+        if (java.awt.geom.Line2D.linesIntersect(x1, y1, x2, y2, b[0], b[1], b[2], b[3])) {
+            return true;
+        }
+        return java.awt.geom.Line2D.ptSegDist(x1, y1, x2, y2, b[0], b[1]) <= margin
+                || java.awt.geom.Line2D.ptSegDist(x1, y1, x2, y2, b[2], b[3]) <= margin
+                || java.awt.geom.Line2D.ptSegDist(b[0], b[1], b[2], b[3], x1, y1) <= margin
+                || java.awt.geom.Line2D.ptSegDist(b[0], b[1], b[2], b[3], x2, y2) <= margin;
+    }
+
+    @Test
+    public void rectangularShapesAgainstRectanglesMatchTheJdk() {
+        double[] sizes = {0, 0.4, 2.7, 9.3, 30};
+        int hits = 0;
+        for (double w : sizes) {
+            for (double h : sizes) {
+                for (double y = -4.3; y <= 14; y += 1.9) {
+                    for (double x = -3.7; x <= 16; x += 2.3) {
+                        String label = "rect " + x + "," + y + "," + w + "," + h;
+                        Rectangle2D q = new Rectangle2D.Double(x, y, w, h);
+                        java.awt.geom.Rectangle2D rq = new java.awt.geom.Rectangle2D.Double(x, y, w, h);
+
+                        Rectangle2D rect = new Rectangle2D.Double(1, 2, 10, 6);
+                        java.awt.geom.Rectangle2D realRect = new java.awt.geom.Rectangle2D.Double(1, 2, 10, 6);
+                        assertEquals(label, realRect.intersects(rq), rect.intersects(q));
+                        assertEquals(label, realRect.contains(rq), rect.contains(q));
+                        assertEquals(label, realRect.intersectsLine(x, y, x + w, y + h),
+                                rect.intersectsLine(x, y, x + w, y + h));
+                        assertEquals(label, realRect.intersectsLine(x + w, y, x, y + h),
+                                rect.intersectsLine(new Line2D.Double(x + w, y, x, y + h)));
+                        assertEquals(label, realRect.outcode(x, y), rect.outcode(x, y));
+                        assertEquals(label, realRect.outcode(x + w, y + h), rect.outcode(new Point2D.Double(x + w, y + h)));
+                        assertSameRect(label + " intersection", realRect.createIntersection(rq),
+                                rect.createIntersection(q), TOL);
+                        assertSameRect(label + " union", realRect.createUnion(rq), rect.createUnion(q), TOL);
+                        Rectangle2D sum = new Rectangle2D.Float(1, 2, 10, 6);
+                        java.awt.geom.Rectangle2D realSum = new java.awt.geom.Rectangle2D.Float(1, 2, 10, 6);
+                        sum.add(q);
+                        realSum.add(rq);
+                        assertSameRect(label + " add rect", realSum, sum, FLOAT_TOL);
+                        sum.add(x - 3, y + 20);
+                        realSum.add(x - 3, y + 20);
+                        assertSameRect(label + " add point", realSum, sum, FLOAT_TOL);
+                        assertEquals(label, new java.awt.geom.Line2D.Double(x, y, x + w, y + h).intersects(realRect),
+                                new Line2D.Double(x, y, x + w, y + h).intersects(rect));
+
+                        Ellipse2D ellipse = new Ellipse2D.Double(1, 2, 10, 6);
+                        java.awt.geom.Ellipse2D realEllipse = new java.awt.geom.Ellipse2D.Double(1, 2, 10, 6);
+                        assertEquals(label + " ellipse intersects", realEllipse.intersects(rq), ellipse.intersects(q));
+                        assertEquals(label + " ellipse contains", realEllipse.contains(rq), ellipse.contains(q));
+
+                        RoundRectangle2D round = new RoundRectangle2D.Double(1, 2, 10, 6, 4, 3);
+                        java.awt.geom.RoundRectangle2D realRound =
+                                new java.awt.geom.RoundRectangle2D.Double(1, 2, 10, 6, 4, 3);
+                        assertEquals(label + " round intersects", realRound.intersects(rq), round.intersects(q));
+                        assertEquals(label + " round contains", realRound.contains(rq), round.contains(q));
+
+                        for (int closure : CLOSURES) {
+                            Arc2D arc = new Arc2D.Double(1, 2, 10, 6, 30, 250, closure);
+                            java.awt.geom.Arc2D realArc = new java.awt.geom.Arc2D.Double(1, 2, 10, 6, 30, 250, closure);
+                            assertEquals(label + " arc contains, closure " + closure, realArc.contains(rq),
+                                    arc.contains(q));
+                        }
+                        hits += realRect.intersects(rq) ? 1 : 0;
+                    }
+                }
+            }
+        }
+        assertTrue("grid must overlap the shapes: " + hits, hits > 100);
+        assertEquals(java.awt.geom.Rectangle2D.OUT_LEFT, Rectangle2D.OUT_LEFT);
+        assertEquals(java.awt.geom.Rectangle2D.OUT_TOP, Rectangle2D.OUT_TOP);
+        assertEquals(java.awt.geom.Rectangle2D.OUT_RIGHT, Rectangle2D.OUT_RIGHT);
+        assertEquals(java.awt.geom.Rectangle2D.OUT_BOTTOM, Rectangle2D.OUT_BOTTOM);
+        assertEquals(new java.awt.geom.Rectangle2D.Double(1, 2, 0, 4).outcode(0, 0),
+                new Rectangle2D.Double(1, 2, 0, 4).outcode(0, 0));
+
+        Rectangle2D frame = new Rectangle2D.Double();
+        java.awt.geom.Rectangle2D realFrame = new java.awt.geom.Rectangle2D.Double();
+        frame.setFrameFromDiagonal(9, 8, 2, 3);
+        realFrame.setFrameFromDiagonal(9, 8, 2, 3);
+        assertSameRect("diagonal", realFrame, frame, TOL);
+        frame.setFrameFromCenter(5, 5, 2, 9);
+        realFrame.setFrameFromCenter(5, 5, 2, 9);
+        assertSameRect("centre", realFrame, frame, TOL);
+        assertEquals(realFrame.getCenterX(), frame.getCenterX(), TOL);
+        assertEquals(realFrame.getMaxY(), frame.getMaxY(), TOL);
+        Rectangle2D fractional = new Rectangle2D.Double(-1.5, 2.25, 3.75, 4.5);
+        java.awt.Rectangle realBounds = new java.awt.geom.Rectangle2D.Double(-1.5, 2.25, 3.75, 4.5).getBounds();
+        assertEquals(realBounds.x, fractional.getBounds().x);
+        assertEquals(realBounds.y, fractional.getBounds().y);
+        assertEquals(realBounds.width, fractional.getBounds().width);
+        assertEquals(realBounds.height, fractional.getBounds().height);
+        assertEquals(new Rectangle2D.Double(1, 2, 3, 4), new Rectangle2D.Float(1, 2, 3, 4));
+        assertEquals(new Rectangle2D.Double(1, 2, 3, 4).hashCode(), new Rectangle2D.Float(1, 2, 3, 4).hashCode());
+        assertTrue(new Rectangle2D.Float(1, 2, 3, 4).clone() instanceof Rectangle2D.Float);
+        assertTrue(new Ellipse2D.Float(1, 2, 3, 4).clone() instanceof Ellipse2D.Float);
+        assertEquals(new Ellipse2D.Double(1, 2, 3, 4), new Ellipse2D.Double(1, 2, 3, 4).clone());
+        assertEquals(new RoundRectangle2D.Double(1, 2, 3, 4, 1, 1), new RoundRectangle2D.Double(1, 2, 3, 4, 1, 1).clone());
+        assertEquals(new Arc2D.Double(1, 2, 3, 4, 5, 6, Arc2D.PIE), new Arc2D.Double(1, 2, 3, 4, 5, 6, Arc2D.PIE).clone());
+        assertFalse(new Arc2D.Double(1, 2, 3, 4, 5, 6, Arc2D.PIE).equals(new Arc2D.Double(1, 2, 3, 4, 5, 6, Arc2D.CHORD)));
+    }
+
+    // ---------------------------------------------------------------- integer rectangle
+
+    private static final int[][] INT_RECTS = {
+        {0, 0, 10, 10}, {5, 5, 10, 10}, {10, 0, 5, 5}, {2, 2, 3, 3}, {-5, -5, 4, 4}, {20, 20, 1, 1},
+        {3, 3, 0, 0}, {3, 3, 0, 5}, {4, 4, -1, -1}, {0, 0, -3, 5}, {1, 1, 6, -2},{0, 0, 10, 0}, {9, 9, 1, 1},
+        {Integer.MAX_VALUE - 5, 0, 10, 10}, {Integer.MIN_VALUE + 2, 3, 5, 5},
+    };
+
+    private static void assertSameRect(String label, java.awt.Rectangle real, Rectangle ours) {
+        assertEquals(label + " x", real.x, ours.x);
+        assertEquals(label + " y", real.y, ours.y);
+        assertEquals(label + " width", real.width, ours.width);
+        assertEquals(label + " height", real.height, ours.height);
+    }
+
+    @Test
+    public void integerRectangleMatchesTheJdk() {
+        for (int[] a : INT_RECTS) {
+            for (int[] b : INT_RECTS) {
+                String label = "[" + a[0] + "," + a[1] + "," + a[2] + "," + a[3] + "] with ["
+                        + b[0] + "," + b[1] + "," + b[2] + "," + b[3] + "]";
+                Rectangle ours = new Rectangle(a[0], a[1], a[2], a[3]);
+                Rectangle other = new Rectangle(b[0], b[1], b[2], b[3]);
+                java.awt.Rectangle real = new java.awt.Rectangle(a[0], a[1], a[2], a[3]);
+                java.awt.Rectangle realOther = new java.awt.Rectangle(b[0], b[1], b[2], b[3]);
+                assertEquals(label + " intersects", real.intersects(realOther), ours.intersects(other));
+                assertEquals(label + " contains", real.contains(realOther), ours.contains(other));
+                assertEquals(label + " contains point", real.contains(b[0], b[1]), ours.contains(b[0], b[1]));
+                assertEquals(label + " contains Point", real.contains(new java.awt.Point(b[0] + b[2], b[1])),
+                        ours.contains(new Point(b[0] + b[2], b[1])));
+                assertEquals(label + " isEmpty", real.isEmpty(), ours.isEmpty());
+                assertEquals(label + " outcode", real.outcode(b[0], b[1]), ours.outcode(b[0], b[1]));
+                assertEquals(label + " equals", real.equals(realOther), ours.equals(other));
+                if (Math.abs((long) a[0]) < 1000000 && Math.abs((long) b[0]) < 1000000) {
+                    // the far-off rows are there for the tests above; what a
+                    // sum beyond the int range becomes is not compared
+                    assertSameRect(label + " intersection", real.intersection(realOther), ours.intersection(other));
+                    assertSameRect(label + " union", real.union(realOther), ours.union(other));
+                    Rectangle added = new Rectangle(ours);
+                    java.awt.Rectangle realAdded = new java.awt.Rectangle(real);
+                    added.add(other);
+                    realAdded.add(realOther);
+                    assertSameRect(label + " add", realAdded, added);
+                    added.add(b[0], b[1]);
+                    realAdded.add(b[0], b[1]);
+                    assertSameRect(label + " add point", realAdded, added);
+                    added.grow(b[2], -b[3]);
+                    realAdded.grow(b[2], -b[3]);
+                    assertSameRect(label + " grow", realAdded, added);
+                    added.translate(b[0], b[1]);
+                    realAdded.translate(b[0], b[1]);
+                    assertSameRect(label + " translate", realAdded, added);
+                    java.awt.geom.Rectangle2D realCross = real.createIntersection(realOther);
+                    Rectangle2D cross = ours.createIntersection(other);
+                    assertTrue(cross instanceof Rectangle);
+                    assertSameRect(label + " createIntersection", realCross, cross, 0.0);
+                    assertSameRect(label + " createUnion", real.createUnion(realOther), ours.createUnion(other), 0.0);
+                    assertSameRect(label + " mixed intersection",
+                            real.createIntersection(new java.awt.geom.Rectangle2D.Double(b[0] + 0.5, b[1], b[2], b[3])),
+                            ours.createIntersection(new Rectangle2D.Double(b[0] + 0.5, b[1], b[2], b[3])), TOL);
+                    assertSameRect(label + " mixed union",
+                            real.createUnion(new java.awt.geom.Rectangle2D.Double(b[0] + 0.5, b[1], b[2], b[3])),
+                            ours.createUnion(new Rectangle2D.Double(b[0] + 0.5, b[1], b[2], b[3])), TOL);
+                }
+            }
+        }
+        double[][] fractional = {{1.5, 2.5, 3.25, 4.75}, {-1.5, -2.25, 3, 4}, {0.2, 0.2, 0.2, 0.2}, {3, 4, 5, 6},
+            {-0.5, 7.9, 0, 0}, {2.5, 2.5, -1.5, 3}};
+        for (double[] f : fractional) {
+            Rectangle ours = new Rectangle();
+            java.awt.Rectangle real = new java.awt.Rectangle();
+            ours.setRect(f[0], f[1], f[2], f[3]);
+            real.setRect(f[0], f[1], f[2], f[3]);
+            assertSameRect("setRect " + f[0] + "," + f[1] + "," + f[2] + "," + f[3], real, ours);
+            ours.setFrame(f[0], f[1], f[2], f[3]);
+            assertSameRect("setFrame", real, ours);
+        }
+        Rectangle r = new Rectangle(new Point(1, 2), new Dimension(3, 4));
+        assertEquals(new java.awt.Rectangle(1, 2, 3, 4).toString(), r.toString());
+        assertEquals(new Rectangle(1, 2, 3, 4), r);
+        assertEquals(new Rectangle(1, 2, 3, 4).hashCode(), r.hashCode());
+        assertEquals(r, new Rectangle2D.Double(1, 2, 3, 4));
+        assertEquals(new Point(1, 2), r.getLocation());
+        assertEquals(new Dimension(3, 4), r.getSize());
+        assertTrue(r.clone() instanceof Rectangle);
+        assertTrue(r.getBounds2D() instanceof Rectangle);
+        r.setBounds(new Rectangle(5, 6, 7, 8));
+        r.setLocation(new Point(9, 9));
+        r.setSize(new Dimension(1, 1));
+        assertEquals(new Rectangle(9, 9, 1, 1), r);
+        assertEquals(new Rectangle(new Dimension(4, 5)), new Rectangle(4, 5));
+        assertEquals(new Rectangle(new Point(4, 5)), new Rectangle(4, 5, 0, 0));
+    }
+
+    @Test
+    public void pointDimensionAndInsetsBehaveLikeTheJdk() {
+        Point p = new Point(3, 4);
+        assertEquals(new java.awt.Point(3, 4).toString(), p.toString());
+        p.translate(2, -1);
+        assertEquals(new Point(5, 3), p);
+        double[][] rounding = {{1.5, -1.5}, {2.4, -2.6}, {-0.5, 0.49}};
+        for (double[] v : rounding) {
+            java.awt.Point real = new java.awt.Point();
+            real.setLocation(v[0], v[1]);
+            p.setLocation(v[0], v[1]);
+            assertEquals(real.x, p.x);
+            assertEquals(real.y, p.y);
+        }
+        p.move(7, 8);
+        assertEquals(new Point2D.Double(7, 8), p);
+        assertEquals(new Point2D.Double(7, 8).hashCode(), p.hashCode());
+        assertTrue(p.clone() instanceof Point);
+        assertTrue(new Point2D.Float(1, 2).clone() instanceof Point2D.Float);
+        assertEquals(new Point(p), p.getLocation());
+        assertEquals(java.awt.geom.Point2D.distance(1, 2, 4, 6), Point2D.distance(1, 2, 4, 6), TOL);
+        assertEquals(25.0, new Point2D.Double(1, 2).distanceSq(new Point2D.Float(4, 6)), TOL);
+        assertEquals(5.0, new Point2D.Double(1, 2).distance(4, 6), TOL);
+        assertEquals(new java.awt.geom.Point2D.Double(1, 2).toString(), new Point2D.Double(1, 2).toString());
+        assertEquals(new java.awt.geom.Point2D.Float(1, 2).toString(), new Point2D.Float(1, 2).toString());
+
+        Dimension d = new Dimension(3, 4);
+        assertEquals(new java.awt.Dimension(3, 4).toString(), d.toString());
+        java.awt.Dimension realD = new java.awt.Dimension();
+        realD.setSize(2.1, -2.1);
+        d.setSize(2.1, -2.1);
+        assertEquals(realD.width, d.width);
+        assertEquals(realD.height, d.height);
+        d.setSize(new Dimension(6, 7));
+        assertEquals(new Dimension(6, 7), d.getSize());
+        assertEquals(new Dimension(6, 7).hashCode(), d.hashCode());
+        assertTrue(d.clone() instanceof Dimension);
+        Dimension2D d2 = new Dimension();
+        d2.setSize(d);
+        assertEquals(d, d2);
+
+        Insets i = new Insets(1, 2, 3, 4);
+        assertEquals(new java.awt.Insets(1, 2, 3, 4).toString(), i.toString());
+        Object copy = i.clone();
+        assertEquals(i, copy);
+        assertEquals(i.hashCode(), copy.hashCode());
+        i.set(5, 6, 7, 8);
+        assertEquals(new Insets(5, 6, 7, 8), i);
+        assertFalse(i.equals(copy));
+    }
+
+    // ---------------------------------------------------------------- lines
+
+    @Test
+    public void lineFunctionsMatchTheJdk() {
+        double[] v = {-3, 0, 1, 2.5, 4, 7};
+        int crossings = 0;
+        for (double x1 : v) {
+            for (double y1 : v) {
+                for (double x2 : v) {
+                    for (double y2 : new double[] {0, 2.5, 7}) {
+                        for (double px : v) {
+                            for (double py : new double[] {-3, 1, 2.5, 4}) {
+                                String label = x1 + "," + y1 + "-" + x2 + "," + y2 + " point " + px + "," + py;
+                                assertEquals(label + " relativeCCW",
+                                        java.awt.geom.Line2D.relativeCCW(x1, y1, x2, y2, px, py),
+                                        Line2D.relativeCCW(x1, y1, x2, y2, px, py));
+                                assertEquals(label + " ptSegDist",
+                                        java.awt.geom.Line2D.ptSegDist(x1, y1, x2, y2, px, py),
+                                        Line2D.ptSegDist(x1, y1, x2, y2, px, py), 1e-7);
+                                assertEquals(label + " ptSegDistSq",
+                                        java.awt.geom.Line2D.ptSegDistSq(x1, y1, x2, y2, px, py),
+                                        Line2D.ptSegDistSq(x1, y1, x2, y2, px, py), TOL * 100);
+                                if (x1 != x2 || y1 != y2) {
+                                    assertEquals(label + " ptLineDist",
+                                            java.awt.geom.Line2D.ptLineDist(x1, y1, x2, y2, px, py),
+                                            Line2D.ptLineDist(x1, y1, x2, y2, px, py), 1e-7);
+                                }
+                                boolean expected = java.awt.geom.Line2D.linesIntersect(x1, y1, x2, y2, px, py, 4, 1);
+                                assertEquals(label + " linesIntersect", expected,
+                                        Line2D.linesIntersect(x1, y1, x2, y2, px, py, 4, 1));
+                                crossings += expected ? 1 : 0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        assertTrue("some segments must cross: " + crossings, crossings > 100);
+        Line2D line = new Line2D.Double(new Point2D.Double(0, 0), new Point2D.Double(10, 5));
+        java.awt.geom.Line2D real = new java.awt.geom.Line2D.Double(0, 0, 10, 5);
+        assertEquals(real.relativeCCW(3, 9), line.relativeCCW(new Point2D.Double(3, 9)));
+        assertEquals(real.ptSegDist(3, 9), line.ptSegDist(new Point2D.Double(3, 9)), TOL);
+        assertEquals(real.ptLineDistSq(30, 9), line.ptLineDistSq(30, 9), TOL);
+        assertEquals(real.intersectsLine(0, 5, 10, 0), line.intersectsLine(new Line2D.Float(0, 5, 10, 0)));
+        assertEquals(real.intersects(2, 0, 3, 3), line.intersects(2, 0, 3, 3));
+        assertFalse(line.contains(5, 2.5));
+        assertSameRect("line bounds", new java.awt.geom.Line2D.Float(9, 1, 2, 6).getBounds2D(),
+                new Line2D.Float(9, 1, 2, 6).getBounds2D(), TOL);
+        assertEquals(real.getBounds().width, line.getBounds().width);
+        assertTrue(new Line2D.Float(9, 1, 2, 6).clone() instanceof Line2D.Float);
+        assertEquals(10.0, line.getP2().getX(), 0.0);
+    }
+
+    // ---------------------------------------------------------------- flattening
+
+    private static double cubicAt(double a, double b, double c, double d, double t) {
+        double u = 1 - t;
+        return u * u * u * a + 3 * u * u * t * b + 3 * u * t * t * c + t * t * t * d;
+    }
+
+    @Test
+    public void flattenedPointsLieOnTheCurveWithinTheFlatness() {
+        double[][] curves = {
+            {0, 0, 10, 40, 60, -30, 80, 20},
+            {5, 5, 5, 95, 95, 95, 95, 5},
+            {0, 0, 100, 0, 0, 50, 100, 50},
+            {10, 10, 11, 10, 12, 10, 13, 10},
+        };
+        double[] flatnesses = {5, 1, 0.1, 0.01};
+        for (double[] k : curves) {
+            // a dense sampling of the true curve to measure against
+            int samples = 20000;
+            double[] sx = new double[samples + 1];
+            double[] sy = new double[samples + 1];
+            for (int i = 0; i <= samples; i++) {
+                double t = i / (double) samples;
+                sx[i] = cubicAt(k[0], k[2], k[4], k[6], t);
+                sy[i] = cubicAt(k[1], k[3], k[5], k[7], t);
+            }
+            CubicCurve2D curve = new CubicCurve2D.Double(k[0], k[1], k[2], k[3], k[4], k[5], k[6], k[7]);
+            int previousCount = 0;
+            for (double flatness : flatnesses) {
+                FlatteningPathIterator it = new FlatteningPathIterator(curve.getPathIterator(null), flatness);
+                assertEquals(flatness, it.getFlatness(), 0.0);
+                assertEquals(10, it.getRecursionLimit());
+                assertEquals(PathIterator.WIND_NON_ZERO, it.getWindingRule());
+                double[] c = new double[6];
+                assertEquals(PathIterator.SEG_MOVETO, it.currentSegment(c));
+                double lastX = c[0];
+                double lastY = c[1];
+                assertEquals(k[0], lastX, 0.0);
+                assertEquals(k[1], lastY, 0.0);
+                it.next();
+                int count = 0;
+                while (!it.isDone()) {
+                    assertEquals(PathIterator.SEG_LINETO, it.currentSegment(c));
+                    // the end of each line is a point of the curve itself
+                    assertTrue("end point off the curve by " + distanceToSamples(sx, sy, c[0], c[1]),
+                            distanceToSamples(sx, sy, c[0], c[1]) < 0.01);
+                    // and the line stays within the flatness of the curve
+                    for (int s = 1; s < 8; s++) {
+                        double mx = lastX + (c[0] - lastX) * s / 8.0;
+                        double my = lastY + (c[1] - lastY) * s / 8.0;
+                        double off = distanceToSamples(sx, sy, mx, my);
+                        assertTrue("line strays " + off + " at flatness " + flatness, off <= flatness + 0.01);
+                    }
+                    lastX = c[0];
+                    lastY = c[1];
+                    count++;
+                    it.next();
+                }
+                assertEquals(k[6], lastX, 0.0);
+                assertEquals(k[7], lastY, 0.0);
+                assertTrue("a finer flatness cannot need fewer lines", count >= previousCount);
+                previousCount = count;
+            }
+        }
+
+        // a quadratic and the closing of a subpath come through as well, and
+        // the limit caps the subdivision
+        Path2D path = new Path2D.Double();
+        path.moveTo(0, 0);
+        path.quadTo(50, 100, 100, 0);
+        path.closePath();
+        FlatteningPathIterator it = new FlatteningPathIterator(path.getPathIterator(null), 0.0, 3);
+        int lines = 0;
+        int closes = 0;
+        float[] f = new float[6];
+        while (!it.isDone()) {
+            int type = it.currentSegment(f);
+            assertTrue(type != PathIterator.SEG_QUADTO && type != PathIterator.SEG_CUBICTO);
+            if (type == PathIterator.SEG_LINETO) {
+                lines++;
+                // on the parabola y = x * (100 - x) / 50
+                assertEquals(f[0] * (100 - f[0]) / 50.0, f[1], 1e-3);
+            } else if (type == PathIterator.SEG_CLOSE) {
+                closes++;
+            }
+            it.next();
+        }
+        assertEquals(8, lines);
+        assertEquals(1, closes);
+        // every shape's flattening overload answers lines only
+        Shape[] shapes = {new Ellipse2D.Double(1, 2, 30, 40), new RoundRectangle2D.Double(1, 2, 30, 40, 9, 9),
+            new Arc2D.Double(1, 2, 30, 40, 10, 200, Arc2D.PIE), new QuadCurve2D.Double(1, 2, 30, 40, 9, 9), path};
+        for (Shape s : shapes) {
+            PathIterator flat = s.getPathIterator(null, 0.25);
+            int segments = 0;
+            while (!flat.isDone()) {
+                int type = flat.currentSegment(f);
+                assertTrue(type != PathIterator.SEG_QUADTO && type != PathIterator.SEG_CUBICTO);
+                segments++;
+                flat.next();
+            }
+            assertTrue(segments > 3);
+        }
+        try {
+            new FlatteningPathIterator(path.getPathIterator(null), -1.0);
+            fail("a negative flatness must be refused");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage().length() > 0);
+        }
+    }
+
+    private static double distanceToSamples(double[] sx, double[] sy, double x, double y) {
+        double best = Double.MAX_VALUE;
+        for (int i = 1; i < sx.length; i++) {
+            best = Math.min(best, java.awt.geom.Line2D.ptSegDistSq(sx[i - 1], sy[i - 1], sx[i], sy[i], x, y));
+        }
+        return Math.sqrt(best);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/beans/PropertyChangeSupportTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/beans/PropertyChangeSupportTest.java
new file mode 100644
index 00000000000..de26622d8d0
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/java/beans/PropertyChangeSupportTest.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.java.beans;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// Covers the firing rules of the bound-property support: equal values are
+/// not events, named listeners see only their property, and a proxy is
+/// registered under the name it carries.
+public class PropertyChangeSupportTest {
+
+    private static final class Recorder implements PropertyChangeListener {
+        final List<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
+
+        public void propertyChange(PropertyChangeEvent evt) {
+            events.add(evt);
+        }
+    }
+
+    private Object bean;
+
+    private PropertyChangeSupport support;
+
+    @Before
+    public void setUp() {
+        bean = new Object();
+        support = new PropertyChangeSupport(bean);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void nullSourceIsRejected() {
+        new PropertyChangeSupport(null);
+    }
+
+    @Test
+    public void unnamedListenerSeesEveryProperty() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(r);
+        support.firePropertyChange("a", "x", "y");
+        support.firePropertyChange("b", 1, 2);
+        assertEquals(2, r.events.size());
+        PropertyChangeEvent e = r.events.get(0);
+        assertSame(bean, e.getSource());
+        assertEquals("a", e.getPropertyName());
+        assertEquals("x", e.getOldValue());
+        assertEquals("y", e.getNewValue());
+        assertEquals(Integer.valueOf(2), r.events.get(1).getNewValue());
+    }
+
+    @Test
+    public void namedListenerSeesOnlyItsProperty() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener("a", r);
+        support.firePropertyChange("a", 1, 2);
+        support.firePropertyChange("b", 1, 2);
+        assertEquals(1, r.events.size());
+        assertEquals("a", r.events.get(0).getPropertyName());
+    }
+
+    @Test
+    public void noEventWhenOldAndNewAreEqual() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(r);
+        support.firePropertyChange("a", "same", new String("same"));
+        support.firePropertyChange("a", 3, 3);
+        support.firePropertyChange("a", true, true);
+        support.fireIndexedPropertyChange("a", 0, 5, 5);
+        assertTrue(r.events.isEmpty());
+    }
+
+    @Test
+    public void nullOldOrNewStillFires() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(r);
+        support.firePropertyChange("a", null, "v");
+        support.firePropertyChange("a", "v", null);
+        support.firePropertyChange("a", null, null);
+        assertEquals(3, r.events.size());
+    }
+
+    @Test
+    public void primitiveOverloadsBoxTheirValues() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(r);
+        support.firePropertyChange("i", 1, 2);
+        support.firePropertyChange("b", false, true);
+        assertEquals(Integer.valueOf(1), r.events.get(0).getOldValue());
+        assertEquals(Boolean.TRUE, r.events.get(1).getNewValue());
+    }
+
+    @Test
+    public void indexedEventsCarryTheIndex() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(r);
+        support.fireIndexedPropertyChange("a", 4, "x", "y");
+        support.fireIndexedPropertyChange("a", 5, 1, 2);
+        support.fireIndexedPropertyChange("a", 6, false, true);
+        assertEquals(3, r.events.size());
+        assertEquals(4, ((IndexedPropertyChangeEvent) r.events.get(0)).getIndex());
+        assertEquals(5, ((IndexedPropertyChangeEvent) r.events.get(1)).getIndex());
+        assertEquals(6, ((IndexedPropertyChangeEvent) r.events.get(2)).getIndex());
+    }
+
+    @Test
+    public void commonListenersFireBeforeNamedOnes() {
+        final List<String> order = new ArrayList<String>();
+        support.addPropertyChangeListener("a", new PropertyChangeListener() {
+            public void propertyChange(PropertyChangeEvent evt) {
+                order.add("named");
+            }
+        });
+        support.addPropertyChangeListener(new PropertyChangeListener() {
+            public void propertyChange(PropertyChangeEvent evt) {
+                order.add("common");
+            }
+        });
+        support.firePropertyChange("a", 1, 2);
+        assertEquals("[common, named]", order.toString());
+    }
+
+    @Test
+    public void proxyRegistersUnderItsName() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(new PropertyChangeListenerProxy("a", r));
+        assertEquals(0, support.getPropertyChangeListeners("b").length);
+        assertEquals(1, support.getPropertyChangeListeners("a").length);
+        assertSame(r, support.getPropertyChangeListeners("a")[0]);
+        support.firePropertyChange("a", 1, 2);
+        support.firePropertyChange("b", 1, 2);
+        assertEquals(1, r.events.size());
+    }
+
+    @Test
+    public void allListenersIncludeProxiesForNamedOnes() {
+        Recorder common = new Recorder();
+        Recorder named = new Recorder();
+        support.addPropertyChangeListener(common);
+        support.addPropertyChangeListener("a", named);
+        PropertyChangeListener[] all = support.getPropertyChangeListeners();
+        assertEquals(2, all.length);
+        assertSame(common, all[0]);
+        assertTrue(all[1] instanceof PropertyChangeListenerProxy);
+        PropertyChangeListenerProxy proxy = (PropertyChangeListenerProxy) all[1];
+        assertEquals("a", proxy.getPropertyName());
+        assertSame(named, proxy.getListener());
+    }
+
+    @Test
+    public void removeWorksWithAndWithoutAName() {
+        Recorder common = new Recorder();
+        Recorder named = new Recorder();
+        support.addPropertyChangeListener(common);
+        support.addPropertyChangeListener("a", named);
+        support.removePropertyChangeListener(common);
+        support.removePropertyChangeListener("a", named);
+        support.firePropertyChange("a", 1, 2);
+        assertTrue(common.events.isEmpty());
+        assertTrue(named.events.isEmpty());
+        assertEquals(0, support.getPropertyChangeListeners().length);
+    }
+
+    @Test
+    public void removingAProxyRemovesTheNamedListener() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener("a", r);
+        support.removePropertyChangeListener(new PropertyChangeListenerProxy("a", r));
+        support.firePropertyChange("a", 1, 2);
+        assertTrue(r.events.isEmpty());
+    }
+
+    @Test
+    public void hasListenersReflectsCommonAndNamed() {
+        assertFalse(support.hasListeners("a"));
+        Recorder named = new Recorder();
+        support.addPropertyChangeListener("a", named);
+        assertTrue(support.hasListeners("a"));
+        assertFalse(support.hasListeners("b"));
+        assertFalse(support.hasListeners(null));
+        support.addPropertyChangeListener(new Recorder());
+        assertTrue(support.hasListeners("b"));
+        assertTrue(support.hasListeners(null));
+    }
+
+    @Test
+    public void listenerMayRemoveItselfWhileFiring() {
+        final Recorder after = new Recorder();
+        support.addPropertyChangeListener(new PropertyChangeListener() {
+            public void propertyChange(PropertyChangeEvent evt) {
+                support.removePropertyChangeListener(this);
+            }
+        });
+        support.addPropertyChangeListener(after);
+        support.firePropertyChange("a", 1, 2);
+        support.firePropertyChange("a", 2, 3);
+        assertEquals(2, after.events.size());
+    }
+
+    @Test
+    public void fireEventDeliversTheSameInstance() {
+        Recorder r = new Recorder();
+        support.addPropertyChangeListener(r);
+        PropertyChangeEvent e = new PropertyChangeEvent(bean, "p", 1, 2);
+        support.firePropertyChange(e);
+        assertSame(e, r.events.get(0));
+    }
+
+    @Test
+    public void nullListenersAndNamesAreIgnored() {
+        support.addPropertyChangeListener((PropertyChangeListener) null);
+        support.addPropertyChangeListener("a", null);
+        support.addPropertyChangeListener(null, new Recorder());
+        assertEquals(0, support.getPropertyChangeListeners().length);
+        assertEquals(0, support.getPropertyChangeListeners("a").length);
+        assertEquals(0, support.getPropertyChangeListeners(null).length);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ButtonLabelGapsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ButtonLabelGapsTest.java
new file mode 100644
index 00000000000..4c9860714b6
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ButtonLabelGapsTest.java
@@ -0,0 +1,683 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// The button and label properties that reach the peer: icons by state,
+/// text position, alignment, gap and margin, and the labels written in
+/// HTML.
+public class ButtonLabelGapsTest extends KernelTestBase {
+
+    /// An icon of a given size that counts how often it was painted.
+    private static final class Square implements Icon {
+        private final int size;
+        int painted;
+
+        Square(int size) {
+            this.size = size;
+        }
+
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+            painted++;
+            g.fillRect(x, y, size, size);
+        }
+
+        public int getIconWidth() {
+            return size;
+        }
+
+        public int getIconHeight() {
+            return size;
+        }
+    }
+
+    private static final class Log implements PropertyChangeListener {
+        final List<String> names = new ArrayList<String>();
+
+        public void propertyChange(PropertyChangeEvent e) {
+            names.add(e.getPropertyName());
+        }
+    }
+
+    private JFrame frame(Component... cs) {
+        JFrame f = new JFrame();
+        JPanel p = new JPanel(null);
+        for (int i = 0; i < cs.length; i++) {
+            cs[i].setBounds(10, 10 + i * 110, 300, 100);
+            p.add(cs[i]);
+        }
+        f.setContentPane(p);
+        return show(f);
+    }
+
+    private static com.codename1.ui.Button peer(AbstractButton b) {
+        return (com.codename1.ui.Button) b.cn1Peer();
+    }
+
+    private static com.codename1.ui.Label peer(JLabel l) {
+        return (com.codename1.ui.Label) l.cn1Peer();
+    }
+
+    // --------------------------------------------------------- buttons
+
+    @Test
+    public void textPositionAlignmentAndGapReachThePeer() {
+        JButton b = new JButton("Go", new Square(8));
+        frame(b);
+        com.codename1.ui.Button p = peer(b);
+        assertEquals(SwingConstants.CENTER, b.getHorizontalAlignment());
+        assertEquals(SwingConstants.CENTER, b.getVerticalAlignment());
+        assertEquals(SwingConstants.TRAILING, b.getHorizontalTextPosition());
+        assertEquals(SwingConstants.CENTER, b.getVerticalTextPosition());
+        assertEquals(4, b.getIconTextGap());
+
+        b.setHorizontalTextPosition(SwingConstants.LEFT);
+        assertEquals(com.codename1.ui.Component.LEFT, p.getTextPosition());
+        b.setHorizontalTextPosition(SwingConstants.CENTER);
+        b.setVerticalTextPosition(SwingConstants.BOTTOM);
+        assertEquals(com.codename1.ui.Component.BOTTOM, p.getTextPosition());
+        b.setVerticalTextPosition(SwingConstants.TOP);
+        assertEquals(com.codename1.ui.Component.TOP, p.getTextPosition());
+        b.setHorizontalTextPosition(SwingConstants.TRAILING);
+        assertEquals(com.codename1.ui.Component.RIGHT, p.getTextPosition());
+
+        b.setHorizontalAlignment(SwingConstants.RIGHT);
+        assertEquals(com.codename1.ui.Component.RIGHT, p.getUnselectedStyle().getAlignment());
+        assertEquals(com.codename1.ui.Component.RIGHT, p.getPressedStyle().getAlignment());
+        b.setHorizontalAlignment(SwingConstants.LEADING);
+        assertEquals(com.codename1.ui.Component.LEFT, p.getUnselectedStyle().getAlignment());
+        b.setVerticalAlignment(SwingConstants.TOP);
+        assertEquals(com.codename1.ui.Component.TOP, p.getVerticalAlignment());
+        b.setVerticalAlignment(SwingConstants.BOTTOM);
+        assertEquals(com.codename1.ui.Component.BOTTOM, p.getVerticalAlignment());
+
+        b.setIconTextGap(7);
+        assertEquals(7, b.getIconTextGap());
+        assertEquals(14, p.getGap());
+    }
+
+    @Test
+    public void whatWasSetBeforeThePeerExistsReachesItToo() {
+        JButton b = new JButton("Go");
+        b.setHorizontalTextPosition(SwingConstants.LEADING);
+        b.setHorizontalAlignment(SwingConstants.TRAILING);
+        b.setVerticalAlignment(SwingConstants.BOTTOM);
+        b.setIconTextGap(3);
+        b.setMargin(new Insets(1, 2, 3, 4));
+        frame(b);
+        com.codename1.ui.Button p = peer(b);
+        assertEquals(com.codename1.ui.Component.LEFT, p.getTextPosition());
+        assertEquals(com.codename1.ui.Component.RIGHT, p.getUnselectedStyle().getAlignment());
+        assertEquals(com.codename1.ui.Component.BOTTOM, p.getVerticalAlignment());
+        assertEquals(6, p.getGap());
+        assertEquals(2, p.getUnselectedStyle().getPaddingTop());
+        assertEquals(6, p.getUnselectedStyle().getPaddingBottom());
+        assertEquals(4, p.getUnselectedStyle().getPaddingLeftNoRTL());
+        assertEquals(8, p.getUnselectedStyle().getPaddingRightNoRTL());
+    }
+
+    @Test
+    public void badAlignmentsAreRefused() {
+        JButton b = new JButton("x");
+        try {
+            b.setHorizontalAlignment(SwingConstants.TOP);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.CENTER, b.getHorizontalAlignment());
+        }
+        try {
+            b.setVerticalAlignment(SwingConstants.LEFT);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.CENTER, b.getVerticalAlignment());
+        }
+        try {
+            b.setHorizontalTextPosition(SwingConstants.BOTTOM);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.TRAILING, b.getHorizontalTextPosition());
+        }
+        try {
+            b.setVerticalTextPosition(SwingConstants.TRAILING);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.CENTER, b.getVerticalTextPosition());
+        }
+        try {
+            b.setDisplayedMnemonicIndex(1);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(-1, b.getDisplayedMnemonicIndex());
+        }
+    }
+
+    @Test
+    public void theMarginBecomesThePeersPaddingAndGoesAwayAgain() {
+        JButton b = new JButton("Go");
+        frame(b);
+        com.codename1.ui.Button p = peer(b);
+        int themeTop = p.getUnselectedStyle().getPaddingTop();
+        int themeLeft = p.getUnselectedStyle().getPaddingLeftNoRTL();
+        Dimension before = b.getPreferredSize();
+
+        b.setMargin(new Insets(10, 20, 30, 40));
+        assertEquals(new Insets(10, 20, 30, 40), b.getMargin());
+        assertEquals(20, p.getUnselectedStyle().getPaddingTop());
+        assertEquals(60, p.getUnselectedStyle().getPaddingBottom());
+        assertEquals(40, p.getUnselectedStyle().getPaddingLeftNoRTL());
+        assertEquals(80, p.getUnselectedStyle().getPaddingRightNoRTL());
+        assertEquals(20, p.getPressedStyle().getPaddingTop());
+        Dimension wide = b.getPreferredSize();
+        assertTrue(wide.width > before.width && wide.height > before.height);
+
+        b.setMargin(null);
+        assertEquals(themeTop, p.getUnselectedStyle().getPaddingTop());
+        assertEquals(themeLeft, p.getUnselectedStyle().getPaddingLeftNoRTL());
+        assertEquals(before, b.getPreferredSize());
+    }
+
+    @Test
+    public void aButtonWithoutBorderOrFillLosesBoth() {
+        JButton b = new JButton("Go");
+        frame(b);
+        com.codename1.ui.Button p = peer(b);
+        assertTrue(b.isBorderPainted());
+        assertTrue(b.isContentAreaFilled());
+        int themeTransparency = p.getUnselectedStyle().getBgTransparency() & 0xff;
+
+        b.setContentAreaFilled(false);
+        assertFalse(b.isContentAreaFilled());
+        assertEquals(0, p.getUnselectedStyle().getBgTransparency() & 0xff);
+        assertEquals(0, p.getPressedStyle().getBgTransparency() & 0xff);
+        b.setBorderPainted(false);
+        assertFalse(b.isBorderPainted());
+        com.codename1.ui.plaf.Border border = p.getUnselectedStyle().getBorder();
+        assertTrue(border == null || border.isEmptyBorder());
+
+        b.setContentAreaFilled(true);
+        b.setBorderPainted(true);
+        assertEquals(themeTransparency, p.getUnselectedStyle().getBgTransparency() & 0xff);
+    }
+
+    // The headless images have no size, so which icon reached the peer is
+    // told by which icon was painted to make the image there.
+
+    @Test
+    public void theIconsOfEachStateReachThePeer() {
+        Square plain = new Square(8);
+        Square pressed = new Square(9);
+        Square disabled = new Square(10);
+        Square rollover = new Square(11);
+        JButton b = new JButton("Go", plain);
+        frame(b);
+        com.codename1.ui.Button p = peer(b);
+        assertNotNull(p.getIcon());
+        assertEquals(1, plain.painted);
+        assertNull(p.getPressedIcon());
+        assertNull(p.getDisabledIcon());
+        assertNull(p.getRolloverIcon());
+
+        b.setPressedIcon(pressed);
+        assertNotNull(p.getPressedIcon());
+        assertNull(p.getDisabledIcon());
+        b.setDisabledIcon(disabled);
+        assertNotNull(p.getDisabledIcon());
+        assertNull(p.getRolloverIcon());
+        b.setRolloverIcon(rollover);
+        assertNotNull(p.getRolloverIcon());
+        assertSame(pressed, b.getPressedIcon());
+        assertSame(disabled, b.getDisabledIcon());
+        assertSame(rollover, b.getRolloverIcon());
+        assertNotSame(p.getIcon(), p.getPressedIcon());
+        assertNotSame(p.getPressedIcon(), p.getDisabledIcon());
+
+        // An icon is converted once, whatever else changes.
+        com.codename1.ui.Image kept = p.getPressedIcon();
+        b.setText("Other");
+        b.setIconTextGap(2);
+        assertSame(kept, p.getPressedIcon());
+        assertEquals(1, plain.painted);
+        assertEquals(1, pressed.painted);
+        assertEquals(1, disabled.painted);
+        assertEquals(1, rollover.painted);
+
+        b.setPressedIcon(null);
+        assertNull(p.getPressedIcon());
+        assertNull(b.getPressedIcon());
+        b.setIcon(null);
+        assertNull(p.getIcon());
+    }
+
+    @Test
+    public void theSelectedIconShowsWhileTheButtonIsSelected() {
+        Square plain = new Square(8);
+        Square selected = new Square(12);
+        Square disabledSelected = new Square(14);
+        JToggleButton b = new JToggleButton("T", plain);
+        b.setSelectedIcon(selected);
+        JFrame f = frame(b);
+        com.codename1.ui.Button p = peer(b);
+        assertSame(selected, b.getSelectedIcon());
+        com.codename1.ui.Image plainImage = p.getIcon();
+        assertNotNull(plainImage);
+        // Codename One shows this one on a selected toggle.
+        assertNotNull(p.getRolloverPressedIcon());
+        int plainPaints = plain.painted;
+        int selectedPaints = selected.painted;
+
+        b.setSelected(true);
+        assertNotSame(plainImage, p.getIcon());
+        assertEquals(selectedPaints + 1, selected.painted);
+        assertEquals(plainPaints, plain.painted);
+        assertNull(p.getDisabledIcon());
+        b.setDisabledSelectedIcon(disabledSelected);
+        assertSame(disabledSelected, b.getDisabledSelectedIcon());
+        assertNotNull(p.getDisabledIcon());
+        assertEquals(1, disabledSelected.painted);
+
+        com.codename1.ui.Image selectedImage = p.getIcon();
+        b.setSelected(false);
+        assertNotSame(selectedImage, p.getIcon());
+        assertEquals(plainPaints + 1, plain.painted);
+        assertNull(p.getDisabledIcon());
+
+        // Touching it selects it, and the icon follows.
+        selectedPaints = selected.painted;
+        press(f, b, 20, 20);
+        release(f, b, 20, 20);
+        assertTrue(b.isSelected());
+        assertEquals(selectedPaints + 1, selected.painted);
+        assertEquals(plainPaints + 1, plain.painted);
+    }
+
+    @Test
+    public void checkBoxesAndRadioButtonsStartLikeTheJdks() {
+        JCheckBox c = new JCheckBox("c");
+        JRadioButton r = new JRadioButton("r");
+        assertFalse(c.isBorderPainted());
+        assertFalse(r.isBorderPainted());
+        assertEquals(SwingConstants.LEADING, c.getHorizontalAlignment());
+        assertEquals(SwingConstants.LEADING, r.getHorizontalAlignment());
+        frame(c, r);
+        assertTrue(c.cn1Peer() instanceof com.codename1.ui.CheckBox);
+        assertTrue(r.cn1Peer() instanceof com.codename1.ui.RadioButton);
+        Square selected = new Square(12);
+        c.setSelectedIcon(selected);
+        c.setSelected(true);
+        assertTrue(((com.codename1.ui.CheckBox) c.cn1Peer()).isSelected());
+        assertSame(selected, c.getSelectedIcon());
+    }
+
+    @Test
+    public void aButtonDrawsItsHtmlOverTheNativeButton() {
+        JButton b = new JButton("<html><b>Save</b> <i>all</i><br>now</html>");
+        JFrame f = frame(b);
+        assertEquals("<html><b>Save</b> <i>all</i><br>now</html>", b.getText());
+        // The widget has no text of its own: the layer draws the HTML,
+        // styled and on its two lines, over the native button.
+        assertEquals("", peer(b).getText());
+        java.util.List<Object[]> drawn = paint(f);
+        Object[] save = find(drawn, "Save");
+        Object[] now = find(drawn, "now");
+        assertNotNull(save);
+        assertNotNull(now);
+        assertTrue(((Integer) now[2]).intValue() > ((Integer) save[2]).intValue());
+        // A check box keeps the text beside its mark, on one line.
+        JCheckBox c = new JCheckBox("<html><b>Save</b> all</html>");
+        frame(c);
+        assertEquals("Save all", ((com.codename1.ui.Button) c.cn1Peer()).getText());
+        b.setText("plain <b>");
+        assertEquals("plain <b>", peer(b).getText());
+        b.setText(null);
+        assertEquals("", peer(b).getText());
+    }
+
+    @Test
+    public void theRecordedButtonPropertiesFireTheJdksNames() {
+        JButton b = new JButton("Save");
+        Log log = new Log();
+        b.addPropertyChangeListener(log);
+        b.setIconTextGap(9);
+        b.setHideActionText(true);
+        b.setDisplayedMnemonicIndex(2);
+        b.setBorderPainted(false);
+        b.setContentAreaFilled(false);
+        b.setMargin(new Insets(1, 1, 1, 1));
+        b.setHorizontalAlignment(SwingConstants.LEFT);
+        b.setVerticalAlignment(SwingConstants.TOP);
+        b.setHorizontalTextPosition(SwingConstants.LEFT);
+        b.setVerticalTextPosition(SwingConstants.TOP);
+        b.setPressedIcon(new Square(4));
+        b.setSelectedIcon(new Square(4));
+        b.setDisabledIcon(new Square(4));
+        b.setDisabledSelectedIcon(new Square(4));
+        assertTrue(b.getHideActionText());
+        assertEquals(2, b.getDisplayedMnemonicIndex());
+        String[] expected = {"iconTextGap", "hideActionText", "displayedMnemonicIndex", "borderPainted",
+            "contentAreaFilled", "margin", "horizontalAlignment", "verticalAlignment", "horizontalTextPosition",
+            "verticalTextPosition", "pressedIcon", "selectedIcon", "disabledIcon", "disabledSelectedIcon"};
+        for (int i = 0; i < expected.length; i++) {
+            assertTrue(expected[i] + " in " + log.names, log.names.contains(expected[i]));
+        }
+    }
+
+    // ---------------------------------------------------------- labels
+
+    @Test
+    public void aLabelsAlignmentsAndTextPositionReachThePeer() {
+        JLabel l = new JLabel("Name", new Square(8), SwingConstants.LEADING);
+        frame(l);
+        com.codename1.ui.Label p = peer(l);
+        assertEquals(SwingConstants.CENTER, l.getVerticalAlignment());
+        assertEquals(com.codename1.ui.Component.CENTER, p.getVerticalAlignment());
+        assertEquals(com.codename1.ui.Component.RIGHT, p.getTextPosition());
+        assertEquals(8, p.getGap());
+
+        l.setVerticalAlignment(SwingConstants.TOP);
+        assertEquals(com.codename1.ui.Component.TOP, p.getVerticalAlignment());
+        l.setVerticalAlignment(SwingConstants.BOTTOM);
+        assertEquals(com.codename1.ui.Component.BOTTOM, p.getVerticalAlignment());
+        l.setHorizontalTextPosition(SwingConstants.LEFT);
+        assertEquals(com.codename1.ui.Component.LEFT, p.getTextPosition());
+        l.setHorizontalTextPosition(SwingConstants.CENTER);
+        l.setVerticalTextPosition(SwingConstants.BOTTOM);
+        assertEquals(com.codename1.ui.Component.BOTTOM, p.getTextPosition());
+        l.setVerticalTextPosition(SwingConstants.TOP);
+        assertEquals(com.codename1.ui.Component.TOP, p.getTextPosition());
+        l.setHorizontalAlignment(SwingConstants.RIGHT);
+        assertEquals(com.codename1.ui.Component.RIGHT, p.getAlignment());
+        l.setIconTextGap(10);
+        assertEquals(20, p.getGap());
+
+        try {
+            l.setVerticalAlignment(SwingConstants.LEFT);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.BOTTOM, l.getVerticalAlignment());
+        }
+        try {
+            l.setHorizontalTextPosition(SwingConstants.TOP);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.CENTER, l.getHorizontalTextPosition());
+        }
+    }
+
+    @Test
+    public void theDisabledIconShowsWhileTheLabelIsDisabled() {
+        Square plain = new Square(8);
+        Square disabled = new Square(12);
+        JLabel l = new JLabel("Name", plain, SwingConstants.LEADING);
+        l.setDisabledIcon(disabled);
+        assertSame(disabled, l.getDisabledIcon());
+        JFrame f = frame(l);
+        // An icon paints itself on the label each time the label is
+        // painted; the Codename One label behind it holds none.
+        com.codename1.ui.Label p = peer(l);
+        assertNull(p.getIcon());
+        paint(f);
+        assertEquals(0, disabled.painted);
+        int plainPaints = plain.painted;
+        assertTrue(plainPaints > 0);
+        l.setEnabled(false);
+        paint(f);
+        assertTrue(disabled.painted > 0);
+        assertEquals(plainPaints, plain.painted);
+        int disabledPaints = disabled.painted;
+        l.setEnabled(true);
+        paint(f);
+        assertEquals(disabledPaints, disabled.painted);
+        assertTrue(plain.painted > plainPaints);
+        l.setEnabled(false);
+        l.setDisabledIcon(null);
+        plainPaints = plain.painted;
+        paint(f);
+        assertEquals(disabledPaints, disabled.painted);
+        assertTrue(plain.painted > plainPaints);
+    }
+
+    @Test
+    public void theMnemonicIsRecordedWithItsIndex() {
+        JLabel l = new JLabel("Save As");
+        Log log = new Log();
+        l.addPropertyChangeListener(log);
+        assertEquals(0, l.getDisplayedMnemonic());
+        assertEquals(-1, l.getDisplayedMnemonicIndex());
+        l.setDisplayedMnemonic('a');
+        assertEquals('A', l.getDisplayedMnemonic());
+        assertEquals(1, l.getDisplayedMnemonicIndex());
+        l.setDisplayedMnemonicIndex(5);
+        assertEquals(5, l.getDisplayedMnemonicIndex());
+        l.setDisplayedMnemonic((int) 'V');
+        assertEquals(2, l.getDisplayedMnemonicIndex());
+        l.setDisplayedMnemonic('z');
+        assertEquals(-1, l.getDisplayedMnemonicIndex());
+        try {
+            l.setDisplayedMnemonicIndex(7);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(-1, l.getDisplayedMnemonicIndex());
+        }
+        assertTrue(log.names.contains("displayedMnemonic"));
+        assertTrue(log.names.contains("displayedMnemonicIndex"));
+    }
+
+    @Test
+    public void aClickOnALabelFocusesWhatItLabels() {
+        final int[] asked = {0};
+        JButton target = new JButton("target") {
+            @Override
+            public void requestFocus() {
+                asked[0]++;
+            }
+        };
+        JLabel l = new JLabel("Name");
+        Log log = new Log();
+        l.addPropertyChangeListener(log);
+        JFrame f = frame(l, target);
+        assertNull(l.getLabelFor());
+        press(f, l, 20, 20);
+        release(f, l, 20, 20);
+        assertEquals(0, asked[0]);
+
+        l.setLabelFor(target);
+        assertSame(target, l.getLabelFor());
+        assertTrue(log.names.contains("labelFor"));
+        press(f, l, 20, 20);
+        release(f, l, 20, 20);
+        assertEquals(1, asked[0]);
+
+        l.setLabelFor(null);
+        press(f, l, 20, 20);
+        release(f, l, 20, 20);
+        assertEquals(1, asked[0]);
+    }
+
+    // ------------------------------------------------------ html labels
+
+    @Test
+    public void anHtmlLabelPaintsItsRuns() {
+        JLabel l = new JLabel("<html>Hello <b>World</b><br><font color=red>second</font></html>");
+        JFrame f = frame(l);
+        assertEquals("", peer(l).getText());
+        List<Object[]> text = paint(f);
+        Object[] hello = find(text, "Hello ");
+        Object[] world = find(text, "World");
+        Object[] second = find(text, "second");
+        assertNotNull("drawn: " + names(text), hello);
+        assertNotNull("drawn: " + names(text), world);
+        assertNotNull("drawn: " + names(text), second);
+        int hx = ((Integer) hello[1]).intValue();
+        int hy = ((Integer) hello[2]).intValue();
+        int wx = ((Integer) world[1]).intValue();
+        int wy = ((Integer) world[2]).intValue();
+        int sx = ((Integer) second[1]).intValue();
+        int sy = ((Integer) second[2]).intValue();
+        // The second run follows the first on the same line, and the
+        // second line starts under the first, one line lower.
+        assertTrue(wx > hx);
+        assertEquals(hy, wy);
+        assertEquals(hx, sx);
+        assertTrue(sy > hy);
+        // Inside the label.
+        int[] origin = onDisplay(l, 0, 0);
+        assertTrue(hx >= origin[0] && hy >= origin[1]);
+        assertTrue(sy < origin[1] + 200);
+
+        // Plain again: the peer draws it.
+        l.setText("plain");
+        assertEquals("plain", peer(l).getText());
+        assertNotNull(find(paint(f), "plain"));
+    }
+
+    @Test
+    public void aTwoLineLabelIsOneLineTaller() {
+        JLabel plain = new JLabel("first");
+        JLabel one = new JLabel("<html>first</html>");
+        JLabel two = new JLabel("<html>first<br>second</html>");
+        JLabel three = new JLabel("<html>first<br>second<br>third</html>");
+        frame(plain, one, two, three);
+        Dimension p = plain.getPreferredSize();
+        Dimension a = one.getPreferredSize();
+        Dimension b = two.getPreferredSize();
+        Dimension c = three.getPreferredSize();
+        int line = b.height - a.height;
+        assertTrue("line " + line, line >= 12 && line <= 24);
+        assertEquals(line, c.height - b.height);
+        // About twice: what is left over is the padding around the text.
+        assertTrue(b.height > a.height + a.height / 2 - 4);
+        assertTrue(b.height <= 2 * a.height);
+        assertEquals(a.width + 8, b.width);
+        // An HTML label of one line is as large as the plain one.
+        assertTrue(Math.abs(a.height - p.height) <= 2);
+        assertTrue(Math.abs(a.width - p.width) <= 2);
+    }
+
+    @Test
+    public void anHtmlLabelPlacesItsIconAndWraps() {
+        Square icon = new Square(10);
+        JLabel l = new JLabel("<html>aaaa bbbb cccc dddd eeee ffff gggg hhhh iiii jjjj kkkk</html>", icon,
+                SwingConstants.CENTER);
+        JFrame f = frame(l);
+        Dimension wide = l.getPreferredSize();
+        assertTrue(wide.width > 300);
+        List<Object[]> text = paint(f);
+        assertTrue(icon.painted > 0);
+        // Wider than the label, so more than one line was drawn.
+        int firstY = ((Integer) text.get(0)[2]).intValue();
+        boolean lower = false;
+        for (int i = 0; i < text.size(); i++) {
+            if (((Integer) text.get(i)[2]).intValue() > firstY) {
+                lower = true;
+            }
+        }
+        assertTrue("drawn: " + names(text), lower);
+
+        l.setVerticalTextPosition(SwingConstants.BOTTOM);
+        l.setHorizontalTextPosition(SwingConstants.CENTER);
+        l.setVerticalAlignment(SwingConstants.TOP);
+        l.setEnabled(false);
+        assertNotSame(wide, l.getPreferredSize());
+        assertTrue(l.getPreferredSize().height > wide.height);
+        assertFalse(paint(f).isEmpty());
+    }
+
+    @Test
+    public void malformedHtmlInALabelDoesNotThrow() {
+        String[] bad = {"<html><b>unclosed <i>x</b> y </zzz> <", "<html>", "<html><", "<html>&#;&bogus <font color=",
+            "<html><p><p></center><br>"};
+        JLabel l = new JLabel();
+        JButton b = new JButton();
+        JFrame f = frame(l, b);
+        for (int i = 0; i < bad.length; i++) {
+            l.setText(bad[i]);
+            b.setText(bad[i]);
+            assertNotNull(l.getPreferredSize());
+            assertNotNull(b.getPreferredSize());
+            assertNotNull(paint(f));
+        }
+        l.setText(bad[0]);
+        assertNotNull(find(paint(f), "unclosed "));
+    }
+
+    private static String names(List<Object[]> text) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < text.size(); i++) {
+            sb.append('[').append(text.get(i)[0]).append(']');
+        }
+        return sb.toString();
+    }
+
+    /// The theme of an application sets the font of its buttons and the
+    /// platform theme under it declares what a button looks like under
+    /// the pointer, with the platform's font: a button with no font of
+    /// its own keeps the one it was measured with while the pointer is
+    /// over it, and so does one that was restyled since.
+    @Test
+    public void aButtonUnderThePointerKeepsTheFontItHasAtRest() {
+        // The fonts of the headless display are all equal to one another,
+        // and a style takes no font that equals the one it has: a font of
+        // another kind is the only one a theme can be seen to give.
+        com.codename1.ui.Font platform = com.codename1.ui.Font.createBitmapFont(
+                com.codename1.ui.Image.createImage(8, 8), new int[]{0}, new int[]{8}, "a");
+        java.util.Hashtable<String, Object> theme = new java.util.Hashtable<String, Object>();
+        theme.put("Button.hover#font", platform);
+        com.codename1.ui.plaf.UIManager.getInstance().addThemeProps(theme);
+        try {
+            assertSame(platform, new com.codename1.ui.Button("Stop").getHoverStyle().getFont());
+            JButton b = new JButton("Stop");
+            JFrame f = new JFrame();
+            f.getContentPane().add(b);
+            f.setSize(200, 100);
+            show(f);
+            com.codename1.ui.Component peer = b.cn1Peer();
+            assertNotNull("the theme styles a button under the pointer", peer.getHoverStyle());
+            assertSame(peer.getUnselectedStyle().getFont(), peer.getHoverStyle().getFont());
+            // A margin takes the styles from the theme again.
+            b.setMargin(new Insets(3, 3, 3, 3));
+            b.setMargin(new Insets(4, 4, 4, 4));
+            assertSame(peer.getUnselectedStyle().getFont(), peer.getHoverStyle().getFont());
+        } finally {
+            com.codename1.ui.plaf.UIManager.getInstance().setThemeProps(new java.util.Hashtable<String, Object>());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/DefaultButtonModelTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/DefaultButtonModelTest.java
new file mode 100644
index 00000000000..a7e0abd932a
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/DefaultButtonModelTest.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// Covers the state machine of the button model: the state bits, the events
+/// each change fires, and the exclusivity a `ButtonGroup` imposes on the
+/// models it holds.
+public class DefaultButtonModelTest {
+
+    private DefaultButtonModel model;
+
+    private int changes;
+
+    private final List<ActionEvent> actions = new ArrayList<ActionEvent>();
+
+    private final List<ItemEvent> items = new ArrayList<ItemEvent>();
+
+    @Before
+    public void setUp() {
+        model = new DefaultButtonModel();
+        listen(model);
+    }
+
+    private void listen(DefaultButtonModel m) {
+        m.addChangeListener(new ChangeListener() {
+            public void stateChanged(ChangeEvent e) {
+                changes++;
+            }
+        });
+        m.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                actions.add(e);
+            }
+        });
+        m.addItemListener(new ItemListener() {
+            public void itemStateChanged(ItemEvent e) {
+                items.add(e);
+            }
+        });
+    }
+
+    @Test
+    public void startsEnabledAndNothingElse() {
+        DefaultButtonModel fresh = new DefaultButtonModel();
+        assertTrue(fresh.isEnabled());
+        assertFalse(fresh.isArmed());
+        assertFalse(fresh.isSelected());
+        assertFalse(fresh.isPressed());
+        assertFalse(fresh.isRollover());
+        assertEquals(DefaultButtonModel.ENABLED, fresh.stateMask);
+        assertNull(fresh.getSelectedObjects());
+    }
+
+    @Test
+    public void constantsAreDistinctBits() {
+        assertEquals(1, DefaultButtonModel.ARMED);
+        assertEquals(2, DefaultButtonModel.SELECTED);
+        assertEquals(4, DefaultButtonModel.PRESSED);
+        assertEquals(8, DefaultButtonModel.ENABLED);
+        assertEquals(16, DefaultButtonModel.ROLLOVER);
+    }
+
+    @Test
+    public void stateChangesFireChangeEventsOnlyWhenTheStateMoves() {
+        model.setArmed(true);
+        assertEquals(1, changes);
+        model.setArmed(true);
+        assertEquals(1, changes);
+        model.setRollover(true);
+        assertEquals(2, changes);
+        model.setMnemonic('A');
+        assertEquals(3, changes);
+        assertEquals('A', model.getMnemonic());
+    }
+
+    @Test
+    public void releasingWhileArmedFiresOneActionEvent() {
+        model.setActionCommand("go");
+        model.setArmed(true);
+        model.setPressed(true);
+        assertTrue(actions.isEmpty());
+        model.setPressed(false);
+        assertEquals(1, actions.size());
+        ActionEvent e = actions.get(0);
+        assertEquals("go", e.getActionCommand());
+        assertEquals(ActionEvent.ACTION_PERFORMED, e.getID());
+        assertSame(model, e.getSource());
+    }
+
+    @Test
+    public void releasingWhileNotArmedFiresNoAction() {
+        model.setPressed(true);
+        model.setPressed(false);
+        assertTrue(actions.isEmpty());
+    }
+
+    @Test
+    public void disabledModelIgnoresArmPressAndRollover() {
+        model.setEnabled(false);
+        int before = changes;
+        model.setArmed(true);
+        model.setPressed(true);
+        model.setRollover(true);
+        assertEquals(before, changes);
+        assertFalse(model.isArmed());
+        assertFalse(model.isPressed());
+        assertFalse(model.isRollover());
+    }
+
+    @Test
+    public void disablingClearsArmedAndPressed() {
+        model.setArmed(true);
+        model.setPressed(true);
+        model.setEnabled(false);
+        assertFalse(model.isArmed());
+        assertFalse(model.isPressed());
+        assertFalse(model.isEnabled());
+    }
+
+    @Test
+    public void selectionFiresItemThenChangeEvents() {
+        model.setSelected(true);
+        assertTrue(model.isSelected());
+        assertEquals(1, items.size());
+        assertEquals(ItemEvent.SELECTED, items.get(0).getStateChange());
+        assertSame(model, items.get(0).getItem());
+        assertSame(model, items.get(0).getItemSelectable());
+        assertEquals(1, changes);
+        model.setSelected(true);
+        assertEquals(1, items.size());
+        model.setSelected(false);
+        assertEquals(ItemEvent.DESELECTED, items.get(1).getStateChange());
+        assertEquals(2, changes);
+    }
+
+    @Test
+    public void listenersCanBeRemovedAndListed() {
+        assertEquals(1, model.getChangeListeners().length);
+        assertEquals(1, model.getActionListeners().length);
+        assertEquals(1, model.getItemListeners().length);
+        model.removeChangeListener(model.getChangeListeners()[0]);
+        model.removeActionListener(model.getActionListeners()[0]);
+        model.removeItemListener(model.getItemListeners()[0]);
+        model.setSelected(true);
+        assertEquals(0, changes);
+        assertTrue(items.isEmpty());
+    }
+
+    @Test
+    public void groupKeepsOneModelSelected() {
+        ButtonGroup group = new ButtonGroup();
+        DefaultButtonModel a = new DefaultButtonModel();
+        DefaultButtonModel b = new DefaultButtonModel();
+        a.setGroup(group);
+        b.setGroup(group);
+        assertSame(group, a.getGroup());
+        a.setSelected(true);
+        assertTrue(a.isSelected());
+        assertSame(a, group.getSelection());
+        b.setSelected(true);
+        assertTrue(b.isSelected());
+        assertFalse(a.isSelected());
+        assertSame(b, group.getSelection());
+        assertTrue(group.isSelected(b));
+        assertFalse(group.isSelected(a));
+    }
+
+    @Test
+    public void groupedModelCannotBeDeselectedDirectly() {
+        ButtonGroup group = new ButtonGroup();
+        DefaultButtonModel a = new DefaultButtonModel();
+        a.setGroup(group);
+        a.setSelected(true);
+        a.setSelected(false);
+        assertTrue(a.isSelected());
+        assertSame(a, group.getSelection());
+    }
+
+    @Test
+    public void groupFiresEventsOnBothModels() {
+        ButtonGroup group = new ButtonGroup();
+        DefaultButtonModel a = new DefaultButtonModel();
+        DefaultButtonModel b = new DefaultButtonModel();
+        a.setGroup(group);
+        b.setGroup(group);
+        listen(a);
+        listen(b);
+        a.setSelected(true);
+        int itemsAfterA = items.size();
+        assertEquals(1, itemsAfterA);
+        b.setSelected(true);
+        assertEquals(3, items.size());
+        assertEquals(ItemEvent.DESELECTED, items.get(1).getStateChange());
+        assertSame(a, items.get(1).getItem());
+        assertEquals(ItemEvent.SELECTED, items.get(2).getStateChange());
+        assertSame(b, items.get(2).getItem());
+    }
+
+    @Test
+    public void clearSelectionDeselectsTheModel() {
+        ButtonGroup group = new ButtonGroup();
+        DefaultButtonModel a = new DefaultButtonModel();
+        a.setGroup(group);
+        a.setSelected(true);
+        group.clearSelection();
+        assertFalse(a.isSelected());
+        assertNull(group.getSelection());
+        assertEquals(0, group.getButtonCount());
+    }
+
+    @Test
+    public void ungroupedModelsAreIndependent() {
+        DefaultButtonModel a = new DefaultButtonModel();
+        DefaultButtonModel b = new DefaultButtonModel();
+        a.setSelected(true);
+        b.setSelected(true);
+        assertTrue(a.isSelected());
+        assertTrue(b.isSelected());
+        a.setSelected(false);
+        assertFalse(a.isSelected());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/EditableComboBoxTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/EditableComboBoxTest.java
new file mode 100644
index 00000000000..a5ceec6700e
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/EditableComboBoxTest.java
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.awt.event.ItemEvent;
+import com.codename1.desktopcompat.java.awt.event.ItemListener;
+import com.codename1.desktopcompat.rt.ComboPeer;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// An editable combo box has a text field to type into, and the popup of
+/// either kind opens, closes and reports a selection only once.
+public class EditableComboBoxTest extends KernelTestBase {
+
+    private static final class Log implements ActionListener, ItemListener {
+        final List<String> lines = new ArrayList<String>();
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            lines.add("action " + e.getActionCommand());
+        }
+
+        @Override
+        public void itemStateChanged(ItemEvent e) {
+            lines.add((e.getStateChange() == ItemEvent.SELECTED ? "selected " : "deselected ") + e.getItem());
+        }
+    }
+
+    private JFrame frame(JComponent c) {
+        JFrame f = new JFrame();
+        f.getContentPane().setLayout(new FlowLayout());
+        f.add(c);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        return f;
+    }
+
+    @Test
+    public void theEditorIsATextFieldShowingTheSelection() {
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"apple", "banana", "a rather longer cherry"});
+        assertNull(combo.getEditor());
+        combo.setEditable(true);
+        ComboBoxEditor editor = combo.getEditor();
+        assertNotNull(editor);
+        Component c = editor.getEditorComponent();
+        assertTrue(c instanceof JTextField);
+        JTextField field = (JTextField) c;
+        assertEquals("apple", field.getText());
+        assertEquals("apple", editor.getItem());
+        JFrame f = frame(combo);
+        assertSame(combo, field.getParent());
+        assertTrue("the field has room: " + field.getWidth(), field.getWidth() > 40);
+        assertTrue("for the longest item",
+                field.getWidth() >= field.getFontMetrics(field.getFont()).stringWidth("a rather longer cherry"));
+        assertTrue(field.getHeight() > 0);
+        assertNotNull("the field draws its text", find(paint(f), "apple"));
+        combo.setSelectedItem("banana");
+        assertEquals("banana", field.getText());
+        assertNotNull(find(paint(f), "banana"));
+    }
+
+    @Test
+    public void enterMakesTheTextTheSelectedItem() {
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"apple", "banana"});
+        combo.setEditable(true);
+        frame(combo);
+        Log log = new Log();
+        combo.addActionListener(log);
+        combo.addItemListener(log);
+        JTextField field = (JTextField) combo.getEditor().getEditorComponent();
+        field.setText("typed");
+        assertEquals("not before Enter", "apple", combo.getSelectedItem());
+        assertEquals("typed", combo.getEditor().getItem());
+        field.postActionEvent();
+        assertEquals("typed", combo.getSelectedItem());
+        assertEquals(-1, combo.getSelectedIndex());
+        assertEquals("[deselected apple, selected typed, action comboBoxChanged, action comboBoxEdited]",
+                log.lines.toString());
+        assertEquals("comboBoxChanged", combo.getActionCommand());
+
+        // Enter on a listed item selects it.
+        log.lines.clear();
+        field.setText("banana");
+        field.postActionEvent();
+        assertEquals(1, combo.getSelectedIndex());
+        assertEquals("[deselected typed, selected banana, action comboBoxChanged, action comboBoxEdited]",
+                log.lines.toString());
+    }
+
+    @Test
+    public void theEventsOfAnEditAreTheDesktopOnes() {
+        JComboBox<String> ours = new JComboBox<String>(new String[]{"apple", "banana"});
+        javax.swing.JComboBox<String> real = new javax.swing.JComboBox<String>(new String[]{"apple", "banana"});
+        ours.setEditable(true);
+        real.setEditable(true);
+        final List<String> oursLog = new ArrayList<String>();
+        final List<String> realLog = new ArrayList<String>();
+        ours.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                oursLog.add(e.getActionCommand());
+            }
+        });
+        real.addActionListener(new java.awt.event.ActionListener() {
+            @Override
+            public void actionPerformed(java.awt.event.ActionEvent e) {
+                realLog.add(e.getActionCommand());
+            }
+        });
+        ((JTextField) ours.getEditor().getEditorComponent()).setText("typed");
+        ((javax.swing.JTextField) real.getEditor().getEditorComponent()).setText("typed");
+        ours.actionPerformed(new ActionEvent(ours.getEditor(), ActionEvent.ACTION_PERFORMED, ""));
+        real.actionPerformed(new java.awt.event.ActionEvent(real.getEditor(), 1001, ""));
+        assertEquals(realLog, oursLog);
+        assertEquals(real.getSelectedItem(), ours.getSelectedItem());
+        assertEquals(real.getEditor().getItem(), ours.getEditor().getItem());
+    }
+
+    @Test
+    public void anItemThatIsNotAStringComesBackAsItself() {
+        Integer seven = Integer.valueOf(7);
+        JComboBox<Integer> combo = new JComboBox<Integer>(new Integer[]{seven, Integer.valueOf(8)});
+        combo.setEditable(true);
+        assertSame(seven, combo.getEditor().getItem());
+        ((JTextField) combo.getEditor().getEditorComponent()).setText("9");
+        assertEquals("9", combo.getEditor().getItem());
+    }
+
+    @Test
+    public void theArrowOpensAMenuOfTheItems() {
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"apple", "banana"});
+        combo.setEditable(true);
+        JFrame f = frame(combo);
+        Log log = new Log();
+        combo.addActionListener(log);
+        combo.addItemListener(log);
+        assertFalse(combo.isPopupVisible());
+        JButton arrow = (JButton) combo.getComponent(1);
+        press(f, arrow, 4, 4);
+        release(f, arrow, 4, 4);
+        assertTrue(combo.isPopupVisible());
+        assertNotNull(find(paint(f), "banana"));
+        assertEquals("opening selects nothing", 0, log.lines.size());
+
+        // Closing it from code selects nothing either.
+        combo.hidePopup();
+        assertFalse(combo.isPopupVisible());
+        assertEquals(0, log.lines.size());
+
+        combo.showPopup();
+        assertTrue(combo.isPopupVisible());
+        JPopupMenu menu = (JPopupMenu) SwingUtilities.getRootPane(combo).getLayeredPane().getComponent(0);
+        JMenuItem banana = (JMenuItem) menu.getComponent(1);
+        assertEquals("banana", banana.getText());
+        banana.doClick();
+        assertEquals("banana", combo.getSelectedItem());
+        assertEquals("banana", ((JTextField) combo.getEditor().getEditorComponent()).getText());
+        assertEquals("[deselected apple, selected banana, action comboBoxChanged]", log.lines.toString());
+    }
+
+    @Test
+    public void editableCanBeTurnedOnAndOffAfterShowing() {
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"apple", "banana"});
+        JFrame f = frame(combo);
+        com.codename1.ui.Component first = combo.cn1Peer();
+        assertTrue(first instanceof ComboPeer);
+        com.codename1.ui.Container host = first.getParent();
+        combo.setEditable(true);
+        f.validate();
+        com.codename1.ui.Component second = combo.cn1Peer();
+        assertFalse(second instanceof ComboPeer);
+        assertSame("in the place of the old peer", host, second.getParent());
+        assertNull(first.getParent());
+        assertEquals(2, combo.getComponentCount());
+        assertTrue(combo.getEditor().getEditorComponent().getWidth() > 0);
+        combo.setEditable(false);
+        f.validate();
+        assertTrue(combo.cn1Peer() instanceof ComboPeer);
+        assertEquals(0, combo.getComponentCount());
+        assertSame(host, combo.cn1Peer().getParent());
+    }
+
+    @Test
+    public void aCustomEditorIsUsed() {
+        final JTextField mine = new JTextField("mine");
+        final Object[] set = new Object[1];
+        ComboBoxEditor editor = new ComboBoxEditor() {
+            @Override
+            public Component getEditorComponent() {
+                return mine;
+            }
+
+            @Override
+            public void setItem(Object anObject) {
+                set[0] = anObject;
+            }
+
+            @Override
+            public Object getItem() {
+                return "from mine";
+            }
+
+            @Override
+            public void selectAll() {
+            }
+
+            @Override
+            public void addActionListener(ActionListener l) {
+                mine.addActionListener(l);
+            }
+
+            @Override
+            public void removeActionListener(ActionListener l) {
+                mine.removeActionListener(l);
+            }
+        };
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"apple", "banana"});
+        combo.setEditable(true);
+        combo.setEditor(editor);
+        frame(combo);
+        assertSame(editor, combo.getEditor());
+        assertSame(combo, mine.getParent());
+        assertEquals("apple", set[0]);
+        mine.postActionEvent();
+        assertEquals("from mine", combo.getSelectedItem());
+        assertEquals("from mine", set[0]);
+    }
+
+    // ------------------------------------------------- the modal popup
+
+    @Test
+    public void highlightingInTheModalPopupIsNotASelection() {
+        JComboBox<String> combo = new JComboBox<String>(new String[]{"apple", "banana", "cherry"});
+        frame(combo);
+        Log log = new Log();
+        combo.addActionListener(log);
+        combo.addItemListener(log);
+        com.codename1.ui.list.ListModel<Object> widget = ((ComboPeer) combo.cn1Peer()).getModel();
+
+        // Dismissed: the widget walks its highlight and then puts it back.
+        combo.cn1PopupOpening();
+        widget.setSelectedIndex(1);
+        widget.setSelectedIndex(2);
+        assertEquals("the popup shows its highlight", 2, widget.getSelectedIndex());
+        assertEquals("apple", combo.getSelectedItem());
+        widget.setSelectedIndex(0);
+        combo.cn1PopupClosed(false);
+        assertEquals("apple", combo.getSelectedItem());
+        assertEquals("a cancelled popup fires nothing", 0, log.lines.size());
+
+        // Picked: one round of events, when the popup has closed.
+        combo.cn1PopupOpening();
+        widget.setSelectedIndex(1);
+        widget.setSelectedIndex(2);
+        assertEquals(0, log.lines.size());
+        combo.cn1PopupClosed(false);
+        assertEquals("cherry", combo.getSelectedItem());
+        assertEquals(2, widget.getSelectedIndex());
+        assertEquals("[deselected apple, selected cherry, action comboBoxChanged]", log.lines.toString());
+
+        // Closed from code: the highlight is given up.
+        log.lines.clear();
+        combo.cn1PopupOpening();
+        widget.setSelectedIndex(0);
+        combo.cn1PopupClosed(true);
+        assertEquals("cherry", combo.getSelectedItem());
+        assertEquals(2, widget.getSelectedIndex());
+        assertEquals(0, log.lines.size());
+        assertFalse(combo.isPopupVisible());
+        // With nothing open, hiding is harmless.
+        combo.hidePopup();
+        assertEquals(0, log.lines.size());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/EditorPaneHtmlTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/EditorPaneHtmlTest.java
new file mode 100644
index 00000000000..1af98f5cc07
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/EditorPaneHtmlTest.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.javax.swing.event.HyperlinkEvent;
+import com.codename1.desktopcompat.javax.swing.event.HyperlinkListener;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// An editor pane with the content type `text/html` shows the page
+/// formatted and reports clicks on its links.
+public class EditorPaneHtmlTest extends KernelTestBase {
+
+    private static final String PAGE = "<html><head><title>Hidden</title></head><body><h1>Title</h1>"
+            + "<p>Some <b>bold</b> text.</p><p>See <a href=\"https://example.com/docs\">the docs</a> or "
+            + "<a href=\"chapter2\">next</a>.</p></body></html>";
+
+    private JFrame frame(JComponent c) {
+        JFrame f = new JFrame();
+        f.add(c, BorderLayout.CENTER);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        return f;
+    }
+
+    @Test
+    public void thePageIsDrawnInRunsNotAsMarkup() {
+        JEditorPane pane = new JEditorPane("text/html", PAGE);
+        JFrame f = frame(pane);
+        List<Object[]> text = paint(f);
+        assertNotNull("the heading is a run of its own", find(text, "Title"));
+        assertNotNull(find(text, "bold"));
+        assertNotNull(find(text, "the docs"));
+        assertNull(find(text, "Hidden"));
+        for (int i = 0; i < text.size(); i++) {
+            assertFalse("no markup is drawn: " + text.get(i)[0], String.valueOf(text.get(i)[0]).indexOf('<') >= 0);
+        }
+        // The heading stands above the paragraph.
+        int headingY = ((Integer) find(text, "Title")[2]).intValue();
+        int boldY = ((Integer) find(text, "bold")[2]).intValue();
+        assertTrue(headingY < boldY);
+        assertEquals(PAGE, pane.getText());
+        assertEquals("text/html", pane.getContentType());
+    }
+
+    @Test
+    public void aClickOnALinkFiresAnActivatedEvent() {
+        JEditorPane pane = new JEditorPane("text/html", PAGE);
+        JFrame f = frame(pane);
+        final List<HyperlinkEvent> heard = new ArrayList<HyperlinkEvent>();
+        pane.addHyperlinkListener(new HyperlinkListener() {
+            @Override
+            public void hyperlinkUpdate(HyperlinkEvent e) {
+                heard.add(e);
+            }
+        });
+        List<Object[]> text = paint(f);
+        Object[] link = find(text, "the docs");
+        int[] origin = onDisplay(pane, 0, 0);
+        int x = Units.toLogical(((Integer) link[1]).intValue() - origin[0]) + 4;
+        int y = Units.toLogical(((Integer) link[2]).intValue() - origin[1]) + 2;
+        assertEquals("https://example.com/docs", pane.cn1LinkAt(x, y));
+        press(f, pane, x, y);
+        release(f, pane, x, y);
+        assertEquals(1, heard.size());
+        HyperlinkEvent e = heard.get(0);
+        assertSame(HyperlinkEvent.EventType.ACTIVATED, e.getEventType());
+        assertEquals("https://example.com/docs", e.getDescription());
+        assertEquals("https://example.com/docs", e.getURL().toString());
+        assertSame(pane, e.getSource());
+
+        // A relative link has a description and no URL.
+        Object[] next = find(text, "next");
+        x = Units.toLogical(((Integer) next[1]).intValue() - origin[0]) + 4;
+        y = Units.toLogical(((Integer) next[2]).intValue() - origin[1]) + 2;
+        press(f, pane, x, y);
+        release(f, pane, x, y);
+        assertEquals(2, heard.size());
+        assertEquals("chapter2", heard.get(1).getDescription());
+        assertNull(heard.get(1).getURL());
+
+        // Text that is not a link fires nothing.
+        Object[] plain = find(text, "Title");
+        x = Units.toLogical(((Integer) plain[1]).intValue() - origin[0]) + 4;
+        y = Units.toLogical(((Integer) plain[2]).intValue() - origin[1]) + 2;
+        assertNull(pane.cn1LinkAt(x, y));
+        press(f, pane, x, y);
+        release(f, pane, x, y);
+        assertEquals(2, heard.size());
+        pane.removeHyperlinkListener(pane.getHyperlinkListeners()[0]);
+        assertEquals(0, pane.getHyperlinkListeners().length);
+    }
+
+    @Test
+    public void aPageIsNotEditedAndPlainTextStillIs() {
+        JEditorPane pane = new JEditorPane("text/html", PAGE);
+        frame(pane);
+        com.codename1.ui.TextArea peer = (com.codename1.ui.TextArea) pane.cn1Peer();
+        assertFalse(peer.isEditable());
+        pane.setContentType("text/plain");
+        pane.setText("plain");
+        assertTrue(peer.isEditable());
+        assertEquals("plain", pane.getText());
+    }
+
+    @Test
+    public void aLongParagraphIsWrappedAndThePaneGrowsWithIt() {
+        StringBuilder sb = new StringBuilder("<html><p>");
+        for (int i = 0; i < 60; i++) {
+            sb.append("word").append(i).append(' ');
+        }
+        sb.append("</p></html>");
+        JTextPane pane = new JTextPane();
+        pane.setContentType("text/html");
+        pane.setText(sb.toString());
+        JScrollPane scroll = new JScrollPane(pane);
+        JFrame f = frame(scroll);
+        assertEquals(scroll.getViewport().getExtentSize().width, pane.getWidth());
+        List<Object[]> text = paint(f);
+        int first = -1;
+        int lines = 0;
+        for (int i = 0; i < text.size(); i++) {
+            int y = ((Integer) text.get(i)[2]).intValue();
+            if (y != first) {
+                lines++;
+                first = y;
+            }
+        }
+        assertTrue("several lines: " + lines, lines > 2);
+        int oneLine = pane.getFontMetrics(pane.getFont()).getHeight();
+        assertTrue(pane.getPreferredSize().height >= lines * oneLine);
+    }
+
+    /// An `<img>` is a word of its line, at the size its tag gives, found
+    /// through the source the caller hands the parser; without a source,
+    /// or when the picture is not found, it leaves nothing.
+    @Test
+    public void anImageStandsInItsLineAtTheSizeItsTagGives() {
+        final List<String> asked = new ArrayList<String>();
+        final com.codename1.desktopcompat.java.awt.Image pic =
+                new com.codename1.desktopcompat.java.awt.image.BufferedImage(20, 10,
+                        com.codename1.desktopcompat.java.awt.image.BufferedImage.TYPE_INT_RGB);
+        com.codename1.desktopcompat.rt.MiniHtml.ImageSource source =
+                new com.codename1.desktopcompat.rt.MiniHtml.ImageSource() {
+            @Override
+            public com.codename1.desktopcompat.java.awt.Image image(String src) {
+                asked.add(src);
+                return "missing.png".equals(src) ? null : pic;
+            }
+        };
+        String html = "<html>top<br><img src=\"a/pic.png\" width=\"80\" height=\"60\">after"
+                + "<img src=\"missing.png\"><br><img src='own.png'></html>";
+        com.codename1.desktopcompat.rt.MiniHtml.Document doc =
+                com.codename1.desktopcompat.rt.MiniHtml.parse(html, source);
+        assertEquals("[a/pic.png, missing.png, own.png]", asked.toString());
+        assertEquals(3, doc.lineCount());
+        assertEquals(2, doc.line(1).runCount());
+        assertSame(pic, doc.line(1).run(0).image());
+        assertEquals(80, doc.line(1).run(0).imageWidth());
+        assertEquals(60, doc.line(1).run(0).imageHeight());
+        assertNull(doc.line(1).run(1).image());
+        assertEquals("after", doc.line(1).text());
+        // Without a size the picture has its own.
+        assertEquals(20, doc.line(2).run(0).imageWidth());
+        assertEquals(10, doc.line(2).run(0).imageHeight());
+
+        com.codename1.desktopcompat.java.awt.Font font = com.codename1.desktopcompat.rt.Fonts.defaultFont();
+        com.codename1.desktopcompat.java.awt.FontMetrics fm = com.codename1.desktopcompat.rt.Fonts.metrics(font);
+        com.codename1.desktopcompat.java.awt.Dimension size =
+                com.codename1.desktopcompat.rt.MiniHtml.preferredSize(doc, font);
+        assertEquals(80 + fm.stringWidth("after"), size.width);
+        int descent = fm.getHeight() - fm.getAscent();
+        // A line that is only an image is as tall as the image.
+        assertEquals(fm.getHeight() + Math.max(fm.getHeight(), 60 + descent) + 10, size.height);
+        // Too narrow for both: the image keeps its line, the word moves on.
+        com.codename1.desktopcompat.rt.MiniHtml.Document wrapped =
+                com.codename1.desktopcompat.rt.MiniHtml.wrap(doc, font, 80 + fm.stringWidth("after") - 1);
+        assertEquals(4, wrapped.lineCount());
+        assertSame(pic, wrapped.line(1).run(0).image());
+        assertEquals("after", wrapped.line(2).text());
+
+        // A parser without a source drops images and keeps the text.
+        com.codename1.desktopcompat.rt.MiniHtml.Document plain =
+                com.codename1.desktopcompat.rt.MiniHtml.parse(html);
+        assertEquals(2, plain.lineCount());
+        assertEquals("after", plain.line(1).text());
+
+        // In an editor pane the text after the picture is drawn after it.
+        JEditorPane pane = new JEditorPane("text/html", "<html>x</html>");
+        JFrame f = frame(pane);
+        assertNotNull(find(paint(f), "x"));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/GroupLayoutParityTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/GroupLayoutParityTest.java
new file mode 100644
index 00000000000..b85f72b25c0
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/GroupLayoutParityTest.java
@@ -0,0 +1,1523 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.codename1.compat.testing.ReferenceJdk;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// Builds the same group layout with the JDK's `javax.swing.GroupLayout`
+/// and with this layer's, and requires identical bounds for every
+/// component and identical preferred, minimum and maximum layout sizes.
+///
+/// A layout is described once, as a [Spec], and built from both class
+/// libraries. The components are bare ones with fixed sizes and the layout
+/// style is an explicit one answering the same numbers on both sides, so
+/// nothing depends on a look and feel and the JDK side runs headless.
+/// Each layout is run at its preferred size, smaller, larger and at zero,
+/// and a few hundred more are drawn from a seeded random generator.
+public class GroupLayoutParityTest {
+
+    static {
+        System.setProperty("java.awt.headless", "true");
+    }
+
+    private static final int SEQ = 0;
+    private static final int PAR = 1;
+    private static final int COMP = 2;
+    private static final int GAP = 3;
+    private static final int AUTO_GAP = 4;
+    private static final int PAIR_GAP = 5;
+    private static final int EDGE_GAP = 6;
+
+    private static final int LEADING = 0;
+    private static final int TRAILING = 1;
+    private static final int CENTER = 2;
+    private static final int BASELINE = 3;
+
+    private static final int RELATED = 0;
+    private static final int UNRELATED = 1;
+    private static final int INDENT = 2;
+
+    private static final int D = -1;
+    private static final int P = -2;
+
+    /// One element of a group, independent of the class library.
+    private static final class S {
+        final int kind;
+        int align = LEADING;
+        boolean resizable = true;
+        // 0: createParallelGroup, 1: baseline group anchored to the top,
+        // 2: baseline group anchored to the bottom
+        int anchor;
+        int childAlign = -1;
+        boolean asBaseline;
+        int comp;
+        int comp2;
+        int min = D;
+        int pref = D;
+        int max = D;
+        int type;
+        final List<S> kids = new ArrayList<S>();
+
+        S(int kind) {
+            this.kind = kind;
+        }
+
+        S al(int a) {
+            childAlign = a;
+            return this;
+        }
+
+        S bl() {
+            asBaseline = true;
+            return this;
+        }
+
+        S fixed() {
+            resizable = false;
+            return this;
+        }
+
+        void describe(StringBuilder sb, String indent) {
+            sb.append(indent);
+            switch (kind) {
+                case SEQ:
+                    sb.append("seq");
+                    break;
+                case PAR:
+                    sb.append("par align=").append(align).append(" resizable=").append(resizable).append(" anchor=")
+                            .append(anchor);
+                    break;
+                case COMP:
+                    sb.append("comp ").append(comp).append(' ').append(min).append('/').append(pref).append('/')
+                            .append(max);
+                    break;
+                case GAP:
+                    sb.append("gap ").append(min).append('/').append(pref).append('/').append(max);
+                    break;
+                case AUTO_GAP:
+                    sb.append("autogap type=").append(type).append(' ').append(pref).append('/').append(max);
+                    break;
+                case PAIR_GAP:
+                    sb.append("pairgap ").append(comp).append(',').append(comp2).append(" type=").append(type)
+                            .append(' ').append(pref).append('/').append(max);
+                    break;
+                default:
+                    sb.append("edgegap ").append(pref).append('/').append(max);
+                    break;
+            }
+            if (childAlign >= 0) {
+                sb.append(" childAlign=").append(childAlign);
+            }
+            if (asBaseline) {
+                sb.append(" asBaseline");
+            }
+            sb.append('\n');
+            for (S k : kids) {
+                k.describe(sb, indent + "  ");
+            }
+        }
+    }
+
+    /// One component, independent of the class library.
+    private static final class C {
+        int pw;
+        int ph;
+        int minw;
+        int minh;
+        int maxw = -1;
+        int maxh = -1;
+        boolean plain;
+        boolean hidden;
+        int baseline = -1;
+        // 0: follows the layout, 1: Boolean.TRUE, 2: Boolean.FALSE
+        int honors;
+
+        C min(int w, int h) {
+            minw = w;
+            minh = h;
+            return this;
+        }
+
+        C max(int w, int h) {
+            maxw = w;
+            maxh = h;
+            return this;
+        }
+
+        C plain() {
+            plain = true;
+            return this;
+        }
+
+        C hide() {
+            hidden = true;
+            return this;
+        }
+
+        C base(int b) {
+            baseline = b;
+            return this;
+        }
+
+        C honors(boolean b) {
+            honors = b ? 1 : 2;
+            return this;
+        }
+    }
+
+    /// A whole layout, independent of the class library.
+    private static final class Spec {
+        final List<C> comps = new ArrayList<C>();
+        S h;
+        S v;
+        boolean autoGaps;
+        boolean autoContainerGaps;
+        boolean honorsVisibility = true;
+        int[] border;
+        final List<int[]> links = new ArrayList<int[]>();
+
+        int add(C c) {
+            comps.add(c);
+            return comps.size() - 1;
+        }
+
+        /// Links the listed components along `axis`: 0 horizontal, 1
+        /// vertical, 2 both.
+        Spec link(int axis, int... which) {
+            int[] l = new int[which.length + 1];
+            l[0] = axis;
+            System.arraycopy(which, 0, l, 1, which.length);
+            links.add(l);
+            return this;
+        }
+
+        String describe() {
+            StringBuilder sb = new StringBuilder();
+            sb.append("autoGaps=").append(autoGaps).append(" autoContainerGaps=").append(autoContainerGaps)
+                    .append(" honorsVisibility=").append(honorsVisibility).append(" border=")
+                    .append(java.util.Arrays.toString(border)).append('\n');
+            for (int i = 0; i < comps.size(); i++) {
+                C c = comps.get(i);
+                sb.append("  ").append(i).append(": pref=").append(c.pw).append('x').append(c.ph).append(" min=")
+                        .append(c.minw).append('x').append(c.minh).append(" max=").append(c.maxw).append('x')
+                        .append(c.maxh).append(c.plain ? " plain" : "").append(c.hidden ? " hidden" : "")
+                        .append(" baseline=").append(c.baseline).append(" honors=").append(c.honors).append('\n');
+            }
+            for (int[] l : links) {
+                sb.append("  link ").append(java.util.Arrays.toString(l)).append('\n');
+            }
+            sb.append("horizontal\n");
+            h.describe(sb, "  ");
+            sb.append("vertical\n");
+            v.describe(sb, "  ");
+            return sb.toString();
+        }
+    }
+
+    private static C comp(int w, int h) {
+        C c = new C();
+        c.pw = w;
+        c.ph = h;
+        c.minw = w;
+        c.minh = h;
+        return c;
+    }
+
+    private static S seq(S... kids) {
+        S s = new S(SEQ);
+        Collections.addAll(s.kids, kids);
+        return s;
+    }
+
+    private static S par(int align, S... kids) {
+        S s = new S(PAR);
+        s.align = align;
+        Collections.addAll(s.kids, kids);
+        return s;
+    }
+
+    private static S base(boolean anchorTop, S... kids) {
+        S s = new S(PAR);
+        s.anchor = anchorTop ? 1 : 2;
+        Collections.addAll(s.kids, kids);
+        return s;
+    }
+
+    private static S c(int index) {
+        S s = new S(COMP);
+        s.comp = index;
+        return s;
+    }
+
+    private static S c(int index, int min, int pref, int max) {
+        S s = c(index);
+        s.min = min;
+        s.pref = pref;
+        s.max = max;
+        return s;
+    }
+
+    private static S gap(int size) {
+        return gap(size, size, size);
+    }
+
+    private static S gap(int min, int pref, int max) {
+        S s = new S(GAP);
+        s.min = min;
+        s.pref = pref;
+        s.max = max;
+        return s;
+    }
+
+    private static S auto(int type) {
+        return auto(type, D, D);
+    }
+
+    private static S auto(int type, int pref, int max) {
+        S s = new S(AUTO_GAP);
+        s.type = type;
+        s.pref = pref;
+        s.max = max;
+        return s;
+    }
+
+    private static S pair(int a, int b, int type) {
+        return pair(a, b, type, D, P);
+    }
+
+    private static S pair(int a, int b, int type, int pref, int max) {
+        S s = new S(PAIR_GAP);
+        s.comp = a;
+        s.comp2 = b;
+        s.type = type;
+        s.pref = pref;
+        s.max = max;
+        return s;
+    }
+
+    private static S edge() {
+        return edge(D, D);
+    }
+
+    private static S edge(int pref, int max) {
+        S s = new S(EDGE_GAP);
+        s.pref = pref;
+        s.max = max;
+        return s;
+    }
+
+    // The numbers both layout styles answer. They vary with the kind of
+    // gap, with the position and with the components, so that a wrong
+    // argument shows up as a different layout.
+    private static int styleGap(int type, int position, int w1, int h2) {
+        int gap = type == RELATED ? 5 : type == UNRELATED ? 11 : 17;
+        if (position == 5) {
+            gap += 2;
+        } else if (position != 3) {
+            gap += 40;
+        }
+        return gap + w1 % 3 + h2 % 2;
+    }
+
+    private static int styleEdge(int position, int h) {
+        int gap;
+        switch (position) {
+            case 7:
+                gap = 7;
+                break;
+            case 1:
+                gap = 9;
+                break;
+            case 3:
+                gap = 4;
+                break;
+            case 5:
+                gap = 13;
+                break;
+            default:
+                gap = 60;
+                break;
+        }
+        return gap + h % 2;
+    }
+
+    // ------------------------------------------------------------------
+    // The JDK side
+
+    private static final class RealStyle extends javax.swing.LayoutStyle {
+        @Override
+        public int getPreferredGap(javax.swing.JComponent a, javax.swing.JComponent b,
+                javax.swing.LayoutStyle.ComponentPlacement type, int position, java.awt.Container parent) {
+            return styleGap(type.ordinal(), position, a.getPreferredSize().width, b.getPreferredSize().height);
+        }
+
+        @Override
+        public int getContainerGap(javax.swing.JComponent c, int position, java.awt.Container parent) {
+            return styleEdge(position, c.getPreferredSize().height);
+        }
+    }
+
+    private static final class RealLeaf extends javax.swing.JComponent {
+        private static final long serialVersionUID = 1L;
+        private final int baseline;
+
+        RealLeaf(int baseline) {
+            this.baseline = baseline;
+        }
+
+        @Override
+        public int getBaseline(int width, int height) {
+            return baseline;
+        }
+    }
+
+    private static final class Real {
+        javax.swing.JComponent host;
+        javax.swing.GroupLayout layout;
+        java.awt.Component[] comps;
+    }
+
+    private static javax.swing.GroupLayout.Alignment realAlign(int a) {
+        return javax.swing.GroupLayout.Alignment.values()[a];
+    }
+
+    private static javax.swing.LayoutStyle.ComponentPlacement realType(int t) {
+        return javax.swing.LayoutStyle.ComponentPlacement.values()[t];
+    }
+
+    private static javax.swing.GroupLayout.Group real(Real r, S s) {
+        javax.swing.GroupLayout l = r.layout;
+        if (s.kind == SEQ) {
+            javax.swing.GroupLayout.SequentialGroup g = l.createSequentialGroup();
+            for (S k : s.kids) {
+                switch (k.kind) {
+                    case COMP:
+                        if (k.asBaseline) {
+                            if (k.min == D && k.pref == D && k.max == D) {
+                                g.addComponent(true, r.comps[k.comp]);
+                            } else {
+                                g.addComponent(true, r.comps[k.comp], k.min, k.pref, k.max);
+                            }
+                        } else if (k.min == D && k.pref == D && k.max == D) {
+                            g.addComponent(r.comps[k.comp]);
+                        } else {
+                            g.addComponent(r.comps[k.comp], k.min, k.pref, k.max);
+                        }
+                        break;
+                    case GAP:
+                        if (k.min == k.pref && k.pref == k.max) {
+                            g.addGap(k.pref);
+                        } else {
+                            g.addGap(k.min, k.pref, k.max);
+                        }
+                        break;
+                    case AUTO_GAP:
+                        if (k.pref == D && k.max == D) {
+                            g.addPreferredGap(realType(k.type));
+                        } else {
+                            g.addPreferredGap(realType(k.type), k.pref, k.max);
+                        }
+                        break;
+                    case PAIR_GAP:
+                        if (k.pref == D && k.max == P) {
+                            g.addPreferredGap((javax.swing.JComponent) r.comps[k.comp],
+                                    (javax.swing.JComponent) r.comps[k.comp2], realType(k.type));
+                        } else {
+                            g.addPreferredGap((javax.swing.JComponent) r.comps[k.comp],
+                                    (javax.swing.JComponent) r.comps[k.comp2], realType(k.type), k.pref, k.max);
+                        }
+                        break;
+                    case EDGE_GAP:
+                        if (k.pref == D && k.max == D) {
+                            g.addContainerGap();
+                        } else {
+                            g.addContainerGap(k.pref, k.max);
+                        }
+                        break;
+                    default:
+                        if (k.asBaseline) {
+                            g.addGroup(true, real(r, k));
+                        } else {
+                            g.addGroup(real(r, k));
+                        }
+                        break;
+                }
+            }
+            return g;
+        }
+        javax.swing.GroupLayout.ParallelGroup g;
+        if (s.anchor != 0) {
+            g = l.createBaselineGroup(s.resizable, s.anchor == 1);
+        } else if (s.resizable && s.align == LEADING) {
+            g = l.createParallelGroup();
+        } else if (s.resizable) {
+            g = l.createParallelGroup(realAlign(s.align));
+        } else {
+            g = l.createParallelGroup(realAlign(s.align), false);
+        }
+        for (S k : s.kids) {
+            switch (k.kind) {
+                case COMP:
+                    if (k.childAlign >= 0) {
+                        if (k.min == D && k.pref == D && k.max == D) {
+                            g.addComponent(r.comps[k.comp], realAlign(k.childAlign));
+                        } else {
+                            g.addComponent(r.comps[k.comp], realAlign(k.childAlign), k.min, k.pref, k.max);
+                        }
+                    } else if (k.min == D && k.pref == D && k.max == D) {
+                        g.addComponent(r.comps[k.comp]);
+                    } else {
+                        g.addComponent(r.comps[k.comp], k.min, k.pref, k.max);
+                    }
+                    break;
+                case GAP:
+                    if (k.min == k.pref && k.pref == k.max) {
+                        g.addGap(k.pref);
+                    } else {
+                        g.addGap(k.min, k.pref, k.max);
+                    }
+                    break;
+                default:
+                    if (k.childAlign >= 0) {
+                        g.addGroup(realAlign(k.childAlign), real(r, k));
+                    } else {
+                        g.addGroup(real(r, k));
+                    }
+                    break;
+            }
+        }
+        return g;
+    }
+
+    private static Real real(Spec spec) {
+        Real r = new Real();
+        r.host = new javax.swing.JComponent() {
+            private static final long serialVersionUID = 1L;
+        };
+        if (spec.border != null) {
+            r.host.setBorder(javax.swing.BorderFactory.createEmptyBorder(spec.border[0], spec.border[1],
+                    spec.border[2], spec.border[3]));
+        }
+        r.layout = new javax.swing.GroupLayout(r.host);
+        r.host.setLayout(r.layout);
+        r.layout.setLayoutStyle(new RealStyle());
+        r.comps = new java.awt.Component[spec.comps.size()];
+        for (int i = 0; i < r.comps.length; i++) {
+            C c = spec.comps.get(i);
+            java.awt.Component k = c.plain ? new java.awt.Component() {
+                private static final long serialVersionUID = 1L;
+            } : new RealLeaf(c.baseline);
+            k.setPreferredSize(new java.awt.Dimension(c.pw, c.ph));
+            k.setMinimumSize(new java.awt.Dimension(c.minw, c.minh));
+            if (c.maxw >= 0) {
+                k.setMaximumSize(new java.awt.Dimension(c.maxw, c.maxh));
+            }
+            k.setVisible(!c.hidden);
+            r.comps[i] = k;
+        }
+        r.layout.setAutoCreateGaps(spec.autoGaps);
+        r.layout.setAutoCreateContainerGaps(spec.autoContainerGaps);
+        r.layout.setHonorsVisibility(spec.honorsVisibility);
+        r.layout.setHorizontalGroup(real(r, spec.h));
+        r.layout.setVerticalGroup(real(r, spec.v));
+        for (int i = 0; i < r.comps.length; i++) {
+            int honors = spec.comps.get(i).honors;
+            if (honors != 0) {
+                r.layout.setHonorsVisibility(r.comps[i], honors == 1 ? Boolean.TRUE : Boolean.FALSE);
+            }
+        }
+        for (int[] link : spec.links) {
+            java.awt.Component[] set = new java.awt.Component[link.length - 1];
+            for (int i = 0; i < set.length; i++) {
+                set[i] = r.comps[link[i + 1]];
+            }
+            if (link[0] == 2) {
+                r.layout.linkSize(set);
+            } else {
+                r.layout.linkSize(link[0], set);
+            }
+        }
+        return r;
+    }
+
+    private static String dump(Real r) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < r.comps.length; i++) {
+            java.awt.Component c = r.comps[i];
+            sb.append(i).append(' ').append(c.getX()).append(',').append(c.getY()).append(' ').append(c.getWidth())
+                    .append('x').append(c.getHeight()).append('\n');
+        }
+        java.awt.Dimension p = r.layout.preferredLayoutSize(r.host);
+        java.awt.Dimension m = r.layout.minimumLayoutSize(r.host);
+        java.awt.Dimension x = r.layout.maximumLayoutSize(r.host);
+        sb.append("pref=").append(p.width).append('x').append(p.height).append(" min=").append(m.width).append('x')
+                .append(m.height).append(" max=").append(x.width).append('x').append(x.height).append('\n');
+        return sb.toString();
+    }
+
+    // ------------------------------------------------------------------
+    // This layer's side
+
+    private static final class OurStyle extends LayoutStyle {
+        @Override
+        public int getPreferredGap(JComponent a, JComponent b, LayoutStyle.ComponentPlacement type, int position,
+                Container parent) {
+            return styleGap(type.ordinal(), position, a.getPreferredSize().width, b.getPreferredSize().height);
+        }
+
+        @Override
+        public int getContainerGap(JComponent c, int position, Container parent) {
+            return styleEdge(position, c.getPreferredSize().height);
+        }
+    }
+
+    private static final class OurLeaf extends JComponent {
+        private final int baseline;
+
+        OurLeaf(int baseline) {
+            this.baseline = baseline;
+        }
+
+        @Override
+        public int getBaseline(int width, int height) {
+            return baseline;
+        }
+    }
+
+    private static final class Ours {
+        JComponent host;
+        GroupLayout layout;
+        Component[] comps;
+    }
+
+    private static GroupLayout.Alignment ourAlign(int a) {
+        return GroupLayout.Alignment.values()[a];
+    }
+
+    private static LayoutStyle.ComponentPlacement ourType(int t) {
+        return LayoutStyle.ComponentPlacement.values()[t];
+    }
+
+    private static GroupLayout.Group ours(Ours r, S s) {
+        GroupLayout l = r.layout;
+        if (s.kind == SEQ) {
+            GroupLayout.SequentialGroup g = l.createSequentialGroup();
+            for (S k : s.kids) {
+                switch (k.kind) {
+                    case COMP:
+                        if (k.asBaseline) {
+                            if (k.min == D && k.pref == D && k.max == D) {
+                                g.addComponent(true, r.comps[k.comp]);
+                            } else {
+                                g.addComponent(true, r.comps[k.comp], k.min, k.pref, k.max);
+                            }
+                        } else if (k.min == D && k.pref == D && k.max == D) {
+                            g.addComponent(r.comps[k.comp]);
+                        } else {
+                            g.addComponent(r.comps[k.comp], k.min, k.pref, k.max);
+                        }
+                        break;
+                    case GAP:
+                        if (k.min == k.pref && k.pref == k.max) {
+                            g.addGap(k.pref);
+                        } else {
+                            g.addGap(k.min, k.pref, k.max);
+                        }
+                        break;
+                    case AUTO_GAP:
+                        if (k.pref == D && k.max == D) {
+                            g.addPreferredGap(ourType(k.type));
+                        } else {
+                            g.addPreferredGap(ourType(k.type), k.pref, k.max);
+                        }
+                        break;
+                    case PAIR_GAP:
+                        if (k.pref == D && k.max == P) {
+                            g.addPreferredGap((JComponent) r.comps[k.comp], (JComponent) r.comps[k.comp2],
+                                    ourType(k.type));
+                        } else {
+                            g.addPreferredGap((JComponent) r.comps[k.comp], (JComponent) r.comps[k.comp2],
+                                    ourType(k.type), k.pref, k.max);
+                        }
+                        break;
+                    case EDGE_GAP:
+                        if (k.pref == D && k.max == D) {
+                            g.addContainerGap();
+                        } else {
+                            g.addContainerGap(k.pref, k.max);
+                        }
+                        break;
+                    default:
+                        if (k.asBaseline) {
+                            g.addGroup(true, ours(r, k));
+                        } else {
+                            g.addGroup(ours(r, k));
+                        }
+                        break;
+                }
+            }
+            return g;
+        }
+        GroupLayout.ParallelGroup g;
+        if (s.anchor != 0) {
+            g = l.createBaselineGroup(s.resizable, s.anchor == 1);
+        } else if (s.resizable && s.align == LEADING) {
+            g = l.createParallelGroup();
+        } else if (s.resizable) {
+            g = l.createParallelGroup(ourAlign(s.align));
+        } else {
+            g = l.createParallelGroup(ourAlign(s.align), false);
+        }
+        for (S k : s.kids) {
+            switch (k.kind) {
+                case COMP:
+                    if (k.childAlign >= 0) {
+                        if (k.min == D && k.pref == D && k.max == D) {
+                            g.addComponent(r.comps[k.comp], ourAlign(k.childAlign));
+                        } else {
+                            g.addComponent(r.comps[k.comp], ourAlign(k.childAlign), k.min, k.pref, k.max);
+                        }
+                    } else if (k.min == D && k.pref == D && k.max == D) {
+                        g.addComponent(r.comps[k.comp]);
+                    } else {
+                        g.addComponent(r.comps[k.comp], k.min, k.pref, k.max);
+                    }
+                    break;
+                case GAP:
+                    if (k.min == k.pref && k.pref == k.max) {
+                        g.addGap(k.pref);
+                    } else {
+                        g.addGap(k.min, k.pref, k.max);
+                    }
+                    break;
+                default:
+                    if (k.childAlign >= 0) {
+                        g.addGroup(ourAlign(k.childAlign), ours(r, k));
+                    } else {
+                        g.addGroup(ours(r, k));
+                    }
+                    break;
+            }
+        }
+        return g;
+    }
+
+    private static Ours ours(Spec spec) {
+        Ours r = new Ours();
+        r.host = new JComponent() {
+        };
+        if (spec.border != null) {
+            r.host.setBorder(new EmptyBorder(spec.border[0], spec.border[1], spec.border[2], spec.border[3]));
+        }
+        r.layout = new GroupLayout(r.host);
+        r.host.setLayout(r.layout);
+        r.layout.setLayoutStyle(new OurStyle());
+        r.comps = new Component[spec.comps.size()];
+        for (int i = 0; i < r.comps.length; i++) {
+            C c = spec.comps.get(i);
+            Component k = c.plain ? new Component() {
+            } : new OurLeaf(c.baseline);
+            k.setPreferredSize(new Dimension(c.pw, c.ph));
+            k.setMinimumSize(new Dimension(c.minw, c.minh));
+            if (c.maxw >= 0) {
+                k.setMaximumSize(new Dimension(c.maxw, c.maxh));
+            }
+            k.setVisible(!c.hidden);
+            r.comps[i] = k;
+        }
+        r.layout.setAutoCreateGaps(spec.autoGaps);
+        r.layout.setAutoCreateContainerGaps(spec.autoContainerGaps);
+        r.layout.setHonorsVisibility(spec.honorsVisibility);
+        r.layout.setHorizontalGroup(ours(r, spec.h));
+        r.layout.setVerticalGroup(ours(r, spec.v));
+        for (int i = 0; i < r.comps.length; i++) {
+            int honors = spec.comps.get(i).honors;
+            if (honors != 0) {
+                r.layout.setHonorsVisibility(r.comps[i], honors == 1 ? Boolean.TRUE : Boolean.FALSE);
+            }
+        }
+        for (int[] link : spec.links) {
+            Component[] set = new Component[link.length - 1];
+            for (int i = 0; i < set.length; i++) {
+                set[i] = r.comps[link[i + 1]];
+            }
+            if (link[0] == 2) {
+                r.layout.linkSize(set);
+            } else {
+                r.layout.linkSize(link[0], set);
+            }
+        }
+        return r;
+    }
+
+    private static String dump(Ours r) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < r.comps.length; i++) {
+            Component c = r.comps[i];
+            sb.append(i).append(' ').append(c.getX()).append(',').append(c.getY()).append(' ').append(c.getWidth())
+                    .append('x').append(c.getHeight()).append('\n');
+        }
+        Dimension p = r.layout.preferredLayoutSize(r.host);
+        Dimension m = r.layout.minimumLayoutSize(r.host);
+        Dimension x = r.layout.maximumLayoutSize(r.host);
+        sb.append("pref=").append(p.width).append('x').append(p.height).append(" min=").append(m.width).append('x')
+                .append(m.height).append(" max=").append(x.width).append('x').append(x.height).append('\n');
+        return sb.toString();
+    }
+
+    // ------------------------------------------------------------------
+
+    // How many steps the JDK laid out without throwing.
+    private static int laidOut;
+
+    /// Runs one step on each side and requires the same outcome, a dump or
+    /// the class of what was thrown.
+    private static void same(String what, Spec spec, Real r, Ours o, int w, int h) {
+        String expected;
+        try {
+            r.host.setSize(w, h);
+            r.host.invalidate();
+            r.host.doLayout();
+            expected = dump(r);
+            laidOut++;
+        } catch (RuntimeException e) {
+            expected = "threw " + e.getClass().getName();
+        }
+        String actual;
+        try {
+            o.host.setSize(w, h);
+            o.host.invalidate();
+            o.host.doLayout();
+            actual = dump(o);
+        } catch (RuntimeException e) {
+            actual = "threw " + e.getClass().getName() + " " + e.getMessage();
+            if (expected.startsWith("threw ") && actual.startsWith(expected)) {
+                actual = expected;
+            }
+        }
+        if (!expected.equals(actual)) {
+            assertEquals(what + " at " + w + "x" + h + "\n" + spec.describe(), expected, actual);
+        }
+    }
+
+    /// Builds the layout from both libraries and lays it out at its
+    /// preferred size, around it, at nothing and at the sizes given.
+    private static void check(String what, Spec spec, int... sizes) {
+        Real r;
+        String thrown = null;
+        try {
+            r = real(spec);
+        } catch (RuntimeException e) {
+            r = null;
+            thrown = e.getClass().getName();
+        }
+        Ours o;
+        try {
+            o = ours(spec);
+            if (thrown != null) {
+                fail(what + ": the JDK threw " + thrown + " building this, the layer did not\n" + spec.describe());
+            }
+        } catch (RuntimeException e) {
+            if (thrown == null) {
+                throw new AssertionError(what + ": only the layer threw building this\n" + spec.describe(), e);
+            }
+            assertEquals(what + "\n" + spec.describe(), thrown, e.getClass().getName());
+            return;
+        }
+        java.awt.Dimension p;
+        try {
+            p = r.layout.preferredLayoutSize(r.host);
+        } catch (RuntimeException e) {
+            p = new java.awt.Dimension(100, 100);
+        }
+        same(what, spec, r, o, p.width, p.height);
+        same(what, spec, r, o, p.width + 57, p.height + 31);
+        same(what, spec, r, o, p.width - 13, p.height - 7);
+        same(what, spec, r, o, p.width / 2, p.height / 2);
+        same(what, spec, r, o, 0, 0);
+        same(what, spec, r, o, 1200, 900);
+        same(what, spec, r, o, p.width, p.height);
+        for (int i = 0; i < sizes.length; i += 2) {
+            same(what, spec, r, o, sizes[i], sizes[i + 1]);
+        }
+    }
+
+    /// Every test here lays the same tree out with the JDK's `GroupLayout`
+    /// and compares pixels. The JDK's side reaches `sun.swing`, which a
+    /// modular JDK does not export, and its unbounded maximum size changed.
+    @Before
+    public void onTheReferenceJdkOnly() {
+        ReferenceJdk.assume("stopped exporting sun.swing.DefaultLayoutStyle, and no longer caps a group's "
+                + "maximum size at Short.MAX_VALUE");
+    }
+
+    @After
+    public void restoreSharedStyle() {
+        LayoutStyle.setInstance(null);
+    }
+
+    // ------------------------------------------------------------------
+
+    @Test
+    public void sequentialAndParallelWithExplicitGaps() {
+        Spec s = new Spec();
+        int a = s.add(comp(40, 20));
+        int b = s.add(comp(70, 35).min(20, 10).max(300, 400));
+        int d = s.add(comp(55, 28).min(11, 7));
+        s.h = seq(c(a), gap(8), c(b), gap(4, 10, 30), c(d));
+        s.v = par(LEADING, c(a), c(b), c(d));
+        check("row", s, 400, 100);
+
+        s = new Spec();
+        a = s.add(comp(40, 20));
+        b = s.add(comp(70, 35).min(20, 10).max(300, 400));
+        d = s.add(comp(55, 28).min(11, 7).plain());
+        s.border = new int[] {3, 5, 7, 9};
+        s.h = par(LEADING, c(a), c(b), c(d));
+        s.v = seq(gap(6), c(a), gap(0, 5, Short.MAX_VALUE), c(b), gap(2, 9, P), c(d), gap(P, 3, 3));
+        check("column with insets", s, 200, 300);
+    }
+
+    @Test
+    public void everyAlignment() {
+        for (int group = LEADING; group <= CENTER; group++) {
+            for (int resizable = 0; resizable < 2; resizable++) {
+                Spec s = new Spec();
+                int a = s.add(comp(40, 20));
+                int b = s.add(comp(70, 35).max(90, 50));
+                int d = s.add(comp(55, 28).min(11, 7).max(55, 28));
+                int e = s.add(comp(30, 12).min(30, 12).max(30, 12));
+                int f = s.add(comp(31, 13).max(31, 13));
+                S hp = par(group, c(a), c(b).al(TRAILING), c(d).al(CENTER), c(e).al(LEADING), c(f));
+                S vp = par(group, c(a).al(CENTER), c(b), c(d).al(TRAILING), c(e), c(f).al(LEADING));
+                if (resizable == 0) {
+                    hp.fixed();
+                    vp.fixed();
+                }
+                s.h = seq(gap(3), hp);
+                s.v = seq(vp, gap(3));
+                check("alignment " + group + " resizable " + resizable, s, 150, 150);
+            }
+        }
+    }
+
+    @Test
+    public void baselineGroups() {
+        for (int variant = 0; variant < 6; variant++) {
+            Spec s = new Spec();
+            int a = s.add(comp(40, 20).base(14));
+            int b = s.add(comp(70, 35).base(30).max(90, 60));
+            int d = s.add(comp(55, 28).min(11, 7));
+            int e = s.add(comp(30, 44).base(9).min(30, 10));
+            s.h = seq(c(a), c(b), c(d), c(e));
+            S row;
+            if (variant == 0) {
+                row = par(BASELINE, c(a), c(b), c(d), c(e));
+            } else if (variant == 1) {
+                row = par(BASELINE, c(a), c(b), c(d), c(e)).fixed();
+            } else if (variant == 2) {
+                row = base(true, c(a), c(b).al(BASELINE), c(d).al(CENTER), c(e).al(TRAILING));
+            } else if (variant == 3) {
+                row = base(false, c(a), c(b), c(d), c(e));
+            } else if (variant == 4) {
+                row = base(false, c(a), c(b).al(LEADING), c(e)).fixed();
+                s.h = seq(c(a), c(b), c(e), c(d));
+                s.v = seq(row, c(d));
+                check("baseline variant " + variant, s);
+                continue;
+            } else {
+                // A baseline group of sequences, each naming its baseline
+                // element.
+                row = par(BASELINE, seq(gap(4), c(a).bl(), gap(2, 6, 20)), seq(c(d), c(b).bl()), c(e));
+            }
+            s.v = seq(gap(2), row, gap(0, 3, 50));
+            check("baseline variant " + variant, s, 300, 200);
+        }
+    }
+
+    @Test
+    public void baselineAlongTheHorizontalAxisIsRejected() {
+        Spec s = new Spec();
+        int a = s.add(comp(40, 20).base(14));
+        int b = s.add(comp(70, 35).base(30));
+        s.h = par(BASELINE, c(a), c(b));
+        s.v = seq(c(a), c(b));
+        check("horizontal baseline", s);
+    }
+
+    @Test
+    public void preferredGaps() {
+        for (int autoGaps = 0; autoGaps < 2; autoGaps++) {
+            for (int autoEdges = 0; autoEdges < 2; autoEdges++) {
+                Spec s = new Spec();
+                s.autoGaps = autoGaps == 1;
+                s.autoContainerGaps = autoEdges == 1;
+                int a = s.add(comp(40, 20));
+                int b = s.add(comp(71, 35).min(20, 10).max(300, 400));
+                int d = s.add(comp(55, 28).min(11, 7));
+                int e = s.add(comp(30, 13));
+                int f = s.add(comp(64, 22).plain());
+                s.h = seq(c(a), auto(RELATED), c(b), auto(UNRELATED), c(d), c(e), auto(RELATED, 20, 40), c(f));
+                s.v = par(LEADING, c(a), c(b), c(d), c(e), c(f));
+                check("auto gaps " + autoGaps + " edges " + autoEdges, s, 500, 80);
+
+                s = new Spec();
+                s.autoGaps = autoGaps == 1;
+                s.autoContainerGaps = autoEdges == 1;
+                a = s.add(comp(40, 20));
+                b = s.add(comp(71, 35).min(20, 10).max(300, 400));
+                d = s.add(comp(55, 28).min(11, 7));
+                e = s.add(comp(30, 13));
+                f = s.add(comp(64, 22).plain());
+                s.border = new int[] {1, 2, 3, 4};
+                s.h = seq(edge(), par(LEADING, c(a), c(b), seq(c(d), c(e), auto(UNRELATED, P, 90), c(f))),
+                        edge(20, 30));
+                s.v = seq(edge(2, P), c(a), pair(a, b, UNRELATED), c(b), pair(b, d, INDENT, 30, 60),
+                        par(TRAILING, c(d), c(e), c(f)), edge());
+                check("form with gaps " + autoGaps + " edges " + autoEdges, s, 400, 300);
+            }
+        }
+    }
+
+    @Test
+    public void containerGapsInTheMiddleAndAround() {
+        Spec s = new Spec();
+        s.autoContainerGaps = true;
+        s.autoGaps = true;
+        int a = s.add(comp(40, 21));
+        int b = s.add(comp(71, 35).plain());
+        int d = s.add(comp(55, 28));
+        s.h = par(CENTER, c(a), seq(c(b), c(d)));
+        s.v = seq(c(a), par(LEADING, c(b), c(d)));
+        check("auto everything", s, 300, 200);
+
+        s = new Spec();
+        a = s.add(comp(40, 21));
+        b = s.add(comp(71, 35));
+        s.h = seq(c(a), edge(), c(b), edge());
+        s.v = seq(edge(), par(LEADING, c(a), c(b)));
+        check("edge gap between components", s, 300, 200);
+    }
+
+    @Test
+    public void linkedSizes() {
+        for (int axis = 0; axis <= 2; axis++) {
+            Spec s = new Spec();
+            int a = s.add(comp(40, 20).min(5, 5));
+            int b = s.add(comp(70, 35).min(20, 10).max(300, 400));
+            int d = s.add(comp(55, 28).min(11, 7));
+            int e = s.add(comp(90, 12));
+            s.h = seq(c(a), gap(5), c(b), gap(5), c(d), gap(1, 5, 100), c(e));
+            s.v = par(CENTER, c(a), c(b), c(d), c(e));
+            s.link(axis, a, b, d);
+            check("link axis " + axis, s, 500, 100);
+
+            s = new Spec();
+            a = s.add(comp(40, 20).min(5, 5));
+            b = s.add(comp(70, 35).hide());
+            d = s.add(comp(55, 28).min(11, 7));
+            e = s.add(comp(90, 12).plain());
+            s.autoGaps = true;
+            s.h = seq(c(a), c(b), c(d), c(e));
+            s.v = par(CENTER, c(a), c(b), c(d), c(e));
+            s.link(axis, a, b).link(axis, d, e).link(axis, b, e);
+            check("merged links with a hidden member, axis " + axis, s, 500, 100);
+        }
+    }
+
+    @Test
+    public void invisibleComponents() {
+        for (int honors = 0; honors < 2; honors++) {
+            for (int autoGaps = 0; autoGaps < 2; autoGaps++) {
+                Spec s = new Spec();
+                s.honorsVisibility = honors == 1;
+                s.autoGaps = autoGaps == 1;
+                s.autoContainerGaps = autoGaps == 1;
+                int a = s.add(comp(40, 20));
+                int b = s.add(comp(70, 35).hide());
+                int d = s.add(comp(55, 28).hide().honors(false));
+                int e = s.add(comp(90, 12).hide().honors(true));
+                int f = s.add(comp(33, 33));
+                s.h = seq(c(a), gap(5), c(b), auto(RELATED), c(d), c(e), auto(UNRELATED), c(f));
+                s.v = seq(par(LEADING, c(a), c(b), c(d)), par(TRAILING, c(e), c(f)));
+                check("invisible, honors " + honors + " gaps " + autoGaps, s, 400, 200);
+            }
+        }
+    }
+
+    @Test
+    public void nestedGroups() {
+        Spec s = new Spec();
+        s.autoGaps = true;
+        s.autoContainerGaps = true;
+        s.border = new int[] {4, 4, 4, 4};
+        int l1 = s.add(comp(60, 16));
+        int l2 = s.add(comp(85, 16));
+        int l3 = s.add(comp(45, 16));
+        int f1 = s.add(comp(120, 22).min(40, 22).max(Short.MAX_VALUE, 22));
+        int f2 = s.add(comp(120, 22).min(40, 22).max(Short.MAX_VALUE, 22));
+        int f3 = s.add(comp(120, 80).min(40, 30).max(Short.MAX_VALUE, Short.MAX_VALUE));
+        int ok = s.add(comp(70, 26));
+        int cancel = s.add(comp(90, 26));
+        s.h = par(LEADING,
+                seq(par(TRAILING, c(l1), c(l2), c(l3)), par(LEADING, c(f1), c(f2), c(f3))),
+                seq(gap(0, 0, Short.MAX_VALUE), c(ok), c(cancel)).al(TRAILING));
+        s.v = seq(par(CENTER, c(l1), c(f1)), par(CENTER, c(l2), c(f2)), par(LEADING, c(l3), c(f3)),
+                auto(UNRELATED), par(LEADING, c(ok), c(cancel)));
+        s.link(0, ok, cancel);
+        check("form", s, 640, 480, 150, 120, 320, 240);
+    }
+
+    @Test
+    public void explicitComponentSizes() {
+        Spec s = new Spec();
+        int a = s.add(comp(40, 20).min(10, 10).max(200, 200));
+        int b = s.add(comp(70, 35).min(20, 10).max(300, 400));
+        int d = s.add(comp(55, 28).min(11, 7));
+        s.h = seq(c(a, P, D, P), c(b, 0, 50, Short.MAX_VALUE), c(d, P, 80, 120));
+        s.v = par(LEADING, c(a, 5, 25, 25), c(b, D, P, P), c(d, D, D, P).al(TRAILING));
+        check("explicit sizes", s, 600, 200, 100, 40);
+    }
+
+    @Test
+    public void invalidArgumentsAreRejectedAlike() {
+        int[][] gaps = {{-3, 5, 5}, {5, -1, 5}, {5, 4, 9}, {1, 5, 3}, {P, 5, P}, {D, 5, 5}, {5, 5, D}};
+        for (int[] g : gaps) {
+            Spec s = new Spec();
+            int a = s.add(comp(40, 20));
+            s.h = seq(c(a), gap(g[0], g[1], g[2]));
+            s.v = seq(c(a));
+            check("gap " + g[0] + "/" + g[1] + "/" + g[2], s);
+        }
+        int[][] sizes = {{-3, D, D}, {5, 4, D}, {D, 9, 3}, {D, D, -5}, {P, P, P}};
+        for (int[] g : sizes) {
+            Spec s = new Spec();
+            int a = s.add(comp(40, 20));
+            s.h = seq(c(a, g[0], g[1], g[2]));
+            s.v = seq(c(a));
+            check("component " + g[0] + "/" + g[1] + "/" + g[2], s);
+        }
+        int[][] prefGaps = {{-3, D}, {9, 3}, {P, P}, {D, -7}, {4, P}};
+        for (int[] g : prefGaps) {
+            Spec s = new Spec();
+            int a = s.add(comp(40, 20));
+            int b = s.add(comp(40, 20));
+            s.h = seq(c(a), auto(RELATED, g[0], g[1]), c(b));
+            s.v = par(LEADING, c(a), c(b));
+            check("auto gap " + g[0] + "/" + g[1], s);
+            s = new Spec();
+            a = s.add(comp(40, 20));
+            b = s.add(comp(40, 20));
+            s.h = seq(c(a), pair(a, b, RELATED, g[0], g[1]), c(b));
+            s.v = par(LEADING, c(a), c(b));
+            check("pair gap " + g[0] + "/" + g[1], s);
+            s = new Spec();
+            a = s.add(comp(40, 20));
+            b = s.add(comp(40, 20));
+            s.h = seq(edge(g[0], g[1]), c(a), c(b));
+            s.v = par(LEADING, c(a), c(b));
+            check("edge gap " + g[0] + "/" + g[1], s);
+        }
+        // INDENT is only a gap between two named components.
+        Spec s = new Spec();
+        int a = s.add(comp(40, 20));
+        s.h = seq(c(a), auto(INDENT));
+        s.v = seq(c(a));
+        check("auto indent", s);
+        // A component in one axis only.
+        s = new Spec();
+        a = s.add(comp(40, 20));
+        int b = s.add(comp(40, 20));
+        s.h = seq(c(a), c(b));
+        s.v = seq(c(a));
+        check("missing from the vertical group", s);
+        // BASELINE as a child alignment of an ordinary parallel group.
+        s = new Spec();
+        a = s.add(comp(40, 20));
+        s.h = seq(c(a));
+        s.v = par(LEADING, c(a).al(BASELINE));
+        check("baseline child of a plain group", s);
+    }
+
+    // ------------------------------------------------------------------
+    // Random layouts
+
+    private static S randomTree(Random rnd, Spec spec, List<Integer> items, boolean vertical, int depth) {
+        if (items.size() == 1 && (depth > 0 || rnd.nextInt(3) == 0)) {
+            S leaf = c(items.get(0));
+            int kind = rnd.nextInt(8);
+            C comp = spec.comps.get(items.get(0));
+            if (kind == 0) {
+                leaf.min = P;
+                leaf.max = P;
+            } else if (kind == 1) {
+                leaf.max = Short.MAX_VALUE;
+            } else if (kind == 2) {
+                leaf.min = 0;
+                leaf.pref = (vertical ? comp.ph : comp.pw) + rnd.nextInt(9);
+            }
+            return leaf;
+        }
+        boolean sequential = rnd.nextBoolean();
+        int parts = items.size() == 1 ? 1 : 2 + rnd.nextInt(Math.min(3, items.size() - 1));
+        List<List<Integer>> chunks = new ArrayList<List<Integer>>();
+        for (int i = 0; i < parts; i++) {
+            chunks.add(new ArrayList<Integer>());
+        }
+        for (int i = 0; i < items.size(); i++) {
+            // Every chunk gets one, the rest land anywhere.
+            chunks.get(i < parts ? i : rnd.nextInt(parts)).add(items.get(i));
+        }
+        if (sequential) {
+            S s = seq();
+            if (rnd.nextInt(6) == 0) {
+                s.kids.add(edge());
+            }
+            for (int i = 0; i < parts; i++) {
+                if (i > 0) {
+                    int kind = rnd.nextInt(9);
+                    if (kind == 0) {
+                        s.kids.add(gap(rnd.nextInt(12)));
+                    } else if (kind == 1) {
+                        s.kids.add(gap(rnd.nextInt(4), 4 + rnd.nextInt(8), 12 + rnd.nextInt(40)));
+                    } else if (kind == 2) {
+                        s.kids.add(auto(rnd.nextInt(2)));
+                    } else if (kind == 3) {
+                        s.kids.add(auto(rnd.nextInt(2), rnd.nextInt(20), 20 + rnd.nextInt(60)));
+                    } else if (kind == 4) {
+                        s.kids.add(gap(0, rnd.nextInt(6), Short.MAX_VALUE));
+                    } else if (kind == 5) {
+                        int a = chunks.get(i - 1).get(0);
+                        int b = chunks.get(i).get(0);
+                        if (!spec.comps.get(a).plain && !spec.comps.get(b).plain) {
+                            s.kids.add(pair(a, b, rnd.nextInt(3)));
+                        }
+                    }
+                }
+                S kid = randomTree(rnd, spec, chunks.get(i), vertical, depth + 1);
+                if (vertical && rnd.nextInt(4) == 0) {
+                    kid.bl();
+                }
+                s.kids.add(kid);
+            }
+            if (rnd.nextInt(6) == 0) {
+                s.kids.add(rnd.nextBoolean() ? edge() : edge(rnd.nextInt(10), 10 + rnd.nextInt(30)));
+            }
+            return s;
+        }
+        S s;
+        boolean baseline = vertical && rnd.nextInt(3) == 0;
+        if (baseline) {
+            int how = rnd.nextInt(3);
+            s = how == 0 ? par(BASELINE) : base(how == 1);
+        } else {
+            s = par(rnd.nextInt(3));
+        }
+        if (rnd.nextInt(4) == 0) {
+            s.fixed();
+        }
+        for (int i = 0; i < parts; i++) {
+            S kid = randomTree(rnd, spec, chunks.get(i), vertical, depth + 1);
+            if (rnd.nextInt(3) == 0) {
+                kid.al(rnd.nextInt(baseline ? 4 : 3));
+            }
+            s.kids.add(kid);
+        }
+        if (rnd.nextInt(8) == 0) {
+            s.kids.add(gap(rnd.nextInt(60)));
+        }
+        return s;
+    }
+
+    private static Spec randomSpec(Random rnd) {
+        Spec spec = new Spec();
+        int count = 1 + rnd.nextInt(7);
+        List<Integer> items = new ArrayList<Integer>();
+        for (int i = 0; i < count; i++) {
+            int w = 5 + rnd.nextInt(90);
+            int h = 5 + rnd.nextInt(60);
+            C c = comp(w, h);
+            if (rnd.nextInt(2) == 0) {
+                c.min(rnd.nextInt(w + 1), rnd.nextInt(h + 1));
+            }
+            if (rnd.nextInt(2) == 0) {
+                c.max(w + rnd.nextInt(200), h + rnd.nextInt(200));
+            }
+            if (rnd.nextInt(6) == 0) {
+                c.plain();
+            } else if (rnd.nextInt(2) == 0) {
+                c.base(rnd.nextInt(h + 1));
+            }
+            if (rnd.nextInt(9) == 0) {
+                c.hide();
+            }
+            if (rnd.nextInt(12) == 0) {
+                c.honors(rnd.nextBoolean());
+            }
+            items.add(spec.add(c));
+        }
+        spec.autoGaps = rnd.nextInt(3) == 0;
+        spec.autoContainerGaps = rnd.nextInt(3) == 0;
+        spec.honorsVisibility = rnd.nextInt(5) != 0;
+        if (rnd.nextInt(4) == 0) {
+            spec.border = new int[] {rnd.nextInt(8), rnd.nextInt(8), rnd.nextInt(8), rnd.nextInt(8)};
+        }
+        Collections.shuffle(items, rnd);
+        spec.h = randomTree(rnd, spec, items, false, 0);
+        Collections.shuffle(items, rnd);
+        spec.v = randomTree(rnd, spec, items, true, 0);
+        if (count > 1 && rnd.nextInt(4) == 0) {
+            int n = 2 + rnd.nextInt(count - 1);
+            int[] which = new int[n];
+            for (int i = 0; i < n; i++) {
+                which[i] = items.get(i);
+            }
+            spec.link(rnd.nextInt(3), which);
+        }
+        return spec;
+    }
+
+    @Test
+    public void randomLayouts() {
+        Random rnd = new Random(77120931L);
+        int before = laidOut;
+        for (int round = 0; round < 600; round++) {
+            Spec spec = randomSpec(rnd);
+            check("random layout " + round, spec, rnd.nextInt(700), rnd.nextInt(500));
+        }
+        // Eight steps a layout; most of them must be real layouts rather
+        // than two matching exceptions.
+        assertTrue("only " + (laidOut - before) + " steps laid out", laidOut - before > 600 * 8 * 3 / 4);
+    }
+
+    // ------------------------------------------------------------------
+    // Changes after the first layout, driven on both sides step by step
+
+    @Test
+    public void changesAfterLayout() {
+        Spec s = new Spec();
+        s.autoGaps = true;
+        int a = s.add(comp(40, 20));
+        int b = s.add(comp(70, 35).min(20, 10).max(300, 400));
+        int d = s.add(comp(55, 28).min(11, 7));
+        s.h = seq(c(a), c(b), c(d));
+        s.v = par(CENTER, c(a), c(b), c(d));
+        Real r = real(s);
+        Ours o = ours(s);
+        same("first", s, r, o, 300, 100);
+
+        r.comps[1].setVisible(false);
+        o.comps[1].setVisible(false);
+        same("hidden", s, r, o, 300, 100);
+
+        r.layout.setHonorsVisibility(false);
+        o.layout.setHonorsVisibility(false);
+        same("visibility ignored", s, r, o, 300, 100);
+
+        r.layout.setHonorsVisibility(r.comps[1], Boolean.TRUE);
+        o.layout.setHonorsVisibility(o.comps[1], Boolean.TRUE);
+        same("honoured for one", s, r, o, 300, 100);
+
+        r.comps[1].setVisible(true);
+        o.comps[1].setVisible(true);
+        r.layout.setAutoCreateContainerGaps(true);
+        o.layout.setAutoCreateContainerGaps(true);
+        same("container gaps on", s, r, o, 300, 100);
+
+        java.awt.Component rn = new RealLeaf(-1);
+        rn.setPreferredSize(new java.awt.Dimension(91, 17));
+        Component on = new OurLeaf(-1);
+        on.setPreferredSize(new Dimension(91, 17));
+        r.layout.replace(r.comps[0], rn);
+        o.layout.replace(o.comps[0], on);
+        assertEquals(r.comps[0].getParent() == null, o.comps[0].getParent() == null);
+        assertSame(o.host, on.getParent());
+        r.comps[0] = rn;
+        o.comps[0] = on;
+        same("replaced", s, r, o, 300, 100);
+
+        r.layout.linkSize(javax.swing.SwingConstants.VERTICAL, r.comps[0], r.comps[2]);
+        o.layout.linkSize(SwingConstants.VERTICAL, o.comps[0], o.comps[2]);
+        same("linked", s, r, o, 300, 100);
+
+        r.host.remove(r.comps[2]);
+        o.host.remove(o.comps[2]);
+        same("removed", s, r, o, 300, 100);
+        same("removed, smaller", s, r, o, 120, 30);
+
+        r.layout.setAutoCreateContainerGaps(false);
+        o.layout.setAutoCreateContainerGaps(false);
+        r.layout.setLayoutStyle(null);
+        o.layout.setLayoutStyle(null);
+        javax.swing.LayoutStyle before = javax.swing.LayoutStyle.getInstance();
+        try {
+            javax.swing.LayoutStyle.setInstance(new RealStyle());
+            LayoutStyle.setInstance(new OurStyle());
+            same("shared style", s, r, o, 300, 100);
+        } finally {
+            javax.swing.LayoutStyle.setInstance(before);
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Expectations worked out by hand
+
+    private static JComponent box(int w, int h) {
+        JComponent c = new JComponent() {
+        };
+        c.setPreferredSize(new Dimension(w, h));
+        c.setMinimumSize(new Dimension(w, h));
+        c.setMaximumSize(new Dimension(w, h));
+        return c;
+    }
+
+    private static void assertBounds(Component c, int x, int y, int w, int h) {
+        assertEquals("x", x, c.getX());
+        assertEquals("y", y, c.getY());
+        assertEquals("width", w, c.getWidth());
+        assertEquals("height", h, c.getHeight());
+    }
+
+    @Test
+    public void defaultStyleGaps() {
+        JPanel host = new JPanel();
+        GroupLayout layout = new GroupLayout(host);
+        host.setLayout(layout);
+        layout.setAutoCreateGaps(true);
+        layout.setAutoCreateContainerGaps(true);
+        JComponent a = box(40, 20);
+        JComponent b = box(30, 10);
+        JComponent d = box(50, 30);
+        layout.setHorizontalGroup(layout.createSequentialGroup().addComponent(a).addComponent(b)
+                .addPreferredGap(LayoutStyle.ComponentPlacement.UNRELATED).addComponent(d));
+        layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.TRAILING).addComponent(a)
+                .addComponent(b).addComponent(d));
+        // 6 + 40 + 6 + 30 + 12 + 50 + 6 wide, 6 + 30 + 6 high
+        assertEquals(new Dimension(150, 42), layout.preferredLayoutSize(host));
+        assertEquals(new Dimension(150, 42), layout.minimumLayoutSize(host));
+        host.setSize(150, 42);
+        host.doLayout();
+        assertBounds(a, 6, 16, 40, 20);
+        assertBounds(b, 52, 26, 30, 10);
+        assertBounds(d, 94, 6, 50, 30);
+    }
+
+    @Test
+    public void defaultStyleMatchesTheJdkDefault() throws Exception {
+        javax.swing.LayoutStyle real;
+        try {
+            real = (javax.swing.LayoutStyle) Class.forName("sun.swing.DefaultLayoutStyle").getMethod("getInstance")
+                    .invoke(null);
+        } catch (ClassNotFoundException e) {
+            org.junit.Assume.assumeNoException(e);
+            return;
+        }
+        LayoutStyle ours = LayoutStyle.getInstance();
+        javax.swing.JComponent ra = new RealLeaf(-1);
+        javax.swing.JComponent rb = new RealLeaf(-1);
+        JComponent oa = new OurLeaf(-1);
+        JComponent ob = new OurLeaf(-1);
+        int[] positions = {1, 3, 5, 7};
+        for (int position : positions) {
+            for (int type = 0; type < 3; type++) {
+                assertEquals("gap " + type + " at " + position,
+                        real.getPreferredGap(ra, rb, realType(type), position, null),
+                        ours.getPreferredGap(oa, ob, ourType(type), position, null));
+            }
+            assertEquals("edge at " + position, real.getContainerGap(ra, position, null),
+                    ours.getContainerGap(oa, position, null));
+        }
+        try {
+            ours.getContainerGap(oa, 2, null);
+            fail("NORTH_EAST is not a position");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(true);
+        }
+        try {
+            ours.getPreferredGap(oa, null, LayoutStyle.ComponentPlacement.RELATED, 1, null);
+            fail("null component");
+        } catch (NullPointerException expected) {
+            assertTrue(true);
+        }
+        LayoutStyle custom = new OurStyle();
+        LayoutStyle.setInstance(custom);
+        assertSame(custom, LayoutStyle.getInstance());
+        LayoutStyle.setInstance(null);
+        assertSame(ours, LayoutStyle.getInstance());
+    }
+
+    @Test
+    public void growingAndShrinkingByHand() {
+        Container host = new Container();
+        GroupLayout layout = new GroupLayout(host);
+        host.setLayout(layout);
+        Component fixed = box(40, 20);
+        Component grows = new Component() {
+        };
+        grows.setPreferredSize(new Dimension(60, 20));
+        grows.setMinimumSize(new Dimension(20, 20));
+        grows.setMaximumSize(new Dimension(100, 20));
+        layout.setHorizontalGroup(
+                layout.createSequentialGroup().addComponent(fixed).addGap(10).addComponent(grows).addGap(0, 5, 15));
+        layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.CENTER).addComponent(fixed)
+                .addComponent(grows, 10, 10, 10));
+        assertEquals(new Dimension(115, 20), layout.preferredLayoutSize(host));
+        assertEquals(new Dimension(70, 20), layout.minimumLayoutSize(host));
+        assertEquals(new Dimension(165, 20), layout.maximumLayoutSize(host));
+        assertEquals(2, host.getComponentCount());
+
+        // 30 extra pixels: the gap can take 10 and takes its even share of
+        // 15 first, capped at 10; the component takes the remaining 20.
+        // The vertical group cannot grow past its 20, so it stays at the
+        // top.
+        host.setSize(145, 40);
+        host.doLayout();
+        assertBounds(fixed, 0, 0, 40, 20);
+        assertBounds(grows, 50, 5, 80, 10);
+
+        // 25 pixels short: the gap gives its 5, the component the other 20.
+        host.setSize(90, 20);
+        host.invalidate();
+        host.doLayout();
+        assertBounds(fixed, 0, 0, 40, 20);
+        assertBounds(grows, 50, 5, 40, 10);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JSplitPaneTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JSplitPaneTest.java
new file mode 100644
index 00000000000..cf6c85008fa
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JSplitPaneTest.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// The split pane: where it puts its two components, and how the divider
+/// moves when set, dragged, collapsed and when the pane is resized.
+public class JSplitPaneTest extends KernelTestBase {
+
+    private static JPanel page(int w, int h, int minW, int minH) {
+        JPanel p = new JPanel(null);
+        p.setPreferredSize(new Dimension(w, h));
+        p.setMinimumSize(new Dimension(minW, minH));
+        return p;
+    }
+
+    /// A split pane of 300 by 100 in a frame, holding a 100 by 50 and a
+    /// 200 by 60 page with minimum sizes of 30 by 20 and 40 by 25.
+    private static final class Fixture {
+        final JFrame frame = new JFrame();
+        final JPanel holder = new JPanel(null);
+        final JPanel first = page(100, 50, 30, 20);
+        final JPanel second = page(200, 60, 40, 25);
+        final JSplitPane split;
+
+        Fixture(int orientation) {
+            split = new JSplitPane(orientation, first, second);
+            holder.add(split);
+            split.setBounds(0, 0, 300, 100);
+            frame.add(holder, BorderLayout.CENTER);
+        }
+    }
+
+    private Fixture shown(int orientation) {
+        Fixture x = new Fixture(orientation);
+        show(x.frame);
+        return x;
+    }
+
+    @Test
+    public void aHorizontalSplitGivesTheLeftItsPreferredWidthAndTheRightTheRest() {
+        Fixture x = shown(JSplitPane.HORIZONTAL_SPLIT);
+        assertEquals(new Rectangle(0, 0, 100, 100), x.first.getBounds());
+        assertEquals(new Rectangle(110, 0, 190, 100), x.second.getBounds());
+        assertEquals(100, x.split.getDividerLocation());
+        assertEquals(new Dimension(310, 60), x.split.getPreferredSize());
+        assertEquals(new Dimension(80, 25), x.split.getMinimumSize());
+        assertEquals(30, x.split.getMinimumDividerLocation());
+        assertEquals(300 - 40 - 10, x.split.getMaximumDividerLocation());
+    }
+
+    @Test
+    public void aVerticalSplitGivesTheTopItsPreferredHeightAndTheBottomTheRest() {
+        Fixture x = shown(JSplitPane.VERTICAL_SPLIT);
+        assertEquals(new Rectangle(0, 0, 300, 50), x.first.getBounds());
+        assertEquals(new Rectangle(0, 60, 300, 40), x.second.getBounds());
+        assertEquals(50, x.split.getDividerLocation());
+        assertEquals(new Dimension(200, 120), x.split.getPreferredSize());
+        assertEquals(20, x.split.getMinimumDividerLocation());
+        assertEquals(100 - 25 - 10, x.split.getMaximumDividerLocation());
+        assertSame(x.first, x.split.getTopComponent());
+        assertSame(x.second, x.split.getBottomComponent());
+    }
+
+    @Test
+    public void insetsAndDividerSizeAreTakenFromTheSpace() {
+        Fixture x = new Fixture(JSplitPane.HORIZONTAL_SPLIT);
+        x.split.setBorder(new EmptyBorder(1, 2, 3, 4));
+        x.split.setDividerSize(20);
+        show(x.frame);
+        assertEquals(new Rectangle(2, 1, 100, 96), x.first.getBounds());
+        assertEquals(new Rectangle(122, 1, 174, 96), x.second.getBounds());
+        assertEquals(102, x.split.getDividerLocation());
+        assertEquals(32, x.split.getMinimumDividerLocation());
+        assertEquals(300 - 40 - 20 - 4, x.split.getMaximumDividerLocation());
+    }
+
+    @Test
+    public void settingTheDividerLocationMovesItAndFiresTheJdksProperties() {
+        Fixture x = shown(JSplitPane.HORIZONTAL_SPLIT);
+        final List<String> log = new ArrayList<String>();
+        x.split.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                log.add(e.getPropertyName() + ":" + e.getOldValue() + ">" + e.getNewValue());
+            }
+        });
+        x.split.setDividerLocation(150);
+        x.frame.validate();
+        assertEquals(new Rectangle(0, 0, 150, 100), x.first.getBounds());
+        assertEquals(new Rectangle(160, 0, 140, 100), x.second.getBounds());
+        assertEquals(150, x.split.getDividerLocation());
+        assertEquals(100, x.split.getLastDividerLocation());
+        assertTrue(log.toString(), log.contains("dividerLocation:100>150"));
+        assertTrue(log.toString(), log.contains("lastDividerLocation:0>100"));
+
+        // A location set by the program is limited by the pane only.
+        x.split.setDividerLocation(1000);
+        x.frame.validate();
+        assertEquals(290, x.split.getDividerLocation());
+        assertEquals(new Rectangle(300, 0, 0, 100), x.second.getBounds());
+
+        x.split.setDividerLocation(0.5);
+        x.frame.validate();
+        assertEquals(145, x.split.getDividerLocation());
+        assertEquals(145, x.first.getWidth());
+        try {
+            x.split.setDividerLocation(1.5);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(145, x.split.getDividerLocation());
+        }
+
+        x.split.resetToPreferredSizes();
+        x.frame.validate();
+        assertEquals(100, x.split.getDividerLocation());
+    }
+
+    @Test
+    public void aResizeHandsTheExtraSpaceOutByTheResizeWeight() {
+        Fixture x = shown(JSplitPane.HORIZONTAL_SPLIT);
+        x.split.setBounds(0, 0, 400, 100);
+        x.frame.validate();
+        // Weight 0: everything goes to the right.
+        assertEquals(100, x.first.getWidth());
+        assertEquals(new Rectangle(110, 0, 290, 100), x.second.getBounds());
+
+        x.split.setResizeWeight(0.5);
+        assertEquals(0.5, x.split.getResizeWeight(), 0);
+        x.split.setBounds(0, 0, 500, 100);
+        x.frame.validate();
+        assertEquals(150, x.first.getWidth());
+        assertEquals(new Rectangle(160, 0, 340, 100), x.second.getBounds());
+        assertEquals(150, x.split.getDividerLocation());
+
+        x.split.setResizeWeight(1);
+        x.split.setBounds(0, 0, 440, 100);
+        x.frame.validate();
+        assertEquals(90, x.first.getWidth());
+        assertEquals(340, x.second.getWidth());
+
+        // Shrinking stops at the minimum size of the side that shrinks.
+        x.split.setBounds(0, 0, 370, 100);
+        x.frame.validate();
+        assertEquals(30, x.first.getWidth());
+        assertEquals(330, x.second.getWidth());
+        try {
+            x.split.setResizeWeight(2);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(1, x.split.getResizeWeight(), 0);
+        }
+    }
+
+    @Test
+    public void draggingTheDividerMovesItBetweenTheMinimumSizes() {
+        Fixture x = shown(JSplitPane.HORIZONTAL_SPLIT);
+        x.split.setContinuousLayout(true);
+        press(x.frame, x.split, 104, 50);
+        drag(x.frame, x.split, 164, 50);
+        assertEquals(160, x.split.getDividerLocation());
+        assertEquals(new Rectangle(0, 0, 160, 100), x.first.getBounds());
+        assertEquals(new Rectangle(170, 0, 130, 100), x.second.getBounds());
+        drag(x.frame, x.split, 5, 50);
+        assertEquals(30, x.split.getDividerLocation());
+        drag(x.frame, x.split, 299, 50);
+        assertEquals(250, x.split.getDividerLocation());
+        assertEquals(40, x.second.getWidth());
+        release(x.frame, x.split, 299, 50);
+        assertEquals(250, x.split.getDividerLocation());
+        // Without a press on the divider nothing moves.
+        drag(x.frame, x.split, 100, 50);
+        assertEquals(250, x.split.getDividerLocation());
+    }
+
+    @Test
+    public void withoutContinuousLayoutTheComponentsMoveOnRelease() {
+        Fixture x = shown(JSplitPane.VERTICAL_SPLIT);
+        press(x.frame, x.split, 150, 55);
+        drag(x.frame, x.split, 150, 45);
+        assertEquals(50, x.split.getDividerLocation());
+        assertEquals(50, x.first.getHeight());
+        release(x.frame, x.split, 150, 45);
+        assertEquals(40, x.split.getDividerLocation());
+        assertEquals(new Rectangle(0, 0, 300, 40), x.first.getBounds());
+        assertEquals(new Rectangle(0, 50, 300, 50), x.second.getBounds());
+        assertEquals(50, x.split.getLastDividerLocation());
+    }
+
+    @Test
+    public void theOneTouchArrowsCollapseASideAndBringTheDividerBack() {
+        Fixture x = shown(JSplitPane.HORIZONTAL_SPLIT);
+        x.split.setOneTouchExpandable(true);
+        assertTrue(x.split.isOneTouchExpandable());
+        // The first arrow, at the top of the divider, collapses the left.
+        press(x.frame, x.split, 105, 4);
+        release(x.frame, x.split, 105, 4);
+        assertEquals(0, x.split.getDividerLocation());
+        assertEquals(0, x.first.getWidth());
+        assertEquals(new Rectangle(10, 0, 290, 100), x.second.getBounds());
+        // The second arrow brings the divider back to where it was.
+        press(x.frame, x.split, 5, 12);
+        release(x.frame, x.split, 5, 12);
+        assertEquals(100, x.split.getDividerLocation());
+        // And once more collapses the right.
+        press(x.frame, x.split, 105, 12);
+        release(x.frame, x.split, 105, 12);
+        assertEquals(290, x.split.getDividerLocation());
+        assertEquals(0, x.second.getWidth());
+        paint(x.frame);
+    }
+
+    @Test
+    public void componentsAreAddedByConstraintAndReplaced() {
+        JSplitPane s = new JSplitPane();
+        assertEquals(JSplitPane.HORIZONTAL_SPLIT, s.getOrientation());
+        assertTrue(s.getLeftComponent() instanceof JButton);
+        assertTrue(s.getRightComponent() instanceof JButton);
+        assertEquals(2, s.getComponentCount());
+        JPanel a = new JPanel();
+        JPanel b = new JPanel();
+        s.setLeftComponent(a);
+        s.add(b, JSplitPane.BOTTOM);
+        assertSame(a, s.getLeftComponent());
+        assertSame(b, s.getRightComponent());
+        assertEquals(2, s.getComponentCount());
+        s.remove(a);
+        assertNull(s.getLeftComponent());
+        JPanel c = new JPanel();
+        s.add(c);
+        assertSame(c, s.getTopComponent());
+        s.setRightComponent(null);
+        assertNull(s.getBottomComponent());
+        assertEquals(1, s.getComponentCount());
+        try {
+            s.add(new JPanel(), Integer.valueOf(3));
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(1, s.getComponentCount());
+        }
+        s.removeAll();
+        assertNull(s.getLeftComponent());
+        assertEquals(0, s.getComponentCount());
+    }
+
+    @Test
+    public void propertiesFireUnderTheJdksNames() {
+        assertEquals(javax.swing.JSplitPane.DIVIDER_LOCATION_PROPERTY, JSplitPane.DIVIDER_LOCATION_PROPERTY);
+        assertEquals(javax.swing.JSplitPane.RESIZE_WEIGHT_PROPERTY, JSplitPane.RESIZE_WEIGHT_PROPERTY);
+        assertEquals(javax.swing.JSplitPane.ORIENTATION_PROPERTY, JSplitPane.ORIENTATION_PROPERTY);
+        assertEquals(javax.swing.JSplitPane.HORIZONTAL_SPLIT, JSplitPane.HORIZONTAL_SPLIT);
+        assertEquals(javax.swing.JSplitPane.VERTICAL_SPLIT, JSplitPane.VERTICAL_SPLIT);
+        JSplitPane s = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
+        final List<String> log = new ArrayList<String>();
+        s.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                log.add(e.getPropertyName() + ":" + e.getOldValue() + ">" + e.getNewValue());
+            }
+        });
+        s.setOrientation(JSplitPane.HORIZONTAL_SPLIT);
+        s.setResizeWeight(0.25);
+        s.setDividerSize(4);
+        s.setOneTouchExpandable(true);
+        s.setContinuousLayout(true);
+        s.setDividerLocation(7);
+        List<String> want = new ArrayList<String>();
+        want.add("orientation:0>1");
+        want.add("resizeWeight:0.0>0.25");
+        want.add("dividerSize:10>4");
+        want.add("oneTouchExpandable:false>true");
+        want.add("continuousLayout:false>true");
+        want.add("dividerLocation:-1>7");
+        want.add("lastDividerLocation:0>-1");
+        assertEquals(want, log);
+        try {
+            s.setOrientation(5);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(JSplitPane.HORIZONTAL_SPLIT, s.getOrientation());
+        }
+    }
+
+    /// A split pane is opaque: around a side that does not fill its half
+    /// it shows its own background, not that of the panel it stands on.
+    @Test
+    public void thePaneFillsItsAreaWithItsOwnBackground() {
+        JPanel black = new JPanel(new BorderLayout());
+        black.setBackground(com.codename1.desktopcompat.java.awt.Color.BLACK);
+        JSplitPane s = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, new JLabel("a"), new JLabel("b"));
+        assertTrue(s.isOpaque());
+        s.setDividerLocation(100);
+        black.add(s, BorderLayout.CENTER);
+        JFrame f = new JFrame();
+        f.getContentPane().add(black, BorderLayout.CENTER);
+        f.setSize(400, 300);
+        show(f);
+        int[][] rows = raster(f);
+        int want = s.getBackground().getRGB() & 0xffffff;
+        assertTrue(want != 0);
+        assertEquals(want, pixel(rows, s, 50, 280) & 0xffffff);
+        assertEquals(want, pixel(rows, s, 300, 280) & 0xffffff);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTabbedPaneTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTabbedPaneTest.java
new file mode 100644
index 00000000000..98b5a5f6052
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTabbedPaneTest.java
@@ -0,0 +1,592 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.TabbedPanePeer;
+import com.codename1.desktopcompat.rt.Units;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// The tabbed pane: its tab bookkeeping and change events against the
+/// JDK's own, and its strip, pages and touch selection on a display.
+public class JTabbedPaneTest extends KernelTestBase {
+
+    private static JPanel page(String name, int w, int h) {
+        JPanel p = new JPanel(null);
+        p.setName(name);
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+
+    /// Runs the same script on our tabbed pane and on the JDK's and
+    /// records, after every step, the change events fired so far, the
+    /// selected index, the tab count and the titles.
+    private static final class Script {
+        final JTabbedPane ours = new JTabbedPane();
+        final javax.swing.JTabbedPane real = new javax.swing.JTabbedPane();
+        final List<JPanel> ourPages = new ArrayList<JPanel>();
+        final List<javax.swing.JPanel> realPages = new ArrayList<javax.swing.JPanel>();
+        final int[] ourEvents = new int[1];
+        final int[] realEvents = new int[1];
+        final StringBuilder ourLog = new StringBuilder();
+        final StringBuilder realLog = new StringBuilder();
+
+        Script() {
+            ours.addChangeListener(new ChangeListener() {
+                @Override
+                public void stateChanged(ChangeEvent e) {
+                    ourEvents[0]++;
+                }
+            });
+            real.addChangeListener(new javax.swing.event.ChangeListener() {
+                @Override
+                public void stateChanged(javax.swing.event.ChangeEvent e) {
+                    realEvents[0]++;
+                }
+            });
+            for (int i = 0; i < 6; i++) {
+                ourPages.add(new JPanel());
+                realPages.add(new javax.swing.JPanel());
+            }
+        }
+
+        void log(String step) {
+            StringBuilder a = new StringBuilder();
+            StringBuilder b = new StringBuilder();
+            for (int i = 0; i < ours.getTabCount(); i++) {
+                a.append(ours.getTitleAt(i)).append(ourPages.indexOf(ours.getComponentAt(i))).append(
+                        ours.getComponentAt(i).isVisible() ? "v" : "h").append(' ');
+            }
+            for (int i = 0; i < real.getTabCount(); i++) {
+                b.append(real.getTitleAt(i)).append(realPages.indexOf(real.getComponentAt(i))).append(
+                        real.getComponentAt(i).isVisible() ? "v" : "h").append(' ');
+            }
+            ourLog.append(step).append(": events=").append(ourEvents[0]).append(" sel=").append(
+                    ours.getSelectedIndex()).append(" tabs=").append(a).append(" children=").append(
+                    ours.getComponentCount()).append('\n');
+            realLog.append(step).append(": events=").append(realEvents[0]).append(" sel=").append(
+                    real.getSelectedIndex()).append(" tabs=").append(b).append(" children=").append(
+                    real.getComponentCount()).append('\n');
+        }
+
+        void addTab(String t, int p) {
+            ours.addTab(t, ourPages.get(p));
+            real.addTab(t, realPages.get(p));
+            log("addTab " + t);
+        }
+
+        void insertTab(String t, int p, int at) {
+            ours.insertTab(t, null, ourPages.get(p), null, at);
+            real.insertTab(t, null, realPages.get(p), null, at);
+            log("insertTab " + t + "@" + at);
+        }
+
+        void select(int i) {
+            ours.setSelectedIndex(i);
+            real.setSelectedIndex(i);
+            log("select " + i);
+        }
+
+        void removeTabAt(int i) {
+            ours.removeTabAt(i);
+            real.removeTabAt(i);
+            log("removeTabAt " + i);
+        }
+
+        void remove(int p) {
+            ours.remove(ourPages.get(p));
+            real.remove(realPages.get(p));
+            log("remove page " + p);
+        }
+
+        void removeAll() {
+            ours.removeAll();
+            real.removeAll();
+            log("removeAll");
+        }
+
+        void check() {
+            assertEquals(realLog.toString(), ourLog.toString());
+        }
+    }
+
+    @Test
+    public void tabBookkeepingAndChangeEventsMatchTheJdk() {
+        Script s = new Script();
+        s.addTab("A", 0);
+        s.addTab("B", 1);
+        s.addTab("C", 2);
+        s.select(2);
+        s.select(2);
+        s.insertTab("D", 3, 0);
+        s.insertTab("E", 4, 4);
+        s.select(1);
+        s.removeTabAt(0);
+        s.removeTabAt(0);
+        s.remove(4);
+        s.select(-1);
+        s.select(1);
+        s.removeTabAt(1);
+        // Adding a page that is already a tab moves it.
+        s.addTab("A2", 0);
+        s.insertTab("C2", 2, 0);
+        s.removeAll();
+        s.addTab("Z", 5);
+        s.check();
+    }
+
+    @Test
+    public void addOverloadsMakeTabsAsTheJdkDoes() {
+        Script s = new Script();
+        s.ourPages.get(0).setName("named");
+        s.realPages.get(0).setName("named");
+        s.ours.add(s.ourPages.get(0));
+        s.real.add(s.realPages.get(0));
+        s.log("add(c)");
+        s.ours.add("T1", s.ourPages.get(1));
+        s.real.add("T1", s.realPages.get(1));
+        s.log("add(title, c)");
+        s.ours.add(s.ourPages.get(2), "T2");
+        s.real.add(s.realPages.get(2), "T2");
+        s.log("add(c, title)");
+        s.ours.add(s.ourPages.get(3), "T3", 0);
+        s.real.add(s.realPages.get(3), "T3", 0);
+        s.log("add(c, title, 0)");
+        s.ours.add(s.ourPages.get(4), 1);
+        s.real.add(s.realPages.get(4), 1);
+        s.log("add(c, 1)");
+        s.check();
+        assertEquals("named", s.ours.getTitleAt(2));
+        assertEquals(2, s.ours.indexOfTab("named"));
+        assertEquals(0, s.ours.indexOfComponent(s.ourPages.get(3)));
+        assertEquals(-1, s.ours.indexOfComponent(s.ourPages.get(5)));
+    }
+
+    @Test
+    public void exactlyOneChangeEventPerSelectionChange() {
+        JTabbedPane t = new JTabbedPane();
+        final List<Object> sources = new ArrayList<Object>();
+        t.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                sources.add(e.getSource());
+            }
+        });
+        JPanel a = new JPanel();
+        JPanel b = new JPanel();
+        t.addTab("A", a);
+        assertEquals(1, sources.size());
+        assertSame(t, sources.get(0));
+        t.addTab("B", b);
+        assertEquals(1, sources.size());
+        t.setSelectedIndex(1);
+        assertEquals(2, sources.size());
+        t.setSelectedIndex(1);
+        assertEquals(2, sources.size());
+        t.setSelectedComponent(a);
+        assertEquals(3, sources.size());
+        assertSame(a, t.getSelectedComponent());
+        assertTrue(a.isVisible());
+        assertFalse(b.isVisible());
+        t.getModel().setSelectedIndex(1);
+        assertEquals(4, sources.size());
+        assertTrue(b.isVisible());
+        assertFalse(a.isVisible());
+    }
+
+    @Test
+    public void badIndexesAndUnknownComponentsAreRefused() {
+        JTabbedPane t = new JTabbedPane();
+        t.addTab("A", new JPanel());
+        try {
+            t.setSelectedIndex(1);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+            assertEquals(0, t.getSelectedIndex());
+        }
+        try {
+            t.setSelectedComponent(new JPanel());
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(0, t.getSelectedIndex());
+        }
+        try {
+            t.setTabPlacement(17);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(SwingConstants.TOP, t.getTabPlacement());
+        }
+    }
+
+    @Test
+    public void perTabPropertiesAreKept() {
+        JTabbedPane t = new JTabbedPane(SwingConstants.BOTTOM, JTabbedPane.SCROLL_TAB_LAYOUT);
+        assertEquals(SwingConstants.BOTTOM, t.getTabPlacement());
+        assertEquals(JTabbedPane.SCROLL_TAB_LAYOUT, t.getTabLayoutPolicy());
+        JPanel a = new JPanel();
+        JPanel b = new JPanel();
+        t.addTab("A", null, a, "tip a");
+        t.addTab("B", b);
+        assertEquals("tip a", t.getToolTipTextAt(0));
+        assertNull(t.getToolTipTextAt(1));
+        t.setToolTipTextAt(1, "tip b");
+        assertEquals("tip b", t.getToolTipTextAt(1));
+        t.setTitleAt(1, "Bee");
+        assertEquals("Bee", t.getTitleAt(1));
+        assertEquals(1, t.indexOfTab("Bee"));
+        assertTrue(t.isEnabledAt(1));
+        t.setEnabledAt(1, false);
+        assertFalse(t.isEnabledAt(1));
+        JPanel c = new JPanel();
+        t.setComponentAt(1, c);
+        assertSame(c, t.getComponentAt(1));
+        assertNull(b.getParent());
+        assertSame(t, c.getParent());
+        assertFalse(c.isVisible());
+        JLabel tab = new JLabel("Custom");
+        t.setTabComponentAt(0, tab);
+        assertSame(tab, t.getTabComponentAt(0));
+        assertEquals(0, t.indexOfTabComponent(tab));
+        assertEquals(-1, t.indexOfTabComponent(new JLabel()));
+    }
+
+    private static TabbedPanePeer peer(JTabbedPane t) {
+        return (TabbedPanePeer) t.cn1Peer();
+    }
+
+    @Test
+    public void theSelectedPageLiesBelowTheStripAndTheOthersAreHidden() {
+        JFrame f = new JFrame();
+        JTabbedPane t = new JTabbedPane();
+        JPanel a = page("a", 100, 50);
+        JPanel b = page("b", 120, 40);
+        t.addTab("First", a);
+        t.addTab("Second", b);
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        TabbedPanePeer p = peer(t);
+        assertEquals(2, p.tabCount());
+        assertEquals("First", p.tab(0).getText());
+        assertEquals("Second", p.tab(1).getText());
+        assertTrue(p.tab(0).isSelected());
+        assertFalse(p.tab(1).isSelected());
+
+        int stripH = Units.toLogicalCeil(p.stripPreferredSize().getHeight());
+        assertTrue(stripH > 0);
+        assertEquals(new Rectangle(0, stripH, t.getWidth(), t.getHeight() - stripH), a.getBounds());
+        assertEquals(a.getBounds(), b.getBounds());
+        assertTrue(a.isVisible());
+        assertFalse(b.isVisible());
+        assertTrue(a.cn1Peer().isVisible());
+        assertFalse(b.cn1Peer().isVisible());
+
+        // The strip is the last Codename One child, above the page peers.
+        assertEquals(3, p.getComponentCount());
+        assertEquals("TabsContainer", p.getComponentAt(2).getUIID());
+        assertEquals(0, p.getComponentAt(p.getComponentCount() - 1).getY());
+        assertEquals(Units.toDevice(stripH), p.getComponentAt(p.getComponentCount() - 1).getHeight());
+        assertEquals(p.getWidth(), p.getComponentAt(p.getComponentCount() - 1).getWidth());
+        assertEquals(Units.toDevice(a.getY()), a.cn1Peer().getY());
+
+        Dimension pref = t.getPreferredSize();
+        assertEquals(50 + stripH, pref.height);
+        assertEquals(Math.max(120, Units.toLogicalCeil(p.stripPreferredSize().getWidth())), pref.width);
+        Rectangle tab1 = t.getBoundsAt(1);
+        assertNotNull(tab1);
+        assertEquals(1, t.indexAtLocation(tab1.x + tab1.width / 2, tab1.y + tab1.height / 2));
+        assertEquals(-1, t.indexAtLocation(5, stripH + 20));
+    }
+
+    @Test
+    public void touchingATabSelectsItAndFiresOneChangeEvent() {
+        JFrame f = new JFrame();
+        JTabbedPane t = new JTabbedPane();
+        JPanel a = page("a", 100, 50);
+        JPanel b = page("b", 100, 50);
+        JPanel c = page("c", 100, 50);
+        t.addTab("One", a);
+        t.addTab("Two", b);
+        t.addTab("Three", c);
+        t.setEnabledAt(2, false);
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        final int[] events = new int[1];
+        t.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                events[0]++;
+            }
+        });
+        Rectangle r = t.getBoundsAt(1);
+        int x = r.x + r.width / 2;
+        int y = r.y + r.height / 2;
+        press(f, t, x, y);
+        release(f, t, x, y);
+        assertEquals(1, events[0]);
+        assertEquals(1, t.getSelectedIndex());
+        assertTrue(b.isVisible());
+        assertFalse(a.isVisible());
+        TabbedPanePeer p = peer(t);
+        assertTrue(p.tab(1).isSelected());
+        assertFalse(p.tab(0).isSelected());
+
+        // The selected tab again: nothing changes.
+        press(f, t, x, y);
+        release(f, t, x, y);
+        assertEquals(1, events[0]);
+        assertTrue(p.tab(1).isSelected());
+
+        // A disabled tab takes no touch.
+        assertFalse(p.tab(2).isEnabled());
+        Rectangle r2 = t.getBoundsAt(2);
+        press(f, t, r2.x + r2.width / 2, r2.y + r2.height / 2);
+        release(f, t, r2.x + r2.width / 2, r2.y + r2.height / 2);
+        assertEquals(1, events[0]);
+        assertEquals(1, t.getSelectedIndex());
+        assertFalse(p.tab(2).isSelected());
+
+        // A selection made by the program reaches the strip.
+        t.setSelectedIndex(0);
+        assertEquals(2, events[0]);
+        assertTrue(p.tab(0).isSelected());
+        assertFalse(p.tab(1).isSelected());
+    }
+
+    @Test
+    public void theStripFollowsTheTabPlacement() {
+        JFrame f = new JFrame();
+        JTabbedPane t = new JTabbedPane(SwingConstants.BOTTOM);
+        JPanel a = page("a", 100, 50);
+        t.addTab("One", a);
+        t.addTab("Two", page("b", 100, 50));
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        TabbedPanePeer p = peer(t);
+        int stripH = Units.toLogicalCeil(p.stripPreferredSize().getHeight());
+        assertEquals(new Rectangle(0, 0, t.getWidth(), t.getHeight() - stripH), a.getBounds());
+        assertEquals(Units.toDevice(t.getHeight() - stripH), p.getComponentAt(p.getComponentCount() - 1).getY());
+        assertTrue(p.tab(1).getX() > p.tab(0).getX());
+        assertEquals(p.tab(0).getY(), p.tab(1).getY());
+
+        t.setTabPlacement(SwingConstants.LEFT);
+        f.validate();
+        int stripW = Units.toLogicalCeil(p.stripPreferredSize().getWidth());
+        assertTrue(stripW > 0 && stripW < t.getWidth());
+        assertEquals(new Rectangle(stripW, 0, t.getWidth() - stripW, t.getHeight()), a.getBounds());
+        assertEquals(0, p.getComponentAt(p.getComponentCount() - 1).getX());
+        assertEquals(p.getHeight(), p.getComponentAt(p.getComponentCount() - 1).getHeight());
+        assertTrue(p.tab(1).getY() > p.tab(0).getY());
+        assertEquals(Math.max(50, Units.toLogicalCeil(p.stripPreferredSize().getHeight())),
+                t.getPreferredSize().height);
+        assertEquals(100 + stripW, t.getPreferredSize().width);
+
+        t.setTabPlacement(SwingConstants.RIGHT);
+        f.validate();
+        assertEquals(new Rectangle(0, 0, t.getWidth() - stripW, t.getHeight()), a.getBounds());
+        assertEquals(Units.toDevice(t.getWidth() - stripW), p.getComponentAt(p.getComponentCount() - 1).getX());
+    }
+
+    @Test
+    public void tabsAddedAndRemovedWhileShowingReachTheStrip() {
+        JFrame f = new JFrame();
+        JTabbedPane t = new JTabbedPane();
+        t.addTab("One", page("a", 100, 50));
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        TabbedPanePeer p = peer(t);
+        JPanel b = page("b", 100, 50);
+        t.insertTab("<html><b>Zero</b></html>", null, b, null, 0);
+        f.validate();
+        assertEquals(2, p.tabCount());
+        assertEquals("Zero", p.tab(0).getText());
+        assertEquals(1, t.getSelectedIndex());
+        assertTrue(p.tab(1).isSelected());
+        assertEquals("TabsContainer", p.getComponentAt(p.getComponentCount() - 1).getUIID());
+        t.setTitleAt(1, "Uno");
+        assertEquals("Uno", p.tab(1).getText());
+        t.setTabComponentAt(1, new JLabel("From label"));
+        assertEquals("From label", p.tab(1).getText());
+        t.removeTabAt(1);
+        f.validate();
+        assertEquals(1, p.tabCount());
+        assertEquals(0, t.getSelectedIndex());
+        assertTrue(b.isVisible());
+        assertTrue(p.tab(0).isSelected());
+        List<Object[]> text = paint(f);
+        assertNotNull(find(text, "Zero"));
+    }
+
+    @Test
+    public void theModelAloneHoldsTheSelection() {
+        DefaultSingleSelectionModel m = new DefaultSingleSelectionModel();
+        final int[] events = new int[1];
+        m.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                events[0]++;
+            }
+        });
+        assertEquals(-1, m.getSelectedIndex());
+        assertFalse(m.isSelected());
+        m.setSelectedIndex(3);
+        m.setSelectedIndex(3);
+        assertEquals(1, events[0]);
+        assertTrue(m.isSelected());
+        m.clearSelection();
+        assertEquals(2, events[0]);
+        assertEquals(-1, m.getSelectedIndex());
+        assertEquals(1, m.getChangeListeners().length);
+    }
+
+    /// Tabs are as wide as their titles and start at the leading end,
+    /// whatever the theme does with its own tabs, and the selected one
+    /// carries a bar along the edge facing the page -- on all four sides.
+    @Test
+    public void tabsSizeToTheirTitlesAndTheSelectedOneIsMarked() {
+        java.util.Hashtable<String, Object> theme = new java.util.Hashtable<String, Object>();
+        theme.put("@tabsGridBool", "true");
+        com.codename1.ui.plaf.UIManager.getInstance().addThemeProps(theme);
+        try {
+            JTabbedPane t = new JTabbedPane();
+            t.addTab("A", page("a", 50, 50));
+            t.addTab("A much longer title", page("b", 50, 50));
+            t.addTab("Mid one", page("c", 50, 50));
+            JFrame f = new JFrame();
+            f.add(t, BorderLayout.CENTER);
+            show(f);
+            TabbedPanePeer peer = (TabbedPanePeer) t.cn1Peer();
+            for (int i = 0; i < 3; i++) {
+                peer.tab(i).getPressedStyle().setFgColor(0x12ab34);
+                peer.tab(i).getUnselectedStyle().setFgColor(0x777777);
+                // Room around the text, which the headless display draws as a box.
+                peer.tab(i).getAllStyles().setPadding(12, 12, 12, 12);
+                peer.tab(i).setShouldCalcPreferredSize(true);
+            }
+            // The strip is measured again when the placement changes.
+            t.setTabPlacement(JTabbedPane.RIGHT);
+            int[] placements = {JTabbedPane.TOP, JTabbedPane.BOTTOM, JTabbedPane.LEFT, JTabbedPane.RIGHT};
+            for (int k = 0; k < placements.length; k++) {
+                int placement = placements[k];
+                t.setTabPlacement(placement);
+                t.setSelectedIndex(1);
+                f.validate();
+                Rectangle a = t.getBoundsAt(0);
+                Rectangle b = t.getBoundsAt(1);
+                Rectangle c = t.getBoundsAt(2);
+                boolean across = placement == JTabbedPane.TOP || placement == JTabbedPane.BOTTOM;
+                if (across) {
+                    assertEquals(0, a.x);
+                    assertTrue("tabs follow one another", b.x >= a.x + a.width && c.x >= b.x + b.width);
+                    assertTrue(a.width + " < " + c.width + " < " + b.width, a.width < c.width && c.width < b.width);
+                    assertTrue("the strip is not filled", c.x + c.width < t.getWidth() - 50);
+                } else {
+                    assertEquals(0, a.y);
+                    assertTrue(b.y >= a.y + a.height && c.y >= b.y + b.height);
+                    assertTrue(c.y + c.height < t.getHeight() - 50);
+                }
+                int[][] px = raster(f);
+                // The bar: three logical pixels along the edge towards the page.
+                int bx = placement == JTabbedPane.LEFT ? b.x + b.width - 2 : b.x + 1;
+                int by = placement == JTabbedPane.TOP ? b.y + b.height - 2 : b.y + 1;
+                int bw = across ? b.width - 2 : 1;
+                int bh = across ? 1 : b.height - 2;
+                assertEquals("placement " + placement, bw * bh * 4, count(px, t, bx, by, bw, bh, 0x12ab34));
+                assertEquals("placement " + placement, 0, count(px, t, a.x + 1, a.y + 1, a.width - 2, a.height - 2, 0x12ab34));
+                assertEquals("placement " + placement, 0, count(px, t, c.x + 1, c.y + 1, c.width - 2, c.height - 2, 0x12ab34));
+            }
+        } finally {
+            theme.put("@tabsGridBool", "false");
+            com.codename1.ui.plaf.UIManager.getInstance().addThemeProps(theme);
+        }
+    }
+
+    /// A theme that gives its tabs no padding still leaves the bar of the
+    /// selected tab clear of the title: a tab is taller than its text by
+    /// the bar and a pixel on the bar's side and as much on the other, and
+    /// wider by as much when the tabs are at the side.
+    @Test
+    public void aTabHasRoomForItsBarBesideTheTitle() {
+        JTabbedPane t = new JTabbedPane();
+        t.addTab("Title", page("a", 50, 50));
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        TabbedPanePeer peer = (TabbedPanePeer) t.cn1Peer();
+        com.codename1.ui.Button tab = peer.tab(0);
+        tab.getAllStyles().setPadding(0, 0, 0, 0);
+        tab.getAllStyles().setMargin(0, 0, 0, 0);
+        tab.getAllStyles().setBorder(null);
+        tab.setShouldCalcPreferredSize(true);
+        com.codename1.ui.Font font = tab.getStyle().getFont();
+        int room = 2 * (Math.max(2, com.codename1.desktopcompat.rt.Units.toDevice(3))
+                + com.codename1.desktopcompat.rt.Units.toDevice(1));
+        assertEquals(font.getHeight() + room, tab.getPreferredH());
+        int across = tab.getPreferredW();
+        t.setTabPlacement(JTabbedPane.LEFT);
+        tab = peer.tab(0);
+        tab.setShouldCalcPreferredSize(true);
+        assertEquals(font.getHeight(), tab.getPreferredH());
+        assertEquals(across + room, tab.getPreferredW());
+    }
+
+    /// A title is written in the color set for its tab, and an HTML title
+    /// in the color it asks for; a tab with neither keeps the theme's, and
+    /// gets it back when the color is taken away.
+    @Test
+    public void aTabTitleTakesTheColourAskedFor() {
+        JTabbedPane t = new JTabbedPane();
+        t.addTab("Plain", page("a", 50, 50));
+        t.addTab("<html><font color=blue><b>Blue</b></font></html>", page("b", 50, 50));
+        t.addTab("Set", page("c", 50, 50));
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        TabbedPanePeer peer = (TabbedPanePeer) t.cn1Peer();
+        int theme = peer.tab(0).getUnselectedStyle().getFgColor() & 0xffffff;
+        assertEquals("Blue", peer.tab(1).getText());
+        assertEquals(0x0000ff, peer.tab(1).getUnselectedStyle().getFgColor() & 0xffffff);
+        assertEquals(0x0000ff, peer.tab(1).getPressedStyle().getFgColor() & 0xffffff);
+        assertEquals(theme, peer.tab(2).getUnselectedStyle().getFgColor() & 0xffffff);
+        t.setForegroundAt(2, new com.codename1.desktopcompat.java.awt.Color(0x10, 0x80, 0x20));
+        assertEquals(0x108020, peer.tab(2).getUnselectedStyle().getFgColor() & 0xffffff);
+        assertEquals(0x108020, peer.tab(2).getSelectedStyle().getFgColor() & 0xffffff);
+        assertEquals(theme, peer.tab(0).getUnselectedStyle().getFgColor() & 0xffffff);
+        t.setForegroundAt(2, null);
+        assertEquals(theme, peer.tab(2).getUnselectedStyle().getFgColor() & 0xffffff);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTableEditingTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTableEditingTest.java
new file mode 100644
index 00000000000..9afd15fe8c2
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTableEditingTest.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import org.junit.Test;
+
+/// Editing a table cell: the editor's component over the cell, committing
+/// and cancelling, and the editors chosen by column class.
+public class JTableEditingTest extends KernelTestBase {
+
+    private static final class Sheet extends DefaultTableModel {
+        Sheet() {
+            super(new Object[][]{
+                {"Carol", Integer.valueOf(30), Boolean.TRUE},
+                {"Alice", Integer.valueOf(10), Boolean.FALSE},
+                {"Bob", Integer.valueOf(20), Boolean.TRUE}}, new Object[]{"Name", "Age", "Member"});
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return column == 0 ? String.class : column == 1 ? Integer.class : Boolean.class;
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            return row != 2;
+        }
+    }
+
+    private JFrame placed(JTable t) {
+        JPanel p = new JPanel(null);
+        t.setRowHeight(20);
+        t.setBounds(0, 0, 300, 200);
+        p.add(t);
+        JFrame f = new JFrame();
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    private static void key(Component c, int code) {
+        c.dispatchEvent(new KeyEvent(c, KeyEvent.KEY_PRESSED, System.currentTimeMillis(), 0, code,
+                KeyEvent.CHAR_UNDEFINED));
+    }
+
+    @Test
+    public void theEditorIsAChildOverTheCellAndEnterStoresItsValue() {
+        Sheet model = new Sheet();
+        JTable t = new JTable(model);
+        JFrame f = placed(t);
+        assertFalse("the model says no", t.editCellAt(2, 0));
+        assertTrue(t.editCellAt(1, 0));
+        assertTrue(t.isEditing());
+        assertEquals(1, t.getEditingRow());
+        assertEquals(0, t.getEditingColumn());
+        Component c = t.getEditorComponent();
+        assertTrue(c instanceof JTextField);
+        JTextField field = (JTextField) c;
+        assertEquals("Alice", field.getText());
+        assertSame(t, field.getParent());
+        assertEquals(t.getCellRect(1, 0, false), field.getBounds());
+        assertSame("the native field is in the table's peer", t.cn1Peer(), field.cn1Peer().getParent());
+        field.setText("Zed");
+        assertTrue(field.requestFocusInWindow());
+        f.cn1Form().keyPressed('\n');
+        f.cn1Form().keyReleased('\n');
+        assertFalse(t.isEditing());
+        assertEquals("Zed", model.getValueAt(1, 0));
+        assertNull(field.getParent());
+        assertNull(t.getEditorComponent());
+        assertEquals(-1, t.getEditingRow());
+    }
+
+    @Test
+    public void escapeCancelsAndStoresNothing() {
+        Sheet model = new Sheet();
+        JTable t = new JTable(model);
+        placed(t);
+        assertTrue(t.editCellAt(0, 0));
+        JTextField field = (JTextField) t.getEditorComponent();
+        field.setText("Nobody");
+        key(field, KeyEvent.VK_ESCAPE);
+        assertFalse(t.isEditing());
+        assertEquals("Carol", model.getValueAt(0, 0));
+        assertTrue(t.editCellAt(0, 0));
+        ((JTextField) t.getEditorComponent()).setText("Somebody");
+        assertTrue(t.getCellEditor().stopCellEditing());
+        assertEquals("Somebody", model.getValueAt(0, 0));
+    }
+
+    @Test
+    public void aNumberColumnParsesItsTextAndRefusesWhatIsNoNumber() {
+        Sheet model = new Sheet();
+        JTable t = new JTable(model);
+        placed(t);
+        assertTrue(t.editCellAt(0, 1));
+        JTextField field = (JTextField) t.getEditorComponent();
+        assertEquals("30", field.getText());
+        field.setText("thirty");
+        key(field, KeyEvent.VK_ENTER);
+        assertTrue("text that is no number keeps the editor open", t.isEditing());
+        assertEquals(Integer.valueOf(30), model.getValueAt(0, 1));
+        field.setText(" 31 ");
+        key(field, KeyEvent.VK_ENTER);
+        assertFalse(t.isEditing());
+        assertEquals(Integer.valueOf(31), model.getValueAt(0, 1));
+    }
+
+    @Test
+    public void aTapOnABooleanCellFlipsItAndASecondTapOnTextEditsIt() {
+        Sheet model = new Sheet();
+        JTable t = new JTable(model);
+        JFrame f = placed(t);
+        press(f, t, 250, 25);
+        release(f, t, 250, 25);
+        assertEquals(Boolean.TRUE, model.getValueAt(1, 2));
+        assertFalse("the check box is gone again", t.isEditing());
+        assertEquals(1, t.getSelectedRow());
+        press(f, t, 250, 45);
+        release(f, t, 250, 45);
+        assertEquals("row 2 is not editable", Boolean.TRUE, model.getValueAt(2, 2));
+        press(f, t, 20, 5);
+        release(f, t, 20, 5);
+        assertFalse("one tap on text selects", t.isEditing());
+        assertEquals(0, t.getSelectedRow());
+        press(f, t, 20, 5);
+        release(f, t, 20, 5);
+        assertTrue("the second tap edits", t.isEditing());
+        assertEquals(0, t.getEditingRow());
+        t.removeEditor();
+        assertFalse(t.isEditing());
+    }
+
+    @Test
+    public void f2AndTypingStartAnEditOnTheLeadCell() {
+        Sheet model = new Sheet();
+        JTable t = new JTable(model);
+        placed(t);
+        t.changeSelection(1, 0, false, false);
+        key(t, KeyEvent.VK_F2);
+        assertTrue(t.isEditing());
+        assertEquals(1, t.getEditingRow());
+        t.getCellEditor().cancelCellEditing();
+        assertFalse(t.isEditing());
+        t.dispatchEvent(new KeyEvent(t, KeyEvent.KEY_TYPED, System.currentTimeMillis(), 0, KeyEvent.VK_UNDEFINED,
+                'x'));
+        assertTrue(t.isEditing());
+        assertEquals("x", ((JTextField) t.getEditorComponent()).getText());
+        key(t.getEditorComponent(), KeyEvent.VK_ENTER);
+        assertEquals("x", model.getValueAt(1, 0));
+    }
+
+    @Test
+    public void aChangeOfStructureEndsTheEdit() {
+        Sheet model = new Sheet();
+        JTable t = new JTable(model);
+        placed(t);
+        assertTrue(t.editCellAt(0, 0));
+        model.addColumn("City");
+        assertFalse(t.isEditing());
+        assertEquals(0, t.getComponentCount());
+        assertTrue(t.editCellAt(0, 0));
+        model.removeRow(1);
+        assertFalse(t.isEditing());
+        JComboBox<String> box = new JComboBox<String>(new String[]{"Carol", "Carl"});
+        t.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(box));
+        assertTrue(t.editCellAt(0, 0));
+        assertSame(box, t.getEditorComponent());
+        box.setSelectedItem("Carl");
+        assertFalse("choosing ends the edit", t.isEditing());
+        assertEquals("Carl", model.getValueAt(0, 0));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTableTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTableTest.java
new file mode 100644
index 00000000000..ad96ab4b264
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTableTest.java
@@ -0,0 +1,652 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.InputEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.ListSelectionListener;
+import com.codename1.desktopcompat.javax.swing.event.TableModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TableModelListener;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.javax.swing.table.JTableHeader;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.TableColumn;
+import com.codename1.desktopcompat.javax.swing.table.TableColumnModel;
+import com.codename1.desktopcompat.javax.swing.table.TableRowSorter;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// The table: its model's events, indexes under sorting, filtering and
+/// moved columns, selection, geometry in logical pixels, column sizing,
+/// renderers, the header and the pointer and keys.
+public class JTableTest extends KernelTestBase {
+
+    /// name, age, member: `String`, `Integer`, `Boolean`.
+    private static final class People extends DefaultTableModel {
+        People() {
+            super(new Object[][]{
+                {"Carol", Integer.valueOf(30), Boolean.TRUE},
+                {"Alice", Integer.valueOf(10), Boolean.FALSE},
+                {"Bob", Integer.valueOf(20), Boolean.TRUE},
+                {"Dave", Integer.valueOf(40), Boolean.FALSE}}, new Object[]{"Name", "Age", "Member"});
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return column == 0 ? String.class : column == 1 ? Integer.class : Boolean.class;
+        }
+    }
+
+    /// A renderer that draws text itself and remembers what it was asked.
+    private static final class Stamp extends JComponent implements TableCellRenderer {
+        final List<String> asked = new ArrayList<String>();
+        private String text = "";
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                boolean hasFocus, int row, int column) {
+            asked.add(row + "," + column + "," + value + "," + isSelected);
+            text = "cell:" + value;
+            return this;
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            g.drawString(text, 2, 12);
+        }
+    }
+
+    private JFrame placed(JTable t, int w, int h) {
+        JPanel p = new JPanel(null);
+        t.setBounds(0, 0, w, h);
+        p.add(t);
+        JFrame f = new JFrame();
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    private static int[] widths(JTable t) {
+        TableColumnModel cm = t.getColumnModel();
+        int[] out = new int[cm.getColumnCount()];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = cm.getColumn(i).getWidth();
+        }
+        return out;
+    }
+
+    private static void tap(JTable t, int x, int y, int modifiers, int clicks) {
+        long now = System.currentTimeMillis();
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_PRESSED, now, modifiers, x, y, clicks, false,
+                MouseEvent.BUTTON1));
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_RELEASED, now, modifiers, x, y, clicks, false,
+                MouseEvent.BUTTON1));
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_CLICKED, now, modifiers, x, y, clicks, false,
+                MouseEvent.BUTTON1));
+    }
+
+    private static void key(Component c, int code) {
+        c.dispatchEvent(new KeyEvent(c, KeyEvent.KEY_PRESSED, System.currentTimeMillis(), 0, code,
+                KeyEvent.CHAR_UNDEFINED));
+    }
+
+    // ------------------------------------------------------------ construction
+
+    @Test
+    public void everyConstructionFormMakesColumnsFromTheModel() {
+        assertEquals(0, new JTable().getColumnCount());
+        JTable sized = new JTable(3, 4);
+        assertEquals(3, sized.getRowCount());
+        assertEquals(4, sized.getColumnCount());
+        assertEquals("A", sized.getColumnName(0));
+        final Object[][] data = {{"x", "y"}, {"z", "w"}};
+        JTable arrays = new JTable(data, new Object[]{"One", "Two"});
+        assertEquals("Two", arrays.getColumnModel().getColumn(1).getHeaderValue());
+        assertTrue(arrays.isCellEditable(0, 0));
+        arrays.setValueAt("changed", 1, 1);
+        assertEquals("changed", data[1][1]);
+        JTable people = new JTable(new People());
+        assertEquals(Integer.class, people.getColumnClass(1));
+        assertEquals("Bob", people.getValueAt(2, 0));
+        assertSame(people, people.getTableHeader().getTable());
+    }
+
+    @Test
+    public void defaultRenderersAndEditorsAreFoundByAssignability() {
+        JTable t = new JTable(new People());
+        TableCellRenderer forObject = t.getDefaultRenderer(Object.class);
+        assertNotNull(forObject);
+        assertSame(forObject, t.getDefaultRenderer(String.class));
+        assertSame(t.getDefaultRenderer(Number.class), t.getDefaultRenderer(Integer.class));
+        assertTrue(t.getDefaultRenderer(Boolean.class) instanceof JCheckBox);
+        Stamp mine = new Stamp();
+        t.setDefaultRenderer(Integer.class, mine);
+        assertSame(mine, t.getCellRenderer(0, 1));
+        // As in the JDK, floats and doubles have a renderer of their own.
+        assertNotSame(t.getDefaultRenderer(Number.class), t.getDefaultRenderer(Double.class));
+        assertSame(t.getDefaultRenderer(Number.class), t.getDefaultRenderer(Long.class));
+        TableColumn c = t.getColumnModel().getColumn(0);
+        c.setCellRenderer(mine);
+        assertSame(mine, t.getCellRenderer(3, 0));
+        assertSame(t.getDefaultEditor(Number.class), t.getDefaultEditor(Long.class));
+        assertNotNull(t.getDefaultEditor(Boolean.class));
+    }
+
+    // ------------------------------------------------------------ model events
+
+    @Test
+    public void modelEventsMoveTheSelectionAndRemakeTheColumns() {
+        People model = new People();
+        JTable t = new JTable(model);
+        t.setRowHeight(20);
+        t.setRowSelectionInterval(1, 1);
+        model.insertRow(0, new Object[]{"Eve", Integer.valueOf(5), Boolean.TRUE});
+        assertEquals(5, t.getRowCount());
+        assertEquals(2, t.getSelectedRow());
+        assertEquals(100, t.getPreferredSize().height);
+        model.removeRow(2);
+        assertEquals(-1, t.getSelectedRow());
+        assertEquals(80, t.getPreferredSize().height);
+        model.addColumn("City");
+        assertEquals(4, t.getColumnCount());
+        assertEquals("City", t.getColumnName(3));
+        t.setAutoCreateColumnsFromModel(false);
+        model.addColumn("Zip");
+        assertEquals(4, t.getColumnCount());
+    }
+
+    @Test
+    public void aCellUpdateIsPaintedAgainWithTheNewValue() {
+        People model = new People();
+        JTable t = new JTable(model);
+        Stamp stamp = new Stamp();
+        t.setDefaultRenderer(String.class, stamp);
+        JFrame f = placed(t, 300, 200);
+        assertNotNull(find(paint(f), "cell:Alice"));
+        final List<TableModelEvent> events = new ArrayList<TableModelEvent>();
+        model.addTableModelListener(new TableModelListener() {
+            @Override
+            public void tableChanged(TableModelEvent e) {
+                events.add(e);
+            }
+        });
+        model.setValueAt("Zoe", 1, 0);
+        assertEquals(1, events.size());
+        assertEquals(TableModelEvent.UPDATE, events.get(0).getType());
+        assertEquals(1, events.get(0).getFirstRow());
+        List<Object[]> text = paint(f);
+        assertNull(find(text, "cell:Alice"));
+        assertNotNull(find(text, "cell:Zoe"));
+    }
+
+    // ------------------------------------------------------------ indexes
+
+    @Test
+    public void sortingMapsViewRowsToModelRowsAndKeepsTheSelection() {
+        JTable t = new JTable(new People());
+        t.setAutoCreateRowSorter(true);
+        assertNotNull(t.getRowSorter());
+        t.setRowSelectionInterval(0, 0);
+        t.getRowSorter().toggleSortOrder(0);
+        assertEquals("Alice", t.getValueAt(0, 0));
+        assertEquals("Dave", t.getValueAt(3, 0));
+        assertEquals(1, t.convertRowIndexToModel(0));
+        assertEquals(2, t.convertRowIndexToView(0));
+        assertEquals("Carol stays selected", 2, t.getSelectedRow());
+        t.getRowSorter().toggleSortOrder(0);
+        assertEquals("Dave", t.getValueAt(0, 0));
+        assertEquals(1, t.getSelectedRow());
+        t.getRowSorter().toggleSortOrder(1);
+        assertEquals(Integer.valueOf(10), t.getValueAt(0, 1));
+        assertEquals(Integer.valueOf(40), t.getValueAt(3, 1));
+    }
+
+    @Test
+    public void filteringHidesRowsAndAnEditGoesToTheRightModelRow() {
+        People model = new People();
+        JTable t = new JTable(model);
+        TableRowSorter<DefaultTableModel> sorter = new TableRowSorter<DefaultTableModel>(model);
+        t.setRowSorter(sorter);
+        sorter.setRowFilter(new RowFilter<Object, Object>() {
+            @Override
+            public boolean include(Entry<? extends Object, ? extends Object> entry) {
+                Object age = entry.getValue(1);
+                return age instanceof Integer && ((Integer) age).intValue() >= 20;
+            }
+        });
+        assertEquals(3, t.getRowCount());
+        assertEquals(-1, t.convertRowIndexToView(1));
+        assertEquals(2, t.convertRowIndexToModel(1));
+        t.setValueAt("Robert", 1, 0);
+        assertEquals("Robert", model.getValueAt(2, 0));
+        sorter.toggleSortOrder(1);
+        assertEquals("Robert", t.getValueAt(0, 0));
+        sorter.setRowFilter(null);
+        assertEquals(4, t.getRowCount());
+        model.addRow(new Object[]{"Eve", Integer.valueOf(5), Boolean.TRUE});
+        assertEquals("the new row is sorted in", "Eve", t.getValueAt(0, 0));
+    }
+
+    @Test
+    public void movedColumnsKeepTheirModelIndex() {
+        People model = new People();
+        JTable t = new JTable(model);
+        t.moveColumn(0, 2);
+        assertEquals(0, t.convertColumnIndexToModel(2));
+        assertEquals(2, t.convertColumnIndexToView(0));
+        assertEquals(0, t.convertColumnIndexToView(1));
+        assertEquals("Name", t.getColumnName(2));
+        assertEquals(model.getValueAt(1, 0), t.getValueAt(1, 2));
+        assertEquals(String.class, t.getColumnClass(2));
+        t.removeColumn(t.getColumnModel().getColumn(0));
+        assertEquals(-1, t.convertColumnIndexToView(1));
+        assertEquals(2, t.getColumnCount());
+    }
+
+    // ------------------------------------------------------------ selection
+
+    @Test
+    public void selectionModesAndEvents() {
+        JTable t = new JTable(new People());
+        final List<ListSelectionEvent> events = new ArrayList<ListSelectionEvent>();
+        t.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
+            @Override
+            public void valueChanged(ListSelectionEvent e) {
+                events.add(e);
+            }
+        });
+        t.setRowSelectionInterval(1, 2);
+        assertFalse(events.isEmpty());
+        assertArrayEquals(new int[]{1, 2}, t.getSelectedRows());
+        assertEquals(2, t.getSelectedRowCount());
+        t.addRowSelectionInterval(3, 3);
+        t.removeRowSelectionInterval(2, 2);
+        assertArrayEquals(new int[]{1, 3}, t.getSelectedRows());
+        t.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        assertEquals(0, t.getSelectedRowCount());
+        t.setRowSelectionInterval(0, 2);
+        assertArrayEquals(new int[]{2}, t.getSelectedRows());
+        t.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+        t.selectAll();
+        assertEquals(4, t.getSelectedRowCount());
+        t.clearSelection();
+        assertEquals(-1, t.getSelectedRow());
+    }
+
+    @Test
+    public void changeSelectionTogglesAndExtendsAndCellsCanBeSelected() {
+        JTable t = new JTable(new People());
+        t.changeSelection(1, 0, false, false);
+        t.changeSelection(3, 0, false, true);
+        assertArrayEquals(new int[]{1, 2, 3}, t.getSelectedRows());
+        t.changeSelection(2, 0, true, false);
+        assertArrayEquals(new int[]{1, 3}, t.getSelectedRows());
+        assertTrue("a row is selected in every column", t.isCellSelected(1, 2));
+        t.setCellSelectionEnabled(true);
+        t.changeSelection(1, 1, false, false);
+        assertTrue(t.isCellSelected(1, 1));
+        assertFalse(t.isCellSelected(1, 0));
+        assertFalse(t.isCellSelected(2, 1));
+        assertEquals(1, t.getSelectedColumn());
+        t.setCellSelectionEnabled(false);
+        t.setRowSelectionAllowed(false);
+        assertFalse(t.isCellSelected(1, 1));
+    }
+
+    // ------------------------------------------------------------ geometry
+
+    @Test
+    public void cellRectanglesAndHitTestsAreInLogicalPixels() {
+        JTable t = new JTable(new People());
+        t.setRowHeight(20);
+        placed(t, 300, 200);
+        assertArrayEquals(new int[]{100, 100, 100}, widths(t));
+        assertEquals(new Rectangle(100, 40, 100, 20), t.getCellRect(2, 1, true));
+        assertEquals(new Rectangle(100, 40, 99, 19), t.getCellRect(2, 1, false));
+        assertEquals(2, t.rowAtPoint(new Point(5, 45)));
+        assertEquals(1, t.columnAtPoint(new Point(150, 45)));
+        assertEquals(3, t.rowAtPoint(new Point(5, 79)));
+        assertEquals(-1, t.rowAtPoint(new Point(5, 80)));
+        assertEquals(-1, t.columnAtPoint(new Point(300, 5)));
+        t.setIntercellSpacing(new com.codename1.desktopcompat.java.awt.Dimension(4, 6));
+        assertEquals(new Rectangle(102, 43, 96, 14), t.getCellRect(2, 1, false));
+        t.setRowHeight(1, 50);
+        assertEquals(new Rectangle(0, 70, 100, 20), t.getCellRect(2, 0, true));
+        assertEquals(1, t.rowAtPoint(new Point(5, 69)));
+        assertEquals(50, t.getRowHeight(1));
+    }
+
+    @Test
+    public void rowsAreSizedForAFingerUntilAHeightIsSet() {
+        JTable t = new JTable(new People());
+        assertTrue("touch rows are at least 28 high, got " + t.getRowHeight(), t.getRowHeight() >= 28);
+        assertEquals(4 * t.getRowHeight(), t.getPreferredSize().height);
+        t.setRowHeight(17);
+        assertEquals(17, t.getRowHeight());
+        assertEquals(68, t.getPreferredSize().height);
+    }
+
+    // ------------------------------------------------------------ column sizing
+
+    @Test
+    public void columnsShareTheWidthFromTheirPreferredWidths() {
+        JTable t = new JTable(new People());
+        TableColumnModel cm = t.getColumnModel();
+        cm.getColumn(0).setPreferredWidth(50);
+        cm.getColumn(1).setPreferredWidth(100);
+        cm.getColumn(2).setPreferredWidth(150);
+        t.setSize(600, 100);
+        t.doLayout();
+        assertArrayEquals(new int[]{150, 200, 250}, widths(t));
+        // Shrinking: each column gives up the share its room above its
+        // minimum is of all the room. 300 down to 241 with minimums 90,
+        // 15 and 15: 96.72, then 72 of the 144 left, and the rest.
+        cm.getColumn(0).setPreferredWidth(100);
+        cm.getColumn(1).setPreferredWidth(100);
+        cm.getColumn(2).setPreferredWidth(100);
+        cm.getColumn(0).setMinWidth(90);
+        t.setSize(241, 100);
+        t.doLayout();
+        assertArrayEquals(new int[]{97, 72, 72}, widths(t));
+        t.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+        t.doLayout();
+        assertArrayEquals(new int[]{100, 100, 100}, widths(t));
+        assertFalse(t.getScrollableTracksViewportWidth());
+        assertEquals(300, t.getPreferredSize().width);
+    }
+
+    private static int[] afterDragging(int mode) {
+        JTable t = new JTable(new People());
+        t.setAutoResizeMode(mode);
+        t.setSize(300, 100);
+        t.doLayout();
+        JTableHeader h = t.getTableHeader();
+        TableColumn first = t.getColumnModel().getColumn(0);
+        h.setResizingColumn(first);
+        first.setWidth(130);
+        t.doLayout();
+        h.setResizingColumn(null);
+        t.doLayout();
+        return widths(t);
+    }
+
+    @Test
+    public void aDraggedColumnTakesItsWidthFromTheColumnsTheModeNames() {
+        assertArrayEquals(new int[]{130, 70, 100}, afterDragging(JTable.AUTO_RESIZE_NEXT_COLUMN));
+        assertArrayEquals(new int[]{130, 85, 85}, afterDragging(JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS));
+        assertArrayEquals(new int[]{130, 100, 70}, afterDragging(JTable.AUTO_RESIZE_LAST_COLUMN));
+        assertArrayEquals(new int[]{130, 75, 75}, afterDragging(JTable.AUTO_RESIZE_OFF));
+    }
+
+    // ------------------------------------------------------------ painting
+
+    @Test
+    public void aCustomRendererIsAskedPerCellAndItsDrawingReachesTheScreen() {
+        JTable t = new JTable(new People());
+        t.setRowHeight(20);
+        Stamp stamp = new Stamp();
+        t.setDefaultRenderer(String.class, stamp);
+        t.setDefaultRenderer(Integer.class, stamp);
+        t.setRowSelectionInterval(2, 2);
+        JFrame f = placed(t, 300, 200);
+        stamp.asked.clear();
+        List<Object[]> text = paint(f);
+        assertTrue(stamp.asked.contains("0,0,Carol,false"));
+        assertTrue(stamp.asked.contains("2,0,Bob,true"));
+        assertTrue(stamp.asked.contains("3,1,40,false"));
+        assertEquals(8, stamp.asked.size());
+        Object[] bob = find(text, "cell:Bob");
+        Object[] twenty = find(text, "cell:20");
+        assertNotNull(bob);
+        assertNotNull(twenty);
+        int[] origin = onDisplay(t, 0, 0);
+        // Column 0 starts at 0 and column 1 at 100, row 2 at 40; the
+        // renderer draws 2 in from the cell's left edge.
+        assertEquals(origin[0] + 2 * 2, ((Integer) bob[1]).intValue());
+        assertEquals(origin[0] + 2 * 102, ((Integer) twenty[1]).intValue());
+        assertEquals(bob[2], twenty[2]);
+        Object[] carol = find(text, "cell:Carol");
+        assertEquals(2 * 40, ((Integer) bob[2]).intValue() - ((Integer) carol[2]).intValue());
+    }
+
+    @Test
+    public void theDefaultRenderersDrawTheValuesThroughTheNativeLabel() {
+        JTable t = new JTable(new People());
+        JFrame f = placed(t, 300, 200);
+        List<Object[]> text = paint(f);
+        assertNotNull(find(text, "Alice"));
+        assertNotNull(find(text, "40"));
+        Component c = t.prepareRenderer(t.getCellRenderer(1, 0), 1, 0);
+        assertTrue(c instanceof DefaultTableCellRenderer);
+        assertEquals("Alice", ((DefaultTableCellRenderer) c).getText());
+        t.setRowSelectionInterval(1, 1);
+        c = t.prepareRenderer(t.getCellRenderer(1, 0), 1, 0);
+        assertEquals(t.getSelectionBackground(), c.getBackground());
+        c = t.prepareRenderer(t.getCellRenderer(0, 0), 0, 0);
+        assertEquals(t.getBackground(), c.getBackground());
+    }
+
+    @Test
+    public void onlyTheCellsThatMeetTheClipArePainted() {
+        JTable t = new JTable(new DefaultTableModel(1000, 3));
+        t.setRowHeight(20);
+        Stamp stamp = new Stamp();
+        t.setDefaultRenderer(Object.class, stamp);
+        t.setSize(300, 20000);
+        t.doLayout();
+        BufferedImage image = new BufferedImage(300, 200, BufferedImage.TYPE_INT_ARGB);
+        Graphics g = image.createGraphics();
+        g.setClip(0, 40, 300, 40);
+        stamp.asked.clear();
+        t.paint(g);
+        g.dispose();
+        assertEquals("two rows of three cells", 6, stamp.asked.size());
+        assertTrue(stamp.asked.get(0).startsWith("2,0,"));
+        assertTrue(stamp.asked.get(5).startsWith("3,2,"));
+        g = image.createGraphics();
+        g.setClip(110, 45, 20, 5);
+        stamp.asked.clear();
+        t.paint(g);
+        g.dispose();
+        assertEquals(1, stamp.asked.size());
+        assertTrue(stamp.asked.get(0).startsWith("2,1,"));
+    }
+
+    // ------------------------------------------------------------ header
+
+    @Test
+    public void aClickOnAHeaderTitleSortsByThatColumn() {
+        JTable t = new JTable(new People());
+        t.setAutoCreateRowSorter(true);
+        JTableHeader h = t.getTableHeader();
+        JFrame f = new JFrame();
+        f.add(h, BorderLayout.NORTH);
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        assertTrue(h.getHeight() >= 20);
+        assertEquals(t.getWidth(), h.getWidth());
+        assertNotNull("titles are painted", find(paint(f), "Age"));
+        int third = t.getWidth() / 3;
+        press(f, h, third + 20, 10);
+        release(f, h, third + 20, 10);
+        assertEquals("sorted by age", "Alice", t.getValueAt(0, 0));
+        assertEquals(1, t.getRowSorter().getSortKeys().get(0).getColumn());
+        assertEquals(SortOrder.ASCENDING, t.getRowSorter().getSortKeys().get(0).getSortOrder());
+        press(f, h, third + 20, 10);
+        release(f, h, third + 20, 10);
+        assertEquals("Dave", t.getValueAt(0, 0));
+        press(f, h, 20, 10);
+        release(f, h, 20, 10);
+        assertEquals("sorted by name", "Alice", t.getValueAt(0, 0));
+        assertEquals(1, h.columnAtPoint(new Point(third + 20, 5)));
+        assertEquals(third, h.getHeaderRect(1).x);
+    }
+
+    @Test
+    public void draggingTheLineBetweenTwoTitlesResizesTheColumn() {
+        JTable t = new JTable(new People());
+        JTableHeader h = t.getTableHeader();
+        JFrame f = new JFrame();
+        f.add(h, BorderLayout.NORTH);
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        int w = t.getWidth();
+        int first = t.getColumnModel().getColumn(0).getWidth();
+        press(f, h, first, 10);
+        assertSame(t.getColumnModel().getColumn(0), h.getResizingColumn());
+        drag(f, h, first + 40, 10);
+        release(f, h, first + 40, 10);
+        assertNull(h.getResizingColumn());
+        assertEquals(first + 40, t.getColumnModel().getColumn(0).getWidth());
+        int[] now = widths(t);
+        assertEquals("the others made room", w, now[0] + now[1] + now[2]);
+        f.validate();
+        assertArrayEquals("the widths stay after the next layout", now, widths(t));
+    }
+
+    // ------------------------------------------------------------ pointer and keys
+
+    @Test
+    public void aTapSelectsADragDoesNotAndModifiersToggleAndExtend() {
+        JTable t = new JTable(new People());
+        t.setRowHeight(20);
+        JFrame f = placed(t, 300, 200);
+        press(f, t, 150, 45);
+        release(f, t, 150, 45);
+        assertEquals(2, t.getSelectedRow());
+        assertEquals(1, t.getColumnModel().getSelectionModel().getLeadSelectionIndex());
+        t.clearSelection();
+        press(f, t, 150, 5);
+        drag(f, t, 150, 30);
+        drag(f, t, 150, 70);
+        release(f, t, 150, 70);
+        assertEquals("a finger drag scrolls, it does not select", -1, t.getSelectedRow());
+        tap(t, 10, 5, 0, 1);
+        tap(t, 10, 65, InputEvent.SHIFT_MASK, 1);
+        assertArrayEquals(new int[]{0, 1, 2, 3}, t.getSelectedRows());
+        tap(t, 10, 25, InputEvent.CTRL_MASK, 1);
+        assertArrayEquals(new int[]{0, 2, 3}, t.getSelectedRows());
+        tap(t, 10, 150, 0, 1);
+        assertArrayEquals("below the rows nothing changes", new int[]{0, 2, 3}, t.getSelectedRows());
+    }
+
+    @Test
+    public void arrowKeysMoveTheSelection() {
+        JTable t = new JTable(new People());
+        JFrame f = placed(t, 300, 200);
+        assertNotNull(f);
+        t.changeSelection(0, 0, false, false);
+        key(t, KeyEvent.VK_DOWN);
+        key(t, KeyEvent.VK_DOWN);
+        assertEquals(2, t.getSelectedRow());
+        key(t, KeyEvent.VK_UP);
+        assertEquals(1, t.getSelectedRow());
+        key(t, KeyEvent.VK_RIGHT);
+        assertEquals(1, t.getColumnModel().getSelectionModel().getLeadSelectionIndex());
+        key(t, KeyEvent.VK_END);
+        assertEquals(2, t.getColumnModel().getSelectionModel().getLeadSelectionIndex());
+        key(t, KeyEvent.VK_TAB);
+        assertEquals("tab wraps to the next row", 2, t.getSelectedRow());
+        assertEquals(0, t.getColumnModel().getSelectionModel().getLeadSelectionIndex());
+        key(t, KeyEvent.VK_PAGE_DOWN);
+        assertEquals(3, t.getSelectedRow());
+        key(t, KeyEvent.VK_DOWN);
+        assertEquals(3, t.getSelectedRow());
+    }
+
+    /// The default renderers by column class write what the JDK's write:
+    /// a double through the number format (44.0 is "44", at most three
+    /// fraction digits), other numbers as they are, both at the trailing
+    /// edge; a date through the date format; an icon centered.
+    @Test
+    public void theDefaultRenderersFormatAsTheJdksDo() {
+        final java.util.Date day = new java.util.Date(86400000L * 365);
+        final Icon icon = new Icon() {
+            public void paintIcon(Component c, Graphics g, int x, int y) {
+                g.fillRect(x, y, 8, 8);
+            }
+
+            public int getIconWidth() {
+                return 8;
+            }
+
+            public int getIconHeight() {
+                return 8;
+            }
+        };
+        DefaultTableModel m = new DefaultTableModel(new Object[][]{
+            {Double.valueOf(44.0), Float.valueOf(2.5f), Integer.valueOf(7), day, icon},
+            {Double.valueOf(2.7182818285), Float.valueOf(1f), Long.valueOf(1234567L), day, icon},
+            {Double.valueOf(1234567.5), null, null, null, null}},
+                new Object[]{"d", "f", "n", "when", "pic"}) {
+            @Override
+            public Class<?> getColumnClass(int c) {
+                return c == 0 ? Double.class : c == 1 ? Float.class : c == 2 ? Number.class
+                        : c == 3 ? java.util.Date.class : Icon.class;
+            }
+        };
+        JTable t = new JTable(m);
+        javax.swing.JTable real = new javax.swing.JTable();
+        String[][] expected = {{"44", "2.5", "7"}, {"2.718", "1", "1234567"}, {"1,234,567.5", "", ""}};
+        for (int r = 0; r < 3; r++) {
+            for (int c = 0; c < 3; c++) {
+                Component comp = t.getCellRenderer(r, c).getTableCellRendererComponent(t, m.getValueAt(r, c),
+                        false, false, r, c);
+                assertTrue(comp instanceof JLabel);
+                assertEquals(r + "," + c, expected[r][c], ((JLabel) comp).getText());
+                assertEquals(SwingConstants.RIGHT, ((JLabel) comp).getHorizontalAlignment());
+                // And the JDK's own renderer for the class says the same.
+                java.awt.Component theirs = real.getDefaultRenderer(m.getColumnClass(c))
+                        .getTableCellRendererComponent(real, m.getValueAt(r, c), false, false, 0, 0);
+                assertEquals(((javax.swing.JLabel) theirs).getText(), ((JLabel) comp).getText());
+            }
+        }
+        Component date = t.getCellRenderer(0, 3).getTableCellRendererComponent(t, day, false, false, 0, 3);
+        assertEquals(java.text.DateFormat.getDateInstance().format(day), ((JLabel) date).getText());
+        Component pic = t.getCellRenderer(0, 4).getTableCellRendererComponent(t, icon, false, false, 0, 4);
+        assertSame(icon, ((JLabel) pic).getIcon());
+        assertEquals("", ((JLabel) pic).getText());
+        assertEquals(SwingConstants.CENTER, ((JLabel) pic).getHorizontalAlignment());
+        assertSame(t.getDefaultRenderer(Icon.class).getClass(), t.getDefaultRenderer(ImageIcon.class).getClass());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTreeTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTreeTest.java
new file mode 100644
index 00000000000..442de6ab451
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/JTreeTest.java
@@ -0,0 +1,581 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeSelectionListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeWillExpandListener;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultTreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.ExpandVetoException;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreeModel;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.javax.swing.tree.TreeSelectionModel;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+import org.junit.AfterClass;
+import org.junit.Test;
+
+/// The tree: rows under expanding and collapsing, a model that is only
+/// asked about what shows, selection by path, model changes that keep the
+/// expansion, and the pointer on arrows and on rows.
+public class JTreeTest extends KernelTestBase {
+
+    /// The kernel counts clicks by time alone and keeps the count between
+    /// tests, so the taps made here would reach the next test class as
+    /// one long multiple click. Wait the count out.
+    @AfterClass
+    public static void letTheClickCountRunOut() throws InterruptedException {
+        Thread.sleep(600);
+    }
+
+    private final DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
+    private final DefaultMutableTreeNode a = new DefaultMutableTreeNode("a");
+    private final DefaultMutableTreeNode a1 = new DefaultMutableTreeNode("a1");
+    private final DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("a2");
+    private final DefaultMutableTreeNode b = new DefaultMutableTreeNode("b");
+    private final DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("b1");
+    private final DefaultMutableTreeNode b1x = new DefaultMutableTreeNode("b1x");
+    private final DefaultTreeModel model = new DefaultTreeModel(root);
+
+    {
+        root.add(a);
+        root.add(b);
+        a.add(a1);
+        a.add(a2);
+        b.add(b1);
+        b1.add(b1x);
+    }
+
+    private TreePath path(DefaultMutableTreeNode n) {
+        return new TreePath(model.getPathToRoot(n));
+    }
+
+    private static String rows(JTree t) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < t.getRowCount(); i++) {
+            if (i > 0) {
+                sb.append(' ');
+            }
+            sb.append(t.getPathForRow(i).getLastPathComponent());
+        }
+        return sb.toString();
+    }
+
+    /// A tree without end: every node has two children, made when asked.
+    private static final class Endless implements TreeModel {
+        final List<Object> asked = new ArrayList<Object>();
+
+        @Override
+        public Object getRoot() {
+            return "r";
+        }
+
+        @Override
+        public Object getChild(Object parent, int index) {
+            asked.add(parent);
+            return parent + "/" + index;
+        }
+
+        @Override
+        public int getChildCount(Object parent) {
+            asked.add(parent);
+            return 2;
+        }
+
+        @Override
+        public boolean isLeaf(Object node) {
+            return false;
+        }
+
+        @Override
+        public void valueForPathChanged(TreePath path, Object newValue) {
+        }
+
+        @Override
+        public int getIndexOfChild(Object parent, Object child) {
+            return String.valueOf(child).endsWith("/1") ? 1 : 0;
+        }
+
+        @Override
+        public void addTreeModelListener(TreeModelListener l) {
+        }
+
+        @Override
+        public void removeTreeModelListener(TreeModelListener l) {
+        }
+    }
+
+    private static void key(Component c, int code) {
+        c.dispatchEvent(new KeyEvent(c, KeyEvent.KEY_PRESSED, System.currentTimeMillis(), 0, code,
+                KeyEvent.CHAR_UNDEFINED));
+    }
+
+    // ------------------------------------------------------------ rows
+
+    @Test
+    public void expandingAndCollapsingChangesTheRows() {
+        JTree t = new JTree(model);
+        assertEquals("the root starts expanded", "root a b", rows(t));
+        assertTrue(t.isExpanded(0));
+        assertFalse(t.isExpanded(path(a)));
+        t.expandPath(path(a));
+        assertEquals("root a a1 a2 b", rows(t));
+        assertEquals(2, t.getRowForPath(path(a1)));
+        assertEquals(-1, t.getRowForPath(path(b1)));
+        assertEquals(path(b), t.getPathForRow(4));
+        assertNull(t.getPathForRow(5));
+        t.expandPath(path(b1));
+        assertEquals("expanding expands what is above", "root a a1 a2 b b1 b1x", rows(t));
+        t.collapsePath(path(b));
+        assertEquals("root a a1 a2 b", rows(t));
+        assertTrue(t.hasBeenExpanded(path(b)));
+        t.expandRow(4);
+        assertEquals("what was open below comes back", "root a a1 a2 b b1 b1x", rows(t));
+        t.collapseRow(0);
+        assertEquals("root", rows(t));
+        t.expandPath(path(a1));
+        assertEquals("a leaf does not expand", "root", rows(t));
+        t.setRootVisible(false);
+        assertEquals("a hidden root shows its children", "a a1 a2 b b1 b1x", rows(t));
+        t.makeVisible(path(b1x));
+        assertTrue(t.isVisible(path(b1x)));
+    }
+
+    @Test
+    public void listenersHearAndCanStopAnExpansion() {
+        JTree t = new JTree(model);
+        final List<String> log = new ArrayList<String>();
+        t.addTreeExpansionListener(new TreeExpansionListener() {
+            @Override
+            public void treeExpanded(TreeExpansionEvent event) {
+                log.add("expanded " + event.getPath().getLastPathComponent());
+            }
+
+            @Override
+            public void treeCollapsed(TreeExpansionEvent event) {
+                log.add("collapsed " + event.getPath().getLastPathComponent());
+            }
+        });
+        t.addTreeWillExpandListener(new TreeWillExpandListener() {
+            @Override
+            public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException {
+                if (event.getPath().getLastPathComponent() == b) {
+                    throw new ExpandVetoException(event);
+                }
+            }
+
+            @Override
+            public void treeWillCollapse(TreeExpansionEvent event) {
+                log.add("will collapse " + event.getPath().getLastPathComponent());
+            }
+        });
+        t.expandPath(path(a));
+        t.expandPath(path(b));
+        t.expandPath(path(b1));
+        t.collapsePath(path(a));
+        assertEquals("root a b", rows(t));
+        assertEquals("[expanded a, will collapse a, collapsed a]", log.toString());
+    }
+
+    @Test
+    public void onlyExpandedNodesAreAskedForTheirChildren() {
+        Endless endless = new Endless();
+        JTree t = new JTree(endless);
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        assertEquals(3, t.getRowCount());
+        assertNotNull(find(paint(f), "r/1"));
+        assertNotNull(t.getPreferredSize());
+        for (int i = 0; i < endless.asked.size(); i++) {
+            assertEquals("r", endless.asked.get(i));
+        }
+        endless.asked.clear();
+        t.expandRow(1);
+        assertEquals(5, t.getRowCount());
+        paint(f);
+        assertTrue(endless.asked.contains("r/0"));
+        assertFalse(endless.asked.contains("r/1"));
+        assertFalse(endless.asked.contains("r/0/0"));
+        assertEquals("r/0/1", t.getPathForRow(3).getLastPathComponent());
+    }
+
+    @Test
+    public void arraysAndVectorsBecomeTrees() {
+        Vector<Object> inner = new Vector<Object>();
+        inner.add("x");
+        inner.add("y");
+        JTree t = new JTree(new Object[]{"one", inner, "three"});
+        assertFalse(t.isRootVisible());
+        assertTrue(t.getShowsRootHandles());
+        assertEquals(3, t.getRowCount());
+        t.expandRow(1);
+        assertEquals(5, t.getRowCount());
+        assertEquals("y", t.getPathForRow(3).getLastPathComponent().toString());
+        assertEquals("colors", new JTree().getPathForRow(1).getLastPathComponent().toString());
+    }
+
+    // ------------------------------------------------------------ selection
+
+    @Test
+    public void selectionIsByPathAndTheTreeTellsItsListeners() {
+        JTree t = new JTree(model);
+        final List<TreeSelectionEvent> events = new ArrayList<TreeSelectionEvent>();
+        t.addTreeSelectionListener(new TreeSelectionListener() {
+            @Override
+            public void valueChanged(TreeSelectionEvent e) {
+                events.add(e);
+            }
+        });
+        t.setSelectionPath(path(a2));
+        assertEquals("selecting a hidden node shows it", "root a a1 a2 b", rows(t));
+        assertEquals(1, events.size());
+        assertSame(t, events.get(0).getSource());
+        assertTrue(events.get(0).isAddedPath());
+        assertEquals(path(a2), events.get(0).getPath());
+        assertEquals(3, t.getSelectionRows()[0]);
+        assertSame(a2, t.getLastSelectedPathComponent());
+        assertEquals(path(a2), t.getLeadSelectionPath());
+        assertEquals(3, t.getLeadSelectionRow());
+        t.addSelectionRow(4);
+        assertEquals(2, t.getSelectionCount());
+        assertTrue(t.isRowSelected(4));
+        assertTrue(t.isPathSelected(path(b)));
+        t.setSelectionInterval(1, 3);
+        assertEquals(3, t.getSelectionCount());
+        assertEquals(1, t.getMinSelectionRow());
+        assertEquals(3, t.getMaxSelectionRow());
+        t.collapsePath(path(a));
+        assertEquals("a selection below a collapsed node moves onto it", 1, t.getSelectionCount());
+        assertEquals(path(a), t.getSelectionPath());
+        t.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
+        t.setSelectionInterval(0, 2);
+        assertEquals(1, t.getSelectionCount());
+        t.clearSelection();
+        assertTrue(t.isSelectionEmpty());
+        assertNull(t.getSelectionPaths());
+    }
+
+    // ------------------------------------------------------------ model events
+
+    @Test
+    public void modelChangesKeepWhatIsExpanded() {
+        JTree t = new JTree(model);
+        t.expandPath(path(a));
+        t.expandPath(path(b1));
+        t.setSelectionPath(path(a1));
+        DefaultMutableTreeNode c = new DefaultMutableTreeNode("c");
+        model.insertNodeInto(c, root, 0);
+        assertEquals("root c a a1 a2 b b1 b1x", rows(t));
+        assertTrue(t.isExpanded(path(a)));
+        assertEquals("the selection follows its node", 3, t.getSelectionRows()[0]);
+        a1.setUserObject("first");
+        model.nodeChanged(a1);
+        assertEquals("root c a first a2 b b1 b1x", rows(t));
+        TreePath gone = path(a);
+        model.removeNodeFromParent(a);
+        assertEquals("root c b b1 b1x", rows(t));
+        assertFalse(t.hasBeenExpanded(gone));
+        assertTrue("the selection below the removed node is gone", t.isSelectionEmpty());
+        b1.add(new DefaultMutableTreeNode("b1y"));
+        model.nodeStructureChanged(b);
+        assertEquals("b stays open, what was open below it is forgotten", "root c b b1", rows(t));
+        t.expandPath(path(b1));
+        assertEquals("root c b b1 b1x b1y", rows(t));
+        model.reload();
+        assertEquals("root c b", rows(t));
+        DefaultMutableTreeNode other = new DefaultMutableTreeNode("other");
+        other.add(new DefaultMutableTreeNode("leaf"));
+        model.setRoot(other);
+        assertEquals("other leaf", rows(t));
+    }
+
+    // ------------------------------------------------------------ geometry and pointer
+
+    @Test
+    public void rowsAreIndentedAndSizedInLogicalPixels() {
+        JTree t = new JTree(model);
+        t.setRowHeight(20);
+        t.expandPath(path(a));
+        Rectangle rootBounds = t.getRowBounds(0);
+        Rectangle aBounds = t.getPathBounds(path(a));
+        Rectangle a1Bounds = t.getPathBounds(path(a1));
+        assertEquals(0, rootBounds.x);
+        assertEquals(0, rootBounds.y);
+        assertEquals(20, rootBounds.height);
+        int step = aBounds.x;
+        assertTrue("an indent a finger can hit, got " + step, step >= 20);
+        assertEquals(20, aBounds.y);
+        assertEquals(2 * step, a1Bounds.x);
+        assertEquals(40, a1Bounds.y);
+        assertTrue(a1Bounds.width > 0);
+        assertNull(t.getPathBounds(path(b1)));
+        assertEquals(5 * 20, t.getPreferredSize().height);
+        assertTrue(t.getPreferredSize().width >= a1Bounds.x + a1Bounds.width);
+        assertEquals(2, t.getRowForLocation(2 * step + 1, 45));
+        assertEquals("before the text is not on the row", -1, t.getRowForLocation(step, 45));
+        assertEquals(2, t.getClosestRowForLocation(0, 45));
+        assertEquals(4, t.getClosestRowForLocation(0, 4000));
+        assertNull(t.getPathForLocation(5, 400));
+        t.setShowsRootHandles(true);
+        assertEquals(step, t.getRowBounds(0).x);
+        t.setRowHeight(0);
+        assertTrue("touch rows are at least 32 high", t.getRowHeight() >= 32);
+        assertEquals(20 * t.getRowHeight(), t.getPreferredScrollableViewportSize().height);
+    }
+
+    @Test
+    public void aTapOnTheArrowTogglesAndATapOnTheRowSelects() {
+        JTree t = new JTree(model);
+        t.setRowHeight(30);
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        int step = t.getPathBounds(path(a)).x;
+        press(f, t, step / 2, 45);
+        release(f, t, step / 2, 45);
+        assertTrue("the arrow expands", t.isExpanded(path(a)));
+        assertTrue("and does not select", t.isSelectionEmpty());
+        press(f, t, step + 5, 45);
+        release(f, t, step + 5, 45);
+        assertEquals(path(a), t.getSelectionPath());
+        assertTrue("one tap on the row does not toggle", t.isExpanded(path(a)));
+        press(f, t, step / 2, 45);
+        release(f, t, step / 2, 45);
+        assertFalse("the arrow collapses", t.isExpanded(path(a)));
+        assertEquals("root a b", rows(t));
+        press(f, t, step + 5, 75);
+        release(f, t, step + 5, 75);
+        assertEquals(path(b), t.getSelectionPath());
+        assertFalse(t.isExpanded(path(b)));
+        press(f, t, step + 5, 75);
+        release(f, t, step + 5, 75);
+        assertTrue("the second tap on a row toggles it", t.isExpanded(path(b)));
+        press(f, t, step + 5, 15);
+        drag(f, t, step + 5, 60);
+        release(f, t, step + 5, 60);
+        assertEquals("a finger drag does not select", path(b), t.getSelectionPath());
+        press(f, t, 300, 15);
+        release(f, t, 300, 15);
+        assertEquals("the row reaches to the right edge", new TreePath(root), t.getSelectionPath());
+    }
+
+    @Test
+    public void theRendererIsAskedPerVisibleRowAndPaints() {
+        JTree t = new JTree(model);
+        t.setRowHeight(20);
+        final List<String> asked = new ArrayList<String>();
+        final JComponent stamp = new JComponent() {
+            @Override
+            protected void paintComponent(Graphics g) {
+                g.drawString("node:" + getName(), 1, 12);
+            }
+        };
+        t.setCellRenderer(new TreeCellRenderer() {
+            @Override
+            public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected,
+                    boolean expanded, boolean leaf, int row, boolean hasFocus) {
+                asked.add(value + "," + selected + "," + expanded + "," + leaf + "," + row);
+                stamp.setName(String.valueOf(value));
+                return stamp;
+            }
+        });
+        t.expandPath(path(a));
+        t.setSelectionPath(path(a1));
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        asked.clear();
+        List<Object[]> text = paint(f);
+        assertTrue(asked.contains("root,false,true,false,0"));
+        assertTrue(asked.contains("a,false,true,false,1"));
+        assertTrue(asked.contains("a1,true,false,true,2"));
+        assertTrue(asked.contains("b,false,false,false,4"));
+        Object[] rootText = find(text, "node:root");
+        Object[] a1Text = find(text, "node:a1");
+        assertNotNull(rootText);
+        assertNotNull(a1Text);
+        int step = t.getPathBounds(path(a)).x;
+        assertEquals(2 * 2 * step, ((Integer) a1Text[1]).intValue() - ((Integer) rootText[1]).intValue());
+        assertEquals(2 * 40, ((Integer) a1Text[2]).intValue() - ((Integer) rootText[2]).intValue());
+        assertNull("what is collapsed is not painted", find(text, "node:b1"));
+    }
+
+    @Test
+    public void theDefaultRendererDrawsTheNodeText() {
+        JTree t = new JTree(model);
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertNotNull(find(text, "root"));
+        assertNotNull(find(text, "b"));
+        assertNull(find(text, "a1"));
+    }
+
+    // ------------------------------------------------------------ keys and editing
+
+    @Test
+    public void arrowKeysWalkAndOpenTheTree() {
+        JTree t = new JTree(model);
+        t.setSelectionRow(0);
+        key(t, KeyEvent.VK_DOWN);
+        assertEquals(path(a), t.getSelectionPath());
+        key(t, KeyEvent.VK_RIGHT);
+        assertTrue(t.isExpanded(path(a)));
+        key(t, KeyEvent.VK_RIGHT);
+        assertEquals(path(a1), t.getSelectionPath());
+        key(t, KeyEvent.VK_LEFT);
+        assertEquals(path(a), t.getSelectionPath());
+        key(t, KeyEvent.VK_LEFT);
+        assertFalse(t.isExpanded(path(a)));
+        key(t, KeyEvent.VK_END);
+        assertEquals(path(b), t.getSelectionPath());
+        key(t, KeyEvent.VK_HOME);
+        assertEquals(new TreePath(root), t.getSelectionPath());
+    }
+
+    @Test
+    public void editingPutsATextFieldOverTheRowAndStoresItsValue() {
+        JTree t = new JTree(model);
+        t.setRowHeight(20);
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        t.startEditingAtPath(path(a));
+        assertFalse("a tree is not editable until asked", t.isEditing());
+        t.setEditable(true);
+        t.startEditingAtPath(path(a1));
+        assertTrue(t.isEditing());
+        assertEquals(path(a1), t.getEditingPath());
+        assertEquals(1, t.getComponentCount());
+        Component c = t.getComponent(0);
+        assertTrue(c instanceof JTextField);
+        assertEquals("a1", ((JTextField) c).getText());
+        assertEquals(t.getPathBounds(path(a1)).x, c.getX());
+        assertEquals(40, c.getY());
+        assertEquals(20, c.getHeight());
+        ((JTextField) c).setText("renamed");
+        assertTrue(t.stopEditing());
+        assertFalse(t.isEditing());
+        assertEquals(0, t.getComponentCount());
+        assertEquals("renamed", a1.getUserObject());
+        t.startEditingAtPath(path(a2));
+        ((JTextField) t.getComponent(0)).setText("dropped");
+        key(t.getComponent(0), KeyEvent.VK_ESCAPE);
+        assertFalse(t.isEditing());
+        assertEquals("a2", a2.getUserObject());
+    }
+
+    /// A node has a folder and a leaf a sheet before its text unless the
+    /// application sets other icons, and the text starts after the icon.
+    @Test
+    public void nodesAndLeavesHaveStockIconsBeforeTheirText() {
+        com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer r =
+                new com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer();
+        assertNotNull(r.getOpenIcon());
+        assertNotNull(r.getClosedIcon());
+        assertNotNull(r.getLeafIcon());
+        assertSame(r.getDefaultLeafIcon(), r.getLeafIcon());
+        assertEquals(16, r.getClosedIcon().getIconWidth());
+
+        DefaultMutableTreeNode top = new DefaultMutableTreeNode("top");
+        DefaultMutableTreeNode folder = new DefaultMutableTreeNode("folder");
+        folder.add(new DefaultMutableTreeNode("inner"));
+        top.add(folder);
+        top.add(new DefaultMutableTreeNode("leaf"));
+        JTree t = new JTree(top);
+        t.setBackground(com.codename1.desktopcompat.java.awt.Color.WHITE);
+        t.setForeground(com.codename1.desktopcompat.java.awt.Color.BLACK);
+        JFrame f = new JFrame();
+        f.add(t, BorderLayout.CENTER);
+        show(f);
+        assertEquals("only the root is expanded at first", 3, t.getRowCount());
+        int[][] px = raster(f);
+        for (int row = 0; row < 3; row++) {
+            Rectangle b = t.getRowBounds(row);
+            int painted = b.width * b.height * 4 - count(px, t, b.x, b.y, 16, b.height, 0xffffff)
+                    - (b.width - 16) * b.height * 4;
+            assertTrue("row " + row + " has an icon", painted > 40);
+        }
+        java.util.List<Object[]> text = paint(f);
+        Object[] leaf = find(text, "leaf");
+        assertNotNull(leaf);
+        Rectangle lb = t.getRowBounds(2);
+        assertTrue("the text follows the icon",
+                ((Integer) leaf[1]).intValue() >= onDisplay(t, lb.x + 16, 0)[0]);
+
+        // An application that wants bare text sets the icons to null.
+        r.setLeafIcon(null);
+        r.setOpenIcon(null);
+        r.setClosedIcon(null);
+        t.setCellRenderer(r);
+        text = paint(f);
+        leaf = find(text, "leaf");
+        assertNotNull(leaf);
+        assertEquals(onDisplay(t, t.getRowBounds(2).x, 0)[0], ((Integer) leaf[1]).intValue());
+    }
+
+    /// A renderer that colours one row is shared by all of them: the next
+    /// row has its own colour again, as it does in the JDK.
+    @Test
+    public void aRowColouredByASubclassDoesNotColourTheNext() {
+        JTree t = new JTree(model);
+        com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer r =
+                new com.codename1.desktopcompat.javax.swing.tree.DefaultTreeCellRenderer() {
+            @Override
+            public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded,
+                                                          boolean leaf, int row, boolean hasFocus) {
+                super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
+                if (row == 1) {
+                    setForeground(com.codename1.desktopcompat.java.awt.Color.RED);
+                }
+                return this;
+            }
+        };
+        com.codename1.desktopcompat.java.awt.Color plain =
+                r.getTreeCellRendererComponent(t, a, false, false, false, 0, false).getForeground();
+        assertEquals(com.codename1.desktopcompat.java.awt.Color.RED,
+                r.getTreeCellRendererComponent(t, a, false, false, false, 1, false).getForeground());
+        assertEquals(plain, r.getTreeCellRendererComponent(t, b, false, false, false, 2, false).getForeground());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ListWrapOrientationTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ListWrapOrientationTest.java
new file mode 100644
index 00000000000..fc1f86e2090
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ListWrapOrientationTest.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import java.util.List;
+import org.junit.Test;
+
+/// The wrapping layout orientations of a list are a grid, the desktop's.
+public class ListWrapOrientationTest extends KernelTestBase {
+
+    private static String[] items(int n) {
+        String[] all = new String[n];
+        for (int i = 0; i < n; i++) {
+            all[i] = "item" + i;
+        }
+        return all;
+    }
+
+    private static String r(Rectangle b) {
+        return b == null ? "null" : b.x + "," + b.y + " " + b.width + "x" + b.height;
+    }
+
+    private static String r(java.awt.Rectangle b) {
+        return b == null ? "null" : b.x + "," + b.y + " " + b.width + "x" + b.height;
+    }
+
+    /// Cell bounds, hit testing and sizes against the JDK's own list, for
+    /// both orientations, with the row count fixed and left to the size.
+    @Test
+    public void theGridIsTheDesktopOne() {
+        int[] orientations = {JList.HORIZONTAL_WRAP, JList.VERTICAL_WRAP};
+        int[] rowCounts = {3, 4, 0, -1, 8};
+        int[] sizes = {10, 7, 1, 12};
+        for (int o = 0; o < orientations.length; o++) {
+            for (int v = 0; v < rowCounts.length; v++) {
+                for (int z = 0; z < sizes.length; z++) {
+                    String what = "orientation " + orientations[o] + " rows " + rowCounts[v] + " n " + sizes[z];
+                    JList<String> ours = new JList<String>(items(sizes[z]));
+                    javax.swing.JList<String> real = new javax.swing.JList<String>(items(sizes[z]));
+                    ours.setFixedCellWidth(50);
+                    ours.setFixedCellHeight(20);
+                    real.setFixedCellWidth(50);
+                    real.setFixedCellHeight(20);
+                    ours.setLayoutOrientation(orientations[o]);
+                    real.setLayoutOrientation(orientations[o]);
+                    ours.setVisibleRowCount(rowCounts[v]);
+                    real.setVisibleRowCount(rowCounts[v]);
+                    ours.setSize(170, 90);
+                    real.setSize(170, 90);
+                    assertEquals(what, real.getPreferredSize().width, ours.getPreferredSize().width);
+                    assertEquals(what, real.getPreferredSize().height, ours.getPreferredSize().height);
+                    for (int i = 0; i < sizes[z]; i++) {
+                        assertEquals(what + " cell " + i, r(real.getCellBounds(i, i)), r(ours.getCellBounds(i, i)));
+                    }
+                    for (int x = 5; x < 300; x += 35) {
+                        for (int y = 5; y < 200; y += 15) {
+                            assertEquals(what + " at " + x + "," + y, real.locationToIndex(new java.awt.Point(x, y)),
+                                    ours.locationToIndex(new Point(x, y)));
+                        }
+                    }
+                    assertEquals(what, real.getScrollableTracksViewportWidth(),
+                            ours.getScrollableTracksViewportWidth());
+                    assertEquals(what, real.getScrollableTracksViewportHeight(),
+                            ours.getScrollableTracksViewportHeight());
+                }
+            }
+        }
+    }
+
+    @Test
+    public void theCellsAreDrawnSideBySide() {
+        JList<String> list = new JList<String>(items(6));
+        list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
+        list.setVisibleRowCount(2);
+        JFrame f = new JFrame();
+        f.add(list, BorderLayout.CENTER);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        List<Object[]> text = paint(f);
+        int[] x = new int[6];
+        int[] y = new int[6];
+        for (int i = 0; i < 6; i++) {
+            Object[] at = find(text, "item" + i);
+            assertNotNull("item" + i, at);
+            x[i] = ((Integer) at[1]).intValue();
+            y[i] = ((Integer) at[2]).intValue();
+        }
+        // Three columns of two rows, filled row by row.
+        assertTrue(x[0] < x[1] && x[1] < x[2]);
+        assertEquals(y[0], y[1]);
+        assertEquals(y[0], y[2]);
+        assertEquals(x[0], x[3]);
+        assertEquals(x[2], x[5]);
+        assertTrue(y[3] > y[0]);
+
+        // The same cells column by column.
+        list.setLayoutOrientation(JList.VERTICAL_WRAP);
+        f.validate();
+        text = paint(f);
+        int x0 = ((Integer) find(text, "item0")[1]).intValue();
+        int y0 = ((Integer) find(text, "item0")[2]).intValue();
+        assertEquals(x0, ((Integer) find(text, "item1")[1]).intValue());
+        assertTrue(((Integer) find(text, "item1")[2]).intValue() > y0);
+        assertTrue(((Integer) find(text, "item2")[1]).intValue() > x0);
+        assertEquals(y0, ((Integer) find(text, "item2")[2]).intValue());
+    }
+
+    @Test
+    public void aClickSelectsTheCellUnderIt() {
+        JList<String> list = new JList<String>(items(9));
+        list.setFixedCellWidth(60);
+        list.setFixedCellHeight(24);
+        list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
+        list.setVisibleRowCount(3);
+        JFrame f = new JFrame();
+        f.add(list, BorderLayout.CENTER);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        // Row 1, column 2 of a grid three wide.
+        press(f, list, 2 * 60 + 10, 24 + 5);
+        release(f, list, 2 * 60 + 10, 24 + 5);
+        assertEquals(5, list.getSelectedIndex());
+    }
+
+    @Test
+    public void theArrowKeysMoveThroughTheGrid() {
+        JList<String> list = new JList<String>(items(9));
+        list.setFixedCellWidth(60);
+        list.setFixedCellHeight(24);
+        list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
+        list.setVisibleRowCount(3);
+        list.setSelectedIndex(4);
+        list.getActionMap().get("selectNextColumn").actionPerformed(null);
+        assertEquals(5, list.getSelectedIndex());
+        list.getActionMap().get("selectNextRow").actionPerformed(null);
+        assertEquals(8, list.getSelectedIndex());
+        list.getActionMap().get("selectNextRow").actionPerformed(null);
+        assertEquals("no row below", 8, list.getSelectedIndex());
+        list.getActionMap().get("selectPreviousColumn").actionPerformed(null);
+        assertEquals(7, list.getSelectedIndex());
+        list.getActionMap().get("selectPreviousRow").actionPerformed(null);
+        assertEquals(4, list.getSelectedIndex());
+
+        list.setLayoutOrientation(JList.VERTICAL_WRAP);
+        list.setSelectedIndex(4);
+        list.getActionMap().get("selectNextColumn").actionPerformed(null);
+        assertEquals(7, list.getSelectedIndex());
+        list.getActionMap().get("selectNextRow").actionPerformed(null);
+        assertEquals(8, list.getSelectedIndex());
+
+        // One column has no columns to step to.
+        list.setLayoutOrientation(JList.VERTICAL);
+        list.setSelectedIndex(4);
+        list.getActionMap().get("selectNextColumn").actionPerformed(null);
+        assertEquals(4, list.getSelectedIndex());
+        list.getActionMap().get("selectNextRow").actionPerformed(null);
+        assertEquals(5, list.getSelectedIndex());
+    }
+
+    @Test
+    public void aGridSizedByItsWidthScrollsDownOnly() {
+        JList<String> list = new JList<String>(items(400));
+        list.setFixedCellWidth(60);
+        list.setFixedCellHeight(24);
+        list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
+        list.setVisibleRowCount(0);
+        JScrollPane pane = new JScrollPane(list);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        f.validate();
+        int extent = pane.getViewport().getExtentSize().width;
+        assertEquals(extent, list.getWidth());
+        int cols = extent / 60;
+        assertTrue(cols > 1);
+        int rows = (400 + cols - 1) / cols;
+        assertEquals(rows * 24, list.getPreferredSize().height);
+        assertEquals(rows * 24, list.getHeight());
+        assertFalse(list.getScrollableTracksViewportHeight());
+        assertEquals(new Rectangle(60, 24, 60, 24), list.getCellBounds(cols + 1, cols + 1));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/LookAndFeelSwitchTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/LookAndFeelSwitchTest.java
new file mode 100644
index 00000000000..1536e88a618
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/LookAndFeelSwitchTest.java
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatDarculaLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatDarkLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatIntelliJLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatLightLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.extras.FlatAnimatedLafChange;
+import com.codename1.desktopcompat.com.formdev.flatlaf.themes.FlatMacDarkLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.themes.FlatMacLightLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.util.UIScale;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.GridLayout;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.plaf.metal.MetalLookAndFeel;
+import com.codename1.desktopcompat.rt.LafTheme;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.After;
+import org.junit.Test;
+
+/// A look and feel selects the light or the dark palette, the widgets are
+/// painted in it at once, and the defaults answer from it.
+public class LookAndFeelSwitchTest extends KernelTestBase {
+
+    /// The keys a real application was found to read, and FlatLaf's own.
+    private static final String[] COLORS = {"Label.disabledForeground", "Separator.foreground", "Panel.background",
+        "Label.foreground", "Tree.selectionBackground", "Tree.foreground", "Panel.foreground", "controlShadow",
+        "Tree.selectionForeground", "TextField.inactiveBackground", "TextArea.foreground", "TextArea.background",
+        "Table.background", "Component.linkColor", "Component.accentColor", "Button.foreground", "Button.background",
+        "Component.borderColor", "Component.focusColor", "Actions.Red", "Actions.Green", "Actions.Yellow",
+        "Actions.Blue", "Actions.Grey", "Table.gridColor", "Component.error.focusedBorderColor",
+        "Button.hoverBackground", "List.selectionBackground", "TextField.placeholderForeground", "controlDkShadow",
+        "controlHighlight", "ProgressBar.foreground", "ToolTip.background", "TabbedPane.underlineColor"};
+
+    @After
+    public void forget() throws Exception {
+        UIManager.put("Mine.kept", null);
+        UIManager.put("Panel.background", null);
+        FlatLaf.setGlobalExtraDefaults(null);
+        UIManager.setLookAndFeel((LookAndFeel) null);
+        HeadlessImplementation.darkMode = false;
+        LafTheme.reset();
+    }
+
+    private static int light(Color c) {
+        return (c.getRed() * 299 + c.getGreen() * 587 + c.getBlue() * 114) / 1000;
+    }
+
+    private static int light(int rgb) {
+        return light(new Color(rgb));
+    }
+
+    @Test
+    public void aDarkLookAndFeelTurnsTheWidgetsDarkAndALightOneBack() {
+        JButton button = new JButton("Go");
+        JTable table = new JTable(new Object[][]{{"a", "b"}, {"c", "d"}}, new Object[]{"One", "Two"});
+        JTree tree = new JTree();
+        JTextArea area = new JTextArea("text");
+        JList<String> list = new JList<String>(new String[]{"x", "y"});
+        JTextField field = new JTextField("f");
+        JLabel label = new JLabel("label");
+        JPanel grid = new JPanel(new GridLayout(2, 2));
+        JScrollPane tablePane = new JScrollPane(table);
+        grid.add(tablePane);
+        grid.add(new JScrollPane(tree));
+        grid.add(new JScrollPane(area));
+        grid.add(new JScrollPane(list));
+        JFrame f = new JFrame();
+        f.add(grid, BorderLayout.CENTER);
+        f.add(button, BorderLayout.SOUTH);
+        f.add(field, BorderLayout.NORTH);
+        f.add(label, BorderLayout.WEST);
+        f.setSize(400, 300);
+        show(f);
+
+        assertTrue(FlatLightLaf.setup());
+        assertFalse(FlatLaf.isLafDark());
+        int[][] rows = raster(f);
+        Component[] dark = {button, table.getTableHeader(), tree, area, list, field, label, table};
+        int[] lightBefore = new int[dark.length];
+        for (int i = 0; i < dark.length; i++) {
+            lightBefore[i] = light(pixel(rows, dark[i], dark[i].getWidth() - 4, dark[i].getHeight() - 4));
+            assertTrue(dark[i].getClass().getName() + " is light in the light palette: " + lightBefore[i],
+                    lightBefore[i] >= 128);
+        }
+        assertTrue(light(UIManager.getColor("Panel.background")) >= 128);
+
+        assertTrue(FlatDarkLaf.setup());
+        assertTrue(FlatLaf.isLafDark());
+        assertTrue(UIManager.getBoolean("laf.dark"));
+        assertTrue(light(UIManager.getColor("Panel.background")) < 128);
+        assertTrue(light(UIManager.getColor("Label.foreground")) >= 128);
+        rows = raster(f);
+        for (int i = 0; i < dark.length; i++) {
+            int now = light(pixel(rows, dark[i], dark[i].getWidth() - 4, dark[i].getHeight() - 4));
+            assertTrue(dark[i].getClass().getName() + " is dark in the dark palette: " + now, now < 128);
+        }
+        assertTrue("the label's text is light", light(label.getForeground()) >= 128);
+        assertTrue("the table's text is light", light(table.getForeground()) >= 128);
+
+        assertTrue(FlatMacLightLaf.setup());
+        rows = raster(f);
+        for (int i = 0; i < dark.length; i++) {
+            int now = light(pixel(rows, dark[i], dark[i].getWidth() - 4, dark[i].getHeight() - 4));
+            assertTrue(dark[i].getClass().getName() + " is light again: " + now, now >= 128);
+        }
+        assertFalse(UIManager.getBoolean("laf.dark"));
+    }
+
+    /// A switch takes every widget's style from the theme again, so what
+    /// the application set on a component has to be given back to it.
+    @Test
+    public void whatWasSetOnAComponentOutlastsASwitch() {
+        assertTrue(FlatLightLaf.setup());
+        JLabel title = new JLabel("Title");
+        title.setFont(title.getFont().deriveFont(31f));
+        title.setForeground(new Color(0x12, 0x34, 0x56));
+        JToolBar bar = new JToolBar();
+        JButton inBar = new JButton("In bar");
+        bar.add(inBar);
+        JFrame f = new JFrame();
+        f.add(bar, BorderLayout.NORTH);
+        f.add(title, BorderLayout.CENTER);
+        f.setSize(400, 300);
+        show(f);
+        com.codename1.ui.Component titlePeer = title.cn1Peer();
+        com.codename1.ui.Component barPeer = inBar.cn1Peer();
+        int size = titlePeer.getUnselectedStyle().getFont().getHeight();
+        assertTrue("a tool bar button has no border",
+                barPeer.getUnselectedStyle().getBorder().isEmptyBorder());
+
+        assertTrue(FlatDarkLaf.setup());
+        assertEquals(size, titlePeer.getUnselectedStyle().getFont().getHeight());
+        assertEquals(0x123456, titlePeer.getUnselectedStyle().getFgColor() & 0xffffff);
+        assertTrue("a tool bar button still has no border",
+                barPeer.getUnselectedStyle().getBorder().isEmptyBorder());
+        assertNull("the button's margin is its own again", inBar.getMargin());
+
+        assertTrue(FlatLightLaf.setup());
+        assertEquals(size, titlePeer.getUnselectedStyle().getFont().getHeight());
+        assertTrue(barPeer.getUnselectedStyle().getBorder().isEmptyBorder());
+    }
+
+    @Test
+    public void everyNameIsAcceptedAndSaysWhichPalette() throws Exception {
+        UIManager.setLookAndFeel("com.formdev.flatlaf.FlatDarkLaf");
+        assertTrue(UIManager.getLookAndFeel() instanceof FlatDarkLaf);
+        assertTrue(LafTheme.isDark());
+        UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
+        assertTrue(UIManager.getLookAndFeel() instanceof MetalLookAndFeel);
+        assertFalse(LafTheme.isDark());
+        UIManager.setLookAndFeel("com.example.themes.DraculaLookAndFeel");
+        assertTrue(LafTheme.isDark());
+        assertEquals("Dracula", UIManager.getLookAndFeel().getName());
+        assertTrue(UIManager.getLookAndFeel().isSupportedLookAndFeel());
+        // A name that says nothing keeps the palette.
+        UIManager.setLookAndFeel("com.example.NoSuchLookAndFeel");
+        assertTrue(LafTheme.isDark());
+        assertEquals("NoSuch", UIManager.getLookAndFeel().getName());
+        String[] lights = {"javax.swing.plaf.nimbus.NimbusLookAndFeel",
+            "com.sun.java.swing.plaf.windows.WindowsLookAndFeel", "com.apple.laf.AquaLookAndFeel",
+            "com.sun.java.swing.plaf.gtk.GTKLookAndFeel", "com.sun.java.swing.plaf.motif.MotifLookAndFeel"};
+        for (int i = 0; i < lights.length; i++) {
+            UIManager.setLookAndFeel("com.formdev.flatlaf.themes.FlatMacDarkLaf");
+            assertTrue(UIManager.getLookAndFeel() instanceof FlatMacDarkLaf);
+            assertTrue(LafTheme.isDark());
+            UIManager.setLookAndFeel(lights[i]);
+            assertFalse(lights[i], LafTheme.isDark());
+        }
+        UIManager.setLookAndFeel(new FlatDarculaLaf());
+        assertTrue(LafTheme.isDark());
+        assertEquals("FlatLaf - FlatLaf Darcula", UIManager.getLookAndFeel().getID());
+        UIManager.setLookAndFeel(new FlatIntelliJLaf());
+        assertFalse(LafTheme.isDark());
+        // The built-in look follows the platform.
+        HeadlessImplementation.darkMode = true;
+        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        assertTrue(LafTheme.isDark());
+        assertEquals("Codename One", UIManager.getLookAndFeel().getName());
+        HeadlessImplementation.darkMode = false;
+        UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
+        assertFalse(LafTheme.isDark());
+    }
+
+    /// A look of the application's own that says it is dark the FlatLaf
+    /// way, and has defaults.
+    private static final class Mine extends FlatLaf {
+        boolean initialized;
+        boolean uninitialized;
+
+        @Override
+        public String getName() {
+            return "Mine";
+        }
+
+        @Override
+        public String getDescription() {
+            return "Mine";
+        }
+
+        @Override
+        public boolean isDark() {
+            return true;
+        }
+
+        @Override
+        public void initialize() {
+            initialized = true;
+        }
+
+        @Override
+        public void uninitialize() {
+            uninitialized = true;
+        }
+
+        @Override
+        public UIDefaults getDefaults() {
+            UIDefaults d = super.getDefaults();
+            d.put("Mine.own", Color.MAGENTA);
+            return d;
+        }
+    }
+
+    @Test
+    public void developerDefaultsStayAndLookAndFeelDefaultsGo() throws Exception {
+        final List<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
+        PropertyChangeListener l = new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                events.add(e);
+            }
+        };
+        UIManager.addPropertyChangeListener(l);
+        try {
+            UIManager.put("Mine.kept", Color.ORANGE);
+            UIManager.getLookAndFeelDefaults().put("Mine.gone", Color.PINK);
+            assertSame(Color.PINK, UIManager.getColor("Mine.gone"));
+            Mine mine = new Mine();
+            UIManager.setLookAndFeel(mine);
+            assertTrue(mine.initialized);
+            assertSame(mine, UIManager.getLookAndFeel());
+            assertEquals(1, events.size());
+            assertEquals("lookAndFeel", events.get(0).getPropertyName());
+            assertSame(mine, events.get(0).getNewValue());
+            assertTrue(LafTheme.isDark());
+            assertSame(Color.ORANGE, UIManager.getColor("Mine.kept"));
+            assertNull(UIManager.getColor("Mine.gone"));
+            assertSame(Color.MAGENTA, UIManager.getColor("Mine.own"));
+            assertSame(Color.MAGENTA, UIManager.getLookAndFeelDefaults().get("Mine.own"));
+            // What the developer put wins over the look and feel.
+            UIManager.put("Panel.background", Color.RED);
+            assertSame(Color.RED, UIManager.getColor("Panel.background"));
+            FlatLightLaf.setup();
+            assertTrue(mine.uninitialized);
+            assertNull(UIManager.getColor("Mine.own"));
+            assertSame(Color.RED, UIManager.getColor("Panel.background"));
+            assertEquals(2, events.size());
+            assertEquals(1, UIManager.getPropertyChangeListeners().length);
+        } finally {
+            UIManager.removePropertyChangeListener(l);
+        }
+    }
+
+    @Test
+    public void theKeysApplicationsReadAnswerInBothPalettes() {
+        FlatLightLaf.setup();
+        Color[] light = new Color[COLORS.length];
+        for (int i = 0; i < COLORS.length; i++) {
+            light[i] = UIManager.getColor(COLORS[i]);
+            assertNotNull(COLORS[i] + " in the light palette", light[i]);
+        }
+        assertTrue(light(UIManager.getColor("Label.disabledForeground")) > light(UIManager.getColor("Label.foreground")));
+        assertNotNull(UIManager.getFont("defaultFont"));
+        assertNotNull(UIManager.getFont("Label.font"));
+        assertTrue(UIManager.getFont("h1.font").getSize() > UIManager.getFont("defaultFont").getSize());
+        assertTrue(UIManager.getFont("small.font").getSize() < UIManager.getFont("defaultFont").getSize());
+        assertNotNull(UIManager.getBorder("TextField.border"));
+        assertNotNull(UIManager.getBorder("ScrollPane.border"));
+        assertNotNull(UIManager.getInsets("Button.margin"));
+        assertTrue(UIManager.getInt("Component.arc") > 0);
+        FlatDarkLaf.setup();
+        int changed = 0;
+        for (int i = 0; i < COLORS.length; i++) {
+            Color c = UIManager.getColor(COLORS[i]);
+            assertNotNull(COLORS[i] + " in the dark palette", c);
+            if (!c.equals(light[i])) {
+                changed++;
+            }
+        }
+        assertTrue("most colors differ between the palettes: " + changed, changed > COLORS.length * 2 / 3);
+        assertTrue(light(UIManager.getColor("Label.disabledForeground")) < light(UIManager.getColor("Label.foreground")));
+        assertTrue(light(UIManager.getColor("TextArea.background")) < 128);
+        assertTrue(light(UIManager.getColor("Button.background")) < 128);
+        assertTrue(light(UIManager.getColor("Button.foreground")) >= 128);
+    }
+
+    @Test
+    public void extraDefaultsAreReadWhenTheyArePlain() {
+        Map<String, String> extra = new HashMap<String, String>();
+        extra.put("@accentColor", "#ff0080");
+        extra.put("Mine.color", "#123");
+        extra.put("Mine.count", "12");
+        extra.put("Mine.flag", "true");
+        extra.put("Mine.insets", "1,2,3,4");
+        extra.put("Mine.expression", "lighten(@background,5%)");
+        FlatLaf.setGlobalExtraDefaults(extra);
+        FlatLightLaf.setup();
+        assertEquals(new Color(0xff, 0x00, 0x80), UIManager.getColor("Component.accentColor"));
+        assertEquals(new Color(0x11, 0x22, 0x33), UIManager.getColor("Mine.color"));
+        assertEquals(12, UIManager.getInt("Mine.count"));
+        assertTrue(UIManager.getBoolean("Mine.flag"));
+        assertEquals(3, UIManager.getInsets("Mine.insets").bottom);
+        assertNull(UIManager.get("Mine.expression"));
+        FlatLaf.setGlobalExtraDefaults(null);
+        FlatLightLaf.setup();
+        assertNull(UIManager.get("Mine.color"));
+        assertFalse(new Color(0xff, 0x00, 0x80).equals(UIManager.getColor("Component.accentColor")));
+    }
+
+    @Test
+    public void theSmallApisAnswer() {
+        assertEquals(7, UIScale.scale(7));
+        assertEquals(7, UIScale.unscale(7));
+        assertEquals(1f, UIScale.getUserScaleFactor(), 0f);
+        assertEquals(new Dimension(3, 4), UIScale.scale(new Dimension(3, 4)));
+        FlatAnimatedLafChange.showSnapshot();
+        FlatDarkLaf.setup();
+        FlatLaf.updateUI();
+        FlatAnimatedLafChange.hideSnapshotWithAnimation();
+        assertTrue(LafTheme.isDark());
+        assertFalse(FlatLaf.supportsNativeWindowDecorations());
+        int before = UIManager.getInstalledLookAndFeels().length;
+        FlatDarkLaf.installLafInfo();
+        UIManager.LookAndFeelInfo[] infos = UIManager.getInstalledLookAndFeels();
+        assertEquals(before + 1, infos.length);
+        assertEquals(FlatDarkLaf.NAME, infos[before].getName());
+        UIManager.setLookAndFeel(infos[before].getClassName());
+        assertTrue(UIManager.getLookAndFeel() instanceof FlatDarkLaf);
+        UIManager.LookAndFeelInfo[] one = new UIManager.LookAndFeelInfo[before];
+        System.arraycopy(infos, 0, one, 0, before);
+        UIManager.setInstalledLookAndFeels(one);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/RangeWidgetsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/RangeWidgetsTest.java
new file mode 100644
index 00000000000..35227f3a860
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/RangeWidgetsTest.java
@@ -0,0 +1,496 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.rt.ProgressPeer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The slider, the progress bar and the separator: their models against
+/// the JDK's, and the Codename One widgets behind them.
+public class RangeWidgetsTest extends KernelTestBase {
+
+    /// Records each change as `value/adjusting`.
+    private static final class Changes implements ChangeListener {
+        final List<String> log = new ArrayList<String>();
+        Object source;
+
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            source = e.getSource();
+            if (source instanceof JSlider) {
+                JSlider s = (JSlider) source;
+                log.add(s.getValue() + "/" + s.getValueIsAdjusting());
+            } else if (source instanceof JProgressBar) {
+                log.add(String.valueOf(((JProgressBar) source).getValue()));
+            }
+        }
+    }
+
+    private static String state(JSlider s) {
+        return s.getValue() + " " + s.getExtent() + " " + s.getMinimum() + " " + s.getMaximum() + " "
+                + s.getValueIsAdjusting();
+    }
+
+    private static String state(javax.swing.JSlider s) {
+        return s.getValue() + " " + s.getExtent() + " " + s.getMinimum() + " " + s.getMaximum() + " "
+                + s.getValueIsAdjusting();
+    }
+
+    @Test
+    public void theSliderClampsAndNotifiesAsTheJdkDoes() {
+        final int[] ours = {0};
+        final int[] theirs = {0};
+        JSlider a = new JSlider(10, 110, 60);
+        javax.swing.JSlider b = new javax.swing.JSlider(10, 110, 60);
+        a.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                ours[0]++;
+            }
+        });
+        b.addChangeListener(new javax.swing.event.ChangeListener() {
+            @Override
+            public void stateChanged(javax.swing.event.ChangeEvent e) {
+                theirs[0]++;
+            }
+        });
+        int[][] ops = {{0, 150}, {0, -5}, {0, 60}, {0, 60}, {3, 30}, {0, 100}, {1, 70}, {2, 75}, {4, 1}, {4, 1},
+            {2, 40}, {1, 200}, {3, -3}, {4, 0}, {0, 0}, {1, -50}, {2, 500}, {3, 400}, {0, 499}, {3, 1000}};
+        for (int i = 0; i < ops.length; i++) {
+            int v = ops[i][1];
+            switch (ops[i][0]) {
+                case 0:
+                    a.setValue(v);
+                    b.setValue(v);
+                    break;
+                case 1:
+                    a.setMinimum(v);
+                    b.setMinimum(v);
+                    break;
+                case 2:
+                    a.setMaximum(v);
+                    b.setMaximum(v);
+                    break;
+                case 3:
+                    a.setExtent(v);
+                    b.setExtent(v);
+                    break;
+                default:
+                    a.setValueIsAdjusting(v != 0);
+                    b.setValueIsAdjusting(v != 0);
+                    break;
+            }
+            assertEquals("after op " + i, state(b), state(a));
+            assertEquals("events after op " + i, theirs[0], ours[0]);
+        }
+    }
+
+    @Test
+    public void theSliderConstructorsMatchTheJdk() {
+        assertEquals(state(new javax.swing.JSlider()), state(new JSlider()));
+        assertEquals(state(new javax.swing.JSlider(3, 40)), state(new JSlider(3, 40)));
+        assertEquals(state(new javax.swing.JSlider(javax.swing.JSlider.VERTICAL, -5, 5, 2)),
+                state(new JSlider(JSlider.VERTICAL, -5, 5, 2)));
+        assertEquals(JSlider.VERTICAL, new JSlider(JSlider.VERTICAL).getOrientation());
+        try {
+            new JSlider(7);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            new JSlider(0, 10, 11);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+    }
+
+    @Test
+    public void standardLabelsHaveTheJdkKeysAndTexts() {
+        JSlider a = new JSlider(10, 110, 60);
+        javax.swing.JSlider b = new javax.swing.JSlider(10, 110, 60);
+        compareLabels(b.createStandardLabels(25), a.createStandardLabels(25));
+        compareLabels(b.createStandardLabels(40, 20), a.createStandardLabels(40, 20));
+        try {
+            a.createStandardLabels(0);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        try {
+            a.createStandardLabels(5, 111);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertNotNull(expected.getMessage());
+        }
+        // Asking for labels with a major spacing makes the table, as the
+        // desktop does.
+        assertNull(a.getLabelTable());
+        a.setMajorTickSpacing(50);
+        assertNull(a.getLabelTable());
+        a.setPaintLabels(true);
+        assertEquals(3, a.getLabelTable().size());
+    }
+
+    private static void compareLabels(Hashtable<?, ?> theirs, Hashtable<?, ?> ours) {
+        List<Integer> a = new ArrayList<Integer>();
+        List<Integer> b = new ArrayList<Integer>();
+        for (Enumeration<?> e = theirs.keys(); e.hasMoreElements();) {
+            b.add((Integer) e.nextElement());
+        }
+        for (Enumeration<?> e = ours.keys(); e.hasMoreElements();) {
+            a.add((Integer) e.nextElement());
+        }
+        Collections.sort(a);
+        Collections.sort(b);
+        assertEquals(b, a);
+        for (Integer k : a) {
+            assertEquals(((javax.swing.JLabel) theirs.get(k)).getText(), ((JLabel) ours.get(k)).getText());
+        }
+    }
+
+    @Test
+    public void draggingTheSliderDrivesTheModelWithoutEchoes() {
+        JSlider s = new JSlider(10, 110, 10);
+        Changes changes = new Changes();
+        s.addChangeListener(changes);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        int w = s.getWidth();
+        assertTrue(w > 100);
+
+        press(f, s, w / 2, 3);
+        assertEquals(1, changes.log.size());
+        assertSame(s, changes.source);
+        assertTrue(s.getValueIsAdjusting());
+        assertTrue("value " + s.getValue(), Math.abs(s.getValue() - 60) <= 1);
+
+        drag(f, s, w / 4, 3);
+        assertEquals(2, changes.log.size());
+        assertTrue(s.getValueIsAdjusting());
+        assertTrue("value " + s.getValue(), Math.abs(s.getValue() - 35) <= 1);
+        int dragged = s.getValue();
+
+        release(f, s, w / 4, 3);
+        assertEquals(3, changes.log.size());
+        assertFalse(s.getValueIsAdjusting());
+        assertEquals(dragged, s.getValue());
+        assertEquals(dragged + "/false", changes.log.get(2));
+
+        // A value set by the program moves the thumb and is one event,
+        // not a second one echoed back by the widget.
+        s.setValue(30);
+        assertEquals(4, changes.log.size());
+        assertEquals("30/false", changes.log.get(3));
+        s.setValue(30);
+        assertEquals(4, changes.log.size());
+        s.setMaximum(50);
+        assertEquals(30, s.getValue());
+
+        // A disabled slider does not move.
+        s.setEnabled(false);
+        press(f, s, w - 2, 3);
+        release(f, s, w - 2, 3);
+        assertEquals(30, s.getValue());
+        // The one more event is the changed maximum.
+        assertEquals(5, changes.log.size());
+    }
+
+    /// The thumb and the track are painted by the slider, in colors that
+    /// stand out from its background: a horizontal thumb that could not be
+    /// seen and a vertical slider without a track were what a Codename One
+    /// slider made of them.
+    @Test
+    public void theThumbAndTheTrackAreVisibleBothWays() {
+        Color accent = new Color(0x1166cc);
+        Color rail = new Color(0x99aabb);
+        UIManager.put("Slider.foreground", accent);
+        UIManager.put("Slider.trackColor", rail);
+        try {
+            JSlider h = new JSlider(0, 100, 25);
+            JSlider v = new JSlider(JSlider.VERTICAL, 0, 100, 75);
+            JPanel p = new JPanel(null);
+            h.setBounds(10, 10, 216, 20);
+            v.setBounds(10, 50, 20, 216);
+            p.add(h);
+            p.add(v);
+            JFrame f = new JFrame();
+            f.setContentPane(p);
+            show(f);
+            int[][] px = raster(f);
+            // The thumb's centre runs from 8 to 208: a quarter is at 58.
+            assertEquals(0x1166cc, pixel(px, h, 58, 10));
+            assertEquals(0x1166cc, pixel(px, h, 58, 4));
+            assertEquals("filled up to the thumb", 0x1166cc, pixel(px, h, 30, 10));
+            assertEquals("the rest of the track", 0x99aabb, pixel(px, h, 150, 10));
+            assertTrue(pixel(px, h, 150, 3) != 0x99aabb);
+            // Vertical: the maximum is at the top, so 75 is a quarter down.
+            assertEquals(0x1166cc, pixel(px, v, 10, 58));
+            assertEquals("the track above the thumb", 0x99aabb, pixel(px, v, 10, 30));
+            assertEquals("filled below it", 0x1166cc, pixel(px, v, 10, 150));
+
+            v.setValue(0);
+            h.setInverted(true);
+            px = raster(f);
+            assertEquals(0x1166cc, pixel(px, v, 10, 208));
+            assertEquals(0x99aabb, pixel(px, v, 10, 58));
+            assertEquals(0x1166cc, pixel(px, h, 158, 10));
+            assertEquals("inverted fills from the right", 0x1166cc, pixel(px, h, 190, 10));
+            assertEquals(0x99aabb, pixel(px, h, 58, 10));
+
+            h.setPaintTrack(false);
+            px = raster(f);
+            assertEquals(0, count(px, h, 0, 0, 216, 20, 0x99aabb));
+            assertEquals(0x1166cc, pixel(px, h, 158, 10));
+        } finally {
+            UIManager.put("Slider.foreground", null);
+            UIManager.put("Slider.trackColor", null);
+        }
+    }
+
+    @Test
+    public void theKeyboardMovesAFocusedSlider() {
+        JSlider s = new JSlider(0, 100, 50);
+        s.setMajorTickSpacing(20);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        key(s, KeyEvent.VK_RIGHT);
+        assertEquals(51, s.getValue());
+        key(s, KeyEvent.VK_DOWN);
+        assertEquals(50, s.getValue());
+        key(s, KeyEvent.VK_PAGE_UP);
+        assertEquals(70, s.getValue());
+        key(s, KeyEvent.VK_HOME);
+        assertEquals(0, s.getValue());
+        key(s, KeyEvent.VK_LEFT);
+        assertEquals(0, s.getValue());
+        key(s, KeyEvent.VK_END);
+        assertEquals(100, s.getValue());
+        s.setInverted(true);
+        key(s, KeyEvent.VK_RIGHT);
+        assertEquals(99, s.getValue());
+    }
+
+    private static void key(JSlider s, int code) {
+        s.dispatchEvent(new KeyEvent(s, KeyEvent.KEY_PRESSED, 0L, 0, code, KeyEvent.CHAR_UNDEFINED));
+    }
+
+    @Test
+    public void invertedVerticalAndSnappingReachTheWidget() {
+        JSlider s = new JSlider(0, 100, 25);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        s.setInverted(true);
+        int w = s.getWidth();
+        press(f, s, w / 10, 3);
+        release(f, s, w / 10, 3);
+        // A tenth of the way along, less the half thumb the track starts after.
+        assertTrue("value " + s.getValue(), Math.abs(s.getValue() - 91) <= 1);
+        s.setInverted(false);
+
+        s.setMajorTickSpacing(25);
+        s.setSnapToTicks(true);
+        press(f, s, w * 4 / 10, 3);
+        assertEquals(50, s.getValue());
+        drag(f, s, w * 3 / 10, 3);
+        assertEquals(25, s.getValue());
+        release(f, s, w * 3 / 10, 3);
+        assertEquals(25, s.getValue());
+        assertFalse(s.getValueIsAdjusting());
+
+        s.setOrientation(JSlider.VERTICAL);
+        assertEquals(200, s.getPreferredSize().height);
+        assertEquals(s.getPreferredSize().width, s.getMinimumSize().width);
+    }
+
+    @Test
+    public void ticksAndLabelsAddRoomAndTheLabelsArePainted() {
+        JSlider s = new JSlider(0, 100, 50);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        Dimension plain = s.getPreferredSize();
+        assertEquals(200, plain.width);
+        assertTrue(plain.height > 0);
+        assertNull(find(paint(f), "50"));
+        s.setPaintTicks(true);
+        s.setMinorTickSpacing(5);
+        assertEquals(plain.height + 8, s.getPreferredSize().height);
+        s.setMajorTickSpacing(50);
+        s.setPaintLabels(true);
+        int withLabels = s.getPreferredSize().height;
+        assertTrue(withLabels > plain.height + 8);
+        f.validate();
+        assertEquals(withLabels, s.getHeight());
+        List<Object[]> text = paint(f);
+        Object[] zero = find(text, "0");
+        Object[] mid = find(text, "50");
+        Object[] end = find(text, "100");
+        assertNotNull(zero);
+        assertNotNull(mid);
+        assertNotNull(end);
+        int x0 = ((Integer) zero[1]).intValue();
+        int x1 = ((Integer) mid[1]).intValue();
+        int x2 = ((Integer) end[1]).intValue();
+        assertTrue(x0 < x1 && x1 < x2);
+        int below = onDisplay(s, 0, plain.height + 8)[1];
+        assertTrue("labels sit under the ticks", ((Integer) mid[2]).intValue() >= below);
+        s.setPaintLabels(false);
+        assertNull(find(paint(f), "50"));
+    }
+
+    @Test
+    public void theProgressBarFollowsItsModelAndTheJdk() {
+        JProgressBar a = new JProgressBar(0, 8);
+        javax.swing.JProgressBar b = new javax.swing.JProgressBar(0, 8);
+        Changes changes = new Changes();
+        a.addChangeListener(changes);
+        String[] expected = {"0%", "12%", "25%", "38%", "50%", "62%", "75%", "88%", "100%"};
+        for (int v = 0; v <= 8; v++) {
+            a.setValue(v);
+            b.setValue(v);
+            assertEquals(b.getPercentComplete(), a.getPercentComplete(), 0);
+            assertEquals(expected[v], a.getString());
+        }
+        assertEquals(8, changes.log.size());
+        assertSame(a, changes.source);
+        a.setValue(99);
+        b.setValue(99);
+        assertEquals(b.getValue(), a.getValue());
+        a.setMinimum(4);
+        b.setMinimum(4);
+        a.setValue(5);
+        b.setValue(5);
+        assertEquals(b.getPercentComplete(), a.getPercentComplete(), 0);
+        assertEquals("25%", a.getString());
+        a.setString("busy");
+        assertEquals("busy", a.getString());
+        a.setString(null);
+        assertEquals("25%", a.getString());
+        assertFalse(a.isStringPainted());
+        assertTrue(a.isBorderPainted());
+        assertFalse(a.isIndeterminate());
+        assertEquals(b.getOrientation(), a.getOrientation());
+        try {
+            a.setOrientation(9);
+            fail();
+        } catch (IllegalArgumentException e) {
+            assertEquals("9 is not a legal orientation", e.getMessage());
+        }
+        JProgressBar empty = new JProgressBar(5, 5);
+        assertEquals("0%", empty.getString());
+    }
+
+    @Test
+    public void theProgressStringIsPaintedCentredOverTheNativeBar() {
+        JProgressBar bar = new JProgressBar(0, 200);
+        bar.setValue(80);
+        JFrame f = new JFrame();
+        f.add(bar, BorderLayout.SOUTH);
+        show(f);
+        ProgressPeer peer = (ProgressPeer) bar.cn1Peer();
+        assertFalse(peer.isEditable());
+        assertEquals(200, peer.getMaxValue());
+        assertEquals(80, peer.getProgress());
+        assertEquals(146, bar.getPreferredSize().width);
+        assertNull(find(paint(f), "40%"));
+
+        bar.setStringPainted(true);
+        f.validate();
+        Object[] drawn = find(paint(f), "40%");
+        assertNotNull(drawn);
+        int x = ((Integer) drawn[1]).intValue();
+        int y = ((Integer) drawn[2]).intValue();
+        int left = peer.getAbsoluteX();
+        int width = peer.getWidth();
+        int textWidth = bar.getFontMetrics(bar.getFont() != null ? bar.getFont()
+                : com.codename1.desktopcompat.rt.Fonts.defaultFont()).stringWidth("40%") * 2;
+        assertTrue("x " + x, Math.abs((x - left) - (width - textWidth) / 2) <= 4);
+        assertTrue(y >= peer.getAbsoluteY() && y < peer.getAbsoluteY() + peer.getHeight());
+
+        bar.setString("loading");
+        assertNotNull(find(paint(f), "loading"));
+        bar.setValue(150);
+        assertEquals(150, peer.getProgress());
+
+        bar.setIndeterminate(true);
+        assertTrue(peer.isInfinite());
+        assertNotNull(find(paint(f), "loading"));
+        bar.setIndeterminate(false);
+        assertFalse(peer.isInfinite());
+        assertEquals(150, peer.getProgress());
+
+        // The user cannot move a progress bar.
+        press(f, bar, 5, 2);
+        release(f, bar, 5, 2);
+        assertEquals(150, bar.getValue());
+    }
+
+    @Test
+    public void theSeparatorIsTwoPixelsAcross() {
+        JSeparator h = new JSeparator();
+        JSeparator v = new JSeparator(JSeparator.VERTICAL);
+        assertEquals(JSeparator.HORIZONTAL, h.getOrientation());
+        assertEquals(new Dimension(0, 2), h.getPreferredSize());
+        assertEquals(new Dimension(2, 0), v.getPreferredSize());
+        h.setOrientation(JSeparator.VERTICAL);
+        assertEquals(new Dimension(2, 0), h.getPreferredSize());
+        try {
+            h.setOrientation(5);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(JSeparator.VERTICAL, h.getOrientation());
+        }
+        JFrame f = new JFrame();
+        f.add(new JSeparator(), BorderLayout.NORTH);
+        f.add(v, BorderLayout.WEST);
+        show(f);
+        paint(f);
+        assertEquals(2, v.getWidth());
+        assertTrue(v.getHeight() > 0);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollPaneBarsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollPaneBarsTest.java
new file mode 100644
index 00000000000..25d67cfb7c2
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollPaneBarsTest.java
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseWheelListener;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import com.codename1.ui.Display;
+import org.junit.After;
+import org.junit.Test;
+
+/// The scroll bars, corners and headers of a scroll pane, and what the
+/// mouse wheel does over one.
+public class ScrollPaneBarsTest extends KernelTestBase {
+
+    /// What is asserted here is the geometry of the pane's own layout, to
+    /// the pixel, so the line a pane has around it by default is taken
+    /// away, the way an application does.
+    @org.junit.Before
+    public void noPaneBorder() {
+        com.codename1.desktopcompat.javax.swing.UIManager.put("ScrollPane.border",
+                new com.codename1.desktopcompat.javax.swing.border.EmptyBorder(0, 0, 0, 0));
+    }
+
+    @org.junit.After
+    public void themePaneBorder() {
+        com.codename1.desktopcompat.javax.swing.UIManager.put("ScrollPane.border", null);
+    }
+
+    private static final int BAR = 14;
+
+    @After
+    public void deviceDecidesAgain() {
+        ScrollDelegate.setBarThickness(-1);
+    }
+
+    private static JPanel panel(int w, int h) {
+        JPanel p = new JPanel();
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+
+    private JFrame frame(JScrollPane pane) {
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        return f;
+    }
+
+    @Test
+    public void aTouchDeviceGivesTheBarsNoRoom() {
+        JScrollPane pane = new JScrollPane(panel(100, 2000));
+        frame(pane);
+        assertEquals(0, pane.getVerticalScrollBar().getWidth());
+        assertEquals(pane.getWidth(), pane.getViewport().getWidth());
+        assertSame(pane, pane.getVerticalScrollBar().getParent());
+    }
+
+    @Test
+    public void aDesktopShowsTheBarTheViewNeeds() {
+        ScrollDelegate.setBarThickness(BAR);
+        JScrollPane pane = new JScrollPane(panel(100, 2000));
+        frame(pane);
+        JScrollBar v = pane.getVerticalScrollBar();
+        JScrollBar h = pane.getHorizontalScrollBar();
+        assertEquals(new Rectangle(pane.getWidth() - BAR, 0, BAR, pane.getHeight()), v.getBounds());
+        assertEquals(0, h.getHeight());
+        assertEquals(pane.getWidth() - BAR, pane.getViewport().getWidth());
+        assertEquals(pane.getHeight(), pane.getViewport().getHeight());
+        assertEquals(2000, v.getMaximum());
+        assertEquals(pane.getHeight(), v.getVisibleAmount());
+    }
+
+    @Test
+    public void aViewThatFitsShowsNoBarUnlessThePolicyIsAlways() {
+        ScrollDelegate.setBarThickness(BAR);
+        JScrollPane pane = new JScrollPane(panel(50, 50));
+        frame(pane);
+        assertEquals(0, pane.getVerticalScrollBar().getWidth());
+        assertEquals(0, pane.getHorizontalScrollBar().getHeight());
+        pane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+        pane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
+        pane.validate();
+        assertEquals(BAR, pane.getVerticalScrollBar().getWidth());
+        assertEquals(BAR, pane.getHorizontalScrollBar().getHeight());
+        assertEquals(pane.getHeight() - BAR, pane.getVerticalScrollBar().getHeight());
+        assertEquals(pane.getWidth() - BAR, pane.getViewport().getWidth());
+        assertEquals(pane.getHeight() - BAR, pane.getViewport().getHeight());
+    }
+
+    @Test
+    public void oneBarCanMakeTheOtherNecessary() {
+        ScrollDelegate.setBarThickness(BAR);
+        JScrollPane pane = new JScrollPane();
+        JFrame f = frame(pane);
+        // As high as the pane: fits until the horizontal bar takes its room.
+        pane.setViewportView(panel(2000, pane.getHeight() - 4));
+        f.validate();
+        assertEquals(BAR, pane.getHorizontalScrollBar().getHeight());
+        assertEquals(BAR, pane.getVerticalScrollBar().getWidth());
+    }
+
+    @Test
+    public void aWrappedTextAreaGetsItsBarFromTheHeightItReallyHas() {
+        ScrollDelegate.setBarThickness(BAR);
+        JTextArea area = new JTextArea();
+        area.setLineWrap(true);
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 100; i++) {
+            sb.append("line ").append(i).append('\n');
+        }
+        area.setText(sb.toString());
+        JScrollPane pane = new JScrollPane(area);
+        frame(pane);
+        assertEquals(BAR, pane.getVerticalScrollBar().getWidth());
+        assertEquals(pane.getWidth() - BAR, area.getWidth());
+        assertEquals(0, pane.getHorizontalScrollBar().getHeight());
+    }
+
+    @Test
+    public void draggingTheThumbScrollsTheView() {
+        ScrollDelegate.setBarThickness(BAR);
+        JScrollPane pane = new JScrollPane(panel(100, 2000));
+        JFrame f = frame(pane);
+        JScrollBar v = pane.getVerticalScrollBar();
+        press(f, v, 5, 5);
+        drag(f, v, 5, 45);
+        drag(f, v, 5, 85);
+        release(f, v, 5, 85);
+        int y = pane.getViewport().getViewPosition().y;
+        // 80 pixels of a track as high as the pane, over a view of 2000.
+        int expected = 80 * (2000 - v.getHeight()) / (v.getHeight() - Math.max(16, v.getHeight() * v.getHeight() / 2000));
+        assertTrue("scrolled by the drag: " + y + " for " + expected, Math.abs(y - expected) <= 4);
+        assertEquals(y, v.getValue());
+        assertFalse(v.getValueIsAdjusting());
+        // A press on the track below the thumb moves a block.
+        press(f, v, 5, v.getHeight() - 2);
+        release(f, v, 5, v.getHeight() - 2);
+        assertEquals(Math.min(y + pane.getViewport().getExtentSize().height, 2000 - pane.getViewport().getExtentSize().height),
+                pane.getViewport().getViewPosition().y);
+    }
+
+    @Test
+    public void theUpperTrailingCornerSitsBesideTheColumnHeader() {
+        JTable t = new JTable(new DefaultTableModel(50, 3));
+        JScrollPane pane = new JScrollPane(t);
+        JButton control = new JButton("+");
+        control.setPreferredSize(new Dimension(20, 20));
+        pane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, control);
+        JFrame f = frame(pane);
+        int headH = pane.getColumnHeader().getHeight();
+        assertTrue(headH > 0);
+        assertSame(pane, control.getParent());
+        assertSame(control, pane.getCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER));
+        // No bar on a touch device: the corner has its own width.
+        assertEquals(new Rectangle(pane.getWidth() - 20, 0, 20, headH), control.getBounds());
+        assertEquals(pane.getWidth() - 20, pane.getColumnHeader().getWidth());
+        assertEquals(pane.getWidth(), pane.getViewport().getWidth());
+
+        ScrollDelegate.setBarThickness(BAR);
+        pane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
+        f.validate();
+        assertEquals(new Rectangle(pane.getWidth() - BAR, 0, BAR, headH), control.getBounds());
+        assertEquals(pane.getViewport().getWidth(), pane.getColumnHeader().getWidth());
+        assertEquals(headH, pane.getVerticalScrollBar().getY());
+
+        pane.setCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER, null);
+        assertEquals(null, control.getParent());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void anUnknownCornerIsRefused() {
+        new JScrollPane().setCorner("MIDDLE", new JPanel());
+    }
+
+    @Test
+    public void theHeadersFollowTheView() {
+        JScrollPane pane = new JScrollPane(panel(2000, 2000));
+        pane.setRowHeaderView(panel(30, 2000));
+        pane.setColumnHeaderView(panel(2000, 20));
+        JPanel corner = new JPanel();
+        pane.setCorner(ScrollPaneConstants.UPPER_LEFT_CORNER, corner);
+        frame(pane);
+        assertEquals(new Rectangle(0, 0, 30, 20), corner.getBounds());
+        pane.getViewport().setViewPosition(new Point(120, 340));
+        assertEquals(new Point(0, 340), pane.getRowHeader().getViewPosition());
+        assertEquals(new Point(120, 0), pane.getColumnHeader().getViewPosition());
+        assertEquals(-340, pane.getRowHeader().getView().getY());
+        assertEquals(-120, pane.getColumnHeader().getView().getX());
+        pane.getVerticalScrollBar().setValue(700);
+        assertEquals(new Point(0, 700), pane.getRowHeader().getViewPosition());
+        assertEquals(700, pane.getViewport().getViewPosition().y);
+    }
+
+    // ------------------------------------------------------------ wheel
+
+    private static void turnWheel(JFrame f, com.codename1.desktopcompat.java.awt.Component over, int deltaY) {
+        int[] at = onDisplay(over, 10, 10);
+        Display.getInstance().fireMouseWheelEvent(at[0], at[1], 0, deltaY, false, 0);
+    }
+
+    private static int[] changes(JScrollPane pane) {
+        final int[] n = {0};
+        pane.getViewport().addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                n[0]++;
+            }
+        });
+        return n;
+    }
+
+    @Test
+    public void theWheelScrollsAPaneOnce() {
+        JPanel view = panel(100, 2000);
+        JScrollPane pane = new JScrollPane(view);
+        JFrame f = frame(pane);
+        int[] changes = changes(pane);
+        turnWheel(f, pane, -40);
+        int y = pane.getViewport().getViewPosition().y;
+        assertTrue("the wheel scrolled down: " + y, y > 0);
+        assertEquals("one movement for one turn of the wheel", 1, changes[0]);
+        assertEquals(y, pane.getVerticalScrollBar().getValue());
+        turnWheel(f, pane, 40);
+        assertEquals("and back up", 0, pane.getViewport().getViewPosition().y);
+        assertEquals(2, changes[0]);
+    }
+
+    @Test
+    public void aWheelListenerGetsTheEventInsteadOfTheScrolling() {
+        JPanel view = panel(100, 2000);
+        JScrollPane pane = new JScrollPane(view);
+        JFrame f = frame(pane);
+        final int[] heard = {0, 0};
+        view.addMouseWheelListener(new MouseWheelListener() {
+            @Override
+            public void mouseWheelMoved(MouseWheelEvent e) {
+                heard[0]++;
+                heard[1] = e.getWheelRotation();
+            }
+        });
+        turnWheel(f, pane, -40);
+        assertEquals(1, heard[0]);
+        assertEquals(1, heard[1]);
+        assertEquals("zooming with the wheel must not scroll as well", 0, pane.getViewport().getViewPosition().y);
+        turnWheel(f, pane, 40);
+        assertEquals(2, heard[0]);
+        assertEquals(-1, heard[1]);
+    }
+
+    @Test
+    public void aListenerThatPassesTheEventOnScrollsThePaneOnce() {
+        final JPanel view = panel(100, 2000);
+        JScrollPane pane = new JScrollPane(view);
+        JFrame f = frame(pane);
+        view.addMouseWheelListener(new MouseWheelListener() {
+            @Override
+            public void mouseWheelMoved(MouseWheelEvent e) {
+                if (!e.isControlDown()) {
+                    for (com.codename1.desktopcompat.java.awt.Container p = view.getParent(); p != null;
+                            p = p.getParent()) {
+                        if (p instanceof JScrollPane) {
+                            p.dispatchEvent(e);
+                        }
+                    }
+                }
+            }
+        });
+        int[] changes = changes(pane);
+        turnWheel(f, pane, -40);
+        int unit = pane.getVerticalScrollBar().getUnitIncrement(1);
+        assertEquals(3 * unit, pane.getViewport().getViewPosition().y);
+        assertEquals(1, changes[0]);
+    }
+
+    @Test
+    public void wheelScrollingCanBeTurnedOff() {
+        JScrollPane pane = new JScrollPane(panel(100, 2000));
+        JFrame f = frame(pane);
+        pane.setWheelScrollingEnabled(false);
+        turnWheel(f, pane, -40);
+        assertEquals(0, pane.getViewport().getViewPosition().y);
+        pane.setWheelScrollingEnabled(true);
+        turnWheel(f, pane, -40);
+        assertTrue(pane.getViewport().getViewPosition().y > 0);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollPaneLayoutAndTreeUiTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollPaneLayoutAndTreeUiTest.java
new file mode 100644
index 00000000000..9a41e59645c
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollPaneLayoutAndTreeUiTest.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.plaf.basic.BasicTreeUI;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.rt.EventBridge;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// A scroll pane laid out by the application's own `ScrollPaneLayout`, a
+/// tree whose rows are painted through the application's `BasicTreeUI`,
+/// and a tool tip that depends on where the pointer is.
+public class ScrollPaneLayoutAndTreeUiTest extends KernelTestBase {
+
+    /// Bars that take room, as on a desktop.
+    @org.junit.Before
+    public void bars() {
+        com.codename1.desktopcompat.rt.ScrollDelegate.setBarThickness(12);
+    }
+
+    @org.junit.After
+    public void barsOfTheDevice() {
+        com.codename1.desktopcompat.rt.ScrollDelegate.setBarThickness(-1);
+    }
+
+    /// The vertical bar on the left of the view, as an application that
+    /// wants it there does it.
+    private static final class BarOnTheLeft extends ScrollPaneLayout {
+
+        int passes;
+
+        @Override
+        public void layoutContainer(Container parent) {
+            super.layoutContainer(parent);
+            passes++;
+            if (vsb != null && vsb.isVisible() && viewport != null) {
+                Rectangle bar = vsb.getBounds();
+                Rectangle view = viewport.getBounds();
+                vsb.setBounds(view.x, bar.y, bar.width, bar.height);
+                viewport.setBounds(view.x + bar.width, view.y, view.width, view.height);
+            }
+        }
+    }
+
+    @Test
+    public void aLayoutOfTheApplicationPlacesTheParts() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JPanel view = new JPanel();
+        view.setPreferredSize(new Dimension(100, 5000));
+        JScrollPane pane = new JScrollPane(view, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
+                ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+        assertTrue(pane.getLayout() instanceof ScrollPaneLayout.UIResource);
+        BarOnTheLeft layout = new BarOnTheLeft();
+        pane.setLayout(layout);
+        assertSame(layout, pane.getLayout());
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        assertTrue(layout.passes > 0);
+        // The layout knows the parts of the pane, and its policies.
+        assertSame(pane.getViewport(), layout.getViewport());
+        assertSame(pane.getVerticalScrollBar(), layout.getVerticalScrollBar());
+        assertEquals(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, layout.getVerticalScrollBarPolicy());
+        assertEquals(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER, layout.getHorizontalScrollBarPolicy());
+        JScrollBar bar = pane.getVerticalScrollBar();
+        JViewport vp = pane.getViewport();
+        assertTrue(bar.getWidth() > 0);
+        assertTrue("the bar is left of the view: " + bar.getBounds() + " " + vp.getBounds(),
+                bar.getX() + bar.getWidth() <= vp.getX());
+        // A part set later reaches the layout too.
+        JLabel head = new JLabel("head");
+        pane.setColumnHeaderView(head);
+        pane.doLayout();
+        assertNotNull(layout.getColumnHeader());
+        assertSame(head, layout.getColumnHeader().getView());
+        assertNull(layout.getRowHeader());
+    }
+
+    @Test
+    public void aScrollPaneRefusesAnyOtherLayout() {
+        JScrollPane pane = new JScrollPane();
+        try {
+            pane.setLayout(new BorderLayout());
+            fail("layout of JScrollPane must be a ScrollPaneLayout");
+        } catch (ClassCastException expected) {
+            assertTrue(pane.getLayout() instanceof ScrollPaneLayout);
+        }
+    }
+
+    /// Counts the rows it is asked to paint, and paints them.
+    private static final class Counting extends BasicTreeUI {
+
+        final List<String> rows = new ArrayList<String>();
+        JTree installedOn;
+
+        @Override
+        public void installUI(JComponent c) {
+            super.installUI(c);
+            installedOn = tree;
+        }
+
+        @Override
+        protected void paintRow(Graphics g, Rectangle clipBounds, Insets insets, Rectangle bounds, TreePath path,
+                int row, boolean isExpanded, boolean hasBeenExpanded, boolean isLeaf) {
+            rows.add(row + ":" + path.getLastPathComponent() + (isLeaf ? " leaf" : "") + (isExpanded ? " open" : "")
+                    + " " + bounds.y);
+            super.paintRow(g, clipBounds, insets, bounds, path, row, isExpanded, hasBeenExpanded, isLeaf);
+        }
+    }
+
+    @Test
+    public void theRowsOfATreeArePaintedThroughItsUi() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
+        DefaultMutableTreeNode a = new DefaultMutableTreeNode("a");
+        a.add(new DefaultMutableTreeNode("a1"));
+        root.add(a);
+        root.add(new DefaultMutableTreeNode("b"));
+        JTree tree = new JTree(root);
+        Counting ui = new Counting();
+        tree.setUI(ui);
+        assertSame(tree, ui.installedOn);
+        assertEquals(3, ui.getRowCount(tree));
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        f.add(tree, BorderLayout.CENTER);
+        show(f);
+        List<Object[]> text = paint(f);
+        assertEquals(ui.rows.toString(), 3, ui.rows.size());
+        assertTrue(ui.rows.get(0), ui.rows.get(0).startsWith("0:root open"));
+        assertTrue(ui.rows.get(1), ui.rows.get(1).startsWith("1:a "));
+        assertTrue(ui.rows.get(2), ui.rows.get(2).startsWith("2:b leaf"));
+        // What the UI passed on to the tree was drawn.
+        assertNotNull(find(text, "root"));
+        assertNotNull(find(text, "b"));
+        assertEquals(ui.getPathBounds(tree, tree.getPathForRow(2)), tree.getRowBounds(2));
+    }
+
+    /// A tip that names the half of the label the pointer is in.
+    private static final class Halves extends JLabel {
+
+        Halves() {
+            super("left and right");
+        }
+
+        @Override
+        public String getToolTipText(MouseEvent event) {
+            return event.getX() < getWidth() / 2 ? "left" : "right";
+        }
+    }
+
+    @Test
+    public void aToolTipFollowsThePlaceOfThePointer() {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        Halves label = new Halves();
+        f.add(label, BorderLayout.CENTER);
+        show(f);
+        // Registers the component with the tool tip manager, as on the
+        // desktop; the text itself is never shown.
+        label.setToolTipText("somewhere");
+        int w = label.getWidth();
+        int[] p = onDisplay(label, 3, 3);
+        EventBridge.pointerEvent(f, MouseEvent.MOUSE_MOVED, p[0], p[1]);
+        assertEquals("left", label.cn1Peer().getTooltip());
+        p = onDisplay(label, w - 3, 3);
+        EventBridge.pointerEvent(f, MouseEvent.MOUSE_MOVED, p[0], p[1]);
+        assertEquals("right", label.cn1Peer().getTooltip());
+        label.setToolTipText(null);
+        assertNull(label.cn1Peer().getTooltip());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollRevealReentrancyTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollRevealReentrancyTest.java
new file mode 100644
index 00000000000..f77ea598ddf
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/ScrollRevealReentrancyTest.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import org.junit.Test;
+
+/// Showing a rectangle must never start the layout it is called from a
+/// second time: a text area given its text inside a scroll pane that was
+/// never laid out used to overflow the stack on the pane's first layout.
+public class ScrollRevealReentrancyTest extends KernelTestBase {
+
+    /// What is asserted here is the geometry of the pane's own layout, to
+    /// the pixel, so the line a pane has around it by default is taken
+    /// away, the way an application does.
+    @org.junit.Before
+    public void noPaneBorder() {
+        com.codename1.desktopcompat.javax.swing.UIManager.put("ScrollPane.border",
+                new com.codename1.desktopcompat.javax.swing.border.EmptyBorder(0, 0, 0, 0));
+    }
+
+    @org.junit.After
+    public void themePaneBorder() {
+        com.codename1.desktopcompat.javax.swing.UIManager.put("ScrollPane.border", null);
+    }
+
+    private static String lines(int n) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < n; i++) {
+            sb.append("line ").append(i).append('\n');
+        }
+        return sb.toString();
+    }
+
+    @Test
+    public void textSetInAPaneThatWasNeverLaidOutLaysOutOnce() {
+        JTextArea area = new JTextArea();
+        JScrollPane pane = new JScrollPane(area);
+        area.setText(lines(200));
+        pane.setSize(200, 100);
+        pane.validate();
+        assertTrue(area.getHeight() > 100);
+        assertEquals("the caret is at the end, and the end shows", area.getHeight() - 100,
+                pane.getViewport().getViewPosition().y);
+    }
+
+    @Test
+    public void textSetBeforeTheFrameIsShownFollowsTheCaret() {
+        JTextArea area = new JTextArea();
+        JScrollPane pane = new JScrollPane(area);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        area.setText(lines(200));
+        f.setSize(200, 150);
+        show(f);
+        f.validate();
+        int extent = pane.getViewport().getExtentSize().height;
+        assertTrue(area.getHeight() > extent);
+        assertEquals(area.getHeight() - extent, pane.getViewport().getViewPosition().y);
+        area.setCaretPosition(0);
+        assertEquals(0, pane.getViewport().getViewPosition().y);
+    }
+
+    @Test
+    public void appendingToAShownAreaKeepsFollowing() {
+        JTextArea area = new JTextArea();
+        JScrollPane pane = new JScrollPane(area);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        f.setSize(200, 150);
+        show(f);
+        f.validate();
+        for (int i = 0; i < 100; i++) {
+            area.append("row " + i + "\n");
+            area.setCaretPosition(area.getDocument().getLength());
+        }
+        f.validate();
+        int extent = pane.getViewport().getExtentSize().height;
+        assertTrue(area.getHeight() > extent);
+        assertEquals(area.getHeight() - extent, pane.getViewport().getViewPosition().y);
+    }
+
+    @Test
+    public void revealingFromInsideALayoutDoesNotLayOutAgain() {
+        final int[] layouts = {0};
+        JPanel view = new JPanel() {
+            @Override
+            public void doLayout() {
+                layouts[0]++;
+                super.doLayout();
+                scrollRectToVisible(new Rectangle(0, 900, 10, 10));
+            }
+        };
+        view.setPreferredSize(new Dimension(100, 1000));
+        JScrollPane pane = new JScrollPane(view);
+        pane.setSize(100, 100);
+        pane.validate();
+        assertEquals(1, layouts[0]);
+        assertEquals(810, pane.getViewport().getViewPosition().y);
+    }
+
+    @Test
+    public void aListAndATableRevealInAPaneThatWasNeverLaidOut() {
+        DefaultListModel<String> m = new DefaultListModel<String>();
+        for (int i = 0; i < 300; i++) {
+            m.addElement("item " + i);
+        }
+        JList<String> list = new JList<String>(m);
+        JScrollPane pane = new JScrollPane(list);
+        list.ensureIndexIsVisible(250);
+        pane.setSize(100, 100);
+        pane.validate();
+        list.ensureIndexIsVisible(250);
+        Rectangle r = list.getCellBounds(250, 250);
+        int y = pane.getViewport().getViewPosition().y;
+        assertTrue(r.y >= y && r.y + r.height <= y + 100);
+
+        JTable t = new JTable(new DefaultTableModel(300, 2));
+        JScrollPane tp = new JScrollPane(t);
+        t.scrollRectToVisible(t.getCellRect(250, 0, true));
+        tp.setSize(100, 200);
+        tp.validate();
+        t.scrollRectToVisible(t.getCellRect(250, 0, true));
+        assertTrue(tp.getViewport().getViewPosition().y > 0);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SizeFollowsContentTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SizeFollowsContentTest.java
new file mode 100644
index 00000000000..609d67a5a19
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SizeFollowsContentTest.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.compat.testing.MainThreadRule;
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/// Sizes and colours a widget answers that follow from what it shows
+/// and from its look and feel, not from the container around it.
+public class SizeFollowsContentTest extends KernelTestBase {
+
+    /// An HTML label that is given less width than its text wants on one
+    /// line wraps, and then prefers the height of the wrapped text: the
+    /// container that measured it at one line lays it out again. Its
+    /// preferred width stays that of the unbroken text.
+    @Test
+    public void anHtmlLabelNarrowerThanItsTextPrefersItsWrappedHeight() {
+        StringBuilder words = new StringBuilder("<html>");
+        for (int i = 0; i < 60; i++) {
+            words.append("word").append(i).append(' ');
+        }
+        JLabel label = new JLabel(words.toString());
+        Dimension unbroken = label.getPreferredSize();
+        assertTrue("the test needs a text wider than the display", unbroken.width > 540);
+        // It can be as narrow as its longest word, with the space after it.
+        int word = new JLabel("<html>word59").getPreferredSize().width;
+        int least = label.getMinimumSize().width;
+        assertTrue(word + " <= " + least, least >= word && least <= word + word / 3);
+        JFrame f = new JFrame();
+        f.getContentPane().add(label, BorderLayout.NORTH);
+        f.getContentPane().add(new JScrollPane(new JTextArea()), BorderLayout.CENTER);
+        show(f);
+        MainThreadRule.drain();
+        f.cn1Form().revalidate();
+        assertEquals(f.getWidth(), label.getWidth());
+        assertEquals(unbroken.width, label.getPreferredSize().width);
+        assertTrue(label.getPreferredSize().height >= 2 * unbroken.height);
+        assertEquals(label.getPreferredSize().height, label.getHeight());
+        // Text that is not HTML is one line, and cannot be narrower.
+        JLabel plain = new JLabel(words.substring(6));
+        assertEquals(plain.getPreferredSize(), plain.getMinimumSize());
+    }
+
+    /// As on the desktop, a button with an HTML text can grow as wide as
+    /// it is let, so a box gives it the room its neighbours leave; a
+    /// button with a plain text keeps its own answer.
+    @Test
+    public void anHtmlButtonTakesTheSpareRoomOfABox() {
+        JButton plain = new JButton("One");
+        JButton html = new JButton("<html><font color=red>Three!</font></html>");
+        assertEquals(Integer.MAX_VALUE, html.getMaximumSize().width);
+        assertEquals(html.getPreferredSize().height, html.getMaximumSize().height);
+        html.setMaximumSize(new Dimension(70, 20));
+        assertEquals(70, html.getMaximumSize().width);
+        html.setMaximumSize(null);
+
+        // A panel with such a button in it, then glue: the glue gets
+        // next to nothing, since what it can take is so much less.
+        JPanel inner = new JPanel();
+        inner.setLayout(new BoxLayout(inner, BoxLayout.X_AXIS));
+        inner.add(plain);
+        inner.add(html);
+        JPanel row = new JPanel();
+        row.setLayout(new BoxLayout(row, BoxLayout.X_AXIS));
+        row.add(inner);
+        row.add(Box.createHorizontalGlue());
+        JFrame f = new JFrame();
+        f.getContentPane().add(row, BorderLayout.CENTER);
+        show(f);
+        int limit = plain.getMaximumSize().width;
+        assertTrue(plain.getWidth() <= limit);
+        assertTrue(row.getWidth() - inner.getWidth() <= 1);
+        assertEquals(inner.getWidth(), html.getX() + html.getWidth());
+        assertTrue(html.getWidth() > html.getPreferredSize().width);
+    }
+
+    /// A widget's colours are its look and feel's, the `control` and
+    /// `controlText` of the UI manager, whatever the container around it
+    /// was given; only a component without a look and feel inherits.
+    @Test
+    public void aWidgetDoesNotTakeItsColoursFromItsContainer() {
+        Color control = UIManager.getColor("control");
+        Color text = UIManager.getColor("controlText");
+        assertNotNull(control);
+        assertNotNull(text);
+        JPanel outer = new JPanel(new BorderLayout());
+        outer.setBackground(new Color(200, 10, 10));
+        outer.setForeground(new Color(10, 200, 10));
+        JPanel inner = new JPanel();
+        JLabel label = new JLabel("x");
+        JComponent bare = new JComponent() {
+        };
+        outer.add(inner, BorderLayout.NORTH);
+        outer.add(label, BorderLayout.CENTER);
+        outer.add(bare, BorderLayout.SOUTH);
+        assertEquals(control, inner.getBackground());
+        assertEquals(text, label.getForeground());
+        assertFalse(inner.isBackgroundSet());
+        assertEquals(new Color(200, 10, 10), bare.getBackground());
+        assertEquals(new Color(10, 200, 10), bare.getForeground());
+        inner.setBackground(Color.BLUE);
+        assertEquals(Color.BLUE, inner.getBackground());
+    }
+
+    /// Where the scroll bars have room they show the position; Codename
+    /// One's own indicator, drawn over the content, is only for a device
+    /// that gives them none.
+    @Test
+    public void aViewportShowsOnePositionIndicator() {
+        JTextArea area = new JTextArea(60, 20);
+        JScrollPane scroll = new JScrollPane(area);
+        JFrame f = new JFrame();
+        f.getContentPane().add(scroll, BorderLayout.CENTER);
+        show(f);
+        com.codename1.ui.Component peer = scroll.getViewport().cn1Peer();
+        assertEquals(ScrollDelegate.barThickness() == 0, peer.isScrollVisible());
+    }
+
+    /// A toggle button that is on shows it even in a theme that draws the
+    /// pressed style, and the one of the focus, as the plain one: the
+    /// button is washed with its text colour. A theme that tells the two apart is left to do so.
+    @Test
+    public void aToggleButtonThatIsOnShowsIt() {
+        Icon icon = new ImageIcon(new com.codename1.desktopcompat.java.awt.image.BufferedImage(8, 8,
+                com.codename1.desktopcompat.java.awt.image.BufferedImage.TYPE_INT_ARGB));
+        JToggleButton b = new JToggleButton(icon);
+        JPanel p = new JPanel(new BorderLayout());
+        p.add(b, BorderLayout.CENTER);
+        JFrame f = new JFrame();
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        show(f);
+        com.codename1.ui.Button peer = (com.codename1.ui.Button) b.cn1Peer();
+        com.codename1.ui.plaf.Style off = peer.getUnselectedStyle();
+        com.codename1.ui.plaf.Style on = peer.getPressedStyle();
+        off.setBgTransparency(255);
+        off.setBgColor(0xffffff);
+        off.setFgColor(0x000000);
+        off.setBorder(null);
+        com.codename1.ui.plaf.Style focused = peer.getSelectedStyle();
+        com.codename1.ui.plaf.Style[] both = {on, focused};
+        for (int i = 0; i < both.length; i++) {
+            both[i].setBgTransparency(255);
+            both[i].setBgColor(0xffffff);
+            both[i].setFgColor(0x000000);
+            both[i].setBorder(null);
+        }
+        int plain = pixel(raster(f), b, 3, 3);
+        assertEquals(0xffffff, plain & 0xffffff);
+        b.setSelected(true);
+        int washed = pixel(raster(f), b, 3, 3) & 0xffffff;
+        assertTrue(Integer.toHexString(washed), washed != 0xffffff && (washed & 0xff) > 0x80);
+        // A theme with a pressed look of its own gets no wash over it.
+        on.setBgColor(0x3366cc);
+        focused.setBgColor(0x3366cc);
+        assertEquals(0x3366cc, pixel(raster(f), b, 3, 3) & 0xffffff);
+        // Off again, in the theme that tells nothing apart: no wash.
+        on.setBgColor(0xffffff);
+        focused.setBgColor(0xffffff);
+        b.setSelected(false);
+        assertEquals(0xffffff, pixel(raster(f), b, 3, 3) & 0xffffff);
+    }
+
+    /// A row that is short of room narrows its text field and keeps the
+    /// label before it and whatever follows inside the row.
+    @Test
+    public void aTextFieldGivesWayInARowThatIsShortOfRoom() {
+        JLabel label = new JLabel("Frame title:");
+        JTextField field = new JTextField(30);
+        JButton after = new JButton("Go");
+        assertTrue(field.getMinimumSize().width < field.getPreferredSize().width);
+        assertEquals(field.getPreferredSize().height, field.getMinimumSize().height);
+        JPanel row = new JPanel();
+        row.setLayout(new BoxLayout(row, BoxLayout.X_AXIS));
+        row.add(label);
+        row.add(field);
+        row.add(after);
+        int room = label.getPreferredSize().width + after.getPreferredSize().width + 60;
+        assertTrue(room < row.getPreferredSize().width);
+        JPanel holder = new JPanel(null);
+        holder.add(row);
+        row.setBounds(0, 0, room, 40);
+        JFrame f = new JFrame();
+        f.getContentPane().add(holder, BorderLayout.CENTER);
+        show(f);
+        row.setBounds(0, 0, room, 40);
+        row.validate();
+        assertEquals(label.getPreferredSize().width, label.getWidth());
+        assertEquals(after.getPreferredSize().width, after.getWidth());
+        assertEquals(room, after.getX() + after.getWidth());
+        assertEquals(60, field.getWidth());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SpinnerTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SpinnerTest.java
new file mode 100644
index 00000000000..dedd895f18f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SpinnerTest.java
@@ -0,0 +1,497 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.javax.swing.event.ChangeEvent;
+import com.codename1.desktopcompat.javax.swing.event.ChangeListener;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The spinner models against the JDK's, and the spinner's buttons and
+/// text field driving a model.
+public class SpinnerTest extends KernelTestBase {
+
+    private static final class Count implements ChangeListener {
+        int n;
+        Object source;
+
+        @Override
+        public void stateChanged(ChangeEvent e) {
+            n++;
+            source = e.getSource();
+        }
+    }
+
+    private static final class JdkCount implements javax.swing.event.ChangeListener {
+        int n;
+
+        @Override
+        public void stateChanged(javax.swing.event.ChangeEvent e) {
+            n++;
+        }
+    }
+
+    private static String state(SpinnerModel m) {
+        return m.getValue() + " " + m.getPreviousValue() + " " + m.getNextValue();
+    }
+
+    private static String state(javax.swing.SpinnerModel m) {
+        return m.getValue() + " " + m.getPreviousValue() + " " + m.getNextValue();
+    }
+
+    private static String message(Runnable r) {
+        try {
+            r.run();
+        } catch (IllegalArgumentException e) {
+            return String.valueOf(e.getMessage());
+        }
+        return "no exception";
+    }
+
+    @Test
+    public void theNumberModelStepsAndStopsAsTheJdkDoes() {
+        final SpinnerNumberModel a = new SpinnerNumberModel(5, 0, 10, 4);
+        final javax.swing.SpinnerNumberModel b = new javax.swing.SpinnerNumberModel(5, 0, 10, 4);
+        Count ours = new Count();
+        JdkCount theirs = new JdkCount();
+        a.addChangeListener(ours);
+        b.addChangeListener(theirs);
+        assertEquals(state(b), state(a));
+        a.setValue(a.getNextValue());
+        b.setValue(b.getNextValue());
+        assertEquals("9 5 null", state(a));
+        assertEquals(state(b), state(a));
+        a.setValue(Integer.valueOf(9));
+        b.setValue(Integer.valueOf(9));
+        a.setValue(Integer.valueOf(1));
+        b.setValue(Integer.valueOf(1));
+        assertEquals("1 null 5", state(a));
+        assertEquals(state(b), state(a));
+        // A value outside the bounds is taken, as on the desktop.
+        a.setValue(Integer.valueOf(40));
+        b.setValue(Integer.valueOf(40));
+        assertEquals(state(b), state(a));
+        a.setStepSize(Integer.valueOf(2));
+        b.setStepSize(Integer.valueOf(2));
+        a.setMaximum(Integer.valueOf(50));
+        b.setMaximum(Integer.valueOf(50));
+        a.setMaximum(Integer.valueOf(50));
+        b.setMaximum(Integer.valueOf(50));
+        a.setMinimum(null);
+        b.setMinimum(null);
+        assertEquals(state(b), state(a));
+        assertEquals(theirs.n, ours.n);
+        assertSame(a, ours.source);
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                b.setValue("x");
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                a.setValue("x");
+            }
+        }));
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                new javax.swing.SpinnerNumberModel(11, 0, 10, 1);
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                new SpinnerNumberModel(11, 0, 10, 1);
+            }
+        }));
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                b.setStepSize(null);
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                a.setStepSize(null);
+            }
+        }));
+    }
+
+    @Test
+    public void theNumberModelKeepsTheTypeOfItsValue() {
+        SpinnerNumberModel d = new SpinnerNumberModel(0.5, 0.0, 1.0, 0.25);
+        javax.swing.SpinnerNumberModel jd = new javax.swing.SpinnerNumberModel(0.5, 0.0, 1.0, 0.25);
+        assertEquals(state(jd), state(d));
+        assertTrue(d.getNextValue() instanceof Double);
+        d.setValue(d.getNextValue());
+        d.setValue(d.getNextValue());
+        assertEquals("1.0 0.75 null", state(d));
+
+        SpinnerNumberModel l = new SpinnerNumberModel(Long.valueOf(7), null, null, Long.valueOf(3));
+        javax.swing.SpinnerNumberModel jl =
+                new javax.swing.SpinnerNumberModel(Long.valueOf(7), null, null, Long.valueOf(3));
+        assertEquals(state(jl), state(l));
+        assertTrue(l.getPreviousValue() instanceof Long);
+
+        SpinnerNumberModel s = new SpinnerNumberModel(Short.valueOf((short) 2), null, null, Short.valueOf((short) 1));
+        assertTrue(s.getNextValue() instanceof Short);
+        SpinnerNumberModel f = new SpinnerNumberModel(Float.valueOf(1f), null, null, Float.valueOf(0.5f));
+        assertEquals(Float.valueOf(1.5f), f.getNextValue());
+
+        SpinnerNumberModel plain = new SpinnerNumberModel();
+        assertEquals(state(new javax.swing.SpinnerNumberModel()), state(plain));
+        assertEquals(Integer.valueOf(0), plain.getNumber());
+    }
+
+    @Test
+    public void theListModelWalksItsListAsTheJdkDoes() {
+        final SpinnerListModel a = new SpinnerListModel(new Object[]{"red", "green", "blue"});
+        final javax.swing.SpinnerListModel b = new javax.swing.SpinnerListModel(new Object[]{"red", "green", "blue"});
+        Count ours = new Count();
+        JdkCount theirs = new JdkCount();
+        a.addChangeListener(ours);
+        b.addChangeListener(theirs);
+        assertEquals("red null green", state(a));
+        assertEquals(state(b), state(a));
+        a.setValue("blue");
+        b.setValue("blue");
+        a.setValue("blue");
+        b.setValue("blue");
+        assertEquals("blue green null", state(a));
+        assertEquals(state(b), state(a));
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                b.setValue("pink");
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                a.setValue("pink");
+            }
+        }));
+        a.setList(Arrays.asList("x", "y"));
+        b.setList(Arrays.asList("x", "y"));
+        assertEquals(state(b), state(a));
+        assertEquals(theirs.n, ours.n);
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                new javax.swing.SpinnerListModel(new Object[0]);
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                new SpinnerListModel(new Object[0]);
+            }
+        }));
+        assertEquals(state(new javax.swing.SpinnerListModel()), state(new SpinnerListModel()));
+    }
+
+    @Test
+    public void theDateModelStepsItsCalendarFieldAsTheJdkDoes() {
+        Calendar c = Calendar.getInstance();
+        c.set(2024, Calendar.JANUARY, 30, 10, 15, 0);
+        c.set(Calendar.MILLISECOND, 0);
+        Date now = c.getTime();
+        c.set(Calendar.DAY_OF_MONTH, 29);
+        Date start = c.getTime();
+        c.set(Calendar.MONTH, Calendar.FEBRUARY);
+        c.set(Calendar.DAY_OF_MONTH, 1);
+        Date end = c.getTime();
+        final SpinnerDateModel a = new SpinnerDateModel(now, start, end, Calendar.DAY_OF_MONTH);
+        final javax.swing.SpinnerDateModel b =
+                new javax.swing.SpinnerDateModel(now, start, end, Calendar.DAY_OF_MONTH);
+        Count ours = new Count();
+        a.addChangeListener(ours);
+        assertEquals(state(b), state(a));
+        a.setValue(a.getNextValue());
+        b.setValue(b.getNextValue());
+        a.setValue(a.getNextValue());
+        b.setValue(b.getNextValue());
+        assertEquals(state(b), state(a));
+        assertNull(a.getNextValue());
+        assertEquals(end, a.getDate());
+        assertEquals(2, ours.n);
+        a.setCalendarField(Calendar.HOUR_OF_DAY);
+        b.setCalendarField(Calendar.HOUR_OF_DAY);
+        assertEquals(state(b), state(a));
+        assertEquals(3, ours.n);
+        a.setValue(start);
+        b.setValue(start);
+        assertNull(a.getPreviousValue());
+        assertEquals(state(b), state(a));
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                b.setValue("x");
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                a.setValue("x");
+            }
+        }));
+        assertEquals(message(new Runnable() {
+            @Override
+            public void run() {
+                b.setCalendarField(99);
+            }
+        }), message(new Runnable() {
+            @Override
+            public void run() {
+                a.setCalendarField(99);
+            }
+        }));
+        assertEquals(Calendar.DAY_OF_MONTH, new SpinnerDateModel().getCalendarField());
+    }
+
+    private static JTextField field(JSpinner s) {
+        return ((JSpinner.DefaultEditor) s.getEditor()).cn1Field();
+    }
+
+    private static JButton button(JSpinner s, String name) {
+        for (int i = 0; i < s.getComponentCount(); i++) {
+            if (name.equals(s.getComponent(i).getName())) {
+                return (JButton) s.getComponent(i);
+            }
+        }
+        fail("no " + name);
+        return null;
+    }
+
+    @Test
+    public void theButtonsStepTheModelAndTheEditorFollows() {
+        JSpinner s = new JSpinner(new SpinnerNumberModel(5, 0, 7, 1));
+        Count changes = new Count();
+        s.addChangeListener(changes);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        assertTrue(s.getEditor() instanceof JSpinner.NumberEditor);
+        assertEquals(3, s.getComponentCount());
+        assertEquals("5", field(s).getText());
+        JButton next = button(s, "Spinner.nextButton");
+        JButton previous = button(s, "Spinner.previousButton");
+        next.doClick();
+        assertEquals(Integer.valueOf(6), s.getValue());
+        assertEquals("6", field(s).getText());
+        assertSame(s, changes.source);
+        next.doClick();
+        next.doClick();
+        next.doClick();
+        assertEquals(Integer.valueOf(7), s.getValue());
+        assertEquals(2, changes.n);
+        previous.doClick();
+        assertEquals(Integer.valueOf(6), s.getValue());
+        assertEquals("6", field(s).getText());
+        assertEquals(Integer.valueOf(7), s.getNextValue());
+        assertEquals(Integer.valueOf(5), s.getPreviousValue());
+
+        // The three children share the row and none is squeezed out.
+        Dimension size = s.getSize();
+        assertTrue(size.width > 0 && size.height > 0);
+        assertTrue(s.getEditor().getWidth() > 0);
+        assertTrue(previous.getWidth() > 0 && next.getWidth() > 0);
+        assertTrue(s.getEditor().getX() + s.getEditor().getWidth() <= previous.getX());
+        assertTrue(previous.getX() + previous.getWidth() <= next.getX());
+        assertEquals(size.height, next.getHeight());
+        // The field draws its own text natively; painting must simply work.
+        assertNotNull(paint(f));
+
+        s.setEnabled(false);
+        assertFalse(next.isEnabled());
+        assertFalse(field(s).isEnabled());
+    }
+
+    @Test
+    public void typedTextIsParsedIntoANumberModelAndBadTextIsDropped() throws Exception {
+        JSpinner s = new JSpinner(new SpinnerNumberModel(5, 0, 100, 1));
+        Count changes = new Count();
+        s.addChangeListener(changes);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        JTextField text = field(s);
+        text.setText("42");
+        text.postActionEvent();
+        assertEquals(Integer.valueOf(42), s.getValue());
+        assertEquals(1, changes.n);
+        text.setText("nope");
+        text.postActionEvent();
+        assertEquals(Integer.valueOf(42), s.getValue());
+        assertEquals("42", text.getText());
+        // Outside the model's range.
+        text.setText("101");
+        text.postActionEvent();
+        assertEquals(Integer.valueOf(42), s.getValue());
+        assertEquals("42", text.getText());
+        assertEquals(1, changes.n);
+        // commitEdit reports what the action swallows.
+        text.setText("12x");
+        try {
+            s.commitEdit();
+            fail("12x is not a number");
+        } catch (java.text.ParseException expected) {
+            assertEquals(Integer.valueOf(42), s.getValue());
+        }
+        // A step takes in what was typed first.
+        text.setText("7");
+        button(s, "Spinner.nextButton").doClick();
+        assertEquals(Integer.valueOf(8), s.getValue());
+        assertEquals("8", text.getText());
+        // And drops what does not parse.
+        text.setText("zz");
+        button(s, "Spinner.previousButton").doClick();
+        assertEquals(Integer.valueOf(7), s.getValue());
+        assertEquals("7", text.getText());
+    }
+
+    @Test
+    public void typedTextIsMatchedAgainstAListModel() {
+        JSpinner s = new JSpinner(new SpinnerListModel(new Object[]{"red", "green", "blue"}));
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        assertTrue(s.getEditor() instanceof JSpinner.ListEditor);
+        JTextField text = field(s);
+        assertEquals("red", text.getText());
+        text.setText("blue");
+        text.postActionEvent();
+        assertEquals("blue", s.getValue());
+        text.setText("pink");
+        text.postActionEvent();
+        assertEquals("blue", s.getValue());
+        assertEquals("blue", text.getText());
+        button(s, "Spinner.nextButton").doClick();
+        assertEquals("blue", s.getValue());
+        button(s, "Spinner.previousButton").doClick();
+        assertEquals("green", s.getValue());
+        assertEquals("green", text.getText());
+    }
+
+    @Test
+    public void aNewModelBringsItsOwnEditorAndAnExplicitEditorStays() {
+        JSpinner s = new JSpinner();
+        assertEquals(Integer.valueOf(0), s.getValue());
+        JComponent first = s.getEditor();
+        assertTrue(first instanceof JSpinner.NumberEditor);
+        assertSame(s, ((JSpinner.NumberEditor) first).getSpinner());
+        assertSame(s.getModel(), ((JSpinner.NumberEditor) first).getModel());
+        Count changes = new Count();
+        s.addChangeListener(changes);
+
+        SpinnerListModel list = new SpinnerListModel(new Object[]{"a", "b"});
+        s.setModel(list);
+        assertSame(list, s.getModel());
+        assertTrue(s.getEditor() instanceof JSpinner.ListEditor);
+        assertEquals(3, s.getComponentCount());
+        // The replaced editor no longer listens.
+        assertEquals(2, s.getChangeListeners().length);
+        s.setValue("b");
+        assertEquals(1, changes.n);
+        assertEquals("b", field(s).getText());
+
+        SpinnerDateModel dates = new SpinnerDateModel();
+        s.setModel(dates);
+        assertTrue(s.getEditor() instanceof JSpinner.DateEditor);
+        JSpinner.DateEditor de = (JSpinner.DateEditor) s.getEditor();
+        assertEquals(de.getFormat().format(dates.getDate()), field(s).getText());
+
+        JLabel mine = new JLabel("mine");
+        s.setEditor(mine);
+        assertSame(mine, s.getEditor());
+        assertEquals(1, s.getChangeListeners().length);
+        s.setModel(new SpinnerNumberModel(1, 0, 9, 1));
+        assertSame(mine, s.getEditor());
+        assertEquals(3, s.getComponentCount());
+
+        try {
+            s.setModel(null);
+            fail("a null model is refused");
+        } catch (IllegalArgumentException expected) {
+            assertEquals("null model", expected.getMessage());
+        }
+        try {
+            new JSpinner.ListEditor(s);
+            fail("the model is not a list model");
+        } catch (IllegalArgumentException expected) {
+            assertEquals("model not a SpinnerListModel", expected.getMessage());
+        }
+        // The refused editor is not left listening.
+        assertEquals(1, s.getChangeListeners().length);
+    }
+
+    @Test
+    public void aModelThatIsNoneOfTheThreeIsShownAndNotEdited() {
+        SpinnerModel odd = new AbstractSpinnerModel() {
+            private Object value = "one";
+
+            @Override
+            public Object getValue() {
+                return value;
+            }
+
+            @Override
+            public void setValue(Object v) {
+                value = v;
+                fireStateChanged();
+            }
+
+            @Override
+            public Object getNextValue() {
+                return "two";
+            }
+
+            @Override
+            public Object getPreviousValue() {
+                return null;
+            }
+        };
+        JSpinner s = new JSpinner(odd);
+        JFrame f = new JFrame();
+        f.add(s, BorderLayout.NORTH);
+        show(f);
+        JTextField text = field(s);
+        assertFalse(text.isEditable());
+        assertEquals("one", text.getText());
+        button(s, "Spinner.previousButton").doClick();
+        assertEquals("one", s.getValue());
+        button(s, "Spinner.nextButton").doClick();
+        assertEquals("two", s.getValue());
+        assertEquals("two", text.getText());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SpringLayoutParityTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SpringLayoutParityTest.java
new file mode 100644
index 00000000000..1aa78f723c7
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SpringLayoutParityTest.java
@@ -0,0 +1,1183 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.junit.Test;
+
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.javax.swing.border.EmptyBorder;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/// Runs the same sequence of spring and spring layout calls against the
+/// JDK's `javax.swing.Spring` and `javax.swing.SpringLayout` and against
+/// this layer's, and requires identical spring values, component bounds
+/// and layout sizes.
+///
+/// A scenario is written once against [Side], which names components and
+/// springs by number, and is played on both class libraries. The
+/// components are bare ones with fixed sizes, so nothing depends on a look
+/// and feel and the JDK side runs headless.
+public class SpringLayoutParityTest {
+
+    static {
+        System.setProperty("java.awt.headless", "true");
+    }
+
+    private static final int HOST = -1;
+
+    private static final String N = "North";
+    private static final String S = "South";
+    private static final String E = "East";
+    private static final String W = "West";
+    private static final String HC = "HorizontalCenter";
+    private static final String VC = "VerticalCenter";
+    private static final String BL = "Baseline";
+    private static final String WD = "Width";
+    private static final String HT = "Height";
+
+    private static final String[] HORIZONTAL = {W, E, HC, WD};
+    private static final String[] VERTICAL = {N, S, VC, HT};
+
+    /// One class library, driven by numbers.
+    private interface Side {
+        void border(int top, int left, int bottom, int right);
+
+        int comp(int pw, int ph, int minw, int minh, int maxw, int maxh, int baseline);
+
+        void add(int comp);
+
+        void addAsIs(int comp, int x, int y);
+
+        void addWith(int comp, int x, int y, int w, int h);
+
+        void addWithProperty(int comp, int x, int y);
+
+        void remove(int comp);
+
+        int constant(int pref);
+
+        int constant(int min, int pref, int max);
+
+        int sum(int a, int b);
+
+        int max(int a, int b);
+
+        int minus(int a);
+
+        int scale(int a, float factor);
+
+        int width(int comp);
+
+        int height(int comp);
+
+        int edge(String edge, int comp);
+
+        int constraint(String edge, int comp);
+
+        void put(String e1, int c1, int pad, String e2, int c2);
+
+        void putSpring(String e1, int c1, int spring, String e2, int c2);
+
+        void set(int comp, String edge, int spring);
+
+        void setValue(int spring, int value);
+
+        String spring(int spring);
+
+        String layout(int w, int h);
+
+        String sizes();
+    }
+
+    /// A scenario: calls on a side, and everything observed on the way.
+    private interface Script {
+        void run(Side side, StringBuilder out);
+    }
+
+    // ------------------------------------------------------------------
+    // The JDK side
+
+    private static final class RealLeaf extends javax.swing.JComponent {
+        private static final long serialVersionUID = 1L;
+        private final int baseline;
+
+        RealLeaf(int baseline) {
+            this.baseline = baseline;
+        }
+
+        @Override
+        public int getBaseline(int width, int height) {
+            return baseline < 0 ? -1 : Math.min(baseline, height);
+        }
+    }
+
+    private static final class Real implements Side {
+        final javax.swing.SpringLayout layout = new javax.swing.SpringLayout();
+        final javax.swing.JComponent host = new javax.swing.JComponent() {
+            private static final long serialVersionUID = 1L;
+        };
+        final List<javax.swing.JComponent> comps = new ArrayList<javax.swing.JComponent>();
+        final List<javax.swing.Spring> springs = new ArrayList<javax.swing.Spring>();
+
+        Real() {
+            host.setLayout(layout);
+        }
+
+        private java.awt.Component c(int i) {
+            return i == HOST ? host : comps.get(i);
+        }
+
+        private int s(javax.swing.Spring s) {
+            if (s == null) {
+                return -1;
+            }
+            springs.add(s);
+            return springs.size() - 1;
+        }
+
+        public void border(int top, int left, int bottom, int right) {
+            host.setBorder(javax.swing.BorderFactory.createEmptyBorder(top, left, bottom, right));
+        }
+
+        public int comp(int pw, int ph, int minw, int minh, int maxw, int maxh, int baseline) {
+            javax.swing.JComponent k = new RealLeaf(baseline);
+            k.setPreferredSize(new java.awt.Dimension(pw, ph));
+            k.setMinimumSize(new java.awt.Dimension(minw, minh));
+            if (maxw >= 0) {
+                k.setMaximumSize(new java.awt.Dimension(maxw, maxh));
+            }
+            comps.add(k);
+            return comps.size() - 1;
+        }
+
+        public void add(int comp) {
+            host.add(comps.get(comp));
+        }
+
+        public void addAsIs(int comp, int x, int y) {
+            comps.get(comp).setLocation(x, y);
+            host.add(comps.get(comp), new javax.swing.SpringLayout.Constraints(comps.get(comp)));
+        }
+
+        public void addWith(int comp, int x, int y, int w, int h) {
+            javax.swing.SpringLayout.Constraints cons;
+            if (w < 0 && x < 0) {
+                cons = new javax.swing.SpringLayout.Constraints();
+            } else if (w < 0) {
+                cons = new javax.swing.SpringLayout.Constraints(springs.get(x), springs.get(y));
+            } else {
+                cons = new javax.swing.SpringLayout.Constraints(springs.get(x), springs.get(y), springs.get(w),
+                        springs.get(h));
+            }
+            host.add(comps.get(comp), cons);
+        }
+
+        public void addWithProperty(int comp, int x, int y) {
+            comps.get(comp).putClientProperty(javax.swing.SpringLayout.class,
+                    new javax.swing.SpringLayout.Constraints(springs.get(x), springs.get(y)));
+            host.add(comps.get(comp));
+        }
+
+        public void remove(int comp) {
+            host.remove(comps.get(comp));
+        }
+
+        public int constant(int pref) {
+            return s(javax.swing.Spring.constant(pref));
+        }
+
+        public int constant(int min, int pref, int max) {
+            return s(javax.swing.Spring.constant(min, pref, max));
+        }
+
+        public int sum(int a, int b) {
+            return s(javax.swing.Spring.sum(springs.get(a), springs.get(b)));
+        }
+
+        public int max(int a, int b) {
+            return s(javax.swing.Spring.max(springs.get(a), springs.get(b)));
+        }
+
+        public int minus(int a) {
+            return s(javax.swing.Spring.minus(springs.get(a)));
+        }
+
+        public int scale(int a, float factor) {
+            return s(javax.swing.Spring.scale(springs.get(a), factor));
+        }
+
+        public int width(int comp) {
+            return s(javax.swing.Spring.width(c(comp)));
+        }
+
+        public int height(int comp) {
+            return s(javax.swing.Spring.height(c(comp)));
+        }
+
+        public int edge(String edge, int comp) {
+            return s(layout.getConstraint(edge, c(comp)));
+        }
+
+        public int constraint(String edge, int comp) {
+            return s(layout.getConstraints(c(comp)).getConstraint(edge));
+        }
+
+        public void put(String e1, int c1, int pad, String e2, int c2) {
+            layout.putConstraint(e1, c(c1), pad, e2, c(c2));
+        }
+
+        public void putSpring(String e1, int c1, int spring, String e2, int c2) {
+            layout.putConstraint(e1, c(c1), springs.get(spring), e2, c(c2));
+        }
+
+        public void set(int comp, String edge, int spring) {
+            layout.getConstraints(c(comp)).setConstraint(edge, spring < 0 ? null : springs.get(spring));
+        }
+
+        public void setValue(int spring, int value) {
+            springs.get(spring).setValue(value);
+        }
+
+        public String spring(int spring) {
+            if (spring < 0) {
+                return "null";
+            }
+            javax.swing.Spring s = springs.get(spring);
+            return s.getMinimumValue() + "/" + s.getPreferredValue() + "/" + s.getMaximumValue() + "=" + s.getValue();
+        }
+
+        public String layout(int w, int h) {
+            host.setSize(w, h);
+            layout.layoutContainer(host);
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < comps.size(); i++) {
+                java.awt.Component k = comps.get(i);
+                if (k.getParent() != host) {
+                    continue;
+                }
+                sb.append(i).append(' ').append(k.getX()).append(',').append(k.getY()).append(' ')
+                        .append(k.getWidth()).append('x').append(k.getHeight()).append('\n');
+            }
+            return sb.toString();
+        }
+
+        public String sizes() {
+            java.awt.Dimension p = layout.preferredLayoutSize(host);
+            java.awt.Dimension m = layout.minimumLayoutSize(host);
+            java.awt.Dimension x = layout.maximumLayoutSize(host);
+            return "pref=" + p.width + "x" + p.height + " min=" + m.width + "x" + m.height + " max=" + x.width + "x"
+                    + x.height + " align=" + layout.getLayoutAlignmentX(host) + "," + layout.getLayoutAlignmentY(host);
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // This layer's side
+
+    private static final class OurLeaf extends JComponent {
+        private final int baseline;
+
+        OurLeaf(int baseline) {
+            this.baseline = baseline;
+        }
+
+        @Override
+        public int getBaseline(int width, int height) {
+            return baseline < 0 ? -1 : Math.min(baseline, height);
+        }
+    }
+
+    private static final class Ours implements Side {
+        final SpringLayout layout = new SpringLayout();
+        final JComponent host = new JComponent() {
+        };
+        final List<JComponent> comps = new ArrayList<JComponent>();
+        final List<Spring> springs = new ArrayList<Spring>();
+
+        Ours() {
+            host.setLayout(layout);
+        }
+
+        private Component c(int i) {
+            return i == HOST ? host : comps.get(i);
+        }
+
+        private int s(Spring s) {
+            if (s == null) {
+                return -1;
+            }
+            springs.add(s);
+            return springs.size() - 1;
+        }
+
+        public void border(int top, int left, int bottom, int right) {
+            host.setBorder(new EmptyBorder(top, left, bottom, right));
+        }
+
+        public int comp(int pw, int ph, int minw, int minh, int maxw, int maxh, int baseline) {
+            JComponent k = new OurLeaf(baseline);
+            k.setPreferredSize(new Dimension(pw, ph));
+            k.setMinimumSize(new Dimension(minw, minh));
+            if (maxw >= 0) {
+                k.setMaximumSize(new Dimension(maxw, maxh));
+            }
+            comps.add(k);
+            return comps.size() - 1;
+        }
+
+        public void add(int comp) {
+            host.add(comps.get(comp));
+        }
+
+        public void addAsIs(int comp, int x, int y) {
+            comps.get(comp).setLocation(x, y);
+            host.add(comps.get(comp), new SpringLayout.Constraints(comps.get(comp)));
+        }
+
+        public void addWith(int comp, int x, int y, int w, int h) {
+            SpringLayout.Constraints cons;
+            if (w < 0 && x < 0) {
+                cons = new SpringLayout.Constraints();
+            } else if (w < 0) {
+                cons = new SpringLayout.Constraints(springs.get(x), springs.get(y));
+            } else {
+                cons = new SpringLayout.Constraints(springs.get(x), springs.get(y), springs.get(w), springs.get(h));
+            }
+            host.add(comps.get(comp), cons);
+        }
+
+        public void addWithProperty(int comp, int x, int y) {
+            comps.get(comp).putClientProperty(SpringLayout.class,
+                    new SpringLayout.Constraints(springs.get(x), springs.get(y)));
+            host.add(comps.get(comp));
+        }
+
+        public void remove(int comp) {
+            host.remove(comps.get(comp));
+        }
+
+        public int constant(int pref) {
+            return s(Spring.constant(pref));
+        }
+
+        public int constant(int min, int pref, int max) {
+            return s(Spring.constant(min, pref, max));
+        }
+
+        public int sum(int a, int b) {
+            return s(Spring.sum(springs.get(a), springs.get(b)));
+        }
+
+        public int max(int a, int b) {
+            return s(Spring.max(springs.get(a), springs.get(b)));
+        }
+
+        public int minus(int a) {
+            return s(Spring.minus(springs.get(a)));
+        }
+
+        public int scale(int a, float factor) {
+            return s(Spring.scale(springs.get(a), factor));
+        }
+
+        public int width(int comp) {
+            return s(Spring.width(c(comp)));
+        }
+
+        public int height(int comp) {
+            return s(Spring.height(c(comp)));
+        }
+
+        public int edge(String edge, int comp) {
+            return s(layout.getConstraint(edge, c(comp)));
+        }
+
+        public int constraint(String edge, int comp) {
+            return s(layout.getConstraints(c(comp)).getConstraint(edge));
+        }
+
+        public void put(String e1, int c1, int pad, String e2, int c2) {
+            layout.putConstraint(e1, c(c1), pad, e2, c(c2));
+        }
+
+        public void putSpring(String e1, int c1, int spring, String e2, int c2) {
+            layout.putConstraint(e1, c(c1), springs.get(spring), e2, c(c2));
+        }
+
+        public void set(int comp, String edge, int spring) {
+            layout.getConstraints(c(comp)).setConstraint(edge, spring < 0 ? null : springs.get(spring));
+        }
+
+        public void setValue(int spring, int value) {
+            springs.get(spring).setValue(value);
+        }
+
+        public String spring(int spring) {
+            if (spring < 0) {
+                return "null";
+            }
+            Spring s = springs.get(spring);
+            return s.getMinimumValue() + "/" + s.getPreferredValue() + "/" + s.getMaximumValue() + "=" + s.getValue();
+        }
+
+        public String layout(int w, int h) {
+            host.setSize(w, h);
+            layout.layoutContainer(host);
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < comps.size(); i++) {
+                Component k = comps.get(i);
+                if (k.getParent() != host) {
+                    continue;
+                }
+                sb.append(i).append(' ').append(k.getX()).append(',').append(k.getY()).append(' ')
+                        .append(k.getWidth()).append('x').append(k.getHeight()).append('\n');
+            }
+            return sb.toString();
+        }
+
+        public String sizes() {
+            Dimension p = layout.preferredLayoutSize(host);
+            Dimension m = layout.minimumLayoutSize(host);
+            Dimension x = layout.maximumLayoutSize(host);
+            return "pref=" + p.width + "x" + p.height + " min=" + m.width + "x" + m.height + " max=" + x.width + "x"
+                    + x.height + " align=" + layout.getLayoutAlignmentX(host) + "," + layout.getLayoutAlignmentY(host);
+        }
+    }
+
+    // ------------------------------------------------------------------
+
+    private static String play(Side side, Script script) {
+        StringBuilder out = new StringBuilder();
+        try {
+            script.run(side, out);
+        } catch (RuntimeException e) {
+            out.append("threw ").append(e.getClass().getSimpleName()).append('\n');
+        }
+        return out.toString();
+    }
+
+    private static String check(String what, Script script) {
+        String real = play(new Real(), script);
+        String ours = play(new Ours(), script);
+        assertEquals(what, real, ours);
+        assertTrue(what + ": nothing was observed", real.length() > 0);
+        return real;
+    }
+
+    private static int leaf(Side s, int w, int h) {
+        return s.comp(w, h, w, h, -1, -1, -1);
+    }
+
+    private static int flexible(Side s, int w, int h) {
+        return s.comp(w, h, w / 2, h / 2, w * 3, h * 2, -1);
+    }
+
+    private static void observe(Side s, StringBuilder out, int... sizes) {
+        out.append(s.sizes()).append('\n');
+        for (int i = 0; i + 1 < sizes.length; i += 2) {
+            out.append(sizes[i]).append('x').append(sizes[i + 1]).append('\n').append(s.layout(sizes[i], sizes[i + 1]));
+        }
+        out.append(s.sizes()).append('\n');
+    }
+
+    private static void describe(Side s, StringBuilder out, int comp) {
+        String[] all = {W, E, HC, WD, N, S, VC, HT};
+        for (String e : all) {
+            out.append(comp).append('.').append(e).append(' ').append(s.spring(s.constraint(e, comp))).append(' ')
+                    .append(s.spring(s.edge(e, comp))).append('\n');
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Spring arithmetic
+
+    @Test
+    public void constantSprings() {
+        check("constants", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.constant(7);
+                int b = s.constant(2, 10, 40);
+                int c = s.constant(-30, -5, 3);
+                int[] all = {a, b, c};
+                int[] values = {0, 5, 10, 100, -100, 40, 2, Integer.MIN_VALUE, 12, 12, Integer.MAX_VALUE};
+                for (int sp : all) {
+                    out.append(s.spring(sp)).append('\n');
+                    for (int v : values) {
+                        s.setValue(sp, v);
+                        out.append(v).append(" -> ").append(s.spring(sp)).append('\n');
+                    }
+                }
+            }
+        });
+    }
+
+    @Test
+    public void sumsSpreadTheStrain() {
+        check("sum", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.constant(10, 20, 100);
+                int b = s.constant(0, 30, 40);
+                int sum = s.sum(a, b);
+                int[] values = {50, 70, 140, 200, 10, 25, 0, -40, 51, 49, Integer.MIN_VALUE, 33};
+                out.append(s.spring(sum)).append('\n');
+                for (int v : values) {
+                    s.setValue(sum, v);
+                    out.append(v).append(" -> ").append(s.spring(sum)).append(" = ").append(s.spring(a)).append(" + ")
+                            .append(s.spring(b)).append('\n');
+                }
+            }
+        });
+        check("sum of rigid springs", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.constant(20);
+                int b = s.constant(5, 30, 30);
+                int sum = s.sum(a, b);
+                int[] values = {50, 70, 30, 49, 51, Integer.MIN_VALUE, 50};
+                for (int v : values) {
+                    s.setValue(sum, v);
+                    out.append(v).append(" -> ").append(s.spring(sum)).append(" = ").append(s.spring(a)).append(" + ")
+                            .append(s.spring(b)).append('\n');
+                }
+            }
+        });
+        check("nested sums", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.constant(1, 10, 30);
+                int b = s.constant(5, 10, 12);
+                int c = s.constant(0, 40, 400);
+                int ab = s.sum(a, b);
+                int abc = s.sum(ab, c);
+                int twice = s.sum(abc, abc);
+                int[] values = {60, 120, 300, 20, 6, 61, Integer.MIN_VALUE};
+                for (int v : values) {
+                    s.setValue(abc, v);
+                    out.append(v).append(" -> ").append(s.spring(abc)).append(' ').append(s.spring(ab)).append(' ')
+                            .append(s.spring(a)).append(' ').append(s.spring(b)).append(' ').append(s.spring(c))
+                            .append(' ').append(s.spring(twice)).append('\n');
+                }
+                s.setValue(twice, 200);
+                out.append(s.spring(twice)).append(' ').append(s.spring(abc)).append(' ').append(s.spring(a))
+                        .append('\n');
+            }
+        });
+    }
+
+    @Test
+    public void maximaHandTheValueToBoth() {
+        check("max", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.constant(10, 20, 100);
+                int b = s.constant(0, 30, 40);
+                int max = s.max(a, b);
+                int[] values = {30, 35, 90, 5, Integer.MIN_VALUE, 22};
+                out.append(s.spring(max)).append('\n');
+                for (int v : values) {
+                    s.setValue(max, v);
+                    out.append(v).append(" -> ").append(s.spring(max)).append(" of ").append(s.spring(a))
+                            .append(" and ").append(s.spring(b)).append('\n');
+                }
+                // The properties are kept from the first time they are read.
+                s.setValue(a, 60);
+                out.append(s.spring(max)).append('\n');
+                s.setValue(max, Integer.MIN_VALUE);
+                out.append(s.spring(max)).append(' ').append(s.spring(a)).append('\n');
+            }
+        });
+    }
+
+    @Test
+    public void negationAndScaling() {
+        check("minus", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.constant(10, 20, 100);
+                int neg = s.minus(a);
+                int back = s.minus(neg);
+                int diff = s.sum(s.constant(0, 200, 500), neg);
+                int[] values = {-20, -50, -5, 30, Integer.MIN_VALUE, -21};
+                out.append(s.spring(neg)).append(' ').append(s.spring(back)).append(' ').append(s.spring(diff))
+                        .append('\n');
+                for (int v : values) {
+                    s.setValue(neg, v);
+                    out.append(v).append(" -> ").append(s.spring(neg)).append(' ').append(s.spring(a)).append(' ')
+                            .append(s.spring(back)).append('\n');
+                }
+                s.setValue(diff, 300);
+                out.append(s.spring(diff)).append(' ').append(s.spring(a)).append('\n');
+                s.setValue(diff, 100);
+                out.append(s.spring(diff)).append(' ').append(s.spring(a)).append('\n');
+            }
+        });
+        final float[] factors = {0.5f, 2f, 1f, -1f, -0.5f, 0.33f, 1.5f, 3.7f, -2.25f, 0.1f};
+        for (final float f : factors) {
+            check("scale by " + f, new Script() {
+                public void run(Side s, StringBuilder out) {
+                    int a = s.constant(11, 21, 101);
+                    int scaled = s.scale(a, f);
+                    int[] values = {10, 11, 25, 63, -17, -40, 0, Integer.MIN_VALUE, 7};
+                    out.append(s.spring(scaled)).append('\n');
+                    for (int v : values) {
+                        s.setValue(scaled, v);
+                        out.append(v).append(" -> ").append(s.spring(scaled)).append(' ').append(s.spring(a))
+                                .append('\n');
+                    }
+                }
+            });
+        }
+    }
+
+    @Test
+    public void componentSprings() {
+        check("width and height", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.comp(80, 20, 30, 10, 300, 60, -1);
+                int b = leaf(s, 55, 33);
+                int[] all = {s.width(a), s.height(a), s.width(b), s.height(b), s.sum(s.width(a), s.width(b)),
+                    s.max(s.height(a), s.height(b)), s.scale(s.width(a), 0.5f), s.minus(s.height(a))};
+                int[] values = {40, 100, 0, Integer.MIN_VALUE, 500};
+                for (int sp : all) {
+                    out.append(s.spring(sp)).append('\n');
+                    for (int v : values) {
+                        s.setValue(sp, v);
+                        out.append(v).append(" -> ").append(s.spring(sp)).append('\n');
+                    }
+                }
+            }
+        });
+    }
+
+    @Test
+    public void nullArgumentsAreRejectedAlike() {
+        check("scale(null)", new Script() {
+            public void run(Side s, StringBuilder out) {
+                out.append("scale\n");
+                if (s instanceof Real) {
+                    javax.swing.Spring.scale(null, 2f);
+                } else {
+                    Spring.scale(null, 2f);
+                }
+            }
+        });
+        check("width(null)", new Script() {
+            public void run(Side s, StringBuilder out) {
+                out.append("width\n");
+                if (s instanceof Real) {
+                    javax.swing.Spring.width(null);
+                } else {
+                    Spring.width(null);
+                }
+            }
+        });
+        check("height(null)", new Script() {
+            public void run(Side s, StringBuilder out) {
+                out.append("height\n");
+                if (s instanceof Real) {
+                    javax.swing.Spring.height(null);
+                } else {
+                    Spring.height(null);
+                }
+            }
+        });
+    }
+
+    @Test
+    public void randomSpringArithmetic() {
+        for (int seed = 0; seed < 400; seed++) {
+            final int fseed = seed;
+            check("random springs " + seed, new Script() {
+                public void run(Side s, StringBuilder out) {
+                    Random rnd = new Random(7000 + fseed);
+                    List<Integer> all = new ArrayList<Integer>();
+                    int leaves = 2 + rnd.nextInt(3);
+                    for (int i = 0; i < leaves; i++) {
+                        int min = rnd.nextInt(40) - 10;
+                        int pref = min + rnd.nextInt(40);
+                        int max = pref + rnd.nextInt(60);
+                        all.add(rnd.nextInt(5) == 0 ? s.constant(pref) : s.constant(min, pref, max));
+                    }
+                    int ops = 2 + rnd.nextInt(6);
+                    for (int i = 0; i < ops; i++) {
+                        int a = all.get(rnd.nextInt(all.size()));
+                        int b = all.get(rnd.nextInt(all.size()));
+                        switch (rnd.nextInt(4)) {
+                            case 0:
+                                all.add(s.sum(a, b));
+                                break;
+                            case 1:
+                                all.add(s.max(a, b));
+                                break;
+                            case 2:
+                                all.add(s.minus(a));
+                                break;
+                            default:
+                                all.add(s.scale(a, (rnd.nextInt(17) - 8) / 4f + 0.125f));
+                                break;
+                        }
+                    }
+                    for (int step = 0; step < 8; step++) {
+                        int target = all.get(rnd.nextInt(all.size()));
+                        int v = rnd.nextInt(6) == 0 ? Integer.MIN_VALUE : rnd.nextInt(400) - 100;
+                        s.setValue(target, v);
+                        out.append(target).append(" := ").append(v).append('\n');
+                        for (int sp : all) {
+                            out.append("  ").append(s.spring(sp)).append('\n');
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Layouts
+
+    @Test
+    public void defaultsPlaceEverythingAtTheOrigin() {
+        check("defaults", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = flexible(s, 80, 20);
+                int b = leaf(s, 40, 44);
+                s.add(a);
+                s.add(b);
+                observe(s, out, 300, 200, 0, 0, 10, 10);
+                describe(s, out, a);
+                describe(s, out, HOST);
+            }
+        });
+        check("empty", new Script() {
+            public void run(Side s, StringBuilder out) {
+                s.border(3, 4, 5, 6);
+                observe(s, out, 300, 200, 0, 0);
+            }
+        });
+    }
+
+    @Test
+    public void constraintChains() {
+        check("a row", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = leaf(s, 80, 20);
+                int b = leaf(s, 40, 44);
+                int c = flexible(s, 60, 30);
+                s.add(a);
+                s.add(b);
+                s.add(c);
+                s.put(W, a, 5, W, HOST);
+                s.put(N, a, 7, N, HOST);
+                s.put(W, b, 6, E, a);
+                s.put(N, b, 0, N, a);
+                s.put(W, c, 9, E, b);
+                s.put(N, c, 3, S, b);
+                s.put(E, HOST, 5, E, c);
+                s.put(S, HOST, 11, S, c);
+                observe(s, out, 400, 300, 215, 115, 100, 50, 0, 0);
+                describe(s, out, c);
+                describe(s, out, HOST);
+            }
+        });
+        check("a column from the bottom right", new Script() {
+            public void run(Side s, StringBuilder out) {
+                s.border(4, 9, 2, 13);
+                int a = leaf(s, 80, 20);
+                int b = leaf(s, 40, 44);
+                int c = leaf(s, 61, 31);
+                s.add(a);
+                s.add(b);
+                s.add(c);
+                s.put(E, a, -5, E, HOST);
+                s.put(S, a, -5, S, HOST);
+                s.put(E, b, 0, E, a);
+                s.put(S, b, -8, N, a);
+                s.put(HC, c, 0, HC, b);
+                s.put(VC, c, -60, VC, b);
+                observe(s, out, 400, 300, 150, 90, 0, 0);
+                describe(s, out, b);
+                describe(s, out, c);
+            }
+        });
+        check("stretching between two edges", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = leaf(s, 80, 20);
+                int b = flexible(s, 40, 44);
+                s.add(a);
+                s.add(b);
+                s.put(W, a, 10, W, HOST);
+                s.put(E, a, -10, E, HOST);
+                s.put(N, a, 10, N, HOST);
+                s.put(W, b, 0, W, a);
+                s.put(E, b, 0, HC, a);
+                s.put(N, b, 5, S, a);
+                s.put(S, b, -5, S, HOST);
+                observe(s, out, 400, 300, 150, 90, 20, 20, 0, 0);
+                describe(s, out, a);
+                describe(s, out, b);
+            }
+        });
+        check("springs between components", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = flexible(s, 80, 20);
+                int b = flexible(s, 40, 44);
+                s.add(a);
+                s.add(b);
+                int gap = s.constant(2, 10, 100);
+                s.putSpring(W, a, gap, W, HOST);
+                s.putSpring(W, b, s.constant(0, 6, 60), E, a);
+                s.putSpring(E, HOST, s.constant(2, 10, 100), E, b);
+                s.putSpring(N, a, s.constant(0, 5, 50), N, HOST);
+                s.putSpring(N, b, s.constant(0, 5, 50), N, HOST);
+                s.putSpring(S, HOST, s.constant(0, 5, 50), S, b);
+                observe(s, out, 146, 54, 400, 300, 100, 30, 60, 20, 0, 0, 2000, 900);
+                describe(s, out, a);
+                describe(s, out, b);
+                describe(s, out, HOST);
+            }
+        });
+    }
+
+    @Test
+    public void aForm() {
+        check("form", new Script() {
+            public void run(Side s, StringBuilder out) {
+                s.border(8, 8, 8, 8);
+                int rows = 4;
+                int[] labels = new int[rows];
+                int[] fields = new int[rows];
+                int[] lw = {40, 95, 62, 18};
+                int labelWidth = -1;
+                for (int i = 0; i < rows; i++) {
+                    labels[i] = leaf(s, lw[i], 16);
+                    fields[i] = s.comp(120, 22 + i, 30, 22 + i, 2000, 22 + i, -1);
+                    s.add(labels[i]);
+                    s.add(fields[i]);
+                    int w = s.width(labels[i]);
+                    labelWidth = labelWidth < 0 ? w : s.max(labelWidth, w);
+                }
+                int ok = leaf(s, 70, 26);
+                int cancel = leaf(s, 84, 26);
+                s.add(ok);
+                s.add(cancel);
+                for (int i = 0; i < rows; i++) {
+                    s.put(W, labels[i], 0, W, HOST);
+                    s.set(labels[i], WD, labelWidth);
+                    s.put(W, fields[i], 6, E, labels[i]);
+                    s.put(E, fields[i], 0, E, HOST);
+                    if (i == 0) {
+                        s.put(N, fields[i], 0, N, HOST);
+                    } else {
+                        s.put(N, fields[i], 5, S, fields[i - 1]);
+                    }
+                    s.put(VC, labels[i], 0, VC, fields[i]);
+                }
+                s.put(E, cancel, 0, E, HOST);
+                s.put(E, ok, -6, W, cancel);
+                s.put(N, cancel, 12, S, fields[rows - 1]);
+                s.put(N, ok, 0, N, cancel);
+                s.put(S, HOST, 0, S, cancel);
+                observe(s, out, 237, 177, 500, 400, 180, 120, 60, 60, 0, 0);
+                out.append(s.spring(labelWidth)).append('\n');
+                for (int i = 0; i < rows; i++) {
+                    describe(s, out, labels[i]);
+                    describe(s, out, fields[i]);
+                }
+                describe(s, out, ok);
+                describe(s, out, HOST);
+            }
+        });
+    }
+
+    @Test
+    public void theTwoMostRecentConstraintsStand() {
+        final String[][] orders = {{W, E, WD}, {W, WD, E}, {E, WD, W}, {WD, E, W}, {HC, W, E}, {W, HC, WD},
+            {WD, HC, W}, {W, E, W}, {W, W, E}, {E, W, HC}, {WD, W, HC}, {HC, WD, E}, {W, E, HC, WD}, {E, HC}, {HC, E}, {W, E, HC}, {WD, HC, E}};
+        for (final String[] order : orders) {
+            check("horizontal " + java.util.Arrays.toString(order), new Script() {
+                public void run(Side s, StringBuilder out) {
+                    int a = flexible(s, 80, 20);
+                    s.add(a);
+                    for (int i = 0; i < order.length; i++) {
+                        String e = order[i];
+                        if (WD.equals(e)) {
+                            s.set(a, WD, s.constant(30 + i, 50 + i, 70 + i));
+                        } else {
+                            s.put(e, a, W.equals(e) ? 13 + i : E.equals(e) ? -17 - i : 4 + i, e, HOST);
+                        }
+                    }
+                    observe(s, out, 300, 200, 100, 50, 0, 0);
+                    describe(s, out, a);
+                }
+            });
+        }
+        final String[][] vertical = {{N, S, HT}, {N, HT, S}, {S, HT, N}, {HT, S, N}, {VC, N, S}, {N, VC, HT},
+            {HT, VC, N}, {N, S, N}, {S, N, VC}, {HT, N, VC}, {VC, HT, S}, {N, S, VC, HT}, {S, VC}, {VC, S}, {N, S, VC}, {HT, VC, S}};
+        for (final String[] order : vertical) {
+            check("vertical " + java.util.Arrays.toString(order), new Script() {
+                public void run(Side s, StringBuilder out) {
+                    int a = flexible(s, 80, 20);
+                    s.add(a);
+                    for (int i = 0; i < order.length; i++) {
+                        String e = order[i];
+                        if (HT.equals(e)) {
+                            s.set(a, HT, s.constant(30 + i, 50 + i, 70 + i));
+                        } else {
+                            s.put(e, a, N.equals(e) ? 13 + i : S.equals(e) ? -17 - i : 4 + i, e, HOST);
+                        }
+                    }
+                    observe(s, out, 300, 200, 100, 50, 0, 0);
+                    describe(s, out, a);
+                }
+            });
+        }
+    }
+
+    @Test
+    public void constraintObjects() {
+        check("constraints given when adding", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = flexible(s, 80, 20);
+                int b = leaf(s, 40, 44);
+                int c = leaf(s, 61, 31);
+                int d = leaf(s, 25, 26);
+                int e = leaf(s, 27, 28);
+                s.addWith(a, s.constant(12), s.constant(0, 14, 90), -1, -1);
+                s.addWith(b, s.constant(100), s.constant(50), s.constant(10, 66, 90), s.constant(33));
+                s.addWith(c, -1, -1, -1, -1);
+                s.addAsIs(d, 140, 9);
+                s.addWithProperty(e, s.constant(200), s.constant(120));
+                observe(s, out, 400, 300, 0, 0);
+                for (int k = 0; k < 5; k++) {
+                    describe(s, out, k);
+                }
+            }
+        });
+        check("clearing and replacing a constraint", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = flexible(s, 80, 20);
+                int b = leaf(s, 40, 44);
+                s.add(a);
+                s.add(b);
+                s.put(W, a, 20, W, HOST);
+                s.put(W, b, 5, E, a);
+                observe(s, out, 300, 200);
+                s.put(W, a, 60, W, HOST);
+                observe(s, out, 300, 200);
+                s.set(a, W, -1);
+                describe(s, out, a);
+                s.set(a, "Nowhere", s.constant(3));
+                out.append(s.spring(s.constraint("Nowhere", a))).append('\n');
+                s.set(a, E, s.constant(250));
+                observe(s, out, 300, 200);
+                describe(s, out, a);
+                describe(s, out, b);
+            }
+        });
+        check("removing a component forgets its constraints", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = leaf(s, 80, 20);
+                int b = leaf(s, 40, 44);
+                s.add(a);
+                s.add(b);
+                s.put(W, a, 20, W, HOST);
+                s.put(N, a, 30, N, HOST);
+                s.put(W, b, 5, E, a);
+                observe(s, out, 300, 200);
+                s.remove(a);
+                observe(s, out, 300, 200);
+                s.add(a);
+                observe(s, out, 300, 200);
+                describe(s, out, a);
+            }
+        });
+    }
+
+    @Test
+    public void baselines() {
+        check("baseline read from a positioned component", new Script() {
+            public void run(Side s, StringBuilder out) {
+                int a = s.comp(80, 30, 80, 30, -1, -1, 21);
+                int b = s.comp(40, 18, 40, 18, -1, -1, 12);
+                int c = leaf(s, 33, 17);
+                s.add(a);
+                s.add(b);
+                s.add(c);
+                s.put(W, a, 5, W, HOST);
+                s.put(N, a, 40, N, HOST);
+                s.put(W, b, 5, E, a);
+                s.put(N, b, 3, BL, a);
+                s.put(W, c, 5, E, b);
+                s.put(S, c, 0, BL, b);
+                observe(s, out, 300, 200, 0, 0);
+                out.append(s.spring(s.edge(BL, a))).append(' ').append(s.spring(s.edge(BL, b))).append(' ')
+                        .append(s.spring(s.edge(BL, c))).append('\n');
+            }
+        });
+    }
+
+    @Test
+    public void cyclesAreAbandoned() {
+        java.io.PrintStream err = System.err;
+        System.setErr(new java.io.PrintStream(new java.io.ByteArrayOutputStream()));
+        try {
+            check("two components each to the right of the other", new Script() {
+                public void run(Side s, StringBuilder out) {
+                    int a = leaf(s, 80, 20);
+                    int b = leaf(s, 40, 44);
+                    int c = leaf(s, 30, 30);
+                    s.add(a);
+                    s.add(b);
+                    s.add(c);
+                    s.put(W, a, 5, E, b);
+                    s.put(W, b, 5, E, a);
+                    s.put(N, c, 9, N, HOST);
+                    s.put(W, c, 9, W, HOST);
+                    s.put(N, a, 4, S, a);
+                    out.append(s.layout(300, 200));
+                    out.append(s.sizes()).append('\n');
+                }
+            });
+        } finally {
+            System.setErr(err);
+        }
+    }
+
+    private static String pick(Random rnd, boolean horizontal) {
+        String[] from = horizontal ? HORIZONTAL : VERTICAL;
+        return from[rnd.nextInt(from.length)];
+    }
+
+    @Test
+    public void randomLayouts() {
+        int laidOut = 0;
+        for (int seed = 0; seed < 500; seed++) {
+            final int fseed = seed;
+            String result = check("random layout " + seed, new Script() {
+                public void run(Side s, StringBuilder out) {
+                    Random rnd = new Random(31000 + fseed);
+                    if (rnd.nextBoolean()) {
+                        s.border(rnd.nextInt(9), rnd.nextInt(9), rnd.nextInt(9), rnd.nextInt(9));
+                    }
+                    int n = 2 + rnd.nextInt(5);
+                    for (int i = 0; i < n; i++) {
+                        int w = 10 + rnd.nextInt(90);
+                        int h = 10 + rnd.nextInt(50);
+                        if (rnd.nextInt(3) == 0) {
+                            leaf(s, w, h);
+                        } else {
+                            s.comp(w, h, rnd.nextInt(w + 1), rnd.nextInt(h + 1), w + rnd.nextInt(200),
+                                    h + rnd.nextInt(100), -1);
+                        }
+                        s.add(i);
+                    }
+                    // A component is only tied to earlier ones, or to the
+                    // container, so that nothing is cyclic. When the far
+                    // edge of the container is itself tied to a component,
+                    // components only refer to its near edge.
+                    boolean tieEast = rnd.nextInt(3) != 0;
+                    boolean tieSouth = rnd.nextInt(3) != 0;
+                    for (int i = 0; i < n; i++) {
+                        for (int axis = 0; axis < 2; axis++) {
+                            boolean horizontal = axis == 0;
+                            int count = rnd.nextInt(4);
+                            for (int k = 0; k < count; k++) {
+                                String e1 = pick(rnd, horizontal);
+                                int target = i == 0 || rnd.nextInt(4) == 0 ? HOST : rnd.nextInt(i);
+                                boolean along = rnd.nextInt(10) == 0 ? !horizontal : horizontal;
+                                String e2 = pick(rnd, along);
+                                boolean rigidHost = target == HOST && (along ? tieEast : tieSouth);
+                                if (rigidHost) {
+                                    e2 = along ? W : N;
+                                }
+                                if (WD.equals(e1) || HT.equals(e1)) {
+                                    if (rigidHost || rnd.nextBoolean()) {
+                                        int min = rnd.nextInt(30);
+                                        int pref = min + rnd.nextInt(60);
+                                        s.set(i, e1, s.constant(min, pref, pref + rnd.nextInt(90)));
+                                        continue;
+                                    }
+                                }
+                                if (rnd.nextInt(3) == 0) {
+                                    int min = rnd.nextInt(10);
+                                    int pref = min + rnd.nextInt(20);
+                                    s.putSpring(e1, i, s.constant(min, pref, pref + rnd.nextInt(60)), e2, target);
+                                } else {
+                                    s.put(e1, i, rnd.nextInt(40) - 8, e2, target);
+                                }
+                            }
+                        }
+                    }
+                    if (tieEast) {
+                        s.put(E, HOST, rnd.nextInt(12), E, rnd.nextInt(n));
+                    }
+                    if (tieSouth) {
+                        s.put(S, HOST, rnd.nextInt(12), S, rnd.nextInt(n));
+                    }
+                    observe(s, out, 400, 300, 150, 100, 37, 23, 0, 0, 900, 700);
+                    for (int i = 0; i < n; i++) {
+                        describe(s, out, i);
+                    }
+                    describe(s, out, HOST);
+                }
+            });
+            if (result.indexOf("threw") < 0) {
+                laidOut++;
+            }
+        }
+        assertTrue("only " + laidOut + " of 500 random layouts ran to the end", laidOut > 450);
+    }
+
+    // ------------------------------------------------------------------
+    // Behaviour that is this layer's own
+
+    private static JComponent box(int w, int h) {
+        JComponent c = new JComponent() {
+        };
+        c.setPreferredSize(new Dimension(w, h));
+        c.setMinimumSize(new Dimension(w, h));
+        return c;
+    }
+
+    private static void assertBounds(Component c, int x, int y, int w, int h) {
+        assertEquals(x + "," + y + " " + w + "x" + h,
+                c.getX() + "," + c.getY() + " " + c.getWidth() + "x" + c.getHeight());
+    }
+
+    /// With the baseline as one of two constraints that leave the height
+    /// open, the component keeps its preferred height.
+    @Test
+    public void aBaselineAndAnEdgeKeepThePreferredHeight() {
+        JPanel host = new JPanel();
+        SpringLayout layout = new SpringLayout();
+        host.setLayout(layout);
+        JComponent a = box(80, 20);
+        host.add(a);
+        layout.putConstraint(SpringLayout.BASELINE, a, 50, SpringLayout.NORTH, host);
+        layout.putConstraint(SpringLayout.SOUTH, a, -10, SpringLayout.SOUTH, host);
+        host.setSize(300, 200);
+        layout.layoutContainer(host);
+        assertBounds(a, 0, 170, 80, 20);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/StyledTextTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/StyledTextTest.java
new file mode 100644
index 00000000000..73f57d71f37
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/StyledTextTest.java
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+import com.codename1.desktopcompat.javax.swing.event.DocumentEvent;
+import com.codename1.desktopcompat.javax.swing.event.DocumentListener;
+import com.codename1.desktopcompat.javax.swing.text.AttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.BadLocationException;
+import com.codename1.desktopcompat.javax.swing.text.DefaultStyledDocument;
+import com.codename1.desktopcompat.javax.swing.text.Element;
+import com.codename1.desktopcompat.javax.swing.text.MutableAttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.PlainDocument;
+import com.codename1.desktopcompat.javax.swing.text.SimpleAttributeSet;
+import com.codename1.desktopcompat.javax.swing.text.Style;
+import com.codename1.desktopcompat.javax.swing.text.StyleConstants;
+import com.codename1.desktopcompat.javax.swing.text.StyleContext;
+import com.codename1.desktopcompat.javax.swing.text.StyledDocument;
+import com.codename1.desktopcompat.rt.StyledText;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Styled text: the attributes of a document by run and by paragraph,
+/// the pane that paints them, and the mapping between a point of a text
+/// component and an offset of its document.
+public class StyledTextTest extends KernelTestBase {
+
+    private static SimpleAttributeSet color(Color c) {
+        SimpleAttributeSet a = new SimpleAttributeSet();
+        StyleConstants.setForeground(a, c);
+        return a;
+    }
+
+    @Test
+    public void anAttributeSetKeepsWhatItIsGivenAndAsksItsParentForTheRest() {
+        SimpleAttributeSet parent = new SimpleAttributeSet();
+        StyleConstants.setItalic(parent, true);
+        StyleConstants.setFontSize(parent, 20);
+        SimpleAttributeSet a = new SimpleAttributeSet();
+        assertTrue(a.isEmpty());
+        assertFalse(StyleConstants.isBold(a));
+        assertEquals(12, StyleConstants.getFontSize(a));
+        assertEquals("Monospaced", StyleConstants.getFontFamily(a));
+        assertEquals(Color.black, StyleConstants.getForeground(a));
+        StyleConstants.setBold(a, true);
+        StyleConstants.setUnderline(a, true);
+        StyleConstants.setStrikeThrough(a, true);
+        StyleConstants.setForeground(a, Color.red);
+        StyleConstants.setBackground(a, Color.yellow);
+        StyleConstants.setFontFamily(a, "Serif");
+        StyleConstants.setAlignment(a, StyleConstants.ALIGN_CENTER);
+        a.setResolveParent(parent);
+        assertTrue(StyleConstants.isBold(a));
+        assertTrue(StyleConstants.isUnderline(a));
+        assertTrue(StyleConstants.isStrikeThrough(a));
+        assertTrue("from the parent", StyleConstants.isItalic(a));
+        assertEquals(20, StyleConstants.getFontSize(a));
+        assertFalse(a.isDefined(StyleConstants.Italic));
+        assertEquals(Color.red, StyleConstants.getForeground(a));
+        assertEquals(Color.yellow, StyleConstants.getBackground(a));
+        assertEquals("Serif", StyleConstants.getFontFamily(a));
+        assertEquals(StyleConstants.ALIGN_CENTER, StyleConstants.getAlignment(a));
+        assertSame(parent, a.getResolveParent());
+        AttributeSet copy = a.copyAttributes();
+        assertTrue(copy.isEqual(a));
+        assertEquals(a, copy);
+        a.removeAttribute(StyleConstants.Bold);
+        assertFalse(StyleConstants.isBold(a));
+        assertFalse(copy.isEqual(a));
+        assertTrue(a.containsAttribute(StyleConstants.Foreground, Color.red));
+        a.removeAttributes(color(Color.blue));
+        assertTrue("another value is not removed", a.isDefined(StyleConstants.Foreground));
+        a.removeAttributes(color(Color.red));
+        assertFalse(a.isDefined(StyleConstants.Foreground));
+        assertEquals(0, SimpleAttributeSet.EMPTY.getAttributeCount());
+    }
+
+    @Test
+    public void aStyleTellsItsListenersAndAContextKeepsItByName() {
+        StyleContext context = new StyleContext();
+        Style def = context.getStyle(StyleContext.DEFAULT_STYLE);
+        assertNotNull(def);
+        assertEquals("default", def.getName());
+        Style warn = context.addStyle("warn", def);
+        assertSame(warn, context.getStyle("warn"));
+        assertSame(def, warn.getResolveParent());
+        final int[] changes = {0};
+        warn.addChangeListener(new com.codename1.desktopcompat.javax.swing.event.ChangeListener() {
+            @Override
+            public void stateChanged(com.codename1.desktopcompat.javax.swing.event.ChangeEvent e) {
+                changes[0]++;
+            }
+        });
+        StyleConstants.setForeground(warn, Color.red);
+        assertEquals(1, changes[0]);
+        StyleConstants.setBold(def, true);
+        assertTrue("through the parent", StyleConstants.isBold(warn));
+        Font f = context.getFont(warn);
+        assertTrue(f.isBold());
+        assertEquals(12, f.getSize());
+        context.removeStyle("warn");
+        assertNull(context.getStyle("warn"));
+    }
+
+    @Test
+    public void aDocumentKeepsTheAttributesOfItsRuns() throws BadLocationException {
+        DefaultStyledDocument doc = new DefaultStyledDocument();
+        doc.insertString(0, "plain ", null);
+        doc.insertString(doc.getLength(), "red", color(Color.red));
+        doc.insertString(doc.getLength(), " tail", null);
+        assertEquals("plain red tail", doc.getText(0, doc.getLength()));
+        Element run = doc.getCharacterElement(7);
+        assertTrue(run.isLeaf());
+        assertEquals(6, run.getStartOffset());
+        assertEquals(9, run.getEndOffset());
+        assertEquals(Color.red, StyleConstants.getForeground(run.getAttributes()));
+        assertNull(doc.getCharacterElement(2).getAttributes().getAttribute(StyleConstants.Foreground));
+        // The last run takes in the break that ends the document.
+        assertEquals(doc.getLength() + 1, doc.getCharacterElement(12).getEndOffset());
+        Element root = doc.getDefaultRootElement();
+        assertEquals(1, root.getElementCount());
+        assertEquals(3, root.getElement(0).getElementCount());
+        assertSame(root, root.getElement(0).getParentElement());
+
+        // Attributes over part of two runs cut both.
+        SimpleAttributeSet bold = new SimpleAttributeSet();
+        StyleConstants.setBold(bold, true);
+        final List<String> events = new ArrayList<String>();
+        doc.addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                events.add("insert");
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                events.add("remove");
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                events.add("change " + e.getOffset() + "+" + e.getLength());
+            }
+        });
+        doc.setCharacterAttributes(4, 4, bold, false);
+        assertEquals("[change 4+4]", events.toString());
+        Element cut = doc.getCharacterElement(7);
+        assertEquals(6, cut.getStartOffset());
+        assertEquals(8, cut.getEndOffset());
+        assertTrue(StyleConstants.isBold(cut.getAttributes()));
+        assertEquals("added, not put in place", Color.red, StyleConstants.getForeground(cut.getAttributes()));
+        assertFalse(StyleConstants.isBold(doc.getCharacterElement(8).getAttributes()));
+        doc.setCharacterAttributes(6, 2, bold, true);
+        assertNull(doc.getCharacterElement(7).getAttributes().getAttribute(StyleConstants.Foreground));
+
+        // What is left of a run that was cut keeps its attributes.
+        doc.remove(4, 4);
+        assertEquals("plaid tail", doc.getText(0, doc.getLength()));
+        assertEquals(Color.red, StyleConstants.getForeground(doc.getCharacterElement(4).getAttributes()));
+        assertEquals(4, doc.getCharacterElement(4).getStartOffset());
+        assertEquals(5, doc.getCharacterElement(4).getEndOffset());
+    }
+
+    @Test
+    public void paragraphsHaveAttributesAndAStyleOfTheirOwn() throws BadLocationException {
+        DefaultStyledDocument doc = new DefaultStyledDocument();
+        doc.insertString(0, "one\ntwo\nthree", null);
+        Element root = doc.getDefaultRootElement();
+        assertEquals(3, root.getElementCount());
+        assertEquals(0, root.getElement(0).getStartOffset());
+        assertEquals(4, root.getElement(0).getEndOffset());
+        assertEquals(4, doc.getParagraphElement(5).getStartOffset());
+        assertEquals(8, doc.getParagraphElement(5).getEndOffset());
+        assertEquals(1, root.getElementIndex(5));
+        SimpleAttributeSet center = new SimpleAttributeSet();
+        StyleConstants.setAlignment(center, StyleConstants.ALIGN_CENTER);
+        doc.setParagraphAttributes(5, 1, center, false);
+        assertEquals(StyleConstants.ALIGN_CENTER, StyleConstants.getAlignment(doc.getParagraphElement(4)
+                .getAttributes()));
+        assertEquals(StyleConstants.ALIGN_LEFT, StyleConstants.getAlignment(doc.getParagraphElement(0)
+                .getAttributes()));
+        // The style a paragraph resolves in gives its runs what they lack.
+        Style loud = doc.addStyle("loud", null);
+        StyleConstants.setForeground(loud, Color.blue);
+        doc.setLogicalStyle(9, loud);
+        assertSame(loud, doc.getLogicalStyle(10));
+        assertEquals("default", doc.getLogicalStyle(0).getName());
+        assertEquals(Color.blue, doc.getCharacterElement(10).getAttributes().getAttribute(StyleConstants.Foreground));
+        assertNull(doc.getCharacterElement(1).getAttributes().getAttribute(StyleConstants.Foreground));
+        // Joining two paragraphs keeps the attributes of the first.
+        doc.remove(3, 1);
+        assertEquals(2, root.getElementCount());
+        assertEquals(StyleConstants.ALIGN_LEFT, StyleConstants.getAlignment(doc.getParagraphElement(4)
+                .getAttributes()));
+        // Splitting one gives both halves its attributes.
+        doc.insertString(doc.getLength(), "\nfour", null);
+        assertEquals(3, root.getElementCount());
+        assertSame(loud, doc.getLogicalStyle(doc.getLength()));
+    }
+
+    private JTextPane pane;
+
+    private JFrame shown(JTextPane p) {
+        pane = p;
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        p.setFont(new Font("Dialog", Font.PLAIN, 14));
+        p.setBackground(Color.white);
+        p.setForeground(new Color(0x10, 0x20, 0x30));
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    @Test
+    public void aTextPaneWantsAStyledDocument() {
+        JTextPane p = new JTextPane();
+        assertTrue(p.getDocument() instanceof StyledDocument);
+        assertSame(p.getDocument(), p.getStyledDocument());
+        try {
+            p.setDocument(new PlainDocument());
+            fail("Model must be StyledDocument");
+        } catch (IllegalArgumentException expected) {
+            assertTrue(p.getDocument() instanceof StyledDocument);
+        }
+        DefaultStyledDocument doc = new DefaultStyledDocument();
+        p.setStyledDocument(doc);
+        assertSame(doc, p.getStyledDocument());
+        Style s = p.addStyle("s", null);
+        assertSame(s, p.getStyle("s"));
+        assertSame(s, doc.getStyle("s"));
+    }
+
+    @Test
+    public void aPaneWithoutAttributesIsAPlainEditableArea() throws BadLocationException {
+        JTextPane p = new JTextPane();
+        p.getStyledDocument().insertString(0, "just text", null);
+        shown(p);
+        assertTrue(p.cn1Peer() instanceof com.codename1.ui.TextArea);
+        assertTrue(((com.codename1.ui.TextArea) p.cn1Peer()).isEditable());
+        assertEquals("just text", ((com.codename1.ui.TextArea) p.cn1Peer()).getText());
+        // The first attribute hands the drawing to the pane.
+        p.getStyledDocument().setCharacterAttributes(0, 4, color(Color.red), false);
+        assertFalse(((com.codename1.ui.TextArea) p.cn1Peer()).isEditable());
+    }
+
+    @Test
+    public void theRunsArePaintedInTheirColorsEachWhereItsTextIs() throws BadLocationException {
+        JTextPane p = new JTextPane();
+        StyledDocument doc = p.getStyledDocument();
+        doc.insertString(0, "aaaa ", null);
+        doc.insertString(doc.getLength(), "bbbb", color(Color.red));
+        SimpleAttributeSet marked = color(Color.blue);
+        StyleConstants.setBackground(marked, Color.yellow);
+        StyleConstants.setUnderline(marked, true);
+        doc.insertString(doc.getLength(), "\ncccc", marked);
+        JFrame f = shown(p);
+        int[][] rows = raster(f);
+        Rectangle a = p.modelToView(0);
+        Rectangle b = p.modelToView(5);
+        Rectangle bEnd = p.modelToView(9);
+        Rectangle c = p.modelToView(10);
+        Rectangle cEnd = p.modelToView(14);
+        assertEquals("the second paragraph is a line down", a.y + a.height, c.y);
+        assertEquals(a.x, c.x);
+        assertTrue(b.x > a.x && bEnd.x > b.x && cEnd.x > c.x);
+        int ink = 0x102030;
+        // A string is drawn as a box of the size it measures.
+        assertTrue("plain text in the pane's color",
+                count(rows, p, a.x, a.y, b.x - a.x, a.height, ink) > 0);
+        assertEquals(0, count(rows, p, a.x, a.y, b.x - a.x, a.height, 0xff0000));
+        assertTrue("the red run", count(rows, p, b.x, b.y, bEnd.x - b.x, b.height, 0xff0000) > 0);
+        assertEquals(0, count(rows, p, b.x, b.y, bEnd.x - b.x, b.height, ink));
+        assertTrue("the blue run", count(rows, p, c.x, c.y, cEnd.x - c.x, c.height, 0x0000ff) > 0);
+        assertEquals("nothing of the first line's colors on the second", 0,
+                count(rows, p, c.x, c.y, cEnd.x - c.x, c.height, 0xff0000));
+
+        // The recorded strings: one per run.
+        List<Object[]> text = paint(f);
+        assertNotNull(find(text, "aaaa "));
+        assertNotNull(find(text, "bbbb"));
+        assertNotNull(find(text, "cccc"));
+        assertEquals(p.getText(), "aaaa bbbb\ncccc");
+    }
+
+    @Test
+    public void aBackgroundStaysUnderItsRun() throws BadLocationException {
+        DefaultStyledDocument doc = new DefaultStyledDocument();
+        SimpleAttributeSet marked = new SimpleAttributeSet();
+        StyleConstants.setBackground(marked, Color.yellow);
+        doc.insertString(0, "    ", marked);
+        doc.insertString(4, "    ", null);
+        JTextPane p = new JTextPane(doc);
+        JFrame f = shown(p);
+        int[][] rows = raster(f);
+        Rectangle from = p.modelToView(0);
+        Rectangle to = p.modelToView(4);
+        Rectangle end = p.modelToView(8);
+        // The run beside the marked one has none of its background.
+        assertTrue(to.x > from.x);
+        assertEquals("no yellow behind the plain run", 0,
+                count(rows, p, to.x, to.y, end.x - to.x, to.height, 0xffff00));
+        StyledText layout = new StyledText(doc, p.getFont(), Color.black, 400);
+        assertEquals(1, layout.getLineCount());
+        assertTrue(StyledText.styled(doc));
+        assertFalse(StyledText.styled(new DefaultStyledDocument()));
+    }
+
+    @Test
+    public void aParagraphIsBrokenAtItsSpacesAndAlignedAsItAsks() throws BadLocationException {
+        DefaultStyledDocument doc = new DefaultStyledDocument();
+        doc.insertString(0, "aaaa bbbb cccc dddd", color(Color.red));
+        Font font = new Font("Dialog", Font.PLAIN, 14);
+        StyledText whole = new StyledText(doc, font, Color.black, 0);
+        assertEquals(1, whole.getLineCount());
+        int four = whole.caretAt(4).x;
+        int five = whole.caretAt(5).x;
+        int all = whole.getWidth();
+        // Room for two words and no more.
+        StyledText narrow = new StyledText(doc, font, Color.black, five + four + 1);
+        assertEquals(2, narrow.getLineCount());
+        assertEquals(0, narrow.caretAt(0).y);
+        assertEquals("the third word starts the second line", 0, narrow.caretAt(10).x);
+        assertEquals(narrow.caretAt(0).height, narrow.caretAt(10).y);
+        assertEquals(10, narrow.offsetAt(0, narrow.caretAt(10).y + 1));
+        assertEquals(narrow.getHeight(), 2 * narrow.caretAt(0).height);
+        // A word wider than the room is broken where it must be.
+        StyledText tiny = new StyledText(doc, font, Color.black, Math.max(1, four / 2));
+        assertTrue(tiny.getLineCount() >= 8);
+        // The nearer half of a character decides.
+        int one = whole.caretAt(1).x;
+        assertEquals(0, whole.offsetAt(one / 2 - 1, 1));
+        assertEquals(1, whole.offsetAt(one / 2 + 1, 1));
+        assertEquals(19, whole.offsetAt(all + 50, 1));
+        assertEquals("below the last line is on it", 10, narrow.offsetAt(0, 5000));
+
+        SimpleAttributeSet right = new SimpleAttributeSet();
+        StyleConstants.setAlignment(right, StyleConstants.ALIGN_RIGHT);
+        doc.setParagraphAttributes(0, 1, right, false);
+        StyledText aligned = new StyledText(doc, font, Color.black, all + 100);
+        assertEquals(100, aligned.caretAt(0).x);
+        StyleConstants.setAlignment(right, StyleConstants.ALIGN_CENTER);
+        doc.setParagraphAttributes(0, 1, right, false);
+        assertEquals(50, new StyledText(doc, font, Color.black, all + 100).caretAt(0).x);
+    }
+
+    @Test
+    public void aRunInAnotherFontStandsAfterTheRunBeforeIt() throws BadLocationException {
+        DefaultStyledDocument doc = new DefaultStyledDocument();
+        SimpleAttributeSet big = new SimpleAttributeSet();
+        StyleConstants.setFontSize(big, 28);
+        StyleConstants.setBold(big, true);
+        doc.insertString(0, "xx", null);
+        doc.insertString(2, "XX", big);
+        Font font = new Font("Dialog", Font.PLAIN, 14);
+        StyledText layout = new StyledText(doc, font, Color.black, 0);
+        StyledText plain = new StyledText(new DefaultStyledDocument() {
+            {
+                try {
+                    insertString(0, "xx", null);
+                } catch (BadLocationException e) {
+                    throw new IllegalStateException(e);
+                }
+            }
+        }, font, Color.black, 0);
+        assertEquals(plain.getWidth(), layout.caretAt(2).x);
+        assertTrue(layout.getWidth() > plain.getWidth());
+        assertTrue("a line is at least as high as the pane's font", layout.getHeight() >= plain.getHeight());
+        assertEquals(1, layout.getLineCount());
+    }
+
+    @Test
+    public void thePaneGivesTheSelectionAttributesAndInsertsWithItsInputAttributes() throws BadLocationException {
+        JTextPane p = new JTextPane();
+        p.setText("hello world");
+        p.select(6, 11);
+        p.setCharacterAttributes(color(Color.red), false);
+        StyledDocument doc = p.getStyledDocument();
+        assertEquals(Color.red, StyleConstants.getForeground(doc.getCharacterElement(7).getAttributes()));
+        assertNull(doc.getCharacterElement(1).getAttributes().getAttribute(StyleConstants.Foreground));
+        // With nothing selected the attributes are those of what is typed.
+        p.setCaretPosition(0);
+        MutableAttributeSet in = p.getInputAttributes();
+        assertEquals(0, in.getAttributeCount());
+        p.setCharacterAttributes(color(Color.blue), true);
+        assertEquals(Color.blue, StyleConstants.getForeground(in));
+        p.replaceSelection("> ");
+        assertEquals("> hello world", p.getText());
+        assertEquals(Color.blue, StyleConstants.getForeground(doc.getCharacterElement(0).getAttributes()));
+        assertEquals(Color.red, StyleConstants.getForeground(doc.getCharacterElement(9).getAttributes()));
+        SimpleAttributeSet center = new SimpleAttributeSet();
+        StyleConstants.setAlignment(center, StyleConstants.ALIGN_CENTER);
+        p.setParagraphAttributes(center, false);
+        assertEquals(StyleConstants.ALIGN_CENTER, StyleConstants.getAlignment(p.getParagraphAttributes()));
+    }
+
+    @Test
+    public void aPointOfATextAreaFindsItsOffsetAndBack() throws BadLocationException {
+        JFrame f = new JFrame();
+        f.setLayout(new BorderLayout());
+        JTextArea area = new JTextArea("abcdef\nghij\n\nklm");
+        assertEquals("no size yet", -1, area.viewToModel(new Point(3, 3)));
+        assertNull(area.modelToView(0));
+        f.add(area, BorderLayout.CENTER);
+        show(f);
+        Rectangle first = area.modelToView(0);
+        Rectangle third = area.modelToView(3);
+        Rectangle second = area.modelToView(8);
+        Rectangle empty = area.modelToView(12);
+        Rectangle last = area.modelToView(14);
+        assertEquals(1, first.width);
+        assertTrue(first.height > 0);
+        assertTrue(third.x > first.x);
+        assertEquals(first.y, third.y);
+        assertEquals(first.y + first.height, second.y);
+        assertEquals(first.y + 2 * first.height, empty.y);
+        assertEquals(first.x, empty.x);
+        assertEquals(first.y + 3 * first.height, last.y);
+        assertEquals(3, area.viewToModel(new Point(third.x, third.y + 2)));
+        assertEquals(8, area.viewToModel(new Point(second.x, second.y + 2)));
+        assertEquals(12, area.viewToModel(new Point(first.x + 200, empty.y + 2)));
+        assertEquals("past the end of a row is its end", 6, area.viewToModel(new Point(first.x + 2000, first.y + 2)));
+        assertEquals(14, area.viewToModel2D(new Point2D.Double(last.x, last.y + 2)));
+        assertEquals(last, area.modelToView2D(14));
+        try {
+            area.modelToView(99);
+            fail("an offset outside the document");
+        } catch (BadLocationException expected) {
+            assertEquals(99, expected.offsetRequested());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SwingWorkerTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SwingWorkerTest.java
new file mode 100644
index 00000000000..985253baf36
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/SwingWorkerTest.java
@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.ui.Display;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The worker's life as an application sees it from the event dispatch
+/// thread, which is where every test here runs.
+public class SwingWorkerTest extends KernelTestBase {
+
+    /// Keeps the event dispatch thread dispatching until `flag` is set.
+    private static void pumpUntil(final AtomicBoolean flag) {
+        final long deadline = System.currentTimeMillis() + 10000;
+        Display.getInstance().invokeAndBlock(new Runnable() {
+            @Override
+            public void run() {
+                while (!flag.get() && System.currentTimeMillis() < deadline) {
+                    try {
+                        Thread.sleep(2);
+                    } catch (InterruptedException e) {
+                        return;
+                    }
+                }
+            }
+        });
+        assertTrue("timed out", flag.get());
+    }
+
+    private static final class Log implements PropertyChangeListener {
+        final List<String> events = new ArrayList<String>();
+        final List<Boolean> onEdt = new ArrayList<Boolean>();
+
+        @Override
+        public void propertyChange(PropertyChangeEvent e) {
+            events.add(e.getPropertyName() + ":" + e.getOldValue() + ">" + e.getNewValue());
+            onEdt.add(Boolean.valueOf(Display.getInstance().isEdt()));
+        }
+    }
+
+    @Test
+    public void stateAndProgressEventsArriveInOrderOnTheEventDispatchThread() throws Exception {
+        final AtomicBoolean finished = new AtomicBoolean();
+        final boolean[] backgroundOnEdt = {true};
+        final boolean[] doneOnEdt = {false};
+        final List<String> order = new ArrayList<String>();
+        final Log log = new Log();
+        SwingWorker<String, Void> w = new SwingWorker<String, Void>() {
+            @Override
+            protected String doInBackground() {
+                backgroundOnEdt[0] = Display.getInstance().isEdt();
+                setProgress(40);
+                setProgress(40);
+                setProgress(100);
+                return "answer";
+            }
+
+            @Override
+            protected void done() {
+                doneOnEdt[0] = Display.getInstance().isEdt();
+                order.addAll(log.events);
+                finished.set(true);
+            }
+        };
+        w.addPropertyChangeListener(log);
+        assertSame(SwingWorker.StateValue.PENDING, w.getState());
+        assertFalse(w.isDone());
+        w.execute();
+        w.execute();
+        pumpUntil(finished);
+        assertFalse(backgroundOnEdt[0]);
+        assertTrue(doneOnEdt[0]);
+        List<String> expected = new ArrayList<String>();
+        expected.add("state:PENDING>STARTED");
+        expected.add("progress:0>40");
+        expected.add("progress:40>100");
+        expected.add("state:STARTED>DONE");
+        assertEquals(expected, log.events);
+        assertEquals("done() runs after the events", expected, order);
+        assertFalse(log.onEdt.contains(Boolean.FALSE));
+        assertSame(SwingWorker.StateValue.DONE, w.getState());
+        assertTrue(w.isDone());
+        assertFalse(w.isCancelled());
+        assertEquals(100, w.getProgress());
+        assertEquals("answer", w.get());
+        assertEquals("answer", w.get(1, TimeUnit.MILLISECONDS));
+        assertFalse(w.cancel(true));
+    }
+
+    @Test
+    public void progressOutsideZeroToOneHundredIsRefused() {
+        SwingWorker<Void, Void> w = new SwingWorker<Void, Void>() {
+            @Override
+            protected Void doInBackground() {
+                return null;
+            }
+        };
+        try {
+            w.setProgress(101);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals(0, w.getProgress());
+        }
+    }
+
+    @Test
+    public void chunksPublishedBeforeTheEventThreadRunsArriveAsOneList() {
+        final AtomicBoolean finished = new AtomicBoolean();
+        final List<List<Integer>> calls = new ArrayList<List<Integer>>();
+        final boolean[] processOnEdt = {true};
+        SwingWorker<Void, Integer> w = new SwingWorker<Void, Integer>() {
+            @Override
+            protected Void doInBackground() {
+                return null;
+            }
+
+            @Override
+            protected void process(List<Integer> chunks) {
+                processOnEdt[0] &= Display.getInstance().isEdt();
+                calls.add(new ArrayList<Integer>(chunks));
+            }
+
+            @Override
+            protected void done() {
+                finished.set(true);
+            }
+        };
+        // Published on the event dispatch thread, which cannot run the
+        // flush before this method lets go of it.
+        w.publish(1, 2);
+        w.publish(3);
+        w.publish();
+        assertTrue(calls.isEmpty());
+        w.execute();
+        pumpUntil(finished);
+        assertEquals(1, calls.size());
+        List<Integer> all = new ArrayList<Integer>();
+        all.add(1);
+        all.add(2);
+        all.add(3);
+        assertEquals(all, calls.get(0));
+        assertTrue(processOnEdt[0]);
+    }
+
+    @Test
+    public void chunksPublishedInTheBackgroundAllArriveInOrderBeforeDone() {
+        final AtomicBoolean finished = new AtomicBoolean();
+        final List<Integer> seen = new ArrayList<Integer>();
+        final int[] atDone = {-1};
+        SwingWorker<Void, Integer> w = new SwingWorker<Void, Integer>() {
+            @Override
+            protected Void doInBackground() {
+                for (int i = 0; i < 200; i++) {
+                    publish(i);
+                }
+                return null;
+            }
+
+            @Override
+            protected void process(List<Integer> chunks) {
+                seen.addAll(chunks);
+            }
+
+            @Override
+            protected void done() {
+                atDone[0] = seen.size();
+                finished.set(true);
+            }
+        };
+        w.execute();
+        pumpUntil(finished);
+        assertEquals(200, atDone[0]);
+        for (int i = 0; i < 200; i++) {
+            assertEquals(i, seen.get(i).intValue());
+        }
+    }
+
+    @Test
+    public void getOnTheEventDispatchThreadWaitsWhileThatThreadKeepsDispatching() throws Exception {
+        final AtomicBoolean release = new AtomicBoolean();
+        SwingWorker<Integer, Void> w = new SwingWorker<Integer, Void>() {
+            @Override
+            protected Integer doInBackground() throws Exception {
+                while (!release.get()) {
+                    Thread.sleep(2);
+                }
+                return 42;
+            }
+        };
+        w.execute();
+        try {
+            w.get(20, TimeUnit.MILLISECONDS);
+            fail();
+        } catch (TimeoutException expected) {
+            assertFalse(w.isDone());
+        }
+        // Only the event dispatch thread releases the task, so get() can
+        // return only if that thread still runs what is posted to it.
+        Display.getInstance().callSerially(new Runnable() {
+            @Override
+            public void run() {
+                release.set(true);
+            }
+        });
+        assertEquals(42, w.get().intValue());
+        assertTrue(w.isDone());
+    }
+
+    @Test
+    public void anExceptionInTheBackgroundSurfacesFromGet() throws Exception {
+        final AtomicBoolean finished = new AtomicBoolean();
+        final IllegalStateException boom = new IllegalStateException("boom");
+        SwingWorker<String, Void> w = new SwingWorker<String, Void>() {
+            @Override
+            protected String doInBackground() {
+                throw boom;
+            }
+
+            @Override
+            protected void done() {
+                finished.set(true);
+            }
+        };
+        w.execute();
+        try {
+            w.get();
+            fail();
+        } catch (ExecutionException e) {
+            assertSame(boom, e.getCause());
+        }
+        pumpUntil(finished);
+        assertSame(SwingWorker.StateValue.DONE, w.getState());
+        assertFalse(w.isCancelled());
+    }
+
+    @Test
+    public void cancelInterruptsTheTaskAndGetThrows() throws Exception {
+        final AtomicBoolean started = new AtomicBoolean();
+        final AtomicBoolean interrupted = new AtomicBoolean();
+        final int[] doneCalls = {0};
+        SwingWorker<String, Void> w = new SwingWorker<String, Void>() {
+            @Override
+            protected String doInBackground() {
+                started.set(true);
+                try {
+                    Thread.sleep(60000);
+                } catch (InterruptedException e) {
+                    interrupted.set(true);
+                }
+                return "late";
+            }
+
+            @Override
+            protected void done() {
+                doneCalls[0]++;
+            }
+        };
+        w.execute();
+        pumpUntil(started);
+        assertTrue(w.cancel(true));
+        assertEquals("done() runs at once on the event dispatch thread", 1, doneCalls[0]);
+        assertTrue(w.isCancelled());
+        assertTrue(w.isDone());
+        assertSame(SwingWorker.StateValue.DONE, w.getState());
+        try {
+            w.get();
+            fail();
+        } catch (CancellationException expected) {
+            assertFalse(w.cancel(true));
+        }
+        pumpUntil(interrupted);
+        assertEquals(1, doneCalls[0]);
+    }
+
+    @Test
+    public void aWorkerCancelledBeforeItStartsNeverRuns() throws Exception {
+        final boolean[] ran = {false};
+        final Log log = new Log();
+        SwingWorker<String, Void> w = new SwingWorker<String, Void>() {
+            @Override
+            protected String doInBackground() {
+                ran[0] = true;
+                return "x";
+            }
+        };
+        w.addPropertyChangeListener(log);
+        assertTrue(w.cancel(false));
+        w.run();
+        assertFalse(ran[0]);
+        assertEquals(1, log.events.size());
+        assertEquals("state:PENDING>DONE", log.events.get(0));
+        try {
+            w.get(1, TimeUnit.SECONDS);
+            fail();
+        } catch (CancellationException expected) {
+            assertTrue(w.isCancelled());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/TableTreeScrollPaneTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/TableTreeScrollPaneTest.java
new file mode 100644
index 00000000000..53480602fbe
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/TableTreeScrollPaneTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.java.awt.event.MouseMotionAdapter;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import org.junit.Test;
+
+/// What a table and a tree ask of the scroll pane around them: the
+/// table's header becomes the pane's column header, the selection is
+/// scrolled into view, and a finger drag over rows is handed to the pane.
+public class TableTreeScrollPaneTest extends KernelTestBase {
+
+    private static boolean shows(JScrollPane pane, Rectangle r) {
+        Point at = pane.getViewport().getViewPosition();
+        Dimension extent = pane.getViewport().getExtentSize();
+        return r.y >= at.y && r.y + r.height <= at.y + extent.height;
+    }
+
+    @Test
+    public void theTableHeaderBecomesTheColumnHeader() {
+        JTable t = new JTable(new DefaultTableModel(5, 3));
+        JScrollPane pane = new JScrollPane(t);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        assertNotNull(pane.getColumnHeader());
+        assertSame(t.getTableHeader(), pane.getColumnHeader().getView());
+        assertTrue(t.getScrollableTracksViewportWidth());
+        assertEquals(t.getRowHeight(), t.getScrollableUnitIncrement(new Rectangle(0, 0, 100, 100),
+                SwingConstants.VERTICAL, 1));
+    }
+
+    @Test
+    public void changingTheSelectionScrollsItIntoView() {
+        JTable t = new JTable(new DefaultTableModel(300, 3));
+        JScrollPane pane = new JScrollPane(t);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        assertTrue("the table is as high as its rows", t.getHeight() >= 300 * t.getRowHeight());
+        t.changeSelection(250, 1, false, false);
+        assertTrue(pane.getViewport().getViewPosition().y > 0);
+        assertTrue(shows(pane, t.getCellRect(250, 1, true)));
+        t.changeSelection(2, 1, false, false);
+        assertTrue(shows(pane, t.getCellRect(2, 1, true)));
+    }
+
+    @Test
+    public void aTreePathIsScrolledIntoView() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
+        DefaultMutableTreeNode last = null;
+        for (int i = 0; i < 200; i++) {
+            DefaultMutableTreeNode n = new DefaultMutableTreeNode("n" + i);
+            n.add(new DefaultMutableTreeNode("leaf" + i));
+            root.add(n);
+            last = n;
+        }
+        JTree t = new JTree(root);
+        JScrollPane pane = new JScrollPane(t);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        TreePath deep = new TreePath(new Object[]{root, last, last.getChildAt(0)});
+        t.scrollPathToVisible(deep);
+        f.validate();
+        assertTrue(t.isExpanded(deep.getParentPath()));
+        assertTrue(pane.getViewport().getViewPosition().y > 0);
+        assertTrue(shows(pane, t.getPathBounds(deep)));
+    }
+
+    @Test
+    public void aFingerDragOverRowsIsHandedToTheScrollPane() {
+        JTable t = new JTable(new DefaultTableModel(300, 3));
+        JScrollPane pane = new JScrollPane(t);
+        final int[] drags = new int[1];
+        pane.addMouseMotionListener(new MouseMotionAdapter() {
+            @Override
+            public void mouseDragged(MouseEvent e) {
+                drags[0]++;
+            }
+        });
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        press(f, t, 50, 100);
+        drag(f, t, 50, 60);
+        drag(f, t, 50, 20);
+        release(f, t, 50, 20);
+        assertTrue("the pane heard the drag", drags[0] >= 2);
+        assertEquals("and nothing was selected", -1, t.getSelectedRow());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/TextAreaLineWrapTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/TextAreaLineWrapTest.java
new file mode 100644
index 00000000000..0a4004e5150
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/TextAreaLineWrapTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Point;
+import org.junit.Test;
+
+/// A text area wraps its lines only when it was asked to.
+public class TextAreaLineWrapTest extends KernelTestBase {
+
+    private static String longLine() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 80; i++) {
+            sb.append("word").append(i).append(' ');
+        }
+        return sb.toString();
+    }
+
+    private JScrollPane shown(JTextArea area) {
+        JScrollPane pane = new JScrollPane(area);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        f.setSize(300, 200);
+        show(f);
+        f.validate();
+        return pane;
+    }
+
+    private static int shownLines(JTextArea area) {
+        return ((com.codename1.ui.TextArea) area.cn1Peer()).getLines();
+    }
+
+    @Test
+    public void aLongLineIsNotWrappedByDefault() {
+        JTextArea area = new JTextArea("first\n" + longLine() + "\nlast");
+        assertFalse(area.getLineWrap());
+        JScrollPane pane = shown(area);
+        int extent = pane.getViewport().getExtentSize().width;
+        assertFalse(area.getScrollableTracksViewportWidth());
+        assertTrue("wider than the viewport: " + area.getWidth(), area.getWidth() > extent);
+        assertEquals("three lines, none broken", 3, shownLines(area));
+        // The pane scrolls it sideways.
+        assertEquals(area.getWidth(), pane.getHorizontalScrollBar().getMaximum());
+        pane.getHorizontalScrollBar().setValue(50);
+        assertEquals(new Point(50, 0), pane.getViewport().getViewPosition());
+        assertEquals(-50, area.getX());
+    }
+
+    @Test
+    public void shortLinesFillTheViewport() {
+        JTextArea area = new JTextArea("a\nb");
+        JScrollPane pane = shown(area);
+        assertTrue(area.getScrollableTracksViewportWidth());
+        assertEquals(pane.getViewport().getExtentSize().width, area.getWidth());
+        assertEquals(2, shownLines(area));
+    }
+
+    @Test
+    public void lineWrapBreaksAtTheViewportsWidth() {
+        JTextArea area = new JTextArea("first\n" + longLine() + "\nlast");
+        area.setLineWrap(true);
+        area.setWrapStyleWord(true);
+        assertTrue(area.getWrapStyleWord());
+        JScrollPane pane = shown(area);
+        assertTrue(area.getScrollableTracksViewportWidth());
+        assertEquals(pane.getViewport().getExtentSize().width, area.getWidth());
+        assertTrue("the long line is broken", shownLines(area) > 3);
+        assertEquals(0, pane.getHorizontalScrollBar().getMaximum() - pane.getHorizontalScrollBar().getVisibleAmount());
+    }
+
+    @Test
+    public void turningWrapOnAndOffLaysOutAgain() {
+        JTextArea area = new JTextArea(longLine());
+        JScrollPane pane = shown(area);
+        int extent = pane.getViewport().getExtentSize().width;
+        assertTrue(area.getWidth() > extent);
+        area.setLineWrap(true);
+        pane.validate();
+        assertEquals(extent, area.getWidth());
+        assertTrue(shownLines(area) > 1);
+        area.setLineWrap(false);
+        pane.validate();
+        assertTrue(area.getWidth() > extent);
+        assertEquals(1, shownLines(area));
+    }
+
+    @Test
+    public void theWidthFollowsTheText() {
+        JTextArea area = new JTextArea("short");
+        JScrollPane pane = shown(area);
+        int extent = pane.getViewport().getExtentSize().width;
+        assertEquals(extent, area.getWidth());
+        area.append(longLine());
+        pane.validate();
+        assertTrue(area.getWidth() > extent);
+        area.setText("short again");
+        pane.validate();
+        assertEquals(extent, area.getWidth());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/UIManagerTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/UIManagerTest.java
new file mode 100644
index 00000000000..6e7c8e86d82
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/UIManagerTest.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.rt.LafTheme;
+import com.codename1.desktopcompat.rt.ScrollDelegate;
+import org.junit.After;
+import org.junit.Test;
+
+/// The look and feel calls an application makes at start-up do no harm,
+/// and the defaults answer what was put, or else the theme.
+public class UIManagerTest extends KernelTestBase {
+
+    private static final String[] KEYS = {"Table.gridColor", "Panel.background", "Mine.color", "Mine.border",
+        "Mine.insets", "Mine.size", "Mine.count", "Mine.flag", "Mine.text", "List.selectionBackground",
+        "Table.background"};
+
+    @After
+    public void forget() throws Exception {
+        for (int i = 0; i < KEYS.length; i++) {
+            UIManager.put(KEYS[i], null);
+        }
+        UIManager.setLookAndFeel((LookAndFeel) null);
+        // Selecting a look and feel lays a palette over the theme of the
+        // one display every class shares, and taking the look and feel
+        // away does not lift it: the classes after this one drew a radio
+        // button whose dot had the colour of its field.
+        LafTheme.reset();
+        ScrollDelegate.setBarThickness(-1);
+    }
+
+    @Test
+    public void settingALookAndFeelNeverFails() throws Exception {
+        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
+        UIManager.setLookAndFeel("com.example.NoSuchLookAndFeel");
+        UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
+        assertNotNull(UIManager.getSystemLookAndFeelClassName());
+
+        // The loop every Nimbus application starts with.
+        UIManager.LookAndFeelInfo[] infos = UIManager.getInstalledLookAndFeels();
+        assertEquals(1, infos.length);
+        for (int i = 0; i < infos.length; i++) {
+            assertNotNull(infos[i].getName());
+            UIManager.setLookAndFeel(infos[i].getClassName());
+        }
+        assertEquals(UIManager.getSystemLookAndFeelClassName(), infos[0].getClassName());
+        infos[0] = null;
+        assertNotNull("a copy was handed out", UIManager.getInstalledLookAndFeels()[0]);
+        UIManager.installLookAndFeel("Mine", "com.example.Mine");
+        assertEquals(2, UIManager.getInstalledLookAndFeels().length);
+        assertEquals("Mine", UIManager.getInstalledLookAndFeels()[1].getName());
+        UIManager.setInstalledLookAndFeels(new UIManager.LookAndFeelInfo[]{infos.length > 0
+                ? new UIManager.LookAndFeelInfo("Codename One", UIManager.getSystemLookAndFeelClassName()) : null});
+        assertEquals(1, UIManager.getInstalledLookAndFeels().length);
+    }
+
+    private static final class Mine extends LookAndFeel {
+        private final boolean supported;
+        boolean initialized;
+
+        Mine(boolean supported) {
+            this.supported = supported;
+        }
+
+        @Override
+        public String getName() {
+            return "Mine";
+        }
+
+        @Override
+        public String getID() {
+            return "Mine";
+        }
+
+        @Override
+        public String getDescription() {
+            return "A look of the application's own";
+        }
+
+        @Override
+        public boolean isNativeLookAndFeel() {
+            return false;
+        }
+
+        @Override
+        public boolean isSupportedLookAndFeel() {
+            return supported;
+        }
+
+        @Override
+        public void initialize() {
+            initialized = true;
+        }
+    }
+
+    @Test
+    public void aLookAndFeelObjectIsRememberedAndInitialized() throws Exception {
+        LookAndFeel builtIn = UIManager.getLookAndFeel();
+        assertNotNull(builtIn);
+        assertEquals("Codename One", builtIn.getName());
+        assertTrue(builtIn.isSupportedLookAndFeel());
+        assertSame(UIManager.getLookAndFeelDefaults(), builtIn.getDefaults());
+        Mine mine = new Mine(true);
+        UIManager.setLookAndFeel(mine);
+        assertSame(mine, UIManager.getLookAndFeel());
+        assertTrue(mine.initialized);
+        assertNull(mine.getDefaults());
+        assertTrue(mine.toString().indexOf("A look of the application's own") >= 0);
+        try {
+            UIManager.setLookAndFeel(new Mine(false));
+            fail("it says it is not supported");
+        } catch (UnsupportedLookAndFeelException expected) {
+            assertSame(mine, UIManager.getLookAndFeel());
+        }
+    }
+
+    @Test
+    public void whatWasPutIsWhatComesBack() {
+        Color c = new Color(1, 2, 3);
+        Border b = BorderFactory.createLineBorder(Color.RED);
+        Insets in = new Insets(1, 2, 3, 4);
+        Dimension d = new Dimension(5, 6);
+        UIManager.put("Mine.color", c);
+        UIManager.put("Mine.border", b);
+        UIManager.put("Mine.insets", in);
+        UIManager.put("Mine.size", d);
+        UIManager.put("Mine.count", Integer.valueOf(7));
+        UIManager.put("Mine.flag", Boolean.TRUE);
+        UIManager.put("Mine.text", "text");
+        assertSame(c, UIManager.getColor("Mine.color"));
+        assertSame(b, UIManager.getBorder("Mine.border"));
+        assertSame(in, UIManager.getInsets("Mine.insets"));
+        assertSame(d, UIManager.getDimension("Mine.size"));
+        assertEquals(7, UIManager.getInt("Mine.count"));
+        assertTrue(UIManager.getBoolean("Mine.flag"));
+        assertEquals("text", UIManager.getString("Mine.text"));
+        // A getter of another type answers nothing.
+        assertNull(UIManager.getColor("Mine.text"));
+        assertNull(UIManager.getBorder("Mine.color"));
+        assertEquals(0, UIManager.getInt("Mine.text"));
+
+        UIDefaults defaults = UIManager.getDefaults();
+        // The look and feel has a table of its own beneath this one.
+        assertTrue(defaults != UIManager.getLookAndFeelDefaults());
+        assertSame(c, defaults.getColor("Mine.color"));
+        assertSame(c, defaults.get("Mine.color"));
+        defaults.put("Mine.color", Color.BLUE);
+        assertSame(Color.BLUE, UIManager.getColor("Mine.color"));
+        UIManager.put("Mine.color", null);
+        assertNull(UIManager.get("Mine.color"));
+        assertNull(UIManager.get("No.such.key"));
+        assertNull(UIManager.getBorder("No.such.border"));
+    }
+
+    @Test
+    public void commonKeysAnswerFromTheTheme() {
+        Color background = UIManager.getColor("Panel.background");
+        assertNotNull(background);
+        assertEquals(background, UIManager.getColor("control"));
+        assertEquals(background, UIManager.getDefaults().getColor("Label.background"));
+        assertNotNull(UIManager.getColor("Label.foreground"));
+        assertEquals(UIManager.getColor("Label.foreground"), UIManager.getColor("controlText"));
+        Font f = UIManager.getFont("Label.font");
+        assertNotNull(f);
+        assertEquals(f, UIManager.getFont("Button.font"));
+        assertNotNull(UIManager.getColor("Table.gridColor"));
+        assertNotNull(UIManager.getColor("List.selectionBackground"));
+        assertNotNull(UIManager.getColor("Table.selectionForeground"));
+        assertEquals(UIManager.getColor("Table.selectionBackground"), UIManager.getColor("textHighlight"));
+        // The grid color is the one a table draws with.
+        assertEquals(UIManager.getColor("Table.gridColor"), new JTable(2, 2).getGridColor());
+        ScrollDelegate.setBarThickness(14);
+        assertEquals(14, UIManager.getInt("ScrollBar.width"));
+    }
+
+    @Test
+    public void theWidgetsTakeWhatTheApplicationPut() {
+        Color grid = new Color(10, 20, 30);
+        Color selection = new Color(40, 50, 60);
+        Color cells = new Color(70, 80, 90);
+        UIManager.put("Table.gridColor", grid);
+        UIManager.put("List.selectionBackground", selection);
+        UIManager.put("Table.background", cells);
+        assertSame(grid, UIManager.getColor("Table.gridColor"));
+        JTable table = new JTable(2, 2);
+        assertEquals(grid, table.getGridColor());
+        assertEquals(cells, table.getBackground());
+        assertEquals(selection, new JList<String>().getSelectionBackground());
+        UIManager.put("List.selectionBackground", null);
+        assertEquals("a list keeps its own default when nothing was put", new Color(0x38, 0x75, 0xd7),
+                new JList<String>().getSelectionBackground());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/WidgetLookTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/WidgetLookTest.java
new file mode 100644
index 00000000000..bed5bdf163f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/WidgetLookTest.java
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.javax.swing.border.Border;
+import com.codename1.desktopcompat.rt.Indicators;
+import com.codename1.desktopcompat.rt.Units;
+import com.codename1.ui.Image;
+import org.junit.Test;
+
+/// What widgets look like when the application set nothing: where the
+/// content is, which mark is which, and what a button without a caption
+/// is drawn as.
+public class WidgetLookTest extends KernelTestBase {
+
+    private static Icon square(final int side) {
+        return new Icon() {
+            @Override
+            public void paintIcon(com.codename1.desktopcompat.java.awt.Component c, Graphics g, int x, int y) {
+                g.setColor(Color.RED);
+                g.fillRect(x, y, side, side);
+            }
+
+            @Override
+            public int getIconWidth() {
+                return side;
+            }
+
+            @Override
+            public int getIconHeight() {
+                return side;
+            }
+        };
+    }
+
+    // ------------------------------------------------------- backgrounds
+
+    /// Lists, trees, tables and text are content areas: they answer the
+    /// content background, under their own keys, and not the window's.
+    @Test
+    public void contentAreasHaveTheContentBackground() {
+        Color content = UIManager.getColor("text");
+        assertNotNull(content);
+        assertEquals(content, UIManager.getColor("TextArea.background"));
+        assertEquals(content, UIManager.getColor("EditorPane.background"));
+        assertEquals(UIManager.getColor("List.background"), new JList<Object>().getBackground());
+        assertEquals(UIManager.getColor("Tree.background"), new JTree().getBackground());
+        assertEquals(UIManager.getColor("Table.background"), new JTable().getBackground());
+        assertEquals(content, new JTextArea().getBackground());
+        assertEquals(content, new JEditorPane().getBackground());
+        assertEquals(UIManager.getColor("control"), new JPanel().getBackground());
+    }
+
+    @Test
+    public void anApplicationsColourUnderTheKeyWins() {
+        Color mine = new Color(1, 2, 3);
+        UIManager.put("Desktop.background", mine);
+        try {
+            assertEquals(mine, new JDesktopPane().getBackground());
+        } finally {
+            UIManager.put("Desktop.background", null);
+        }
+        assertEquals(UIManager.getColor("Desktop.background"), new JDesktopPane().getBackground());
+    }
+
+    /// The desktop is painted in its own colour, and a tree in a scroll
+    /// pane in the content colour, with the pane's line around it.
+    @Test
+    public void aDesktopAndAScrolledTreeArePaintedInTheirColours() {
+        JDesktopPane desk = new JDesktopPane();
+        JTree tree = new JTree();
+        JScrollPane pane = new JScrollPane(tree);
+        Border line = pane.getBorder();
+        assertNotNull(line);
+        Insets in = line.getBorderInsets(pane);
+        assertEquals(1, in.left);
+        assertEquals(1, in.top);
+        JFrame f = new JFrame();
+        f.getContentPane().add(desk, BorderLayout.CENTER);
+        f.getContentPane().add(pane, BorderLayout.SOUTH);
+        pane.setPreferredSize(new Dimension(300, 100));
+        f.setSize(300, 300);
+        show(f);
+        int[][] rows = raster(f);
+        assertEquals(UIManager.getColor("Desktop.background").getRGB() & 0xffffff, pixel(rows, desk, 50, 50));
+        int content = UIManager.getColor("Tree.background").getRGB() & 0xffffff;
+        assertEquals(content, pixel(rows, pane, pane.getWidth() - 30, pane.getHeight() - 10));
+        assertTrue(pixel(rows, pane, 0, 50) != content);
+        assertTrue(pixel(rows, pane, pane.getWidth() / 2, 0) != content);
+    }
+
+    // -------------------------------------------------------------- marks
+
+    private static int luma(int argb) {
+        return ((argb >> 16) & 0xff) + ((argb >> 8) & 0xff) + (argb & 0xff);
+    }
+
+    /// A check box is a square and a radio button a circle: the corner of
+    /// the square is drawn, that of the circle is not.
+    @Test
+    public void aCheckBoxIsASquareAndARadioButtonACircle() {
+        HeadlessImplementation.rasterImages = true;
+        try {
+            int side = 40;
+            for (int state = 0; state < 2; state++) {
+                boolean on = state == 1;
+                Image box = Indicators.mark(false, on, true, side);
+                Image dot = Indicators.mark(true, on, true, side);
+                assertEquals(side, box.getWidth());
+                int[] b = box.getRGB();
+                int[] d = dot.getRGB();
+                int corner = 4 * side + 4;
+                assertTrue("the corner of a box is drawn", (b[corner] >>> 24) != 0);
+                assertEquals("the corner of a circle is not", 0, d[corner] >>> 24);
+                int edge = (side / 2) * side + 1;
+                assertTrue((b[edge] >>> 24) != 0);
+                assertTrue((d[edge] >>> 24) != 0);
+            }
+            // On and off differ in the middle of either.
+            int mid = 20 * 40 + 20;
+            assertTrue(Indicators.mark(true, true, true, 40).getRGB()[mid]
+                    != Indicators.mark(true, false, true, 40).getRGB()[mid]);
+            int[] ticked = Indicators.mark(false, true, true, 40).getRGB();
+            int[] empty = Indicators.mark(false, false, true, 40).getRGB();
+            int differ = 0;
+            for (int i = 0; i < ticked.length; i++) {
+                if (ticked[i] != empty[i]) {
+                    differ++;
+                }
+            }
+            assertTrue(differ > 100);
+        } finally {
+            HeadlessImplementation.rasterImages = false;
+        }
+    }
+
+    /// The mark is what the peer shows and is measured with, and its text
+    /// has the colour of a label rather than whatever the theme gives a
+    /// check box.
+    @Test
+    public void theMarkIsDrawnHereAndItsTextIsLabelText() {
+        HeadlessImplementation.rasterImages = true;
+        try {
+            JCheckBox box = new JCheckBox("Pick");
+            JRadioButton radio = new JRadioButton("Pick");
+            JFrame f = new JFrame();
+            JPanel p = new JPanel(new FlowLayout());
+            p.add(box);
+            p.add(radio);
+            f.getContentPane().add(p, BorderLayout.CENTER);
+            f.setSize(300, 200);
+            show(f);
+            com.codename1.ui.Component bp = box.cn1PeerOrNull();
+            com.codename1.ui.Component rp = radio.cn1PeerOrNull();
+            assertTrue(bp instanceof com.codename1.ui.Button);
+            assertTrue(rp instanceof com.codename1.ui.Button);
+            Image off = ((com.codename1.ui.Button) bp).getIconFromState();
+            assertNotNull(off);
+            assertTrue(off.getWidth() >= Units.toDevice(13));
+            box.setSelected(true);
+            Image on = ((com.codename1.ui.Button) bp).getIconFromState();
+            assertTrue(on != off);
+            assertTrue(((com.codename1.ui.Button) rp).getIconFromState() != off);
+            bp.getUnselectedStyle().setFgColor(0x0000ff);
+            raster(f);
+            int label = UIManager.getColor("Label.foreground").getRGB() & 0xffffff;
+            assertEquals(label, bp.getUnselectedStyle().getFgColor());
+            // A colour the application set is kept.
+            radio.setForeground(Color.RED);
+            raster(f);
+            assertEquals(0xff0000, rp.getUnselectedStyle().getFgColor());
+        } finally {
+            HeadlessImplementation.rasterImages = false;
+        }
+    }
+
+    // ------------------------------------------------------------ buttons
+
+    private static boolean shapeless(com.codename1.ui.Component peer) {
+        com.codename1.ui.plaf.Style s = peer.getUnselectedStyle();
+        com.codename1.ui.plaf.Border b = s.getBorder();
+        return (s.getBgTransparency() & 0xff) == 0 && (b == null || !b.isBackgroundPainter());
+    }
+
+    /// A button that is only an icon, and any button of a tool bar, is not
+    /// drawn in the theme's button shape, and is as large as its icon and
+    /// margin.
+    @Test
+    public void anIconButtonAndAToolBarButtonHaveNoThemeShape() {
+        JButton iconOnly = new JButton(square(20));
+        iconOnly.setMargin(new Insets(0, 0, 0, 0));
+        JToggleButton inBar = new JToggleButton(square(16));
+        inBar.setMargin(new Insets(0, 0, 0, 0));
+        JButton textInBar = new JButton("Bar");
+        JToolBar bar = new JToolBar();
+        bar.add(inBar);
+        bar.add(textInBar);
+        JPanel p = new JPanel(new FlowLayout());
+        p.add(iconOnly);
+        JFrame f = new JFrame();
+        f.getContentPane().add(bar, BorderLayout.NORTH);
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        f.setSize(400, 300);
+        show(f);
+        assertTrue(shapeless(iconOnly.cn1PeerOrNull()));
+        assertTrue(shapeless(inBar.cn1PeerOrNull()));
+        assertTrue(shapeless(textInBar.cn1PeerOrNull()));
+        com.codename1.ui.plaf.Style s = iconOnly.cn1PeerOrNull().getUnselectedStyle();
+        int pad = s.getPaddingLeftNoRTL();
+        assertTrue("room for the line around the icon and no more: " + pad, pad >= 1 && pad <= Units.toDevice(3));
+        assertEquals(pad, s.getPaddingTop());
+        // With a caption the button goes back to the theme's.
+        iconOnly.setText("Now with text");
+        iconOnly.setMargin(null);
+        JButton fresh = new JButton("Now with text");
+        p.add(fresh);
+        f.validate();
+        assertEquals(fresh.cn1PeerOrNull().getUnselectedStyle().getBgTransparency(),
+                iconOnly.cn1PeerOrNull().getUnselectedStyle().getBgTransparency());
+        assertEquals(fresh.cn1PeerOrNull().getUnselectedStyle().getPaddingLeftNoRTL(),
+                iconOnly.cn1PeerOrNull().getUnselectedStyle().getPaddingLeftNoRTL());
+    }
+
+    /// A selected toggle in a tool bar shows it: the same place is darker
+    /// than when it is not selected.
+    @Test
+    public void aSelectedToolBarToggleShows() {
+        JToggleButton t = new JToggleButton(square(8));
+        t.setMargin(new Insets(6, 6, 6, 6));
+        t.setPreferredSize(new Dimension(30, 30));
+        t.setMinimumSize(new Dimension(30, 30));
+        t.setMaximumSize(new Dimension(30, 30));
+        JToolBar bar = new JToolBar();
+        bar.add(t);
+        JFrame f = new JFrame();
+        f.getContentPane().add(bar, BorderLayout.NORTH);
+        f.setSize(300, 200);
+        show(f);
+        t.cn1PeerOrNull().getUnselectedStyle().setFgColor(0x000000);
+        int off = pixel(raster(f), t, 3, t.getHeight() / 2);
+        t.setSelected(true);
+        int on = pixel(raster(f), t, 3, t.getHeight() / 2);
+        assertTrue("selected " + Integer.toHexString(on) + " against " + Integer.toHexString(off),
+                Math.abs(luma(on) - luma(off)) >= 12);
+    }
+
+    // -------------------------------------------------------------- combo
+
+    /// A combo box is as wide as its widest entry needs, wherever in the
+    /// list that is, and stretches like the JDK's.
+    @Test
+    public void aComboBoxIsAsWideAsItsWidestEntry() {
+        String[] few = {"a", "b", "c"};
+        String[] late = new String[12];
+        for (int i = 0; i < late.length; i++) {
+            late[i] = "a";
+        }
+        late[11] = "the widest entry of them all";
+        JComboBox<String> narrow = new JComboBox<String>(few);
+        JComboBox<String> wide = new JComboBox<String>(late);
+        JPanel p = new JPanel(new FlowLayout());
+        p.add(narrow);
+        p.add(wide);
+        JFrame f = new JFrame();
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        f.setSize(500, 200);
+        show(f);
+        int textWidth = (late[11].length() - 1) * HeadlessImplementation.CHAR_WIDTH / 2;
+        assertTrue(wide.getPreferredSize().width - narrow.getPreferredSize().width >= textWidth - 2);
+        assertEquals(Short.MAX_VALUE, wide.getMaximumSize().width);
+    }
+
+    // --------------------------------------------------------------- flow
+
+    /// A row wider than the display wraps, and the layout asks for the
+    /// height of its rows.
+    @Test
+    public void aFlowWiderThanTheDisplayAsksForItsRows() {
+        int display = Units.toLogical(HeadlessImplementation.WIDTH);
+        JPanel row = new JPanel(new FlowLayout(FlowLayout.CENTER, 5, 5));
+        int each = display / 3;
+        for (int i = 0; i < 5; i++) {
+            JPanel leaf = new JPanel();
+            leaf.setPreferredSize(new Dimension(each, 20));
+            leaf.setMinimumSize(new Dimension(each, 20));
+            row.add(leaf);
+        }
+        Dimension d = row.getPreferredSize();
+        // Two fit a row of the display: three rows.
+        assertEquals(3 * 20 + 4 * 5, d.height);
+        JFrame f = new JFrame();
+        f.getContentPane().add(row, BorderLayout.NORTH);
+        f.getContentPane().add(new JPanel(), BorderLayout.CENTER);
+        f.setSize(display, 300);
+        show(f);
+        assertEquals(3 * 20 + 4 * 5, row.getHeight());
+        assertTrue(row.getWidth() <= display);
+        assertEquals(2 * (20 + 5), row.getComponent(4).getY() - row.getComponent(0).getY());
+        // One that fits the display keeps the answer of a desktop.
+        JPanel small = new JPanel(new FlowLayout(FlowLayout.CENTER, 5, 5));
+        for (int i = 0; i < 2; i++) {
+            JPanel leaf = new JPanel();
+            leaf.setPreferredSize(new Dimension(40, 20));
+            small.add(leaf);
+        }
+        small.setSize(50, 100);
+        assertEquals(new Dimension(95, 30), small.getPreferredSize());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/border/BorderSidesTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/border/BorderSidesTest.java
new file mode 100644
index 00000000000..ffb4390db34
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/border/BorderSidesTest.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.border;
+
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import org.junit.Test;
+
+/// Every side of an etched or bevelled border is painted, whatever the
+/// background: on a white panel there is nothing brighter than the
+/// background, and the lit sides must not disappear into it.
+public class BorderSidesTest extends KernelTestBase {
+    private static final int W = 200;
+    private static final int H = 120;
+
+    private static int luma(int rgb) {
+        return ((rgb >> 16) & 0xff) + ((rgb >> 8) & 0xff) + (rgb & 0xff);
+    }
+
+    /// The outermost painted pixel of the left, top, right and bottom side.
+    private int[] sides(Border b, Color background) {
+        JPanel p = new JPanel(new BorderLayout());
+        p.setOpaque(true);
+        p.setBackground(background);
+        p.setBorder(b);
+        JFrame f = new JFrame();
+        f.getContentPane().add(p, BorderLayout.CENTER);
+        f.setSize(W, H);
+        show(f);
+        int[][] rows = raster(f);
+        int w = p.getWidth();
+        int h = p.getHeight();
+        assertTrue(w > 40 && h > 40);
+        int[] out = {pixel(rows, p, 0, h / 2), pixel(rows, p, w / 2, 0), pixel(rows, p, w - 1, h / 2),
+            pixel(rows, p, w / 2, h - 1), pixel(rows, p, w / 2, h / 2)};
+        f.dispose();
+        return out;
+    }
+
+    private void allFourShow(String what, Border b, Color background) {
+        int[] s = sides(b, background);
+        String[] names = {"left", "top", "right", "bottom"};
+        for (int i = 0; i < 4; i++) {
+            assertTrue(what + ": the " + names[i] + " side is the background",
+                    Math.abs(luma(s[i]) - luma(s[4])) >= 24);
+        }
+    }
+
+    @Test
+    public void anEtchedBorderShowsAllFourSides() {
+        Color[] grounds = {Color.WHITE, new Color(0xf2f2f7), Color.LIGHT_GRAY, new Color(0x202020)};
+        for (int i = 0; i < grounds.length; i++) {
+            allFourShow("raised on " + grounds[i], new EtchedBorder(EtchedBorder.RAISED), grounds[i]);
+            allFourShow("lowered on " + grounds[i], new EtchedBorder(EtchedBorder.LOWERED), grounds[i]);
+        }
+    }
+
+    @Test
+    public void aBevelShowsAllFourSides() {
+        Color[] grounds = {Color.WHITE, new Color(0xf2f2f7), Color.LIGHT_GRAY, new Color(0x202020)};
+        for (int i = 0; i < grounds.length; i++) {
+            allFourShow("raised on " + grounds[i], new BevelBorder(BevelBorder.RAISED), grounds[i]);
+            allFourShow("lowered on " + grounds[i], new BevelBorder(BevelBorder.LOWERED), grounds[i]);
+        }
+    }
+
+    @Test
+    public void aSoftBevelShowsAllFourSides() {
+        Color[] grounds = {Color.WHITE, Color.LIGHT_GRAY};
+        for (int i = 0; i < grounds.length; i++) {
+            allFourShow("raised on " + grounds[i], new SoftBevelBorder(BevelBorder.RAISED), grounds[i]);
+            allFourShow("lowered on " + grounds[i], new SoftBevelBorder(BevelBorder.LOWERED), grounds[i]);
+        }
+    }
+
+    /// Raised is lit from the top left and lowered from the bottom right,
+    /// also where the lit sides had to be drawn darker than the background.
+    @Test
+    public void theLitSidesAreTheLighterOnes() {
+        int[] up = sides(new BevelBorder(BevelBorder.RAISED), Color.WHITE);
+        assertTrue(luma(up[0]) > luma(up[2]));
+        assertTrue(luma(up[1]) > luma(up[3]));
+        int[] down = sides(new BevelBorder(BevelBorder.LOWERED), Color.WHITE);
+        assertTrue(luma(down[0]) < luma(down[2]));
+        assertTrue(luma(down[1]) < luma(down[3]));
+    }
+
+    /// Where the background leaves room, the highlight is the brighter
+    /// shade the JDK derives.
+    @Test
+    public void aMidToneBackgroundKeepsTheBrighterHighlight() {
+        JPanel p = new JPanel();
+        p.setBackground(new Color(120, 120, 120));
+        assertTrue(new EtchedBorder().getHighlightColor(p).equals(new Color(120, 120, 120).brighter()));
+        assertTrue(new BevelBorder(BevelBorder.RAISED).getHighlightInnerColor(p)
+                .equals(new Color(120, 120, 120).brighter()));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/event/ListenerArrayTypesTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/event/ListenerArrayTypesTest.java
new file mode 100644
index 00000000000..790a3822895
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/event/ListenerArrayTypesTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.event;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+/// Every listener type the layer passes to `EventListenerList.getListeners`
+/// has its array class named in that class's table.
+///
+/// `getListeners` creates its result reflectively, and ParparVM can only do
+/// that for a type whose array class some bytecode names. Nothing on a JVM
+/// shows a missing one -- the simulator creates array classes on demand -- so
+/// this reads the call sites out of the sources instead: a new
+/// `getListeners(FooListener.class)` in the layer without `FooListener[].class`
+/// in the table fails here rather than on a device.
+public class ListenerArrayTypesTest {
+
+    private static final Pattern CALL = Pattern.compile("getListeners\\(\\s*([A-Za-z0-9_.]+)\\.class\\s*\\)");
+
+    @Test
+    public void everyListenerTypeTheLayerAsksForHasAnArrayClass() throws IOException {
+        Set<String> registered = new HashSet<String>();
+        for (Class<?> array : EventListenerList.listenerArrayTypes()) {
+            assertTrue(array + " is not an array class", array.isArray());
+            registered.add(array.getComponentType().getSimpleName());
+        }
+        File root = new File(System.getProperty("swingcompat.sources", "src/main/java"));
+        Set<String> asked = new TreeSet<String>();
+        int files = collect(root, asked);
+        assertTrue("no sources under " + root.getAbsolutePath(), files > 0);
+        assertTrue("the scan found no call site at all; the pattern no longer matches", asked.size() > 5);
+        Set<String> missing = new TreeSet<String>(asked);
+        missing.removeAll(registered);
+        assertTrue("getListeners is called with listener types whose array class EventListenerList "
+                + "does not name, so the call throws on a device: " + missing, missing.isEmpty());
+    }
+
+    private static int collect(File dir, Set<String> asked) throws IOException {
+        File[] files = dir.listFiles();
+        if (files == null) {
+            return 0;
+        }
+        int count = 0;
+        for (File f : files) {
+            if (f.isDirectory()) {
+                count += collect(f, asked);
+            } else if (f.getName().endsWith(".java")) {
+                count++;
+                String text = new String(Files.readAllBytes(f.toPath()), StandardCharsets.UTF_8);
+                Matcher m = CALL.matcher(text);
+                while (m.find()) {
+                    String name = m.group(1);
+                    asked.add(name.substring(name.lastIndexOf('.') + 1));
+                }
+            }
+        }
+        return count;
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/tree/DefaultMutableTreeNodeTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/tree/DefaultMutableTreeNodeTest.java
new file mode 100644
index 00000000000..1f2c92d069f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/javax/swing/tree/DefaultMutableTreeNodeTest.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.javax.swing.tree;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.javax.swing.event.TreeModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import org.junit.Test;
+
+/// The walks and relations of the general tree node, tree paths, the
+/// default model's events and the selection model's modes. None of this
+/// needs a display.
+public class DefaultMutableTreeNodeTest {
+
+    private final DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
+    private final DefaultMutableTreeNode a = new DefaultMutableTreeNode("a");
+    private final DefaultMutableTreeNode a1 = new DefaultMutableTreeNode("a1");
+    private final DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("a2");
+    private final DefaultMutableTreeNode b = new DefaultMutableTreeNode("b");
+    private final DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("b1");
+    private final DefaultMutableTreeNode b1x = new DefaultMutableTreeNode("b1x");
+
+    {
+        root.add(a);
+        root.add(b);
+        a.add(a1);
+        a.add(a2);
+        b.add(b1);
+        b1.add(b1x);
+    }
+
+    private static String walk(Enumeration<?> e) {
+        StringBuilder sb = new StringBuilder();
+        while (e.hasMoreElements()) {
+            if (sb.length() > 0) {
+                sb.append(' ');
+            }
+            sb.append(e.nextElement());
+        }
+        return sb.toString();
+    }
+
+    @Test
+    public void theFourWalks() {
+        assertEquals("root a a1 a2 b b1 b1x", walk(root.preorderEnumeration()));
+        assertEquals("a1 a2 a b1x b1 b root", walk(root.postorderEnumeration()));
+        assertEquals("a1 a2 a b1x b1 b root", walk(root.depthFirstEnumeration()));
+        assertEquals("root a b a1 a2 b1 b1x", walk(root.breadthFirstEnumeration()));
+        assertEquals("root b b1 b1x", walk(b1x.pathFromAncestorEnumeration(root)));
+        assertEquals("b b1", walk(b1.pathFromAncestorEnumeration(b)));
+        assertEquals("a1 a2", walk(a.children()));
+        assertEquals("", walk(a1.children()));
+        assertEquals("b b1 b1x", walk(b.preorderEnumeration()));
+    }
+
+    @Test
+    public void levelsNeighboursAndLeaves() {
+        assertEquals(3, root.getDepth());
+        assertEquals(0, a1.getDepth());
+        assertEquals(3, b1x.getLevel());
+        assertSame(root, b1x.getRoot());
+        assertTrue(root.isRoot());
+        assertEquals(3, root.getLeafCount());
+        assertSame(a1, root.getFirstLeaf());
+        assertSame(b1x, root.getLastLeaf());
+        assertSame(a2, a1.getNextLeaf());
+        assertSame(b1x, a2.getNextLeaf());
+        assertNull(b1x.getNextLeaf());
+        assertSame(a2, b1x.getPreviousLeaf());
+        assertSame(b, a2.getNextNode());
+        assertSame(a2, b.getPreviousNode());
+        assertSame(a, a1.getPreviousNode());
+        assertSame(b, a.getNextSibling());
+        assertNull(b.getNextSibling());
+        assertSame(a, b.getPreviousSibling());
+        assertEquals(2, a.getSiblingCount());
+        assertSame(root, a1.getSharedAncestor(b1x));
+        assertSame(a, a1.getSharedAncestor(a2));
+        assertTrue(b1x.isNodeAncestor(b));
+        assertTrue(b.isNodeDescendant(b1x));
+        assertFalse(a.isNodeDescendant(b1x));
+        assertTrue(a1.isNodeSibling(a2));
+        assertSame(a2, a.getChildAfter(a1));
+        assertNull(a.getChildBefore(a1));
+        assertEquals(1, root.getIndex(b));
+        assertEquals(-1, root.getIndex(b1));
+        TreeNode[] path = b1x.getPath();
+        assertEquals(4, path.length);
+        assertSame(root, path[0]);
+        assertSame(b1x, path[3]);
+        assertEquals("b1", b1x.getUserObjectPath()[2]);
+    }
+
+    @Test
+    public void movingAndRemovingNodes() {
+        b.add(a2);
+        assertSame(b, a2.getParent());
+        assertEquals(1, a.getChildCount());
+        assertEquals("b1 a2", walk(b.children()));
+        a2.removeFromParent();
+        assertNull(a2.getParent());
+        b.insert(a2, 0);
+        assertEquals("a2 b1", walk(b.children()));
+        try {
+            b1x.add(root);
+            assertTrue("an ancestor cannot become a child", false);
+        } catch (IllegalArgumentException expected) {
+            assertEquals(2, root.getChildCount());
+        }
+        DefaultMutableTreeNode leafOnly = new DefaultMutableTreeNode("leaf", false);
+        try {
+            leafOnly.add(new DefaultMutableTreeNode("x"));
+            assertTrue("a node that allows no children takes none", false);
+        } catch (IllegalStateException expected) {
+            assertEquals(0, leafOnly.getChildCount());
+        }
+        Object copy = a.clone();
+        assertTrue(copy instanceof DefaultMutableTreeNode);
+        assertEquals("a", ((DefaultMutableTreeNode) copy).getUserObject());
+        assertEquals(0, ((DefaultMutableTreeNode) copy).getChildCount());
+        b.removeAllChildren();
+        assertTrue(b.isLeaf());
+        assertNull(b1.getParent());
+    }
+
+    @Test
+    public void pathsAreEqualNodeByNode() {
+        TreePath one = new TreePath(new Object[]{"r", "x", "y"});
+        TreePath two = new TreePath("r").pathByAddingChild("x").pathByAddingChild("y");
+        assertEquals(one, two);
+        assertEquals(one.hashCode(), two.hashCode());
+        assertEquals(3, one.getPathCount());
+        assertEquals("x", one.getPathComponent(1));
+        assertEquals("y", one.getLastPathComponent());
+        assertEquals(new TreePath(new Object[]{"r", "x"}), one.getParentPath());
+        assertTrue(one.getParentPath().isDescendant(two));
+        assertFalse(one.isDescendant(one.getParentPath()));
+        assertFalse(one.equals(new TreePath(new Object[]{"r", "z", "y"})));
+        assertEquals("[r, x, y]", one.toString());
+        assertEquals(3, one.getPath().length);
+    }
+
+    @Test
+    public void theDefaultModelTellsWhatChanged() {
+        DefaultTreeModel model = new DefaultTreeModel(root);
+        final List<String> log = new ArrayList<String>();
+        model.addTreeModelListener(new TreeModelListener() {
+            private String of(String what, TreeModelEvent e) {
+                int[] at = e.getChildIndices();
+                return what + " " + e.getTreePath() + (at != null && at.length > 0 ? " " + at[0] : "");
+            }
+
+            @Override
+            public void treeNodesChanged(TreeModelEvent e) {
+                log.add(of("changed", e));
+            }
+
+            @Override
+            public void treeNodesInserted(TreeModelEvent e) {
+                log.add(of("inserted", e));
+            }
+
+            @Override
+            public void treeNodesRemoved(TreeModelEvent e) {
+                log.add(of("removed", e));
+            }
+
+            @Override
+            public void treeStructureChanged(TreeModelEvent e) {
+                log.add(of("structure", e));
+            }
+        });
+        DefaultMutableTreeNode c = new DefaultMutableTreeNode("c");
+        model.insertNodeInto(c, a, 1);
+        model.valueForPathChanged(new TreePath(model.getPathToRoot(c)), "see");
+        model.removeNodeFromParent(c);
+        model.nodeStructureChanged(b);
+        model.reload();
+        assertEquals("inserted [root, a] 1", log.get(0));
+        assertEquals("changed [root, a] 1", log.get(1));
+        assertEquals("see", c.getUserObject());
+        assertEquals("removed [root, a] 1", log.get(2));
+        assertEquals("structure [root, b]", log.get(3));
+        assertEquals("structure [root]", log.get(4));
+        assertEquals(1, model.getIndexOfChild(root, b));
+        assertSame(a2, model.getChild(a, 1));
+        assertTrue(model.isLeaf(a1));
+        model.setAsksAllowsChildren(true);
+        assertFalse(model.isLeaf(a1));
+    }
+
+    @Test
+    public void theSelectionModelKeepsToItsMode() {
+        DefaultTreeSelectionModel sm = new DefaultTreeSelectionModel();
+        final TreePath pa = new TreePath(new Object[]{"r", "a"});
+        final TreePath pb = new TreePath(new Object[]{"r", "b"});
+        final TreePath pc = new TreePath(new Object[]{"r", "c"});
+        sm.setRowMapper(new RowMapper() {
+            @Override
+            public int[] getRowsForPaths(TreePath[] path) {
+                int[] out = new int[path.length];
+                for (int i = 0; i < path.length; i++) {
+                    out[i] = path[i].equals(pa) ? 1 : path[i].equals(pb) ? 2 : path[i].equals(pc) ? 3 : -1;
+                }
+                return out;
+            }
+        });
+        sm.setSelectionPaths(new TreePath[]{pa, pc});
+        assertEquals(2, sm.getSelectionCount());
+        assertEquals(1, sm.getMinSelectionRow());
+        assertEquals(3, sm.getMaxSelectionRow());
+        assertTrue(sm.isRowSelected(3));
+        assertFalse(sm.isRowSelected(2));
+        sm.setSelectionMode(TreeSelectionModel.CONTIGUOUS_TREE_SELECTION);
+        sm.setSelectionPaths(new TreePath[]{pa, pc});
+        assertEquals("rows 1 and 3 are not one run", 1, sm.getSelectionCount());
+        sm.addSelectionPath(pb);
+        assertEquals(2, sm.getSelectionCount());
+        sm.addSelectionPath(pc);
+        assertEquals(3, sm.getSelectionCount());
+        sm.removeSelectionPath(pb);
+        assertTrue("removing the middle of a run clears it", sm.isSelectionEmpty());
+        sm.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
+        sm.addSelectionPaths(new TreePath[]{pb, pc});
+        assertEquals(1, sm.getSelectionCount());
+        assertEquals(pb, sm.getSelectionPath());
+        assertEquals(pb, sm.getLeadSelectionPath());
+        assertEquals(2, sm.getLeadSelectionRow());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaTest.java
new file mode 100644
index 00000000000..eaefa787d26
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/fife/ui/rsyntaxtextarea/RSyntaxTextAreaTest.java
@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.fife.ui.rsyntaxtextarea;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatDarkLaf;
+import com.codename1.desktopcompat.com.formdev.flatlaf.FlatLightLaf;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.LookAndFeel;
+import com.codename1.desktopcompat.javax.swing.UIManager;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.Gutter;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.RTextScrollPane;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.SearchContext;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.SearchEngine;
+import com.codename1.desktopcompat.org.fife.ui.rtextarea.SearchResult;
+import com.codename1.desktopcompat.rt.LafTheme;
+import java.io.ByteArrayInputStream;
+import org.junit.After;
+import org.junit.Test;
+
+/// The reduced RSyntaxTextArea: what it paints, where its lines are, and
+/// what its search finds.
+public class RSyntaxTextAreaTest extends KernelTestBase {
+
+    private static final String TEXT = "first line\nsecond line\n\tthird\nfourth\nfifth\nsixth\nseventh\n"
+            + "eighth\nninth\ntenth\neleventh\ntwelfth\nthirteenth\nfourteenth\nfifteenth\nsixteenth\n"
+            + "seventeenth\neighteenth\nnineteenth\ntwentieth";
+
+    private RSyntaxTextArea area;
+    private RTextScrollPane pane;
+    private JFrame frame;
+
+    @After
+    public void forget() throws Exception {
+        UIManager.setLookAndFeel((LookAndFeel) null);
+        HeadlessImplementation.darkMode = false;
+        LafTheme.reset();
+    }
+
+    private void open(String text) {
+        area = new RSyntaxTextArea(text);
+        area.setEditable(false);
+        pane = new RTextScrollPane(area);
+        frame = new JFrame();
+        frame.add(pane, BorderLayout.CENTER);
+        frame.setSize(400, 200);
+        show(frame);
+    }
+
+    private static int rgb(Color c) {
+        return c.getRGB() & 0xffffff;
+    }
+
+    /// How many pixels of a band of a component are not `background`.
+    private int inked(int[][] rows, Component c, int y, int height, int background) {
+        int n = 0;
+        for (int yy = y; yy < y + height; yy++) {
+            for (int x = 0; x < c.getWidth() - 1; x++) {
+                if ((pixel(rows, c, x, yy) & 0xffffff) != background) {
+                    n++;
+                }
+            }
+        }
+        return n;
+    }
+
+    @Test
+    public void aLineHighlightIsPaintedBehindItsLineAndGoesWhenRemoved() throws Exception {
+        open(TEXT);
+        area.setHighlightCurrentLine(false);
+        Color red = new Color(200, 30, 30);
+        Color green = new Color(30, 160, 60);
+        Object first = area.addLineHighlight(1, red);
+        area.addLineHighlight(3, green);
+        int h = area.getLineHeight();
+        int x = area.getWidth() - 3;
+        int[][] rows = raster(frame);
+        assertEquals(rgb(red), pixel(rows, area, x, area.yForLine(1) + h / 2) & 0xffffff);
+        assertEquals(rgb(red), pixel(rows, area, x, area.yForLine(1) + 1) & 0xffffff);
+        assertEquals(rgb(green), pixel(rows, area, x, area.yForLine(3) + h / 2) & 0xffffff);
+        int plain = pixel(rows, area, x, area.yForLine(2) + h / 2) & 0xffffff;
+        assertEquals(rgb(area.getBackground()), plain);
+
+        area.removeLineHighlight(first);
+        rows = raster(frame);
+        assertEquals(plain, pixel(rows, area, x, area.yForLine(1) + h / 2) & 0xffffff);
+        assertEquals(rgb(green), pixel(rows, area, x, area.yForLine(3) + h / 2) & 0xffffff);
+
+        area.removeAllLineHighlights();
+        rows = raster(frame);
+        assertEquals(plain, pixel(rows, area, x, area.yForLine(3) + h / 2) & 0xffffff);
+        try {
+            area.addLineHighlight(500, red);
+            fail("no such line");
+        } catch (com.codename1.desktopcompat.javax.swing.text.BadLocationException expected) {
+            assertNotNull(expected);
+        }
+    }
+
+    @Test
+    public void theCurrentLineIsHighlightedAndFollowsTheCaret() throws Exception {
+        open(TEXT);
+        Color mark = new Color(250, 240, 120);
+        area.setCurrentLineHighlightColor(mark);
+        assertTrue(area.getHighlightCurrentLine());
+        area.setCaretPosition(area.getLineStartOffset(2));
+        int h = area.getLineHeight();
+        int x = area.getWidth() - 3;
+        int[][] rows = raster(frame);
+        assertEquals(rgb(mark), pixel(rows, area, x, area.yForLine(2) + h / 2) & 0xffffff);
+        area.setCaretPosition(area.getLineStartOffset(4));
+        rows = raster(frame);
+        assertEquals(rgb(mark), pixel(rows, area, x, area.yForLine(4) + h / 2) & 0xffffff);
+        assertFalse(rgb(mark) == (pixel(rows, area, x, area.yForLine(2) + h / 2) & 0xffffff));
+        assertEquals(4, area.getCaretLineNumber());
+    }
+
+    @Test
+    public void aCharacterIsWhereItsLineAndColumnPutIt() throws Exception {
+        open(TEXT);
+        int h = area.getLineHeight();
+        assertTrue(h > 0);
+        Rectangle start = area.modelToView(0);
+        Rectangle third = area.modelToView(area.getLineStartOffset(2));
+        assertEquals(area.yForLine(2), third.y);
+        assertEquals(start.y + 2 * h, third.y);
+        assertEquals(start.x, third.x);
+        assertEquals(h, third.height);
+        // A tab reaches the next tab stop: four columns.
+        Rectangle afterTab = area.modelToView(area.getLineStartOffset(2) + 1);
+        Rectangle fourIn = area.modelToView(4);
+        assertEquals(fourIn.x, afterTab.x);
+        assertTrue(afterTab.x > third.x);
+        assertEquals(area.yForLine(2), area.yForLineContaining(area.getLineStartOffset(2) + 3));
+        // And back again.
+        assertEquals(4, area.viewToModel(new Point(fourIn.x + 1, fourIn.y + 1)));
+        assertEquals(area.getLineStartOffset(2) + 1, area.viewToModel(new Point(afterTab.x + 1, afterTab.y + 1)));
+        assertEquals(TEXT.length(), area.viewToModel(new Point(5000, 50000)));
+        // Every line has a row, so the text is as high as its lines.
+        assertEquals(20, area.getLineCount());
+        assertTrue(area.getPreferredSize().height >= 20 * h);
+        assertEquals("Monospaced", area.getFont().getFamily());
+    }
+
+    @Test
+    public void theGutterNumbersEveryLineAndScrollsWithTheText() throws Exception {
+        StringBuilder many = new StringBuilder(TEXT);
+        for (int i = 0; i < 100; i++) {
+            many.append("\nline ").append(i);
+        }
+        open(many.toString());
+        Gutter gutter = pane.getGutter();
+        assertSame(area, pane.getTextArea());
+        assertTrue(pane.getLineNumbersEnabled());
+        assertTrue(gutter.getWidth() > 0);
+        int h = area.getLineHeight();
+        int[][] rows = raster(frame);
+        int bg = pixel(rows, gutter, 1, 1) & 0xffffff;
+        assertTrue("line 1 has a number", inked(rows, gutter, 0, h, bg) > 0);
+        assertTrue("line 3 has a number", inked(rows, gutter, 2 * h, h, bg) > 0);
+
+        // Scrolled, the gutter is at the same place as the text.
+        assertTrue(area.getSize() + " in " + pane.getViewport().getSize() + " pref " + area.getPreferredSize()
+                + " line " + h + " gutter " + gutter.getSize() + " pane " + pane.getSize(),
+                area.getHeight() > pane.getViewport().getHeight());
+        pane.getVerticalScrollBar().setValue(5 * h);
+        raster(frame);
+        assertEquals(5 * h, pane.getViewport().getViewPosition().y);
+        assertEquals(5 * h, pane.getRowHeader().getViewPosition().y);
+
+        // Without line numbers the text takes the room.
+        int with = area.getWidth();
+        pane.setLineNumbersEnabled(false);
+        raster(frame);
+        assertFalse(pane.getLineNumbersEnabled());
+        assertTrue(pane.getViewport().getWidth() > 0);
+        assertTrue(pane.getViewport().getWidth() >= with || area.getWidth() >= with);
+        pane.setLineNumbersEnabled(true);
+        pane.setFoldIndicatorEnabled(true);
+        assertTrue(pane.isFoldIndicatorEnabled());
+        raster(frame);
+        assertTrue(gutter.getWidth() > 0);
+    }
+
+    @Test
+    public void aShortTextHasNoNumbersBelowItsLastLine() throws Exception {
+        open("one\ntwo");
+        Gutter gutter = pane.getGutter();
+        int h = area.getLineHeight();
+        int[][] rows = raster(frame);
+        int bg = pixel(rows, gutter, 1, 1) & 0xffffff;
+        assertTrue(inked(rows, gutter, h, h, bg) > 0);
+        assertEquals(0, inked(rows, gutter, 3 * h, h, bg));
+    }
+
+    @Test
+    public void plainSearchFindsSelectsAndWraps() {
+        open("one two One twofold two");
+        area.setCaretPosition(0);
+        SearchContext context = new SearchContext("two");
+        context.setMarkAll(false);
+        SearchResult r = SearchEngine.find(area, context);
+        assertTrue(r.wasFound());
+        assertEquals(1, r.getCount());
+        assertEquals(4, r.getMatchRange().getStartOffset());
+        assertEquals(7, r.getMatchRange().getEndOffset());
+        assertEquals(4, area.getSelectionStart());
+        assertEquals(7, area.getSelectionEnd());
+        assertEquals(12, SearchEngine.find(area, context).getMatchRange().getStartOffset());
+
+        context.setWholeWord(true);
+        r = SearchEngine.find(area, context);
+        assertEquals(20, r.getMatchRange().getStartOffset());
+        assertFalse(SearchEngine.find(area, context).wasFound());
+        context.setSearchWrap(true);
+        r = SearchEngine.find(area, context);
+        assertEquals(4, r.getMatchRange().getStartOffset());
+        assertTrue(r.isWrapped());
+
+        context.setSearchForward(false);
+        context.setSearchWrap(false);
+        assertFalse(SearchEngine.find(area, context).wasFound());
+
+        SearchContext one = new SearchContext("one");
+        one.setMarkAll(false);
+        area.setCaretPosition(1);
+        assertEquals(8, SearchEngine.find(area, one).getMatchRange().getStartOffset());
+        one.setMatchCase(true);
+        area.setCaretPosition(1);
+        assertFalse(SearchEngine.find(area, one).wasFound());
+        one.setSearchForward(false);
+        area.setCaretPosition(6);
+        assertEquals(0, SearchEngine.find(area, one).getMatchRange().getStartOffset());
+
+        assertEquals(4, SearchEngine.getNextMatchPos("two", "one two two", true, true, false));
+        assertEquals(8, SearchEngine.getNextMatchPos("two", "one two two", false, true, false));
+        assertEquals(-1, SearchEngine.getNextMatchPos("TWO", "one two two", true, true, false));
+    }
+
+    @Test
+    public void aRegularExpressionSearchFindsNothing() {
+        open("one two");
+        area.setCaretPosition(0);
+        SearchContext context = new SearchContext("t.o");
+        context.setRegularExpression(true);
+        SearchResult r = SearchEngine.find(area, context);
+        assertFalse(r.wasFound());
+        assertNull(r.getMatchRange());
+        assertEquals(0, SearchEngine.markAll(area, context).getMarkedCount());
+        assertEquals(0, SearchEngine.replaceAll(area, context).getCount());
+        assertEquals("one two", area.getText());
+    }
+
+    @Test
+    public void markAllMarksEveryOccurrenceAndPaintsIt() throws Exception {
+        open("alpha beta\nbeta gamma\nBETA");
+        area.setHighlightCurrentLine(false);
+        Color mark = new Color(255, 200, 0);
+        area.setMarkAllHighlightColor(mark);
+        SearchContext context = new SearchContext("beta");
+        SearchResult r = SearchEngine.markAll(area, context);
+        assertEquals(3, r.getMarkedCount());
+        assertFalse(r.wasFound());
+        assertEquals(3, area.getMarkAllHighlightRanges().size());
+
+        // Marked blanks show the mark itself, with no letter over it:
+        // from the first marked character to the last, on its line only.
+        // (The test font draws a run of text as a block, and a colored
+        // text draws its blanks not at all, so the style is set.)
+        area.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
+        SearchContext blanks = new SearchContext("   ");
+        area.setText("ab\ncd   ef  gh");
+        assertEquals(1, SearchEngine.markAll(area, blanks).getMarkedCount());
+        int h = area.getLineHeight();
+        int[][] rows = raster(frame);
+        Rectangle from = area.modelToView(5);
+        Rectangle to = area.modelToView(8);
+        Rectangle two = area.modelToView(10);
+        assertEquals(h, from.y);
+        assertEquals(rgb(mark), pixel(rows, area, from.x + 1, from.y + h / 2) & 0xffffff);
+        assertEquals(rgb(mark), pixel(rows, area, to.x - 1, to.y + 1) & 0xffffff);
+        assertEquals(rgb(mark), pixel(rows, area, to.x - 1, to.y + h - 1) & 0xffffff);
+        assertEquals(rgb(area.getBackground()), pixel(rows, area, two.x + 2, two.y + h / 2) & 0xffffff);
+        assertEquals(rgb(area.getBackground()), pixel(rows, area, from.x + 1, h + h + h / 2) & 0xffffff);
+        area.setText("alpha beta\nbeta gamma\nBETA");
+        assertEquals(3, SearchEngine.markAll(area, context).getMarkedCount());
+
+        context.setMatchCase(true);
+        assertEquals(2, SearchEngine.markAll(area, context).getMarkedCount());
+        // Finding marks as well, unless the context says not to.
+        area.setCaretPosition(0);
+        context.setMatchCase(false);
+        r = SearchEngine.find(area, context);
+        assertEquals(3, r.getMarkedCount());
+        assertTrue(r.wasFound());
+        context.setMarkAll(false);
+        assertEquals(0, SearchEngine.markAll(area, context).getMarkedCount());
+        assertEquals(0, area.getMarkAllHighlightRanges().size());
+    }
+
+    @Test
+    public void replaceAndReplaceAll() {
+        open("cat dog cat catalog cat");
+        area.setCaretPosition(0);
+        SearchContext context = new SearchContext("cat");
+        context.setReplaceWith("bird");
+        context.setWholeWord(true);
+        SearchResult r = SearchEngine.replace(area, context);
+        assertEquals(1, r.getCount());
+        assertEquals("bird dog cat catalog cat", area.getText());
+        // The next occurrence is selected.
+        assertEquals(9, area.getSelectionStart());
+        assertEquals(12, area.getSelectionEnd());
+        r = SearchEngine.replaceAll(area, context);
+        assertEquals(2, r.getCount());
+        assertEquals("bird dog bird catalog bird", area.getText());
+        assertEquals(0, SearchEngine.replaceAll(area, context).getCount());
+        SearchContext copy = context.clone();
+        assertEquals("cat", copy.getSearchFor());
+        assertEquals("bird", copy.getReplaceWith());
+        assertTrue(copy.getWholeWord());
+    }
+
+    @Test
+    public void theColorsFollowThePaletteAndAThemeReplacesThem() throws Exception {
+        open("int x = 1; // note");
+        area.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
+        assertEquals("text/java", area.getSyntaxEditingStyle());
+        assertTrue(FlatLightLaf.setup());
+        int[][] rows = raster(frame);
+        int light = pixel(rows, area, area.getWidth() - 3, area.getHeight() - 3);
+        Color lightComment = area.getForegroundForTokenType(TokenTypes.COMMENT_EOL);
+        assertTrue(FlatDarkLaf.setup());
+        rows = raster(frame);
+        int dark = pixel(rows, area, area.getWidth() - 3, area.getHeight() - 3);
+        assertTrue("light " + Integer.toHexString(light), (light >> 8 & 0xff) >= 128);
+        assertTrue("dark " + Integer.toHexString(dark), (dark >> 8 & 0xff) < 128);
+        assertFalse(lightComment.equals(area.getForegroundForTokenType(TokenTypes.COMMENT_EOL)));
+        int gutter = pixel(rows, pane.getGutter(), 1, 1);
+        assertTrue("gutter " + Integer.toHexString(gutter), (gutter >> 8 & 0xff) < 128);
+
+        String xml = "<?xml version=\"1.0\"?>\n<RSyntaxTheme version=\"1.0\">\n"
+                + "  <baseFont size=\"15\"/>\n  <background color=\"102030\"/>\n  <caret color=\"ffffff\"/>\n"
+                + "  <selection useFG=\"false\" bg=\"$405060\" roundedEdges=\"false\"/>\n"
+                + "  <currentLineHighlight color=\"203040\" fade=\"false\"/>\n"
+                + "  <markAllHighlight color=\"708090\"/>\n  <gutterBackground color=\"0a0b0c\"/>\n"
+                + "  <gutterBorder color=\"default\"/>\n  <lineNumbers fg=\"aabbcc\" fontSize=\"11\"/>\n"
+                + "  <tokenStyles>\n    <style token=\"COMMENT_EOL\" fg=\"112233\" italic=\"true\"/>\n"
+                + "    <style token=\"IDENTIFIER\" fg=\"ddeeff\"/>\n    <style token=\"NO_SUCH\" fg=\"010101\"/>\n"
+                + "  </tokenStyles>\n</RSyntaxTheme>\n";
+        Theme theme = Theme.load(new ByteArrayInputStream(xml.getBytes("UTF-8")));
+        assertEquals(0x102030, rgb(theme.bgColor));
+        assertEquals(0x405060, rgb(theme.selectionBG));
+        assertNull(theme.gutterBorderColor);
+        assertEquals(15, theme.baseFont.getSize());
+        theme.apply(area);
+        assertEquals(0x102030, rgb(area.getBackground()));
+        assertEquals(0x203040, rgb(area.getCurrentLineHighlightColor()));
+        assertEquals(0x708090, rgb(area.getMarkAllHighlightColor()));
+        assertEquals(0x112233, rgb(area.getForegroundForTokenType(TokenTypes.COMMENT_EOL)));
+        assertEquals(0xddeeff, rgb(area.getForeground()));
+        assertEquals(0xaabbcc, rgb(pane.getGutter().getLineNumberColor()));
+        rows = raster(frame);
+        assertEquals(0x102030, pixel(rows, area, area.getWidth() - 3, area.getHeight() - 3) & 0xffffff);
+        assertEquals(0x0a0b0c, pixel(rows, pane.getGutter(), 1, pane.getGutter().getHeight() - 2) & 0xffffff);
+        assertEquals(0x102030, rgb(new Theme(area).bgColor));
+        try {
+            Theme.load(null);
+            fail("a theme that is not there");
+        } catch (NullPointerException expected) {
+            assertNotNull(expected);
+        }
+    }
+
+    @Test
+    public void theLexerTellsCommentsStringsNumbersAndKeywordsApart() {
+        Lexer lexer = new Lexer();
+        assertEquals(Lexer.C_LIKE, Lexer.family(SyntaxConstants.SYNTAX_STYLE_JAVA));
+        assertEquals(Lexer.HASH, Lexer.family(SyntaxConstants.SYNTAX_STYLE_PYTHON));
+        assertEquals(Lexer.SQL, Lexer.family(SyntaxConstants.SYNTAX_STYLE_SQL));
+        assertEquals(Lexer.MARKUP, Lexer.family(SyntaxConstants.SYNTAX_STYLE_XML));
+        assertEquals(Lexer.NONE, Lexer.family(SyntaxConstants.SYNTAX_STYLE_NONE));
+        assertEquals(Lexer.NONE, Lexer.family(null));
+
+        String line = "int n = 0x1F; String s = \"a // b\"; // done";
+        assertEquals(0, lexer.scan(line, Lexer.C_LIKE, 0));
+        assertEquals(TokenTypes.DATA_TYPE, typeAt(lexer, line.indexOf("int")));
+        assertEquals(TokenTypes.IDENTIFIER, typeAt(lexer, line.indexOf("n =")));
+        assertEquals(TokenTypes.LITERAL_NUMBER_HEXADECIMAL, typeAt(lexer, line.indexOf("0x1F")));
+        assertEquals(TokenTypes.LITERAL_STRING_DOUBLE_QUOTE, typeAt(lexer, line.indexOf("// b")));
+        assertEquals(TokenTypes.COMMENT_EOL, typeAt(lexer, line.indexOf("// done") + 3));
+
+        assertEquals(1, lexer.scan("return x; /* open", Lexer.C_LIKE, 0));
+        assertEquals(TokenTypes.RESERVED_WORD, typeAt(lexer, 0));
+        assertEquals(TokenTypes.COMMENT_MULTILINE, typeAt(lexer, 14));
+        assertEquals(1, lexer.scan("still inside", Lexer.C_LIKE, 1));
+        assertEquals(TokenTypes.COMMENT_MULTILINE, typeAt(lexer, 3));
+        assertEquals(0, lexer.scan("end */ if (true)", Lexer.C_LIKE, 1));
+        assertEquals(TokenTypes.COMMENT_MULTILINE, typeAt(lexer, 1));
+        assertEquals(TokenTypes.RESERVED_WORD, typeAt(lexer, 7));
+        assertEquals(TokenTypes.LITERAL_BOOLEAN, typeAt(lexer, 11));
+
+        lexer.scan("def f(): # note", Lexer.HASH, 0);
+        assertEquals(TokenTypes.RESERVED_WORD, typeAt(lexer, 0));
+        assertEquals(TokenTypes.COMMENT_EOL, typeAt(lexer, 12));
+        lexer.scan("select a from t -- all", Lexer.SQL, 0);
+        assertEquals(TokenTypes.RESERVED_WORD, typeAt(lexer, 0));
+        assertEquals(TokenTypes.IDENTIFIER, typeAt(lexer, 7));
+        assertEquals(TokenTypes.COMMENT_EOL, typeAt(lexer, 18));
+        String tag = "<a href=\"x\">text</a> <!-- c";
+        assertEquals(1, lexer.scan(tag, Lexer.MARKUP, 0));
+        assertEquals(TokenTypes.MARKUP_TAG_NAME, typeAt(lexer, 1));
+        assertEquals(TokenTypes.MARKUP_TAG_ATTRIBUTE, typeAt(lexer, 3));
+        assertEquals(TokenTypes.MARKUP_TAG_ATTRIBUTE_VALUE, typeAt(lexer, 9));
+        assertEquals(TokenTypes.IDENTIFIER, typeAt(lexer, 13));
+        assertEquals(TokenTypes.MARKUP_COMMENT, typeAt(lexer, tag.length() - 1));
+    }
+
+    private static int typeAt(Lexer lexer, int index) {
+        for (int i = 0; i < lexer.count; i++) {
+            if (index < lexer.ends[i]) {
+                return lexer.types[i];
+            }
+        }
+        return -1;
+    }
+
+    @Test
+    public void theEditorSwitchesAreRecorded() {
+        open("x");
+        area.setAntiAliasingEnabled(false);
+        area.setCodeFoldingEnabled(true);
+        area.setBracketMatchingEnabled(false);
+        area.setAnimateBracketMatching(false);
+        area.setLineWrap(true);
+        area.forceReparsing(0);
+        assertFalse(area.getAntiAliasingEnabled());
+        assertTrue(area.isCodeFoldingEnabled());
+        assertFalse(area.isBracketMatchingEnabled());
+        assertFalse(area.getAnimateBracketMatching());
+        assertEquals(0, area.getParserCount());
+        assertFalse(area.canUndo());
+        assertEquals(4, area.getTabSize());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/CollapsibleAndTaskPaneTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/CollapsibleAndTaskPaneTest.java
new file mode 100644
index 00000000000..ec70ec9c6b5
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/CollapsibleAndTaskPaneTest.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FlowLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// The collapsible pane's sizes while it closes and opens, and the task
+/// pane and its container built on it.
+public class CollapsibleAndTaskPaneTest extends KernelTestBase {
+
+    private static JPanel box(int w, int h) {
+        JPanel p = new JPanel();
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+
+    private static final class Log implements PropertyChangeListener {
+        final List<String> seen = new ArrayList<String>();
+
+        @Override
+        public void propertyChange(PropertyChangeEvent evt) {
+            if ("collapsed".equals(evt.getPropertyName()) || "animationState".equals(evt.getPropertyName())) {
+                seen.add(evt.getPropertyName() + "=" + evt.getNewValue());
+            }
+        }
+    }
+
+    @Test
+    public void componentsAndLayoutGoToTheContentPane() {
+        JXCollapsiblePane pane = new JXCollapsiblePane();
+        JPanel child = box(100, 80);
+        pane.add(child);
+        assertEquals(1, pane.getComponentCount());
+        assertSame(pane.getContentPane(), pane.getComponent(0));
+        assertSame(pane.getContentPane(), child.getParent());
+        assertTrue(pane.getContentPane().getLayout() instanceof VerticalLayout);
+        FlowLayout flow = new FlowLayout();
+        pane.setLayout(flow);
+        assertSame(flow, pane.getContentPane().getLayout());
+        pane.remove(child);
+        assertEquals(0, pane.getContentPane().getComponentCount());
+        assertTrue(JXCollapsiblePane.Direction.UP.isVertical());
+        assertTrue(JXCollapsiblePane.Direction.END.isVertical());
+        assertFalse(JXCollapsiblePane.Direction.LEFT.isVertical());
+        assertFalse(JXCollapsiblePane.Direction.TRAILING.isVertical());
+    }
+
+    @Test
+    public void collapsingWithoutAnimationIsImmediate() {
+        JXCollapsiblePane pane = new JXCollapsiblePane();
+        pane.setAnimated(false);
+        pane.add(box(100, 80));
+        Log log = new Log();
+        pane.addPropertyChangeListener(log);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.NORTH);
+        show(f);
+        f.validate();
+        assertEquals(80, pane.getHeight());
+        assertEquals(80, pane.getContentPane().getHeight());
+
+        pane.setCollapsed(true);
+        assertTrue(pane.isCollapsed());
+        assertFalse(pane.cn1Animating());
+        f.validate();
+        assertEquals(0, pane.getPreferredSize().height);
+        assertEquals(0, pane.getHeight());
+        assertFalse(pane.getContentPane().isVisible());
+        assertEquals("[animationState=reinit, animationState=collapsed, collapsed=true]", log.seen.toString());
+
+        pane.setCollapsed(false);
+        f.validate();
+        assertEquals(80, pane.getHeight());
+        assertTrue(pane.getContentPane().isVisible());
+    }
+
+    @Test
+    public void anAnimatedChangeRunsInEightSteps() {
+        JXCollapsiblePane pane = new JXCollapsiblePane();
+        assertTrue(pane.isAnimated());
+        pane.add(box(100, 80));
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.NORTH);
+        show(f);
+        f.validate();
+
+        pane.setCollapsed(true);
+        assertTrue(pane.isCollapsed());
+        assertTrue(pane.cn1Animating());
+        assertEquals(80, pane.getPreferredSize().height);
+        pane.cn1AnimationStep();
+        f.validate();
+        assertEquals(70, pane.getHeight());
+        // UP: the content keeps its height and slides out through the top.
+        assertEquals(80, pane.getContentPane().getHeight());
+        assertEquals(-10, pane.getContentPane().getY());
+        assertTrue(pane.getContentPane().isVisible());
+        for (int i = 0; i < 6; i++) {
+            pane.cn1AnimationStep();
+        }
+        f.validate();
+        assertEquals(10, pane.getHeight());
+        assertTrue(pane.cn1Animating());
+        pane.cn1AnimationStep();
+        f.validate();
+        assertFalse(pane.cn1Animating());
+        assertEquals(0, pane.getHeight());
+        assertFalse(pane.getContentPane().isVisible());
+
+        // Reversing half way goes back from where it is.
+        pane.setCollapsed(false);
+        assertTrue(pane.getContentPane().isVisible());
+        pane.cn1AnimationStep();
+        pane.cn1AnimationStep();
+        f.validate();
+        assertEquals(20, pane.getHeight());
+        pane.setCollapsed(true);
+        pane.cn1AnimationStep();
+        f.validate();
+        assertEquals(10, pane.getHeight());
+        pane.setCollapsed(false);
+        for (int i = 0; i < 7; i++) {
+            pane.cn1AnimationStep();
+        }
+        f.validate();
+        assertFalse(pane.cn1Animating());
+        assertEquals(80, pane.getHeight());
+    }
+
+    @Test
+    public void aHorizontalPaneShrinksItsWidth() {
+        JXCollapsiblePane pane = new JXCollapsiblePane(JXCollapsiblePane.Direction.RIGHT);
+        pane.setAnimated(false);
+        pane.add(box(100, 80));
+        assertEquals(new Dimension(100, 80), pane.getPreferredSize());
+        pane.setCollapsed(true);
+        assertEquals(new Dimension(0, 80), pane.getPreferredSize());
+    }
+
+    @Test
+    public void tappingTheTitleTogglesATaskPane() {
+        JXTaskPane tasks = new JXTaskPane("Tasks");
+        tasks.setAnimated(false);
+        tasks.add(box(100, 60));
+        Log log = new Log();
+        tasks.addPropertyChangeListener(log);
+        JFrame f = new JFrame();
+        f.add(tasks, BorderLayout.NORTH);
+        show(f);
+        f.validate();
+        int bar = tasks.cn1TitleBar().getHeight();
+        assertTrue(bar > 0);
+        // 60 of content and 8 of padding above and below it.
+        assertEquals(bar + 76, tasks.getHeight());
+        assertNotNull(find(paint(f), "Tasks"));
+
+        press(f, tasks.cn1TitleBar(), 60, bar / 2);
+        release(f, tasks.cn1TitleBar(), 60, bar / 2);
+        assertTrue(tasks.isCollapsed());
+        f.validate();
+        assertEquals(bar, tasks.getHeight());
+        assertEquals("[collapsed=true]", log.seen.toString());
+
+        press(f, tasks.cn1TitleBar(), 60, bar / 2);
+        release(f, tasks.cn1TitleBar(), 60, bar / 2);
+        assertFalse(tasks.isCollapsed());
+        f.validate();
+        assertEquals(bar + 76, tasks.getHeight());
+    }
+
+    @Test
+    public void anActionBecomesALinkInTheTaskPane() {
+        final int[] fired = new int[1];
+        JXTaskPane tasks = new JXTaskPane();
+        tasks.setTitle("Files");
+        assertEquals("Files", tasks.getTitle());
+        Component link = tasks.add(new AbstractAction("Open") {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                fired[0]++;
+            }
+        });
+        assertTrue(link instanceof JXHyperlink);
+        assertSame(tasks.getContentPane(), link.getParent());
+        JFrame f = new JFrame();
+        f.add(tasks, BorderLayout.NORTH);
+        show(f);
+        f.validate();
+        assertNotNull(find(paint(f), "Open"));
+        press(f, link, 5, 5);
+        release(f, link, 5, 5);
+        assertEquals(1, fired[0]);
+        assertTrue(((JXHyperlink) link).isClicked());
+        tasks.setSpecial(true);
+        assertTrue(tasks.isSpecial());
+        tasks.setScrollOnExpand(true);
+        assertTrue(tasks.isScrollOnExpand());
+    }
+
+    @Test
+    public void theContainerStacksTaskPanes() {
+        JXTaskPaneContainer container = new JXTaskPaneContainer();
+        JXTaskPane first = new JXTaskPane("One");
+        first.setAnimated(false);
+        first.add(box(100, 60));
+        JXTaskPane second = new JXTaskPane("Two");
+        second.setAnimated(false);
+        second.add(box(100, 40));
+        container.add(first);
+        container.add(second);
+        JFrame f = new JFrame();
+        f.add(container, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        assertSame(container, first.getValidatingContainer());
+        assertEquals(14, first.getX());
+        assertEquals(14, first.getY());
+        assertEquals(container.getWidth() - 28, first.getWidth());
+        int open = first.getHeight();
+        assertEquals(14 + open + 14, second.getY());
+        assertEquals(first.getWidth(), second.getWidth());
+
+        first.setCollapsed(true);
+        f.validate();
+        assertEquals(open - 76, first.getHeight());
+        assertEquals(14 + open - 76 + 14, second.getY());
+        assertTrue(container.getScrollableTracksViewportWidth());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDatePickerTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDatePickerTest.java
new file mode 100644
index 00000000000..52f31d2c979
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXDatePickerTest.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.ui.spinner.Picker;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import org.junit.Test;
+
+/// The date picker: the date it holds, the text its formats show it
+/// with, what a choice in the chooser tells the listeners, and the month
+/// view that follows along. Every date is fixed.
+public class JXDatePickerTest extends KernelTestBase {
+
+    private static Date date(int month, int day, int hour) {
+        Calendar c = Calendar.getInstance();
+        c.set(Calendar.YEAR, 2024);
+        c.set(Calendar.MONTH, month);
+        c.set(Calendar.DAY_OF_MONTH, day);
+        c.set(Calendar.HOUR_OF_DAY, hour);
+        c.set(Calendar.MINUTE, 0);
+        c.set(Calendar.SECOND, 0);
+        c.set(Calendar.MILLISECOND, 0);
+        return c.getTime();
+    }
+
+    private JFrame open(JXDatePicker picker) {
+        JFrame f = new JFrame();
+        f.add(picker, BorderLayout.NORTH);
+        return show(f);
+    }
+
+    private static Picker peer(JXDatePicker picker) {
+        return (Picker) picker.cn1Peer();
+    }
+
+    private static List<String> listen(JXDatePicker picker) {
+        final List<String> commands = new ArrayList<String>();
+        picker.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                commands.add(e.getActionCommand());
+            }
+        });
+        return commands;
+    }
+
+    @Test
+    public void theDateIsKeptAsItsDay() {
+        JXDatePicker picker = new JXDatePicker();
+        assertNull(picker.getDate());
+        final List<Object> changes = new ArrayList<Object>();
+        picker.addPropertyChangeListener("date", new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                changes.add(e.getNewValue());
+            }
+        });
+        picker.setDate(date(Calendar.MARCH, 15, 17));
+        assertEquals(date(Calendar.MARCH, 15, 0), picker.getDate());
+        assertEquals(1, changes.size());
+        assertEquals(date(Calendar.MARCH, 15, 0), changes.get(0));
+        // Another hour of the same day is the same date.
+        picker.setDate(date(Calendar.MARCH, 15, 3));
+        assertEquals(1, changes.size());
+        picker.setDate(null);
+        assertNull(picker.getDate());
+        assertEquals(2, changes.size());
+        assertEquals(date(Calendar.JUNE, 2, 0), new JXDatePicker(date(Calendar.JUNE, 2, 9)).getDate());
+    }
+
+    @Test
+    public void theFirstFormatShowsTheDateAndReadsItBack() throws Exception {
+        JXDatePicker picker = new JXDatePicker(date(Calendar.MARCH, 15, 17));
+        picker.setFormats("yyyy-MM-dd", "dd/MM/yyyy");
+        DateFormat[] formats = picker.getFormats();
+        assertEquals(2, formats.length);
+        open(picker);
+        assertEquals("2024-03-15", peer(picker).getText());
+        assertEquals(picker.getDate(), formats[0].parse(peer(picker).getText()));
+
+        picker.setDate(date(Calendar.NOVEMBER, 3, 0));
+        assertEquals("2024-11-03", peer(picker).getText());
+        assertEquals(picker.getDate(), formats[0].parse(peer(picker).getText()));
+
+        // Formats handed over as objects, and replaced while showing.
+        DateFormat other = new SimpleDateFormat("dd.MM.yyyy");
+        picker.setFormats(other);
+        assertEquals(1, picker.getFormats().length);
+        assertSame(other, picker.getFormats()[0]);
+        assertEquals("03.11.2024", peer(picker).getText());
+        assertEquals(picker.getDate(), other.parse(peer(picker).getText()));
+
+        // The array handed out is a copy.
+        picker.getFormats()[0] = null;
+        assertSame(other, picker.getFormats()[0]);
+        try {
+            picker.setFormats("yyyy", null);
+            throw new AssertionError("a null pattern must be refused");
+        } catch (NullPointerException expected) {
+            assertSame(other, picker.getFormats()[0]);
+        }
+    }
+
+    @Test
+    public void aChoiceInTheChooserCommits() throws Exception {
+        JXDatePicker picker = new JXDatePicker(date(Calendar.MARCH, 15, 0));
+        picker.setFormats("yyyy-MM-dd");
+        List<String> commands = listen(picker);
+        open(picker);
+        assertEquals("setting up tells nobody", 0, commands.size());
+        picker.setDate(date(Calendar.MARCH, 16, 0));
+        assertEquals("nor does a date set by the program", 0, commands.size());
+
+        // What the chooser does when the user picks a date.
+        peer(picker).setDate(date(Calendar.MARCH, 20, 11));
+        assertEquals(date(Calendar.MARCH, 20, 0), picker.getDate());
+        assertEquals(1, commands.size());
+        assertEquals(JXDatePicker.COMMIT_KEY, commands.get(0));
+        assertEquals("2024-03-20", peer(picker).getText());
+        assertEquals(date(Calendar.MARCH, 20, 0), picker.getMonthView().getSelectionDate());
+
+        assertTrue(picker.isEditValid());
+        picker.commitEdit();
+        assertEquals(date(Calendar.MARCH, 20, 0), picker.getDate());
+        assertEquals(2, commands.size());
+        assertEquals(JXDatePicker.COMMIT_KEY, commands.get(1));
+        picker.cancelEdit();
+        assertEquals(JXDatePicker.CANCEL_KEY, commands.get(2));
+        assertEquals(date(Calendar.MARCH, 20, 0), picker.getDate());
+    }
+
+    @Test
+    public void theMonthViewFollowsAndLeads() {
+        JXDatePicker picker = new JXDatePicker();
+        JXMonthView view = picker.getMonthView();
+        assertTrue(view.isSelectionEmpty());
+        picker.setDate(date(Calendar.AUGUST, 21, 6));
+        assertEquals(date(Calendar.AUGUST, 21, 0), view.getSelectionDate());
+        assertEquals(date(Calendar.AUGUST, 1, 0), view.getFirstDisplayedDay());
+
+        // A day committed in the month view becomes the picker's date.
+        List<String> commands = listen(picker);
+        view.setSelectionDate(date(Calendar.AUGUST, 9, 0));
+        assertEquals("not before it is committed", date(Calendar.AUGUST, 21, 0), picker.getDate());
+        view.commitSelection();
+        assertEquals(date(Calendar.AUGUST, 9, 0), picker.getDate());
+        assertEquals(1, commands.size());
+        assertEquals(JXDatePicker.COMMIT_KEY, commands.get(0));
+
+        // A cancelled choice is put back.
+        view.setSelectionDate(date(Calendar.AUGUST, 30, 0));
+        view.cancelSelection();
+        assertEquals(date(Calendar.AUGUST, 9, 0), view.getSelectionDate());
+        assertEquals(JXDatePicker.CANCEL_KEY, commands.get(1));
+
+        // A new month view takes the date over, and the old one is let go.
+        JXMonthView other = new JXMonthView(date(Calendar.JANUARY, 1, 0));
+        picker.setMonthView(other);
+        assertSame(other, picker.getMonthView());
+        assertEquals(date(Calendar.AUGUST, 9, 0), other.getSelectionDate());
+        view.setSelectionDate(date(Calendar.AUGUST, 2, 0));
+        view.commitSelection();
+        assertEquals(date(Calendar.AUGUST, 9, 0), picker.getDate());
+        assertEquals(2, commands.size());
+    }
+
+    @Test
+    public void theChooserOpensOnlyWhenEditableAndEnabled() {
+        JXDatePicker picker = new JXDatePicker(date(Calendar.MARCH, 15, 0));
+        open(picker);
+        assertTrue(picker.isEditable());
+        assertTrue(peer(picker).isEnabled());
+        picker.setEditable(false);
+        assertFalse(picker.isEditable());
+        assertFalse(peer(picker).isEnabled());
+        picker.setEditable(true);
+        assertTrue(peer(picker).isEnabled());
+        picker.setEnabled(false);
+        assertFalse(peer(picker).isEnabled());
+        picker.setEnabled(true);
+        assertTrue(peer(picker).isEnabled());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXListAndTreeTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXListAndTreeTest.java
new file mode 100644
index 00000000000..b6a11742ceb
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXListAndTreeTest.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.DefaultListModel;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JList;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.ListCellRenderer;
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import com.codename1.desktopcompat.javax.swing.tree.DefaultMutableTreeNode;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ColorHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.HighlightPredicate;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultListRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultTreeRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import java.util.Comparator;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// `JXList` and `JXTree`: highlighters through painting, the list's
+/// sorting and filtering, the tree's expand-all, and rollover.
+public class JXListAndTreeTest extends KernelTestBase {
+
+    private static final Color RED = new Color(200, 0, 0);
+    private static final Color BLUE = new Color(0, 0, 200);
+
+    /// Draws its value and the background it was left with.
+    private static final class Stamp extends JComponent implements ListCellRenderer<Object>, TreeCellRenderer {
+        private String text = "";
+
+        @Override
+        public Component getListCellRendererComponent(JList<? extends Object> list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            text = String.valueOf(value);
+            setBackground(Color.WHITE);
+            return this;
+        }
+
+        @Override
+        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
+                boolean leaf, int row, boolean hasFocus) {
+            text = String.valueOf(value);
+            setBackground(Color.WHITE);
+            return this;
+        }
+
+        @Override
+        public com.codename1.desktopcompat.java.awt.Dimension getPreferredSize() {
+            return new com.codename1.desktopcompat.java.awt.Dimension(150, 20);
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            Color bg = getBackground();
+            g.drawString(text + "@" + bg.getRed() + "," + bg.getGreen() + "," + bg.getBlue(), 2, 12);
+        }
+    }
+
+    private JFrame placed(JComponent c, int w, int h) {
+        JPanel p = new JPanel(null);
+        c.setBounds(0, 0, w, h);
+        p.add(c);
+        JFrame f = new JFrame();
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    private static DefaultListModel<Object> fruit() {
+        DefaultListModel<Object> m = new DefaultListModel<Object>();
+        m.addElement("pear");
+        m.addElement("apple");
+        m.addElement("fig");
+        m.addElement("banana");
+        return m;
+    }
+
+    @Test
+    public void listHighlightersApplyInOrderWhenTheListPaints() {
+        JXList l = new JXList(fruit());
+        l.setCellRenderer(new Stamp());
+        l.addHighlighter(new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        l.addHighlighter(new ColorHighlighter(HighlightPredicate.ODD, BLUE, null));
+        JFrame f = placed(l, 300, 300);
+        List<Object[]> drawn = paint(f);
+        assertNotNull(find(drawn, "pear@200,0,0"));
+        assertNotNull(find(drawn, "apple@0,0,200"));
+        assertNotNull(find(drawn, "fig@200,0,0"));
+        l.setHighlighters(new ColorHighlighter(HighlightPredicate.ODD, BLUE, null),
+                new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        assertNotNull(find(paint(f), "apple@200,0,0"));
+        assertTrue(l.getWrappedCellRenderer() instanceof Stamp);
+        assertFalse(l.getCellRenderer() instanceof Stamp);
+    }
+
+    @Test
+    public void theDefaultListRendererTakesAHighlight() {
+        JXList l = new JXList(fruit());
+        assertTrue(l.getWrappedCellRenderer() instanceof DefaultListRenderer);
+        l.addHighlighter(new ColorHighlighter(new HighlightPredicate.EqualsHighlightPredicate("fig"), RED, null));
+        Component c = l.getCellRenderer().getListCellRendererComponent(l, "fig", 2, false, false);
+        assertEquals(RED, c.getBackground());
+        c = l.getCellRenderer().getListCellRendererComponent(l, "banana", 3, false, false);
+        assertEquals(l.getBackground(), c.getBackground());
+        JFrame f = placed(l, 300, 300);
+        assertNotNull(find(paint(f), "banana"));
+    }
+
+    @Test
+    public void aListSortsAndFiltersItsView() {
+        DefaultListModel<Object> m = fruit();
+        JXList l = new JXList(m, true);
+        assertSame(m, l.getModel());
+        assertEquals(4, l.getElementCount());
+        assertEquals("pear", l.getElementAt(0));
+        assertEquals(SortOrder.UNSORTED, l.getSortOrder());
+
+        l.setSelectedIndex(0);
+        l.toggleSortOrder();
+        assertEquals(SortOrder.ASCENDING, l.getSortOrder());
+        assertEquals("apple", l.getElementAt(0));
+        assertEquals("pear", l.getElementAt(3));
+        assertEquals(1, l.convertIndexToModel(0));
+        assertEquals(3, l.convertIndexToView(0));
+        assertEquals("the selection followed its element", 3, l.getSelectedIndex());
+        assertEquals("pear", l.getSelectedValue());
+
+        l.toggleSortOrder();
+        assertEquals(SortOrder.DESCENDING, l.getSortOrder());
+        assertEquals("pear", l.getElementAt(0));
+
+        l.setRowFilter(new RowFilter<Object, Integer>() {
+            @Override
+            public boolean include(RowFilter.Entry<? extends Object, ? extends Integer> entry) {
+                return entry.getStringValue(0).length() > 3;
+            }
+        });
+        assertEquals(3, l.getElementCount());
+        assertEquals(4, l.getModel().getSize());
+        assertEquals(-1, l.convertIndexToView(2));
+        assertEquals("pear", l.getElementAt(0));
+        assertEquals("apple", l.getElementAt(2));
+
+        m.addElement("cherry");
+        assertEquals(4, l.getElementCount());
+        assertEquals("cherry", l.getElementAt(1));
+
+        l.setRowFilter(null);
+        l.resetSortOrder();
+        assertEquals(5, l.getElementCount());
+        assertEquals("pear", l.getElementAt(0));
+
+        l.setComparator(new Comparator<Object>() {
+            @Override
+            public int compare(Object a, Object b) {
+                return a.toString().length() - b.toString().length();
+            }
+        });
+        l.setSortOrder(SortOrder.ASCENDING);
+        assertEquals("fig", l.getElementAt(0));
+
+        l.setSortable(false);
+        l.toggleSortOrder();
+        assertEquals(SortOrder.ASCENDING, l.getSortOrder());
+    }
+
+    @Test
+    public void aSortedListPaintsInViewOrder() {
+        JXList l = new JXList(fruit(), true);
+        l.setCellRenderer(new DefaultListRenderer(new StringValue() {
+            @Override
+            public String getString(Object value) {
+                return "<" + value + ">";
+            }
+        }));
+        assertEquals("<pear>", l.getStringAt(0));
+        l.toggleSortOrder();
+        JFrame f = placed(l, 300, 300);
+        List<Object[]> drawn = paint(f);
+        Object[] apple = find(drawn, "<apple>");
+        Object[] pear = find(drawn, "<pear>");
+        assertNotNull(apple);
+        assertNotNull(pear);
+        assertTrue(((Integer) apple[2]).intValue() < ((Integer) pear[2]).intValue());
+    }
+
+    @Test
+    public void aListWithoutASorterShowsItsModel() {
+        DefaultListModel<Object> m = fruit();
+        JXList l = new JXList(m);
+        assertNull(l.getRowSorter());
+        l.toggleSortOrder();
+        assertEquals("pear", l.getElementAt(0));
+        l.setSelectedIndex(2);
+        m.add(0, "kiwi");
+        assertEquals(5, l.getElementCount());
+        assertEquals("kiwi", l.getElementAt(0));
+        JXList fromArray = new JXList(new Object[]{"b", "a"}, true);
+        fromArray.toggleSortOrder();
+        assertEquals("a", fromArray.getElementAt(0));
+    }
+
+    @Test
+    public void listRolloverFollowsThePointer() {
+        JXList l = new JXList(fruit());
+        placed(l, 300, 300);
+        l.setRolloverEnabled(true);
+        l.addHighlighter(new ColorHighlighter(HighlightPredicate.ROLLOVER_ROW, RED, null));
+        com.codename1.desktopcompat.java.awt.Rectangle cell = l.getCellBounds(1, 1);
+        l.dispatchEvent(new MouseEvent(l, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, cell.x + 2,
+                cell.y + 2, 0, false, MouseEvent.NOBUTTON));
+        assertEquals(new Point(0, 1), l.getClientProperty("swingx.rollover"));
+        assertEquals(RED, l.getCellRenderer().getListCellRendererComponent(l, "apple", 1, false, false)
+                .getBackground());
+        assertEquals(l.getBackground(), l.getCellRenderer().getListCellRendererComponent(l, "pear", 0, false, false)
+                .getBackground());
+    }
+
+    private static JXTree tree() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
+        DefaultMutableTreeNode a = new DefaultMutableTreeNode("a");
+        DefaultMutableTreeNode b = new DefaultMutableTreeNode("b");
+        a.add(new DefaultMutableTreeNode("a1"));
+        DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("a2");
+        a2.add(new DefaultMutableTreeNode("deep"));
+        a.add(a2);
+        b.add(new DefaultMutableTreeNode("b1"));
+        root.add(a);
+        root.add(b);
+        return new JXTree(root);
+    }
+
+    @Test
+    public void expandAllAndCollapseAll() {
+        JXTree t = tree();
+        assertEquals(3, t.getRowCount());
+        t.expandAll();
+        assertEquals(7, t.getRowCount());
+        assertEquals("deep", t.getStringAt(4));
+        t.collapseAll();
+        assertEquals(1, t.getRowCount());
+    }
+
+    @Test
+    public void treeHighlightersSeeDepthAndLeaves() {
+        JXTree t = tree();
+        t.expandAll();
+        assertTrue(t.getWrappedCellRenderer() instanceof DefaultTreeRenderer);
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.IS_LEAF, RED, null));
+        t.addHighlighter(new ColorHighlighter(new HighlightPredicate.DepthHighlightPredicate(1), BLUE, null));
+        Object a1 = t.getPathForRow(2).getLastPathComponent();
+        Object a = t.getPathForRow(1).getLastPathComponent();
+        Object root = t.getPathForRow(0).getLastPathComponent();
+        assertEquals(RED, t.getCellRenderer().getTreeCellRendererComponent(t, a1, false, false, true, 2, false)
+                .getBackground());
+        assertEquals(BLUE, t.getCellRenderer().getTreeCellRendererComponent(t, a, false, true, false, 1, false)
+                .getBackground());
+        Color plain = t.getCellRenderer().getTreeCellRendererComponent(t, root, false, true, false, 0, false)
+                .getBackground();
+        assertFalse(RED.equals(plain));
+        assertFalse(BLUE.equals(plain));
+    }
+
+    @Test
+    public void treeHighlightersApplyInOrderWhenTheTreePaints() {
+        JXTree t = tree();
+        t.setCellRenderer(new Stamp());
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.IS_FOLDER, BLUE, null));
+        t.expandAll();
+        JFrame f = placed(t, 300, 400);
+        List<Object[]> drawn = paint(f);
+        assertNotNull(find(drawn, "a1@200,0,0"));
+        assertNotNull(find(drawn, "a@0,0,200"));
+        t.setHighlighters(new ColorHighlighter(HighlightPredicate.IS_FOLDER, BLUE, null),
+                new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        assertNotNull(find(paint(f), "a@200,0,0"));
+    }
+
+    @Test
+    public void treeRolloverFollowsThePointer() {
+        JXTree t = tree();
+        placed(t, 300, 300);
+        t.setRolloverEnabled(true);
+        com.codename1.desktopcompat.java.awt.Rectangle row = t.getRowBounds(1);
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, row.x + 2,
+                row.y + 2, 0, false, MouseEvent.NOBUTTON));
+        assertEquals(new Point(0, 1), t.getClientProperty("swingx.rollover"));
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_EXITED, System.currentTimeMillis(), 0, row.x + 2,
+                row.y + 2, 0, false, MouseEvent.NOBUTTON));
+        assertNull(t.getClientProperty("swingx.rollover"));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXMonthViewTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXMonthViewTest.java
new file mode 100644
index 00000000000..fe3a6edcb0c
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXMonthViewTest.java
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DateSelectionModel.SelectionMode;
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DaySelectionModel;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import org.junit.Test;
+
+/// The month view: where its days are, what presses select and how the
+/// month moves. Every date is fixed; March 2024 starts on a Friday and
+/// has 31 days.
+public class JXMonthViewTest extends KernelTestBase {
+
+    private static Date date(int month, int day, int hour) {
+        Calendar c = Calendar.getInstance();
+        c.set(Calendar.YEAR, 2024);
+        c.set(Calendar.MONTH, month);
+        c.set(Calendar.DAY_OF_MONTH, day);
+        c.set(Calendar.HOUR_OF_DAY, hour);
+        c.set(Calendar.MINUTE, 0);
+        c.set(Calendar.SECOND, 0);
+        c.set(Calendar.MILLISECOND, 0);
+        return c.getTime();
+    }
+
+    private static Date march(int day) {
+        return date(Calendar.MARCH, day, 0);
+    }
+
+    private JXMonthView view;
+    private JFrame frame;
+
+    private void open() {
+        view = new JXMonthView(march(1));
+        frame = new JFrame();
+        frame.add(view, BorderLayout.CENTER);
+        show(frame);
+    }
+
+    private void click(Rectangle r) {
+        int x = r.x + r.width / 2;
+        int y = r.y + r.height / 2;
+        press(frame, view, x, y);
+        release(frame, view, x, y);
+    }
+
+    private Date at(Rectangle r) {
+        return view.getDayAtLocation(r.x + r.width / 2, r.y + r.height / 2);
+    }
+
+    @Test
+    public void aPointFindsItsDay() {
+        open();
+        assertEquals(march(1), view.getFirstDisplayedDay());
+        int[] days = {1, 2, 9, 15, 30, 31};
+        for (int i = 0; i < days.length; i++) {
+            Rectangle r = view.cn1DayBounds(date(Calendar.MARCH, days[i], 13));
+            assertNotNull(r);
+            assertTrue(r.width > 0 && r.height > 0);
+            assertEquals(march(days[i]), at(r));
+            assertEquals(march(days[i]), view.getDayAtLocation(r.x, r.y));
+            assertEquals(march(days[i]), view.getDayAtLocation(r.x + r.width - 1, r.y + r.height - 1));
+        }
+        // A week is a row: the 8th sits right under the 1st.
+        Rectangle first = view.cn1DayBounds(march(1));
+        Rectangle eighth = view.cn1DayBounds(march(8));
+        assertEquals(first.x, eighth.x);
+        assertEquals(first.y + first.height, eighth.y);
+        assertNull("a day of another month has no box", view.cn1DayBounds(date(Calendar.APRIL, 1, 0)));
+    }
+
+    @Test
+    public void theTitleTheDayNamesAndTheEmptyBoxesHoldNoDay() {
+        open();
+        Rectangle previous = view.cn1ArrowBounds(false);
+        Rectangle next = view.cn1ArrowBounds(true);
+        assertTrue(previous.x < next.x);
+        assertNull(at(previous));
+        assertNull(at(next));
+        assertNull("the title", view.getDayAtLocation(view.getWidth() / 2, previous.y + previous.height / 2));
+        assertNull("the day names",
+                view.getDayAtLocation(view.getWidth() / 2, previous.y + previous.height + previous.height / 2));
+        // With Sunday first the 1st, a Friday, has five empty boxes
+        // before it.
+        Rectangle first = view.cn1DayBounds(march(1));
+        assertEquals(previous.x + 5 * first.width, first.x);
+        assertNull(view.getDayAtLocation(first.x - 1, first.y + 1));
+        assertNull(view.getDayAtLocation(previous.x + 1, first.y + 1));
+        // And the 31st, a Sunday, starts the last row alone.
+        Rectangle last = view.cn1DayBounds(march(31));
+        assertEquals(previous.x, last.x);
+        assertNull(view.getDayAtLocation(last.x + last.width + 1, last.y + 1));
+        assertNull(view.getDayAtLocation(-5, last.y + 1));
+        assertNull(view.getDayAtLocation(last.x + 1, view.getHeight() + 50));
+    }
+
+    @Test
+    public void theFirstDayOfTheWeekMovesTheGrid() {
+        open();
+        assertEquals(Calendar.SUNDAY, view.getFirstDayOfWeek());
+        Rectangle sunday = view.cn1DayBounds(march(1));
+        String firstName = view.getDayOfTheWeek(Calendar.SUNDAY);
+        List<Object[]> text = paint(frame);
+        assertNotNull(find(text, view.cn1Title()));
+        assertTrue(view.cn1Title().indexOf("2024") >= 0);
+        Object[] sun = find(text, firstName);
+        assertNotNull(sun);
+
+        view.setFirstDayOfWeek(Calendar.MONDAY);
+        assertEquals(Calendar.MONDAY, view.getFirstDayOfWeek());
+        assertEquals(Calendar.MONDAY, view.getSelectionModel().getFirstDayOfWeek());
+        Rectangle monday = view.cn1DayBounds(march(1));
+        assertEquals("one box to the left", sunday.x - sunday.width, monday.x);
+        assertEquals(sunday.y, monday.y);
+        assertEquals(march(2), at(sunday));
+        // The 31st, a Sunday, now ends the row before instead of
+        // starting one.
+        Rectangle last = view.cn1DayBounds(march(31));
+        assertEquals(monday.x + 2 * monday.width, last.x);
+        // And Sunday's name is drawn in the last column.
+        Object[] moved = find(paint(frame), firstName);
+        assertNotNull(moved);
+        assertTrue(((Number) moved[1]).intValue() > ((Number) sun[1]).intValue());
+    }
+
+    @Test
+    public void aPressSelectsADayAndCommits() {
+        open();
+        final List<String> commands = new ArrayList<String>();
+        view.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                commands.add(e.getActionCommand());
+            }
+        });
+        assertTrue(view.isSelectionEmpty());
+        assertNull(view.getSelectionDate());
+        click(view.cn1DayBounds(march(10)));
+        assertEquals(march(10), view.getSelectionDate());
+        assertTrue(view.isSelected(date(Calendar.MARCH, 10, 16)));
+        assertEquals(1, commands.size());
+        assertEquals(JXMonthView.COMMIT_KEY, commands.get(0));
+        assertFalse(view.getSelectionModel().isAdjusting());
+        // One day at a time: the next press replaces it.
+        click(view.cn1DayBounds(march(12)));
+        assertEquals(1, view.getSelection().size());
+        assertEquals(march(12), view.getSelectionDate());
+        assertEquals(2, commands.size());
+        // A press on an empty box selects nothing and commits nothing.
+        Rectangle first = view.cn1DayBounds(march(1));
+        press(frame, view, first.x - first.width / 2, first.y + 2);
+        release(frame, view, first.x - first.width / 2, first.y + 2);
+        assertEquals(march(12), view.getSelectionDate());
+        assertEquals(2, commands.size());
+        view.cancelSelection();
+        assertEquals(JXMonthView.CANCEL_KEY, commands.get(2));
+    }
+
+    @Test
+    public void theSelectionModeDecidesWhatIsSelected() {
+        open();
+        assertEquals(SelectionMode.SINGLE_SELECTION, view.getSelectionMode());
+        view.setSelectionInterval(march(5), march(8));
+        assertEquals(1, view.getSelection().size());
+
+        view.setSelectionMode(SelectionMode.SINGLE_INTERVAL_SELECTION);
+        view.setSelectionInterval(march(5), march(8));
+        assertEquals(4, view.getSelection().size());
+        assertEquals(march(5), view.getFirstSelectionDate());
+        assertEquals(march(8), view.getLastSelectionDate());
+        view.addSelectionInterval(march(20), march(21));
+        assertEquals(2, view.getSelection().size());
+
+        view.setSelectionMode(SelectionMode.MULTIPLE_INTERVAL_SELECTION);
+        view.setSelectionInterval(march(5), march(8));
+        view.addSelectionInterval(march(20), march(21));
+        assertEquals(6, view.getSelection().size());
+        view.removeSelectionInterval(march(6), march(6));
+        assertEquals(5, view.getSelection().size());
+        // A plain press starts over with the day pressed.
+        click(view.cn1DayBounds(march(14)));
+        assertEquals(1, view.getSelection().size());
+        assertEquals(march(14), view.getSelectionDate());
+        view.clearSelection();
+        assertTrue(view.isSelectionEmpty());
+
+        // The view follows a model handed to it.
+        DaySelectionModel model = new DaySelectionModel();
+        model.setSelectionMode(SelectionMode.SINGLE_INTERVAL_SELECTION);
+        view.setSelectionModel(model);
+        assertEquals(SelectionMode.SINGLE_INTERVAL_SELECTION, view.getSelectionMode());
+        model.setSelectionInterval(march(2), march(4));
+        assertEquals(3, view.getSelection().size());
+        assertTrue(view.isSelected(march(3)));
+    }
+
+    @Test
+    public void aDragSpansAnIntervalWithAMouse() {
+        open();
+        view.setSelectionMode(SelectionMode.SINGLE_INTERVAL_SELECTION);
+        Rectangle from = view.cn1DayBounds(march(11));
+        Rectangle to = view.cn1DayBounds(march(14));
+        int y = from.y + from.height / 2;
+        press(frame, view, from.x + from.width / 2, y);
+        drag(frame, view, to.x + to.width / 2, y);
+        release(frame, view, to.x + to.width / 2, y);
+        if (com.codename1.ui.Display.getInstance().isTouchScreenDevice()) {
+            // A finger that moves scrolls; it selects nothing.
+            assertTrue(view.getSelection().size() <= 1);
+        } else {
+            assertEquals(4, view.getSelection().size());
+            assertEquals(march(11), view.getFirstSelectionDate());
+            assertEquals(march(14), view.getLastSelectionDate());
+        }
+    }
+
+    @Test
+    public void unselectableDaysAndBoundsRefuseAPress() {
+        open();
+        view.setUnselectableDates(date(Calendar.MARCH, 11, 9));
+        assertTrue(view.isUnselectableDate(march(11)));
+        assertFalse(view.isUnselectableDate(march(12)));
+        click(view.cn1DayBounds(march(11)));
+        assertTrue(view.isSelectionEmpty());
+
+        view.setLowerBound(march(5));
+        view.setUpperBound(march(25));
+        assertEquals(march(5), view.getLowerBound());
+        assertEquals(march(25), view.getUpperBound());
+        assertTrue(view.isUnselectableDate(march(4)));
+        assertTrue(view.isUnselectableDate(march(26)));
+        assertFalse(view.isUnselectableDate(march(5)));
+        assertFalse(view.isUnselectableDate(march(25)));
+        click(view.cn1DayBounds(march(3)));
+        assertTrue(view.isSelectionEmpty());
+        click(view.cn1DayBounds(march(28)));
+        assertTrue(view.isSelectionEmpty());
+        click(view.cn1DayBounds(march(25)));
+        assertEquals(march(25), view.getSelectionDate());
+        view.setSelectionDate(march(2));
+        assertFalse("a date beyond the bounds is not taken", view.isSelected(march(2)));
+        view.setUpperBound(null);
+        assertNull(view.getUpperBound());
+        assertFalse(view.isUnselectableDate(march(26)));
+    }
+
+    @Test
+    public void flaggedDatesAreKeptByDay() {
+        open();
+        assertFalse(view.hasFlaggedDates());
+        view.setFlaggedDates(date(Calendar.MARCH, 7, 14), march(9));
+        assertTrue(view.hasFlaggedDates());
+        assertTrue(view.isFlaggedDate(march(7)));
+        assertTrue(view.isFlaggedDate(date(Calendar.MARCH, 9, 22)));
+        assertFalse(view.isFlaggedDate(march(8)));
+        assertEquals(2, view.getFlaggedDates().size());
+        assertEquals(march(7), view.getFlaggedDates().first());
+        view.addFlaggedDates(march(8));
+        assertEquals(3, view.getFlaggedDates().size());
+        view.removeFlaggedDates(date(Calendar.MARCH, 7, 3));
+        assertFalse(view.isFlaggedDate(march(7)));
+        assertEquals(2, view.getFlaggedDates().size());
+        // A flag does not stand in the way of selecting.
+        click(view.cn1DayBounds(march(8)));
+        assertEquals(march(8), view.getSelectionDate());
+        view.clearFlaggedDates();
+        assertFalse(view.hasFlaggedDates());
+    }
+
+    @Test
+    public void theArrowsMoveAMonth() {
+        open();
+        view.setTraversable(true);
+        click(view.cn1ArrowBounds(true));
+        assertEquals(date(Calendar.APRIL, 1, 0), view.getFirstDisplayedDay());
+        assertTrue(view.isSelectionEmpty());
+        click(view.cn1ArrowBounds(false));
+        click(view.cn1ArrowBounds(false));
+        assertEquals(date(Calendar.FEBRUARY, 1, 0), view.getFirstDisplayedDay());
+        // 2024 is a leap year.
+        assertEquals(date(Calendar.FEBRUARY, 29, 0),
+                view.getSelectionModel().getNormalizedDate(view.getLastDisplayedDay()));
+        assertNotNull(view.cn1DayBounds(date(Calendar.FEBRUARY, 29, 0)));
+        assertNull(view.cn1DayBounds(march(1)));
+        // February 2024 starts on a Thursday.
+        assertEquals(view.cn1ArrowBounds(false).x + 4 * view.cn1ArrowBounds(false).width,
+                view.cn1DayBounds(date(Calendar.FEBRUARY, 1, 0)).x);
+
+        view.setTraversable(false);
+        click(view.cn1ArrowBounds(true));
+        assertEquals(date(Calendar.FEBRUARY, 1, 0), view.getFirstDisplayedDay());
+
+        view.setFirstDisplayedDay(date(Calendar.JULY, 19, 11));
+        assertEquals(date(Calendar.JULY, 1, 0), view.getFirstDisplayedDay());
+        view.ensureDateVisible(date(Calendar.JULY, 30, 0));
+        assertEquals(date(Calendar.JULY, 1, 0), view.getFirstDisplayedDay());
+        view.ensureDateVisible(date(Calendar.DECEMBER, 25, 0));
+        assertEquals(date(Calendar.DECEMBER, 1, 0), view.getFirstDisplayedDay());
+        assertEquals(date(Calendar.DECEMBER, 25, 0), at(view.cn1DayBounds(date(Calendar.DECEMBER, 25, 0))));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTableTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTableTest.java
new file mode 100644
index 00000000000..c9d2642febb
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTableTest.java
@@ -0,0 +1,457 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Point;
+import com.codename1.desktopcompat.java.awt.event.MouseEvent;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JTable;
+import com.codename1.desktopcompat.javax.swing.RowFilter;
+import com.codename1.desktopcompat.javax.swing.SortOrder;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableCellRenderer;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.javax.swing.table.TableCellRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ColorHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.HighlightPredicate;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.Highlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.HighlighterFactory;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.DefaultTableRenderer;
+import com.codename1.desktopcompat.org.jdesktop.swingx.renderer.StringValue;
+import com.codename1.desktopcompat.org.jdesktop.swingx.table.TableColumnExt;
+import java.util.Comparator;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// `JXTable`: highlighters through painting, hidden columns and the
+/// indexes around them, packing, the sorting and filtering switches,
+/// the viewport size in rows and rollover.
+public class JXTableTest extends KernelTestBase {
+
+    private static final Color RED = new Color(200, 0, 0);
+    private static final Color BLUE = new Color(0, 0, 200);
+
+    /// name, age, member: `String`, `Integer`, `Boolean`.
+    private static final class People extends DefaultTableModel {
+        People() {
+            super(new Object[][]{
+                {"Carol", Integer.valueOf(30), Boolean.TRUE},
+                {"Alice", Integer.valueOf(10), Boolean.FALSE},
+                {"Bob", Integer.valueOf(20), Boolean.TRUE},
+                {"Dave the very long named one", Integer.valueOf(4), Boolean.FALSE}},
+                    new Object[]{"Name", "Age", "Member"});
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return column == 0 ? String.class : column == 1 ? Integer.class : Boolean.class;
+        }
+    }
+
+    /// Draws its value and the background it was left with.
+    private static final class Stamp extends JComponent implements TableCellRenderer {
+        private String text = "";
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                boolean hasFocus, int row, int column) {
+            text = String.valueOf(value);
+            setBackground(Color.WHITE);
+            return this;
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            Color bg = getBackground();
+            g.drawString(text + "@" + bg.getRed() + "," + bg.getGreen() + "," + bg.getBlue(), 2, 12);
+        }
+    }
+
+    private JFrame placed(JTable t, int w, int h) {
+        JPanel p = new JPanel(null);
+        t.setBounds(0, 0, w, h);
+        p.add(t);
+        JFrame f = new JFrame();
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    private static String name(JXTable t, int row) {
+        return String.valueOf(t.getValueAt(row, 0));
+    }
+
+    @Test
+    public void highlightersApplyInOrderWhenTheTablePaints() {
+        JXTable t = new JXTable(new People());
+        t.getColumn(0).setCellRenderer(new Stamp());
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.EVEN, BLUE, null));
+        JFrame f = placed(t, 400, 300);
+        List<Object[]> drawn = paint(f);
+        assertNotNull("row 0 is even: the later highlighter wins", find(drawn, "Carol@0,0,200"));
+        assertNotNull("row 1 only has the first", find(drawn, "Alice@200,0,0"));
+        assertNotNull(find(drawn, "Bob@0,0,200"));
+
+        t.setHighlighters(new ColorHighlighter(HighlightPredicate.EVEN, BLUE, null),
+                new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        drawn = paint(f);
+        assertNotNull("the order turned round: red is last everywhere", find(drawn, "Carol@200,0,0"));
+        assertEquals(2, t.getHighlighters().length);
+
+        t.setHighlighters();
+        drawn = paint(f);
+        assertNotNull(find(drawn, "Carol@255,255,255"));
+    }
+
+    @Test
+    public void columnHighlightersComeAfterTheTables() {
+        JXTable t = new JXTable(new People());
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.ALWAYS, RED, null));
+        t.getColumnExt(1).addHighlighter(new ColorHighlighter(HighlightPredicate.ALWAYS, BLUE, null));
+        assertEquals(RED, t.prepareRenderer(0, 0).getBackground());
+        assertEquals(BLUE, t.prepareRenderer(0, 1).getBackground());
+        assertEquals(RED, t.prepareRenderer(0, 2).getBackground());
+    }
+
+    @Test
+    public void aHighlightDoesNotStickToTheNextCell() {
+        JXTable t = new JXTable(new People());
+        Highlighter firstRow = new ColorHighlighter(new HighlightPredicate.RowGroupHighlightPredicate(100) {
+            @Override
+            public boolean isHighlighted(Component renderer,
+                    com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter adapter) {
+                return adapter.row == 0;
+            }
+        }, RED, BLUE);
+        t.addHighlighter(firstRow);
+        // The SwingX renderer resets itself for every cell.
+        assertEquals(RED, t.prepareRenderer(0, 0).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(1, 0).getBackground());
+        assertEquals(t.getForeground(), t.prepareRenderer(1, 0).getForeground());
+        // The JDK's remembers a color set on it: the table undoes that.
+        DefaultTableCellRenderer plain = new DefaultTableCellRenderer();
+        t.getColumn(0).setCellRenderer(plain);
+        assertEquals(RED, t.prepareRenderer(0, 0).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(1, 0).getBackground());
+        assertEquals(t.getForeground(), t.prepareRenderer(1, 0).getForeground());
+        assertEquals(RED, t.prepareRenderer(0, 0).getBackground());
+        // A color the application set on the renderer survives.
+        DefaultTableCellRenderer green = new DefaultTableCellRenderer();
+        green.setBackground(Color.GREEN);
+        t.getColumn(1).setCellRenderer(green);
+        assertEquals(RED, t.prepareRenderer(0, 1).getBackground());
+        assertEquals(Color.GREEN, t.prepareRenderer(1, 1).getBackground());
+    }
+
+    @Test
+    public void predicatesSeeTheCell() {
+        JXTable t = new JXTable(new People());
+        t.setHighlighters(new ColorHighlighter(new HighlightPredicate.ColumnHighlightPredicate(1), RED, null));
+        assertEquals(RED, t.prepareRenderer(0, 1).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(0, 0).getBackground());
+
+        t.setHighlighters(new ColorHighlighter(new HighlightPredicate.EqualsHighlightPredicate("Bob"), RED, null));
+        assertEquals(RED, t.prepareRenderer(2, 0).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(1, 0).getBackground());
+
+        t.setHighlighters(new ColorHighlighter(new HighlightPredicate.IdentifierHighlightPredicate("Age"), RED,
+                null));
+        assertEquals(RED, t.prepareRenderer(0, 1).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(0, 2).getBackground());
+
+        t.setHighlighters(new ColorHighlighter(new HighlightPredicate.NotHighlightPredicate(
+                HighlightPredicate.ODD), RED, null));
+        assertEquals(RED, t.prepareRenderer(0, 0).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(1, 0).getBackground());
+
+        t.setHighlighters(new ColorHighlighter(new HighlightPredicate.AndHighlightPredicate(
+                HighlightPredicate.EVEN, new HighlightPredicate.ColumnHighlightPredicate(2)), RED, null));
+        assertEquals(RED, t.prepareRenderer(0, 2).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(0, 1).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(1, 2).getBackground());
+
+        t.setHighlighters(new ColorHighlighter(HighlightPredicate.IS_SELECTED, null, null, null, RED));
+        t.setRowSelectionInterval(1, 1);
+        assertEquals(RED, t.prepareRenderer(1, 0).getForeground());
+        assertFalse(RED.equals(t.prepareRenderer(0, 0).getForeground()));
+    }
+
+    @Test
+    public void stripingColorsEveryOtherRow() {
+        JXTable t = new JXTable(new People());
+        t.addHighlighter(HighlighterFactory.createSimpleStriping(RED));
+        Color even = t.prepareRenderer(0, 0).getBackground();
+        Color odd = t.prepareRenderer(1, 0).getBackground();
+        assertFalse(even.equals(odd));
+        assertTrue(RED.equals(even) || RED.equals(odd));
+        assertEquals(even, t.prepareRenderer(2, 0).getBackground());
+    }
+
+    @Test
+    public void hiddenColumnsLeaveTheViewAndComeBack() {
+        JXTable t = new JXTable(new People());
+        final int[] events = new int[2];
+        TableColumnExt age = t.getColumnExt("Age");
+        assertNotNull(age);
+        assertSame(age, t.getColumnExt(1));
+        age.setVisible(false);
+        assertEquals(2, t.getColumnCount());
+        assertEquals(3, t.getColumnCount(true));
+        assertEquals(2, t.getColumns().size());
+        assertEquals(3, t.getColumns(true).size());
+        assertEquals(-1, t.convertColumnIndexToView(1));
+        assertEquals(2, t.convertColumnIndexToModel(1));
+        assertEquals(1, t.convertColumnIndexToView(2));
+        assertEquals("Member", t.getColumnName(1));
+        assertEquals(Boolean.TRUE, t.getValueAt(0, 1));
+        assertSame("a hidden column is still found by identifier", age, t.getColumnExt("Age"));
+        assertFalse(age.isVisible());
+        assertEquals(events[0], events[1]);
+
+        age.setVisible(true);
+        assertEquals(3, t.getColumnCount());
+        assertSame("back where it was", age, t.getColumn(1));
+        assertEquals(1, t.convertColumnIndexToView(1));
+
+        // Hide the first, move the remaining two, show it: it leads again.
+        TableColumnExt name = t.getColumnExt("Name");
+        name.setVisible(false);
+        t.moveColumn(0, 1);
+        assertEquals("Member", t.getColumnName(0));
+        name.setVisible(true);
+        assertEquals("Name", t.getColumnName(0));
+        assertEquals("Member", t.getColumnName(1));
+        assertEquals("Age", t.getColumnName(2));
+    }
+
+    @Test
+    public void paintingSkipsAHiddenColumn() {
+        JXTable t = new JXTable(new People());
+        JFrame f = placed(t, 400, 300);
+        assertNotNull(find(paint(f), "30"));
+        t.getColumnExt("Age").setVisible(false);
+        List<Object[]> drawn = paint(f);
+        assertNull(find(drawn, "30"));
+        assertNotNull(find(drawn, "Carol"));
+    }
+
+    @Test
+    public void packAllSizesColumnsToTheirContent() {
+        JXTable t = new JXTable(new People());
+        t.setHorizontalScrollEnabled(true);
+        assertTrue(t.isHorizontalScrollEnabled());
+        assertEquals(JTable.AUTO_RESIZE_OFF, t.getAutoResizeMode());
+        t.packAll();
+        int margin = t.getColumnFactory().getDefaultPackMargin();
+        for (int c = 0; c < t.getColumnCount(); c++) {
+            int widest = t.getTableHeader().getDefaultRenderer().getTableCellRendererComponent(t,
+                    t.getColumn(c).getHeaderValue(), false, false, -1, -1).getPreferredSize().width;
+            TableCellRenderer r = t.getCellRenderer(0, c);
+            for (int row = 0; row < t.getRowCount(); row++) {
+                widest = Math.max(widest, r.getTableCellRendererComponent(t, t.getValueAt(row, c), false, false,
+                        row, c).getPreferredSize().width);
+            }
+            assertEquals("column " + c, widest + 2 * margin, t.getColumn(c).getPreferredWidth());
+        }
+        assertTrue(t.getColumn(0).getPreferredWidth() > t.getColumn(1).getPreferredWidth());
+
+        t.packColumn(0, 10, 50);
+        assertEquals("the maximum caps the width", 50, t.getColumn(0).getPreferredWidth());
+        t.setHorizontalScrollEnabled(false);
+        assertFalse(t.isHorizontalScrollEnabled());
+        assertEquals(JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS, t.getAutoResizeMode());
+    }
+
+    @Test
+    public void sortOrdersCycleAndReset() {
+        JXTable t = new JXTable(new People());
+        assertTrue(t.isSortable());
+        assertEquals(SortOrder.UNSORTED, t.getSortOrder(0));
+        t.toggleSortOrder(0);
+        assertEquals(SortOrder.ASCENDING, t.getSortOrder(0));
+        assertEquals("Alice", name(t, 0));
+        assertEquals(1, t.convertRowIndexToModel(0));
+        assertSame(t.getColumn(0), t.getSortedColumn());
+        t.toggleSortOrder(0);
+        assertEquals(SortOrder.DESCENDING, t.getSortOrder(0));
+        assertEquals("Dave the very long named one", name(t, 0));
+        t.toggleSortOrder(0);
+        assertEquals("two orders in the default cycle", SortOrder.ASCENDING, t.getSortOrder(0));
+        t.resetSortOrder();
+        assertEquals(SortOrder.UNSORTED, t.getSortOrder(0));
+        assertEquals("Carol", name(t, 0));
+        assertNull(t.getSortedColumn());
+
+        t.setSortOrderCycle(SortOrder.DESCENDING, SortOrder.UNSORTED);
+        t.toggleSortOrder(1);
+        assertEquals(SortOrder.DESCENDING, t.getSortOrder(1));
+        assertEquals("numbers compare as numbers", "Carol", name(t, 0));
+        t.toggleSortOrder(1);
+        assertEquals(SortOrder.UNSORTED, t.getSortOrder(1));
+
+        t.setSortOrder("Age", SortOrder.ASCENDING);
+        assertEquals(SortOrder.ASCENDING, t.getSortOrder("Age"));
+        assertEquals("Dave the very long named one", name(t, 0));
+        t.getColumnExt("Age").setVisible(false);
+        assertEquals("sorted by a hidden column", SortOrder.ASCENDING, t.getSortOrder("Age"));
+        assertEquals("Dave the very long named one", name(t, 0));
+        t.toggleSortOrder("Age");
+        assertEquals(SortOrder.DESCENDING, t.getSortOrder("Age"));
+        assertEquals("Carol", name(t, 0));
+    }
+
+    @Test
+    public void sortableSwitchesAndComparators() {
+        JXTable t = new JXTable(new People());
+        t.setSortable(false);
+        t.toggleSortOrder(0);
+        assertEquals(SortOrder.UNSORTED, t.getSortOrder(0));
+        assertEquals("Carol", name(t, 0));
+        t.setSortable(true);
+        t.getColumnExt(0).setSortable(false);
+        t.toggleSortOrder(0);
+        assertEquals(SortOrder.UNSORTED, t.getSortOrder(0));
+        t.getColumnExt(0).setSortable(true);
+        t.getColumnExt(0).setComparator(new Comparator<Object>() {
+            @Override
+            public int compare(Object a, Object b) {
+                return a.toString().length() - b.toString().length();
+            }
+        });
+        t.toggleSortOrder(0);
+        assertEquals("by length", "Bob", name(t, 0));
+        assertEquals("Dave the very long named one", name(t, 3));
+    }
+
+    @Test
+    public void sortingByTheStringsTheRendererShows() {
+        DefaultTableModel m = new DefaultTableModel(new Object[][]{{new int[]{1}}, {new int[]{2, 2, 2}},
+            {new int[]{3, 3}}}, new Object[]{"Arrays"});
+        JXTable t = new JXTable(m);
+        // Shows an array by its length, upside down: 9 - length.
+        t.getColumn(0).setCellRenderer(new DefaultTableRenderer(new StringValue() {
+            @Override
+            public String getString(Object value) {
+                return value instanceof int[] ? String.valueOf(9 - ((int[]) value).length) : "";
+            }
+        }));
+        assertEquals("8", t.getStringAt(0, 0));
+        t.toggleSortOrder(0);
+        assertEquals("6", t.getStringAt(0, 0));
+        assertEquals("7", t.getStringAt(1, 0));
+        assertEquals("8", t.getStringAt(2, 0));
+    }
+
+    @Test
+    public void aRowFilterHidesRows() {
+        JXTable t = new JXTable(new People());
+        t.setRowFilter(new RowFilter<Object, Integer>() {
+            @Override
+            public boolean include(RowFilter.Entry<? extends Object, ? extends Integer> entry) {
+                Object age = entry.getValue(1);
+                return age instanceof Integer && ((Integer) age).intValue() >= 20;
+            }
+        });
+        assertNotNull(t.getRowFilter());
+        assertEquals(2, t.getRowCount());
+        assertEquals("Carol", name(t, 0));
+        assertEquals("Bob", name(t, 1));
+        t.toggleSortOrder(0);
+        assertEquals("Bob", name(t, 0));
+        t.setRowFilter(null);
+        assertEquals(4, t.getRowCount());
+        assertEquals("the filter survives a new model", "Alice", name(t, 0));
+    }
+
+    @Test
+    public void aNewModelGetsANewSorterWithTheTablesSettings() {
+        JXTable t = new JXTable(new People());
+        t.setSortable(false);
+        t.setModel(new People());
+        t.toggleSortOrder(0);
+        assertEquals(SortOrder.UNSORTED, t.getSortOrder(0));
+        t.setSortable(true);
+        t.toggleSortOrder(0);
+        assertEquals("Alice", name(t, 0));
+        assertTrue(t.getColumn(0) instanceof TableColumnExt);
+    }
+
+    @Test
+    public void theViewportSizeIsCountedInRowsAndColumns() {
+        JXTable t = new JXTable(new People());
+        assertEquals(20, t.getVisibleRowCount());
+        t.setVisibleRowCount(5);
+        assertEquals(5 * t.getRowHeight(), t.getPreferredScrollableViewportSize().height);
+        int all = t.getPreferredScrollableViewportSize().width;
+        assertEquals(t.getColumn(0).getPreferredWidth() + t.getColumn(1).getPreferredWidth()
+                + t.getColumn(2).getPreferredWidth(), all);
+        t.setVisibleColumnCount(2);
+        assertEquals(t.getColumn(0).getPreferredWidth() + t.getColumn(1).getPreferredWidth(),
+                t.getPreferredScrollableViewportSize().width);
+    }
+
+    @Test
+    public void editableSwitches() {
+        JXTable t = new JXTable(new People());
+        assertTrue(t.isCellEditable(0, 0));
+        t.getColumnExt(0).setEditable(false);
+        assertFalse(t.isCellEditable(0, 0));
+        assertTrue(t.isCellEditable(0, 1));
+        t.setEditable(false);
+        assertFalse(t.isCellEditable(0, 1));
+    }
+
+    @Test
+    public void rolloverFollowsThePointer() {
+        JXTable t = new JXTable(new People());
+        placed(t, 300, 200);
+        t.setRolloverEnabled(true);
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.ROLLOVER_ROW, RED, null));
+        int y = t.getCellRect(2, 1, true).y + 2;
+        int x = t.getCellRect(2, 1, true).x + 2;
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0, x, y, 0, false,
+                MouseEvent.NOBUTTON));
+        assertEquals(new Point(1, 2), t.getClientProperty("swingx.rollover"));
+        assertEquals(RED, t.prepareRenderer(2, 0).getBackground());
+        assertEquals(t.getBackground(), t.prepareRenderer(1, 0).getBackground());
+        t.dispatchEvent(new MouseEvent(t, MouseEvent.MOUSE_EXITED, System.currentTimeMillis(), 0, x, y, 0, false,
+                MouseEvent.NOBUTTON));
+        assertNull(t.getClientProperty("swingx.rollover"));
+        assertEquals(t.getBackground(), t.prepareRenderer(2, 0).getBackground());
+        t.setRolloverEnabled(false);
+        assertFalse(t.isRolloverEnabled());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTreeTableTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTreeTableTest.java
new file mode 100644
index 00000000000..76a8301e04e
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/JXTreeTableTest.java
@@ -0,0 +1,534 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.javax.swing.JComponent;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JTree;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeExpansionListener;
+import com.codename1.desktopcompat.javax.swing.event.TreeWillExpandListener;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.javax.swing.tree.ExpandVetoException;
+import com.codename1.desktopcompat.javax.swing.tree.TreeCellRenderer;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ColorHighlighter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.decorator.HighlightPredicate;
+import com.codename1.desktopcompat.org.jdesktop.swingx.treetable.AbstractMutableTreeTableNode;
+import com.codename1.desktopcompat.org.jdesktop.swingx.treetable.DefaultMutableTreeTableNode;
+import com.codename1.desktopcompat.org.jdesktop.swingx.treetable.DefaultTreeTableModel;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// `JXTreeTable`: rows that follow the expanded nodes, values per
+/// column, the indent of the hierarchical column, the arrow, highlighters
+/// that know the node, and a table that follows its model's events.
+public class JXTreeTableTest extends KernelTestBase {
+
+    private static final Color RED = new Color(200, 0, 0);
+    private static final Color BLUE = new Color(0, 0, 200);
+
+    /// A node with a name and a size: two columns, neither editable
+    /// unless asked for.
+    private static final class Entry extends AbstractMutableTreeTableNode {
+        private Object size;
+        private final boolean editable;
+
+        Entry(String name, Object size) {
+            this(name, size, false);
+        }
+
+        Entry(String name, Object size, boolean editable) {
+            super(name);
+            this.size = size;
+            this.editable = editable;
+        }
+
+        @Override
+        public Object getValueAt(int column) {
+            return column == 0 ? getUserObject() : size;
+        }
+
+        @Override
+        public int getColumnCount() {
+            return 2;
+        }
+
+        @Override
+        public boolean isEditable(int column) {
+            return editable;
+        }
+
+        @Override
+        public void setValueAt(Object value, int column) {
+            if (column == 0) {
+                setUserObject(value);
+            } else {
+                size = value;
+            }
+        }
+    }
+
+    /// Draws the node and the background it was left with.
+    private static final class Stamp extends JComponent implements TreeCellRenderer {
+        private String text = "";
+
+        @Override
+        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
+                boolean leaf, int row, boolean hasFocus) {
+            text = String.valueOf(value);
+            setBackground(Color.WHITE);
+            return this;
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            Color bg = getBackground();
+            g.drawString(text + "@" + bg.getRed() + "," + bg.getGreen() + "," + bg.getBlue(), 2, 12);
+        }
+    }
+
+    private Entry root;
+    private Entry docs;
+    private Entry notes;
+    private Entry todo;
+    private Entry readme;
+    private DefaultTreeTableModel model;
+
+    /// root > docs > (notes, todo), readme; the root is hidden.
+    private JXTreeTable sample() {
+        root = new Entry("root", "-");
+        docs = new Entry("docs", "2 items");
+        notes = new Entry("notes", Integer.valueOf(12));
+        todo = new Entry("todo", Integer.valueOf(3));
+        readme = new Entry("readme", Integer.valueOf(40));
+        root.add(docs);
+        docs.add(notes);
+        docs.add(todo);
+        root.add(readme);
+        model = new DefaultTreeTableModel(root, Arrays.asList("Name", "Size"));
+        return new JXTreeTable(model);
+    }
+
+    private TreePath path(Object... nodes) {
+        return new TreePath(nodes);
+    }
+
+    private JFrame placed(JXTreeTable t, int w, int h) {
+        JPanel p = new JPanel(null);
+        t.setBounds(0, 0, w, h);
+        p.add(t);
+        JFrame f = new JFrame();
+        f.add(p, BorderLayout.CENTER);
+        show(f);
+        return f;
+    }
+
+    private static int x(Object[] drawn) {
+        return ((Number) drawn[1]).intValue();
+    }
+
+    @Test
+    public void theRowsAreTheNodesThatShow() {
+        JXTreeTable t = sample();
+        assertFalse(t.isRootVisible());
+        assertTrue(t.getShowsRootHandles());
+        assertEquals(2, t.getRowCount());
+        assertEquals("docs", t.getValueAt(0, 0));
+        assertEquals("readme", t.getValueAt(1, 0));
+        assertEquals(path(root, docs), t.getPathForRow(0));
+        assertNull(t.getPathForRow(-1));
+        assertNull(t.getPathForRow(7));
+        assertEquals(-1, t.getRowForPath(path(root)));
+        assertEquals(-1, t.getRowForPath(path(root, docs, notes)));
+        assertTrue(t.isExpanded(path(root)));
+        assertFalse(t.isExpanded(0));
+        assertTrue(t.isCollapsed(0));
+        assertTrue(t.isCollapsed(-1));
+        assertFalse(t.isVisible(path(root, docs, notes)));
+
+        t.expandRow(0);
+        assertEquals(4, t.getRowCount());
+        assertEquals("notes", t.getValueAt(1, 0));
+        assertEquals("todo", t.getValueAt(2, 0));
+        assertEquals("readme", t.getValueAt(3, 0));
+        assertEquals(2, t.getRowForPath(path(root, docs, todo)));
+        assertTrue(t.isExpanded(0));
+        assertTrue(t.isVisible(path(root, docs, notes)));
+
+        t.expandRow(1);
+        assertEquals("a leaf does not expand", 4, t.getRowCount());
+
+        t.collapsePath(path(root, docs));
+        assertEquals(2, t.getRowCount());
+
+        t.expandAll();
+        assertEquals(4, t.getRowCount());
+        t.collapseAll();
+        assertEquals("the hidden root stays expanded", 2, t.getRowCount());
+
+        t.setRootVisible(true);
+        assertEquals(3, t.getRowCount());
+        assertEquals("root", t.getValueAt(0, 0));
+        assertEquals(0, t.getRowForPath(path(root)));
+        t.setRootVisible(false);
+        assertEquals(2, t.getRowCount());
+
+        t.scrollPathToVisible(path(root, docs, todo));
+        assertEquals("the nodes above were expanded", 2, t.getRowForPath(path(root, docs, todo)));
+    }
+
+    @Test
+    public void everyColumnShowsTheNodesValue() {
+        JXTreeTable t = sample();
+        t.expandAll();
+        assertEquals(2, t.getColumnCount());
+        assertEquals("Name", t.getColumnName(0));
+        assertEquals("Size", t.getColumnName(1));
+        assertEquals(0, t.getHierarchicalColumn());
+        assertTrue(t.isHierarchical(0));
+        assertFalse(t.isHierarchical(1));
+        assertFalse(t.isHierarchical(5));
+        assertEquals("2 items", t.getValueAt(0, 1));
+        assertEquals(Integer.valueOf(12), t.getValueAt(1, 1));
+        assertEquals(Integer.valueOf(40), t.getValueAt(3, 1));
+        assertEquals("notes", t.getStringAt(1, 0));
+        assertEquals("12", t.getStringAt(1, 1));
+        assertFalse(t.isCellEditable(1, 0));
+
+        t.setValueAt(Integer.valueOf(99), 1, 1);
+        assertEquals("the node took the value", Integer.valueOf(99), notes.getValueAt(1));
+
+        t.moveColumn(0, 1);
+        assertEquals("the hierarchical column moved with its column", 1, t.getHierarchicalColumn());
+        assertTrue(t.isHierarchical(1));
+        assertEquals("notes", t.getValueAt(1, 1));
+        t.getColumnExt(1).setVisible(false);
+        assertEquals(-1, t.getHierarchicalColumn());
+    }
+
+    @Test
+    public void aTreeTableDoesNotSortAndTakesOnlyItsOwnModel() {
+        JXTreeTable t = sample();
+        assertFalse(t.isSortable());
+        assertNull(t.getRowSorter());
+        t.setSortable(true);
+        t.setAutoCreateRowSorter(true);
+        assertFalse(t.isSortable());
+        assertFalse(t.getAutoCreateRowSorter());
+        assertNull(t.getRowSorter());
+        try {
+            t.setModel(new DefaultTableModel(2, 2));
+            fail("a plain table model was taken");
+        } catch (IllegalArgumentException expected) {
+            assertEquals(2, t.getColumnCount());
+        }
+        assertSame(model, t.getTreeTableModel());
+    }
+
+    @Test
+    public void theHierarchicalColumnIndentsByDepth() {
+        JXTreeTable t = sample();
+        t.expandAll();
+        JFrame f = placed(t, 400, 300);
+        List<Object[]> drawn = paint(f);
+        Object[] folder = find(drawn, "docs");
+        Object[] child = find(drawn, "notes");
+        Object[] sibling = find(drawn, "readme");
+        assertNotNull("the default renderer shows the model's value", folder);
+        assertNotNull(child);
+        assertNotNull(sibling);
+        assertNotNull("the other column is a plain table column", find(drawn, "2 items"));
+        assertEquals("same depth, same indent", x(folder), x(sibling));
+        int step = x(child) - x(folder);
+        assertTrue("a child is indented one step: " + step, step >= 2 * 20);
+
+        t.setShowsRootHandles(false);
+        List<Object[]> flat = paint(f);
+        assertEquals("without root handles the first level loses its step", x(folder) - step,
+                x(find(flat, "docs")));
+        t.setShowsRootHandles(true);
+        t.setRootVisible(true);
+        List<Object[]> rooted = paint(f);
+        assertNotNull(find(rooted, "root"));
+        assertEquals("with a root row every node is one step further in", x(child) + step,
+                x(find(rooted, "notes")));
+    }
+
+    @Test
+    public void aPressOnTheArrowTogglesTheNode() {
+        JXTreeTable t = sample();
+        JFrame f = placed(t, 400, 300);
+        int rh = t.getRowHeight();
+        assertEquals(2, t.getRowCount());
+        // First level, root handles shown: the arrow is in the first step.
+        press(f, t, 10, rh / 2);
+        release(f, t, 10, rh / 2);
+        assertEquals("the press on the arrow expanded docs", 4, t.getRowCount());
+        assertFalse(t.isEditing());
+        assertEquals("and selected its row", 0, t.getSelectedRow());
+
+        // readme is a leaf: nothing to toggle where its arrow would be.
+        press(f, t, 10, 3 * rh + rh / 2);
+        release(f, t, 10, 3 * rh + rh / 2);
+        assertEquals(4, t.getRowCount());
+        assertEquals(3, t.getSelectedRow());
+
+        press(f, t, 10, rh / 2);
+        release(f, t, 10, rh / 2);
+        assertEquals("a second press collapsed it", 2, t.getRowCount());
+
+        // One press on the text selects and leaves the node alone.
+        t.setToggleClickCount(1);
+        t.setToggleClickCount(2);
+        press(f, t, 200, rh + rh / 2);
+        release(f, t, 200, rh + rh / 2);
+        assertEquals(2, t.getRowCount());
+        assertEquals(1, t.getSelectedRow());
+    }
+
+    @Test
+    public void theToggleClickCountOnTheCellTogglesTheNode() {
+        JXTreeTable t = sample();
+        JFrame f = placed(t, 400, 300);
+        int rh = t.getRowHeight();
+        assertEquals(2, t.getToggleClickCount());
+        press(f, t, 100, rh / 2);
+        release(f, t, 100, rh / 2);
+        assertEquals("one click does nothing", 2, t.getRowCount());
+        press(f, t, 100, rh / 2);
+        release(f, t, 100, rh / 2);
+        assertEquals("the second click expanded docs", 4, t.getRowCount());
+    }
+
+    @Test
+    public void highlightersKnowTheNode() {
+        JXTreeTable t = sample();
+        t.expandAll();
+        t.addHighlighter(new ColorHighlighter(HighlightPredicate.IS_LEAF, RED, null));
+        t.addHighlighter(new ColorHighlighter(new HighlightPredicate.DepthHighlightPredicate(2), null, BLUE));
+        // docs: a folder at depth 1.
+        Component c = t.prepareRenderer(0, 1);
+        assertFalse(RED.equals(c.getBackground()));
+        assertFalse(BLUE.equals(c.getForeground()));
+        // notes: a leaf at depth 2.
+        c = t.prepareRenderer(1, 1);
+        assertEquals(RED, c.getBackground());
+        assertEquals(BLUE, c.getForeground());
+        // readme: a leaf at depth 1.
+        c = t.prepareRenderer(3, 1);
+        assertEquals(RED, c.getBackground());
+        assertFalse(BLUE.equals(c.getForeground()));
+
+        // In the hierarchical column the tree cell renderer's component
+        // is what the highlighters decorate.
+        t.setTreeCellRenderer(new Stamp());
+        JFrame f = placed(t, 400, 300);
+        List<Object[]> drawn = paint(f);
+        assertNotNull(find(drawn, "docs@255,255,255"));
+        assertNotNull(find(drawn, "notes@200,0,0"));
+        assertNotNull(find(drawn, "readme@200,0,0"));
+
+        t.setHighlighters(new ColorHighlighter(HighlightPredicate.IS_FOLDER, BLUE, null));
+        drawn = paint(f);
+        assertNotNull(find(drawn, "docs@0,0,200"));
+        assertNotNull(find(drawn, "notes@255,255,255"));
+
+        t.setHighlighters(new ColorHighlighter(new HighlightPredicate() {
+            @Override
+            public boolean isHighlighted(Component renderer,
+                    com.codename1.desktopcompat.org.jdesktop.swingx.decorator.ComponentAdapter adapter) {
+                return adapter.isHierarchical() && adapter.isExpanded() && "docs".equals(adapter.getString());
+            }
+        }, RED, null));
+        drawn = paint(f);
+        assertNotNull(find(drawn, "docs@200,0,0"));
+        assertNotNull(find(drawn, "notes@255,255,255"));
+        assertFalse(RED.equals(t.prepareRenderer(0, 1).getBackground()));
+    }
+
+    @Test
+    public void theTableFollowsTheModelsEvents() {
+        JXTreeTable t = sample();
+        t.expandAll();
+        t.setRowSelectionInterval(3, 3);
+        Entry draft = new Entry("draft", Integer.valueOf(1));
+        model.insertNodeInto(draft, docs, 0);
+        assertEquals(5, t.getRowCount());
+        assertEquals("draft", t.getValueAt(1, 0));
+        assertEquals("the selection stayed with readme", 4, t.getSelectedRow());
+
+        model.removeNodeFromParent(draft);
+        assertEquals(4, t.getRowCount());
+        assertEquals("notes", t.getValueAt(1, 0));
+        assertEquals(3, t.getSelectedRow());
+
+        t.collapseRow(0);
+        model.insertNodeInto(draft, docs, 0);
+        assertEquals("a node below a collapsed one has no row", 2, t.getRowCount());
+        t.expandRow(0);
+        assertEquals(5, t.getRowCount());
+
+        model.setValueAt("renamed", todo, 0);
+        assertEquals("renamed", t.getValueAt(3, 0));
+        model.setValueAt(Integer.valueOf(7), todo, 1);
+        assertEquals(Integer.valueOf(7), t.getValueAt(3, 1));
+
+        model.setColumnIdentifiers(Arrays.asList("Name", "Size", "Kind"));
+        assertEquals("the columns were made again", 3, t.getColumnCount());
+        assertEquals("Kind", t.getColumnName(2));
+        assertNull("a node with two columns has nothing in the third", t.getValueAt(0, 2));
+
+        Entry other = new Entry("other", "-");
+        other.add(new Entry("only", Integer.valueOf(5)));
+        model.setRoot(other);
+        assertEquals(1, t.getRowCount());
+        assertEquals("only", t.getValueAt(0, 0));
+    }
+
+    @Test
+    public void theFirstChildrenOfAHiddenRootShow() {
+        Entry empty = new Entry("empty", "-");
+        DefaultTreeTableModel m = new DefaultTreeTableModel(empty, Arrays.asList("Name", "Size"));
+        JXTreeTable t = new JXTreeTable(m);
+        assertEquals(0, t.getRowCount());
+        m.insertNodeInto(new Entry("first", Integer.valueOf(1)), empty, 0);
+        assertEquals(1, t.getRowCount());
+        assertEquals("first", t.getValueAt(0, 0));
+    }
+
+    @Test
+    public void anotherModelReplacesColumnsAndRows() {
+        JXTreeTable t = sample();
+        final List<String> names = new ArrayList<String>();
+        t.addPropertyChangeListener(new com.codename1.desktopcompat.java.beans.PropertyChangeListener() {
+            @Override
+            public void propertyChange(com.codename1.desktopcompat.java.beans.PropertyChangeEvent e) {
+                names.add(e.getPropertyName());
+            }
+        });
+        DefaultMutableTreeTableNode r = new DefaultMutableTreeTableNode("r");
+        r.add(new DefaultMutableTreeTableNode("one"));
+        DefaultTreeTableModel next = new DefaultTreeTableModel(r, Arrays.asList("Only"));
+        t.setTreeTableModel(next);
+        assertTrue(names.contains("treeTableModel"));
+        assertSame(next, t.getTreeTableModel());
+        assertEquals(1, t.getColumnCount());
+        assertEquals(1, t.getRowCount());
+        assertEquals("one", t.getValueAt(0, 0));
+        assertTrue("the user object of a default node can be edited", t.isCellEditable(0, 0));
+        // The old model is let go.
+        model.insertNodeInto(new Entry("late", "-"), root, 0);
+        assertEquals(1, t.getRowCount());
+        try {
+            t.setTreeTableModel(null);
+            fail("null was taken for a model");
+        } catch (NullPointerException expected) {
+            assertSame(next, t.getTreeTableModel());
+        }
+
+        JXTreeTable none = new JXTreeTable();
+        assertEquals(0, none.getRowCount());
+        assertEquals(0, none.getColumnCount());
+        assertNull(none.getTreeTableModel().getRoot());
+    }
+
+    @Test
+    public void expansionListenersHearTheTable() {
+        final JXTreeTable t = sample();
+        final List<String> heard = new ArrayList<String>();
+        TreeExpansionListener l = new TreeExpansionListener() {
+            @Override
+            public void treeExpanded(TreeExpansionEvent e) {
+                heard.add("expanded " + e.getPath().getLastPathComponent() + " " + (e.getSource() == t) + " "
+                        + t.getRowCount());
+            }
+
+            @Override
+            public void treeCollapsed(TreeExpansionEvent e) {
+                heard.add("collapsed " + e.getPath().getLastPathComponent() + " " + (e.getSource() == t) + " "
+                        + t.getRowCount());
+            }
+        };
+        t.addTreeExpansionListener(l);
+        t.expandRow(0);
+        t.setRowSelectionInterval(2, 2);
+        t.collapseRow(0);
+        assertEquals(Arrays.asList("expanded docs true 4", "collapsed docs true 2"), heard);
+        assertEquals("the selection moved up to the collapsed node", 0, t.getSelectedRow());
+        t.removeTreeExpansionListener(l);
+        t.expandRow(0);
+        assertEquals(2, heard.size());
+        t.collapseRow(0);
+
+        t.addTreeWillExpandListener(new TreeWillExpandListener() {
+            @Override
+            public void treeWillExpand(TreeExpansionEvent e) throws ExpandVetoException {
+                throw new ExpandVetoException(e);
+            }
+
+            @Override
+            public void treeWillCollapse(TreeExpansionEvent e) {
+            }
+        });
+        t.expandRow(0);
+        assertEquals("the listener refused", 2, t.getRowCount());
+    }
+
+    @Test
+    public void anEditorInTheHierarchicalColumnStartsAfterTheIndent() {
+        DefaultMutableTreeTableNode r = new DefaultMutableTreeTableNode("r");
+        DefaultMutableTreeTableNode a = new DefaultMutableTreeTableNode("a");
+        r.add(a);
+        a.add(new DefaultMutableTreeTableNode("b"));
+        JXTreeTable t = new JXTreeTable(new DefaultTreeTableModel(r, Arrays.asList("Name")));
+        t.expandAll();
+        placed(t, 400, 300);
+        assertTrue(t.editCellAt(0, 0));
+        int step = t.getEditorComponent().getX() - t.getCellRect(0, 0, false).x;
+        assertTrue("the first level is one step in, for its arrow: " + step, step >= 20);
+        t.removeEditor();
+        assertTrue(t.editCellAt(1, 0));
+        Component editor = t.getEditorComponent();
+        assertNotNull(editor);
+        assertEquals("one level down is one step more", 2 * step, editor.getX() - t.getCellRect(1, 0, false).x);
+        t.doLayout();
+        assertEquals(2 * step, t.getEditorComponent().getX() - t.getCellRect(1, 0, false).x);
+        t.removeEditor();
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/PainterWidgetsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/PainterWidgetsTest.java
new file mode 100644
index 00000000000..7c33828b336
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/PainterWidgetsTest.java
@@ -0,0 +1,500 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JSeparator;
+import com.codename1.desktopcompat.javax.swing.SwingConstants;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.BusyPainter;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import com.codename1.desktopcompat.rt.Fonts;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The widgets a painter draws: the label, the button, the busy label
+/// and the titled separator.
+public class PainterWidgetsTest extends KernelTestBase {
+
+    /// A painter that records every call and draws a string, so its turn
+    /// shows among the text the frame draws.
+    private static final class Probe implements Painter<Object> {
+        private final String name;
+        private final List<String> calls;
+
+        Probe(String name, List<String> calls) {
+            this.name = name;
+            this.calls = calls;
+        }
+
+        @Override
+        public void paint(Graphics2D g, Object object, int width, int height) {
+            calls.add(name + ":" + width + "x" + height + ":" + (object == null ? "null" : "component"));
+            g.drawString(name, 1, 12);
+        }
+    }
+
+    private JFrame frameWith(com.codename1.desktopcompat.java.awt.Component c, Object where) {
+        JFrame f = new JFrame();
+        f.add(c, where);
+        show(f);
+        return f;
+    }
+
+    // ------------------------------------------------------------ JXLabel
+
+    @Test
+    public void labelWithoutPaintersIsThePlainLabel() {
+        JXLabel l = new JXLabel("Plain");
+        JFrame f = frameWith(l, BorderLayout.NORTH);
+        assertNotNull(find(paint(f), "Plain"));
+        assertEquals(new JLabel("Plain").getPreferredSize(), l.getPreferredSize());
+    }
+
+    @Test
+    public void labelBackgroundPainterRunsUnderTheText() {
+        List<String> calls = new ArrayList<String>();
+        JXLabel l = new JXLabel("Title");
+        l.setBackgroundPainter(new Probe("under", calls));
+        JFrame f = frameWith(l, BorderLayout.NORTH);
+        List<Object[]> text = paint(f);
+        assertEquals(1, calls.size());
+        assertEquals("under:" + l.getWidth() + "x" + l.getHeight() + ":component", calls.get(0));
+        int under = text.indexOf(find(text, "under"));
+        int title = text.indexOf(find(text, "Title"));
+        assertTrue(under >= 0 && title > under);
+    }
+
+    @Test
+    public void labelForegroundPainterReplacesTheText() {
+        List<String> calls = new ArrayList<String>();
+        JXLabel l = new JXLabel("Title");
+        l.setBackgroundPainter(new Probe("under", calls));
+        l.setForegroundPainter(new Probe("over", calls));
+        JFrame f = frameWith(l, BorderLayout.NORTH);
+        List<Object[]> text = paint(f);
+        assertEquals(2, calls.size());
+        assertTrue(calls.get(0).startsWith("under:"));
+        assertTrue(calls.get(1).startsWith("over:"));
+        assertNull(find(text, "Title"));
+        assertSame(l.getForegroundPainter(), l.getForegroundPainter());
+    }
+
+    @Test
+    public void painterPropertiesAreBoundProperties() {
+        final List<String> names = new ArrayList<String>();
+        JXLabel l = new JXLabel("x");
+        l.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                names.add(e.getPropertyName());
+            }
+        });
+        l.setBackgroundPainter(new Probe("a", new ArrayList<String>()));
+        l.setForegroundPainter(new Probe("b", new ArrayList<String>()));
+        l.setLineWrap(true);
+        l.setTextRotation(JXLabel.VERTICAL_LEFT);
+        assertTrue(names.toString(), names.contains("backgroundPainter"));
+        assertTrue(names.toString(), names.contains("foregroundPainter"));
+        assertTrue(names.toString(), names.contains("lineWrap"));
+        assertTrue(names.toString(), names.contains("textRotation"));
+    }
+
+    @Test
+    public void textWrapsAtWordsAndLineFeeds() {
+        FontMetrics fm = Fonts.metrics(Fonts.defaultFont());
+        int limit = fm.stringWidth("alpha beta");
+        List<String> lines = JXLabel.cn1Wrap("alpha beta gamma delta\nepsilon", fm, limit);
+        assertEquals("[alpha beta, gamma, delta, epsilon]", lines.toString());
+        assertEquals("[one two, three]", JXLabel.cn1Wrap("one two\nthree", fm, 0).toString());
+        assertTrue(JXLabel.cn1Wrap(null, fm, 10).isEmpty());
+        // A word wider than the limit keeps a line to itself.
+        assertEquals("[a, incomprehensibilities, b]",
+                JXLabel.cn1Wrap("a incomprehensibilities b", fm, fm.stringWidth("incompr")).toString());
+    }
+
+    @Test
+    public void wrappedLabelPrefersTheHeightOfItsLines() {
+        FontMetrics fm = Fonts.metrics(Fonts.defaultFont());
+        String text = "one two three four five six seven eight nine ten";
+        JXLabel one = new JXLabel(text);
+        one.setLineWrap(true);
+        Dimension single = one.getPreferredSize();
+
+        JXLabel l = new JXLabel(text);
+        l.setLineWrap(true);
+        l.setMaxLineSpan(fm.stringWidth("one two three four"));
+        assertEquals(fm.stringWidth("one two three four"), l.getMaxLineSpan());
+        int lines = JXLabel.cn1Wrap(text, fm, l.getMaxLineSpan()).size();
+        assertTrue(lines >= 3);
+        Dimension wrapped = l.getPreferredSize();
+        assertEquals(single.height + (lines - 1) * fm.getHeight(), wrapped.height);
+        assertTrue(wrapped.width < single.width);
+        assertTrue(wrapped.width >= l.getMaxLineSpan() - fm.stringWidth("four "));
+    }
+
+    @Test
+    public void wrappedLabelDrawsEachLineItself() {
+        FontMetrics fm = Fonts.metrics(Fonts.defaultFont());
+        JXLabel l = new JXLabel("alpha beta gamma delta");
+        l.setLineWrap(true);
+        l.setMaxLineSpan(fm.stringWidth("gamma delta"));
+        JFrame f = frameWith(l, BorderLayout.NORTH);
+        List<Object[]> text = paint(f);
+        Object[] first = find(text, "alpha beta");
+        Object[] second = find(text, "gamma delta");
+        assertNotNull(first);
+        assertNotNull(second);
+        assertTrue(first[2] + " then " + second[2] + " in " + l.getSize(),
+                ((Integer) second[2]).intValue() > ((Integer) first[2]).intValue());
+        assertNull(find(text, "alpha beta gamma delta"));
+    }
+
+    @Test
+    public void rotatedLabelPrefersTheTurnedBox() {
+        JXLabel flat = new JXLabel("A fairly long caption");
+        flat.setLineWrap(true);
+        Dimension d0 = flat.getPreferredSize();
+        assertTrue(d0.width > d0.height);
+
+        JXLabel up = new JXLabel("A fairly long caption");
+        up.setLineWrap(true);
+        up.setTextRotation(JXLabel.VERTICAL_LEFT);
+        assertEquals(JXLabel.VERTICAL_LEFT, up.getTextRotation(), 0.0);
+        Dimension d1 = up.getPreferredSize();
+        assertTrue(d1.height > d1.width);
+        FontMetrics fm = Fonts.metrics(Fonts.defaultFont());
+        assertTrue(d1.height >= fm.stringWidth("A fairly long caption"));
+        assertTrue(d1.width >= fm.getHeight());
+
+        // Upside down the box is the unrotated one.
+        JXLabel down = new JXLabel("A fairly long caption");
+        down.setLineWrap(true);
+        down.setTextRotation(JXLabel.INVERTED);
+        assertEquals(d0, down.getPreferredSize());
+
+        // A quarter between: both sides grow.
+        JXLabel slant = new JXLabel("A fairly long caption");
+        slant.setTextRotation(Math.PI / 4);
+        Dimension d2 = slant.getPreferredSize();
+        assertTrue(d2.height > d0.height && d2.width > d0.height);
+    }
+
+    @Test
+    public void textAlignmentCarriesItsStyleConstant() {
+        assertEquals(0, JXLabel.TextAlignment.LEFT.getValue());
+        assertEquals(1, JXLabel.TextAlignment.CENTER.getValue());
+        assertEquals(2, JXLabel.TextAlignment.RIGHT.getValue());
+        assertEquals(3, JXLabel.TextAlignment.JUSTIFY.getValue());
+        JXLabel l = new JXLabel("x");
+        l.setTextAlignment(JXLabel.TextAlignment.RIGHT);
+        assertSame(JXLabel.TextAlignment.RIGHT, l.getTextAlignment());
+    }
+
+    // ------------------------------------------------------------ JXButton
+
+    @Test
+    public void buttonWithoutPaintersIsThePlainButton() {
+        JXButton b = new JXButton("Go");
+        JFrame f = frameWith(b, BorderLayout.SOUTH);
+        assertNotNull(find(paint(f), "Go"));
+    }
+
+    @Test
+    public void buttonBackgroundPainterRunsUnderItsText() {
+        List<String> calls = new ArrayList<String>();
+        JXButton b = new JXButton("Go");
+        b.setBackgroundPainter(new Probe("under", calls));
+        JFrame f = frameWith(b, BorderLayout.SOUTH);
+        List<Object[]> text = paint(f);
+        assertEquals(1, calls.size());
+        assertEquals("under:" + b.getWidth() + "x" + b.getHeight() + ":component", calls.get(0));
+        int under = text.indexOf(find(text, "under"));
+        int go = text.indexOf(find(text, "Go"));
+        assertTrue(under >= 0 && go > under);
+        // The text is centered.
+        int x = ((Integer) find(text, "Go")[1]).intValue();
+        int left = onDisplay(b, 0, 0)[0];
+        int right = onDisplay(b, b.getWidth(), 0)[0];
+        assertTrue(x > left && x < right);
+    }
+
+    @Test
+    public void buttonForegroundPainterReplacesItsText() {
+        List<String> calls = new ArrayList<String>();
+        JXButton b = new JXButton("Go");
+        b.setForegroundPainter(new Probe("over", calls));
+        JFrame f = frameWith(b, BorderLayout.SOUTH);
+        List<Object[]> text = paint(f);
+        assertEquals(1, calls.size());
+        assertNull(find(text, "Go"));
+        assertNotNull(find(text, "over"));
+    }
+
+    @Test
+    public void paintedButtonStillClicks() {
+        final int[] clicks = new int[1];
+        JXButton b = new JXButton("Go");
+        b.setBackgroundPainter(new Probe("under", new ArrayList<String>()));
+        b.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                clicks[0]++;
+            }
+        });
+        JFrame f = frameWith(b, BorderLayout.SOUTH);
+        paint(f);
+        press(f, b, 5, 5);
+        release(f, b, 5, 5);
+        assertEquals(1, clicks[0]);
+    }
+
+    // ------------------------------------------------------------ JXBusyLabel
+
+    private static JXBusyLabel still() {
+        JXBusyLabel l = new JXBusyLabel(new Dimension(20, 20));
+        // Out of the way of the real clock: the test turns the wheel.
+        l.setDelay(3600000);
+        return l;
+    }
+
+    @Test
+    public void busyLabelReservesThePlaceOfItsWheel() {
+        JXBusyLabel l = still();
+        assertEquals(20, l.getIcon().getIconWidth());
+        assertEquals(20, l.getIcon().getIconHeight());
+        assertNotNull(l.getBusyPainter());
+        assertFalse(l.isBusy());
+        assertEquals(-1, l.getBusyPainter().getFrame());
+        assertEquals(26, new JXBusyLabel().getIcon().getIconWidth());
+    }
+
+    @Test
+    public void eachTickMovesTheHighlightOnePointAndWrapsAround() {
+        final int[] frames = new int[1];
+        JXBusyLabel l = new JXBusyLabel(new Dimension(20, 20)) {
+            @Override
+            protected void frameChanged() {
+                frames[0]++;
+                super.frameChanged();
+            }
+        };
+        l.setDelay(3600000);
+        BusyPainter p = l.getBusyPainter();
+        int points = p.getPoints();
+        assertTrue(points > 1);
+        // An idle label does not turn.
+        l.cn1Tick();
+        assertEquals(-1, p.getFrame());
+        assertEquals(0, frames[0]);
+
+        l.setBusy(true);
+        assertTrue(l.isBusy());
+        for (int i = 0; i < points; i++) {
+            l.cn1Tick();
+            assertEquals(i, p.getFrame());
+        }
+        l.cn1Tick();
+        assertEquals(0, p.getFrame());
+        assertEquals(points + 1, frames[0]);
+
+        l.setBusy(false);
+        assertEquals(-1, p.getFrame());
+        l.cn1Tick();
+        assertEquals(-1, p.getFrame());
+    }
+
+    @Test
+    public void theTimerRunsOnlyWhileBusyAndShown() {
+        JXBusyLabel l = still();
+        l.setBusy(true);
+        // Busy, but in no window.
+        assertFalse(l.cn1Animating());
+        JFrame f = frameWith(l, BorderLayout.NORTH);
+        assertTrue(l.cn1Animating());
+        l.setBusy(false);
+        assertFalse(l.cn1Animating());
+        l.setBusy(true);
+        assertTrue(l.cn1Animating());
+        f.remove(l);
+        assertFalse(l.cn1Animating());
+        assertTrue(l.isBusy());
+        f.add(l, BorderLayout.NORTH);
+        assertTrue(l.cn1Animating());
+        l.setBusy(false);
+    }
+
+    @Test
+    public void busyIsABoundPropertyAndDelayReachesTheTimer() {
+        final List<String> events = new ArrayList<String>();
+        JXBusyLabel l = still();
+        l.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                events.add(e.getPropertyName() + "=" + e.getNewValue());
+            }
+        });
+        l.setBusy(true);
+        l.setBusy(true);
+        l.setDelay(250);
+        l.setBusy(false);
+        assertEquals(250, l.getDelay());
+        assertEquals("[busy=true, delay=250, busy=false]", events.toString());
+    }
+
+    @Test
+    public void theWheelIsPaintedWhereTheIconIs() {
+        final List<String> calls = new ArrayList<String>();
+        JXBusyLabel l = still();
+        l.setText("Loading");
+        l.setBusyPainter(new BusyPainter(20) {
+            @Override
+            protected void doPaint(Graphics2D g, Object t, int width, int height) {
+                calls.add(width + "x" + height + ":" + getFrame());
+                g.drawString("wheel", 0, 12);
+            }
+        });
+        JFrame f = frameWith(l, BorderLayout.NORTH);
+        l.setBusy(true);
+        l.cn1Tick();
+        l.cn1Tick();
+        List<Object[]> text = paint(f);
+        l.setBusy(false);
+        assertEquals("[20x20:1]", calls.toString());
+        Object[] wheel = find(text, "wheel");
+        Object[] loading = find(text, "Loading");
+        assertNotNull(wheel);
+        assertNotNull(loading);
+        // The wheel comes before the text, inside the label.
+        assertTrue(((Integer) wheel[1]).intValue() < ((Integer) loading[1]).intValue());
+        Rectangle r = l.cn1WheelBounds();
+        assertEquals(onDisplay(l, r.x, 0)[0], ((Integer) wheel[1]).intValue());
+        assertEquals(20, r.width);
+        assertEquals(20, r.height);
+        assertTrue(r.toString(), r.x >= 0 && r.x + r.width <= l.getWidth());
+    }
+
+    @Test
+    public void directionReachesThePainter() {
+        JXBusyLabel l = still();
+        l.setDirection(BusyPainter.Direction.LEFT);
+        assertSame(BusyPainter.Direction.LEFT, l.getBusyPainter().getDirection());
+    }
+
+    // ------------------------------------------------------------ JXTitledSeparator
+
+    private static int index(JXTitledSeparator s, Class<?> type, int nth) {
+        int seen = 0;
+        for (int i = 0; i < s.getComponentCount(); i++) {
+            if (type.isInstance(s.getComponent(i))) {
+                if (seen == nth) {
+                    return i;
+                }
+                seen++;
+            }
+        }
+        return -1;
+    }
+
+    @Test
+    public void titledSeparatorIsATitleAndALineThatTakesTheRest() {
+        JXTitledSeparator s = new JXTitledSeparator("Options");
+        assertEquals("Options", s.getTitle());
+        assertEquals(2, s.getComponentCount());
+        assertTrue(s.getComponent(0) instanceof JLabel);
+        assertTrue(s.getComponent(1) instanceof JSeparator);
+        JFrame f = frameWith(s, BorderLayout.NORTH);
+        f.setSize(400, 300);
+        f.validate();
+        assertNotNull(find(paint(f), "Options"));
+        com.codename1.desktopcompat.java.awt.Component label = s.getComponent(0);
+        com.codename1.desktopcompat.java.awt.Component line = s.getComponent(1);
+        assertTrue(line.getX() >= label.getX() + label.getWidth());
+        assertTrue(line.getWidth() > label.getWidth());
+        assertEquals("Untitled", new JXTitledSeparator().getTitle());
+    }
+
+    @Test
+    public void alignmentMovesTheTitle() {
+        JXTitledSeparator s = new JXTitledSeparator("Options", SwingConstants.RIGHT);
+        assertEquals(SwingConstants.RIGHT, s.getHorizontalAlignment());
+        assertEquals(2, s.getComponentCount());
+        assertEquals(0, index(s, JSeparator.class, 0));
+        assertEquals(1, index(s, JLabel.class, 0));
+        s.setHorizontalAlignment(SwingConstants.CENTER);
+        assertEquals(3, s.getComponentCount());
+        assertEquals(0, index(s, JSeparator.class, 0));
+        assertEquals(1, index(s, JLabel.class, 0));
+        assertEquals(2, index(s, JSeparator.class, 1));
+        s.setHorizontalAlignment(SwingConstants.LEFT);
+        assertEquals(0, index(s, JLabel.class, 0));
+        assertEquals(2, s.getComponentCount());
+    }
+
+    @Test
+    public void titlePropertiesReachTheLabel() {
+        final List<String> names = new ArrayList<String>();
+        JXTitledSeparator s = new JXTitledSeparator("Options");
+        s.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                names.add(e.getPropertyName());
+            }
+        });
+        s.setTitle("Other");
+        s.setForeground(Color.RED);
+        s.setHorizontalTextPosition(SwingConstants.LEFT);
+        assertEquals("Other", s.getTitle());
+        assertEquals(SwingConstants.LEFT, s.getHorizontalTextPosition());
+        assertTrue(s.getComponent(0) instanceof JLabel);
+        JLabel label = (JLabel) s.getComponent(0);
+        assertEquals("Other", label.getText());
+        assertEquals(Color.RED, label.getForeground());
+        assertTrue(names.toString(), names.contains("title"));
+        assertNull(s.getIcon());
+        // An empty title leaves the line alone.
+        s.setTitle("");
+        assertFalse(label.isVisible());
+        s.setTitle("Back");
+        assertTrue(label.isVisible());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/PanelLayoutsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/PanelLayoutsTest.java
new file mode 100644
index 00000000000..c32ef777609
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/PanelLayoutsTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.javax.swing.BorderFactory;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import org.junit.Test;
+
+/// The arithmetic of the vertical and horizontal layouts and of the
+/// status bar's constraints.
+public class PanelLayoutsTest extends KernelTestBase {
+
+    private static JPanel box(int w, int h) {
+        JPanel p = new JPanel();
+        p.setPreferredSize(new Dimension(w, h));
+        return p;
+    }
+
+    @Test
+    public void verticalLayoutStacksVisibleChildrenAtFullWidth() {
+        JPanel p = new JPanel(new VerticalLayout(5));
+        p.setBorder(BorderFactory.createEmptyBorder(1, 2, 3, 4));
+        JPanel a = box(30, 10);
+        JPanel hidden = box(500, 500);
+        hidden.setVisible(false);
+        JPanel b = box(50, 20);
+        p.add(a);
+        p.add(hidden);
+        p.add(b);
+        assertEquals(new Dimension(50 + 6, 10 + 5 + 20 + 4), p.getPreferredSize());
+        assertEquals(p.getPreferredSize(), p.getMinimumSize());
+        p.setSize(100, 100);
+        p.doLayout();
+        assertEquals(new Rectangle(2, 1, 94, 10), a.getBounds());
+        assertEquals(new Rectangle(2, 16, 94, 20), b.getBounds());
+    }
+
+    @Test
+    public void horizontalLayoutPlacesVisibleChildrenAtFullHeight() {
+        HorizontalLayout layout = new HorizontalLayout();
+        layout.setGap(7);
+        assertEquals(7, layout.getGap());
+        JPanel p = new JPanel(layout);
+        p.setBorder(BorderFactory.createEmptyBorder(1, 2, 3, 4));
+        JPanel a = box(30, 10);
+        JPanel b = box(50, 20);
+        p.add(a);
+        p.add(b);
+        assertEquals(new Dimension(30 + 7 + 50 + 6, 20 + 4), p.getPreferredSize());
+        p.setSize(200, 40);
+        p.doLayout();
+        assertEquals(new Rectangle(2, 1, 30, 36), a.getBounds());
+        assertEquals(new Rectangle(39, 1, 50, 36), b.getBounds());
+    }
+
+    @Test
+    public void statusBarGivesFixedWidthsAndSharesTheRest() {
+        JXStatusBar bar = new JXStatusBar();
+        JPanel a = box(10, 12);
+        JPanel b = box(10, 12);
+        JPanel c = box(30, 12);
+        JPanel d = box(10, 12);
+        bar.add(a, new JXStatusBar.Constraint(50));
+        bar.add(b, new JXStatusBar.Constraint(JXStatusBar.Constraint.ResizeBehavior.FILL));
+        bar.add(c);
+        bar.add(d, new JXStatusBar.Constraint(JXStatusBar.Constraint.ResizeBehavior.FILL, new Insets(0, 5, 0, 5)));
+        bar.setSize(300, 30);
+        bar.doLayout();
+        assertEquals(new Rectangle(4, 3, 50, 24), a.getBounds());
+        assertEquals(new Rectangle(63, 3, 87, 24), b.getBounds());
+        assertEquals(new Rectangle(159, 3, 30, 24), c.getBounds());
+        assertEquals(new Rectangle(203, 3, 88, 24), d.getBounds());
+        // 4 edge + 50 + 10 + 30 + 10 preferred + 10 insets + 3 gaps of 9 + 4 edge
+        assertEquals(new Dimension(145, 18), bar.getPreferredSize());
+    }
+
+    @Test
+    public void statusBarConstraintAccessors() {
+        JXStatusBar.Constraint fixed = new JXStatusBar.Constraint();
+        assertEquals(JXStatusBar.Constraint.ResizeBehavior.FIXED, fixed.getResizeBehavior());
+        assertTrue(fixed.getFixedWidth() < 0);
+        fixed.setFixedWidth(40);
+        assertEquals(40, fixed.getFixedWidth());
+        Insets in = new Insets(1, 2, 3, 4);
+        JXStatusBar.Constraint c = new JXStatusBar.Constraint(20, in);
+        in.left = 99;
+        assertEquals(new Insets(1, 2, 3, 4), c.getInsets());
+        JXStatusBar bar = new JXStatusBar();
+        assertTrue(bar.isResizeHandleEnabled());
+        bar.setResizeHandleEnabled(false);
+        assertFalse(bar.isResizeHandleEnabled());
+    }
+
+    @Test
+    public void statusBarHidesNothingWhenTooNarrow() {
+        JXStatusBar bar = new JXStatusBar();
+        JPanel a = box(60, 12);
+        JPanel fill = box(10, 12);
+        bar.add(a);
+        bar.add(fill, new JXStatusBar.Constraint(JXStatusBar.Constraint.ResizeBehavior.FILL));
+        bar.setSize(40, 20);
+        bar.doLayout();
+        assertEquals(60, a.getWidth());
+        assertEquals(0, fill.getWidth());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/TitledPanelAndHeaderTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/TitledPanelAndHeaderTest.java
new file mode 100644
index 00000000000..0aaabaf369c
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/TitledPanelAndHeaderTest.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.painter.Painter;
+import java.util.List;
+import org.junit.Test;
+
+/// The titled panel's bar and content, and the header's title and
+/// description.
+public class TitledPanelAndHeaderTest extends KernelTestBase {
+
+    @Test
+    public void theTitleIsPaintedOverTheContent() {
+        JXTitledPanel panel = new JXTitledPanel("Inbox");
+        panel.getContentContainer().add(new JLabel("Body"));
+        JFrame f = new JFrame();
+        f.add(panel, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        List<Object[]> text = paint(f);
+        Object[] title = find(text, "Inbox");
+        Object[] body = find(text, "Body");
+        assertNotNull(title);
+        assertNotNull(body);
+        assertTrue(((Integer) title[2]).intValue() < ((Integer) body[2]).intValue());
+
+        panel.setTitle("Sent");
+        assertEquals("Sent", panel.getTitle());
+        text = paint(f);
+        assertNull(find(text, "Inbox"));
+        assertNotNull(find(text, "Sent"));
+    }
+
+    @Test
+    public void replacingTheContentContainer() {
+        JXTitledPanel panel = new JXTitledPanel("T");
+        Container old = panel.getContentContainer();
+        assertSame(panel, old.getParent());
+        JXPanel next = new JXPanel();
+        panel.setContentContainer(next);
+        assertSame(next, panel.getContentContainer());
+        assertSame(panel, next.getParent());
+        assertNull(old.getParent());
+        assertEquals(2, panel.getComponentCount());
+    }
+
+    @Test
+    public void decorationsSitAtTheEndsOfTheBar() {
+        JXTitledPanel panel = new JXTitledPanel("Title");
+        JButton left = new JButton("L");
+        JButton right = new JButton("R");
+        panel.setLeftDecoration(left);
+        panel.setRightDecoration(right);
+        assertSame(left, panel.getLeftDecoration());
+        assertSame(right, panel.getRightDecoration());
+        JFrame f = new JFrame();
+        f.add(panel, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        Container bar = right.getParent();
+        assertSame(bar, left.getParent());
+        assertEquals(6, left.getX());
+        assertEquals(bar.getWidth() - 6, right.getX() + right.getWidth());
+        assertEquals(panel.getWidth(), bar.getWidth());
+        Object[] title = find(paint(f), "Title");
+        assertNotNull(title);
+        int titleX = ((Integer) title[1]).intValue();
+        assertTrue(titleX >= onDisplay(left, left.getWidth(), 0)[0]);
+        assertTrue(titleX < onDisplay(right, 0, 0)[0]);
+
+        panel.setRightDecoration(null);
+        assertNull(right.getParent());
+    }
+
+    @Test
+    public void aTitlePainterDrawsTheBar() {
+        final Object[] seen = new Object[3];
+        JXTitledPanel panel = new JXTitledPanel("Painted");
+        panel.setTitlePainter(new Painter<Object>() {
+            @Override
+            public void paint(Graphics2D g, Object object, int width, int height) {
+                seen[0] = object;
+                seen[1] = Integer.valueOf(width);
+                seen[2] = Integer.valueOf(height);
+            }
+        });
+        panel.setTitleForeground(Color.RED);
+        assertEquals(Color.RED, panel.getTitleForeground());
+        JFrame f = new JFrame();
+        f.add(panel, BorderLayout.CENTER);
+        show(f);
+        f.validate();
+        assertNotNull(find(paint(f), "Painted"));
+        assertSame(panel, seen[0]);
+        assertEquals(Integer.valueOf(panel.getWidth()), seen[1]);
+        assertTrue(((Integer) seen[2]).intValue() > 0);
+    }
+
+    @Test
+    public void theHeaderShowsTitleOverDescription() {
+        JXHeader header = new JXHeader("Welcome", "Pick a file");
+        assertEquals("Welcome", header.getTitle());
+        assertEquals("Pick a file", header.getDescription());
+        assertEquals(JXHeader.IconPosition.RIGHT, header.getIconPosition());
+        JFrame f = new JFrame();
+        f.add(header, BorderLayout.NORTH);
+        show(f);
+        f.validate();
+        assertTrue(header.getHeight() > 24);
+        List<Object[]> text = paint(f);
+        Object[] title = find(text, "Welcome");
+        Object[] description = find(text, "Pick a file");
+        assertNotNull(title);
+        assertNotNull(description);
+        assertTrue(((Integer) title[2]).intValue() < ((Integer) description[2]).intValue());
+        // The description is indented under the title.
+        assertTrue(((Integer) title[1]).intValue() < ((Integer) description[1]).intValue());
+
+        header.setDescription("Or drop one");
+        header.setIconPosition(JXHeader.IconPosition.LEFT);
+        assertEquals(JXHeader.IconPosition.LEFT, header.getIconPosition());
+        f.validate();
+        assertNotNull(find(paint(f), "Or drop one"));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/WindowsAndErrorsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/WindowsAndErrorsTest.java
new file mode 100644
index 00000000000..d2fcf910a1f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/WindowsAndErrorsTest.java
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx;
+
+import com.codename1.desktopcompat.WindowsTestBase;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.java.awt.Container;
+import com.codename1.desktopcompat.java.awt.Cursor;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Window;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.KeyEvent;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.AbstractButton;
+import com.codename1.desktopcompat.javax.swing.Action;
+import com.codename1.desktopcompat.javax.swing.Icon;
+import com.codename1.desktopcompat.javax.swing.JButton;
+import com.codename1.desktopcompat.javax.swing.JDialog;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import com.codename1.desktopcompat.javax.swing.JPanel;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.JTextArea;
+import com.codename1.desktopcompat.javax.swing.KeyStroke;
+import com.codename1.desktopcompat.org.jdesktop.swingx.action.AbstractActionExt;
+import com.codename1.desktopcompat.org.jdesktop.swingx.error.ErrorEvent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.error.ErrorListener;
+import com.codename1.desktopcompat.org.jdesktop.swingx.error.ErrorSupport;
+import com.codename1.desktopcompat.rt.WindowHosts;
+import com.codename1.ui.Display;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The SwingX windows and what hangs off the action map: the error pane
+/// and its dialog, the extended frame and dialog, the collapsible pane's
+/// toggle action and the accelerator of an extended action.
+public class WindowsAndErrorsTest extends WindowsTestBase {
+
+    private final List<String> order = new ArrayList<String>();
+
+    /// Runs `r` on the event thread once the dialog the test is about to
+    /// open is on the screen and the test is blocked in it.
+    private void whileBlocked(final Runnable r) {
+        Thread later = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(150);
+                } catch (InterruptedException e) {
+                    return;
+                }
+                Display.getInstance().callSerially(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            r.run();
+                            order.add("answered");
+                        } catch (RuntimeException e) {
+                            order.add("failed: " + e);
+                            closeTop();
+                        } catch (AssertionError e) {
+                            order.add("failed: " + e);
+                            closeTop();
+                        }
+                    }
+                });
+            }
+        });
+        later.start();
+    }
+
+    private static void closeTop() {
+        Window w = WindowHosts.active();
+        if (w instanceof JDialog) {
+            w.setVisible(false);
+        }
+    }
+
+    private static <T> T find(Component root, Class<T> type, String text) {
+        if (type.isInstance(root)) {
+            boolean match = text == null;
+            if (!match && root instanceof AbstractButton) {
+                match = text.equals(((AbstractButton) root).getText());
+            }
+            if (!match && root instanceof JLabel) {
+                match = text.equals(((JLabel) root).getText());
+            }
+            if (match) {
+                return type.cast(root);
+            }
+        }
+        if (root instanceof Container) {
+            Component[] kids = ((Container) root).getComponents();
+            for (int i = 0; i < kids.length; i++) {
+                T t = find(kids[i], type, text);
+                if (t != null) {
+                    return t;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static final class Dot implements Icon {
+
+        @Override
+        public void paintIcon(Component c, Graphics g, int x, int y) {
+        }
+
+        @Override
+        public int getIconWidth() {
+            return 8;
+        }
+
+        @Override
+        public int getIconHeight() {
+            return 8;
+        }
+    }
+
+    @Test
+    public void anErrorDialogBlocksShowsTheMessageAndOpensTheTrace() {
+        final Throwable cause = new IllegalArgumentException("bad input");
+        final Throwable error = new IllegalStateException("It broke", cause);
+        whileBlocked(new Runnable() {
+            @Override
+            public void run() {
+                Window top = WindowHosts.active();
+                assertTrue("a dialog is showing: " + top, top instanceof JDialog);
+                JDialog d = (JDialog) top;
+                assertEquals("Error", d.getTitle());
+                assertTrue(d.isModal());
+                assertNotNull("the message", find(d, JLabel.class, "It broke"));
+                JScrollPane scroll = find(d, JScrollPane.class, null);
+                assertNotNull(scroll);
+                assertFalse("the trace starts closed", scroll.isVisible());
+                int closed = d.getHeight();
+                find(d, JButton.class, "Details >>").doClick();
+                assertTrue(scroll.isVisible());
+                assertTrue("the dialog grew: " + closed + " -> " + d.getHeight(), d.getHeight() > closed);
+                String trace = find(d, JTextArea.class, null).getText();
+                assertTrue(trace, trace.startsWith("java.lang.IllegalStateException: It broke\n"));
+                assertTrue(trace, trace.indexOf("Caused by: java.lang.IllegalArgumentException: bad input\n") > 0);
+                find(d, JButton.class, "Details <<").doClick();
+                assertFalse(scroll.isVisible());
+                JButton close = find(d, JButton.class, "Close");
+                assertSame(close, d.getRootPane().getDefaultButton());
+                close.doClick();
+            }
+        });
+        JXErrorPane.showDialog(error);
+        order.add("returned");
+        assertEquals("[answered, returned]", order.toString());
+        assertFalse("the dialog is gone", WindowHosts.active() instanceof JDialog);
+    }
+
+    @Test
+    public void anErrorPaneDialogBelongsToTheOwnersWindow() {
+        JFrame f = show(new JFrame("owner"));
+        JPanel p = new JPanel();
+        f.add(p);
+        JXErrorPane pane = new JXErrorPane();
+        assertEquals("ErrorPaneUI", pane.getUIClassID());
+        Icon dot = new Dot();
+        pane.setIcon(dot);
+        assertSame(dot, pane.getIcon());
+        JDialog d = JXErrorPane.createDialog(p, pane);
+        assertSame(f, d.getOwner());
+        assertFalse(d.isVisible());
+        assertSame(dot, find(d, JLabel.class, null).getIcon());
+        assertFalse("nothing to detail", find(d, JButton.class, "Details >>").isEnabled());
+        d.dispose();
+    }
+
+    @Test
+    public void errorSupportTellsItsListeners() {
+        final List<ErrorEvent> seen = new ArrayList<ErrorEvent>();
+        ErrorSupport support = new ErrorSupport(this);
+        ErrorListener l = new ErrorListener() {
+            @Override
+            public void errorOccured(ErrorEvent event) {
+                seen.add(event);
+            }
+        };
+        support.addErrorListener(l);
+        assertEquals(1, support.getErrorListeners().length);
+        Throwable t = new RuntimeException("x");
+        support.fireErrorEvent(t);
+        assertEquals(1, seen.size());
+        assertSame(t, seen.get(0).getThrowable());
+        assertSame(this, seen.get(0).getSource());
+        support.removeErrorListener(l);
+        support.fireErrorEvent(t);
+        assertEquals(1, seen.size());
+    }
+
+    @Test
+    public void escapePressesTheCancelButtonOfAFrame() {
+        JXFrame f = new JXFrame("x");
+        final int[] cancelled = new int[1];
+        JButton cancel = new JButton(new AbstractAction("Cancel") {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                cancelled[0]++;
+            }
+        });
+        JButton ok = new JButton("OK");
+        JPanel p = new JPanel();
+        p.add(ok);
+        p.add(cancel);
+        f.add(p);
+        f.setCancelButton(cancel);
+        f.setDefaultButton(ok);
+        assertSame(cancel, f.getCancelButton());
+        assertSame(ok, f.getDefaultButton());
+        assertSame(ok, f.getRootPane().getDefaultButton());
+        show(f);
+        type(f, KeyEvent.VK_ESCAPE);
+        assertEquals(1, cancelled[0]);
+        cancel.setEnabled(false);
+        type(f, KeyEvent.VK_ESCAPE);
+        assertEquals(1, cancelled[0]);
+        f.setCancelButton(null);
+        cancel.setEnabled(true);
+        type(f, KeyEvent.VK_ESCAPE);
+        assertEquals(1, cancelled[0]);
+    }
+
+    @Test
+    public void aWaitingFrameShowsItsWaitPaneAndCursor() {
+        JXFrame f = new JXFrame();
+        assertEquals(JXFrame.StartPosition.Manual, f.getStartPosition());
+        f.setStartPosition(JXFrame.StartPosition.CenterInScreen);
+        assertEquals(JXFrame.StartPosition.CenterInScreen, f.getStartPosition());
+        Component glass = f.getGlassPane();
+        JPanel wait = new JPanel();
+        f.setWaitPane(wait);
+        assertSame(wait, f.getWaitPane());
+        assertSame(glass, f.getGlassPane());
+        f.setSize(200, 100);
+        show(f);
+
+        f.setWaiting(true);
+        assertTrue(f.isWaiting());
+        assertTrue(f.isWaitPaneVisible());
+        assertTrue(f.isWaitCursorVisible());
+        assertSame(wait, f.getGlassPane());
+        assertTrue(wait.isVisible());
+        assertEquals(Cursor.WAIT_CURSOR, f.getCursor().getType());
+        Cursor hand = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR);
+        f.setCursor(hand);
+        assertEquals("kept for later", Cursor.WAIT_CURSOR, f.getCursor().getType());
+
+        f.setWaiting(false);
+        assertFalse(f.isWaiting());
+        assertSame(glass, f.getGlassPane());
+        assertFalse(wait.isVisible());
+        assertSame(hand, f.getCursor());
+
+        assertFalse(f.isIdle());
+        f.setIdle(true);
+        assertTrue(f.isIdle());
+        f.setIdleThreshold(5000L);
+        assertEquals(5000L, f.getIdleThreshold());
+    }
+
+    @Test
+    public void aDialogTakesItsButtonsFromTheContentsActions() {
+        final int[] ran = new int[1];
+        JPanel content = new JPanel();
+        content.setName("Find");
+        content.add(new JLabel("what"));
+        content.getActionMap().put(JXDialog.EXECUTE_ACTION_COMMAND, new AbstractAction("Search") {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                ran[0]++;
+            }
+        });
+        JFrame owner = show(new JFrame("owner"));
+        JXDialog d = new JXDialog(owner, content);
+        assertEquals("Find", d.getTitle());
+        assertSame(owner, d.getOwner());
+        assertFalse(d.isModal());
+        JButton search = find(d, JButton.class, "Search");
+        JButton close = find(d, JButton.class, "Close");
+        assertNotNull(search);
+        assertNotNull(close);
+        assertSame(search, d.getRootPane().getDefaultButton());
+        assertTrue("packed", d.getWidth() > 0 && d.getHeight() > 0);
+        d.setVisible(true);
+        search.doClick();
+        assertEquals(1, ran[0]);
+        assertTrue(d.isVisible());
+        type(d, KeyEvent.VK_ESCAPE);
+        assertFalse("escape closes", d.isVisible());
+
+        JXDialog plain = new JXDialog(new JPanel());
+        assertNull(find(plain, JButton.class, "Execute"));
+        plain.setVisible(true);
+        find(plain, JButton.class, "Close").doClick();
+        assertFalse(plain.isVisible());
+    }
+
+    @Test
+    public void theToggleActionFlipsACollapsiblePaneAndSwapsItsIcon() {
+        JXCollapsiblePane pane = new JXCollapsiblePane();
+        pane.setAnimated(false);
+        Action toggle = pane.getActionMap().get(JXCollapsiblePane.TOGGLE_ACTION);
+        assertNotNull(toggle);
+        Icon expand = new Dot();
+        Icon collapse = new Dot();
+        toggle.putValue(JXCollapsiblePane.EXPAND_ICON, expand);
+        assertNull("open, and no collapse icon yet", toggle.getValue(Action.SMALL_ICON));
+        toggle.putValue(JXCollapsiblePane.COLLAPSE_ICON, collapse);
+        assertSame(collapse, toggle.getValue(Action.SMALL_ICON));
+
+        toggle.actionPerformed(new ActionEvent(pane, ActionEvent.ACTION_PERFORMED, "toggle"));
+        assertTrue(pane.isCollapsed());
+        assertSame(expand, toggle.getValue(Action.SMALL_ICON));
+        JButton b = new JButton(toggle);
+        b.doClick();
+        assertFalse(pane.isCollapsed());
+        assertSame(collapse, toggle.getValue(Action.SMALL_ICON));
+        pane.setCollapsed(true);
+        assertSame(expand, toggle.getValue(Action.SMALL_ICON));
+    }
+
+    @Test
+    public void anExtendedActionKeepsItsAccelerator() {
+        AbstractActionExt a = new AbstractActionExt("Save") {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+            }
+        };
+        assertNull(a.getAccelerator());
+        KeyStroke k = KeyStroke.getKeyStroke(KeyEvent.VK_S, 0);
+        a.setAccelerator(k);
+        assertSame(k, a.getAccelerator());
+        assertSame(k, a.getValue(Action.ACCELERATOR_KEY));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSelectionModelTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSelectionModelTest.java
new file mode 100644
index 00000000000..ceac57aee87
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/calendar/DateSelectionModelTest.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.calendar;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.org.jdesktop.swingx.calendar.DateSelectionModel.SelectionMode;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionEvent.EventType;
+import com.codename1.desktopcompat.org.jdesktop.swingx.event.DateSelectionListener;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.TreeSet;
+import org.junit.Test;
+
+/// The selection models on their own: no component and no display.
+public class DateSelectionModelTest {
+
+    private static Date at(int day, int hour) {
+        Calendar c = Calendar.getInstance();
+        c.set(Calendar.YEAR, 2024);
+        c.set(Calendar.MONTH, Calendar.MARCH);
+        c.set(Calendar.DAY_OF_MONTH, day);
+        c.set(Calendar.HOUR_OF_DAY, hour);
+        c.set(Calendar.MINUTE, 0);
+        c.set(Calendar.SECOND, 0);
+        c.set(Calendar.MILLISECOND, 0);
+        return c.getTime();
+    }
+
+    private static Date day(int day) {
+        return at(day, 0);
+    }
+
+    private static List<EventType> listen(DateSelectionModel m) {
+        final List<EventType> seen = new ArrayList<EventType>();
+        m.addDateSelectionListener(new DateSelectionListener() {
+            @Override
+            public void valueChanged(DateSelectionEvent ev) {
+                seen.add(ev.getEventType());
+            }
+        });
+        return seen;
+    }
+
+    @Test
+    public void daySelectionReadsADateAsItsDay() {
+        DaySelectionModel m = new DaySelectionModel();
+        List<EventType> seen = listen(m);
+        assertTrue(m.isSelectionEmpty());
+        assertNull(m.getFirstSelectionDate());
+        m.setSelectionInterval(at(10, 15), at(10, 15));
+        assertEquals(day(10), m.getFirstSelectionDate());
+        assertEquals(day(10), m.getNormalizedDate(at(10, 23)));
+        assertTrue(m.isSelected(at(10, 8)));
+        assertFalse(m.isSelected(day(11)));
+        assertEquals(1, seen.size());
+        assertEquals(EventType.DATES_SET, seen.get(0));
+        // The same day again changes nothing and tells nobody.
+        m.setSelectionInterval(day(10), day(10));
+        assertEquals(1, seen.size());
+        m.clearSelection();
+        assertTrue(m.isSelectionEmpty());
+        assertEquals(EventType.SELECTION_CLEARED, seen.get(1));
+    }
+
+    @Test
+    public void theModeDecidesWhatAnIntervalSelects() {
+        DaySelectionModel m = new DaySelectionModel();
+        assertEquals(SelectionMode.SINGLE_SELECTION, m.getSelectionMode());
+        m.setSelectionInterval(day(5), day(8));
+        assertEquals(1, m.getSelection().size());
+        assertEquals(day(5), m.getFirstSelectionDate());
+
+        m.setSelectionMode(SelectionMode.SINGLE_INTERVAL_SELECTION);
+        assertTrue("changing the mode clears the selection", m.isSelectionEmpty());
+        m.setSelectionInterval(day(5), day(8));
+        assertEquals(4, m.getSelection().size());
+        assertEquals(day(5), m.getFirstSelectionDate());
+        assertEquals(day(8), m.getLastSelectionDate());
+        m.addSelectionInterval(day(20), day(21));
+        assertEquals("one interval at a time", 2, m.getSelection().size());
+        assertEquals(day(20), m.getFirstSelectionDate());
+
+        m.setSelectionMode(SelectionMode.MULTIPLE_INTERVAL_SELECTION);
+        m.setSelectionInterval(day(5), day(8));
+        m.addSelectionInterval(day(20), day(21));
+        assertEquals(6, m.getSelection().size());
+        m.removeSelectionInterval(day(6), day(7));
+        assertEquals(4, m.getSelection().size());
+        assertTrue(m.isSelected(day(5)));
+        assertFalse(m.isSelected(day(6)));
+        assertTrue(m.isSelected(day(21)));
+        // An interval that ends before it starts selects nothing.
+        m.setSelectionInterval(day(9), day(3));
+        assertEquals(4, m.getSelection().size());
+    }
+
+    @Test
+    public void unselectableDatesAndBoundsAreLeftOut() {
+        DaySelectionModel m = new DaySelectionModel();
+        m.setSelectionMode(SelectionMode.SINGLE_INTERVAL_SELECTION);
+        TreeSet<Date> no = new TreeSet<Date>();
+        no.add(at(11, 9));
+        m.setUnselectableDates(no);
+        assertTrue(m.isUnselectableDate(day(11)));
+        assertEquals(1, m.getUnselectableDates().size());
+        assertEquals(day(11), m.getUnselectableDates().first());
+        m.setSelectionInterval(day(10), day(12));
+        assertEquals(2, m.getSelection().size());
+        assertFalse(m.isSelected(day(11)));
+
+        List<EventType> seen = listen(m);
+        m.setLowerBound(day(11));
+        assertEquals(day(11), m.getLowerBound());
+        assertTrue(m.isUnselectableDate(day(10)));
+        assertFalse("the day before the bound left the selection", m.isSelected(day(10)));
+        assertTrue(m.isSelected(day(12)));
+        assertTrue(seen.contains(EventType.LOWER_BOUND_CHANGED));
+        m.setUpperBound(day(20));
+        assertEquals(day(20), m.getUpperBound());
+        assertTrue(m.isUnselectableDate(day(21)));
+        assertFalse(m.isUnselectableDate(day(20)));
+        assertTrue("the bound itself stays selectable", m.isSelected(day(12)));
+        assertTrue(seen.contains(EventType.UPPER_BOUND_CHANGED));
+        m.setSelectionInterval(day(19), day(23));
+        assertEquals(2, m.getSelection().size());
+        assertEquals(day(20), m.getLastSelectionDate());
+    }
+
+    @Test
+    public void adjustingAndTheCalendarAreAnnounced() {
+        DaySelectionModel m = new DaySelectionModel();
+        List<EventType> seen = listen(m);
+        assertFalse(m.isAdjusting());
+        m.setAdjusting(true);
+        assertTrue(m.isAdjusting());
+        m.setAdjusting(true);
+        m.setAdjusting(false);
+        assertEquals(2, seen.size());
+        assertEquals(EventType.ADJUSTING_STARTED, seen.get(0));
+        assertEquals(EventType.ADJUSTING_STOPPED, seen.get(1));
+
+        assertEquals(Calendar.SUNDAY, m.getFirstDayOfWeek());
+        m.setFirstDayOfWeek(Calendar.MONDAY);
+        assertEquals(Calendar.MONDAY, m.getFirstDayOfWeek());
+        assertEquals(EventType.CALENDAR_CHANGED, seen.get(2));
+        // Every call answers a calendar of its own.
+        Calendar a = m.getCalendar();
+        a.setTime(day(3));
+        Calendar b = m.getCalendar();
+        b.setTime(day(9));
+        assertEquals(3, a.get(Calendar.DAY_OF_MONTH));
+        assertEquals(1, m.getDateSelectionListeners().size());
+    }
+
+    @Test
+    public void theDefaultModelKeepsTheInstant() {
+        DefaultDateSelectionModel m = new DefaultDateSelectionModel();
+        m.setSelectionInterval(at(10, 15), at(10, 15));
+        assertEquals(at(10, 15), m.getFirstSelectionDate());
+        assertTrue(m.isSelected(at(10, 15)));
+        assertFalse(m.isSelected(day(10)));
+        assertEquals(at(10, 15), m.getNormalizedDate(at(10, 15)));
+        m.setSelectionMode(SelectionMode.SINGLE_INTERVAL_SELECTION);
+        m.setSelectionInterval(at(10, 15), at(12, 15));
+        assertEquals(3, m.getSelection().size());
+        assertEquals(at(12, 15), m.getLastSelectionDate());
+    }
+
+    @Test
+    public void theCalendarHelpersFindTheEdgesOfADay() {
+        Calendar c = Calendar.getInstance();
+        assertEquals(day(10), CalendarUtils.startOfDay(c, at(10, 17)));
+        assertEquals(day(11).getTime() - 1, CalendarUtils.endOfDay(c, at(10, 17)).getTime());
+        c.setTime(at(10, 17));
+        assertTrue(CalendarUtils.isSameDay(c, at(10, 23)));
+        assertFalse(CalendarUtils.isSameDay(c, at(11, 1)));
+        assertEquals(at(10, 17), c.getTime());
+        CalendarUtils.startOfMonth(c);
+        assertEquals(day(1), c.getTime());
+        assertTrue(CalendarUtils.isStartOfMonth(c));
+        CalendarUtils.endOfMonth(c);
+        assertEquals(31, c.get(Calendar.DAY_OF_MONTH));
+        assertTrue(CalendarUtils.isEndOfMonth(c));
+        assertTrue(CalendarUtils.isEndOfDay(c));
+        assertEquals(29, CalendarUtils.daysInMonth(2024, Calendar.FEBRUARY));
+        assertEquals(28, CalendarUtils.daysInMonth(2100, Calendar.FEBRUARY));
+        assertTrue(CalendarUtils.areEqual(null, null));
+        assertFalse(CalendarUtils.areEqual(day(1), null));
+        assertTrue(CalendarUtils.areEqual(day(1), at(1, 0)));
+    }
+}
diff --git a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileCanonicalPathTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlighterFactoryParityTest.java
similarity index 52%
rename from maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileCanonicalPathTest.java
rename to maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlighterFactoryParityTest.java
index cf47edef676..4a027920473 100644
--- a/maven/android-compat/src/test/java/com/codename1/androidcompat/jdk/FileCanonicalPathTest.java
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/decorator/HighlighterFactoryParityTest.java
@@ -20,35 +20,33 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
-package com.codename1.androidcompat.jdk;
+package com.codename1.desktopcompat.org.jdesktop.swingx.decorator;
 
-import com.codename1.androidcompat.testing.MainThreadRule;
-import org.junit.Rule;
+import com.codename1.desktopcompat.java.awt.Color;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
 import org.junit.Test;
-
-import java.io.IOException;
-
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
-/// The canonical path resolves `.` and `..`: a check that a name stays
-/// inside a directory accepted `root/../outside`, which the native file
-/// system then resolved outside it.
-public class FileCanonicalPathTest {
-
-    @Rule
-    public final MainThreadRule mainThread = new MainThreadRule();
-
-    @Test
-    public void resolvesDotSegments() throws IOException {
-        assertEquals("file:///outside", new File("file:///root/../outside").getCanonicalPath());
-        assertEquals("file:///a/c", new File("/a/./b/../c").getCanonicalPath());
-        assertEquals("file:///a/c", new File(new File("file:///a/b"), "../c").getCanonicalFile().getPath());
-        assertEquals("file:///", new File("/a/../..").getCanonicalPath());
-        assertEquals("file:///data/files/x", new File("file:///data/files/x").getCanonicalPath());
-    }
+/// The striping colors are those of SwingX, read from the real class.
+public class HighlighterFactoryParityTest {
 
     @Test
-    public void keepsAnAuthorityLessHome() throws IOException {
-        assertEquals("file://home/x", new File("file://home/files/../x").getCanonicalPath());
+    public void colorConstantsMatchSwingX() throws Exception {
+        Class<?> real = Class.forName("org.jdesktop.swingx.decorator.HighlighterFactory");
+        int checked = 0;
+        Field[] ours = HighlighterFactory.class.getFields();
+        for (int i = 0; i < ours.length; i++) {
+            Field f = ours[i];
+            if (!Modifier.isStatic(f.getModifiers()) || f.getType() != Color.class) {
+                continue;
+            }
+            Object theirs = real.getField(f.getName()).get(null);
+            int rgb = ((Integer) theirs.getClass().getMethod("getRGB").invoke(theirs)).intValue();
+            assertEquals(f.getName(), Integer.toHexString(rgb), Integer.toHexString(((Color) f.get(null)).getRGB()));
+            checked++;
+        }
+        assertTrue(checked >= 8);
     }
 }
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/HyperlinkTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/HyperlinkTest.java
new file mode 100644
index 00000000000..94304d18265
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/hyperlink/HyperlinkTest.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.hyperlink;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.javax.swing.AbstractAction;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXHyperlink;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/// The hyperlink and its actions: what a click fires and opens, and the
+/// color the link takes afterwards. Addresses go to a recording opener,
+/// never to a browser.
+public class HyperlinkTest extends KernelTestBase {
+
+    private final List<String> opened = new ArrayList<String>();
+
+    @Before
+    public void record() {
+        HyperlinkAction.setOpener(new UrlOpener() {
+            @Override
+            public void open(String url) {
+                opened.add(url);
+            }
+        });
+    }
+
+    @After
+    public void restore() {
+        HyperlinkAction.setOpener(null);
+    }
+
+    @Test
+    public void aClickOpensTheAddressAndMarksTheLinkVisited() {
+        JXHyperlink link = new JXHyperlink();
+        link.setURI(URI.create("http://example.com/a"));
+        assertEquals("http://example.com/a", link.getText());
+        assertTrue(link.isEnabled());
+        assertFalse(link.isClicked());
+        assertEquals(link.getUnclickedColor(), link.getForeground());
+        JFrame f = new JFrame();
+        f.add(link, BorderLayout.NORTH);
+        show(f);
+        assertNotNull(find(paint(f), "http://example.com/a"));
+        press(f, link, 5, 5);
+        release(f, link, 5, 5);
+        assertEquals("[http://example.com/a]", opened.toString());
+        assertTrue(link.isClicked());
+        assertEquals(link.getClickedColor(), link.getForeground());
+        assertTrue(link.getAction() instanceof HyperlinkAction);
+        assertTrue(((HyperlinkAction) link.getAction()).isVisited());
+    }
+
+    @Test
+    public void theLinkFollowsItsActionsVisitedFlagAndTarget() {
+        HyperlinkAction action = HyperlinkAction.createHyperlinkAction(URI.create("http://example.com/b"));
+        JXHyperlink link = new JXHyperlink(action);
+        assertFalse(link.isClicked());
+        action.setVisited(true);
+        assertTrue(link.isClicked());
+        action.setTarget(URI.create("mailto:someone@example.com"));
+        assertEquals("mailto:someone@example.com", link.getText());
+        assertFalse(action.isVisited());
+        assertFalse(link.isClicked());
+        action.actionPerformed(new ActionEvent(link, ActionEvent.ACTION_PERFORMED, null));
+        assertEquals("[mailto:someone@example.com]", opened.toString());
+        assertTrue(link.isClicked());
+    }
+
+    @Test
+    public void anActionWithoutATargetIsDisabledAndOpensNothing() {
+        HyperlinkAction action = new HyperlinkAction();
+        assertFalse(action.isEnabled());
+        action.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, null));
+        assertTrue(opened.isEmpty());
+        assertFalse(action.isVisited());
+        JXHyperlink link = new JXHyperlink();
+        link.setURI(null);
+        assertFalse(link.isEnabled());
+    }
+
+    @Test
+    public void aPlainActionIsFiredAndTheLinkMarksItselfClicked() {
+        final int[] fired = new int[1];
+        JXHyperlink link = new JXHyperlink(new AbstractAction("Go") {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                fired[0]++;
+            }
+        });
+        assertEquals("Go", link.getText());
+        JFrame f = new JFrame();
+        f.add(link, BorderLayout.NORTH);
+        show(f);
+        press(f, link, 5, 5);
+        release(f, link, 5, 5);
+        assertEquals(1, fired[0]);
+        assertTrue(link.isClicked());
+        assertTrue(opened.isEmpty());
+    }
+
+    @Test
+    public void theColorsFollowTheClickedState() {
+        JXHyperlink link = new JXHyperlink();
+        link.setUnclickedColor(Color.GREEN);
+        assertSame(Color.GREEN, link.getForeground());
+        link.setClickedColor(Color.RED);
+        assertSame(Color.GREEN, link.getForeground());
+        link.setClicked(true);
+        assertSame(Color.RED, link.getForeground());
+        link.setClicked(false);
+        assertSame(Color.GREEN, link.getForeground());
+    }
+
+    @Test
+    public void theExtendedActionKeepsItsValues() {
+        HyperlinkAction action = new HyperlinkAction();
+        action.setShortDescription("short");
+        assertEquals("short", action.getShortDescription());
+        assertEquals("short", action.getLongDescription());
+        action.setActionCommand("cmd");
+        assertEquals("cmd", action.getActionCommand());
+        action.setMnemonic("Open");
+        assertEquals('O', action.getMnemonic());
+        action.setGroup("g");
+        assertEquals("g", action.getGroup());
+        action.setStateAction(true);
+        assertFalse(action.isStateAction());
+        action.setSelected(true);
+        assertTrue(action.isSelected());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/PaintersTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/PaintersTest.java
new file mode 100644
index 00000000000..2583121f57c
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/PaintersTest.java
@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BasicStroke;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.GradientPaint;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Insets;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.RenderingHints;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.Ellipse2D;
+import com.codename1.desktopcompat.java.awt.geom.Line2D;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.geom.RoundRectangle2D;
+import com.codename1.desktopcompat.java.beans.PropertyChangeEvent;
+import com.codename1.desktopcompat.java.beans.PropertyChangeListener;
+import com.codename1.desktopcompat.javax.swing.JLabel;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The painters, drawing into a graphics that records what it is asked.
+public class PaintersTest extends KernelTestBase {
+
+    private static void box(Rectangle2D r, double x, double y, double w, double h) {
+        assertNotNull(r);
+        assertEquals(x, r.getX(), 0.01);
+        assertEquals(y, r.getY(), 0.01);
+        assertEquals(w, r.getWidth(), 0.01);
+        assertEquals(h, r.getHeight(), 0.01);
+    }
+
+    /// A painter that records its turn in a shared list.
+    private static final class Named implements Painter<Object> {
+        private final String name;
+        private final List<String> order;
+
+        Named(String name, List<String> order) {
+            this.name = name;
+            this.order = order;
+        }
+
+        @Override
+        public void paint(Graphics2D g, Object object, int width, int height) {
+            order.add(name + ":" + width + "x" + height);
+            g.translate(100, 100);
+            g.setColor(Color.PINK);
+        }
+    }
+
+    @Test
+    public void matteFillsTheWholeAreaWithItsPaint() {
+        RecordingGraphics g = new RecordingGraphics();
+        new MattePainter(Color.BLUE).paint(g, null, 40, 30);
+        assertEquals(1, g.ops.size());
+        RecordingGraphics.Op op = g.ops.get(0);
+        assertEquals("fill", op.kind);
+        assertEquals(Color.BLUE, op.color());
+        box(op.bounds, 0, 0, 40, 30);
+    }
+
+    @Test
+    public void stretchedGradientIsFittedToTheArea() {
+        RecordingGraphics g = new RecordingGraphics();
+        GradientPaint unit = new GradientPaint(0f, 0f, Color.RED, 1f, 0f, Color.GREEN);
+        new MattePainter(unit, true).paint(g, null, 200, 50);
+        assertTrue(g.ops.get(0).paint instanceof GradientPaint);
+        GradientPaint fitted = (GradientPaint) g.ops.get(0).paint;
+        assertEquals(0.0, fitted.getPoint1().getX(), 0.01);
+        assertEquals(200.0, fitted.getPoint2().getX(), 0.01);
+        assertEquals(Color.RED, fitted.getColor1());
+        assertEquals(Color.GREEN, fitted.getColor2());
+
+        RecordingGraphics plain = new RecordingGraphics();
+        new MattePainter(unit, false).paint(plain, null, 200, 50);
+        assertSame(unit, plain.ops.get(0).paint);
+    }
+
+    @Test
+    public void invisiblePainterAndEmptyAreaPaintNothing() {
+        RecordingGraphics g = new RecordingGraphics();
+        MattePainter p = new MattePainter(Color.BLUE);
+        p.paint(g, null, 0, 30);
+        p.paint(g, null, 30, 0);
+        p.setVisible(false);
+        p.paint(g, null, 30, 30);
+        assertTrue(g.ops.isEmpty());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void paintingWithoutGraphicsIsRefused() {
+        new MattePainter(Color.BLUE).paint(null, null, 10, 10);
+    }
+
+    @Test
+    public void antialiasingAndInterpolationBecomeRenderingHints() {
+        RecordingGraphics g = new RecordingGraphics();
+        MattePainter p = new MattePainter(Color.BLUE);
+        p.paint(g, null, 10, 10);
+        assertSame(RenderingHints.VALUE_ANTIALIAS_ON, g.getRenderingHint(RenderingHints.KEY_ANTIALIASING));
+        assertSame(RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR,
+                g.getRenderingHint(RenderingHints.KEY_INTERPOLATION));
+        p.setAntialiasing(false);
+        p.setInterpolation(AbstractPainter.Interpolation.Bilinear);
+        p.paint(g, null, 10, 10);
+        assertSame(RenderingHints.VALUE_ANTIALIAS_OFF, g.getRenderingHint(RenderingHints.KEY_ANTIALIASING));
+        assertSame(RenderingHints.VALUE_INTERPOLATION_BILINEAR,
+                g.getRenderingHint(RenderingHints.KEY_INTERPOLATION));
+    }
+
+    @Test
+    public void aChangedPropertyDirtiesThePainterUntilItPaints() {
+        MattePainter p = new MattePainter(Color.BLUE);
+        p.paint(new RecordingGraphics(), null, 10, 10);
+        assertFalse(p.isDirty());
+        final List<String> events = new ArrayList<String>();
+        p.addPropertyChangeListener(new PropertyChangeListener() {
+            @Override
+            public void propertyChange(PropertyChangeEvent e) {
+                events.add(e.getPropertyName() + "=" + e.getNewValue());
+            }
+        });
+        p.setFillPaint(Color.GREEN);
+        assertTrue(p.isDirty());
+        assertTrue(events.contains("dirty=true"));
+        assertTrue(events.toString(), events.contains("fillPaint=" + Color.GREEN));
+        p.paint(new RecordingGraphics(), null, 10, 10);
+        assertFalse(p.isDirty());
+        assertTrue(events.contains("dirty=false"));
+        assertFalse(p.shouldUseCache());
+    }
+
+    @Test
+    public void compoundPaintsInOrderEachOnAFreshCopy() {
+        List<String> order = new ArrayList<String>();
+        RecordingGraphics g = new RecordingGraphics();
+        CompoundPainter<Object> c = new CompoundPainter<Object>(new Named("a", order), null,
+                new Named("b", order), new MattePainter(Color.BLUE), new Named("c", order));
+        c.paint(g, null, 20, 10);
+        assertEquals("[a:20x10, b:20x10, c:20x10]", order.toString());
+        // The matte came after two painters that moved and recolored their
+        // own copies; it starts from the caller's state.
+        assertEquals(1, g.ops.size());
+        box(g.ops.get(0).bounds, 0, 0, 20, 10);
+        assertEquals(Color.BLUE, g.ops.get(0).color());
+        assertTrue(g.getTransform().isIdentity());
+    }
+
+    @Test
+    public void compoundLayersLaterPaintersOverEarlierOnes() {
+        RecordingGraphics g = new RecordingGraphics();
+        new CompoundPainter<Object>(new MattePainter(Color.RED), new MattePainter(Color.GREEN),
+                new MattePainter(Color.BLUE)).paint(g, null, 8, 8);
+        assertEquals(3, g.ops.size());
+        assertEquals(Color.RED, g.ops.get(0).color());
+        assertEquals(Color.GREEN, g.ops.get(1).color());
+        assertEquals(Color.BLUE, g.ops.get(2).color());
+    }
+
+    @Test
+    public void compoundTransformAppliesToEveryPainter() {
+        RecordingGraphics g = new RecordingGraphics();
+        CompoundPainter<Object> c = new CompoundPainter<Object>(new MattePainter(Color.RED));
+        c.setTransform(AffineTransform.getTranslateInstance(5, 7));
+        c.paint(g, null, 10, 10);
+        box(g.ops.get(0).bounds, 5, 7, 10, 10);
+    }
+
+    @Test
+    public void compoundIsDirtyWhileAChildIs() {
+        MattePainter child = new MattePainter(Color.RED);
+        CompoundPainter<Object> c = new CompoundPainter<Object>(child);
+        c.paint(new RecordingGraphics(), null, 10, 10);
+        assertFalse(c.isDirty());
+        child.setFillPaint(Color.BLUE);
+        assertTrue(c.isDirty());
+        c.setCheckingDirtyChildPainters(false);
+        assertFalse(c.isDirty());
+    }
+
+    @Test
+    public void alphaPainterMultipliesTheAlphaOfItsChildren() {
+        RecordingGraphics g = new RecordingGraphics();
+        AlphaPainter<Object> a = new AlphaPainter<Object>();
+        a.setPainters(new MattePainter(Color.RED));
+        a.setAlpha(0.5f);
+        a.paint(g, null, 10, 10);
+        assertEquals(0.5f, g.ops.get(0).alpha, 0.001f);
+        // Nested, the alphas multiply; the caller's composite is untouched.
+        AlphaPainter<Object> outer = new AlphaPainter<Object>();
+        outer.setPainters(a);
+        outer.setAlpha(0.5f);
+        outer.paint(g, null, 10, 10);
+        assertEquals(0.25f, g.ops.get(1).alpha, 0.001f);
+        a.setAlpha(0f);
+        a.paint(g, null, 10, 10);
+        assertEquals(2, g.ops.size());
+    }
+
+    @Test
+    public void rectangleFillsThenOutlinesInsideItsInsets() {
+        RecordingGraphics g = new RecordingGraphics();
+        RectanglePainter p = new RectanglePainter(Color.YELLOW, Color.BLACK);
+        p.setInsets(new Insets(2, 4, 6, 8));
+        p.setBorderWidth(1f);
+        p.paint(g, null, 100, 50);
+        assertEquals(2, g.ops.size());
+        assertEquals("fill", g.ops.get(0).kind);
+        assertEquals(Color.YELLOW, g.ops.get(0).color());
+        assertEquals("draw", g.ops.get(1).kind);
+        assertEquals(Color.BLACK, g.ops.get(1).color());
+        Rectangle2D r = g.ops.get(0).bounds;
+        assertTrue(r.getX() >= 4 && r.getY() >= 2);
+        assertTrue(r.getMaxX() <= 100 - 8 && r.getMaxY() <= 50 - 6);
+        assertTrue(g.ops.get(1).stroke instanceof BasicStroke);
+    }
+
+    @Test
+    public void rectangleStyleChoosesFillAndOutline() {
+        RectanglePainter p = new RectanglePainter(Color.YELLOW, Color.BLACK);
+        p.setStyle(AbstractAreaPainter.Style.FILLED);
+        RecordingGraphics g = new RecordingGraphics();
+        p.paint(g, null, 30, 30);
+        assertEquals(1, g.ops.size());
+        assertEquals("fill", g.ops.get(0).kind);
+        p.setStyle(AbstractAreaPainter.Style.OUTLINE);
+        g = new RecordingGraphics();
+        p.paint(g, null, 30, 30);
+        assertEquals(1, g.ops.size());
+        assertEquals("draw", g.ops.get(0).kind);
+        p.setStyle(AbstractAreaPainter.Style.NONE);
+        g = new RecordingGraphics();
+        p.paint(g, null, 30, 30);
+        assertTrue(g.ops.isEmpty());
+    }
+
+    @Test
+    public void roundedRectangleDrawsARoundRectangle() {
+        RectanglePainter p = new RectanglePainter(0, 0, 0, 0, 10, 10, true, Color.RED, 1f, Color.BLACK);
+        assertTrue(p.isRounded());
+        RecordingGraphics g = new RecordingGraphics();
+        p.paint(g, null, 30, 30);
+        assertTrue(g.ops.get(0).shape instanceof RoundRectangle2D);
+        p.setRounded(false);
+        g = new RecordingGraphics();
+        p.paint(g, null, 30, 30);
+        assertFalse(g.ops.get(0).shape instanceof RoundRectangle2D);
+    }
+
+    @Test
+    public void layoutPlacesContentByAlignmentAndInsets() {
+        RectanglePainter p = new RectanglePainter();
+        p.setFillHorizontal(false);
+        p.setFillVertical(false);
+        p.setInsets(new Insets(0, 0, 0, 0));
+        p.setHorizontalAlignment(AbstractLayoutPainter.HorizontalAlignment.RIGHT);
+        p.setVerticalAlignment(AbstractLayoutPainter.VerticalAlignment.BOTTOM);
+        assertEquals(new Rectangle(80, 40, 20, 10), p.calculateLayout(20, 10, 100, 50));
+        p.setHorizontalAlignment(AbstractLayoutPainter.HorizontalAlignment.CENTER);
+        p.setVerticalAlignment(AbstractLayoutPainter.VerticalAlignment.CENTER);
+        assertEquals(new Rectangle(40, 20, 20, 10), p.calculateLayout(20, 10, 100, 50));
+        p.setHorizontalAlignment(AbstractLayoutPainter.HorizontalAlignment.LEFT);
+        p.setVerticalAlignment(AbstractLayoutPainter.VerticalAlignment.TOP);
+        p.setInsets(new Insets(3, 5, 0, 0));
+        assertEquals(new Rectangle(5, 3, 20, 10), p.calculateLayout(20, 10, 100, 50));
+    }
+
+    @Test
+    public void textPainterDrawsItsTextCenteredInItsPaint() {
+        RecordingGraphics g = new RecordingGraphics();
+        TextPainter p = new TextPainter("Hello", Color.MAGENTA);
+        p.paint(g, null, 200, 100);
+        List<RecordingGraphics.Op> text = g.of("text");
+        assertEquals(1, text.size());
+        assertEquals("Hello", text.get(0).text);
+        assertEquals(Color.MAGENTA, text.get(0).color());
+        Rectangle2D r = text.get(0).bounds;
+        assertEquals(100.0, r.getCenterX(), 1.0);
+        assertEquals(50.0, r.getCenterY(), 1.0);
+        assertEquals(r.getBounds(), p.provideShape(g, null, 200, 100).getBounds());
+    }
+
+    @Test
+    public void textPainterWithoutTextUsesTheComponents() {
+        RecordingGraphics g = new RecordingGraphics();
+        JLabel label = new JLabel("From the label");
+        label.setForeground(Color.ORANGE);
+        TextPainter p = new TextPainter();
+        p.setFillPaint(null);
+        p.paint(g, label, 200, 100);
+        assertEquals("From the label", g.of("text").get(0).text);
+        assertEquals(Color.ORANGE, g.of("text").get(0).color());
+        p.setText(null);
+        assertEquals("", p.getText());
+        // Nothing to draw for a plain object.
+        g = new RecordingGraphics();
+        p.paint(g, "x", 200, 100);
+        assertTrue(g.ops.isEmpty());
+    }
+
+    @Test
+    public void shapePainterPlacesItsShapeAndPaintsFillThenBorder() {
+        RecordingGraphics g = new RecordingGraphics();
+        ShapePainter p = new ShapePainter(new Ellipse2D.Double(0, 0, 20, 10), Color.CYAN);
+        p.setBorderPaint(Color.BLACK);
+        p.setBorderWidth(2f);
+        p.paint(g, null, 100, 50);
+        assertEquals(2, g.ops.size());
+        assertEquals("fill", g.ops.get(0).kind);
+        assertEquals(Color.CYAN, g.ops.get(0).color());
+        assertEquals("draw", g.ops.get(1).kind);
+        // Centered, as the layout defaults say.
+        box(g.ops.get(0).bounds, 40, 20, 20, 10);
+    }
+
+    @Test
+    public void checkerboardFillsLightThenEveryOtherSquareDark() {
+        RecordingGraphics g = new RecordingGraphics();
+        CheckerboardPainter p = new CheckerboardPainter(Color.BLACK, Color.WHITE, 10);
+        p.paint(g, null, 40, 20);
+        assertEquals(Color.WHITE, g.ops.get(0).color());
+        box(g.ops.get(0).bounds, 0, 0, 40, 20);
+        // Two rows of four squares: four of the eight are dark.
+        assertEquals(5, g.ops.size());
+        for (int i = 1; i < g.ops.size(); i++) {
+            RecordingGraphics.Op op = g.ops.get(i);
+            assertEquals(Color.BLACK, op.color());
+            int column = (int) Math.round(op.bounds.getX() / 10);
+            int row = (int) Math.round(op.bounds.getY() / 10);
+            assertEquals("square " + column + "," + row, 1, (column + row) % 2);
+            assertEquals(10.0, op.bounds.getWidth(), 0.01);
+        }
+    }
+
+    @Test
+    public void pinstripesAreParallelLinesOfTheStripeWidthTurnedByTheAngle() {
+        RecordingGraphics g = new RecordingGraphics();
+        PinstripePainter p = new PinstripePainter(Color.GRAY, 0, 2, 8);
+        p.paint(g, null, 100, 100);
+        List<RecordingGraphics.Op> lines = g.of("draw");
+        assertTrue(lines.size() >= 10);
+        double last = Double.NaN;
+        for (int i = 0; i < lines.size(); i++) {
+            RecordingGraphics.Op op = lines.get(i);
+            assertTrue(op.shape instanceof Line2D);
+            assertEquals(Color.GRAY, op.color());
+            assertTrue(op.stroke instanceof BasicStroke);
+            assertEquals(2f, ((BasicStroke) op.stroke).getLineWidth(), 0.001f);
+            // Angle 0: vertical lines, ten pixels apart.
+            assertEquals(0.0, op.bounds.getWidth(), 0.01);
+            if (i > 0) {
+                assertEquals(10.0, op.bounds.getX() - last, 0.01);
+            }
+            last = op.bounds.getX();
+        }
+        // A quarter turn lays them flat.
+        g = new RecordingGraphics();
+        p.setAngle(90);
+        p.paint(g, null, 100, 100);
+        assertEquals(0.0, g.of("draw").get(0).bounds.getHeight(), 0.01);
+        assertTrue(g.of("draw").get(0).bounds.getWidth() > 100);
+    }
+
+    @Test
+    public void pinstripeAngleIsKeptWithinAFullTurn() {
+        PinstripePainter p = new PinstripePainter();
+        p.setAngle(400);
+        assertEquals(40.0, p.getAngle(), 0.001);
+        p.setAngle(-90);
+        assertEquals(270.0, p.getAngle(), 0.001);
+    }
+
+    @Test
+    public void glossCoversItsHalfOfTheArea() {
+        RecordingGraphics g = new RecordingGraphics();
+        GlossPainter p = new GlossPainter(Color.WHITE);
+        p.paint(g, null, 100, 40);
+        assertEquals(1, g.ops.size());
+        assertEquals(Color.WHITE, g.ops.get(0).color());
+        Rectangle2D top = g.ops.get(0).bounds;
+        assertTrue(top.getMaxY() <= 40.01 && top.getY() < 1);
+        assertTrue(top.getCenterY() < 20);
+        g = new RecordingGraphics();
+        p.setPosition(GlossPainter.GlossPosition.BOTTOM);
+        p.paint(g, null, 100, 40);
+        assertTrue(g.ops.get(0).bounds.getCenterY() > 20);
+        p.setPosition(null);
+        assertSame(GlossPainter.GlossPosition.TOP, p.getPosition());
+    }
+
+    @Test
+    public void imagePainterWithoutImagePaintsNothing() {
+        RecordingGraphics g = new RecordingGraphics();
+        ImagePainter p = new ImagePainter();
+        assertNull(p.getImage());
+        p.paint(g, null, 50, 50);
+        assertTrue(g.of("image").isEmpty());
+    }
+
+    @Test
+    public void busyPainterDrawsOnePointPerStopAllInTheBaseColorAtRest() {
+        RecordingGraphics g = new RecordingGraphics();
+        BusyPainter p = new BusyPainter(26);
+        p.setBaseColor(Color.LIGHT_GRAY);
+        p.setHighlightColor(Color.BLACK);
+        p.paint(g, null, 26, 26);
+        assertEquals(p.getPoints(), g.ops.size());
+        for (int i = 0; i < g.ops.size(); i++) {
+            assertEquals(Color.LIGHT_GRAY, g.ops.get(i).color());
+            Rectangle2D b = g.ops.get(i).bounds;
+            assertTrue("point " + i + " at " + b, b.getX() > -2 && b.getMaxX() < 28);
+            assertTrue("point " + i + " at " + b, b.getY() > -2 && b.getMaxY() < 28);
+        }
+        assertEquals(-1, p.cn1HighlightedPoint());
+    }
+
+    @Test
+    public void busyPainterHighlightFollowsTheFrameAndFadesBehindIt() {
+        BusyPainter p = new BusyPainter(26);
+        p.setBaseColor(Color.WHITE);
+        p.setHighlightColor(Color.BLACK);
+        p.setPoints(8);
+        p.setTrailLength(4);
+        p.setFrame(3);
+        assertEquals(3, p.cn1HighlightedPoint());
+        assertEquals(Color.BLACK, p.cn1PointColor(3));
+        // Behind the highlight the points fade to the base color.
+        int one = p.cn1PointColor(2).getRed();
+        int two = p.cn1PointColor(1).getRed();
+        assertTrue(one > 0 && one < 255);
+        assertTrue(two > one);
+        assertEquals(Color.WHITE, p.cn1PointColor(4));
+        assertEquals(Color.WHITE, p.cn1PointColor(7));
+        // The frame wraps around the points.
+        p.setFrame(11);
+        assertEquals(3, p.cn1HighlightedPoint());
+
+        RecordingGraphics g = new RecordingGraphics();
+        p.paint(g, null, 26, 26);
+        assertEquals(8, g.ops.size());
+        assertEquals(Color.BLACK, g.ops.get(3).color());
+    }
+
+    @Test
+    public void busyPainterTurnsTheOtherWayToTheLeft() {
+        BusyPainter p = new BusyPainter(26);
+        p.setBaseColor(Color.WHITE);
+        p.setHighlightColor(Color.BLACK);
+        p.setPoints(8);
+        p.setTrailLength(4);
+        p.setDirection(BusyPainter.Direction.LEFT);
+        p.setFrame(0);
+        assertEquals(7, p.cn1HighlightedPoint());
+        p.setFrame(1);
+        assertEquals(6, p.cn1HighlightedPoint());
+        // The trail is now on the other side.
+        assertTrue(p.cn1PointColor(7).getRed() < 255);
+        assertEquals(Color.WHITE, p.cn1PointColor(5));
+    }
+
+    @Test
+    public void busyPainterSpreadsPointsAlongAnOpenTrajectoryEndToEnd() {
+        BusyPainter p = new BusyPainter(new Rectangle2D.Double(0, 0, 2, 2), new Line2D.Double(0, 5, 30, 5));
+        p.setPoints(4);
+        p.setPaintCentered(false);
+        RecordingGraphics g = new RecordingGraphics();
+        p.paint(g, null, 40, 10);
+        assertEquals(4, g.ops.size());
+        for (int i = 0; i < 4; i++) {
+            assertEquals(i * 10.0, g.ops.get(i).bounds.getCenterX(), 0.01);
+            assertEquals(5.0, g.ops.get(i).bounds.getCenterY(), 0.01);
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/RecordingGraphics.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/RecordingGraphics.java
new file mode 100644
index 00000000000..4bb41689ee9
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/painter/RecordingGraphics.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.painter;
+
+import com.codename1.desktopcompat.java.awt.AlphaComposite;
+import com.codename1.desktopcompat.java.awt.BasicStroke;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Composite;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.FontMetrics;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.Graphics2D;
+import com.codename1.desktopcompat.java.awt.Image;
+import com.codename1.desktopcompat.java.awt.Paint;
+import com.codename1.desktopcompat.java.awt.Rectangle;
+import com.codename1.desktopcompat.java.awt.RenderingHints;
+import com.codename1.desktopcompat.java.awt.Shape;
+import com.codename1.desktopcompat.java.awt.Stroke;
+import com.codename1.desktopcompat.java.awt.geom.AffineTransform;
+import com.codename1.desktopcompat.java.awt.geom.Point2D;
+import com.codename1.desktopcompat.java.awt.geom.Rectangle2D;
+import com.codename1.desktopcompat.java.awt.image.ImageObserver;
+import com.codename1.desktopcompat.rt.Fonts;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// A graphics that draws nothing and remembers what it was asked to draw:
+/// every operation with the paint, alpha, stroke and transform it was
+/// drawn under. Copies made with `create()` write to the same list.
+public class RecordingGraphics extends Graphics2D {
+
+    /// One drawing operation.
+    public static final class Op {
+        /// `fill`, `draw`, `text` or `image`.
+        public final String kind;
+        /// The shape filled or drawn, in the user space of the moment.
+        public final Shape shape;
+        public final String text;
+        public final Paint paint;
+        public final float alpha;
+        public final Stroke stroke;
+        public final AffineTransform transform;
+        /// The bounds of the operation on the device: the shape's, through
+        /// the transform.
+        public final Rectangle2D bounds;
+
+        Op(String kind, Shape shape, String text, RecordingGraphics g) {
+            this.kind = kind;
+            this.shape = shape;
+            this.text = text;
+            this.paint = g.paint;
+            this.alpha = g.composite instanceof AlphaComposite ? ((AlphaComposite) g.composite).getAlpha() : 1f;
+            this.stroke = g.stroke;
+            this.transform = new AffineTransform(g.transform);
+            this.bounds = shape == null ? null : g.transform.createTransformedShape(shape).getBounds2D();
+        }
+
+        /// The color of the operation, or `null` for another paint.
+        public Color color() {
+            return paint instanceof Color ? (Color) paint : null;
+        }
+    }
+
+    public final List<Op> ops;
+    private final Map<Object, Object> hints;
+    private Paint paint = Color.BLACK;
+    private Color background = Color.WHITE;
+    private Composite composite = AlphaComposite.SrcOver;
+    private Stroke stroke = new BasicStroke();
+    private Font font = Fonts.defaultFont();
+    private AffineTransform transform = new AffineTransform();
+    private Shape clip;
+
+    public RecordingGraphics() {
+        ops = new ArrayList<Op>();
+        hints = new HashMap<Object, Object>();
+    }
+
+    private RecordingGraphics(RecordingGraphics from) {
+        ops = from.ops;
+        hints = new HashMap<Object, Object>(from.hints);
+        paint = from.paint;
+        background = from.background;
+        composite = from.composite;
+        stroke = from.stroke;
+        font = from.font;
+        transform = new AffineTransform(from.transform);
+        clip = from.clip;
+    }
+
+    /// The operations of one kind, in the order they were made.
+    public List<Op> of(String kind) {
+        List<Op> out = new ArrayList<Op>();
+        for (int i = 0; i < ops.size(); i++) {
+            if (ops.get(i).kind.equals(kind)) {
+                out.add(ops.get(i));
+            }
+        }
+        return out;
+    }
+
+    private void record(String kind, Shape s, String text) {
+        ops.add(new Op(kind, s, text, this));
+    }
+
+    @Override
+    public Graphics create() {
+        return new RecordingGraphics(this);
+    }
+
+    @Override
+    public void dispose() {
+    }
+
+    @Override
+    public void draw(Shape s) {
+        record("draw", s, null);
+    }
+
+    @Override
+    public void fill(Shape s) {
+        record("fill", s, null);
+    }
+
+    @Override
+    public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs) {
+        record("image", null, null);
+        return true;
+    }
+
+    @Override
+    public void drawString(String str, int x, int y) {
+        FontMetrics fm = getFontMetrics(font);
+        record("text", new Rectangle(x, y - fm.getAscent(), fm.stringWidth(str), fm.getHeight()), str);
+    }
+
+    @Override
+    public void drawString(String str, float x, float y) {
+        drawString(str, (int) x, (int) y);
+    }
+
+    @Override
+    public void setComposite(Composite comp) {
+        composite = comp;
+    }
+
+    @Override
+    public void setPaint(Paint p) {
+        if (p != null) {
+            paint = p;
+        }
+    }
+
+    @Override
+    public void setStroke(Stroke s) {
+        stroke = s;
+    }
+
+    @Override
+    public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue) {
+        hints.put(hintKey, hintValue);
+    }
+
+    @Override
+    public Object getRenderingHint(RenderingHints.Key hintKey) {
+        return hints.get(hintKey);
+    }
+
+    @Override
+    public void setRenderingHints(Map<?, ?> h) {
+        hints.clear();
+        hints.putAll(h);
+    }
+
+    @Override
+    public void addRenderingHints(Map<?, ?> h) {
+        hints.putAll(h);
+    }
+
+    @Override
+    public RenderingHints getRenderingHints() {
+        return null;
+    }
+
+    @Override
+    public void translate(int x, int y) {
+        transform.translate(x, y);
+    }
+
+    @Override
+    public void translate(double tx, double ty) {
+        transform.translate(tx, ty);
+    }
+
+    @Override
+    public void rotate(double theta) {
+        transform.rotate(theta);
+    }
+
+    @Override
+    public void rotate(double theta, double x, double y) {
+        transform.rotate(theta, x, y);
+    }
+
+    @Override
+    public void scale(double sx, double sy) {
+        transform.scale(sx, sy);
+    }
+
+    @Override
+    public void shear(double shx, double shy) {
+        transform.shear(shx, shy);
+    }
+
+    @Override
+    public void transform(AffineTransform tx) {
+        transform.concatenate(tx);
+    }
+
+    @Override
+    public void setTransform(AffineTransform tx) {
+        transform = tx == null ? new AffineTransform() : new AffineTransform(tx);
+    }
+
+    @Override
+    public AffineTransform getTransform() {
+        return new AffineTransform(transform);
+    }
+
+    @Override
+    public Paint getPaint() {
+        return paint;
+    }
+
+    @Override
+    public Composite getComposite() {
+        return composite;
+    }
+
+    @Override
+    public void setBackground(Color color) {
+        background = color;
+    }
+
+    @Override
+    public Color getBackground() {
+        return background;
+    }
+
+    @Override
+    public Stroke getStroke() {
+        return stroke;
+    }
+
+    @Override
+    public void clip(Shape s) {
+        clip = s;
+    }
+
+    @Override
+    public Color getColor() {
+        return paint instanceof Color ? (Color) paint : Color.BLACK;
+    }
+
+    @Override
+    public void setColor(Color c) {
+        if (c != null) {
+            paint = c;
+        }
+    }
+
+    @Override
+    public void setPaintMode() {
+    }
+
+    @Override
+    public void setXORMode(Color c1) {
+    }
+
+    @Override
+    public Font getFont() {
+        return font;
+    }
+
+    @Override
+    public void setFont(Font f) {
+        if (f != null) {
+            font = f;
+        }
+    }
+
+    @Override
+    public FontMetrics getFontMetrics(Font f) {
+        return Fonts.metrics(f);
+    }
+
+    @Override
+    public Rectangle getClipBounds() {
+        return clip == null ? null : clip.getBounds();
+    }
+
+    @Override
+    public void clipRect(int x, int y, int width, int height) {
+        clip = new Rectangle(x, y, width, height);
+    }
+
+    @Override
+    public void setClip(int x, int y, int width, int height) {
+        clip = new Rectangle(x, y, width, height);
+    }
+
+    @Override
+    public Shape getClip() {
+        return clip;
+    }
+
+    @Override
+    public void setClip(Shape c) {
+        clip = c;
+    }
+
+    @Override
+    public void copyArea(int x, int y, int width, int height, int dx, int dy) {
+    }
+
+    @Override
+    public void drawLine(int x1, int y1, int x2, int y2) {
+        record("draw", new Rectangle(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1)),
+                null);
+    }
+
+    @Override
+    public void fillRect(int x, int y, int width, int height) {
+        record("fill", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void clearRect(int x, int y, int width, int height) {
+    }
+
+    @Override
+    public void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
+        record("draw", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) {
+        record("fill", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void drawOval(int x, int y, int width, int height) {
+        record("draw", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void fillOval(int x, int y, int width, int height) {
+        record("fill", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
+        record("draw", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) {
+        record("fill", new Rectangle(x, y, width, height), null);
+    }
+
+    @Override
+    public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) {
+        record("draw", null, null);
+    }
+
+    @Override
+    public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) {
+        record("draw", null, null);
+    }
+
+    @Override
+    public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints) {
+        record("fill", null, null);
+    }
+
+    private boolean image(int x, int y, int w, int h) {
+        record("image", new Rectangle(x, y, w, h), null);
+        return true;
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
+        return image(x, y, img.getWidth(null), img.getHeight(null));
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer) {
+        return image(x, y, width, height);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer) {
+        return image(x, y, img.getWidth(null), img.getHeight(null));
+    }
+
+    @Override
+    public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor,
+                             ImageObserver observer) {
+        return image(x, y, width, height);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2,
+                             int sy2, ImageObserver observer) {
+        return image(dx1, dy1, dx2 - dx1, dy2 - dy1);
+    }
+
+    @Override
+    public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2,
+                             int sy2, Color bgcolor, ImageObserver observer) {
+        return image(dx1, dy1, dx2 - dx1, dy2 - dy1);
+    }
+
+    /// The device position of a user-space point under the current
+    /// transform.
+    public Point2D onDevice(double x, double y) {
+        return transform.transform(new Point2D.Double(x, y), null);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/PromptSupportTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/PromptSupportTest.java
new file mode 100644
index 00000000000..26f77fe3b84
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/prompt/PromptSupportTest.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.prompt;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.event.ActionEvent;
+import com.codename1.desktopcompat.java.awt.event.ActionListener;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JTextField;
+import com.codename1.desktopcompat.javax.swing.text.JTextComponent;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXFormattedTextField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXSearchField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXSearchField.SearchMode;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTextArea;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTextField;
+import com.codename1.desktopcompat.org.jdesktop.swingx.prompt.PromptSupport.FocusBehavior;
+import com.codename1.ui.TextArea;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+
+/// Prompts: the text handed to [PromptSupport] becomes the hint of the
+/// Codename One text field behind the component.
+public class PromptSupportTest extends KernelTestBase {
+
+    private static String hint(JTextComponent c) {
+        return ((TextArea) c.cn1Peer()).getHint();
+    }
+
+    private JFrame open(JTextComponent c) {
+        JFrame f = new JFrame();
+        f.add(c, BorderLayout.NORTH);
+        return show(f);
+    }
+
+    @Test
+    public void aPromptBecomesTheHintOfAPlainTextField() {
+        JTextField field = new JTextField(10);
+        assertNull(PromptSupport.getPrompt(field));
+        PromptSupport.setPrompt("Name", field);
+        assertEquals("Name", PromptSupport.getPrompt(field));
+        assertEquals("Name", field.getClientProperty(PromptSupport.PROMPT));
+        open(field);
+        assertEquals("Name", hint(field));
+        assertEquals("the prompt is not the text", "", field.getText());
+
+        PromptSupport.setPrompt("Surname", field);
+        assertEquals("Surname", hint(field));
+        PromptSupport.setPrompt(null, field);
+        assertNull(PromptSupport.getPrompt(field));
+        assertEquals("", hint(field));
+    }
+
+    @Test
+    public void theColorAndTheStyleReachTheHint() {
+        JTextField field = new JTextField(10);
+        open(field);
+        PromptSupport.init("Find", new Color(0x336699), new Color(0xfff0f0), field);
+        assertEquals("Find", hint(field));
+        assertEquals(new Color(0x336699), PromptSupport.getForeground(field));
+        assertEquals(new Color(0xfff0f0), PromptSupport.getBackground(field));
+        TextArea peer = (TextArea) field.cn1Peer();
+        assertNotNull(peer.getHintLabel());
+        assertEquals(0x336699, peer.getHintLabel().getUnselectedStyle().getFgColor());
+
+        assertNull(PromptSupport.getFontStyle(field));
+        PromptSupport.setFontStyle(Integer.valueOf(Font.ITALIC), field);
+        assertEquals(Integer.valueOf(Font.ITALIC), PromptSupport.getFontStyle(field));
+        assertEquals("Find", hint(field));
+
+        assertSame(FocusBehavior.HIDE_PROMPT, PromptSupport.getFocusBehavior(field));
+        PromptSupport.setFocusBehavior(FocusBehavior.SHOW_PROMPT, field);
+        assertSame(FocusBehavior.SHOW_PROMPT, PromptSupport.getFocusBehavior(field));
+    }
+
+    @Test
+    public void thePromptFieldsCarryTheirPrompt() {
+        JXTextField field = new JXTextField("City", new Color(0x808080));
+        assertEquals("City", field.getPrompt());
+        assertEquals(new Color(0x808080), field.getPromptForeground());
+        open(field);
+        assertEquals("City", hint(field));
+        field.setPrompt("Town");
+        assertEquals("Town", PromptSupport.getPrompt(field));
+        assertEquals("Town", hint(field));
+        field.setPromptFontStyle(Integer.valueOf(Font.BOLD));
+        assertEquals(Integer.valueOf(Font.BOLD), field.getPromptFontStyle());
+        field.setFocusBehavior(FocusBehavior.HIGHLIGHT_PROMPT);
+        assertSame(FocusBehavior.HIGHLIGHT_PROMPT, field.getFocusBehavior());
+
+        JXTextArea area = new JXTextArea("Notes");
+        open(area);
+        assertEquals("Notes", hint(area));
+        area.setPrompt("Remarks");
+        assertEquals("Remarks", hint(area));
+
+        JXFormattedTextField formatted = new JXFormattedTextField("Amount");
+        open(formatted);
+        assertEquals("Amount", hint(formatted));
+    }
+
+    @Test
+    public void theSearchFieldTellsItsListenersWhenToSearch() {
+        JXSearchField search = new JXSearchField();
+        assertEquals("Search", search.getPrompt());
+        assertSame(SearchMode.INSTANT, search.getSearchMode());
+        assertTrue(search.isInstantSearchMode());
+        final List<String> searched = new ArrayList<String>();
+        final JXSearchField field = search;
+        search.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                searched.add(field.getText());
+            }
+        });
+        open(search);
+        assertEquals("Search", hint(search));
+
+        // Without a delay every change searches at once.
+        search.setInstantSearchDelay(0);
+        assertEquals(0, search.getInstantSearchDelay());
+        search.setText("ab");
+        assertFalse(searched.isEmpty());
+        assertEquals("ab", searched.get(searched.size() - 1));
+
+        // With one the timer is started instead.
+        searched.clear();
+        search.setInstantSearchDelay(60000);
+        search.setText("abc");
+        assertTrue(searched.isEmpty());
+        assertTrue(search.getInstantSearchTimer().isRunning());
+        assertFalse(search.getInstantSearchTimer().isRepeats());
+        // Searching now stops the wait.
+        search.postActionEvent();
+        assertEquals(1, searched.size());
+        assertEquals("abc", searched.get(0));
+        assertFalse(search.getInstantSearchTimer().isRunning());
+
+        // The regular mode waits for the edit to finish.
+        searched.clear();
+        search.setSearchMode(SearchMode.REGULAR);
+        assertTrue(search.isRegularSearchMode());
+        search.setText("abcd");
+        assertTrue(searched.isEmpty());
+        assertFalse(search.getInstantSearchTimer().isRunning());
+
+        // The cancel action a field starts with clears the text.
+        search.getCancelAction().actionPerformed(new ActionEvent(search, ActionEvent.ACTION_PERFORMED, "cancel"));
+        assertEquals("", search.getText());
+        final int[] cancelled = {0};
+        ActionListener own = new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                cancelled[0]++;
+            }
+        };
+        search.setCancelAction(own);
+        assertSame(own, search.getCancelAction());
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnControlButtonTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnControlButtonTest.java
new file mode 100644
index 00000000000..152364f5c90
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/table/ColumnControlButtonTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.table;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.BorderLayout;
+import com.codename1.desktopcompat.java.awt.Component;
+import com.codename1.desktopcompat.javax.swing.JCheckBoxMenuItem;
+import com.codename1.desktopcompat.javax.swing.JFrame;
+import com.codename1.desktopcompat.javax.swing.JMenuItem;
+import com.codename1.desktopcompat.javax.swing.JPopupMenu;
+import com.codename1.desktopcompat.javax.swing.JScrollPane;
+import com.codename1.desktopcompat.javax.swing.ScrollPaneConstants;
+import com.codename1.desktopcompat.javax.swing.table.DefaultTableModel;
+import com.codename1.desktopcompat.org.jdesktop.swingx.JXTable;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/// The column control: its menu shows and hides columns.
+public class ColumnControlButtonTest extends KernelTestBase {
+
+    private static JXTable table() {
+        return new JXTable(new DefaultTableModel(new Object[][]{{"a", "b", "c"}}, new Object[]{"One", "Two",
+            "Three"}));
+    }
+
+    private static JMenuItem item(JPopupMenu menu, String text) {
+        for (int i = 0; i < menu.getComponentCount(); i++) {
+            Component c = menu.getComponent(i);
+            if (c instanceof JMenuItem && text.equals(((JMenuItem) c).getText())) {
+                return (JMenuItem) c;
+            }
+        }
+        return null;
+    }
+
+    @Test
+    public void theMenuHidesAndShowsColumns() {
+        JXTable t = table();
+        assertTrue(t.getColumnControl() instanceof ColumnControlButton);
+        ColumnControlButton b = (ColumnControlButton) t.getColumnControl();
+        JPopupMenu menu = b.cn1BuildPopup();
+        JMenuItem two = item(menu, "Two");
+        assertTrue(two instanceof JCheckBoxMenuItem);
+        assertTrue(((JCheckBoxMenuItem) two).getState());
+        two.doClick();
+        assertEquals(2, t.getColumnCount());
+        assertFalse(t.getColumnExt("Two").isVisible());
+
+        menu = b.cn1BuildPopup();
+        two = item(menu, "Two");
+        assertFalse("a hidden column is still in the menu", ((JCheckBoxMenuItem) two).getState());
+        two.doClick();
+        assertEquals(3, t.getColumnCount());
+        assertEquals("Two", t.getColumnName(1));
+
+        t.getColumnExt("Three").setHideable(false);
+        menu = b.cn1BuildPopup();
+        assertSame(null, item(menu, "Three"));
+        item(menu, "One").doClick();
+        item(menu, "Two").doClick();
+        assertEquals("the last visible column stays", 1, t.getColumnCount());
+
+        item(menu, "Horizontal Scroll").doClick();
+        assertTrue(t.isHorizontalScrollEnabled());
+        b.setAdditionalActionsVisible(false);
+        assertSame(null, item(b.cn1BuildPopup(), "Pack All Columns"));
+    }
+
+    @Test
+    public void theButtonOpensAndClosesItsMenuAndIsTheScrollPanesCorner() {
+        JXTable t = table();
+        JScrollPane pane = new JScrollPane(t);
+        JFrame f = new JFrame();
+        f.add(pane, BorderLayout.CENTER);
+        f.add(t.getColumnControl(), BorderLayout.NORTH);
+        show(f);
+        t.setColumnControlVisible(true);
+        assertTrue(t.isColumnControlVisible());
+        assertSame(t.getColumnControl(), pane.getCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER));
+        t.setColumnControlVisible(false);
+        assertSame(null, pane.getCorner(ScrollPaneConstants.UPPER_TRAILING_CORNER));
+        ColumnControlButton b = (ColumnControlButton) t.getColumnControl();
+        b.togglePopup();
+        b.togglePopup();
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableModelTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableModelTest.java
new file mode 100644
index 00000000000..5f0424cfccc
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/org/jdesktop/swingx/treetable/TreeTableModelTest.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.org.jdesktop.swingx.treetable;
+
+import com.codename1.desktopcompat.javax.swing.event.TreeModelEvent;
+import com.codename1.desktopcompat.javax.swing.event.TreeModelListener;
+import com.codename1.desktopcompat.javax.swing.tree.TreePath;
+import com.codename1.desktopcompat.org.jdesktop.swingx.tree.TreeModelSupport;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/// The tree table nodes and models, held to what SwingX does with the
+/// same calls.
+public class TreeTableModelTest {
+
+    private static final class Log implements TreeModelListener {
+        final List<String> heard = new ArrayList<String>();
+
+        private void add(String kind, TreeModelEvent e) {
+            heard.add(kind + " " + e.getTreePath() + " " + Arrays.toString(e.getChildIndices()) + " "
+                    + Arrays.toString(e.getChildren()));
+        }
+
+        @Override
+        public void treeNodesChanged(TreeModelEvent e) {
+            add("changed", e);
+        }
+
+        @Override
+        public void treeNodesInserted(TreeModelEvent e) {
+            add("inserted", e);
+        }
+
+        @Override
+        public void treeNodesRemoved(TreeModelEvent e) {
+            add("removed", e);
+        }
+
+        @Override
+        public void treeStructureChanged(TreeModelEvent e) {
+            add("structure", e);
+        }
+
+        String last() {
+            return heard.get(heard.size() - 1);
+        }
+    }
+
+    private static String kids(DefaultMutableTreeTableNode n) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < n.getChildCount(); i++) {
+            sb.append(n.getChildAt(i)).append(' ');
+        }
+        return sb.toString().trim();
+    }
+
+    private static DefaultMutableTreeTableNode three(DefaultMutableTreeTableNode[] c) {
+        DefaultMutableTreeTableNode p = new DefaultMutableTreeTableNode("p");
+        for (int i = 0; i < 3; i++) {
+            c[i] = new DefaultMutableTreeTableNode("c" + i);
+            p.add(c[i]);
+        }
+        return p;
+    }
+
+    @Test
+    public void aNodeKeepsBothSidesOfAMove() {
+        DefaultMutableTreeTableNode p1 = new DefaultMutableTreeTableNode("p1");
+        DefaultMutableTreeTableNode p2 = new DefaultMutableTreeTableNode("p2");
+        DefaultMutableTreeTableNode c = new DefaultMutableTreeTableNode("c");
+        p1.add(c);
+        assertSame(p1, c.getParent());
+        p2.add(c);
+        assertEquals(0, p1.getChildCount());
+        assertEquals(1, p2.getChildCount());
+        assertSame(p2, c.getParent());
+        c.setParent(p1);
+        assertEquals("c", kids(p1));
+        assertEquals("", kids(p2));
+        c.setParent(null);
+        assertEquals(0, p1.getChildCount());
+        assertNull(c.getParent());
+        p1.add(c);
+        c.removeFromParent();
+        assertEquals(0, p1.getChildCount());
+        assertNull(c.getParent());
+        p1.add(c);
+        p2.remove(c);
+        assertEquals("removing takes the node from the parent it has", 0, p1.getChildCount());
+        assertNull(c.getParent());
+        assertEquals(-1, p1.getIndex(c));
+        assertEquals(-1, p1.getIndex(null));
+    }
+
+    @Test
+    public void insertingAChildAgainMovesItAndCountsWithoutIt() {
+        DefaultMutableTreeTableNode[] c = new DefaultMutableTreeTableNode[3];
+        DefaultMutableTreeTableNode p = three(c);
+        p.insert(c[0], 2);
+        assertEquals("c1 c0 c2", kids(p));
+        p = three(c);
+        p.insert(c[0], 3);
+        assertEquals("c1 c2 c0", kids(p));
+        p = three(c);
+        p.insert(c[2], 1);
+        assertEquals("c2 c0 c1", kids(p));
+        p = three(c);
+        p.add(c[0]);
+        assertEquals("c1 c2 c0", kids(p));
+        p = three(c);
+        try {
+            p.insert(c[1], 0);
+            fail("index 0 counts as -1 once the child is out");
+        } catch (IndexOutOfBoundsException expected) {
+            assertEquals(2, p.getChildCount());
+        }
+    }
+
+    @Test
+    public void aNodeThatTakesNoChildrenRefusesThem() {
+        DefaultMutableTreeTableNode closed = new DefaultMutableTreeTableNode("x", false);
+        DefaultMutableTreeTableNode c = new DefaultMutableTreeTableNode("c");
+        try {
+            closed.add(c);
+            fail();
+        } catch (IllegalStateException expected) {
+            assertEquals("this node cannot accept children", expected.getMessage());
+        }
+        try {
+            c.setParent(closed);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("newParent does not allow children", expected.getMessage());
+        }
+        assertNull(c.getParent());
+        DefaultMutableTreeTableNode p = new DefaultMutableTreeTableNode("p");
+        p.add(c);
+        p.setAllowsChildren(false);
+        assertEquals(0, p.getChildCount());
+        assertTrue(p.isLeaf());
+        assertFalse(p.getAllowsChildren());
+    }
+
+    @Test
+    public void theDefaultNodeIsItsUserObjectInOneEditableColumn() {
+        DefaultMutableTreeTableNode n = new DefaultMutableTreeTableNode("u");
+        assertEquals(1, n.getColumnCount());
+        assertEquals("u", n.getValueAt(0));
+        assertEquals("u", n.getValueAt(3));
+        assertTrue(n.isEditable(0));
+        n.setValueAt("v", 0);
+        assertEquals("v", n.getUserObject());
+        assertEquals("v", n.toString());
+        assertEquals("", new DefaultMutableTreeTableNode().toString());
+        assertTrue(n.isLeaf());
+        assertTrue(n.getAllowsChildren());
+        AbstractMutableTreeTableNode plain = new AbstractMutableTreeTableNode("plain") {
+            @Override
+            public Object getValueAt(int column) {
+                return "v" + column;
+            }
+
+            @Override
+            public int getColumnCount() {
+                return 2;
+            }
+        };
+        assertFalse(plain.isEditable(0));
+        plain.setValueAt("z", 0);
+        assertEquals("plain", plain.getUserObject());
+        assertTrue(plain.children().hasMoreElements() == false);
+    }
+
+    @Test
+    public void theDefaultModelAnswersForItsNodesOnly() {
+        DefaultMutableTreeTableNode root = new DefaultMutableTreeTableNode("root");
+        DefaultMutableTreeTableNode f1 = new DefaultMutableTreeTableNode("f1");
+        DefaultMutableTreeTableNode l1 = new DefaultMutableTreeTableNode("l1");
+        root.add(f1);
+        f1.add(l1);
+        DefaultTreeTableModel m = new DefaultTreeTableModel(root, Arrays.asList("Name", "Size"));
+        assertSame(root, m.getRoot());
+        assertEquals(2, m.getColumnCount());
+        assertEquals("Name", m.getColumnName(0));
+        assertEquals("F", m.getColumnName(5));
+        assertEquals(Object.class, m.getColumnClass(0));
+        assertEquals(0, m.getHierarchicalColumn());
+        assertEquals("f1", m.getValueAt(f1, 0));
+        assertNull("the node has one column", m.getValueAt(f1, 1));
+        assertTrue(m.isCellEditable(f1, 0));
+        assertFalse(m.isCellEditable(f1, 1));
+        assertFalse(m.isLeaf(f1));
+        assertTrue(m.isLeaf(l1));
+        assertSame(f1, m.getChild(root, 0));
+        assertEquals(1, m.getChildCount(f1));
+        assertEquals(0, m.getIndexOfChild(f1, l1));
+        assertEquals(-1, m.getIndexOfChild("zz", l1));
+        assertEquals(Arrays.asList(root, f1, l1), Arrays.asList(m.getPathToRoot(l1)));
+        DefaultMutableTreeTableNode orphan = new DefaultMutableTreeTableNode("o");
+        try {
+            m.getValueAt(orphan, 0);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("node must be a valid node managed by this model", expected.getMessage());
+        }
+        try {
+            m.getValueAt(f1, 9);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("column must be a valid index", expected.getMessage());
+        }
+        try {
+            m.isLeaf("zz");
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("node must be a TreeTableNode managed by this model", expected.getMessage());
+        }
+        try {
+            m.getChildCount(orphan);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("parent must be a TreeTableNode managed by this model", expected.getMessage());
+        }
+        try {
+            m.removeNodeFromParent(orphan);
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("node does not have a parent.", expected.getMessage());
+        }
+        try {
+            m.valueForPathChanged(new TreePath(orphan), "x");
+            fail();
+        } catch (IllegalArgumentException expected) {
+            assertEquals("invalid path", expected.getMessage());
+        }
+        assertEquals(0, new DefaultTreeTableModel().getColumnCount());
+        assertNull(new DefaultTreeTableModel().getRoot());
+        assertEquals(-1, new DefaultTreeTableModel().getHierarchicalColumn());
+        DefaultTreeTableModel unnamed = new DefaultTreeTableModel(root);
+        assertEquals(1, unnamed.getColumnCount());
+        assertEquals("A", unnamed.getColumnName(0));
+        assertEquals("AB", unnamed.getColumnName(27));
+    }
+
+    @Test
+    public void theDefaultModelTellsItsListeners() {
+        DefaultMutableTreeTableNode root = new DefaultMutableTreeTableNode("root");
+        DefaultMutableTreeTableNode f1 = new DefaultMutableTreeTableNode("f1");
+        root.add(f1);
+        DefaultTreeTableModel m = new DefaultTreeTableModel(root, Arrays.asList("Name", "Size"));
+        Log log = new Log();
+        m.addTreeModelListener(log);
+        assertEquals(1, m.getTreeModelListeners().length);
+        DefaultMutableTreeTableNode x = new DefaultMutableTreeTableNode("x");
+        m.insertNodeInto(x, f1, 0);
+        assertEquals("inserted [root, f1] [0] [x]", log.last());
+        m.setValueAt("x2", x, 0);
+        assertEquals("changed [root, f1] [0] [x2]", log.last());
+        int before = log.heard.size();
+        m.setValueAt("q", x, 1);
+        assertEquals("nothing in a column the node does not have", before, log.heard.size());
+        m.setUserObject(x, "x3");
+        assertEquals("changed [root, f1] [0] [x3]", log.last());
+        m.valueForPathChanged(new TreePath(new Object[]{root, f1, x}), "x4");
+        assertEquals("changed [root, f1] [0] [x4]", log.last());
+        m.setValueAt("r2", root, 0);
+        assertEquals("changed [r2] null null", log.last());
+        m.removeNodeFromParent(x);
+        assertEquals("removed [r2, f1] [0] [x4]", log.last());
+        m.setColumnIdentifiers(Arrays.asList("A", "B", "C"));
+        assertEquals("structure [r2] [] null", log.last());
+        assertEquals(3, m.getColumnCount());
+        m.setRoot(null);
+        assertEquals("structure null [] null", log.last());
+        m.removeTreeModelListener(log);
+        assertEquals(0, m.getTreeModelListeners().length);
+    }
+
+    @Test
+    public void theSupportNamesTheParentOfAChangedNodeAndTellsTheLastListenerFirst() {
+        final List<String> order = new ArrayList<String>();
+        AbstractTreeTableModel m = new AbstractTreeTableModel("R") {
+            @Override
+            public int getColumnCount() {
+                return 3;
+            }
+
+            @Override
+            public Object getValueAt(Object node, int column) {
+                return node + ":" + column;
+            }
+
+            @Override
+            public Object getChild(Object parent, int index) {
+                return "R".equals(parent) ? "c" + index : null;
+            }
+
+            @Override
+            public int getChildCount(Object parent) {
+                return "R".equals(parent) ? 2 : 0;
+            }
+
+            @Override
+            public int getIndexOfChild(Object parent, Object child) {
+                return "c0".equals(child) ? 0 : "c1".equals(child) ? 1 : -1;
+            }
+        };
+        assertFalse(m.isLeaf("R"));
+        assertTrue(m.isLeaf("c0"));
+        assertFalse(m.isCellEditable("R", 0));
+        assertEquals("B", m.getColumnName(1));
+        TreeModelSupport s = new TreeModelSupport(m);
+        Log log = new Log();
+        s.addTreeModelListener(log);
+        TreePath rp = new TreePath("R");
+        s.firePathChanged(rp.pathByAddingChild("c1"));
+        assertEquals("changed [R] [1] [c1]", log.last());
+        s.firePathChanged(rp);
+        assertEquals("changed [R] null null", log.last());
+        s.fireNewRoot();
+        assertEquals("structure [R] [] null", log.last());
+        s.firePathLeafStateChanged(rp.pathByAddingChild("c0"));
+        assertEquals("structure [R, c0] [] null", log.last());
+        s.fireChildrenAdded(rp, new int[]{0, 1}, new Object[]{"c0", "c1"});
+        assertEquals("inserted [R] [0, 1] [c0, c1]", log.last());
+        s.fireChildRemoved(rp, 1, "c1");
+        assertEquals("removed [R] [1] [c1]", log.last());
+        s.removeTreeModelListener(log);
+        for (int i = 0; i < 2; i++) {
+            final int id = i;
+            s.addTreeModelListener(new TreeModelListener() {
+                @Override
+                public void treeNodesChanged(TreeModelEvent e) {
+                    order.add("L" + id);
+                    assertSame("the model is the source", m, e.getSource());
+                }
+
+                @Override
+                public void treeNodesInserted(TreeModelEvent e) {
+                }
+
+                @Override
+                public void treeNodesRemoved(TreeModelEvent e) {
+                }
+
+                @Override
+                public void treeStructureChanged(TreeModelEvent e) {
+                }
+            });
+        }
+        s.fireChildChanged(rp, 0, "c0");
+        assertEquals(Arrays.asList("L1", "L0"), order);
+        try {
+            new TreeModelSupport(null);
+            fail();
+        } catch (NullPointerException expected) {
+            assertEquals("model must not be null", expected.getMessage());
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/GradientFillTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/GradientFillTest.java
new file mode 100644
index 00000000000..7c21e69cdaa
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/GradientFillTest.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.compat.testing.HeadlessImplementation;
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.GradientPaint;
+import com.codename1.desktopcompat.java.awt.geom.Path2D;
+import com.codename1.desktopcompat.java.awt.geom.RoundRectangle2D;
+import com.codename1.ui.Image;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/// A `GradientPaint` through a shape: the colors its definition gives, and
+/// nothing outside the shape.
+///
+/// The tests run on a surface with shapes and no shape clip (see
+/// `HeadlessImplementation.shapes`), which is no kinder than the ports whose
+/// captures showed this fill as a hollow outline and as a block from the
+/// panel's corner: a fill that needs a rectangle on top of a shape clip to
+/// stay inside its shape paints outside it here.
+public class GradientFillTest extends KernelTestBase {
+
+    private static final int W = 480;
+    private static final int H = 280;
+
+    private Image surface;
+
+    @Before
+    public void shapes() {
+        HeadlessImplementation.rasterImages = true;
+        HeadlessImplementation.pixelImages = true;
+        HeadlessImplementation.shapes = true;
+        surface = Image.createImage(W, H, 0);
+    }
+
+    @After
+    public void noShapes() {
+        HeadlessImplementation.rasterImages = false;
+        HeadlessImplementation.pixelImages = false;
+        HeadlessImplementation.shapes = false;
+        HeadlessImplementation.resetRaster();
+    }
+
+    /// A graphics over the whole surface. The scale is the 2 of the base
+    /// class, so a user unit is two pixels.
+    private G2D graphics() {
+        return G2D.forPeer(surface.getGraphics(), 0, 0, W, H);
+    }
+
+    private int pixel(int x, int y) {
+        return surface.getRGB()[y * W + x];
+    }
+
+    private static void near(String what, int expected, int actual) {
+        assertTrue(what + ": alpha " + (actual >>> 24), (actual >>> 24) >= 250);
+        for (int shift = 0; shift <= 16; shift += 8) {
+            int e = (expected >> shift) & 0xff;
+            int a = (actual >> shift) & 0xff;
+            assertTrue(what + ": expected " + Integer.toHexString(expected) + ", was " + Integer.toHexString(actual),
+                    Math.abs(e - a) <= 4);
+        }
+    }
+
+    private void nothingOutside(int x1, int y1, int x2, int y2) {
+        int[] px = surface.getRGB();
+        for (int y = 0; y < H; y++) {
+            for (int x = 0; x < W; x++) {
+                if (x < x1 || x >= x2 || y < y1 || y >= y2) {
+                    assertEquals("painted outside the shape at " + x + "," + y, 0, px[y * W + x] >>> 24);
+                }
+            }
+        }
+    }
+
+    /// The fill of the painting scene: a gradient from one end of a rounded
+    /// rectangle to the other. User (16, 30, 150, 44) is device
+    /// (32, 60, 300, 88).
+    @Test
+    public void aGradientFillsARoundedRectangleAndNothingElse() {
+        G2D g = graphics();
+        g.setPaint(new GradientPaint(16, 30, new Color(0x11998e), 166, 30, new Color(0x38ef7d)));
+        g.fill(new RoundRectangle2D.Double(16, 30, 150, 44, 24, 24));
+        g.finish();
+        near("start", 0xff11998e, pixel(33, 104));
+        near("middle", 0xff25c486, pixel(182, 104));
+        near("end", 0xff38ef7d, pixel(330, 104));
+        // Inside the bounds, outside the round corner.
+        assertEquals("the corner of the bounds", 0, pixel(34, 62) >>> 24);
+        assertEquals("the far corner of the bounds", 0, pixel(329, 145) >>> 24);
+        nothingOutside(32, 60, 332, 148);
+    }
+
+    /// Past its two points a gradient that does not cycle goes on in the
+    /// nearest color, and a cyclic one walks back: the first color returns
+    /// as far past the second point as the points are apart.
+    @Test
+    public void pastItsPointsAGradientHoldsItsColorOrWalksBack() {
+        Color first = new Color(0x000000);
+        Color second = new Color(0xffffff);
+        G2D g = graphics();
+        g.setPaint(new GradientPaint(40, 0, first, 80, 0, second));
+        g.fill(new RoundRectangle2D.Double(10, 10, 200, 20, 6, 6));
+        g.setPaint(new GradientPaint(40, 0, first, 80, 0, second, true));
+        g.fill(new RoundRectangle2D.Double(10, 50, 200, 20, 6, 6));
+        g.finish();
+        // Device x is twice the user x; rows 40 and 120 are mid shape.
+        near("before the first point", 0xff000000, pixel(50, 40));
+        near("half way", 0xff808080, pixel(120, 40));
+        near("past the second point", 0xffffffff, pixel(300, 40));
+        near("cyclic, half way", 0xff808080, pixel(120, 120));
+        near("cyclic, at the second point", 0xffffffff, pixel(160, 120));
+        near("cyclic, half way back", 0xff808080, pixel(200, 120));
+        near("cyclic, the first color again", 0xff000000, pixel(240, 120));
+        near("cyclic, before the first point", 0xff808080, pixel(40, 120));
+    }
+
+    /// The place on the gradient is measured in user space. Under a matrix
+    /// that stretches one axis the colors still run from point to point, and
+    /// a triangle is filled as a triangle.
+    @Test
+    public void aGradientUnderAMatrixFollowsTheUserSpace() {
+        G2D g = graphics();
+        g.translate(20, 10);
+        g.scale(2, 1);
+        // User (0,0)-(50,100) is device (40,20)-(240,220).
+        g.setPaint(new GradientPaint(0, 0, new Color(0xff0000), 0, 100, new Color(0x0000ff)));
+        Path2D.Double triangle = new Path2D.Double();
+        triangle.moveTo(0, 0);
+        triangle.lineTo(50, 0);
+        triangle.lineTo(0, 100);
+        triangle.closePath();
+        g.fill(triangle);
+        g.finish();
+        near("top", 0xffff0000, pixel(60, 21));
+        near("half way down", 0xff800080, pixel(60, 120));
+        near("near the bottom", 0xff0a00f5, pixel(42, 212));
+        // The half of the bounds the triangle does not cover.
+        assertEquals(0, pixel(230, 200) >>> 24);
+        assertEquals(0, pixel(160, 130) >>> 24);
+        nothingOutside(40, 20, 240, 220);
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/MiniHtmlTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/MiniHtmlTest.java
new file mode 100644
index 00000000000..d244363730f
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/MiniHtmlTest.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.codename1.desktopcompat.KernelTestBase;
+import com.codename1.desktopcompat.java.awt.Color;
+import com.codename1.desktopcompat.java.awt.Dimension;
+import com.codename1.desktopcompat.java.awt.Font;
+import com.codename1.desktopcompat.java.awt.Graphics;
+import com.codename1.desktopcompat.java.awt.image.BufferedImage;
+import org.junit.Test;
+
+/// The HTML reader: the runs and lines it makes, the sizes it measures,
+/// and that nothing it is given makes it throw.
+public class MiniHtmlTest extends KernelTestBase {
+
+    private static final Font FONT = new Font(Font.DIALOG, Font.PLAIN, 12);
+
+    @Test
+    public void onlyATextStartingWithTheHtmlTagIsHtml() {
+        assertTrue(MiniHtml.isHtml("<html>x"));
+        assertTrue(MiniHtml.isHtml("<HTML>x"));
+        assertTrue(MiniHtml.isHtml("<HtMl>"));
+        assertFalse(MiniHtml.isHtml(" <html>x"));
+        assertFalse(MiniHtml.isHtml("<b>x</b>"));
+        assertFalse(MiniHtml.isHtml("<htm"));
+        assertFalse(MiniHtml.isHtml(null));
+    }
+
+    @Test
+    public void stylesBecomeRuns() {
+        MiniHtml.Document d = MiniHtml.parse("<html><b>Bold</b> plain <i>it</i><u>under</u></html>");
+        assertEquals(1, d.lineCount());
+        MiniHtml.Line l = d.line(0);
+        assertEquals(4, l.runCount());
+        assertEquals("Bold", l.run(0).text());
+        assertTrue(l.run(0).bold());
+        assertFalse(l.run(0).italic());
+        assertEquals(" plain ", l.run(1).text());
+        assertFalse(l.run(1).bold());
+        assertEquals("it", l.run(2).text());
+        assertTrue(l.run(2).italic());
+        assertFalse(l.run(2).underline());
+        assertEquals("under", l.run(3).text());
+        assertTrue(l.run(3).underline());
+        assertFalse(l.run(3).italic());
+        assertEquals("Bold plain itunder", l.text());
+        assertEquals(MiniHtml.ALIGN_DEFAULT, l.alignment());
+    }
+
+    @Test
+    public void stylesNest() {
+        MiniHtml.Document d = MiniHtml.parse("<html><b>a<i>b</i>c</b>d<strong><em>e</em></strong>");
+        MiniHtml.Line l = d.line(0);
+        assertEquals(5, l.runCount());
+        assertTrue(l.run(0).bold() && !l.run(0).italic());
+        assertTrue(l.run(1).bold() && l.run(1).italic());
+        assertTrue(l.run(2).bold() && !l.run(2).italic());
+        assertFalse(l.run(3).bold());
+        assertTrue(l.run(4).bold() && l.run(4).italic());
+    }
+
+    @Test
+    public void breaksAndParagraphsMakeLines() {
+        MiniHtml.Document d = MiniHtml.parse("<html>one<br>two<BR/>\n  three<br><br>five<p>six</p>seven<p>eight");
+        assertEquals(8, d.lineCount());
+        assertEquals("one", d.line(0).text());
+        assertEquals("two", d.line(1).text());
+        assertEquals("three", d.line(2).text());
+        assertEquals("", d.line(3).text());
+        assertEquals(0, d.line(3).runCount());
+        assertEquals("five", d.line(4).text());
+        assertEquals("six", d.line(5).text());
+        assertTrue(d.line(5).gapBefore());
+        assertFalse(d.line(4).gapBefore());
+        assertEquals("seven", d.line(6).text());
+        assertTrue(d.line(6).gapBefore());
+        assertEquals("eight", d.line(7).text());
+        assertEquals("one\ntwo\nthree\n\nfive\nsix\nseven\neight",
+                MiniHtml.plainText("<html>one<br>two<BR/>\n  three<br><br>five<p>six</p>seven<p>eight"));
+    }
+
+    @Test
+    public void whiteSpaceCollapsesAndEntitiesAreRead() {
+        MiniHtml.Document d = MiniHtml.parse("<html>  a \n\t b&amp;c &lt;d&gt; &quot;e&quot;&nbsp;&nbsp;f &#65;&#x42; </html>");
+        assertEquals(1, d.lineCount());
+        assertEquals("a b&c <d> \"e\"  f AB", d.line(0).text());
+        assertEquals("x & y &bogus; &", MiniHtml.plainText("<html>x & y &bogus; &"));
+    }
+
+    @Test
+    public void fontColorsAreRead() {
+        MiniHtml.Document d = MiniHtml.parse("<html><font color=\"red\">r</font><font color=#00ff00>g</font>"
+                + "<FONT COLOR='#00F'>b</FONT><span style=\"font-weight: bold; color: rgb(1, 2, 3)\">s</span>n"
+                + "<font color=nonsense>x</font>");
+        MiniHtml.Line l = d.line(0);
+        assertEquals(new Color(255, 0, 0), l.run(0).color());
+        assertEquals(new Color(0, 255, 0), l.run(1).color());
+        assertEquals(new Color(0, 0, 255), l.run(2).color());
+        assertEquals(new Color(1, 2, 3), l.run(3).color());
+        assertEquals("nx", l.run(4).text());
+        assertNull(l.run(4).color());
+        assertNull(MiniHtml.color(null));
+        assertNull(MiniHtml.color("#12"));
+        assertEquals(new Color(0x80, 0x80, 0x80), MiniHtml.color("Gray"));
+    }
+
+    @Test
+    public void centerAndAlignSetTheLinesAlignment() {
+        MiniHtml.Document d = MiniHtml.parse("<html>left<center>mid<br>dle</center>after<p align=right>r</p>"
+                + "<div align=\"CENTER\">c</div>");
+        assertEquals(6, d.lineCount());
+        assertEquals(MiniHtml.ALIGN_DEFAULT, d.line(0).alignment());
+        assertEquals(MiniHtml.ALIGN_CENTER, d.line(1).alignment());
+        assertEquals(MiniHtml.ALIGN_CENTER, d.line(2).alignment());
+        assertEquals("after", d.line(3).text());
+        assertEquals(MiniHtml.ALIGN_DEFAULT, d.line(3).alignment());
+        assertEquals(MiniHtml.ALIGN_RIGHT, d.line(4).alignment());
+        assertEquals(MiniHtml.ALIGN_CENTER, d.line(5).alignment());
+    }
+
+    @Test
+    public void sizesScaleTheFont() {
+        MiniHtml.Document d = MiniHtml.parse("<html><font size=5>big</font><font size=\"-1\">small</font>"
+                + "<h1>head</h1>");
+        assertEquals(1.5f, d.line(0).run(0).scale(), 0.001f);
+        assertEquals(0.8f, d.line(0).run(1).scale(), 0.001f);
+        assertEquals(2f, d.line(1).run(0).scale(), 0.001f);
+        assertTrue(d.line(1).run(0).bold());
+    }
+
+    @Test
+    public void headStyleAndCommentsAreDropped() {
+        assertEquals("shown", MiniHtml.plainText("<html><head><title>t</title><style>b { x }</style></head>"
+                + "<body><!-- not this -->shown</body></html>"));
+        assertEquals("a b", MiniHtml.plainText("<html>a <unknown attr=1>b</unknown>"));
+        assertEquals("not html <b>", MiniHtml.plainText("not html <b>"));
+        assertEquals("a b", MiniHtml.singleLine("<html>a<br>b"));
+    }
+
+    @Test
+    public void malformedInputNeverThrows() {
+        String[] bad = {
+            "<html><b>unclosed <i>x</b> y </zzz> <",
+            "<html><",
+            "<html></",
+            "<html><>",
+            "<html>&;&#xZZ;&#;&#99999999999;&unknown; a < b > c <font color=> <font color",
+            "<html><!-- never closed",
+            "<html><head>never closed",
+            "<html><font color=\"unterminated>x",
+            "<html></b></i></p></center></font>text",
+            "<html><p><p><p></p><br><br><br>",
+            "<html><font size=abc>x</font><font size=+>y</font><font size=99>z</font>",
+            "<html><span style=\"color\">a</span><span style=\":;:;\">b</span>",
+            "<html>&#0;&#x0;&#160;&#xFFFFF;",
+            "<html><li>one<li>two</ul></ol>",
+            "",
+            "<",
+            "&"
+        };
+        BufferedImage img = new BufferedImage(50, 50, BufferedImage.TYPE_INT_ARGB);
+        for (int i = 0; i < bad.length; i++) {
+            MiniHtml.Document d = MiniHtml.parse(bad[i]);
+            assertNotNull(bad[i], d);
+            assertNotNull(MiniHtml.plainText(bad[i]));
+            Dimension size = MiniHtml.preferredSize(d, FONT);
+            assertTrue(size.width >= 0 && size.height >= 0);
+            assertNotNull(MiniHtml.wrap(d, FONT, 10));
+            Graphics g = img.createGraphics();
+            try {
+                MiniHtml.paint(g, d, 0, 0, 20, MiniHtml.ALIGN_CENTER);
+            } finally {
+                g.dispose();
+            }
+        }
+        assertEquals(0, MiniHtml.parse(null).lineCount());
+        assertEquals("unclosed x y <", MiniHtml.plainText(bad[0]));
+    }
+
+    @Test
+    public void theSizeIsTheWidestLineAndTheSumOfTheHeights() {
+        Dimension one = MiniHtml.preferredSize(MiniHtml.parse("<html>abcdef"), FONT);
+        Dimension two = MiniHtml.preferredSize(MiniHtml.parse("<html>abcdef<br>abc"), FONT);
+        Dimension para = MiniHtml.preferredSize(MiniHtml.parse("<html>abcdef<p>abc"), FONT);
+        assertTrue(one.width > 0 && one.height > 0);
+        assertEquals(one.width, two.width);
+        assertEquals(2 * one.height, two.height);
+        assertEquals(2 * one.height + one.height / 2, para.height);
+        assertEquals(Fonts.metrics(FONT).stringWidth("abcdef"), one.width);
+    }
+
+    @Test
+    public void aLineWiderThanTheWidthWrapsAtSpaces() {
+        MiniHtml.Document d = MiniHtml.parse("<html>aaaa bbbb <b>cccc dddd</b><br>ee");
+        int word = Fonts.metrics(FONT).stringWidth("aaaa bbbb");
+        MiniHtml.Document w = MiniHtml.wrap(d, FONT, word + 2);
+        assertEquals(3, w.lineCount());
+        assertEquals("aaaa bbbb ", w.line(0).text());
+        assertEquals("cccc dddd", w.line(1).text());
+        assertTrue(w.line(1).run(0).bold());
+        assertEquals("ee", w.line(2).text());
+        assertSame(d, MiniHtml.wrap(d, FONT, 10000));
+        assertSame(d, MiniHtml.wrap(d, FONT, 0));
+        // A word wider than the width stays whole on a line of its own.
+        MiniHtml.Document narrow = MiniHtml.wrap(d, FONT, 1);
+        assertEquals(5, narrow.lineCount());
+        assertEquals("aaaa ", narrow.line(0).text());
+    }
+
+    /// A font of the monospaced family is drawn in the platform's fixed
+    /// width font, whatever the case the family is written in; any other
+    /// family is not.
+    @Test
+    public void aMonospacedFamilyGetsTheFixedWidthFont() {
+        com.codename1.compat.testing.HeadlessImplementation.lastFontFace = -1;
+        Fonts.nativeFont(new Font("Dialog", Font.PLAIN, 12), 23.25f);
+        assertTrue(com.codename1.compat.testing.HeadlessImplementation.lastFontFace
+                != com.codename1.ui.Font.FACE_MONOSPACE);
+        Fonts.nativeFont(new Font("monospaced", Font.PLAIN, 12), 23.25f);
+        assertEquals(com.codename1.ui.Font.FACE_MONOSPACE,
+                com.codename1.compat.testing.HeadlessImplementation.lastFontFace);
+        com.codename1.compat.testing.HeadlessImplementation.lastFontFace = -1;
+        Fonts.nativeFont(new Font("Courier New", Font.BOLD, 12), 23.25f);
+        assertEquals(com.codename1.ui.Font.FACE_MONOSPACE,
+                com.codename1.compat.testing.HeadlessImplementation.lastFontFace);
+    }
+
+    /// The entities a label is written with beyond the five of XML; one
+    /// that is not known stays as it was typed.
+    @Test
+    public void namedEntitiesAreTheirCharacters() {
+        assertEquals("1" + (char) 177 + "2", MiniHtml.plainText("<html>1&plusmn;2"));
+        assertEquals(String.valueOf((char) 169) + (char) 8230 + (char) 8594,
+                MiniHtml.plainText("<html>&copy;&hellip;&rarr;"));
+        assertEquals("a&nosuch;b", MiniHtml.plainText("<html>a&nosuch;b"));
+        assertEquals("<", MiniHtml.plainText("<html>&#60;"));
+    }
+}
diff --git a/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/UnitsTest.java b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/UnitsTest.java
new file mode 100644
index 00000000000..7be15953dd3
--- /dev/null
+++ b/maven/swing-compat/src/test/java/com/codename1/desktopcompat/rt/UnitsTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.desktopcompat.rt;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.After;
+import org.junit.Test;
+
+/// The conversion between logical pixels and device pixels.
+public class UnitsTest {
+
+    @After
+    public void reset() {
+        Units.setScale(0);
+    }
+
+    @Test
+    public void scaleIsOneWithoutADisplayOrOverride() {
+        Units.setScale(0);
+        // No display is initialised in this class unless another test class
+        // ran first in the same JVM, so only the override is asserted.
+        Units.setScale(1f);
+        assertEquals(1f, Units.scale(), 0f);
+        assertEquals(17, Units.toDevice(17));
+    }
+
+    @Test
+    public void positionsRoundToTheNearestDevicePixel() {
+        Units.setScale(1.5f);
+        assertEquals(0, Units.toDevice(0));
+        assertEquals(2, Units.toDevice(1));
+        assertEquals(3, Units.toDevice(2));
+        assertEquals(15, Units.toDevice(10));
+    }
+
+    @Test
+    public void adjacentRectanglesStayAdjacent() {
+        float[] scales = {1f, 1.25f, 1.5f, 2f, 2.625f, 3.3333333f};
+        for (int s = 0; s < scales.length; s++) {
+            Units.setScale(scales[s]);
+            for (int x = 0; x < 60; x++) {
+                for (int w = 0; w < 40; w++) {
+                    assertEquals("scale " + scales[s] + " x " + x + " w " + w, Units.toDevice(x + w),
+                            Units.toDevice(x) + Units.toDeviceSize(x, w));
+                }
+            }
+        }
+    }
+
+    @Test
+    public void logicalSizesRoundDownAndUp() {
+        Units.setScale(2f);
+        assertEquals(5, Units.toLogical(11));
+        assertEquals(6, Units.toLogicalCeil(11));
+        assertEquals(5, Units.toLogicalCeil(10));
+        assertEquals(5.5f, Units.toLogicalExact(11), 0.0001f);
+    }
+
+    @Test
+    public void aLogicalSizeFitsInTheDeviceSizeItCameFrom() {
+        float[] scales = {1.25f, 1.5f, 2.625f, 3.3333333f};
+        for (int s = 0; s < scales.length; s++) {
+            Units.setScale(scales[s]);
+            for (int device = 0; device < 2000; device += 7) {
+                int logical = Units.toLogical(device);
+                assertEquals(true, Units.toDevice(logical) <= device);
+            }
+        }
+    }
+}
diff --git a/maven/swing-compat/src/test/resources/com/codename1/desktopcompat/com/formdev/flatlaf/flatlaf-absent.txt b/maven/swing-compat/src/test/resources/com/codename1/desktopcompat/com/formdev/flatlaf/flatlaf-absent.txt
new file mode 100644
index 00000000000..d00667b2f39
--- /dev/null
+++ b/maven/swing-compat/src/test/resources/com/codename1/desktopcompat/com/formdev/flatlaf/flatlaf-absent.txt
@@ -0,0 +1,57 @@
+# The public classes of FlatLaf and FlatLaf Extras that this layer deliberately
+# does not have. FlatLafApiShapeTest reads this file: a class of the real jars
+# must be in the layer, or named here, or in a package named here with ".*".
+# A line that names a class the layer does have fails the test, so the list
+# cannot go stale.
+#
+# Whole packages. The UI delegates, icons and JSON reader are how FlatLaf
+# paints Swing; here the widgets are Codename One components and the palette
+# is a theme, so there is nothing for them to do. The extras components wrap
+# Swing components to add FlatLaf-only properties.
+com.formdev.flatlaf.ui.*
+com.formdev.flatlaf.icons.*
+com.formdev.flatlaf.json.*
+com.formdev.flatlaf.resources.*
+com.formdev.flatlaf.extras.components.*
+com.formdev.flatlaf.extras.resources.*
+#
+# Single classes: property-file loading, addons, IntelliJ theme files, the
+# inspector and the native-window and font machinery, none of which has a
+# counterpart on a device; and the SVG icon, which needs a renderer the
+# layer does not carry.
+com.formdev.flatlaf.FlatDefaultsAddon
+com.formdev.flatlaf.FlatIconColors
+com.formdev.flatlaf.FlatInputMaps
+com.formdev.flatlaf.FlatPropertiesLaf
+com.formdev.flatlaf.IntelliJTheme
+com.formdev.flatlaf.LinuxFontPolicy
+com.formdev.flatlaf.LinuxPopupMenuCanceler
+com.formdev.flatlaf.MnemonicHandler
+com.formdev.flatlaf.SubMenuUsabilityHelper
+com.formdev.flatlaf.UIDefaultsLoader
+com.formdev.flatlaf.extras.FlatDesktop
+com.formdev.flatlaf.extras.FlatInspector
+com.formdev.flatlaf.extras.FlatSVGIcon
+com.formdev.flatlaf.extras.FlatSVGUtils
+com.formdev.flatlaf.extras.FlatUIDefaultsInspector
+com.formdev.flatlaf.util.AnimatedIcon
+com.formdev.flatlaf.util.Animator
+com.formdev.flatlaf.util.ColorFunctions
+com.formdev.flatlaf.util.CubicBezierEasing
+com.formdev.flatlaf.util.DerivedColor
+com.formdev.flatlaf.util.FontUtils
+com.formdev.flatlaf.util.Graphics2DProxy
+com.formdev.flatlaf.util.GrayFilter
+com.formdev.flatlaf.util.HSLColor
+com.formdev.flatlaf.util.HiDPIUtils
+com.formdev.flatlaf.util.JavaCompatibility
+com.formdev.flatlaf.util.LoggingFacade
+com.formdev.flatlaf.util.LoggingFacadeImpl
+com.formdev.flatlaf.util.MultiResolutionImageSupport
+com.formdev.flatlaf.util.NativeLibrary
+com.formdev.flatlaf.util.ScaledEmptyBorder
+com.formdev.flatlaf.util.ScaledImageIcon
+com.formdev.flatlaf.util.SoftCache
+com.formdev.flatlaf.util.StringUtils
+com.formdev.flatlaf.util.SwingUtils
+com.formdev.flatlaf.util.SystemFileChooser
diff --git a/scripts/android/screenshots/DesktopCompatFxAlert.png b/scripts/android/screenshots/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..801fad7bcfe
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatFxAlert.png differ
diff --git a/scripts/android/screenshots/DesktopCompatFxControls.png b/scripts/android/screenshots/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..19cd19d14a0
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatFxControls.png differ
diff --git a/scripts/android/screenshots/DesktopCompatFxData.png b/scripts/android/screenshots/DesktopCompatFxData.png
new file mode 100644
index 00000000000..a7e4a27279b
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatFxData.png differ
diff --git a/scripts/android/screenshots/DesktopCompatFxFxml.png b/scripts/android/screenshots/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..e60bd554b6e
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatFxFxml.png differ
diff --git a/scripts/android/screenshots/DesktopCompatFxPanes.png b/scripts/android/screenshots/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..3b411b1ccb8
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatFxPanes.png differ
diff --git a/scripts/android/screenshots/DesktopCompatFxShapes.png b/scripts/android/screenshots/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..2fce786294a
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatFxShapes.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingContainers.png b/scripts/android/screenshots/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..6b59ca13c3d
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingContainers.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingControls.png b/scripts/android/screenshots/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..ddbce6df37e
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingControls.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingOptionPane.png b/scripts/android/screenshots/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..c3d20e0eee2
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingPainting.png b/scripts/android/screenshots/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..f84b80904bf
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingPainting.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingTables.png b/scripts/android/screenshots/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..d92eadcf533
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingTables.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingTrees.png b/scripts/android/screenshots/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..30d8d90b3dc
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingTrees.png differ
diff --git a/scripts/android/screenshots/DesktopCompatSwingX.png b/scripts/android/screenshots/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..bac414f7c19
Binary files /dev/null and b/scripts/android/screenshots/DesktopCompatSwingX.png differ
diff --git a/scripts/check-cast-semantics.sh b/scripts/check-cast-semantics.sh
index 028627337be..b07fcd66197 100755
--- a/scripts/check-cast-semantics.sh
+++ b/scripts/check-cast-semantics.sh
@@ -24,7 +24,9 @@ TRANSLATOR="$REPO_ROOT/vm/ByteCodeTranslator/target/classes"
 # The modules whose bytecode ParparVM translates and that we own. A translation
 # sees maven/core, maven/ios and vm/JavaAPI, and -- in an application with
 # Android sources -- maven/android-compat, whose runtime the build relocates into
-# the application's own classes. Nothing else of ours.
+# the application's own classes. An application with Swing, SwingX or JavaFX sources gets the same
+# treatment from maven/swing-compat and maven/javafx-compat: their classes are
+# relocated into the application and translated with it.
 # Deliberately NOT covered, for the one reason: the code runs on a VM whose
 # CHECKCAST does throw, so its catch(ClassCastException) handlers are live and
 # correct and demanding an instanceof there buys nothing.
@@ -37,6 +39,8 @@ DEFAULT_ROOTS=(
   "maven/core/target/classes"
   "maven/ios/target/classes"
   "maven/android-compat/target/classes"
+  "maven/swing-compat/target/classes"
+  "maven/javafx-compat/target/classes"
 )
 
 write_baseline=0
diff --git a/scripts/check-native-signatures.sh b/scripts/check-native-signatures.sh
index 87c9e556c4f..0b00bdebd00 100755
--- a/scripts/check-native-signatures.sh
+++ b/scripts/check-native-signatures.sh
@@ -56,9 +56,13 @@ if [[ -d "$REPO_ROOT/vm/backend/impl/parparvm" ]] && command -v javac >/dev/null
   mkdir -p "$REPO_ROOT/$backend_build"
   # Plus the core classes the backend shares (@SharedWithBackend), which live in
   # CodenameOne/src rather than under vm/backend.
+  # vm/JavaAPI on the class path: the backend installs the class library's
+  # file host (com.codename1.impl.JdkHost, PosixJdkHost), which only JavaAPI
+  # has. The JDK still answers java.* -- the class path cannot override it.
   if { find "$REPO_ROOT/vm/backend/src" "$REPO_ROOT/vm/backend/impl/parparvm" -name '*.java' -print \
        && "$REPO_ROOT/vm/backend/shared-sources.sh"; } \
-       | tr '\n' '\0' | xargs -0 javac -nowarn -d "$REPO_ROOT/$backend_build" >/dev/null 2>&1; then
+       | tr '\n' '\0' | xargs -0 javac -nowarn -cp "$REPO_ROOT/vm/JavaAPI/target/classes" \
+           -d "$REPO_ROOT/$backend_build" >/dev/null 2>&1; then
     BACKEND_CLASSES="$backend_build"
   else
     echo "check-native-signatures: could not compile the backend's ParparVM sources" >&2
diff --git a/scripts/copyright-header-exclusions.txt b/scripts/copyright-header-exclusions.txt
index f404927ffd9..6a97e54494a 100644
--- a/scripts/copyright-header-exclusions.txt
+++ b/scripts/copyright-header-exclusions.txt
@@ -199,6 +199,7 @@ Ports/CLDC11/src/java/text/DateFormatSymbols.java | Codename One contribution wh
 Ports/CLDC11/src/java/text/Format.java | Codename One contribution whose copyright line names its contributor; the notice is kept as written
 Ports/CLDC11/src/java/text/ParseException.java | Codename One contribution whose copyright line names its contributor; the notice is kept as written
 Ports/CLDC11/src/java/text/SimpleDateFormat.java | Codename One contribution whose copyright line names its contributor; the notice is kept as written
+Ports/CLDC11/src/java/util/Comparator.java | Apache Software Foundation (Harmony-derived) source retaining its original Apache-2.0 notice
 maven/cn1app-archetype/src/main/resources/archetype-resources/common/src/test/java/MyFirstTest.java | Archetype template copied into user projects, which carries no Codename One header by design
 maven/cn1lib-archetype/src/main/resources/archetype-resources/common/src/test/java/FilechooserTest.java | Archetype template copied into user projects, which carries no Codename One header by design
 maven/build-engine/src/main/java/com/codename1/builders/Base64.java | Apache Software Foundation (Harmony-derived) source retaining its original Apache-2.0 notice
@@ -366,6 +367,7 @@ vm/ByteCodeTranslator/src/com/codename1/tools/translator/classfile/tree/TableSwi
 vm/ByteCodeTranslator/src/com/codename1/tools/translator/classfile/tree/TryCatchBlockNode.java | Rewrite of ASM org.objectweb.asm.tree.TryCatchBlockNode for ParparVM, retaining ASM's BSD-3-Clause notice (INRIA, France Telecom)
 vm/ByteCodeTranslator/src/com/codename1/tools/translator/classfile/tree/TypeInsnNode.java | Rewrite of ASM org.objectweb.asm.tree.TypeInsnNode for ParparVM, retaining ASM's BSD-3-Clause notice (INRIA, France Telecom)
 vm/ByteCodeTranslator/src/com/codename1/tools/translator/classfile/tree/VarInsnNode.java | Rewrite of ASM org.objectweb.asm.tree.VarInsnNode for ParparVM, retaining ASM's BSD-3-Clause notice (INRIA, France Telecom)
+maven/swing-compat/src/main/java/com/codename1/desktopcompat/javax/swing/GroupLayout.java | Adapted from CodenameOne/src/com/codename1/ui/layouts/GroupLayout.java (Oracle GPLv2 + Classpath-exception group layout), retaining its original Oracle notice
 scripts/backend-mvc/src/main/resources/static/htmx-2.0.11.min.js | Unmodified htmx 2.0.11 distribution, Zero-Clause BSD license in scripts/backend-mvc/HTMX-LICENSE.txt
 
 # Relocated JZlib retains its original BSD license.
@@ -385,3 +387,25 @@ vm/JavaAPI/src/com/codename1/impl/zip/JZlib.java | JZlib, Copyright ymnk, JCraft
 vm/JavaAPI/src/com/codename1/impl/zip/StaticTree.java | JZlib, Copyright ymnk, JCraft Inc., BSD license; generated relocation retains original notice
 vm/JavaAPI/src/com/codename1/impl/zip/Tree.java | JZlib, Copyright ymnk, JCraft Inc., BSD license; generated relocation retains original notice
 vm/JavaAPI/src/com/codename1/impl/zip/ZStream.java | JZlib, Copyright ymnk, JCraft Inc., BSD license; generated relocation retains original notice
+Ports/CLDC11/src/java/lang/Iterable.java | Apache Harmony source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/Arrays.java | Apache Harmony source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/Collection.java | Apache Harmony source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/Iterator.java | Apache Harmony source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/List.java | Apache Harmony source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/Map.java | Apache Harmony source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/Set.java | Apache Harmony source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/lang/Iterable.java | Apache Harmony source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/util/Arrays.java | Apache Harmony source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/util/Iterator.java | Apache Harmony source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/util/List.java | Apache Harmony source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/util/Map.java | Apache Harmony source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/util/Set.java | Apache Harmony source retaining its original Apache-2.0 notice
+# Rewrite of OpenJDK's FloatingDecimal digit generation (see NOTICE), keeping the Oracle notice verbatim.
+vm/JavaAPI/src/java/text/LegacyDoubleDigits.java | Rewrite of OpenJDK sun.misc.FloatingDecimal.BinaryToASCIIBuffer.dtoa and FDBigInteger (Oracle GPLv2 + Classpath exception), retaining the original Oracle notice; recorded in NOTICE
+Ports/CLDC11/src/java/text/LegacyDoubleDigits.java | Rewrite of OpenJDK sun.misc.FloatingDecimal.BinaryToASCIIBuffer.dtoa and FDBigInteger (Oracle GPLv2 + Classpath exception), retaining the original Oracle notice; recorded in NOTICE
+vm/JavaAPI/src/java/util/Random.java | Apache Harmony source under the Apache License 2.0, retaining its original ASF notice
+Ports/CLDC11/src/java/lang/CharSequence.java | Apache Harmony class library source retaining its original Apache-2.0 notice
+Ports/CLDC11/src/java/util/Collections.java | Apache Harmony class library source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/io/ByteArrayOutputStream.java | Apache Harmony class library source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/lang/CharSequence.java | Apache Harmony class library source retaining its original Apache-2.0 notice
+vm/JavaAPI/src/java/util/Objects.java | Apache Harmony class library source retaining its original Apache-2.0 notice
diff --git a/scripts/desktop-compat-benchmarks/Containerfile b/scripts/desktop-compat-benchmarks/Containerfile
new file mode 100644
index 00000000000..550298f3a92
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/Containerfile
@@ -0,0 +1,11 @@
+# The image the Linux leg of the desktop-compat benchmarks runs in when it is
+# not on a CI runner. Same distribution as the ubuntu-24.04 runners, and the
+# same install script the workflow calls, so both measure one stack.
+#
+#   podman build -t bench-linux -f scripts/desktop-compat-benchmarks/Containerfile \
+#       scripts/desktop-compat-benchmarks
+FROM docker.io/library/ubuntu:24.04
+COPY install-linux-deps.sh javafx-jmods.sh /opt/bench/
+RUN bash /opt/bench/install-linux-deps.sh /opt/bench/tools \
+    && rm -rf /var/lib/apt/lists/*
+ENV BENCH_TOOLS=/opt/bench/tools
diff --git a/scripts/desktop-compat-benchmarks/README.md b/scripts/desktop-compat-benchmarks/README.md
new file mode 100644
index 00000000000..9ed0bcd49e6
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/README.md
@@ -0,0 +1,202 @@
+# Desktop compatibility benchmarks
+
+How big, how hungry and how quick is a Swing or JavaFX application once it has
+been imported with `cn1:import-desktop-project` and built as a native Codename
+One executable, next to the same application shipped the way its developer ships
+it today?
+
+Everything here measures; nothing estimates. A cell that could not be measured
+is printed as `--` and the reason is in the result's `errors` or under
+"Failures" in the report.
+
+## What is compared
+
+| | Baseline | Codename One |
+|---|---|---|
+| Sources | the application's own `src/main`, unmodified | the same directory, imported |
+| Compiler | `javac --release 17` (JDK 21) | the generated project's Maven build (JDK 17), then ParparVM to C |
+| Runtime | a `jlink` image of exactly the modules `jdeps` names, `--strip-debug --no-header-files --no-man-pages --compress zip-6` | none: one native executable |
+| Toolkit | the JDK's Swing, or OpenJFX from jmods | `maven/swing-compat` or `maven/javafx-compat` over the native port |
+| Package | `jpackage --type app-image` around that runtime | the builder's output (`-O3`, ThinLTO, `--gc-sections`, stripped) |
+
+Two JVM configurations run, because "the JVM" is not one number:
+
+- **default**: `java -cp ... Main`, with the JDK's default CDS archive
+  regenerated in the image (`-Xshare:dump`). A jlink image has none, and
+  without it "default" would be slower than the `java` a developer starts.
+- **tuned**: `-XX:+UseSerialGC -Xss256k -XX:TieredStopAtLevel=1`, an AppCDS
+  archive recorded by one training run through the input script
+  (`-XX:ArchiveClassesAtExit`), and the smallest `-Xmx` from
+  `8 12 16 24 32 48 64 96 128 192 256 384 512` MB under which the application
+  starts, runs the whole input script and logs no more exceptions than it does
+  with no limit. (`OutOfMemoryError` alone is not the test: JavaFX under a heap
+  too small for its textures paints once and then throws from the renderer on
+  every frame.)
+
+Sizes are taken **before** either CDS archive is written, which is the smaller
+figure and so the one more favourable to the baseline.
+
+## What is measured, and how
+
+**Size.** Bytes on disk, and bytes as a single deflate level 9 zip, of: the
+jar and its dependencies; the jlink image plus the jars; the jpackage
+application image; the native build. The staged jar (what any Codename One
+builder is handed) is broken down by layer, and the translated C project is
+counted the same way, so the table shows how many of the compatibility
+runtime's classes dead-code elimination kept.
+
+**Start-up** (Linux). Every launch gets a private Xvfb with a window manager.
+The driver polls the X server and records three instants after `exec`:
+the application's window is mapped; the window's interior first shows three or
+more distinct colours (**first paint** -- the headline figure, since a mapped
+but blank window is not a started application); the picture stops changing.
+Cold and warm, seven launches each after a discarded primer, reported as
+median with minimum and maximum. Cold means the page cache was dropped
+(`/proc/sys/vm/drop_caches`, which needs real root) or, failing that, the
+application's own files -- its runtime image and jars, or its executable --
+were evicted with `posix_fadvise`; the result says which (`cold_method`).
+Rootless podman and a GitHub runner both get the second: the system libraries
+both variants share stay cached, so "cold" here is "this application has not
+run since boot", not "nothing has".
+
+**Memory** (Linux). RSS, PSS and USS summed over the application's process
+tree from `/proc/<pid>/smaps_rollup`, ten seconds after first paint and again
+after the input script; peak RSS from `/usr/bin/time -v`. Median of three
+sessions.
+
+**Idle CPU** (Linux). CPU time of the process tree over the second half of the
+idle window, as a share of one core, plus the number of polls at which the
+window's pixels changed. A Codename One application idling above 1% is flagged
+`DEFECT` in the report: something is repainting or polling with nothing to do.
+
+**Input script.** `input/<name>.txt`, or `input/default.txt`: clicks at
+window-relative positions and key presses through XTEST, identical for all
+three variants. The scripts are short because they must mean the same thing to
+two different toolkits' renderings of one application.
+
+A position is a fraction of the window, and that is not enough to press the
+same control in both builds: the native look is taller than Metal or Modena,
+so a control is not at the same fraction in the two windows. `default.txt`
+ignores this, and with it the two builds of one application can end up doing
+different work. A script written for one application names such a press once
+for each arm, with a `jvm:` or `cn1:` prefix; the driver plays the lines of
+the arm it measures and every line that has no prefix. Check a new script with
+`x11bench.py --check-only` against both builds and look at the two
+`check-after.png` before trusting the numbers it produces.
+
+On **macOS** nothing may be launched unattended on a developer's desktop, so
+`bench.sh --stage build` only builds and sizes. `run-macos-bench.sh` is the
+runtime half, run by hand (or by CI, which has a desktop session): start-up to
+the first on-screen window (`firstwindow.swift`; not first paint, which would
+need the Screen Recording permission), idle RSS and physical footprint, idle
+CPU, peak RSS. No scripted input. **Windows** has `win-measure.ps1`, the same
+reduced set, and has only ever run in CI.
+
+## Running it
+
+Linux, in the container the published numbers came from:
+
+```bash
+podman build -t bench-linux scripts/desktop-compat-benchmarks      # once
+# Codename One itself has to be in the Maven repository the run uses:
+#   cd maven && mvn -pl linux,parparvm,swing-compat,javafx-compat,fxml-compiler,\
+#     codenameone-maven-plugin,cn1app-archetype -am -Plocal-dev-javase \
+#     -DskipTests install
+scripts/desktop-compat-benchmarks/linux-container.sh run \
+  bash -c 'ARCH=$(dpkg --print-architecture)
+    export JAVA17_HOME=/usr/lib/jvm/java-17-openjdk-$ARCH
+    export BENCH_JDK21_HOME=/usr/lib/jvm/java-21-openjdk-$ARCH
+    export BENCH_JAVAFX_JMODS=$BENCH_TOOLS/javafx-jmods CN1_CC=$BENCH_TOOLS/cn1-zig-cc
+    export PATH=$BENCH_TOOLS/zig:$PATH BENCH_XVFB=1 BENCH_M2=$PWD/.m2-repo
+    scripts/desktop-compat-benchmarks/bench-samples.sh --work /work/bench --out /work/out'
+```
+
+One application, anywhere:
+
+```bash
+scripts/desktop-compat-benchmarks/bench.sh --app path/to/project --name myapp \
+  --kind swing --main com.example.Main --work /some/dir
+scripts/desktop-compat-benchmarks/report.py /some/dir/myapp/result.json
+```
+
+`bench.sh --help` lists the environment it reads. Every file it writes is below
+`--work`; set `BENCH_USER_HOME` to keep the Codename One plugin out of the real
+`~/.codenameone` as well. A native build takes a quarter of an hour per
+application on four cores, most of it the ThinLTO link.
+
+macOS:
+
+```bash
+scripts/desktop-compat-benchmarks/javafx-jmods.sh "$BENCH_JDK21_HOME" /some/dir/jmods
+BENCH_JAVAFX_JMODS=/some/dir/jmods scripts/desktop-compat-benchmarks/bench.sh --stage build ...
+scripts/desktop-compat-benchmarks/run-macos-bench.sh --work /some/dir --name myapp   # opens windows
+```
+
+iOS and Android, size only (no simulator, no emulator, nothing installed):
+
+```bash
+scripts/desktop-compat-benchmarks/mobile-size.sh --target ios \
+  --project /some/dir/myapp/cn1/app --work /some/dir/myapp-ios
+ANDROID_HOME=... scripts/desktop-compat-benchmarks/mobile-size.sh --target android \
+  --project /some/dir/myapp/cn1/app --work /some/dir/myapp-android
+```
+
+iOS is an unsigned Release build for a generic device (`CODE_SIGNING_ALLOWED=NO`);
+the JSON gives the `.app`, its zip, and the executable before and after
+`strip -x`. Android is `assembleRelease` of the generated Gradle project with
+R8 on, signed with the throwaway key that project carries.
+
+Every Maven invocation here passes `-Dopen=false`. Without it the Codename One
+plugin opens a generated Xcode or Android Studio project in the IDE.
+
+CI: `.github/workflows/desktop-compat-benchmarks.yml` runs the two in-tree
+samples on Linux, macOS and Windows and uploads `benchmarks-<os>.json` and
+`benchmarks-<os>.md`.
+
+## Files
+
+| File | |
+|---|---|
+| `bench.sh` | one application: both builds, sizes, and on Linux the measurements |
+| `bench-samples.sh` | the in-tree samples through `bench.sh`, then the two files CI uploads |
+| `x11bench.py` | the Linux driver: Xvfb, first-paint detection, input, memory, CPU |
+| `benchutil.py` | sizes, the layer breakdown, environment facts, result assembly |
+| `report.py` | `result.json` files to markdown or AsciiDoc tables |
+| `input/` | input scripts |
+| `Containerfile`, `install-linux-deps.sh`, `linux-container.sh` | the Linux environment |
+| `javafx-jmods.sh` | OpenJFX jmods from the platform jars on Maven Central |
+| `run-macos-bench.sh`, `firstwindow.swift` | the macOS runtime half |
+| `win-measure.ps1` | the Windows runtime half (CI only) |
+| `mobile-size.sh` | iOS `.app` and Android APK sizes of an imported application |
+
+## Reading the numbers honestly
+
+- **Ratios are baseline / Codename One.** Above 1 the native build is smaller
+  or faster by that factor; below 1 it lost, and the report prints it the same
+  way.
+- **The baseline is not handicapped.** It gets a minimal runtime image, and the
+  tuned variant gets every start-up and footprint switch a developer would
+  reasonably ship. If a flag would help the JVM and is missing, that is a bug in
+  this harness.
+- **Xvfb is a software framebuffer.** Neither toolkit has a GPU here. That
+  takes hardware-accelerated pipelines out of both columns; it does not favour
+  one, but absolute paint times on real hardware will differ.
+- **A window that paints is not an application that works.** The driver saves
+  a screenshot of the idle and the after-script state of the first session
+  (`logs/run-*/session-0-*.png`). Look at them before quoting a number: a
+  native build that shows an error dialog starts very quickly.
+- **The X server has had a GTK program on it.** The first GTK 3 program on an
+  X server initialises GL to choose its visuals and records the choice on the
+  root window; every later one reads it and loads no GL driver. A private Xvfb
+  made each launch that first program, and Mesa's llvmpipe was 53 MB of a
+  native Notepad's 108 MB resident set -- 56 MB when launched second. A desktop
+  session is past that point before any application starts, so the driver runs
+  one bare `gtk_init` on each new server first (`gtk_session` in every sample
+  says whether it could). A Swing baseline never loads GTK and is unaffected;
+  a JavaFX one loads GTK itself, and starts from the same server as the
+  native build it is compared with.
+- **RSS counts shared pages in full.** PSS is the fairer single-process figure;
+  USS is what quitting the application gives back.
+- **OpenJFX version.** The jmods default to OpenJFX 23.0.2, the oldest release
+  that both runs on JDK 21 and publishes a linux-aarch64 build, whatever
+  version the application's pom names.
diff --git a/scripts/desktop-compat-benchmarks/bench-samples.sh b/scripts/desktop-compat-benchmarks/bench-samples.sh
new file mode 100755
index 00000000000..bfabd469fef
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/bench-samples.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+#
+# Runs bench.sh over the samples that live in this repository and writes the two
+# files CI uploads:
+#
+#   OUT/benchmarks-<os>.json   every sample's result.json, in one document
+#   OUT/benchmarks-<os>.md     the same, as tables (report.py)
+#
+# Usage: bench-samples.sh --work DIR --out DIR [--stage all|build|measure]
+#                         [--startup-runs N] [--session-runs N]
+#
+# The environment is bench.sh's (JAVA17_HOME, BENCH_JDK21_HOME, ...). Only the
+# in-tree samples are built: third-party applications are never vendored, and a
+# benchmark anyone can re-run must not depend on a checkout nobody else has. To
+# measure another application, call bench.sh on it directly.
+set -euo pipefail
+
+HERE="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
+ROOT="$(CDPATH='' cd -- "$HERE/../.." && pwd)"
+SAMPLES="$ROOT/scripts/desktop-compat-samples"
+
+WORK="" OUT="" PASS=()
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --work) WORK="$2"; shift 2 ;;
+    --out) OUT="$2"; shift 2 ;;
+    --stage|--startup-runs|--session-runs|--heaps) PASS+=("$1" "$2"); shift 2 ;;
+    -h|--help) sed -n '2,17p' "$0"; exit 0 ;;
+    *) echo "bench-samples.sh: unknown argument $1" >&2; exit 2 ;;
+  esac
+done
+if [ -z "$WORK" ] || [ -z "$OUT" ]; then
+  echo "bench-samples.sh: --work and --out are required" >&2
+  exit 2
+fi
+mkdir -p "$WORK" "$OUT"
+
+case "$(uname -s)" in
+  Linux) OS_NAME="linux" ;;
+  Darwin) OS_NAME="macos" ;;
+  *) OS_NAME="windows" ;;
+esac
+
+# name | kind | main class
+SAMPLE_LIST="swing-gallery|swing|com.example.gallery.GalleryApp
+javafx-gallery|javafx|com.example.fxgallery.GalleryApp"
+
+RESULTS=()
+while IFS='|' read -r NAME KIND MAIN; do
+  [ -n "$NAME" ] || continue
+  # A sample that fails to build is a row with empty cells and a line under
+  # "Failures", not a missing row: bench.sh records the reason and goes on.
+  bash "$HERE/bench.sh" --app "$SAMPLES/$NAME" --name "$NAME" --kind "$KIND" --main "$MAIN" \
+    --work "$WORK" ${PASS[@]+"${PASS[@]}"} || echo "bench-samples.sh: bench.sh failed outright for $NAME" >&2
+  if [ -f "$WORK/$NAME/result.json" ]; then
+    RESULTS+=("$WORK/$NAME/result.json")
+  fi
+done <<EOF
+$SAMPLE_LIST
+EOF
+
+if [ "${#RESULTS[@]}" -eq 0 ]; then
+  echo "bench-samples.sh: no sample produced a result" >&2
+  exit 1
+fi
+python3 "$HERE/benchutil.py" collect "$OUT/benchmarks-$OS_NAME.json" "${RESULTS[@]}"
+python3 "$HERE/report.py" --out "$OUT/benchmarks-$OS_NAME.md" "${RESULTS[@]}"
+echo "wrote $OUT/benchmarks-$OS_NAME.json and $OUT/benchmarks-$OS_NAME.md"
diff --git a/scripts/desktop-compat-benchmarks/bench.sh b/scripts/desktop-compat-benchmarks/bench.sh
new file mode 100755
index 00000000000..005bc9fee45
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/bench.sh
@@ -0,0 +1,574 @@
+#!/usr/bin/env bash
+#
+# Builds one desktop Java application two ways and measures both:
+#
+#   baseline   the application as its developer ships it today -- its jar and
+#              dependencies, a jlink runtime image holding exactly the modules
+#              it needs, and a jpackage application image;
+#   cn1        the same, unmodified sources imported with
+#              cn1:import-desktop-project and built as a native executable by
+#              the local ParparVM builder (no JVM in the result).
+#
+# Usage:
+#   bench.sh --app DIR --name NAME --kind swing|javafx --main CLASS --work DIR
+#            [--out FILE] [--script FILE] [--stage all|build|baseline|measure]
+#            [--startup-runs N] [--session-runs N] [--heaps "8 12 16 ..."]
+#
+#   --app     the application's own Maven project (pom.xml + src/main). Never
+#             modified: it is read, and copied by the importer.
+#   --work    every file this script writes goes below DIR/NAME.
+#   --out     the result (default: DIR/NAME/result.json).
+#   --script  input script for x11bench.py (default: input/NAME.txt beside
+#             this script if it exists, else input/default.txt).
+#   --stage   build = sizes only, nothing is launched; baseline = rebuild the
+#             baseline and keep the native build; measure = reuse a finished
+#             build. On macOS only "build" exists: run-macos-bench.sh
+#             does the launching, by hand.
+#
+# Environment:
+#   JAVA17_HOME          JDK 17, builds the Codename One project   (required)
+#   BENCH_JDK21_HOME     JDK 21 with jmods, the baseline's JDK      (required)
+#   BENCH_JAVAFX_JMODS   OpenJFX jmods (javafx-jmods.sh)   (required for javafx)
+#   BENCH_M2             Maven local repository holding the Codename One
+#                        artifacts (default: Maven's own default)
+#   BENCH_USER_HOME      user.home for the Maven JVMs. The Codename One plugin
+#                        keeps tools in ~/.codenameone; set this to keep a
+#                        benchmark run out of the real one.
+#   CN1_VERSION          Codename One version to build with (8.0-SNAPSHOT)
+#   CN1_CC               C compiler for the native Linux build (the zig wrapper
+#                        from install-linux-deps.sh), read by the builder itself
+#   BENCH_XVFB           set to 1 to run Maven under xvfb-run (Linux; the CSS
+#                        compiler opens an AWT frame)
+set -euo pipefail
+
+HERE="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
+ROOT="$(CDPATH='' cd -- "$HERE/../.." && pwd)"
+
+APP="" NAME="" KIND="" MAIN="" WORK="" OUT="" SCRIPT="" STAGE="all"
+STARTUP_RUNS=7 SESSION_RUNS=3
+HEAPS="8 12 16 24 32 48 64 96 128 192 256 384 512"
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --app) APP="$2"; shift 2 ;;
+    --name) NAME="$2"; shift 2 ;;
+    --kind) KIND="$2"; shift 2 ;;
+    --main) MAIN="$2"; shift 2 ;;
+    --work) WORK="$2"; shift 2 ;;
+    --out) OUT="$2"; shift 2 ;;
+    --script) SCRIPT="$2"; shift 2 ;;
+    --stage) STAGE="$2"; shift 2 ;;
+    --startup-runs) STARTUP_RUNS="$2"; shift 2 ;;
+    --session-runs) SESSION_RUNS="$2"; shift 2 ;;
+    --heaps) HEAPS="$2"; shift 2 ;;
+    -h|--help) sed -n '2,45p' "$0"; exit 0 ;;
+    *) echo "bench.sh: unknown argument $1" >&2; exit 2 ;;
+  esac
+done
+for REQUIRED in APP NAME KIND MAIN WORK; do
+  if [ -z "${!REQUIRED}" ]; then
+    echo "bench.sh: --$(printf '%s' "$REQUIRED" | tr '[:upper:]' '[:lower:]') is required" >&2
+    exit 2
+  fi
+done
+case "$KIND" in swing|javafx) ;; *) echo "bench.sh: --kind is swing or javafx" >&2; exit 2 ;; esac
+: "${JAVA17_HOME:?JAVA17_HOME must name a JDK 17}"
+: "${BENCH_JDK21_HOME:?BENCH_JDK21_HOME must name a JDK 21}"
+if [ "$KIND" = "javafx" ]; then
+  : "${BENCH_JAVAFX_JMODS:?BENCH_JAVAFX_JMODS must name the OpenJFX jmods (javafx-jmods.sh)}"
+fi
+CN1_VERSION="${CN1_VERSION:-8.0-SNAPSHOT}"
+OS="$(uname -s)"
+
+APP="$(CDPATH='' cd -- "$APP" && pwd)"
+mkdir -p "$WORK/$NAME"
+D="$(CDPATH='' cd -- "$WORK/$NAME" && pwd)"
+OUT="${OUT:-$D/result.json}"
+PARTS="$D/parts" LOGS="$D/logs" TMP="$D/tmp"
+mkdir -p "$PARTS" "$LOGS" "$TMP"
+export TMPDIR="$TMP"
+if [ -z "$SCRIPT" ]; then
+  SCRIPT="$HERE/input/$NAME.txt"
+  [ -f "$SCRIPT" ] || SCRIPT="$HERE/input/default.txt"
+fi
+
+say() { printf '[bench %s] %s\n' "$NAME" "$*" >&2; }
+util() { python3 "$HERE/benchutil.py" "$@"; }
+# A failed step is a result, not the end of the run: the reason is recorded
+# and the cells that depended on the step stay empty.
+fail_part() { # <part> <default classification> <log>
+  util diagnose "$3" "$2" > "$PARTS/$1.json"
+  say "FAILED $1: $(python3 -c 'import json, sys; d = json.load(open(sys.argv[1])); print("%s: %s" % (d["classification"], d["first_error"]))' "$PARTS/$1.json") (see $3)"
+}
+
+# -Dopen=false: the Codename One plugin otherwise opens a generated Xcode or
+# Android Studio project in the IDE, and a benchmark must never open a window.
+MVN_ARGS=(-B -ntp -Dopen=false)
+if [ -n "${BENCH_M2:-}" ]; then
+  MVN_ARGS+=("-Dmaven.repo.local=$BENCH_M2")
+fi
+MVN_JVM="-Djava.io.tmpdir=$TMP"
+CN1_HOME_DIR="$HOME/.codenameone"
+if [ -n "${BENCH_USER_HOME:-}" ]; then
+  MVN_JVM="$MVN_JVM -Duser.home=$BENCH_USER_HOME"
+  CN1_HOME_DIR="$BENCH_USER_HOME/.codenameone"
+fi
+mvn_with() { # <java-home> <maven args...>
+  local JDK="$1"
+  shift
+  if [ "${BENCH_XVFB:-0}" = "1" ]; then
+    JAVA_HOME="$JDK" PATH="$JDK/bin:$PATH" MAVEN_OPTS="$MVN_JVM" xvfb-run -a mvn "${MVN_ARGS[@]}" "$@"
+  else
+    JAVA_HOME="$JDK" PATH="$JDK/bin:$PATH" MAVEN_OPTS="$MVN_JVM" mvn "${MVN_ARGS[@]}" "$@"
+  fi
+}
+
+BASE="$D/baseline"
+CN1="$D/cn1"
+J21="$BENCH_JDK21_HOME/bin"
+
+# ---------------------------------------------------------------------------
+# Baseline: jar + dependencies, jlink runtime image, jpackage application image
+
+fx_modules() {
+  # javafx.controls always (it pulls graphics and base); the rest only when the
+  # sources name them, so the runtime image holds what the application uses.
+  local MODULES="javafx.controls" PAIR MODULE PATTERN
+  for PAIR in "fxml:javafx.fxml" "media:javafx.scene.media" "swing:javafx.embed.swing"; do
+    MODULE="${PAIR%%:*}"
+    PATTERN="${PAIR#*:}"
+    if grep -rqs --include='*.java' "import ${PATTERN}" "$APP/src/main/java" \
+        || { [ "$MODULE" = "fxml" ] && find "$APP/src/main" -name '*.fxml' | grep -q .; }; then
+      MODULES="$MODULES,javafx.$MODULE"
+    fi
+  done
+  printf '%s' "$MODULES"
+}
+
+build_baseline() {
+  local LOG="$LOGS/baseline-build.log"
+  rm -rf "$BASE"
+  mkdir -p "$BASE/app" "$BASE/classes"
+  say "baseline: dependencies"
+  # The application's own pom decides its dependencies. OpenJFX is left out:
+  # it comes from the jmods, as part of the runtime image.
+  # The OpenJFX dependencies are cut out of a copy of the pom rather than
+  # excluded on the command line: an exclusion still resolves them first, and
+  # OpenJFX publishes no artifact at all for some version/architecture pairs.
+  mkdir -p "$BASE/pom"
+  python3 - "$APP/pom.xml" "$BASE/pom/pom.xml" <<'PY'
+import re, sys
+with open(sys.argv[1], encoding="utf-8") as handle:
+    pom = handle.read()
+pom = re.sub(r"<build>.*?</build>", "", pom, flags=re.S)
+pom = re.sub(r"<dependency>(?:(?!</dependency>).)*?<groupId>\s*org\.openjfx\s*</groupId>.*?</dependency>",
+             "", pom, flags=re.S)
+with open(sys.argv[2], "w", encoding="utf-8") as handle:
+    handle.write(pom)
+PY
+  if ! mvn_with "$BENCH_JDK21_HOME" -q -f "$BASE/pom/pom.xml" dependency:copy-dependencies \
+      "-DoutputDirectory=$BASE/app" -DincludeScope=runtime \
+      "-Dmdep.stripClassifier=false" > "$LOG" 2>&1; then
+    fail_part baseline "baseline build" "$LOG"
+    return 1
+  fi
+  local CP="" JAR
+  for JAR in "$BASE/app"/*.jar; do
+    [ -f "$JAR" ] && CP="$CP:$JAR"
+  done
+  CP="${CP#:}"
+  local FX=() FXMODS=""
+  if [ "$KIND" = "javafx" ]; then
+    FXMODS="$(fx_modules)"
+    FX=(--module-path "$BENCH_JAVAFX_JMODS" --add-modules "$FXMODS")
+  fi
+  say "baseline: compile"
+  # On the class path, without the module descriptor: the same sources then
+  # build whether or not their author wrote one, and the importer ignores it too.
+  find "$APP/src/main/java" -name '*.java' ! -name 'module-info.java' > "$BASE/sources.txt"
+  if ! "$J21/javac" -nowarn -encoding UTF-8 --release 17 -d "$BASE/classes" ${CP:+-cp "$CP"} \
+      ${FX[@]+"${FX[@]}"} "@$BASE/sources.txt" >> "$LOG" 2>&1; then
+    fail_part baseline "baseline build" "$LOG"
+    return 1
+  fi
+  if [ -d "$APP/src/main/resources" ]; then
+    cp -R "$APP/src/main/resources/." "$BASE/classes/"
+  fi
+  "$J21/jar" --create --file "$BASE/app/$NAME.jar" --main-class "$MAIN" -C "$BASE/classes" . >> "$LOG" 2>&1
+
+  say "baseline: jlink"
+  local MODULES
+  # jdeps is not given the OpenJFX modules: it cannot read a jmod from a module
+  # path. The javafx.* packages are therefore "missing" and ignored here, and
+  # the modules the sources name are added below.
+  if ! MODULES="$("$J21/jdeps" --ignore-missing-deps --multi-release 17 --print-module-deps \
+      ${CP:+-cp "$CP"} "$BASE/app"/*.jar 2>> "$LOG")"; then
+    fail_part baseline "baseline build" "$LOG"
+    return 1
+  fi
+  if [ -n "$FXMODS" ]; then
+    MODULES="$MODULES,$FXMODS"
+  fi
+  local LINK_PATH="$BENCH_JDK21_HOME/jmods"
+  if [ "$KIND" = "javafx" ]; then
+    LINK_PATH="$LINK_PATH:$BENCH_JAVAFX_JMODS"
+  fi
+  if ! "$J21/jlink" --module-path "$LINK_PATH" --add-modules "$MODULES" \
+      --strip-debug --no-header-files --no-man-pages --compress zip-6 \
+      --output "$BASE/runtime" >> "$LOG" 2>&1; then
+    fail_part baseline "baseline build" "$LOG"
+    return 1
+  fi
+  printf '%s\n' "$MODULES" > "$BASE/modules.txt"
+
+  say "baseline: jpackage"
+  local JPACKAGE_OK=1
+  if ! "$J21/jpackage" --type app-image --name "$NAME" --input "$BASE/app" \
+      --main-jar "$NAME.jar" --main-class "$MAIN" --runtime-image "$BASE/runtime" \
+      --dest "$BASE/jpackage" >> "$LOG" 2>&1; then
+    JPACKAGE_OK=0
+    say "jpackage failed here; its cells stay empty (see $LOG)"
+  fi
+
+  # Sizes are taken now, before anything below adds a CDS archive: the archive
+  # is a start-up optimisation the developer may or may not ship, and leaving it
+  # out is the smaller, more favourable figure for the baseline.
+  util size --scratch "$TMP" "$BASE/app" > "$PARTS/size.baseline_jars.json"
+  util size --scratch "$TMP" "$BASE/runtime" > "$PARTS/size.baseline_runtime_image.json"
+  util size --scratch "$TMP" "$BASE/runtime" "$BASE/app" > "$PARTS/size.baseline_jlink.json"
+  if [ "$JPACKAGE_OK" = "1" ]; then
+    util size --scratch "$TMP" "$BASE/jpackage" > "$PARTS/size.baseline_jpackage.json"
+  fi
+
+  # The JDK's default CDS archive. A distribution JDK has one and a jlink image
+  # does not, so without this "default flags" would time a slower JVM than the
+  # one a developer starts with `java -jar`.
+  "$BASE/runtime/bin/java" -Xshare:dump >> "$LOG" 2>&1 || say "default CDS archive not generated"
+  util size --scratch "$TMP" "$BASE/runtime" "$BASE/app" > "$PARTS/size.baseline_jlink_with_cds.json"
+
+  python3 - "$PARTS/baseline.json" "$MODULES" "$MAIN" <<'PY'
+import json, sys
+with open(sys.argv[1], "w") as handle:
+    json.dump({"ok": True, "modules": sys.argv[2].split(","), "main_class": sys.argv[3],
+               "jlink_flags": "--strip-debug --no-header-files --no-man-pages --compress zip-6",
+               "javac_flags": "--release 17, class path (module-info.java left out)"},
+              handle, indent=2)
+PY
+}
+
+# ---------------------------------------------------------------------------
+# Codename One: archetype + import-desktop-project + the local native builder
+
+prepare_cn1_home() {
+  mkdir -p "$CN1_HOME_DIR"
+  # generate-gui-sources insists on both files existing; neither is used by a
+  # project that has no GUI builder forms. setup-workspace.sh does the same.
+  [ -f "$CN1_HOME_DIR/guibuilder.jar" ] || : > "$CN1_HOME_DIR/guibuilder.jar"
+  if [ ! -f "$CN1_HOME_DIR/CodeNameOneBuildClient.jar" ]; then
+    cp "$ROOT/maven/CodeNameOneBuildClient.jar" "$CN1_HOME_DIR/CodeNameOneBuildClient.jar"
+  fi
+}
+
+generate_cn1_project() {
+  local LOG="$LOGS/cn1-generate.log"
+  rm -rf "$CN1"
+  mkdir -p "$CN1"
+  prepare_cn1_home
+  say "cn1: archetype"
+  if ! (cd "$CN1" && mvn_with "$JAVA17_HOME" archetype:generate \
+      -DarchetypeGroupId=com.codenameone -DarchetypeArtifactId=cn1app-archetype \
+      "-DarchetypeVersion=$CN1_VERSION" -DgroupId=com.codenameone.bench -DartifactId=app \
+      -Dpackage=com.codenameone.bench -Dversion=1.0-SNAPSHOT -DmainName=BenchApp \
+      -DjavaVersion=17 -DinteractiveMode=false) > "$LOG" 2>&1; then
+    fail_part cn1 "project generation" "$LOG"
+    return 1
+  fi
+  say "cn1: import-desktop-project"
+  if ! (cd "$CN1/app" && mvn_with "$JAVA17_HOME" \
+      "com.codenameone:codenameone-maven-plugin:$CN1_VERSION:import-desktop-project" \
+      "-Dcn1.desktop.import=$APP") >> "$LOG" 2>&1; then
+    fail_part cn1 "import" "$LOG"
+    return 1
+  fi
+}
+
+build_cn1_linux() {
+  local LOG="$LOGS/cn1-linux-build.log" ARCH
+  case "$(uname -m)" in aarch64|arm64) ARCH="arm64" ;; *) ARCH="x64" ;; esac
+  # The builder's default is x64 whatever the host is.
+  printf '\ncodename1.arg.linux.arch=%s\n' "$ARCH" >> "$CN1/app/common/codenameone_settings.properties"
+  say "cn1: native Linux build ($ARCH)"
+  if ! (cd "$CN1/app" && mvn_with "$JAVA17_HOME" package -DskipTests \
+      -Dcodename1.platform=linux -Dcodename1.buildTarget=local-linux-device) > "$LOG" 2>&1; then
+    fail_part cn1 "layer or build-engine" "$LOG"
+    return 1
+  fi
+  local EXE
+  EXE="$(sed -n 's/.*Built native Linux executable: //p' "$LOG" | tail -1)"
+  if [ -z "$EXE" ] || [ ! -f "$EXE" ]; then
+    fail_part cn1 "native compile or link" "$LOG"
+    return 1
+  fi
+  # The distributable is the executable's directory as the builder left it,
+  # minus what only a developer wants (a separate debug-symbol companion).
+  rm -rf "$CN1/dist"
+  mkdir -p "$CN1/dist"
+  cp -R "$(dirname "$EXE")/." "$CN1/dist/"
+  find "$CN1/dist" -name '*.debug' -delete
+  printf '%s\n' "$(basename "$EXE")" > "$CN1/executable.txt"
+  record_cn1 "$EXE" "$LOG" linux
+}
+
+record_cn1() { # <executable-or-bundle> <log> <target>
+  local PRODUCT="$1" LOG="$2" TARGET="$3" JAR TRANSLATED
+  util size --scratch "$TMP" "$CN1/dist" > "$PARTS/size.cn1_$TARGET.json"
+  JAR="$(find "$CN1/app" -name '*-jar-with-dependencies.jar' -path '*target*' | head -1)"
+  if [ -n "$JAR" ]; then
+    util layers "$JAR" > "$PARTS/layers.staged_jar.json"
+  fi
+  TRANSLATED="$(find "$CN1/app" -type d -path '*-build*' -name 'dist' | head -1)"
+  if [ -n "$TRANSLATED" ]; then
+    util translated "$TRANSLATED" > "$PARTS/layers.translated_$TARGET.json"
+  fi
+  python3 - "$PARTS/cn1_$TARGET.json" "$PRODUCT" "$LOG" <<'PY'
+import json, os, re, subprocess, sys
+product, log = sys.argv[2], sys.argv[3]
+info = {"ok": True, "product": os.path.basename(product)}
+if os.path.isfile(product):
+    info["executable_bytes"] = os.path.getsize(product)
+    try:
+        out = subprocess.run(["size", product], stdout=subprocess.PIPE, universal_newlines=True).stdout
+        fields = out.splitlines()[1].split()
+        info["text_bytes"], info["data_bytes"], info["bss_bytes"] = (int(f) for f in fields[:3])
+    except Exception:
+        pass
+    try:
+        out = subprocess.run(["file", "-b", product], stdout=subprocess.PIPE,
+                             universal_newlines=True).stdout.strip()
+        info["file"] = out.splitlines()[0] if out else out
+        if "ELF" in out:
+            info["stripped"] = "not stripped" not in out
+    except Exception:
+        pass
+    try:
+        # A universal Mac binary: the size of each slice, since a developer
+        # who ships one architecture ships about half of the file.
+        out = subprocess.run(["lipo", "-detailed_info", product], stdout=subprocess.PIPE,
+                             stderr=subprocess.DEVNULL, universal_newlines=True).stdout
+        slices = dict((name, int(size)) for name, size in
+                      re.findall(r"architecture (\S+).*?\n\s+size (\d+)", out, re.S))
+        if slices:
+            info["slice_bytes"] = slices
+    except Exception:
+        pass
+with open(log, errors="replace") as handle:
+    text = handle.read()
+flags = re.findall(r"-DCMAKE_BUILD_TYPE=\w+", text)
+if flags:
+    info["cmake_build_type"] = flags[-1].split("=")[1]
+with open(sys.argv[1], "w") as handle:
+    json.dump(info, handle, indent=2)
+PY
+}
+
+build_cn1_macos() {
+  local LOG="$LOGS/cn1-macos-build.log"
+  # Unsigned, on purpose: the builder otherwise looks for a "Developer ID
+  # Application" certificate, and a benchmark must neither need one nor use the
+  # one it finds in the keychain of whoever runs it. The slice is universal (arm64 +
+  # x86_64), the builder's default, so the bundle is what a developer would ship.
+  printf '\ncodename1.arg.macos.signingIdentity.developerID=none\n' \
+    >> "$CN1/app/common/codenameone_settings.properties"
+  say "cn1: native macOS build"
+  # The AppKit build rides the "ios" platform profile of the generated project;
+  # the build target is what makes it a Mac application.
+  if ! (cd "$CN1/app" && mvn_with "$JAVA17_HOME" package -DskipTests \
+      -Dcodename1.platform=ios -Dcodename1.buildTarget=local-mac-device) > "$LOG" 2>&1; then
+    fail_part cn1 "layer or build-engine" "$LOG"
+    return 1
+  fi
+  local BUNDLE
+  BUNDLE="$(find "$CN1/app" -type d -name '*.app' -path '*Release*' -not -path '*/*.app/*' | head -1)"
+  if [ -z "$BUNDLE" ]; then
+    BUNDLE="$(find "$CN1/app" -type d -name '*.app' -not -path '*/*.app/*' | head -1)"
+  fi
+  if [ -z "$BUNDLE" ]; then
+    fail_part cn1 "native compile or link" "$LOG"
+    return 1
+  fi
+  rm -rf "$CN1/dist"
+  mkdir -p "$CN1/dist"
+  cp -R "$BUNDLE" "$CN1/dist/"
+  find "$CN1/dist" -name '*.dSYM' -prune -exec rm -rf {} +
+  printf '%s\n' "$(basename "$BUNDLE")" > "$CN1/executable.txt"
+  record_cn1 "$CN1/dist/$(basename "$BUNDLE")/Contents/MacOS/$(basename "$BUNDLE" .app)" "$LOG" macos
+  # The jlink baseline holds the runtime of this machine's architecture only,
+  # so size a copy of the bundle with only that slice of the executable too:
+  # a universal bundle against one architecture is not like for like. The
+  # chapter compares size.cn1_macos_thin with the jlink image.
+  local THIN="$TMP/cn1-macos-thin" ARCH THIN_EXE
+  ARCH="$(uname -m)"
+  rm -rf "$THIN"
+  mkdir -p "$THIN"
+  cp -R "$CN1/dist/." "$THIN/"
+  THIN_EXE="$THIN/$(basename "$BUNDLE")/Contents/MacOS/$(basename "$BUNDLE" .app)"
+  if lipo "$THIN_EXE" -thin "$ARCH" -output "$THIN_EXE.thin" 2>/dev/null; then
+    mv "$THIN_EXE.thin" "$THIN_EXE"
+    util size --scratch "$TMP" "$THIN" > "$PARTS/size.cn1_macos_thin.json"
+  fi
+  rm -rf "$THIN"
+}
+
+build_cn1_windows() {
+  # Only CI runs this (a windows-latest runner with the MSVC environment and
+  # clang-cl on PATH, under Git Bash); it has never been run on a developer box.
+  local LOG="$LOGS/cn1-windows-build.log" EXE
+  say "cn1: native Windows build"
+  if ! (cd "$CN1/app" && mvn_with "$JAVA17_HOME" package -DskipTests \
+      -Dcodename1.platform=win -Dcodename1.buildTarget=local-windows-device) > "$LOG" 2>&1; then
+    fail_part cn1 "layer or build-engine" "$LOG"
+    return 1
+  fi
+  EXE="$(sed -n 's/.*Native Windows executable: \(.*\) ([a-z0-9]*).*/\1/p' "$LOG" | tail -1 | tr -d '\r')"
+  if [ -n "$EXE" ] && command -v cygpath > /dev/null 2>&1; then
+    EXE="$(cygpath -u "$EXE")"
+  fi
+  if [ -z "$EXE" ] || [ ! -f "$EXE" ]; then
+    fail_part cn1 "native compile or link" "$LOG"
+    return 1
+  fi
+  # The executable and the libraries beside it; the directory also holds the
+  # objects it was linked from, which nobody ships.
+  rm -rf "$CN1/dist"
+  mkdir -p "$CN1/dist"
+  cp "$EXE" "$CN1/dist/"
+  find "$(dirname "$EXE")" -maxdepth 1 -name '*.dll' -exec cp {} "$CN1/dist/" \;
+  printf '%s\n' "$(basename "$EXE")" > "$CN1/executable.txt"
+  record_cn1 "$EXE" "$LOG" windows
+}
+
+# ---------------------------------------------------------------------------
+# Measurement (Linux): three variants through the same driver
+
+JVM_BASE=()
+measure_variant() { # <label> <evict-path> <command...>
+  local LABEL="$1" EVICT="$2"
+  shift 2
+  say "measure: $LABEL"
+  python3 "$HERE/x11bench.py" --label "$LABEL" --out "$PARTS/run.$LABEL.json" \
+    --log-dir "$LOGS/run-$LABEL" --cwd "$D" --script "$SCRIPT" \
+    --startup-runs "$STARTUP_RUNS" --session-runs "$SESSION_RUNS" \
+    --screen "${BENCH_SCREEN:-1280x800}" --evict "$EVICT" -- "$@" \
+    || say "measure: $LABEL did not complete (recorded in run.$LABEL.json)"
+}
+
+exception_lines() { # <log>: how many lines name a Java exception or error
+  local COUNT=0
+  if [ -f "$1" ]; then
+    COUNT="$(grep -c -E '(Exception|Error)(:|$)' "$1" || true)"
+  fi
+  printf '%s' "${COUNT:-0}"
+}
+
+measure_linux() {
+  export BENCH_SCREEN="${BENCH_SCREEN:-1280x800}"
+  if [ -f "$PARTS/baseline.json" ] && grep -q '"ok": true' "$PARTS/baseline.json"; then
+    local CP="" JAR
+    for JAR in "$BASE/app"/*.jar; do
+      CP="$CP:$JAR"
+    done
+    CP="${CP#:}"
+    JVM_BASE=("$BASE/runtime/bin/java" -cp "$CP")
+    measure_variant jvm_default "$BASE" "${JVM_BASE[@]}" "$MAIN"
+
+    # Tuned: the smallest configuration a developer could reasonably ship.
+    # AppCDS first (a training run through the same input script), then the
+    # smallest heap from the list that still survives that script.
+    local TUNED=(-XX:+UseSerialGC -Xss256k -XX:TieredStopAtLevel=1) JSA="$BASE/app.jsa" HEAP FOUND=""
+    rm -f "$JSA"
+    python3 "$HERE/x11bench.py" --label train --out "$TMP/train.json" --log-dir "$LOGS/run-train" \
+      --cwd "$D" --script "$SCRIPT" --check-only -- \
+      "${JVM_BASE[@]}" "${TUNED[@]}" "-XX:ArchiveClassesAtExit=$JSA" "$MAIN" || true
+    if [ -f "$JSA" ]; then
+      TUNED+=("-XX:SharedArchiveFile=$JSA")
+    else
+      say "AppCDS archive was not written; tuned run uses the default archive only"
+    fi
+    # A heap is big enough when the application paints, survives the script
+    # and logs no more exceptions than it does with no limit at all. Looking
+    # for OutOfMemoryError alone is not enough: JavaFX under a heap too small
+    # for its textures paints once and then throws a NullPointerException from
+    # the renderer on every frame.
+    local QUIET LOUD
+    QUIET="$(exception_lines "$LOGS/run-train/check.log")"
+    for HEAP in $HEAPS; do
+      if python3 "$HERE/x11bench.py" --label "heap$HEAP" --out "$TMP/heap$HEAP.json" \
+          --log-dir "$LOGS/run-heap-search" --cwd "$D" --script "$SCRIPT" --check-only -- \
+          "${JVM_BASE[@]}" "${TUNED[@]}" "-Xmx${HEAP}m" "$MAIN"; then
+        LOUD="$(exception_lines "$LOGS/run-heap-search/check.log")"
+        if [ "$LOUD" -le "$QUIET" ]; then
+          FOUND="$HEAP"
+          break
+        fi
+      fi
+    done
+    if [ -n "$FOUND" ]; then
+      TUNED+=("-Xmx${FOUND}m")
+      measure_variant jvm_tuned "$BASE" "${JVM_BASE[@]}" "${TUNED[@]}" "$MAIN"
+      python3 - "$PARTS/tuned.json" "$FOUND" "$JSA" "${TUNED[*]}" <<'PY'
+import json, os, sys
+jsa = sys.argv[3]
+with open(sys.argv[1], "w") as handle:
+    json.dump({"xmx_mb": int(sys.argv[2]), "flags": sys.argv[4].replace(os.path.dirname(jsa) + "/", ""),
+               "appcds_bytes": os.path.getsize(jsa) if os.path.isfile(jsa) else None},
+              handle, indent=2)
+PY
+    else
+      say "no heap in [$HEAPS] ran the script; jvm_tuned stays empty"
+    fi
+  fi
+  if [ -f "$CN1/executable.txt" ]; then
+    measure_variant cn1_native "$CN1/dist" "$CN1/dist/$(cat "$CN1/executable.txt")"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+
+BENCH_COMMIT="${BENCH_COMMIT:-$(git -C "$ROOT" rev-parse HEAD 2>/dev/null || true)}"
+export BENCH_COMMIT
+
+if [ "$STAGE" = "baseline" ]; then
+  rm -f "$PARTS"/baseline.json "$PARTS"/size.baseline_*.json
+  build_baseline || true
+elif [ "$STAGE" != "measure" ]; then
+  rm -f "$PARTS"/*.json
+  build_baseline || true
+  if generate_cn1_project; then
+    case "$OS" in
+      Linux) build_cn1_linux || true ;;
+      Darwin) build_cn1_macos || true ;;
+      MINGW*|MSYS*|CYGWIN*) build_cn1_windows || true ;;
+      *) say "no native builder is wired for $OS" ;;
+    esac
+  fi
+fi
+if [ "$STAGE" != "build" ] && [ "$STAGE" != "baseline" ]; then
+  case "$OS" in
+    Linux) rm -f "$PARTS"/run.*.json "$PARTS/tuned.json"; measure_linux ;;
+    *) say "nothing is launched on $OS by this script; see run-macos-bench.sh" ;;
+  esac
+fi
+
+util environment > "$PARTS/environment.json"
+case "$OS" in
+  Linux) TARGET="linux" ;;
+  Darwin) TARGET="macos" ;;
+  *) TARGET="windows" ;;
+esac
+python3 - "$PARTS/app.json" "$NAME" "$KIND" "$MAIN" "$(basename "$SCRIPT")" "$TARGET" <<'PY'
+import json, sys
+with open(sys.argv[1], "w") as handle:
+    json.dump({"name": sys.argv[2], "kind": sys.argv[3], "main_class": sys.argv[4],
+               "input_script": sys.argv[5], "target": sys.argv[6]}, handle, indent=2)
+PY
+util assemble "$PARTS" "$OUT"
+say "wrote $OUT"
diff --git a/scripts/desktop-compat-benchmarks/benchutil.py b/scripts/desktop-compat-benchmarks/benchutil.py
new file mode 100755
index 00000000000..c9efd82e182
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/benchutil.py
@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""Size accounting and result assembly for the desktop-compat benchmarks.
+
+Subcommands, each printing or writing JSON:
+
+  size PATH...          bytes on disk and bytes as one deflated zip
+  layers JAR            what the compatibility runtime contributes to a jar
+  translated DIR        which classes survived into the translated C project
+  environment           the machine the numbers were taken on
+  assemble DIR OUT      merge the per-step JSON files of one application
+  collect OUT RESULT... several applications' results in one document
+  diagnose LOG DEFAULT  why a build log failed: first telling line and a class
+
+Python 3.9 compatible, standard library only.
+"""
+
+import argparse
+import json
+import os
+import platform
+import re
+import subprocess
+import sys
+import tempfile
+import zipfile
+
+# Class-name prefixes, as they appear in a staged (relocated) jar, of each part
+# of the runtime an imported desktop application ships.
+LAYERS = [
+    ("swing-compat", ("com/codename1/desktopcompat/",)),
+    ("javafx-compat", ("com/codename1/fxcompat/",)),
+    ("generated", ("com/codename1/generated/",)),
+    ("codenameone-core", ("com/codename1/",)),
+    ("java-api", ("java/", "javax/", "sun/", "kotlin/")),
+]
+
+
+def layer_of(class_path):
+    for name, prefixes in LAYERS:
+        for prefix in prefixes:
+            if class_path.startswith(prefix):
+                return name
+    return "application"
+
+
+def walk_files(path):
+    if os.path.isfile(path) or os.path.islink(path):
+        yield path, os.path.basename(path)
+        return
+    base = os.path.dirname(os.path.abspath(path))
+    for folder, dirs, files in os.walk(path):
+        dirs.sort()
+        # A symlinked directory is reported by os.walk under dirs and not
+        # descended into; record the link itself, as a bundle ships it.
+        for name in sorted(files) + [d for d in dirs if os.path.islink(os.path.join(folder, d))]:
+            full = os.path.join(folder, name)
+            yield full, os.path.relpath(full, base)
+
+
+def measure_size(paths, scratch):
+    """Uncompressed bytes and the size of a single deflate -9 zip of the paths."""
+    total = 0
+    count = 0
+    handle, archive = tempfile.mkstemp(suffix=".zip", dir=scratch)
+    os.close(handle)
+    try:
+        with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED, compresslevel=9) as bundle:
+            for path in paths:
+                for full, relative in walk_files(path):
+                    count += 1
+                    if os.path.islink(full):
+                        target = os.readlink(full)
+                        total += len(target)
+                        info = zipfile.ZipInfo(relative)
+                        info.external_attr = 0o120777 << 16
+                        bundle.writestr(info, target)
+                    else:
+                        total += os.path.getsize(full)
+                        bundle.write(full, relative)
+        zipped = os.path.getsize(archive)
+    finally:
+        os.remove(archive)
+    return {"files": count, "bytes": total, "zip_bytes": zipped}
+
+
+def jar_layers(jar):
+    """Per-layer class count and bytes of a jar."""
+    layers = {}
+    resources = {"files": 0, "bytes": 0, "compressed_bytes": 0}
+    with zipfile.ZipFile(jar) as bundle:
+        for entry in bundle.infolist():
+            if entry.filename.endswith("/"):
+                continue
+            if entry.filename.endswith(".class"):
+                bucket = layers.setdefault(layer_of(entry.filename),
+                                           {"classes": 0, "bytes": 0, "compressed_bytes": 0})
+                bucket["classes"] += 1
+            else:
+                bucket = resources
+                bucket["files"] += 1
+            bucket["bytes"] += entry.file_size
+            bucket["compressed_bytes"] += entry.compress_size
+    return {"jar": os.path.basename(jar), "jar_bytes": os.path.getsize(jar),
+            "classes": layers, "resources": resources}
+
+
+CLASS_DEFINITION = re.compile(r"^struct clazz class__([A-Za-z0-9_]+) = \{", re.M)
+
+
+def translated_layers(directory):
+    """Classes that reached the translated C project, by layer.
+
+    ParparVM emits one `struct clazz class__<mangled name> = {` definition per
+    class that survives its dead-code pass. The definitions are counted rather
+    than the files, because the Apple builds concatenate many classes into one
+    file. Counting them against the classes in the staged jar is the measure of
+    what was stripped.
+    """
+    prefixes = [(name, tuple(p.replace("/", "_") for p in group)) for name, group in LAYERS]
+    layers = {}
+    seen = set()
+    for folder, dirs, files in os.walk(directory):
+        # Build products: objects and indexes, not translator output.
+        dirs[:] = [d for d in dirs if d not in ("build", "DerivedData")]
+        for name in files:
+            if not name.endswith((".c", ".m")):
+                continue
+            with open(os.path.join(folder, name), errors="replace") as handle:
+                text = handle.read()
+            for mangled in CLASS_DEFINITION.findall(text):
+                if mangled in seen:
+                    continue
+                seen.add(mangled)
+                layer = "application"
+                for candidate, group in prefixes:
+                    if any(mangled.startswith(p) for p in group):
+                        layer = candidate
+                        break
+                bucket = layers.setdefault(layer, {"classes": 0})
+                bucket["classes"] += 1
+    return layers
+
+
+NOISE = re.compile(r"Prohibited package name|is not a native interface|Parsing: |Building C(XX)? object|"
+                   r"^\s+at |warning: ")
+DIAGNOSES = [
+    ("builder time limit", re.compile(r"Process timed out|Timeout reached")),
+    ("unsupported API", re.compile(r"bytecode-compliance.*(ERROR|FAIL)|\[ERROR\].*is not supported on")),
+    ("ParparVM translation", re.compile(r"Multiple main classes|tools\.translator\.|ByteCodeTranslator.*(Exception|rror)")),
+    ("native compile or link", re.compile(r": error: |ld(\.lld|64)?: error|undefined symbol|Undefined symbols|"
+                                          r"ninja: build stopped|\*\* BUILD FAILED \*\*|fatal error")),
+    ("javac", re.compile(r"COMPILATION ERROR|\.java:\[?\d+.*error")),
+]
+FALLBACK = re.compile(r"\[ERROR\] Failed to execute goal|Exception in thread|Exception: |\[ERROR\] \S|error:")
+
+
+def diagnose(log, default):
+    """The first line of a build log that says why it failed, and what kind of failure it is.
+
+    A heuristic, and labelled as one: the classification is where to start
+    reading, not a verdict. The full log is kept beside the result.
+    """
+    with open(log, errors="replace") as handle:
+        lines = [line.rstrip() for line in handle if not NOISE.search(line)]
+    for classification, pattern in DIAGNOSES:
+        for line in lines:
+            if pattern.search(line):
+                return {"classification": classification, "first_error": line.strip()[:600]}
+    for line in lines:
+        if FALLBACK.search(line):
+            return {"classification": default, "first_error": line.strip()[:600]}
+    return {"classification": default, "first_error": ""}
+
+
+def run(command):
+    try:
+        return subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                              universal_newlines=True, timeout=60).stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+
+def first_line(text):
+    return text.splitlines()[0] if text else None
+
+
+def environment():
+    facts = {
+        "system": platform.system(),
+        "kernel": platform.release(),
+        "machine": platform.machine(),
+        "python": platform.python_version(),
+        "cpus": os.cpu_count(),
+        "commit": os.environ.get("BENCH_COMMIT"),
+        "container_image": os.environ.get("BENCH_IMAGE_NAME"),
+        "in_container": os.path.exists("/run/.containerenv") or os.path.exists("/.dockerenv"),
+        "screen": os.environ.get("BENCH_SCREEN"),
+    }
+    if platform.system() == "Linux":
+        try:
+            with open("/etc/os-release") as handle:
+                for line in handle:
+                    if line.startswith("PRETTY_NAME="):
+                        facts["os"] = line.split("=", 1)[1].strip().strip('"')
+        except OSError:
+            pass
+        try:
+            with open("/proc/meminfo") as handle:
+                facts["ram_kb"] = int(handle.readline().split()[1])
+        except (OSError, ValueError, IndexError):
+            pass
+        model = None
+        try:
+            with open("/proc/cpuinfo") as handle:
+                for line in handle:
+                    if line.lower().startswith(("model name", "cpu part", "hardware")):
+                        model = line.split(":", 1)[1].strip()
+                        if line.lower().startswith("model name"):
+                            break
+        except OSError:
+            pass
+        facts["cpu"] = model
+        facts["host_cpu"] = os.environ.get("BENCH_HOST_CPU")
+        facts["gtk"] = run(["pkg-config", "--modversion", "gtk+-3.0"])
+    elif platform.system() == "Darwin":
+        facts["os"] = "macOS " + platform.mac_ver()[0]
+        facts["cpu"] = run(["sysctl", "-n", "machdep.cpu.brand_string"])
+        ram = run(["sysctl", "-n", "hw.memsize"])
+        facts["ram_kb"] = int(ram) // 1024 if ram and ram.isdigit() else None
+        facts["xcode"] = (run(["xcodebuild", "-version"]) or "").replace("\n", ", ")
+    for key, variable in (("baseline_jdk", "BENCH_JDK21_HOME"), ("cn1_build_jdk", "JAVA17_HOME")):
+        home = os.environ.get(variable)
+        if home:
+            facts[key] = first_line(run([os.path.join(home, "bin", "java"), "--version"]))
+    jmods = os.environ.get("BENCH_JAVAFX_JMODS")
+    if jmods and os.path.isfile(os.path.join(jmods, "VERSION")):
+        with open(os.path.join(jmods, "VERSION")) as handle:
+            facts["openjfx"] = handle.read().strip()
+    compiler = os.environ.get("CN1_CC")
+    if compiler:
+        facts["cn1_c_compiler"] = compiler
+        facts["cn1_c_compiler_version"] = first_line(run([compiler, "--version"]))
+    return facts
+
+
+def assemble(directory, out):
+    """Merge NAME.json files into one object keyed by NAME ('a.b.json' nests)."""
+    merged = {}
+    for name in sorted(os.listdir(directory)):
+        if not name.endswith(".json"):
+            continue
+        with open(os.path.join(directory, name)) as handle:
+            try:
+                value = json.load(handle)
+            except ValueError:
+                value = {"error": "unreadable " + name}
+        keys = name[:-5].split(".")
+        node = merged
+        for key in keys[:-1]:
+            node = node.setdefault(key, {})
+        node[keys[-1]] = value
+    with open(out, "w") as handle:
+        json.dump(merged, handle, indent=2, sort_keys=True)
+        handle.write("\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    commands = parser.add_subparsers(dest="command")
+    size = commands.add_parser("size")
+    size.add_argument("--scratch", required=True, help="directory for the temporary zip")
+    size.add_argument("paths", nargs="+")
+    layers = commands.add_parser("layers")
+    layers.add_argument("jar")
+    translated = commands.add_parser("translated")
+    translated.add_argument("directory")
+    commands.add_parser("environment")
+    merge = commands.add_parser("assemble")
+    merge.add_argument("directory")
+    merge.add_argument("out")
+    diagnosis = commands.add_parser("diagnose")
+    diagnosis.add_argument("log")
+    diagnosis.add_argument("default")
+    collect = commands.add_parser("collect")
+    collect.add_argument("out")
+    collect.add_argument("results", nargs="+")
+    args = parser.parse_args()
+
+    if args.command == "size":
+        missing = [p for p in args.paths if not os.path.lexists(p)]
+        if missing:
+            sys.exit("no such path: " + ", ".join(missing))
+        result = measure_size(args.paths, args.scratch)
+    elif args.command == "layers":
+        result = jar_layers(args.jar)
+    elif args.command == "translated":
+        result = translated_layers(args.directory)
+    elif args.command == "environment":
+        result = environment()
+    elif args.command == "diagnose":
+        result = diagnose(args.log, args.default)
+        result.update({"ok": False, "log": args.log})
+    elif args.command == "assemble":
+        assemble(args.directory, args.out)
+        return
+    elif args.command == "collect":
+        documents = []
+        for path in args.results:
+            with open(path) as handle:
+                documents.append(json.load(handle))
+        with open(args.out, "w") as handle:
+            json.dump({"results": documents}, handle, indent=2, sort_keys=True)
+            handle.write("\n")
+        return
+    else:
+        parser.error("no command given")
+        return
+    json.dump(result, sys.stdout, indent=2, sort_keys=True)
+    sys.stdout.write("\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/desktop-compat-benchmarks/firstwindow.swift b/scripts/desktop-compat-benchmarks/firstwindow.swift
new file mode 100644
index 00000000000..b8371da5594
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/firstwindow.swift
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+// Waits for a process to put its first window on screen and prints the wall
+// clock time at which it was seen, as seconds since the epoch.
+//
+//   firstwindow <pid> <timeout-seconds>
+//
+// The macOS half of the desktop-compat benchmarks (run-macos-bench.sh) uses it
+// to time start-up without touching either application: the window list is read
+// from the window server, which needs no permission for bounds and owner. It
+// answers "a window of at least 100 x 100 points is on screen", not "its first
+// frame is painted" -- reading pixels would need the Screen Recording
+// permission -- so macOS start-up figures are the earlier of the two events the
+// Linux leg reports.
+//
+// Exit status: 0 when a window appeared, 1 on timeout, 2 on bad arguments.
+
+import CoreGraphics
+import Foundation
+
+let arguments = CommandLine.arguments
+guard arguments.count == 3, let pid = Int(arguments[1]), let timeout = Double(arguments[2]) else {
+    FileHandle.standardError.write("usage: firstwindow <pid> <timeout-seconds>\n".data(using: .utf8)!)
+    exit(2)
+}
+
+let deadline = Date().addingTimeInterval(timeout)
+while Date() < deadline {
+    let options: CGWindowListOption = [.optionOnScreenOnly, .excludeDesktopElements]
+    if let windows = CGWindowListCopyWindowInfo(options, kCGNullWindowID) as? [[String: Any]] {
+        for window in windows {
+            guard let owner = window[kCGWindowOwnerPID as String] as? Int, owner == pid,
+                  let layer = window[kCGWindowLayer as String] as? Int, layer == 0,
+                  let bounds = window[kCGWindowBounds as String] as? [String: Any],
+                  let width = bounds["Width"] as? Double, let height = bounds["Height"] as? Double,
+                  width >= 100, height >= 100 else {
+                continue
+            }
+            print(String(format: "%.4f", Date().timeIntervalSince1970))
+            exit(0)
+        }
+    }
+    usleep(4000)
+}
+exit(1)
diff --git a/scripts/desktop-compat-benchmarks/input/default.txt b/scripts/desktop-compat-benchmarks/input/default.txt
new file mode 100644
index 00000000000..8b3bc7c47c0
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/input/default.txt
@@ -0,0 +1,34 @@
+# The input every application gets unless input/<name>.txt exists.
+#
+# Coordinates are fractions of the application window, so the same script
+# drives the JVM build and the Codename One build although their windows are
+# not the same size. Nothing here touches the top fifth of the window: a menu
+# bar lives there, and a script that happened to pick "Exit" would measure
+# nothing.
+#
+# sleep SECONDS | move FX FY | click FX FY | key NAME | type TEXT
+sleep 0.5
+move 0.50 0.50
+click 0.30 0.35
+click 0.50 0.45
+click 0.70 0.35
+key Tab
+key Tab
+type hello
+key Down
+key Down
+key Right
+key Up
+key Left
+click 0.30 0.65
+click 0.50 0.75
+click 0.70 0.65
+key space
+move 0.20 0.30
+move 0.80 0.30
+move 0.80 0.80
+move 0.20 0.80
+click 0.50 0.55
+type codename one
+key Return
+sleep 0.5
diff --git a/scripts/desktop-compat-benchmarks/input/fx2048.txt b/scripts/desktop-compat-benchmarks/input/fx2048.txt
new file mode 100644
index 00000000000..4138f260f88
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/input/fx2048.txt
@@ -0,0 +1,24 @@
+# 2048 is played with the arrow keys: one click to take the focus, then moves.
+sleep 0.5
+click 0.50 0.60
+key Left
+key Down
+key Right
+key Down
+key Left
+key Up
+key Right
+key Down
+key Left
+key Down
+key Right
+key Up
+key Left
+key Down
+key Right
+key Down
+key Left
+key Left
+key Down
+key Right
+sleep 1.0
diff --git a/scripts/desktop-compat-benchmarks/input/javafx-gallery.txt b/scripts/desktop-compat-benchmarks/input/javafx-gallery.txt
new file mode 100644
index 00000000000..be4391a56bc
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/input/javafx-gallery.txt
@@ -0,0 +1,34 @@
+# The controls tab of the JavaFX gallery, the same controls in both arms.
+#
+# The native look is taller than Modena, so a control of the Codename One
+# build is not where the JVM's window has it. default.txt pressed nothing in
+# particular in either, and what happened came from where Tab and the arrow
+# keys left the focus: a radio button was chosen in one arm and not in the
+# other. Every press is given per arm.
+sleep 0.5
+# "Click me", then "Toggle"
+jvm: click 0.057 0.212
+cn1: click 0.060 0.206
+jvm: click 0.448 0.212
+cn1: click 0.458 0.206
+# the check box of three states, and the radio button "Small"
+jvm: click 0.020 0.312
+cn1: click 0.029 0.324
+jvm: click 0.022 0.347
+cn1: click 0.029 0.371
+# the name field, then on to the password
+jvm: click 0.499 0.412
+cn1: click 0.499 0.441
+type hello
+key Tab
+type secret
+# the slider, at 75
+jvm: click 0.741 0.726
+cn1: click 0.741 0.780
+move 0.20 0.90
+move 0.80 0.90
+# the text area
+jvm: click 0.499 0.555
+cn1: click 0.499 0.584
+type codename one
+sleep 0.5
diff --git a/scripts/desktop-compat-benchmarks/input/mandelbrot.txt b/scripts/desktop-compat-benchmarks/input/mandelbrot.txt
new file mode 100644
index 00000000000..17d9962db85
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/input/mandelbrot.txt
@@ -0,0 +1,14 @@
+# The Mandelbrot demo: fly to its position "1" and render the picture there.
+#
+# default.txt never pressed a button with the pointer. What it did came from
+# where Tab, the arrows and Space left the focus, which is not the same
+# button in a tool bar laid out for another look: one arm zoomed and the
+# other opened and closed the bar. The button is pressed here, per arm.
+#
+# One press only. The buttons are disabled while a picture renders, and how
+# long that takes is what differs between the arms: a second press would be
+# taken by the faster one and ignored by the slower.
+sleep 0.5
+jvm: click 0.228 0.077
+cn1: click 0.207 0.086
+sleep 15
diff --git a/scripts/desktop-compat-benchmarks/input/swing-gallery.txt b/scripts/desktop-compat-benchmarks/input/swing-gallery.txt
new file mode 100644
index 00000000000..60898018dbe
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/input/swing-gallery.txt
@@ -0,0 +1,34 @@
+# The controls tab of the Swing gallery, the same controls in both arms.
+#
+# The native look is taller than Metal, so the window of the Codename One
+# build does not put a control where the JVM's has it, and default.txt
+# pressed different things in the two: it typed into the editable combo box
+# in one and moved the slider in the other. Every press is given per arm.
+sleep 0.5
+# "Click me"
+jvm: click 0.086 0.269
+cn1: click 0.077 0.323
+# the radio buttons "Small", then "Large"
+jvm: click 0.275 0.269
+cn1: click 0.260 0.323
+jvm: click 0.470 0.269
+cn1: click 0.462 0.323
+# the name field, then on to the password
+jvm: click 0.369 0.368
+cn1: click 0.376 0.418
+type hello
+key Tab
+type secret
+# the slider, at 75
+jvm: click 0.547 0.534
+cn1: click 0.717 0.610
+# "Start", and the progress bar runs
+jvm: click 0.264 0.677
+cn1: click 0.251 0.748
+move 0.20 0.90
+move 0.80 0.90
+# the text area
+jvm: click 0.739 0.420
+cn1: click 0.732 0.467
+type codename one
+sleep 0.5
diff --git a/scripts/desktop-compat-benchmarks/input/tetris.txt b/scripts/desktop-compat-benchmarks/input/tetris.txt
new file mode 100644
index 00000000000..2786468be7c
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/input/tetris.txt
@@ -0,0 +1,26 @@
+# A keyboard-driven game: one click to take the focus, then play.
+sleep 0.5
+click 0.50 0.50
+key Left
+key Left
+key Up
+key Right
+key space
+key Right
+key Right
+key Up
+key Down
+key space
+key Left
+key Up
+key Up
+key Right
+key space
+key Left
+key Left
+key Left
+key space
+key Right
+key Up
+key space
+sleep 1.0
diff --git a/scripts/desktop-compat-benchmarks/install-linux-deps.sh b/scripts/desktop-compat-benchmarks/install-linux-deps.sh
new file mode 100755
index 00000000000..5013744cce4
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/install-linux-deps.sh
@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+#
+# Installs everything the Linux leg of the desktop-compat benchmarks needs on a
+# Debian/Ubuntu machine: the GTK build stack of the native Linux port (the list
+# is the one .github/workflows/linux-build-run.yml installs), JDK 17 for the
+# Codename One build, JDK 21 for the baseline, OpenJFX (as jmods) and
+# the zig toolchain the native port links an old-glibc binary with.
+#
+# Usage: install-linux-deps.sh <tools-dir>
+#   <tools-dir> receives zig/ and javafx-jmods/. Nothing else is written outside
+#   the package manager's own directories.
+#
+# Used both by the Containerfile beside it and by the CI workflow, so the local
+# container and the runner measure the same stack.
+set -euo pipefail
+
+TOOLS_DIR="${1:?usage: install-linux-deps.sh <tools-dir>}"
+ZIG_VERSION="${BENCH_ZIG_VERSION:-0.14.1}"
+
+SUDO=""
+if [ "$(id -u)" -ne 0 ]; then
+  SUDO="sudo"
+fi
+
+export DEBIAN_FRONTEND=noninteractive
+$SUDO apt-get update
+$SUDO apt-get install -y --no-install-recommends \
+  ca-certificates curl unzip zip xz-utils file time binutils procps git \
+  cmake ninja-build pkg-config clang \
+  xvfb x11-utils openbox fonts-dejavu-core python3 python3-xlib \
+  libgtk-3-dev libcairo2-dev libpango1.0-dev libgdk-pixbuf-2.0-dev libglib2.0-dev \
+  libfontconfig1-dev libfreetype-dev \
+  libcurl4-openssl-dev libssl-dev \
+  libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev gstreamer1.0-plugins-base gstreamer1.0-plugins-good \
+  libwebkit2gtk-4.1-dev libsecret-1-dev libnotify-dev libgeoclue-2-dev \
+  libepoxy-dev libegl1-mesa-dev libgles2-mesa-dev libgl1-mesa-dri \
+  libxtst6 libxxf86vm1 \
+  openjdk-17-jdk openjdk-21-jdk maven
+
+mkdir -p "$TOOLS_DIR"
+ARCH="$(uname -m)"
+
+if [ ! -x "$TOOLS_DIR/zig/zig" ]; then
+  curl -fsSL -o "$TOOLS_DIR/zig.tar.xz" \
+    "https://ziglang.org/download/${ZIG_VERSION}/zig-${ARCH}-linux-${ZIG_VERSION}.tar.xz"
+  mkdir -p "$TOOLS_DIR/zig"
+  tar -xf "$TOOLS_DIR/zig.tar.xz" -C "$TOOLS_DIR/zig" --strip-components=1
+  rm -f "$TOOLS_DIR/zig.tar.xz"
+fi
+
+# The compiler wrapper linux-build-run.yml uses: zig cc against glibc 2.28, so
+# the binary measured here is the portable one a developer would ship.
+cat > "$TOOLS_DIR/cn1-zig-cc" <<WRAP
+#!/bin/sh
+ARCH=\$(uname -m)
+exec "$TOOLS_DIR/zig/zig" cc -target \${ARCH}-linux-gnu.2.28 -D_DEFAULT_SOURCE -Wno-macro-redefined \\
+  -L/usr/lib/\${ARCH}-linux-gnu -L/lib/\${ARCH}-linux-gnu "\$@"
+WRAP
+chmod +x "$TOOLS_DIR/cn1-zig-cc"
+
+# OpenJFX as jmods (see javafx-jmods.sh for why jmods and not the jars).
+HERE="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
+JDK21="/usr/lib/jvm/java-21-openjdk-$(dpkg --print-architecture)"
+bash "$HERE/javafx-jmods.sh" "$JDK21" "$TOOLS_DIR/javafx-jmods"
+
+"$TOOLS_DIR/zig/zig" version
+ls "$TOOLS_DIR/javafx-jmods"
diff --git a/scripts/desktop-compat-benchmarks/javafx-jmods.sh b/scripts/desktop-compat-benchmarks/javafx-jmods.sh
new file mode 100755
index 00000000000..c5e4b1b7405
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/javafx-jmods.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+#
+# Builds OpenJFX jmods for this machine from the platform jars on Maven Central.
+#
+# Usage: javafx-jmods.sh <jdk-home> <output-dir> [version]
+#
+# Each OpenJFX platform jar is a module's classes with its native libraries at
+# the root, and a jmod is the same two things in separate sections. Linked from
+# jmods, a jlink runtime image carries the libraries in lib/ like a JDK's own,
+# instead of unpacking them into ~/.openjfx/cache on first start the way an
+# image linked from the jars does -- which is the layout a packaged JavaFX
+# application normally ships, and the fairer one to time.
+#
+# The default version is the newest OpenJFX that both runs on JDK 21 and
+# publishes a linux-aarch64 build.
+set -euo pipefail
+
+JDK_HOME="${1:?usage: javafx-jmods.sh <jdk-home> <output-dir> [version]}"
+OUT="${2:?usage: javafx-jmods.sh <jdk-home> <output-dir> [version]}"
+VERSION="${3:-${BENCH_JAVAFX_VERSION:-23.0.2}}"
+
+if [ -f "$OUT/VERSION" ] && [ "$(cat "$OUT/VERSION")" = "$VERSION" ]; then
+  exit 0
+fi
+
+case "$(uname -s)-$(uname -m)" in
+  Linux-aarch64|Linux-arm64) CLASSIFIER="linux-aarch64"; LIB_GLOB='*.so'; SECTION="--libs" ;;
+  Linux-*) CLASSIFIER="linux"; LIB_GLOB='*.so'; SECTION="--libs" ;;
+  Darwin-arm64) CLASSIFIER="mac-aarch64"; LIB_GLOB='*.dylib'; SECTION="--libs" ;;
+  Darwin-*) CLASSIFIER="mac"; LIB_GLOB='*.dylib'; SECTION="--libs" ;;
+  # A Windows runtime image keeps its DLLs in bin/, the "cmds" section of a
+  # jmod. Only CI has run this branch.
+  MINGW*|MSYS*|CYGWIN*) CLASSIFIER="win"; LIB_GLOB='*.dll'; SECTION="--cmds" ;;
+  *) echo "javafx-jmods.sh: unsupported platform $(uname -s)-$(uname -m)" >&2; exit 1 ;;
+esac
+
+STAGE="$OUT.stage"
+rm -rf "$STAGE" "$OUT"
+mkdir -p "$STAGE/jmods"
+for MODULE in base graphics controls fxml media swing; do
+  JAR="$STAGE/javafx-$MODULE.jar"
+  curl -fsSL --retry 3 -o "$JAR" \
+    "https://repo1.maven.org/maven2/org/openjfx/javafx-$MODULE/$VERSION/javafx-$MODULE-$VERSION-$CLASSIFIER.jar"
+  mkdir -p "$STAGE/$MODULE/classes" "$STAGE/$MODULE/libs"
+  unzip -q "$JAR" -d "$STAGE/$MODULE/classes"
+  find "$STAGE/$MODULE/classes" -maxdepth 1 -name "$LIB_GLOB" -exec mv {} "$STAGE/$MODULE/libs/" \;
+  rm -rf "$STAGE/$MODULE/classes/META-INF"
+  "$JDK_HOME/bin/jmod" create --class-path "$STAGE/$MODULE/classes" "$SECTION" "$STAGE/$MODULE/libs" \
+    --module-version "$VERSION" "$STAGE/jmods/javafx.$MODULE.jmod"
+done
+mv "$STAGE/jmods" "$OUT"
+rm -rf "$STAGE"
+echo "$VERSION" > "$OUT/VERSION"
diff --git a/scripts/desktop-compat-benchmarks/linux-container.sh b/scripts/desktop-compat-benchmarks/linux-container.sh
new file mode 100755
index 00000000000..aeb880240fe
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/linux-container.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+#
+# Runs a command inside the bench-linux container with this checkout mounted at
+# the path it has on the host, so a Maven repository or an application
+# directory named by an absolute path means the same thing on both sides.
+#
+# Usage: linux-container.sh <container-name-suffix> <command> [args...]
+#
+# Environment:
+#   BENCH_IMAGE     image to run (default: bench-linux)
+#   BENCH_VOLUME    named volume mounted at /work (default: bench-work). Builds
+#                   go there rather than on the shared host mount: a translated
+#                   application is tens of thousands of small C files, and a
+#                   virtiofs mount makes that the slowest part of the build.
+#   BENCH_MOUNTS    extra host directories to mount read-only, colon separated
+#
+# The container is privileged so the benchmark can drop the page cache for its
+# cold-start samples; without that it falls back to evicting only the
+# application's own files and says so in its output.
+set -euo pipefail
+
+if [ "$#" -lt 2 ]; then
+  echo "usage: linux-container.sh <name-suffix> <command> [args...]" >&2
+  exit 2
+fi
+SUFFIX="$1"
+shift
+
+HERE="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
+ROOT="$(CDPATH='' cd -- "$HERE/../.." && pwd)"
+IMAGE="${BENCH_IMAGE:-bench-linux}"
+VOLUME="${BENCH_VOLUME:-bench-work}"
+
+MOUNTS=(-v "$ROOT:$ROOT" -v "$VOLUME:/work")
+if [ -n "${BENCH_MOUNTS:-}" ]; then
+  IFS=':' read -r -a EXTRA <<< "$BENCH_MOUNTS"
+  for DIR in "${EXTRA[@]}"; do
+    MOUNTS+=(-v "$DIR:$DIR:ro")
+  done
+fi
+
+exec podman run --rm --privileged --name "bench-$SUFFIX" "${MOUNTS[@]}" -w "$ROOT" "$IMAGE" "$@"
diff --git a/scripts/desktop-compat-benchmarks/mobile-size.sh b/scripts/desktop-compat-benchmarks/mobile-size.sh
new file mode 100644
index 00000000000..d38df98c8f7
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/mobile-size.sh
@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+#
+# Size of an imported desktop application as an iOS or an Android application.
+#
+#   mobile-size.sh --target ios|android --project <dir> --work <dir>
+#
+# --project is the Codename One project bench.sh generated and imported into
+# (<work>/<name>/cn1/app); it is copied, never built in place. Nothing is
+# installed or launched: iOS is an unsigned Release build for a generic device,
+# Android the release APK (R8 on, signed with the throwaway key the generated
+# project carries). Sizes only -- no simulator or emulator is involved.
+#
+# Environment: JAVA17_HOME (required), BENCH_M2 (Maven repository holding
+# Codename One), BENCH_USER_HOME (keeps the plugin out of ~/.codenameone),
+# ANDROID_HOME (Android only; the SDK is read, never added to).
+#
+# Writes <work>/<target>-size.json and keeps the build logs beside it.
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TARGET=""
+PROJECT=""
+WORK=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --target) TARGET="$2"; shift 2 ;;
+    --project) PROJECT="$2"; shift 2 ;;
+    --work) WORK="$2"; shift 2 ;;
+    -h|--help) sed -n '2,18p' "$0"; exit 0 ;;
+    *) echo "mobile-size: unknown argument $1" >&2; exit 2 ;;
+  esac
+done
+if [ -z "$TARGET" ] || [ -z "$PROJECT" ] || [ -z "$WORK" ]; then
+  echo "mobile-size: --target, --project and --work are required" >&2
+  exit 2
+fi
+: "${JAVA17_HOME:?JAVA17_HOME must point at a JDK 17}"
+
+say() { printf '[mobile-size %s] %s\n' "$TARGET" "$*"; }
+
+mkdir -p "$WORK/tmp"
+WORK="$(cd "$WORK" && pwd)"
+TMP="$WORK/tmp"
+rm -rf "$WORK/app"
+cp -R "$PROJECT" "$WORK/app"
+find "$WORK/app" -type d -name target -prune -exec rm -rf {} +
+
+# -Dopen=false: the Codename One plugin otherwise opens a generated Xcode or
+# Android Studio project in the IDE, and a benchmark must never open a window.
+MVN_ARGS=(-B -ntp -Dopen=false)
+if [ -n "${BENCH_M2:-}" ]; then
+  MVN_ARGS+=("-Dmaven.repo.local=$BENCH_M2")
+fi
+MVN_JVM="-Djava.io.tmpdir=$TMP"
+if [ -n "${BENCH_USER_HOME:-}" ]; then
+  MVN_JVM="$MVN_JVM -Duser.home=$BENCH_USER_HOME"
+fi
+generate() { # <platform> <build target> <log>
+  (cd "$WORK/app" && JAVA_HOME="$JAVA17_HOME" PATH="$JAVA17_HOME/bin:$PATH" MAVEN_OPTS="$MVN_JVM" \
+    TMPDIR="$TMP" mvn "${MVN_ARGS[@]}" package -DskipTests \
+    "-Dcodename1.platform=$1" "-Dcodename1.buildTarget=$2") > "$3" 2>&1
+}
+
+case "$TARGET" in
+  ios)
+    say "generating the Xcode project"
+    generate ios ios-source "$WORK/ios-source.log"
+    XCODEPROJ="$(find "$WORK/app" -type d -name '*.xcodeproj' -not -path '*/Pods/*' | head -1)"
+    [ -n "$XCODEPROJ" ] || { echo "mobile-size: no Xcode project was generated" >&2; exit 1; }
+    NAME="$(basename "$XCODEPROJ" .xcodeproj)"
+    say "xcodebuild Release, generic device, unsigned"
+    (cd "$(dirname "$XCODEPROJ")" && TMPDIR="$TMP" xcodebuild -project "$XCODEPROJ" -target "$NAME" \
+      -configuration Release -sdk iphoneos "SYMROOT=$WORK/build" "OBJROOT=$WORK/obj" \
+      ONLY_ACTIVE_ARCH=NO CODE_SIGN_IDENTITY= CODE_SIGNING_REQUIRED=NO CODE_SIGNING_ALLOWED=NO \
+      DEVELOPMENT_TEAM= PROVISIONING_PROFILE_SPECIFIER= "MODULE_CACHE_DIR=$WORK/modules" \
+      "CLANG_MODULE_CACHE_PATH=$WORK/modules" COMPILER_INDEX_STORE_ENABLE=NO build) \
+      > "$WORK/xcodebuild.log" 2>&1
+    BUNDLE="$(find "$WORK/build" -type d -name '*.app' -not -path '*/*.app/*' | head -1)"
+    [ -n "$BUNDLE" ] || { echo "mobile-size: xcodebuild produced no application" >&2; exit 1; }
+    find "$WORK/build" -name '*.dSYM' -prune -exec rm -rf {} +
+    # The App Store strips symbols on delivery; -x is what Xcode's own
+    # "Strip Linked Product" does to an application.
+    xcrun strip -x -o "$WORK/stripped-executable" "$BUNDLE/$NAME"
+    python3 "$HERE/benchutil.py" size --scratch "$TMP" "$BUNDLE" > "$WORK/bundle-size.json"
+    python3 - "$WORK/bundle-size.json" "$BUNDLE/$NAME" "$WORK/stripped-executable" > "$WORK/ios-size.json" <<'PY'
+import json, os, sys
+size = json.load(open(sys.argv[1]))
+size["what"] = "unsigned Release .app, arm64, generic iOS device"
+size["executable_bytes"] = os.path.getsize(sys.argv[2])
+size["executable_stripped_bytes"] = os.path.getsize(sys.argv[3])
+json.dump(size, sys.stdout, indent=2, sort_keys=True)
+PY
+    ;;
+  android)
+    : "${ANDROID_HOME:?ANDROID_HOME must point at an Android SDK}"
+    say "generating the Gradle project"
+    generate android android-source "$WORK/android-source.log"
+    GRADLEW="$(find "$WORK/app" -name gradlew -path '*android-source*' | head -1)"
+    [ -n "$GRADLEW" ] || { echo "mobile-size: no Gradle project was generated" >&2; exit 1; }
+    chmod +x "$GRADLEW"
+    say "gradle assembleRelease"
+    # Its own Gradle home, and no SDK downloads: a size run must not change the
+    # machine it runs on.
+    (cd "$(dirname "$GRADLEW")" && JAVA_HOME="$JAVA17_HOME" PATH="$JAVA17_HOME/bin:$PATH" \
+      GRADLE_USER_HOME="${GRADLE_USER_HOME:-$WORK/gradle-home}" ANDROID_SDK_ROOT="$ANDROID_HOME" \
+      ANDROID_USER_HOME="$WORK/android-user-home" TMPDIR="$TMP" \
+      ./gradlew --no-daemon -Pandroid.builder.sdkDownload=false "-Djava.io.tmpdir=$TMP" \
+      assembleRelease) > "$WORK/gradle.log" 2>&1
+    APK="$(find "$(dirname "$GRADLEW")" -name '*.apk' -path '*release*' | head -1)"
+    [ -n "$APK" ] || { echo "mobile-size: gradle produced no APK" >&2; exit 1; }
+    python3 - "$APK" > "$WORK/android-size.json" <<'PY'
+import json, os, sys, zipfile
+with zipfile.ZipFile(sys.argv[1]) as apk:
+    entries = apk.infolist()
+    dex = sum(e.file_size for e in entries if e.filename.endswith(".dex"))
+    unpacked = sum(e.file_size for e in entries)
+json.dump({"what": "release APK, R8 minified", "apk_bytes": os.path.getsize(sys.argv[1]),
+           "unpacked_bytes": unpacked, "dex_bytes": dex, "files": len(entries)},
+          sys.stdout, indent=2, sort_keys=True)
+PY
+    ;;
+  *)
+    echo "mobile-size: --target must be ios or android" >&2
+    exit 2
+    ;;
+esac
+say "wrote $WORK/$TARGET-size.json"
+cat "$WORK/$TARGET-size.json"
+echo
diff --git a/scripts/desktop-compat-benchmarks/report.py b/scripts/desktop-compat-benchmarks/report.py
new file mode 100755
index 00000000000..be8f497408d
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/report.py
@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+"""Render desktop-compat benchmark results as tables.
+
+  report.py [--format markdown|asciidoc] [--out FILE] RESULT.json [RESULT.json ...]
+
+Each RESULT.json is what bench.sh wrote for one application. A cell with no
+measurement behind it is printed as "--": nothing here is estimated or carried
+over from another run. Ratios are baseline / Codename One, so a number above 1
+means the Codename One build is that many times smaller or faster, and a number
+below 1 means it lost.
+
+Python 3.9 compatible, standard library only.
+"""
+
+import argparse
+import json
+import sys
+
+EMPTY = "--"
+IDLE_CPU_DEFECT_PERCENT = 1.0
+
+
+def dig(node, *path):
+    for key in path:
+        if not isinstance(node, dict) or key not in node:
+            return None
+        node = node[key]
+    return node
+
+
+def megabytes(value):
+    return EMPTY if value is None else "%.1f" % (value / 1048576.0)
+
+
+def megabytes_kb(value):
+    return EMPTY if value is None else "%.1f" % (value / 1024.0)
+
+
+def ratio(baseline, candidate):
+    if baseline is None or candidate is None or candidate == 0:
+        return EMPTY
+    return "%.1fx" % (float(baseline) / float(candidate))
+
+
+def timing(node):
+    if not node or node.get("median") is None:
+        return EMPTY
+    return "%.0f (%.0f-%.0f)" % (node["median"], node["min"], node["max"])
+
+
+def percent(value):
+    return EMPTY if value is None else "%.1f%%" % value
+
+
+class Table(object):
+    def __init__(self, title, header, note=None):
+        self.title = title
+        self.header = header
+        self.rows = []
+        self.note = note
+
+    def add(self, *cells):
+        self.rows.append([str(cell) for cell in cells])
+
+    def markdown(self):
+        lines = ["### " + self.title, ""]
+        if self.note:
+            lines += [self.note, ""]
+        lines.append("| " + " | ".join(self.header) + " |")
+        lines.append("|" + "|".join(["---"] + ["---:"] * (len(self.header) - 1)) + "|")
+        for row in self.rows:
+            lines.append("| " + " | ".join(row) + " |")
+        lines.append("")
+        return "\n".join(lines)
+
+    def asciidoc(self):
+        lines = ["." + self.title]
+        lines.append('[cols="' + ",".join(["<2"] + [">1"] * (len(self.header) - 1)) + '",options="header"]')
+        lines.append("|===")
+        lines.append("".join("|" + cell + " " for cell in self.header).rstrip())
+        for row in self.rows:
+            lines.append("")
+            lines.append("".join("|" + cell + " " for cell in row).rstrip())
+        lines.append("|===")
+        if self.note:
+            lines += ["", self.note]
+        lines.append("")
+        return "\n".join(lines)
+
+
+def build_tables(results):
+    tables = []
+
+    size = Table(
+        "Distributable size (MB; zip = one deflate -9 archive)",
+        ["App", "Jar + deps", "jlink image + app", "jlink zip", "jpackage image", "jpackage zip",
+         "CN1 native", "CN1 zip", "jlink zip / CN1 zip"],
+        "The jlink image holds only the modules the application needs "
+        "(`jdeps --print-module-deps`), is stripped of debug information and compressed "
+        "(`--compress zip-6`), and has no CDS archive in it.")
+    for result in results:
+        name = dig(result, "app", "name")
+        target = dig(result, "app", "target") or "linux"
+        cn1 = dig(result, "size", "cn1_" + target)
+        slices = dig(result, "cn1_" + target, "slice_bytes")
+        if slices:
+            name = "%s (CN1 bundle is universal: %s)" % (name, ", ".join(
+                "%s %.1f MB" % (arch, slices[arch] / 1048576.0) for arch in sorted(slices)))
+        size.add(name,
+                 megabytes(dig(result, "size", "baseline_jars", "bytes")),
+                 megabytes(dig(result, "size", "baseline_jlink", "bytes")),
+                 megabytes(dig(result, "size", "baseline_jlink", "zip_bytes")),
+                 megabytes(dig(result, "size", "baseline_jpackage", "bytes")),
+                 megabytes(dig(result, "size", "baseline_jpackage", "zip_bytes")),
+                 megabytes(dig(cn1, "bytes")),
+                 megabytes(dig(cn1, "zip_bytes")),
+                 ratio(dig(result, "size", "baseline_jlink", "zip_bytes"), dig(cn1, "zip_bytes")))
+    tables.append(size)
+
+    measured = [r for r in results if dig(r, "run")]
+    if measured:
+        for section, title in (("idle", "Memory after start-up and %s s idle (MB)"),
+                               ("after_script", "Memory after the scripted interaction (MB)")):
+            header = ["App"]
+            for variant in ("JVM default", "JVM tuned", "CN1 native"):
+                header += [variant + " RSS", "PSS", "USS"]
+            header += ["RSS default / CN1", "RSS tuned / CN1"]
+            idle_seconds = dig(measured[0], "run", "jvm_default", "idle_seconds") or \
+                dig(measured[0], "run", "cn1_native", "idle_seconds") or 10
+            table = Table(title % ("%g" % idle_seconds) if "%s" in title else title, header,
+                          "Summed over the application's whole process tree from "
+                          "`/proc/<pid>/smaps_rollup`; median of the sessions.")
+            for result in measured:
+                row = [dig(result, "app", "name")]
+                for variant in ("jvm_default", "jvm_tuned", "cn1_native"):
+                    for field in ("rss_kb", "pss_kb", "uss_kb"):
+                        row.append(megabytes_kb(dig(result, "run", variant, section, field)))
+                cn1 = dig(result, "run", "cn1_native", section, "rss_kb")
+                row.append(ratio(dig(result, "run", "jvm_default", section, "rss_kb"), cn1))
+                row.append(ratio(dig(result, "run", "jvm_tuned", section, "rss_kb"), cn1))
+                table.add(*row)
+            tables.append(table)
+
+        peak = Table("Peak RSS over a whole session (MB, `/usr/bin/time -v`)",
+                     ["App", "JVM default", "JVM tuned", "CN1 native", "default / CN1", "tuned / CN1",
+                      "Tuned -Xmx (MB)"])
+        for result in measured:
+            cn1 = dig(result, "run", "cn1_native", "peak_rss_kb")
+            peak.add(dig(result, "app", "name"),
+                     megabytes_kb(dig(result, "run", "jvm_default", "peak_rss_kb")),
+                     megabytes_kb(dig(result, "run", "jvm_tuned", "peak_rss_kb")),
+                     megabytes_kb(cn1),
+                     ratio(dig(result, "run", "jvm_default", "peak_rss_kb"), cn1),
+                     ratio(dig(result, "run", "jvm_tuned", "peak_rss_kb"), cn1),
+                     dig(result, "tuned", "xmx_mb") or EMPTY)
+        tables.append(peak)
+
+        for mode in ("cold", "warm"):
+            startup = Table(
+                "Start-up, %s: process start to first painted frame (ms, median (min-max))" % mode,
+                ["App", "JVM default", "JVM tuned", "CN1 native", "default / CN1", "tuned / CN1"],
+                "Linux: read off the X server, the first poll at which the application's window "
+                "shows more than a flat colour. macOS and Windows: the window appearing, which is "
+                "earlier than its first frame.")
+            for result in measured:
+                key = "startup_" + mode
+                # Linux reports the first painted frame. macOS and Windows can
+                # only see the window appear, and report that instead.
+                field = "first_paint_ms"
+                if dig(result, "run", "cn1_native", key, field) is None and \
+                        dig(result, "run", "jvm_default", key, field) is None:
+                    field = "window_ms"
+                cn1 = dig(result, "run", "cn1_native", key, field)
+                default = dig(result, "run", "jvm_default", key, field)
+                tuned = dig(result, "run", "jvm_tuned", key, field)
+                startup.add(dig(result, "app", "name"), timing(default), timing(tuned), timing(cn1),
+                            ratio(dig(default, "median"), dig(cn1, "median")),
+                            ratio(dig(tuned, "median"), dig(cn1, "median")))
+            # macOS and Windows take no cold figures; a table of dashes says nothing.
+            if any(cell != EMPTY for row in startup.rows for cell in row[1:]):
+                tables.append(startup)
+
+        cpu = Table("Idle CPU (% of one core, second half of the idle window)",
+                    ["App", "JVM default", "JVM tuned", "CN1 native", "CN1 visible changes", "Verdict"])
+        for result in measured:
+            value = dig(result, "run", "cn1_native", "idle", "cpu_percent")
+            verdict = EMPTY
+            if value is not None:
+                verdict = "DEFECT: repaints while idle" if value > IDLE_CPU_DEFECT_PERCENT else "ok"
+            cpu.add(dig(result, "app", "name"),
+                    percent(dig(result, "run", "jvm_default", "idle", "cpu_percent")),
+                    percent(dig(result, "run", "jvm_tuned", "idle", "cpu_percent")),
+                    percent(value),
+                    dig(result, "run", "cn1_native", "idle", "visible_changes")
+                    if value is not None else EMPTY,
+                    verdict)
+        tables.append(cpu)
+
+    layers = Table(
+        "What the compatibility runtime costs, and what dead-code elimination removed",
+        ["App", "Layer", "Classes in staged jar", "Class bytes (MB)", "Classes translated to C", "Kept"],
+        "Staged jar: what the application hands to any builder. Translated: the classes "
+        "ParparVM still emitted C for after its dead-code pass (the application row also "
+        "counts the classes the translator makes out of lambdas).")
+    for result in results:
+        staged = dig(result, "layers", "staged_jar", "classes") or {}
+        translated = None
+        for key in sorted(dig(result, "layers") or {}):
+            if key.startswith("translated_"):
+                translated = dig(result, "layers", key)
+        for layer in ("swing-compat", "javafx-compat", "application", "codenameone-core"):
+            if layer not in staged:
+                continue
+            kept = dig(translated, layer, "classes")
+            share = EMPTY
+            # Only for the runtime layers: the translator adds classes of its
+            # own to the application's (one per lambda), so a share there would
+            # compare two different sets.
+            if kept is not None and staged[layer]["classes"] and layer != "application":
+                share = "%.0f%%" % (100.0 * kept / staged[layer]["classes"])
+            layers.add(dig(result, "app", "name"), layer, staged[layer]["classes"],
+                       megabytes(staged[layer]["bytes"]), EMPTY if kept is None else kept, share)
+    if layers.rows:
+        tables.append(layers)
+    return tables
+
+
+def failures(results):
+    lines = []
+    for result in results:
+        name = dig(result, "app", "name")
+        for part in ("baseline", "cn1"):
+            node = dig(result, part)
+            if isinstance(node, dict) and node.get("ok") is False:
+                lines.append("%s: %s build failed (%s): %s" % (
+                    name, part, node.get("classification"), node.get("first_error") or "see log"))
+        for variant in sorted(dig(result, "run") or {}):
+            for error in dig(result, "run", variant, "errors") or []:
+                lines.append("%s: %s: %s" % (name, variant, error))
+    return lines
+
+
+def environment_lines(results):
+    facts = dig(results[0], "environment") or {}
+    order = ["commit", "os", "kernel", "machine", "cpu", "host_cpu", "cpus", "ram_kb", "in_container",
+             "container_image", "screen", "baseline_jdk", "openjfx", "cn1_build_jdk", "cn1_c_compiler",
+             "cn1_c_compiler_version", "gtk", "xcode"]
+    lines = []
+    for key in order:
+        value = facts.get(key)
+        if value is None or value == "":
+            continue
+        if key == "ram_kb":
+            value = "%.1f GiB" % (value / 1048576.0)
+        lines.append((key.replace("_kb", "").replace("_", " "), value))
+    tuned = sorted(set(dig(r, "tuned", "flags") for r in results if dig(r, "tuned", "flags")))
+    for flags in tuned:
+        lines.append(("tuned JVM flags", flags))
+    cold = sorted(set(dig(r, "run", v, "cold_method") or "" for r in results
+                      for v in ("jvm_default", "jvm_tuned", "cn1_native")) - {""})
+    if cold:
+        lines.append(("cold start made cold by", ", ".join(cold)))
+    return lines
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--format", choices=("markdown", "asciidoc"), default="markdown")
+    parser.add_argument("--out", default=None)
+    parser.add_argument("results", nargs="+")
+    args = parser.parse_args()
+
+    results = []
+    for path in args.results:
+        with open(path) as handle:
+            results.append(json.load(handle))
+    results.sort(key=lambda r: (dig(r, "app", "kind") or "", dig(r, "app", "name") or ""))
+
+    markdown = args.format == "markdown"
+    out = []
+    out.append("## Desktop compatibility benchmarks" if markdown else "== Desktop compatibility benchmarks")
+    out.append("")
+    for table in build_tables(results):
+        out.append(table.markdown() if markdown else table.asciidoc())
+    problems = failures(results)
+    if problems:
+        out.append("### Failures" if markdown else "=== Failures")
+        out.append("")
+        out.extend(("- " if markdown else "* ") + line for line in problems)
+        out.append("")
+    out.append("### Environment" if markdown else "=== Environment")
+    out.append("")
+    for key, value in environment_lines(results):
+        out.append(("- **%s**: %s" if markdown else "* *%s*: %s") % (key, value))
+    out.append("")
+    text = "\n".join(out)
+    if args.out:
+        with open(args.out, "w") as handle:
+            handle.write(text)
+    else:
+        sys.stdout.write(text)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/desktop-compat-benchmarks/run-macos-bench.sh b/scripts/desktop-compat-benchmarks/run-macos-bench.sh
new file mode 100755
index 00000000000..a86f431358c
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/run-macos-bench.sh
@@ -0,0 +1,228 @@
+#!/usr/bin/env bash
+#
+# The macOS runtime half of the desktop-compat benchmarks. RUN IT BY HAND: it
+# opens the applications' windows, one after another, on the logged-in desktop.
+#
+#   1. bench.sh --stage build ... --work DIR --name NAME      (sizes; opens nothing)
+#   2. run-macos-bench.sh --work DIR --name NAME              (this script)
+#   3. report.py DIR/NAME/result.json
+#
+# For the JVM baseline (the jlink image bench.sh built, default flags, and the
+# same tuned flags the Linux leg uses with a fixed -Xmx) and for the native
+# Codename One .app, it measures per launch:
+#
+#   start-up     process start until its first window is on screen (firstwindow.swift)
+#   idle RAM     RSS from ps, and the physical footprint from footprint(1), after
+#                the idle window
+#   idle CPU     CPU time accumulated over the second half of the idle window
+#   peak RSS     /usr/bin/time -l
+#
+# There is no scripted input here: synthesising clicks on macOS needs the
+# Accessibility permission for whatever runs this script, and a benchmark that
+# silently measures a different thing when the permission is missing is worse
+# than one that does not claim to. "After interaction" cells stay empty on macOS.
+#
+# Usage: run-macos-bench.sh --work DIR --name NAME [--runs N] [--idle SECONDS]
+#                           [--tuned-xmx MB]
+set -euo pipefail
+
+HERE="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
+WORK="" NAME="" RUNS=7 IDLE=10 TUNED_XMX=64
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --work) WORK="$2"; shift 2 ;;
+    --name) NAME="$2"; shift 2 ;;
+    --runs) RUNS="$2"; shift 2 ;;
+    --idle) IDLE="$2"; shift 2 ;;
+    --tuned-xmx) TUNED_XMX="$2"; shift 2 ;;
+    -h|--help) sed -n '2,27p' "$0"; exit 0 ;;
+    *) echo "run-macos-bench.sh: unknown argument $1" >&2; exit 2 ;;
+  esac
+done
+if [ -z "$WORK" ] || [ -z "$NAME" ]; then
+  echo "run-macos-bench.sh: --work and --name are required" >&2
+  exit 2
+fi
+if [ "$(uname -s)" != "Darwin" ]; then
+  echo "run-macos-bench.sh: this is the macOS leg; use bench.sh on Linux" >&2
+  exit 2
+fi
+
+D="$(CDPATH='' cd -- "$WORK/$NAME" && pwd)"
+PARTS="$D/parts" LOGS="$D/logs/macos-run" TMP="$D/tmp"
+mkdir -p "$PARTS" "$LOGS" "$TMP"
+
+HELPER="$TMP/firstwindow"
+if [ ! -x "$HELPER" ] || [ "$HERE/firstwindow.swift" -nt "$HELPER" ]; then
+  xcrun swiftc -O -o "$HELPER" "$HERE/firstwindow.swift"
+fi
+
+measure() { # <label> <command...>
+  local LABEL="$1"
+  shift
+  python3 - "$LABEL" "$PARTS/run.$LABEL.json" "$LOGS" "$HELPER" "$RUNS" "$IDLE" "$D" "$@" <<'PY'
+import json, os, re, signal, statistics, subprocess, sys, time
+
+label, out, logs, helper, runs, idle, cwd = sys.argv[1:8]
+command = sys.argv[8:]
+runs, idle = int(runs), float(idle)
+
+
+def children(pid):
+    listing = subprocess.run(["pgrep", "-P", str(pid)], stdout=subprocess.PIPE,
+                             universal_newlines=True).stdout.split()
+    return [int(p) for p in listing]
+
+
+def cpu_seconds(pid):
+    text = subprocess.run(["ps", "-o", "time=", "-p", str(pid)], stdout=subprocess.PIPE,
+                          universal_newlines=True).stdout.strip()
+    if not text:
+        return None
+    parts = [float(p) for p in text.split(":")]
+    seconds = 0.0
+    for part in parts:
+        seconds = seconds * 60.0 + part
+    return seconds
+
+
+def rss_kb(pid):
+    text = subprocess.run(["ps", "-o", "rss=", "-p", str(pid)], stdout=subprocess.PIPE,
+                          universal_newlines=True).stdout.strip()
+    return int(text) if text.isdigit() else None
+
+
+def footprint_kb(pid):
+    try:
+        text = subprocess.run(["footprint", "-p", str(pid)], stdout=subprocess.PIPE,
+                              stderr=subprocess.DEVNULL, universal_newlines=True, timeout=30).stdout
+    except (OSError, subprocess.SubprocessError):
+        return None
+    match = re.search(r"phys_footprint:\s*([\d.]+)\s*(KB|MB|GB)", text)
+    if not match:
+        return None
+    scale = {"KB": 1, "MB": 1024, "GB": 1024 * 1024}[match.group(2)]
+    return int(float(match.group(1)) * scale)
+
+
+def launch(tag, idle_seconds):
+    report = os.path.join(logs, "%s-%s.time" % (label, tag))
+    log = open(os.path.join(logs, "%s-%s.log" % (label, tag)), "wb")
+    started = time.time()
+    process = subprocess.Popen(["/usr/bin/time", "-l", "-o", report] + command, cwd=cwd,
+                               stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
+    result = {"tag": tag, "ok": False}
+    pid = None
+    try:
+        deadline = time.time() + 20
+        while time.time() < deadline and not pid:
+            kids = children(process.pid)
+            pid = kids[0] if kids else None
+            if not pid:
+                time.sleep(0.002)
+        if not pid:
+            result["error"] = "the application did not start"
+            return result
+        seen = subprocess.run([helper, str(pid), "90"], stdout=subprocess.PIPE, universal_newlines=True)
+        if seen.returncode != 0:
+            result["error"] = "no window within 90 s"
+            return result
+        result["window_ms"] = round((float(seen.stdout.strip()) - started) * 1000.0, 1)
+        result["ok"] = True
+        if idle_seconds > 0:
+            time.sleep(idle_seconds / 2.0)
+            before, wall = cpu_seconds(pid), time.time()
+            time.sleep(idle_seconds / 2.0)
+            after = cpu_seconds(pid)
+            idle_result = {"rss_kb": rss_kb(pid), "footprint_kb": footprint_kb(pid)}
+            if before is not None and after is not None:
+                idle_result["cpu_percent"] = round(100.0 * (after - before) / (time.time() - wall), 2)
+            result["idle"] = idle_result
+        return result
+    finally:
+        if pid:
+            try:
+                os.kill(pid, signal.SIGTERM)
+            except OSError:
+                pass
+        try:
+            process.wait(timeout=15)
+        except subprocess.TimeoutExpired:
+            os.killpg(process.pid, signal.SIGKILL)
+            process.wait()
+        log.close()
+        try:
+            with open(report) as handle:
+                match = re.search(r"(\d+)\s+maximum resident set size", handle.read())
+            if match:
+                result["peak_rss_kb"] = int(match.group(1)) // 1024
+        except OSError:
+            pass
+
+
+def summary(values):
+    if not values:
+        return None
+    return {"median": round(statistics.median(values), 1), "min": round(min(values), 1),
+            "max": round(max(values), 1), "runs": len(values)}
+
+
+launch("primer", 0)
+warm = [launch("warm-%d" % i, 0) for i in range(runs)]
+sessions = [launch("session-%d" % i, idle) for i in range(3)]
+good = [s for s in sessions if s.get("ok") and "idle" in s]
+
+
+def middle(field):
+    values = [s["idle"][field] for s in good if s["idle"].get(field) is not None]
+    return round(statistics.median(values), 2) if values else None
+
+
+peaks = [s["peak_rss_kb"] for s in good if "peak_rss_kb" in s]
+result = {
+    "label": label, "command": command, "idle_seconds": idle, "ok": bool(good),
+    "errors": ["%s: %s" % (s["tag"], s["error"]) for s in warm + sessions if "error" in s],
+    # Only warm: purging the page cache on a desktop Mac needs sudo, and this
+    # script asks for nothing it does not need.
+    "startup_warm": {"window_ms": summary([s["window_ms"] for s in warm if s.get("ok")]),
+                     "first_paint_ms": None, "samples": warm},
+    "idle": {f: middle(f) for f in ("rss_kb", "footprint_kb", "cpu_percent")},
+    "peak_rss_kb": round(statistics.median(peaks)) if peaks else None,
+    "sessions": sessions,
+}
+with open(out, "w") as handle:
+    json.dump(result, handle, indent=2, sort_keys=True)
+print("%s: window %s ms, idle %s" % (label, result["startup_warm"]["window_ms"], result["idle"]))
+PY
+}
+
+if [ -x "$D/baseline/runtime/bin/java" ]; then
+  CP=""
+  for JAR in "$D/baseline/app"/*.jar; do
+    CP="$CP:$JAR"
+  done
+  CP="${CP#:}"
+  MAIN="$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["main_class"])' "$PARTS/baseline.json")"
+  measure jvm_default "$D/baseline/runtime/bin/java" -cp "$CP" "$MAIN"
+  measure jvm_tuned "$D/baseline/runtime/bin/java" -XX:+UseSerialGC -Xss256k -XX:TieredStopAtLevel=1 \
+    "-Xmx${TUNED_XMX}m" -cp "$CP" "$MAIN"
+  python3 - "$PARTS/tuned.json" "$TUNED_XMX" <<'PY'
+import json, sys
+with open(sys.argv[1], "w") as handle:
+    json.dump({"xmx_mb": int(sys.argv[2]), "appcds_bytes": None,
+               "flags": "-XX:+UseSerialGC -Xss256k -XX:TieredStopAtLevel=1 -Xmx%sm (fixed, not searched; no AppCDS)"
+                        % sys.argv[2]}, handle, indent=2)
+PY
+else
+  echo "no baseline runtime image in $D/baseline; run bench.sh --stage build first" >&2
+fi
+
+if [ -f "$D/cn1/executable.txt" ]; then
+  BUNDLE="$D/cn1/dist/$(cat "$D/cn1/executable.txt")"
+  measure cn1_native "$BUNDLE/Contents/MacOS/$(basename "$BUNDLE" .app)"
+else
+  echo "no native Codename One build in $D/cn1; its cells stay empty" >&2
+fi
+
+python3 "$HERE/benchutil.py" assemble "$PARTS" "$D/result.json"
+echo "wrote $D/result.json"
diff --git a/scripts/desktop-compat-benchmarks/win-measure.ps1 b/scripts/desktop-compat-benchmarks/win-measure.ps1
new file mode 100644
index 00000000000..f59eb4ab692
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/win-measure.ps1
@@ -0,0 +1,127 @@
+# The Windows runtime half of the desktop-compat benchmarks.
+#
+#   win-measure.ps1 -Label jvm_default -Out parts\run.jvm_default.json `
+#                   -Exe path\to\java.exe -Arguments '-cp','app\*','Main'
+#
+# UNVALIDATED OUTSIDE CI: nobody has a Windows desktop to run it on by hand, so
+# the first numbers it produces are the workflow's. It writes the same shape of
+# file x11bench.py does, with fewer fields, and report.py prints the missing
+# ones as empty cells:
+#
+#   start-up     process start until the process has a main window (a window
+#                handle, not a painted frame -- the earlier of the two events
+#                the Linux leg reports), warm only
+#   idle RAM     working set (rss_kb) and private bytes (uss_kb) after the idle
+#                window; Windows has no proportional figure, so pss_kb is absent
+#   idle CPU     processor time over the second half of the idle window
+#   peak RSS     peak working set at the end of a session
+#
+# No scripted input: "after interaction" cells stay empty on Windows.
+param(
+    [Parameter(Mandatory = $true)][string]$Label,
+    [Parameter(Mandatory = $true)][string]$Out,
+    [Parameter(Mandatory = $true)][string]$Exe,
+    [string[]]$Arguments = @(),
+    [int]$Runs = 7,
+    [int]$Sessions = 3,
+    [double]$Idle = 10,
+    [int]$TimeoutSeconds = 90
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Start-Measured([double]$IdleSeconds) {
+    $info = New-Object System.Diagnostics.ProcessStartInfo
+    $info.FileName = $Exe
+    $info.Arguments = ($Arguments | ForEach-Object { if ($_ -match '\s') { '"' + $_ + '"' } else { $_ } }) -join ' '
+    $info.UseShellExecute = $false
+    $watch = [System.Diagnostics.Stopwatch]::StartNew()
+    $process = [System.Diagnostics.Process]::Start($info)
+    $result = @{ ok = $false }
+    try {
+        while ($watch.Elapsed.TotalSeconds -lt $TimeoutSeconds) {
+            if ($process.HasExited) {
+                $result.error = "exited with $($process.ExitCode) before showing a window"
+                return $result
+            }
+            $process.Refresh()
+            if ($process.MainWindowHandle -ne [IntPtr]::Zero) {
+                $result.window_ms = [math]::Round($watch.Elapsed.TotalMilliseconds, 1)
+                $result.ok = $true
+                break
+            }
+            Start-Sleep -Milliseconds 4
+        }
+        if (-not $result.ok) {
+            $result.error = "no window within $TimeoutSeconds s"
+            return $result
+        }
+        if ($IdleSeconds -gt 0) {
+            Start-Sleep -Milliseconds ([int]($IdleSeconds * 500))
+            $process.Refresh()
+            $before = $process.TotalProcessorTime.TotalSeconds
+            $mark = [System.Diagnostics.Stopwatch]::StartNew()
+            Start-Sleep -Milliseconds ([int]($IdleSeconds * 500))
+            $process.Refresh()
+            $cpu = 100.0 * ($process.TotalProcessorTime.TotalSeconds - $before) / $mark.Elapsed.TotalSeconds
+            $result.idle = @{
+                rss_kb      = [int64]($process.WorkingSet64 / 1024)
+                uss_kb      = [int64]($process.PrivateMemorySize64 / 1024)
+                threads     = $process.Threads.Count
+                cpu_percent = [math]::Round($cpu, 2)
+            }
+            $result.peak_rss_kb = [int64]($process.PeakWorkingSet64 / 1024)
+        }
+        return $result
+    }
+    finally {
+        if (-not $process.HasExited) {
+            $process.Kill()
+            $process.WaitForExit(15000) | Out-Null
+        }
+    }
+}
+
+function Get-Median($values) {
+    $sorted = @($values | Sort-Object)
+    if ($sorted.Count -eq 0) { return $null }
+    $middle = [int][math]::Floor($sorted.Count / 2)
+    if ($sorted.Count % 2 -eq 1) { return $sorted[$middle] }
+    return ($sorted[$middle - 1] + $sorted[$middle]) / 2.0
+}
+
+Start-Measured 0 | Out-Null
+$warm = @(1..$Runs | ForEach-Object { Start-Measured 0 })
+# Not $sessions: PowerShell names ignore case, so that would be the [int]
+# parameter above, and an array assigned to it fails to convert.
+$idleRuns = @(1..$Sessions | ForEach-Object { Start-Measured $Idle })
+$good = @($idleRuns | Where-Object { $_.ok -and $_.idle })
+$times = @($warm | Where-Object { $_.ok } | ForEach-Object { $_.window_ms })
+
+$summary = $null
+if ($times.Count -gt 0) {
+    $summary = @{
+        median = [math]::Round((Get-Median $times), 1)
+        min    = ($times | Measure-Object -Minimum).Minimum
+        max    = ($times | Measure-Object -Maximum).Maximum
+        runs   = $times.Count
+    }
+}
+$idleResult = @{}
+foreach ($field in 'rss_kb', 'uss_kb', 'threads', 'cpu_percent') {
+    $idleResult[$field] = Get-Median @($good | ForEach-Object { $_.idle[$field] })
+}
+$errors = @(($warm + $idleRuns) | Where-Object { $_.error } | ForEach-Object { $_.error })
+
+$document = @{
+    label        = $Label
+    command      = @($Exe) + $Arguments
+    idle_seconds = $Idle
+    ok           = ($good.Count -gt 0)
+    errors       = $errors
+    startup_warm = @{ window_ms = $summary; first_paint_ms = $null }
+    idle         = $idleResult
+    peak_rss_kb  = Get-Median @($good | ForEach-Object { $_.peak_rss_kb })
+}
+$document | ConvertTo-Json -Depth 6 | Set-Content -Encoding ascii -Path $Out
+Write-Host "${Label}: window $($summary.median) ms, idle RSS $($idleResult.rss_kb) kB, CPU $($idleResult.cpu_percent)%"
diff --git a/scripts/desktop-compat-benchmarks/x11bench.py b/scripts/desktop-compat-benchmarks/x11bench.py
new file mode 100755
index 00000000000..d6e4bbc0de0
--- /dev/null
+++ b/scripts/desktop-compat-benchmarks/x11bench.py
@@ -0,0 +1,760 @@
+#!/usr/bin/env python3
+"""Run one desktop application under a private X server and measure it.
+
+This is the Linux half of the desktop-compat benchmarks. It is handed a command
+line and treats it as a black box, so the JVM baseline and the Codename One
+native binary are launched, watched and driven by exactly the same code:
+
+* a private ``Xvfb`` (and ``openbox``, so both toolkits get focus and a frame
+  the way they would on a desktop) is started for every single launch;
+* **startup** is the time from ``fork`` to the first moment the application's
+  window holds something other than one flat colour. It is read off the X
+  server, never out of the application, so neither variant is instrumented;
+* **memory** is summed over the application's whole process tree from
+  ``/proc/<pid>/smaps_rollup`` (RSS, PSS, USS) and the peak comes from
+  ``/usr/bin/time -v``;
+* **idle CPU** is the user + system time the tree accumulates over the idle
+  window, as a percentage of one core;
+* **scripted input** is injected with XTEST, in window-relative coordinates.
+
+Python 3.9 compatible. Needs python-xlib (``python3-xlib``).
+"""
+
+import argparse
+import json
+import os
+import re
+import shutil
+import signal
+import statistics
+import struct
+import subprocess
+import sys
+import time
+import zlib
+
+try:
+    from Xlib import X, XK, display
+    from Xlib.ext import xtest
+except ImportError:  # pragma: no cover - reported at run time
+    display = None
+
+CLK_TCK = os.sysconf("SC_CLK_TCK")
+PAGE_POLL_SECONDS = 0.010
+# A window counts as painted once this many distinct colours are visible in it.
+# One is an unpainted window, two is a flat background and a border.
+PAINTED_COLOURS = 3
+STRIP_PITCH = 4
+
+
+def log(message):
+    sys.stderr.write("[x11bench] %s\n" % message)
+    sys.stderr.flush()
+
+
+# --------------------------------------------------------------------------
+# /proc readers
+
+
+def process_table():
+    """pid -> parent pid for every process visible in /proc."""
+    table = {}
+    for name in os.listdir("/proc"):
+        if not name.isdigit():
+            continue
+        try:
+            with open("/proc/%s/stat" % name) as handle:
+                data = handle.read()
+        except OSError:
+            continue
+        # The command is parenthesised and may itself contain spaces or ')'.
+        tail = data[data.rfind(")") + 2:].split()
+        table[int(name)] = int(tail[1])
+    return table
+
+
+def descendants(root_pid, include_root):
+    table = process_table()
+    found = []
+    frontier = [root_pid]
+    while frontier:
+        parent = frontier.pop()
+        for pid, ppid in table.items():
+            if ppid == parent and pid not in found:
+                found.append(pid)
+                frontier.append(pid)
+    if include_root and root_pid in table:
+        found.append(root_pid)
+    return found
+
+
+def cpu_ticks(pids):
+    total = 0
+    for pid in pids:
+        try:
+            with open("/proc/%d/stat" % pid) as handle:
+                data = handle.read()
+        except OSError:
+            continue
+        tail = data[data.rfind(")") + 2:].split()
+        total += int(tail[11]) + int(tail[12])
+    return total
+
+
+def memory_kb(pids):
+    """Summed RSS / PSS / USS of the given processes, in kB."""
+    totals = {"rss_kb": 0, "pss_kb": 0, "uss_kb": 0}
+    readable = 0
+    for pid in pids:
+        try:
+            with open("/proc/%d/smaps_rollup" % pid) as handle:
+                text = handle.read()
+        except OSError:
+            continue
+        readable += 1
+        fields = {}
+        for line in text.splitlines():
+            match = re.match(r"^(\w+):\s+(\d+) kB", line)
+            if match:
+                fields[match.group(1)] = int(match.group(2))
+        totals["rss_kb"] += fields.get("Rss", 0)
+        totals["pss_kb"] += fields.get("Pss", 0)
+        totals["uss_kb"] += fields.get("Private_Clean", 0) + fields.get("Private_Dirty", 0)
+    totals["processes"] = readable
+    return totals
+
+
+def thread_count(pids):
+    total = 0
+    for pid in pids:
+        try:
+            total += len(os.listdir("/proc/%d/task" % pid))
+        except OSError:
+            continue
+    return total
+
+
+def evict_from_page_cache(paths):
+    """Make the next launch read its own files from disk again.
+
+    Returns the method that was used. ``drop_caches`` is the real thing and
+    needs a privileged container; ``fadvise`` only evicts the files named, so
+    the system libraries both variants share stay warm.
+    """
+    try:
+        os.sync()
+        with open("/proc/sys/vm/drop_caches", "w") as handle:
+            handle.write("3\n")
+        return "drop_caches"
+    except OSError:
+        pass
+    evicted = 0
+    for root in paths:
+        candidates = []
+        if os.path.isdir(root):
+            for folder, _dirs, files in os.walk(root):
+                candidates.extend(os.path.join(folder, name) for name in files)
+        elif os.path.isfile(root):
+            candidates.append(root)
+        for path in candidates:
+            try:
+                fd = os.open(path, os.O_RDONLY)
+            except OSError:
+                continue
+            try:
+                os.fsync(fd)
+            except OSError:
+                pass
+            try:
+                os.posix_fadvise(fd, 0, 0, os.POSIX_FADV_DONTNEED)
+                evicted += 1
+            except OSError:
+                pass
+            finally:
+                os.close(fd)
+    return "fadvise(%d files)" % evicted
+
+
+# --------------------------------------------------------------------------
+# X server
+
+
+class Screen(object):
+    """A private Xvfb + openbox pair, and the queries the benchmark needs."""
+
+    def __init__(self, size, log_dir):
+        self.size = size
+        self.log_dir = log_dir
+        self.xvfb = None
+        self.wm = None
+        self.name = None
+        self.dpy = None
+        self.gtk_session = False
+
+    def start(self):
+        read_fd, write_fd = os.pipe()
+        xvfb_log = open(os.path.join(self.log_dir, "xvfb.log"), "ab")
+        self.xvfb = subprocess.Popen(
+            ["Xvfb", "-displayfd", str(write_fd), "-screen", "0", self.size + "x24",
+             "-nolisten", "tcp", "-noreset"],
+            pass_fds=[write_fd], stdout=xvfb_log, stderr=xvfb_log)
+        os.close(write_fd)
+        number = b""
+        deadline = time.monotonic() + 20
+        while not number.endswith(b"\n"):
+            if time.monotonic() > deadline:
+                raise RuntimeError("Xvfb did not report a display")
+            chunk = os.read(read_fd, 16)
+            if not chunk:
+                raise RuntimeError("Xvfb exited before reporting a display")
+            number += chunk
+        os.close(read_fd)
+        self.name = ":" + number.decode().strip()
+        self.dpy = display.Display(self.name)
+        if shutil.which("openbox"):
+            wm_log = open(os.path.join(self.log_dir, "openbox.log"), "ab")
+            env = dict(os.environ, DISPLAY=self.name)
+            self.wm = subprocess.Popen(["openbox", "--sm-disable"], env=env,
+                                       stdout=wm_log, stderr=wm_log)
+            # Wait until it owns the root window's substructure redirect.
+            atom = self.dpy.intern_atom("_NET_SUPPORTING_WM_CHECK")
+            deadline = time.monotonic() + 10
+            while time.monotonic() < deadline:
+                if self.dpy.screen().root.get_full_property(atom, X.AnyPropertyType):
+                    break
+                time.sleep(0.05)
+        self.gtk_session = self.start_gtk_session()
+        return self.name
+
+    def start_gtk_session(self):
+        """Makes the new X server one a GTK program has already run on.
+
+        The first GTK 3 program on an X server initialises GL to choose its
+        visuals and then records the choice on the root window (GDK_VISUALS),
+        "to avoid having to initialize GL each time, as it may not be used
+        later" in GDK's words. Every later program reads the property and never
+        loads a GL driver. A desktop session has had its first GTK program long
+        before an application starts; a private Xvfb has not, so each launch
+        measured here WAS the first one, and carried Mesa's llvmpipe with it:
+        53 MB of the resident set of a native Notepad (108 MB, against 56 MB
+        launched second on the same server), none of it the application's.
+        One bare gtk_init, as a process of its own that exits, puts the server
+        in the state a session leaves it in. Returns whether it did.
+        """
+        code = ("import ctypes, sys; "
+                "sys.exit(0 if ctypes.CDLL('libgtk-3.so.0').gtk_init_check(None, None) else 1)")
+        env = dict(os.environ, DISPLAY=self.name, NO_AT_BRIDGE="1")
+        env.setdefault("LIBGL_ALWAYS_SOFTWARE", "1")
+        try:
+            with open(os.path.join(self.log_dir, "gtk-session.log"), "ab") as out:
+                return subprocess.call([sys.executable, "-c", code], env=env,
+                                       stdout=out, stderr=out, timeout=30) == 0
+        except (OSError, subprocess.SubprocessError):
+            return False
+
+    def stop(self):
+        for process in (self.wm, self.xvfb):
+            if process is None:
+                continue
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except Exception:  # noqa: BLE001 - best effort teardown
+                try:
+                    process.kill()
+                except Exception:  # noqa: BLE001
+                    pass
+        try:
+            if self.dpy is not None:
+                self.dpy.close()
+        except Exception:  # noqa: BLE001
+            pass
+
+    def application_window(self):
+        """Geometry (x, y, w, h) of the largest viewable top-level window."""
+        root = self.dpy.screen().root
+        best = None
+        try:
+            children = root.query_tree().children
+        except Exception:  # noqa: BLE001 - a window vanished mid-query
+            return None
+        for child in children:
+            try:
+                attributes = child.get_attributes()
+                if attributes.map_state != X.IsViewable or attributes.win_class != X.InputOutput:
+                    continue
+                geometry = child.get_geometry()
+            except Exception:  # noqa: BLE001
+                continue
+            if geometry.width < 100 or geometry.height < 100:
+                continue
+            area = geometry.width * geometry.height
+            if best is None or area > best[0]:
+                best = (area, (geometry.x, geometry.y, geometry.width, geometry.height))
+        return best[1] if best else None
+
+    def colours(self, geometry):
+        """(distinct colours, fingerprint) of horizontal strips through a window.
+
+        Strips, not the whole window: a full-screen GetImage every poll would
+        make the measuring process the busiest thing on the machine. The top is
+        skipped so a window manager's title bar cannot count as paint.
+        """
+        root = self.dpy.screen().root
+        screen = self.dpy.screen()
+        x, y, width, height = geometry
+        left = max(0, x + width // 20)
+        right = min(screen.width_in_pixels, x + width - width // 20)
+        top = max(0, y + max(40, height // 10))
+        bottom = min(screen.height_in_pixels, y + height - height // 20)
+        if right - left < 20 or bottom - top < 8:
+            return 0, 0
+        seen = set()
+        fingerprint = 0
+        row = top
+        while row < bottom:
+            try:
+                image = root.get_image(left, row, right - left, 1, X.ZPixmap, 0xFFFFFFFF)
+            except Exception:  # noqa: BLE001
+                return 0, 0
+            data = image.data
+            if isinstance(data, str):
+                data = data.encode("latin-1")
+            usable = len(data) - (len(data) % 4)
+            seen.update(memoryview(data[:usable]).cast("I"))
+            fingerprint = hash((fingerprint, data))
+            row += STRIP_PITCH
+        return len(seen), fingerprint
+
+    def screenshot(self, geometry, path):
+        """Write the window as a PNG: the evidence that what was timed is the
+        application's own first screen and not an error dialog."""
+        root = self.dpy.screen().root
+        screen = self.dpy.screen()
+        x, y, width, height = geometry
+        x = max(0, x)
+        y = max(0, y)
+        width = min(width, screen.width_in_pixels - x)
+        height = min(height, screen.height_in_pixels - y)
+        rows = []
+        try:
+            for row in range(height):
+                data = root.get_image(x, y + row, width, 1, X.ZPixmap, 0xFFFFFFFF).data
+                if isinstance(data, str):
+                    data = data.encode("latin-1")
+                pixels = bytearray(width * 3)
+                pixels[0::3] = data[2:width * 4:4]
+                pixels[1::3] = data[1:width * 4:4]
+                pixels[2::3] = data[0:width * 4:4]
+                rows.append(b"\x00" + bytes(pixels))
+        except Exception:  # noqa: BLE001
+            return False
+
+        def chunk(kind, payload):
+            body = kind + payload
+            return struct.pack(">I", len(payload)) + body + struct.pack(">I", zlib.crc32(body))
+
+        with open(path, "wb") as handle:
+            handle.write(b"\x89PNG\r\n\x1a\n")
+            handle.write(chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)))
+            handle.write(chunk(b"IDAT", zlib.compress(b"".join(rows), 6)))
+            handle.write(chunk(b"IEND", b""))
+        return True
+
+    # -- input ---------------------------------------------------------
+
+    def pointer(self, px, py):
+        xtest.fake_input(self.dpy, X.MotionNotify, x=int(px), y=int(py))
+        self.dpy.sync()
+
+    def click(self, px, py, button=1):
+        self.pointer(px, py)
+        time.sleep(0.03)
+        xtest.fake_input(self.dpy, X.ButtonPress, button)
+        self.dpy.sync()
+        time.sleep(0.03)
+        xtest.fake_input(self.dpy, X.ButtonRelease, button)
+        self.dpy.sync()
+
+    def key(self, name):
+        keysym = XK.string_to_keysym(name)
+        if keysym == 0:
+            raise ValueError("unknown key name: %s" % name)
+        keycode = self.dpy.keysym_to_keycode(keysym)
+        if keycode == 0:
+            raise ValueError("no keycode for key: %s" % name)
+        xtest.fake_input(self.dpy, X.KeyPress, keycode)
+        self.dpy.sync()
+        time.sleep(0.02)
+        xtest.fake_input(self.dpy, X.KeyRelease, keycode)
+        self.dpy.sync()
+
+
+ARMS = ("jvm", "cn1")
+
+
+def arm_of(label):
+    """The arm a variant belongs to: the Codename One build, or a JVM."""
+    return "cn1" if label.startswith("cn1") else "jvm"
+
+
+def parse_script(path, arm=None):
+    """Read an input script: one action per line, '#' starts a comment.
+
+    sleep SECONDS | move FX FY | click FX FY | key NAME | type TEXT
+    FX and FY are fractions of the application window, so one script drives
+    both variants even though their windows are not the same size.
+
+    A line that starts with "jvm:" or "cn1:" is for that arm alone. The two
+    builds do not lay a window out alike -- a native look is taller -- so a
+    script that is to press the same control in both names it once for each:
+
+        jvm: click 0.47 0.56
+        cn1: click 0.64 0.61
+    """
+    actions = []
+    with open(path) as handle:
+        for number, raw in enumerate(handle, 1):
+            line = raw.split("#", 1)[0].strip()
+            if not line:
+                continue
+            head = line.split(":", 1)[0]
+            if head in ARMS:
+                if arm is not None and head != arm:
+                    continue
+                line = line.split(":", 1)[1].strip()
+                if not line:
+                    continue
+            parts = line.split(None, 1)
+            verb = parts[0]
+            argument = parts[1] if len(parts) > 1 else ""
+            if verb == "sleep":
+                actions.append(("sleep", float(argument)))
+            elif verb in ("move", "click"):
+                fx, fy = argument.split()
+                actions.append((verb, float(fx), float(fy)))
+            elif verb == "key":
+                actions.append(("key", argument.strip()))
+            elif verb == "type":
+                actions.append(("type", argument))
+            else:
+                raise ValueError("%s:%d: unknown action %r" % (path, number, verb))
+    return actions
+
+
+KEY_NAMES = {" ": "space", ".": "period", ",": "comma", "-": "minus"}
+
+
+def play_script(screen, actions, alive):
+    for action in actions:
+        if not alive():
+            return False
+        verb = action[0]
+        if verb == "sleep":
+            time.sleep(action[1])
+            continue
+        if verb in ("move", "click"):
+            geometry = screen.application_window()
+            if geometry is None:
+                continue
+            x, y, width, height = geometry
+            px = x + action[1] * width
+            py = y + action[2] * height
+            if verb == "move":
+                screen.pointer(px, py)
+            else:
+                screen.click(px, py)
+        elif verb == "key":
+            screen.key(action[1])
+        elif verb == "type":
+            for character in action[1]:
+                screen.key(KEY_NAMES.get(character, character))
+                time.sleep(0.03)
+        time.sleep(0.12)
+    return alive()
+
+
+# --------------------------------------------------------------------------
+# one launch
+
+
+def parse_time_report(path):
+    try:
+        with open(path) as handle:
+            text = handle.read()
+    except OSError:
+        return None
+    match = re.search(r"Maximum resident set size \(kbytes\): (\d+)", text)
+    return int(match.group(1)) if match else None
+
+
+def launch(command, cwd, env, size, log_dir, tag, idle_seconds, script, settle_seconds,
+           startup_timeout, screenshots=False):
+    """Start the application once and measure it. Returns a dict."""
+    os.makedirs(log_dir, exist_ok=True)
+    screen = Screen(size, log_dir)
+    result = {"tag": tag, "ok": False}
+    time_report = os.path.join(log_dir, tag + ".time")
+    if os.path.exists(time_report):
+        os.remove(time_report)
+    app_log = open(os.path.join(log_dir, tag + ".log"), "wb")
+    process = None
+    try:
+        name = screen.start()
+        result["gtk_session"] = screen.gtk_session
+        child_env = dict(os.environ)
+        child_env.update(env)
+        child_env["DISPLAY"] = name
+        # No accessibility bus: it is a second process the JVM and GTK would
+        # each start, and it is not part of either application.
+        child_env["NO_AT_BRIDGE"] = "1"
+        child_env.setdefault("LIBGL_ALWAYS_SOFTWARE", "1")
+        started = time.monotonic()
+        process = subprocess.Popen(
+            ["/usr/bin/time", "-v", "-o", time_report] + list(command),
+            cwd=cwd, env=child_env, stdout=app_log, stderr=subprocess.STDOUT,
+            start_new_session=True)
+
+        def alive():
+            return process.poll() is None
+
+        def tree():
+            return descendants(process.pid, False)
+
+        window_at = None
+        painted_at = None
+        geometry = None
+        fingerprint = None
+        changed_at = None
+        deadline = started + startup_timeout
+        while time.monotonic() < deadline and alive():
+            now = time.monotonic()
+            geometry = screen.application_window()
+            if geometry is not None:
+                if window_at is None:
+                    window_at = now
+                colours, current = screen.colours(geometry)
+                if colours >= PAINTED_COLOURS:
+                    painted_at = time.monotonic()
+                    fingerprint = current
+                    changed_at = painted_at
+                    break
+            time.sleep(PAGE_POLL_SECONDS)
+        if painted_at is None:
+            result["error"] = ("exited before painting (status %s)" % process.returncode
+                               if not alive() else "no painted window within %ds" % startup_timeout)
+            return result
+        result["window_ms"] = round((window_at - started) * 1000.0, 1)
+        result["first_paint_ms"] = round((painted_at - started) * 1000.0, 1)
+
+        # When did the window stop changing? One quiet second ends the search;
+        # an application that animates forever never settles and reports null.
+        settled_at = None
+        search_until = painted_at + 8.0
+        while time.monotonic() < search_until and alive():
+            geometry = screen.application_window() or geometry
+            _colours, current = screen.colours(geometry)
+            now = time.monotonic()
+            if current != fingerprint:
+                fingerprint = current
+                changed_at = now
+            elif now - changed_at >= 1.0:
+                settled_at = changed_at
+                break
+            time.sleep(0.02)
+        result["settled_ms"] = (round((settled_at - started) * 1000.0, 1)
+                                if settled_at is not None else None)
+        result["window_size"] = [geometry[2], geometry[3]]
+        result["ok"] = True
+
+        if idle_seconds > 0:
+            # Idle: RAM at the end of the window, CPU across the second half of
+            # it so the tail of startup work is not billed as idling.
+            time.sleep(idle_seconds / 2.0)
+            ticks_before = cpu_ticks(tree())
+            wall_before = time.monotonic()
+            fingerprint_before = screen.colours(screen.application_window() or geometry)[1]
+            repaints = 0
+            while time.monotonic() - wall_before < idle_seconds / 2.0:
+                time.sleep(0.25)
+                current = screen.colours(screen.application_window() or geometry)[1]
+                if current != fingerprint_before:
+                    repaints += 1
+                    fingerprint_before = current
+            wall = time.monotonic() - wall_before
+            pids = tree()
+            ticks = cpu_ticks(pids) - ticks_before
+            idle = memory_kb(pids)
+            idle["threads"] = thread_count(pids)
+            idle["cpu_percent"] = round(100.0 * ticks / CLK_TCK / wall, 2)
+            idle["cpu_window_seconds"] = round(wall, 2)
+            idle["visible_changes"] = repaints
+            result["idle"] = idle
+            if screenshots:
+                screen.screenshot(screen.application_window() or geometry,
+                                  os.path.join(log_dir, tag + "-idle.png"))
+            if not alive():
+                result["ok"] = False
+                result["error"] = "exited while idle (status %s)" % process.returncode
+                return result
+
+        if script:
+            survived = play_script(screen, script, alive)
+            time.sleep(settle_seconds)
+            if not survived or not alive():
+                result["ok"] = False
+                result["error"] = "exited during the input script (status %s)" % process.returncode
+                return result
+            pids = tree()
+            after = memory_kb(pids)
+            after["threads"] = thread_count(pids)
+            result["after_script"] = after
+            if screenshots:
+                screen.screenshot(screen.application_window() or geometry,
+                                  os.path.join(log_dir, tag + "-after.png"))
+        return result
+    finally:
+        if process is not None:
+            if process.poll() is None:
+                # The application, not /usr/bin/time: time then reports and exits.
+                for pid in descendants(process.pid, False):
+                    try:
+                        os.kill(pid, signal.SIGTERM)
+                    except OSError:
+                        pass
+                try:
+                    process.wait(timeout=10)
+                except subprocess.TimeoutExpired:
+                    try:
+                        os.killpg(process.pid, signal.SIGKILL)
+                    except OSError:
+                        pass
+                    process.wait()
+            peak = parse_time_report(time_report)
+            if peak is not None:
+                result["peak_rss_kb"] = peak
+        screen.stop()
+        app_log.close()
+
+
+def summary(values):
+    if not values:
+        return None
+    return {"median": round(statistics.median(values), 1), "min": round(min(values), 1),
+            "max": round(max(values), 1), "runs": len(values)}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--label", required=True, help="name of this variant in the output")
+    parser.add_argument("--out", required=True, help="JSON file to write")
+    parser.add_argument("--log-dir", required=True, help="directory for logs and scratch files")
+    parser.add_argument("--cwd", default=None, help="working directory of the application")
+    parser.add_argument("--env", action="append", default=[], metavar="NAME=VALUE")
+    parser.add_argument("--screen", default="1280x800", help="Xvfb screen size")
+    parser.add_argument("--startup-runs", type=int, default=7)
+    parser.add_argument("--session-runs", type=int, default=3)
+    parser.add_argument("--idle-seconds", type=float, default=10.0)
+    parser.add_argument("--settle-seconds", type=float, default=3.0)
+    parser.add_argument("--startup-timeout", type=float, default=90.0)
+    parser.add_argument("--script", default=None, help="input script (see parse_script)")
+    parser.add_argument("--arm", default=None, choices=ARMS,
+                        help="which arm's lines of the script to play "
+                             "(default: cn1 for a label that starts with cn1, else jvm)")
+    parser.add_argument("--evict", action="append", default=[], metavar="PATH",
+                        help="file or directory to evict before each cold start")
+    parser.add_argument("--check-only", action="store_true",
+                        help="one session, exit 0 only if it survives the script")
+    parser.add_argument("command", nargs=argparse.REMAINDER)
+    args = parser.parse_args()
+
+    if display is None:
+        sys.exit("python-xlib is required (apt install python3-xlib)")
+    command = args.command
+    if command and command[0] == "--":
+        command = command[1:]
+    if not command:
+        parser.error("no command given")
+    env = {}
+    for item in args.env:
+        name, _sep, value = item.partition("=")
+        env[name] = value
+    script = parse_script(args.script, args.arm or arm_of(args.label)) if args.script else None
+    os.makedirs(args.log_dir, exist_ok=True)
+
+    def one(tag, idle, with_script):
+        return launch(command, args.cwd, env, args.screen, args.log_dir, tag, idle,
+                      script if with_script else None, args.settle_seconds, args.startup_timeout,
+                      screenshots=tag in ("check", "session-0"))
+
+    report = {"label": args.label, "command": command, "screen": args.screen,
+              "idle_seconds": args.idle_seconds, "errors": []}
+
+    if args.check_only:
+        outcome = one("check", 2.0, True)
+        report["check"] = outcome
+        with open(args.out, "w") as handle:
+            json.dump(report, handle, indent=2, sort_keys=True)
+        sys.exit(0 if outcome.get("ok") else 1)
+
+    # One throwaway launch so first-run side effects (font caches, JavaFX
+    # extracting natives, a settings directory being created) are in no sample.
+    primer = one("primer", 0, False)
+    if not primer.get("ok"):
+        report["errors"].append("primer: " + primer.get("error", "failed"))
+        report["ok"] = False
+        with open(args.out, "w") as handle:
+            json.dump(report, handle, indent=2, sort_keys=True)
+        log("%s: %s" % (args.label, report["errors"][0]))
+        sys.exit(1)
+
+    for mode in ("cold", "warm"):
+        samples = []
+        for index in range(args.startup_runs):
+            method = None
+            if mode == "cold":
+                method = evict_from_page_cache(args.evict)
+                report["cold_method"] = method
+            outcome = one("%s-%d" % (mode, index), 0, False)
+            if outcome.get("ok"):
+                samples.append(outcome)
+            else:
+                report["errors"].append("%s-%d: %s" % (mode, index, outcome.get("error")))
+        report["startup_" + mode] = {
+            "first_paint_ms": summary([s["first_paint_ms"] for s in samples]),
+            "window_ms": summary([s["window_ms"] for s in samples]),
+            "settled_ms": summary([s["settled_ms"] for s in samples
+                                   if s.get("settled_ms") is not None]),
+            "samples": samples,
+        }
+        log("%s %s first paint: %s" % (args.label, mode, report["startup_" + mode]["first_paint_ms"]))
+
+    sessions = []
+    for index in range(args.session_runs):
+        outcome = one("session-%d" % index, args.idle_seconds, True)
+        sessions.append(outcome)
+        if not outcome.get("ok"):
+            report["errors"].append("session-%d: %s" % (index, outcome.get("error")))
+    good = [s for s in sessions if s.get("ok")]
+
+    def middle(section, field):
+        values = [s[section][field] for s in good if section in s and field in s[section]]
+        return round(statistics.median(values), 2) if values else None
+
+    report["sessions"] = sessions
+    report["idle"] = {field: middle("idle", field) for field in
+                      ("rss_kb", "pss_kb", "uss_kb", "threads", "cpu_percent", "visible_changes")}
+    report["after_script"] = {field: middle("after_script", field) for field in
+                              ("rss_kb", "pss_kb", "uss_kb", "threads")}
+    peaks = [s["peak_rss_kb"] for s in good if "peak_rss_kb" in s]
+    report["peak_rss_kb"] = round(statistics.median(peaks)) if peaks else None
+    report["ok"] = bool(good)
+    with open(args.out, "w") as handle:
+        json.dump(report, handle, indent=2, sort_keys=True)
+    log("%s idle: %s" % (args.label, report["idle"]))
+    sys.exit(0 if report["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/desktop-compat-samples/javafx-gallery/pom.xml b/scripts/desktop-compat-samples/javafx-gallery/pom.xml
new file mode 100644
index 00000000000..819b6a4e6a7
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/pom.xml
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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.example</groupId>
+    <artifactId>javafx-gallery</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>JavaFX Gallery</name>
+    <description>A plain JavaFX desktop application: controls, layouts, bindings, FXML, CSS, shapes,
+        animation, dialogs and background tasks.</description>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.release>17</maven.compiler.release>
+        <javafx.version>17.0.2</javafx.version>
+        <exec.mainClass>com.example.fxgallery.GalleryApp</exec.mainClass>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-controls</artifactId>
+            <version>${javafx.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-fxml</artifactId>
+            <version>${javafx.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+            </plugin>
+            <plugin>
+                <groupId>org.openjfx</groupId>
+                <artifactId>javafx-maven-plugin</artifactId>
+                <version>0.0.8</version>
+                <configuration>
+                    <mainClass>com.example.fxgallery/com.example.fxgallery.GalleryApp</mainClass>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/AnimationTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/AnimationTab.java
new file mode 100644
index 00000000000..5d0a16cd8d4
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/AnimationTab.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import javafx.animation.Animation;
+import javafx.animation.AnimationTimer;
+import javafx.animation.FadeTransition;
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.ParallelTransition;
+import javafx.animation.RotateTransition;
+import javafx.animation.SequentialTransition;
+import javafx.animation.Timeline;
+import javafx.animation.TranslateTransition;
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Duration;
+
+/**
+ * Timelines, transitions and a frame timer.
+ */
+public class AnimationTab extends VBox {
+
+    private final Rectangle bar = new Rectangle(20, 20, 40, 24);
+    private final Circle ball = new Circle(40, 100, 16, Color.TOMATO);
+    private final Rectangle box = new Rectangle(20, 150, 40, 40);
+    private final Label frames = new Label("0 frames");
+    private final Label clock = new Label("0 s");
+
+    private final Timeline timeline;
+    private final Animation transitions;
+    private final AnimationTimer timer;
+    private long frameCount;
+    private int seconds;
+
+    public AnimationTab() {
+        super(10);
+        setPadding(new Insets(12));
+
+        bar.setFill(Color.ROYALBLUE);
+        box.setFill(Color.MEDIUMSEAGREEN);
+        Pane stage = new Pane(bar, ball, box);
+        stage.setPrefSize(420, 210);
+        stage.setStyle("-fx-background-color: white; -fx-border-color: lightgray;");
+
+        timeline = new Timeline(
+                new KeyFrame(Duration.ZERO, new KeyValue(bar.widthProperty(), 40)),
+                new KeyFrame(Duration.millis(900), new KeyValue(bar.widthProperty(), 360, Interpolator.EASE_BOTH)),
+                new KeyFrame(Duration.seconds(1), event -> clock.setText(++seconds + " s")));
+        timeline.setCycleCount(Animation.INDEFINITE);
+        timeline.setAutoReverse(true);
+
+        TranslateTransition slide = new TranslateTransition(Duration.millis(800), ball);
+        slide.setByX(320);
+        slide.setInterpolator(Interpolator.EASE_OUT);
+        FadeTransition fade = new FadeTransition(Duration.millis(800), ball);
+        fade.setFromValue(1.0);
+        fade.setToValue(0.2);
+        RotateTransition spin = new RotateTransition(Duration.millis(600), box);
+        spin.setByAngle(180);
+        TranslateTransition back = new TranslateTransition(Duration.millis(400), ball);
+        back.setToX(0);
+        FadeTransition appear = new FadeTransition(Duration.millis(400), ball);
+        appear.setToValue(1.0);
+        transitions = new SequentialTransition(new ParallelTransition(slide, fade), spin,
+                new ParallelTransition(back, appear));
+        transitions.setOnFinished(event -> frames.setText(frameCount + " frames, transitions finished"));
+
+        timer = new AnimationTimer() {
+            @Override
+            public void handle(long now) {
+                frameCount++;
+                if (frameCount % 30 == 0) {
+                    frames.setText(frameCount + " frames");
+                }
+            }
+        };
+
+        Button play = new Button("Play");
+        play.setOnAction(event -> start());
+        Button pause = new Button("Pause");
+        pause.setOnAction(event -> {
+            timeline.pause();
+            transitions.pause();
+        });
+        Button stop = new Button("Stop");
+        stop.setOnAction(event -> stop());
+
+        getChildren().addAll(stage, new HBox(8, play, pause, stop), new HBox(16, clock, frames));
+    }
+
+    private void start() {
+        timeline.play();
+        transitions.play();
+        timer.start();
+    }
+
+    private void stop() {
+        timeline.stop();
+        transitions.stop();
+        timer.stop();
+        bar.setWidth(40);
+        ball.setTranslateX(0);
+        ball.setOpacity(1);
+        box.setRotate(0);
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/BindingsTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/BindingsTab.java
new file mode 100644
index 00000000000..7c4ea288007
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/BindingsTab.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.NumberBinding;
+import javafx.beans.binding.StringBinding;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.Slider;
+import javafx.scene.control.TextArea;
+import javafx.scene.control.TextField;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+
+/**
+ * Properties, listeners and the bindings between them.
+ */
+public class BindingsTab extends VBox {
+
+    private final IntegerProperty clicks = new SimpleIntegerProperty(this, "clicks", 0);
+    private final ObservableList<String> entries = FXCollections.observableArrayList();
+    private final TextArea history = new TextArea();
+
+    public BindingsTab() {
+        super(10);
+        setPadding(new Insets(12));
+        getChildren().addAll(mirror(), greeting(), conditional(), arithmetic(), counter(), list(), history);
+        history.setEditable(false);
+        history.setPrefRowCount(5);
+    }
+
+    private HBox mirror() {
+        TextField left = new TextField("type here");
+        TextField right = new TextField();
+        right.textProperty().bindBidirectional(left.textProperty());
+        return new HBox(8, new Label("Bidirectional:"), left, right);
+    }
+
+    private HBox greeting() {
+        TextField first = new TextField("Ada");
+        TextField last = new TextField("Lovelace");
+        StringBinding full = Bindings.createStringBinding(
+                () -> "Hello, " + first.getText().trim() + " " + last.getText().trim() + "!",
+                first.textProperty(), last.textProperty());
+        Label label = new Label();
+        label.textProperty().bind(full);
+
+        Button clear = new Button("Clear");
+        clear.disableProperty().bind(first.textProperty().isEmpty().and(last.textProperty().isEmpty()));
+        clear.setOnAction(event -> {
+            first.clear();
+            last.clear();
+        });
+        return new HBox(8, first, last, clear, label);
+    }
+
+    private HBox conditional() {
+        CheckBox enabled = new CheckBox("Enabled");
+        Label state = new Label();
+        state.textProperty().bind(Bindings.when(enabled.selectedProperty()).then("Switched on").otherwise("Switched off"));
+        state.styleProperty().bind(Bindings.when(enabled.selectedProperty())
+                .then("-fx-text-fill: green;").otherwise("-fx-text-fill: gray;"));
+        return new HBox(8, enabled, state);
+    }
+
+    private HBox arithmetic() {
+        Slider width = new Slider(1, 20, 4);
+        Slider height = new Slider(1, 20, 5);
+        NumberBinding area = width.valueProperty().multiply(height.valueProperty());
+        Label label = new Label();
+        label.textProperty().bind(Bindings.format("%.1f x %.1f = %.1f", width.valueProperty(),
+                height.valueProperty(), area));
+        Label big = new Label("large");
+        big.visibleProperty().bind(area.greaterThan(100));
+        return new HBox(8, width, height, label, big);
+    }
+
+    private HBox counter() {
+        Button button = new Button("Count");
+        button.setOnAction(event -> clicks.set(clicks.get() + 1));
+        Label label = new Label();
+        label.textProperty().bind(clicks.asString("Clicked %d times"));
+
+        ChangeListener<Number> listener = (observable, before, now) ->
+                entries.add("clicks: " + before + " -> " + now);
+        clicks.addListener(listener);
+
+        Button reset = new Button("Reset");
+        reset.setOnAction(event -> {
+            clicks.removeListener(listener);
+            clicks.set(0);
+            clicks.addListener(listener);
+            entries.clear();
+        });
+        return new HBox(8, button, reset, label);
+    }
+
+    private HBox list() {
+        TextField entry = new TextField();
+        entry.setPromptText("Add an entry");
+        Button add = new Button("Add");
+        add.disableProperty().bind(entry.textProperty().isEmpty());
+        add.setOnAction(event -> {
+            entries.add(entry.getText());
+            entry.clear();
+        });
+        entries.addListener((ListChangeListener<String>) change -> {
+            while (change.next()) {
+                for (String added : change.getAddedSubList()) {
+                    history.appendText("+ " + added + "\n");
+                }
+                if (change.wasRemoved()) {
+                    history.appendText("- " + change.getRemovedSize() + " removed\n");
+                }
+            }
+        });
+        Label size = new Label();
+        size.textProperty().bind(Bindings.size(entries).asString("%d entries"));
+        return new HBox(8, entry, add, size);
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/ControlsTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/ControlsTab.java
new file mode 100644
index 00000000000..c0f41755deb
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/ControlsTab.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import java.time.LocalDate;
+
+import javafx.collections.FXCollections;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.DatePicker;
+import javafx.scene.control.Hyperlink;
+import javafx.scene.control.Label;
+import javafx.scene.control.PasswordField;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.control.ProgressIndicator;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.Separator;
+import javafx.scene.control.Slider;
+import javafx.scene.control.TextArea;
+import javafx.scene.control.TextField;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.control.Tooltip;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+
+/**
+ * The standard controls, created and wired in code.
+ */
+public class ControlsTab extends ScrollPane {
+
+    private final Label echo = new Label("Nothing happened yet");
+
+    public ControlsTab() {
+        VBox content = new VBox(10);
+        content.setPadding(new Insets(12));
+        content.getChildren().addAll(
+                header(),
+                buttons(),
+                new Separator(),
+                choices(),
+                new Separator(),
+                textInputs(),
+                new Separator(),
+                selectors(),
+                new Separator(),
+                ranges(),
+                echo);
+        echo.getStyleClass().add("echo");
+        setContent(content);
+        setFitToWidth(true);
+    }
+
+    private HBox header() {
+        ImageView logo = new ImageView(new Image(getClass().getResourceAsStream("images/logo.png")));
+        logo.setFitHeight(32);
+        logo.setPreserveRatio(true);
+        Label title = new Label("Controls");
+        title.getStyleClass().add("title");
+        HBox box = new HBox(8, logo, title);
+        box.setAlignment(Pos.CENTER_LEFT);
+        return box;
+    }
+
+    private HBox buttons() {
+        Button plain = new Button("Click me");
+        plain.setTooltip(new Tooltip("A plain button"));
+        plain.setOnAction(event -> echo.setText("Button clicked"));
+
+        Button primary = new Button("Primary");
+        primary.setId("primary-button");
+        primary.getStyleClass().add("primary");
+        primary.setDefaultButton(true);
+        primary.setOnAction(event -> echo.setText("Primary clicked"));
+
+        Button styled = new Button("Inline style");
+        styled.setStyle("-fx-background-color: #2e7d32; -fx-text-fill: white; -fx-background-radius: 12;");
+
+        Button disabled = new Button("Disabled");
+        disabled.setDisable(true);
+
+        ToggleButton toggle = new ToggleButton("Toggle");
+        toggle.selectedProperty().addListener((observable, was, is) ->
+                echo.setText(is ? "Toggle is on" : "Toggle is off"));
+
+        Hyperlink link = new Hyperlink("A hyperlink");
+        link.setOnAction(event -> echo.setText("Link followed"));
+
+        return new HBox(8, plain, primary, styled, disabled, toggle, link);
+    }
+
+    private VBox choices() {
+        CheckBox news = new CheckBox("Send me the newsletter");
+        news.setSelected(true);
+        news.setOnAction(event -> echo.setText("Newsletter: " + news.isSelected()));
+
+        CheckBox terms = new CheckBox("Three states");
+        terms.setAllowIndeterminate(true);
+        terms.setIndeterminate(true);
+
+        ToggleGroup size = new ToggleGroup();
+        RadioButton small = new RadioButton("Small");
+        RadioButton medium = new RadioButton("Medium");
+        RadioButton large = new RadioButton("Large");
+        small.setToggleGroup(size);
+        medium.setToggleGroup(size);
+        large.setToggleGroup(size);
+        medium.setSelected(true);
+        size.selectedToggleProperty().addListener((observable, before, now) -> {
+            if (now instanceof RadioButton) {
+                echo.setText("Size: " + ((RadioButton) now).getText());
+            }
+        });
+
+        return new VBox(6, news, terms, new HBox(12, small, medium, large));
+    }
+
+    private VBox textInputs() {
+        TextField name = new TextField();
+        name.setPromptText("Your name");
+        name.setPrefColumnCount(20);
+        name.setOnAction(event -> echo.setText("Hello, " + name.getText()));
+
+        PasswordField password = new PasswordField();
+        password.setPromptText("Password");
+
+        TextArea notes = new TextArea("Several lines\nof text");
+        notes.setPrefRowCount(3);
+        notes.setWrapText(true);
+
+        Label length = new Label();
+        length.textProperty().bind(notes.textProperty().length().asString("%d characters"));
+
+        return new VBox(6, name, password, notes, length);
+    }
+
+    private HBox selectors() {
+        ComboBox<String> fruit = new ComboBox<>(FXCollections.observableArrayList("Apple", "Banana", "Cherry"));
+        fruit.setPromptText("Fruit");
+        fruit.setOnAction(event -> echo.setText("Fruit: " + fruit.getValue()));
+
+        ComboBox<String> editable = new ComboBox<>();
+        editable.getItems().addAll("Red", "Green", "Blue");
+        editable.setEditable(true);
+        editable.setValue("Green");
+
+        ChoiceBox<String> size = new ChoiceBox<>();
+        size.getItems().addAll("S", "M", "L", "XL");
+        size.getSelectionModel().select(1);
+        size.getSelectionModel().selectedItemProperty().addListener(
+                (observable, before, now) -> echo.setText("Choice: " + now));
+
+        DatePicker date = new DatePicker(LocalDate.of(2024, 2, 29));
+        date.setOnAction(event -> echo.setText("Date: " + date.getValue()));
+
+        return new HBox(8, fruit, editable, size, date);
+    }
+
+    private VBox ranges() {
+        Slider slider = new Slider(0, 100, 40);
+        slider.setShowTickMarks(true);
+        slider.setShowTickLabels(true);
+        slider.setMajorTickUnit(25);
+        slider.setBlockIncrement(5);
+
+        ProgressBar bar = new ProgressBar();
+        bar.setPrefWidth(240);
+        bar.progressProperty().bind(slider.valueProperty().divide(100));
+
+        ProgressIndicator indicator = new ProgressIndicator();
+        indicator.progressProperty().bind(bar.progressProperty());
+
+        ProgressIndicator busy = new ProgressIndicator(ProgressIndicator.INDETERMINATE_PROGRESS);
+        busy.setPrefSize(28, 28);
+
+        Label value = new Label();
+        value.textProperty().bind(slider.valueProperty().asString("%.0f"));
+
+        HBox row = new HBox(10, bar, indicator, busy, value);
+        row.setAlignment(Pos.CENTER_LEFT);
+        return new VBox(6, slider, row);
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/DataTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/DataTab.java
new file mode 100644
index 00000000000..d8273737fbc
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/DataTab.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import com.example.fxgallery.model.Person;
+
+import javafx.beans.binding.Bindings;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.collections.transformation.FilteredList;
+import javafx.collections.transformation.SortedList;
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.Label;
+import javafx.scene.control.ListCell;
+import javafx.scene.control.ListView;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.SelectionMode;
+import javafx.scene.control.SplitPane;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.TextField;
+import javafx.scene.control.cell.TextFieldTableCell;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Circle;
+
+/**
+ * A list with a cell factory and a sortable, filterable, editable table over the same people.
+ */
+public class DataTab extends BorderPane {
+
+    private final ObservableList<Person> people = FXCollections.observableArrayList(
+            new Person("Ada Lovelace", "London", 36, true),
+            new Person("Grace Hopper", "New York", 85, true),
+            new Person("Alan Turing", "Manchester", 41, false),
+            new Person("Katherine Johnson", "Hampton", 101, true),
+            new Person("Linus Torvalds", "Portland", 54, false));
+
+    private final Label log = new Label("No changes yet");
+
+    public DataTab() {
+        TextField filter = new TextField();
+        filter.setPromptText("Filter by name");
+        HBox.setHgrow(filter, Priority.ALWAYS);
+
+        FilteredList<Person> filtered = new FilteredList<>(people, person -> true);
+        filter.textProperty().addListener((observable, before, now) -> {
+            String needle = now == null ? "" : now.trim().toLowerCase();
+            filtered.setPredicate(person -> needle.isEmpty() || person.getName().toLowerCase().contains(needle));
+        });
+
+        TableView<Person> table = createTable(filtered);
+        ListView<Person> list = createList();
+
+        Button add = new Button("Add");
+        add.setOnAction(event -> people.add(new Person("Person " + (people.size() + 1), "Nowhere", 20, false)));
+        Button remove = new Button("Remove selected");
+        remove.disableProperty().bind(table.getSelectionModel().selectedItemProperty().isNull());
+        remove.setOnAction(event -> people.remove(table.getSelectionModel().getSelectedItem()));
+
+        Label count = new Label();
+        count.textProperty().bind(Bindings.size(people).asString("%d people"));
+
+        people.addListener((ListChangeListener<Person>) change -> {
+            while (change.next()) {
+                if (change.wasAdded()) {
+                    log.setText("Added " + change.getAddedSubList().get(0).getName());
+                } else if (change.wasRemoved()) {
+                    log.setText("Removed " + change.getRemoved().get(0).getName());
+                }
+            }
+        });
+
+        HBox toolbar = new HBox(8, filter, add, remove, count);
+        toolbar.setPadding(new Insets(8));
+
+        SplitPane split = new SplitPane(list, table);
+        split.setDividerPositions(0.3);
+
+        setTop(toolbar);
+        setCenter(split);
+        setBottom(log);
+        BorderPane.setMargin(log, new Insets(4, 8, 4, 8));
+    }
+
+    private ListView<Person> createList() {
+        ListView<Person> list = new ListView<>(people);
+        list.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
+        list.setCellFactory(view -> new ListCell<Person>() {
+            @Override
+            protected void updateItem(Person person, boolean empty) {
+                super.updateItem(person, empty);
+                if (empty || person == null) {
+                    setText(null);
+                    setGraphic(null);
+                } else {
+                    setText(person.getName());
+                    setGraphic(new Circle(5, person.isMember() ? Color.SEAGREEN : Color.LIGHTGRAY));
+                }
+            }
+        });
+
+        MenuItem promote = new MenuItem("Toggle membership");
+        promote.setOnAction(event -> {
+            Person selected = list.getSelectionModel().getSelectedItem();
+            if (selected != null) {
+                selected.setMember(!selected.isMember());
+                list.refresh();
+            }
+        });
+        list.setContextMenu(new ContextMenu(promote));
+        return list;
+    }
+
+    private TableView<Person> createTable(FilteredList<Person> filtered) {
+        TableView<Person> table = new TableView<>();
+        table.setEditable(true);
+        table.setPlaceholder(new Label("Nobody matches"));
+
+        TableColumn<Person, String> name = new TableColumn<>("Name");
+        name.setCellValueFactory(data -> data.getValue().nameProperty());
+        name.setCellFactory(TextFieldTableCell.forTableColumn());
+        name.setOnEditCommit(event -> event.getRowValue().setName(event.getNewValue()));
+        name.setPrefWidth(180);
+
+        TableColumn<Person, String> city = new TableColumn<>("City");
+        city.setCellValueFactory(data -> data.getValue().cityProperty());
+        city.setPrefWidth(120);
+
+        TableColumn<Person, Number> age = new TableColumn<>("Age");
+        age.setCellValueFactory(data -> data.getValue().ageProperty());
+        age.setStyle("-fx-alignment: CENTER-RIGHT;");
+
+        TableColumn<Person, Boolean> member = new TableColumn<>("Member");
+        member.setCellValueFactory(data -> data.getValue().memberProperty());
+        member.setSortable(false);
+
+        table.getColumns().add(name);
+        table.getColumns().add(city);
+        table.getColumns().add(age);
+        table.getColumns().add(member);
+
+        SortedList<Person> sorted = new SortedList<>(filtered);
+        sorted.comparatorProperty().bind(table.comparatorProperty());
+        table.setItems(sorted);
+        table.getSortOrder().add(name);
+        return table;
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/DialogsTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/DialogsTab.java
new file mode 100644
index 00000000000..a0ef58a2581
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/DialogsTab.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.ChoiceDialog;
+import javafx.scene.control.ContextMenu;
+import javafx.scene.control.Label;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.TextInputDialog;
+import javafx.scene.layout.FlowPane;
+import javafx.scene.layout.VBox;
+import javafx.stage.Modality;
+import javafx.stage.Stage;
+
+/**
+ * The standard dialogs, a context menu and a second window.
+ */
+public class DialogsTab extends VBox {
+
+    private final Label result = new Label("No dialog shown yet");
+    private int windows;
+
+    public DialogsTab() {
+        super(10);
+        setPadding(new Insets(12));
+
+        Button confirm = new Button("Confirm");
+        confirm.setOnAction(event -> {
+            Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
+            alert.setTitle("Delete");
+            alert.setHeaderText("Delete the selected item?");
+            alert.setContentText("This cannot be undone.");
+            Optional<ButtonType> answer = alert.showAndWait();
+            result.setText(answer.filter(button -> button == ButtonType.OK).isPresent() ? "Deleted" : "Kept");
+        });
+
+        Button error = new Button("Error");
+        error.setOnAction(event -> {
+            Alert alert = new Alert(Alert.AlertType.ERROR, "The file could not be saved.", ButtonType.CLOSE);
+            alert.setHeaderText(null);
+            alert.showAndWait();
+            result.setText("Error acknowledged");
+        });
+
+        Button input = new Button("Text input");
+        input.setOnAction(event -> {
+            TextInputDialog dialog = new TextInputDialog("World");
+            dialog.setTitle("Greeting");
+            dialog.setHeaderText("Who should be greeted?");
+            dialog.setContentText("Name:");
+            dialog.showAndWait().ifPresent(name -> result.setText("Hello, " + name));
+        });
+
+        Button choice = new Button("Choice");
+        choice.setOnAction(event -> {
+            ChoiceDialog<String> dialog = new ChoiceDialog<>("Medium", Arrays.asList("Small", "Medium", "Large"));
+            dialog.setTitle("Size");
+            dialog.setHeaderText("Pick a size");
+            Optional<String> picked = dialog.showAndWait();
+            result.setText(picked.map(size -> "Picked " + size).orElse("Nothing picked"));
+        });
+
+        Button window = new Button("Second window");
+        window.setOnAction(event -> openWindow());
+
+        Label target = new Label("Right click me");
+        target.setStyle("-fx-border-color: gray; -fx-padding: 8;");
+        MenuItem copy = new MenuItem("Copy");
+        copy.setOnAction(event -> result.setText("Copy chosen"));
+        MenuItem paste = new MenuItem("Paste");
+        paste.setOnAction(event -> result.setText("Paste chosen"));
+        target.setContextMenu(new ContextMenu(copy, paste));
+
+        getChildren().addAll(new FlowPane(8, 8, confirm, error, input, choice, window), target, result);
+    }
+
+    private void openWindow() {
+        Stage stage = new Stage();
+        stage.initOwner(getScene().getWindow());
+        stage.initModality(Modality.WINDOW_MODAL);
+        stage.setTitle("Window " + (++windows));
+
+        Label label = new Label("This is another stage");
+        Button close = new Button("Close");
+        close.setOnAction(event -> stage.close());
+        VBox root = new VBox(12, label, close);
+        root.setAlignment(Pos.CENTER);
+        root.setPadding(new Insets(24));
+
+        stage.setScene(new Scene(root, 280, 160));
+        stage.setOnHidden(event -> result.setText("Window " + windows + " closed"));
+        stage.show();
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/FxmlTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/FxmlTab.java
new file mode 100644
index 00000000000..ba5d4f4f8e3
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/FxmlTab.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.ResourceBundle;
+
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.layout.StackPane;
+
+/**
+ * Shows the screen described by {@code fxml/profile.fxml}.
+ */
+public class FxmlTab extends StackPane {
+
+    public FxmlTab() {
+        ResourceBundle bundle = ResourceBundle.getBundle("com.example.fxgallery.i18n.messages");
+        FXMLLoader loader = new FXMLLoader(getClass().getResource("fxml/profile.fxml"), bundle);
+        try {
+            Parent screen = loader.load();
+            getChildren().add(screen);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/GalleryApp.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/GalleryApp.java
new file mode 100644
index 00000000000..19748f77455
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/GalleryApp.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import java.util.Optional;
+
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.CheckMenuItem;
+import javafx.scene.control.Label;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.SeparatorMenuItem;
+import javafx.scene.control.Tab;
+import javafx.scene.control.TabPane;
+import javafx.scene.image.Image;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyCodeCombination;
+import javafx.scene.input.KeyCombination;
+import javafx.scene.layout.BorderPane;
+import javafx.stage.Stage;
+
+/**
+ * The gallery's main window: a menu bar, one tab per topic and a status line.
+ */
+public class GalleryApp extends Application {
+
+    private final Label status = new Label("Ready");
+    private TabPane tabs;
+
+    @Override
+    public void start(Stage stage) {
+        tabs = new TabPane();
+        tabs.setTabClosingPolicy(TabPane.TabClosingPolicy.UNAVAILABLE);
+        tabs.getTabs().addAll(
+                tab("Controls", new ControlsTab()),
+                tab("Data", new DataTab()),
+                tab("Layouts", new LayoutsTab()),
+                tab("Bindings", new BindingsTab()),
+                tab("FXML", new FxmlTab()),
+                tab("Shapes", new ShapesTab()),
+                tab("Animation", new AnimationTab()),
+                tab("Dialogs", new DialogsTab()),
+                tab("Tasks", new TasksTab()));
+        tabs.getSelectionModel().selectedItemProperty().addListener(
+                (observable, before, now) -> status.setText("Showing " + now.getText()));
+
+        status.setId("status");
+        status.setPadding(new Insets(4, 8, 4, 8));
+
+        BorderPane root = new BorderPane();
+        root.setTop(createMenuBar(stage));
+        root.setCenter(tabs);
+        root.setBottom(status);
+
+        Scene scene = new Scene(root, 920, 660);
+        scene.getStylesheets().add(GalleryApp.class.getResource("css/gallery.css").toExternalForm());
+
+        stage.setTitle("JavaFX Gallery");
+        stage.getIcons().add(new Image(GalleryApp.class.getResourceAsStream("images/logo.png")));
+        stage.setScene(scene);
+        stage.show();
+    }
+
+    private static Tab tab(String title, Node content) {
+        Tab tab = new Tab(title, content);
+        tab.setClosable(false);
+        return tab;
+    }
+
+    private MenuBar createMenuBar(Stage stage) {
+        MenuItem about = new MenuItem("About");
+        about.setOnAction(event -> {
+            Alert alert = new Alert(Alert.AlertType.INFORMATION);
+            alert.initOwner(stage);
+            alert.setTitle("About");
+            alert.setHeaderText("JavaFX Gallery");
+            alert.setContentText("A tour of the JavaFX controls, layouts and APIs.");
+            alert.showAndWait();
+        });
+
+        MenuItem exit = new MenuItem("Exit");
+        exit.setAccelerator(new KeyCodeCombination(KeyCode.Q, KeyCombination.SHORTCUT_DOWN));
+        exit.setOnAction(event -> {
+            Alert confirm = new Alert(Alert.AlertType.CONFIRMATION, "Close the gallery?",
+                    ButtonType.YES, ButtonType.NO);
+            Optional<ButtonType> answer = confirm.showAndWait();
+            if (answer.isPresent() && answer.get() == ButtonType.YES) {
+                Platform.exit();
+            }
+        });
+
+        CheckMenuItem compact = new CheckMenuItem("Compact status");
+        compact.selectedProperty().addListener((observable, was, is) ->
+                status.setStyle(is ? "-fx-font-size: 10px;" : ""));
+
+        Menu file = new Menu("File");
+        file.getItems().addAll(about, new SeparatorMenuItem(), exit);
+
+        Menu view = new Menu("View");
+        view.getItems().add(compact);
+        Menu go = new Menu("Go to");
+        for (Tab tab : tabs.getTabs()) {
+            MenuItem item = new MenuItem(tab.getText());
+            item.setOnAction(event -> tabs.getSelectionModel().select(tab));
+            go.getItems().add(item);
+        }
+        view.getItems().add(go);
+
+        return new MenuBar(file, view);
+    }
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/LayoutsTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/LayoutsTab.java
new file mode 100644
index 00000000000..80dc7639ca3
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/LayoutsTab.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.geometry.Orientation;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.SplitPane;
+import javafx.scene.control.TextField;
+import javafx.scene.layout.AnchorPane;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.ColumnConstraints;
+import javafx.scene.layout.FlowPane;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+
+/**
+ * One example of each layout pane.
+ */
+public class LayoutsTab extends ScrollPane {
+
+    public LayoutsTab() {
+        VBox content = new VBox(14,
+                titled("HBox and VBox with grow priorities", boxes()),
+                titled("GridPane form", form()),
+                titled("BorderPane", border()),
+                titled("StackPane", stack()),
+                titled("FlowPane", flow()),
+                titled("AnchorPane", anchor()),
+                titled("SplitPane", split()));
+        content.setPadding(new Insets(12));
+        setContent(content);
+        setFitToWidth(true);
+    }
+
+    private static VBox titled(String title, Node body) {
+        Label label = new Label(title);
+        label.getStyleClass().add("section");
+        VBox box = new VBox(4, label, body);
+        box.getStyleClass().add("card");
+        return box;
+    }
+
+    private static Label cell(String text, String colour) {
+        Label label = new Label(text);
+        label.setStyle("-fx-background-color: " + colour + "; -fx-padding: 6 10 6 10;");
+        label.setMaxWidth(Double.MAX_VALUE);
+        return label;
+    }
+
+    private Node boxes() {
+        Label fixed = cell("fixed", "#ffe082");
+        Label grows = cell("grows", "#a5d6a7");
+        Region spacer = new Region();
+        Button end = new Button("End");
+        HBox.setHgrow(grows, Priority.ALWAYS);
+        HBox.setHgrow(spacer, Priority.SOMETIMES);
+        HBox row = new HBox(6, fixed, grows, spacer, end);
+        row.setAlignment(Pos.CENTER_LEFT);
+
+        VBox column = new VBox(4, cell("first", "#90caf9"), cell("second", "#ce93d8"));
+        column.setFillWidth(true);
+        return new VBox(6, row, column);
+    }
+
+    private Node form() {
+        GridPane grid = new GridPane();
+        grid.setHgap(8);
+        grid.setVgap(6);
+        ColumnConstraints labels = new ColumnConstraints();
+        labels.setHalignment(HPos.RIGHT);
+        labels.setMinWidth(80);
+        ColumnConstraints fields = new ColumnConstraints();
+        fields.setHgrow(Priority.ALWAYS);
+        grid.getColumnConstraints().addAll(labels, fields);
+
+        grid.add(new Label("First name"), 0, 0);
+        grid.add(new TextField("Ada"), 1, 0);
+        grid.add(new Label("Last name"), 0, 1);
+        grid.add(new TextField("Lovelace"), 1, 1);
+        Button save = new Button("Save");
+        GridPane.setHalignment(save, HPos.RIGHT);
+        grid.add(save, 0, 2, 2, 1);
+        return grid;
+    }
+
+    private Node border() {
+        BorderPane pane = new BorderPane();
+        pane.setTop(cell("top", "#ffcc80"));
+        pane.setLeft(cell("left", "#80cbc4"));
+        pane.setCenter(cell("center", "#eeeeee"));
+        pane.setRight(cell("right", "#80cbc4"));
+        pane.setBottom(cell("bottom", "#ffcc80"));
+        pane.setPrefHeight(110);
+        return pane;
+    }
+
+    private Node stack() {
+        Rectangle back = new Rectangle(160, 60, Color.STEELBLUE);
+        back.setArcWidth(16);
+        back.setArcHeight(16);
+        Label front = new Label("On top");
+        front.setTextFill(Color.WHITE);
+        StackPane stack = new StackPane(back, front);
+        StackPane.setAlignment(front, Pos.BOTTOM_RIGHT);
+        StackPane.setMargin(front, new Insets(0, 8, 4, 0));
+        stack.setMaxWidth(160);
+        return stack;
+    }
+
+    private Node flow() {
+        FlowPane flow = new FlowPane(6, 6);
+        for (int i = 1; i <= 12; i++) {
+            flow.getChildren().add(new Button("Item " + i));
+        }
+        flow.setPrefWrapLength(360);
+        return flow;
+    }
+
+    private Node anchor() {
+        Button topLeft = new Button("Top left");
+        Button bottomRight = new Button("Bottom right");
+        Label stretched = cell("left and right anchored", "#ef9a9a");
+        AnchorPane.setTopAnchor(topLeft, 4.0);
+        AnchorPane.setLeftAnchor(topLeft, 4.0);
+        AnchorPane.setBottomAnchor(bottomRight, 4.0);
+        AnchorPane.setRightAnchor(bottomRight, 4.0);
+        AnchorPane.setLeftAnchor(stretched, 100.0);
+        AnchorPane.setRightAnchor(stretched, 100.0);
+        AnchorPane.setTopAnchor(stretched, 40.0);
+        AnchorPane pane = new AnchorPane(topLeft, bottomRight, stretched);
+        pane.setPrefHeight(110);
+        return pane;
+    }
+
+    private Node split() {
+        SplitPane inner = new SplitPane(cell("upper", "#fff59d"), cell("lower", "#b39ddb"));
+        inner.setOrientation(Orientation.VERTICAL);
+        SplitPane split = new SplitPane(cell("navigation", "#c5e1a5"), inner);
+        split.setDividerPositions(0.35);
+        split.setPrefHeight(120);
+        return split;
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/ShapesTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/ShapesTab.java
new file mode 100644
index 00000000000..a81a81c3e9e
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/ShapesTab.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import javafx.geometry.Insets;
+import javafx.geometry.VPos;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.MouseButton;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+import javafx.scene.shape.Arc;
+import javafx.scene.shape.ArcType;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.ClosePath;
+import javafx.scene.shape.CubicCurveTo;
+import javafx.scene.shape.Ellipse;
+import javafx.scene.shape.Line;
+import javafx.scene.shape.LineTo;
+import javafx.scene.shape.MoveTo;
+import javafx.scene.shape.Path;
+import javafx.scene.shape.Polygon;
+import javafx.scene.shape.QuadCurveTo;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.shape.StrokeLineCap;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontWeight;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextAlignment;
+import javafx.scene.transform.Rotate;
+
+/**
+ * Scene graph shapes on the left, immediate mode drawing on a canvas on the right.
+ */
+public class ShapesTab extends VBox {
+
+    private final Label hint = new Label("Drag on the canvas to draw, right click to clear, arrow keys move the square");
+    private final Canvas canvas = new Canvas(380, 300);
+    private final Rectangle player = new Rectangle(20, 20, Color.CRIMSON);
+
+    public ShapesTab() {
+        super(8);
+        setPadding(new Insets(12));
+        Button redraw = new Button("Redraw canvas");
+        redraw.setOnAction(event -> paint());
+        getChildren().addAll(new HBox(16, shapes(), canvas), redraw, hint);
+        paint();
+        installMouse();
+    }
+
+    private Pane shapes() {
+        Pane pane = new Pane();
+        pane.setPrefSize(380, 300);
+        pane.setStyle("-fx-background-color: white; -fx-border-color: lightgray;");
+
+        Rectangle rounded = new Rectangle(20, 20, 110, 60);
+        rounded.setArcWidth(20);
+        rounded.setArcHeight(20);
+        rounded.setFill(new LinearGradient(0, 0, 1, 1, true, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.DODGERBLUE), new Stop(1, Color.MIDNIGHTBLUE)));
+        rounded.setStroke(Color.BLACK);
+        rounded.setStrokeWidth(2);
+
+        Circle sun = new Circle(200, 50, 32);
+        sun.setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.5, true, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.YELLOW), new Stop(1, Color.ORANGERED)));
+
+        Ellipse ellipse = new Ellipse(310, 50, 45, 25);
+        ellipse.setFill(Color.TRANSPARENT);
+        ellipse.setStroke(Color.DARKGREEN);
+        ellipse.getStrokeDashArray().addAll(6.0, 4.0);
+
+        Line line = new Line(20, 110, 360, 110);
+        line.setStrokeWidth(4);
+        line.setStrokeLineCap(StrokeLineCap.ROUND);
+        line.setStroke(Color.SLATEGRAY);
+
+        Polygon triangle = new Polygon(40, 200, 90, 130, 140, 200);
+        triangle.setFill(Color.web("#8e24aa", 0.8));
+
+        Path path = new Path(
+                new MoveTo(170, 200),
+                new LineTo(190, 140),
+                new QuadCurveTo(220, 100, 250, 140),
+                new CubicCurveTo(260, 170, 290, 170, 300, 140),
+                new LineTo(320, 200),
+                new ClosePath());
+        path.setFill(Color.LIGHTGREEN);
+        path.setStroke(Color.DARKGREEN);
+        path.setStrokeWidth(2);
+
+        Arc pie = new Arc(60, 250, 35, 35, 30, 300);
+        pie.setType(ArcType.ROUND);
+        pie.setFill(Color.GOLD);
+
+        Text rotated = new Text(140, 255, "Rotated text");
+        rotated.setFont(Font.font("SansSerif", FontWeight.BOLD, 18));
+        rotated.setFill(Color.DARKSLATEBLUE);
+        rotated.getTransforms().add(new Rotate(-12, 140, 255));
+
+        Circle clipped = new Circle(320, 250, 40, Color.TEAL);
+        clipped.setClip(new Rectangle(280, 230, 80, 40));
+
+        player.setX(250);
+        player.setY(215);
+
+        pane.getChildren().addAll(rounded, sun, ellipse, line, triangle, path, pie, rotated, clipped, player);
+        pane.setFocusTraversable(true);
+        pane.setOnMouseClicked(event -> pane.requestFocus());
+        pane.setOnKeyPressed(event -> {
+            KeyCode code = event.getCode();
+            if (code == KeyCode.LEFT) {
+                player.setX(player.getX() - 5);
+            } else if (code == KeyCode.RIGHT) {
+                player.setX(player.getX() + 5);
+            } else if (code == KeyCode.UP) {
+                player.setY(player.getY() - 5);
+            } else if (code == KeyCode.DOWN) {
+                player.setY(player.getY() + 5);
+            }
+            event.consume();
+        });
+        return pane;
+    }
+
+    private void paint() {
+        GraphicsContext g = canvas.getGraphicsContext2D();
+        double w = canvas.getWidth();
+        double h = canvas.getHeight();
+        g.clearRect(0, 0, w, h);
+        g.setFill(new LinearGradient(0, 0, 0, 1, true, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.LIGHTSKYBLUE), new Stop(1, Color.WHITE)));
+        g.fillRect(0, 0, w, h);
+
+        g.setStroke(Color.DARKGRAY);
+        g.setLineWidth(1);
+        for (int x = 0; x <= w; x += 40) {
+            g.strokeLine(x, 0, x, h);
+        }
+
+        g.setFill(Color.FORESTGREEN);
+        g.fillOval(30, 30, 70, 50);
+        g.setStroke(Color.DARKRED);
+        g.setLineWidth(3);
+        g.strokeRoundRect(130, 30, 90, 50, 14, 14);
+        g.strokeArc(250, 25, 80, 60, 45, 240, ArcType.OPEN);
+
+        g.beginPath();
+        g.moveTo(30, 180);
+        g.bezierCurveTo(90, 100, 150, 260, 210, 180);
+        g.quadraticCurveTo(250, 130, 290, 180);
+        g.lineTo(340, 120);
+        g.setStroke(Color.NAVY);
+        g.stroke();
+
+        g.save();
+        g.translate(190, 250);
+        g.rotate(-8);
+        g.setFill(Color.BLACK);
+        g.setFont(Font.font(20));
+        g.setTextAlign(TextAlignment.CENTER);
+        g.setTextBaseline(VPos.CENTER);
+        g.fillText("Canvas text", 0, 0);
+        g.restore();
+
+        g.setGlobalAlpha(0.5);
+        g.setFill(Color.MAGENTA);
+        g.fillPolygon(new double[] {300, 360, 330}, new double[] {220, 220, 280}, 3);
+        g.setGlobalAlpha(1);
+    }
+
+    private void installMouse() {
+        GraphicsContext g = canvas.getGraphicsContext2D();
+        canvas.setOnMousePressed(event -> {
+            if (event.getButton() == MouseButton.SECONDARY) {
+                paint();
+            } else {
+                g.setFill(Color.BLACK);
+                g.fillOval(event.getX() - 2, event.getY() - 2, 4, 4);
+            }
+        });
+        canvas.setOnMouseDragged(event -> {
+            g.setFill(Color.BLACK);
+            g.fillOval(event.getX() - 2, event.getY() - 2, 4, 4);
+            hint.setText(String.format("Drawing at %.0f, %.0f", event.getX(), event.getY()));
+        });
+        canvas.setOnMouseReleased(event -> hint.setText("Stroke finished"));
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/TasksTab.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/TasksTab.java
new file mode 100644
index 00000000000..328943d7adf
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/TasksTab.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery;
+
+import javafx.application.Platform;
+import javafx.concurrent.Task;
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+
+/**
+ * Work off the application thread: a {@link Task} bound to a progress bar, and
+ * {@link Platform#runLater(Runnable)} from a plain thread.
+ */
+public class TasksTab extends VBox {
+
+    private final ProgressBar progress = new ProgressBar(0);
+    private final Label message = new Label("Idle");
+    private final Label outcome = new Label();
+    private final Label ticker = new Label("No ticks yet");
+    private Task<Integer> running;
+
+    public TasksTab() {
+        super(10);
+        setPadding(new Insets(12));
+        progress.setPrefWidth(320);
+
+        Button start = new Button("Start task");
+        Button cancel = new Button("Cancel");
+        cancel.setDisable(true);
+        start.setOnAction(event -> {
+            running = createTask();
+            progress.progressProperty().bind(running.progressProperty());
+            message.textProperty().bind(running.messageProperty());
+            start.disableProperty().bind(running.runningProperty());
+            cancel.disableProperty().bind(running.runningProperty().not());
+            running.setOnSucceeded(done -> outcome.setText("Sum: " + running.getValue()));
+            running.setOnCancelled(done -> outcome.setText("Cancelled"));
+            running.setOnFailed(done -> outcome.setText("Failed: " + running.getException()));
+            Thread thread = new Thread(running, "gallery-task");
+            thread.setDaemon(true);
+            thread.start();
+        });
+        cancel.setOnAction(event -> {
+            if (running != null) {
+                running.cancel();
+            }
+        });
+
+        Button tick = new Button("Tick from a thread");
+        tick.setOnAction(event -> {
+            Thread thread = new Thread(() -> {
+                for (int i = 1; i <= 3; i++) {
+                    int count = i;
+                    Platform.runLater(() -> ticker.setText("Tick " + count));
+                    try {
+                        Thread.sleep(200);
+                    } catch (InterruptedException e) {
+                        return;
+                    }
+                }
+            });
+            thread.setDaemon(true);
+            thread.start();
+        });
+
+        getChildren().addAll(new HBox(8, start, cancel), progress, message, outcome, new HBox(8, tick, ticker));
+    }
+
+    private static Task<Integer> createTask() {
+        return new Task<Integer>() {
+            @Override
+            protected Integer call() throws Exception {
+                int sum = 0;
+                int steps = 40;
+                for (int i = 1; i <= steps; i++) {
+                    if (isCancelled()) {
+                        updateMessage("Stopping");
+                        break;
+                    }
+                    sum += i;
+                    updateProgress(i, steps);
+                    updateMessage("Step " + i + " of " + steps);
+                    Thread.sleep(50);
+                }
+                return sum;
+            }
+        };
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/control/StatusBadge.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/control/StatusBadge.java
new file mode 100644
index 00000000000..a5c4751909a
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/control/StatusBadge.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery.control;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Circle;
+
+/**
+ * A custom control: a coloured dot and a caption, laid out by {@code status-badge.fxml} and usable
+ * as an element of other FXML documents.
+ */
+public class StatusBadge extends HBox {
+
+    private static final Color[] COLOURS = {Color.GRAY, Color.ORANGE, Color.LIMEGREEN};
+
+    @FXML
+    private Circle dot;
+    @FXML
+    private Label caption;
+
+    private final IntegerProperty level = new SimpleIntegerProperty(this, "level", 0);
+
+    public StatusBadge() {
+        FXMLLoader loader = new FXMLLoader(StatusBadge.class.getResource("status-badge.fxml"));
+        loader.setRoot(this);
+        loader.setController(this);
+        try {
+            loader.load();
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+        level.addListener((observable, before, now) -> updateDot());
+        updateDot();
+    }
+
+    private void updateDot() {
+        int index = Math.max(0, Math.min(COLOURS.length - 1, getLevel()));
+        dot.setFill(COLOURS[index]);
+    }
+
+    public final String getText() {
+        return caption.getText();
+    }
+
+    public final void setText(String text) {
+        caption.setText(text);
+    }
+
+    public final StringProperty textProperty() {
+        return caption.textProperty();
+    }
+
+    public final int getLevel() {
+        return level.get();
+    }
+
+    public final void setLevel(int value) {
+        level.set(value);
+    }
+
+    public final IntegerProperty levelProperty() {
+        return level;
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/fxml/AddressController.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/fxml/AddressController.java
new file mode 100644
index 00000000000..a78ffef4be1
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/fxml/AddressController.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery.fxml;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+import javafx.fxml.FXML;
+import javafx.fxml.Initializable;
+import javafx.scene.control.TextField;
+
+/**
+ * The controller of {@code address.fxml}, which {@code profile.fxml} includes.
+ */
+public class AddressController implements Initializable {
+
+    @FXML
+    private TextField streetField;
+    @FXML
+    private TextField cityField;
+
+    @Override
+    public void initialize(URL location, ResourceBundle resources) {
+        cityField.setText(resources.getString("address.defaultCity"));
+    }
+
+    public String getCity() {
+        return cityField.getText();
+    }
+
+    public void clear() {
+        streetField.clear();
+        cityField.clear();
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/fxml/ProfileController.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/fxml/ProfileController.java
new file mode 100644
index 00000000000..a10b4762a09
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/fxml/ProfileController.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery.fxml;
+
+import java.net.URL;
+import java.util.ResourceBundle;
+
+import com.example.fxgallery.control.StatusBadge;
+
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextField;
+import javafx.scene.control.ToggleGroup;
+
+/**
+ * The controller of {@code profile.fxml}.
+ */
+public class ProfileController {
+
+    @FXML
+    private ResourceBundle resources;
+    @FXML
+    private URL location;
+
+    @FXML
+    private TextField nameField;
+    @FXML
+    private ComboBox<String> roleBox;
+    @FXML
+    private CheckBox activeBox;
+    @FXML
+    private ToggleGroup planGroup;
+    @FXML
+    private Button greetButton;
+    @FXML
+    private Label greeting;
+    @FXML
+    private StatusBadge badge;
+    @FXML
+    private AddressController addressController;
+
+    private int greetings;
+
+    @FXML
+    private void initialize() {
+        roleBox.getItems().addAll("Developer", "Designer", "Manager");
+        roleBox.getSelectionModel().selectFirst();
+        greetButton.disableProperty().bind(nameField.textProperty().isEmpty());
+        activeBox.selectedProperty().addListener((observable, was, is) -> badge.setLevel(is ? 2 : 0));
+        greeting.setText(resources.getString("profile.hint"));
+    }
+
+    @FXML
+    private void onGreet(ActionEvent event) {
+        greetings++;
+        String plan = planGroup.getSelectedToggle() == null ? "?" : String.valueOf(planGroup.getSelectedToggle().getUserData());
+        greeting.setText(resources.getString("profile.hello") + " " + nameField.getText()
+                + " (" + roleBox.getValue() + ", " + plan + ") from " + addressController.getCity());
+        badge.setText(resources.getString("badge.greeted") + " " + greetings);
+        badge.setLevel(1);
+    }
+
+    @FXML
+    private void onReset() {
+        nameField.clear();
+        addressController.clear();
+        greeting.setText(resources.getString("profile.hint"));
+        badge.setText(resources.getString("badge.ready"));
+        badge.setLevel(activeBox.isSelected() ? 2 : 0);
+    }
+
+    public int getGreetings() {
+        return greetings;
+    }
+
+    public URL getLocation() {
+        return location;
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/model/Person.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/model/Person.java
new file mode 100644
index 00000000000..9ba6207aff5
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/com/example/fxgallery/model/Person.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.fxgallery.model;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+
+/**
+ * A row of the table: a JavaFX bean with one property per column.
+ */
+public class Person {
+
+    private final StringProperty name = new SimpleStringProperty(this, "name");
+    private final StringProperty city = new SimpleStringProperty(this, "city");
+    private final IntegerProperty age = new SimpleIntegerProperty(this, "age");
+    private final BooleanProperty member = new SimpleBooleanProperty(this, "member");
+
+    public Person(String name, String city, int age, boolean member) {
+        setName(name);
+        setCity(city);
+        setAge(age);
+        setMember(member);
+    }
+
+    public final String getName() {
+        return name.get();
+    }
+
+    public final void setName(String value) {
+        name.set(value);
+    }
+
+    public StringProperty nameProperty() {
+        return name;
+    }
+
+    public final String getCity() {
+        return city.get();
+    }
+
+    public final void setCity(String value) {
+        city.set(value);
+    }
+
+    public StringProperty cityProperty() {
+        return city;
+    }
+
+    public final int getAge() {
+        return age.get();
+    }
+
+    public final void setAge(int value) {
+        age.set(value);
+    }
+
+    public IntegerProperty ageProperty() {
+        return age;
+    }
+
+    public final boolean isMember() {
+        return member.get();
+    }
+
+    public final void setMember(boolean value) {
+        member.set(value);
+    }
+
+    public BooleanProperty memberProperty() {
+        return member;
+    }
+
+    @Override
+    public String toString() {
+        return getName() + " (" + getAge() + ")";
+    }
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/java/module-info.java b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/module-info.java
new file mode 100644
index 00000000000..e1591bee074
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/java/module-info.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+module com.example.fxgallery {
+    requires javafx.controls;
+    requires javafx.fxml;
+
+    opens com.example.fxgallery to javafx.fxml;
+    opens com.example.fxgallery.fxml to javafx.fxml;
+    opens com.example.fxgallery.control to javafx.fxml;
+    opens com.example.fxgallery.model to javafx.base;
+
+    exports com.example.fxgallery;
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/control/status-badge.fxml b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/control/status-badge.fxml
new file mode 100644
index 00000000000..b2f31836fcd
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/control/status-badge.fxml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.shape.Circle?>
+
+<fx:root type="HBox" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1"
+         spacing="6" alignment="CENTER_LEFT" styleClass="status-badge">
+    <Circle fx:id="dot" radius="6" fill="GRAY"/>
+    <Label fx:id="caption" text="-"/>
+</fx:root>
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/css/gallery.css b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/css/gallery.css
new file mode 100644
index 00000000000..2d8331f5122
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/css/gallery.css
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/* The gallery's look: colours are looked up from .root, so a theme is a change of three lines. */
+.root {
+    -brand: #1565c0;
+    -brand-light: derive(-brand, 60%);
+    -accent: #ef6c00;
+    -fx-font-size: 13px;
+    -fx-background-color: #fafafa;
+}
+
+/* Type selectors */
+Label {
+    -fx-text-fill: #263238;
+}
+
+/* Class selectors */
+.title {
+    -fx-font-size: 20px;
+    -fx-font-weight: bold;
+    -fx-text-fill: -brand;
+}
+
+.section {
+    -fx-font-weight: bold;
+    -fx-text-fill: derive(-brand, -20%);
+}
+
+.card {
+    -fx-background-color: white;
+    -fx-background-radius: 6;
+    -fx-border-color: #cfd8dc;
+    -fx-border-radius: 6;
+    -fx-padding: 8;
+}
+
+.echo {
+    -fx-font-style: italic;
+    -fx-text-fill: gray;
+}
+
+.button {
+    -fx-background-radius: 4;
+    -fx-padding: 5 12 5 12;
+}
+
+.button.primary {
+    -fx-background-color: -brand;
+    -fx-text-fill: white;
+}
+
+/* Pseudo-class states */
+.button.primary:hover {
+    -fx-background-color: derive(-brand, 20%);
+}
+
+.button.primary:pressed {
+    -fx-background-color: derive(-brand, -25%);
+}
+
+.button:disabled {
+    -fx-opacity: 0.5;
+}
+
+.text-field:focused {
+    -fx-border-color: -accent;
+}
+
+.check-box:selected .label {
+    -fx-text-fill: -brand;
+}
+
+/* Id selector */
+#status {
+    -fx-background-color: -brand-light;
+    -fx-text-fill: #0d47a1;
+    -fx-max-width: infinity;
+}
+
+#primary-button {
+    -fx-font-weight: bold;
+}
+
+/* Descendant and child selectors */
+.card .label {
+    -fx-padding: 0 0 2 0;
+}
+
+.tab-pane > .tab-header-area .tab:selected .tab-label {
+    -fx-text-fill: -brand;
+}
+
+.table-view .column-header .label {
+    -fx-font-weight: bold;
+}
+
+.list-cell:selected {
+    -fx-background-color: -brand;
+    -fx-text-fill: white;
+}
+
+.progress-bar {
+    -fx-accent: -accent;
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/css/profile.css b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/css/profile.css
new file mode 100644
index 00000000000..282ace49a79
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/css/profile.css
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/* Loaded by profile.fxml through stylesheets="@../css/profile.css". */
+.profile {
+    -fx-background-color: linear-gradient(to bottom, white, #e3f2fd);
+}
+
+.profile .greeting {
+    -fx-font-size: 15px;
+    -fx-text-fill: #1b5e20;
+}
+
+.status-badge {
+    -fx-padding: 2 8 2 8;
+    -fx-background-color: #eceff1;
+    -fx-background-radius: 10;
+}
+
+.status-badge .label {
+    -fx-font-size: 11px;
+}
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/fxml/address.fxml b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/fxml/address.fxml
new file mode 100644
index 00000000000..4136e877d3f
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/fxml/address.fxml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.GridPane?>
+
+<GridPane xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1"
+          fx:controller="com.example.fxgallery.fxml.AddressController" hgap="8" vgap="6">
+    <Label text="%address.street" GridPane.rowIndex="0" GridPane.columnIndex="0"/>
+    <TextField fx:id="streetField" GridPane.rowIndex="0" GridPane.columnIndex="1" GridPane.hgrow="ALWAYS"/>
+    <Label text="%address.city" GridPane.rowIndex="1" GridPane.columnIndex="0"/>
+    <TextField fx:id="cityField" GridPane.rowIndex="1" GridPane.columnIndex="1" GridPane.hgrow="ALWAYS"/>
+</GridPane>
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/fxml/profile.fxml b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/fxml/profile.fxml
new file mode 100644
index 00000000000..d142e5dd3eb
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/fxml/profile.fxml
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import com.example.fxgallery.control.StatusBadge?>
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.ComboBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.RadioButton?>
+<?import javafx.scene.control.Separator?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.control.ToggleGroup?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.VBox?>
+
+<VBox xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1"
+      fx:controller="com.example.fxgallery.fxml.ProfileController"
+      spacing="10" styleClass="profile" stylesheets="@../css/profile.css">
+    <padding>
+        <Insets top="12" right="12" bottom="12" left="12"/>
+    </padding>
+    <fx:define>
+        <ToggleGroup fx:id="planGroup"/>
+    </fx:define>
+
+    <Label text="%profile.title" styleClass="title"/>
+
+    <GridPane hgap="8" vgap="6">
+        <columnConstraints>
+            <ColumnConstraints minWidth="90" halignment="RIGHT"/>
+            <ColumnConstraints hgrow="ALWAYS"/>
+        </columnConstraints>
+        <Label text="%profile.name" GridPane.rowIndex="0" GridPane.columnIndex="0"/>
+        <TextField fx:id="nameField" promptText="%profile.name.prompt" GridPane.rowIndex="0" GridPane.columnIndex="1"/>
+        <Label text="%profile.role" GridPane.rowIndex="1" GridPane.columnIndex="0"/>
+        <ComboBox fx:id="roleBox" maxWidth="Infinity" GridPane.rowIndex="1" GridPane.columnIndex="1"/>
+        <Label text="%profile.plan" GridPane.rowIndex="2" GridPane.columnIndex="0"/>
+        <HBox spacing="12" GridPane.rowIndex="2" GridPane.columnIndex="1">
+            <RadioButton text="%profile.plan.free" toggleGroup="$planGroup" userData="free" selected="true"/>
+            <RadioButton text="%profile.plan.pro" toggleGroup="$planGroup" userData="pro"/>
+        </HBox>
+        <CheckBox fx:id="activeBox" text="%profile.active" GridPane.rowIndex="3" GridPane.columnIndex="1"/>
+    </GridPane>
+
+    <Separator/>
+    <fx:include fx:id="address" source="address.fxml"/>
+    <Separator/>
+
+    <HBox spacing="8" alignment="CENTER_LEFT">
+        <Button fx:id="greetButton" text="%profile.greet" onAction="#onGreet" defaultButton="true" styleClass="primary"/>
+        <Button text="%profile.reset" onAction="#onReset"/>
+        <StatusBadge fx:id="badge" text="%badge.ready" level="0" HBox.hgrow="ALWAYS"/>
+    </HBox>
+    <Label fx:id="greeting" wrapText="true" styleClass="greeting"/>
+</VBox>
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/i18n/messages.properties b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/i18n/messages.properties
new file mode 100644
index 00000000000..5ea9818596d
--- /dev/null
+++ b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/i18n/messages.properties
@@ -0,0 +1,17 @@
+profile.title=Profile
+profile.name=Name
+profile.name.prompt=Who are you?
+profile.role=Role
+profile.plan=Plan
+profile.plan.free=Free
+profile.plan.pro=Pro
+profile.active=Active account
+profile.greet=Greet
+profile.reset=Reset
+profile.hint=Enter a name and press Greet
+profile.hello=Hello,
+badge.ready=Ready
+badge.greeted=Greeted
+address.street=Street
+address.city=City
+address.defaultCity=London
diff --git a/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/images/logo.png b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/images/logo.png
new file mode 100644
index 00000000000..45be989d862
Binary files /dev/null and b/scripts/desktop-compat-samples/javafx-gallery/src/main/resources/com/example/fxgallery/images/logo.png differ
diff --git a/scripts/desktop-compat-samples/swing-gallery/pom.xml b/scripts/desktop-compat-samples/swing-gallery/pom.xml
new file mode 100644
index 00000000000..68dff1d69a1
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/pom.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- An ordinary Swing desktop application. Nothing here knows about Codename
+     One: `mvn package` builds a jar that runs on a desktop JVM, and
+     `mvn cn1:import-desktop-project` imports the same sources unmodified. -->
+<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.example</groupId>
+    <artifactId>swing-gallery</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>Swing Gallery</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.miglayout</groupId>
+            <artifactId>miglayout-swing</artifactId>
+            <version>5.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.swinglabs.swingx</groupId>
+            <artifactId>swingx-all</artifactId>
+            <version>1.6.5-1</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.3.0</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.example.gallery.GalleryApp</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/ControlsPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/ControlsPanel.java
new file mode 100644
index 00000000000..95215337c2b
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/ControlsPanel.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.awt.Toolkit;
+import java.awt.datatransfer.StringSelection;
+
+import javax.swing.BorderFactory;
+import javax.swing.BoxLayout;
+import javax.swing.ButtonGroup;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
+import javax.swing.JEditorPane;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JPasswordField;
+import javax.swing.JProgressBar;
+import javax.swing.JRadioButton;
+import javax.swing.JScrollPane;
+import javax.swing.JSlider;
+import javax.swing.JSpinner;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.SwingConstants;
+import javax.swing.Timer;
+import javax.swing.event.HyperlinkEvent;
+
+/**
+ * The basic controls: labels, buttons, text, choices and a progress bar.
+ */
+public class ControlsPanel extends JPanel {
+
+    private final JLabel echo = new JLabel(" ");
+    private int clicks;
+
+    public ControlsPanel() {
+        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        add(labels());
+        add(buttons());
+        add(text());
+        add(choices());
+        add(progress());
+        add(help());
+        add(echo);
+    }
+
+    private JPanel labels() {
+        JPanel p = row("Labels");
+        p.add(new JLabel("Plain label"));
+        p.add(new JLabel("<html><b>Bold</b> and <i>italic</i> and <font color='red'>red</font></html>"));
+        JLabel right = new JLabel("Right aligned", SwingConstants.RIGHT);
+        right.setToolTipText("A label with a tool tip");
+        p.add(right);
+        return p;
+    }
+
+    private JPanel buttons() {
+        JPanel p = row("Buttons");
+        JButton count = new JButton("Click me");
+        count.addActionListener(e -> {
+            clicks++;
+            echo.setText("Clicked " + clicks + (clicks == 1 ? " time" : " times"));
+        });
+        p.add(count);
+
+        JCheckBox enabled = new JCheckBox("Enabled", true);
+        enabled.addItemListener(e -> count.setEnabled(enabled.isSelected()));
+        p.add(enabled);
+
+        ButtonGroup sizes = new ButtonGroup();
+        for (String size : new String[] {"Small", "Medium", "Large"}) {
+            JRadioButton radio = new JRadioButton(size, "Medium".equals(size));
+            radio.setActionCommand(size);
+            radio.addActionListener(e -> echo.setText("Size: " + sizes.getSelection().getActionCommand()));
+            sizes.add(radio);
+            p.add(radio);
+        }
+        return p;
+    }
+
+    private JPanel text() {
+        JPanel p = new JPanel(new GridLayout(1, 2, 8, 0));
+        p.setBorder(BorderFactory.createTitledBorder("Text"));
+
+        JPanel fields = new JPanel(new GridLayout(2, 2, 4, 4));
+        JTextField name = new JTextField("Ada", 12);
+        name.addActionListener(e -> echo.setText("Hello, " + name.getText()));
+        JPasswordField password = new JPasswordField(12);
+        password.addActionListener(e -> echo.setText("Password of " + password.getPassword().length + " characters"));
+        fields.add(new JLabel("Name:"));
+        fields.add(name);
+        fields.add(new JLabel("Password:"));
+        fields.add(password);
+
+        JButton copy = new JButton("Copy name");
+        copy.addActionListener(e -> {
+            StringSelection selection = new StringSelection(name.getText());
+            Toolkit.getDefaultToolkit().getSystemClipboard().setContents(selection, selection);
+            echo.setText("Copied " + name.getText());
+        });
+        JPanel left = new JPanel();
+        left.setLayout(new BoxLayout(left, BoxLayout.Y_AXIS));
+        left.add(fields);
+        left.add(copy);
+        p.add(left);
+
+        JTextArea notes = new JTextArea(4, 20);
+        notes.setLineWrap(true);
+        notes.setWrapStyleWord(true);
+        notes.setText("A text area inside a scroll pane.\nIt wraps long lines at word boundaries.");
+        p.add(new JScrollPane(notes));
+        return p;
+    }
+
+    private JPanel choices() {
+        JPanel p = row("Choices");
+        JComboBox<String> colors = new JComboBox<>(new String[] {"Red", "Green", "Blue"});
+        colors.setSelectedItem("Green");
+        colors.addActionListener(e -> echo.setText("Color: " + colors.getSelectedItem()));
+        p.add(colors);
+
+        JComboBox<String> fruit = new JComboBox<>(new String[] {"Apple", "Pear", "Plum"});
+        fruit.setEditable(true);
+        fruit.addActionListener(e -> echo.setText("Fruit: " + fruit.getEditor().getItem()));
+        p.add(fruit);
+
+        JSpinner quantity = new JSpinner(new SpinnerNumberModel(3, 0, 10, 1));
+        quantity.addChangeListener(e -> echo.setText("Quantity: " + quantity.getValue()));
+        p.add(quantity);
+
+        JSlider volume = new JSlider(0, 100, 40);
+        volume.setMajorTickSpacing(25);
+        volume.setPaintTicks(true);
+        volume.setPaintLabels(true);
+        volume.addChangeListener(e -> {
+            if (!volume.getValueIsAdjusting()) {
+                echo.setText("Volume: " + volume.getValue());
+            }
+        });
+        p.add(volume);
+        return p;
+    }
+
+    private JPanel progress() {
+        JPanel p = row("Progress");
+        JProgressBar bar = new JProgressBar(0, 100);
+        bar.setStringPainted(true);
+        Timer timer = new Timer(100, e -> bar.setValue((bar.getValue() + 2) % 101));
+        JButton toggle = new JButton("Start");
+        toggle.addActionListener(e -> {
+            if (timer.isRunning()) {
+                timer.stop();
+                toggle.setText("Start");
+            } else {
+                timer.start();
+                toggle.setText("Stop");
+            }
+        });
+        p.add(bar);
+        p.add(toggle);
+        return p;
+    }
+
+    private JPanel help() {
+        JPanel p = new JPanel(new GridLayout(1, 1));
+        p.setBorder(BorderFactory.createTitledBorder("Help"));
+        JEditorPane html = new JEditorPane("text/html",
+                "<html><body><h3>Controls</h3><p>Every control on this tab reports what you did in the line"
+                + " at the bottom. See the <a href=\"https://docs.oracle.com/javase/tutorial/uiswing/\">Swing"
+                + " tutorial</a> for more.</p></body></html>");
+        html.setEditable(false);
+        html.addHyperlinkListener(e -> {
+            if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
+                echo.setText("Link: " + e.getURL());
+            }
+        });
+        p.add(new JScrollPane(html));
+        return p;
+    }
+
+    private static JPanel row(String title) {
+        JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT, 8, 4));
+        p.setBorder(BorderFactory.createTitledBorder(title));
+        return p;
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/DataPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/DataPanel.java
new file mode 100644
index 00000000000..969058704a5
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/DataPanel.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Font;
+import java.awt.GridLayout;
+import java.text.DecimalFormat;
+
+import javax.swing.BorderFactory;
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.DefaultListModel;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTree;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingConstants;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableRowSorter;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+
+/**
+ * A list, a table and a tree over the same planets.
+ */
+public class DataPanel extends JPanel {
+
+    private final Planet[] planets = Planet.all();
+    private final JLabel selection = new JLabel("Nothing selected");
+
+    public DataPanel() {
+        super(new BorderLayout(6, 6));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        JPanel top = new JPanel(new GridLayout(1, 2, 6, 6));
+        top.add(titled("List", planetList()));
+        top.add(titled("Tree", planetTree()));
+        JPanel center = new JPanel(new GridLayout(2, 1, 6, 6));
+        center.add(top);
+        center.add(titled("Table", planetTable()));
+        add(center, BorderLayout.CENTER);
+        add(selection, BorderLayout.SOUTH);
+    }
+
+    private JScrollPane planetList() {
+        DefaultListModel<Planet> model = new DefaultListModel<>();
+        for (Planet p : planets) {
+            model.addElement(p);
+        }
+        JList<Planet> list = new JList<>(model);
+        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        list.setCellRenderer(new PlanetRenderer());
+        list.addListSelectionListener(e -> {
+            if (!e.getValueIsAdjusting() && list.getSelectedValue() != null) {
+                selection.setText("List: " + list.getSelectedValue().getName());
+            }
+        });
+        return new JScrollPane(list);
+    }
+
+    private JScrollPane planetTable() {
+        PlanetTableModel model = new PlanetTableModel(planets);
+        JTable table = new JTable(model);
+        table.setRowSorter(new TableRowSorter<>(model));
+        table.setFillsViewportHeight(true);
+        table.setRowHeight(22);
+        table.getColumnModel().getColumn(PlanetTableModel.NAME).setPreferredWidth(140);
+        table.getColumnModel().getColumn(PlanetTableModel.MASS).setCellRenderer(new MassRenderer());
+        table.getSelectionModel().addListSelectionListener(e -> {
+            int row = table.getSelectedRow();
+            if (!e.getValueIsAdjusting() && row >= 0) {
+                Object name = model.getValueAt(table.convertRowIndexToModel(row), PlanetTableModel.NAME);
+                selection.setText("Table: " + name);
+            }
+        });
+        return new JScrollPane(table);
+    }
+
+    private JScrollPane planetTree() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Solar system");
+        DefaultMutableTreeNode rocky = new DefaultMutableTreeNode("Rocky planets");
+        DefaultMutableTreeNode giants = new DefaultMutableTreeNode("Giants");
+        root.add(rocky);
+        root.add(giants);
+        for (Planet p : planets) {
+            (p.getMass() < 10 ? rocky : giants).add(new DefaultMutableTreeNode(p));
+        }
+        JTree tree = new JTree(new DefaultTreeModel(root));
+        tree.expandRow(1);
+        tree.addTreeSelectionListener(e -> {
+            TreePath path = e.getNewLeadSelectionPath();
+            if (path != null) {
+                DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
+                selection.setText("Tree: " + node.getUserObject() + (node.isLeaf() ? "" : " ("
+                        + node.getChildCount() + ")"));
+            }
+        });
+        return new JScrollPane(tree);
+    }
+
+    private static JPanel titled(String title, Component content) {
+        JPanel p = new JPanel(new BorderLayout());
+        p.setBorder(BorderFactory.createTitledBorder(title));
+        p.add(content, BorderLayout.CENTER);
+        return p;
+    }
+
+    /** Shows a planet with its moons, the giants in bold. */
+    private static class PlanetRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected,
+                                                      boolean cellHasFocus) {
+            super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            Planet p = (Planet) value;
+            setText(p.getName() + "  -  " + p.getMoons() + (p.getMoons() == 1 ? " moon" : " moons"));
+            setFont(getFont().deriveFont(p.getMass() > 10 ? Font.BOLD : Font.PLAIN));
+            if (!isSelected && index % 2 == 1) {
+                setBackground(new Color(0xf2f6fa));
+            }
+            return this;
+        }
+    }
+
+    /** Right-aligned, two decimals, heavy planets in a darker color. */
+    private static class MassRenderer extends DefaultTableCellRenderer {
+        private final DecimalFormat format = new DecimalFormat("#,##0.000");
+
+        MassRenderer() {
+            setHorizontalAlignment(SwingConstants.RIGHT);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                                                       boolean hasFocus, int row, int column) {
+            super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+            double mass = ((Number) value).doubleValue();
+            setText(format.format(mass));
+            if (!isSelected) {
+                setForeground(mass > 10 ? new Color(0x8a3b00) : table.getForeground());
+            }
+            return this;
+        }
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/DialogsPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/DialogsPanel.java
new file mode 100644
index 00000000000..acc7aca7ac1
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/DialogsPanel.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BorderLayout;
+import java.awt.FlowLayout;
+import java.awt.Frame;
+import java.io.File;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.SwingUtilities;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+/**
+ * The standard dialogs, a modal dialog of the application's own, and the file chooser.
+ */
+public class DialogsPanel extends JPanel {
+
+    private final JLabel result = new JLabel("No dialog shown yet");
+
+    public DialogsPanel() {
+        super(new BorderLayout());
+        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.LEFT, 8, 8));
+        buttons.add(button("Message", this::showMessage));
+        buttons.add(button("Confirm", this::showConfirm));
+        buttons.add(button("Input", this::showInput));
+        buttons.add(button("Custom dialog", this::showCustom));
+        buttons.add(button("Open file", this::showOpen));
+        add(buttons, BorderLayout.NORTH);
+        result.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        add(result, BorderLayout.CENTER);
+    }
+
+    private static JButton button(String text, Runnable action) {
+        JButton b = new JButton(text);
+        b.addActionListener(e -> action.run());
+        return b;
+    }
+
+    private void showMessage() {
+        JOptionPane.showMessageDialog(this, "The operation completed.", "Message", JOptionPane.INFORMATION_MESSAGE);
+        result.setText("Message dismissed");
+    }
+
+    private void showConfirm() {
+        int answer = JOptionPane.showConfirmDialog(this, "Delete the selected item?", "Confirm",
+                JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
+        result.setText(answer == JOptionPane.YES_OPTION ? "Confirmed" : "Declined");
+    }
+
+    private void showInput() {
+        String name = JOptionPane.showInputDialog(this, "What is your name?", "Input", JOptionPane.QUESTION_MESSAGE);
+        result.setText(name == null ? "Input cancelled" : "Hello, " + name);
+    }
+
+    private void showCustom() {
+        Frame owner = (Frame) SwingUtilities.getWindowAncestor(this);
+        JDialog dialog = new JDialog(owner, "Rename", true);
+        JTextField field = new JTextField("untitled", 18);
+        JButton ok = new JButton("OK");
+        JButton cancel = new JButton("Cancel");
+        boolean[] accepted = new boolean[1];
+        ok.addActionListener(e -> {
+            accepted[0] = true;
+            dialog.dispose();
+        });
+        cancel.addActionListener(e -> dialog.dispose());
+
+        JPanel form = new JPanel(new FlowLayout());
+        form.add(new JLabel("New name:"));
+        form.add(field);
+        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+        buttons.add(cancel);
+        buttons.add(ok);
+        dialog.getContentPane().add(form, BorderLayout.CENTER);
+        dialog.getContentPane().add(buttons, BorderLayout.SOUTH);
+        dialog.getRootPane().setDefaultButton(ok);
+        dialog.pack();
+        dialog.setLocationRelativeTo(owner);
+        dialog.setVisible(true);
+        result.setText(accepted[0] ? "Renamed to " + field.getText() : "Rename cancelled");
+    }
+
+    private void showOpen() {
+        JFileChooser chooser = new JFileChooser();
+        chooser.setFileFilter(new FileNameExtensionFilter("Text files", "txt", "md"));
+        if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
+            File file = chooser.getSelectedFile();
+            result.setText("Chose " + file.getName() + " (" + file.length() + " bytes)");
+        } else {
+            result.setText("No file chosen");
+        }
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/GalleryApp.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/GalleryApp.java
new file mode 100644
index 00000000000..45d3fd724c9
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/GalleryApp.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.swing.BorderFactory;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JTabbedPane;
+import javax.swing.KeyStroke;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.WindowConstants;
+
+/**
+ * The application: one frame, a menu bar, and a tab per area of Swing.
+ */
+public class GalleryApp {
+
+    private static final Logger LOG = Logger.getLogger(GalleryApp.class.getName());
+
+    private final ResourceBundle messages = ResourceBundle.getBundle("messages");
+    private JFrame frame;
+    private JLabel status;
+
+    public static void main(String[] args) {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (Exception e) {
+            LOG.log(Level.WARNING, "Keeping the default look and feel", e);
+        }
+        SwingUtilities.invokeLater(new Runnable() {
+            @Override
+            public void run() {
+                new GalleryApp().show();
+            }
+        });
+    }
+
+    private void show() {
+        frame = new JFrame(messages.getString("app.title"));
+        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        frame.setJMenuBar(createMenuBar());
+
+        JTabbedPane tabs = new JTabbedPane();
+        tabs.addTab(messages.getString("tab.controls"), new ControlsPanel());
+        tabs.addTab(messages.getString("tab.layouts"), new LayoutsPanel());
+        tabs.addTab(messages.getString("tab.data"), new DataPanel());
+        tabs.addTab(messages.getString("tab.painting"), new PaintPanel());
+        tabs.addTab(messages.getString("tab.dialogs"), new DialogsPanel());
+        tabs.addTab(messages.getString("tab.worker"), new WorkerPanel());
+        tabs.addTab(messages.getString("tab.swingx"), new SwingXPanel());
+        tabs.addTab(messages.getString("tab.resources"), new ResourcesPanel(messages));
+        tabs.addChangeListener(e -> status.setText(tabs.getTitleAt(tabs.getSelectedIndex())));
+
+        status = new JLabel(tabs.getTitleAt(0));
+        status.setBorder(BorderFactory.createEmptyBorder(2, 6, 2, 6));
+
+        frame.getContentPane().add(tabs, BorderLayout.CENTER);
+        frame.getContentPane().add(status, BorderLayout.SOUTH);
+        frame.setPreferredSize(new Dimension(820, 600));
+        frame.pack();
+        frame.setLocationRelativeTo(null);
+        frame.setVisible(true);
+        LOG.info("Gallery started");
+    }
+
+    private JMenuBar createMenuBar() {
+        JMenuBar bar = new JMenuBar();
+
+        JMenu file = new JMenu(messages.getString("menu.file"));
+        file.setMnemonic(KeyEvent.VK_F);
+        JMenuItem exit = new JMenuItem(messages.getString("menu.exit"));
+        exit.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, InputEvent.CTRL_DOWN_MASK));
+        exit.addActionListener(e -> System.exit(0));
+        file.add(exit);
+        bar.add(file);
+
+        JMenu view = new JMenu(messages.getString("menu.view"));
+        JCheckBoxMenuItem showStatus = new JCheckBoxMenuItem(messages.getString("menu.status"), true);
+        showStatus.addActionListener(e -> status.setVisible(showStatus.isSelected()));
+        view.add(showStatus);
+        bar.add(view);
+
+        JMenu help = new JMenu(messages.getString("menu.help"));
+        JMenuItem about = new JMenuItem(messages.getString("menu.about"));
+        about.addActionListener(e -> JOptionPane.showMessageDialog(frame,
+                messages.getString("about.text"), messages.getString("menu.about"),
+                JOptionPane.INFORMATION_MESSAGE));
+        help.add(about);
+        bar.add(help);
+        return bar;
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/LayoutsPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/LayoutsPanel.java
new file mode 100644
index 00000000000..5e9e669584d
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/LayoutsPanel.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BorderLayout;
+import java.awt.CardLayout;
+import java.awt.Color;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.GroupLayout;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+
+import net.miginfocom.swing.MigLayout;
+
+/**
+ * One small form or arrangement per layout manager.
+ */
+public class LayoutsPanel extends JPanel {
+
+    public LayoutsPanel() {
+        super(new BorderLayout());
+        JTabbedPane tabs = new JTabbedPane(SwingConstants.LEFT);
+        tabs.addTab("Border", border());
+        tabs.addTab("GridBag", gridBag());
+        tabs.addTab("Group", group());
+        tabs.addTab("Box", box());
+        tabs.addTab("Card", card());
+        tabs.addTab("Mig", mig());
+        add(tabs, BorderLayout.CENTER);
+    }
+
+    private JPanel border() {
+        JPanel p = new JPanel(new BorderLayout(4, 4));
+        p.add(colored("North", new Color(0xcfe8ff)), BorderLayout.NORTH);
+        p.add(colored("South", new Color(0xcfe8ff)), BorderLayout.SOUTH);
+        p.add(colored("West", new Color(0xffe9c4)), BorderLayout.WEST);
+        p.add(colored("East", new Color(0xffe9c4)), BorderLayout.EAST);
+        p.add(colored("Center", Color.WHITE), BorderLayout.CENTER);
+        return p;
+    }
+
+    private JPanel gridBag() {
+        JPanel p = new JPanel(new GridBagLayout());
+        GridBagConstraints c = new GridBagConstraints();
+        c.insets = new Insets(4, 4, 4, 4);
+        c.anchor = GridBagConstraints.LINE_END;
+        c.gridx = 0;
+        c.gridy = 0;
+        p.add(new JLabel("First name:"), c);
+        c.gridy = 1;
+        p.add(new JLabel("Last name:"), c);
+        c.gridy = 2;
+        p.add(new JLabel("Email:"), c);
+
+        c.gridx = 1;
+        c.gridy = 0;
+        c.weightx = 1;
+        c.fill = GridBagConstraints.HORIZONTAL;
+        c.anchor = GridBagConstraints.LINE_START;
+        p.add(new JTextField(16), c);
+        c.gridy = 1;
+        p.add(new JTextField(16), c);
+        c.gridy = 2;
+        p.add(new JTextField(16), c);
+
+        c.gridx = 0;
+        c.gridy = 3;
+        c.gridwidth = 2;
+        c.weighty = 1;
+        c.fill = GridBagConstraints.NONE;
+        c.anchor = GridBagConstraints.FIRST_LINE_END;
+        p.add(new JButton("Save"), c);
+        return p;
+    }
+
+    private JPanel group() {
+        JPanel p = new JPanel();
+        GroupLayout layout = new GroupLayout(p);
+        p.setLayout(layout);
+        layout.setAutoCreateGaps(true);
+        layout.setAutoCreateContainerGaps(true);
+
+        JLabel hostLabel = new JLabel("Host:");
+        JLabel portLabel = new JLabel("Port:");
+        JTextField host = new JTextField("localhost", 16);
+        JTextField port = new JTextField("8080", 6);
+        JButton connect = new JButton("Connect");
+
+        layout.setHorizontalGroup(layout.createSequentialGroup()
+                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.TRAILING)
+                        .addComponent(hostLabel)
+                        .addComponent(portLabel))
+                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
+                        .addComponent(host)
+                        .addComponent(port, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
+                                GroupLayout.PREFERRED_SIZE)
+                        .addComponent(connect)));
+        layout.setVerticalGroup(layout.createSequentialGroup()
+                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
+                        .addComponent(hostLabel)
+                        .addComponent(host))
+                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
+                        .addComponent(portLabel)
+                        .addComponent(port))
+                .addComponent(connect));
+        return p;
+    }
+
+    private JPanel box() {
+        JPanel p = new JPanel();
+        p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
+        p.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        p.add(new JButton("Left"));
+        p.add(Box.createHorizontalStrut(12));
+        p.add(new JButton("Next to it"));
+        p.add(Box.createHorizontalGlue());
+        p.add(new JButton("Far right"));
+        return p;
+    }
+
+    private JPanel card() {
+        CardLayout cards = new CardLayout();
+        JPanel deck = new JPanel(cards);
+        deck.add(colored("The first card", new Color(0xe3f6e0)), "first");
+        deck.add(colored("The second card", new Color(0xf6e0ee)), "second");
+        deck.add(colored("The third card", new Color(0xe0e6f6)), "third");
+
+        JComboBox<String> chooser = new JComboBox<>(new String[] {"first", "second", "third"});
+        chooser.addActionListener(e -> cards.show(deck, (String) chooser.getSelectedItem()));
+        JButton next = new JButton("Next");
+        next.addActionListener(e -> cards.next(deck));
+
+        JPanel top = new JPanel();
+        top.add(chooser);
+        top.add(next);
+        JPanel p = new JPanel(new BorderLayout());
+        p.add(top, BorderLayout.NORTH);
+        p.add(deck, BorderLayout.CENTER);
+        return p;
+    }
+
+    private JPanel mig() {
+        JPanel p = new JPanel(new MigLayout("wrap 2, insets 10", "[right][grow, fill]"));
+        p.add(new JLabel("Street:"));
+        p.add(new JTextField());
+        p.add(new JLabel("City:"));
+        p.add(new JTextField());
+        p.add(new JLabel("Zip:"));
+        p.add(new JTextField(6), "width 80!, growx 0");
+        p.add(new JButton("Cancel"), "span 2, split 2, right");
+        p.add(new JButton("OK"));
+        return p;
+    }
+
+    private static JLabel colored(String text, Color background) {
+        JLabel label = new JLabel(text, SwingConstants.CENTER);
+        label.setOpaque(true);
+        label.setBackground(background);
+        label.setBorder(BorderFactory.createLineBorder(Color.GRAY));
+        return label;
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/PaintPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/PaintPanel.java
new file mode 100644
index 00000000000..44bebba53cf
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/PaintPanel.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BasicStroke;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.RoundRectangle2D;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.JButton;
+import javax.swing.JComponent;
+import javax.swing.JPanel;
+
+/**
+ * Custom painting with Graphics2D, and free-hand drawing with the mouse.
+ */
+public class PaintPanel extends JPanel {
+
+    public PaintPanel() {
+        super(new BorderLayout());
+        Canvas canvas = new Canvas();
+        JButton clear = new JButton("Clear drawing");
+        clear.addActionListener(e -> canvas.clear());
+        JPanel bottom = new JPanel();
+        bottom.add(clear);
+        add(canvas, BorderLayout.CENTER);
+        add(bottom, BorderLayout.SOUTH);
+    }
+
+    private static class Canvas extends JComponent {
+
+        private final List<List<Point>> strokes = new ArrayList<>();
+        private final BufferedImage checker = createChecker();
+        private List<Point> current;
+
+        Canvas() {
+            setPreferredSize(new Dimension(600, 400));
+            MouseAdapter mouse = new MouseAdapter() {
+                @Override
+                public void mousePressed(MouseEvent e) {
+                    current = new ArrayList<>();
+                    current.add(e.getPoint());
+                    strokes.add(current);
+                }
+
+                @Override
+                public void mouseDragged(MouseEvent e) {
+                    if (current != null) {
+                        current.add(e.getPoint());
+                        repaint();
+                    }
+                }
+
+                @Override
+                public void mouseReleased(MouseEvent e) {
+                    current = null;
+                }
+            };
+            addMouseListener(mouse);
+            addMouseMotionListener(mouse);
+        }
+
+        void clear() {
+            strokes.clear();
+            repaint();
+        }
+
+        /** An image painted once, off screen, and drawn on every repaint. */
+        private static BufferedImage createChecker() {
+            BufferedImage image = new BufferedImage(64, 64, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D g = image.createGraphics();
+            for (int y = 0; y < 8; y++) {
+                for (int x = 0; x < 8; x++) {
+                    g.setColor((x + y) % 2 == 0 ? new Color(0x355c7d) : new Color(0xf8b195));
+                    g.fillRect(x * 8, y * 8, 8, 8);
+                }
+            }
+            g.dispose();
+            return image;
+        }
+
+        @Override
+        protected void paintComponent(Graphics graphics) {
+            super.paintComponent(graphics);
+            Graphics2D g = (Graphics2D) graphics.create();
+            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            int w = getWidth();
+            int h = getHeight();
+
+            g.setPaint(new GradientPaint(0, 0, new Color(0xfdfbfb), 0, h, new Color(0xdfe9f3)));
+            g.fillRect(0, 0, w, h);
+
+            g.setColor(new Color(0x6c5b7b));
+            g.fill(new Ellipse2D.Double(20, 20, 90, 60));
+            g.setColor(new Color(0xc06c84));
+            g.fill(new RoundRectangle2D.Double(130, 20, 90, 60, 18, 18));
+
+            Path2D triangle = new Path2D.Double();
+            triangle.moveTo(285, 20);
+            triangle.lineTo(330, 80);
+            triangle.lineTo(240, 80);
+            triangle.closePath();
+            g.setColor(new Color(0xf67280));
+            g.fill(triangle);
+
+            g.setColor(Color.DARK_GRAY);
+            g.setStroke(new BasicStroke(2f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 10f,
+                    new float[] {8f, 6f}, 0f));
+            g.draw(new Line2D.Double(20, 100, 330, 100));
+            g.setStroke(new BasicStroke(3f));
+            g.draw(new Ellipse2D.Double(20, 20, 90, 60));
+
+            AffineTransform saved = g.getTransform();
+            g.rotate(Math.toRadians(-20), 420, 60);
+            g.setColor(new Color(0x355c7d));
+            g.fillRect(380, 40, 80, 40);
+            g.setTransform(saved);
+
+            g.drawImage(checker, 20, 120, null);
+            g.drawImage(checker, 100, 120, 32, 32, null);
+
+            String text = "Graphics2D";
+            g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 22));
+            FontMetrics metrics = g.getFontMetrics();
+            int textWidth = metrics.stringWidth(text);
+            int baseline = 150 + metrics.getAscent();
+            g.setColor(new Color(0x355c7d));
+            g.drawString(text, w - textWidth - 20, baseline);
+            g.drawLine(w - textWidth - 20, baseline + 2, w - 20, baseline + 2);
+
+            g.setColor(Color.BLACK);
+            g.setStroke(new BasicStroke(2f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+            for (List<Point> stroke : strokes) {
+                for (int i = 1; i < stroke.size(); i++) {
+                    Point a = stroke.get(i - 1);
+                    Point b = stroke.get(i);
+                    g.drawLine(a.x, a.y, b.x, b.y);
+                }
+            }
+            g.dispose();
+        }
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/Planet.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/Planet.java
new file mode 100644
index 00000000000..9593ad3a769
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/Planet.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+/**
+ * A row of the data the list, the tables and the tree show.
+ */
+public class Planet {
+
+    private final String name;
+    private final double mass;
+    private final int moons;
+    private boolean visited;
+
+    public Planet(String name, double mass, int moons) {
+        this.name = name;
+        this.mass = mass;
+        this.moons = moons;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /** In Earth masses. */
+    public double getMass() {
+        return mass;
+    }
+
+    public int getMoons() {
+        return moons;
+    }
+
+    public boolean isVisited() {
+        return visited;
+    }
+
+    public void setVisited(boolean visited) {
+        this.visited = visited;
+    }
+
+    public static Planet[] all() {
+        return new Planet[] {
+            new Planet("Mercury", 0.055, 0),
+            new Planet("Venus", 0.815, 0),
+            new Planet("Earth", 1.0, 1),
+            new Planet("Mars", 0.107, 2),
+            new Planet("Jupiter", 317.8, 95),
+            new Planet("Saturn", 95.2, 146),
+            new Planet("Uranus", 14.5, 28),
+            new Planet("Neptune", 17.1, 16),
+        };
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/PlanetTableModel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/PlanetTableModel.java
new file mode 100644
index 00000000000..fcf93cd2521
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/PlanetTableModel.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import javax.swing.table.AbstractTableModel;
+
+/**
+ * The planets as a table: three read-only columns and an editable check box.
+ */
+public class PlanetTableModel extends AbstractTableModel {
+
+    public static final int NAME = 0;
+    public static final int MASS = 1;
+    public static final int MOONS = 2;
+    public static final int VISITED = 3;
+
+    private static final String[] COLUMNS = {"Name", "Mass (Earths)", "Moons", "Visited"};
+
+    private final Planet[] planets;
+
+    public PlanetTableModel(Planet[] planets) {
+        this.planets = planets;
+    }
+
+    @Override
+    public int getRowCount() {
+        return planets.length;
+    }
+
+    @Override
+    public int getColumnCount() {
+        return COLUMNS.length;
+    }
+
+    @Override
+    public String getColumnName(int column) {
+        return COLUMNS[column];
+    }
+
+    @Override
+    public Class<?> getColumnClass(int column) {
+        switch (column) {
+            case MASS:
+                return Double.class;
+            case MOONS:
+                return Integer.class;
+            case VISITED:
+                return Boolean.class;
+            default:
+                return String.class;
+        }
+    }
+
+    @Override
+    public boolean isCellEditable(int row, int column) {
+        return column == VISITED;
+    }
+
+    @Override
+    public Object getValueAt(int row, int column) {
+        Planet p = planets[row];
+        switch (column) {
+            case MASS:
+                return p.getMass();
+            case MOONS:
+                return p.getMoons();
+            case VISITED:
+                return p.isVisited();
+            default:
+                return p.getName();
+        }
+    }
+
+    @Override
+    public void setValueAt(Object value, int row, int column) {
+        if (column == VISITED) {
+            planets[row].setVisited(Boolean.TRUE.equals(value));
+            fireTableCellUpdated(row, column);
+        }
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/ResourcesPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/ResourcesPanel.java
new file mode 100644
index 00000000000..11109372c62
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/ResourcesPanel.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.GridLayout;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.net.URL;
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.prefs.Preferences;
+
+import javax.imageio.ImageIO;
+import javax.swing.BorderFactory;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.SwingConstants;
+
+/**
+ * What an application loads by name: images, translated text and its saved settings.
+ */
+public class ResourcesPanel extends JPanel {
+
+    private static final Logger LOG = Logger.getLogger(ResourcesPanel.class.getName());
+    private static final String VISITS = "visits";
+
+    private final Preferences prefs = Preferences.userNodeForPackage(ResourcesPanel.class);
+
+    public ResourcesPanel(ResourceBundle messages) {
+        super(new GridLayout(0, 1, 6, 6));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+
+        add(new JLabel(messages.getString("resources.icon"), icon("/icons/star.png"), SwingConstants.LEFT));
+
+        JButton iconButton = new JButton(messages.getString("resources.button"), icon("/icons/dot.png"));
+        JPanel buttonRow = new JPanel();
+        buttonRow.add(iconButton);
+        add(buttonRow);
+
+        int visits = prefs.getInt(VISITS, 0) + 1;
+        prefs.putInt(VISITS, visits);
+        JLabel counter = new JLabel(MessageFormat.format(messages.getString("resources.visits"), visits));
+        add(counter);
+
+        JButton reset = new JButton(messages.getString("resources.reset"));
+        reset.addActionListener(e -> {
+            prefs.remove(VISITS);
+            counter.setText(MessageFormat.format(messages.getString("resources.visits"), 0));
+            LOG.log(Level.INFO, "Visit counter reset");
+        });
+        JPanel resetRow = new JPanel();
+        resetRow.add(reset);
+        add(resetRow);
+
+        add(new JLabel(messages.getString("resources.locale") + " " + messages.getLocale()));
+        add(new JLabel(describe("/icons/star.png")));
+    }
+
+    private String describe(String path) {
+        URL url = getClass().getResource(path);
+        if (url == null) {
+            return path + ": missing";
+        }
+        try {
+            BufferedImage image = ImageIO.read(url);
+            return path + ": " + image.getWidth() + " x " + image.getHeight();
+        } catch (IOException e) {
+            LOG.log(Level.WARNING, "Cannot read " + path, e);
+            return path + ": unreadable";
+        }
+    }
+
+    private ImageIcon icon(String path) {
+        URL url = getClass().getResource(path);
+        if (url == null) {
+            LOG.warning("Missing resource " + path);
+            return null;
+        }
+        return new ImageIcon(url);
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/SwingXPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/SwingXPanel.java
new file mode 100644
index 00000000000..95e76126489
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/SwingXPanel.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BorderLayout;
+import java.awt.FlowLayout;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+
+import org.jdesktop.swingx.JXBusyLabel;
+import org.jdesktop.swingx.JXDatePicker;
+import org.jdesktop.swingx.JXTable;
+import org.jdesktop.swingx.JXTaskPane;
+import org.jdesktop.swingx.JXTaskPaneContainer;
+import org.jdesktop.swingx.decorator.HighlighterFactory;
+
+/**
+ * A few SwingX components: a striped table, task panes, a date picker and a busy label.
+ */
+public class SwingXPanel extends JPanel {
+
+    private final JLabel picked = new JLabel("No date picked");
+
+    public SwingXPanel() {
+        super(new BorderLayout(6, 6));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        add(new JScrollPane(tasks()), BorderLayout.WEST);
+        add(new JScrollPane(table()), BorderLayout.CENTER);
+        add(pickers(), BorderLayout.SOUTH);
+    }
+
+    private JXTable table() {
+        JXTable table = new JXTable(new PlanetTableModel(Planet.all()));
+        table.setHighlighters(HighlighterFactory.createSimpleStriping());
+        table.setColumnControlVisible(true);
+        table.setVisibleRowCount(8);
+        table.packAll();
+        return table;
+    }
+
+    private JXTaskPaneContainer tasks() {
+        JXTaskPaneContainer container = new JXTaskPaneContainer();
+
+        JXTaskPane files = new JXTaskPane();
+        files.setTitle("File tasks");
+        files.add(new JLabel("Rename this file"));
+        files.add(new JLabel("Move this file"));
+        container.add(files);
+
+        JXTaskPane details = new JXTaskPane();
+        details.setTitle("Details");
+        details.setCollapsed(true);
+        details.add(new JLabel("8 planets"));
+        container.add(details);
+        return container;
+    }
+
+    private JPanel pickers() {
+        JPanel p = new JPanel(new FlowLayout(FlowLayout.LEFT, 8, 4));
+        JXDatePicker date = new JXDatePicker(new Date());
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
+        date.addActionListener(e -> picked.setText(date.getDate() == null ? "No date picked"
+                : "Picked " + format.format(date.getDate())));
+        p.add(date);
+        p.add(picked);
+
+        JXBusyLabel busy = new JXBusyLabel();
+        busy.setText("Idle");
+        JButton toggle = new JButton("Toggle busy");
+        toggle.addActionListener(e -> {
+            busy.setBusy(!busy.isBusy());
+            busy.setText(busy.isBusy() ? "Working..." : "Idle");
+        });
+        p.add(toggle);
+        p.add(busy);
+        return p;
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/WorkerPanel.java b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/WorkerPanel.java
new file mode 100644
index 00000000000..f7e7a902ae7
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/java/com/example/gallery/WorkerPanel.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.example.gallery;
+
+import java.awt.BorderLayout;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JPanel;
+import javax.swing.JProgressBar;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.SwingWorker;
+
+/**
+ * Work done off the event dispatch thread, reporting back as it goes.
+ */
+public class WorkerPanel extends JPanel {
+
+    private final JProgressBar progress = new JProgressBar(0, 100);
+    private final JTextArea log = new JTextArea(10, 40);
+    private final JButton start = new JButton("Find primes");
+    private final JButton cancel = new JButton("Cancel");
+    private PrimeFinder worker;
+
+    public WorkerPanel() {
+        super(new BorderLayout(6, 6));
+        setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        log.setEditable(false);
+        cancel.setEnabled(false);
+        start.addActionListener(e -> start());
+        cancel.addActionListener(e -> worker.cancel(true));
+
+        JPanel top = new JPanel(new BorderLayout(6, 6));
+        JPanel buttons = new JPanel();
+        buttons.add(start);
+        buttons.add(cancel);
+        top.add(buttons, BorderLayout.WEST);
+        top.add(progress, BorderLayout.CENTER);
+        add(top, BorderLayout.NORTH);
+        add(new JScrollPane(log), BorderLayout.CENTER);
+    }
+
+    private void start() {
+        log.setText("");
+        start.setEnabled(false);
+        cancel.setEnabled(true);
+        worker = new PrimeFinder(20000);
+        worker.addPropertyChangeListener(e -> {
+            if ("progress".equals(e.getPropertyName())) {
+                progress.setValue((Integer) e.getNewValue());
+            }
+        });
+        worker.execute();
+    }
+
+    /** Counts the primes below a limit, publishing each thousandth one. */
+    private class PrimeFinder extends SwingWorker<Integer, Integer> {
+
+        private final int limit;
+
+        PrimeFinder(int limit) {
+            this.limit = limit;
+        }
+
+        @Override
+        protected Integer doInBackground() throws Exception {
+            int found = 0;
+            for (int n = 2; n < limit && !isCancelled(); n++) {
+                if (isPrime(n)) {
+                    found++;
+                    if (found % 250 == 0) {
+                        publish(n);
+                    }
+                }
+                setProgress(n * 100 / limit);
+            }
+            return found;
+        }
+
+        private boolean isPrime(int n) {
+            for (int d = 2; (long) d * d <= n; d++) {
+                if (n % d == 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override
+        protected void process(List<Integer> chunks) {
+            for (Integer prime : chunks) {
+                log.append("... " + prime + "\n");
+            }
+        }
+
+        @Override
+        protected void done() {
+            start.setEnabled(true);
+            cancel.setEnabled(false);
+            if (isCancelled()) {
+                log.append("Cancelled\n");
+                return;
+            }
+            try {
+                progress.setValue(100);
+                log.append(get() + " primes below " + limit + "\n");
+            } catch (InterruptedException | ExecutionException e) {
+                log.append("Failed: " + e.getMessage() + "\n");
+            }
+        }
+    }
+}
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/resources/icons/dot.png b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/icons/dot.png
new file mode 100644
index 00000000000..ba52e978c36
Binary files /dev/null and b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/icons/dot.png differ
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/resources/icons/star.png b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/icons/star.png
new file mode 100644
index 00000000000..7dbdbf43246
Binary files /dev/null and b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/icons/star.png differ
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/resources/messages.properties b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/messages.properties
new file mode 100644
index 00000000000..f5ef6a9b0cf
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/messages.properties
@@ -0,0 +1,21 @@
+app.title=Swing Gallery
+menu.file=File
+menu.exit=Exit
+menu.view=View
+menu.status=Status bar
+menu.help=Help
+menu.about=About
+about.text=An ordinary Swing application.
+tab.controls=Controls
+tab.layouts=Layouts
+tab.data=Data
+tab.painting=Painting
+tab.dialogs=Dialogs
+tab.worker=Worker
+tab.swingx=SwingX
+tab.resources=Resources
+resources.icon=An icon loaded from the classpath
+resources.button=A button with an icon
+resources.visits=This tab was opened {0} times
+resources.reset=Reset the counter
+resources.locale=Bundle locale:
diff --git a/scripts/desktop-compat-samples/swing-gallery/src/main/resources/messages_fr.properties b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/messages_fr.properties
new file mode 100644
index 00000000000..a384b230580
--- /dev/null
+++ b/scripts/desktop-compat-samples/swing-gallery/src/main/resources/messages_fr.properties
@@ -0,0 +1,21 @@
+app.title=Galerie Swing
+menu.file=Fichier
+menu.exit=Quitter
+menu.view=Affichage
+menu.status=Barre d'\u00e9tat
+menu.help=Aide
+menu.about=\u00c0 propos
+about.text=Une application Swing ordinaire.
+tab.controls=Contr\u00f4les
+tab.layouts=Dispositions
+tab.data=Donn\u00e9es
+tab.painting=Dessin
+tab.dialogs=Dialogues
+tab.worker=T\u00e2che
+tab.swingx=SwingX
+tab.resources=Ressources
+resources.icon=Une ic\u00f4ne charg\u00e9e depuis le classpath
+resources.button=Un bouton avec une ic\u00f4ne
+resources.visits=Cet onglet a \u00e9t\u00e9 ouvert {0} fois
+resources.reset=Remettre le compteur \u00e0 z\u00e9ro
+resources.locale=Langue du fichier :
diff --git a/scripts/developer-guide/check-guide-api-names.py b/scripts/developer-guide/check-guide-api-names.py
index 9a842ad4bce..15f6aff805b 100755
--- a/scripts/developer-guide/check-guide-api-names.py
+++ b/scripts/developer-guide/check-guide-api-names.py
@@ -60,8 +60,12 @@
 # which the workflow watches. Triggering on Ports/**, vm/** and maven/**
 # instead would run this job -- maven install, the demo build and the
 # screenshots -- for nearly every change in the repository.
+# docs/demos is the guide's own code: every snippet compiles there, so a class
+# a chapter defines and then names -- the game builder's Level1, a near miss
+# for java.util.logging.Level once the class library had that -- is real.
 IDENTIFIER_ROOTS = [os.path.join(ROOT, d)
-                    for d in ('CodenameOne', 'Ports', 'vm', 'maven')]
+                    for d in ('CodenameOne', 'Ports', 'vm', 'maven',
+                              os.path.join('docs', 'demos'))]
 IDENTIFIER_SUFFIXES = ('.java', '.m', '.h', '.mm', '.kt', '.js', '.c', '.cpp',
                        '.xml', '.gradle', '.swift', '.cs')
 
diff --git a/scripts/hellocodenameone/common/pom.xml b/scripts/hellocodenameone/common/pom.xml
index a32f1b93ece..34080a452c7 100644
--- a/scripts/hellocodenameone/common/pom.xml
+++ b/scripts/hellocodenameone/common/pom.xml
@@ -43,6 +43,38 @@
     <!-- The following are profiles to cover special cases -->
     <profiles>
 
+        <!-- The desktop compatibility layers: active while src/main/desktop
+             exists, as in a generated project. This app's own main class extends
+             neither desktop lifecycle, so the desktop sources there are built
+             in library mode. SwingX is
+             only compiled against: the Swing layer has its own. -->
+        <profile>
+            <id>desktop-compat</id>
+            <activation>
+                <file>
+                    <exists>${basedir}/src/main/desktop</exists>
+                </file>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>com.codenameone</groupId>
+                    <artifactId>codenameone-swing-compat</artifactId>
+                    <scope>provided</scope>
+                </dependency>
+                <dependency>
+                    <groupId>com.codenameone</groupId>
+                    <artifactId>codenameone-javafx-compat</artifactId>
+                    <scope>provided</scope>
+                </dependency>
+                <dependency>
+                    <groupId>org.swinglabs.swingx</groupId>
+                    <artifactId>swingx-all</artifactId>
+                    <version>1.6.5-1</version>
+                    <scope>provided</scope>
+                </dependency>
+            </dependencies>
+        </profile>
+
         <!-- A profile to install Codename One support libraries to your home directory
             if they aren't installed yet. -->
         <profile>
@@ -411,6 +443,16 @@
                             <androidSourceDir>${android.gallery.dir}</androidSourceDir>
                         </configuration>
                     </execution>
+                    <!-- The desktop compatibility screens (src/main/desktop): adds
+                         its java/ and resources/ to the build and compiles the
+                         FXML document and the style sheet. -->
+                    <execution>
+                        <id>prepare-desktop-sources</id>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>prepare-desktop-sources</goal>
+                        </goals>
+                    </execution>
                     <execution>
                         <id>generate-gui-sources</id>
                         <phase>process-sources</phase>
@@ -422,7 +464,9 @@
                         <id>cn1-process-classes</id>
                         <phase>process-classes</phase>
                         <goals>
-                            <goal>remap-android</goal>
+                            <!-- Relocates the Android gallery AND the desktop
+                                 screens onto their compatibility runtimes. -->
+                            <goal>remap-compat</goal>
                             <goal>bytecode-compliance</goal>
                             <goal>css</goal>
                             <goal>process-annotations</goal>
diff --git a/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/AccountController.java b/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/AccountController.java
new file mode 100644
index 00000000000..8d059c40cde
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/AccountController.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.desktop;
+
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextField;
+
+/// The controller of `account.fxml`, the FXML screen of the desktop
+/// compatibility screenshot tests.
+public class AccountController {
+
+    @FXML
+    private Label status;
+
+    @FXML
+    private TextField owner;
+
+    @FXML
+    private Button save;
+
+    @FXML
+    private void initialize() {
+        // What the capture shows: the document's own text is replaced, so a
+        // controller that never ran is visible in the picture.
+        status.setText("Loaded by the controller");
+        owner.setText("Ada Lovelace");
+        // A focused field has a caret, which blinks.
+        owner.setFocusTraversable(false);
+    }
+
+    @FXML
+    private void save(ActionEvent event) {
+        status.setText("Saved " + owner.getText());
+        save.setDisable(true);
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/FxScenes.java b/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/FxScenes.java
new file mode 100644
index 00000000000..9dfbf68c103
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/FxScenes.java
@@ -0,0 +1,397 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.desktop;
+
+import com.codename1.fxcompat.FxInterop;
+
+import java.util.Optional;
+
+import javafx.beans.property.ReadOnlyObjectWrapper;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXMLLoader;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.ListCell;
+import javafx.scene.control.ListView;
+import javafx.scene.control.PasswordField;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.Slider;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.TextField;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.FlowPane;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.CycleMethod;
+import javafx.scene.paint.LinearGradient;
+import javafx.scene.paint.RadialGradient;
+import javafx.scene.paint.Stop;
+import javafx.scene.shape.Circle;
+import javafx.scene.shape.Ellipse;
+import javafx.scene.shape.Line;
+import javafx.scene.shape.Polygon;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Callback;
+
+/// The JavaFX screens of the desktop compatibility screenshot tests.
+///
+/// This class is ordinary JavaFX; the build relocates it onto the JavaFX
+/// layer and compiles the FXML document and the style sheet beside it.
+/// Each scene is built here and handed to the application as a Codename One
+/// component, which is all the tests in `tests/desktopcompat` ever see of
+/// JavaFX.
+///
+/// Everything a scene shows is fixed: no clock, no animation, no focused
+/// text field.
+public final class FxScenes {
+
+    private static final String[] NAMES = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn"};
+    private static final int[] MOONS = {0, 0, 1, 2, 95, 146};
+
+    private static Alert open;
+
+    private FxScenes() {
+    }
+
+    private static com.codename1.ui.Component host(Parent content) {
+        StackPane root = new StackPane(content);
+        root.setPadding(new Insets(8));
+        root.setStyle("-fx-background-color: white;");
+        return FxInterop.asComponent(root);
+    }
+
+    /// A text control that takes no focus on its own: a caret blinks.
+    private static <T extends Node> T still(T node) {
+        node.setFocusTraversable(false);
+        return node;
+    }
+
+    /// Scene (h): the basic controls in a `GridPane` inside a `VBox`.
+    public static com.codename1.ui.Component controls() {
+        GridPane grid = new GridPane();
+        grid.setHgap(8);
+        grid.setVgap(8);
+        grid.add(new Label("Name:"), 0, 0);
+        TextField name = still(new TextField("Ada Lovelace"));
+        grid.add(name, 1, 0);
+        GridPane.setHgrow(name, Priority.ALWAYS);
+        grid.add(new Label("Password:"), 0, 1);
+        PasswordField password = still(new PasswordField());
+        password.setText("secret");
+        grid.add(password, 1, 1);
+        grid.add(new Label("Planet:"), 0, 2);
+        ComboBox<String> planet = new ComboBox<String>(FXCollections.observableArrayList(NAMES));
+        planet.setValue("Earth");
+        grid.add(planet, 1, 2);
+        grid.add(new Label("Volume:"), 0, 3);
+        grid.add(new Slider(0, 100, 35), 1, 3);
+        grid.add(new Label("Progress:"), 0, 4);
+        ProgressBar progress = new ProgressBar(0.6);
+        progress.setMaxWidth(Double.MAX_VALUE);
+        grid.add(progress, 1, 4);
+
+        CheckBox remember = new CheckBox("Remember me");
+        remember.setSelected(true);
+        CheckBox offline = new CheckBox("Work offline");
+        HBox checks = new HBox(12, remember, offline);
+
+        ToggleGroup sizes = new ToggleGroup();
+        RadioButton small = new RadioButton("Small");
+        RadioButton medium = new RadioButton("Medium");
+        RadioButton large = new RadioButton("Large");
+        small.setToggleGroup(sizes);
+        medium.setToggleGroup(sizes);
+        large.setToggleGroup(sizes);
+        medium.setSelected(true);
+        HBox radios = new HBox(12, small, medium, large);
+
+        Button disabled = new Button("Disabled");
+        disabled.setDisable(true);
+        HBox buttons = new HBox(8, disabled, new Button("Cancel"), new Button("OK"));
+        buttons.setAlignment(Pos.CENTER_RIGHT);
+
+        VBox box = new VBox(12, grid, checks, radios, buttons);
+        box.setAlignment(Pos.TOP_LEFT);
+        return host(box);
+    }
+
+    /// A row of the table of scene (i).
+    public static final class Planet {
+        private final String name;
+        private final int moons;
+
+        Planet(String name, int moons) {
+            this.name = name;
+            this.moons = moons;
+        }
+
+        /// The planet's name.
+        public String getName() {
+            return name;
+        }
+
+        /// How many moons it has.
+        public int getMoons() {
+            return moons;
+        }
+    }
+
+    /// Scene (i): a `TableView` over a `ListView` with a cell factory.
+    public static com.codename1.ui.Component data() {
+        ObservableList<Planet> planets = FXCollections.observableArrayList();
+        for (int i = 0; i < NAMES.length; i++) {
+            planets.add(new Planet(NAMES[i], MOONS[i]));
+        }
+        TableView<Planet> table = new TableView<Planet>(planets);
+        TableColumn<Planet, String> name = new TableColumn<Planet, String>("Planet");
+        name.setCellValueFactory(
+                new Callback<TableColumn.CellDataFeatures<Planet, String>, ObservableValue<String>>() {
+                    @Override
+                    public ObservableValue<String> call(TableColumn.CellDataFeatures<Planet, String> row) {
+                        return new ReadOnlyObjectWrapper<String>(row.getValue().getName());
+                    }
+                });
+        name.setPrefWidth(160);
+        TableColumn<Planet, Number> moons = new TableColumn<Planet, Number>("Moons");
+        moons.setCellValueFactory(
+                new Callback<TableColumn.CellDataFeatures<Planet, Number>, ObservableValue<Number>>() {
+                    @Override
+                    public ObservableValue<Number> call(TableColumn.CellDataFeatures<Planet, Number> row) {
+                        return new ReadOnlyObjectWrapper<Number>(Integer.valueOf(row.getValue().getMoons()));
+                    }
+                });
+        moons.setPrefWidth(90);
+        table.getColumns().add(name);
+        table.getColumns().add(moons);
+        table.setPrefHeight(200);
+
+        ListView<Planet> list = new ListView<Planet>(planets);
+        list.setCellFactory(new Callback<ListView<Planet>, ListCell<Planet>>() {
+            @Override
+            public ListCell<Planet> call(ListView<Planet> view) {
+                return new ListCell<Planet>() {
+                    @Override
+                    protected void updateItem(Planet item, boolean empty) {
+                        super.updateItem(item, empty);
+                        if (empty || item == null) {
+                            setText(null);
+                            setStyle("");
+                        } else {
+                            setText(item.getName() + "  -  " + item.getMoons()
+                                    + (item.getMoons() == 1 ? " moon" : " moons"));
+                            setStyle(item.getMoons() > 10 ? "-fx-font-weight: bold; -fx-text-fill: #8a3b00;"
+                                    : "-fx-text-fill: black;");
+                        }
+                    }
+                };
+            }
+        });
+        list.setPrefHeight(200);
+
+        VBox box = new VBox(8, new Label("TableView"), table, new Label("ListView, cell factory"), list);
+        VBox.setVgrow(table, Priority.ALWAYS);
+        VBox.setVgrow(list, Priority.ALWAYS);
+        return host(box);
+    }
+
+    /// Scene (j): shape nodes over a `Canvas`, with gradients and
+    /// transforms in both.
+    public static com.codename1.ui.Component shapes() {
+        Pane nodes = new Pane();
+        nodes.setPrefSize(320, 150);
+        Rectangle rect = new Rectangle(10, 10, 90, 60);
+        rect.setArcWidth(18);
+        rect.setArcHeight(18);
+        rect.setFill(new LinearGradient(0, 0, 1, 1, true, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.web("#11998e")), new Stop(1, Color.web("#38ef7d"))));
+        Circle circle = new Circle(155, 40, 30);
+        circle.setFill(new RadialGradient(0, 0, 0.5, 0.5, 0.5, true, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.WHITE), new Stop(1, Color.web("#c06c84"))));
+        circle.setStroke(Color.web("#6c5b7b"));
+        circle.setStrokeWidth(3);
+        Ellipse ellipse = new Ellipse(250, 40, 50, 26);
+        ellipse.setFill(Color.web("#f8b195"));
+        ellipse.setRotate(-20);
+        Polygon triangle = new Polygon(55, 85, 100, 140, 10, 140);
+        triangle.setFill(Color.web("#f67280"));
+        Line dashed = new Line(120, 110, 310, 110);
+        dashed.setStroke(Color.DARKGRAY);
+        dashed.setStrokeWidth(2);
+        dashed.getStrokeDashArray().addAll(Double.valueOf(8), Double.valueOf(6));
+        Rectangle turned = new Rectangle(200, 120, 60, 24);
+        turned.setFill(Color.web("#355c7d"));
+        turned.setRotate(15);
+        nodes.getChildren().addAll(rect, circle, ellipse, triangle, dashed, turned);
+
+        Canvas canvas = new Canvas(320, 150);
+        GraphicsContext g = canvas.getGraphicsContext2D();
+        g.setFill(new LinearGradient(0, 0, 0, 1, true, CycleMethod.NO_CYCLE,
+                new Stop(0, Color.web("#fdfbfb")), new Stop(1, Color.web("#c9d6e6"))));
+        g.fillRect(0, 0, 320, 150);
+        g.setFill(Color.web("#6c5b7b"));
+        g.fillOval(12, 12, 80, 50);
+        g.setStroke(Color.web("#355c7d"));
+        g.setLineWidth(3);
+        g.strokeRoundRect(110, 12, 80, 50, 14, 14);
+        g.save();
+        g.translate(250, 40);
+        g.rotate(30);
+        g.setFill(Color.web("#f67280"));
+        g.fillRect(-30, -18, 60, 36);
+        g.restore();
+        g.setLineWidth(2);
+        g.setLineDashes(8, 6);
+        g.strokeLine(12, 84, 308, 84);
+        g.setLineDashes();
+        g.setFill(Color.web("#355c7d"));
+        g.fillText("Canvas", 12, 120);
+        g.save();
+        g.scale(1.5, 1.5);
+        g.fillRect(100, 66, 30, 14);
+        g.restore();
+
+        VBox box = new VBox(8, new Label("Shapes"), nodes, new Label("Canvas"), canvas);
+        return host(box);
+    }
+
+    /// Scene (k): a screen declared in FXML, with a controller and a
+    /// style sheet whose colours are looked up.
+    public static com.codename1.ui.Component fxml() {
+        Parent root;
+        try {
+            root = FXMLLoader.load(FxScenes.class.getResource("account.fxml"));
+        } catch (java.io.IOException failed) {
+            throw new IllegalStateException("account.fxml did not load: " + failed.getMessage());
+        }
+        Scene scene = new Scene(root);
+        scene.getStylesheets().add(FxScenes.class.getResource("account.css").toExternalForm());
+        return FxInterop.asComponent(scene);
+    }
+
+    private static Label tile(String text, String color) {
+        Label tile = new Label(text);
+        tile.setPrefSize(84, 40);
+        tile.setAlignment(Pos.CENTER);
+        tile.setStyle("-fx-background-color: " + color + "; -fx-text-fill: white; -fx-background-radius: 6;");
+        return tile;
+    }
+
+    /// Scene (l): a `BorderPane` holding a `StackPane` and a `FlowPane`.
+    public static com.codename1.ui.Component panes() {
+        Label title = new Label("BorderPane top");
+        title.setMaxWidth(Double.MAX_VALUE);
+        title.setPadding(new Insets(8));
+        title.setStyle("-fx-background-color: #355c7d; -fx-text-fill: white; -fx-font-weight: bold;");
+
+        Rectangle back = new Rectangle(200, 110, Color.web("#f8b195"));
+        back.setArcWidth(16);
+        back.setArcHeight(16);
+        Circle middle = new Circle(40, Color.web("#c06c84"));
+        Label front = new Label("StackPane");
+        front.setStyle("-fx-text-fill: white; -fx-font-weight: bold;");
+        StackPane stack = new StackPane(back, middle, front);
+        stack.setPadding(new Insets(12));
+
+        FlowPane flow = new FlowPane(8, 8);
+        flow.setPadding(new Insets(8));
+        String[] colors = {"#6c5b7b", "#c06c84", "#f67280", "#355c7d", "#11998e", "#8a3b00", "#2f6fed"};
+        for (int i = 0; i < colors.length; i++) {
+            flow.getChildren().add(tile("Tile " + (i + 1), colors[i]));
+        }
+
+        Label left = new Label("Left");
+        left.setPadding(new Insets(8));
+        left.setStyle("-fx-background-color: #f2f6fa;");
+        left.setMaxHeight(Double.MAX_VALUE);
+        Label status = new Label("BorderPane bottom");
+        status.setPadding(new Insets(6));
+
+        BorderPane border = new BorderPane();
+        border.setTop(title);
+        border.setLeft(left);
+        border.setCenter(new VBox(stack, flow));
+        border.setBottom(status);
+        return host(border);
+    }
+
+    /// Scene (m): asks for a confirmation in an `Alert` and answers the
+    /// name of the button that was chosen. The call blocks, as on a desktop,
+    /// until [#answerConfirm()] or the user answered.
+    public static String confirm() {
+        FxInterop.setNativeWindows(false);
+        try {
+            Alert alert = new Alert(AlertType.CONFIRMATION, "Delete the selected planet?");
+            alert.setHeaderText("Confirm");
+            open = alert;
+            Optional<ButtonType> answer = alert.showAndWait();
+            if (!answer.isPresent()) {
+                return "closed";
+            }
+            return answer.get() == ButtonType.OK ? "ok" : answer.get() == ButtonType.CANCEL ? "cancel" : "other";
+        } finally {
+            open = null;
+            FxInterop.setNativeWindows(true);
+        }
+    }
+
+    /// Whether the dialog of [#confirm()] is up.
+    public static boolean confirmShowing() {
+        return open != null && open.isShowing();
+    }
+
+    /// Presses "OK" in the dialog of [#confirm()]; false if it is not up.
+    public static boolean answerConfirm() {
+        Alert alert = open;
+        if (alert == null || !alert.isShowing()) {
+            return false;
+        }
+        Node ok = alert.getDialogPane().lookupButton(ButtonType.OK);
+        if (!(ok instanceof Button)) {
+            return false;
+        }
+        ((Button) ok).fire();
+        return true;
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/SwingScenes.java b/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/SwingScenes.java
new file mode 100644
index 00000000000..652faf08fb8
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/desktop/java/com/codenameone/examples/hellocodenameone/desktop/SwingScenes.java
@@ -0,0 +1,544 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.desktop;
+
+import com.codename1.desktopcompat.SwingInterop;
+
+import java.awt.BasicStroke;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.GridLayout;
+import java.awt.Insets;
+import java.awt.RenderingHints;
+import java.awt.Window;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.RoundRectangle2D;
+import java.awt.image.BufferedImage;
+import java.util.Calendar;
+
+import javax.swing.AbstractButton;
+import javax.swing.BorderFactory;
+import javax.swing.ButtonGroup;
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.DefaultListModel;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPasswordField;
+import javax.swing.JProgressBar;
+import javax.swing.JRadioButton;
+import javax.swing.JScrollPane;
+import javax.swing.JSlider;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.JTree;
+import javax.swing.SwingConstants;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+
+import org.jdesktop.swingx.JXBusyLabel;
+import org.jdesktop.swingx.JXDatePicker;
+import org.jdesktop.swingx.JXTable;
+import org.jdesktop.swingx.JXTaskPane;
+import org.jdesktop.swingx.JXTaskPaneContainer;
+import org.jdesktop.swingx.decorator.HighlighterFactory;
+
+/// The Swing screens of the desktop compatibility screenshot tests.
+///
+/// This class is ordinary Swing, compiled against the JDK's own classes; the
+/// build relocates it onto the Swing layer. Each scene is built here and
+/// handed to the application as a Codename One component, which is all the
+/// tests in `tests/desktopcompat` ever see of Swing.
+///
+/// Everything a scene shows is fixed: no clock, no animation, no focused
+/// text field.
+public final class SwingScenes {
+
+    private static final String[] NAMES = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn"};
+    private static final int[] MOONS = {0, 0, 1, 2, 95, 146};
+    private static final double[] MASS = {0.055, 0.815, 1.0, 0.107, 317.8, 95.2};
+
+    private SwingScenes() {
+    }
+
+    private static com.codename1.ui.Component host(JComponent content) {
+        JPanel root = new JPanel(new BorderLayout());
+        root.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
+        root.setBackground(Color.WHITE);
+        root.add(content, BorderLayout.CENTER);
+        return SwingInterop.asComponent(root);
+    }
+
+    private static GridBagConstraints at(int x, int y, int width, double weight) {
+        GridBagConstraints c = new GridBagConstraints();
+        c.gridx = x;
+        c.gridy = y;
+        c.gridwidth = width;
+        c.weightx = weight;
+        c.fill = GridBagConstraints.HORIZONTAL;
+        c.anchor = GridBagConstraints.WEST;
+        c.insets = new Insets(4, 4, 4, 4);
+        return c;
+    }
+
+    /// Scene (a): the basic controls in a `GridBagLayout`.
+    public static com.codename1.ui.Component controls() {
+        JPanel form = new JPanel(new GridBagLayout());
+        form.setOpaque(false);
+        int row = 0;
+        form.add(new JLabel("Name:"), at(0, row, 1, 0));
+        form.add(new JTextField("Ada Lovelace", 12), at(1, row++, 2, 1));
+        form.add(new JLabel("Password:"), at(0, row, 1, 0));
+        form.add(new JPasswordField("secret", 12), at(1, row++, 2, 1));
+
+        JCheckBox remember = new JCheckBox("Remember me", true);
+        remember.setOpaque(false);
+        JCheckBox offline = new JCheckBox("Work offline");
+        offline.setOpaque(false);
+        form.add(remember, at(0, row, 2, 0));
+        form.add(offline, at(2, row++, 1, 1));
+
+        JRadioButton small = new JRadioButton("Small");
+        JRadioButton medium = new JRadioButton("Medium", true);
+        JRadioButton large = new JRadioButton("Large");
+        ButtonGroup sizes = new ButtonGroup();
+        JPanel radios = new JPanel(new FlowLayout(FlowLayout.LEFT, 6, 0));
+        radios.setOpaque(false);
+        for (JRadioButton b : new JRadioButton[] {small, medium, large}) {
+            b.setOpaque(false);
+            sizes.add(b);
+            radios.add(b);
+        }
+        form.add(new JLabel("Size:"), at(0, row, 1, 0));
+        form.add(radios, at(1, row++, 2, 1));
+
+        JComboBox<String> planet = new JComboBox<String>(NAMES);
+        planet.setSelectedIndex(2);
+        form.add(new JLabel("Planet:"), at(0, row, 1, 0));
+        form.add(planet, at(1, row++, 2, 1));
+
+        JSlider volume = new JSlider(0, 100, 35);
+        volume.setOpaque(false);
+        form.add(new JLabel("Volume:"), at(0, row, 1, 0));
+        form.add(volume, at(1, row++, 2, 1));
+
+        JProgressBar progress = new JProgressBar(0, 100);
+        progress.setValue(60);
+        progress.setStringPainted(true);
+        form.add(new JLabel("Progress:"), at(0, row, 1, 0));
+        form.add(progress, at(1, row++, 2, 1));
+
+        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT, 6, 0));
+        buttons.setOpaque(false);
+        JButton disabled = new JButton("Disabled");
+        disabled.setEnabled(false);
+        buttons.add(disabled);
+        buttons.add(new JButton("Cancel"));
+        buttons.add(new JButton("OK"));
+        form.add(buttons, at(0, row++, 3, 1));
+
+        GridBagConstraints rest = at(0, row, 3, 1);
+        rest.weighty = 1;
+        JPanel filler = new JPanel();
+        filler.setOpaque(false);
+        form.add(filler, rest);
+        return host(form);
+    }
+
+    /// The planets as a table model: a name, a moon count and a mass.
+    private static final class Planets extends AbstractTableModel {
+        private static final String[] COLUMNS = {"Planet", "Moons", "Mass"};
+
+        @Override
+        public int getRowCount() {
+            return NAMES.length;
+        }
+
+        @Override
+        public int getColumnCount() {
+            return COLUMNS.length;
+        }
+
+        @Override
+        public String getColumnName(int column) {
+            return COLUMNS[column];
+        }
+
+        @Override
+        public Class<?> getColumnClass(int column) {
+            return column == 0 ? String.class : column == 1 ? Integer.class : Double.class;
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            if (column == 0) {
+                return NAMES[row];
+            }
+            if (column == 1) {
+                return Integer.valueOf(MOONS[row]);
+            }
+            return Double.valueOf(MASS[row]);
+        }
+    }
+
+    /// Right aligned, the giants in bold on a tinted cell.
+    private static final class MassRenderer extends DefaultTableCellRenderer {
+        MassRenderer() {
+            setHorizontalAlignment(SwingConstants.RIGHT);
+        }
+
+        @Override
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                boolean hasFocus, int row, int column) {
+            super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+            double mass = value instanceof Number ? ((Number) value).doubleValue() : 0;
+            setText(mass + " M");
+            boolean giant = mass > 10;
+            setFont(getFont().deriveFont(giant ? Font.BOLD : Font.PLAIN));
+            setForeground(giant ? new Color(0x8a3b00) : Color.BLACK);
+            setBackground(giant ? new Color(0xfff1e0) : Color.WHITE);
+            return this;
+        }
+    }
+
+    private static JPanel titled(String title, Component content) {
+        JPanel p = new JPanel(new BorderLayout());
+        p.setOpaque(false);
+        p.setBorder(BorderFactory.createTitledBorder(title));
+        p.add(content, BorderLayout.CENTER);
+        return p;
+    }
+
+    /// Scene (b): a `JTable` with a custom renderer over a striped
+    /// `JXTable`.
+    public static com.codename1.ui.Component tables() {
+        JTable plain = new JTable(new Planets());
+        plain.setRowHeight(22);
+        plain.getColumnModel().getColumn(2).setCellRenderer(new MassRenderer());
+
+        JXTable striped = new JXTable(new Planets());
+        striped.setHighlighters(HighlighterFactory.createSimpleStriping());
+        striped.setRowHeight(22);
+
+        JPanel both = new JPanel(new GridLayout(2, 1, 0, 8));
+        both.setOpaque(false);
+        both.add(titled("JTable, custom renderer", new JScrollPane(plain)));
+        both.add(titled("JXTable, striped", new JScrollPane(striped)));
+        return host(both);
+    }
+
+    /// A planet with its moons, the giants in bold, odd rows tinted.
+    private static final class PlanetRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected,
+                boolean cellHasFocus) {
+            super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            int moons = index >= 0 && index < MOONS.length ? MOONS[index] : 0;
+            setText(value + "  -  " + moons + (moons == 1 ? " moon" : " moons"));
+            setFont(getFont().deriveFont(moons > 10 ? Font.BOLD : Font.PLAIN));
+            if (!isSelected) {
+                setBackground(index % 2 == 1 ? new Color(0xf2f6fa) : Color.WHITE);
+            }
+            return this;
+        }
+    }
+
+    /// Scene (c): an expanded `JTree` over a `JList` with a custom
+    /// renderer.
+    public static com.codename1.ui.Component trees() {
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Solar system");
+        DefaultMutableTreeNode rocky = new DefaultMutableTreeNode("Rocky planets");
+        DefaultMutableTreeNode giants = new DefaultMutableTreeNode("Giants");
+        root.add(rocky);
+        root.add(giants);
+        for (int i = 0; i < NAMES.length; i++) {
+            (MASS[i] < 10 ? rocky : giants).add(new DefaultMutableTreeNode(NAMES[i]));
+        }
+        JTree tree = new JTree(new DefaultTreeModel(root));
+        for (int i = 0; i < tree.getRowCount(); i++) {
+            tree.expandRow(i);
+        }
+
+        DefaultListModel<String> model = new DefaultListModel<String>();
+        for (String name : NAMES) {
+            model.addElement(name);
+        }
+        JList<String> list = new JList<String>(model);
+        list.setCellRenderer(new PlanetRenderer());
+        list.setSelectedIndex(4);
+
+        JPanel both = new JPanel(new GridLayout(2, 1, 0, 8));
+        both.setOpaque(false);
+        both.add(titled("JTree", new JScrollPane(tree)));
+        both.add(titled("JList, custom renderer", new JScrollPane(list)));
+        return host(both);
+    }
+
+    /// Scene (d): everything painted by hand.
+    private static final class Painting extends JComponent {
+        private final BufferedImage checker = checker();
+
+        private static BufferedImage checker() {
+            BufferedImage image = new BufferedImage(64, 64, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D g = image.createGraphics();
+            for (int y = 0; y < 8; y++) {
+                for (int x = 0; x < 8; x++) {
+                    g.setColor((x + y) % 2 == 0 ? new Color(0x355c7d) : new Color(0xf8b195));
+                    g.fillRect(x * 8, y * 8, 8, 8);
+                }
+            }
+            g.dispose();
+            return image;
+        }
+
+        @Override
+        protected void paintComponent(Graphics graphics) {
+            Graphics2D g = (Graphics2D) graphics.create();
+            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            int w = getWidth();
+            int h = getHeight();
+            g.setPaint(new GradientPaint(0, 0, new Color(0xfdfbfb), 0, h, new Color(0xc9d6e6)));
+            g.fillRect(0, 0, w, h);
+
+            g.setColor(new Color(0x6c5b7b));
+            g.fill(new Ellipse2D.Double(16, 16, 90, 60));
+            g.setColor(new Color(0xc06c84));
+            g.fill(new RoundRectangle2D.Double(122, 16, 90, 60, 18, 18));
+            Path2D triangle = new Path2D.Double();
+            triangle.moveTo(273, 16);
+            triangle.lineTo(318, 76);
+            triangle.lineTo(228, 76);
+            triangle.closePath();
+            g.setColor(new Color(0xf67280));
+            g.fill(triangle);
+
+            g.setColor(Color.DARK_GRAY);
+            g.setStroke(new BasicStroke(2f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 10f,
+                    new float[] {8f, 6f}, 0f));
+            g.draw(new Line2D.Double(16, 96, 318, 96));
+            g.setStroke(new BasicStroke(3f));
+            g.draw(new Ellipse2D.Double(16, 16, 90, 60));
+
+            g.setPaint(new GradientPaint(16, 116, new Color(0x11998e), 166, 116, new Color(0x38ef7d)));
+            g.fill(new RoundRectangle2D.Double(16, 116, 150, 44, 12, 12));
+
+            AffineTransform saved = g.getTransform();
+            g.rotate(Math.toRadians(-20), 250, 150);
+            g.setColor(new Color(0x355c7d));
+            g.fillRect(200, 126, 100, 44);
+            g.setColor(Color.WHITE);
+            g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 16));
+            g.drawString("Rotated", 216, 154);
+            g.setTransform(saved);
+
+            g.drawImage(checker, 16, 190, null);
+            g.drawImage(checker, 96, 190, 32, 32, null);
+
+            String text = "Graphics2D";
+            g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 22));
+            FontMetrics metrics = g.getFontMetrics();
+            int baseline = 200 + metrics.getAscent();
+            g.setColor(new Color(0x355c7d));
+            g.drawString(text, 150, baseline);
+            g.setStroke(new BasicStroke(2f));
+            g.drawLine(150, baseline + 3, 150 + metrics.stringWidth(text), baseline + 3);
+            g.dispose();
+        }
+    }
+
+    /// Scene (d): shapes, a gradient, a dashed stroke, rotated text and a
+    /// `BufferedImage`, painted by a component of the application's own.
+    public static com.codename1.ui.Component painting() {
+        Painting p = new Painting();
+        p.setPreferredSize(new Dimension(334, 280));
+        return host(p);
+    }
+
+    /// Scene (e): a `JTabbedPane` whose tab holds a `JSplitPane` of
+    /// panels with titled borders.
+    public static com.codename1.ui.Component containers() {
+        JPanel top = new JPanel(new GridLayout(3, 1, 0, 2));
+        top.setBorder(BorderFactory.createTitledBorder("Account"));
+        top.add(new JLabel("Owner: Ada Lovelace"));
+        top.add(new JLabel("Plan: Analytical"));
+        top.add(new JLabel("Seats: 12"));
+
+        JPanel bottom = new JPanel(new BorderLayout(0, 4));
+        bottom.setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(new Color(0x355c7d), 2),
+                "Notes"));
+        bottom.add(new JLabel("The split pane divides this tab."), BorderLayout.NORTH);
+        bottom.add(new JButton("Add note"), BorderLayout.SOUTH);
+
+        JSplitPane split = new JSplitPane(JSplitPane.VERTICAL_SPLIT, top, bottom);
+        split.setDividerLocation(120);
+        split.setContinuousLayout(false);
+
+        JTabbedPane tabs = new JTabbedPane();
+        tabs.addTab("Overview", split);
+        tabs.addTab("History", new JLabel("Nothing yet", SwingConstants.CENTER));
+        tabs.addTab("Settings", new JLabel("No settings", SwingConstants.CENTER));
+        tabs.setSelectedIndex(0);
+        return host(tabs);
+    }
+
+    /// Scene (g): SwingX task panes, a date picker on a fixed date and a
+    /// busy label that is not busy.
+    public static com.codename1.ui.Component swingx() {
+        JXTaskPaneContainer tasks = new JXTaskPaneContainer();
+        JXTaskPane files = new JXTaskPane();
+        files.setTitle("File tasks");
+        files.add(new JLabel("Rename this file"));
+        files.add(new JLabel("Move this file"));
+        tasks.add(files);
+        JXTaskPane details = new JXTaskPane();
+        details.setTitle("Details");
+        details.add(new JLabel("6 planets"));
+        tasks.add(details);
+        JXTaskPane closed = new JXTaskPane();
+        closed.setTitle("Collapsed");
+        closed.setAnimated(false);
+        closed.setCollapsed(true);
+        closed.add(new JLabel("Not shown"));
+        tasks.add(closed);
+
+        // Noon, so the day is the same in every time zone.
+        Calendar day = Calendar.getInstance();
+        day.set(Calendar.YEAR, 2024);
+        day.set(Calendar.MONTH, Calendar.MARCH);
+        day.set(Calendar.DAY_OF_MONTH, 15);
+        day.set(Calendar.HOUR_OF_DAY, 12);
+        day.set(Calendar.MINUTE, 0);
+        day.set(Calendar.SECOND, 0);
+        day.set(Calendar.MILLISECOND, 0);
+        JXDatePicker picker = new JXDatePicker(day.getTime());
+        picker.setFormats("yyyy-MM-dd");
+
+        JXBusyLabel busy = new JXBusyLabel();
+        busy.setText("Idle");
+        busy.setBusy(false);
+
+        JPanel south = new JPanel(new FlowLayout(FlowLayout.LEFT, 8, 4));
+        south.setOpaque(false);
+        south.add(new JLabel("Due:"));
+        south.add(picker);
+        south.add(busy);
+
+        JPanel all = new JPanel(new BorderLayout(0, 8));
+        all.setOpaque(false);
+        all.add(tasks, BorderLayout.CENTER);
+        all.add(south, BorderLayout.SOUTH);
+        return host(all);
+    }
+
+    /// Scene (f): asks a yes/no question in a modal `JOptionPane` and
+    /// answers what was chosen, as [#answerName(int)] names it. The call
+    /// blocks, as on a desktop, until [#answerConfirm()] or the user
+    /// answered.
+    public static int confirm() {
+        SwingInterop.setNativeWindows(false);
+        try {
+            return JOptionPane.showConfirmDialog(null, "Delete the selected planet?", "Confirm",
+                    JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
+        } finally {
+            SwingInterop.setNativeWindows(true);
+        }
+    }
+
+    /// The name of an answer of [#confirm()].
+    public static String answerName(int answer) {
+        if (answer == JOptionPane.YES_OPTION) {
+            return "yes";
+        }
+        if (answer == JOptionPane.NO_OPTION) {
+            return "no";
+        }
+        return "closed(" + answer + ")";
+    }
+
+    private static AbstractButton button(Container in, String text) {
+        for (int i = 0; i < in.getComponentCount(); i++) {
+            Component c = in.getComponent(i);
+            if (c instanceof AbstractButton && text.equals(((AbstractButton) c).getText())) {
+                return (AbstractButton) c;
+            }
+            if (c instanceof Container) {
+                AbstractButton found = button((Container) c, text);
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static AbstractButton yesButton() {
+        Window[] windows = Window.getWindows();
+        for (int i = windows.length - 1; i >= 0; i--) {
+            if (windows[i].isShowing()) {
+                AbstractButton yes = button(windows[i], "Yes");
+                if (yes != null) {
+                    return yes;
+                }
+            }
+        }
+        return null;
+    }
+
+    /// Whether the dialog of [#confirm()] is up.
+    public static boolean confirmShowing() {
+        return yesButton() != null;
+    }
+
+    /// Presses "Yes" in the dialog of [#confirm()]; false if it is not up.
+    public static boolean answerConfirm() {
+        AbstractButton yes = yesButton();
+        if (yes == null) {
+            return false;
+        }
+        yes.doClick();
+        return true;
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/desktop/resources/com/codenameone/examples/hellocodenameone/desktop/account.css b/scripts/hellocodenameone/common/src/main/desktop/resources/com/codenameone/examples/hellocodenameone/desktop/account.css
new file mode 100644
index 00000000000..98b2b7bf45e
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/desktop/resources/com/codenameone/examples/hellocodenameone/desktop/account.css
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/* The colours every rule below looks up by name. */
+.root {
+    -app-accent: #2f6fed;
+    -app-surface: #f2f6fa;
+    -app-ink: #1d2733;
+}
+
+.screen {
+    -fx-background-color: -app-surface;
+}
+
+.heading {
+    -fx-text-fill: -app-accent;
+    -fx-font-size: 22;
+    -fx-font-weight: bold;
+}
+
+.card {
+    -fx-background-color: white;
+    -fx-border-color: -app-accent;
+    -fx-border-width: 2;
+    -fx-border-radius: 8;
+    -fx-background-radius: 8;
+}
+
+.card .label {
+    -fx-text-fill: -app-ink;
+}
+
+#status {
+    -fx-text-fill: -app-accent;
+    -fx-font-weight: bold;
+}
+
+.value {
+    -fx-font-style: italic;
+}
+
+.primary {
+    -fx-background-color: -app-accent;
+    -fx-text-fill: white;
+    -fx-background-radius: 6;
+}
+
+.note {
+    -fx-text-fill: derive(-app-ink, 40%);
+    -fx-font-size: 12;
+}
diff --git a/scripts/hellocodenameone/common/src/main/desktop/resources/com/codenameone/examples/hellocodenameone/desktop/account.fxml b/scripts/hellocodenameone/common/src/main/desktop/resources/com/codenameone/examples/hellocodenameone/desktop/account.fxml
new file mode 100644
index 00000000000..9e101e88d27
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/desktop/resources/com/codenameone/examples/hellocodenameone/desktop/account.fxml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.VBox?>
+
+<VBox xmlns:fx="http://javafx.com/fxml/1" spacing="12" styleClass="screen"
+      fx:controller="com.codenameone.examples.hellocodenameone.desktop.AccountController">
+    <padding>
+        <Insets top="12" right="12" bottom="12" left="12"/>
+    </padding>
+    <Label text="Account" styleClass="heading"/>
+    <VBox spacing="10" styleClass="card">
+        <padding>
+            <Insets top="12" right="12" bottom="12" left="12"/>
+        </padding>
+        <Label fx:id="status" text="Set in the document"/>
+        <GridPane hgap="8" vgap="8">
+            <Label text="Owner:" GridPane.columnIndex="0" GridPane.rowIndex="0"/>
+            <TextField fx:id="owner" promptText="Name" GridPane.columnIndex="1" GridPane.rowIndex="0"/>
+            <Label text="Plan:" GridPane.columnIndex="0" GridPane.rowIndex="1"/>
+            <Label text="Analytical" styleClass="value" GridPane.columnIndex="1" GridPane.rowIndex="1"/>
+        </GridPane>
+        <CheckBox text="Send a receipt" selected="true"/>
+        <HBox spacing="8">
+            <Button fx:id="save" text="Save" styleClass="primary" onAction="#save"/>
+            <Button text="Cancel"/>
+        </HBox>
+    </VBox>
+    <Label text="Styled by account.css" styleClass="note"/>
+</VBox>
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java
index 83898996bf1..fcf5f0c237f 100644
--- a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/Cn1ssDeviceRunner.java
@@ -45,6 +45,19 @@
 import com.codenameone.examples.hellocodenameone.tests.androidcompat.AndroidCompatRecyclerScreenshotTest;
 import com.codenameone.examples.hellocodenameone.tests.androidcompat.AndroidCompatMaterialScreenshotTest;
 import com.codenameone.examples.hellocodenameone.tests.androidcompat.AndroidCompatKotlinScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingControlsScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingTablesScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingTreesScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingPaintingScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingContainersScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingOptionPaneScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatSwingXScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatFxControlsScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatFxDataScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatFxShapesScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatFxFxmlScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatFxPanesScreenshotTest;
+import com.codenameone.examples.hellocodenameone.tests.desktopcompat.DesktopCompatFxAlertScreenshotTest;
 import com.codename1.testing.TestReporting;
 import com.codename1.ui.CN;
 import com.codename1.ui.Display;
@@ -617,7 +630,6 @@ private static int testTimeoutMs(BaseTest testClass) {
             new VPNDetectionAPITest(),
             new CallDetectionAPITest(),
             new DeviceInputApiTest(),
-            new LocalNotificationOverrideTest(),
             new Base64NativePerformanceTest(),
             new AccessibilityTest(),
             new FileSystemStorageOpenInputStreamMissingTest(),
@@ -645,6 +657,31 @@ private static int testTimeoutMs(BaseTest testClass) {
             new AndroidCompatRecyclerScreenshotTest(),
             new AndroidCompatMaterialScreenshotTest(),
             new AndroidCompatKotlinScreenshotTest(),
+            // The desktop compatibility layers: Swing, SwingX and JavaFX screens that this
+            // app compiles from common/src/main/desktop in library mode (no entry point of
+            // their own) and embeds in forms of its own, plus one modal dialog of each
+            // toolkit captured while open and answered from code. After the Android
+            // screens for the same reason those come late -- a runtime installed here
+            // cannot shift an existing baseline -- and before DesktopMode, which must stay
+            // the last ordinary capture.
+            new DesktopCompatSwingControlsScreenshotTest(),
+            new DesktopCompatSwingTablesScreenshotTest(),
+            new DesktopCompatSwingTreesScreenshotTest(),
+            new DesktopCompatSwingPaintingScreenshotTest(),
+            new DesktopCompatSwingContainersScreenshotTest(),
+            new DesktopCompatSwingOptionPaneScreenshotTest(),
+            new DesktopCompatSwingXScreenshotTest(),
+            new DesktopCompatFxControlsScreenshotTest(),
+            new DesktopCompatFxDataScreenshotTest(),
+            new DesktopCompatFxShapesScreenshotTest(),
+            new DesktopCompatFxFxmlScreenshotTest(),
+            new DesktopCompatFxPanesScreenshotTest(),
+            new DesktopCompatFxAlertScreenshotTest(),
+            // After every test that shows a dialog. It asks for the notification
+            // permission, and on iOS the system alert nobody answers leaves the
+            // application inactive for the rest of the run: Display.isMinimized()
+            // is then true and Dialog refuses to show anything at all.
+            new LocalNotificationOverrideTest(),
             // Desktop integration demo. Placed LAST on purpose: it shows a Toolbar with text
             // and a populated list, which warms the font cache / shifts suite timing, and the
             // earlier graphics screenshot tests (DrawString, DrawStringDecorated, inscribed
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/StringFormatTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/StringFormatTest.java
index 7cdd76e3003..17e47b19122 100644
--- a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/StringFormatTest.java
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/StringFormatTest.java
@@ -292,7 +292,7 @@ private void check(String label, String expected, String actual) {
      * IllegalFormatPrecisionException on Android and UnknownFormatConversionException on
      * OpenJDK, for instance. Neither is Codename One's to change. The exact subtype
      * ParparVM raises is pinned against the JDK in
-     * vm/tests StringFormatIntegrationTest, which covers every port that runs Codename
+     * vm/tests BulkConformanceIntegrationTest (StringFormatChecks), which covers every port that runs Codename
      * One's own formatter; {@code javaSeType} is carried here only to make a failure
      * message say what Java SE does.</p>
      */
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatDialogScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatDialogScreenshotTest.java
new file mode 100644
index 00000000000..7157bb6469d
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatDialogScreenshotTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.CN;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.Label;
+import com.codename1.ui.layouts.BorderLayout;
+import com.codenameone.examples.hellocodenameone.tests.BaseTest;
+
+/// A modal dialog of a desktop compatibility layer, captured WHILE IT IS
+/// OPEN over a form of this app, then answered from code.
+///
+/// The question is asked the way desktop code asks it: one call that
+/// returns the answer, and blocks until there is one. The test therefore
+/// runs in two strands on the event dispatch thread. The asking strand sits
+/// inside the blocking call; a timer, which the dialog's nested event loop
+/// keeps serving, waits for the dialog to be on screen, captures it and
+/// presses its default button. The asking strand then returns, and the test
+/// passes only if what it returned is the button that was pressed.
+///
+/// The dialog is kept inside the app's own window on every port: on a
+/// desktop port it would otherwise be a window of the window manager, which
+/// a capture of the form does not contain.
+public abstract class DesktopCompatDialogScreenshotTest extends BaseTest {
+
+    /// How long the dialog may take to appear. Well under the runner's
+    /// shortest per-test timeout, so a dialog that never shows is reported
+    /// as that rather than as an anonymous timeout.
+    private static final int APPEAR_BUDGET_MS = 6000;
+    private static final int POLL_MS = 100;
+
+    private final String title;
+    private final String imageName;
+    private String failure;
+
+    protected DesktopCompatDialogScreenshotTest(String title, String imageName) {
+        this.title = title;
+        this.imageName = imageName;
+    }
+
+    /// Asks the question and answers the name of what was chosen. Blocks.
+    protected abstract String ask();
+
+    /// Whether the dialog of [#ask()] is showing.
+    protected abstract boolean showing();
+
+    /// Presses the dialog's affirmative button; false if it is not there.
+    protected abstract boolean answer();
+
+    /// What [#ask()] returns when [#answer()] pressed the button.
+    protected abstract String expected();
+
+    /// The asking strand outlives runTest(): a rerun on this instance could be
+    /// completed by the first attempt's answer.
+    @Override
+    public boolean isRetrySafe() {
+        return false;
+    }
+
+    @Override
+    public boolean runTest() throws Exception {
+        Display.getInstance().setDarkMode(Boolean.FALSE);
+        failure = null;
+        final Form host = new Form(title, new BorderLayout());
+        host.add(BorderLayout.CENTER, new Label("The application's own form"));
+        host.show();
+        CN.callSerially(new Runnable() {
+            @Override
+            public void run() {
+                watch(host, 0);
+                String got;
+                try {
+                    got = ask();
+                } catch (RuntimeException thrown) {
+                    got = null;
+                    failure = "the dialog threw " + thrown;
+                }
+                Display.getInstance().setDarkMode(null);
+                if (failure == null && !expected().equals(got)) {
+                    failure = "the blocking call returned " + got + ", expected " + expected();
+                }
+                if (failure != null) {
+                    fail(imageName + ": " + failure);
+                } else {
+                    done();
+                }
+            }
+        });
+        return true;
+    }
+
+    /// Waits for the dialog to be the current form, then captures it. A plain
+    /// timer of the display, not a UITimer: those belong to a form, and the
+    /// host's stop running the moment the dialog covers it.
+    private void watch(final Form host, final int waitedMs) {
+        CN.setTimeout(POLL_MS, new Runnable() {
+            @Override
+            public void run() {
+                final Form current = Display.getInstance().getCurrent();
+                if (showing() && current != null && current != host) {
+                    // The same settle the other screens get before a capture.
+                    CN.setTimeout(1500, new Runnable() {
+                        @Override
+                        public void run() {
+                            capture(current);
+                        }
+                    });
+                    return;
+                }
+                if (waitedMs >= APPEAR_BUDGET_MS) {
+                    failure = "the dialog was not on screen after " + waitedMs + "ms (showing=" + showing()
+                            + ", minimized=" + Display.getInstance().isMinimized() + ")";
+                    // Let the asking strand go, or it blocks the suite.
+                    answer();
+                    return;
+                }
+                watch(host, waitedMs + POLL_MS);
+            }
+        });
+    }
+
+    private void capture(Form dialog) {
+        captureWhenSettled(dialog, imageName, new Runnable() {
+            @Override
+            public void run() {
+                if (!answer()) {
+                    failure = "the dialog had no button to press";
+                }
+            }
+        });
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxAlertScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxAlertScreenshotTest.java
new file mode 100644
index 00000000000..ef252396692
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxAlertScreenshotTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codenameone.examples.hellocodenameone.desktop.FxScenes;
+
+/// A JavaFX confirmation `Alert`, captured while it is open and then answered OK: `showAndWait` must
+/// return `ButtonType.OK`.
+public class DesktopCompatFxAlertScreenshotTest extends DesktopCompatDialogScreenshotTest {
+    public DesktopCompatFxAlertScreenshotTest() {
+        super("JavaFX alert", "DesktopCompatFxAlert");
+    }
+
+    @Override
+    protected String ask() {
+        return FxScenes.confirm();
+    }
+
+    @Override
+    protected boolean showing() {
+        return FxScenes.confirmShowing();
+    }
+
+    @Override
+    protected boolean answer() {
+        return FxScenes.answerConfirm();
+    }
+
+    @Override
+    protected String expected() {
+        return "ok";
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxControlsScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxControlsScreenshotTest.java
new file mode 100644
index 00000000000..9f5102b0087
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxControlsScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.FxScenes;
+
+/// JavaFX's basic controls in a `GridPane` inside a `VBox`.
+public class DesktopCompatFxControlsScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatFxControlsScreenshotTest() {
+        super("JavaFX controls", "DesktopCompatFxControls");
+    }
+
+    @Override
+    protected Component scene() {
+        return FxScenes.controls();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxDataScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxDataScreenshotTest.java
new file mode 100644
index 00000000000..11e263336ed
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxDataScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.FxScenes;
+
+/// A `TableView` above a `ListView` with a cell factory.
+public class DesktopCompatFxDataScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatFxDataScreenshotTest() {
+        super("JavaFX table and list", "DesktopCompatFxData");
+    }
+
+    @Override
+    protected Component scene() {
+        return FxScenes.data();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxFxmlScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxFxmlScreenshotTest.java
new file mode 100644
index 00000000000..e9b3a395be6
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxFxmlScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.FxScenes;
+
+/// A screen declared in FXML, with a controller and a style sheet whose colours are looked up.
+public class DesktopCompatFxFxmlScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatFxFxmlScreenshotTest() {
+        super("JavaFX FXML", "DesktopCompatFxFxml");
+    }
+
+    @Override
+    protected Component scene() {
+        return FxScenes.fxml();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxPanesScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxPanesScreenshotTest.java
new file mode 100644
index 00000000000..828ea28b9f1
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxPanesScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.FxScenes;
+
+/// A `BorderPane` holding a `StackPane` and a `FlowPane`.
+public class DesktopCompatFxPanesScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatFxPanesScreenshotTest() {
+        super("JavaFX panes", "DesktopCompatFxPanes");
+    }
+
+    @Override
+    protected Component scene() {
+        return FxScenes.panes();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxShapesScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxShapesScreenshotTest.java
new file mode 100644
index 00000000000..d138b4256a6
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatFxShapesScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.FxScenes;
+
+/// Shape nodes above a `Canvas`, with gradients and transforms in both.
+public class DesktopCompatFxShapesScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatFxShapesScreenshotTest() {
+        super("JavaFX shapes", "DesktopCompatFxShapes");
+    }
+
+    @Override
+    protected Component scene() {
+        return FxScenes.shapes();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatScreenshotTest.java
new file mode 100644
index 00000000000..20e3fe45d8c
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatScreenshotTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codename1.ui.Display;
+import com.codename1.ui.Form;
+import com.codename1.ui.layouts.BorderLayout;
+import com.codename1.ui.util.UITimer;
+import com.codenameone.examples.hellocodenameone.tests.BaseTest;
+
+/// One screen of the desktop compatibility layers: Swing, SwingX or JavaFX
+/// code that this app compiles from `common/src/main/desktop` and embeds in a
+/// form of its own.
+///
+/// The app has its own main class and the desktop sources name no entry point,
+/// so they are built in library mode: relocated like any library, with nothing
+/// started on their behalf. A scene is built by `SwingScenes` or `FxScenes`,
+/// which hand it over as a Codename One component, and the test shows that
+/// component in a plain form and captures the form once it has settled.
+public abstract class DesktopCompatScreenshotTest extends BaseTest {
+
+    private final String title;
+    private final String imageName;
+
+    protected DesktopCompatScreenshotTest(String title, String imageName) {
+        this.title = title;
+        this.imageName = imageName;
+    }
+
+    /// Builds the scene, as the Codename One component that shows it.
+    protected abstract Component scene();
+
+    @Override
+    public boolean runTest() throws Exception {
+        // Pin the light appearance, as the Android compatibility screens do:
+        // the baseline must not depend on the host's appearance setting.
+        Display.getInstance().setDarkMode(Boolean.FALSE);
+        final Form form = new Form(title, new BorderLayout());
+        form.add(BorderLayout.CENTER, scene());
+        form.show();
+        // A focused text field has a caret, which blinks.
+        form.setFocused(null);
+        UITimer.timer(1500, false, form, new Runnable() {
+            @Override
+            public void run() {
+                captureWhenSettled(form, imageName, new Runnable() {
+                    @Override
+                    public void run() {
+                        Display.getInstance().setDarkMode(null);
+                        done();
+                    }
+                });
+            }
+        });
+        return true;
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingContainersScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingContainersScreenshotTest.java
new file mode 100644
index 00000000000..ffc8539e92f
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingContainersScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// A `JTabbedPane` holding a `JSplitPane` of panels with titled borders.
+public class DesktopCompatSwingContainersScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatSwingContainersScreenshotTest() {
+        super("Swing containers", "DesktopCompatSwingContainers");
+    }
+
+    @Override
+    protected Component scene() {
+        return SwingScenes.containers();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingControlsScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingControlsScreenshotTest.java
new file mode 100644
index 00000000000..6ba2881a830
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingControlsScreenshotTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// Swing's basic controls in a `GridBagLayout`: labels, a text field, a password field, check boxes, radio
+/// buttons, a combo box, a slider, a progress bar and buttons.
+public class DesktopCompatSwingControlsScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatSwingControlsScreenshotTest() {
+        super("Swing controls", "DesktopCompatSwingControls");
+    }
+
+    @Override
+    protected Component scene() {
+        return SwingScenes.controls();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingOptionPaneScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingOptionPaneScreenshotTest.java
new file mode 100644
index 00000000000..daeb6f3d44f
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingOptionPaneScreenshotTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// A modal `JOptionPane` confirmation, captured while it is open and then answered Yes:
+/// `showConfirmDialog` must return `YES_OPTION`.
+public class DesktopCompatSwingOptionPaneScreenshotTest extends DesktopCompatDialogScreenshotTest {
+    public DesktopCompatSwingOptionPaneScreenshotTest() {
+        super("Swing option pane", "DesktopCompatSwingOptionPane");
+    }
+
+    @Override
+    protected String ask() {
+        return SwingScenes.answerName(SwingScenes.confirm());
+    }
+
+    @Override
+    protected boolean showing() {
+        return SwingScenes.confirmShowing();
+    }
+
+    @Override
+    protected boolean answer() {
+        return SwingScenes.answerConfirm();
+    }
+
+    @Override
+    protected String expected() {
+        return "yes";
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingPaintingScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingPaintingScreenshotTest.java
new file mode 100644
index 00000000000..66fb4298cac
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingPaintingScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// A component that paints itself: shapes, gradients, a dashed stroke, rotated text and a `BufferedImage`.
+public class DesktopCompatSwingPaintingScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatSwingPaintingScreenshotTest() {
+        super("Swing painting", "DesktopCompatSwingPainting");
+    }
+
+    @Override
+    protected Component scene() {
+        return SwingScenes.painting();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingTablesScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingTablesScreenshotTest.java
new file mode 100644
index 00000000000..a06789f105a
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingTablesScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// A `JTable` with a custom cell renderer above a striped `JXTable`.
+public class DesktopCompatSwingTablesScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatSwingTablesScreenshotTest() {
+        super("Swing tables", "DesktopCompatSwingTables");
+    }
+
+    @Override
+    protected Component scene() {
+        return SwingScenes.tables();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingTreesScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingTreesScreenshotTest.java
new file mode 100644
index 00000000000..e64471e2c95
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingTreesScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// A fully expanded `JTree` above a `JList` with a custom cell renderer.
+public class DesktopCompatSwingTreesScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatSwingTreesScreenshotTest() {
+        super("Swing tree and list", "DesktopCompatSwingTrees");
+    }
+
+    @Override
+    protected Component scene() {
+        return SwingScenes.trees();
+    }
+}
diff --git a/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingXScreenshotTest.java b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingXScreenshotTest.java
new file mode 100644
index 00000000000..0ca90522599
--- /dev/null
+++ b/scripts/hellocodenameone/common/src/main/java/com/codenameone/examples/hellocodenameone/tests/desktopcompat/DesktopCompatSwingXScreenshotTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codenameone.examples.hellocodenameone.tests.desktopcompat;
+
+import com.codename1.ui.Component;
+import com.codenameone.examples.hellocodenameone.desktop.SwingScenes;
+
+/// SwingX task panes, a date picker on a fixed date and a busy label that is not busy.
+public class DesktopCompatSwingXScreenshotTest extends DesktopCompatScreenshotTest {
+    public DesktopCompatSwingXScreenshotTest() {
+        super("SwingX", "DesktopCompatSwingX");
+    }
+
+    @Override
+    protected Component scene() {
+        return SwingScenes.swingx();
+    }
+}
diff --git a/scripts/hellocodenameone/pom.xml b/scripts/hellocodenameone/pom.xml
index 5b19f620275..3ea4ba507b5 100644
--- a/scripts/hellocodenameone/pom.xml
+++ b/scripts/hellocodenameone/pom.xml
@@ -56,6 +56,20 @@
         <version>${cn1.version}</version>
         <scope>provided</scope>
       </dependency>
+      <!-- The desktop compatibility layers, which common/src/main/desktop is
+           compiled against; the build ships the one its classes use, relocated. -->
+      <dependency>
+        <groupId>com.codenameone</groupId>
+        <artifactId>codenameone-swing-compat</artifactId>
+        <version>${cn1.version}</version>
+        <scope>provided</scope>
+      </dependency>
+      <dependency>
+        <groupId>com.codenameone</groupId>
+        <artifactId>codenameone-javafx-compat</artifactId>
+        <version>${cn1.version}</version>
+        <scope>provided</scope>
+      </dependency>
       <dependency>
         <groupId>com.codenameone</groupId>
         <artifactId>codenameone-buildclient</artifactId>
diff --git a/scripts/initializr/common/src/main/resources/skill/references/swing-comparison.md b/scripts/initializr/common/src/main/resources/skill/references/swing-comparison.md
index 54b650ecd21..936eaf729f0 100644
--- a/scripts/initializr/common/src/main/resources/skill/references/swing-comparison.md
+++ b/scripts/initializr/common/src/main/resources/skill/references/swing-comparison.md
@@ -2,6 +2,8 @@
 
 Codename One's UI model is consciously modeled on Swing. If you know `javax.swing`, ~80% of your reflexes will carry over. The differences are mostly *what to import* and *which methods are async*.
 
+This page is for writing new code against the Codename One API. An existing Swing application doesn't have to be rewritten first: its sources can be built as they are through the Swing compatibility layer, by placing them under `common/src/main/desktop` or importing the project with `mvn cn1:import-desktop-project -Dcn1.desktop.import=<path>`. The layer covers a subset of Swing, AWT and SwingX, and the build reports any API it lacks. See "Running Swing and JavaFX applications" in the developer guide.
+
 ## Mental model: identical concepts, different package
 
 | Swing concept | Codename One equivalent | Note |
@@ -19,8 +21,8 @@ Codename One's UI model is consciously modeled on Swing. If you know `javax.swin
 | `JTabbedPane` | `Tabs` | |
 | `JDialog` / `JOptionPane` | `Dialog` / `Dialog.show(...)` | |
 | `JMenuBar` / `JMenu` / `JMenuItem` | `Toolbar` (always present on every Form) | |
-| `JTable` | No direct equivalent | Use `Container` with `TableLayout`, or a `MultiList`. |
-| `JTree` | No direct equivalent | Build with nested `Accordion`s or custom rendering. |
+| `JTable` + `TableModel` | `Table` + `TableModel` | `com.codename1.ui.table.Table`, driven by a `com.codename1.ui.table.TableModel` (`DefaultTableModel` for simple data). |
+| `JTree` + `TreeModel` | `Tree` + `TreeModel` | `com.codename1.ui.tree.Tree`, driven by a `com.codename1.ui.tree.TreeModel`. |
 | `JScrollPane` | `Container.setScrollableY(true)` | Built into every container — no wrapper needed. |
 | `JSlider` | `Slider` | |
 | `JSpinner` | `Picker` (numeric/date variants) | |
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatFxAlert.png b/scripts/ios/screenshots-metal-27/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..6c7617edf16
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatFxAlert.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatFxControls.png b/scripts/ios/screenshots-metal-27/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..1dc7108071d
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatFxControls.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatFxData.png b/scripts/ios/screenshots-metal-27/DesktopCompatFxData.png
new file mode 100644
index 00000000000..cc4de0fb5e5
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatFxData.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatFxFxml.png b/scripts/ios/screenshots-metal-27/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..56e8d004f0e
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatFxFxml.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatFxPanes.png b/scripts/ios/screenshots-metal-27/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..3412c5473f6
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatFxPanes.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatFxShapes.png b/scripts/ios/screenshots-metal-27/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..2662526bc5a
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatFxShapes.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingContainers.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..5db68016541
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingContainers.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingControls.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..715f9ab50fc
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingControls.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingOptionPane.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..ffc45c5bb46
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingPainting.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..63a5bcf1604
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingPainting.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingTables.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..0eff8aaba70
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingTables.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingTrees.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..a661a98e8ff
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingTrees.png differ
diff --git a/scripts/ios/screenshots-metal-27/DesktopCompatSwingX.png b/scripts/ios/screenshots-metal-27/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..536ccce3a1e
Binary files /dev/null and b/scripts/ios/screenshots-metal-27/DesktopCompatSwingX.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatFxAlert.png b/scripts/ios/screenshots-metal/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..faf15d4e958
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatFxAlert.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatFxControls.png b/scripts/ios/screenshots-metal/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..df2b20b4a1d
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatFxControls.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatFxData.png b/scripts/ios/screenshots-metal/DesktopCompatFxData.png
new file mode 100644
index 00000000000..2e3e9466833
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatFxData.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatFxFxml.png b/scripts/ios/screenshots-metal/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..ed5b25bf738
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatFxFxml.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatFxPanes.png b/scripts/ios/screenshots-metal/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..ba9efacf0b5
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatFxPanes.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatFxShapes.png b/scripts/ios/screenshots-metal/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..4ed48a0d071
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatFxShapes.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingContainers.png b/scripts/ios/screenshots-metal/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..893e27f7fb4
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingContainers.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingControls.png b/scripts/ios/screenshots-metal/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..b17b9d94bf5
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingControls.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingOptionPane.png b/scripts/ios/screenshots-metal/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..a6b38d5cf98
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingPainting.png b/scripts/ios/screenshots-metal/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..cb99bafe3bb
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingPainting.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingTables.png b/scripts/ios/screenshots-metal/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..f1bc125e38d
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingTables.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingTrees.png b/scripts/ios/screenshots-metal/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..e6cafa3ade8
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingTrees.png differ
diff --git a/scripts/ios/screenshots-metal/DesktopCompatSwingX.png b/scripts/ios/screenshots-metal/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..bee39c80176
Binary files /dev/null and b/scripts/ios/screenshots-metal/DesktopCompatSwingX.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatFxAlert.png b/scripts/ios/screenshots-tv/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..31877978a00
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatFxAlert.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatFxControls.png b/scripts/ios/screenshots-tv/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..59170269d50
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatFxControls.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatFxData.png b/scripts/ios/screenshots-tv/DesktopCompatFxData.png
new file mode 100644
index 00000000000..696b50d7376
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatFxData.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatFxFxml.png b/scripts/ios/screenshots-tv/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..e6dfc7b21c1
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatFxFxml.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatFxPanes.png b/scripts/ios/screenshots-tv/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..551792903b6
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatFxPanes.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatFxShapes.png b/scripts/ios/screenshots-tv/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..7c3d025c5bd
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatFxShapes.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingContainers.png b/scripts/ios/screenshots-tv/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..cb7b80d3c1b
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingContainers.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingControls.png b/scripts/ios/screenshots-tv/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..f0ac6160636
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingControls.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingOptionPane.png b/scripts/ios/screenshots-tv/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..acba3edc5d7
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingPainting.png b/scripts/ios/screenshots-tv/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..4a8720b4c4d
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingPainting.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingTables.png b/scripts/ios/screenshots-tv/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..77e5b375343
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingTables.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingTrees.png b/scripts/ios/screenshots-tv/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..d7bd04f4104
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingTrees.png differ
diff --git a/scripts/ios/screenshots-tv/DesktopCompatSwingX.png b/scripts/ios/screenshots-tv/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..16296aa6163
Binary files /dev/null and b/scripts/ios/screenshots-tv/DesktopCompatSwingX.png differ
diff --git a/scripts/ios/screenshots-watch/ButtonTheme_dark.png b/scripts/ios/screenshots-watch/ButtonTheme_dark.png
index b9ef60ede17..b42808a4293 100644
Binary files a/scripts/ios/screenshots-watch/ButtonTheme_dark.png and b/scripts/ios/screenshots-watch/ButtonTheme_dark.png differ
diff --git a/scripts/ios/screenshots-watch/ButtonTheme_light.png b/scripts/ios/screenshots-watch/ButtonTheme_light.png
index 146c1b4055d..1828d32202d 100644
Binary files a/scripts/ios/screenshots-watch/ButtonTheme_light.png and b/scripts/ios/screenshots-watch/ButtonTheme_light.png differ
diff --git a/scripts/ios/screenshots-watch/ChatInput_dark.png b/scripts/ios/screenshots-watch/ChatInput_dark.png
index 3d640ac84da..a8acd31bb53 100644
Binary files a/scripts/ios/screenshots-watch/ChatInput_dark.png and b/scripts/ios/screenshots-watch/ChatInput_dark.png differ
diff --git a/scripts/ios/screenshots-watch/ChatInput_light.png b/scripts/ios/screenshots-watch/ChatInput_light.png
index 760996f679f..58c2699e53e 100644
Binary files a/scripts/ios/screenshots-watch/ChatInput_light.png and b/scripts/ios/screenshots-watch/ChatInput_light.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatFxAlert.png b/scripts/ios/screenshots-watch/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..ee34cf8a911
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatFxAlert.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatFxControls.png b/scripts/ios/screenshots-watch/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..8e365ad59ec
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatFxControls.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatFxData.png b/scripts/ios/screenshots-watch/DesktopCompatFxData.png
new file mode 100644
index 00000000000..ff2d0a21d61
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatFxData.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatFxFxml.png b/scripts/ios/screenshots-watch/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..447b0505a68
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatFxFxml.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatFxPanes.png b/scripts/ios/screenshots-watch/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..6d014ae9b98
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatFxPanes.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatFxShapes.png b/scripts/ios/screenshots-watch/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..faf29d051a6
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatFxShapes.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingContainers.png b/scripts/ios/screenshots-watch/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..6c950ef103d
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingContainers.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingControls.png b/scripts/ios/screenshots-watch/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..1de457d4b65
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingControls.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingOptionPane.png b/scripts/ios/screenshots-watch/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..f0b448a32a0
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingPainting.png b/scripts/ios/screenshots-watch/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..cabc18a8921
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingPainting.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingTables.png b/scripts/ios/screenshots-watch/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..c602124fce8
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingTables.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingTrees.png b/scripts/ios/screenshots-watch/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..b7f9afc28e5
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingTrees.png differ
diff --git a/scripts/ios/screenshots-watch/DesktopCompatSwingX.png b/scripts/ios/screenshots-watch/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..a1b5ec50613
Binary files /dev/null and b/scripts/ios/screenshots-watch/DesktopCompatSwingX.png differ
diff --git a/scripts/ios/screenshots-watch/PaletteOverrideTheme_dark.png b/scripts/ios/screenshots-watch/PaletteOverrideTheme_dark.png
index b774ea80b94..83b980ddb19 100644
Binary files a/scripts/ios/screenshots-watch/PaletteOverrideTheme_dark.png and b/scripts/ios/screenshots-watch/PaletteOverrideTheme_dark.png differ
diff --git a/scripts/ios/screenshots-watch/PaletteOverrideTheme_light.png b/scripts/ios/screenshots-watch/PaletteOverrideTheme_light.png
index c3093fba905..4bcf3be6d24 100644
Binary files a/scripts/ios/screenshots-watch/PaletteOverrideTheme_light.png and b/scripts/ios/screenshots-watch/PaletteOverrideTheme_light.png differ
diff --git a/scripts/ios/screenshots-watch/ShowcaseTheme_dark.png b/scripts/ios/screenshots-watch/ShowcaseTheme_dark.png
index 6cdbf91df01..b385cfd3e77 100644
Binary files a/scripts/ios/screenshots-watch/ShowcaseTheme_dark.png and b/scripts/ios/screenshots-watch/ShowcaseTheme_dark.png differ
diff --git a/scripts/ios/screenshots-watch/ShowcaseTheme_light.png b/scripts/ios/screenshots-watch/ShowcaseTheme_light.png
index 84052bd794f..0cea54c8e14 100644
Binary files a/scripts/ios/screenshots-watch/ShowcaseTheme_light.png and b/scripts/ios/screenshots-watch/ShowcaseTheme_light.png differ
diff --git a/scripts/javascript/screenshots/ButtonTheme_ios_dark.png b/scripts/javascript/screenshots/ButtonTheme_ios_dark.png
index 68519104a3e..86ede1c8864 100644
Binary files a/scripts/javascript/screenshots/ButtonTheme_ios_dark.png and b/scripts/javascript/screenshots/ButtonTheme_ios_dark.png differ
diff --git a/scripts/javascript/screenshots/ButtonTheme_ios_light.png b/scripts/javascript/screenshots/ButtonTheme_ios_light.png
index d1e7de23d11..dc8856ec5b3 100644
Binary files a/scripts/javascript/screenshots/ButtonTheme_ios_light.png and b/scripts/javascript/screenshots/ButtonTheme_ios_light.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatFxAlert.png b/scripts/javascript/screenshots/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..8df4094e19c
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatFxAlert.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatFxControls.png b/scripts/javascript/screenshots/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..41ebbc57fc4
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatFxControls.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatFxData.png b/scripts/javascript/screenshots/DesktopCompatFxData.png
new file mode 100644
index 00000000000..c36e112d882
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatFxData.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatFxFxml.png b/scripts/javascript/screenshots/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..bd6d7152692
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatFxFxml.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatFxPanes.png b/scripts/javascript/screenshots/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..ee63c0d2920
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatFxPanes.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatFxShapes.png b/scripts/javascript/screenshots/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..e19c3b9fcdd
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatFxShapes.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingContainers.png b/scripts/javascript/screenshots/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..c9b3379d627
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingContainers.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingControls.png b/scripts/javascript/screenshots/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..f1977e899a6
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingControls.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingOptionPane.png b/scripts/javascript/screenshots/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..3f79c2b78a3
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingPainting.png b/scripts/javascript/screenshots/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..c3933c99880
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingPainting.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingTables.png b/scripts/javascript/screenshots/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..20402848b94
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingTables.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingTrees.png b/scripts/javascript/screenshots/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..0607da27faa
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingTrees.png differ
diff --git a/scripts/javascript/screenshots/DesktopCompatSwingX.png b/scripts/javascript/screenshots/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..a7f95ddd364
Binary files /dev/null and b/scripts/javascript/screenshots/DesktopCompatSwingX.png differ
diff --git a/scripts/linux/screenshots-arm/AndroidCompatMain.png b/scripts/linux/screenshots-arm/AndroidCompatMain.png
index e354bf590f3..2fd3a553cc5 100644
Binary files a/scripts/linux/screenshots-arm/AndroidCompatMain.png and b/scripts/linux/screenshots-arm/AndroidCompatMain.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatFxAlert.png b/scripts/linux/screenshots-arm/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..da50d24402e
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatFxAlert.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatFxControls.png b/scripts/linux/screenshots-arm/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..3622653c5c4
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatFxControls.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatFxData.png b/scripts/linux/screenshots-arm/DesktopCompatFxData.png
new file mode 100644
index 00000000000..dce83db7aed
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatFxData.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatFxFxml.png b/scripts/linux/screenshots-arm/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..aeca97b26e2
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatFxFxml.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatFxPanes.png b/scripts/linux/screenshots-arm/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..0c91d9a9ebf
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatFxPanes.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatFxShapes.png b/scripts/linux/screenshots-arm/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..75f5976f53d
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatFxShapes.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingContainers.png b/scripts/linux/screenshots-arm/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..16b32748396
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingContainers.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingControls.png b/scripts/linux/screenshots-arm/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..bbc0c75b30c
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingControls.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingOptionPane.png b/scripts/linux/screenshots-arm/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..05870033bf8
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingPainting.png b/scripts/linux/screenshots-arm/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..b51fd15739f
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingPainting.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingTables.png b/scripts/linux/screenshots-arm/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..e48245b5c4c
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingTables.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingTrees.png b/scripts/linux/screenshots-arm/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..d7a56db389b
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingTrees.png differ
diff --git a/scripts/linux/screenshots-arm/DesktopCompatSwingX.png b/scripts/linux/screenshots-arm/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..6fab4adfee8
Binary files /dev/null and b/scripts/linux/screenshots-arm/DesktopCompatSwingX.png differ
diff --git a/scripts/linux/screenshots-arm/ImageViewerNavigationModes.png b/scripts/linux/screenshots-arm/ImageViewerNavigationModes.png
index 58536821c1e..ab399e9c940 100644
Binary files a/scripts/linux/screenshots-arm/ImageViewerNavigationModes.png and b/scripts/linux/screenshots-arm/ImageViewerNavigationModes.png differ
diff --git a/scripts/linux/screenshots-arm/SurfacesRasterizer.png b/scripts/linux/screenshots-arm/SurfacesRasterizer.png
index 3e6bc78628e..6388066fc94 100644
Binary files a/scripts/linux/screenshots-arm/SurfacesRasterizer.png and b/scripts/linux/screenshots-arm/SurfacesRasterizer.png differ
diff --git a/scripts/linux/screenshots-arm/graphics-draw-image-rect.png b/scripts/linux/screenshots-arm/graphics-draw-image-rect.png
index cfdd331787e..34c4ad11f07 100644
Binary files a/scripts/linux/screenshots-arm/graphics-draw-image-rect.png and b/scripts/linux/screenshots-arm/graphics-draw-image-rect.png differ
diff --git a/scripts/linux/screenshots-arm/graphics-draw-string.png b/scripts/linux/screenshots-arm/graphics-draw-string.png
index 2986a5ea788..87818d513c6 100644
Binary files a/scripts/linux/screenshots-arm/graphics-draw-string.png and b/scripts/linux/screenshots-arm/graphics-draw-string.png differ
diff --git a/scripts/linux/screenshots/AndroidCompatMain.png b/scripts/linux/screenshots/AndroidCompatMain.png
index e354bf590f3..2fd3a553cc5 100644
Binary files a/scripts/linux/screenshots/AndroidCompatMain.png and b/scripts/linux/screenshots/AndroidCompatMain.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatFxAlert.png b/scripts/linux/screenshots/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..da50d24402e
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatFxAlert.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatFxControls.png b/scripts/linux/screenshots/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..3622653c5c4
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatFxControls.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatFxData.png b/scripts/linux/screenshots/DesktopCompatFxData.png
new file mode 100644
index 00000000000..dce83db7aed
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatFxData.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatFxFxml.png b/scripts/linux/screenshots/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..aeca97b26e2
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatFxFxml.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatFxPanes.png b/scripts/linux/screenshots/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..0c91d9a9ebf
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatFxPanes.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatFxShapes.png b/scripts/linux/screenshots/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..75f5976f53d
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatFxShapes.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingContainers.png b/scripts/linux/screenshots/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..16b32748396
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingContainers.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingControls.png b/scripts/linux/screenshots/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..bbc0c75b30c
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingControls.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingOptionPane.png b/scripts/linux/screenshots/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..05870033bf8
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingPainting.png b/scripts/linux/screenshots/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..b51fd15739f
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingPainting.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingTables.png b/scripts/linux/screenshots/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..e48245b5c4c
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingTables.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingTrees.png b/scripts/linux/screenshots/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..d7a56db389b
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingTrees.png differ
diff --git a/scripts/linux/screenshots/DesktopCompatSwingX.png b/scripts/linux/screenshots/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..6fab4adfee8
Binary files /dev/null and b/scripts/linux/screenshots/DesktopCompatSwingX.png differ
diff --git a/scripts/linux/screenshots/ImageViewerNavigationModes.png b/scripts/linux/screenshots/ImageViewerNavigationModes.png
index 58536821c1e..ab399e9c940 100644
Binary files a/scripts/linux/screenshots/ImageViewerNavigationModes.png and b/scripts/linux/screenshots/ImageViewerNavigationModes.png differ
diff --git a/scripts/linux/screenshots/SurfacesRasterizer.png b/scripts/linux/screenshots/SurfacesRasterizer.png
index 3e6bc78628e..6388066fc94 100644
Binary files a/scripts/linux/screenshots/SurfacesRasterizer.png and b/scripts/linux/screenshots/SurfacesRasterizer.png differ
diff --git a/scripts/linux/screenshots/graphics-draw-image-rect.png b/scripts/linux/screenshots/graphics-draw-image-rect.png
index cfdd331787e..34c4ad11f07 100644
Binary files a/scripts/linux/screenshots/graphics-draw-image-rect.png and b/scripts/linux/screenshots/graphics-draw-image-rect.png differ
diff --git a/scripts/linux/screenshots/graphics-draw-string.png b/scripts/linux/screenshots/graphics-draw-string.png
index 2986a5ea788..87818d513c6 100644
Binary files a/scripts/linux/screenshots/graphics-draw-string.png and b/scripts/linux/screenshots/graphics-draw-string.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatFxAlert.png b/scripts/mac-catalyst/screenshots/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..f3b306a6ec8
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatFxAlert.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatFxControls.png b/scripts/mac-catalyst/screenshots/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..ee5a843ddba
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatFxControls.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatFxData.png b/scripts/mac-catalyst/screenshots/DesktopCompatFxData.png
new file mode 100644
index 00000000000..003dff0cf49
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatFxData.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatFxFxml.png b/scripts/mac-catalyst/screenshots/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..d73e8e9c716
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatFxFxml.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatFxPanes.png b/scripts/mac-catalyst/screenshots/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..4b913d21d09
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatFxPanes.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatFxShapes.png b/scripts/mac-catalyst/screenshots/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..ea562d23c70
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatFxShapes.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingContainers.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..58bcfe3a251
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingContainers.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingControls.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..42be715eb4a
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingControls.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingOptionPane.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..da730eef064
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingPainting.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..a89eae0b59b
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingPainting.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingTables.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..60553e74d78
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingTables.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingTrees.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..4a33457ad98
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingTrees.png differ
diff --git a/scripts/mac-catalyst/screenshots/DesktopCompatSwingX.png b/scripts/mac-catalyst/screenshots/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..401207f7650
Binary files /dev/null and b/scripts/mac-catalyst/screenshots/DesktopCompatSwingX.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatFxAlert.png b/scripts/macos/screenshots/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..e71e4c1a8b8
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatFxAlert.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatFxControls.png b/scripts/macos/screenshots/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..8da2ed8a42a
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatFxControls.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatFxData.png b/scripts/macos/screenshots/DesktopCompatFxData.png
new file mode 100644
index 00000000000..51733b492e9
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatFxData.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatFxFxml.png b/scripts/macos/screenshots/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..7ad3e0b73b2
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatFxFxml.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatFxPanes.png b/scripts/macos/screenshots/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..723bcbf154a
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatFxPanes.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatFxShapes.png b/scripts/macos/screenshots/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..53cb1d603cf
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatFxShapes.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingContainers.png b/scripts/macos/screenshots/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..46b1e9294b0
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingContainers.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingControls.png b/scripts/macos/screenshots/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..a758f2106d6
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingControls.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingOptionPane.png b/scripts/macos/screenshots/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..dde7621fca8
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingPainting.png b/scripts/macos/screenshots/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..bc433e70cc7
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingPainting.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingTables.png b/scripts/macos/screenshots/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..e8c6423dc94
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingTables.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingTrees.png b/scripts/macos/screenshots/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..f4e00faac58
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingTrees.png differ
diff --git a/scripts/macos/screenshots/DesktopCompatSwingX.png b/scripts/macos/screenshots/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..7b92fac5621
Binary files /dev/null and b/scripts/macos/screenshots/DesktopCompatSwingX.png differ
diff --git a/scripts/windows/screenshots/AndroidCompatMain.png b/scripts/windows/screenshots/AndroidCompatMain.png
index 1c85738887a..dc7ffaaca92 100644
Binary files a/scripts/windows/screenshots/AndroidCompatMain.png and b/scripts/windows/screenshots/AndroidCompatMain.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatFxAlert.png b/scripts/windows/screenshots/DesktopCompatFxAlert.png
new file mode 100644
index 00000000000..3c65eceb61c
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatFxAlert.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatFxControls.png b/scripts/windows/screenshots/DesktopCompatFxControls.png
new file mode 100644
index 00000000000..c465f488d9b
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatFxControls.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatFxData.png b/scripts/windows/screenshots/DesktopCompatFxData.png
new file mode 100644
index 00000000000..66589b7083a
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatFxData.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatFxFxml.png b/scripts/windows/screenshots/DesktopCompatFxFxml.png
new file mode 100644
index 00000000000..67a76656859
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatFxFxml.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatFxPanes.png b/scripts/windows/screenshots/DesktopCompatFxPanes.png
new file mode 100644
index 00000000000..51f53e502b9
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatFxPanes.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatFxShapes.png b/scripts/windows/screenshots/DesktopCompatFxShapes.png
new file mode 100644
index 00000000000..52a71acfeea
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatFxShapes.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingContainers.png b/scripts/windows/screenshots/DesktopCompatSwingContainers.png
new file mode 100644
index 00000000000..9320737fb52
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingContainers.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingControls.png b/scripts/windows/screenshots/DesktopCompatSwingControls.png
new file mode 100644
index 00000000000..1646094fceb
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingControls.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingOptionPane.png b/scripts/windows/screenshots/DesktopCompatSwingOptionPane.png
new file mode 100644
index 00000000000..06fc33f8aef
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingOptionPane.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingPainting.png b/scripts/windows/screenshots/DesktopCompatSwingPainting.png
new file mode 100644
index 00000000000..5f0b9a9ee5a
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingPainting.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingTables.png b/scripts/windows/screenshots/DesktopCompatSwingTables.png
new file mode 100644
index 00000000000..fb316137a22
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingTables.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingTrees.png b/scripts/windows/screenshots/DesktopCompatSwingTrees.png
new file mode 100644
index 00000000000..a97a389609c
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingTrees.png differ
diff --git a/scripts/windows/screenshots/DesktopCompatSwingX.png b/scripts/windows/screenshots/DesktopCompatSwingX.png
new file mode 100644
index 00000000000..a75563b78cc
Binary files /dev/null and b/scripts/windows/screenshots/DesktopCompatSwingX.png differ
diff --git a/scripts/windows/screenshots/DesktopMode.png b/scripts/windows/screenshots/DesktopMode.png
index c5f7ec8ea06..11c27c3eeb4 100644
Binary files a/scripts/windows/screenshots/DesktopMode.png and b/scripts/windows/screenshots/DesktopMode.png differ
diff --git a/scripts/windows/screenshots/SurfacesRasterizer.png b/scripts/windows/screenshots/SurfacesRasterizer.png
index 2cca54f68f7..a9c605c27fb 100644
Binary files a/scripts/windows/screenshots/SurfacesRasterizer.png and b/scripts/windows/screenshots/SurfacesRasterizer.png differ
diff --git a/scripts/windows/screenshots/graphics-draw-string.png b/scripts/windows/screenshots/graphics-draw-string.png
index 000606f0988..22fcea3b0cf 100644
Binary files a/scripts/windows/screenshots/graphics-draw-string.png and b/scripts/windows/screenshots/graphics-draw-string.png differ
diff --git a/vm/ByteCodeTranslator/src/cn1_globals.h b/vm/ByteCodeTranslator/src/cn1_globals.h
index e1d7b1c5498..b7327f0ccc7 100644
--- a/vm/ByteCodeTranslator/src/cn1_globals.h
+++ b/vm/ByteCodeTranslator/src/cn1_globals.h
@@ -2092,6 +2092,10 @@ struct ThreadLocalData {
     int utf8BufferSize;
     JAVA_BOOLEAN threadKilled;      // we don't expect to see this in the GC
     JAVA_BOOLEAN interrupted;
+    // The object this thread is blocked on in Object.wait, or JAVA_NULL. Written
+    // by the waiter with the object's monitor mutex held, read by Thread.interrupt
+    // (java_lang_Thread_interrupt0__), which wakes the wait through it.
+    JAVA_OBJECT waitingOn;
 
     // Dead-thread pending-migration queue (single-writer allObjectsInHeap):
     // markDeadThread queues the dying thread's TLD (critical section held)
diff --git a/vm/ByteCodeTranslator/src/cn1_globals.m b/vm/ByteCodeTranslator/src/cn1_globals.m
index ff4a9a6f6b7..444909c1eb3 100644
--- a/vm/ByteCodeTranslator/src/cn1_globals.m
+++ b/vm/ByteCodeTranslator/src/cn1_globals.m
@@ -1240,7 +1240,26 @@ void cn1MarkDeadNow(JAVA_OBJECT o) {
      * liveness decision that outranks any static proof. */
     signed char expected = (signed char)cn1GcMarkEncode(CN1_GC_MARK_FRESH);
     int floorv = atomic_load_explicit(&cn1GcReclaimedBefore, memory_order_acquire);
+    /* ONLY BETWEEN CYCLES, and this is what makes "a wrong proof is not fatal" true.
+     *
+     * The floor moves at the END of a sweep. A value chosen while that sweep was still
+     * running was clamped to the OLD floor, and one store later sat below the new one:
+     * cn1GcWasReclaimed then answered TRUE for an object nobody had reclaimed, so
+     * cn1ConservativeResolve refused it and gcMarkObject's resolve guard dropped every
+     * root that named it. The mark could no longer reach it, which is the one thing the
+     * paragraph above depends on. Measured on a JavaFX application built for Linux,
+     * where the translator had wrongly proved a started Thread frame-local: the Thread
+     * was stamped epoch 11 during the sweep of cycle 12, was the registered
+     * currentThreadObject of a parked thread when cycle 13 marked, did not resolve, and
+     * was swept; its finalizer unmapped the live thread's shadow stack and the next
+     * root scan of that thread faulted (2-4% of launches).
+     *
+     * The floor equals the current epoch less the slack exactly when the last full
+     * sweep has finished and no later cycle has begun, and then the clamp below
+     * yields the floor itself -- the lowest value that still resolves. Anywhere else
+     * the object simply keeps its fresh mark and the ordinary grace. */
     int stale = currentGcMarkValue - cn1GcAgingSlack() - 1;
+    if(floorv != stale + 1) { return; }
     if(stale < floorv) { stale = floorv; }
     // The word holds the ENCODED epoch (see CN1_GC_EPOCH_WINDOW); both sides of the swap
     // are encoded values.
@@ -20628,7 +20647,7 @@ JAVA_BOOLEAN throwException_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT exc
 // retained when -Dcn1.checkedCasts is on -- an unresolved symbol at link time for
 // everyone else. Keeping the reference in generated code, which only exists under
 // the same flag that retains the class, makes the two impossible to desynchronize.
-// (That is exactly how the first cut of this broke FileClassIntegrationTest.)
+// (That is exactly how the first cut of this broke FileClassIntegrationTest, now part of HostLocksIntegrationTest.)
 //
 // No detail message on the exception: the no-arg constructor is the shape proven
 // to survive dead-code elimination (it is how NullPointerException is thrown from
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeClass.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeClass.java
index 784811c6439..27a3e24460b 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeClass.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeClass.java
@@ -662,6 +662,47 @@ public static List<ByteCodeClass> clearUnmarked(List<ByteCodeClass> lst) {
         return response;
     }
     
+    /// The backend runtime's file-system install. The class library reaches the
+    /// file system through `com.codename1.impl.JdkHost`, and a backend program
+    /// has no Codename One core to install one -- `Backend`'s static initializer
+    /// did, so a program that wrote a file before touching `Backend` (the
+    /// runtime self test does, through `FileIo` and `StaticFiles`) got "No file
+    /// system". The clean target's main() now runs it before the program's main.
+    /// Only a translation that carries the backend runtime has the class.
+    private static final String CLEAN_STARTUP_CLASS = "com_codename1_backend_FileIo";
+    private static final String CLEAN_STARTUP_METHOD = "installJdkHost";
+
+    static boolean isCleanTargetStartup(String clsName, BytecodeMethod m) {
+        return ByteCodeTranslator.output == ByteCodeTranslator.OutputType.OUTPUT_TYPE_CLEAN
+                && CLEAN_STARTUP_CLASS.equals(clsName)
+                && CLEAN_STARTUP_METHOD.equals(m.getMethodName())
+                && m.isStatic();
+    }
+
+    private void appendCleanTargetStartup(StringBuilder b, List<ByteCodeClass> allClasses) {
+        // Only a class in the emitted set: calling into one that is not
+        // emitted would not link.
+        ByteCodeClass cls = null;
+        for (ByteCodeClass c : allClasses) {
+            if (CLEAN_STARTUP_CLASS.equals(c.getClsName())) {
+                cls = c;
+                break;
+            }
+        }
+        if (cls == null) {
+            return;
+        }
+        for (BytecodeMethod m : cls.getMethods()) {
+            if (!m.isEliminated() && isCleanTargetStartup(CLEAN_STARTUP_CLASS, m)
+                    && m.getSignature().equals("()V")) {
+                String fn = CLEAN_STARTUP_CLASS + "_" + CLEAN_STARTUP_METHOD + "__";
+                b.append("    extern void ").append(fn).append("(CODENAME_ONE_THREAD_STATE);\n");
+                b.append("    ").append(fn).append("(getThreadLocalData());\n");
+                return;
+            }
+        }
+    }
+
     private ByteCodeClass findClass(String s, List<ByteCodeClass> lst) {
         // lst is always Parser.classes here (markDependencies -> markDependent), so
         // the shared name index gives the same first-match result in O(1) instead of
@@ -1844,6 +1885,7 @@ public String generateCCode(List<ByteCodeClass> allClasses) {
                         b.append("    struct ThreadLocalData* mainThread = getThreadLocalData();\n");
                         b.append("    mainThread->lightweightThread = JAVA_TRUE;\n");
                         b.append("    mainThread->threadActive = JAVA_TRUE;\n");
+                        appendCleanTargetStartup(b, allClasses);
                     }
                     // UI host threads remain native: AppKit's event loop enters
                     // Java through callbacks rather than running a Java main to
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeTranslator.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeTranslator.java
index 2b8fa2939e3..07048287052 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeTranslator.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/ByteCodeTranslator.java
@@ -397,6 +397,7 @@ private static void deleteIfPresent(File stale) throws IOException {
     }
 
     public static void main(String[] args) throws Exception {
+        RuntimeHost.install();
         // Provenance describes ONE translation, and this is the start of one. It has to
         // be cleared here rather than in Parser.cleanup(): that runs from the `finally`
         // of Parser.writeOutput(), which is BEFORE the output handler writes the
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/BytecodeMethod.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/BytecodeMethod.java
index 708270c6fed..a5d70401d3d 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/BytecodeMethod.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/BytecodeMethod.java
@@ -4722,7 +4722,8 @@ public void collectRetireCandidates() {
             }
             java.util.List<String> calls =
                     new java.util.ArrayList<String>(IteratorEscape.receiverCalls);
-            if (!Parser.calleesKeepThis(calls, new java.util.HashMap<String, Boolean>())) {
+            if (!Parser.calleesKeepThis(ti.getTypeName(), calls,
+                    new java.util.HashMap<String, Boolean>())) {
                 continue;
             }
             if (retireCandidates == null) {
@@ -4816,7 +4817,8 @@ private void unusedOldRetirePass() {
             }
             java.util.List<String> calls =
                     new java.util.ArrayList<String>(IteratorEscape.receiverCalls);
-            if (!Parser.calleesKeepThis(calls, new java.util.HashMap<String, Boolean>())) {
+            if (!Parser.calleesKeepThis(ti.getTypeName(), calls,
+                    new java.util.HashMap<String, Boolean>())) {
                 continue;
             }
             if (frameless) {
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/IteratorEscape.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/IteratorEscape.java
index 388166e206d..07acb199268 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/IteratorEscape.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/IteratorEscape.java
@@ -75,9 +75,15 @@ class IteratorEscape {
 
     /// Callees invoked ON the tracked reference during the last walk, as
     /// owner.name+desc. Valid only immediately after a walk, exactly like lastReason.
-    /// A site is only retirable if none of these leaks `this`.
+    /// A site is only retirable if none of these leaks `this`. An entry that starts
+    /// with SPECIAL_CALL was an INVOKESPECIAL, whose target is the named method itself
+    /// rather than whatever the receiver's class overrides it with.
     static final java.util.List<String> receiverCalls = new java.util.ArrayList<String>();
 
+    /// Prefix of a receiverCalls entry recorded from an INVOKESPECIAL. Not a character
+    /// an internal class name can start with.
+    static final String SPECIAL_CALL = "!";
+
     /// The local the last walk followed, or -1 if the value never reached one. Valid
     /// only immediately after a walk. Frame-exit retirement needs it: the object to
     /// retire is whatever that local holds when the frame goes.
@@ -93,6 +99,15 @@ static int thisEscapes(BytecodeMethod m) {
         if (m.isStatic()) {
             return SAFE;   // no `this` to leak
         }
+        if (m.isNative()) {
+            // No instructions is not "no escape". A native can publish its receiver --
+            // Thread.start() hands it to another thread -- and nothing here can read
+            // what it does, so the walk below would answer SAFE for an empty body.
+            lastReason = "native method";
+            receiverCalls.clear();
+            lastTrackedLocal = -1;
+            return UNKNOWN;
+        }
         return walk(m, true, null, true);
     }
 
@@ -436,7 +451,12 @@ && ctorOnlyStoresParamsIntoThis(inv.getOwner(), inv.getDesc())) {
                 if (hasReceiver) {
                     int ridx = sp - 1 - argCount;
                     if (ridx >= 0 && stack[ridx]) {
-                        receiverCalls.add(inv.getOwner() + "." + inv.getName() + inv.getDesc());
+                        // INVOKESPECIAL names its target exactly (a constructor, a
+                        // super call); every other receiver call dispatches on the
+                        // object's own class. The marker keeps that apart for
+                        // Parser.calleeIsSafe, which must check the method that RUNS.
+                        receiverCalls.add((op == Opcodes.INVOKESPECIAL ? SPECIAL_CALL : "")
+                                + inv.getOwner() + "." + inv.getName() + inv.getDesc());
                     }
                 }
                 sp = Math.max(0, sp - argCount - (hasReceiver ? 1 : 0));
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java
index 17d9773f2f8..b61ddccc414 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptMethodGenerator.java
@@ -5215,7 +5215,7 @@ private static boolean appendStraightLineLdcInstruction(StringBuilder out, Ldc i
             return true;
         }
         if (value instanceof Integer || value instanceof Float || value instanceof Double) {
-            out.append("  ").append(ctx.push(value.toString())).append(";\n");
+            out.append("  ").append(ctx.push(numericLiteral(value))).append(";\n");
             return true;
         }
         if (value instanceof Type) {
@@ -5411,6 +5411,19 @@ private static void appendStraightLineEnsureClassInitialized(StringBuilder out,
      * depth of the call's value; consumption by a store / return / putfield
      * / array-store / jump-condition / further composition ends the window.
      */
+    /// The JavaScript literal for an int, float or double LDC constant. A float is
+    /// a double in JavaScript, so it is written at its exact double value:
+    /// ``Float.toString`` is only the shortest string that rounds back to the
+    /// FLOAT, and read as a double it is a different number -- Float.MIN_VALUE
+    /// printed as ``1.4E-45`` is not 2^-149, and every arithmetic result built on
+    /// it was wrong.
+    static String numericLiteral(Object value) {
+        if (value instanceof Float) {
+            return Double.toString(((Float) value).doubleValue());
+        }
+        return value.toString();
+    }
+
     private static boolean canDeferInvokeResult(List<Instruction> instructions, int index) {
         int depth = 0; // our value sits at relative depth 0 from the top
         for (int i = index + 1; i < instructions.size() && i < index + 10; i++) {
@@ -5727,11 +5740,38 @@ private String push(String expression) {
                 return "";
             }
             pendingExpr[sp] = null;
+            // A deferred invoke (pushComposite from the call sites that
+            // canDeferInvokeResult admits) can name slots ABOVE its own as
+            // arguments: ``s0 = call(s0, s1)`` is held as pending s0 and s1 is
+            // free again. A materialised push into that slot would then
+            // overwrite an argument before the call reads it -- as in
+            // ``Long.divideUnsigned(a, b) == 14L``, where the long literal is
+            // not deferrable and became ``s1 = _Llit(14, 0)`` ahead of the
+            // call. Evaluate any such pending first; nothing between the call
+            // and here has side effects, so this is the order the bytecode has.
+            String prelude = flushPendingReading("s" + sp);
             String slot = "s" + sp++;
             if (sp > maxObservedStack) {
                 maxObservedStack = sp;
             }
-            return slot + " = " + expression;
+            return prelude + slot + " = " + expression;
+        }
+
+        /// Materialise every pending below the top whose expression reads
+        /// ``slot``. Returns the statements to emit, each ending in a newline.
+        private String flushPendingReading(String slot) {
+            StringBuilder prelude = null;
+            for (int i = 0; i < sp; i++) {
+                if (pendingExpr[i] != null && containsWord(pendingExpr[i], slot)) {
+                    if (prelude == null) {
+                        prelude = new StringBuilder();
+                    }
+                    prelude.append("s").append(i).append(" = ").append(pendingExpr[i]).append(";\n  ");
+                    pendingExpr[i] = null;
+                    pendingIsField[i] = false;
+                }
+            }
+            return prelude == null ? "" : prelude.toString();
         }
 
         private String pop() {
@@ -7145,7 +7185,7 @@ private static void appendLdcInstruction(StringBuilder out, Ldc instruction, int
             return;
         }
         if (value instanceof Integer || value instanceof Float || value instanceof Double) {
-            out.append("        stack.p(").append(value.toString()).append("); pc = ").append(index + 1).append("; break;\n");
+            out.append("        stack.p(").append(numericLiteral(value)).append("); pc = ").append(index + 1).append("; break;\n");
             return;
         }
         if (value instanceof Type) {
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptNativeRegistry.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptNativeRegistry.java
index 113cf186ea1..9dbf8a297ea 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptNativeRegistry.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/JavascriptNativeRegistry.java
@@ -131,6 +131,7 @@ enum NativeCategory {
             "cn1_java_lang_Object_notifyAll",
             "cn1_java_lang_Object_toString_R_java_lang_String",
             "cn1_java_lang_Object_wait_long_int",
+            "cn1_java_lang_Runtime_exitImpl_int",
             "cn1_java_lang_Runtime_freeMemoryImpl_R_long",
             "cn1_java_lang_Runtime_totalMemoryImpl_R_long",
             "cn1_java_lang_StringBuilder_resizeBufferImpl_int_boolean_R_boolean",
@@ -171,7 +172,6 @@ enum NativeCategory {
             "cn1_java_lang_String_toUpperCase_R_java_lang_String",
             "cn1_java_lang_System_arraycopy_java_lang_Object_int_java_lang_Object_int_int",
             "cn1_java_lang_System_currentTimeMillis_R_long",
-            "cn1_java_lang_System_exit_int",
             "cn1_java_lang_System_gcLight",
             "cn1_java_lang_System_getenvImpl_java_lang_String_R_java_lang_String",
             "cn1_java_lang_System_gcMarkSweep",
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/Parser.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/Parser.java
index bb5c045270d..eac938c21eb 100644
--- a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/Parser.java
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/Parser.java
@@ -489,6 +489,10 @@ public static void cleanup() {
         LocalReceiverTypes.clear();
         cn1SubclassIndex = null;
         cn1SubclassIndexSize = -1;
+        // A later translation in this process can parse exactly as many classes.
+        calleeClassIndex = null;
+        calleeClassIndexSource = null;
+        calleeClassIndexSize = -1;
         nativeSources = null;
         classes.clear();
         // classes is cleared in place (same List reference), so the name index's
@@ -1781,6 +1785,11 @@ private static int cullMethods() {
                 if(JavascriptNativeRegistry.isRuntimeDelegateTarget(bc.getClsName(), mtd.getMethodName())) {
                     continue;
                 }
+                // Called from the clean target's generated main() before the
+                // program's own main; no bytecode call site exists.
+                if(ByteCodeClass.isCleanTargetStartup(bc.getClsName(), mtd)) {
+                    continue;
+                }
                 if(mtd.isEliminated() || mtd.isMain() || mtd.getMethodName().equals("__CLINIT__") || mtd.getMethodName().equals("finalize") || mtd.isNative()) {
                     if (!mtd.isEliminated() && mtd.getMethodName().contains("yield")) {
                         if(ByteCodeTranslator.verbose) {
@@ -3159,24 +3168,98 @@ public static boolean isStackIterator(String mangledClsName) {
     /// Do all of these callees keep `this` to themselves? The precise form of the
     /// receiver check: only the methods a site ACTUALLY invokes on the tracked object
     /// matter, not every method the class happens to declare.
-    static boolean calleesKeepThis(List<String> calls, Map<String, Boolean> memo) {
+    ///
+    /// `allocated` is the class the tracked object was created as. The object's class
+    /// is known exactly -- the walk follows the result of one NEW -- and that is the
+    /// class a virtual call dispatches on, whatever type the call site names.
+    static boolean calleesKeepThis(String allocated, List<String> calls, Map<String, Boolean> memo) {
         for (int i = 0; i < calls.size(); i++) {
-            String key = calls.get(i);
-            Boolean cached = memo.get(key);
-            if (cached == null) {
-                cached = Boolean.valueOf(calleeIsSafe(key));
-                memo.put(key, cached);
-            }
-            if (!cached.booleanValue()) {
+            if (!calleeIsSafe(allocated, calls.get(i), memo)) {
                 return false;
             }
         }
         return true;
     }
 
-    /// owner.name+desc -> does that one method keep `this`? A callee that cannot be
-    /// resolved in this closed world answers NO: an unknown body is an unchecked body.
-    static boolean calleeIsSafe(String key) {
+    /// Mangled class name -> class, for the closed world as it stands. Rebuilt when the
+    /// list is replaced or changes size; resolving a callee used to mangle every class
+    /// name once per question.
+    private static Map<String, ByteCodeClass> calleeClassIndex;
+    private static List<ByteCodeClass> calleeClassIndexSource;
+    private static int calleeClassIndexSize = -1;
+
+    private static ByteCodeClass calleeClass(String mangled) {
+        if (calleeClassIndex == null || calleeClassIndexSource != classes
+                || calleeClassIndexSize != classes.size()) {
+            Map<String, ByteCodeClass> idx = new HashMap<String, ByteCodeClass>();
+            for (ByteCodeClass c : classes) {
+                String k = IteratorEscape.mangle(c.getClsName());
+                // The first one wins, as it did when this was a scan of the list.
+                if (!idx.containsKey(k)) {
+                    idx.put(k, c);
+                }
+            }
+            calleeClassIndex = idx;
+            calleeClassIndexSource = classes;
+            calleeClassIndexSize = classes.size();
+        }
+        return calleeClassIndex.get(mangled);
+    }
+
+    private static BytecodeMethod declaredMethod(ByteCodeClass c, String name, String desc) {
+        for (BytecodeMethod m : c.getMethods()) {
+            if (m.getMethodName().equals(name) && desc.equals(m.getDesc())) {
+                return m;
+            }
+        }
+        return null;
+    }
+
+    /// owner.name+desc -> does the method that call RUNS keep `this`? A callee that
+    /// cannot be resolved in this closed world answers NO: an unknown body is an
+    /// unchecked body.
+    ///
+    /// THREE WAYS THIS USED TO ANSWER YES FOR A METHOD THAT PUBLISHES `this`, each of
+    /// them "the body was never looked at":
+    ///
+    ///   1. A NATIVE callee. It has no instructions, so the walk over them found no
+    ///      escape and said SAFE. `Thread.start()` is native and hands its receiver to
+    ///      a new thread: `Thread t = new Thread(r); t.start();` was therefore proved
+    ///      frame-local and the Thread retired at frame exit, while it was running.
+    ///      The collector then swept the Thread, its finalizer released the thread's
+    ///      native record and shadow stack, and the next root scan of that live thread
+    ///      read unmapped memory. What a native does with its receiver cannot be read
+    ///      from bytecode, so it answers NO.
+    ///   2. An ABSTRACT callee, for the same reason: `Runnable r = new Task(); r.run()`
+    ///      names Runnable.run, which has no body, while Task.run is what executes. A
+    ///      virtual call is resolved from the allocated class upwards instead, and so
+    ///      is an override of a method the call site names in a superclass.
+    ///   3. A callee that calls ANOTHER method on `this`. The walk allows the tracked
+    ///      value as a receiver "because that callee is checked on its own", and for a
+    ///      callee's own callees nothing did. `void begin() { register(); }` was SAFE
+    ///      whatever register() did. The check is now the whole closure.
+    ///
+    /// A cycle in that closure is assumed safe while it is being walked, which is sound
+    /// because the answer is a conjunction over everything reachable: one unsafe
+    /// method anywhere fails the question that was asked, and `memo` lives for that
+    /// one question only.
+    static boolean calleeIsSafe(String allocated, String key, Map<String, Boolean> memo) {
+        Boolean cached = memo.get(key);
+        if (cached != null) {
+            return cached.booleanValue();
+        }
+        memo.put(key, Boolean.TRUE);
+        boolean r = calleeIsSafeUncached(allocated, key, memo);
+        memo.put(key, Boolean.valueOf(r));
+        return r;
+    }
+
+    private static boolean calleeIsSafeUncached(String allocated, String key,
+            Map<String, Boolean> memo) {
+        boolean special = key.startsWith(IteratorEscape.SPECIAL_CALL);
+        if (special) {
+            key = key.substring(IteratorEscape.SPECIAL_CALL.length());
+        }
         int dot = key.indexOf('.');
         if (dot < 0) {
             return false;
@@ -3196,18 +3279,38 @@ static boolean calleeIsSafe(String key) {
             name = "__INIT__";
         }
         String desc = rest.substring(paren);
-        for (ByteCodeClass c : classes) {
-            if (!IteratorEscape.mangle(c.getClsName()).equals(owner)) {
-                continue;
-            }
-            for (BytecodeMethod m : c.getMethods()) {
-                if (m.getMethodName().equals(name) && desc.equals(m.getDesc())) {
-                    return IteratorEscape.thisEscapes(m) == IteratorEscape.SAFE;
+        ByteCodeClass ownerCls = calleeClass(owner);
+        if (ownerCls == null) {
+            return false;       // not in this closed world
+        }
+        BytecodeMethod target = declaredMethod(ownerCls, name, desc);
+        // A private method is never overridden, and newer class files call one with
+        // INVOKEVIRTUAL; a subclass may declare an unrelated method of the same name.
+        if (!special && (target == null || !target.isPrivate())) {
+            target = null;
+            ByteCodeClass c = calleeClass(IteratorEscape.mangle(allocated));
+            // Bounded: a malformed hierarchy must not hang the build.
+            for (int depth = 0; c != null && depth < 64; depth++) {
+                target = declaredMethod(c, name, desc);
+                if (target != null) {
+                    break;
                 }
+                String base = c.getBaseClass();
+                c = base == null ? null : calleeClass(IteratorEscape.mangle(base));
             }
-            return false;   // class found, method not -- inherited or synthetic
         }
-        return false;       // not in this closed world
+        if (target == null) {
+            return false;       // inherited past what is known here, or synthetic
+        }
+        if (target.isNative() || target.isAbstract()) {
+            return false;       // no body to check
+        }
+        if (IteratorEscape.thisEscapes(target) != IteratorEscape.SAFE) {
+            return false;
+        }
+        // Copied before recursing: the list belongs to the walk that just ran.
+        List<String> nested = new ArrayList<String>(IteratorEscape.receiverCalls);
+        return calleesKeepThis(allocated, nested, memo);
     }
 
     static void iteratorStackCensus() {
diff --git a/vm/ByteCodeTranslator/src/com/codename1/tools/translator/RuntimeHost.java b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/RuntimeHost.java
new file mode 100644
index 00000000000..b3ee97b3b2f
--- /dev/null
+++ b/vm/ByteCodeTranslator/src/com/codename1/tools/translator/RuntimeHost.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.tools.translator;
+
+/**
+ * Connects the class library the translator runs on to the platform.
+ *
+ * On a JVM there is nothing to connect, so this does nothing. The self-hosted
+ * build replaces the class with {@code vm/selfhost/stubs}' version, which
+ * installs {@code com.codename1.impl.PosixJdkHost} -- the translator running on
+ * ParparVM's own class library reaches the file system through it.
+ */
+final class RuntimeHost {
+    private RuntimeHost() {
+    }
+
+    static void install() {
+    }
+}
diff --git a/vm/ByteCodeTranslator/src/java_io_File.m b/vm/ByteCodeTranslator/src/java_io_File.m
index 729d2e6c5ad..5bd2b880377 100644
--- a/vm/ByteCodeTranslator/src/java_io_File.m
+++ b/vm/ByteCodeTranslator/src/java_io_File.m
@@ -726,20 +726,58 @@ and rename(p, d) was rename(d, d): a no-op that reports success when the
     }
 }
 
+/* The permission setters, as the JDK implements them on each platform: on POSIX
+   a chmod of the OWNER bit (File.setX(on) is setX(on, true)), and setReadOnly
+   clears every write bit. They used to answer false without touching the file,
+   so a file could never be locked on Linux or the clean target and everything
+   that relies on that (a move that must fail to delete its source, a read-only
+   cache) silently did something else. Found by the bulk conformance run.
+   Windows has only the read-only attribute, which _chmod sets: reading cannot be
+   taken away and there is no execute bit, so those answer whether the request
+   already holds, as the JDK does there. */
+static JAVA_BOOLEAN cn1FileSetMode(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT path, int which, JAVA_BOOLEAN on) {
+    const char* p;
+    struct stat st;
+    if(path == JAVA_NULL) return JAVA_FALSE;
+    p = stringToUTF8(threadStateData, path);
+    if(p == NULL || stat(p, &st) != 0) return JAVA_FALSE;
+#ifdef _WIN32
+    if(which == 'w') {
+        return _chmod(p, on ? (_S_IREAD | _S_IWRITE) : _S_IREAD) == 0 ? JAVA_TRUE : JAVA_FALSE;
+    }
+    if(which == 'o') {
+        return _chmod(p, _S_IREAD) == 0 ? JAVA_TRUE : JAVA_FALSE;
+    }
+    return on ? JAVA_TRUE : JAVA_FALSE;
+#else
+    {
+        mode_t mode = st.st_mode & 07777;
+        mode_t bit = which == 'r' ? S_IRUSR : which == 'x' ? S_IXUSR : which == 'w' ? S_IWUSR
+                : (S_IWUSR | S_IWGRP | S_IWOTH);
+        if(which == 'o' || !on) {
+            mode &= ~bit;
+        } else {
+            mode |= bit;
+        }
+        return chmod(p, mode) == 0 ? JAVA_TRUE : JAVA_FALSE;
+    }
+#endif
+}
+
 JAVA_BOOLEAN java_io_File_setReadOnlyImpl___java_lang_String_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT  __cn1ThisObject, JAVA_OBJECT path) {
-    return JAVA_FALSE; // Not implemented for POSIX here
+    return cn1FileSetMode(threadStateData, path, 'o', JAVA_FALSE);
 }
 
 JAVA_BOOLEAN java_io_File_setWritableImpl___java_lang_String_boolean_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT  __cn1ThisObject, JAVA_OBJECT path, JAVA_BOOLEAN writable) {
-    return JAVA_FALSE;
+    return cn1FileSetMode(threadStateData, path, 'w', writable);
 }
 
 JAVA_BOOLEAN java_io_File_setReadableImpl___java_lang_String_boolean_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT  __cn1ThisObject, JAVA_OBJECT path, JAVA_BOOLEAN readable) {
-    return JAVA_FALSE;
+    return cn1FileSetMode(threadStateData, path, 'r', readable);
 }
 
 JAVA_BOOLEAN java_io_File_setExecutableImpl___java_lang_String_boolean_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT  __cn1ThisObject, JAVA_OBJECT path, JAVA_BOOLEAN executable) {
-    return JAVA_FALSE;
+    return cn1FileSetMode(threadStateData, path, 'x', executable);
 }
 
 JAVA_BOOLEAN java_io_File_canReadImpl___java_lang_String_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT  __cn1ThisObject, JAVA_OBJECT path) {
diff --git a/vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js b/vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js
index f45a2b2369e..8268640e1cd 100644
--- a/vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js
+++ b/vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js
@@ -5451,6 +5451,17 @@ bindNative([
   "cn1_java_lang_Object_wait_long_int",
   "cn1_java_lang_Object_wait___long_int"
 ], function*(__cn1ThisObject, timeout, nanos) {
+  // A thread already interrupted throws without waiting, as the JDK's does
+  // (and as the native wait in nativeMethods.m does). The monitor must still
+  // be owned, which waitOn would otherwise have checked.
+  const current = jvm.currentThread;
+  if (current && current.object && current.object.__interrupted) {
+    const monitor = __cn1ThisObject.__monitor;
+    if (!monitor || monitor.owner !== current.id) {
+      throw new Error("IllegalMonitorStateException");
+    }
+    yield* throwInterruptedException();
+  }
   const resumed = yield jvm.waitOn(jvm.currentThread, __cn1ThisObject, timeout || 0);
   if (resumed && resumed.interrupted) {
     yield* throwInterruptedException();
@@ -5637,7 +5648,7 @@ bindNative(["cn1_java_lang_Short_cn1Value_R_short"], function(__cn1ThisObject) {
 bindNative(["cn1_java_lang_Short_valueOf_short_R_java_lang_Short"], function*(v) {
   return yield* adaptVirtualResult(cn1_java_lang_Short_valueOfHeap_short_R_java_lang_Short(v));
 });
-bindNative(["cn1_java_lang_System_exit_int", "cn1_java_lang_System_exit___int"], function(status) { jvm.finish(status); return null; });
+bindNative(["cn1_java_lang_Runtime_exitImpl_int", "cn1_java_lang_Runtime_exitImpl___int"], function(status) { jvm.finish(status); return null; });
 bindNative(["cn1_java_lang_Runtime_totalMemoryImpl_R_long"], function() { return _LfromNumber(67108864); });
 bindNative(["cn1_java_lang_Runtime_freeMemoryImpl_R_long"], function() { return _LfromNumber(33554432); });
 bindNative(["cn1_java_lang_Throwable_fillInStack"], function(__cn1ThisObject) {
@@ -5939,11 +5950,15 @@ bindNative(["cn1_java_lang_StringToReal_parseDblImpl_java_lang_String_int_R_doub
   // The previous implementation returned Number("14")=14, which was the root
   // cause of the huge Switch pills and any other CN1 path that uses fractional
   // theme constants / scale factors. Apply the exponent.
+  // The exponent goes into the text, so Number rounds once, correctly, and
+  // reaches Infinity or 0 itself: multiplying by Math.pow(10, exp) rounded
+  // twice (14 * 0.1 is 1.4000000000000001) and overflowed the power before
+  // the digits could bring it back into range.
   const text = jvm.toNativeString(value);
-  const parsed = Number(text);
-  if (isNaN(parsed)) return 0;
   const exp = exponentIndex | 0;
-  return exp === 0 ? parsed : parsed * Math.pow(10, exp);
+  const parsed = Number(exp === 0 ? text : text + "e" + exp);
+  if (isNaN(parsed)) return 0;
+  return parsed;
 });
 bindNative(["cn1_java_lang_Enum_valueOf_java_lang_Class_java_lang_String_R_java_lang_Enum"], function(enumType, name) {
   if (!enumType || !enumType.__classDef) {
diff --git a/vm/ByteCodeTranslator/src/nativeMethods.m b/vm/ByteCodeTranslator/src/nativeMethods.m
index 12840bba8df..6880f26c78c 100644
--- a/vm/ByteCodeTranslator/src/nativeMethods.m
+++ b/vm/ByteCodeTranslator/src/nativeMethods.m
@@ -1589,6 +1589,12 @@ JAVA_LONG java_lang_Double_doubleToLongBits___double_R_long(CODENAME_ONE_THREAD_
         JAVA_LONG   l;
     } u;
     
+    // Java collapses every NaN to the canonical one, and Double.equals and
+    // hashCode depend on it. The hardware does not: x86 produces 0xfff8...
+    // for Infinity + -Infinity where ARM produces 0x7ff8...
+    if (n1 != n1) {
+        return 0x7ff8000000000000LL;
+    }
     u.d = n1;
     return u.l;
 }
@@ -1611,6 +1617,10 @@ JAVA_INT java_lang_Float_floatToIntBits___float_R_int(CODENAME_ONE_THREAD_STATE,
         JAVA_INT    i;
     } u;
     
+    // The canonical NaN, as doubleToLongBits above.
+    if (n1 != n1) {
+        return 0x7fc00000;
+    }
     u.f = n1;
     return u.i;
 }
@@ -1995,6 +2005,12 @@ JAVA_DOUBLE java_lang_Math_floor___double_R_double(CODENAME_ONE_THREAD_STATE, JA
 }
 
 JAVA_DOUBLE java_lang_Math_max___double_double_R_double(CODENAME_ONE_THREAD_STATE, JAVA_DOUBLE a, JAVA_DOUBLE b){
+    // Java semantics, not C's comparison: NaN wins over any value, and
+    // -0.0 is smaller than 0.0 although the two compare equal. A plain
+    // comparison answered the other operand for both (found by the bulk
+    // conformance run, through DoubleStream.min/max).
+    if(a != a) return a;
+    if(a == 0 && b == 0) return signbit(a) ? b : a;
     if(a > b) return a;
     return b;
 }
@@ -2004,6 +2020,9 @@ JAVA_DOUBLE java_lang_Math_pow___double_double_R_double(CODENAME_ONE_THREAD_STAT
 }
 
 JAVA_FLOAT java_lang_Math_max___float_float_R_float(CODENAME_ONE_THREAD_STATE, JAVA_FLOAT a, JAVA_FLOAT b){
+    // See max(double, double).
+    if(a != a) return a;
+    if(a == 0 && b == 0) return signbit(a) ? b : a;
     if(a > b) return a;
     return b;
 }
@@ -2019,11 +2038,17 @@ JAVA_LONG java_lang_Math_max___long_long_R_long(CODENAME_ONE_THREAD_STATE, JAVA_
 }
 
 JAVA_DOUBLE java_lang_Math_min___double_double_R_double(CODENAME_ONE_THREAD_STATE, JAVA_DOUBLE a, JAVA_DOUBLE b){
+    // See max(double, double).
+    if(a != a) return a;
+    if(a == 0 && b == 0) return signbit(a) ? a : b;
     if(a < b) return a;
     return b;
 }
 
 JAVA_FLOAT java_lang_Math_min___float_float_R_float(CODENAME_ONE_THREAD_STATE, JAVA_FLOAT a, JAVA_FLOAT b){
+    // See max(double, double).
+    if(a != a) return a;
+    if(a == 0 && b == 0) return signbit(a) ? a : b;
     if(a < b) return a;
     return b;
 }
@@ -2956,7 +2981,7 @@ JAVA_VOID java_lang_System_gcMarkSweep__(CODENAME_ONE_THREAD_STATE) {
     }
 }
 
-JAVA_VOID java_lang_System_exit___int(CODENAME_ONE_THREAD_STATE, JAVA_INT i) {
+JAVA_VOID java_lang_Runtime_exitImpl___int(CODENAME_ONE_THREAD_STATE, JAVA_INT i) {
     exit(i);
 }
 
@@ -3356,8 +3381,21 @@ JAVA_VOID java_lang_Object_wait___long_int(CODENAME_ONE_THREAD_STATE, JAVA_OBJEC
     data->ownerThread = 0;
     data->counter = 0;
 
+    // INTERRUPTION. Publish the object before reading the status, and read the
+    // status with the monitor mutex still held: java_lang_Thread_interrupt0__
+    // stores the status before it reads waitingOn, so either this read sees the
+    // interrupt and the thread never blocks, or the interrupter sees the object
+    // and broadcasts its condition -- which it does only once it holds this mutex
+    // or has seen another thread own the monitor, i.e. once pthread_cond_wait
+    // below has released it. A wakeup can therefore not fall between the check
+    // and the wait. Both sides are sequentially consistent for that argument.
+    __atomic_store_n(&threadStateData->waitingOn, obj, __ATOMIC_SEQ_CST);
+    JAVA_BOOLEAN interruptedBeforeWait = __atomic_load_n(&threadStateData->interrupted, __ATOMIC_SEQ_CST);
+
     int errCode = 0;
-    if(timeout == 0 && nanos == 0) {
+    if(interruptedBeforeWait) {
+        // already interrupted: the JDK throws without waiting
+    } else if(timeout == 0 && nanos == 0) {
         errCode = pthread_cond_wait(&data->__codenameOneCondition, &data->__codenameOneMutex);
         if(errCode != 0) {
             printf("Error with wait %i EINVAL %i, ETIMEDOUT %i, EPERM %i\n", errCode, EINVAL, ETIMEDOUT, EPERM);
@@ -3408,12 +3446,22 @@ + (JAVA_LONG)nanos;
         pthread_cond_timedwait(&data->__codenameOneCondition, &data->__codenameOneMutex, &ts);
     }
 
+    __atomic_store_n(&threadStateData->waitingOn, JAVA_NULL, __ATOMIC_SEQ_CST);
+
     // restore the ownership of the thread
     data->ownerThread = CN1_MONITOR_SELF();
     data->counter = counter;
     
     threadStateData->threadActive = JAVA_TRUE;
     //printf("Waiting on mutex %i with timeout %i finished", (int)obj->__codenameOneMutex, (int)timeout);
+
+    // An interrupted wait throws once the monitor is owned again, and clears
+    // the status, as the JDK's does. The exception comes from Thread so that
+    // this file names no class a translated application might not keep.
+    if(__atomic_load_n(&threadStateData->interrupted, __ATOMIC_SEQ_CST)) {
+        threadStateData->interrupted = JAVA_FALSE;
+        throwException(threadStateData, java_lang_Thread_newInterruptedException___R_java_lang_InterruptedException(threadStateData));
+    }
 }
 
 JAVA_VOID java_lang_Object_notify__(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT obj) {
@@ -3516,11 +3564,10 @@ JAVA_VOID java_lang_Thread_sleepImpl___long(CODENAME_ONE_THREAD_STATE, JAVA_LONG
     // deadline and resume across early wakeups. Chunked below 1s because POSIX
     // allows usleep() to reject arguments >= 1000000 outright (EINVAL on musl),
     // which silently turned long sleeps into no-ops on those libcs.
-    // INTERRUPT SEMANTICS UNCHANGED: this VM has never delivered
-    // InterruptedException from sleep (interrupt() only sets the flag), so the
-    // resume loop deliberately does NOT exit early on it -- waking without the
-    // exception would be a third behavior, neither historical nor Java's.
-    // Proper interrupt delivery is a separate change.
+    // INTERRUPTION: the loop ends as soon as the thread's interrupt status is
+    // set, and Thread.sleep -- the Java caller -- turns that into the
+    // InterruptedException the JDK throws. interrupt0 cannot wake a usleep, so
+    // an interrupt is seen within one chunk; the chunk is 50ms for that reason.
     // Saturate instead of overflowing: Thread.sleep(Long.MAX_VALUE) is a real
     // "park this thread" idiom, and millis * 1000 would wrap negative and make
     // it return immediately.
@@ -3529,12 +3576,15 @@ JAVA_VOID java_lang_Thread_sleepImpl___long(CODENAME_ONE_THREAD_STATE, JAVA_LONG
     JAVA_LONG deltaMicros = (millis > maxMicros / 1000) ? maxMicros : millis * 1000;
     JAVA_LONG deadline = (deltaMicros > maxMicros - now) ? maxMicros : now + deltaMicros;
     for(;;) {
+        if(__atomic_load_n(&threadStateData->interrupted, __ATOMIC_SEQ_CST)) {
+            break;
+        }
         JAVA_LONG remainMicros = deadline - cn1SleepNowMicros();
         if(remainMicros <= 0) {
             break;
         }
-        if(remainMicros > 500000) {
-            remainMicros = 500000;
+        if(remainMicros > 50000) {
+            remainMicros = 50000;
         }
         // JAVA_INT cast, not useconds_t: the MSVC/clang-cl target's cn1_win_compat
         // usleep shim has no useconds_t typedef (same reason the old code cast here)
@@ -3686,16 +3736,56 @@ JAVA_LONG java_lang_Thread_getNativeThreadId___R_long(CODENAME_ONE_THREAD_STATE)
     return currentThreadId();
 }
 
+// Sets the status and, when the thread is in Object.wait, wakes it (the waiter
+// throws InterruptedException; see java_lang_Object_wait___long_int for the
+// ordering argument). Thread.sleep notices the status by itself.
+//
+// The wake broadcasts the waited-on object's condition, which is safe from a
+// lost wakeup only once the waiter has released the monitor mutex inside
+// pthread_cond_wait. That is known when this thread can take the mutex, or when
+// some OTHER thread owns the monitor (it could only have entered after the waiter
+// released it). Neither is ever waited for while holding the critical section:
+// a thread inside synchronized(obj) may itself be about to lock it (starting a
+// thread, say), so blocking on obj's mutex here could deadlock. Hence trylock,
+// and a short back-off with the critical section released, which also keeps the
+// monitor data alive: the waiter clears waitingOn before it returns, and the
+// object cannot be collected while it is still waiting on it.
 JAVA_VOID java_lang_Thread_interrupt0__(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT me) {
-    lockCriticalSection();
-    for(int i=0; i<NUMBER_OF_SUPPORTED_THREADS; i++) {
-        struct ThreadLocalData* d = allThreads[i];
-        if(d && d->currentThreadObject == me) {
-            d->interrupted = JAVA_TRUE;
-            break;
+    for(int attempt = 0 ; ; attempt++) {
+        JAVA_BOOLEAN retry = JAVA_FALSE;
+        lockCriticalSection();
+        for(int i=0; i<NUMBER_OF_SUPPORTED_THREADS; i++) {
+            struct ThreadLocalData* d = allThreads[i];
+            if(d && d->currentThreadObject == me) {
+                __atomic_store_n(&d->interrupted, JAVA_TRUE, __ATOMIC_SEQ_CST);
+                JAVA_OBJECT waitingOn = __atomic_load_n(&d->waitingOn, __ATOMIC_SEQ_CST);
+                if(waitingOn != JAVA_NULL && d != threadStateData) {
+                    struct CN1ThreadData* data = (struct CN1ThreadData*)cn1MonitorDataGet(waitingOn);
+                    if(data != 0) {
+                        if(pthread_mutex_trylock(&data->__codenameOneMutex) == 0) {
+                            pthread_cond_broadcast(&data->__codenameOneCondition);
+                            pthread_mutex_unlock(&data->__codenameOneMutex);
+                        } else if(data->ownerThread != 0 || attempt >= 2000) {
+                            // Another thread owns the monitor, so the waiter is
+                            // inside pthread_cond_wait (or already awake). The
+                            // attempt bound is a last resort that cannot be
+                            // reached by the protocol: every holder of the mutex
+                            // with no owner recorded is between two statements.
+                            pthread_cond_broadcast(&data->__codenameOneCondition);
+                        } else {
+                            retry = JAVA_TRUE;
+                        }
+                    }
+                }
+                break;
+            }
         }
+        unlockCriticalSection();
+        if(!retry) {
+            return;
+        }
+        usleep(50);
     }
-    unlockCriticalSection();
 }
 
 JAVA_BOOLEAN java_lang_Thread_isInterrupted___boolean_R_boolean(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT me, JAVA_BOOLEAN clear) {
@@ -3724,48 +3814,29 @@ JAVA_DOUBLE java_lang_StringToReal_parseDblImpl___java_lang_String_int_R_double(
     int length = java_lang_String_length___R_int(threadStateData, s);
     JAVA_ARRAY arrayData = (JAVA_ARRAY)java_lang_String_toCharNoCopy___R_char_1ARRAY(threadStateData, s);
     JAVA_ARRAY_CHAR* chrs = CN1_ARRAY_DATA(arrayData);
-    char data[length + 1];
+    // The exponent is handed to strtod with the digits, so the value is
+    // rounded once, correctly, and strtod itself answers HUGE_VAL or 0 past
+    // the range. Scaling afterwards rounded at every step and, for a positive
+    // exponent past 18, DIVIDED by ten where it meant to multiply: 1e40 parsed
+    // as 1.0E-4 and 1.5E400 as 0.0. The digits are ASCII only (StringToReal
+    // has already taken off the sign, the point and the exponent), so the
+    // locale's decimal separator never matters here. Issue #3250 (a long
+    // accumulator overflowing past 18 digits) cannot recur: there is none.
+    char data[length + 16];
     for(int iter = 0 ; iter < length ; iter++) {
         data[iter] = (char)chrs[iter];
     }
     data[length] = 0;
     char *err;
-    JAVA_DOUBLE db = strtod(data, &err);
+    strtod(data, &err);
     if (data == err) {
         JAVA_OBJECT numberFormatException = java_lang_StringToReal_invalidReal___java_lang_String_boolean_R_java_lang_NumberFormatException(threadStateData, s, JAVA_TRUE);
         throwException(threadStateData,numberFormatException);
     }
-    JAVA_LONG exp = 1;
     if(e != 0) {
-        if(e < 0) {
-            while (e < -18) {
-                // Long accumulator will overflow past 18 digits so we do
-                // floating point math until we get there.
-                // fixes https://github.com/codenameone/CodenameOne/issues/3250
-                e++;
-                db /= 10;
-            }
-            while(e < 0) {
-                e++;
-                exp *= 10;
-            }
-            db /= exp;
-        } else {
-            while (e > 18) {
-                // Long accumulator will overflow past 18 digits so we do
-                // floating point math until we get there.
-                // fixes https://github.com/codenameone/CodenameOne/issues/3250
-                e--;
-                db /= 10;
-            }
-            while(e > 0) {
-                e--;
-                exp *= 10;
-            }
-            db *= exp;
-        }
+        snprintf(data + length, 16, "e%d", (int)e);
     }
-    return db;
+    return strtod(data, NULL);
 }
 
 void initMethodStack(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT __cn1ThisObject, int stackSize, int localsStackSize, int classNameId, int methodNameId) {
@@ -4843,11 +4914,36 @@ static long long cn1WinUtcMillis(int year, int month, int day, int millisOfDay)
     int result;
 } cn1_timezone_offset_ctx;
 
+/* Past the last transition a zone repeats its recurring rule forever, and
+ * the Gregorian calendar repeats every 400 years (146097 days, a whole
+ * number of weeks), so a far-future instant has the offset of its
+ * counterpart in 2400-2799. The JDK answers that, and so does macOS's libc,
+ * but glibc answers standard time for distant years: the year 81190086
+ * resolved to EST in July. Folding first makes every libc answer the same. */
+#define CN1_TZ_FOLD_FROM_YEAR 2400
+#define CN1_TZ_FOLD_CYCLE_SECONDS (146097LL * 86400LL)
+#define CN1_TZ_FOLD_FROM_SECONDS 13569465600LL /* 2400-01-01T00:00Z */
+
+static int cn1_fold_timezone_year(int year) {
+    if (year >= CN1_TZ_FOLD_FROM_YEAR + 400) {
+        return CN1_TZ_FOLD_FROM_YEAR + (year - CN1_TZ_FOLD_FROM_YEAR) % 400;
+    }
+    return year;
+}
+
+static long long cn1_fold_timezone_seconds(long long seconds) {
+    if (seconds >= CN1_TZ_FOLD_FROM_SECONDS + CN1_TZ_FOLD_CYCLE_SECONDS) {
+        return CN1_TZ_FOLD_FROM_SECONDS
+                + (seconds - CN1_TZ_FOLD_FROM_SECONDS) % CN1_TZ_FOLD_CYCLE_SECONDS;
+    }
+    return seconds;
+}
+
 static void cn1_compute_timezone_offset(void* data) {
     cn1_timezone_offset_ctx* ctx = (cn1_timezone_offset_ctx*)data;
     struct tm utc;
     memset(&utc, 0, sizeof(utc));
-    utc.tm_year = ctx->year - 1900;
+    utc.tm_year = cn1_fold_timezone_year(ctx->year) - 1900;
     utc.tm_mon = ctx->month - 1;
     utc.tm_mday = ctx->day;
     utc.tm_hour = ctx->millis / 3600000;
@@ -4871,7 +4967,7 @@ static void cn1_compute_timezone_offset(void* data) {
 
 static void cn1_compute_timezone_dst(void* data) {
     cn1_timezone_dst_ctx* ctx = (cn1_timezone_dst_ctx*)data;
-    time_t epoch = (time_t)(ctx->millis / 1000LL);
+    time_t epoch = (time_t)cn1_fold_timezone_seconds(ctx->millis / 1000LL);
     struct tm resolved;
     localtime_r(&epoch, &resolved);
     ctx->result = resolved.tm_isdst > 0 ? JAVA_TRUE : JAVA_FALSE;
diff --git a/vm/CLAUDE.md b/vm/CLAUDE.md
index 8ea49b1d67f..2dd03985497 100644
--- a/vm/CLAUDE.md
+++ b/vm/CLAUDE.md
@@ -358,7 +358,8 @@ assertion an assertion about nothing.
 The translator reads class files with its own `classfile` package (reader, tree,
 frame analysis, `JsrInliner`) and its JavaScript backend uses its own `regex`
 engine, `Sha256` and `java.io` -- because it compiles against `vm/JavaAPI`, which
-has no ASM, `java.util.regex` (a stub that throws), `java.security` or
+has no ASM, `java.util.regex` (none at all -- desktop code's regex is relocated
+to `com.codename1.util.regex`), `java.security` or
 `java.nio.file`. Do not reintroduce any of them into
 `vm/ByteCodeTranslator/src`: `vm/selfhost/build-selfhost.sh` compiles the sources
 against JavaAPI alone and fails, and an API JavaAPI only *stubs* compiles fine and
diff --git a/vm/JavaAPI/src/com/codename1/impl/JdkHost.java b/vm/JavaAPI/src/com/codename1/impl/JdkHost.java
new file mode 100644
index 00000000000..ae07bd506c4
--- /dev/null
+++ b/vm/JavaAPI/src/com/codename1/impl/JdkHost.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+/// The services the Java class library asks of the platform it runs on.
+///
+/// Internal API. The `java.*` classes of the ParparVM runtime (`vm/JavaAPI`)
+/// need a file system, preferences, the network, a log and an event thread,
+/// and on a device those belong to Codename One, which the class library
+/// cannot name: it is translated alone for the translator itself, the backend
+/// and the VM tests. So the class library calls this class, and whoever runs
+/// it installs the implementation that fits:
+///
+/// - a Codename One application gets `com.codename1.impl.CoreJdkHost`, which
+///   delegates to `FileSystemStorage`, `Preferences`, `NetworkManager`, `Log`
+///   and `Display`. The ParparVM ports install it from their `init`.
+/// - a program translated without Codename One (the self-hosted translator,
+///   the backend, a VM test) gets `PosixJdkHost`, which reaches the POSIX file
+///   natives through `java.io.File`.
+/// - anything else gets the defaults below, which are plain Java and touch no
+///   native method, so an application target that never installs a host
+///   cannot link the file natives through this class.
+///
+/// On Java SE and Android the real JDK runs and nothing calls this class.
+/// Copies of it ship in those ports only so that `CoreJdkHost`, which is part
+/// of the core sources, always has its superclass.
+///
+/// The file is kept byte for byte identical in `vm/JavaAPI`, `Ports/CLDC11`,
+/// `Ports/JavaSE` and `Ports/Android`; `CldcJavaApiParityTest` holds them
+/// to that. It may use only API all four class libraries have.
+///
+/// Paths are in the host's own form: absolute, as [#appHome] answers them.
+/// Turning a relative path into one is the caller's job.
+public abstract class JdkHost {
+    /// [#log] level of a debug message.
+    public static final int LOG_DEBUG = 1;
+    /// [#log] level of an informational message.
+    public static final int LOG_INFO = 2;
+    /// [#log] level of a warning.
+    public static final int LOG_WARNING = 3;
+    /// [#log] level of an error.
+    public static final int LOG_ERROR = 4;
+
+    private static final JdkHost DEFAULTS = new Defaults();
+    private static JdkHost current;
+    private static Registry registry;
+    private static Map<String, String> memoryPreferences;
+
+    /// Subclasses are installed with [#install].
+    protected JdkHost() {
+    }
+
+    /// The installed host, or the plain Java defaults when none was installed.
+    public static JdkHost get() {
+        JdkHost h = current;
+        return h == null ? DEFAULTS : h;
+    }
+
+    /// Makes `host` the one [#get] answers; null restores the defaults.
+    /// Called once, while the program starts and before it starts a thread
+    /// of its own.
+    public static void install(JdkHost host) {
+        current = host;
+    }
+
+    /// Makes `r` the registry [#providers] and [#newInstance] read. An
+    /// application's generated start-up code installs it.
+    public static void setRegistry(Registry r) {
+        registry = r;
+    }
+
+    /// The registry [#setRegistry] installed, or null.
+    public static Registry getRegistry() {
+        return registry;
+    }
+
+    // ------------------------------------------------------------------
+    // Files
+
+    /// What is known of `path`, or null when nothing is there.
+    public FileStat fileStat(String path) {
+        return null;
+    }
+
+    /// The names of the entries of the directory `path`, or null when it is
+    /// not a directory.
+    public String[] fileList(String path) throws IOException {
+        return null;
+    }
+
+    /// Opens the file `path` for reading.
+    public InputStream fileRead(String path) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Opens the file `path` for writing, at its end when `append` is true
+    /// and from empty otherwise, creating it when it is not there.
+    public OutputStream fileWrite(String path, boolean append) throws IOException {
+        throw new IOException("No file system: " + path);
+    }
+
+    /// Creates the directory `path`; false when it was not created, also
+    /// when something was there already.
+    public boolean fileMkdir(String path) {
+        return false;
+    }
+
+    /// Deletes the file or empty directory `path`; false when it is still
+    /// there or never was.
+    public boolean fileDelete(String path) {
+        return false;
+    }
+
+    /// Moves `from` to `to`, which must not exist. False when it did not
+    /// happen; a host may refuse a move to another directory, and the
+    /// caller then copies.
+    public boolean fileRename(String from, String to) {
+        return false;
+    }
+
+    /// The application's home directory, where a relative path resolves.
+    public String appHome() {
+        return "/";
+    }
+
+    /// A directory for disposable files, or null when the platform has no
+    /// separate one and [#appHome] serves.
+    public String cachesDir() {
+        return null;
+    }
+
+    /// The roots of the file system.
+    public String[] fileRoots() {
+        return new String[] {appHome()};
+    }
+
+    /// The size in bytes of the volume holding `path`, or 0 when unknown.
+    public long fileTotalSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes still free for this program on the volume holding `path`,
+    /// or 0 when unknown.
+    public long fileUsableSpace(String path) {
+        return 0L;
+    }
+
+    /// The bytes free on the volume holding `path`, counting what only a
+    /// privileged user may use; [#fileUsableSpace] unless the host knows
+    /// better.
+    public long fileFreeSpace(String path) {
+        return fileUsableSpace(path);
+    }
+
+    /// [#fileTest]: something is at the path.
+    public static final int FILE_EXISTS = 1;
+    /// [#fileTest]: the path is a directory.
+    public static final int FILE_DIRECTORY = 2;
+    /// [#fileTest]: the path is a file that is not a directory.
+    public static final int FILE_REGULAR = 3;
+    /// [#fileTest] and [#fileSet]: the path may be read.
+    public static final int FILE_READABLE = 4;
+    /// [#fileTest] and [#fileSet]: the path may be written.
+    public static final int FILE_WRITABLE = 5;
+    /// [#fileTest] and [#fileSet]: the path may be executed, or for a
+    /// directory, entered.
+    public static final int FILE_EXECUTABLE = 6;
+    /// [#fileTest]: the path is hidden.
+    public static final int FILE_HIDDEN = 7;
+
+    /// Whether `path` has the property `what`, one of the `FILE_` constants.
+    ///
+    /// The defaults read [#fileStat]: a file system without permissions lets
+    /// everything that exists be read and written, a directory be entered and
+    /// nothing be run, and hides a name that starts with a dot.
+    public boolean fileTest(String path, int what) {
+        if (what == FILE_HIDDEN) {
+            int slash = path.lastIndexOf('/');
+            return path.startsWith(".", slash + 1);
+        }
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_DIRECTORY || what == FILE_EXECUTABLE) {
+            return st.isDirectory();
+        }
+        if (what == FILE_REGULAR) {
+            return !st.isDirectory();
+        }
+        return true;
+    }
+
+    /// Grants (`on`) or takes away the permission `what` on `path`, one of
+    /// [#FILE_READABLE], [#FILE_WRITABLE] and [#FILE_EXECUTABLE]; false when
+    /// the path is not left that way.
+    ///
+    /// The defaults change nothing, so they answer whether the path already is
+    /// as asked, by the rules of [#fileTest].
+    public boolean fileSet(String path, int what, boolean on) {
+        FileStat st = fileStat(path);
+        if (st == null) {
+            return false;
+        }
+        if (what == FILE_EXECUTABLE) {
+            return on == st.isDirectory();
+        }
+        return on;
+    }
+
+    /// The length in bytes of the file `path`; 0 for a directory or when
+    /// nothing is there.
+    public long fileLength(String path) {
+        FileStat st = fileStat(path);
+        return st == null || st.isDirectory() ? 0L : st.length();
+    }
+
+    /// When `path` was last modified, in milliseconds since the epoch; 0 when
+    /// nothing is there.
+    public long fileLastModified(String path) {
+        FileStat st = fileStat(path);
+        return st == null ? 0L : st.lastModified();
+    }
+
+    /// Creates the empty file `path` when nothing is there; false when
+    /// something was.
+    ///
+    /// The default checks and then creates, which is not atomic: two threads
+    /// racing on one path can both be answered true.
+    public boolean fileCreate(String path) throws IOException {
+        if (fileStat(path) != null) {
+            return false;
+        }
+        fileWrite(path, false).close();
+        return true;
+    }
+
+    /// Moves `from` over `to`, replacing the file there. False when it did not
+    /// happen, which is all the defaults answer; the caller then copies.
+    public boolean fileReplace(String from, String to) {
+        return false;
+    }
+
+    /// The absolute `path` with symbolic links, `.` and `..` resolved, or
+    /// null when the host cannot resolve links and the caller should resolve
+    /// the dots by itself.
+    public String fileCanonicalPath(String path) throws IOException {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Preferences
+
+    /// The stored preference `key`, or null. The defaults keep preferences
+    /// in memory, for this run only.
+    public String preference(String key) {
+        return memoryPreference(key, null, false);
+    }
+
+    /// Stores `value` under `key`.
+    public void setPreference(String key, String value) {
+        memoryPreference(key, value, true);
+    }
+
+    /// Removes the preference `key`.
+    public void deletePreference(String key) {
+        memoryPreference(key, null, true);
+    }
+
+    /// Reads `key` from the in-memory preferences, or, when `write` is true,
+    /// stores `value` there (null removes it). One lock: the class library
+    /// runs on several threads where a host leaves this to the defaults.
+    private static synchronized String memoryPreference(String key, String value, boolean write) {
+        if (memoryPreferences == null) {
+            memoryPreferences = new HashMap<String, String>();
+        }
+        if (!write) {
+            return memoryPreferences.get(key);
+        }
+        if (value == null) {
+            return memoryPreferences.remove(key);
+        }
+        return memoryPreferences.put(key, value);
+    }
+
+    // ------------------------------------------------------------------
+    // Network, log and process
+
+    /// Reads `url` with an HTTP GET. A missing resource (404, 410) throws
+    /// `java.io.FileNotFoundException`, any other failure an `IOException`.
+    public InputStream openUrl(String url) throws IOException {
+        throw new IOException("No network: " + url);
+    }
+
+    /// Logs `message` and `thrown`, either of which may be null, at `level`
+    /// ([#LOG_DEBUG] to [#LOG_ERROR]).
+    public void log(int level, String message, Throwable thrown) {
+        if (message != null) {
+            System.err.println(message);
+        }
+        if (thrown != null) {
+            thrown.printStackTrace();
+        }
+    }
+
+    /// The platform's answer for the system property `key`, or null. The
+    /// class library answers the properties it defines itself.
+    public String property(String key) {
+        return null;
+    }
+
+    /// Asks the platform to close the application, after the shutdown hooks
+    /// ran; `Runtime.exit` ends the process itself if this returns. The
+    /// defaults leave it to that.
+    public void exit(int status) {
+    }
+
+    /// Called when the program installs a default uncaught exception
+    /// handler, so that a host whose UI thread catches what its tasks throw
+    /// can hand that to `Thread.getDefaultUncaughtExceptionHandler()` too.
+    /// Called on every such install; the defaults do nothing.
+    public void watchUncaughtExceptions() {
+    }
+
+    // ------------------------------------------------------------------
+    // Threads
+
+    /// Whether the caller is the UI thread, which must not block.
+    public boolean isUiThread() {
+        return false;
+    }
+
+    /// Runs `task`, which blocks, where blocking is allowed: off the UI
+    /// thread while that thread keeps serving events, or right here.
+    public void blockUi(Runnable task) {
+        task.run();
+    }
+
+    // ------------------------------------------------------------------
+    // Resources, services and locale
+
+    /// Opens the application resource `name` (a path such as
+    /// `META-INF/services/x`, without a leading slash), or null.
+    public InputStream resource(String name) {
+        return null;
+    }
+
+    /// The class names of the providers of `service` the application
+    /// declares, from the [Registry]; empty when there is none.
+    public String[] providers(String service) {
+        Registry r = registry;
+        String[] names = r == null ? null : r.providers(service);
+        return names == null ? new String[0] : names;
+    }
+
+    /// A new instance of the application class `className`, made by the
+    /// [Registry] without reflection; null when it cannot make one.
+    public Object newInstance(String className) {
+        Registry r = registry;
+        return r == null ? null : r.newInstance(className);
+    }
+
+    /// The class of the application class `className`, as the [Registry]
+    /// knows it, so that its type can be tested without creating one; null
+    /// when it does not know the class.
+    public Class<?> type(String className) {
+        Registry r = registry;
+        return r == null ? null : r.type(className);
+    }
+
+    /// The decimal separator, grouping separator and currency symbol of the
+    /// device's locale, any of them null when unknown; or null when the
+    /// platform cannot tell.
+    public String[] localeNumberSymbols() {
+        return null;
+    }
+
+    // ------------------------------------------------------------------
+    // Security
+
+    /// Fills `out` with cryptographically secure random bytes.
+    public void randomBytes(byte[] out) {
+        throw new UnsupportedOperationException("No secure random source");
+    }
+
+    /// A new digest for `algorithm` (`MD5`, `SHA-1`, `SHA-256` and the like),
+    /// or null when the platform has none.
+    public Digest digest(String algorithm) {
+        return null;
+    }
+
+    /// The attributes [#fileStat] reports.
+    public static final class FileStat {
+        private final boolean directory;
+        private final long length;
+        private final long lastModified;
+
+        /// A file or, when `directory` is true, a directory.
+        public FileStat(boolean directory, long length, long lastModified) {
+            this.directory = directory;
+            this.length = length;
+            this.lastModified = lastModified;
+        }
+
+        /// Whether it is a directory.
+        public boolean isDirectory() {
+            return directory;
+        }
+
+        /// The length in bytes of a file; 0 for a directory.
+        public long length() {
+            return length;
+        }
+
+        /// When it was last modified, in milliseconds since the epoch, or 0.
+        public long lastModified() {
+            return lastModified;
+        }
+    }
+
+    /// A running message digest, as [#digest] makes it.
+    public interface Digest {
+        /// Feeds `length` bytes of `data` from `offset`.
+        void update(byte[] data, int offset, int length);
+
+        /// Finishes the digest and resets it.
+        byte[] digest();
+
+        /// Discards what was fed.
+        void reset();
+
+        /// The length of the digest in bytes.
+        int length();
+    }
+
+    /// What an application declares for `java.util.ServiceLoader` and
+    /// `java.util.ResourceBundle`, generated with the application. Once one
+    /// is installed it is the whole answer: the class library creates no
+    /// class from its name and reads no services file.
+    public interface Registry {
+        /// The provider class names declared for `service`, or null.
+        String[] providers(String service);
+
+        /// A new instance of `className`, or null.
+        Object newInstance(String className);
+
+        /// The class `className`, or null when the registry does not know it.
+        Class<?> type(String className);
+    }
+
+    /// The host [#get] answers when none was installed.
+    private static final class Defaults extends JdkHost {
+    }
+}
diff --git a/vm/JavaAPI/src/com/codename1/impl/PosixJdkHost.java b/vm/JavaAPI/src/com/codename1/impl/PosixJdkHost.java
new file mode 100644
index 00000000000..99e6d91d08e
--- /dev/null
+++ b/vm/JavaAPI/src/com/codename1/impl/PosixJdkHost.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.impl;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PosixFileAccess;
+
+/// The [JdkHost] of a program translated without Codename One -- the
+/// self-hosted translator, the backend, a VM test -- over the native file
+/// system.
+///
+/// It reaches the file natives through `java.io.PosixFileAccess`, never
+/// through `java.io.File` or the file streams, which themselves go through
+/// the installed host. Only such a program installs it: an application never
+/// names this class, so the translator's reachability keeps those natives out
+/// of watch, TV and JavaScript builds, which do not link them. Installed with
+/// `JdkHost.install(new PosixJdkHost())` from the program's own start-up;
+/// without it `java.io.File` sees the empty file system of the defaults.
+///
+/// Preferences stay the in-memory defaults; a program that needs them kept
+/// stores them itself.
+public class PosixJdkHost extends JdkHost {
+    @Override
+    public FileStat fileStat(String path) {
+        if (!PosixFileAccess.exists(path)) {
+            return null;
+        }
+        boolean directory = PosixFileAccess.isDirectory(path);
+        return new FileStat(directory, directory ? 0L : PosixFileAccess.length(path),
+                PosixFileAccess.lastModified(path));
+    }
+
+    @Override
+    public String[] fileList(String path) throws IOException {
+        return PosixFileAccess.isDirectory(path) ? PosixFileAccess.list(path) : null;
+    }
+
+    @Override
+    public InputStream fileRead(String path) throws IOException {
+        if (PosixFileAccess.isDirectory(path)) {
+            throw new FileNotFoundException(path + " (Is a directory)");
+        }
+        return PosixFileAccess.openRead(path);
+    }
+
+    @Override
+    public OutputStream fileWrite(String path, boolean append) throws IOException {
+        if (PosixFileAccess.isDirectory(path)) {
+            throw new FileNotFoundException(path + " (Is a directory)");
+        }
+        return PosixFileAccess.openWrite(path, append);
+    }
+
+    @Override
+    public boolean fileMkdir(String path) {
+        return PosixFileAccess.mkdir(path);
+    }
+
+    @Override
+    public boolean fileDelete(String path) {
+        return PosixFileAccess.delete(path);
+    }
+
+    @Override
+    public boolean fileRename(String from, String to) {
+        // rename(2) replaces an existing destination; this contract does not.
+        return !PosixFileAccess.exists(to) && PosixFileAccess.rename(from, to);
+    }
+
+    @Override
+    public boolean fileReplace(String from, String to) {
+        return PosixFileAccess.rename(from, to);
+    }
+
+    @Override
+    public boolean fileTest(String path, int what) {
+        switch (what) {
+            case FILE_EXISTS:
+                return PosixFileAccess.exists(path);
+            case FILE_DIRECTORY:
+                return PosixFileAccess.isDirectory(path);
+            case FILE_REGULAR:
+                return PosixFileAccess.isFile(path);
+            case FILE_READABLE:
+                return PosixFileAccess.canRead(path);
+            case FILE_WRITABLE:
+                return PosixFileAccess.canWrite(path);
+            case FILE_EXECUTABLE:
+                return PosixFileAccess.canExecute(path);
+            case FILE_HIDDEN:
+                return PosixFileAccess.isHidden(path);
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public boolean fileSet(String path, int what, boolean on) {
+        switch (what) {
+            case FILE_READABLE:
+                return PosixFileAccess.setReadable(path, on);
+            case FILE_WRITABLE:
+                return PosixFileAccess.setWritable(path, on);
+            case FILE_EXECUTABLE:
+                return PosixFileAccess.setExecutable(path, on);
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public long fileLength(String path) {
+        return PosixFileAccess.length(path);
+    }
+
+    @Override
+    public long fileLastModified(String path) {
+        return PosixFileAccess.lastModified(path);
+    }
+
+    /// Atomic: the native creates with `O_CREAT | O_EXCL`.
+    @Override
+    public boolean fileCreate(String path) throws IOException {
+        return PosixFileAccess.createNewFile(path);
+    }
+
+    @Override
+    public String fileCanonicalPath(String path) throws IOException {
+        return PosixFileAccess.canonicalPath(path);
+    }
+
+    @Override
+    public String appHome() {
+        // The working directory. Resolving "." and dropping the "." keeps it
+        // independent of whether a target's native also normalizes the path.
+        String abs = PosixFileAccess.absolutePath(".");
+        if (abs.endsWith("/.") || abs.endsWith("\\.")) {
+            abs = abs.substring(0, abs.length() - 2);
+        }
+        return abs.length() == 0 || ".".equals(abs) ? "/" : abs;
+    }
+
+    /// `/tmp`. Not the `java.io.tmpdir` property: `System` answers that
+    /// property from this method, so reading it here would ask itself.
+    /// `TMPDIR` is honoured when the environment sets it.
+    @Override
+    public String cachesDir() {
+        String tmp = System.getenv("TMPDIR");
+        return tmp == null || tmp.length() == 0 ? "/tmp" : tmp;
+    }
+
+    @Override
+    public String[] fileRoots() {
+        return new String[] {"/"};
+    }
+
+    @Override
+    public long fileTotalSpace(String path) {
+        return PosixFileAccess.totalSpace(path);
+    }
+
+    @Override
+    public long fileUsableSpace(String path) {
+        return PosixFileAccess.usableSpace(path);
+    }
+
+    @Override
+    public long fileFreeSpace(String path) {
+        return PosixFileAccess.freeSpace(path);
+    }
+
+    /// Reads `/dev/urandom`, which every POSIX system the translator and the
+    /// backend run on provides.
+    @Override
+    public void randomBytes(byte[] out) {
+        try {
+            InputStream in = PosixFileAccess.openRead("/dev/urandom");
+            try {
+                int off = 0;
+                while (off < out.length) {
+                    int n = in.read(out, off, out.length - off);
+                    if (n < 0) {
+                        throw new IllegalStateException("/dev/urandom ended");
+                    }
+                    off += n;
+                }
+            } finally {
+                in.close();
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("No secure random source: " + e.getMessage());
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/com/codename1/impl/time/TimeZoneSupport.java b/vm/JavaAPI/src/com/codename1/impl/time/TimeZoneSupport.java
deleted file mode 100644
index bc3f15f467e..00000000000
--- a/vm/JavaAPI/src/com/codename1/impl/time/TimeZoneSupport.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package com.codename1.impl.time;
-
-import java.time.ZoneId;
-import java.time.ZoneOffset;
-import java.util.TimeZone;
-
-public final class TimeZoneSupport {
-    private TimeZoneSupport() {
-    }
-
-    public static TimeZone toTimeZone(ZoneId zoneId) {
-        if (zoneId instanceof ZoneOffset) {
-            ZoneOffset offset = (ZoneOffset) zoneId;
-            return TimeZone.getTimeZone(offset.getId().equals("Z") ? "GMT" : "GMT" + offset.getId());
-        }
-        return TimeZone.getTimeZone(zoneId.getId());
-    }
-}
diff --git a/vm/JavaAPI/src/java/io/BufferedInputStream.java b/vm/JavaAPI/src/java/io/BufferedInputStream.java
new file mode 100644
index 00000000000..6c7efca43ef
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/BufferedInputStream.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Reads from another stream through a buffer, so that many small reads
+/// become few large ones, and supports `mark` and `reset`.
+///
+/// Like most streams, it is for one thread at a time.
+public class BufferedInputStream extends FilterInputStream {
+
+    /// The buffer; null once the stream is closed, which every read checks.
+    protected byte[] buf;
+    /// How many bytes of [#buf] are valid.
+    protected int count;
+    /// The index in [#buf] of the next byte to read.
+    protected int pos;
+    /// The index in [#buf] of the mark, or -1 when there is none.
+    protected int markpos = -1;
+    /// How far past the mark a read may go before the mark is dropped.
+    protected int marklimit;
+
+    /// Buffers `in` with an 8192 byte buffer.
+    public BufferedInputStream(InputStream in) {
+        this(in, 8192);
+    }
+
+    /// Buffers `in` with a buffer of `size` bytes.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
+    public BufferedInputStream(InputStream in, int size) {
+        super(in);
+        if (size <= 0) {
+            throw new IllegalArgumentException("Buffer size <= 0");
+        }
+        buf = new byte[size];
+    }
+
+    private void ensureOpen() throws IOException {
+        if (buf == null) {
+            throw new IOException("Stream closed");
+        }
+    }
+
+    /// Refills the buffer once it is consumed, keeping the bytes from a
+    /// valid mark on and growing the buffer up to the mark limit.
+    private void fill() throws IOException {
+        if (markpos < 0) {
+            pos = 0;
+        } else if (pos >= buf.length) {
+            if (markpos > 0) {
+                int keep = pos - markpos;
+                System.arraycopy(buf, markpos, buf, 0, keep);
+                pos = keep;
+                markpos = 0;
+            } else if (buf.length >= marklimit) {
+                markpos = -1;
+                pos = 0;
+            } else {
+                int grownSize = buf.length * 2;
+                if (grownSize > marklimit) {
+                    grownSize = marklimit;
+                }
+                if (grownSize <= buf.length) {
+                    grownSize = buf.length + 1;
+                }
+                byte[] grown = new byte[grownSize];
+                System.arraycopy(buf, 0, grown, 0, pos);
+                buf = grown;
+            }
+        }
+        count = pos;
+        int n = in.read(buf, pos, buf.length - pos);
+        if (n > 0) {
+            count = n + pos;
+        }
+    }
+
+    @Override
+    public int read() throws IOException {
+        ensureOpen();
+        if (pos >= count) {
+            fill();
+            if (pos >= count) {
+                return -1;
+            }
+        }
+        return buf[pos++] & 0xff;
+    }
+
+    /// Reads as the JDK does: on past the buffer while the stream underneath
+    /// has bytes available without blocking, so a small buffer does not make
+    /// every read a short one.
+    @Override
+    public int read(byte[] b, int off, int len) throws IOException {
+        ensureOpen();
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (len == 0) {
+            return 0;
+        }
+        int total = 0;
+        while (true) {
+            int n = readOnce(b, off + total, len - total);
+            if (n <= 0) {
+                return total == 0 ? n : total;
+            }
+            total += n;
+            if (total >= len) {
+                return total;
+            }
+            InputStream input = in;
+            if (input != null && input.available() <= 0) {
+                return total;
+            }
+        }
+    }
+
+    private int readOnce(byte[] b, int off, int len) throws IOException {
+        int avail = count - pos;
+        if (avail <= 0) {
+            if (len >= buf.length && markpos < 0) {
+                return in.read(b, off, len);
+            }
+            fill();
+            avail = count - pos;
+            if (avail <= 0) {
+                return -1;
+            }
+        }
+        int n = avail < len ? avail : len;
+        System.arraycopy(buf, pos, b, off, n);
+        pos += n;
+        return n;
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        ensureOpen();
+        if (n <= 0) {
+            return 0;
+        }
+        long avail = count - pos;
+        if (avail <= 0) {
+            if (markpos < 0) {
+                return in.skip(n);
+            }
+            fill();
+            avail = count - pos;
+            if (avail <= 0) {
+                return 0;
+            }
+        }
+        long skipped = avail < n ? avail : n;
+        pos += (int) skipped;
+        return skipped;
+    }
+
+    @Override
+    public int available() throws IOException {
+        ensureOpen();
+        return (count - pos) + in.available();
+    }
+
+    @Override
+    public void mark(int readlimit) {
+        marklimit = readlimit;
+        markpos = pos;
+    }
+
+    @Override
+    public void reset() throws IOException {
+        ensureOpen();
+        if (markpos < 0) {
+            throw new IOException("Resetting to invalid mark");
+        }
+        pos = markpos;
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (buf == null) {
+            return;
+        }
+        buf = null;
+        in.close();
+    }
+
+    @Override
+    public boolean markSupported() {
+        return true;
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/BufferedOutputStream.java b/vm/JavaAPI/src/java/io/BufferedOutputStream.java
new file mode 100644
index 00000000000..7494991e8e4
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/BufferedOutputStream.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Writes to another stream through a buffer, so that many small writes
+/// become few large ones.
+public class BufferedOutputStream extends FilterOutputStream {
+
+    /// The buffer.
+    protected byte[] buf;
+    /// How many bytes of [#buf] are waiting to be written.
+    protected int count;
+    /// Set by [#close()]. The buffer and the underlying stream are kept, so
+    /// without it a later write would land in the buffer and a second close
+    /// could hand those bytes to a stream whose own close is a no-op.
+    private boolean closed;
+
+    /// Buffers `out` with an 8192 byte buffer.
+    public BufferedOutputStream(OutputStream out) {
+        this(out, 8192);
+    }
+
+    /// Buffers `out` with a buffer of `size` bytes.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
+    public BufferedOutputStream(OutputStream out, int size) {
+        super(out);
+        if (size <= 0) {
+            throw new IllegalArgumentException("Buffer size <= 0");
+        }
+        buf = new byte[size];
+    }
+
+    private void ensureOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
+    }
+
+    private void flushBuffer() throws IOException {
+        if (count > 0) {
+            out.write(buf, 0, count);
+            count = 0;
+        }
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+        ensureOpen();
+        if (count >= buf.length) {
+            flushBuffer();
+        }
+        buf[count++] = (byte) b;
+    }
+
+    @Override
+    public void write(byte[] b, int off, int len) throws IOException {
+        ensureOpen();
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (len >= buf.length) {
+            flushBuffer();
+            out.write(b, off, len);
+            return;
+        }
+        if (len > buf.length - count) {
+            flushBuffer();
+        }
+        System.arraycopy(b, off, buf, count, len);
+        count += len;
+    }
+
+    @Override
+    public void flush() throws IOException {
+        ensureOpen();
+        flushBuffer();
+        out.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        try {
+            flush();
+        } finally {
+            closed = true;
+            count = 0;
+            out.close();
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/BufferedReader.java b/vm/JavaAPI/src/java/io/BufferedReader.java
new file mode 100644
index 00000000000..c3d0ccc494c
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/BufferedReader.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Reads text from another reader through a buffer, and reads it a line at
+/// a time. A line ends at `\n`, `\r` or `\r\n`.
+///
+/// Like most readers, it is for one thread at a time.
+public class BufferedReader extends Reader {
+
+    private static final int UNMARKED = -1;
+    private static final int INVALIDATED = -2;
+
+    private final Reader in;
+    /// Null once the reader is closed, which every operation checks.
+    private char[] buf;
+    private int pos;
+    private int count;
+    private boolean skipLf;
+    /// Index in `buf` of the marked character, or `UNMARKED`/`INVALIDATED`.
+    private int markedChar = UNMARKED;
+    private int readAheadLimit;
+    private boolean markedSkipLf;
+
+    /// Buffers `in` with an 8192 character buffer.
+    public BufferedReader(Reader in) {
+        this(in, 8192);
+    }
+
+    /// Buffers `in` with a buffer of `size` characters.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
+    public BufferedReader(Reader in, int size) {
+        super(in);
+        if (size <= 0) {
+            throw new IllegalArgumentException("Buffer size <= 0");
+        }
+        this.in = in;
+        this.buf = new char[size];
+    }
+
+    private void ensureOpen() throws IOException {
+        if (buf == null) {
+            throw new IOException("Stream closed");
+        }
+    }
+
+    /// Refills the buffer once it is consumed. A valid mark keeps the
+    /// characters from the mark on at the start of the buffer, growing it up
+    /// to the read-ahead limit; reading past that limit drops the mark.
+    private boolean fill() throws IOException {
+        int dst = 0;
+        if (markedChar >= 0) {
+            int delta = pos - markedChar;
+            if (delta >= readAheadLimit) {
+                markedChar = INVALIDATED;
+                readAheadLimit = 0;
+            } else {
+                if (readAheadLimit > buf.length) {
+                    char[] grown = new char[readAheadLimit];
+                    System.arraycopy(buf, markedChar, grown, 0, delta);
+                    buf = grown;
+                } else {
+                    System.arraycopy(buf, markedChar, buf, 0, delta);
+                }
+                markedChar = 0;
+                pos = delta;
+                count = delta;
+                dst = delta;
+            }
+        }
+        int n = in.read(buf, dst, buf.length - dst);
+        if (n <= 0) {
+            return false;
+        }
+        pos = dst;
+        count = dst + n;
+        return true;
+    }
+
+    @Override
+    public int read() throws IOException {
+        ensureOpen();
+        while (true) {
+            if (pos >= count && !fill()) {
+                return -1;
+            }
+            char c = buf[pos++];
+            if (skipLf) {
+                skipLf = false;
+                if (c == '\n') {
+                    continue;
+                }
+            }
+            return c;
+        }
+    }
+
+    @Override
+    public int read(char[] cbuf, int off, int len) throws IOException {
+        ensureOpen();
+        if (off < 0 || len < 0 || len > cbuf.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (len == 0) {
+            return 0;
+        }
+        int n = 0;
+        while (n < len) {
+            int c = read();
+            if (c < 0) {
+                return n == 0 ? -1 : n;
+            }
+            cbuf[off + n++] = (char) c;
+            if (pos >= count && !in.ready()) {
+                break;
+            }
+        }
+        return n;
+    }
+
+    /// Reads a line of text, without its terminator.
+    ///
+    /// #### Returns
+    ///
+    /// the line, or null at the end of the text
+    public String readLine() throws IOException {
+        ensureOpen();
+        StringBuilder sb = null;
+        while (true) {
+            if (pos >= count && !fill()) {
+                return sb == null ? null : sb.toString();
+            }
+            if (skipLf) {
+                skipLf = false;
+                if (buf[pos] == '\n') {
+                    pos++;
+                    continue;
+                }
+            }
+            int start = pos;
+            while (pos < count) {
+                char c = buf[pos];
+                if (c == '\n' || c == '\r') {
+                    if (sb == null) {
+                        sb = new StringBuilder();
+                    }
+                    sb.append(buf, start, pos - start);
+                    pos++;
+                    if (c == '\r') {
+                        skipLf = true;
+                    }
+                    return sb.toString();
+                }
+                pos++;
+            }
+            if (sb == null) {
+                sb = new StringBuilder();
+            }
+            sb.append(buf, start, pos - start);
+        }
+    }
+
+    @Override
+    public boolean ready() throws IOException {
+        ensureOpen();
+        return pos < count || in.ready();
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        if (n < 0) {
+            throw new IllegalArgumentException("skip value is negative");
+        }
+        ensureOpen();
+        long skipped = 0;
+        while (skipped < n && read() >= 0) {
+            skipped++;
+        }
+        return skipped;
+    }
+
+    @Override
+    public boolean markSupported() {
+        return true;
+    }
+
+    @Override
+    public void mark(int readAheadLimit) throws IOException {
+        if (readAheadLimit < 0) {
+            throw new IllegalArgumentException("Read-ahead limit < 0");
+        }
+        ensureOpen();
+        this.readAheadLimit = readAheadLimit;
+        markedChar = pos;
+        markedSkipLf = skipLf;
+    }
+
+    @Override
+    public void reset() throws IOException {
+        ensureOpen();
+        if (markedChar < 0) {
+            throw new IOException(markedChar == INVALIDATED ? "Mark invalid" : "Stream not marked");
+        }
+        pos = markedChar;
+        skipLf = markedSkipLf;
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (buf == null) {
+            return;
+        }
+        buf = null;
+        in.close();
+    }
+
+    /// The remaining lines, read as the stream asks for them. A read that
+    /// fails surfaces as an UncheckedIOException; closing the stream does
+    /// not close this reader, as in the JDK.
+    public java.util.stream.Stream<String> lines() {
+        return java.util.stream.StreamSupport.stream(
+                java.util.Spliterators.spliteratorUnknownSize(new LineIterator(this),
+                        java.util.Spliterator.ORDERED | java.util.Spliterator.NONNULL), false);
+    }
+
+    /// Reads one line ahead, so `hasNext` can answer without losing one.
+    private static final class LineIterator implements java.util.Iterator<String> {
+        private final BufferedReader reader;
+        private String next;
+        private boolean done;
+
+        LineIterator(BufferedReader reader) {
+            this.reader = reader;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (next != null) {
+                return true;
+            }
+            if (done) {
+                return false;
+            }
+            try {
+                next = reader.readLine();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+            if (next == null) {
+                done = true;
+                return false;
+            }
+            return true;
+        }
+
+        @Override
+        public String next() {
+            if (!hasNext()) {
+                throw new java.util.NoSuchElementException();
+            }
+            String line = next;
+            next = null;
+            return line;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/BufferedWriter.java b/vm/JavaAPI/src/java/io/BufferedWriter.java
new file mode 100644
index 00000000000..89377b497b1
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/BufferedWriter.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Writes text to another writer through a buffer.
+public class BufferedWriter extends Writer {
+
+    private final Writer out;
+    private final char[] buf;
+    private int count;
+    /// Set by [#close()]. The buffer and the underlying writer are kept, so
+    /// without it a later write would land in the buffer and a second close
+    /// could hand that data to a writer whose own close is a no-op.
+    private boolean closed;
+
+    /// Buffers `out` with an 8192 character buffer.
+    public BufferedWriter(Writer out) {
+        this(out, 8192);
+    }
+
+    /// Buffers `out` with a buffer of `size` characters.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `size` is not positive
+    public BufferedWriter(Writer out, int size) {
+        super(out);
+        if (size <= 0) {
+            throw new IllegalArgumentException("Buffer size <= 0");
+        }
+        this.out = out;
+        this.buf = new char[size];
+    }
+
+    private void ensureOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
+    }
+
+    private void flushBuffer() throws IOException {
+        if (count > 0) {
+            out.write(buf, 0, count);
+            count = 0;
+        }
+    }
+
+    @Override
+    public void write(int c) throws IOException {
+        ensureOpen();
+        if (count >= buf.length) {
+            flushBuffer();
+        }
+        buf[count++] = (char) c;
+    }
+
+    @Override
+    public void write(char[] cbuf, int off, int len) throws IOException {
+        ensureOpen();
+        if (off < 0 || len < 0 || len > cbuf.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (len >= buf.length) {
+            flushBuffer();
+            out.write(cbuf, off, len);
+            return;
+        }
+        if (len > buf.length - count) {
+            flushBuffer();
+        }
+        System.arraycopy(cbuf, off, buf, count, len);
+        count += len;
+    }
+
+    @Override
+    public void write(String s, int off, int len) throws IOException {
+        ensureOpen();
+        char[] c = new char[len];
+        s.getChars(off, off + len, c, 0);
+        write(c, 0, len);
+    }
+
+    /// Writes a line separator, `\n`.
+    public void newLine() throws IOException {
+        write('\n');
+    }
+
+    @Override
+    public void flush() throws IOException {
+        ensureOpen();
+        flushBuffer();
+        out.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        try {
+            flushBuffer();
+        } finally {
+            count = 0;
+            out.close();
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/ByteArrayOutputStream.java b/vm/JavaAPI/src/java/io/ByteArrayOutputStream.java
index df13365ba32..291949b8c22 100644
--- a/vm/JavaAPI/src/java/io/ByteArrayOutputStream.java
+++ b/vm/JavaAPI/src/java/io/ByteArrayOutputStream.java
@@ -173,6 +173,11 @@ public String toString(String charsetName) throws UnsupportedEncodingException {
         return new String(buf, 0, count, charsetName);
     }
 
+    /// The contents decoded with `charset`.
+    public synchronized String toString(java.nio.charset.Charset charset) {
+        return new String(buf, 0, count, charset);
+    }
+
     /**
      * Writes {@code count} bytes from the byte array {@code buffer} starting at
      * offset {@code index} to this stream.
diff --git a/vm/JavaAPI/src/java/io/Closeable.java b/vm/JavaAPI/src/java/io/Closeable.java
new file mode 100644
index 00000000000..529e9a57652
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/Closeable.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// A source or destination of data that holds something until it is closed:
+/// every stream, reader and writer.
+public interface Closeable extends AutoCloseable {
+    /// Closes this and releases what it holds. Closing it again has no effect.
+    @Override
+    void close() throws IOException;
+}
diff --git a/vm/JavaAPI/src/java/io/Externalizable.java b/vm/JavaAPI/src/java/io/Externalizable.java
index 6aa211e9776..7630dc82b10 100644
--- a/vm/JavaAPI/src/java/io/Externalizable.java
+++ b/vm/JavaAPI/src/java/io/Externalizable.java
@@ -20,15 +20,15 @@
  * Please contact Codename One through http://www.codenameone.com/ if you 
  * need additional information or have any questions.
  */
-
 package java.io;
 
-/**
- * Here to simplify porting, won't actually work...
- *
- */
+/// An object that writes and reads its own state through [ObjectOutput] and
+/// [ObjectInput].
 public interface Externalizable extends Serializable {
+
+    /// Restores this object's state from `in`.
     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
 
+    /// Writes this object's state to `out`.
     void writeExternal(ObjectOutput out) throws IOException;
 }
diff --git a/vm/JavaAPI/src/java/io/File.java b/vm/JavaAPI/src/java/io/File.java
index fa29553647d..4a91aab6a4a 100644
--- a/vm/JavaAPI/src/java/io/File.java
+++ b/vm/JavaAPI/src/java/io/File.java
@@ -1,185 +1,502 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.io;
 
+import com.codename1.impl.JdkHost;
+
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.net.URL;
-
-public class File {
-    public static final String pathSeparator = ":";
-    public static final char pathSeparatorChar = ':';
-    public static final String separator = "/";
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+/// A path in the file system, and the operations on the file or directory at
+/// it.
+///
+/// Every operation goes to the platform's file system through
+/// `com.codename1.impl.JdkHost`: on a device that is `FileSystemStorage`, in a
+/// program translated without Codename One it is the native file system.
+///
+/// #### Paths
+///
+/// A path is kept with duplicate separators collapsed and no trailing one,
+/// and a backslash is read as a separator. It is absolute when it starts with
+/// `/`, with a drive (`C:/`), or with the `file:` scheme Codename One names its
+/// files with. A relative path is resolved against the application's home
+/// directory, which in a program run from a shell is the working directory.
+///
+/// #### What differs from a desktop file system
+///
+/// - Where the file system has no permissions, every file that exists may be
+///   read and written, a directory may be entered and nothing may be run; the
+///   permission setters answer whether the file already is as asked.
+/// - [#setLastModified(long)] answers false: no platform lets it be set.
+/// - [#deleteOnExit()] does nothing.
+/// - Where the file system cannot resolve symbolic links,
+///   [#getCanonicalPath()] answers the absolute path with `.` and `..`
+///   resolved.
+public class File implements Serializable, Comparable<File> {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The separator of the names in a path.
     public static final char separatorChar = '/';
-    
-    private String path;
-    
+    /// [#separatorChar] as a string.
+    public static final String separator = "/";
+    /// The separator of the paths in a list of them.
+    public static final char pathSeparatorChar = ':';
+    /// [#pathSeparatorChar] as a string.
+    public static final String pathSeparator = ":";
+
+    private static final String SCHEME = "file:";
+
+    private final String path;
+
+    /// The file at `pathname`.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `pathname` is null
     public File(String pathname) {
         if (pathname == null) {
             throw new NullPointerException();
         }
-        this.path = pathname;
+        this.path = normalize(pathname);
     }
-    
+
+    /// The file `child` in the directory `parent`. A null `parent` makes it
+    /// `new File(child)`, an empty one the root.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `child` is null
     public File(String parent, String child) {
         if (child == null) {
             throw new NullPointerException();
         }
-        if (parent != null) {
-            if (parent.equals("")) {
-                this.path = separator + child;
-            } else {
-                this.path = resolve(parent, child);
-            }
+        if (parent == null) {
+            this.path = normalize(child);
+        } else if (parent.length() == 0) {
+            this.path = join(separator, child);
         } else {
-            this.path = child;
+            this.path = join(normalize(parent), child);
         }
     }
-    
+
+    /// The file `child` in the directory `parent`. A null `parent` makes it
+    /// `new File(child)`, an empty one the root.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `child` is null
     public File(File parent, String child) {
         if (child == null) {
             throw new NullPointerException();
         }
-        if (parent != null) {
-            if (parent.getPath().equals("")) {
-                this.path = separator + child;
-            } else {
-                this.path = resolve(parent.getPath(), child);
-            }
+        if (parent == null) {
+            this.path = normalize(child);
+        } else if (parent.path.length() == 0) {
+            this.path = join(separator, child);
         } else {
-            this.path = child;
+            this.path = join(parent.path, child);
         }
     }
 
+    /// The file a `file:` URI names.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `uri` is not an absolute,
+    ///   hierarchical `file:` URI with a path and without an authority, a query
+    ///   or a fragment
     public File(URI uri) {
-        throw new UnsupportedOperationException("URI constructor not supported");
+        if (!uri.isAbsolute()) {
+            throw new IllegalArgumentException("URI is not absolute");
+        }
+        if (uri.isOpaque()) {
+            throw new IllegalArgumentException("URI is not hierarchical");
+        }
+        if (!"file".equalsIgnoreCase(uri.getScheme())) {
+            throw new IllegalArgumentException("URI scheme is not \"file\"");
+        }
+        if (present(uri.getRawAuthority())) {
+            throw new IllegalArgumentException("URI has an authority component");
+        }
+        if (present(uri.getRawFragment())) {
+            throw new IllegalArgumentException("URI has a fragment component");
+        }
+        if (present(uri.getRawQuery())) {
+            throw new IllegalArgumentException("URI has a query component");
+        }
+        String p = uri.getPath();
+        if (p == null || p.length() == 0) {
+            throw new IllegalArgumentException("URI path component is empty");
+        }
+        this.path = normalize(p);
+    }
+
+    /// Whether a URI has the component. An empty one counts as none: the
+    /// runtime's `URI` answers an empty authority for `file:///x`, where the
+    /// JDK's answers null.
+    private static boolean present(String component) {
+        return component != null && component.length() > 0;
+    }
+
+    private static JdkHost host() {
+        return JdkHost.get();
+    }
+
+    /// How many leading characters of `p` are its root: the scheme and its
+    /// slashes, `/`, a drive with its separator, or none.
+    private static int rootLength(String p) {
+        if (p.startsWith(SCHEME)) {
+            int i = SCHEME.length();
+            while (i < p.length() && p.charAt(i) == '/') {
+                i++;
+            }
+            return i;
+        }
+        if (p.startsWith("/")) {
+            return 1;
+        }
+        if (p.length() >= 3 && p.charAt(1) == ':' && p.charAt(2) == '/' && isLetter(p.charAt(0))) {
+            return 3;
+        }
+        return 0;
     }
 
-    private String resolve(String parent, String child) {
-        if (child.equals("")) return parent;
-        if (parent.endsWith(separator)) return parent + child;
-        return parent + separator + child;
+    private static boolean isLetter(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+    }
+
+    /// Reads a backslash as a separator, collapses duplicate separators
+    /// outside the scheme and drops a trailing one, as `java.io.File` does.
+    private static String normalize(String p) {
+        StringBuilder sb = new StringBuilder(p.length());
+        int start = 0;
+        if (p.startsWith("file://")) {
+            sb.append("file://");
+            start = 7;
+        }
+        char prev = 0;
+        for (int i = start; i < p.length(); i++) {
+            char c = p.charAt(i);
+            if (c == '\\') {
+                c = '/';
+            }
+            if (c == '/' && prev == '/') {
+                continue;
+            }
+            sb.append(c);
+            prev = c;
+        }
+        int min = start + 1;
+        while (sb.length() > min && sb.charAt(sb.length() - 1) == '/') {
+            sb.setLength(sb.length() - 1);
+        }
+        return sb.toString();
     }
-    
+
+    private static String join(String parent, String child) {
+        String c = normalize(child);
+        if (parent.length() == 0) {
+            return c;
+        }
+        if (c.startsWith("/")) {
+            c = c.substring(1);
+        }
+        if (c.length() == 0) {
+            return parent;
+        }
+        return parent.endsWith("/") ? parent + c : parent + "/" + c;
+    }
+
+    /// The path the host is asked about: this one when it is absolute, else
+    /// resolved against the application's home directory.
+    String hostPath() {
+        if (path.startsWith("file:/") || (rootLength(path) > 0 && !path.startsWith(SCHEME))) {
+            return path;
+        }
+        // A relative path, a "file:" with no slash after it included: a
+        // device's file system throws for anything but an absolute path.
+        String rel = path.startsWith(SCHEME) ? path.substring(SCHEME.length()) : path;
+        String home = host().appHome();
+        if (rel.length() == 0) {
+            return home;
+        }
+        return home.endsWith("/") ? home + rel : home + "/" + rel;
+    }
+
+    /// The last name of the path, or the whole path when it has one name.
+    public String getName() {
+        int i = path.lastIndexOf('/');
+        return i < 0 ? path : path.substring(i + 1);
+    }
+
+    /// The path as it was given, normalized.
     public String getPath() {
         return path;
     }
-    
-    public String getAbsolutePath() {
-        if (isAbsolute()) return path;
-        return getAbsolutePathImpl(path);
-    }
-    
-    private native String getAbsolutePathImpl(String path);
 
-    public String getCanonicalPath() throws IOException {
-        return getCanonicalPathImpl(path);
+    /// The path resolved against the application's home directory when it is
+    /// relative.
+    public String getAbsolutePath() {
+        return hostPath();
     }
-    
-    private native String getCanonicalPathImpl(String path);
 
+    /// The file at [#getAbsolutePath()].
     public File getAbsoluteFile() {
         return new File(getAbsolutePath());
     }
 
+    /// The absolute path with symbolic links, `.` and `..` resolved. Code
+    /// checks a canonical path against a directory to reject a name like
+    /// `root/../outside`, so where the file system cannot resolve links the
+    /// dots are still resolved; a `..` at the root stays at the root.
+    public String getCanonicalPath() throws IOException {
+        String abs = hostPath();
+        String canonical = host().fileCanonicalPath(abs);
+        return canonical != null ? canonical : resolveDots(abs);
+    }
+
+    /// The file at [#getCanonicalPath()].
     public File getCanonicalFile() throws IOException {
         return new File(getCanonicalPath());
     }
-    
-    public String getName() {
-        int index = path.lastIndexOf(separatorChar);
-        if (index < 0) return path;
-        return path.substring(index + 1);
+
+    private static String resolveDots(String p) {
+        int start = rootLength(p);
+        ArrayList<String> segs = new ArrayList<String>();
+        int s = start;
+        for (int i = start; i <= p.length(); i++) {
+            if (i == p.length() || p.charAt(i) == '/') {
+                String seg = p.substring(s, i);
+                if (seg.equals("..")) {
+                    if (!segs.isEmpty()) {
+                        segs.remove(segs.size() - 1);
+                    }
+                } else if (seg.length() > 0 && !seg.equals(".")) {
+                    segs.add(seg);
+                }
+                s = i + 1;
+            }
+        }
+        StringBuilder sb = new StringBuilder(p.length());
+        sb.append(p.substring(0, start));
+        for (int i = 0; i < segs.size(); i++) {
+            if (i > 0) {
+                sb.append('/');
+            }
+            sb.append(segs.get(i));
+        }
+        return sb.toString();
     }
-    
+
+    /// The path without its last name, or null when it has no parent.
     public String getParent() {
-        int index = path.lastIndexOf(separatorChar);
-        if (index < 0) return null;
-        return path.substring(0, index);
+        int i = path.lastIndexOf('/');
+        if (i < 0) {
+            return null;
+        }
+        int root = rootLength(path);
+        if (i < root) {
+            return path.length() > root ? path.substring(0, root) : null;
+        }
+        if (i == root - 1) {
+            return path.length() > root ? path.substring(0, root) : null;
+        }
+        return path.substring(0, i);
     }
-    
+
+    /// The file at [#getParent()], or null.
     public File getParentFile() {
         String p = getParent();
-        if (p == null) return null;
-        return new File(p);
+        return p == null ? null : new File(p);
     }
-    
+
+    /// Whether the path is absolute.
     public boolean isAbsolute() {
-        return path.startsWith(separator);
+        return rootLength(path) > 0;
     }
-    
+
+    /// Whether something is at the path.
     public boolean exists() {
-        return existsImpl(path);
+        return host().fileTest(hostPath(), JdkHost.FILE_EXISTS);
     }
-    
-    private native boolean existsImpl(String path);
 
+    /// Whether the path is a directory.
     public boolean isDirectory() {
-        return isDirectoryImpl(path);
+        return host().fileTest(hostPath(), JdkHost.FILE_DIRECTORY);
     }
-    
-    private native boolean isDirectoryImpl(String path);
 
+    /// Whether the path is a file that is not a directory.
     public boolean isFile() {
-        return isFileImpl(path);
+        return host().fileTest(hostPath(), JdkHost.FILE_REGULAR);
     }
-    
-    private native boolean isFileImpl(String path);
 
+    /// Whether the file is hidden; on most file systems, whether its name
+    /// starts with a dot.
     public boolean isHidden() {
-        return isHiddenImpl(path);
+        return host().fileTest(hostPath(), JdkHost.FILE_HIDDEN);
     }
-    
-    private native boolean isHiddenImpl(String path);
 
-    public long lastModified() {
-        return lastModifiedImpl(path);
+    /// Whether the file may be read.
+    public boolean canRead() {
+        return host().fileTest(hostPath(), JdkHost.FILE_READABLE);
+    }
+
+    /// Whether the file may be written.
+    public boolean canWrite() {
+        return host().fileTest(hostPath(), JdkHost.FILE_WRITABLE);
+    }
+
+    /// Whether the file may be run, or the directory entered.
+    public boolean canExecute() {
+        return host().fileTest(hostPath(), JdkHost.FILE_EXECUTABLE);
+    }
+
+    /// Lets the file be read, or not; false when it is not left as asked.
+    public boolean setReadable(boolean readable, boolean ownerOnly) {
+        return host().fileSet(hostPath(), JdkHost.FILE_READABLE, readable);
+    }
+
+    /// Lets the file be read, or not; false when it is not left as asked.
+    public boolean setReadable(boolean readable) {
+        return setReadable(readable, true);
+    }
+
+    /// Lets the file be written, or not; false when it is not left as asked.
+    public boolean setWritable(boolean writable, boolean ownerOnly) {
+        return host().fileSet(hostPath(), JdkHost.FILE_WRITABLE, writable);
+    }
+
+    /// Lets the file be written, or not; false when it is not left as asked.
+    public boolean setWritable(boolean writable) {
+        return setWritable(writable, true);
     }
-    
-    private native long lastModifiedImpl(String path);
 
+    /// Lets the file be run, or not; false when it is not left as asked.
+    public boolean setExecutable(boolean executable, boolean ownerOnly) {
+        return host().fileSet(hostPath(), JdkHost.FILE_EXECUTABLE, executable);
+    }
+
+    /// Lets the file be run, or not; false when it is not left as asked.
+    public boolean setExecutable(boolean executable) {
+        return setExecutable(executable, true);
+    }
+
+    /// Stops the file being written; false when it still can be.
+    public boolean setReadOnly() {
+        return host().fileSet(hostPath(), JdkHost.FILE_WRITABLE, false);
+    }
+
+    /// Answers false: no platform lets a file's time be set.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `time` is negative
+    public boolean setLastModified(long time) {
+        if (time < 0) {
+            throw new IllegalArgumentException("Negative time");
+        }
+        return false;
+    }
+
+    /// The length of the file in bytes; 0 for a directory or when nothing is
+    /// there.
     public long length() {
-        return lengthImpl(path);
+        return host().fileLength(hostPath());
+    }
+
+    /// When the file was last modified, in milliseconds since the epoch; 0
+    /// when nothing is there.
+    public long lastModified() {
+        return host().fileLastModified(hostPath());
+    }
+
+    /// The size of the volume holding the file, or 0 when unknown.
+    public long getTotalSpace() {
+        return host().fileTotalSpace(hostPath());
     }
-    
-    private native long lengthImpl(String path);
 
+    /// The bytes free on the volume holding the file, or 0 when unknown.
+    public long getFreeSpace() {
+        return host().fileFreeSpace(hostPath());
+    }
+
+    /// The bytes this program may still write on the volume holding the
+    /// file, or 0 when unknown.
+    public long getUsableSpace() {
+        return host().fileUsableSpace(hostPath());
+    }
+
+    /// Creates the file, empty, when nothing is at the path.
+    ///
+    /// #### Returns
+    ///
+    /// true when it was created, false when something was there
+    ///
+    /// #### Throws
+    ///
+    /// - `IOException`: when the directory it would be in does not exist, or
+    ///   the file could not be created
     public boolean createNewFile() throws IOException {
-        return createNewFileImpl(path);
+        File parent = getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new IOException("No such file or directory: " + getParent());
+        }
+        return host().fileCreate(hostPath());
     }
-    
-    private native boolean createNewFileImpl(String path);
 
+    /// Deletes the file, or the directory when it is empty.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was deleted
     public boolean delete() {
-        return deleteImpl(path);
+        return host().fileDelete(hostPath());
     }
-    
-    private native boolean deleteImpl(String path);
 
+    /// Does nothing: nothing is deleted when the program ends.
     public void deleteOnExit() {
-        // Not implemented
-    }
-    
-    public String[] list() {
-        return listImpl(path);
     }
-    
-    private native String[] listImpl(String path);
 
-    public File[] listFiles() {
-        String[] ss = list();
-        if (ss == null) return null;
-        int n = ss.length;
-        File[] fs = new File[n];
-        for (int i = 0; i < n; i++) {
-            fs[i] = new File(this, ss[i]);
-        }
-        return fs;
-    }
-    
+    /// Creates the directory, in a parent that must exist.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was created
     public boolean mkdir() {
-        return mkdirImpl(path);
+        return host().fileMkdir(hostPath());
     }
-    
-    private native boolean mkdirImpl(String path);
 
+    /// Creates the directory and the parents it needs.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was created; false also when it already existed
     public boolean mkdirs() {
         if (exists()) {
             return false;
@@ -188,142 +505,427 @@ public boolean mkdirs() {
             return true;
         }
         File p = getParentFile();
-        return (p != null && (p.mkdirs() || p.exists()) && mkdir());
-    }
-    
+        return p != null && (p.mkdirs() || p.exists()) && mkdir();
+    }
+
+    /// Moves the file or directory to `dest`. A file replaces a file already
+    /// there. Where the platform cannot move a file in place, it is copied and
+    /// the original deleted; when the original will not go, the copy is taken
+    /// back unless it replaced something.
+    ///
+    /// #### Returns
+    ///
+    /// whether it was moved
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: when `dest` is null
     public boolean renameTo(File dest) {
-        return renameToImpl(path, dest.getPath());
+        if (dest == null) {
+            throw new NullPointerException();
+        }
+        JdkHost h = host();
+        String from = hostPath();
+        String to = dest.hostPath();
+        if (!h.fileTest(from, JdkHost.FILE_EXISTS)) {
+            return false;
+        }
+        // A file renamed onto itself is already where it was asked to be.
+        // The copy below would open the same file for reading and writing,
+        // truncating it, and then delete it.
+        if (resolveDots(from).equals(resolveDots(to))) {
+            return true;
+        }
+        boolean replacing = h.fileTest(to, JdkHost.FILE_EXISTS);
+        if (replacing ? h.fileReplace(from, to) : h.fileRename(from, to)) {
+            return true;
+        }
+        if (h.fileTest(from, JdkHost.FILE_DIRECTORY) || (replacing && h.fileTest(to, JdkHost.FILE_DIRECTORY))) {
+            return false;
+        }
+        try {
+            InputStream in = h.fileRead(from);
+            try {
+                OutputStream out = h.fileWrite(to, false);
+                try {
+                    byte[] buffer = new byte[8192];
+                    int n;
+                    while ((n = in.read(buffer, 0, buffer.length)) >= 0) {
+                        out.write(buffer, 0, n);
+                    }
+                } finally {
+                    out.close();
+                }
+            } finally {
+                in.close();
+            }
+        } catch (IOException e) {
+            return false;
+        }
+        // The move only happened if the source is gone. When it cannot be
+        // removed the rename fails, and a copy that created the destination
+        // is taken back so the file is left where it was; one that replaced
+        // an existing destination stays, as deleting it would lose both.
+        h.fileDelete(from);
+        if (h.fileTest(from, JdkHost.FILE_EXISTS)) {
+            if (!replacing) {
+                h.fileDelete(to);
+            }
+            return false;
+        }
+        return true;
     }
-    
-    private native boolean renameToImpl(String path, String dest);
 
-    public boolean setReadOnly() {
-        return setReadOnlyImpl(path);
+    /// The names of the entries of the directory, or null when this is not a
+    /// directory.
+    public String[] list() {
+        String[] names;
+        try {
+            names = host().fileList(hostPath());
+        } catch (IOException e) {
+            return null;
+        }
+        if (names == null) {
+            return null;
+        }
+        String[] out = new String[names.length];
+        for (int i = 0; i < names.length; i++) {
+            String n = names[i];
+            while (n.endsWith("/")) {
+                n = n.substring(0, n.length() - 1);
+            }
+            int slash = n.lastIndexOf('/');
+            out[i] = slash < 0 ? n : n.substring(slash + 1);
+        }
+        return out;
     }
-    
-    private native boolean setReadOnlyImpl(String path);
 
-    public boolean setWritable(boolean writable, boolean ownerOnly) {
-        return setWritableImpl(path, writable);
+    /// The names of the entries of the directory that `filter` accepts, or
+    /// null when this is not a directory. A null `filter` accepts all.
+    public String[] list(FilenameFilter filter) {
+        String[] names = list();
+        if (names == null || filter == null) {
+            return names;
+        }
+        List<String> out = new ArrayList<String>();
+        for (int i = 0; i < names.length; i++) {
+            if (filter.accept(this, names[i])) {
+                out.add(names[i]);
+            }
+        }
+        return out.toArray(new String[out.size()]);
     }
-    
-    public boolean setWritable(boolean writable) {
-        return setWritable(writable, false);
+
+    /// The entries of the directory, or null when this is not a directory.
+    public File[] listFiles() {
+        return files(list());
     }
-    
-    private native boolean setWritableImpl(String path, boolean writable);
 
-    public boolean setReadable(boolean readable, boolean ownerOnly) {
-        return setReadableImpl(path, readable);
+    /// The entries of the directory whose names `filter` accepts, or null when
+    /// this is not a directory. A null `filter` accepts all.
+    public File[] listFiles(FilenameFilter filter) {
+        return files(list(filter));
     }
-    
-    public boolean setReadable(boolean readable) {
-        return setReadable(readable, false);
+
+    /// The entries of the directory that `filter` accepts, or null when this
+    /// is not a directory. A null `filter` accepts all.
+    public File[] listFiles(FileFilter filter) {
+        File[] all = listFiles();
+        if (all == null || filter == null) {
+            return all;
+        }
+        List<File> out = new ArrayList<File>();
+        for (int i = 0; i < all.length; i++) {
+            if (filter.accept(all[i])) {
+                out.add(all[i]);
+            }
+        }
+        return out.toArray(new File[out.size()]);
     }
-    
-    private native boolean setReadableImpl(String path, boolean readable);
 
-    public boolean setExecutable(boolean executable, boolean ownerOnly) {
-        return setExecutableImpl(path, executable);
+    private File[] files(String[] names) {
+        if (names == null) {
+            return null;
+        }
+        File[] out = new File[names.length];
+        for (int i = 0; i < names.length; i++) {
+            out[i] = new File(this, names[i]);
+        }
+        return out;
     }
-    
-    public boolean setExecutable(boolean executable) {
-        return setExecutable(executable, false);
+
+    /// Creates an empty file named `prefix`, a number and `suffix` in the
+    /// directory for disposable files.
+    public static File createTempFile(String prefix, String suffix) throws IOException {
+        return createTempFile(prefix, suffix, null);
     }
-    
-    private native boolean setExecutableImpl(String path, boolean executable);
 
-    public boolean canRead() {
-        return canReadImpl(path);
+    /// Creates an empty file named `prefix`, a number and `suffix` (`.tmp`
+    /// when null) in `directory`, or in the directory for disposable files
+    /// when that is null. Nothing deletes it.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `prefix` is shorter than three
+    ///   characters
+    /// - `IOException`: when the file could not be created
+    public static File createTempFile(String prefix, String suffix, File directory) throws IOException {
+        if (prefix.length() < 3) {
+            throw new IllegalArgumentException("Prefix string too short");
+        }
+        File dir = directory;
+        if (dir == null) {
+            JdkHost h = host();
+            String caches = h.cachesDir();
+            dir = new File(caches != null ? caches : h.appHome());
+        }
+        String s = suffix == null ? ".tmp" : suffix;
+        long n = System.currentTimeMillis();
+        while (true) {
+            File f = new File(dir, prefix + n + s);
+            if (f.createNewFile()) {
+                return f;
+            }
+            if (!f.exists()) {
+                throw new IOException("Unable to create temporary file " + f.getPath());
+            }
+            n++;
+        }
     }
-    
-    private native boolean canReadImpl(String path);
 
-    public boolean canWrite() {
-        return canWriteImpl(path);
+    /// The roots of the file system.
+    public static File[] listRoots() {
+        String[] roots = host().fileRoots();
+        File[] out = new File[roots == null ? 0 : roots.length];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = new File(roots[i]);
+        }
+        return out;
     }
-    
-    private native boolean canWriteImpl(String path);
 
-    public boolean canExecute() {
-        return canExecuteImpl(path);
+    /// Compares the paths.
+    @Override
+    public int compareTo(File other) {
+        return path.compareTo(other.path);
     }
-    
-    private native boolean canExecuteImpl(String path);
-    
-    public long getTotalSpace() {
-        return getTotalSpaceImpl(path);
+
+    /// Whether `o` is a file with the same path.
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof File && ((File) o).path.equals(path);
     }
-    
-    private native long getTotalSpaceImpl(String path);
 
-    public long getFreeSpace() {
-        return getFreeSpaceImpl(path);
+    @Override
+    public int hashCode() {
+        return path.hashCode() ^ 1234321;
     }
-    
-    private native long getFreeSpaceImpl(String path);
 
-    public long getUsableSpace() {
-        return getUsableSpaceImpl(path);
+    /// The path.
+    @Override
+    public String toString() {
+        return path;
     }
-    
-    private native long getUsableSpaceImpl(String path);
 
-    public int compareTo(File pathname) {
-        return getPath().compareTo(pathname.getPath());
+    /// This file as a `java.nio.file.Path`.
+    public Path toPath() {
+        return Paths.get(path);
     }
-    
-    public boolean equals(Object obj) {
-        if ((obj != null) && (obj instanceof File)) {
-            return compareTo((File)obj) == 0;
+
+    /// The absolute path, without the scheme and with a single leading
+    /// separator, as a URI's path.
+    private String uriPath() {
+        String abs = getAbsolutePath();
+        if (abs.startsWith(SCHEME)) {
+            int at = SCHEME.length();
+            while (at + 1 < abs.length() && abs.charAt(at) == '/' && abs.charAt(at + 1) == '/') {
+                at++;
+            }
+            abs = abs.substring(at);
         }
-        return false;
-    }
-    
-    public int hashCode() {
-        return getPath().hashCode() ^ 1234321;
+        if (!abs.startsWith("/")) {
+            abs = "/" + abs;
+        }
+        return abs;
     }
 
-    public String toString() {
-        return getPath();
+    /// The `file:` URI of the absolute path, ending in a separator when the
+    /// file is a directory.
+    public URI toURI() {
+        String p = uriPath();
+        if (!p.endsWith("/") && isDirectory()) {
+            p = p + "/";
+        }
+        try {
+            return new URI("file", null, p, null, null);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException(e.getMessage());
+        }
     }
 
-    public static File[] listRoots() {
-        return new File[]{new File(separator)};
+    /// The `file:` URL of the absolute path.
+    ///
+    /// #### Deprecated
+    ///
+    /// The path is not escaped; use `toURI().toURL()` where it may hold
+    /// characters a URL does not allow.
+    @Deprecated
+    public URL toURL() throws java.net.MalformedURLException {
+        return new URL("file", "", uriPath());
     }
 
-    public static File createTempFile(String prefix, String suffix, File directory) throws IOException {
-        if (prefix.length() < 3)
-            throw new IllegalArgumentException("Prefix string too short");
-        if (suffix == null)
-            suffix = ".tmp";
-        if (directory == null) {
-            String tmpDir = System.getProperty("java.io.tmpdir");
-            if (tmpDir == null) tmpDir = "/tmp";
-            directory = new File(tmpDir);
+    // ------------------------------------------------------------------
+    // The native file system, for PosixFileAccess and nothing else. The
+    // natives keep their names and signatures, which the C runtime and the
+    // JavaScript bindings implement; they are reached only through these
+    // bridges, so a program that never installs PosixJdkHost never calls
+    // them.
+
+    private static File nativeReceiver;
+
+    private static File receiver() {
+        File f = nativeReceiver;
+        if (f == null) {
+            f = new File(separator);
+            nativeReceiver = f;
         }
+        return f;
+    }
 
-        File f;
-        do {
-            long n = System.currentTimeMillis();
-             f = new File(directory, prefix + n + suffix);
-        } while (f.exists());
+    static boolean nExists(String p) {
+        return receiver().existsImpl(p);
+    }
 
-        if (!f.createNewFile())
-            throw new IOException("Unable to create temporary file");
+    static boolean nIsDirectory(String p) {
+        return receiver().isDirectoryImpl(p);
+    }
 
-        return f;
+    static boolean nIsFile(String p) {
+        return receiver().isFileImpl(p);
     }
 
-    public static File createTempFile(String prefix, String suffix) throws IOException {
-        return createTempFile(prefix, suffix, null);
+    static boolean nIsHidden(String p) {
+        return receiver().isHiddenImpl(p);
     }
-    
-    public URI toURI() {
-         throw new UnsupportedOperationException();
+
+    static long nLastModified(String p) {
+        return receiver().lastModifiedImpl(p);
     }
-    
-    public URL toURL() throws java.net.MalformedURLException {
-         return new URL("file", "", getAbsolutePath());
+
+    static long nLength(String p) {
+        return receiver().lengthImpl(p);
+    }
+
+    static boolean nCreateNewFile(String p) {
+        return receiver().createNewFileImpl(p);
     }
+
+    static boolean nDelete(String p) {
+        return receiver().deleteImpl(p);
+    }
+
+    static String[] nList(String p) {
+        return receiver().listImpl(p);
+    }
+
+    static boolean nMkdir(String p) {
+        return receiver().mkdirImpl(p);
+    }
+
+    static boolean nRename(String p, String dest) {
+        return receiver().renameToImpl(p, dest);
+    }
+
+    static boolean nSetReadOnly(String p) {
+        return receiver().setReadOnlyImpl(p);
+    }
+
+    static boolean nSetWritable(String p, boolean on) {
+        return receiver().setWritableImpl(p, on);
+    }
+
+    static boolean nSetReadable(String p, boolean on) {
+        return receiver().setReadableImpl(p, on);
+    }
+
+    static boolean nSetExecutable(String p, boolean on) {
+        return receiver().setExecutableImpl(p, on);
+    }
+
+    static boolean nCanRead(String p) {
+        return receiver().canReadImpl(p);
+    }
+
+    static boolean nCanWrite(String p) {
+        return receiver().canWriteImpl(p);
+    }
+
+    static boolean nCanExecute(String p) {
+        return receiver().canExecuteImpl(p);
+    }
+
+    static long nTotalSpace(String p) {
+        return receiver().getTotalSpaceImpl(p);
+    }
+
+    static long nFreeSpace(String p) {
+        return receiver().getFreeSpaceImpl(p);
+    }
+
+    static long nUsableSpace(String p) {
+        return receiver().getUsableSpaceImpl(p);
+    }
+
+    static String nAbsolutePath(String p) {
+        return receiver().getAbsolutePathImpl(p);
+    }
+
+    static String nCanonicalPath(String p) {
+        return receiver().getCanonicalPathImpl(p);
+    }
+
+    private native String getAbsolutePathImpl(String path);
+
+    private native String getCanonicalPathImpl(String path);
+
+    private native boolean existsImpl(String path);
+
+    private native boolean isDirectoryImpl(String path);
+
+    private native boolean isFileImpl(String path);
+
+    private native boolean isHiddenImpl(String path);
+
+    private native long lastModifiedImpl(String path);
+
+    private native long lengthImpl(String path);
+
+    private native boolean createNewFileImpl(String path);
+
+    private native boolean deleteImpl(String path);
+
+    private native String[] listImpl(String path);
+
+    private native boolean mkdirImpl(String path);
+
+    private native boolean renameToImpl(String path, String dest);
+
+    private native boolean setReadOnlyImpl(String path);
+
+    private native boolean setWritableImpl(String path, boolean writable);
+
+    private native boolean setReadableImpl(String path, boolean readable);
+
+    private native boolean setExecutableImpl(String path, boolean executable);
+
+    private native boolean canReadImpl(String path);
+
+    private native boolean canWriteImpl(String path);
+
+    private native boolean canExecuteImpl(String path);
+
+    private native long getTotalSpaceImpl(String path);
+
+    private native long getFreeSpaceImpl(String path);
+
+    private native long getUsableSpaceImpl(String path);
 }
diff --git a/vm/JavaAPI/src/java/io/FileFilter.java b/vm/JavaAPI/src/java/io/FileFilter.java
new file mode 100644
index 00000000000..815ce200515
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/FileFilter.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Decides which files `File.listFiles(FileFilter)` answers.
+public interface FileFilter {
+
+    /// Whether `pathname` is wanted.
+    boolean accept(File pathname);
+}
diff --git a/vm/JavaAPI/src/java/io/FileInputStream.java b/vm/JavaAPI/src/java/io/FileInputStream.java
index cfac889307a..1a67c902880 100644
--- a/vm/JavaAPI/src/java/io/FileInputStream.java
+++ b/vm/JavaAPI/src/java/io/FileInputStream.java
@@ -22,138 +22,110 @@
  */
 package java.io;
 
-/**
- * Reads bytes from a file. Backed by C stdio through a native handle rather than
- * by any Codename One implementation, so it is available to a translated program
- * that has no platform layer at all - a server-side binary, for example.
- */
+import com.codename1.impl.JdkHost;
+
+/// Reads the bytes of a file, from the platform's file system through
+/// `com.codename1.impl.JdkHost`.
+///
+/// Like most streams, it is for one thread at a time; closing it twice, or
+/// from another thread, is safe.
 public class FileInputStream extends InputStream {
-    private long handle;
-    /* volatile + synchronized close: two threads closing concurrently could both
-       read closed == false and hand the SAME FILE* to fclose twice, which is
-       undefined and crashes the translated process rather than merely erroring.
-       Idempotent now.
-
-       NOT a claim of thread safety. A read racing a close on the same stream can
-       still reach the native call with a handle this method is closing -- the JDK
-       buys that with a lock on every operation, and these streams are not worth
-       that cost. Like most java.io streams they are for one thread at a time; what
-       is guaranteed here is that closing twice, or closing from another thread, is
-       safe rather than fatal. */
-    private volatile boolean closed;
 
+    private final InputStream in;
+    private boolean closed;
+
+    /// Opens the file at `name`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
     public FileInputStream(String name) throws FileNotFoundException {
-        if(name == null) {
+        this(new File(name));
+    }
+
+    /// Opens `file`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
+    public FileInputStream(File file) throws FileNotFoundException {
+        if (file == null) {
             throw new NullPointerException();
         }
-        handle = openImpl(name);
-        if(handle == 0) {
-            throw new FileNotFoundException(name);
+        try {
+            in = JdkHost.get().fileRead(file.hostPath());
+        } catch (FileNotFoundException e) {
+            throw e;
+        } catch (IOException e) {
+            throw new FileNotFoundException(file.getPath() + " (" + e.getMessage() + ")");
+        }
+        if (in == null) {
+            throw new FileNotFoundException(file.getPath());
         }
     }
 
-    public FileInputStream(File file) throws FileNotFoundException {
-        this(file == null ? null : file.getPath());
+    private void checkOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
     }
 
+    @Override
     public int read() throws IOException {
-        byte[] one = new byte[1];
-        int n = read(one, 0, 1);
-        if(n <= 0) {
-            return -1;
-        }
-        return one[0] & 0xff;
+        checkOpen();
+        return in.read();
     }
 
+    @Override
     public int read(byte[] b) throws IOException {
-        return read(b, 0, b == null ? 0 : b.length);
+        return read(b, 0, b.length);
     }
 
+    @Override
     public int read(byte[] b, int off, int len) throws IOException {
-        if(b == null) {
-            throw new NullPointerException();
-        }
-        if(off < 0 || len < 0 || len > b.length - off) {
+        if (off < 0 || len < 0 || len > b.length - off) {
             throw new IndexOutOfBoundsException();
         }
         checkOpen();
-        if(len == 0) {
+        if (len == 0) {
             return 0;
         }
-        int n = readImpl(handle, b, off, len);
-        if(n < -1) {
-            throw new IOException("Read failed");
-        }
-        return n;
+        return in.read(b, off, len);
     }
 
+    @Override
     public long skip(long n) throws IOException {
         checkOpen();
-        if(n <= 0) {
-            return 0;
-        }
-        long moved = skipImpl(handle, n);
-        if(moved < 0) {
-            throw new IOException("Seek failed");
-        }
-        return moved;
+        return n <= 0 ? 0 : in.skip(n);
     }
 
+    @Override
     public int available() throws IOException {
         checkOpen();
-        int a = availableImpl(handle);
-        if(a < 0) {
-            throw new IOException("Unable to determine available bytes");
-        }
-        return a;
+        return in.available();
     }
 
-    public synchronized void close() throws IOException {
-        if(closed) {
+    @Override
+    public void close() throws IOException {
+        if (closed) {
             return;
         }
         closed = true;
-        long h = handle;
-        handle = 0;
-        if(closeImpl(h) != 0) {
-            throw new IOException("Close failed");
-        }
+        in.close();
     }
 
-    /**
-     * Releases the native FILE* if the caller never closed the stream.
-     *
-     * This VM runs finalizers for exactly this purpose (java.lang.Thread does the
-     * same for its thread state), and without one a stream that goes unreachable
-     * unclosed holds its descriptor until the process exits. On a desktop app that
-     * is untidy; on a long-running clean-target server it ends in EMFILE.
-     *
-     * Deliberately silent: a finalizer has nobody to report to, and throwing from
-     * one is worse than the leak it is cleaning up. close() remains the way to learn
-     * that a close failed.
-     */
-    protected void finalize() {
-        // Same lock as close(): a finalizer running while another thread closes
-        // would otherwise be the two-fclose case this synchronization exists for.
-        synchronized(this) {
-            if(!closed && handle != 0) {
-                closed = true;
-                long h = handle;
-                handle = 0;
-                closeImpl(h);
-            }
-        }
-    }
+    // The C stdio natives behind PosixFileAccess.openRead; see
+    // NativeFileInputStream. Their names and signatures are what the C
+    // runtime and the JavaScript bindings implement.
+    static native long openImpl(String name);
 
-    private void checkOpen() throws IOException {
-        if(closed) {
-            throw new IOException("Stream closed");
-        }
-    }
+    static native int readImpl(long handle, byte[] buffer, int offset, int length);
+
+    static native long skipImpl(long handle, long count);
+
+    static native int availableImpl(long handle);
 
-    private static native long openImpl(String name);
-    private static native int readImpl(long handle, byte[] buffer, int offset, int length);
-    private static native long skipImpl(long handle, long count);
-    private static native int availableImpl(long handle);
-    private static native int closeImpl(long handle);
+    static native int closeImpl(long handle);
 }
diff --git a/vm/JavaAPI/src/java/io/FileOutputStream.java b/vm/JavaAPI/src/java/io/FileOutputStream.java
index 6ff39850906..b8a69affc0d 100644
--- a/vm/JavaAPI/src/java/io/FileOutputStream.java
+++ b/vm/JavaAPI/src/java/io/FileOutputStream.java
@@ -22,130 +22,119 @@
  */
 package java.io;
 
-/**
- * Writes bytes to a file. Backed by C stdio through a native handle rather than by
- * any Codename One implementation, so it is available to a translated program that
- * has no platform layer at all - a server-side binary, for example.
- */
+import com.codename1.impl.JdkHost;
+
+/// Writes the bytes of a file, to the platform's file system through
+/// `com.codename1.impl.JdkHost`. The file is created when it is not there.
+///
+/// Like most streams, it is for one thread at a time; closing it twice, or
+/// from another thread, is safe.
 public class FileOutputStream extends OutputStream {
-    private long handle;
-    /* volatile + synchronized close: two threads closing concurrently could both
-       read closed == false and hand the SAME FILE* to fclose twice, which is
-       undefined and crashes the translated process rather than merely erroring.
-       Idempotent now.
-
-       NOT a claim of thread safety. A read racing a close on the same stream can
-       still reach the native call with a handle this method is closing -- the JDK
-       buys that with a lock on every operation, and these streams are not worth
-       that cost. Like most java.io streams they are for one thread at a time; what
-       is guaranteed here is that closing twice, or closing from another thread, is
-       safe rather than fatal. */
-    private volatile boolean closed;
 
+    private final OutputStream out;
+    private boolean closed;
+
+    /// Opens the file at `name`, emptying it.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(String name) throws FileNotFoundException {
-        this(name, false);
+        this(new File(name), false);
     }
 
+    /// Opens the file at `name`, at its end when `append` is true and emptied
+    /// otherwise.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(String name, boolean append) throws FileNotFoundException {
-        if(name == null) {
-            throw new NullPointerException();
-        }
-        handle = openImpl(name, append);
-        if(handle == 0) {
-            throw new FileNotFoundException(name);
-        }
+        this(new File(name), append);
     }
 
+    /// Opens `file`, emptying it.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(File file) throws FileNotFoundException {
-        this(file == null ? null : file.getPath(), false);
+        this(file, false);
     }
 
+    /// Opens `file`, at its end when `append` is true and emptied otherwise.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is a directory or cannot be written
     public FileOutputStream(File file, boolean append) throws FileNotFoundException {
-        this(file == null ? null : file.getPath(), append);
+        if (file == null) {
+            throw new NullPointerException();
+        }
+        try {
+            out = JdkHost.get().fileWrite(file.hostPath(), append);
+        } catch (FileNotFoundException e) {
+            throw e;
+        } catch (IOException e) {
+            throw new FileNotFoundException(file.getPath() + " (" + e.getMessage() + ")");
+        }
+        if (out == null) {
+            throw new FileNotFoundException(file.getPath());
+        }
+    }
+
+    private void checkOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
     }
 
+    @Override
     public void write(int b) throws IOException {
-        byte[] one = new byte[1];
-        one[0] = (byte)b;
-        write(one, 0, 1);
+        checkOpen();
+        out.write(b);
     }
 
+    @Override
     public void write(byte[] b) throws IOException {
-        write(b, 0, b == null ? 0 : b.length);
+        write(b, 0, b.length);
     }
 
+    @Override
     public void write(byte[] b, int off, int len) throws IOException {
-        if(b == null) {
-            throw new NullPointerException();
-        }
-        if(off < 0 || len < 0 || len > b.length - off) {
+        if (off < 0 || len < 0 || len > b.length - off) {
             throw new IndexOutOfBoundsException();
         }
         checkOpen();
-        if(len == 0) {
+        if (len == 0) {
             return;
         }
-        // A short write is a failure, not a partial success: OutputStream.write has
-        // no way to report how much it managed, so the caller would silently lose
-        // the tail.
-        if(writeImpl(handle, b, off, len) != len) {
-            throw new IOException("Write failed");
-        }
+        out.write(b, off, len);
     }
 
+    @Override
     public void flush() throws IOException {
         checkOpen();
-        if(flushImpl(handle) != 0) {
-            throw new IOException("Flush failed");
-        }
+        out.flush();
     }
 
-    public synchronized void close() throws IOException {
-        if(closed) {
+    @Override
+    public void close() throws IOException {
+        if (closed) {
             return;
         }
         closed = true;
-        long h = handle;
-        handle = 0;
-        if(closeImpl(h) != 0) {
-            throw new IOException("Close failed");
-        }
+        out.close();
     }
 
-    /**
-     * Releases the native FILE* if the caller never closed the stream.
-     *
-     * This VM runs finalizers for exactly this purpose (java.lang.Thread does the
-     * same for its thread state), and without one a stream that goes unreachable
-     * unclosed holds its descriptor until the process exits. On a desktop app that
-     * is untidy; on a long-running clean-target server it ends in EMFILE. Buffered output is flushed by the C runtime as part of closing the
-     * stream, so this also stops unwritten bytes being dropped.
-     *
-     * Deliberately silent: a finalizer has nobody to report to, and throwing from
-     * one is worse than the leak it is cleaning up. close() remains the way to learn
-     * that a close failed.
-     */
-    protected void finalize() {
-        // Same lock as close(): a finalizer running while another thread closes
-        // would otherwise be the two-fclose case this synchronization exists for.
-        synchronized(this) {
-            if(!closed && handle != 0) {
-                closed = true;
-                long h = handle;
-                handle = 0;
-                closeImpl(h);
-            }
-        }
-    }
+    // The C stdio natives behind PosixFileAccess.openWrite; see
+    // NativeFileOutputStream. Their names and signatures are what the C
+    // runtime and the JavaScript bindings implement.
+    static native long openImpl(String name, boolean append);
 
-    private void checkOpen() throws IOException {
-        if(closed) {
-            throw new IOException("Stream closed");
-        }
-    }
+    static native int writeImpl(long handle, byte[] buffer, int offset, int length);
+
+    static native int flushImpl(long handle);
 
-    private static native long openImpl(String name, boolean append);
-    private static native int writeImpl(long handle, byte[] buffer, int offset, int length);
-    private static native int flushImpl(long handle);
-    private static native int closeImpl(long handle);
+    static native int closeImpl(long handle);
 }
diff --git a/vm/JavaAPI/src/java/io/FileReader.java b/vm/JavaAPI/src/java/io/FileReader.java
new file mode 100644
index 00000000000..ac492f1e623
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/FileReader.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+import java.nio.charset.Charset;
+
+/// Reads the text of a file, in UTF-8 unless a charset is given.
+public class FileReader extends InputStreamReader {
+
+    /// Opens the file at `fileName`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
+    public FileReader(String fileName) throws FileNotFoundException {
+        super(new FileInputStream(fileName));
+    }
+
+    /// Opens `file`.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: when it is not there, is a directory or
+    ///   cannot be read
+    public FileReader(File file) throws FileNotFoundException {
+        super(new FileInputStream(file));
+    }
+
+    /// Opens the file at `fileName`, reading `charset`.
+    public FileReader(String fileName, Charset charset) throws IOException {
+        super(new FileInputStream(fileName), charset.name());
+    }
+
+    /// Opens `file`, reading `charset`.
+    public FileReader(File file, Charset charset) throws IOException {
+        super(new FileInputStream(file), charset.name());
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/FileWriter.java b/vm/JavaAPI/src/java/io/FileWriter.java
new file mode 100644
index 00000000000..e5415f4be95
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/FileWriter.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+import java.nio.charset.Charset;
+
+/// Writes text to a file, in UTF-8 unless a charset is given.
+public class FileWriter extends OutputStreamWriter {
+
+    /// Opens the file at `fileName`, emptying it.
+    public FileWriter(String fileName) throws IOException {
+        super(new FileOutputStream(fileName));
+    }
+
+    /// Opens the file at `fileName`, at its end when `append` is true.
+    public FileWriter(String fileName, boolean append) throws IOException {
+        super(new FileOutputStream(fileName, append));
+    }
+
+    /// Opens `file`, emptying it.
+    public FileWriter(File file) throws IOException {
+        super(new FileOutputStream(file));
+    }
+
+    /// Opens `file`, at its end when `append` is true.
+    public FileWriter(File file, boolean append) throws IOException {
+        super(new FileOutputStream(file, append));
+    }
+
+    /// Opens the file at `fileName`, emptying it, writing `charset`.
+    public FileWriter(String fileName, Charset charset) throws IOException {
+        super(new FileOutputStream(fileName), charset.name());
+    }
+
+    /// Opens the file at `fileName`, at its end when `append` is true,
+    /// writing `charset`.
+    public FileWriter(String fileName, Charset charset, boolean append) throws IOException {
+        super(new FileOutputStream(fileName, append), charset.name());
+    }
+
+    /// Opens `file`, emptying it, writing `charset`.
+    public FileWriter(File file, Charset charset) throws IOException {
+        super(new FileOutputStream(file), charset.name());
+    }
+
+    /// Opens `file`, at its end when `append` is true, writing `charset`.
+    public FileWriter(File file, Charset charset, boolean append) throws IOException {
+        super(new FileOutputStream(file, append), charset.name());
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/FilenameFilter.java b/vm/JavaAPI/src/java/io/FilenameFilter.java
new file mode 100644
index 00000000000..6c2a83faae9
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/FilenameFilter.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Decides which names `File.list(FilenameFilter)` answers.
+public interface FilenameFilter {
+
+    /// Whether the entry `name` of the directory `dir` is wanted.
+    boolean accept(File dir, String name);
+}
diff --git a/vm/JavaAPI/src/java/io/InputStream.java b/vm/JavaAPI/src/java/io/InputStream.java
index 1539d687cec..bb6ca70fcd5 100644
--- a/vm/JavaAPI/src/java/io/InputStream.java
+++ b/vm/JavaAPI/src/java/io/InputStream.java
@@ -27,7 +27,7 @@
  * Applications that need to define a subclass of InputStream must always provide a method that returns the next byte of input.
  * Since: JDK1.0, CLDC 1.0 See Also:ByteArrayInputStream, DataInputStream, read(), OutputStream
  */
-public abstract class InputStream implements AutoCloseable {
+public abstract class InputStream implements Closeable {
     public InputStream(){
     }
 
@@ -127,4 +127,85 @@ public long skip(long n) throws java.io.IOException{
         return read(new byte[(int)n]); 
     }
 
+    /// Reads everything left in this stream, until its end. The stream is
+    /// not closed.
+    ///
+    /// #### Returns
+    ///
+    /// the bytes read, an empty array when the stream was at its end
+    public byte[] readAllBytes() throws IOException {
+        return readNBytes(Integer.MAX_VALUE);
+    }
+
+    /// Reads up to `len` bytes, fewer only when the stream ends first.
+    ///
+    /// #### Parameters
+    ///
+    /// - `len`: the most bytes to read
+    ///
+    /// #### Returns
+    ///
+    /// the bytes read
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: when `len` is negative
+    public byte[] readNBytes(int len) throws IOException {
+        if (len < 0) {
+            throw new IllegalArgumentException("len < 0");
+        }
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        byte[] chunk = new byte[8192];
+        int left = len;
+        while (left > 0) {
+            int n = read(chunk, 0, left < chunk.length ? left : chunk.length);
+            if (n < 0) {
+                break;
+            }
+            out.write(chunk, 0, n);
+            left -= n;
+        }
+        return out.toByteArray();
+    }
+
+    /// Reads into `b` from `off` until `len` bytes arrived or the stream
+    /// ended, where a single `read` may stop short.
+    ///
+    /// #### Returns
+    ///
+    /// how many bytes were read, 0 at the end of the stream
+    public int readNBytes(byte[] b, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        int total = 0;
+        while (total < len) {
+            int n = read(b, off + total, len - total);
+            if (n < 0) {
+                break;
+            }
+            total += n;
+        }
+        return total;
+    }
+
+    /// Copies everything left in this stream to `out`, closing neither.
+    ///
+    /// #### Returns
+    ///
+    /// how many bytes were copied
+    public long transferTo(OutputStream out) throws IOException {
+        if (out == null) {
+            throw new NullPointerException("out");
+        }
+        byte[] chunk = new byte[8192];
+        long total = 0;
+        int n = read(chunk, 0, chunk.length);
+        while (n >= 0) {
+            out.write(chunk, 0, n);
+            total += n;
+            n = read(chunk, 0, chunk.length);
+        }
+        return total;
+    }
 }
diff --git a/vm/JavaAPI/src/java/io/InputStreamReader.java b/vm/JavaAPI/src/java/io/InputStreamReader.java
index f0f8ddcaad3..19941e50247 100644
--- a/vm/JavaAPI/src/java/io/InputStreamReader.java
+++ b/vm/JavaAPI/src/java/io/InputStreamReader.java
@@ -70,8 +70,50 @@ private static void copy(InputStream i, OutputStream o, int bufferSize) throws I
      * - If the named encoding is not supported
      */
     public InputStreamReader(java.io.InputStream is, java.lang.String enc) throws java.io.UnsupportedEncodingException{
+         if (enc == null) {
+             throw new NullPointerException("charsetName");
+         }
          internal = is;
-         this.enc = enc.intern();
+         this.enc = OutputStreamWriter.knownEncoding(enc);
+    }
+
+    /// An InputStreamReader that decodes with `cs`.
+    public InputStreamReader(java.io.InputStream is, java.nio.charset.Charset cs) {
+        if (cs == null) {
+            throw new NullPointerException("charset");
+        }
+        internal = is;
+        this.enc = cs.name();
+    }
+
+    /// The historical name of the encoding: `UTF8`, `ASCII`, `ISO8859_1`.
+    public String getEncoding() {
+        return historicalName(enc);
+    }
+
+    /// The historical name the JDK's `getEncoding` answers for the standard
+    /// charsets: `UTF8`, `ASCII`, `ISO8859_1`. Any other name is answered
+    /// as it was given.
+    private static String historicalName(String name) {
+        StringBuilder folded = new StringBuilder(name.length());
+        for (int i = 0; i < name.length(); i++) {
+            char c = name.charAt(i);
+            if (c == '-' || c == '_') {
+                continue;
+            }
+            folded.append(c >= 'a' && c <= 'z' ? (char) (c - ('a' - 'A')) : c);
+        }
+        String key = folded.toString();
+        if ("UTF8".equals(key)) {
+            return "UTF8";
+        }
+        if ("USASCII".equals(key) || "ASCII".equals(key)) {
+            return "ASCII";
+        }
+        if ("ISO88591".equals(key) || "LATIN1".equals(key)) {
+            return "ISO8859_1";
+        }
+        return name;
     }
 
     private static native char[] bytesToChars(byte[] b, int off, int len, String encoding); 
diff --git a/vm/JavaAPI/src/java/io/NativeFileInputStream.java b/vm/JavaAPI/src/java/io/NativeFileInputStream.java
new file mode 100644
index 00000000000..2f112ef610e
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/NativeFileInputStream.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Reads bytes from a file through C stdio and a native handle rather than
+/// through any Codename One implementation, so it serves a translated program
+/// that has no platform layer at all -- a server-side binary, for example.
+/// Only [PosixFileAccess] creates one.
+final class NativeFileInputStream extends InputStream {
+    private long handle;
+    /* volatile + synchronized close: two threads closing concurrently could both
+       read closed == false and hand the SAME FILE* to fclose twice, which is
+       undefined and crashes the translated process rather than merely erroring.
+       Idempotent now.
+
+       NOT a claim of thread safety. A read racing a close on the same stream can
+       still reach the native call with a handle this method is closing -- the JDK
+       buys that with a lock on every operation, and these streams are not worth
+       that cost. Like most java.io streams they are for one thread at a time; what
+       is guaranteed here is that closing twice, or closing from another thread, is
+       safe rather than fatal. */
+    private volatile boolean closed;
+
+    NativeFileInputStream(String name) throws FileNotFoundException {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        handle = FileInputStream.openImpl(name);
+        if (handle == 0) {
+            throw new FileNotFoundException(name);
+        }
+    }
+
+    @Override
+    public int read() throws IOException {
+        byte[] one = new byte[1];
+        int n = read(one, 0, 1);
+        if (n <= 0) {
+            return -1;
+        }
+        return one[0] & 0xff;
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        checkOpen();
+        if (len == 0) {
+            return 0;
+        }
+        int n = FileInputStream.readImpl(handle, b, off, len);
+        if (n < -1) {
+            throw new IOException("Read failed");
+        }
+        return n;
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        checkOpen();
+        if (n <= 0) {
+            return 0;
+        }
+        long moved = FileInputStream.skipImpl(handle, n);
+        if (moved < 0) {
+            throw new IOException("Seek failed");
+        }
+        return moved;
+    }
+
+    @Override
+    public int available() throws IOException {
+        checkOpen();
+        int a = FileInputStream.availableImpl(handle);
+        if (a < 0) {
+            throw new IOException("Unable to determine available bytes");
+        }
+        return a;
+    }
+
+    @Override
+    public synchronized void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        long h = handle;
+        handle = 0;
+        if (FileInputStream.closeImpl(h) != 0) {
+            throw new IOException("Close failed");
+        }
+    }
+
+    /// Releases the native `FILE*` if the caller never closed the stream.
+    ///
+    /// This VM runs finalizers for exactly this purpose (`java.lang.Thread`
+    /// does the same for its thread state), and without one a stream that goes
+    /// unreachable unclosed holds its descriptor until the process exits. On a
+    /// long-running clean-target server that ends in EMFILE.
+    ///
+    /// Deliberately silent: a finalizer has nobody to report to, and throwing
+    /// from one is worse than the leak it is cleaning up.
+    @Override
+    protected void finalize() {
+        // Same lock as close(): a finalizer running while another thread closes
+        // would otherwise be the two-fclose case this synchronization exists for.
+        synchronized (this) {
+            if (!closed && handle != 0) {
+                closed = true;
+                long h = handle;
+                handle = 0;
+                FileInputStream.closeImpl(h);
+            }
+        }
+    }
+
+    private void checkOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/NativeFileOutputStream.java b/vm/JavaAPI/src/java/io/NativeFileOutputStream.java
new file mode 100644
index 00000000000..42bbc684e42
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/NativeFileOutputStream.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Writes bytes to a file through C stdio and a native handle rather than
+/// through any Codename One implementation, so it serves a translated program
+/// that has no platform layer at all -- a server-side binary, for example.
+/// Only [PosixFileAccess] creates one.
+final class NativeFileOutputStream extends OutputStream {
+    private long handle;
+    /* volatile + synchronized close: two threads closing concurrently could both
+       read closed == false and hand the SAME FILE* to fclose twice, which is
+       undefined and crashes the translated process rather than merely erroring.
+       Idempotent now.
+
+       NOT a claim of thread safety. A write racing a close on the same stream can
+       still reach the native call with a handle this method is closing -- the JDK
+       buys that with a lock on every operation, and these streams are not worth
+       that cost. Like most java.io streams they are for one thread at a time; what
+       is guaranteed here is that closing twice, or closing from another thread, is
+       safe rather than fatal. */
+    private volatile boolean closed;
+
+    NativeFileOutputStream(String name, boolean append) throws FileNotFoundException {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        handle = FileOutputStream.openImpl(name, append);
+        if (handle == 0) {
+            throw new FileNotFoundException(name);
+        }
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+        byte[] one = new byte[1];
+        one[0] = (byte) b;
+        write(one, 0, 1);
+    }
+
+    @Override
+    public void write(byte[] b, int off, int len) throws IOException {
+        if (off < 0 || len < 0 || len > b.length - off) {
+            throw new IndexOutOfBoundsException();
+        }
+        checkOpen();
+        if (len == 0) {
+            return;
+        }
+        // A short write is a failure, not a partial success: OutputStream.write has
+        // no way to report how much it managed, so the caller would silently lose
+        // the tail.
+        if (FileOutputStream.writeImpl(handle, b, off, len) != len) {
+            throw new IOException("Write failed");
+        }
+    }
+
+    @Override
+    public void flush() throws IOException {
+        checkOpen();
+        if (FileOutputStream.flushImpl(handle) != 0) {
+            throw new IOException("Flush failed");
+        }
+    }
+
+    @Override
+    public synchronized void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        long h = handle;
+        handle = 0;
+        if (FileOutputStream.closeImpl(h) != 0) {
+            throw new IOException("Close failed");
+        }
+    }
+
+    /// Releases the native `FILE*` if the caller never closed the stream, which
+    /// also has the C runtime write what is still buffered.
+    ///
+    /// Deliberately silent: a finalizer has nobody to report to, and throwing
+    /// from one is worse than the leak it is cleaning up.
+    @Override
+    protected void finalize() {
+        // Same lock as close(): a finalizer running while another thread closes
+        // would otherwise be the two-fclose case this synchronization exists for.
+        synchronized (this) {
+            if (!closed && handle != 0) {
+                closed = true;
+                long h = handle;
+                handle = 0;
+                FileOutputStream.closeImpl(h);
+            }
+        }
+    }
+
+    private void checkOpen() throws IOException {
+        if (closed) {
+            throw new IOException("Stream closed");
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/ObjectInput.java b/vm/JavaAPI/src/java/io/ObjectInput.java
index 57c0220bdc6..56345032564 100644
--- a/vm/JavaAPI/src/java/io/ObjectInput.java
+++ b/vm/JavaAPI/src/java/io/ObjectInput.java
@@ -20,12 +20,33 @@
  * Please contact Codename One through http://www.codenameone.com/ if you 
  * need additional information or have any questions.
  */
-
 package java.io;
 
-/**
- * Here to simplify porting, won't actually work...
- *
- */
+/// Reads objects as well as primitive values. Codename One has no object
+/// serialization of its own; this type exists so code written against it
+/// compiles, and an implementation supplies the reading.
 public interface ObjectInput extends DataInput, AutoCloseable {
+
+    /// Reads the next object.
+    Object readObject() throws ClassNotFoundException, IOException;
+
+    /// Reads one byte, or -1 at the end of the input.
+    int read() throws IOException;
+
+    /// Reads into `b`, returning how many bytes were read or -1 at the end.
+    int read(byte[] b) throws IOException;
+
+    /// Reads into `b` from `off`, returning how many bytes were read or -1
+    /// at the end.
+    int read(byte[] b, int off, int len) throws IOException;
+
+    /// Skips up to `n` bytes, returning how many were skipped.
+    long skip(long n) throws IOException;
+
+    /// How many bytes can be read without blocking.
+    int available() throws IOException;
+
+    /// Closes the input.
+    @Override
+    void close() throws IOException;
 }
diff --git a/vm/JavaAPI/src/java/io/ObjectOutput.java b/vm/JavaAPI/src/java/io/ObjectOutput.java
index 678521603d3..8c063514473 100644
--- a/vm/JavaAPI/src/java/io/ObjectOutput.java
+++ b/vm/JavaAPI/src/java/io/ObjectOutput.java
@@ -20,12 +20,20 @@
  * Please contact Codename One through http://www.codenameone.com/ if you 
  * need additional information or have any questions.
  */
-
 package java.io;
 
-/**
- * Here to simplify porting, won't actually work...
- *
- */
+/// Writes objects as well as primitive values. Codename One has no object
+/// serialization of its own; this type exists so code written against it
+/// compiles, and an implementation supplies the writing.
 public interface ObjectOutput extends DataOutput, AutoCloseable {
+
+    /// Writes `obj`.
+    void writeObject(Object obj) throws IOException;
+
+    /// Writes any buffered output.
+    void flush() throws IOException;
+
+    /// Closes the output.
+    @Override
+    void close() throws IOException;
 }
diff --git a/vm/JavaAPI/src/java/io/OutputStream.java b/vm/JavaAPI/src/java/io/OutputStream.java
index 998de5f7fe7..7db9dfa693c 100644
--- a/vm/JavaAPI/src/java/io/OutputStream.java
+++ b/vm/JavaAPI/src/java/io/OutputStream.java
@@ -27,7 +27,7 @@
  * Applications that need to define a subclass of OutputStream must always provide at least a method that writes one byte of output.
  * Since: JDK1.0, CLDC 1.0 See Also:ByteArrayOutputStream, DataOutputStream, InputStream, write(int)
  */
-public abstract class OutputStream implements AutoCloseable {
+public abstract class OutputStream implements Closeable, Flushable {
     public OutputStream(){
     }
 
diff --git a/vm/JavaAPI/src/java/io/OutputStreamWriter.java b/vm/JavaAPI/src/java/io/OutputStreamWriter.java
index 95e08dfe90c..fbdec0be028 100644
--- a/vm/JavaAPI/src/java/io/OutputStreamWriter.java
+++ b/vm/JavaAPI/src/java/io/OutputStreamWriter.java
@@ -66,9 +66,83 @@ public OutputStreamWriter(java.io.OutputStream os){
      * - If the named encoding is not supported
      */
     public OutputStreamWriter(java.io.OutputStream os, java.lang.String enc) throws java.io.UnsupportedEncodingException{
+         if (enc == null) {
+             throw new NullPointerException("charsetName");
+         }
          this.os = os;
-         this.enc = enc;
-         utf8 = isUtf8Name(enc);
+         this.enc = knownEncoding(enc);
+         utf8 = isUtf8Name(this.enc);
+    }
+
+    /// The name the encoding natives know `enc` by: the canonical name of a
+    /// charset, so an alias or another case reaches them as the name they
+    /// compare with. `null` stays `null`, which they read as UTF-8.
+    ///
+    /// UTF-16 and ISO-8859-2 have no `Charset` here but the natives encode them
+    /// on Apple platforms, so they are names this runtime knows.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedEncodingException`: for a name this runtime has no
+    ///   encoding for, as the JDK throws. The natives used to encode such a
+    ///   name as UTF-8 without a word.
+    static String knownEncoding(String enc) throws UnsupportedEncodingException {
+        if (enc == null || "UTF-8".equals(enc)) {
+            return enc;
+        }
+        if (enc.equalsIgnoreCase("UTF-16") || enc.equalsIgnoreCase("UTF16")) {
+            return "UTF-16";
+        }
+        if (enc.equalsIgnoreCase("ISO-8859-2") || enc.equalsIgnoreCase("ISO8859-2")
+                || enc.equalsIgnoreCase("ISO8859_2") || enc.equalsIgnoreCase("LATIN2")) {
+            return "ISO-8859-2";
+        }
+        try {
+            return java.nio.charset.Charset.forName(enc).name();
+        } catch (IllegalArgumentException e) {
+            // UnsupportedCharsetException and IllegalCharsetNameException
+            throw new UnsupportedEncodingException(enc);
+        }
+    }
+
+    /// An OutputStreamWriter that encodes with `cs`.
+    public OutputStreamWriter(java.io.OutputStream os, java.nio.charset.Charset cs) {
+        if (cs == null) {
+            throw new NullPointerException("charset");
+        }
+        this.os = os;
+        this.enc = cs.name();
+        utf8 = isUtf8Name(enc);
+    }
+
+    /// The historical name of the encoding: `UTF8`, `ASCII`, `ISO8859_1`.
+    public String getEncoding() {
+        return historicalName(enc);
+    }
+
+    /// The historical name the JDK's `getEncoding` answers for the standard
+    /// charsets: `UTF8`, `ASCII`, `ISO8859_1`. Any other name is answered
+    /// as it was given.
+    private static String historicalName(String name) {
+        StringBuilder folded = new StringBuilder(name.length());
+        for (int i = 0; i < name.length(); i++) {
+            char c = name.charAt(i);
+            if (c == '-' || c == '_') {
+                continue;
+            }
+            folded.append(c >= 'a' && c <= 'z' ? (char) (c - ('a' - 'A')) : c);
+        }
+        String key = folded.toString();
+        if ("UTF8".equals(key)) {
+            return "UTF8";
+        }
+        if ("USASCII".equals(key) || "ASCII".equals(key)) {
+            return "ASCII";
+        }
+        if ("ISO88591".equals(key) || "LATIN1".equals(key)) {
+            return "ISO8859_1";
+        }
+        return name;
     }
 
     /* The encoding name is ASCII by specification, so it is folded by hand.
diff --git a/vm/JavaAPI/src/java/io/PosixFileAccess.java b/vm/JavaAPI/src/java/io/PosixFileAccess.java
new file mode 100644
index 00000000000..d0d8843e0c9
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/PosixFileAccess.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// The native file system: the C natives behind `java.io.File` and the file
+/// streams, for `com.codename1.impl.PosixJdkHost`.
+///
+/// Internal API of the ParparVM class library; applications compile against
+/// a class library that does not have it. `java.io.File` and the streams go
+/// through `com.codename1.impl.JdkHost`, and only `PosixJdkHost` -- installed
+/// by a program translated without Codename One -- reaches the natives,
+/// through this class. That keeps them out of the reach of an application,
+/// whose watch, TV and JavaScript builds do not link them.
+///
+/// Paths are passed to the natives as they are, except that a `file:` scheme
+/// is dropped.
+public final class PosixFileAccess {
+
+    private PosixFileAccess() {
+    }
+
+    private static String p(String path) {
+        if (path.startsWith("file:")) {
+            int i = 5;
+            while (i + 1 < path.length() && path.charAt(i) == '/' && path.charAt(i + 1) == '/') {
+                i++;
+            }
+            return path.substring(i);
+        }
+        return path;
+    }
+
+    /// Whether something is at `path`.
+    public static boolean exists(String path) {
+        return File.nExists(p(path));
+    }
+
+    /// Whether `path` is a directory.
+    public static boolean isDirectory(String path) {
+        return File.nIsDirectory(p(path));
+    }
+
+    /// Whether `path` is a regular file.
+    public static boolean isFile(String path) {
+        return File.nIsFile(p(path));
+    }
+
+    /// Whether `path` is hidden.
+    public static boolean isHidden(String path) {
+        return File.nIsHidden(p(path));
+    }
+
+    /// When `path` was last modified, in milliseconds since the epoch.
+    public static long lastModified(String path) {
+        return File.nLastModified(p(path));
+    }
+
+    /// The length of the file `path` in bytes.
+    public static long length(String path) {
+        return File.nLength(p(path));
+    }
+
+    /// Creates the empty file `path` atomically; false when something was
+    /// there or it could not be created.
+    public static boolean createNewFile(String path) {
+        return File.nCreateNewFile(p(path));
+    }
+
+    /// Deletes the file or empty directory `path`.
+    public static boolean delete(String path) {
+        return File.nDelete(p(path));
+    }
+
+    /// The names of the entries of the directory `path`, or null.
+    public static String[] list(String path) {
+        return File.nList(p(path));
+    }
+
+    /// Creates the directory `path`.
+    public static boolean mkdir(String path) {
+        return File.nMkdir(p(path));
+    }
+
+    /// Moves `from` to `to` with rename(2), replacing what is there.
+    public static boolean rename(String from, String to) {
+        return File.nRename(p(from), p(to));
+    }
+
+    /// Makes `path` read-only.
+    public static boolean setReadOnly(String path) {
+        return File.nSetReadOnly(p(path));
+    }
+
+    /// Grants or takes away writing `path`.
+    public static boolean setWritable(String path, boolean on) {
+        return File.nSetWritable(p(path), on);
+    }
+
+    /// Grants or takes away reading `path`.
+    public static boolean setReadable(String path, boolean on) {
+        return File.nSetReadable(p(path), on);
+    }
+
+    /// Grants or takes away executing `path`.
+    public static boolean setExecutable(String path, boolean on) {
+        return File.nSetExecutable(p(path), on);
+    }
+
+    /// Whether `path` may be read.
+    public static boolean canRead(String path) {
+        return File.nCanRead(p(path));
+    }
+
+    /// Whether `path` may be written.
+    public static boolean canWrite(String path) {
+        return File.nCanWrite(p(path));
+    }
+
+    /// Whether `path` may be executed.
+    public static boolean canExecute(String path) {
+        return File.nCanExecute(p(path));
+    }
+
+    /// The size of the volume holding `path`.
+    public static long totalSpace(String path) {
+        return File.nTotalSpace(p(path));
+    }
+
+    /// The bytes free on the volume holding `path`.
+    public static long freeSpace(String path) {
+        return File.nFreeSpace(p(path));
+    }
+
+    /// The bytes this program may use on the volume holding `path`.
+    public static long usableSpace(String path) {
+        return File.nUsableSpace(p(path));
+    }
+
+    /// `path` resolved against the working directory.
+    public static String absolutePath(String path) {
+        return File.nAbsolutePath(p(path));
+    }
+
+    /// `path` with symbolic links, `.` and `..` resolved, where the file
+    /// system can.
+    public static String canonicalPath(String path) {
+        return File.nCanonicalPath(p(path));
+    }
+
+    /// Opens the file `path` for reading.
+    public static InputStream openRead(String path) throws FileNotFoundException {
+        return new NativeFileInputStream(p(path));
+    }
+
+    /// Opens the file `path` for writing, at its end when `append` is true.
+    public static OutputStream openWrite(String path, boolean append) throws FileNotFoundException {
+        return new NativeFileOutputStream(p(path), append);
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/PrintWriter.java b/vm/JavaAPI/src/java/io/PrintWriter.java
new file mode 100644
index 00000000000..6aa96768421
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/PrintWriter.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// Prints formatted text to a writer or a stream. It never throws: an I/O error is recorded and reported by `checkError`.
+public class PrintWriter extends Writer {
+
+    protected Writer out;
+    private final boolean autoFlush;
+    private boolean trouble;
+
+    public PrintWriter(Writer out) {
+        this(out, false);
+    }
+
+    public PrintWriter(Writer out, boolean autoFlush) {
+        this.out = out;
+        this.autoFlush = autoFlush;
+    }
+
+    public PrintWriter(OutputStream out) {
+        this(out, false);
+    }
+
+    public PrintWriter(OutputStream out, boolean autoFlush) {
+        this(utf8(out), autoFlush);
+    }
+
+    /// Writes to the file `fileName` in UTF-8, creating it or truncating it.
+    public PrintWriter(String fileName) throws FileNotFoundException {
+        this(new BufferedWriter(utf8(new FileOutputStream(fileName))), false);
+    }
+
+    /// Writes to the file `fileName` in the charset `csn`.
+    public PrintWriter(String fileName, String csn) throws FileNotFoundException, UnsupportedEncodingException {
+        this(encoded(new File(fileName), csn), false);
+    }
+
+    /// Writes to the file `fileName` in the charset `cs`.
+    public PrintWriter(String fileName, java.nio.charset.Charset cs) throws IOException {
+        this(encoded(new File(fileName), cs.name()), false);
+    }
+
+    /// Writes to `file` in UTF-8, creating it or truncating it.
+    public PrintWriter(File file) throws FileNotFoundException {
+        this(new BufferedWriter(utf8(new FileOutputStream(file))), false);
+    }
+
+    /// Writes to `file` in the charset `csn`.
+    public PrintWriter(File file, String csn) throws FileNotFoundException, UnsupportedEncodingException {
+        this(encoded(file, csn), false);
+    }
+
+    /// Writes to `file` in the charset `cs`.
+    public PrintWriter(File file, java.nio.charset.Charset cs) throws IOException {
+        this(encoded(file, cs.name()), false);
+    }
+
+    /// Checks the charset before the file is opened, so an unknown name
+    /// leaves the file as it was, as the JDK does.
+    private static Writer encoded(File file, String csn) throws FileNotFoundException, UnsupportedEncodingException {
+        if (csn == null) {
+            throw new NullPointerException("charsetName");
+        }
+        // Asked of Charset, not of String.getBytes: on ParparVM the string
+        // natives fall back to a default encoding for a name they do not know
+        // rather than throwing, so that check let every name through.
+        try {
+            java.nio.charset.Charset.forName(csn);
+        } catch (IllegalArgumentException e) {
+            // UnsupportedCharsetException and IllegalCharsetNameException.
+            throw new UnsupportedEncodingException(csn);
+        }
+        return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), csn));
+    }
+
+    private static Writer utf8(OutputStream out) {
+        try {
+            return new OutputStreamWriter(out, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            throw new IllegalStateException("UTF-8 is not supported");
+        }
+    }
+
+    public boolean checkError() {
+        if (out != null) {
+            flush();
+        }
+        return trouble;
+    }
+
+    protected void setError() {
+        trouble = true;
+    }
+
+    protected void clearError() {
+        trouble = false;
+    }
+
+    @Override
+    public void flush() {
+        if (out == null) {
+            trouble = true;
+            return;
+        }
+        try {
+            out.flush();
+        } catch (IOException e) {
+            trouble = true;
+        }
+    }
+
+    /// Closes the delegate and drops it, as the JDK does: a later write or
+    /// flush is then suppressed and recorded as an error for `checkError`,
+    /// even when the delegate's own close is a no-op (a `StringWriter`). A
+    /// second close does nothing.
+    @Override
+    public void close() {
+        if (out == null) {
+            return;
+        }
+        try {
+            out.close();
+        } catch (IOException e) {
+            trouble = true;
+        } finally {
+            out = null;
+        }
+    }
+
+    @Override
+    public void write(int c) {
+        if (out == null) {
+            trouble = true;
+            return;
+        }
+        try {
+            out.write(c);
+        } catch (IOException e) {
+            trouble = true;
+        }
+    }
+
+    @Override
+    public void write(char[] buf, int off, int len) {
+        if (out == null) {
+            trouble = true;
+            return;
+        }
+        try {
+            out.write(buf, off, len);
+        } catch (IOException e) {
+            trouble = true;
+        }
+    }
+
+    @Override
+    public void write(char[] buf) {
+        write(buf, 0, buf.length);
+    }
+
+    @Override
+    public void write(String s, int off, int len) {
+        if (out == null) {
+            trouble = true;
+            return;
+        }
+        try {
+            out.write(s, off, len);
+        } catch (IOException e) {
+            trouble = true;
+        }
+    }
+
+    @Override
+    public void write(String s) {
+        write(s, 0, s.length());
+    }
+
+    public void print(String s) {
+        write(s == null ? "null" : s);
+    }
+
+    public void print(Object o) {
+        print(String.valueOf(o));
+    }
+
+    public void print(char c) {
+        write(c);
+    }
+
+    public void print(char[] s) {
+        write(s);
+    }
+
+    public void print(boolean b) {
+        print(String.valueOf(b));
+    }
+
+    public void print(int i) {
+        print(String.valueOf(i));
+    }
+
+    public void print(long l) {
+        print(String.valueOf(l));
+    }
+
+    public void print(float f) {
+        print(String.valueOf(f));
+    }
+
+    public void print(double d) {
+        print(String.valueOf(d));
+    }
+
+    public void println() {
+        write('\n');
+        if (autoFlush) {
+            flush();
+        }
+    }
+
+    public void println(String s) {
+        print(s);
+        println();
+    }
+
+    public void println(Object o) {
+        print(o);
+        println();
+    }
+
+    public void println(char c) {
+        print(c);
+        println();
+    }
+
+    public void println(char[] s) {
+        print(s);
+        println();
+    }
+
+    public void println(boolean b) {
+        print(b);
+        println();
+    }
+
+    public void println(int i) {
+        print(i);
+        println();
+    }
+
+    public void println(long l) {
+        print(l);
+        println();
+    }
+
+    public void println(float f) {
+        print(f);
+        println();
+    }
+
+    public void println(double d) {
+        print(d);
+        println();
+    }
+
+    public PrintWriter append(CharSequence csq) {
+        print(String.valueOf(csq));
+        return this;
+    }
+
+    public PrintWriter append(char c) {
+        print(c);
+        return this;
+    }
+
+    /// Writes `format` filled in with `args`, as `String.format` does.
+    ///
+    /// #### Returns
+    ///
+    /// this writer
+    public PrintWriter printf(String format, Object... args) {
+        return format(format, args);
+    }
+
+    /// Writes `format` filled in with `args`, as `String.format` does.
+    ///
+    /// #### Returns
+    ///
+    /// this writer
+    public PrintWriter format(String format, Object... args) {
+        write(String.format(format, args));
+        if (autoFlush) {
+            flush();
+        }
+        return this;
+    }
+
+    public PrintWriter append(CharSequence csq, int start, int end) {
+        CharSequence cs = csq == null ? "null" : csq;
+        print(cs.subSequence(start, end).toString());
+        return this;
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/Reader.java b/vm/JavaAPI/src/java/io/Reader.java
index f2790e256fe..73bbf91dc90 100644
--- a/vm/JavaAPI/src/java/io/Reader.java
+++ b/vm/JavaAPI/src/java/io/Reader.java
@@ -26,7 +26,7 @@
  * Abstract class for reading character streams. The only methods that a subclass must implement are read(char[], int, int) and close(). Most subclasses, however, will override some of the methods defined here in order to provide higher efficiency, additional functionality, or both.
  * Since: JDK1.1, CLDC 1.0 See Also:InputStreamReader, Writer
  */
-public abstract class Reader implements AutoCloseable {
+public abstract class Reader implements Closeable {
     /**
      * The object used to synchronize operations on this stream. For efficiency, a character-stream object may use an object other than itself to protect critical sections. A subclass should therefore use the object in this field rather than this or a synchronized method.
      */
@@ -134,4 +134,23 @@ public long skip(long count) throws java.io.IOException{
         }
     }
 
+    /// Copies everything left in this reader to `out`, closing neither.
+    ///
+    /// #### Returns
+    ///
+    /// how many characters were copied
+    public long transferTo(Writer out) throws IOException {
+        if (out == null) {
+            throw new NullPointerException("out");
+        }
+        char[] chunk = new char[8192];
+        long total = 0;
+        int n = read(chunk, 0, chunk.length);
+        while (n >= 0) {
+            out.write(chunk, 0, n);
+            total += n;
+            n = read(chunk, 0, chunk.length);
+        }
+        return total;
+    }
 }
diff --git a/vm/JavaAPI/src/java/io/UncheckedIOException.java b/vm/JavaAPI/src/java/io/UncheckedIOException.java
new file mode 100644
index 00000000000..71864bc40b2
--- /dev/null
+++ b/vm/JavaAPI/src/java/io/UncheckedIOException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.io;
+
+/// `java.io.UncheckedIOException`: an
+/// `IOException` carried through code that cannot declare it, as a lambda or
+/// a constructor that loads a resource does.
+public class UncheckedIOException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Wraps an exception with a message of its own.
+    public UncheckedIOException(String message, IOException cause) {
+        super(message, required(cause));
+    }
+
+    /// Wraps an exception, taking its description as the message.
+    public UncheckedIOException(IOException cause) {
+        super(required(cause).toString(), cause);
+    }
+
+    private static IOException required(IOException cause) {
+        if (cause == null) {
+            throw new NullPointerException();
+        }
+        return cause;
+    }
+
+    /// Returns the exception this one carries.
+    @Override
+    public IOException getCause() {
+        Throwable cause = super.getCause();
+        return cause instanceof IOException ? (IOException) cause : null;
+    }
+}
diff --git a/vm/JavaAPI/src/java/io/Writer.java b/vm/JavaAPI/src/java/io/Writer.java
index a030abc0948..db44da4a342 100644
--- a/vm/JavaAPI/src/java/io/Writer.java
+++ b/vm/JavaAPI/src/java/io/Writer.java
@@ -26,7 +26,7 @@
  * Abstract class for writing to character streams. The only methods that a subclass must implement are write(char[], int, int), flush(), and close(). Most subclasses, however, will override some of the methods defined here in order to provide higher efficiency, additional functionality, or both.
  * Since: JDK1.1, CLDC 1.0 See Also:OutputStreamWriter, Reader
  */
-public abstract class Writer implements Appendable, AutoCloseable {
+public abstract class Writer implements Appendable, Closeable, Flushable {
     /**
      * The object used to synchronize operations on this stream. For efficiency, a character-stream object may use an object other than itself to protect critical sections. A subclass should therefore use the object in this field rather than this or a synchronized method.
      */
diff --git a/vm/JavaAPI/src/java/lang/Boolean.java b/vm/JavaAPI/src/java/lang/Boolean.java
index 62c36722b01..283962e11eb 100644
--- a/vm/JavaAPI/src/java/lang/Boolean.java
+++ b/vm/JavaAPI/src/java/lang/Boolean.java
@@ -126,4 +126,53 @@ public int compareTo(final Boolean b2) {
         }
         return 1;
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// A Boolean of `parseBoolean(s)`.
+    @Deprecated
+    public Boolean(String s) {
+        this(parseBoolean(s));
+    }
+
+    /// `"true"` or `"false"`.
+    public static String toString(boolean b) {
+        return b ? "true" : "false";
+    }
+
+    /// 1231 for true, 1237 for false, as the JDK hashes them.
+    public static int hashCode(boolean value) {
+        return value ? 1231 : 1237;
+    }
+
+    /// 0 when equal, otherwise positive when `x` is true.
+    public static int compare(boolean x, boolean y) {
+        return x == y ? 0 : (x ? 1 : -1);
+    }
+
+    /// `a && b`.
+    public static boolean logicalAnd(boolean a, boolean b) {
+        return a && b;
+    }
+
+    /// `a || b`.
+    public static boolean logicalOr(boolean a, boolean b) {
+        return a || b;
+    }
+
+    /// `a ^ b`.
+    public static boolean logicalXor(boolean a, boolean b) {
+        return a ^ b;
+    }
+
+    /// Whether the system property `name` is `"true"`, ignoring case.
+    public static boolean getBoolean(String name) {
+        if (name == null || name.length() == 0) {
+            return false;
+        }
+        String value = System.getProperty(name);
+        return value != null && value.equalsIgnoreCase("true");
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Byte.java b/vm/JavaAPI/src/java/lang/Byte.java
index 9a7fa9d99e9..a4dbbb93802 100644
--- a/vm/JavaAPI/src/java/lang/Byte.java
+++ b/vm/JavaAPI/src/java/lang/Byte.java
@@ -90,7 +90,7 @@ public static byte parseByte(java.lang.String s, int radix) throws java.lang.Num
         if (result == intValue) {
             return result;
         }
-        throw new NumberFormatException("Value out of range for byte: \"" + s + "\"");
+        throw new NumberFormatException("Value out of range. Value:\"" + s + "\" Radix:" + radix);
     }
 
     /**
@@ -136,4 +136,61 @@ public static int compare(byte f1, byte f2) {
     public int compareTo(Byte another) {
         return value < another.value ? -1 : value > another.value ? 1 : 0;
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// The size of a byte in bytes.
+    public static final int BYTES = 1;
+
+    /// A Byte of `parseByte(s)`.
+    @Deprecated
+    public Byte(String s) throws NumberFormatException {
+        this(parseByte(s, 10));
+    }
+
+    /// The decimal string of `b`.
+    public static String toString(byte b) {
+        return Integer.toString(b);
+    }
+
+    /// A Byte of `parseByte(s)`.
+    public static Byte valueOf(String s) throws NumberFormatException {
+        return valueOf(parseByte(s, 10));
+    }
+
+    /// A Byte of `parseByte(s, radix)`.
+    public static Byte valueOf(String s, int radix) throws NumberFormatException {
+        return valueOf(parseByte(s, radix));
+    }
+
+    /// Decodes a decimal, hexadecimal or octal byte, as `Integer.decode`.
+    public static Byte decode(String nm) throws NumberFormatException {
+        int value = Integer.decode(nm).intValue();
+        if (value < MIN_VALUE || value > MAX_VALUE) {
+            throw new NumberFormatException("Value " + value + " out of range from input " + nm);
+        }
+        return valueOf((byte) value);
+    }
+
+    /// The value itself.
+    public static int hashCode(byte value) {
+        return value;
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(byte x, byte y) {
+        return toUnsignedInt(x) - toUnsignedInt(y);
+    }
+
+    /// The value as an unsigned int.
+    public static int toUnsignedInt(byte x) {
+        return x & 0xff;
+    }
+
+    /// The value as an unsigned long.
+    public static long toUnsignedLong(byte x) {
+        return x & 0xffL;
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/CharSequence.java b/vm/JavaAPI/src/java/lang/CharSequence.java
index c763765ffe7..29002e4e68c 100644
--- a/vm/JavaAPI/src/java/lang/CharSequence.java
+++ b/vm/JavaAPI/src/java/lang/CharSequence.java
@@ -71,4 +71,69 @@ public interface CharSequence {
      * @return a string based on this sequence.
      */
     public String toString();
+
+    /// Whether the sequence has no characters.
+    default boolean isEmpty() {
+        return length() == 0;
+    }
+
+    /// The sequence's `char` values, zero-extended to `int`. The
+    /// characters are read when this is called, not when the stream runs,
+    /// which is the same answer as the JDK's for any sequence that is not
+    /// modified between the two.
+    default java.util.stream.IntStream chars() {
+        int n = length();
+        int[] out = new int[n];
+        for (int i = 0; i < n; i++) {
+            out[i] = charAt(i);
+        }
+        return java.util.stream.IntStream.of(out);
+    }
+
+    /// The sequence's code points: a valid surrogate pair becomes one
+    /// supplementary code point, and an unpaired surrogate is passed
+    /// through as its own value, as the JDK does.
+    default java.util.stream.IntStream codePoints() {
+        int n = length();
+        int[] out = new int[n];
+        int count = 0;
+        int i = 0;
+        while (i < n) {
+            char c = charAt(i++);
+            if (Character.isHighSurrogate(c) && i < n) {
+                char d = charAt(i);
+                if (Character.isLowSurrogate(d)) {
+                    i++;
+                    out[count++] = Character.toCodePoint(c, d);
+                    continue;
+                }
+            }
+            out[count++] = c;
+        }
+        if (count == n) {
+            return java.util.stream.IntStream.of(out);
+        }
+        int[] trimmed = new int[count];
+        System.arraycopy(out, 0, trimmed, 0, count);
+        return java.util.stream.IntStream.of(trimmed);
+    }
+
+    /// Compares two sequences lexicographically, char by char, the shorter
+    /// first when one is a prefix of the other.
+    public static int compare(CharSequence cs1, CharSequence cs2) {
+        if (cs1 == cs2) {
+            return 0;
+        }
+        int len1 = cs1.length();
+        int len2 = cs2.length();
+        int n = len1 < len2 ? len1 : len2;
+        for (int i = 0; i < n; i++) {
+            char a = cs1.charAt(i);
+            char b = cs2.charAt(i);
+            if (a != b) {
+                return a - b;
+            }
+        }
+        return len1 - len2;
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Character.java b/vm/JavaAPI/src/java/lang/Character.java
index d86999e8f79..57e8e4144ef 100644
--- a/vm/JavaAPI/src/java/lang/Character.java
+++ b/vm/JavaAPI/src/java/lang/Character.java
@@ -277,8 +277,43 @@ public static int digit(int codePoint, int radix) {
             }
             return result < radix ? result : -1;
         }
-        //return digitImpl(codePoint, radix);
-        return codePoint;
+        // Was "return codePoint", so digit of e-acute in radix 10 answered 233. A
+        // decimal digit of another script, or a fullwidth Latin letter, has
+        // the value the JDK gives it; everything else is not a digit.
+        int result = decimalDigitValue(codePoint);
+        if (result < 0) {
+            if (codePoint >= 0xff21 && codePoint <= 0xff3a) {
+                result = 10 + (codePoint - 0xff21);
+            } else if (codePoint >= 0xff41 && codePoint <= 0xff5a) {
+                result = 10 + (codePoint - 0xff41);
+            }
+        }
+        return result >= 0 && result < radix ? result : -1;
+    }
+
+    /// The zero of every block of ten decimal digits this runtime knows,
+    /// ASCII aside: Arabic-Indic, Extended Arabic-Indic, the Indic scripts,
+    /// Thai, Lao, Tibetan, Myanmar and the fullwidth forms.
+    private static final int[] DECIMAL_ZEROS = {
+        0x0660, 0x06f0, 0x07c0, 0x0966, 0x09e6, 0x0a66, 0x0ae6, 0x0b66, 0x0be6,
+        0x0c66, 0x0ce6, 0x0d66, 0x0de6, 0x0e50, 0x0ed0, 0x0f20, 0x1040, 0x1090,
+        0x17e0, 0x1810, 0xff10
+    };
+
+    private static int decimalDigitValue(int codePoint) {
+        if (codePoint >= '0' && codePoint <= '9') {
+            return codePoint - '0';
+        }
+        if (codePoint < 0x0660 || codePoint > 0xff19) {
+            return -1;
+        }
+        for (int i = 0; i < DECIMAL_ZEROS.length; i++) {
+            int zero = DECIMAL_ZEROS[i];
+            if (codePoint >= zero && codePoint <= zero + 9) {
+                return codePoint - zero;
+            }
+        }
+        return -1;
     }
 
 
@@ -440,8 +475,7 @@ public static boolean isDigit(int codePoint) {
         if (codePoint < 1632) {
             return false;
         }
-        //return isDigitImpl(codePoint);
-        return false;
+        return decimalDigitValue(codePoint) >= 0;
     }
 
     /**
@@ -573,6 +607,18 @@ public static int toUpperCase(int codePoint) {
         if ('a' <= codePoint && codePoint <= 'z') {
             return (char) (codePoint - ('a' - 'A'));
         }
+        // The rest of Latin-1, which this class documents as supported. The
+        // sharp s has no single-char upper case and stays; the micro sign and
+        // y with diaeresis map outside the range, as they do in the JDK.
+        if (codePoint >= 0xe0 && codePoint <= 0xfe && codePoint != 0xf7) {
+            return codePoint - 0x20;
+        }
+        if (codePoint == 0xb5) {
+            return 0x39c;
+        }
+        if (codePoint == 0xff) {
+            return 0x178;
+        }
         /*if (codePoint < 181) {
             return codePoint;
         }
@@ -1324,8 +1370,20 @@ public static boolean isWhitespace(char c) {
         return isWhitespace((int) c);
     }
 
+    /// Whether the char is a Unicode space separator, line separator or
+    /// paragraph separator. Unlike `isWhitespace` this includes the
+    /// no-break spaces and excludes the ASCII control characters.
     public static boolean isSpaceChar(char c) {
-        return c == ' ';
+        return isSpaceChar((int) c);
+    }
+
+    /// Whether the code point is a Unicode space separator, line separator or
+    /// paragraph separator.
+    public static boolean isSpaceChar(int codePoint) {
+        return codePoint == 0x20 || codePoint == 0xa0 || codePoint == 0x1680
+                || codePoint >= 0x2000 && codePoint <= 0x200a
+                || codePoint == 0x2028 || codePoint == 0x2029 || codePoint == 0x202f
+                || codePoint == 0x205f || codePoint == 0x3000;
     }
 
     public static byte getDirectionality(char ch) {
@@ -1337,7 +1395,8 @@ public static int getType(char c) {
     }
 
     public static boolean isBmpCodePoint(int codePoint) {
-        return codePoint > 0 && codePoint <= MAX_VALUE;
+        // U+0000 is in the Basic Multilingual Plane; this used to say "> 0".
+        return codePoint >= 0 && codePoint <= MAX_VALUE;
     }
     
     public static boolean isSurrogate(char ch) {
@@ -1456,11 +1515,55 @@ public static int getType(int codePoint) {
         if (isDigit(codePoint)) {
             return DECIMAL_DIGIT_NUMBER;
         }
-        if (isWhitespace(codePoint)) {
+        if (isTitleCaseLetter(codePoint)) {
+            return TITLECASE_LETTER;
+        }
+        if (isSpaceChar(codePoint) || isWhitespace(codePoint)) {
             return SPACE_SEPARATOR;
         }
+        if (isScriptLetter(codePoint)) {
+            // Without a case table above Latin-1 the letters of the scripts
+            // below cannot be told apart by case, but they are letters: this
+            // is what makes isLetter, isLetterOrDigit and the identifier tests
+            // answer for Greek, Cyrillic, Hebrew, Arabic, the CJK ideographs,
+            // kana and Hangul.
+            return OTHER_LETTER;
+        }
         return UNASSIGNED;
     }
+
+    private static boolean isTitleCaseLetter(int c) {
+        return c == 0x1c5 || c == 0x1c8 || c == 0x1cb || c == 0x1f2
+                || c >= 0x1f88 && c <= 0x1f8f || c >= 0x1f98 && c <= 0x1f9f
+                || c >= 0x1fa8 && c <= 0x1faf || c == 0x1fbc || c == 0x1fcc || c == 0x1ffc;
+    }
+
+    private static boolean isScriptLetter(int c) {
+        return c >= 0x100 && c <= 0x24f // Latin Extended
+                || c >= 0x370 && c <= 0x3ff && c != 0x37e && c != 0x387 && c != 0x375
+                        && c != 0x384 && c != 0x385 && c != 0x3f6 // Greek
+                || c >= 0x400 && c <= 0x481 || c >= 0x48a && c <= 0x52f // Cyrillic
+                || c >= 0x531 && c <= 0x556 || c >= 0x561 && c <= 0x587 // Armenian
+                || c >= 0x5d0 && c <= 0x5ea // Hebrew
+                || c >= 0x620 && c <= 0x64a || c >= 0x671 && c <= 0x6d3 // Arabic
+                || c >= 0x904 && c <= 0x939 // Devanagari
+                || c >= 0xe01 && c <= 0xe30 // Thai
+                || c >= 0x10a0 && c <= 0x10ff && c != 0x10fb // Georgian
+                || c >= 0x1e00 && c <= 0x1fff && !isGreekExtendedSymbol(c) // Latin and Greek Extended Additional
+                || c >= 0x3041 && c <= 0x3096 || c >= 0x30a1 && c <= 0x30fa // Kana
+                || c >= 0x3400 && c <= 0x4dbf || c >= 0x4e00 && c <= 0x9fff // CJK
+                || c >= 0xac00 && c <= 0xd7a3 // Hangul
+                || c >= 0xf900 && c <= 0xfaff // CJK compatibility ideographs
+                || c >= 0xff21 && c <= 0xff3a || c >= 0xff41 && c <= 0xff5a // fullwidth Latin
+                || c >= 0x20000 && c <= 0x3134a; // CJK extensions B-G
+    }
+
+    // Greek Extended holds spacing accents (Sk) and unassigned holes between its letters.
+    private static boolean isGreekExtendedSymbol(int c) {
+        return c == 0x1fbd || c >= 0x1fbf && c <= 0x1fc1 || c >= 0x1fcd && c <= 0x1fcf
+                || c >= 0x1fdd && c <= 0x1fdf || c >= 0x1fed && c <= 0x1fef
+                || c >= 0x1ffd && c <= 0x1fff;
+    }
     
     /**
      * Returns true if the given code point is a Unicode whitespace character.
@@ -1525,7 +1628,241 @@ public static int toTitleCase(int codePoint) {
     public static char toTitleCase(char c) {
         return String.valueOf(c).toUpperCase().charAt(0);
     }
-    
+
+    // ---------------------------------------------------------------------
+    // The members of the JDK's Character the class did not have, in plain
+    // Java over the classification above.
+    // ---------------------------------------------------------------------
+
+    /// The size of a char in bytes.
+    public static final int BYTES = 2;
+
+    /// Throws the JDK's exception for a value that is not a code point.
+    static void checkCodePoint(int codePoint) {
+        if (!isValidCodePoint(codePoint)) {
+            throw new IllegalArgumentException("Not a valid Unicode code point: 0x" + upperHex(codePoint));
+        }
+    }
+
+    private static String upperHex(int value) {
+        String digits = "0123456789ABCDEF";
+        char[] out = new char[8];
+        int at = 8;
+        do {
+            out[--at] = digits.charAt(value & 0xf);
+            value >>>= 4;
+        } while (value != 0);
+        return new String(out, at, 8 - at);
+    }
+
+    /// A one-char string of `c`.
+    public static String toString(char c) {
+        return String.valueOf(c);
+    }
+
+    /// The string of the code point: one char, or a surrogate pair.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if it is not a valid code point
+    public static String toString(int codePoint) {
+        checkCodePoint(codePoint);
+        if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) {
+            return String.valueOf((char) codePoint);
+        }
+        return new String(new char[] {highSurrogate(codePoint), lowSurrogate(codePoint)});
+    }
+
+    /// The char itself, as the JDK hashes it.
+    public static int hashCode(char value) {
+        return value;
+    }
+
+    /// `x - y`.
+    public static int compare(char x, char y) {
+        return x - y;
+    }
+
+    /// Whether the char is an ISO control character: U+0000 to U+001F or
+    /// U+007F to U+009F.
+    public static boolean isISOControl(char ch) {
+        return isISOControl((int) ch);
+    }
+
+    /// Whether the code point is an ISO control character.
+    public static boolean isISOControl(int codePoint) {
+        return codePoint >= 0 && codePoint <= 0x1f || codePoint >= 0x7f && codePoint <= 0x9f;
+    }
+
+    /// The char of `digit` in `radix`, a lower case letter from 10 on, or
+    /// U+0000 when either is out of range.
+    public static char forDigit(int digit, int radix) {
+        if (radix < MIN_RADIX || radix > MAX_RADIX || digit < 0 || digit >= radix) {
+            return '\0';
+        }
+        return (char) (digit < 10 ? '0' + digit : 'a' + digit - 10);
+    }
+
+    /// The value of a digit, or of a Latin letter read as a digit of base
+    /// 36, or of a numeric symbol this runtime knows (superscripts,
+    /// subscripts, Roman numerals, circled numbers); -2 for a vulgar fraction,
+    /// which has a value but not an integral one; otherwise -1.
+    public static int getNumericValue(char ch) {
+        return getNumericValue((int) ch);
+    }
+
+    /// The value of a digit, or of a Latin letter read as a digit of base
+    /// 36, or of a numeric symbol this runtime knows (superscripts,
+    /// subscripts, Roman numerals, circled numbers); -2 for a vulgar fraction,
+    /// which has a value but not an integral one; otherwise -1.
+    public static int getNumericValue(int codePoint) {
+        int value = digit(codePoint, MAX_RADIX);
+        return value >= 0 || codePoint < 0xb2 ? value : numericSymbolValue(codePoint);
+    }
+
+    /// Ranges of numeric symbols as {first, last, value of first}; each code
+    /// point after the first is worth one more. A first value of -2 marks a
+    /// range of fractions, all of them -2.
+    private static final int[] NUMERIC_RANGES = {
+        0x00b2, 0x00b3, 2,
+        0x00b9, 0x00b9, 1,
+        0x00bc, 0x00be, -2,
+        0x2070, 0x2070, 0,
+        0x2074, 0x2079, 4,
+        0x2080, 0x2089, 0,
+        0x2150, 0x215e, -2,
+        0x215f, 0x215f, 1,
+        0x2160, 0x216b, 1,
+        0x2170, 0x217b, 1,
+        0x2460, 0x2473, 1,
+        0x2474, 0x2487, 1,
+        0x2488, 0x249b, 1,
+        0x24ea, 0x24ea, 0,
+        0x24eb, 0x24f4, 11,
+        0x24f5, 0x24fe, 1,
+        0x24ff, 0x24ff, 0,
+        0x2776, 0x277f, 1,
+        0x2780, 0x2789, 1,
+        0x278a, 0x2793, 1
+    };
+
+    private static int numericSymbolValue(int codePoint) {
+        for (int i = 0; i < NUMERIC_RANGES.length; i += 3) {
+            if (codePoint >= NUMERIC_RANGES[i] && codePoint <= NUMERIC_RANGES[i + 1]) {
+                int first = NUMERIC_RANGES[i + 2];
+                return first == -2 ? -2 : first + codePoint - NUMERIC_RANGES[i];
+            }
+        }
+        // The Roman numerals past twelve: L, C, D and M, upper and lower case.
+        if (codePoint >= 0x216c && codePoint <= 0x216f || codePoint >= 0x217c && codePoint <= 0x217f) {
+            int k = (codePoint - 0x216c) % 16;
+            return k == 0 ? 50 : k == 1 ? 100 : k == 2 ? 500 : 1000;
+        }
+        return -1;
+    }
+
+    /// Whether the code point is alphabetic. This runtime answers as for
+    /// `isLetter`.
+    public static boolean isAlphabetic(int codePoint) {
+        return isLetter(codePoint);
+    }
+
+    /// Whether the char has a category in this runtime's classification.
+    public static boolean isDefined(char ch) {
+        return isDefined((int) ch);
+    }
+
+    /// Whether the code point has a category in this runtime's
+    /// classification. Above Latin-1 that classification is partial, so an
+    /// assigned symbol it does not know answers false.
+    public static boolean isDefined(int codePoint) {
+        return getType(codePoint) != UNASSIGNED;
+    }
+
+    /// Whether the code point is a CJK ideograph.
+    public static boolean isIdeographic(int codePoint) {
+        return codePoint >= 0x3400 && codePoint <= 0x4dbf || codePoint >= 0x4e00 && codePoint <= 0x9fff
+                || codePoint >= 0xf900 && codePoint <= 0xfaff || codePoint >= 0x20000 && codePoint <= 0x3134a
+                || codePoint == 0x3006 || codePoint == 0x3007 || codePoint >= 0x3021 && codePoint <= 0x3029
+                || codePoint >= 0x3038 && codePoint <= 0x303a;
+    }
+
+    /// Whether the char is a title case letter.
+    public static boolean isTitleCase(char ch) {
+        return isTitleCaseLetter(ch);
+    }
+
+    /// Whether the code point is a title case letter.
+    public static boolean isTitleCase(int codePoint) {
+        return isTitleCaseLetter(codePoint);
+    }
+
+    /// Whether the char is mirrored in right-to-left text: the ASCII
+    /// brackets and the guillemets.
+    public static boolean isMirrored(char ch) {
+        return isMirrored((int) ch);
+    }
+
+    /// Whether the code point is mirrored in right-to-left text. This
+    /// runtime knows the ASCII brackets and the guillemets.
+    public static boolean isMirrored(int codePoint) {
+        switch (codePoint) {
+            case '(':
+            case ')':
+            case '<':
+            case '>':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case 0xab:
+            case 0xbb:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /// The ISO-LATIN-1 white space of the old JDK: tab, line feed, form feed,
+    /// carriage return and space.
+    @Deprecated
+    public static boolean isSpace(char ch) {
+        return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f' || ch == '\r';
+    }
+
+    /// As `isJavaIdentifierStart(char)`.
+    @Deprecated
+    public static boolean isJavaLetter(char ch) {
+        return isJavaIdentifierStart(ch);
+    }
+
+    /// As `isJavaIdentifierPart(char)`.
+    @Deprecated
+    public static boolean isJavaLetterOrDigit(char ch) {
+        return isJavaIdentifierPart(ch);
+    }
+
+    /// Whether the char may start a Unicode identifier.
+    public static boolean isUnicodeIdentifierStart(char ch) {
+        return isUnicodeIdentifierStart((int) ch);
+    }
+
+    /// Whether the code point may start a Unicode identifier: a letter.
+    public static boolean isUnicodeIdentifierStart(int codePoint) {
+        return isLetter(codePoint);
+    }
+
+    /// Whether the char may continue a Unicode identifier.
+    public static boolean isUnicodeIdentifierPart(char ch) {
+        return isUnicodeIdentifierPart((int) ch);
+    }
+
+    /// Whether the code point may continue a Unicode identifier: a letter, a
+    /// digit, connecting punctuation or an ignorable character.
+    public static boolean isUnicodeIdentifierPart(int codePoint) {
+        return isLetterOrDigit(codePoint) || getType(codePoint) == CONNECTOR_PUNCTUATION
+                || isIdentifierIgnorable(codePoint);
+    }
 }
 
 
diff --git a/vm/JavaAPI/src/java/lang/Class.java b/vm/JavaAPI/src/java/lang/Class.java
index 79da8c77e3b..d0009b4d2b8 100644
--- a/vm/JavaAPI/src/java/lang/Class.java
+++ b/vm/JavaAPI/src/java/lang/Class.java
@@ -574,4 +574,10 @@ public boolean isLocalClass() {
     public boolean isRecord() {
         return this != java.lang.Record.class && java.lang.Record.class.isAssignableFrom(this);
     }
+
+    /// The module this class is in: the unnamed module, for every class, as
+    /// for a class the JDK loaded from the class path.
+    public Module getModule() {
+        return Module.unnamed();
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Double.java b/vm/JavaAPI/src/java/lang/Double.java
index 39d026c98d8..583bc91ff00 100644
--- a/vm/JavaAPI/src/java/lang/Double.java
+++ b/vm/JavaAPI/src/java/lang/Double.java
@@ -395,4 +395,64 @@ public static double max(double a, double b) {
     public static double min(double a, double b) {
         return Math.min(a, b);
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// The size of a double in bytes.
+    public static final int BYTES = 8;
+
+    /// The bits of precision of a double's significand.
+    public static final int PRECISION = 53;
+
+    /// The smallest positive normal double, 2 to the power -1022.
+    public static final double MIN_NORMAL = 0x1.0p-1022;
+
+    /// A Double of `parseDouble(s)`.
+    @Deprecated
+    public Double(String s) throws NumberFormatException {
+        this(parseDouble(s));
+    }
+
+    /// Whether `d` is neither infinite nor NaN.
+    public static boolean isFinite(double d) {
+        return d - d == 0.0;
+    }
+
+    /// The hash the JDK gives `value`: its bits folded to an int.
+    public static int hashCode(double value) {
+        long bits = doubleToLongBits(value);
+        return (int) (bits ^ (bits >>> 32));
+    }
+
+    /// The value as a hexadecimal floating point literal, as the JDK writes
+    /// it: `0x1.8p1` for 3.0, `0x0.0p0` for zero.
+    public static String toHexString(double d) {
+        if (isNaN(d)) {
+            return "NaN";
+        }
+        if (isInfinite(d)) {
+            return d > 0 ? "Infinity" : "-Infinity";
+        }
+        long bits = doubleToRawLongBits(d);
+        StringBuilder out = new StringBuilder(24);
+        if (bits < 0) {
+            out.append('-');
+        }
+        long exponentBits = (bits >>> 52) & 0x7ff;
+        long significand = bits & 0x000fffffffffffffL;
+        if (exponentBits == 0 && significand == 0) {
+            return out.append("0x0.0p0").toString();
+        }
+        out.append(exponentBits == 0 ? "0x0." : "0x1.");
+        String digits = Long.toHexString(significand | 0x0010000000000000L).substring(1);
+        int end = digits.length();
+        while (end > 1 && digits.charAt(end - 1) == '0') {
+            end--;
+        }
+        out.append(digits, 0, end).append('p');
+        out.append(exponentBits == 0 ? MIN_EXPONENT : (int) exponentBits - 1023);
+        return out.toString();
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Float.java b/vm/JavaAPI/src/java/lang/Float.java
index acb17f1c682..a1ddedd2360 100644
--- a/vm/JavaAPI/src/java/lang/Float.java
+++ b/vm/JavaAPI/src/java/lang/Float.java
@@ -136,14 +136,13 @@ public boolean equals(java.lang.Object obj){
      * method, will produce a floating-point value equal to the argument to floatToIntBits.
      */
     /**
-     * The raw IEEE 754 bits of {@code value}, without collapsing NaN to the
-     * canonical NaN.
+     * The raw IEEE 754 bits of {@code value}.
      *
-     * Delegates rather than declaring a second native. ParparVM's floatToIntBits
-     * is a bare union punt that does not collapse NaN to the canonical NaN -- so it
-     * is already the raw operation, and the two differ in the spec but not here. A
-     * separate native would be one more mangled symbol to get wrong, silently, for
-     * no behavioural difference.
+     * Delegates rather than declaring a second native, so a NaN comes back as
+     * the canonical NaN here too: floatToIntBits collapses it, as the spec asks
+     * and as Float.equals needs, and a NaN's payload is the one thing this
+     * cannot report. A separate native would be one more mangled symbol to get
+     * wrong, silently, for that alone.
      */
     public static int floatToRawIntBits(float value) {
         return floatToIntBits(value);
@@ -373,4 +372,55 @@ public static float max(float a, float b) {
     public static float min(float a, float b) {
         return Math.min(a, b);
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// The size of a float in bytes.
+    public static final int BYTES = 4;
+
+    /// The size of a float in bits.
+    public static final int SIZE = 32;
+
+    /// The bits of precision of a float's significand.
+    public static final int PRECISION = 24;
+
+    /// The largest exponent of a finite float.
+    public static final int MAX_EXPONENT = 127;
+
+    /// The smallest exponent of a normal float.
+    public static final int MIN_EXPONENT = -126;
+
+    /// The smallest positive normal float, 2 to the power -126.
+    public static final float MIN_NORMAL = 0x1.0p-126f;
+
+    /// A Float of `parseFloat(s)`.
+    @Deprecated
+    public Float(String s) throws NumberFormatException {
+        this(parseFloat(s));
+    }
+
+    /// Whether `f` is neither infinite nor NaN.
+    public static boolean isFinite(float f) {
+        return f - f == 0.0f;
+    }
+
+    /// The hash the JDK gives `value`: its bits.
+    public static int hashCode(float value) {
+        return floatToIntBits(value);
+    }
+
+    /// The value as a hexadecimal floating point literal, as the JDK writes
+    /// it.
+    public static String toHexString(float f) {
+        if (f != 0.0f && Math.abs(f) < MIN_NORMAL) {
+            // A subnormal float is a normal double; scale it to the double
+            // subnormal with the same significand bits, exactly, and name the
+            // float exponent instead of the double one.
+            String s = Double.toHexString((double) f * 0x1.0p-896);
+            return s.substring(0, s.length() - "p-1022".length()) + "p-126";
+        }
+        return Double.toHexString(f);
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Integer.java b/vm/JavaAPI/src/java/lang/Integer.java
index 0bce3d81bbf..4db41b3b6e8 100644
--- a/vm/JavaAPI/src/java/lang/Integer.java
+++ b/vm/JavaAPI/src/java/lang/Integer.java
@@ -134,23 +134,21 @@ public static int parseInt(java.lang.String s) throws java.lang.NumberFormatExce
      * parseInt("0", 10) returns 0 parseInt("473", 10) returns 473 parseInt("-0", 10) returns 0 parseInt("-FF", 16) returns -255 parseInt("1100110", 2) returns 102 parseInt("2147483647", 10) returns 2147483647 parseInt("-2147483648", 10) returns -2147483648 parseInt("2147483648", 10) throws a NumberFormatException parseInt("99", 8) throws a NumberFormatException parseInt("Kona", 10) throws a NumberFormatException parseInt("Kona", 27) returns 411787
      */
     public static int parseInt(String string, int radix) throws NumberFormatException {
-        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
-            throw new NumberFormatException("Invalid radix");
-        }
         if (string == null) {
-            throw invalidInt(string);
+            throw new NumberFormatException("Cannot parse null string");
         }
+        checkRadix(radix);
         int length = string.length(), i = 0;
         if (length == 0) {
-            throw invalidInt(string);
+            throw invalidInt(string, radix);
         }
         boolean negative = string.charAt(i) == '-';
         if (negative && ++i == length) {
-            throw invalidInt(string);
+            throw invalidInt(string, radix);
         }
-        boolean positive = string.charAt(i) == '+';
+        boolean positive = !negative && string.charAt(i) == '+';
         if (positive && ++i == length) {
-            throw invalidInt(string);
+            throw invalidInt(string, radix);
         }
 
         return parse(string, i, radix, negative);
@@ -162,28 +160,39 @@ private static int parse(String string, int offset, int radix, boolean negative)
         while (offset < length) {
             int digit = Character.digit(string.charAt(offset++), radix);
             if (digit == -1) {
-                throw invalidInt(string);
+                throw invalidInt(string, radix);
             }
             if (max > result) {
-                throw invalidInt(string);
+                throw invalidInt(string, radix);
             }
             int next = result * radix - digit;
             if (next > result) {
-                throw invalidInt(string);
+                throw invalidInt(string, radix);
             }
             result = next;
         }
         if (!negative) {
             result = -result;
             if (result < 0) {
-                throw invalidInt(string);
+                throw invalidInt(string, radix);
             }
         }
         return result;
     }
 
-    private static NumberFormatException invalidInt(String s) {
-        throw new NumberFormatException("Invalid int");
+    private static NumberFormatException invalidInt(String s, int radix) {
+        return new NumberFormatException("For input string: \"" + s + "\""
+                + (radix == 10 ? "" : " under radix " + radix));
+    }
+
+    // The JDK's messages for a radix outside [MIN_RADIX, MAX_RADIX].
+    static void checkRadix(int radix) {
+        if (radix < Character.MIN_RADIX) {
+            throw new NumberFormatException("radix " + radix + " less than Character.MIN_RADIX");
+        }
+        if (radix > Character.MAX_RADIX) {
+            throw new NumberFormatException("radix " + radix + " greater than Character.MAX_RADIX");
+        }
     }
 
 
@@ -444,4 +453,216 @@ public static int max(int a, int b) {
     public static int min(int a, int b) {
         return Math.min(a, b);
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// The size of an int in bytes.
+    public static final int BYTES = 4;
+
+    /// The size of an int in bits.
+    public static final int SIZE = 32;
+
+    /// An Integer of `parseInt(s)`.
+    @Deprecated
+    public Integer(String s) throws NumberFormatException {
+        this(parseInt(s));
+    }
+
+    /// The value itself.
+    public static int hashCode(int value) {
+        return value;
+    }
+
+    /// The number of one bits.
+    public static int bitCount(int i) {
+        i = i - ((i >>> 1) & 0x55555555);
+        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+        i = (i + (i >>> 4)) & 0x0f0f0f0f;
+        i = i + (i >>> 8);
+        i = i + (i >>> 16);
+        return i & 0x3f;
+    }
+
+    /// The highest one bit alone, or 0.
+    public static int highestOneBit(int i) {
+        return i == 0 ? 0 : 0x80000000 >>> numberOfLeadingZeros(i);
+    }
+
+    /// The lowest one bit alone, or 0.
+    public static int lowestOneBit(int i) {
+        return i & -i;
+    }
+
+    /// The number of zero bits below the lowest one bit; 32 for zero.
+    public static int numberOfTrailingZeros(int i) {
+        if (i == 0) {
+            return 32;
+        }
+        int n = 0;
+        while ((i & 1) == 0) {
+            i >>>= 1;
+            n++;
+        }
+        return n;
+    }
+
+    /// The bits in reverse order.
+    public static int reverse(int i) {
+        i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
+        i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
+        i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
+        return reverseBytes(i);
+    }
+
+    /// The bytes in reverse order.
+    public static int reverseBytes(int i) {
+        return (i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24);
+    }
+
+    /// The bits rotated right by `distance`.
+    public static int rotateRight(int i, int distance) {
+        return (i >>> distance) | (i << -distance);
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(int x, int y) {
+        return compare(x + MIN_VALUE, y + MIN_VALUE);
+    }
+
+    /// The value as an unsigned long.
+    public static long toUnsignedLong(int x) {
+        return ((long) x) & 0xffffffffL;
+    }
+
+    /// The unsigned quotient.
+    public static int divideUnsigned(int dividend, int divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        return (int) (toUnsignedLong(dividend) / toUnsignedLong(divisor));
+    }
+
+    /// The unsigned remainder.
+    public static int remainderUnsigned(int dividend, int divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        return (int) (toUnsignedLong(dividend) % toUnsignedLong(divisor));
+    }
+
+    /// The value as an unsigned decimal string.
+    public static String toUnsignedString(int i) {
+        return Long.toString(toUnsignedLong(i));
+    }
+
+    /// The value as an unsigned string in `radix`.
+    public static String toUnsignedString(int i, int radix) {
+        return Long.toString(toUnsignedLong(i), radix);
+    }
+
+    /// Parses an unsigned decimal int.
+    public static int parseUnsignedInt(String s) throws NumberFormatException {
+        return parseUnsignedInt(s, 10);
+    }
+
+    /// Parses an unsigned int in `radix`.
+    public static int parseUnsignedInt(String s, int radix) throws NumberFormatException {
+        if (s == null) {
+            throw new NumberFormatException("Cannot parse null string: null");
+        }
+        if (s.length() > 0 && s.charAt(0) == '-') {
+            throw new NumberFormatException("Illegal leading minus sign on unsigned string " + s + ".");
+        }
+        long value = Long.parseLong(s, radix);
+        if ((value & 0xffffffff00000000L) != 0) {
+            throw new NumberFormatException("String value " + s + " exceeds range of unsigned int.");
+        }
+        return (int) value;
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as a signed int.
+    public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
+            throw new IndexOutOfBoundsException();
+        }
+        return parseInt(s.subSequence(beginIndex, endIndex).toString(), radix);
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as an unsigned int.
+    public static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
+            throw new IndexOutOfBoundsException();
+        }
+        return parseUnsignedInt(s.subSequence(beginIndex, endIndex).toString(), radix);
+    }
+
+    /// Decodes a decimal, `0x`, `0X`, `#` or leading-zero octal int, with an
+    /// optional sign.
+    public static Integer decode(String nm) throws NumberFormatException {
+        int[] radix = new int[1];
+        String digits = Long.decodeDigits(nm, radix);
+        return valueOf(parseInt(digits, radix[0]));
+    }
+
+    /// The system property `nm` as an Integer, or null.
+    public static Integer getInteger(String nm) {
+        return getInteger(nm, null);
+    }
+
+    /// The system property `nm` as an Integer, or `val`.
+    public static Integer getInteger(String nm, int val) {
+        Integer result = getInteger(nm, null);
+        return result == null ? valueOf(val) : result;
+    }
+
+    /// The system property `nm` decoded as an Integer, or `val` when it is
+    /// unset or not a number.
+    public static Integer getInteger(String nm, Integer val) {
+        String v = null;
+        if (nm != null && nm.length() > 0) {
+            v = System.getProperty(nm);
+        }
+        if (v != null) {
+            try {
+                return decode(v);
+            } catch (NumberFormatException e) {
+                // fall through to the default, as the JDK does
+            }
+        }
+        return val;
+    }
+
+    /// The bits of `i` selected by `mask`, packed to the low end.
+    public static int compress(int i, int mask) {
+        int result = 0;
+        int out = 0;
+        for (int bit = 0; bit < 32; bit++) {
+            if ((mask & (1 << bit)) != 0) {
+                if ((i & (1 << bit)) != 0) {
+                    result |= 1 << out;
+                }
+                out++;
+            }
+        }
+        return result;
+    }
+
+    /// The low bits of `i` spread to the positions of the one bits of `mask`.
+    public static int expand(int i, int mask) {
+        int result = 0;
+        int in = 0;
+        for (int bit = 0; bit < 32; bit++) {
+            if ((mask & (1 << bit)) != 0) {
+                if ((i & (1 << in)) != 0) {
+                    result |= 1 << bit;
+                }
+                in++;
+            }
+        }
+        return result;
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Iterable.java b/vm/JavaAPI/src/java/lang/Iterable.java
index 3349bf0e94e..cfe3476c102 100644
--- a/vm/JavaAPI/src/java/lang/Iterable.java
+++ b/vm/JavaAPI/src/java/lang/Iterable.java
@@ -47,4 +47,9 @@ default void forEach(Consumer<? super T> action) {
             action.accept(t);
         }
     }
+
+    /// The elements, as a [java.util.Spliterator] whose size is not known.
+    default java.util.Spliterator<T> spliterator() {
+        return java.util.Spliterators.spliteratorUnknownSize(iterator(), 0);
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/Long.java b/vm/JavaAPI/src/java/lang/Long.java
index f3eec2696df..556864ec031 100644
--- a/vm/JavaAPI/src/java/lang/Long.java
+++ b/vm/JavaAPI/src/java/lang/Long.java
@@ -138,19 +138,21 @@ public static long parseLong(java.lang.String s) throws java.lang.NumberFormatEx
      * parseLong("0", 10) returns 0L parseLong("473", 10) returns 473L parseLong("-0", 10) returns 0L parseLong("-FF", 16) returns -255L parseLong("1100110", 2) returns 102L parseLong("99", 8) throws a NumberFormatException parseLong("Hazelnut", 10) throws a NumberFormatException parseLong("Hazelnut", 36) returns 1356099454469L
      */
     public static long parseLong(String string, int radix) throws NumberFormatException {
-        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
-            throw new NumberFormatException("Invalid radix: " + radix);
-        }
         if (string == null) {
-            throw invalidLong(string);
+            throw new NumberFormatException("Cannot parse null string");
         }
+        Integer.checkRadix(radix);
         int length = string.length(), i = 0;
         if (length == 0) {
-            throw invalidLong(string);
+            throw invalidLong(string, radix);
         }
         boolean negative = string.charAt(i) == '-';
         if (negative && ++i == length) {
-            throw invalidLong(string);
+            throw invalidLong(string, radix);
+        }
+        boolean positive = !negative && string.charAt(i) == '+';
+        if (positive && ++i == length) {
+            throw invalidLong(string, radix);
         }
 
         return parse(string, i, radix, negative);
@@ -162,28 +164,29 @@ private static long parse(String string, int offset, int radix, boolean negative
         while (offset < length) {
             int digit = Character.digit(string.charAt(offset++), radix);
             if (digit == -1) {
-                throw invalidLong(string);
+                throw invalidLong(string, radix);
             }
             if (max > result) {
-                throw invalidLong(string);
+                throw invalidLong(string, radix);
             }
             long next = result * radix - digit;
             if (next > result) {
-                throw invalidLong(string);
+                throw invalidLong(string, radix);
             }
             result = next;
         }
         if (!negative) {
             result = -result;
             if (result < 0) {
-                throw invalidLong(string);
+                throw invalidLong(string, radix);
             }
         }
         return result;
     }
 
-    private static NumberFormatException invalidLong(String s) {
-        throw new NumberFormatException("Invalid long: \"" + s + "\"");
+    private static NumberFormatException invalidLong(String s, int radix) {
+        return new NumberFormatException("For input string: \"" + s + "\""
+                + (radix == 10 ? "" : " under radix " + radix));
     }
 
     /**
@@ -286,4 +289,318 @@ public static long max(long a, long b) {
     public static long min(long a, long b) {
         return Math.min(a, b);
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// The size of a long in bytes.
+    public static final int BYTES = 8;
+
+    /// The size of a long in bits.
+    public static final int SIZE = 64;
+
+    /// A Long of `parseLong(s)`.
+    @Deprecated
+    public Long(String s) throws NumberFormatException {
+        this(parseLong(s));
+    }
+
+    /// A Long of `parseLong(s)`.
+    public static Long valueOf(String s) throws NumberFormatException {
+        return valueOf(parseLong(s, 10));
+    }
+
+    /// A Long of `parseLong(s, radix)`.
+    public static Long valueOf(String s, int radix) throws NumberFormatException {
+        return valueOf(parseLong(s, radix));
+    }
+
+    /// The number of one bits.
+    public static int bitCount(long i) {
+        return Integer.bitCount((int) i) + Integer.bitCount((int) (i >>> 32));
+    }
+
+    /// The highest one bit alone, or 0.
+    public static long highestOneBit(long i) {
+        return i == 0 ? 0 : 0x8000000000000000L >>> numberOfLeadingZeros(i);
+    }
+
+    /// The lowest one bit alone, or 0.
+    public static long lowestOneBit(long i) {
+        return i & -i;
+    }
+
+    /// The number of zero bits above the highest one bit; 64 for zero.
+    public static int numberOfLeadingZeros(long i) {
+        int high = (int) (i >>> 32);
+        return high != 0 ? Integer.numberOfLeadingZeros(high) : 32 + Integer.numberOfLeadingZeros((int) i);
+    }
+
+    /// The number of zero bits below the lowest one bit; 64 for zero.
+    public static int numberOfTrailingZeros(long i) {
+        int low = (int) i;
+        return low != 0 ? Integer.numberOfTrailingZeros(low) : 32 + Integer.numberOfTrailingZeros((int) (i >>> 32));
+    }
+
+    /// The bits in reverse order.
+    public static long reverse(long i) {
+        return ((long) Integer.reverse((int) i) << 32) | (Integer.reverse((int) (i >>> 32)) & 0xffffffffL);
+    }
+
+    /// The bytes in reverse order.
+    public static long reverseBytes(long i) {
+        return ((long) Integer.reverseBytes((int) i) << 32) | (Integer.reverseBytes((int) (i >>> 32)) & 0xffffffffL);
+    }
+
+    /// The bits rotated left by `distance`.
+    public static long rotateLeft(long i, int distance) {
+        return (i << distance) | (i >>> -distance);
+    }
+
+    /// The bits rotated right by `distance`.
+    public static long rotateRight(long i, int distance) {
+        return (i >>> distance) | (i << -distance);
+    }
+
+    /// -1, 0 or 1 by the sign of `i`.
+    public static int signum(long i) {
+        return (int) ((i >> 63) | (-i >>> 63));
+    }
+
+    /// The value as unsigned hexadecimal digits.
+    public static String toHexString(long i) {
+        return toPow2String(i, 4);
+    }
+
+    /// The value as unsigned octal digits.
+    public static String toOctalString(long i) {
+        return toPow2String(i, 3);
+    }
+
+    /// The value as unsigned binary digits.
+    public static String toBinaryString(long i) {
+        return toPow2String(i, 1);
+    }
+
+    private static String toPow2String(long i, int shift) {
+        char[] buf = new char[64];
+        int at = 64;
+        long mask = (1L << shift) - 1;
+        do {
+            buf[--at] = Character.forDigit((int) (i & mask), 1 << shift);
+            i >>>= shift;
+        } while (i != 0);
+        return new String(buf, at, 64 - at);
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(long x, long y) {
+        return compare(x + MIN_VALUE, y + MIN_VALUE);
+    }
+
+    /// The unsigned quotient.
+    public static long divideUnsigned(long dividend, long divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (divisor < 0) {
+            return compareUnsigned(dividend, divisor) < 0 ? 0 : 1;
+        }
+        if (dividend >= 0) {
+            return dividend / divisor;
+        }
+        long quotient = ((dividend >>> 1) / divisor) << 1;
+        long rem = dividend - quotient * divisor;
+        return quotient + (compareUnsigned(rem, divisor) >= 0 ? 1 : 0);
+    }
+
+    /// The unsigned remainder.
+    public static long remainderUnsigned(long dividend, long divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        return dividend - divideUnsigned(dividend, divisor) * divisor;
+    }
+
+    /// The value as an unsigned decimal string.
+    public static String toUnsignedString(long i) {
+        return toUnsignedString(i, 10);
+    }
+
+    /// The value as an unsigned string in `radix`.
+    public static String toUnsignedString(long i, int radix) {
+        if (i >= 0) {
+            return toString(i, radix);
+        }
+        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
+            radix = 10;
+        }
+        long quotient = divideUnsigned(i, radix);
+        long rem = i - quotient * radix;
+        return toString(quotient, radix) + Character.forDigit((int) rem, radix);
+    }
+
+    /// Parses an unsigned decimal long.
+    public static long parseUnsignedLong(String s) throws NumberFormatException {
+        return parseUnsignedLong(s, 10);
+    }
+
+    /// Parses an unsigned long in `radix`.
+    public static long parseUnsignedLong(String s, int radix) throws NumberFormatException {
+        if (s == null) {
+            throw new NumberFormatException("Cannot parse null string: null");
+        }
+        int len = s.length();
+        if (len == 0) {
+            throw new NumberFormatException("For input string: \"\"" + (radix == 10 ? "" : " under radix " + radix));
+        }
+        if (s.charAt(0) == '-') {
+            throw new NumberFormatException("Illegal leading minus sign on unsigned string " + s + ".");
+        }
+        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
+            throw new NumberFormatException("radix " + radix + " out of range");
+        }
+        int start = s.charAt(0) == '+' ? 1 : 0;
+        if (start == len) {
+            throw new NumberFormatException("For input string: \"" + s + "\"" + (radix == 10 ? "" : " under radix " + radix));
+        }
+        long limit = divideUnsigned(-1L, radix);
+        long result = 0;
+        for (int i = start; i < len; i++) {
+            int d = Character.digit(s.charAt(i), radix);
+            if (d < 0) {
+                throw new NumberFormatException("For input string: \"" + s + "\"" + (radix == 10 ? "" : " under radix " + radix));
+            }
+            if (compareUnsigned(result, limit) > 0) {
+                throw new NumberFormatException("String value " + s + " exceeds range of unsigned long.");
+            }
+            long shifted = result * radix;
+            long next = shifted + d;
+            if (compareUnsigned(next, shifted) < 0) {
+                throw new NumberFormatException("String value " + s + " exceeds range of unsigned long.");
+            }
+            result = next;
+        }
+        return result;
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as a signed long.
+    public static long parseLong(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
+            throw new IndexOutOfBoundsException();
+        }
+        return parseLong(s.subSequence(beginIndex, endIndex).toString(), radix);
+    }
+
+    /// Parses `s` from `beginIndex` to `endIndex` as an unsigned long.
+    public static long parseUnsignedLong(CharSequence s, int beginIndex, int endIndex, int radix)
+            throws NumberFormatException {
+        if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
+            throw new IndexOutOfBoundsException();
+        }
+        return parseUnsignedLong(s.subSequence(beginIndex, endIndex).toString(), radix);
+    }
+
+    /// Decodes a decimal, `0x`, `0X`, `#` or leading-zero octal long, with an
+    /// optional sign.
+    public static Long decode(String nm) throws NumberFormatException {
+        int[] radix = new int[1];
+        String digits = decodeDigits(nm, radix);
+        return valueOf(parseLong(digits, radix[0]));
+    }
+
+    /// The number `decode` reads from `nm`, in the JDK's grammar: an
+    /// optional sign, then `0x`, `0X` or `#` for hexadecimal or a leading zero
+    /// for octal. Answers the signed digits to parse; the radix goes in
+    /// `radixOut[0]`.
+    static String decodeDigits(String nm, int[] radixOut) throws NumberFormatException {
+        if (nm.length() == 0) {
+            throw new NumberFormatException("Zero length string");
+        }
+        int radix = 10;
+        int index = 0;
+        boolean negative = false;
+        char first = nm.charAt(0);
+        if (first == '-') {
+            negative = true;
+            index++;
+        } else if (first == '+') {
+            index++;
+        }
+        if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
+            index += 2;
+            radix = 16;
+        } else if (nm.startsWith("#", index)) {
+            index++;
+            radix = 16;
+        } else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
+            index++;
+            radix = 8;
+        }
+        if (nm.startsWith("-", index) || nm.startsWith("+", index)) {
+            throw new NumberFormatException("Sign character in wrong position");
+        }
+        radixOut[0] = radix;
+        return negative ? "-" + nm.substring(index) : nm.substring(index);
+    }
+
+    /// The system property `nm` as a Long, or null.
+    public static Long getLong(String nm) {
+        return getLong(nm, null);
+    }
+
+    /// The system property `nm` as a Long, or `val`.
+    public static Long getLong(String nm, long val) {
+        Long result = getLong(nm, null);
+        return result == null ? valueOf(val) : result;
+    }
+
+    /// The system property `nm` decoded as a Long, or `val` when it is unset
+    /// or not a number.
+    public static Long getLong(String nm, Long val) {
+        String v = null;
+        if (nm != null && nm.length() > 0) {
+            v = System.getProperty(nm);
+        }
+        if (v != null) {
+            try {
+                return decode(v);
+            } catch (NumberFormatException e) {
+                // fall through to the default, as the JDK does
+            }
+        }
+        return val;
+    }
+
+    /// The bits of `i` selected by `mask`, packed to the low end.
+    public static long compress(long i, long mask) {
+        long result = 0;
+        int out = 0;
+        for (int bit = 0; bit < 64; bit++) {
+            if ((mask & (1L << bit)) != 0) {
+                if ((i & (1L << bit)) != 0) {
+                    result |= 1L << out;
+                }
+                out++;
+            }
+        }
+        return result;
+    }
+
+    /// The low bits of `i` spread to the positions of the one bits of `mask`.
+    public static long expand(long i, long mask) {
+        long result = 0;
+        int in = 0;
+        for (int bit = 0; bit < 64; bit++) {
+            if ((mask & (1L << bit)) != 0) {
+                if ((i & (1L << in)) != 0) {
+                    result |= 1L << bit;
+                }
+                in++;
+            }
+        }
+        return result;
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/MatchException.java b/vm/JavaAPI/src/java/lang/MatchException.java
new file mode 100644
index 00000000000..eb3e1aab5dd
--- /dev/null
+++ b/vm/JavaAPI/src/java/lang/MatchException.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang;
+
+/// `java.lang.MatchException`: what a `switch` over patterns throws when no
+/// case matched a value it was compiled to cover -- a sealed type or an enum
+/// that gained a member after the switch was compiled -- or when a record's
+/// accessor failed while a pattern took the record apart.
+///
+/// javac names it in the code of every exhaustive pattern switch, so the
+/// class has to exist on a device for such a switch to load at all.
+public final class MatchException extends RuntimeException {
+    /// A failed match, with what caused it or null.
+    public MatchException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/lang/Math.java b/vm/JavaAPI/src/java/lang/Math.java
index 7dde5bbe20e..2b7ab0dfcd1 100644
--- a/vm/JavaAPI/src/java/lang/Math.java
+++ b/vm/JavaAPI/src/java/lang/Math.java
@@ -212,11 +212,21 @@ public static double toRadians(double angdeg){
      * @return the closest integer to the argument.
      */
     public static long round(double d) {
-        // check for NaN
-        if (d != d) {
-            return 0L;
+        // The JDK's own algorithm, on the bits. floor(d + 0.5) was off by one
+        // where the addition rounds: 0.49999999999999994 + 0.5 is exactly 1.0,
+        // so it answered 1 for a value below one half.
+        long bits = Double.doubleToRawLongBits(d);
+        long biasedExp = (bits & 0x7ff0000000000000L) >> 52;
+        long shift = (51 + 1023) - biasedExp;
+        if ((shift & -64) == 0) {
+            long r = (bits & 0x000fffffffffffffL) | 0x0010000000000000L;
+            if (bits < 0) {
+                r = -r;
+            }
+            return ((r >> shift) + 1) >> 1;
         }
-        return (long) floor(d + 0.5d);
+        // NaN answers 0 and anything out of range saturates, as the cast does.
+        return (long) d;
     }
 
     /**
@@ -239,11 +249,18 @@ public static long round(double d) {
      * @return the closest integer to the argument.
      */
     public static int round(float f) {
-        // check for NaN
-        if (f != f) {
-            return 0;
+        // The JDK's own algorithm, on the bits; see round(double).
+        int bits = Float.floatToRawIntBits(f);
+        int biasedExp = (bits & 0x7f800000) >> 23;
+        int shift = (22 + 127) - biasedExp;
+        if ((shift & -32) == 0) {
+            int r = (bits & 0x007fffff) | 0x00800000;
+            if (bits < 0) {
+                r = -r;
+            }
+            return ((r >> shift) + 1) >> 1;
         }
-        return (int) floor(f + 0.5f);
+        return (int) f;
     }
     
     public static double nextDown(double d) {
@@ -253,6 +270,10 @@ public static double nextDown(double d) {
         if (d == Double.NEGATIVE_INFINITY) {
             return d;
         }
+        if (d == 0.0) {
+            // Both zeros; stepping the bits of +0.0 down made a NaN.
+            return -Double.MIN_VALUE;
+        }
         long bits = Double.doubleToLongBits(d);
         boolean negative = (bits & (1L << 63)) != 0;
         if (negative) {
@@ -263,11 +284,643 @@ public static double nextDown(double d) {
         return Double.longBitsToDouble(bits);
     }
     
+    /// The double next to `start` in the direction of `direction`.
     public static double nextAfter(double start, double direction) {
-        throw new RuntimeException("Math.nextAfter() not supported.  Use MathUtil.nextAfter()");
+        if (start > direction) {
+            if (start != 0.0d) {
+                long t = Double.doubleToRawLongBits(start);
+                return Double.longBitsToDouble(t + ((t > 0L) ? -1L : 1L));
+            }
+            return -Double.MIN_VALUE;
+        } else if (start < direction) {
+            long t = Double.doubleToRawLongBits(start + 0.0d);
+            return Double.longBitsToDouble(t + ((t >= 0L) ? 1L : -1L));
+        } else if (start == direction) {
+            return direction;
+        }
+        return start + direction;
     }
 
+    /// The float next to `start` in the direction of `direction`.
     public static float nextAfter(float start, double direction) {
-        throw new RuntimeException("Math.nextAfter() not supported.  Use MathUtil.nextAfter()");
+        if (start > direction) {
+            if (start != 0.0f) {
+                int t = Float.floatToRawIntBits(start);
+                return Float.intBitsToFloat(t + ((t > 0) ? -1 : 1));
+            }
+            return -Float.MIN_VALUE;
+        } else if (start < direction) {
+            int t = Float.floatToRawIntBits(start + 0.0f);
+            return Float.intBitsToFloat(t + ((t >= 0) ? 1 : -1));
+        } else if (start == direction) {
+            return (float) direction;
+        }
+        return start + (float) direction;
+    }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java. The
+    // integer division below checks its divisor itself: ParparVM answers 0
+    // for a division by zero instead of throwing.
+    // ---------------------------------------------------------------------
+
+    /// Twice pi, the ratio of a circle's circumference to its radius.
+    public static final double TAU = 2.0 * PI;
+
+    /// Holds the generator of `random()`, created on first use.
+    private static final class RandomHolder {
+        static final java.util.Random RANDOM = new java.util.Random();
+
+        private RandomHolder() {
+        }
+    }
+
+    /// A pseudo-random double in `[0, 1)`.
+    public static double random() {
+        return RandomHolder.RANDOM.nextDouble();
+    }
+
+    /// -1.0, 0.0 or 1.0 by the sign of `d`; a zero or NaN is returned as it is.
+    public static double signum(double d) {
+        return d > 0 ? 1.0 : d < 0 ? -1.0 : d;
+    }
+
+    /// -1.0f, 0.0f or 1.0f by the sign of `f`; a zero or NaN is returned as it is.
+    public static float signum(float f) {
+        return f > 0 ? 1.0f : f < 0 ? -1.0f : f;
+    }
+
+    /// `magnitude` with the sign bit of `sign`.
+    public static double copySign(double magnitude, double sign) {
+        return Double.longBitsToDouble((Double.doubleToRawLongBits(sign) & 0x8000000000000000L)
+                | (Double.doubleToRawLongBits(magnitude) & 0x7fffffffffffffffL));
+    }
+
+    /// `magnitude` with the sign bit of `sign`.
+    public static float copySign(float magnitude, float sign) {
+        return Float.intBitsToFloat((Float.floatToRawIntBits(sign) & 0x80000000)
+                | (Float.floatToRawIntBits(magnitude) & 0x7fffffff));
+    }
+
+    /// The unbiased exponent of `d`: 1024 for NaN and the infinities, -1023
+    /// for zero and the subnormals.
+    public static int getExponent(double d) {
+        return (int) (((Double.doubleToRawLongBits(d) & 0x7ff0000000000000L) >> 52) - 1023);
+    }
+
+    /// The unbiased exponent of `f`: 128 for NaN and the infinities, -127 for
+    /// zero and the subnormals.
+    public static int getExponent(float f) {
+        return ((Float.floatToRawIntBits(f) & 0x7f800000) >> 23) - 127;
+    }
+
+    private static double powerOfTwoD(int n) {
+        return Double.longBitsToDouble(((long) n + 1023L) << 52);
+    }
+
+    /// The distance from `d` to the next double of larger magnitude.
+    public static double ulp(double d) {
+        int exp = getExponent(d);
+        if (exp == Double.MAX_EXPONENT + 1) {
+            return Math.abs(d);
+        }
+        if (exp == Double.MIN_EXPONENT - 1) {
+            return Double.MIN_VALUE;
+        }
+        exp -= 52;
+        if (exp >= Double.MIN_EXPONENT) {
+            return powerOfTwoD(exp);
+        }
+        return Double.longBitsToDouble(1L << (exp - (Double.MIN_EXPONENT - 52)));
+    }
+
+    /// The distance from `f` to the next float of larger magnitude.
+    public static float ulp(float f) {
+        int exp = getExponent(f);
+        if (exp == Float.MAX_EXPONENT + 1) {
+            return Math.abs(f);
+        }
+        if (exp == Float.MIN_EXPONENT - 1) {
+            return Float.MIN_VALUE;
+        }
+        exp -= 23;
+        if (exp >= Float.MIN_EXPONENT) {
+            return Float.intBitsToFloat((exp + 127) << 23);
+        }
+        return Float.intBitsToFloat(1 << (exp - (Float.MIN_EXPONENT - 23)));
+    }
+
+    /// The double next to `d` towards positive infinity.
+    public static double nextUp(double d) {
+        if (d != d || d == Double.POSITIVE_INFINITY) {
+            return d;
+        }
+        d += 0.0d;
+        return Double.longBitsToDouble(Double.doubleToRawLongBits(d) + ((d >= 0.0d) ? 1L : -1L));
+    }
+
+    /// The float next to `f` towards positive infinity.
+    public static float nextUp(float f) {
+        if (f != f || f == Float.POSITIVE_INFINITY) {
+            return f;
+        }
+        f += 0.0f;
+        return Float.intBitsToFloat(Float.floatToRawIntBits(f) + ((f >= 0.0f) ? 1 : -1));
+    }
+
+    /// The float next to `f` towards negative infinity.
+    public static float nextDown(float f) {
+        if (f != f || f == Float.NEGATIVE_INFINITY) {
+            return f;
+        }
+        if (f == 0.0f) {
+            return -Float.MIN_VALUE;
+        }
+        return Float.intBitsToFloat(Float.floatToRawIntBits(f) + ((f > 0.0f) ? -1 : 1));
+    }
+
+    /// `d` times 2 to the power `scaleFactor`, rounded once.
+    public static double scalb(double d, int scaleFactor) {
+        final int maxScale = 1023 + 1022 + 52 + 1;
+        int scaleIncrement;
+        double expDelta;
+        if (scaleFactor < 0) {
+            scaleFactor = Math.max(scaleFactor, -maxScale);
+            scaleIncrement = -512;
+            expDelta = 0x1.0p-512;
+        } else {
+            scaleFactor = Math.min(scaleFactor, maxScale);
+            scaleIncrement = 512;
+            expDelta = 0x1.0p512;
+        }
+        // The part of the scale that is not a multiple of 512, with the
+        // remainder's sign; the rest goes in exact steps of 2 to the 512.
+        int t = (scaleFactor >> 9 - 1) >>> 32 - 9;
+        int expAdjust = ((scaleFactor + t) & (512 - 1)) - t;
+        d *= powerOfTwoD(expAdjust);
+        scaleFactor -= expAdjust;
+        while (scaleFactor != 0) {
+            d *= expDelta;
+            scaleFactor -= scaleIncrement;
+        }
+        return d;
+    }
+
+    /// `f` times 2 to the power `scaleFactor`, rounded once.
+    public static float scalb(float f, int scaleFactor) {
+        final int maxScale = 127 + 126 + 23 + 1;
+        scaleFactor = Math.max(Math.min(scaleFactor, maxScale), -maxScale);
+        return (float) ((double) f * powerOfTwoD(scaleFactor));
+    }
+
+    /// The square root of `x * x + y * y`, without overflow in between.
+    public static double hypot(double x, double y) {
+        if (Double.isInfinite(x) || Double.isInfinite(y)) {
+            return Double.POSITIVE_INFINITY;
+        }
+        if (x != x || y != y) {
+            return Double.NaN;
+        }
+        double a = Math.abs(x);
+        double b = Math.abs(y);
+        double big = a > b ? a : b;
+        double small = a > b ? b : a;
+        if (big == 0) {
+            return 0;
+        }
+        double ratio = small / big;
+        return big * Math.sqrt(1 + ratio * ratio);
+    }
+
+    /// The cube root of `a`.
+    public static double cbrt(double a) {
+        if (a == 0 || !Double.isFinite(a)) {
+            return a;
+        }
+        double magnitude = Math.abs(a);
+        double root = Math.pow(magnitude, 1.0 / 3.0);
+        // One Newton step takes out the error of the inexact exponent.
+        root = root - (root * root * root - magnitude) / (3 * root * root);
+        return a < 0 ? -root : root;
+    }
+
+    /// The whole number nearest `a`; a tie goes to the even one.
+    public static double rint(double a) {
+        if (!Double.isFinite(a) || Math.abs(a) >= 4503599627370496.0) {
+            return a;
+        }
+        double floor = Math.floor(a);
+        double diff = a - floor;
+        double half = floor / 2;
+        double out = diff < 0.5 || diff == 0.5 && half == Math.floor(half) ? floor : floor + 1;
+        // -0.2 rounds to negative zero, which prints and divides differently.
+        return out == 0 && (a < 0 || copySign(1.0, a) < 0) ? -0.0 : out;
+    }
+
+    /// The hyperbolic sine of `x`.
+    public static double sinh(double x) {
+        if (x != x || x == 0) {
+            return x;
+        }
+        if (Math.abs(x) < 1) {
+            // Near zero the two exponentials agree in almost every digit and
+            // their difference is lost; the series keeps it.
+            return sinhSeries(x);
+        }
+        if (Math.abs(x) > 22) {
+            return x < 0 ? -halfExp(-x) : halfExp(x);
+        }
+        return (Math.exp(x) - Math.exp(-x)) / 2;
+    }
+
+    /// `exp(x) / 2` for `x > 22`, taken as two halves past 709 where
+    /// `exp(x)` itself overflows though half of it does not.
+    private static double halfExp(double x) {
+        if (x < 709) {
+            return Math.exp(x) / 2;
+        }
+        double half = Math.exp(x / 2);
+        return half * (half / 2);
+    }
+
+    private static double sinhSeries(double x) {
+        double x2 = x * x;
+        double term = x;
+        double sum = x;
+        for (int n = 3; n < 40; n += 2) {
+            term *= x2 / ((n - 1) * n);
+            double next = sum + term;
+            if (next == sum) {
+                break;
+            }
+            sum = next;
+        }
+        return sum;
+    }
+
+    /// The hyperbolic cosine of `x`.
+    public static double cosh(double x) {
+        if (x != x) {
+            return x;
+        }
+        if (Math.abs(x) > 22) {
+            return halfExp(Math.abs(x));
+        }
+        return (Math.exp(x) + Math.exp(-x)) / 2;
+    }
+
+    /// The hyperbolic tangent of `x`.
+    public static double tanh(double x) {
+        if (x != x || x == 0) {
+            return x;
+        }
+        if (x > 20) {
+            return 1;
+        }
+        if (x < -20) {
+            return -1;
+        }
+        if (Math.abs(x) < 1) {
+            double s = sinhSeries(x);
+            return s / Math.sqrt(1 + s * s);
+        }
+        double e = Math.exp(2 * x);
+        return (e - 1) / (e + 1);
+    }
+
+    /// The largest int not greater than `x / y`.
+    public static int floorDiv(int x, int y) {
+        if (y == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (y == -1) {
+            return -x;
+        }
+        int r = x / y;
+        return (x ^ y) < 0 && r * y != x ? r - 1 : r;
+    }
+
+    /// The largest long not greater than `x / y`.
+    public static long floorDiv(long x, int y) {
+        return floorDiv(x, (long) y);
+    }
+
+    /// The largest long not greater than `x / y`.
+    public static long floorDiv(long x, long y) {
+        if (y == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (y == -1) {
+            return -x;
+        }
+        long r = x / y;
+        return (x ^ y) < 0 && r * y != x ? r - 1 : r;
+    }
+
+    /// `x - floorDiv(x, y) * y`: the remainder with the sign of `y`.
+    public static int floorMod(int x, int y) {
+        return x - floorDiv(x, y) * y;
+    }
+
+    /// `x - floorDiv(x, y) * y`: the remainder with the sign of `y`.
+    public static int floorMod(long x, int y) {
+        return (int) floorMod(x, (long) y);
+    }
+
+    /// `x - floorDiv(x, y) * y`: the remainder with the sign of `y`.
+    public static long floorMod(long x, long y) {
+        return x - floorDiv(x, y) * y;
+    }
+
+    /// The smallest int not less than `x / y`.
+    public static int ceilDiv(int x, int y) {
+        if (y == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (y == -1) {
+            return -x;
+        }
+        int r = x / y;
+        return (x ^ y) >= 0 && r * y != x ? r + 1 : r;
+    }
+
+    /// The smallest long not less than `x / y`.
+    public static long ceilDiv(long x, int y) {
+        return ceilDiv(x, (long) y);
+    }
+
+    /// The smallest long not less than `x / y`.
+    public static long ceilDiv(long x, long y) {
+        if (y == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (y == -1) {
+            return -x;
+        }
+        long r = x / y;
+        return (x ^ y) >= 0 && r * y != x ? r + 1 : r;
+    }
+
+    /// `x - ceilDiv(x, y) * y`.
+    public static int ceilMod(int x, int y) {
+        return x - ceilDiv(x, y) * y;
+    }
+
+    /// `x - ceilDiv(x, y) * y`.
+    public static int ceilMod(long x, int y) {
+        return (int) ceilMod(x, (long) y);
+    }
+
+    /// `x - ceilDiv(x, y) * y`.
+    public static long ceilMod(long x, long y) {
+        return x - ceilDiv(x, y) * y;
+    }
+
+    /// `x / y`, throwing on the one quotient that overflows.
+    public static int divideExact(int x, int y) {
+        if (y == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (x == Integer.MIN_VALUE && y == -1) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return x / y;
+    }
+
+    /// `x / y`, throwing on the one quotient that overflows.
+    public static long divideExact(long x, long y) {
+        if (y == 0) {
+            throw new ArithmeticException("/ by zero");
+        }
+        if (x == Long.MIN_VALUE && y == -1) {
+            throw new ArithmeticException("long overflow");
+        }
+        return x / y;
+    }
+
+    /// `floorDiv(x, y)`, throwing on the one quotient that overflows.
+    public static int floorDivExact(int x, int y) {
+        if (x == Integer.MIN_VALUE && y == -1) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return floorDiv(x, y);
+    }
+
+    /// `floorDiv(x, y)`, throwing on the one quotient that overflows.
+    public static long floorDivExact(long x, long y) {
+        if (x == Long.MIN_VALUE && y == -1) {
+            throw new ArithmeticException("long overflow");
+        }
+        return floorDiv(x, y);
+    }
+
+    /// `ceilDiv(x, y)`, throwing on the one quotient that overflows.
+    public static int ceilDivExact(int x, int y) {
+        if (x == Integer.MIN_VALUE && y == -1) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return ceilDiv(x, y);
+    }
+
+    /// `ceilDiv(x, y)`, throwing on the one quotient that overflows.
+    public static long ceilDivExact(long x, long y) {
+        if (x == Long.MIN_VALUE && y == -1) {
+            throw new ArithmeticException("long overflow");
+        }
+        return ceilDiv(x, y);
+    }
+
+    /// `x + y`, throwing when it overflows.
+    public static int addExact(int x, int y) {
+        int r = x + y;
+        if (((x ^ r) & (y ^ r)) < 0) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return r;
+    }
+
+    /// `x + y`, throwing when it overflows.
+    public static long addExact(long x, long y) {
+        long r = x + y;
+        if (((x ^ r) & (y ^ r)) < 0) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    /// `x - y`, throwing when it overflows.
+    public static int subtractExact(int x, int y) {
+        int r = x - y;
+        if (((x ^ y) & (x ^ r)) < 0) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return r;
+    }
+
+    /// `x - y`, throwing when it overflows.
+    public static long subtractExact(long x, long y) {
+        long r = x - y;
+        if (((x ^ y) & (x ^ r)) < 0) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    /// `x * y`, throwing when it overflows.
+    public static int multiplyExact(int x, int y) {
+        long r = (long) x * (long) y;
+        if ((int) r != r) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return (int) r;
+    }
+
+    /// `x * y`, throwing when it overflows.
+    public static long multiplyExact(long x, int y) {
+        return multiplyExact(x, (long) y);
+    }
+
+    /// `x * y`, throwing when it overflows.
+    public static long multiplyExact(long x, long y) {
+        if (x == 0 || y == 0) {
+            return 0;
+        }
+        if (x == Long.MIN_VALUE && y == -1 || y == Long.MIN_VALUE && x == -1) {
+            throw new ArithmeticException("long overflow");
+        }
+        long r = x * y;
+        if (r / y != x) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    /// The exact product of two ints.
+    public static long multiplyFull(int x, int y) {
+        return (long) x * (long) y;
+    }
+
+    /// The high 64 bits of the 128-bit product of two signed longs.
+    public static long multiplyHigh(long x, long y) {
+        long x1 = x >> 32;
+        long x2 = x & 0xffffffffL;
+        long y1 = y >> 32;
+        long y2 = y & 0xffffffffL;
+        long z2 = x2 * y2;
+        long t = x1 * y2 + (z2 >>> 32);
+        long z1 = t & 0xffffffffL;
+        long z0 = t >> 32;
+        z1 += x2 * y1;
+        return x1 * y1 + z0 + (z1 >> 32);
+    }
+
+    /// The high 64 bits of the 128-bit product of two unsigned longs.
+    public static long unsignedMultiplyHigh(long x, long y) {
+        long result = multiplyHigh(x, y);
+        result += y & (x >> 63);
+        result += x & (y >> 63);
+        return result;
+    }
+
+    /// `a + 1`, throwing when it overflows.
+    public static int incrementExact(int a) {
+        return addExact(a, 1);
+    }
+
+    /// `a + 1`, throwing when it overflows.
+    public static long incrementExact(long a) {
+        return addExact(a, 1L);
+    }
+
+    /// `a - 1`, throwing when it overflows.
+    public static int decrementExact(int a) {
+        return subtractExact(a, 1);
+    }
+
+    /// `a - 1`, throwing when it overflows.
+    public static long decrementExact(long a) {
+        return subtractExact(a, 1L);
+    }
+
+    /// `-a`, throwing when it overflows.
+    public static int negateExact(int a) {
+        return subtractExact(0, a);
+    }
+
+    /// `-a`, throwing when it overflows.
+    public static long negateExact(long a) {
+        return subtractExact(0L, a);
+    }
+
+    /// The value as an int, throwing when it does not fit.
+    public static int toIntExact(long value) {
+        if ((int) value != value) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return (int) value;
+    }
+
+    /// The absolute value, throwing for `Integer.MIN_VALUE`, which has none.
+    public static int absExact(int a) {
+        if (a == Integer.MIN_VALUE) {
+            throw new ArithmeticException("Overflow to represent absolute value of Integer.MIN_VALUE");
+        }
+        return abs(a);
+    }
+
+    /// The absolute value, throwing for `Long.MIN_VALUE`, which has none.
+    public static long absExact(long a) {
+        if (a == Long.MIN_VALUE) {
+            throw new ArithmeticException("Overflow to represent absolute value of Long.MIN_VALUE");
+        }
+        return abs(a);
+    }
+
+    /// `value` clamped to `[min, max]`, as an int.
+    public static int clamp(long value, int min, int max) {
+        if (min > max) {
+            throw new IllegalArgumentException(min + " > " + max);
+        }
+        return (int) Math.min(max, Math.max(value, min));
+    }
+
+    /// `value` clamped to `[min, max]`.
+    public static long clamp(long value, long min, long max) {
+        if (min > max) {
+            throw new IllegalArgumentException(min + " > " + max);
+        }
+        return Math.min(max, Math.max(value, min));
+    }
+
+    /// `value` clamped to `[min, max]`.
+    public static double clamp(double value, double min, double max) {
+        if (!(min < max)) {
+            if (min != min) {
+                throw new IllegalArgumentException("min is NaN");
+            }
+            if (max != max) {
+                throw new IllegalArgumentException("max is NaN");
+            }
+            if (Double.compare(min, max) > 0) {
+                throw new IllegalArgumentException(min + " > " + max);
+            }
+        }
+        return Math.min(max, Math.max(value, min));
+    }
+
+    /// `value` clamped to `[min, max]`.
+    public static float clamp(float value, float min, float max) {
+        if (!(min < max)) {
+            if (min != min) {
+                throw new IllegalArgumentException("min is NaN");
+            }
+            if (max != max) {
+                throw new IllegalArgumentException("max is NaN");
+            }
+            if (Float.compare(min, max) > 0) {
+                throw new IllegalArgumentException(min + " > " + max);
+            }
+        }
+        return Math.min(max, Math.max(value, min));
     }
 }
diff --git a/vm/JavaAPI/src/java/lang/Module.java b/vm/JavaAPI/src/java/lang/Module.java
new file mode 100644
index 00000000000..3ab4b321139
--- /dev/null
+++ b/vm/JavaAPI/src/java/lang/Module.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang;
+
+/// The module a class is in, as far as an application without modules has
+/// one: the single unnamed module every class of it is in.
+///
+/// [Class#getModule()] answers it for every class. It has no name, no layer
+/// and no descriptor, which is what the JDK answers for a class loaded from
+/// the class path, and what code that asks in order to choose between the
+/// module path and the class path needs to hear. Nothing else of the module
+/// system is here.
+public final class Module {
+
+    // Made by this class's own initializer, which only a getModule() call runs.
+    private static final Module UNNAMED = new Module();
+
+    private Module() {
+    }
+
+    /// The one module.
+    static Module unnamed() {
+        return UNNAMED;
+    }
+
+    /// False: the one module there is has no name.
+    public boolean isNamed() {
+        return false;
+    }
+
+    /// Null, as for every unnamed module.
+    public String getName() {
+        return null;
+    }
+
+    /// Null: an unnamed module is in no layer.
+    public ModuleLayer getLayer() {
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return "unnamed module @" + Integer.toHexString(hashCode());
+    }
+}
diff --git a/vm/JavaAPI/src/java/lang/ModuleLayer.java b/vm/JavaAPI/src/java/lang/ModuleLayer.java
new file mode 100644
index 00000000000..282fba9c41a
--- /dev/null
+++ b/vm/JavaAPI/src/java/lang/ModuleLayer.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang;
+
+/// `java.lang.ModuleLayer`, as a type only. An application without modules
+/// has no layer: [Module#getLayer()] answers null and nothing creates an
+/// instance of this class. It exists so that code which asks for a class's
+/// layer, and takes the class path route when there is none, links.
+public final class ModuleLayer {
+
+    private ModuleLayer() {
+    }
+}
diff --git a/vm/JavaAPI/src/java/lang/Runtime.java b/vm/JavaAPI/src/java/lang/Runtime.java
index 336c05f8058..ad5d43598e9 100644
--- a/vm/JavaAPI/src/java/lang/Runtime.java
+++ b/vm/JavaAPI/src/java/lang/Runtime.java
@@ -22,6 +22,11 @@
  */
 
 package java.lang;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+
 /**
  * Every Java application has a single instance of class Runtime that allows the application to interface with the environment in which the application is running. The current runtime can be obtained from the getRuntime method.
  * An application cannot create its own instance of this class.
@@ -29,13 +34,122 @@
  */
 public class Runtime {
     private static final Runtime instance = new Runtime();
-    
+
+    /** The registered shutdown hooks; also the lock for them and for {@link #shuttingDown}. */
+    private final ArrayList<Thread> hooks = new ArrayList<Thread>();
+
+    /** Whether exit has begun, after which hooks are neither run again nor accepted. */
+    private boolean shuttingDown;
+
+    private Runtime() {
+    }
+
     /**
      * Terminates the currently running Java application. This method never returns normally.
      * The argument serves as a status code; by convention, a nonzero status code indicates abnormal termination.
+     *
+     * The registered shutdown hooks run first, one after another on this
+     * thread, each in its own try so one that throws does not stop the rest.
+     * Then the platform is asked to close the application through
+     * com.codename1.impl.JdkHost -- a Codename One application closes the
+     * way Display.exitApplication closes it -- and if that returns, the
+     * process ends with the status.
+     *
+     * A second call, including one the platform's own close makes, skips
+     * all of that and ends the process at once.
      */
     public void exit(int status){
-        System.exit(status);
+        // An array, not a list: the element is typed without a cast, so no
+        // checkcast sits inside the try below (ParparVM does not check one).
+        Thread[] run = null;
+        synchronized (hooks) {
+            if (!shuttingDown) {
+                shuttingDown = true;
+                run = hooks.toArray(new Thread[hooks.size()]);
+                hooks.clear();
+            }
+        }
+        if (run != null) {
+            for (int i = 0; i < run.length; i++) {
+                Thread hook = run[i];
+                try {
+                    hook.run();
+                } catch (Throwable t) {
+                    t.printStackTrace();
+                }
+            }
+            JdkHost.get().exit(status);
+        }
+        exitImpl(status);
+    }
+
+    /**
+     * Ends the process at once, without running the shutdown hooks or asking
+     * the platform to close the application.
+     */
+    public void halt(int status) {
+        synchronized (hooks) {
+            shuttingDown = true;
+            hooks.clear();
+        }
+        exitImpl(status);
+    }
+
+    private static native void exitImpl(int status);
+
+    /**
+     * Registers a hook that exit runs before the application closes. The
+     * hook's run method is called on the exiting thread; the thread is never
+     * started.
+     */
+    public void addShutdownHook(Thread hook) {
+        if (hook == null) {
+            throw new NullPointerException();
+        }
+        synchronized (hooks) {
+            if (shuttingDown) {
+                throw new IllegalStateException("Shutdown in progress");
+            }
+            if (hook.isAlive()) {
+                throw new IllegalArgumentException("Hook already running");
+            }
+            if (hooks.contains(hook)) {
+                throw new IllegalArgumentException("Hook previously registered");
+            }
+            hooks.add(hook);
+        }
+    }
+
+    /**
+     * Unregisters a hook; whether it was registered.
+     */
+    public boolean removeShutdownHook(Thread hook) {
+        if (hook == null) {
+            throw new NullPointerException();
+        }
+        synchronized (hooks) {
+            if (shuttingDown) {
+                throw new IllegalStateException("Shutdown in progress");
+            }
+            return hooks.remove(hook);
+        }
+    }
+
+    /**
+     * The number of processors available to the program. The class library
+     * cannot ask the platform, so it answers 1, the one answer that is
+     * never too many for a program sizing a thread pool by it.
+     */
+    public int availableProcessors() {
+        return 1;
+    }
+
+    /**
+     * The most memory the program may use; the runtime does not expose a
+     * limit, so this is the total memory, as totalMemory answers it.
+     */
+    public long maxMemory() {
+        return totalMemory();
     }
 
     /**
diff --git a/vm/JavaAPI/src/java/lang/Short.java b/vm/JavaAPI/src/java/lang/Short.java
index 16610a821a9..0b3ad5f5954 100644
--- a/vm/JavaAPI/src/java/lang/Short.java
+++ b/vm/JavaAPI/src/java/lang/Short.java
@@ -102,14 +102,18 @@ public int hashCode(){
      * Assuming the specified String represents a short, returns that short's value. Throws an exception if the String cannot be parsed as a short. The radix is assumed to be 10.
      */
     public static short parseShort(java.lang.String s) throws java.lang.NumberFormatException{
-        return (short)Integer.parseInt(s);
+        return parseShort(s, 10);
     }
 
     /**
      * Assuming the specified String represents a short, returns that short's value in the radix specified by the second argument. Throws an exception if the String cannot be parsed as a short.
      */
     public static short parseShort(java.lang.String s, int radix) throws java.lang.NumberFormatException{
-        return (short)Integer.parseInt(s, radix);
+        int i = Integer.parseInt(s, radix);
+        if (i < MIN_VALUE || i > MAX_VALUE) {
+            throw new NumberFormatException("Value out of range. Value:\"" + s + "\" Radix:" + radix);
+        }
+        return (short) i;
     }
 
     /**
@@ -184,4 +188,69 @@ public int compareTo(Short another) {
         // this class's own compare(short, short) directly above.
         return cn1Value() - another.cn1Value();
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// The size of a short in bytes.
+    public static final int BYTES = 2;
+
+    /// The size of a short in bits.
+    public static final int SIZE = 16;
+
+    /// A Short of `parseShort(s)`.
+    @Deprecated
+    public Short(String s) throws NumberFormatException {
+        this(parseShort(s, 10));
+    }
+
+    /// The decimal string of `s`.
+    public static String toString(short s) {
+        return Integer.toString(s);
+    }
+
+    /// A Short of `parseShort(s)`.
+    public static Short valueOf(String s) throws NumberFormatException {
+        return valueOf(parseShort(s, 10));
+    }
+
+    /// A Short of `parseShort(s, radix)`.
+    public static Short valueOf(String s, int radix) throws NumberFormatException {
+        return valueOf(parseShort(s, radix));
+    }
+
+    /// Decodes a decimal, hexadecimal or octal short, as `Integer.decode`.
+    public static Short decode(String nm) throws NumberFormatException {
+        int value = Integer.decode(nm).intValue();
+        if (value < MIN_VALUE || value > MAX_VALUE) {
+            throw new NumberFormatException("Value " + value + " out of range from input " + nm);
+        }
+        return valueOf((short) value);
+    }
+
+    /// The value itself.
+    public static int hashCode(short value) {
+        return value;
+    }
+
+    /// Compares the two as unsigned values.
+    public static int compareUnsigned(short x, short y) {
+        return toUnsignedInt(x) - toUnsignedInt(y);
+    }
+
+    /// The value as an unsigned int.
+    public static int toUnsignedInt(short x) {
+        return x & 0xffff;
+    }
+
+    /// The value as an unsigned long.
+    public static long toUnsignedLong(short x) {
+        return x & 0xffffL;
+    }
+
+    /// The bytes in reverse order.
+    public static short reverseBytes(short i) {
+        return (short) (((i & 0xff00) >> 8) | (i << 8));
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/StrictMath.java b/vm/JavaAPI/src/java/lang/StrictMath.java
new file mode 100644
index 00000000000..db537a7c20a
--- /dev/null
+++ b/vm/JavaAPI/src/java/lang/StrictMath.java
@@ -0,0 +1,512 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package java.lang;
+
+/// The JDK's StrictMath. Every member answers exactly as the `Math` member
+/// of the same name: this runtime has one implementation of each function,
+/// so the results are the same on every platform it runs on, which is what
+/// StrictMath promises.
+public final class StrictMath {
+    private StrictMath() {
+    }
+
+    /// As `Math.E`.
+    public static final double E = Math.E;
+
+    /// As `Math.PI`.
+    public static final double PI = Math.PI;
+
+    /// As `Math.TAU`.
+    public static final double TAU = Math.TAU;
+
+    /// As `Math.abs`.
+    public static double abs(double a) {
+        return Math.abs(a);
+    }
+
+    /// As `Math.abs`.
+    public static float abs(float a) {
+        return Math.abs(a);
+    }
+
+    /// As `Math.abs`.
+    public static int abs(int a) {
+        return Math.abs(a);
+    }
+
+    /// As `Math.abs`.
+    public static long abs(long a) {
+        return Math.abs(a);
+    }
+
+    /// As `Math.ceil`.
+    public static double ceil(double a) {
+        return Math.ceil(a);
+    }
+
+    /// As `Math.floor`.
+    public static double floor(double a) {
+        return Math.floor(a);
+    }
+
+    /// As `Math.max`.
+    public static double max(double a, double b) {
+        return Math.max(a, b);
+    }
+
+    /// As `Math.pow`.
+    public static double pow(double a, double b) {
+        return Math.pow(a, b);
+    }
+
+    /// As `Math.max`.
+    public static float max(float a, float b) {
+        return Math.max(a, b);
+    }
+
+    /// As `Math.max`.
+    public static int max(int a, int b) {
+        return Math.max(a, b);
+    }
+
+    /// As `Math.max`.
+    public static long max(long a, long b) {
+        return Math.max(a, b);
+    }
+
+    /// As `Math.min`.
+    public static double min(double a, double b) {
+        return Math.min(a, b);
+    }
+
+    /// As `Math.min`.
+    public static float min(float a, float b) {
+        return Math.min(a, b);
+    }
+
+    /// As `Math.min`.
+    public static int min(int a, int b) {
+        return Math.min(a, b);
+    }
+
+    /// As `Math.min`.
+    public static long min(long a, long b) {
+        return Math.min(a, b);
+    }
+
+    /// As `Math.cos`.
+    public static double cos(double a) {
+        return Math.cos(a);
+    }
+
+    /// As `Math.sin`.
+    public static double sin(double a) {
+        return Math.sin(a);
+    }
+
+    /// As `Math.sqrt`.
+    public static double sqrt(double a) {
+        return Math.sqrt(a);
+    }
+
+    /// As `Math.tan`.
+    public static double tan(double a) {
+        return Math.tan(a);
+    }
+
+    /// As `Math.atan`.
+    public static double atan(double a) {
+        return Math.atan(a);
+    }
+
+    /// As `Math.acos`.
+    public static double acos(double a) {
+        return Math.acos(a);
+    }
+
+    /// As `Math.asin`.
+    public static double asin(double a) {
+        return Math.asin(a);
+    }
+
+    /// As `Math.atan2`.
+    public static double atan2(double a, double b) {
+        return Math.atan2(a, b);
+    }
+
+    /// As `Math.exp`.
+    public static double exp(double a) {
+        return Math.exp(a);
+    }
+
+    /// As `Math.log`.
+    public static double log(double a) {
+        return Math.log(a);
+    }
+
+    /// As `Math.log10`.
+    public static double log10(double a) {
+        return Math.log10(a);
+    }
+
+    /// As `Math.toDegrees`.
+    public static double toDegrees(double a) {
+        return Math.toDegrees(a);
+    }
+
+    /// As `Math.toRadians`.
+    public static double toRadians(double a) {
+        return Math.toRadians(a);
+    }
+
+    /// As `Math.round`.
+    public static long round(double a) {
+        return Math.round(a);
+    }
+
+    /// As `Math.round`.
+    public static int round(float a) {
+        return Math.round(a);
+    }
+
+    /// As `Math.nextDown`.
+    public static double nextDown(double a) {
+        return Math.nextDown(a);
+    }
+
+    /// As `Math.nextAfter`.
+    public static double nextAfter(double a, double b) {
+        return Math.nextAfter(a, b);
+    }
+
+    /// As `Math.nextAfter`.
+    public static float nextAfter(float a, double b) {
+        return Math.nextAfter(a, b);
+    }
+
+    /// As `Math.random`.
+    public static double random() {
+        return Math.random();
+    }
+
+    /// As `Math.signum`.
+    public static double signum(double a) {
+        return Math.signum(a);
+    }
+
+    /// As `Math.signum`.
+    public static float signum(float a) {
+        return Math.signum(a);
+    }
+
+    /// As `Math.copySign`.
+    public static double copySign(double a, double b) {
+        return Math.copySign(a, b);
+    }
+
+    /// As `Math.copySign`.
+    public static float copySign(float a, float b) {
+        return Math.copySign(a, b);
+    }
+
+    /// As `Math.getExponent`.
+    public static int getExponent(double a) {
+        return Math.getExponent(a);
+    }
+
+    /// As `Math.getExponent`.
+    public static int getExponent(float a) {
+        return Math.getExponent(a);
+    }
+
+    /// As `Math.ulp`.
+    public static double ulp(double a) {
+        return Math.ulp(a);
+    }
+
+    /// As `Math.ulp`.
+    public static float ulp(float a) {
+        return Math.ulp(a);
+    }
+
+    /// As `Math.nextUp`.
+    public static double nextUp(double a) {
+        return Math.nextUp(a);
+    }
+
+    /// As `Math.nextUp`.
+    public static float nextUp(float a) {
+        return Math.nextUp(a);
+    }
+
+    /// As `Math.nextDown`.
+    public static float nextDown(float a) {
+        return Math.nextDown(a);
+    }
+
+    /// As `Math.scalb`.
+    public static double scalb(double a, int b) {
+        return Math.scalb(a, b);
+    }
+
+    /// As `Math.scalb`.
+    public static float scalb(float a, int b) {
+        return Math.scalb(a, b);
+    }
+
+    /// As `Math.hypot`.
+    public static double hypot(double a, double b) {
+        return Math.hypot(a, b);
+    }
+
+    /// As `Math.cbrt`.
+    public static double cbrt(double a) {
+        return Math.cbrt(a);
+    }
+
+    /// As `Math.rint`.
+    public static double rint(double a) {
+        return Math.rint(a);
+    }
+
+    /// As `Math.sinh`.
+    public static double sinh(double a) {
+        return Math.sinh(a);
+    }
+
+    /// As `Math.cosh`.
+    public static double cosh(double a) {
+        return Math.cosh(a);
+    }
+
+    /// As `Math.tanh`.
+    public static double tanh(double a) {
+        return Math.tanh(a);
+    }
+
+    /// As `Math.floorDiv`.
+    public static int floorDiv(int a, int b) {
+        return Math.floorDiv(a, b);
+    }
+
+    /// As `Math.floorDiv`.
+    public static long floorDiv(long a, int b) {
+        return Math.floorDiv(a, b);
+    }
+
+    /// As `Math.floorDiv`.
+    public static long floorDiv(long a, long b) {
+        return Math.floorDiv(a, b);
+    }
+
+    /// As `Math.floorMod`.
+    public static int floorMod(int a, int b) {
+        return Math.floorMod(a, b);
+    }
+
+    /// As `Math.floorMod`.
+    public static int floorMod(long a, int b) {
+        return Math.floorMod(a, b);
+    }
+
+    /// As `Math.floorMod`.
+    public static long floorMod(long a, long b) {
+        return Math.floorMod(a, b);
+    }
+
+    /// As `Math.ceilDiv`.
+    public static int ceilDiv(int a, int b) {
+        return Math.ceilDiv(a, b);
+    }
+
+    /// As `Math.ceilDiv`.
+    public static long ceilDiv(long a, int b) {
+        return Math.ceilDiv(a, b);
+    }
+
+    /// As `Math.ceilDiv`.
+    public static long ceilDiv(long a, long b) {
+        return Math.ceilDiv(a, b);
+    }
+
+    /// As `Math.ceilMod`.
+    public static int ceilMod(int a, int b) {
+        return Math.ceilMod(a, b);
+    }
+
+    /// As `Math.ceilMod`.
+    public static int ceilMod(long a, int b) {
+        return Math.ceilMod(a, b);
+    }
+
+    /// As `Math.ceilMod`.
+    public static long ceilMod(long a, long b) {
+        return Math.ceilMod(a, b);
+    }
+
+    /// As `Math.divideExact`.
+    public static int divideExact(int a, int b) {
+        return Math.divideExact(a, b);
+    }
+
+    /// As `Math.divideExact`.
+    public static long divideExact(long a, long b) {
+        return Math.divideExact(a, b);
+    }
+
+    /// As `Math.floorDivExact`.
+    public static int floorDivExact(int a, int b) {
+        return Math.floorDivExact(a, b);
+    }
+
+    /// As `Math.floorDivExact`.
+    public static long floorDivExact(long a, long b) {
+        return Math.floorDivExact(a, b);
+    }
+
+    /// As `Math.ceilDivExact`.
+    public static int ceilDivExact(int a, int b) {
+        return Math.ceilDivExact(a, b);
+    }
+
+    /// As `Math.ceilDivExact`.
+    public static long ceilDivExact(long a, long b) {
+        return Math.ceilDivExact(a, b);
+    }
+
+    /// As `Math.addExact`.
+    public static int addExact(int a, int b) {
+        return Math.addExact(a, b);
+    }
+
+    /// As `Math.addExact`.
+    public static long addExact(long a, long b) {
+        return Math.addExact(a, b);
+    }
+
+    /// As `Math.subtractExact`.
+    public static int subtractExact(int a, int b) {
+        return Math.subtractExact(a, b);
+    }
+
+    /// As `Math.subtractExact`.
+    public static long subtractExact(long a, long b) {
+        return Math.subtractExact(a, b);
+    }
+
+    /// As `Math.multiplyExact`.
+    public static int multiplyExact(int a, int b) {
+        return Math.multiplyExact(a, b);
+    }
+
+    /// As `Math.multiplyExact`.
+    public static long multiplyExact(long a, int b) {
+        return Math.multiplyExact(a, b);
+    }
+
+    /// As `Math.multiplyExact`.
+    public static long multiplyExact(long a, long b) {
+        return Math.multiplyExact(a, b);
+    }
+
+    /// As `Math.multiplyFull`.
+    public static long multiplyFull(int a, int b) {
+        return Math.multiplyFull(a, b);
+    }
+
+    /// As `Math.multiplyHigh`.
+    public static long multiplyHigh(long a, long b) {
+        return Math.multiplyHigh(a, b);
+    }
+
+    /// As `Math.unsignedMultiplyHigh`.
+    public static long unsignedMultiplyHigh(long a, long b) {
+        return Math.unsignedMultiplyHigh(a, b);
+    }
+
+    /// As `Math.incrementExact`.
+    public static int incrementExact(int a) {
+        return Math.incrementExact(a);
+    }
+
+    /// As `Math.incrementExact`.
+    public static long incrementExact(long a) {
+        return Math.incrementExact(a);
+    }
+
+    /// As `Math.decrementExact`.
+    public static int decrementExact(int a) {
+        return Math.decrementExact(a);
+    }
+
+    /// As `Math.decrementExact`.
+    public static long decrementExact(long a) {
+        return Math.decrementExact(a);
+    }
+
+    /// As `Math.negateExact`.
+    public static int negateExact(int a) {
+        return Math.negateExact(a);
+    }
+
+    /// As `Math.negateExact`.
+    public static long negateExact(long a) {
+        return Math.negateExact(a);
+    }
+
+    /// As `Math.toIntExact`.
+    public static int toIntExact(long a) {
+        return Math.toIntExact(a);
+    }
+
+    /// As `Math.absExact`.
+    public static int absExact(int a) {
+        return Math.absExact(a);
+    }
+
+    /// As `Math.absExact`.
+    public static long absExact(long a) {
+        return Math.absExact(a);
+    }
+
+    /// As `Math.clamp`.
+    public static int clamp(long a, int b, int c) {
+        return Math.clamp(a, b, c);
+    }
+
+    /// As `Math.clamp`.
+    public static long clamp(long a, long b, long c) {
+        return Math.clamp(a, b, c);
+    }
+
+    /// As `Math.clamp`.
+    public static double clamp(double a, double b, double c) {
+        return Math.clamp(a, b, c);
+    }
+
+    /// As `Math.clamp`.
+    public static float clamp(float a, float b, float c) {
+        return Math.clamp(a, b, c);
+    }
+}
diff --git a/vm/JavaAPI/src/java/lang/String.java b/vm/JavaAPI/src/java/lang/String.java
index 4a2d407ccb0..06e266d61ff 100644
--- a/vm/JavaAPI/src/java/lang/String.java
+++ b/vm/JavaAPI/src/java/lang/String.java
@@ -246,11 +246,13 @@ public String(byte[] bytes, int off, int len){
      * JDK1.1
      */
     public String(byte[] bytes, int off, int len, java.lang.String enc) throws java.io.UnsupportedEncodingException{
-        this(bytesToChars(bytes, off, len, enc));
+        this(bytesToChars(bytes, off, len, knownEncoding(enc)));
     }
     
-    public String(byte[] bytes, java.nio.charset.Charset charset) throws java.io.UnsupportedEncodingException {
-        this(bytes, 0, bytes.length, charset.name());
+    /// Decodes `bytes` with `charset`. Unlike the constructor taking a
+    /// charset name, this throws no checked exception, as in the JDK.
+    public String(byte[] bytes, java.nio.charset.Charset charset) {
+        this(bytesToChars(bytes, 0, bytes.length, charset.name()));
     }
 
     /**
@@ -260,7 +262,7 @@ public String(byte[] bytes, java.nio.charset.Charset charset) throws java.io.Uns
      * JDK1.1
      */
     public String(byte[] bytes, java.lang.String enc) throws java.io.UnsupportedEncodingException{
-        this(bytesToChars(bytes, 0, bytes.length, enc));
+        this(bytesToChars(bytes, 0, bytes.length, knownEncoding(enc)));
     }
 
     private static native char[] bytesToChars(byte[] b, int off, int len, String encoding); 
@@ -667,6 +669,7 @@ public byte[] getBytes(){
      * Convert this String into bytes according to the specified character encoding, storing the result into a new byte array.
      */
     public byte[] getBytes(java.lang.String enc) throws java.io.UnsupportedEncodingException{
+        enc = knownEncoding(enc);
         if(isLatin1()) {
             byte[] compact = compactBytes(enc);
             if(compact != null) return compact;
@@ -683,8 +686,46 @@ public byte[] getBytes(java.lang.String enc) throws java.io.UnsupportedEncodingE
         return charsToBytes(toCharArray(), enc.toCharNoCopy()); 
     }
     
-    public byte[] getBytes(Charset charset) throws java.io.UnsupportedEncodingException {
-        return getBytes(charset.name());
+    /// The name the encoding natives know `enc` by: the canonical name of a
+    /// charset, so an alias or another case reaches them as the name they
+    /// compare with. `null` stays `null`, which they read as UTF-8.
+    ///
+    /// UTF-16 and ISO-8859-2 have no `Charset` here but the natives encode them
+    /// on Apple platforms, so they are names this runtime knows.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedEncodingException`: for a name this runtime has no
+    ///   encoding for, as the JDK throws. The natives used to encode such a
+    ///   name as UTF-8 without a word.
+    private static String knownEncoding(String enc) throws java.io.UnsupportedEncodingException {
+        if (enc == null || "UTF-8".equals(enc)) {
+            return enc;
+        }
+        if (enc.equalsIgnoreCase("UTF-16") || enc.equalsIgnoreCase("UTF16")) {
+            return "UTF-16";
+        }
+        if (enc.equalsIgnoreCase("ISO-8859-2") || enc.equalsIgnoreCase("ISO8859-2")
+                || enc.equalsIgnoreCase("ISO8859_2") || enc.equalsIgnoreCase("LATIN2")) {
+            return "ISO-8859-2";
+        }
+        try {
+            return Charset.forName(enc).name();
+        } catch (IllegalArgumentException e) {
+            // UnsupportedCharsetException and IllegalCharsetNameException
+            throw new java.io.UnsupportedEncodingException(enc);
+        }
+    }
+
+    /// The string encoded with `charset`. Unlike `getBytes(String)`, this
+    /// throws no checked exception, as in the JDK.
+    public byte[] getBytes(Charset charset) {
+        try {
+            return getBytes(charset.name());
+        } catch (java.io.UnsupportedEncodingException e) {
+            // Every Charset this runtime hands out is one it can encode.
+            throw new IllegalStateException(e.getMessage());
+        }
     }
 
     /**
@@ -1329,4 +1370,422 @@ public boolean contains(CharSequence seq) {
     public boolean isEmpty() {
         return length() == 0;
     }
+
+    // ---------------------------------------------------------------------
+    // The members of the JDK's String the class did not have. Plain Java over
+    // the members above: none of them is a native, so the JavaScript port and
+    // every ParparVM target run the same code. The regular expression members
+    // (matches, split, replaceAll, replaceFirst) are deliberately absent; the
+    // build rewrites them to com.codename1.util.regex.StringRegex.
+    // ---------------------------------------------------------------------
+
+    /// A string of the code points `codePoints[offset]` to
+    /// `codePoints[offset + count - 1]`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if one of them is not a valid code point
+    /// - `IndexOutOfBoundsException`: if the range is outside the array
+    public String(int[] codePoints, int offset, int count) {
+        this(codePointsToChars(codePoints, offset, count));
+    }
+
+    /// Decodes `length` bytes of `bytes` from `offset` with `charset`.
+    public String(byte[] bytes, int offset, int length, Charset charset) {
+        this(bytesToChars(bytes, offset, length, charset.name()));
+    }
+
+    private static char[] codePointsToChars(int[] codePoints, int offset, int count) {
+        if (offset < 0 || count < 0 || offset > codePoints.length - count) {
+            throw new StringIndexOutOfBoundsException("offset " + offset + ", count " + count
+                    + ", length " + codePoints.length);
+        }
+        int units = 0;
+        for (int i = offset; i < offset + count; i++) {
+            int cp = codePoints[i];
+            if (!Character.isValidCodePoint(cp)) {
+                throw new IllegalArgumentException(Integer.toString(cp));
+            }
+            units += Character.charCount(cp);
+        }
+        char[] out = new char[units];
+        int at = 0;
+        for (int i = offset; i < offset + count; i++) {
+            at += Character.toChars(codePoints[i], out, at);
+        }
+        return out;
+    }
+
+    /// The code point at `index`: a surrogate pair starting there is one code
+    /// point, an unpaired surrogate is itself.
+    public int codePointAt(int index) {
+        if (index < 0 || index >= count) {
+            throw new StringIndexOutOfBoundsException(index);
+        }
+        return Character.codePointAt(this, index);
+    }
+
+    /// The code point that ends just before `index`.
+    public int codePointBefore(int index) {
+        if (index < 1 || index > count) {
+            throw new StringIndexOutOfBoundsException(index);
+        }
+        return Character.codePointBefore(this, index);
+    }
+
+    /// The number of code points between `beginIndex` and `endIndex`.
+    public int codePointCount(int beginIndex, int endIndex) {
+        if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) {
+            throw new IndexOutOfBoundsException();
+        }
+        return Character.codePointCount(this, beginIndex, endIndex);
+    }
+
+    /// The index `codePointOffset` code points away from `index`.
+    public int offsetByCodePoints(int index, int codePointOffset) {
+        if (index < 0 || index > count) {
+            throw new IndexOutOfBoundsException();
+        }
+        return Character.offsetByCodePoints(this, index, codePointOffset);
+    }
+
+    /// The first index of `ch` in `[beginIndex, endIndex)`, or -1.
+    public int indexOf(int ch, int beginIndex, int endIndex) {
+        checkBoundsBeginEnd(beginIndex, endIndex);
+        int found = indexOf(ch, beginIndex);
+        return found >= 0 && found < endIndex ? found : -1;
+    }
+
+    /// The first index of `str` that lies wholly in `[beginIndex, endIndex)`,
+    /// or -1.
+    public int indexOf(String str, int beginIndex, int endIndex) {
+        if (str == null) {
+            throw new NullPointerException();
+        }
+        checkBoundsBeginEnd(beginIndex, endIndex);
+        int found = indexOf(str, beginIndex);
+        return found >= 0 && found + str.length() <= endIndex ? found : -1;
+    }
+
+    private void checkBoundsBeginEnd(int beginIndex, int endIndex) {
+        if (beginIndex < 0 || beginIndex > endIndex || endIndex > count) {
+            throw new StringIndexOutOfBoundsException("begin " + beginIndex + ", end " + endIndex
+                    + ", length " + count);
+        }
+    }
+
+    /// The elements, each as `String.valueOf` writes it, with `delimiter`
+    /// between every two.
+    public static String join(CharSequence delimiter, CharSequence... elements) {
+        if (delimiter == null || elements == null) {
+            throw new NullPointerException();
+        }
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < elements.length; i++) {
+            if (i > 0) {
+                out.append(delimiter);
+            }
+            out.append(String.valueOf(elements[i]));
+        }
+        return out.toString();
+    }
+
+    /// The elements, each as `String.valueOf` writes it, with `delimiter`
+    /// between every two.
+    public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {
+        if (delimiter == null || elements == null) {
+            throw new NullPointerException();
+        }
+        StringBuilder out = new StringBuilder();
+        boolean first = true;
+        for (CharSequence element : elements) {
+            if (!first) {
+                out.append(delimiter);
+            }
+            first = false;
+            out.append(String.valueOf(element));
+        }
+        return out.toString();
+    }
+
+    /// As `format(String, Object...)`. The locale is not consulted: this
+    /// runtime formats one way.
+    public static String format(java.util.Locale l, String format, Object... args) {
+        return StringFormatter.format(format, args);
+    }
+
+    /// As `toLowerCase()`. The locale is not consulted.
+    public java.lang.String toLowerCase(java.util.Locale locale) {
+        if (locale == null) {
+            throw new NullPointerException();
+        }
+        return toLowerCase();
+    }
+
+    /// `String.format(this, args)`.
+    public String formatted(Object... args) {
+        return StringFormatter.format(this, args);
+    }
+
+    /// Whether the string is empty or holds nothing but white space.
+    public boolean isBlank() {
+        return indexOfNonWhitespace() == count;
+    }
+
+    /// The string without its leading and trailing white space, as
+    /// `Character.isWhitespace` defines it. Unlike `trim`, which drops every
+    /// character up to the space, this keeps control characters that are not
+    /// white space and drops white space beyond ASCII.
+    public String strip() {
+        int start = indexOfNonWhitespace();
+        if (start == count) {
+            return "";
+        }
+        int end = lastIndexOfNonWhitespace() + 1;
+        return start == 0 && end == count ? this : substring(start, end);
+    }
+
+    /// The string without its leading white space.
+    public String stripLeading() {
+        int start = indexOfNonWhitespace();
+        return start == 0 ? this : substring(start);
+    }
+
+    /// The string without its trailing white space.
+    public String stripTrailing() {
+        int end = lastIndexOfNonWhitespace() + 1;
+        return end == count ? this : substring(0, end);
+    }
+
+    private int indexOfNonWhitespace() {
+        int i = 0;
+        while (i < count && Character.isWhitespace(charAt(i))) {
+            i++;
+        }
+        return i;
+    }
+
+    private int lastIndexOfNonWhitespace() {
+        int i = count - 1;
+        while (i >= 0 && Character.isWhitespace(charAt(i))) {
+            i--;
+        }
+        return i;
+    }
+
+    /// The string `count` times over.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `count` is negative
+    /// - `OutOfMemoryError`: if the result would be longer than a String can be
+    public String repeat(int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("count is negative: " + count);
+        }
+        if (count == 1) {
+            return this;
+        }
+        int length = length();
+        if (count == 0 || length == 0) {
+            return "";
+        }
+        if ((long) length * count > Integer.MAX_VALUE) {
+            throw new OutOfMemoryError("Required length exceeds implementation limit");
+        }
+        StringBuilder out = new StringBuilder(length * count);
+        for (int i = 0; i < count; i++) {
+            out.append(this);
+        }
+        return out.toString();
+    }
+
+    /// The lines of the string, without their terminators: a line feed, a
+    /// carriage return, or the two together. A terminator at the very end
+    /// starts no empty last line.
+    public java.util.stream.Stream<String> lines() {
+        return splitLines().stream();
+    }
+
+    private ArrayList<String> splitLines() {
+        ArrayList<String> out = new ArrayList<String>();
+        int n = count;
+        int start = 0;
+        while (start < n) {
+            int end = start;
+            char c = 0;
+            while (end < n) {
+                c = charAt(end);
+                if (c == '\n' || c == '\r') {
+                    break;
+                }
+                end++;
+            }
+            out.add(substring(start, end));
+            if (end < n && c == '\r' && end + 1 < n && charAt(end + 1) == '\n') {
+                end++;
+            }
+            start = end + 1;
+        }
+        return out;
+    }
+
+    /// Every line indented by `n` spaces, or, for a negative `n`, with up to
+    /// `-n` leading white space characters removed. Each line, the last
+    /// included, ends with a line feed in the result.
+    public String indent(int n) {
+        if (count == 0) {
+            return "";
+        }
+        ArrayList<String> lines = splitLines();
+        StringBuilder out = new StringBuilder(count + 16);
+        for (int i = 0; i < lines.size(); i++) {
+            String line = lines.get(i);
+            if (n > 0) {
+                for (int s = 0; s < n; s++) {
+                    out.append(' ');
+                }
+                out.append(line);
+            } else if (n < 0) {
+                // -n overflows for Integer.MIN_VALUE; negate as a long.
+                int drop = (int) Math.min(-(long) n, (long) line.indexOfNonWhitespace());
+                out.append(line, drop, line.length());
+            } else {
+                out.append(line);
+            }
+            out.append('\n');
+        }
+        return out.toString();
+    }
+
+    /// The string with the indentation common to its lines removed, trailing
+    /// white space removed from every line, and its line terminators
+    /// normalized to a line feed, as for a text block.
+    public String stripIndent() {
+        if (count == 0) {
+            return "";
+        }
+        char last = charAt(count - 1);
+        boolean optOut = last == '\n' || last == '\r';
+        ArrayList<String> lines = splitLines();
+        if (optOut) {
+            lines.add("");
+        }
+        int outdent = Integer.MAX_VALUE;
+        if (!optOut) {
+            for (int i = 0; i < lines.size(); i++) {
+                String line = lines.get(i);
+                int leading = line.indexOfNonWhitespace();
+                if (leading != line.length()) {
+                    outdent = Math.min(outdent, leading);
+                }
+            }
+            String lastLine = lines.get(lines.size() - 1);
+            if (lastLine.isBlank()) {
+                outdent = Math.min(outdent, lastLine.length());
+            }
+        } else {
+            outdent = 0;
+        }
+        StringBuilder out = new StringBuilder(count);
+        for (int i = 0; i < lines.size(); i++) {
+            String line = lines.get(i);
+            if (i > 0) {
+                out.append('\n');
+            }
+            int first = line.indexOfNonWhitespace();
+            int lastNonWs = line.lastIndexOfNonWhitespace();
+            if (first > lastNonWs) {
+                continue;
+            }
+            out.append(line, Math.min(outdent, first), lastNonWs + 1);
+        }
+        // With optOut, the empty line added above produced the final terminator.
+        return out.toString();
+    }
+
+    /// The string with its escape sequences translated as the Java language
+    /// translates them in a literal: `\b`, `\t`, `\n`, `\f`, `\r`, `\s`, the
+    /// quotes, the backslash, octal escapes, and a backslash before a line
+    /// terminator, which joins the lines.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: for an escape the language does not have
+    public String translateEscapes() {
+        if (indexOf('\\') < 0) {
+            return this;
+        }
+        StringBuilder out = new StringBuilder(count);
+        int i = 0;
+        while (i < count) {
+            char c = charAt(i++);
+            if (c != '\\') {
+                out.append(c);
+                continue;
+            }
+            c = i < count ? charAt(i++) : '\0';
+            switch (c) {
+                case 'b':
+                    out.append('\b');
+                    break;
+                case 'f':
+                    out.append('\f');
+                    break;
+                case 'n':
+                    out.append('\n');
+                    break;
+                case 'r':
+                    out.append('\r');
+                    break;
+                case 's':
+                    out.append(' ');
+                    break;
+                case 't':
+                    out.append('\t');
+                    break;
+                case '\'':
+                case '"':
+                case '\\':
+                    out.append(c);
+                    break;
+                case '\n':
+                    break;
+                case '\r':
+                    if (i < count && charAt(i) == '\n') {
+                        i++;
+                    }
+                    break;
+                default:
+                    if (c >= '0' && c <= '7') {
+                        int limit = c <= '3' ? 2 : 1;
+                        int code = c - '0';
+                        while (limit > 0 && i < count && charAt(i) >= '0' && charAt(i) <= '7') {
+                            code = code * 8 + (charAt(i++) - '0');
+                            limit--;
+                        }
+                        out.append((char) code);
+                    } else {
+                        throw new IllegalArgumentException("Invalid escape sequence: \\" + c + " \\\\u"
+                                + hex4(c));
+                    }
+            }
+        }
+        return out.toString();
+    }
+
+    private static String hex4(char c) {
+        String digits = "0123456789ABCDEF";
+        char[] out = new char[4];
+        for (int i = 3; i >= 0; i--) {
+            out[i] = digits.charAt(c & 0xf);
+            c >>>= 4;
+        }
+        return new String(out);
+    }
+
+    /// `f.apply(this)`.
+    public <R> R transform(java.util.function.Function<? super String, ? extends R> f) {
+        return f.apply(this);
+    }
 }
diff --git a/vm/JavaAPI/src/java/lang/StringBuffer.java b/vm/JavaAPI/src/java/lang/StringBuffer.java
index aa5df90d0a8..154ba1668eb 100644
--- a/vm/JavaAPI/src/java/lang/StringBuffer.java
+++ b/vm/JavaAPI/src/java/lang/StringBuffer.java
@@ -33,7 +33,7 @@
  * Every string buffer has a capacity. As long as the length of the character sequence contained in the string buffer does not exceed the capacity, it is not necessary to allocate a new internal buffer array. If the internal buffer overflows, it is automatically made larger.
  * Since: JDK1.0, CLDC 1.0 See Also:ByteArrayOutputStream, String
  */
-public final class StringBuffer implements CharSequence, Appendable {
+public final class StringBuffer implements CharSequence, Appendable, Comparable<StringBuffer> {
     private StringBuilder internal;
     /**
      * Constructs a string buffer with no characters in it and an initial capacity of 16 characters.
@@ -334,8 +334,9 @@ public synchronized java.lang.String toString(){
         return internal.toString();
     }
 
-    public synchronized StringBuffer StringBuffer(java.lang.CharSequence cs) {
-        return new StringBuffer(cs.toString());
+    /// A buffer holding the characters of `cs`.
+    public StringBuffer(java.lang.CharSequence cs) {
+        internal = new StringBuilder(cs.toString());
     }
 
     public synchronized void trimToSize() {
@@ -368,5 +369,96 @@ public synchronized CharSequence subSequence(int start, int end) {
         return internal.substring(start, end);
     }
 
+    /// Appends the contents of `sb`, or `"null"`.
+    public synchronized StringBuffer append(StringBuffer sb) {
+        internal.append(sb == null ? "null" : sb.toString());
+        return this;
+    }
+
+    /// Inserts `len` chars of `str` from `offset` at `index`.
+    public synchronized StringBuffer insert(int index, char[] str, int offset, int len) {
+        internal.insert(index, str, offset, len);
+        return this;
+    }
+
+    /// Appends the code point, as one char or as a surrogate pair.
+    public synchronized StringBuffer appendCodePoint(int codePoint) {
+        internal.appendCodePoint(codePoint);
+        return this;
+    }
+
+    /// The code point at `index`.
+    public synchronized int codePointAt(int index) {
+        return internal.codePointAt(index);
+    }
+
+    /// The code point that ends just before `index`.
+    public synchronized int codePointBefore(int index) {
+        return internal.codePointBefore(index);
+    }
+
+    /// The number of code points between `beginIndex` and `endIndex`.
+    public synchronized int codePointCount(int beginIndex, int endIndex) {
+        return internal.codePointCount(beginIndex, endIndex);
+    }
+
+    /// The index `codePointOffset` code points away from `index`.
+    public synchronized int offsetByCodePoints(int index, int codePointOffset) {
+        return internal.offsetByCodePoints(index, codePointOffset);
+    }
+
+    /// The first index of `str`, or -1.
+    public synchronized int indexOf(String str) {
+        return internal.indexOf(str);
+    }
+
+    /// The first index of `str` at or after `fromIndex`, or -1.
+    public synchronized int indexOf(String str, int fromIndex) {
+        return internal.indexOf(str, fromIndex);
+    }
+
+    /// The last index of `str`, or -1.
+    public synchronized int lastIndexOf(String str) {
+        return internal.lastIndexOf(str);
+    }
+
+    /// The last index of `str` at or before `fromIndex`, or -1.
+    public synchronized int lastIndexOf(String str, int fromIndex) {
+        return internal.lastIndexOf(str, fromIndex);
+    }
+
+    /// Replaces the characters from `start` to `end` with `str`.
+    public synchronized StringBuffer replace(int start, int end, String str) {
+        internal.replace(start, end, str);
+        return this;
+    }
+
+    /// The characters from `start` to the end.
+    public synchronized String substring(int start) {
+        return internal.substring(start);
+    }
+
+    /// The characters from `start` to `end`.
+    public synchronized String substring(int start, int end) {
+        return internal.substring(start, end);
+    }
+
+    /// Appends the code point `count` times.
+    public synchronized StringBuffer repeat(int codePoint, int count) {
+        internal.repeat(codePoint, count);
+        return this;
+    }
+
+    /// Appends `cs` `count` times.
+    public synchronized StringBuffer repeat(CharSequence cs, int count) {
+        internal.repeat(cs, count);
+        return this;
+    }
+
+    /// Compares the contents lexicographically.
+    public synchronized int compareTo(StringBuffer another) {
+        return CharSequence.compare(this, another);
+    }
+
 
 }
diff --git a/vm/JavaAPI/src/java/lang/StringBuilder.java b/vm/JavaAPI/src/java/lang/StringBuilder.java
index 6492eb415c8..6c9cd55c5fb 100644
--- a/vm/JavaAPI/src/java/lang/StringBuilder.java
+++ b/vm/JavaAPI/src/java/lang/StringBuilder.java
@@ -24,7 +24,7 @@
 package java.lang;
 
 /** Mutable UTF-16 sequence with compact storage for Latin-1 code units. */
-public final class StringBuilder implements CharSequence, Appendable {
+public final class StringBuilder implements CharSequence, Appendable, Comparable<StringBuilder> {
     static final int INITIAL_CAPACITY = 16;
     // Private native buffer lock. Explicit initialization also covers no-zero allocation.
     private long cn1AccessOwner = 0;
@@ -199,11 +199,96 @@ public StringBuilder reverse() {
     }
 
     public CharSequence subSequence(int start, int end) { return substring(start, end); }
-    // Preserve the API's existing return type.
-    public StringBuilder substring(int start, int end) {
+
+    /// The characters from `start` to the end, as a String.
+    public String substring(int start) { return substring(start, count); }
+
+    /// The characters from `start` to `end`, as a String.
+    public String substring(int start, int end) {
         checkRange(start, end);
-        StringBuilder result = new StringBuilder(end - start);
-        for (int i = start; i < end; i++) result.append(unit(i));
-        return result;
+        char[] chars = new char[end - start];
+        getChars(start, end, chars, 0);
+        return new String(chars);
+    }
+
+    /// Appends the code point, as one char or as a surrogate pair.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if it is not a valid code point
+    public StringBuilder appendCodePoint(int codePoint) {
+        if (codePoint >= 0 && codePoint < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
+            return append((char) codePoint);
+        }
+        Character.checkCodePoint(codePoint);
+        append(Character.highSurrogate(codePoint));
+        return append(Character.lowSurrogate(codePoint));
+    }
+
+    /// The code point at `index`.
+    public int codePointAt(int index) {
+        checkIndex(index);
+        return Character.codePointAt(this, index);
+    }
+
+    /// The code point that ends just before `index`.
+    public int codePointBefore(int index) {
+        if (index < 1 || index > count) throw new StringIndexOutOfBoundsException(index);
+        return Character.codePointBefore(this, index);
+    }
+
+    /// The number of code points between `beginIndex` and `endIndex`.
+    public int codePointCount(int beginIndex, int endIndex) {
+        if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) throw new IndexOutOfBoundsException();
+        return Character.codePointCount(this, beginIndex, endIndex);
+    }
+
+    /// The index `codePointOffset` code points away from `index`.
+    public int offsetByCodePoints(int index, int codePointOffset) {
+        if (index < 0 || index > count) throw new IndexOutOfBoundsException();
+        return Character.offsetByCodePoints(this, index, codePointOffset);
+    }
+
+    /// The first index of `str`, or -1.
+    public int indexOf(String str) { return indexOf(str, 0); }
+
+    /// The first index of `str` at or after `fromIndex`, or -1.
+    public int indexOf(String str, int fromIndex) { return toString().indexOf(str, fromIndex); }
+
+    /// The last index of `str`, or -1.
+    public int lastIndexOf(String str) { return lastIndexOf(str, count); }
+
+    /// The last index of `str` at or before `fromIndex`, or -1.
+    public int lastIndexOf(String str, int fromIndex) { return toString().lastIndexOf(str, fromIndex); }
+
+    /// Replaces the characters from `start` to `end` (clamped to the length)
+    /// with `str`.
+    public StringBuilder replace(int start, int end, String str) {
+        if (str == null) throw new NullPointerException();
+        if (end > count) end = count;
+        if (start < 0 || start > end) {
+            throw new StringIndexOutOfBoundsException("Range [" + start + ", " + end + ") out of bounds for length " + count);
+        }
+        delete(start, end);
+        return insert(start, str);
     }
+
+    /// Appends the code point `count` times.
+    public StringBuilder repeat(int codePoint, int count) {
+        if (count < 0) throw new IllegalArgumentException("count is negative: " + count);
+        Character.checkCodePoint(codePoint);
+        for (int i = 0; i < count; i++) appendCodePoint(codePoint);
+        return this;
+    }
+
+    /// Appends `cs` (or `"null"`) `count` times.
+    public StringBuilder repeat(CharSequence cs, int count) {
+        if (count < 0) throw new IllegalArgumentException("count is negative: " + count);
+        String text = String.valueOf(cs);
+        for (int i = 0; i < count; i++) append(text);
+        return this;
+    }
+
+    /// Compares the contents lexicographically.
+    public int compareTo(StringBuilder another) { return CharSequence.compare(this, another); }
 }
diff --git a/vm/JavaAPI/src/java/lang/System.java b/vm/JavaAPI/src/java/lang/System.java
index 24067773bcd..8e07484241d 100644
--- a/vm/JavaAPI/src/java/lang/System.java
+++ b/vm/JavaAPI/src/java/lang/System.java
@@ -23,6 +23,8 @@
 
 package java.lang;
 
+import com.codename1.impl.JdkHost;
+
 import java.io.NSLogOutputStream;
 import java.io.PrintStream;
 
@@ -156,8 +158,12 @@ private static void stopGC() {
      * This method calls the exit method in class Runtime. This method never returns normally.
      * The call System.exit(n) is effectively equivalent to the call:
      * Runtime.getRuntime().exit(n)
+     * The shutdown hooks run first, then the platform is asked to close the
+     * application (see Runtime.exit), then the process ends.
      */
-    public static native void exit(int status);
+    public static void exit(int status) {
+        Runtime.getRuntime().exit(status);
+    }
 
     /**
      * Runs the garbage collector.
@@ -184,13 +190,83 @@ public static void gc() {
 
     /**
      * Gets the system property indicated by the specified key.
+     *
+     * A property set with setProperty wins, and one removed with
+     * clearProperty stays removed. Otherwise the class library answers the
+     * properties every program reads the same way on every platform --
+     * line.separator, file.separator and path.separator; user.home and
+     * user.dir, the application's home directory; java.io.tmpdir, its caches
+     * directory where the platform has one and its home otherwise; user.name,
+     * java.version and os.arch, which a device does not expose and which get
+     * fixed answers -- and asks the platform for any other, through
+     * com.codename1.impl.JdkHost (os.name, and display properties in a
+     * Codename One application).
      */
-    public static synchronized java.lang.String getProperty(java.lang.String key){
+    public static java.lang.String getProperty(java.lang.String key){
         checkPropertyKey(key);
-        return properties == null ? null : properties.get(key);
+        synchronized (System.class) {
+            if (properties != null && properties.containsKey(key)) {
+                return properties.get(key);
+            }
+        }
+        return builtInProperty(key);
     }
 
-    private static java.util.Hashtable<String, String> properties;
+    /**
+     * Set and cleared properties; a cleared one maps to null, which hides the
+     * built-in answer as the JDK's removal does.
+     */
+    private static java.util.HashMap<String, String> properties;
+
+    /**
+     * The answer for a property nobody set. Called without the lock: the
+     * host may call into the platform, which may read a property itself.
+     */
+    private static String builtInProperty(String key) {
+        if ("line.separator".equals(key)) {
+            return "\n";
+        }
+        if ("file.separator".equals(key)) {
+            return "/";
+        }
+        if ("path.separator".equals(key)) {
+            return ":";
+        }
+        if ("user.name".equals(key)) {
+            return "user";
+        }
+        if ("java.version".equals(key)) {
+            return "1.8.0";
+        }
+        if ("os.arch".equals(key)) {
+            return "unknown";
+        }
+        JdkHost host = JdkHost.get();
+        if ("user.home".equals(key) || "user.dir".equals(key)) {
+            return withoutTrailingSlash(host.appHome());
+        }
+        if ("java.io.tmpdir".equals(key)) {
+            String caches = host.cachesDir();
+            return withoutTrailingSlash(caches == null ? host.appHome() : caches);
+        }
+        return host.property(key);
+    }
+
+    /** {@code path} without a trailing separator, unless it is the root. */
+    private static String withoutTrailingSlash(String path) {
+        if (path != null && path.length() > 1 && (path.endsWith("/") || path.endsWith("\\"))) {
+            return path.substring(0, path.length() - 1);
+        }
+        return path;
+    }
+
+    /**
+     * The system-dependent line separator, always a single line feed: the
+     * line.separator property, as it stood when the program started.
+     */
+    public static String lineSeparator() {
+        return "\n";
+    }
 
     private static void checkPropertyKey(String key) {
         if (key == null) throw new NullPointerException();
@@ -202,16 +278,29 @@ public static String getProperty(String key, String defaultValue) {
         return value == null ? defaultValue : value;
     }
 
-    public static synchronized String setProperty(String key, String value) {
+    public static String setProperty(String key, String value) {
         checkPropertyKey(key);
         if (value == null) throw new NullPointerException();
-        if (properties == null) properties = new java.util.Hashtable<String, String>();
-        return properties.put(key, value);
+        String previous;
+        boolean known;
+        synchronized (System.class) {
+            if (properties == null) properties = new java.util.HashMap<String, String>();
+            known = properties.containsKey(key);
+            previous = properties.put(key, value);
+        }
+        return known ? previous : builtInProperty(key);
     }
 
-    public static synchronized String clearProperty(String key) {
+    public static String clearProperty(String key) {
         checkPropertyKey(key);
-        return properties == null ? null : properties.remove(key);
+        String previous;
+        boolean known;
+        synchronized (System.class) {
+            if (properties == null) properties = new java.util.HashMap<String, String>();
+            known = properties.containsKey(key);
+            previous = properties.put(key, null);
+        }
+        return known ? previous : builtInProperty(key);
     }
 
     /**
@@ -247,6 +336,15 @@ public static java.lang.String getenv(java.lang.String name) {
 
     private static native java.lang.String getenvImpl(java.lang.String name);
 
+    /**
+     * The environment as a map. The class library cannot list the process
+     * environment, so the map is empty; getenv(String) still reads each
+     * variable by name.
+     */
+    public static java.util.Map<String, String> getenv() {
+        return java.util.Collections.emptyMap();
+    }
+
     /**
      * Returns the same hashcode for the given object as would be returned by the default method hashCode(), whether or not the given object's class overrides hashCode(). The hashcode for the null reference is zero.
      */
diff --git a/vm/JavaAPI/src/java/lang/Thread.java b/vm/JavaAPI/src/java/lang/Thread.java
index b1e00e5eea2..285d093483f 100644
--- a/vm/JavaAPI/src/java/lang/Thread.java
+++ b/vm/JavaAPI/src/java/lang/Thread.java
@@ -23,6 +23,8 @@
 
 package java.lang;
 
+import com.codename1.impl.JdkHost;
+
 import java.util.HashMap;
 
 /**
@@ -70,7 +72,22 @@ public class Thread implements java.lang.Runnable{
     private int priority = NORM_PRIORITY;
     private long nativeThreadId;
     private boolean daemon;
+    private long id;
+    private UncaughtExceptionHandler uncaughtExceptionHandler;
     private static int activeThreads = 0;
+    private static long lastId;
+    private static UncaughtExceptionHandler defaultUncaughtExceptionHandler;
+
+    /**
+     * Handles what a thread's run method throws.
+     */
+    public interface UncaughtExceptionHandler {
+        /**
+         * Called with the thread and what its run method threw; anything
+         * this throws in turn is ignored.
+         */
+        void uncaughtException(Thread t, Throwable e);
+    }
     
     /**
      * Allocates a new Thread object.
@@ -142,6 +159,65 @@ public final java.lang.String getName(){
         return name; 
     }
 
+    /**
+     * Changes this thread's name.
+     */
+    public final void setName(String name) {
+        if (name == null) {
+            throw new NullPointerException("name cannot be null");
+        }
+        this.name = name;
+    }
+
+    /**
+     * A number that identifies this thread for its lifetime, assigned the
+     * first time it is asked for; never reused while the program runs.
+     */
+    public long getId() {
+        synchronized (Thread.class) {
+            if (id == 0) {
+                id = ++lastId;
+            }
+            return id;
+        }
+    }
+
+    /**
+     * Sets the handler for what this thread's run method throws; null
+     * leaves it to the default handler.
+     */
+    public void setUncaughtExceptionHandler(UncaughtExceptionHandler handler) {
+        this.uncaughtExceptionHandler = handler;
+    }
+
+    /**
+     * This thread's handler, or the default handler when it has none.
+     */
+    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
+        UncaughtExceptionHandler h = uncaughtExceptionHandler;
+        return h != null ? h : defaultUncaughtExceptionHandler;
+    }
+
+    /**
+     * Sets the handler for what any thread without its own handler throws.
+     * In a Codename One application it also receives what an event
+     * dispatch thread task throws, which then no longer reaches the
+     * platform's own error handling.
+     */
+    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler handler) {
+        defaultUncaughtExceptionHandler = handler;
+        if (handler != null) {
+            JdkHost.get().watchUncaughtExceptions();
+        }
+    }
+
+    /**
+     * The handler setDefaultUncaughtExceptionHandler set, or null.
+     */
+    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
+        return defaultUncaughtExceptionHandler;
+    }
+
     /**
      * Returns this thread's priority.
      */
@@ -230,7 +306,7 @@ private void runImpl(long tid) {
         try {
             target.run();
         } catch(Throwable t) {
-            t.printStackTrace();
+            dispatchUncaught(t);
         }
         activeThreads--;
         // DROPPED HERE, because nothing else can ever drop it.
@@ -255,6 +331,24 @@ private void runImpl(long tid) {
         }
     }
     
+    /**
+     * Hands what the run method threw to this thread's handler, else to the
+     * default one, else prints it. What a handler throws is ignored, as on
+     * the JDK.
+     */
+    private void dispatchUncaught(Throwable t) {
+        UncaughtExceptionHandler h = getUncaughtExceptionHandler();
+        if (h == null) {
+            t.printStackTrace();
+            return;
+        }
+        try {
+            h.uncaughtException(this, t);
+        } catch (Throwable ignored) {
+            // As the JDK: a handler's own failure goes nowhere.
+        }
+    }
+
     /**
      * If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.
      * Subclasses of Thread should override this method.
@@ -282,11 +376,28 @@ public static void sleep(long millis) throws java.lang.InterruptedException {
         if (millis < 0) {
             throw new IllegalArgumentException("timeout value is negative");
         }
+        // An interrupt that is pending, or that arrives while the thread
+        // sleeps, ends the sleep with InterruptedException and clears the
+        // status, as the JDK does. The native returns early when the status
+        // is set; the JavaScript runtime's throws by itself.
+        if (interrupted()) {
+            throw new InterruptedException();
+        }
         sleepImpl(millis);
+        if (interrupted()) {
+            throw new InterruptedException();
+        }
     }
 
     private static native void sleepImpl(long millis);
 
+    /// The exception the native `Object.wait` throws when the waiting thread
+    /// is interrupted. Called from `nativeMethods.m`, which is what keeps it
+    /// (and the exception class) in a translated application.
+    private static InterruptedException newInterruptedException() {
+        return new InterruptedException();
+    }
+
     public static void sleep(long millis, int nanos) throws java.lang.InterruptedException {
         if (millis < 0) {
             throw new IllegalArgumentException("timeout value is negative");
diff --git a/vm/JavaAPI/src/java/lang/Throwable.java b/vm/JavaAPI/src/java/lang/Throwable.java
index 31034b4f128..350fd370ac9 100644
--- a/vm/JavaAPI/src/java/lang/Throwable.java
+++ b/vm/JavaAPI/src/java/lang/Throwable.java
@@ -99,39 +99,58 @@ public java.lang.String getMessage(){
      * The format of the backtrace information depends on the implementation.
      */
     public void printStackTrace(){
-        System.out.println(renderedStack());
-        if (cause != null) {
-            System.out.println("Caused by ");
-            cause.printStackTrace();
-        }
+        System.out.println(printedStack());
     }
 
     public void printStackTrace(java.io.PrintStream s) {
-        s.println(renderedStack());
-        if (cause != null) {
-            s.println("Caused by ");
-            cause.printStackTrace(s);
+        s.println(printedStack());
+    }
+
+    /// Prints this throwable and its backtrace to the given writer, in the
+    /// same text `printStackTrace(PrintStream)` writes.
+    public void printStackTrace(java.io.PrintWriter s) {
+        s.println(printedStack());
+    }
+
+    /// The whole text `printStackTrace` prints, in the JDK's shape: the first
+    /// line is `toString()`, then this throwable's frames, then each cause
+    /// as `Caused by: ` followed by the cause's own text.
+    private String printedStack() {
+        StringBuilder sb = new StringBuilder();
+        Throwable t = this;
+        int depth = 0;
+        while (t != null && depth < 64) {
+            if (depth > 0) {
+                sb.append('\n').append("Caused by: ");
+            }
+            sb.append(t.headedStack());
+            Throwable next = t.cause;
+            t = next == t ? null : next;
+            depth++;
         }
+        return sb.toString();
     }
 
-    /*
-     * There is deliberately NO printStackTrace(java.io.PrintWriter) here.
-     *
-     * This VM has no java.io.PrintWriter -- not in vm/JavaAPI and not in
-     * Ports/CLDC11 -- so nothing on a device can construct one to pass, and
-     * CLDC11's Throwable, which is what the CN1 API offers at compile time, never
-     * declared the overload either. It existed here only because this file is
-     * compiled without a -bootclasspath and borrowed the JDK's class; the
-     * translator then emitted "#include java_io_PrintWriter.h" into
-     * java_lang_Throwable.c and every fresh translation died on the missing
-     * header. Nothing in the core or the device ports called it: the one caller in
-     * the tree is Ports/JavaSE, which compiles against the real JDK.
-     *
-     * Restoring it does not make `e.printStackTrace(writer)` translate either --
-     * the app's own PrintWriter reference is just as unresolvable -- so it would
-     * buy back the broken build and nothing else. Add java/io/PrintWriter.java
-     * first if that pattern is ever wanted.
-     */
+    /// [#renderedStack()] with `toString()` as its first line. The native
+    /// trace is filled in when the throwable is THROWN, so one that never
+    /// was has none and prints its `toString()` alone; and the native header
+    /// is the bare class name, without the message the JDK prints there.
+    private String headedStack() {
+        String text = renderedStack();
+        if (text == null) {
+            return toString();
+        }
+        if (stackReplaced) {
+            return text;
+        }
+        int nl = text.indexOf('\n');
+        String first = nl < 0 ? text : text.substring(0, nl);
+        if (!first.equals(getClass().getName())) {
+            // Not the native header (a browser engine's trace): leave it.
+            return text;
+        }
+        return nl < 0 ? toString() : toString() + text.substring(nl);
+    }
 
     /**
      * The text to print for this throwable's own frames. By default this is the native
diff --git a/vm/JavaAPI/src/java/lang/reflect/InvocationTargetException.java b/vm/JavaAPI/src/java/lang/reflect/InvocationTargetException.java
new file mode 100644
index 00000000000..77619898d8b
--- /dev/null
+++ b/vm/JavaAPI/src/java/lang/reflect/InvocationTargetException.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.lang.reflect;
+
+/// `java.lang.reflect.InvocationTargetException` for the Codename One
+/// runtime. A device has no reflective invocation, so nothing here throws
+/// it on its own account: it exists for the code that declares, catches or
+/// wraps it, `EventQueue.invokeAndWait` and `SwingUtilities.invokeAndWait`
+/// first among them.
+public class InvocationTargetException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    private final Throwable target;
+
+    protected InvocationTargetException() {
+        super((Throwable) null);
+        this.target = null;
+    }
+
+    public InvocationTargetException(Throwable target) {
+        super((Throwable) null);
+        this.target = target;
+    }
+
+    public InvocationTargetException(Throwable target, String s) {
+        super(s, null);
+        this.target = target;
+    }
+
+    public Throwable getTargetException() {
+        return target;
+    }
+
+    @Override
+    public Throwable getCause() {
+        return target;
+    }
+}
diff --git a/vm/JavaAPI/src/java/net/MalformedURLException.java b/vm/JavaAPI/src/java/net/MalformedURLException.java
new file mode 100644
index 00000000000..26ebc362f97
--- /dev/null
+++ b/vm/JavaAPI/src/java/net/MalformedURLException.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.net;
+
+import java.io.IOException;
+
+/// A string
+/// could not be parsed as a URL, or names a protocol nothing handles.
+public class MalformedURLException extends IOException {
+
+    private static final long serialVersionUID = 1L;
+
+    public MalformedURLException() {
+        super();
+    }
+
+    public MalformedURLException(String msg) {
+        super(msg);
+    }
+}
diff --git a/vm/JavaAPI/src/java/net/URI.java b/vm/JavaAPI/src/java/net/URI.java
index 7dec22fe4c9..4d1eed16804 100644
--- a/vm/JavaAPI/src/java/net/URI.java
+++ b/vm/JavaAPI/src/java/net/URI.java
@@ -300,6 +300,9 @@ protected void setAuthority(String newAuthority, boolean encode) throws URISynta
             authority = authority.substring(AUTHORITY_MARKER.length());
             newAuthority = authority;
         }
+        if (!encode) {
+            checkLegal(newAuthority, AUTHORITY_LEGAL, "authority");
+        }
         int index = newAuthority.indexOf(USERINFO_SEPARATOR);
         if (index != -1) {
             this.userInfo = newAuthority.substring(0, index);
@@ -345,6 +348,7 @@ protected void setQuery(String query, boolean encode) throws URISyntaxException
                 this.query = URIHelper.encodeString(this.query);
             } else {
                 // validate
+                checkLegal(this.query, URIC_LEGAL, "query");
                 URIHelper.decodeString(this.query);
             }
         }
@@ -367,6 +371,7 @@ protected void setPath(String path, boolean encode) throws URISyntaxException {
                 this.path = URIHelper.encodeString(this.path);
             } else {
                 // validate
+                checkLegal(this.path, PATH_LEGAL, "path");
                 URIHelper.decodeString(this.path);
             }
         }
@@ -492,6 +497,9 @@ protected void parseURI(String uriString) throws URISyntaxException {
         String s = uriString;
         int index = s.indexOf(FRAGMENT_SEPARATOR);
         if (index != -1) {
+            // setFragment cannot declare the exception, so the fragment is
+            // checked here, where the single-string constructor reads it.
+            checkLegal(s.substring(index + 1), URIC_LEGAL, "fragment");
             setFragment(s.substring(index + 1), false);
             s = s.substring(0, index);
         }
@@ -523,7 +531,14 @@ protected void parseSchemeSpecificPart(String ssp, boolean encode) throws URISyn
         if (ssp == null) {
             throw new URISyntaxException(ssp, "Invalid scheme specific part");
         }
+        if (scheme != null && ssp.length() == 0) {
+            // "http:" -- the JDK reports this rather than reading past the end.
+            throw new URISyntaxException(scheme + SCHEME_SEPARATOR, "Expected scheme-specific part");
+        }
         if (scheme != null && ssp.charAt(0) != PATH_SEPARATOR) {
+            if (!encode) {
+                checkLegal(ssp, URIC_LEGAL, "opaque part");
+            }
             this.opaque = true;
             this.schemeSpecificPart = ssp;
             return;
@@ -539,8 +554,18 @@ protected void parseSchemeSpecificPart(String ssp, boolean encode) throws URISyn
             s = s.substring(0, index);
         }
 
-        index = (s.startsWith(AUTHORITY_MARKER)) ? 2 : 0;
-        index = s.indexOf(PATH_SEPARATOR, index);
+        // Only a "//" opens an authority. Without one the remainder is all
+        // path: "file:/tmp/x" has no authority at all (not an empty one, which
+        // would print back as "file:///tmp/x"), and a relative "a/b" is a
+        // path, not host "a" with path "/b". An empty remainder ("#f", "?q")
+        // leaves the path null, which resolve() reads as "no path given".
+        if (!s.startsWith(AUTHORITY_MARKER)) {
+            if (s.length() > 0) {
+                setPath(s, encode);
+            }
+            return;
+        }
+        index = s.indexOf(PATH_SEPARATOR, AUTHORITY_MARKER.length());
         if (index != -1) {
             setPath(s.substring(index), encode);
             s = s.substring(0, index);
@@ -548,6 +573,53 @@ protected void parseSchemeSpecificPart(String ssp, boolean encode) throws URISyn
         setAuthority(s, encode);
     }
 
+    /// Characters, beyond the unreserved ones, that may appear unescaped in a
+    /// path: `pchar` plus the segment separator, from the RFC 2396 grammar
+    /// `java.net.URI` parses. `?` and `#` never reach a path, they split it.
+    private static final String PATH_LEGAL = ",;:$&+=/@";
+
+    /// The same for an authority, server or registry based; the brackets are
+    /// RFC 2732's IPv6 literal.
+    private static final String AUTHORITY_LEGAL = ",;:$&+=@[]";
+
+    /// The same for a query, a fragment and an opaque part (`uric`, with the
+    /// RFC 2732 brackets the JDK also accepts there).
+    private static final String URIC_LEGAL = ",;:$&+=/@?[]";
+
+    /// Throws `URISyntaxException` for the first character of `component` the
+    /// JDK's parser would reject: anything that is not unreserved, listed in
+    /// `legal`, a `%` followed by two hex digits, or a non-ASCII character
+    /// other than a control or space character. A space is the common case --
+    /// `new URI("http://h/a b")` must fail, as it does on the JVM, rather than
+    /// build a URI no server would accept.
+    ///
+    /// The checks only run on text the caller claimed was already encoded:
+    /// the single-string constructor. The multi-argument constructors encode
+    /// their arguments instead.
+    private static void checkLegal(String component, String legal, String name) throws URISyntaxException {
+        int len = component.length();
+        for (int i = 0; i < len; i++) {
+            char ch = component.charAt(i);
+            if (ch < 128) {
+                if (URIHelper.isAlphaNum(ch) || UNRESERVED_EXTRAS.indexOf(ch) != -1 || legal.indexOf(ch) != -1) {
+                    continue;
+                }
+                if (ch == QUOTE_MARKER && i + 2 < len && isHexDigit(component.charAt(i + 1))
+                        && isHexDigit(component.charAt(i + 2))) {
+                    i += 2;
+                    continue;
+                }
+            } else if (!Character.isISOControl(ch) && !Character.isSpaceChar(ch)) {
+                continue;
+            }
+            throw new URISyntaxException(component, "Illegal character in " + name, i);
+        }
+    }
+
+    private static boolean isHexDigit(char ch) {
+        return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
+    }
+
     /**
      * Internal utility method to throw a syntax error if a value can not be
      * parsed.
diff --git a/vm/JavaAPI/src/java/net/URL.java b/vm/JavaAPI/src/java/net/URL.java
index 257db50e533..348ad5f37fa 100644
--- a/vm/JavaAPI/src/java/net/URL.java
+++ b/vm/JavaAPI/src/java/net/URL.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Codename One and/or its affiliates. All rights reserved.
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
@@ -22,32 +22,717 @@
  */
 package java.net;
 
+import com.codename1.impl.JdkHost;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 
-public class URL {
-    
-    public URL(String spec) {
-        throw new UnsupportedOperationException("URL not implemented on this platform");
+/// A parsed URL, and a way to read what it points at.
+///
+/// Parsing follows the JDK class, including the resolution of a relative
+/// reference against a context URL. The protocols accepted are `http`,
+/// `https`, `file`, `ftp`, `jar`, `mailto` and `cn1res`; any other throws
+/// `MalformedURLException`, as an unknown protocol does on the JDK.
+///
+/// #### Reading
+///
+/// [#openStream()] reads:
+///
+/// - `file:` through `java.io.FileInputStream`.
+/// - `http:` and `https:` through the platform's network, which
+///   `com.codename1.impl.JdkHost` reaches (a Codename One `ConnectionRequest`
+///   in an application), run to completion before the stream is returned:
+///   the stream is over the whole downloaded body, so it suits configuration
+///   files and images, not endless or very large responses.
+/// - `cn1res:` from the application's packaged resources, through the same
+///   host.
+///
+/// #### The `cn1res` scheme
+///
+/// `cn1res:/images/logo.png` names the resource `/images/logo.png` of the
+/// application, the one `Class.getResourceAsStream("/images/logo.png")`
+/// opens. The scheme exists because the device has no `Class.getResource`:
+/// a later step of the build rewrites calls to `Class.getResource(String)` so
+/// that they return a URL of this scheme, and code that goes on to call
+/// `openStream()`, `toString()` or `toExternalForm()` on the result keeps
+/// working. A `cn1res` URL has no host; its path is the absolute resource
+/// name.
+///
+/// #### Differences from the JDK
+///
+/// - No `openConnection`, `getContent` or stream handler factories: the
+///   device has no `URLConnection`.
+/// - `equals` and `hashCode` compare host names as text, ignoring case, and
+///   never resolve them.
+public final class URL implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String protocol;
+    private final String host;
+    private final int port;
+    private final String authority;
+    private final String userInfo;
+    private final String path;
+    private final String query;
+    private final String ref;
+
+    public URL(String spec) throws MalformedURLException {
+        this(null, spec);
+    }
+
+    public URL(String protocol, String host, String file) throws MalformedURLException {
+        this(protocol, host, -1, file);
+    }
+
+    public URL(String protocol, String host, int port, String file) throws MalformedURLException {
+        String scheme = asciiLower(protocol);
+        if (!isKnownProtocol(scheme)) {
+            throw new MalformedURLException("unknown protocol: " + protocol);
+        }
+        this.protocol = scheme;
+        if (host != null) {
+            String h = host;
+            if (h.indexOf(':') >= 0 && !h.startsWith("[")) {
+                h = "[" + h + "]";
+            }
+            if (port < -1) {
+                throw new MalformedURLException("Invalid port number :" + port);
+            }
+            this.host = h;
+            this.port = port;
+            this.authority = port == -1 ? h : h + ":" + port;
+        } else {
+            this.host = null;
+            this.port = -1;
+            this.authority = null;
+        }
+        this.userInfo = null;
+        String rest = file;
+        int hash = rest.indexOf('#');
+        this.ref = hash < 0 ? null : rest.substring(hash + 1);
+        if (hash >= 0) {
+            rest = rest.substring(0, hash);
+        }
+        int question = rest.lastIndexOf('?');
+        if (question >= 0) {
+            this.query = rest.substring(question + 1);
+            this.path = rest.substring(0, question);
+        } else {
+            this.query = null;
+            this.path = rest;
+        }
+    }
+
+    /// Parses `spec`, resolving it against `context` when it is a relative
+    /// reference; `context` may be `null`.
+    public URL(URL context, String spec) throws MalformedURLException {
+        if (spec == null) {
+            throw new MalformedURLException("no protocol: null");
+        }
+        int limit = spec.length();
+        while (limit > 0 && spec.charAt(limit - 1) <= ' ') {
+            limit--;
+        }
+        int start = 0;
+        while (start < limit && spec.charAt(start) <= ' ') {
+            start++;
+        }
+        if (spec.regionMatches(true, start, "url:", 0, 4)) {
+            start += 4;
+        }
+        boolean isRef = start < spec.length() && spec.charAt(start) == '#';
+        String newProtocol = null;
+        for (int i = start; !isRef && i < limit; i++) {
+            char c = spec.charAt(i);
+            if (c == '/') {
+                break;
+            }
+            if (c == ':') {
+                String s = asciiLower(spec.substring(start, i));
+                if (isValidProtocol(s)) {
+                    newProtocol = s;
+                    start = i + 1;
+                }
+                break;
+            }
+        }
+
+        String p = newProtocol;
+        String h = null;
+        int prt = -1;
+        String auth = null;
+        String user = null;
+        String pth = null;
+        String qry = null;
+        String rf = null;
+        boolean isRelative = false;
+        if (context != null && (newProtocol == null || newProtocol.equals(context.protocol))) {
+            // A scheme repeated in front of a relative reference to a
+            // hierarchical URL is ignored.
+            if (context.path != null && context.path.startsWith("/")) {
+                newProtocol = null;
+            }
+            if (newProtocol == null) {
+                p = context.protocol;
+                auth = context.authority;
+                user = context.userInfo;
+                h = context.host;
+                prt = context.port;
+                pth = context.path;
+                isRelative = true;
+            }
+        }
+        if (p == null) {
+            throw new MalformedURLException("no protocol: " + spec);
+        }
+        if (!isKnownProtocol(p)) {
+            throw new MalformedURLException("unknown protocol: " + p);
+        }
+        int hash = spec.indexOf('#', start);
+        if (hash >= 0) {
+            rf = spec.substring(hash + 1, limit);
+            limit = hash;
+        }
+        if (isRelative && start == limit) {
+            // An empty reference is the context itself.
+            qry = context.query;
+            if (rf == null) {
+                rf = context.ref;
+            }
+        }
+
+        if ("jar".equals(p) || "mailto".equals(p)) {
+            // Not hierarchical: everything after the scheme is the file.
+            String file;
+            if ("mailto".equals(p)) {
+                file = spec.substring(start, limit);
+                if (file.trim().length() == 0) {
+                    throw new MalformedURLException("No email address");
+                }
+            } else if (hash == start && isRelative) {
+                file = context.getFile();
+            } else {
+                file = jarFile(isRelative ? context.getFile() : null, spec.substring(start, limit),
+                        newProtocol != null);
+            }
+            if ("mailto".equals(p)) {
+                // As in the JDK, an address has no fragment.
+                rf = null;
+            }
+            int question = file.lastIndexOf('?');
+            this.protocol = p;
+            this.host = "";
+            this.port = -1;
+            this.authority = null;
+            this.userInfo = null;
+            this.path = question < 0 ? file : file.substring(0, question);
+            this.query = question < 0 ? null : file.substring(question + 1);
+            this.ref = rf;
+            return;
+        }
+
+        // From here on: the authority, then the path and the query.
+        String s = spec;
+        boolean isRelPath = false;
+        boolean queryOnly = false;
+        if (start < limit) {
+            int queryStart = s.indexOf('?');
+            queryOnly = queryStart == start;
+            if (queryStart != -1 && queryStart < limit) {
+                qry = s.substring(queryStart + 1, limit);
+                limit = queryStart;
+                s = s.substring(0, queryStart);
+            }
+        }
+        boolean fourSlashes = start <= limit - 4 && s.charAt(start) == '/' && s.charAt(start + 1) == '/'
+                && s.charAt(start + 2) == '/' && s.charAt(start + 3) == '/';
+        if (!fourSlashes && start <= limit - 2 && s.charAt(start) == '/' && s.charAt(start + 1) == '/') {
+            start += 2;
+            int end = s.indexOf('/', start);
+            if (end < 0 || end > limit) {
+                end = s.indexOf('?', start);
+                if (end < 0 || end > limit) {
+                    end = limit;
+                }
+            }
+            auth = s.substring(start, end);
+            h = auth;
+            int at = auth.indexOf('@');
+            if (at != -1) {
+                if (at != auth.lastIndexOf('@')) {
+                    user = null;
+                    h = null;
+                } else {
+                    user = auth.substring(0, at);
+                    h = auth.substring(at + 1);
+                }
+            } else {
+                user = null;
+            }
+            prt = -1;
+            if (h != null) {
+                String portText = null;
+                if (h.length() > 0 && h.charAt(0) == '[') {
+                    int close = h.indexOf(']');
+                    if (close <= 2) {
+                        throw new MalformedURLException("Invalid authority field: " + auth);
+                    }
+                    if (h.length() > close + 1) {
+                        if (h.charAt(close + 1) != ':') {
+                            throw new MalformedURLException("Invalid authority field: " + auth);
+                        }
+                        portText = h.substring(close + 2);
+                    }
+                    h = h.substring(0, close + 1);
+                } else {
+                    int colon = h.indexOf(':');
+                    if (colon >= 0) {
+                        portText = h.substring(colon + 1);
+                        h = h.substring(0, colon);
+                    }
+                }
+                if (portText != null && portText.length() > 0) {
+                    prt = parsePort(portText);
+                }
+            } else {
+                h = "";
+            }
+            start = end;
+            if (auth.length() > 0) {
+                // With an authority, the path comes from the reference alone.
+                pth = "";
+            }
+        }
+        if (h == null) {
+            h = "";
+        }
+        if (start < limit) {
+            if (s.charAt(start) == '/') {
+                pth = s.substring(start, limit);
+            } else if (pth != null && pth.length() > 0) {
+                isRelPath = true;
+                int slash = pth.lastIndexOf('/');
+                String separator = slash == -1 && auth != null ? "/" : "";
+                pth = pth.substring(0, slash + 1) + separator + s.substring(start, limit);
+            } else {
+                String separator = auth != null ? "/" : "";
+                pth = separator + s.substring(start, limit);
+            }
+        } else if (queryOnly && pth != null) {
+            int slash = pth.lastIndexOf('/');
+            if (slash < 0) {
+                slash = 0;
+            }
+            pth = pth.substring(0, slash) + "/";
+        }
+        if (pth == null) {
+            pth = "";
+        }
+        if (isRelPath) {
+            pth = removeDots(pth);
+        }
+        this.protocol = p;
+        this.host = h;
+        this.port = prt;
+        this.authority = auth;
+        this.userInfo = user;
+        this.path = pth;
+        this.query = qry;
+        this.ref = rf;
+    }
+
+    /// The index of the `/` of the last `!/` in a `jar:` file, or -1.
+    private static int indexOfBangSlash(String file) {
+        int bang = file.lastIndexOf('!');
+        while (bang >= 0) {
+            if (bang != file.length() - 1 && file.charAt(bang + 1) == '/') {
+                return bang + 1;
+            }
+            bang = bang == 0 ? -1 : file.lastIndexOf('!', bang - 1);
+        }
+        return -1;
+    }
+
+    /// The file of a `jar:` URL: an archive's own URL, `!/`, and the entry.
+    /// A relative reference is resolved inside the archive, never out of it.
+    private static String jarFile(String contextFile, String part, boolean absolute)
+            throws MalformedURLException {
+        if (absolute) {
+            int bangSlash = indexOfBangSlash(part);
+            if (bangSlash < 0) {
+                throw new MalformedURLException("no !/ in spec");
+            }
+            try {
+                new URL(part.substring(0, bangSlash - 1));
+            } catch (MalformedURLException e) {
+                throw new MalformedURLException("invalid url: " + part + " (" + e.getMessage() + ")");
+            }
+            return part;
+        }
+        if (contextFile == null) {
+            throw new MalformedURLException("no !/ in spec");
+        }
+        String file = contextFile;
+        if (part.startsWith("/")) {
+            int bangSlash = indexOfBangSlash(file);
+            if (bangSlash < 0) {
+                throw new MalformedURLException("malformed context url: no !/");
+            }
+            file = file.substring(0, bangSlash);
+        } else if (!file.endsWith("/")) {
+            int lastSlash = file.lastIndexOf('/');
+            if (lastSlash < 0) {
+                throw new MalformedURLException("malformed context url");
+            }
+            file = file.substring(0, lastSlash + 1);
+        }
+        file = file + part;
+        int bangSlash = indexOfBangSlash(file);
+        if (bangSlash < 0) {
+            throw new MalformedURLException("no !/ in spec");
+        }
+        return file.substring(0, bangSlash) + canonizeEntry(file.substring(bangSlash));
+    }
+
+    /// Resolves `.` and `..` in the entry part of a `jar:` file.
+    private static String canonizeEntry(String entry) {
+        String file = entry;
+        int i = file.indexOf("/../");
+        while (i >= 0) {
+            int lim = i > 0 ? file.lastIndexOf('/', i - 1) : -1;
+            file = lim >= 0 ? file.substring(0, lim) + file.substring(i + 3) : file.substring(i + 3);
+            i = file.indexOf("/../");
+        }
+        i = file.indexOf("/./");
+        while (i >= 0) {
+            file = file.substring(0, i) + file.substring(i + 2);
+            i = file.indexOf("/./");
+        }
+        while (file.endsWith("/..")) {
+            i = file.indexOf("/..");
+            int lim = i > 0 ? file.lastIndexOf('/', i - 1) : -1;
+            file = lim >= 0 ? file.substring(0, lim + 1) : file.substring(0, i);
+        }
+        if (file.endsWith("/.")) {
+            file = file.substring(0, file.length() - 1);
+        }
+        return file;
+    }
+
+    /// A port as the JDK reads one: a decimal `int` with an optional sign,
+    /// of which -1, "no port", is the only negative accepted.
+    private static int parsePort(String text) throws MalformedURLException {
+        int from = 0;
+        boolean negative = false;
+        if (text.charAt(0) == '-' || text.charAt(0) == '+') {
+            negative = text.charAt(0) == '-';
+            from = 1;
+        }
+        long value = 0;
+        if (text.length() == from || text.length() - from > 10) {
+            throw new MalformedURLException("For input string: \"" + text + "\"");
+        }
+        for (int i = from; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                throw new MalformedURLException("For input string: \"" + text + "\"");
+            }
+            value = value * 10 + (c - '0');
+        }
+        if (negative) {
+            value = -value;
+        }
+        if (value > Integer.MAX_VALUE || value < Integer.MIN_VALUE) {
+            throw new MalformedURLException("For input string: \"" + text + "\"");
+        }
+        if (value < -1) {
+            throw new MalformedURLException("Invalid port number :" + value);
+        }
+        return (int) value;
+    }
+
+    /// Resolves the `.` and `..` segments a relative reference brought into
+    /// a path.
+    private static String removeDots(String in) {
+        String path = in;
+        int i = path.indexOf("/./");
+        while (i >= 0) {
+            path = path.substring(0, i) + path.substring(i + 2);
+            i = path.indexOf("/./");
+        }
+        i = path.indexOf("/../");
+        while (i >= 0) {
+            // "/a/b/../c" becomes "/a/c"; "/../../a" has nothing to cancel
+            // and stays.
+            int previous = i > 0 ? path.lastIndexOf('/', i - 1) : -1;
+            if (previous >= 0 && path.indexOf("/../", previous) != 0) {
+                path = path.substring(0, previous) + path.substring(i + 3);
+                i = path.indexOf("/../");
+            } else {
+                i = path.indexOf("/../", i + 3);
+            }
+        }
+        while (path.endsWith("/..")) {
+            i = path.indexOf("/..");
+            int previous = i > 0 ? path.lastIndexOf('/', i - 1) : -1;
+            if (previous < 0) {
+                break;
+            }
+            path = path.substring(0, previous + 1);
+        }
+        if (path.startsWith("./") && path.length() > 2) {
+            path = path.substring(2);
+        }
+        if (path.endsWith("/.")) {
+            path = path.substring(0, path.length() - 1);
+        }
+        return path;
+    }
+
+    /// Lower case for the ASCII letters only. A scheme is ASCII by
+    /// specification, and `String.toLowerCase()` follows the device's locale.
+    private static String asciiLower(String s) {
+        StringBuilder sb = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                if (sb == null) {
+                    sb = new StringBuilder(s);
+                }
+                sb.setCharAt(i, (char) (c + ('a' - 'A')));
+            }
+        }
+        return sb == null ? s : sb.toString();
+    }
+
+    private static boolean isAsciiLetter(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+    }
+
+    private static boolean isValidProtocol(String protocol) {
+        int len = protocol.length();
+        if (len < 1 || !isAsciiLetter(protocol.charAt(0))) {
+            return false;
+        }
+        for (int i = 1; i < len; i++) {
+            char c = protocol.charAt(i);
+            boolean digit = c >= '0' && c <= '9';
+            if (!isAsciiLetter(c) && !digit && c != '.' && c != '+' && c != '-') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean isKnownProtocol(String protocol) {
+        return "http".equals(protocol) || "https".equals(protocol) || "file".equals(protocol)
+                || "cn1res".equals(protocol) || "ftp".equals(protocol) || "jar".equals(protocol)
+                || "mailto".equals(protocol);
+    }
+
+    public String getProtocol() {
+        return protocol;
+    }
+
+    public String getHost() {
+        return host;
     }
-    
-    public URL(String protocol, String host, int port, String file) {
-        throw new UnsupportedOperationException("URL not implemented on this platform");
+
+    public int getPort() {
+        return port;
+    }
+
+    public int getDefaultPort() {
+        if ("http".equals(protocol)) {
+            return 80;
+        }
+        if ("https".equals(protocol)) {
+            return 443;
+        }
+        if ("ftp".equals(protocol)) {
+            return 21;
+        }
+        return -1;
+    }
+
+    public String getAuthority() {
+        return authority;
+    }
+
+    public String getUserInfo() {
+        return userInfo;
+    }
+
+    public String getPath() {
+        return path;
     }
-    
-    public URL(String protocl, String host, String file) {
-        throw new UnsupportedOperationException("URL not implemented on this platform");
+
+    public String getQuery() {
+        return query;
     }
-    
-    public URL(URL context, String spec) {
-        throw new UnsupportedOperationException("URL not implemented on this platform");
+
+    public String getRef() {
+        return ref;
     }
-    
-    public URL(URL context, String spec, URLStreamHandler handler) {
-        throw new UnsupportedOperationException("URL not implemented on this platform");
+
+    public String getFile() {
+        return query == null ? path : path + "?" + query;
+    }
+
+    public String toExternalForm() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(protocol).append(':');
+        if (authority != null && authority.length() > 0) {
+            sb.append("//").append(authority);
+        }
+        if (path != null) {
+            sb.append(path);
+        }
+        if (query != null) {
+            sb.append('?').append(query);
+        }
+        if (ref != null) {
+            sb.append('#').append(ref);
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public String toString() {
+        return toExternalForm();
+    }
+
+    public URI toURI() throws URISyntaxException {
+        return new URI(toString());
     }
-    
-    public final InputStream openStream() throws IOException {
-        return null;
+
+    private static boolean same(String a, String b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    private int effectivePort() {
+        return port != -1 ? port : getDefaultPort();
+    }
+
+    /// Whether the two URLs name the same resource, the fragment aside.
+    public boolean sameFile(URL other) {
+        if (other == null) {
+            return false;
+        }
+        boolean hostsEqual = host == null || other.host == null
+                ? host == null && other.host == null
+                : host.equalsIgnoreCase(other.host);
+        return protocol.equals(other.protocol) && same(getFile(), other.getFile())
+                && effectivePort() == other.effectivePort() && hostsEqual;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof URL)) {
+            return false;
+        }
+        URL other = (URL) obj;
+        return same(ref, other.ref) && sameFile(other);
+    }
+
+    @Override
+    public int hashCode() {
+        int h = protocol.hashCode();
+        if (host != null) {
+            h += asciiLower(host).hashCode();
+        }
+        String file = getFile();
+        if (file != null) {
+            h += file.hashCode();
+        }
+        h += effectivePort();
+        if (ref != null) {
+            h += ref.hashCode();
+        }
+        return h;
+    }
+
+    private static int hex(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    /// Replaces each `%XX` by the byte it stands for and reads the result
+    /// as UTF-8. A `%` not followed by two hex digits is kept.
+    private static String percentDecode(String s) throws IOException {
+        if (s.indexOf('%') < 0) {
+            return s;
+        }
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        int i = 0;
+        while (i < s.length()) {
+            if (s.charAt(i) == '%' && i + 2 < s.length() && hex(s.charAt(i + 1)) >= 0
+                    && hex(s.charAt(i + 2)) >= 0) {
+                bytes.write((hex(s.charAt(i + 1)) << 4) | hex(s.charAt(i + 2)));
+                i += 3;
+            } else {
+                // Up to the next escape in one piece, so that a surrogate
+                // pair is encoded as the one character it is.
+                int next = s.indexOf('%', i + 1);
+                if (next < 0) {
+                    next = s.length();
+                }
+                bytes.write(s.substring(i, next).getBytes("UTF-8"));
+                i = next;
+            }
+        }
+        return new String(bytes.toByteArray(), "UTF-8");
+    }
+
+    /// Opens the resource for reading; see the class description for what
+    /// each protocol reads.
+    ///
+    /// #### Throws
+    ///
+    /// - `FileNotFoundException`: if the file or resource does not exist, or
+    ///   the server answers 404 or 410
+    ///
+    /// - `IOException`: if the request fails, the server answers another
+    ///   error status, or the protocol cannot be read on the device
+    public InputStream openStream() throws IOException {
+        if ("file".equals(protocol)) {
+            return new FileInputStream(new File(percentDecode(path)));
+        }
+        if ("cn1res".equals(protocol)) {
+            // Through the host, which knows the flat name the build shipped
+            // the resource under; the path here is the one it had on a desktop.
+            String name = percentDecode(path);
+            InputStream in = JdkHost.get().resource(name.startsWith("/") ? name.substring(1) : name);
+            if (in == null) {
+                throw new FileNotFoundException(toExternalForm());
+            }
+            return in;
+        }
+        if ("http".equals(protocol) || "https".equals(protocol)) {
+            return openHttp();
+        }
+        throw new IOException("Cannot read the " + protocol + " protocol: " + toExternalForm());
+    }
+
+    private InputStream openHttp() throws IOException {
+        StringBuilder address = new StringBuilder();
+        address.append(protocol).append("://").append(authority == null ? "" : authority).append(path);
+        if (query != null) {
+            address.append('?').append(query);
+        }
+        return JdkHost.get().openUrl(address.toString());
     }
 }
diff --git a/vm/JavaAPI/src/java/net/URLDecoder.java b/vm/JavaAPI/src/java/net/URLDecoder.java
new file mode 100644
index 00000000000..d65cea4ddc9
--- /dev/null
+++ b/vm/JavaAPI/src/java/net/URLDecoder.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.net;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+/// A string out of its
+/// `application/x-www-form-urlencoded` form. A plus is a space and a run of
+/// `%XX` is the bytes of some characters.
+public final class URLDecoder {
+
+    private URLDecoder() {
+    }
+
+    /// Decodes as UTF-8, where the JDK uses the platform's default.
+    public static String decode(String s) {
+        return decodeAs(s, "UTF-8");
+    }
+
+    public static String decode(String s, String enc) throws UnsupportedEncodingException {
+        if (enc == null) {
+            throw new NullPointerException("charsetName");
+        }
+        if (enc.length() == 0) {
+            throw new UnsupportedEncodingException("URLDecoder: empty string enc parameter");
+        }
+        return decodeAs(s, URLEncoder.charsetName(enc));
+    }
+
+    public static String decode(String s, Charset charset) {
+        return decodeAs(s, charset.name());
+    }
+
+    private static int hex(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    private static String decodeAs(String s, String charset) {
+        int n = s.length();
+        StringBuilder out = new StringBuilder(n);
+        byte[] bytes = null;
+        int i = 0;
+        while (i < n) {
+            char c = s.charAt(i);
+            if (c == '+') {
+                out.append(' ');
+                i++;
+            } else if (c == '%') {
+                if (bytes == null) {
+                    bytes = new byte[(n - i) / 3];
+                }
+                int count = 0;
+                while (i + 2 < n && c == '%') {
+                    int high = hex(s.charAt(i + 1));
+                    int low = hex(s.charAt(i + 2));
+                    if (high < 0 || low < 0) {
+                        throw new IllegalArgumentException(
+                                "URLDecoder: Illegal hex characters in escape (%) pattern - Error at index "
+                                + (high < 0 ? 0 : 1) + " in: \"" + s.substring(i + 1, i + 3) + "\"");
+                    }
+                    bytes[count++] = (byte) (high * 16 + low);
+                    i += 3;
+                    if (i < n) {
+                        c = s.charAt(i);
+                    }
+                }
+                if (i < n && c == '%') {
+                    throw new IllegalArgumentException("URLDecoder: Incomplete trailing escape (%) pattern");
+                }
+                try {
+                    out.append(new String(bytes, 0, count, charset));
+                } catch (UnsupportedEncodingException e) {
+                    throw new IllegalArgumentException(charset);
+                }
+            } else {
+                out.append(c);
+                i++;
+            }
+        }
+        return out.toString();
+    }
+}
diff --git a/vm/JavaAPI/src/java/net/URLEncoder.java b/vm/JavaAPI/src/java/net/URLEncoder.java
new file mode 100644
index 00000000000..3d65ea379b5
--- /dev/null
+++ b/vm/JavaAPI/src/java/net/URLEncoder.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.net;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+/// The `application/x-www-form-urlencoded` form of a
+/// string. Letters, digits and `.-*_` stay, a space is a plus, and every
+/// other character is the bytes of its encoding as `%XX`.
+public final class URLEncoder {
+    private static final String HEX = "0123456789ABCDEF";
+
+    private URLEncoder() {
+    }
+
+    static String charsetName(String enc) throws UnsupportedEncodingException {
+        if (enc == null) {
+            throw new NullPointerException("charsetName");
+        }
+        try {
+            return Charset.forName(enc).name();
+        } catch (IllegalArgumentException e) {
+            throw new UnsupportedEncodingException(enc);
+        }
+    }
+
+    private static boolean plain(char c) {
+        return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9'
+                || c == '.' || c == '-' || c == '*' || c == '_';
+    }
+
+    /// Encodes in UTF-8, where the JDK uses the platform's default.
+    public static String encode(String s) {
+        return encodeAs(s, "UTF-8");
+    }
+
+    public static String encode(String s, String enc) throws UnsupportedEncodingException {
+        return encodeAs(s, charsetName(enc));
+    }
+
+    public static String encode(String s, Charset charset) {
+        return encodeAs(s, charset.name());
+    }
+
+    private static String encodeAs(String s, String charset) {
+        int n = s.length();
+        StringBuilder out = new StringBuilder(n + 16);
+        int i = 0;
+        while (i < n) {
+            char c = s.charAt(i);
+            if (plain(c)) {
+                out.append(c);
+                i++;
+            } else if (c == ' ') {
+                out.append('+');
+                i++;
+            } else {
+                // The run of characters to escape is encoded as one piece,
+                // so the two halves of a surrogate pair stay together.
+                int start = i;
+                while (i < n && !plain(s.charAt(i)) && s.charAt(i) != ' ') {
+                    i++;
+                }
+                byte[] bytes;
+                try {
+                    bytes = s.substring(start, i).getBytes(charset);
+                } catch (UnsupportedEncodingException e) {
+                    throw new IllegalArgumentException(charset);
+                }
+                for (int b = 0; b < bytes.length; b++) {
+                    out.append('%').append(HEX.charAt((bytes[b] >> 4) & 0xF)).append(HEX.charAt(bytes[b] & 0xF));
+                }
+            }
+        }
+        return out.toString();
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/charset/Charset.java b/vm/JavaAPI/src/java/nio/charset/Charset.java
index a45d0e24746..a10e1024f78 100644
--- a/vm/JavaAPI/src/java/nio/charset/Charset.java
+++ b/vm/JavaAPI/src/java/nio/charset/Charset.java
@@ -22,52 +22,192 @@
  */
 package java.nio.charset;
 
-/**
- * Added this for Kotlin
- */
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+/// A named character encoding. This runtime has the three charsets every
+/// Java platform must: UTF-8, US-ASCII and ISO-8859-1, under their canonical
+/// names and the JDK's aliases. Encoding and decoding go through the
+/// String constructors and `getBytes` that take a Charset, and the readers
+/// and writers of `java.io`.
 public class Charset implements Comparable<Charset> {
 
-    private String name;
-    private static final Charset UTF8 = new SimpleCharset("UTF-8");
-    private static final Charset USASCII = new SimpleCharset("US-ASCII");
-    private static final Charset ISO88591 = new SimpleCharset("ISO-8859-1");
+    private static final String[] UTF8_ALIASES = {"unicode-1-1-utf-8", "UTF8"};
+    private static final String[] USASCII_ALIASES = {
+        "iso-ir-6", "ANSI_X3.4-1986", "ISO_646.irv:1991", "ASCII", "iso_646.irv:1983", "ANSI_X3.4-1968",
+        "646", "default", "cp367", "csASCII", "us", "ISO646-US", "IBM367", "ascii7"
+    };
+    private static final String[] ISO88591_ALIASES = {
+        "819", "ISO8859-1", "l1", "ISO_8859-1:1987", "ISO_8859-1", "8859_1", "iso-ir-100", "latin1",
+        "cp819", "ISO8859_1", "IBM819", "ISO_8859_1", "IBM-819", "csISOLatin1"
+    };
+    private static final Charset UTF8 = new SimpleCharset("UTF-8", UTF8_ALIASES);
+    private static final Charset USASCII = new SimpleCharset("US-ASCII", USASCII_ALIASES);
+    private static final Charset ISO88591 = new SimpleCharset("ISO-8859-1", ISO88591_ALIASES);
+
+    private final String name;
+    private final String[] aliases;
+
     protected Charset(String canonicalName, String[] aliases) {
+        checkName(canonicalName);
         name = canonicalName;
+        this.aliases = aliases == null ? new String[0] : aliases;
     }
-    
-    public int compareTo(Charset another) {
-        return name.compareTo(another.name);
+
+    /// Compares canonical names, ignoring case.
+    public final int compareTo(Charset another) {
+        return name.compareToIgnoreCase(another.name);
     }
-    
+
+    /// The canonical name.
     public final String name() {
         return name;
     }
 
+    /// The canonical name.
     public String displayName() {
         return name;
     }
-    
-    public static Charset forName(String name) {
-        if (name == null) {
-            throw new NullPointerException();
+
+    /// The canonical name, whatever the locale.
+    public String displayName(Locale locale) {
+        return name;
+    }
+
+    /// The aliases of the charset.
+    public final Set<String> aliases() {
+        HashSet<String> out = new HashSet<String>();
+        for (int i = 0; i < aliases.length; i++) {
+            out.add(aliases[i]);
+        }
+        return Collections.unmodifiableSet(out);
+    }
+
+    /// Whether the charset is registered with IANA; the three this runtime
+    /// has are.
+    public final boolean isRegistered() {
+        return true;
+    }
+
+    /// Whether the charset can encode; the three this runtime has can.
+    public boolean canEncode() {
+        return true;
+    }
+
+    /// Whether `obj` is a charset of the same canonical name.
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Charset)) {
+            return false;
+        }
+        return name.equals(((Charset) obj).name);
+    }
+
+    /// The hash of the canonical name.
+    public final int hashCode() {
+        return name.hashCode();
+    }
+
+    /// The canonical name.
+    public final String toString() {
+        return name;
+    }
+
+    /// UTF-8, the default charset of this runtime on every platform.
+    public static Charset defaultCharset() {
+        return UTF8;
+    }
+
+    /// Whether `charsetName` names a charset this runtime has.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalCharsetNameException`: if the name is not a legal charset name
+    /// - `IllegalArgumentException`: if it is null
+    public static boolean isSupported(String charsetName) {
+        return lookup(charsetName) != null;
+    }
+
+    /// The charset `charsetName` names, by canonical name or alias, in any
+    /// case.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalCharsetNameException`: if the name is not a legal charset name
+    /// - `UnsupportedCharsetException`: if this runtime has no such charset
+    /// - `IllegalArgumentException`: if it is null
+    public static Charset forName(String charsetName) {
+        Charset cs = lookup(charsetName);
+        if (cs == null) {
+            throw new UnsupportedCharsetException(charsetName);
+        }
+        return cs;
+    }
+
+    /// The charset `charsetName` names, or `fallback` when the name is
+    /// illegal or names a charset this runtime does not have.
+    public static Charset forName(String charsetName, Charset fallback) {
+        try {
+            Charset cs = lookup(charsetName);
+            return cs == null ? fallback : cs;
+        } catch (IllegalCharsetNameException e) {
+            return fallback;
         }
-        String normalized = name.toUpperCase().replace('_', '-');
-        if ("UTF-8".equals(normalized)) {
+    }
+
+    private static Charset lookup(String charsetName) {
+        if (charsetName == null) {
+            throw new IllegalArgumentException("Null charset name");
+        }
+        checkName(charsetName);
+        if (matches(UTF8, charsetName)) {
             return UTF8;
         }
-        if ("US-ASCII".equals(normalized) || "ASCII".equals(normalized)) {
+        if (matches(ISO88591, charsetName)) {
+            return ISO88591;
+        }
+        if (matches(USASCII, charsetName)) {
             return USASCII;
         }
-        if ("ISO-8859-1".equals(normalized) || "ISO8859-1".equals(normalized)) {
-            return ISO88591;
+        return null;
+    }
+
+    // Charset names are ASCII; equalsIgnoreCase folds them without the
+    // device's locale.
+    private static boolean matches(Charset cs, String charsetName) {
+        if (cs.name.equalsIgnoreCase(charsetName)) {
+            return true;
+        }
+        for (int i = 0; i < cs.aliases.length; i++) {
+            if (cs.aliases[i].equalsIgnoreCase(charsetName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void checkName(String s) {
+        int n = s.length();
+        if (n == 0) {
+            throw new IllegalCharsetNameException(s);
+        }
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            boolean ok = c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9'
+                    || i > 0 && (c == '-' || c == '+' || c == ':' || c == '_' || c == '.');
+            if (!ok) {
+                throw new IllegalCharsetNameException(s);
+            }
         }
-        throw new UnsupportedOperationException("Charset.forName not implemented on this platform: " + name);
     }
 
     private static final class SimpleCharset extends Charset {
-        private SimpleCharset(String canonicalName) {
-            super(canonicalName, new String[0]);
+        private SimpleCharset(String canonicalName, String[] aliases) {
+            super(canonicalName, aliases);
         }
     }
-    
 }
diff --git a/vm/JavaAPI/src/java/nio/charset/IllegalCharsetNameException.java b/vm/JavaAPI/src/java/nio/charset/IllegalCharsetNameException.java
new file mode 100644
index 00000000000..34c7a73e179
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/charset/IllegalCharsetNameException.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package java.nio.charset;
+
+/// Thrown for a string that is not a legal charset name.
+public class IllegalCharsetNameException extends IllegalArgumentException {
+
+    private final String charsetName;
+
+    /// An exception naming `charsetName`.
+    public IllegalCharsetNameException(String charsetName) {
+        super(String.valueOf(charsetName));
+        this.charsetName = charsetName;
+    }
+
+    /// The charset name this exception is about.
+    public String getCharsetName() {
+        return charsetName;
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/charset/UnsupportedCharsetException.java b/vm/JavaAPI/src/java/nio/charset/UnsupportedCharsetException.java
new file mode 100644
index 00000000000..2b0016396df
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/charset/UnsupportedCharsetException.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package java.nio.charset;
+
+/// Thrown for a legal charset name this runtime has no charset for.
+public class UnsupportedCharsetException extends IllegalArgumentException {
+
+    private final String charsetName;
+
+    /// An exception naming `charsetName`.
+    public UnsupportedCharsetException(String charsetName) {
+        super(String.valueOf(charsetName));
+        this.charsetName = charsetName;
+    }
+
+    /// The charset name this exception is about.
+    public String getCharsetName() {
+        return charsetName;
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/AccessDeniedException.java b/vm/JavaAPI/src/java/nio/file/AccessDeniedException.java
new file mode 100644
index 00000000000..4982149cd2c
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/AccessDeniedException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The file system refused the operation.
+public class AccessDeniedException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public AccessDeniedException(String file) {
+        super(file);
+    }
+
+    public AccessDeniedException(String file, String other, String reason) {
+        super(file, other, reason);
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/CopyOption.java b/vm/JavaAPI/src/java/nio/file/CopyOption.java
new file mode 100644
index 00000000000..22912454d71
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/CopyOption.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is
+/// copied or moved. [StandardCopyOption] has the values.
+public interface CopyOption {
+}
diff --git a/vm/JavaAPI/src/java/nio/file/DirectoryIteratorException.java b/vm/JavaAPI/src/java/nio/file/DirectoryIteratorException.java
new file mode 100644
index 00000000000..e78d5f72b8c
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/DirectoryIteratorException.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+
+/// An `IOException` met while iterating a directory, which an iterator
+/// cannot throw as it is.
+public final class DirectoryIteratorException extends RuntimeException {
+    private static final long serialVersionUID = 1L;
+    private final IOException cause;
+
+    public DirectoryIteratorException(IOException cause) {
+        super(text(cause));
+        this.cause = cause;
+    }
+
+    private static String text(IOException cause) {
+        if (cause == null) {
+            throw new NullPointerException();
+        }
+        return cause.toString();
+    }
+
+    @Override
+    public IOException getCause() {
+        return cause;
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/DirectoryNotEmptyException.java b/vm/JavaAPI/src/java/nio/file/DirectoryNotEmptyException.java
new file mode 100644
index 00000000000..de3cc35e360
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/DirectoryNotEmptyException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// A directory that has entries cannot be deleted or replaced.
+public class DirectoryNotEmptyException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public DirectoryNotEmptyException(String file) {
+        super(file);
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/DirectoryStream.java b/vm/JavaAPI/src/java/nio/file/DirectoryStream.java
new file mode 100644
index 00000000000..51353de80d3
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/DirectoryStream.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+
+/// The entries
+/// of a directory, read when the stream was opened. It can be iterated once.
+public interface DirectoryStream<T> extends AutoCloseable, Iterable<T> {
+
+    /// Decides which entries a directory stream answers.
+    interface Filter<T> {
+        boolean accept(T entry) throws IOException;
+    }
+
+    @Override
+    void close() throws IOException;
+}
diff --git a/vm/JavaAPI/src/java/nio/file/FileAlreadyExistsException.java b/vm/JavaAPI/src/java/nio/file/FileAlreadyExistsException.java
new file mode 100644
index 00000000000..9c21b957266
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/FileAlreadyExistsException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// Something is already at the path.
+public class FileAlreadyExistsException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public FileAlreadyExistsException(String file) {
+        super(file);
+    }
+
+    public FileAlreadyExistsException(String file, String other, String reason) {
+        super(file, other, reason);
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/FileSystemException.java b/vm/JavaAPI/src/java/nio/file/FileSystemException.java
new file mode 100644
index 00000000000..d44771bb04a
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/FileSystemException.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+
+/// An operation on a file failed; names the file, the other file of a copy
+/// or move, and the reason.
+public class FileSystemException extends IOException {
+    private static final long serialVersionUID = 1L;
+    private final String file;
+    private final String other;
+    private final String reason;
+
+    public FileSystemException(String file) {
+        this(file, null, null);
+    }
+
+    public FileSystemException(String file, String other, String reason) {
+        super((String) null);
+        this.file = file;
+        this.other = other;
+        this.reason = reason;
+    }
+
+    public String getFile() {
+        return file;
+    }
+
+    public String getOtherFile() {
+        return other;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    @Override
+    public String getMessage() {
+        if (file == null && other == null) {
+            return reason;
+        }
+        StringBuilder sb = new StringBuilder();
+        if (file != null) {
+            sb.append(file);
+        }
+        if (other != null) {
+            sb.append(" -> ").append(other);
+        }
+        if (reason != null) {
+            sb.append(": ").append(reason);
+        }
+        return sb.toString();
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/FileVisitOption.java b/vm/JavaAPI/src/java/nio/file/FileVisitOption.java
new file mode 100644
index 00000000000..ebf4637b044
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/FileVisitOption.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// Accepted
+/// and without effect: symbolic links are never followed.
+public enum FileVisitOption {
+    FOLLOW_LINKS
+}
diff --git a/vm/JavaAPI/src/java/nio/file/FileVisitResult.java b/vm/JavaAPI/src/java/nio/file/FileVisitResult.java
new file mode 100644
index 00000000000..8b575a51b35
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/FileVisitResult.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// What a
+/// [FileVisitor] tells `Files.walkFileTree` to do next.
+public enum FileVisitResult {
+    CONTINUE,
+    TERMINATE,
+    SKIP_SUBTREE,
+    SKIP_SIBLINGS
+}
diff --git a/vm/JavaAPI/src/java/nio/file/FileVisitor.java b/vm/JavaAPI/src/java/nio/file/FileVisitor.java
new file mode 100644
index 00000000000..5ca1e9d5944
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/FileVisitor.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+import java.nio.file.attribute.BasicFileAttributes;
+
+/// What
+/// `Files.walkFileTree` calls for each directory and file it reaches.
+public interface FileVisitor<T> {
+
+    FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs) throws IOException;
+
+    FileVisitResult visitFile(T file, BasicFileAttributes attrs) throws IOException;
+
+    FileVisitResult visitFileFailed(T file, IOException exc) throws IOException;
+
+    FileVisitResult postVisitDirectory(T dir, IOException exc) throws IOException;
+}
diff --git a/vm/JavaAPI/src/java/nio/file/Files.java b/vm/JavaAPI/src/java/nio/file/Files.java
new file mode 100644
index 00000000000..99c2b0bb970
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/Files.java
@@ -0,0 +1,1105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.UncheckedIOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileAttribute;
+import java.nio.file.attribute.FileTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.BiPredicate;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/// Operations on files, directories and their contents, over `java.io.File`
+/// and the file streams, so over the platform's file system as
+/// `com.codename1.impl.JdkHost` provides it.
+///
+/// #### What differs from a desktop file system
+///
+/// - A directory's entries come back sorted by name. The JDK promises no
+///   order, and a device's file systems disagree with each other.
+/// - `newDirectoryStream` reads the entries when it is called, not as the
+///   result is consumed.
+/// - Nothing is a symbolic link, and a `LinkOption` changes nothing.
+/// - The device keeps one time per file. `getLastModifiedTime` answers it,
+///   and so do the creation and access times of [BasicFileAttributes].
+/// - A file is executable when it is a directory, which is all "executable"
+///   can mean where no program can be started.
+/// - A temporary file goes to the caches directory where the device has
+///   one, and to the application's home otherwise. Nothing deletes it.
+/// - Text is UTF-8 unless a `Charset` says otherwise; undecodable bytes are
+///   replaced rather than reported.
+///
+/// #### What is not provided
+///
+/// Channels (`newByteChannel`), POSIX permissions, owners, file stores, hard
+/// and symbolic links, `probeContentType`, `setLastModifiedTime` and the
+/// attribute views by name. A device has no equivalent, and a call to any of
+/// them is a build error.
+///
+/// `lines`, `list`, `walk` and `find` are lazy, as in the JDK: `lines` reads
+/// the file as the stream asks for lines, and `walk` lists a directory only
+/// when it is about to enter it, so `walk(root).limit(1)` lists nothing. A
+/// failure found that late surfaces as an `UncheckedIOException`. Close the
+/// stream `lines` answers (try-with-resources) to close the file.
+public final class Files {
+
+    private static final String LINE = "\n";
+
+    private Files() {
+    }
+
+    private static File file(Path path) {
+        if (path == null) {
+            throw new NullPointerException();
+        }
+        return path.toFile();
+    }
+
+    private static boolean has(Object[] options, Object option) {
+        if (options != null) {
+            for (Object o : options) {
+                if (o == null) {
+                    throw new NullPointerException();
+                }
+                if (o == option) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // ---- what is there ----
+
+    public static boolean exists(Path path, LinkOption... options) {
+        return file(path).exists();
+    }
+
+    public static boolean notExists(Path path, LinkOption... options) {
+        return !file(path).exists();
+    }
+
+    public static boolean isDirectory(Path path, LinkOption... options) {
+        return file(path).isDirectory();
+    }
+
+    public static boolean isRegularFile(Path path, LinkOption... options) {
+        return file(path).isFile();
+    }
+
+    public static boolean isSymbolicLink(Path path) {
+        file(path);
+        return false;
+    }
+
+    public static boolean isReadable(Path path) {
+        return file(path).exists();
+    }
+
+    public static boolean isWritable(Path path) {
+        return file(path).exists();
+    }
+
+    public static boolean isExecutable(Path path) {
+        return file(path).isDirectory();
+    }
+
+    public static boolean isHidden(Path path) throws IOException {
+        return file(path).isHidden();
+    }
+
+    public static boolean isSameFile(Path path, Path path2) throws IOException {
+        if (path.equals(path2)) {
+            return true;
+        }
+        return path.toRealPath().equals(path2.toRealPath());
+    }
+
+    private static File existing(Path path) throws IOException {
+        File f = file(path);
+        if (!f.exists()) {
+            throw new NoSuchFileException(path.toString());
+        }
+        return f;
+    }
+
+    public static long size(Path path) throws IOException {
+        return existing(path).length();
+    }
+
+    public static FileTime getLastModifiedTime(Path path, LinkOption... options) throws IOException {
+        return FileTime.fromMillis(existing(path).lastModified());
+    }
+
+    /// The attributes of `path`. `type` has to be `BasicFileAttributes.class`,
+    /// the one set a device has.
+    @SuppressWarnings("unchecked")
+    public static <A extends BasicFileAttributes> A readAttributes(Path path, Class<A> type, LinkOption... options)
+            throws IOException {
+        if (type != BasicFileAttributes.class) {
+            throw new UnsupportedOperationException("Only BasicFileAttributes can be read on a device");
+        }
+        return (A) attributes(existing(path));
+    }
+
+    private static BasicFileAttributes attributes(File f) {
+        final boolean directory = f.isDirectory();
+        final long size = f.length();
+        final FileTime time = FileTime.fromMillis(f.lastModified());
+        return new BasicFileAttributes() {
+            @Override
+            public FileTime lastModifiedTime() {
+                return time;
+            }
+
+            @Override
+            public FileTime lastAccessTime() {
+                return time;
+            }
+
+            @Override
+            public FileTime creationTime() {
+                return time;
+            }
+
+            @Override
+            public boolean isRegularFile() {
+                return !directory;
+            }
+
+            @Override
+            public boolean isDirectory() {
+                return directory;
+            }
+
+            @Override
+            public boolean isSymbolicLink() {
+                return false;
+            }
+
+            @Override
+            public boolean isOther() {
+                return false;
+            }
+
+            @Override
+            public long size() {
+                return size;
+            }
+
+            @Override
+            public Object fileKey() {
+                return null;
+            }
+        };
+    }
+
+    // ---- streams ----
+
+    public static InputStream newInputStream(Path path, OpenOption... options) throws IOException {
+        if (has(options, StandardOpenOption.WRITE) || has(options, StandardOpenOption.APPEND)) {
+            throw new UnsupportedOperationException("An input stream cannot be opened for writing");
+        }
+        File f = existing(path);
+        if (f.isDirectory()) {
+            throw new IOException(path + ": Is a directory");
+        }
+        return new FileInputStream(f);
+    }
+
+    public static OutputStream newOutputStream(Path path, OpenOption... options) throws IOException {
+        if (has(options, StandardOpenOption.READ)) {
+            throw new IllegalArgumentException("READ not allowed");
+        }
+        boolean none = options == null || options.length == 0;
+        boolean append = has(options, StandardOpenOption.APPEND);
+        if (append && has(options, StandardOpenOption.TRUNCATE_EXISTING)) {
+            throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
+        }
+        File f = file(path);
+        boolean exists = f.exists();
+        if (has(options, StandardOpenOption.CREATE_NEW)) {
+            if (exists) {
+                throw new FileAlreadyExistsException(path.toString());
+            }
+        } else if (!exists && !none && !has(options, StandardOpenOption.CREATE)) {
+            throw new NoSuchFileException(path.toString());
+        }
+        if (f.isDirectory()) {
+            throw new FileSystemException(path.toString(), null, "Is a directory");
+        }
+        File parent = f.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(path.toString());
+        }
+        // Without APPEND or TRUNCATE_EXISTING the JDK overwrites from the
+        // start and leaves a longer file's tail in place. A device stream
+        // replaces the file, so the tail is put back when there is one.
+        byte[] tail = null;
+        if (exists && !none && !append && !has(options, StandardOpenOption.TRUNCATE_EXISTING)) {
+            tail = readAllBytes(path);
+        }
+        // CREATE_NEW claims the path with the exclusive create before opening
+        // it: the check above alone lets two callers both pass and the later
+        // open erase what the first one wrote.
+        if (has(options, StandardOpenOption.CREATE_NEW) && !f.createNewFile()) {
+            throw new FileAlreadyExistsException(path.toString());
+        }
+        OutputStream out = new FileOutputStream(f, append);
+        return tail == null || tail.length == 0 ? out : new Overwrite(out, tail);
+    }
+
+    /// A stream that writes over the start of what a file held and keeps the
+    /// rest: what opening a file with `WRITE` alone means.
+    private static final class Overwrite extends OutputStream {
+        private final OutputStream out;
+        private final byte[] old;
+        private long written;
+        private boolean closed;
+
+        Overwrite(OutputStream out, byte[] old) {
+            this.out = out;
+            this.old = old;
+        }
+
+        @Override
+        public void write(int b) throws IOException {
+            out.write(b);
+            written++;
+        }
+
+        @Override
+        public void write(byte[] b, int off, int len) throws IOException {
+            out.write(b, off, len);
+            written += len;
+        }
+
+        @Override
+        public void flush() throws IOException {
+            out.flush();
+        }
+
+        @Override
+        public void close() throws IOException {
+            if (!closed) {
+                closed = true;
+                if (written < old.length) {
+                    out.write(old, (int) written, old.length - (int) written);
+                }
+                out.close();
+            }
+        }
+    }
+
+    public static BufferedReader newBufferedReader(Path path, Charset cs) throws IOException {
+        return new BufferedReader(new InputStreamReader(newInputStream(path), cs.name()));
+    }
+
+    public static BufferedReader newBufferedReader(Path path) throws IOException {
+        return newBufferedReader(path, StandardCharsets.UTF_8);
+    }
+
+    public static BufferedWriter newBufferedWriter(Path path, Charset cs, OpenOption... options) throws IOException {
+        return new BufferedWriter(new OutputStreamWriter(newOutputStream(path, options), cs.name()));
+    }
+
+    public static BufferedWriter newBufferedWriter(Path path, OpenOption... options) throws IOException {
+        return newBufferedWriter(path, StandardCharsets.UTF_8, options);
+    }
+
+    // ---- reading ----
+
+    public static byte[] readAllBytes(Path path) throws IOException {
+        InputStream in = newInputStream(path);
+        try {
+            // Read here rather than by InputStream.readAllBytes, which a Java 8
+            // class library lacks: the differential tests run this class over
+            // the JDK's own streams.
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            byte[] buf = new byte[8192];
+            int n;
+            while ((n = in.read(buf, 0, buf.length)) > 0) {
+                out.write(buf, 0, n);
+            }
+            return out.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    public static String readString(Path path) throws IOException {
+        return readString(path, StandardCharsets.UTF_8);
+    }
+
+    public static String readString(Path path, Charset cs) throws IOException {
+        return new String(readAllBytes(path), cs.name());
+    }
+
+    public static List<String> readAllLines(Path path) throws IOException {
+        return readAllLines(path, StandardCharsets.UTF_8);
+    }
+
+    /// The lines of the file. A line ends at `\n`, `\r` or `\r\n`, and a
+    /// file that ends with a terminator has no empty last line.
+    public static List<String> readAllLines(Path path, Charset cs) throws IOException {
+        String text = readString(path, cs);
+        List<String> lines = new ArrayList<String>();
+        int n = text.length();
+        int start = 0;
+        for (int i = 0; i < n; i++) {
+            char c = text.charAt(i);
+            if (c == '\n' || c == '\r') {
+                lines.add(text.substring(start, i));
+                if (c == '\r' && i + 1 < n && text.charAt(i + 1) == '\n') {
+                    i++;
+                }
+                start = i + 1;
+            }
+        }
+        if (start < n) {
+            lines.add(text.substring(start));
+        }
+        return lines;
+    }
+
+    // ---- writing ----
+
+    public static Path write(Path path, byte[] bytes, OpenOption... options) throws IOException {
+        if (bytes == null) {
+            throw new NullPointerException();
+        }
+        OutputStream out = newOutputStream(path, options);
+        try {
+            out.write(bytes, 0, bytes.length);
+        } finally {
+            out.close();
+        }
+        return path;
+    }
+
+    public static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)
+            throws IOException {
+        if (lines == null) {
+            throw new NullPointerException();
+        }
+        StringBuilder sb = new StringBuilder();
+        for (CharSequence line : lines) {
+            sb.append(line.toString()).append(LINE);
+        }
+        return write(path, sb.toString().getBytes(cs.name()), options);
+    }
+
+    public static Path write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options)
+            throws IOException {
+        return write(path, lines, StandardCharsets.UTF_8, options);
+    }
+
+    public static Path writeString(Path path, CharSequence csq, OpenOption... options) throws IOException {
+        return writeString(path, csq, StandardCharsets.UTF_8, options);
+    }
+
+    public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOption... options)
+            throws IOException {
+        if (csq == null) {
+            throw new NullPointerException();
+        }
+        return write(path, csq.toString().getBytes(cs.name()), options);
+    }
+
+    // ---- creating and deleting ----
+
+    public static Path createFile(Path path, FileAttribute<?>... attrs) throws IOException {
+        File f = file(path);
+        if (f.exists()) {
+            throw new FileAlreadyExistsException(path.toString());
+        }
+        File parent = f.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(path.toString());
+        }
+        // Claimed with the exclusive create, so of two callers racing for
+        // the path exactly one succeeds and nothing is truncated.
+        if (!f.createNewFile()) {
+            throw new FileAlreadyExistsException(path.toString());
+        }
+        return path;
+    }
+
+    public static Path createDirectory(Path dir, FileAttribute<?>... attrs) throws IOException {
+        File f = file(dir);
+        if (f.exists()) {
+            throw new FileAlreadyExistsException(dir.toString());
+        }
+        File parent = f.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(dir.toString());
+        }
+        if (!f.mkdir()) {
+            // mkdir is the atomic claim: a caller that lost the race for the
+            // name is told so, as createFile tells it.
+            if (f.exists()) {
+                throw new FileAlreadyExistsException(dir.toString());
+            }
+            throw new IOException("Could not create the directory " + dir);
+        }
+        return dir;
+    }
+
+    public static Path createDirectories(Path dir, FileAttribute<?>... attrs) throws IOException {
+        File f = file(dir);
+        if (f.isDirectory()) {
+            return dir;
+        }
+        if (f.exists()) {
+            throw new FileAlreadyExistsException(dir.toString());
+        }
+        f.mkdirs();
+        if (!f.isDirectory()) {
+            throw new IOException("Could not create the directory " + dir);
+        }
+        return dir;
+    }
+
+    private static Path temporaryDirectory() {
+        JdkHost h = JdkHost.get();
+        String caches = h.cachesDir();
+        return PathImpl.of(caches != null ? caches : h.appHome());
+    }
+
+    private static Path temporary(Path dir, String prefix, String suffix, boolean directory) throws IOException {
+        Path parent = dir == null ? temporaryDirectory() : dir;
+        String p = prefix == null ? "" : prefix;
+        long n = System.currentTimeMillis();
+        while (true) {
+            Path candidate = parent.resolve(p + n + suffix);
+            if (!file(candidate).exists()) {
+                // Another caller can claim the same name between the check and
+                // the create; the create is exclusive, so the loser moves on.
+                try {
+                    return directory ? createDirectory(candidate) : createFile(candidate);
+                } catch (FileAlreadyExistsException e) {
+                    // Taken meanwhile: try the next name.
+                }
+            }
+            n++;
+        }
+    }
+
+    public static Path createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>... attrs)
+            throws IOException {
+        if (dir == null) {
+            throw new NullPointerException();
+        }
+        return temporary(dir, prefix, suffix == null ? ".tmp" : suffix, false);
+    }
+
+    public static Path createTempFile(String prefix, String suffix, FileAttribute<?>... attrs) throws IOException {
+        return temporary(null, prefix, suffix == null ? ".tmp" : suffix, false);
+    }
+
+    public static Path createTempDirectory(Path dir, String prefix, FileAttribute<?>... attrs) throws IOException {
+        if (dir == null) {
+            throw new NullPointerException();
+        }
+        return temporary(dir, prefix, "", true);
+    }
+
+    public static Path createTempDirectory(String prefix, FileAttribute<?>... attrs) throws IOException {
+        return temporary(null, prefix, "", true);
+    }
+
+    public static void delete(Path path) throws IOException {
+        File f = existing(path);
+        if (f.isDirectory()) {
+            String[] entries = f.list();
+            if (entries != null && entries.length > 0) {
+                throw new DirectoryNotEmptyException(path.toString());
+            }
+        }
+        if (!f.delete()) {
+            throw new IOException("Could not delete " + path);
+        }
+    }
+
+    public static boolean deleteIfExists(Path path) throws IOException {
+        if (!file(path).exists()) {
+            return false;
+        }
+        delete(path);
+        return true;
+    }
+
+    // ---- copying and moving ----
+
+    /// Clears the way for a copy or a move to `target`, or says why not.
+    private static void replace(Path target, CopyOption[] options) throws IOException {
+        if (file(target).exists()) {
+            if (!has(options, StandardCopyOption.REPLACE_EXISTING)) {
+                throw new FileAlreadyExistsException(target.toString());
+            }
+            delete(target);
+        }
+    }
+
+    private static void transfer(File from, File to) throws IOException {
+        InputStream in = new FileInputStream(from);
+        try {
+            OutputStream out = new FileOutputStream(to, false);
+            try {
+                pump(in, out);
+            } finally {
+                out.close();
+            }
+        } finally {
+            in.close();
+        }
+    }
+
+    private static long pump(InputStream in, OutputStream out) throws IOException {
+        byte[] buffer = new byte[8192];
+        long total = 0;
+        int n;
+        while ((n = in.read(buffer, 0, buffer.length)) >= 0) {
+            out.write(buffer, 0, n);
+            total += n;
+        }
+        return total;
+    }
+
+    /// Copies a file, or creates an empty directory where `source` is one:
+    /// a directory's entries are not copied, as in the JDK.
+    public static Path copy(Path source, Path target, CopyOption... options) throws IOException {
+        File from = existing(source);
+        if (file(target).exists() && isSameFile(source, target)) {
+            return target;
+        }
+        replace(target, options);
+        if (from.isDirectory()) {
+            createDirectory(target);
+        } else {
+            File to = file(target);
+            File parent = to.getParentFile();
+            if (parent != null && !parent.isDirectory()) {
+                throw new NoSuchFileException(target.toString());
+            }
+            transfer(from, to);
+        }
+        return target;
+    }
+
+    public static long copy(InputStream in, Path target, CopyOption... options) throws IOException {
+        if (in == null) {
+            throw new NullPointerException();
+        }
+        replace(target, options);
+        OutputStream out = newOutputStream(target, StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);
+        try {
+            return pump(in, out);
+        } finally {
+            out.close();
+        }
+    }
+
+    public static long copy(Path source, OutputStream out) throws IOException {
+        if (out == null) {
+            throw new NullPointerException();
+        }
+        InputStream in = newInputStream(source);
+        try {
+            return pump(in, out);
+        } finally {
+            in.close();
+        }
+    }
+
+    private static void copyTree(File from, File to) throws IOException {
+        if (from.isDirectory()) {
+            if (!to.mkdir()) {
+                throw new IOException("Could not create the directory " + to.getPath());
+            }
+            String[] names = from.list();
+            if (names != null) {
+                for (String name : names) {
+                    copyTree(new File(from, name), new File(to, name));
+                }
+            }
+        } else {
+            transfer(from, to);
+        }
+    }
+
+    /// Deletes what a move has copied. An entry that will not go is an
+    /// error: answering normally would report a move that left the source,
+    /// or half of it, where it was.
+    private static void deleteTree(File f) throws IOException {
+        if (f.isDirectory()) {
+            String[] names = f.list();
+            if (names != null) {
+                for (String name : names) {
+                    deleteTree(new File(f, name));
+                }
+            }
+        }
+        if (!f.delete() && f.exists()) {
+            throw new IOException("Moved " + f.getPath() + " but could not delete the original");
+        }
+    }
+
+    /// Moves a file or a directory with everything in it. Where the device
+    /// cannot rename in place the tree is copied and the original deleted.
+    public static Path move(Path source, Path target, CopyOption... options) throws IOException {
+        File from = existing(source);
+        if (file(target).exists() && isSameFile(source, target)) {
+            return target;
+        }
+        replace(target, options);
+        File to = file(target);
+        File parent = to.getParentFile();
+        if (parent != null && !parent.isDirectory()) {
+            throw new NoSuchFileException(target.toString());
+        }
+        if (!from.renameTo(to)) {
+            // No copy fallback for a regular file: File.renameTo already is
+            // one -- outside its directory it copies the bytes and deletes
+            // the original -- so a rename that failed is a copy or a delete
+            // that failed, and trying the same again would fail the same way.
+            if (!from.isDirectory()) {
+                throw new IOException("Could not move " + source + " to " + target);
+            }
+            // The copy fallback must not run when the source cannot leave its
+            // directory: the JDK's rename fails there and touches nothing,
+            // while copying first left a full copy at the target and emptied
+            // the source of every entry that could be deleted.
+            File fromParent = from.getAbsoluteFile().getParentFile();
+            if (fromParent != null && !fromParent.canWrite()) {
+                throw new AccessDeniedException(source.toString());
+            }
+            copyTree(from, to);
+            try {
+                deleteTree(from);
+            } catch (IOException e) {
+                // Undo the copy, so a failed move leaves no second tree.
+                try {
+                    deleteTree(to);
+                } catch (IOException ignored) {
+                    // The original error is the one to report.
+                }
+                throw e;
+            }
+        }
+        return target;
+    }
+
+    /// The position of the first byte two files differ in, or -1 when they
+    /// hold the same bytes. Both are read a block at a time, as the JDK
+    /// reads them, so two large files that differ early are not loaded
+    /// whole, and a file larger than an array can be compared at all.
+    public static long mismatch(Path path, Path path2) throws IOException {
+        if (isSameFile(path, path2)) {
+            return -1L;
+        }
+        InputStream a = newInputStream(path);
+        try {
+            InputStream b = newInputStream(path2);
+            try {
+                byte[] bufA = new byte[8192];
+                byte[] bufB = new byte[8192];
+                long at = 0;
+                while (true) {
+                    int na = fill(a, bufA);
+                    int nb = fill(b, bufB);
+                    int n = Math.min(na, nb);
+                    for (int i = 0; i < n; i++) {
+                        if (bufA[i] != bufB[i]) {
+                            return at + i;
+                        }
+                    }
+                    if (na != nb) {
+                        return at + n;
+                    }
+                    if (na < bufA.length) {
+                        return -1L;
+                    }
+                    at += n;
+                }
+            } finally {
+                b.close();
+            }
+        } finally {
+            a.close();
+        }
+    }
+
+    /// Reads into `buf` until it is full or the stream ends; how many bytes
+    /// were read. A stream may answer fewer than asked before its end.
+    private static int fill(InputStream in, byte[] buf) throws IOException {
+        int total = 0;
+        while (total < buf.length) {
+            int n = in.read(buf, total, buf.length - total);
+            if (n < 0) {
+                break;
+            }
+            total += n;
+        }
+        return total;
+    }
+
+    // ---- directories ----
+
+    private static List<Path> entries(Path dir) throws IOException {
+        File f = existing(dir);
+        if (!f.isDirectory()) {
+            throw new NotDirectoryException(dir.toString());
+        }
+        String[] names = f.list();
+        List<Path> out = new ArrayList<Path>();
+        if (names != null) {
+            Arrays.sort(names);
+            for (String name : names) {
+                out.add(dir.resolve(name));
+            }
+        }
+        return out;
+    }
+
+    /// The lines of `path` as UTF-8. See [#lines(Path, Charset)].
+    public static Stream<String> lines(Path path) throws IOException {
+        return lines(path, StandardCharsets.UTF_8);
+    }
+
+    /// The lines of `path`, read as the stream asks for them: `findFirst`
+    /// reads the start of a large file, not all of it. The file is opened
+    /// here, so a missing one throws now, and closing the stream closes it.
+    public static Stream<String> lines(Path path, Charset cs) throws IOException {
+        BufferedReader reader = newBufferedReader(path, cs);
+        return reader.lines().onClose(new CloseReader(reader));
+    }
+
+    /// The entries of `dir`, sorted by name.
+    public static Stream<Path> list(Path dir) throws IOException {
+        return lazy(entries(dir).iterator());
+    }
+
+    /// The paths under `start`, `start` first, depth first, to `maxDepth`
+    /// levels below it.
+    public static Stream<Path> walk(Path start, int maxDepth, FileVisitOption... options) throws IOException {
+        if (maxDepth < 0) {
+            throw new IllegalArgumentException("'maxDepth' is negative");
+        }
+        existing(start);
+        return lazy(new Walker(start, maxDepth));
+    }
+
+    /// The paths under `start`, at every depth. See
+    /// [#walk(Path, int, FileVisitOption...)].
+    public static Stream<Path> walk(Path start, FileVisitOption... options) throws IOException {
+        return walk(start, Integer.MAX_VALUE, options);
+    }
+
+    /// The paths [#walk(Path, int, FileVisitOption...)] would answer for
+    /// which `matcher` holds, given each path's attributes.
+    public static Stream<Path> find(Path start, int maxDepth, BiPredicate<Path, BasicFileAttributes> matcher,
+                                    FileVisitOption... options) throws IOException {
+        if (maxDepth < 0) {
+            throw new IllegalArgumentException("'maxDepth' is negative");
+        }
+        if (matcher == null) {
+            throw new NullPointerException();
+        }
+        existing(start);
+        return lazy(new Finder(new Walker(start, maxDepth), matcher));
+    }
+
+    private static <T> Stream<T> lazy(Iterator<T> it) {
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it,
+                Spliterator.ORDERED | Spliterator.NONNULL), false);
+    }
+
+    private static final class CloseReader implements Runnable {
+        private final BufferedReader reader;
+
+        CloseReader(BufferedReader reader) {
+            this.reader = reader;
+        }
+
+        @Override
+        public void run() {
+            try {
+                reader.close();
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+    }
+
+    /// Depth first, discovering as it goes: a directory is listed when the
+    /// walk advances past it, never before, and a failure to list it
+    /// surfaces then.
+    private static final class Walker implements Iterator<Path> {
+        /// The entries still to visit, one iterator per open directory.
+        private final List<Iterator<Path>> levels = new ArrayList<Iterator<Path>>();
+        private final int maxDepth;
+        private Path pending;
+        private int pendingDepth;
+        /// The path answered last, entered on the next advance if it is a
+        /// directory within the depth limit.
+        private Path last;
+        private int lastDepth;
+
+        Walker(Path start, int maxDepth) {
+            this.maxDepth = maxDepth;
+            this.pending = start;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (pending != null) {
+                return true;
+            }
+            if (last != null && lastDepth < maxDepth && file(last).isDirectory()) {
+                try {
+                    levels.add(entries(last).iterator());
+                } catch (IOException e) {
+                    throw new UncheckedIOException(e);
+                }
+            }
+            last = null;
+            while (!levels.isEmpty()) {
+                Iterator<Path> top = levels.get(levels.size() - 1);
+                if (top.hasNext()) {
+                    pending = top.next();
+                    pendingDepth = levels.size();
+                    return true;
+                }
+                levels.remove(levels.size() - 1);
+            }
+            return false;
+        }
+
+        @Override
+        public Path next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            Path p = pending;
+            pending = null;
+            last = p;
+            lastDepth = pendingDepth;
+            return p;
+        }
+    }
+
+    private static final class Finder implements Iterator<Path> {
+        private final Iterator<Path> all;
+        private final BiPredicate<Path, BasicFileAttributes> matcher;
+        private Path next;
+
+        Finder(Iterator<Path> all, BiPredicate<Path, BasicFileAttributes> matcher) {
+            this.all = all;
+            this.matcher = matcher;
+        }
+
+        @Override
+        public boolean hasNext() {
+            while (next == null && all.hasNext()) {
+                Path p = all.next();
+                if (matcher.test(p, attributes(file(p)))) {
+                    next = p;
+                }
+            }
+            return next != null;
+        }
+
+        @Override
+        public Path next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            Path p = next;
+            next = null;
+            return p;
+        }
+    }
+
+    public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor) throws IOException {
+        return walkFileTree(start, null, Integer.MAX_VALUE, visitor);
+    }
+
+    public static Path walkFileTree(Path start, Set<FileVisitOption> options, int maxDepth,
+                                    FileVisitor<? super Path> visitor) throws IOException {
+        if (maxDepth < 0) {
+            throw new IllegalArgumentException("'maxDepth' is negative");
+        }
+        if (visitor == null) {
+            throw new NullPointerException();
+        }
+        visit(start, 0, maxDepth, visitor);
+        return start;
+    }
+
+    private static FileVisitResult checked(FileVisitResult result) {
+        if (result == null) {
+            throw new NullPointerException();
+        }
+        return result;
+    }
+
+    /// Visits `path` and what is under it. Answers `TERMINATE` to stop the
+    /// walk, `SKIP_SIBLINGS` to stop the directory it is an entry of, and
+    /// `CONTINUE` otherwise.
+    private static FileVisitResult visit(Path path, int depth, int maxDepth, FileVisitor<? super Path> visitor)
+            throws IOException {
+        File f = file(path);
+        if (!f.exists()) {
+            return checked(visitor.visitFileFailed(path, new NoSuchFileException(path.toString())));
+        }
+        BasicFileAttributes attrs = attributes(f);
+        if (!attrs.isDirectory() || depth >= maxDepth) {
+            return checked(visitor.visitFile(path, attrs));
+        }
+        FileVisitResult pre = checked(visitor.preVisitDirectory(path, attrs));
+        if (pre == FileVisitResult.SKIP_SUBTREE) {
+            return FileVisitResult.CONTINUE;
+        }
+        if (pre != FileVisitResult.CONTINUE) {
+            return pre;
+        }
+        for (Path entry : entries(path)) {
+            FileVisitResult result = visit(entry, depth + 1, maxDepth, visitor);
+            if (result == FileVisitResult.TERMINATE) {
+                return result;
+            }
+            if (result == FileVisitResult.SKIP_SIBLINGS) {
+                break;
+            }
+        }
+        FileVisitResult post = checked(visitor.postVisitDirectory(path, null));
+        return post == FileVisitResult.SKIP_SUBTREE ? FileVisitResult.CONTINUE : post;
+    }
+
+    public static DirectoryStream<Path> newDirectoryStream(Path dir) throws IOException {
+        return new Listing(entries(dir));
+    }
+
+    public static DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)
+            throws IOException {
+        if (filter == null) {
+            throw new NullPointerException();
+        }
+        List<Path> out = new ArrayList<Path>();
+        for (Path entry : entries(dir)) {
+            if (filter.accept(entry)) {
+                out.add(entry);
+            }
+        }
+        return new Listing(out);
+    }
+
+    /// The entries of `dir` whose names match `glob`: `*` and `?` for any
+    /// characters and any one, `[a-c]` and `[!a-c]` for a set of them,
+    /// `{one,two}` for alternatives, and a backslash to take the next
+    /// character literally.
+    public static DirectoryStream<Path> newDirectoryStream(Path dir, String glob) throws IOException {
+        if (glob == null) {
+            throw new NullPointerException();
+        }
+        List<Path> out = new ArrayList<Path>();
+        for (Path entry : entries(dir)) {
+            String name = entry.getFileName().toString();
+            if (Glob.matches(glob, 0, glob.length(), name, 0)) {
+                out.add(entry);
+            }
+        }
+        return new Listing(out);
+    }
+
+    private static final class Listing implements DirectoryStream<Path> {
+        private final List<Path> entries;
+        private boolean iterated;
+        private boolean closed;
+
+        Listing(List<Path> entries) {
+            this.entries = entries;
+        }
+
+        @Override
+        public Iterator<Path> iterator() {
+            if (closed) {
+                throw new IllegalStateException("Directory stream is closed");
+            }
+            if (iterated) {
+                throw new IllegalStateException("Iterator already obtained");
+            }
+            iterated = true;
+            final Iterator<Path> it = entries.iterator();
+            return new Iterator<Path>() {
+                @Override
+                public boolean hasNext() {
+                    return !closed && it.hasNext();
+                }
+
+                @Override
+                public Path next() {
+                    if (closed) {
+                        throw new NoSuchElementException();
+                    }
+                    return it.next();
+                }
+
+                @Override
+                public void remove() {
+                    throw new UnsupportedOperationException();
+                }
+            };
+        }
+
+        @Override
+        public void close() {
+            closed = true;
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/Glob.java b/vm/JavaAPI/src/java/nio/file/Glob.java
new file mode 100644
index 00000000000..33b36151901
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/Glob.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The glob syntax of `Files.newDirectoryStream(dir, glob)`, matched against
+/// one file name.
+final class Glob {
+
+    private Glob() {
+    }
+
+    /// Whether `name` from `ni` on matches `glob` between `gi` and `gEnd`.
+    static boolean matches(String glob, int gi, int gEnd, String name, int ni) {
+        int n = name.length();
+        while (gi < gEnd) {
+            char g = glob.charAt(gi);
+            if (g == '*') {
+                while (gi < gEnd && glob.charAt(gi) == '*') {
+                    gi++;
+                }
+                if (gi == gEnd) {
+                    return true;
+                }
+                for (int k = ni; k <= n; k++) {
+                    if (matches(glob, gi, gEnd, name, k)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            if (g == '{') {
+                int close = closing(glob, gi, gEnd);
+                if (close < 0) {
+                    throw new IllegalArgumentException("Missing '}' in glob: " + glob);
+                }
+                String rest = glob.substring(close + 1, gEnd);
+                int start = gi + 1;
+                for (int i = start; i <= close; i++) {
+                    char c = glob.charAt(i);
+                    if (c == '\\') {
+                        i++;
+                    } else if (c == ',' || i == close) {
+                        String alternative = glob.substring(start, i) + rest;
+                        if (matches(alternative, 0, alternative.length(), name, ni)) {
+                            return true;
+                        }
+                        start = i + 1;
+                    }
+                }
+                return false;
+            }
+            if (ni >= n) {
+                return false;
+            }
+            char c = name.charAt(ni);
+            if (g == '?') {
+                gi++;
+            } else if (g == '[') {
+                int close = gi + 1;
+                boolean negate = close < gEnd && glob.charAt(close) == '!';
+                if (negate) {
+                    close++;
+                }
+                int first = close;
+                boolean found = false;
+                while (close < gEnd && (glob.charAt(close) != ']' || close == first)) {
+                    char lo = glob.charAt(close);
+                    char hi = lo;
+                    if (close + 2 < gEnd && glob.charAt(close + 1) == '-' && glob.charAt(close + 2) != ']') {
+                        hi = glob.charAt(close + 2);
+                        close += 2;
+                    }
+                    found = found || (c >= lo && c <= hi);
+                    close++;
+                }
+                if (close >= gEnd) {
+                    throw new IllegalArgumentException("Missing ']' in glob: " + glob);
+                }
+                if (found == negate) {
+                    return false;
+                }
+                gi = close + 1;
+            } else {
+                if (g == '\\') {
+                    gi++;
+                    if (gi >= gEnd) {
+                        throw new IllegalArgumentException("No character to escape in glob: " + glob);
+                    }
+                    g = glob.charAt(gi);
+                }
+                if (g != c) {
+                    return false;
+                }
+                gi++;
+            }
+            ni++;
+        }
+        return ni == n;
+    }
+
+    private static int closing(String glob, int open, int end) {
+        for (int i = open + 1; i < end; i++) {
+            char c = glob.charAt(i);
+            if (c == '\\') {
+                i++;
+            } else if (c == '}') {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/InvalidPathException.java b/vm/JavaAPI/src/java/nio/file/InvalidPathException.java
new file mode 100644
index 00000000000..b2f91cbc64c
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/InvalidPathException.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// A string that cannot be made a path.
+public class InvalidPathException extends IllegalArgumentException {
+    private static final long serialVersionUID = 1L;
+    private final String input;
+    private final String reason;
+    private final int index;
+
+    public InvalidPathException(String input, String reason, int index) {
+        super(reason);
+        if (input == null || reason == null) {
+            throw new NullPointerException();
+        }
+        if (index < -1) {
+            throw new IllegalArgumentException();
+        }
+        this.input = input;
+        this.reason = reason;
+        this.index = index;
+    }
+
+    public InvalidPathException(String input, String reason) {
+        this(input, reason, -1);
+    }
+
+    public String getInput() {
+        return input;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    @Override
+    public String getMessage() {
+        StringBuilder sb = new StringBuilder(reason);
+        if (index > -1) {
+            sb.append(" at index ").append(index);
+        }
+        return sb.append(": ").append(input).toString();
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/LinkOption.java b/vm/JavaAPI/src/java/nio/file/LinkOption.java
new file mode 100644
index 00000000000..b3e7d920389
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/LinkOption.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The device's
+/// file system is not asked about symbolic links, so the option is accepted
+/// wherever the JDK takes it and changes nothing.
+public enum LinkOption implements OpenOption, CopyOption {
+    NOFOLLOW_LINKS
+}
diff --git a/vm/JavaAPI/src/java/nio/file/NoSuchFileException.java b/vm/JavaAPI/src/java/nio/file/NoSuchFileException.java
new file mode 100644
index 00000000000..30cdb47343f
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/NoSuchFileException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// Nothing is at the path.
+public class NoSuchFileException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public NoSuchFileException(String file) {
+        super(file);
+    }
+
+    public NoSuchFileException(String file, String other, String reason) {
+        super(file, other, reason);
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/NotDirectoryException.java b/vm/JavaAPI/src/java/nio/file/NotDirectoryException.java
new file mode 100644
index 00000000000..cead4086d50
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/NotDirectoryException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// The path is not a directory.
+public class NotDirectoryException extends FileSystemException {
+    private static final long serialVersionUID = 1L;
+
+    public NotDirectoryException(String file) {
+        super(file);
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/OpenOption.java b/vm/JavaAPI/src/java/nio/file/OpenOption.java
new file mode 100644
index 00000000000..02550233ff4
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/OpenOption.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is
+/// opened. [StandardOpenOption] has the values.
+public interface OpenOption {
+}
diff --git a/vm/JavaAPI/src/java/nio/file/Path.java b/vm/JavaAPI/src/java/nio/file/Path.java
new file mode 100644
index 00000000000..db53f9b0d1b
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/Path.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Iterator;
+
+/// A path in the platform's file system, the one `java.io.File` reaches.
+///
+/// #### What a path is here
+///
+/// A sequence of names separated by `/`, after an optional root. A backslash
+/// is read as a separator. The root is `/`, or -- because Codename One names
+/// its files `file:///...` and `java.io.File.getAbsolutePath()` answers that
+/// form -- the `file:` scheme with the slashes after it. A relative path is
+/// resolved against the application's home directory when it is used, which
+/// is also what [#toAbsolutePath()] answers.
+///
+/// The methods that only rearrange names (`resolve`, `relativize`,
+/// `normalize`, `getParent`, `startsWith`, ...) answer what the JDK answers
+/// on a Unix file system.
+///
+/// #### What is not provided
+///
+/// `getFileSystem()` and `register(...)`: there is one file system and it
+/// cannot be watched. [#toRealPath] is `File.getCanonicalPath()`: where the
+/// file system cannot resolve symbolic links it answers the absolute path
+/// with `.` and `..` resolved.
+public interface Path extends Comparable<Path>, Iterable<Path> {
+
+    /// The path `first`, with each of `more` appended as further names.
+    static Path of(String first, String... more) {
+        return PathImpl.of(first, more);
+    }
+
+    /// The path a `file:` URI names.
+    static Path of(URI uri) {
+        return PathImpl.of(uri);
+    }
+
+    boolean isAbsolute();
+
+    Path getRoot();
+
+    Path getFileName();
+
+    Path getParent();
+
+    int getNameCount();
+
+    Path getName(int index);
+
+    Path subpath(int beginIndex, int endIndex);
+
+    boolean startsWith(Path other);
+
+    boolean startsWith(String other);
+
+    boolean endsWith(Path other);
+
+    boolean endsWith(String other);
+
+    Path normalize();
+
+    Path resolve(Path other);
+
+    Path resolve(String other);
+
+    Path resolveSibling(Path other);
+
+    Path resolveSibling(String other);
+
+    Path relativize(Path other);
+
+    URI toUri();
+
+    Path toAbsolutePath();
+
+    /// The absolute path with `.` and `..` resolved, and symbolic links where
+    /// the file system can. Throws [NoSuchFileException] when nothing is there.
+    Path toRealPath(LinkOption... options) throws IOException;
+
+    File toFile();
+
+    @Override
+    Iterator<Path> iterator();
+
+    @Override
+    int compareTo(Path other);
+}
diff --git a/vm/JavaAPI/src/java/nio/file/PathImpl.java b/vm/JavaAPI/src/java/nio/file/PathImpl.java
new file mode 100644
index 00000000000..d229c310493
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/PathImpl.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/// The one implementation of [Path]: a normalized path string, split into a
+/// root and names when a method needs them.
+final class PathImpl implements Path {
+
+    private static final String[] NO_NAMES = new String[0];
+    private static final String SCHEME = "file:";
+
+    /// Separators collapsed, no trailing separator unless the path is a root.
+    private final String path;
+    private final int rootLength;
+    private String[] names;
+
+    private PathImpl(String path) {
+        this.path = path;
+        this.rootLength = rootLength(path);
+    }
+
+    static PathImpl of(String first, String[] more) {
+        if (first == null) {
+            throw new NullPointerException();
+        }
+        String joined = first;
+        if (more != null && more.length > 0) {
+            StringBuilder sb = new StringBuilder(first);
+            for (String m : more) {
+                if (m == null) {
+                    throw new NullPointerException();
+                }
+                if (m.length() > 0) {
+                    if (sb.length() > 0) {
+                        sb.append('/');
+                    }
+                    sb.append(m);
+                }
+            }
+            joined = sb.toString();
+        }
+        if (joined.indexOf('\0') >= 0) {
+            throw new InvalidPathException(joined, "Nul character not allowed");
+        }
+        return new PathImpl(clean(joined));
+    }
+
+    static PathImpl of(String path) {
+        return of(path, null);
+    }
+
+    static PathImpl of(URI uri) {
+        String scheme = uri.getScheme();
+        if (scheme == null || !"file".equalsIgnoreCase(scheme)) {
+            throw new IllegalArgumentException("URI scheme is not \"file\"");
+        }
+        // Only what names a file on this device is a path, as in the JDK:
+        // a host, a query or a fragment is not dropped, it is refused, so
+        // that file://server/share/x does not quietly become /share/x.
+        if (uri.isOpaque()) {
+            throw new IllegalArgumentException("URI is not hierarchical");
+        }
+        if (present(uri.getRawAuthority())) {
+            throw new IllegalArgumentException("URI has an authority component");
+        }
+        if (present(uri.getRawFragment())) {
+            throw new IllegalArgumentException("URI has a fragment component");
+        }
+        if (present(uri.getRawQuery())) {
+            throw new IllegalArgumentException("URI has a query component");
+        }
+        String p = uri.getPath();
+        if (p == null || p.length() == 0) {
+            throw new IllegalArgumentException("URI has no path component");
+        }
+        return of(p);
+    }
+
+    /// Whether a URI has the component. An empty one counts as none: the
+    /// device's `URI` answers an empty authority for `file:///x`, where the
+    /// JDK's answers null.
+    private static boolean present(String component) {
+        return component != null && component.length() > 0;
+    }
+
+    /// How many leading characters are the root: one for `/`, the scheme and
+    /// its slashes for a `file:` path, none for a relative path.
+    private static int rootLength(String p) {
+        if (p.startsWith(SCHEME)) {
+            int i = SCHEME.length();
+            while (i < p.length() && p.charAt(i) == '/') {
+                i++;
+            }
+            return i;
+        }
+        return p.startsWith("/") ? 1 : 0;
+    }
+
+    /// Collapses runs of separators and drops a trailing one, leaving the
+    /// slashes of a `file:` root as they were written.
+    private static String clean(String p) {
+        int root = 0;
+        StringBuilder sb = new StringBuilder(p.length());
+        if (p.startsWith(SCHEME)) {
+            root = rootLength(p);
+            sb.append(p.substring(0, root));
+        }
+        boolean separator = false;
+        for (int i = root; i < p.length(); i++) {
+            char c = p.charAt(i);
+            if (c == '\\') {
+                c = '/';
+            }
+            if (c == '/') {
+                if (sb.length() == 0) {
+                    sb.append('/');
+                    root = 1;
+                } else {
+                    separator = sb.length() > root;
+                }
+                continue;
+            }
+            if (separator) {
+                sb.append('/');
+                separator = false;
+            }
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    private String[] names() {
+        if (names == null) {
+            if (path.length() == rootLength) {
+                // The empty path is one empty name; a root has none.
+                names = rootLength == 0 ? new String[] {""} : NO_NAMES;
+            } else {
+                List<String> out = new ArrayList<String>();
+                int start = rootLength;
+                for (int i = rootLength; i <= path.length(); i++) {
+                    if (i == path.length() || path.charAt(i) == '/') {
+                        out.add(path.substring(start, i));
+                        start = i + 1;
+                    }
+                }
+                names = out.toArray(new String[out.size()]);
+            }
+        }
+        return names;
+    }
+
+    private boolean isEmpty() {
+        return path.length() == 0;
+    }
+
+    private String root() {
+        return path.substring(0, rootLength);
+    }
+
+    private static PathImpl build(String root, String[] names, int from, int to) {
+        StringBuilder sb = new StringBuilder(root);
+        for (int i = from; i < to; i++) {
+            if (i > from) {
+                sb.append('/');
+            }
+            sb.append(names[i]);
+        }
+        return new PathImpl(sb.toString());
+    }
+
+    private static PathImpl impl(Path other) {
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        if (other instanceof PathImpl) {
+            return (PathImpl) other;
+        }
+        return of(other.toString());
+    }
+
+    @Override
+    public boolean isAbsolute() {
+        return rootLength > 0;
+    }
+
+    @Override
+    public Path getRoot() {
+        return rootLength == 0 ? null : new PathImpl(root());
+    }
+
+    @Override
+    public Path getFileName() {
+        String[] n = names();
+        return n.length == 0 ? null : new PathImpl(n[n.length - 1]);
+    }
+
+    @Override
+    public Path getParent() {
+        String[] n = names();
+        if (n.length == 0) {
+            return null;
+        }
+        if (n.length == 1) {
+            return rootLength == 0 ? null : new PathImpl(root());
+        }
+        return build(root(), n, 0, n.length - 1);
+    }
+
+    @Override
+    public int getNameCount() {
+        return names().length;
+    }
+
+    @Override
+    public Path getName(int index) {
+        String[] n = names();
+        if (index < 0 || index >= n.length) {
+            throw new IllegalArgumentException();
+        }
+        return new PathImpl(n[index]);
+    }
+
+    @Override
+    public Path subpath(int beginIndex, int endIndex) {
+        String[] n = names();
+        if (beginIndex < 0 || beginIndex >= n.length || endIndex > n.length || beginIndex >= endIndex) {
+            throw new IllegalArgumentException();
+        }
+        return build("", n, beginIndex, endIndex);
+    }
+
+    @Override
+    public boolean startsWith(Path other) {
+        PathImpl o = impl(other);
+        if (!root().equals(o.root())) {
+            return false;
+        }
+        String[] a = names();
+        String[] b = o.names();
+        if (b.length > a.length) {
+            return false;
+        }
+        for (int i = 0; i < b.length; i++) {
+            if (!a[i].equals(b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean startsWith(String other) {
+        return startsWith(of(other));
+    }
+
+    @Override
+    public boolean endsWith(Path other) {
+        PathImpl o = impl(other);
+        if (o.rootLength > 0) {
+            return equals(o);
+        }
+        String[] a = names();
+        String[] b = o.names();
+        if (b.length > a.length) {
+            return false;
+        }
+        for (int i = 0; i < b.length; i++) {
+            if (!a[a.length - b.length + i].equals(b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean endsWith(String other) {
+        return endsWith(of(other));
+    }
+
+    @Override
+    public Path normalize() {
+        String[] n = names();
+        List<String> out = new ArrayList<String>(n.length);
+        for (String name : n) {
+            if (".".equals(name) || name.length() == 0) {
+                continue;
+            }
+            if ("..".equals(name)) {
+                int last = out.size() - 1;
+                if (last >= 0 && !"..".equals(out.get(last))) {
+                    out.remove(last);
+                    continue;
+                }
+                if (rootLength > 0) {
+                    // Above the root there is the root.
+                    continue;
+                }
+            }
+            out.add(name);
+        }
+        if (out.size() == n.length) {
+            return this;
+        }
+        return build(root(), out.toArray(new String[out.size()]), 0, out.size());
+    }
+
+    @Override
+    public Path resolve(Path other) {
+        PathImpl o = impl(other);
+        if (o.rootLength > 0 || isEmpty()) {
+            return o;
+        }
+        if (o.isEmpty()) {
+            return this;
+        }
+        return new PathImpl(path.length() == rootLength ? path + o.path : path + "/" + o.path);
+    }
+
+    @Override
+    public Path resolve(String other) {
+        return resolve(of(other));
+    }
+
+    @Override
+    public Path resolveSibling(Path other) {
+        PathImpl o = impl(other);
+        Path parent = getParent();
+        return parent == null ? o : parent.resolve(o);
+    }
+
+    @Override
+    public Path resolveSibling(String other) {
+        return resolveSibling(of(other));
+    }
+
+    private boolean hasDots() {
+        if (isEmpty()) {
+            return false;
+        }
+        for (String name : names()) {
+            if (".".equals(name) || "..".equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Path relativize(Path other) {
+        PathImpl o = impl(other);
+        if (!root().equals(o.root())) {
+            throw new IllegalArgumentException("'other' is different type of Path");
+        }
+        if (path.equals(o.path)) {
+            return new PathImpl("");
+        }
+        // A `.` or `..` anywhere has both sides normalized first, as the
+        // JDK has done since it stopped answering `../../b` for `a/..`
+        // against `b`: a name that cancels the one before it is no step
+        // away from anything. What is left of a `..` afterwards leads the
+        // path, cancels nothing, and is refused below.
+        PathImpl from = this;
+        if (!isEmpty() && (hasDots() || o.hasDots())) {
+            from = impl(normalize());
+            o = impl(o.normalize());
+        }
+        String[] a = from.isEmpty() ? NO_NAMES : from.names();
+        String[] b = o.isEmpty() ? NO_NAMES : o.names();
+        int common = 0;
+        while (common < a.length && common < b.length && a[common].equals(b[common])) {
+            common++;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = common; i < a.length; i++) {
+            if ("..".equals(a[i])) {
+                throw new IllegalArgumentException("Unable to compute relative path from " + this + " to " + other);
+            }
+            if (sb.length() > 0) {
+                sb.append('/');
+            }
+            sb.append("..");
+        }
+        for (int i = common; i < b.length; i++) {
+            if (sb.length() > 0) {
+                sb.append('/');
+            }
+            sb.append(b[i]);
+        }
+        return new PathImpl(sb.toString());
+    }
+
+    @Override
+    public URI toUri() {
+        // The storage path is "file://" and an absolute path, as typed: a
+        // space, '#' or '%' in a file's name is not legal in a URI as it
+        // stands. Handing the path over as a component has it escaped.
+        String storage = toFile().getAbsolutePath();
+        int at = storage.startsWith(SCHEME) ? SCHEME.length() : 0;
+        while (at + 1 < storage.length() && storage.charAt(at) == '/' && storage.charAt(at + 1) == '/') {
+            at++;
+        }
+        String uriPath = storage.substring(at);
+        // A directory's URI ends in '/', as the JDK's does, so that resolving
+        // a name against it lands inside the directory rather than beside it.
+        if (!uriPath.endsWith("/") && toFile().isDirectory()) {
+            uriPath = uriPath + "/";
+        }
+        try {
+            return new URI("file", null, uriPath, null, null);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException(e.getMessage());
+        }
+    }
+
+    @Override
+    public Path toAbsolutePath() {
+        return rootLength > 0 ? this : new PathImpl(clean(toFile().getAbsolutePath()));
+    }
+
+    @Override
+    public Path toRealPath(LinkOption... options) throws IOException {
+        File file = toFile();
+        if (!file.exists()) {
+            throw new NoSuchFileException(path);
+        }
+        return new PathImpl(clean(file.getCanonicalPath()));
+    }
+
+    @Override
+    public File toFile() {
+        return new File(path);
+    }
+
+    @Override
+    public Iterator<Path> iterator() {
+        return new Names(names());
+    }
+
+    /// The names of a path, each as a path of its own.
+    private static final class Names implements Iterator<Path> {
+        private final String[] n;
+        private int next;
+
+        Names(String[] n) {
+            this.n = n;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return next < n.length;
+        }
+
+        @Override
+        public Path next() {
+            if (next >= n.length) {
+                throw new NoSuchElementException();
+            }
+            return new PathImpl(n[next++]);
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override
+    public int compareTo(Path other) {
+        return path.compareTo(impl(other).path);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof PathImpl && ((PathImpl) o).path.equals(path);
+    }
+
+    @Override
+    public int hashCode() {
+        return path.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return path;
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/Paths.java b/vm/JavaAPI/src/java/nio/file/Paths.java
new file mode 100644
index 00000000000..afb6f8e9d12
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/Paths.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.net.URI;
+
+/// Makes paths; see [Path].
+public final class Paths {
+
+    private Paths() {
+    }
+
+    public static Path get(String first, String... more) {
+        return PathImpl.of(first, more);
+    }
+
+    public static Path get(URI uri) {
+        return PathImpl.of(uri);
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/SimpleFileVisitor.java b/vm/JavaAPI/src/java/nio/file/SimpleFileVisitor.java
new file mode 100644
index 00000000000..ac7e9451e32
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/SimpleFileVisitor.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+import java.io.IOException;
+import java.nio.file.attribute.BasicFileAttributes;
+
+/// A
+/// [FileVisitor] that visits everything and rethrows what failed.
+public class SimpleFileVisitor<T> implements FileVisitor<T> {
+
+    protected SimpleFileVisitor() {
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs) throws IOException {
+        if (dir == null || attrs == null) {
+            throw new NullPointerException();
+        }
+        return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFile(T file, BasicFileAttributes attrs) throws IOException {
+        if (file == null || attrs == null) {
+            throw new NullPointerException();
+        }
+        return FileVisitResult.CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(T file, IOException exc) throws IOException {
+        if (file == null) {
+            throw new NullPointerException();
+        }
+        throw exc;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(T dir, IOException exc) throws IOException {
+        if (dir == null) {
+            throw new NullPointerException();
+        }
+        if (exc != null) {
+            throw exc;
+        }
+        return FileVisitResult.CONTINUE;
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/StandardCopyOption.java b/vm/JavaAPI/src/java/nio/file/StandardCopyOption.java
new file mode 100644
index 00000000000..e7f564abb0e
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/StandardCopyOption.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is copied or moved.
+/// `REPLACE_EXISTING` is honoured; `COPY_ATTRIBUTES` and `ATOMIC_MOVE` are
+/// accepted and have no effect.
+public enum StandardCopyOption implements CopyOption {
+    REPLACE_EXISTING,
+    COPY_ATTRIBUTES,
+    ATOMIC_MOVE
+}
diff --git a/vm/JavaAPI/src/java/nio/file/StandardOpenOption.java b/vm/JavaAPI/src/java/nio/file/StandardOpenOption.java
new file mode 100644
index 00000000000..b86be1e717a
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/StandardOpenOption.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file;
+
+/// How a file is opened.
+///
+/// `READ`, `WRITE`, `APPEND`, `TRUNCATE_EXISTING`, `CREATE` and `CREATE_NEW`
+/// mean what they mean in the JDK. `DELETE_ON_CLOSE`, `SPARSE`, `SYNC` and
+/// `DSYNC` are accepted and have no effect: a device writes a file when the
+/// stream is closed and has nothing to say about how.
+public enum StandardOpenOption implements OpenOption {
+    READ,
+    WRITE,
+    APPEND,
+    TRUNCATE_EXISTING,
+    CREATE,
+    CREATE_NEW,
+    DELETE_ON_CLOSE,
+    SPARSE,
+    SYNC,
+    DSYNC
+}
diff --git a/vm/JavaAPI/src/java/nio/file/attribute/BasicFileAttributes.java b/vm/JavaAPI/src/java/nio/file/attribute/BasicFileAttributes.java
new file mode 100644
index 00000000000..df3cab26b9b
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/attribute/BasicFileAttributes.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file.attribute;
+
+/// What the device's file system knows about a file.
+///
+/// The three times are all the time of the last modification, which is the
+/// only one the device records. Nothing is a symbolic link, and there is no
+/// file key.
+public interface BasicFileAttributes {
+
+    FileTime lastModifiedTime();
+
+    FileTime lastAccessTime();
+
+    FileTime creationTime();
+
+    boolean isRegularFile();
+
+    boolean isDirectory();
+
+    boolean isSymbolicLink();
+
+    boolean isOther();
+
+    long size();
+
+    Object fileKey();
+}
diff --git a/vm/JavaAPI/src/java/nio/file/attribute/FileAttribute.java b/vm/JavaAPI/src/java/nio/file/attribute/FileAttribute.java
new file mode 100644
index 00000000000..9ea9cdfd1fe
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/attribute/FileAttribute.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file.attribute;
+
+/// The
+/// methods that create a file take these and a device has none to set, so
+/// the type exists for the empty array every such call passes.
+public interface FileAttribute<T> {
+
+    String name();
+
+    T value();
+}
diff --git a/vm/JavaAPI/src/java/nio/file/attribute/FileTime.java b/vm/JavaAPI/src/java/nio/file/attribute/FileTime.java
new file mode 100644
index 00000000000..8924d06279d
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/attribute/FileTime.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.nio.file.attribute;
+
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+
+/// A file's
+/// time stamp, kept to the millisecond, which is as fine as the device's
+/// file system reports it.
+public final class FileTime implements Comparable<FileTime> {
+
+    private final long millis;
+
+    private FileTime(long millis) {
+        this.millis = millis;
+    }
+
+    public static FileTime fromMillis(long value) {
+        return new FileTime(value);
+    }
+
+    public static FileTime from(long value, TimeUnit unit) {
+        return new FileTime(unit.toMillis(value));
+    }
+
+    public static FileTime from(Instant instant) {
+        return new FileTime(instant.toEpochMilli());
+    }
+
+    public long toMillis() {
+        return millis;
+    }
+
+    public long to(TimeUnit unit) {
+        return unit.convert(millis, TimeUnit.MILLISECONDS);
+    }
+
+    public Instant toInstant() {
+        return Instant.ofEpochMilli(millis);
+    }
+
+    @Override
+    public int compareTo(FileTime other) {
+        return millis < other.millis ? -1 : millis == other.millis ? 0 : 1;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof FileTime && ((FileTime) o).millis == millis;
+    }
+
+    @Override
+    public int hashCode() {
+        return (int) (millis ^ (millis >>> 32));
+    }
+
+    private static long floorDiv(long x, long y) {
+        long q = x / y;
+        return (x % y != 0 && (x < 0) != (y < 0)) ? q - 1 : q;
+    }
+
+    private static void pad(StringBuilder sb, long value, int width) {
+        String digits = Long.toString(value);
+        for (int i = digits.length(); i < width; i++) {
+            sb.append('0');
+        }
+        sb.append(digits);
+    }
+
+    /// The time in ISO 8601, in UTC, as the JDK writes it:
+    /// `2024-02-29T12:30:05.25Z`, the fraction left out when it is zero.
+    @Override
+    public String toString() {
+        long days = floorDiv(millis, 86400000L);
+        long ofDay = millis - floorDiv(millis, 86400000L) * 86400000L;
+        // Days since 1970-01-01 to a civil date, in the proleptic Gregorian
+        // calendar: eras of 400 years, counted from the first of March.
+        long z = days + 719468L;
+        long era = floorDiv(z, 146097L);
+        long doe = z - era * 146097L;
+        long yoe = (doe - doe / 1460L + doe / 36524L - doe / 146096L) / 365L;
+        long doy = doe - (365L * yoe + yoe / 4L - yoe / 100L);
+        long mp = (5L * doy + 2L) / 153L;
+        long day = doy - (153L * mp + 2L) / 5L + 1L;
+        long month = mp < 10 ? mp + 3 : mp - 9;
+        long year = yoe + era * 400L + (month <= 2 ? 1 : 0);
+        StringBuilder sb = new StringBuilder(30);
+        if (year < 0) {
+            sb.append('-');
+            pad(sb, -year, 4);
+        } else {
+            pad(sb, year, 4);
+        }
+        sb.append('-');
+        pad(sb, month, 2);
+        sb.append('-');
+        pad(sb, day, 2);
+        sb.append('T');
+        pad(sb, ofDay / 3600000L, 2);
+        sb.append(':');
+        pad(sb, ofDay / 60000L % 60L, 2);
+        sb.append(':');
+        pad(sb, ofDay / 1000L % 60L, 2);
+        long fraction = ofDay % 1000L;
+        if (fraction != 0) {
+            sb.append('.');
+            pad(sb, fraction, 3);
+            while (sb.charAt(sb.length() - 1) == '0') {
+                sb.setLength(sb.length() - 1);
+            }
+        }
+        return sb.append('Z').toString();
+    }
+}
diff --git a/vm/JavaAPI/src/java/nio/file/attribute/package-info.java b/vm/JavaAPI/src/java/nio/file/attribute/package-info.java
new file mode 100644
index 00000000000..465f850991f
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/attribute/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// The attributes of a file: its type, size and time stamp.
+package java.nio.file.attribute;
diff --git a/vm/JavaAPI/src/java/nio/file/package-info.java b/vm/JavaAPI/src/java/nio/file/package-info.java
new file mode 100644
index 00000000000..17825f5ee4f
--- /dev/null
+++ b/vm/JavaAPI/src/java/nio/file/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+/// Paths, and the operations on the files and directories they name, over
+/// the platform's file system as `java.io.File` reaches it.
+///
+/// `Files` reads, writes, copies, moves and walks; `Path` and `Paths` make
+/// and take apart paths. The methods of `Files` that answer a stream of
+/// lines or paths are not provided; `readAllLines`, `newDirectoryStream` and
+/// `walkFileTree` do the same work.
+package java.nio.file;
diff --git a/vm/JavaAPI/src/java/security/GeneralSecurityException.java b/vm/JavaAPI/src/java/security/GeneralSecurityException.java
new file mode 100644
index 00000000000..f5550cbc02a
--- /dev/null
+++ b/vm/JavaAPI/src/java/security/GeneralSecurityException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+/// `java.security.GeneralSecurityException`.
+public class GeneralSecurityException extends Exception {
+
+    public GeneralSecurityException() {
+    }
+
+    public GeneralSecurityException(String message) {
+        super(message);
+    }
+
+    public GeneralSecurityException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public GeneralSecurityException(Throwable cause) {
+        super(cause == null ? null : cause.toString(), cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/security/MessageDigest.java b/vm/JavaAPI/src/java/security/MessageDigest.java
new file mode 100644
index 00000000000..bb1dda4b26d
--- /dev/null
+++ b/vm/JavaAPI/src/java/security/MessageDigest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+import com.codename1.impl.JdkHost;
+
+/// A message digest over the platform's own, which
+/// `com.codename1.impl.JdkHost` reaches: MD5, SHA-1, SHA-224, SHA-256,
+/// SHA-384 and SHA-512 in a Codename One application. Any algorithm the
+/// platform lacks is a `NoSuchAlgorithmException`, as it is on a JDK without
+/// a provider for it.
+///
+/// There are no providers here: `getInstance` with a provider argument,
+/// `getProvider` and a subclass of this class are not offered.
+public final class MessageDigest {
+    private final String algorithm;
+    private final JdkHost.Digest hash;
+
+    private MessageDigest(String algorithm, JdkHost.Digest hash) {
+        this.algorithm = algorithm;
+        this.hash = hash;
+    }
+
+    public static MessageDigest getInstance(String algorithm) throws NoSuchAlgorithmException {
+        if (algorithm == null) {
+            throw new NullPointerException("null algorithm name");
+        }
+        String name = null;
+        if ("MD5".equalsIgnoreCase(algorithm)) {
+            name = "MD5";
+        } else if ("SHA-1".equalsIgnoreCase(algorithm) || "SHA1".equalsIgnoreCase(algorithm)
+                || "SHA".equalsIgnoreCase(algorithm)) {
+            name = "SHA-1";
+        } else if ("SHA-224".equalsIgnoreCase(algorithm) || "SHA224".equalsIgnoreCase(algorithm)) {
+            name = "SHA-224";
+        } else if ("SHA-256".equalsIgnoreCase(algorithm) || "SHA256".equalsIgnoreCase(algorithm)) {
+            name = "SHA-256";
+        } else if ("SHA-384".equalsIgnoreCase(algorithm) || "SHA384".equalsIgnoreCase(algorithm)) {
+            name = "SHA-384";
+        } else if ("SHA-512".equalsIgnoreCase(algorithm) || "SHA512".equalsIgnoreCase(algorithm)) {
+            name = "SHA-512";
+        }
+        JdkHost.Digest digest = name == null ? null : JdkHost.get().digest(name);
+        if (digest == null) {
+            throw new NoSuchAlgorithmException(algorithm + " MessageDigest not available");
+        }
+        return new MessageDigest(algorithm, digest);
+    }
+
+    public void update(byte input) {
+        hash.update(new byte[] {input}, 0, 1);
+    }
+
+    public void update(byte[] input) {
+        hash.update(input, 0, input.length);
+    }
+
+    public void update(byte[] input, int offset, int len) {
+        if (input == null) {
+            throw new IllegalArgumentException("No input buffer given");
+        }
+        if (offset < 0 || len < 0 || input.length - offset < len) {
+            throw new IllegalArgumentException("Input buffer too short");
+        }
+        hash.update(input, offset, len);
+    }
+
+    /// The digest of everything given so far; the next one starts empty.
+    public byte[] digest() {
+        byte[] out = hash.digest();
+        hash.reset();
+        return out;
+    }
+
+    public byte[] digest(byte[] input) {
+        update(input);
+        return digest();
+    }
+
+    public void reset() {
+        hash.reset();
+    }
+
+    public String getAlgorithm() {
+        return algorithm;
+    }
+
+    public int getDigestLength() {
+        return hash.length();
+    }
+
+    /// Whether two digests are the same, in a time that does not depend
+    /// on where they first differ.
+    public static boolean isEqual(byte[] a, byte[] b) {
+        if (a == b) {
+            return true;
+        }
+        if (a == null || b == null) {
+            return false;
+        }
+        if (b.length == 0) {
+            return a.length == 0;
+        }
+        int diff = a.length ^ b.length;
+        for (int i = 0; i < a.length; i++) {
+            diff |= a[i] ^ b[i % b.length];
+        }
+        return diff == 0;
+    }
+
+    @Override
+    public String toString() {
+        return algorithm + " Message Digest from the platform, <in progress>\n";
+    }
+}
diff --git a/vm/JavaAPI/src/java/security/NoSuchAlgorithmException.java b/vm/JavaAPI/src/java/security/NoSuchAlgorithmException.java
new file mode 100644
index 00000000000..ff0379e7a62
--- /dev/null
+++ b/vm/JavaAPI/src/java/security/NoSuchAlgorithmException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+/// `java.security.NoSuchAlgorithmException`.
+public class NoSuchAlgorithmException extends GeneralSecurityException {
+
+    public NoSuchAlgorithmException() {
+    }
+
+    public NoSuchAlgorithmException(String message) {
+        super(message);
+    }
+
+    public NoSuchAlgorithmException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public NoSuchAlgorithmException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/security/SecureRandom.java b/vm/JavaAPI/src/java/security/SecureRandom.java
new file mode 100644
index 00000000000..fbb1e83997b
--- /dev/null
+++ b/vm/JavaAPI/src/java/security/SecureRandom.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.security;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.Random;
+
+/// A cryptographically strong random number generator over the platform's
+/// own source of secure random bytes, which `com.codename1.impl.JdkHost`
+/// reaches: the one `com.codename1.security.SecureRandom` reads in a Codename
+/// One application, `/dev/urandom` for a program translated without it.
+///
+/// A seed adds nothing: the platform's generator seeds itself, and
+/// `setSeed` is accepted and ignored rather than made to weaken it.
+public class SecureRandom extends Random {
+    private static final long serialVersionUID = 1L;
+
+    public SecureRandom() {
+        super(0);
+    }
+
+    /// The seed is ignored; see the class description.
+    public SecureRandom(byte[] seed) {
+        super(0);
+    }
+
+    /// The platform's generator, which never blocks.
+    public static SecureRandom getInstanceStrong() {
+        return new SecureRandom();
+    }
+
+    @Override
+    public void setSeed(long seed) {
+        // Ignored: see the class description.
+    }
+
+    /// Ignored: see the class description.
+    public void setSeed(byte[] seed) {
+    }
+
+    public void nextBytes(byte[] bytes) {
+        JdkHost.get().randomBytes(bytes);
+    }
+
+    /// `numBytes` fresh random bytes, where the JDK answers seed material.
+    public byte[] generateSeed(int numBytes) {
+        if (numBytes < 0) {
+            throw new IllegalArgumentException("numBytes cannot be negative");
+        }
+        byte[] out = new byte[numBytes];
+        JdkHost.get().randomBytes(out);
+        return out;
+    }
+
+    @Override
+    protected int next(int bits) {
+        byte[] four = new byte[4];
+        JdkHost.get().randomBytes(four);
+        int value = (four[0] & 0xFF) << 24 | (four[1] & 0xFF) << 16 | (four[2] & 0xFF) << 8 | (four[3] & 0xFF);
+        return bits >= 32 ? value : value >>> (32 - bits);
+    }
+
+    public String getAlgorithm() {
+        return "NativePRNG";
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/ChoiceFormat.java b/vm/JavaAPI/src/java/text/ChoiceFormat.java
new file mode 100644
index 00000000000..f88312cacc5
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/ChoiceFormat.java
@@ -0,0 +1,337 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Picks a string by the range a number falls in. It is what the `choice` element of a
+/// [MessageFormat] pattern uses to write plurals.
+///
+/// A pattern is a list of `limit#text` pairs separated by `|`, the limits
+/// ascending: `0#no files|1#one file|1<{0} files`. A number selects the last
+/// pair whose limit it reaches; `#` includes the limit itself and `<` starts
+/// just above it. A number below the first limit selects the first pair. A
+/// single quote makes the characters up to the next one literal, and two in a
+/// row stand for one quote.
+public class ChoiceFormat extends NumberFormat {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final char LESS_OR_EQUAL = (char) 0x2264;
+    private static final String INFINITY = String.valueOf((char) 0x221E);
+
+    private static final long SIGN_BIT = 0x8000000000000000L;
+    private static final long POSITIVE_INFINITY_BITS = 0x7FF0000000000000L;
+
+    private double[] choiceLimits = new double[0];
+    private String[] choiceFormats = new String[0];
+
+    public ChoiceFormat(String newPattern) {
+        parsePattern(newPattern);
+    }
+
+    public ChoiceFormat(double[] limits, String[] formats) {
+        store(limits, formats);
+    }
+
+    public void applyPattern(String newPattern) {
+        parsePattern(newPattern);
+    }
+
+    private void parsePattern(String newPattern) {
+        StringBuilder limitText = new StringBuilder();
+        StringBuilder formatText = new StringBuilder();
+        double[] limits = new double[8];
+        String[] formats = new String[8];
+        int count = 0;
+        boolean inFormat = false;
+        boolean inQuote = false;
+        double startValue = 0;
+        double oldStartValue = Double.NaN;
+        for (int i = 0; i < newPattern.length(); i++) {
+            char ch = newPattern.charAt(i);
+            StringBuilder current = inFormat ? formatText : limitText;
+            if (ch == '\'') {
+                if (i + 1 < newPattern.length() && newPattern.charAt(i + 1) == ch) {
+                    current.append(ch);
+                    i++;
+                } else {
+                    inQuote = !inQuote;
+                }
+            } else if (inQuote) {
+                current.append(ch);
+            } else if (ch == '<' || ch == '#' || ch == LESS_OR_EQUAL) {
+                if (limitText.length() == 0) {
+                    throw new IllegalArgumentException("A choice has no limit: " + newPattern);
+                }
+                startValue = parseLimit(limitText.toString().trim(), newPattern);
+                if (ch == '<' && !Double.isInfinite(startValue)) {
+                    startValue = nextDouble(startValue);
+                }
+                if (startValue <= oldStartValue) {
+                    throw new IllegalArgumentException("Choice limits are not ascending: " + newPattern);
+                }
+                limitText.setLength(0);
+                inFormat = true;
+            } else if (ch == '|') {
+                if (count == limits.length) {
+                    double[] moreLimits = new double[count * 2];
+                    String[] moreFormats = new String[count * 2];
+                    System.arraycopy(limits, 0, moreLimits, 0, count);
+                    System.arraycopy(formats, 0, moreFormats, 0, count);
+                    limits = moreLimits;
+                    formats = moreFormats;
+                }
+                limits[count] = startValue;
+                formats[count] = formatText.toString();
+                count++;
+                oldStartValue = startValue;
+                formatText.setLength(0);
+                inFormat = false;
+            } else {
+                current.append(ch);
+            }
+        }
+        if (inFormat) {
+            if (count == limits.length) {
+                double[] moreLimits = new double[count + 1];
+                String[] moreFormats = new String[count + 1];
+                System.arraycopy(limits, 0, moreLimits, 0, count);
+                System.arraycopy(formats, 0, moreFormats, 0, count);
+                limits = moreLimits;
+                formats = moreFormats;
+            }
+            limits[count] = startValue;
+            formats[count] = formatText.toString();
+            count++;
+        }
+        choiceLimits = new double[count];
+        System.arraycopy(limits, 0, choiceLimits, 0, count);
+        choiceFormats = new String[count];
+        System.arraycopy(formats, 0, choiceFormats, 0, count);
+    }
+
+    private static double parseLimit(String text, String pattern) {
+        if (text.equals(INFINITY)) {
+            return Double.POSITIVE_INFINITY;
+        }
+        if (text.equals("-" + INFINITY)) {
+            return Double.NEGATIVE_INFINITY;
+        }
+        try {
+            return Double.parseDouble(text);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("A choice limit is not a number: " + pattern);
+        }
+    }
+
+    private static double distanceToInteger(double value) {
+        return Math.abs(value - Math.floor(value + 0.5));
+    }
+
+    public String toPattern() {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < choiceLimits.length; i++) {
+            if (i != 0) {
+                result.append('|');
+            }
+            // Either "limit#" or "justBelow<" says the same thing; the one
+            // that is closer to a whole number is the one that was written.
+            double limit = choiceLimits[i];
+            double less = previousDouble(limit);
+            if (distanceToInteger(limit) < distanceToInteger(less)) {
+                appendLimit(result, limit);
+                result.append('#');
+            } else {
+                appendLimit(result, less);
+                result.append('<');
+            }
+            String text = choiceFormats[i];
+            boolean needQuote = text.indexOf('<') >= 0 || text.indexOf('#') >= 0
+                    || text.indexOf(LESS_OR_EQUAL) >= 0 || text.indexOf('|') >= 0;
+            if (needQuote) {
+                result.append('\'');
+            }
+            for (int k = 0; k < text.length(); k++) {
+                char c = text.charAt(k);
+                result.append(c);
+                if (c == '\'') {
+                    result.append(c);
+                }
+            }
+            if (needQuote) {
+                result.append('\'');
+            }
+        }
+        return result.toString();
+    }
+
+    private static void appendLimit(StringBuilder out, double limit) {
+        if (limit == Double.POSITIVE_INFINITY) {
+            out.append(INFINITY);
+        } else if (limit == Double.NEGATIVE_INFINITY) {
+            out.append('-').append(INFINITY);
+        } else {
+            out.append(Double.toString(limit));
+        }
+    }
+
+    public void setChoices(double[] limits, String[] formats) {
+        store(limits, formats);
+    }
+
+    private void store(double[] limits, String[] formats) {
+        if (limits.length != formats.length) {
+            throw new IllegalArgumentException("Array and limit arrays must be of the same length.");
+        }
+        choiceLimits = limits.clone();
+        choiceFormats = formats.clone();
+    }
+
+    public double[] getLimits() {
+        return choiceLimits.clone();
+    }
+
+    public Object[] getFormats() {
+        return choiceFormats.clone();
+    }
+
+    @Override
+    public StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition status) {
+        return format((double) number, toAppendTo, status);
+    }
+
+    @Override
+    public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition status) {
+        if (choiceFormats.length == 0) {
+            return toAppendTo;
+        }
+        int i = 0;
+        // Written so that not-a-number, which is below nothing, selects the
+        // first choice.
+        while (i < choiceLimits.length && number >= choiceLimits[i]) {
+            i++;
+        }
+        i--;
+        if (i < 0) {
+            i = 0;
+        }
+        return toAppendTo.append(choiceFormats[i]);
+    }
+
+    /// Finds the choice whose text starts at the position, the longest if
+    /// several do, and answers its limit as a `Double`. When none does, the
+    /// error index is set and the answer is not-a-number.
+    @Override
+    public Number parse(String text, ParsePosition status) {
+        int start = status.getIndex();
+        int furthest = start;
+        double bestNumber = Double.NaN;
+        for (int i = 0; i < choiceFormats.length; i++) {
+            String candidate = choiceFormats[i];
+            if (text.regionMatches(start, candidate, 0, candidate.length())) {
+                int end = start + candidate.length();
+                if (end > furthest) {
+                    furthest = end;
+                    bestNumber = choiceLimits[i];
+                    if (furthest == text.length()) {
+                        break;
+                    }
+                }
+            }
+        }
+        status.setIndex(furthest);
+        if (furthest == start) {
+            status.setErrorIndex(furthest);
+        }
+        return Double.valueOf(bestNumber);
+    }
+
+    public static final double nextDouble(double d) {
+        return nextDouble(d, true);
+    }
+
+    public static final double previousDouble(double d) {
+        return nextDouble(d, false);
+    }
+
+    /// The `double` next to `d`: the next greater when `positive`, else the
+    /// next smaller.
+    public static double nextDouble(double d, boolean positive) {
+        if (Double.isNaN(d)) {
+            return d;
+        }
+        if (d == 0.0) {
+            double smallest = Double.longBitsToDouble(1L);
+            return positive ? smallest : -smallest;
+        }
+        long bits = Double.doubleToLongBits(d);
+        long magnitude = bits & ~SIGN_BIT;
+        if ((bits > 0) == positive) {
+            if (magnitude != POSITIVE_INFINITY_BITS) {
+                magnitude += 1;
+            }
+        } else {
+            magnitude -= 1;
+        }
+        return Double.longBitsToDouble(magnitude | (bits & SIGN_BIT));
+    }
+
+    /// A copy of this format, built from copies of its arrays:
+    /// `Object.clone()` answers `null` on the device for anything but an
+    /// array.
+    @Override
+    public Object clone() {
+        ChoiceFormat copy = new ChoiceFormat(choiceLimits, choiceFormats);
+        copyNumberFormatTo(copy);
+        return copy;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = choiceLimits.length;
+        if (choiceFormats.length > 0) {
+            result ^= choiceFormats[choiceFormats.length - 1].hashCode();
+        }
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ChoiceFormat) || getClass() != obj.getClass()) {
+            return false;
+        }
+        ChoiceFormat other = (ChoiceFormat) obj;
+        if (choiceLimits.length != other.choiceLimits.length) {
+            return false;
+        }
+        for (int i = 0; i < choiceLimits.length; i++) {
+            if (Double.doubleToLongBits(choiceLimits[i]) != Double.doubleToLongBits(other.choiceLimits[i])
+                    || !choiceFormats[i].equals(other.choiceFormats[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/DateFormat.java b/vm/JavaAPI/src/java/text/DateFormat.java
index 5aab5900634..19f6e87c85e 100644
--- a/vm/JavaAPI/src/java/text/DateFormat.java
+++ b/vm/JavaAPI/src/java/text/DateFormat.java
@@ -80,15 +80,35 @@ public class DateFormat extends Format {
 
 
 	/**
-	 * Format a given object.
-	 * 
-	 * @obj object to be formatted.
-	 * @return formatted object.
-	 * @throws IllegalArgumentException of the source can not be formatted.
+	 * Format a given object, a date or a number of milliseconds since the epoch.
+	 *
+	 * @param obj object to be formatted.
+	 * @param toAppendTo buffer to which to append output.
+	 * @param fieldPosition not updated: no field is reported.
+	 * @return toAppendTo.
+	 * @throws IllegalArgumentException if the source is neither a date nor a number.
 	 */
 	@Override
-	public String format(Object obj) throws IllegalArgumentException {
-		return format(obj, new StringBuffer());
+	public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition fieldPosition) {
+		if (obj instanceof Date) {
+			return format((Date) obj, toAppendTo, fieldPosition);
+		}
+		if (obj instanceof Number) {
+			return format(new Date(((Number) obj).longValue()), toAppendTo, fieldPosition);
+		}
+		throw new IllegalArgumentException("Cannot format given Object as a Date");
+	}
+
+	/**
+	 * Format a given date.
+	 *
+	 * @param date date to be formatted.
+	 * @param toAppendTo buffer to which to append output.
+	 * @param fieldPosition not updated: no field is reported.
+	 * @return toAppendTo.
+	 */
+	public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition) {
+		return toAppendTo.append(format(date));
 	}
 
 	/**
@@ -123,19 +143,51 @@ public String format(Date source) {
 	native String format(Date source, StringBuffer toAppendTo);
 
 	/**
-	 * NOT IMPLEMENTED - use SimpleDateFormat for parsing instead.
+	 * Parse a date from the beginning of the source. NOT IMPLEMENTED for the
+	 * style based formats - use SimpleDateFormat for parsing instead.
 	 */
 	@Override
 	public Object parseObject(String source) throws ParseException {
-		// can't parse because we don't know the L10NManagers templates
-		throw new ParseException("Not implemented", 0);
+		return parse(source);
 	}
 
 	/**
-	 * NOT IMPLEMENTED - use SimpleDateFormat for parsing instead.
+	 * Parse a date from the beginning of the source. NOT IMPLEMENTED for the
+	 * style based formats - use SimpleDateFormat for parsing instead.
 	 */
 	public Date parse(String source) throws ParseException {
-		return (Date) parseObject(source);
+		return parseAt(source, 0, null);
+	}
+
+	/**
+	 * Parse a date starting at a position. On success the index of the
+	 * position is moved past the date; on failure it is left alone, its
+	 * error index is set and null is returned.
+	 */
+	public Date parse(String source, ParsePosition pos) {
+		int[] end = new int[1];
+		try {
+			Date result = parseAt(source, pos.getIndex(), end);
+			pos.setIndex(end[0]);
+			return result;
+		} catch (ParseException e) {
+			pos.setErrorIndex(e.getErrorOffset());
+			return null;
+		}
+	}
+
+	@Override
+	public Object parseObject(String source, ParsePosition pos) {
+		return parse(source, pos);
+	}
+
+	/**
+	 * Parse a date at index start of source and, when end is not null, store
+	 * in end[0] the index just past it.
+	 */
+	Date parseAt(String source, int start, int[] end) throws ParseException {
+		// can't parse because we don't know the L10NManagers templates
+		throw new ParseException("Not implemented", start);
 	}
 
 	/**
diff --git a/vm/JavaAPI/src/java/text/DecimalFormat.java b/vm/JavaAPI/src/java/text/DecimalFormat.java
new file mode 100644
index 00000000000..84c1769b1ce
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/DecimalFormat.java
@@ -0,0 +1,1463 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Formats and parses decimal numbers according to a pattern.
+///
+/// #### Pattern syntax
+///
+/// A pattern is a positive subpattern, optionally followed by `;` and a
+/// negative subpattern of which only the prefix and suffix are used. Each
+/// subpattern is a prefix, a number and a suffix. In the number:
+///
+/// - `0` is a digit that is always written, `#` a digit written only when
+///   it is significant.
+/// - `.` is the decimal separator and `,` the grouping separator; the
+///   distance from the last `,` to the end of the integer part is the group
+///   size.
+/// - `E` followed by one or more `0` selects scientific notation, with at
+///   least that many exponent digits. With more integer digit positions than
+///   `0`s among them (`##0.###E0`), the exponent is kept a multiple of the
+///   number of integer positions.
+///
+/// In a prefix or suffix, `%` multiplies the number by 100 and writes a
+/// percent sign, the per mille sign multiplies by 1000, the currency sign
+/// writes the currency symbol (doubled, the international currency code), and
+/// `-` writes the minus sign. A single quote makes the characters up to the
+/// next one literal, and two in a row stand for one quote.
+///
+/// The characters actually written -- separators, minus, percent, currency
+/// -- come from the format's [DecimalFormatSymbols].
+///
+/// #### Rounding
+///
+/// Rounding is half-even, the JDK default, and like the JDK it is decided by
+/// the exact binary value of a `double`: `0.125` is a true tie and formats as
+/// `0.12` under `0.00`, while `0.15`, which as a `double` lies just below the
+/// decimal `0.15`, formats as `0.1` under `0.0`.
+///
+/// The JDK departs from half-even in two places, and so does this class,
+/// because a last digit that differs from the desktop's is worse than either
+/// answer: a whole number rounds a tie up in scientific notation (`12345`
+/// under `0.###E0` is `1.235E4`), and `5E-4`, `5E-5` and so on round down
+/// when the 5 is the first digit dropped (`0.0005` under `0.000` is `0.000`).
+///
+/// #### Differences from the JDK
+///
+/// - No `setRoundingMode`, `setCurrency`, `setParseBigDecimal` or
+///   `formatToCharacterIterator`: the device has none of the types they name.
+/// - No localized patterns (`applyLocalizedPattern`, `toLocalizedPattern`).
+public class DecimalFormat extends NumberFormat {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The currency sign of a pattern. Not written as a character literal:
+    /// the sources are ASCII.
+    static final char CURRENCY_SIGN = (char) 0xA4;
+
+    private static final char PER_MILLE_SIGN = (char) 0x2030;
+    private static final char QUOTE = '\'';
+
+    /// A `double` has no more integer digits than this, nor fraction digits
+    /// than the next; the JDK caps the settings there for a `double` as well.
+    private static final int DOUBLE_INTEGER_DIGITS = 309;
+    private static final int DOUBLE_FRACTION_DIGITS = 340;
+
+    private DecimalFormatSymbols symbols;
+
+    // The affixes as the pattern gave them, in an internal form where a quote
+    // precedes each character to be replaced by a symbol and '' is a quote.
+    private String posPrefixPattern = "";
+    private String posSuffixPattern = "";
+    private String negPrefixPattern = "'-";
+    private String negSuffixPattern = "";
+
+    // The same affixes with the symbols filled in.
+    private String positivePrefix = "";
+    private String positiveSuffix = "";
+    private String negativePrefix = "-";
+    private String negativeSuffix = "";
+
+    private int multiplier = 1;
+    private int groupingSize = 3;
+    private boolean decimalSeparatorAlwaysShown;
+    private boolean useExponentialNotation;
+    private int minExponentDigits;
+    private boolean currencyFormat;
+
+    public DecimalFormat() {
+        this("#,##0.###", DecimalFormatSymbols.getInstance());
+    }
+
+    public DecimalFormat(String pattern) {
+        this(pattern, DecimalFormatSymbols.getInstance());
+    }
+
+    public DecimalFormat(String pattern, DecimalFormatSymbols symbols) {
+        if (symbols == null) {
+            throw new NullPointerException();
+        }
+        Object copy = symbols.clone();
+        this.symbols = copy instanceof DecimalFormatSymbols ? (DecimalFormatSymbols) copy : symbols;
+        parsePattern(pattern);
+    }
+
+    // ------------------------------------------------------------------
+    // Digits
+    // ------------------------------------------------------------------
+
+    /// A non-negative decimal number: `count` significant digits, with the
+    /// decimal point `decimalAt` digits from the left (so the value is
+    /// 0.d1d2... times ten to the `decimalAt`). No trailing zeros; zero is no
+    /// digits at all.
+    private static final class Digits {
+        /// The digits are the number: a tie goes to the even neighbour.
+        static final int TIE_EVEN = 0;
+        /// The digits are the shortest text of a `double`: a tie is settled
+        /// by where the `double` really lies, and is even only if it lies
+        /// exactly there.
+        static final int TIE_BY_VALUE = 1;
+        static final int TIE_UP = 2;
+        static final int TIE_DOWN = 3;
+
+        private char[] d = new char[24];
+        private int count;
+        private int decimalAt;
+
+        private void append(char c) {
+            if (count == d.length) {
+                char[] bigger = new char[d.length * 2];
+                System.arraycopy(d, 0, bigger, 0, count);
+                d = bigger;
+            }
+            d[count++] = c;
+        }
+
+        private void trim() {
+            while (count > 0 && d[count - 1] == '0') {
+                count--;
+            }
+            if (count == 0) {
+                decimalAt = 0;
+            }
+        }
+
+        /// Takes plain decimal digits, an integer.
+        void setInteger(String digits) {
+            count = 0;
+            int i = 0;
+            while (i < digits.length() && digits.charAt(i) == '0') {
+                i++;
+            }
+            decimalAt = digits.length() - i;
+            for (; i < digits.length(); i++) {
+                append(digits.charAt(i));
+            }
+            trim();
+        }
+
+        /// Takes the digits of a finite, non-negative `double` as the JDK's
+        /// `DecimalFormat` sees them. Those are NOT the shortest digits
+        /// `Double.toString` writes (`1.0E23` is `9.999999999999999E22`
+        /// here); see `LegacyDoubleDigits` for why.
+        void setDouble(double value) {
+            count = 0;
+            decimalAt = 0;
+            // Zero has no digits. So does NaN, which reaches here from an
+            // infinity times a multiplier of zero.
+            if (!(value > 0.0)) {
+                return;
+            }
+            LegacyDoubleDigits converted = new LegacyDoubleDigits(value);
+            for (int i = 0; i < converted.count; i++) {
+                append(converted.digits[converted.first + i]);
+            }
+            decimalAt = converted.decExponent;
+            trim();
+        }
+
+        /// Multiplies by a positive integer.
+        void multiply(int by) {
+            if (count == 0) {
+                return;
+            }
+            char[] out = new char[count + 11];
+            int at = out.length;
+            long carry = 0;
+            for (int i = count - 1; i >= 0; i--) {
+                long v = (long) (d[i] - '0') * by + carry;
+                out[--at] = (char) ('0' + (int) (v % 10));
+                carry = v / 10;
+            }
+            while (carry > 0) {
+                out[--at] = (char) ('0' + (int) (carry % 10));
+                carry = carry / 10;
+            }
+            int produced = out.length - at;
+            decimalAt += produced - count;
+            count = 0;
+            for (int i = at; i < out.length; i++) {
+                append(out[i]);
+            }
+            trim();
+        }
+
+        /// Keeps the first `keep` digits, rounding half-even. `tie` says how
+        /// digits that end in exactly a half are settled; `value` is the
+        /// `double` they were taken from, for [#TIE_BY_VALUE].
+        void round(int keep, int tie, double value) {
+            if (keep >= count) {
+                return;
+            }
+            if (keep < 0) {
+                count = 0;
+                decimalAt = 0;
+                return;
+            }
+            if (roundsUp(keep, tie, value)) {
+                int i = keep - 1;
+                while (i >= 0 && d[i] == '9') {
+                    i--;
+                }
+                if (i < 0) {
+                    d[0] = '1';
+                    count = 1;
+                    decimalAt++;
+                } else {
+                    d[i]++;
+                    count = i + 1;
+                }
+            } else {
+                count = keep;
+            }
+            trim();
+        }
+
+        private boolean roundsUp(int keep, int tie, double value) {
+            char next = d[keep];
+            if (next != '5') {
+                return next > '5';
+            }
+            if (keep + 1 < count) {
+                // Past the 5 there is something, and it is not zero.
+                return true;
+            }
+            // The digits end in exactly a half.
+            if (tie == TIE_UP) {
+                return true;
+            }
+            if (tie == TIE_DOWN) {
+                return false;
+            }
+            // A long is those digits. A double is only the nearest double to
+            // them, so the true value is compared against the half it
+            // appears to be.
+            int side = tie == TIE_EVEN ? 0 : compareToDigits(value);
+            if (side != 0) {
+                return side > 0;
+            }
+            return keep > 0 && ((d[keep - 1] - '0') & 1) == 1;
+        }
+
+        /// The sign of `value` minus the number these digits spell.
+        private int compareToDigits(double value) {
+            long bits = Double.doubleToLongBits(value);
+            int rawExponent = (int) ((bits >> 52) & 0x7ffL);
+            long mantissa = bits & 0xfffffffffffffL;
+            int binaryExponent;
+            if (rawExponent == 0) {
+                binaryExponent = -1074;
+            } else {
+                mantissa |= 1L << 52;
+                binaryExponent = rawExponent - 1075;
+            }
+            // value = mantissa * 2^binaryExponent, digits = n * 10^decimalExponent.
+            // Negative powers move to the other side, leaving integers.
+            Magnitude left = Magnitude.ofLong(mantissa);
+            Magnitude right = Magnitude.ofDigits(d, count);
+            int decimalExponent = decimalAt - count;
+            if (binaryExponent > 0) {
+                left.shiftLeft(binaryExponent);
+            } else if (binaryExponent < 0) {
+                right.shiftLeft(-binaryExponent);
+            }
+            if (decimalExponent > 0) {
+                right.multiplyByPowerOfTen(decimalExponent);
+            } else if (decimalExponent < 0) {
+                left.multiplyByPowerOfTen(-decimalExponent);
+            }
+            return left.compareTo(right);
+        }
+    }
+
+    /// A non-negative integer of any size, just enough of one to compare a
+    /// `double` with the decimal digits it was written as: the device has no
+    /// `java.math`. Little-endian limbs in base one billion, so a limb times
+    /// any factor up to two to the 30th plus a carry fits a `long`.
+    private static final class Magnitude {
+        private static final int BASE = 1000000000;
+        private static final int SHIFT_STEP = 30;
+
+        private int[] limbs = new int[4];
+        private int length;
+
+        static Magnitude ofLong(long value) {
+            Magnitude m = new Magnitude();
+            long v = value;
+            while (v > 0) {
+                m.push((int) (v % BASE));
+                v = v / BASE;
+            }
+            return m;
+        }
+
+        /// The integer the first `count` ASCII digits of `digits` spell.
+        static Magnitude ofDigits(char[] digits, int count) {
+            Magnitude m = new Magnitude();
+            int end = count;
+            while (end > 0) {
+                int start = Math.max(0, end - 9);
+                int limb = 0;
+                for (int i = start; i < end; i++) {
+                    limb = limb * 10 + (digits[i] - '0');
+                }
+                m.push(limb);
+                end = start;
+            }
+            m.normalize();
+            return m;
+        }
+
+        private void push(int limb) {
+            if (length == limbs.length) {
+                int[] bigger = new int[limbs.length * 2];
+                System.arraycopy(limbs, 0, bigger, 0, length);
+                limbs = bigger;
+            }
+            limbs[length++] = limb;
+        }
+
+        private void normalize() {
+            while (length > 0 && limbs[length - 1] == 0) {
+                length--;
+            }
+        }
+
+        /// Multiplies by a factor from 1 to two to the 30th.
+        private void multiplySmall(int factor) {
+            long carry = 0;
+            for (int i = 0; i < length; i++) {
+                long v = (long) limbs[i] * factor + carry;
+                limbs[i] = (int) (v % BASE);
+                carry = v / BASE;
+            }
+            while (carry > 0) {
+                push((int) (carry % BASE));
+                carry = carry / BASE;
+            }
+        }
+
+        void shiftLeft(int bits) {
+            int left = bits;
+            while (left >= SHIFT_STEP) {
+                multiplySmall(1 << SHIFT_STEP);
+                left -= SHIFT_STEP;
+            }
+            if (left > 0) {
+                multiplySmall(1 << left);
+            }
+        }
+
+        void multiplyByPowerOfTen(int exponent) {
+            int left = exponent;
+            while (left >= 9) {
+                multiplySmall(BASE);
+                left -= 9;
+            }
+            int factor = 1;
+            for (int i = 0; i < left; i++) {
+                factor *= 10;
+            }
+            if (factor > 1) {
+                multiplySmall(factor);
+            }
+        }
+
+        int compareTo(Magnitude other) {
+            if (length != other.length) {
+                return length < other.length ? -1 : 1;
+            }
+            for (int i = length - 1; i >= 0; i--) {
+                if (limbs[i] != other.limbs[i]) {
+                    return limbs[i] < other.limbs[i] ? -1 : 1;
+                }
+            }
+            return 0;
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Formatting
+    // ------------------------------------------------------------------
+
+    @Override
+    public StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition) {
+        fieldPosition.setBeginIndex(0);
+        fieldPosition.setEndIndex(0);
+        if (Double.isNaN(number)) {
+            int begin = result.length();
+            result.append(symbols.getNaN());
+            if (fieldPosition.getField() == INTEGER_FIELD) {
+                fieldPosition.setBeginIndex(begin);
+                fieldPosition.setEndIndex(result.length());
+            }
+            return result;
+        }
+        // The sign bit, so that negative zero is negative.
+        boolean negative = (Double.doubleToLongBits(number) < 0) ^ (multiplier < 0);
+        double value = number;
+        if (multiplier != 1) {
+            value = value * multiplier;
+        }
+        if (Double.isInfinite(value)) {
+            result.append(negative ? negativePrefix : positivePrefix);
+            int begin = result.length();
+            result.append(symbols.getInfinity());
+            if (fieldPosition.getField() == INTEGER_FIELD) {
+                fieldPosition.setBeginIndex(begin);
+                fieldPosition.setEndIndex(result.length());
+            }
+            result.append(negative ? negativeSuffix : positiveSuffix);
+            return result;
+        }
+        value = Math.abs(value);
+        int maxInt = Math.min(getMaximumIntegerDigits(), DOUBLE_INTEGER_DIGITS);
+        int minInt = Math.min(getMinimumIntegerDigits(), DOUBLE_INTEGER_DIGITS);
+        int maxFrac = Math.min(getMaximumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        int minFrac = Math.min(getMinimumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        Digits digits = new Digits();
+        digits.setDouble(value);
+        // Two places where the JDK does not round half-even, kept because
+        // output that differs from the desktop's in the last digit is worse
+        // than either answer. A whole number below two to the 63rd rounds a
+        // tie up (12345 under 0.###E0 is 1.235E4), and 5E-4, 5E-5, ... round
+        // down when the 5 is the first digit dropped (0.0005 under 0.000 is
+        // 0.000, though 0.005 under 0.00 is 0.01).
+        int tie = Digits.TIE_BY_VALUE;
+        if (value < 9.2E18 && (double) (long) value == value) {
+            tie = Digits.TIE_UP;
+        }
+        if (useExponentialNotation) {
+            digits.round(maxInt + maxFrac, tie, value);
+        } else {
+            int keep = digits.decimalAt + maxFrac;
+            if (keep == 0 && value < 1.0E-3 && !isCommonShape(maxInt, minInt, maxFrac, minFrac)) {
+                tie = Digits.TIE_DOWN;
+            }
+            digits.round(keep, tie, value);
+        }
+        return subformat(result, fieldPosition, digits, negative, false, maxInt, minInt, maxFrac, minFrac);
+    }
+
+    /// The shapes the JDK formats by a separate, exact route -- the default
+    /// number and currency patterns -- where neither exception applies.
+    private boolean isCommonShape(int maxInt, int minInt, int maxFrac, int minFrac) {
+        if (!isGroupingUsed() || groupingSize != 3 || multiplier != 1 || decimalSeparatorAlwaysShown
+                || minInt != 1 || maxInt < 10) {
+            return false;
+        }
+        return currencyFormat ? minFrac == 2 && maxFrac == 2 : minFrac == 0 && maxFrac == 3;
+    }
+
+    @Override
+    public StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition) {
+        fieldPosition.setBeginIndex(0);
+        fieldPosition.setEndIndex(0);
+        boolean negative = number < 0;
+        String text = Long.toString(number);
+        Digits digits = new Digits();
+        digits.setInteger(negative ? text.substring(1) : text);
+        if (multiplier != 1) {
+            if (multiplier == 0) {
+                digits.setInteger("0");
+            } else if (multiplier < 0) {
+                negative = !negative;
+                if (multiplier == Integer.MIN_VALUE) {
+                    digits.multiply(1 << 30);
+                    digits.multiply(2);
+                } else {
+                    digits.multiply(-multiplier);
+                }
+            } else {
+                digits.multiply(multiplier);
+            }
+        }
+        int maxInt = getMaximumIntegerDigits();
+        int minInt = getMinimumIntegerDigits();
+        int maxFrac = getMaximumFractionDigits();
+        int minFrac = getMinimumFractionDigits();
+        if (useExponentialNotation) {
+            int significant = maxInt + maxFrac;
+            if (significant > 0) {
+                digits.round(significant, Digits.TIE_EVEN, 0);
+            }
+        }
+        if (digits.count == 0) {
+            // An integer zero has no sign.
+            negative = false;
+        }
+        return subformat(result, fieldPosition, digits, negative, true, maxInt, minInt, maxFrac, minFrac);
+    }
+
+    private char digitChar(char asciiDigit) {
+        return (char) (asciiDigit - '0' + symbols.getZeroDigit());
+    }
+
+    private StringBuffer subformat(StringBuffer result, FieldPosition fieldPosition, Digits digits,
+                                   boolean negative, boolean isInteger,
+                                   int maxInt, int minInt, int maxFrac, int minFrac) {
+        char zero = symbols.getZeroDigit();
+        char decimal = currencyFormat ? symbols.getMonetaryDecimalSeparator() : symbols.getDecimalSeparator();
+        result.append(negative ? negativePrefix : positivePrefix);
+        int integerBegin = result.length();
+        int integerEnd = -1;
+        int fractionBegin = -1;
+        if (useExponentialNotation) {
+            // The exponent is what leaves the wanted number of integer
+            // digits; with more integer positions than required digits it is
+            // also kept a multiple of the number of positions.
+            int exponent = digits.decimalAt;
+            int repeat = maxInt;
+            int minimumIntegerDigits = minInt;
+            if (repeat > 1 && repeat > minInt) {
+                if (exponent >= 1) {
+                    exponent = ((exponent - 1) / repeat) * repeat;
+                } else {
+                    exponent = ((exponent - repeat) / repeat) * repeat;
+                }
+                minimumIntegerDigits = 1;
+            } else {
+                exponent -= minimumIntegerDigits;
+            }
+            int minimumDigits = minInt + minFrac;
+            if (minimumDigits < 0) {
+                minimumDigits = Integer.MAX_VALUE;
+            }
+            int integerDigits = digits.count == 0 ? minimumIntegerDigits : digits.decimalAt - exponent;
+            if (minimumDigits < integerDigits) {
+                minimumDigits = integerDigits;
+            }
+            int totalDigits = Math.max(digits.count, minimumDigits);
+            boolean wroteDecimal = false;
+            for (int i = 0; i < totalDigits; i++) {
+                if (i == integerDigits) {
+                    integerEnd = result.length();
+                    result.append(decimal);
+                    wroteDecimal = true;
+                    fractionBegin = result.length();
+                }
+                result.append(i < digits.count ? digitChar(digits.d[i]) : zero);
+            }
+            if (decimalSeparatorAlwaysShown && totalDigits == integerDigits) {
+                integerEnd = result.length();
+                result.append(decimal);
+                wroteDecimal = true;
+                fractionBegin = result.length();
+            }
+            if (integerEnd < 0) {
+                integerEnd = result.length();
+            }
+            if (!wroteDecimal) {
+                fractionBegin = result.length();
+            }
+            int fractionEnd = result.length();
+            result.append(symbols.getExponentSeparator());
+            if (digits.count == 0) {
+                exponent = 0;
+            }
+            if (exponent < 0) {
+                exponent = -exponent;
+                result.append(symbols.getMinusSign());
+            }
+            String exponentText = Integer.toString(exponent);
+            for (int i = exponentText.length(); i < minExponentDigits; i++) {
+                result.append(zero);
+            }
+            for (int i = 0; i < exponentText.length(); i++) {
+                result.append(digitChar(exponentText.charAt(i)));
+            }
+            setField(fieldPosition, integerBegin, integerEnd, fractionBegin, fractionEnd);
+        } else {
+            int count = minInt;
+            int digitIndex = 0;
+            if (digits.decimalAt > 0 && count < digits.decimalAt) {
+                count = digits.decimalAt;
+            }
+            // With fewer integer digits allowed than the number has, the
+            // least significant ones are the ones written: 1997 under a
+            // maximum of two is "97".
+            if (count > maxInt) {
+                count = maxInt;
+                digitIndex = digits.decimalAt - count;
+            }
+            boolean grouping = isGroupingUsed() && groupingSize > 0;
+            for (int i = count - 1; i >= 0; i--) {
+                if (i < digits.decimalAt && digitIndex < digits.count) {
+                    result.append(digitChar(digits.d[digitIndex++]));
+                } else {
+                    result.append(zero);
+                }
+                // groupingSize is checked positive just above.
+                if (grouping && i > 0 && i % groupingSize == 0) {
+                    result.append(symbols.getGroupingSeparator());
+                }
+            }
+            boolean fractionPresent = minFrac > 0 || (!isInteger && digitIndex < digits.count);
+            if (!fractionPresent && result.length() == integerBegin) {
+                result.append(zero);
+            }
+            integerEnd = result.length();
+            if (decimalSeparatorAlwaysShown || fractionPresent) {
+                result.append(decimal);
+            }
+            fractionBegin = result.length();
+            for (int i = 0; i < maxFrac; i++) {
+                if (i >= minFrac && (isInteger || digitIndex >= digits.count)) {
+                    break;
+                }
+                // Zeros between the decimal point and the first digit.
+                if (-1 - i > digits.decimalAt - 1) {
+                    result.append(zero);
+                    continue;
+                }
+                if (!isInteger && digitIndex < digits.count) {
+                    result.append(digitChar(digits.d[digitIndex++]));
+                } else {
+                    result.append(zero);
+                }
+            }
+            setField(fieldPosition, integerBegin, integerEnd, fractionBegin, result.length());
+        }
+        result.append(negative ? negativeSuffix : positiveSuffix);
+        return result;
+    }
+
+    private static void setField(FieldPosition fieldPosition, int integerBegin, int integerEnd,
+                                 int fractionBegin, int fractionEnd) {
+        if (fieldPosition.getField() == INTEGER_FIELD) {
+            fieldPosition.setBeginIndex(integerBegin);
+            fieldPosition.setEndIndex(integerEnd);
+        } else if (fieldPosition.getField() == FRACTION_FIELD) {
+            fieldPosition.setBeginIndex(fractionBegin);
+            fieldPosition.setEndIndex(fractionEnd);
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Parsing
+    // ------------------------------------------------------------------
+
+    private int digitValue(char c) {
+        int v = c - symbols.getZeroDigit();
+        if (v >= 0 && v <= 9) {
+            return v;
+        }
+        v = c - '0';
+        return v >= 0 && v <= 9 ? v : -1;
+    }
+
+    private static boolean matches(String text, int at, String part) {
+        return text.regionMatches(at, part, 0, part.length());
+    }
+
+    @Override
+    public Number parse(String text, ParsePosition pos) {
+        int start = pos.getIndex();
+        int position = start;
+        String nan = symbols.getNaN();
+        if (nan.length() > 0 && matches(text, position, nan)) {
+            pos.setIndex(position + nan.length());
+            return Double.valueOf(Double.NaN);
+        }
+        boolean gotPositive = matches(text, position, positivePrefix);
+        boolean gotNegative = matches(text, position, negativePrefix);
+        if (gotPositive && gotNegative) {
+            if (positivePrefix.length() > negativePrefix.length()) {
+                gotNegative = false;
+            } else if (positivePrefix.length() < negativePrefix.length()) {
+                gotPositive = false;
+            }
+        }
+        if (gotPositive) {
+            position += positivePrefix.length();
+        } else if (gotNegative) {
+            position += negativePrefix.length();
+        } else {
+            pos.setErrorIndex(position);
+            return null;
+        }
+
+        boolean infinite = false;
+        StringBuilder digits = new StringBuilder();
+        int decimalAt = 0;
+        String infinity = symbols.getInfinity();
+        if (infinity.length() > 0 && matches(text, position, infinity)) {
+            position += infinity.length();
+            infinite = true;
+        } else {
+            char decimal = currencyFormat ? symbols.getMonetaryDecimalSeparator() : symbols.getDecimalSeparator();
+            char grouping = symbols.getGroupingSeparator();
+            String exponentText = symbols.getExponentSeparator();
+            boolean sawDecimal = false;
+            boolean sawDigit = false;
+            int exponent = 0;
+            int digitCount = 0;
+            int backup = -1;
+            for (; position < text.length(); position++) {
+                char ch = text.charAt(position);
+                int digit = digitValue(ch);
+                if (digit >= 0) {
+                    backup = -1;
+                    sawDigit = true;
+                    if (digit == 0 && digits.length() == 0) {
+                        // Leading zeros carry no digits, but after the
+                        // decimal point they shift it.
+                        if (sawDecimal) {
+                            decimalAt--;
+                        }
+                    } else {
+                        digitCount++;
+                        digits.append((char) ('0' + digit));
+                    }
+                } else if (ch == decimal) {
+                    if (isParseIntegerOnly() || sawDecimal) {
+                        break;
+                    }
+                    decimalAt = digitCount;
+                    sawDecimal = true;
+                } else if (ch == grouping && isGroupingUsed()) {
+                    if (sawDecimal) {
+                        break;
+                    }
+                    // A grouping separator must be followed by a digit; if
+                    // it is not, the number ended before it.
+                    backup = position;
+                } else if (exponentText.length() > 0 && matches(text, position, exponentText)) {
+                    int at = position + exponentText.length();
+                    boolean negativeExponent = false;
+                    if (at < text.length() && text.charAt(at) == symbols.getMinusSign()) {
+                        negativeExponent = true;
+                        at++;
+                    }
+                    int exponentStart = at;
+                    long parsed = 0;
+                    while (at < text.length() && digitValue(text.charAt(at)) >= 0) {
+                        if (parsed < 100000000L) {
+                            parsed = parsed * 10 + digitValue(text.charAt(at));
+                        }
+                        at++;
+                    }
+                    if (at > exponentStart) {
+                        exponent = (int) (negativeExponent ? -parsed : parsed);
+                        position = at;
+                    }
+                    break;
+                } else {
+                    break;
+                }
+            }
+            if (backup != -1) {
+                position = backup;
+            }
+            if (!sawDecimal) {
+                decimalAt = digitCount;
+            }
+            decimalAt += exponent;
+            if (!sawDigit) {
+                // As in the JDK, a prefix with no number after it is reported
+                // at the start of the prefix.
+                pos.setErrorIndex(start);
+                return null;
+            }
+        }
+
+        if (gotPositive) {
+            gotPositive = matches(text, position, positiveSuffix);
+        }
+        if (gotNegative) {
+            gotNegative = matches(text, position, negativeSuffix);
+        }
+        if (gotPositive && gotNegative) {
+            if (positiveSuffix.length() > negativeSuffix.length()) {
+                gotNegative = false;
+            } else if (positiveSuffix.length() < negativeSuffix.length()) {
+                gotPositive = false;
+            }
+        }
+        if (gotPositive == gotNegative) {
+            pos.setErrorIndex(position);
+            return null;
+        }
+        position += gotPositive ? positiveSuffix.length() : negativeSuffix.length();
+        pos.setIndex(position);
+
+        if (infinite) {
+            boolean positiveResult = gotPositive == (multiplier >= 0);
+            return Double.valueOf(positiveResult ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY);
+        }
+        return toNumber(digits, decimalAt, gotPositive);
+    }
+
+    private static final String LONG_MIN_DIGITS = "9223372036854775808";
+
+    /// Whether these digits, an integer with `decimalAt` digits before the
+    /// point, fit a `long` of the given sign.
+    private static boolean fitsLong(StringBuilder digits, int decimalAt, boolean positive) {
+        int count = digits.length();
+        if (decimalAt < count || decimalAt > LONG_MIN_DIGITS.length()) {
+            return false;
+        }
+        if (decimalAt < LONG_MIN_DIGITS.length()) {
+            return true;
+        }
+        for (int i = 0; i < count; i++) {
+            char mine = digits.charAt(i);
+            char limit = LONG_MIN_DIGITS.charAt(i);
+            if (mine > limit) {
+                return false;
+            }
+            if (mine < limit) {
+                return true;
+            }
+        }
+        if (count < decimalAt) {
+            return true;
+        }
+        // Exactly the magnitude of Long.MIN_VALUE.
+        return !positive;
+    }
+
+    private Number toNumber(StringBuilder digits, int decimalAt, boolean positive) {
+        while (digits.length() > 0 && digits.charAt(digits.length() - 1) == '0') {
+            digits.setLength(digits.length() - 1);
+        }
+        boolean gotDouble;
+        long longResult = 0;
+        double doubleResult = 0.0;
+        if (digits.length() == 0) {
+            if (positive || isParseIntegerOnly()) {
+                gotDouble = false;
+            } else {
+                gotDouble = true;
+                doubleResult = -0.0;
+            }
+        } else if (fitsLong(digits, decimalAt, positive)) {
+            gotDouble = false;
+            StringBuilder sb = new StringBuilder();
+            if (!positive) {
+                sb.append('-');
+            }
+            sb.append(digits.toString());
+            for (int i = digits.length(); i < decimalAt; i++) {
+                sb.append('0');
+            }
+            longResult = Long.parseLong(sb.toString());
+        } else if (decimalAt > 309) {
+            // At least ten to the 309th, past Double.MAX_VALUE: the JDK
+            // answers an infinity. Settled here rather than handed to
+            // Double.parseDouble, which on some ports answers 0.0 for an
+            // exponent this large.
+            gotDouble = true;
+            doubleResult = positive ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+        } else if (decimalAt < -323) {
+            // Below ten to the -324th, under half of Double.MIN_VALUE: the
+            // JDK answers a zero of the parsed sign.
+            gotDouble = true;
+            doubleResult = positive ? 0.0 : -0.0;
+        } else {
+            gotDouble = true;
+            StringBuilder sb = new StringBuilder();
+            if (!positive) {
+                sb.append('-');
+            }
+            sb.append(digits.charAt(0)).append('.');
+            if (digits.length() > 1) {
+                sb.append(digits.toString().substring(1));
+            } else {
+                sb.append('0');
+            }
+            sb.append('E').append(decimalAt - 1);
+            doubleResult = Double.parseDouble(sb.toString());
+        }
+        // A multiplier of zero formats everything as zero; there is nothing
+        // to divide back by.
+        if (multiplier != 1 && multiplier != 0) {
+            if (gotDouble) {
+                doubleResult = doubleResult / multiplier;
+            } else if (longResult % multiplier == 0) {
+                longResult = longResult / multiplier;
+            } else {
+                doubleResult = (double) longResult / multiplier;
+                gotDouble = true;
+            }
+            if (gotDouble) {
+                long whole = (long) doubleResult;
+                boolean negativeZero = doubleResult == 0.0 && Double.doubleToLongBits(doubleResult) < 0;
+                if (doubleResult == (double) whole && !negativeZero) {
+                    gotDouble = false;
+                    longResult = whole;
+                } else if (isParseIntegerOnly()) {
+                    gotDouble = false;
+                    longResult = whole;
+                }
+            }
+        }
+        if (gotDouble) {
+            return Double.valueOf(doubleResult);
+        }
+        return Long.valueOf(longResult);
+    }
+
+    // ------------------------------------------------------------------
+    // Pattern
+    // ------------------------------------------------------------------
+
+    public void applyPattern(String pattern) {
+        parsePattern(pattern);
+    }
+
+    private static IllegalArgumentException malformed(String why, String pattern) {
+        return new IllegalArgumentException(why + " in pattern \"" + pattern + '"');
+    }
+
+    private static boolean isNumberChar(char ch) {
+        return ch == '#' || ch == '0' || ch == ',' || ch == '.';
+    }
+
+    private void parsePattern(String pattern) {
+        if (pattern == null) {
+            throw new NullPointerException();
+        }
+        int len = pattern.length();
+        boolean gotNegative = false;
+        boolean exponential = false;
+        boolean currency = false;
+        int exponentDigits = 0;
+        int newMultiplier = 1;
+        String newPosPrefix = "";
+        String newPosSuffix = "";
+        String newNegPrefix = "";
+        String newNegSuffix = "";
+        int digitLeftCount = 0;
+        int zeroDigitCount = 0;
+        int digitRightCount = 0;
+        int decimalPos = -1;
+        int groupingCount = -1;
+        int numberLength = 0;
+
+        int start = 0;
+        for (int part = 0; part < 2 && start < len; part++) {
+            boolean positive = part == 0;
+            StringBuilder prefix = new StringBuilder();
+            StringBuilder suffix = new StringBuilder();
+            StringBuilder affix = prefix;
+            int phase = 0;
+            boolean inQuote = false;
+            boolean sawSeparator = false;
+            int partMultiplier = 1;
+            int toSkip = numberLength;
+            int pos = start;
+            while (pos < len) {
+                char ch = pattern.charAt(pos);
+                if (phase == 1) {
+                    if (!positive) {
+                        // Only the affixes of the negative subpattern count;
+                        // its number is skipped, as long as the positive one.
+                        if (toSkip > 0) {
+                            toSkip--;
+                            pos++;
+                            continue;
+                        }
+                        phase = 2;
+                        affix = suffix;
+                        continue;
+                    }
+                    if (ch == '#') {
+                        if (zeroDigitCount > 0) {
+                            digitRightCount++;
+                        } else {
+                            digitLeftCount++;
+                        }
+                        if (groupingCount >= 0 && decimalPos < 0) {
+                            groupingCount++;
+                        }
+                    } else if (ch == '0') {
+                        if (digitRightCount > 0) {
+                            throw malformed("Unexpected '0'", pattern);
+                        }
+                        zeroDigitCount++;
+                        if (groupingCount >= 0 && decimalPos < 0) {
+                            groupingCount++;
+                        }
+                    } else if (ch == ',') {
+                        groupingCount = 0;
+                    } else if (ch == '.') {
+                        if (decimalPos >= 0) {
+                            throw malformed("Multiple decimal separators", pattern);
+                        }
+                        decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
+                    } else if (ch == 'E') {
+                        if (exponential) {
+                            throw malformed("Multiple exponential symbols", pattern);
+                        }
+                        exponential = true;
+                        exponentDigits = 0;
+                        while (pos + 1 < len && pattern.charAt(pos + 1) == '0') {
+                            exponentDigits++;
+                            numberLength++;
+                            pos++;
+                        }
+                        if (digitLeftCount + zeroDigitCount < 1 || exponentDigits < 1) {
+                            throw malformed("Malformed exponential pattern", pattern);
+                        }
+                        numberLength++;
+                        pos++;
+                        phase = 2;
+                        affix = suffix;
+                        continue;
+                    } else {
+                        phase = 2;
+                        affix = suffix;
+                        continue;
+                    }
+                    numberLength++;
+                    pos++;
+                    continue;
+                }
+                // A prefix or a suffix.
+                if (inQuote) {
+                    if (ch == QUOTE) {
+                        if (pos + 1 < len && pattern.charAt(pos + 1) == QUOTE) {
+                            pos++;
+                            affix.append("''");
+                        } else {
+                            inQuote = false;
+                        }
+                        pos++;
+                        continue;
+                    }
+                } else if (isNumberChar(ch)) {
+                    // In a suffix too: the JDK goes back to reading the
+                    // number, so "0.0x0" is "0.00x", and this does the same
+                    // rather than reject a pattern the desktop accepts.
+                    if (phase == 2 && !positive) {
+                        pos = len;
+                        continue;
+                    }
+                    phase = 1;
+                    continue;
+                } else if (ch == CURRENCY_SIGN) {
+                    boolean doubled = pos + 1 < len && pattern.charAt(pos + 1) == CURRENCY_SIGN;
+                    if (doubled) {
+                        pos++;
+                    }
+                    currency = true;
+                    affix.append(QUOTE).append(CURRENCY_SIGN);
+                    if (doubled) {
+                        affix.append(CURRENCY_SIGN);
+                    }
+                    pos++;
+                    continue;
+                } else if (ch == QUOTE) {
+                    if (pos + 1 < len && pattern.charAt(pos + 1) == QUOTE) {
+                        pos++;
+                        affix.append("''");
+                    } else {
+                        inQuote = true;
+                    }
+                    pos++;
+                    continue;
+                } else if (ch == ';') {
+                    if (phase == 0 || !positive) {
+                        throw malformed("Unquoted special character ';'", pattern);
+                    }
+                    sawSeparator = true;
+                    pos++;
+                    break;
+                } else if (ch == '%' || ch == PER_MILLE_SIGN) {
+                    if (partMultiplier != 1) {
+                        throw malformed("Too many percent/per mille characters", pattern);
+                    }
+                    partMultiplier = ch == '%' ? 100 : 1000;
+                    if (positive) {
+                        newMultiplier = partMultiplier;
+                    }
+                    affix.append(QUOTE).append(ch);
+                    pos++;
+                    continue;
+                } else if (ch == '-') {
+                    affix.append(QUOTE).append('-');
+                    pos++;
+                    continue;
+                }
+                affix.append(ch);
+                pos++;
+            }
+            if (inQuote) {
+                throw malformed("Unterminated quote", pattern);
+            }
+            if (positive) {
+                newPosPrefix = prefix.toString();
+                newPosSuffix = suffix.toString();
+            } else {
+                newNegPrefix = prefix.toString();
+                newNegSuffix = suffix.toString();
+                gotNegative = true;
+            }
+            // Without a separator the whole pattern is read again as the
+            // negative one. Its affixes then equal the positive ones, which
+            // is what selects the default minus sign below.
+            start = sawSeparator ? pos : 0;
+        }
+
+        if (len == 0) {
+            useExponentialNotation = false;
+            minExponentDigits = 0;
+            currencyFormat = false;
+            decimalSeparatorAlwaysShown = false;
+            setMinimumIntegerDigits(0);
+            setMaximumIntegerDigits(Integer.MAX_VALUE);
+            setMinimumFractionDigits(0);
+            setMaximumFractionDigits(Integer.MAX_VALUE);
+        } else {
+            if (zeroDigitCount == 0 && digitLeftCount > 0 && decimalPos >= 0) {
+                // "#.##", "#." and ".#" have one digit that is always
+                // written; it is the one next to the decimal point.
+                int n = decimalPos;
+                if (n == 0) {
+                    n++;
+                }
+                digitRightCount = digitLeftCount - n;
+                digitLeftCount = n - 1;
+                zeroDigitCount = 1;
+            }
+            if ((decimalPos < 0 && digitRightCount > 0)
+                    || (decimalPos >= 0
+                            && (decimalPos < digitLeftCount || decimalPos > digitLeftCount + zeroDigitCount))
+                    || groupingCount == 0) {
+                throw malformed("Malformed pattern", pattern);
+            }
+            int digitTotalCount = digitLeftCount + zeroDigitCount + digitRightCount;
+            if (decimalPos > digitTotalCount) {
+                decimalPos = digitTotalCount;
+            }
+            int effectiveDecimalPos = decimalPos >= 0 ? decimalPos : digitTotalCount;
+            useExponentialNotation = exponential;
+            minExponentDigits = exponentDigits;
+            // Reset first, so that neither setter is clamped by a previous
+            // pattern's limits.
+            setMinimumIntegerDigits(0);
+            setMinimumFractionDigits(0);
+            int minInt = effectiveDecimalPos - digitLeftCount;
+            setMaximumIntegerDigits(exponential ? digitLeftCount + minInt : Integer.MAX_VALUE);
+            setMinimumIntegerDigits(minInt);
+            setMaximumFractionDigits(decimalPos >= 0 ? digitTotalCount - decimalPos : 0);
+            setMinimumFractionDigits(decimalPos >= 0 ? digitLeftCount + zeroDigitCount - decimalPos : 0);
+            setGroupingUsed(groupingCount > 0);
+            groupingSize = groupingCount > 0 ? groupingCount : 0;
+            multiplier = newMultiplier;
+            currencyFormat = currency;
+            decimalSeparatorAlwaysShown = decimalPos == 0 || decimalPos == digitTotalCount;
+        }
+        posPrefixPattern = newPosPrefix;
+        posSuffixPattern = newPosSuffix;
+        // No negative subpattern, or one that says nothing new, means a
+        // minus sign in front of the positive one.
+        if (!gotNegative || (newNegPrefix.equals(newPosPrefix) && newNegSuffix.equals(newPosSuffix))) {
+            negPrefixPattern = "'-" + newPosPrefix;
+            negSuffixPattern = newPosSuffix;
+        } else {
+            negPrefixPattern = newNegPrefix;
+            negSuffixPattern = newNegSuffix;
+        }
+        expandAffixes();
+    }
+
+    private void expandAffixes() {
+        positivePrefix = expandAffix(posPrefixPattern);
+        positiveSuffix = expandAffix(posSuffixPattern);
+        negativePrefix = expandAffix(negPrefixPattern);
+        negativeSuffix = expandAffix(negSuffixPattern);
+    }
+
+    private String expandAffix(String internal) {
+        if (internal.indexOf(QUOTE) < 0) {
+            return internal;
+        }
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        while (i < internal.length()) {
+            char c = internal.charAt(i++);
+            if (c != QUOTE || i >= internal.length()) {
+                sb.append(c);
+                continue;
+            }
+            c = internal.charAt(i++);
+            if (c == CURRENCY_SIGN) {
+                if (i < internal.length() && internal.charAt(i) == CURRENCY_SIGN) {
+                    i++;
+                    sb.append(symbols.getInternationalCurrencySymbol());
+                } else {
+                    sb.append(symbols.getCurrencySymbol());
+                }
+            } else if (c == '%') {
+                sb.append(symbols.getPercent());
+            } else if (c == PER_MILLE_SIGN) {
+                sb.append(symbols.getPerMill());
+            } else if (c == '-') {
+                sb.append(symbols.getMinusSign());
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static String literalAffix(String literal) {
+        if (literal.indexOf(QUOTE) < 0) {
+            return literal;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < literal.length(); i++) {
+            char c = literal.charAt(i);
+            sb.append(c);
+            if (c == QUOTE) {
+                sb.append(QUOTE);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static boolean needsQuoting(char c) {
+        return isNumberChar(c) || c == ';' || c == '%' || c == PER_MILLE_SIGN || c == CURRENCY_SIGN
+                || c == '-';
+    }
+
+    private static void appendAffixPattern(StringBuilder out, String internal) {
+        int i = 0;
+        while (i < internal.length()) {
+            char c = internal.charAt(i++);
+            if (c == QUOTE && i < internal.length()) {
+                c = internal.charAt(i++);
+                if (c == QUOTE) {
+                    out.append("''");
+                } else {
+                    out.append(c);
+                    if (c == CURRENCY_SIGN && i < internal.length() && internal.charAt(i) == CURRENCY_SIGN) {
+                        out.append(CURRENCY_SIGN);
+                        i++;
+                    }
+                }
+            } else if (needsQuoting(c)) {
+                out.append(QUOTE).append(c).append(QUOTE);
+            } else {
+                out.append(c);
+            }
+        }
+    }
+
+    private void appendNumberPattern(StringBuilder out) {
+        int minInt = getMinimumIntegerDigits();
+        // Capped: an empty pattern allows any number of fraction digits, and
+        // spelling that out exhausts memory, as it does in the JDK.
+        int maxFrac = Math.min(getMaximumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        int minFrac = Math.min(getMinimumFractionDigits(), DOUBLE_FRACTION_DIGITS);
+        boolean grouping = isGroupingUsed() && groupingSize > 0;
+        int digitCount = useExponentialNotation
+                ? getMaximumIntegerDigits()
+                : Math.max(groupingSize, minInt) + 1;
+        for (int i = digitCount; i > 0; i--) {
+            // groupingSize is checked positive just above.
+            if (i != digitCount && grouping && i % groupingSize == 0) {
+                out.append(',');
+            }
+            out.append(i <= minInt ? '0' : '#');
+        }
+        if (maxFrac > 0 || decimalSeparatorAlwaysShown) {
+            out.append('.');
+        }
+        for (int i = 0; i < maxFrac; i++) {
+            out.append(i < minFrac ? '0' : '#');
+        }
+        if (useExponentialNotation) {
+            out.append('E');
+            for (int i = 0; i < minExponentDigits; i++) {
+                out.append('0');
+            }
+        }
+    }
+
+    /// A pattern that produces this format. It is equivalent to the pattern
+    /// that was applied, not necessarily the same text: `0.00` comes back as
+    /// `#0.00`.
+    public String toPattern() {
+        StringBuilder out = new StringBuilder();
+        appendAffixPattern(out, posPrefixPattern);
+        appendNumberPattern(out);
+        appendAffixPattern(out, posSuffixPattern);
+        boolean defaultNegative = negSuffixPattern.equals(posSuffixPattern)
+                && negPrefixPattern.equals("'-" + posPrefixPattern);
+        if (!defaultNegative) {
+            out.append(';');
+            appendAffixPattern(out, negPrefixPattern);
+            appendNumberPattern(out);
+            appendAffixPattern(out, negSuffixPattern);
+        }
+        return out.toString();
+    }
+
+    // ------------------------------------------------------------------
+    // Properties
+    // ------------------------------------------------------------------
+
+    /// A copy of the symbols in use; changing it changes nothing until it
+    /// is passed to [#setDecimalFormatSymbols(DecimalFormatSymbols)].
+    public DecimalFormatSymbols getDecimalFormatSymbols() {
+        Object copy = symbols.clone();
+        return copy instanceof DecimalFormatSymbols ? (DecimalFormatSymbols) copy : symbols;
+    }
+
+    public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols) {
+        Object copy = newSymbols.clone();
+        if (copy instanceof DecimalFormatSymbols) {
+            symbols = (DecimalFormatSymbols) copy;
+            expandAffixes();
+        }
+    }
+
+    public String getPositivePrefix() {
+        return positivePrefix;
+    }
+
+    public void setPositivePrefix(String newValue) {
+        positivePrefix = newValue;
+        posPrefixPattern = literalAffix(newValue);
+    }
+
+    public String getNegativePrefix() {
+        return negativePrefix;
+    }
+
+    public void setNegativePrefix(String newValue) {
+        negativePrefix = newValue;
+        negPrefixPattern = literalAffix(newValue);
+    }
+
+    public String getPositiveSuffix() {
+        return positiveSuffix;
+    }
+
+    public void setPositiveSuffix(String newValue) {
+        positiveSuffix = newValue;
+        posSuffixPattern = literalAffix(newValue);
+    }
+
+    public String getNegativeSuffix() {
+        return negativeSuffix;
+    }
+
+    public void setNegativeSuffix(String newValue) {
+        negativeSuffix = newValue;
+        negSuffixPattern = literalAffix(newValue);
+    }
+
+    public int getMultiplier() {
+        return multiplier;
+    }
+
+    public void setMultiplier(int newValue) {
+        multiplier = newValue;
+    }
+
+    public int getGroupingSize() {
+        return groupingSize;
+    }
+
+    public void setGroupingSize(int newValue) {
+        groupingSize = Math.max(0, newValue);
+    }
+
+    public boolean isDecimalSeparatorAlwaysShown() {
+        return decimalSeparatorAlwaysShown;
+    }
+
+    public void setDecimalSeparatorAlwaysShown(boolean newValue) {
+        decimalSeparatorAlwaysShown = newValue;
+    }
+
+    /// A copy of this format. Written out field by field: `Object.clone()`
+    /// answers `null` on the device for anything but an array.
+    @Override
+    public Object clone() {
+        DecimalFormat copy = new DecimalFormat("", symbols);
+        copyNumberFormatTo(copy);
+        copy.posPrefixPattern = posPrefixPattern;
+        copy.posSuffixPattern = posSuffixPattern;
+        copy.negPrefixPattern = negPrefixPattern;
+        copy.negSuffixPattern = negSuffixPattern;
+        copy.positivePrefix = positivePrefix;
+        copy.positiveSuffix = positiveSuffix;
+        copy.negativePrefix = negativePrefix;
+        copy.negativeSuffix = negativeSuffix;
+        copy.multiplier = multiplier;
+        copy.groupingSize = groupingSize;
+        copy.decimalSeparatorAlwaysShown = decimalSeparatorAlwaysShown;
+        copy.useExponentialNotation = useExponentialNotation;
+        copy.minExponentDigits = minExponentDigits;
+        copy.currencyFormat = currencyFormat;
+        return copy;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!super.equals(obj) || !(obj instanceof DecimalFormat)) {
+            return false;
+        }
+        DecimalFormat other = (DecimalFormat) obj;
+        return positivePrefix.equals(other.positivePrefix)
+                && positiveSuffix.equals(other.positiveSuffix)
+                && negativePrefix.equals(other.negativePrefix)
+                && negativeSuffix.equals(other.negativeSuffix)
+                && multiplier == other.multiplier
+                && groupingSize == other.groupingSize
+                && decimalSeparatorAlwaysShown == other.decimalSeparatorAlwaysShown
+                && useExponentialNotation == other.useExponentialNotation
+                && minExponentDigits == other.minExponentDigits
+                && symbols.equals(other.symbols);
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode() * 37 + positivePrefix.hashCode();
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/DecimalFormatSymbols.java b/vm/JavaAPI/src/java/text/DecimalFormatSymbols.java
new file mode 100644
index 00000000000..4941d026547
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/DecimalFormatSymbols.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.Locale;
+
+/// The characters a [DecimalFormat] writes and reads -- decimal and
+/// grouping separators, minus sign, percent, currency symbol and so on.
+///
+/// #### Where the symbols come from
+///
+/// The device library carries no locale data of its own. What it knows about
+/// the user's locale -- the decimal and grouping separators and the currency
+/// symbol -- it is told by the platform, which on a device reads them off
+/// numbers Codename One's `L10NManager` formatted. Everything the platform
+/// cannot tell (percent, per mille, the exponent separator, the infinity and
+/// not-a-number texts) is as in the US English locale.
+///
+/// A request that names `en_US` gets the US English symbols outright. Any
+/// other locale gets the device's symbols, since the device cannot format for
+/// a locale other than its own. Before Codename One is initialized, and where
+/// the platform answers nothing usable, the symbols are US English.
+public class DecimalFormatSymbols implements Cloneable, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private char zeroDigit = '0';
+    private char groupingSeparator = ',';
+    private char decimalSeparator = '.';
+    private char perMill = (char) 0x2030;
+    private char percent = '%';
+    private char digit = '#';
+    private char patternSeparator = ';';
+    private String infinity = String.valueOf((char) 0x221E);
+    private String nan = String.valueOf((char) 0xFFFD);
+    private char minusSign = '-';
+    private String currencySymbol = "$";
+    private String intlCurrencySymbol = "USD";
+    private char monetarySeparator = '.';
+    private String exponentSeparator = "E";
+
+    public DecimalFormatSymbols() {
+        this(Locale.getDefault());
+    }
+
+    public DecimalFormatSymbols(Locale locale) {
+        if (locale == null) {
+            throw new NullPointerException();
+        }
+        if (!isUsEnglish(locale)) {
+            readDeviceSymbols();
+        }
+    }
+
+    public static final DecimalFormatSymbols getInstance() {
+        return new DecimalFormatSymbols();
+    }
+
+    public static final DecimalFormatSymbols getInstance(Locale locale) {
+        return new DecimalFormatSymbols(locale);
+    }
+
+    private static boolean isUsEnglish(Locale locale) {
+        return "en".equals(locale.getLanguage()) && "US".equals(locale.getCountry());
+    }
+
+    private void readDeviceSymbols() {
+        String[] device;
+        try {
+            device = JdkHost.get().localeNumberSymbols();
+        } catch (RuntimeException e) {
+            // A port whose localization cannot answer leaves the US English
+            // symbols in place, which is the documented fallback.
+            return;
+        }
+        if (device == null || device.length < 3) {
+            return;
+        }
+        String decimal = device[0];
+        if (decimal != null && decimal.length() == 1) {
+            decimalSeparator = decimal.charAt(0);
+            monetarySeparator = decimalSeparator;
+        }
+        String grouping = device[1];
+        if (grouping != null && grouping.length() == 1 && grouping.charAt(0) != decimalSeparator) {
+            groupingSeparator = grouping.charAt(0);
+        } else if (decimalSeparator == ',') {
+            // A locale that writes a decimal comma and no grouping on this
+            // platform still must not group with the same character.
+            groupingSeparator = '.';
+        }
+        String currency = device[2];
+        if (currency != null && currency.length() > 0) {
+            currencySymbol = currency;
+            intlCurrencySymbol = currency;
+        }
+    }
+
+    public char getZeroDigit() {
+        return zeroDigit;
+    }
+
+    public void setZeroDigit(char zeroDigit) {
+        this.zeroDigit = zeroDigit;
+    }
+
+    public char getGroupingSeparator() {
+        return groupingSeparator;
+    }
+
+    public void setGroupingSeparator(char groupingSeparator) {
+        this.groupingSeparator = groupingSeparator;
+    }
+
+    public char getDecimalSeparator() {
+        return decimalSeparator;
+    }
+
+    public void setDecimalSeparator(char decimalSeparator) {
+        this.decimalSeparator = decimalSeparator;
+    }
+
+    public char getPerMill() {
+        return perMill;
+    }
+
+    public void setPerMill(char perMill) {
+        this.perMill = perMill;
+    }
+
+    public char getPercent() {
+        return percent;
+    }
+
+    public void setPercent(char percent) {
+        this.percent = percent;
+    }
+
+    public char getDigit() {
+        return digit;
+    }
+
+    public void setDigit(char digit) {
+        this.digit = digit;
+    }
+
+    public char getPatternSeparator() {
+        return patternSeparator;
+    }
+
+    public void setPatternSeparator(char patternSeparator) {
+        this.patternSeparator = patternSeparator;
+    }
+
+    public String getInfinity() {
+        return infinity;
+    }
+
+    public void setInfinity(String infinity) {
+        this.infinity = infinity;
+    }
+
+    public String getNaN() {
+        return nan;
+    }
+
+    public void setNaN(String nan) {
+        this.nan = nan;
+    }
+
+    public char getMinusSign() {
+        return minusSign;
+    }
+
+    public void setMinusSign(char minusSign) {
+        this.minusSign = minusSign;
+    }
+
+    public String getCurrencySymbol() {
+        return currencySymbol;
+    }
+
+    public void setCurrencySymbol(String currency) {
+        currencySymbol = currency;
+    }
+
+    public String getInternationalCurrencySymbol() {
+        return intlCurrencySymbol;
+    }
+
+    public void setInternationalCurrencySymbol(String currencyCode) {
+        intlCurrencySymbol = currencyCode;
+    }
+
+    public char getMonetaryDecimalSeparator() {
+        return monetarySeparator;
+    }
+
+    public void setMonetaryDecimalSeparator(char sep) {
+        monetarySeparator = sep;
+    }
+
+    public String getExponentSeparator() {
+        return exponentSeparator;
+    }
+
+    public void setExponentSeparator(String exp) {
+        if (exp == null) {
+            throw new NullPointerException();
+        }
+        exponentSeparator = exp;
+    }
+
+    /// A copy of these symbols. Written out field by field: `Object.clone()`
+    /// answers `null` on the device for anything but an array.
+    @Override
+    public Object clone() {
+        DecimalFormatSymbols copy = new DecimalFormatSymbols(new Locale("en", "US"));
+        copy.zeroDigit = zeroDigit;
+        copy.groupingSeparator = groupingSeparator;
+        copy.decimalSeparator = decimalSeparator;
+        copy.perMill = perMill;
+        copy.percent = percent;
+        copy.digit = digit;
+        copy.patternSeparator = patternSeparator;
+        copy.infinity = infinity;
+        copy.nan = nan;
+        copy.minusSign = minusSign;
+        copy.currencySymbol = currencySymbol;
+        copy.intlCurrencySymbol = intlCurrencySymbol;
+        copy.monetarySeparator = monetarySeparator;
+        copy.exponentSeparator = exponentSeparator;
+        return copy;
+    }
+
+    private static boolean same(String a, String b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof DecimalFormatSymbols)) {
+            return false;
+        }
+        DecimalFormatSymbols other = (DecimalFormatSymbols) obj;
+        return zeroDigit == other.zeroDigit
+                && groupingSeparator == other.groupingSeparator
+                && decimalSeparator == other.decimalSeparator
+                && percent == other.percent
+                && perMill == other.perMill
+                && digit == other.digit
+                && minusSign == other.minusSign
+                && patternSeparator == other.patternSeparator
+                && monetarySeparator == other.monetarySeparator
+                && same(infinity, other.infinity)
+                && same(nan, other.nan)
+                && same(currencySymbol, other.currencySymbol)
+                && same(intlCurrencySymbol, other.intlCurrencySymbol)
+                && same(exponentSeparator, other.exponentSeparator);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = zeroDigit;
+        result = result * 37 + groupingSeparator;
+        result = result * 37 + decimalSeparator;
+        return result;
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/FieldPosition.java b/vm/JavaAPI/src/java/text/FieldPosition.java
new file mode 100644
index 00000000000..aedd19d8be3
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/FieldPosition.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Names a field of formatted output and receives the range of characters that field took.
+/// `NumberFormat.INTEGER_FIELD` and `NumberFormat.FRACTION_FIELD` are the
+/// fields the number formats here report.
+public class FieldPosition {
+
+    private final int field;
+    private int beginIndex;
+    private int endIndex;
+
+    public FieldPosition(int field) {
+        this.field = field;
+    }
+
+    public int getField() {
+        return field;
+    }
+
+    public int getBeginIndex() {
+        return beginIndex;
+    }
+
+    public int getEndIndex() {
+        return endIndex;
+    }
+
+    public void setBeginIndex(int bi) {
+        beginIndex = bi;
+    }
+
+    public void setEndIndex(int ei) {
+        endIndex = ei;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof FieldPosition)) {
+            return false;
+        }
+        FieldPosition other = (FieldPosition) obj;
+        return field == other.field && beginIndex == other.beginIndex && endIndex == other.endIndex;
+    }
+
+    @Override
+    public int hashCode() {
+        return (field << 24) | (beginIndex << 16) | endIndex;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[field=" + field + ",attribute=null,beginIndex=" + beginIndex
+                + ",endIndex=" + endIndex + ']';
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/Format.java b/vm/JavaAPI/src/java/text/Format.java
index 832a46628a4..e3838fef3d4 100644
--- a/vm/JavaAPI/src/java/text/Format.java
+++ b/vm/JavaAPI/src/java/text/Format.java
@@ -6,43 +6,76 @@
  * published by the Free Software Foundation.  Codename One designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
- *  
+ *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
- * 
+ *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- * 
- * Please contact Codename One through http://www.codenameone.com/ if you 
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
 package java.text;
 
-/**
- * An abstract class for parsing and formatting localisation sensitive information, compatible with JDK 6.
- * 
- * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/text/Format.html">http://docs.oracle.com/javase/6/docs/api/java/text/Format.html</a>
- */
-public abstract class Format implements Cloneable {
-	/**
-	 * Format an object.
-	 * 
-	 * @param source object to be formatted to text.
-	 * @return formatted text.
-	 * @throws IllegalArgumentException if the source can not be formatted. 
-	 */
-	public abstract String format(Object source) throws IllegalArgumentException;
+/// The base of the formats that turn locale sensitive values into text and
+/// back: [DateFormat], [NumberFormat] and [MessageFormat].
+///
+/// A subclass implements [#format(Object, StringBuffer, FieldPosition)] and
+/// [#parseObject(String, ParsePosition)]; the one-argument forms are written
+/// over them, as in the JDK.
+///
+/// #### Differences from the JDK
+///
+/// - No `clone` here: `Object.clone()` answers `null` on the device for
+///   anything but an array, so every format of this package declares a
+///   `clone` that copies its own fields.
+/// - No `formatToCharacterIterator`: the device has no
+///   `AttributedCharacterIterator`.
+public abstract class Format implements Cloneable, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    protected Format() {
+    }
+
+    /// Formats an object to text.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if this format cannot format `obj`
+    public final String format(Object obj) {
+        return format(obj, new StringBuffer(), new FieldPosition(0)).toString();
+    }
+
+    /// Formats an object, appending the text to `toAppendTo`, and reports the
+    /// range the field `pos` names took.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if this format cannot format `obj`
+    public abstract StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos);
+
+    /// Parses an object from `source` starting at `pos`. On success the index
+    /// of `pos` is moved past what was read; on failure it is left alone, the
+    /// error index is set and `null` is returned.
+    public abstract Object parseObject(String source, ParsePosition pos);
 
-	/**
-	 * Parse an string to an object.
-	 * 
-	 * @param source document to be parsed.
-	 * @return parsed object.
-	 * @throws ParseException if the source could not be parsed.
-	 */
-	public abstract Object parseObject(String source) throws ParseException;
-}
\ No newline at end of file
+    /// Parses an object from the beginning of `source`.
+    ///
+    /// #### Throws
+    ///
+    /// - `ParseException`: if nothing at the beginning of `source` parses
+    public Object parseObject(String source) throws ParseException {
+        ParsePosition pos = new ParsePosition(0);
+        Object result = parseObject(source, pos);
+        if (pos.getIndex() == 0) {
+            throw new ParseException("Format.parseObject(String) failed", pos.getErrorIndex());
+        }
+        return result;
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/LegacyDoubleDigits.java b/vm/JavaAPI/src/java/text/LegacyDoubleDigits.java
new file mode 100644
index 00000000000..fa571f1d145
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/LegacyDoubleDigits.java
@@ -0,0 +1,547 @@
+/*
+ * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * Codename One note: this is a rewrite of the digit generation in OpenJDK's
+ * FloatingDecimal.BinaryToASCIIBuffer.dtoa (and the arithmetic it needs from
+ * FDBigInteger), reduced to what DecimalFormat uses and written against the
+ * JDK subset vm/JavaAPI and Ports/CLDC11 both provide. The decisions -- which
+ * path a value takes, the stopping tests, the rounding of the last digit --
+ * are OpenJDK's and are kept exactly, quirks included, because reproducing
+ * the JDK's output is the whole point of the class.
+ */
+package java.text;
+
+/// The decimal digits the JDK's `DecimalFormat` starts from when it formats a
+/// `double`.
+///
+/// That is NOT `Double.toString`. Since JDK-4511638 `Double.toString` writes
+/// the shortest string that round-trips, but `DecimalFormat` still takes its
+/// digits from the older `FloatingDecimal` conversion, which is not always the
+/// shortest: `1.0E23` comes out as `9.999999999999999E22`, and a value above
+/// two to the 53rd whose shortest form ends in zeros keeps its seventeenth
+/// digit (`7.2057594037927936E16`). Formatting from the shortest digits
+/// therefore disagrees with the desktop in the last digits of large numbers,
+/// so this class reproduces the old conversion.
+///
+/// The conversion picks one of three routes and the routes are NOT
+/// equivalent at their edges (`int` and `long` arithmetic use a strict
+/// stopping test where the big-integer route uses an inclusive one), so all
+/// three are kept rather than doing everything with big integers.
+final class LegacyDoubleDigits {
+    private static final int EXP_SHIFT = 52;
+    private static final long FRACT_HOB = 1L << EXP_SHIFT;
+    private static final long EXP_ONE = 1023L << EXP_SHIFT;
+    private static final long SIGNIF_BIT_MASK = FRACT_HOB - 1;
+    private static final int MAX_SMALL_BIN_EXP = 62;
+    private static final int MIN_SMALL_BIN_EXP = -(63 / 3);
+
+    private static final int[] SMALL_5_POW = new int[14];
+    private static final long[] LONG_5_POW = new long[27];
+
+    static {
+        SMALL_5_POW[0] = 1;
+        for (int i = 1; i < SMALL_5_POW.length; i++) {
+            SMALL_5_POW[i] = SMALL_5_POW[i - 1] * 5;
+        }
+        LONG_5_POW[0] = 1L;
+        for (int i = 1; i < LONG_5_POW.length; i++) {
+            LONG_5_POW[i] = LONG_5_POW[i - 1] * 5L;
+        }
+    }
+
+    /// Approximately `ceil(log2(5^i))`, as OpenJDK tabulates it; the route
+    /// choice depends on these exact values.
+    private static final int[] N_5_BITS = {
+        0, 3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31, 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59, 61
+    };
+
+    /// `insignificantDigits(1L << i)`: how many low decimal digits of an
+    /// integer value are below its precision.
+    private static final int[] INSIGNIFICANT_DIGITS_NUMBER = {
+        0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3,
+        4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7,
+        8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 11, 11, 11,
+        12, 12, 12, 12, 13, 13, 13, 14, 14, 14,
+        15, 15, 15, 15, 16, 16, 16, 17, 17, 17,
+        18, 18, 18, 19
+    };
+
+    /// The digits, `digits[first]` to `digits[first + count - 1]`.
+    final char[] digits = new char[24];
+    int first;
+    int count;
+    /// The position of the decimal point relative to the first digit:
+    /// the value is `0.d1d2d3... * 10^decExponent`.
+    int decExponent;
+
+    /// Converts a finite, strictly positive value.
+    LegacyDoubleDigits(double value) {
+        long bits = Double.doubleToLongBits(value);
+        long fractBits = bits & SIGNIF_BIT_MASK;
+        int binExp = (int) ((bits >> EXP_SHIFT) & 0x7ffL);
+        int nSignificantBits;
+        if (binExp == 0) {
+            // Subnormal: normalize so the high-order bit sits at EXP_SHIFT.
+            int leadingZeros = Long.numberOfLeadingZeros(fractBits);
+            int shift = leadingZeros - (63 - EXP_SHIFT);
+            fractBits <<= shift;
+            binExp = 1 - shift;
+            nSignificantBits = 64 - leadingZeros;
+        } else {
+            fractBits |= FRACT_HOB;
+            nSignificantBits = EXP_SHIFT + 1;
+        }
+        binExp -= 1023;
+        dtoa(binExp, fractBits, nSignificantBits);
+    }
+
+    private void developLongDigits(int decExp, long lvalue, int insignificantDigits) {
+        if (insignificantDigits != 0) {
+            // Drop the digits below the value's precision, rounding.
+            long pow10 = LONG_5_POW[insignificantDigits] << insignificantDigits;
+            long residue = lvalue % pow10;
+            lvalue /= pow10;
+            decExp += insignificantDigits;
+            if (residue >= (pow10 >> 1)) {
+                lvalue++;
+            }
+        }
+        int digitno = digits.length - 1;
+        int c = (int) (lvalue % 10L);
+        lvalue /= 10L;
+        while (c == 0) {
+            decExp++;
+            c = (int) (lvalue % 10L);
+            lvalue /= 10L;
+        }
+        while (lvalue != 0L) {
+            digits[digitno--] = (char) (c + '0');
+            decExp++;
+            c = (int) (lvalue % 10L);
+            lvalue /= 10L;
+        }
+        digits[digitno] = (char) (c + '0');
+        decExponent = decExp + 1;
+        first = digitno;
+        count = digits.length - digitno;
+    }
+
+    private void dtoa(int binExp, long fractBits, int nSignificantBits) {
+        final int tailZeros = Long.numberOfTrailingZeros(fractBits);
+        final int nFractBits = EXP_SHIFT + 1 - tailZeros;
+        int nTinyBits = Math.max(0, nFractBits - binExp - 1);
+        if (binExp <= MAX_SMALL_BIN_EXP && binExp >= MIN_SMALL_BIN_EXP
+                && nTinyBits < LONG_5_POW.length && nFractBits + N_5_BITS[nTinyBits] < 64
+                && nTinyBits == 0) {
+            // An integer that fits a long: its digits, less the ones below
+            // its precision.
+            int insignificant = 0;
+            if (binExp > nSignificantBits) {
+                int p2 = binExp - nSignificantBits - 1;
+                if (p2 > 1 && p2 < INSIGNIFICANT_DIGITS_NUMBER.length) {
+                    insignificant = INSIGNIFICANT_DIGITS_NUMBER[p2];
+                }
+            }
+            if (binExp >= EXP_SHIFT) {
+                fractBits <<= (binExp - EXP_SHIFT);
+            } else {
+                fractBits >>>= (EXP_SHIFT - binExp);
+            }
+            developLongDigits(0, fractBits, insignificant);
+            return;
+        }
+        // value = (B / S) * 10^decExp with 1 <= B / S < 10, and M is half an
+        // ULP scaled like B; digits are developed until the remainder is
+        // within M of either neighbour.
+        int decExp = estimateDecExp(fractBits, binExp);
+        int b5 = Math.max(0, -decExp);
+        int b2 = b5 + nTinyBits + binExp;
+        int s5 = Math.max(0, decExp);
+        int s2 = s5 + nTinyBits;
+        int m5 = b5;
+        int m2 = b2 - nSignificantBits;
+
+        fractBits >>>= tailZeros;
+        b2 -= nFractBits - 1;
+        int common2factor = Math.min(b2, s2);
+        b2 -= common2factor;
+        s2 -= common2factor;
+        m2 -= common2factor;
+        // Below an exact power of two the next smaller double is only half
+        // as far away.
+        if (nFractBits == 1) {
+            m2 -= 1;
+        }
+        if (m2 < 0) {
+            b2 -= m2;
+            s2 -= m2;
+            m2 = 0;
+        }
+
+        int ndigit = 0;
+        boolean low;
+        boolean high;
+        long lowDigitDifference;
+        int q;
+        int bBits = nFractBits + b2 + (b5 < N_5_BITS.length ? N_5_BITS[b5] : b5 * 3);
+        int tenSBits = s2 + 1 + (s5 + 1 < N_5_BITS.length ? N_5_BITS[s5 + 1] : (s5 + 1) * 3);
+        if (bBits < 64 && tenSBits < 64) {
+            if (bBits < 32 && tenSBits < 32) {
+                int b = ((int) fractBits * SMALL_5_POW[b5]) << b2;
+                int s = SMALL_5_POW[s5] << s2;
+                int m = SMALL_5_POW[m5] << m2;
+                int tens = s * 10;
+                q = b / s;
+                b = 10 * (b % s);
+                m *= 10;
+                low = b < m;
+                high = b + m > tens;
+                if (q == 0 && !high) {
+                    // The exponent estimate was one too high.
+                    decExp--;
+                } else {
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                // Java's E-form always shows a digit after the point, so
+                // outside the plain-notation range a second digit is forced.
+                if (decExp < -3 || decExp >= 8) {
+                    high = false;
+                    low = false;
+                }
+                while (!low && !high) {
+                    q = b / s;
+                    b = 10 * (b % s);
+                    m *= 10;
+                    if (m > 0) {
+                        low = b < m;
+                        high = b + m > tens;
+                    } else {
+                        // m overflowed, so it certainly exceeds both tests.
+                        low = true;
+                        high = true;
+                    }
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                lowDigitDifference = (b << 1) - tens;
+            } else {
+                long b = (fractBits * LONG_5_POW[b5]) << b2;
+                long s = LONG_5_POW[s5] << s2;
+                long m = LONG_5_POW[m5] << m2;
+                long tens = s * 10L;
+                q = (int) (b / s);
+                b = 10L * (b % s);
+                m *= 10L;
+                low = b < m;
+                high = b + m > tens;
+                if (q == 0 && !high) {
+                    decExp--;
+                } else {
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                if (decExp < -3 || decExp >= 8) {
+                    high = false;
+                    low = false;
+                }
+                while (!low && !high) {
+                    q = (int) (b / s);
+                    b = 10 * (b % s);
+                    m *= 10;
+                    if (m > 0L) {
+                        low = b < m;
+                        high = b + m > tens;
+                    } else {
+                        low = true;
+                        high = true;
+                    }
+                    digits[ndigit++] = (char) ('0' + q);
+                }
+                lowDigitDifference = (b << 1) - tens;
+            }
+        } else {
+            // OpenJDK normalizes these by a common power of two first to
+            // speed its division; that scales every comparison equally, so
+            // it is left out. Note the HIGH test here is inclusive (>=),
+            // unlike the int and long routes above.
+            Big sVal = Big.pow52(s5, s2);
+            Big bVal = Big.pow52(0, 0);
+            bVal.multiplyLong(fractBits);
+            bVal.multiplyPow5(b5);
+            bVal.shiftLeft(b2);
+            Big mVal = Big.pow52(m5 + 1, m2 + 1);
+            Big tenSVal = Big.pow52(s5 + 1, s2 + 1);
+            q = bVal.quoRemIteration(sVal);
+            low = bVal.compareTo(mVal) < 0;
+            high = tenSVal.compareToSum(bVal, mVal) <= 0;
+            if (q == 0 && !high) {
+                decExp--;
+            } else {
+                digits[ndigit++] = (char) ('0' + q);
+            }
+            if (decExp < -3 || decExp >= 8) {
+                high = false;
+                low = false;
+            }
+            while (!low && !high) {
+                q = bVal.quoRemIteration(sVal);
+                mVal.multiplySmall(10);
+                low = bVal.compareTo(mVal) < 0;
+                high = tenSVal.compareToSum(bVal, mVal) <= 0;
+                digits[ndigit++] = (char) ('0' + q);
+            }
+            if (high && low) {
+                bVal.shiftLeft(1);
+                lowDigitDifference = bVal.compareTo(tenSVal);
+            } else {
+                lowDigitDifference = 0L;
+            }
+        }
+        decExponent = decExp + 1;
+        first = 0;
+        count = ndigit;
+        // The last digit is rounded by the stopping condition.
+        if (high) {
+            if (low) {
+                if (lowDigitDifference == 0L) {
+                    if ((digits[first + count - 1] & 1) != 0) {
+                        roundup();
+                    }
+                } else if (lowDigitDifference > 0) {
+                    roundup();
+                }
+            } else {
+                roundup();
+            }
+        }
+    }
+
+    private void roundup() {
+        int i = first + count - 1;
+        int q = digits[i];
+        if (q == '9') {
+            while (q == '9' && i > first) {
+                digits[i] = '0';
+                q = digits[--i];
+            }
+            if (q == '9') {
+                decExponent += 1;
+                digits[first] = '1';
+                return;
+            }
+        }
+        digits[i] = (char) (q + 1);
+    }
+
+    /// Estimates `floor(log10(value))` from a linear approximation of
+    /// `log10` over the mantissa; it may come out one too high, which the
+    /// first digit corrects.
+    private static int estimateDecExp(long fractBits, int binExp) {
+        double d2 = Double.longBitsToDouble(EXP_ONE | (fractBits & SIGNIF_BIT_MASK));
+        double d = (d2 - 1.5D) * 0.289529654D + 0.176091259 + (double) binExp * 0.301029995663981;
+        long dBits = Double.doubleToLongBits(d);
+        int exponent = (int) ((dBits >> EXP_SHIFT) & 0x7ffL) - 1023;
+        boolean isNegative = dBits < 0;
+        if (exponent >= 0 && exponent < 52) {
+            long mask = SIGNIF_BIT_MASK >> exponent;
+            int r = (int) (((dBits & SIGNIF_BIT_MASK) | FRACT_HOB) >> (EXP_SHIFT - exponent));
+            return isNegative ? (((mask & dBits) == 0L) ? -r : -r - 1) : r;
+        } else if (exponent < 0) {
+            return ((dBits & ~(1L << 63)) == 0) ? 0 : (isNegative ? -1 : 0);
+        } else {
+            return (int) d;
+        }
+    }
+
+    /// A non-negative integer of any size: little-endian 32-bit words held
+    /// in an `int[]`, worked on through `long`s. Only the operations the
+    /// digit loop needs.
+    private static final class Big {
+        private static final long MASK = 0xffffffffL;
+        private int[] words = new int[8];
+        private int length;
+
+        static Big pow52(int p5, int p2) {
+            Big b = new Big();
+            b.words[0] = 1;
+            b.length = 1;
+            b.multiplyPow5(p5);
+            b.shiftLeft(p2);
+            return b;
+        }
+
+        private void ensure(int size) {
+            if (size > words.length) {
+                int[] bigger = new int[Math.max(size, words.length * 2)];
+                System.arraycopy(words, 0, bigger, 0, length);
+                words = bigger;
+            }
+        }
+
+        private void trim() {
+            while (length > 0 && words[length - 1] == 0) {
+                length--;
+            }
+        }
+
+        /// Multiplies by a non-negative factor below two to the 31st.
+        void multiplySmall(int factor) {
+            long carry = 0;
+            for (int i = 0; i < length; i++) {
+                long v = (words[i] & MASK) * factor + carry;
+                words[i] = (int) v;
+                carry = v >>> 32;
+            }
+            if (carry != 0) {
+                ensure(length + 1);
+                words[length++] = (int) carry;
+            }
+        }
+
+        /// Multiplies by a non-negative long.
+        void multiplyLong(long factor) {
+            int lowFactor = (int) (factor & 0x7fffffffL);
+            long high = factor >>> 31;
+            if (high == 0) {
+                multiplySmall(lowFactor);
+                return;
+            }
+            Big highPart = copy();
+            highPart.multiplyLong(high);
+            highPart.shiftLeft(31);
+            multiplySmall(lowFactor);
+            add(highPart);
+        }
+
+        void multiplyPow5(int p5) {
+            int left = p5;
+            while (left >= 13) {
+                multiplySmall(SMALL_5_POW[13]);
+                left -= 13;
+            }
+            if (left > 0) {
+                multiplySmall(SMALL_5_POW[left]);
+            }
+        }
+
+        void shiftLeft(int bits) {
+            if (length == 0 || bits == 0) {
+                return;
+            }
+            int wordShift = bits >>> 5;
+            int bitShift = bits & 31;
+            ensure(length + wordShift + 1);
+            if (bitShift == 0) {
+                // The extra top word is counted below; a word left over from
+                // an earlier, larger value must not survive in it.
+                words[length + wordShift] = 0;
+                for (int i = length - 1; i >= 0; i--) {
+                    words[i + wordShift] = words[i];
+                }
+            } else {
+                words[length + wordShift] = words[length - 1] >>> (32 - bitShift);
+                for (int i = length - 1; i > 0; i--) {
+                    words[i + wordShift] = (words[i] << bitShift) | (words[i - 1] >>> (32 - bitShift));
+                }
+                words[wordShift] = words[0] << bitShift;
+            }
+            for (int i = 0; i < wordShift; i++) {
+                words[i] = 0;
+            }
+            length += wordShift + 1;
+            trim();
+        }
+
+        private Big copy() {
+            Big c = new Big();
+            c.ensure(length);
+            System.arraycopy(words, 0, c.words, 0, length);
+            c.length = length;
+            return c;
+        }
+
+        void add(Big other) {
+            int size = Math.max(length, other.length);
+            ensure(size + 1);
+            long carry = 0;
+            for (int i = 0; i < size; i++) {
+                long a = i < length ? (words[i] & MASK) : 0L;
+                long b = i < other.length ? (other.words[i] & MASK) : 0L;
+                long v = a + b + carry;
+                words[i] = (int) v;
+                carry = v >>> 32;
+            }
+            length = size;
+            if (carry != 0) {
+                words[length++] = (int) carry;
+            }
+        }
+
+        /// Subtracts a value no greater than this one.
+        private void subtract(Big other) {
+            long borrow = 0;
+            for (int i = 0; i < length; i++) {
+                long b = i < other.length ? (other.words[i] & MASK) : 0L;
+                long v = (words[i] & MASK) - b - borrow;
+                words[i] = (int) v;
+                borrow = v < 0 ? 1 : 0;
+            }
+            trim();
+        }
+
+        int compareTo(Big other) {
+            if (length != other.length) {
+                return length < other.length ? -1 : 1;
+            }
+            for (int i = length - 1; i >= 0; i--) {
+                long a = words[i] & MASK;
+                long b = other.words[i] & MASK;
+                if (a != b) {
+                    return a < b ? -1 : 1;
+                }
+            }
+            return 0;
+        }
+
+        /// The sign of this minus `(x + y)`.
+        int compareToSum(Big x, Big y) {
+            Big sum = x.copy();
+            sum.add(y);
+            return compareTo(sum);
+        }
+
+        /// `q = this / s; this = 10 * (this % s)`, returning `q`. The
+        /// quotient is a single decimal digit, so repeated subtraction is
+        /// both exact and cheap.
+        int quoRemIteration(Big s) {
+            int q = 0;
+            while (compareTo(s) >= 0) {
+                subtract(s);
+                q++;
+            }
+            multiplySmall(10);
+            return q;
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/MessageFormat.java b/vm/JavaAPI/src/java/text/MessageFormat.java
new file mode 100644
index 00000000000..66f627a0ca5
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/MessageFormat.java
@@ -0,0 +1,627 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/// Builds a message from a pattern and a list of arguments, and reads the
+/// arguments back out of a message.
+///
+/// #### Pattern syntax
+///
+/// Text is copied as it is, and each `{...}` element is replaced by an
+/// argument:
+///
+/// - `{0}`: the argument at that index. A `Number` is formatted with
+///   `NumberFormat.getInstance`, a `Date` with the short date and time
+///   format, a `String` is copied, anything else contributes `toString()`.
+/// - `{0,number}`, `{0,number,integer}`, `{0,number,percent}`,
+///   `{0,number,currency}`, or `{0,number,#,##0.00}` with a [DecimalFormat]
+///   pattern.
+/// - `{0,date}` and `{0,time}`, optionally followed by `short`, `medium`,
+///   `long` or `full`, or by a `SimpleDateFormat` pattern:
+///   `{0,date,yyyy-MM-dd}`. The device's own `java.text.DateFormat` does the
+///   formatting, so the named styles produce what the device produces.
+/// - `{0,choice,0#none|1#one|1<{0} items}` with a [ChoiceFormat] pattern.
+///   If the chosen text has elements of its own, they are formatted against
+///   the same arguments.
+///
+/// A single quote makes the characters up to the next one literal, which is
+/// how a `{` is written (`'{'`), and two quotes in a row stand for one. An
+/// apostrophe in a message must therefore be doubled: `it''s`.
+///
+/// An argument that is `null` is written as `null`, and an element whose
+/// index is past the end of the arguments is written back as it was, `{2}`.
+///
+/// #### Differences from the JDK
+///
+/// - `toPattern` returns the elements as they were written rather than a
+///   canonical rewrite of them.
+/// - Date and time elements ignore the locale passed to the constructor: the
+///   device formats dates for its own locale only.
+public class MessageFormat extends Format {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final int TYPE_NONE = 0;
+    private static final int TYPE_NUMBER = 1;
+    private static final int TYPE_DATE = 2;
+    private static final int TYPE_TIME = 3;
+    private static final int TYPE_CHOICE = 4;
+
+    private Locale locale;
+
+    /// The literal text before each element, and after the last one: always
+    /// one longer than the element arrays.
+    private String[] literals = new String[] {""};
+    private int[] argumentNumbers = new int[0];
+    private Format[] formats = new Format[0];
+    private String[] elementTexts = new String[0];
+
+    public MessageFormat(String pattern) {
+        this(pattern, Locale.getDefault());
+    }
+
+    public MessageFormat(String pattern, Locale locale) {
+        this.locale = locale;
+        parsePattern(pattern);
+    }
+
+    public void setLocale(Locale locale) {
+        this.locale = locale;
+    }
+
+    public Locale getLocale() {
+        return locale;
+    }
+
+    public void applyPattern(String pattern) {
+        parsePattern(pattern);
+    }
+
+    private void parsePattern(String pattern) {
+        List<String> newLiterals = new ArrayList<String>();
+        List<Integer> newNumbers = new ArrayList<Integer>();
+        List<Format> newFormats = new ArrayList<Format>();
+        List<String> newTexts = new ArrayList<String>();
+        StringBuilder raw = new StringBuilder();
+        // The parts of the element being read: index, type, style.
+        StringBuilder[] parts = new StringBuilder[3];
+        int part = -1;
+        boolean inQuote = false;
+        int braceDepth = 0;
+        for (int i = 0; i < pattern.length(); i++) {
+            char ch = pattern.charAt(i);
+            if (part < 0) {
+                if (ch == '\'') {
+                    if (i + 1 < pattern.length() && pattern.charAt(i + 1) == '\'') {
+                        raw.append(ch);
+                        i++;
+                    } else {
+                        inQuote = !inQuote;
+                    }
+                } else if (ch == '{' && !inQuote) {
+                    part = 0;
+                    parts[0] = new StringBuilder();
+                    parts[1] = null;
+                    parts[2] = null;
+                } else {
+                    raw.append(ch);
+                }
+                continue;
+            }
+            if (inQuote) {
+                // Inside an element the quotes are the sub-pattern's own.
+                parts[part].append(ch);
+                if (ch == '\'') {
+                    inQuote = false;
+                }
+                continue;
+            }
+            if (ch == ',') {
+                if (part < 2) {
+                    part++;
+                    parts[part] = new StringBuilder();
+                } else {
+                    parts[part].append(ch);
+                }
+            } else if (ch == '{') {
+                braceDepth++;
+                parts[part].append(ch);
+            } else if (ch == '}') {
+                if (braceDepth == 0) {
+                    newLiterals.add(raw.toString());
+                    raw.setLength(0);
+                    String type = parts[1] == null ? "" : parts[1].toString();
+                    String style = parts[2] == null ? "" : parts[2].toString();
+                    int number = parseArgumentNumber(parts[0].toString());
+                    newNumbers.add(Integer.valueOf(number));
+                    Format made = makeFormat(type, style);
+                    newFormats.add(made);
+                    newTexts.add(number + describe(typeOf(type), style, made));
+                    part = -1;
+                } else {
+                    braceDepth--;
+                    parts[part].append(ch);
+                }
+            } else if (ch == ' ') {
+                // Leading spaces of the type are not part of it.
+                if (part != 1 || parts[1].length() > 0) {
+                    parts[part].append(ch);
+                }
+            } else {
+                if (ch == '\'') {
+                    inQuote = true;
+                }
+                parts[part].append(ch);
+            }
+        }
+        // Only an element left open at depth zero is refused. A pattern that
+        // ends inside a NESTED brace ("{0,choice,0#{") is accepted by every
+        // JDK from 8 to 25 -- java.text.MessageFormat tests braceStack == 0
+        // at this point too -- so refusing it would reject what the desktop
+        // accepts. MessageFormatDifferentialTest.rejectsWhatTheJdkRejects
+        // holds both sides to it.
+        if (braceDepth == 0 && part >= 0) {
+            throw new IllegalArgumentException("Unmatched braces in the pattern.");
+        }
+        newLiterals.add(raw.toString());
+        int n = newNumbers.size();
+        literals = newLiterals.toArray(new String[newLiterals.size()]);
+        argumentNumbers = new int[n];
+        for (int i = 0; i < n; i++) {
+            argumentNumbers[i] = newNumbers.get(i).intValue();
+        }
+        formats = newFormats.toArray(new Format[n]);
+        elementTexts = newTexts.toArray(new String[n]);
+    }
+
+    private static int parseArgumentNumber(String text) {
+        boolean negative = text.startsWith("-");
+        int from = negative ? 1 : 0;
+        if (text.length() == from || text.length() - from > 9) {
+            throw new IllegalArgumentException("can't parse argument number: " + text);
+        }
+        int value = 0;
+        for (int i = from; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                throw new IllegalArgumentException("can't parse argument number: " + text);
+            }
+            value = value * 10 + (c - '0');
+        }
+        if (negative) {
+            throw new IllegalArgumentException("negative argument number: " + text);
+        }
+        return value;
+    }
+
+    private static int typeOf(String type) {
+        String t = type.trim();
+        if (t.length() == 0) {
+            return TYPE_NONE;
+        }
+        if (t.equalsIgnoreCase("number")) {
+            return TYPE_NUMBER;
+        }
+        if (t.equalsIgnoreCase("date")) {
+            return TYPE_DATE;
+        }
+        if (t.equalsIgnoreCase("time")) {
+            return TYPE_TIME;
+        }
+        if (t.equalsIgnoreCase("choice")) {
+            return TYPE_CHOICE;
+        }
+        throw new IllegalArgumentException("unknown format type: " + type);
+    }
+
+    /// The date style a keyword names, or -1 when the text is a pattern.
+    private static int dateStyle(String style) {
+        String s = style.trim();
+        if (s.length() == 0) {
+            return DateFormat.DEFAULT;
+        }
+        if (s.equalsIgnoreCase("short")) {
+            return DateFormat.SHORT;
+        }
+        if (s.equalsIgnoreCase("medium")) {
+            return DateFormat.DEFAULT;
+        }
+        if (s.equalsIgnoreCase("long")) {
+            return DateFormat.LONG;
+        }
+        if (s.equalsIgnoreCase("full")) {
+            return DateFormat.FULL;
+        }
+        return -1;
+    }
+
+    private Format makeFormat(String type, String style) {
+        int kind = typeOf(type);
+        String keyword = style.trim();
+        if (kind == TYPE_NUMBER) {
+            if (keyword.length() == 0) {
+                return NumberFormat.getInstance(locale);
+            }
+            if (keyword.equalsIgnoreCase("currency")) {
+                return NumberFormat.getCurrencyInstance(locale);
+            }
+            if (keyword.equalsIgnoreCase("percent")) {
+                return NumberFormat.getPercentInstance(locale);
+            }
+            if (keyword.equalsIgnoreCase("integer")) {
+                return NumberFormat.getIntegerInstance(locale);
+            }
+            return new DecimalFormat(style, DecimalFormatSymbols.getInstance(locale));
+        }
+        if (kind == TYPE_DATE) {
+            int dateStyle = dateStyle(style);
+            return dateStyle >= 0 ? DateFormat.getDateInstance(dateStyle) : new SimpleDateFormat(style);
+        }
+        if (kind == TYPE_TIME) {
+            int timeStyle = dateStyle(style);
+            return timeStyle >= 0 ? DateFormat.getTimeInstance(timeStyle) : new SimpleDateFormat(style);
+        }
+        if (kind == TYPE_CHOICE) {
+            try {
+                return new ChoiceFormat(style);
+            } catch (IllegalArgumentException e) {
+                throw new IllegalArgumentException("Choice Pattern incorrect: " + style);
+            }
+        }
+        return null;
+    }
+
+    /// The type and style of an element as `toPattern` writes them: not the
+    /// text that was read but, as in the JDK, a description of the format it
+    /// produced -- `{0, number, #.##}` comes back as `{0,number,#0.##}`.
+    private String describe(int kind, String style, Format made) {
+        if (kind == TYPE_NUMBER) {
+            if (made.equals(NumberFormat.getInstance(locale))) {
+                return ",number";
+            }
+            if (made.equals(NumberFormat.getCurrencyInstance(locale))) {
+                return ",number,currency";
+            }
+            if (made.equals(NumberFormat.getPercentInstance(locale))) {
+                return ",number,percent";
+            }
+            if (made.equals(NumberFormat.getIntegerInstance(locale))) {
+                return ",number,integer";
+            }
+            return made instanceof DecimalFormat ? ",number," + ((DecimalFormat) made).toPattern() : ",number";
+        }
+        if (kind == TYPE_CHOICE) {
+            return made instanceof ChoiceFormat ? ",choice," + ((ChoiceFormat) made).toPattern() : ",choice";
+        }
+        if (kind == TYPE_DATE || kind == TYPE_TIME) {
+            String name = kind == TYPE_DATE ? ",date" : ",time";
+            int dateStyle = dateStyle(style);
+            if (dateStyle == DateFormat.SHORT) {
+                return name + ",short";
+            }
+            if (dateStyle == DateFormat.LONG) {
+                return name + ",long";
+            }
+            if (dateStyle == DateFormat.FULL) {
+                return name + ",full";
+            }
+            // A pattern of either type is a date pattern to the JDK.
+            return dateStyle >= 0 ? name : ",date," + style;
+        }
+        return "";
+    }
+
+    private static void appendLiteral(StringBuilder out, String text) {
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == '\'') {
+                out.append("''");
+            } else if (c == '{') {
+                out.append("'{'");
+            } else {
+                out.append(c);
+            }
+        }
+    }
+
+    public String toPattern() {
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            appendLiteral(out, literals[i]);
+            out.append('{').append(elementTexts[i]).append('}');
+        }
+        appendLiteral(out, literals[argumentNumbers.length]);
+        return out.toString();
+    }
+
+    public static String format(String pattern, Object... arguments) {
+        return new MessageFormat(pattern).format(arguments);
+    }
+
+    /// Formats an array of arguments, which `arguments` must be.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `arguments` is not an `Object[]`, or
+    ///   an argument is not of the type its element formats
+    @Override
+    public final StringBuffer format(Object arguments, StringBuffer result, FieldPosition pos) {
+        if (arguments == null || arguments instanceof Object[]) {
+            return format((Object[]) arguments, result, pos);
+        }
+        throw new IllegalArgumentException("The arguments of a message are an Object[]");
+    }
+
+    public final StringBuffer format(Object[] arguments, StringBuffer result, FieldPosition pos) {
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            result.append(literals[i]);
+            int number = argumentNumbers[i];
+            if (arguments == null || number >= arguments.length) {
+                result.append('{').append(number).append('}');
+                continue;
+            }
+            Object argument = arguments[number];
+            Format format = formats[i];
+            if (argument == null) {
+                result.append("null");
+            } else if (format instanceof ChoiceFormat) {
+                String chosen = ((ChoiceFormat) format).format(argument);
+                if (chosen.indexOf('{') >= 0) {
+                    new MessageFormat(chosen, locale).format(arguments, result, pos);
+                } else {
+                    result.append(chosen);
+                }
+            } else if (format instanceof NumberFormat) {
+                result.append(((NumberFormat) format).format(argument));
+            } else if (format instanceof DateFormat) {
+                result.append(formatDate((DateFormat) format, argument));
+            } else if (format != null) {
+                result.append(format.format(argument));
+            } else if (argument instanceof Number) {
+                result.append(NumberFormat.getInstance(locale).format(argument));
+            } else if (argument instanceof Date) {
+                DateFormat dateTime = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
+                result.append(dateTime.format((Date) argument));
+            } else if (argument instanceof String) {
+                result.append((String) argument);
+            } else {
+                result.append(String.valueOf(argument.toString()));
+            }
+        }
+        result.append(literals[argumentNumbers.length]);
+        return result;
+    }
+
+    private static String formatDate(DateFormat format, Object argument) {
+        if (argument instanceof Date) {
+            return format.format((Date) argument);
+        }
+        if (argument instanceof Number) {
+            return format.format(new Date(((Number) argument).longValue()));
+        }
+        throw new IllegalArgumentException("Cannot format given Object as a Date");
+    }
+
+    /// The formats of the elements, in the order the elements appear in the
+    /// pattern; `null` for an element that has none.
+    public Format[] getFormats() {
+        Format[] copy = new Format[formats.length];
+        System.arraycopy(formats, 0, copy, 0, formats.length);
+        return copy;
+    }
+
+    /// The formats of the arguments, indexed by argument number; `null` for
+    /// an argument no element formats. Where several elements name the same
+    /// argument, the last one's format is the one returned.
+    public Format[] getFormatsByArgumentIndex() {
+        Format[] result = new Format[maximumArgumentNumber() + 1];
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            result[argumentNumbers[i]] = formats[i];
+        }
+        return result;
+    }
+
+    private int maximumArgumentNumber() {
+        int max = -1;
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            max = Math.max(max, argumentNumbers[i]);
+        }
+        return max;
+    }
+
+    /// Sets the format of the element at `formatElementIndex`, counted in
+    /// the order the elements appear in the pattern.
+    ///
+    /// #### Throws
+    ///
+    /// - `ArrayIndexOutOfBoundsException`: if there is no such element
+    public void setFormat(int formatElementIndex, Format newFormat) {
+        if (formatElementIndex < 0 || formatElementIndex >= formats.length) {
+            throw new ArrayIndexOutOfBoundsException(formatElementIndex);
+        }
+        formats[formatElementIndex] = newFormat;
+        elementTexts[formatElementIndex] = argumentNumbers[formatElementIndex] + describeFormat(newFormat);
+    }
+
+    /// Sets the formats of the elements in pattern order; extra formats are
+    /// ignored and elements past the end of `newFormats` are left alone.
+    public void setFormats(Format[] newFormats) {
+        int n = Math.min(newFormats.length, formats.length);
+        for (int i = 0; i < n; i++) {
+            setFormat(i, newFormats[i]);
+        }
+    }
+
+    /// Sets the format of every element that formats argument
+    /// `argumentIndex`.
+    public void setFormatByArgumentIndex(int argumentIndex, Format newFormat) {
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            if (argumentNumbers[i] == argumentIndex) {
+                setFormat(i, newFormat);
+            }
+        }
+    }
+
+    /// Sets the formats of the arguments, indexed by argument number.
+    public void setFormatsByArgumentIndex(Format[] newFormats) {
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            if (argumentNumbers[i] < newFormats.length) {
+                setFormat(i, newFormats[argumentNumbers[i]]);
+            }
+        }
+    }
+
+    /// How `toPattern` writes an element whose format was set rather than
+    /// read from the pattern: as the JDK does, by recognising the format.
+    private String describeFormat(Format f) {
+        if (f instanceof ChoiceFormat) {
+            return describe(TYPE_CHOICE, "", f);
+        }
+        if (f instanceof NumberFormat) {
+            return describe(TYPE_NUMBER, "", f);
+        }
+        if (f instanceof DateFormat) {
+            String[] names = {",short", "", ",long", ",full"};
+            int[] styles = {DateFormat.SHORT, DateFormat.MEDIUM, DateFormat.LONG, DateFormat.FULL};
+            for (int i = 0; i < styles.length; i++) {
+                if (f.equals(DateFormat.getDateInstance(styles[i]))) {
+                    return ",date" + names[i];
+                }
+                if (f.equals(DateFormat.getTimeInstance(styles[i]))) {
+                    return ",time" + names[i];
+                }
+            }
+            if (f instanceof SimpleDateFormat) {
+                return ",date," + ((SimpleDateFormat) f).toPattern();
+            }
+        }
+        return "";
+    }
+
+    /// Reads the arguments back out of `source`, starting at `pos`: the
+    /// literal text must match exactly, an element with a format is read by
+    /// that format, and an element without one takes the text up to the
+    /// literal that follows it. The result is indexed by argument number. On
+    /// failure `pos` is left alone, its error index is set, and `null` is
+    /// returned.
+    public Object[] parse(String source, ParsePosition pos) {
+        if (source == null) {
+            return new Object[0];
+        }
+        Object[] result = new Object[maximumArgumentNumber() + 1];
+        int at = pos.getIndex();
+        ParsePosition inner = new ParsePosition(0);
+        for (int i = 0; i < argumentNumbers.length; i++) {
+            String literal = literals[i];
+            if (!source.regionMatches(at, literal, 0, literal.length())) {
+                pos.setErrorIndex(at);
+                return null;
+            }
+            at += literal.length();
+            Format format = formats[i];
+            if (format == null) {
+                // The text runs to the literal after this element; with
+                // none, to the end of the source.
+                String next = literals[i + 1];
+                int end = next.length() == 0 ? source.length() : source.indexOf(next, at);
+                if (end < 0) {
+                    pos.setErrorIndex(at);
+                    return null;
+                }
+                String value = source.substring(at, end);
+                if (!value.equals("{" + argumentNumbers[i] + "}")) {
+                    result[argumentNumbers[i]] = value;
+                }
+                at = end;
+            } else {
+                inner.setIndex(at);
+                Object value = format.parseObject(source, inner);
+                if (inner.getIndex() == at) {
+                    pos.setErrorIndex(at);
+                    return null;
+                }
+                result[argumentNumbers[i]] = value;
+                at = inner.getIndex();
+            }
+        }
+        String last = literals[argumentNumbers.length];
+        if (!source.regionMatches(at, last, 0, last.length())) {
+            pos.setErrorIndex(at);
+            return null;
+        }
+        pos.setIndex(at + last.length());
+        return result;
+    }
+
+    /// Reads the arguments back out of the beginning of `source`.
+    ///
+    /// #### Throws
+    ///
+    /// - `ParseException`: if `source` does not match the pattern
+    public Object[] parse(String source) throws ParseException {
+        ParsePosition pos = new ParsePosition(0);
+        Object[] result = parse(source, pos);
+        if (pos.getIndex() == 0) {
+            throw new ParseException("MessageFormat parse error!", pos.getErrorIndex());
+        }
+        return result;
+    }
+
+    @Override
+    public Object parseObject(String source, ParsePosition pos) {
+        return parse(source, pos);
+    }
+
+    /// A copy of this format, built by applying its pattern again:
+    /// `Object.clone()` answers `null` on the device for anything but an
+    /// array.
+    @Override
+    public Object clone() {
+        return new MessageFormat(toPattern(), locale);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass() || !(obj instanceof MessageFormat)) {
+            return false;
+        }
+        MessageFormat other = (MessageFormat) obj;
+        if (locale == null ? other.locale != null : !locale.equals(other.locale)) {
+            return false;
+        }
+        return toPattern().equals(other.toPattern());
+    }
+
+    @Override
+    public int hashCode() {
+        return toPattern().hashCode();
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/NumberFormat.java b/vm/JavaAPI/src/java/text/NumberFormat.java
new file mode 100644
index 00000000000..2ca8abdca38
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/NumberFormat.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+import java.util.Locale;
+
+/// The base of the number formats, and the factory for the usual ones.
+///
+/// The factory methods answer a [DecimalFormat] with these patterns:
+///
+/// - `getInstance` / `getNumberInstance`: `#,##0.###`
+/// - `getIntegerInstance`: `#,##0`, rounding to a whole number and parsing
+///   only the integer part
+/// - `getPercentInstance`: `#,##0%`
+/// - `getCurrencyInstance`: the currency symbol followed by `#,##0.00`, and a
+///   minus sign before the symbol for a negative amount
+///
+/// The separators and the currency symbol are those of
+/// [DecimalFormatSymbols]; read there how a locale is honoured.
+///
+/// #### Differences from the JDK
+///
+/// - Rounding is always half-even, the JDK's default. There is no
+///   `setRoundingMode`, as the device has no `java.math.RoundingMode`.
+/// - There is no `getCurrency`/`setCurrency`, as the device has no
+///   `java.util.Currency`.
+public abstract class NumberFormat extends Format {
+
+    private static final long serialVersionUID = 1L;
+
+    /// Names the integer part of a formatted number to a [FieldPosition].
+    public static final int INTEGER_FIELD = 0;
+
+    /// Names the fraction part of a formatted number to a [FieldPosition].
+    public static final int FRACTION_FIELD = 1;
+
+    private boolean groupingUsed = true;
+    private int maximumIntegerDigits = 40;
+    private int minimumIntegerDigits = 1;
+    private int maximumFractionDigits = 3;
+    private int minimumFractionDigits;
+    private boolean parseIntegerOnly;
+
+    protected NumberFormat() {
+    }
+
+    public static final NumberFormat getInstance() {
+        return getNumberInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getInstance(Locale inLocale) {
+        return getNumberInstance(inLocale);
+    }
+
+    public static final NumberFormat getNumberInstance() {
+        return getNumberInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getNumberInstance(Locale inLocale) {
+        return new DecimalFormat("#,##0.###", DecimalFormatSymbols.getInstance(inLocale));
+    }
+
+    public static final NumberFormat getIntegerInstance() {
+        return getIntegerInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getIntegerInstance(Locale inLocale) {
+        DecimalFormat format = new DecimalFormat("#,##0", DecimalFormatSymbols.getInstance(inLocale));
+        format.setParseIntegerOnly(true);
+        return format;
+    }
+
+    public static final NumberFormat getPercentInstance() {
+        return getPercentInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getPercentInstance(Locale inLocale) {
+        return new DecimalFormat("#,##0%", DecimalFormatSymbols.getInstance(inLocale));
+    }
+
+    public static final NumberFormat getCurrencyInstance() {
+        return getCurrencyInstance(Locale.getDefault());
+    }
+
+    public static NumberFormat getCurrencyInstance(Locale inLocale) {
+        String pattern = DecimalFormat.CURRENCY_SIGN + "#,##0.00";
+        return new DecimalFormat(pattern, DecimalFormatSymbols.getInstance(inLocale));
+    }
+
+    /// Formats a `Number`: an integral type as a `long`, anything else as a
+    /// `double`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `number` is not a `Number`
+    @Override
+    public StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos) {
+        if (number instanceof Long || number instanceof Integer || number instanceof Short
+                || number instanceof Byte) {
+            return format(((Number) number).longValue(), toAppendTo, pos);
+        }
+        if (number instanceof Number) {
+            return format(((Number) number).doubleValue(), toAppendTo, pos);
+        }
+        throw new IllegalArgumentException("Cannot format given Object as a Number");
+    }
+
+    public final String format(double number) {
+        return format(number, new StringBuffer(), new FieldPosition(0)).toString();
+    }
+
+    public final String format(long number) {
+        return format(number, new StringBuffer(), new FieldPosition(0)).toString();
+    }
+
+    public abstract StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos);
+
+    public abstract StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos);
+
+    /// Parses a number starting at `parsePosition`, which is advanced past
+    /// what was read. On failure the position is left alone, its error index
+    /// is set, and `null` is returned. The result is a `Long` when the text is
+    /// a whole number that fits one, and a `Double` otherwise.
+    public abstract Number parse(String source, ParsePosition parsePosition);
+
+    public Number parse(String source) throws ParseException {
+        ParsePosition parsePosition = new ParsePosition(0);
+        Number result = parse(source, parsePosition);
+        if (parsePosition.getIndex() == 0) {
+            throw new ParseException("Unparseable number: \"" + source + "\"", parsePosition.getErrorIndex());
+        }
+        return result;
+    }
+
+    @Override
+    public final Object parseObject(String source, ParsePosition pos) {
+        return parse(source, pos);
+    }
+
+    public boolean isParseIntegerOnly() {
+        return parseIntegerOnly;
+    }
+
+    public void setParseIntegerOnly(boolean value) {
+        parseIntegerOnly = value;
+    }
+
+    public boolean isGroupingUsed() {
+        return groupingUsed;
+    }
+
+    public void setGroupingUsed(boolean newValue) {
+        groupingUsed = newValue;
+    }
+
+    public int getMaximumIntegerDigits() {
+        return maximumIntegerDigits;
+    }
+
+    public void setMaximumIntegerDigits(int newValue) {
+        maximumIntegerDigits = Math.max(0, newValue);
+        if (minimumIntegerDigits > maximumIntegerDigits) {
+            minimumIntegerDigits = maximumIntegerDigits;
+        }
+    }
+
+    public int getMinimumIntegerDigits() {
+        return minimumIntegerDigits;
+    }
+
+    public void setMinimumIntegerDigits(int newValue) {
+        minimumIntegerDigits = Math.max(0, newValue);
+        if (minimumIntegerDigits > maximumIntegerDigits) {
+            maximumIntegerDigits = minimumIntegerDigits;
+        }
+    }
+
+    public int getMaximumFractionDigits() {
+        return maximumFractionDigits;
+    }
+
+    public void setMaximumFractionDigits(int newValue) {
+        maximumFractionDigits = Math.max(0, newValue);
+        if (maximumFractionDigits < minimumFractionDigits) {
+            minimumFractionDigits = maximumFractionDigits;
+        }
+    }
+
+    public int getMinimumFractionDigits() {
+        return minimumFractionDigits;
+    }
+
+    public void setMinimumFractionDigits(int newValue) {
+        minimumFractionDigits = Math.max(0, newValue);
+        if (maximumFractionDigits < minimumFractionDigits) {
+            maximumFractionDigits = minimumFractionDigits;
+        }
+    }
+
+    /// Copies the settings this class holds into `target`, for the `clone`
+    /// of a subclass: `Object.clone()` answers `null` on the device.
+    final void copyNumberFormatTo(NumberFormat target) {
+        target.groupingUsed = groupingUsed;
+        target.maximumIntegerDigits = maximumIntegerDigits;
+        target.minimumIntegerDigits = minimumIntegerDigits;
+        target.maximumFractionDigits = maximumFractionDigits;
+        target.minimumFractionDigits = minimumFractionDigits;
+        target.parseIntegerOnly = parseIntegerOnly;
+    }
+
+    /// A copy of this format. Every subclass in this package implements it
+    /// by copying its fields.
+    @Override
+    public abstract Object clone();
+
+    @Override
+    public int hashCode() {
+        return maximumIntegerDigits * 37 + maximumFractionDigits;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        if (getClass() != obj.getClass() || !(obj instanceof NumberFormat)) {
+            return false;
+        }
+        NumberFormat other = (NumberFormat) obj;
+        return maximumIntegerDigits == other.maximumIntegerDigits
+                && minimumIntegerDigits == other.minimumIntegerDigits
+                && maximumFractionDigits == other.maximumFractionDigits
+                && minimumFractionDigits == other.minimumFractionDigits
+                && groupingUsed == other.groupingUsed
+                && parseIntegerOnly == other.parseIntegerOnly;
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/ParsePosition.java b/vm/JavaAPI/src/java/text/ParsePosition.java
new file mode 100644
index 00000000000..7f3327e3c36
--- /dev/null
+++ b/vm/JavaAPI/src/java/text/ParsePosition.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.text;
+
+/// Where a parse starts, where it stopped, and where it failed.
+public class ParsePosition {
+
+    private int index;
+    private int errorIndex = -1;
+
+    public ParsePosition(int index) {
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public void setIndex(int index) {
+        this.index = index;
+    }
+
+    public void setErrorIndex(int ei) {
+        errorIndex = ei;
+    }
+
+    public int getErrorIndex() {
+        return errorIndex;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof ParsePosition)) {
+            return false;
+        }
+        ParsePosition other = (ParsePosition) obj;
+        return index == other.index && errorIndex == other.errorIndex;
+    }
+
+    @Override
+    public int hashCode() {
+        return (errorIndex << 16) | index;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[index=" + index + ",errorIndex=" + errorIndex + ']';
+    }
+}
diff --git a/vm/JavaAPI/src/java/text/SimpleDateFormat.java b/vm/JavaAPI/src/java/text/SimpleDateFormat.java
index 26972f8134e..e561ebbc048 100644
--- a/vm/JavaAPI/src/java/text/SimpleDateFormat.java
+++ b/vm/JavaAPI/src/java/text/SimpleDateFormat.java
@@ -419,12 +419,20 @@ String leftPad(int v, int size) {
 	 */
 	@Override
 	public Date parse(String source) throws ParseException {
+		return parseAt(source, 0, null);
+	}
+
+	@Override
+	Date parseAt(String source, int start, int[] end) throws ParseException {
 		if (pattern == null) {
-			return super.parse(source);
+			return super.parseAt(source, start, end);
 		}
-		int startIndex = 0;
+		int startIndex = start;
 		// parse based on GMT timezone for handling offsets
 		Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone(GMT));
+		// A field the pattern does not parse takes its value from the epoch,
+		// 1970-01-01 00:00:00.000, as in the JDK -- never from the current time.
+		calendar.setTime(new Date(0L));
 		int tzMinutes = -1;
 		List<String> pattern = getPatternTokens();
 		for (int i = 0; i < pattern.size(); i++) {
@@ -517,6 +525,9 @@ public Date parse(String source) throws ParseException {
 				startIndex += s.length();
 			}
 		}
+		if (end != null) {
+			end[0] = startIndex;
+		}
 		TimeZone localTimezone = Calendar.getInstance().getTimeZone();
 		calendar.setTimeZone(localTimezone);
 		// If timezone offset not part of date, the date passed will be treated
@@ -653,7 +664,7 @@ String readNumber(String source, int ofs, String token, boolean adjacent) {
 			char ch = source.charAt(i);
 			if (isNumeric(ch) == false) {
 				// empty string would be invalid number
-				if (i == 0) {
+				if (i == ofs) {
 					return null;
 				}
 				return source.substring(ofs, i);
@@ -788,7 +799,7 @@ String readMonth(String source, int ofs, String token, boolean adjacent) {
 			if (adjacent) {
 				return source.substring(ofs, ofs + token.length());
 			}
-			if (isNumeric(source.charAt(0))) {
+			if (ofs < source.length() && isNumeric(source.charAt(ofs))) {
 				return readNumber(source, ofs, token, adjacent);
 			}
 		}
@@ -823,6 +834,9 @@ String readMonth(String source, int ofs, String token, boolean adjacent) {
 	 * @throws ParseException if the source could not be parsed.
 	 */
 	int parseMonth(String month, int offset) throws ParseException {
+		if (month == null) {
+			throwInvalid("month", offset);
+		}
 		if (month.length() < 3) {
 			return (parseNumber(month, offset, "month", 1, 12) - 1) + Calendar.JANUARY;
 		}
diff --git a/vm/JavaAPI/src/java/time/Clock.java b/vm/JavaAPI/src/java/time/Clock.java
index 85d04e71d48..c6e942aeecf 100644
--- a/vm/JavaAPI/src/java/time/Clock.java
+++ b/vm/JavaAPI/src/java/time/Clock.java
@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 public abstract class Clock {
@@ -5,6 +27,9 @@ public abstract class Clock {
 
     public abstract Instant instant();
 
+    /// This clock, reporting its instants in `zone`.
+    public abstract Clock withZone(ZoneId zone);
+
     public long millis() {
         return instant().toEpochMilli();
     }
@@ -17,10 +42,32 @@ public static Clock systemDefaultZone() {
         return new SystemClock(ZoneId.systemDefault());
     }
 
+    /// The system clock, seen in `zone`.
+    public static Clock system(ZoneId zone) {
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return new SystemClock(zone);
+    }
+
     public static Clock fixed(Instant fixedInstant, ZoneId zone) {
         return new FixedClock(fixedInstant, zone);
     }
 
+    /// A clock that reads `base` moved on by `offsetDuration`.
+    public static Clock offset(Clock base, Duration offsetDuration) {
+        if (base == null) {
+            throw new NullPointerException("baseClock");
+        }
+        if (offsetDuration == null) {
+            throw new NullPointerException("offsetDuration");
+        }
+        if (offsetDuration.isZero()) {
+            return base;
+        }
+        return new OffsetClock(base, offsetDuration);
+    }
+
     private static final class SystemClock extends Clock {
         private final ZoneId zone;
 
@@ -35,6 +82,22 @@ public ZoneId getZone() {
         public Instant instant() {
             return Instant.now();
         }
+
+        public Clock withZone(ZoneId zone) {
+            return zone.equals(this.zone) ? this : new SystemClock(zone);
+        }
+
+        public boolean equals(Object obj) {
+            return obj instanceof SystemClock && zone.equals(((SystemClock) obj).zone);
+        }
+
+        public int hashCode() {
+            return zone.hashCode() + 1;
+        }
+
+        public String toString() {
+            return "SystemClock[" + zone + "]";
+        }
     }
 
     private static final class FixedClock extends Clock {
@@ -53,5 +116,63 @@ public ZoneId getZone() {
         public Instant instant() {
             return instant;
         }
+
+        public Clock withZone(ZoneId zone) {
+            return zone.equals(this.zone) ? this : new FixedClock(instant, zone);
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof FixedClock)) {
+                return false;
+            }
+            FixedClock other = (FixedClock) obj;
+            return instant.equals(other.instant) && zone.equals(other.zone);
+        }
+
+        public int hashCode() {
+            return instant.hashCode() ^ zone.hashCode();
+        }
+
+        public String toString() {
+            return "FixedClock[" + instant + "," + zone + "]";
+        }
+    }
+
+    private static final class OffsetClock extends Clock {
+        private final Clock base;
+        private final Duration offset;
+
+        private OffsetClock(Clock base, Duration offset) {
+            this.base = base;
+            this.offset = offset;
+        }
+
+        public ZoneId getZone() {
+            return base.getZone();
+        }
+
+        public Instant instant() {
+            return base.instant().plus(offset);
+        }
+
+        public Clock withZone(ZoneId zone) {
+            return zone.equals(base.getZone()) ? this : new OffsetClock(base.withZone(zone), offset);
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof OffsetClock)) {
+                return false;
+            }
+            OffsetClock other = (OffsetClock) obj;
+            return base.equals(other.base) && offset.equals(other.offset);
+        }
+
+        public int hashCode() {
+            return base.hashCode() ^ offset.hashCode();
+        }
+
+        public String toString() {
+            return "OffsetClock[" + base + "," + offset + "]";
+        }
     }
 }
diff --git a/vm/JavaAPI/src/java/time/DateTimeSupport.java b/vm/JavaAPI/src/java/time/DateTimeSupport.java
index c904655a29b..d3e4b356d15 100644
--- a/vm/JavaAPI/src/java/time/DateTimeSupport.java
+++ b/vm/JavaAPI/src/java/time/DateTimeSupport.java
@@ -22,216 +22,45 @@
  */
 package java.time;
 
-import com.codename1.impl.time.TimeZoneSupport;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Date;
-import java.util.Locale;
 import java.util.TimeZone;
 
+/// Where `java.time` meets the platform's time zone rules.
 final class DateTimeSupport {
-    static final long MILLIS_PER_SECOND = 1000L;
-    static final long MILLIS_PER_DAY = 86400000L;
-    static final long SECONDS_PER_DAY = 86400L;
-    static final long NANOS_PER_SECOND = 1000000000L;
-    static final long NANOS_PER_MILLI = 1000000L;
-    static final long NANOS_PER_DAY = 86400000000000L;
-
-    private static final long DAYS_0000_TO_1970 = 719528L;
-
     private DateTimeSupport() {
     }
 
-    public static int floorDiv(int x, int y) {
-        int r = x / y;
-        if ((x ^ y) < 0 && (r * y != x)) {
-            r--;
-        }
-        return r;
-    }
-
-    public static long floorDiv(long x, long y) {
-        long r = x / y;
-        if ((x ^ y) < 0 && (r * y != x)) {
-            r--;
-        }
-        return r;
-    }
-
-    public static int floorMod(int x, int y) {
-        return x - floorDiv(x, y) * y;
-    }
-
-    public static long floorMod(long x, long y) {
-        return x - floorDiv(x, y) * y;
-    }
-
-    public static boolean isLeapYear(int year) {
-        return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
-    }
-
-    public static int lengthOfMonth(int year, int month) {
-        switch (month) {
-            case 2:
-                return isLeapYear(year) ? 29 : 28;
-            case 4:
-            case 6:
-            case 9:
-            case 11:
-                return 30;
-            default:
-                return 31;
-        }
-    }
-
-    public static long toEpochDay(int year, int month, int dayOfMonth) {
-        long y = year;
-        long m = month;
-        long total = 365L * y;
-        if (y >= 0) {
-            total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;
-        } else {
-            total -= y / -4 - y / -100 + y / -400;
-        }
-        total += ((367 * m - 362) / 12);
-        total += dayOfMonth - 1;
-        if (m > 2) {
-            total--;
-            if (!isLeapYear(year)) {
-                total--;
-            }
-        }
-        return total - DAYS_0000_TO_1970;
-    }
-
-    public static int[] epochDayToDate(long epochDay) {
-        long zeroDay = epochDay + DAYS_0000_TO_1970;
-        zeroDay -= 60;
-        long adjust = 0;
-        if (zeroDay < 0) {
-            long adjustCycles = (zeroDay + 1) / 146097 - 1;
-            adjust = adjustCycles * 400;
-            zeroDay += -adjustCycles * 146097;
-        }
-        long yearEst = (400 * zeroDay + 591) / 146097;
-        long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
-        if (doyEst < 0) {
-            yearEst--;
-            doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
-        }
-        yearEst += adjust;
-        int marchDoy0 = (int) doyEst;
-        int marchMonth0 = (marchDoy0 * 5 + 2) / 153;
-        int month = (marchMonth0 + 2) % 12 + 1;
-        int day = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;
-        yearEst += marchMonth0 / 10;
-        return new int[] { (int) yearEst, month, day };
-    }
-
-    public static void checkDate(int year, int month, int day) {
-        if (month < 1 || month > 12) {
-            throw new IllegalArgumentException("Invalid month: " + month);
-        }
-        int maxDay = lengthOfMonth(year, month);
-        if (day < 1 || day > maxDay) {
-            throw new IllegalArgumentException("Invalid day: " + day);
-        }
-    }
-
-    public static void checkTime(int hour, int minute, int second, int nano) {
-        if (hour < 0 || hour > 23) {
-            throw new IllegalArgumentException("Invalid hour: " + hour);
-        }
-        if (minute < 0 || minute > 59) {
-            throw new IllegalArgumentException("Invalid minute: " + minute);
-        }
-        if (second < 0 || second > 59) {
-            throw new IllegalArgumentException("Invalid second: " + second);
-        }
-        if (nano < 0 || nano >= NANOS_PER_SECOND) {
-            throw new IllegalArgumentException("Invalid nano: " + nano);
-        }
-    }
-
-    public static long toEpochSecond(LocalDate date, LocalTime time, ZoneOffset offset) {
-        long days = date.toEpochDay();
-        long secs = days * SECONDS_PER_DAY + time.toSecondOfDay();
-        return secs - offset.getTotalSeconds();
-    }
-
-    public static int millisOfSecond(int nano) {
-        return nano / 1000000;
-    }
-
-    public static Calendar newCalendar(TimeZone tz) {
-        Calendar out = Calendar.getInstance(tz);
-        return out;
-    }
-
-    public static Instant instantFromCalendar(Calendar cal, int nano) {
-        long millis = cal.getTime().getTime();
-        long epochSecond = floorDiv(millis, 1000L);
-        int nanoAdj = (int) (floorMod(millis, 1000L) * NANOS_PER_MILLI) + nano % 1000000;
-        if (nanoAdj >= NANOS_PER_SECOND) {
-            epochSecond++;
-            nanoAdj -= NANOS_PER_SECOND;
-        }
-        return Instant.ofEpochSecond(epochSecond, nanoAdj);
-    }
-
-    public static Calendar calendarFromLocalDateTime(LocalDate date, LocalTime time, TimeZone tz) {
-        Calendar cal = newCalendar(tz);
-        cal.set(Calendar.YEAR, date.getYear());
-        cal.set(Calendar.MONTH, date.getMonthValue() - 1);
-        cal.set(Calendar.DAY_OF_MONTH, date.getDayOfMonth());
-        cal.set(Calendar.HOUR_OF_DAY, time.getHour());
-        cal.set(Calendar.MINUTE, time.getMinute());
-        cal.set(Calendar.SECOND, time.getSecond());
-        cal.set(Calendar.MILLISECOND, millisOfSecond(time.getNano()));
-        cal.getTime();
-        return cal;
-    }
-
-    public static LocalDateTime localDateTimeFromInstant(Instant instant, ZoneId zone) {
+    static LocalDateTime localDateTimeFromInstant(Instant instant, ZoneId zone) {
         ZoneOffset offset = offsetFromInstant(instant, zone);
-        long localSecond = instant.getEpochSecond() + offset.getTotalSeconds();
-        long epochDay = floorDiv(localSecond, SECONDS_PER_DAY);
-        int secondOfDay = (int) floorMod(localSecond, SECONDS_PER_DAY);
-        LocalDate date = LocalDate.ofEpochDay(epochDay);
-        LocalTime time = LocalTime.ofNanoOfDay(secondOfDay * NANOS_PER_SECOND + instant.getNano());
-        return LocalDateTime.of(date, time);
+        return LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset);
     }
 
-    public static ZoneOffset offsetFromInstant(Instant instant, ZoneId zone) {
-        if (zone instanceof ZoneOffset) {
+    /// The offset `zone` has at `instant`.
+    static ZoneOffset offsetFromInstant(Instant instant, ZoneId zone) {
+        ZoneOffset fixed = zone.fixedOffset();
+        if (fixed != null) {
             // A fixed offset already is the answer; round-tripping it through
             // the host time zone database can only lose or invert it.
-            return (ZoneOffset) zone;
+            return fixed;
         }
-        TimeZone tz = TimeZoneSupport.toTimeZone(zone);
+        TimeZone tz = zone.toTimeZone();
         // Ask the zone for its offset at this instant rather than reading the
         // fields back out of a Calendar. Calendar reconstructs the local time
         // from a raw offset plus a fixed one-hour daylight guess, which loses
         // the saving on the desktop ports (Europe/Berlin in June came back as
         // UTC), while TimeZone.getOffset consults the platform's own rules.
-        // getOffset takes LOCAL STANDARD time fields, which is what its javadoc
-        // says and what every other caller passes. This used to hand it UTC
-        // fields, which happened to work only because the natives read them that
-        // way; now that TimeZone converts properly, an instant has to be turned
-        // into local standard time first -- add the raw offset -- or it would be
-        // shifted by that offset twice.
-        long epochMilli = instant.toEpochMilli();
-        long localStandard = epochMilli + tz.getRawOffset();
-        long epochDay = floorDiv(localStandard, MILLIS_PER_DAY);
-        int millisOfDay = (int) floorMod(localStandard, MILLIS_PER_DAY);
+        // getOffset takes LOCAL STANDARD time fields, so the instant is
+        // turned into local standard time first by adding the raw offset.
+        // Worked in seconds, not milliseconds: the instants java.time accepts
+        // reach past what a long counts in milliseconds.
+        long localStandard = instant.getEpochSecond() + tz.getRawOffset() / 1000;
+        long epochDay = TimeArithmetic.floorDiv(localStandard, 86400L);
+        int millisOfDay = (int) TimeArithmetic.floorMod(localStandard, 86400L) * 1000
+                + instant.getNano() / 1000000;
         LocalDate utcDate = LocalDate.ofEpochDay(epochDay);
         // Calendar.SUNDAY is 1 and epoch day 0 was a Thursday.
-        int dayOfWeek = (int) floorMod(epochDay + 4, 7) + 1;
+        int dayOfWeek = (int) TimeArithmetic.floorMod(epochDay + 4, 7) + 1;
         // getOffset takes an era plus a year *of that era*, not a proleptic ISO
-        // year. Passing AD with a non-positive year described a date that does
-        // not exist, so instants before 1 CE resolved against the wrong year.
-        // ISO 0 is 1 BC, ISO -1 is 2 BC, hence 1 - isoYear.
+        // year: ISO 0 is 1 BC, ISO -1 is 2 BC, hence 1 - isoYear.
         int isoYear = utcDate.getYear();
         int era = isoYear > 0 ? 1 /* GregorianCalendar.AD */ : 0 /* GregorianCalendar.BC */;
         int yearOfEra = isoYear > 0 ? isoYear : 1 - isoYear;
@@ -239,56 +68,4 @@ public static ZoneOffset offsetFromInstant(Instant instant, ZoneId zone) {
                 utcDate.getMonthValue() - 1, utcDate.getDayOfMonth(), dayOfWeek, millisOfDay);
         return ZoneOffset.ofTotalSeconds(offsetMillis / 1000);
     }
-
-    public static SimpleDateFormat newFormat(String pattern, ZoneId zone, Locale locale) {
-        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
-        return sdf;
-    }
-
-    public static String formatPattern(String pattern, TemporalCarrier carrier, Locale locale) {
-        ZoneId zone = carrier.getZoneForFormatting();
-        SimpleDateFormat sdf = newFormat(pattern, zone, locale);
-        TimeZone original = TimeZone.getDefault();
-        try {
-            if (zone != null) {
-                TimeZone.setDefault(TimeZoneSupport.toTimeZone(zone));
-            }
-            return sdf.format(new Date(carrier.toInstant().toEpochMilli()));
-        } finally {
-            TimeZone.setDefault(original);
-        }
-    }
-
-    public static ParsedPatternResult parsePattern(String text, String pattern, ZoneId defaultZone, Locale locale) {
-        TimeZone original = TimeZone.getDefault();
-        try {
-            if (defaultZone != null) {
-                TimeZone.setDefault(TimeZoneSupport.toTimeZone(defaultZone));
-            }
-            SimpleDateFormat sdf = newFormat(pattern, defaultZone, locale);
-            Date date = sdf.parse(text);
-            Instant instant = Instant.ofEpochMilli(date.getTime());
-            ZoneId zone = defaultZone == null ? ZoneOffset.UTC : defaultZone;
-            return new ParsedPatternResult(instant, zone);
-        } catch (ParseException err) {
-            throw new java.time.format.DateTimeParseException(err.getMessage(), text, 0);
-        } finally {
-            TimeZone.setDefault(original);
-        }
-    }
-
-    public interface TemporalCarrier {
-        Instant toInstant();
-        ZoneId getZoneForFormatting();
-    }
-
-    public static final class ParsedPatternResult {
-        public final Instant instant;
-        public final ZoneId zone;
-
-        ParsedPatternResult(Instant instant, ZoneId zone) {
-            this.instant = instant;
-            this.zone = zone;
-        }
-    }
 }
diff --git a/vm/JavaAPI/src/java/time/DayOfWeek.java b/vm/JavaAPI/src/java/time/DayOfWeek.java
new file mode 100644
index 00000000000..95ba8eaa2c7
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/DayOfWeek.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time;
+
+import java.time.temporal.TemporalAccessor;
+
+/// The seven days of the week, Monday first as ISO counts them.
+public enum DayOfWeek implements TemporalAccessor {
+    /// Monday, day 1.
+    MONDAY,
+    /// Tuesday, day 2.
+    TUESDAY,
+    /// Wednesday, day 3.
+    WEDNESDAY,
+    /// Thursday, day 4.
+    THURSDAY,
+    /// Friday, day 5.
+    FRIDAY,
+    /// Saturday, day 6.
+    SATURDAY,
+    /// Sunday, day 7.
+    SUNDAY;
+
+    private static final DayOfWeek[] ALL = values();
+
+    /// The day numbered `dayOfWeek`, 1 for Monday to 7 for Sunday.
+    public static DayOfWeek of(int dayOfWeek) {
+        if (dayOfWeek < 1 || dayOfWeek > 7) {
+            throw new DateTimeException("Invalid value for DayOfWeek: " + dayOfWeek);
+        }
+        return ALL[dayOfWeek - 1];
+    }
+
+    /// 1 for Monday to 7 for Sunday.
+    public int getValue() {
+        return ordinal() + 1;
+    }
+
+    /// The day `days` later, around the week.
+    public DayOfWeek plus(long days) {
+        int amount = (int) (days % 7);
+        return ALL[(ordinal() + amount + 7) % 7];
+    }
+
+    /// The day `days` earlier, around the week.
+    public DayOfWeek minus(long days) {
+        return plus(-(days % 7));
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/Duration.java b/vm/JavaAPI/src/java/time/Duration.java
index 9c56a302ff7..4b15161d750 100644
--- a/vm/JavaAPI/src/java/time/Duration.java
+++ b/vm/JavaAPI/src/java/time/Duration.java
@@ -23,8 +23,24 @@
 package java.time;
 
 import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// An amount of time in seconds and nanoseconds, such as 34.5 seconds.
+///
+/// Arithmetic is exact: a result longer than a `Duration` holds throws
+/// `ArithmeticException` rather than wrapping around, as the JDK's does.
+public final class Duration implements TemporalAmount, Comparable<Duration> {
+    /// A duration of zero.
+    public static final Duration ZERO = new Duration(0L, 0);
+
+    private static final long NANOS_PER_SECOND = TimeArithmetic.NANOS_PER_SECOND;
 
-public final class Duration implements Comparable<Duration> {
     private final long seconds;
     private final int nanos;
 
@@ -33,30 +49,105 @@ private Duration(long seconds, int nanos) {
         this.nanos = nanos;
     }
 
+    private static Duration create(long seconds, int nanos) {
+        if ((seconds | nanos) == 0) {
+            return ZERO;
+        }
+        return new Duration(seconds, nanos);
+    }
+
+    /// A duration of `days` standard 24 hour days.
     public static Duration ofDays(long days) {
-        return ofSeconds(days * 86400L);
+        return create(TimeArithmetic.multiplyExact(days, 86400L), 0);
     }
 
+    /// A duration of `hours` hours.
     public static Duration ofHours(long hours) {
-        return ofSeconds(hours * 3600L);
+        return create(TimeArithmetic.multiplyExact(hours, 3600L), 0);
     }
 
+    /// A duration of `minutes` minutes.
     public static Duration ofMinutes(long minutes) {
-        return ofSeconds(minutes * 60L);
+        return create(TimeArithmetic.multiplyExact(minutes, 60L), 0);
     }
 
+    /// A duration of `seconds` seconds.
     public static Duration ofSeconds(long seconds) {
-        return new Duration(seconds, 0);
+        return create(seconds, 0);
     }
 
+    /// A duration of `seconds` seconds adjusted by `nanoAdjustment`
+    /// nanoseconds, which may take it across any number of seconds.
     public static Duration ofSeconds(long seconds, long nanoAdjustment) {
-        long secs = seconds + DateTimeSupport.floorDiv(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        int nanos = (int) DateTimeSupport.floorMod(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        return new Duration(secs, nanos);
+        long secs = TimeArithmetic.addExact(seconds, TimeArithmetic.floorDiv(nanoAdjustment, NANOS_PER_SECOND));
+        int nos = (int) TimeArithmetic.floorMod(nanoAdjustment, NANOS_PER_SECOND);
+        return create(secs, nos);
     }
 
+    /// A duration of `millis` milliseconds.
     public static Duration ofMillis(long millis) {
-        return ofSeconds(DateTimeSupport.floorDiv(millis, 1000L), DateTimeSupport.floorMod(millis, 1000L) * 1000000L);
+        long secs = millis / 1000;
+        int mos = (int) (millis % 1000);
+        if (mos < 0) {
+            mos += 1000;
+            secs--;
+        }
+        return create(secs, mos * 1000000);
+    }
+
+    /// A duration of `nanos` nanoseconds.
+    public static Duration ofNanos(long nanos) {
+        long secs = nanos / NANOS_PER_SECOND;
+        int nos = (int) (nanos % NANOS_PER_SECOND);
+        if (nos < 0) {
+            nos += (int) NANOS_PER_SECOND;
+            secs--;
+        }
+        return create(secs, nos);
+    }
+
+    /// A duration of `amount` of `unit`. The unit must have an exact length:
+    /// a day or anything shorter.
+    public static Duration of(long amount, TemporalUnit unit) {
+        return ZERO.plus(amount, unit);
+    }
+
+    /// The duration `amount` adds up to. Every unit it is made of must have
+    /// an exact length.
+    public static Duration from(TemporalAmount amount) {
+        if (amount == null) {
+            throw new NullPointerException("amount");
+        }
+        Duration duration = ZERO;
+        List<TemporalUnit> units = amount.getUnits();
+        for (int i = 0; i < units.size(); i++) {
+            TemporalUnit unit = units.get(i);
+            duration = duration.plus(amount.get(unit), unit);
+        }
+        return duration;
+    }
+
+    /// The duration from one value to another of the same kind, negative
+    /// when `endExclusive` comes first.
+    public static Duration between(Temporal startInclusive, Temporal endExclusive) {
+        try {
+            return ofNanos(startInclusive.until(endExclusive, ChronoUnit.NANOS));
+        } catch (DateTimeException ex) {
+            return betweenInSeconds(startInclusive, endExclusive);
+        } catch (ArithmeticException ex) {
+            return betweenInSeconds(startInclusive, endExclusive);
+        }
+    }
+
+    private static Duration betweenInSeconds(Temporal startInclusive, Temporal endExclusive) {
+        long secs = startInclusive.until(endExclusive, ChronoUnit.SECONDS);
+        long nanoDiff = TimeArithmetic.nanoOfSecond(endExclusive) - TimeArithmetic.nanoOfSecond(startInclusive);
+        if (secs > 0 && nanoDiff < 0) {
+            secs++;
+        } else if (secs < 0 && nanoDiff > 0) {
+            secs--;
+        }
+        return ofSeconds(secs, nanoDiff);
     }
 
     public static Duration parse(CharSequence text) {
@@ -126,18 +217,18 @@ public static Duration parse(CharSequence text) {
                 throw invalidDuration(value);
             }
             if (unit == 'D' && !time && !foundDays && fractionStart < 0) {
-                seconds += amount * 86400L;
+                seconds = parsedSum(value, seconds, amount, 86400L);
                 foundDays = true;
             } else if (unit == 'H' && time && lastTimeUnit < 1 && fractionStart < 0) {
-                seconds += amount * 3600L;
+                seconds = parsedSum(value, seconds, amount, 3600L);
                 lastTimeUnit = 1;
                 foundTime = true;
             } else if (unit == 'M' && time && lastTimeUnit < 2 && fractionStart < 0) {
-                seconds += amount * 60L;
+                seconds = parsedSum(value, seconds, amount, 60L);
                 lastTimeUnit = 2;
                 foundTime = true;
             } else if (unit == 'S' && time && lastTimeUnit < 3) {
-                seconds += amount;
+                seconds = parsedSum(value, seconds, amount, 1L);
                 lastTimeUnit = 3;
                 foundTime = true;
                 if (fractionStart >= 0) {
@@ -161,46 +252,374 @@ public static Duration parse(CharSequence text) {
         if (!found || (time && !foundTime)) {
             throw invalidDuration(value);
         }
-        return ofSeconds(overallSign * seconds, overallSign * (long) nanos);
+        try {
+            return ofSeconds(TimeArithmetic.multiplyExact(overallSign, seconds), overallSign * (long) nanos);
+        } catch (ArithmeticException e) {
+            throw invalidDuration(value);
+        }
+    }
+
+    /// `seconds` plus `amount` units of `unitSeconds` each. A field too large
+    /// for a duration is refused as the JDK refuses it, rather than wrapping
+    /// around to an unrelated one.
+    private static long parsedSum(String value, long seconds, long amount, long unitSeconds) {
+        try {
+            return TimeArithmetic.addExact(seconds, TimeArithmetic.multiplyExact(amount, unitSeconds));
+        } catch (ArithmeticException e) {
+            throw invalidDuration(value);
+        }
     }
 
     private static DateTimeParseException invalidDuration(String value) {
         return new DateTimeParseException("Text cannot be parsed to a Duration", value, 0);
     }
 
+    /// The amount of `unit` held: the seconds or the nanoseconds.
+    @Override
+    public long get(TemporalUnit unit) {
+        if (unit == ChronoUnit.SECONDS) {
+            return seconds;
+        }
+        if (unit == ChronoUnit.NANOS) {
+            return nanos;
+        }
+        throw TimeArithmetic.unsupported(unit);
+    }
+
+    /// Seconds and nanoseconds, the two units a duration is made of.
+    @Override
+    public List<TemporalUnit> getUnits() {
+        List<TemporalUnit> units = new ArrayList<TemporalUnit>(2);
+        units.add(ChronoUnit.SECONDS);
+        units.add(ChronoUnit.NANOS);
+        return Collections.unmodifiableList(units);
+    }
+
+    @Override
+    public Temporal addTo(Temporal temporal) {
+        if (seconds != 0) {
+            temporal = temporal.plus(seconds, ChronoUnit.SECONDS);
+        }
+        if (nanos != 0) {
+            temporal = temporal.plus(nanos, ChronoUnit.NANOS);
+        }
+        return temporal;
+    }
+
+    @Override
+    public Temporal subtractFrom(Temporal temporal) {
+        if (seconds != 0) {
+            temporal = temporal.minus(seconds, ChronoUnit.SECONDS);
+        }
+        if (nanos != 0) {
+            temporal = temporal.minus(nanos, ChronoUnit.NANOS);
+        }
+        return temporal;
+    }
+
+    /// Whether this is zero long.
+    public boolean isZero() {
+        return (seconds | nanos) == 0;
+    }
+
+    /// Whether this is shorter than zero.
+    public boolean isNegative() {
+        return seconds < 0;
+    }
+
+    /// The whole seconds, rounded towards negative infinity.
     public long getSeconds() {
         return seconds;
     }
 
+    /// The nanoseconds within the second, 0 to 999,999,999.
     public int getNano() {
         return nanos;
     }
 
+    /// This duration with `seconds` whole seconds.
+    public Duration withSeconds(long seconds) {
+        return create(seconds, nanos);
+    }
+
+    /// This duration with `nanoOfSecond` nanoseconds within the second.
+    public Duration withNanos(int nanoOfSecond) {
+        if (nanoOfSecond < 0 || nanoOfSecond >= NANOS_PER_SECOND) {
+            throw new DateTimeException("Invalid value for NanoOfSecond: " + nanoOfSecond);
+        }
+        return create(seconds, nanoOfSecond);
+    }
+
+    public Duration plus(Duration duration) {
+        return plus(duration.getSeconds(), duration.getNano());
+    }
+
+    /// This duration plus `amountToAdd` of `unit`, which must have an exact
+    /// length.
+    public Duration plus(long amountToAdd, TemporalUnit unit) {
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        if (unit == ChronoUnit.DAYS) {
+            return plus(TimeArithmetic.multiplyExact(amountToAdd, 86400L), 0);
+        }
+        if (unit.isDurationEstimated()) {
+            throw new java.time.temporal.UnsupportedTemporalTypeException(
+                    "Unit must not have an estimated duration");
+        }
+        if (amountToAdd == 0) {
+            return this;
+        }
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plusSeconds((amountToAdd / (1000000L * 1000)) * 1000)
+                        .plusNanos((amountToAdd % (1000000L * 1000)) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusMillis(amountToAdd);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            return plusSeconds(TimeArithmetic.multiplyExact(TimeArithmetic.seconds(u), amountToAdd));
+        }
+        Duration duration = unit.getDuration().multipliedBy(amountToAdd);
+        return plusSeconds(duration.getSeconds()).plusNanos(duration.getNano());
+    }
+
+    public Duration plusDays(long daysToAdd) {
+        return plus(TimeArithmetic.multiplyExact(daysToAdd, 86400L), 0);
+    }
+
+    public Duration plusHours(long hoursToAdd) {
+        return plus(TimeArithmetic.multiplyExact(hoursToAdd, 3600L), 0);
+    }
+
+    public Duration plusMinutes(long minutesToAdd) {
+        return plus(TimeArithmetic.multiplyExact(minutesToAdd, 60L), 0);
+    }
+
+    public Duration plusSeconds(long secondsToAdd) {
+        return plus(secondsToAdd, 0);
+    }
+
+    public Duration plusMillis(long millisToAdd) {
+        return plus(millisToAdd / 1000, (millisToAdd % 1000) * 1000000);
+    }
+
+    public Duration plusNanos(long nanosToAdd) {
+        return plus(0, nanosToAdd);
+    }
+
+    private Duration plus(long secondsToAdd, long nanosToAdd) {
+        if ((secondsToAdd | nanosToAdd) == 0) {
+            return this;
+        }
+        long epochSec = TimeArithmetic.addExact(seconds, secondsToAdd);
+        epochSec = TimeArithmetic.addExact(epochSec, nanosToAdd / NANOS_PER_SECOND);
+        nanosToAdd = nanosToAdd % NANOS_PER_SECOND;
+        long nanoAdjustment = nanos + nanosToAdd;
+        return ofSeconds(epochSec, nanoAdjustment);
+    }
+
+    public Duration minus(Duration duration) {
+        long secsToSubtract = duration.getSeconds();
+        int nanosToSubtract = duration.getNano();
+        if (secsToSubtract == Long.MIN_VALUE) {
+            return plus(Long.MAX_VALUE, -nanosToSubtract).plus(1, 0);
+        }
+        return plus(-secsToSubtract, -nanosToSubtract);
+    }
+
+    public Duration minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    public Duration minusDays(long daysToSubtract) {
+        return daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract);
+    }
+
+    public Duration minusHours(long hoursToSubtract) {
+        return hoursToSubtract == Long.MIN_VALUE ? plusHours(Long.MAX_VALUE).plusHours(1)
+                : plusHours(-hoursToSubtract);
+    }
+
+    public Duration minusMinutes(long minutesToSubtract) {
+        return minutesToSubtract == Long.MIN_VALUE ? plusMinutes(Long.MAX_VALUE).plusMinutes(1)
+                : plusMinutes(-minutesToSubtract);
+    }
+
+    public Duration minusSeconds(long secondsToSubtract) {
+        return secondsToSubtract == Long.MIN_VALUE ? plusSeconds(Long.MAX_VALUE).plusSeconds(1)
+                : plusSeconds(-secondsToSubtract);
+    }
+
+    public Duration minusMillis(long millisToSubtract) {
+        return millisToSubtract == Long.MIN_VALUE ? plusMillis(Long.MAX_VALUE).plusMillis(1)
+                : plusMillis(-millisToSubtract);
+    }
+
+    public Duration minusNanos(long nanosToSubtract) {
+        return nanosToSubtract == Long.MIN_VALUE ? plusNanos(Long.MAX_VALUE).plusNanos(1)
+                : plusNanos(-nanosToSubtract);
+    }
+
+    /// This duration multiplied by `multiplicand`, or `ArithmeticException`
+    /// when the product is longer than a duration holds.
+    public Duration multipliedBy(long multiplicand) {
+        if (multiplicand == 1) {
+            return this;
+        }
+        // A negative duration borrows a second first, so its seconds and
+        // nanoseconds share a sign and neither partial product overflows while
+        // the whole fits; the factor is split at a billion so the nanosecond
+        // product fits a long.
+        long secs = seconds;
+        long nos = nanos;
+        if (secs < 0 && nos > 0) {
+            secs++;
+            nos -= NANOS_PER_SECOND;
+        }
+        long high = TimeArithmetic.floorDiv(multiplicand, NANOS_PER_SECOND);
+        long rest = nos * TimeArithmetic.floorMod(multiplicand, NANOS_PER_SECOND);
+        // The nanosecond terms are summed first: together they are the carry
+        // of nanos * factor, which is never larger than the factor, while the
+        // first alone can push a result that fits past the range.
+        long carry = TimeArithmetic.addExact(nos * high, TimeArithmetic.floorDiv(rest, NANOS_PER_SECOND));
+        long total = TimeArithmetic.addExact(TimeArithmetic.multiplyExact(secs, multiplicand), carry);
+        return ofSeconds(total, TimeArithmetic.floorMod(rest, NANOS_PER_SECOND));
+    }
+
+    /// This duration divided by `divisor`, the fraction of a nanosecond
+    /// dropped towards zero. Exact for anything shorter than 292 years; a
+    /// longer one throws `ArithmeticException`.
+    public Duration dividedBy(long divisor) {
+        if (divisor == 0) {
+            throw new ArithmeticException("Cannot divide by zero");
+        }
+        if (divisor == 1) {
+            return this;
+        }
+        return ofNanos(toNanos() / divisor);
+    }
+
+    /// This duration with its sign reversed. The most negative duration has
+    /// no positive counterpart and throws `ArithmeticException`.
+    public Duration negated() {
+        return multipliedBy(-1);
+    }
+
+    /// This duration without its sign.
+    public Duration abs() {
+        return isNegative() ? negated() : this;
+    }
+
+    /// The whole days, of 24 hours.
+    public long toDays() {
+        return seconds / 86400L;
+    }
+
+    /// The whole hours.
+    public long toHours() {
+        return seconds / 3600L;
+    }
+
+    /// The whole minutes.
+    public long toMinutes() {
+        return seconds / 60L;
+    }
+
+    /// The whole seconds; the same as `getSeconds()`.
+    public long toSeconds() {
+        return seconds;
+    }
+
+    /// The whole milliseconds, or `ArithmeticException` past what a long
+    /// holds.
     public long toMillis() {
-        return seconds * 1000L + nanos / 1000000L;
+        long tempSeconds = seconds;
+        long tempNanos = nanos;
+        if (tempSeconds < 0) {
+            // A negative duration borrows a second first, so the most negative
+            // value a long holds is reached without an intermediate overflow.
+            tempSeconds = tempSeconds + 1;
+            tempNanos = tempNanos - NANOS_PER_SECOND;
+        }
+        long millis = TimeArithmetic.multiplyExact(tempSeconds, 1000L);
+        return TimeArithmetic.addExact(millis, tempNanos / 1000000L);
+    }
+
+    /// The whole nanoseconds, or `ArithmeticException` past what a long
+    /// holds (about 292 years).
+    public long toNanos() {
+        long tempSeconds = seconds;
+        long tempNanos = nanos;
+        if (tempSeconds < 0) {
+            tempSeconds = tempSeconds + 1;
+            tempNanos = tempNanos - NANOS_PER_SECOND;
+        }
+        long totalNanos = TimeArithmetic.multiplyExact(tempSeconds, NANOS_PER_SECOND);
+        return TimeArithmetic.addExact(totalNanos, tempNanos);
+    }
+
+    /// The whole days; the same as `toDays()`.
+    public long toDaysPart() {
+        return seconds / 86400L;
+    }
+
+    /// The hours left over after the whole days.
+    public int toHoursPart() {
+        return (int) (toHours() % 24);
+    }
+
+    /// The minutes left over after the whole hours.
+    public int toMinutesPart() {
+        return (int) (toMinutes() % 60);
+    }
+
+    /// The seconds left over after the whole minutes.
+    public int toSecondsPart() {
+        return (int) (seconds % 60);
     }
 
-    public Duration plus(Duration other) {
-        return ofSeconds(seconds + other.seconds, nanos + other.nanos);
+    /// The milliseconds within the second.
+    public int toMillisPart() {
+        return nanos / 1000000;
     }
 
-    public Duration minus(Duration other) {
-        return ofSeconds(seconds - other.seconds, nanos - other.nanos);
+    /// The nanoseconds within the second; the same as `getNano()`.
+    public int toNanosPart() {
+        return nanos;
     }
 
+    @Override
     public int compareTo(Duration other) {
         if (seconds != other.seconds) {
             return seconds < other.seconds ? -1 : 1;
         }
-        return nanos < other.nanos ? -1 : nanos > other.nanos ? 1 : 0;
+        return nanos - other.nanos;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof Duration && compareTo((Duration) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Duration)) {
+            return false;
+        }
+        Duration other = (Duration) obj;
+        return seconds == other.seconds && nanos == other.nanos;
     }
 
+    @Override
     public int hashCode() {
-        return (int) (seconds ^ (seconds >>> 32)) + nanos * 31;
+        return ((int) (seconds ^ (seconds >>> 32))) + (51 * nanos);
     }
 
     public String toString() {
diff --git a/vm/JavaAPI/src/java/time/Instant.java b/vm/JavaAPI/src/java/time/Instant.java
index 8ac4e01fdb2..1a58de06765 100644
--- a/vm/JavaAPI/src/java/time/Instant.java
+++ b/vm/JavaAPI/src/java/time/Instant.java
@@ -1,9 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+
+/// A moment on the time line, in seconds and nanoseconds from
+/// 1970-01-01T00:00:00Z.
+public final class Instant implements Temporal, Comparable<Instant> {
+    private static final long MIN_SECOND = -31557014167219200L;
+    private static final long MAX_SECOND = 31556889864403199L;
+
+    /// 1970-01-01T00:00:00Z.
+    public static final Instant EPOCH = new Instant(0L, 0);
+
+    /// The earliest instant, -1000000000-01-01T00:00Z.
+    public static final Instant MIN = new Instant(MIN_SECOND, 0);
+
+    /// The latest instant, 1000000000-12-31T23:59:59.999999999Z.
+    public static final Instant MAX = new Instant(MAX_SECOND, 999999999);
 
-public final class Instant implements Comparable<Instant>, TemporalAccessor {
     private final long epochSecond;
     private final int nano;
 
@@ -12,28 +52,67 @@ private Instant(long epochSecond, int nano) {
         this.nano = nano;
     }
 
+    private static Instant create(long seconds, int nanoOfSecond) {
+        if ((seconds | nanoOfSecond) == 0) {
+            return EPOCH;
+        }
+        if (seconds < MIN_SECOND || seconds > MAX_SECOND) {
+            throw TimeArithmetic.instantOutOfRange();
+        }
+        return new Instant(seconds, nanoOfSecond);
+    }
+
     public static Instant now() {
         return ofEpochMilli(System.currentTimeMillis());
     }
 
+    /// The moment now on `clock`.
+    public static Instant now(Clock clock) {
+        return clock.instant();
+    }
+
     public static Instant ofEpochMilli(long epochMilli) {
-        long secs = DateTimeSupport.floorDiv(epochMilli, 1000L);
-        int nanos = (int) (DateTimeSupport.floorMod(epochMilli, 1000L) * 1000000L);
-        return new Instant(secs, nanos);
+        long secs = TimeArithmetic.floorDiv(epochMilli, 1000L);
+        int mos = (int) TimeArithmetic.floorMod(epochMilli, 1000L);
+        return create(secs, mos * 1000000);
     }
 
     public static Instant ofEpochSecond(long epochSecond) {
-        return new Instant(epochSecond, 0);
+        return create(epochSecond, 0);
     }
 
     public static Instant ofEpochSecond(long epochSecond, long nanoAdjustment) {
-        long secs = epochSecond + DateTimeSupport.floorDiv(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        int nanos = (int) DateTimeSupport.floorMod(nanoAdjustment, DateTimeSupport.NANOS_PER_SECOND);
-        return new Instant(secs, nanos);
+        long secs = TimeArithmetic.addExact(epochSecond,
+                TimeArithmetic.floorDiv(nanoAdjustment, TimeArithmetic.NANOS_PER_SECOND));
+        int nos = (int) TimeArithmetic.floorMod(nanoAdjustment, TimeArithmetic.NANOS_PER_SECOND);
+        return create(secs, nos);
+    }
+
+    /// The moment `temporal` is.
+    public static Instant from(TemporalAccessor temporal) {
+        if (temporal instanceof Instant) {
+            return (Instant) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toInstant();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toInstant();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain Instant from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static Instant parse(CharSequence text) {
-        return (Instant) DateTimeFormatter.ISO_INSTANT.parse(text);
+        TemporalAccessor parsed = DateTimeFormatter.ISO_INSTANT.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public long getEpochSecond() {
@@ -44,50 +123,200 @@ public int getNano() {
         return nano;
     }
 
+    /// The milliseconds since the epoch, or `ArithmeticException` past what
+    /// a long holds.
     public long toEpochMilli() {
-        return epochSecond * 1000L + nano / 1000000L;
+        if (epochSecond < 0 && nano > 0) {
+            long millis = TimeArithmetic.multiplyExact(epochSecond + 1, 1000L);
+            long adjustment = nano / 1000000 - 1000;
+            return TimeArithmetic.addExact(millis, adjustment);
+        }
+        long millis = TimeArithmetic.multiplyExact(epochSecond, 1000L);
+        return TimeArithmetic.addExact(millis, nano / 1000000);
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit.isTimeBased() || unit == ChronoUnit.DAYS;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public Instant plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plus(amountToAdd / 1000000, (amountToAdd % 1000000) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusMillis(amountToAdd);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            if (u == ChronoUnit.MINUTES || u == ChronoUnit.HOURS || u == ChronoUnit.HALF_DAYS
+                    || u == ChronoUnit.DAYS) {
+                return plusSeconds(TimeArithmetic.multiplyExact(amountToAdd, TimeArithmetic.seconds(u)));
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public Instant minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public Instant plus(TemporalAmount amount) {
+        return (Instant) amount.addTo(this);
+    }
+
+    @Override
+    public Instant minus(TemporalAmount amount) {
+        return (Instant) amount.subtractFrom(this);
     }
 
     public Instant plusSeconds(long secondsToAdd) {
-        return ofEpochSecond(epochSecond + secondsToAdd, nano);
+        return plus(secondsToAdd, 0);
     }
 
     public Instant plusMillis(long millisToAdd) {
-        return ofEpochMilli(toEpochMilli() + millisToAdd);
+        return plus(millisToAdd / 1000, (millisToAdd % 1000) * 1000000);
+    }
+
+    public Instant plusNanos(long nanosToAdd) {
+        return plus(0, nanosToAdd);
+    }
+
+    private Instant plus(long secondsToAdd, long nanosToAdd) {
+        if ((secondsToAdd | nanosToAdd) == 0) {
+            return this;
+        }
+        long epochSec = TimeArithmetic.addExact(epochSecond, secondsToAdd);
+        epochSec = TimeArithmetic.addExact(epochSec, nanosToAdd / TimeArithmetic.NANOS_PER_SECOND);
+        nanosToAdd = nanosToAdd % TimeArithmetic.NANOS_PER_SECOND;
+        long nanoAdjustment = nano + nanosToAdd;
+        return ofEpochSecond(epochSec, nanoAdjustment);
     }
 
     public Instant minusSeconds(long secondsToSubtract) {
+        if (secondsToSubtract == Long.MIN_VALUE) {
+            return plusSeconds(Long.MAX_VALUE).plusSeconds(1);
+        }
         return plusSeconds(-secondsToSubtract);
     }
 
     public Instant minusMillis(long millisToSubtract) {
+        if (millisToSubtract == Long.MIN_VALUE) {
+            return plusMillis(Long.MAX_VALUE).plusMillis(1);
+        }
         return plusMillis(-millisToSubtract);
     }
 
+    public Instant minusNanos(long nanosToSubtract) {
+        if (nanosToSubtract == Long.MIN_VALUE) {
+            return plusNanos(Long.MAX_VALUE).plusNanos(1);
+        }
+        return plusNanos(-nanosToSubtract);
+    }
+
+    /// This moment with everything smaller than `unit` dropped. The unit has
+    /// to divide a day.
+    public Instant truncatedTo(TemporalUnit unit) {
+        if (unit == ChronoUnit.NANOS) {
+            return this;
+        }
+        long dur = TimeArithmetic.truncationNanos(unit);
+        long nod = (epochSecond % TimeArithmetic.SECONDS_PER_DAY) * TimeArithmetic.NANOS_PER_SECOND + nano;
+        long result = TimeArithmetic.floorDiv(nod, dur) * dur;
+        return plusNanos(result - nod);
+    }
+
+    /// The whole units of `unit` from this moment to `endExclusive`.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        Instant end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u.compareTo(ChronoUnit.DAYS) > 0) {
+                throw TimeArithmetic.unsupported(unit);
+            }
+            if (u == ChronoUnit.NANOS || u == ChronoUnit.MICROS) {
+                // Counted in nanoseconds first, as the JDK does: more than
+                // 292 years apart is an overflow in either unit.
+                long secsDiff = TimeArithmetic.subtractExact(end.epochSecond, epochSecond);
+                long nanos = TimeArithmetic.addExact(TimeArithmetic.multiplyExact(secsDiff,
+                        TimeArithmetic.NANOS_PER_SECOND), end.nano - nano);
+                return u == ChronoUnit.NANOS ? nanos : nanos / 1000;
+            }
+            if (u == ChronoUnit.MILLIS) {
+                // Between the two moments each cut to its millisecond.
+                return TimeArithmetic.subtractExact(end.toEpochMilli(), toEpochMilli());
+            }
+            return TimeArithmetic.timeUntil(epochSecond, nano, end.epochSecond, end.nano, u);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
+    /// This moment in `zone`.
+    public ZonedDateTime atZone(ZoneId zone) {
+        return ZonedDateTime.ofInstant(this, zone);
+    }
+
+    /// This moment at `offset`.
+    public OffsetDateTime atOffset(ZoneOffset offset) {
+        return OffsetDateTime.ofInstant(this, offset);
+    }
+
+    public boolean isAfter(Instant otherInstant) {
+        return compareTo(otherInstant) > 0;
+    }
+
+    public boolean isBefore(Instant otherInstant) {
+        return compareTo(otherInstant) < 0;
+    }
+
+    @Override
     public int compareTo(Instant other) {
         if (epochSecond != other.epochSecond) {
             return epochSecond < other.epochSecond ? -1 : 1;
         }
-        return nano < other.nano ? -1 : nano > other.nano ? 1 : 0;
+        return nano - other.nano;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof Instant && compareTo((Instant) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Instant)) {
+            return false;
+        }
+        Instant other = (Instant) obj;
+        return epochSecond == other.epochSecond && nano == other.nano;
     }
 
+    @Override
     public int hashCode() {
-        return (int) (epochSecond ^ (epochSecond >>> 32)) + nano * 51;
+        return ((int) (epochSecond ^ (epochSecond >>> 32))) + 51 * nano;
     }
 
+    @Override
     public String toString() {
         return DateTimeFormatter.ISO_INSTANT.format(this);
     }
-
-    Instant toInstant() {
-        return this;
-    }
-
-    ZoneId getZoneForFormatting() {
-        return ZoneOffset.UTC;
-    }
 }
diff --git a/vm/JavaAPI/src/java/time/LocalDate.java b/vm/JavaAPI/src/java/time/LocalDate.java
index 35440aaaa50..daffa6894c9 100644
--- a/vm/JavaAPI/src/java/time/LocalDate.java
+++ b/vm/JavaAPI/src/java/time/LocalDate.java
@@ -1,43 +1,200 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
+import java.time.chrono.ChronoLocalDate;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.util.stream.Stream;
+
+/// A date of the ISO calendar with no time and no zone, such as 2007-12-03.
+public final class LocalDate implements ChronoLocalDate {
+    /// -999999999-01-01, the earliest date.
+    public static final LocalDate MIN = new LocalDate(-999999999, 1, 1);
+    /// +999999999-12-31, the latest date.
+    public static final LocalDate MAX = new LocalDate(999999999, 12, 31);
+    /// 1970-01-01.
+    public static final LocalDate EPOCH = new LocalDate(1970, 1, 1);
+
+    private static final int YEAR_LIMIT = 999999999;
+    private static final long DAYS_PER_CYCLE = 146097L;
+    private static final long DAYS_0000_TO_1970 = (DAYS_PER_CYCLE * 5L) - (30L * 365L + 7L);
 
-public final class LocalDate implements Comparable<LocalDate>, TemporalAccessor {
     private final int year;
-    private final int month;
-    private final int dayOfMonth;
+    private final short month;
+    private final short day;
 
     private LocalDate(int year, int month, int dayOfMonth) {
-        DateTimeSupport.checkDate(year, month, dayOfMonth);
         this.year = year;
-        this.month = month;
-        this.dayOfMonth = dayOfMonth;
+        this.month = (short) month;
+        this.day = (short) dayOfMonth;
+    }
+
+    private static boolean leap(long year) {
+        return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0);
+    }
+
+    private static int monthLength(int year, int month) {
+        return Month.of(month).length(leap(year));
+    }
+
+    private static LocalDate create(int year, int month, int dayOfMonth) {
+        if (dayOfMonth > 28) {
+            int dom = monthLength(year, month);
+            if (dayOfMonth > dom) {
+                if (dayOfMonth == 29) {
+                    throw new DateTimeException("Invalid date 'February 29' as '" + year + "' is not a leap year");
+                }
+                throw new DateTimeException("Invalid date '" + Month.of(month).name() + " " + dayOfMonth + "'");
+            }
+        }
+        return new LocalDate(year, month, dayOfMonth);
+    }
+
+    /// The date, with the day brought back to the last one the month has.
+    private static LocalDate resolvePreviousValid(int year, int month, int day) {
+        int last = monthLength(year, month);
+        return new LocalDate(year, month, day > last ? last : day);
+    }
+
+    private static int checkYear(long year) {
+        return (int) TimeArithmetic.check("Year", -YEAR_LIMIT, YEAR_LIMIT, year);
     }
 
     public static LocalDate now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The date today in `zone`.
+    public static LocalDate now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static LocalDate now(Clock clock) {
-        return LocalDateTime.ofInstant(clock.instant(), clock.getZone()).toLocalDate();
+        return ofInstant(clock.instant(), clock.getZone());
     }
 
     public static LocalDate of(int year, int month, int dayOfMonth) {
-        return new LocalDate(year, month, dayOfMonth);
+        checkYear(year);
+        TimeArithmetic.check("MonthOfYear", 1, 12, month);
+        TimeArithmetic.check("DayOfMonth", 1, 31, dayOfMonth);
+        return create(year, month, dayOfMonth);
+    }
+
+    public static LocalDate of(int year, Month month, int dayOfMonth) {
+        if (month == null) {
+            throw new NullPointerException("month");
+        }
+        return of(year, month.getValue(), dayOfMonth);
+    }
+
+    /// The `dayOfYear`th day of `year`.
+    public static LocalDate ofYearDay(int year, int dayOfYear) {
+        checkYear(year);
+        TimeArithmetic.check("DayOfYear", 1, 366, dayOfYear);
+        boolean leap = leap(year);
+        if (dayOfYear == 366 && !leap) {
+            throw new DateTimeException("Invalid date 'DayOfYear 366' as '" + year + "' is not a leap year");
+        }
+        Month moy = Month.of((dayOfYear - 1) / 31 + 1);
+        int monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;
+        if (dayOfYear > monthEnd) {
+            moy = moy.plus(1);
+        }
+        int dom = dayOfYear - moy.firstDayOfYear(leap) + 1;
+        return new LocalDate(year, moy.getValue(), dom);
+    }
+
+    /// The date `instant` falls on in `zone`.
+    public static LocalDate ofInstant(Instant instant, ZoneId zone) {
+        return LocalDateTime.ofInstant(instant, zone).toLocalDate();
     }
 
     public static LocalDate ofEpochDay(long epochDay) {
-        int[] parts = DateTimeSupport.epochDayToDate(epochDay);
-        return of(parts[0], parts[1], parts[2]);
+        TimeArithmetic.check("EpochDay", -365243219162L, 365241780471L, epochDay);
+        long zeroDay = epochDay + DAYS_0000_TO_1970;
+        // find the march-based year
+        zeroDay -= 60;
+        long adjust = 0;
+        if (zeroDay < 0) {
+            long adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1;
+            adjust = adjustCycles * 400;
+            zeroDay += -adjustCycles * DAYS_PER_CYCLE;
+        }
+        long yearEst = (400 * zeroDay + 591) / DAYS_PER_CYCLE;
+        long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
+        if (doyEst < 0) {
+            yearEst--;
+            doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);
+        }
+        yearEst += adjust;
+        int marchDoy0 = (int) doyEst;
+        int marchMonth0 = (marchDoy0 * 5 + 2) / 153;
+        int month = (marchMonth0 + 2) % 12 + 1;
+        int dom = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;
+        yearEst += marchMonth0 / 10;
+        return new LocalDate(checkYear(yearEst), month, dom);
+    }
+
+    /// The date of `temporal`.
+    public static LocalDate from(TemporalAccessor temporal) {
+        if (temporal instanceof LocalDate) {
+            return (LocalDate) temporal;
+        }
+        if (temporal instanceof LocalDateTime) {
+            return ((LocalDateTime) temporal).toLocalDate();
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toLocalDate();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toLocalDate();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain LocalDate from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static LocalDate parse(CharSequence text) {
-        return (LocalDate) DateTimeFormatter.ISO_LOCAL_DATE.parse(text);
+        return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);
     }
 
     public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) {
-        return (LocalDate) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public int getYear() {
@@ -48,43 +205,285 @@ public int getMonthValue() {
         return month;
     }
 
+    /// The month as a `Month`.
+    public Month getMonth() {
+        return Month.of(month);
+    }
+
     public int getDayOfMonth() {
-        return dayOfMonth;
+        return day;
+    }
+
+    /// The day of the year, 1 for January 1st.
+    public int getDayOfYear() {
+        return getMonth().firstDayOfYear(isLeapYear()) + day - 1;
+    }
+
+    /// The day of the week.
+    public DayOfWeek getDayOfWeek() {
+        int dow0 = (int) TimeArithmetic.floorMod(toEpochDay() + 3, 7);
+        return DayOfWeek.of(dow0 + 1);
     }
 
+    @Override
     public boolean isLeapYear() {
-        return DateTimeSupport.isLeapYear(year);
+        return leap(year);
     }
 
+    @Override
     public int lengthOfMonth() {
-        return DateTimeSupport.lengthOfMonth(year, month);
+        return monthLength(year, month);
     }
 
+    @Override
+    public int lengthOfYear() {
+        return isLeapYear() ? 366 : 365;
+    }
+
+    @Override
     public long toEpochDay() {
-        return DateTimeSupport.toEpochDay(year, month, dayOfMonth);
+        long y = year;
+        long m = month;
+        long total = 0;
+        total += 365 * y;
+        if (y >= 0) {
+            total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;
+        } else {
+            total -= y / -4 - y / -100 + y / -400;
+        }
+        total += ((367 * m - 362) / 12);
+        total += day - 1;
+        if (m > 2) {
+            total--;
+            if (!isLeapYear()) {
+                total--;
+            }
+        }
+        return total - DAYS_0000_TO_1970;
+    }
+
+    private long getProlepticMonth() {
+        return (year * 12L + month - 1);
+    }
+
+    public LocalDate withYear(int year) {
+        if (this.year == year) {
+            return this;
+        }
+        checkYear(year);
+        return resolvePreviousValid(year, month, day);
+    }
+
+    public LocalDate withMonth(int month) {
+        if (this.month == month) {
+            return this;
+        }
+        TimeArithmetic.check("MonthOfYear", 1, 12, month);
+        return resolvePreviousValid(year, month, day);
+    }
+
+    public LocalDate withDayOfMonth(int dayOfMonth) {
+        if (this.day == dayOfMonth) {
+            return this;
+        }
+        return of(year, month, dayOfMonth);
+    }
+
+    public LocalDate withDayOfYear(int dayOfYear) {
+        if (getDayOfYear() == dayOfYear) {
+            return this;
+        }
+        return ofYearDay(year, dayOfYear);
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit.isDateBased();
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public LocalDate plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.DAYS) {
+                return plusDays(amountToAdd);
+            }
+            if (u == ChronoUnit.WEEKS) {
+                return plusWeeks(amountToAdd);
+            }
+            if (u == ChronoUnit.MONTHS) {
+                return plusMonths(amountToAdd);
+            }
+            if (u == ChronoUnit.YEARS) {
+                return plusYears(amountToAdd);
+            }
+            if (u == ChronoUnit.DECADES) {
+                return plusYears(TimeArithmetic.multiplyExact(amountToAdd, 10));
+            }
+            if (u == ChronoUnit.CENTURIES) {
+                return plusYears(TimeArithmetic.multiplyExact(amountToAdd, 100));
+            }
+            if (u == ChronoUnit.MILLENNIA) {
+                return plusYears(TimeArithmetic.multiplyExact(amountToAdd, 1000));
+            }
+            if (u == ChronoUnit.ERAS) {
+                // The two eras of the ISO calendar: year 1 and later, and before.
+                long era = TimeArithmetic.addExact(year >= 1 ? 1 : 0, amountToAdd);
+                TimeArithmetic.check("Era", 0, 1, era);
+                return amountToAdd == 0 ? this : resolvePreviousValid(1 - year, month, day);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public LocalDate minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public LocalDate plus(TemporalAmount amount) {
+        return (LocalDate) amount.addTo(this);
+    }
+
+    @Override
+    public LocalDate minus(TemporalAmount amount) {
+        return (LocalDate) amount.subtractFrom(this);
     }
 
     public LocalDate plusDays(long daysToAdd) {
-        return ofEpochDay(toEpochDay() + daysToAdd);
+        if (daysToAdd == 0) {
+            return this;
+        }
+        return ofEpochDay(TimeArithmetic.addExact(toEpochDay(), daysToAdd));
+    }
+
+    public LocalDate plusWeeks(long weeksToAdd) {
+        return plusDays(TimeArithmetic.multiplyExact(weeksToAdd, 7));
     }
 
     public LocalDate plusMonths(long monthsToAdd) {
+        if (monthsToAdd == 0) {
+            return this;
+        }
         long monthCount = year * 12L + (month - 1);
         long calcMonths = monthCount + monthsToAdd;
-        int newYear = (int) DateTimeSupport.floorDiv(calcMonths, 12);
-        int newMonth = (int) DateTimeSupport.floorMod(calcMonths, 12) + 1;
-        int newDay = Math.min(dayOfMonth, DateTimeSupport.lengthOfMonth(newYear, newMonth));
-        return of(newYear, newMonth, newDay);
+        int newYear = checkYear(TimeArithmetic.floorDiv(calcMonths, 12));
+        int newMonth = (int) TimeArithmetic.floorMod(calcMonths, 12) + 1;
+        return resolvePreviousValid(newYear, newMonth, day);
     }
 
     public LocalDate plusYears(long yearsToAdd) {
-        int newYear = (int) (year + yearsToAdd);
-        int newDay = Math.min(dayOfMonth, DateTimeSupport.lengthOfMonth(newYear, month));
-        return of(newYear, month, newDay);
+        if (yearsToAdd == 0) {
+            return this;
+        }
+        int newYear = checkYear(year + yearsToAdd);
+        return resolvePreviousValid(newYear, month, day);
     }
 
     public LocalDate minusDays(long daysToSubtract) {
-        return plusDays(-daysToSubtract);
+        return daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract);
+    }
+
+    public LocalDate minusWeeks(long weeksToSubtract) {
+        return weeksToSubtract == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1)
+                : plusWeeks(-weeksToSubtract);
+    }
+
+    public LocalDate minusMonths(long monthsToSubtract) {
+        return monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1)
+                : plusMonths(-monthsToSubtract);
+    }
+
+    public LocalDate minusYears(long yearsToSubtract) {
+        return yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1)
+                : plusYears(-yearsToSubtract);
+    }
+
+    /// The whole units of `unit` from this date to the date of `endExclusive`.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        LocalDate end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.DAYS) {
+                return end.toEpochDay() - toEpochDay();
+            }
+            if (u == ChronoUnit.WEEKS) {
+                return (end.toEpochDay() - toEpochDay()) / 7;
+            }
+            if (u == ChronoUnit.MONTHS) {
+                return monthsUntil(end);
+            }
+            if (u == ChronoUnit.YEARS) {
+                return monthsUntil(end) / 12;
+            }
+            if (u == ChronoUnit.DECADES) {
+                return monthsUntil(end) / 120;
+            }
+            if (u == ChronoUnit.CENTURIES) {
+                return monthsUntil(end) / 1200;
+            }
+            if (u == ChronoUnit.MILLENNIA) {
+                return monthsUntil(end) / 12000;
+            }
+            if (u == ChronoUnit.ERAS) {
+                return (end.year >= 1 ? 1 : 0) - (year >= 1 ? 1 : 0);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
+    long monthsUntil(LocalDate end) {
+        long packed1 = getProlepticMonth() * 32L + day;
+        long packed2 = end.getProlepticMonth() * 32L + end.day;
+        return (packed2 - packed1) / 32;
+    }
+
+    /// The years, months and days from this date to `endDateExclusive`.
+    public Period until(ChronoLocalDate endDateExclusive) {
+        LocalDate end = from(endDateExclusive);
+        long totalMonths = end.getProlepticMonth() - getProlepticMonth();
+        int days = end.day - day;
+        if (totalMonths > 0 && days < 0) {
+            totalMonths--;
+            LocalDate calcDate = plusMonths(totalMonths);
+            days = (int) (end.toEpochDay() - calcDate.toEpochDay());
+        } else if (totalMonths < 0 && days > 0) {
+            totalMonths++;
+            days -= end.lengthOfMonth();
+        }
+        long years = totalMonths / 12;
+        int months = (int) (totalMonths % 12);
+        return Period.of(TimeArithmetic.toIntExact(years), months, days);
+    }
+
+    /// The dates from this one up to and not including `endExclusive`, a day
+    /// apart.
+    public Stream<LocalDate> datesUntil(LocalDate endExclusive) {
+        long end = endExclusive.toEpochDay();
+        long start = toEpochDay();
+        if (end < start) {
+            throw new IllegalArgumentException(endExclusive + " < " + this);
+        }
+        // Made in full: the class library has no lazy stream source yet.
+        LocalDate[] all = new LocalDate[TimeArithmetic.toIntExact(end - start)];
+        for (int i = 0; i < all.length; i++) {
+            all[i] = ofEpochDay(start + i);
+        }
+        return Stream.of(all);
     }
 
     public LocalDateTime atTime(int hour, int minute) {
@@ -103,6 +502,11 @@ public LocalDateTime atTime(LocalTime time) {
         return LocalDateTime.of(this, time);
     }
 
+    /// Midnight at the start of this date.
+    public LocalDateTime atStartOfDay() {
+        return LocalDateTime.of(this, LocalTime.MIDNIGHT);
+    }
+
     public ZonedDateTime atStartOfDay(ZoneId zone) {
         return ZonedDateTime.of(this, LocalTime.MIDNIGHT, zone);
     }
@@ -111,25 +515,82 @@ public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
-    public int compareTo(LocalDate other) {
-        if (year != other.year) {
-            return year < other.year ? -1 : 1;
+    private int compareTo0(LocalDate otherDate) {
+        int cmp = year - otherDate.year;
+        if (cmp == 0) {
+            cmp = month - otherDate.month;
+            if (cmp == 0) {
+                cmp = day - otherDate.day;
+            }
+        }
+        return cmp;
+    }
+
+    @Override
+    public int compareTo(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other);
+        }
+        long a = toEpochDay();
+        long b = other.toEpochDay();
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+
+    @Override
+    public boolean isAfter(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other) > 0;
         }
-        if (month != other.month) {
-            return month < other.month ? -1 : 1;
+        return toEpochDay() > other.toEpochDay();
+    }
+
+    @Override
+    public boolean isBefore(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other) < 0;
         }
-        return dayOfMonth < other.dayOfMonth ? -1 : dayOfMonth > other.dayOfMonth ? 1 : 0;
+        return toEpochDay() < other.toEpochDay();
     }
 
+    @Override
+    public boolean isEqual(ChronoLocalDate other) {
+        if (other instanceof LocalDate) {
+            return compareTo0((LocalDate) other) == 0;
+        }
+        return toEpochDay() == other.toEpochDay();
+    }
+
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof LocalDate && compareTo((LocalDate) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        return obj instanceof LocalDate && compareTo0((LocalDate) obj) == 0;
     }
 
+    @Override
     public int hashCode() {
-        return year * 37 + month * 13 + dayOfMonth;
+        return (year & 0xFFFFF800) ^ ((year << 11) + (month << 6) + day);
     }
 
+    /// The JDK's text, `uuuu-MM-dd`, with a sign on a year past 9999.
+    @Override
     public String toString() {
-        return DateTimeFormatter.ISO_LOCAL_DATE.format(this);
+        StringBuilder buf = new StringBuilder(12);
+        int absYear = year < 0 ? -year : year;
+        if (absYear < 1000) {
+            if (year < 0) {
+                buf.append('-');
+            }
+            String digits = Integer.toString(absYear + 10000);
+            buf.append(digits.substring(1));
+        } else {
+            if (year > 9999) {
+                buf.append('+');
+            }
+            buf.append(year);
+        }
+        return buf.append(month < 10 ? "-0" : "-").append((int) month).append(day < 10 ? "-0" : "-")
+                .append((int) day).toString();
     }
 }
diff --git a/vm/JavaAPI/src/java/time/LocalDateTime.java b/vm/JavaAPI/src/java/time/LocalDateTime.java
index d19cfed30d0..423c0384185 100644
--- a/vm/JavaAPI/src/java/time/LocalDateTime.java
+++ b/vm/JavaAPI/src/java/time/LocalDateTime.java
@@ -1,9 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
+import java.time.chrono.ChronoLocalDateTime;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+
+/// A date and a time of day with no zone, such as 2007-12-03T10:15:30.
+public final class LocalDateTime implements ChronoLocalDateTime<LocalDate> {
+    /// The earliest date and time.
+    public static final LocalDateTime MIN = new LocalDateTime(LocalDate.MIN, LocalTime.MIN);
+    /// The latest date and time.
+    public static final LocalDateTime MAX = new LocalDateTime(LocalDate.MAX, LocalTime.MAX);
+
+    private static final long NANOS_PER_SECOND = TimeArithmetic.NANOS_PER_SECOND;
+    private static final long NANOS_PER_MINUTE = 60L * NANOS_PER_SECOND;
+    private static final long NANOS_PER_HOUR = 60L * NANOS_PER_MINUTE;
+    private static final long NANOS_PER_DAY = TimeArithmetic.NANOS_PER_DAY;
 
-public final class LocalDateTime implements Comparable<LocalDateTime>, TemporalAccessor {
     private final LocalDate date;
     private final LocalTime time;
 
@@ -12,15 +50,33 @@ private LocalDateTime(LocalDate date, LocalTime time) {
         this.time = time;
     }
 
+    private LocalDateTime with(LocalDate newDate, LocalTime newTime) {
+        if (date == newDate && time == newTime) {
+            return this;
+        }
+        return new LocalDateTime(newDate, newTime);
+    }
+
     public static LocalDateTime now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The date and time now in `zone`.
+    public static LocalDateTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static LocalDateTime now(Clock clock) {
         return ofInstant(clock.instant(), clock.getZone());
     }
 
     public static LocalDateTime of(LocalDate date, LocalTime time) {
+        if (date == null) {
+            throw new NullPointerException("date");
+        }
+        if (time == null) {
+            throw new NullPointerException("time");
+        }
         return new LocalDateTime(date, time);
     }
 
@@ -36,22 +92,75 @@ public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, in
         return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute, second, nano));
     }
 
+    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute) {
+        return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute));
+    }
+
+    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second) {
+        return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute, second));
+    }
+
+    public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second,
+            int nano) {
+        return of(LocalDate.of(year, month, dayOfMonth), LocalTime.of(hour, minute, second, nano));
+    }
+
     public static LocalDateTime ofInstant(Instant instant, ZoneId zone) {
         return DateTimeSupport.localDateTimeFromInstant(instant, zone);
     }
 
+    /// The date and time `epochSecond` seconds and `nanoOfSecond` nanoseconds
+    /// after 1970-01-01T00:00 at `offset`.
+    public static LocalDateTime ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset) {
+        TimeArithmetic.check("NanoOfSecond", 0, 999999999, nanoOfSecond);
+        long localSecond = epochSecond + offset.getTotalSeconds();
+        long localEpochDay = TimeArithmetic.floorDiv(localSecond, TimeArithmetic.SECONDS_PER_DAY);
+        int secsOfDay = (int) TimeArithmetic.floorMod(localSecond, TimeArithmetic.SECONDS_PER_DAY);
+        LocalDate date = LocalDate.ofEpochDay(localEpochDay);
+        LocalTime time = LocalTime.ofNanoOfDay(secsOfDay * NANOS_PER_SECOND + nanoOfSecond);
+        return new LocalDateTime(date, time);
+    }
+
+    /// The date and time of `temporal`.
+    public static LocalDateTime from(TemporalAccessor temporal) {
+        if (temporal instanceof LocalDateTime) {
+            return (LocalDateTime) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toLocalDateTime();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toLocalDateTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain LocalDateTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
+    }
+
     public static LocalDateTime parse(CharSequence text) {
-        return (LocalDateTime) DateTimeFormatter.ISO_LOCAL_DATE_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
     }
 
     public static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (LocalDateTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
+    @Override
     public LocalDate toLocalDate() {
         return date;
     }
 
+    @Override
     public LocalTime toLocalTime() {
         return time;
     }
@@ -64,10 +173,22 @@ public int getMonthValue() {
         return date.getMonthValue();
     }
 
+    public Month getMonth() {
+        return date.getMonth();
+    }
+
     public int getDayOfMonth() {
         return date.getDayOfMonth();
     }
 
+    public int getDayOfYear() {
+        return date.getDayOfYear();
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return date.getDayOfWeek();
+    }
+
     public int getHour() {
         return time.getHour();
     }
@@ -84,58 +205,332 @@ public int getNano() {
         return time.getNano();
     }
 
+    public LocalDateTime withYear(int year) {
+        return with(date.withYear(year), time);
+    }
+
+    public LocalDateTime withMonth(int month) {
+        return with(date.withMonth(month), time);
+    }
+
+    public LocalDateTime withDayOfMonth(int dayOfMonth) {
+        return with(date.withDayOfMonth(dayOfMonth), time);
+    }
+
+    public LocalDateTime withDayOfYear(int dayOfYear) {
+        return with(date.withDayOfYear(dayOfYear), time);
+    }
+
+    public LocalDateTime withHour(int hour) {
+        return with(date, time.withHour(hour));
+    }
+
+    public LocalDateTime withMinute(int minute) {
+        return with(date, time.withMinute(minute));
+    }
+
+    public LocalDateTime withSecond(int second) {
+        return with(date, time.withSecond(second));
+    }
+
+    public LocalDateTime withNano(int nanoOfSecond) {
+        return with(date, time.withNano(nanoOfSecond));
+    }
+
+    /// This value with everything smaller than `unit` set to zero. The unit
+    /// has to divide a day.
+    public LocalDateTime truncatedTo(TemporalUnit unit) {
+        return with(date, time.truncatedTo(unit));
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit != ChronoUnit.FOREVER;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public LocalDateTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plusDays(amountToAdd / 86400000000L).plusNanos((amountToAdd % 86400000000L) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusDays(amountToAdd / 86400000L).plusNanos((amountToAdd % 86400000L) * 1000000);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            if (u == ChronoUnit.MINUTES) {
+                return plusMinutes(amountToAdd);
+            }
+            if (u == ChronoUnit.HOURS) {
+                return plusHours(amountToAdd);
+            }
+            if (u == ChronoUnit.HALF_DAYS) {
+                // The JDK's own arithmetic, 256 half days to a step.
+                return plusDays(amountToAdd / 256).plusHours((amountToAdd % 256) * 12);
+            }
+            return with(date.plus(amountToAdd, unit), time);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public LocalDateTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public LocalDateTime plus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            Period periodToAdd = (Period) amount;
+            return with(date.plus(periodToAdd), time);
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToAdd");
+        }
+        return (LocalDateTime) amount.addTo(this);
+    }
+
+    @Override
+    public LocalDateTime minus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            Period periodToSubtract = (Period) amount;
+            return with(date.minus(periodToSubtract), time);
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToSubtract");
+        }
+        return (LocalDateTime) amount.subtractFrom(this);
+    }
+
+    public LocalDateTime plusYears(long years) {
+        return with(date.plusYears(years), time);
+    }
+
+    public LocalDateTime plusMonths(long months) {
+        return with(date.plusMonths(months), time);
+    }
+
+    public LocalDateTime plusWeeks(long weeks) {
+        return with(date.plusWeeks(weeks), time);
+    }
+
     public LocalDateTime plusDays(long days) {
-        return of(date.plusDays(days), time);
+        return with(date.plusDays(days), time);
     }
 
     public LocalDateTime plusHours(long hours) {
-        long totalNanos = time.toNanoOfDay() + hours * 3600L * DateTimeSupport.NANOS_PER_SECOND;
-        long dayAdjust = DateTimeSupport.floorDiv(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        long nanoOfDay = DateTimeSupport.floorMod(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        return of(date.plusDays(dayAdjust), LocalTime.ofNanoOfDay(nanoOfDay));
+        return plusWithOverflow(date, hours, 0, 0, 0, 1);
     }
 
     public LocalDateTime plusMinutes(long minutes) {
-        return plusHours(minutes / 60).plusSeconds((minutes % 60) * 60);
+        return plusWithOverflow(date, 0, minutes, 0, 0, 1);
     }
 
     public LocalDateTime plusSeconds(long seconds) {
-        long totalNanos = time.toNanoOfDay() + seconds * DateTimeSupport.NANOS_PER_SECOND;
-        long dayAdjust = DateTimeSupport.floorDiv(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        long nanoOfDay = DateTimeSupport.floorMod(totalNanos, DateTimeSupport.NANOS_PER_DAY);
-        return of(date.plusDays(dayAdjust), LocalTime.ofNanoOfDay(nanoOfDay));
+        return plusWithOverflow(date, 0, 0, seconds, 0, 1);
+    }
+
+    public LocalDateTime plusNanos(long nanos) {
+        return plusWithOverflow(date, 0, 0, 0, nanos, 1);
+    }
+
+    public LocalDateTime minusYears(long years) {
+        return years == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-years);
+    }
+
+    public LocalDateTime minusMonths(long months) {
+        return months == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-months);
+    }
+
+    public LocalDateTime minusWeeks(long weeks) {
+        return weeks == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1) : plusWeeks(-weeks);
     }
 
-    public Instant toInstant(ZoneOffset offset) {
-        return Instant.ofEpochSecond(DateTimeSupport.toEpochSecond(date, time, offset), time.getNano());
+    public LocalDateTime minusDays(long days) {
+        return days == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-days);
+    }
+
+    public LocalDateTime minusHours(long hours) {
+        return plusWithOverflow(date, hours, 0, 0, 0, -1);
+    }
+
+    public LocalDateTime minusMinutes(long minutes) {
+        return plusWithOverflow(date, 0, minutes, 0, 0, -1);
+    }
+
+    public LocalDateTime minusSeconds(long seconds) {
+        return plusWithOverflow(date, 0, 0, seconds, 0, -1);
+    }
+
+    public LocalDateTime minusNanos(long nanos) {
+        return plusWithOverflow(date, 0, 0, 0, nanos, -1);
+    }
+
+    /// The time added a unit at a time, each taken apart into whole days and
+    /// the rest first, so no step overflows while the result fits.
+    private LocalDateTime plusWithOverflow(LocalDate newDate, long hours, long minutes, long seconds, long nanos,
+            int sign) {
+        if ((hours | minutes | seconds | nanos) == 0) {
+            return with(newDate, time);
+        }
+        long totDays = nanos / NANOS_PER_DAY + seconds / 86400L + minutes / 1440L + hours / 24L;
+        totDays *= sign;
+        long totNanos = nanos % NANOS_PER_DAY + (seconds % 86400L) * NANOS_PER_SECOND
+                + (minutes % 1440L) * NANOS_PER_MINUTE + (hours % 24L) * NANOS_PER_HOUR;
+        long curNoD = time.toNanoOfDay();
+        totNanos = totNanos * sign + curNoD;
+        totDays += TimeArithmetic.floorDiv(totNanos, NANOS_PER_DAY);
+        long newNoD = TimeArithmetic.floorMod(totNanos, NANOS_PER_DAY);
+        LocalTime newTime = newNoD == curNoD ? time : LocalTime.ofNanoOfDay(newNoD);
+        return with(newDate.plusDays(totDays), newTime);
+    }
+
+    /// The whole units of `unit` from this value to `endExclusive`.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        LocalDateTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u.isTimeBased()) {
+                long amount = end.date.toEpochDay() - date.toEpochDay();
+                if (amount == 0) {
+                    return time.until(end.time, unit);
+                }
+                long timePart = end.time.toNanoOfDay() - time.toNanoOfDay();
+                if (amount > 0) {
+                    amount--;
+                    timePart += NANOS_PER_DAY;
+                } else {
+                    amount++;
+                    timePart -= NANOS_PER_DAY;
+                }
+                if (u == ChronoUnit.NANOS) {
+                    amount = TimeArithmetic.multiplyExact(amount, NANOS_PER_DAY);
+                } else if (u == ChronoUnit.MICROS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 86400000000L);
+                    timePart = timePart / 1000;
+                } else if (u == ChronoUnit.MILLIS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 86400000L);
+                    timePart = timePart / 1000000;
+                } else if (u == ChronoUnit.SECONDS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 86400L);
+                    timePart = timePart / NANOS_PER_SECOND;
+                } else if (u == ChronoUnit.MINUTES) {
+                    amount = TimeArithmetic.multiplyExact(amount, 1440L);
+                    timePart = timePart / NANOS_PER_MINUTE;
+                } else if (u == ChronoUnit.HOURS) {
+                    amount = TimeArithmetic.multiplyExact(amount, 24L);
+                    timePart = timePart / NANOS_PER_HOUR;
+                } else {
+                    amount = TimeArithmetic.multiplyExact(amount, 2L);
+                    timePart = timePart / (NANOS_PER_HOUR * 12);
+                }
+                return TimeArithmetic.addExact(amount, timePart);
+            }
+            LocalDate endDate = end.date;
+            if (endDate.isAfter(date) && end.time.isBefore(time)) {
+                endDate = endDate.minusDays(1);
+            } else if (endDate.isBefore(date) && end.time.isAfter(time)) {
+                endDate = endDate.plusDays(1);
+            }
+            return date.until(endDate, unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
+    /// This date and time in `zone`.
+    public ZonedDateTime atZone(ZoneId zone) {
+        return ZonedDateTime.of(this, zone);
+    }
+
+    /// This date and time at `offset`.
+    public OffsetDateTime atOffset(ZoneOffset offset) {
+        return OffsetDateTime.of(this, offset);
     }
 
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
-    public int compareTo(LocalDateTime other) {
+    private int compareTo0(LocalDateTime other) {
         int cmp = date.compareTo(other.date);
-        return cmp != 0 ? cmp : time.compareTo(other.time);
+        if (cmp == 0) {
+            cmp = time.compareTo(other.time);
+        }
+        return cmp;
     }
 
-    public boolean equals(Object obj) {
-        return obj instanceof LocalDateTime && compareTo((LocalDateTime) obj) == 0;
+    @Override
+    public int compareTo(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other);
+        }
+        int cmp = toLocalDate().compareTo(other.toLocalDate());
+        if (cmp == 0) {
+            cmp = toLocalTime().compareTo(other.toLocalTime());
+        }
+        return cmp;
     }
 
-    public int hashCode() {
-        return date.hashCode() * 31 + time.hashCode();
+    @Override
+    public boolean isAfter(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other) > 0;
+        }
+        return compareTo(other) > 0;
     }
 
-    public String toString() {
-        return DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(this);
+    @Override
+    public boolean isBefore(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other) < 0;
+        }
+        return compareTo(other) < 0;
     }
 
-    Instant toInstant() {
-        return toInstant(ZoneOffset.UTC);
+    @Override
+    public boolean isEqual(ChronoLocalDateTime<?> other) {
+        if (other instanceof LocalDateTime) {
+            return compareTo0((LocalDateTime) other) == 0;
+        }
+        return compareTo(other) == 0;
     }
 
-    ZoneId getZoneForFormatting() {
-        return ZoneOffset.UTC;
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof LocalDateTime)) {
+            return false;
+        }
+        LocalDateTime other = (LocalDateTime) obj;
+        return date.equals(other.date) && time.equals(other.time);
+    }
+
+    @Override
+    public int hashCode() {
+        return date.hashCode() ^ time.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return date.toString() + 'T' + time.toString();
     }
 }
diff --git a/vm/JavaAPI/src/java/time/LocalTime.java b/vm/JavaAPI/src/java/time/LocalTime.java
index 51d76969676..41bd7496b5d 100644
--- a/vm/JavaAPI/src/java/time/LocalTime.java
+++ b/vm/JavaAPI/src/java/time/LocalTime.java
@@ -1,10 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
 
-public final class LocalTime implements Comparable<LocalTime>, TemporalAccessor {
+/// A time of day with no date and no zone, such as 10:15:30.
+public final class LocalTime implements Temporal, Comparable<LocalTime> {
+    /// 00:00.
     public static final LocalTime MIDNIGHT = new LocalTime(0, 0, 0, 0);
+    /// 00:00, the earliest time of day.
+    public static final LocalTime MIN = MIDNIGHT;
+    /// 12:00.
+    public static final LocalTime NOON = new LocalTime(12, 0, 0, 0);
+    /// 23:59:59.999999999, the latest time of day.
+    public static final LocalTime MAX = new LocalTime(23, 59, 59, 999999999);
+
+    private static final long NANOS_PER_SECOND = TimeArithmetic.NANOS_PER_SECOND;
+    private static final long NANOS_PER_MINUTE = 60L * NANOS_PER_SECOND;
+    private static final long NANOS_PER_HOUR = 60L * NANOS_PER_MINUTE;
+    private static final long NANOS_PER_DAY = TimeArithmetic.NANOS_PER_DAY;
 
     private final int hour;
     private final int minute;
@@ -12,53 +51,103 @@ public final class LocalTime implements Comparable<LocalTime>, TemporalAccessor
     private final int nano;
 
     private LocalTime(int hour, int minute, int second, int nano) {
-        DateTimeSupport.checkTime(hour, minute, second, nano);
         this.hour = hour;
         this.minute = minute;
         this.second = second;
         this.nano = nano;
     }
 
+    private static LocalTime create(int hour, int minute, int second, int nano) {
+        if ((minute | second | nano) == 0 && hour == 0) {
+            return MIDNIGHT;
+        }
+        return new LocalTime(hour, minute, second, nano);
+    }
+
     public static LocalTime now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The time of day now in `zone`.
+    public static LocalTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static LocalTime now(Clock clock) {
         return LocalDateTime.ofInstant(clock.instant(), clock.getZone()).toLocalTime();
     }
 
     public static LocalTime of(int hour, int minute) {
-        return new LocalTime(hour, minute, 0, 0);
+        return of(hour, minute, 0, 0);
     }
 
     public static LocalTime of(int hour, int minute, int second) {
-        return new LocalTime(hour, minute, second, 0);
+        return of(hour, minute, second, 0);
     }
 
-    public static LocalTime of(int hour, int minute, int second, int nano) {
-        return new LocalTime(hour, minute, second, nano);
+    public static LocalTime of(int hour, int minute, int second, int nanoOfSecond) {
+        TimeArithmetic.check("HourOfDay", 0, 23, hour);
+        TimeArithmetic.check("MinuteOfHour", 0, 59, minute);
+        TimeArithmetic.check("SecondOfMinute", 0, 59, second);
+        TimeArithmetic.check("NanoOfSecond", 0, 999999999, nanoOfSecond);
+        return create(hour, minute, second, nanoOfSecond);
     }
 
     public static LocalTime ofSecondOfDay(long secondOfDay) {
+        TimeArithmetic.check("SecondOfDay", 0, 86399, secondOfDay);
         int hours = (int) (secondOfDay / 3600);
-        int minutes = (int) ((secondOfDay % 3600) / 60);
-        int seconds = (int) (secondOfDay % 60);
-        return of(hours, minutes, seconds);
+        secondOfDay -= hours * 3600L;
+        int minutes = (int) (secondOfDay / 60);
+        secondOfDay -= minutes * 60L;
+        return create(hours, minutes, (int) secondOfDay, 0);
     }
 
     public static LocalTime ofNanoOfDay(long nanoOfDay) {
-        long secondOfDay = nanoOfDay / DateTimeSupport.NANOS_PER_SECOND;
-        int nanos = (int) (nanoOfDay % DateTimeSupport.NANOS_PER_SECOND);
-        LocalTime base = ofSecondOfDay(secondOfDay);
-        return of(base.hour, base.minute, base.second, nanos);
+        TimeArithmetic.check("NanoOfDay", 0, NANOS_PER_DAY - 1, nanoOfDay);
+        int hours = (int) (nanoOfDay / NANOS_PER_HOUR);
+        nanoOfDay -= hours * NANOS_PER_HOUR;
+        int minutes = (int) (nanoOfDay / NANOS_PER_MINUTE);
+        nanoOfDay -= minutes * NANOS_PER_MINUTE;
+        int seconds = (int) (nanoOfDay / NANOS_PER_SECOND);
+        nanoOfDay -= seconds * NANOS_PER_SECOND;
+        return create(hours, minutes, seconds, (int) nanoOfDay);
+    }
+
+    /// The time of day of `temporal`.
+    public static LocalTime from(TemporalAccessor temporal) {
+        if (temporal instanceof LocalTime) {
+            return (LocalTime) temporal;
+        }
+        if (temporal instanceof LocalDateTime) {
+            return ((LocalDateTime) temporal).toLocalTime();
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toLocalTime();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toLocalTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain LocalTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static LocalTime parse(CharSequence text) {
-        return (LocalTime) DateTimeFormatter.ISO_LOCAL_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_LOCAL_TIME);
     }
 
     public static LocalTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (LocalTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public int getHour() {
@@ -82,50 +171,268 @@ public int toSecondOfDay() {
     }
 
     public long toNanoOfDay() {
-        return toSecondOfDay() * DateTimeSupport.NANOS_PER_SECOND + nano;
+        return hour * NANOS_PER_HOUR + minute * NANOS_PER_MINUTE + second * NANOS_PER_SECOND + nano;
+    }
+
+    /// This time of day on `date`.
+    public LocalDateTime atDate(LocalDate date) {
+        return LocalDateTime.of(date, this);
+    }
+
+    public LocalTime withHour(int hour) {
+        if (this.hour == hour) {
+            return this;
+        }
+        TimeArithmetic.check("HourOfDay", 0, 23, hour);
+        return create(hour, minute, second, nano);
+    }
+
+    public LocalTime withMinute(int minute) {
+        if (this.minute == minute) {
+            return this;
+        }
+        TimeArithmetic.check("MinuteOfHour", 0, 59, minute);
+        return create(hour, minute, second, nano);
+    }
+
+    public LocalTime withSecond(int second) {
+        if (this.second == second) {
+            return this;
+        }
+        TimeArithmetic.check("SecondOfMinute", 0, 59, second);
+        return create(hour, minute, second, nano);
+    }
+
+    public LocalTime withNano(int nanoOfSecond) {
+        if (this.nano == nanoOfSecond) {
+            return this;
+        }
+        TimeArithmetic.check("NanoOfSecond", 0, 999999999, nanoOfSecond);
+        return create(hour, minute, second, nanoOfSecond);
+    }
+
+    /// This time with everything smaller than `unit` set to zero. The unit
+    /// has to divide a day.
+    public LocalTime truncatedTo(TemporalUnit unit) {
+        if (unit == ChronoUnit.NANOS) {
+            return this;
+        }
+        long dur = TimeArithmetic.truncationNanos(unit);
+        long nod = toNanoOfDay();
+        return ofNanoOfDay((nod / dur) * dur);
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit.isTimeBased();
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public LocalTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return plusNanos(amountToAdd);
+            }
+            if (u == ChronoUnit.MICROS) {
+                return plusNanos((amountToAdd % 86400000000L) * 1000);
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return plusNanos((amountToAdd % 86400000L) * 1000000);
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return plusSeconds(amountToAdd);
+            }
+            if (u == ChronoUnit.MINUTES) {
+                return plusMinutes(amountToAdd);
+            }
+            if (u == ChronoUnit.HOURS) {
+                return plusHours(amountToAdd);
+            }
+            if (u == ChronoUnit.HALF_DAYS) {
+                return plusHours((amountToAdd % 2) * 12);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public LocalTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public LocalTime plus(TemporalAmount amount) {
+        return (LocalTime) amount.addTo(this);
+    }
+
+    @Override
+    public LocalTime minus(TemporalAmount amount) {
+        return (LocalTime) amount.subtractFrom(this);
     }
 
     public LocalTime plusHours(long hoursToAdd) {
-        return ofNanoOfDay(DateTimeSupport.floorMod(toNanoOfDay() + hoursToAdd * 3600L * DateTimeSupport.NANOS_PER_SECOND,
-                DateTimeSupport.NANOS_PER_DAY));
+        if (hoursToAdd == 0) {
+            return this;
+        }
+        int newHour = ((int) (hoursToAdd % 24) + hour + 24) % 24;
+        return create(newHour, minute, second, nano);
     }
 
     public LocalTime plusMinutes(long minutesToAdd) {
-        return ofNanoOfDay(DateTimeSupport.floorMod(toNanoOfDay() + minutesToAdd * 60L * DateTimeSupport.NANOS_PER_SECOND,
-                DateTimeSupport.NANOS_PER_DAY));
+        if (minutesToAdd == 0) {
+            return this;
+        }
+        int mofd = hour * 60 + minute;
+        int newMofd = ((int) (minutesToAdd % 1440) + mofd + 1440) % 1440;
+        if (mofd == newMofd) {
+            return this;
+        }
+        return create(newMofd / 60, newMofd % 60, second, nano);
+    }
+
+    public LocalTime plusSeconds(long secondstoAdd) {
+        if (secondstoAdd == 0) {
+            return this;
+        }
+        int sofd = toSecondOfDay();
+        int newSofd = ((int) (secondstoAdd % 86400) + sofd + 86400) % 86400;
+        if (sofd == newSofd) {
+            return this;
+        }
+        return create(newSofd / 3600, (newSofd / 60) % 60, newSofd % 60, nano);
     }
 
-    public LocalTime plusSeconds(long secondsToAdd) {
-        return ofNanoOfDay(DateTimeSupport.floorMod(toNanoOfDay() + secondsToAdd * DateTimeSupport.NANOS_PER_SECOND,
-                DateTimeSupport.NANOS_PER_DAY));
+    public LocalTime plusNanos(long nanosToAdd) {
+        if (nanosToAdd == 0) {
+            return this;
+        }
+        long nofd = toNanoOfDay();
+        long newNofd = ((nanosToAdd % NANOS_PER_DAY) + nofd + NANOS_PER_DAY) % NANOS_PER_DAY;
+        if (nofd == newNofd) {
+            return this;
+        }
+        return ofNanoOfDay(newNofd);
+    }
+
+    public LocalTime minusHours(long hoursToSubtract) {
+        return plusHours(-(hoursToSubtract % 24));
+    }
+
+    public LocalTime minusMinutes(long minutesToSubtract) {
+        return plusMinutes(-(minutesToSubtract % 1440));
+    }
+
+    public LocalTime minusSeconds(long secondsToSubtract) {
+        return plusSeconds(-(secondsToSubtract % 86400));
+    }
+
+    public LocalTime minusNanos(long nanosToSubtract) {
+        return plusNanos(-(nanosToSubtract % NANOS_PER_DAY));
+    }
+
+    /// The whole units of `unit` from this time to `endExclusive`, within
+    /// one day.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        LocalTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            long nanosUntil = end.toNanoOfDay() - toNanoOfDay();
+            ChronoUnit u = (ChronoUnit) unit;
+            if (u == ChronoUnit.NANOS) {
+                return nanosUntil;
+            }
+            if (u == ChronoUnit.MICROS) {
+                return nanosUntil / 1000;
+            }
+            if (u == ChronoUnit.MILLIS) {
+                return nanosUntil / 1000000;
+            }
+            if (u == ChronoUnit.SECONDS) {
+                return nanosUntil / NANOS_PER_SECOND;
+            }
+            if (u == ChronoUnit.MINUTES) {
+                return nanosUntil / NANOS_PER_MINUTE;
+            }
+            if (u == ChronoUnit.HOURS) {
+                return nanosUntil / NANOS_PER_HOUR;
+            }
+            if (u == ChronoUnit.HALF_DAYS) {
+                return nanosUntil / (12 * NANOS_PER_HOUR);
+            }
+            throw TimeArithmetic.unsupported(unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
     }
 
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
+    public boolean isAfter(LocalTime other) {
+        return compareTo(other) > 0;
+    }
+
+    public boolean isBefore(LocalTime other) {
+        return compareTo(other) < 0;
+    }
+
+    @Override
     public int compareTo(LocalTime other) {
-        if (hour != other.hour) {
-            return hour < other.hour ? -1 : 1;
-        }
-        if (minute != other.minute) {
-            return minute < other.minute ? -1 : 1;
-        }
-        if (second != other.second) {
-            return second < other.second ? -1 : 1;
-        }
-        return nano < other.nano ? -1 : nano > other.nano ? 1 : 0;
+        long a = toNanoOfDay();
+        long b = other.toNanoOfDay();
+        return a < b ? -1 : a > b ? 1 : 0;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof LocalTime && compareTo((LocalTime) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof LocalTime)) {
+            return false;
+        }
+        LocalTime other = (LocalTime) obj;
+        return hour == other.hour && minute == other.minute && second == other.second && nano == other.nano;
     }
 
+    @Override
     public int hashCode() {
-        return hour * 3600 + minute * 60 + second + nano;
+        long nod = toNanoOfDay();
+        return (int) (nod ^ (nod >>> 32));
     }
 
+    /// The JDK's text: `HH:mm`, then `:ss` when there are seconds or a
+    /// fraction, then the fraction in as many groups of three digits as it
+    /// needs.
+    @Override
     public String toString() {
-        return DateTimeFormatter.ISO_LOCAL_TIME.format(this);
+        StringBuilder buf = new StringBuilder(18);
+        buf.append(hour < 10 ? "0" : "").append(hour).append(minute < 10 ? ":0" : ":").append(minute);
+        if (second > 0 || nano > 0) {
+            buf.append(second < 10 ? ":0" : ":").append(second);
+            if (nano > 0) {
+                buf.append('.');
+                if (nano % 1000000 == 0) {
+                    buf.append(Integer.toString((nano / 1000000) + 1000).substring(1));
+                } else if (nano % 1000 == 0) {
+                    buf.append(Integer.toString((nano / 1000) + 1000000).substring(1));
+                } else {
+                    buf.append(Integer.toString(nano + 1000000000).substring(1));
+                }
+            }
+        }
+        return buf.toString();
     }
 }
diff --git a/vm/JavaAPI/src/java/time/Month.java b/vm/JavaAPI/src/java/time/Month.java
new file mode 100644
index 00000000000..3d2ef98b516
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/Month.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time;
+
+import java.time.temporal.TemporalAccessor;
+
+/// The twelve months of the ISO calendar.
+public enum Month implements TemporalAccessor {
+    /// January, month 1.
+    JANUARY,
+    /// February, month 2.
+    FEBRUARY,
+    /// March, month 3.
+    MARCH,
+    /// April, month 4.
+    APRIL,
+    /// May, month 5.
+    MAY,
+    /// June, month 6.
+    JUNE,
+    /// July, month 7.
+    JULY,
+    /// August, month 8.
+    AUGUST,
+    /// September, month 9.
+    SEPTEMBER,
+    /// October, month 10.
+    OCTOBER,
+    /// November, month 11.
+    NOVEMBER,
+    /// December, month 12.
+    DECEMBER;
+
+    private static final Month[] ALL = values();
+
+    /// The month numbered `month`, 1 for January to 12 for December.
+    public static Month of(int month) {
+        if (month < 1 || month > 12) {
+            throw new DateTimeException("Invalid value for MonthOfYear: " + month);
+        }
+        return ALL[month - 1];
+    }
+
+    /// 1 for January to 12 for December.
+    public int getValue() {
+        return ordinal() + 1;
+    }
+
+    /// The month `months` later, around the year.
+    public Month plus(long months) {
+        int amount = (int) (months % 12);
+        return ALL[(ordinal() + amount + 12) % 12];
+    }
+
+    /// The month `months` earlier, around the year.
+    public Month minus(long months) {
+        return plus(-(months % 12));
+    }
+
+    /// The number of days of this month in a leap year or another.
+    public int length(boolean leapYear) {
+        // Not a switch: one over an enum compiles to a class that catches
+        // NoSuchFieldError, which a device does not have.
+        if (this == FEBRUARY) {
+            return leapYear ? 29 : 28;
+        }
+        if (this == APRIL || this == JUNE || this == SEPTEMBER || this == NOVEMBER) {
+            return 30;
+        }
+        return 31;
+    }
+
+    /// The fewest days this month can have.
+    public int minLength() {
+        return length(false);
+    }
+
+    /// The most days this month can have.
+    public int maxLength() {
+        return length(true);
+    }
+
+    /// The day of the year this month starts on, 1 for January.
+    public int firstDayOfYear(boolean leapYear) {
+        int day = 1;
+        for (int i = 0; i < ordinal(); i++) {
+            day += ALL[i].length(leapYear);
+        }
+        return day;
+    }
+
+    /// The first month of the quarter this month is in.
+    public Month firstMonthOfQuarter() {
+        return ALL[ordinal() / 3 * 3];
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/OffsetDateTime.java b/vm/JavaAPI/src/java/time/OffsetDateTime.java
index 5de661396cf..5e175e1f420 100644
--- a/vm/JavaAPI/src/java/time/OffsetDateTime.java
+++ b/vm/JavaAPI/src/java/time/OffsetDateTime.java
@@ -1,17 +1,69 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+
+/// A date and time with a fixed offset from UTC, such as
+/// 2007-12-03T10:15:30+01:00.
+public final class OffsetDateTime implements Temporal, Comparable<OffsetDateTime> {
+    /// The earliest date and time, at the largest offset.
+    public static final OffsetDateTime MIN = new OffsetDateTime(LocalDateTime.MIN, ZoneOffset.MAX);
+
+    /// The latest date and time, at the smallest offset.
+    public static final OffsetDateTime MAX = new OffsetDateTime(LocalDateTime.MAX, ZoneOffset.MIN);
 
-public final class OffsetDateTime implements Comparable<OffsetDateTime>, TemporalAccessor {
     private final LocalDateTime dateTime;
     private final ZoneOffset offset;
 
     private OffsetDateTime(LocalDateTime dateTime, ZoneOffset offset) {
+        if (dateTime == null) {
+            throw new NullPointerException("dateTime");
+        }
+        if (offset == null) {
+            throw new NullPointerException("offset");
+        }
         this.dateTime = dateTime;
         this.offset = offset;
     }
 
+    public static OffsetDateTime now() {
+        return now(Clock.systemDefaultZone());
+    }
+
+    public static OffsetDateTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
+    public static OffsetDateTime now(Clock clock) {
+        return ofInstant(clock.instant(), clock.getZone());
+    }
+
     public static OffsetDateTime of(LocalDate date, LocalTime time, ZoneOffset offset) {
         return new OffsetDateTime(LocalDateTime.of(date, time), offset);
     }
@@ -20,24 +72,67 @@ public static OffsetDateTime of(LocalDateTime dateTime, ZoneOffset offset) {
         return new OffsetDateTime(dateTime, offset);
     }
 
+    public static OffsetDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second,
+            int nanoOfSecond, ZoneOffset offset) {
+        return new OffsetDateTime(LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond),
+                offset);
+    }
+
     public static OffsetDateTime ofInstant(Instant instant, ZoneId zone) {
+        if (instant == null) {
+            throw new NullPointerException("instant");
+        }
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
         ZoneOffset offset = DateTimeSupport.offsetFromInstant(instant, zone);
-        LocalDateTime local = LocalDateTime.ofInstant(instant, zone);
-        return new OffsetDateTime(local, offset);
+        return new OffsetDateTime(LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset),
+                offset);
+    }
+
+    /// The date, time and offset of `temporal`.
+    public static OffsetDateTime from(TemporalAccessor temporal) {
+        if (temporal instanceof OffsetDateTime) {
+            return (OffsetDateTime) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).toOffsetDateTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain OffsetDateTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static OffsetDateTime parse(CharSequence text) {
-        return (OffsetDateTime) DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_OFFSET_DATE_TIME);
     }
 
     public static OffsetDateTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (OffsetDateTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
     public LocalDateTime toLocalDateTime() {
         return dateTime;
     }
 
+    public LocalDate toLocalDate() {
+        return dateTime.toLocalDate();
+    }
+
+    public LocalTime toLocalTime() {
+        return dateTime.toLocalTime();
+    }
+
     public ZoneOffset getOffset() {
         return offset;
     }
@@ -46,28 +141,285 @@ public Instant toInstant() {
         return dateTime.toInstant(offset);
     }
 
+    public long toEpochSecond() {
+        return dateTime.toEpochSecond(offset);
+    }
+
+    /// This date and time, as a moment in `offset`'s own zone.
+    public ZonedDateTime toZonedDateTime() {
+        return ZonedDateTime.of(dateTime, offset);
+    }
+
+    /// The same moment in `zone`.
+    public ZonedDateTime atZoneSameInstant(ZoneId zone) {
+        return ZonedDateTime.ofInstant(dateTime, offset, zone);
+    }
+
+    /// The same moment at another offset.
+    public OffsetDateTime withOffsetSameInstant(ZoneOffset offset) {
+        if (offset.equals(this.offset)) {
+            return this;
+        }
+        int difference = offset.getTotalSeconds() - this.offset.getTotalSeconds();
+        return new OffsetDateTime(dateTime.plusSeconds(difference), offset);
+    }
+
+    /// The same wall clock time at another offset.
+    public OffsetDateTime withOffsetSameLocal(ZoneOffset offset) {
+        return offset.equals(this.offset) ? this : new OffsetDateTime(dateTime, offset);
+    }
+
+    public int getYear() {
+        return dateTime.getYear();
+    }
+
+    public int getMonthValue() {
+        return dateTime.getMonthValue();
+    }
+
+    public Month getMonth() {
+        return dateTime.getMonth();
+    }
+
+    public int getDayOfMonth() {
+        return dateTime.getDayOfMonth();
+    }
+
+    public int getDayOfYear() {
+        return dateTime.getDayOfYear();
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return dateTime.getDayOfWeek();
+    }
+
+    public int getHour() {
+        return dateTime.getHour();
+    }
+
+    public int getMinute() {
+        return dateTime.getMinute();
+    }
+
+    public int getSecond() {
+        return dateTime.getSecond();
+    }
+
+    public int getNano() {
+        return dateTime.getNano();
+    }
+
+    private OffsetDateTime with(LocalDateTime newDateTime) {
+        return newDateTime == dateTime ? this : new OffsetDateTime(newDateTime, offset);
+    }
+
+    public OffsetDateTime withYear(int year) {
+        return with(dateTime.withYear(year));
+    }
+
+    public OffsetDateTime withMonth(int month) {
+        return with(dateTime.withMonth(month));
+    }
+
+    public OffsetDateTime withDayOfMonth(int dayOfMonth) {
+        return with(dateTime.withDayOfMonth(dayOfMonth));
+    }
+
+    public OffsetDateTime withDayOfYear(int dayOfYear) {
+        return with(dateTime.withDayOfYear(dayOfYear));
+    }
+
+    public OffsetDateTime withHour(int hour) {
+        return with(dateTime.withHour(hour));
+    }
+
+    public OffsetDateTime withMinute(int minute) {
+        return with(dateTime.withMinute(minute));
+    }
+
+    public OffsetDateTime withSecond(int second) {
+        return with(dateTime.withSecond(second));
+    }
+
+    public OffsetDateTime withNano(int nanoOfSecond) {
+        return with(dateTime.withNano(nanoOfSecond));
+    }
+
+    public OffsetDateTime truncatedTo(TemporalUnit unit) {
+        return with(dateTime.truncatedTo(unit));
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit != ChronoUnit.FOREVER;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public OffsetDateTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return with(dateTime.plus(amountToAdd, unit));
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public OffsetDateTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public OffsetDateTime plus(TemporalAmount amount) {
+        if (amount == null) {
+            throw new NullPointerException("amountToAdd");
+        }
+        return (OffsetDateTime) amount.addTo(this);
+    }
+
+    @Override
+    public OffsetDateTime minus(TemporalAmount amount) {
+        if (amount == null) {
+            throw new NullPointerException("amountToSubtract");
+        }
+        return (OffsetDateTime) amount.subtractFrom(this);
+    }
+
+    public OffsetDateTime plusYears(long years) {
+        return with(dateTime.plusYears(years));
+    }
+
+    public OffsetDateTime plusMonths(long months) {
+        return with(dateTime.plusMonths(months));
+    }
+
+    public OffsetDateTime plusWeeks(long weeks) {
+        return with(dateTime.plusWeeks(weeks));
+    }
+
+    public OffsetDateTime plusDays(long days) {
+        return with(dateTime.plusDays(days));
+    }
+
+    public OffsetDateTime plusHours(long hours) {
+        return with(dateTime.plusHours(hours));
+    }
+
+    public OffsetDateTime plusMinutes(long minutes) {
+        return with(dateTime.plusMinutes(minutes));
+    }
+
+    public OffsetDateTime plusSeconds(long seconds) {
+        return with(dateTime.plusSeconds(seconds));
+    }
+
+    public OffsetDateTime plusNanos(long nanos) {
+        return with(dateTime.plusNanos(nanos));
+    }
+
+    public OffsetDateTime minusYears(long years) {
+        return with(dateTime.minusYears(years));
+    }
+
+    public OffsetDateTime minusMonths(long months) {
+        return with(dateTime.minusMonths(months));
+    }
+
+    public OffsetDateTime minusWeeks(long weeks) {
+        return with(dateTime.minusWeeks(weeks));
+    }
+
+    public OffsetDateTime minusDays(long days) {
+        return with(dateTime.minusDays(days));
+    }
+
+    public OffsetDateTime minusHours(long hours) {
+        return with(dateTime.minusHours(hours));
+    }
+
+    public OffsetDateTime minusMinutes(long minutes) {
+        return with(dateTime.minusMinutes(minutes));
+    }
+
+    public OffsetDateTime minusSeconds(long seconds) {
+        return with(dateTime.minusSeconds(seconds));
+    }
+
+    public OffsetDateTime minusNanos(long nanos) {
+        return with(dateTime.minusNanos(nanos));
+    }
+
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        OffsetDateTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            end = end.withOffsetSameInstant(offset);
+            return dateTime.until(end.dateTime, unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
+    }
+
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
+    public boolean isAfter(OffsetDateTime other) {
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        return a > b || (a == b && getNano() > other.getNano());
+    }
+
+    public boolean isBefore(OffsetDateTime other) {
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        return a < b || (a == b && getNano() < other.getNano());
+    }
+
+    public boolean isEqual(OffsetDateTime other) {
+        return toEpochSecond() == other.toEpochSecond() && getNano() == other.getNano();
+    }
+
+    /// Orders by moment, and moments that are equal by wall clock time.
     public int compareTo(OffsetDateTime other) {
-        int cmp = toInstant().compareTo(other.toInstant());
-        return cmp != 0 ? cmp : dateTime.compareTo(other.dateTime);
+        if (offset.equals(other.offset)) {
+            return dateTime.compareTo(other.dateTime);
+        }
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        int cmp = a < b ? -1 : (a > b ? 1 : 0);
+        if (cmp == 0) {
+            cmp = getNano() - other.getNano();
+            if (cmp == 0) {
+                cmp = dateTime.compareTo(other.dateTime);
+            }
+        }
+        return cmp;
     }
 
     public boolean equals(Object obj) {
-        return obj instanceof OffsetDateTime && compareTo((OffsetDateTime) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OffsetDateTime)) {
+            return false;
+        }
+        OffsetDateTime other = (OffsetDateTime) obj;
+        return dateTime.equals(other.dateTime) && offset.equals(other.offset);
     }
 
     public int hashCode() {
-        return dateTime.hashCode() * 31 + offset.hashCode();
+        return dateTime.hashCode() ^ offset.hashCode();
     }
 
     public String toString() {
-        return DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(this);
-    }
-
-    ZoneId getZoneForFormatting() {
-        return offset;
+        return dateTime.toString() + offset.toString();
     }
 }
diff --git a/vm/JavaAPI/src/java/time/Period.java b/vm/JavaAPI/src/java/time/Period.java
index 3fab3574b7c..77b61b2ab6c 100644
--- a/vm/JavaAPI/src/java/time/Period.java
+++ b/vm/JavaAPI/src/java/time/Period.java
@@ -1,6 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
-public final class Period {
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.time.temporal.UnsupportedTemporalTypeException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/// An amount of calendar time in years, months and days, such as
+/// "2 years, 3 months and 4 days". The three are kept apart and never
+/// converted into one another except by [#normalized].
+public final class Period implements TemporalAmount {
+    public static final Period ZERO = new Period(0, 0, 0);
+
     private final int years;
     private final int months;
     private final int days;
@@ -11,20 +47,157 @@ private Period(int years, int months, int days) {
         this.days = days;
     }
 
-    public static Period of(int years, int months, int days) {
+    private static Period create(int years, int months, int days) {
+        if ((years | months | days) == 0) {
+            return ZERO;
+        }
         return new Period(years, months, days);
     }
 
+    public static Period of(int years, int months, int days) {
+        return create(years, months, days);
+    }
+
     public static Period ofDays(int days) {
-        return new Period(0, 0, days);
+        return create(0, 0, days);
+    }
+
+    public static Period ofWeeks(int weeks) {
+        return create(0, 0, TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) weeks, 7L)));
     }
 
     public static Period ofMonths(int months) {
-        return new Period(0, months, 0);
+        return create(0, months, 0);
     }
 
     public static Period ofYears(int years) {
-        return new Period(years, 0, 0);
+        return create(years, 0, 0);
+    }
+
+    /// The years, months and days from `startDateInclusive` to
+    /// `endDateExclusive`.
+    public static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive) {
+        return startDateInclusive.until(endDateExclusive);
+    }
+
+    /// The period of `amount`, which must be in years, months and days.
+    public static Period from(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            return (Period) amount;
+        }
+        if (amount == null) {
+            throw new NullPointerException("amount");
+        }
+        int years = 0;
+        int months = 0;
+        int days = 0;
+        List<TemporalUnit> units = amount.getUnits();
+        for (int i = 0; i < units.size(); i++) {
+            TemporalUnit unit = units.get(i);
+            long value = amount.get(unit);
+            if (unit == ChronoUnit.YEARS) {
+                years = TimeArithmetic.toIntExact(value);
+            } else if (unit == ChronoUnit.MONTHS) {
+                months = TimeArithmetic.toIntExact(value);
+            } else if (unit == ChronoUnit.DAYS) {
+                days = TimeArithmetic.toIntExact(value);
+            } else {
+                throw new DateTimeException("Unit must be Years, Months or Days, but was " + unit);
+            }
+        }
+        return create(years, months, days);
+    }
+
+    /// Reads `PnYnMnWnD`: each section optional but at least one present,
+    /// each number signed, the letters in either case, and a leading sign
+    /// negating the whole. Weeks are added to the days.
+    public static Period parse(CharSequence text) {
+        if (text == null) {
+            throw new NullPointerException("text");
+        }
+        String s = text.toString();
+        int pos = 0;
+        boolean negate = false;
+        if (pos < s.length() && (s.charAt(pos) == '+' || s.charAt(pos) == '-')) {
+            negate = s.charAt(pos) == '-';
+            pos++;
+        }
+        if (pos >= s.length() || (s.charAt(pos) != 'P' && s.charAt(pos) != 'p')) {
+            throw unparsablePeriod(s, null);
+        }
+        pos++;
+        String order = "YMWD";
+        long[] values = new long[4];
+        int next = 0;
+        boolean any = false;
+        try {
+            while (pos < s.length()) {
+                int start = pos;
+                if (s.charAt(pos) == '+' || s.charAt(pos) == '-') {
+                    pos++;
+                }
+                int digits = pos;
+                while (pos < s.length() && s.charAt(pos) >= '0' && s.charAt(pos) <= '9') {
+                    pos++;
+                }
+                if (pos == digits || pos >= s.length()) {
+                    throw unparsablePeriod(s, null);
+                }
+                char letter = Character.toUpperCase(s.charAt(pos));
+                int slot = order.indexOf(letter, next);
+                if (slot < 0) {
+                    throw unparsablePeriod(s, null);
+                }
+                values[slot] = Integer.parseInt(s.substring(s.charAt(start) == '+' ? start + 1 : start, pos));
+                next = slot + 1;
+                any = true;
+                pos++;
+            }
+        } catch (NumberFormatException ex) {
+            throw unparsablePeriod(s, ex);
+        }
+        if (!any) {
+            throw unparsablePeriod(s, null);
+        }
+        if (negate) {
+            for (int i = 0; i < values.length; i++) {
+                if (values[i] == Integer.MIN_VALUE) {
+                    throw unparsablePeriod(s, new ArithmeticException("integer overflow"));
+                }
+                values[i] = -values[i];
+            }
+        }
+        // Weeks join the days outside the reading, so an overflow there is
+        // the arithmetic's own exception, as the JDK's is.
+        int days = TimeArithmetic.toIntExact(values[3] + TimeArithmetic.toIntExact(values[2] * 7));
+        return create((int) values[0], (int) values[1], days);
+    }
+
+    private static java.time.format.DateTimeParseException unparsablePeriod(String text, Throwable cause) {
+        return new java.time.format.DateTimeParseException("Text cannot be parsed to a Period", text, 0, cause);
+    }
+
+    @Override
+    public long get(TemporalUnit unit) {
+        if (unit == ChronoUnit.YEARS) {
+            return years;
+        }
+        if (unit == ChronoUnit.MONTHS) {
+            return months;
+        }
+        if (unit == ChronoUnit.DAYS) {
+            return days;
+        }
+        throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+    }
+
+    @Override
+    public List<TemporalUnit> getUnits() {
+        ArrayList<TemporalUnit> units = new ArrayList<TemporalUnit>(3);
+        units.add(ChronoUnit.YEARS);
+        units.add(ChronoUnit.MONTHS);
+        units.add(ChronoUnit.DAYS);
+        return Collections.unmodifiableList(units);
     }
 
     public int getYears() {
@@ -39,19 +212,166 @@ public int getDays() {
         return days;
     }
 
-    public LocalDate addTo(LocalDate date) {
-        return date.plusYears(years).plusMonths(months).plusDays(days);
+    public boolean isZero() {
+        return this == ZERO || (years | months | days) == 0;
+    }
+
+    public boolean isNegative() {
+        return years < 0 || months < 0 || days < 0;
+    }
+
+    public Period withYears(int years) {
+        return years == this.years ? this : create(years, months, days);
+    }
+
+    public Period withMonths(int months) {
+        return months == this.months ? this : create(years, months, days);
+    }
+
+    public Period withDays(int days) {
+        return days == this.days ? this : create(years, months, days);
+    }
+
+    /// This period plus `amountToAdd`, which must be in years, months and
+    /// days; each unit is added to its own.
+    public Period plus(TemporalAmount amountToAdd) {
+        Period other = from(amountToAdd);
+        return create(TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) years, (long) other.years)),
+                TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) months, (long) other.months)),
+                TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) days, (long) other.days)));
+    }
+
+    public Period minus(TemporalAmount amountToSubtract) {
+        Period other = from(amountToSubtract);
+        return create(TimeArithmetic.toIntExact(TimeArithmetic.subtractExact((long) years, (long) other.years)),
+                TimeArithmetic.toIntExact(TimeArithmetic.subtractExact((long) months, (long) other.months)),
+                TimeArithmetic.toIntExact(TimeArithmetic.subtractExact((long) days, (long) other.days)));
+    }
+
+    public Period plusYears(long yearsToAdd) {
+        return yearsToAdd == 0 ? this
+                : create(TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) years, yearsToAdd)), months, days);
+    }
+
+    public Period plusMonths(long monthsToAdd) {
+        return monthsToAdd == 0 ? this
+                : create(years, TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) months, monthsToAdd)), days);
+    }
+
+    public Period plusDays(long daysToAdd) {
+        return daysToAdd == 0 ? this
+                : create(years, months, TimeArithmetic.toIntExact(TimeArithmetic.addExact((long) days, daysToAdd)));
+    }
+
+    public Period minusYears(long yearsToSubtract) {
+        return yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1)
+                : plusYears(-yearsToSubtract);
+    }
+
+    public Period minusMonths(long monthsToSubtract) {
+        return monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1)
+                : plusMonths(-monthsToSubtract);
+    }
+
+    public Period minusDays(long daysToSubtract) {
+        return daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1)
+                : plusDays(-daysToSubtract);
+    }
+
+    public Period multipliedBy(int scalar) {
+        if (this == ZERO || scalar == 1) {
+            return this;
+        }
+        return create(TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) years, (long) scalar)),
+                TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) months, (long) scalar)),
+                TimeArithmetic.toIntExact(TimeArithmetic.multiplyExact((long) days, (long) scalar)));
+    }
+
+    public Period negated() {
+        return multipliedBy(-1);
+    }
+
+    /// The years and months rebalanced so that the months lie within
+    /// -11 to 11 with the sign of the years; the days are left as they are.
+    public Period normalized() {
+        long totalMonths = toTotalMonths();
+        long splitYears = totalMonths / 12;
+        int splitMonths = (int) (totalMonths % 12);
+        if (splitYears == years && splitMonths == months) {
+            return this;
+        }
+        return create(TimeArithmetic.toIntExact(splitYears), splitMonths, days);
+    }
+
+    public long toTotalMonths() {
+        return years * 12L + months;
+    }
+
+    /// Adds the years and months together, then the days, as the JDK does:
+    /// a date at the end of a month stays valid in between.
+    @Override
+    public Temporal addTo(Temporal temporal) {
+        if (months == 0) {
+            if (years != 0) {
+                temporal = temporal.plus(years, ChronoUnit.YEARS);
+            }
+        } else {
+            long totalMonths = toTotalMonths();
+            if (totalMonths != 0) {
+                temporal = temporal.plus(totalMonths, ChronoUnit.MONTHS);
+            }
+        }
+        if (days != 0) {
+            temporal = temporal.plus(days, ChronoUnit.DAYS);
+        }
+        return temporal;
+    }
+
+    @Override
+    public Temporal subtractFrom(Temporal temporal) {
+        if (months == 0) {
+            if (years != 0) {
+                temporal = temporal.minus(years, ChronoUnit.YEARS);
+            }
+        } else {
+            long totalMonths = toTotalMonths();
+            if (totalMonths != 0) {
+                temporal = temporal.minus(totalMonths, ChronoUnit.MONTHS);
+            }
+        }
+        if (days != 0) {
+            temporal = temporal.minus(days, ChronoUnit.DAYS);
+        }
+        return temporal;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Period)) {
+            return false;
+        }
+        Period other = (Period) obj;
+        return years == other.years && months == other.months && days == other.days;
+    }
+
+    public int hashCode() {
+        return years + ((months << 8) | (months >>> 24)) + ((days << 16) | (days >>> 16));
     }
 
     public String toString() {
-        StringBuffer sb = new StringBuffer("P");
+        if (this == ZERO || (years | months | days) == 0) {
+            return "P0D";
+        }
+        StringBuilder sb = new StringBuilder("P");
         if (years != 0) {
             sb.append(years).append('Y');
         }
         if (months != 0) {
             sb.append(months).append('M');
         }
-        if (days != 0 || (years == 0 && months == 0)) {
+        if (days != 0) {
             sb.append(days).append('D');
         }
         return sb.toString();
diff --git a/vm/JavaAPI/src/java/time/TimeArithmetic.java b/vm/JavaAPI/src/java/time/TimeArithmetic.java
new file mode 100644
index 00000000000..ca3f529cbba
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/TimeArithmetic.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time;
+
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalUnit;
+import java.time.temporal.UnsupportedTemporalTypeException;
+
+/// Exact arithmetic and unit tables the date and time classes share. The
+/// exact operations throw `ArithmeticException("long overflow")` where the
+/// JDK's `Math.*Exact` do, rather than wrapping around.
+final class TimeArithmetic {
+    static final long NANOS_PER_SECOND = 1000000000L;
+    static final long SECONDS_PER_DAY = 86400L;
+    static final long NANOS_PER_DAY = SECONDS_PER_DAY * NANOS_PER_SECOND;
+
+    /// The whole seconds of each `ChronoUnit`, by ordinal; 0 below a second.
+    private static final long[] UNIT_SECONDS = {0L, 0L, 0L, 1L, 60L, 3600L, 43200L, 86400L, 604800L,
+        2629746L, 31556952L, 315569520L, 3155695200L, 31556952000L, 31556952000000000L, Long.MAX_VALUE};
+
+    /// The nanoseconds in one unit below a second, by ordinal; 0 above.
+    private static final long[] UNIT_NANOS = {1L, 1000L, 1000000L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
+        0L, 0L, 0L};
+
+    private TimeArithmetic() {
+    }
+
+    static long floorDiv(long a, long b) {
+        long q = a / b;
+        return (a % b != 0 && ((a < 0) != (b < 0))) ? q - 1 : q;
+    }
+
+    static long floorMod(long a, long b) {
+        return a - floorDiv(a, b) * b;
+    }
+
+    static long multiplyExact(long a, long b) {
+        long r = a * b;
+        long absA = a < 0 ? -a : a;
+        long absB = b < 0 ? -b : b;
+        // MIN_VALUE * -1 is tested before the division: ParparVM divides in
+        // C, where MIN_VALUE / -1 is undefined and traps (SIGFPE) on x86.
+        if (((absA | absB) >>> 31) != 0
+                && (a == Long.MIN_VALUE && b == -1 || b != 0 && r / b != a)) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    static long addExact(long a, long b) {
+        long r = a + b;
+        if (((a ^ r) & (b ^ r)) < 0) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    static long subtractExact(long a, long b) {
+        long r = a - b;
+        if (((a ^ b) & (a ^ r)) < 0) {
+            throw new ArithmeticException("long overflow");
+        }
+        return r;
+    }
+
+    static int toIntExact(long value) {
+        if ((int) value != value) {
+            throw new ArithmeticException("integer overflow");
+        }
+        return (int) value;
+    }
+
+    /// `unit` as a `ChronoUnit`, or the JDK's refusal of a unit it cannot add.
+    /// The length in nanoseconds of a unit to truncate a time to. Any unit
+    /// will do, a custom one included, as long as its duration divides a
+    /// standard day: that is the JDK's rule, and the reason it reads the
+    /// duration rather than requiring a [ChronoUnit].
+    static long truncationNanos(TemporalUnit unit) {
+        java.time.Duration length = unit.getDuration();
+        if (length.getSeconds() > SECONDS_PER_DAY) {
+            throw new UnsupportedTemporalTypeException("Unit is too large to be used for truncation");
+        }
+        long dur = length.toNanos();
+        if (dur <= 0 || NANOS_PER_DAY % dur != 0) {
+            throw new UnsupportedTemporalTypeException("Unit must divide into a standard day without remainder");
+        }
+        return dur;
+    }
+
+    static ChronoUnit chrono(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return (ChronoUnit) unit;
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        throw unsupported(unit);
+    }
+
+    static UnsupportedTemporalTypeException unsupported(Object unit) {
+        return new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
+    }
+
+    /// The whole seconds in one `unit`, 0 for the units shorter than a second.
+    static long seconds(ChronoUnit unit) {
+        return UNIT_SECONDS[unit.ordinal()];
+    }
+
+    /// The nanoseconds in one `unit` shorter than a second, 0 for the others.
+    static long nanos(ChronoUnit unit) {
+        return UNIT_NANOS[unit.ordinal()];
+    }
+
+    /// The whole units between two moments given as seconds and nanoseconds,
+    /// the fraction dropped towards zero.
+    static long timeUntil(long s1, long n1, long s2, long n2, ChronoUnit unit) {
+        long seconds = s2 - s1;
+        long nanos = n2 - n1;
+        if (seconds > 0 && nanos < 0) {
+            seconds--;
+            nanos += NANOS_PER_SECOND;
+        } else if (seconds < 0 && nanos > 0) {
+            seconds++;
+            nanos -= NANOS_PER_SECOND;
+        }
+        long perNanos = nanos(unit);
+        if (perNanos != 0) {
+            return addExact(multiplyExact(seconds, NANOS_PER_SECOND / perNanos), nanos / perNanos);
+        }
+        return seconds / seconds(unit);
+    }
+
+    /// The nanosecond of the second of a value that has a time, 0 for one
+    /// that has none.
+    static int nanoOfSecond(Object value) {
+        if (value instanceof Instant) {
+            return ((Instant) value).getNano();
+        }
+        if (value instanceof LocalTime) {
+            return ((LocalTime) value).getNano();
+        }
+        if (value instanceof LocalDateTime) {
+            return ((LocalDateTime) value).getNano();
+        }
+        if (value instanceof ZonedDateTime) {
+            return ((ZonedDateTime) value).getNano();
+        }
+        if (value instanceof OffsetDateTime) {
+            return ((OffsetDateTime) value).toLocalDateTime().getNano();
+        }
+        return 0;
+    }
+
+    /// `value`, or the JDK's `DateTimeException` for a field outside
+    /// `min` to `max`.
+    static long check(String field, long min, long max, long value) {
+        if (value < min || value > max) {
+            throw new DateTimeException("Invalid value for " + field + " (valid values " + min + " - " + max
+                    + "): " + value);
+        }
+        return value;
+    }
+
+    static DateTimeException instantOutOfRange() {
+        return new DateTimeException("Instant exceeds minimum or maximum instant");
+    }
+
+    /// What `parse(text, formatter)` throws when the text was read but does
+    /// not make the value asked for.
+    static java.time.format.DateTimeParseException unparsable(CharSequence text, DateTimeException cause) {
+        return new java.time.format.DateTimeParseException("Text '" + text + "' could not be parsed: "
+                + cause.getMessage(), text, 0, cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/ZoneId.java b/vm/JavaAPI/src/java/time/ZoneId.java
index 47b9cabc1af..958a9b6c2ea 100644
--- a/vm/JavaAPI/src/java/time/ZoneId.java
+++ b/vm/JavaAPI/src/java/time/ZoneId.java
@@ -1,48 +1,165 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
-import com.codename1.impl.time.TimeZoneSupport;
 import java.util.TimeZone;
 
+/// A time zone: either a fixed [ZoneOffset], or a region such as
+/// `Europe/Paris` whose offsets come from the platform's time zone rules.
+///
+/// As in the JDK, `ZoneId.of("UTC")` and `ZoneId.of("GMT")` are regions
+/// named that way, not [ZoneOffset#UTC] (whose id is `Z`), and
+/// `ZoneId.of("UTC+01:00")` keeps its prefix in its id.
 public class ZoneId {
     private final String id;
+    /// The offset of a region that never changes it (`UTC`, `GMT`, `UT`
+    /// and those followed by an offset), or null.
+    private final ZoneOffset fixed;
 
     ZoneId(String id) {
+        this(id, null);
+    }
+
+    private ZoneId(String id, ZoneOffset fixed) {
         this.id = id;
+        this.fixed = fixed;
     }
 
     public static ZoneId of(String zoneId) {
         if (zoneId == null) {
-            throw new NullPointerException();
-        }
-        if ("Z".equals(zoneId) || "UTC".equals(zoneId) || "GMT".equals(zoneId)) {
-            return ZoneOffset.UTC;
+            throw new NullPointerException("zoneId");
         }
-        if (zoneId.startsWith("+") || zoneId.startsWith("-")) {
+        if (zoneId.length() <= 1 || zoneId.startsWith("+") || zoneId.startsWith("-")) {
             return ZoneOffset.of(zoneId);
         }
-        if (zoneId.startsWith("UTC+") || zoneId.startsWith("UTC-")) {
-            return ZoneOffset.of(zoneId.substring(3));
+        if (zoneId.startsWith("UTC") || zoneId.startsWith("GMT")) {
+            return ofPrefixed(zoneId, 3);
+        }
+        if (zoneId.startsWith("UT")) {
+            return ofPrefixed(zoneId, 2);
+        }
+        for (int i = 0; i < zoneId.length(); i++) {
+            char c = zoneId.charAt(i);
+            boolean ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+                    || c == '~' || c == '/' || c == '.' || c == '_' || c == '+' || c == '-';
+            if (!ok) {
+                throw new DateTimeException("Invalid ID for region-based ZoneId, invalid format: " + zoneId);
+            }
+        }
+        // A well-formed region ID is accepted without checking it names a
+        // real region, where the JDK throws ZoneRulesException. That is
+        // deliberate: a device has no zone database to check against -- the
+        // rules come from the OS one lookup at a time, through TimeZone, and
+        // TimeZone.getAvailableIDs() answers only GMT and the default zone --
+        // so validating would mean a new native on every port for an error
+        // case. Its rules are whatever java.util.TimeZone.getTimeZone gives
+        // the same ID, which -- on the JDK as here -- does not throw for an
+        // unknown one either.
+        return new ZoneId(zoneId, null);
+    }
+
+    private static ZoneId ofPrefixed(String zoneId, int prefixLength) {
+        String prefix = zoneId.substring(0, prefixLength);
+        if (zoneId.length() == prefixLength) {
+            return new ZoneId(prefix, ZoneOffset.UTC);
+        }
+        char sign = zoneId.charAt(prefixLength);
+        if (sign != '+' && sign != '-') {
+            // GMT0 and the like: a region of its own.
+            return of0(zoneId);
+        }
+        ZoneOffset offset;
+        try {
+            offset = ZoneOffset.of(zoneId.substring(prefixLength));
+        } catch (DateTimeException ex) {
+            throw new DateTimeException("Invalid ID for offset-based ZoneId: " + zoneId);
         }
-        if (zoneId.startsWith("GMT+") || zoneId.startsWith("GMT-")) {
-            return ZoneOffset.of(zoneId.substring(3));
+        if (offset.getTotalSeconds() == 0) {
+            return new ZoneId(prefix, ZoneOffset.UTC);
         }
-        return new ZoneId(zoneId);
+        return new ZoneId(prefix + offset.getId(), offset);
+    }
+
+    private static ZoneId of0(String zoneId) {
+        return new ZoneId(zoneId, "GMT0".equals(zoneId) ? ZoneOffset.UTC : null);
     }
 
     public static ZoneId systemDefault() {
         return of(TimeZone.getDefault().getID());
     }
 
+    /// The zone `prefix` followed by `offset`: `UTC+01:00` for `UTC`,
+    /// just `UTC` for a zero offset.
+    public static ZoneId ofOffset(String prefix, ZoneOffset offset) {
+        if (prefix == null || offset == null) {
+            throw new NullPointerException();
+        }
+        if (prefix.length() == 0) {
+            return offset;
+        }
+        if (!prefix.equals("GMT") && !prefix.equals("UTC") && !prefix.equals("UT")) {
+            throw new IllegalArgumentException("prefix should be GMT, UTC or UT, is: " + prefix);
+        }
+        if (offset.getTotalSeconds() == 0) {
+            return new ZoneId(prefix, ZoneOffset.UTC);
+        }
+        return new ZoneId(prefix + offset.getId(), offset);
+    }
+
     public String getId() {
         return id;
     }
 
+    /// This zone as a [ZoneOffset] when its offset never changes, and
+    /// itself otherwise.
+    public ZoneId normalized() {
+        ZoneOffset f = fixedOffset();
+        return f != null ? f : this;
+    }
+
+    /// The offset this zone always has, or null for a region whose offset
+    /// changes.
+    ZoneOffset fixedOffset() {
+        return fixed;
+    }
+
+    /// The platform time zone with this zone's rules.
     TimeZone toTimeZone() {
-        return TimeZoneSupport.toTimeZone(this);
+        ZoneOffset offset = fixedOffset();
+        if (offset != null) {
+            return TimeZone.getTimeZone(offset.getTotalSeconds() == 0 ? "GMT" : "GMT" + offset.getId());
+        }
+        return TimeZone.getTimeZone(id);
     }
 
     public boolean equals(Object obj) {
-        return obj instanceof ZoneId && id.equals(((ZoneId) obj).id);
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ZoneId) || obj instanceof ZoneOffset) {
+            return false;
+        }
+        return id.equals(((ZoneId) obj).id);
     }
 
     public int hashCode() {
diff --git a/vm/JavaAPI/src/java/time/ZoneOffset.java b/vm/JavaAPI/src/java/time/ZoneOffset.java
index c66eca48d06..4c10c59e4a5 100644
--- a/vm/JavaAPI/src/java/time/ZoneOffset.java
+++ b/vm/JavaAPI/src/java/time/ZoneOffset.java
@@ -1,7 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
-public final class ZoneOffset extends ZoneId {
+import java.time.temporal.TemporalAccessor;
+
+/// A fixed offset from UTC, between -18:00 and +18:00.
+public final class ZoneOffset extends ZoneId implements TemporalAccessor, Comparable<ZoneOffset> {
+    private static final int MAX_SECONDS = 18 * 3600;
+
     public static final ZoneOffset UTC = new ZoneOffset(0);
+    public static final ZoneOffset MIN = new ZoneOffset(-MAX_SECONDS);
+    public static final ZoneOffset MAX = new ZoneOffset(MAX_SECONDS);
 
     private final int totalSeconds;
 
@@ -10,83 +39,183 @@ private ZoneOffset(int totalSeconds) {
         this.totalSeconds = totalSeconds;
     }
 
+    /// Reads `Z`, `+h`, `+hh`, `+hh:mm`, `+hhmm`, `+hh:mm:ss` and
+    /// `+hhmmss`, with `-` in place of `+` for a negative offset.
     public static ZoneOffset of(String offsetId) {
         if (offsetId == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("offsetId");
         }
         if ("Z".equals(offsetId)) {
             return UTC;
         }
         String text = offsetId;
-        char sign = text.charAt(0);
-        if (sign != '+' && sign != '-') {
-            throw new IllegalArgumentException("Invalid offset: " + offsetId);
-        }
-        text = text.substring(1);
         int hours;
-        int minutes = 0;
-        if (text.indexOf(':') > 0) {
-            String[] parts = split(text, ':');
-            hours = Integer.parseInt(parts[0]);
-            minutes = Integer.parseInt(parts[1]);
-        } else if (text.length() == 2) {
-            hours = Integer.parseInt(text);
-        } else if (text.length() == 4) {
-            hours = Integer.parseInt(text.substring(0, 2));
-            minutes = Integer.parseInt(text.substring(2));
-        } else {
-            throw new IllegalArgumentException("Invalid offset: " + offsetId);
-        }
-        int total = hours * 3600 + minutes * 60;
-        if (sign == '-') {
-            total = -total;
-        }
-        return ofTotalSeconds(total);
+        int minutes;
+        int seconds;
+        switch (text.length()) {
+            case 2:
+                text = text.charAt(0) + "0" + text.charAt(1);
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = 0;
+                seconds = 0;
+                break;
+            case 3:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = 0;
+                seconds = 0;
+                break;
+            case 5:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 3, false);
+                seconds = 0;
+                break;
+            case 6:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 4, true);
+                seconds = 0;
+                break;
+            case 7:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 3, false);
+                seconds = parseNumber(offsetId, text, 5, false);
+                break;
+            case 9:
+                hours = parseNumber(offsetId, text, 1, false);
+                minutes = parseNumber(offsetId, text, 4, true);
+                seconds = parseNumber(offsetId, text, 7, true);
+                break;
+            default:
+                throw new DateTimeException("Invalid ID for ZoneOffset, invalid format: " + offsetId);
+        }
+        char first = text.charAt(0);
+        if (first != '+' && first != '-') {
+            throw new DateTimeException("Invalid ID for ZoneOffset, plus/minus not found when expected: "
+                    + offsetId);
+        }
+        if (first == '-') {
+            return ofHoursMinutesSeconds(-hours, -minutes, -seconds);
+        }
+        return ofHoursMinutesSeconds(hours, minutes, seconds);
     }
 
-    private static String[] split(String value, char ch) {
-        int pos = value.indexOf(ch);
-        return new String[] { value.substring(0, pos), value.substring(pos + 1) };
+    private static int parseNumber(String offsetId, String text, int pos, boolean precededByColon) {
+        if (precededByColon && text.charAt(pos - 1) != ':') {
+            throw new DateTimeException("Invalid ID for ZoneOffset, colon not found when expected: " + offsetId);
+        }
+        char ch1 = text.charAt(pos);
+        char ch2 = text.charAt(pos + 1);
+        if (ch1 < '0' || ch1 > '9' || ch2 < '0' || ch2 > '9') {
+            throw new DateTimeException("Invalid ID for ZoneOffset, non numeric characters found: " + offsetId);
+        }
+        return (ch1 - 48) * 10 + (ch2 - 48);
     }
 
     public static ZoneOffset ofHours(int hours) {
-        return ofTotalSeconds(hours * 3600);
+        return ofHoursMinutesSeconds(hours, 0, 0);
     }
 
     public static ZoneOffset ofHoursMinutes(int hours, int minutes) {
-        int sign = hours < 0 || minutes < 0 ? -1 : 1;
-        return ofTotalSeconds(hours * 3600 + sign * Math.abs(minutes) * 60);
+        return ofHoursMinutesSeconds(hours, minutes, 0);
+    }
+
+    /// The offset of `hours`, `minutes` and `seconds`, which must all have
+    /// the same sign.
+    public static ZoneOffset ofHoursMinutesSeconds(int hours, int minutes, int seconds) {
+        if (hours < -18 || hours > 18) {
+            throw new DateTimeException("Zone offset hours not in valid range: value " + hours
+                    + " is not in the range -18 to 18");
+        }
+        if (hours > 0) {
+            if (minutes < 0 || seconds < 0) {
+                throw new DateTimeException("Zone offset minutes and seconds must be positive because hours is positive");
+            }
+        } else if (hours < 0) {
+            if (minutes > 0 || seconds > 0) {
+                throw new DateTimeException("Zone offset minutes and seconds must be negative because hours is negative");
+            }
+        } else if ((minutes > 0 && seconds < 0) || (minutes < 0 && seconds > 0)) {
+            throw new DateTimeException("Zone offset minutes and seconds must have the same sign");
+        }
+        if (minutes < -59 || minutes > 59) {
+            throw new DateTimeException("Zone offset minutes not in valid range: value " + minutes
+                    + " is not in the range -59 to 59");
+        }
+        if (seconds < -59 || seconds > 59) {
+            throw new DateTimeException("Zone offset seconds not in valid range: value " + seconds
+                    + " is not in the range -59 to 59");
+        }
+        if (Math.abs(hours) == 18 && (minutes | seconds) != 0) {
+            throw new DateTimeException("Zone offset not in valid range: -18:00 to +18:00");
+        }
+        return ofTotalSeconds(hours * 3600 + minutes * 60 + seconds);
     }
 
     public static ZoneOffset ofTotalSeconds(int totalSeconds) {
+        if (totalSeconds < -MAX_SECONDS || totalSeconds > MAX_SECONDS) {
+            throw new DateTimeException("Zone offset not in valid range: -18:00 to +18:00");
+        }
         if (totalSeconds == 0) {
             return UTC;
         }
         return new ZoneOffset(totalSeconds);
     }
 
+    /// The offset of `temporal`.
+    public static ZoneOffset from(TemporalAccessor temporal) {
+        if (temporal instanceof ZoneOffset) {
+            return (ZoneOffset) temporal;
+        }
+        if (temporal instanceof ZonedDateTime) {
+            return ((ZonedDateTime) temporal).getOffset();
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).getOffset();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain ZoneOffset from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
+    }
+
     public int getTotalSeconds() {
         return totalSeconds;
     }
 
+    @Override
+    ZoneOffset fixedOffset() {
+        return this;
+    }
+
+    /// Larger offsets sort first, as in the JDK: an offset further east is
+    /// an earlier moment for the same wall clock time.
+    public int compareTo(ZoneOffset other) {
+        return other.totalSeconds - totalSeconds;
+    }
+
+    public boolean equals(Object obj) {
+        return obj == this || (obj instanceof ZoneOffset && ((ZoneOffset) obj).totalSeconds == totalSeconds);
+    }
+
+    public int hashCode() {
+        return totalSeconds;
+    }
+
     private static String buildId(int totalSeconds) {
         if (totalSeconds == 0) {
             return "Z";
         }
         int abs = Math.abs(totalSeconds);
         int hours = abs / 3600;
-        int minutes = (abs % 3600) / 60;
-        StringBuffer sb = new StringBuffer();
+        int minutes = (abs / 60) % 60;
+        int seconds = abs % 60;
+        StringBuilder sb = new StringBuilder();
         sb.append(totalSeconds < 0 ? '-' : '+');
-        if (hours < 10) {
-            sb.append('0');
-        }
-        sb.append(hours);
-        sb.append(':');
-        if (minutes < 10) {
-            sb.append('0');
+        sb.append(hours < 10 ? "0" : "").append(hours);
+        sb.append(minutes < 10 ? ":0" : ":").append(minutes);
+        if (seconds != 0) {
+            sb.append(seconds < 10 ? ":0" : ":").append(seconds);
         }
-        sb.append(minutes);
         return sb.toString();
     }
 }
diff --git a/vm/JavaAPI/src/java/time/ZonedDateTime.java b/vm/JavaAPI/src/java/time/ZonedDateTime.java
index 7fe868a58bf..ec21defa796 100644
--- a/vm/JavaAPI/src/java/time/ZonedDateTime.java
+++ b/vm/JavaAPI/src/java/time/ZonedDateTime.java
@@ -1,94 +1,528 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time;
 
+import java.time.chrono.ChronoZonedDateTime;
 import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
 import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
 
-public final class ZonedDateTime implements Comparable<ZonedDateTime>, TemporalAccessor {
+/// A date and a time of day in a time zone, such as
+/// `2007-12-03T10:15:30+01:00[Europe/Paris]`.
+///
+/// Adding a date-based amount moves the wall clock and keeps the offset where
+/// the zone allows it; adding a time-based amount moves the instant. Across a
+/// change of offset the two differ, as they do in the JDK.
+public final class ZonedDateTime implements ChronoZonedDateTime<LocalDate> {
     private final LocalDateTime dateTime;
     private final ZoneId zone;
     private final ZoneOffset offset;
 
-    private ZonedDateTime(LocalDateTime dateTime, ZoneId zone, ZoneOffset offset) {
+    private ZonedDateTime(LocalDateTime dateTime, ZoneOffset offset, ZoneId zone) {
         this.dateTime = dateTime;
-        this.zone = zone;
         this.offset = offset;
+        this.zone = zone;
     }
 
     public static ZonedDateTime now() {
         return now(Clock.systemDefaultZone());
     }
 
+    /// The date and time now in `zone`.
+    public static ZonedDateTime now(ZoneId zone) {
+        return now(Clock.system(zone));
+    }
+
     public static ZonedDateTime now(Clock clock) {
         return ofInstant(clock.instant(), clock.getZone());
     }
 
     public static ZonedDateTime of(LocalDate date, LocalTime time, ZoneId zone) {
-        LocalDateTime ldt = LocalDateTime.of(date, time);
-        Instant instant = ldt.toInstant(DateTimeSupport.offsetFromInstant(ldt.toInstant(ZoneOffset.UTC), zone));
-        return ofInstant(instant, zone);
+        return of(LocalDateTime.of(date, time), zone);
+    }
+
+    public static ZonedDateTime of(LocalDateTime localDateTime, ZoneId zone) {
+        return ofLocal(localDateTime, zone, null);
+    }
+
+    public static ZonedDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second,
+            int nanoOfSecond, ZoneId zone) {
+        return ofLocal(LocalDateTime.of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond), zone, null);
+    }
+
+    /// `localDateTime` in `zone`. A wall clock time the zone skips is moved
+    /// forward by the length of the gap; one it passes twice takes
+    /// `preferredOffset` when that is one of its two offsets, and the earlier
+    /// offset otherwise.
+    public static ZonedDateTime ofLocal(LocalDateTime localDateTime, ZoneId zone, ZoneOffset preferredOffset) {
+        if (localDateTime == null) {
+            throw new NullPointerException("localDateTime");
+        }
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        if (zone instanceof ZoneOffset) {
+            return new ZonedDateTime(localDateTime, (ZoneOffset) zone, zone);
+        }
+        long local = localDateTime.toEpochSecond(ZoneOffset.UTC);
+        // The offsets a day either side; a zone changes its offset far less
+        // often than that, so these are the offset before any transition
+        // touching this wall clock time and the offset after it.
+        ZoneOffset before = offsetAt(local - 86400L, zone);
+        ZoneOffset after = offsetAt(local + 86400L, zone);
+        boolean beforeValid = offsetAt(local - before.getTotalSeconds(), zone).equals(before);
+        boolean afterValid = offsetAt(local - after.getTotalSeconds(), zone).equals(after);
+        if (before.equals(after) || (beforeValid && !afterValid)) {
+            return new ZonedDateTime(localDateTime, before, zone);
+        }
+        if (afterValid && !beforeValid) {
+            return new ZonedDateTime(localDateTime, after, zone);
+        }
+        if (beforeValid) {
+            // An overlap: the wall clock time happens at both offsets.
+            ZoneOffset chosen = after.equals(preferredOffset) ? after : before;
+            return new ZonedDateTime(localDateTime, chosen, zone);
+        }
+        // A gap: the wall clock time never happens; move past it.
+        LocalDateTime shifted = localDateTime.plusSeconds(after.getTotalSeconds() - before.getTotalSeconds());
+        return new ZonedDateTime(shifted, after, zone);
+    }
+
+    /// The two offsets of the overlap this wall clock time falls in, earlier
+    /// first, or null when it falls in none.
+    private ZoneOffset[] overlap() {
+        if (zone instanceof ZoneOffset) {
+            return null;
+        }
+        long local = dateTime.toEpochSecond(ZoneOffset.UTC);
+        ZoneOffset before = offsetAt(local - 86400L, zone);
+        ZoneOffset after = offsetAt(local + 86400L, zone);
+        if (before.equals(after) || !offsetAt(local - before.getTotalSeconds(), zone).equals(before)
+                || !offsetAt(local - after.getTotalSeconds(), zone).equals(after)) {
+            return null;
+        }
+        return new ZoneOffset[] {before, after};
     }
 
-    public static ZonedDateTime of(LocalDateTime dateTime, ZoneId zone) {
-        Instant instant = dateTime.toInstant(DateTimeSupport.offsetFromInstant(dateTime.toInstant(ZoneOffset.UTC), zone));
-        return ofInstant(instant, zone);
+    /// At a wall clock time the zone passes twice, the first of the two
+    /// moments; otherwise this.
+    public ZonedDateTime withEarlierOffsetAtOverlap() {
+        ZoneOffset[] both = overlap();
+        return both == null || both[0].equals(offset) ? this : new ZonedDateTime(dateTime, both[0], zone);
+    }
+
+    /// At a wall clock time the zone passes twice, the second of the two
+    /// moments; otherwise this.
+    public ZonedDateTime withLaterOffsetAtOverlap() {
+        ZoneOffset[] both = overlap();
+        return both == null || both[1].equals(offset) ? this : new ZonedDateTime(dateTime, both[1], zone);
+    }
+
+    private static ZoneOffset offsetAt(long epochSecond, ZoneId zone) {
+        return DateTimeSupport.offsetFromInstant(Instant.ofEpochSecond(epochSecond), zone);
     }
 
     public static ZonedDateTime ofInstant(Instant instant, ZoneId zone) {
+        if (instant == null) {
+            throw new NullPointerException("instant");
+        }
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return create(instant.getEpochSecond(), instant.getNano(), zone);
+    }
+
+    /// The moment `localDateTime` is at `offset`, in `zone`.
+    public static ZonedDateTime ofInstant(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone) {
+        return create(localDateTime.toEpochSecond(offset), localDateTime.getNano(), zone);
+    }
+
+    private static ZonedDateTime create(long epochSecond, int nanoOfSecond, ZoneId zone) {
+        Instant instant = Instant.ofEpochSecond(epochSecond, nanoOfSecond);
         ZoneOffset offset = DateTimeSupport.offsetFromInstant(instant, zone);
-        LocalDateTime local = LocalDateTime.ofInstant(instant, zone);
-        return new ZonedDateTime(local, zone, offset);
+        LocalDateTime ldt = LocalDateTime.ofEpochSecond(epochSecond, nanoOfSecond, offset);
+        return new ZonedDateTime(ldt, offset, zone);
+    }
+
+    /// The date and time and zone of `temporal`.
+    public static ZonedDateTime from(TemporalAccessor temporal) {
+        if (temporal instanceof ZonedDateTime) {
+            return (ZonedDateTime) temporal;
+        }
+        if (temporal instanceof OffsetDateTime) {
+            return ((OffsetDateTime) temporal).toZonedDateTime();
+        }
+        if (temporal == null) {
+            throw new NullPointerException("temporal");
+        }
+        throw new DateTimeException("Unable to obtain ZonedDateTime from TemporalAccessor: " + temporal
+                + " of type " + temporal.getClass().getName());
     }
 
     public static ZonedDateTime parse(CharSequence text) {
-        return (ZonedDateTime) DateTimeFormatter.ISO_ZONED_DATE_TIME.parse(text);
+        return parse(text, DateTimeFormatter.ISO_ZONED_DATE_TIME);
     }
 
     public static ZonedDateTime parse(CharSequence text, DateTimeFormatter formatter) {
-        return (ZonedDateTime) formatter.parse(text);
+        if (formatter == null) {
+            throw new NullPointerException("formatter");
+        }
+        TemporalAccessor parsed = formatter.parse(text);
+        try {
+            return from(parsed);
+        } catch (DateTimeException ex) {
+            throw TimeArithmetic.unparsable(text, ex);
+        }
     }
 
+    @Override
     public LocalDateTime toLocalDateTime() {
         return dateTime;
     }
 
+    @Override
+    public LocalDate toLocalDate() {
+        return dateTime.toLocalDate();
+    }
+
+    @Override
+    public LocalTime toLocalTime() {
+        return dateTime.toLocalTime();
+    }
+
+    @Override
     public ZoneId getZone() {
         return zone;
     }
 
+    @Override
     public ZoneOffset getOffset() {
         return offset;
     }
 
+    @Override
     public Instant toInstant() {
-        return dateTime.toInstant(offset);
+        return Instant.ofEpochSecond(toEpochSecond(), dateTime.getNano());
+    }
+
+    @Override
+    public long toEpochSecond() {
+        return dateTime.toEpochSecond(offset);
+    }
+
+    /// This date and time with its offset and no zone.
+    public OffsetDateTime toOffsetDateTime() {
+        return OffsetDateTime.of(dateTime, offset);
+    }
+
+    public int getYear() {
+        return dateTime.getYear();
+    }
+
+    public int getMonthValue() {
+        return dateTime.getMonthValue();
+    }
+
+    public Month getMonth() {
+        return dateTime.getMonth();
+    }
+
+    public int getDayOfMonth() {
+        return dateTime.getDayOfMonth();
+    }
+
+    public int getDayOfYear() {
+        return dateTime.getDayOfYear();
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return dateTime.getDayOfWeek();
+    }
+
+    public int getHour() {
+        return dateTime.getHour();
+    }
+
+    public int getMinute() {
+        return dateTime.getMinute();
+    }
+
+    public int getSecond() {
+        return dateTime.getSecond();
+    }
+
+    public int getNano() {
+        return dateTime.getNano();
+    }
+
+    /// The same moment in `zone`.
+    public ZonedDateTime withZoneSameInstant(ZoneId zone) {
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return this.zone.equals(zone) ? this : create(dateTime.toEpochSecond(offset), dateTime.getNano(), zone);
+    }
+
+    /// The same wall clock time in `zone`, keeping the offset if it can.
+    public ZonedDateTime withZoneSameLocal(ZoneId zone) {
+        if (zone == null) {
+            throw new NullPointerException("zone");
+        }
+        return this.zone.equals(zone) ? this : ofLocal(dateTime, zone, offset);
+    }
+
+    private ZonedDateTime resolveLocal(LocalDateTime newDateTime) {
+        return ofLocal(newDateTime, zone, offset);
+    }
+
+    private ZonedDateTime resolveInstant(LocalDateTime newDateTime) {
+        return ofInstant(newDateTime, offset, zone);
+    }
+
+    public ZonedDateTime withYear(int year) {
+        return resolveLocal(dateTime.withYear(year));
+    }
+
+    public ZonedDateTime withMonth(int month) {
+        return resolveLocal(dateTime.withMonth(month));
+    }
+
+    public ZonedDateTime withDayOfMonth(int dayOfMonth) {
+        return resolveLocal(dateTime.withDayOfMonth(dayOfMonth));
+    }
+
+    public ZonedDateTime withDayOfYear(int dayOfYear) {
+        return resolveLocal(dateTime.withDayOfYear(dayOfYear));
+    }
+
+    /// This date and time with its zone replaced by its current offset.
+    public ZonedDateTime withFixedOffsetZone() {
+        return zone.equals(offset) ? this : new ZonedDateTime(dateTime, offset, offset);
+    }
+
+    public ZonedDateTime withHour(int hour) {
+        return resolveLocal(dateTime.withHour(hour));
+    }
+
+    public ZonedDateTime withMinute(int minute) {
+        return resolveLocal(dateTime.withMinute(minute));
+    }
+
+    public ZonedDateTime withSecond(int second) {
+        return resolveLocal(dateTime.withSecond(second));
+    }
+
+    public ZonedDateTime withNano(int nanoOfSecond) {
+        return resolveLocal(dateTime.withNano(nanoOfSecond));
+    }
+
+    public ZonedDateTime truncatedTo(TemporalUnit unit) {
+        return resolveLocal(dateTime.truncatedTo(unit));
+    }
+
+    @Override
+    public boolean isSupported(TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            return unit != ChronoUnit.FOREVER;
+        }
+        return unit != null && unit.isSupportedBy(this);
+    }
+
+    @Override
+    public ZonedDateTime plus(long amountToAdd, TemporalUnit unit) {
+        if (unit instanceof ChronoUnit) {
+            if (unit.isDateBased()) {
+                return resolveLocal(dateTime.plus(amountToAdd, unit));
+            }
+            return resolveInstant(dateTime.plus(amountToAdd, unit));
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.addTo(this, amountToAdd);
+    }
+
+    @Override
+    public ZonedDateTime minus(long amountToSubtract, TemporalUnit unit) {
+        return amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit)
+                : plus(-amountToSubtract, unit);
+    }
+
+    @Override
+    public ZonedDateTime plus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            return resolveLocal(dateTime.plus(amount));
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToAdd");
+        }
+        return (ZonedDateTime) amount.addTo(this);
+    }
+
+    @Override
+    public ZonedDateTime minus(TemporalAmount amount) {
+        if (amount instanceof Period) {
+            return resolveLocal(dateTime.minus(amount));
+        }
+        if (amount == null) {
+            throw new NullPointerException("amountToSubtract");
+        }
+        return (ZonedDateTime) amount.subtractFrom(this);
+    }
+
+    public ZonedDateTime plusYears(long years) {
+        return resolveLocal(dateTime.plusYears(years));
+    }
+
+    public ZonedDateTime plusMonths(long months) {
+        return resolveLocal(dateTime.plusMonths(months));
+    }
+
+    public ZonedDateTime plusWeeks(long weeks) {
+        return resolveLocal(dateTime.plusWeeks(weeks));
+    }
+
+    public ZonedDateTime plusDays(long days) {
+        return resolveLocal(dateTime.plusDays(days));
+    }
+
+    public ZonedDateTime plusHours(long hours) {
+        return resolveInstant(dateTime.plusHours(hours));
+    }
+
+    public ZonedDateTime plusMinutes(long minutes) {
+        return resolveInstant(dateTime.plusMinutes(minutes));
+    }
+
+    public ZonedDateTime plusSeconds(long seconds) {
+        return resolveInstant(dateTime.plusSeconds(seconds));
+    }
+
+    public ZonedDateTime plusNanos(long nanos) {
+        return resolveInstant(dateTime.plusNanos(nanos));
+    }
+
+    public ZonedDateTime minusYears(long years) {
+        return years == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-years);
+    }
+
+    public ZonedDateTime minusMonths(long months) {
+        return months == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-months);
+    }
+
+    public ZonedDateTime minusWeeks(long weeks) {
+        return weeks == Long.MIN_VALUE ? plusWeeks(Long.MAX_VALUE).plusWeeks(1) : plusWeeks(-weeks);
+    }
+
+    public ZonedDateTime minusDays(long days) {
+        return days == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-days);
+    }
+
+    public ZonedDateTime minusHours(long hours) {
+        return hours == Long.MIN_VALUE ? plusHours(Long.MAX_VALUE).plusHours(1) : plusHours(-hours);
+    }
+
+    public ZonedDateTime minusMinutes(long minutes) {
+        return minutes == Long.MIN_VALUE ? plusMinutes(Long.MAX_VALUE).plusMinutes(1) : plusMinutes(-minutes);
+    }
+
+    public ZonedDateTime minusSeconds(long seconds) {
+        return seconds == Long.MIN_VALUE ? plusSeconds(Long.MAX_VALUE).plusSeconds(1) : plusSeconds(-seconds);
+    }
+
+    public ZonedDateTime minusNanos(long nanos) {
+        return nanos == Long.MIN_VALUE ? plusNanos(Long.MAX_VALUE).plusNanos(1) : plusNanos(-nanos);
+    }
+
+    /// The whole units of `unit` from this value to `endExclusive`: date
+    /// units on the wall clock of this zone, time units on the time line.
+    @Override
+    public long until(Temporal endExclusive, TemporalUnit unit) {
+        ZonedDateTime end = from(endExclusive);
+        if (unit instanceof ChronoUnit) {
+            if (unit.isDateBased()) {
+                end = end.withZoneSameInstant(zone);
+                return dateTime.until(end.dateTime, unit);
+            }
+            LocalDateTime endHere = LocalDateTime.ofEpochSecond(end.toEpochSecond(), end.getNano(), offset);
+            return dateTime.until(endHere, unit);
+        }
+        if (unit == null) {
+            throw new NullPointerException("unit");
+        }
+        return unit.between(this, end);
     }
 
     public String format(DateTimeFormatter formatter) {
         return formatter.format(this);
     }
 
-    public int compareTo(ZonedDateTime other) {
-        int cmp = toInstant().compareTo(other.toInstant());
-        if (cmp != 0) {
-            return cmp;
+    @Override
+    public int compareTo(ChronoZonedDateTime<?> other) {
+        long a = toEpochSecond();
+        long b = other.toEpochSecond();
+        if (a != b) {
+            return a < b ? -1 : 1;
+        }
+        int cmp = toLocalTime().getNano() - other.toLocalTime().getNano();
+        if (cmp == 0) {
+            cmp = toLocalDateTime().compareTo(other.toLocalDateTime());
+            if (cmp == 0) {
+                cmp = getZone().getId().compareTo(other.getZone().getId());
+            }
         }
-        cmp = dateTime.compareTo(other.dateTime);
-        return cmp != 0 ? cmp : zone.getId().compareTo(other.zone.getId());
+        return cmp;
     }
 
+    @Override
     public boolean equals(Object obj) {
-        return obj instanceof ZonedDateTime && compareTo((ZonedDateTime) obj) == 0;
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof ZonedDateTime)) {
+            return false;
+        }
+        ZonedDateTime other = (ZonedDateTime) obj;
+        return dateTime.equals(other.dateTime) && offset.equals(other.offset) && zone.equals(other.zone);
     }
 
+    @Override
     public int hashCode() {
-        return dateTime.hashCode() * 31 + zone.hashCode();
+        int z = zone.hashCode();
+        return dateTime.hashCode() ^ offset.hashCode() ^ ((z << 3) | (z >>> 29));
     }
 
+    /// The JDK's text: the date and time, the offset, and the zone in
+    /// brackets when it is a region rather than the offset itself.
+    @Override
     public String toString() {
-        return DateTimeFormatter.ISO_ZONED_DATE_TIME.format(this);
-    }
-
-    ZoneId getZoneForFormatting() {
-        return zone;
+        String str = dateTime.toString() + offset.toString();
+        if (!offset.equals(zone)) {
+            str += '[' + zone.toString() + ']';
+        }
+        return str;
     }
 }
diff --git a/vm/JavaAPI/src/java/time/chrono/ChronoLocalDate.java b/vm/JavaAPI/src/java/time/chrono/ChronoLocalDate.java
new file mode 100644
index 00000000000..1af4fd36deb
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/chrono/ChronoLocalDate.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.chrono;
+
+import java.time.temporal.Temporal;
+
+/// A date of a calendar. The ISO calendar's `LocalDate` is the one there is.
+public interface ChronoLocalDate extends Temporal, Comparable<ChronoLocalDate> {
+    /// The days since 1970-01-01.
+    long toEpochDay();
+
+    /// Whether the year of this date is a leap year.
+    boolean isLeapYear();
+
+    /// The days in the month of this date.
+    int lengthOfMonth();
+
+    /// The days in the year of this date.
+    default int lengthOfYear() {
+        return isLeapYear() ? 366 : 365;
+    }
+
+    /// Whether this date comes after `other`.
+    default boolean isAfter(ChronoLocalDate other) {
+        return toEpochDay() > other.toEpochDay();
+    }
+
+    /// Whether this date comes before `other`.
+    default boolean isBefore(ChronoLocalDate other) {
+        return toEpochDay() < other.toEpochDay();
+    }
+
+    /// Whether this date is the same day as `other`.
+    default boolean isEqual(ChronoLocalDate other) {
+        return toEpochDay() == other.toEpochDay();
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/chrono/ChronoLocalDateTime.java b/vm/JavaAPI/src/java/time/chrono/ChronoLocalDateTime.java
new file mode 100644
index 00000000000..0f6651198ac
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/chrono/ChronoLocalDateTime.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.chrono;
+
+import java.time.Instant;
+import java.time.LocalTime;
+import java.time.ZoneOffset;
+import java.time.temporal.Temporal;
+
+/// A date and a time of day of a calendar, with no zone.
+public interface ChronoLocalDateTime<D extends ChronoLocalDate>
+        extends Temporal, Comparable<ChronoLocalDateTime<?>> {
+    /// The date.
+    D toLocalDate();
+
+    /// The time of day.
+    LocalTime toLocalTime();
+
+    /// The seconds since 1970-01-01T00:00Z of this date and time at `offset`.
+    default long toEpochSecond(ZoneOffset offset) {
+        long epochDay = toLocalDate().toEpochDay();
+        long secs = epochDay * 86400L + toLocalTime().toSecondOfDay();
+        return secs - offset.getTotalSeconds();
+    }
+
+    /// The moment this date and time is at `offset`.
+    default Instant toInstant(ZoneOffset offset) {
+        return Instant.ofEpochSecond(toEpochSecond(offset), toLocalTime().getNano());
+    }
+
+    /// Whether this comes after `other` on the local time line.
+    default boolean isAfter(ChronoLocalDateTime<?> other) {
+        long thisDay = toLocalDate().toEpochDay();
+        long otherDay = other.toLocalDate().toEpochDay();
+        return thisDay > otherDay
+                || (thisDay == otherDay && toLocalTime().toNanoOfDay() > other.toLocalTime().toNanoOfDay());
+    }
+
+    /// Whether this comes before `other` on the local time line.
+    default boolean isBefore(ChronoLocalDateTime<?> other) {
+        long thisDay = toLocalDate().toEpochDay();
+        long otherDay = other.toLocalDate().toEpochDay();
+        return thisDay < otherDay
+                || (thisDay == otherDay && toLocalTime().toNanoOfDay() < other.toLocalTime().toNanoOfDay());
+    }
+
+    /// Whether this is the same date and time as `other`.
+    default boolean isEqual(ChronoLocalDateTime<?> other) {
+        return toLocalTime().toNanoOfDay() == other.toLocalTime().toNanoOfDay()
+                && toLocalDate().toEpochDay() == other.toLocalDate().toEpochDay();
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/chrono/ChronoZonedDateTime.java b/vm/JavaAPI/src/java/time/chrono/ChronoZonedDateTime.java
new file mode 100644
index 00000000000..3b875999605
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/chrono/ChronoZonedDateTime.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.chrono;
+
+import java.time.Instant;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.temporal.Temporal;
+
+/// A date and a time of day in a time zone.
+public interface ChronoZonedDateTime<D extends ChronoLocalDate>
+        extends Temporal, Comparable<ChronoZonedDateTime<?>> {
+    /// The date and time on the wall clock.
+    ChronoLocalDateTime<D> toLocalDateTime();
+
+    /// The offset from UTC.
+    ZoneOffset getOffset();
+
+    /// The zone.
+    ZoneId getZone();
+
+    /// The date.
+    default D toLocalDate() {
+        return toLocalDateTime().toLocalDate();
+    }
+
+    /// The time of day.
+    default LocalTime toLocalTime() {
+        return toLocalDateTime().toLocalTime();
+    }
+
+    /// The seconds since 1970-01-01T00:00Z.
+    default long toEpochSecond() {
+        return toLocalDateTime().toEpochSecond(getOffset());
+    }
+
+    /// The moment this is.
+    default Instant toInstant() {
+        return Instant.ofEpochSecond(toEpochSecond(), toLocalTime().getNano());
+    }
+
+    /// Whether this moment comes after `other`.
+    default boolean isAfter(ChronoZonedDateTime<?> other) {
+        long thisSecond = toEpochSecond();
+        long otherSecond = other.toEpochSecond();
+        return thisSecond > otherSecond
+                || (thisSecond == otherSecond && toLocalTime().getNano() > other.toLocalTime().getNano());
+    }
+
+    /// Whether this moment comes before `other`.
+    default boolean isBefore(ChronoZonedDateTime<?> other) {
+        long thisSecond = toEpochSecond();
+        long otherSecond = other.toEpochSecond();
+        return thisSecond < otherSecond
+                || (thisSecond == otherSecond && toLocalTime().getNano() < other.toLocalTime().getNano());
+    }
+
+    /// Whether this is the same moment as `other`.
+    default boolean isEqual(ChronoZonedDateTime<?> other) {
+        return toEpochSecond() == other.toEpochSecond()
+                && toLocalTime().getNano() == other.toLocalTime().getNano();
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/format/DateTimeFormatter.java b/vm/JavaAPI/src/java/time/format/DateTimeFormatter.java
index 9ef776930d1..fbf37066dab 100644
--- a/vm/JavaAPI/src/java/time/format/DateTimeFormatter.java
+++ b/vm/JavaAPI/src/java/time/format/DateTimeFormatter.java
@@ -1,8 +1,29 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time.format;
 
-import com.codename1.impl.time.TimeZoneSupport;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
+import java.time.DateTimeException;
+import java.time.DayOfWeek;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -12,388 +33,1599 @@
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.time.temporal.TemporalAccessor;
-import java.util.Date;
+import java.time.temporal.TemporalQuery;
+import java.time.temporal.UnsupportedTemporalTypeException;
+import java.util.ArrayList;
 import java.util.Locale;
-import java.util.TimeZone;
 
+/// Formats and parses dates and times: the ISO formats as constants, and
+/// any other through [#ofPattern(String)].
+///
+/// Patterns follow the JDK's letters and counts. Supported: `G` era, `u`
+/// year, `y` year of era, `M`/`L` month, `d` day of month, `D` day of
+/// year, `Q`/`q` quarter, `E` day of week, `a` AM/PM, `h`, `K`, `k`, `H`
+/// hours, `m` minutes, `s` seconds, `S` fraction of a second, `n` nano of
+/// second, `N` nano of day, `A` milli of day, `VV` zone id, `z` (the zone
+/// id), `O`, `X`, `x` and `Z` offsets, quoted text, and `[...]` optional
+/// sections. Text is English whatever the locale. The week-based letters
+/// (`Y`, `w`, `W`, `e`, `c`, `F`, `g`), `v`, `B` and `p` are refused.
+///
+/// A pattern parses as the JDK's smart resolver does: a day of month past
+/// the end of its month becomes the last day, an hour alone is that hour
+/// on the dot, and a two-digit year is one of 2000 to 2099. The ISO
+/// formats resolve strictly.
 public final class DateTimeFormatter {
-    private static final String[] EN_SHORT_DAYS = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-    private static final String[] EN_SHORT_MONTHS = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
-
-    private static final int TYPE_PATTERN = 0;
-    private static final int TYPE_ISO_LOCAL_DATE = 1;
-    private static final int TYPE_ISO_LOCAL_TIME = 2;
-    private static final int TYPE_ISO_LOCAL_DATE_TIME = 3;
-    private static final int TYPE_ISO_OFFSET_DATE_TIME = 4;
-    private static final int TYPE_ISO_ZONED_DATE_TIME = 5;
-    private static final int TYPE_ISO_INSTANT = 6;
-
-    public static final DateTimeFormatter ISO_LOCAL_DATE = new DateTimeFormatter(TYPE_ISO_LOCAL_DATE, null, null);
-    public static final DateTimeFormatter ISO_LOCAL_TIME = new DateTimeFormatter(TYPE_ISO_LOCAL_TIME, null, null);
-    public static final DateTimeFormatter ISO_LOCAL_DATE_TIME = new DateTimeFormatter(TYPE_ISO_LOCAL_DATE_TIME, null, null);
-    public static final DateTimeFormatter ISO_OFFSET_DATE_TIME = new DateTimeFormatter(TYPE_ISO_OFFSET_DATE_TIME, null, null);
-    public static final DateTimeFormatter ISO_ZONED_DATE_TIME = new DateTimeFormatter(TYPE_ISO_ZONED_DATE_TIME, null, null);
-    public static final DateTimeFormatter ISO_INSTANT = new DateTimeFormatter(TYPE_ISO_INSTANT, null, null);
-
-    private final int type;
+    private static final int KIND_PATTERN = 0;
+    private static final int KIND_LOCAL_DATE = 1;
+    private static final int KIND_LOCAL_TIME = 2;
+    private static final int KIND_LOCAL_DATE_TIME = 3;
+    private static final int KIND_OFFSET_DATE_TIME = 4;
+    private static final int KIND_ZONED_DATE_TIME = 5;
+    private static final int KIND_INSTANT = 6;
+
+    private static final long SECONDS_PER_10000_YEARS = 146097L * 25L * 86400L;
+    private static final long SECONDS_0000_TO_1970 = ((146097L * 5L) - (30L * 365L + 7L)) * 86400L;
+
+    public static final DateTimeFormatter ISO_LOCAL_DATE = new DateTimeFormatter(KIND_LOCAL_DATE, null, null,
+            null, null);
+    public static final DateTimeFormatter ISO_LOCAL_TIME = new DateTimeFormatter(KIND_LOCAL_TIME, null, null,
+            null, null);
+    public static final DateTimeFormatter ISO_LOCAL_DATE_TIME = new DateTimeFormatter(KIND_LOCAL_DATE_TIME, null,
+            null, null, null);
+    public static final DateTimeFormatter ISO_OFFSET_DATE_TIME = new DateTimeFormatter(KIND_OFFSET_DATE_TIME, null,
+            null, null, null);
+    public static final DateTimeFormatter ISO_ZONED_DATE_TIME = new DateTimeFormatter(KIND_ZONED_DATE_TIME, null,
+            null, null, null);
+    public static final DateTimeFormatter ISO_INSTANT = new DateTimeFormatter(KIND_INSTANT, null, null, null, null);
+
+    private final int kind;
     private final String pattern;
+    private final Token[] tokens;
     private final Locale locale;
+    private final ZoneId zone;
 
-    private DateTimeFormatter(int type, String pattern, Locale locale) {
-        this.type = type;
+    private DateTimeFormatter(int kind, String pattern, Token[] tokens, Locale locale, ZoneId zone) {
+        this.kind = kind;
         this.pattern = pattern;
+        this.tokens = tokens;
         this.locale = locale;
+        this.zone = zone;
     }
 
     public static DateTimeFormatter ofPattern(String pattern) {
-        return new DateTimeFormatter(TYPE_PATTERN, pattern, null);
+        return ofPattern(pattern, Locale.getDefault());
     }
 
     public static DateTimeFormatter ofPattern(String pattern, Locale locale) {
-        return new DateTimeFormatter(TYPE_PATTERN, pattern, locale);
+        if (pattern == null) {
+            throw new NullPointerException("pattern");
+        }
+        if (locale == null) {
+            throw new NullPointerException("locale");
+        }
+        return new DateTimeFormatter(KIND_PATTERN, pattern, compile(pattern), locale, null);
+    }
+
+    /// This formatter with `zone` overriding the zone of what it formats and
+    /// supplying one to what it parses; null removes the override.
+    public DateTimeFormatter withZone(ZoneId zone) {
+        if (zone == null ? this.zone == null : zone.equals(this.zone)) {
+            return this;
+        }
+        return new DateTimeFormatter(kind, pattern, tokens, locale, zone);
     }
 
+    /// The zone given to [#withZone(ZoneId)], or null.
+    public ZoneId getZone() {
+        return zone;
+    }
+
+    public DateTimeFormatter withLocale(Locale locale) {
+        if (locale == null) {
+            throw new NullPointerException("locale");
+        }
+        if (locale.equals(this.locale)) {
+            return this;
+        }
+        return new DateTimeFormatter(kind, pattern, tokens, locale, zone);
+    }
+
+    public Locale getLocale() {
+        return locale == null ? Locale.getDefault() : locale;
+    }
+
+    // ---- formatting ----
+
     public String format(TemporalAccessor temporal) {
         if (temporal == null) {
-            throw new NullPointerException();
-        }
-        switch (type) {
-            case TYPE_PATTERN:
-                return formatPattern(temporal);
-            case TYPE_ISO_LOCAL_DATE:
-                return formatLocalDate((LocalDate) temporal);
-            case TYPE_ISO_LOCAL_TIME:
-                return formatLocalTime((LocalTime) temporal);
-            case TYPE_ISO_LOCAL_DATE_TIME:
-                return formatLocalDate((LocalDateTime) temporal) + "T" + formatLocalTime(((LocalDateTime) temporal).toLocalTime());
-            case TYPE_ISO_OFFSET_DATE_TIME:
-                return formatLocalDateTime(((OffsetDateTime) temporal).toLocalDateTime()) + formatOffset(((OffsetDateTime) temporal).getOffset());
-            case TYPE_ISO_ZONED_DATE_TIME:
-                ZonedDateTime zdt = (ZonedDateTime) temporal;
-                return formatLocalDateTime(zdt.toLocalDateTime()) + formatOffset(zdt.getOffset()) + "[" + zdt.getZone().getId() + "]";
-            case TYPE_ISO_INSTANT:
-                return formatInstant((Instant) temporal);
+            throw new NullPointerException("temporal");
+        }
+        Fields f = Fields.of(temporal, zone);
+        StringBuilder out = new StringBuilder(32);
+        switch (kind) {
+            case KIND_PATTERN:
+                formatPattern(f, out);
+                break;
+            case KIND_LOCAL_DATE:
+                isoDate(f, out);
+                break;
+            case KIND_LOCAL_TIME:
+                isoTime(f, out);
+                break;
+            case KIND_LOCAL_DATE_TIME:
+                isoDate(f, out);
+                out.append('T');
+                isoTime(f, out);
+                break;
+            case KIND_OFFSET_DATE_TIME:
+                isoDate(f, out);
+                out.append('T');
+                isoTime(f, out);
+                out.append(f.offset("OffsetSeconds").getId());
+                break;
+            case KIND_ZONED_DATE_TIME:
+                isoDate(f, out);
+                out.append('T');
+                isoTime(f, out);
+                out.append(f.offset("OffsetSeconds").getId());
+                if (f.zone != null && !(f.zone instanceof ZoneOffset)) {
+                    out.append('[').append(f.zone.getId()).append(']');
+                }
+                break;
             default:
-                throw new IllegalStateException();
+                isoInstant(f, out);
+                break;
         }
+        return out.toString();
     }
 
-    public TemporalAccessor parse(CharSequence text) {
-        switch (type) {
-            case TYPE_ISO_LOCAL_DATE:
-                return parseLocalDate(text.toString());
-            case TYPE_ISO_LOCAL_TIME:
-                return parseLocalTime(text.toString());
-            case TYPE_ISO_LOCAL_DATE_TIME:
-                return parseLocalDateTime(text.toString());
-            case TYPE_ISO_OFFSET_DATE_TIME:
-                return parseOffsetDateTime(text.toString());
-            case TYPE_ISO_ZONED_DATE_TIME:
-                return parseZonedDateTime(text.toString());
-            case TYPE_ISO_INSTANT:
-                return parseInstant(text.toString());
-            case TYPE_PATTERN:
-                return parseLocalDateTime(text.toString());
-            default:
-                throw new IllegalStateException();
-        }
+    private static void isoDate(Fields f, StringBuilder out) {
+        LocalDate date = f.date("Year");
+        appendYear(date.getYear(), out);
+        out.append('-');
+        pad(out, date.getMonthValue(), 2);
+        out.append('-');
+        pad(out, date.getDayOfMonth(), 2);
     }
 
-    LocalDate parseLocalDate(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return LocalDateTime.ofInstant(parsed.instant, ZoneOffset.UTC).toLocalDate();
+    /// A year as the ISO formats print it: at least four digits, a sign
+    /// when negative, and a `+` when more than four digits.
+    private static void appendYear(int year, StringBuilder out) {
+        if (year < 0) {
+            out.append('-');
+            pad(out, -(long) year, 4);
+        } else {
+            if (year > 9999) {
+                out.append('+');
+            }
+            pad(out, year, 4);
         }
-        if (type != TYPE_ISO_LOCAL_DATE) {
-            throw new DateTimeParseException("Formatter does not produce LocalDate", text, 0);
+    }
+
+    private static void isoTime(Fields f, StringBuilder out) {
+        LocalTime time = f.time("HourOfDay");
+        pad(out, time.getHour(), 2);
+        out.append(':');
+        pad(out, time.getMinute(), 2);
+        out.append(':');
+        pad(out, time.getSecond(), 2);
+        int nano = time.getNano();
+        if (nano != 0) {
+            String digits = String.valueOf(1000000000 + nano).substring(1);
+            int end = 9;
+            while (digits.charAt(end - 1) == '0') {
+                end--;
+            }
+            out.append('.').append(digits.substring(0, end));
         }
-        return LocalDate.of(parseInt(text, 0, 4), parseInt(text, 5, 7), parseInt(text, 8, 10));
     }
 
-    LocalTime parseLocalTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return LocalDateTime.ofInstant(parsed.instant, ZoneOffset.UTC).toLocalTime();
+    private static void isoInstant(Fields f, StringBuilder out) {
+        if (f.epochSecond == null) {
+            throw new UnsupportedTemporalTypeException("Unsupported field: InstantSeconds");
         }
-        if (type != TYPE_ISO_LOCAL_TIME) {
-            throw new DateTimeParseException("Formatter does not produce LocalTime", text, 0);
+        // An instant reaches a year past what LocalDate holds, so the year
+        // is split off in whole 10000 year cycles first, as the JDK does.
+        long seconds = f.epochSecond.longValue();
+        long shifted = seconds + SECONDS_0000_TO_1970;
+        long cycles = shifted / SECONDS_PER_10000_YEARS;
+        if (shifted < 0 && cycles * SECONDS_PER_10000_YEARS != shifted) {
+            cycles--;
         }
-        int hour = parseInt(text, 0, 2);
-        int minute = parseInt(text, 3, 5);
-        int second = text.length() >= 8 ? parseInt(text, 6, 8) : 0;
-        int nano = 0;
-        int dot = text.indexOf('.');
-        if (dot > 0) {
-            String frac = text.substring(dot + 1);
-            while (frac.length() < 9) {
-                frac += "0";
-            }
-            if (frac.length() > 9) {
-                frac = frac.substring(0, 9);
+        long within = seconds - cycles * SECONDS_PER_10000_YEARS;
+        LocalDateTime utc = LocalDateTime.ofEpochSecond(within, f.nano, ZoneOffset.UTC);
+        appendYear((int) (cycles * 10000 + utc.getYear()), out);
+        out.append('-');
+        pad(out, utc.getMonthValue(), 2);
+        out.append('-');
+        pad(out, utc.getDayOfMonth(), 2);
+        out.append('T');
+        pad(out, utc.getHour(), 2);
+        out.append(':');
+        pad(out, utc.getMinute(), 2);
+        out.append(':');
+        pad(out, utc.getSecond(), 2);
+        int nano = utc.getNano();
+        if (nano != 0) {
+            // Whole groups of three digits: millis, micros or nanos.
+            String digits = String.valueOf(1000000000 + nano).substring(1);
+            if (nano % 1000000 == 0) {
+                digits = digits.substring(0, 3);
+            } else if (nano % 1000 == 0) {
+                digits = digits.substring(0, 6);
             }
-            nano = Integer.parseInt(frac);
+            out.append('.').append(digits);
         }
-        return LocalTime.of(hour, minute, second, nano);
+        out.append('Z');
     }
 
-    LocalDateTime parseLocalDateTime(String text) {
-        if (type == TYPE_PATTERN) {
-            LocalDateTime numeric = parseNumericLocalDateTime(text, pattern);
-            if (numeric != null) {
-                return numeric;
+    private void formatPattern(Fields f, StringBuilder out) {
+        ArrayList<Integer> starts = new ArrayList<Integer>();
+        int i = 0;
+        while (i < tokens.length) {
+            Token t = tokens[i];
+            if (t.kind == Token.OPTIONAL_START) {
+                starts.add(Integer.valueOf(out.length()));
+                i++;
+                continue;
+            }
+            if (t.kind == Token.OPTIONAL_END) {
+                starts.remove(starts.size() - 1);
+                i++;
+                continue;
+            }
+            if (t.kind == Token.LITERAL) {
+                out.append(t.text);
+                i++;
+                continue;
+            }
+            try {
+                formatField(t, f, out);
+                i++;
+            } catch (UnsupportedTemporalTypeException missing) {
+                if (starts.isEmpty()) {
+                    throw missing;
+                }
+                // A field an optional section needs is missing: drop the
+                // section, whatever of it was printed already included.
+                out.setLength(starts.remove(starts.size() - 1).intValue());
+                i = skipSection(i);
             }
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return LocalDateTime.ofInstant(parsed.instant, ZoneOffset.UTC);
         }
-        if (type != TYPE_ISO_LOCAL_DATE_TIME) {
-            throw new DateTimeParseException("Formatter does not produce LocalDateTime", text, 0);
+    }
+
+    /// The index after the end of the optional section `i` is inside.
+    private int skipSection(int i) {
+        int depth = 1;
+        i++;
+        while (i < tokens.length && depth > 0) {
+            if (tokens[i].kind == Token.OPTIONAL_START) {
+                depth++;
+            } else if (tokens[i].kind == Token.OPTIONAL_END) {
+                depth--;
+            }
+            i++;
         }
-        int t = text.indexOf('T');
-        return LocalDateTime.of(ISO_LOCAL_DATE.parseLocalDate(text.substring(0, t)),
-                ISO_LOCAL_TIME.parseLocalTime(text.substring(t + 1)));
+        return i;
     }
 
-    OffsetDateTime parseOffsetDateTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneOffset.UTC, locale);
-            return OffsetDateTime.ofInstant(parsed.instant, parsed.zone);
+    private static void formatField(Token t, Fields f, StringBuilder out) {
+        int count = t.count;
+        switch (t.letter) {
+            case 'G': {
+                int year = f.date("Era").getYear();
+                text(out, count, year >= 1 ? ERA_FULL[1] : ERA_FULL[0], year >= 1 ? "AD" : "BC");
+                return;
+            }
+            case 'u':
+            case 'y': {
+                int year = f.date(t.letter == 'u' ? "Year" : "YearOfEra").getYear();
+                long value = t.letter == 'y' && year < 1 ? 1L - year : year;
+                if (count == 2) {
+                    pad(out, Math.abs(value) % 100, 2);
+                } else if (count < 4) {
+                    number(out, value, count, 19, SIGN_NORMAL, "Year");
+                } else {
+                    number(out, value, count, 19, SIGN_EXCEEDS_PAD, "Year");
+                }
+                return;
+            }
+            case 'M':
+            case 'L': {
+                int month = f.date("MonthOfYear").getMonthValue();
+                if (count >= 3) {
+                    text(out, count, MONTHS[month - 1], null);
+                } else {
+                    small(out, month, count);
+                }
+                return;
+            }
+            case 'Q':
+            case 'q': {
+                int quarter = (f.date("QuarterOfYear").getMonthValue() - 1) / 3 + 1;
+                if (count == 3) {
+                    out.append('Q').append(quarter);
+                } else if (count == 4) {
+                    out.append(QUARTERS[quarter - 1]).append(" quarter");
+                } else if (count == 5) {
+                    out.append(quarter);
+                } else {
+                    small(out, quarter, count);
+                }
+                return;
+            }
+            case 'd':
+                small(out, f.date("DayOfMonth").getDayOfMonth(), count);
+                return;
+            case 'D': {
+                int doy = f.date("DayOfYear").getDayOfYear();
+                if (count == 2) {
+                    number(out, doy, 2, 3, SIGN_NOT_NEGATIVE, "DayOfYear");
+                } else {
+                    small(out, doy, count);
+                }
+                return;
+            }
+            case 'E': {
+                DayOfWeek dow = f.dayOfWeek();
+                text(out, count, DAYS[dow.getValue() - 1], null);
+                return;
+            }
+            case 'a':
+                out.append(f.time("AmPmOfDay").getHour() < 12 ? "AM" : "PM");
+                return;
+            case 'h': {
+                int h = f.time("ClockHourOfAmPm").getHour() % 12;
+                small(out, h == 0 ? 12 : h, count);
+                return;
+            }
+            case 'K':
+                small(out, f.time("HourOfAmPm").getHour() % 12, count);
+                return;
+            case 'k': {
+                int h = f.time("ClockHourOfDay").getHour();
+                small(out, h == 0 ? 24 : h, count);
+                return;
+            }
+            case 'H':
+                small(out, f.time("HourOfDay").getHour(), count);
+                return;
+            case 'm':
+                small(out, f.time("MinuteOfHour").getMinute(), count);
+                return;
+            case 's':
+                small(out, f.time("SecondOfMinute").getSecond(), count);
+                return;
+            case 'S':
+                out.append(String.valueOf(1000000000 + f.nanoOfSecond()).substring(1, 1 + count));
+                return;
+            case 'n':
+                small(out, f.nanoOfSecond(), count);
+                return;
+            case 'N':
+                small(out, f.time("NanoOfDay").toNanoOfDay(), count);
+                return;
+            case 'A':
+                small(out, f.time("MilliOfDay").toNanoOfDay() / 1000000L, count);
+                return;
+            case 'V':
+            case 'z':
+                if (f.zone == null) {
+                    throw new UnsupportedTemporalTypeException("Unable to extract ZoneId from temporal");
+                }
+                out.append(f.zone.getId());
+                return;
+            case 'O':
+                localizedOffset(out, f.offset("OffsetSeconds").getTotalSeconds(), count == 4);
+                return;
+            case 'X':
+                offset(out, f.offset("OffsetSeconds").getTotalSeconds(), count == 1 ? 1 : count, "Z");
+                return;
+            case 'x':
+                offset(out, f.offset("OffsetSeconds").getTotalSeconds(), count, OFFSET_ZERO[count - 1]);
+                return;
+            case 'Z':
+                if (count == 4) {
+                    localizedOffset(out, f.offset("OffsetSeconds").getTotalSeconds(), true);
+                } else if (count == 5) {
+                    offset(out, f.offset("OffsetSeconds").getTotalSeconds(), 5, "Z");
+                } else {
+                    offset(out, f.offset("OffsetSeconds").getTotalSeconds(), 2, "+0000");
+                }
+                return;
+            default:
+                throw new IllegalStateException(String.valueOf(t.letter));
         }
-        if (type != TYPE_ISO_OFFSET_DATE_TIME) {
-            throw new DateTimeParseException("Formatter does not produce OffsetDateTime", text, 0);
+    }
+
+    private static final String[] MONTHS = {"January", "February", "March", "April", "May", "June", "July",
+        "August", "September", "October", "November", "December"};
+    private static final String[] DAYS = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
+        "Sunday"};
+    private static final String[] ERA_FULL = {"Before Christ", "Anno Domini"};
+    private static final String[] QUARTERS = {"1st", "2nd", "3rd", "4th"};
+    private static final String[] OFFSET_ZERO = {"+00", "+0000", "+00:00", "+0000", "+00:00"};
+
+    private static final int SIGN_NORMAL = 0;
+    private static final int SIGN_NOT_NEGATIVE = 1;
+    private static final int SIGN_EXCEEDS_PAD = 2;
+
+    /// Text in the style the count asks for: short (1 to 3), full (4) or
+    /// narrow (5). `shortForm` stands in when the short form is not the
+    /// first three letters.
+    private static void text(StringBuilder out, int count, String full, String shortForm) {
+        if (count == 4) {
+            out.append(full);
+        } else if (count == 5) {
+            out.append(full.charAt(0));
+        } else {
+            out.append(shortForm != null ? shortForm : full.substring(0, 3));
         }
-        int idx = Math.max(text.lastIndexOf('+'), text.lastIndexOf('-'));
-        if (text.endsWith("Z")) {
-            idx = text.length() - 1;
+    }
+
+    /// A field of one letter (any width) or two (exactly two digits).
+    private static void small(StringBuilder out, long value, int count) {
+        if (count == 1) {
+            out.append(value);
+        } else {
+            pad(out, value, count);
         }
-        LocalDateTime ldt = ISO_LOCAL_DATE_TIME.parseLocalDateTime(text.substring(0, idx));
-        ZoneOffset offset = text.endsWith("Z") ? ZoneOffset.UTC : ZoneOffset.of(text.substring(idx));
-        return OffsetDateTime.of(ldt, offset);
     }
 
-    ZonedDateTime parseZonedDateTime(String text) {
-        if (type == TYPE_PATTERN) {
-            ParsedPatternResult parsed = parsePattern(text, pattern, ZoneId.systemDefault(), locale);
-            return ZonedDateTime.ofInstant(parsed.instant, parsed.zone);
+    private static void number(StringBuilder out, long value, int minWidth, int maxWidth, int sign, String field) {
+        String digits = String.valueOf(Math.abs(value));
+        if (value == Long.MIN_VALUE || digits.length() > maxWidth) {
+            throw new DateTimeException("Field " + field + " cannot be printed as the value " + value
+                    + " exceeds the maximum print width of " + maxWidth);
         }
-        if (type != TYPE_ISO_ZONED_DATE_TIME) {
-            throw new DateTimeParseException("Formatter does not produce ZonedDateTime", text, 0);
+        if (value < 0) {
+            if (sign == SIGN_NOT_NEGATIVE) {
+                throw new DateTimeException("Field " + field + " cannot be printed as the value " + value
+                        + " cannot be negative according to the SignStyle");
+            }
+            out.append('-');
+        } else if (sign == SIGN_EXCEEDS_PAD && minWidth < 19 && digits.length() > minWidth) {
+            out.append('+');
         }
-        int zoneStart = text.indexOf('[');
-        int offsetIdx = Math.max(text.lastIndexOf('+'), text.lastIndexOf('-'));
-        if (text.indexOf('Z') > 0 && (offsetIdx < 0 || text.indexOf('Z') < zoneStart)) {
-            offsetIdx = text.indexOf('Z');
+        for (int i = digits.length(); i < minWidth; i++) {
+            out.append('0');
         }
-        LocalDateTime ldt = ISO_LOCAL_DATE_TIME.parseLocalDateTime(text.substring(0, offsetIdx));
-        ZoneOffset offset = text.charAt(offsetIdx) == 'Z' ? ZoneOffset.UTC : ZoneOffset.of(text.substring(offsetIdx, zoneStart));
-        ZoneId zone = ZoneId.of(text.substring(zoneStart + 1, text.length() - 1));
-        return ZonedDateTime.ofInstant(ldt.toInstant(offset), zone);
+        out.append(digits);
     }
 
-    Instant parseInstant(String text) {
-        if (type != TYPE_ISO_INSTANT) {
-            throw new DateTimeParseException("Formatter does not produce Instant", text, 0);
+    private static void pad(StringBuilder out, long value, int width) {
+        String digits = String.valueOf(value);
+        for (int i = digits.length(); i < width; i++) {
+            out.append('0');
         }
-        OffsetDateTime odt = ISO_OFFSET_DATE_TIME.parseOffsetDateTime(text.endsWith("Z")
-                ? text.substring(0, text.length() - 1) + "+00:00"
-                : text);
-        return odt.toInstant();
+        out.append(digits);
     }
 
-    private String formatPattern(TemporalAccessor temporal) {
-        ZoneId zone;
-        ZoneOffset offset;
-        Instant instant;
-        if (temporal instanceof Instant) {
-            instant = (Instant) temporal;
-            zone = ZoneOffset.UTC;
-            offset = ZoneOffset.UTC;
-        } else if (temporal instanceof LocalDateTime) {
-            instant = ((LocalDateTime) temporal).toInstant(ZoneOffset.UTC);
-            zone = ZoneOffset.UTC;
-            offset = ZoneOffset.UTC;
-        } else if (temporal instanceof OffsetDateTime) {
-            OffsetDateTime offsetDateTime = (OffsetDateTime) temporal;
-            instant = offsetDateTime.toInstant();
-            zone = offsetDateTime.getOffset();
-            offset = offsetDateTime.getOffset();
-        } else if (temporal instanceof ZonedDateTime) {
-            ZonedDateTime zonedDateTime = (ZonedDateTime) temporal;
-            instant = zonedDateTime.toInstant();
-            zone = zonedDateTime.getZone();
-            offset = zonedDateTime.getOffset();
+    /// An offset as the `X`, `x` and `Z` letters print it. `style` is the
+    /// count of `X`: 1 `+HHmm`, 2 `+HHMM`, 3 `+HH:MM`, 4 `+HHMMss`, 5
+    /// `+HH:MM:ss`.
+    private static void offset(StringBuilder out, int total, int style, String zeroText) {
+        if (total == 0) {
+            out.append(zeroText);
+            return;
+        }
+        int abs = Math.abs(total);
+        int hours = abs / 3600;
+        int minutes = (abs / 60) % 60;
+        int seconds = abs % 60;
+        boolean colon = style == 3 || style == 5;
+        out.append(total < 0 ? '-' : '+');
+        pad(out, hours, 2);
+        if (style == 1 && minutes == 0) {
+            return;
+        }
+        if (colon) {
+            out.append(':');
+        }
+        pad(out, minutes, 2);
+        if (style >= 4 && seconds != 0) {
+            if (colon) {
+                out.append(':');
+            }
+            pad(out, seconds, 2);
+        }
+    }
+
+    /// `GMT+8` (short) or `GMT+08:00` (full); `GMT` alone for zero.
+    private static void localizedOffset(StringBuilder out, int total, boolean full) {
+        out.append("GMT");
+        if (total == 0) {
+            return;
+        }
+        int abs = Math.abs(total);
+        int hours = abs / 3600;
+        int minutes = (abs / 60) % 60;
+        int seconds = abs % 60;
+        out.append(total < 0 ? '-' : '+');
+        if (full) {
+            pad(out, hours, 2);
+            out.append(':');
+            pad(out, minutes, 2);
+            if (seconds != 0) {
+                out.append(':');
+                pad(out, seconds, 2);
+            }
         } else {
-            throw new IllegalArgumentException("Unsupported temporal type");
+            out.append(hours);
+            if (minutes != 0 || seconds != 0) {
+                out.append(':');
+                pad(out, minutes, 2);
+                if (seconds != 0) {
+                    out.append(':');
+                    pad(out, seconds, 2);
+                }
+            }
         }
-        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, zone);
-        String knownPattern = formatKnownPattern(dateTime, offset, pattern, locale);
-        if (knownPattern != null) {
-            return knownPattern;
+    }
+
+    // ---- parsing ----
+
+    public TemporalAccessor parse(CharSequence text) {
+        if (text == null) {
+            throw new NullPointerException("text");
+        }
+        String s = text.toString();
+        Parsed p = new Parsed(s);
+        switch (kind) {
+            case KIND_PATTERN:
+                parsePattern(p);
+                break;
+            case KIND_LOCAL_DATE:
+                parseIsoDate(p);
+                break;
+            case KIND_LOCAL_TIME:
+                parseIsoTime(p);
+                break;
+            case KIND_LOCAL_DATE_TIME:
+                parseIsoDateTime(p);
+                break;
+            case KIND_OFFSET_DATE_TIME:
+                parseIsoDateTime(p);
+                parseOffsetId(p);
+                break;
+            case KIND_ZONED_DATE_TIME:
+                parseIsoDateTime(p);
+                parseOffsetId(p);
+                if (p.pos < s.length() && s.charAt(p.pos) == '[') {
+                    p.pos++;
+                    parseZoneId(p);
+                    p.literal(']');
+                }
+                break;
+            default:
+                Instant instant = parseIsoInstant(p);
+                // With a zone of its own the formatter places the moment
+                // in it, so the result is a zoned date and time as well.
+                return zone == null ? instant : ZonedDateTime.ofInstant(instant, zone);
+        }
+        if (p.pos < s.length()) {
+            throw new DateTimeParseException("Text '" + s + "' could not be parsed, unparsed text found at index "
+                    + p.pos, s, p.pos);
         }
-        SimpleDateFormat sdf = newFormat(pattern, zone, locale);
-        TimeZone original = TimeZone.getDefault();
         try {
-            if (zone != null) {
-                TimeZone.setDefault(TimeZoneSupport.toTimeZone(zone));
-            }
-            return sdf.format(new Date(instant.toEpochMilli()));
-        } finally {
-            TimeZone.setDefault(original);
+            return p.resolve(zone, kind != KIND_PATTERN);
+        } catch (DateTimeParseException ex) {
+            throw ex;
+        } catch (DateTimeException ex) {
+            throw new DateTimeParseException("Text '" + s + "' could not be parsed: " + ex.getMessage(), s, 0, ex);
+        }
+    }
+
+    /// Parses `text` and hands the result to `query`, as in
+    /// `formatter.parse(text, LocalDate::from)`.
+    public <T> T parse(CharSequence text, TemporalQuery<T> query) {
+        if (query == null) {
+            throw new NullPointerException("query");
+        }
+        TemporalAccessor parsed = parse(text);
+        try {
+            return query.queryFrom(parsed);
+        } catch (DateTimeParseException ex) {
+            throw ex;
+        } catch (RuntimeException ex) {
+            String s = text.toString();
+            throw new DateTimeParseException("Text '" + s + "' could not be parsed: " + ex.getMessage(), s, 0, ex);
         }
     }
 
-    private static String formatKnownPattern(LocalDateTime dateTime, ZoneOffset offset, String pattern, Locale locale) {
-        if ("yyyy-MM-dd'T'HH:mm:ssXXX".equals(pattern)) {
-            return formatLocalDate(dateTime.toLocalDate()) + "T" + formatHourMinuteSecond(dateTime.toLocalTime()) + formatOffset(offset);
+    private static void parseIsoDate(Parsed p) {
+        int start = p.pos;
+        boolean negative = false;
+        boolean signed = false;
+        if (p.pos < p.text.length() && (p.text.charAt(p.pos) == '+' || p.text.charAt(p.pos) == '-')) {
+            negative = p.text.charAt(p.pos) == '-';
+            signed = true;
+            p.pos++;
         }
-        if ("yyyy-MM-dd HH:mm XXX".equals(pattern)) {
-            return formatLocalDate(dateTime.toLocalDate()) + " " + formatHourMinute(dateTime.toLocalTime()) + " " + formatOffset(offset);
+        int digitsStart = p.pos;
+        long year = p.digits(4, 10);
+        if (p.pos - digitsStart > 4 && !signed) {
+            p.fail(start);
         }
-        if ("EEE MMM dd yyyy HH:mm".equals(pattern) && isEnglish(locale)) {
-            LocalDate date = dateTime.toLocalDate();
-            return EN_SHORT_DAYS[dayOfWeekSundayZero(date)] + " " + EN_SHORT_MONTHS[date.getMonthValue() - 1]
-                    + " " + pad(date.getDayOfMonth(), 2) + " " + pad(date.getYear(), 4)
-                    + " " + formatHourMinute(dateTime.toLocalTime());
+        if (signed && !negative && p.pos - digitsStart <= 4) {
+            p.fail(start);
         }
-        return null;
+        p.set(F_YEAR, negative ? -year : year);
+        p.literal('-');
+        p.set(F_MONTH, p.digits(2, 2));
+        p.literal('-');
+        p.set(F_DAY, p.digits(2, 2));
     }
 
-    private static boolean isEnglish(Locale locale) {
-        return locale == null || "en".equals(locale.getLanguage());
+    private static void parseIsoTime(Parsed p) {
+        p.set(F_HOUR, p.digits(2, 2));
+        p.literal(':');
+        p.set(F_MINUTE, p.digits(2, 2));
+        if (p.pos < p.text.length() && p.text.charAt(p.pos) == ':') {
+            p.pos++;
+            p.set(F_SECOND, p.digits(2, 2));
+            if (p.pos < p.text.length() && p.text.charAt(p.pos) == '.') {
+                p.pos++;
+                int from = p.pos;
+                long fraction = p.digits(0, 9);
+                int width = p.pos - from;
+                for (int i = width; i < 9; i++) {
+                    fraction *= 10;
+                }
+                p.set(F_NANO, fraction);
+            }
+        }
     }
 
-    private static int dayOfWeekSundayZero(LocalDate date) {
-        return (int) floorMod(date.toEpochDay() + 4, 7);
+    private static void parseIsoDateTime(Parsed p) {
+        parseIsoDate(p);
+        if (p.pos >= p.text.length() || (p.text.charAt(p.pos) != 'T' && p.text.charAt(p.pos) != 't')) {
+            p.fail(p.pos);
+        }
+        p.pos++;
+        parseIsoTime(p);
     }
 
-    private static long floorMod(long value, long divisor) {
-        long result = value % divisor;
-        return result < 0 ? result + divisor : result;
+    /// `Z`, or an offset of hours with optional minutes and seconds, with
+    /// or without colons.
+    private static void parseOffsetId(Parsed p) {
+        if (p.pos < p.text.length() && (p.text.charAt(p.pos) == 'Z' || p.text.charAt(p.pos) == 'z')) {
+            p.pos++;
+            p.offset = ZoneOffset.UTC;
+            return;
+        }
+        p.offset = ZoneOffset.ofTotalSeconds(p.offsetSeconds());
     }
 
-    private static SimpleDateFormat newFormat(String pattern, ZoneId zone, Locale locale) {
-        return new SimpleDateFormat(pattern);
+    private static void parseZoneId(Parsed p) {
+        int start = p.pos;
+        while (p.pos < p.text.length()) {
+            char c = p.text.charAt(p.pos);
+            if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '~' || c == '/'
+                    || c == '.' || c == '_' || c == '+' || c == '-' || c == ':') {
+                p.pos++;
+            } else {
+                break;
+            }
+        }
+        if (p.pos == start) {
+            p.fail(start);
+        }
+        try {
+            p.zone = ZoneId.of(p.text.substring(start, p.pos));
+        } catch (DateTimeException ex) {
+            p.fail(start);
+        }
     }
 
-    private static ParsedPatternResult parsePattern(String text, String pattern, ZoneId defaultZone, Locale locale) {
-        TimeZone original = TimeZone.getDefault();
+    private Instant parseIsoInstant(Parsed p) {
+        parseIsoDate(p);
+        if (p.pos >= p.text.length() || (p.text.charAt(p.pos) != 'T' && p.text.charAt(p.pos) != 't')) {
+            p.fail(p.pos);
+        }
+        p.pos++;
+        p.set(F_HOUR, p.digits(2, 2));
+        p.literal(':');
+        p.set(F_MINUTE, p.digits(2, 2));
+        p.literal(':');
+        p.set(F_SECOND, p.digits(2, 2));
+        long nano = 0;
+        if (p.pos < p.text.length() && p.text.charAt(p.pos) == '.') {
+            p.pos++;
+            int from = p.pos;
+            nano = p.digits(0, 9);
+            for (int i = p.pos - from; i < 9; i++) {
+                nano *= 10;
+            }
+        }
+        parseOffsetId(p);
+        if (p.pos < p.text.length()) {
+            throw new DateTimeParseException("Text '" + p.text + "' could not be parsed, unparsed text found at index "
+                    + p.pos, p.text, p.pos);
+        }
         try {
-            if (defaultZone != null) {
-                TimeZone.setDefault(TimeZoneSupport.toTimeZone(defaultZone));
+            int hour = (int) p.values[F_HOUR];
+            int second = (int) p.values[F_SECOND];
+            long dayAdjust = 0;
+            if (hour == 24 && p.values[F_MINUTE] == 0 && second == 0 && nano == 0) {
+                hour = 0;
+                dayAdjust = 1;
             }
-            SimpleDateFormat sdf = newFormat(pattern, defaultZone, locale);
-            Date date = sdf.parse(text);
-            Instant instant = Instant.ofEpochMilli(date.getTime());
-            ZoneId zone = defaultZone == null ? ZoneOffset.UTC : defaultZone;
-            return new ParsedPatternResult(instant, zone);
-        } catch (ParseException err) {
-            throw new DateTimeParseException(err.getMessage(), text, 0);
-        } finally {
-            TimeZone.setDefault(original);
+            if (second == 60) {
+                // A leap second reads as the last second of its minute.
+                second = 59;
+            }
+            LocalDate date = LocalDate.of((int) p.values[F_YEAR], (int) p.values[F_MONTH], (int) p.values[F_DAY])
+                    .plusDays(dayAdjust);
+            LocalTime time = LocalTime.of(hour, (int) p.values[F_MINUTE], second, (int) nano);
+            return LocalDateTime.of(date, time).toInstant(p.offset);
+        } catch (DateTimeException ex) {
+            throw new DateTimeParseException("Text '" + p.text + "' could not be parsed: " + ex.getMessage(), p.text,
+                    0, ex);
         }
     }
 
-    private static final class ParsedPatternResult {
-        final Instant instant;
-        final ZoneId zone;
+    private void parsePattern(Parsed p) {
+        parseTokens(p, 0, tokens.length);
+    }
 
-        ParsedPatternResult(Instant instant, ZoneId zone) {
-            this.instant = instant;
-            this.zone = zone;
+    /// Parses tokens `from` to `to`; an optional section that fails is
+    /// undone and skipped.
+    private void parseTokens(Parsed p, int from, int to) {
+        int i = from;
+        while (i < to) {
+            Token t = tokens[i];
+            if (t.kind == Token.OPTIONAL_START) {
+                int end = skipSection(i) - 1;
+                Parsed saved = p.copy();
+                try {
+                    parseTokens(p, i + 1, end);
+                } catch (DateTimeParseException ex) {
+                    p.restore(saved);
+                }
+                i = end + 1;
+                continue;
+            }
+            if (t.kind == Token.OPTIONAL_END) {
+                i++;
+                continue;
+            }
+            if (t.kind == Token.LITERAL) {
+                for (int c = 0; c < t.text.length(); c++) {
+                    p.literal(t.text.charAt(c));
+                }
+                i++;
+                continue;
+            }
+            parseField(p, t, reserved(i + 1, to));
+            i++;
         }
     }
 
-    private static int parseInt(String text, int start, int end) {
-        return Integer.parseInt(text.substring(start, end));
+    /// The digits the fixed-width numbers directly after token `i` need,
+    /// which a variable-width number before them leaves for them.
+    private int reserved(int i, int to) {
+        int total = 0;
+        while (i < to && tokens[i].kind == Token.FIELD) {
+            int width = fixedWidth(tokens[i]);
+            if (width <= 0) {
+                break;
+            }
+            total += width;
+            i++;
+        }
+        return total;
     }
 
-    private static LocalDateTime parseNumericLocalDateTime(String text, String pattern) {
-        try {
-            // These numeric patterns are parsed directly because the JavaAPI
-            // SimpleDateFormat subset does not reliably parse them. If the
-            // text has the exact shape but invalid values, fail at the bad
-            // field instead of falling through to the unrelated pattern parser.
-            if ("yyyy-MM-dd HH:mm:ss".equals(pattern) && text.length() == 19
-                    && text.charAt(4) == '-' && text.charAt(7) == '-'
-                    && text.charAt(10) == ' ' && text.charAt(13) == ':'
-                    && text.charAt(16) == ':') {
-                return LocalDateTime.of(
-                        parseInt(text, 0, 4),
-                        parseInt(text, 5, 7),
-                        parseInt(text, 8, 10),
-                        parseInt(text, 11, 13),
-                        parseInt(text, 14, 16),
-                        parseInt(text, 17, 19)
-                );
-            }
-            if ("yyyy-MM-dd HH:mm".equals(pattern) && text.length() == 16
-                    && text.charAt(4) == '-' && text.charAt(7) == '-'
-                    && text.charAt(10) == ' ' && text.charAt(13) == ':') {
-                return LocalDateTime.of(
-                        parseInt(text, 0, 4),
-                        parseInt(text, 5, 7),
-                        parseInt(text, 8, 10),
-                        parseInt(text, 11, 13),
-                        parseInt(text, 14, 16)
-                );
-            }
-        } catch (RuntimeException err) {
-            throw new DateTimeParseException(err.getMessage(), text, 0);
-        }
-        return null;
-    }
-
-    private static String pad(int value, int length) {
-        String s = String.valueOf(Math.abs(value));
-        StringBuffer out = new StringBuffer();
-        if (value < 0) {
-            out.append('-');
+    /// The width of a number that is always printed with exactly that many
+    /// digits, or 0.
+    private static int fixedWidth(Token t) {
+        switch (t.letter) {
+            case 'y':
+            case 'u':
+                return t.count == 2 ? 2 : 0;
+            case 'M':
+            case 'L':
+            case 'Q':
+            case 'q':
+                return t.count == 2 ? 2 : 0;
+            case 'd':
+            case 'H':
+            case 'h':
+            case 'K':
+            case 'k':
+            case 'm':
+            case 's':
+                return t.count == 2 ? 2 : 0;
+            case 'D':
+                return t.count == 3 ? 3 : 0;
+            case 'S':
+                return t.count;
+            default:
+                return 0;
         }
-        for (int i = s.length(); i < length; i++) {
-            out.append('0');
+    }
+
+    private static void parseField(Parsed p, Token t, int reserve) {
+        int count = t.count;
+        switch (t.letter) {
+            case 'G':
+                p.set(F_ERA, p.oneOf(count == 4 ? ERA_FULL : (count == 5 ? new String[] {"B", "A"}
+                        : new String[] {"BC", "AD"})));
+                return;
+            case 'u':
+            case 'y': {
+                int field = t.letter == 'u' ? F_YEAR : F_YEAR_OF_ERA;
+                if (count == 2) {
+                    p.set(field, 2000 + p.digits(2, 2));
+                } else {
+                    boolean negative = false;
+                    int start = p.pos;
+                    if (p.pos < p.text.length() && (p.text.charAt(p.pos) == '-'
+                            || (count >= 4 && p.text.charAt(p.pos) == '+'))) {
+                        negative = p.text.charAt(p.pos) == '-';
+                        p.pos++;
+                    }
+                    int digitsStart = p.pos;
+                    long value = p.digits(count, Math.max(count, 19 - reserve), reserve);
+                    if (count >= 4 && !negative && (p.pos - digitsStart > count) != (start != digitsStart)) {
+                        p.fail(start);
+                    }
+                    if (negative && t.letter == 'y') {
+                        p.fail(start);
+                    }
+                    p.set(field, negative ? -value : value);
+                }
+                return;
+            }
+            case 'M':
+            case 'L':
+                if (count >= 3) {
+                    p.set(F_MONTH, 1 + p.oneOf(styled(MONTHS, count)));
+                } else {
+                    p.set(F_MONTH, p.number(count, reserve));
+                }
+                return;
+            case 'Q':
+            case 'q':
+                if (count == 3) {
+                    p.literal('Q');
+                    p.set(F_QUARTER, p.digits(1, 1));
+                } else if (count == 4) {
+                    p.set(F_QUARTER, 1 + p.oneOf(new String[] {"1st quarter", "2nd quarter", "3rd quarter",
+                        "4th quarter"}));
+                } else if (count == 5) {
+                    p.set(F_QUARTER, p.digits(1, 1));
+                } else {
+                    p.set(F_QUARTER, p.number(count, reserve));
+                }
+                return;
+            case 'd':
+                p.set(F_DAY, p.number(count, reserve));
+                return;
+            case 'D':
+                p.set(F_DAY_OF_YEAR, count == 2 ? p.digits(2, 3, reserve) : p.number(count, reserve));
+                return;
+            case 'E':
+                p.set(F_DAY_OF_WEEK, 1 + p.oneOf(styled(DAYS, count)));
+                return;
+            case 'a':
+                p.set(F_AMPM, p.oneOf(new String[] {"AM", "PM"}));
+                return;
+            case 'h':
+                p.set(F_CLOCK_HOUR_AMPM, p.number(count, reserve));
+                return;
+            case 'K':
+                p.set(F_HOUR_AMPM, p.number(count, reserve));
+                return;
+            case 'k':
+                p.set(F_CLOCK_HOUR, p.number(count, reserve));
+                return;
+            case 'H':
+                p.set(F_HOUR, p.number(count, reserve));
+                return;
+            case 'm':
+                p.set(F_MINUTE, p.number(count, reserve));
+                return;
+            case 's':
+                p.set(F_SECOND, p.number(count, reserve));
+                return;
+            case 'S': {
+                long fraction = p.digits(count, count);
+                for (int i = count; i < 9; i++) {
+                    fraction *= 10;
+                }
+                p.set(F_NANO, fraction);
+                return;
+            }
+            case 'n':
+                p.set(F_NANO, p.number(count, reserve));
+                return;
+            case 'N':
+                p.set(F_NANO_OF_DAY, p.number(count, reserve));
+                return;
+            case 'A':
+                p.set(F_MILLI_OF_DAY, p.number(count, reserve));
+                return;
+            case 'V':
+            case 'z':
+                parseZoneId(p);
+                return;
+            case 'O': {
+                int start = p.pos;
+                p.literal('G');
+                p.literal('M');
+                p.literal('T');
+                if (p.pos < p.text.length() && (p.text.charAt(p.pos) == '+' || p.text.charAt(p.pos) == '-')) {
+                    boolean negative = p.text.charAt(p.pos) == '-';
+                    p.pos++;
+                    int hours = (int) p.digits(1, 2);
+                    int minutes = 0;
+                    int seconds = 0;
+                    if (p.pos < p.text.length() && p.text.charAt(p.pos) == ':') {
+                        p.pos++;
+                        minutes = (int) p.digits(2, 2);
+                        if (p.pos < p.text.length() && p.text.charAt(p.pos) == ':') {
+                            p.pos++;
+                            seconds = (int) p.digits(2, 2);
+                        }
+                    }
+                    int total = hours * 3600 + minutes * 60 + seconds;
+                    p.setOffset(negative ? -total : total, start);
+                } else {
+                    p.setOffset(0, start);
+                }
+                return;
+            }
+            case 'X':
+            case 'Z':
+                if ((t.letter == 'X' || count == 5) && p.pos < p.text.length() && p.text.charAt(p.pos) == 'Z') {
+                    p.pos++;
+                    p.offset = ZoneOffset.UTC;
+                    return;
+                }
+                p.setOffset(p.offsetSeconds(), p.pos);
+                return;
+            case 'x':
+                p.setOffset(p.offsetSeconds(), p.pos);
+                return;
+            default:
+                throw new IllegalStateException(String.valueOf(t.letter));
         }
-        out.append(s);
-        return out.toString();
     }
 
-    private static String formatLocalDate(LocalDate date) {
-        return pad(date.getYear(), 4) + "-" + pad(date.getMonthValue(), 2) + "-" + pad(date.getDayOfMonth(), 2);
+    /// The names of `full` in the style `count` asks for.
+    private static String[] styled(String[] full, int count) {
+        String[] out = new String[full.length];
+        for (int i = 0; i < full.length; i++) {
+            out[i] = count == 4 ? full[i] : (count == 5 ? full[i].substring(0, 1) : full[i].substring(0, 3));
+        }
+        return out;
     }
 
-    private static String formatLocalTime(LocalTime time) {
-        String base = pad(time.getHour(), 2) + ":" + pad(time.getMinute(), 2) + ":" + pad(time.getSecond(), 2);
-        if (time.getNano() == 0) {
-            return base;
+    // ---- what was read, and what it makes ----
+
+    private static final int F_ERA = 0;
+    private static final int F_YEAR = 1;
+    private static final int F_YEAR_OF_ERA = 2;
+    private static final int F_MONTH = 3;
+    private static final int F_DAY = 4;
+    private static final int F_DAY_OF_YEAR = 5;
+    private static final int F_DAY_OF_WEEK = 6;
+    private static final int F_QUARTER = 7;
+    private static final int F_AMPM = 8;
+    private static final int F_HOUR = 9;
+    private static final int F_CLOCK_HOUR = 10;
+    private static final int F_HOUR_AMPM = 11;
+    private static final int F_CLOCK_HOUR_AMPM = 12;
+    private static final int F_MINUTE = 13;
+    private static final int F_SECOND = 14;
+    private static final int F_NANO = 15;
+    private static final int F_NANO_OF_DAY = 16;
+    private static final int F_MILLI_OF_DAY = 17;
+    private static final int FIELD_COUNT = 18;
+
+    private static final String[] FIELD_NAMES = {"Era", "Year", "YearOfEra", "MonthOfYear", "DayOfMonth",
+        "DayOfYear", "DayOfWeek", "QuarterOfYear", "AmPmOfDay", "HourOfDay", "ClockHourOfDay", "HourOfAmPm",
+        "ClockHourOfAmPm", "MinuteOfHour", "SecondOfMinute", "NanoOfSecond", "NanoOfDay", "MilliOfDay"};
+    private static final long[] FIELD_MIN = {0, -999999999L, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0};
+    private static final long[] FIELD_MAX = {1, 999999999L, 1000000000L, 12, 31, 366, 7, 4, 1, 23, 24, 11, 12, 59,
+        59, 999999999L, 86399999999999L, 86399999L};
+
+    /// The state of one parse: where it is in the text and every field and
+    /// offset read so far.
+    private static final class Parsed implements TemporalAccessor {
+        final String text;
+        int pos;
+        final long[] values = new long[FIELD_COUNT];
+        final boolean[] present = new boolean[FIELD_COUNT];
+        /// Whether the time read was 24:00, which ends the day it was read
+        /// with and so moves a date read beside it on by one.
+        private boolean endOfDay;
+        ZoneOffset offset;
+        ZoneId zone;
+
+        Parsed(String text) {
+            this.text = text;
         }
-        String frac = String.valueOf(1000000000L + time.getNano()).substring(1);
-        while (frac.endsWith("0")) {
-            frac = frac.substring(0, frac.length() - 1);
+
+        Parsed copy() {
+            Parsed c = new Parsed(text);
+            c.pos = pos;
+            System.arraycopy(values, 0, c.values, 0, FIELD_COUNT);
+            System.arraycopy(present, 0, c.present, 0, FIELD_COUNT);
+            c.offset = offset;
+            c.zone = zone;
+            return c;
+        }
+
+        void restore(Parsed saved) {
+            pos = saved.pos;
+            System.arraycopy(saved.values, 0, values, 0, FIELD_COUNT);
+            System.arraycopy(saved.present, 0, present, 0, FIELD_COUNT);
+            offset = saved.offset;
+            zone = saved.zone;
+        }
+
+        void fail(int index) {
+            throw new DateTimeParseException("Text '" + text + "' could not be parsed at index " + index, text, index);
+        }
+
+        void set(int field, long value) {
+            if (present[field] && values[field] != value) {
+                throw new DateTimeParseException("Text '" + text + "' could not be parsed: Conflict found: "
+                        + FIELD_NAMES[field] + " " + values[field] + " differs from " + FIELD_NAMES[field] + " "
+                        + value, text, 0);
+            }
+            values[field] = value;
+            present[field] = true;
+        }
+
+        void setOffset(int seconds, int start) {
+            try {
+                offset = ZoneOffset.ofTotalSeconds(seconds);
+            } catch (DateTimeException ex) {
+                fail(start);
+            }
+        }
+
+        void literal(char c) {
+            if (pos >= text.length() || text.charAt(pos) != c) {
+                fail(pos);
+            }
+            pos++;
+        }
+
+        long digits(int min, int max) {
+            return digits(min, max, 0);
+        }
+
+        /// Between `min` and `max` digits, leaving `reserve` of them for
+        /// the fixed-width numbers that follow when there are more.
+        long digits(int min, int max, int reserve) {
+            int start = pos;
+            int end = start;
+            while (end < text.length() && end - start < max && text.charAt(end) >= '0' && text.charAt(end) <= '9') {
+                end++;
+            }
+            if (reserve > 0 && end - start - reserve >= min) {
+                end -= reserve;
+            }
+            if (end - start < min) {
+                fail(start);
+            }
+            long value = 0;
+            for (int i = start; i < end; i++) {
+                value = value * 10 + (text.charAt(i) - '0');
+                if (value < 0) {
+                    fail(start);
+                }
+            }
+            pos = end;
+            return value;
+        }
+
+        /// A number of one letter (one or more digits) or two (exactly two).
+        long number(int count, int reserve) {
+            return count == 1 ? digits(1, 19, reserve) : digits(count, count);
+        }
+
+        int oneOf(String[] names) {
+            int best = -1;
+            int bestLength = 0;
+            for (int i = 0; i < names.length; i++) {
+                String n = names[i];
+                if (n.length() > bestLength && text.regionMatches(pos, n, 0, n.length())) {
+                    best = i;
+                    bestLength = n.length();
+                }
+            }
+            if (best < 0) {
+                fail(pos);
+            }
+            pos += bestLength;
+            return best;
+        }
+
+        /// `+HH`, `+HHMM`, `+HH:MM`, `+HHMMss` or `+HH:MM:ss`.
+        int offsetSeconds() {
+            int start = pos;
+            if (pos >= text.length() || (text.charAt(pos) != '+' && text.charAt(pos) != '-')) {
+                fail(start);
+            }
+            boolean negative = text.charAt(pos) == '-';
+            pos++;
+            int hours = (int) digits(2, 2);
+            int minutes = 0;
+            int seconds = 0;
+            boolean colon = pos < text.length() && text.charAt(pos) == ':';
+            if (colon) {
+                pos++;
+            }
+            if (pos + 1 < text.length() && isDigit(pos) && isDigit(pos + 1)) {
+                minutes = (int) digits(2, 2);
+                if (colon ? pos < text.length() && text.charAt(pos) == ':' : true) {
+                    int mark = pos;
+                    if (colon) {
+                        pos++;
+                    }
+                    if (pos + 1 < text.length() && isDigit(pos) && isDigit(pos + 1)) {
+                        seconds = (int) digits(2, 2);
+                    } else {
+                        pos = mark;
+                    }
+                }
+            } else if (colon) {
+                fail(pos);
+            }
+            if (minutes > 59 || seconds > 59) {
+                fail(start);
+            }
+            int total = hours * 3600 + minutes * 60 + seconds;
+            if (total > 18 * 3600) {
+                fail(start);
+            }
+            return negative ? -total : total;
+        }
+
+        private boolean isDigit(int i) {
+            char c = text.charAt(i);
+            return c >= '0' && c <= '9';
+        }
+
+        private void check(int field, boolean strict) {
+            long v = values[field];
+            if (!strict) {
+                // The smart resolver takes 24:00 as the end of the day and
+                // a clock hour of 0 as midnight, as the JDK's does.
+                if (field == F_HOUR && v == 24) {
+                    return;
+                }
+                if ((field == F_CLOCK_HOUR || field == F_CLOCK_HOUR_AMPM) && v == 0) {
+                    return;
+                }
+            }
+            if (present[field] && (v < FIELD_MIN[field] || v > FIELD_MAX[field])) {
+                throw new DateTimeException("Invalid value for " + FIELD_NAMES[field] + " (valid values "
+                        + FIELD_MIN[field] + " - " + FIELD_MAX[field] + "): " + v);
+            }
+        }
+
+        /// The date, time, offset and zone that were read, as the class
+        /// they make: a zoned or offset date and time, a date and time, a
+        /// date, a time, or this when they make none of those.
+        TemporalAccessor resolve(ZoneId overrideZone, boolean strict) {
+            for (int f = 0; f < FIELD_COUNT; f++) {
+                check(f, strict);
+            }
+            LocalDate date = resolveDate(strict);
+            LocalTime time = resolveTime();
+            ZoneId z = zone != null ? zone : overrideZone;
+            if (date != null && time != null) {
+                LocalDateTime ldt = LocalDateTime.of(date, time);
+                if (endOfDay) {
+                    ldt = ldt.plusDays(1);
+                }
+                if (offset != null) {
+                    if (z == null) {
+                        return OffsetDateTime.of(ldt, offset);
+                    }
+                    return ZonedDateTime.ofInstant(ldt.toInstant(offset), z);
+                }
+                if (z != null) {
+                    return ZonedDateTime.of(ldt, z);
+                }
+                return ldt;
+            }
+            if (date != null) {
+                return date;
+            }
+            if (time != null) {
+                return time;
+            }
+            return this;
+        }
+
+        private LocalDate resolveDate(boolean strict) {
+            Long year = null;
+            if (present[F_YEAR]) {
+                year = Long.valueOf(values[F_YEAR]);
+            }
+            if (present[F_YEAR_OF_ERA]) {
+                long yoe = values[F_YEAR_OF_ERA];
+                long fromEra = !present[F_ERA] || values[F_ERA] == 1 ? yoe : 1 - yoe;
+                if (year != null && year.longValue() != fromEra) {
+                    throw new DateTimeException("Conflict found: Year " + year + " differs from Year " + fromEra);
+                }
+                year = Long.valueOf(fromEra);
+            } else if (present[F_ERA] && year != null && (year.longValue() >= 1 ? 1 : 0) != values[F_ERA]) {
+                throw new DateTimeException("Conflict found: Era " + values[F_ERA] + " differs from year " + year);
+            }
+            LocalDate date = null;
+            if (year != null && present[F_MONTH] && present[F_DAY]) {
+                int y = (int) year.longValue();
+                int m = (int) values[F_MONTH];
+                int d = (int) values[F_DAY];
+                if (!strict) {
+                    int length = LocalDate.of(y, m, 1).lengthOfMonth();
+                    if (d > length) {
+                        d = length;
+                    }
+                }
+                date = LocalDate.of(y, m, d);
+            } else if (year != null && present[F_DAY_OF_YEAR]) {
+                date = LocalDate.ofYearDay((int) year.longValue(), (int) values[F_DAY_OF_YEAR]);
+            }
+            if (date != null) {
+                if (present[F_DAY_OF_WEEK] && date.getDayOfWeek().getValue() != values[F_DAY_OF_WEEK]) {
+                    throw new DateTimeException("Conflict found: Field DayOfWeek " + date.getDayOfWeek().getValue()
+                            + " differs from DayOfWeek " + values[F_DAY_OF_WEEK] + " derived from " + date);
+                }
+                if (present[F_QUARTER] && (date.getMonthValue() - 1) / 3 + 1 != values[F_QUARTER]) {
+                    throw new DateTimeException("Conflict found: Field QuarterOfYear differs from " + date);
+                }
+            }
+            return date;
         }
-        return base + "." + frac;
-    }
 
-    private static String formatLocalDate(LocalDateTime dateTime) {
-        return formatLocalDate(dateTime.toLocalDate());
+        private LocalTime resolveTime() {
+            Long hour = null;
+            if (present[F_HOUR]) {
+                hour = Long.valueOf(values[F_HOUR]);
+            }
+            if (present[F_CLOCK_HOUR]) {
+                long h = values[F_CLOCK_HOUR] == 24 ? 0 : values[F_CLOCK_HOUR];
+                hour = conflict(hour, h);
+            }
+            if (present[F_AMPM]) {
+                if (present[F_CLOCK_HOUR_AMPM]) {
+                    long h = values[F_CLOCK_HOUR_AMPM] == 12 ? 0 : values[F_CLOCK_HOUR_AMPM];
+                    hour = conflict(hour, values[F_AMPM] * 12 + h);
+                }
+                if (present[F_HOUR_AMPM]) {
+                    hour = conflict(hour, values[F_AMPM] * 12 + values[F_HOUR_AMPM]);
+                }
+            }
+            if (hour == null) {
+                if (present[F_NANO_OF_DAY]) {
+                    return LocalTime.ofNanoOfDay(values[F_NANO_OF_DAY]);
+                }
+                if (present[F_MILLI_OF_DAY]) {
+                    return LocalTime.ofNanoOfDay(values[F_MILLI_OF_DAY] * 1000000L);
+                }
+                return null;
+            }
+            if (present[F_AMPM] && hour.longValue() / 12 != values[F_AMPM]) {
+                throw new DateTimeException("Conflict found: AmPmOfDay " + values[F_AMPM] + " differs from hour "
+                        + hour);
+            }
+            boolean minute = present[F_MINUTE];
+            boolean second = present[F_SECOND];
+            boolean nano = present[F_NANO];
+            if ((!minute && (second || nano)) || (minute && !second && nano)) {
+                return null;
+            }
+            if (hour.longValue() == 24) {
+                if ((minute && values[F_MINUTE] != 0) || (second && values[F_SECOND] != 0)
+                        || (nano && values[F_NANO] != 0)) {
+                    throw new DateTimeException("Invalid value for HourOfDay (valid values 0 - 23): 24");
+                }
+                endOfDay = true;
+                return LocalTime.MIDNIGHT;
+            }
+            return LocalTime.of((int) hour.longValue(), minute ? (int) values[F_MINUTE] : 0,
+                    second ? (int) values[F_SECOND] : 0, nano ? (int) values[F_NANO] : 0);
+        }
+
+        private static Long conflict(Long hour, long value) {
+            if (hour != null && hour.longValue() != value) {
+                throw new DateTimeException("Conflict found: HourOfDay " + hour + " differs from HourOfDay " + value);
+            }
+            return Long.valueOf(value);
+        }
+
+        public String toString() {
+            StringBuilder sb = new StringBuilder("{");
+            boolean first = true;
+            for (int f = 0; f < FIELD_COUNT; f++) {
+                if (present[f]) {
+                    if (!first) {
+                        sb.append(", ");
+                    }
+                    sb.append(FIELD_NAMES[f]).append('=').append(values[f]);
+                    first = false;
+                }
+            }
+            sb.append("},ISO");
+            if (zone != null) {
+                sb.append(',').append(zone);
+            } else if (offset != null) {
+                sb.append(',').append(offset);
+            }
+            return sb.toString();
+        }
     }
 
-    private static String formatLocalDateTime(LocalDateTime dateTime) {
-        return formatLocalDate(dateTime.toLocalDate()) + "T" + formatLocalTime(dateTime.toLocalTime());
+    // ---- what a value to format has ----
+
+    /// The date, time, offset and zone a value carries, after the
+    /// formatter's override zone is applied.
+    private static final class Fields {
+        LocalDate date;
+        LocalTime time;
+        ZoneOffset offsetValue;
+        ZoneId zone;
+        Long epochSecond;
+        int nano;
+        DayOfWeek dayOfWeek;
+
+        static Fields of(TemporalAccessor temporal, ZoneId override) {
+            Fields f = new Fields();
+            if (override != null) {
+                Instant instant = null;
+                if (temporal instanceof Instant) {
+                    instant = (Instant) temporal;
+                } else if (temporal instanceof OffsetDateTime) {
+                    instant = ((OffsetDateTime) temporal).toInstant();
+                } else if (temporal instanceof ZonedDateTime && !((ZonedDateTime) temporal).getZone().equals(override)) {
+                    instant = ((ZonedDateTime) temporal).toInstant();
+                }
+                if (instant != null) {
+                    temporal = ZonedDateTime.ofInstant(instant, override);
+                }
+            }
+            if (temporal instanceof ZonedDateTime) {
+                ZonedDateTime z = (ZonedDateTime) temporal;
+                f.date = z.toLocalDate();
+                f.time = z.toLocalTime();
+                f.offsetValue = z.getOffset();
+                f.zone = z.getZone();
+                f.epochSecond = Long.valueOf(z.toEpochSecond());
+                f.nano = z.getNano();
+            } else if (temporal instanceof OffsetDateTime) {
+                OffsetDateTime o = (OffsetDateTime) temporal;
+                f.date = o.toLocalDate();
+                f.time = o.toLocalTime();
+                f.offsetValue = o.getOffset();
+                f.epochSecond = Long.valueOf(o.toEpochSecond());
+                f.nano = o.getNano();
+            } else if (temporal instanceof LocalDateTime) {
+                LocalDateTime l = (LocalDateTime) temporal;
+                f.date = l.toLocalDate();
+                f.time = l.toLocalTime();
+                f.nano = l.getNano();
+            } else if (temporal instanceof LocalDate) {
+                f.date = (LocalDate) temporal;
+            } else if (temporal instanceof LocalTime) {
+                f.time = (LocalTime) temporal;
+                f.nano = f.time.getNano();
+            } else if (temporal instanceof Instant) {
+                Instant i = (Instant) temporal;
+                f.epochSecond = Long.valueOf(i.getEpochSecond());
+                f.nano = i.getNano();
+            } else if (temporal instanceof DayOfWeek) {
+                f.dayOfWeek = (DayOfWeek) temporal;
+            } else if (temporal instanceof ZoneOffset) {
+                f.offsetValue = (ZoneOffset) temporal;
+            }
+            if (f.zone == null && override != null && !(temporal instanceof Instant)) {
+                f.zone = override;
+            }
+            return f;
+        }
+
+        LocalDate date(String field) {
+            if (date == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+            }
+            return date;
+        }
+
+        LocalTime time(String field) {
+            if (time == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+            }
+            return time;
+        }
+
+        ZoneOffset offset(String field) {
+            if (offsetValue == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
+            }
+            return offsetValue;
+        }
+
+        DayOfWeek dayOfWeek() {
+            if (dayOfWeek != null) {
+                return dayOfWeek;
+            }
+            return date("DayOfWeek").getDayOfWeek();
+        }
+
+        int nanoOfSecond() {
+            if (time == null && epochSecond == null) {
+                throw new UnsupportedTemporalTypeException("Unsupported field: NanoOfSecond");
+            }
+            return nano;
+        }
     }
 
-    private static String formatHourMinute(LocalTime time) {
-        return pad(time.getHour(), 2) + ":" + pad(time.getMinute(), 2);
+    // ---- the pattern itself ----
+
+    private static final class Token {
+        static final int FIELD = 0;
+        static final int LITERAL = 1;
+        static final int OPTIONAL_START = 2;
+        static final int OPTIONAL_END = 3;
+
+        final int kind;
+        final char letter;
+        final int count;
+        final String text;
+
+        Token(int kind, char letter, int count, String text) {
+            this.kind = kind;
+            this.letter = letter;
+            this.count = count;
+            this.text = text;
+        }
     }
 
-    private static String formatHourMinuteSecond(LocalTime time) {
-        return pad(time.getHour(), 2) + ":" + pad(time.getMinute(), 2) + ":" + pad(time.getSecond(), 2);
+    private static final String SUPPORTED = "GuyMLQqdDEahKkHmsSnNAVzOXxZ";
+    private static final String KNOWN_UNSUPPORTED = "YwWecFgvBp";
+
+    private static Token[] compile(String pattern) {
+        ArrayList<Token> out = new ArrayList<Token>();
+        int depth = 0;
+        int i = 0;
+        while (i < pattern.length()) {
+            char c = pattern.charAt(i);
+            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
+                int start = i;
+                while (i < pattern.length() && pattern.charAt(i) == c) {
+                    i++;
+                }
+                int count = i - start;
+                if (KNOWN_UNSUPPORTED.indexOf(c) >= 0) {
+                    throw new IllegalArgumentException("Pattern letter not supported here: " + c);
+                }
+                if (SUPPORTED.indexOf(c) < 0) {
+                    throw new IllegalArgumentException("Unknown pattern letter: " + c);
+                }
+                validateCount(c, count);
+                out.add(new Token(Token.FIELD, c, count, null));
+            } else if (c == '\'') {
+                int start = i++;
+                StringBuilder lit = new StringBuilder();
+                boolean closed = false;
+                while (i < pattern.length()) {
+                    char q = pattern.charAt(i);
+                    if (q == '\'') {
+                        if (i + 1 < pattern.length() && pattern.charAt(i + 1) == '\'') {
+                            lit.append('\'');
+                            i += 2;
+                            continue;
+                        }
+                        closed = true;
+                        i++;
+                        break;
+                    }
+                    lit.append(q);
+                    i++;
+                }
+                if (!closed) {
+                    throw new IllegalArgumentException("Pattern ends with an incomplete string literal: " + pattern);
+                }
+                if (i - start == 2) {
+                    lit.append('\'');
+                }
+                out.add(new Token(Token.LITERAL, '\0', 0, lit.toString()));
+            } else if (c == '[') {
+                depth++;
+                out.add(new Token(Token.OPTIONAL_START, '\0', 0, null));
+                i++;
+            } else if (c == ']') {
+                if (depth == 0) {
+                    throw new IllegalArgumentException("Pattern invalid as it contains ] without previous [");
+                }
+                depth--;
+                out.add(new Token(Token.OPTIONAL_END, '\0', 0, null));
+                i++;
+            } else if (c == '{' || c == '}' || c == '#') {
+                throw new IllegalArgumentException("Pattern includes reserved character: '" + c + "'");
+            } else {
+                out.add(new Token(Token.LITERAL, '\0', 0, String.valueOf(c)));
+                i++;
+            }
+        }
+        while (depth-- > 0) {
+            out.add(new Token(Token.OPTIONAL_END, '\0', 0, null));
+        }
+        return out.toArray(new Token[out.size()]);
     }
 
-    private static String formatOffset(ZoneOffset offset) {
-        return offset.getId();
+    private static void validateCount(char c, int count) {
+        int max;
+        switch (c) {
+            case 'd':
+            case 'h':
+            case 'H':
+            case 'k':
+            case 'K':
+            case 'm':
+            case 's':
+                max = 2;
+                break;
+            case 'D':
+                max = 3;
+                break;
+            case 'a':
+                max = 1;
+                break;
+            case 'S':
+                max = 9;
+                break;
+            case 'z':
+                max = 4;
+                break;
+            case 'u':
+            case 'y':
+            case 'n':
+            case 'N':
+            case 'A':
+                max = 19;
+                break;
+            default:
+                max = 5;
+                break;
+        }
+        if (count > max) {
+            throw new IllegalArgumentException("Too many pattern letters: " + c);
+        }
+        if (c == 'V' && count != 2) {
+            throw new IllegalArgumentException("Pattern letter count must be 2: " + c);
+        }
+        if (c == 'O' && count != 1 && count != 4) {
+            throw new IllegalArgumentException("Pattern letter count must be 1 or 4: " + c);
+        }
     }
 
-    private static String formatInstant(Instant instant) {
-        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
-        return formatLocalDateTime(dateTime) + "Z";
+    public String toString() {
+        switch (kind) {
+            case KIND_LOCAL_DATE:
+                return "ISO_LOCAL_DATE";
+            case KIND_LOCAL_TIME:
+                return "ISO_LOCAL_TIME";
+            case KIND_LOCAL_DATE_TIME:
+                return "ISO_LOCAL_DATE_TIME";
+            case KIND_OFFSET_DATE_TIME:
+                return "ISO_OFFSET_DATE_TIME";
+            case KIND_ZONED_DATE_TIME:
+                return "ISO_ZONED_DATE_TIME";
+            case KIND_INSTANT:
+                return "ISO_INSTANT";
+            default:
+                return pattern;
+        }
     }
 }
diff --git a/vm/JavaAPI/src/java/time/temporal/ChronoUnit.java b/vm/JavaAPI/src/java/time/temporal/ChronoUnit.java
new file mode 100644
index 00000000000..9ad00f84c95
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/temporal/ChronoUnit.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.time.Duration;
+
+/// The units of the ISO calendar, with the JDK's order, names and lengths.
+public enum ChronoUnit implements TemporalUnit {
+    /// A nanosecond.
+    NANOS("Nanos", 0L, 1),
+    /// A microsecond.
+    MICROS("Micros", 0L, 1000),
+    /// A millisecond.
+    MILLIS("Millis", 0L, 1000000),
+    /// A second.
+    SECONDS("Seconds", 1L, 0),
+    /// A minute.
+    MINUTES("Minutes", 60L, 0),
+    /// An hour.
+    HOURS("Hours", 3600L, 0),
+    /// Twelve hours.
+    HALF_DAYS("HalfDays", 43200L, 0),
+    /// A day.
+    DAYS("Days", 86400L, 0),
+    /// Seven days.
+    WEEKS("Weeks", 7 * 86400L, 0),
+    /// A month, estimated as a twelfth of a year.
+    MONTHS("Months", 31556952L / 12, 0),
+    /// A year, estimated as 365.2425 days.
+    YEARS("Years", 31556952L, 0),
+    /// Ten years.
+    DECADES("Decades", 31556952L * 10L, 0),
+    /// A hundred years.
+    CENTURIES("Centuries", 31556952L * 100L, 0),
+    /// A thousand years.
+    MILLENNIA("Millennia", 31556952L * 1000L, 0),
+    /// An era, estimated as a billion years.
+    ERAS("Eras", 31556952L * 1000000000L, 0),
+    /// Forever: longer than any other unit.
+    FOREVER("Forever", Long.MAX_VALUE, 999999999);
+
+    private final String label;
+    private final long seconds;
+    private final int nanos;
+
+    ChronoUnit(String label, long seconds, int nanos) {
+        this.label = label;
+        this.seconds = seconds;
+        this.nanos = nanos;
+    }
+
+    @Override
+    public Duration getDuration() {
+        return Duration.ofSeconds(seconds, nanos);
+    }
+
+    @Override
+    public boolean isDurationEstimated() {
+        return compareTo(DAYS) >= 0;
+    }
+
+    @Override
+    public boolean isDateBased() {
+        return compareTo(DAYS) >= 0 && this != FOREVER;
+    }
+
+    @Override
+    public boolean isTimeBased() {
+        return compareTo(DAYS) < 0;
+    }
+
+    @Override
+    public boolean isSupportedBy(Temporal temporal) {
+        return temporal.isSupported(this);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <R extends Temporal> R addTo(R temporal, long amount) {
+        return (R) temporal.plus(amount, this);
+    }
+
+    @Override
+    public long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive) {
+        return temporal1Inclusive.until(temporal2Exclusive, this);
+    }
+
+    @Override
+    public String toString() {
+        return label;
+    }
+}
diff --git a/vm/JavaAPI/src/java/time/temporal/Temporal.java b/vm/JavaAPI/src/java/time/temporal/Temporal.java
new file mode 100644
index 00000000000..3691dd73012
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/temporal/Temporal.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+/// A date, a time or a moment that can be moved by an amount of time and
+/// measured against another of its kind.
+public interface Temporal extends TemporalAccessor {
+    /// Whether this value can add or subtract `unit`.
+    boolean isSupported(TemporalUnit unit);
+
+    /// This value moved forward by `amountToAdd` of `unit`.
+    Temporal plus(long amountToAdd, TemporalUnit unit);
+
+    /// This value moved back by `amountToSubtract` of `unit`.
+    default Temporal minus(long amountToSubtract, TemporalUnit unit) {
+        if (amountToSubtract == Long.MIN_VALUE) {
+            return plus(Long.MAX_VALUE, unit).plus(1, unit);
+        }
+        return plus(-amountToSubtract, unit);
+    }
+
+    /// This value moved forward by `amount`.
+    default Temporal plus(TemporalAmount amount) {
+        return amount.addTo(this);
+    }
+
+    /// This value moved back by `amount`.
+    default Temporal minus(TemporalAmount amount) {
+        return amount.subtractFrom(this);
+    }
+
+    /// The whole units of `unit` from this value to `endExclusive`.
+    long until(Temporal endExclusive, TemporalUnit unit);
+}
diff --git a/vm/JavaAPI/src/java/time/temporal/TemporalAccessor.java b/vm/JavaAPI/src/java/time/temporal/TemporalAccessor.java
index 93d35a217ec..6eb2ce641fa 100644
--- a/vm/JavaAPI/src/java/time/temporal/TemporalAccessor.java
+++ b/vm/JavaAPI/src/java/time/temporal/TemporalAccessor.java
@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.time.temporal;
 
 public interface TemporalAccessor {
diff --git a/vm/JavaAPI/src/java/time/temporal/TemporalAmount.java b/vm/JavaAPI/src/java/time/temporal/TemporalAmount.java
new file mode 100644
index 00000000000..5feea4d1152
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/temporal/TemporalAmount.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.util.List;
+
+/// An amount of time, such as a `Duration` or a `Period`.
+public interface TemporalAmount {
+    /// The amount of `unit` this holds.
+    long get(TemporalUnit unit);
+
+    /// The units this amount is made of.
+    List<TemporalUnit> getUnits();
+
+    /// `temporal` moved forward by this amount.
+    Temporal addTo(Temporal temporal);
+
+    /// `temporal` moved back by this amount.
+    Temporal subtractFrom(Temporal temporal);
+}
diff --git a/vm/JavaAPI/src/java/time/temporal/TemporalQuery.java b/vm/JavaAPI/src/java/time/temporal/TemporalQuery.java
new file mode 100644
index 00000000000..5d11d5100ca
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/temporal/TemporalQuery.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+/// A question asked of a date or time, such as what
+/// `formatter.parse(text, LocalDate::from)` takes as its second argument.
+public interface TemporalQuery<R> {
+    /// The answer for `temporal`.
+    R queryFrom(TemporalAccessor temporal);
+}
diff --git a/vm/JavaAPI/src/java/time/temporal/TemporalUnit.java b/vm/JavaAPI/src/java/time/temporal/TemporalUnit.java
new file mode 100644
index 00000000000..4b894f379a0
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/temporal/TemporalUnit.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.time.Duration;
+
+/// A unit time is measured in. `ChronoUnit` holds the units of the ISO
+/// calendar.
+public interface TemporalUnit {
+    /// The length of one unit; an estimate for the units a calendar decides.
+    Duration getDuration();
+
+    /// Whether the length is an estimate.
+    boolean isDurationEstimated();
+
+    /// Whether this is a unit of a date: a day or longer.
+    boolean isDateBased();
+
+    /// Whether this is a unit of a time of day: shorter than a day.
+    boolean isTimeBased();
+
+    /// Whether `temporal` can add or subtract this unit.
+    default boolean isSupportedBy(Temporal temporal) {
+        return temporal.isSupported(this);
+    }
+
+    /// `temporal` moved by `amount` of this unit.
+    <R extends Temporal> R addTo(R temporal, long amount);
+
+    /// How many whole units lie between two values of the same kind.
+    long between(Temporal temporal1Inclusive, Temporal temporal2Exclusive);
+}
diff --git a/vm/JavaAPI/src/java/time/temporal/UnsupportedTemporalTypeException.java b/vm/JavaAPI/src/java/time/temporal/UnsupportedTemporalTypeException.java
new file mode 100644
index 00000000000..b36e943c05b
--- /dev/null
+++ b/vm/JavaAPI/src/java/time/temporal/UnsupportedTemporalTypeException.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.time.temporal;
+
+import java.time.DateTimeException;
+
+/// Thrown when a date or time is asked for a unit it does not have.
+public class UnsupportedTemporalTypeException extends DateTimeException {
+    /// An exception with `message`.
+    public UnsupportedTemporalTypeException(String message) {
+        super(message);
+    }
+
+    /// An exception with `message`, caused by `cause`.
+    public UnsupportedTemporalTypeException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Arrays.java b/vm/JavaAPI/src/java/util/Arrays.java
index 3ce687f9ee5..4f25442320f 100644
--- a/vm/JavaAPI/src/java/util/Arrays.java
+++ b/vm/JavaAPI/src/java/util/Arrays.java
@@ -4085,4 +4085,59 @@ public static short[] copyOf(short[] original, int len) {
         return copyOfRange(original, 0, len);
     }
    
+
+    /// A sequential stream of the elements of `array`.
+    public static <T> java.util.stream.Stream<T> stream(T[] array) {
+        return java.util.stream.Stream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static <T> java.util.stream.Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.Stream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    /// A sequential stream of the elements of `array`.
+    public static java.util.stream.IntStream stream(int[] array) {
+        return java.util.stream.IntStream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static java.util.stream.IntStream stream(int[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.IntStream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    /// A sequential stream of the elements of `array`.
+    public static java.util.stream.LongStream stream(long[] array) {
+        return java.util.stream.LongStream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static java.util.stream.LongStream stream(long[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.LongStream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    /// A sequential stream of the elements of `array`.
+    public static java.util.stream.DoubleStream stream(double[] array) {
+        return java.util.stream.DoubleStream.of(array);
+    }
+
+    /// A sequential stream of the elements of `array` from `startInclusive` up
+    /// to, not including, `endExclusive`.
+    public static java.util.stream.DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
+        checkStreamRange(array.length, startInclusive, endExclusive);
+        return java.util.stream.DoubleStream.of(array).skip(startInclusive).limit(endExclusive - startInclusive);
+    }
+
+    private static void checkStreamRange(int length, int startInclusive, int endExclusive) {
+        if (startInclusive < 0 || endExclusive > length || startInclusive > endExclusive) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + startInclusive + ") > fence(" + endExclusive + ")");
+        }
+    }
+
 }
diff --git a/vm/JavaAPI/src/java/util/Base64.java b/vm/JavaAPI/src/java/util/Base64.java
new file mode 100644
index 00000000000..3d7e81f62e6
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/Base64.java
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.Base64`: the basic, URL-safe and MIME encodings of RFC 4648
+/// and RFC 2045, by the JDK's rules for padding and for what a decoder
+/// refuses.
+public final class Base64 {
+    private static final String BASIC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    private static final String URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    private static final byte[] CRLF = {'\r', '\n'};
+
+    private Base64() {
+    }
+
+    public static Encoder getEncoder() {
+        return new Encoder(BASIC, 0, null, true);
+    }
+
+    public static Encoder getUrlEncoder() {
+        return new Encoder(URL, 0, null, true);
+    }
+
+    public static Encoder getMimeEncoder() {
+        return new Encoder(BASIC, 76, CRLF, true);
+    }
+
+    public static Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) {
+        if (lineSeparator == null) {
+            throw new NullPointerException();
+        }
+        for (int i = 0; i < lineSeparator.length; i++) {
+            int b = lineSeparator[i] & 0xFF;
+            // The padding character too, as on the JDK: a '=' between two
+            // groups reads as the end of the data.
+            if (b == '=' || BASIC.indexOf((char) b) >= 0) {
+                throw new IllegalArgumentException("Illegal base64 line separator character 0x"
+                        + Integer.toString(b, 16));
+            }
+        }
+        // Rounded down to a multiple of four, as whole groups make a line.
+        int length = lineLength & ~3;
+        if (length <= 0) {
+            return new Encoder(BASIC, 0, null, true);
+        }
+        byte[] separator = new byte[lineSeparator.length];
+        System.arraycopy(lineSeparator, 0, separator, 0, separator.length);
+        return new Encoder(BASIC, length, separator, true);
+    }
+
+    public static Decoder getDecoder() {
+        return new Decoder(BASIC, false);
+    }
+
+    public static Decoder getUrlDecoder() {
+        return new Decoder(URL, false);
+    }
+
+    public static Decoder getMimeDecoder() {
+        return new Decoder(BASIC, true);
+    }
+
+    /// `java.util.Base64.Encoder`.
+    public static final class Encoder {
+        private final String alphabet;
+        private final int lineLength;
+        private final byte[] separator;
+        private final boolean padding;
+
+        Encoder(String alphabet, int lineLength, byte[] separator, boolean padding) {
+            this.alphabet = alphabet;
+            this.lineLength = lineLength;
+            this.separator = separator;
+            this.padding = padding;
+        }
+
+        /// The same encoding without the `=` that fills the last group.
+        public Encoder withoutPadding() {
+            return padding ? new Encoder(alphabet, lineLength, separator, false) : this;
+        }
+
+        private int length(int n) {
+            int length = padding ? 4 * ((n + 2) / 3) : 4 * (n / 3) + (n % 3 == 0 ? 0 : n % 3 + 1);
+            if (lineLength > 0 && length > 0) {
+                length += (length - 1) / lineLength * separator.length;
+            }
+            return length;
+        }
+
+        public byte[] encode(byte[] src) {
+            byte[] out = new byte[length(src.length)];
+            write(src, out);
+            return out;
+        }
+
+        /// Encodes into `dst`, which must be large enough, and answers how
+        /// many bytes were written.
+        public int encode(byte[] src, byte[] dst) {
+            if (dst.length < length(src.length)) {
+                throw new IllegalArgumentException("Output byte array is too small for encoding all input bytes");
+            }
+            return write(src, dst);
+        }
+
+        public String encodeToString(byte[] src) {
+            byte[] out = encode(src);
+            char[] chars = new char[out.length];
+            for (int i = 0; i < out.length; i++) {
+                chars[i] = (char) (out[i] & 0xFF);
+            }
+            return new String(chars);
+        }
+
+        private int write(byte[] src, byte[] dst) {
+            int at = 0;
+            int onLine = 0;
+            int n = src.length;
+            for (int i = 0; i < n; i += 3) {
+                if (lineLength > 0 && onLine == lineLength) {
+                    for (int s = 0; s < separator.length; s++) {
+                        dst[at++] = separator[s];
+                    }
+                    onLine = 0;
+                }
+                int left = n - i;
+                int bits = (src[i] & 0xFF) << 16;
+                if (left > 1) {
+                    bits |= (src[i + 1] & 0xFF) << 8;
+                }
+                if (left > 2) {
+                    bits |= src[i + 2] & 0xFF;
+                }
+                dst[at++] = (byte) alphabet.charAt((bits >> 18) & 0x3F);
+                dst[at++] = (byte) alphabet.charAt((bits >> 12) & 0x3F);
+                if (left > 1) {
+                    dst[at++] = (byte) alphabet.charAt((bits >> 6) & 0x3F);
+                } else if (padding) {
+                    dst[at++] = '=';
+                }
+                if (left > 2) {
+                    dst[at++] = (byte) alphabet.charAt(bits & 0x3F);
+                } else if (padding) {
+                    dst[at++] = '=';
+                }
+                onLine += 4;
+            }
+            return at;
+        }
+    }
+
+    /// `java.util.Base64.Decoder`.
+    public static final class Decoder {
+        private final int[] values = new int[256];
+        private final boolean mime;
+
+        Decoder(String alphabet, boolean mime) {
+            this.mime = mime;
+            for (int i = 0; i < 256; i++) {
+                values[i] = -1;
+            }
+            for (int i = 0; i < alphabet.length(); i++) {
+                values[alphabet.charAt(i)] = i;
+            }
+            values['='] = -2;
+        }
+
+        public byte[] decode(String src) {
+            byte[] bytes = new byte[src.length()];
+            for (int i = 0; i < bytes.length; i++) {
+                char c = src.charAt(i);
+                bytes[i] = (byte) (c < 256 ? c : '?');
+            }
+            return decode(bytes);
+        }
+
+        public byte[] decode(byte[] src) {
+            byte[] out = new byte[src.length / 4 * 3 + 3];
+            int n = read(src, out);
+            byte[] exact = new byte[n];
+            System.arraycopy(out, 0, exact, 0, n);
+            return exact;
+        }
+
+        /// Decodes into `dst`, which must be large enough, and answers how
+        /// many bytes were written.
+        public int decode(byte[] src, byte[] dst) {
+            byte[] out = decode(src);
+            if (dst.length < out.length) {
+                throw new IllegalArgumentException("Output byte array is too small for decoding all input bytes");
+            }
+            System.arraycopy(out, 0, dst, 0, out.length);
+            return out.length;
+        }
+
+        private int read(byte[] src, byte[] dst) {
+            int at = 0;
+            int bits = 0;
+            int shift = 18;
+            int sp = 0;
+            int end = src.length;
+            while (sp < end) {
+                int b = values[src[sp++] & 0xFF];
+                if (b < 0) {
+                    if (b == -2) {
+                        // xx== or xxx=, and nothing else, ends the input.
+                        if (shift == 6 && (sp == end || src[sp++] != '=') || shift == 18) {
+                            throw new IllegalArgumentException("Input byte array has wrong 4-byte ending unit");
+                        }
+                        break;
+                    }
+                    if (mime) {
+                        continue;
+                    }
+                    throw new IllegalArgumentException("Illegal base64 character "
+                            + Integer.toString(src[sp - 1], 16));
+                }
+                bits |= b << shift;
+                shift -= 6;
+                if (shift < 0) {
+                    dst[at++] = (byte) (bits >> 16);
+                    dst[at++] = (byte) (bits >> 8);
+                    dst[at++] = (byte) bits;
+                    shift = 18;
+                    bits = 0;
+                }
+            }
+            if (shift == 6) {
+                dst[at++] = (byte) (bits >> 16);
+            } else if (shift == 0) {
+                dst[at++] = (byte) (bits >> 16);
+                dst[at++] = (byte) (bits >> 8);
+            } else if (shift == 12) {
+                throw new IllegalArgumentException("Last unit does not have enough valid bits");
+            }
+            while (sp < end) {
+                if (mime && values[src[sp++] & 0xFF] < 0) {
+                    continue;
+                }
+                throw new IllegalArgumentException("Input byte array has incorrect ending byte at " + sp);
+            }
+            return at;
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Collection.java b/vm/JavaAPI/src/java/util/Collection.java
index 98875ca42f8..ea19d9470b3 100644
--- a/vm/JavaAPI/src/java/util/Collection.java
+++ b/vm/JavaAPI/src/java/util/Collection.java
@@ -17,6 +17,7 @@
 
 package java.util;
 
+import java.util.function.IntFunction;
 import java.util.function.Predicate;
 
 
@@ -335,13 +336,27 @@ default boolean removeIf(Predicate<? super E> filter) {
         return removed;
     }
 
-    /**
-     * A sequential stream over a snapshot of this collection's elements.
-     *
-     * @return a stream of the elements
-     */
-    @SuppressWarnings("unchecked")
+    /// A sequential stream of the elements, read when a terminal operation
+    /// asks for them, so elements added before then are seen.
     default java.util.stream.Stream<E> stream() {
-        return (java.util.stream.Stream<E>) java.util.stream.Stream.of(toArray());
+        return java.util.stream.StreamSupport.stream(spliterator(), false);
     }
+
+    /// The same as [#stream()]: streams here are sequential, which the JDK
+    /// allows a parallel stream to be.
+    default java.util.stream.Stream<E> parallelStream() {
+        return java.util.stream.StreamSupport.stream(spliterator(), true);
+    }
+
+    /// The elements, read from [#iterator()] when the first one is asked for.
+    @Override
+    default Spliterator<E> spliterator() {
+        return Spliterators.spliterator(this, 0);
+    }
+
+    /// The elements in an array `generator` makes, as `toArray(generator.apply(0))`.
+    default <T> T[] toArray(IntFunction<T[]> generator) {
+        return toArray(generator.apply(0));
+    }
+
 }
diff --git a/vm/JavaAPI/src/java/util/Comparator.java b/vm/JavaAPI/src/java/util/Comparator.java
index 44dcda17a8c..9f4fccd7fad 100644
--- a/vm/JavaAPI/src/java/util/Comparator.java
+++ b/vm/JavaAPI/src/java/util/Comparator.java
@@ -182,6 +182,148 @@ static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
         // collection traversal keys on, in every application.
         return (Comparator<T>) NaturalOrder.INSTANCE.reversed();
     }
+
+    /// This ordering, ties broken by a key in the order `keyComparator` gives.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param keyComparator orders the keys
+    /// @param <U> the key type
+    /// @return the combined comparator
+    default <U> Comparator<T> thenComparing(java.util.function.Function<? super T, ? extends U> keyExtractor,
+            Comparator<? super U> keyComparator) {
+        return thenComparing(Comparator.<T, U>comparing(keyExtractor, keyComparator));
+    }
+
+    /// This ordering, ties broken by an `int` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @return the combined comparator
+    default Comparator<T> thenComparingInt(java.util.function.ToIntFunction<? super T> keyExtractor) {
+        return thenComparing(Comparator.<T>comparingInt(keyExtractor));
+    }
+
+    /// This ordering, ties broken by a `long` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @return the combined comparator
+    default Comparator<T> thenComparingLong(java.util.function.ToLongFunction<? super T> keyExtractor) {
+        return thenComparing(Comparator.<T>comparingLong(keyExtractor));
+    }
+
+    /// This ordering, ties broken by a `double` key, compared as [Double#compare] does.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @return the combined comparator
+    default Comparator<T> thenComparingDouble(java.util.function.ToDoubleFunction<? super T> keyExtractor) {
+        return thenComparing(Comparator.<T>comparingDouble(keyExtractor));
+    }
+
+    /// Compares by an `int` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> comparingInt(final java.util.function.ToIntFunction<? super T> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                int x = keyExtractor.applyAsInt(a);
+                int y = keyExtractor.applyAsInt(b);
+                return x < y ? -1 : x == y ? 0 : 1;
+            }
+        };
+    }
+
+    /// Compares by a `long` key.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> comparingLong(final java.util.function.ToLongFunction<? super T> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                long x = keyExtractor.applyAsLong(a);
+                long y = keyExtractor.applyAsLong(b);
+                return x < y ? -1 : x == y ? 0 : 1;
+            }
+        };
+    }
+
+    /// Compares by a `double` key, as [Double#compare] does: NaN above
+    /// everything and `-0.0` below `0.0`.
+    ///
+    /// @param keyExtractor extracts the key
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> comparingDouble(final java.util.function.ToDoubleFunction<? super T> keyExtractor) {
+        if (keyExtractor == null) {
+            throw new NullPointerException();
+        }
+        return new Comparator<T>() {
+            public int compare(T a, T b) {
+                return Double.compare(keyExtractor.applyAsDouble(a), keyExtractor.applyAsDouble(b));
+            }
+        };
+    }
+
+    /// Orders null before every other value, and the rest by `comparator`;
+    /// with a null `comparator` the others are all equal.
+    ///
+    /// @param comparator orders the values that are not null, or null
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
+        return new NullOrder<T>(true, comparator);
+    }
+
+    /// Orders null after every other value, and the rest by `comparator`;
+    /// with a null `comparator` the others are all equal.
+    ///
+    /// @param comparator orders the values that are not null, or null
+    /// @param <T> the compared type
+    /// @return the comparator
+    static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
+        return new NullOrder<T>(false, comparator);
+    }
+}
+
+/// The order [Comparator#nullsFirst] and [Comparator#nullsLast] hand out. Its
+/// [#reversed] keeps null on the same side and reverses the rest, as the JDK's does.
+final class NullOrder<T> implements Comparator<T> {
+    private final boolean nullFirst;
+    private final Comparator<T> real;
+
+    @SuppressWarnings("unchecked")
+    NullOrder(boolean nullFirst, Comparator<? super T> real) {
+        this.nullFirst = nullFirst;
+        this.real = (Comparator<T>) real;
+    }
+
+    public int compare(T a, T b) {
+        if (a == null) {
+            return b == null ? 0 : nullFirst ? -1 : 1;
+        }
+        if (b == null) {
+            return nullFirst ? 1 : -1;
+        }
+        return real == null ? 0 : real.compare(a, b);
+    }
+
+    public Comparator<T> thenComparing(Comparator<? super T> other) {
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        return new NullOrder<T>(nullFirst, real == null ? other : real.thenComparing(other));
+    }
+
+    public Comparator<T> reversed() {
+        return new NullOrder<T>(!nullFirst, real == null ? null : real.reversed());
+    }
 }
 
 /** The natural ordering {@link Comparator#naturalOrder()} hands out. */
diff --git a/vm/JavaAPI/src/java/util/Date.java b/vm/JavaAPI/src/java/util/Date.java
index d59977f56d2..724a75c256d 100644
--- a/vm/JavaAPI/src/java/util/Date.java
+++ b/vm/JavaAPI/src/java/util/Date.java
@@ -90,4 +90,83 @@ public int compareTo(Date another) {
         return getTime() < another.getTime() ? -1 : getTime() > another.getTime() ? 1 : 0;
     }
 
+    /// This date as an [java.time.Instant].
+    public java.time.Instant toInstant() {
+        return java.time.Instant.ofEpochMilli(getTime());
+    }
+
+    /// The date of `instant`, which must fit in milliseconds since the
+    /// epoch.
+    public static Date from(java.time.Instant instant) {
+        try {
+            return new Date(instant.toEpochMilli());
+        } catch (ArithmeticException ex) {
+            throw new IllegalArgumentException(ex.toString());
+        }
+    }
+
+    /// Whether this date is after `when`.
+    public boolean after(Date when) {
+        return getTime() > when.getTime();
+    }
+
+    /// Whether this date is before `when`.
+    public boolean before(Date when) {
+        return getTime() < when.getTime();
+    }
+
+    private int field(int field) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(this);
+        return calendar.get(field);
+    }
+
+    /// The year less 1900, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.YEAR) - 1900`
+    public int getYear() {
+        return field(Calendar.YEAR) - 1900;
+    }
+
+    /// The month, 0 for January, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.MONTH)`
+    public int getMonth() {
+        return field(Calendar.MONTH);
+    }
+
+    /// The day of the month, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.DAY_OF_MONTH)`
+    public int getDate() {
+        return field(Calendar.DAY_OF_MONTH);
+    }
+
+    /// The day of the week, 0 for Sunday, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.DAY_OF_WEEK)`
+    public int getDay() {
+        return field(Calendar.DAY_OF_WEEK) - Calendar.SUNDAY;
+    }
+
+    /// The hour of the day, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.HOUR_OF_DAY)`
+    public int getHours() {
+        return field(Calendar.HOUR_OF_DAY);
+    }
+
+    /// The minute of the hour, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.MINUTE)`
+    public int getMinutes() {
+        return field(Calendar.MINUTE);
+    }
+
+    /// The second of the minute, in the default time zone.
+    ///
+    /// @deprecated use `Calendar.get(Calendar.SECOND)`
+    public int getSeconds() {
+        return field(Calendar.SECOND);
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/DoubleSum.java b/vm/JavaAPI/src/java/util/DoubleSum.java
new file mode 100644
index 00000000000..02920bd9cb8
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/DoubleSum.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// A running sum of `double` values that carries the rounding error of each
+/// addition along (Kahan summation), so that adding many small values to a
+/// large one does not lose them.
+final class DoubleSum {
+
+    private double sum;
+    private double compensation;
+    /// The plain sum, which is what says "infinite" when the compensated
+    /// one has turned into a NaN by subtracting two infinities.
+    private double simple;
+
+    void add(double value) {
+        simple += value;
+        double corrected = value - compensation;
+        double next = sum + corrected;
+        compensation = (next - sum) - corrected;
+        sum = next;
+    }
+
+    void add(DoubleSum other) {
+        double plain = simple + other.simple;
+        add(other.sum);
+        add(-other.compensation);
+        simple = plain;
+    }
+
+    double value() {
+        double out = sum - compensation;
+        if (Double.isNaN(out) && Double.isInfinite(simple)) {
+            return simple;
+        }
+        return out;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/DoubleSummaryStatistics.java b/vm/JavaAPI/src/java/util/DoubleSummaryStatistics.java
new file mode 100644
index 00000000000..4d219243bb2
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/DoubleSummaryStatistics.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.DoubleConsumer;
+
+/// The count,
+/// sum, minimum, maximum and average of the values it was given.
+public class DoubleSummaryStatistics implements DoubleConsumer {
+
+    private long count;
+    private final DoubleSum sum = new DoubleSum();
+    private double min = Double.POSITIVE_INFINITY;
+    private double max = Double.NEGATIVE_INFINITY;
+
+    public DoubleSummaryStatistics() {
+        // Nothing seen yet.
+    }
+
+    @Override
+    public void accept(double value) {
+        count++;
+        sum.add(value);
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+
+    public void combine(DoubleSummaryStatistics other) {
+        count += other.count;
+        sum.add(other.sum);
+        min = Math.min(min, other.min);
+        max = Math.max(max, other.max);
+    }
+
+    public final long getCount() {
+        return count;
+    }
+
+    public final double getSum() {
+        return sum.value();
+    }
+
+    public final double getMin() {
+        return min;
+    }
+
+    public final double getMax() {
+        return max;
+    }
+
+    public final double getAverage() {
+        return count > 0 ? (double) getSum() / count : 0.0d;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/EventObject.java b/vm/JavaAPI/src/java/util/EventObject.java
new file mode 100644
index 00000000000..48f852f5505
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/EventObject.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.EventObject`: the root of every
+/// listener event, carrying the object the event happened on.
+public class EventObject implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /// The object the event initially occurred on.
+    protected transient Object source;
+
+    public EventObject(Object source) {
+        if (source == null) {
+            throw new IllegalArgumentException("null source");
+        }
+        this.source = source;
+    }
+
+    public Object getSource() {
+        return source;
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + "[source=" + source + "]";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/HexFormat.java b/vm/JavaAPI/src/java/util/HexFormat.java
new file mode 100644
index 00000000000..d0c73c05d3e
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/HexFormat.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.HexFormat`: bytes to hexadecimal text and back, with an
+/// optional delimiter between bytes and a prefix and suffix around each.
+public final class HexFormat {
+    private static final String LOWER = "0123456789abcdef";
+    private static final String UPPER = "0123456789ABCDEF";
+    private static final HexFormat PLAIN = new HexFormat("", "", "", false);
+
+    private final String delimiter;
+    private final String prefix;
+    private final String suffix;
+    private final boolean upper;
+
+    private HexFormat(String delimiter, String prefix, String suffix, boolean upper) {
+        if (delimiter == null || prefix == null || suffix == null) {
+            throw new NullPointerException();
+        }
+        this.delimiter = delimiter;
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.upper = upper;
+    }
+
+    /// Lowercase digits and nothing between or around the bytes.
+    public static HexFormat of() {
+        return PLAIN;
+    }
+
+    public static HexFormat ofDelimiter(String delimiter) {
+        return new HexFormat(delimiter, "", "", false);
+    }
+
+    public HexFormat withDelimiter(String delimiter) {
+        return new HexFormat(delimiter, prefix, suffix, upper);
+    }
+
+    public HexFormat withPrefix(String prefix) {
+        return new HexFormat(delimiter, prefix, suffix, upper);
+    }
+
+    public HexFormat withSuffix(String suffix) {
+        return new HexFormat(delimiter, prefix, suffix, upper);
+    }
+
+    public HexFormat withUpperCase() {
+        return new HexFormat(delimiter, prefix, suffix, true);
+    }
+
+    public HexFormat withLowerCase() {
+        return new HexFormat(delimiter, prefix, suffix, false);
+    }
+
+    public String delimiter() {
+        return delimiter;
+    }
+
+    public String prefix() {
+        return prefix;
+    }
+
+    public String suffix() {
+        return suffix;
+    }
+
+    public boolean isUpperCase() {
+        return upper;
+    }
+
+    public String formatHex(byte[] bytes) {
+        return formatHex(bytes, 0, bytes.length);
+    }
+
+    public String formatHex(byte[] bytes, int fromIndex, int toIndex) {
+        if (fromIndex < 0 || toIndex > bytes.length || fromIndex > toIndex) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + toIndex
+                    + ") out of bounds for length " + bytes.length);
+        }
+        String digits = upper ? UPPER : LOWER;
+        StringBuilder out = new StringBuilder();
+        for (int i = fromIndex; i < toIndex; i++) {
+            if (i > fromIndex) {
+                out.append(delimiter);
+            }
+            out.append(prefix).append(digits.charAt((bytes[i] >> 4) & 0xF)).append(digits.charAt(bytes[i] & 0xF))
+                    .append(suffix);
+        }
+        return out.toString();
+    }
+
+    public byte[] parseHex(CharSequence string) {
+        return parseHex(string, 0, string.length());
+    }
+
+    public byte[] parseHex(CharSequence string, int fromIndex, int toIndex) {
+        if (fromIndex < 0 || toIndex > string.length() || fromIndex > toIndex) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + toIndex
+                    + ") out of bounds for length " + string.length());
+        }
+        int length = toIndex - fromIndex;
+        if (length == 0) {
+            return new byte[0];
+        }
+        int each = prefix.length() + 2 + suffix.length();
+        int stride = each + delimiter.length();
+        if ((length - each) % stride != 0) {
+            throw new IllegalArgumentException("extra or missing delimiters "
+                    + "or values consisting of prefix, two hexadecimal digits, and suffix in the string");
+        }
+        byte[] out = new byte[(length - each) / stride + 1];
+        int at = fromIndex;
+        for (int i = 0; i < out.length; i++) {
+            if (i > 0) {
+                at = expect(string, at, delimiter, "delimiter");
+            }
+            at = expect(string, at, prefix, "prefix");
+            out[i] = (byte) (fromHexDigit(string.charAt(at)) * 16 + fromHexDigit(string.charAt(at + 1)));
+            at = expect(string, at + 2, suffix, "suffix");
+        }
+        return out;
+    }
+
+    private static int expect(CharSequence string, int at, String literal, String what) {
+        for (int i = 0; i < literal.length(); i++) {
+            if (string.charAt(at + i) != literal.charAt(i)) {
+                throw new IllegalArgumentException("found: \"" + string.subSequence(at, at + literal.length())
+                        + "\", expected: \"" + literal + "\", index: " + at + " ch: "
+                        + Integer.toHexString(string.charAt(at)));
+            }
+        }
+        return at + literal.length();
+    }
+
+    public char toLowHexDigit(int value) {
+        return (upper ? UPPER : LOWER).charAt(value & 0xF);
+    }
+
+    public char toHighHexDigit(int value) {
+        return (upper ? UPPER : LOWER).charAt((value >> 4) & 0xF);
+    }
+
+    public String toHexDigits(byte value) {
+        return toHexDigits(value, 2);
+    }
+
+    public String toHexDigits(char value) {
+        return toHexDigits(value, 4);
+    }
+
+    public String toHexDigits(short value) {
+        return toHexDigits(value, 4);
+    }
+
+    public String toHexDigits(int value) {
+        return toHexDigits(value, 8);
+    }
+
+    public String toHexDigits(long value) {
+        return toHexDigits(value, 16);
+    }
+
+    public String toHexDigits(long value, int digits) {
+        if (digits < 0 || digits > 16) {
+            throw new IllegalArgumentException("number of digits: " + digits);
+        }
+        char[] out = new char[digits];
+        long v = value;
+        for (int i = digits - 1; i >= 0; i--) {
+            out[i] = toLowHexDigit((int) v);
+            v >>>= 4;
+        }
+        return new String(out);
+    }
+
+    public static boolean isHexDigit(int ch) {
+        return ch >= '0' && ch <= '9' || ch >= 'a' && ch <= 'f' || ch >= 'A' && ch <= 'F';
+    }
+
+    public static int fromHexDigit(int ch) {
+        if (ch >= '0' && ch <= '9') {
+            return ch - '0';
+        }
+        if (ch >= 'a' && ch <= 'f') {
+            return ch - 'a' + 10;
+        }
+        if (ch >= 'A' && ch <= 'F') {
+            return ch - 'A' + 10;
+        }
+        throw new NumberFormatException("not a hexadecimal digit: \"" + (char) ch + "\" = " + ch);
+    }
+
+    public static int fromHexDigits(CharSequence string) {
+        int length = string.length();
+        if (length > 8) {
+            throw new IllegalArgumentException("string length greater than 8: " + length);
+        }
+        int value = 0;
+        for (int i = 0; i < length; i++) {
+            value = (value << 4) + fromHexDigit(string.charAt(i));
+        }
+        return value;
+    }
+
+    public static long fromHexDigitsToLong(CharSequence string) {
+        int length = string.length();
+        if (length > 16) {
+            throw new IllegalArgumentException("string length greater than 16: " + length);
+        }
+        long value = 0;
+        for (int i = 0; i < length; i++) {
+            value = (value << 4) + fromHexDigit(string.charAt(i));
+        }
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof HexFormat)) {
+            return false;
+        }
+        HexFormat other = (HexFormat) o;
+        return upper == other.upper && delimiter.equals(other.delimiter) && prefix.equals(other.prefix)
+                && suffix.equals(other.suffix);
+    }
+
+    @Override
+    public int hashCode() {
+        return (delimiter.hashCode() * 31 + prefix.hashCode()) * 31 + suffix.hashCode() + (upper ? 1 : 0);
+    }
+
+    @Override
+    public String toString() {
+        return "uppercase: " + upper + ", delimiter: \"" + delimiter + "\", prefix: \"" + prefix
+                + "\", suffix: \"" + suffix + "\"";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/ImmutableCollections.java b/vm/JavaAPI/src/java/util/ImmutableCollections.java
new file mode 100644
index 00000000000..a7e5309180e
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/ImmutableCollections.java
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
+/// What `List.of`, `Set.of`, `Map.of`, their `copyOf` forms and `Map.entry`
+/// answer: collections that reject null elements and every mutation, as the
+/// JDK's do. A set and a map iterate in no particular order, which the JDK
+/// leaves unspecified too; they are hashed rather than linked so an
+/// application that never calls them does not keep `LinkedHashMap`.
+final class ImmutableCollections {
+
+    private ImmutableCollections() {
+    }
+
+    /// A list of `elements`, which the caller hands over: nothing else may
+    /// hold the array.
+    static <E> List<E> list(Object[] elements) {
+        for (int i = 0; i < elements.length; i++) {
+            Objects.requireNonNull(elements[i]);
+        }
+        return new ImmutableList<E>(elements);
+    }
+
+    /// A set of `elements`. Two equal ones are an error when `strict`, as in
+    /// `Set.of`, and one element otherwise, as in `Set.copyOf`.
+    @SuppressWarnings("unchecked")
+    static <E> Set<E> set(Object[] elements, boolean strict) {
+        HashSet<E> all = new HashSet<E>();
+        for (int i = 0; i < elements.length; i++) {
+            if (!all.add((E) Objects.requireNonNull(elements[i])) && strict) {
+                throw new IllegalArgumentException("duplicate element: " + elements[i]);
+            }
+        }
+        return new ImmutableSet<E>(all);
+    }
+
+    /// A map of `keysAndValues`, alternating.
+    @SuppressWarnings("unchecked")
+    static <K, V> Map<K, V> map(Object[] keysAndValues) {
+        HashMap<K, V> all = new HashMap<K, V>();
+        for (int i = 0; i < keysAndValues.length; i += 2) {
+            K key = (K) Objects.requireNonNull(keysAndValues[i]);
+            V value = (V) Objects.requireNonNull(keysAndValues[i + 1]);
+            if (all.containsKey(key)) {
+                throw new IllegalArgumentException("duplicate key: " + key);
+            }
+            all.put(key, value);
+        }
+        return new ImmutableMap<K, V>(all);
+    }
+
+    /// A list of a copy of `elements`.
+    static <E> List<E> listCopy(Object[] elements) {
+        Object[] copy = new Object[elements.length];
+        System.arraycopy(elements, 0, copy, 0, elements.length);
+        return list(copy);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <E> List<E> listCopyOf(Collection<? extends E> collection) {
+        if (collection instanceof ImmutableList) {
+            return (List<E>) collection;
+        }
+        return list(collection.toArray());
+    }
+
+    @SuppressWarnings("unchecked")
+    static <E> Set<E> setCopyOf(Collection<? extends E> collection) {
+        if (collection instanceof ImmutableSet) {
+            return (Set<E>) collection;
+        }
+        return set(collection.toArray(), false);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V> Map<K, V> mapCopyOf(Map<? extends K, ? extends V> map) {
+        if (map instanceof ImmutableMap) {
+            return (Map<K, V>) map;
+        }
+        Object[] flat = new Object[map.size() * 2];
+        int at = 0;
+        for (Map.Entry<? extends K, ? extends V> e : map.entrySet()) {
+            flat[at++] = e.getKey();
+            flat[at++] = e.getValue();
+        }
+        return map(flat);
+    }
+
+    static <K, V> Map<K, V> mapOfEntries(Map.Entry<? extends K, ? extends V>[] entries) {
+        Object[] flat = new Object[entries.length * 2];
+        for (int i = 0; i < entries.length; i++) {
+            flat[i * 2] = entries[i].getKey();
+            flat[i * 2 + 1] = entries[i].getValue();
+        }
+        return map(flat);
+    }
+
+    private static UnsupportedOperationException immutable() {
+        return new UnsupportedOperationException();
+    }
+
+    static final class ImmutableEntry<K, V> implements Map.Entry<K, V> {
+
+        private final K key;
+        private final V value;
+
+        ImmutableEntry(K key, V value) {
+            this.key = Objects.requireNonNull(key);
+            this.value = Objects.requireNonNull(value);
+        }
+
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValue() {
+            return value;
+        }
+
+        @Override
+        public V setValue(V newValue) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+            return key.equals(other.getKey()) && value.equals(other.getValue());
+        }
+
+        @Override
+        public int hashCode() {
+            return key.hashCode() ^ value.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return key + "=" + value;
+        }
+    }
+
+    static final class ImmutableList<E> extends AbstractList<E> implements RandomAccess {
+
+        private final Object[] elements;
+
+        ImmutableList(Object[] elements) {
+            this.elements = elements;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public E get(int index) {
+            if (index < 0 || index >= elements.length) {
+                throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length "
+                        + elements.length);
+            }
+            return (E) elements[index];
+        }
+
+        @Override
+        public int size() {
+            return elements.length;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return indexOf(o) >= 0;
+        }
+
+        @Override
+        public int indexOf(Object o) {
+            Objects.requireNonNull(o);
+            for (int i = 0; i < elements.length; i++) {
+                if (o.equals(elements[i])) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        @Override
+        public int lastIndexOf(Object o) {
+            Objects.requireNonNull(o);
+            for (int i = elements.length - 1; i >= 0; i--) {
+                if (o.equals(elements[i])) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        @Override
+        public boolean add(E e) {
+            throw immutable();
+        }
+
+        @Override
+        public void add(int index, E e) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean addAll(int index, Collection<? extends E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public void clear() {
+            throw immutable();
+        }
+
+        @Override
+        public E remove(int index) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeIf(Predicate<? super E> filter) {
+            throw immutable();
+        }
+
+        @Override
+        public void replaceAll(UnaryOperator<E> operator) {
+            throw immutable();
+        }
+
+        @Override
+        public void sort(Comparator<? super E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public E set(int index, E e) {
+            throw immutable();
+        }
+    }
+
+    static final class ImmutableSet<E> extends AbstractSet<E> {
+
+        private final Set<E> elements;
+
+        ImmutableSet(Set<E> elements) {
+            this.elements = elements;
+        }
+
+        @Override
+        public Iterator<E> iterator() {
+            Iterator<E> it = elements.iterator();
+            return new Iterator<E>() {
+                @Override
+                public boolean hasNext() {
+                    return it.hasNext();
+                }
+
+                @Override
+                public E next() {
+                    return it.next();
+                }
+
+                @Override
+                public void remove() {
+                    throw immutable();
+                }
+            };
+        }
+
+        @Override
+        public int size() {
+            return elements.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return elements.contains(Objects.requireNonNull(o));
+        }
+
+        @Override
+        public boolean add(E e) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends E> c) {
+            throw immutable();
+        }
+
+        @Override
+        public void clear() {
+            throw immutable();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean removeIf(Predicate<? super E> filter) {
+            throw immutable();
+        }
+    }
+
+    static final class ImmutableMap<K, V> extends AbstractMap<K, V> {
+
+        private final Map<K, V> entries;
+        private final Set<Map.Entry<K, V>> entrySet;
+
+        ImmutableMap(HashMap<K, V> entries) {
+            this.entries = entries;
+            HashSet<Map.Entry<K, V>> all = new HashSet<Map.Entry<K, V>>();
+            for (Map.Entry<K, V> e : entries.entrySet()) {
+                all.add(new ImmutableEntry<K, V>(e.getKey(), e.getValue()));
+            }
+            this.entrySet = new ImmutableSet<Map.Entry<K, V>>(all);
+        }
+
+        @Override
+        public Set<Map.Entry<K, V>> entrySet() {
+            return entrySet;
+        }
+
+        @Override
+        public int size() {
+            return entries.size();
+        }
+
+        @Override
+        public V get(Object key) {
+            return entries.get(Objects.requireNonNull(key));
+        }
+
+        @Override
+        public boolean containsKey(Object key) {
+            return entries.containsKey(Objects.requireNonNull(key));
+        }
+
+        @Override
+        public boolean containsValue(Object value) {
+            return entries.containsValue(Objects.requireNonNull(value));
+        }
+
+        @Override
+        public V put(K key, V value) {
+            throw immutable();
+        }
+
+        @Override
+        public void putAll(Map<? extends K, ? extends V> map) {
+            throw immutable();
+        }
+
+        @Override
+        public V remove(Object key) {
+            throw immutable();
+        }
+
+        @Override
+        public void clear() {
+            throw immutable();
+        }
+
+        @Override
+        public V putIfAbsent(K key, V value) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean remove(Object key, Object value) {
+            throw immutable();
+        }
+
+        @Override
+        public boolean replace(K key, V oldValue, V newValue) {
+            throw immutable();
+        }
+
+        @Override
+        public V replace(K key, V value) {
+            throw immutable();
+        }
+
+        @Override
+        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+            throw immutable();
+        }
+
+        @Override
+        public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+            throw immutable();
+        }
+
+        @Override
+        public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+            throw immutable();
+        }
+
+        @Override
+        public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+            throw immutable();
+        }
+
+        @Override
+        public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+            throw immutable();
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/IntSummaryStatistics.java b/vm/JavaAPI/src/java/util/IntSummaryStatistics.java
new file mode 100644
index 00000000000..377d6f95d71
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/IntSummaryStatistics.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.IntConsumer;
+
+/// The count,
+/// sum, minimum, maximum and average of the values it was given.
+public class IntSummaryStatistics implements IntConsumer {
+
+    private long count;
+    private long sum;
+    private int min = Integer.MAX_VALUE;
+    private int max = Integer.MIN_VALUE;
+
+    public IntSummaryStatistics() {
+        // Nothing seen yet.
+    }
+
+    @Override
+    public void accept(int value) {
+        count++;
+        sum += value;
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+
+    public void combine(IntSummaryStatistics other) {
+        count += other.count;
+        sum += other.sum;
+        min = Math.min(min, other.min);
+        max = Math.max(max, other.max);
+    }
+
+    public final long getCount() {
+        return count;
+    }
+
+    public final long getSum() {
+        return sum;
+    }
+
+    public final int getMin() {
+        return min;
+    }
+
+    public final int getMax() {
+        return max;
+    }
+
+    public final double getAverage() {
+        return count > 0 ? (double) getSum() / count : 0.0d;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Iterator.java b/vm/JavaAPI/src/java/util/Iterator.java
index 6ebae043652..d7d2ed0f596 100644
--- a/vm/JavaAPI/src/java/util/Iterator.java
+++ b/vm/JavaAPI/src/java/util/Iterator.java
@@ -17,6 +17,8 @@
 
 package java.util;
 
+import java.util.function.Consumer;
+
 /**
  * An {@code Iterator} is used to sequence over a collection of objects.
  * Conceptually, an iterator is always positioned between two elements of a
@@ -51,16 +53,26 @@ public interface Iterator<E> {
      */
     public E next();
 
-    /**
-     * Removes the last object returned by {@code next} from the collection.
-     * This method can only be called once after {@code next} was called.
-     * 
-     * @throws UnsupportedOperationException
-     *             if removing is not supported by the collection being
-     *             iterated.
-     * @throws IllegalStateException
-     *             if {@code next} has not been called, or {@code remove} has
-     *             already been called after the last call to {@code next}.
-     */
-    public void remove();
+    /// Removes the last element `next` answered from the collection being
+    /// iterated, which this iterator does not support unless it says otherwise.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedOperationException`: when removing is not supported
+    ///
+    /// - `IllegalStateException`: when `next` has not been called, or `remove`
+    ///   has already been called after the last call to `next`
+    default void remove() {
+        throw new UnsupportedOperationException("remove");
+    }
+
+    /// Hands each remaining element to `action`, in order.
+    default void forEachRemaining(Consumer<? super E> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        while (hasNext()) {
+            action.accept(next());
+        }
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/List.java b/vm/JavaAPI/src/java/util/List.java
index 045fd929883..c22cd2415ce 100644
--- a/vm/JavaAPI/src/java/util/List.java
+++ b/vm/JavaAPI/src/java/util/List.java
@@ -380,4 +380,122 @@ default void sort(Comparator<? super E> c) {
             it.set((E) e);
         }
     }
+
+    /// Inserts `e` before the first element.
+    default void addFirst(E e) {
+        add(0, e);
+    }
+
+    /// Appends `e` after the last element.
+    default void addLast(E e) {
+        add(e);
+    }
+
+    /// The first element; NoSuchElementException when there is none.
+    default E getFirst() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return get(0);
+    }
+
+    /// The last element; NoSuchElementException when there is none.
+    default E getLast() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return get(size() - 1);
+    }
+
+    /// Removes and answers the first element; NoSuchElementException when
+    /// there is none.
+    default E removeFirst() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return remove(0);
+    }
+
+    /// Removes and answers the last element; NoSuchElementException when
+    /// there is none.
+    default E removeLast() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        return remove(size() - 1);
+    }
+
+    /// A view of this list in the opposite order. It reads and writes
+    /// through to this list, and its own `reversed()` is this list.
+    default List<E> reversed() {
+        return new ReversedList<E>(this);
+    }
+
+    /// An unmodifiable list of no elements.
+    static <E> List<E> of() {
+        return ImmutableCollections.list(new Object[] {});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1) {
+        return ImmutableCollections.list(new Object[] {e1});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2) {
+        return ImmutableCollections.list(new Object[] {e1, e2});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9});
+    }
+
+    /// An unmodifiable list of the given elements, none of which may be null.
+    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
+        return ImmutableCollections.list(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9, e10});
+    }
+
+    /// An unmodifiable list of `elements`, none of which may be null.
+    @SafeVarargs
+    static <E> List<E> of(E... elements) {
+        return ImmutableCollections.listCopy(elements);
+    }
+
+    /// An unmodifiable list of the elements of `collection`, which may not hold
+    /// null; `collection` itself when it is already such a list.
+    static <E> List<E> copyOf(Collection<? extends E> collection) {
+        return ImmutableCollections.listCopyOf(collection);
+    }
+
 }
diff --git a/vm/JavaAPI/src/java/util/ListResourceBundle.java b/vm/JavaAPI/src/java/util/ListResourceBundle.java
new file mode 100644
index 00000000000..909ba5dbaa0
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/ListResourceBundle.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+
+/// A resource bundle whose content a subclass supplies as an array of key
+/// and value pairs.
+public abstract class ListResourceBundle extends ResourceBundle {
+
+    private Map<String, Object> lookup;
+
+    public ListResourceBundle() {
+        super();
+    }
+
+    /// The bundle's content: each element is a pair, the key (a `String`)
+    /// and its value.
+    protected abstract Object[][] getContents();
+
+    private Map<String, Object> lookup() {
+        if (lookup == null) {
+            Map<String, Object> built = new HashMap<String, Object>();
+            Object[][] contents = getContents();
+            for (int i = 0; i < contents.length; i++) {
+                Object key = contents[i][0];
+                Object value = contents[i][1];
+                if (!(key instanceof String) || value == null) {
+                    throw new NullPointerException();
+                }
+                built.put((String) key, value);
+            }
+            lookup = built;
+        }
+        return lookup;
+    }
+
+    public final Object handleGetObject(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        return lookup().get(key);
+    }
+
+    public Enumeration<String> getKeys() {
+        return new ResourceBundle.KeyEnumeration(keySet().iterator());
+    }
+
+    protected Set<String> handleKeySet() {
+        return lookup().keySet();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Locale.java b/vm/JavaAPI/src/java/util/Locale.java
index 4e31be249a3..e14697218e7 100644
--- a/vm/JavaAPI/src/java/util/Locale.java
+++ b/vm/JavaAPI/src/java/util/Locale.java
@@ -23,15 +23,91 @@
 
 package java.util;
 
+/// A language, a country and a variant, with the JDK's value semantics:
+/// two locales of the same codes are equal, hash alike and print alike
+/// (`en_US`). The codes are normalized as the JDK normalizes them -- the
+/// language to lower case, the country to upper case, with an ASCII fold, so
+/// a device set to Turkish cannot turn `IT` into a dotless `it`.
+///
+/// This runtime carries no locale data beyond the English names of the
+/// common languages and countries, so the `getDisplay*` methods answer in
+/// English whatever locale they are asked for, and fall back to the code.
+/// A script and extensions are not kept: `getScript` is always empty.
 public class Locale {
+    /// English.
+    public static final Locale ENGLISH = new Locale("en", "");
+    /// French.
+    public static final Locale FRENCH = new Locale("fr", "");
+    /// German.
+    public static final Locale GERMAN = new Locale("de", "");
+    /// Italian.
+    public static final Locale ITALIAN = new Locale("it", "");
+    /// Japanese.
+    public static final Locale JAPANESE = new Locale("ja", "");
+    /// Korean.
+    public static final Locale KOREAN = new Locale("ko", "");
+    /// Chinese.
+    public static final Locale CHINESE = new Locale("zh", "");
+    /// Chinese as written in China.
+    public static final Locale SIMPLIFIED_CHINESE = new Locale("zh", "CN");
+    /// Chinese as written in Taiwan.
+    public static final Locale TRADITIONAL_CHINESE = new Locale("zh", "TW");
+    /// French in France.
+    public static final Locale FRANCE = new Locale("fr", "FR");
+    /// German in Germany.
+    public static final Locale GERMANY = new Locale("de", "DE");
+    /// Italian in Italy.
+    public static final Locale ITALY = new Locale("it", "IT");
+    /// Japanese in Japan.
+    public static final Locale JAPAN = new Locale("ja", "JP");
+    /// Korean in Korea.
+    public static final Locale KOREA = new Locale("ko", "KR");
+    /// Chinese in China; the same locale as `SIMPLIFIED_CHINESE`.
+    public static final Locale CHINA = SIMPLIFIED_CHINESE;
+    /// Chinese in China; the same locale as `SIMPLIFIED_CHINESE`.
+    public static final Locale PRC = SIMPLIFIED_CHINESE;
+    /// Chinese in Taiwan; the same locale as `TRADITIONAL_CHINESE`.
+    public static final Locale TAIWAN = TRADITIONAL_CHINESE;
+    /// English in the United Kingdom.
+    public static final Locale UK = new Locale("en", "GB");
+    /// English in the United States.
+    public static final Locale US = new Locale("en", "US");
+    /// English in Canada.
+    public static final Locale CANADA = new Locale("en", "CA");
+    /// French in Canada.
+    public static final Locale CANADA_FRENCH = new Locale("fr", "CA");
+    /// The root locale: no language, country or variant.
+    public static final Locale ROOT = new Locale("", "");
+
     private static Locale defaultLocale;
     private String language;
     private String country;
-    public Locale(String language, String locale) {
-        this.language = language;
-        this.country = locale;
+    private String variant;
+
+    /// A locale of a language alone.
+    public Locale(String language) {
+        this(language, "", "");
+    }
+
+    /// A locale of a language and a country.
+    public Locale(String language, String country) {
+        this(language, country, "");
+    }
+
+    /// A locale of a language, a country and a variant.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: if any of them is null
+    public Locale(String language, String country, String variant) {
+        if (language == null || country == null || variant == null) {
+            throw new NullPointerException();
+        }
+        this.language = normalizeLanguage(language);
+        this.country = asciiUpper(country);
+        this.variant = variant;
     }
-    
+
     Locale() {
         language = getOSLanguage();
         int pos;
@@ -46,27 +122,422 @@ public Locale(String language, String locale) {
         if (country == null) {
             country = "US";//getOSCountry();
         }
+        language = language == null ? "" : normalizeLanguage(language);
+        country = asciiUpper(country);
+        variant = "";
+    }
+
+    /// `new Locale(language)`.
+    public static Locale of(String language) {
+        return new Locale(language);
+    }
+
+    /// `new Locale(language, country)`.
+    public static Locale of(String language, String country) {
+        return new Locale(language, country);
+    }
+
+    /// `new Locale(language, country, variant)`.
+    public static Locale of(String language, String country, String variant) {
+        return new Locale(language, country, variant);
     }
-    
+
     public static Locale getDefault() {
         if(defaultLocale == null) {
             defaultLocale = new Locale();
         }
         return defaultLocale;
     }
-    
+
     public static void setDefault(Locale l) {
+        if (l == null) {
+            throw new NullPointerException("Can't set default locale to NULL");
+        }
         defaultLocale = l;
     }
-    
+
     public String getLanguage() {
         return language;
     }
-        
+
     public String getCountry() {
         return country;
     }
 
+    /// The variant, or the empty string.
+    public String getVariant() {
+        return variant;
+    }
+
+    /// Always empty: this runtime does not keep a script.
+    public String getScript() {
+        return "";
+    }
+
+    /// Whether the locale carries extensions; never, here.
+    public boolean hasExtensions() {
+        return false;
+    }
+
+    /// The locale without extensions, which is the locale itself here.
+    public Locale stripExtensions() {
+        return this;
+    }
+
+    /// The locale an IETF BCP 47 language tag names: `fr`, `en-US`,
+    /// `zh-Hans-CN`. The first subtag is the language, a four letter subtag
+    /// after it a script (dropped), the next two letter or three digit subtag
+    /// the country and the subtags after it, five to eight characters or a
+    /// digit and three more, the variant. A single character subtag starts
+    /// the extensions, which are dropped. `und` and the empty tag are the
+    /// root locale.
+    public static Locale forLanguageTag(String languageTag) {
+        if (languageTag == null) {
+            throw new NullPointerException();
+        }
+        String language = "";
+        String country = "";
+        StringBuilder variant = null;
+        int n = languageTag.length();
+        int start = 0;
+        int index = 0;
+        for (int i = 0; i <= n; i++) {
+            if (i < n && languageTag.charAt(i) != '-' && languageTag.charAt(i) != '_') {
+                continue;
+            }
+            String part = languageTag.substring(start, i);
+            start = i + 1;
+            if (index == 0) {
+                if (!isLetters(part) || part.length() < 2 || part.length() > 8) {
+                    break;
+                }
+                language = "und".equals(asciiLower(part)) ? "" : part;
+            } else if (part.length() == 1 || part.length() == 0) {
+                // "x-lvariant-" carries a variant that is not well formed BCP 47,
+                // which is how toLanguageTag writes one; the JDK reads it back.
+                String rest = i < n ? languageTag.substring(i + 1) : "";
+                if (part.length() == 1 && (part.charAt(0) == 'x' || part.charAt(0) == 'X')
+                        && rest.length() > 9 && rest.regionMatches(true, 0, "lvariant", 0, 8)
+                        && (rest.charAt(8) == '-' || rest.charAt(8) == '_')) {
+                    String lvariant = rest.substring(9).replace('-', '_');
+                    if (variant == null) {
+                        variant = new StringBuilder(lvariant);
+                    } else {
+                        variant.append('_').append(lvariant);
+                    }
+                }
+                break;
+            } else if (index == 1 && part.length() == 4 && isLetters(part)) {
+                // a script
+                index++;
+                continue;
+            } else if (country.length() == 0 && variant == null
+                    && ((part.length() == 2 && isLetters(part)) || (part.length() == 3 && isDigits(part)))) {
+                country = part;
+            } else if (part.length() >= 5 && part.length() <= 8 && isAlphanumeric(part)
+                    || part.length() == 4 && part.charAt(0) >= '0' && part.charAt(0) <= '9' && isAlphanumeric(part)) {
+                if (variant == null) {
+                    variant = new StringBuilder(part);
+                } else {
+                    variant.append('_').append(part);
+                }
+            } else {
+                break;
+            }
+            index++;
+        }
+        return new Locale(language, country, variant == null ? "" : variant.toString());
+    }
+
+    /// The IETF BCP 47 tag of the locale: `en-US`, `fr`, or `und` for the
+    /// root.
+    public String toLanguageTag() {
+        StringBuilder out = new StringBuilder();
+        out.append(language.length() == 0 ? "und" : language);
+        if (country.length() > 0) {
+            out.append('-').append(country);
+        }
+        if (variant.length() > 0) {
+            String tagged = variant.replace('_', '-');
+            if (isWellFormedVariant(tagged)) {
+                out.append('-').append(tagged);
+            } else {
+                out.append("-x-lvariant-").append(tagged);
+            }
+        }
+        return out.toString();
+    }
+
+    private static boolean isWellFormedVariant(String tagged) {
+        int start = 0;
+        int n = tagged.length();
+        for (int i = 0; i <= n; i++) {
+            if (i < n && tagged.charAt(i) != '-') {
+                continue;
+            }
+            String part = tagged.substring(start, i);
+            start = i + 1;
+            boolean ok = part.length() >= 5 && part.length() <= 8 && isAlphanumeric(part)
+                    || part.length() == 4 && part.charAt(0) >= '0' && part.charAt(0) <= '9' && isAlphanumeric(part);
+            if (!ok) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Whether `obj` is a locale of the same language, country and variant.
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof Locale)) {
+            return false;
+        }
+        Locale other = (Locale) obj;
+        return language.equals(other.language) && country.equals(other.country) && variant.equals(other.variant);
+    }
+
+    /// A hash of the language, country and variant.
+    public int hashCode() {
+        return (language.hashCode() * 31 + country.hashCode()) * 31 + variant.hashCode();
+    }
+
+    /// `en_US`, `fr`, `en_US_POSIX`, or the empty string for the root locale.
+    public String toString() {
+        boolean l = language.length() > 0;
+        boolean c = country.length() > 0;
+        boolean v = variant.length() > 0;
+        if (!c && !(l && v)) {
+            return language;
+        }
+        StringBuilder out = new StringBuilder(language);
+        out.append('_');
+        if (c) {
+            out.append(country);
+        }
+        if (v && (l || c)) {
+            out.append('_').append(variant);
+        }
+        return out.toString();
+    }
+
+    /// The English name of the language, or its code when this runtime has
+    /// no name for it.
+    public String getDisplayLanguage() {
+        return displayLanguage(language);
+    }
+
+    /// As `getDisplayLanguage()`: names are in English only.
+    public String getDisplayLanguage(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayLanguage();
+    }
+
+    /// The English name of the country, or its code when this runtime has no
+    /// name for it.
+    public String getDisplayCountry() {
+        return displayCountry(country);
+    }
+
+    /// As `getDisplayCountry()`: names are in English only.
+    public String getDisplayCountry(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayCountry();
+    }
+
+    /// The variant as it is.
+    public String getDisplayVariant() {
+        return variant;
+    }
+
+    /// As `getDisplayVariant()`.
+    public String getDisplayVariant(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayVariant();
+    }
+
+    /// Always empty: this runtime does not keep a script.
+    public String getDisplayScript() {
+        return "";
+    }
+
+    /// Always empty: this runtime does not keep a script.
+    public String getDisplayScript(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return "";
+    }
+
+    /// `English (United States)`: the language, then the country and the
+    /// variant in parentheses.
+    public String getDisplayName() {
+        String lang = getDisplayLanguage();
+        StringBuilder qualifiers = new StringBuilder();
+        if (country.length() > 0) {
+            qualifiers.append(getDisplayCountry());
+        }
+        if (variant.length() > 0) {
+            if (qualifiers.length() > 0) {
+                qualifiers.append(", ");
+            }
+            qualifiers.append(variant);
+        }
+        if (lang.length() == 0) {
+            return qualifiers.toString();
+        }
+        if (qualifiers.length() == 0) {
+            return lang;
+        }
+        return lang + " (" + qualifiers + ")";
+    }
+
+    /// As `getDisplayName()`: names are in English only.
+    public String getDisplayName(Locale inLocale) {
+        if (inLocale == null) {
+            throw new NullPointerException();
+        }
+        return getDisplayName();
+    }
+
+    /// The default locale and the locales this class has constants for.
+    public static Locale[] getAvailableLocales() {
+        return new Locale[] {
+            getDefault(), ENGLISH, FRENCH, GERMAN, ITALIAN, JAPANESE, KOREAN, CHINESE,
+            SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE, FRANCE, GERMANY, ITALY, JAPAN, KOREA, UK, US, CANADA,
+            CANADA_FRENCH
+        };
+    }
+
+    /// The English names, in a holder so that the tables are built the
+    /// first time a display name is asked for, not by every use of a
+    /// `Locale`.
+    private static final class Names {
+        private Names() {
+        }
+
+        private static final String[] LANGUAGE_NAMES = {
+            "ar", "Arabic", "bg", "Bulgarian", "ca", "Catalan", "cs", "Czech", "da", "Danish",
+            "de", "German", "el", "Greek", "en", "English", "es", "Spanish", "et", "Estonian",
+            "fa", "Persian", "fi", "Finnish", "fr", "French", "he", "Hebrew", "hi", "Hindi",
+            "hr", "Croatian", "hu", "Hungarian", "id", "Indonesian", "is", "Icelandic", "it", "Italian",
+            "ja", "Japanese", "ko", "Korean", "lt", "Lithuanian", "lv", "Latvian", "ms", "Malay",
+            "nl", "Dutch", "no", "Norwegian", "pl", "Polish", "pt", "Portuguese", "ro", "Romanian",
+            "ru", "Russian", "sk", "Slovak", "sl", "Slovenian", "sr", "Serbian", "sv", "Swedish",
+            "th", "Thai", "tr", "Turkish", "uk", "Ukrainian", "vi", "Vietnamese", "zh", "Chinese"
+        };
+
+        private static final String[] COUNTRY_NAMES = {
+            "AR", "Argentina", "AT", "Austria", "AU", "Australia", "BE", "Belgium", "BR", "Brazil",
+            "CA", "Canada", "CH", "Switzerland", "CN", "China", "CZ", "Czechia", "DE", "Germany",
+            "DK", "Denmark", "ES", "Spain", "FI", "Finland", "FR", "France", "GB", "United Kingdom",
+            "GR", "Greece", "HK", "Hong Kong SAR China", "IE", "Ireland", "IL", "Israel", "IN", "India",
+            "IT", "Italy", "JP", "Japan", "KR", "South Korea", "MX", "Mexico", "NL", "Netherlands",
+            "NO", "Norway", "NZ", "New Zealand", "PL", "Poland", "PT", "Portugal", "RU", "Russia",
+            "SE", "Sweden", "TR", "Turkey", "TW", "Taiwan", "UA", "Ukraine", "US", "United States",
+            "ZA", "South Africa"
+        };
+    }
+
+    private static String displayLanguage(String code) {
+        return lookup(Names.LANGUAGE_NAMES, code);
+    }
+
+    private static String displayCountry(String code) {
+        return lookup(Names.COUNTRY_NAMES, code);
+    }
+
+    private static String lookup(String[] table, String code) {
+        for (int i = 0; i < table.length; i += 2) {
+            if (table[i].equals(code)) {
+                return table[i + 1];
+            }
+        }
+        return code;
+    }
+
+    private static String normalizeLanguage(String language) {
+        String lower = asciiLower(language);
+        // The JDK answers the current ISO 639 code for the three it renamed.
+        if ("iw".equals(lower)) {
+            return "he";
+        }
+        if ("ji".equals(lower)) {
+            return "yi";
+        }
+        if ("in".equals(lower)) {
+            return "id";
+        }
+        return lower;
+    }
+
+    private static boolean isLetters(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
+                return false;
+            }
+        }
+        return s.length() > 0;
+    }
+
+    private static boolean isDigits(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c < '0' || c > '9') {
+                return false;
+            }
+        }
+        return s.length() > 0;
+    }
+
+    private static boolean isAlphanumeric(String s) {
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))) {
+                return false;
+            }
+        }
+        return s.length() > 0;
+    }
+
+    // Language and country codes are ASCII, and String.toLowerCase folds by
+    // the device's locale: under Turkish "IT" would not become "it".
+    private static String asciiLower(String s) {
+        StringBuilder out = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'A' && c <= 'Z') {
+                if (out == null) {
+                    out = new StringBuilder(s);
+                }
+                out.setCharAt(i, (char) (c + ('a' - 'A')));
+            }
+        }
+        return out == null ? s : out.toString();
+    }
+
+    private static String asciiUpper(String s) {
+        StringBuilder out = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c >= 'a' && c <= 'z') {
+                if (out == null) {
+                    out = new StringBuilder(s);
+                }
+                out.setCharAt(i, (char) (c - ('a' - 'A')));
+            }
+        }
+        return out == null ? s : out.toString();
+    }
+
     private static native String getOSLanguage();
     //private static native String getOSCountry();
 }
diff --git a/vm/JavaAPI/src/java/util/LongSummaryStatistics.java b/vm/JavaAPI/src/java/util/LongSummaryStatistics.java
new file mode 100644
index 00000000000..ff3db599dc2
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/LongSummaryStatistics.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.LongConsumer;
+
+/// The count,
+/// sum, minimum, maximum and average of the values it was given.
+public class LongSummaryStatistics implements LongConsumer {
+
+    private long count;
+    private long sum;
+    private long min = Long.MAX_VALUE;
+    private long max = Long.MIN_VALUE;
+
+    public LongSummaryStatistics() {
+        // Nothing seen yet.
+    }
+
+    @Override
+    public void accept(long value) {
+        count++;
+        sum += value;
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+
+    public void accept(int value) {
+        accept((long) value);
+    }
+
+    public void combine(LongSummaryStatistics other) {
+        count += other.count;
+        sum += other.sum;
+        min = Math.min(min, other.min);
+        max = Math.max(max, other.max);
+    }
+
+    public final long getCount() {
+        return count;
+    }
+
+    public final long getSum() {
+        return sum;
+    }
+
+    public final long getMin() {
+        return min;
+    }
+
+    public final long getMax() {
+        return max;
+    }
+
+    public final double getAverage() {
+        return count > 0 ? (double) getSum() / count : 0.0d;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Map.java b/vm/JavaAPI/src/java/util/Map.java
index a1452ebc85c..d6b004bf9bf 100644
--- a/vm/JavaAPI/src/java/util/Map.java
+++ b/vm/JavaAPI/src/java/util/Map.java
@@ -83,7 +83,53 @@ public static interface Entry<K,V> {
          * @return object the replaced value of this entry.
          */
         public V setValue(V object);
-    };
+
+        /// Orders entries by the natural order of their keys.
+        static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K, V>> comparingByKey() {
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return a.getKey().compareTo(b.getKey());
+                }
+            };
+        }
+
+        /// Orders entries by the natural order of their values.
+        static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K, V>> comparingByValue() {
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return a.getValue().compareTo(b.getValue());
+                }
+            };
+        }
+
+        /// Orders entries by their keys, as `comparator` orders them.
+        static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(final Comparator<? super K> comparator) {
+            if (comparator == null) {
+                throw new NullPointerException();
+            }
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return comparator.compare(a.getKey(), b.getKey());
+                }
+            };
+        }
+
+        /// Orders entries by their values, as `comparator` orders them.
+        static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(final Comparator<? super V> comparator) {
+            if (comparator == null) {
+                throw new NullPointerException();
+            }
+            return new Comparator<Map.Entry<K, V>>() {
+                @Override
+                public int compare(Map.Entry<K, V> a, Map.Entry<K, V> b) {
+                    return comparator.compare(a.getValue(), b.getValue());
+                }
+            };
+        }
+    }
 
     /**
      * Removes all elements from this {@code Map}, leaving it empty.
@@ -432,4 +478,88 @@ default V merge(K key, V value,
         }
         return newValue;
     }
+
+    /// An unmodifiable map of no mappings.
+    static <K, V> Map<K, V> of() {
+        return ImmutableCollections.map(new Object[0]);
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1) {
+        return ImmutableCollections.map(new Object[] {k1, v1});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9});
+    }
+
+    /// An unmodifiable map of the given keys and values, none of which may be
+    /// null, and no key given twice.
+    static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
+        return ImmutableCollections.map(new Object[] {k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9, k10, v10});
+    }
+
+    /// An unmodifiable map of the keys and values of `entries`, none of which
+    /// may be null, and no key given twice.
+    @SafeVarargs
+    static <K, V> Map<K, V> ofEntries(Map.Entry<? extends K, ? extends V>... entries) {
+        return ImmutableCollections.mapOfEntries(entries);
+    }
+
+    /// An unmodifiable entry of `key` and `value`, neither of which may be null.
+    static <K, V> Map.Entry<K, V> entry(K key, V value) {
+        return new ImmutableCollections.ImmutableEntry<K, V>(key, value);
+    }
+
+    /// An unmodifiable map of the mappings of `map`, which may not hold null;
+    /// `map` itself when it is already such a map.
+    static <K, V> Map<K, V> copyOf(Map<? extends K, ? extends V> map) {
+        return ImmutableCollections.mapCopyOf(map);
+    }
+
 }
diff --git a/vm/JavaAPI/src/java/util/MissingResourceException.java b/vm/JavaAPI/src/java/util/MissingResourceException.java
new file mode 100644
index 00000000000..3ee1805c22c
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/MissingResourceException.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// A resource bundle, or a key in one, could not be found.
+public class MissingResourceException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String className;
+    private final String key;
+
+    public MissingResourceException(String s, String className, String key) {
+        super(s);
+        this.className = className;
+        this.key = key;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    public String getKey() {
+        return key;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Objects.java b/vm/JavaAPI/src/java/util/Objects.java
index 908e9901641..72e830db28e 100644
--- a/vm/JavaAPI/src/java/util/Objects.java
+++ b/vm/JavaAPI/src/java/util/Objects.java
@@ -102,4 +102,113 @@ public static int hash(Object... values) {
         }
         return hashCode;
     }
+
+    // ---------------------------------------------------------------------
+    // Members of the JDK's class this one did not have, in plain Java.
+    // ---------------------------------------------------------------------
+
+    /// `obj`, or a NullPointerException whose message `messageSupplier`
+    /// makes, only when it is needed.
+    public static <T> T requireNonNull(T obj, java.util.function.Supplier<String> messageSupplier) {
+        if (obj == null) {
+            throw new NullPointerException(messageSupplier == null ? null : messageSupplier.get());
+        }
+        return obj;
+    }
+
+    /// `obj`, or `defaultObj` when `obj` is null.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: if both are null
+    public static <T> T requireNonNullElse(T obj, T defaultObj) {
+        if (obj != null) {
+            return obj;
+        }
+        if (defaultObj == null) {
+            throw new NullPointerException("defaultObj");
+        }
+        return defaultObj;
+    }
+
+    /// `obj`, or what `supplier` gives when `obj` is null.
+    ///
+    /// #### Throws
+    ///
+    /// - `NullPointerException`: if `obj` is null and the supplier is null or gives null
+    public static <T> T requireNonNullElseGet(T obj, java.util.function.Supplier<? extends T> supplier) {
+        if (obj != null) {
+            return obj;
+        }
+        if (supplier == null) {
+            throw new NullPointerException("supplier");
+        }
+        T value = supplier.get();
+        if (value == null) {
+            throw new NullPointerException("supplier.get()");
+        }
+        return value;
+    }
+
+    /// `index`, if it lies in `[0, length)`.
+    ///
+    /// #### Throws
+    ///
+    /// - `IndexOutOfBoundsException`: otherwise
+    public static int checkIndex(int index, int length) {
+        if (index < 0 || index >= length) {
+            throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length " + length);
+        }
+        return index;
+    }
+
+    /// `index`, if it lies in `[0, length)`.
+    public static long checkIndex(long index, long length) {
+        if (index < 0 || index >= length) {
+            throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length " + length);
+        }
+        return index;
+    }
+
+    /// `fromIndex`, if `[fromIndex, toIndex)` lies in `[0, length)`.
+    public static int checkFromToIndex(int fromIndex, int toIndex, int length) {
+        if (fromIndex < 0 || fromIndex > toIndex || toIndex > length) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + toIndex
+                    + ") out of bounds for length " + length);
+        }
+        return fromIndex;
+    }
+
+    /// `fromIndex`, if `[fromIndex, toIndex)` lies in `[0, length)`.
+    public static long checkFromToIndex(long fromIndex, long toIndex, long length) {
+        if (fromIndex < 0 || fromIndex > toIndex || toIndex > length) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + toIndex
+                    + ") out of bounds for length " + length);
+        }
+        return fromIndex;
+    }
+
+    /// `fromIndex`, if `[fromIndex, fromIndex + size)` lies in `[0, length)`.
+    public static int checkFromIndexSize(int fromIndex, int size, int length) {
+        if ((length | fromIndex | size) < 0 || size > length - fromIndex) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + fromIndex + " + " + size
+                    + ") out of bounds for length " + length);
+        }
+        return fromIndex;
+    }
+
+    /// `fromIndex`, if `[fromIndex, fromIndex + size)` lies in `[0, length)`.
+    public static long checkFromIndexSize(long fromIndex, long size, long length) {
+        if ((length | fromIndex | size) < 0 || size > length - fromIndex) {
+            throw new IndexOutOfBoundsException("Range [" + fromIndex + ", " + fromIndex + " + " + size
+                    + ") out of bounds for length " + length);
+        }
+        return fromIndex;
+    }
+
+    /// What `Object.toString` would answer for `o`, even when its class
+    /// overrides it.
+    public static String toIdentityString(Object o) {
+        return o.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(o));
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/Optional.java b/vm/JavaAPI/src/java/util/Optional.java
index 1db7dabe515..eb74cb16b3a 100644
--- a/vm/JavaAPI/src/java/util/Optional.java
+++ b/vm/JavaAPI/src/java/util/Optional.java
@@ -130,6 +130,11 @@ public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
         return r;
     }
 
+    /// A stream of the value, or an empty stream when there is none.
+    public java.util.stream.Stream<T> stream() {
+        return value == null ? java.util.stream.Stream.<T>empty() : java.util.stream.Stream.of(value);
+    }
+
     public T orElse(T other) {
         return value != null ? value : other;
     }
diff --git a/vm/JavaAPI/src/java/util/OptionalDouble.java b/vm/JavaAPI/src/java/util/OptionalDouble.java
new file mode 100644
index 00000000000..d69bfce021c
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/OptionalDouble.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.DoubleConsumer;
+import java.util.stream.DoubleStream;
+import java.util.function.DoubleSupplier;
+
+import java.util.function.Supplier;
+
+/// A container that
+/// holds one `double` or nothing.
+public final class OptionalDouble {
+
+    private static final OptionalDouble EMPTY = new OptionalDouble(false, 0d);
+
+    private final boolean present;
+    private final double value;
+
+    private OptionalDouble(boolean present, double value) {
+        this.present = present;
+        this.value = value;
+    }
+
+    public static OptionalDouble empty() {
+        return EMPTY;
+    }
+
+    public static OptionalDouble of(double value) {
+        return new OptionalDouble(true, value);
+    }
+
+    public double getAsDouble() {
+        if (!present) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return present;
+    }
+
+    public boolean isEmpty() {
+        return !present;
+    }
+
+    public void ifPresent(DoubleConsumer action) {
+        if (present) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(DoubleConsumer action, Runnable emptyAction) {
+        if (present) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public DoubleStream stream() {
+        return present ? DoubleStream.of(value) : DoubleStream.empty();
+    }
+
+    public double orElse(double other) {
+        return present ? value : other;
+    }
+
+    public double orElseGet(DoubleSupplier supplier) {
+        return present ? value : supplier.getAsDouble();
+    }
+
+    public double orElseThrow() {
+        return getAsDouble();
+    }
+
+    public <X extends Throwable> double orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (present) {
+            return value;
+        }
+        throw exceptionSupplier.get();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OptionalDouble)) {
+            return false;
+        }
+        OptionalDouble other = (OptionalDouble) obj;
+        if (present != other.present) {
+            return false;
+        }
+        return !present || Double.compare(value, other.value) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return present ? Double.valueOf(value).hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return present ? "OptionalDouble[" + value + "]" : "OptionalDouble.empty";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/OptionalInt.java b/vm/JavaAPI/src/java/util/OptionalInt.java
new file mode 100644
index 00000000000..910427fc02f
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/OptionalInt.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.IntConsumer;
+import java.util.stream.IntStream;
+import java.util.function.IntSupplier;
+
+import java.util.function.Supplier;
+
+/// A container that
+/// holds one `int` or nothing.
+public final class OptionalInt {
+
+    private static final OptionalInt EMPTY = new OptionalInt(false, 0);
+
+    private final boolean present;
+    private final int value;
+
+    private OptionalInt(boolean present, int value) {
+        this.present = present;
+        this.value = value;
+    }
+
+    public static OptionalInt empty() {
+        return EMPTY;
+    }
+
+    public static OptionalInt of(int value) {
+        return new OptionalInt(true, value);
+    }
+
+    public int getAsInt() {
+        if (!present) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return present;
+    }
+
+    public boolean isEmpty() {
+        return !present;
+    }
+
+    public void ifPresent(IntConsumer action) {
+        if (present) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(IntConsumer action, Runnable emptyAction) {
+        if (present) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public IntStream stream() {
+        return present ? IntStream.of(value) : IntStream.empty();
+    }
+
+    public int orElse(int other) {
+        return present ? value : other;
+    }
+
+    public int orElseGet(IntSupplier supplier) {
+        return present ? value : supplier.getAsInt();
+    }
+
+    public int orElseThrow() {
+        return getAsInt();
+    }
+
+    public <X extends Throwable> int orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (present) {
+            return value;
+        }
+        throw exceptionSupplier.get();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OptionalInt)) {
+            return false;
+        }
+        OptionalInt other = (OptionalInt) obj;
+        if (present != other.present) {
+            return false;
+        }
+        return !present || Integer.compare(value, other.value) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return present ? Integer.valueOf(value).hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return present ? "OptionalInt[" + value + "]" : "OptionalInt.empty";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/OptionalLong.java b/vm/JavaAPI/src/java/util/OptionalLong.java
new file mode 100644
index 00000000000..ab313afcf5a
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/OptionalLong.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.LongConsumer;
+import java.util.stream.LongStream;
+import java.util.function.LongSupplier;
+
+import java.util.function.Supplier;
+
+/// A container that
+/// holds one `long` or nothing.
+public final class OptionalLong {
+
+    private static final OptionalLong EMPTY = new OptionalLong(false, 0L);
+
+    private final boolean present;
+    private final long value;
+
+    private OptionalLong(boolean present, long value) {
+        this.present = present;
+        this.value = value;
+    }
+
+    public static OptionalLong empty() {
+        return EMPTY;
+    }
+
+    public static OptionalLong of(long value) {
+        return new OptionalLong(true, value);
+    }
+
+    public long getAsLong() {
+        if (!present) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    public boolean isPresent() {
+        return present;
+    }
+
+    public boolean isEmpty() {
+        return !present;
+    }
+
+    public void ifPresent(LongConsumer action) {
+        if (present) {
+            action.accept(value);
+        }
+    }
+
+    public void ifPresentOrElse(LongConsumer action, Runnable emptyAction) {
+        if (present) {
+            action.accept(value);
+        } else {
+            emptyAction.run();
+        }
+    }
+
+    public LongStream stream() {
+        return present ? LongStream.of(value) : LongStream.empty();
+    }
+
+    public long orElse(long other) {
+        return present ? value : other;
+    }
+
+    public long orElseGet(LongSupplier supplier) {
+        return present ? value : supplier.getAsLong();
+    }
+
+    public long orElseThrow() {
+        return getAsLong();
+    }
+
+    public <X extends Throwable> long orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        if (present) {
+            return value;
+        }
+        throw exceptionSupplier.get();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof OptionalLong)) {
+            return false;
+        }
+        OptionalLong other = (OptionalLong) obj;
+        if (present != other.present) {
+            return false;
+        }
+        return !present || Long.compare(value, other.value) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return present ? Long.valueOf(value).hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return present ? "OptionalLong[" + value + "]" : "OptionalLong.empty";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/PrimitiveIterator.java b/vm/JavaAPI/src/java/util/PrimitiveIterator.java
new file mode 100644
index 00000000000..ed941198567
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/PrimitiveIterator.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.DoubleConsumer;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+
+import java.util.function.Consumer;
+
+/// An iterator
+/// that can hand out its elements unboxed.
+public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
+
+    void forEachRemaining(T_CONS action);
+
+    /// An iterator of `int` values.
+    interface OfInt extends PrimitiveIterator<Integer, IntConsumer> {
+
+        int nextInt();
+
+        @Override
+        default void forEachRemaining(IntConsumer action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(nextInt());
+            }
+        }
+
+        @Override
+        default Integer next() {
+            return Integer.valueOf(nextInt());
+        }
+
+        default void forEachRemaining(Consumer<? super Integer> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(Integer.valueOf(nextInt()));
+            }
+        }
+    }
+
+    /// An iterator of `long` values.
+    interface OfLong extends PrimitiveIterator<Long, LongConsumer> {
+
+        long nextLong();
+
+        @Override
+        default void forEachRemaining(LongConsumer action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(nextLong());
+            }
+        }
+
+        @Override
+        default Long next() {
+            return Long.valueOf(nextLong());
+        }
+
+        default void forEachRemaining(Consumer<? super Long> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(Long.valueOf(nextLong()));
+            }
+        }
+    }
+
+    /// An iterator of `double` values.
+    interface OfDouble extends PrimitiveIterator<Double, DoubleConsumer> {
+
+        double nextDouble();
+
+        @Override
+        default void forEachRemaining(DoubleConsumer action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(nextDouble());
+            }
+        }
+
+        @Override
+        default Double next() {
+            return Double.valueOf(nextDouble());
+        }
+
+        default void forEachRemaining(Consumer<? super Double> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            while (hasNext()) {
+                action.accept(Double.valueOf(nextDouble()));
+            }
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Properties.java b/vm/JavaAPI/src/java/util/Properties.java
index ed4e37d5fe2..18577fff25e 100644
--- a/vm/JavaAPI/src/java/util/Properties.java
+++ b/vm/JavaAPI/src/java/util/Properties.java
@@ -24,162 +24,77 @@
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
 import java.io.OutputStream;
-import java.io.OutputStreamWriter;
 import java.io.Reader;
 import java.io.Writer;
 
-public class Properties extends HashMap<String, String> {
+/// String keys and values, a second table of defaults behind them, and the
+/// `.properties` text format.
+///
+/// The format is read as the JDK reads it: `#` and `!` comments, `=`, `:` or
+/// white space between key and value, a trailing backslash continuing a line
+/// (the next line's indentation dropped), and the escapes `\t`, `\n`, `\r`,
+/// `\f` and backslash-u followed by four hexadecimal digits; a backslash
+/// before any other character stands for that character. A stream is
+/// ISO 8859-1; a reader is whatever its characters are. [#store] writes text
+/// that [#load] reads back to the same table, escaping what the format
+/// requires and, on a stream, every character outside printable ASCII.
+///
+/// The XML form (`loadFromXML`, `storeToXML`) and `list` are not provided.
+public class Properties extends Hashtable<Object, Object> {
 
-    /**
-     * The default values for keys not found in this {@code Properties}
-     * instance.
-     */
+    private static final long serialVersionUID = 4112578634029874840L;
+
+    private static final String HEX = "0123456789ABCDEF";
+
+    /// The table consulted for a key this one does not have, or null.
     protected Properties defaults;
 
     private static final int NONE = 0, SLASH = 1, UNICODE = 2, CONTINUE = 3,
             KEY_DONE = 4, IGNORE = 5;
 
-    /**
-     * Constructs a new {@code Properties} object.
-     */
+    /// An empty table with no defaults.
     public Properties() {
     }
 
-    /**
-     * Constructs a new {@code Properties} object using the specified default
-     * {@code Properties}.
-     *
-     * @param properties
-     *            the default {@code Properties}.
-     */
-    public Properties(Properties properties) {
-        defaults = properties;
+    /// An empty table with `defaults` behind it.
+    public Properties(Properties defaults) {
+        this.defaults = defaults;
     }
 
-    private void dumpString(StringBuilder buffer, String string, boolean key) {
-        int i = 0;
-        if (!key && i < string.length() && string.charAt(i) == ' ') {
-            buffer.append("\\ ");
-            i++;
-        }
-        int slen = string.length();
-        for (; i < slen; i++) {
-            char ch = string.charAt(i);
-            switch (ch) {
-            case '\t':
-                buffer.append("\\t");
-                break;
-            case '\n':
-                buffer.append("\\n");
-                break;
-            case '\f':
-                buffer.append("\\f");
-                break;
-            case '\r':
-                buffer.append("\\r");
-                break;
-            default:
-                if ("\\#!=:".indexOf(ch) >= 0 || (key && ch == ' ')) {
-                    buffer.append('\\');
-                }
-                if (ch >= ' ' && ch <= '~') {
-                    buffer.append(ch);
-                } else {
-                    String hex = Integer.toHexString(ch);
-                    buffer.append("\\u");
-                    int hlen = hex.length();
-                    for (int j = 0; j < 4 - hlen; j++) {
-                        buffer.append("0");
-                    }
-                    buffer.append(hex);
-                }
-            }
-        }
-    }
-
-    /**
-     * Searches for the property with the specified name. If the property is not
-     * found, the default {@code Properties} are checked. If the property is not
-     * found in the default {@code Properties}, {@code null} is returned.
-     *
-     * @param name
-     *            the name of the property to find.
-     * @return the named property value, or {@code null} if it can't be found.
-     */
+    /// The value for `name` here, else in the defaults, else null. A value
+    /// that is not a `String` counts as absent, as in the JDK.
     public String getProperty(String name) {
-        Object result = super.get(name);
-        String property = result instanceof String ? (String) result : null;
-        if (property == null && defaults != null) {
-            property = defaults.getProperty(name);
+        Object result = get(name);
+        if (result instanceof String) {
+            return (String) result;
         }
-        return property;
+        return defaults == null ? null : defaults.getProperty(name);
     }
 
-    /**
-     * Searches for the property with the specified name. If the property is not
-     * found, it looks in the default {@code Properties}. If the property is not
-     * found in the default {@code Properties}, it returns the specified
-     * default.
-     *
-     * @param name
-     *            the name of the property to find.
-     * @param defaultValue
-     *            the default value.
-     * @return the named property value.
-     */
+    /// The value for `name` as [#getProperty(String)] finds it, or
+    /// `defaultValue` when there is none.
     public String getProperty(String name, String defaultValue) {
-        Object result = super.get(name);
-        String property = result instanceof String ? (String) result : null;
-        if (property == null && defaults != null) {
-            property = defaults.getProperty(name);
-        }
-        if (property == null) {
-            return defaultValue;
-        }
-        return property;
+        String property = getProperty(name);
+        return property == null ? defaultValue : property;
     }
 
-    /**
-     * Loads properties from the specified {@code InputStream}, assumed to be ISO-8859-1.
-     * See "<a href="#character_encoding">Character Encoding</a>".
-     *
-     * @param in the {@code InputStream}
-     * @throws IOException
-     */
+    /// Maps `name` to `value` in this table, answering the value it replaced.
+    public Object setProperty(String name, String value) {
+        return put(name, value);
+    }
+
+    /// Reads ISO 8859-1 `.properties` text, adding to what is here. The
+    /// stream is left open.
     public synchronized void load(InputStream in) throws IOException {
         if (in == null) {
             throw new NullPointerException("in == null");
         }
-        load(new InputStreamReader(in, "UTF-8"));
+        load(new Latin1Reader(in));
     }
 
-    /**
-     * Loads properties from the specified {@code Reader}.
-     * The properties file is interpreted according to the following rules:
-     * <ul>
-     * <li>Empty lines are ignored.</li>
-     * <li>Lines starting with either a "#" or a "!" are comment lines and are
-     * ignored.</li>
-     * <li>A backslash at the end of the line escapes the following newline
-     * character ("\r", "\n", "\r\n"). If there's whitespace after the
-     * backslash it will just escape that whitespace instead of concatenating
-     * the lines. This does not apply to comment lines.</li>
-     * <li>A property line consists of the key, the space between the key and
-     * the value, and the value. The key goes up to the first whitespace, "=" or
-     * ":" that is not escaped. The space between the key and the value contains
-     * either one whitespace, one "=" or one ":" and any amount of additional
-     * whitespace before and after that character. The value starts with the
-     * first character after the space between the key and the value.</li>
-     * <li>Following escape sequences are recognized: "\ ", "\\", "\r", "\n",
-     * "\!", "\#", "\t", "\b", "\f", and "&#92;uXXXX" (unicode character).</li>
-     * </ul>
-     *
-     * @param in the {@code Reader}
-     * @throws IOException
-     * @since 1.6
-     */
+    /// Reads `.properties` text, adding to what is here. The reader is left
+    /// open.
     @SuppressWarnings("fallthrough")
     public synchronized void load(Reader in) throws IOException {
         if (in == null) {
@@ -212,7 +127,7 @@ public synchronized void load(Reader in) throws IOException {
                         continue;
                     }
                 } else if (count <= 4) {
-                    throw new IllegalArgumentException("Invalid Unicode sequence: illegal character");
+                    throw new IllegalArgumentException("Malformed \\uxxxx encoding.");
                 }
                 mode = NONE;
                 buf[offset++] = (char) unicode;
@@ -229,9 +144,6 @@ public synchronized void load(Reader in) throws IOException {
                 case '\n':
                     mode = IGNORE; // Ignore whitespace on the next line
                     continue;
-                case 'b':
-                    nextChar = '\b';
-                    break;
                 case 'f':
                     nextChar = '\f';
                     break;
@@ -248,6 +160,10 @@ public synchronized void load(Reader in) throws IOException {
                     mode = UNICODE;
                     unicode = count = 0;
                     continue;
+                default:
+                    // Any other escaped character is that character, `\b`
+                    // included: the JDK has no backspace escape.
+                    break;
                 }
             } else {
                 switch (nextChar) {
@@ -281,8 +197,7 @@ public synchronized void load(Reader in) throws IOException {
                             keyLength = offset;
                         }
                         String temp = new String(buf, 0, offset);
-                        put(temp.substring(0, keyLength), temp
-                                .substring(keyLength));
+                        put(temp.substring(0, keyLength), temp.substring(keyLength));
                     }
                     keyLength = -1;
                     offset = 0;
@@ -301,8 +216,11 @@ public synchronized void load(Reader in) throws IOException {
                         continue;
                     }
                     break;
+                default:
+                    break;
                 }
-                if (nextChar == ' ' || nextChar == '\n' || nextChar == '\r' || nextChar == '\t') {
+                if (nextChar == ' ' || nextChar == '\n' || nextChar == '\r' || nextChar == '\t'
+                        || nextChar == '\f') {
                     if (mode == CONTINUE) {
                         mode = IGNORE;
                     }
@@ -327,141 +245,226 @@ public synchronized void load(Reader in) throws IOException {
             buf[offset++] = nextChar;
         }
         if (mode == UNICODE && count <= 4) {
-            throw new IllegalArgumentException("Invalid Unicode sequence: expected format \\uxxxx");
+            throw new IllegalArgumentException("Malformed \\uxxxx encoding.");
         }
         if (keyLength == -1 && offset > 0) {
             keyLength = offset;
         }
         if (keyLength >= 0) {
             String temp = new String(buf, 0, offset);
-            String key = temp.substring(0, keyLength);
-            String value = temp.substring(keyLength);
-            if (mode == SLASH) {
-                value += "\u0000";
-            }
-            put(key, value);
+            put(temp.substring(0, keyLength), temp.substring(keyLength));
         }
     }
 
-    /**
-     * Returns all of the property names (keys) in this {@code Properties} object.
-     */
+    /// Every key of this table and of its defaults.
     public Enumeration<?> propertyNames() {
-        Hashtable<Object, Object> selected = new Hashtable<Object, Object>();
-        selectProperties(selected, false);
-        return selected.keys();
+        Hashtable<Object, Object> all = new Hashtable<Object, Object>();
+        collect(all, false);
+        return all.keys();
     }
 
-    /**
-     * Returns those property names (keys) in this {@code Properties} object for which
-     * both key and value are strings.
-     *
-     * @return a set of keys in the property list
-     * @since 1.6
-     */
+    /// The keys, of this table and of its defaults, whose key and value are
+    /// both strings.
     public Set<String> stringPropertyNames() {
-        Hashtable<String, Object> stringProperties = new Hashtable<String, Object>();
-        selectProperties(stringProperties, true);
-        return Collections.unmodifiableSet(stringProperties.keySet());
+        Hashtable<Object, Object> all = new Hashtable<Object, Object>();
+        collect(all, true);
+        Set<String> names = new HashSet<String>();
+        for (Object key : all.keySet()) {
+            if (key instanceof String) {
+                names.add((String) key);
+            }
+        }
+        return Collections.unmodifiableSet(names);
     }
 
-    private <K> void selectProperties(Hashtable<K, Object> selectProperties, final boolean isStringOnly) {
+    /// Defaults first, so that this table's own entries replace them.
+    private void collect(Hashtable<Object, Object> into, boolean stringsOnly) {
         if (defaults != null) {
-            defaults.selectProperties(selectProperties, isStringOnly);
+            defaults.collect(into, stringsOnly);
         }
-        Iterator<String> keys = keySet().iterator();
-        while (keys.hasNext()) {
-            @SuppressWarnings("unchecked")
-            K key = (K) keys.next();
-            if (isStringOnly && !(key instanceof String)) {
-                // Only select property with string key and value
+        for (Map.Entry<Object, Object> e : entrySet()) {
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (stringsOnly && !(key instanceof String && value instanceof String)) {
                 continue;
             }
-            Object value = get(key);
-            selectProperties.put(key, value);
+            into.put(key, value);
         }
     }
 
-    /**
-     * Saves the mappings in this {@code Properties} to the specified {@code
-     * OutputStream}, putting the specified comment at the beginning. The output
-     * from this method is suitable for being read by the
-     * {@link #load(InputStream)} method.
-     *
-     * @param out the {@code OutputStream} to write to.
-     * @param comment the comment to add at the beginning.
-     * @throws ClassCastException if the key or value of a mapping is not a
-     *                String.
-     * @deprecated This method ignores any {@code IOException} thrown while
-     *             writing -- use {@link #store} instead for better exception
-     *             handling.
-     */
+    /// Writes this table as [#store(OutputStream, String)] does, ignoring any
+    /// `IOException`.
+    ///
+    /// #### Deprecated
+    ///
+    /// An error writing is lost; use [#store(OutputStream, String)].
     @Deprecated
-    public void save(OutputStream out, String comment) {
+    public void save(OutputStream out, String comments) {
         try {
-            store(out, comment);
+            store(out, comments);
         } catch (IOException e) {
+            // As documented: save reports nothing.
         }
     }
 
-    /**
-     * Maps the specified key to the specified value. If the key already exists,
-     * the old value is replaced. The key and value cannot be {@code null}.
-     *
-     * @param name
-     *            the key.
-     * @param value
-     *            the value.
-     * @return the old value mapped to the key, or {@code null}.
-     */
-    public Object setProperty(String name, String value) {
-        return put(name, value);
+    /// Writes this table (not its defaults) as ISO 8859-1 `.properties`
+    /// text: the comment lines, a line with the current date, then one
+    /// `key=value` line per entry. The stream is flushed and left open.
+    ///
+    /// #### Throws
+    ///
+    /// - `ClassCastException`: if a key or value is not a `String`
+    public void store(OutputStream out, String comments) throws IOException {
+        if (out == null) {
+            throw new NullPointerException();
+        }
+        String text = render(comments, true);
+        byte[] bytes = new byte[text.length()];
+        for (int i = 0; i < bytes.length; i++) {
+            // Everything outside ASCII was escaped by render.
+            bytes[i] = (byte) text.charAt(i);
+        }
+        out.write(bytes);
+        out.flush();
+    }
+
+    /// Writes this table as `.properties` text, leaving characters outside
+    /// ASCII as they are. The writer is flushed and left open.
+    ///
+    /// #### Throws
+    ///
+    /// - `ClassCastException`: if a key or value is not a `String`
+    public void store(Writer writer, String comments) throws IOException {
+        if (writer == null) {
+            throw new NullPointerException();
+        }
+        writer.write(render(comments, false));
+        writer.flush();
+    }
+
+    private synchronized String render(String comments, boolean escapeUnicode) {
+        StringBuilder out = new StringBuilder();
+        if (comments != null) {
+            writeComments(out, comments, escapeUnicode);
+        }
+        out.append('#').append(new Date().toString()).append('\n');
+        for (Map.Entry<Object, Object> e : entrySet()) {
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (!(key instanceof String) || !(value instanceof String)) {
+                // The JDK fails here with a ClassCastException, which a
+                // device cannot be relied on to raise from a cast.
+                throw new ClassCastException("Properties holds a key or value that is not a String");
+            }
+            escape(out, (String) key, true, escapeUnicode);
+            out.append('=');
+            escape(out, (String) value, false, escapeUnicode);
+            out.append('\n');
+        }
+        return out.toString();
+    }
+
+    /// Every line of `comments` as a comment line: a line that does not
+    /// start one already gets `#`.
+    private static void writeComments(StringBuilder out, String comments, boolean escapeUnicode) {
+        out.append('#');
+        int n = comments.length();
+        for (int i = 0; i < n; i++) {
+            char c = comments.charAt(i);
+            if (c == '\n' || c == '\r') {
+                if (c == '\r' && i + 1 < n && comments.charAt(i + 1) == '\n') {
+                    i++;
+                }
+                out.append('\n');
+                if (i + 1 >= n || (comments.charAt(i + 1) != '#' && comments.charAt(i + 1) != '!')) {
+                    out.append('#');
+                }
+            } else if (escapeUnicode && c > 0xff) {
+                unicode(out, c);
+            } else {
+                out.append(c);
+            }
+        }
+        out.append('\n');
     }
 
-    /**
-     * Stores properties to the specified {@code OutputStream}, using ISO-8859-1.
-     * See "<a href="#character_encoding">Character Encoding</a>".
-     *
-     * @param out the {@code OutputStream}
-     * @param comment an optional comment to be written, or null
-     * @throws IOException
-     * @throws ClassCastException if a key or value is not a string
-     */
-    public synchronized void store(OutputStream out, String comment) throws IOException {
-        store(new OutputStreamWriter(out, "UTF-8"), comment);
+    private static void unicode(StringBuilder out, char c) {
+        out.append('\\').append('u');
+        out.append(HEX.charAt((c >> 12) & 0xf)).append(HEX.charAt((c >> 8) & 0xf));
+        out.append(HEX.charAt((c >> 4) & 0xf)).append(HEX.charAt(c & 0xf));
     }
 
-    /**
-     * Stores the mappings in this {@code Properties} object to {@code out},
-     * putting the specified comment at the beginning.
-     *
-     * @param writer the {@code Writer}
-     * @param comment an optional comment to be written, or null
-     * @throws IOException
-     * @throws ClassCastException if a key or value is not a string
-     * @since 1.6
-     */
-    public synchronized void store(Writer writer, String comment) throws IOException {
-        if (comment != null && comment.length() > 0) {
-            writer.write("#");
-            writer.write(comment);
-            writer.write("\n");
-            writer.write("#");
-            writer.write(new Date().toString());
-            writer.write("\n");
+    private static void escape(StringBuilder out, String s, boolean key, boolean escapeUnicode) {
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            switch (c) {
+                case ' ':
+                    // Only a leading space of a value would be dropped on
+                    // reading; in a key every space ends the key.
+                    if (key || i == 0) {
+                        out.append('\\');
+                    }
+                    out.append(' ');
+                    break;
+                case '\t':
+                    out.append("\\t");
+                    break;
+                case '\n':
+                    out.append("\\n");
+                    break;
+                case '\r':
+                    out.append("\\r");
+                    break;
+                case '\f':
+                    out.append("\\f");
+                    break;
+                case '=':
+                case ':':
+                case '#':
+                case '!':
+                case '\\':
+                    out.append('\\').append(c);
+                    break;
+                default:
+                    if (escapeUnicode && (c < 0x20 || c > 0x7e)) {
+                        unicode(out, c);
+                    } else {
+                        out.append(c);
+                    }
+            }
+        }
+    }
+
+    /// A stream's bytes as ISO 8859-1 characters, one for one.
+    private static final class Latin1Reader extends Reader {
+        private final InputStream in;
+
+        Latin1Reader(InputStream in) {
+            this.in = in;
         }
 
-        StringBuilder sb = new StringBuilder(200);
-        ArrayList<String> k = new ArrayList<String>(keySet());
-        Collections.sort(k, new CaseInsensitiveOrder());
-        for (String key : k) {
-            dumpString(sb, key, true);
-            sb.append('=');
-            dumpString(sb, (String) get(key), false);
-            sb.append("\n");
-            writer.write(sb.toString());
-            sb.setLength(0);
+        @Override
+        public int read() throws IOException {
+            return in.read();
+        }
+
+        @Override
+        public int read(char[] cbuf, int off, int len) throws IOException {
+            int n = 0;
+            while (n < len) {
+                int b = in.read();
+                if (b < 0) {
+                    return n == 0 ? -1 : n;
+                }
+                cbuf[off + n++] = (char) b;
+            }
+            return n;
+        }
+
+        @Override
+        public void close() throws IOException {
+            // The caller's stream stays open.
         }
-        writer.flush();
     }
-}
\ No newline at end of file
+}
diff --git a/vm/JavaAPI/src/java/util/PropertyResourceBundle.java b/vm/JavaAPI/src/java/util/PropertyResourceBundle.java
new file mode 100644
index 00000000000..d0931528d35
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/PropertyResourceBundle.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+
+/// A resource bundle read from a `.properties` file.
+///
+/// The parser implements the whole `java.util.Properties` text format: `#` and `!`
+/// comment lines, `=`, `:` or whitespace between key and value, a logical line
+/// continued by a trailing backslash, and the escapes -- tab, newline, form
+/// feed, carriage return, backslash-u followed by four hex digits, and a
+/// backslash before any other character standing for that character.
+///
+/// A stream is decoded as ISO-8859-1, one byte to one character, which is
+/// what the JDK did for as long as `.properties` files have carried
+/// backslash-u escapes for everything else. Pass a `Reader` to choose another
+/// encoding.
+public class PropertyResourceBundle extends ResourceBundle {
+
+    private final Map<String, Object> lookup = new HashMap<String, Object>();
+
+    public PropertyResourceBundle(InputStream stream) throws IOException {
+        StringBuilder text = new StringBuilder();
+        byte[] buffer = new byte[4096];
+        int n = stream.read(buffer);
+        while (n >= 0) {
+            for (int i = 0; i < n; i++) {
+                text.append((char) (buffer[i] & 0xff));
+            }
+            n = stream.read(buffer);
+        }
+        parse(text.toString(), lookup);
+    }
+
+    public PropertyResourceBundle(Reader reader) throws IOException {
+        StringBuilder text = new StringBuilder();
+        char[] buffer = new char[4096];
+        int n = reader.read(buffer, 0, buffer.length);
+        while (n >= 0) {
+            text.append(buffer, 0, n);
+            n = reader.read(buffer, 0, buffer.length);
+        }
+        parse(text.toString(), lookup);
+    }
+
+    public Object handleGetObject(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        return lookup.get(key);
+    }
+
+    public Enumeration<String> getKeys() {
+        return new ResourceBundle.KeyEnumeration(keySet().iterator());
+    }
+
+    protected Set<String> handleKeySet() {
+        return lookup.keySet();
+    }
+
+    private static boolean isBlank(char c) {
+        return c == ' ' || c == '\t' || c == '\f';
+    }
+
+    private static boolean isLineEnd(char c) {
+        return c == '\n' || c == '\r';
+    }
+
+    /// Reads `.properties` text into `out`, a later definition of a key
+    /// replacing an earlier one.
+    static void parse(String text, Map<String, ? super String> out) {
+        int n = text.length();
+        int i = 0;
+        StringBuilder line = new StringBuilder();
+        while (i < n) {
+            // Blank lines and the indentation of a logical line carry nothing.
+            while (i < n && (isBlank(text.charAt(i)) || isLineEnd(text.charAt(i)))) {
+                i++;
+            }
+            if (i >= n) {
+                break;
+            }
+            char c = text.charAt(i);
+            if (c == '#' || c == '!') {
+                // A comment runs to the end of its natural line and cannot be
+                // continued, whatever it ends with.
+                while (i < n && !isLineEnd(text.charAt(i))) {
+                    i++;
+                }
+                continue;
+            }
+            line.setLength(0);
+            boolean escaped = false;
+            // A line that is nothing but a continuation is no entry, unless
+            // the input ends in the middle of it: then the JDK defines the
+            // empty key, and so does this.
+            boolean cutShort = false;
+            while (i < n) {
+                c = text.charAt(i);
+                if (isLineEnd(c)) {
+                    if (!escaped) {
+                        break;
+                    }
+                    // An odd run of backslashes before the terminator joins
+                    // the next natural line, minus its indentation.
+                    line.setLength(line.length() - 1);
+                    i++;
+                    cutShort = i >= n;
+                    if (c == '\r' && i < n && text.charAt(i) == '\n') {
+                        i++;
+                    }
+                    while (i < n && isBlank(text.charAt(i))) {
+                        i++;
+                    }
+                    escaped = false;
+                    continue;
+                }
+                line.append(c);
+                escaped = c == '\\' && !escaped;
+                i++;
+            }
+            if (escaped) {
+                // A lone backslash at the end of the input escapes nothing.
+                line.setLength(line.length() - 1);
+                cutShort = true;
+            }
+            if (line.length() > 0 || cutShort) {
+                store(line, out);
+            }
+        }
+    }
+
+    private static void store(StringBuilder line, Map<String, ? super String> out) {
+        int len = line.length();
+        int keyLen = 0;
+        int valueStart = len;
+        boolean hasSeparator = false;
+        boolean escaped = false;
+        while (keyLen < len) {
+            char c = line.charAt(keyLen);
+            if ((c == '=' || c == ':') && !escaped) {
+                valueStart = keyLen + 1;
+                hasSeparator = true;
+                break;
+            }
+            if (isBlank(c) && !escaped) {
+                valueStart = keyLen + 1;
+                break;
+            }
+            escaped = c == '\\' && !escaped;
+            keyLen++;
+        }
+        // Whitespace may surround the one separator character.
+        while (valueStart < len) {
+            char c = line.charAt(valueStart);
+            if (!isBlank(c)) {
+                if (!hasSeparator && (c == '=' || c == ':')) {
+                    hasSeparator = true;
+                } else {
+                    break;
+                }
+            }
+            valueStart++;
+        }
+        out.put(unescape(line, 0, keyLen), unescape(line, valueStart, len));
+    }
+
+    private static int hexDigit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        throw new IllegalArgumentException("Malformed unicode escape in properties text");
+    }
+
+    private static String unescape(StringBuilder in, int from, int to) {
+        StringBuilder sb = new StringBuilder(to - from);
+        int i = from;
+        while (i < to) {
+            char c = in.charAt(i++);
+            if (c != '\\' || i >= to) {
+                if (c != '\\') {
+                    sb.append(c);
+                }
+                continue;
+            }
+            c = in.charAt(i++);
+            if (c == 'u') {
+                if (i + 4 > to) {
+                    throw new IllegalArgumentException("Malformed unicode escape in properties text");
+                }
+                int value = 0;
+                for (int k = 0; k < 4; k++) {
+                    value = (value << 4) | hexDigit(in.charAt(i++));
+                }
+                sb.append((char) value);
+            } else if (c == 't') {
+                sb.append('\t');
+            } else if (c == 'r') {
+                sb.append('\r');
+            } else if (c == 'n') {
+                sb.append('\n');
+            } else if (c == 'f') {
+                sb.append('\f');
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Random.java b/vm/JavaAPI/src/java/util/Random.java
index 1e4e4b39d6e..6eb36423d61 100644
--- a/vm/JavaAPI/src/java/util/Random.java
+++ b/vm/JavaAPI/src/java/util/Random.java
@@ -127,9 +127,17 @@ public boolean nextBoolean() {
         return nextInt() % 2 == 0;
     }
     
+    /// Fills `bytes` with random bytes. Four bytes come from each `nextInt()`,
+    /// low byte first, which is the algorithm the JDK documents: a seeded
+    /// generator must hand out the same bytes as on the JVM, and one `next(8)`
+    /// per byte does not.
     public void nextBytes(byte[] bytes) {
-        for (int i = 0; i < bytes.length; ++i) {
-            bytes[i] = (byte) next(8);
+        int len = bytes.length;
+        for (int i = 0; i < len;) {
+            int rnd = nextInt();
+            for (int n = Math.min(len - i, 4); n-- > 0; rnd >>= 8) {
+                bytes[i++] = (byte) rnd;
+            }
         }
     }
 
diff --git a/vm/JavaAPI/src/java/util/ResourceBundle.java b/vm/JavaAPI/src/java/util/ResourceBundle.java
new file mode 100644
index 00000000000..81cb4bf6549
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/ResourceBundle.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/// Locale specific strings and objects, looked up by key, with a chain of
+/// less specific bundles behind each one.
+///
+/// `getBundle("com.example.Messages", locale)` looks for three bundles, most
+/// specific first -- `Messages_<language>_<COUNTRY>`, `Messages_<language>`
+/// and `Messages` -- and chains the ones that exist, so a key missing from the
+/// first is answered by the next. When nothing more specific than the base
+/// bundle exists for the requested locale, the default locale is tried the
+/// same way before the base bundle is settled for. Finding none at all throws
+/// `MissingResourceException`.
+///
+/// Each of the three is first created as a class of that name extending
+/// `ResourceBundle`, then read as the resource
+/// `com/example/Messages_<suffix>.properties`. An application built by
+/// Codename One carries a registry, generated with it, that creates the bundle
+/// classes it has with `new`; no class is then created from its name, which a
+/// device cannot be relied on to do. Without a registry the class is looked up
+/// by name. The resource is read through the platform
+/// (`com.codename1.impl.JdkHost`), which knows where the build put it.
+///
+/// Bundles are cached for the life of the application, or until
+/// `clearCache()`. `ResourceBundle.Control`, and the lookups that take one,
+/// are not provided.
+public abstract class ResourceBundle {
+
+    /// Every bundle already loaded, by base name and suffix; MISSING for one known not to exist.
+    private static final Map<String, Object> CACHE = new HashMap<String, Object>();
+
+    private static final Object MISSING = new Object();
+
+    /// The bundle consulted for a key this one does not have, or null.
+    protected ResourceBundle parent;
+
+    private Locale locale;
+    private String baseName;
+
+    public ResourceBundle() {
+    }
+
+    public static final ResourceBundle getBundle(String baseName) {
+        return getBundle(baseName, Locale.getDefault());
+    }
+
+    /// Looks the bundle up as getBundle(String, Locale) does. The class loader
+    /// is not used: an application has one.
+    public static ResourceBundle getBundle(String baseName, Locale locale, ClassLoader loader) {
+        return getBundle(baseName, locale);
+    }
+
+    public static final ResourceBundle getBundle(String baseName, Locale locale) {
+        if (baseName == null || locale == null) {
+            throw new NullPointerException();
+        }
+        String name = baseName.replace('/', '.');
+        String language = nonNull(locale.getLanguage());
+        String country = nonNull(locale.getCountry());
+        ResourceBundle found;
+        synchronized (CACHE) {
+            found = findChain(name, language, country);
+            // A bundle found by the chain has had its locale set; one that
+            // has none is the base bundle, like one of the empty language.
+            Locale foundLocale = found == null ? null : found.locale;
+            if (foundLocale == null || nonNull(foundLocale.getLanguage()).length() == 0) {
+                // Nothing specific to the requested locale: the default
+                // locale's bundle is preferred to the base bundle.
+                Locale fallback = Locale.getDefault();
+                String fallbackLanguage = nonNull(fallback.getLanguage());
+                String fallbackCountry = nonNull(fallback.getCountry());
+                boolean requestedRoot = language.length() == 0;
+                boolean sameLocale = fallbackLanguage.equals(language) && fallbackCountry.equals(country);
+                if (!sameLocale && !(requestedRoot && found != null)) {
+                    ResourceBundle viaDefault = findChain(name, fallbackLanguage, fallbackCountry);
+                    if (viaDefault != null) {
+                        found = viaDefault;
+                    }
+                }
+            }
+        }
+        if (found == null) {
+            String localeName = localeSuffix(language, country);
+            throw new MissingResourceException(
+                    "Can't find bundle for base name " + baseName + ", locale "
+                            + (localeName.length() == 0 ? "" : localeName.substring(1)),
+                    baseName + localeName, "");
+        }
+        return found;
+    }
+
+    public static final void clearCache() {
+        synchronized (CACHE) {
+            CACHE.clear();
+        }
+    }
+
+    private static String nonNull(String s) {
+        return s == null ? "" : s;
+    }
+
+    private static String localeSuffix(String language, String country) {
+        if (language.length() == 0) {
+            return "";
+        }
+        return country.length() == 0 ? "_" + language : "_" + language + "_" + country;
+    }
+
+    /// The most specific bundle that exists for the locale, with the less
+    /// specific ones chained behind it, or null when not even the base bundle
+    /// exists.
+    private static ResourceBundle findChain(String baseName, String language, String country) {
+        ResourceBundle result = load(baseName, "", "", "", null);
+        if (language.length() > 0) {
+            ResourceBundle forLanguage = load(baseName, "_" + language, language, "", result);
+            if (forLanguage != null) {
+                result = forLanguage;
+            }
+            if (country.length() > 0) {
+                ResourceBundle forCountry =
+                        load(baseName, "_" + language + "_" + country, language, country, result);
+                if (forCountry != null) {
+                    result = forCountry;
+                }
+            }
+        }
+        return result;
+    }
+
+    private static ResourceBundle load(String baseName, String suffix, String language, String country,
+                                       ResourceBundle parent) {
+        String key = baseName + '\n' + suffix;
+        Object cached = CACHE.get(key);
+        if (cached instanceof ResourceBundle) {
+            return (ResourceBundle) cached;
+        }
+        if (cached != null) {
+            return null;
+        }
+        ResourceBundle bundle = create(baseName, suffix);
+        if (bundle == null) {
+            CACHE.put(key, MISSING);
+            return null;
+        }
+        if (bundle.parent == null) {
+            // The less specific bundle of a name is the same whichever locale
+            // led here, so the chain is fixed the first time it is built.
+            bundle.parent = parent;
+        }
+        bundle.locale = new Locale(language, country);
+        bundle.baseName = baseName;
+        CACHE.put(key, bundle);
+        return bundle;
+    }
+
+    private static ResourceBundle create(String baseName, String suffix) {
+        String name = baseName + suffix;
+        JdkHost host = JdkHost.get();
+        Object made = host.newInstance(name);
+        if (made instanceof ResourceBundle) {
+            return (ResourceBundle) made;
+        }
+        if (JdkHost.getRegistry() == null) {
+            // No registry was generated with the application, so nothing says
+            // which bundle classes it has: ask for the class by name.
+            ResourceBundle byName = createByName(name);
+            if (byName != null) {
+                return byName;
+            }
+        }
+        InputStream in = host.resource(baseName.replace('.', '/') + suffix + ".properties");
+        if (in == null) {
+            return null;
+        }
+        try {
+            return new PropertyResourceBundle(in);
+        } catch (IOException e) {
+            // A bundle that cannot be read is a bundle that is not there.
+            return null;
+        } finally {
+            try {
+                in.close();
+            } catch (IOException e) {
+                // Nothing to do about a failed close of a stream already read.
+            }
+        }
+    }
+
+    private static ResourceBundle createByName(String name) {
+        try {
+            Object instance = Class.forName(name).newInstance();
+            if (instance instanceof ResourceBundle) {
+                return (ResourceBundle) instance;
+            }
+        } catch (ClassNotFoundException e) {
+            // No class of this name: the bundle is a properties file, or absent.
+        } catch (InstantiationException e) {
+            // Not a class this lookup can create; the file may still be there.
+        } catch (IllegalAccessException e) {
+            // As above.
+        }
+        return null;
+    }
+
+    public final String getString(String key) {
+        Object value = getObject(key);
+        if (value instanceof String) {
+            return (String) value;
+        }
+        throw new ClassCastException("Resource " + key + " is not a String");
+    }
+
+    public final String[] getStringArray(String key) {
+        Object value = getObject(key);
+        if (value instanceof String[]) {
+            return (String[]) value;
+        }
+        throw new ClassCastException("Resource " + key + " is not a String array");
+    }
+
+    public final Object getObject(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        for (ResourceBundle b = this; b != null; b = b.parent) {
+            Object value = b.handleGetObject(key);
+            if (value != null) {
+                return value;
+            }
+        }
+        throw new MissingResourceException(
+                "Can't find resource for bundle " + getClass().getName() + ", key " + key,
+                getClass().getName(), key);
+    }
+
+    /// The locale this bundle was found for, which may be less specific than
+    /// the one asked for. The base bundle's has an empty language.
+    public Locale getLocale() {
+        return locale;
+    }
+
+    public String getBaseBundleName() {
+        return baseName;
+    }
+
+    protected void setParent(ResourceBundle parent) {
+        this.parent = parent;
+    }
+
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException();
+        }
+        for (ResourceBundle b = this; b != null; b = b.parent) {
+            if (b.handleKeySet().contains(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Every key of this bundle and of the bundles behind it.
+    public Set<String> keySet() {
+        Set<String> keys = new HashSet<String>();
+        for (ResourceBundle b = this; b != null; b = b.parent) {
+            keys.addAll(b.handleKeySet());
+        }
+        return keys;
+    }
+
+    /// The keys this bundle itself defines. The default derives them from
+    /// getKeys(); a subclass that has them at hand should override it.
+    protected Set<String> handleKeySet() {
+        Set<String> keys = new HashSet<String>();
+        Enumeration<String> all = getKeys();
+        while (all.hasMoreElements()) {
+            String key = all.nextElement();
+            if (handleGetObject(key) != null) {
+                keys.add(key);
+            }
+        }
+        return keys;
+    }
+
+    protected abstract Object handleGetObject(String key);
+
+    public abstract Enumeration<String> getKeys();
+
+    /// An Enumeration over an iterator, for the getKeys implementations.
+    static final class KeyEnumeration implements Enumeration<String> {
+        private final Iterator<String> it;
+
+        KeyEnumeration(Iterator<String> it) {
+            this.it = it;
+        }
+
+        public boolean hasMoreElements() {
+            return it.hasNext();
+        }
+
+        public String nextElement() {
+            return it.next();
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/ReversedList.java b/vm/JavaAPI/src/java/util/ReversedList.java
new file mode 100644
index 00000000000..be6f440d8b3
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/ReversedList.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// The view `List.reversed()` answers: index `i` here is index
+/// `size() - 1 - i` of the backing list, and every read and write goes
+/// through to it. Structural changes made to the backing list directly are
+/// visible here at once, because nothing is copied.
+final class ReversedList<E> extends AbstractList<E> {
+
+    private final List<E> base;
+
+    ReversedList(List<E> base) {
+        this.base = base;
+    }
+
+    private int flip(int index) {
+        return base.size() - 1 - index;
+    }
+
+    @Override
+    public E get(int index) {
+        if (index < 0 || index >= base.size()) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        return base.get(flip(index));
+    }
+
+    @Override
+    public int size() {
+        return base.size();
+    }
+
+    @Override
+    public E set(int index, E element) {
+        if (index < 0 || index >= base.size()) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        return base.set(flip(index), element);
+    }
+
+    @Override
+    public void add(int index, E element) {
+        int size = base.size();
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        base.add(size - index, element);
+    }
+
+    @Override
+    public E remove(int index) {
+        if (index < 0 || index >= base.size()) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        return base.remove(flip(index));
+    }
+
+    @Override
+    public void clear() {
+        base.clear();
+    }
+
+    @Override
+    public List<E> reversed() {
+        return base;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/ServiceConfigurationError.java b/vm/JavaAPI/src/java/util/ServiceConfigurationError.java
new file mode 100644
index 00000000000..2e0e66b2c3f
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/ServiceConfigurationError.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// What a [ServiceLoader] throws for a provider that cannot be had. The
+/// build leaves such a provider out with a warning, so an iteration never
+/// throws it here; [ServiceLoader.Provider#get()] does, for a provider whose
+/// class creates no instance of the service.
+public class ServiceConfigurationError extends Error {
+
+    private static final long serialVersionUID = 1L;
+
+    public ServiceConfigurationError(String msg) {
+        super(msg);
+    }
+
+    public ServiceConfigurationError(String msg, Throwable cause) {
+        super(msg);
+        initCause(cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/ServiceLoader.java b/vm/JavaAPI/src/java/util/ServiceLoader.java
new file mode 100644
index 00000000000..fb28c624e5c
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/ServiceLoader.java
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import com.codename1.impl.JdkHost;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+/// The providers of a service, as the `META-INF/services` files of the
+/// application and of the libraries bundled with it list them.
+///
+/// #### Where the providers come from
+///
+/// A device discovers nothing at run time and creates no class from its
+/// name. The build reads every `META-INF/services/<service>` file the
+/// application ships and generates a registry with the application that
+/// names the providers of each service, in class path order, and creates each
+/// of them with `new` (`com.codename1.impl.JdkHost.Registry`). So the set of
+/// providers is fixed when the application is built. A listed class that the
+/// application does not ship, that is abstract or that has no public
+/// constructor without parameters is left out by the build with a warning;
+/// the JDK throws `ServiceConfigurationError` for such a provider when the
+/// iteration reaches it, and here it is simply not there.
+///
+/// Where no registry was generated -- a program translated without Codename
+/// One, a test -- the services file is read through the platform
+/// (`JdkHost.resource`), as the JDK reads it, and the classes are created
+/// from their names.
+///
+/// #### What is the same as the JDK
+///
+/// Providers are created lazily, one at a time as an iteration reaches them,
+/// and once per loader: a second `iterator()` answers the instances the first
+/// one created and goes on from where it stopped. [#reload()] forgets them.
+/// [#stream()] creates nothing until [Provider#get()] is called, which
+/// answers a new instance on every call.
+///
+/// #### What is not there
+///
+/// The class loader a loader is asked for selects nothing: an application
+/// has one. Module layers, and providers that are a static `provider()`
+/// method of a named module, are not provided.
+public final class ServiceLoader<S> implements Iterable<S> {
+
+    private final Class<S> service;
+
+    /// The provider class names of this service, or null until an iteration asks.
+    private List<String> entries;
+
+    /// The instances created so far, in order.
+    private final List<S> instances = new ArrayList<S>();
+
+    /// The index in [#entries] of the next provider to create.
+    private int next;
+
+    /// Counts the reloads, so that an iterator taken before one can tell.
+    private int generation;
+
+    /// Whether this is the loader of the installed providers, which has none.
+    private final boolean installed;
+
+    private ServiceLoader(Class<S> service, boolean installed) {
+        if (service == null) {
+            throw new NullPointerException("Service interface cannot be null");
+        }
+        this.service = service;
+        this.installed = installed;
+    }
+
+    /// One provider of a service, not yet created: what [#stream()] answers.
+    public interface Provider<S> extends Supplier<S> {
+        /// The provider's class.
+        Class<? extends S> type();
+
+        /// A new instance of the provider.
+        S get();
+    }
+
+    /// A loader of the providers of `service`. Nothing is looked up or
+    /// created until it is iterated.
+    public static <S> ServiceLoader<S> load(Class<S> service) {
+        return new ServiceLoader<S>(service, false);
+    }
+
+    /// As [#load(Class)]: an application has one class loader, so `loader`,
+    /// which may be null as in the JDK, selects nothing.
+    public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader) {
+        return new ServiceLoader<S>(service, false);
+    }
+
+    /// As [#load(Class)], for a layer that is not null. Nothing here hands
+    /// out a module layer -- [Module#getLayer()] answers null -- so code
+    /// reaches this only with the null the JDK refuses as well.
+    public static <S> ServiceLoader<S> load(ModuleLayer layer, Class<S> service) {
+        if (layer == null) {
+            throw new NullPointerException();
+        }
+        return new ServiceLoader<S>(service, false);
+    }
+
+    /// The providers installed in the platform: on a desktop, the ones the
+    /// platform class loader sees. An application's own providers are not
+    /// among those, and a device installs none, so the loader is empty.
+    public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
+        return new ServiceLoader<S>(service, true);
+    }
+
+    private List<String> entries() {
+        if (entries == null) {
+            entries = installed ? new ArrayList<String>() : lookup(service.getName());
+        }
+        return entries;
+    }
+
+    private static List<String> lookup(String name) {
+        List<String> out = new ArrayList<String>();
+        JdkHost host = JdkHost.get();
+        if (JdkHost.getRegistry() != null) {
+            // The build registered every provider the application has.
+            String[] registered = host.providers(name);
+            for (int i = 0; i < registered.length; i++) {
+                out.add(registered[i]);
+            }
+            return out;
+        }
+        String text = read(host.resource("META-INF/services/" + name));
+        if (text != null) {
+            providerNames(text, out);
+        }
+        return out;
+    }
+
+    /// The provider class names a services file lists, in order: each line
+    /// up to its first `#`, trimmed, when anything is left, and a name that
+    /// appears twice once. A line that is not a class name is left out; the
+    /// JDK refuses the whole file for one.
+    private static void providerNames(String text, List<String> out) {
+        int n = text.length();
+        int start = 0;
+        while (start <= n) {
+            int end = start;
+            while (end < n && text.charAt(end) != '\n' && text.charAt(end) != '\r') {
+                end++;
+            }
+            String line = text.substring(start, end);
+            int hash = line.indexOf('#');
+            if (hash >= 0) {
+                line = line.substring(0, hash);
+            }
+            line = line.trim();
+            if (line.length() > 0 && isClassName(line) && !out.contains(line)) {
+                out.add(line);
+            }
+            start = end + 1;
+        }
+    }
+
+    private static boolean isClassName(String name) {
+        int n = name.length();
+        for (int i = 0; i < n; i++) {
+            char c = name.charAt(i);
+            boolean letter = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c >= 0x80;
+            boolean digit = c >= '0' && c <= '9';
+            if (i == 0 ? !letter : !(letter || digit || c == '.')) {
+                return false;
+            }
+        }
+        return n > 0;
+    }
+
+    private static String read(InputStream in) {
+        if (in == null) {
+            return null;
+        }
+        try {
+            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+            byte[] buffer = new byte[1024];
+            for (int n = in.read(buffer); n >= 0; n = in.read(buffer)) {
+                bytes.write(buffer, 0, n);
+            }
+            return new String(bytes.toByteArray(), "UTF-8");
+        } catch (IOException e) {
+            // A file that cannot be read lists nothing.
+            return null;
+        } finally {
+            try {
+                in.close();
+            } catch (IOException e) {
+                // Nothing to do about a failed close of a stream already read.
+            }
+        }
+    }
+
+    /// The class of the provider `className`, or null when there is none.
+    private static Class<?> typeOf(String className) {
+        if (JdkHost.getRegistry() != null) {
+            return JdkHost.get().type(className);
+        }
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    /// A new instance of the provider `className`, or null when none can be made.
+    private static Object instantiate(String className) {
+        if (JdkHost.getRegistry() != null) {
+            return JdkHost.get().newInstance(className);
+        }
+        try {
+            return Class.forName(className).newInstance();
+        } catch (ClassNotFoundException e) {
+            return null;
+        } catch (InstantiationException e) {
+            return null;
+        } catch (IllegalAccessException e) {
+            return null;
+        }
+    }
+
+    /// The instance of `className` as this service's type, or null when it
+    /// could not be created or is not one. Tested rather than cast: a cast
+    /// that fails does not throw on every device.
+    @SuppressWarnings("unchecked")
+    private S create(String className) {
+        Object made = instantiate(className);
+        return service.isInstance(made) ? (S) made : null;
+    }
+
+    /// Whether a provider is left to create. Skips what cannot be one -- a
+    /// class that is not there, or is not of the service's type -- without
+    /// creating anything: `hasNext()` creates no provider in the JDK either.
+    private boolean more() {
+        List<String> all = entries();
+        while (next < all.size()) {
+            Class<?> type = typeOf(all.get(next));
+            if (type != null && service.isAssignableFrom(type)) {
+                return true;
+            }
+            next++;
+        }
+        return false;
+    }
+
+    /// The providers, each created when `next()` reaches it. The instances
+    /// an earlier iteration created come first, without being created again.
+    public Iterator<S> iterator() {
+        return new ProviderIterator<S>(this);
+    }
+
+    /// The iterator [#iterator()] answers. A named class: the class library
+    /// is translated without lambdas, and an anonymous one reads no better.
+    private static final class ProviderIterator<S> implements Iterator<S> {
+        private final ServiceLoader<S> loader;
+        private final int born;
+        private int index;
+
+        ProviderIterator(ServiceLoader<S> loader) {
+            this.loader = loader;
+            this.born = loader.generation;
+        }
+
+        /// After a reload this iterator's place means nothing: the instances
+        /// it walked are gone and the providers are counted from the start
+        /// again. Going on would create a provider it has already handed
+        /// out, so it refuses, as the JDK's does.
+        private void check() {
+            if (born != loader.generation) {
+                throw new ConcurrentModificationException();
+            }
+        }
+
+        public boolean hasNext() {
+            check();
+            return index < loader.instances.size() || loader.more();
+        }
+
+        public S next() {
+            check();
+            if (index < loader.instances.size()) {
+                return loader.instances.get(index++);
+            }
+            while (loader.more()) {
+                S made = loader.create(loader.entries().get(loader.next++));
+                if (made != null) {
+                    loader.instances.add(made);
+                    index = loader.instances.size();
+                    return made;
+                }
+            }
+            throw new NoSuchElementException();
+        }
+
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public void forEach(Consumer<? super S> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        Iterator<S> it = iterator();
+        while (it.hasNext()) {
+            action.accept(it.next());
+        }
+    }
+
+    /// The first provider, created if it has not been, or an empty optional
+    /// when the service has none.
+    public Optional<S> findFirst() {
+        Iterator<S> it = iterator();
+        return it.hasNext() ? Optional.<S>of(it.next()) : Optional.<S>empty();
+    }
+
+    /// The providers, none of them created: [Provider#get()] creates one,
+    /// anew on every call.
+    public Stream<Provider<S>> stream() {
+        List<Provider<S>> out = new ArrayList<Provider<S>>();
+        List<String> all = entries();
+        for (int i = 0; i < all.size(); i++) {
+            String className = all.get(i);
+            Class<?> type = typeOf(className);
+            if (type != null && service.isAssignableFrom(type)) {
+                out.add(new Lazy<S>(this, className, type));
+            }
+        }
+        return out.stream();
+    }
+
+    private static final class Lazy<S> implements Provider<S> {
+        private final ServiceLoader<S> loader;
+        private final String className;
+        private final Class<?> type;
+
+        Lazy(ServiceLoader<S> loader, String className, Class<?> type) {
+            this.loader = loader;
+            this.className = className;
+            this.type = type;
+        }
+
+        @SuppressWarnings("unchecked")
+        public Class<? extends S> type() {
+            return (Class<? extends S>) type;
+        }
+
+        public S get() {
+            S made = loader.create(className);
+            if (made == null) {
+                throw new ServiceConfigurationError(loader.service.getName() + ": Provider " + type.getName()
+                        + " could not be instantiated");
+            }
+            return made;
+        }
+    }
+
+    /// Forgets the providers created so far, so that the next iteration
+    /// creates them again.
+    public void reload() {
+        generation++;
+        instances.clear();
+        next = 0;
+        entries = null;
+    }
+
+    public String toString() {
+        return "java.util.ServiceLoader[" + service.getName() + "]";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Set.java b/vm/JavaAPI/src/java/util/Set.java
index 109c8df1aec..792b68ab1ba 100644
--- a/vm/JavaAPI/src/java/util/Set.java
+++ b/vm/JavaAPI/src/java/util/Set.java
@@ -193,4 +193,72 @@ public interface Set<E> extends Collection<E> {
      * @see Collection#toArray(Object[])
      */
     public <T> T[] toArray(T[] array);
+
+    /// An unmodifiable set of no elements.
+    static <E> Set<E> of() {
+        return ImmutableCollections.set(new Object[] {}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1) {
+        return ImmutableCollections.set(new Object[] {e1}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2) {
+        return ImmutableCollections.set(new Object[] {e1, e2}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9}, true);
+    }
+
+    /// An unmodifiable set of the given elements, none of which may be null and no two equal.
+    static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
+        return ImmutableCollections.set(new Object[] {e1, e2, e3, e4, e5, e6, e7, e8, e9, e10}, true);
+    }
+
+    /// An unmodifiable set of `elements`, none of which may be null and no two equal.
+    @SafeVarargs
+    static <E> Set<E> of(E... elements) {
+        return ImmutableCollections.set(elements, true);
+    }
+
+    /// An unmodifiable set of the elements of `collection`, which may not hold
+    /// null; `collection` itself when it is already such a set.
+    static <E> Set<E> copyOf(Collection<? extends E> collection) {
+        return ImmutableCollections.setCopyOf(collection);
+    }
+
 }
diff --git a/vm/JavaAPI/src/java/util/Spliterator.java b/vm/JavaAPI/src/java/util/Spliterator.java
new file mode 100644
index 00000000000..fda97ba2f96
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/Spliterator.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.Consumer;
+
+/// A source of elements that hands them out one at a time, which is what
+/// `java.util.stream.StreamSupport` makes a stream of.
+///
+/// Streams here are sequential, so nothing splits one: `trySplit` may
+/// answer null, and the ones this library makes always do.
+public interface Spliterator<T> {
+
+    /// The elements have a defined encounter order.
+    int ORDERED = 0x00000010;
+
+    /// No two elements are equal.
+    int DISTINCT = 0x00000001;
+
+    /// The elements are in the order [#getComparator()] gives.
+    int SORTED = 0x00000004;
+
+    /// [#estimateSize()] is exact.
+    int SIZED = 0x00000040;
+
+    /// No element is null.
+    int NONNULL = 0x00000100;
+
+    /// The source cannot be changed.
+    int IMMUTABLE = 0x00000400;
+
+    /// The source may be changed safely while it is read.
+    int CONCURRENT = 0x00001000;
+
+    /// The parts a split makes are sized too.
+    int SUBSIZED = 0x00004000;
+
+    /// Hands the next element to `action` and answers true, or answers false
+    /// when there is none.
+    boolean tryAdvance(Consumer<? super T> action);
+
+    /// Hands every remaining element to `action`, in order.
+    default void forEachRemaining(Consumer<? super T> action) {
+        while (tryAdvance(action)) {
+            // each call handed one element on
+        }
+    }
+
+    /// A part of the elements to be read separately, or null when this
+    /// source does not split.
+    Spliterator<T> trySplit();
+
+    /// How many elements remain, `Long.MAX_VALUE` when that is not known.
+    long estimateSize();
+
+    /// [#estimateSize()] when the source is [#SIZED], -1 otherwise.
+    default long getExactSizeIfKnown() {
+        return (characteristics() & SIZED) == 0 ? -1L : estimateSize();
+    }
+
+    /// The characteristics of this source, as a set of the bits declared here.
+    int characteristics();
+
+    /// Whether every bit of `characteristics` is one of this source's.
+    default boolean hasCharacteristics(int characteristics) {
+        return (characteristics() & characteristics) == characteristics;
+    }
+
+    /// The order of a [#SORTED] source, null for the natural order.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalStateException`: when the source is not sorted
+    default Comparator<? super T> getComparator() {
+        throw new IllegalStateException();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/Spliterators.java b/vm/JavaAPI/src/java/util/Spliterators.java
new file mode 100644
index 00000000000..615052437f0
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/Spliterators.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.util.function.Consumer;
+
+/// Ways to make a [Spliterator] of a collection or an iterator, and an
+/// iterator of a spliterator.
+public final class Spliterators {
+
+    private Spliterators() {
+    }
+
+    /// A spliterator of no elements.
+    public static <T> Spliterator<T> emptySpliterator() {
+        return new IteratorSpliterator<T>(null, Collections.<T>emptyList().iterator(), 0,
+                Spliterator.SIZED | Spliterator.SUBSIZED);
+    }
+
+    /// The elements of `c`. Its iterator is asked for when the first element
+    /// is, not now, so elements added in between are seen, as the JDK's
+    /// collections do.
+    public static <T> Spliterator<T> spliterator(Collection<? extends T> c, int characteristics) {
+        if (c == null) {
+            throw new NullPointerException();
+        }
+        return new IteratorSpliterator<T>(c, null, -1, sized(characteristics));
+    }
+
+    /// The `size` elements of `iterator`.
+    public static <T> Spliterator<T> spliterator(Iterator<? extends T> iterator, long size, int characteristics) {
+        if (iterator == null) {
+            throw new NullPointerException();
+        }
+        return new IteratorSpliterator<T>(null, iterator, size, sized(characteristics));
+    }
+
+    /// The elements of `iterator`, however many there are.
+    public static <T> Spliterator<T> spliteratorUnknownSize(Iterator<? extends T> iterator, int characteristics) {
+        if (iterator == null) {
+            throw new NullPointerException();
+        }
+        return new IteratorSpliterator<T>(null, iterator, Long.MAX_VALUE,
+                characteristics & ~(Spliterator.SIZED | Spliterator.SUBSIZED));
+    }
+
+    private static int sized(int characteristics) {
+        return (characteristics & Spliterator.CONCURRENT) == 0
+                ? characteristics | Spliterator.SIZED | Spliterator.SUBSIZED : characteristics;
+    }
+
+    /// The elements of `spliterator`, as an iterator.
+    public static <T> Iterator<T> iterator(final Spliterator<? extends T> spliterator) {
+        if (spliterator == null) {
+            throw new NullPointerException();
+        }
+        return new Unspliterated<T>(spliterator);
+    }
+
+    /// What [#iterator(Spliterator)] answers: an element taken ahead to
+    /// answer `hasNext`.
+    private static final class Unspliterated<T> implements Iterator<T>, Consumer<T> {
+        private final Spliterator<? extends T> spliterator;
+        private boolean ready;
+        private T next;
+
+        Unspliterated(Spliterator<? extends T> spliterator) {
+            this.spliterator = spliterator;
+        }
+
+        @Override
+        public void accept(T t) {
+            ready = true;
+            next = t;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (!ready) {
+                spliterator.tryAdvance(this);
+            }
+            return ready;
+        }
+
+        @Override
+        public T next() {
+            if (!ready && !hasNext()) {
+                throw new NoSuchElementException();
+            }
+            ready = false;
+            T out = next;
+            next = null;
+            return out;
+        }
+    }
+
+    /// A spliterator over an iterator, or over the iterator a collection
+    /// gives when it is first read.
+    private static final class IteratorSpliterator<T> implements Spliterator<T> {
+        private final Collection<? extends T> collection;
+        private Iterator<? extends T> it;
+        private long size;
+        private final int characteristics;
+
+        IteratorSpliterator(Collection<? extends T> collection, Iterator<? extends T> it, long size,
+                            int characteristics) {
+            this.collection = collection;
+            this.it = it;
+            this.size = size;
+            this.characteristics = characteristics;
+        }
+
+        private Iterator<? extends T> open() {
+            if (it == null) {
+                it = collection.iterator();
+                size = collection.size();
+            }
+            return it;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super T> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            Iterator<? extends T> source = open();
+            if (!source.hasNext()) {
+                return false;
+            }
+            action.accept(source.next());
+            return true;
+        }
+
+        @Override
+        public void forEachRemaining(Consumer<? super T> action) {
+            if (action == null) {
+                throw new NullPointerException();
+            }
+            Iterator<? extends T> source = open();
+            while (source.hasNext()) {
+                action.accept(source.next());
+            }
+        }
+
+        @Override
+        public Spliterator<T> trySplit() {
+            return null;
+        }
+
+        @Override
+        public long estimateSize() {
+            if (it == null) {
+                return collection.size();
+            }
+            return size;
+        }
+
+        @Override
+        public int characteristics() {
+            return characteristics;
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/StringJoiner.java b/vm/JavaAPI/src/java/util/StringJoiner.java
new file mode 100644
index 00000000000..a889db758a5
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/StringJoiner.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+/// `java.util.StringJoiner`: builds a sequence
+/// of strings separated by a delimiter, optionally between a prefix and a
+/// suffix.
+public final class StringJoiner {
+
+    private final String prefix;
+    private final String delimiter;
+    private final String suffix;
+    private StringBuilder value;
+    private String emptyValue;
+
+    public StringJoiner(CharSequence delimiter) {
+        this(delimiter, "", "");
+    }
+
+    public StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix) {
+        if (prefix == null) {
+            throw new NullPointerException("The prefix must not be null");
+        }
+        if (delimiter == null) {
+            throw new NullPointerException("The delimiter must not be null");
+        }
+        if (suffix == null) {
+            throw new NullPointerException("The suffix must not be null");
+        }
+        this.prefix = prefix.toString();
+        this.delimiter = delimiter.toString();
+        this.suffix = suffix.toString();
+        this.emptyValue = this.prefix + this.suffix;
+    }
+
+    public StringJoiner setEmptyValue(CharSequence emptyValue) {
+        if (emptyValue == null) {
+            throw new NullPointerException("The empty value must not be null");
+        }
+        this.emptyValue = emptyValue.toString();
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        if (value == null) {
+            return emptyValue;
+        }
+        if (suffix.length() == 0) {
+            return value.toString();
+        }
+        return value.toString() + suffix;
+    }
+
+    public StringJoiner add(CharSequence newElement) {
+        prepareBuilder().append(String.valueOf(newElement));
+        return this;
+    }
+
+    public StringJoiner merge(StringJoiner other) {
+        if (other == null) {
+            throw new NullPointerException();
+        }
+        if (other.value != null) {
+            // Taken before the builder is prepared, so that merging a joiner
+            // into itself appends its content once.
+            String content = other.value.toString().substring(other.prefix.length());
+            prepareBuilder().append(content);
+        }
+        return this;
+    }
+
+    private StringBuilder prepareBuilder() {
+        if (value != null) {
+            value.append(delimiter);
+        } else {
+            value = new StringBuilder().append(prefix);
+        }
+        return value;
+    }
+
+    public int length() {
+        return value != null ? value.length() + suffix.length() : emptyValue.length();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/UUID.java b/vm/JavaAPI/src/java/util/UUID.java
new file mode 100644
index 00000000000..a59d7e85b51
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/UUID.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import com.codename1.impl.JdkHost;
+
+/// A 128 bit identifier: its canonical text form, random (version 4)
+/// generation and name based (version 3) generation.
+///
+/// [#randomUUID()] draws its bits from the platform's secure random source
+/// through `JdkHost`. Where the platform installed none it falls back to a
+/// `Random` seeded from the clock, which keeps identifiers unique for every
+/// practical purpose but NOT unpredictable; an application that uses one as
+/// a secret should check that its platform provides secure random bytes.
+///
+/// [#nameUUIDFromBytes(byte\[\])] needs an MD5 digest from the platform and
+/// throws `UnsupportedOperationException` where there is none. The time based
+/// accessors (`timestamp`, `clockSequence`, `node`) are not provided.
+public final class UUID implements Comparable<UUID>, java.io.Serializable {
+
+    private static final long serialVersionUID = -4856846361193249489L;
+
+    private static final String HEX = "0123456789abcdef";
+
+    /// Made the first time the host has no secure source; see the class
+    /// description.
+    private static Random fallback;
+
+    private final long mostSigBits;
+    private final long leastSigBits;
+
+    /// An identifier from its two halves.
+    public UUID(long mostSigBits, long leastSigBits) {
+        this.mostSigBits = mostSigBits;
+        this.leastSigBits = leastSigBits;
+    }
+
+    /// A new version 4 identifier; see the class description for where its
+    /// randomness comes from.
+    public static UUID randomUUID() {
+        byte[] bits = new byte[16];
+        try {
+            JdkHost.get().randomBytes(bits);
+        } catch (UnsupportedOperationException noSecureSource) {
+            insecureBytes(bits);
+        }
+        // Version 4 in the high nibble of the seventh byte, the IETF variant
+        // in the top two bits of the ninth.
+        bits[6] = (byte) ((bits[6] & 0x0f) | 0x40);
+        bits[8] = (byte) ((bits[8] & 0x3f) | 0x80);
+        return fromBytes(bits);
+    }
+
+    private static synchronized void insecureBytes(byte[] out) {
+        if (fallback == null) {
+            fallback = new Random(System.currentTimeMillis() ^ (System.nanoTime() << 21));
+        }
+        for (int i = 0; i < out.length; i++) {
+            out[i] = (byte) fallback.nextInt(256);
+        }
+    }
+
+    /// The version 3 identifier of `name`: its MD5 digest, with the version
+    /// and variant bits set.
+    ///
+    /// #### Throws
+    ///
+    /// - `UnsupportedOperationException`: if the platform has no MD5 digest
+    public static UUID nameUUIDFromBytes(byte[] name) {
+        JdkHost.Digest md5 = JdkHost.get().digest("MD5");
+        if (md5 == null) {
+            throw new UnsupportedOperationException("MD5 not supported");
+        }
+        md5.update(name, 0, name.length);
+        byte[] bits = md5.digest();
+        bits[6] = (byte) ((bits[6] & 0x0f) | 0x30);
+        bits[8] = (byte) ((bits[8] & 0x3f) | 0x80);
+        return fromBytes(bits);
+    }
+
+    private static UUID fromBytes(byte[] bits) {
+        long most = 0;
+        long least = 0;
+        for (int i = 0; i < 8; i++) {
+            most = (most << 8) | (bits[i] & 0xff);
+        }
+        for (int i = 8; i < 16; i++) {
+            least = (least << 8) | (bits[i] & 0xff);
+        }
+        return new UUID(most, least);
+    }
+
+    /// Parses the text form [#toString()] writes: five groups of hexadecimal
+    /// digits separated by `-`. As in the JDK, a group may be shorter than
+    /// its full width, and one that is longer is not refused either: the
+    /// digits past its width are dropped, so `100000000-0-0-0-0` is the
+    /// nil UUID there and here. Only a group of more than sixteen digits,
+    /// which no `long` holds, is an error.
+    ///
+    /// #### Throws
+    ///
+    /// - `IllegalArgumentException`: if `name` is not in that form
+    public static UUID fromString(String name) {
+        long[] groups = new long[5];
+        int group = 0;
+        int digits = 0;
+        long value = 0;
+        int n = name.length();
+        for (int i = 0; i <= n; i++) {
+            char c = i < n ? name.charAt(i) : '-';
+            if (c == '-') {
+                if (digits == 0 || group > 4) {
+                    throw new IllegalArgumentException("Invalid UUID string: " + name);
+                }
+                groups[group++] = value;
+                value = 0;
+                digits = 0;
+                continue;
+            }
+            int d = hexDigit(c);
+            if (d < 0 || digits >= 16) {
+                throw new IllegalArgumentException("Invalid UUID string: " + name);
+            }
+            value = (value << 4) | d;
+            digits++;
+        }
+        if (group != 5) {
+            throw new IllegalArgumentException("Invalid UUID string: " + name);
+        }
+        long most = ((groups[0] & 0xffffffffL) << 32) | ((groups[1] & 0xffffL) << 16) | (groups[2] & 0xffffL);
+        long least = ((groups[3] & 0xffffL) << 48) | (groups[4] & 0xffffffffffffL);
+        return new UUID(most, least);
+    }
+
+    private static int hexDigit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'a' + 10;
+        }
+        if (c >= 'A' && c <= 'F') {
+            return c - 'A' + 10;
+        }
+        return -1;
+    }
+
+    /// The most significant 64 bits.
+    public long getMostSignificantBits() {
+        return mostSigBits;
+    }
+
+    /// The least significant 64 bits.
+    public long getLeastSignificantBits() {
+        return leastSigBits;
+    }
+
+    /// The version number: 4 for one made by [#randomUUID()], 3 for one made
+    /// by [#nameUUIDFromBytes(byte\[\])].
+    public int version() {
+        return (int) ((mostSigBits >> 12) & 0x0f);
+    }
+
+    /// The variant number: 2 for the IETF layout every identifier made here
+    /// has.
+    public int variant() {
+        return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder out = new StringBuilder(36);
+        hex(out, mostSigBits >> 32, 8);
+        out.append('-');
+        hex(out, mostSigBits >> 16, 4);
+        out.append('-');
+        hex(out, mostSigBits, 4);
+        out.append('-');
+        hex(out, leastSigBits >> 48, 4);
+        out.append('-');
+        hex(out, leastSigBits, 12);
+        return out.toString();
+    }
+
+    private static void hex(StringBuilder out, long value, int digits) {
+        for (int shift = (digits - 1) * 4; shift >= 0; shift -= 4) {
+            out.append(HEX.charAt((int) ((value >> shift) & 0xf)));
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        long hilo = mostSigBits ^ leastSigBits;
+        return ((int) (hilo >> 32)) ^ (int) hilo;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof UUID)) {
+            return false;
+        }
+        UUID other = (UUID) obj;
+        return mostSigBits == other.mostSigBits && leastSigBits == other.leastSigBits;
+    }
+
+    /// Orders by the most significant half, then the least, each as a signed
+    /// number -- the order the JDK defines.
+    @Override
+    public int compareTo(UUID val) {
+        if (mostSigBits != val.mostSigBits) {
+            return mostSigBits < val.mostSigBits ? -1 : 1;
+        }
+        if (leastSigBits != val.leastSigBits) {
+            return leastSigBits < val.leastSigBits ? -1 : 1;
+        }
+        return 0;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/WeakHashMap.java b/vm/JavaAPI/src/java/util/WeakHashMap.java
new file mode 100644
index 00000000000..47b336dd589
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/WeakHashMap.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util;
+
+import java.lang.ref.WeakReference;
+
+/// `java.util.WeakHashMap`: a map that does not
+/// keep its keys alive. An entry disappears once nothing else refers to its
+/// key, which is what lets desktop code hang data off a component -- a layout
+/// manager's cached constraints, say -- without ever removing it.
+///
+/// Keys are held through the device's `WeakReference` and compared with
+/// `equals`, as the JDK's are. Entries whose key is gone are dropped by the
+/// next change to the map, by [#size()], and by reads too, in a sweep that
+/// runs once per roughly as many reads as the map has keys -- so a cache that
+/// is only ever read still lets go of its values, at an amortized constant
+/// cost per read. There is no reference queue on a device, so nothing is
+/// dropped in between, and [#size()] counts only the entries still alive.
+///
+/// [#entrySet()], [#keySet()] and [#values()] are snapshots taken when they
+/// are called: removing through them, or through their iterators, does not
+/// change the map. The JDK's are live views; code that edits a weak map
+/// through a view is rare enough that the simpler contract is kept.
+///
+/// Like every shared JDK class here it is not synchronized, and neither is
+/// the JDK's.
+public class WeakHashMap<K, V> extends AbstractMap<K, V> {
+
+    /// Stands in for the null key, which a weak reference cannot tell from a
+    /// key that was collected.
+    private static final Object NULL_KEY = new Object();
+
+    /// The entries by their key's hash code.
+    private final HashMap<Integer, List<Cell<V>>> buckets = new HashMap<Integer, List<Cell<V>>>();
+
+    /// Reads since the last sweep; see the class description.
+    private int readsSinceExpunge;
+
+    private static final class Cell<V> {
+        @SuppressWarnings("rawtypes")
+        private final WeakReference key;
+        private V value;
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        Cell(Object key, V value) {
+            this.key = new WeakReference(key);
+            this.value = value;
+        }
+    }
+
+    public WeakHashMap() {
+        // Nothing to size: the buckets grow as they are used.
+    }
+
+    public WeakHashMap(int initialCapacity) {
+        if (initialCapacity < 0) {
+            throw new IllegalArgumentException("Illegal Initial Capacity: " + initialCapacity);
+        }
+    }
+
+    public WeakHashMap(int initialCapacity, float loadFactor) {
+        this(initialCapacity);
+        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
+            throw new IllegalArgumentException("Illegal Load factor: " + loadFactor);
+        }
+    }
+
+    public WeakHashMap(Map<? extends K, ? extends V> m) {
+        putAll(m);
+    }
+
+    private static Object mask(Object key) {
+        return key == null ? NULL_KEY : key;
+    }
+
+    /// The cell of `key` (already masked), or null.
+    private Cell<V> find(Object key) {
+        List<Cell<V>> bucket = buckets.get(Integer.valueOf(key.hashCode()));
+        if (bucket == null) {
+            return null;
+        }
+        for (int i = 0; i < bucket.size(); i++) {
+            Cell<V> c = bucket.get(i);
+            Object k = c.key.get();
+            if (k == key || (k != null && k.equals(key))) {
+                return c;
+            }
+        }
+        return null;
+    }
+
+    /// Sweeps from a read once enough reads have passed to pay for it.
+    private void expungeFromRead() {
+        if (++readsSinceExpunge > buckets.size() + 16) {
+            expunge();
+        }
+    }
+
+    /// Drops every entry whose key has been collected.
+    private void expunge() {
+        readsSinceExpunge = 0;
+        Iterator<List<Cell<V>>> all = buckets.values().iterator();
+        while (all.hasNext()) {
+            List<Cell<V>> bucket = all.next();
+            for (int i = bucket.size() - 1; i >= 0; i--) {
+                if (bucket.get(i).key.get() == null) {
+                    bucket.remove(i);
+                }
+            }
+            if (bucket.isEmpty()) {
+                all.remove();
+            }
+        }
+    }
+
+    @Override
+    public int size() {
+        expunge();
+        int n = 0;
+        for (List<Cell<V>> bucket : buckets.values()) {
+            n += bucket.size();
+        }
+        return n;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        expungeFromRead();
+        return find(mask(key)) != null;
+    }
+
+    @Override
+    public V get(Object key) {
+        expungeFromRead();
+        Cell<V> c = find(mask(key));
+        return c == null ? null : c.value;
+    }
+
+    @Override
+    public V put(K key, V value) {
+        Object k = mask(key);
+        Cell<V> c = find(k);
+        if (c != null) {
+            V old = c.value;
+            c.value = value;
+            return old;
+        }
+        expunge();
+        Integer hash = Integer.valueOf(k.hashCode());
+        List<Cell<V>> bucket = buckets.get(hash);
+        if (bucket == null) {
+            bucket = new ArrayList<Cell<V>>(1);
+            buckets.put(hash, bucket);
+        }
+        bucket.add(new Cell<V>(k, value));
+        return null;
+    }
+
+    @Override
+    public V remove(Object key) {
+        Object k = mask(key);
+        Integer hash = Integer.valueOf(k.hashCode());
+        List<Cell<V>> bucket = buckets.get(hash);
+        if (bucket == null) {
+            return null;
+        }
+        for (int i = 0; i < bucket.size(); i++) {
+            Cell<V> c = bucket.get(i);
+            Object held = c.key.get();
+            if (held == k || (held != null && held.equals(k))) {
+                bucket.remove(i);
+                if (bucket.isEmpty()) {
+                    buckets.remove(hash);
+                }
+                return c.value;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void clear() {
+        buckets.clear();
+    }
+
+    /// A snapshot of the live entries; see the class comment.
+    @Override
+    @SuppressWarnings("unchecked")
+    public Set<Map.Entry<K, V>> entrySet() {
+        Set<Map.Entry<K, V>> out = new HashSet<Map.Entry<K, V>>();
+        for (List<Cell<V>> bucket : buckets.values()) {
+            for (int i = 0; i < bucket.size(); i++) {
+                Cell<V> c = bucket.get(i);
+                Object k = c.key.get();
+                if (k != null) {
+                    out.add(new AbstractMap.SimpleEntry<K, V>(k == NULL_KEY ? null : (K) k, c.value));
+                }
+            }
+        }
+        return out;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/AbstractExecutorService.java b/vm/JavaAPI/src/java/util/concurrent/AbstractExecutorService.java
index ee0b93084f2..1553c7e7b25 100644
--- a/vm/JavaAPI/src/java/util/concurrent/AbstractExecutorService.java
+++ b/vm/JavaAPI/src/java/util/concurrent/AbstractExecutorService.java
@@ -1,10 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
+/// The [ExecutorService] methods that need nothing but `execute`: a
+/// subclass provides execution and the life cycle, and gets `submit`,
+/// `invokeAll` and `invokeAny` from here.
 public abstract class AbstractExecutorService implements ExecutorService {
 
+    public AbstractExecutorService() {
+    }
+
     protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
         return new FutureTask<T>(runnable, value);
     }
@@ -14,23 +43,234 @@ protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
     }
 
     public Future<?> submit(Runnable task) {
-        if (task == null) throw new NullPointerException();
+        if (task == null) {
+            throw new NullPointerException();
+        }
         RunnableFuture<Void> ftask = newTaskFor(task, null);
         execute(ftask);
         return ftask;
     }
 
     public <T> Future<T> submit(Runnable task, T result) {
-        if (task == null) throw new NullPointerException();
+        if (task == null) {
+            throw new NullPointerException();
+        }
         RunnableFuture<T> ftask = newTaskFor(task, result);
         execute(ftask);
         return ftask;
     }
 
     public <T> Future<T> submit(Callable<T> task) {
-        if (task == null) throw new NullPointerException();
+        if (task == null) {
+            throw new NullPointerException();
+        }
         RunnableFuture<T> ftask = newTaskFor(task);
         execute(ftask);
         return ftask;
     }
+
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        if (tasks == null) {
+            throw new NullPointerException();
+        }
+        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        boolean done = false;
+        try {
+            for (Callable<T> t : tasks) {
+                RunnableFuture<T> f = newTaskFor(t);
+                futures.add(f);
+                execute(f);
+            }
+            for (int i = 0; i < futures.size(); i++) {
+                Future<T> f = futures.get(i);
+                if (!f.isDone()) {
+                    try {
+                        f.get();
+                    } catch (CancellationException ignore) {
+                        // The future reports it to whoever asks.
+                    } catch (ExecutionException ignore) {
+                        // The future reports it to whoever asks.
+                    }
+                }
+            }
+            done = true;
+            return futures;
+        } finally {
+            if (!done) {
+                cancelAll(futures);
+            }
+        }
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException {
+        if (tasks == null || unit == null) {
+            throw new NullPointerException();
+        }
+        long deadline = BlockingWait.deadline(unit.toMillis(timeout));
+        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        boolean done = false;
+        try {
+            for (Callable<T> t : tasks) {
+                futures.add(newTaskFor(t));
+            }
+            for (int i = 0; i < futures.size(); i++) {
+                if (System.currentTimeMillis() >= deadline) {
+                    return futures;
+                }
+                execute((Runnable) futures.get(i));
+            }
+            for (int i = 0; i < futures.size(); i++) {
+                Future<T> f = futures.get(i);
+                if (!f.isDone()) {
+                    long left = deadline - System.currentTimeMillis();
+                    if (left <= 0) {
+                        return futures;
+                    }
+                    try {
+                        f.get(left, TimeUnit.MILLISECONDS);
+                    } catch (CancellationException ignore) {
+                        // The future reports it to whoever asks.
+                    } catch (ExecutionException ignore) {
+                        // The future reports it to whoever asks.
+                    } catch (TimeoutException timedOut) {
+                        return futures;
+                    }
+                }
+            }
+            done = true;
+            return futures;
+        } finally {
+            if (!done) {
+                cancelAll(futures);
+            }
+        }
+    }
+
+    /// Cancels every future that is not done, the LAST first.
+    ///
+    /// The order matters. Workers take tasks in the order they were
+    /// submitted, so cancelling from the front frees a worker -- a task
+    /// cancelled before it started returns at once -- which then starts the
+    /// next task in line before this loop has reached it: a task the caller
+    /// was promised would not run, runs. Cancelling from the back means
+    /// every task behind the one being cancelled is already cancelled.
+    static <T> void cancelAll(List<Future<T>> futures) {
+        for (int i = futures.size() - 1; i >= 0; i--) {
+            futures.get(i).cancel(true);
+        }
+    }
+
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+        try {
+            return doInvokeAny(tasks, BlockingWait.FOREVER);
+        } catch (TimeoutException cannotHappen) {
+            throw new ExecutionException(cannotHappen);
+        }
+    }
+
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        return doInvokeAny(tasks, BlockingWait.deadline(unit.toMillis(timeout)));
+    }
+
+    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks, long deadline)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        if (tasks == null) {
+            throw new NullPointerException();
+        }
+        int n = tasks.size();
+        if (n == 0) {
+            throw new IllegalArgumentException();
+        }
+        Finished finished = new Finished();
+        List<Future<T>> futures = new ArrayList<Future<T>>(n);
+        try {
+            for (Callable<T> t : tasks) {
+                if (t == null) {
+                    throw new NullPointerException();
+                }
+                AnyTask<T> f = new AnyTask<T>(t, finished);
+                futures.add(f);
+                execute(f);
+            }
+            ExecutionException last = null;
+            for (int seen = 0; seen < n; seen++) {
+                Future<?> f = finished.next(deadline);
+                if (f == null) {
+                    throw new TimeoutException();
+                }
+                try {
+                    @SuppressWarnings("unchecked")
+                    T value = ((Future<T>) f).get();
+                    return value;
+                } catch (ExecutionException e) {
+                    last = e;
+                } catch (CancellationException e) {
+                    last = new ExecutionException(e);
+                }
+            }
+            throw last;
+        } finally {
+            cancelAll(futures);
+        }
+    }
+
+    /// The futures of an `invokeAny` in the order they completed.
+    private static final class Finished {
+        private final List<Future<?>> queue = new ArrayList<Future<?>>();
+
+        void add(Future<?> f) {
+            synchronized (this) {
+                queue.add(f);
+                notifyAll();
+            }
+        }
+
+        /// The next completed future, or null when none completed by `deadline`.
+        Future<?> next(long deadline) throws InterruptedException {
+            synchronized (this) {
+                if (!queue.isEmpty()) {
+                    return queue.remove(0);
+                }
+            }
+            new Wait(this, deadline).await();
+            synchronized (this) {
+                return queue.isEmpty() ? null : queue.remove(0);
+            }
+        }
+
+        boolean isEmpty() {
+            return queue.isEmpty();
+        }
+    }
+
+    private static final class Wait extends BlockingWait {
+        private final Finished finished;
+
+        Wait(Finished finished, long deadline) {
+            super(finished, deadline);
+            this.finished = finished;
+        }
+
+        boolean ready() {
+            return !finished.isEmpty();
+        }
+    }
+
+    private static final class AnyTask<T> extends FutureTask<T> {
+        private final Finished finished;
+
+        AnyTask(Callable<T> c, Finished finished) {
+            super(c);
+            this.finished = finished;
+        }
+
+        protected void done() {
+            finished.add(this);
+        }
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/AsyncPool.java b/vm/JavaAPI/src/java/util/concurrent/AsyncPool.java
new file mode 100644
index 00000000000..91dafb16352
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/AsyncPool.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// The threads the `...Async` methods of [CompletableFuture] run on when
+/// they are given no executor.
+///
+/// A cached pool of daemon threads: a task goes to an idle worker or to a
+/// new one, so a task that waits for another never holds that one up -- a
+/// bounded pool deadlocks the moment every worker waits on work still in its
+/// queue. A worker ends after a minute without work, and none keeps a
+/// program from ending, as with the JDK's common pool.
+final class AsyncPool {
+
+    private static final Object LOCK = new Object();
+    private static Executor pool;
+
+    private AsyncPool() {
+    }
+
+    /// The pool, made when it is first needed.
+    static Executor get() {
+        synchronized (LOCK) {
+            if (pool == null) {
+                pool = new Executors.Pool(Integer.MAX_VALUE, 60000L, new Executors.DefaultThreadFactory(true));
+            }
+            return pool;
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/BlockingWait.java b/vm/JavaAPI/src/java/util/concurrent/BlockingWait.java
new file mode 100644
index 00000000000..735bc0d0336
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/BlockingWait.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import com.codename1.impl.JdkHost;
+
+/// A wait on a monitor until a condition holds or a deadline passes, for
+/// every blocking call in this package: `Future.get`, `awaitTermination`,
+/// `CountDownLatch.await` and the like.
+///
+/// The UI thread must never block. Called there, the wait runs through
+/// `JdkHost.blockUi`, which on a Codename One device is
+/// `Display.invokeAndBlock`: events keep being dispatched while it waits.
+/// Everywhere else -- a worker, the backend, a VM test -- it is a plain
+/// `Object.wait` on the caller's thread and is interruptible.
+///
+/// Whoever makes the condition true calls `notifyAll()` on the same monitor
+/// while holding it.
+abstract class BlockingWait implements Runnable {
+
+    /// A deadline that never comes.
+    static final long FOREVER = Long.MAX_VALUE;
+
+    private final Object monitor;
+    private final long deadline;
+    /// Set by [#run] when the wait was interrupted on the thread `blockUi`
+    /// lent it; read back by [#await] on the UI thread. Guarded by `this`.
+    private InterruptedException interrupted;
+
+    /// A wait on `monitor` until `deadline` ([#FOREVER], or a time from
+    /// [#deadline]).
+    BlockingWait(Object monitor, long deadline) {
+        this.monitor = monitor;
+        this.deadline = deadline;
+    }
+
+    /// The deadline `millis` from now, saturating at [#FOREVER]; a negative
+    /// duration is due now.
+    static long deadline(long millis) {
+        long now = System.currentTimeMillis();
+        if (millis <= 0) {
+            return now;
+        }
+        return millis >= FOREVER - now ? FOREVER : now + millis;
+    }
+
+    /// Whether the wait is over. Called holding the monitor.
+    abstract boolean ready();
+
+    /// Waits until [#ready] or the deadline, whichever is first. The caller
+    /// asks [#ready] again (or reads its own state) to learn which.
+    ///
+    /// A thread that is interrupted does not start to wait: the interrupt is
+    /// consumed by the `InterruptedException`, as in the JDK.
+    final void await() throws InterruptedException {
+        if (Thread.interrupted()) {
+            throw new InterruptedException();
+        }
+        JdkHost host = JdkHost.get();
+        if (!host.isUiThread()) {
+            block();
+            return;
+        }
+        host.blockUi(this);
+        InterruptedException e;
+        synchronized (this) {
+            e = interrupted;
+            interrupted = null;
+        }
+        if (e != null) {
+            throw e;
+        }
+    }
+
+    /// The wait, on the thread `JdkHost.blockUi` runs it on.
+    @Override
+    public final void run() {
+        try {
+            block();
+        } catch (InterruptedException e) {
+            synchronized (this) {
+                interrupted = e;
+            }
+        }
+    }
+
+    private void block() throws InterruptedException {
+        synchronized (monitor) {
+            while (!ready()) {
+                if (deadline == FOREVER) {
+                    monitor.wait();
+                } else {
+                    long left = deadline - System.currentTimeMillis();
+                    if (left <= 0) {
+                        return;
+                    }
+                    monitor.wait(left);
+                }
+            }
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/Callable.java b/vm/JavaAPI/src/java/util/concurrent/Callable.java
index 3168cf4082b..12897a5c521 100644
--- a/vm/JavaAPI/src/java/util/concurrent/Callable.java
+++ b/vm/JavaAPI/src/java/util/concurrent/Callable.java
@@ -1,5 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+/// A task that answers a result and may throw.
+///
+/// @param <V> the type of the result
 public interface Callable<V> {
+
+    /// Computes the result.
     V call() throws Exception;
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/CompletableFuture.java b/vm/JavaAPI/src/java/util/concurrent/CompletableFuture.java
new file mode 100644
index 00000000000..eef231277bc
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/CompletableFuture.java
@@ -0,0 +1,1144 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/// `java.util.concurrent.CompletableFuture` for the Codename One runtime.
+///
+/// A stage completes on the thread that completed the one before it, as in
+/// the JDK. The `...Async` methods without an executor run on a pool of
+/// daemon threads -- there is no fork-join pool here -- and never on the UI
+/// thread; a continuation that touches the user interface passes an executor
+/// that calls `Display.callSerially`, or calls it itself.
+///
+/// The class is safe to use from several threads at once: its state is
+/// kept in atomics, and every dependent action runs exactly once.
+///
+/// `get()` and `join()` on the UI thread wait through `JdkHost.blockUi`,
+/// which on a device is `Display.invokeAndBlock`: events keep being
+/// dispatched.
+///
+/// Exceptions travel as in the JDK: a stage that depends on a failed one
+/// fails with a [CompletionException] whose cause is the original; `get()`
+/// reports that cause in an [ExecutionException], `join()` throws the
+/// `CompletionException`, and both throw [CancellationException] after
+/// `cancel`.
+///
+/// Not provided: `obtrudeValue`, `obtrudeException`,
+/// `getNumberOfDependents`, `delayedExecutor` and `state()`.
+public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
+
+    /// A null result; null in [#result] is "not completed".
+    private static final Object NIL = new Object();
+
+    private static final class Failure {
+        final Throwable cause;
+
+        Failure(Throwable cause) {
+            this.cause = cause;
+        }
+    }
+
+    /// One action waiting for this future, in a stack of them.
+    private static final class Waiting {
+        final Runnable action;
+        Waiting next;
+
+        Waiting(Runnable action) {
+            this.action = action;
+        }
+    }
+
+    /// What the stack of waiting actions holds once they have been run.
+    private static final Waiting RELEASED = new Waiting(null);
+
+    private final AtomicReference<Object> result = new AtomicReference<Object>();
+    private final AtomicReference<Waiting> waiting = new AtomicReference<Waiting>();
+
+    public CompletableFuture() {
+    }
+
+    // ------------------------------------------------------------------
+    // Completion
+    // ------------------------------------------------------------------
+
+    private boolean completeRaw(Object outcome) {
+        if (!result.compareAndSet(null, outcome)) {
+            return false;
+        }
+        Waiting head = waiting.getAndSet(RELEASED);
+        // The stack is newest first; run in the order they were added.
+        Waiting ordered = null;
+        while (head != null && head != RELEASED) {
+            Waiting next = head.next;
+            head.next = ordered;
+            ordered = head;
+            head = next;
+        }
+        while (ordered != null) {
+            ordered.action.run();
+            ordered = ordered.next;
+        }
+        return true;
+    }
+
+    /// Runs `action` when this future is complete: now if it already is.
+    private void whenDone(Runnable action) {
+        Waiting w = new Waiting(action);
+        while (true) {
+            Waiting head = waiting.get();
+            if (head == RELEASED) {
+                action.run();
+                return;
+            }
+            w.next = head;
+            if (waiting.compareAndSet(head, w)) {
+                return;
+            }
+        }
+    }
+
+    private static CompletionException wrap(Throwable t) {
+        if (t instanceof CompletionException) {
+            return (CompletionException) t;
+        }
+        return new CompletionException(t);
+    }
+
+    private boolean fail(Throwable t) {
+        return completeRaw(new Failure(t));
+    }
+
+    /// Takes the outcome of a stage this one depends on.
+    private boolean relay(Object outcome) {
+        if (outcome instanceof Failure) {
+            return completeRaw(new Failure(wrap(((Failure) outcome).cause)));
+        }
+        return completeRaw(outcome);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <V> V value(Object outcome) {
+        return outcome == NIL ? null : (V) outcome;
+    }
+
+    private static Throwable failure(Object outcome) {
+        return outcome instanceof Failure ? ((Failure) outcome).cause : null;
+    }
+
+    public boolean complete(T value) {
+        return completeRaw(value == null ? NIL : value);
+    }
+
+    public boolean completeExceptionally(Throwable ex) {
+        if (ex == null) {
+            throw new NullPointerException();
+        }
+        return fail(ex);
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        boolean cancelled = result.get() == null && fail(new CancellationException());
+        return cancelled || isCancelled();
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return failure(result.get()) instanceof CancellationException;
+    }
+
+    @Override
+    public boolean isDone() {
+        return result.get() != null;
+    }
+
+    public boolean isCompletedExceptionally() {
+        return result.get() instanceof Failure;
+    }
+
+    // ------------------------------------------------------------------
+    // Reading the result
+    // ------------------------------------------------------------------
+
+    /// Waits for completion, for `millis` at most when that is not negative.
+    /// On the UI thread the wait goes through `JdkHost.blockUi`, so events
+    /// keep being dispatched; anywhere else it is interruptible.
+    private Object await(long millis) throws InterruptedException, TimeoutException {
+        Object outcome = result.get();
+        if (outcome != null) {
+            return outcome;
+        }
+        if (millis == 0) {
+            throw new TimeoutException();
+        }
+        final Signal signal = new Signal();
+        whenDone(signal);
+        new SignalWait(signal, millis < 0 ? BlockingWait.FOREVER : BlockingWait.deadline(millis)).await();
+        outcome = result.get();
+        if (outcome == null) {
+            throw new TimeoutException();
+        }
+        return outcome;
+    }
+
+    /// Raised when the future completes, for a thread waiting on it.
+    private static final class Signal implements Runnable {
+        private boolean raised;
+
+        public void run() {
+            synchronized (this) {
+                raised = true;
+                notifyAll();
+            }
+        }
+    }
+
+    private static final class SignalWait extends BlockingWait {
+        private final Signal signal;
+
+        SignalWait(Signal signal, long deadline) {
+            super(signal, deadline);
+            this.signal = signal;
+        }
+
+        boolean ready() {
+            return signal.raised;
+        }
+    }
+
+    private T reportGet(Object outcome) throws ExecutionException {
+        if (outcome instanceof Failure) {
+            Throwable t = ((Failure) outcome).cause;
+            if (t instanceof CancellationException) {
+                throw (CancellationException) t;
+            }
+            if (t instanceof CompletionException && t.getCause() != null) {
+                t = t.getCause();
+            }
+            throw new ExecutionException(t);
+        }
+        return CompletableFuture.<T>value(outcome);
+    }
+
+    private T reportJoin(Object outcome) {
+        if (outcome instanceof Failure) {
+            Throwable t = ((Failure) outcome).cause;
+            if (t instanceof CancellationException) {
+                throw (CancellationException) t;
+            }
+            throw wrap(t);
+        }
+        return CompletableFuture.<T>value(outcome);
+    }
+
+    @Override
+    public T get() throws InterruptedException, ExecutionException {
+        try {
+            return reportGet(await(-1));
+        } catch (TimeoutException cannotHappen) {
+            // A wait without a limit ends only once the future is done.
+            throw new IllegalStateException(cannotHappen.toString());
+        }
+    }
+
+    @Override
+    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        return reportGet(await(Math.max(0, unit.toMillis(timeout))));
+    }
+
+    /// The result, waiting for it; a failure is a [CompletionException].
+    public T join() {
+        Object outcome = result.get();
+        boolean interrupted = false;
+        while (outcome == null) {
+            try {
+                outcome = await(-1);
+            } catch (InterruptedException e) {
+                // join does not give up; it asks again, and hands the
+                // interrupt back to the thread once it is done.
+                interrupted = true;
+                outcome = result.get();
+            } catch (TimeoutException e) {
+                outcome = result.get();
+            }
+        }
+        if (interrupted) {
+            Thread.currentThread().interrupt();
+        }
+        return reportJoin(outcome);
+    }
+
+    public T getNow(T valueIfAbsent) {
+        Object outcome = result.get();
+        return outcome == null ? valueIfAbsent : reportJoin(outcome);
+    }
+
+    /// The result of a future that completed normally.
+    public T resultNow() {
+        Object outcome = result.get();
+        if (outcome == null) {
+            throw new IllegalStateException("Task has not completed");
+        }
+        if (outcome instanceof Failure) {
+            throw new IllegalStateException(isCancelled() ? "Task was cancelled"
+                    : "Task completed with exception");
+        }
+        return CompletableFuture.<T>value(outcome);
+    }
+
+    /// The exception of a future that failed.
+    public Throwable exceptionNow() {
+        Object outcome = result.get();
+        if (outcome == null) {
+            throw new IllegalStateException("Task has not completed");
+        }
+        if (!(outcome instanceof Failure)) {
+            throw new IllegalStateException("Task completed with a result");
+        }
+        if (isCancelled()) {
+            throw new IllegalStateException("Task was cancelled");
+        }
+        Throwable t = ((Failure) outcome).cause;
+        return t instanceof CompletionException && t.getCause() != null ? t.getCause() : t;
+    }
+
+    // ------------------------------------------------------------------
+    // Factories
+    // ------------------------------------------------------------------
+
+    /// The executor the `...Async` methods use when given none.
+    public Executor defaultExecutor() {
+        return pool();
+    }
+
+    private static Executor pool() {
+        return AsyncPool.get();
+    }
+
+    public <U> CompletableFuture<U> newIncompleteFuture() {
+        return new CompletableFuture<U>();
+    }
+
+    public static <U> CompletableFuture<U> completedFuture(U value) {
+        CompletableFuture<U> f = new CompletableFuture<U>();
+        f.complete(value);
+        return f;
+    }
+
+    public static <U> CompletableFuture<U> failedFuture(Throwable ex) {
+        if (ex == null) {
+            throw new NullPointerException();
+        }
+        CompletableFuture<U> f = new CompletableFuture<U>();
+        f.fail(ex);
+        return f;
+    }
+
+    public static <U> CompletionStage<U> completedStage(U value) {
+        return completedFuture(value);
+    }
+
+    public static <U> CompletionStage<U> failedStage(Throwable ex) {
+        return failedFuture(ex);
+    }
+
+    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
+        return supplyAsync(supplier, pool());
+    }
+
+    public static <U> CompletableFuture<U> supplyAsync(final Supplier<U> supplier, Executor executor) {
+        if (supplier == null || executor == null) {
+            throw new NullPointerException();
+        }
+        final CompletableFuture<U> f = new CompletableFuture<U>();
+        executor.execute(new Runnable() {
+            @Override
+            public void run() {
+                if (f.isDone()) {
+                    return;
+                }
+                U value;
+                try {
+                    value = supplier.get();
+                } catch (Throwable t) {
+                    f.fail(wrap(t));
+                    return;
+                }
+                f.complete(value);
+            }
+        });
+        return f;
+    }
+
+    public static CompletableFuture<Void> runAsync(Runnable runnable) {
+        return runAsync(runnable, pool());
+    }
+
+    public static CompletableFuture<Void> runAsync(final Runnable runnable, Executor executor) {
+        if (runnable == null) {
+            throw new NullPointerException();
+        }
+        return supplyAsync(new Supplier<Void>() {
+            @Override
+            public Void get() {
+                runnable.run();
+                return null;
+            }
+        }, executor);
+    }
+
+    public CompletableFuture<T> completeAsync(Supplier<? extends T> supplier) {
+        return completeAsync(supplier, pool());
+    }
+
+    public CompletableFuture<T> completeAsync(final Supplier<? extends T> supplier, Executor executor) {
+        if (supplier == null || executor == null) {
+            throw new NullPointerException();
+        }
+        executor.execute(new Runnable() {
+            @Override
+            public void run() {
+                if (isDone()) {
+                    return;
+                }
+                T value;
+                try {
+                    value = supplier.get();
+                } catch (Throwable t) {
+                    fail(wrap(t));
+                    return;
+                }
+                complete(value);
+            }
+        });
+        return this;
+    }
+
+    public static CompletableFuture<Void> allOf(final CompletableFuture<?>... futures) {
+        final CompletableFuture<Void> all = new CompletableFuture<Void>();
+        if (futures.length == 0) {
+            all.complete(null);
+            return all;
+        }
+        final AtomicInteger remaining = new AtomicInteger(futures.length);
+        Runnable one = new Runnable() {
+            @Override
+            public void run() {
+                if (remaining.decrementAndGet() != 0) {
+                    return;
+                }
+                for (CompletableFuture<?> f : futures) {
+                    Object outcome = f.result.get();
+                    if (outcome instanceof Failure) {
+                        all.relay(outcome);
+                        return;
+                    }
+                }
+                all.complete(null);
+            }
+        };
+        for (CompletableFuture<?> f : futures) {
+            f.whenDone(one);
+        }
+        return all;
+    }
+
+    public static CompletableFuture<Object> anyOf(CompletableFuture<?>... futures) {
+        final CompletableFuture<Object> any = new CompletableFuture<Object>();
+        for (final CompletableFuture<?> f : futures) {
+            f.whenDone(new Runnable() {
+                @Override
+                public void run() {
+                    any.relay(f.result.get());
+                }
+            });
+        }
+        return any;
+    }
+
+    // ------------------------------------------------------------------
+    // Time
+    // ------------------------------------------------------------------
+
+    /// Runs `action` after `millis`, unless this future completes first:
+    /// then the wait is given up, and holds neither a thread nor the
+    /// future. See [Delays].
+    private void later(long millis, Runnable action) {
+        final Delays.Handle wait = Delays.after(millis, action);
+        whenDone(new Runnable() {
+            @Override
+            public void run() {
+                wait.cancel();
+            }
+        });
+    }
+
+    /// Fails this future with a [TimeoutException] if it is not complete
+    /// when the time has passed.
+    public CompletableFuture<T> orTimeout(long timeout, TimeUnit unit) {
+        // The unit is required even when there is nothing left to time.
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (!isDone()) {
+            later(unit.toMillis(timeout), new Runnable() {
+                @Override
+                public void run() {
+                    fail(new TimeoutException());
+                }
+            });
+        }
+        return this;
+    }
+
+    public CompletableFuture<T> completeOnTimeout(final T value, long timeout, TimeUnit unit) {
+        // The unit is required even when there is nothing left to time.
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (!isDone()) {
+            later(unit.toMillis(timeout), new Runnable() {
+                @Override
+                public void run() {
+                    complete(value);
+                }
+            });
+        }
+        return this;
+    }
+
+    // ------------------------------------------------------------------
+    // Dependent stages
+    // ------------------------------------------------------------------
+
+    /// What a dependent stage does with the outcome of this one.
+    private interface Step<U> {
+        void run(Object outcome, CompletableFuture<U> stage) throws Throwable;
+    }
+
+    /// A new stage completed by `step` once this one is complete, on
+    /// `executor` when there is one and on the completing thread otherwise.
+    private <U> CompletableFuture<U> then(final Executor executor, final Step<U> step) {
+        final CompletableFuture<U> stage = newIncompleteFuture();
+        whenDone(new Runnable() {
+            @Override
+            public void run() {
+                final Object outcome = result.get();
+                Runnable body = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            step.run(outcome, stage);
+                        } catch (Throwable t) {
+                            stage.fail(wrap(t));
+                        }
+                    }
+                };
+                if (executor == null) {
+                    body.run();
+                    return;
+                }
+                try {
+                    executor.execute(body);
+                } catch (Throwable t) {
+                    stage.fail(wrap(t));
+                }
+            }
+        });
+        return stage;
+    }
+
+    private static Executor required(Executor executor) {
+        if (executor == null) {
+            throw new NullPointerException();
+        }
+        return executor;
+    }
+
+    private <U> CompletableFuture<U> apply(Executor executor, final Function<? super T, ? extends U> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<U>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<U> stage) {
+                if (outcome instanceof Failure) {
+                    stage.relay(outcome);
+                } else {
+                    stage.complete(fn.apply(CompletableFuture.<T>value(outcome)));
+                }
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn) {
+        return apply(null, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenApplyAsync(Function<? super T, ? extends U> fn) {
+        return apply(pool(), fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenApplyAsync(Function<? super T, ? extends U> fn, Executor executor) {
+        return apply(required(executor), fn);
+    }
+
+    private CompletableFuture<Void> accept(Executor executor, final Consumer<? super T> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return apply(executor, new Function<T, Void>() {
+            @Override
+            public Void apply(T value) {
+                action.accept(value);
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
+        return accept(null, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
+        return accept(pool(), action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor) {
+        return accept(required(executor), action);
+    }
+
+    private CompletableFuture<Void> run(Executor executor, final Runnable action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return apply(executor, new Function<T, Void>() {
+            @Override
+            public Void apply(T value) {
+                action.run();
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> thenRun(Runnable action) {
+        return run(null, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenRunAsync(Runnable action) {
+        return run(pool(), action);
+    }
+
+    @Override
+    public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor) {
+        return run(required(executor), action);
+    }
+
+    private <U> CompletableFuture<U> compose(Executor executor,
+            final Function<? super T, ? extends CompletionStage<U>> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<U>() {
+            @Override
+            public void run(Object outcome, final CompletableFuture<U> stage) {
+                if (outcome instanceof Failure) {
+                    stage.relay(outcome);
+                    return;
+                }
+                final CompletableFuture<U> inner = fn.apply(CompletableFuture.<T>value(outcome))
+                        .toCompletableFuture();
+                inner.whenDone(new Runnable() {
+                    @Override
+                    public void run() {
+                        stage.relay(inner.result.get());
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) {
+        return compose(null, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) {
+        return compose(pool(), fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,
+            Executor executor) {
+        return compose(required(executor), fn);
+    }
+
+    private <U> CompletableFuture<U> handled(Executor executor,
+            final BiFunction<? super T, Throwable, ? extends U> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<U>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<U> stage) {
+                if (outcome instanceof Failure) {
+                    stage.complete(fn.apply(null, ((Failure) outcome).cause));
+                } else {
+                    stage.complete(fn.apply(CompletableFuture.<T>value(outcome), null));
+                }
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) {
+        return handled(null, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) {
+        return handled(pool(), fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn,
+            Executor executor) {
+        return handled(required(executor), fn);
+    }
+
+    private CompletableFuture<T> completed(Executor executor, final BiConsumer<? super T, ? super Throwable> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<T>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<T> stage) throws Throwable {
+                if (outcome instanceof Failure) {
+                    try {
+                        action.accept(null, ((Failure) outcome).cause);
+                    } catch (Throwable t) {
+                        // The stage keeps the failure it was told about, and
+                        // since JDK 9 the action's own failure rides along as
+                        // a suppressed exception of it (JDK 8 dropped it).
+                        Throwable cause = ((Failure) outcome).cause;
+                        if (cause != null && cause != t) {
+                            cause.addSuppressed(t);
+                        }
+                        stage.relay(outcome);
+                        return;
+                    }
+                    stage.relay(outcome);
+                } else {
+                    action.accept(CompletableFuture.<T>value(outcome), null);
+                    stage.completeRaw(outcome);
+                }
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
+        return completed(null, action);
+    }
+
+    @Override
+    public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
+        return completed(pool(), action);
+    }
+
+    @Override
+    public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,
+            Executor executor) {
+        return completed(required(executor), action);
+    }
+
+    private CompletableFuture<T> recovered(Executor executor, final Function<Throwable, ? extends T> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(executor, new Step<T>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<T> stage) {
+                if (outcome instanceof Failure) {
+                    stage.complete(fn.apply(((Failure) outcome).cause));
+                } else {
+                    stage.completeRaw(outcome);
+                }
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) {
+        return recovered(null, fn);
+    }
+
+    public CompletableFuture<T> exceptionallyAsync(Function<Throwable, ? extends T> fn) {
+        return recovered(pool(), fn);
+    }
+
+    public CompletableFuture<T> exceptionallyAsync(Function<Throwable, ? extends T> fn, Executor executor) {
+        return recovered(required(executor), fn);
+    }
+
+    public CompletableFuture<T> exceptionallyCompose(final Function<Throwable, ? extends CompletionStage<T>> fn) {
+        if (fn == null) {
+            throw new NullPointerException();
+        }
+        return then(null, new Step<T>() {
+            @Override
+            public void run(Object outcome, final CompletableFuture<T> stage) {
+                if (!(outcome instanceof Failure)) {
+                    stage.completeRaw(outcome);
+                    return;
+                }
+                final CompletableFuture<T> inner = fn.apply(((Failure) outcome).cause).toCompletableFuture();
+                inner.whenDone(new Runnable() {
+                    @Override
+                    public void run() {
+                        stage.relay(inner.result.get());
+                    }
+                });
+            }
+        });
+    }
+
+    private <U, V> CompletableFuture<V> both(final Executor executor, CompletionStage<? extends U> other,
+            final BiFunction<? super T, ? super U, ? extends V> fn) {
+        if (fn == null || other == null) {
+            throw new NullPointerException();
+        }
+        final CompletableFuture<? extends U> second = other.toCompletableFuture();
+        final CompletableFuture<V> stage = newIncompleteFuture();
+        final AtomicInteger remaining = new AtomicInteger(2);
+        Runnable one = new Runnable() {
+            @Override
+            public void run() {
+                if (remaining.decrementAndGet() != 0) {
+                    return;
+                }
+                final Object a = result.get();
+                final Object b = second.result.get();
+                if (a instanceof Failure) {
+                    stage.relay(a);
+                    return;
+                }
+                if (b instanceof Failure) {
+                    stage.relay(b);
+                    return;
+                }
+                Runnable body = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            stage.complete(fn.apply(CompletableFuture.<T>value(a), CompletableFuture.<U>value(b)));
+                        } catch (Throwable t) {
+                            stage.fail(wrap(t));
+                        }
+                    }
+                };
+                if (executor == null) {
+                    body.run();
+                    return;
+                }
+                try {
+                    executor.execute(body);
+                } catch (Throwable t) {
+                    stage.fail(wrap(t));
+                }
+            }
+        };
+        whenDone(one);
+        second.whenDone(one);
+        return stage;
+    }
+
+    @Override
+    public <U, V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn) {
+        return both(null, other, fn);
+    }
+
+    @Override
+    public <U, V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn) {
+        return both(pool(), other, fn);
+    }
+
+    @Override
+    public <U, V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn, Executor executor) {
+        return both(required(executor), other, fn);
+    }
+
+    private <U> CompletableFuture<Void> acceptBoth(Executor executor, CompletionStage<? extends U> other,
+            final BiConsumer<? super T, ? super U> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return both(executor, other, new BiFunction<T, U, Void>() {
+            @Override
+            public Void apply(T a, U b) {
+                action.accept(a, b);
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action) {
+        return acceptBoth(null, other, action);
+    }
+
+    @Override
+    public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action) {
+        return acceptBoth(pool(), other, action);
+    }
+
+    @Override
+    public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action, Executor executor) {
+        return acceptBoth(required(executor), other, action);
+    }
+
+    private CompletableFuture<Void> runBoth(Executor executor, CompletionStage<?> other, final Runnable action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return both(executor, other, new BiFunction<T, Object, Void>() {
+            @Override
+            public Void apply(T a, Object b) {
+                action.run();
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other, Runnable action) {
+        return runBoth(null, other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action) {
+        return runBoth(pool(), other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor) {
+        return runBoth(required(executor), other, action);
+    }
+
+    private <U> CompletableFuture<U> either(final Executor executor, CompletionStage<? extends T> other,
+            final Function<? super T, U> fn) {
+        if (fn == null || other == null) {
+            throw new NullPointerException();
+        }
+        final CompletableFuture<? extends T> second = other.toCompletableFuture();
+        final CompletableFuture<U> stage = newIncompleteFuture();
+        final AtomicBoolean taken = new AtomicBoolean();
+        final CompletableFuture<T> self = this;
+        Runnable first = new Runnable() {
+            @Override
+            public void run() {
+                if (!taken.compareAndSet(false, true)) {
+                    return;
+                }
+                Object mine = self.result.get();
+                final Object outcome = mine != null ? mine : second.result.get();
+                if (outcome instanceof Failure) {
+                    stage.relay(outcome);
+                    return;
+                }
+                Runnable body = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            stage.complete(fn.apply(CompletableFuture.<T>value(outcome)));
+                        } catch (Throwable t) {
+                            stage.fail(wrap(t));
+                        }
+                    }
+                };
+                if (executor == null) {
+                    body.run();
+                    return;
+                }
+                try {
+                    executor.execute(body);
+                } catch (Throwable t) {
+                    stage.fail(wrap(t));
+                }
+            }
+        };
+        whenDone(first);
+        second.whenDone(first);
+        return stage;
+    }
+
+    @Override
+    public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) {
+        return either(null, other, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other,
+            Function<? super T, U> fn) {
+        return either(pool(), other, fn);
+    }
+
+    @Override
+    public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn,
+            Executor executor) {
+        return either(required(executor), other, fn);
+    }
+
+    private CompletableFuture<Void> acceptFirst(Executor executor, CompletionStage<? extends T> other,
+            final Consumer<? super T> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        return either(executor, other, new Function<T, Void>() {
+            @Override
+            public Void apply(T value) {
+                action.accept(value);
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) {
+        return acceptFirst(null, other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other,
+            Consumer<? super T> action) {
+        return acceptFirst(pool(), other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,
+            Executor executor) {
+        return acceptFirst(required(executor), other, action);
+    }
+
+    @SuppressWarnings("unchecked")
+    private CompletableFuture<Void> runFirst(Executor executor, CompletionStage<?> other, final Runnable action) {
+        if (action == null || other == null) {
+            throw new NullPointerException();
+        }
+        // Only that one of the two completed matters, not with what.
+        CompletableFuture<Object> mine = thenApply(new Function<T, Object>() {
+            @Override
+            public Object apply(T value) {
+                return value;
+            }
+        });
+        return mine.either(executor, (CompletionStage<Object>) other, new Function<Object, Void>() {
+            @Override
+            public Void apply(Object value) {
+                action.run();
+                return null;
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action) {
+        return runFirst(null, other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action) {
+        return runFirst(pool(), other, action);
+    }
+
+    @Override
+    public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action,
+            Executor executor) {
+        return runFirst(required(executor), other, action);
+    }
+
+    @Override
+    public CompletableFuture<T> toCompletableFuture() {
+        return this;
+    }
+
+    /// A new future that completes as this one does.
+    public CompletableFuture<T> copy() {
+        return then(null, new Step<T>() {
+            @Override
+            public void run(Object outcome, CompletableFuture<T> stage) {
+                stage.relay(outcome);
+            }
+        });
+    }
+
+    /// A stage that completes as this one does, and that completing does
+    /// not complete this one: a [#copy].
+    ///
+    /// **Not provided: the JDK's refusal.** There the stage answered is of
+    /// a class whose `complete`, `cancel`, `get` and the rest throw
+    /// `UnsupportedOperationException`, and whose `toCompletableFuture`
+    /// answers yet another copy. Here it is an ordinary future, as what
+    /// [#completedStage] and [#failedStage] answer is, so code that casts
+    /// the stage back to a `CompletableFuture`, or calls
+    /// `toCompletableFuture()` on it, and completes that, completes the
+    /// stage its dependents hang off instead of being refused. What the
+    /// method is called for holds either way: whoever is handed the stage
+    /// cannot complete, fail or cancel the future it was made from.
+    public CompletionStage<T> minimalCompletionStage() {
+        return copy();
+    }
+
+    @Override
+    public String toString() {
+        Object outcome = result.get();
+        String state = outcome == null ? "Not completed"
+                : outcome instanceof Failure ? "Completed exceptionally: " + ((Failure) outcome).cause
+                : "Completed normally";
+        return "CompletableFuture[" + state + "]";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/CompletionException.java b/vm/JavaAPI/src/java/util/concurrent/CompletionException.java
new file mode 100644
index 00000000000..f5dcae15bd3
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/CompletionException.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// `java.util.concurrent.CompletionException`: a stage failed, or the one
+/// it depended on did; the cause is the original exception.
+public class CompletionException extends RuntimeException {
+
+    protected CompletionException() {
+    }
+
+    protected CompletionException(String message) {
+        super(message);
+    }
+
+    public CompletionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public CompletionException(Throwable cause) {
+        super(cause == null ? null : cause.toString(), cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/CompletionStage.java b/vm/JavaAPI/src/java/util/concurrent/CompletionStage.java
new file mode 100644
index 00000000000..2b8ac5588d7
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/CompletionStage.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/// `java.util.concurrent.CompletionStage`: one step of a computation that
+/// others can be attached to. [CompletableFuture] is the implementation.
+public interface CompletionStage<T> {
+
+    <U> CompletionStage<U> thenApply(Function<? super T, ? extends U> fn);
+
+    <U> CompletionStage<U> thenApplyAsync(Function<? super T, ? extends U> fn);
+
+    <U> CompletionStage<U> thenApplyAsync(Function<? super T, ? extends U> fn, Executor executor);
+
+    CompletionStage<Void> thenAccept(Consumer<? super T> action);
+
+    CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
+
+    CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor);
+
+    CompletionStage<Void> thenRun(Runnable action);
+
+    CompletionStage<Void> thenRunAsync(Runnable action);
+
+    CompletionStage<Void> thenRunAsync(Runnable action, Executor executor);
+
+    <U, V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn);
+
+    <U, V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn);
+
+    <U, V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,
+            BiFunction<? super T, ? super U, ? extends V> fn, Executor executor);
+
+    <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action);
+
+    <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action);
+
+    <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
+            BiConsumer<? super T, ? super U> action, Executor executor);
+
+    CompletionStage<Void> runAfterBoth(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor);
+
+    <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn);
+
+    <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn);
+
+    <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn,
+            Executor executor);
+
+    CompletionStage<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action);
+
+    CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action);
+
+    CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action,
+            Executor executor);
+
+    CompletionStage<Void> runAfterEither(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action);
+
+    CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor);
+
+    <U> CompletionStage<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn);
+
+    <U> CompletionStage<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn);
+
+    <U> CompletionStage<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,
+            Executor executor);
+
+    <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
+
+    <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
+
+    <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);
+
+    CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
+
+    CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
+
+    CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor);
+
+    CompletionStage<T> exceptionally(Function<Throwable, ? extends T> fn);
+
+    CompletableFuture<T> toCompletableFuture();
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/ConcurrentHashMap.java b/vm/JavaAPI/src/java/util/concurrent/ConcurrentHashMap.java
new file mode 100644
index 00000000000..74d31511a89
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/ConcurrentHashMap.java
@@ -0,0 +1,671 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.AbstractCollection;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/// `java.util.concurrent.ConcurrentHashMap` for the Codename One runtime,
+/// over a `HashMap`.
+///
+/// It is safe to use from several threads at once. Every operation holds
+/// the map's monitor, so the compound operations (`putIfAbsent`,
+/// `computeIfAbsent`, `compute`, `merge`, ...) are atomic, and a mapping
+/// function runs while the monitor is held: it must not touch the map. Two
+/// threads never read and write at the same moment, which a device's few
+/// threads rarely notice and which keeps the class small.
+///
+/// It also keeps from the JDK class:
+///
+/// - `null` keys and values are rejected with `NullPointerException`.
+/// - Iterators never throw `ConcurrentModificationException`. Each iterates
+///   over the entries present when it was created, so a loop may add to and
+///   remove from the map it is walking; `Iterator.remove` and
+///   `Map.Entry.setValue` write through to the map.
+///
+/// The bulk parallel operations (`forEach(long, ...)`, `search`, `reduce`)
+/// and `forEachKey`/`forEachValue` are not provided.
+public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final HashMap<K, V> map;
+
+    public ConcurrentHashMap() {
+        map = new HashMap<K, V>();
+    }
+
+    public ConcurrentHashMap(int initialCapacity) {
+        if (initialCapacity < 0) {
+            throw new IllegalArgumentException();
+        }
+        map = new HashMap<K, V>(initialCapacity);
+    }
+
+    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
+        this(initialCapacity, loadFactor, 1);
+    }
+
+    public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
+        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) {
+            throw new IllegalArgumentException();
+        }
+        map = new HashMap<K, V>(initialCapacity);
+    }
+
+    public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
+        map = new HashMap<K, V>();
+        putAll(m);
+    }
+
+    private static void requireNonNull(Object o) {
+        if (o == null) {
+            throw new NullPointerException();
+        }
+    }
+
+    @Override
+    public synchronized int size() {
+        return map.size();
+    }
+
+    public synchronized long mappingCount() {
+        return map.size();
+    }
+
+    @Override
+    public synchronized boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public synchronized V get(Object key) {
+        requireNonNull(key);
+        return map.get(key);
+    }
+
+    @Override
+    public synchronized boolean containsKey(Object key) {
+        requireNonNull(key);
+        return map.containsKey(key);
+    }
+
+    @Override
+    public synchronized boolean containsValue(Object value) {
+        requireNonNull(value);
+        return map.containsValue(value);
+    }
+
+    public boolean contains(Object value) {
+        return containsValue(value);
+    }
+
+    @Override
+    public synchronized V put(K key, V value) {
+        requireNonNull(key);
+        requireNonNull(value);
+        return map.put(key, value);
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
+            put(e.getKey(), e.getValue());
+        }
+    }
+
+    @Override
+    public synchronized V remove(Object key) {
+        requireNonNull(key);
+        return map.remove(key);
+    }
+
+    @Override
+    public synchronized void clear() {
+        map.clear();
+    }
+
+    @Override
+    public V getOrDefault(Object key, V defaultValue) {
+        V v = get(key);
+        return v == null ? defaultValue : v;
+    }
+
+    @Override
+    public synchronized V putIfAbsent(K key, V value) {
+        requireNonNull(key);
+        requireNonNull(value);
+        V old = map.get(key);
+        if (old == null) {
+            map.put(key, value);
+        }
+        return old;
+    }
+
+    @Override
+    public synchronized boolean remove(Object key, Object value) {
+        requireNonNull(key);
+        if (value == null) {
+            return false;
+        }
+        V old = map.get(key);
+        if (old != null && old.equals(value)) {
+            map.remove(key);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public synchronized boolean replace(K key, V oldValue, V newValue) {
+        requireNonNull(key);
+        requireNonNull(oldValue);
+        requireNonNull(newValue);
+        V old = map.get(key);
+        if (old != null && old.equals(oldValue)) {
+            map.put(key, newValue);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public synchronized V replace(K key, V value) {
+        requireNonNull(key);
+        requireNonNull(value);
+        V old = map.get(key);
+        if (old != null) {
+            map.put(key, value);
+        }
+        return old;
+    }
+
+    @Override
+    public synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+        requireNonNull(key);
+        requireNonNull(mappingFunction);
+        V old = map.get(key);
+        if (old != null) {
+            return old;
+        }
+        V created = mappingFunction.apply(key);
+        if (created != null) {
+            map.put(key, created);
+        }
+        return created;
+    }
+
+    public synchronized V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        requireNonNull(key);
+        requireNonNull(remappingFunction);
+        V old = map.get(key);
+        if (old == null) {
+            return null;
+        }
+        V updated = remappingFunction.apply(key, old);
+        if (updated == null) {
+            map.remove(key);
+        } else {
+            map.put(key, updated);
+        }
+        return updated;
+    }
+
+    public synchronized V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        requireNonNull(key);
+        requireNonNull(remappingFunction);
+        V old = map.get(key);
+        V updated = remappingFunction.apply(key, old);
+        if (updated == null) {
+            if (old != null) {
+                map.remove(key);
+            }
+        } else {
+            map.put(key, updated);
+        }
+        return updated;
+    }
+
+    public synchronized V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+        requireNonNull(key);
+        requireNonNull(value);
+        requireNonNull(remappingFunction);
+        V old = map.get(key);
+        if (old == null) {
+            map.put(key, value);
+            return value;
+        }
+        V updated = remappingFunction.apply(old, value);
+        if (updated == null) {
+            map.remove(key);
+        } else {
+            map.put(key, updated);
+        }
+        return updated;
+    }
+
+    @Override
+    public void forEach(BiConsumer<? super K, ? super V> action) {
+        requireNonNull(action);
+        for (Map.Entry<K, V> e : snapshot()) {
+            action.accept(e.getKey(), e.getValue());
+        }
+    }
+
+    @Override
+    public synchronized void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+        requireNonNull(function);
+        for (Map.Entry<K, V> e : snapshot()) {
+            V updated = function.apply(e.getKey(), e.getValue());
+            requireNonNull(updated);
+            replace(e.getKey(), updated);
+        }
+    }
+
+    /// The entries present now, as entries that write through to this map.
+    /// Every iterator walks one of these, which is what lets a caller modify
+    /// the map while iterating it.
+    private synchronized List<Map.Entry<K, V>> snapshot() {
+        List<Map.Entry<K, V>> out = new ArrayList<Map.Entry<K, V>>(map.size());
+        for (Map.Entry<K, V> e : map.entrySet()) {
+            out.add(new WriteThroughEntry<K, V>(this, e.getKey(), e.getValue()));
+        }
+        return out;
+    }
+
+    /// The keys, as a view of this map. Compiled code names the JDK's return
+    /// type, `ConcurrentHashMap.KeySetView`, so that is what this returns.
+    @Override
+    public KeySetView<K, V> keySet() {
+        return new KeySetView<K, V>(this, null);
+    }
+
+    public KeySetView<K, V> keySet(V mappedValue) {
+        requireNonNull(mappedValue);
+        return new KeySetView<K, V>(this, mappedValue);
+    }
+
+    public static <K> KeySetView<K, Boolean> newKeySet() {
+        return new KeySetView<K, Boolean>(new ConcurrentHashMap<K, Boolean>(), Boolean.TRUE);
+    }
+
+    public static <K> KeySetView<K, Boolean> newKeySet(int initialCapacity) {
+        return new KeySetView<K, Boolean>(new ConcurrentHashMap<K, Boolean>(initialCapacity), Boolean.TRUE);
+    }
+
+    @Override
+    public Collection<V> values() {
+        return new ValuesView<K, V>(this);
+    }
+
+    @Override
+    public Set<Map.Entry<K, V>> entrySet() {
+        return new EntrySetView<K, V>(this);
+    }
+
+    public Enumeration<K> keys() {
+        return new IteratorEnumeration<K>(keySet().iterator());
+    }
+
+    public Enumeration<V> elements() {
+        return new IteratorEnumeration<V>(values().iterator());
+    }
+
+    private static final class WriteThroughEntry<K, V> implements Map.Entry<K, V> {
+        private final ConcurrentHashMap<K, V> owner;
+        private final K key;
+        private V value;
+
+        WriteThroughEntry(ConcurrentHashMap<K, V> owner, K key, V value) {
+            this.owner = owner;
+            this.key = key;
+            this.value = value;
+        }
+
+        @Override
+        public K getKey() {
+            return key;
+        }
+
+        @Override
+        public V getValue() {
+            return value;
+        }
+
+        @Override
+        public V setValue(V newValue) {
+            requireNonNull(newValue);
+            V old = value;
+            value = newValue;
+            owner.put(key, newValue);
+            return old;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+            Object otherKey = other.getKey();
+            Object otherValue = other.getValue();
+            return key.equals(otherKey) && value.equals(otherValue);
+        }
+
+        @Override
+        public int hashCode() {
+            return key.hashCode() ^ value.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return key + "=" + value;
+        }
+    }
+
+    /// Walks a snapshot of the entries; `remove` removes the key from the
+    /// live map.
+    private static final class SnapshotIterator<K, V> {
+        private final ConcurrentHashMap<K, V> owner;
+        private final List<Map.Entry<K, V>> entries;
+        private int next;
+        private Map.Entry<K, V> last;
+
+        SnapshotIterator(ConcurrentHashMap<K, V> owner) {
+            this.owner = owner;
+            this.entries = owner.snapshot();
+        }
+
+        boolean hasNext() {
+            return next < entries.size();
+        }
+
+        Map.Entry<K, V> nextEntry() {
+            if (next >= entries.size()) {
+                throw new NoSuchElementException();
+            }
+            last = entries.get(next++);
+            return last;
+        }
+
+        void remove() {
+            if (last == null) {
+                throw new IllegalStateException();
+            }
+            owner.remove(last.getKey());
+            last = null;
+        }
+    }
+
+    private static final class KeyIterator<K, V> implements Iterator<K> {
+        private final SnapshotIterator<K, V> it;
+
+        KeyIterator(ConcurrentHashMap<K, V> owner) {
+            it = new SnapshotIterator<K, V>(owner);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public K next() {
+            return it.nextEntry().getKey();
+        }
+
+        @Override
+        public void remove() {
+            it.remove();
+        }
+    }
+
+    private static final class ValueIterator<K, V> implements Iterator<V> {
+        private final SnapshotIterator<K, V> it;
+
+        ValueIterator(ConcurrentHashMap<K, V> owner) {
+            it = new SnapshotIterator<K, V>(owner);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public V next() {
+            return it.nextEntry().getValue();
+        }
+
+        @Override
+        public void remove() {
+            it.remove();
+        }
+    }
+
+    private static final class EntryIterator<K, V> implements Iterator<Map.Entry<K, V>> {
+        private final SnapshotIterator<K, V> it;
+
+        EntryIterator(ConcurrentHashMap<K, V> owner) {
+            it = new SnapshotIterator<K, V>(owner);
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public Map.Entry<K, V> next() {
+            return it.nextEntry();
+        }
+
+        @Override
+        public void remove() {
+            it.remove();
+        }
+    }
+
+    private static final class IteratorEnumeration<T> implements Enumeration<T> {
+        private final Iterator<T> it;
+
+        IteratorEnumeration(Iterator<T> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasMoreElements() {
+            return it.hasNext();
+        }
+
+        @Override
+        public T nextElement() {
+            return it.next();
+        }
+    }
+
+    private static final class ValuesView<K, V> extends AbstractCollection<V> {
+        private final ConcurrentHashMap<K, V> owner;
+
+        ValuesView(ConcurrentHashMap<K, V> owner) {
+            this.owner = owner;
+        }
+
+        @Override
+        public Iterator<V> iterator() {
+            return new ValueIterator<K, V>(owner);
+        }
+
+        @Override
+        public int size() {
+            return owner.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return o != null && owner.containsValue(o);
+        }
+
+        @Override
+        public void clear() {
+            owner.clear();
+        }
+    }
+
+    private static final class EntrySetView<K, V> extends AbstractSet<Map.Entry<K, V>> {
+        private final ConcurrentHashMap<K, V> owner;
+
+        EntrySetView(ConcurrentHashMap<K, V> owner) {
+            this.owner = owner;
+        }
+
+        @Override
+        public Iterator<Map.Entry<K, V>> iterator() {
+            return new EntryIterator<K, V>(owner);
+        }
+
+        @Override
+        public int size() {
+            return owner.size();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+            Object key = e.getKey();
+            Object value = e.getValue();
+            if (key == null || value == null) {
+                return false;
+            }
+            Object mine = owner.get(key);
+            return mine != null && mine.equals(value);
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            if (!(o instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
+            Object key = e.getKey();
+            Object value = e.getValue();
+            return key != null && value != null && owner.remove(key, value);
+        }
+
+        @Override
+        public void clear() {
+            owner.clear();
+        }
+    }
+
+    /// `java.util.concurrent.ConcurrentHashMap.KeySetView`: the keys of a
+    /// map as a set. A view created with a mapped value (`keySet(V)`,
+    /// `newKeySet()`) also accepts `add`, which maps the key to that value.
+    public static class KeySetView<K, V> extends AbstractSet<K> implements java.io.Serializable {
+
+        private static final long serialVersionUID = 1L;
+
+        private final ConcurrentHashMap<K, V> owner;
+        private final V value;
+
+        KeySetView(ConcurrentHashMap<K, V> owner, V value) {
+            this.owner = owner;
+            this.value = value;
+        }
+
+        /// The map this is a view of. It is the live map, as in the JDK:
+        /// the view exists to share it.
+        public ConcurrentHashMap<K, V> getMap() {
+            return owner;
+        }
+
+        public V getMappedValue() {
+            return value;
+        }
+
+        @Override
+        public Iterator<K> iterator() {
+            return new KeyIterator<K, V>(owner);
+        }
+
+        @Override
+        public int size() {
+            return owner.size();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return owner.isEmpty();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return owner.containsKey(o);
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            return owner.remove(o) != null;
+        }
+
+        @Override
+        public void clear() {
+            owner.clear();
+        }
+
+        @Override
+        public boolean add(K e) {
+            if (value == null) {
+                throw new UnsupportedOperationException();
+            }
+            return owner.putIfAbsent(e, value) == null;
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends K> c) {
+            boolean added = false;
+            for (K e : c) {
+                if (add(e)) {
+                    added = true;
+                }
+            }
+            return added;
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/ConcurrentMap.java b/vm/JavaAPI/src/java/util/concurrent/ConcurrentMap.java
index f21e669b160..d16859b9d4f 100644
--- a/vm/JavaAPI/src/java/util/concurrent/ConcurrentMap.java
+++ b/vm/JavaAPI/src/java/util/concurrent/ConcurrentMap.java
@@ -24,9 +24,8 @@
 
 import java.util.Map;
 
-/**
- * Added this for Kotlin
- */
+/// A map whose compound operations are atomic. The four methods it declares
+/// are default methods of `Map` as well; an implementation makes them atomic.
 public interface ConcurrentMap<K,V> extends Map<K,V> {
     public V putIfAbsent(K key, V value);
     public boolean remove(Object key, Object value);
diff --git a/vm/JavaAPI/src/java/util/concurrent/CopyOnWriteArrayList.java b/vm/JavaAPI/src/java/util/concurrent/CopyOnWriteArrayList.java
new file mode 100644
index 00000000000..dae26e4fbb0
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/CopyOnWriteArrayList.java
@@ -0,0 +1,572 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+import java.util.RandomAccess;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+
+/// `java.util.concurrent.CopyOnWriteArrayList` for the Codename One runtime.
+///
+/// Every mutation replaces the backing array with a modified copy, and an
+/// iterator keeps the array that was current when it was created. That is the
+/// property listener lists rely on, and it matters on a single thread as much
+/// as across threads: a listener that removes itself, or adds another, while
+/// the list is being walked to deliver an event neither disturbs the walk nor
+/// throws `ConcurrentModificationException`.
+///
+/// It is safe to use from several threads at once: mutations are made one
+/// at a time under an internal lock, and reads take the current array.
+///
+/// Iterators are read only, as in the JDK: `remove`, `set` and `add` on one
+/// throw `UnsupportedOperationException`. `subList` differs from the JDK: it
+/// returns an unmodifiable copy of the range instead of a live view.
+public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final Object[] EMPTY = new Object[0];
+
+    private Object[] array;
+    /// Guards [#array]; every mutation runs whole under it, so two threads
+    /// never both copy the same array and lose one of their changes.
+    private final transient Object lock = new Object();
+
+    private Object[] getArray() {
+        synchronized (lock) {
+            return array;
+        }
+    }
+
+    private void setArray(Object[] a) {
+        synchronized (lock) {
+            array = a;
+        }
+    }
+
+    public CopyOnWriteArrayList() {
+        setArray(EMPTY);
+    }
+
+    public CopyOnWriteArrayList(Collection<? extends E> c) {
+        setArray(c.toArray());
+    }
+
+    public CopyOnWriteArrayList(E[] toCopyIn) {
+        Object[] copy = new Object[toCopyIn.length];
+        System.arraycopy(toCopyIn, 0, copy, 0, copy.length);
+        setArray(copy);
+    }
+
+    private CopyOnWriteArrayList(Object[] shared, boolean marker) {
+        setArray(shared);
+    }
+
+    private static boolean same(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
+    }
+
+    private static int indexOf(Object o, Object[] elements, int from, int to) {
+        for (int i = from; i < to; i++) {
+            if (same(o, elements[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static int lastIndexOf(Object o, Object[] elements, int from) {
+        for (int i = from; i >= 0; i--) {
+            if (same(o, elements[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T element(Object[] elements, int index) {
+        return (T) elements[index];
+    }
+
+    @Override
+    public int size() {
+        return getArray().length;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return getArray().length == 0;
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        Object[] elements = getArray();
+        return indexOf(o, elements, 0, elements.length) >= 0;
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        Object[] elements = getArray();
+        return indexOf(o, elements, 0, elements.length);
+    }
+
+    public int indexOf(E e, int index) {
+        Object[] elements = getArray();
+        return indexOf(e, elements, index, elements.length);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        Object[] elements = getArray();
+        return lastIndexOf(o, elements, elements.length - 1);
+    }
+
+    public int lastIndexOf(E e, int index) {
+        return lastIndexOf(e, getArray(), index);
+    }
+
+    /// A list sharing this one's current array. Neither list ever writes to
+    /// an array it has published, so the two are independent from here on,
+    /// which is all a copy has to be.
+    @Override
+    public Object clone() {
+        return new CopyOnWriteArrayList<E>(getArray(), true);
+    }
+
+    @Override
+    public Object[] toArray() {
+        Object[] elements = getArray();
+        Object[] copy = new Object[elements.length];
+        System.arraycopy(elements, 0, copy, 0, elements.length);
+        return copy;
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        Object[] elements = getArray();
+        if (a.length < elements.length) {
+            // Only a collection can create an array of the caller's type
+            // without reflection.
+            return new ArrayList<Object>(Arrays.asList(elements)).toArray(a);
+        }
+        System.arraycopy(elements, 0, a, 0, elements.length);
+        if (a.length > elements.length) {
+            a[elements.length] = null;
+        }
+        return a;
+    }
+
+    @Override
+    public E get(int index) {
+        return element(getArray(), index);
+    }
+
+    @Override
+    public E set(int index, E element) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            E old = element(elements, index);
+            if (old != element) {
+                Object[] copy = new Object[elements.length];
+                System.arraycopy(elements, 0, copy, 0, elements.length);
+                copy[index] = element;
+                setArray(copy);
+            }
+            return old;
+        }
+    }
+
+    @Override
+    public boolean add(E e) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            Object[] copy = new Object[elements.length + 1];
+            System.arraycopy(elements, 0, copy, 0, elements.length);
+            copy[elements.length] = e;
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public void add(int index, E element) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            int len = elements.length;
+            if (index > len || index < 0) {
+                throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + len);
+            }
+            Object[] copy = new Object[len + 1];
+            System.arraycopy(elements, 0, copy, 0, index);
+            System.arraycopy(elements, index, copy, index + 1, len - index);
+            copy[index] = element;
+            setArray(copy);
+        }
+    }
+
+    @Override
+    public E remove(int index) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            int len = elements.length;
+            E old = element(elements, index);
+            Object[] copy = new Object[len - 1];
+            System.arraycopy(elements, 0, copy, 0, index);
+            System.arraycopy(elements, index + 1, copy, index, len - index - 1);
+            setArray(copy);
+            return old;
+        }
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        synchronized (lock) {
+            Object[] elements = getArray();
+            int index = indexOf(o, elements, 0, elements.length);
+            if (index < 0) {
+                return false;
+            }
+            remove(index);
+            return true;
+        }
+    }
+
+    public boolean addIfAbsent(E e) {
+        synchronized (lock) {
+            if (contains(e)) {
+                return false;
+            }
+            return add(e);
+        }
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        Object[] elements = getArray();
+        for (Object e : c) {
+            if (indexOf(e, elements, 0, elements.length) < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// Keeps the elements for which membership in `c` equals `keep`.
+    private boolean filter(Collection<?> c, boolean keep) {
+        synchronized (lock) {
+            if (c == null) {
+                throw new NullPointerException();
+            }
+            Object[] elements = getArray();
+            Object[] kept = new Object[elements.length];
+            int n = 0;
+            for (int i = 0; i < elements.length; i++) {
+                if (c.contains(elements[i]) == keep) {
+                    kept[n++] = elements[i];
+                }
+            }
+            if (n == elements.length) {
+                return false;
+            }
+            Object[] copy = new Object[n];
+            System.arraycopy(kept, 0, copy, 0, n);
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        return filter(c, false);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return filter(c, true);
+    }
+
+    public int addAllAbsent(Collection<? extends E> c) {
+        synchronized (lock) {
+            int added = 0;
+            for (E e : c) {
+                if (addIfAbsent(e)) {
+                    added++;
+                }
+            }
+            return added;
+        }
+    }
+
+    @Override
+    public void clear() {
+        synchronized (lock) {
+            setArray(EMPTY);
+        }
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        synchronized (lock) {
+            return addAll(getArray().length, c);
+        }
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends E> c) {
+        synchronized (lock) {
+            Object[] incoming = c.toArray();
+            Object[] elements = getArray();
+            int len = elements.length;
+            if (index > len || index < 0) {
+                throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + len);
+            }
+            if (incoming.length == 0) {
+                return false;
+            }
+            Object[] copy = new Object[len + incoming.length];
+            System.arraycopy(elements, 0, copy, 0, index);
+            System.arraycopy(incoming, 0, copy, index, incoming.length);
+            System.arraycopy(elements, index, copy, index + incoming.length, len - index);
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public void forEach(Consumer<? super E> action) {
+        if (action == null) {
+            throw new NullPointerException();
+        }
+        Object[] elements = getArray();
+        for (int i = 0; i < elements.length; i++) {
+            action.accept(CopyOnWriteArrayList.<E>element(elements, i));
+        }
+    }
+
+    @Override
+    public boolean removeIf(Predicate<? super E> filter) {
+        synchronized (lock) {
+            if (filter == null) {
+                throw new NullPointerException();
+            }
+            Object[] elements = getArray();
+            Object[] kept = new Object[elements.length];
+            int n = 0;
+            for (int i = 0; i < elements.length; i++) {
+                if (!filter.test(CopyOnWriteArrayList.<E>element(elements, i))) {
+                    kept[n++] = elements[i];
+                }
+            }
+            if (n == elements.length) {
+                return false;
+            }
+            Object[] copy = new Object[n];
+            System.arraycopy(kept, 0, copy, 0, n);
+            setArray(copy);
+            return true;
+        }
+    }
+
+    @Override
+    public void replaceAll(UnaryOperator<E> operator) {
+        synchronized (lock) {
+            if (operator == null) {
+                throw new NullPointerException();
+            }
+            Object[] elements = getArray();
+            Object[] copy = new Object[elements.length];
+            for (int i = 0; i < elements.length; i++) {
+                copy[i] = operator.apply(CopyOnWriteArrayList.<E>element(elements, i));
+            }
+            setArray(copy);
+        }
+    }
+
+    @Override
+    public void sort(Comparator<? super E> c) {
+        synchronized (lock) {
+            Object[] copy = toArray();
+            if (c == null) {
+                Arrays.sort(copy);
+            } else {
+                sortWith(copy, c);
+            }
+            setArray(copy);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> void sortWith(Object[] elements, Comparator<? super T> c) {
+        // Every element was added as an E, which is what T stands for here.
+        Arrays.sort((T[]) elements, c);
+    }
+
+    @Override
+    public String toString() {
+        Object[] elements = getArray();
+        StringBuilder sb = new StringBuilder();
+        sb.append('[');
+        for (int i = 0; i < elements.length; i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(elements[i] == this ? "(this Collection)" : String.valueOf(elements[i]));
+        }
+        return sb.append(']').toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof List)) {
+            return false;
+        }
+        Object[] elements = getArray();
+        Iterator<?> it = ((List<?>) o).iterator();
+        for (int i = 0; i < elements.length; i++) {
+            if (!it.hasNext() || !same(elements[i], it.next())) {
+                return false;
+            }
+        }
+        return !it.hasNext();
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 1;
+        Object[] elements = getArray();
+        for (int i = 0; i < elements.length; i++) {
+            hash = 31 * hash + (elements[i] == null ? 0 : elements[i].hashCode());
+        }
+        return hash;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new SnapshotIterator<E>(getArray(), 0);
+    }
+
+    @Override
+    public ListIterator<E> listIterator() {
+        return new SnapshotIterator<E>(getArray(), 0);
+    }
+
+    @Override
+    public ListIterator<E> listIterator(int index) {
+        Object[] elements = getArray();
+        if (index < 0 || index > elements.length) {
+            throw new IndexOutOfBoundsException("Index: " + index);
+        }
+        return new SnapshotIterator<E>(elements, index);
+    }
+
+    /// An unmodifiable copy of the range. The JDK returns a live view; code
+    /// that writes through a sublist of a copy-on-write list gets an
+    /// `UnsupportedOperationException` here instead of a lost update.
+    @Override
+    public List<E> subList(int fromIndex, int toIndex) {
+        Object[] elements = getArray();
+        if (fromIndex < 0 || toIndex > elements.length || fromIndex > toIndex) {
+            throw new IndexOutOfBoundsException();
+        }
+        List<E> out = new ArrayList<E>(toIndex - fromIndex);
+        for (int i = fromIndex; i < toIndex; i++) {
+            out.add(CopyOnWriteArrayList.<E>element(elements, i));
+        }
+        return Collections.unmodifiableList(out);
+    }
+
+    private static final class SnapshotIterator<E> implements ListIterator<E> {
+        private final Object[] snapshot;
+        private int cursor;
+
+        SnapshotIterator(Object[] snapshot, int cursor) {
+            this.snapshot = snapshot;
+            this.cursor = cursor;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return cursor < snapshot.length;
+        }
+
+        @Override
+        public boolean hasPrevious() {
+            return cursor > 0;
+        }
+
+        @Override
+        public E next() {
+            if (cursor >= snapshot.length) {
+                throw new NoSuchElementException();
+            }
+            return element(snapshot, cursor++);
+        }
+
+        @Override
+        public E previous() {
+            if (cursor <= 0) {
+                throw new NoSuchElementException();
+            }
+            return element(snapshot, --cursor);
+        }
+
+        @Override
+        public int nextIndex() {
+            return cursor;
+        }
+
+        @Override
+        public int previousIndex() {
+            return cursor - 1;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void set(E e) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void add(E e) {
+            throw new UnsupportedOperationException();
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/CopyOnWriteArraySet.java b/vm/JavaAPI/src/java/util/concurrent/CopyOnWriteArraySet.java
new file mode 100644
index 00000000000..6baaee33ec2
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/CopyOnWriteArraySet.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.AbstractSet;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/// `java.util.concurrent.CopyOnWriteArraySet` for the Codename One runtime:
+/// a set kept in a [CopyOnWriteArrayList], in the order its elements were
+/// added.
+///
+/// Every mutation replaces the backing array with a modified copy, and an
+/// iterator keeps the array that was current when it was created, so a
+/// listener that removes itself while the set is being walked neither
+/// disturbs the walk nor throws `ConcurrentModificationException`. Iterators
+/// are read only, as in the JDK.
+///
+/// It is as safe to use from several threads at once as the list it is
+/// kept in.
+public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final CopyOnWriteArrayList<E> al;
+
+    public CopyOnWriteArraySet() {
+        al = new CopyOnWriteArrayList<E>();
+    }
+
+    public CopyOnWriteArraySet(Collection<? extends E> c) {
+        al = new CopyOnWriteArrayList<E>();
+        al.addAllAbsent(c);
+    }
+
+    @Override
+    public int size() {
+        return al.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return al.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return al.contains(o);
+    }
+
+    @Override
+    public Object[] toArray() {
+        return al.toArray();
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        return al.toArray(a);
+    }
+
+    @Override
+    public void clear() {
+        al.clear();
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return al.remove(o);
+    }
+
+    @Override
+    public boolean add(E e) {
+        return al.addIfAbsent(e);
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        return al.containsAll(c);
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        return al.addAllAbsent(c) > 0;
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        return al.removeAll(c);
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        return al.retainAll(c);
+    }
+
+    /// The elements as they were when this was called, in the order they
+    /// were added. `remove` on the iterator throws
+    /// `UnsupportedOperationException`.
+    @Override
+    public Iterator<E> iterator() {
+        return al.iterator();
+    }
+
+    public boolean removeIf(Predicate<? super E> filter) {
+        return al.removeIf(filter);
+    }
+
+    @Override
+    public void forEach(Consumer<? super E> action) {
+        al.forEach(action);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/CountDownLatch.java b/vm/JavaAPI/src/java/util/concurrent/CountDownLatch.java
new file mode 100644
index 00000000000..7b16a74db90
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/CountDownLatch.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/// `java.util.concurrent.CountDownLatch`: threads wait until a count
+/// reaches zero. It is safe to use from any number of threads. Waiting on
+/// the UI thread goes through `JdkHost.blockUi`, which keeps events being
+/// dispatched.
+public class CountDownLatch {
+
+    private final AtomicLong count;
+    private final CompletableFuture<Boolean> open = new CompletableFuture<Boolean>();
+
+    public CountDownLatch(int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("count < 0");
+        }
+        this.count = new AtomicLong(count);
+        if (count == 0) {
+            open.complete(Boolean.TRUE);
+        }
+    }
+
+    public void countDown() {
+        while (true) {
+            long c = count.get();
+            if (c == 0) {
+                return;
+            }
+            if (count.compareAndSet(c, c - 1)) {
+                if (c == 1) {
+                    open.complete(Boolean.TRUE);
+                }
+                return;
+            }
+        }
+    }
+
+    public long getCount() {
+        return count.get();
+    }
+
+    public void await() throws InterruptedException {
+        try {
+            open.get();
+        } catch (ExecutionException e) {
+            // The latch is only ever opened; there is no failure to report.
+            return;
+        }
+    }
+
+    public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
+        try {
+            open.get(timeout, unit);
+            return true;
+        } catch (ExecutionException e) {
+            return true;
+        } catch (TimeoutException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "CountDownLatch[Count = " + count.get() + "]";
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/Delayed.java b/vm/JavaAPI/src/java/util/concurrent/Delayed.java
new file mode 100644
index 00000000000..b533f4b684d
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/Delayed.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// Something that is due after a delay, ordered by when it is due.
+public interface Delayed extends Comparable<Delayed> {
+
+    /// How long until this is due in `unit`; zero or negative once it is.
+    long getDelay(TimeUnit unit);
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/Delays.java b/vm/JavaAPI/src/java/util/concurrent/Delays.java
new file mode 100644
index 00000000000..7ee508930a3
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/Delays.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// Runs an action after a delay, for everything in this package that
+/// waits: the timeouts of [CompletableFuture] and the work of a
+/// [ScheduledPool]. One thread serves them all, and it ends when nothing
+/// is waiting.
+///
+/// #### Why not `java.util.Timer`
+///
+/// A device's `Timer` starts a thread for every task it is given, which
+/// sleeps for the whole delay; a cancelled task is not looked at again
+/// until that sleep is over. A request that sets a long timeout on a
+/// future which then completes at once -- the ordinary case of a timeout --
+/// left a thread asleep until the deadline, one per request, and enough of
+/// them use up the threads a process may have. Here a cancelled wait is
+/// taken out of the queue at once and holds nothing.
+///
+/// An action runs on the waiting thread, so it must be short: hand real
+/// work to a pool, as [ScheduledPool] does.
+final class Delays {
+
+    /// One wait: [#cancel] it to give it up.
+    static final class Handle {
+        private final long due;
+        private Runnable action;
+
+        Handle(long due, Runnable action) {
+            this.due = due;
+            this.action = action;
+        }
+
+        /// Gives the wait up. Does nothing once the action has started.
+        void cancel() {
+            synchronized (LOCK) {
+                action = null;
+                // Woken so that a thread with nothing left to wait for ends
+                // now and not at a deadline nobody is waiting on.
+                if (QUEUE.remove(this)) {
+                    LOCK.notifyAll();
+                }
+            }
+        }
+    }
+
+    private static final Object LOCK = new Object();
+    /// Ordered by the time each is due; equal times in the order given.
+    private static final List<Handle> QUEUE = new ArrayList<Handle>();
+    private static boolean running;
+
+    private Delays() {
+    }
+
+    /// Runs `action` once `millis` have passed.
+    static Handle after(long millis, Runnable action) {
+        // A delay too long to add to the clock (Long.MAX_VALUE as "never",
+        // say) is due at the end of time rather than wrapping into the past.
+        long now = System.currentTimeMillis();
+        long due = millis > Long.MAX_VALUE - now ? Long.MAX_VALUE : now + Math.max(0, millis);
+        Handle handle = new Handle(due, action);
+        synchronized (LOCK) {
+            int at = QUEUE.size();
+            while (at > 0 && QUEUE.get(at - 1).due > handle.due) {
+                at--;
+            }
+            QUEUE.add(at, handle);
+            if (running) {
+                LOCK.notifyAll();
+            } else {
+                running = true;
+                Thread t = new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+                        serve();
+                    }
+                }, "cn1-delays");
+                // A wait nobody gives up (a timeout of Long.MAX_VALUE) must
+                // not keep a program from ending, as the JDK's own delay
+                // thread does not.
+                t.setDaemon(true);
+                t.start();
+            }
+        }
+        return handle;
+    }
+
+    /// How many waits are queued: what a test asks to see that a cancelled
+    /// one is gone.
+    static int pending() {
+        synchronized (LOCK) {
+            return QUEUE.size();
+        }
+    }
+
+    private static void serve() {
+        while (true) {
+            Runnable action = next();
+            if (action == null) {
+                return;
+            }
+            try {
+                action.run();
+            } catch (Throwable t) {
+                // One action that fails must not end the thread the others
+                // wait on.
+                JdkHost.get().log(JdkHost.LOG_ERROR, "Exception in a delayed action: " + t, t);
+            }
+        }
+    }
+
+    /// The next action that is due, waiting for it; null when the queue is
+    /// empty, with the thread marked as gone under the same lock a new wait
+    /// would start one under.
+    private static Runnable next() {
+        synchronized (LOCK) {
+            while (true) {
+                if (QUEUE.isEmpty()) {
+                    running = false;
+                    return null;
+                }
+                Handle first = QUEUE.get(0);
+                long wait = first.due - System.currentTimeMillis();
+                if (wait <= 0) {
+                    QUEUE.remove(0);
+                    Runnable action = first.action;
+                    first.action = null;
+                    if (action != null) {
+                        return action;
+                    }
+                    continue;
+                }
+                try {
+                    LOCK.wait(wait);
+                } catch (InterruptedException e) {
+                    // Nothing interrupts this thread to stop it: the queue
+                    // says when it is done.
+                    continue;
+                }
+            }
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/Executor.java b/vm/JavaAPI/src/java/util/concurrent/Executor.java
index 4038aa587f9..eacd1807186 100644
--- a/vm/JavaAPI/src/java/util/concurrent/Executor.java
+++ b/vm/JavaAPI/src/java/util/concurrent/Executor.java
@@ -1,5 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+/// Runs submitted tasks, on a thread of its choosing.
 public interface Executor {
+
+    /// Runs `command` at some time in the future.
     void execute(Runnable command);
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/ExecutorService.java b/vm/JavaAPI/src/java/util/concurrent/ExecutorService.java
index cd8738f8ee4..10696bd4dba 100644
--- a/vm/JavaAPI/src/java/util/concurrent/ExecutorService.java
+++ b/vm/JavaAPI/src/java/util/concurrent/ExecutorService.java
@@ -1,20 +1,72 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
 import java.util.Collection;
 import java.util.List;
 
+/// An [Executor] that answers a [Future] for a submitted task and can be
+/// shut down. [Executors] creates the implementations;
+/// [AbstractExecutorService] provides everything but the execution itself.
 public interface ExecutorService extends Executor {
+
+    /// Stops accepting tasks. The ones already submitted still run.
     void shutdown();
+
+    /// Stops accepting tasks, drops the ones that have not started and
+    /// answers them, and interrupts the ones that are running.
     List<Runnable> shutdownNow();
+
     boolean isShutdown();
+
+    /// Whether the service was shut down and every task it accepted has
+    /// finished or been dropped.
     boolean isTerminated();
+
+    /// Waits until the service has terminated or the time is up, and answers
+    /// which of the two it was.
     boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
+
     <T> Future<T> submit(Callable<T> task);
+
     <T> Future<T> submit(Runnable task, T result);
+
     Future<?> submit(Runnable task);
-    // invokeAll and invokeAny are complex to implement correctly in a minimal way without full infrastructure
-    // but the test uses submit. I will skip invokeAll/Any for now or add stubs if needed.
-    // The previous copied interface had them. If I omit them, I break source compatibility with full JDK,
-    // but the requirement is "subset".
-    // I'll add them if tests fail or if I can implement them simply.
+
+    /// Runs every task and answers their futures, all of them done.
+    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
+
+    /// Runs every task and answers their futures once all are done or the
+    /// time is up; the ones not done by then are cancelled.
+    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException;
+
+    /// The result of one of the tasks that completed without failing; the
+    /// others are cancelled.
+    <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
+
+    /// As [#invokeAny(Collection)], giving up with a [TimeoutException] when
+    /// no task has succeeded in time.
+    <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException;
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/Executors.java b/vm/JavaAPI/src/java/util/concurrent/Executors.java
index 595142e5ad4..600d58c0ec5 100644
--- a/vm/JavaAPI/src/java/util/concurrent/Executors.java
+++ b/vm/JavaAPI/src/java/util/concurrent/Executors.java
@@ -1,131 +1,379 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+import com.codename1.impl.JdkHost;
+
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 
+/// Factories for the executor services.
+///
+/// #### Where a task runs
+///
+/// On the pool's own threads, never on the UI thread. A task that touches
+/// the user interface hands that part back, the way desktop code does with
+/// `SwingUtilities.invokeLater` or `Platform.runLater`.
+///
+/// Workers are started when a task first needs one and share one queue: a
+/// task goes to whichever worker is free. A fixed pool keeps its workers
+/// until it is shut down; a cached pool starts one whenever none is free and
+/// lets one go after a minute without work, as the JDK's do. The overloads
+/// that take a [ThreadFactory] make their workers with it.
+///
+/// #### Waiting
+///
+/// `Future.get()` and `awaitTermination` on the UI thread wait through
+/// `JdkHost.blockUi`, so events keep being dispatched.
+///
+/// The work stealing pools are fixed pools.
 public class Executors {
 
+    /// How long a cached pool's idle worker waits for work before it ends.
+    private static final long CACHED_KEEP_ALIVE_MILLIS = 60000L;
+
+    /// How many workers a work stealing pool without a size has.
+    private static final int WORK_STEALING_WORKERS = 4;
+
+    private Executors() {
+    }
+
     public static ExecutorService newFixedThreadPool(int nThreads) {
-        return new SimpleThreadPool(nThreads);
+        return newFixedThreadPool(nThreads, defaultThreadFactory());
+    }
+
+    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
+        if (nThreads <= 0) {
+            throw new IllegalArgumentException();
+        }
+        return new Pool(nThreads, 0, requireFactory(threadFactory));
     }
 
     public static ExecutorService newSingleThreadExecutor() {
-        return new SimpleThreadPool(1);
+        return newSingleThreadExecutor(defaultThreadFactory());
     }
 
+    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
+        return new Pool(1, 0, requireFactory(threadFactory));
+    }
+
+    public static ExecutorService newCachedThreadPool() {
+        return newCachedThreadPool(defaultThreadFactory());
+    }
+
+    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
+        return new Pool(Integer.MAX_VALUE, CACHED_KEEP_ALIVE_MILLIS, requireFactory(threadFactory));
+    }
+
+    /// A pool for work that splits itself up: here, a fixed pool.
+    public static ExecutorService newWorkStealingPool() {
+        return newFixedThreadPool(WORK_STEALING_WORKERS);
+    }
+
+    public static ExecutorService newWorkStealingPool(int parallelism) {
+        return newFixedThreadPool(parallelism);
+    }
+
+    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
+        return newScheduledThreadPool(corePoolSize, defaultThreadFactory());
+    }
+
+    /// Zero is accepted, as the JDK accepts it: a zero sized scheduled pool
+    /// still starts a worker for the first task it is given.
+    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {
+        if (corePoolSize < 0) {
+            throw new IllegalArgumentException();
+        }
+        return new ScheduledPool(new Pool(Math.max(1, corePoolSize), 0, requireFactory(threadFactory)));
+    }
+
+    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
+        return newScheduledThreadPool(1);
+    }
+
+    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
+        return newScheduledThreadPool(1, threadFactory);
+    }
+
+    /// The factory the executors use by default: non-daemon threads named
+    /// `pool-N-thread-M`.
+    public static ThreadFactory defaultThreadFactory() {
+        return new DefaultThreadFactory(false);
+    }
+
+    /// A `Callable` that runs `task` and answers `result`.
     public static <T> Callable<T> callable(Runnable task, T result) {
-        if (task == null) throw new NullPointerException();
+        if (task == null) {
+            throw new NullPointerException();
+        }
         return new RunnableAdapter<T>(task, result);
     }
 
     public static Callable<Object> callable(Runnable task) {
-        if (task == null) throw new NullPointerException();
-        return new RunnableAdapter<Object>(task, null);
+        return callable(task, null);
+    }
+
+    private static ThreadFactory requireFactory(ThreadFactory threadFactory) {
+        if (threadFactory == null) {
+            throw new NullPointerException();
+        }
+        return threadFactory;
     }
 
     static final class RunnableAdapter<T> implements Callable<T> {
-        final Runnable task;
-        final T result;
+        private final Runnable task;
+        private final T result;
+
         RunnableAdapter(Runnable task, T result) {
             this.task = task;
             this.result = result;
         }
+
         public T call() {
             task.run();
             return result;
         }
     }
 
-    static class SimpleThreadPool extends AbstractExecutorService {
-        private final List<Runnable> workQueue = new ArrayList<Runnable>();
-        private final List<Worker> workers = new ArrayList<Worker>();
-        private boolean isShutdown;
+    static final class DefaultThreadFactory implements ThreadFactory {
+        private static final Object COUNT_LOCK = new Object();
+        private static int pools;
+
+        private final String prefix;
+        private final boolean daemon;
+        private int threads;
 
-        SimpleThreadPool(int nThreads) {
-            for (int i = 0; i < nThreads; i++) {
-                Worker w = new Worker();
-                workers.add(w);
-                w.start();
+        DefaultThreadFactory(boolean daemon) {
+            int n;
+            synchronized (COUNT_LOCK) {
+                n = ++pools;
             }
+            this.prefix = "pool-" + n + "-thread-";
+            this.daemon = daemon;
+        }
+
+        public Thread newThread(Runnable r) {
+            int n;
+            synchronized (this) {
+                n = ++threads;
+            }
+            Thread t = new Thread(r, prefix + n);
+            if (daemon) {
+                t.setDaemon(true);
+            }
+            return t;
+        }
+    }
+
+    /// The thread pool every factory above hands out: workers started on
+    /// demand, up to `maxWorkers`, sharing one queue. Everything is guarded
+    /// by the queue's monitor; the backend submits from many threads at once.
+    static final class Pool extends AbstractExecutorService {
+        private final LinkedList<Runnable> queue = new LinkedList<Runnable>();
+        private final List<Thread> workers = new ArrayList<Thread>();
+        private final int maxWorkers;
+        /// How long an idle worker waits for work before ending; 0 is forever.
+        private final long keepAliveMillis;
+        private final ThreadFactory factory;
+        /// Workers waiting for work.
+        private int idle;
+        private boolean shutdown;
+        /// Set by shutdownNow: workers stop without draining the queue.
+        private boolean stop;
+
+        Pool(int maxWorkers, long keepAliveMillis, ThreadFactory factory) {
+            this.maxWorkers = maxWorkers;
+            this.keepAliveMillis = keepAliveMillis;
+            this.factory = factory;
         }
 
         public void execute(Runnable command) {
-            synchronized(workQueue) {
-                if (isShutdown) throw new RejectedExecutionException();
-                workQueue.add(command);
-                workQueue.notify();
+            if (command == null) {
+                throw new NullPointerException();
+            }
+            Thread started = null;
+            synchronized (queue) {
+                if (shutdown) {
+                    throw new RejectedExecutionException("The executor has been shut down");
+                }
+                queue.add(command);
+                if (queue.size() > idle && workers.size() < maxWorkers) {
+                    Thread t = factory.newThread(new Worker());
+                    if (t == null) {
+                        if (workers.isEmpty()) {
+                            queue.removeLast();
+                            throw new RejectedExecutionException("The thread factory made no thread");
+                        }
+                    } else {
+                        workers.add(t);
+                        started = t;
+                    }
+                } else {
+                    queue.notify();
+                }
+            }
+            if (started != null) {
+                started.start();
             }
         }
 
         public void shutdown() {
-            synchronized(workQueue) {
-                isShutdown = true;
-                workQueue.notifyAll();
+            synchronized (queue) {
+                shutdown = true;
+                queue.notifyAll();
             }
         }
 
         public List<Runnable> shutdownNow() {
             List<Runnable> pending;
-            synchronized(workQueue) {
-                isShutdown = true;
-                pending = new ArrayList<Runnable>(workQueue);
-                workQueue.clear();
-                workQueue.notifyAll();
+            List<Thread> running;
+            synchronized (queue) {
+                shutdown = true;
+                stop = true;
+                pending = new ArrayList<Runnable>(queue);
+                queue.clear();
+                running = new ArrayList<Thread>(workers);
+                queue.notifyAll();
+            }
+            for (int i = 0; i < running.size(); i++) {
+                running.get(i).interrupt();
             }
             return pending;
         }
 
         public boolean isShutdown() {
-            synchronized(workQueue) {
-                return isShutdown;
+            synchronized (queue) {
+                return shutdown;
             }
         }
 
         public boolean isTerminated() {
-            synchronized(workQueue) {
-                if (!isShutdown || !workQueue.isEmpty()) return false;
-                for (Worker w : workers) {
-                    if (w.isAlive()) return false;
-                }
-                return true;
+            synchronized (queue) {
+                return terminated();
             }
         }
 
+        /// Called holding the queue's monitor.
+        boolean terminated() {
+            return shutdown && workers.isEmpty() && queue.isEmpty();
+        }
+
         public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
-            long millis = unit.toMillis(timeout);
-            long end = System.currentTimeMillis() + millis;
-            while (!isTerminated()) {
-                long delay = end - System.currentTimeMillis();
-                if (delay <= 0) return false;
-                Thread.sleep(Math.min(delay, 100));
+            if (unit == null) {
+                throw new NullPointerException();
             }
-            return true;
+            if (!isTerminated()) {
+                new Termination(this, BlockingWait.deadline(unit.toMillis(timeout))).await();
+            }
+            return isTerminated();
         }
 
-        class Worker extends Thread {
-            public void run() {
+        /// The next task for the calling worker, or null when it is to end;
+        /// a worker that ends is taken off the list here, under the lock.
+        Runnable next(Thread self) {
+            synchronized (queue) {
                 while (true) {
-                    Runnable task = null;
-                    synchronized(workQueue) {
-                        while (workQueue.isEmpty() && !isShutdown) {
-                            try {
-                                workQueue.wait();
-                            } catch (InterruptedException e) {}
-                        }
-                        if (workQueue.isEmpty() && isShutdown) {
-                            return;
-                        }
-                        task = workQueue.remove(0);
+                    if (stop || (queue.isEmpty() && shutdown)) {
+                        retire(self);
+                        return null;
+                    }
+                    if (!queue.isEmpty()) {
+                        return queue.removeFirst();
                     }
-                    if (task != null) {
-                        try {
-                            task.run();
-                        } catch (RuntimeException e) {
-                            e.printStackTrace();
+                    idle++;
+                    boolean timedOut = false;
+                    try {
+                        if (keepAliveMillis > 0) {
+                            long before = System.currentTimeMillis();
+                            queue.wait(keepAliveMillis);
+                            timedOut = System.currentTimeMillis() - before >= keepAliveMillis;
+                        } else {
+                            queue.wait();
                         }
+                    } catch (InterruptedException e) {
+                        // shutdownNow interrupts; the flags above say what to do.
+                        timedOut = false;
+                    } finally {
+                        idle--;
+                    }
+                    if (timedOut && queue.isEmpty()) {
+                        retire(self);
+                        return null;
+                    }
+                }
+            }
+        }
+
+        private void retire(Thread self) {
+            workers.remove(self);
+            if (terminated()) {
+                queue.notifyAll();
+            }
+        }
+
+        /// Whether shutdownNow has been called; read by a worker between tasks.
+        boolean stopping() {
+            synchronized (queue) {
+                return stop;
+            }
+        }
+
+        final class Worker implements Runnable {
+            public void run() {
+                Thread self = Thread.currentThread();
+                while (true) {
+                    Runnable task = next(self);
+                    if (task == null) {
+                        return;
+                    }
+                    // An interrupt meant for the last task, or for an idle
+                    // wait, must not reach this one -- unless the pool is
+                    // stopping, which is what the interrupt then says.
+                    if (!stopping()) {
+                        Thread.interrupted();
+                    }
+                    try {
+                        task.run();
+                    } catch (Throwable t) {
+                        JdkHost.get().log(JdkHost.LOG_ERROR,
+                                "Exception in thread \"" + self.getName() + "\" " + t, t);
                     }
                 }
             }
         }
+
+        private static final class Termination extends BlockingWait {
+            private final Pool pool;
+
+            Termination(Pool pool, long deadline) {
+                super(pool.queue, deadline);
+                this.pool = pool;
+            }
+
+            boolean ready() {
+                return pool.terminated();
+            }
+        }
     }
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/Future.java b/vm/JavaAPI/src/java/util/concurrent/Future.java
index d3f597f773f..5367df903c5 100644
--- a/vm/JavaAPI/src/java/util/concurrent/Future.java
+++ b/vm/JavaAPI/src/java/util/concurrent/Future.java
@@ -28,7 +28,8 @@
 /// @param <V> the type of the result
 public interface Future<V> {
     /// Stops the work if it has not started. Answers whether it was cancelled;
-    /// work already running is not interrupted by the backend's executors.
+    /// whether work already running is interrupted is up to the implementation
+    /// and to `mayInterruptIfRunning`.
     ///
     /// @param mayInterruptIfRunning whether a running task may be interrupted
     /// @return true when this call cancelled it
diff --git a/vm/JavaAPI/src/java/util/concurrent/FutureTask.java b/vm/JavaAPI/src/java/util/concurrent/FutureTask.java
index 95be39dc1cd..853e074889c 100644
--- a/vm/JavaAPI/src/java/util/concurrent/FutureTask.java
+++ b/vm/JavaAPI/src/java/util/concurrent/FutureTask.java
@@ -1,94 +1,252 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+/// A cancellable computation whose result is read through [Future].
+///
+/// The state lives under this object's monitor, so it may be run, cancelled
+/// and waited for from any number of threads. `get()` on the UI thread waits
+/// through `JdkHost.blockUi`, which keeps events being dispatched.
+///
+/// `cancel(true)` interrupts the thread running the task, as in the JDK.
 public class FutureTask<V> implements RunnableFuture<V> {
+    private static final int NEW = 0;
+    private static final int NORMAL = 1;
+    private static final int EXCEPTIONAL = 2;
+    private static final int CANCELLED = 3;
+
+    /// Null once the task has run, so that it does not hold what it captured.
     private Callable<V> callable;
-    private V result;
-    private Throwable exception;
-    private boolean done;
-    private boolean cancelled;
+    private int state;
+    private Object outcome;
+    /// The thread inside [#run], so that `cancel(true)` can interrupt it.
+    private Thread runner;
 
     public FutureTask(Callable<V> callable) {
-        if (callable == null) throw new NullPointerException();
+        if (callable == null) {
+            throw new NullPointerException();
+        }
         this.callable = callable;
     }
 
     public FutureTask(Runnable runnable, V result) {
-        if (runnable == null) throw new NullPointerException();
+        if (runnable == null) {
+            throw new NullPointerException();
+        }
         this.callable = Executors.callable(runnable, result);
     }
 
     public boolean cancel(boolean mayInterruptIfRunning) {
-        synchronized(this) {
-            if (done) return false;
-            cancelled = true;
-            done = true;
+        synchronized (this) {
+            if (state != NEW) {
+                return false;
+            }
+            state = CANCELLED;
+            callable = null;
+            if (mayInterruptIfRunning && runner != null) {
+                runner.interrupt();
+            }
             notifyAll();
         }
+        done();
         return true;
     }
 
     public boolean isCancelled() {
-        synchronized(this) {
-            return cancelled;
+        synchronized (this) {
+            return state == CANCELLED;
         }
     }
 
     public boolean isDone() {
-        synchronized(this) {
-            return done;
+        synchronized (this) {
+            return state != NEW;
         }
     }
 
-    public V get() throws InterruptedException, ExecutionException {
-        synchronized(this) {
-            while (!done) {
-                wait();
+    /// Called once when the task becomes done, by whichever thread made it
+    /// so: completion, failure or cancellation. Does nothing here.
+    protected void done() {
+    }
+
+    /// Completes the future with `v`, unless it is already done.
+    protected void set(V v) {
+        if (finish(NORMAL, v)) {
+            done();
+        }
+    }
+
+    /// Fails the future with `t`, unless it is already done.
+    protected void setException(Throwable t) {
+        if (finish(EXCEPTIONAL, t)) {
+            done();
+        }
+    }
+
+    private boolean finish(int to, Object value) {
+        synchronized (this) {
+            if (state != NEW) {
+                return false;
             }
-            if (cancelled) throw new CancellationException();
-            if (exception != null) throw new ExecutionException(exception);
-            return result;
+            state = to;
+            outcome = value;
+            callable = null;
+            notifyAll();
+            return true;
+        }
+    }
+
+    public V get() throws InterruptedException, ExecutionException {
+        if (!isDone()) {
+            new Wait(this, BlockingWait.FOREVER).await();
         }
+        return report();
     }
 
     public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        if (unit == null) throw new NullPointerException();
-        long millis = unit.toMillis(timeout);
-        long end = System.currentTimeMillis() + millis;
-        synchronized(this) {
-            while (!done) {
-                long delay = end - System.currentTimeMillis();
-                if (delay <= 0) throw new TimeoutException();
-                wait(delay);
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (!isDone()) {
+            new Wait(this, BlockingWait.deadline(unit.toMillis(timeout))).await();
+            if (!isDone()) {
+                throw new TimeoutException();
             }
-            if (cancelled) throw new CancellationException();
-            if (exception != null) throw new ExecutionException(exception);
-            return result;
         }
+        return report();
+    }
+
+    @SuppressWarnings("unchecked")
+    private V report() throws ExecutionException {
+        int s;
+        Object o;
+        synchronized (this) {
+            s = state;
+            o = outcome;
+        }
+        if (s == CANCELLED) {
+            throw new CancellationException();
+        }
+        if (s == EXCEPTIONAL) {
+            throw new ExecutionException((Throwable) o);
+        }
+        return (V) o;
     }
 
     public void run() {
-        Callable<V> c;
-        synchronized(this) {
-            if (done) return;
-            c = callable;
+        Callable<V> c = claim();
+        if (c == null) {
+            return;
         }
+        V v;
         try {
-            V v = c.call();
-            synchronized(this) {
-                if (!done) {
-                    result = v;
-                    done = true;
-                    notifyAll();
-                }
-            }
+            v = c.call();
+        } catch (Throwable t) {
+            release();
+            setException(t);
+            return;
+        }
+        release();
+        set(v);
+    }
+
+    /// Runs the task without setting a result, leaving the future ready to
+    /// run again: for work that repeats. False when the task failed, was
+    /// cancelled, or was not runnable.
+    protected boolean runAndReset() {
+        Callable<V> c = claim();
+        if (c == null) {
+            return false;
+        }
+        try {
+            c.call();
         } catch (Throwable t) {
-            synchronized(this) {
-                if (!done) {
-                    exception = t;
-                    done = true;
-                    notifyAll();
-                }
+            release();
+            setException(t);
+            return false;
+        }
+        release();
+        return !isDone();
+    }
+
+    /// The callable, with this thread recorded as its runner; null when the
+    /// task is done or another thread is running it.
+    private Callable<V> claim() {
+        synchronized (this) {
+            if (state != NEW || runner != null) {
+                return null;
+            }
+            runner = Thread.currentThread();
+            return callable;
+        }
+    }
+
+    /// Forgets the runner. A cancel(true) that arrived during the run has
+    /// interrupted this thread; that interrupt is meant for the task, so it
+    /// is consumed here rather than leaking into the next task the thread runs.
+    private void release() {
+        boolean cancelled;
+        synchronized (this) {
+            runner = null;
+            cancelled = state == CANCELLED;
+        }
+        if (cancelled) {
+            Thread.interrupted();
+        }
+    }
+
+    public String toString() {
+        String status;
+        synchronized (this) {
+            switch (state) {
+                case NORMAL:
+                    status = "[Completed normally]";
+                    break;
+                case EXCEPTIONAL:
+                    status = "[Completed exceptionally: " + outcome + "]";
+                    break;
+                case CANCELLED:
+                    status = "[Cancelled]";
+                    break;
+                default:
+                    status = "[Not completed]";
+                    break;
             }
         }
+        return super.toString() + status;
+    }
+
+    /// Waits for the task to be done.
+    private static final class Wait extends BlockingWait {
+        private final FutureTask<?> task;
+
+        Wait(FutureTask<?> task, long deadline) {
+            super(task, deadline);
+            this.task = task;
+        }
+
+        boolean ready() {
+            return task.state != NEW;
+        }
     }
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/RejectedExecutionException.java b/vm/JavaAPI/src/java/util/concurrent/RejectedExecutionException.java
index fb6a204d36a..044724fb498 100644
--- a/vm/JavaAPI/src/java/util/concurrent/RejectedExecutionException.java
+++ b/vm/JavaAPI/src/java/util/concurrent/RejectedExecutionException.java
@@ -1,8 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+/// Thrown by an [Executor] that does not accept a task, typically because
+/// it has been shut down.
 public class RejectedExecutionException extends RuntimeException {
-    public RejectedExecutionException() { }
-    public RejectedExecutionException(String message) { super(message); }
-    public RejectedExecutionException(String message, Throwable cause) { super(message, cause); }
-    public RejectedExecutionException(Throwable cause) { super(cause); }
+
+    public RejectedExecutionException() {
+    }
+
+    public RejectedExecutionException(String message) {
+        super(message);
+    }
+
+    public RejectedExecutionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public RejectedExecutionException(Throwable cause) {
+        super(cause);
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/RunnableFuture.java b/vm/JavaAPI/src/java/util/concurrent/RunnableFuture.java
index 08774bf3c87..70567ad1b59 100644
--- a/vm/JavaAPI/src/java/util/concurrent/RunnableFuture.java
+++ b/vm/JavaAPI/src/java/util/concurrent/RunnableFuture.java
@@ -1,5 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+/// A [Future] that is also the task computing it: running it completes it.
 public interface RunnableFuture<V> extends Runnable, Future<V> {
+
+    /// Computes the result and completes this future with it, unless it was
+    /// cancelled.
     void run();
 }
diff --git a/vm/JavaAPI/src/java/util/concurrent/ScheduledExecutorService.java b/vm/JavaAPI/src/java/util/concurrent/ScheduledExecutorService.java
new file mode 100644
index 00000000000..b4f01364311
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/ScheduledExecutorService.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// `java.util.concurrent.ScheduledExecutorService`: an executor that also
+/// runs work after a delay, or again and again.
+///
+/// The work runs on the executor's threads, never on the UI thread.
+public interface ScheduledExecutorService extends ExecutorService {
+
+    ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
+
+    <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
+
+    ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);
+
+    ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/ScheduledFuture.java b/vm/JavaAPI/src/java/util/concurrent/ScheduledFuture.java
new file mode 100644
index 00000000000..29d60302da2
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/ScheduledFuture.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+/// `java.util.concurrent.ScheduledFuture`: the result of work an executor
+/// was asked to run later.
+public interface ScheduledFuture<V> extends Delayed, Future<V> {
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/ScheduledPool.java b/vm/JavaAPI/src/java/util/concurrent/ScheduledPool.java
new file mode 100644
index 00000000000..6ccdb525ba5
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/concurrent/ScheduledPool.java
@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.concurrent;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+
+/// The [ScheduledExecutorService] that [Executors] hands out: a timer that
+/// passes each piece of work, when it is due, to an ordinary executor.
+///
+/// #### After `shutdown()`
+///
+/// As a JDK `ScheduledThreadPoolExecutor` with its default policies: work
+/// already scheduled to run once still runs when it is due, and its future
+/// completes; work that repeats is cancelled; nothing new is accepted. The
+/// executor is terminated once the last of the accepted work has run.
+/// `shutdownNow()` drops what has not started.
+///
+/// Not provided: the two policies themselves
+/// (`setExecuteExistingDelayedTasksAfterShutdownPolicy` and its periodic
+/// twin are methods of the JDK's class, not of the interface this is handed
+/// out as).
+final class ScheduledPool extends AbstractExecutorService implements ScheduledExecutorService {
+
+    private static final Scheduled<?>[] NONE = new Scheduled<?>[0];
+
+    private final ExecutorService pool;
+    private final AtomicBoolean shutdown = new AtomicBoolean();
+    /// Set once the pool has been told to stop and nothing waits any more.
+    private final AtomicBoolean stopped = new AtomicBoolean();
+    /// The scheduled work that has not completed, which is what an orderly
+    /// shutdown waits for (the work that runs once) or cancels (the work
+    /// that repeats). Replaced, never changed: this is read and written by
+    /// the timer's thread, the workers and the caller's.
+    private final AtomicReference<Scheduled<?>[]> live = new AtomicReference<Scheduled<?>[]>(NONE);
+
+    ScheduledPool(ExecutorService pool) {
+        this.pool = pool;
+    }
+
+    private final class Scheduled<V> implements Runnable, ScheduledFuture<V> {
+        private final Callable<V> work;
+        private final boolean periodic;
+        /// The gap to keep after a run ends, or zero for a fixed rate.
+        private final long delayAfter;
+        /// The period of a fixed rate, or zero.
+        private final long rate;
+        /// The wait this is in, in [Delays], or null: see [#arm].
+        private final AtomicReference<Delays.Handle> wait = new AtomicReference<Delays.Handle>();
+        private final AtomicLong due;
+        private final AtomicBoolean running = new AtomicBoolean();
+        /// A fixed rate's firings that have come and not yet run, counting
+        /// the one running now. See [#run].
+        private final AtomicInteger owed = new AtomicInteger();
+        private final CompletableFuture<V> outcome = new CompletableFuture<V>();
+
+        Scheduled(Callable<V> work, long dueAt, boolean periodic, long delayAfter, long rate) {
+            this.work = work;
+            this.periodic = periodic;
+            this.delayAfter = delayAfter;
+            this.rate = rate;
+            this.due = new AtomicLong(dueAt);
+        }
+
+        @Override
+        public void run() {
+            // Work that runs once and was accepted before a shutdown still
+            // runs; work that repeats does not.
+            if (outcome.isDone() || (periodic && shutdown.get()) || stopped.get()) {
+                disarm();
+                return;
+            }
+            if (rate > 0) {
+                // A fixed rate keeps its beat whatever a run takes.
+                due.set(due.get() + rate);
+                arm(due.get() - System.currentTimeMillis());
+                // A firing that comes while a run is under way is owed, not
+                // dropped: as with the JDK's scheduleAtFixedRate, an overrun
+                // makes the next runs start late and one after another,
+                // never at once. The worker already running takes it.
+                if (owed.getAndIncrement() > 0) {
+                    return;
+                }
+            } else if (!running.compareAndSet(false, true)) {
+                return;
+            }
+            try {
+                pool.execute(new Runnable() {
+                    @Override
+                    public void run() {
+                        once();
+                    }
+                });
+            } catch (RuntimeException e) {
+                running.set(false);
+                owed.set(0);
+                outcome.completeExceptionally(e);
+                disarm();
+            }
+        }
+
+        /// Waits `millis` and then runs. The handle is kept so that a
+        /// cancelled task leaves the queue at once.
+        void arm(long millis) {
+            Delays.Handle next = Delays.after(millis, this);
+            Delays.Handle before = wait.getAndSet(next);
+            if (before != null) {
+                before.cancel();
+            }
+            if (outcome.isDone() || stopped.get()) {
+                // Cancelled, or stopped, while this was being armed.
+                disarm();
+            }
+        }
+
+        void disarm() {
+            Delays.Handle before = wait.getAndSet(null);
+            if (before != null) {
+                before.cancel();
+            }
+        }
+
+        /// A fixed rate runs every firing it owes, in turn, on this worker.
+        private void once() {
+            if (rate == 0) {
+                step();
+                return;
+            }
+            do {
+                running.set(true);
+                if (!step()) {
+                    return;
+                }
+            } while (owed.decrementAndGet() > 0);
+        }
+
+        /// One run; false when the work is not to run again.
+        private boolean step() {
+            // Cancelled, or stopped, while it waited for a worker: a future
+            // that answers isCancelled() must never start its work after.
+            if (outcome.isDone() || (periodic && shutdown.get()) || stopped.get()) {
+                running.set(false);
+                disarm();
+                return false;
+            }
+            boolean rearm = false;
+            try {
+                V value;
+                try {
+                    value = work.call();
+                } catch (Throwable t) {
+                    // Work that fails is not run again.
+                    outcome.completeExceptionally(t);
+                    disarm();
+                    return false;
+                }
+                if (!periodic) {
+                    outcome.complete(value);
+                } else if (delayAfter > 0 && !outcome.isDone() && !shutdown.get()) {
+                    rearm = true;
+                }
+            } finally {
+                running.set(false);
+            }
+            if (rearm) {
+                // Only once the flag is down. Armed before it, a short delay
+                // let the timer fire while this run still held the flag: the
+                // next run saw a run in progress and returned, nothing armed
+                // another, and the task stopped for good with its future
+                // never completing.
+                again();
+            }
+            return !outcome.isDone();
+        }
+
+        private void again() {
+            due.set(System.currentTimeMillis() + delayAfter);
+            arm(delayAfter);
+        }
+
+        @Override
+        public long getDelay(TimeUnit unit) {
+            return unit.convert(due.get() - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
+        }
+
+        @Override
+        public int compareTo(Delayed other) {
+            if (other == this) {
+                return 0;
+            }
+            long mine = getDelay(TimeUnit.MILLISECONDS);
+            long theirs = other.getDelay(TimeUnit.MILLISECONDS);
+            return mine < theirs ? -1 : (mine == theirs ? 0 : 1);
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            disarm();
+            return outcome.cancel(mayInterruptIfRunning);
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return outcome.isCancelled();
+        }
+
+        @Override
+        public boolean isDone() {
+            return outcome.isDone();
+        }
+
+        @Override
+        public V get() throws InterruptedException, ExecutionException {
+            return outcome.get();
+        }
+
+        @Override
+        public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+            return outcome.get(timeout, unit);
+        }
+    }
+
+    /// Keeps `task` until it completes, and runs it after `millis`.
+    private <V> Scheduled<V> accept(final Scheduled<V> task, long millis) {
+        checkOpen();
+        while (true) {
+            Scheduled<?>[] before = live.get();
+            Scheduled<?>[] after = new Scheduled<?>[before.length + 1];
+            System.arraycopy(before, 0, after, 0, before.length);
+            after[before.length] = task;
+            if (live.compareAndSet(before, after)) {
+                break;
+            }
+        }
+        task.outcome.whenComplete(new BiConsumer<V, Throwable>() {
+            @Override
+            public void accept(V value, Throwable failure) {
+                forget(task);
+            }
+        });
+        if (shutdown.get()) {
+            // A shutdown came in between: this one was not accepted.
+            task.cancel(false);
+            throw new RejectedExecutionException("The executor has been shut down");
+        }
+        task.arm(millis);
+        return task;
+    }
+
+    private void forget(Scheduled<?> task) {
+        while (true) {
+            Scheduled<?>[] before = live.get();
+            int at = -1;
+            for (int i = 0; i < before.length; i++) {
+                if (before[i] == task) {
+                    at = i;
+                }
+            }
+            if (at < 0) {
+                break;
+            }
+            Scheduled<?>[] after = new Scheduled<?>[before.length - 1];
+            System.arraycopy(before, 0, after, 0, at);
+            System.arraycopy(before, at + 1, after, at, after.length - at);
+            if (live.compareAndSet(before, after.length == 0 ? NONE : after)) {
+                break;
+            }
+        }
+        stopWhenIdle();
+    }
+
+    /// After a shutdown, stops the timer and the pool once nothing accepted
+    /// is left to run.
+    private void stopWhenIdle() {
+        if (shutdown.get() && live.get().length == 0 && stopped.compareAndSet(false, true)) {
+            pool.shutdown();
+        }
+    }
+
+    private void checkOpen() {
+        if (shutdown.get()) {
+            throw new RejectedExecutionException("The executor has been shut down");
+        }
+    }
+
+    @Override
+    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
+        if (callable == null || unit == null) {
+            throw new NullPointerException();
+        }
+        final long millis = Math.max(0, unit.toMillis(delay));
+        final Scheduled<V> task = new Scheduled<V>(callable, System.currentTimeMillis() + millis, false, 0, 0);
+        return accept(task, millis);
+    }
+
+    @Override
+    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+        return schedule(Executors.callable(command, null), delay, unit);
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (period <= 0) {
+            throw new IllegalArgumentException();
+        }
+        final long millis = Math.max(0, unit.toMillis(initialDelay));
+        final long every = Math.max(1, unit.toMillis(period));
+        final Scheduled<Object> task = new Scheduled<Object>(Executors.callable(command, null),
+                System.currentTimeMillis() + millis, true, 0, every);
+        return accept(task, millis);
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,
+            TimeUnit unit) {
+        if (unit == null) {
+            throw new NullPointerException();
+        }
+        if (delay <= 0) {
+            throw new IllegalArgumentException();
+        }
+        final long millis = Math.max(0, unit.toMillis(initialDelay));
+        final Scheduled<Object> task = new Scheduled<Object>(Executors.callable(command, null),
+                System.currentTimeMillis() + millis, true, Math.max(1, unit.toMillis(delay)), 0);
+        return accept(task, millis);
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        // The pool itself stays open after a shutdown for as long as
+        // delayed work is due to be handed to it, so it cannot be the one
+        // to refuse.
+        checkOpen();
+        pool.execute(command);
+    }
+
+    @Override
+    public void shutdown() {
+        shutdown.set(true);
+        for (Scheduled<?> task : live.get()) {
+            if (task.periodic) {
+                task.cancel(false);
+            }
+        }
+        stopWhenIdle();
+    }
+
+    /// Nothing scheduled that has not started runs after this. The futures
+    /// of the dropped work stay as they are, neither done nor cancelled,
+    /// as the JDK leaves them.
+    ///
+    /// What is answered is all of it, as the contract of the interface
+    /// has it: the work the pool had been handed and had not begun, and
+    /// the work that was still waiting for its time, which the pool never
+    /// saw. The JDK answers its delayed tasks the same way, as the futures
+    /// `schedule` returned.
+    @Override
+    public List<Runnable> shutdownNow() {
+        shutdown.set(true);
+        stopped.set(true);
+        List<Runnable> dropped = new ArrayList<Runnable>(pool.shutdownNow());
+        // Taken out of `live` here: a dropped task's future never completes,
+        // so the forget() its completion would run never comes, and the
+        // pool would hold every dropped task (and what its work holds) for
+        // as long as the pool itself is reachable. Nothing reads `live`
+        // after this -- `stopped` is set, so stopWhenIdle() is done with it
+        // -- and a task still running forgets itself into an empty array.
+        for (Scheduled<?> task : live.getAndSet(NONE)) {
+            task.disarm();
+            if (!task.outcome.isDone() && !task.running.get()) {
+                dropped.add(task);
+            }
+        }
+        return dropped;
+    }
+
+    @Override
+    public boolean isShutdown() {
+        return shutdown.get();
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return pool.isTerminated();
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        return pool.awaitTermination(timeout, unit);
+    }
+
+    @Override
+    public <T> Future<T> submit(Callable<T> task) {
+        checkOpen();
+        return pool.submit(task);
+    }
+
+    @Override
+    public <T> Future<T> submit(Runnable task, T result) {
+        checkOpen();
+        return pool.submit(task, result);
+    }
+
+    @Override
+    public Future<?> submit(Runnable task) {
+        checkOpen();
+        return pool.submit(task);
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+        checkOpen();
+        return pool.invokeAll(tasks);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/concurrent/ThreadFactory.java b/vm/JavaAPI/src/java/util/concurrent/ThreadFactory.java
index b1bb5554ad3..2be3cd81893 100644
--- a/vm/JavaAPI/src/java/util/concurrent/ThreadFactory.java
+++ b/vm/JavaAPI/src/java/util/concurrent/ThreadFactory.java
@@ -1,5 +1,30 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.concurrent;
 
+/// Makes the threads an executor runs its tasks on.
 public interface ThreadFactory {
+
+    /// A new, unstarted thread that runs `r`; null to refuse.
     Thread newThread(Runnable r);
 }
diff --git a/vm/JavaAPI/src/java/util/function/BiConsumer.java b/vm/JavaAPI/src/java/util/function/BiConsumer.java
index f27cf084ac6..52c0356ef5b 100644
--- a/vm/JavaAPI/src/java/util/function/BiConsumer.java
+++ b/vm/JavaAPI/src/java/util/function/BiConsumer.java
@@ -1,5 +1,55 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// An operation on two values that answers nothing.
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
 public interface BiConsumer<T, U> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the first input
+    /// @param u the second input
     void accept(T t, U u);
+
+    /// This operation followed by `after`, both given the same values. If
+    /// this operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default BiConsumer<T, U> andThen(final BiConsumer<? super T, ? super U> after) {
+        Objects.requireNonNull(after);
+        final BiConsumer<T, U> self = this;
+        return new BiConsumer<T, U>() {
+            public void accept(T t, U u) {
+                self.accept(t, u);
+                after.accept(t, u);
+            }
+        };
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/function/BiFunction.java b/vm/JavaAPI/src/java/util/function/BiFunction.java
index 92c2bccaf71..cdfa42856e3 100644
--- a/vm/JavaAPI/src/java/util/function/BiFunction.java
+++ b/vm/JavaAPI/src/java/util/function/BiFunction.java
@@ -1,5 +1,56 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// A function of two arguments.
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+/// @param <R> the result type
+@FunctionalInterface
 public interface BiFunction<T, U, R> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
     R apply(T t, U u);
+
+    /// This function, then `after` on its result.
+    ///
+    /// @param after the function applied next
+    /// @param <V> the result type of `after`
+    /// @return the composed function
+    default <V> BiFunction<T, U, V> andThen(final Function<? super R, ? extends V> after) {
+        Objects.requireNonNull(after);
+        final BiFunction<T, U, R> self = this;
+        return new BiFunction<T, U, V>() {
+            public V apply(T t, U u) {
+                return after.apply(self.apply(t, u));
+            }
+        };
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/function/BiPredicate.java b/vm/JavaAPI/src/java/util/function/BiPredicate.java
new file mode 100644
index 00000000000..9f4585b89ad
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/BiPredicate.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of two arguments; the two-argument form of [Predicate].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface BiPredicate<T, U> {
+
+    /// Whether `t` and `u` pass.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return true when they pass
+    boolean test(T t, U u);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default BiPredicate<T, U> and(final BiPredicate<? super T, ? super U> other) {
+        Objects.requireNonNull(other);
+        final BiPredicate<T, U> self = this;
+        return new BiPredicate<T, U>() {
+            public boolean test(T t, U u) {
+                return self.test(t, u) && other.test(t, u);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default BiPredicate<T, U> negate() {
+        final BiPredicate<T, U> self = this;
+        return new BiPredicate<T, U>() {
+            public boolean test(T t, U u) {
+                return !self.test(t, u);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default BiPredicate<T, U> or(final BiPredicate<? super T, ? super U> other) {
+        Objects.requireNonNull(other);
+        final BiPredicate<T, U> self = this;
+        return new BiPredicate<T, U>() {
+            public boolean test(T t, U u) {
+                return self.test(t, u) || other.test(t, u);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/BinaryOperator.java b/vm/JavaAPI/src/java/util/function/BinaryOperator.java
index 6bb43e2efd4..2755a698c25 100644
--- a/vm/JavaAPI/src/java/util/function/BinaryOperator.java
+++ b/vm/JavaAPI/src/java/util/function/BinaryOperator.java
@@ -1,5 +1,61 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
-public interface BinaryOperator<T> {
-    T apply(T a, T b);
+import java.util.Comparator;
+import java.util.Objects;
+
+/// An operation on two values of one type that answers that type.
+///
+/// @param <T> the operand and result type
+@FunctionalInterface
+public interface BinaryOperator<T> extends BiFunction<T, T, T> {
+
+    /// The smaller of two values by `comparator`; the first on a tie.
+    ///
+    /// @param comparator the order
+    /// @param <T> the type
+    /// @return the operator
+    static <T> BinaryOperator<T> minBy(final Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return new BinaryOperator<T>() {
+            public T apply(T a, T b) {
+                return comparator.compare(a, b) <= 0 ? a : b;
+            }
+        };
+    }
+
+    /// The larger of two values by `comparator`; the first on a tie.
+    ///
+    /// @param comparator the order
+    /// @param <T> the type
+    /// @return the operator
+    static <T> BinaryOperator<T> maxBy(final Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return new BinaryOperator<T>() {
+            public T apply(T a, T b) {
+                return comparator.compare(a, b) >= 0 ? a : b;
+            }
+        };
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/function/BooleanSupplier.java b/vm/JavaAPI/src/java/util/function/BooleanSupplier.java
new file mode 100644
index 00000000000..43fc08737e8
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/BooleanSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `boolean` values; the `boolean` form of [Supplier].
+@FunctionalInterface
+public interface BooleanSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    boolean getAsBoolean();
+}
diff --git a/vm/JavaAPI/src/java/util/function/Consumer.java b/vm/JavaAPI/src/java/util/function/Consumer.java
index a000a2c474e..7ee4c4c190a 100644
--- a/vm/JavaAPI/src/java/util/function/Consumer.java
+++ b/vm/JavaAPI/src/java/util/function/Consumer.java
@@ -1,5 +1,53 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// An operation on one value that answers nothing.
+///
+/// @param <T> the input type
+@FunctionalInterface
 public interface Consumer<T> {
+
+    /// Performs this operation on `t`.
+    ///
+    /// @param t the input
     void accept(T t);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default Consumer<T> andThen(final Consumer<? super T> after) {
+        Objects.requireNonNull(after);
+        final Consumer<T> self = this;
+        return new Consumer<T>() {
+            public void accept(T t) {
+                self.accept(t);
+                after.accept(t);
+            }
+        };
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/function/DoubleBinaryOperator.java b/vm/JavaAPI/src/java/util/function/DoubleBinaryOperator.java
new file mode 100644
index 00000000000..bfa1d4e0513
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleBinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on two `double` values that answers a `double`; the `double` form of [BinaryOperator].
+@FunctionalInterface
+public interface DoubleBinaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param left the first operand
+    /// @param right the second operand
+    /// @return the result
+    double applyAsDouble(double left, double right);
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoubleConsumer.java b/vm/JavaAPI/src/java/util/function/DoubleConsumer.java
new file mode 100644
index 00000000000..1d44bd4bd42
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleConsumer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `double` that answers nothing; the `double` form of [Consumer].
+@FunctionalInterface
+public interface DoubleConsumer {
+
+    /// Performs this operation on `value`.
+    ///
+    /// @param value the input
+    void accept(double value);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default DoubleConsumer andThen(final DoubleConsumer after) {
+        Objects.requireNonNull(after);
+        final DoubleConsumer self = this;
+        return new DoubleConsumer() {
+            public void accept(double value) {
+                self.accept(value);
+                after.accept(value);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoubleFunction.java b/vm/JavaAPI/src/java/util/function/DoubleFunction.java
new file mode 100644
index 00000000000..85cbd3632dc
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `double`; the `double` form of [Function].
+///
+/// @param <R> the result type
+@FunctionalInterface
+public interface DoubleFunction<R> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    R apply(double value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoublePredicate.java b/vm/JavaAPI/src/java/util/function/DoublePredicate.java
new file mode 100644
index 00000000000..125d220f3b6
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoublePredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of one `double`; the `double` form of [Predicate].
+@FunctionalInterface
+public interface DoublePredicate {
+
+    /// Whether `value` passes.
+    ///
+    /// @param value the input
+    /// @return true when it passes
+    boolean test(double value);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default DoublePredicate and(final DoublePredicate other) {
+        Objects.requireNonNull(other);
+        final DoublePredicate self = this;
+        return new DoublePredicate() {
+            public boolean test(double value) {
+                return self.test(value) && other.test(value);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default DoublePredicate negate() {
+        final DoublePredicate self = this;
+        return new DoublePredicate() {
+            public boolean test(double value) {
+                return !self.test(value);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default DoublePredicate or(final DoublePredicate other) {
+        Objects.requireNonNull(other);
+        final DoublePredicate self = this;
+        return new DoublePredicate() {
+            public boolean test(double value) {
+                return self.test(value) || other.test(value);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoubleSupplier.java b/vm/JavaAPI/src/java/util/function/DoubleSupplier.java
new file mode 100644
index 00000000000..de3fe0d5a37
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `double` values; the `double` form of [Supplier].
+@FunctionalInterface
+public interface DoubleSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    double getAsDouble();
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoubleToIntFunction.java b/vm/JavaAPI/src/java/util/function/DoubleToIntFunction.java
new file mode 100644
index 00000000000..fe3d5a98fad
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleToIntFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `double` that answers a `int`.
+@FunctionalInterface
+public interface DoubleToIntFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    int applyAsInt(double value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoubleToLongFunction.java b/vm/JavaAPI/src/java/util/function/DoubleToLongFunction.java
new file mode 100644
index 00000000000..949d967ce35
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleToLongFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `double` that answers a `long`.
+@FunctionalInterface
+public interface DoubleToLongFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    long applyAsLong(double value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/DoubleUnaryOperator.java b/vm/JavaAPI/src/java/util/function/DoubleUnaryOperator.java
new file mode 100644
index 00000000000..16e51536be4
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/DoubleUnaryOperator.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `double` that answers a `double`; the `double` form of [UnaryOperator].
+@FunctionalInterface
+public interface DoubleUnaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param operand the input
+    /// @return the result
+    double applyAsDouble(double operand);
+
+    /// `before`, then this operator on its result.
+    ///
+    /// @param before the operator applied first
+    /// @return the composed operator
+    default DoubleUnaryOperator compose(final DoubleUnaryOperator before) {
+        Objects.requireNonNull(before);
+        final DoubleUnaryOperator self = this;
+        return new DoubleUnaryOperator() {
+            public double applyAsDouble(double value) {
+                return self.applyAsDouble(before.applyAsDouble(value));
+            }
+        };
+    }
+
+    /// This operator, then `after` on its result.
+    ///
+    /// @param after the operator applied next
+    /// @return the composed operator
+    default DoubleUnaryOperator andThen(final DoubleUnaryOperator after) {
+        Objects.requireNonNull(after);
+        final DoubleUnaryOperator self = this;
+        return new DoubleUnaryOperator() {
+            public double applyAsDouble(double value) {
+                return after.applyAsDouble(self.applyAsDouble(value));
+            }
+        };
+    }
+
+    /// The operator that answers its operand.
+    ///
+    /// @return the identity operator
+    static DoubleUnaryOperator identity() {
+        return new DoubleUnaryOperator() {
+            public double applyAsDouble(double value) {
+                return value;
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/Function.java b/vm/JavaAPI/src/java/util/function/Function.java
index ad779d44781..1c16bc90b84 100644
--- a/vm/JavaAPI/src/java/util/function/Function.java
+++ b/vm/JavaAPI/src/java/util/function/Function.java
@@ -1,5 +1,81 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// A function of one argument.
+///
+/// @param <T> the input type
+/// @param <R> the result type
+@FunctionalInterface
 public interface Function<T, R> {
+
+    /// Applies this function.
+    ///
+    /// @param t the input
+    /// @return the result
     R apply(T t);
+
+    /// `before`, then this function on its result.
+    ///
+    /// @param before the function applied first
+    /// @param <V> the input type of `before`
+    /// @return the composed function
+    default <V> Function<V, R> compose(final Function<? super V, ? extends T> before) {
+        Objects.requireNonNull(before);
+        final Function<T, R> self = this;
+        return new Function<V, R>() {
+            public R apply(V v) {
+                return self.apply(before.apply(v));
+            }
+        };
+    }
+
+    /// This function, then `after` on its result.
+    ///
+    /// @param after the function applied next
+    /// @param <V> the result type of `after`
+    /// @return the composed function
+    default <V> Function<T, V> andThen(final Function<? super R, ? extends V> after) {
+        Objects.requireNonNull(after);
+        final Function<T, R> self = this;
+        return new Function<T, V>() {
+            public V apply(T t) {
+                return after.apply(self.apply(t));
+            }
+        };
+    }
+
+    /// The function that answers its argument.
+    ///
+    /// @param <T> the type
+    /// @return the identity function
+    static <T> Function<T, T> identity() {
+        return new Function<T, T>() {
+            public T apply(T t) {
+                return t;
+            }
+        };
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/function/IntBinaryOperator.java b/vm/JavaAPI/src/java/util/function/IntBinaryOperator.java
new file mode 100644
index 00000000000..dccd2f21f3c
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntBinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on two `int` values that answers a `int`; the `int` form of [BinaryOperator].
+@FunctionalInterface
+public interface IntBinaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param left the first operand
+    /// @param right the second operand
+    /// @return the result
+    int applyAsInt(int left, int right);
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntConsumer.java b/vm/JavaAPI/src/java/util/function/IntConsumer.java
new file mode 100644
index 00000000000..80a74ca841c
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntConsumer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `int` that answers nothing; the `int` form of [Consumer].
+@FunctionalInterface
+public interface IntConsumer {
+
+    /// Performs this operation on `value`.
+    ///
+    /// @param value the input
+    void accept(int value);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default IntConsumer andThen(final IntConsumer after) {
+        Objects.requireNonNull(after);
+        final IntConsumer self = this;
+        return new IntConsumer() {
+            public void accept(int value) {
+                self.accept(value);
+                after.accept(value);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntFunction.java b/vm/JavaAPI/src/java/util/function/IntFunction.java
new file mode 100644
index 00000000000..a148d448cb8
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `int`; the `int` form of [Function].
+///
+/// @param <R> the result type
+@FunctionalInterface
+public interface IntFunction<R> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    R apply(int value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntPredicate.java b/vm/JavaAPI/src/java/util/function/IntPredicate.java
new file mode 100644
index 00000000000..3c538be9255
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntPredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of one `int`; the `int` form of [Predicate].
+@FunctionalInterface
+public interface IntPredicate {
+
+    /// Whether `value` passes.
+    ///
+    /// @param value the input
+    /// @return true when it passes
+    boolean test(int value);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default IntPredicate and(final IntPredicate other) {
+        Objects.requireNonNull(other);
+        final IntPredicate self = this;
+        return new IntPredicate() {
+            public boolean test(int value) {
+                return self.test(value) && other.test(value);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default IntPredicate negate() {
+        final IntPredicate self = this;
+        return new IntPredicate() {
+            public boolean test(int value) {
+                return !self.test(value);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default IntPredicate or(final IntPredicate other) {
+        Objects.requireNonNull(other);
+        final IntPredicate self = this;
+        return new IntPredicate() {
+            public boolean test(int value) {
+                return self.test(value) || other.test(value);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntSupplier.java b/vm/JavaAPI/src/java/util/function/IntSupplier.java
new file mode 100644
index 00000000000..630ef2d22d6
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `int` values; the `int` form of [Supplier].
+@FunctionalInterface
+public interface IntSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    int getAsInt();
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntToDoubleFunction.java b/vm/JavaAPI/src/java/util/function/IntToDoubleFunction.java
new file mode 100644
index 00000000000..9a5f753bc75
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntToDoubleFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `int` that answers a `double`.
+@FunctionalInterface
+public interface IntToDoubleFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    double applyAsDouble(int value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntToLongFunction.java b/vm/JavaAPI/src/java/util/function/IntToLongFunction.java
new file mode 100644
index 00000000000..c31acba27c5
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntToLongFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `int` that answers a `long`.
+@FunctionalInterface
+public interface IntToLongFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    long applyAsLong(int value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/IntUnaryOperator.java b/vm/JavaAPI/src/java/util/function/IntUnaryOperator.java
new file mode 100644
index 00000000000..ce97b7a0b9e
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/IntUnaryOperator.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `int` that answers a `int`; the `int` form of [UnaryOperator].
+@FunctionalInterface
+public interface IntUnaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param operand the input
+    /// @return the result
+    int applyAsInt(int operand);
+
+    /// `before`, then this operator on its result.
+    ///
+    /// @param before the operator applied first
+    /// @return the composed operator
+    default IntUnaryOperator compose(final IntUnaryOperator before) {
+        Objects.requireNonNull(before);
+        final IntUnaryOperator self = this;
+        return new IntUnaryOperator() {
+            public int applyAsInt(int value) {
+                return self.applyAsInt(before.applyAsInt(value));
+            }
+        };
+    }
+
+    /// This operator, then `after` on its result.
+    ///
+    /// @param after the operator applied next
+    /// @return the composed operator
+    default IntUnaryOperator andThen(final IntUnaryOperator after) {
+        Objects.requireNonNull(after);
+        final IntUnaryOperator self = this;
+        return new IntUnaryOperator() {
+            public int applyAsInt(int value) {
+                return after.applyAsInt(self.applyAsInt(value));
+            }
+        };
+    }
+
+    /// The operator that answers its operand.
+    ///
+    /// @return the identity operator
+    static IntUnaryOperator identity() {
+        return new IntUnaryOperator() {
+            public int applyAsInt(int value) {
+                return value;
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongBinaryOperator.java b/vm/JavaAPI/src/java/util/function/LongBinaryOperator.java
new file mode 100644
index 00000000000..3b6faeacc4e
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongBinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on two `long` values that answers a `long`; the `long` form of [BinaryOperator].
+@FunctionalInterface
+public interface LongBinaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param left the first operand
+    /// @param right the second operand
+    /// @return the result
+    long applyAsLong(long left, long right);
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongConsumer.java b/vm/JavaAPI/src/java/util/function/LongConsumer.java
new file mode 100644
index 00000000000..cdb2b02e5d8
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongConsumer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `long` that answers nothing; the `long` form of [Consumer].
+@FunctionalInterface
+public interface LongConsumer {
+
+    /// Performs this operation on `value`.
+    ///
+    /// @param value the input
+    void accept(long value);
+
+    /// This operation followed by `after`, both given the same value. If this
+    /// operation throws, `after` does not run.
+    ///
+    /// @param after the operation to run next
+    /// @return the composed operation
+    default LongConsumer andThen(final LongConsumer after) {
+        Objects.requireNonNull(after);
+        final LongConsumer self = this;
+        return new LongConsumer() {
+            public void accept(long value) {
+                self.accept(value);
+                after.accept(value);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongFunction.java b/vm/JavaAPI/src/java/util/function/LongFunction.java
new file mode 100644
index 00000000000..f1458845b13
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `long`; the `long` form of [Function].
+///
+/// @param <R> the result type
+@FunctionalInterface
+public interface LongFunction<R> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    R apply(long value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongPredicate.java b/vm/JavaAPI/src/java/util/function/LongPredicate.java
new file mode 100644
index 00000000000..f010b7bc72b
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongPredicate.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// A test of one `long`; the `long` form of [Predicate].
+@FunctionalInterface
+public interface LongPredicate {
+
+    /// Whether `value` passes.
+    ///
+    /// @param value the input
+    /// @return true when it passes
+    boolean test(long value);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default LongPredicate and(final LongPredicate other) {
+        Objects.requireNonNull(other);
+        final LongPredicate self = this;
+        return new LongPredicate() {
+            public boolean test(long value) {
+                return self.test(value) && other.test(value);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default LongPredicate negate() {
+        final LongPredicate self = this;
+        return new LongPredicate() {
+            public boolean test(long value) {
+                return !self.test(value);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default LongPredicate or(final LongPredicate other) {
+        Objects.requireNonNull(other);
+        final LongPredicate self = this;
+        return new LongPredicate() {
+            public boolean test(long value) {
+                return self.test(value) || other.test(value);
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongSupplier.java b/vm/JavaAPI/src/java/util/function/LongSupplier.java
new file mode 100644
index 00000000000..133d768e0fd
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A source of `long` values; the `long` form of [Supplier].
+@FunctionalInterface
+public interface LongSupplier {
+
+    /// A value.
+    ///
+    /// @return the value
+    long getAsLong();
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongToDoubleFunction.java b/vm/JavaAPI/src/java/util/function/LongToDoubleFunction.java
new file mode 100644
index 00000000000..ec0ad15bf49
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongToDoubleFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `long` that answers a `double`.
+@FunctionalInterface
+public interface LongToDoubleFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    double applyAsDouble(long value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongToIntFunction.java b/vm/JavaAPI/src/java/util/function/LongToIntFunction.java
new file mode 100644
index 00000000000..1ae1a3c9ce5
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongToIntFunction.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of one `long` that answers a `int`.
+@FunctionalInterface
+public interface LongToIntFunction {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    int applyAsInt(long value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/LongUnaryOperator.java b/vm/JavaAPI/src/java/util/function/LongUnaryOperator.java
new file mode 100644
index 00000000000..e70cbd9fa22
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/LongUnaryOperator.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+import java.util.Objects;
+
+/// An operation on one `long` that answers a `long`; the `long` form of [UnaryOperator].
+@FunctionalInterface
+public interface LongUnaryOperator {
+
+    /// Applies this operator.
+    ///
+    /// @param operand the input
+    /// @return the result
+    long applyAsLong(long operand);
+
+    /// `before`, then this operator on its result.
+    ///
+    /// @param before the operator applied first
+    /// @return the composed operator
+    default LongUnaryOperator compose(final LongUnaryOperator before) {
+        Objects.requireNonNull(before);
+        final LongUnaryOperator self = this;
+        return new LongUnaryOperator() {
+            public long applyAsLong(long value) {
+                return self.applyAsLong(before.applyAsLong(value));
+            }
+        };
+    }
+
+    /// This operator, then `after` on its result.
+    ///
+    /// @param after the operator applied next
+    /// @return the composed operator
+    default LongUnaryOperator andThen(final LongUnaryOperator after) {
+        Objects.requireNonNull(after);
+        final LongUnaryOperator self = this;
+        return new LongUnaryOperator() {
+            public long applyAsLong(long value) {
+                return after.applyAsLong(self.applyAsLong(value));
+            }
+        };
+    }
+
+    /// The operator that answers its operand.
+    ///
+    /// @return the identity operator
+    static LongUnaryOperator identity() {
+        return new LongUnaryOperator() {
+            public long applyAsLong(long value) {
+                return value;
+            }
+        };
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/function/ObjDoubleConsumer.java b/vm/JavaAPI/src/java/util/function/ObjDoubleConsumer.java
new file mode 100644
index 00000000000..9a90ee68e89
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ObjDoubleConsumer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on an object and a `double` that answers nothing; the `double` form of [BiConsumer].
+///
+/// @param <T> the object type
+@FunctionalInterface
+public interface ObjDoubleConsumer<T> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the object
+    /// @param value the `double`
+    void accept(T t, double value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ObjIntConsumer.java b/vm/JavaAPI/src/java/util/function/ObjIntConsumer.java
new file mode 100644
index 00000000000..d6a5fe85d0b
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ObjIntConsumer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on an object and a `int` that answers nothing; the `int` form of [BiConsumer].
+///
+/// @param <T> the object type
+@FunctionalInterface
+public interface ObjIntConsumer<T> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the object
+    /// @param value the `int`
+    void accept(T t, int value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ObjLongConsumer.java b/vm/JavaAPI/src/java/util/function/ObjLongConsumer.java
new file mode 100644
index 00000000000..6b4735ae72f
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ObjLongConsumer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// An operation on an object and a `long` that answers nothing; the `long` form of [BiConsumer].
+///
+/// @param <T> the object type
+@FunctionalInterface
+public interface ObjLongConsumer<T> {
+
+    /// Performs this operation.
+    ///
+    /// @param t the object
+    /// @param value the `long`
+    void accept(T t, long value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/Predicate.java b/vm/JavaAPI/src/java/util/function/Predicate.java
index 4bb9d60f478..4c0067d26d4 100644
--- a/vm/JavaAPI/src/java/util/function/Predicate.java
+++ b/vm/JavaAPI/src/java/util/function/Predicate.java
@@ -1,5 +1,105 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+import java.util.Objects;
+
+/// A test of one value.
+///
+/// @param <T> the input type
+@FunctionalInterface
 public interface Predicate<T> {
+
+    /// Whether `t` passes.
+    ///
+    /// @param t the input
+    /// @return true when it passes
     boolean test(T t);
+
+    /// Passes when this and `other` both pass; `other` is not asked when this
+    /// fails.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default Predicate<T> and(final Predicate<? super T> other) {
+        Objects.requireNonNull(other);
+        final Predicate<T> self = this;
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return self.test(t) && other.test(t);
+            }
+        };
+    }
+
+    /// Passes when this fails.
+    ///
+    /// @return the negated test
+    default Predicate<T> negate() {
+        final Predicate<T> self = this;
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return !self.test(t);
+            }
+        };
+    }
+
+    /// Passes when this or `other` passes; `other` is not asked when this
+    /// passes.
+    ///
+    /// @param other the second test
+    /// @return the composed test
+    default Predicate<T> or(final Predicate<? super T> other) {
+        Objects.requireNonNull(other);
+        final Predicate<T> self = this;
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return self.test(t) || other.test(t);
+            }
+        };
+    }
+
+    /// Passes for values equal to `targetRef` by [Object#equals], or for null
+    /// when `targetRef` is null.
+    ///
+    /// @param targetRef the value to compare with
+    /// @param <T> the input type
+    /// @return the test
+    static <T> Predicate<T> isEqual(final Object targetRef) {
+        return new Predicate<T>() {
+            public boolean test(T t) {
+                return targetRef == null ? t == null : targetRef.equals(t);
+            }
+        };
+    }
+
+    /// The negation of `target`.
+    ///
+    /// @param target the test to negate
+    /// @param <T> the input type
+    /// @return the negated test
+    @SuppressWarnings("unchecked")
+    static <T> Predicate<T> not(Predicate<? super T> target) {
+        Objects.requireNonNull(target);
+        return (Predicate<T>) target.negate();
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/function/Supplier.java b/vm/JavaAPI/src/java/util/function/Supplier.java
index e45d9f5aeef..499a06e4965 100644
--- a/vm/JavaAPI/src/java/util/function/Supplier.java
+++ b/vm/JavaAPI/src/java/util/function/Supplier.java
@@ -1,5 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+/// A source of values.
+///
+/// @param <T> the type supplied
+@FunctionalInterface
 public interface Supplier<T> {
+
+    /// A value.
+    ///
+    /// @return the value
     T get();
 }
diff --git a/vm/JavaAPI/src/java/util/function/ToDoubleBiFunction.java b/vm/JavaAPI/src/java/util/function/ToDoubleBiFunction.java
new file mode 100644
index 00000000000..bedef3df575
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ToDoubleBiFunction.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of two arguments that answers a `double`; the `double` form of [BiFunction].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface ToDoubleBiFunction<T, U> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
+    double applyAsDouble(T t, U u);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ToDoubleFunction.java b/vm/JavaAPI/src/java/util/function/ToDoubleFunction.java
new file mode 100644
index 00000000000..57d5d343ec1
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ToDoubleFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function that answers a `double`; the `double` form of [Function].
+///
+/// @param <T> the input type
+@FunctionalInterface
+public interface ToDoubleFunction<T> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    double applyAsDouble(T value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ToIntBiFunction.java b/vm/JavaAPI/src/java/util/function/ToIntBiFunction.java
new file mode 100644
index 00000000000..b9aa9c17d86
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ToIntBiFunction.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of two arguments that answers a `int`; the `int` form of [BiFunction].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface ToIntBiFunction<T, U> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
+    int applyAsInt(T t, U u);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ToIntFunction.java b/vm/JavaAPI/src/java/util/function/ToIntFunction.java
new file mode 100644
index 00000000000..8d03908f875
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ToIntFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function that answers a `int`; the `int` form of [Function].
+///
+/// @param <T> the input type
+@FunctionalInterface
+public interface ToIntFunction<T> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    int applyAsInt(T value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ToLongBiFunction.java b/vm/JavaAPI/src/java/util/function/ToLongBiFunction.java
new file mode 100644
index 00000000000..a751c610c2e
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ToLongBiFunction.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function of two arguments that answers a `long`; the `long` form of [BiFunction].
+///
+/// @param <T> the first input type
+/// @param <U> the second input type
+@FunctionalInterface
+public interface ToLongBiFunction<T, U> {
+
+    /// Applies this function.
+    ///
+    /// @param t the first input
+    /// @param u the second input
+    /// @return the result
+    long applyAsLong(T t, U u);
+}
diff --git a/vm/JavaAPI/src/java/util/function/ToLongFunction.java b/vm/JavaAPI/src/java/util/function/ToLongFunction.java
new file mode 100644
index 00000000000..45dc0fedb37
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/function/ToLongFunction.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.function;
+
+/// A function that answers a `long`; the `long` form of [Function].
+///
+/// @param <T> the input type
+@FunctionalInterface
+public interface ToLongFunction<T> {
+
+    /// Applies this function.
+    ///
+    /// @param value the input
+    /// @return the result
+    long applyAsLong(T value);
+}
diff --git a/vm/JavaAPI/src/java/util/function/UnaryOperator.java b/vm/JavaAPI/src/java/util/function/UnaryOperator.java
index 0a15d04019a..e58ddc6cdb3 100644
--- a/vm/JavaAPI/src/java/util/function/UnaryOperator.java
+++ b/vm/JavaAPI/src/java/util/function/UnaryOperator.java
@@ -1,4 +1,42 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.function;
 
+/// An operation on one value that answers the same type.
+///
+/// @param <T> the operand and result type
+@FunctionalInterface
 public interface UnaryOperator<T> extends Function<T, T> {
+
+    /// The operator that answers its operand.
+    ///
+    /// @param <T> the type
+    /// @return the identity operator
+    static <T> UnaryOperator<T> identity() {
+        return new UnaryOperator<T>() {
+            public T apply(T t) {
+                return t;
+            }
+        };
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/logging/Level.java b/vm/JavaAPI/src/java/util/logging/Level.java
new file mode 100644
index 00000000000..032099d8ad8
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/logging/Level.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.logging;
+
+/// A logging level: the standard
+/// levels, and room for an application's own -- the constructor is
+/// protected, as the JDK's is, so a class may extend this one to add them.
+///
+/// [Logger] writes through the platform log, which has four levels; see
+/// there for how these map onto them.
+public class Level implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    public static final Level OFF = new Level("OFF", Integer.MAX_VALUE);
+    public static final Level SEVERE = new Level("SEVERE", 1000);
+    public static final Level WARNING = new Level("WARNING", 900);
+    public static final Level INFO = new Level("INFO", 800);
+    public static final Level CONFIG = new Level("CONFIG", 700);
+    public static final Level FINE = new Level("FINE", 500);
+    public static final Level FINER = new Level("FINER", 400);
+    public static final Level FINEST = new Level("FINEST", 300);
+    public static final Level ALL = new Level("ALL", Integer.MIN_VALUE);
+
+    private final String name;
+    private final int value;
+    private final String resourceBundleName;
+
+    protected Level(String name, int value) {
+        this(name, value, null);
+    }
+
+    protected Level(String name, int value, String resourceBundleName) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        this.name = name;
+        this.value = value;
+        this.resourceBundleName = resourceBundleName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /// The name: a device carries no translations of the level names.
+    public String getLocalizedName() {
+        return name;
+    }
+
+    public String getResourceBundleName() {
+        return resourceBundleName;
+    }
+
+    public final int intValue() {
+        return value;
+    }
+
+    private static Level[] standard() {
+        return new Level[] {OFF, SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST, ALL};
+    }
+
+    /// The standard level called `name`, in any case, or whose number
+    /// `name` spells. A number that belongs to no standard level makes a
+    /// level of its own, named by the number.
+    public static Level parse(String name) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        String trimmed = name.trim();
+        Level[] all = standard();
+        for (Level level : all) {
+            if (level.name.equalsIgnoreCase(trimmed)) {
+                return level;
+            }
+        }
+        int number;
+        try {
+            number = Integer.parseInt(trimmed);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Bad level \"" + name + "\"");
+        }
+        for (Level level : all) {
+            if (level.value == number) {
+                return level;
+            }
+        }
+        return new Level(trimmed, number);
+    }
+
+    @Override
+    public final String toString() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof Level && ((Level) other).value == value;
+    }
+
+    @Override
+    public int hashCode() {
+        return value;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/logging/Logger.java b/vm/JavaAPI/src/java/util/logging/Logger.java
new file mode 100644
index 00000000000..bbf1cbd401e
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/logging/Logger.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.logging;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/// A logger writing through the platform's log, which
+/// `com.codename1.impl.JdkHost` reaches: `com.codename1.io.Log` in a Codename
+/// One application, standard error elsewhere.
+///
+/// The platform log has four levels where the JDK has seven, so they fold:
+/// `SEVERE` is an error, `WARNING` a warning, `INFO` and `CONFIG` are
+/// information, and the three `FINE` levels are debug output. A record
+/// carries its logger's name in front of the message, and an attached
+/// exception is logged with it, which is what prints a stack trace on a
+/// device.
+///
+/// A logger with no level of its own logs `INFO` and above, the JDK's
+/// default; the platform log's own level may then filter once more. There are no
+/// handlers, filters, formatters or parents to configure: a call that would
+/// install one has no method here, and the build reports it.
+public class Logger {
+
+    public static final String GLOBAL_LOGGER_NAME = "global";
+
+    private static final Map<String, Logger> LOGGERS = new HashMap<String, Logger>();
+
+    private final String name;
+    private Level level;
+
+    protected Logger(String name, String resourceBundleName) {
+        this.name = name;
+    }
+
+    public static Logger getLogger(String name) {
+        if (name == null) {
+            throw new NullPointerException();
+        }
+        synchronized (LOGGERS) {
+            Logger logger = LOGGERS.get(name);
+            if (logger == null) {
+                logger = new Logger(name, null);
+                LOGGERS.put(name, logger);
+            }
+            return logger;
+        }
+    }
+
+    /// The bundle is not consulted: messages are logged as they are given.
+    public static Logger getLogger(String name, String resourceBundleName) {
+        return getLogger(name);
+    }
+
+    public static Logger getGlobal() {
+        return getLogger(GLOBAL_LOGGER_NAME);
+    }
+
+    public static Logger getAnonymousLogger() {
+        return new Logger(null, null);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Level getLevel() {
+        return level;
+    }
+
+    public void setLevel(Level newLevel) {
+        this.level = newLevel;
+    }
+
+    public Logger getParent() {
+        return null;
+    }
+
+    public void setUseParentHandlers(boolean useParentHandlers) {
+        // There are no handlers; see the class description.
+    }
+
+    public boolean getUseParentHandlers() {
+        return false;
+    }
+
+    public boolean isLoggable(Level l) {
+        int floor = (level == null ? Level.INFO : level).intValue();
+        return l.intValue() >= floor && floor != Level.OFF.intValue();
+    }
+
+    private static int logLevel(Level l) {
+        int value = l.intValue();
+        if (value >= Level.SEVERE.intValue()) {
+            return JdkHost.LOG_ERROR;
+        }
+        if (value >= Level.WARNING.intValue()) {
+            return JdkHost.LOG_WARNING;
+        }
+        if (value >= Level.CONFIG.intValue()) {
+            return JdkHost.LOG_INFO;
+        }
+        return JdkHost.LOG_DEBUG;
+    }
+
+    public void log(Level l, String msg) {
+        if (isLoggable(l)) {
+            JdkHost.get().log(logLevel(l), name == null ? String.valueOf(msg) : name + ": " + msg, null);
+        }
+    }
+
+    public void log(Level l, Supplier<String> msgSupplier) {
+        if (isLoggable(l)) {
+            log(l, msgSupplier.get());
+        }
+    }
+
+    public void log(Level l, String msg, Object param1) {
+        log(l, msg, new Object[] {param1});
+    }
+
+    /// Logs `msg` with each `{n}` replaced by parameter `n`, as the JDK's
+    /// formatter does.
+    public void log(Level l, String msg, Object[] params) {
+        if (!isLoggable(l)) {
+            return;
+        }
+        String text = msg;
+        if (text != null && params != null && params.length > 0 && text.indexOf('{') >= 0) {
+            text = substitute(text, params);
+        }
+        log(l, text);
+    }
+
+    /// `msg` with each `{n}` for which there is a parameter replaced by it.
+    /// The JDK formats with `MessageFormat`; this covers the plain index
+    /// form, which is what a log message uses, and leaves anything else --
+    /// a format type, quoting, a brace with no parameter -- as written.
+    private static String substitute(String msg, Object[] params) {
+        StringBuilder out = new StringBuilder(msg.length() + 16);
+        int i = 0;
+        while (i < msg.length()) {
+            char c = msg.charAt(i);
+            if (c == '{') {
+                int close = msg.indexOf('}', i + 1);
+                int index = close < 0 ? -1 : index(msg, i + 1, close);
+                if (index >= 0 && index < params.length) {
+                    out.append(String.valueOf(params[index]));
+                    i = close + 1;
+                    continue;
+                }
+            }
+            out.append(c);
+            i++;
+        }
+        return out.toString();
+    }
+
+    /// The decimal number spelled from `start` to `end`, or -1.
+    private static int index(String text, int start, int end) {
+        if (start == end || end - start > 4) {
+            return -1;
+        }
+        int value = 0;
+        for (int i = start; i < end; i++) {
+            char c = text.charAt(i);
+            if (c < '0' || c > '9') {
+                return -1;
+            }
+            value = value * 10 + (c - '0');
+        }
+        return value;
+    }
+
+    public void log(Level l, String msg, Throwable thrown) {
+        if (isLoggable(l)) {
+            JdkHost.get().log(logLevel(l), name == null ? String.valueOf(msg) : name + ": " + msg, thrown);
+        }
+    }
+
+    public void log(Level l, Throwable thrown, Supplier<String> msgSupplier) {
+        if (isLoggable(l)) {
+            log(l, msgSupplier.get(), thrown);
+        }
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg) {
+        log(l, msg);
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg, Object param1) {
+        log(l, msg, param1);
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg, Object[] params) {
+        log(l, msg, params);
+    }
+
+    public void logp(Level l, String sourceClass, String sourceMethod, String msg, Throwable thrown) {
+        log(l, msg, thrown);
+    }
+
+    public void entering(String sourceClass, String sourceMethod) {
+        log(Level.FINER, "ENTRY " + sourceClass + "." + sourceMethod);
+    }
+
+    public void entering(String sourceClass, String sourceMethod, Object param1) {
+        log(Level.FINER, "ENTRY " + sourceClass + "." + sourceMethod + " " + param1);
+    }
+
+    public void exiting(String sourceClass, String sourceMethod) {
+        log(Level.FINER, "RETURN " + sourceClass + "." + sourceMethod);
+    }
+
+    public void exiting(String sourceClass, String sourceMethod, Object result) {
+        log(Level.FINER, "RETURN " + sourceClass + "." + sourceMethod + " " + result);
+    }
+
+    public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
+        log(Level.FINER, "THROW " + sourceClass + "." + sourceMethod, thrown);
+    }
+
+    public void severe(String msg) {
+        log(Level.SEVERE, msg);
+    }
+
+    public void warning(String msg) {
+        log(Level.WARNING, msg);
+    }
+
+    public void info(String msg) {
+        log(Level.INFO, msg);
+    }
+
+    public void config(String msg) {
+        log(Level.CONFIG, msg);
+    }
+
+    public void fine(String msg) {
+        log(Level.FINE, msg);
+    }
+
+    public void finer(String msg) {
+        log(Level.FINER, msg);
+    }
+
+    public void finest(String msg) {
+        log(Level.FINEST, msg);
+    }
+
+    public void severe(Supplier<String> msgSupplier) {
+        log(Level.SEVERE, msgSupplier);
+    }
+
+    public void warning(Supplier<String> msgSupplier) {
+        log(Level.WARNING, msgSupplier);
+    }
+
+    public void info(Supplier<String> msgSupplier) {
+        log(Level.INFO, msgSupplier);
+    }
+
+    public void config(Supplier<String> msgSupplier) {
+        log(Level.CONFIG, msgSupplier);
+    }
+
+    public void fine(Supplier<String> msgSupplier) {
+        log(Level.FINE, msgSupplier);
+    }
+
+    public void finer(Supplier<String> msgSupplier) {
+        log(Level.FINER, msgSupplier);
+    }
+
+    public void finest(Supplier<String> msgSupplier) {
+        log(Level.FINEST, msgSupplier);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/prefs/BackingStoreException.java b/vm/JavaAPI/src/java/util/prefs/BackingStoreException.java
new file mode 100644
index 00000000000..819fd8a4867
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/prefs/BackingStoreException.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.prefs;
+
+/// A failure of the store under the preferences.
+/// [Preferences] declares it where the JDK does and never throws it: the
+/// store it writes to does not fail that way.
+public class BackingStoreException extends Exception {
+
+    private static final long serialVersionUID = 1L;
+
+    public BackingStoreException(String s) {
+        super(s);
+    }
+
+    public BackingStoreException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/prefs/Preferences.java b/vm/JavaAPI/src/java/util/prefs/Preferences.java
new file mode 100644
index 00000000000..7f446fe2749
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/prefs/Preferences.java
@@ -0,0 +1,529 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.prefs;
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/// Preferences kept in the platform's preference store, which
+/// `com.codename1.impl.JdkHost` reaches: `com.codename1.io.Preferences` in a
+/// Codename One application, memory for this run elsewhere.
+///
+/// The store is one flat table of the application's own, so a node is a
+/// prefix: the value of `key` in the node `/com/acme` is stored under the
+/// node's path and the key. The user and the system trees are the same
+/// tree -- an application on a device has no machine-wide settings to write.
+/// Every value is stored as text, as the JDK stores it, so `getInt` of
+/// something written with `put` reads it back.
+///
+/// Each node keeps the list of its keys beside them, which is what `keys`
+/// and `clear` answer from; the store cannot be asked for it. A node also
+/// keeps the names of its children that hold a key, or have a descendant
+/// that does: that is what `childrenNames` answers and what `removeNode`
+/// walks to remove a whole subtree. A node that only ever was asked for,
+/// and never written to, is not listed.
+///
+/// Writes are saved as they are made. `flush` and `sync` do nothing, and
+/// there are no change listeners.
+public abstract class Preferences {
+
+    public static final int MAX_KEY_LENGTH = 80;
+    public static final int MAX_VALUE_LENGTH = 8192;
+    public static final int MAX_NAME_LENGTH = 80;
+
+    private final String path;
+
+    /// [#removalCount] as it stood when this instance was made: a removal
+    /// of this node, or of one above it, numbered higher happened to it.
+    private final long born;
+
+    /// For the JDK's shape; the nodes this class hands out are its own.
+    protected Preferences() {
+        this("/");
+    }
+
+    private Preferences(String path) {
+        this.path = path;
+        synchronized (STORE_LOCK) {
+            born = removalCount;
+        }
+    }
+
+    public static Preferences userRoot() {
+        return new Node("/");
+    }
+
+    public static Preferences systemRoot() {
+        return new Node("/");
+    }
+
+    public static Preferences userNodeForPackage(Class<?> c) {
+        return new Node(packagePath(c));
+    }
+
+    public static Preferences systemNodeForPackage(Class<?> c) {
+        return new Node(packagePath(c));
+    }
+
+    private static String packagePath(Class<?> c) {
+        if (c.isArray()) {
+            throw new IllegalArgumentException("Arrays have no associated preferences node.");
+        }
+        String name = c.getName();
+        int dot = name.lastIndexOf('.');
+        return dot < 0 ? "/<unnamed>" : "/" + name.substring(0, dot).replace('.', '/');
+    }
+
+    /// The node at `pathName`: absolute when it starts with a slash, else
+    /// below this one.
+    public Preferences node(String pathName) {
+        checkLive();
+        if (pathName.length() == 0) {
+            return this;
+        }
+        if (pathName.charAt(0) == '/') {
+            return new Node(pathName);
+        }
+        return new Node("/".equals(path) ? "/" + pathName : path + "/" + pathName);
+    }
+
+    public String name() {
+        return "/".equals(path) ? "" : path.substring(path.lastIndexOf('/') + 1);
+    }
+
+    public String absolutePath() {
+        return path;
+    }
+
+    public Preferences parent() {
+        checkLive();
+        if ("/".equals(path)) {
+            return null;
+        }
+        int slash = path.lastIndexOf('/');
+        return new Node(slash <= 0 ? "/" : path.substring(0, slash));
+    }
+
+    public boolean isUserNode() {
+        return true;
+    }
+
+    /// Where `key` of this node is kept in Codename One's flat store: the
+    /// node's path and the key, each escaped, around one line break.
+    ///
+    /// A key may hold a `/`, so joining the two with one aliased entries:
+    /// `node("a").put("b/c", ...)` and `node("a/b").put("c", ...)` both
+    /// wrote `/a/b/c`. A node name may hold anything but `/`, a line break
+    /// too, so both halves are escaped and the one raw line break left is
+    /// where they meet. The index ([#indexKey()]) ends in a second raw line
+    /// break, which no escaped key can be.
+    private String storeKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("Null key");
+        }
+        return escape(path) + '\n' + escape(key);
+    }
+
+    private String indexKey() {
+        return escape(path) + "\n\n";
+    }
+
+    /// Where the names of the node's children are kept: three raw line
+    /// breaks, which neither a key ([#storeKey]) nor the index can end in.
+    private String childrenKey() {
+        return childrenKey(path);
+    }
+
+    private static String childrenKey(String nodePath) {
+        return escape(nodePath) + "\n\n\n";
+    }
+
+    private static String parentPath(String nodePath) {
+        int slash = nodePath.lastIndexOf('/');
+        return slash <= 0 ? "/" : nodePath.substring(0, slash);
+    }
+
+    private static String escape(String text) {
+        if (text.indexOf('\\') < 0 && text.indexOf('\n') < 0) {
+            return text;
+        }
+        StringBuilder out = new StringBuilder(text.length() + 8);
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == '\\') {
+                out.append("\\\\");
+            } else if (c == '\n') {
+                out.append("\\n");
+            } else {
+                out.append(c);
+            }
+        }
+        return out.toString();
+    }
+
+    /// Guards every use of the store, from every node. Codename One's
+    /// Preferences, and the Storage under it, are written for its one
+    /// thread: two workers saving at once threw inside Storage, which logs
+    /// the failure and goes on, so a value could be lost without a word.
+    /// It also makes each read-modify-write of an index whole: two threads
+    /// adding different keys to one node each read the same index, and the
+    /// one that saved last dropped the other's key for good. Static, since
+    /// two instances can stand for one node.
+    private static final Object STORE_LOCK = new Object();
+
+    /// The nodes removed in this run, each with the number of its removal.
+    /// Nodes are not cached -- two calls to `node` hand out two instances
+    /// for one path -- so an instance cannot be told it was removed; it
+    /// asks here instead, for its path and every one above it.
+    private static final Map<String, Long> REMOVALS = new HashMap<String, Long>();
+
+    private static long removalCount;
+
+    /// Throws as the JDK does for any use of a removed node.
+    private void checkLive() {
+        synchronized (STORE_LOCK) {
+            if (isRemoved()) {
+                throw new IllegalStateException("Node has been removed.");
+            }
+        }
+    }
+
+    /// Called under [#STORE_LOCK].
+    private boolean isRemoved() {
+        if (REMOVALS.isEmpty()) {
+            return false;
+        }
+        String at = path;
+        while (true) {
+            Long when = REMOVALS.get(at);
+            if (when != null && when.longValue() > born) {
+                return true;
+            }
+            if ("/".equals(at)) {
+                return false;
+            }
+            at = parentPath(at);
+        }
+    }
+
+    /// The node's keys, one per line. A key may hold any character, a line
+    /// break too, so a backslash and a line break inside one are written as
+    /// `\\` and `\n`; see [#saveIndex].
+    private List<String> index() {
+        return readList(indexKey());
+    }
+
+    private void saveIndex(List<String> keys) {
+        saveList(indexKey(), keys);
+    }
+
+    private static List<String> readList(String storeKey) {
+        List<String> keys = new ArrayList<String>();
+        String all = stored(storeKey, "");
+        StringBuilder key = new StringBuilder();
+        for (int i = 0; i < all.length(); i++) {
+            char c = all.charAt(i);
+            if (c == '\\' && i + 1 < all.length()) {
+                i++;
+                key.append(all.charAt(i) == 'n' ? '\n' : all.charAt(i));
+            } else if (c == '\n') {
+                keys.add(key.toString());
+                key.setLength(0);
+            } else {
+                key.append(c);
+            }
+        }
+        if (key.length() > 0) {
+            keys.add(key.toString());
+        }
+        return keys;
+    }
+
+    private static void saveList(String storeKey, List<String> keys) {
+        if (keys.isEmpty()) {
+            JdkHost.get().deletePreference(storeKey);
+            return;
+        }
+        StringBuilder all = new StringBuilder();
+        for (String key : keys) {
+            for (int i = 0; i < key.length(); i++) {
+                char c = key.charAt(i);
+                if (c == '\\') {
+                    all.append("\\\\");
+                } else if (c == '\n') {
+                    all.append("\\n");
+                } else {
+                    all.append(c);
+                }
+            }
+            all.append('\n');
+        }
+        JdkHost.get().setPreference(storeKey, all.toString());
+    }
+
+    /// Lists this node with its parent, and so on up, so that removing an
+    /// ancestor finds it. Stops at the first one already listed: a node is
+    /// only ever listed after everything above it.
+    private void register() {
+        String at = path;
+        while (!"/".equals(at)) {
+            String parent = parentPath(at);
+            String name = at.substring(at.lastIndexOf('/') + 1);
+            String key = childrenKey(parent);
+            List<String> names = readList(key);
+            if (names.contains(name)) {
+                return;
+            }
+            names.add(name);
+            saveList(key, names);
+            at = parent;
+        }
+    }
+
+    /// Deletes every entry of `nodePath` and of every node listed below it.
+    private static void removeTree(String nodePath) {
+        for (String child : readList(childrenKey(nodePath))) {
+            removeTree("/".equals(nodePath) ? "/" + child : nodePath + "/" + child);
+        }
+        String prefix = escape(nodePath) + '\n';
+        for (String key : readList(prefix + '\n')) {
+            JdkHost.get().deletePreference(prefix + escape(key));
+        }
+        JdkHost.get().deletePreference(prefix + '\n');
+        JdkHost.get().deletePreference(childrenKey(nodePath));
+    }
+
+    public void put(String key, String value) {
+        if (value == null) {
+            throw new NullPointerException("Null value");
+        }
+        synchronized (STORE_LOCK) {
+            checkLive();
+            JdkHost.get().setPreference(storeKey(key), value);
+            List<String> keys = index();
+            if (!keys.contains(key)) {
+                keys.add(key);
+                saveIndex(keys);
+            }
+            register();
+        }
+    }
+
+    public String get(String key, String def) {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            return stored(storeKey(key), def);
+        }
+    }
+
+    public void remove(String key) {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            JdkHost.get().deletePreference(storeKey(key));
+            List<String> keys = index();
+            if (keys.remove(key)) {
+                saveIndex(keys);
+            }
+        }
+    }
+
+    public void clear() throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            for (String key : index()) {
+                JdkHost.get().deletePreference(storeKey(key));
+            }
+            saveIndex(new ArrayList<String>());
+        }
+    }
+
+    public String[] keys() throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            List<String> keys = index();
+            return keys.toArray(new String[keys.size()]);
+        }
+    }
+
+    /// The children that hold a key, or have a descendant that does; see
+    /// the class description.
+    public String[] childrenNames() throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            checkLive();
+            List<String> names = readList(childrenKey());
+            return names.toArray(new String[names.size()]);
+        }
+    }
+
+    /// As the JDK: `nodeExists("")` answers whether this node is still
+    /// there, and is the one question a removed node may still be asked.
+    public boolean nodeExists(String pathName) throws BackingStoreException {
+        synchronized (STORE_LOCK) {
+            if (pathName.length() == 0) {
+                return !isRemoved();
+            }
+            Preferences node = node(pathName);
+            return !node.index().isEmpty() || !readList(node.childrenKey()).isEmpty();
+        }
+    }
+
+    /// Removes this node and everything below it, as the JDK does: their
+    /// entries are deleted, this instance and every other one for the
+    /// removed nodes throw `IllegalStateException` from then on, and a node
+    /// asked for again by its path afterwards is a new, empty one. The root
+    /// cannot be removed.
+    public void removeNode() throws BackingStoreException {
+        if ("/".equals(path)) {
+            throw new UnsupportedOperationException("Can't remove the root!");
+        }
+        synchronized (STORE_LOCK) {
+            if (isRemoved()) {
+                throw new IllegalStateException("Node already removed.");
+            }
+            removeTree(path);
+            String parentKey = childrenKey(parentPath(path));
+            List<String> siblings = readList(parentKey);
+            if (siblings.remove(path.substring(path.lastIndexOf('/') + 1))) {
+                saveList(parentKey, siblings);
+            }
+            recordRemoval(path);
+        }
+    }
+
+    /// Called under [#STORE_LOCK].
+    private static void recordRemoval(String nodePath) {
+        removalCount++;
+        REMOVALS.put(nodePath, Long.valueOf(removalCount));
+    }
+
+    public void putInt(String key, int value) {
+        put(key, Integer.toString(value));
+    }
+
+    public int getInt(String key, int def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Integer.parseInt(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void putLong(String key, long value) {
+        put(key, Long.toString(value));
+    }
+
+    public long getLong(String key, long def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Long.parseLong(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void putBoolean(String key, boolean value) {
+        put(key, value ? "true" : "false");
+    }
+
+    public boolean getBoolean(String key, boolean def) {
+        String value = get(key, null);
+        if ("true".equalsIgnoreCase(value)) {
+            return true;
+        }
+        if ("false".equalsIgnoreCase(value)) {
+            return false;
+        }
+        return def;
+    }
+
+    public void putFloat(String key, float value) {
+        put(key, Float.toString(value));
+    }
+
+    public float getFloat(String key, float def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Float.parseFloat(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void putDouble(String key, double value) {
+        put(key, Double.toString(value));
+    }
+
+    public double getDouble(String key, double def) {
+        String value = get(key, null);
+        if (value != null) {
+            try {
+                return Double.parseDouble(value.trim());
+            } catch (NumberFormatException e) {
+                return def;
+            }
+        }
+        return def;
+    }
+
+    public void flush() throws BackingStoreException {
+        // Saved as written; see the class description.
+    }
+
+    public void sync() throws BackingStoreException {
+        // Saved as written; see the class description. A removed node
+        // cannot be synced, as with the JDK (flushing one is allowed).
+        checkLive();
+    }
+
+    @Override
+    public String toString() {
+        return "User Preference Node: " + path;
+    }
+
+    /// The stored value of `storeKey`, or `def`.
+    private static String stored(String storeKey, String def) {
+        String value = JdkHost.get().preference(storeKey);
+        return value == null ? def : value;
+    }
+
+    /// The one concrete node.
+    private static final class Node extends Preferences {
+        Node(String path) {
+            super(path);
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/regex/Matcher.java b/vm/JavaAPI/src/java/util/regex/Matcher.java
deleted file mode 100644
index 7d3605808f4..00000000000
--- a/vm/JavaAPI/src/java/util/regex/Matcher.java
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2018, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package java.util.regex;
-
-public class Matcher implements MatchResult {
-    Matcher() {
-        
-    }
-    public Matcher appendReplacement(StringBuffer sb, String replacement) {
-        return null;
-    }
-    
-    public StringBuffer appendTail(StringBuffer sb) {
-        return null;
-    }
-    
-    public int end() {
-        return 0;
-    }
-    
-    public int end(int group) {
-        return 0;
-    }
-    
-    public boolean find() {
-        return false;
-    }
-    
-    public boolean find(int start) {
-        return false;
-    }
-    
-    public String group() {
-        return null;
-    }
-    
-    public String group(int group) {
-        return null;
-    }
-    
-    public String group(String name) {
-        return null;
-    }
-    
-    public int groupCount() {
-        return 0;
-    }
-    
-    public boolean hasAnchoringBounds() {
-        return false;
-    }
-    
-    public boolean hasTransparentBounds() {
-        return false;
-    }
-    
-    public boolean hitEnd() {
-        return false;
-    }
-    
-    public boolean lookingAt() {
-        return false;
-    }
-    public boolean matches() {
-        return false;
-    }
-    
-    public Pattern pattern() {
-        return null;
-    }
-    
-    public String quoteReplacement(String s) {
-        return null;
-    }
-    
-    public Matcher region(int start, int end) {
-        return null;
-    }
-    public int regionEnd() {
-        return 0;
-    }
-    
-    public int regionStart() {
-        return 0;
-    }
-    
-    public String replaceAll(String replacement) {
-        return null;
-    }
-    
-    public String replaceFirst(String replacement) {
-        return null;
-    }
-    
-    public boolean requireEnd() {
-        return false;
-    }
-    
-    public Matcher reset() {
-        return null;
-    }
-    
-    public Matcher reset(CharSequence input) {
-        return null;
-    }
-    
-    public int start() {
-        return 0;
-    }
-    
-    public int start(int group) {
-        return 0;
-    }
-    
-    public MatchResult toMatchResult() {
-        return null;
-    }
-    
-    public String toString() {
-        return null;
-    }
-    
-    public Matcher useAnchoringBounds(boolean b) {
-        return null;
-    }
-    
-    public Matcher usePattern(Pattern newPattern) {
-        return null;
-    }
-    
-    public Matcher useTransparentBounds(boolean b) {
-        return null;
-    }
-    
-    
-}
diff --git a/vm/JavaAPI/src/java/util/regex/Pattern.java b/vm/JavaAPI/src/java/util/regex/Pattern.java
deleted file mode 100644
index 536076dd90e..00000000000
--- a/vm/JavaAPI/src/java/util/regex/Pattern.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2018, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package java.util.regex;
-
-public class Pattern {
-    /**
-     * This constant specifies that a pattern matches Unix line endings ('\n')
-     * only against the '.', '^', and '$' meta characters.
-     */
-    public static final int UNIX_LINES = 1;
-
-    /**
-     * This constant specifies that a {@code Pattern} is matched
-     * case-insensitively. That is, the patterns "a+" and "A+" would both match
-     * the string "aAaAaA".
-     */
-    public static final int CASE_INSENSITIVE = 1 << 1;
-
-    /**
-     * This constant specifies that a {@code Pattern} may contain whitespace or
-     * comments. Otherwise comments and whitespace are taken as literal
-     * characters.
-     */
-    public static final int COMMENTS = 1 << 2;
-
-    /**
-     * This constant specifies that the meta characters '^' and '$' match only
-     * the beginning and end end of an input line, respectively. Normally, they
-     * match the beginning and the end of the complete input.
-     */
-    public static final int MULTILINE = 1 << 3;
-
-    /**
-     * This constant specifies that the whole {@code Pattern} is to be taken
-     * literally, that is, all meta characters lose their meanings.
-     */
-    public static final int LITERAL = 1 << 4;
-
-    /**
-     * This constant specifies that the '.' meta character matches arbitrary
-     * characters, including line endings, which is normally not the case.
-     */
-    public static final int DOTALL = 1 << 5;
-
-    /**
-     * This constant specifies that a {@code Pattern} is matched
-     * case-insensitively with regard to all Unicode characters. It is used in
-     * conjunction with the {@link #CASE_INSENSITIVE} constant to extend its
-     * meaning to all Unicode characters.
-     */
-    public static final int UNICODE_CASE = 1 << 6;
-
-    /**
-     * This constant specifies that a character in a {@code Pattern} and a
-     * character in the input string only match if they are canonically
-     * equivalent.
-     */
-    public static final int CANON_EQ = 1 << 7;
-
-    
-    public static Pattern compile(String regex) {
-        throw new UnsupportedOperationException("Pattern.compile() not implemented on this platform");
-    }
-    public static Pattern compile(String regex, int flags) {
-        throw new UnsupportedOperationException("Pattern.compile() not implemented on this platform");
-    }
-    public int flags() {
-        return 0;
-    }
-    public String toString() {
-        return null;
-    }
-    public static boolean matches(String regex, CharSequence input) {
-        throw new UnsupportedOperationException("Pattern.matches() not implemented on thsi platform");
-    }
-    
-    public Matcher matcher(CharSequence input) {
-        return null;
-    }
-    
-    public String pattern() {
-        return null;
-    }
-    
-    public static String quote(String input) {
-        throw new UnsupportedOperationException("Pattern.quote() not implemented on this platform");
-    }
-    
-    public String[] split(CharSequence input) {
-        return null;
-    }
-    
-    public String[] split(CharSequence input, int limit) {
-        return null;
-    }
-    
-    private Pattern() {
-        
-    }
-    
-}
diff --git a/vm/JavaAPI/src/java/util/stream/BaseStream.java b/vm/JavaAPI/src/java/util/stream/BaseStream.java
index 63e61583529..7310abdb7bb 100644
--- a/vm/JavaAPI/src/java/util/stream/BaseStream.java
+++ b/vm/JavaAPI/src/java/util/stream/BaseStream.java
@@ -24,14 +24,25 @@
 
 import java.util.Iterator;
 
+/// What the
+/// object stream and the three primitive ones have in common.
+///
+/// Streams here are sequential. `parallel()` exists because code calls it,
+/// and answers the stream it was called on.
 public interface BaseStream<T, S extends BaseStream<T, S>> extends AutoCloseable {
+
     Iterator<T> iterator();
 
+    boolean isParallel();
+
     S sequential();
 
     S parallel();
 
+    S unordered();
+
     S onClose(Runnable closeHandler);
 
+    @Override
     void close();
 }
diff --git a/vm/JavaAPI/src/java/util/stream/Collector.java b/vm/JavaAPI/src/java/util/stream/Collector.java
index 67a7519bb39..767b5541de6 100644
--- a/vm/JavaAPI/src/java/util/stream/Collector.java
+++ b/vm/JavaAPI/src/java/util/stream/Collector.java
@@ -1,11 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.stream;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+/// How [Stream#collect(Collector)] folds the elements of a stream into a
+/// result: a container to start from, a step per element, a way to merge two
+/// containers and a last step that turns the container into the result.
 public interface Collector<T, A, R> {
+
     Supplier<A> supplier();
 
     BiConsumer<A, T> accumulator();
@@ -13,4 +43,37 @@ public interface Collector<T, A, R> {
     BinaryOperator<A> combiner();
 
     Function<A, R> finisher();
+
+    Set<Characteristics> characteristics();
+
+    static <T, R> Collector<T, R, R> of(Supplier<R> supplier, BiConsumer<R, T> accumulator,
+                                        BinaryOperator<R> combiner, Characteristics... characteristics) {
+        if (supplier == null || accumulator == null || combiner == null || characteristics == null) {
+            throw new NullPointerException();
+        }
+        Set<Characteristics> all = new HashSet<Characteristics>(Arrays.asList(characteristics));
+        all.add(Characteristics.IDENTITY_FINISH);
+        return new Collectors.Of<T, R, R>(supplier, accumulator, combiner, Function.<R>identity(),
+                Collections.unmodifiableSet(all));
+    }
+
+    static <T, A, R> Collector<T, A, R> of(Supplier<A> supplier, BiConsumer<A, T> accumulator,
+                                           BinaryOperator<A> combiner, Function<A, R> finisher,
+                                           Characteristics... characteristics) {
+        if (supplier == null || accumulator == null || combiner == null || finisher == null
+                || characteristics == null) {
+            throw new NullPointerException();
+        }
+        Set<Characteristics> all = new HashSet<Characteristics>(Arrays.asList(characteristics));
+        return new Collectors.Of<T, A, R>(supplier, accumulator, combiner, finisher,
+                Collections.unmodifiableSet(all));
+    }
+
+    /// What a collector says about itself. Nothing here acts on them: a
+    /// sequential stream runs every collector the same way.
+    enum Characteristics {
+        CONCURRENT,
+        UNORDERED,
+        IDENTITY_FINISH
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/stream/Collectors.java b/vm/JavaAPI/src/java/util/stream/Collectors.java
index afac38aed4f..3ef7bb0e244 100644
--- a/vm/JavaAPI/src/java/util/stream/Collectors.java
+++ b/vm/JavaAPI/src/java/util/stream/Collectors.java
@@ -1,87 +1,785 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
 package java.util.stream;
 
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IntSummaryStatistics;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
 
+/// The common [Collector]s: into collections, maps, strings, groups and
+/// numbers.
+///
+/// The results are the JDK's: `groupingBy` answers a `HashMap` of
+/// `ArrayList`s unless told otherwise, `toMap` refuses a second value for a
+/// key unless given a function to merge them, and the unmodifiable variants
+/// refuse null.
+///
+/// Every function here is a class of its own, made only by the method that
+/// needs it, so an application carries the collectors it uses and no others.
 public final class Collectors {
+
     private Collectors() {
     }
 
-    public static <T> Collector<T, List<T>, List<T>> toList() {
-        return new Collector<T, List<T>, List<T>>() {
-            public Supplier<List<T>> supplier() {
-                return new Supplier<List<T>>() {
-                    public List<T> get() {
-                        return new ArrayList<T>();
-                    }
-                };
+    /// A collector made of its four functions.
+    static final class Of<T, A, R> implements Collector<T, A, R> {
+
+        private final Supplier<A> supplier;
+        private final BiConsumer<A, T> accumulator;
+        private final BinaryOperator<A> combiner;
+        private final Function<A, R> finisher;
+        private final Set<Characteristics> characteristics;
+
+        Of(Supplier<A> supplier, BiConsumer<A, T> accumulator, BinaryOperator<A> combiner, Function<A, R> finisher,
+           Set<Characteristics> characteristics) {
+            this.supplier = supplier;
+            this.accumulator = accumulator;
+            this.combiner = combiner;
+            this.finisher = finisher;
+            this.characteristics = characteristics;
+        }
+
+        @Override
+        public Supplier<A> supplier() {
+            return supplier;
+        }
+
+        @Override
+        public BiConsumer<A, T> accumulator() {
+            return accumulator;
+        }
+
+        @Override
+        public BinaryOperator<A> combiner() {
+            return combiner;
+        }
+
+        @Override
+        public Function<A, R> finisher() {
+            return finisher;
+        }
+
+        @Override
+        public Set<Characteristics> characteristics() {
+            return characteristics;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T, A, R> Collector<T, A, R> of(Supplier<A> supplier, BiConsumer<A, ? super T> accumulator,
+                                                   BinaryOperator<A> combiner, Function<A, R> finisher) {
+        return new Of<T, A, R>(supplier, (BiConsumer<A, T>) accumulator, combiner, finisher,
+                Collections.<Collector.Characteristics>emptySet());
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <A, R> Function<A, R> castingIdentity() {
+        return (Function<A, R>) Function.identity();
+    }
+
+    /// One value being folded, and whether any element reached it yet.
+    private static final class Box<T> {
+        T value;
+        boolean present;
+
+        Box(T value, boolean present) {
+            this.value = value;
+            this.present = present;
+        }
+    }
+
+    // ---- into collections ----
+
+    private static <T, C extends Collection<T>> BiConsumer<C, T> adder() {
+        return new BiConsumer<C, T>() {
+            @Override
+            public void accept(C c, T t) {
+                c.add(t);
             }
+        };
+    }
 
-            public BiConsumer<List<T>, T> accumulator() {
-                return new BiConsumer<List<T>, T>() {
-                    public void accept(List<T> target, T value) {
-                        target.add(value);
-                    }
-                };
+    private static <T, C extends Collection<T>> BinaryOperator<C> addAll() {
+        return new BinaryOperator<C>() {
+            @Override
+            public C apply(C a, C b) {
+                a.addAll(b);
+                return a;
             }
+        };
+    }
 
-            public BinaryOperator<List<T>> combiner() {
-                return new BinaryOperator<List<T>>() {
-                    public List<T> apply(List<T> left, List<T> right) {
-                        left.addAll(right);
-                        return left;
-                    }
-                };
+    private static <T> Supplier<List<T>> newArrayList() {
+        return new Supplier<List<T>>() {
+            @Override
+            public List<T> get() {
+                return new ArrayList<T>();
             }
+        };
+    }
 
-            public Function<List<T>, List<T>> finisher() {
-                return new Function<List<T>, List<T>>() {
-                    public List<T> apply(List<T> value) {
-                        return value;
-                    }
-                };
+    private static <T> Supplier<Set<T>> newHashSet() {
+        return new Supplier<Set<T>>() {
+            @Override
+            public Set<T> get() {
+                return new HashSet<T>();
             }
         };
     }
 
-    public static Collector<CharSequence, StringBuilder, String> joining() {
-        return new Collector<CharSequence, StringBuilder, String>() {
-            public Supplier<StringBuilder> supplier() {
-                return new Supplier<StringBuilder>() {
-                    public StringBuilder get() {
-                        return new StringBuilder();
+    public static <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
+        Objects.requireNonNull(collectionFactory);
+        return Collectors.<T, C, C>of(collectionFactory, Collectors.<T, C>adder(), Collectors.<T, C>addAll(),
+                Collectors.<C, C>castingIdentity());
+    }
+
+    public static <T> Collector<T, ?, List<T>> toList() {
+        return Collectors.<T, List<T>, List<T>>of(Collectors.<T>newArrayList(), Collectors.<T, List<T>>adder(),
+                Collectors.<T, List<T>>addAll(), Collectors.<List<T>, List<T>>castingIdentity());
+    }
+
+    public static <T> Collector<T, ?, List<T>> toUnmodifiableList() {
+        return Collectors.<T, List<T>, List<T>>of(Collectors.<T>newArrayList(), Collectors.<T, List<T>>adder(),
+                Collectors.<T, List<T>>addAll(), new Function<List<T>, List<T>>() {
+                    @Override
+                    public List<T> apply(List<T> c) {
+                        return List.copyOf(c);
                     }
-                };
-            }
+                });
+    }
+
+    public static <T> Collector<T, ?, Set<T>> toSet() {
+        return Collectors.<T, Set<T>, Set<T>>of(Collectors.<T>newHashSet(), Collectors.<T, Set<T>>adder(),
+                Collectors.<T, Set<T>>addAll(), Collectors.<Set<T>, Set<T>>castingIdentity());
+    }
 
-            public BiConsumer<StringBuilder, CharSequence> accumulator() {
-                return new BiConsumer<StringBuilder, CharSequence>() {
-                    public void accept(StringBuilder target, CharSequence value) {
-                        target.append(value);
+    public static <T> Collector<T, ?, Set<T>> toUnmodifiableSet() {
+        return Collectors.<T, Set<T>, Set<T>>of(Collectors.<T>newHashSet(), Collectors.<T, Set<T>>adder(),
+                Collectors.<T, Set<T>>addAll(), new Function<Set<T>, Set<T>>() {
+                    @Override
+                    public Set<T> apply(Set<T> c) {
+                        return Set.copyOf(c);
                     }
-                };
+                });
+    }
+
+    // ---- into a string ----
+
+    /// What `java.util.StringJoiner` does for [#joining(CharSequence,
+    /// CharSequence, CharSequence)].
+    private static final class Joiner {
+        private final String delimiter;
+        private final String prefix;
+        private final String suffix;
+        private StringBuilder value;
+
+        Joiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix) {
+            this.delimiter = delimiter.toString();
+            this.prefix = prefix.toString();
+            this.suffix = suffix.toString();
+        }
+
+        private StringBuilder next() {
+            if (value == null) {
+                value = new StringBuilder().append(prefix);
+            } else {
+                value.append(delimiter);
+            }
+            return value;
+        }
+
+        void add(CharSequence s) {
+            next().append(String.valueOf(s));
+        }
+
+        /// Adds what `other` holds, without its prefix and suffix, as one element.
+        void merge(Joiner other) {
+            if (other.value != null) {
+                next().append(other.value, other.prefix.length(), other.value.length());
+            }
+        }
+
+        @Override
+        public String toString() {
+            return value == null ? prefix + suffix : value.toString() + suffix;
+        }
+    }
+
+    public static Collector<CharSequence, ?, String> joining() {
+        return Collectors.<CharSequence, StringBuilder, String>of(new Supplier<StringBuilder>() {
+            @Override
+            public StringBuilder get() {
+                return new StringBuilder();
+            }
+        }, new BiConsumer<StringBuilder, CharSequence>() {
+            @Override
+            public void accept(StringBuilder sb, CharSequence s) {
+                sb.append(String.valueOf(s));
+            }
+        }, new BinaryOperator<StringBuilder>() {
+            @Override
+            public StringBuilder apply(StringBuilder a, StringBuilder b) {
+                return a.append(b.toString());
+            }
+        }, new Function<StringBuilder, String>() {
+            @Override
+            public String apply(StringBuilder sb) {
+                return sb.toString();
+            }
+        });
+    }
+
+    public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
+        return joining(delimiter, "", "");
+    }
+
+    public static Collector<CharSequence, ?, String> joining(final CharSequence delimiter,
+                                                             final CharSequence prefix, final CharSequence suffix) {
+        if (delimiter == null || prefix == null || suffix == null) {
+            throw new NullPointerException();
+        }
+        return Collectors.<CharSequence, Joiner, String>of(new Supplier<Joiner>() {
+            @Override
+            public Joiner get() {
+                return new Joiner(delimiter, prefix, suffix);
+            }
+        }, new BiConsumer<Joiner, CharSequence>() {
+            @Override
+            public void accept(Joiner j, CharSequence s) {
+                j.add(s);
             }
+        }, new BinaryOperator<Joiner>() {
+            @Override
+            public Joiner apply(Joiner a, Joiner b) {
+                a.merge(b);
+                return a;
+            }
+        }, new Function<Joiner, String>() {
+            @Override
+            public String apply(Joiner j) {
+                return j.toString();
+            }
+        });
+    }
 
-            public BinaryOperator<StringBuilder> combiner() {
-                return new BinaryOperator<StringBuilder>() {
-                    public StringBuilder apply(StringBuilder left, StringBuilder right) {
-                        left.append(right);
-                        return left;
+    // ---- adapting another collector ----
+
+    public static <T, U, A, R> Collector<T, ?, R> mapping(final Function<? super T, ? extends U> mapper,
+                                                          Collector<? super U, A, R> downstream) {
+        Objects.requireNonNull(mapper);
+        final BiConsumer<A, ? super U> inner = downstream.accumulator();
+        return Collectors.<T, A, R>of(downstream.supplier(), new BiConsumer<A, T>() {
+            @Override
+            public void accept(A a, T t) {
+                inner.accept(a, mapper.apply(t));
+            }
+        }, downstream.combiner(), downstream.finisher());
+    }
+
+    public static <T, A, R> Collector<T, ?, R> filtering(final Predicate<? super T> predicate,
+                                                         Collector<? super T, A, R> downstream) {
+        Objects.requireNonNull(predicate);
+        final BiConsumer<A, ? super T> inner = downstream.accumulator();
+        return Collectors.<T, A, R>of(downstream.supplier(), new BiConsumer<A, T>() {
+            @Override
+            public void accept(A a, T t) {
+                if (predicate.test(t)) {
+                    inner.accept(a, t);
+                }
+            }
+        }, downstream.combiner(), downstream.finisher());
+    }
+
+    public static <T, U, A, R> Collector<T, ?, R> flatMapping(
+            final Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, A, R> downstream) {
+        Objects.requireNonNull(mapper);
+        final BiConsumer<A, ? super U> inner = downstream.accumulator();
+        return Collectors.<T, A, R>of(downstream.supplier(), new BiConsumer<A, T>() {
+            @Override
+            public void accept(A a, T t) {
+                Stream<? extends U> mapped = mapper.apply(t);
+                if (mapped != null) {
+                    try {
+                        Iterator<? extends U> it = mapped.iterator();
+                        while (it.hasNext()) {
+                            inner.accept(a, it.next());
+                        }
+                    } finally {
+                        mapped.close();
                     }
-                };
+                }
             }
+        }, downstream.combiner(), downstream.finisher());
+    }
 
-            public Function<StringBuilder, String> finisher() {
-                return new Function<StringBuilder, String>() {
-                    public String apply(StringBuilder value) {
-                        return value.toString();
+    public static <T, A, R, RR> Collector<T, A, RR> collectingAndThen(Collector<T, A, R> downstream,
+                                                                      final Function<R, RR> finisher) {
+        Objects.requireNonNull(finisher);
+        final Function<A, R> first = downstream.finisher();
+        return Collectors.<T, A, RR>of(downstream.supplier(), downstream.accumulator(), downstream.combiner(),
+                new Function<A, RR>() {
+                    @Override
+                    public RR apply(A a) {
+                        return finisher.apply(first.apply(a));
                     }
-                };
+                });
+    }
+
+    // ---- numbers ----
+
+    /// Folds the `long` values `mapper` answers into a [LongSummaryStatistics];
+    /// `mapper` null counts the elements instead.
+    private static <T> Collector<T, LongSummaryStatistics, LongSummaryStatistics> longs(
+            final ToLongFunction<? super T> mapper) {
+        return Collectors.<T, LongSummaryStatistics, LongSummaryStatistics>of(
+                new Supplier<LongSummaryStatistics>() {
+                    @Override
+                    public LongSummaryStatistics get() {
+                        return new LongSummaryStatistics();
+                    }
+                }, new BiConsumer<LongSummaryStatistics, T>() {
+                    @Override
+                    public void accept(LongSummaryStatistics a, T t) {
+                        a.accept(mapper == null ? 1L : mapper.applyAsLong(t));
+                    }
+                }, new BinaryOperator<LongSummaryStatistics>() {
+                    @Override
+                    public LongSummaryStatistics apply(LongSummaryStatistics a, LongSummaryStatistics b) {
+                        a.combine(b);
+                        return a;
+                    }
+                }, Collectors.<LongSummaryStatistics, LongSummaryStatistics>castingIdentity());
+    }
+
+    private static <T> Collector<T, IntSummaryStatistics, IntSummaryStatistics> ints(
+            final ToIntFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, IntSummaryStatistics, IntSummaryStatistics>of(
+                new Supplier<IntSummaryStatistics>() {
+                    @Override
+                    public IntSummaryStatistics get() {
+                        return new IntSummaryStatistics();
+                    }
+                }, new BiConsumer<IntSummaryStatistics, T>() {
+                    @Override
+                    public void accept(IntSummaryStatistics a, T t) {
+                        a.accept(mapper.applyAsInt(t));
+                    }
+                }, new BinaryOperator<IntSummaryStatistics>() {
+                    @Override
+                    public IntSummaryStatistics apply(IntSummaryStatistics a, IntSummaryStatistics b) {
+                        a.combine(b);
+                        return a;
+                    }
+                }, Collectors.<IntSummaryStatistics, IntSummaryStatistics>castingIdentity());
+    }
+
+    private static <T> Collector<T, DoubleSummaryStatistics, DoubleSummaryStatistics> doubles(
+            final ToDoubleFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, DoubleSummaryStatistics, DoubleSummaryStatistics>of(
+                new Supplier<DoubleSummaryStatistics>() {
+                    @Override
+                    public DoubleSummaryStatistics get() {
+                        return new DoubleSummaryStatistics();
+                    }
+                }, new BiConsumer<DoubleSummaryStatistics, T>() {
+                    @Override
+                    public void accept(DoubleSummaryStatistics a, T t) {
+                        a.accept(mapper.applyAsDouble(t));
+                    }
+                }, new BinaryOperator<DoubleSummaryStatistics>() {
+                    @Override
+                    public DoubleSummaryStatistics apply(DoubleSummaryStatistics a, DoubleSummaryStatistics b) {
+                        a.combine(b);
+                        return a;
+                    }
+                }, Collectors.<DoubleSummaryStatistics, DoubleSummaryStatistics>castingIdentity());
+    }
+
+    /// Statistics a collector folds into, answering one of their figures.
+    private static final int SUM = 0;
+    private static final int AVERAGE = 1;
+    private static final int COUNT = 2;
+
+    private static <S, R> Function<S, R> figure(final int which) {
+        return new Function<S, R>() {
+            @Override
+            @SuppressWarnings("unchecked")
+            public R apply(S s) {
+                Object out;
+                if (s instanceof IntSummaryStatistics) {
+                    IntSummaryStatistics i = (IntSummaryStatistics) s;
+                    out = which == SUM ? (Object) Integer.valueOf((int) i.getSum()) : Double.valueOf(i.getAverage());
+                } else if (s instanceof LongSummaryStatistics) {
+                    LongSummaryStatistics l = (LongSummaryStatistics) s;
+                    out = which == AVERAGE ? (Object) Double.valueOf(l.getAverage())
+                            : Long.valueOf(which == SUM ? l.getSum() : l.getCount());
+                } else {
+                    DoubleSummaryStatistics d = (DoubleSummaryStatistics) s;
+                    out = Double.valueOf(which == SUM ? d.getSum() : d.getAverage());
+                }
+                return (R) out;
             }
         };
     }
+
+    private static <T, S, R> Collector<T, S, R> finishing(Collector<T, S, S> folded, int which) {
+        return Collectors.<T, S, R>of(folded.supplier(), folded.accumulator(), folded.combiner(),
+                Collectors.<S, R>figure(which));
+    }
+
+    public static <T> Collector<T, ?, Long> counting() {
+        return Collectors.<T, LongSummaryStatistics, Long>finishing(Collectors.<T>longs(null), COUNT);
+    }
+
+    public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper) {
+        return Collectors.<T, IntSummaryStatistics, Integer>finishing(ints(mapper), SUM);
+    }
+
+    public static <T> Collector<T, ?, Long> summingLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, LongSummaryStatistics, Long>finishing(longs(mapper), SUM);
+    }
+
+    public static <T> Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper) {
+        return Collectors.<T, DoubleSummaryStatistics, Double>finishing(doubles(mapper), SUM);
+    }
+
+    public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper) {
+        return Collectors.<T, IntSummaryStatistics, Double>finishing(ints(mapper), AVERAGE);
+    }
+
+    public static <T> Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return Collectors.<T, LongSummaryStatistics, Double>finishing(longs(mapper), AVERAGE);
+    }
+
+    public static <T> Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper) {
+        return Collectors.<T, DoubleSummaryStatistics, Double>finishing(doubles(mapper), AVERAGE);
+    }
+
+    public static <T> Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper) {
+        return ints(mapper);
+    }
+
+    public static <T> Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        return longs(mapper);
+    }
+
+    public static <T> Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(
+            ToDoubleFunction<? super T> mapper) {
+        return doubles(mapper);
+    }
+
+    // ---- reductions ----
+
+    public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op) {
+        return Collectors.<T, T>reducing(identity, Function.<T>identity(), op);
+    }
+
+    public static <T> Collector<T, ?, Optional<T>> reducing(final BinaryOperator<T> op) {
+        Objects.requireNonNull(op);
+        return Collectors.<T, Box<T>, Optional<T>>of(new Supplier<Box<T>>() {
+            @Override
+            public Box<T> get() {
+                return new Box<T>(null, false);
+            }
+        }, new BiConsumer<Box<T>, T>() {
+            @Override
+            public void accept(Box<T> a, T t) {
+                a.value = a.present ? op.apply(a.value, t) : t;
+                a.present = true;
+            }
+        }, new BinaryOperator<Box<T>>() {
+            @Override
+            public Box<T> apply(Box<T> a, Box<T> b) {
+                if (b.present) {
+                    a.value = a.present ? op.apply(a.value, b.value) : b.value;
+                    a.present = true;
+                }
+                return a;
+            }
+        }, new Function<Box<T>, Optional<T>>() {
+            @Override
+            public Optional<T> apply(Box<T> a) {
+                return Optional.ofNullable(a.value);
+            }
+        });
+    }
+
+    public static <T, U> Collector<T, ?, U> reducing(final U identity, final Function<? super T, ? extends U> mapper,
+                                                     final BinaryOperator<U> op) {
+        Objects.requireNonNull(mapper);
+        Objects.requireNonNull(op);
+        return Collectors.<T, Box<U>, U>of(new Supplier<Box<U>>() {
+            @Override
+            public Box<U> get() {
+                return new Box<U>(identity, true);
+            }
+        }, new BiConsumer<Box<U>, T>() {
+            @Override
+            public void accept(Box<U> a, T t) {
+                a.value = op.apply(a.value, mapper.apply(t));
+            }
+        }, new BinaryOperator<Box<U>>() {
+            @Override
+            public Box<U> apply(Box<U> a, Box<U> b) {
+                a.value = op.apply(a.value, b.value);
+                return a;
+            }
+        }, new Function<Box<U>, U>() {
+            @Override
+            public U apply(Box<U> a) {
+                return a.value;
+            }
+        });
+    }
+
+    public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator) {
+        return reducing(BinaryOperator.<T>minBy(comparator));
+    }
+
+    public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator) {
+        return reducing(BinaryOperator.<T>maxBy(comparator));
+    }
+
+    // ---- groups ----
+
+    public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier) {
+        return groupingBy(classifier, Collectors.<T>toList());
+    }
+
+    public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
+                                                                     Collector<? super T, A, D> downstream) {
+        return Collectors.<T, K, D, A, Map<K, D>>groupingBy(classifier, new Supplier<Map<K, D>>() {
+            @Override
+            public Map<K, D> get() {
+                return new HashMap<K, D>();
+            }
+        }, downstream);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(
+            final Function<? super T, ? extends K> classifier, final Supplier<M> mapFactory,
+            Collector<? super T, A, D> downstream) {
+        Objects.requireNonNull(classifier);
+        Objects.requireNonNull(mapFactory);
+        final Supplier<A> innerSupplier = downstream.supplier();
+        final BiConsumer<A, ? super T> innerAccumulator = downstream.accumulator();
+        final BinaryOperator<A> innerCombiner = downstream.combiner();
+        final Function<A, D> innerFinisher = downstream.finisher();
+        // While elements arrive the map holds each group's container, and
+        // the finisher puts the group's result in its place: one map, of
+        // the kind the caller asked for.
+        return Collectors.<T, Map<K, A>, M>of(new Supplier<Map<K, A>>() {
+            @Override
+            public Map<K, A> get() {
+                return (Map<K, A>) mapFactory.get();
+            }
+        }, new BiConsumer<Map<K, A>, T>() {
+            @Override
+            public void accept(Map<K, A> m, T t) {
+                K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
+                A container = m.get(key);
+                if (container == null) {
+                    container = innerSupplier.get();
+                    m.put(key, container);
+                }
+                innerAccumulator.accept(container, t);
+            }
+        }, new BinaryOperator<Map<K, A>>() {
+            @Override
+            public Map<K, A> apply(Map<K, A> a, Map<K, A> b) {
+                for (Map.Entry<K, A> e : b.entrySet()) {
+                    A mine = a.get(e.getKey());
+                    a.put(e.getKey(), mine == null ? e.getValue() : innerCombiner.apply(mine, e.getValue()));
+                }
+                return a;
+            }
+        }, new Function<Map<K, A>, M>() {
+            @Override
+            public M apply(Map<K, A> m) {
+                Map<K, Object> out = (Map<K, Object>) m;
+                for (K key : new ArrayList<K>(m.keySet())) {
+                    out.put(key, innerFinisher.apply(m.get(key)));
+                }
+                return (M) out;
+            }
+        });
+    }
+
+    public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
+        return partitioningBy(predicate, Collectors.<T>toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(final Predicate<? super T> predicate,
+                                                                            Collector<? super T, A, D> downstream) {
+        Objects.requireNonNull(predicate);
+        final Supplier<A> innerSupplier = downstream.supplier();
+        final BiConsumer<A, ? super T> innerAccumulator = downstream.accumulator();
+        final BinaryOperator<A> innerCombiner = downstream.combiner();
+        final Function<A, D> innerFinisher = downstream.finisher();
+        return Collectors.<T, Object[], Map<Boolean, D>>of(new Supplier<Object[]>() {
+            @Override
+            public Object[] get() {
+                return new Object[] {innerSupplier.get(), innerSupplier.get()};
+            }
+        }, new BiConsumer<Object[], T>() {
+            @Override
+            public void accept(Object[] a, T t) {
+                innerAccumulator.accept((A) a[predicate.test(t) ? 1 : 0], t);
+            }
+        }, new BinaryOperator<Object[]>() {
+            @Override
+            public Object[] apply(Object[] a, Object[] b) {
+                a[0] = innerCombiner.apply((A) a[0], (A) b[0]);
+                a[1] = innerCombiner.apply((A) a[1], (A) b[1]);
+                return a;
+            }
+        }, new Function<Object[], Map<Boolean, D>>() {
+            @Override
+            public Map<Boolean, D> apply(Object[] a) {
+                // Both keys are always there, false first.
+                Map<Boolean, D> out = new LinkedHashMap<Boolean, D>();
+                out.put(Boolean.FALSE, innerFinisher.apply((A) a[0]));
+                out.put(Boolean.TRUE, innerFinisher.apply((A) a[1]));
+                return out;
+            }
+        });
+    }
+
+    // ---- maps ----
+
+    /// Puts `value` under `key`; a second value for a key is an error when
+    /// `mergeFunction` is null and merged with the first otherwise, a merged
+    /// null removing the key.
+    static <K, U> void put(Map<K, U> map, K key, U value, BinaryOperator<U> mergeFunction) {
+        Objects.requireNonNull(value);
+        U old = map.get(key);
+        if (old == null) {
+            map.put(key, value);
+            return;
+        }
+        if (mergeFunction == null) {
+            throw new IllegalStateException("Duplicate key " + key + " (attempted merging values " + old + " and "
+                    + value + ")");
+        }
+        U merged = mergeFunction.apply(old, value);
+        if (merged == null) {
+            map.remove(key);
+        } else {
+            map.put(key, merged);
+        }
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper,
+                                                             Function<? super T, ? extends U> valueMapper) {
+        return Collectors.<T, K, U, Map<K, U>>toMap(keyMapper, valueMapper, null, Collectors.<K, U>newHashMap());
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(Function<? super T, ? extends K> keyMapper,
+                                                             Function<? super T, ? extends U> valueMapper,
+                                                             BinaryOperator<U> mergeFunction) {
+        Objects.requireNonNull(mergeFunction);
+        return Collectors.<T, K, U, Map<K, U>>toMap(keyMapper, valueMapper, mergeFunction,
+                Collectors.<K, U>newHashMap());
+    }
+
+    private static <K, U> Supplier<Map<K, U>> newHashMap() {
+        return new Supplier<Map<K, U>>() {
+            @Override
+            public Map<K, U> get() {
+                return new HashMap<K, U>();
+            }
+        };
+    }
+
+    public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
+            final Function<? super T, ? extends K> keyMapper, final Function<? super T, ? extends U> valueMapper,
+            final BinaryOperator<U> mergeFunction, Supplier<M> mapFactory) {
+        Objects.requireNonNull(keyMapper);
+        Objects.requireNonNull(valueMapper);
+        Objects.requireNonNull(mapFactory);
+        return Collectors.<T, M, M>of(mapFactory, new BiConsumer<M, T>() {
+            @Override
+            public void accept(M m, T t) {
+                put(m, keyMapper.apply(t), valueMapper.apply(t), mergeFunction);
+            }
+        }, new BinaryOperator<M>() {
+            @Override
+            public M apply(M a, M b) {
+                for (Map.Entry<K, U> e : b.entrySet()) {
+                    put(a, e.getKey(), e.getValue(), mergeFunction);
+                }
+                return a;
+            }
+        }, Collectors.<M, M>castingIdentity());
+    }
+
+    private static <K, U> Function<Map<K, U>, Map<K, U>> unmodifiableMap() {
+        return new Function<Map<K, U>, Map<K, U>>() {
+            @Override
+            public Map<K, U> apply(Map<K, U> m) {
+                return Map.copyOf(m);
+            }
+        };
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableMap(
+            Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {
+        return collectingAndThen(Collectors.<T, K, U>toMap(keyMapper, valueMapper),
+                Collectors.<K, U>unmodifiableMap());
+    }
+
+    public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableMap(
+            Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
+            BinaryOperator<U> mergeFunction) {
+        return collectingAndThen(Collectors.<T, K, U>toMap(keyMapper, valueMapper, mergeFunction),
+                Collectors.<K, U>unmodifiableMap());
+    }
 }
diff --git a/vm/JavaAPI/src/java/util/stream/DoublePipeline.java b/vm/JavaAPI/src/java/util/stream/DoublePipeline.java
new file mode 100644
index 00000000000..0d269c7688a
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/DoublePipeline.java
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.DoubleSummaryStatistics;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleSupplier;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.Function;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// The one implementation of [DoubleStream]: a view of a stream of boxed values,
+/// which does the work. Boxing costs little on ParparVM, where a boxed
+/// `double` from `valueOf` is usually an immediate rather than an object.
+final class DoublePipeline implements DoubleStream {
+
+    private final Stream<Double> boxed;
+
+    DoublePipeline(Stream<Double> boxed) {
+        this.boxed = boxed;
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static DoubleStream ofArray(final double[] values, final int from, final int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return new DoublePipeline(ObjPipeline.over(new PullIterator<Double>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(Double.valueOf(values[at++]));
+                return true;
+            }
+        }));
+    }
+
+    static DoubleStream iterate(double seed, DoublePredicate hasNext, DoubleUnaryOperator next) {
+        Objects.requireNonNull(next);
+        UnaryOperator<Double> step = Fn.<Double, Double>function(Fn.MAP, next);
+        if (hasNext == null) {
+            return new DoublePipeline(Stream.<Double>iterate(Double.valueOf(seed), step));
+        }
+        return new DoublePipeline(Stream.<Double>iterate(Double.valueOf(seed), Fn.<Double>predicate(hasNext), step));
+    }
+
+    @SuppressWarnings("unchecked")
+    static DoubleStream generate(DoubleSupplier s) {
+        Objects.requireNonNull(s);
+        return new DoublePipeline(Stream.<Double>generate((Supplier<Double>) new Fn(Fn.GET, s)));
+    }
+
+    /// Each primitive function this stream is handed, as the object function
+    /// the boxed stream underneath takes. One class for every operation keeps
+    /// an application that uses this stream from carrying a class per method.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final class Fn implements Predicate, UnaryOperator, Consumer, Supplier {
+        static final int TEST = 0;
+        static final int MAP = 1;
+        static final int TO_OBJ = 2;
+        static final int TO_INT = 3;
+        static final int TO_LONG = 4;
+        static final int FLAT = 5;
+        static final int BOX = 6;
+        static final int ACCEPT = 7;
+        static final int GET = 8;
+
+        private final int kind;
+        private final Object fn;
+
+        Fn(int kind, Object fn) {
+            this.kind = kind;
+            this.fn = fn;
+        }
+
+        static <T, R> UnaryOperator function(int kind, Object fn) {
+            return new Fn(kind, fn);
+        }
+
+        static <T> Predicate<T> predicate(DoublePredicate fn) {
+            return new Fn(TEST, fn);
+        }
+
+        static <T> Consumer<T> consumer(DoubleConsumer fn) {
+            return new Fn(ACCEPT, fn);
+        }
+
+        @Override
+        public boolean test(Object o) {
+            return ((DoublePredicate) fn).test(((Double) o).doubleValue());
+        }
+
+        @Override
+        public Object apply(Object o) {
+            if (kind == BOX) {
+                return o;
+            }
+            double v = ((Double) o).doubleValue();
+            switch (kind) {
+                case MAP:
+                    return Double.valueOf(((DoubleUnaryOperator) fn).applyAsDouble(v));
+                case TO_OBJ:
+                    return ((DoubleFunction) fn).apply(v);
+                case TO_INT:
+                    return Integer.valueOf(((DoubleToIntFunction) fn).applyAsInt(v));
+                case TO_LONG:
+                    return Long.valueOf(((DoubleToLongFunction) fn).applyAsLong(v));
+                default: {
+                    DoubleStream inner = (DoubleStream) ((DoubleFunction) fn).apply(v);
+                    return inner == null ? null : inner.boxed();
+                }
+            }
+        }
+
+        @Override
+        public void accept(Object o) {
+            ((DoubleConsumer) fn).accept(((Double) o).doubleValue());
+        }
+
+        @Override
+        public Object get() {
+            return Double.valueOf(((DoubleSupplier) fn).getAsDouble());
+        }
+    }
+
+    @Override
+    public DoubleStream filter(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new DoublePipeline(boxed.filter(Fn.<Double>predicate(predicate)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public DoubleStream map(DoubleUnaryOperator mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>map(Fn.<Double, Double>function(Fn.MAP, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper) {
+        Objects.requireNonNull(mapper);
+        return boxed.<U>map(Fn.<Double, U>function(Fn.TO_OBJ, mapper));
+    }
+
+    @Override
+    public IntStream mapToInt(DoubleToIntFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>map(Fn.<Double, Integer>function(Fn.TO_INT, mapper)));
+    }
+
+    @Override
+    public LongStream mapToLong(DoubleToLongFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>map(Fn.<Double, Long>function(Fn.TO_LONG, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>flatMap(Fn.<Double, Stream<Double>>function(Fn.FLAT, mapper)));
+    }
+
+    @Override
+    public DoubleStream distinct() {
+        return new DoublePipeline(boxed.distinct());
+    }
+
+    @Override
+    public DoubleStream sorted() {
+        return new DoublePipeline(boxed.sorted());
+    }
+
+    @Override
+    public DoubleStream peek(DoubleConsumer action) {
+        Objects.requireNonNull(action);
+        return new DoublePipeline(boxed.peek(Fn.<Double>consumer(action)));
+    }
+
+    @Override
+    public DoubleStream limit(long maxSize) {
+        return new DoublePipeline(boxed.limit(maxSize));
+    }
+
+    @Override
+    public DoubleStream skip(long n) {
+        return new DoublePipeline(boxed.skip(n));
+    }
+
+    @Override
+    public DoubleStream takeWhile(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new DoublePipeline(boxed.takeWhile(Fn.<Double>predicate(predicate)));
+    }
+
+    @Override
+    public DoubleStream dropWhile(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new DoublePipeline(boxed.dropWhile(Fn.<Double>predicate(predicate)));
+    }
+
+    @Override
+    public void forEach(DoubleConsumer action) {
+        Objects.requireNonNull(action);
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next().doubleValue());
+            }
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(DoubleConsumer action) {
+        forEach(action);
+    }
+
+    @Override
+    public double[] toArray() {
+        List<Double> all = new ArrayList<Double>();
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            double[] out = new double[all.size()];
+            for (int i = 0; i < out.length; i++) {
+                out[i] = all.get(i).doubleValue();
+            }
+            return out;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public double reduce(double identity, DoubleBinaryOperator op) {
+        Objects.requireNonNull(op);
+        double result = identity;
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                result = op.applyAsDouble(result, it.next().doubleValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalDouble reduce(DoubleBinaryOperator op) {
+        Objects.requireNonNull(op);
+        Iterator<Double> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalDouble.empty();
+            }
+            double result = it.next().doubleValue();
+            while (it.hasNext()) {
+                result = op.applyAsDouble(result, it.next().doubleValue());
+            }
+            return OptionalDouble.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next().doubleValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public double sum() {
+        return summaryStatistics().getSum();
+    }
+
+    /// The smallest (`max` false) or largest value, as `Math.min` and
+    /// `Math.max` choose, which is what the JDK's reduction uses.
+    private OptionalDouble extreme(boolean max) {
+        Iterator<Double> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalDouble.empty();
+            }
+            double result = it.next().doubleValue();
+            while (it.hasNext()) {
+                double v = it.next().doubleValue();
+                result = max ? Math.max(result, v) : Math.min(result, v);
+            }
+            return OptionalDouble.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalDouble min() {
+        return extreme(false);
+    }
+
+    @Override
+    public OptionalDouble max() {
+        return extreme(true);
+    }
+
+    @Override
+    public long count() {
+        return boxed.count();
+    }
+
+    @Override
+    public OptionalDouble average() {
+        DoubleSummaryStatistics all = summaryStatistics();
+        return all.getCount() == 0 ? OptionalDouble.empty() : OptionalDouble.of(all.getAverage());
+    }
+
+    @Override
+    public DoubleSummaryStatistics summaryStatistics() {
+        DoubleSummaryStatistics all = new DoubleSummaryStatistics();
+        Iterator<Double> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.accept(it.next().doubleValue());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.anyMatch(Fn.<Double>predicate(predicate));
+    }
+
+    @Override
+    public boolean allMatch(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.allMatch(Fn.<Double>predicate(predicate));
+    }
+
+    @Override
+    public boolean noneMatch(DoublePredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.noneMatch(Fn.<Double>predicate(predicate));
+    }
+
+    @Override
+    public OptionalDouble findFirst() {
+        // Through the boxed stream's own, which says that the rest is not
+        // going to be read: a mapped stream left part read is closed.
+        Optional<Double> first = boxed.findFirst();
+        return first.isPresent() ? OptionalDouble.of(first.get().doubleValue()) : OptionalDouble.empty();
+    }
+
+    @Override
+    public OptionalDouble findAny() {
+        return findFirst();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Stream<Double> boxed() {
+        // A stage of its own, so that this stream counts as used like any
+        // other that had an operation applied to it.
+        return boxed.map(Fn.<Double, Double>function(Fn.BOX, null));
+    }
+
+    @Override
+    public PrimitiveIterator.OfDouble iterator() {
+        return new Unboxing(boxed.iterator());
+    }
+
+    /// The elements of the boxed pipeline, one primitive at a time.
+    private static final class Unboxing implements PrimitiveIterator.OfDouble {
+        private final Iterator<Double> it;
+
+        Unboxing(Iterator<Double> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public double nextDouble() {
+            return it.next().doubleValue();
+        }
+    }
+
+    @Override
+    public boolean isParallel() {
+        return boxed.isParallel();
+    }
+
+    @Override
+    public DoubleStream sequential() {
+        boxed.sequential();
+        return this;
+    }
+
+    @Override
+    public DoubleStream parallel() {
+        boxed.parallel();
+        return this;
+    }
+
+    @Override
+    public DoubleStream unordered() {
+        return this;
+    }
+
+    @Override
+    public DoubleStream onClose(Runnable closeHandler) {
+        boxed.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        boxed.close();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/DoubleStream.java b/vm/JavaAPI/src/java/util/stream/DoubleStream.java
new file mode 100644
index 00000000000..907d9f74769
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/DoubleStream.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.DoubleSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleSupplier;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.Supplier;
+
+/// A sequence of `double` values to which operations are applied one stage at a
+/// time, evaluated lazily, one element at a time, when a terminal operation
+/// asks for them.
+///
+/// Streams here are sequential: `parallel()` answers the same stream, which
+/// the JDK allows a parallel stream to be.
+public interface DoubleStream extends BaseStream<Double, DoubleStream> {
+
+    /// Declared again with this type, as the JDK does: a call compiled
+    /// against the JDK names `DoubleStream.sequential()` answering `DoubleStream`,
+    /// and the method inherited from [BaseStream] answers its type
+    /// variable, which is another descriptor.
+    @Override
+    DoubleStream sequential();
+
+    /// Declared again with this type; see [#sequential()].
+    @Override
+    DoubleStream parallel();
+
+    DoubleStream filter(DoublePredicate predicate);
+
+    DoubleStream map(DoubleUnaryOperator mapper);
+
+    <U> Stream<U> mapToObj(DoubleFunction<? extends U> mapper);
+
+    IntStream mapToInt(DoubleToIntFunction mapper);
+
+    LongStream mapToLong(DoubleToLongFunction mapper);
+
+    DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper);
+
+    DoubleStream distinct();
+
+    DoubleStream sorted();
+
+    DoubleStream peek(DoubleConsumer action);
+
+    DoubleStream limit(long maxSize);
+
+    DoubleStream skip(long n);
+
+    DoubleStream takeWhile(DoublePredicate predicate);
+
+    DoubleStream dropWhile(DoublePredicate predicate);
+
+    void forEach(DoubleConsumer action);
+
+    void forEachOrdered(DoubleConsumer action);
+
+    double[] toArray();
+
+    double reduce(double identity, DoubleBinaryOperator op);
+
+    OptionalDouble reduce(DoubleBinaryOperator op);
+
+    <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+    double sum();
+
+    OptionalDouble min();
+
+    OptionalDouble max();
+
+    long count();
+
+    OptionalDouble average();
+
+    DoubleSummaryStatistics summaryStatistics();
+
+    boolean anyMatch(DoublePredicate predicate);
+
+    boolean allMatch(DoublePredicate predicate);
+
+    boolean noneMatch(DoublePredicate predicate);
+
+    OptionalDouble findFirst();
+
+    OptionalDouble findAny();
+
+    Stream<Double> boxed();
+
+    @Override
+    PrimitiveIterator.OfDouble iterator();
+
+    static DoubleStream empty() {
+        return DoublePipeline.ofArray(new double[0], 0, 0);
+    }
+
+    static DoubleStream of(double value) {
+        return DoublePipeline.ofArray(new double[] {value}, 0, 1);
+    }
+
+    static DoubleStream of(double... values) {
+        return DoublePipeline.ofArray(values, 0, values.length);
+    }
+
+    /// `seed`, then `f` applied to it, then `f` applied to that, without end.
+    static DoubleStream iterate(double seed, DoubleUnaryOperator f) {
+        return DoublePipeline.iterate(seed, null, f);
+    }
+
+    /// As [#iterate(double, DoubleUnaryOperator)], ending before the first value
+    /// `hasNext` refuses.
+    static DoubleStream iterate(double seed, DoublePredicate hasNext, DoubleUnaryOperator next) {
+        if (hasNext == null) {
+            throw new NullPointerException();
+        }
+        return DoublePipeline.iterate(seed, hasNext, next);
+    }
+
+    /// The values `s` answers, one call per element, without end.
+    static DoubleStream generate(DoubleSupplier s) {
+        return DoublePipeline.generate(s);
+    }
+
+    /// The elements of `a`, then those of `b`. Closing the result closes both.
+    static DoubleStream concat(DoubleStream a, DoubleStream b) {
+        return new DoublePipeline(Stream.concat(a.boxed(), b.boxed()));
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/IntPipeline.java b/vm/JavaAPI/src/java/util/stream/IntPipeline.java
new file mode 100644
index 00000000000..c0dec4cd833
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/IntPipeline.java
@@ -0,0 +1,536 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.IntSummaryStatistics;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// The one implementation of [IntStream]: a view of a stream of boxed values,
+/// which does the work. Boxing costs little on ParparVM, where a boxed
+/// `int` from `valueOf` is usually an immediate rather than an object.
+final class IntPipeline implements IntStream {
+
+    private final Stream<Integer> boxed;
+
+    IntPipeline(Stream<Integer> boxed) {
+        this.boxed = boxed;
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static IntStream ofArray(final int[] values, final int from, final int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return new IntPipeline(ObjPipeline.over(new PullIterator<Integer>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(Integer.valueOf(values[at++]));
+                return true;
+            }
+        }));
+    }
+
+    /// The values from `start` up to `end`, which is part of them when
+    /// `closed`. An empty stream when `start` is past `end`.
+    static IntStream ofRange(final int start, final int end, final boolean closed) {
+        return new IntPipeline(ObjPipeline.over(new PullIterator<Integer>() {
+            private int next = start;
+            /// Whether `next` is still to be handed out. Counting towards
+            /// `end` with a flag, not past it, is what keeps a closed range
+            /// that ends at the largest value from wrapping around.
+            private boolean more = closed ? start <= end : start < end;
+
+            @Override
+            boolean advance() {
+                if (!more) {
+                    return false;
+                }
+                emit(Integer.valueOf(next));
+                if (closed ? next < end : next < end - 1) {
+                    next++;
+                } else {
+                    more = false;
+                }
+                return true;
+            }
+        }));
+    }
+
+    static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator next) {
+        Objects.requireNonNull(next);
+        UnaryOperator<Integer> step = Fn.<Integer, Integer>function(Fn.MAP, next);
+        if (hasNext == null) {
+            return new IntPipeline(Stream.<Integer>iterate(Integer.valueOf(seed), step));
+        }
+        return new IntPipeline(Stream.<Integer>iterate(Integer.valueOf(seed), Fn.<Integer>predicate(hasNext), step));
+    }
+
+    @SuppressWarnings("unchecked")
+    static IntStream generate(IntSupplier s) {
+        Objects.requireNonNull(s);
+        return new IntPipeline(Stream.<Integer>generate((Supplier<Integer>) new Fn(Fn.GET, s)));
+    }
+
+    /// Each primitive function this stream is handed, as the object function
+    /// the boxed stream underneath takes. One class for every operation keeps
+    /// an application that uses this stream from carrying a class per method.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final class Fn implements Predicate, UnaryOperator, Consumer, Supplier {
+        static final int TEST = 0;
+        static final int MAP = 1;
+        static final int TO_OBJ = 2;
+        static final int TO_LONG = 3;
+        static final int TO_DOUBLE = 4;
+        static final int WIDEN_LONG = 5;
+        static final int WIDEN_DOUBLE = 6;
+        static final int FLAT = 7;
+        static final int BOX = 8;
+        static final int ACCEPT = 9;
+        static final int GET = 10;
+
+        private final int kind;
+        private final Object fn;
+
+        Fn(int kind, Object fn) {
+            this.kind = kind;
+            this.fn = fn;
+        }
+
+        static <T, R> UnaryOperator function(int kind, Object fn) {
+            return new Fn(kind, fn);
+        }
+
+        static <T> Predicate<T> predicate(IntPredicate fn) {
+            return new Fn(TEST, fn);
+        }
+
+        static <T> Consumer<T> consumer(IntConsumer fn) {
+            return new Fn(ACCEPT, fn);
+        }
+
+        @Override
+        public boolean test(Object o) {
+            return ((IntPredicate) fn).test(((Integer) o).intValue());
+        }
+
+        @Override
+        public Object apply(Object o) {
+            if (kind == BOX) {
+                return o;
+            }
+            int v = ((Integer) o).intValue();
+            switch (kind) {
+                case MAP:
+                    return Integer.valueOf(((IntUnaryOperator) fn).applyAsInt(v));
+                case TO_OBJ:
+                    return ((IntFunction) fn).apply(v);
+                case TO_LONG:
+                    return Long.valueOf(((IntToLongFunction) fn).applyAsLong(v));
+                case TO_DOUBLE:
+                    return Double.valueOf(((IntToDoubleFunction) fn).applyAsDouble(v));
+                case WIDEN_LONG:
+                    return Long.valueOf(v);
+                case WIDEN_DOUBLE:
+                    return Double.valueOf(v);
+                default: {
+                    IntStream inner = (IntStream) ((IntFunction) fn).apply(v);
+                    return inner == null ? null : inner.boxed();
+                }
+            }
+        }
+
+        @Override
+        public void accept(Object o) {
+            ((IntConsumer) fn).accept(((Integer) o).intValue());
+        }
+
+        @Override
+        public Object get() {
+            return Integer.valueOf(((IntSupplier) fn).getAsInt());
+        }
+    }
+
+    @Override
+    public IntStream filter(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new IntPipeline(boxed.filter(Fn.<Integer>predicate(predicate)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public IntStream map(IntUnaryOperator mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>map(Fn.<Integer, Integer>function(Fn.MAP, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
+        Objects.requireNonNull(mapper);
+        return boxed.<U>map(Fn.<Integer, U>function(Fn.TO_OBJ, mapper));
+    }
+
+    @Override
+    public LongStream mapToLong(IntToLongFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>map(Fn.<Integer, Long>function(Fn.TO_LONG, mapper)));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>map(Fn.<Integer, Double>function(Fn.TO_DOUBLE, mapper)));
+    }
+
+    @Override
+    public LongStream asLongStream() {
+        return new LongPipeline(boxed.<Long>map(Fn.<Integer, Long>function(Fn.WIDEN_LONG, null)));
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+        return new DoublePipeline(boxed.<Double>map(Fn.<Integer, Double>function(Fn.WIDEN_DOUBLE, null)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>flatMap(Fn.<Integer, Stream<Integer>>function(Fn.FLAT, mapper)));
+    }
+
+    @Override
+    public IntStream distinct() {
+        return new IntPipeline(boxed.distinct());
+    }
+
+    @Override
+    public IntStream sorted() {
+        return new IntPipeline(boxed.sorted());
+    }
+
+    @Override
+    public IntStream peek(IntConsumer action) {
+        Objects.requireNonNull(action);
+        return new IntPipeline(boxed.peek(Fn.<Integer>consumer(action)));
+    }
+
+    @Override
+    public IntStream limit(long maxSize) {
+        return new IntPipeline(boxed.limit(maxSize));
+    }
+
+    @Override
+    public IntStream skip(long n) {
+        return new IntPipeline(boxed.skip(n));
+    }
+
+    @Override
+    public IntStream takeWhile(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new IntPipeline(boxed.takeWhile(Fn.<Integer>predicate(predicate)));
+    }
+
+    @Override
+    public IntStream dropWhile(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new IntPipeline(boxed.dropWhile(Fn.<Integer>predicate(predicate)));
+    }
+
+    @Override
+    public void forEach(IntConsumer action) {
+        Objects.requireNonNull(action);
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next().intValue());
+            }
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(IntConsumer action) {
+        forEach(action);
+    }
+
+    @Override
+    public int[] toArray() {
+        List<Integer> all = new ArrayList<Integer>();
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            int[] out = new int[all.size()];
+            for (int i = 0; i < out.length; i++) {
+                out[i] = all.get(i).intValue();
+            }
+            return out;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public int reduce(int identity, IntBinaryOperator op) {
+        Objects.requireNonNull(op);
+        int result = identity;
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                result = op.applyAsInt(result, it.next().intValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalInt reduce(IntBinaryOperator op) {
+        Objects.requireNonNull(op);
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalInt.empty();
+            }
+            int result = it.next().intValue();
+            while (it.hasNext()) {
+                result = op.applyAsInt(result, it.next().intValue());
+            }
+            return OptionalInt.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next().intValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public int sum() {
+        int total = 0;
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                total += it.next().intValue();
+            }
+            return total;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    /// The smallest (`max` false) or largest value, as `Math.min` and
+    /// `Math.max` choose, which is what the JDK's reduction uses.
+    private OptionalInt extreme(boolean max) {
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalInt.empty();
+            }
+            int result = it.next().intValue();
+            while (it.hasNext()) {
+                int v = it.next().intValue();
+                result = max ? Math.max(result, v) : Math.min(result, v);
+            }
+            return OptionalInt.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalInt min() {
+        return extreme(false);
+    }
+
+    @Override
+    public OptionalInt max() {
+        return extreme(true);
+    }
+
+    @Override
+    public long count() {
+        return boxed.count();
+    }
+
+    @Override
+    public OptionalDouble average() {
+        IntSummaryStatistics all = summaryStatistics();
+        return all.getCount() == 0 ? OptionalDouble.empty() : OptionalDouble.of(all.getAverage());
+    }
+
+    @Override
+    public IntSummaryStatistics summaryStatistics() {
+        IntSummaryStatistics all = new IntSummaryStatistics();
+        Iterator<Integer> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.accept(it.next().intValue());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.anyMatch(Fn.<Integer>predicate(predicate));
+    }
+
+    @Override
+    public boolean allMatch(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.allMatch(Fn.<Integer>predicate(predicate));
+    }
+
+    @Override
+    public boolean noneMatch(IntPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.noneMatch(Fn.<Integer>predicate(predicate));
+    }
+
+    @Override
+    public OptionalInt findFirst() {
+        // Through the boxed stream's own, which says that the rest is not
+        // going to be read: a mapped stream left part read is closed.
+        Optional<Integer> first = boxed.findFirst();
+        return first.isPresent() ? OptionalInt.of(first.get().intValue()) : OptionalInt.empty();
+    }
+
+    @Override
+    public OptionalInt findAny() {
+        return findFirst();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Stream<Integer> boxed() {
+        // A stage of its own, so that this stream counts as used like any
+        // other that had an operation applied to it.
+        return boxed.map(Fn.<Integer, Integer>function(Fn.BOX, null));
+    }
+
+    @Override
+    public PrimitiveIterator.OfInt iterator() {
+        return new Unboxing(boxed.iterator());
+    }
+
+    /// The elements of the boxed pipeline, one primitive at a time.
+    private static final class Unboxing implements PrimitiveIterator.OfInt {
+        private final Iterator<Integer> it;
+
+        Unboxing(Iterator<Integer> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public int nextInt() {
+            return it.next().intValue();
+        }
+    }
+
+    @Override
+    public boolean isParallel() {
+        return boxed.isParallel();
+    }
+
+    @Override
+    public IntStream sequential() {
+        boxed.sequential();
+        return this;
+    }
+
+    @Override
+    public IntStream parallel() {
+        boxed.parallel();
+        return this;
+    }
+
+    @Override
+    public IntStream unordered() {
+        return this;
+    }
+
+    @Override
+    public IntStream onClose(Runnable closeHandler) {
+        boxed.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        boxed.close();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/IntStream.java b/vm/JavaAPI/src/java/util/stream/IntStream.java
new file mode 100644
index 00000000000..c5edbe6ad4f
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/IntStream.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.IntSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.ObjIntConsumer;
+import java.util.function.Supplier;
+
+/// A sequence of `int` values to which operations are applied one stage at a
+/// time, evaluated lazily, one element at a time, when a terminal operation
+/// asks for them.
+///
+/// Streams here are sequential: `parallel()` answers the same stream, which
+/// the JDK allows a parallel stream to be.
+public interface IntStream extends BaseStream<Integer, IntStream> {
+
+    /// Declared again with this type, as the JDK does: a call compiled
+    /// against the JDK names `IntStream.sequential()` answering `IntStream`,
+    /// and the method inherited from [BaseStream] answers its type
+    /// variable, which is another descriptor.
+    @Override
+    IntStream sequential();
+
+    /// Declared again with this type; see [#sequential()].
+    @Override
+    IntStream parallel();
+
+    IntStream filter(IntPredicate predicate);
+
+    IntStream map(IntUnaryOperator mapper);
+
+    <U> Stream<U> mapToObj(IntFunction<? extends U> mapper);
+
+    LongStream mapToLong(IntToLongFunction mapper);
+
+    DoubleStream mapToDouble(IntToDoubleFunction mapper);
+
+    IntStream flatMap(IntFunction<? extends IntStream> mapper);
+
+    IntStream distinct();
+
+    IntStream sorted();
+
+    IntStream peek(IntConsumer action);
+
+    IntStream limit(long maxSize);
+
+    IntStream skip(long n);
+
+    IntStream takeWhile(IntPredicate predicate);
+
+    IntStream dropWhile(IntPredicate predicate);
+
+    void forEach(IntConsumer action);
+
+    void forEachOrdered(IntConsumer action);
+
+    int[] toArray();
+
+    int reduce(int identity, IntBinaryOperator op);
+
+    OptionalInt reduce(IntBinaryOperator op);
+
+    <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+    int sum();
+
+    OptionalInt min();
+
+    OptionalInt max();
+
+    long count();
+
+    OptionalDouble average();
+
+    IntSummaryStatistics summaryStatistics();
+
+    boolean anyMatch(IntPredicate predicate);
+
+    boolean allMatch(IntPredicate predicate);
+
+    boolean noneMatch(IntPredicate predicate);
+
+    OptionalInt findFirst();
+
+    OptionalInt findAny();
+
+    LongStream asLongStream();
+
+    DoubleStream asDoubleStream();
+
+    Stream<Integer> boxed();
+
+    @Override
+    PrimitiveIterator.OfInt iterator();
+
+    static IntStream empty() {
+        return IntPipeline.ofArray(new int[0], 0, 0);
+    }
+
+    static IntStream of(int value) {
+        return IntPipeline.ofArray(new int[] {value}, 0, 1);
+    }
+
+    static IntStream of(int... values) {
+        return IntPipeline.ofArray(values, 0, values.length);
+    }
+
+    /// `seed`, then `f` applied to it, then `f` applied to that, without end.
+    static IntStream iterate(int seed, IntUnaryOperator f) {
+        return IntPipeline.iterate(seed, null, f);
+    }
+
+    /// As [#iterate(int, IntUnaryOperator)], ending before the first value
+    /// `hasNext` refuses.
+    static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator next) {
+        if (hasNext == null) {
+            throw new NullPointerException();
+        }
+        return IntPipeline.iterate(seed, hasNext, next);
+    }
+
+    /// The values `s` answers, one call per element, without end.
+    static IntStream generate(IntSupplier s) {
+        return IntPipeline.generate(s);
+    }
+
+    /// The values from `startInclusive` up to, not including, `endExclusive`,
+    /// in steps of one. Empty when `startInclusive` is not below `endExclusive`.
+    static IntStream range(int startInclusive, int endExclusive) {
+        return IntPipeline.ofRange(startInclusive, endExclusive, false);
+    }
+
+    /// The values from `startInclusive` up to and including `endInclusive`, in
+    /// steps of one. Empty when `startInclusive` is above `endInclusive`.
+    static IntStream rangeClosed(int startInclusive, int endInclusive) {
+        return IntPipeline.ofRange(startInclusive, endInclusive, true);
+    }
+
+    /// The elements of `a`, then those of `b`. Closing the result closes both.
+    static IntStream concat(IntStream a, IntStream b) {
+        return new IntPipeline(Stream.concat(a.boxed(), b.boxed()));
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/LongPipeline.java b/vm/JavaAPI/src/java/util/stream/LongPipeline.java
new file mode 100644
index 00000000000..b58c5921d4d
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/LongPipeline.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongSupplier;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjLongConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/// The one implementation of [LongStream]: a view of a stream of boxed values,
+/// which does the work. Boxing costs little on ParparVM, where a boxed
+/// `long` from `valueOf` is usually an immediate rather than an object.
+final class LongPipeline implements LongStream {
+
+    private final Stream<Long> boxed;
+
+    LongPipeline(Stream<Long> boxed) {
+        this.boxed = boxed;
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static LongStream ofArray(final long[] values, final int from, final int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return new LongPipeline(ObjPipeline.over(new PullIterator<Long>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(Long.valueOf(values[at++]));
+                return true;
+            }
+        }));
+    }
+
+    /// The values from `start` up to `end`, which is part of them when
+    /// `closed`. An empty stream when `start` is past `end`.
+    static LongStream ofRange(final long start, final long end, final boolean closed) {
+        return new LongPipeline(ObjPipeline.over(new PullIterator<Long>() {
+            private long next = start;
+            /// Whether `next` is still to be handed out. Counting towards
+            /// `end` with a flag, not past it, is what keeps a closed range
+            /// that ends at the largest value from wrapping around.
+            private boolean more = closed ? start <= end : start < end;
+
+            @Override
+            boolean advance() {
+                if (!more) {
+                    return false;
+                }
+                emit(Long.valueOf(next));
+                if (closed ? next < end : next < end - 1) {
+                    next++;
+                } else {
+                    more = false;
+                }
+                return true;
+            }
+        }));
+    }
+
+    static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator next) {
+        Objects.requireNonNull(next);
+        UnaryOperator<Long> step = Fn.<Long, Long>function(Fn.MAP, next);
+        if (hasNext == null) {
+            return new LongPipeline(Stream.<Long>iterate(Long.valueOf(seed), step));
+        }
+        return new LongPipeline(Stream.<Long>iterate(Long.valueOf(seed), Fn.<Long>predicate(hasNext), step));
+    }
+
+    @SuppressWarnings("unchecked")
+    static LongStream generate(LongSupplier s) {
+        Objects.requireNonNull(s);
+        return new LongPipeline(Stream.<Long>generate((Supplier<Long>) new Fn(Fn.GET, s)));
+    }
+
+    /// Each primitive function this stream is handed, as the object function
+    /// the boxed stream underneath takes. One class for every operation keeps
+    /// an application that uses this stream from carrying a class per method.
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final class Fn implements Predicate, UnaryOperator, Consumer, Supplier {
+        static final int TEST = 0;
+        static final int MAP = 1;
+        static final int TO_OBJ = 2;
+        static final int TO_INT = 3;
+        static final int TO_DOUBLE = 4;
+        static final int WIDEN_DOUBLE = 5;
+        static final int FLAT = 6;
+        static final int BOX = 7;
+        static final int ACCEPT = 8;
+        static final int GET = 9;
+
+        private final int kind;
+        private final Object fn;
+
+        Fn(int kind, Object fn) {
+            this.kind = kind;
+            this.fn = fn;
+        }
+
+        static <T, R> UnaryOperator function(int kind, Object fn) {
+            return new Fn(kind, fn);
+        }
+
+        static <T> Predicate<T> predicate(LongPredicate fn) {
+            return new Fn(TEST, fn);
+        }
+
+        static <T> Consumer<T> consumer(LongConsumer fn) {
+            return new Fn(ACCEPT, fn);
+        }
+
+        @Override
+        public boolean test(Object o) {
+            return ((LongPredicate) fn).test(((Long) o).longValue());
+        }
+
+        @Override
+        public Object apply(Object o) {
+            if (kind == BOX) {
+                return o;
+            }
+            long v = ((Long) o).longValue();
+            switch (kind) {
+                case MAP:
+                    return Long.valueOf(((LongUnaryOperator) fn).applyAsLong(v));
+                case TO_OBJ:
+                    return ((LongFunction) fn).apply(v);
+                case TO_INT:
+                    return Integer.valueOf(((LongToIntFunction) fn).applyAsInt(v));
+                case TO_DOUBLE:
+                    return Double.valueOf(((LongToDoubleFunction) fn).applyAsDouble(v));
+                case WIDEN_DOUBLE:
+                    return Double.valueOf(v);
+                default: {
+                    LongStream inner = (LongStream) ((LongFunction) fn).apply(v);
+                    return inner == null ? null : inner.boxed();
+                }
+            }
+        }
+
+        @Override
+        public void accept(Object o) {
+            ((LongConsumer) fn).accept(((Long) o).longValue());
+        }
+
+        @Override
+        public Object get() {
+            return Long.valueOf(((LongSupplier) fn).getAsLong());
+        }
+    }
+
+    @Override
+    public LongStream filter(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new LongPipeline(boxed.filter(Fn.<Long>predicate(predicate)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public LongStream map(LongUnaryOperator mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>map(Fn.<Long, Long>function(Fn.MAP, mapper)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
+        Objects.requireNonNull(mapper);
+        return boxed.<U>map(Fn.<Long, U>function(Fn.TO_OBJ, mapper));
+    }
+
+    @Override
+    public IntStream mapToInt(LongToIntFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new IntPipeline(boxed.<Integer>map(Fn.<Long, Integer>function(Fn.TO_INT, mapper)));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
+        Objects.requireNonNull(mapper);
+        return new DoublePipeline(boxed.<Double>map(Fn.<Long, Double>function(Fn.TO_DOUBLE, mapper)));
+    }
+
+    @Override
+    public DoubleStream asDoubleStream() {
+        return new DoublePipeline(boxed.<Double>map(Fn.<Long, Double>function(Fn.WIDEN_DOUBLE, null)));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
+        Objects.requireNonNull(mapper);
+        return new LongPipeline(boxed.<Long>flatMap(Fn.<Long, Stream<Long>>function(Fn.FLAT, mapper)));
+    }
+
+    @Override
+    public LongStream distinct() {
+        return new LongPipeline(boxed.distinct());
+    }
+
+    @Override
+    public LongStream sorted() {
+        return new LongPipeline(boxed.sorted());
+    }
+
+    @Override
+    public LongStream peek(LongConsumer action) {
+        Objects.requireNonNull(action);
+        return new LongPipeline(boxed.peek(Fn.<Long>consumer(action)));
+    }
+
+    @Override
+    public LongStream limit(long maxSize) {
+        return new LongPipeline(boxed.limit(maxSize));
+    }
+
+    @Override
+    public LongStream skip(long n) {
+        return new LongPipeline(boxed.skip(n));
+    }
+
+    @Override
+    public LongStream takeWhile(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new LongPipeline(boxed.takeWhile(Fn.<Long>predicate(predicate)));
+    }
+
+    @Override
+    public LongStream dropWhile(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return new LongPipeline(boxed.dropWhile(Fn.<Long>predicate(predicate)));
+    }
+
+    @Override
+    public void forEach(LongConsumer action) {
+        Objects.requireNonNull(action);
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next().longValue());
+            }
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(LongConsumer action) {
+        forEach(action);
+    }
+
+    @Override
+    public long[] toArray() {
+        List<Long> all = new ArrayList<Long>();
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            long[] out = new long[all.size()];
+            for (int i = 0; i < out.length; i++) {
+                out[i] = all.get(i).longValue();
+            }
+            return out;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public long reduce(long identity, LongBinaryOperator op) {
+        Objects.requireNonNull(op);
+        long result = identity;
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                result = op.applyAsLong(result, it.next().longValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalLong reduce(LongBinaryOperator op) {
+        Objects.requireNonNull(op);
+        Iterator<Long> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalLong.empty();
+            }
+            long result = it.next().longValue();
+            while (it.hasNext()) {
+                result = op.applyAsLong(result, it.next().longValue());
+            }
+            return OptionalLong.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next().longValue());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public long sum() {
+        long total = 0;
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                total += it.next().longValue();
+            }
+            return total;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    /// The smallest (`max` false) or largest value, as `Math.min` and
+    /// `Math.max` choose, which is what the JDK's reduction uses.
+    private OptionalLong extreme(boolean max) {
+        Iterator<Long> it = boxed.iterator();
+        try {
+            if (!it.hasNext()) {
+                return OptionalLong.empty();
+            }
+            long result = it.next().longValue();
+            while (it.hasNext()) {
+                long v = it.next().longValue();
+                result = max ? Math.max(result, v) : Math.min(result, v);
+            }
+            return OptionalLong.of(result);
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public OptionalLong min() {
+        return extreme(false);
+    }
+
+    @Override
+    public OptionalLong max() {
+        return extreme(true);
+    }
+
+    @Override
+    public long count() {
+        return boxed.count();
+    }
+
+    @Override
+    public OptionalDouble average() {
+        LongSummaryStatistics all = summaryStatistics();
+        return all.getCount() == 0 ? OptionalDouble.empty() : OptionalDouble.of(all.getAverage());
+    }
+
+    @Override
+    public LongSummaryStatistics summaryStatistics() {
+        LongSummaryStatistics all = new LongSummaryStatistics();
+        Iterator<Long> it = boxed.iterator();
+        try {
+            while (it.hasNext()) {
+                all.accept(it.next().longValue());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw ObjPipeline.fail(boxed, e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.anyMatch(Fn.<Long>predicate(predicate));
+    }
+
+    @Override
+    public boolean allMatch(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.allMatch(Fn.<Long>predicate(predicate));
+    }
+
+    @Override
+    public boolean noneMatch(LongPredicate predicate) {
+        Objects.requireNonNull(predicate);
+        return boxed.noneMatch(Fn.<Long>predicate(predicate));
+    }
+
+    @Override
+    public OptionalLong findFirst() {
+        // Through the boxed stream's own, which says that the rest is not
+        // going to be read: a mapped stream left part read is closed.
+        Optional<Long> first = boxed.findFirst();
+        return first.isPresent() ? OptionalLong.of(first.get().longValue()) : OptionalLong.empty();
+    }
+
+    @Override
+    public OptionalLong findAny() {
+        return findFirst();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Stream<Long> boxed() {
+        // A stage of its own, so that this stream counts as used like any
+        // other that had an operation applied to it.
+        return boxed.map(Fn.<Long, Long>function(Fn.BOX, null));
+    }
+
+    @Override
+    public PrimitiveIterator.OfLong iterator() {
+        return new Unboxing(boxed.iterator());
+    }
+
+    /// The elements of the boxed pipeline, one primitive at a time.
+    private static final class Unboxing implements PrimitiveIterator.OfLong {
+        private final Iterator<Long> it;
+
+        Unboxing(Iterator<Long> it) {
+            this.it = it;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return it.hasNext();
+        }
+
+        @Override
+        public long nextLong() {
+            return it.next().longValue();
+        }
+    }
+
+    @Override
+    public boolean isParallel() {
+        return boxed.isParallel();
+    }
+
+    @Override
+    public LongStream sequential() {
+        boxed.sequential();
+        return this;
+    }
+
+    @Override
+    public LongStream parallel() {
+        boxed.parallel();
+        return this;
+    }
+
+    @Override
+    public LongStream unordered() {
+        return this;
+    }
+
+    @Override
+    public LongStream onClose(Runnable closeHandler) {
+        boxed.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        boxed.close();
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/LongStream.java b/vm/JavaAPI/src/java/util/stream/LongStream.java
new file mode 100644
index 00000000000..6cef52daf12
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/LongStream.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.LongSummaryStatistics;
+import java.util.OptionalDouble;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.function.BiConsumer;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongSupplier;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjLongConsumer;
+import java.util.function.Supplier;
+
+/// A sequence of `long` values to which operations are applied one stage at a
+/// time, evaluated lazily, one element at a time, when a terminal operation
+/// asks for them.
+///
+/// Streams here are sequential: `parallel()` answers the same stream, which
+/// the JDK allows a parallel stream to be.
+public interface LongStream extends BaseStream<Long, LongStream> {
+
+    /// Declared again with this type, as the JDK does: a call compiled
+    /// against the JDK names `LongStream.sequential()` answering `LongStream`,
+    /// and the method inherited from [BaseStream] answers its type
+    /// variable, which is another descriptor.
+    @Override
+    LongStream sequential();
+
+    /// Declared again with this type; see [#sequential()].
+    @Override
+    LongStream parallel();
+
+    LongStream filter(LongPredicate predicate);
+
+    LongStream map(LongUnaryOperator mapper);
+
+    <U> Stream<U> mapToObj(LongFunction<? extends U> mapper);
+
+    IntStream mapToInt(LongToIntFunction mapper);
+
+    DoubleStream mapToDouble(LongToDoubleFunction mapper);
+
+    LongStream flatMap(LongFunction<? extends LongStream> mapper);
+
+    LongStream distinct();
+
+    LongStream sorted();
+
+    LongStream peek(LongConsumer action);
+
+    LongStream limit(long maxSize);
+
+    LongStream skip(long n);
+
+    LongStream takeWhile(LongPredicate predicate);
+
+    LongStream dropWhile(LongPredicate predicate);
+
+    void forEach(LongConsumer action);
+
+    void forEachOrdered(LongConsumer action);
+
+    long[] toArray();
+
+    long reduce(long identity, LongBinaryOperator op);
+
+    OptionalLong reduce(LongBinaryOperator op);
+
+    <R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner);
+
+    long sum();
+
+    OptionalLong min();
+
+    OptionalLong max();
+
+    long count();
+
+    OptionalDouble average();
+
+    LongSummaryStatistics summaryStatistics();
+
+    boolean anyMatch(LongPredicate predicate);
+
+    boolean allMatch(LongPredicate predicate);
+
+    boolean noneMatch(LongPredicate predicate);
+
+    OptionalLong findFirst();
+
+    OptionalLong findAny();
+
+    DoubleStream asDoubleStream();
+
+    Stream<Long> boxed();
+
+    @Override
+    PrimitiveIterator.OfLong iterator();
+
+    static LongStream empty() {
+        return LongPipeline.ofArray(new long[0], 0, 0);
+    }
+
+    static LongStream of(long value) {
+        return LongPipeline.ofArray(new long[] {value}, 0, 1);
+    }
+
+    static LongStream of(long... values) {
+        return LongPipeline.ofArray(values, 0, values.length);
+    }
+
+    /// `seed`, then `f` applied to it, then `f` applied to that, without end.
+    static LongStream iterate(long seed, LongUnaryOperator f) {
+        return LongPipeline.iterate(seed, null, f);
+    }
+
+    /// As [#iterate(long, LongUnaryOperator)], ending before the first value
+    /// `hasNext` refuses.
+    static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator next) {
+        if (hasNext == null) {
+            throw new NullPointerException();
+        }
+        return LongPipeline.iterate(seed, hasNext, next);
+    }
+
+    /// The values `s` answers, one call per element, without end.
+    static LongStream generate(LongSupplier s) {
+        return LongPipeline.generate(s);
+    }
+
+    /// The values from `startInclusive` up to, not including, `endExclusive`,
+    /// in steps of one. Empty when `startInclusive` is not below `endExclusive`.
+    static LongStream range(long startInclusive, long endExclusive) {
+        return LongPipeline.ofRange(startInclusive, endExclusive, false);
+    }
+
+    /// The values from `startInclusive` up to and including `endInclusive`, in
+    /// steps of one. Empty when `startInclusive` is above `endInclusive`.
+    static LongStream rangeClosed(long startInclusive, long endInclusive) {
+        return LongPipeline.ofRange(startInclusive, endInclusive, true);
+    }
+
+    /// The elements of `a`, then those of `b`. Closing the result closes both.
+    static LongStream concat(LongStream a, LongStream b) {
+        return new LongPipeline(Stream.concat(a.boxed(), b.boxed()));
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/ObjPipeline.java b/vm/JavaAPI/src/java/util/stream/ObjPipeline.java
new file mode 100644
index 00000000000..0ccf2d1b428
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/ObjPipeline.java
@@ -0,0 +1,821 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.function.IntFunction;
+import java.util.Optional;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/// The one implementation of [Stream]: a stage holding the iterator that
+/// produces its elements. An intermediate operation wraps that iterator in
+/// another and answers a new stage; a terminal one drains it.
+///
+/// Nothing runs until a terminal operation pulls, and then one element at a
+/// time travels the whole chain before the next is asked for.
+final class ObjPipeline<T> implements Stream<T> {
+
+    private static final String USED = "stream has already been operated upon or closed";
+
+    private final Iterator<T> source;
+    private final StreamState state;
+    /// A stage takes one operation, like the JDK's.
+    private boolean used;
+
+    private ObjPipeline(Iterator<T> source, StreamState state) {
+        this.source = source;
+        this.state = state;
+    }
+
+    static <T> ObjPipeline<T> over(Iterator<T> source) {
+        return new ObjPipeline<T>(source, new StreamState());
+    }
+
+    /// A stream of what `source` holds when the terminal operation starts,
+    /// not when the stream was made: elements added in between are seen.
+    static <T> ObjPipeline<T> over(Iterable<? extends T> source) {
+        return over(new PullIterator<T>() {
+            private Iterator<? extends T> it;
+
+            @Override
+            boolean advance() {
+                if (it == null) {
+                    it = source.iterator();
+                }
+                if (!it.hasNext()) {
+                    return false;
+                }
+                emit(it.next());
+                return true;
+            }
+        });
+    }
+
+    /// The elements `from` (inclusive) to `to` (exclusive) of `values`.
+    static <T> ObjPipeline<T> ofArray(T[] values, int from, int to) {
+        if (from < 0 || to > values.length || from > to) {
+            throw new ArrayIndexOutOfBoundsException("origin(" + from + ") > fence(" + to + ")");
+        }
+        return over(new PullIterator<T>() {
+            private int at = from;
+
+            @Override
+            boolean advance() {
+                if (at >= to) {
+                    return false;
+                }
+                emit(values[at++]);
+                return true;
+            }
+        });
+    }
+
+    static <T> ObjPipeline<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
+        Iterator<? extends T> first = a.iterator();
+        Iterator<? extends T> second = b.iterator();
+        ObjPipeline<T> out = over(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                if (first.hasNext()) {
+                    emit(first.next());
+                    return true;
+                }
+                if (second.hasNext()) {
+                    emit(second.next());
+                    return true;
+                }
+                return false;
+            }
+        });
+        // Parallel when either input is, as the JDK's concatenation reports.
+        out.state.parallel = a.isParallel() || b.isParallel();
+        // Closing the concatenation closes both inputs, the second even
+        // when the first one's handler throws.
+        out.state.onClose(new Runnable() {
+            @Override
+            public void run() {
+                a.close();
+            }
+        });
+        out.state.onClose(new Runnable() {
+            @Override
+            public void run() {
+                b.close();
+            }
+        });
+        return out;
+    }
+
+    /// The iterator of this stage, which the caller now owns.
+    /// Rethrows `failure` from a terminal operation of a primitive stream
+    /// over `stream`, first closing what its pipeline still holds open -- the
+    /// inner stream of a `flatMap` -- as this class's own terminals do.
+    static RuntimeException fail(Stream<?> stream, Throwable failure) {
+        if (stream instanceof ObjPipeline) {
+            return ((ObjPipeline<?>) stream).state.fail(failure);
+        }
+        return StreamState.unchecked(failure);
+    }
+
+    private Iterator<T> take() {
+        // Closing any stage closes the pipeline, so a stage made before an
+        // earlier one was closed is refused as well as the closed one.
+        if (used || state.isClosed()) {
+            throw new IllegalStateException(USED);
+        }
+        used = true;
+        return source;
+    }
+
+    private <R> ObjPipeline<R> stage(Iterator<R> next) {
+        return new ObjPipeline<R>(next, state);
+    }
+
+    @Override
+    public Stream<T> filter(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                while (up.hasNext()) {
+                    T value = up.next();
+                    if (predicate.test(value)) {
+                        emit(value);
+                        return true;
+                    }
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
+        Objects.requireNonNull(mapper);
+        Iterator<T> up = take();
+        return stage(new PullIterator<R>() {
+            @Override
+            boolean advance() {
+                if (!up.hasNext()) {
+                    return false;
+                }
+                emit(mapper.apply(up.next()));
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        final ToIntFunction<? super T> f = mapper;
+        return new IntPipeline(this.<Integer>map(new Function<T, Integer>() {
+            @Override
+            public Integer apply(T v) {
+                return Integer.valueOf(f.applyAsInt(v));
+            }
+        }));
+    }
+
+    @Override
+    public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        final ToLongFunction<? super T> f = mapper;
+        return new LongPipeline(this.<Long>map(new Function<T, Long>() {
+            @Override
+            public Long apply(T v) {
+                return Long.valueOf(f.applyAsLong(v));
+            }
+        }));
+    }
+
+    @Override
+    public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+        Objects.requireNonNull(mapper);
+        final ToDoubleFunction<? super T> f = mapper;
+        return new DoublePipeline(this.<Double>map(new Function<T, Double>() {
+            @Override
+            public Double apply(T v) {
+                return Double.valueOf(f.applyAsDouble(v));
+            }
+        }));
+    }
+
+    @Override
+    public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
+        Objects.requireNonNull(mapper);
+        FlatMapped<T, R> flat = new FlatMapped<T, R>(take(), mapper);
+        // The mapped stream being read when the pipeline stops asking is
+        // closed too, as the JDK closes it: see StreamState#onAbandon.
+        state.onAbandon(flat);
+        return stage(flat);
+    }
+
+    /// The elements of each stream a mapper answers, one mapped stream at a
+    /// time. A mapped stream is read lazily, so the one in hand can be left
+    /// part read: by a `limit` or a `takeWhile` after this stage, or by a
+    /// terminal operation that has its answer. Running this closes it.
+    private static final class FlatMapped<T, R> extends PullIterator<R> implements Runnable {
+        private final Iterator<T> up;
+        private final Function<? super T, ? extends Stream<? extends R>> mapper;
+        private Stream<? extends R> inner;
+        private Iterator<? extends R> it;
+
+        FlatMapped(Iterator<T> up, Function<? super T, ? extends Stream<? extends R>> mapper) {
+            this.up = up;
+            this.mapper = mapper;
+        }
+
+        @Override
+        boolean advance() {
+            while (true) {
+                if (it != null) {
+                    if (it.hasNext()) {
+                        emit(it.next());
+                        return true;
+                    }
+                    // A mapped stream is closed once its elements have
+                    // been taken.
+                    run();
+                }
+                if (!up.hasNext()) {
+                    return false;
+                }
+                Stream<? extends R> mapped = mapper.apply(up.next());
+                if (mapped != null) {
+                    inner = mapped;
+                    it = mapped.iterator();
+                }
+            }
+        }
+
+        @Override
+        public void run() {
+            Stream<? extends R> open = inner;
+            inner = null;
+            it = null;
+            if (open != null) {
+                open.close();
+            }
+        }
+    }
+
+    @Override
+    public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+        Objects.requireNonNull(mapper);
+        final Function<? super T, ? extends IntStream> f = mapper;
+        return new IntPipeline(this.<Integer>flatMap(new Function<T, Stream<Integer>>() {
+            @Override
+            public Stream<Integer> apply(T v) {
+                IntStream mapped = f.apply(v);
+                return mapped == null ? null : mapped.boxed();
+            }
+        }));
+    }
+
+    @Override
+    public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+        Objects.requireNonNull(mapper);
+        final Function<? super T, ? extends LongStream> f = mapper;
+        return new LongPipeline(this.<Long>flatMap(new Function<T, Stream<Long>>() {
+            @Override
+            public Stream<Long> apply(T v) {
+                LongStream mapped = f.apply(v);
+                return mapped == null ? null : mapped.boxed();
+            }
+        }));
+    }
+
+    @Override
+    public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+        Objects.requireNonNull(mapper);
+        final Function<? super T, ? extends DoubleStream> f = mapper;
+        return new DoublePipeline(this.<Double>flatMap(new Function<T, Stream<Double>>() {
+            @Override
+            public Stream<Double> apply(T v) {
+                DoubleStream mapped = f.apply(v);
+                return mapped == null ? null : mapped.boxed();
+            }
+        }));
+    }
+
+    @Override
+    public Stream<T> distinct() {
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private final Set<T> seen = new HashSet<T>();
+
+            @Override
+            boolean advance() {
+                while (up.hasNext()) {
+                    T value = up.next();
+                    if (seen.add(value)) {
+                        emit(value);
+                        return true;
+                    }
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> sorted() {
+        // The natural order of whatever the elements are; an element that is not
+        // Comparable fails in the comparison, as on the JDK.
+        @SuppressWarnings({"unchecked", "rawtypes"})
+        Comparator<? super T> natural = (Comparator) Comparator.naturalOrder();
+        return sorted(natural);
+    }
+
+    @Override
+    public Stream<T> sorted(Comparator<? super T> comparator) {
+        // The JDK refuses a null comparator here; only sorted() means the
+        // natural order, and it passes that order itself.
+        if (comparator == null) {
+            throw new NullPointerException();
+        }
+        final Comparator<? super T> order = comparator;
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private Iterator<T> it;
+
+            @Override
+            boolean advance() {
+                if (it == null) {
+                    // Sorting needs every element, so the first pull takes
+                    // the whole of what is upstream.
+                    List<T> all = new ArrayList<T>();
+                    while (up.hasNext()) {
+                        all.add(up.next());
+                    }
+                    Collections.sort(all, order);
+                    it = all.iterator();
+                }
+                if (!it.hasNext()) {
+                    return false;
+                }
+                emit(it.next());
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> peek(Consumer<? super T> action) {
+        Objects.requireNonNull(action);
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                if (!up.hasNext()) {
+                    return false;
+                }
+                T value = up.next();
+                action.accept(value);
+                emit(value);
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> limit(long maxSize) {
+        if (maxSize < 0) {
+            throw new IllegalArgumentException(Long.toString(maxSize));
+        }
+        Iterator<T> up = take();
+        int before = state.abandonable();
+        return stage(new PullIterator<T>() {
+            private long left = maxSize;
+
+            @Override
+            boolean advance() {
+                // Checked before asking upstream: the element after the
+                // last one wanted is never produced.
+                if (left <= 0) {
+                    // Nothing before this stage is asked again.
+                    state.abandon(before);
+                    return false;
+                }
+                if (!up.hasNext()) {
+                    return false;
+                }
+                left--;
+                emit(up.next());
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> skip(long n) {
+        if (n < 0) {
+            throw new IllegalArgumentException(Long.toString(n));
+        }
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private long left = n;
+
+            @Override
+            boolean advance() {
+                while (left > 0) {
+                    if (!up.hasNext()) {
+                        return false;
+                    }
+                    up.next();
+                    left--;
+                }
+                if (!up.hasNext()) {
+                    return false;
+                }
+                emit(up.next());
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> takeWhile(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> up = take();
+        int before = state.abandonable();
+        return stage(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                if (!up.hasNext()) {
+                    return false;
+                }
+                T value = up.next();
+                if (!predicate.test(value)) {
+                    state.abandon(before);
+                    return false;
+                }
+                emit(value);
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public Stream<T> dropWhile(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> up = take();
+        return stage(new PullIterator<T>() {
+            private boolean dropping = true;
+
+            @Override
+            boolean advance() {
+                while (up.hasNext()) {
+                    T value = up.next();
+                    if (dropping && predicate.test(value)) {
+                        continue;
+                    }
+                    dropping = false;
+                    emit(value);
+                    return true;
+                }
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+        Objects.requireNonNull(action);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                action.accept(it.next());
+            }
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public void forEachOrdered(Consumer<? super T> action) {
+        forEach(action);
+    }
+
+    private List<T> drain() {
+        List<T> all = new ArrayList<T>();
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                all.add(it.next());
+            }
+            return all;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Object[] toArray() {
+        return drain().toArray();
+    }
+
+    @Override
+    public <A> A[] toArray(IntFunction<A[]> generator) {
+        Objects.requireNonNull(generator);
+        List<T> all = drain();
+        A[] out = generator.apply(all.size());
+        if (out.length != all.size()) {
+            throw new IllegalStateException("The generator answered an array of " + out.length + " for "
+                    + all.size() + " elements");
+        }
+        // Copied through an Object[] view: storing an element of the wrong
+        // type fails as an ArrayStoreException, like the JDK's.
+        Object[] target = out;
+        for (int i = 0; i < target.length; i++) {
+            target[i] = all.get(i);
+        }
+        return out;
+    }
+
+    @Override
+    public T reduce(T identity, BinaryOperator<T> accumulator) {
+        Objects.requireNonNull(accumulator);
+        T result = identity;
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                result = accumulator.apply(result, it.next());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> reduce(BinaryOperator<T> accumulator) {
+        Objects.requireNonNull(accumulator);
+        Iterator<T> it = take();
+        try {
+            if (!it.hasNext()) {
+                return Optional.empty();
+            }
+            T result = it.next();
+            while (it.hasNext()) {
+                result = accumulator.apply(result, it.next());
+            }
+            return Optional.of(result);
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        U result = identity;
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                result = accumulator.apply(result, it.next());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
+        Objects.requireNonNull(supplier);
+        Objects.requireNonNull(accumulator);
+        Objects.requireNonNull(combiner);
+        R result = supplier.get();
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(result, it.next());
+            }
+            return result;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public <R, A> R collect(Collector<? super T, A, R> collector) {
+        Objects.requireNonNull(collector);
+        A container = collector.supplier().get();
+        BiConsumer<A, ? super T> accumulator = collector.accumulator();
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                accumulator.accept(container, it.next());
+            }
+            return collector.finisher().apply(container);
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> min(Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return reduce(BinaryOperator.<T>minBy(comparator));
+    }
+
+    @Override
+    public Optional<T> max(Comparator<? super T> comparator) {
+        Objects.requireNonNull(comparator);
+        return reduce(BinaryOperator.<T>maxBy(comparator));
+    }
+
+    @Override
+    public long count() {
+        long n = 0;
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                it.next();
+                n++;
+            }
+            return n;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public boolean anyMatch(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                if (predicate.test(it.next())) {
+                    state.abandon(state.abandonable());
+                    return true;
+                }
+            }
+            return false;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public boolean allMatch(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                if (!predicate.test(it.next())) {
+                    state.abandon(state.abandonable());
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public boolean noneMatch(Predicate<? super T> predicate) {
+        Objects.requireNonNull(predicate);
+        Iterator<T> it = take();
+        try {
+            while (it.hasNext()) {
+                if (predicate.test(it.next())) {
+                    state.abandon(state.abandonable());
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> findFirst() {
+        Iterator<T> it = take();
+        try {
+            if (!it.hasNext()) {
+                return Optional.empty();
+            }
+            Optional<T> first = Optional.of(it.next());
+            // The answer is in hand with the rest unread.
+            state.abandon(state.abandonable());
+            return first;
+        } catch (Throwable e) {
+            throw state.fail(e);
+        }
+    }
+
+    @Override
+    public Optional<T> findAny() {
+        return findFirst();
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return take();
+    }
+
+    @Override
+    public boolean isParallel() {
+        return state.parallel;
+    }
+
+    @Override
+    public Stream<T> sequential() {
+        state.parallel = false;
+        return this;
+    }
+
+    @Override
+    public Stream<T> parallel() {
+        state.parallel = true;
+        return this;
+    }
+
+    @Override
+    public Stream<T> unordered() {
+        return this;
+    }
+
+    @Override
+    public Stream<T> onClose(Runnable closeHandler) {
+        if (used || state.isClosed()) {
+            throw new IllegalStateException(USED);
+        }
+        state.onClose(closeHandler);
+        return this;
+    }
+
+    @Override
+    public void close() {
+        used = true;
+        state.close();
+    }
+
+    /// What [Stream#builder] answers.
+    static final class ListBuilder<T> implements Stream.Builder<T> {
+
+        private List<T> elements = new ArrayList<T>();
+
+        @Override
+        public void accept(T t) {
+            if (elements == null) {
+                throw new IllegalStateException();
+            }
+            elements.add(t);
+        }
+
+        @Override
+        public Stream<T> build() {
+            if (elements == null) {
+                throw new IllegalStateException();
+            }
+            List<T> built = elements;
+            elements = null;
+            return over(built);
+        }
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/PullIterator.java b/vm/JavaAPI/src/java/util/stream/PullIterator.java
new file mode 100644
index 00000000000..2a8eed18320
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/PullIterator.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/// The iterator every stream stage is: it produces its next element only
+/// when asked whether there is one, which is what makes a pipeline lazy --
+/// `limit` stops asking the stage before it, and nothing further upstream
+/// runs.
+abstract class PullIterator<T> implements Iterator<T> {
+
+    private boolean ready;
+    private boolean done;
+    private T value;
+
+    /// Produces the next element by calling [#emit], or answers false when
+    /// there is none. Not called again once it answered false.
+    abstract boolean advance();
+
+    final void emit(T next) {
+        value = next;
+    }
+
+    @Override
+    public final boolean hasNext() {
+        if (!ready && !done) {
+            if (advance()) {
+                ready = true;
+            } else {
+                done = true;
+            }
+        }
+        return ready;
+    }
+
+    @Override
+    public final T next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        ready = false;
+        T out = value;
+        value = null;
+        return out;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/Stream.java b/vm/JavaAPI/src/java/util/stream/Stream.java
index d372550e513..f6815ce98e9 100644
--- a/vm/JavaAPI/src/java/util/stream/Stream.java
+++ b/vm/JavaAPI/src/java/util/stream/Stream.java
@@ -22,38 +22,97 @@
  */
 package java.util.stream;
 
+import java.util.function.IntFunction;
+import java.util.Optional;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
-import java.util.Optional;
 import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
-
+import java.util.function.UnaryOperator;
+
+/// A stream here is sequential and lazy: each stage pulls one element at a
+/// time from the one before it, and only when a terminal operation asks. So
+/// an infinite `iterate` or `generate` behind a `limit` ends, `findFirst`
+/// and the `anyMatch` family stop at the element that decides them, and the
+/// side effects of `peek` happen element by element, in encounter order.
+///
+/// What is not here: spliterators, and with them parallel evaluation.
+/// `parallel()` answers the stream it was called on.
 public interface Stream<T> extends BaseStream<T, Stream<T>> {
+
     Stream<T> filter(Predicate<? super T> predicate);
 
     <R> Stream<R> map(Function<? super T, ? extends R> mapper);
 
-    Stream<T> sorted();
+    IntStream mapToInt(ToIntFunction<? super T> mapper);
+
+    LongStream mapToLong(ToLongFunction<? super T> mapper);
+
+    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
+
+    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
+
+    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
+
+    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
+
+    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
 
     Stream<T> distinct();
 
+    Stream<T> sorted();
+
+    Stream<T> sorted(Comparator<? super T> comparator);
+
+    Stream<T> peek(Consumer<? super T> action);
+
     Stream<T> limit(long maxSize);
 
     Stream<T> skip(long n);
 
+    Stream<T> takeWhile(Predicate<? super T> predicate);
+
+    Stream<T> dropWhile(Predicate<? super T> predicate);
+
     void forEach(Consumer<? super T> action);
 
+    void forEachOrdered(Consumer<? super T> action);
+
     Object[] toArray();
 
+    <A> A[] toArray(IntFunction<A[]> generator);
+
     T reduce(T identity, BinaryOperator<T> accumulator);
 
-    <A, R> R collect(Collector<? super T, A, R> collector);
+    Optional<T> reduce(BinaryOperator<T> accumulator);
+
+    <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
+
+    <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
+
+    <R, A> R collect(Collector<? super T, A, R> collector);
+
+    /// An unmodifiable list of the elements, which may be null.
+    @SuppressWarnings("unchecked")
+    default List<T> toList() {
+        return (List<T>) Collections.unmodifiableList(new ArrayList<Object>(Arrays.asList(toArray())));
+    }
+
+    Optional<T> min(Comparator<? super T> comparator);
+
+    Optional<T> max(Comparator<? super T> comparator);
 
     long count();
 
@@ -63,47 +122,103 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
 
     boolean noneMatch(Predicate<? super T> predicate);
 
-    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
-
-    Stream<T> peek(Consumer<? super T> action);
-
-    Stream<T> sorted(Comparator<? super T> comparator);
-
     Optional<T> findFirst();
 
     Optional<T> findAny();
 
-    Optional<T> min(Comparator<? super T> comparator);
+    static <T> Builder<T> builder() {
+        return new ObjPipeline.ListBuilder<T>();
+    }
 
-    Optional<T> max(Comparator<? super T> comparator);
+    static <T> Stream<T> empty() {
+        return ObjPipeline.over(Collections.<T>emptyList());
+    }
 
-    Optional<T> reduce(BinaryOperator<T> accumulator);
+    static <T> Stream<T> of(T t) {
+        return ObjPipeline.over(Collections.singletonList(t));
+    }
 
-    <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
+    static <T> Stream<T> ofNullable(T t) {
+        return t == null ? Stream.<T>empty() : Stream.of(t);
+    }
 
-    /**
-     * The elements as an unmodifiable list.
-     *
-     * @return the list
-     */
-    List<T> toList();
+    @SafeVarargs
+    @SuppressWarnings("varargs")
+    static <T> Stream<T> of(T... values) {
+        return ObjPipeline.ofArray(values, 0, values.length);
+    }
 
-    static <T> Stream<T> empty() {
-        return new StreamImpl<T>(new ArrayList<T>());
+    static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) {
+        if (f == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.over(new PullIterator<T>() {
+            private boolean started;
+            private T current;
+
+            @Override
+            boolean advance() {
+                current = started ? f.apply(current) : seed;
+                started = true;
+                emit(current);
+                return true;
+            }
+        });
     }
 
-    /**
-     * The single-element overload the JDK has: code compiled against the JDK binds a
-     * one-argument Stream.of to it, so without it that call fails to link here.
-     */
-    static <T> Stream<T> of(T value) {
-        List<T> one = new ArrayList<T>();
-        one.add(value);
-        return new StreamImpl<T>(one);
+    static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+        if (hasNext == null || next == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.over(new PullIterator<T>() {
+            private boolean started;
+            private T current;
+
+            @Override
+            boolean advance() {
+                current = started ? next.apply(current) : seed;
+                started = true;
+                if (!hasNext.test(current)) {
+                    return false;
+                }
+                emit(current);
+                return true;
+            }
+        });
     }
 
-    static <T> Stream<T> of(T... values) {
-        if (values == null) throw new NullPointerException();
-        return new StreamImpl<T>(java.util.Arrays.asList(values));
+    static <T> Stream<T> generate(Supplier<? extends T> s) {
+        if (s == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.over(new PullIterator<T>() {
+            @Override
+            boolean advance() {
+                emit(s.get());
+                return true;
+            }
+        });
+    }
+
+    static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
+        if (a == null || b == null) {
+            throw new NullPointerException();
+        }
+        return ObjPipeline.concat(a, b);
+    }
+
+    /// `java.util.stream.Stream.Builder`: collects elements, then answers
+    /// them as a stream, once.
+    interface Builder<T> extends Consumer<T> {
+
+        @Override
+        void accept(T t);
+
+        default Builder<T> add(T t) {
+            accept(t);
+            return this;
+        }
+
+        Stream<T> build();
     }
 }
diff --git a/vm/JavaAPI/src/java/util/stream/StreamImpl.java b/vm/JavaAPI/src/java/util/stream/StreamImpl.java
deleted file mode 100644
index faf8605474e..00000000000
--- a/vm/JavaAPI/src/java/util/stream/StreamImpl.java
+++ /dev/null
@@ -1,567 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package java.util.stream;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-
-/** Lazy fallback for pipelines whose source or callbacks cannot be specialized. */
-final class StreamImpl<T> implements Stream<T> {
-    private static final int SOURCE = 0, FILTER = 1, MAP = 2, SORTED = 3,
-            DISTINCT = 4, LIMIT = 5, SKIP = 6, FLATMAP = 7, PEEK = 8;
-
-    private static final class Source {
-        final List<?> values;
-        boolean closed;
-        /** onClose handlers, shared by every stage of the pipeline, run once by the first close(). */
-        List<Runnable> closeHandlers;
-        /**
-         * The pipeline's flatMap cursors. A cursor holds the mapped stream it is reading until
-         * that stream runs out, so one left mid-way by an iterator the caller stopped using
-         * would never close it; close() releases them all.
-         */
-        List<Cursor> flatMapCursors;
-        Source(List<?> values) { this.values = values; }
-    }
-
-    private final Source source;
-    private final StreamImpl<?> upstream;
-    private final int operation;
-    private final Object callback;
-    private final long amount;
-    private boolean linkedOrConsumed;
-
-    StreamImpl(List<T> values) {
-        source = new Source(values);
-        upstream = null;
-        operation = SOURCE;
-        callback = null;
-        amount = 0;
-    }
-
-    private StreamImpl(StreamImpl<?> upstream, int operation, Object callback, long amount) {
-        upstream.claim();
-        this.source = upstream.source;
-        this.upstream = upstream;
-        this.operation = operation;
-        this.callback = callback;
-        this.amount = amount;
-    }
-
-    private void claim() {
-        if (linkedOrConsumed || source.closed) throw new IllegalStateException();
-        linkedOrConsumed = true;
-    }
-
-    private static void require(Object value) {
-        if (value == null) throw new NullPointerException();
-    }
-
-    public Stream<T> filter(Predicate<? super T> predicate) {
-        require(predicate);
-        return new StreamImpl<T>(this, FILTER, predicate, 0);
-    }
-
-    public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
-        require(mapper);
-        return new StreamImpl<R>(this, MAP, mapper, 0);
-    }
-
-    public Stream<T> sorted() { return new StreamImpl<T>(this, SORTED, null, 0); }
-
-    public Stream<T> sorted(Comparator<? super T> comparator) {
-        // A null comparator is an error, not natural order: SORTED with a null callback means sorted().
-        require(comparator);
-        return new StreamImpl<T>(this, SORTED, comparator, 0);
-    }
-
-    public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
-        require(mapper);
-        return new StreamImpl<R>(this, FLATMAP, mapper, 0);
-    }
-
-    public Stream<T> peek(Consumer<? super T> action) {
-        require(action);
-        return new StreamImpl<T>(this, PEEK, action, 0);
-    }
-    public Stream<T> distinct() { return new StreamImpl<T>(this, DISTINCT, null, 0); }
-
-    public Stream<T> limit(long maxSize) {
-        if (maxSize < 0) throw new IllegalArgumentException();
-        return new StreamImpl<T>(this, LIMIT, null, maxSize);
-    }
-
-    public Stream<T> skip(long n) {
-        if (n < 0) throw new IllegalArgumentException();
-        return new StreamImpl<T>(this, SKIP, null, n);
-    }
-
-    /** One buffered element, never an eagerly materialized intermediate collection. */
-    private static final class Cursor implements Iterator<Object> {
-        private Iterator<?> input;
-        private final int operation;
-        private final Object callback;
-        private long remaining;
-        private Set<Object> seen;
-        private boolean sorted;
-        private boolean ready;
-        private boolean exhausted;
-        private Object next;
-        private Iterator<?> inner;
-        /** The stream flatMap's mapper returned, closed once its elements are used (as the JDK does). */
-        private Stream<?> innerStream;
-
-        Cursor(Iterator<?> input, int operation, Object callback, long amount) {
-            this.input = input;
-            this.operation = operation;
-            this.callback = callback;
-            remaining = amount;
-        }
-
-        @SuppressWarnings("unchecked")
-        public boolean hasNext() {
-            if (ready) return true;
-            if (exhausted) return false;
-            if (operation == LIMIT && remaining == 0) {
-                exhausted = true;
-                return false;
-            }
-            if (operation == SORTED && !sorted) {
-                List<Object> values = new ArrayList<Object>();
-                while (input.hasNext()) values.add(input.next());
-                if (callback == null) {
-                    Collections.sort((List) values);
-                } else {
-                    Collections.sort(values, (Comparator<Object>) callback);
-                }
-                input = values.iterator();
-                sorted = true;
-            }
-            if (operation == SKIP) {
-                while (remaining > 0 && input.hasNext()) {
-                    input.next();
-                    remaining--;
-                }
-            }
-            if (operation == FLATMAP) {
-                while (true) {
-                    if (inner != null && inner.hasNext()) {
-                        next = inner.next();
-                        ready = true;
-                        return true;
-                    }
-                    closeInner();
-                    if (!input.hasNext()) {
-                        exhausted = true;
-                        return false;
-                    }
-                    Stream<?> s = (Stream<?>) ((Function<Object, Object>) callback).apply(input.next());
-                    innerStream = s;
-                    inner = s == null ? null : s.iterator();
-                }
-            }
-            while (input.hasNext()) {
-                Object value = input.next();
-                if (operation == PEEK) ((Consumer<Object>) callback).accept(value);
-                if (operation == FILTER && !((Predicate<Object>) callback).test(value)) continue;
-                if (operation == DISTINCT) {
-                    if (seen == null) seen = new HashSet<Object>();
-                    if (!seen.add(value)) continue;
-                }
-                if (operation == MAP) value = ((Function<Object, Object>) callback).apply(value);
-                if (operation == LIMIT) remaining--;
-                next = value;
-                ready = true;
-                return true;
-            }
-            exhausted = true;
-            return false;
-        }
-
-        public Object next() {
-            if (!hasNext()) throw new NoSuchElementException();
-            Object result = next;
-            next = null;
-            ready = false;
-            return result;
-        }
-
-        public void remove() { throw new UnsupportedOperationException(); }
-
-        private void closeInner() {
-            if (innerStream != null) {
-                Stream<?> s = innerStream;
-                innerStream = null;
-                inner = null;
-                s.close();
-            }
-        }
-
-        /**
-         * A terminal operation ended -- early, or by an exception from a callback: close the
-         * mapped streams still open upstream. Every terminal operation calls it in a finally.
-         */
-        void release(Throwable primary) {
-            // Every open mapped stream up the pipeline is closed even when one close throws.
-            // A close failure never replaces the exception that ended the traversal: it is
-            // added to it as suppressed, as the JDK's try-with-resources does; with no such
-            // exception the first close failure is thrown, the rest suppressed into it.
-            Throwable first = null;
-            Cursor c = this;
-            while (c != null) {
-                try {
-                    c.closeInner();
-                } catch (Throwable t) {
-                    if (first == null) {
-                        first = t;
-                    } else if (first != t) {
-                        first.addSuppressed(t);
-                    }
-                }
-                c = c.input instanceof Cursor ? (Cursor) c.input : null;
-            }
-            if (first == null) {
-                return;
-            }
-            if (primary == null) {
-                StreamImpl.<RuntimeException>rethrow(first);
-            } else if (primary != first) {
-                primary.addSuppressed(first);
-            }
-        }
-    }
-
-    private static void release(Iterator<?> values, Throwable failure) {
-        if (values instanceof Cursor) {
-            ((Cursor) values).release(failure);
-        }
-    }
-
-    private Iterator<?> open() {
-        if (operation == SOURCE) return new Cursor(source.values.iterator(), SOURCE, null, 0);
-        Cursor cursor = new Cursor(upstream.open(), operation, callback, amount);
-        if (operation == FLATMAP) {
-            if (source.flatMapCursors == null) source.flatMapCursors = new ArrayList<Cursor>();
-            source.flatMapCursors.add(cursor);
-        }
-        return cursor;
-    }
-
-    @SuppressWarnings("unchecked")
-    public Iterator<T> iterator() {
-        claim();
-        return (Iterator<T>) open();
-    }
-
-    public void forEach(Consumer<? super T> action) {
-        require(action);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            while (values.hasNext()) action.accept(values.next());
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public Object[] toArray() {
-        List<T> result = new ArrayList<T>();
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            while (values.hasNext()) result.add(values.next());
-            return result.toArray();
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public T reduce(T identity, BinaryOperator<T> accumulator) {
-        require(accumulator);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            T result = identity;
-            while (values.hasNext()) result = accumulator.apply(result, values.next());
-            return result;
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public <A, R> R collect(Collector<? super T, A, R> collector) {
-        require(collector);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            A container = collector.supplier().get();
-            BiConsumer<A, ? super T> accumulator = collector.accumulator();
-            while (values.hasNext()) accumulator.accept(container, values.next());
-            return collector.finisher().apply(container);
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public long count() {
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            long count = 0;
-            while (values.hasNext()) { values.next(); count++; }
-            return count;
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public boolean anyMatch(Predicate<? super T> predicate) {
-        require(predicate);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            boolean found = false;
-            while (!found && values.hasNext()) found = predicate.test(values.next());
-            return found;
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public boolean allMatch(Predicate<? super T> predicate) {
-        require(predicate);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            boolean all = true;
-            while (all && values.hasNext()) all = predicate.test(values.next());
-            return all;
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public boolean noneMatch(Predicate<? super T> predicate) { return !anyMatch(predicate); }
-
-    public Optional<T> findFirst() {
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            Optional<T> first = values.hasNext() ? Optional.of(values.next()) : Optional.<T>empty();
-            return first;
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public Optional<T> findAny() { return findFirst(); }
-
-    public Optional<T> min(Comparator<? super T> comparator) {
-        require(comparator);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            if (!values.hasNext()) return Optional.<T>empty();
-            T best = values.next();
-            while (values.hasNext()) {
-                T v = values.next();
-                if (comparator.compare(v, best) < 0) best = v;
-            }
-            return Optional.of(best);
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public Optional<T> max(Comparator<? super T> comparator) {
-        require(comparator);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            if (!values.hasNext()) return Optional.<T>empty();
-            T best = values.next();
-            while (values.hasNext()) {
-                T v = values.next();
-                if (comparator.compare(v, best) > 0) best = v;
-            }
-            return Optional.of(best);
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public Optional<T> reduce(BinaryOperator<T> accumulator) {
-        require(accumulator);
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            if (!values.hasNext()) return Optional.<T>empty();
-            T result = values.next();
-            while (values.hasNext()) result = accumulator.apply(result, values.next());
-            return Optional.of(result);
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
-        require(supplier);
-        require(accumulator);
-        // Never called on a sequential stream, but required all the same, as on the JDK.
-        require(combiner);
-        R container = supplier.get();
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            while (values.hasNext()) accumulator.accept(container, values.next());
-            return container;
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-
-    public List<T> toList() {
-        List<T> result = new ArrayList<T>();
-        Iterator<T> values = iterator();
-        Throwable failure = null;
-        try {
-            while (values.hasNext()) result.add(values.next());
-            return Collections.unmodifiableList(result);
-        } catch (Throwable t) {
-            failure = t;
-            throw t;
-        } finally {
-            release(values, failure);
-        }
-    }
-    public Stream<T> sequential() { return this; }
-    public Stream<T> parallel() { return this; }
-    public Stream<T> onClose(Runnable closeHandler) {
-        require(closeHandler);
-        if (linkedOrConsumed || source.closed) throw new IllegalStateException();
-        if (source.closeHandlers == null) source.closeHandlers = new ArrayList<Runnable>();
-        source.closeHandlers.add(closeHandler);
-        return this;
-    }
-
-    /** Runs every handler even when one throws; the first failure is rethrown with the rest suppressed. */
-    public void close() {
-        linkedOrConsumed = true;
-        if (source.closed) return;
-        source.closed = true;
-        Throwable failure = null;
-        // Mapped streams a stopped iterator still holds come first (the JDK has closed them
-        // by now: it reads each one to the end as soon as it opens it), then the handlers.
-        List<Cursor> cursors = source.flatMapCursors;
-        source.flatMapCursors = null;
-        if (cursors != null) {
-            for (int i = 0; i < cursors.size(); i++) {
-                Cursor cursor = cursors.get(i);
-                try {
-                    cursor.release(null);
-                } catch (Throwable t) {
-                    if (failure == null) {
-                        failure = t;
-                    } else if (failure != t) {
-                        failure.addSuppressed(t);
-                    }
-                }
-            }
-        }
-        List<Runnable> handlers = source.closeHandlers;
-        source.closeHandlers = null;
-        for (int i = 0; handlers != null && i < handlers.size(); i++) {
-            // Fetched outside the try: the generic get() is a checkcast, which ParparVM does not
-            // check, so it must never sit under a handler that would catch its failure.
-            Runnable handler = handlers.get(i);
-            try {
-                handler.run();
-            } catch (Throwable t) {
-                if (failure == null) {
-                    failure = t;
-                } else if (failure != t) {
-                    failure.addSuppressed(t);
-                }
-            }
-        }
-        if (failure != null) {
-            // A handler can throw a checked exception (a generic "sneaky throw"); it is rethrown
-            // as it is, never dropped, as the JDK's close() does.
-            StreamImpl.<RuntimeException>rethrow(failure);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static <E extends Throwable> void rethrow(Throwable t) throws E {
-        throw (E) t;
-    }
-}
diff --git a/vm/JavaAPI/src/java/util/stream/StreamState.java b/vm/JavaAPI/src/java/util/stream/StreamState.java
new file mode 100644
index 00000000000..1be432ad226
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/StreamState.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/// What the stages of one pipeline share: the handlers `onClose` registered,
+/// which `close()` on any stage runs, once.
+final class StreamState {
+
+    private List<Runnable> handlers;
+
+    /// What `parallel()` and `sequential()` last asked for, which
+    /// `isParallel()` reports. The pipeline runs sequentially either way,
+    /// which the JDK allows a parallel stream to do.
+    boolean parallel;
+    private boolean closed;
+
+    /// What closes a resource a stage holds while it is part read: the
+    /// mapped stream a `flatMap` is in the middle of. Kept in the order the
+    /// stages were added, which is the order the elements travel.
+    ///
+    /// The JDK closes a mapped stream whether or not all of it was wanted
+    /// (`flatMap(...).findFirst()` closes the one it took its answer from).
+    /// A pulled pipeline has to be told that nobody will ask again, and
+    /// three things know: a `limit` that has handed out its last element
+    /// and a `takeWhile` that met its first refusal, about the stages
+    /// before them, and a short-circuiting terminal operation or `close`,
+    /// about every stage.
+    ///
+    /// A terminal operation that ends by throwing releases them all too
+    /// ([#fail(Throwable)]). Not covered, and left to `close` as for any
+    /// stream holding a resource: an `iterator()` its caller stops reading.
+    private List<Runnable> abandoned;
+
+    void onAbandon(Runnable release) {
+        if (abandoned == null) {
+            abandoned = new ArrayList<Runnable>();
+        }
+        abandoned.add(release);
+    }
+
+    /// How many stages so far hold something to release: what a stage keeps
+    /// to say later that everything before it is no longer read.
+    int abandonable() {
+        return abandoned == null ? 0 : abandoned.size();
+    }
+
+    /// Releases what the first `count` such stages hold, the latest stage
+    /// first as the JDK's nested `flatMap`s close, even when one throws; the
+    /// first exception is thrown once all have run.
+    void abandon(int count) {
+        List<Runnable> held = abandoned;
+        if (held == null) {
+            return;
+        }
+        RuntimeException first = null;
+        for (int i = Math.min(count, held.size()) - 1; i >= 0; i--) {
+            Runnable release = held.get(i);
+            try {
+                release.run();
+            } catch (RuntimeException e) {
+                if (first == null) {
+                    first = e;
+                }
+            }
+        }
+        if (first != null) {
+            throw first;
+        }
+    }
+
+    void onClose(Runnable handler) {
+        if (handler == null) {
+            throw new NullPointerException();
+        }
+        if (handlers == null) {
+            handlers = new ArrayList<Runnable>();
+        }
+        handlers.add(handler);
+    }
+
+    /// Whether some stage of the pipeline was closed. The stages share this
+    /// state, so each of them can tell.
+    boolean isClosed() {
+        return closed;
+    }
+
+    /// Runs every handler, in the order they were added, even when one
+    /// throws, an Error included; the first failure is thrown once all have
+    /// run, with each later one added to it as suppressed, as the JDK's
+    /// stream does.
+    void close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        Throwable first = null;
+        try {
+            abandon(abandonable());
+        } catch (Throwable e) {
+            first = e;
+        }
+        if (handlers != null) {
+            for (int i = 0; i < handlers.size(); i++) {
+                // Read outside the try: the cast a generic get compiles to must
+                // not sit under a handler that would swallow its failure.
+                Runnable handler = handlers.get(i);
+                try {
+                    handler.run();
+                } catch (Throwable e) {
+                    first = suppress(first, e);
+                }
+            }
+        }
+        if (first != null) {
+            // Thrown as it is, a sneakily thrown checked exception included,
+            // which the JDK does not wrap either.
+            StreamState.<RuntimeException>rethrow(first);
+        }
+    }
+
+    /// What a terminal operation that ended by throwing `failure` calls:
+    /// every mapped stream still open is closed, the latest first, and what
+    /// closing one throws rides along as suppressed, as the JDK's
+    /// try-with-resources around each mapped stream does. Always throws
+    /// `failure`; declared to answer an exception so a caller can write
+    /// `throw state.fail(e)`.
+    RuntimeException fail(Throwable failure) {
+        List<Runnable> held = abandoned;
+        if (held != null) {
+            for (int i = held.size() - 1; i >= 0; i--) {
+                Runnable release = held.get(i);
+                try {
+                    release.run();
+                } catch (Throwable e) {
+                    suppress(failure, e);
+                }
+            }
+        }
+        StreamState.<RuntimeException>rethrow(failure);
+        return null;
+    }
+
+    /// Throws `t` unchanged, checked or not: the erased cast is to
+    /// `Throwable`, so nothing is checked at run time.
+    @SuppressWarnings("unchecked")
+    /// Throws `failure` as it is, checked or not.
+    static RuntimeException unchecked(Throwable failure) {
+        StreamState.<RuntimeException>rethrow(failure);
+        return null;
+    }
+
+    private static <E extends Throwable> void rethrow(Throwable t) throws E {
+        throw (E) t;
+    }
+
+    private static Throwable suppress(Throwable first, Throwable next) {
+        if (first == null) {
+            return next;
+        }
+        if (first != next) {
+            first.addSuppressed(next);
+        }
+        return first;
+    }
+}
diff --git a/vm/JavaAPI/src/java/util/stream/StreamSupport.java b/vm/JavaAPI/src/java/util/stream/StreamSupport.java
new file mode 100644
index 00000000000..3f1cfbd854d
--- /dev/null
+++ b/vm/JavaAPI/src/java/util/stream/StreamSupport.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package java.util.stream;
+
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/// Makes a [Stream] of a [Spliterator]: what `Collection.stream()` does, and
+/// how a library turns any `Iterable` into a stream
+/// (`StreamSupport.stream(iterable.spliterator(), false)`).
+///
+/// Streams here run sequentially; `parallel` is what `isParallel()`
+/// reports and changes nothing else, which the JDK allows.
+public final class StreamSupport {
+
+    private StreamSupport() {
+    }
+
+    /// The elements of `spliterator`, read when a terminal operation asks
+    /// for them.
+    public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
+        if (spliterator == null) {
+            throw new NullPointerException();
+        }
+        Stream<T> out = ObjPipeline.over(new Source<T>(spliterator, null));
+        return parallel ? out.parallel() : out;
+    }
+
+    /// The elements of the spliterator `supplier` answers when a terminal
+    /// operation first asks for one.
+    public static <T> Stream<T> stream(Supplier<? extends Spliterator<T>> supplier, int characteristics,
+                                       boolean parallel) {
+        if (supplier == null) {
+            throw new NullPointerException();
+        }
+        Stream<T> out = ObjPipeline.over(new Source<T>(null, supplier));
+        return parallel ? out.parallel() : out;
+    }
+
+    /// The first stage of such a stream: one `tryAdvance` per element.
+    private static final class Source<T> extends PullIterator<T> implements Consumer<T> {
+        private Spliterator<T> spliterator;
+        private final Supplier<? extends Spliterator<T>> supplier;
+
+        Source(Spliterator<T> spliterator, Supplier<? extends Spliterator<T>> supplier) {
+            this.spliterator = spliterator;
+            this.supplier = supplier;
+        }
+
+        @Override
+        public void accept(T t) {
+            emit(t);
+        }
+
+        @Override
+        boolean advance() {
+            if (spliterator == null) {
+                spliterator = supplier.get();
+            }
+            return spliterator.tryAdvance(this);
+        }
+    }
+}
diff --git a/vm/backend/demo/process/com/demo/ProcessConformance.java b/vm/backend/demo/process/com/demo/ProcessConformance.java
index 12f64b61725..6297396b1b0 100644
--- a/vm/backend/demo/process/com/demo/ProcessConformance.java
+++ b/vm/backend/demo/process/com/demo/ProcessConformance.java
@@ -25,6 +25,7 @@
 import com.codename1.io.Process;
 import com.codename1.io.ProcessBuilder;
 import java.io.ByteArrayOutputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.concurrent.TimeUnit;
@@ -74,12 +75,12 @@ public static void main(String[] args) throws Exception {
         check("<absent>".equals(output(env)), "environment removal");
         env.environment().clear();
         check("<absent>".equals(output(env)), "empty environment");
-        check(output(new ProcessBuilder(fixture, "cwd").directory(args[1])).equals(args[1]), "working directory");
+        check(output(new ProcessBuilder(fixture, "cwd").directory(new File(args[1]))).equals(args[1]), "working directory");
         try { new ProcessBuilder(fixture + "-missing").start(); throw new AssertionError("missing executable accepted"); }
         catch (IOException expectedFailure) { }
         try { new ProcessBuilder(fixture, "bad\0argument").start(); throw new AssertionError("NUL accepted"); }
         catch (IllegalArgumentException expectedFailure) { }
-        try { new ProcessBuilder(fixture, "exit").directory(args[1] + "/missing-dir").start(); throw new AssertionError("bad cwd accepted"); }
+        try { new ProcessBuilder(fixture, "exit").directory(new File(args[1], "missing-dir")).start(); throw new AssertionError("bad cwd accepted"); }
         catch (IOException expectedFailure) { }
         for (int merged = 0; merged < 2; ++merged) {
             Process p = new ProcessBuilder(fixture, "duplex").redirectErrorStream(merged == 1).start();
diff --git a/vm/backend/demo/selftest/com/demo/SelfTest.java b/vm/backend/demo/selftest/com/demo/SelfTest.java
index 28d66bc0041..068f3dc0d66 100644
--- a/vm/backend/demo/selftest/com/demo/SelfTest.java
+++ b/vm/backend/demo/selftest/com/demo/SelfTest.java
@@ -5659,8 +5659,8 @@ private static void aNestedFinallyDoesNotDefeatTheOuterCatch() throws Exception
         // 3. BOTH IN ONE METHOD: the catch encloses a try/finally. This was skipped
         // by default as the case that killed the binary -- the finally's rethrow
         // escaped the enclosing catch -- until the translator's catch-depth fix.
-        // vm/tests CatchRethrowIntegrationTest now covers it on every compiler
-        // configuration, so it runs here as an ordinary check.
+        // vm/tests BulkConformanceIntegrationTest (CatchRethrowApp) now covers
+        // it, so it runs here as an ordinary check.
         String sameMethod;
         try {
             try {
diff --git a/vm/backend/impl/javase/com/codename1/backend/FileIo.java b/vm/backend/impl/javase/com/codename1/backend/FileIo.java
index 1ee6e57e28d..00817ad37db 100644
--- a/vm/backend/impl/javase/com/codename1/backend/FileIo.java
+++ b/vm/backend/impl/javase/com/codename1/backend/FileIo.java
@@ -48,6 +48,11 @@ public final class FileIo {
     private FileIo() {
     }
 
+    /// Nothing to do: on Java SE the JDK is the class library and has its own
+    /// file system. The production twin installs the POSIX `JdkHost`.
+    static void installJdkHost() {
+    }
+
     private static final class OpenFile {
         final FileChannel channel;
         final Path path;
diff --git a/vm/backend/impl/parparvm/com/codename1/backend/FileIo.java b/vm/backend/impl/parparvm/com/codename1/backend/FileIo.java
index e59e9e0d60f..5890aef8861 100644
--- a/vm/backend/impl/parparvm/com/codename1/backend/FileIo.java
+++ b/vm/backend/impl/parparvm/com/codename1/backend/FileIo.java
@@ -33,6 +33,16 @@ public final class FileIo {
     private FileIo() {
     }
 
+    /// Hands the class library its file system: a backend has no Codename One
+    /// core to serve it, so it gets the POSIX host over the file natives this
+    /// runtime links anyway. The translator's generated main() calls it before
+    /// the program's own main, so a program that writes a file before it touches
+    /// `Backend` has a file system too; `Backend`'s static initializer calls it
+    /// again, which is harmless.
+    static void installJdkHost() {
+        com.codename1.impl.JdkHost.install(new com.codename1.impl.PosixJdkHost());
+    }
+
     // Opens for reading. The descriptor, or -1.
     /// A descriptor for `relative` under `root`, or -1. Never a file outside `root`,
     /// and never by checking afterwards: the kernel refuses the escape while it
diff --git a/vm/backend/src/com/codename1/backend/Backend.java b/vm/backend/src/com/codename1/backend/Backend.java
index 68f9529cea7..48fcb225534 100644
--- a/vm/backend/src/com/codename1/backend/Backend.java
+++ b/vm/backend/src/com/codename1/backend/Backend.java
@@ -78,6 +78,7 @@ public final class Backend {
         // First, so code in another package reaching for the internals while
         // anything below initializes still finds them.
         com.codename1.impl.backend.BackendAccess.install(new Access());
+        FileIo.installJdkHost();
     }
 
     private final HttpServer server;
diff --git a/vm/benchmarks/host/com/bench/PosixHost.java b/vm/benchmarks/host/com/bench/PosixHost.java
new file mode 100644
index 00000000000..706fe4f0866
--- /dev/null
+++ b/vm/benchmarks/host/com/bench/PosixHost.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.bench;
+
+/**
+ * The host arm's stand-in for src/com/bench/PosixHost.java: the JDK's java.io
+ * needs no host, and com.codename1.impl is not on the host's class path.
+ */
+final class PosixHost {
+    private PosixHost() {
+    }
+
+    static void install() {
+    }
+}
diff --git a/vm/benchmarks/run-io-benchmark.sh b/vm/benchmarks/run-io-benchmark.sh
index ef708bbedbc..1ba771e0dd6 100755
--- a/vm/benchmarks/run-io-benchmark.sh
+++ b/vm/benchmarks/run-io-benchmark.sh
@@ -27,7 +27,8 @@ mkdir -p target
 
 J8="${JDK_8_HOME:?set JDK_8_HOME}"
 mkdir -p target/io-host-classes
-"$J8/bin/javac" -nowarn -encoding UTF-8 -d target/io-host-classes src/com/bench/IoBench.java
+"$J8/bin/javac" -nowarn -encoding UTF-8 -d target/io-host-classes src/com/bench/IoBench.java \
+    host/com/bench/PosixHost.java
 
 python3 - "$OUT" "$REF_JAVA" "$ROUNDS" <<'PY'
 import subprocess, re, sys, os, shutil, tempfile
diff --git a/vm/benchmarks/run-matrix.sh b/vm/benchmarks/run-matrix.sh
index eb9331af66c..1a1536cf4d5 100755
--- a/vm/benchmarks/run-matrix.sh
+++ b/vm/benchmarks/run-matrix.sh
@@ -56,7 +56,7 @@ echo "== building arms =="
 ./translate-and-build.sh IoBench "$OUT/iobench-bin" >/dev/null
 mkdir -p "$OUT/host-classes"
 "$J8/bin/javac" -nowarn -encoding UTF-8 -d "$OUT/host-classes" \
-    src/com/bench/Bench.java src/com/bench/IoBench.java \
+    src/com/bench/Bench.java src/com/bench/IoBench.java host/com/bench/PosixHost.java \
     common/src/main/java/com/bench/CommonWorkloads.java
 # The AOT cache REFUSES an exploded directory on the classpath ("Cannot have
 # non-empty directory in paths"), so the host arm runs from a jar. Both the record
diff --git a/vm/benchmarks/src/com/bench/IoBench.java b/vm/benchmarks/src/com/bench/IoBench.java
index 1a23a8a1601..b682eb587d5 100644
--- a/vm/benchmarks/src/com/bench/IoBench.java
+++ b/vm/benchmarks/src/com/bench/IoBench.java
@@ -180,6 +180,9 @@ private static long writeManySmall() throws IOException {
     }
 
     public static void main(String[] args) throws IOException {
+        // The translated arm brings its own file system (PosixHost in src/,
+        // compiled only by translate-and-build.sh); the host arm's is a no-op.
+        PosixHost.install();
         // No System.getProperty(String,String) in vm/JavaAPI -- the two-arg overload
         // does not exist there, so the directory is passed in or defaults literally.
         String base = args.length > 0 ? args[0] : "/tmp";
diff --git a/vm/benchmarks/src/com/bench/PosixHost.java b/vm/benchmarks/src/com/bench/PosixHost.java
new file mode 100644
index 00000000000..6ac20c68bf0
--- /dev/null
+++ b/vm/benchmarks/src/com/bench/PosixHost.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.bench;
+
+/**
+ * Gives a benchmark translated without Codename One its file system: without
+ * an installed host, vm/JavaAPI's java.io.File sees an empty one. Compiled
+ * only against JavaAPI, by translate-and-build.sh; the host arm compiles
+ * host/com/bench/PosixHost.java, which does nothing, in its place.
+ */
+final class PosixHost {
+    private PosixHost() {
+    }
+
+    static void install() {
+        com.codename1.impl.JdkHost.install(new com.codename1.impl.PosixJdkHost());
+    }
+}
diff --git a/vm/benchmarks/translate-and-build.sh b/vm/benchmarks/translate-and-build.sh
index d57ff18975a..472da992061 100755
--- a/vm/benchmarks/translate-and-build.sh
+++ b/vm/benchmarks/translate-and-build.sh
@@ -92,6 +92,10 @@ SOURCES=("src/com/bench/$MAIN.java")
 if [ "$MAIN" = "Bench" ]; then
     SOURCES+=("common/src/main/java/com/bench/CommonWorkloads.java")
 fi
+if [ "$MAIN" = "IoBench" ]; then
+    # Installs the POSIX file system host; the host arm uses host/com/bench.
+    SOURCES+=("src/com/bench/PosixHost.java")
+fi
 "$J8/bin/javac" -nowarn -encoding UTF-8 -bootclasspath "$JAVAAPI" -source 1.8 -target 1.8 \
     -d "$WORK/classes" "${SOURCES[@]}"
 
diff --git a/vm/selfhost/perf-baseline/pr/5980.json b/vm/selfhost/perf-baseline/pr/5980.json
new file mode 100644
index 00000000000..5eff17bf168
--- /dev/null
+++ b/vm/selfhost/perf-baseline/pr/5980.json
@@ -0,0 +1,107 @@
+{
+ "pr": 5980,
+ "rebaseline": {
+  "linux-arm64@neoverse-n2": {
+   "hello": {
+    "all": {
+     "from": {
+      "memory": 0.868,
+      "time": 0.931
+     },
+     "memory": 1.103,
+     "reason": "The hello application now ships the Swing and JavaFX compatibility runtimes, so the translation this benchmark times reads about 9,600 classes instead of 7,350. ParparVM's peak grows with the larger live set and the garbage allocated while a concurrent cycle runs over it; the JVM's committed heap already had room, so its peak barely moves and the ratio rises. The fixed-input translator benchmark is unchanged.",
+     "runs": 1,
+     "time": 0.931
+    }
+   }
+  },
+  "linux-x64@amd-epyc-7763-64-core-processor": {
+   "hello": {
+    "all": {
+     "from": {
+      "memory": 1.018,
+      "time": 0.847,
+      "tolerance": {
+       "memory": 0.2,
+       "time": 0.5
+      }
+     },
+     "memory": 0.783,
+     "reason": "The native Linux port hands the memory of freed images back to the system, so the hello application settles at a lower resident size.",
+     "runs": 1,
+     "time": 0.847,
+     "tolerance": {
+      "memory": 0.2,
+      "time": 0.5
+     }
+    }
+   }
+  },
+  "macos-arm64": {
+   "hello": {
+    "all": {
+     "from": {
+      "memory": 1.34,
+      "time": 0.957,
+      "tolerance": {
+       "memory": 0.2,
+       "time": 0.5
+      }
+     },
+     "memory": 1.935,
+     "reason": "The hello application now ships the Swing and JavaFX compatibility runtimes, so the translation this benchmark times reads about 9,600 classes instead of 7,350. ParparVM's peak grows with the larger live set and the garbage allocated while a concurrent cycle runs over it; the JVM's committed heap already had room, so its peak barely moves and the ratio rises. The fixed-input translator benchmark is unchanged.",
+     "runs": 1,
+     "time": 0.957,
+     "tolerance": {
+      "memory": 0.2,
+      "time": 0.5
+     }
+    }
+   }
+  },
+  "windows-x64@amd64-family-26-model-2-authenticamd": {
+   "hello": {
+    "all": {
+     "from": {
+      "memory": 0.749,
+      "time": 1.41,
+      "tolerance": {
+       "memory": 0.3,
+       "time": 0.5
+      }
+     },
+     "memory": 1.06,
+     "reason": "The hello application now ships the Swing and JavaFX compatibility runtimes, so the translation this benchmark times reads about 9,600 classes instead of 7,350. ParparVM's peak grows with the larger live set and the garbage allocated while a concurrent cycle runs over it; the JVM's committed heap already had room, so its peak barely moves and the ratio rises. The fixed-input translator benchmark is unchanged.",
+     "runs": 1,
+     "time": 1.41,
+     "tolerance": {
+      "memory": 0.3,
+      "time": 0.5
+     }
+    }
+   }
+  },
+  "windows-x64@intel64-family-6-model-106-genuineintel": {
+   "hello": {
+    "all": {
+     "from": {
+      "memory": 0.761,
+      "time": 1.212,
+      "tolerance": {
+       "memory": 0.2,
+       "time": 0.5
+      }
+     },
+     "memory": 1.082,
+     "reason": "The hello application now ships the Swing and JavaFX compatibility runtimes, so the translation this benchmark times reads about 9,600 classes instead of 7,350. ParparVM's peak grows with the larger live set and the garbage allocated while a concurrent cycle runs over it; the JVM's committed heap already had room, so its peak barely moves and the ratio rises. The fixed-input translator benchmark is unchanged.",
+     "runs": 1,
+     "time": 1.212,
+     "tolerance": {
+      "memory": 0.2,
+      "time": 0.5
+     }
+    }
+   }
+  }
+ }
+}
diff --git a/vm/selfhost/stubs/com/codename1/tools/translator/RuntimeHost.java b/vm/selfhost/stubs/com/codename1/tools/translator/RuntimeHost.java
new file mode 100644
index 00000000000..4d4f1365e28
--- /dev/null
+++ b/vm/selfhost/stubs/com/codename1/tools/translator/RuntimeHost.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.tools.translator;
+
+import com.codename1.impl.JdkHost;
+import com.codename1.impl.PosixJdkHost;
+
+/**
+ * The self-hosted translator's start-up hook. See {@code vm/selfhost/README.md}.
+ *
+ * The real class is a no-op for the JVM. Here the translator runs on
+ * {@code vm/JavaAPI}, which asks {@code JdkHost} for the platform's file system
+ * and properties; this is a program with no Codename One in it, so it gets the
+ * POSIX host over the file natives it already links.
+ */
+final class RuntimeHost {
+    private RuntimeHost() {
+    }
+
+    static void install() {
+        JdkHost.install(new PosixJdkHost());
+    }
+}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/BulkConformanceIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/BulkConformanceIntegrationTest.java
new file mode 100644
index 00000000000..53ad819dfc3
--- /dev/null
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/BulkConformanceIntegrationTest.java
@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package com.codename1.tools.translator;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/// The bulk conformance run: hundreds of named checks of the class library,
+/// compiled once, run once on HotSpot (the JDK's `java.*`), translated once,
+/// built once and run once on ParparVM (JavaAPI's), then compared check by
+/// check. One translation and one CMake build replace the one each small
+/// fixture used to pay for.
+///
+/// The program lives in `src/test/resources/com/codename1/tools/translator/bulk`:
+///
+/// - `Bulk.java` is the harness (see its comment for the rules a check follows)
+///   and `BulkHost.java` the host the ParparVM run installs;
+/// - every `*Checks.java` is a group with a `public static void run()`; the
+///   main class calling them all is generated here, in file-name order;
+/// - `res/` holds resources: on the HotSpot class path as files, and on
+///   ParparVM served by `BulkHost` from a generated `BulkResources` class;
+/// - a `*.c` file there is the native half of a check and is handed to the
+///   translator beside the classes.
+///
+/// A failure names EVERY check that differs, not the first. To iterate on a few
+/// groups, `-Dbulk.groups=OptionalChecks,LangChecks` builds a main class that
+/// calls only those.
+///
+/// Further assertions on the generated C, which a folded fixture used to make
+/// on its own translation, run here on the shared one.
+class BulkConformanceIntegrationTest {
+
+    private static final String BULK = "/com/codename1/tools/translator/bulk";
+
+    @Test
+    void everyCheckAnswersTheSameOnHotSpotAndParparVM() throws Exception {
+        Parser.cleanup();
+        Path bulkDir = bulkDir();
+        Path work = Files.createTempDirectory("bulk-conformance");
+        Path sourceDir = Files.createDirectories(work.resolve("sources"));
+        Path classesDir = Files.createDirectories(work.resolve("classes"));
+        Path javaApiDir = Files.createDirectories(work.resolve("javaapi"));
+
+        List<String> groups = groups(bulkDir);
+        assertTrue(!groups.isEmpty(), "no *Checks.java group under " + bulkDir);
+        boolean subset = System.getProperty("bulk.groups", "").trim().length() > 0;
+        List<Path> sources = new ArrayList<>();
+        try (Stream<Path> files = Files.list(bulkDir)) {
+            for (Path p : files.filter(f -> f.toString().endsWith(".java")).sorted().collect(Collectors.toList())) {
+                if (subset && !belongsTo(p.getFileName().toString(), groups)) {
+                    continue;
+                }
+                Path copy = sourceDir.resolve(p.getFileName().toString());
+                Files.copy(p, copy);
+                sources.add(copy);
+            }
+        }
+        for (String shared : CORE_SOURCES) {
+            sources.add(coreSources().resolve(shared));
+        }
+        Path main = sourceDir.resolve("BulkApp.java");
+        Files.write(main, mainSource(groups).getBytes(StandardCharsets.UTF_8));
+        sources.add(main);
+        Path resourcesClass = sourceDir.resolve("BulkResources.java");
+        Files.write(resourcesClass, resourcesSource(bulkDir.resolve("res")).getBytes(StandardCharsets.UTF_8));
+        sources.add(resourcesClass);
+
+        CompilerHelper.CompilerConfig config = selectCompiler();
+        assertNotNull(config, "No JDK 17+ compiler that can build JavaAPI");
+        CompilerHelper.compileJavaAPI(javaApiDir, config);
+        List<String> compileArgs = new ArrayList<>(Arrays.asList("-source", config.targetVersion,
+                "-target", config.targetVersion, "-encoding", "UTF-8", "-nowarn"));
+        if (CompilerHelper.useClasspath(config)) {
+            compileArgs.add("-classpath");
+        } else {
+            compileArgs.add("-Xlint:-options");
+            compileArgs.add("-bootclasspath");
+        }
+        compileArgs.add(javaApiDir.toString());
+        compileArgs.add("-d");
+        compileArgs.add(classesDir.toString());
+        for (Path s : sources) {
+            compileArgs.add(s.toString());
+        }
+        assertEquals(0, CompilerHelper.compile(config.jdkHome, compileArgs),
+                "the bulk program should compile. " + CompilerHelper.getLastErrorLog());
+        BulkGeneratedCodeChecks.patchClasses(classesDir);
+        if (Files.isDirectory(bulkDir.resolve("res"))) {
+            CompilerHelper.copyDirectory(bulkDir.resolve("res"), classesDir);
+        }
+
+        // HotSpot: the reference. JDK 19+ when there is one, for the reason
+        // TaggedValueIntegrationTest gives: Double.toString changed in 19 and
+        // ParparVM implements the new form.
+        Path hotspotHome = referenceJdk(config);
+        Path hotspotDir = Files.createDirectories(work.resolve("run-hotspot"));
+        String javaExe = hotspotHome.resolve("bin").resolve(CompilerHelper.executableName("java")).toString();
+        Run hotspot = run(Arrays.asList(javaExe, "-Dbulk.host=hotspot", "-Duser.language=en",
+                "-Duser.country=US", "-cp", classesDir + java.io.File.pathSeparator + javaApiDir, "BulkApp"),
+                hotspotDir);
+        assertEquals(0, hotspot.exit, "the HotSpot run should exit cleanly:\n" + tail(hotspot.output));
+        if (Boolean.getBoolean("bulk.hotspotOnly")) {
+            // For writing checks: what the JDK answers, without the translation.
+            System.out.println(hotspot.output);
+            return;
+        }
+
+        // ParparVM.
+        CompilerHelper.copyDirectory(javaApiDir, classesDir);
+        try (Stream<Path> files = Files.list(bulkDir)) {
+            for (Path c : files.filter(f -> f.toString().endsWith(".c")).collect(Collectors.toList())) {
+                Files.copy(c, classesDir.resolve(c.getFileName().toString()));
+            }
+        }
+        Path outputDir = Files.createDirectories(work.resolve("output"));
+        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "BulkApp");
+        Path distDir = outputDir.resolve("dist");
+        Path cmakeLists = distDir.resolve("CMakeLists.txt");
+        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
+        List<String> failures = new ArrayList<>();
+        Path generated = distDir.resolve("BulkApp-src");
+        BulkGeneratedCodeChecks.check(generated, groups, failures);
+
+        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "BulkApp-src");
+        Path buildDir = Files.createDirectories(distDir.resolve("build"));
+        List<String> configure = new ArrayList<>(Arrays.asList("cmake", "-S", distDir.toString(), "-B",
+                buildDir.toString()));
+        configure.addAll(CompilerHelper.cmakeToolchainArgs());
+        // CN1_TEST_EXTRA_CFLAGS, e.g. AddressSanitizer for the allocation
+        // lifetime evidence StringBuilderGrowthApp was written to collect.
+        configure.addAll(CompilerHelper.extraCFlagArgs());
+        CleanTargetIntegrationTest.runCommand(configure, distDir);
+        // One build, so it may use every core: this is the cost the bulk run
+        // pays once instead of once per fixture.
+        ProcessBuilder build = new ProcessBuilder("cmake", "--build", buildDir.toString(), "--parallel",
+                String.valueOf(Math.max(2, Runtime.getRuntime().availableProcessors())));
+        build.directory(distDir.toFile());
+        CleanTargetIntegrationTest.runCommand(build, 45, TimeUnit.MINUTES);
+        Path executable = buildDir.resolve(CompilerHelper.executableName("BulkApp"));
+        assertTrue(Files.exists(executable), "ParparVM build should produce " + executable);
+        Path parparDir = Files.createDirectories(work.resolve("run-parparvm"));
+        Run parpar = run(Collections.singletonList(executable.toString()), parparDir);
+
+        Map<String, List<String>> expected = parse(hotspot.output);
+        Map<String, List<String>> actual = parse(parpar.output);
+        compare(expected, actual, failures);
+        BulkGeneratedCodeChecks.checkOutput(actual, failures);
+        if (parpar.exit != 0) {
+            String last = actual.isEmpty() ? "(none)" : new ArrayList<>(actual.keySet()).get(actual.size() - 1);
+            failures.add(0, "ParparVM exited with " + parpar.exit + " during check " + last + ":\n"
+                    + tail(parpar.output));
+        }
+        int checks = expected.size() - (expected.containsKey("(end)") ? 1 : 0);
+        System.out.println("[bulk] " + checks + " checks in " + groups.size() + " groups; "
+                + failures.size() + " failing");
+        if (!failures.isEmpty()) {
+            fail(failures.size() + " bulk check(s) differ between HotSpot and ParparVM (outputs under "
+                    + work + "):\n" + String.join("\n", failures));
+        }
+    }
+
+    /// Splits a run's output into checks: a `### name` line opens one, every
+    /// line up to the next belongs to it. A runtime diagnostic -- an upper
+    /// case tag in brackets, `[GC-INSTR] ...` -- is never a check's output and
+    /// is dropped on both sides. Only that shape: dropping every line that
+    /// starts with `[` silently stopped comparing a check that printed an
+    /// array or a list on a line of its own.
+    static Map<String, List<String>> parse(String output) {
+        Map<String, List<String>> checks = new LinkedHashMap<>();
+        List<String> current = null;
+        for (String line : output.split("\\R")) {
+            if (line.startsWith("### ")) {
+                current = new ArrayList<>();
+                checks.put(line.substring(4), current);
+            } else if (current != null && !DIAGNOSTIC.matcher(line).lookingAt()) {
+                current.add(line);
+            }
+        }
+        return checks;
+    }
+
+    static void compare(Map<String, List<String>> expected, Map<String, List<String>> actual, List<String> failures) {
+        Set<String> names = new LinkedHashSet<>(expected.keySet());
+        names.addAll(actual.keySet());
+        for (String name : names) {
+            List<String> e = expected.get(name);
+            List<String> a = actual.get(name);
+            if (e == null) {
+                failures.add(name + ": ran on ParparVM only");
+                continue;
+            }
+            if (a == null) {
+                failures.add(name + ": never ran on ParparVM");
+                continue;
+            }
+            if (!e.isEmpty() && e.get(0).startsWith("SKIPPED ")) {
+                continue;
+            }
+            if (e.size() == 1 && "CN1-ONLY".equals(e.get(0))) {
+                for (String line : a) {
+                    if (line.startsWith("FAIL") || line.startsWith("THREW")) {
+                        failures.add(name + " (ParparVM only): " + line);
+                    }
+                }
+                continue;
+            }
+            if (e.equals(a)) {
+                continue;
+            }
+            int i = 0;
+            while (i < e.size() && i < a.size() && e.get(i).equals(a.get(i))) {
+                i++;
+            }
+            failures.add(name + ": line " + (i + 1) + "\n    HotSpot:  " + clip(i < e.size() ? e.get(i) : "(no line)")
+                    + "\n    ParparVM: " + clip(i < a.size() ? a.get(i) : "(no line)"));
+        }
+    }
+
+    private static String clip(String s) {
+        if (s.length() <= 600) {
+            return s;
+        }
+        // A RESULT line of a folded fixture carries every case; show where it
+        // starts to differ rather than its first kilobyte.
+        return s.substring(0, 600) + "...";
+    }
+
+    /// A runtime diagnostic line: `[TAG]` or `[TAG-SUB]` at the start.
+    static final java.util.regex.Pattern DIAGNOSTIC = java.util.regex.Pattern.compile("\\[[A-Z][A-Z0-9_-]*\\]");
+
+    /// Core classes compiled into the bulk program, from `CodenameOne/src`
+    /// itself: the pure-Java digests a built application's host answers
+    /// `MessageDigest` with, so the program digests through the same code an
+    /// application does rather than through a copy. All are
+    /// `@SharedWithBackend`, i.e. depend on the JDK subset alone. Each is in
+    /// the `paths` of `.github/workflows/parparvm-tests.yml`.
+    static final String[] CORE_SOURCES = {
+        "com/codename1/impl/SharedWithBackend.java",
+        "com/codename1/security/CryptoException.java",
+        "com/codename1/security/MessageDigestImpl.java",
+        "com/codename1/security/Hash.java",
+    };
+
+    /// `CodenameOne/src`: `-Dbulk.repo` names the checkout, otherwise it is
+    /// found above the working directory (vm/tests under Maven).
+    static Path coreSources() {
+        String repo = System.getProperty("bulk.repo");
+        if (repo != null && !repo.trim().isEmpty()) {
+            return Paths.get(repo.trim(), "CodenameOne", "src");
+        }
+        for (Path p = Paths.get("").toAbsolutePath(); p != null; p = p.getParent()) {
+            Path src = p.resolve("CodenameOne").resolve("src");
+            if (Files.isRegularFile(src.resolve(CORE_SOURCES[0]))) {
+                return src;
+            }
+        }
+        fail("CodenameOne/src not found above " + Paths.get("").toAbsolutePath() + "; pass -Dbulk.repo");
+        return null;
+    }
+
+    static Path bulkDir() throws URISyntaxException {
+        URL url = BulkConformanceIntegrationTest.class.getResource(BULK + "/Bulk.java");
+        assertNotNull(url, "bulk program resources should be on the test class path");
+        return Paths.get(url.toURI()).getParent();
+    }
+
+    static List<String> groups(Path bulkDir) throws IOException {
+        String only = System.getProperty("bulk.groups");
+        Set<String> filter = null;
+        if (only != null && !only.trim().isEmpty()) {
+            filter = new LinkedHashSet<>(Arrays.asList(only.trim().split("\\s*,\\s*")));
+        }
+        List<String> out = new ArrayList<>();
+        try (Stream<Path> files = Files.list(bulkDir)) {
+            for (Path p : files.sorted().collect(Collectors.toList())) {
+                String f = p.getFileName().toString();
+                if (f.endsWith("Checks.java")) {
+                    String cls = f.substring(0, f.length() - ".java".length());
+                    if (filter == null || filter.contains(cls)) {
+                        out.add(cls);
+                    }
+                }
+            }
+        }
+        if (filter != null) {
+            assertEquals(filter.size(), out.size(), "-Dbulk.groups names a group that does not exist: " + filter);
+        }
+        return out;
+    }
+
+    /// With `-Dbulk.groups`, only the harness and the named groups compile: a
+    /// group `XChecks` owns every file whose name starts with `X`.
+    static boolean belongsTo(String file, List<String> groups) {
+        if (file.startsWith("Bulk")) {
+            return true;
+        }
+        for (String g : groups) {
+            if (file.startsWith(g.substring(0, g.length() - "Checks".length()))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static String mainSource(List<String> groups) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("/// Generated by BulkConformanceIntegrationTest.\n");
+        sb.append("public class BulkApp {\n");
+        sb.append("    public static void main(String[] args) throws Exception {\n");
+        sb.append("        Bulk.begin();\n");
+        for (String g : groups) {
+            sb.append("        ").append(g).append(".run();\n");
+        }
+        sb.append("        Bulk.end();\n");
+        sb.append("    }\n");
+        sb.append("}\n");
+        return sb.toString();
+    }
+
+    /// `BulkResources.get(name)`: every file under `res`, as the bytes the
+    /// HotSpot run reads from its class path.
+    static String resourcesSource(Path res) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        sb.append("/// Generated by BulkConformanceIntegrationTest from bulk/res.\n");
+        sb.append("final class BulkResources {\n");
+        sb.append("    static byte[] get(String name) {\n");
+        if (Files.isDirectory(res)) {
+            List<Path> files;
+            try (Stream<Path> all = Files.walk(res)) {
+                files = all.filter(Files::isRegularFile).sorted().collect(Collectors.toList());
+            }
+            for (Path f : files) {
+                String name = res.relativize(f).toString().replace('\\', '/');
+                sb.append("        if (\"").append(name).append("\".equals(name)) {\n");
+                sb.append("            return bytes(\"").append(latin1Literal(Files.readAllBytes(f))).append("\");\n");
+                sb.append("        }\n");
+            }
+        }
+        sb.append("        return null;\n");
+        sb.append("    }\n\n");
+        sb.append("    private static byte[] bytes(String s) {\n");
+        sb.append("        byte[] b = new byte[s.length()];\n");
+        sb.append("        for (int i = 0; i < b.length; i++) {\n");
+        sb.append("            b[i] = (byte) s.charAt(i);\n");
+        sb.append("        }\n");
+        sb.append("        return b;\n");
+        sb.append("    }\n");
+        sb.append("}\n");
+        return sb.toString();
+    }
+
+    private static String latin1Literal(byte[] data) {
+        StringBuilder sb = new StringBuilder(data.length);
+        for (byte b : data) {
+            int c = b & 0xff;
+            if (c >= 0x20 && c < 0x7f && c != '"' && c != '\\') {
+                sb.append((char) c);
+            } else {
+                // Octal, not a unicode escape: javac turns a unicode escape into
+                // its character before it lexes, so a newline written that way
+                // ends the string literal.
+                sb.append(String.format("\\%03o", c));
+            }
+        }
+        return sb.toString();
+    }
+
+    static final class Run {
+        final int exit;
+        final String output;
+
+        Run(int exit, String output) {
+            this.exit = exit;
+            this.output = output;
+        }
+    }
+
+    /// Runs a command to completion and keeps its output whatever the exit
+    /// status: a crash part-way through still tells which checks ran.
+    static Run run(List<String> command, Path dir) throws Exception {
+        ProcessBuilder pb = new ProcessBuilder(command);
+        pb.directory(dir.toFile());
+        pb.redirectErrorStream(true);
+        Path log = dir.resolve("output.log");
+        pb.redirectOutput(log.toFile());
+        System.out.println("Running command: " + String.join(" ", command) + " (output: " + log + ")");
+        Process p = pb.start();
+        p.getOutputStream().close();
+        boolean finished = p.waitFor(20, TimeUnit.MINUTES);
+        if (!finished) {
+            p.destroyForcibly();
+            p.waitFor(10, TimeUnit.SECONDS);
+        }
+        String output = new String(Files.readAllBytes(log), StandardCharsets.UTF_8);
+        return new Run(finished ? p.exitValue() : -1, output);
+    }
+
+    private static String tail(String output) {
+        String[] lines = output.split("\\R");
+        int from = Math.max(0, lines.length - 40);
+        return String.join("\n", Arrays.asList(lines).subList(from, lines.length));
+    }
+
+    private static CompilerHelper.CompilerConfig selectCompiler() {
+        // The checks use Java 21 API (SwitchoverMembersApp calls the sequenced
+        // List methods), so prefer 21; 17 is the last resort for the rest.
+        for (String target : new String[] {"21", "25", "17"}) {
+            for (CompilerHelper.CompilerConfig config : CompilerHelper.getAvailableCompilers(target)) {
+                if (CompilerHelper.isJavaApiCompatible(config)) {
+                    return config;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static Path referenceJdk(CompilerHelper.CompilerConfig fallback) {
+        for (String v : new String[] {"21", "25", "19"}) {
+            for (CompilerHelper.CompilerConfig candidate : CompilerHelper.getAvailableCompilers(v)) {
+                if (CompilerHelper.getJdkMajor(candidate) >= 19) {
+                    return candidate.jdkHome;
+                }
+            }
+        }
+        return fallback.jdkHome;
+    }
+}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/BulkGeneratedCodeChecks.java b/vm/tests/src/test/java/com/codename1/tools/translator/BulkGeneratedCodeChecks.java
new file mode 100644
index 00000000000..554ab51d3e1
--- /dev/null
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/BulkGeneratedCodeChecks.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+package com.codename1.tools.translator;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/// The assertions a folded fixture used to make on its own translation and
+/// output, beyond "HotSpot and ParparVM print the same", run on the bulk
+/// program's shared translation. Each adds to `failures` instead of throwing,
+/// so one run reports all of them.
+final class BulkGeneratedCodeChecks {
+    private BulkGeneratedCodeChecks() {
+    }
+
+    /// Assertions on the generated C, made before it is built.
+    static void check(Path generated, List<String> groups, List<String> failures) throws IOException {
+        if (groups.contains("StreamEdgeChecks")) {
+            streamEdgeFusion(read(generated.resolve("StreamEdgeApp.c")), failures);
+        }
+        if (groups.contains("StringFormatChecks")) {
+            stringFormatOwnership(generated, failures);
+        }
+        if (groups.contains("CollectionSemanticsChecks")) {
+            collectionTraversal(read(generated.resolve("CollectionSemanticsApp.c")), failures);
+        }
+    }
+
+    /// Rewrites compiled fixture classes before both runs, for a bytecode
+    /// shape javac does not reliably produce.
+    ///
+    /// CollectionSemanticsApp.stringFromCollection calls `toString` on a
+    /// Collection. Both owners are legal for that Object method and some
+    /// compilers emit `Collection.toString` as an INVOKEINTERFACE, as in the
+    /// Windows ARM64 migration-test crash; this exercises that form on both
+    /// runtimes whichever javac compiled the fixture.
+    static void patchClasses(Path classesDir) throws IOException {
+        Path appClass = classesDir.resolve("CollectionSemanticsApp.class");
+        if (!Files.exists(appClass)) {
+            return;
+        }
+        ClassWriter writer = new ClassWriter(0);
+        new ClassReader(Files.readAllBytes(appClass)).accept(new ClassVisitor(Opcodes.ASM9, writer) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
+                    String[] exceptions) {
+                MethodVisitor method = super.visitMethod(access, name, descriptor, signature, exceptions);
+                if (!"stringFromCollection".equals(name)) {
+                    return method;
+                }
+                return new MethodVisitor(Opcodes.ASM9, method) {
+                    @Override
+                    public void visitMethodInsn(int opcode, String owner, String called, String desc,
+                            boolean isInterface) {
+                        if ("toString".equals(called)) {
+                            super.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/Collection", called, desc,
+                                    true);
+                        } else {
+                            super.visitMethodInsn(opcode, owner, called, desc, isInterface);
+                        }
+                    }
+                };
+            }
+        }, 0);
+        Files.write(appClass, writer.toByteArray());
+    }
+
+    /// StringBuilder's native primitive storage needs a finalizer and no
+    /// tracing, String still traces, and StringFormatApp's builder helpers
+    /// keep stack allocation only where the builder provably does not escape.
+    private static void stringFormatOwnership(Path generated, List<String> failures) throws IOException {
+        if (!read(generated.resolve("java_lang_StringBuilder.c")).contains(
+                "&__FINALIZER_java_lang_StringBuilder ,0 , 0,")) {
+            failures.add("StringFormatApp: native primitive storage needs cleanup but no tracing callback");
+        }
+        if (!read(generated.resolve("java_lang_String.c")).contains("&__GC_MARK_java_lang_String,")) {
+            failures.add("StringFormatApp: Strings still trace their backing storage");
+        }
+        String app = read(generated.resolve("StringFormatApp.c"));
+        if (!app.contains("cleanup(cn1StackBufferLeave)")) {
+            failures.add("StringFormatApp: the exception/return cases must exercise stack buffer ownership");
+        }
+        String borrowed = function(app, "JAVA_OBJECT StringFormatApp_borrowedBuilderResult___R_java_lang_String(", "\n}");
+        if (borrowed == null || !borrowed.contains("cleanup(cn1StackBufferLeave)")) {
+            failures.add("StringFormatApp: a proved borrowing helper must preserve stack allocation");
+        }
+        String escaped = function(app, "JAVA_VOID StringFormatApp_escapingBuilderResult__(", "\n}");
+        if (escaped == null || escaped.contains("cleanup(cn1StackBufferLeave)")) {
+            failures.add("StringFormatApp: a retaining helper must keep heap ownership");
+        }
+    }
+
+    /// CollectionSemanticsApp's list traversals use native cursors and never
+    /// a map or set layout; direct `List.get` calls are inlined behind a
+    /// receiver test and keep the virtual call for mixed receivers.
+    private static void collectionTraversal(String generated, List<String> failures) {
+        String walk = function(generated, "JAVA_VOID CollectionSemanticsApp_fieldTraversalCases__(", null);
+        if (walk == null) {
+            failures.add("CollectionSemanticsApp: no generated fieldTraversalCases");
+        } else {
+            expect(walk.contains("cn1RefBlockGet"), "field and call-result loops use native cursors", failures);
+            expect(!walk.contains("java_util_HashMap"), "List receivers cannot use map-view layouts", failures);
+            expect(!walk.contains("java_util_HashSet"), "List receivers cannot use set layouts", failures);
+            expect(!walk.contains("java_util_IdentityHashMap"),
+                    "List receivers cannot use identity-map layouts", failures);
+        }
+        String direct = function(generated, "JAVA_VOID CollectionSemanticsApp_directCallCases__(", null);
+        if (direct == null) {
+            failures.add("CollectionSemanticsApp: no generated directCallCases");
+        } else {
+            expect(direct.contains("cn1InlListGet"), "direct List.get is inlined", failures);
+            expect(direct.contains("__cn1DirectReceiver"), "direct List.get tests its receiver", failures);
+            expect(direct.contains("cn1ThrowNullPointerOrDie"), "direct List.get checks null", failures);
+            expect(direct.contains("virtual_java_util_List_get___int_R_java_lang_Object"),
+                    "mixed receivers must retain dispatch", failures);
+        }
+    }
+
+    private static void expect(boolean ok, String what, List<String> failures) {
+        if (!ok) {
+            failures.add("CollectionSemanticsApp: " + what);
+        }
+    }
+
+    /// The generated C from the definition starting with `signature` up to
+    /// `end` (or the end of the file); null if absent. With a null `end` it
+    /// runs to the next function definition: a statement expression can put
+    /// a brace, or a `JAVA_` declaration, at column 0 inside a function.
+    private static String function(String c, String signature, String end) {
+        int start = c.indexOf(signature);
+        if (start < 0) {
+            return null;
+        }
+        int from = start + signature.length();
+        int stop;
+        if (end != null) {
+            stop = c.indexOf(end, from);
+        } else {
+            stop = c.indexOf("(CODENAME_ONE_THREAD_STATE", from);
+            if (stop >= 0) {
+                stop = c.lastIndexOf('\n', stop);
+            }
+        }
+        return c.substring(start, stop < 0 ? c.length() : stop);
+    }
+
+    /// StreamEdgeApp's eight immediate helper pipelines must lower to fused C
+    /// loops: no callback objects, no dispatch through the stream stages.
+    /// Equal output cannot show this, since the unfused pipeline answers the
+    /// same.
+    private static void streamEdgeFusion(String generated, List<String> failures) {
+        if (generated.split("fused array stream", -1).length < 9) {
+            failures.add("StreamEdgeApp: all eight immediate helper pipelines must lower to C");
+        }
+        for (String helper : Arrays.asList("fusedMatch", "fusedCount", "fusedForEach", "fusedAll",
+                "fusedNone", "fusedZero", "fusedThrow", "fusedMutation")) {
+            int start = generated.indexOf(" StreamEdgeApp_" + helper + "_");
+            if (start < 0) {
+                failures.add("StreamEdgeApp: no generated function for " + helper);
+                continue;
+            }
+            int end = generated.indexOf("\nJAVA_", start);
+            String body = generated.substring(start, end < 0 ? generated.length() : end);
+            if (!body.contains("fused array stream")) {
+                failures.add("StreamEdgeApp." + helper + " was not fused");
+            }
+            if (body.contains("lambda$factory")) {
+                failures.add("StreamEdgeApp." + helper + " must not allocate callback objects");
+            }
+            if (body.contains("virtual_java_util_stream")) {
+                failures.add("StreamEdgeApp." + helper + " must not dispatch stream stages");
+            }
+        }
+    }
+
+    /// Assertions on what particular checks printed on ParparVM.
+    static void checkOutput(Map<String, List<String>> parparvm, List<String> failures) {
+        List<String> collections = parparvm.get("CollectionSemanticsApp");
+        if (collections != null) {
+            // Named explicitly so a regression points at the change rather
+            // than at a generic diff.
+            caseValue(collections, "empty.size", "0", "a list never added to must be empty", failures);
+            caseValue(collections, "empty.get0", "IndexOutOfBounds", "get(0) on an empty list must still throw",
+                    failures);
+            caseValue(collections, "ihm.keyNulls", "1",
+                    "the key iterator must hand back the null key as null, not the table's sentinel", failures);
+            caseValue(collections, "ihm.valNulls", "1", "the value iterator must hand back a null value as null",
+                    failures);
+            caseValue(collections, "ihm.bigSeen", "500", "key iteration must survive a rehash", failures);
+        }
+        List<String> rethrow = parparvm.get("CatchRethrowApp");
+        if (rethrow != null && !rethrow.contains("RESULT=127")) {
+            // Formerly CatchRethrowIntegrationTest's own assertion.
+            failures.add("CatchRethrowApp: an exception thrown from a catch handler was caught by a sibling"
+                    + " handler: " + rethrow);
+        }
+    }
+
+    private static void caseValue(List<String> lines, String key, String expected, String what,
+            List<String> failures) {
+        String prefix = "CASE|" + key + "|";
+        for (String line : lines) {
+            if (line.startsWith(prefix)) {
+                if (!line.substring(prefix.length()).equals(expected)) {
+                    failures.add("CollectionSemanticsApp: " + what + " (" + line + ")");
+                }
+                return;
+            }
+        }
+        failures.add("CollectionSemanticsApp: no " + key + " case (" + what + ")");
+    }
+
+    static String read(Path file) throws IOException {
+        return new String(Files.readAllBytes(file), StandardCharsets.UTF_8);
+    }
+}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/CatchRethrowIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/CatchRethrowIntegrationTest.java
deleted file mode 100644
index 4afd7c3cb78..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/CatchRethrowIntegrationTest.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.params.ParameterizedTest;
-
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * An exception thrown from a catch handler leaves the whole try statement: the
- * statement's other handlers do not see it.
- *
- * A try with two catch clauses registers two try blocks, one per handler, and
- * throwException used to pop only the block that matched -- so when that handler
- * threw (a rethrow, or a new exception), its sibling handler for the SAME try was
- * still registered and caught it. {@code catch (IOException e) { throw e; } catch
- * (Exception e) { ... }} swallowed the rethrow on every native target; JUnit's
- * assertAll stand-in, which rethrows an OutOfMemoryError ahead of a catch
- * (Throwable), is how it surfaced.
- */
-class CatchRethrowIntegrationTest {
-
-    /// One compiler, not the diagonal: the bug is in how the translator emits
-    /// handlers, which no javac version changes, and each configuration costs a
-    /// full translate and native build -- across all of them this test alone was
-    /// ten minutes of a job that has a ninety-minute limit.
-    static java.util.stream.Stream<CompilerHelper.CompilerConfig> oneCompilerConfig() {
-        return CompilerHelper.getDiagonalCompilers().stream()
-                .filter(CompilerHelper::isJavaApiCompatible)
-                .limit(1);
-    }
-
-    @ParameterizedTest
-    @org.junit.jupiter.params.provider.MethodSource("oneCompilerConfig")
-    void anExceptionFromAHandlerLeavesTheTryStatement(CompilerHelper.CompilerConfig config) throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("rethrow-sources");
-        Path classesDir = Files.createTempDirectory("rethrow-classes");
-        Path javaApiDir = Files.createTempDirectory("rethrow-java-api");
-        Files.write(sourceDir.resolve("RethrowApp.java"), source().getBytes(StandardCharsets.UTF_8));
-
-        JavascriptTargetIntegrationTest.compileAgainstJavaApi(config, sourceDir, classesDir, javaApiDir);
-
-        Path outputDir = Files.createTempDirectory("rethrow-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "RethrowApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "RethrowApp-src");
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-        List<String> configure = new java.util.ArrayList<>(Arrays.asList(
-                "cmake", "-S", distDir.toString(), "-B", buildDir.toString(),
-                "-DCMAKE_BUILD_TYPE=Release"));
-        configure.addAll(CompilerHelper.cmakeToolchainArgs());
-        CleanTargetIntegrationTest.runCommand(configure, distDir);
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        Path executable = buildDir.resolve(CompilerHelper.executableName("RethrowApp"));
-        String output = CleanTargetIntegrationTest.runCommand(Arrays.asList(executable.toString()), buildDir);
-        assertTrue(output.contains("RESULT=127"),
-                "an exception thrown from a catch handler was caught by a sibling handler:\n" + output);
-    }
-
-    private static String source() {
-        return "public class RethrowApp {\n"
-                + "    static int cleanups;\n"
-                + "    static void fail(String why) { throw new IllegalStateException(why); }\n"
-                // A typed handler rethrows; the broader sibling must not see it.
-                + "    static int rethrow() {\n"
-                + "        try { fail(\"a\"); } catch (IllegalStateException e) { throw e; }\n"
-                + "        catch (RuntimeException e) { return 100; }\n"
-                + "        return 200;\n"
-                + "    }\n"
-                // A typed handler throws something new; same.
-                + "    static int throwNew() {\n"
-                + "        try { fail(\"b\"); } catch (IllegalStateException e) {\n"
-                + "            throw new UnsupportedOperationException(\"from the handler\"); }\n"
-                + "        catch (RuntimeException e) { return 100; }\n"
-                + "        return 200;\n"
-                + "    }\n"
-                // The same inside a try/finally: the finally runs once.
-                + "    static int withFinally() {\n"
-                + "        try {\n"
-                + "            try { fail(\"c\"); } catch (IllegalStateException e) { throw e; }\n"
-                + "            catch (RuntimeException e) { return 100; }\n"
-                + "        } finally { cleanups++; }\n"
-                + "        return 200;\n"
-                + "    }\n"
-                // A handler of an inner try that throws is still caught by an OUTER try.
-                + "    static int nested() {\n"
-                + "        try {\n"
-                + "            try { fail(\"d\"); } catch (IllegalStateException e) { throw e; }\n"
-                + "            catch (RuntimeException e) { return 100; }\n"
-                + "        } catch (IllegalStateException outer) { return 7; }\n"
-                + "        return 200;\n"
-                + "    }\n"
-                // SelfTest's long-skipped VM probe: a catch around a try/finally in
-                // the same method must see what the finally rethrows.
-                + "    static int touched;\n"
-                + "    static String nestedFinally() {\n"
-                + "        try {\n"
-                + "            try { throw new java.io.IOException(\"thrown in the inner try\"); }\n"
-                + "            finally { touched++; }\n"
-                + "        } catch (Exception caught) { return \"caught\"; }\n"
-                + "    }\n"
-                + "    public static void main(String[] args) {\n"
-                + "        int score = 0;\n"
-                + "        try { rethrow(); } catch (IllegalStateException e) {\n"
-                + "            if (\"a\".equals(e.getMessage())) { score |= 1; } }\n"
-                + "        try { throwNew(); } catch (UnsupportedOperationException e) { score |= 2; }\n"
-                + "        try { withFinally(); } catch (IllegalStateException e) { score |= 4; }\n"
-                + "        if (cleanups == 1) { score |= 8; }\n"
-                + "        if (nested() == 7) { score |= 16; }\n"
-                + "        try { fail(\"e\"); } catch (RuntimeException e) { score |= 32; }\n"
-                + "        if (\"caught\".equals(nestedFinally()) && touched == 1) { score |= 64; }\n"
-                + "        System.out.println(\"RESULT=\" + score);\n"
-                + "    }\n"
-                + "}\n";
-    }
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/CldcJavaApiParityTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/CldcJavaApiParityTest.java
new file mode 100644
index 00000000000..62400583d8b
--- /dev/null
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/CldcJavaApiParityTest.java
@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.tools.translator;
+
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Every public member of a {@code Ports/CLDC11} class must exist in {@code vm/JavaAPI}.
+ *
+ * CLDC11 is the API applications compile against and the index the build's
+ * compliance check reads; JavaAPI is what a device runs. A member CLDC11 declares
+ * and JavaAPI lacks compiles, passes the compliance check, and then fails the
+ * translation (or links to nothing) on the device. So JavaAPI must be a superset.
+ *
+ * The rule, member by member: for each public or protected class of CLDC11, each
+ * public or protected field, method and constructor it declares must exist in
+ * JavaAPI with the same name and descriptor, at least as accessible, and with the
+ * same static-ness. Methods and fields may be inherited there (a JavaAPI class may
+ * put a method in a superclass or a default method in an interface); constructors
+ * may not. Synthetic and bridge members are ignored.
+ *
+ * Existing gaps are listed in {@code cldc-javaapi-parity-baseline.txt}, a ratchet:
+ * a NEW gap fails, and so does a listed gap that has since been closed, so the
+ * file only ever shrinks. Regenerate it after closing gaps with
+ * {@code -DcldcParity.writeBaseline=true}; never to admit a new one.
+ *
+ * It also holds the four copies of {@code com.codename1.impl.JdkHost} byte for byte
+ * identical, as that class's documentation promises.
+ */
+class CldcJavaApiParityTest {
+    private static final Path REPO_ROOT = Paths.get("..", "..").toAbsolutePath().normalize();
+    private static final Path CLDC_SRC = REPO_ROOT.resolve(Paths.get("Ports", "CLDC11", "src"));
+    private static final Path JAVAAPI_SRC = REPO_ROOT.resolve(Paths.get("vm", "JavaAPI", "src"));
+    private static final Path BASELINE = REPO_ROOT.resolve(Paths.get(
+            "vm", "tests", "src", "test", "resources", "cldc-javaapi-parity-baseline.txt"));
+
+    private static final String[] JDK_HOST_COPIES = {
+        "vm/JavaAPI/src/com/codename1/impl/JdkHost.java",
+        "Ports/CLDC11/src/com/codename1/impl/JdkHost.java",
+        "Ports/JavaSE/src/com/codename1/impl/JdkHost.java",
+        "Ports/Android/src/com/codename1/impl/JdkHost.java",
+    };
+
+    @Test
+    void jdkHostCopiesAreIdentical() throws IOException {
+        byte[] canonical = Files.readAllBytes(REPO_ROOT.resolve(JDK_HOST_COPIES[0]));
+        for (int i = 1; i < JDK_HOST_COPIES.length; i++) {
+            Path copy = REPO_ROOT.resolve(JDK_HOST_COPIES[i]);
+            assertTrue(Files.isRegularFile(copy), "missing " + JDK_HOST_COPIES[i]);
+            assertArrayEquals(canonical, Files.readAllBytes(copy),
+                    JDK_HOST_COPIES[i] + " differs from " + JDK_HOST_COPIES[0]
+                            + "; edit the JavaAPI copy and copy it over the other three");
+        }
+    }
+
+    @Test
+    void everyCldcMemberExistsInJavaApi() throws Exception {
+        Path cldcClasses = Files.createTempDirectory("cldc-parity-cldc");
+        Path javaApiClasses = Files.createTempDirectory("cldc-parity-javaapi");
+        compile(CLDC_SRC, cldcClasses);
+        compile(JAVAAPI_SRC, javaApiClasses);
+
+        Map<String, ClassShape> cldc = load(cldcClasses);
+        Map<String, ClassShape> javaApi = load(javaApiClasses);
+        assertTrue(cldc.containsKey("java/lang/Object") && javaApi.containsKey("java/lang/Object"),
+                "both class libraries should have compiled");
+
+        TreeSet<String> violations = new TreeSet<String>();
+        for (ClassShape c : cldc.values()) {
+            if (!c.visible) {
+                continue;
+            }
+            ClassShape j = javaApi.get(c.name);
+            if (j == null) {
+                violations.add("MISSING_CLASS " + c.name);
+                continue;
+            }
+            for (Member m : c.members.values()) {
+                Member found = m.constructor ? j.members.get(m.key) : find(javaApi, j, m.key, m.isStatic());
+                if (found == null) {
+                    violations.add("MISSING " + c.name + "#" + m.key);
+                } else if (!atLeastAsVisible(found, m) || found.isStatic() != m.isStatic()) {
+                    violations.add("DIFFERS " + c.name + "#" + m.key);
+                }
+            }
+        }
+
+        if (Boolean.getBoolean("cldcParity.writeBaseline")) {
+            Files.write(BASELINE, header().concat(String.join("\n", violations)).concat("\n")
+                    .getBytes(StandardCharsets.UTF_8));
+            return;
+        }
+
+        TreeSet<String> baseline = readBaseline();
+        List<String> added = new ArrayList<String>();
+        for (String v : violations) {
+            if (!baseline.contains(v)) {
+                added.add(v);
+            }
+        }
+        List<String> closed = new ArrayList<String>();
+        for (String b : baseline) {
+            if (!violations.contains(b)) {
+                closed.add(b);
+            }
+        }
+        if (!added.isEmpty()) {
+            fail(added.size() + " CLDC11 API member(s) missing from vm/JavaAPI. Add them to "
+                    + "JavaAPI (never to the baseline):\n  " + String.join("\n  ", added));
+        }
+        if (!closed.isEmpty()) {
+            fail(closed.size() + " baseline entr(ies) no longer occur -- the gap was closed. "
+                    + "Remove them from " + REPO_ROOT.relativize(BASELINE)
+                    + " (or rerun with -DcldcParity.writeBaseline=true):\n  "
+                    + String.join("\n  ", closed));
+        }
+    }
+
+    private static String header() {
+        return "# CLDC11 API members vm/JavaAPI does not provide. A RATCHET, not an\n"
+                + "# allow-list: CldcJavaApiParityTest fails on a new entry and on a stale\n"
+                + "# one. Close a gap by adding the member to JavaAPI, then delete its line.\n";
+    }
+
+    private static TreeSet<String> readBaseline() throws IOException {
+        TreeSet<String> out = new TreeSet<String>();
+        if (!Files.exists(BASELINE)) {
+            return out;
+        }
+        for (String line : Files.readAllLines(BASELINE, StandardCharsets.UTF_8)) {
+            String t = line.trim();
+            if (t.length() > 0 && !t.startsWith("#")) {
+                out.add(t);
+            }
+        }
+        return out;
+    }
+
+    private static boolean atLeastAsVisible(Member javaApi, Member cldc) {
+        if ((javaApi.access & Opcodes.ACC_PUBLIC) != 0) {
+            return true;
+        }
+        return (cldc.access & Opcodes.ACC_PROTECTED) != 0 && (javaApi.access & Opcodes.ACC_PROTECTED) != 0;
+    }
+
+    /** Looks {@code key} up in {@code start}, its superclasses and its interfaces. */
+    private static Member find(Map<String, ClassShape> all, ClassShape start, String key, boolean isStatic) {
+        List<ClassShape> work = new ArrayList<ClassShape>();
+        work.add(start);
+        java.util.Set<String> seen = new java.util.HashSet<String>();
+        while (!work.isEmpty()) {
+            ClassShape c = work.remove(0);
+            if (!seen.add(c.name)) {
+                continue;
+            }
+            Member m = c.members.get(key);
+            // A static interface method is not inherited; anything else is.
+            if (m != null && (c == start || !(c.isInterface && m.isStatic()))) {
+                return m;
+            }
+            if (c.superName != null && all.containsKey(c.superName)) {
+                work.add(all.get(c.superName));
+            }
+            for (String i : c.interfaces) {
+                if (all.containsKey(i)) {
+                    work.add(all.get(i));
+                }
+            }
+        }
+        return null;
+    }
+
+    private static void compile(Path srcRoot, Path out) throws IOException {
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+        assertNotNull(javac, "the tests must run on a JDK, not a JRE");
+        List<String> args = new ArrayList<String>();
+        String spec = System.getProperty("java.specification.version");
+        if (spec.startsWith("1.")) {
+            args.addAll(Arrays.asList("-source", "1.8", "-target", "1.8"));
+        } else {
+            // No modules at release 8, so a source tree may declare java.lang.
+            args.addAll(Arrays.asList("--release", "8"));
+        }
+        args.addAll(Arrays.asList("-nowarn", "-encoding", "UTF-8", "-proc:none",
+                "-Xmaxerrs", "100000", "-d", out.toString()));
+        try (Stream<Path> files = Files.walk(srcRoot)) {
+            args.addAll(files.filter(p -> p.toString().endsWith(".java"))
+                    .map(Path::toString).sorted().collect(Collectors.toList()));
+        }
+        ByteArrayOutputStream err = new ByteArrayOutputStream();
+        int rc = javac.run(null, null, err, args.toArray(new String[0]));
+        assertEquals(0, rc, "compiling " + srcRoot + " failed:\n" + new String(err.toByteArray(), StandardCharsets.UTF_8));
+    }
+
+    private static Map<String, ClassShape> load(Path classesRoot) throws IOException {
+        Map<String, ClassShape> out = new HashMap<String, ClassShape>();
+        List<Path> files;
+        try (Stream<Path> s = Files.walk(classesRoot)) {
+            files = s.filter(p -> p.toString().endsWith(".class")).collect(Collectors.toList());
+        }
+        for (Path p : files) {
+            try (InputStream in = Files.newInputStream(p)) {
+                ClassShape shape = new ClassShape();
+                new ClassReader(in).accept(shape, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+                out.put(shape.name, shape);
+            }
+        }
+        // A nested class is visible only when it and every class around it is.
+        for (ClassShape c : out.values()) {
+            c.visible = c.ownVisible;
+            String outer = c.outerName;
+            while (c.visible && outer != null) {
+                ClassShape o = out.get(outer);
+                c.visible = o != null && o.ownVisible;
+                outer = o == null ? null : o.outerName;
+            }
+        }
+        return out;
+    }
+
+    private static final class Member {
+        final String key;
+        final int access;
+        final boolean constructor;
+
+        Member(String key, int access, boolean constructor) {
+            this.key = key;
+            this.access = access;
+            this.constructor = constructor;
+        }
+
+        boolean isStatic() {
+            return (access & Opcodes.ACC_STATIC) != 0;
+        }
+    }
+
+    private static final class ClassShape extends ClassVisitor {
+        String name;
+        String superName;
+        List<String> interfaces = Collections.emptyList();
+        boolean isInterface;
+        boolean ownVisible;
+        boolean visible;
+        String outerName;
+        final Map<String, Member> members = new LinkedHashMap<String, Member>();
+
+        ClassShape() {
+            super(Opcodes.ASM9);
+        }
+
+        @Override
+        public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+            this.name = name;
+            this.superName = superName;
+            this.interfaces = interfaces == null ? Collections.<String>emptyList() : Arrays.asList(interfaces);
+            this.isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
+            this.ownVisible = (access & Opcodes.ACC_PUBLIC) != 0;
+        }
+
+        @Override
+        public void visitInnerClass(String innerName, String outer, String simpleName, int access) {
+            // The InnerClasses entry for this class itself carries its real
+            // (source) access; the class-level flags of a nested class do not.
+            if (innerName.equals(name)) {
+                ownVisible = (access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) != 0;
+                outerName = outer;
+                if (outer == null) {
+                    // A local or anonymous class.
+                    ownVisible = false;
+                }
+            }
+        }
+
+        @Override
+        public FieldVisitor visitField(int access, String fname, String descriptor, String signature, Object value) {
+            if (exposed(access)) {
+                members.put(fname + ":" + descriptor, new Member(fname + ":" + descriptor, access, false));
+            }
+            return null;
+        }
+
+        @Override
+        public MethodVisitor visitMethod(int access, String mname, String descriptor, String signature, String[] exceptions) {
+            if (exposed(access) && (access & Opcodes.ACC_BRIDGE) == 0 && !"<clinit>".equals(mname)) {
+                members.put(mname + descriptor, new Member(mname + descriptor, access, "<init>".equals(mname)));
+            }
+            return null;
+        }
+
+        private static boolean exposed(int access) {
+            return (access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) != 0
+                    && (access & Opcodes.ACC_SYNTHETIC) == 0;
+        }
+    }
+}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/CleanTargetIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/CleanTargetIntegrationTest.java
index 359ac28ff9e..f81c1211912 100644
--- a/vm/tests/src/test/java/com/codename1/tools/translator/CleanTargetIntegrationTest.java
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/CleanTargetIntegrationTest.java
@@ -2016,12 +2016,16 @@ static String tailOf(String output) {
     }
 
     static String runCmakeBuild(Path buildDir, Path workingDir) throws Exception {
-        // The full desktop suite compiles more than 4,000 translation units. On
-        // Linux/musl, a healthy build can take over 20 minutes; it must not share
-        // the ten-minute deadline used to detect a hung test executable.
+        // The full desktop suite compiles more than 5,400 translation units now
+        // that it carries the Swing and JavaFX compatibility scenes. On a
+        // four-core Linux runner a healthy build takes close to 30 minutes, and
+        // one was stopped at 5,248 of 5,413 steps; it must not share the
+        // ten-minute deadline used to detect a hung test executable either.
+        // This is a guard against a hang, not a performance budget: the perf
+        // gate is what judges speed.
         ProcessBuilder builder = new ProcessBuilder("cmake", "--build", buildDir.toString());
         builder.directory(workingDir.toFile());
-        return runCommand(builder, 30, java.util.concurrent.TimeUnit.MINUTES);
+        return runCommand(builder, 45, java.util.concurrent.TimeUnit.MINUTES);
     }
 
     static String runCommand(List<String> command, Path workingDir) throws Exception {
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/CollectionSemanticsIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/CollectionSemanticsIntegrationTest.java
deleted file mode 100644
index 8096211a098..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/CollectionSemanticsIntegrationTest.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.api.Test;
-
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
-/** Compares collection API behavior with the host JDK, including native storage,
- * exposed subclass arrays, views, typed arrays and callback reentry. */
-class CollectionSemanticsIntegrationTest {
-
-    @Test
-    void collectionSemanticsMatchTheJvm() throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("collection-semantics-sources");
-        Path classesDir = Files.createTempDirectory("collection-semantics-classes");
-        Path javaApiDir = Files.createTempDirectory("collection-semantics-java-api");
-
-        Path source = sourceDir.resolve("CollectionSemanticsApp.java");
-        Files.write(source, loadAppSource().getBytes(StandardCharsets.UTF_8));
-
-        CompilerHelper.CompilerConfig config = selectCompiler();
-        if (config == null) {
-            fail("No compatible compiler available for the collection semantics integration test");
-        }
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        List<String> compileArgs = new ArrayList<>();
-        compileArgs.add("-source");
-        compileArgs.add(config.targetVersion);
-        compileArgs.add("-target");
-        compileArgs.add(config.targetVersion);
-        if (CompilerHelper.useClasspath(config)) {
-            compileArgs.add("-classpath");
-            compileArgs.add(javaApiDir.toString());
-        } else {
-            compileArgs.add("-bootclasspath");
-            compileArgs.add(javaApiDir.toString());
-            compileArgs.add("-Xlint:-options");
-        }
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.add(source.toString());
-
-        assertEquals(0, CompilerHelper.compile(config.jdkHome, compileArgs),
-                "CollectionSemanticsApp should compile against the JavaAPI");
-
-        // Both owners are legal for this Object method. Some compilers emit
-        // Collection.toString, as in the Windows ARM64 migration-test crash.
-        // Exercise that form on the JVM and translated runtime regardless of
-        // which javac compiled this fixture.
-        Path appClass = classesDir.resolve("CollectionSemanticsApp.class");
-        org.objectweb.asm.ClassWriter writer = new org.objectweb.asm.ClassWriter(0);
-        new org.objectweb.asm.ClassReader(Files.readAllBytes(appClass)).accept(
-                new org.objectweb.asm.ClassVisitor(org.objectweb.asm.Opcodes.ASM9, writer) {
-                    @Override
-                    public org.objectweb.asm.MethodVisitor visitMethod(int access, String name,
-                            String descriptor, String signature, String[] exceptions) {
-                        org.objectweb.asm.MethodVisitor method = super.visitMethod(access, name,
-                                descriptor, signature, exceptions);
-                        if (!"stringFromCollection".equals(name)) {
-                            return method;
-                        }
-                        return new org.objectweb.asm.MethodVisitor(org.objectweb.asm.Opcodes.ASM9, method) {
-                            @Override
-                            public void visitMethodInsn(int opcode, String owner, String called,
-                                    String desc, boolean isInterface) {
-                                if ("toString".equals(called)) {
-                                    super.visitMethodInsn(org.objectweb.asm.Opcodes.INVOKEINTERFACE,
-                                            "java/util/Collection", called, desc, true);
-                                } else {
-                                    super.visitMethodInsn(opcode, owner, called, desc, isInterface);
-                                }
-                            }
-                        };
-                    }
-                }, 0);
-        Files.write(appClass, writer.toByteArray());
-
-        Map<String, String> expected = parseCases(runJavaMain(config, classesDir, javaApiDir));
-        assertFalse(expected.isEmpty(), "JVM run should emit cases");
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        Path outputDir = Files.createTempDirectory("collection-semantics-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "CollectionSemanticsApp");
-
-        Path distDir = outputDir.resolve("dist");
-        String generated = new String(Files.readAllBytes(distDir.resolve(
-                "CollectionSemanticsApp-src/CollectionSemanticsApp.c")), StandardCharsets.UTF_8);
-        int walkStart = generated.indexOf("JAVA_VOID CollectionSemanticsApp_fieldTraversalCases__(");
-        assertTrue(walkStart >= 0);
-        int walkEnd = generated.indexOf("\nJAVA_VOID CollectionSemanticsApp_main", walkStart);
-        assertTrue(walkEnd > walkStart);
-        String walk = generated.substring(walkStart, walkEnd);
-        assertTrue(walk.contains("cn1RefBlockGet"), "field and call-result loops use native cursors");
-        assertFalse(walk.contains("java_util_HashMap"), "List receivers cannot use map-view layouts");
-        assertFalse(walk.contains("java_util_HashSet"), "List receivers cannot use set layouts");
-        assertFalse(walk.contains("java_util_IdentityHashMap"), "List receivers cannot use identity-map layouts");
-        int directStart = generated.indexOf("JAVA_VOID CollectionSemanticsApp_directCallCases__(");
-        int directEnd = generated.indexOf("\nJAVA_VOID CollectionSemanticsApp_fieldTraversalCases__", directStart);
-        assertTrue(directStart >= 0 && directEnd > directStart);
-        String direct = generated.substring(directStart, directEnd);
-        assertTrue(direct.contains("cn1InlListGet"), direct);
-        assertTrue(direct.contains("__cn1DirectReceiver"), direct);
-        assertTrue(direct.contains("cn1ThrowNullPointerOrDie"), direct);
-        assertTrue(direct.contains("virtual_java_util_List_get___int_R_java_lang_Object"),
-                "mixed receivers must retain dispatch");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "CollectionSemanticsApp-src");
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        Path executable = buildDir.resolve("CollectionSemanticsApp");
-        String parparOutput = CleanTargetIntegrationTest.runCommand(
-                Arrays.asList(executable.toString()), buildDir);
-        assertTrue(parparOutput.contains("DONE"),
-                "ParparVM run should complete. Output: " + parparOutput);
-
-        Map<String, String> actual = parseCases(parparOutput);
-        assertEquals(expected.keySet(), actual.keySet(), "ParparVM should emit the same cases");
-
-        List<String> differences = new ArrayList<>();
-        for (Map.Entry<String, String> entry : expected.entrySet()) {
-            if (!entry.getValue().equals(actual.get(entry.getKey()))) {
-                differences.add(entry.getKey()
-                        + "\n    jvm     : " + entry.getValue()
-                        + "\n    parparvm: " + actual.get(entry.getKey()));
-            }
-        }
-        assertTrue(differences.isEmpty(),
-                "Collection semantics diverged from the JVM:\n" + String.join("\n", differences));
-
-        // Named explicitly so a regression points at the change rather than at a
-        // generic diff.
-        assertEquals("0", actual.get("empty.size"), "a list never added to must be empty");
-        assertEquals("IndexOutOfBounds", actual.get("empty.get0"),
-                "get(0) on an empty list must still throw");
-        assertEquals("1", actual.get("ihm.keyNulls"),
-                "the key iterator must hand back the null key as null, not the table's sentinel");
-        assertEquals("1", actual.get("ihm.valNulls"),
-                "the value iterator must hand back a null value as null");
-        assertEquals("500", actual.get("ihm.bigSeen"),
-                "key iteration must survive a rehash");
-    }
-
-    private Map<String, String> parseCases(String output) {
-        Map<String, String> cases = new LinkedHashMap<>();
-        for (String line : output.split("\\R")) {
-            if (!line.startsWith("CASE|")) {
-                continue;
-            }
-            String body = line.substring("CASE|".length());
-            int separator = body.indexOf('|');
-            assertTrue(separator > 0, "Malformed case line: " + line);
-            cases.put(body.substring(0, separator), body.substring(separator + 1));
-        }
-        return cases;
-    }
-
-    private String loadAppSource() throws Exception {
-        java.io.InputStream in = CollectionSemanticsIntegrationTest.class
-                .getResourceAsStream("/com/codename1/tools/translator/CollectionSemanticsApp.java");
-        assertNotNull(in, "CollectionSemanticsApp.java test resource should exist");
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
-            return reader.lines().collect(Collectors.joining("\n")) + "\n";
-        }
-    }
-
-    private String runJavaMain(CompilerHelper.CompilerConfig config, Path classesDir, Path javaApiDir)
-            throws Exception {
-        String javaExe = config.jdkHome.resolve("bin").resolve(CompilerHelper.executableName("java")).toString();
-        ProcessBuilder pb = new ProcessBuilder(
-                javaExe,
-                "-cp",
-                classesDir + System.getProperty("path.separator") + javaApiDir,
-                "CollectionSemanticsApp"
-        );
-        pb.redirectErrorStream(true);
-
-        Process process = pb.start();
-        String output;
-        try (BufferedReader reader = new BufferedReader(
-                new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
-            output = reader.lines().collect(Collectors.joining("\n"));
-        }
-        assertEquals(0, process.waitFor(), "JVM run should exit cleanly. Output: " + output);
-        return output;
-    }
-
-    private CompilerHelper.CompilerConfig selectCompiler() {
-        String[] preferredTargets = {"11", "17", "21", "25", "1.8"};
-        for (String target : preferredTargets) {
-            List<CompilerHelper.CompilerConfig> configs = CompilerHelper.getAvailableCompilers(target);
-            for (CompilerHelper.CompilerConfig config : configs) {
-                if (CompilerHelper.isJavaApiCompatible(config)) {
-                    return config;
-                }
-            }
-        }
-        return null;
-    }
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/CompilerHelper.java b/vm/tests/src/test/java/com/codename1/tools/translator/CompilerHelper.java
index 995b00c5c43..eae9460cb43 100644
--- a/vm/tests/src/test/java/com/codename1/tools/translator/CompilerHelper.java
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/CompilerHelper.java
@@ -395,12 +395,32 @@ public static int compile(Path jdkHome, List<String> args) throws IOException, I
             command.add("UTF-8");
         }
 
-        command.addAll(args);
+        // Everything else goes through an @argfile. The JavaAPI compile names
+        // every source of the class library, and that command line outgrew
+        // Windows' 32K limit (CreateProcess error=206) once java.* gained the
+        // classes a desktop application needs. javac reads argfiles on JDK 8
+        // too; each argument is quoted, with backslashes and quotes escaped,
+        // so Windows paths and spaces survive.
+        Path argFile = Files.createTempFile("cn1-javac", ".args");
+        StringBuilder argText = new StringBuilder();
+        for (String arg : args) {
+            argText.append('"')
+                    .append(arg.replace("\\", "\\\\").replace("\"", "\\\""))
+                    .append("\"\n");
+        }
+        Files.write(argFile, argText.toString().getBytes(StandardCharsets.UTF_8));
+        command.add("@" + argFile.toAbsolutePath());
 
         ProcessBuilder pb = new ProcessBuilder(command);
         // Inherit IO so we see errors in the log
         pb.redirectErrorStream(true);
-        Process p = pb.start();
+        Process p;
+        try {
+            p = pb.start();
+        } catch (IOException e) {
+            Files.deleteIfExists(argFile);
+            throw e;
+        }
         lastErrorLog = "";
         try (InputStream is = p.getInputStream();
              ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
@@ -413,7 +433,11 @@ public static int compile(Path jdkHome, List<String> args) throws IOException, I
 
             lastErrorLog = buffer.toString("UTF-8");
         }
-        return p.waitFor();
+        try {
+            return p.waitFor();
+        } finally {
+            Files.deleteIfExists(argFile);
+        }
     }
 
     public static String getLastErrorLog() {
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/ExecutorIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/ExecutorIntegrationTest.java
deleted file mode 100644
index 72ca7f38c6e..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/ExecutorIntegrationTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package com.codename1.tools.translator;
-
-import java.io.IOException;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.Disabled;
-import static org.junit.jupiter.api.Assertions.*;
-
-@Disabled // Fails with SEGV in minimal harness; requires full VM or better stubs
-public class ExecutorIntegrationTest {
-
-    @Test
-    public void testExecutorService() throws Exception {
-        String code = "package test;\n" +
-            "import java.util.concurrent.*;\n" +
-            "import java.util.*;\n" +
-            "public class Main {\n" +
-            "    private static native void print(String s);\n" +
-            "    static class DirectExecutorService extends AbstractExecutorService {\n" +
-            "        private boolean shutdown;\n" +
-            "        public void execute(Runnable command) {\n" +
-            "            if (shutdown) throw new RejectedExecutionException();\n" +
-            "            command.run();\n" +
-            "        }\n" +
-            "        public void shutdown() { shutdown = true; }\n" +
-            "        public List<Runnable> shutdownNow() { shutdown = true; return new ArrayList<Runnable>(); }\n" +
-            "        public boolean isShutdown() { return shutdown; }\n" +
-            "        public boolean isTerminated() { return shutdown; }\n" +
-            "        public boolean awaitTermination(long timeout, TimeUnit unit) { return true; }\n" +
-            "    }\n" +
-            "    public static void main(String[] args) throws Exception {\n" +
-            "        ExecutorService executor = new DirectExecutorService();\n" +
-            "        Future<String> f1 = executor.submit(new Callable<String>() {\n" +
-            "            public String call() throws Exception {\n" +
-            "                return \"Hello\";\n" +
-            "            }\n" +
-            "        });\n" +
-            "        Future<String> f2 = executor.submit(new Callable<String>() {\n" +
-            "            public String call() throws Exception {\n" +
-            "                return \"World\";\n" +
-            "            }\n" +
-            "        });\n" +
-            "        print(f1.get() + \" \" + f2.get());\n" +
-            "        executor.shutdown();\n" +
-            "    }\n" +
-            "}";
-
-        assertTrue(CompilerHelper.compileAndRun(code, "Hello World"));
-    }
-
-    @Test
-    public void testSingleThreadExecutor() throws Exception {
-        String code = "package test;\n" +
-            "import java.util.concurrent.*;\n" +
-            "import java.util.concurrent.atomic.AtomicInteger;\n" +
-            "import java.util.*;\n" +
-            "public class Main {\n" +
-            "    private static native void print(String s);\n" +
-            "    static class DirectExecutorService extends AbstractExecutorService {\n" +
-            "        private boolean shutdown;\n" +
-            "        public void execute(Runnable command) {\n" +
-            "            if (shutdown) throw new RejectedExecutionException();\n" +
-            "            command.run();\n" +
-            "        }\n" +
-            "        public void shutdown() { shutdown = true; }\n" +
-            "        public List<Runnable> shutdownNow() { shutdown = true; return new ArrayList<Runnable>(); }\n" +
-            "        public boolean isShutdown() { return shutdown; }\n" +
-            "        public boolean isTerminated() { return shutdown; }\n" +
-            "        public boolean awaitTermination(long timeout, TimeUnit unit) { return true; }\n" +
-            "    }\n" +
-            "    public static void main(String[] args) throws Exception {\n" +
-            "        ExecutorService executor = new DirectExecutorService();\n" +
-            "        final AtomicInteger counter = new AtomicInteger(0);\n" +
-            "        Runnable task = new Runnable() {\n" +
-            "            public void run() {\n" +
-            "                counter.set(counter.get() + 1);\n" +
-            "            }\n" +
-            "        };\n" +
-            "        Future<?> f1 = executor.submit(task);\n" +
-            "        Future<?> f2 = executor.submit(task);\n" +
-            "        f1.get();\n" +
-            "        f2.get();\n" +
-            "        print(String.valueOf(counter.get()));\n" +
-            "        executor.shutdown();\n" +
-            "    }\n" +
-            "}";
-
-        assertTrue(CompilerHelper.compileAndRun(code, "2"));
-    }
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/FileClassIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/FileClassIntegrationTest.java
deleted file mode 100644
index 18f946b6ea8..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/FileClassIntegrationTest.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.params.ParameterizedTest;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-public class FileClassIntegrationTest {
-
-    @ParameterizedTest
-    @org.junit.jupiter.params.provider.MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
-    public void testFileClassMethods(CompilerHelper.CompilerConfig config) throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("file-test-sources");
-        Path classesDir = Files.createTempDirectory("file-test-classes");
-        Path javaFile = sourceDir.resolve("FileTestApp.java");
-
-        Files.write(javaFile, fileTestAppSource().getBytes(StandardCharsets.UTF_8));
-
-        Path javaApiDir = Files.createTempDirectory("java-api-classes");
-
-        List<String> compileArgs = new ArrayList<>();
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        if (CompilerHelper.useClasspath(config)) {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-classpath");
-             compileArgs.add(javaApiDir.toString());
-        } else {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-bootclasspath");
-             compileArgs.add(javaApiDir.toString());
-             compileArgs.add("-Xlint:-options");
-        }
-
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.add(javaFile.toString());
-
-        int compileResult = CompilerHelper.compile(config.jdkHome, compileArgs);
-        assertEquals(0, compileResult, "FileTestApp.java compilation failed with " + config);
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        Path outputDir = Files.createTempDirectory("file-test-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "FileTestApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
-
-        Path srcRoot = distDir.resolve("FileTestApp-src");
-        // The SHARED helper, not a private copy. The copy that used to live at the
-        // bottom of this file matched the add_library line by its full argument list,
-        // so the moment the generator gained an assembly glob it silently stopped
-        // matching -- and this test built a library, then failed to run an executable
-        // that was never asked for.
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(
-                cmakeLists, srcRoot.getFileName().toString());
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        Path executable = buildDir.resolve("FileTestApp");
-        // Running the app. If it exits with 0, logic passed.
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(executable.toString()), buildDir);
-    }
-
-    private String fileTestAppSource() {
-        return "import java.io.File;\n" +
-               "public class FileTestApp {\n" +
-               "    public static void main(String[] args) {\n" +
-               "        try {\n" +
-               "            // Construct string manually to avoid constant pool issues in test env\n" +
-               "            char[] pathChars = new char[]{'t','e','s','t','f','i','l','e','.','t','x','t'};\n" +
-               "            String path = new String(pathChars);\n" +
-               "            File f = new File(path);\n" +
-               "            if (f.exists()) {\n" +
-               "                f.delete();\n" +
-               "            }\n" +
-               "            boolean created = f.createNewFile();\n" +
-               "            if (!created) throw new RuntimeException(\"Create failed\");\n" +
-               "            if (!f.exists()) throw new RuntimeException(\"Exists failed\");\n" +
-               "            if (f.isDirectory()) throw new RuntimeException(\"IsDirectory failed\");\n" +
-               "            if (!f.delete()) throw new RuntimeException(\"Delete failed\");\n" +
-               "            if (f.exists()) throw new RuntimeException(\"Delete verification failed\");\n" +
-               // File.list(): nothing exercised it before, so the native listing --
-               // rewritten from a racy count-then-refill pair into one enumeration --
-               // was compiled but never RUN by this suite.
-               "            char[] dirChars = new char[]{'l','s','d','i','r'};\n" +
-               "            File dir = new File(new String(dirChars));\n" +
-               "            dir.mkdir();\n" +
-               "            char[] aChars = new char[]{'l','s','d','i','r','/','a'};\n" +
-               "            char[] bChars = new char[]{'l','s','d','i','r','/','b'};\n" +
-               "            File fa = new File(new String(aChars));\n" +
-               "            File fb = new File(new String(bChars));\n" +
-               "            fa.createNewFile();\n" +
-               "            fb.createNewFile();\n" +
-               "            String[] names = dir.list();\n" +
-               "            if (names == null) throw new RuntimeException(\"list returned null\");\n" +
-               "            if (names.length != 2) throw new RuntimeException(\"list length\");\n" +
-               // A trailing null is what the old two-pass version produced when the
-               // second walk saw fewer entries than the first.
-               "            if (names[0] == null || names[1] == null) throw new RuntimeException(\"null entry\");\n" +
-               // The result must be a String[], not a String: allocArray installs the
-               // class it is handed as the ARRAY's own class.
-               "            Object asObject = names;\n" +
-               "            if (!(asObject instanceof String[])) throw new RuntimeException(\"not a String[]\");\n" +
-               "            boolean sawA = false; boolean sawB = false;\n" +
-               "            for (int i = 0; i < names.length; i++) {\n" +
-               "                if (names[i].equals(new String(new char[]{'a'}))) sawA = true;\n" +
-               "                if (names[i].equals(new String(new char[]{'b'}))) sawB = true;\n" +
-               "            }\n" +
-               "            if (!sawA || !sawB) throw new RuntimeException(\"missing entry\");\n" +
-               "            fa.delete(); fb.delete(); dir.delete();\n" +
-               // A REGRESSION GUARD, not a proof of atomicity -- stated plainly
-               // because the difference is easy to misread. This checks the
-               // uncontended path: createNewFile on an existing file returns false
-               // and leaves it intact. The check-then-act version it replaced passes
-               // this too, since access() succeeds and it returns before ever
-               // reaching the fopen that would truncate. Verified by running it
-               // against the old code: 5/5 green.
-               //
-               // The actual defect needs a file to appear BETWEEN the check and the
-               // open, which one thread cannot produce, so no single-threaded test
-               // can demonstrate it. The correctness argument is structural instead:
-               // one O_EXCL syscall where there were two operations, with the kernel
-               // deciding who wins. What this guards is that the rewrite did not
-               // break the ordinary path.
-               "            char[] exChars = new char[]{'e','x','c','l','.','t','x','t'};\n" +
-               "            File ex = new File(new String(exChars));\n" +
-               "            if (ex.exists()) ex.delete();\n" +
-               "            if (!ex.createNewFile()) throw new RuntimeException(\"first create\");\n" +
-               "            java.io.FileOutputStream os = new java.io.FileOutputStream(ex);\n" +
-               "            os.write(new byte[]{1,2,3,4});\n" +
-               "            os.close();\n" +
-               "            if (ex.createNewFile()) throw new RuntimeException(\"second create returned true\");\n" +
-               "            if (ex.length() != 4) throw new RuntimeException(\"existing file was truncated\");\n" +
-               "            ex.delete();\n" +
-               // renameTo was never exercised, which is how an implementation that
-               // renamed the destination onto itself survived. Content is checked
-               // too: the aliased version reported success while moving nothing.
-               "            char[] rnChars = new char[]{'r','n','-','s','r','c'};\n" +
-               "            char[] rdChars = new char[]{'r','n','-','d','s','t','-','l','o','n','g','e','r'};\n" +
-               "            File rsrc = new File(new String(rnChars));\n" +
-               "            File rdst = new File(new String(rdChars));\n" +
-               "            if (rsrc.exists()) rsrc.delete();\n" +
-               "            if (rdst.exists()) rdst.delete();\n" +
-               "            rsrc.createNewFile();\n" +
-               "            java.io.FileOutputStream ros = new java.io.FileOutputStream(rsrc);\n" +
-               "            ros.write(new byte[]{7,7,7});\n" +
-               "            ros.close();\n" +
-               "            if (!rsrc.renameTo(rdst)) throw new RuntimeException(\"rename returned false\");\n" +
-               "            if (rsrc.exists()) throw new RuntimeException(\"source still present\");\n" +
-               "            if (!rdst.exists()) throw new RuntimeException(\"destination missing\");\n" +
-               "            if (rdst.length() != 3) throw new RuntimeException(\"content not moved\");\n" +
-               "            rdst.delete();\n" +
-               "        } catch (Exception e) {\n" +
-               "            // e.printStackTrace(); // Can't print stack trace without constants\n" +
-               "            System.exit(1);\n" +
-               "        }\n" +
-               "    }\n" +
-               "}";
-    }
-
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/FrameRetireEscapeTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/FrameRetireEscapeTest.java
new file mode 100644
index 00000000000..36d6131faf4
--- /dev/null
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/FrameRetireEscapeTest.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.tools.translator;
+
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import javax.tools.ToolProvider;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+/// Frame-exit retirement stamps an object dead when the frame that allocated it
+/// returns, on the strength of a proof that no reference to it left the frame. The
+/// proof allows the object as the RECEIVER of a call only if the method that call
+/// runs keeps `this` to itself, and these are the callees it used to wave through
+/// without reading: a native, an override reached through a supertype, and a
+/// callee's own callee.
+///
+/// The first one shipped. `Thread t = new Thread(r); t.start();` retired a running
+/// thread's Thread object, the collector swept it, its finalizer released the
+/// thread's native record, and the next root scan of that thread read unmapped
+/// memory.
+class FrameRetireEscapeTest {
+    private static final String SOURCE = "class Retire {"
+            + "static Object sink;"
+            // Stands in for java.lang.Thread: start() is native and publishes `this`.
+            + "static class Starter { int n; native void start(); void set(int v){ n = v; } }"
+            + "static class Base { void run(){} }"
+            + "static class Leaky extends Base { void run(){ sink = this; } }"
+            + "static abstract class Task { abstract void go(); }"
+            + "static class LeakyTask extends Task { void go(){ sink = this; } }"
+            + "static class Chain { int n;"
+            + "  void begin(){ register(); } void register(){ sink = this; }"
+            + "  void count(){ bump(); } void bump(){ n++; } }"
+            // The control: nothing leaves the frame, so the site must stay retirable.
+            + "static int local(){ Starter s = new Starter(); s.set(3); return s.n; }"
+            + "static int localChain(){ Chain c = new Chain(); c.count(); return c.n; }"
+            + "static void started(){ Starter s = new Starter(); s.start(); }"
+            + "static void overridden(){ Base b = new Leaky(); b.run(); }"
+            + "static void implemented(){ Task t = new LeakyTask(); t.go(); }"
+            + "static void transitive(){ Chain c = new Chain(); c.begin(); }"
+            + "}";
+
+    @BeforeEach
+    @AfterEach
+    void reset() {
+        Parser.cleanup();
+    }
+
+    @Test
+    void receiverCallsAreJudgedByTheMethodThatRuns() throws Exception {
+        Path dir = Files.createTempDirectory("frame-retire");
+        Path source = dir.resolve("Retire.java");
+        Files.write(source, SOURCE.getBytes(StandardCharsets.UTF_8));
+        assertEquals(0, ToolProvider.getSystemJavaCompiler().run(null, null, null,
+                "-source", "8", "-target", "8", "-d", dir.toString(), source.toString()));
+        // Every constructor chain ends in Object.<init>, which the proof follows, so
+        // the closed world needs an Object. The running JDK's is as good as any.
+        Path objectClass = dir.resolve("Object.class");
+        try (InputStream in = Object.class.getResourceAsStream("Object.class")) {
+            assertNotNull(in, "the JDK must expose java/lang/Object.class");
+            Files.copy(in, objectClass);
+        }
+        Parser.parse(objectClass.toFile());
+        for (String name : new String[]{"Retire", "Retire$Starter", "Retire$Base",
+                "Retire$Leaky", "Retire$Task", "Retire$LeakyTask", "Retire$Chain"}) {
+            Parser.parse(dir.resolve(name + ".class").toFile());
+        }
+
+        // Non-vacuity first: an analysis that refuses everything passes every
+        // assertion below it.
+        assertTrue(retires("local"), "an object used only inside its frame is retirable");
+        assertTrue(retires("localChain"),
+                "a callee whose own callees keep `this` does not disqualify the site");
+
+        assertFalse(retires("started"),
+                "a native receiver call has no body to check: Thread.start() publishes `this`");
+        assertFalse(retires("overridden"),
+                "the override runs, not the superclass method the call site names");
+        assertFalse(retires("implemented"),
+                "an abstract method has no body; the implementation is what runs");
+        assertFalse(retires("transitive"),
+                "a callee that calls another method on `this` is only as safe as that one");
+    }
+
+    private static boolean retires(String methodName) {
+        for (ByteCodeClass c : Parser.getClasses()) {
+            if (!"Retire".equals(c.getClsName())) {
+                continue;
+            }
+            for (BytecodeMethod m : c.getMethods()) {
+                if (m.getMethodName().equals(methodName)) {
+                    m.collectRetireCandidates();
+                    m.analyzeRetirableLocals();
+                    return m.frameRetireScopeDecl().length() > 0;
+                }
+            }
+        }
+        throw new AssertionError("no method " + methodName);
+    }
+}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/HostLocksIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/HostLocksIntegrationTest.java
new file mode 100644
index 00000000000..5810fdb8174
--- /dev/null
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/HostLocksIntegrationTest.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.tools.translator;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/// The PosixJdkHost, File and lock programs, built ONCE per compiler
+/// configuration instead of once per program per configuration.
+///
+/// They used to be five tests over the same compiler matrix, each paying for its
+/// own JavaAPI compile, translation and native build. The program lives in
+/// `src/test/resources/com/codename1/tools/translator/hostlocks`; `HostLocksApp`
+/// says which parts run and why the lock programs are only built. What each old
+/// test asserted is still asserted:
+///
+/// - the program compiles with the configuration's compiler and target,
+/// - the translator emits a CMake project and it builds,
+/// - the run exits 0 (`FileTestApp` exits 1 on any failure; `runCommand` fails
+///   on a non-zero exit), and
+/// - it prints `POSIX-HOST-OK`, which `PosixHostApp` prints only after checking
+///   the JdkHost defaults and then the installed PosixJdkHost.
+public class HostLocksIntegrationTest {
+
+    private static final String DIR = "/com/codename1/tools/translator/hostlocks";
+
+    @ParameterizedTest
+    @MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
+    void hostFileAndLockProgramsBuildAndRun(CompilerHelper.CompilerConfig config) throws Exception {
+        Parser.cleanup();
+
+        URL url = HostLocksIntegrationTest.class.getResource(DIR + "/HostLocksApp.java");
+        assertNotNull(url, "hostlocks program resources should be on the test class path");
+        Path programDir = Paths.get(url.toURI()).getParent();
+
+        Path work = Files.createTempDirectory("hostlocks");
+        Path classesDir = Files.createDirectories(work.resolve("classes"));
+        Path javaApiDir = Files.createDirectories(work.resolve("javaapi"));
+
+        assertTrue(CompilerHelper.isJavaApiCompatible(config),
+                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
+        CompilerHelper.compileJavaAPI(javaApiDir, config);
+
+        List<String> compileArgs = new ArrayList<>();
+        compileArgs.add("-source");
+        compileArgs.add(config.targetVersion);
+        compileArgs.add("-target");
+        compileArgs.add(config.targetVersion);
+        if (CompilerHelper.useClasspath(config)) {
+            compileArgs.add("-classpath");
+            compileArgs.add(javaApiDir.toString());
+        } else {
+            compileArgs.add("-bootclasspath");
+            compileArgs.add(javaApiDir.toString());
+            compileArgs.add("-Xlint:-options");
+        }
+        compileArgs.add("-d");
+        compileArgs.add(classesDir.toString());
+        try (Stream<Path> files = Files.list(programDir)) {
+            compileArgs.addAll(files.filter(f -> f.toString().endsWith(".java"))
+                    .map(Path::toString).sorted().collect(Collectors.toList()));
+        }
+        assertEquals(0, CompilerHelper.compile(config.jdkHome, compileArgs),
+                "the hostlocks program should compile with " + config);
+
+        CompilerHelper.copyDirectory(javaApiDir, classesDir);
+        Files.copy(programDir.resolve("native_report.c"), classesDir.resolve("native_report.c"));
+
+        Path outputDir = Files.createDirectories(work.resolve("output"));
+        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "HostLocksApp");
+
+        Path distDir = outputDir.resolve("dist");
+        Path cmakeLists = distDir.resolve("CMakeLists.txt");
+        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
+        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "HostLocksApp-src");
+
+        Path buildDir = Files.createDirectories(distDir.resolve("build"));
+        List<String> configure = new ArrayList<>(Arrays.asList(
+                "cmake", "-S", distDir.toString(), "-B", buildDir.toString(),
+                "-DCMAKE_BUILD_TYPE=Release"));
+        configure.addAll(CompilerHelper.cmakeToolchainArgs());
+        CleanTargetIntegrationTest.runCommand(configure, distDir);
+        CleanTargetIntegrationTest.runCmakeBuild(buildDir, distDir);
+
+        Path executable = buildDir.resolve(CompilerHelper.executableName("HostLocksApp"));
+        String output = CleanTargetIntegrationTest.runCommand(Arrays.asList(executable.toString()), buildDir);
+        assertTrue(output.contains("POSIX-HOST-OK"), "PosixJdkHost fixture failed, output was:\n" + output);
+    }
+}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/JavascriptRuntimeSemanticsTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/JavascriptRuntimeSemanticsTest.java
index ac1eefd3447..d0959f7d9d9 100644
--- a/vm/tests/src/test/java/com/codename1/tools/translator/JavascriptRuntimeSemanticsTest.java
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/JavascriptRuntimeSemanticsTest.java
@@ -252,6 +252,21 @@ void latin1StringsAndUtf8BytesKeepJavaSemantics(CompilerHelper.CompilerConfig co
         assertTrue(result.errorMessage == null || result.errorMessage.isEmpty(), "Worker should not emit an error message");
     }
 
+    @ParameterizedTest
+    @org.junit.jupiter.params.provider.MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
+    void langMembersKeepJavaSemantics(CompilerHelper.CompilerConfig config) throws Exception {
+        // The String, wrapper, Character, Math, Objects, Locale and Charset members
+        // JavaAPI provides, in the browser runtime. One bit per
+        // property; BulkConformanceIntegrationTest (LangMembersChecks) holds the same members to HotSpot
+        // on the native target.
+        WorkerRunResult result = translateAndRunFixture(config, "JsLangMembersApp.java", "JsLangMembersApp");
+
+        assertEquals(0x3fffffff, result.result,
+                "java.lang and java.util members must keep Java semantics. raw="
+                        + result.rawMessage + " err=" + result.errorMessage);
+        assertTrue(result.errorMessage == null || result.errorMessage.isEmpty(), "Worker should not emit an error message");
+    }
+
     @ParameterizedTest
     @org.junit.jupiter.params.provider.MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
     void executesLocaleTimeZoneAndDateFormatInWorkerRuntime(CompilerHelper.CompilerConfig config) throws Exception {
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/LockIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/LockIntegrationTest.java
deleted file mode 100644
index 8482a3ab2a7..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/LockIntegrationTest.java
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.params.ParameterizedTest;
-
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Stream;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class LockIntegrationTest {
-
-    @ParameterizedTest
-    @org.junit.jupiter.params.provider.MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
-    void verifiesLockAndReentrantLockBehavior(CompilerHelper.CompilerConfig config) throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("lock-integration-sources");
-        Path classesDir = Files.createTempDirectory("lock-integration-classes");
-        Path javaApiDir = Files.createTempDirectory("java-api-classes");
-
-        // 1. Write Test App
-        Files.write(sourceDir.resolve("LockTestApp.java"), lockTestAppSource().getBytes(StandardCharsets.UTF_8));
-
-        // 2. Compile Test App against JavaAPI
-        List<String> sources = new ArrayList<>();
-        try (Stream<Path> paths = Files.walk(sourceDir)) {
-            paths.filter(p -> p.toString().endsWith(".java")).forEach(p -> sources.add(p.toString()));
-        }
-
-        List<String> compileArgs = new ArrayList<>();
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        if (CompilerHelper.useClasspath(config)) {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-classpath");
-             compileArgs.add(javaApiDir.toString());
-        } else {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-bootclasspath");
-             compileArgs.add(javaApiDir.toString());
-             compileArgs.add("-Xlint:-options");
-        }
-
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.addAll(sources);
-
-        int compileResult = CompilerHelper.compile(config.jdkHome, compileArgs);
-        assertEquals(0, compileResult, "Compilation failed");
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        // 3. Native Report Stub
-        Path nativeReport = sourceDir.resolve("native_report.c");
-        Files.write(nativeReport, nativeReportSource().getBytes(StandardCharsets.UTF_8));
-        Files.copy(nativeReport, classesDir.resolve("native_report.c"));
-
-        // 4. Run Translator
-        Path outputDir = Files.createTempDirectory("lock-integration-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "LockTestApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists));
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        // TODO: Execution still skipped because the generated executable SIGSEGVs on Linux runners.
-        // Track and fix the underlying runtime stub issues before enabling.
-
-        // Verify output assertions
-        // assertTrue(output.contains("TEST: Basic Lock OK"), "Basic lock should work");
-        // assertTrue(output.contains("TEST: Reentrancy OK"), "Reentrant lock should work");
-        // assertTrue(output.contains("TEST: TryLock OK"), "TryLock should work");
-        // assertTrue(output.contains("TEST: Condition OK"), "Condition wait/signal should work");
-    }
-
-    private String lockTestAppSource() {
-        return "import java.util.concurrent.locks.*;\n" +
-                "import java.util.concurrent.TimeUnit;\n" +
-                "public class LockTestApp {\n" +
-                "    private static native void report(String msg);\n" +
-                "    \n" +
-                "    public static void main(String[] args) {\n" +
-                "        testBasicLock();\n" +
-                "        testReentrancy();\n" +
-                "        testTryLock();\n" +
-                "        testCondition();\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testBasicLock() {\n" +
-                "        ReentrantLock lock = new ReentrantLock();\n" +
-                "        lock.lock();\n" +
-                "        try {\n" +
-                "             report(\"TEST: Basic Lock OK\");\n" +
-                "        } finally {\n" +
-                "            lock.unlock();\n" +
-                "        }\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testReentrancy() {\n" +
-                "        ReentrantLock lock = new ReentrantLock();\n" +
-                "        lock.lock();\n" +
-                "        try {\n" +
-                "            lock.lock();\n" +
-                "            try {\n" +
-                "                if (lock.getHoldCount() == 2) {\n" +
-                "                    report(\"TEST: Reentrancy OK\");\n" +
-                "                }\n" +
-                "            } finally {\n" +
-                "                lock.unlock();\n" +
-                "            }\n" +
-                "        } finally {\n" +
-                "            lock.unlock();\n" +
-                "        }\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testTryLock() {\n" +
-                "        ReentrantLock lock = new ReentrantLock();\n" +
-                "        if (lock.tryLock()) {\n" +
-                "            try {\n" +
-                "                report(\"TEST: TryLock OK\");\n" +
-                "            } finally {\n" +
-                "                lock.unlock();\n" +
-                "            }\n" +
-                "        } else {\n" +
-                "            report(\"TEST: TryLock FAILED\");\n" +
-                "        }\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testCondition() {\n" +
-                "        final ReentrantLock lock = new ReentrantLock();\n" +
-                "        final Condition cond = lock.newCondition();\n" +
-                "        final boolean[] signalled = new boolean[1];\n" +
-                "        \n" +
-                "        Thread t = new Thread(new Runnable() {\n" +
-                "            public void run() {\n" +
-                "                lock.lock();\n" +
-                "                try {\n" +
-                "                    signalled[0] = true;\n" +
-                "                    cond.signal();\n" +
-                "                } finally {\n" +
-                "                    lock.unlock();\n" +
-                "                }\n" +
-                "            }\n" +
-                "        });\n" +
-                "        \n" +
-                "        lock.lock();\n" +
-                "        try {\n" +
-                "            t.start();\n" +
-                "            cond.await();\n" +
-                "            if (signalled[0]) {\n" +
-                "                report(\"TEST: Condition OK\");\n" +
-                "            }\n" +
-                "        } catch (InterruptedException e) {\n" +
-                "            report(\"TEST: Condition INTERRUPTED\");\n" +
-                "        } finally {\n" +
-                "            lock.unlock();\n" +
-                "        }\n" +
-                "    }\n" +
-                "}\n";
-    }
-
-    private String nativeReportSource() {
-        // Through the runtime's own conversion, not a hand-copied String struct: the
-        // layout is the VM's to change, and a fixture that mirrors it stops compiling
-        // (no offset field, no array ->data) and fails every case before it runs.
-        return "#include \"cn1_globals.h\"\n" +
-                "#include <stdio.h>\n" +
-                "void LockTestApp_report___java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {\n" +
-                "    if (msg != JAVA_NULL) {\n" +
-                "        printf(\"%s\\n\", stringToUTF8(threadStateData, msg));\n" +
-                "        fflush(stdout);\n" +
-                "    }\n" +
-                "}\n";
-    }
-
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/NativeSignatureVerifierTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/NativeSignatureVerifierTest.java
index 26525d15061..61292e54a3e 100644
--- a/vm/tests/src/test/java/com/codename1/tools/translator/NativeSignatureVerifierTest.java
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/NativeSignatureVerifierTest.java
@@ -476,7 +476,7 @@ void thePropertyIsReadWhenSet() {
      * check runs -- on the clean target {@code java_io_File.m} is conditional on a
      * header {@code writeOutput} generates -- so the index has to read those off
      * the classpath. Missing this reported all 23 {@code java.io.File} natives as
-     * unimplemented and failed FileClassIntegrationTest.
+     * unimplemented and failed FileClassIntegrationTest (now HostLocksIntegrationTest).
      */
     @Test
     void theTranslatorsOwnRuntimeCIsIndexedEvenBeforeItIsCopiedOut() throws IOException {
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/ReadWriteLockIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/ReadWriteLockIntegrationTest.java
deleted file mode 100644
index a4f84a672b0..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/ReadWriteLockIntegrationTest.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.params.ParameterizedTest;
-
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Stream;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class ReadWriteLockIntegrationTest {
-
-    @ParameterizedTest
-    @org.junit.jupiter.params.provider.MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
-    void verifiesReadWriteLockBehavior(CompilerHelper.CompilerConfig config) throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("rwlock-integration-sources");
-        Path classesDir = Files.createTempDirectory("rwlock-integration-classes");
-        Path javaApiDir = Files.createTempDirectory("java-api-classes");
-
-        // 1. Write Test App
-        Files.write(sourceDir.resolve("ReadWriteLockTestApp.java"), lockTestAppSource().getBytes(StandardCharsets.UTF_8));
-
-        // 2. Compile Test App against JavaAPI
-        List<String> sources = new ArrayList<>();
-        try (Stream<Path> paths = Files.walk(sourceDir)) {
-            paths.filter(p -> p.toString().endsWith(".java")).forEach(p -> sources.add(p.toString()));
-        }
-
-        List<String> compileArgs = new ArrayList<>();
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        if (CompilerHelper.useClasspath(config)) {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-classpath");
-             compileArgs.add(javaApiDir.toString());
-        } else {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-bootclasspath");
-             compileArgs.add(javaApiDir.toString());
-             compileArgs.add("-Xlint:-options");
-        }
-
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.addAll(sources);
-
-        int compileResult = CompilerHelper.compile(config.jdkHome, compileArgs);
-        assertEquals(0, compileResult, "Compilation failed");
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        // 3. Native Report Stub
-        Path nativeReport = sourceDir.resolve("native_report.c");
-        Files.write(nativeReport, nativeReportSource().getBytes(StandardCharsets.UTF_8));
-        Files.copy(nativeReport, classesDir.resolve("native_report.c"));
-
-        // 4. Run Translator
-        Path outputDir = Files.createTempDirectory("rwlock-integration-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "ReadWriteLockTestApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists));
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-    }
-
-    private String lockTestAppSource() {
-        return "import java.util.concurrent.locks.*;\n" +
-                "import java.util.concurrent.TimeUnit;\n" +
-                "public class ReadWriteLockTestApp {\n" +
-                "    private static native void report(String msg);\n" +
-                "    \n" +
-                "    public static void main(String[] args) {\n" +
-                "        testBasicReadLock();\n" +
-                "        testWriteLockExclusion();\n" +
-                "        testReentrancy();\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testBasicReadLock() {\n" +
-                "        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();\n" +
-                "        rw.readLock().lock();\n" +
-                "        try {\n" +
-                "             report(\"TEST: Basic Read Lock OK\");\n" +
-                "        } finally {\n" +
-                "            rw.readLock().unlock();\n" +
-                "        }\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testWriteLockExclusion() {\n" +
-                "        final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();\n" +
-                "        rw.writeLock().lock();\n" +
-                "        \n" +
-                "        final boolean[] success = new boolean[1];\n" +
-                "        Thread t = new Thread(new Runnable() {\n" +
-                "            public void run() {\n" +
-                "                // This should block until writer unlocks\n" +
-                "                rw.readLock().lock();\n" +
-                "                rw.readLock().unlock();\n" +
-                "                success[0] = true;\n" +
-                "            }\n" +
-                "        });\n" +
-                "        t.start();\n" +
-                "        \n" +
-                "        try { Thread.sleep(200); } catch(Exception e) {}\n" +
-                "        if (success[0]) {\n" +
-                "             report(\"TEST: Write Lock Exclusion FAILED (Reader acquired lock while writer held it)\");\n" +
-                "             return;\n" +
-                "        }\n" +
-                "        \n" +
-                "        rw.writeLock().unlock();\n" +
-                "        try { Thread.sleep(200); } catch(Exception e) {}\n" +
-                "        if (success[0]) {\n" +
-                "             report(\"TEST: Write Lock Exclusion OK\");\n" +
-                "        } else {\n" +
-                "             report(\"TEST: Write Lock Exclusion FAILED (Reader did not acquire lock)\");\n" +
-                "        }\n" +
-                "    }\n" +
-                "    \n" +
-                "    private static void testReentrancy() {\n" +
-                "        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();\n" +
-                "        rw.writeLock().lock();\n" +
-                "        try {\n" +
-                "            rw.readLock().lock();\n" +
-                "            try {\n" +
-                "                if (rw.getWriteHoldCount() == 1 && rw.getReadHoldCount() == 1) {\n" +
-                "                    report(\"TEST: Reentrancy (Downgrade) OK\");\n" +
-                "                }\n" +
-                "            } finally {\n" +
-                "                rw.readLock().unlock();\n" +
-                "            }\n" +
-                "        } finally {\n" +
-                "            rw.writeLock().unlock();\n" +
-                "        }\n" +
-                "    }\n" +
-                "}\n";
-    }
-
-    private String nativeReportSource() {
-        // Through the runtime's own conversion, not a hand-copied String struct: the
-        // layout is the VM's to change, and a fixture that mirrors it stops compiling
-        // (no offset field, no array ->data) and fails every case before it runs.
-        return "#include \"cn1_globals.h\"\n" +
-                "#include <stdio.h>\n" +
-                "void ReadWriteLockTestApp_report___java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {\n" +
-                "    if (msg != JAVA_NULL) {\n" +
-                "        printf(\"%s\\n\", stringToUTF8(threadStateData, msg));\n" +
-                "        fflush(stdout);\n" +
-                "    }\n" +
-                "}\n";
-    }
-
-
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/StampedLockIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/StampedLockIntegrationTest.java
deleted file mode 100644
index 657d798f386..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/StampedLockIntegrationTest.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.params.ParameterizedTest;
-
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Stream;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class StampedLockIntegrationTest {
-
-    @ParameterizedTest
-    @org.junit.jupiter.params.provider.MethodSource("com.codename1.tools.translator.BytecodeInstructionIntegrationTest#provideCompilerConfigs")
-    void verifiesStampedLockBehavior(CompilerHelper.CompilerConfig config) throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("stampedlock-integration-sources");
-        Path classesDir = Files.createTempDirectory("stampedlock-integration-classes");
-        Path javaApiDir = Files.createTempDirectory("java-api-classes");
-
-        // 1. Write Test App
-        Files.write(sourceDir.resolve("StampedLockTestApp.java"), stampedLockTestAppSource().getBytes(StandardCharsets.UTF_8));
-
-        // 2. Compile Test App against JavaAPI
-        List<String> sources = new ArrayList<>();
-        try (Stream<Path> paths = Files.walk(sourceDir)) {
-            paths.filter(p -> p.toString().endsWith(".java")).forEach(p -> sources.add(p.toString()));
-        }
-
-        List<String> compileArgs = new ArrayList<>();
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        if (CompilerHelper.useClasspath(config)) {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-classpath");
-             compileArgs.add(javaApiDir.toString());
-        } else {
-             compileArgs.add("-source");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-target");
-             compileArgs.add(config.targetVersion);
-             compileArgs.add("-bootclasspath");
-             compileArgs.add(javaApiDir.toString());
-             compileArgs.add("-Xlint:-options");
-        }
-
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.addAll(sources);
-
-        int compileResult = CompilerHelper.compile(config.jdkHome, compileArgs);
-        assertEquals(0, compileResult, "Compilation failed");
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        // 3. Native Report Stub
-        Path nativeReport = sourceDir.resolve("native_report.c");
-        Files.write(nativeReport, nativeReportSource().getBytes(StandardCharsets.UTF_8));
-        Files.copy(nativeReport, classesDir.resolve("native_report.c"));
-
-        // 4. Run Translator
-        Path outputDir = Files.createTempDirectory("stampedlock-integration-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "StampedLockTestApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists));
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        // Execution skipped; building the generated library validates translation output.
-    }
-
-    private String stampedLockTestAppSource() {
-        return "import java.util.concurrent.locks.*;\n" +
-               "import java.util.concurrent.TimeUnit;\n" +
-               "public class StampedLockTestApp {\n" +
-               "    private static native void report(String msg);\n" +
-               "    \n" +
-               "    public static void main(String[] args) {\n" +
-               "        testBasic();\n" +
-               "        testOptimisticRead();\n" +
-               "        testWriteLockExclusion();\n" +
-               "    }\n" +
-               "    \n" +
-               "    private static void testBasic() {\n" +
-               "        StampedLock sl = new StampedLock();\n" +
-               "        long stamp = sl.writeLock();\n" +
-               "        try {\n" +
-               "             report(\"TEST: Basic Write Lock OK\");\n" +
-               "        } finally {\n" +
-               "             sl.unlockWrite(stamp);\n" +
-               "        }\n" +
-               "        \n" +
-               "        stamp = sl.readLock();\n" +
-               "        try {\n" +
-               "             report(\"TEST: Basic Read Lock OK\");\n" +
-               "        } finally {\n" +
-               "             sl.unlockRead(stamp);\n" +
-               "        }\n" +
-               "    }\n" +
-               "    \n" +
-               "    private static void testOptimisticRead() {\n" +
-               "        StampedLock sl = new StampedLock();\n" +
-               "        long stamp = sl.tryOptimisticRead();\n" +
-               "        if (stamp != 0 && sl.validate(stamp)) {\n" +
-               "            report(\"TEST: Optimistic Read Valid OK\");\n" +
-               "        } else {\n" +
-               "            report(\"TEST: Optimistic Read Valid FAILED\");\n" +
-               "        }\n" +
-               "        \n" +
-               "        long ws = sl.writeLock();\n" +
-               "        if (sl.validate(stamp)) {\n" +
-               "            report(\"TEST: Optimistic Read Invalid (during write) FAILED\");\n" +
-               "        } else {\n" +
-               "            report(\"TEST: Optimistic Read Invalid (during write) OK\");\n" +
-               "        }\n" +
-               "        sl.unlockWrite(ws);\n" +
-               "        \n" +
-               "        if (sl.validate(stamp)) {\n" +
-               "             report(\"TEST: Optimistic Read Invalid (after write) FAILED\");\n" +
-               "        } else {\n" +
-               "             report(\"TEST: Optimistic Read Invalid (after write) OK\");\n" +
-               "        }\n" +
-               "    }\n" +
-               "    \n" +
-               "    private static void testWriteLockExclusion() {\n" +
-               "        final StampedLock sl = new StampedLock();\n" +
-               "        long stamp = sl.writeLock();\n" +
-               "        \n" +
-               "        final boolean[] success = new boolean[1];\n" +
-               "        Thread t = new Thread(new Runnable() {\n" +
-               "            public void run() {\n" +
-               "                long s = sl.readLock();\n" +
-               "                sl.unlockRead(s);\n" +
-               "                success[0] = true;\n" +
-               "            }\n" +
-               "        });\n" +
-               "        t.start();\n" +
-               "        \n" +
-               "        try { Thread.sleep(200); } catch(Exception e) {}\n" +
-               "        if (success[0]) {\n" +
-               "             report(\"TEST: Write Lock Exclusion FAILED (Reader acquired lock)\");\n" +
-               "             return;\n" +
-               "        }\n" +
-               "        \n" +
-               "        sl.unlockWrite(stamp);\n" +
-               "        try { Thread.sleep(200); } catch(Exception e) {}\n" +
-               "        if (success[0]) {\n" +
-               "             report(\"TEST: Write Lock Exclusion OK\");\n" +
-               "        } else {\n" +
-               "             report(\"TEST: Write Lock Exclusion FAILED (Reader did not acquire lock)\");\n" +
-               "        }\n" +
-               "    }\n" +
-               "}\n";
-    }
-
-    private String nativeReportSource() {
-        // Through the runtime's own conversion, not a hand-copied String struct: the
-        // layout is the VM's to change, and a fixture that mirrors it stops compiling
-        // (no offset field, no array ->data) and fails every case before it runs.
-        return "#include \"cn1_globals.h\"\n" +
-                "#include <stdio.h>\n" +
-                "void StampedLockTestApp_report___java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {\n" +
-                "    if (msg != JAVA_NULL) {\n" +
-                "        printf(\"%s\\n\", stringToUTF8(threadStateData, msg));\n" +
-                "        fflush(stdout);\n" +
-                "    }\n" +
-                "}\n";
-    }
-
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/StreamApiIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/StreamApiIntegrationTest.java
deleted file mode 100644
index 3d20992c9f3..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/StreamApiIntegrationTest.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.api.Test;
-
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class StreamApiIntegrationTest {
-
-    @Test
-    void streamEdgeCasesMatchBetweenJavaSEAndParparVM() throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("stream-integration-sources");
-        Path classesDir = Files.createTempDirectory("stream-integration-classes");
-        Path javaApiDir = Files.createTempDirectory("java-api-classes");
-
-        Path source = sourceDir.resolve("StreamEdgeApp.java");
-        Files.write(source, loadAppSource().getBytes(StandardCharsets.UTF_8));
-
-        CompilerHelper.CompilerConfig config = selectCompiler();
-        if (config == null) {
-            fail("No compatible compiler available for stream integration test");
-        }
-
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        List<String> compileArgs = new ArrayList<>();
-        compileArgs.add("-source");
-        compileArgs.add(config.targetVersion);
-        compileArgs.add("-target");
-        compileArgs.add(config.targetVersion);
-        if (CompilerHelper.useClasspath(config)) {
-            compileArgs.add("-classpath");
-            compileArgs.add(javaApiDir.toString());
-        } else {
-            compileArgs.add("-bootclasspath");
-            compileArgs.add(javaApiDir.toString());
-            compileArgs.add("-Xlint:-options");
-        }
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.add(source.toString());
-
-        int compileResult = CompilerHelper.compile(config.jdkHome, compileArgs);
-        assertEquals(0, compileResult, "StreamEdgeApp should compile");
-
-        String javaOutput = runJavaMain(config, classesDir, javaApiDir);
-        String javaResult = extractResultLine(javaOutput);
-        assertTrue(javaResult.startsWith("RESULT="), "JavaSE should produce a RESULT line. Output: " + javaOutput);
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        Path outputDir = Files.createTempDirectory("stream-integration-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "StreamEdgeApp");
-
-        Path distDir = outputDir.resolve("dist");
-        String generated = new String(Files.readAllBytes(distDir.resolve("StreamEdgeApp-src/StreamEdgeApp.c")), StandardCharsets.UTF_8);
-        assertTrue(generated.split("fused array stream", -1).length >= 9,
-                "All eight immediate helper pipelines must actually lower to C");
-        for (String helper : Arrays.asList("fusedMatch", "fusedCount", "fusedForEach", "fusedAll",
-                "fusedNone", "fusedZero", "fusedThrow", "fusedMutation")) {
-            int start = generated.indexOf(" StreamEdgeApp_" + helper + "_");
-            assertTrue(start >= 0);
-            int end = generated.indexOf("\nJAVA_", start);
-            String body = generated.substring(start, end < 0 ? generated.length() : end);
-            assertTrue(body.contains("fused array stream"), helper);
-            assertFalse(body.contains("lambda$factory"), helper + " must not allocate callback objects");
-            assertFalse(body.contains("virtual_java_util_stream"), helper + " must not dispatch stream stages");
-        }
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
-
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "StreamEdgeApp-src");
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        Path executable = buildDir.resolve("StreamEdgeApp");
-        String parparOutput = CleanTargetIntegrationTest.runCommand(Arrays.asList(executable.toString()), buildDir);
-        String parparResult = extractResultLine(parparOutput);
-        assertTrue(parparResult.startsWith("RESULT="), "ParparVM execution should produce a RESULT line. Output: " + parparOutput);
-
-        assertEquals(javaResult, parparResult,
-                "JavaSE and ParparVM should emit identical result lines for stream edge cases");
-    }
-
-    private String loadAppSource() throws Exception {
-        java.io.InputStream in = StreamApiIntegrationTest.class.getResourceAsStream("/com/codename1/tools/translator/StreamEdgeApp.java");
-        assertNotNull(in, "StreamEdgeApp.java test resource should exist");
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
-            return reader.lines().collect(Collectors.joining("\n")) + "\n";
-        }
-    }
-
-    private String runJavaMain(CompilerHelper.CompilerConfig config, Path classesDir, Path javaApiDir) throws Exception {
-        String javaExe = config.jdkHome.resolve("bin").resolve("java").toString();
-        if (System.getProperty("os.name").toLowerCase().contains("win")) {
-            javaExe += ".exe";
-        }
-
-        ProcessBuilder pb = new ProcessBuilder(
-                javaExe,
-                "-cp",
-                classesDir + System.getProperty("path.separator") + javaApiDir,
-                "StreamEdgeApp"
-        );
-        pb.redirectErrorStream(true);
-
-        Process process = pb.start();
-        String output;
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
-            output = reader.lines().collect(Collectors.joining("\n"));
-        }
-
-        int exitCode = process.waitFor();
-        assertEquals(0, exitCode, "JVM run should exit cleanly. Output: " + output);
-        return output;
-    }
-
-    private String extractResultLine(String output) {
-        for (String line : output.split("\\R")) {
-            if (line.startsWith("RESULT=")) {
-                return line.trim();
-            }
-        }
-        return "";
-    }
-
-    private CompilerHelper.CompilerConfig selectCompiler() {
-        String[] preferredTargets = {"11", "17", "21", "25", "1.8"};
-        for (String target : preferredTargets) {
-            List<CompilerHelper.CompilerConfig> configs = CompilerHelper.getAvailableCompilers(target);
-            for (CompilerHelper.CompilerConfig config : configs) {
-                if (CompilerHelper.isJavaApiCompatible(config)) {
-                    return config;
-                }
-            }
-        }
-        return null;
-    }
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/StringBuilderGrowthIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/StringBuilderGrowthIntegrationTest.java
deleted file mode 100644
index fc99fd5c4af..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/StringBuilderGrowthIntegrationTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.api.Test;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/** Runs the issue-5963 reproducer through the actual generated native runtime.
- * CN1_TEST_EXTRA_CFLAGS can add AddressSanitizer for allocation-lifetime evidence. */
-class StringBuilderGrowthIntegrationTest {
-    @Test
-    void concurrentGrowthDoesNotCorruptNativeStorage() throws Exception {
-        Parser.cleanup();
-        Path root = Files.createTempDirectory("builder-growth-");
-        Path api = Files.createDirectories(root.resolve("api"));
-        Path classes = Files.createDirectories(root.resolve("classes"));
-        CompilerHelper.CompilerConfig config = null;
-        for (String target : new String[]{"11", "17", "21", "1.8"}) {
-            for (CompilerHelper.CompilerConfig candidate : CompilerHelper.getAvailableCompilers(target)) {
-                if (CompilerHelper.isJavaApiCompatible(candidate)) { config = candidate; break; }
-            }
-            if (config != null) break;
-        }
-        assertNotNull(config);
-        CompilerHelper.compileJavaAPI(api, config);
-        Path source = root.resolve("StringBuilderGrowthApp.java");
-        try (java.io.InputStream in = getClass().getResourceAsStream("StringBuilderGrowthApp.java")) {
-            assertNotNull(in);
-            Files.copy(in, source);
-        }
-        List<String> args = new ArrayList<>(Arrays.asList("-source", config.targetVersion,
-                "-target", config.targetVersion, CompilerHelper.useClasspath(config) ? "-classpath" : "-bootclasspath",
-                api.toString(), "-d", classes.toString(), source.toString()));
-        assertEquals(0, CompilerHelper.compile(config.jdkHome, args));
-        CompilerHelper.copyDirectory(api, classes);
-        CleanTargetIntegrationTest.runTranslator(classes, root.resolve("output"), "StringBuilderGrowthApp");
-        Path dist = root.resolve("output/dist");
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(dist.resolve("CMakeLists.txt"), "StringBuilderGrowthApp-src");
-        Path build = dist.resolve("build");
-        List<String> cmake = new ArrayList<>(Arrays.asList("cmake", "-S", dist.toString(), "-B", build.toString(),
-                "-DCMAKE_BUILD_TYPE=RelWithDebInfo", "-DCMAKE_C_COMPILER=clang", "-DCMAKE_OBJC_COMPILER=clang"));
-        cmake.addAll(CompilerHelper.extraCFlagArgs());
-        CleanTargetIntegrationTest.runCommand(cmake, dist);
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", build.toString(), "--parallel", "4"), dist);
-        Path log = root.resolve("run.log");
-        Process process = new ProcessBuilder(build.resolve("StringBuilderGrowthApp").toString())
-                .directory(build.toFile()).redirectErrorStream(true).redirectOutput(log.toFile()).start();
-        try {
-            assertTrue(process.waitFor(90, TimeUnit.SECONDS), "Native builder test timed out: " + log);
-            String output = new String(Files.readAllBytes(log), StandardCharsets.UTF_8);
-            assertEquals(0, process.exitValue(), output);
-            assertTrue(output.contains("BUILDER_GROWTH_OK"), output);
-        } finally {
-            if (process.isAlive()) process.destroyForcibly();
-        }
-    }
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatConformanceTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatConformanceTest.java
index 06e5535e6bf..d859d19775e 100644
--- a/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatConformanceTest.java
+++ b/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatConformanceTest.java
@@ -82,7 +82,7 @@ class StringFormatConformanceTest {
 
     /**
      * {@code %a} and {@code %t} are unimplemented by design and raise
-     * UnknownFormatConversionException; they are covered by StringFormatIntegrationTest
+     * UnknownFormatConversionException; they are covered by BulkConformanceIntegrationTest (StringFormatChecks)
      * and deliberately absent from CONVERSIONS.
      */
     @Test
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatIntegrationTest.java
deleted file mode 100644
index 1b5df68a482..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/StringFormatIntegrationTest.java
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Codename One designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Codename One through http://www.codenameone.com/ if you
- * need additional information or have any questions.
- */
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.api.Test;
-
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
-/**
- * Differential test for {@code java.lang.String.format} (issue #5482).
- *
- * <p>{@code String.format} used to be a native method. Its Objective-C branch built an
- * argument vector by hand, threw away the string it formatted, and returned
- * {@code fromNSString([NSString init])} -- sending {@code init} to the {@code NSString}
- * class object, which aborts the process with
- * {@code +[NSString init]: cannot init a class object}. Because that branch is behind
- * {@code #if defined(__APPLE__) && defined(__OBJC__)} and this suite runs on Linux in CI,
- * nothing ever executed it. The C fallback that CI did run silently ignored width and
- * precision, so {@code "%.3f"} rendered every digit of the double.</p>
- *
- * <p>Formatting is now plain Java shared by every target, so this one test covers the
- * iOS behavior too. It runs the same program on the JVM and under ParparVM and requires
- * the two renderings to be identical, case by case -- which pins the output against the
- * real {@code java.util.Formatter}, not against a hand-written expectation.</p>
- */
-class StringFormatIntegrationTest {
-
-    @Test
-    void formatOutputMatchesTheJdkCaseByCase() throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("string-format-sources");
-        Path classesDir = Files.createTempDirectory("string-format-classes");
-        Path javaApiDir = Files.createTempDirectory("string-format-java-api");
-
-        Path source = sourceDir.resolve("StringFormatApp.java");
-        Files.write(source, loadAppSource().getBytes(StandardCharsets.UTF_8));
-
-        CompilerHelper.CompilerConfig config = selectCompiler();
-        if (config == null) {
-            fail("No compatible compiler available for the String.format integration test");
-        }
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        List<String> compileArgs = new ArrayList<>();
-        compileArgs.add("-source");
-        compileArgs.add(config.targetVersion);
-        compileArgs.add("-target");
-        compileArgs.add(config.targetVersion);
-        if (CompilerHelper.useClasspath(config)) {
-            compileArgs.add("-classpath");
-            compileArgs.add(javaApiDir.toString());
-        } else {
-            compileArgs.add("-bootclasspath");
-            compileArgs.add(javaApiDir.toString());
-            compileArgs.add("-Xlint:-options");
-        }
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.add(source.toString());
-
-        assertEquals(0, CompilerHelper.compile(config.jdkHome, compileArgs),
-                "StringFormatApp should compile against the JavaAPI");
-
-        // The JVM run resolves java.lang.String from the boot class path, so this side is
-        // the real java.util.Formatter no matter what is on the classpath.
-        String javaOutput = runJavaMain(config, classesDir, javaApiDir);
-        Map<String, String> expected = parseCases(javaOutput, "CASE|");
-        assertFalse(expected.isEmpty(), "JVM run should emit cases. Output: " + javaOutput);
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        Path outputDir = Files.createTempDirectory("string-format-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "StringFormatApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path generated = distDir.resolve("StringFormatApp-src");
-        String builderC = new String(Files.readAllBytes(generated.resolve("java_lang_StringBuilder.c")),
-                StandardCharsets.UTF_8);
-        assertTrue(builderC.contains("&__FINALIZER_java_lang_StringBuilder ,0 , 0,"),
-                "Native primitive storage needs cleanup but no tracing callback");
-        String stringC = new String(Files.readAllBytes(generated.resolve("java_lang_String.c")),
-                StandardCharsets.UTF_8);
-        assertTrue(stringC.contains("&__GC_MARK_java_lang_String,"),
-                "Strings still trace their backing storage");
-        String applicationC = new String(Files.readAllBytes(generated.resolve("StringFormatApp.c")),
-                StandardCharsets.UTF_8);
-        assertTrue(applicationC.contains("cleanup(cn1StackBufferLeave)"),
-                "The exception/return cases must exercise stack buffer ownership");
-        int borrowedStart = applicationC.indexOf("JAVA_OBJECT StringFormatApp_borrowedBuilderResult___R_java_lang_String(");
-        assertTrue(borrowedStart >= 0);
-        assertTrue(applicationC.substring(borrowedStart, applicationC.indexOf("\n}", borrowedStart))
-                .contains("cleanup(cn1StackBufferLeave)"), "A proved borrowing helper must preserve stack allocation");
-        int escapedStart = applicationC.indexOf("JAVA_VOID StringFormatApp_escapingBuilderResult__(");
-        assertTrue(escapedStart >= 0);
-        assertFalse(applicationC.substring(escapedStart, applicationC.indexOf("\n}", escapedStart))
-                .contains("cleanup(cn1StackBufferLeave)"), "A retaining helper must keep heap ownership");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "StringFormatApp-src");
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        Path executable = buildDir.resolve("StringFormatApp");
-        String parparOutput = CleanTargetIntegrationTest.runCommand(
-                Arrays.asList(executable.toString()), buildDir);
-
-        // The Objective-C native aborted the process here rather than returning.
-        assertTrue(parparOutput.contains("DONE"),
-                "ParparVM run should complete String.format without dying. Output: " + parparOutput);
-
-        Map<String, String> actual = parseCases(parparOutput, "CASE|");
-        assertEquals(expected.keySet(), actual.keySet(),
-                "ParparVM should emit exactly the cases the JVM emitted");
-
-        List<String> differences = new ArrayList<>();
-        for (Map.Entry<String, String> entry : expected.entrySet()) {
-            String parpar = actual.get(entry.getKey());
-            if (!entry.getValue().equals(parpar)) {
-                differences.add(entry.getKey()
-                        + "\n    jdk     : " + entry.getValue()
-                        + "\n    parparvm: " + parpar);
-            }
-        }
-        assertTrue(differences.isEmpty(),
-                "ParparVM String.format diverged from the JDK in " + differences.size()
-                        + " case(s):\n" + String.join("\n", differences));
-
-        // Cases that cannot go through the shared diff, because the JDK either formats
-        // them (%a, %t, which ParparVM does not implement) or because the JDK's own
-        // answer moved between versions (%0$s is accepted on 11, rejected from 16 on).
-        // Either way the requirement is the same: a catchable Java exception, since the
-        // point of issue #5482 was that a formatting problem took the whole process down.
-        Map<String, String> expectedCn1Only = new LinkedHashMap<>();
-        expectedCn1Only.put("hexFloat", "EX|java.util.UnknownFormatConversionException");
-        expectedCn1Only.put("dateTime", "EX|java.util.UnknownFormatConversionException");
-        expectedCn1Only.put("zeroArgumentIndex", "EX|java.util.IllegalFormatArgumentIndexException");
-
-        Map<String, String> unsupported = parseCases(parparOutput, "CN1ONLY|");
-        assertEquals(expectedCn1Only, unsupported,
-                "Unsupported and version-dependent specifiers must throw, not crash or guess");
-    }
-
-    private Map<String, String> parseCases(String output, String prefix) {
-        Map<String, String> cases = new LinkedHashMap<>();
-        for (String line : output.split("\\R")) {
-            if (!line.startsWith(prefix)) {
-                continue;
-            }
-            String body = line.substring(prefix.length());
-            int separator = body.indexOf('|');
-            assertTrue(separator > 0, "Malformed case line: " + line);
-            cases.put(body.substring(0, separator), body.substring(separator + 1));
-        }
-        return cases;
-    }
-
-    private String loadAppSource() throws Exception {
-        java.io.InputStream in = StringFormatIntegrationTest.class
-                .getResourceAsStream("/com/codename1/tools/translator/StringFormatApp.java");
-        assertNotNull(in, "StringFormatApp.java test resource should exist");
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
-            return reader.lines().collect(Collectors.joining("\n")) + "\n";
-        }
-    }
-
-    private String runJavaMain(CompilerHelper.CompilerConfig config, Path classesDir, Path javaApiDir)
-            throws Exception {
-        String javaExe = config.jdkHome.resolve("bin").resolve(CompilerHelper.executableName("java")).toString();
-        // The JVM side formats through its default locale while ParparVM's formatter is
-        // locale independent, so pin the locale rather than inherit whatever the machine
-        // running the build happens to use.
-        ProcessBuilder pb = new ProcessBuilder(
-                javaExe,
-                "-Duser.language=en",
-                "-Duser.country=US",
-                "-cp",
-                classesDir + System.getProperty("path.separator") + javaApiDir,
-                "StringFormatApp"
-        );
-        pb.redirectErrorStream(true);
-
-        Process process = pb.start();
-        String output;
-        try (BufferedReader reader = new BufferedReader(
-                new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
-            output = reader.lines().collect(Collectors.joining("\n"));
-        }
-        assertEquals(0, process.waitFor(), "JVM run should exit cleanly. Output: " + output);
-        return output;
-    }
-
-    private CompilerHelper.CompilerConfig selectCompiler() {
-        String[] preferredTargets = {"11", "17", "21", "25", "1.8"};
-        for (String target : preferredTargets) {
-            List<CompilerHelper.CompilerConfig> configs = CompilerHelper.getAvailableCompilers(target);
-            for (CompilerHelper.CompilerConfig config : configs) {
-                if (CompilerHelper.isJavaApiCompatible(config)) {
-                    return config;
-                }
-            }
-        }
-        return null;
-    }
-}
diff --git a/vm/tests/src/test/java/com/codename1/tools/translator/TimeApiIntegrationTest.java b/vm/tests/src/test/java/com/codename1/tools/translator/TimeApiIntegrationTest.java
deleted file mode 100644
index 39e16229573..00000000000
--- a/vm/tests/src/test/java/com/codename1/tools/translator/TimeApiIntegrationTest.java
+++ /dev/null
@@ -1,152 +0,0 @@
-package com.codename1.tools.translator;
-
-import org.junit.jupiter.api.Test;
-
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
-class TimeApiIntegrationTest {
-
-    @Test
-    void timeEdgeCasesMatchBetweenJavaSEAndParparVM() throws Exception {
-        Parser.cleanup();
-
-        Path sourceDir = Files.createTempDirectory("time-integration-sources");
-        Path classesDir = Files.createTempDirectory("time-integration-classes");
-        Path javaApiDir = Files.createTempDirectory("java-api-classes");
-
-        Path source = sourceDir.resolve("TimeEdgeApp.java");
-        Files.write(source, loadAppSource().getBytes(StandardCharsets.UTF_8));
-
-        CompilerHelper.CompilerConfig config = selectCompiler();
-        if (config == null) {
-            fail("No compatible compiler available for time integration test");
-        }
-
-        assertTrue(CompilerHelper.isJavaApiCompatible(config),
-                "JDK " + config.jdkVersion + " must target matching bytecode level for JavaAPI");
-
-        CompilerHelper.compileJavaAPI(javaApiDir, config);
-
-        List<String> compileArgs = new ArrayList<>();
-        compileArgs.add("-source");
-        compileArgs.add(config.targetVersion);
-        compileArgs.add("-target");
-        compileArgs.add(config.targetVersion);
-        if (CompilerHelper.useClasspath(config)) {
-            compileArgs.add("-classpath");
-            compileArgs.add(javaApiDir.toString());
-        } else {
-            compileArgs.add("-bootclasspath");
-            compileArgs.add(javaApiDir.toString());
-            compileArgs.add("-Xlint:-options");
-        }
-        compileArgs.add("-d");
-        compileArgs.add(classesDir.toString());
-        compileArgs.add(source.toString());
-
-        int compileResult = CompilerHelper.compile(config.jdkHome, compileArgs);
-        assertEquals(0, compileResult, "TimeEdgeApp should compile. " + CompilerHelper.getLastErrorLog());
-
-        String javaOutput = runJavaMain(config, classesDir, javaApiDir);
-        String javaResult = extractResultLine(javaOutput);
-        assertTrue(javaResult.startsWith("RESULT="), "JavaSE should produce a RESULT line. Output: " + javaOutput);
-
-        CompilerHelper.copyDirectory(javaApiDir, classesDir);
-
-        Path outputDir = Files.createTempDirectory("time-integration-output");
-        CleanTargetIntegrationTest.runTranslator(classesDir, outputDir, "TimeEdgeApp");
-
-        Path distDir = outputDir.resolve("dist");
-        Path cmakeLists = distDir.resolve("CMakeLists.txt");
-        assertTrue(Files.exists(cmakeLists), "Translator should emit a CMake project");
-
-        CleanTargetIntegrationTest.replaceLibraryWithExecutableTarget(cmakeLists, "TimeEdgeApp-src");
-
-        Path buildDir = distDir.resolve("build");
-        Files.createDirectories(buildDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList(
-                "cmake",
-                "-S", distDir.toString(),
-                "-B", buildDir.toString(),
-                "-DCMAKE_C_COMPILER=clang",
-                "-DCMAKE_OBJC_COMPILER=clang"
-        ), distDir);
-
-        CleanTargetIntegrationTest.runCommand(Arrays.asList("cmake", "--build", buildDir.toString()), distDir);
-
-        Path executable = buildDir.resolve("TimeEdgeApp");
-        assertTrue(Files.exists(executable), "ParparVM build should produce a runnable executable");
-        String vmOutput = CleanTargetIntegrationTest.runCommand(Arrays.asList(executable.toString()), buildDir);
-        String vmResult = extractResultLine(vmOutput);
-        assertEquals(javaResult, vmResult, "ParparVM output should match JavaSE");
-    }
-
-    private String loadAppSource() throws Exception {
-        java.io.InputStream in = TimeApiIntegrationTest.class.getResourceAsStream("/com/codename1/tools/translator/TimeEdgeApp.java");
-        assertNotNull(in, "TimeEdgeApp.java test resource should exist");
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
-            return reader.lines().collect(Collectors.joining("\n")) + "\n";
-        }
-    }
-
-    private String runJavaMain(CompilerHelper.CompilerConfig config, Path classesDir, Path javaApiDir) throws Exception {
-        String javaExe = config.jdkHome.resolve("bin").resolve("java").toString();
-        if (System.getProperty("os.name").toLowerCase().contains("win")) {
-            javaExe += ".exe";
-        }
-
-        ProcessBuilder pb = new ProcessBuilder(
-                javaExe,
-                "-cp",
-                classesDir + System.getProperty("path.separator") + javaApiDir,
-                "TimeEdgeApp"
-        );
-        pb.redirectErrorStream(true);
-
-        Process process = pb.start();
-        String output;
-        try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
-            output = reader.lines().collect(Collectors.joining("\n"));
-        }
-
-        int exitCode = process.waitFor();
-        assertEquals(0, exitCode, "JVM run should exit cleanly. Output: " + output);
-        return output;
-    }
-
-    private String extractResultLine(String output) {
-        for (String line : output.split("\\R")) {
-            if (line.startsWith("RESULT=")) {
-                return line.trim();
-            }
-        }
-        return "";
-    }
-
-    private CompilerHelper.CompilerConfig selectCompiler() {
-        String[] preferredTargets = {"11", "17", "21", "25", "1.8"};
-        for (String target : preferredTargets) {
-            List<CompilerHelper.CompilerConfig> configs = CompilerHelper.getAvailableCompilers(target);
-            for (CompilerHelper.CompilerConfig config : configs) {
-                if (CompilerHelper.isJavaApiCompatible(config)) {
-                    return config;
-                }
-            }
-        }
-        return null;
-    }
-}
diff --git a/vm/tests/src/test/resources/cldc-javaapi-parity-baseline.txt b/vm/tests/src/test/resources/cldc-javaapi-parity-baseline.txt
new file mode 100644
index 00000000000..eacac26de25
--- /dev/null
+++ b/vm/tests/src/test/resources/cldc-javaapi-parity-baseline.txt
@@ -0,0 +1,6 @@
+# CLDC11 API members vm/JavaAPI does not provide. A RATCHET, not an
+# allow-list: CldcJavaApiParityTest fails on a new entry and on a stale
+# one. Close a gap by adding the member to JavaAPI, then delete its line.
+MISSING java/lang/ref/Reference#<init>()V
+MISSING java/util/Calendar#DAY_OF_WEEK_IN_MONTH:I
+MISSING java/util/Calendar#WEEK_OF_MONTH:I
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/JsFileIoProgram.java b/vm/tests/src/test/resources/com/codename1/tools/translator/JsFileIoProgram.java
index a15152b1f31..53dd4cd62e2 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/JsFileIoProgram.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/JsFileIoProgram.java
@@ -28,6 +28,9 @@ public class JsFileIoProgram {
     public static int result;
 
     public static void main(String[] args) throws Exception {
+        // A program translated without Codename One brings its own file
+        // system; without it java.io.File sees an empty one.
+        com.codename1.impl.JdkHost.install(new com.codename1.impl.PosixJdkHost());
         int mask = 0;
         File root = new File(args[0]);
         File dir = new File(root, "a/b");
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/JsLangMembersApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/JsLangMembersApp.java
new file mode 100644
index 00000000000..9c7eb5966cf
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/JsLangMembersApp.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+import java.util.Objects;
+
+/// The java.lang / java.util members JavaAPI provides, in the browser
+/// runtime. One bit per property; all of them is 0x3fffffff (30 bits).
+/// Java 11 API only.
+public class JsLangMembersApp {
+    public static int result;
+
+    static String msg(Throwable t) {
+        return t.getClass().getName() + ":" + t.getMessage();
+    }
+
+    public static void main(String[] args) throws Exception {
+        int mask = 0;
+        String em = "" + (char) 0x2003;
+        if ((em + " a b " + em).strip().equals("a b")) mask |= 1;
+        if (" x ".isBlank() == false && "  ".isBlank() && "ab".repeat(3).equals("ababab")) mask |= 1 << 1;
+        String smile = new String(new int[] {0x1F600}, 0, 1);
+        if (smile.length() == 2 && smile.codePointAt(0) == 0x1F600 && ("a" + smile).codePointCount(0, 3) == 2) mask |= 1 << 2;
+        if ("a\nb\r\nc".lines().count() == 3) mask |= 1 << 3;
+        if (Integer.parseUnsignedInt("4294967295") == -1 && Integer.toUnsignedString(-1).equals("4294967295")) mask |= 1 << 4;
+        if (Integer.decode("-0x1F") == -31 && Integer.decode("#ff") == 255 && Integer.decode("010") == 8) mask |= 1 << 5;
+        try {
+            Integer.parseInt("80000000", 16);
+        } catch (NumberFormatException e) {
+            if ("For input string: \"80000000\" under radix 16".equals(e.getMessage())) mask |= 1 << 6;
+        }
+        if (Long.parseUnsignedLong("18446744073709551615") == -1L && Long.toUnsignedString(-1L).equals("18446744073709551615")
+                && Long.divideUnsigned(-1L, 10) == 1844674407370955161L) mask |= 1 << 7;
+        if (Long.toHexString(-255L).equals("ffffffffffffff01") && Long.toBinaryString(5L).equals("101") && Long.bitCount(-1L) == 64) mask |= 1 << 8;
+        if (Integer.reverse(0x12345678) == 0x1e6a2c48 && Integer.reverseBytes(0x12345678) == 0x78563412 && Integer.highestOneBit(100) == 64) mask |= 1 << 9;
+        if (Double.toHexString(1.0).equals("0x1.0p0") && Double.toHexString(0.1).equals("0x1.999999999999ap-4")
+                && Float.toHexString(Float.MIN_VALUE).equals("0x0.000002p-126")) mask |= 1 << 10;
+        if (Short.decode("0x7fff") == 32767 && Byte.toUnsignedInt((byte) -1) == 255 && Short.reverseBytes((short) 0x1234) == 0x3412) mask |= 1 << 11;
+        if (Boolean.logicalXor(true, false) && Boolean.compare(true, false) == 1 && Boolean.hashCode(true) == 1231) mask |= 1 << 12;
+        if (Character.getNumericValue('a') == 10 && Character.digit((char) 0xFF21, 16) == 10 && Character.isDigit(0x0663)) mask |= 1 << 13;
+        if (Character.toUpperCase(0xe9) == 0xc9 && Character.toUpperCase(0xff) == 0x178 && Character.isSpaceChar((char) 0xa0)) mask |= 1 << 14;
+        if (Character.getType('A') == Character.UPPERCASE_LETTER && Character.getType(' ') == Character.SPACE_SEPARATOR
+                && Character.getType((char) 0x01c5) == Character.TITLECASE_LETTER) mask |= 1 << 15;
+        if (Character.toString(0x1F600).length() == 2 && Character.forDigit(11, 16) == 'b' && Character.isAlphabetic('a')) mask |= 1 << 16;
+        if (Math.round(-2.5) == -2 && Math.round(2.5f) == 3 && Math.round(0.49999999999999994) == 0 && Math.round(1.5) == 2) mask |= 1 << 17;
+        if (Math.floorDiv(-7, 2) == -4 && Math.floorMod(-7, 2) == 1 && Math.floorMod(7, -2) == -1) mask |= 1 << 18;
+        try {
+            Math.addExact(Integer.MAX_VALUE, 1);
+        } catch (ArithmeticException e) {
+            if ("integer overflow".equals(e.getMessage())) mask |= 1 << 19;
+        }
+        if (Double.doubleToLongBits(Math.nextUp(1.0)) == 0x3ff0000000000001L && Double.doubleToLongBits(Math.ulp(1.0)) == 0x3cb0000000000000L
+                && Math.hypot(3, 4) == 5.0 && Math.getExponent(1024.0) == 10) mask |= 1 << 20;
+        if (Math.multiplyHigh(Long.MAX_VALUE, Long.MAX_VALUE) == 4611686018427387903L && Math.multiplyFull(-2, 3) == -6L && StrictMath.max(1, 2) == 2) mask |= 1 << 21;
+        if ("d".equals(Objects.requireNonNullElse(null, "d"))) mask |= 1 << 22;
+        try {
+            Objects.checkIndex(5, 3);
+        } catch (IndexOutOfBoundsException e) {
+            if ("Index 5 out of bounds for length 3".equals(e.getMessage())) mask |= 1 << 23;
+        }
+        StringBuilder sb = new StringBuilder("ab");
+        sb.appendCodePoint(0x1F600);
+        if (sb.length() == 4 && sb.codePointCount(0, 4) == 3 && sb.compareTo(new StringBuilder("ac")) < 0
+                && CharSequence.compare("a", sb) < 0 && sb.substring(1, 2).equals("b")) mask |= 1 << 24;
+        if (new Locale("IW", "il").toString().equals("he_IL") && new Locale("en", "US", "WIN").toLanguageTag().equals("en-US-x-lvariant-WIN")
+                && Locale.forLanguageTag("en-US-x-lvariant-POSIX").getVariant().equals("POSIX")) mask |= 1 << 25;
+        if (new Locale("fr", "CA").getDisplayName(Locale.ENGLISH).equals("French (Canada)") && Locale.ROOT.toLanguageTag().equals("und")
+                && new Locale("en", "US").equals(Locale.US)) mask |= 1 << 26;
+        if (Charset.forName("latin1").name().equals("ISO-8859-1") && Charset.forName("utf8") == StandardCharsets.UTF_8
+                && !Charset.isSupported("x-nope") && Charset.forName("UTF-8").aliases().contains("UTF8")) mask |= 1 << 27;
+        try {
+            Charset.forName("x-nope");
+        } catch (IllegalArgumentException e) {
+            if ("java.nio.charset.UnsupportedCharsetException:x-nope".equals(msg(e))) mask |= 1 << 28;
+        }
+        byte[] utf8 = "h\u00e9".getBytes(StandardCharsets.UTF_8);
+        if (utf8.length == 3 && new String(utf8, StandardCharsets.UTF_8).equals("h\u00e9")
+                && new String(new byte[] {(byte) 0xe9}, StandardCharsets.ISO_8859_1).charAt(0) == 0xe9) mask |= 1 << 29;
+        result = mask;
+        System.out.println("MASK=" + Integer.toHexString(mask));
+        System.exit(mask);
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/ZipApiApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/ZipApiApp.java
index 8d36295448e..d5e0a7cefd4 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/ZipApiApp.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/ZipApiApp.java
@@ -882,7 +882,19 @@ static void compatibilityRegressions(boolean customRuntime) throws Exception {
                     "unrelated extra preserved");
         }
     }
+    /// Gives the translated runtime its file system. Its own class, so the JDK
+    /// runs that have no JavaAPI on the class path fail to load only this.
+    static final class PosixHost {
+        static void install() {
+            com.codename1.impl.JdkHost.install(new com.codename1.impl.PosixJdkHost());
+        }
+    }
     public static void main(String[] args) throws Exception {
+        try {
+            PosixHost.install();
+        } catch (LinkageError onTheJdk) {
+            // The JDK's java.io needs no host.
+        }
         byte[] data = payload();
         checksums();
         systemPropertyConfiguration();
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/Base64Checks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/Base64Checks.java
new file mode 100644
index 00000000000..ee086381def
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/Base64Checks.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.List;
+import java.util.Random;
+
+/// java.util.Base64: every encoder and decoder on the same input, every
+/// outcome compared as text (the value, or the exception's class name).
+public final class Base64Checks {
+    private Base64Checks() {
+    }
+
+    /// One call whose outcome is compared.
+    private interface Call {
+        Object call() throws Exception;
+    }
+
+    private static String outcome(Call call) {
+        try {
+            Object o = call.call();
+            if (o instanceof byte[]) {
+                return Arrays.toString((byte[]) o);
+            }
+            return String.valueOf(o);
+        } catch (Exception e) {
+            return e.getClass().getName();
+        }
+    }
+
+    /// `Random.nextBytes` as the JDK documents it: four bytes from each
+    /// `nextInt`, low byte first. Written out rather than called because
+    /// JavaAPI's takes one `next(8)` per byte, so the two runs would encode
+    /// different inputs; that difference is not what this group compares.
+    private static void fill(Random random, byte[] bytes) {
+        for (int i = 0; i < bytes.length;) {
+            int rnd = random.nextInt();
+            for (int n = Math.min(bytes.length - i, 4); n-- > 0; rnd >>= 8) {
+                bytes[i++] = (byte) rnd;
+            }
+        }
+    }
+
+    private static List<byte[]> inputs() {
+        List<byte[]> out = new ArrayList<byte[]>();
+        Random random = new Random(42);
+        for (int n = 0; n < 70; n++) {
+            byte[] b = new byte[n];
+            fill(random, b);
+            out.add(b);
+        }
+        for (int n : new int[] {113, 114, 115, 171, 1000}) {
+            byte[] b = new byte[n];
+            fill(random, b);
+            out.add(b);
+        }
+        out.add(new byte[] {-1, -1, -1, -5, -17, -65});
+        return out;
+    }
+
+    /// Runs the group.
+    public static void run() {
+        // The original filled its inputs with Random.nextBytes; this group
+        // fills them by hand (see fill), and this check holds nextBytes
+        // itself to the JDK's documented algorithm.
+        Bulk.check("Base64.randomNextBytesAsTheInputsWereMade", () -> {
+            Random random = new Random(42);
+            for (int n : new int[] {0, 1, 3, 4, 6, 9}) {
+                byte[] b = new byte[n];
+                random.nextBytes(b);
+                Bulk.p("nextBytes" + n, b);
+            }
+            Random byHand = new Random(42);
+            for (int n : new int[] {0, 1, 3, 4, 6, 9}) {
+                byte[] b = new byte[n];
+                fill(byHand, b);
+                Bulk.p("fill" + n, b);
+            }
+        });
+        Bulk.check("Base64.thePaddingCharacterIsNoLineSeparator", () -> {
+            byte[][] separators = {{'='}, {'\r', '='}, {'A'}};
+            for (int i = 0; i < separators.length; i++) {
+                final byte[] separator = separators[i];
+                Bulk.pThrown("separator" + i, IllegalArgumentException.class,
+                        () -> Base64.getMimeEncoder(4, separator));
+            }
+        });
+        Bulk.check("Base64.everyEncoderAndDecoderIsTheJdks", () -> {
+            final Base64.Encoder[] encoders = {Base64.getEncoder(), Base64.getUrlEncoder(), Base64.getMimeEncoder(),
+                Base64.getEncoder().withoutPadding(), Base64.getUrlEncoder().withoutPadding(),
+                Base64.getMimeEncoder(10, new byte[] {'!', '\n'}), Base64.getMimeEncoder(0, new byte[] {'!'}),
+                Base64.getMimeEncoder(7, new byte[0]).withoutPadding()};
+            final Base64.Decoder[] decoders = {Base64.getDecoder(), Base64.getUrlDecoder(), Base64.getMimeDecoder()};
+            int compared = 0;
+            List<String> texts = new ArrayList<String>();
+            List<byte[]> inputs = inputs();
+            for (int k = 0; k < inputs.size(); k++) {
+                final byte[] in = inputs.get(k);
+                // Every outcome of one input folded into a hash, one line per
+                // input: the encodings of 1000 bytes are too long to print.
+                int hash = 0;
+                for (int e = 0; e < encoders.length; e++) {
+                    final Base64.Encoder enc = encoders[e];
+                    hash = 31 * hash + outcome(() -> enc.encodeToString(in)).hashCode();
+                    hash = 31 * hash + outcome(() -> enc.encode(in)).hashCode();
+                    hash = 31 * hash + outcome(() -> enc.encode(in, new byte[in.length * 2 + 8])).hashCode();
+                    hash = 31 * hash + outcome(() -> enc.encode(in, new byte[in.length])).hashCode();
+                    compared += 4;
+                    texts.add(enc.encodeToString(in));
+                }
+                Bulk.p("encode" + k + " length " + in.length, hash);
+            }
+            Bulk.p("encodingOf6", encoders[0].encodeToString(inputs.get(6)));
+            Bulk.p("mimeOf171", outcome(() -> encoders[2].encodeToString(inputs.get(73))));
+            String[] literal = {"=", "==", "A", "A=", "A==", "AA", "AA=", "AA==", "AAA", "AAA=", "AAA==", "AAAA=",
+                "AAAA", "AA==AA", "AA=A", "A A A A", "AAAA\nAAAA", "AA\n==", "AA=\n=", "AAA\n=", "****", "AAA*",
+                "AAAA====", "-_-_", "+/+/", "QUJD" + (char) 0xE9, "QUJD" + (char) 0x142, "AAA=A", "AQ==\n", "AQ=="};
+            int generated = texts.size();
+            texts.addAll(Arrays.asList(literal));
+            int hash = 0;
+            for (int t = 0; t < texts.size(); t++) {
+                final String text = texts.get(t);
+                StringBuilder line = new StringBuilder();
+                for (int d = 0; d < decoders.length; d++) {
+                    final Base64.Decoder dec = decoders[d];
+                    String fromString = outcome(() -> dec.decode(text));
+                    String fromBytes = outcome(() -> dec.decode(text.getBytes(StandardCharsets.ISO_8859_1)));
+                    compared += 2;
+                    if (t < generated) {
+                        hash = 31 * hash + fromString.hashCode();
+                        hash = 31 * hash + fromBytes.hashCode();
+                    } else {
+                        line.append(" d").append(d).append('=').append(fromString).append(" b").append(d).append('=')
+                                .append(fromBytes);
+                    }
+                }
+                if (t < generated) {
+                    if (t % 100 == 99 || t == generated - 1) {
+                        Bulk.p("decodeGenerated upTo" + t, hash);
+                    }
+                } else {
+                    Bulk.p("decode [" + Bulk.esc(text) + "]", line.toString());
+                }
+            }
+            Bulk.pThrown("separatorA", IllegalArgumentException.class,
+                    () -> Base64.getMimeEncoder(8, new byte[] {'A'}));
+            Bulk.p("compared", compared);
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/Bulk.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/Bulk.java
new file mode 100644
index 00000000000..adbc739d5dd
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/Bulk.java
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/// The harness of the bulk conformance program (BulkConformanceIntegrationTest).
+///
+/// The program runs twice: on HotSpot, where every `java.*` class is the JDK's,
+/// and translated by ParparVM, where every one is JavaAPI's. Each named check
+/// prints a header line and then what it observed; the test compares the two
+/// runs check by check and names every check whose lines differ.
+///
+/// Rules for a check, so that the two runs are comparable at all:
+///
+/// - print values, never identity hash codes, timings, absolute paths
+///   ([#rel]) or the iteration order of a hash collection ([#sorted]);
+/// - a throw the check expects is reported with [#thrown], which compares
+///   by type the way `assertThrows` does; an unexpected one ends the check
+///   with a `THREW` line and the program goes on with the next check;
+/// - behaviour that is Codename One's own and not the JDK's goes in a
+///   [#cn1Only] check, which asserts with [#expect] and runs on ParparVM only;
+/// - a check that compares with a JDK behaviour that changed after Java 8
+///   calls [#skipOnHotSpot] when the HotSpot run is a later JDK.
+public final class Bulk {
+    /// A check's body.
+    public interface Body {
+        /// Runs the check.
+        void run() throws Throwable;
+    }
+
+    private static final boolean HOTSPOT = "hotspot".equals(System.getProperty("bulk.host"));
+    private static final Set<String> NAMES = new HashSet<String>();
+    private static int count;
+
+    private Bulk() {
+    }
+
+    /// True in the HotSpot run, where the JDK answers.
+    public static boolean onHotSpot() {
+        return HOTSPOT;
+    }
+
+    /// Called first by the generated main class.
+    public static void begin() {
+        if (!HOTSPOT) {
+            BulkHost.installDefault();
+        }
+    }
+
+    /// Called last by the generated main class. Exits, so that shutdown hooks
+    /// run and a pool a check forgot cannot keep the program alive.
+    public static void end() {
+        header("(end)");
+        System.out.println("checks=" + count);
+        System.out.flush();
+        System.exit(0);
+    }
+
+    private static void header(String name) {
+        if (!NAMES.add(name)) {
+            throw new IllegalStateException("Two checks are named " + name);
+        }
+        System.out.println("### " + name);
+        System.out.flush();
+    }
+
+    /// Runs `body` as the check `name`.
+    public static void check(String name, Body body) {
+        header(name);
+        count++;
+        try {
+            body.run();
+        } catch (Throwable t) {
+            System.out.println("THREW " + t.getClass().getName() + ": " + esc(String.valueOf(t.getMessage())));
+        }
+        after();
+    }
+
+    /// Runs `body` as the check `name` on ParparVM only: Codename One
+    /// behaviour that the JDK does not share, asserted with [#expect]. The
+    /// HotSpot run prints `CN1-ONLY`, and the test then requires the ParparVM
+    /// run to print no `FAIL` and no `THREW` line for it.
+    public static void cn1Only(String name, Body body) {
+        header(name);
+        count++;
+        if (HOTSPOT) {
+            System.out.println("CN1-ONLY");
+            return;
+        }
+        try {
+            body.run();
+        } catch (Throwable t) {
+            System.out.println("THREW " + t.getClass().getName() + ": " + esc(String.valueOf(t.getMessage())));
+        }
+        after();
+    }
+
+    private static void after() {
+        // A check must not leave the next one interrupted or on its own host.
+        Thread.interrupted();
+        if (!HOTSPOT) {
+            BulkHost.installDefault();
+            JdkHost.setRegistry(null);
+        }
+        System.out.flush();
+    }
+
+    /// In a [#cn1Only] check: prints `FAIL what` unless `ok`.
+    public static void expect(boolean ok, String what) {
+        if (!ok) {
+            System.out.println("FAIL " + esc(what));
+        }
+    }
+
+    /// In a [#cn1Only] check: prints `FAIL` unless `expected` equals `actual`.
+    public static void expectEquals(Object expected, Object actual, String what) {
+        boolean same = expected == null ? actual == null : expected.equals(actual);
+        if (!same) {
+            System.out.println("FAIL " + esc(what) + ": expected <" + fmt(expected) + "> but was <" + fmt(actual) + ">");
+        }
+    }
+
+    /// On HotSpot, when `skip`, prints `SKIPPED reason` and answers true: the
+    /// test then ignores the check. ParparVM always answers false and runs it.
+    public static boolean skipOnHotSpot(boolean skip, String reason) {
+        if (HOTSPOT && skip) {
+            System.out.println("SKIPPED " + reason);
+            return true;
+        }
+        return false;
+    }
+
+    /// True when the HotSpot run is Java 8.
+    public static boolean hotSpotIsJava8() {
+        String v = System.getProperty("java.specification.version");
+        return v != null && v.startsWith("1.");
+    }
+
+    /// Prints `key=value`.
+    public static void p(String key, Object value) {
+        System.out.println(key + "=" + fmt(value));
+    }
+
+    /// Prints `key=value` for a boolean.
+    public static void p(String key, boolean value) {
+        System.out.println(key + "=" + value);
+    }
+
+    /// Prints `key=value` for an int.
+    public static void p(String key, int value) {
+        System.out.println(key + "=" + value);
+    }
+
+    /// Prints `key=value` for a long.
+    public static void p(String key, long value) {
+        System.out.println(key + "=" + value);
+    }
+
+    /// Prints `key=value` for a double.
+    public static void p(String key, double value) {
+        System.out.println(key + "=" + value);
+    }
+
+    /// Prints `key=value` for a char.
+    public static void p(String key, char value) {
+        System.out.println(key + "=" + esc(String.valueOf(value)));
+    }
+
+    /// What `body` threw, as `assertThrows(expected, body)` sees it: the
+    /// simple name of `expected` when it threw one, `none` when it threw
+    /// nothing, otherwise `other:` and the class it threw.
+    public static String thrown(Class<?> expected, Body body) {
+        try {
+            body.run();
+        } catch (Throwable t) {
+            if (expected.isInstance(t)) {
+                return expected.getSimpleName();
+            }
+            return "other:" + t.getClass().getName();
+        }
+        return "none";
+    }
+
+    /// Prints `key=` and what [#thrown] answers.
+    public static void pThrown(String key, Class<?> expected, Body body) {
+        p(key, thrown(expected, body));
+    }
+
+    /// The class name of what `body` threw, or `none`: for a check that
+    /// compares the exact type.
+    public static String thrownClass(Body body) {
+        try {
+            body.run();
+        } catch (Throwable t) {
+            return t.getClass().getName();
+        }
+        return "none";
+    }
+
+    /// The elements of `c` in their natural order, so a hash collection
+    /// prints the same on both runs.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static List<Object> sorted(Collection<?> c) {
+        List list = new ArrayList(c);
+        Collections.sort(list);
+        return list;
+    }
+
+    /// The entries of `m` as `k=v`, sorted by key.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static String sortedMap(Map<?, ?> m) {
+        List keys = new ArrayList(m.keySet());
+        Collections.sort(keys);
+        StringBuilder sb = new StringBuilder("{");
+        for (int i = 0; i < keys.size(); i++) {
+            if (i > 0) {
+                sb.append(", ");
+            }
+            sb.append(fmt(keys.get(i))).append('=').append(fmt(m.get(keys.get(i))));
+        }
+        return sb.append('}').toString();
+    }
+
+    /// `path` relative to `root`, with forward slashes, so a check never
+    /// prints a temporary directory.
+    public static String rel(String root, String path) {
+        String r = root.replace('\\', '/');
+        String p = path.replace('\\', '/');
+        if (p.equals(r)) {
+            return ".";
+        }
+        if (p.startsWith(r + "/")) {
+            return p.substring(r.length() + 1);
+        }
+        return p;
+    }
+
+    /// The value as the checks print it: arrays by content, every character
+    /// outside printable ASCII escaped so that a line stays one line and the
+    /// two runs' output encodings cannot differ.
+    public static String fmt(Object v) {
+        if (v == null) {
+            return "null";
+        }
+        String s;
+        if (v instanceof Object[]) {
+            s = Arrays.deepToString((Object[]) v);
+        } else if (v instanceof int[]) {
+            s = Arrays.toString((int[]) v);
+        } else if (v instanceof long[]) {
+            s = Arrays.toString((long[]) v);
+        } else if (v instanceof double[]) {
+            s = Arrays.toString((double[]) v);
+        } else if (v instanceof byte[]) {
+            s = Arrays.toString((byte[]) v);
+        } else if (v instanceof char[]) {
+            s = new String((char[]) v);
+        } else if (v instanceof boolean[]) {
+            s = Arrays.toString((boolean[]) v);
+        } else if (v instanceof float[]) {
+            s = Arrays.toString((float[]) v);
+        } else if (v instanceof short[]) {
+            s = Arrays.toString((short[]) v);
+        } else {
+            s = String.valueOf(v);
+        }
+        return esc(s);
+    }
+
+    /// `s` with every character outside printable ASCII written as a
+    /// backslash, `u` and four hex digits.
+    public static String esc(String s) {
+        StringBuilder sb = null;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c < 0x20 || c > 0x7e) {
+                if (sb == null) {
+                    sb = new StringBuilder(s.length() + 16);
+                    sb.append(s, 0, i);
+                }
+                String hex = Integer.toHexString(c);
+                sb.append("\\u");
+                for (int k = hex.length(); k < 4; k++) {
+                    sb.append('0');
+                }
+                sb.append(hex);
+            } else if (sb != null) {
+                sb.append(c);
+            }
+        }
+        return sb == null ? s : sb.toString();
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/BulkHost.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/BulkHost.java
new file mode 100644
index 00000000000..918bae9e076
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/BulkHost.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+import com.codename1.impl.PosixJdkHost;
+import com.codename1.security.Hash;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+/// The host the ParparVM run of the bulk program installs before every check:
+/// the POSIX file system, plus the files under `bulk/res`, which the HotSpot
+/// run reads from its class path, served as application resources the way a
+/// built application's host serves the ones the build packaged. Never loaded
+/// on HotSpot, where the JDK answers and no host is consulted.
+public class BulkHost extends PosixJdkHost {
+    /// Installs a fresh instance; [Bulk] calls it after every check.
+    static void installDefault() {
+        JdkHost.install(new BulkHost());
+    }
+
+    @Override
+    public InputStream resource(String name) {
+        byte[] data = BulkResources.get(name);
+        return data == null ? null : new ByteArrayInputStream(data);
+    }
+
+    /// The digests a built application's host offers, by the names
+    /// `CoreJdkHost.digest` answers: the core's own `Hash`, which the bulk
+    /// program compiles from `CodenameOne/src`.
+    @Override
+    public Digest digest(String algorithm) {
+        if (!Hash.MD5.equalsIgnoreCase(algorithm) && !Hash.SHA1.equalsIgnoreCase(algorithm)
+                && !Hash.SHA224.equalsIgnoreCase(algorithm) && !Hash.SHA256.equalsIgnoreCase(algorithm)
+                && !Hash.SHA384.equalsIgnoreCase(algorithm) && !Hash.SHA512.equalsIgnoreCase(algorithm)) {
+            return null;
+        }
+        final Hash hash = Hash.create(algorithm);
+        return new Digest() {
+            @Override
+            public void update(byte[] data, int offset, int length) {
+                hash.update(data, offset, length);
+            }
+
+            @Override
+            public byte[] digest() {
+                return hash.digest();
+            }
+
+            @Override
+            public void reset() {
+                hash.reset();
+            }
+
+            @Override
+            public int length() {
+                return hash.digestLength();
+            }
+        };
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CatchRethrowApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CatchRethrowApp.java
new file mode 100644
index 00000000000..ed1b2040229
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CatchRethrowApp.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// An exception thrown from a catch handler must leave the try statement, not
+/// be caught by a sibling handler of the same try. Each case sets one bit of
+/// the score; `RESULT=127` is every case right, and
+/// `BulkGeneratedCodeChecks.checkOutput` requires exactly that on ParparVM.
+public class CatchRethrowApp {
+    static int cleanups;
+
+    static void fail(String why) {
+        throw new IllegalStateException(why);
+    }
+
+    static int rethrow() {
+        try {
+            fail("a");
+        } catch (IllegalStateException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            return 100;
+        }
+        return 200;
+    }
+
+    static int throwNew() {
+        try {
+            fail("b");
+        } catch (IllegalStateException e) {
+            throw new UnsupportedOperationException("from the handler");
+        } catch (RuntimeException e) {
+            return 100;
+        }
+        return 200;
+    }
+
+    static int withFinally() {
+        try {
+            try {
+                fail("c");
+            } catch (IllegalStateException e) {
+                throw e;
+            } catch (RuntimeException e) {
+                return 100;
+            }
+        } finally {
+            cleanups++;
+        }
+        return 200;
+    }
+
+    static int nested() {
+        try {
+            try {
+                fail("d");
+            } catch (IllegalStateException e) {
+                throw e;
+            } catch (RuntimeException e) {
+                return 100;
+            }
+        } catch (IllegalStateException outer) {
+            return 7;
+        }
+        return 200;
+    }
+
+    static int touched;
+
+    // SelfTest's long-skipped VM probe: a catch around a try/finally in the
+    // same method must see what the finally rethrows.
+    static String nestedFinally() {
+        try {
+            try {
+                throw new java.io.IOException("thrown in the inner try");
+            } finally {
+                touched++;
+            }
+        } catch (Exception caught) {
+            return "caught";
+        }
+    }
+
+    public static void fixtureMain(String[] args) {
+        int score = 0;
+        try {
+            rethrow();
+        } catch (IllegalStateException e) {
+            if ("a".equals(e.getMessage())) {
+                score |= 1;
+            }
+        }
+        try {
+            throwNew();
+        } catch (UnsupportedOperationException e) {
+            score |= 2;
+        }
+        try {
+            withFinally();
+        } catch (IllegalStateException e) {
+            score |= 4;
+        }
+        if (cleanups == 1) {
+            score |= 8;
+        }
+        if (nested() == 7) {
+            score |= 16;
+        }
+        try {
+            fail("e");
+        } catch (RuntimeException e) {
+            score |= 32;
+        }
+        if ("caught".equals(nestedFinally()) && touched == 1) {
+            score |= 64;
+        }
+        System.out.println("RESULT=" + score);
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CatchRethrowChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CatchRethrowChecks.java
new file mode 100644
index 00000000000..1d7ee86171e
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CatchRethrowChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// CatchRethrowApp, formerly translated and built on its own by CatchRethrowIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class CatchRethrowChecks {
+    private CatchRethrowChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("CatchRethrowApp", () -> CatchRethrowApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/CollectionSemanticsApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectionSemanticsApp.java
similarity index 99%
rename from vm/tests/src/test/resources/com/codename1/tools/translator/CollectionSemanticsApp.java
rename to vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectionSemanticsApp.java
index d63ee9ac6c0..204aacd44f8 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/CollectionSemanticsApp.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectionSemanticsApp.java
@@ -244,7 +244,7 @@ private void fieldTraversalCases() {
         } catch (NullPointerException expected) { emit("fieldTraversal.null", traversalCalls); }
     }
 
-    public static void main(String[] args) throws InterruptedException {
+    public static void fixtureMain(String[] args) throws InterruptedException {
         // The migration result exposes this exact wrapper. Its toString calls
         // Object.toString through a Collection receiver, whose interface also
         // redeclares equals and hashCode. These use different dispatch tables.
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectionSemanticsChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectionSemanticsChecks.java
new file mode 100644
index 00000000000..e57d9cbbf34
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectionSemanticsChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// CollectionSemanticsApp, formerly translated and built on its own by CollectionSemanticsIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class CollectionSemanticsChecks {
+    private CollectionSemanticsChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("CollectionSemanticsApp", () -> CollectionSemanticsApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectorsChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectorsChecks.java
new file mode 100644
index 00000000000..36b9203a632
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CollectorsChecks.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.DoubleSummaryStatistics;
+import java.util.HashMap;
+import java.util.IntSummaryStatistics;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/// java.util.stream.Collectors and Collector.of.
+public final class CollectorsChecks {
+    private static final List<String> WORDS = Collections.unmodifiableList(Arrays.asList(
+            "pear", "apple", "fig", "banana", "apple", "kiwi", "cherry", "fig", "date", "avocado"));
+    private static final List<String> NONE = Collections.<String>emptyList();
+
+    private CollectorsChecks() {
+    }
+
+    private static Stream<String> words() {
+        return src(WORDS);
+    }
+
+    private static <T> Stream<T> src(List<T> list) {
+        return StreamSupport.stream(list.spliterator(), false);
+    }
+
+    private static String first(String word) {
+        return word.substring(0, 1);
+    }
+
+    /// The letters of `word`, one string each, as `word.split("")` answers
+    /// them on the JDK (JavaAPI has no regex `split`).
+    private static List<String> letters(String word) {
+        List<String> out = new ArrayList<String>();
+        for (int i = 0; i < word.length(); i++) {
+            out.add(word.substring(i, i + 1));
+        }
+        return out;
+    }
+
+    /// `v` printed the same on both runs: a hash map or set in sorted order,
+    /// at every depth; a list or a sorted collection as it iterates.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private static String canon(Object v) {
+        if (v instanceof Map) {
+            Map m = (Map) v;
+            List keys = new ArrayList(m.keySet());
+            if (!(v instanceof TreeMap) && !(v instanceof LinkedHashMap)) {
+                Collections.sort(keys);
+            }
+            StringBuilder sb = new StringBuilder("{");
+            for (int i = 0; i < keys.size(); i++) {
+                if (i > 0) {
+                    sb.append(", ");
+                }
+                sb.append(canon(keys.get(i))).append('=').append(canon(m.get(keys.get(i))));
+            }
+            return sb.append('}').toString();
+        }
+        if (v instanceof Collection) {
+            List items = new ArrayList((Collection) v);
+            if (v instanceof Set && !(v instanceof TreeSet)) {
+                Collections.sort(items);
+            }
+            StringBuilder sb = new StringBuilder("[");
+            for (int i = 0; i < items.size(); i++) {
+                if (i > 0) {
+                    sb.append(", ");
+                }
+                sb.append(canon(items.get(i)));
+            }
+            return sb.append(']').toString();
+        }
+        return Bulk.fmt(v);
+    }
+
+    /// Runs the group.
+    public static void run() {
+        collections();
+        reductions();
+        grouping();
+        toMap();
+        own();
+    }
+
+    private static void collections() {
+        Bulk.check("Collectors.toListToSetAndToCollection", () -> {
+            List<String> list = words().collect(Collectors.toList());
+            Bulk.p("list", list);
+            Bulk.p("listMutable", list.add("mutable"));
+            Set<String> set = words().collect(Collectors.toSet());
+            Bulk.p("set", canon(set));
+            Bulk.p("setMutable", set.add("mutable"));
+            TreeSet<String> sorted = words().collect(Collectors.toCollection(TreeSet::new));
+            Bulk.p("treeSet", sorted);
+            Bulk.p("emptyList", src(NONE).collect(Collectors.toList()));
+        });
+        Bulk.check("Collectors.joiningInItsThreeForms", () -> {
+            Bulk.p("plain", words().collect(Collectors.joining()));
+            Bulk.p("delimited", words().collect(Collectors.joining(", ")));
+            Bulk.p("wrapped", words().collect(Collectors.joining(", ", "[", "]")));
+            Bulk.p("emptyPlain", src(NONE).collect(Collectors.joining()));
+            Bulk.p("emptyDelimited", src(NONE).collect(Collectors.joining("-")));
+            Bulk.p("emptyWrapped", src(NONE).collect(Collectors.joining("-", "<", ">")));
+            Bulk.p("oneWrapped", words().limit(1).collect(Collectors.joining("-", "<", ">")));
+            List<CharSequence> mixed = Arrays.<CharSequence>asList("a", new StringBuilder("b"), null, "");
+            Bulk.p("mixed", src(mixed).collect(Collectors.joining("|")));
+        });
+    }
+
+    private static void reductions() {
+        Bulk.check("Collectors.countingSummingAndAveraging", () -> {
+            Bulk.p("counting", words().collect(Collectors.counting()));
+            Bulk.p("summingInt", words().collect(Collectors.summingInt(String::length)));
+            Bulk.p("summingLong", words().collect(Collectors.summingLong(w -> w.length() * 5000000000L)));
+            Bulk.p("summingDouble", words().collect(Collectors.summingDouble(w -> w.length() / 10.0)));
+            Bulk.p("averagingInt", words().collect(Collectors.averagingInt(String::length)));
+            Bulk.p("averagingLong", words().collect(Collectors.averagingLong(w -> w.length() * 5000000000L)));
+            Bulk.p("averagingDouble", words().collect(Collectors.averagingDouble(w -> w.length() / 10.0)));
+        });
+        Bulk.check("Collectors.theReductionsOfNothing", () -> {
+            Bulk.p("counting", src(NONE).collect(Collectors.counting()));
+            Bulk.p("summingInt", src(NONE).collect(Collectors.summingInt(String::length)));
+            Bulk.p("summingDouble", src(NONE).collect(Collectors.summingDouble(String::length)));
+            // An empty average is zero, not absent and not NaN.
+            Bulk.p("averagingInt", src(NONE).collect(Collectors.averagingInt(String::length)));
+            Bulk.p("averagingLong", src(NONE).collect(Collectors.averagingLong(String::length)));
+            Bulk.p("averagingDouble", src(NONE).collect(Collectors.averagingDouble(String::length)));
+            Comparator<String> natural = Comparator.naturalOrder();
+            Bulk.p("minBy", src(NONE).collect(Collectors.minBy(natural)).isPresent());
+            Bulk.p("maxBy", src(NONE).collect(Collectors.maxBy(natural)).isPresent());
+        });
+        Bulk.check("Collectors.summarizing", () -> {
+            IntSummaryStatistics i = words().collect(Collectors.summarizingInt(String::length));
+            Bulk.p("int", i.getCount() + " " + i.getSum() + " " + i.getMin() + " " + i.getMax() + " " + i.getAverage());
+            LongSummaryStatistics l = words().collect(Collectors.summarizingLong(w -> w.length() * 5000000000L));
+            Bulk.p("long", l.getSum() + " " + l.getMax());
+            DoubleSummaryStatistics d = words().collect(Collectors.summarizingDouble(w -> w.length() / 10.0));
+            Bulk.p("double", d.getSum() + " " + d.getMin() + " " + d.getAverage());
+        });
+        Bulk.check("Collectors.reducingMinByAndMaxBy", () -> {
+            Bulk.p("reducingIdentity", words().collect(Collectors.reducing("", (a, b) -> a + first(b))));
+            Bulk.p("reducing", words().collect(Collectors.reducing((a, b) -> a + first(b))).get());
+            Bulk.p("reducingMapped", words().collect(Collectors.reducing(0, String::length, Integer::sum)));
+            // Among equals, which one: told apart by where each stands.
+            List<String> tagged = new ArrayList<String>();
+            for (int i = 0; i < WORDS.size(); i++) {
+                tagged.add(WORDS.get(i) + "#" + i);
+            }
+            Comparator<String> byLength = (a, b) -> a.indexOf('#') - b.indexOf('#');
+            Bulk.p("minBy", src(tagged).collect(Collectors.minBy(byLength)).get());
+            Bulk.p("maxBy", src(tagged).collect(Collectors.maxBy(byLength)).get());
+        });
+        Bulk.check("Collectors.mappingAndCollectingAndThen", () -> {
+            Bulk.p("mapping", words().collect(Collectors.mapping(String::length, Collectors.toList())));
+            Bulk.p("size", words().collect(Collectors.collectingAndThen(Collectors.<String>toList(), l -> l.size())));
+            List<String> wrapped = words().collect(Collectors.collectingAndThen(Collectors.<String>toList(),
+                    l -> Collections.<String>unmodifiableList(l)));
+            Bulk.p("wrapped", wrapped);
+        });
+        Bulk.check("Collectors.filteringAndFlatMapping", () -> {
+            Bulk.p("filtering", words().collect(Collectors.filtering(w -> w.length() > 4, Collectors.toList())));
+            Bulk.p("flatMapping", words().limit(2).collect(Collectors.flatMapping(
+                    w -> src(letters(w)), Collectors.toList())));
+            // A group nothing survives the filter in is still there, and empty.
+            Map<Integer, List<String>> groups = words().collect(Collectors.groupingBy(String::length,
+                    Collectors.filtering(w -> w.startsWith("a"), Collectors.toList())));
+            Bulk.p("groups", canon(groups));
+            // A null inner stream is no elements.
+            Bulk.p("nullInner", words().collect(Collectors.flatMapping(w -> (Stream<String>) null,
+                    Collectors.counting())));
+        });
+    }
+
+    private static void grouping() {
+        Bulk.check("Collectors.groupingByAClassifier", () -> {
+            Map<Integer, List<String>> groups = words().collect(Collectors.groupingBy(String::length));
+            Bulk.p("groups", canon(groups));
+            // Within a group, encounter order; and the result is mutable.
+            Bulk.p("addToGroup", groups.get(4).add("mutable"));
+            groups.put(99, new ArrayList<String>());
+            Bulk.p("afterPut", groups.size());
+            Bulk.p("empty", src(NONE).collect(Collectors.groupingBy(String::length)).isEmpty());
+        });
+        Bulk.check("Collectors.groupingByWithADownstream", () -> {
+            Bulk.p("counting", canon(words().collect(Collectors.groupingBy(w -> first(w), Collectors.counting()))));
+            Bulk.p("joining", canon(words().collect(Collectors.groupingBy(String::length, Collectors.joining("+")))));
+            Bulk.p("toSet", canon(words().collect(Collectors.groupingBy(String::length, Collectors.toSet()))));
+            Bulk.p("averaging", canon(words().collect(Collectors.groupingBy(String::length,
+                    Collectors.averagingInt(w -> w.charAt(0))))));
+            // A group of groups.
+            Bulk.p("nested", canon(words().collect(Collectors.groupingBy(String::length,
+                    Collectors.groupingBy(w -> first(w))))));
+        });
+        Bulk.check("Collectors.groupingByIntoAChosenMap", () -> {
+            TreeMap<String, Long> sorted = words().collect(
+                    Collectors.groupingBy(w -> first(w), TreeMap::new, Collectors.counting()));
+            Bulk.p("treeMap", sorted.toString());
+            LinkedHashMap<Integer, List<String>> ordered = words().collect(
+                    Collectors.groupingBy(String::length, LinkedHashMap::new, Collectors.toList()));
+            Bulk.p("linkedHashMap", ordered.toString());
+        });
+        Bulk.check("Collectors.groupingByRefusesANullKey", () -> {
+            Bulk.pThrown("nullKey", NullPointerException.class,
+                    () -> words().collect(Collectors.groupingBy(w -> w.length() == 3 ? null : w)));
+        });
+        Bulk.check("Collectors.partitioningAlwaysHasBothHalves", () -> {
+            Map<Boolean, List<String>> halves = words().collect(Collectors.partitioningBy(w -> w.length() > 4));
+            Bulk.p("toString", halves.toString());
+            Bulk.p("true", halves.get(true));
+            Bulk.p("false", halves.get(false));
+            Bulk.p("size", halves.size());
+            Bulk.p("keySet", halves.keySet().toString());
+            Map<Boolean, List<String>> empty = src(NONE).collect(Collectors.partitioningBy(w -> true));
+            Bulk.p("emptyToString", empty.toString());
+            Bulk.p("emptyHasTrue", empty.containsKey(Boolean.TRUE));
+            Bulk.p("emptyHasFalse", empty.containsKey(Boolean.FALSE));
+            Bulk.p("emptyHasString", empty.containsKey("true"));
+            Bulk.p("counting", words().collect(Collectors.partitioningBy(w -> w.contains("a"),
+                    Collectors.counting())).toString());
+            Bulk.p("joining", words().collect(Collectors.partitioningBy(w -> w.contains("a"),
+                    Collectors.joining("/"))).toString());
+        });
+    }
+
+    private static void toMap() {
+        Bulk.check("Collectors.toMapOfDistinctKeys", () -> {
+            Map<String, Integer> map = words().distinct().collect(Collectors.toMap(w -> w, String::length));
+            Bulk.p("map", canon(map));
+            Bulk.p("put", map.put("mutable", 1));
+            Bulk.p("isHashMap", map instanceof HashMap);
+        });
+        Bulk.check("Collectors.toMapRefusesADuplicateKey", () -> {
+            String message = "none";
+            try {
+                words().collect(Collectors.toMap(w -> w, String::length));
+            } catch (IllegalStateException expected) {
+                message = String.valueOf(expected.getMessage().startsWith("Duplicate key apple"));
+            }
+            Bulk.p("namesTheKey", message);
+            // The same key from different elements counts as well.
+            Bulk.pThrown("sameKey", IllegalStateException.class,
+                    () -> words().collect(Collectors.toMap(w -> first(w), w -> w)));
+        });
+        Bulk.check("Collectors.toMapMergesWhenToldHow", () -> {
+            Bulk.p("concat", canon(words().collect(Collectors.toMap(w -> first(w), w -> w, (a, b) -> a + "+" + b))));
+            Bulk.p("sum", canon(words().collect(Collectors.toMap(String::length, w -> 1, Integer::sum))));
+        });
+        Bulk.check("Collectors.toMapIntoAChosenMap", () -> {
+            LinkedHashMap<String, String> linked = words().collect(
+                    Collectors.toMap(w -> first(w), w -> w, (a, b) -> b, LinkedHashMap::new));
+            Bulk.p("linked", linked.toString());
+            TreeMap<Integer, String> sorted = words().collect(
+                    Collectors.toMap(String::length, w -> w, (a, b) -> a, TreeMap::new));
+            Bulk.p("sorted", sorted.toString());
+        });
+        Bulk.check("Collectors.toMapRefusesANullValue", () -> {
+            Bulk.pThrown("merging", NullPointerException.class,
+                    () -> words().collect(Collectors.toMap(w -> w + w.hashCode(), w -> (String) null, (a, b) -> a)));
+            Bulk.pThrown("plain", NullPointerException.class,
+                    () -> words().distinct().collect(Collectors.toMap(w -> w, w -> (String) null)));
+        });
+    }
+
+    private static void own() {
+        Bulk.check("Collectors.collectorOf", () -> {
+            Collector<String, StringBuilder, String> initials = Collector.of(StringBuilder::new,
+                    (sb, w) -> sb.append(w.charAt(0)), (a, b) -> a.append(b), StringBuilder::toString);
+            Bulk.p("initials", words().collect(initials));
+            Bulk.p("initialsIdentityFinish",
+                    initials.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH));
+            Collector<String, List<String>, List<String>> identity = Collector.of(ArrayList::new, List::add,
+                    (a, b) -> {
+                        a.addAll(b);
+                        return a;
+                    });
+            Bulk.p("identity", words().collect(identity));
+            Bulk.p("identityIdentityFinish",
+                    identity.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH));
+            Collector.Characteristics[] all = Collector.Characteristics.values();
+            StringBuilder names = new StringBuilder();
+            for (Collector.Characteristics c : all) {
+                names.append(c.name()).append('=').append(c.ordinal()).append(' ')
+                        .append(Collector.Characteristics.valueOf(c.name()).ordinal()).append(';');
+            }
+            Bulk.p("characteristics", names.toString());
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrencyChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrencyChecks.java
new file mode 100644
index 00000000000..0017f0fc66c
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrencyChecks.java
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/// The thread-related contracts of java.util.concurrent that a race test can
+/// only hit sometimes, driven deterministically: the order invokeAll cancels
+/// in, the UI-thread wait through `JdkHost.blockUi`, and mutation from many
+/// threads at once.
+public final class ConcurrencyChecks {
+    private ConcurrencyChecks() {
+    }
+
+    /// An executor whose single worker is driven by the check, built on
+    /// public API only (an AbstractExecutorService with its own `execute`
+    /// and `newTaskFor`): the worker is waiting to take the first queued
+    /// task, and moves only when that task is cancelled -- the moment a real
+    /// worker is freed. It then skips every cancelled task and runs the
+    /// first one that is not.
+    private static final class SteppedExecutor extends AbstractExecutorService {
+        final List<FutureTask<?>> queue = new ArrayList<FutureTask<?>>();
+        /// The index of each task in the order invokeAll cancelled it.
+        final List<Integer> cancelOrder = new ArrayList<Integer>();
+        private int submitted;
+
+        @Override
+        public void execute(Runnable command) {
+            if (!(command instanceof FutureTask)) {
+                throw new IllegalArgumentException();
+            }
+            queue.add((FutureTask<?>) command);
+        }
+
+        @Override
+        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
+            final int index = submitted++;
+            return new FutureTask<T>(callable) {
+                @Override
+                public boolean cancel(boolean mayInterruptIfRunning) {
+                    boolean cancelled = super.cancel(mayInterruptIfRunning);
+                    if (cancelled) {
+                        cancelOrder.add(Integer.valueOf(index));
+                        step();
+                    }
+                    return cancelled;
+                }
+            };
+        }
+
+        void step() {
+            if (queue.isEmpty() || !queue.get(0).isDone()) {
+                return;
+            }
+            while (!queue.isEmpty()) {
+                FutureTask<?> next = queue.remove(0);
+                if (!next.isDone()) {
+                    next.run();
+                    return;
+                }
+            }
+        }
+
+        @Override
+        public void shutdown() {
+        }
+
+        @Override
+        public List<Runnable> shutdownNow() {
+            return Collections.<Runnable>emptyList();
+        }
+
+        @Override
+        public boolean isShutdown() {
+            return false;
+        }
+
+        @Override
+        public boolean isTerminated() {
+            return false;
+        }
+
+        @Override
+        public boolean awaitTermination(long timeout, TimeUnit unit) {
+            return false;
+        }
+    }
+
+    /// A host whose UI thread is the check's thread, and whose blockUi runs
+    /// the wait on another thread, as `Display.invokeAndBlock` does.
+    private static final class ConcurrencyUiHost extends JdkHost {
+        final Thread ui;
+        final AtomicInteger blocked = new AtomicInteger();
+
+        ConcurrencyUiHost(Thread ui) {
+            this.ui = ui;
+        }
+
+        @Override
+        public boolean isUiThread() {
+            return Thread.currentThread() == ui;
+        }
+
+        @Override
+        public void blockUi(Runnable task) {
+            blocked.incrementAndGet();
+            Thread t = new Thread(task, "blockUi");
+            t.start();
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+    }
+
+    /// A host for which every thread is the UI thread, and whose blockUi
+    /// interrupts the thread it runs the wait on. Bounded: when the
+    /// interrupt does not end the wait within ten seconds it says so, then
+    /// runs the task waited for so the wait ends and the program goes on.
+    private static final class ConcurrencyInterruptingHost extends JdkHost {
+        final FutureTask<String> waitedFor;
+        boolean interruptEndedTheWait;
+
+        ConcurrencyInterruptingHost(FutureTask<String> waitedFor) {
+            this.waitedFor = waitedFor;
+        }
+
+        @Override
+        public boolean isUiThread() {
+            return true;
+        }
+
+        @Override
+        public void blockUi(Runnable task) {
+            Thread t = new Thread(task, "blockUi");
+            t.start();
+            try {
+                Thread.sleep(50);
+                t.interrupt();
+                t.join(10000);
+                interruptEndedTheWait = !t.isAlive();
+                if (t.isAlive()) {
+                    waitedFor.run();
+                    t.join(10000);
+                }
+            } catch (InterruptedException e) {
+                throw new IllegalStateException(e);
+            }
+        }
+    }
+
+    private static void stop(ExecutorService pool) throws InterruptedException {
+        pool.shutdownNow();
+        pool.awaitTermination(20, TimeUnit.SECONDS);
+    }
+
+    /// Runs the group.
+    public static void run() {
+        // JavaAPI cancels what is left of an interrupted invokeAll from the
+        // BACK; the JDK cancels from the front, and with this executor that
+        // runs a task the caller was told would not run. Codename One's own
+        // contract, so ParparVM only.
+        Bulk.cn1Only("Concurrency.anInterruptedInvokeAllRunsNoTaskItWasGivenAfterAll", () -> {
+            SteppedExecutor executor = new SteppedExecutor();
+            final AtomicInteger ran = new AtomicInteger();
+            List<Callable<String>> tasks = new ArrayList<Callable<String>>();
+            for (int i = 0; i < 4; i++) {
+                tasks.add(() -> {
+                    ran.incrementAndGet();
+                    return "ran";
+                });
+            }
+            Thread.currentThread().interrupt();
+            boolean threw = false;
+            try {
+                executor.invokeAll(tasks);
+            } catch (InterruptedException expected) {
+                threw = true;
+                Bulk.expect(!Thread.currentThread().isInterrupted(), "the interrupt was not cleared");
+            } finally {
+                Thread.interrupted();
+            }
+            Bulk.expect(threw, "invokeAll returned although interrupted");
+            Bulk.expectEquals(Integer.valueOf(0), Integer.valueOf(ran.get()),
+                    "a task invokeAll cancelled ran while it was cancelling");
+            Bulk.expect(executor.queue.isEmpty(), "the worker did not get past the cancelled tasks");
+            Bulk.expectEquals(Arrays.asList(Integer.valueOf(3), Integer.valueOf(2), Integer.valueOf(1),
+                    Integer.valueOf(0)), executor.cancelOrder, "the order invokeAll cancelled in");
+        });
+        Bulk.check("Concurrency.aTimedInvokeAllThatRunsOutCancelsWhatIsLeft", () -> {
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                // Half a second, so the worker has started the first task on a
+                // loaded machine too before the deadline cancels anything.
+                // The first task ignores the interrupt the timed invokeAll's
+                // cancel(true) sends it, so its worker is not freed to start the
+                // second before that is cancelled too: the JDK cancels from the
+                // front, so an interruptible first task makes this a race there.
+                final AtomicBoolean release = new AtomicBoolean();
+                final AtomicInteger later = new AtomicInteger();
+                List<Callable<String>> tasks = new ArrayList<Callable<String>>();
+                tasks.add(() -> {
+                    long deadline = System.currentTimeMillis() + 30000;
+                    while (!release.get() && System.currentTimeMillis() < deadline) {
+                        Thread.interrupted();
+                        Thread.yield();
+                    }
+                    Thread.interrupted();
+                    return "first";
+                });
+                tasks.add(() -> {
+                    later.incrementAndGet();
+                    return "second";
+                });
+                List<Future<String>> futures = pool.invokeAll(tasks, 500, TimeUnit.MILLISECONDS);
+                release.set(true);
+                Bulk.p("firstIsCancelled", futures.get(0).isCancelled());
+                Bulk.p("secondIsCancelled", futures.get(1).isCancelled());
+                pool.shutdown();
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("later", later.get());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Concurrency.invokeAnyAnswersTheFirstSuccessAndCancelsTheRest", () -> {
+            ExecutorService pool = Executors.newFixedThreadPool(3);
+            try {
+                List<Callable<String>> tasks = new ArrayList<Callable<String>>();
+                tasks.add(() -> {
+                    throw new IllegalStateException("fails");
+                });
+                tasks.add(() -> "wins");
+                Bulk.p("invokeAny", pool.invokeAny(tasks));
+                List<Callable<String>> failing = new ArrayList<Callable<String>>();
+                failing.add(tasks.get(0));
+                try {
+                    pool.invokeAny(failing);
+                    Bulk.p("failing", "returned");
+                } catch (ExecutionException e) {
+                    Bulk.p("failingCause", e.getCause() instanceof IllegalStateException);
+                }
+                List<Callable<String>> slow = new ArrayList<Callable<String>>();
+                slow.add(() -> {
+                    Thread.sleep(5000);
+                    return "late";
+                });
+                Bulk.pThrown("slow", TimeoutException.class, () -> pool.invokeAny(slow, 20, TimeUnit.MILLISECONDS));
+            } finally {
+                stop(pool);
+            }
+        });
+        // Every wait in the package, on the UI thread, goes through blockUi
+        // and never blocks that thread itself. JdkHost is Codename One's.
+        Bulk.cn1Only("Concurrency.waitsOnTheUiThreadGoThroughBlockUi", () -> {
+            ConcurrencyUiHost host = new ConcurrencyUiHost(Thread.currentThread());
+            JdkHost.install(host);
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                final CountDownLatch go = new CountDownLatch(1);
+                Future<String> f = pool.submit(() -> {
+                    go.await();
+                    return "done";
+                });
+                CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
+                    try {
+                        Thread.sleep(30);
+                    } catch (InterruptedException e) {
+                        return "interrupted";
+                    }
+                    go.countDown();
+                    return "async";
+                });
+                Bulk.expectEquals("done", f.get(), "the future");
+                Bulk.expectEquals("async", cf.join(), "the completable future");
+                Bulk.expect(go.await(1, TimeUnit.SECONDS), "the latch");
+                pool.shutdown();
+                Bulk.expect(pool.awaitTermination(20, TimeUnit.SECONDS), "the pool did not stop");
+                Bulk.expect(host.blocked.get() >= 2, "blockUi was used " + host.blocked.get() + " times");
+            } finally {
+                JdkHost.install(null);
+                stop(pool);
+            }
+        });
+        // An interrupt that arrives while the UI thread's wait runs elsewhere
+        // still reaches the caller as an InterruptedException.
+        Bulk.cn1Only("Concurrency.aWaitInterruptedOffTheUiThreadIsReportedOnIt", () -> {
+            FutureTask<String> never = new FutureTask<String>(() -> "never run");
+            ConcurrencyInterruptingHost host = new ConcurrencyInterruptingHost(never);
+            JdkHost.install(host);
+            try {
+                String thrown = Bulk.thrown(InterruptedException.class, never::get);
+                Bulk.expect(host.interruptEndedTheWait, "the interrupt did not end the wait on the blockUi thread");
+                Bulk.expectEquals("InterruptedException", thrown, "what the wait threw");
+            } finally {
+                JdkHost.install(null);
+            }
+        });
+        Bulk.check("Concurrency.concurrentMutationLosesNothing", () -> {
+            final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<Integer, Integer>();
+            final CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>();
+            final CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<Integer>();
+            final int threads = 8;
+            final int each = 500;
+            ExecutorService pool = Executors.newFixedThreadPool(threads);
+            try {
+                final CountDownLatch start = new CountDownLatch(1);
+                List<Future<?>> futures = new ArrayList<Future<?>>();
+                for (int t = 0; t < threads; t++) {
+                    final int id = t;
+                    futures.add(pool.submit(() -> {
+                        try {
+                            start.await();
+                        } catch (InterruptedException e) {
+                            return;
+                        }
+                        for (int i = 0; i < each; i++) {
+                            map.merge(i, 1, Integer::sum);
+                            list.add(id * each + i);
+                            set.add(i);
+                        }
+                    }));
+                }
+                start.countDown();
+                for (Future<?> f : futures) {
+                    f.get(60, TimeUnit.SECONDS);
+                }
+                pool.shutdown();
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("isTerminated", pool.isTerminated());
+                Bulk.p("mapSize", map.size());
+                boolean everyCount = true;
+                for (int i = 0; i < each; i++) {
+                    everyCount &= Integer.valueOf(threads).equals(map.get(i));
+                }
+                Bulk.p("everyKeyCountedByEveryThread", everyCount);
+                Bulk.p("listSize", list.size());
+                Bulk.p("listDistinct", new HashSet<Integer>(list).size());
+                Set<Integer> expected = new HashSet<Integer>();
+                for (int i = 0; i < each; i++) {
+                    expected.add(i);
+                }
+                Bulk.p("setIsEveryKey", expected.equals(new HashSet<Integer>(Arrays.asList(set.toArray(new Integer[0])))));
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Concurrency.cancelInterruptsTheRunnerAndOnlyIt", () -> {
+            // cancel(true) interrupts the running task, and the interrupt does
+            // not leak into the next task that worker runs.
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                final CountDownLatch started = new CountDownLatch(1);
+                final CountDownLatch interrupted = new CountDownLatch(1);
+                Future<?> sleeper = pool.submit(() -> {
+                    started.countDown();
+                    try {
+                        Thread.sleep(20000);
+                    } catch (InterruptedException e) {
+                        interrupted.countDown();
+                    }
+                });
+                Bulk.p("started", started.await(20, TimeUnit.SECONDS));
+                Bulk.p("cancel", sleeper.cancel(true));
+                Bulk.p("isCancelled", sleeper.isCancelled());
+                Bulk.p("interrupted", interrupted.await(20, TimeUnit.SECONDS));
+                Bulk.pThrown("get", CancellationException.class, sleeper::get);
+                Future<Boolean> next = pool.submit(() -> Thread.currentThread().isInterrupted());
+                Bulk.p("nextInterrupted", next.get(20, TimeUnit.SECONDS));
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Concurrency.aThreadFactoryMakesTheWorkers", () -> {
+            final AtomicInteger made = new AtomicInteger();
+            ExecutorService pool = Executors.newFixedThreadPool(2, r -> {
+                made.incrementAndGet();
+                return new Thread(r, "made-" + made.get());
+            });
+            try {
+                Future<String> name = pool.submit(() -> Thread.currentThread().getName());
+                Bulk.p("nameFromFactory", name.get(20, TimeUnit.SECONDS).startsWith("made-"));
+                Bulk.p("factoryAsked", made.get() >= 1);
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Concurrency.scheduledFuturesAreOrderedByDelay", () -> {
+            ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
+            try {
+                ScheduledFuture<?> soon = pool.schedule(() -> {
+                }, 10, TimeUnit.SECONDS);
+                ScheduledFuture<?> later = pool.schedule(() -> {
+                }, 20, TimeUnit.SECONDS);
+                Bulk.p("soonBeforeLater", soon.compareTo(later) < 0);
+                Bulk.p("laterAfterSoon", later.compareTo(soon) > 0);
+                Bulk.p("self", soon.compareTo(soon));
+            } finally {
+                stop(pool);
+            }
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrentApiApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrentApiApp.java
new file mode 100644
index 00000000000..251a490cd1f
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrentApiApp.java
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+/// The executors, futures and concurrent collections, on real threads,
+/// printed as one line the JVM and ParparVM must agree on. Every value is
+/// either independent of scheduling or gathered in submission order, so the
+/// line is the same however the threads interleave.
+public class ConcurrentApiApp {
+    private static final StringBuilder OUT = new StringBuilder();
+
+    private static void out(Object label, Object value) {
+        OUT.append(label).append('=').append(value).append(';');
+    }
+
+    public static void fixtureMain(String[] args) throws Exception {
+        pools();
+        invokeAllAndAny();
+        cancellation();
+        completableFutures();
+        concurrentMaps();
+        copyOnWrite();
+        latchesAndScheduling();
+        System.out.println("RESULT=" + OUT);
+    }
+
+    private static void pools() throws Exception {
+        ExecutorService fixed = Executors.newFixedThreadPool(4);
+        List<Future<Integer>> squares = new ArrayList<Future<Integer>>();
+        for (int i = 0; i < 20; i++) {
+            final int n = i;
+            squares.add(fixed.submit(() -> n * n));
+        }
+        int sum = 0;
+        for (Future<Integer> f : squares) {
+            sum += f.get();
+        }
+        out("fixedSum", sum);
+        final AtomicInteger counter = new AtomicInteger();
+        for (int i = 0; i < 100; i++) {
+            fixed.execute(counter::incrementAndGet);
+        }
+        fixed.shutdown();
+        out("terminated", fixed.awaitTermination(30, TimeUnit.SECONDS));
+        out("counter", counter.get());
+        out("isShutdown", fixed.isShutdown());
+        try {
+            fixed.execute(() -> { });
+            out("rejected", "no");
+        } catch (RejectedExecutionException e) {
+            out("rejected", "yes");
+        }
+
+        ExecutorService single = Executors.newSingleThreadExecutor();
+        final StringBuilder order = new StringBuilder();
+        List<Future<?>> steps = new ArrayList<Future<?>>();
+        for (int i = 0; i < 6; i++) {
+            final int n = i;
+            steps.add(single.submit(() -> {
+                synchronized (order) {
+                    order.append(n);
+                }
+            }));
+        }
+        for (Future<?> f : steps) {
+            f.get();
+        }
+        synchronized (order) {
+            out("singleOrder", order);
+        }
+        out("resultOf", single.submit(() -> { }, "given").get());
+        single.shutdownNow();
+
+        ExecutorService cached = Executors.newCachedThreadPool(r -> {
+            Thread t = new Thread(r);
+            t.setDaemon(true);
+            return t;
+        });
+        Future<String> boom = cached.submit(() -> {
+            throw new IllegalStateException("boom");
+        });
+        try {
+            boom.get();
+            out("execException", "none");
+        } catch (ExecutionException e) {
+            out("execException", e.getCause().getClass().getName() + ":" + e.getCause().getMessage());
+        }
+        out("boomDone", boom.isDone());
+        cached.shutdown();
+        out("cachedTerminated", cached.awaitTermination(30, TimeUnit.SECONDS));
+        out("callable", Executors.callable(() -> { }, 7).call());
+    }
+
+    private static void invokeAllAndAny() throws Exception {
+        ExecutorService pool = Executors.newFixedThreadPool(3);
+        List<Callable<String>> tasks = new ArrayList<Callable<String>>();
+        for (int i = 0; i < 5; i++) {
+            final int n = i;
+            tasks.add(() -> "t" + n);
+        }
+        StringBuilder all = new StringBuilder();
+        for (Future<String> f : pool.invokeAll(tasks)) {
+            all.append(f.isDone()).append(':').append(f.get()).append(',');
+        }
+        out("invokeAll", all);
+        List<Callable<String>> one = new ArrayList<Callable<String>>();
+        one.add(() -> {
+            throw new IllegalArgumentException("first");
+        });
+        one.add(() -> "second");
+        out("invokeAny", pool.invokeAny(one));
+        List<Callable<String>> slow = new ArrayList<Callable<String>>();
+        slow.add(() -> {
+            // Polled for the same reason as in cancellation(): the cancel
+            // that the timeout makes must end this promptly on both VMs.
+            long end = System.currentTimeMillis() + 10000;
+            while (!Thread.currentThread().isInterrupted() && System.currentTimeMillis() < end) {
+                Thread.sleep(5);
+            }
+            return "late";
+        });
+        slow.add(() -> "quick");
+        List<Future<String>> timed = pool.invokeAll(slow, 200, TimeUnit.MILLISECONDS);
+        out("timedFirstCancelled", timed.get(0).isCancelled());
+        out("timedSecond", timed.get(1).get());
+        pool.shutdownNow();
+        out("poolTerminated", pool.awaitTermination(30, TimeUnit.SECONDS));
+    }
+
+    private static void cancellation() throws Exception {
+        FutureTask<String> task = new FutureTask<String>(() -> "ran");
+        out("cancelUnstarted", task.cancel(false));
+        task.run();
+        out("cancelled", task.isCancelled() + "/" + task.isDone());
+        try {
+            task.get();
+            out("getCancelled", "none");
+        } catch (CancellationException e) {
+            out("getCancelled", "ce");
+        }
+        FutureTask<String> done = new FutureTask<String>(() -> "value");
+        done.run();
+        out("cancelDone", done.cancel(true));
+        out("doneValue", done.get());
+
+        final StringBuilder hook = new StringBuilder();
+        FutureTask<Integer> withHook = new FutureTask<Integer>(() -> 42) {
+            @Override
+            protected void done() {
+                hook.append("done:").append(isCancelled());
+            }
+        };
+        withHook.run();
+        out("doneHook", hook);
+
+        ExecutorService pool = Executors.newSingleThreadExecutor();
+        final CountDownLatch started = new CountDownLatch(1);
+        final CountDownLatch interrupted = new CountDownLatch(1);
+        // Polls the flag rather than sleeping it out: ParparVM's interrupt()
+        // sets the flag but does not wake a Thread.sleep (see
+        // java_lang_Thread_sleepImpl in nativeMethods.m), so the JVM sees the
+        // exception and ParparVM the flag -- either is the runner interrupted.
+        Future<?> sleeper = pool.submit(() -> {
+            started.countDown();
+            long end = System.currentTimeMillis() + 30000;
+            try {
+                while (!Thread.currentThread().isInterrupted() && System.currentTimeMillis() < end) {
+                    Thread.sleep(5);
+                }
+                if (Thread.currentThread().isInterrupted()) {
+                    interrupted.countDown();
+                }
+            } catch (InterruptedException e) {
+                interrupted.countDown();
+            }
+        });
+        started.await();
+        out("cancelRunning", sleeper.cancel(true));
+        out("runnerInterrupted", interrupted.await(30, TimeUnit.SECONDS));
+        out("nextNotInterrupted", pool.submit(() -> Thread.currentThread().isInterrupted()).get());
+        try {
+            pool.submit(() -> "x").get(1, TimeUnit.NANOSECONDS);
+            out("timeout", "maybe");
+        } catch (TimeoutException e) {
+            out("timeout", "maybe");
+        }
+        pool.shutdown();
+        out("singleTerminated", pool.awaitTermination(30, TimeUnit.SECONDS));
+    }
+
+    private static void completableFutures() throws Exception {
+        CompletableFuture<Integer> a = CompletableFuture.supplyAsync(() -> 6);
+        CompletableFuture<Integer> b = CompletableFuture.supplyAsync(() -> 7);
+        out("combine", a.thenCombine(b, (x, y) -> x * y).get());
+        out("chain", CompletableFuture.completedFuture("a")
+                .thenApply(s -> s + "b")
+                .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + "c"))
+                .join());
+        CompletableFuture<String> failed = CompletableFuture.supplyAsync(() -> {
+            throw new IllegalStateException("bad");
+        });
+        try {
+            failed.join();
+            out("join", "none");
+        } catch (CompletionException e) {
+            out("join", e.getCause().getClass().getName());
+        }
+        try {
+            failed.get();
+            out("getFailed", "none");
+        } catch (ExecutionException e) {
+            out("getFailed", e.getCause().getMessage());
+        }
+        out("exceptionally", failed.exceptionally(t -> "recovered").join());
+        out("handle", failed.handle((v, t) -> v == null ? "handled" : v).join());
+        out("isCompletedExceptionally", failed.isCompletedExceptionally());
+
+        List<CompletableFuture<Integer>> parts = new ArrayList<CompletableFuture<Integer>>();
+        for (int i = 1; i <= 10; i++) {
+            final int n = i;
+            parts.add(CompletableFuture.supplyAsync(() -> n));
+        }
+        CompletableFuture.allOf(parts.toArray(new CompletableFuture[0])).join();
+        int total = 0;
+        for (CompletableFuture<Integer> p : parts) {
+            total += p.join();
+        }
+        out("allOf", total);
+        CompletableFuture<String> manual = new CompletableFuture<String>();
+        CompletableFuture<Object> any = CompletableFuture.anyOf(manual, CompletableFuture.completedFuture("ready"));
+        out("anyOf", any.join());
+        out("completeOnce", manual.complete("x") + "/" + manual.complete("y") + "/" + manual.join());
+        CompletableFuture<String> cancelled = new CompletableFuture<String>();
+        out("cfCancel", cancelled.cancel(true) + "/" + cancelled.isCancelled());
+        final AtomicReference<String> seen = new AtomicReference<String>();
+        CompletableFuture.supplyAsync(() -> "async").thenAccept(seen::set).join();
+        out("thenAccept", seen.get());
+    }
+
+    private static void concurrentMaps() throws Exception {
+        final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
+        ExecutorService pool = Executors.newFixedThreadPool(4);
+        List<Future<?>> work = new ArrayList<Future<?>>();
+        for (int t = 0; t < 4; t++) {
+            work.add(pool.submit(() -> {
+                for (int i = 0; i < 250; i++) {
+                    map.merge("k" + (i % 10), 1, Integer::sum);
+                    map.compute("total", (k, v) -> v == null ? 1 : v + 1);
+                }
+            }));
+        }
+        for (Future<?> f : work) {
+            f.get();
+        }
+        pool.shutdown();
+        pool.awaitTermination(30, TimeUnit.SECONDS);
+        out("chm", new TreeMap<String, Integer>(map));
+        out("putIfAbsent", map.putIfAbsent("k0", -1) + "/" + map.putIfAbsent("new", 5));
+        out("replace", map.replace("new", 5, 6) + "/" + map.get("new"));
+        out("removeKV", map.remove("new", 0) + "/" + map.remove("new", 6));
+        out("computeIfAbsent", map.computeIfAbsent("abs", k -> k.length()));
+        out("getOrDefault", map.getOrDefault("missing", -9));
+        try {
+            map.put(null, 1);
+            out("nullKey", "accepted");
+        } catch (NullPointerException e) {
+            out("nullKey", "npe");
+        }
+        ConcurrentMap<String, Integer> iface = map;
+        out("ifaceSize", iface.size());
+    }
+
+    private static void copyOnWrite() throws Exception {
+        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>(Arrays.asList(1, 2, 3));
+        StringBuilder seen = new StringBuilder();
+        for (Integer i : list) {
+            list.add(i * 10);
+            seen.append(i);
+        }
+        out("cowSnapshot", seen + "/" + list);
+        out("addIfAbsent", list.addIfAbsent(1) + "/" + list.addIfAbsent(4));
+        Iterator<Integer> it = list.iterator();
+        it.next();
+        try {
+            it.remove();
+            out("iterRemove", "allowed");
+        } catch (UnsupportedOperationException e) {
+            out("iterRemove", "uoe");
+        }
+        list.removeIf(x -> x > 9);
+        out("removeIf", list);
+        CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>();
+        out("setAdd", set.add("b") + "/" + set.add("a") + "/" + set.add("b"));
+        out("set", set);
+
+        final CopyOnWriteArrayList<Integer> shared = new CopyOnWriteArrayList<Integer>();
+        Thread[] threads = new Thread[4];
+        for (int t = 0; t < threads.length; t++) {
+            final int base = t * 100;
+            threads[t] = new Thread(() -> {
+                for (int i = 0; i < 100; i++) {
+                    shared.add(base + i);
+                }
+            });
+            threads[t].start();
+        }
+        for (Thread t : threads) {
+            t.join();
+        }
+        List<Integer> sortedShared = new ArrayList<Integer>(shared);
+        Collections.sort(sortedShared);
+        out("cowThreads", shared.size() + "/" + sortedShared.get(0) + "/" + sortedShared.get(399));
+    }
+
+    private static void latchesAndScheduling() throws Exception {
+        final CountDownLatch latch = new CountDownLatch(3);
+        for (int i = 0; i < 3; i++) {
+            new Thread(latch::countDown).start();
+        }
+        out("latch", latch.await(30, TimeUnit.SECONDS) + "/" + latch.getCount());
+        out("latchTimeout", new CountDownLatch(1).await(10, TimeUnit.MILLISECONDS));
+
+        ScheduledExecutorService sched = Executors.newScheduledThreadPool(1);
+        long start = System.currentTimeMillis();
+        ScheduledFuture<String> later = sched.schedule(() -> "scheduled", 50, TimeUnit.MILLISECONDS);
+        out("scheduled", later.get());
+        out("waited", System.currentTimeMillis() - start >= 40);
+        final AtomicInteger ticks = new AtomicInteger();
+        final CountDownLatch three = new CountDownLatch(3);
+        ScheduledFuture<?> rate = sched.scheduleAtFixedRate(() -> {
+            ticks.incrementAndGet();
+            three.countDown();
+        }, 0, 10, TimeUnit.MILLISECONDS);
+        out("ticked", three.await(30, TimeUnit.SECONDS));
+        out("rateCancel", rate.cancel(false) + "/" + rate.isCancelled());
+        ScheduledFuture<?> far = sched.schedule(() -> { }, 1, TimeUnit.HOURS);
+        out("delayPositive", far.getDelay(TimeUnit.MINUTES) > 50);
+        far.cancel(false);
+        sched.shutdown();
+        out("schedTerminated", sched.awaitTermination(30, TimeUnit.SECONDS));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrentApiChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrentApiChecks.java
new file mode 100644
index 00000000000..627b858d30a
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ConcurrentApiChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// ConcurrentApiApp, formerly translated and built on its own by FunctionalApiIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class ConcurrentApiChecks {
+    private ConcurrentApiChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("ConcurrentApiApp", () -> ConcurrentApiApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CopyOnWriteChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CopyOnWriteChecks.java
new file mode 100644
index 00000000000..119ece9fa58
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/CopyOnWriteChecks.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+/// java.util.concurrent.CopyOnWriteArraySet.
+public final class CopyOnWriteChecks {
+    private CopyOnWriteChecks() {
+    }
+
+    private static List<Integer> some(Random random) {
+        List<Integer> out = new ArrayList<Integer>();
+        for (int i = random.nextInt(5); i > 0; i--) {
+            out.add(random.nextInt(8) == 0 ? null : Integer.valueOf(random.nextInt(12)));
+        }
+        return out;
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("CopyOnWrite.aRandomSequenceOfOperationsMatchesTheJdk", () -> {
+            // Every step's answer and the set after it, in insertion order
+            // (which is what a copy-on-write set keeps), printed a hundred
+            // steps to a line so a divergence names its step range.
+            Random random = new Random(20261009L);
+            CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<Integer>();
+            int inconsistent = 0;
+            StringBuilder trace = new StringBuilder();
+            for (int step = 0; step < 5000; step++) {
+                Integer value = random.nextInt(10) == 0 ? null : Integer.valueOf(random.nextInt(12));
+                List<Integer> several = some(random);
+                switch (random.nextInt(10)) {
+                    case 0:
+                    case 1:
+                    case 2:
+                        trace.append("add:").append(set.add(value));
+                        break;
+                    case 3:
+                        trace.append("remove:").append(set.remove(value));
+                        break;
+                    case 4:
+                        trace.append("contains:").append(set.contains(value));
+                        trace.append(",containsAll:").append(set.containsAll(several));
+                        break;
+                    case 5:
+                        trace.append("addAll:").append(set.addAll(several));
+                        break;
+                    case 6:
+                        trace.append("removeAll:").append(set.removeAll(several));
+                        break;
+                    case 7:
+                        trace.append("retainAll:").append(set.retainAll(several));
+                        break;
+                    case 8:
+                        final int limit = random.nextInt(12);
+                        trace.append("removeIf:").append(set.removeIf(x -> x != null && x.intValue() < limit));
+                        break;
+                    default:
+                        if (random.nextInt(20) == 0) {
+                            set.clear();
+                            trace.append("clear");
+                        }
+                        break;
+                }
+                trace.append(' ').append(set).append(" h").append(set.hashCode()).append(" n").append(set.size())
+                        .append(set.isEmpty() ? " e" : "").append(';');
+                List<Integer> asList = new ArrayList<Integer>(set);
+                if (!asList.equals(Arrays.asList(set.toArray()))
+                        || !asList.equals(Arrays.asList(set.toArray(new Integer[0])))
+                        || !set.equals(new HashSet<Integer>(asList))
+                        || !new HashSet<Integer>(asList).equals(set)
+                        || asList.size() != set.size()) {
+                    inconsistent++;
+                }
+                if (step % 100 == 99) {
+                    Bulk.p("steps" + (step - 99), trace.toString());
+                    trace.setLength(0);
+                }
+            }
+            Bulk.p("inconsistentSteps", inconsistent);
+        });
+        Bulk.check("CopyOnWrite.aCopyKeepsTheFirstOfEachElementInOrder", () -> {
+            List<String> source = Arrays.asList("b", "a", "b", null, "c", "a", null);
+            Bulk.p("copy", new ArrayList<String>(new CopyOnWriteArraySet<String>(source)));
+        });
+        Bulk.check("CopyOnWrite.anIteratorSeesTheSetAsItWasWhenItWasCreated", () -> {
+            CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>(Arrays.asList("a", "b", "c"));
+            List<String> seen = new ArrayList<String>();
+            for (String s : set) {
+                set.remove(s);
+                set.add(s + s);
+                seen.add(s);
+            }
+            Bulk.p("seen", seen);
+            Bulk.p("after", new ArrayList<String>(set));
+            final List<String> each = new ArrayList<String>();
+            set.forEach(s -> {
+                set.clear();
+                each.add(s);
+            });
+            Bulk.p("forEach", each);
+            Bulk.p("isEmpty", set.isEmpty());
+        });
+        Bulk.check("CopyOnWrite.anIteratorIsReadOnly", () -> {
+            CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>(Arrays.asList("a"));
+            Iterator<String> it = set.iterator();
+            it.next();
+            Bulk.pThrown("remove", UnsupportedOperationException.class, it::remove);
+            Bulk.p("isEmpty", set.isEmpty());
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/DecimalFormatChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/DecimalFormatChecks.java
new file mode 100644
index 00000000000..658b1de0d81
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/DecimalFormatChecks.java
@@ -0,0 +1,518 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.FieldPosition;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.util.Locale;
+
+/// java.text.DecimalFormat, NumberFormat and DecimalFormatSymbols: the same
+/// patterns and values give the same text, the same parsed numbers and the
+/// same parse positions.
+///
+/// JavaAPI keeps Java 8's US English symbols where the JDK's locale data
+/// changed them later (CLDR from Java 9), and the HotSpot reference is a
+/// later JDK. Where that is the only difference -- NaN is written U+FFFD by
+/// Java 8 and `NaN` by CLDR -- the HotSpot run sets the Java 8 symbol on its
+/// own symbols ([#usSymbols]) so the formatting itself is still compared,
+/// and [#java8UsSymbols] pins JavaAPI's defaults to Java 8's on ParparVM.
+public final class DecimalFormatChecks {
+    private DecimalFormatChecks() {
+    }
+
+    private static final Locale US = new Locale("en", "US");
+    private static final String CURRENCY = String.valueOf((char) 0xA4);
+    private static final String PER_MILLE = String.valueOf((char) 0x2030);
+    private static final String JAVA8_NAN = String.valueOf((char) 0xFFFD);
+
+    private static final String[] PATTERNS = {
+        "0", "#", "0.0", "0.00", "#.##", "#.00", "#,##0.00", "#,###", "#,##0.###", "000.000",
+        "0.###E0", "00.###E0", "##0.#####E0", "0.00E00", "##0.##E0", "#E0", "0E0", "000E0", "0.0E0",
+        "#,##0.00E0", "###0.###E00",
+        "#%", "0.0%", "#,##0%", "#" + PER_MILLE, "0.00" + PER_MILLE,
+        "#,##0.00;(#,##0.00)", "0.0;0.0-", "-0;+0", "+0.0;-0.0",
+        "'#'#", "$#,##0.00", "0.0 'units'", "'x'''0", "0 'o''clock'", "EUR 0.00", "0.0 kg",
+        "#,####.##", "#,##,##0.0", "#,#", "0.#", ".00", "#.", "0.", "000", ".##", "#.0#",
+        CURRENCY + "#,##0.00", CURRENCY + CURRENCY + " 0.00", "#,##0.00 " + CURRENCY,
+        "0.0000000000", "#.##########", "0.000000000000000000", "00000000000000000000.0",
+        "", "abc", "'%'0", "0'%'", "a0b;c0d", "#,##0.###;-#",
+    };
+
+    private static final double[] DOUBLES = {
+        0, -0.0, 1, -1, 0.5, -0.5, 1.5, 2.5, 3.5, 0.125, 0.135, 0.145, 0.15, 0.25, 0.35, 0.45, 0.05,
+        0.005, 0.015, 0.025, 1.005, 1.015, 1.025, 2.675, 4.35, 8.345, 9.995, 99.995, 0.999, 0.9999,
+        999.9995, 1234.5678, -1234.5678, 0.001, 0.0005, 0.00049, 0.00051, 1e-7, 1e-10, 123456789.123,
+        1e15, 1e16, 1e17, 1e20, 1e22, 1e23, 1.23e25, 12345, 100, 1000, 999, 999.5, 9999.5, 0.1 + 0.2,
+        1.0 / 3, 2.0 / 3, 10.0 / 3, 1e3, 1e6, 123456.789, 0.000123456, 1.5e-5, 2.5e-5, 6.02214076e23,
+        Double.MAX_VALUE, Double.MIN_VALUE, 5e-324, Double.NaN, Double.POSITIVE_INFINITY,
+        Double.NEGATIVE_INFINITY, 0.5000000000000001, 0.49999999999999994, 1.0000000000000002,
+        4503599627370496.5, 9007199254740993.0, 72057594037927936.0, -0.001, -0.004, -0.006,
+        0.285, 1.115, 5.015, 1.45, 1.55, 1.65, 10.5, 11.5, 0.3, 0.7, 1e-320,
+    };
+
+    private static final long[] LONGS = {
+        0, 1, -1, 9, 10, 12, 99, 100, 999, 1000, 1234567, -987654321, 1500, 2500, 12345, 15, 25, 125,
+        Long.MAX_VALUE, Long.MIN_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE, 1000000000000L,
+    };
+
+    /// The US English symbols as Java 8 has them: on HotSpot the JDK's, with
+    /// the one symbol CLDR changed set back; on ParparVM JavaAPI's own.
+    private static DecimalFormatSymbols usSymbols() {
+        DecimalFormatSymbols s = new DecimalFormatSymbols(US);
+        if (Bulk.onHotSpot()) {
+            s.setNaN(JAVA8_NAN);
+        }
+        return s;
+    }
+
+    private static DecimalFormat format(String pattern) {
+        return new DecimalFormat(pattern, usSymbols());
+    }
+
+    /// Prints `key=value`, the key escaped as the value is: a pattern here
+    /// carries characters outside ASCII. A key that starts with the `[` of
+    /// a pattern gets a prefix, because the test drops every line starting
+    /// with `[` as a runtime diagnostic.
+    private static void p(String key, Object value) {
+        Bulk.p(Bulk.esc(key.startsWith("[") ? "p" + key : key), value);
+    }
+
+    private static String simpleName(Object o) {
+        String n = o.getClass().getName();
+        return n.substring(n.lastIndexOf('.') + 1);
+    }
+
+    /// The pattern's meaning as `toPattern` and a formatted value, or
+    /// `rejected`.
+    private static String malformed(String pattern) {
+        try {
+            DecimalFormat f = format(pattern);
+            // Accepted: then it has to mean the same thing.
+            return f.toPattern() + " " + f.format(-1234.5678);
+        } catch (IllegalArgumentException e) {
+            return "rejected";
+        }
+    }
+
+    /// US English with every symbol a format writes changed.
+    private static DecimalFormatSymbols changedSymbols() {
+        DecimalFormatSymbols symbols = usSymbols();
+        symbols.setDecimalSeparator(',');
+        symbols.setGroupingSeparator('.');
+        symbols.setMinusSign('~');
+        symbols.setPercent('P');
+        symbols.setCurrencySymbol("EUR");
+        symbols.setExponentSeparator("x10^");
+        symbols.setInfinity("inf");
+        symbols.setNaN("nan");
+        return symbols;
+    }
+
+    /// java.util.Random's generator, written out so that the values do not
+    /// depend on the Random under test elsewhere.
+    private static final class DecimalFormatRandom {
+        private long seed;
+
+        DecimalFormatRandom(long seed) {
+            this.seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1);
+        }
+
+        private int next(int bits) {
+            seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
+            return (int) (seed >>> (48 - bits));
+        }
+
+        long nextLong() {
+            return ((long) next(32) << 32) + next(32);
+        }
+
+        double nextDouble() {
+            return (((long) next(26) << 27) + next(27)) * 0x1.0p-53;
+        }
+
+        int nextInt(int bound) {
+            int r = next(31);
+            int m = bound - 1;
+            if ((bound & m) == 0) {
+                return (int) ((bound * (long) r) >> 31);
+            }
+            for (int u = r; u - (r = u % bound) + m < 0; u = next(31)) {
+                // rejected: retry
+            }
+            return r;
+        }
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("DecimalFormat.formatsDoublesLikeTheJdk", () -> {
+            for (String pattern : PATTERNS) {
+                DecimalFormat f = format(pattern);
+                for (double value : DOUBLES) {
+                    p("[" + pattern + "] " + value, f.format(value));
+                }
+            }
+        });
+        Bulk.check("DecimalFormat.formatsLongsLikeTheJdk", () -> {
+            for (String pattern : PATTERNS) {
+                DecimalFormat f = format(pattern);
+                for (long value : LONGS) {
+                    p("[" + pattern + "] " + value + "L", f.format(value));
+                }
+            }
+        });
+        // Random values across the whole exponent range, and values built to
+        // sit on or next to a rounding boundary, where half-even and the
+        // binary representation both matter.
+        Bulk.check("DecimalFormat.formatsRandomDoublesLikeTheJdk", () -> {
+            String[] patterns = {
+                "0", "0.0", "0.00", "0.000", "#.####", "#,##0.00", "0.###E0", "##0.##E0", "0.00%", "0.0000000",
+            };
+            DecimalFormatRandom random = new DecimalFormatRandom(20240607L);
+            for (String pattern : patterns) {
+                DecimalFormat f = format(pattern);
+                for (int i = 0; i < 4000; i++) {
+                    double value;
+                    int kind = i % 4;
+                    if (kind == 0) {
+                        value = Double.longBitsToDouble(random.nextLong());
+                    } else if (kind == 1) {
+                        value = (random.nextDouble() - 0.5) * 2000;
+                    } else if (kind == 2) {
+                        // k / 1000 and k / 8: decimal halves, some exact in binary.
+                        value = random.nextInt(200000) / (i % 8 < 4 ? 1000.0 : 8.0);
+                    } else {
+                        value = (random.nextInt(2000) + 0.5) / Math.pow(10, random.nextInt(6));
+                    }
+                    p("[" + pattern + "] " + value, f.format(value));
+                }
+            }
+        });
+        Bulk.check("DecimalFormat.reproducesPatternsLikeTheJdk", () -> {
+            for (String pattern : PATTERNS) {
+                if (pattern.length() == 0) {
+                    // The empty pattern allows any number of fraction digits,
+                    // and the JDK runs out of memory writing a '#' for each.
+                    continue;
+                }
+                p("[" + pattern + "] toPattern", format(pattern).toPattern());
+            }
+        });
+        Bulk.check("DecimalFormat.readsPatternSettingsLikeTheJdk", () -> {
+            for (String pattern : PATTERNS) {
+                DecimalFormat m = format(pattern);
+                p("[" + pattern + "] settings", m.getMinimumIntegerDigits() + "/" + m.getMaximumIntegerDigits()
+                        + "/" + m.getMinimumFractionDigits() + "/" + m.getMaximumFractionDigits() + "/"
+                        + m.isGroupingUsed() + "/" + m.getGroupingSize() + "/" + m.getMultiplier() + "/"
+                        + m.isDecimalSeparatorAlwaysShown() + "/" + m.getPositivePrefix() + "/"
+                        + m.getPositiveSuffix() + "/" + m.getNegativePrefix() + "/" + m.getNegativeSuffix());
+            }
+        });
+        Bulk.check("DecimalFormat.rejectsTheMalformedPatternsTheJdkRejects", () -> {
+            String[] bad = {
+                "0.0.0", "#0#", "0#.0", "0.#0", "0E", "E0", "0E0E0", "#,", "0;0;0", "0'", "%%0", "0;",
+                "0.0#0", "#,##0.00;", ";0", "0%;0%%",
+            };
+            for (String pattern : bad) {
+                p("[" + pattern + "]", malformed(pattern));
+            }
+        });
+        // Text between the digits of a pattern: after Java 8 the JDK reads it
+        // as a suffix of both subpatterns, where Java 8 (and JavaAPI) end the
+        // positive subpattern's digits at it. The Java 8 answers, taken from
+        // Java 8.
+        Bulk.cn1Only("DecimalFormat.readsTextBetweenDigitsAsJava8", () -> {
+            Bulk.expectEquals("#0.00x;#0.00 1234.57", malformed("0.0x0"), "0.0x0");
+            Bulk.expectEquals("#00x;y#00 y1235", malformed("0x0;y0z0"), "0x0;y0z0");
+            Bulk.expectEquals("00E0x;00E0 12E2", malformed("0E0x0"), "0E0x0");
+            Bulk.expectEquals("#0.0#x;#0.0# 1234.57", malformed("0.0x#"), "0.0x#");
+        });
+        Bulk.check("DecimalFormat.parsesLikeTheJdk", () -> {
+            String[] patterns = {
+                "#,##0.###", "0.00", "#", "#%", "0.0%", "#,##0.00;(#,##0.00)", "$#,##0.00", "0.###E0",
+                "0 'units'", "#" + PER_MILLE, "-0;+0", "#,####.##",
+            };
+            String[] texts = {
+                "0", "1", "12", "-12", "1,234", "1,234.5", "1,234.50", "-1,234.5", "12.0", "12.50", ".5", "0.5",
+                "-0", "-0.0", "1.", "1,", "1,234,", "1,,2", "abc", "", " 1", "1 ", "1abc", "1.2.3", "--1",
+                "50%", "12.5%", "200%", "150.0%", "-5%", "(1,234.50)", "(12", "$5.00", "-$5.00", "$", "$x",
+                "1E3", "1.5E3", "1E-3", "1E", "1Ex", "-1.25E2", "1e3", "5 units", "5 unit", "5", "+5", "-5",
+                "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809",
+                "123456789012345678901234567890", "0.000", "000123", "00.50", "1" + PER_MILLE,
+                "1500" + PER_MILLE, "1,2,3", "1.5E400", "1.0E-400", "0E5", "1,234E2",
+                String.valueOf((char) 0x221E), "-" + (char) 0x221E, String.valueOf((char) 0xFFFD), "12,34.5",
+            };
+            for (String pattern : patterns) {
+                for (int integerOnly = 0; integerOnly < 2; integerOnly++) {
+                    DecimalFormat f = format(pattern);
+                    f.setParseIntegerOnly(integerOnly == 1);
+                    for (String text : texts) {
+                        for (int from = 0; from < 2; from++) {
+                            String input = from == 0 ? text : "x" + text;
+                            ParsePosition position = new ParsePosition(from);
+                            Number n = f.parse(input, position);
+                            String value = n == null ? "null" : simpleName(n) + ":" + n;
+                            p("[" + pattern + (integerOnly == 1 ? ",integerOnly" : "") + "] \"" + input
+                                    + "\"@" + from, value + " index=" + position.getIndex() + " error="
+                                    + position.getErrorIndex());
+                        }
+                    }
+                }
+            }
+        });
+        Bulk.check("DecimalFormat.parseOfAStringThrowsWhereTheJdkThrows", () -> {
+            p("parse", NumberFormat.getInstance(US).parse("1,234.5"));
+            try {
+                NumberFormat.getInstance(US).parse("abc");
+                p("abc", "parsed");
+            } catch (ParseException e) {
+                p("offset", e.getErrorOffset());
+                p("message", e.getMessage());
+            }
+        });
+        Bulk.check("DecimalFormat.factoriesFormatLikeTheJdk", () -> {
+            double[] values = {0, 1, -1, 1234567.891, 0.5, 0.125, 0.126, -0.5, 1.5, 2.5, 1e10, 0.0049, 12.345};
+            for (double v : values) {
+                p("getInstance " + v, NumberFormat.getInstance(US).format(v));
+                p("getNumberInstance " + v, NumberFormat.getNumberInstance(US).format(v));
+                p("getIntegerInstance " + v, NumberFormat.getIntegerInstance(US).format(v));
+                p("getPercentInstance " + v, NumberFormat.getPercentInstance(US).format(v));
+                if (v >= 0) {
+                    p("getCurrencyInstance " + v, NumberFormat.getCurrencyInstance(US).format(v));
+                }
+            }
+        });
+        // JDK 8's locale data writes a negative US amount in parentheses,
+        // `($1.50)`; later JDKs, with CLDR data, write `-$1.50`, as JavaAPI
+        // does.
+        Bulk.check("DecimalFormat.negativeCurrencyUsesAMinusSign", () -> {
+            p("1.5", NumberFormat.getCurrencyInstance(US).format(-1.5));
+            p("1234.567", NumberFormat.getCurrencyInstance(US).format(-1234.567));
+        });
+        Bulk.check("DecimalFormat.settersBehaveLikeTheJdk", () -> {
+            DecimalFormat f = format("#,##0.###");
+            f.setMaximumFractionDigits(1);
+            p("maxFraction", f.format(1234.56));
+            f.setMinimumFractionDigits(4);
+            p("minFraction", f.format(1234.56));
+            p("getMaxFraction", f.getMaximumFractionDigits());
+            f.setGroupingUsed(false);
+            p("ungrouped", f.format(1234567));
+            f.setMinimumIntegerDigits(10);
+            p("minInteger", f.format(42));
+            f.setMaximumIntegerDigits(2);
+            p("maxInteger", f.format(1997));
+            p("maxIntegerFraction", f.format(1997.5));
+            p("getMinInteger", f.getMinimumIntegerDigits());
+            f.setGroupingUsed(true);
+            f.setGroupingSize(2);
+            f.setMaximumIntegerDigits(20);
+            f.setMinimumIntegerDigits(1);
+            p("groupingSize", f.format(1234567));
+            p("pattern", f.toPattern());
+            f.setPositivePrefix("+");
+            f.setNegativeSuffix(" CR");
+            f.setDecimalSeparatorAlwaysShown(true);
+            p("affixes", f.format(5));
+            p("negativeAffixes", f.format(-5));
+            p("affixPattern", f.toPattern());
+            f.setMultiplier(7);
+            p("times7", f.format(6));
+            p("times7Half", f.format(0.5));
+            p("times7Max", f.format(Long.MAX_VALUE));
+            f.setMultiplier(-3);
+            p("timesMinus3", f.format(6));
+            p("timesMinus3Negative", f.format(-2.5));
+        });
+        Bulk.check("DecimalFormat.formatsObjectsByTheirType", () -> {
+            NumberFormat f = NumberFormat.getInstance(US);
+            Object[] numbers = {
+                Integer.valueOf(1234), Long.valueOf(-99999L), Short.valueOf((short) 7), Byte.valueOf((byte) -3),
+                Double.valueOf(1234.5678), Float.valueOf(0.5f),
+            };
+            for (Object number : numbers) {
+                p(simpleName(number) + " " + number, f.format(number));
+            }
+            Bulk.pThrown("notANumber", IllegalArgumentException.class, () -> f.format("not a number"));
+        });
+        Bulk.check("DecimalFormat.reportsFieldPositionsLikeTheJdk", () -> {
+            String[] patterns = {"#,##0.00", "0.###E0", "$0.0#", "#"};
+            double[] values = {1234.5, -0.25, 7, 1e9};
+            for (String pattern : patterns) {
+                for (double value : values) {
+                    for (int field = 0; field < 2; field++) {
+                        FieldPosition position = new FieldPosition(field);
+                        String text = format(pattern).format(value, new StringBuffer("ab"), position).toString();
+                        p(pattern + " " + value + " field " + field, text + " " + position.getBeginIndex() + "-"
+                                + position.getEndIndex());
+                    }
+                }
+            }
+        });
+        Bulk.check("DecimalFormat.symbolsChangeTheOutput", () -> {
+            DecimalFormatSymbols symbols = changedSymbols();
+            // The currency pattern is in symbolsChangeTheCurrencyOutput.
+            String[] patterns = {"#,##0.00", "0.0%", "0.##E0"};
+            double[] values = {1234567.891, -0.5, 0.000123, Double.NaN, Double.NEGATIVE_INFINITY};
+            for (String pattern : patterns) {
+                DecimalFormat f = new DecimalFormat(pattern, symbols);
+                for (double value : values) {
+                    p(pattern + " " + value, f.format(value));
+                }
+                String text = f.format(-1234.5);
+                p(pattern + " parse " + text, f.parse(text, new ParsePosition(0)));
+            }
+            // The format holds its own copy, as the JDK's does.
+            DecimalFormat f = new DecimalFormat("0.0", symbols);
+            symbols.setDecimalSeparator('!');
+            p("copied", f.format(1.5));
+            DecimalFormatSymbols handedOut = f.getDecimalFormatSymbols();
+            handedOut.setDecimalSeparator('?');
+            p("handedOutCopy", f.format(1.5));
+            f.setDecimalFormatSymbols(handedOut);
+            p("set", f.format(1.5));
+        });
+        // After Java 8 the JDK groups a currency pattern with a monetary
+        // grouping separator of its own, which setGroupingSeparator leaves
+        // alone; Java 8 (and JavaAPI) group it with the grouping separator.
+        // The Java 8 answers, taken from Java 8.
+        Bulk.cn1Only("DecimalFormat.symbolsChangeTheCurrencyOutput", () -> {
+            DecimalFormat f = new DecimalFormat(CURRENCY + " #,##0.00", changedSymbols());
+            Bulk.expectEquals("EUR 1.234.567.89", f.format(1234567.891), "1234567.891");
+            Bulk.expectEquals("~EUR 0.50", f.format(-0.5), "-0.5");
+            Bulk.expectEquals("EUR 0.00", f.format(0.000123), "0.000123");
+            Bulk.expectEquals("nan", f.format(Double.NaN), "NaN");
+            Bulk.expectEquals("~EUR inf", f.format(Double.NEGATIVE_INFINITY), "-Infinity");
+            Bulk.expectEquals("-1.234", String.valueOf(f.parse("~EUR 1.234.50", new ParsePosition(0))), "parse");
+        });
+        Bulk.check("DecimalFormat.cloneIsAnIndependentEqualCopy", () -> {
+            DecimalFormat original = format("#,##0.00;(#)");
+            Object copy = original.clone();
+            p("isDecimalFormat", copy instanceof DecimalFormat);
+            p("notSame", original != copy);
+            p("equal", original.equals(copy));
+            p("sameHash", original.hashCode() == copy.hashCode());
+            DecimalFormat cloned = (DecimalFormat) copy;
+            p("sameFormat", original.format(-1234.5).equals(cloned.format(-1234.5)));
+            p("samePattern", original.toPattern().equals(cloned.toPattern()));
+            cloned.setMaximumFractionDigits(0);
+            p("equalAfterChange", original.equals(cloned));
+            p("originalKept", original.format(1234.5));
+            Object symbolsCopy = usSymbols().clone();
+            p("symbolsEqual", usSymbols().equals(symbolsCopy));
+        });
+        Bulk.check("DecimalFormat.parseFailureLeavesThePositionAlone", () -> {
+            ParsePosition position = new ParsePosition(2);
+            p("parsed", format("0.00").parse("ab?", position));
+            p("index", position.getIndex());
+            p("error", position.getErrorIndex());
+        });
+        // With no platform to say what the device's locale writes -- the
+        // bulk host answers no locale symbols, as before Codename One is
+        // initialized -- every locale gets the US English symbols. The JDK
+        // answers French symbols here.
+        Bulk.cn1Only("DecimalFormat.symbolsFallBackToUsEnglishWithoutADisplay", () -> {
+            DecimalFormatSymbols symbols = new DecimalFormatSymbols(new Locale("fr", "FR"));
+            Bulk.expectEquals(Character.valueOf('.'), Character.valueOf(symbols.getDecimalSeparator()), "decimal");
+            Bulk.expectEquals(Character.valueOf(','), Character.valueOf(symbols.getGroupingSeparator()), "grouping");
+            Bulk.expectEquals("$", symbols.getCurrencySymbol(), "currency");
+            Bulk.expectEquals(new DecimalFormatSymbols(US), symbols, "equal to en_US");
+        });
+        // JavaAPI's US English symbols are Java 8's; the HotSpot run cannot
+        // say so, since its JDK takes CLDR's.
+        Bulk.cn1Only("DecimalFormat.java8UsSymbols", () -> {
+            DecimalFormatSymbols symbols = new DecimalFormatSymbols(US);
+            Bulk.expectEquals(JAVA8_NAN, symbols.getNaN(), "NaN");
+            Bulk.expectEquals(String.valueOf((char) 0x221E), symbols.getInfinity(), "infinity");
+            Bulk.expectEquals("E", symbols.getExponentSeparator(), "exponent");
+            Bulk.expectEquals(JAVA8_NAN, NumberFormat.getInstance(US).format(Double.NaN), "NaN formatted");
+        });
+        hostChecks();
+    }
+
+    /// A device that writes "1.234.567,5" and prices in euros.
+    private static final class DecimalFormatGermanDevice extends BulkHost {
+        @Override
+        public String[] localeNumberSymbols() {
+            return new String[] {",", ".", "EUR"};
+        }
+    }
+
+    /// A device that writes a decimal comma and does not group.
+    private static final class DecimalFormatUngroupedDevice extends BulkHost {
+        @Override
+        public String[] localeNumberSymbols() {
+            return new String[] {",", null, null};
+        }
+    }
+
+    /// A platform whose localization fails outright.
+    private static final class DecimalFormatBrokenDevice extends BulkHost {
+        @Override
+        public String[] localeNumberSymbols() {
+            throw new IllegalStateException("no localization");
+        }
+    }
+
+    /// JavaAPI's `DecimalFormatSymbols` takes the device locale's separators
+    /// and currency from the installed `JdkHost`: Codename One's own, so
+    /// these run on ParparVM only. The harness reinstalls its host after each.
+    private static void hostChecks() {
+        Bulk.cn1Only("DecimalFormatSymbolsHost.deviceSymbolsComeFromTheHost", () -> {
+            JdkHost.install(new DecimalFormatGermanDevice());
+            DecimalFormatSymbols symbols = new DecimalFormatSymbols(new Locale("de", "DE"));
+            Bulk.expectEquals(Character.valueOf(','), Character.valueOf(symbols.getDecimalSeparator()), "decimal");
+            Bulk.expectEquals(Character.valueOf(','), Character.valueOf(symbols.getMonetaryDecimalSeparator()),
+                    "monetary decimal");
+            Bulk.expectEquals(Character.valueOf('.'), Character.valueOf(symbols.getGroupingSeparator()), "grouping");
+            Bulk.expectEquals("EUR", symbols.getCurrencySymbol(), "currency");
+            Bulk.expectEquals("1.234.567,5", new DecimalFormat("#,##0.0", symbols).format(1234567.5), "format");
+            Bulk.expectEquals("1.234,567", NumberFormat.getNumberInstance(new Locale("de", "DE")).format(1234.567),
+                    "number instance");
+        });
+        Bulk.cn1Only("DecimalFormatSymbolsHost.usEnglishIsNeverAskedOfTheHost", () -> {
+            JdkHost.install(new DecimalFormatGermanDevice());
+            DecimalFormatSymbols symbols = new DecimalFormatSymbols(new Locale("en", "US"));
+            Bulk.expectEquals(Character.valueOf('.'), Character.valueOf(symbols.getDecimalSeparator()), "decimal");
+            Bulk.expectEquals(Character.valueOf(','), Character.valueOf(symbols.getGroupingSeparator()), "grouping");
+            Bulk.expectEquals("$", symbols.getCurrencySymbol(), "currency");
+        });
+        Bulk.cn1Only("DecimalFormatSymbolsHost.aDecimalCommaNeverGroupsWithAComma", () -> {
+            JdkHost.install(new DecimalFormatUngroupedDevice());
+            DecimalFormatSymbols symbols = new DecimalFormatSymbols(new Locale("fr", "FR"));
+            Bulk.expectEquals(Character.valueOf(','), Character.valueOf(symbols.getDecimalSeparator()), "decimal");
+            Bulk.expectEquals(Character.valueOf('.'), Character.valueOf(symbols.getGroupingSeparator()), "grouping");
+            Bulk.expectEquals("$", symbols.getCurrencySymbol(), "currency");
+        });
+        Bulk.cn1Only("DecimalFormatSymbolsHost.aFailingHostLeavesUsEnglish", () -> {
+            JdkHost.install(new DecimalFormatBrokenDevice());
+            Bulk.expectEquals(new DecimalFormatSymbols(new Locale("en", "US")),
+                    new DecimalFormatSymbols(new Locale("fr", "FR")), "fallback");
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ExecutorsChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ExecutorsChecks.java
new file mode 100644
index 00000000000..9bae7e2e149
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ExecutorsChecks.java
@@ -0,0 +1,902 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+/// The executor services of java.util.concurrent, on real threads.
+///
+/// Every pool a check starts is shut down and waited for before the check
+/// ends, and every wait is bounded generously, so that a loaded machine
+/// changes how long a check takes and never what it prints.
+public final class ExecutorsChecks {
+    private static final Runnable NOTHING = () -> {
+    };
+
+    private ExecutorsChecks() {
+    }
+
+    /// Shuts `pool` down and prints whether it stopped.
+    private static void terminate(String key, ExecutorService pool) throws InterruptedException {
+        pool.shutdown();
+        Bulk.p(key + ".isShutdown", pool.isShutdown());
+        Bulk.p(key + ".awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+        Bulk.p(key + ".isTerminated", pool.isTerminated());
+    }
+
+    /// Stops `pool` for good, whatever the check printed.
+    private static void stop(ExecutorService pool) throws InterruptedException {
+        pool.shutdownNow();
+        pool.awaitTermination(20, TimeUnit.SECONDS);
+    }
+
+    /// Waits up to 30 seconds for `runs` to reach `target`.
+    private static boolean waitForRuns(AtomicInteger runs, int target) throws InterruptedException {
+        long deadline = System.currentTimeMillis() + 30000;
+        while (runs.get() < target && System.currentTimeMillis() < deadline) {
+            Thread.sleep(10);
+        }
+        return runs.get() >= target;
+    }
+
+    private static Callable<String> answering(String value, AtomicBoolean ran) {
+        return () -> {
+            ran.set(true);
+            return value;
+        };
+    }
+
+    /// Waits until `flag` is set, for at most 30 seconds, ignoring every
+    /// interrupt (and keeping none of them).
+    private static void awaitIgnoringInterrupts(AtomicBoolean flag) {
+        long deadline = System.currentTimeMillis() + 30000;
+        while (!flag.get() && System.currentTimeMillis() < deadline) {
+            Thread.interrupted();
+            Thread.yield();
+        }
+        Thread.interrupted();
+    }
+
+    /// What `work` answers, computed on a thread of its own that has ended
+    /// by the time this returns.
+    ///
+    /// Every object a collection check watches is made, and every weak
+    /// reference to one is read, this way. ParparVM scans native stacks
+    /// conservatively: a stale machine word left on a living thread's stack by
+    /// a call that once held the object keeps it marked, which the JDK's
+    /// contract allows (a weakly reachable object MAY be cleared) and which
+    /// made these checks answer false on ParparVM for an object nothing
+    /// reached. A thread that has ended leaves no stack to scan. (Measured: the
+    /// same plain `Object` was never cleared when made on the check's thread,
+    /// and was cleared when made on one that ended.)
+    @SuppressWarnings("unchecked")
+    private static <T> T offThread(final Callable<T> work) throws Exception {
+        final Object[] out = new Object[1];
+        final Throwable[] failure = new Throwable[1];
+        Thread t = new Thread(() -> {
+            try {
+                out[0] = work.call();
+            } catch (Throwable e) {
+                failure[0] = e;
+            }
+        });
+        t.start();
+        t.join();
+        if (failure[0] != null) {
+            throw new RuntimeException(failure[0]);
+        }
+        return (T) out[0];
+    }
+
+    /// How many of `refs` still answer a referent, read off this thread.
+    private static int uncleared(final List<? extends WeakReference<?>> refs) throws Exception {
+        Integer left = offThread(() -> {
+            int n = 0;
+            for (WeakReference<?> r : refs) {
+                if (r.get() != null) {
+                    n++;
+                }
+            }
+            return Integer.valueOf(n);
+        });
+        return left.intValue();
+    }
+
+    /// How many of `refs` are not cleared after asking the collector for up
+    /// to about twelve seconds.
+    ///
+    /// The references are read only after several collections in a row: on
+    /// ParparVM a read marks its referent as in use for the next collection,
+    /// which then keeps it (see cn1GcProcessReferences), so reading after
+    /// every one would keep the referent forever.
+    private static int notCollected(List<? extends WeakReference<?>> refs) throws Exception {
+        int left = uncleared(refs);
+        for (int round = 0; round < 40 && left > 0; round++) {
+            for (int i = 0; i < 4; i++) {
+                System.gc();
+                Thread.sleep(75);
+            }
+            left = uncleared(refs);
+        }
+        return left;
+    }
+
+    /// True once `ref` is cleared, asking the collector the same way.
+    private static boolean collected(WeakReference<?> ref) throws Exception {
+        return notCollected(Collections.singletonList(ref)) == 0;
+    }
+
+    /// Schedules, an hour out, a task whose result is a large array, and
+    /// answers a weak reference to that array: in a method of its own so
+    /// that no frame of the check holds it.
+    private static WeakReference<Object> scheduleHolding(ScheduledExecutorService pool) {
+        final Object held = new byte[1 << 16];
+        ScheduledFuture<Object> future = pool.schedule(() -> held, 1, TimeUnit.HOURS);
+        Bulk.p("holding.isDone", future.isDone());
+        return new WeakReference<Object>(held);
+    }
+
+    private static WeakReference<Object> completedOrTimeout() {
+        CompletableFuture<String> failing = new CompletableFuture<String>();
+        Bulk.p("orTimeout.same", failing == failing.orTimeout(1, TimeUnit.HOURS));
+        Bulk.p("orTimeout.complete", failing.complete("in time"));
+        return new WeakReference<Object>(failing);
+    }
+
+    private static WeakReference<Object> cancelledCompleteOnTimeout() {
+        CompletableFuture<String> defaulting = new CompletableFuture<String>();
+        defaulting.completeOnTimeout("late", 1, TimeUnit.HOURS);
+        Bulk.p("completeOnTimeout.cancel", defaulting.cancel(false));
+        return new WeakReference<Object>(defaulting);
+    }
+
+    /// Makes 1000 timeouts of an hour, completes every future in time, and
+    /// answers weak references to the futures: none of them may stay held
+    /// by a wait nobody needs any more.
+    private static List<WeakReference<Object>> manyCompletedTimeouts(int threadsBefore) {
+        List<CompletableFuture<String>> all = new ArrayList<CompletableFuture<String>>();
+        for (int i = 0; i < 500; i++) {
+            all.add(new CompletableFuture<String>().orTimeout(1, TimeUnit.HOURS));
+            all.add(new CompletableFuture<String>().completeOnTimeout("late", 1, TimeUnit.HOURS));
+        }
+        Bulk.p("oneThreadWaitsForAll", Thread.activeCount() <= threadsBefore + 1);
+        int completed = 0;
+        List<WeakReference<Object>> refs = new ArrayList<WeakReference<Object>>();
+        for (CompletableFuture<String> f : all) {
+            if (f.complete("in time")) {
+                completed++;
+            }
+            refs.add(new WeakReference<Object>(f));
+        }
+        Bulk.p("completedInTime", completed);
+        return refs;
+    }
+
+    /// Schedules, at a delay `pool.shutdownNow()` will drop, a task holding
+    /// a large array, and answers a weak reference to the array.
+    private static WeakReference<Object> scheduleDroppedPayload(ScheduledExecutorService pool) {
+        final Object held = new byte[1 << 16];
+        pool.schedule(() -> held, 1, TimeUnit.HOURS);
+        return new WeakReference<Object>(held);
+    }
+
+    /// An executor that runs each task on the calling thread: only
+    /// `AbstractExecutorService`'s own `submit` and `FutureTask` between it
+    /// and the task.
+    private static final class DirectExecutorService extends AbstractExecutorService {
+        private boolean shutdown;
+
+        @Override
+        public void execute(Runnable command) {
+            if (shutdown) {
+                throw new RejectedExecutionException();
+            }
+            command.run();
+        }
+
+        @Override
+        public void shutdown() {
+            shutdown = true;
+        }
+
+        @Override
+        public List<Runnable> shutdownNow() {
+            shutdown = true;
+            return new ArrayList<Runnable>();
+        }
+
+        @Override
+        public boolean isShutdown() {
+            return shutdown;
+        }
+
+        @Override
+        public boolean isTerminated() {
+            return shutdown;
+        }
+
+        @Override
+        public boolean awaitTermination(long timeout, TimeUnit unit) {
+            return true;
+        }
+    }
+
+    /// Runs the group.
+    public static void run() {
+        // Was ExecutorIntegrationTest, disabled for a crash in the one-off
+        // harness it ran in; the two programs it never ran are this check.
+        Bulk.check("Executors.aSubclassOfAbstractExecutorServiceRunsWhatItIsSubmitted", () -> {
+            ExecutorService executor = new DirectExecutorService();
+            Future<String> f1 = executor.submit(() -> "Hello");
+            Future<String> f2 = executor.submit(() -> "World");
+            Bulk.p("callables", f1.get() + " " + f2.get());
+            final AtomicInteger counter = new AtomicInteger(0);
+            Runnable task = () -> counter.set(counter.get() + 1);
+            Future<?> r1 = executor.submit(task);
+            Future<?> r2 = executor.submit(task);
+            Bulk.p("runnableResults", String.valueOf(r1.get()) + "/" + r2.get());
+            Bulk.p("counter", counter.get());
+            Bulk.p("done", r1.isDone() + "/" + r2.isDone());
+            executor.shutdown();
+            Bulk.p("isShutdown", executor.isShutdown());
+            Bulk.pThrown("afterShutdown", RejectedExecutionException.class, () -> executor.submit(task));
+        });
+        Bulk.check("Executors.aSingleThreadRunsTasksInOrderOffTheSubmittingThread", () -> {
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                final List<Integer> order = Collections.synchronizedList(new ArrayList<Integer>());
+                final Thread caller = Thread.currentThread();
+                final AtomicBoolean onCaller = new AtomicBoolean();
+                List<Future<Integer>> futures = new ArrayList<Future<Integer>>();
+                for (int i = 0; i < 50; i++) {
+                    final int n = i;
+                    futures.add(pool.submit(() -> {
+                        order.add(Integer.valueOf(n));
+                        onCaller.compareAndSet(false, Thread.currentThread() == caller);
+                        return Integer.valueOf(n * 2);
+                    }));
+                }
+                StringBuilder values = new StringBuilder();
+                boolean allDone = true;
+                boolean noneCancelled = true;
+                for (int i = 0; i < 50; i++) {
+                    values.append(futures.get(i).get(20, TimeUnit.SECONDS)).append(',');
+                    allDone &= futures.get(i).isDone();
+                    noneCancelled &= !futures.get(i).isCancelled();
+                }
+                Bulk.p("values", values.toString());
+                Bulk.p("allDone", allDone);
+                Bulk.p("noneCancelled", noneCancelled);
+                Bulk.p("order", order);
+                Bulk.p("ranOnCaller", onCaller.get());
+                Bulk.p("terminatedEarly", pool.isTerminated());
+                terminate("pool", pool);
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aFailingTaskSurfacesAsAnExecutionException", () -> {
+            ExecutorService pool = Executors.newFixedThreadPool(2);
+            try {
+                final IllegalStateException boom = new IllegalStateException("boom");
+                Future<String> failed = pool.submit(() -> {
+                    throw boom;
+                });
+                try {
+                    failed.get(20, TimeUnit.SECONDS);
+                    Bulk.p("get", "returned");
+                } catch (ExecutionException expected) {
+                    Bulk.p("causeIsTheThrown", expected.getCause() == boom);
+                }
+                Bulk.p("isDone", failed.isDone());
+                // The worker survives a task that throws.
+                Bulk.p("after", pool.submit(Executors.callable(NOTHING, "after")).get(20, TimeUnit.SECONDS));
+                terminate("pool", pool);
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aPoolRunsEveryTaskAndInvokeAllWaitsForThem", () -> {
+            ExecutorService pool = Executors.newCachedThreadPool();
+            try {
+                final AtomicInteger ran = new AtomicInteger();
+                List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
+                for (int i = 0; i < 40; i++) {
+                    final int n = i;
+                    tasks.add(() -> {
+                        ran.incrementAndGet();
+                        if (n == 13) {
+                            throw new IllegalArgumentException("unlucky");
+                        }
+                        return Integer.valueOf(n);
+                    });
+                }
+                List<Future<Integer>> futures = pool.invokeAll(tasks);
+                Bulk.p("ran", ran.get());
+                Bulk.p("size", futures.size());
+                StringBuilder values = new StringBuilder();
+                boolean allDone = true;
+                for (int i = 0; i < 40; i++) {
+                    allDone &= futures.get(i).isDone();
+                    try {
+                        values.append(futures.get(i).get()).append(',');
+                    } catch (ExecutionException e) {
+                        values.append("failed:").append(e.getCause().getMessage()).append(',');
+                    }
+                }
+                Bulk.p("allDone", allDone);
+                Bulk.p("values", values.toString());
+                final AtomicBoolean plain = new AtomicBoolean();
+                pool.submit(() -> plain.set(true)).get(20, TimeUnit.SECONDS);
+                Bulk.p("plain", plain.get());
+                terminate("pool", pool);
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.shutdownRefusesNewTasksButFinishesAcceptedOnes", () -> {
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                final AtomicInteger ran = new AtomicInteger();
+                for (int i = 0; i < 20; i++) {
+                    pool.execute(ran::incrementAndGet);
+                }
+                pool.shutdown();
+                Bulk.pThrown("executeAfterShutdown", RejectedExecutionException.class,
+                        () -> pool.execute(() -> ran.addAndGet(1000)));
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("ran", ran.get());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.shutdownNowHandsBackWhatNeverStarted", () -> {
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                final AtomicBoolean release = new AtomicBoolean();
+                final AtomicBoolean started = new AtomicBoolean();
+                // The running task ignores the interrupt cancel(true) sends it, so
+                // the worker stays busy until the check releases it: on the JDK
+                // an interruptible wait freed the worker at once, and it took the
+                // queued task before shutdownNow() could hand it back.
+                Future<String> running = pool.submit(() -> {
+                    started.set(true);
+                    awaitIgnoringInterrupts(release);
+                    return "finished";
+                });
+                for (int i = 0; i < 10000 && !started.get(); i++) {
+                    Thread.sleep(2);
+                }
+                Bulk.p("started", started.get());
+                final AtomicBoolean queuedRan = new AtomicBoolean();
+                Future<String> queued = pool.submit(() -> {
+                    queuedRan.set(true);
+                    return "queued";
+                });
+                // The worker is busy with the first task.
+                Bulk.pThrown("queuedGet", TimeoutException.class, () -> queued.get(50, TimeUnit.MILLISECONDS));
+                // The JDK interrupts a running FutureTask on cancel(true) and answers true.
+                Bulk.p("cancelRunning", running.cancel(true));
+                Bulk.p("runningIsCancelled", running.isCancelled());
+                List<Runnable> dropped = pool.shutdownNow();
+                Bulk.p("dropped", dropped.size());
+                // The dropped task is handed back as the very future submitted,
+                // neither cancelled nor completed.
+                Bulk.p("droppedIsTheFuture", dropped.contains(queued));
+                Bulk.p("queuedIsCancelled", queued.isCancelled());
+                Bulk.p("queuedIsDone", queued.isDone());
+                release.set(true);
+                Bulk.pThrown("runningGet", CancellationException.class, () -> running.get(20, TimeUnit.SECONDS));
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("queuedRan", queuedRan.get());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.anUnboundedAwaitTerminationWaits", () -> {
+            // A deadline of now plus Long.MAX_VALUE overflowed into the past
+            // and the wait answered false at once.
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                pool.execute(() -> {
+                    try {
+                        Thread.sleep(200);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                });
+                pool.shutdown();
+                Bulk.p("awaitTermination", pool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS));
+                Bulk.p("isTerminated", pool.isTerminated());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.theArgumentsAreChecked", () -> {
+            Bulk.pThrown("fixed0", IllegalArgumentException.class, () -> Executors.newFixedThreadPool(0));
+            Bulk.pThrown("fixedNegative", IllegalArgumentException.class, () -> Executors.newFixedThreadPool(-1));
+            ExecutorService pool = Executors.newSingleThreadExecutor();
+            try {
+                Bulk.pThrown("executeNull", NullPointerException.class, () -> pool.execute(null));
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.anOrderlyShutdownStillRunsDelayedWorkAndCancelsWhatRepeats", () -> {
+            // What a JDK scheduled executor does by default: delayed work that
+            // was accepted still runs after shutdown(), repeating work is
+            // cancelled. The delay is long enough that the shutdown below
+            // comes first on a loaded machine too.
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
+            ScheduledExecutorService idle = Executors.newSingleThreadScheduledExecutor();
+            ScheduledExecutorService cancelled = Executors.newSingleThreadScheduledExecutor();
+            try {
+                AtomicBoolean ran = new AtomicBoolean();
+                ScheduledFuture<String> once = pool.schedule(answering("ran", ran), 1500, TimeUnit.MILLISECONDS);
+                ScheduledFuture<?> repeating = pool.scheduleAtFixedRate(NOTHING, 50, 50, TimeUnit.MILLISECONDS);
+                ScheduledFuture<?> spaced = pool.scheduleWithFixedDelay(NOTHING, 50, 50, TimeUnit.MILLISECONDS);
+                pool.shutdown();
+                Bulk.p("isShutdown", pool.isShutdown());
+                Bulk.p("isTerminatedWithWorkDue", pool.isTerminated());
+                Bulk.p("repeatingIsCancelled", repeating.isCancelled());
+                Bulk.p("spacedIsCancelled", spaced.isCancelled());
+                Bulk.p("onceIsDone", once.isDone());
+                Bulk.pThrown("scheduleAfterShutdown", RejectedExecutionException.class,
+                        () -> pool.schedule(answering("late", new AtomicBoolean()), 1, TimeUnit.MILLISECONDS));
+                Bulk.pThrown("executeAfterShutdown", RejectedExecutionException.class, () -> pool.execute(NOTHING));
+                Bulk.pThrown("submitAfterShutdown", RejectedExecutionException.class, () -> pool.submit(NOTHING));
+                Bulk.p("once", once.get(20, TimeUnit.SECONDS));
+                Bulk.p("ran", ran.get());
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("isTerminated", pool.isTerminated());
+
+                // With nothing due, it stops at once.
+                idle.scheduleAtFixedRate(NOTHING, 50, 50, TimeUnit.MILLISECONDS);
+                terminate("idle", idle);
+
+                // Work cancelled before the shutdown is not waited for.
+                Bulk.p("cancelBeforeShutdown",
+                        cancelled.schedule(answering("never", new AtomicBoolean()), 1, TimeUnit.HOURS).cancel(false));
+                terminate("cancelled", cancelled);
+            } finally {
+                stop(pool);
+                stop(idle);
+                stop(cancelled);
+            }
+        });
+        Bulk.check("Executors.shutdownNowDropsDelayedWork", () -> {
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
+            try {
+                AtomicBoolean ran = new AtomicBoolean();
+                ScheduledFuture<String> once = pool.schedule(answering("ran", ran), 1000, TimeUnit.MILLISECONDS);
+                ScheduledFuture<?> repeating = pool.scheduleAtFixedRate(NOTHING, 1, 1, TimeUnit.HOURS);
+                // Work still waiting for its time never reached the pool, and is
+                // handed back all the same: as the futures it was scheduled as.
+                List<Runnable> dropped = pool.shutdownNow();
+                Bulk.p("dropped", dropped.size());
+                Bulk.p("droppedOnce", dropped.contains(once));
+                Bulk.p("droppedRepeating", dropped.contains(repeating));
+                Bulk.p("isShutdown", pool.isShutdown());
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Thread.sleep(1300);
+                Bulk.p("ran", ran.get());
+                // As the JDK leaves the future of a dropped task.
+                Bulk.p("onceIsDone", once.isDone());
+                Bulk.p("onceIsCancelled", once.isCancelled());
+            } finally {
+                stop(pool);
+            }
+            // The public face of "a dropped wait is still queued" (the original
+            // asked the package-private Delays.pending()): a wait that stayed
+            // queued would still hold its task, and the task its payload.
+            ScheduledExecutorService second = Executors.newScheduledThreadPool(1);
+            try {
+                WeakReference<Object> payload = offThread(() -> scheduleDroppedPayload(second));
+                // Off this thread too: the list shutdownNow() answers holds the task.
+                Bulk.p("droppedCount", offThread(() -> Integer.valueOf(second.shutdownNow().size())));
+                Bulk.p("secondAwaitTermination", second.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("droppedWaitLetGo", collected(payload));
+            } finally {
+                stop(second);
+            }
+        });
+        Bulk.check("Executors.whenCompleteKeepsAFailingActionAsSuppressed", () -> {
+            // An action of whenComplete that fails on a stage that failed: the
+            // stage's own failure stays the one reported, and since JDK 9 the
+            // action's rides along suppressed in it.
+            final RuntimeException source = new RuntimeException("source");
+            final IllegalStateException action = new IllegalStateException("action");
+            CompletableFuture<String> f = new CompletableFuture<String>();
+            CompletableFuture<String> g = f.whenComplete((value, failure) -> {
+                throw action;
+            });
+            f.completeExceptionally(source);
+            try {
+                g.join();
+                Bulk.p("join", "returned");
+            } catch (CompletionException e) {
+                Bulk.p("causeIsSource", e.getCause() == source);
+                Throwable[] suppressed = source.getSuppressed();
+                Bulk.p("suppressed", suppressed.length);
+                Bulk.p("suppressedIsAction", suppressed.length == 1 && suppressed[0] == action);
+            }
+
+            // An action that rethrows the very failure it was given adds nothing.
+            CompletableFuture<String> h = new CompletableFuture<String>();
+            CompletableFuture<String> k = h.whenComplete((value, failure) -> {
+                throw (RuntimeException) failure;
+            });
+            final RuntimeException same = new RuntimeException("same");
+            h.completeExceptionally(same);
+            Bulk.p("rethrowIsCompletedExceptionally", k.isCompletedExceptionally());
+            Bulk.p("rethrowSuppressed", same.getSuppressed().length);
+        });
+        Bulk.check("Executors.shutdownNowLetsGoOfTheWorkItDrops", () -> {
+            // A dropped task's future never completes, so nothing ever took it
+            // out of the pool's own list: a pool kept after shutdownNow() held
+            // every dropped task, and whatever its work held, for good.
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
+            try {
+                WeakReference<Object> payload = offThread(() -> scheduleHolding(pool));
+                // Off this thread too: the list shutdownNow() answers holds the task.
+                Bulk.p("dropped", offThread(() -> Integer.valueOf(pool.shutdownNow().size())));
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("collected", collected(payload));
+                // The pool itself is still reachable here, which is the point.
+                Bulk.p("isShutdown", pool.isShutdown());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aFixedRateCatchesUpAfterAnOverrun", () -> {
+            // A fixed rate whose run overruns its period owes the firings that
+            // fell inside it, as the JDK's does: they run late, one after
+            // another, straight after the long run, and never two at once.
+            // The overrun is 400 ms of a 20 ms period: about nineteen firings
+            // owed. Within 150 ms of its end a pool that catches up starts all
+            // of them and then some, one that dropped them at most eight; the
+            // threshold of twelve sits between the two with room on either
+            // side, so a loaded machine cannot move the answer.
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
+            try {
+                final AtomicInteger runs = new AtomicInteger();
+                final AtomicInteger active = new AtomicInteger();
+                final AtomicInteger overlap = new AtomicInteger();
+                final AtomicLong ended = new AtomicLong();
+                final List<Long> starts = Collections.synchronizedList(new ArrayList<Long>());
+                pool.scheduleAtFixedRate(() -> {
+                    if (active.incrementAndGet() > 1) {
+                        overlap.incrementAndGet();
+                    }
+                    starts.add(Long.valueOf(System.currentTimeMillis()));
+                    if (runs.incrementAndGet() == 1) {
+                        try {
+                            Thread.sleep(400);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                        }
+                        ended.set(System.currentTimeMillis());
+                    }
+                    active.decrementAndGet();
+                }, 0, 20, TimeUnit.MILLISECONDS);
+                for (int i = 0; i < 4000 && runs.get() < 25; i++) {
+                    Thread.sleep(5);
+                }
+                pool.shutdownNow();
+                Bulk.p("awaitTermination", pool.awaitTermination(20, TimeUnit.SECONDS));
+                Bulk.p("overlap", overlap.get());
+                int soon = 0;
+                synchronized (starts) {
+                    for (Long at : starts) {
+                        if (at.longValue() >= ended.get() && at.longValue() - ended.get() < 150) {
+                            soon++;
+                        }
+                    }
+                }
+                Bulk.p("overrunFiringsRunLate", soon >= 12);
+                if (soon < 12) {
+                    System.out.println("# only " + soon + " of " + runs.get() + " runs right after the overrun");
+                }
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aTaskCancelledWhileWaitingForAWorkerNeverStarts", () -> {
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
+            try {
+                final CountDownLatch busy = new CountDownLatch(1);
+                final CountDownLatch release = new CountDownLatch(1);
+                pool.execute(() -> {
+                    busy.countDown();
+                    try {
+                        release.await(20, TimeUnit.SECONDS);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                });
+                Bulk.p("busy", busy.await(20, TimeUnit.SECONDS));
+                final AtomicInteger ran = new AtomicInteger();
+                ScheduledFuture<?> waiting = pool.schedule(ran::incrementAndGet, 1, TimeUnit.MILLISECONDS);
+                Thread.sleep(50);
+                Bulk.p("cancel", waiting.cancel(false));
+                release.countDown();
+                // Something after it on the same worker shows the queue drained.
+                Bulk.p("after", pool.submit(() -> "after").get(20, TimeUnit.SECONDS));
+                Bulk.p("ran", ran.get());
+                Bulk.p("isCancelled", waiting.isCancelled());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aZeroSizedScheduledPoolRunsItsWork", () -> {
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(0);
+            try {
+                Bulk.p("ran", pool.schedule(() -> "ran", 5, TimeUnit.MILLISECONDS).get(20, TimeUnit.SECONDS));
+            } finally {
+                stop(pool);
+            }
+            Bulk.pThrown("negative", IllegalArgumentException.class, () -> Executors.newScheduledThreadPool(-1));
+        });
+        Bulk.check("Executors.aFixedRateOutlivesARunLongerThanItsPeriod", () -> {
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
+            try {
+                final AtomicInteger runs = new AtomicInteger();
+                final CountDownLatch five = new CountDownLatch(5);
+                pool.scheduleAtFixedRate(() -> {
+                    if (runs.incrementAndGet() == 1) {
+                        try {
+                            Thread.sleep(120);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                        }
+                    }
+                    five.countDown();
+                }, 0, 20, TimeUnit.MILLISECONDS);
+                Bulk.p("fiveRuns", five.await(20, TimeUnit.SECONDS));
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aDelayPastTheEndOfTheClockNeverFires", () -> {
+            // A delay too long to add to the clock means never, not the past.
+            CompletableFuture<String> never = new CompletableFuture<String>().orTimeout(Long.MAX_VALUE,
+                    TimeUnit.MILLISECONDS);
+            CompletableFuture<String> soon = new CompletableFuture<String>().completeOnTimeout("late", 30,
+                    TimeUnit.MILLISECONDS);
+            Bulk.p("soon", soon.get(20, TimeUnit.SECONDS));
+            Bulk.p("neverIsDone", never.isDone());
+            Bulk.p("neverComplete", never.complete("in time"));
+        });
+        Bulk.check("Executors.manyTimeoutsThatAreNotNeededHoldNoThread", () -> {
+            // A device's timer slept a thread through every delay it was given,
+            // cancelled or not. The original counted the queued waits through
+            // the package-private Delays.pending() (1000, then 0); here a wait
+            // given up must hold on to nothing: every completed future is
+            // collectable.
+            // Counted on the thread that makes the timeouts, which is one of the
+            // living threads it compares with.
+            List<WeakReference<Object>> refs = offThread(() -> manyCompletedTimeouts(Thread.activeCount()));
+            Bulk.p("notCollected", notCollected(refs));
+            // And the waits that are due still fire, in the order of their
+            // time (the original scheduled raw Delays.after() actions; these
+            // are the public timeouts built on them).
+            final List<String> order = Collections.synchronizedList(new ArrayList<String>());
+            final CountDownLatch done = new CountDownLatch(3);
+            for (final int millis : new int[] {600, 200, 400}) {
+                new CompletableFuture<String>().completeOnTimeout(String.valueOf(millis), millis, TimeUnit.MILLISECONDS)
+                        .thenAccept(v -> {
+                            order.add(v);
+                            done.countDown();
+                        });
+            }
+            Bulk.p("fired", done.await(20, TimeUnit.SECONDS));
+            Bulk.p("order", order);
+        });
+        Bulk.check("Executors.aTimeoutNoLongerNeededLetsGoOfItsFuture", () -> {
+            // A timeout set for a future that completed in time is cancelled,
+            // and holds on to nothing: a timer keeps a cancelled task until
+            // its time.
+            Bulk.p("orTimeoutLetGo", collected(offThread(() -> completedOrTimeout())));
+            Bulk.p("completeOnTimeoutLetGo", collected(offThread(() -> cancelledCompleteOnTimeout())));
+            // And one that is needed still fires.
+            Bulk.p("late", new CompletableFuture<String>().completeOnTimeout("late", 30, TimeUnit.MILLISECONDS)
+                    .get(20, TimeUnit.SECONDS));
+            try {
+                new CompletableFuture<String>().orTimeout(30, TimeUnit.MILLISECONDS).get(20, TimeUnit.SECONDS);
+                Bulk.p("orTimeout", "returned");
+            } catch (ExecutionException expected) {
+                Bulk.p("orTimeoutCause", expected.getCause() instanceof TimeoutException);
+            }
+        });
+        Bulk.check("Executors.aMinimalCompletionStageIsACopy", () -> {
+            // Completing the stage leaves the future alone.
+            CompletableFuture<String> source = new CompletableFuture<String>();
+            CompletionStage<String> stage = source.minimalCompletionStage();
+            Bulk.p("stageComplete", stage.toCompletableFuture().complete("the stage's own"));
+            Bulk.p("sourceIsDone", source.isDone());
+            Bulk.p("sourceComplete", source.complete("the source's"));
+            Bulk.p("source", source.get());
+
+            CompletableFuture<String> second = new CompletableFuture<String>();
+            CompletionStage<String> follows = second.minimalCompletionStage();
+            second.complete("value");
+            Bulk.p("follows", follows.toCompletableFuture().get(20, TimeUnit.SECONDS));
+        });
+        Bulk.check("Executors.submissionsFromSeveralThreadsAreAllAccounted", () -> {
+            final ExecutorService pool = Executors.newFixedThreadPool(3);
+            try {
+                final AtomicInteger ran = new AtomicInteger();
+                final AtomicInteger failed = new AtomicInteger();
+                Thread[] submitters = new Thread[8];
+                for (int t = 0; t < submitters.length; t++) {
+                    submitters[t] = new Thread(() -> {
+                        try {
+                            for (int i = 0; i < 500; i++) {
+                                pool.execute(ran::incrementAndGet);
+                            }
+                        } catch (Throwable e) {
+                            failed.incrementAndGet();
+                        }
+                    });
+                    submitters[t].start();
+                }
+                boolean joined = true;
+                for (Thread submitter : submitters) {
+                    submitter.join(30000);
+                    joined &= !submitter.isAlive();
+                }
+                Bulk.p("joined", joined);
+                Bulk.p("failed", failed.get());
+                terminate("pool", pool);
+                Bulk.p("ran", ran.get());
+            } finally {
+                stop(pool);
+            }
+        });
+        Bulk.check("Executors.aPoolShutDownWhileItIsSubmittedToTerminates", () -> {
+            // A submission racing a shutdown may start a worker after the
+            // shutdown has looked for workers to stop; the pool must still
+            // terminate.
+            int terminated = 0;
+            boolean joined = true;
+            for (int round = 0; round < 40; round++) {
+                final ExecutorService pool = Executors.newFixedThreadPool(4);
+                try {
+                    Thread[] submitters = new Thread[4];
+                    for (int t = 0; t < submitters.length; t++) {
+                        submitters[t] = new Thread(() -> {
+                            try {
+                                for (int i = 0; i < 4; i++) {
+                                    pool.execute(NOTHING);
+                                }
+                            } catch (RejectedExecutionException expected) {
+                                return;
+                            }
+                        });
+                    }
+                    for (Thread t : submitters) {
+                        t.start();
+                    }
+                    pool.shutdown();
+                    for (Thread t : submitters) {
+                        t.join(30000);
+                        joined &= !t.isAlive();
+                    }
+                    if (pool.awaitTermination(10, TimeUnit.SECONDS)) {
+                        terminated++;
+                    }
+                } finally {
+                    stop(pool);
+                }
+            }
+            Bulk.p("joined", joined);
+            Bulk.p("terminatedRounds", terminated);
+        });
+        Bulk.check("Executors.aVeryShortFixedDelayKeepsRepeating", () -> {
+            // A fixed delay shorter than the time a run takes to wind up must
+            // not end the repetition: the next run is armed once this one is over.
+            // The evidence is that runs keep coming after a first batch, not how
+            // many fit in a time: every run is two thread hand-offs, and a loaded
+            // two-core CI runner managed fewer than 300 in 30 seconds.
+            ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
+            try {
+                final AtomicInteger runs = new AtomicInteger();
+                ScheduledFuture<?> spaced = pool.scheduleWithFixedDelay(runs::incrementAndGet, 0, 1,
+                        TimeUnit.MILLISECONDS);
+                boolean first = waitForRuns(runs, 20);
+                int seen = runs.get();
+                boolean more = waitForRuns(runs, seen + 20);
+                Bulk.p("keepsRepeating", first && more);
+                Bulk.p("isDone", spaced.isDone());
+                spaced.cancel(false);
+            } finally {
+                stop(pool);
+            }
+        });
+        // invokeAll interrupted while it waits cancels the tasks that have not
+        // finished, so none of them runs after it has returned. ParparVM only:
+        // the interrupt is already pending, so invokeAll gives up before the
+        // worker has necessarily taken the first task, and the JDK -- which
+        // cancels from the FRONT -- then frees the worker to start the second
+        // before that one is cancelled (HotSpot answered later=1 on one run in
+        // three). JavaAPI cancels from the back, which is the contract here.
+        Bulk.cn1Only("Executors.anInterruptedInvokeAllCancelsWhatIsLeft", () -> {
+            ExecutorService pool = Executors.newFixedThreadPool(1);
+            final AtomicBoolean go = new AtomicBoolean();
+            try {
+                final AtomicInteger later = new AtomicInteger();
+                List<Callable<String>> tasks = new ArrayList<Callable<String>>();
+                // The first task ignores the interrupt cancel(true) sends it, so
+                // a started first task keeps the worker busy while invokeAll
+                // cancels.
+                tasks.add(() -> {
+                    awaitIgnoringInterrupts(go);
+                    return "first";
+                });
+                tasks.add(() -> {
+                    later.incrementAndGet();
+                    return "second";
+                });
+                Thread.currentThread().interrupt();
+                boolean threw = false;
+                try {
+                    pool.invokeAll(tasks);
+                } catch (InterruptedException expected) {
+                    threw = true;
+                    Bulk.expect(!Thread.currentThread().isInterrupted(), "the interrupt was not cleared");
+                } finally {
+                    Thread.interrupted();
+                    go.set(true);
+                }
+                Bulk.expect(threw, "invokeAll returned although interrupted");
+                Bulk.expectEquals("after", pool.submit(() -> "after").get(20, TimeUnit.SECONDS), "a task after it");
+                Bulk.expectEquals(Integer.valueOf(0), Integer.valueOf(later.get()), "a cancelled task ran");
+            } finally {
+                go.set(true);
+                Thread.interrupted();
+                stop(pool);
+            }
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/FunctionEdgeApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/FunctionEdgeApp.java
new file mode 100644
index 00000000000..2ed899c0a51
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/FunctionEdgeApp.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.*;
+
+/// The default and static members of java.util.function and java.util.Comparator,
+/// printed as one line that the JVM and ParparVM must agree on.
+public class FunctionEdgeApp {
+    private static final StringBuilder OUT = new StringBuilder();
+
+    private static void out(Object label, Object value) {
+        OUT.append(label).append('=').append(value).append(';');
+    }
+
+    static final class Person {
+        final String name;
+        final int age;
+        final long id;
+        final double score;
+
+        Person(String name, int age, long id, double score) {
+            this.name = name;
+            this.age = age;
+            this.id = id;
+            this.score = score;
+        }
+
+        public String toString() {
+            return name;
+        }
+    }
+
+    public static void fixtureMain(String[] args) {
+        Function<Integer, Integer> inc = x -> x + 1;
+        Function<Integer, Integer> dbl = x -> x * 2;
+        out("compose", inc.compose(dbl).apply(5));
+        out("andThen", inc.andThen(dbl).apply(5));
+        out("identity", Function.<String>identity().apply("same"));
+        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
+        out("biAndThen", add.andThen(dbl).apply(3, 4));
+        BinaryOperator<String> min = BinaryOperator.minBy(Comparator.<String>naturalOrder());
+        BinaryOperator<String> max = BinaryOperator.maxBy(Comparator.<String>naturalOrder());
+        out("minBy", min.apply("b", "a") + min.apply("a", "a"));
+        out("maxBy", max.apply("b", "a") + max.apply("a", "b"));
+        BiFunction<String, String, String> asBi = min;
+        out("binaryIsBi", asBi.apply("z", "y"));
+        out("unaryIdentity", UnaryOperator.<String>identity().apply("u"));
+
+        final StringBuilder trace = new StringBuilder();
+        Consumer<String> first = s -> trace.append("1").append(s);
+        Consumer<String> second = s -> trace.append("2").append(s);
+        first.andThen(second).accept("x");
+        BiConsumer<String, Integer> b1 = (s, i) -> trace.append("[").append(s).append(i);
+        b1.andThen((s, i) -> trace.append(i).append(s).append("]")).accept("k", 9);
+        out("consumers", trace);
+        try {
+            first.andThen(null);
+            out("andThenNull", "accepted");
+        } catch (NullPointerException e) {
+            out("andThenNull", "npe");
+        }
+
+        Predicate<Integer> even = x -> x % 2 == 0;
+        Predicate<Integer> big = x -> x > 10;
+        out("and", even.and(big).test(12) + "," + even.and(big).test(8));
+        out("or", even.or(big).test(11) + "," + even.or(big).test(7));
+        out("negate", even.negate().test(3));
+        out("not", Predicate.not(even).test(4));
+        out("isEqual", Predicate.isEqual("a").test("a") + "," + Predicate.isEqual(null).test(null)
+                + "," + Predicate.isEqual(null).test("x"));
+        final int[] asked = new int[1];
+        Predicate<Integer> counting = x -> {
+            asked[0]++;
+            return true;
+        };
+        even.and(counting).test(3);
+        even.or(counting).test(4);
+        out("shortCircuit", asked[0]);
+        BiPredicate<String, Integer> longer = (s, n) -> s.length() > n;
+        out("biPredicate", longer.test("abc", 2) + "," + longer.negate().test("abc", 2) + ","
+                + longer.and((s, n) -> n > 0).test("abc", 0) + "," + longer.or((s, n) -> n == 5).test("a", 5));
+
+        IntUnaryOperator i1 = x -> x + 3;
+        out("intUnary", i1.andThen(x -> x * 10).applyAsInt(1) + "," + i1.compose(x -> x * 10).applyAsInt(1)
+                + "," + IntUnaryOperator.identity().applyAsInt(7));
+        LongUnaryOperator l1 = x -> x - 1;
+        out("longUnary", l1.andThen(x -> x * 3L).applyAsLong(Long.MAX_VALUE / 4) + ","
+                + LongUnaryOperator.identity().applyAsLong(-5L) + "," + l1.compose(x -> x * 2).applyAsLong(4));
+        DoubleUnaryOperator d1 = x -> x / 2;
+        out("doubleUnary", d1.andThen(x -> x + 0.25).applyAsDouble(3) + "," + d1.compose(x -> x * 4).applyAsDouble(1)
+                + "," + DoubleUnaryOperator.identity().applyAsDouble(-0.0));
+        IntPredicate ip = x -> x > 0;
+        LongPredicate lp = x -> x > 0;
+        DoublePredicate dp = x -> x > 0;
+        out("primPredicates", ip.and(x -> x < 5).test(3) + "," + ip.or(x -> x == -1).test(-1) + "," + ip.negate().test(1)
+                + "," + lp.and(x -> x < 5).test(9) + "," + lp.or(x -> x == -1).test(-1) + "," + lp.negate().test(0)
+                + "," + dp.and(x -> x < 5).test(4.5) + "," + dp.or(x -> Double.isNaN(x)).test(Double.NaN) + ","
+                + dp.negate().test(Double.NaN));
+        final StringBuilder prim = new StringBuilder();
+        IntConsumer ic = x -> prim.append('i').append(x);
+        LongConsumer lc = x -> prim.append('l').append(x);
+        DoubleConsumer dc = x -> prim.append('d').append(x);
+        ic.andThen(x -> prim.append('I')).accept(1);
+        lc.andThen(x -> prim.append('L')).accept(2L);
+        dc.andThen(x -> prim.append('D')).accept(2.5);
+        out("primConsumers", prim);
+        IntBinaryOperator ib = (a, b) -> a * b;
+        LongBinaryOperator lb = (a, b) -> a - b;
+        DoubleBinaryOperator db = (a, b) -> a / b;
+        IntFunction<String> ifn = x -> "#" + x;
+        LongFunction<String> lfn = x -> "L" + x;
+        DoubleFunction<String> dfn = x -> "D" + x;
+        IntToLongFunction itl = x -> x * 1000000000L;
+        IntToDoubleFunction itd = x -> x / 4.0;
+        LongToIntFunction lti = x -> (int) (x >> 32);
+        LongToDoubleFunction ltd = x -> x / 8.0;
+        DoubleToIntFunction dti = x -> (int) Math.floor(x);
+        DoubleToLongFunction dtl = x -> Math.round(x);
+        ToIntFunction<String> tif = String::length;
+        ToLongFunction<String> tlf = s -> s.length() * 10L;
+        ToDoubleFunction<String> tdf = s -> s.length() / 2.0;
+        ToIntBiFunction<String, String> tibf = (a, b) -> a.length() + b.length();
+        ToLongBiFunction<String, String> tlbf = (a, b) -> a.length() * (long) b.length();
+        ToDoubleBiFunction<String, String> tdbf = (a, b) -> a.length() / (double) b.length();
+        IntSupplier is = () -> 42;
+        LongSupplier ls = () -> 43L;
+        DoubleSupplier ds = () -> 4.5;
+        BooleanSupplier bs = () -> true;
+        final StringBuilder objPrim = new StringBuilder();
+        ObjIntConsumer<String> oic = (s, x) -> objPrim.append(s).append(x);
+        ObjLongConsumer<String> olc = (s, x) -> objPrim.append(s).append(x);
+        ObjDoubleConsumer<String> odc = (s, x) -> objPrim.append(s).append(x);
+        oic.accept("a", 1);
+        olc.accept("b", 2L);
+        odc.accept("c", 3.5);
+        out("plain", ib.applyAsInt(6, 7) + "," + lb.applyAsLong(1, 2) + "," + db.applyAsDouble(1, 4) + ","
+                + ifn.apply(1) + lfn.apply(2) + dfn.apply(0.5) + "," + itl.applyAsLong(3) + "," + itd.applyAsDouble(3)
+                + "," + lti.applyAsInt(1L << 33) + "," + ltd.applyAsDouble(3) + "," + dti.applyAsInt(-1.5) + ","
+                + dtl.applyAsLong(2.5) + "," + tif.applyAsInt("abc") + "," + tlf.applyAsLong("ab") + ","
+                + tdf.applyAsDouble("abc") + "," + tibf.applyAsInt("a", "bc") + "," + tlbf.applyAsLong("ab", "cde")
+                + "," + tdbf.applyAsDouble("a", "bcd") + "," + is.getAsInt() + ls.getAsLong() + ds.getAsDouble()
+                + bs.getAsBoolean() + "," + objPrim);
+
+        List<Person> people = new ArrayList<Person>(Arrays.asList(
+                new Person("cat", 30, 5L, 1.5), new Person("ann", 25, 9L, Double.NaN),
+                new Person("bob", 30, 1L, -0.0), new Person("dan", 25, 9L, 0.0)));
+        List<Person> sorted = new ArrayList<Person>(people);
+        Collections.sort(sorted, Comparator.comparingInt((Person p) -> p.age).thenComparing(p -> p.name));
+        out("byAgeName", sorted);
+        Collections.sort(sorted, Comparator.comparingLong((Person p) -> p.id).thenComparingInt(p -> p.age)
+                .thenComparing(p -> p.name, Comparator.<String>reverseOrder()));
+        out("byIdAgeNameDesc", sorted);
+        Collections.sort(sorted, Comparator.comparingDouble((Person p) -> p.score));
+        out("byScore", sorted);
+        Collections.sort(sorted, Comparator.comparing((Person p) -> p.name).reversed());
+        out("byNameDesc", sorted);
+        Collections.sort(sorted, Comparator.comparing((Person p) -> p.age, Comparator.<Integer>reverseOrder())
+                .thenComparingLong(p -> p.id).thenComparingDouble(p -> p.score));
+        out("byAgeDescIdScore", sorted);
+
+        List<String> withNulls = new ArrayList<String>(Arrays.asList("b", null, "a", null, "c"));
+        Collections.sort(withNulls, Comparator.nullsFirst(Comparator.<String>naturalOrder()));
+        out("nullsFirst", withNulls);
+        Collections.sort(withNulls, Comparator.nullsLast(Comparator.<String>naturalOrder()));
+        out("nullsLast", withNulls);
+        Collections.sort(withNulls, Comparator.nullsFirst(Comparator.<String>naturalOrder()).reversed());
+        out("nullsFirstReversed", withNulls);
+        Collections.sort(withNulls, Comparator.<String>nullsLast(null));
+        out("nullsLastNoComparator", withNulls);
+        Collections.sort(withNulls, Comparator.nullsLast(Comparator.<String>naturalOrder())
+                .thenComparing(Comparator.<String>reverseOrder()));
+        out("nullsLastThen", withNulls);
+        try {
+            Comparator.comparingInt(null);
+            out("comparingIntNull", "accepted");
+        } catch (NullPointerException e) {
+            out("comparingIntNull", "npe");
+        }
+        System.out.println("RESULT=" + OUT);
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/FunctionEdgeChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/FunctionEdgeChecks.java
new file mode 100644
index 00000000000..bb90468969d
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/FunctionEdgeChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// FunctionEdgeApp, formerly translated and built on its own by FunctionalApiIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class FunctionEdgeChecks {
+    private FunctionEdgeChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("FunctionEdgeApp", () -> FunctionEdgeApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ImmutableChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ImmutableChecks.java
new file mode 100644
index 00000000000..213fd010d3b
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ImmutableChecks.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/// `List.of`, `Set.of`, `Map.of`, their `copyOf` forms, `Map.ofEntries` and
+/// `Map.entry`, through the public factories only. (The parity test this
+/// replaces called the package-private `ImmutableCollections` the factories
+/// delegate to; every one of those calls is made here through the factory
+/// that reaches it.) A set and a map iterate in an unspecified order, so
+/// they are printed sorted, never in iteration order.
+public final class ImmutableChecks {
+    private ImmutableChecks() {
+    }
+
+    private static void unsupported(String what, Bulk.Body body) {
+        Bulk.pThrown(what, UnsupportedOperationException.class, body);
+    }
+
+    private static void refusesNull(String what, Bulk.Body body) {
+        Bulk.pThrown(what, NullPointerException.class, body);
+    }
+
+    private static void duplicate(String what, Bulk.Body body) {
+        Bulk.pThrown(what, IllegalArgumentException.class, body);
+    }
+
+    /// Runs the group.
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public static void run() {
+        Bulk.check("Immutable.listOfHoldsItsElementsInOrder", () -> {
+            Bulk.p("empty", List.of().equals(Collections.emptyList()));
+            Bulk.p("one", List.of("a"));
+            Bulk.p("two", List.of("a", "b"));
+            Bulk.p("ten", List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+            Bulk.p("array11", List.of(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}));
+            // Duplicates are a list's business.
+            List<String> list = List.of("x", "y", "x");
+            List<String> reference = Collections.unmodifiableList(Arrays.asList("x", "y", "x"));
+            Bulk.p("equalsReference", reference.equals(list));
+            Bulk.p("referenceEquals", list.equals(reference));
+            Bulk.p("hashCode", list.hashCode());
+            Bulk.p("hashCodeAsReference", list.hashCode() == reference.hashCode());
+            Bulk.p("toString", list.toString());
+            Bulk.p("size", list.size());
+            Bulk.p("indexOf", list.indexOf("x"));
+            Bulk.p("lastIndexOf", list.lastIndexOf("x"));
+            Bulk.p("subList", list.subList(1, 3));
+            Bulk.p("toArray", list.toArray());
+            Bulk.p("toArrayTyped", list.toArray(new String[0]));
+            Bulk.p("containsY", list.contains("y"));
+            Bulk.p("containsZ", list.contains("z"));
+            Bulk.p("containsAll", list.containsAll(Arrays.asList("x", "y")));
+            Bulk.pThrown("get3", IndexOutOfBoundsException.class, () -> list.get(3));
+        });
+        Bulk.check("Immutable.listOfCannotBeChanged", () -> {
+            final List<String> list = List.of("a", "b", "c");
+            unsupported("add", () -> list.add("d"));
+            unsupported("addAt", () -> list.add(0, "d"));
+            unsupported("addAll", () -> list.addAll(Arrays.asList("d")));
+            unsupported("addAllAt", () -> list.addAll(1, Arrays.asList("d")));
+            unsupported("remove", () -> list.remove("a"));
+            unsupported("removeAt", () -> list.remove(0));
+            unsupported("removeAll", () -> list.removeAll(Arrays.asList("a")));
+            unsupported("retainAll", () -> list.retainAll(Arrays.asList("a")));
+            unsupported("set", () -> list.set(0, "z"));
+            unsupported("clear", () -> list.clear());
+            unsupported("sort", () -> list.sort(null));
+            unsupported("replaceAll", () -> list.replaceAll(s -> s));
+            unsupported("removeIf", () -> list.removeIf(s -> true));
+            unsupported("CollectionsSort", () -> Collections.sort(list));
+            unsupported("iteratorRemove", () -> {
+                Iterator<String> it = list.iterator();
+                it.next();
+                it.remove();
+            });
+            unsupported("listIteratorSet", () -> {
+                ListIterator<String> it = list.listIterator();
+                it.next();
+                it.set("z");
+            });
+            unsupported("listIteratorAdd", () -> list.listIterator().add("z"));
+            unsupported("subListClear", () -> list.subList(0, 2).clear());
+            unsupported("subListSet", () -> list.subList(0, 2).set(0, "z"));
+            unsupported("emptyAdd", () -> List.<String>of().add("d"));
+            unsupported("emptyArrayAdd", () -> List.of(new String[0]).add("d"));
+            unsupported("singleAdd", () -> List.of("a").add("d"));
+            Bulk.p("list", list);
+        });
+        Bulk.check("Immutable.listOfRefusesNull", () -> {
+            refusesNull("of1", () -> List.of((String) null));
+            refusesNull("of2", () -> List.of("a", null));
+            refusesNull("of5", () -> List.of("a", "b", null, "d", "e"));
+            refusesNull("ofArray", () -> List.of(new String[] {"a", null}));
+            refusesNull("ofNullArray", () -> List.of((String[]) null));
+            refusesNull("copyOf", () -> List.copyOf(Arrays.asList("a", null)));
+            refusesNull("copyOfNull", () -> List.copyOf(null));
+            refusesNull("contains", () -> List.of("a").contains(null));
+            refusesNull("indexOf", () -> List.of("a").indexOf(null));
+            refusesNull("lastIndexOf", () -> List.of("a").lastIndexOf(null));
+            refusesNull("containsMany", () -> List.of("a", "b", "c").contains(null));
+        });
+        Bulk.check("Immutable.listOfAnArrayDoesNotKeepTheArray", () -> {
+            String[] array = {"a", "b"};
+            List<String> list = List.of(array);
+            array[0] = "changed";
+            Bulk.p("two", list);
+            String[] longer = {"a", "b", "c", "d"};
+            List<String> four = List.of(longer);
+            longer[0] = "changed";
+            Bulk.p("four", four);
+        });
+        Bulk.check("Immutable.listCopyOfIsASnapshot", () -> {
+            List<String> source = new ArrayList<String>(Arrays.asList("a", "b"));
+            final List<String> copy = List.copyOf(source);
+            source.add("c");
+            Bulk.p("copy", copy);
+            unsupported("add", () -> copy.add("d"));
+            // An immutable list is its own copy.
+            Bulk.p("selfCopySame", copy == List.copyOf(copy));
+            Bulk.p("fromSet", List.copyOf(new LinkedHashSet<String>(Arrays.asList("b", "a", "b"))));
+        });
+        Bulk.check("Immutable.setOfHoldsItsElements", () -> {
+            Bulk.p("empty", Set.of().equals(Collections.emptySet()));
+            Set<String> set = Set.of("a", "b", "c");
+            Set<String> reference = new HashSet<String>(Arrays.asList("c", "b", "a"));
+            Bulk.p("equalsReference", reference.equals(set));
+            Bulk.p("referenceEquals", set.equals(reference));
+            Bulk.p("hashCode", set.hashCode());
+            Bulk.p("size", set.size());
+            Bulk.p("containsB", set.contains("b"));
+            Bulk.p("containsZ", set.contains("z"));
+            Bulk.p("containsAll", set.containsAll(reference));
+            Bulk.p("toArray", Bulk.sorted(Arrays.asList(set.toArray(new String[0]))));
+            Bulk.p("ten", Bulk.sorted(Set.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)));
+            Bulk.p("array11", Bulk.sorted(Set.of(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11})));
+            List<String> walked = new ArrayList<String>();
+            for (String s : set) {
+                walked.add(s);
+            }
+            Bulk.p("walked", Bulk.sorted(walked));
+        });
+        Bulk.check("Immutable.setOfCannotBeChanged", () -> {
+            final Set<String> set = Set.of("a", "b", "c");
+            unsupported("add", () -> set.add("d"));
+            unsupported("addPresent", () -> set.add("a"));
+            unsupported("addAll", () -> set.addAll(Arrays.asList("d")));
+            unsupported("remove", () -> set.remove("a"));
+            unsupported("removeAll", () -> set.removeAll(Arrays.asList("a")));
+            unsupported("retainAll", () -> set.retainAll(Arrays.asList("a")));
+            unsupported("removeIf", () -> set.removeIf(s -> true));
+            unsupported("clear", () -> set.clear());
+            unsupported("iteratorRemove", () -> {
+                Iterator<String> it = set.iterator();
+                it.next();
+                it.remove();
+            });
+            unsupported("emptyAdd", () -> Set.<String>of().add("d"));
+            unsupported("emptyArrayAdd", () -> Set.of(new String[0]).add("d"));
+            Bulk.p("size", set.size());
+        });
+        Bulk.check("Immutable.setOfRefusesNullAndDuplicates", () -> {
+            refusesNull("of1", () -> Set.of((String) null));
+            refusesNull("of3", () -> Set.of("a", null, "c"));
+            refusesNull("ofArray", () -> Set.of(new String[] {"a", null}));
+            refusesNull("copyOf", () -> Set.copyOf(Arrays.asList("a", null)));
+            refusesNull("contains", () -> Set.of("a").contains(null));
+            refusesNull("containsMany", () -> Set.of("a", "b", "c").contains(null));
+            duplicate("of2", () -> Set.of("a", "a"));
+            duplicate("of4", () -> Set.of("a", "b", "c", "a"));
+            duplicate("ofArray", () -> Set.of(new String[] {"a", "b", "b"}));
+        });
+        Bulk.check("Immutable.setCopyOfDropsDuplicatesInsteadOfRefusingThem", () -> {
+            final Set<String> copy = Set.copyOf(Arrays.asList("a", "b", "a"));
+            Bulk.p("copy", Bulk.sorted(copy));
+            Bulk.p("selfCopySame", copy == Set.copyOf(copy));
+            unsupported("add", () -> copy.add("z"));
+        });
+        Bulk.check("Immutable.mapOfHoldsItsEntries", () -> {
+            Bulk.p("empty", Map.of().equals(Collections.emptyMap()));
+            Map<String, Integer> map = Map.of("a", 1, "b", 2, "c", 3);
+            Map<String, Integer> reference = new HashMap<String, Integer>();
+            reference.put("a", 1);
+            reference.put("b", 2);
+            reference.put("c", 3);
+            Bulk.p("equalsReference", reference.equals(map));
+            Bulk.p("referenceEquals", map.equals(reference));
+            Bulk.p("hashCode", map.hashCode());
+            Bulk.p("size", map.size());
+            Bulk.p("getB", map.get("b"));
+            Bulk.p("getZ", map.get("z"));
+            Bulk.p("containsKeyC", map.containsKey("c"));
+            Bulk.p("containsKeyZ", map.containsKey("z"));
+            Bulk.p("containsValue3", map.containsValue(3));
+            Bulk.p("containsValue4", map.containsValue(4));
+            Bulk.p("keySet", Bulk.sorted(map.keySet()));
+            Bulk.p("keySetEqualsReference", reference.keySet().equals(map.keySet()));
+            Bulk.p("values", Bulk.sorted(map.values()));
+            Bulk.p("entrySetEqualsReference", reference.entrySet().equals(map.entrySet()));
+            Bulk.p("getOrDefault", map.getOrDefault("z", 9));
+            Bulk.p("sorted", Bulk.sortedMap(map));
+            Map<Integer, Integer> ten = Map.of(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10);
+            Bulk.p("tenSize", ten.size());
+            Bulk.p("tenGet10", ten.get(10));
+            Bulk.p("ten", Bulk.sortedMap(ten));
+        });
+        Bulk.check("Immutable.mapOfCannotBeChanged", () -> {
+            final Map<String, Integer> map = Map.of("a", 1, "b", 2);
+            unsupported("put", () -> map.put("c", 3));
+            unsupported("putPresent", () -> map.put("a", 1));
+            unsupported("putAll", () -> map.putAll(Collections.singletonMap("c", 3)));
+            unsupported("remove", () -> map.remove("a"));
+            unsupported("clear", () -> map.clear());
+            unsupported("putIfAbsent", () -> map.putIfAbsent("c", 3));
+            unsupported("removePair", () -> map.remove("a", 1));
+            unsupported("replace", () -> map.replace("a", 5));
+            unsupported("replacePair", () -> map.replace("a", 1, 5));
+            unsupported("replaceAll", () -> map.replaceAll((k, v) -> v));
+            unsupported("computeIfAbsent", () -> map.computeIfAbsent("c", k -> 3));
+            unsupported("computeIfPresent", () -> map.computeIfPresent("a", (k, v) -> v));
+            unsupported("compute", () -> map.compute("a", (k, v) -> v));
+            unsupported("merge", () -> map.merge("a", 1, Integer::sum));
+            unsupported("keysRemove", () -> map.keySet().remove("a"));
+            unsupported("keysClear", () -> map.keySet().clear());
+            unsupported("valuesRemove", () -> map.values().remove(1));
+            unsupported("valuesClear", () -> map.values().clear());
+            unsupported("entriesClear", () -> map.entrySet().clear());
+            unsupported("entrySetValue", () -> map.entrySet().iterator().next().setValue(7));
+            unsupported("entriesIteratorRemove", () -> {
+                Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
+                it.next();
+                it.remove();
+            });
+            unsupported("keysIteratorRemove", () -> {
+                Iterator<String> it = map.keySet().iterator();
+                it.next();
+                it.remove();
+            });
+            unsupported("emptyPut", () -> Map.<String, Integer>of().put("c", 3));
+            unsupported("emptyEntriesPut", () -> Map.<String, Integer>ofEntries().put("c", 3));
+            Bulk.p("size", map.size());
+            Bulk.p("getA", map.get("a"));
+        });
+        Bulk.check("Immutable.mapOfRefusesNullAndDuplicateKeys", () -> {
+            refusesNull("nullKey", () -> Map.of(null, 1));
+            refusesNull("nullValue", () -> Map.of("a", null));
+            refusesNull("nullLater", () -> Map.of("a", 1, "b", null));
+            refusesNull("get", () -> Map.of("a", 1).get(null));
+            refusesNull("containsKey", () -> Map.of("a", 1).containsKey(null));
+            refusesNull("containsValue", () -> Map.of("a", 1).containsValue(null));
+            refusesNull("getMany", () -> Map.of("a", 1, "b", 2, "c", 3).get(null));
+            refusesNull("containsKeyMany", () -> Map.of("a", 1, "b", 2, "c", 3).containsKey(null));
+            refusesNull("containsValueMany", () -> Map.of("a", 1, "b", 2, "c", 3).containsValue(null));
+            refusesNull("copyOfKey", () -> Map.copyOf(Collections.singletonMap(null, 1)));
+            refusesNull("copyOfValue", () -> Map.copyOf(Collections.singletonMap("a", null)));
+            refusesNull("copyOfNull", () -> Map.copyOf(null));
+            duplicate("of2", () -> Map.of("a", 1, "a", 2));
+            duplicate("of3", () -> Map.of("a", 1, "b", 2, "a", 1));
+        });
+        Bulk.check("Immutable.entryOfEntriesAndCopyOf", () -> {
+            final Map.Entry<String, Integer> entry = Map.entry("k", 5);
+            Map.Entry<String, Integer> reference = new AbstractMap.SimpleImmutableEntry<String, Integer>("k", 5);
+            Bulk.p("key", entry.getKey());
+            Bulk.p("value", entry.getValue());
+            Bulk.p("equalsReference", reference.equals(entry));
+            Bulk.p("referenceEquals", entry.equals(reference));
+            Bulk.p("hashCode", entry.hashCode());
+            Bulk.p("toString", entry.toString());
+            unsupported("setValue", () -> entry.setValue(6));
+            refusesNull("entryNullKey", () -> Map.entry(null, 1));
+            refusesNull("entryNullValue", () -> Map.entry("a", null));
+
+            final Map<String, Integer> map = Map.ofEntries(Map.entry("a", 1), Map.entry("b", 2));
+            Bulk.p("ofEntriesSize", map.size());
+            Bulk.p("ofEntriesGetB", map.get("b"));
+            unsupported("ofEntriesPut", () -> map.put("c", 3));
+            Bulk.p("ofEntriesEmpty", Map.ofEntries(new Map.Entry[0]).isEmpty());
+            duplicate("ofEntriesDuplicate", () -> Map.ofEntries(Map.entry("a", 1), Map.entry("a", 2)));
+            refusesNull("ofEntriesNull", () -> Map.ofEntries(Map.entry("a", 1), null));
+
+            Map<String, Integer> source = new TreeMap<String, Integer>();
+            source.put("x", 1);
+            Map<String, Integer> copy = Map.copyOf(source);
+            source.put("y", 2);
+            Bulk.p("copy", Bulk.sortedMap(copy));
+            Bulk.p("copyEqualsSingleton", Collections.singletonMap("x", 1).equals(copy));
+            Bulk.p("selfCopySame", copy == Map.copyOf(copy));
+            Bulk.p("notTheSource", copy != source);
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/IoChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/IoChecks.java
new file mode 100644
index 00000000000..cfeb1ced397
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/IoChecks.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+
+/// java.io's buffered streams, readers and writers and PrintWriter.
+public final class IoChecks {
+    private IoChecks() {
+    }
+
+    private static final String[] TEXTS = {"", "a", "a\n", "a\r\nb\rc\n\nd", "\r", "\r\n", "\n\n", "x\r\r\ny",
+        "caf\u00e9\nline two\r\n", "no newline at the end"};
+
+    private static String lines(BufferedReader r) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        String line;
+        while ((line = r.readLine()) != null) {
+            sb.append('<').append(line).append('>');
+        }
+        return sb.append(r.read()).toString();
+    }
+
+    private static void deleteTree(File f) {
+        File[] kids = f.listFiles();
+        if (kids != null) {
+            for (File k : kids) {
+                deleteTree(k);
+            }
+        }
+        f.delete();
+    }
+
+    private static byte[] readAll(File f) throws IOException {
+        FileInputStream in = new FileInputStream(f);
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            byte[] buf = new byte[256];
+            int n;
+            while ((n = in.read(buf)) > 0) {
+                out.write(buf, 0, n);
+            }
+            return out.toByteArray();
+        } finally {
+            in.close();
+        }
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("Io.readLineSplitsAsTheJdkDoes", () -> {
+            for (int t = 0; t < TEXTS.length; t++) {
+                for (int size : new int[] {1, 2, 3, 8192}) {
+                    Bulk.p("text" + t + "/" + size, lines(new BufferedReader(new StringReader(TEXTS[t]), size)));
+                }
+            }
+        });
+        Bulk.check("Io.markResetAndSkipOnAReader", () -> {
+            BufferedReader r = new BufferedReader(new StringReader("0123456789abcdef"), 4);
+            Bulk.p("markSupported", r.markSupported());
+            Bulk.p("read", r.read());
+            r.mark(10);
+            char[] a = new char[6];
+            Bulk.p("readArray", r.read(a, 0, 6));
+            Bulk.p("chars", a);
+            r.reset();
+            Bulk.p("skip3", r.skip(3));
+            Bulk.p("read2", r.read());
+            Bulk.p("skip100", r.skip(100));
+            Bulk.p("readEnd", r.read());
+            Bulk.p("ready", r.ready());
+            r.close();
+            Bulk.pThrown("readClosed", IOException.class, () -> r.read());
+        });
+        Bulk.check("Io.aBufferedWriterWritesWhatItWasGiven", () -> {
+            StringWriter out = new StringWriter();
+            BufferedWriter w = new BufferedWriter(out, 3);
+            for (String s : new String[] {"ab", "", "cdefgh", "i"}) {
+                w.write(s);
+                w.write('-');
+            }
+            w.write("0123456789", 2, 5);
+            w.newLine();
+            w.flush();
+            Bulk.p("written", out.toString().replace(System.lineSeparator(), "\n"));
+            w.close();
+            w.close();
+            Bulk.pThrown("writeClosed", IOException.class, () -> w.write("x"));
+        });
+        Bulk.check("Io.aPrintWriterPrintsAsTheJdkDoes", () -> {
+            StringWriter out = new StringWriter();
+            PrintWriter w = new PrintWriter(out);
+            w.print(1);
+            w.print('c');
+            w.print(2.5);
+            w.print(true);
+            w.print((Object) null);
+            w.print((String) null);
+            w.println("line");
+            w.printf("%d-%s-%5.2f|", 42, "x", 3.14159);
+            w.format("%08X", 255);
+            w.append("abc", 1, 2).append('z').append(null);
+            w.flush();
+            Bulk.p("printed", out.toString().replace(System.lineSeparator(), "\n"));
+            Bulk.p("checkError", w.checkError());
+        });
+        Bulk.check("Io.aPrintWriterOnAFileWritesUtf8AndRefusesAnUnknownCharset", () -> {
+            File dir = new File(new File("Io-scratch").getAbsoluteFile(), "printwriter");
+            deleteTree(dir);
+            dir.mkdirs();
+            try {
+                File file = new File(dir, "out.txt");
+                PrintWriter utf = new PrintWriter(file.getPath());
+                utf.print("caf\u00e9");
+                utf.close();
+                Bulk.p("utf8", readAll(file));
+                PrintWriter latin = new PrintWriter(file, "ISO-8859-1");
+                latin.print("caf\u00e9");
+                latin.close();
+                Bulk.p("latin1", readAll(file));
+                Bulk.pThrown("unknownCharset", UnsupportedEncodingException.class,
+                        () -> new PrintWriter(file, "no-such-charset"));
+                // An unknown charset leaves the file as it was.
+                Bulk.p("afterUnknown", readAll(file));
+                Bulk.pThrown("noSuchDir", FileNotFoundException.class,
+                        () -> new PrintWriter(new File(dir, "no/such/dir/x.txt").getPath()));
+                Bulk.p("noDirMade", new File(dir, "no").exists());
+            } finally {
+                deleteTree(dir);
+                new File("Io-scratch").getAbsoluteFile().delete();
+            }
+        });
+        Bulk.check("Io.anUnknownCharsetNameIsRefusedAndAnAliasIsHonoured", () -> {
+            // ParparVM's encoding natives took any name they did not know for
+            // UTF-8, so all of these answered UTF-8 bytes instead of throwing.
+            Bulk.pThrown("getBytes", UnsupportedEncodingException.class, () -> "x".getBytes("no-such-charset"));
+            Bulk.pThrown("newString", UnsupportedEncodingException.class,
+                    () -> new String(new byte[] {65}, "no-such-charset"));
+            Bulk.pThrown("newStringRange", UnsupportedEncodingException.class,
+                    () -> new String(new byte[] {65}, 0, 1, "no-such-charset"));
+            Bulk.pThrown("writer", UnsupportedEncodingException.class,
+                    () -> new OutputStreamWriter(new ByteArrayOutputStream(), "no-such-charset"));
+            Bulk.pThrown("reader", UnsupportedEncodingException.class,
+                    () -> new InputStreamReader(new ByteArrayInputStream(new byte[0]), "no-such-charset"));
+            Bulk.pThrown("writerNull", NullPointerException.class,
+                    () -> new OutputStreamWriter(new ByteArrayOutputStream(), (String) null));
+            // An alias in another case names the same charset, and the bytes
+            // and the decoded text are that charset's, not UTF-8's.
+            Bulk.p("latin1Bytes", "caf\u00e9".getBytes("latin1"));
+            Bulk.p("isoLowerBytes", "caf\u00e9".getBytes("iso-8859-1"));
+            Bulk.p("utf8LowerBytes", "caf\u00e9".getBytes("utf-8"));
+            Bulk.p("latin1String", new String(new byte[] {99, 97, 102, (byte) 0xe9}, "Latin1"));
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            OutputStreamWriter w = new OutputStreamWriter(out, "iso-8859-1");
+            Bulk.p("writerEncoding", w.getEncoding());
+            w.write("caf\u00e9");
+            w.close();
+            Bulk.p("writerBytes", out.toByteArray());
+            InputStreamReader r = new InputStreamReader(new ByteArrayInputStream(new byte[] {99, 97, 102, (byte) 0xe9}), "ISO8859_1");
+            Bulk.p("readerEncoding", r.getEncoding());
+            char[] buf = new char[8];
+            int n = r.read(buf);
+            Bulk.p("readerText", new String(buf, 0, Math.max(n, 0)));
+        });
+        Bulk.check("Io.aBufferedInputStreamReadsMarksAndSkipsAsTheJdkDoes", () -> {
+            byte[] data = new byte[100];
+            for (int i = 0; i < data.length; i++) {
+                data[i] = (byte) (i * 7);
+            }
+            for (int size : new int[] {1, 3, 16, 8192}) {
+                BufferedInputStream in = new BufferedInputStream(new ByteArrayInputStream(data), size);
+                String m = "[" + size + "]";
+                Bulk.p("read" + m, in.read());
+                in.mark(20);
+                byte[] a = new byte[10];
+                Bulk.p("readArray" + m, in.read(a, 0, 10));
+                Bulk.p("bytes" + m, a);
+                in.reset();
+                Bulk.p("skip" + m, in.skip(5));
+                Bulk.p("read2" + m, in.read());
+                Bulk.p("markSupported" + m, in.markSupported());
+                byte[] rest = new byte[200];
+                int total = 0;
+                int n;
+                while ((n = in.read(rest, total, rest.length - total)) > 0) {
+                    total += n;
+                }
+                Bulk.p("restCount" + m, total);
+                Bulk.p("rest" + m, Arrays.copyOf(rest, total));
+                Bulk.p("readEnd" + m, in.read());
+                in.close();
+                Bulk.pThrown("readClosed" + m, IOException.class, () -> in.read());
+            }
+        });
+        Bulk.check("Io.aBufferedOutputStreamWritesWhatItWasGiven", () -> {
+            ByteArrayOutputStream sink = new ByteArrayOutputStream();
+            BufferedOutputStream out = new BufferedOutputStream(sink, 4);
+            out.write(1);
+            out.write(new byte[] {2, 3, 4, 5, 6, 7}, 1, 4);
+            Bulk.p("atMostFiveBeforeFlush", sink.size() <= 5);
+            out.write(new byte[10], 0, 10);
+            out.flush();
+            Bulk.p("size", sink.size());
+            Bulk.p("first", Arrays.copyOf(sink.toByteArray(), 5));
+            out.close();
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LangMembersApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LangMembersApp.java
new file mode 100644
index 00000000000..8dd2342c3e5
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LangMembersApp.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/// The java.lang / java.util members JavaAPI provides, run on
+/// HotSpot (the JDK's own classes) and on ParparVM; the RESULT lines must
+/// match. Every case answers a string, or the class and message of what it
+/// threw, so a difference names the member. Java 17 API only.
+public class LangMembersApp {
+
+    static final int CASES = 140;
+
+    public static void fixtureMain(String[] args) throws Exception {
+        StringBuilder all = new StringBuilder();
+        for (int i = 0; i < CASES; i++) {
+            String v;
+            try {
+                v = run(i);
+            } catch (Throwable t) {
+                v = "!" + t.getClass().getName() + ":" + t.getMessage();
+            }
+            if (v == null) {
+                continue;
+            }
+            System.out.println("case " + i + " = " + v);
+            all.append(i).append('=').append(v).append('|');
+        }
+        System.out.println("RESULT=" + all);
+    }
+
+    static String bits(double d) {
+        return Long.toHexString(Double.doubleToLongBits(d));
+    }
+
+    static String bits(float f) {
+        return Integer.toHexString(Float.floatToIntBits(f));
+    }
+
+    // Results that are not bit-exact by design: compared to 1e-12 relative.
+    static String approx(double d) {
+        return String.valueOf(Math.round(d * 1e12));
+    }
+
+    static String cps(String s) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            sb.append(Integer.toHexString(s.charAt(i))).append(',');
+        }
+        return sb.toString();
+    }
+
+    static String run(int i) throws Exception {
+        String em = "" + (char) 0x2003;
+        String smile = new String(new int[] {0x1F600}, 0, 1);
+        switch (i) {
+            // ---- String
+            case 0: return "[" + (em + " a b " + em).strip() + "]";
+            case 1: return "[" + ("  a b  ").stripLeading() + "]";
+            case 2: return "[" + ("  a b  " + em).stripTrailing() + "]";
+            case 3: return "" + "   ".isBlank() + ("  " + em).isBlank() + " x ".isBlank();
+            case 4: return "ab".repeat(3) + "/" + "ab".repeat(0).length();
+            case 5: return "ab".repeat(-1);
+            case 6: return cps("a\nb".indent(2));
+            case 7: return cps("   a\n  b\r\n".indent(-1));
+            case 8: return cps("    a\n      b\n    ".stripIndent());
+            case 9: return cps("a\\tb\\n\\101\\s\\\\".translateEscapes());
+            case 10: return "a\\qb".translateEscapes();
+            case 11: return "" + smile.length() + smile.codePointAt(0) + "/" + ("a" + smile).codePointCount(0, 3);
+            case 12: return "" + ("a" + smile + "b").offsetByCodePoints(0, 2) + "/" + (smile + "x").codePointBefore(2);
+            case 13: return "" + "a\nb\r\nc\rd".lines().count();
+            case 14: return "%d-%s".formatted(3, "x");
+            case 15: return "abc".transform(new Function<String, String>() {
+                public String apply(String s) {
+                    return s + s.length();
+                }
+            });
+            case 16: return String.join("-", "a", "b", "c") + "/" + String.join(",", java.util.Arrays.asList("x", "y"));
+            case 17: return cps(new String(new int[] {0x41, 0x1F600, 0x42}, 1, 2));
+            case 18: return new String(new int[] {-1}, 0, 1);
+            case 19: return cps(new String("h\u00e9llo".getBytes(StandardCharsets.UTF_8), 1, 2, StandardCharsets.UTF_8));
+            // ---- Integer
+            case 20: return Integer.parseUnsignedInt("4294967295") + "/" + Integer.toUnsignedString(-1) + "/" + Integer.toUnsignedString(-1, 16);
+            case 21: return Integer.divideUnsigned(-1, 3) + "/" + Integer.remainderUnsigned(-1, 3) + "/" + Integer.compareUnsigned(-1, 1) + "/" + Integer.toUnsignedLong(-2);
+            case 22: return Integer.decode("-0x1F") + "/" + Integer.decode("#ff") + "/" + Integer.decode("010") + "/" + Integer.decode("-2147483648");
+            case 23: return "" + Integer.decode("+-1");
+            case 24: return "" + Integer.decode("");
+            case 25: return "" + Integer.decode("0x80000000");
+            case 26: return Integer.toHexString(Integer.reverse(0x12345678)) + "/" + Integer.toHexString(Integer.reverseBytes(0x12345678));
+            case 27: return Integer.bitCount(0xF0F0) + "/" + Integer.highestOneBit(100) + "/" + Integer.lowestOneBit(100) + "/" + Integer.numberOfTrailingZeros(64) + "/" + Integer.rotateRight(1, 1);
+            case 28: return "" + Integer.parseInt("x123y", 1, 4, 10) + "/" + Integer.parseUnsignedInt("ffffffff", 16);
+            case 29: return "" + Integer.parseUnsignedInt("4294967296");
+            case 30: return "" + Integer.divideUnsigned(5, 0);
+            case 31: return Integer.hashCode(-7) + "/" + Integer.BYTES + "/" + new Integer("12");
+            // ---- Long
+            case 32: return Long.parseUnsignedLong("18446744073709551615") + "/" + Long.toUnsignedString(-1L) + "/" + Long.toUnsignedString(-1L, 36);
+            case 33: return Long.divideUnsigned(-1L, 10) + "/" + Long.remainderUnsigned(-1L, 10) + "/" + Long.compareUnsigned(-1L, 1L);
+            case 34: return Long.toHexString(-255L) + "/" + Long.toBinaryString(5L) + "/" + Long.toOctalString(-1L);
+            case 35: return Long.decode("-0x8000000000000000") + "/" + Long.decode("0777") + "/" + Long.valueOf("-42") + "/" + Long.valueOf("zz", 36);
+            case 36: return "" + Long.parseUnsignedLong("18446744073709551616");
+            case 37: return Long.bitCount(-1L) + "/" + Long.numberOfLeadingZeros(1L) + "/" + Long.numberOfTrailingZeros(0L) + "/" + Long.signum(-9L);
+            case 38: return Long.toHexString(Long.reverse(1L)) + "/" + Long.toHexString(Long.reverseBytes(0x0102030405060708L)) + "/" + Long.rotateLeft(1L, 65);
+            case 39: return Long.highestOneBit(-1L) + "/" + Long.lowestOneBit(12L) + "/" + Long.hashCode(-1L) + "/" + Long.parseLong("x-77", 1, 4, 10);
+            // ---- Short / Byte
+            case 40: return Short.decode("0x7fff") + "/" + Short.toUnsignedInt((short) -1) + "/" + Integer.toHexString(Short.reverseBytes((short) 0x1234));
+            case 41: return "" + Short.decode("0x8000");
+            case 42: return Byte.decode("-0x80") + "/" + Byte.toUnsignedInt((byte) -1) + "/" + Byte.compare((byte) 1, (byte) -1) + "/" + Byte.compareUnsigned((byte) 1, (byte) -1);
+            case 43: return "" + Byte.valueOf("128");
+            case 44: return Short.valueOf("-7", 8) + "/" + Short.compareUnsigned((short) -1, (short) 1) + "/" + Short.hashCode((short) -3) + "/" + Byte.hashCode((byte) -3);
+            // ---- Double / Float
+            case 45: return Double.toHexString(1.0) + "/" + Double.toHexString(-0.0) + "/" + Double.toHexString(Double.MIN_VALUE) + "/" + Double.toHexString(0.1);
+            case 46: return Double.toHexString(Double.MAX_VALUE) + "/" + Double.toHexString(Double.NaN) + "/" + Double.toHexString(Double.NEGATIVE_INFINITY) + "/" + Double.toHexString(Double.MIN_NORMAL);
+            case 47: return Float.toHexString(1.5f) + "/" + Float.toHexString(Float.MIN_VALUE) + "/" + Float.toHexString(-3.25e-40f) + "/" + Float.toHexString(Float.MAX_VALUE);
+            case 48: return "" + Double.isFinite(1e308) + Double.isFinite(Double.POSITIVE_INFINITY) + Float.isFinite(Float.NaN) + "/" + Double.hashCode(1.5) + "/" + Float.hashCode(1.5f);
+            case 49: return bits(Double.MIN_NORMAL) + "/" + bits(Float.MIN_NORMAL) + "/" + Float.MAX_EXPONENT + Float.MIN_EXPONENT + Double.MAX_EXPONENT;
+            // ---- Boolean
+            case 50: return "" + Boolean.logicalXor(true, false) + Boolean.logicalAnd(true, false) + Boolean.logicalOr(false, false) + Boolean.compare(true, false) + Boolean.hashCode(true) + Boolean.hashCode(false) + Boolean.toString(true) + new Boolean("TRUE");
+            // ---- Character
+            case 51: return Character.getNumericValue('a') + "/" + Character.getNumericValue((char) 0x0663) + "/" + Character.getNumericValue('5') + "/" + Character.getNumericValue('%');
+            case 52: return Character.digit((char) 0xFF21, 16) + "/" + Character.digit(0x0663, 10) + "/" + Character.digit('z', 36) + "/" + Character.digit('9', 8);
+            case 53: return "" + Character.isDigit(0x0663) + Character.isDigit(0xFF10) + Character.isDigit('a');
+            case 54: return Integer.toHexString(Character.toUpperCase(0xe9)) + "/" + Integer.toHexString(Character.toUpperCase(0xff)) + "/" + Integer.toHexString(Character.toUpperCase(0xb5)) + "/" + Integer.toHexString(Character.toUpperCase(0xf7));
+            case 55: return "" + Character.isSpaceChar((char) 0xa0) + Character.isSpaceChar(0x2028) + Character.isSpaceChar('\t') + Character.isISOControl('\t') + Character.isISOControl(0x85) + Character.isISOControl('a');
+            case 56: return "" + Character.forDigit(11, 16) + Character.forDigit(5, 10) + (int) Character.forDigit(10, 10) + (int) Character.forDigit(1, 99);
+            case 57: return "" + Character.isAlphabetic('a') + Character.isAlphabetic('1') + Character.isIdeographic(0x4e00) + Character.isIdeographic('a');
+            case 58: return Character.getType('A') + "/" + Character.getType('a') + "/" + Character.getType(' ') + "/" + Character.getType((char) 0x01c5) + "/" + Character.getType('1') + "/" + Character.getType(0x4e00);
+            case 59: return "" + Character.isTitleCase((char) 0x01c5) + Character.isTitleCase('A') + Character.isMirrored('(') + Character.isMirrored('a');
+            case 60: return "" + Character.isUnicodeIdentifierStart('a') + Character.isUnicodeIdentifierStart('1') + Character.isUnicodeIdentifierPart('1') + Character.isUnicodeIdentifierPart(' ');
+            case 61: return Character.toString(0x1F600).length() + "/" + Character.toString('x') + "/" + Character.compare('a', 'b') + "/" + Character.hashCode('a') + "/" + Character.BYTES;
+            case 62: return "" + Character.isDefined('a') + Character.isLetter(0x4e00) + Character.isLowerCase(0xe9) + Character.isUpperCase(0xc9) + Character.isBmpCodePoint(0x10000);
+            case 63: return Character.toString(0x110000);
+            // ---- Math
+            case 64: return Math.floorDiv(-7, 2) + "/" + Math.floorMod(-7, 2) + "/" + Math.floorMod(7, -2) + "/" + Math.floorDiv(Integer.MIN_VALUE, -1) + "/" + Math.floorMod(-7L, 3) + "/" + Math.floorDiv(-7L, 2L);
+            case 65: return "" + Math.floorDiv(1, 0);
+            case 66: return "" + Math.addExact(Integer.MAX_VALUE, 1);
+            case 67: return "" + Math.multiplyExact(Long.MAX_VALUE, 2L);
+            case 68: return "" + Math.toIntExact(1L << 40);
+            case 69: return "" + Math.negateExact(Integer.MIN_VALUE);
+            case 70: return "" + Math.absExact(Integer.MIN_VALUE);
+            case 71: return Math.multiplyHigh(Long.MAX_VALUE, Long.MAX_VALUE) + "/" + Math.multiplyFull(Integer.MAX_VALUE, Integer.MAX_VALUE) + "/" + Math.multiplyHigh(-3L, 5L);
+            case 72: return Math.subtractExact(5L, 7L) + "/" + Math.incrementExact(4) + "/" + Math.decrementExact(-4L) + "/" + Math.multiplyExact(1L << 30, 2);
+            case 73: return bits(Math.signum(-2.5)) + "/" + bits(Math.signum(0.0f)) + "/" + bits(Math.copySign(1.0, -0.0)) + "/" + bits(Math.copySign(2f, Float.NaN));
+            case 74: return Math.getExponent(1024.0) + "/" + Math.getExponent(Double.MIN_VALUE) + "/" + Math.getExponent(0.5f) + "/" + Math.getExponent(Float.NaN);
+            case 75: return bits(Math.ulp(1.0)) + "/" + bits(Math.ulp(Double.MAX_VALUE)) + "/" + bits(Math.ulp(0.0f)) + "/" + bits(Math.ulp(Double.POSITIVE_INFINITY));
+            case 76: return bits(Math.nextUp(1.0)) + "/" + bits(Math.nextUp(-0.0)) + "/" + bits(Math.nextDown(0.0)) + "/" + bits(Math.nextDown(1.0f)) + "/" + bits(Math.nextUp(Float.MAX_VALUE));
+            case 77: return bits(Math.nextAfter(1.0, 0)) + "/" + bits(Math.nextAfter(0.0, -1)) + "/" + bits(Math.nextAfter(1f, 2.0)) + "/" + bits(Math.nextAfter(-0.0, 0.0));
+            case 78: return bits(Math.scalb(1.0, 1030)) + "/" + bits(Math.scalb(3.0, -1075)) + "/" + bits(Math.scalb(1.5f, -130)) + "/" + bits(Math.scalb(1.0, -1074));
+            case 79: return bits(Math.rint(2.5)) + "/" + bits(Math.rint(-3.5)) + "/" + bits(Math.rint(-0.2)) + "/" + bits(Math.rint(1e300));
+            case 80: return Math.round(0.49999999999999994) + "/" + Math.round(-2.5) + "/" + Math.round(2.5f) + "/" + Math.round(Double.NaN) + "/" + Math.round(1e20) + "/" + Math.round(-0.5f);
+            case 81: return bits(Math.hypot(3, 4)) + "/" + bits(Math.hypot(Double.POSITIVE_INFINITY, Double.NaN)) + "/" + approx(Math.cbrt(27)) + "/" + approx(Math.cbrt(-2));
+            case 82: return approx(Math.sinh(1)) + "/" + approx(Math.cosh(1)) + "/" + approx(Math.tanh(0.5)) + "/" + bits(Math.tanh(40)) + "/" + bits(Math.sinh(-0.0));
+            case 83: return StrictMath.floorMod(-1, 5) + "/" + StrictMath.max(1, 2) + "/" + bits(StrictMath.abs(-0.0)) + "/" + StrictMath.round(1.5);
+            case 84: return "" + Math.floorMod(Long.MIN_VALUE, -1L) + "/" + Math.floorDiv(Long.MIN_VALUE, -1L);
+            // ---- Objects
+            case 85: return Objects.requireNonNullElse(null, "d") + "/" + Objects.requireNonNullElse("o", "d");
+            case 86: return "" + Objects.requireNonNullElse(null, null);
+            case 87: return Objects.requireNonNullElseGet(null, new Supplier<String>() {
+                public String get() {
+                    return "got";
+                }
+            });
+            case 88: return Objects.requireNonNullElseGet(null, new Supplier<String>() {
+                public String get() {
+                    return null;
+                }
+            });
+            case 89: return "" + Objects.checkIndex(5, 3);
+            case 90: return "" + Objects.checkFromToIndex(2, 1, 5);
+            case 91: return "" + Objects.checkFromIndexSize(2, 4, 5);
+            case 92: return "" + Objects.checkIndex(5L, 3L);
+            case 93: return Objects.requireNonNull(null, new Supplier<String>() {
+                public String get() {
+                    return "made";
+                }
+            });
+            case 94: return Objects.checkIndex(2, 3) + "/" + Objects.checkFromToIndex(1, 5, 5) + "/" + Objects.checkFromIndexSize(0, 0, 0);
+            // ---- CharSequence / StringBuilder / StringBuffer
+            case 95: {
+                StringBuilder sb = new StringBuilder("ab");
+                sb.appendCodePoint(0x1F600).appendCodePoint('c');
+                return sb.length() + "/" + sb.codePointCount(0, sb.length()) + "/" + sb.codePointAt(2) + "/" + sb.codePointBefore(4) + "/" + sb.offsetByCodePoints(0, 3);
+            }
+            case 96: {
+                StringBuilder sb = new StringBuilder("hello");
+                return sb.compareTo(new StringBuilder("help")) + "/" + CharSequence.compare("a", sb) + "/" + sb.isEmpty() + new StringBuilder().isEmpty();
+            }
+            case 97: {
+                StringBuilder sb = new StringBuilder("hello lo");
+                return sb.indexOf("lo") + "/" + sb.indexOf("lo", 4) + "/" + sb.lastIndexOf("lo") + "/" + sb.lastIndexOf("lo", 5) + "/" + sb.substring(6) + "/" + sb.substring(1, 3);
+            }
+            case 98: return new StringBuilder("hello").replace(1, 3, "XY").replace(4, 99, "!").toString();
+            case 99: {
+                // The message changed between JDK 17 and 21; the class did not.
+                try {
+                    return new StringBuilder("hello").replace(6, 7, "x").toString();
+                } catch (StringIndexOutOfBoundsException e) {
+                    return "SIOOBE";
+                }
+            }
+            case 100: return new StringBuilder().appendCodePoint(-1).toString();
+            case 101: {
+                StringBuffer sb = new StringBuffer((CharSequence) new StringBuilder("buf"));
+                sb.appendCodePoint(0x1F600).append(new StringBuffer("!"));
+                return sb.length() + "/" + sb.compareTo(new StringBuffer("bug")) + "/" + sb.indexOf("f") + "/" + sb.substring(2, 3) + "/" + cps(sb.replace(0, 1, "B").toString());
+            }
+            // ---- Locale
+            case 102: return new Locale("IW", "il").toString() + "/" + new Locale("JI").getLanguage() + "/" + new Locale("in", "id").toLanguageTag();
+            case 103: return new Locale("en", "US", "WIN").toString() + "/" + new Locale("en", "US", "WIN").toLanguageTag() + "/" + new Locale("", "", "POSIX").toString();
+            case 104: return Locale.forLanguageTag("en-US-x-lvariant-POSIX").getVariant() + "/" + Locale.forLanguageTag("de-CH-1996").getVariant() + "/" + Locale.forLanguageTag("de-CH-1996").toString() + "/" + Locale.forLanguageTag("EN-gb").toString();
+            case 105: return Locale.ROOT.toLanguageTag() + "/" + Locale.CHINA + "/" + Locale.CANADA_FRENCH + "/" + Locale.JAPANESE.toLanguageTag() + "/" + new Locale("", "US").toString() + "/" + new Locale("", "US").toLanguageTag();
+            case 106: return new Locale("fr").getDisplayLanguage(Locale.ENGLISH) + "/" + new Locale("", "DE").getDisplayCountry(Locale.ENGLISH) + "/" + new Locale("fr", "CA").getDisplayName(Locale.ENGLISH) + "/" + new Locale("xx").getDisplayLanguage(Locale.ENGLISH);
+            case 107: return "" + new Locale("en", "US").equals(Locale.US) + new Locale("en", "US", "x").equals(Locale.US) + Locale.US.getVariant().length() + Locale.US.getScript().length() + Locale.US.hasExtensions();
+            case 108: return "" + new Locale(null);
+            case 109: return Locale.forLanguageTag("").toString().length() + "/" + Locale.forLanguageTag("und").toString().length() + "/" + Locale.forLanguageTag("pt-BR").getCountry();
+            // ---- Charsets
+            case 110: return Charset.forName("latin1").name() + "/" + Charset.forName("utf8").name() + "/" + Charset.forName("ascii").name() + "/" + Charset.forName("Iso-8859-1").name();
+            case 111: return "" + Charset.isSupported("x-nope") + Charset.isSupported("UTF-8") + Charset.forName("UTF-8").aliases().contains("UTF8") + Charset.forName("UTF-8").equals(StandardCharsets.UTF_8);
+            case 112: return "" + Charset.forName("bad name");
+            case 113: return "" + Charset.forName("x-nope");
+            case 114: return "" + Charset.forName(null);
+            case 115: return "" + Charset.isSupported("");
+            case 116: return StandardCharsets.UTF_8.compareTo(Charset.forName("utf-8")) + "/" + StandardCharsets.US_ASCII + "/" + StandardCharsets.ISO_8859_1.displayName() + "/" + StandardCharsets.UTF_8.isRegistered() + StandardCharsets.UTF_8.canEncode();
+            case 117: return cps(new String(new byte[] {(byte) 0xe9, 0x41}, StandardCharsets.ISO_8859_1)) + "/" + "\u00e9".getBytes(StandardCharsets.UTF_8).length + "/" + "\u00e9".getBytes(StandardCharsets.ISO_8859_1).length;
+            case 118: return new InputStreamReader(new ByteArrayInputStream(new byte[0]), StandardCharsets.UTF_8).getEncoding() + "/" + new OutputStreamWriter(new ByteArrayOutputStream(), StandardCharsets.ISO_8859_1).getEncoding() + "/" + new OutputStreamWriter(new ByteArrayOutputStream(), StandardCharsets.US_ASCII).getEncoding();
+            case 119: {
+                ByteArrayOutputStream bout = new ByteArrayOutputStream();
+                OutputStreamWriter w = new OutputStreamWriter(bout, StandardCharsets.UTF_8);
+                w.write("h\u00e9");
+                w.flush();
+                return bout.size() + "/" + cps(bout.toString(StandardCharsets.UTF_8)) + "/" + cps(bout.toString(StandardCharsets.ISO_8859_1));
+            }
+            case 120: {
+                InputStreamReader r = new InputStreamReader(new ByteArrayInputStream(new byte[] {(byte) 0xc3, (byte) 0xa9, 0x41}), StandardCharsets.UTF_8);
+                return r.read() + "/" + r.read() + "/" + r.read();
+            }
+            case 121: {
+                // Superscripts, fractions, Roman numerals and circled numbers.
+                int[] ranges = {0xa0, 0xbf, 0x2070, 0x208f, 0x2150, 0x217f, 0x2460, 0x249b, 0x24ea, 0x24ff, 0x2776, 0x2793};
+                StringBuilder sb = new StringBuilder();
+                for (int r = 0; r < ranges.length; r += 2) {
+                    for (int c = ranges[r]; c <= ranges[r + 1]; c++) {
+                        sb.append(Character.getNumericValue(c)).append(',').append(Character.getNumericValue((char) c)).append(' ');
+                    }
+                }
+                return sb.toString();
+            }
+            default: return null;
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LangMembersChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LangMembersChecks.java
new file mode 100644
index 00000000000..3fb842cd3ce
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LangMembersChecks.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// LangMembersApp, which used to be translated and built by a test of its own,
+/// run as one check of the bulk program. Its `fixtureMain` (the translator
+/// allows one `main` per program) prints what its `main` always
+/// printed (case lines and a RESULT line); a difference names the line.
+public final class LangMembersChecks {
+    private LangMembersChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("LangMembersApp", () -> LangMembersApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LoggingChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LoggingChecks.java
new file mode 100644
index 00000000000..5071631cd50
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/LoggingChecks.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/// java.util.logging: levels parse and compare alike, and on Codename One a
+/// logger writes through the host's log at the folded level.
+public final class LoggingChecks {
+    private LoggingChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("Logging.levelsParseAndCompareAsTheJdksDo", () -> {
+            for (Level level : new Level[] {Level.OFF, Level.SEVERE, Level.WARNING, Level.INFO, Level.CONFIG,
+                Level.FINE, Level.FINER, Level.FINEST, Level.ALL}) {
+                Level parsed = Level.parse(level.getName());
+                String k = "[" + level.getName() + "]";
+                Bulk.p("name" + k, parsed.getName());
+                Bulk.p("intValue" + k, parsed.intValue());
+                Bulk.p("sameAsParsedInt" + k, parsed == Level.parse(String.valueOf(level.intValue())));
+                Bulk.p("toString" + k, parsed.toString());
+            }
+            Level custom = new Level("AUDIT", 850) {
+                private static final long serialVersionUID = 1L;
+            };
+            Bulk.p("customName", custom.getName());
+            Bulk.p("customBundle", custom.getResourceBundleName());
+            Bulk.p("parse123", Level.parse("123").getName());
+            Bulk.pThrown("parseLoud", IllegalArgumentException.class, () -> Level.parse("LOUD"));
+            Logger quiet = Logger.getAnonymousLogger();
+            Bulk.p("anonymousInfo", quiet.isLoggable(Level.INFO));
+            Bulk.p("anonymousFine", quiet.isLoggable(Level.FINE));
+            quiet.setLevel(Level.OFF);
+            Bulk.p("offSevere", quiet.isLoggable(Level.SEVERE));
+            Bulk.p("sameLogger", Logger.getLogger("a.b") == Logger.getLogger("a.b"));
+            Bulk.p("globalName", Logger.getGlobal().getName());
+        });
+        // A host the check installs receives every record, at the level the
+        // host's four levels fold the JDK's into.
+        Bulk.cn1Only("Logging.writesThroughTheHostLog", () -> {
+            final List<String> lines = new ArrayList<String>();
+            final List<Throwable> thrown = new ArrayList<Throwable>();
+            JdkHost.install(new JdkHost() {
+                @Override
+                public void log(int level, String message, Throwable t) {
+                    lines.add(level + " " + message);
+                    if (t != null) {
+                        thrown.add(t);
+                    }
+                }
+            });
+            Logger log = Logger.getLogger("parity");
+            log.severe("s");
+            log.warning("w");
+            log.info("i");
+            log.config("c");
+            log.fine("f");
+            log.setLevel(Level.ALL);
+            log.config("c");
+            log.finest("f");
+            log.log(Level.INFO, "{0} and {1}, {2} and {x}", new Object[] {"a", Integer.valueOf(2)});
+            log.log(Level.WARNING, "q", "one");
+            log.log(Level.WARNING, () -> "supplied");
+            RuntimeException failure = new RuntimeException("boom");
+            log.log(Level.SEVERE, "failed", failure);
+            Bulk.expectEquals(Arrays.asList(
+                    JdkHost.LOG_ERROR + " parity: s",
+                    JdkHost.LOG_WARNING + " parity: w",
+                    JdkHost.LOG_INFO + " parity: i",
+                    JdkHost.LOG_INFO + " parity: c",
+                    JdkHost.LOG_DEBUG + " parity: f",
+                    JdkHost.LOG_INFO + " parity: a and 2, {2} and {x}",
+                    JdkHost.LOG_WARNING + " parity: q",
+                    JdkHost.LOG_WARNING + " parity: supplied",
+                    JdkHost.LOG_ERROR + " parity: failed"), lines, "the host's log");
+            Bulk.expectEquals(Integer.valueOf(1), Integer.valueOf(thrown.size()), "one throwable logged");
+            Bulk.expect(thrown.size() == 1 && thrown.get(0) == failure, "the throwable logged is the one given");
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/MessageFormatChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/MessageFormatChecks.java
new file mode 100644
index 00000000000..7c3282f9a81
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/MessageFormatChecks.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.text.ChoiceFormat;
+import java.text.FieldPosition;
+import java.text.Format;
+import java.text.MessageFormat;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.text.ParsePosition;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+/// java.text.MessageFormat and ChoiceFormat: the same pattern and arguments
+/// give the same text, and the same message the same arguments back.
+///
+/// A date element runs `DateFormat` as well. Its style based formats are
+/// native on Codename One -- the device formats them -- so only a
+/// `SimpleDateFormat` pattern is formatted here.
+public final class MessageFormatChecks {
+    private MessageFormatChecks() {
+    }
+
+    private static final String[] PATTERNS = {
+        "plain text",
+        "{0}",
+        "Hello {0}, you have {1} messages",
+        "{1} before {0}",
+        "{0}{0}{0}",
+        "'{0}' is literal, {0} is not",
+        "It''s {0}",
+        "'quoted '' quote' {0}",
+        "a '{' b {0} c '}' d",
+        "{0,number}",
+        "{0,number,integer}",
+        "{0,number,percent}",
+        "{0,number,currency}",
+        "{0,number,#.##}",
+        "{0,number,000.0}",
+        "{0,number,#,##0.00;(#,##0.00)}",
+        "{0, number , integer }",
+        "{0,choice,0#no files|1#one file|1<{0,number,integer} files}",
+        "{0,choice,-1#negative|0#zero or more}",
+        "missing {5} argument",
+        "{2}",
+        "trailing quote '",
+        "{0} and '{1}' and {1}",
+        "{0,number,'#'#}",
+        "",
+    };
+
+    private static final Object[][] ARGUMENTS = {
+        {},
+        {"World", Integer.valueOf(3)},
+        {Integer.valueOf(0), "x"},
+        {Integer.valueOf(1), "x"},
+        {Integer.valueOf(2), "x"},
+        {Double.valueOf(1234.5678), Long.valueOf(-7)},
+        {Double.valueOf(-0.256), null},
+        {null, null, null},
+        {Long.valueOf(1234567), "it's", Boolean.TRUE},
+        {"text", "more"},
+        {Integer.valueOf(-5)},
+    };
+
+    // Written as casts: the sources are ASCII.
+    private static final char INFINITY = (char) 0x221E;
+    private static final char AT_LEAST = (char) 0x2264;
+
+    private static final String[] CHOICES = {
+        "0#zero|1#one|2#two",
+        "0#no files|1#one file|1<many files",
+        "-1#negative|0#zero|0<positive",
+        "1#only",
+        "0.5#half|1.5#one and a half",
+        "-" + INFINITY + "#low|0#mid|100#high",
+        "0#a''b|1#'c|d'",
+        "1" + AT_LEAST + "at least one|5<more than five",
+    };
+
+    private static final double[] CHOICE_VALUES = {
+        -1000, -1, -0.5, 0, 0.25, 0.5, 1, 1.0000001, 1.5, 2, 5, 5.5, 99, 100, 1e9,
+        Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY,
+    };
+
+    /// Prints `key=value`, the key escaped as the value is: a pattern here
+    /// carries characters outside ASCII. A key that starts with the `[` of
+    /// a pattern gets a prefix, because the test drops every line starting
+    /// with `[` as a runtime diagnostic.
+    private static void p(String key, Object value) {
+        Bulk.p(Bulk.esc(key.startsWith("[") ? "p" + key : key), value);
+    }
+
+    private static String simpleName(Object o) {
+        String n = o.getClass().getName();
+        return n.substring(n.lastIndexOf('.') + 1);
+    }
+
+    private static String describe(Object[] values, int index, int errorIndex) {
+        StringBuilder sb = new StringBuilder();
+        if (values == null) {
+            sb.append("null");
+        } else {
+            sb.append('[');
+            for (int i = 0; i < values.length; i++) {
+                Object v = values[i];
+                if (i > 0) {
+                    sb.append(", ");
+                }
+                if (v == null) {
+                    sb.append("null");
+                } else if (v instanceof Date) {
+                    sb.append("Date:").append(((Date) v).getTime());
+                } else {
+                    sb.append(simpleName(v)).append(':').append(v);
+                }
+            }
+            sb.append(']');
+        }
+        return sb.append(" index=").append(index).append(" error=").append(errorIndex).toString();
+    }
+
+    /// The message `pattern` makes of `arguments`, or that it was refused.
+    private static String formatted(String pattern, Object[] arguments) {
+        try {
+            return new MessageFormat(pattern, Locale.US).format(arguments);
+        } catch (IllegalArgumentException e) {
+            return "IllegalArgumentException";
+        }
+    }
+
+    /// Runs the group. The default zone is pinned to UTC as well as the
+    /// locale: a date pattern formats in the default zone, and the HotSpot
+    /// reference would otherwise take the machine's zone where the
+    /// translated program does not.
+    public static void run() {
+        Locale saved = Locale.getDefault();
+        TimeZone savedZone = TimeZone.getDefault();
+        Locale.setDefault(Locale.US);
+        TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+        try {
+            messages();
+            choices();
+        } finally {
+            TimeZone.setDefault(savedZone);
+            Locale.setDefault(saved);
+        }
+    }
+
+    private static void messages() {
+        Bulk.check("MessageFormat.formatsLikeTheJdk", () -> {
+            for (String pattern : PATTERNS) {
+                for (Object[] arguments : ARGUMENTS) {
+                    p("[" + pattern + "] " + Arrays.toString(arguments), formatted(pattern, arguments));
+                }
+            }
+        });
+        Bulk.check("MessageFormat.staticFormatMatchesTheJdk", () -> {
+            p("twoArguments", MessageFormat.format("{0} of {1}", "a", Integer.valueOf(12345)));
+            p("noArguments", MessageFormat.format("no arguments", new Object[0]));
+            p("nullArguments", MessageFormat.format("{0}", (Object[]) null));
+        });
+        Bulk.check("MessageFormat.rejectsWhatTheJdkRejects", () -> {
+            String[] patterns = {
+                "{", "{0", "{x}", "{-1}", "{0,bogus}", "{0,number,#.#.#}", "{0}}", "}", "{ 0 }", "{0,}", "{}",
+                "{0,number", "{0,choice,1#a|0#b}", "{1.5}",
+                // Ending inside a nested brace is NOT rejected by the JDK (8 through 25).
+                "{0,choice,0#{", "a{0}b{0,choice,0#{1", "x{0,choice,0#{1}", "{0,choice,0#'{'",
+            };
+            for (String pattern : patterns) {
+                p("[" + pattern + "]", formatted(pattern, new Object[] {Integer.valueOf(1)}));
+            }
+        });
+        Bulk.check("MessageFormat.reproducesPatternsLikeTheJdk", () -> {
+            for (String pattern : PATTERNS) {
+                p("[" + pattern + "] toPattern", new MessageFormat(pattern, Locale.US).toPattern());
+            }
+        });
+        Bulk.check("MessageFormat.formatsDatesLikeTheJdk", () -> {
+            Date when = new Date(1700000000000L);
+            String[] patterns = {
+                "{0,date}", "{0,date,short}", "{0,date,medium}", "{0,date,long}", "{0,time}", "{0,time,short}",
+                "{0,date,yyyy-MM-dd}", "{0,time,HH:mm}", "{0}", "{0, date, full}", "{0,time,long}",
+            };
+            for (String pattern : patterns) {
+                // Only a pattern of letters is formatted here: a style is
+                // formatted by the device, through a native method.
+                if (pattern.indexOf('-') >= 0 || pattern.indexOf(':') >= 0) {
+                    p("[" + pattern + "]", new MessageFormat(pattern, Locale.US).format(new Object[] {when}));
+                }
+                p("[" + pattern + "] toPattern", new MessageFormat(pattern, Locale.US).toPattern());
+            }
+        });
+        Bulk.check("MessageFormat.parsesLikeTheJdk", () -> {
+            String[][] cases = {
+                {"Hello {0}, you have {1} messages", "Hello World, you have 3 messages"},
+                {"Hello {0}, you have {1} messages", "Hello World, you have 3"},
+                {"Hello {0}, you have {1} messages", "Goodbye World"},
+                {"{0}{1}", "ab"},
+                {"{1} before {0}", "x before y"},
+                {"{0} and {0}", "a and b"},
+                {"{0,number} items", "1,234.5 items"},
+                {"{0,number} items", "lots of items"},
+                {"{0,number,integer}-{1}", "42-rest"},
+                {"{0,number,percent}", "12%"},
+                {"{0,choice,0#none|1#one|2#many}!", "one!"},
+                {"{0,choice,0#none|1#one|2#many}!", "several!"},
+                {"{0,date,yyyy-MM-dd} at {1}", "2023-11-14 at noon"},
+                {"It''s {0}", "It's me"},
+                {"plain text", "plain text and more"},
+                {"plain text", "plain"},
+                {"missing {5} argument", "missing {5} argument"},
+                {"", "anything"},
+            };
+            for (String[] c : cases) {
+                for (int from = 0; from < 2; from++) {
+                    String input = from == 0 ? c[1] : "x" + c[1];
+                    ParsePosition position = new ParsePosition(from);
+                    Object[] values = new MessageFormat(c[0], Locale.US).parse(input, position);
+                    p("[" + c[0] + "] \"" + input + "\"@" + from,
+                            describe(values, position.getIndex(), position.getErrorIndex()));
+                }
+            }
+        });
+        Bulk.check("MessageFormat.parseOfAStringThrowsWhereTheJdkThrows", () -> {
+            String pattern = "{0} of {1}";
+            p("parse", Arrays.toString(new MessageFormat(pattern).parse("a of b")));
+            p("parseObject", Arrays.toString((Object[]) new MessageFormat(pattern).parseObject("a of b")));
+            try {
+                new MessageFormat("[{0}]").parse("{x");
+                p("parsed", true);
+            } catch (ParseException e) {
+                p("errorOffset", e.getErrorOffset());
+            }
+        });
+        Bulk.check("MessageFormat.formatsAreReadAndSetLikeTheJdk", () -> {
+            String pattern = "{1,number,integer} and {0} and {1,choice,0#none|1#some}";
+            MessageFormat f = new MessageFormat(pattern, Locale.US);
+            Format[] formats = f.getFormats();
+            p("formats", formats.length);
+            for (int i = 0; i < formats.length; i++) {
+                p("format " + i, formats[i] == null ? "null" : simpleName(formats[i]));
+            }
+            Format[] byArgument = f.getFormatsByArgumentIndex();
+            p("byArgument", byArgument.length);
+            p("byArgument0", byArgument[0] == null ? "null" : simpleName(byArgument[0]));
+            p("byArgument1IsChoice", byArgument[1] instanceof ChoiceFormat);
+
+            Object[] arguments = {"x", Double.valueOf(0.25)};
+            // Element 0 is the {1,number,integer}, which formats the 0.25.
+            f.setFormat(0, NumberFormat.getPercentInstance(Locale.US));
+            p("setFormat", f.format(arguments));
+            p("setFormatPattern", f.toPattern());
+
+            f.setFormatByArgumentIndex(1, NumberFormat.getIntegerInstance(Locale.US));
+            p("setFormatByArgumentIndex", f.format(arguments));
+            p("setFormatByArgumentIndexPattern", f.toPattern());
+
+            f.setFormats(new Format[] {null, null, null});
+            p("setFormats", f.format(arguments));
+            p("setFormatsPattern", f.toPattern());
+        });
+        Bulk.check("MessageFormat.appendsAndComparesLikeAFormat", () -> {
+            MessageFormat format = new MessageFormat("{0}-{1}");
+            StringBuffer out = new StringBuffer("> ");
+            format.format(new Object[] {"a", "b"}, out, new FieldPosition(0));
+            p("appended", out.toString());
+            p("equal", format.equals(new MessageFormat("{0}-{1}")));
+            p("sameHash", format.hashCode() == new MessageFormat("{0}-{1}").hashCode());
+            p("notEqual", format.equals(new MessageFormat("{0}+{1}")));
+            Object copy = format.clone();
+            p("cloneEqual", format.equals(copy));
+            format.applyPattern("{0}");
+            p("cloneEqualAfterApply", format.equals(copy));
+        });
+    }
+
+    private static void choices() {
+        Bulk.check("MessageFormat.choosesLikeTheJdk", () -> {
+            for (String pattern : CHOICES) {
+                ChoiceFormat f = new ChoiceFormat(pattern);
+                for (double value : CHOICE_VALUES) {
+                    p("[" + pattern + "] " + value, f.format(value));
+                }
+                p("[" + pattern + "] 3L", f.format(3L));
+                p("[" + pattern + "] toPattern", f.toPattern());
+                p("[" + pattern + "] limits", Arrays.toString(f.getLimits()));
+                p("[" + pattern + "] formats", Arrays.toString(f.getFormats()));
+            }
+        });
+        Bulk.check("MessageFormat.choiceFromArraysMatchesTheJdk", () -> {
+            double[] limits = {0, 1, ChoiceFormat.nextDouble(1)};
+            String[] formats = {"none", "single", "several"};
+            ChoiceFormat f = new ChoiceFormat(limits, formats);
+            p("toPattern", f.toPattern());
+            for (double value : CHOICE_VALUES) {
+                p("" + value, f.format(value));
+            }
+            p("limits", Arrays.toString(f.getLimits()));
+            Bulk.pThrown("differentLengths", IllegalArgumentException.class,
+                    () -> new ChoiceFormat(new double[] {0, 1}, new String[] {"a"}));
+        });
+        Bulk.check("MessageFormat.choiceParsesLikeTheJdk", () -> {
+            ChoiceFormat f = new ChoiceFormat("0#zero|1#one|2#two|2<twenty");
+            for (String text : new String[] {"zero", "one", "two", "twenty", "three", "", "onex", "tw"}) {
+                ParsePosition position = new ParsePosition(0);
+                Number n = f.parse(text, position);
+                p(text, String.valueOf(n) + " index=" + position.getIndex() + " error="
+                        + position.getErrorIndex());
+            }
+        });
+        Bulk.check("MessageFormat.nextAndPreviousDoubleMatchTheJdk", () -> {
+            double[] values = {
+                0.0, -0.0, 1.0, -1.0, 0.1, 1e300, -1e300, Double.MIN_VALUE, -Double.MIN_VALUE, Double.MAX_VALUE,
+                -Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 4.9E-324,
+                2.2250738585072014E-308,
+            };
+            for (double value : values) {
+                p("next " + value, Double.doubleToLongBits(ChoiceFormat.nextDouble(value)));
+                p("previous " + value, Double.doubleToLongBits(ChoiceFormat.previousDouble(value)));
+            }
+            p("next NaN", Double.doubleToLongBits(ChoiceFormat.nextDouble(Double.NaN)));
+        });
+        Bulk.check("MessageFormat.positionsBehaveLikeTheJdk", () -> {
+            ParsePosition position = new ParsePosition(3);
+            p("index", position.getIndex());
+            p("errorIndex", position.getErrorIndex());
+            position.setErrorIndex(5);
+            p("hash", new ParsePosition(3).hashCode());
+            p("equalWithError", position.equals(new ParsePosition(3)));
+            position.setErrorIndex(-1);
+            p("equalWithoutError", position.equals(new ParsePosition(3)));
+
+            FieldPosition field = new FieldPosition(NumberFormat.FRACTION_FIELD);
+            p("field", field.getField());
+            p("integerField", NumberFormat.INTEGER_FIELD);
+            field.setBeginIndex(2);
+            field.setEndIndex(4);
+            p("begin", field.getBeginIndex());
+            p("end", field.getEndIndex());
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/NioFilesChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/NioFilesChecks.java
new file mode 100644
index 00000000000..cef0d9c0b78
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/NioFilesChecks.java
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.PosixJdkHost;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.DirectoryStream;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/// java.nio.file.Files on the real file system, step by step, each check in
+/// its own directory under `NioFiles-scratch` in the working directory.
+public final class NioFilesChecks {
+    private NioFilesChecks() {
+    }
+
+    /// The script: operation, path, second path, text.
+    private static final String[][] SCRIPT = {
+        {"state", "missing.txt", null, null},
+        {"size", "missing.txt", null, null},
+        {"read", "missing.txt", null, null},
+        {"delete", "missing.txt", null, null},
+        {"deleteIfExists", "missing.txt", null, null},
+        {"write", "a.txt", null, "hello"},
+        {"state", "a.txt", null, null},
+        {"size", "a.txt", null, null},
+        {"attrs", "a.txt", null, null},
+        {"read", "a.txt", null, null},
+        {"writeCreateNew", "a.txt", null, "again"},
+        {"writeCreateNew", "fresh.txt", null, "new"},
+        {"writeAppend", "a.txt", null, " world"},
+        {"read", "a.txt", null, null},
+        {"writeNoCreate", "a.txt", null, "HE"},
+        {"read", "a.txt", null, null},
+        {"writeNoCreate", "nothing.txt", null, "x"},
+        {"writeTruncate", "a.txt", null, "cut"},
+        {"read", "a.txt", null, null},
+        {"writeTruncate", "nothing.txt", null, "x"},
+        {"write", "a.txt", null, "short"},
+        {"readString", "a.txt", null, null},
+        {"writeString", "s.txt", null, "caf\u00e9 \u00fcber"},
+        {"readString", "s.txt", null, null},
+        {"readLatin", "s.txt", null, null},
+        {"size", "s.txt", null, null},
+        {"writeLines", "l.txt", null, "one,two,,four"},
+        {"read", "l.txt", null, null},
+        {"lines", "l.txt", null, null},
+        {"reader", "l.txt", null, null},
+        {"writeString", "crlf.txt", null, "a\r\nb\rc\n\nd"},
+        {"lines", "crlf.txt", null, null},
+        {"writer", "w.txt", null, "written"},
+        {"read", "w.txt", null, null},
+        {"stream", "st.txt", null, "A"},
+        {"write", "no/such/dir/x.txt", null, "x"},
+        {"createFile", "made.txt", null, null},
+        {"createFile", "made.txt", null, null},
+        {"createFile", "no/dir/made.txt", null, null},
+        {"size", "made.txt", null, null},
+        {"createDirectory", "d", null, null},
+        {"createDirectory", "d", null, null},
+        {"createDirectory", "x/y", null, null},
+        {"createDirectories", "x/y/z", null, null},
+        {"createDirectories", "x/y/z", null, null},
+        {"createDirectories", "a.txt", null, null},
+        {"state", "d", null, null},
+        {"attrs", "d", null, null},
+        {"read", "d", null, null},
+        {"write", "d", null, "x"},
+        {"write", "d/one.txt", null, "1"},
+        {"write", "d/two.md", null, "22"},
+        {"write", "d/three.txt", null, "333"},
+        {"write", "x/y/z/deep.txt", null, "deep"},
+        {"write", "x/top.txt", null, "top"},
+        {"delete", "d", null, null},
+        {"dir", "d", null, null},
+        {"glob", "d", null, "*.txt"},
+        {"glob", "d", null, "t*"},
+        {"glob", "d", null, "*.{md,txt}"},
+        {"glob", "d", null, "?n?.txt"},
+        {"glob", "d", null, "[a-o]*"},
+        {"glob", "d", null, "[!a-o]*"},
+        {"glob", "d", null, "t\\wo.md"},
+        {"tree", "x", null, "none"},
+        {"tree", "x", null, "y"},
+        {"tree", "a.txt", null, "none"},
+        {"copy", "a.txt", "copy.txt", null},
+        {"read", "copy.txt", null, null},
+        {"copy", "a.txt", "copy.txt", null},
+        {"copy", "s.txt", "copy.txt", null},
+        {"copyReplace", "s.txt", "copy.txt", null},
+        {"read", "copy.txt", null, null},
+        {"copy", "missing.txt", "copy2.txt", null},
+        {"copy", "a.txt", "no/dir/copy.txt", null},
+        {"copy", "d", "dcopy", null},
+        {"copyReplace", "a.txt", "d", null},
+        {"copy", "a.txt", "a.txt", null},
+        {"copyIn", "in.txt", null, "streamed"},
+        {"copyIn", "in.txt", null, "streamed"},
+        {"copyOut", "in.txt", null, null},
+        {"mismatch", "a.txt", "copy.txt", null},
+        {"mismatch", "a.txt", "a.txt", null},
+        {"mismatch", "d/one.txt", "d/three.txt", null},
+        {"mismatch", "a.txt", "missing.txt", null},
+        {"same", "a.txt", "a.txt", null},
+        {"same", "a.txt", "x/../a.txt", null},
+        {"same", "a.txt", "copy.txt", null},
+        {"move", "copy.txt", "moved.txt", null},
+        {"state", "copy.txt", null, null},
+        {"read", "moved.txt", null, null},
+        {"move", "moved.txt", "a.txt", null},
+        {"moveReplace", "moved.txt", "a.txt", null},
+        {"read", "a.txt", null, null},
+        {"move", "a.txt", "d/in-d.txt", null},
+        {"read", "d/in-d.txt", null, null},
+        {"move", "missing.txt", "x.txt", null},
+        {"move", "d", "renamed", null},
+        {"move", "renamed", "x/y/under", null},
+        {"state", "renamed", null, null},
+        {"delete", "x/y/z/deep.txt", null, null},
+        {"delete", "x/y/z", null, null},
+        {"deleteIfExists", "x/y/z", null, null},
+    };
+
+    /// A fresh, empty directory `name` under the group's scratch directory,
+    /// as an absolute path.
+    private static File scratch(String name) {
+        File dir = new File(new File("NioFiles-scratch").getAbsoluteFile(), name);
+        deleteTree(dir);
+        dir.mkdirs();
+        return dir;
+    }
+
+    private static void deleteTree(File f) {
+        File[] kids = f.listFiles();
+        if (kids != null) {
+            for (File k : kids) {
+                deleteTree(k);
+            }
+        }
+        f.delete();
+    }
+
+    /// Removes a check's directory, and the scratch directory once empty.
+    private static void cleanup(File dir) {
+        deleteTree(dir);
+        new File("NioFiles-scratch").getAbsoluteFile().delete();
+    }
+
+    private static String relative(Path base, Path path) {
+        return base.relativize(path).toString();
+    }
+
+    private static String sorted(Iterator<Path> it, Path base) {
+        List<String> out = new ArrayList<String>();
+        while (it.hasNext()) {
+            out.add(relative(base, it.next()));
+        }
+        Collections.sort(out);
+        return out.toString();
+    }
+
+    private static String op(Path base, String name, String a, String b, String text) throws IOException {
+        final Path p = base.resolve(a);
+        Path q = b == null ? null : base.resolve(b);
+        byte[] bytes = text == null ? null : text.getBytes(StandardCharsets.UTF_8);
+        switch (name) {
+            case "state":
+                return Files.exists(p) + "," + Files.notExists(p) + "," + Files.isDirectory(p) + ","
+                        + Files.isRegularFile(p) + "," + Files.isSymbolicLink(p) + "," + Files.isReadable(p)
+                        + "," + Files.isWritable(p);
+            case "size":
+                return String.valueOf(Files.size(p));
+            case "attrs":
+                BasicFileAttributes at = Files.readAttributes(p, BasicFileAttributes.class);
+                return at.isDirectory() + "," + at.isRegularFile() + "," + at.isSymbolicLink() + ","
+                        + at.isOther() + "," + (at.isDirectory() ? 0 : at.size()) + ","
+                        + (at.lastModifiedTime().toMillis() > 0);
+            case "write":
+                return relative(base, Files.write(p, bytes));
+            case "writeCreateNew":
+                return relative(base, Files.write(p, bytes, StandardOpenOption.CREATE_NEW));
+            case "writeAppend":
+                return relative(base, Files.write(p, bytes, StandardOpenOption.CREATE, StandardOpenOption.APPEND));
+            case "writeNoCreate":
+                return relative(base, Files.write(p, bytes, StandardOpenOption.WRITE));
+            case "writeTruncate":
+                return relative(base, Files.write(p, bytes, StandardOpenOption.TRUNCATE_EXISTING));
+            case "writeString":
+                return relative(base, Files.writeString(p, text));
+            case "writeLines":
+                // String.split is regex API, which JavaAPI deliberately lacks.
+                List<String> parts = new ArrayList<String>();
+                int from = 0;
+                for (int comma; (comma = text.indexOf(',', from)) >= 0; from = comma + 1) {
+                    parts.add(text.substring(from, comma));
+                }
+                parts.add(text.substring(from));
+                return relative(base, Files.write(p, parts, StandardCharsets.UTF_8));
+            case "read":
+                return new String(Files.readAllBytes(p), StandardCharsets.UTF_8);
+            case "readString":
+                return Files.readString(p);
+            case "readLatin":
+                return Files.readString(p, StandardCharsets.ISO_8859_1);
+            case "lines":
+                return Files.readAllLines(p).toString();
+            case "reader":
+                BufferedReader r = Files.newBufferedReader(p);
+                try {
+                    return r.readLine() + "/" + r.readLine();
+                } finally {
+                    r.close();
+                }
+            case "writer":
+                BufferedWriter w = Files.newBufferedWriter(p);
+                w.write(text);
+                w.close();
+                return "ok";
+            case "stream":
+                OutputStream out = Files.newOutputStream(p);
+                out.write(bytes);
+                out.close();
+                InputStream in = Files.newInputStream(p);
+                try {
+                    return String.valueOf(in.read());
+                } finally {
+                    in.close();
+                }
+            case "createFile":
+                return relative(base, Files.createFile(p));
+            case "createDirectory":
+                return relative(base, Files.createDirectory(p));
+            case "createDirectories":
+                return relative(base, Files.createDirectories(p));
+            case "delete":
+                Files.delete(p);
+                return "ok";
+            case "deleteIfExists":
+                return String.valueOf(Files.deleteIfExists(p));
+            case "copy":
+                return relative(base, Files.copy(p, q));
+            case "copyReplace":
+                return relative(base, Files.copy(p, q, StandardCopyOption.REPLACE_EXISTING));
+            case "copyIn":
+                return String.valueOf(Files.copy(new ByteArrayInputStream(bytes), p));
+            case "copyOut":
+                ByteArrayOutputStream sink = new ByteArrayOutputStream();
+                return Files.copy(p, sink) + ":" + sink.toString("UTF-8");
+            case "move":
+                return relative(base, Files.move(p, q));
+            case "moveReplace":
+                return relative(base, Files.move(p, q, StandardCopyOption.REPLACE_EXISTING));
+            case "mismatch":
+                return String.valueOf(Files.mismatch(p, q));
+            case "same":
+                return String.valueOf(Files.isSameFile(p, q));
+            case "dir":
+                DirectoryStream<Path> ds = Files.newDirectoryStream(p);
+                try {
+                    return sorted(ds.iterator(), base);
+                } finally {
+                    ds.close();
+                }
+            case "glob":
+                DirectoryStream<Path> gs = Files.newDirectoryStream(p, text);
+                try {
+                    return sorted(gs.iterator(), base);
+                } finally {
+                    gs.close();
+                }
+            case "tree":
+                final List<String> log = new ArrayList<String>();
+                final String stop = text;
+                Files.walkFileTree(p, new SimpleFileVisitor<Path>() {
+                    @Override
+                    public FileVisitResult preVisitDirectory(Path d, BasicFileAttributes at3) {
+                        log.add("pre " + relative(p, d));
+                        return d.getFileName().toString().equals(stop) ? FileVisitResult.SKIP_SUBTREE
+                                : FileVisitResult.CONTINUE;
+                    }
+
+                    @Override
+                    public FileVisitResult visitFile(Path f, BasicFileAttributes at3) {
+                        log.add("file " + relative(p, f));
+                        return FileVisitResult.CONTINUE;
+                    }
+
+                    @Override
+                    public FileVisitResult postVisitDirectory(Path d, IOException e) {
+                        log.add("post " + relative(p, d));
+                        return FileVisitResult.CONTINUE;
+                    }
+                });
+                Collections.sort(log);
+                return log.toString();
+            default:
+                throw new IllegalStateException(name);
+        }
+    }
+
+    /// One step's answer, or the simple name of what it threw. The JDK
+    /// reports a directory opened as a file in several ways, by platform;
+    /// all of them are an IOException and print as `<io>`.
+    private static String step(Path base, String[] s) {
+        String answer;
+        try {
+            answer = op(base, s[0], s[1], s[2], s[3]);
+        } catch (IOException e) {
+            answer = e.getClass().getSimpleName();
+        } catch (RuntimeException e) {
+            answer = e.getClass().getSimpleName();
+        }
+        if (answer.equals("IOException") || answer.equals("FileSystemException")
+                || answer.equals("AccessDeniedException")) {
+            return "<io>";
+        }
+        return answer;
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("NioFiles.theScriptAnswersTheSameOnBothFileSystems", () -> {
+            File dir = scratch("script");
+            try {
+                Path base = Paths.get(dir.getPath());
+                for (int i = 0; i < SCRIPT.length; i++) {
+                    String[] s = SCRIPT[i];
+                    Bulk.p(i + " " + s[0] + " " + s[1] + (s[2] == null ? "" : " " + s[2]), step(base, s));
+                }
+            } finally {
+                cleanup(dir);
+            }
+        });
+        Bulk.check("NioFiles.largeFilesAreComparedBlockByBlock", () -> {
+            File dir = scratch("large");
+            try {
+                byte[] data = new byte[20000];
+                for (int i = 0; i < data.length; i++) {
+                    data[i] = (byte) (i * 31);
+                }
+                Path one = Paths.get(new File(dir, "big1.bin").getPath());
+                Path two = Paths.get(new File(dir, "big2.bin").getPath());
+                Files.write(one, data);
+                Files.write(two, data);
+                Bulk.p("same", Files.mismatch(one, two));
+                byte[] other = data.clone();
+                other[12345]++;
+                Files.write(two, other);
+                Bulk.p("oneByte", Files.mismatch(one, two));
+                Files.write(two, Arrays.copyOf(data, 16384));
+                Bulk.p("shorter", Files.mismatch(one, two));
+            } finally {
+                cleanup(dir);
+            }
+        });
+        Bulk.check("NioFiles.aMoveThatCannotDeleteTheSourceFails", () -> {
+            File dir = scratch("locked");
+            File locked = new File(dir, "locked");
+            try {
+                Bulk.p("mkdirs", new File(locked, "tree").mkdirs());
+                Bulk.p("create", new File(locked, "tree/a.txt").createNewFile());
+                Bulk.p("setWritable", locked.setWritable(false));
+                boolean writable;
+                try {
+                    writable = new File(locked, "probe").createNewFile();
+                } catch (IOException refused) {
+                    writable = false;
+                }
+                // A user who may write anywhere cannot be refused; both runs
+                // are the same user, so both then print only this line.
+                Bulk.p("probeWritable", writable);
+                if (!writable) {
+                    Bulk.pThrown("move", IOException.class, () -> Files.move(Paths.get(locked + "/tree"),
+                            Paths.get(dir + "/unlocked")));
+                    Bulk.p("sourceStillThere", new File(locked, "tree").isDirectory());
+                    Bulk.p("targetAbsent", !new File(dir, "unlocked").exists());
+                }
+            } finally {
+                locked.setWritable(true);
+                cleanup(dir);
+            }
+        });
+        // The temporary directory is the host's caches directory, which the
+        // check points at its own scratch directory.
+        Bulk.cn1Only("NioFiles.aTemporaryFileIsCreatedAndUnique", () -> {
+            File dir = scratch("temp");
+            try {
+                final String caches = dir.getPath();
+                com.codename1.impl.JdkHost.install(new PosixJdkHost() {
+                    @Override
+                    public String cachesDir() {
+                        return caches;
+                    }
+                });
+                Path a = Files.createTempFile("pre", ".bin");
+                Path b = Files.createTempFile("pre", ".bin");
+                Bulk.expect(Files.isRegularFile(a), "a is a file");
+                Bulk.expect(Files.isRegularFile(b), "b is a file");
+                Bulk.expect(!a.equals(b), "a and b differ");
+                Bulk.expect(a.getFileName().toString().startsWith("pre"), "prefix: " + a.getFileName());
+                Bulk.expect(a.getFileName().toString().endsWith(".bin"), "suffix: " + a.getFileName());
+                Path tmp = Files.createTempDirectory("work");
+                Bulk.expect(Files.isDirectory(tmp), "a directory");
+                Path inside = Files.createTempFile(tmp, null, null);
+                Bulk.expectEquals(tmp, inside.getParent(), "made in the directory given");
+                Bulk.expect(inside.getFileName().toString().endsWith(".tmp"), ".tmp: " + inside.getFileName());
+                Bulk.expectEquals(Paths.get(caches), a.getParent(), "made in the host's caches directory");
+            } finally {
+                cleanup(dir);
+            }
+        });
+        Bulk.check("NioFiles.aFileTimePrintsAsTheJdkPrintsIt", () -> {
+            long[] times = {0L, 1L, 999L, 1000L, 1709209805250L, 1700000000000L, -1L, -86400000L,
+                253402300799999L, 951782400000L, 951868800000L, 4102444800000L, -62135596800000L,
+                1234567890120L, 1234567890100L};
+            for (long t : times) {
+                FileTime ft = FileTime.fromMillis(t);
+                Bulk.p("toString[" + t + "]", ft.toString());
+                Bulk.p("epochMilli[" + t + "]", ft.toInstant().toEpochMilli());
+                Bulk.p("seconds[" + t + "]", ft.to(TimeUnit.SECONDS));
+            }
+            Bulk.p("compareSame", FileTime.fromMillis(5).compareTo(FileTime.from(5, TimeUnit.MILLISECONDS)));
+            Bulk.p("compareLess", FileTime.fromMillis(5).compareTo(FileTime.fromMillis(6)) < 0);
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/NioPathChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/NioPathChecks.java
new file mode 100644
index 00000000000..bbc975b797d
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/NioPathChecks.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.net.URI;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Iterator;
+
+/// Every method of java.nio.file.Path that only rearranges names, on the
+/// same inputs, as a Unix file system answers them. Every path here is
+/// described, never opened, so none of them is a real directory.
+public final class NioPathChecks {
+    private NioPathChecks() {
+    }
+
+    private static final String[] PATHS = {"", "/", "a", "a/b", "/a", "/a/b", "/a/b/c", "a/b/c/d", ".", "..", "./a",
+        "../a", "a/..", "a/./b", "a/../b", "/..", "/../a", "/a/../..", "a/b/../../..", "//a//b//", "a/", "/a/b/",
+        "a.txt", "dir/a.txt", "/dir/sub/a.tar.gz", ".hidden", "/a/b/../c/./d", "x/y", "a/b/c", "b", "/b", "..//..",
+        "a b/c d", "/usr/local/bin", "/usr/local", "local/bin", "bin"};
+
+    private interface Probe {
+        String run(Path a, Path b);
+    }
+
+    private static String text(Object o) {
+        return o == null ? "null" : o.toString();
+    }
+
+    private static int sign(int n) {
+        return n < 0 ? -1 : n > 0 ? 1 : 0;
+    }
+
+    private static String names(Iterator<?> it) {
+        StringBuilder sb = new StringBuilder();
+        while (it.hasNext()) {
+            sb.append('<').append(it.next()).append('>');
+        }
+        return sb.toString();
+    }
+
+    private static String run(Probe probe, String a, String b) {
+        try {
+            return probe.run(Paths.get(a), Paths.get(b));
+        } catch (RuntimeException e) {
+            return e.getClass().getSimpleName();
+        }
+    }
+
+    private static final Probe DESCRIBE = (a, b) -> a + "|" + a.isAbsolute() + "|" + text(a.getRoot()) + "|"
+            + text(a.getFileName()) + "|" + text(a.getParent()) + "|" + a.getNameCount() + "|" + names(a.iterator())
+            + "|" + a.normalize() + "|" + a.toFile().getPath() + "|" + a.hashCode() % 1;
+
+    private static final Probe SUBPATHS = (a, b) -> {
+        StringBuilder sb = new StringBuilder();
+        for (int i = -1; i <= a.getNameCount(); i++) {
+            try {
+                sb.append(a.getName(i)).append(',');
+            } catch (IllegalArgumentException e) {
+                sb.append("IAE,");
+            }
+            for (int j = i; j <= a.getNameCount() + 1; j++) {
+                try {
+                    sb.append(a.subpath(i, j)).append(';');
+                } catch (IllegalArgumentException e) {
+                    sb.append("IAE;");
+                }
+            }
+        }
+        return sb.toString();
+    };
+
+    private static final Probe COMBINE = (a, b) -> a.resolve(b) + "|" + a.resolve(b.toString()) + "|"
+            + a.resolveSibling(b) + "|" + a.resolveSibling(b.toString()) + "|" + a.startsWith(b) + "|"
+            + a.startsWith(b.toString()) + "|" + a.endsWith(b) + "|" + a.endsWith(b.toString()) + "|"
+            + sign(a.compareTo(b)) + "|" + a.equals(b);
+
+    private static final Probe RELATIVIZE = (a, b) -> a.relativize(b).toString();
+
+    /// `relativize` between a path with `.` or `..` names and another is
+    /// where JDK releases disagree with each other, so those pairs are left
+    /// to [#run]'s `relativizeNormalizesDottedPaths`.
+    private static boolean dotted(String p) {
+        return p.equals(".") || p.equals("..") || p.startsWith("./") || p.startsWith("../") || p.contains("/./")
+                || p.contains("/../") || p.endsWith("/..") || p.endsWith("/.");
+    }
+
+    private static String ofUri(String uri) {
+        try {
+            return Paths.get(URI.create(uri)).toString();
+        } catch (IllegalArgumentException e) {
+            return "IllegalArgumentException: " + e.getMessage();
+        }
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("NioPath.oneDescribedPathAnswersAsTheJdkDoes", () -> {
+            for (String a : PATHS) {
+                Bulk.p("describe[" + a + "]", run(DESCRIBE, a, ""));
+            }
+            for (String a : PATHS) {
+                Bulk.p("subpaths[" + a + "]", run(SUBPATHS, a, ""));
+            }
+        });
+        Bulk.check("NioPath.twoPathsCombineAsInTheJdk", () -> {
+            for (String a : PATHS) {
+                for (String b : PATHS) {
+                    Bulk.p("[" + a + "][" + b + "]", run(COMBINE, a, b));
+                    if (!dotted(a) && !dotted(b)) {
+                        Bulk.p("relativize[" + a + "][" + b + "]", run(RELATIVIZE, a, b));
+                    }
+                }
+            }
+        });
+        // What a current JDK answers for the dotted pairs the comparison above
+        // leaves out: both sides are normalized first, so a name that cancels
+        // the one before it is no step away from anything.
+        Bulk.check("NioPath.relativizeNormalizesDottedPaths", () -> {
+            String[][] cases = {{"a/..", "b"}, {"a/../c", "c/d"}, {"a/b", "a/./c"}, {"/a/../b", "/b/c"},
+                {"a", "../b"}, {"a/./b", "a/b"}, {"a/b/..", "a"}, {"", "a/../b"}};
+            for (String[] c : cases) {
+                Bulk.p("[" + c[0] + "][" + c[1] + "]", Paths.get(c[0]).relativize(Paths.get(c[1])).toString());
+            }
+            // A `..` that nothing cancels still leads nowhere that can be named.
+            for (String from : new String[] {"../a", "a/../..", ".."}) {
+                String answer;
+                try {
+                    answer = "none: " + Paths.get(from).relativize(Paths.get("b"));
+                } catch (IllegalArgumentException expected) {
+                    answer = "IAE " + String.valueOf(expected.getMessage()).startsWith("Unable to compute");
+                }
+                Bulk.p("[" + from + "][b]", answer);
+            }
+        });
+        Bulk.check("NioPath.severalNamesJoinIntoOnePath", () -> {
+            String[][] cases = {{"a", "b", "c"}, {"/", "a"}, {"", "a"}, {"a", "", "b"}, {"/a/", "/b/"}, {"a"},
+                {"", ""}, {"a/b", "c/d"}};
+            for (String[] c : cases) {
+                String[] more = new String[c.length - 1];
+                System.arraycopy(c, 1, more, 0, more.length);
+                Bulk.p("get" + Bulk.fmt(c), Paths.get(c[0], more).toString());
+                Bulk.p("of" + Bulk.fmt(c), Path.of(c[0], more).toString());
+            }
+        });
+        // The form Codename One names files in is a root like any other; the
+        // JDK reads `file:` as a relative name.
+        Bulk.cn1Only("NioPath.aFileSchemePathHasItsSchemeForARoot", () -> {
+            Path p = Paths.get("file:///var/data/app/notes.txt");
+            Bulk.expect(p.isAbsolute(), "absolute");
+            Bulk.expectEquals("file:///", p.getRoot().toString(), "root");
+            Bulk.expectEquals("notes.txt", p.getFileName().toString(), "file name");
+            Bulk.expectEquals("file:///var/data/app", p.getParent().toString(), "parent");
+            Bulk.expectEquals(Integer.valueOf(4), Integer.valueOf(p.getNameCount()), "name count");
+            Bulk.expectEquals("file:///var/data/app/other.txt", p.resolveSibling("other.txt").toString(),
+                    "resolveSibling");
+            Bulk.expectEquals("app/notes.txt", Paths.get("file:///var/data").relativize(p).toString(), "relativize");
+            Bulk.expectEquals("file:///var/notes.txt",
+                    Paths.get("file:///var/data/../notes.txt").normalize().toString(), "normalize");
+            Bulk.expectEquals("/var/data/app/notes.txt",
+                    Paths.get(URI.create("file:///var/data/app/notes.txt")).toString(), "of a URI");
+        });
+        // A name with a character a URI escapes has the URI the JDK gives it.
+        Bulk.check("NioPath.aPathWithASpaceOrAHashHasAnEscapedUri", () -> {
+            String name = "/var/data/my notes#1 50%.txt";
+            URI uri = Paths.get(name).toUri();
+            // Compared with URI.equals, as the original did: the JDK writes an
+            // empty authority (`file:///`) and JavaAPI none (`file:/`), which
+            // URI.equals treats as the same URI.
+            Bulk.p("uriEquals", uri.equals(URI.create("file:///var/data/my%20notes%231%2050%25.txt")));
+            Bulk.p("scheme", uri.getScheme());
+            Bulk.p("authority", uri.getRawAuthority());
+            Bulk.p("rawPath", uri.getRawPath());
+            Bulk.p("path", uri.getPath());
+        });
+        // Only a `file:` URI that is a path and nothing else is one: a host, a
+        // query or a fragment is refused, not dropped.
+        Bulk.check("NioPath.aFileUriWithMoreThanAPathIsRefused", () -> {
+            for (String uri : new String[] {"file:/var/data/a.txt", "file:///var/data/a.txt",
+                "file:/var/my%20data/a.txt", "file:/", "file:/var/data/a.txt?version=2", "file:/var/data/a.txt#top",
+                "file://server/share/a.txt", "file://user@server:8080/a.txt", "file:relative/a.txt", "file:/a?b",
+                "file:/a#b", "file://host/a", "file:a"}) {
+                Bulk.p(uri, ofUri(uri));
+            }
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/OptionalChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/OptionalChecks.java
new file mode 100644
index 00000000000..959d034d183
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/OptionalChecks.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.NoSuchElementException;
+import java.util.Optional;
+
+/// java.util.Optional.
+public final class OptionalChecks {
+    private OptionalChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("Optional.presentValue", () -> {
+            Optional<String> o = Optional.of("cn1");
+            Bulk.p("isPresent", o.isPresent());
+            Bulk.p("get", o.get());
+            Bulk.p("orElse", o.orElse("x"));
+            Bulk.p("map", o.map(String::length).get());
+            Bulk.p("filterTrue", o.filter(s -> s.startsWith("c")).isPresent());
+            Bulk.p("filterFalse", o.filter(s -> s.startsWith("z")).isPresent());
+            Bulk.p("hashCode", o.hashCode());
+            Bulk.p("toString", o.toString());
+            Bulk.p("equalsOf", o.equals(Optional.of("cn1")));
+        });
+        Bulk.check("Optional.emptyValue", () -> {
+            Optional<String> o = Optional.ofNullable(null);
+            Bulk.p("isPresent", o.isPresent());
+            Bulk.p("orElse", o.orElse("x"));
+            Bulk.p("orElseGet", o.orElseGet(() -> "y"));
+            Bulk.p("hashCode", o.hashCode());
+            Bulk.p("toString", o.toString());
+            Bulk.p("equalsEmpty", o.equals(Optional.empty()));
+            Bulk.pThrown("get", NoSuchElementException.class, o::get);
+            Bulk.pThrown("ofNull", NullPointerException.class, () -> Optional.of(null));
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ParseNumberChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ParseNumberChecks.java
new file mode 100644
index 00000000000..42c12f23cbc
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ParseNumberChecks.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// `Double.parseDouble` and `Float.parseFloat` at the edges of the range: an
+/// exponent past the largest finite value is an infinity and one past the
+/// smallest subnormal is a zero, with the sign kept either way.
+public final class ParseNumberChecks {
+    private ParseNumberChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("ParseNumber.doubleOverflowAndUnderflow", () -> {
+            String[] inputs = {"1.5E400", "-1.5E400", "1e309", "1.7976931348623157E308", "1e-400", "-1e-400",
+                "4.9E-324", "2e-324", "123456789012345678901234567890e300", "0.000001e-320"};
+            for (String s : inputs) {
+                double d = Double.parseDouble(s);
+                Bulk.p(s, d + "/" + Long.toHexString(Double.doubleToRawLongBits(d)));
+            }
+        });
+        Bulk.check("ParseNumber.floatOverflowAndUnderflow", () -> {
+            String[] inputs = {"1e40", "-1e40", "3.4028235E38", "1e-50", "-1e-50", "1.4E-45"};
+            for (String s : inputs) {
+                float f = Float.parseFloat(s);
+                Bulk.p(s, f + "/" + Integer.toHexString(Float.floatToRawIntBits(f)));
+            }
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PreferencesChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PreferencesChecks.java
new file mode 100644
index 00000000000..8d7b75d8b07
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PreferencesChecks.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.prefs.Preferences;
+
+/// java.util.prefs.Preferences over the host's flat store, with the
+/// hardening the compat layer's copy earned: escaped keys that never alias
+/// another node's entries, a per-node key index kept whole under concurrent
+/// writers, and removeNode that removes the subtree and leaves every
+/// instance for a removed node throwing.
+///
+/// Every check here is ParparVM only. The expectations are what
+/// `java.util.prefs` answers on the JDK, as literals, because running the
+/// JDK's would write to the real preferences of the user running the build.
+/// The bulk host keeps preferences in JdkHost's in-memory defaults.
+public final class PreferencesChecks {
+    private PreferencesChecks() {
+    }
+
+    private static Object thrown(Class<?> type, Bulk.Body body) {
+        return Bulk.thrown(type, body);
+    }
+
+    /// Runs the group.
+    public static void run() {
+        // Several threads adding keys to one node, each through an instance
+        // of its own: every key is kept.
+        Bulk.cn1Only("Preferences.keysAddedFromSeveralThreadsAreAllIndexed", () -> {
+            final String node = "/cn1/test/concurrent";
+            Thread[] writers = new Thread[4];
+            for (int t = 0; t < writers.length; t++) {
+                final int id = t;
+                writers[t] = new Thread(() -> {
+                    for (int i = 0; i < 50; i++) {
+                        Preferences.userRoot().node(node).put("k" + id + "." + i, "v");
+                    }
+                });
+                writers[t].start();
+            }
+            for (Thread w : writers) {
+                w.join();
+            }
+            Preferences prefs = Preferences.userRoot().node(node);
+            Bulk.expectEquals(Integer.valueOf(200), Integer.valueOf(prefs.keys().length), "keys indexed");
+            for (int t = 0; t < writers.length; t++) {
+                for (int i = 0; i < 50; i++) {
+                    Bulk.expectEquals("v", prefs.get("k" + t + "." + i, null), "k" + t + "." + i);
+                }
+            }
+            prefs.put("a\nb", "1");
+            prefs.put("c\\nd", "2");
+            List<String> keys = Arrays.asList(prefs.keys());
+            Bulk.expect(keys.contains("a\nb"), "a line break in a key");
+            Bulk.expect(keys.contains("c\\nd"), "a backslash in a key");
+            Bulk.expectEquals(Integer.valueOf(202), Integer.valueOf(keys.size()), "keys");
+            prefs.remove("a\nb");
+            Bulk.expect(!Arrays.asList(prefs.keys()).contains("a\nb"), "removed");
+            prefs.clear();
+            Bulk.expectEquals(Integer.valueOf(0), Integer.valueOf(prefs.keys().length), "cleared");
+            Bulk.expectEquals("gone", prefs.get("c\\nd", "gone"), "cleared value");
+        });
+        // A key may hold a slash or a line break, and none of it makes one
+        // entry another's.
+        Bulk.cn1Only("Preferences.keysNeverAliasAnotherNodesEntries", () -> {
+            Preferences a = Preferences.userRoot().node("/cn1/test/alias/a");
+            Preferences ab = Preferences.userRoot().node("/cn1/test/alias/a/b");
+            a.put("b/c", "x");
+            ab.put("c", "y");
+            a.put("\nkeys", "not the index");
+            a.put("\n", "line break");
+            Bulk.expectEquals("x", a.get("b/c", null), "b/c");
+            Bulk.expectEquals("y", ab.get("c", null), "c of a/b");
+            Bulk.expectEquals("not the index", a.get("\nkeys", null), "a key named like the index");
+            Bulk.expectEquals("line break", a.get("\n", null), "a key that is a line break");
+            Bulk.expectEquals(Arrays.asList("b/c", "\nkeys", "\n"), Arrays.asList(a.keys()), "keys of a");
+            Bulk.expectEquals(Arrays.asList("c"), Arrays.asList(ab.keys()), "keys of a/b");
+            a.clear();
+            ab.clear();
+            Bulk.expectEquals("y", ab.get("c", "y"), "a/b cleared");
+            Bulk.expectEquals(Integer.valueOf(0), Integer.valueOf(a.keys().length), "a cleared");
+        });
+        Bulk.cn1Only("Preferences.removeNodeRemovesTheWholeSubtree", () -> {
+            Bulk.expectEquals("UnsupportedOperationException",
+                    thrown(UnsupportedOperationException.class, () -> Preferences.userRoot().removeNode()),
+                    "the root cannot be removed");
+            Preferences root = Preferences.userRoot();
+            Preferences a = root.node("/cn1/test/remove/a");
+            Preferences b = a.node("b");
+            a.put("k", "v");
+            b.put("x", "y");
+            Preferences.userRoot().node("/cn1/test/remove/keep").put("z", "w");
+            Preferences top = root.node("/cn1/test/remove");
+            Bulk.expectEquals(Arrays.asList("a", "keep"), Arrays.asList(top.childrenNames()), "children");
+            Bulk.expect(root.nodeExists("/cn1/test/remove/a/b"), "a/b exists");
+
+            Preferences doomed = root.node("/cn1/test/remove/a");
+            doomed.removeNode();
+            for (Preferences gone : new Preferences[] {doomed, a, b}) {
+                String n = gone.absolutePath();
+                Bulk.expectEquals("IllegalStateException",
+                        thrown(IllegalStateException.class, () -> gone.get("k", "d")), "get on removed " + n);
+                Bulk.expectEquals("IllegalStateException",
+                        thrown(IllegalStateException.class, () -> gone.put("k", "d")), "put on removed " + n);
+                Bulk.expectEquals("IllegalStateException",
+                        thrown(IllegalStateException.class, () -> gone.sync()), "sync on removed " + n);
+                Bulk.expect(!gone.nodeExists(""), "removed " + n + " does not exist");
+            }
+            // As the JDK: "Node already removed."
+            Bulk.expectEquals("IllegalStateException",
+                    thrown(IllegalStateException.class, () -> doomed.removeNode()), "removed twice");
+            Bulk.expectEquals("a", doomed.name(), "name of a removed node");
+            Bulk.expectEquals("/cn1/test/remove/a", doomed.absolutePath(), "path of a removed node");
+            Bulk.expect(!root.nodeExists("/cn1/test/remove/a"), "a is gone");
+            Bulk.expect(!root.nodeExists("/cn1/test/remove/a/b"), "a/b is gone");
+            Bulk.expectEquals(Arrays.asList("keep"), Arrays.asList(top.childrenNames()), "children after");
+            Bulk.expectEquals("w", root.node("/cn1/test/remove/keep").get("z", null), "keep is kept");
+            Preferences fresh = root.node("/cn1/test/remove/a");
+            Bulk.expectEquals("gone", fresh.get("k", "gone"), "a recreated is empty");
+            Bulk.expectEquals("gone", fresh.node("b").get("x", "gone"), "a/b recreated is empty");
+            Bulk.expectEquals(Integer.valueOf(0), Integer.valueOf(fresh.node("b").keys().length), "a/b keys");
+            fresh.put("k", "again");
+            Bulk.expectEquals("again", root.node("/cn1/test/remove/a").get("k", null), "a written again");
+            top.removeNode();
+            Bulk.expect(!root.nodeExists("/cn1/test/remove"), "the top is gone");
+        });
+        // Typed values are stored as text and read back as the JDK reads them.
+        Bulk.cn1Only("Preferences.typedValuesReadAsTheJdkReadsThem", () -> {
+            Preferences p = Preferences.userRoot().node("/cn1/test/typed");
+            p.putInt("i", 42);
+            p.putLong("l", -7L);
+            p.putBoolean("b", true);
+            p.putFloat("f", 1.5f);
+            p.putDouble("d", 2.25);
+            p.put("spaced", " 12 ");
+            p.put("bool", "TRUE");
+            p.put("junk", "x");
+            Bulk.expectEquals("42", p.get("i", null), "int as text");
+            Bulk.expectEquals(Integer.valueOf(42), Integer.valueOf(p.getInt("i", 0)), "getInt");
+            Bulk.expectEquals(Long.valueOf(-7L), Long.valueOf(p.getLong("l", 0L)), "getLong");
+            Bulk.expect(p.getBoolean("b", false), "getBoolean");
+            Bulk.expectEquals(Float.valueOf(1.5f), Float.valueOf(p.getFloat("f", 0f)), "getFloat");
+            Bulk.expectEquals(Double.valueOf(2.25), Double.valueOf(p.getDouble("d", 0.0)), "getDouble");
+            Bulk.expectEquals(Integer.valueOf(12), Integer.valueOf(p.getInt("spaced", 0)), "a spaced int");
+            Bulk.expect(p.getBoolean("bool", false), "TRUE");
+            Bulk.expectEquals(Integer.valueOf(9), Integer.valueOf(p.getInt("junk", 9)), "junk int");
+            Bulk.expect(!p.getBoolean("junk", false), "junk boolean");
+            Bulk.expectEquals(null, p.get("absent", null), "absent");
+            Bulk.expectEquals("NullPointerException",
+                    thrown(NullPointerException.class, () -> p.put("k", null)), "a null value");
+            Bulk.expectEquals("NullPointerException",
+                    thrown(NullPointerException.class, () -> p.get(null, "d")), "a null key");
+        });
+        Bulk.cn1Only("Preferences.namesAndPathsAsTheJdk", () -> {
+            Preferences root = Preferences.userRoot();
+            Bulk.expectEquals("", root.name(), "root name");
+            Bulk.expectEquals("/", root.absolutePath(), "root path");
+            Bulk.expectEquals(null, root.parent(), "root parent");
+            Preferences n = root.node("x/y");
+            Bulk.expectEquals("y", n.name(), "name");
+            Bulk.expectEquals("/x/y", n.absolutePath(), "path");
+            Bulk.expectEquals("/x", n.parent().absolutePath(), "parent");
+            Bulk.expectEquals("User Preference Node: /x/y", n.toString(), "toString");
+            // The original named its own package; this program is in the
+            // unnamed one, so a JDK class stands in.
+            Bulk.expectEquals("/java/lang", Preferences.userNodeForPackage(String.class).absolutePath(),
+                    "userNodeForPackage");
+            Bulk.expectEquals("IllegalArgumentException",
+                    thrown(IllegalArgumentException.class, () -> Preferences.userNodeForPackage(String[].class)),
+                    "an array class");
+            // The JDK's constants.
+            Bulk.expectEquals(Integer.valueOf(80), Integer.valueOf(Preferences.MAX_KEY_LENGTH), "MAX_KEY_LENGTH");
+            Bulk.expectEquals(Integer.valueOf(8192), Integer.valueOf(Preferences.MAX_VALUE_LENGTH),
+                    "MAX_VALUE_LENGTH");
+            Bulk.expectEquals(Integer.valueOf(80), Integer.valueOf(Preferences.MAX_NAME_LENGTH), "MAX_NAME_LENGTH");
+        });
+        // The entries go through the host, so a Codename One application keeps
+        // them in its own store.
+        Bulk.cn1Only("Preferences.writesThroughTheHost", () -> {
+            final Map<String, String> store = new HashMap<String, String>();
+            JdkHost.install(new JdkHost() {
+                @Override
+                public String preference(String key) {
+                    return store.get(key);
+                }
+
+                @Override
+                public void setPreference(String key, String value) {
+                    store.put(key, value);
+                }
+
+                @Override
+                public void deletePreference(String key) {
+                    store.remove(key);
+                }
+            });
+            Preferences.userRoot().node("/host").put("k", "v");
+            Bulk.expectEquals("v", store.get("/host\nk"), "the entry");
+            Bulk.expectEquals("k\n", store.get("/host\n\n"), "the node's key index");
+            Bulk.expectEquals("host\n", store.get("/\n\n\n"), "the root's child index");
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PrimitiveFunctionChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PrimitiveFunctionChecks.java
new file mode 100644
index 00000000000..872b1dfc6b3
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PrimitiveFunctionChecks.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiPredicate;
+import java.util.function.BooleanSupplier;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoublePredicate;
+import java.util.function.DoubleSupplier;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.IntToLongFunction;
+import java.util.function.IntUnaryOperator;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongFunction;
+import java.util.function.LongPredicate;
+import java.util.function.LongSupplier;
+import java.util.function.LongToDoubleFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.LongUnaryOperator;
+import java.util.function.ObjDoubleConsumer;
+import java.util.function.ObjIntConsumer;
+import java.util.function.ObjLongConsumer;
+import java.util.function.ToDoubleBiFunction;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntBiFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongBiFunction;
+import java.util.function.ToLongFunction;
+
+/// The defaults of the primitive java.util.function interfaces, and the
+/// single method of the rest.
+public final class PrimitiveFunctionChecks {
+    private PrimitiveFunctionChecks() {
+    }
+
+    private static char b(boolean v) {
+        return v ? 'T' : 'F';
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("PrimitiveFunction.predicates", () -> {
+            IntPredicate even = n -> n % 2 == 0;
+            IntPredicate big = n -> n > 5;
+            LongPredicate longP = n -> n > 5L;
+            DoublePredicate doubleP = d -> d > 0.5;
+            StringBuilder sb = new StringBuilder();
+            for (int n = -2; n < 12; n++) {
+                double d = n / 8.0;
+                sb.append(n).append(':')
+                        .append(b(even.and(big).test(n))).append(b(even.or(big).test(n)))
+                        .append(b(even.negate().test(n)))
+                        .append(b(longP.and(x -> x < 9L).test(n))).append(b(longP.or(x -> x == 0L).test(n)))
+                        .append(b(longP.negate().test(n)))
+                        .append(b(doubleP.and(x -> x < 1).test(d))).append(b(doubleP.or(x -> x < 0).test(d)))
+                        .append(b(doubleP.negate().test(d))).append(' ');
+            }
+            Bulk.p("primitive", sb.toString());
+            BiPredicate<String, Integer> longer = (s, n) -> s.length() > n;
+            StringBuilder bi = new StringBuilder();
+            for (String s : Arrays.asList("", "a", "abc")) {
+                for (int n = -1; n < 4; n++) {
+                    bi.append(s).append(n).append(':')
+                            .append(b(longer.and((x, y) -> y > 0).test(s, n)))
+                            .append(b(longer.or((x, y) -> y > 2).test(s, n)))
+                            .append(b(longer.negate().test(s, n))).append(' ');
+                }
+            }
+            Bulk.p("bi", bi.toString());
+        });
+        Bulk.check("PrimitiveFunction.combinatorsAskTheSecondOnlyWhenTheyMust", () -> {
+            int[] asked = new int[1];
+            IntPredicate counted = n -> {
+                asked[0]++;
+                return true;
+            };
+            IntPredicate never = n -> false;
+            IntPredicate always = n -> true;
+            never.and(counted).test(1);
+            always.or(counted).test(1);
+            Bulk.p("shortCircuited", asked[0]);
+            never.or(counted).test(1);
+            always.and(counted).test(1);
+            Bulk.p("asked", asked[0]);
+        });
+        Bulk.check("PrimitiveFunction.nullArgumentsAreRefusedWhenComposing", () -> {
+            IntPredicate p = n -> true;
+            IntUnaryOperator op = n -> n;
+            LongConsumer c = n -> { };
+            BiPredicate<String, String> bp = (x, y) -> true;
+            Bulk.pThrown("and", NullPointerException.class, () -> p.and(null));
+            Bulk.pThrown("or", NullPointerException.class, () -> p.or(null));
+            Bulk.pThrown("andThen", NullPointerException.class, () -> op.andThen(null));
+            Bulk.pThrown("compose", NullPointerException.class, () -> op.compose(null));
+            Bulk.pThrown("consumerAndThen", NullPointerException.class, () -> c.andThen(null));
+            Bulk.pThrown("biAnd", NullPointerException.class, () -> bp.and(null));
+        });
+        Bulk.check("PrimitiveFunction.operators", () -> {
+            IntUnaryOperator twice = n -> n * 2;
+            LongUnaryOperator thrice = n -> n * 3;
+            DoubleUnaryOperator half = d -> d / 2;
+            StringBuilder sb = new StringBuilder();
+            for (int n = -3; n < 4; n++) {
+                sb.append(n).append(':')
+                        .append(twice.andThen(x -> x + 3).applyAsInt(n)).append(',')
+                        .append(twice.compose(x -> x + 3).applyAsInt(n)).append(',')
+                        .append(IntUnaryOperator.identity().applyAsInt(n)).append(',')
+                        .append(thrice.andThen(x -> x - 1).applyAsLong(n)).append(',')
+                        .append(thrice.compose(x -> x - 1).applyAsLong(n)).append(',')
+                        .append(LongUnaryOperator.identity().applyAsLong(n)).append(',')
+                        .append(half.andThen(x -> x + 1).applyAsDouble(n)).append(',')
+                        .append(half.compose(x -> x + 1).applyAsDouble(n)).append(',')
+                        .append(DoubleUnaryOperator.identity().applyAsDouble(n)).append(' ');
+            }
+            Bulk.p("operators", sb.toString());
+        });
+        Bulk.check("PrimitiveFunction.consumersRunInOrderAndStopAtAFailure", () -> {
+            List<Object> seen = new ArrayList<Object>();
+            IntConsumer ic = seen::add;
+            ic.andThen(n -> seen.add(-n)).accept(4);
+            LongConsumer lc = seen::add;
+            lc.andThen(n -> seen.add(n * 2)).accept(5L);
+            DoubleConsumer dc = seen::add;
+            dc.andThen(n -> seen.add(n / 2)).accept(3.0);
+            Bulk.p("seen", seen);
+            IntConsumer failing = n -> {
+                throw new IllegalStateException();
+            };
+            Bulk.pThrown("failing", IllegalStateException.class, () -> failing.andThen(n -> seen.add("ran")).accept(1));
+            Bulk.p("seenAfter", seen);
+        });
+        Bulk.check("PrimitiveFunction.theRestAreTheirOneMethod", () -> {
+            IntBinaryOperator ib = (x, y) -> x * y;
+            LongBinaryOperator lb = (x, y) -> x - y;
+            DoubleBinaryOperator db = (x, y) -> x / y;
+            IntFunction<String> ifn = x -> "#" + x;
+            LongFunction<String> lfn = x -> "L" + x;
+            DoubleFunction<String> dfn = x -> "D" + x;
+            IntToLongFunction itl = x -> x * 1000000000L;
+            IntToDoubleFunction itd = x -> x / 4.0;
+            LongToIntFunction lti = x -> (int) (x >> 32);
+            LongToDoubleFunction ltd = x -> x / 8.0;
+            DoubleToIntFunction dti = x -> (int) Math.floor(x);
+            DoubleToLongFunction dtl = Math::round;
+            ToIntFunction<String> tif = String::length;
+            ToLongFunction<String> tlf = s -> s.length() * 10L;
+            ToDoubleFunction<String> tdf = s -> s.length() / 2.0;
+            ToIntBiFunction<String, String> tibf = (x, y) -> x.length() + y.length();
+            ToLongBiFunction<String, String> tlbf = (x, y) -> x.length() * (long) y.length();
+            ToDoubleBiFunction<String, String> tdbf = (x, y) -> x.length() / (double) y.length();
+            IntSupplier is = () -> 42;
+            LongSupplier ls = () -> 43L;
+            DoubleSupplier ds = () -> 4.5;
+            BooleanSupplier bs = () -> true;
+            List<Object> seen = new ArrayList<Object>();
+            ObjIntConsumer<String> oic = (s, x) -> seen.add(s + x);
+            ObjLongConsumer<String> olc = (s, x) -> seen.add(s + x);
+            ObjDoubleConsumer<String> odc = (s, x) -> seen.add(s + x);
+            oic.accept("a", 1);
+            olc.accept("b", 2L);
+            odc.accept("c", 3.5);
+            Bulk.p("intBinary", ib.applyAsInt(6, 7));
+            Bulk.p("longBinary", lb.applyAsLong(1, 2));
+            Bulk.p("doubleBinary", db.applyAsDouble(1, 4));
+            Bulk.p("functions", ifn.apply(1) + lfn.apply(2) + dfn.apply(0.5));
+            Bulk.p("intToLong", itl.applyAsLong(3));
+            Bulk.p("intToDouble", itd.applyAsDouble(3));
+            Bulk.p("longToInt", lti.applyAsInt(1L << 33));
+            Bulk.p("longToDouble", ltd.applyAsDouble(3));
+            Bulk.p("doubleToInt", dti.applyAsInt(-1.5));
+            Bulk.p("doubleToLong", dtl.applyAsLong(2.5));
+            Bulk.p("toInt", tif.applyAsInt("abc"));
+            Bulk.p("toLong", tlf.applyAsLong("ab"));
+            Bulk.p("toDouble", tdf.applyAsDouble("abc"));
+            Bulk.p("toIntBi", tibf.applyAsInt("a", "bc"));
+            Bulk.p("toLongBi", tlbf.applyAsLong("ab", "cde"));
+            Bulk.p("toDoubleBi", tdbf.applyAsDouble("a", "bcd"));
+            Bulk.p("suppliers", "" + is.getAsInt() + ls.getAsLong() + ds.getAsDouble() + bs.getAsBoolean());
+            Bulk.p("objConsumers", seen);
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PrimitiveStreamChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PrimitiveStreamChecks.java
new file mode 100644
index 00000000000..73b7b1d5b6f
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/PrimitiveStreamChecks.java
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.DoubleSummaryStatistics;
+import java.util.IntSummaryStatistics;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.NoSuchElementException;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import java.util.PrimitiveIterator;
+import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+/// java.util.stream's IntStream, LongStream and DoubleStream, their
+/// optionals and their summary statistics.
+public final class PrimitiveStreamChecks {
+    private static final int[] INTS = {5, 3, 8, 3, 1, 9, 2, 8, 7, 4, 6, 0, -4};
+    private static final long[] LONGS = {5000000000L, 3, -8000000000L, 3, 1, 9, 2, 5000000000L, 7};
+    private static final double[] DOUBLES = {0.1, 2.5, -3.75, 0.1, 1e10, 0.2, 0.3, -1e10, 7.0};
+
+    private PrimitiveStreamChecks() {
+    }
+
+    private static IntStream ints() {
+        return Arrays.stream(INTS);
+    }
+
+    private static void opt(String key, OptionalInt o) {
+        Bulk.p(key, o.isPresent() + " " + o + " " + (o.isPresent() ? o.getAsInt() : 0) + " " + o.orElse(-77));
+    }
+
+    private static void opt(String key, OptionalLong o) {
+        Bulk.p(key, o.isPresent() + " " + o + " " + o.orElse(-77L));
+    }
+
+    private static void opt(String key, OptionalDouble o) {
+        Bulk.p(key, o.isPresent() + " " + o + " " + o.orElse(-77.5));
+    }
+
+    /// The bit patterns of `values`, so a signed zero or a NaN payload shows.
+    private static String bits(double v) {
+        return v + "/" + Long.toHexString(Double.doubleToLongBits(v));
+    }
+
+    /// Runs the group.
+    public static void run() {
+        ranges();
+        intStreams();
+        iteratorsAndLife();
+        longsAndDoubles();
+        statistics();
+        optionals();
+    }
+
+    private static void ranges() {
+        Bulk.check("PrimitiveStream.intRangeAtEveryBoundary", () -> {
+            int max = Integer.MAX_VALUE;
+            int min = Integer.MIN_VALUE;
+            int[][] bounds = {{0, 0}, {0, 1}, {0, 5}, {5, 2}, {-3, 3}, {5, 5}, {5, 4}, {max - 2, max}, {max, max},
+                {min, min + 2}, {min, min}, {max, min}, {-1, 0}};
+            for (int[] b : bounds) {
+                String at = b[0] + ".." + b[1];
+                Bulk.p("range " + at, IntStream.range(b[0], b[1]).toArray());
+                Bulk.p("rangeClosed " + at, IntStream.rangeClosed(b[0], b[1]).toArray());
+            }
+            // The widest ranges, counted without being walked to the end.
+            Bulk.p("widestLimitSum", IntStream.rangeClosed(min, max).limit(3).sum());
+            Bulk.p("widestSkipFirst", IntStream.range(min, max).skip(4).findFirst().getAsInt());
+        });
+        Bulk.check("PrimitiveStream.longRangeAtEveryBoundary", () -> {
+            long max = Long.MAX_VALUE;
+            long min = Long.MIN_VALUE;
+            long[][] bounds = {{0, 0}, {0, 1}, {0, 5}, {5, 2}, {-3, 3}, {5, 5}, {5, 4}, {max - 2, max}, {max, max},
+                {min, min + 2}, {min, min}, {max, min}, {4000000000L, 4000000003L}};
+            for (long[] b : bounds) {
+                String at = b[0] + ".." + b[1];
+                Bulk.p("range " + at, LongStream.range(b[0], b[1]).toArray());
+                Bulk.p("rangeClosed " + at, LongStream.rangeClosed(b[0], b[1]).toArray());
+            }
+            Bulk.p("widestLimitSum", LongStream.rangeClosed(min, max).limit(3).sum());
+        });
+    }
+
+    private static void intStreams() {
+        Bulk.check("PrimitiveStream.intIntermediateOperations", () -> {
+            Bulk.p("filterMap", ints().filter(n -> n % 2 == 1).map(n -> n * 10).toArray());
+            Bulk.p("distinct", ints().distinct().toArray());
+            Bulk.p("sorted", ints().sorted().toArray());
+            Bulk.p("skipLimit", ints().skip(2).limit(4).toArray());
+            Bulk.p("flatMap", ints().flatMap(n -> IntStream.range(0, n)).toArray());
+            Bulk.p("flatMapNull", ints().flatMap(n -> n > 5 ? null : IntStream.of(n)).toArray());
+            List<Integer> seen = new ArrayList<Integer>();
+            Bulk.p("peekLimit", ints().peek(seen::add).limit(3).toArray());
+            Bulk.p("seen", seen);
+        });
+        Bulk.check("PrimitiveStream.intTerminalOperations", () -> {
+            Bulk.p("sum", ints().sum());
+            Bulk.p("count", ints().count());
+            opt("min", ints().min());
+            opt("max", ints().max());
+            opt("average", ints().average());
+            opt("findFirst", ints().findFirst());
+            opt("findAny", ints().skip(4).findAny());
+            opt("reduce", ints().reduce((a, b) -> a * 3 + b));
+            Bulk.p("reduceIdentity", ints().reduce(7, (a, b) -> a ^ b));
+            Bulk.p("any", ints().anyMatch(n -> n == 9));
+            Bulk.p("all", ints().allMatch(n -> n >= 0));
+            Bulk.p("none", ints().noneMatch(n -> n > 100));
+            Bulk.p("collect", ints().collect(StringBuilder::new, (sb, n) -> sb.append(n).append(';'),
+                    (a, b) -> a.append(b)).toString());
+            List<Integer> seen = new ArrayList<Integer>();
+            ints().forEach(seen::add);
+            Bulk.p("forEach", seen);
+            List<Integer> ordered = new ArrayList<Integer>();
+            ints().forEachOrdered(ordered::add);
+            Bulk.p("forEachOrdered", ordered);
+        });
+        Bulk.check("PrimitiveStream.intSumWrapsAsTheJdkDoes", () -> {
+            int[] big = {Integer.MAX_VALUE, Integer.MAX_VALUE, 5};
+            Bulk.p("sum", IntStream.of(big).sum());
+            // The average does not wrap: it is summed as a long.
+            opt("average", IntStream.of(big).average());
+        });
+        Bulk.check("PrimitiveStream.anEmptyIntStreamHasNoMinMaxOrAverage", () -> {
+            opt("min", IntStream.empty().min());
+            opt("max", IntStream.empty().max());
+            opt("average", IntStream.empty().average());
+            opt("findFirst", IntStream.empty().findFirst());
+            opt("reduce", IntStream.empty().reduce((a, b) -> a + b));
+            Bulk.p("sum", IntStream.empty().sum());
+            Bulk.pThrown("maxGet", NoSuchElementException.class, () -> IntStream.empty().max().getAsInt());
+            Bulk.pThrown("averageGet", NoSuchElementException.class, () -> IntStream.empty().average().getAsDouble());
+        });
+        Bulk.check("PrimitiveStream.intConversions", () -> {
+            Bulk.p("asLong", ints().asLongStream().map(n -> n * 3000000000L).toArray());
+            Bulk.p("asDouble", ints().asDoubleStream().map(n -> n / 4.0).toArray());
+            Bulk.p("mapToLong", ints().mapToLong(n -> n * 3000000000L).toArray());
+            Bulk.p("mapToDouble", ints().mapToDouble(n -> n / 8.0).toArray());
+            Bulk.p("mapToObj", ints().mapToObj(Integer::toHexString).collect(Collectors.joining("/")));
+            Bulk.p("boxed", ints().boxed().collect(Collectors.toList()));
+        });
+        Bulk.check("PrimitiveStream.intFactories", () -> {
+            Bulk.p("ofOne", IntStream.of(4).toArray());
+            Bulk.p("ofMany", IntStream.of(4, 5, 6).toArray());
+            Bulk.p("iterate", IntStream.iterate(1, n -> n * 3).limit(6).toArray());
+            final int[] next = {0};
+            Bulk.p("generate", IntStream.generate(() -> next[0]++).limit(4).toArray());
+            Bulk.p("concat", IntStream.concat(IntStream.range(0, 3), ints().limit(2)).toArray());
+            Bulk.p("boundedIterate", IntStream.iterate(1, n -> n < 50, n -> n * 3).toArray());
+            Bulk.p("takeWhile", ints().takeWhile(n -> n < 8).toArray());
+            Bulk.p("dropWhile", ints().dropWhile(n -> n != 0).toArray());
+        });
+        // Arrays.stream(array, from, to): the values, not the bounds check.
+        Bulk.check("PrimitiveStream.arraysStreamRanges", () -> {
+            Bulk.p("ints", Arrays.stream(INTS, 2, 6).toArray());
+            Bulk.p("intsEmpty", Arrays.stream(INTS, 4, 4).toArray());
+            Bulk.p("intsWhole", Arrays.stream(INTS, 0, INTS.length).toArray());
+            Bulk.p("longs", Arrays.stream(LONGS, 1, 5).toArray());
+            Bulk.p("doubles", Arrays.stream(DOUBLES, 1, 5).toArray());
+            String[] words = {"a", "b", "c", "d"};
+            Bulk.p("objects", Arrays.stream(words, 1, 3).toArray());
+            Bulk.p("objectsWhole", Arrays.stream(words).toArray());
+            // And the same values through what JavaAPI's Arrays builds them from.
+            Bulk.p("intsOfSkipLimit", IntStream.of(INTS).skip(2).limit(4).toArray());
+            Bulk.p("objectsOfSkipLimit", Stream.of(words).skip(1).limit(2).toArray());
+        });
+    }
+
+    private static void iteratorsAndLife() {
+        Bulk.check("PrimitiveStream.thePrimitiveIterators", () -> {
+            PrimitiveIterator.OfInt it = ints().filter(n -> n > 4).iterator();
+            List<Integer> walked = new ArrayList<Integer>();
+            while (it.hasNext()) {
+                walked.add(it.nextInt());
+            }
+            Bulk.p("walked", walked);
+            Bulk.p("hasNext", it.hasNext());
+            Bulk.pThrown("nextAtEnd", NoSuchElementException.class, it::nextInt);
+            PrimitiveIterator.OfLong longs = LongStream.of(4L, 5L).iterator();
+            Bulk.p("nextLong", longs.nextLong());
+            Bulk.p("nextBoxed", longs.next());
+            PrimitiveIterator.OfDouble doubles = DoubleStream.of(0.5).iterator();
+            Bulk.p("nextDouble", doubles.nextDouble());
+            Bulk.p("doublesHasNext", doubles.hasNext());
+        });
+        Bulk.check("PrimitiveStream.aPrimitiveStreamRunsOnce", () -> {
+            IntStream stream = ints();
+            Bulk.p("sum", stream.sum());
+            Bulk.pThrown("again", IllegalStateException.class, stream::sum);
+            IntStream staged = ints();
+            staged.map(n -> n);
+            Bulk.pThrown("secondStage", IllegalStateException.class, () -> staged.filter(n -> true));
+        });
+    }
+
+    private static void longsAndDoubles() {
+        Bulk.check("PrimitiveStream.longOperations", () -> {
+            Bulk.p("pipeline", LongStream.of(LONGS).filter(n -> n > 2).map(n -> n * 2).sorted().distinct().toArray());
+            Bulk.p("sum", LongStream.of(LONGS).sum());
+            Bulk.p("count", LongStream.of(LONGS).count());
+            opt("min", LongStream.of(LONGS).min());
+            opt("max", LongStream.of(LONGS).max());
+            opt("average", LongStream.of(LONGS).average());
+            opt("reduce", LongStream.of(LONGS).reduce((a, b) -> a - b));
+            opt("findFirst", LongStream.of(LONGS).skip(1).limit(2).findFirst());
+            Bulk.p("reduceIdentity", LongStream.of(LONGS).reduce(1L, (a, b) -> a + b));
+            Bulk.p("mapToInt", LongStream.of(LONGS).mapToInt(n -> (int) (n % 7)).toArray());
+            Bulk.p("asDouble", LongStream.of(LONGS).asDoubleStream().toArray());
+            Bulk.p("mapToDouble", LongStream.of(LONGS).mapToDouble(n -> n / 2.0).toArray());
+            Bulk.p("boxed", LongStream.of(LONGS).boxed().collect(Collectors.toList()));
+            Bulk.p("mapToObj", LongStream.of(LONGS).mapToObj(Long::toString).collect(Collectors.joining()));
+            Bulk.p("flatMap", LongStream.of(LONGS).flatMap(n -> LongStream.of(n, n)).limit(5).toArray());
+            Bulk.p("any", LongStream.of(LONGS).anyMatch(n -> n < 0));
+            Bulk.p("all", LongStream.of(LONGS).allMatch(n -> n < 0));
+            Bulk.p("none", LongStream.of(LONGS).noneMatch(n -> n == 0));
+            opt("emptyMin", LongStream.empty().min());
+            opt("emptyAverage", LongStream.empty().average());
+            Bulk.p("iterate", LongStream.iterate(1, n -> n * 5).limit(20).toArray());
+            Bulk.p("concat", LongStream.concat(LongStream.of(1), LongStream.of(2, 3)).toArray());
+        });
+        Bulk.check("PrimitiveStream.doubleOperations", () -> {
+            Bulk.p("pipeline", DoubleStream.of(DOUBLES).filter(d -> d > 0).map(d -> d * 3).sorted().distinct()
+                    .toArray());
+            Bulk.p("count", DoubleStream.of(DOUBLES).count());
+            opt("min", DoubleStream.of(DOUBLES).min());
+            opt("max", DoubleStream.of(DOUBLES).max());
+            opt("findFirst", DoubleStream.of(DOUBLES).findFirst());
+            opt("reduce", DoubleStream.of(DOUBLES).reduce((a, b) -> a / 2 + b));
+            Bulk.p("reduceIdentity", DoubleStream.of(DOUBLES).reduce(1.5, (a, b) -> a * 0.5 + b));
+            Bulk.p("mapToInt", DoubleStream.of(DOUBLES).mapToInt(d -> (int) d).toArray());
+            Bulk.p("mapToLong", DoubleStream.of(DOUBLES).mapToLong(d -> (long) (d * 10)).toArray());
+            Bulk.p("boxed", DoubleStream.of(DOUBLES).boxed().collect(Collectors.toList()));
+            Bulk.p("mapToObj", DoubleStream.of(DOUBLES).mapToObj(Double::toString).collect(Collectors.joining(" ")));
+            Bulk.p("flatMap", DoubleStream.of(DOUBLES).flatMap(d -> DoubleStream.of(d, -d)).skip(3).limit(5)
+                    .toArray());
+            Bulk.p("any", DoubleStream.of(DOUBLES).anyMatch(d -> d < 0));
+            Bulk.p("all", DoubleStream.of(DOUBLES).allMatch(d -> d < 0));
+            Bulk.p("none", DoubleStream.of(DOUBLES).noneMatch(d -> d == 0));
+            opt("emptyMin", DoubleStream.empty().min());
+            opt("emptyMax", DoubleStream.empty().max());
+            opt("emptyAverage", DoubleStream.empty().average());
+            Bulk.p("emptySum", DoubleStream.empty().sum());
+            Bulk.p("iterate", DoubleStream.iterate(1, d -> d / 3).limit(8).toArray());
+        });
+        Bulk.check("PrimitiveStream.doubleSumAndAverageAreCompensatedLikeTheJdks", () -> {
+            double[][] cases = {DOUBLES, {0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1}, {1e100, 1.0, -1e100},
+                {1.0, 1e-16, 1e-16, 1e-16, 1e-16}, {}, {3.5}, {-0.0}, {-0.0, -0.0}};
+            for (double[] values : cases) {
+                String at = Arrays.toString(values);
+                Bulk.p("sum " + at, bits(DoubleStream.of(values).sum()));
+                opt("average " + at, DoubleStream.of(values).average());
+            }
+        });
+        Bulk.check("PrimitiveStream.doubleSumOfInfinitiesAndNaN", () -> {
+            double inf = Double.POSITIVE_INFINITY;
+            double[][] cases = {{inf, 1.0}, {1.0, inf, 2.0}, {-inf, 1.0}, {inf, -inf}, {inf, inf}, {Double.NaN, 1.0},
+                {1.0, Double.NaN, inf}, {Double.MAX_VALUE, Double.MAX_VALUE}, {Double.MAX_VALUE, Double.MAX_VALUE, -inf}};
+            for (double[] values : cases) {
+                String at = Arrays.toString(values);
+                Bulk.p("sum " + at, bits(DoubleStream.of(values).sum()));
+                opt("min " + at, DoubleStream.of(values).min());
+                opt("max " + at, DoubleStream.of(values).max());
+            }
+        });
+        Bulk.check("PrimitiveStream.doubleMinAndMaxOrderTheZeros", () -> {
+            double[] zeros = {0.0, -0.0, 0.0};
+            Bulk.p("min", bits(DoubleStream.of(zeros).min().getAsDouble()));
+            Bulk.p("max", bits(DoubleStream.of(zeros).max().getAsDouble()));
+            Bulk.p("sorted", DoubleStream.of(zeros).sorted().toArray());
+            Bulk.p("distinct", DoubleStream.of(zeros).distinct().count());
+        });
+    }
+
+    private static void statistics() {
+        Bulk.check("PrimitiveStream.summaryStatistics", () -> {
+            IntSummaryStatistics i = ints().summaryStatistics();
+            Bulk.p("int", i.getCount() + " " + i.getSum() + " " + i.getMin() + " " + i.getMax() + " " + i.getAverage());
+            LongSummaryStatistics l = LongStream.of(LONGS).summaryStatistics();
+            Bulk.p("long", l.getCount() + " " + l.getSum() + " " + l.getMin() + " " + l.getMax() + " "
+                    + l.getAverage());
+            DoubleSummaryStatistics d = DoubleStream.of(DOUBLES).summaryStatistics();
+            Bulk.p("double", d.getCount() + " " + d.getSum() + " " + d.getMin() + " " + d.getMax() + " "
+                    + d.getAverage());
+        });
+        Bulk.check("PrimitiveStream.emptyStatisticsAnswerTheJdksSentinels", () -> {
+            IntSummaryStatistics i = new IntSummaryStatistics();
+            Bulk.p("int", i.getCount() + " " + i.getMin() + " " + i.getMax() + " " + i.getAverage());
+            LongSummaryStatistics l = new LongSummaryStatistics();
+            Bulk.p("long", l.getMin() + " " + l.getMax() + " " + l.getAverage());
+            DoubleSummaryStatistics d = new DoubleSummaryStatistics();
+            Bulk.p("double", d.getMin() + " " + d.getMax() + " " + d.getSum() + " " + d.getAverage());
+        });
+        Bulk.check("PrimitiveStream.statisticsCombine", () -> {
+            IntSummaryStatistics a = IntStream.of(1, 9).summaryStatistics();
+            a.combine(IntStream.of(-5, 20, 3).summaryStatistics());
+            a.accept(4);
+            Bulk.p("int", a.getCount() + " " + a.getSum() + " " + a.getMin() + " " + a.getMax());
+            DoubleSummaryStatistics d = DoubleStream.of(0.1, 0.2).summaryStatistics();
+            d.combine(DoubleStream.of(0.3, 1e10, -1e10).summaryStatistics());
+            Bulk.p("double", d.getCount() + " " + d.getSum() + " " + d.getAverage());
+        });
+    }
+
+    private static void optionals() {
+        Bulk.check("PrimitiveStream.optionalEqualityAndFallbacks", () -> {
+            Bulk.p("intEquals", OptionalInt.of(4).equals(OptionalInt.of(4)));
+            Bulk.p("intHash", OptionalInt.of(4).hashCode());
+            Bulk.p("intNotEquals", OptionalInt.of(4).equals(OptionalInt.of(5)));
+            Bulk.p("zeroVsEmpty", OptionalInt.of(0).equals(OptionalInt.empty()));
+            Bulk.p("emptyEquals", OptionalInt.empty().equals(OptionalInt.empty()));
+            Bulk.p("longHash", OptionalLong.of(1L << 40).hashCode());
+            Bulk.p("doubleHash", OptionalDouble.of(2.5).hashCode());
+            Bulk.p("nanEquals", OptionalDouble.of(Double.NaN).equals(OptionalDouble.of(Double.NaN)));
+            Bulk.p("orElseGetEmpty", OptionalInt.empty().orElseGet(() -> 9));
+            Bulk.p("orElseGetPresent", OptionalInt.of(3).orElseGet(() -> 9));
+            final int[] got = {0};
+            OptionalInt.of(6).ifPresent(v -> got[0] = v);
+            OptionalInt.empty().ifPresent(v -> got[0] = -1);
+            Bulk.p("ifPresent", got[0]);
+            String message = "none";
+            try {
+                OptionalLong.empty().orElseThrow(() -> new IllegalStateException("none thrown"));
+            } catch (IllegalStateException expected) {
+                message = expected.getMessage();
+            }
+            Bulk.p("orElseThrow", message);
+        });
+        // A call compiled against the JDK is linked by descriptor, and the
+        // JDK's primitive streams declare parallel() and sequential()
+        // answering their own type. Assigning each to its own type below
+        // only compiles if JavaAPI declares them the same way, and links on
+        // both runs only if the descriptor is the JDK's.
+        Bulk.check("PrimitiveStream.parallelAndSequentialAnswerTheStreamsOwnType", () -> {
+            IntStream ip = IntStream.range(0, 5).parallel();
+            IntStream is = ip.sequential();
+            Bulk.p("int", is.sum());
+            LongStream lp = LongStream.range(0, 5).parallel();
+            LongStream ls = lp.sequential();
+            Bulk.p("long", ls.sum());
+            DoubleStream dp = DoubleStream.of(0.5, 1.5).parallel();
+            DoubleStream ds = dp.sequential();
+            Bulk.p("double", ds.sum());
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleChecks.java
new file mode 100644
index 00000000000..3e2b5c41385
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleChecks.java
@@ -0,0 +1,445 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Locale;
+import java.util.MissingResourceException;
+import java.util.PropertyResourceBundle;
+import java.util.Random;
+import java.util.ResourceBundle;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/// java.util.ResourceBundle and PropertyResourceBundle: the `.properties`
+/// format, and the lookup of a bundle by name and locale over the files in
+/// `res/com/codename1/bulk/bundles` and the bundle classes below.
+public final class ResourceBundleChecks {
+    private static final String BASE = "com.codename1.bulk.bundles.Messages";
+
+    // A backslash, kept out of string literals next to a 'u': javac reads
+    // that pair as an escape wherever it appears.
+    private static final String BS = String.valueOf((char) 92);
+
+    private ResourceBundleChecks() {
+    }
+
+    /// The name of [ResourceBundleList], spelled out: ParparVM's `getName`
+    /// reports an '_' in a class name as a '.', so `ResourceBundleList_fr`
+    /// cannot be named through its class.
+    private static final String LIST = "ResourceBundleList";
+
+    /// What the build generates for an application: its bundle classes, made
+    /// without reflection. With `french` false only the base class is
+    /// registered.
+    private static final class ListRegistry implements JdkHost.Registry {
+        private final boolean french;
+
+        ListRegistry(boolean french) {
+            this.french = french;
+        }
+
+        @Override
+        public String[] providers(String service) {
+            return null;
+        }
+
+        @Override
+        public Object newInstance(String className) {
+            if (LIST.equals(className)) {
+                return new ResourceBundleList();
+            }
+            return french && (LIST + "_fr").equals(className) ? new ResourceBundleList_fr() : null;
+        }
+
+        @Override
+        public Class<?> type(String className) {
+            if (LIST.equals(className)) {
+                return ResourceBundleList.class;
+            }
+            return french && (LIST + "_fr").equals(className) ? ResourceBundleList_fr.class : null;
+        }
+    }
+
+    /// A check's body run with the default locale `Locale.US` and empty
+    /// bundle caches, the default restored afterwards.
+    private static Bulk.Body inUs(final Bulk.Body body) {
+        return () -> {
+            Locale saved = Locale.getDefault();
+            Locale.setDefault(Locale.US);
+            ResourceBundle.clearCache();
+            try {
+                body.run();
+            } finally {
+                Locale.setDefault(saved);
+                ResourceBundle.clearCache();
+            }
+        };
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("ResourceBundle.parsesPropertiesLikeTheJdk", () -> {
+            String[] texts = {
+                "",
+                "a=b",
+                "a=b\n",
+                "a = b",
+                "a : b",
+                "a:b",
+                "a b",
+                "a\tb",
+                "a   =   b   ",
+                "   a=b",
+                "\t a=b",
+                "a",
+                "a=",
+                "=b",
+                ":b",
+                " = b",
+                "# comment\na=b",
+                "! comment\na=b",
+                "  # indented comment\na=b",
+                "a=b # not a comment",
+                "a=b\r\nc=d\re=f\ng=h",
+                "a=b\n\n\nc=d",
+                "a=first\na=second",
+                "long=one \\\n    two \\\n    three",
+                "long=one\\\r\n   two",
+                "odd=ends with two \\\\\nnext=1",
+                "odd=ends with three \\\\\\\nstill the value",
+                "key\\ with\\ spaces=value",
+                "key\\=with\\:separators=value",
+                "key\\",
+                "a=b\\",
+                "tabs=\\ta\\nb\\rc\\fd",
+                "unknown=\\q\\z\\'\\\"",
+                "unicode=" + BS + "u0041" + BS + "u00e9" + BS + "u4E2D",
+                "unicodeKey" + BS + "u0020x=1",
+                "lower=" + BS + "u00ff" + BS + "u00FF",
+                "# a comment does not continue \\\na=b",
+                "a=b\n   \n  \t\nc=d",
+                "\\#notcomment=1",
+                "\\!notcomment=1",
+                "a==b",
+                "a=:b",
+                "a:=b",
+                "a = = b",
+                "a\\\n  b=c",
+                "a=b\\\n",
+                "a=b\\\n\n",
+                "a=b\\\n# not a comment\n",
+                "a=\\\n\\\n\\\nb",
+                "path=c:\\\\dir\\\\file",
+                "url=http://example.com/a?b=c",
+                "sp\\ ace : v",
+                "a\fb=c",
+                "\fa=b",
+                "a=" + (char) 0xE9 + (char) 0x4E2D,
+                "trailing=value\t \f",
+                "k1=v1\nk2:v2\nk3 v3\n",
+            };
+            for (int i = 0; i < texts.length; i++) {
+                Bulk.p("t" + i + " " + show(texts[i]), outcome(texts[i]));
+            }
+        });
+        Bulk.check("ResourceBundle.rejectsMalformedEscapesLikeTheJdk", () -> {
+            String[] texts = {
+                "a=" + BS + "u12", "a=" + BS + "uXYZW", "a=" + BS + "u", "a=" + BS + "u123", BS + "u00G0=1",
+                "a=" + BS + "u12\nb=2",
+            };
+            for (int i = 0; i < texts.length; i++) {
+                Bulk.p("t" + i + " " + show(texts[i]), outcome(texts[i]));
+            }
+        });
+        // After Java 8 the JDK reads a comment marker that follows an empty
+        // continued line as a comment. The texts on which the HotSpot run's
+        // JDK and Java 8 agree are compared here; the others are held to Java
+        // 8's answers, written out, by the check after this one.
+        Bulk.check("ResourceBundle.parsesRandomPropertiesLikeTheJdk", () -> {
+            List<String> texts = randomTexts();
+            java.util.Set<Integer> java8Only = new java.util.HashSet<Integer>();
+            for (int index : ResourceBundleJava8Table.INDEX) {
+                java8Only.add(Integer.valueOf(index));
+            }
+            int hash = 0;
+            int compared = 0;
+            for (int i = 0; i < texts.size(); i++) {
+                String text = texts.get(i);
+                if (text == null || java8Only.contains(Integer.valueOf(i))) {
+                    continue;
+                }
+                hash = 31 * hash + outcome(text).hashCode();
+                compared++;
+                if (i % 2000 == 1999) {
+                    Bulk.p("upTo" + i, hash + " over " + compared);
+                }
+            }
+            Bulk.p("all", hash + " over " + compared);
+        });
+        Bulk.cn1Only("ResourceBundle.parsesRandomPropertiesLikeTheJdkOnJava8", () -> {
+            List<String> texts = randomTexts();
+            for (int k = 0; k < ResourceBundleJava8Table.INDEX.length; k++) {
+                int i = ResourceBundleJava8Table.INDEX[k];
+                Bulk.expect(texts.get(i) != null, "text " + i + " is not one of the skipped ones");
+                if (texts.get(i) != null) {
+                    Bulk.expectEquals(ResourceBundleJava8Table.OUTCOME[k], outcome(texts.get(i)),
+                            "text " + i + " " + show(texts.get(i)));
+                }
+            }
+        });
+        Bulk.cn1Only("ResourceBundle.commentsDoNotReachTheNextLine", () -> {
+            // Where the JDK and JavaAPI part ways, pinned down.
+            Bulk.expectEquals("{b=1}", parse("# comment \\\nb=1").toString(), "hash comment");
+            Bulk.expectEquals("{b=1}", parse("! comment \\\r\n  b=1").toString(), "bang comment");
+        });
+        Bulk.check("ResourceBundle.readsStreamsAsLatin1LikeTheJdk", () -> {
+            byte[] bytes = {'k', '=', (byte) 0xE9, (byte) 0xFF, '\n', 'u', '=', '\\', 'u', '4', 'E', '2', 'D', '\n'};
+            PropertyResourceBundle bundle = new PropertyResourceBundle(new ByteArrayInputStream(bytes));
+            Bulk.p("k", bundle.getString("k"));
+            Bulk.p("u", bundle.getString("u"));
+            Bulk.p("keys", new TreeSet<String>(bundle.keySet()));
+            PropertyResourceBundle fromReader = new PropertyResourceBundle(new StringReader("a=1\nb=2"));
+            Bulk.p("a", fromReader.getString("a"));
+            Bulk.p("b", fromReader.getObject("b"));
+            Bulk.p("containsA", fromReader.containsKey("a"));
+            Bulk.p("containsC", fromReader.containsKey("c"));
+        });
+        Bulk.check("ResourceBundle.resolvesLocalesLikeTheJdk", inUs(() -> {
+            Locale[] locales = {
+                new Locale("", ""), new Locale("fr", ""), new Locale("fr", "CA"), new Locale("fr", "FR"),
+                new Locale("de", ""), new Locale("de", "DE"), new Locale("en", "US"), new Locale("en", "GB"),
+                new Locale("es", "MX"),
+            };
+            Locale[] defaults = {Locale.US, new Locale("fr", "CA"), new Locale("fr", "BE"), new Locale("de", "DE")};
+            for (Locale def : defaults) {
+                Locale.setDefault(def);
+                for (Locale locale : locales) {
+                    ResourceBundle.clearCache();
+                    Bulk.p("default " + def + " asked " + locale, describe(ResourceBundle.getBundle(BASE, locale)));
+                }
+                ResourceBundle.clearCache();
+                Bulk.p("default " + def, describe(ResourceBundle.getBundle(BASE)));
+            }
+        }));
+        Bulk.check("ResourceBundle.chainsToLessSpecificBundles", inUs(() -> {
+            ResourceBundle bundle = ResourceBundle.getBundle(BASE, new Locale("fr", "CA"));
+            Bulk.p("greeting", bundle.getString("greeting"));
+            Bulk.p("farewell", bundle.getString("farewell"));
+            Bulk.p("only.fr", bundle.getString("only.fr"));
+            Bulk.p("only.base", bundle.getString("only.base"));
+            Bulk.p("only.base object", bundle.getObject("only.base"));
+            Bulk.p("containsBase", bundle.containsKey("only.base"));
+            Bulk.p("containsAbsent", bundle.containsKey("absent"));
+            Bulk.p("keySet", new TreeSet<String>(bundle.keySet()));
+            List<String> keys = new ArrayList<String>();
+            for (Enumeration<String> e = bundle.getKeys(); e.hasMoreElements();) {
+                keys.add(e.nextElement());
+            }
+            Collections.sort(keys);
+            Bulk.p("getKeys", keys);
+            // The lookup is cached until told otherwise.
+            Bulk.p("cached", bundle == ResourceBundle.getBundle(BASE, new Locale("fr", "CA")));
+            ResourceBundle.clearCache();
+            Bulk.p("afterClear", bundle == ResourceBundle.getBundle(BASE, new Locale("fr", "CA")));
+        }));
+        // The JDK caches by the name as given, so the slashed name is another
+        // entry there, and it refuses a null class loader.
+        Bulk.cn1Only("ResourceBundle.chainsToLessSpecificBundlesCn1", inUs(() -> {
+            ResourceBundle bundle = ResourceBundle.getBundle(BASE, new Locale("fr", "CA"));
+            Bulk.expect(bundle == ResourceBundle.getBundle(BASE.replace('.', '/'), new Locale("fr", "CA")),
+                    "slashes name the same bundle as dots");
+            Bulk.expect(bundle == ResourceBundle.getBundle(BASE, new Locale("fr", "CA"), (ClassLoader) null),
+                    "a null loader answers the cached bundle");
+        }));
+        Bulk.check("ResourceBundle.reportsWhatIsMissingLikeTheJdk", inUs(() -> {
+            ResourceBundle bundle = ResourceBundle.getBundle(BASE, new Locale("fr", ""));
+            try {
+                bundle.getString("absent");
+                Bulk.p("absentKey", "none");
+            } catch (MissingResourceException e) {
+                Bulk.p("absentKey.key", e.getKey());
+                Bulk.p("absentKey.message", e.getMessage());
+            }
+            try {
+                ResourceBundle.getBundle("com.codename1.bulk.bundles.Nothing", new Locale("fr", "CA"));
+                Bulk.p("absentBundle", "none");
+            } catch (MissingResourceException e) {
+                Bulk.p("absentBundle.message", e.getMessage());
+                Bulk.p("absentBundle.className", e.getClassName());
+                Bulk.p("absentBundle.key", e.getKey());
+            }
+            Bulk.pThrown("nullName", NullPointerException.class, () -> ResourceBundle.getBundle(null));
+            // A bundle with no base file exists only for its own language.
+            Bulk.p("noBaseDeAt", ResourceBundle
+                    .getBundle("com.codename1.bulk.bundles.NoBase", new Locale("de", "AT")).getString("key"));
+            Bulk.pThrown("noBaseFr", MissingResourceException.class,
+                    () -> ResourceBundle.getBundle("com.codename1.bulk.bundles.NoBase", new Locale("fr", "")));
+        }));
+        // The JDK finds the classes by name, with reflection; ParparVM has none,
+        // and a built application has the registry its build generates, so
+        // that run is given one that knows both classes.
+        Bulk.check("ResourceBundle.loadsBundleClassesByName", inUs(() -> {
+            if (!Bulk.onHotSpot()) {
+                JdkHost.setRegistry(new ListRegistry(true));
+            }
+            String name = LIST;
+            ResourceBundle base = ResourceBundle.getBundle(name, new Locale("it", ""));
+            Bulk.p("baseIsList", base instanceof ResourceBundleList);
+            Bulk.p("text", base.getString("text"));
+            Bulk.p("array", base.getStringArray("array"));
+            Bulk.p("number", base.getObject("number"));
+            Bulk.pThrown("numberAsString", ClassCastException.class, () -> base.getString("number"));
+            ResourceBundle french = ResourceBundle.getBundle(name, new Locale("fr", "FR"));
+            Bulk.p("frenchIsFrench", french instanceof ResourceBundleList_fr);
+            Bulk.p("frenchText", french.getString("text"));
+            Bulk.p("frenchNumber", french.getObject("number"));
+            Bulk.p("frenchKeys", new TreeSet<String>(french.keySet()));
+        }));
+        Bulk.cn1Only("ResourceBundle.aBuiltApplicationHasTheBundleClassesItsRegistryKnowsAndItsFiles", inUs(() -> {
+            JdkHost.setRegistry(new ListRegistry(false));
+            ResourceBundle.clearCache();
+            // The French class is not registered, so it is not looked up by
+            // name: the chain ends at the class the registry knows.
+            ResourceBundle french = ResourceBundle.getBundle(LIST, new Locale("fr", "FR"));
+            Bulk.expect(french instanceof ResourceBundleList && !(french instanceof ResourceBundleList_fr),
+                    "the registered class");
+            Bulk.expectEquals("from a class", french.getString("text"), "text");
+            // The properties files are still read.
+            Bulk.expectEquals("Allo", ResourceBundle.getBundle(BASE, new Locale("fr", "CA")).getString("greeting"),
+                    "greeting");
+            Bulk.expectEquals("base", ResourceBundle.getBundle(BASE, new Locale("fr", "CA")).getString("only.base"),
+                    "only.base");
+        }));
+    }
+
+    /// The texts of the random comparison, generated as the original test
+    /// generated them; null in place of one whose comment line ends in a
+    /// backslash (see [#commentEndsInBackslash(String)]).
+    private static List<String> randomTexts() {
+        String[] pieces = {
+            "a", "b", "key", "value", " ", "  ", "\t", "\f", "=", ":", "#", "!", "\\", "\\\\", "\n", "\r", "\r\n",
+            "\\n", "\\t", "\\ ", "\\=", "\\:", "\\#", BS + "u0041", BS + "u00e9", "x", "1", ".", "\\\n", "\\\r\n",
+            String.valueOf((char) 0xE9),
+        };
+        Random random = new Random(7L);
+        List<String> out = new ArrayList<String>();
+        for (int i = 0; i < 20000; i++) {
+            StringBuilder text = new StringBuilder();
+            int n = random.nextInt(14);
+            for (int j = 0; j < n; j++) {
+                text.append(pieces[random.nextInt(pieces.length)]);
+            }
+            out.add(commentEndsInBackslash(text.toString()) ? null : text.toString());
+        }
+        return out;
+    }
+
+    /// Whether a line that may be a comment ends in a backslash.
+    ///
+    /// Intended difference. The JDK's line reader counts backslashes through
+    /// a comment and does not start again at the next line, so a comment
+    /// ending in one changes how the following line is read -- to the point
+    /// of reading characters left in its buffer by earlier lines. A comment
+    /// cannot be continued in this format, and JavaAPI does not let it reach
+    /// past its own line.
+    private static boolean commentEndsInBackslash(String text) {
+        int lineStart = 0;
+        for (int i = 0; i <= text.length(); i++) {
+            if (i < text.length() && text.charAt(i) != '\n' && text.charAt(i) != '\r') {
+                continue;
+            }
+            int first = lineStart;
+            while (first < i && (text.charAt(first) == ' ' || text.charAt(first) == '\t'
+                    || text.charAt(first) == '\f')) {
+                first++;
+            }
+            if (first < i && (text.charAt(first) == '#' || text.charAt(first) == '!')
+                    && text.charAt(i - 1) == '\\') {
+                return true;
+            }
+            lineStart = i + 1;
+        }
+        return false;
+    }
+
+    private static TreeMap<String, String> parse(String text) throws IOException {
+        PropertyResourceBundle bundle = new PropertyResourceBundle(new StringReader(text));
+        TreeMap<String, String> out = new TreeMap<String, String>();
+        for (String key : bundle.keySet()) {
+            out.put(key, bundle.getString(key));
+        }
+        return out;
+    }
+
+    private static String outcome(String text) {
+        try {
+            return parse(text).toString();
+        } catch (IllegalArgumentException e) {
+            return "IllegalArgumentException";
+        } catch (IOException e) {
+            return "IOException";
+        }
+    }
+
+    private static String describe(ResourceBundle bundle) {
+        StringBuilder sb = new StringBuilder();
+        for (String key : new TreeSet<String>(bundle.keySet())) {
+            sb.append(key).append('=').append(bundle.getString(key)).append(';');
+        }
+        Locale locale = bundle.getLocale();
+        String name = locale.getLanguage();
+        if (locale.getCountry().length() > 0) {
+            name = name + "_" + locale.getCountry();
+        }
+        return sb.append(" locale=").append(name).toString();
+    }
+
+    private static String show(String text) {
+        StringBuilder sb = new StringBuilder("\"");
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c == '\n') {
+                sb.append("<LF>");
+            } else if (c == '\r') {
+                sb.append("<CR>");
+            } else if (c == '\t') {
+                sb.append("<TAB>");
+            } else if (c == '\f') {
+                sb.append("<FF>");
+            } else if (c > 126) {
+                sb.append("<").append(Integer.toHexString(c)).append(">");
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.append('"').toString();
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleJava8Table.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleJava8Table.java
new file mode 100644
index 00000000000..1fa585bd6d9
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleJava8Table.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// What Java 8 parsed for the generated texts of
+/// `ResourceBundle.parsesRandomPropertiesLikeTheJdkOnJava8`, at the indexes
+/// where the JDK the HotSpot run uses answers differently (it reads a
+/// comment marker that follows an empty continued line as a comment).
+/// Written out from a Java 8 run of the same generator.
+final class ResourceBundleJava8Table {
+    /// The indexes of the generated texts.
+    static final int[] INDEX = {
+        473, 474, 845, 1020, 1115, 1243, 1261, 1381, 1799, 1901, 2527, 2578,
+        2634, 2681, 3226, 3328, 3539, 3696, 3711, 4536, 4840, 4969, 5148, 5443,
+        5618, 5679, 5697, 6012, 6239, 6291, 6475, 6560, 6599, 6705, 6836, 6917,
+        7685, 7949, 8326, 8338, 8416, 8510, 8518, 8556, 8667, 8777, 8784, 8934,
+        9013, 9276, 9561, 9613, 9753, 9960, 10365, 10573, 10604, 10895, 10916, 11252,
+        11403, 11694, 11816, 11841, 12172, 12248, 12304, 12361, 12501, 12895, 13227, 13381,
+        13496, 13811, 13875, 14171, 14311, 14425, 14847, 14882, 15301, 15448, 15530, 15846,
+        16343, 16530, 16555, 16765, 16928, 17005, 17026, 17064, 17291, 17547, 17679, 17827,
+        18318, 19103, 19107, 19210, 19312, 19500, 19750, 19768, 19816, 19990,
+    };
+
+    /// What Java 8 parsed each of them to, as a sorted map.
+    static final String[] OUTCOME = {
+        "{#=}",
+        "{!a=1\u00e9value :\u00e9}",
+        "{#\n=, xvalue#=}",
+        "{#a#\u00e9\t=}",
+        "{#=, key b\\=}",
+        "{=  \f, #=, b=value}",
+        "{!=, x\\=:}",
+        "{#=, A=}",
+        "{=a, \t=value, #=}",
+        "{!=:#=#}",
+        "{!#=#=, a\u00e9=, value==}",
+        "{!#\\\u00e9\u00e9=}",
+        "{#a\\=}",
+        "{#=}",
+        "{#a#value=, #\u00e9A=}",
+        "{\t=, # =:!\t\t}",
+        "{!\n\\a1key=, 1:.b=}",
+        "{!b=\\\t#\t\u00e9:\u00e9 }",
+        "{#b\\#:#= }",
+        "{=\u00e9, !1=, #==, a=}",
+        "{#=\u00e9}",
+        "{\t#a:=, #=}",
+        "{!\t\u00e9=key}",
+        "{=, # \\\n=, .=\n}",
+        "{!\\=}",
+        "{#=#key:value\\u0041#, value#=}",
+        "{!=, .=, ::=}",
+        "{!=, bkey=}",
+        "{!A=#!, \\b=}",
+        "{ \t=, #=}",
+        "{#!x=}",
+        "{!\n1=}",
+        "{##=:=\u00e9}",
+        "{#=b1\\t}",
+        "{!:A#key=}",
+        "{#=, aaA==}",
+        "{#\\=\t \t  !}",
+        "{!=, b=b}",
+        "{!value:=, : !\t=}",
+        "{#.\n\\\u00e9=}",
+        "{##=, \u00e9 =}",
+        "{!=, #keyx=}",
+        "{!\n1\\=! :\u00e9key}",
+        "{#==}",
+        "{#=}",
+        "{#:a=}",
+        "{#=, 1x=, ==}",
+        "{!=, 1==}",
+        "{!==}",
+        "{!=, ==:, x\t=}",
+        "{!a=b}",
+        "{#ab=}",
+        "{!\t1=, :=\t x=}",
+        "{!=}",
+        "{#1#\t:=}",
+        "{! :A\n==, :=, x=}",
+        "{#=}",
+        "{\n=#A, #=}",
+        "{#value\t=\n=}",
+        "{#:A\u00e9=key =}",
+        "{#=}",
+        "{#:=}",
+        "{#=}",
+        "{#!\u00e9\\=\nx  \u00e9}",
+        "{#b=}",
+        "{#=, a==value1value}",
+        "{!=}",
+        "{##\ta=, \\1=, \\\\=}",
+        "{#value =, \u00e9=a}",
+        "{ \u00e9=, !\n=}",
+        "{!a\\\\value=}",
+        "{=a\fb, #=, :1\t=}",
+        "{!a=#}",
+        "{!\u00e9=}",
+        "{!=, \u00e9aA=\t=\n}",
+        "{#=\u00e9=#\t\\ # }",
+        "{!#=:b\u00e9value=}",
+        "{#\\t:value\u00e9=}",
+        "{!#=}",
+        "{#\\keya=}",
+        "{#=, \u00e9key\u00e9=\nAx=}",
+        "{!.bkey\u00e9.key=#=}",
+        "{#=}",
+        "{!value=}",
+        "{=, \na=, #=, \\=}",
+        "{ =#, !=}",
+        "{#value\u00e9:x==#\n}",
+        "{#\u00e9\\xaAavalue=}",
+        "{#=\\:a\\ \u00e9}",
+        "{!=}",
+        "{#==}",
+        "{!=, xb.\u00e9=}",
+        "{!value#1A=}",
+        "{#x=}",
+        "{#=, 1b=\t!}",
+        "{#=, ##==1, 1=}",
+        "{!=}",
+        "{###A=key\u00e9}",
+        "{!..=}",
+        "{\n=keyb\u00e9, #1=A}",
+        "{!:b=}",
+        "{#\t:#b=.\u00e9\\:}",
+        "{!\u00e9=}",
+        "{#1value=, .=valuex, \\=}",
+        "{# \u00e9=}",
+        "{!\n:A=, 1=}",
+    };
+
+    private ResourceBundleJava8Table() {
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleList.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleList.java
new file mode 100644
index 00000000000..540ecbfc4c0
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleList.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ListResourceBundle;
+
+/// A bundle that is a class, found by name like a properties file. Top
+/// level, and its French one beside it: ParparVM reports a nested class's
+/// name with a '.' where the JDK has a '$' (see the note in JavaAPI's
+/// `Class.getResource`).
+public class ResourceBundleList extends ListResourceBundle {
+    @Override
+    protected Object[][] getContents() {
+        return new Object[][] {
+            {"text", "from a class"},
+            {"array", new String[] {"one", "two"}},
+            {"number", Integer.valueOf(42)},
+        };
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleList_fr.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleList_fr.java
new file mode 100644
index 00000000000..37d125f1ce3
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ResourceBundleList_fr.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ListResourceBundle;
+
+/// The French [ResourceBundleList]; its parent is that class.
+public class ResourceBundleList_fr extends ListResourceBundle {
+    @Override
+    protected Object[][] getContents() {
+        return new Object[][] {{"text", "d'une classe"}};
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SecurityChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SecurityChecks.java
new file mode 100644
index 00000000000..2d3a61a0d7d
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SecurityChecks.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Arrays;
+
+/// java.security: digests and secure random bytes. On ParparVM the digests
+/// come from the host, as they do in an application: [BulkHost] answers
+/// them with the core's own `Hash`.
+public final class SecurityChecks {
+    private SecurityChecks() {
+    }
+
+    private interface Op {
+        Object run() throws Exception;
+    }
+
+    private static String run(Op op) {
+        try {
+            return String.valueOf(op.run());
+        } catch (Exception e) {
+            return e.getClass().getSimpleName();
+        }
+    }
+
+    private static byte[][] inputs() {
+        byte[] big = new byte[1000];
+        for (int i = 0; i < big.length; i++) {
+            big[i] = (byte) (i * 31 + 7);
+        }
+        return new byte[][] {{}, {0}, "abc".getBytes(StandardCharsets.UTF_8), new byte[55], new byte[56],
+            new byte[64], new byte[111], new byte[112], new byte[128], big};
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("Security.digestsAreTheJdks", () -> {
+            for (String name : new String[] {"MD5", "SHA-1", "SHA", "SHA1", "SHA-224", "SHA-256", "sha-256",
+                "SHA-384", "SHA-512", "SHA-3", "CRC32", ""}) {
+                Bulk.p("algorithm[" + name + "]", run(() -> MessageDigest.getInstance(name).getAlgorithm()));
+                Bulk.p("length[" + name + "]", run(() -> MessageDigest.getInstance(name).getDigestLength()));
+                for (byte[] in : inputs()) {
+                    Bulk.p("digest[" + name + "," + in.length + "]",
+                            run(() -> Arrays.toString(MessageDigest.getInstance(name).digest(in))));
+                    Bulk.p("pieces[" + name + "," + in.length + "]", run(() -> {
+                        MessageDigest md = MessageDigest.getInstance(name);
+                        md.update(in, 0, in.length / 2);
+                        md.update((byte) 7);
+                        md.update(in);
+                        byte[] first = md.digest();
+                        md.update(in, in.length / 2, in.length - in.length / 2);
+                        md.reset();
+                        md.update(first);
+                        return Arrays.toString(first) + Arrays.toString(md.digest());
+                    }));
+                }
+            }
+            byte[][] pairs = {null, {}, {1}, {1, 2}, {1, 3}, {2, 1}, {1, 2, 3}};
+            StringBuilder eq = new StringBuilder();
+            for (byte[] a : pairs) {
+                for (byte[] b : pairs) {
+                    eq.append(MessageDigest.isEqual(a, b) ? '1' : '0');
+                }
+            }
+            Bulk.p("isEqual", eq.toString());
+            Bulk.pThrown("getInstanceNull", NullPointerException.class, () -> MessageDigest.getInstance(null));
+            Bulk.pThrown("updateNull", IllegalArgumentException.class,
+                    () -> MessageDigest.getInstance("MD5").update(null, 0, 1));
+            Object e = new NoSuchAlgorithmException("x");
+            Bulk.p("isGeneralSecurityException", e instanceof GeneralSecurityException);
+        });
+        // A host the check installs answers every secure random byte.
+        Bulk.cn1Only("Security.secureRandomReadsTheHost", () -> {
+            final int[] asked = new int[1];
+            JdkHost.install(new JdkHost() {
+                @Override
+                public void randomBytes(byte[] out) {
+                    asked[0] += out.length;
+                    Arrays.fill(out, (byte) 0x5A);
+                }
+            });
+            SecureRandom random = new SecureRandom();
+            // A caller's seed only supplements the host's source; the output
+            // below is still the host's bytes.
+            random.setSeed(random.generateSeed(8));
+            byte[] bytes = new byte[9];
+            random.nextBytes(bytes);
+            byte[] expected = new byte[9];
+            Arrays.fill(expected, (byte) 0x5A);
+            Bulk.expect(Arrays.equals(expected, bytes), "nextBytes is the host's: " + Arrays.toString(bytes));
+            Bulk.expect(Arrays.equals(new byte[] {0x5A, 0x5A}, random.generateSeed(2)), "generateSeed");
+            Bulk.expectEquals(Integer.valueOf(0x5A5A5A5A), Integer.valueOf(random.nextInt()), "nextInt");
+            Bulk.expectEquals(Integer.valueOf(23), Integer.valueOf(asked[0]), "bytes asked of the host");
+            Bulk.expectEquals("IllegalArgumentException",
+                    Bulk.thrown(IllegalArgumentException.class, () -> random.generateSeed(-1)), "generateSeed(-1)");
+            Bulk.expectEquals("NativePRNG", SecureRandom.getInstanceStrong().getAlgorithm(), "getInstanceStrong");
+            // With no host installed the defaults have no source and refuse.
+            JdkHost.install(null);
+            Bulk.expectEquals("UnsupportedOperationException",
+                    Bulk.thrown(UnsupportedOperationException.class, () -> new SecureRandom().nextBytes(new byte[1])),
+                    "the defaults refuse");
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderChecks.java
new file mode 100644
index 00000000000..51c2c8a56f0
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderChecks.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.ServiceLoader;
+import java.util.stream.Collectors;
+
+/// java.util.ServiceLoader over the services files in `res/META-INF/services`:
+/// the order of the providers, what a file may hold besides names, when a
+/// provider is created and how often. Then the loader over a registry, as a
+/// built application has one.
+public final class ServiceLoaderChecks {
+    /// The providers created, in order; the providers add themselves.
+    static final List<String> CREATED = new ArrayList<String>();
+
+    private ServiceLoaderChecks() {
+    }
+
+    /// What the build generates for an application: the providers of each
+    /// service in order, made without reflection.
+    private static class Registry implements JdkHost.Registry {
+        @Override
+        public String[] providers(String service) {
+            if (!ServiceLoaderGreeter.class.getName().equals(service)) {
+                return null;
+            }
+            return new String[] {ServiceLoaderGerman.class.getName(), "java.lang.String", "no.such.Provider",
+                ServiceLoaderEnglish.class.getName()};
+        }
+
+        @Override
+        public Object newInstance(String className) {
+            if (ServiceLoaderGerman.class.getName().equals(className)) {
+                return new ServiceLoaderGerman();
+            }
+            if (ServiceLoaderEnglish.class.getName().equals(className)) {
+                return new ServiceLoaderEnglish();
+            }
+            return "java.lang.String".equals(className) ? "not a greeter" : null;
+        }
+
+        @Override
+        public Class<?> type(String className) {
+            if (ServiceLoaderGerman.class.getName().equals(className)) {
+                return ServiceLoaderGerman.class;
+            }
+            if (ServiceLoaderEnglish.class.getName().equals(className)) {
+                return ServiceLoaderEnglish.class;
+            }
+            return "java.lang.String".equals(className) ? String.class : null;
+        }
+    }
+
+    private static List<String> created() {
+        List<String> out = new ArrayList<String>(CREATED);
+        CREATED.clear();
+        return out;
+    }
+
+    /// One step of a walk over a loader, as text.
+    private static String step(Iterator<ServiceLoaderGreeter> it, String what) {
+        String answer;
+        if ("hasNext".equals(what)) {
+            answer = String.valueOf(it.hasNext());
+        } else {
+            try {
+                answer = it.next().greet();
+            } catch (NoSuchElementException e) {
+                answer = "NoSuchElementException";
+            }
+        }
+        return what + "=" + answer + " created " + created();
+    }
+
+    /// A check's body run with no creation recorded before it.
+    private static Bulk.Body fresh(final Bulk.Body body) {
+        return () -> {
+            CREATED.clear();
+            body.run();
+        };
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("ServiceLoader.theProvidersComeInFileOrderWithoutCommentsBlanksOrRepeats", fresh(() -> {
+            List<String> mine = new ArrayList<String>();
+            for (ServiceLoaderGreeter g : ServiceLoader.load(ServiceLoaderGreeter.class)) {
+                mine.add(g.getClass().getName() + "=" + g.greet());
+            }
+            Bulk.p("providers", mine);
+            Bulk.p("created", created());
+        }));
+        Bulk.check("ServiceLoader.aProviderIsCreatedWhenTheIterationReachesItAndOncePerLoader", fresh(() -> {
+            String[] walk = {"next", "hasNext", "hasNext", "next", "next", "hasNext", "next"};
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            Bulk.p("loadingCreates", created());
+            Iterator<ServiceLoaderGreeter> b = mine.iterator();
+            for (int i = 0; i < walk.length; i++) {
+                Bulk.p("step" + i, step(b, walk[i]));
+            }
+            // A second iteration answers the same instances and creates nothing.
+            ServiceLoaderGreeter first = mine.iterator().next();
+            Bulk.p("sameInstance", first == mine.iterator().next());
+            Bulk.p("createdAfter", created());
+        }));
+        Bulk.check("ServiceLoader.twoIterationsShareWhatEitherCreated", fresh(() -> {
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            Iterator<ServiceLoaderGreeter> b1 = mine.iterator();
+            Iterator<ServiceLoaderGreeter> b2 = mine.iterator();
+            Bulk.p("1", step(b1, "next"));
+            Bulk.p("2", step(b2, "next"));
+            Bulk.p("3", step(b2, "next"));
+            Bulk.p("4", step(b1, "next"));
+            Bulk.p("5", step(b1, "next"));
+            Bulk.p("6", step(b2, "next"));
+            Bulk.p("7", step(b2, "hasNext"));
+            Bulk.p("8", step(b1, "next"));
+        }));
+        Bulk.check("ServiceLoader.reloadCreatesTheProvidersAgain", fresh(() -> {
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            ServiceLoaderGreeter myFirst = mine.iterator().next();
+            created();
+            mine.reload();
+            Bulk.p("reloadCreates", created());
+            Bulk.p("sameAfterReload", myFirst == mine.iterator().next());
+            Bulk.p("created", created());
+        }));
+        Bulk.check("ServiceLoader.anIteratorFromBeforeAReloadRefusesToGoOn", fresh(() -> {
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            Iterator<ServiceLoaderGreeter> before = mine.iterator();
+            before.next();
+            mine.reload();
+            Bulk.pThrown("hasNext", java.util.ConcurrentModificationException.class, () -> before.hasNext());
+            Bulk.pThrown("next", java.util.ConcurrentModificationException.class, () -> before.next());
+            Bulk.p("freshHasNext", mine.iterator().hasNext());
+        }));
+        Bulk.check("ServiceLoader.aServiceWithNoProviderHasNone", fresh(() -> {
+            Bulk.p("empty", ServiceLoader.load(ServiceLoaderEmpty.class).iterator().hasNext());
+            Bulk.p("unlisted", ServiceLoader.load(ServiceLoaderUnlisted.class).iterator().hasNext());
+            Bulk.p("unlistedFindFirst", ServiceLoader.load(ServiceLoaderUnlisted.class).findFirst().isPresent());
+            Bulk.p("emptyFindFirst", ServiceLoader.load(ServiceLoaderEmpty.class).findFirst().isPresent());
+            Bulk.p("emptyStream", ServiceLoader.load(ServiceLoaderEmpty.class).stream().count());
+            // What the application ships is never "installed in the platform".
+            ServiceLoader<ServiceLoaderGreeter> installed = ServiceLoader.loadInstalled(ServiceLoaderGreeter.class);
+            Bulk.p("installed", installed.iterator().hasNext());
+            installed.reload();
+            Bulk.p("installedFindFirst", installed.findFirst().isPresent());
+            Bulk.p("created", created());
+        }));
+        Bulk.check("ServiceLoader.theOtherWaysToLoadAnswerTheSameProviders", fresh(() -> {
+            ServiceLoader<ServiceLoaderGreeter> byLoader = ServiceLoader.load(ServiceLoaderGreeter.class,
+                    ServiceLoaderChecks.class.getClassLoader());
+            Bulk.p("byLoader", byLoader.iterator().next().greet());
+            Bulk.p("nullLoader", ServiceLoader.load(ServiceLoaderGreeter.class, null).iterator().next().greet());
+            Bulk.p("toString", ServiceLoader.load(ServiceLoaderGreeter.class).toString());
+            Bulk.pThrown("nullService", NullPointerException.class, () -> ServiceLoader.load((Class<ServiceLoaderGreeter>) null));
+        }));
+        Bulk.check("ServiceLoader.findFirstCreatesOnlyTheFirstAndForEachTheRest", fresh(() -> {
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            Optional<ServiceLoaderGreeter> first = mine.findFirst();
+            Bulk.p("present", first.isPresent());
+            Bulk.p("greet", first.get().greet());
+            Bulk.p("created", created());
+            Bulk.p("sameFirst", first.get() == mine.findFirst().get());
+            final List<String> said = new ArrayList<String>();
+            mine.forEach(g -> said.add(g.greet()));
+            Bulk.p("said", said);
+            Bulk.p("createdByForEach", created());
+            Bulk.pThrown("forEachNull", NullPointerException.class, () -> mine.forEach(null));
+            Bulk.pThrown("remove", UnsupportedOperationException.class, () -> mine.iterator().remove());
+        }));
+        Bulk.check("ServiceLoader.aStreamCreatesNothingUntilAskedAndThenAnewEachTime", fresh(() -> {
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            List<ServiceLoader.Provider<ServiceLoaderGreeter>> providers = mine.stream().collect(Collectors.toList());
+            Bulk.p("size", providers.size());
+            Bulk.p("created", created());
+            Bulk.p("typeIsFrench", providers.get(1).type() == ServiceLoaderFrench.class);
+            ServiceLoaderGreeter one = providers.get(1).get();
+            ServiceLoaderGreeter two = providers.get(1).get();
+            Bulk.p("greet", one.greet());
+            Bulk.p("sameInstance", one == two);
+            Bulk.p("createdByGet", created());
+        }));
+        Bulk.cn1Only("ServiceLoader.aBuiltApplicationHasTheProvidersItsRegistryListsAndNoOthers", fresh(() -> {
+            JdkHost.setRegistry(new Registry());
+            ServiceLoader<ServiceLoaderGreeter> mine = ServiceLoader.load(ServiceLoaderGreeter.class);
+            Bulk.expectEquals(Arrays.asList(), created(), "loading creates nothing");
+            List<String> said = new ArrayList<String>();
+            for (ServiceLoaderGreeter g : mine) {
+                said.add(g.greet());
+            }
+            // The registry's order, not the file's; what is no ServiceLoaderGreeter, or is
+            // not there, is left out rather than handed over under the wrong type.
+            Bulk.expectEquals(Arrays.asList("hallo", "hello"), said, "said");
+            Bulk.expectEquals(Arrays.asList("German", "English"), created(), "created");
+            Bulk.expectEquals(Long.valueOf(2), Long.valueOf(mine.stream().count()), "stream count");
+            Bulk.expect(mine.stream().findFirst().get().type() == ServiceLoaderGerman.class, "first type is ServiceLoaderGerman");
+
+            // A service the registry does not know has no provider, though a
+            // file lists some: the registry is the whole answer.
+            Bulk.expect(!ServiceLoader.load(ServiceLoaderEmpty.class).iterator().hasNext(), "Empty has none");
+            JdkHost.setRegistry(new Registry() {
+                @Override
+                public String[] providers(String service) {
+                    return null;
+                }
+            });
+            Bulk.expect(!ServiceLoader.load(ServiceLoaderGreeter.class).iterator().hasNext(), "an empty registry has none");
+            Bulk.expectEquals(Arrays.asList(), created(), "created at the end");
+        }));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderCommented.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderCommented.java
new file mode 100644
index 00000000000..1aa8cf1d2ac
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderCommented.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// Listed in the file behind a `#`, so never a provider.
+public class ServiceLoaderCommented implements ServiceLoaderGreeter {
+    /// Records its creation.
+    public ServiceLoaderCommented() {
+        ServiceLoaderChecks.CREATED.add("Commented");
+    }
+
+    @Override
+    public String greet() {
+        return "never";
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderEmpty.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderEmpty.java
new file mode 100644
index 00000000000..1b145314070
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderEmpty.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// A service of [ServiceLoaderChecks] whose file lists nothing.
+public interface ServiceLoaderEmpty {
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderEnglish.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderEnglish.java
new file mode 100644
index 00000000000..f2e9d9607da
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderEnglish.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// The first provider in the file.
+public class ServiceLoaderEnglish implements ServiceLoaderGreeter {
+    /// Records its creation.
+    public ServiceLoaderEnglish() {
+        ServiceLoaderChecks.CREATED.add("English");
+    }
+
+    @Override
+    public String greet() {
+        return "hello";
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderFrench.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderFrench.java
new file mode 100644
index 00000000000..be201269dcb
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderFrench.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// The second provider in the file.
+public class ServiceLoaderFrench implements ServiceLoaderGreeter {
+    /// Records its creation.
+    public ServiceLoaderFrench() {
+        ServiceLoaderChecks.CREATED.add("French");
+    }
+
+    @Override
+    public String greet() {
+        return "bonjour";
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderGerman.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderGerman.java
new file mode 100644
index 00000000000..d67839687a8
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderGerman.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// The third provider in the file.
+public class ServiceLoaderGerman implements ServiceLoaderGreeter {
+    /// Records its creation.
+    public ServiceLoaderGerman() {
+        ServiceLoaderChecks.CREATED.add("German");
+    }
+
+    @Override
+    public String greet() {
+        return "hallo";
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderGreeter.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderGreeter.java
new file mode 100644
index 00000000000..1f631539fc3
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderGreeter.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// The service of [ServiceLoaderChecks]. Top level, as are its providers:
+/// ParparVM reports a nested class's name with a '.' where the JDK has a
+/// '$' (see the note in JavaAPI's `Class.getResource`), and a services file
+/// is named, and lists its providers, by those names.
+public interface ServiceLoaderGreeter {
+    /// The greeting.
+    String greet();
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderUnlisted.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderUnlisted.java
new file mode 100644
index 00000000000..8109f7acc21
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/ServiceLoaderUnlisted.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// A service of [ServiceLoaderChecks] with no file.
+public interface ServiceLoaderUnlisted {
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamChecks.java
new file mode 100644
index 00000000000..728c1964731
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamChecks.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/// java.util.stream.Stream: the intermediate and terminal operations, the
+/// order they keep, laziness and short-circuiting, closing, and the
+/// factories.
+public final class StreamChecks {
+    private static final List<String> WORDS = Collections.unmodifiableList(Arrays.asList(
+            "pear", "apple", "fig", "banana", "apple", "kiwi", "cherry", "fig", "date"));
+    private static final List<Integer> NUMBERS = Collections.unmodifiableList(Arrays.asList(
+            5, 3, 8, 3, 1, 9, 2, 8, 7, 4, 6, 0));
+
+    private StreamChecks() {
+    }
+
+    /// A stream over `list` through its spliterator, which is what
+    /// `Collection.stream()` does.
+    private static <T> Stream<T> src(List<T> list) {
+        return StreamSupport.stream(list.spliterator(), false);
+    }
+
+    private static <T> List<T> listed(Stream<T> stream) {
+        return stream.collect(Collectors.<T>toList());
+    }
+
+    /// The characters of `s`, as `String.chars()` answers them.
+    private static IntStream chars(String s) {
+        return IntStream.range(0, s.length()).map(s::charAt);
+    }
+
+    /// Runs the group.
+    public static void run() {
+        intermediate();
+        laziness();
+        closing();
+        terminal();
+        life();
+        factories();
+        later();
+        primitives();
+    }
+
+    private static void intermediate() {
+        Bulk.check("Stream.sortedRefusesANullComparator", () -> {
+            Bulk.pThrown("sortedNull", NullPointerException.class, () -> Stream.of("b", "a").sorted(null));
+        });
+        Bulk.check("Stream.filterAndMapKeepEncounterOrder", () -> {
+            Bulk.p("words", listed(src(WORDS).filter(w -> w.length() > 3).map(w -> w.toUpperCase() + w.length())));
+            Bulk.p("numbers", listed(src(NUMBERS).map(n -> n * n).filter(n -> n % 2 == 0)));
+        });
+        Bulk.check("Stream.distinctKeepsTheFirstOfEachInOrder", () -> {
+            Bulk.p("words", listed(src(WORDS).distinct()));
+            Bulk.p("numbers", listed(src(NUMBERS).distinct()));
+            Bulk.p("withNull", listed(src(Arrays.asList("a", null, "b", null, "a")).distinct()));
+        });
+        Bulk.check("Stream.sortedIsNaturalOrByComparatorAndStable", () -> {
+            Bulk.p("natural", listed(src(WORDS).sorted()));
+            Bulk.p("reverse", listed(src(NUMBERS).sorted(Collections.reverseOrder())));
+            // By length alone: words of one length must keep their order.
+            Comparator<String> byLength = (a, b) -> a.length() - b.length();
+            Bulk.p("byLength", listed(src(WORDS).sorted(byLength)));
+        });
+        Bulk.check("Stream.limitAndSkipAtEveryBoundary", () -> {
+            long[] counts = {0, 1, 3, NUMBERS.size() - 1, NUMBERS.size(), NUMBERS.size() + 5, Long.MAX_VALUE};
+            for (long n : counts) {
+                Bulk.p("limit " + n, listed(src(NUMBERS).limit(n)));
+                Bulk.p("skip " + n, listed(src(NUMBERS).skip(n)));
+                Bulk.p("skip 2 limit " + n, listed(src(NUMBERS).skip(2).limit(n)));
+                Bulk.p("limit skip 2 " + n, listed(src(NUMBERS).limit(n).skip(2)));
+            }
+        });
+        Bulk.check("Stream.aNegativeLimitOrSkipIsRefused", () -> {
+            Bulk.pThrown("limit", IllegalArgumentException.class, () -> src(NUMBERS).limit(-1));
+            Bulk.pThrown("skip", IllegalArgumentException.class, () -> src(NUMBERS).skip(-1));
+        });
+        Bulk.check("Stream.flatMapConcatenatesInOrderAndSkipsNull", () -> {
+            Bulk.p("skipsNull", listed(src(WORDS).flatMap(w -> w.length() == 3 ? null
+                    : src(Arrays.asList(w, w.substring(0, 1))))));
+            Bulk.p("limited", listed(src(NUMBERS).flatMap(n -> Stream.of(n, -n)).limit(7)));
+            Bulk.p("empties", listed(src(NUMBERS).flatMap(n -> Stream.<Integer>empty())));
+        });
+        Bulk.check("Stream.flatMapToThePrimitiveStreams", () -> {
+            Bulk.p("toInt", src(WORDS).flatMapToInt(w -> chars(w)).limit(20).toArray());
+            Bulk.p("toLong", src(NUMBERS).flatMapToLong(n -> LongStream.rangeClosed(1, n)).toArray());
+            Bulk.p("toDouble", src(NUMBERS).flatMapToDouble(n -> DoubleStream.of(n, n / 2.0)).toArray());
+        });
+    }
+
+    private static void laziness() {
+        Bulk.check("Stream.nothingRunsUntilATerminalOperation", () -> {
+            List<Integer> seen = new ArrayList<Integer>();
+            Stream<Integer> pending = src(NUMBERS).peek(seen::add).filter(n -> n > 2).map(n -> n + 1);
+            Bulk.p("seenBefore", seen);
+            Bulk.p("first", pending.findFirst().get());
+            Bulk.p("seenAfter", seen);
+        });
+        Bulk.check("Stream.findFirstPullsOnlyWhatItNeeds", () -> {
+            List<String> seen = new ArrayList<String>();
+            Bulk.p("first", src(WORDS).peek(seen::add).filter(w -> w.startsWith("b")).findFirst().get());
+            Bulk.p("seen", seen);
+        });
+        Bulk.check("Stream.limitStopsThePipelineAboveIt", () -> {
+            List<Integer> seen = new ArrayList<Integer>();
+            Bulk.p("out", listed(src(NUMBERS).peek(seen::add).map(n -> n * 2).limit(3)));
+            Bulk.p("seen", seen);
+        });
+        Bulk.check("Stream.theMatchesStopAtTheirAnswer", () -> {
+            List<Integer> seen = new ArrayList<Integer>();
+            Bulk.p("any", src(NUMBERS).peek(seen::add).anyMatch(n -> n == 8));
+            Bulk.p("anySeen", seen);
+            seen.clear();
+            Bulk.p("all", src(NUMBERS).peek(seen::add).allMatch(n -> n != 1));
+            Bulk.p("allSeen", seen);
+            seen.clear();
+            Bulk.p("none", src(NUMBERS).peek(seen::add).noneMatch(n -> n == 9));
+            Bulk.p("noneSeen", seen);
+        });
+        Bulk.check("Stream.theMatchesOfAnEmptyStream", () -> {
+            List<Integer> none = Collections.<Integer>emptyList();
+            Bulk.p("any", src(none).anyMatch(n -> true));
+            Bulk.p("all", src(none).allMatch(n -> false));
+            Bulk.p("none", src(none).noneMatch(n -> true));
+        });
+        Bulk.check("Stream.anInfiniteStreamIsCutByLimit", () -> {
+            Bulk.p("iterate", listed(Stream.iterate(1, n -> n * 2).limit(12)));
+            final int[] next = {0};
+            Bulk.p("generate", listed(Stream.generate(() -> next[0]++).filter(n -> n % 3 == 0).limit(5)));
+            Bulk.p("generated", next[0]);
+            Bulk.p("anyOfInfinite", Stream.iterate(1, n -> n + 1).anyMatch(n -> n == 1000));
+        });
+        Bulk.check("Stream.flatMapIsLazyInsideItsInnerStream", () -> {
+            // JDK 8 pushes a whole inner stream before it looks at the
+            // limit; the later ones stop, and so does JavaAPI's.
+            List<Integer> seen = new ArrayList<Integer>();
+            Bulk.p("first", src(NUMBERS).flatMap(n -> Stream.iterate(1, i -> i + 1).peek(seen::add)).findFirst().get());
+            Bulk.p("seen", seen);
+        });
+    }
+
+    private static void closing() {
+        // A mapped stream is closed whether or not all of it was wanted.
+        Bulk.check("Stream.aMappedStreamLeftPartReadIsClosed", () -> {
+            List<Integer> source = Arrays.asList(1, 2, 3);
+            List<String> closed = new ArrayList<String>();
+            Bulk.p("first", src(source).flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("first " + n)))
+                    .findFirst().get());
+            Bulk.p("limit", listed(src(source).flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("limit " + n)))
+                    .limit(3)));
+            Bulk.p("any", src(source).flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("any " + n)))
+                    .anyMatch(v -> v == 2));
+            Bulk.p("all", src(source).flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("all " + n)))
+                    .allMatch(v -> v > 0));
+            Bulk.p("none", src(source).flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("none " + n)))
+                    .noneMatch(v -> v == 1));
+            Bulk.p("int", src(source).flatMapToInt(n -> IntStream.of(n, -n).onClose(() -> closed.add("int " + n)))
+                    .findFirst().getAsInt());
+            Bulk.p("closed", closed);
+
+            closed.clear();
+            Bulk.p("takeWhile", listed(src(source)
+                    .flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("while " + n))).takeWhile(v -> v != -2)));
+            Bulk.p("whileClosed", closed);
+
+            // A limit says so about the stages before it only: the mapped
+            // stream after it is still being read when the limit runs out.
+            List<String> order = new ArrayList<String>();
+            src(source).limit(1).flatMap(n -> Stream.of(n, -n).onClose(() -> order.add("closed")))
+                    .forEach(v -> order.add(String.valueOf(v)));
+            Bulk.p("order", order);
+        });
+        // An iterator nobody reads to the end is the caller's to close.
+        // JavaAPI's iterator pulls the mapped stream lazily and leaves it
+        // open; the JDK's buffers the whole mapped stream on the first
+        // next() and closes it there, so the two differ by design.
+        Bulk.cn1Only("Stream.aMappedStreamLeftPartReadIsClosedByTheCaller", () -> {
+            List<String> closed = new ArrayList<String>();
+            Stream<Integer> open = src(Arrays.asList(1, 2, 3))
+                    .flatMap(n -> Stream.of(n, -n).onClose(() -> closed.add("it " + n)));
+            Iterator<Integer> it = open.iterator();
+            Bulk.expectEquals(Integer.valueOf(1), it.next(), "first element");
+            Bulk.expect(closed.isEmpty(), "nothing closed before the caller closes: " + closed);
+            open.close();
+            open.close();
+            Bulk.expectEquals(Collections.singletonList("it 1"), closed, "closed once by the caller");
+        });
+        // Every close handler runs, past an Error too, and the failures
+        // after the first are suppressed in it.
+        Bulk.check("Stream.closeRunsEveryHandlerAndKeepsEveryFailure", () -> {
+            final IllegalStateException a = new IllegalStateException("a");
+            final AssertionError b = new AssertionError("b");
+            final IllegalArgumentException c = new IllegalArgumentException("c");
+            final List<String> ran = new ArrayList<String>();
+            Runnable first = () -> {
+                ran.add("1");
+                throw a;
+            };
+            Runnable second = () -> {
+                ran.add("2");
+                throw b;
+            };
+            Runnable third = () -> {
+                ran.add("3");
+                throw c;
+            };
+            Runnable fourth = () -> ran.add("4");
+            Runnable again = () -> {
+                ran.add("5");
+                throw a;
+            };
+            Stream<Integer> s = Stream.of(1).onClose(first).onClose(second).onClose(third).onClose(fourth)
+                    .onClose(again);
+            String outcome = "none";
+            try {
+                s.close();
+            } catch (IllegalStateException e) {
+                outcome = e == a ? "first" : "other ISE";
+            }
+            Bulk.p("threw", outcome);
+            Bulk.p("ran", ran);
+            Throwable[] suppressed = a.getSuppressed();
+            Bulk.p("suppressedCount", suppressed.length);
+            for (int i = 0; i < suppressed.length; i++) {
+                String which = suppressed[i] == b ? "b" : suppressed[i] == c ? "c" : suppressed[i] == a ? "a" : "?";
+                Bulk.p("suppressed" + i, which);
+            }
+        });
+        // Closing any stage closes the pipeline: a stage made from the
+        // closed one, before or after, runs nothing.
+        Bulk.check("Stream.aClosedPipelineRefusesEveryStage", () -> {
+            Stream<Integer> closedItself = Stream.of(1).map(x -> x);
+            closedItself.close();
+            Stream<Integer> source = Stream.of(1);
+            Stream<Integer> madeBefore = source.map(x -> x);
+            source.close();
+            Stream<Integer> early = Stream.of(1);
+            Stream<Integer> later = early.filter(x -> true).map(x -> x);
+            later.close();
+            Bulk.p("closedItselfCount", Bulk.thrown(IllegalStateException.class, () -> closedItself.count()));
+            Bulk.p("madeBeforeCount", Bulk.thrown(IllegalStateException.class, () -> madeBefore.count()));
+            Bulk.p("madeBeforeFilter", Bulk.thrown(IllegalStateException.class, () -> madeBefore.filter(x -> true)));
+            Bulk.p("madeBeforeOnClose", Bulk.thrown(IllegalStateException.class, () -> madeBefore.onClose(() -> { })));
+            Bulk.p("laterIterator", Bulk.thrown(IllegalStateException.class, () -> later.iterator()));
+            String message = "none";
+            try {
+                Stream<Integer> s = Stream.of(1);
+                Stream<Integer> m = s.map(x -> x);
+                s.close();
+                m.count();
+            } catch (IllegalStateException e) {
+                message = e.getMessage() != null ? "has message" : "null message";
+            }
+            Bulk.p("message", message);
+            // Closing again is allowed, and runs nothing twice.
+            List<String> ran = new ArrayList<String>();
+            Stream<Integer> once = Stream.of(1).onClose(() -> ran.add("closed"));
+            Stream<Integer> mapped = once.map(x -> x);
+            mapped.close();
+            mapped.close();
+            Bulk.p("ran", ran);
+        });
+    }
+
+    private static void terminal() {
+        Bulk.check("Stream.reduceInItsThreeForms", () -> {
+            Bulk.p("identity", src(NUMBERS).reduce(100, (a, b) -> a - b));
+            Bulk.p("optional", src(WORDS).reduce((a, b) -> a + "," + b).get());
+            Bulk.p("combiner", src(WORDS).reduce(0, (n, w) -> n + w.length(), (a, b) -> a + b));
+            List<String> none = Collections.<String>emptyList();
+            Bulk.p("emptyOptional", src(none).reduce((a, b) -> a + b).isPresent());
+            Bulk.p("emptyIdentity", src(none).reduce("seed", (a, b) -> a + b));
+        });
+        Bulk.check("Stream.minMaxAndCount", () -> {
+            Comparator<String> natural = Comparator.naturalOrder();
+            Comparator<String> byLength = (a, b) -> a.length() - b.length();
+            // Words of one length are told apart by where they stand.
+            List<String> tagged = new ArrayList<String>();
+            for (int i = 0; i < WORDS.size(); i++) {
+                tagged.add(WORDS.get(i) + "#" + i);
+            }
+            Comparator<String> byWordLength = (a, b) -> a.indexOf('#') - b.indexOf('#');
+            Bulk.p("min", src(WORDS).min(natural).get());
+            Bulk.p("max", src(WORDS).max(natural).get());
+            // Ties: which of the equal ones is answered.
+            Bulk.p("minByLength", src(WORDS).min(byLength).get());
+            Bulk.p("maxByLength", src(WORDS).max(byLength).get());
+            Bulk.p("minTie", src(tagged).min(byWordLength).get());
+            Bulk.p("maxTie", src(tagged).max(byWordLength).get());
+            Bulk.p("count", src(WORDS).count());
+            Bulk.p("countFiltered", src(WORDS).filter(w -> w.length() == 3).count());
+            List<String> none = Collections.<String>emptyList();
+            Bulk.p("emptyMin", src(none).min(natural).isPresent());
+            Bulk.p("emptyMax", src(none).max(natural).isPresent());
+            Bulk.p("emptyCount", src(none).count());
+        });
+        Bulk.check("Stream.findFirstAndFindAny", () -> {
+            Bulk.p("first", src(WORDS).findFirst().get());
+            Bulk.p("any", src(WORDS).skip(3).findAny().get());
+            Bulk.p("emptyFirst", src(WORDS).filter(w -> w.isEmpty()).findFirst().isPresent());
+        });
+        Bulk.check("Stream.findFirstRefusesANullElement", () -> {
+            Bulk.pThrown("findFirst", NullPointerException.class, () -> src(Arrays.asList(null, "a")).findFirst());
+        });
+        Bulk.check("Stream.toArrayPlainAndTyped", () -> {
+            Bulk.p("plain", src(WORDS).sorted().toArray());
+            String[] typed = src(WORDS).filter(w -> w.length() > 4).toArray(String[]::new);
+            Bulk.p("typed", typed);
+            Bulk.p("typedIsStringArray", typed.getClass() == String[].class);
+            Bulk.p("emptyLength", src(Collections.<String>emptyList()).toArray(String[]::new).length);
+        });
+        Bulk.check("Stream.forEachAndForEachOrderedVisitInOrder", () -> {
+            List<String> seen = new ArrayList<String>();
+            src(WORDS).filter(w -> w.length() != 4).forEach(seen::add);
+            Bulk.p("forEach", seen);
+            List<String> ordered = new ArrayList<String>();
+            src(WORDS).filter(w -> w.length() != 4).forEachOrdered(ordered::add);
+            Bulk.p("forEachOrdered", ordered);
+        });
+        Bulk.check("Stream.collectWithASupplierAndAccumulator", () -> {
+            Bulk.p("initials", src(WORDS).collect(StringBuilder::new, (sb, w) -> sb.append(w.charAt(0)),
+                    (a, b) -> a.append(b)).toString());
+        });
+        Bulk.check("Stream.theIteratorWalksThePipeline", () -> {
+            Iterator<String> it = src(WORDS).filter(w -> w.length() > 4).map(String::toUpperCase).iterator();
+            List<String> walked = new ArrayList<String>();
+            while (it.hasNext()) {
+                walked.add(it.next());
+            }
+            Bulk.p("walked", walked);
+            Bulk.p("hasNext", it.hasNext());
+            Bulk.pThrown("nextAtEnd", NoSuchElementException.class, it::next);
+        });
+    }
+
+    private static void life() {
+        Bulk.check("Stream.aStreamRunsOnce", () -> {
+            Stream<String> stream = src(WORDS);
+            Bulk.p("count", stream.count());
+            Bulk.pThrown("again", IllegalStateException.class, stream::count);
+        });
+        Bulk.check("Stream.aStageTakesOneOperation", () -> {
+            Stream<String> stream = src(WORDS);
+            stream.filter(w -> true);
+            Bulk.pThrown("second", IllegalStateException.class, () -> stream.map(w -> w));
+        });
+        Bulk.check("Stream.theSourceIsReadWhenTheTerminalOperationStarts", () -> {
+            List<String> source = new ArrayList<String>(Arrays.asList("a", "b"));
+            Stream<String> stream = src(source).map(String::toUpperCase);
+            source.add("c");
+            Bulk.p("out", listed(stream));
+        });
+        Bulk.check("Stream.closeRunsTheHandlersOnceInOrder", () -> {
+            List<String> ran = new ArrayList<String>();
+            Stream<String> stream = src(WORDS).onClose(() -> ran.add("one"))
+                    .filter(w -> true).onClose(() -> ran.add("two"));
+            stream.close();
+            stream.close();
+            Bulk.p("ran", ran);
+        });
+        Bulk.check("Stream.sequentialParallelAndUnordered", () -> {
+            Bulk.p("sequential", src(WORDS).sequential().isParallel());
+            // JavaAPI runs a parallel stream sequentially, which the JDK
+            // allows, but reports what was asked for as the JDK does.
+            Bulk.p("parallel", src(WORDS).parallel().isParallel());
+            Bulk.p("parallelMap", listed(src(WORDS).parallel().map(String::length)));
+            Bulk.p("unorderedSorted", listed(src(WORDS).unordered().sorted()));
+        });
+        Bulk.check("Stream.aNullFunctionIsRefusedAtOnce", () -> {
+            Bulk.pThrown("map", NullPointerException.class, () -> src(WORDS).map(null));
+            Bulk.pThrown("filter", NullPointerException.class, () -> src(WORDS).filter(null));
+            Bulk.pThrown("forEach", NullPointerException.class, () -> src(WORDS).sorted().forEach(null));
+        });
+    }
+
+    private static void factories() {
+        Bulk.check("Stream.ofEmptyConcatAndBuilder", () -> {
+            Bulk.p("of", listed(Stream.of("a", "b", "c")));
+            Bulk.p("ofOne", listed(Stream.of("solo")));
+            Bulk.p("empty", listed(Stream.<String>empty()));
+            Bulk.p("concat", listed(Stream.concat(src(WORDS).limit(2), src(WORDS).skip(7))));
+            Bulk.p("builder", listed(Stream.<String>builder().add("x").add("y").build()));
+            Stream.Builder<String> built = Stream.builder();
+            built.accept("z");
+            built.build();
+            Bulk.pThrown("addAfterBuild", IllegalStateException.class, () -> built.add("late"));
+        });
+        Bulk.check("Stream.concatIsLazyAndClosesBoth", () -> {
+            List<String> seen = new ArrayList<String>();
+            List<String> closed = new ArrayList<String>();
+            Stream<String> both = Stream.concat(src(WORDS).peek(seen::add).onClose(() -> closed.add("a")),
+                    src(WORDS).peek(seen::add).onClose(() -> closed.add("b")));
+            Bulk.p("seenBefore", seen);
+            Bulk.p("first", both.findFirst().get());
+            Bulk.p("seenAfter", seen);
+            both.close();
+            Bulk.p("closed", closed);
+        });
+    }
+
+    private static void later() {
+        Bulk.check("Stream.takeWhileAndDropWhile", () -> {
+            Bulk.p("take", listed(src(NUMBERS).takeWhile(n -> n < 8)));
+            Bulk.p("drop", listed(src(NUMBERS).dropWhile(n -> n < 8)));
+            Bulk.p("takeAll", listed(src(NUMBERS).takeWhile(n -> true)));
+            Bulk.p("dropNone", listed(src(NUMBERS).dropWhile(n -> false)));
+            Bulk.p("takeNone", listed(src(NUMBERS).takeWhile(n -> false)));
+            Bulk.p("dropAll", listed(src(NUMBERS).dropWhile(n -> true)));
+            // takeWhile stops asking: an infinite stream ends.
+            Bulk.p("infinite", listed(Stream.iterate(1, n -> n + 1).takeWhile(n -> n < 5)));
+            // dropWhile stops testing after the first that fails.
+            List<Integer> tested = new ArrayList<Integer>();
+            listed(src(NUMBERS).dropWhile(n -> {
+                tested.add(n);
+                return n != 8;
+            }));
+            Bulk.p("tested", tested);
+        });
+        Bulk.check("Stream.ofNullableAndTheBoundedIterate", () -> {
+            Bulk.p("ofNullable", listed(Stream.ofNullable("a")));
+            Bulk.p("ofNullableNull", listed(Stream.<String>ofNullable(null)));
+            Bulk.p("iterate", listed(Stream.iterate(1, n -> n < 50, n -> n * 3)));
+            Bulk.p("iterateNone", listed(Stream.iterate(1, n -> n < 0, n -> n * 3)));
+        });
+        Bulk.check("Stream.toListIsUnmodifiableAndTakesNull", () -> {
+            List<String> out = src(Arrays.asList("a", null, "b")).toList();
+            Bulk.p("out", out);
+            Bulk.pThrown("add", UnsupportedOperationException.class, () -> out.add("c"));
+            Bulk.pThrown("set", UnsupportedOperationException.class, () -> out.set(0, "c"));
+        });
+    }
+
+    private static void primitives() {
+        Bulk.check("Stream.mapToIntLongAndDouble", () -> {
+            Bulk.p("int", src(WORDS).mapToInt(String::length).sum());
+            Bulk.p("long", src(WORDS).mapToLong(w -> w.length() * 10000000000L).sum());
+            Bulk.p("double", src(WORDS).mapToDouble(w -> w.length() / 4.0).sum());
+            Bulk.p("boxed", listed(src(WORDS).mapToInt(String::length).boxed()));
+            Bulk.p("mapToObj", listed(src(WORDS).mapToInt(String::length).mapToObj(n -> "#" + n)));
+        });
+        Bulk.check("Stream.primitiveStreamsAreLazyToo", () -> {
+            List<Integer> seen = new ArrayList<Integer>();
+            Bulk.p("first", src(NUMBERS).peek(seen::add).mapToInt(n -> n).filter(n -> n > 5).findFirst().getAsInt());
+            Bulk.p("seen", seen);
+            Bulk.p("iterate", IntStream.iterate(1, n -> n * 2).limit(5).toArray());
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/StreamEdgeApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamEdgeApp.java
similarity index 99%
rename from vm/tests/src/test/resources/com/codename1/tools/translator/StreamEdgeApp.java
rename to vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamEdgeApp.java
index ed677cf2dbd..923b9c1a58d 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/StreamEdgeApp.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamEdgeApp.java
@@ -290,7 +290,7 @@ private static int closeSemantics() {
         return 0;
     }
 
-    public static void main(String[] args) {
+    public static void fixtureMain(String[] args) {
         System.out.println("RESULT=" + (calculate() + lazySemantics() + fusionSemantics() + closeSemantics()));
     }
 }
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamEdgeChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamEdgeChecks.java
new file mode 100644
index 00000000000..3b44288f710
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamEdgeChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// StreamEdgeApp, formerly translated and built on its own by StreamApiIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class StreamEdgeChecks {
+    private StreamEdgeChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("StreamEdgeApp", () -> StreamEdgeApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamPipelineApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamPipelineApp.java
new file mode 100644
index 00000000000..a133a2eac62
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamPipelineApp.java
@@ -0,0 +1,409 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+/// Streams, primitive streams, collectors and the stream-era members of the
+/// collection interfaces, printed as one line the JVM and ParparVM must agree
+/// on. Unordered results (hash maps, Set.of) are sorted before printing.
+public class StreamPipelineApp {
+    private static final StringBuilder OUT = new StringBuilder();
+
+    private static void out(Object label, Object value) {
+        OUT.append(label).append('=').append(value).append(';');
+    }
+
+    private static <K, V> String sorted(Map<K, V> map) {
+        return new TreeMap<K, V>(map).toString();
+    }
+
+    private static <T> String sorted(Collection<T> c) {
+        List<String> all = new ArrayList<String>();
+        for (T t : c) {
+            all.add(String.valueOf(t));
+        }
+        Collections.sort(all);
+        return all.toString();
+    }
+
+    private static String ints(int[] a) {
+        return Arrays.toString(a);
+    }
+
+    interface Check {
+        void run();
+    }
+
+    private static void fails(String label, Check c) {
+        try {
+            c.run();
+            out(label, "none");
+        } catch (NullPointerException e) {
+            out(label, "npe");
+        } catch (IllegalStateException e) {
+            out(label, "ise");
+        } catch (IllegalArgumentException e) {
+            out(label, "iae");
+        } catch (UnsupportedOperationException e) {
+            out(label, "uoe");
+        } catch (IndexOutOfBoundsException e) {
+            out(label, "ioobe");
+        } catch (NoSuchElementException e) {
+            out(label, "nsee");
+        }
+    }
+
+    public static void fixtureMain(String[] args) {
+        objectStreams();
+        laziness();
+        primitiveStreams();
+        collectors();
+        collectionMembers();
+        System.out.println("RESULT=" + OUT);
+    }
+
+    static void objectStreams() {
+        List<String> words = new ArrayList<String>(Arrays.asList("pear", "fig", "apple", "kiwi", "fig", "banana"));
+        out("filterMap", words.stream().filter(w -> w.length() > 3).map(String::toUpperCase).collect(Collectors.toList()));
+        out("distinctSorted", words.stream().distinct().sorted().collect(Collectors.toList()));
+        out("sortedBy", words.stream().sorted(Comparator.comparing(String::length).thenComparing(Comparator.reverseOrder()))
+                .collect(Collectors.joining(",", "<", ">")));
+        out("skipLimit", words.stream().skip(1).limit(3).collect(Collectors.toList()));
+        out("takeDrop", Stream.of(1, 2, 3, 10, 4).takeWhile(i -> i < 5).collect(Collectors.toList()) + "/"
+                + Stream.of(1, 2, 3, 10, 4).dropWhile(i -> i < 5).collect(Collectors.toList()));
+        out("flatMap", Stream.of("ab", "", "cde").flatMap(s -> IntStream.range(0, s.length()).mapToObj(s::charAt)).collect(Collectors.toList()));
+        out("reduce", words.stream().reduce("", (a, b) -> a + b.charAt(0)) + "," + words.stream().map(String::length)
+                .reduce(Integer::sum).get() + "," + words.stream().reduce(0, (n, w) -> n + w.length(), Integer::sum));
+        out("minMax", words.stream().min(Comparator.naturalOrder()).get() + "," + words.stream().max(Comparator.naturalOrder()).get()
+                + "," + Stream.<String>empty().min(Comparator.naturalOrder()).isPresent());
+        out("matches", words.stream().anyMatch(w -> w.startsWith("b")) + "," + words.stream().allMatch(w -> w.length() > 2)
+                + "," + words.stream().noneMatch(String::isEmpty) + "," + Stream.empty().allMatch(x -> false));
+        out("find", words.stream().filter(w -> w.contains("i")).findFirst().get() + ","
+                + words.stream().filter(w -> w.contains("z")).findAny().isPresent());
+        out("count", words.stream().filter(w -> w.equals("fig")).count());
+        out("toArray", Arrays.toString(words.stream().limit(2).toArray()) + Arrays.toString(words.stream().limit(2)
+                .toArray(String[]::new)));
+        out("iterate", Stream.iterate(1, x -> x * 3).limit(5).collect(Collectors.toList()) + ","
+                + Stream.iterate(1, x -> x < 50, x -> x * 4).collect(Collectors.toList()));
+        final int[] counter = new int[1];
+        out("generate", Stream.generate(() -> counter[0]++).limit(4).collect(Collectors.toList()));
+        out("concat", Stream.concat(Stream.of(1, 2), Stream.of(3)).collect(Collectors.toList()));
+        out("ofNullable", Stream.ofNullable(null).count() + "," + Stream.ofNullable("x").count());
+        Stream.Builder<String> b = Stream.builder();
+        b.add("x").add("y");
+        b.accept("z");
+        out("builder", b.build().collect(Collectors.joining()));
+        Iterator<String> it = Stream.of("i1", "i2").iterator();
+        StringBuilder seen = new StringBuilder();
+        while (it.hasNext()) {
+            seen.append(it.next());
+        }
+        out("iterator", seen);
+        out("forEachOrdered", words.stream().limit(2).collect(StringBuilder::new, StringBuilder::append,
+                StringBuilder::append));
+        out("mapToPrim", words.stream().mapToInt(String::length).sum() + "," + words.stream().mapToLong(String::length)
+                .max().getAsLong() + "," + words.stream().mapToDouble(String::length).average().getAsDouble());
+        out("flatToPrim", Stream.of("ab", "c").flatMapToInt(s -> IntStream.range(0, s.length()).map(s::charAt)).sum() + ","
+                + Stream.of(2L, 3L).flatMapToLong(x -> LongStream.range(0, x)).count() + ","
+                + Stream.of(1.5).flatMapToDouble(x -> DoubleStream.of(x, x)).sum());
+        out("parallel", words.parallelStream().isParallel() + "," + words.stream().parallel().sequential()
+                .unordered().count());
+    }
+
+    static void laziness() {
+        final StringBuilder trace = new StringBuilder();
+        List<Integer> got = Stream.of(1, 2, 3, 4, 5, 6).peek(x -> trace.append('p').append(x)).filter(x -> x % 2 == 0)
+                .peek(x -> trace.append('f').append(x)).limit(2).collect(Collectors.toList());
+        out("lazyTrace", trace + ":" + got);
+        trace.setLength(0);
+        Stream<Integer> pending = Stream.of(1, 2, 3).peek(x -> trace.append(x));
+        out("nothingYet", "[" + trace + "]");
+        pending.findFirst();
+        out("findFirstPulls", trace);
+        trace.setLength(0);
+        out("infiniteFind", Stream.iterate(1, x -> x + 1).peek(x -> trace.append(x)).filter(x -> x > 3).findFirst().get()
+                + ":" + trace);
+        trace.setLength(0);
+        out("anyMatchStops", IntStream.range(0, 100).peek(x -> trace.append(x)).anyMatch(x -> x == 2) + ":" + trace);
+        trace.setLength(0);
+        out("sortedBarrier", Stream.of(3, 1, 2).peek(x -> trace.append('a').append(x)).sorted()
+                .peek(x -> trace.append('b').append(x)).limit(1).collect(Collectors.toList()) + ":" + trace);
+
+        final StringBuilder closed = new StringBuilder();
+        Stream<String> s = Stream.of("a").onClose(() -> closed.append('1')).onClose(() -> closed.append('2'));
+        s.close();
+        s.close();
+        out("onClose", closed);
+        closed.setLength(0);
+        Stream.concat(Stream.of(1).onClose(() -> closed.append('A')), Stream.of(2).onClose(() -> closed.append('B')))
+                .close();
+        out("concatClose", closed);
+        closed.setLength(0);
+        out("flatMapCloses", Stream.of(1, 2, 3).flatMap(x -> Stream.of(x, x * 10).onClose(() -> closed.append(x)))
+                .limit(3).collect(Collectors.toList()) + ":" + closed);
+        closed.setLength(0);
+        Stream.of(7, 8).flatMap(x -> Stream.of(x).onClose(() -> closed.append(x))).findFirst();
+        out("flatMapFindFirstCloses", closed);
+        final Stream<String> once = Stream.of("x");
+        once.count();
+        fails("reuse", () -> once.count());
+        final Stream<String> twice = Stream.of("x");
+        twice.map(String::length);
+        fails("reuseAfterStage", () -> twice.filter(x -> true));
+        fails("negativeLimit", () -> Stream.of(1).limit(-1));
+        fails("nullFilter", () -> Stream.of(1).filter(null));
+        fails("nullFindFirst", () -> Stream.of((String) null).findFirst());
+        fails("generatorTooSmall", () -> Stream.of("a", "b").toArray(n -> new String[1]));
+
+        List<String> live = new ArrayList<String>(Arrays.asList("a"));
+        Stream<String> late = live.stream();
+        live.add("b");
+        out("lateBinding", late.collect(Collectors.toList()));
+    }
+
+    static void primitiveStreams() {
+        out("range", ints(IntStream.range(2, 6).toArray()) + ints(IntStream.rangeClosed(5, 5).toArray())
+                + ints(IntStream.range(5, 2).toArray()));
+        out("rangeEdge", IntStream.rangeClosed(Integer.MAX_VALUE - 1, Integer.MAX_VALUE).count() + ","
+                + LongStream.rangeClosed(Long.MAX_VALUE - 2, Long.MAX_VALUE).count());
+        out("intOps", IntStream.of(5, 3, 8, 3, 1).distinct().sorted().map(x -> x * 2).boxed()
+                .collect(Collectors.toList()));
+        out("intTerminals", IntStream.of(4, -2, 9).sum() + "," + IntStream.of(4, -2, 9).min().getAsInt() + ","
+                + IntStream.of(4, -2, 9).max().getAsInt() + "," + IntStream.of(4, -2, 9).average().getAsDouble() + ","
+                + IntStream.empty().average().isPresent() + "," + IntStream.of(1, 2, 3).reduce(10, (a, b) -> a * b) + ","
+                + IntStream.of(1, 2, 3).reduce(Math::max).getAsInt());
+        out("intOverflow", IntStream.of(Integer.MAX_VALUE, 1).sum());
+        IntSummaryStatistics st = IntStream.of(3, 9, -1).summaryStatistics();
+        out("intStats", st.getCount() + "," + st.getSum() + "," + st.getMin() + "," + st.getMax() + "," + st.getAverage());
+        out("intStatsEmpty", new IntSummaryStatistics().getMin() + "," + new IntSummaryStatistics().getMax());
+        out("intConvert", IntStream.of(1, 2).asLongStream().map(x -> x << 40).sum() + ","
+                + IntStream.of(1, 2).asDoubleStream().map(x -> x / 4).sum() + ","
+                + IntStream.of(65, 66).mapToObj(x -> String.valueOf((char) x)).collect(Collectors.joining()));
+        out("intMatch", IntStream.of(2, 4).allMatch(x -> x % 2 == 0) + "," + IntStream.of(2, 4).noneMatch(x -> x > 3)
+                + "," + IntStream.of(1, 3).anyMatch(x -> x == 3));
+        out("intIterate", ints(IntStream.iterate(1, x -> x * 2).limit(6).toArray()) + ","
+                + ints(IntStream.iterate(0, x -> x < 10, x -> x + 3).toArray()));
+        final int[] next = {0};
+        out("intGenerate", ints(IntStream.generate(() -> next[0]++).skip(2).limit(3).toArray()));
+        out("intFlat", ints(IntStream.of(1, 3).flatMap(x -> IntStream.range(0, x)).toArray()));
+        out("intTakeDrop", ints(IntStream.of(1, 2, 5, 1).takeWhile(x -> x < 3).toArray())
+                + ints(IntStream.of(1, 2, 5, 1).dropWhile(x -> x < 3).toArray()));
+        out("intConcat", ints(IntStream.concat(IntStream.of(1), IntStream.of(2, 3)).toArray()));
+        out("intCollect", IntStream.of(1, 2, 3).collect(ArrayList<Integer>::new, ArrayList::add, ArrayList::addAll));
+        PrimitiveIterator.OfInt pit = IntStream.of(7, 8).iterator();
+        StringBuilder pi = new StringBuilder();
+        pi.append(pit.nextInt());
+        pit.forEachRemaining((IntConsumer) x -> pi.append('+').append(x));
+        out("primIterator", pi);
+        out("intFind", IntStream.of(9, 8).findFirst().getAsInt() + "," + IntStream.empty().findAny().isPresent());
+        fails("emptyGetAsInt", () -> IntStream.empty().max().getAsInt());
+
+        out("longOps", LongStream.of(1L << 40, 3, 3).distinct().map(x -> x + 1).sum() + ","
+                + LongStream.range(0, 5).mapToInt(x -> (int) x * 2).sum() + ","
+                + LongStream.of(3, 1).sorted().boxed().collect(Collectors.toList()) + ","
+                + LongStream.of(5, 7).summaryStatistics().getAverage() + ","
+                + LongStream.of(5, 7).asDoubleStream().max().getAsDouble());
+        out("doubleOps", DoubleStream.of(1.5, -2.0, 4.25).sum() + "," + DoubleStream.of(1.5, -2.0).min().getAsDouble()
+                + "," + DoubleStream.of(0.5, 2.5).average().getAsDouble() + ","
+                + DoubleStream.of(2.5, 1.5).mapToLong(x -> (long) Math.floor(x)).sum() + ","
+                + DoubleStream.of(2.5, 1.5).mapToInt(x -> (int) x).max().getAsInt() + ","
+                + DoubleStream.of(1.0, Double.NaN).max().getAsDouble() + ","
+                + DoubleStream.iterate(1.0, x -> x / 2).limit(4).sum());
+        DoubleSummaryStatistics ds = DoubleStream.of(1e16, 1.0, -1e16).summaryStatistics();
+        out("doubleKahan", ds.getSum() + "," + ds.getMin() + "," + ds.getMax() + "," + ds.getCount());
+        out("optionals", OptionalInt.of(3) + "," + OptionalInt.empty() + "," + OptionalLong.of(4).orElse(1) + ","
+                + OptionalDouble.empty().orElseGet(() -> 2.5) + "," + OptionalInt.of(5).equals(OptionalInt.of(5)) + ","
+                + OptionalInt.of(6).stream().sum() + "," + Optional.of("o").stream().count() + ","
+                + Optional.empty().stream().count());
+    }
+
+    static class Item {
+        final String kind;
+        final String name;
+        final int qty;
+
+        Item(String kind, String name, int qty) {
+            this.kind = kind;
+            this.name = name;
+            this.qty = qty;
+        }
+
+        public String toString() {
+            return name;
+        }
+    }
+
+    static void collectors() {
+        List<Item> items = Arrays.asList(new Item("fruit", "apple", 3), new Item("veg", "leek", 1),
+                new Item("fruit", "plum", 5), new Item("nut", "pecan", 2), new Item("veg", "kale", 4));
+        out("groupingBy", sorted(items.stream().collect(Collectors.groupingBy(i -> i.kind))));
+        out("groupingByCounting", sorted(items.stream().collect(Collectors.groupingBy(i -> i.kind, Collectors.counting()))));
+        out("groupingByTree", items.stream().collect(Collectors.groupingBy(i -> i.kind, TreeMap::new,
+                Collectors.mapping(i -> i.name, Collectors.joining("|")))));
+        out("partitioningBy", items.stream().collect(Collectors.partitioningBy(i -> i.qty > 2)));
+        out("partitionEmpty", Stream.<Item>empty().collect(Collectors.partitioningBy(i -> true, Collectors.counting())));
+        out("toMap", sorted(items.stream().collect(Collectors.toMap(i -> i.name, i -> i.qty))));
+        out("toMapMerge", sorted(items.stream().collect(Collectors.toMap(i -> i.kind, i -> i.qty, Integer::sum))));
+        out("toMapTree", items.stream().collect(Collectors.toMap(i -> i.kind, i -> i.name, (a, b) -> a + "&" + b,
+                TreeMap::new)));
+        fails("toMapDuplicate", () -> items.stream().collect(Collectors.toMap(i -> i.kind, i -> i.qty)));
+        fails("toMapNullValue", () -> Stream.of("a").collect(Collectors.toMap(x -> x, x -> null)));
+        out("numbers", items.stream().collect(Collectors.summingInt(i -> i.qty)) + ","
+                + items.stream().collect(Collectors.summingLong(i -> i.qty)) + ","
+                + items.stream().collect(Collectors.summingDouble(i -> i.qty / 2.0)) + ","
+                + items.stream().collect(Collectors.averagingInt(i -> i.qty)) + ","
+                + items.stream().collect(Collectors.averagingLong(i -> i.qty)) + ","
+                + items.stream().collect(Collectors.averagingDouble(i -> i.qty)) + ","
+                + Stream.<Item>empty().collect(Collectors.averagingInt(i -> i.qty)) + ","
+                + items.stream().collect(Collectors.counting()));
+        IntSummaryStatistics is = items.stream().collect(Collectors.summarizingInt(i -> i.qty));
+        out("summarizing", is.getMin() + "," + is.getMax() + "," + is.getSum() + ","
+                + items.stream().collect(Collectors.summarizingLong(i -> i.qty)).getMax() + ","
+                + items.stream().collect(Collectors.summarizingDouble(i -> i.qty)).getAverage());
+        out("reducing", items.stream().map(i -> i.qty).collect(Collectors.reducing(0, Integer::sum)) + ","
+                + items.stream().map(i -> i.qty).collect(Collectors.reducing(Integer::max)).get() + ","
+                + items.stream().collect(Collectors.reducing(0, i -> i.qty, Integer::sum)) + ","
+                + Stream.<Integer>empty().collect(Collectors.reducing(Integer::max)).isPresent());
+        out("minMaxBy", items.stream().collect(Collectors.minBy(Comparator.comparingInt(i -> i.qty))).get() + ","
+                + items.stream().collect(Collectors.maxBy(Comparator.comparingInt(i -> i.qty))).get());
+        out("filteringFlatMapping", items.stream().collect(Collectors.filtering(i -> i.qty > 1,
+                Collectors.mapping(i -> i.name, Collectors.toList()))) + ","
+                + items.stream().limit(2).collect(Collectors.flatMapping(i -> Stream.of(i.kind, i.name),
+                Collectors.toList())));
+        out("collectingAndThen", items.stream().map(i -> i.name).collect(Collectors.collectingAndThen(
+                Collectors.toList(), List::size)));
+        out("toSet", sorted(items.stream().map(i -> i.kind).collect(Collectors.toSet())) + ","
+                + items.stream().map(i -> i.kind).collect(Collectors.toCollection(TreeSet::new)));
+        out("joining", Stream.of("a", "b").collect(Collectors.joining()) + "," + Stream.<String>empty()
+                .collect(Collectors.joining(",", "[", "]")) + "," + Stream.of("x").collect(Collectors.joining("-", "(", ")")));
+        fails("unmodifiableList", () -> Stream.of(1).collect(Collectors.toUnmodifiableList()).add(2));
+        fails("unmodifiableListNull", () -> Stream.of((Object) null).collect(Collectors.toUnmodifiableList()));
+        fails("unmodifiableSet", () -> Stream.of(1).collect(Collectors.toUnmodifiableSet()).add(2));
+        fails("unmodifiableMap", () -> Stream.of(1).collect(Collectors.toUnmodifiableMap(x -> x, x -> x)).clear());
+        out("unmodifiableMapMerge", sorted(Stream.of(1, 1, 2).collect(Collectors.toUnmodifiableMap(x -> x, x -> 1,
+                Integer::sum))));
+        Collector<String, ?, List<String>> custom = Collector.of(ArrayList::new, List::add,
+                (a, c) -> { a.addAll(c); return a; });
+        out("collectorOf", Stream.of("q").collect(custom) + "," + custom.characteristics().contains(
+                Collector.Characteristics.IDENTITY_FINISH) + "," + Stream.of("r", "s").collect(Collector.of(
+                StringBuilder::new, StringBuilder::append, StringBuilder::append, StringBuilder::length)));
+        fails("nullKey", () -> Stream.of("a").collect(Collectors.groupingBy(x -> null)));
+    }
+
+    static void collectionMembers() {
+        List<Integer> l = List.of(3, 1, 2);
+        out("listOf", l + "," + List.of() + "," + List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).size() + ","
+                + l.indexOf(2) + "," + l.contains(1) + "," + l.equals(Arrays.asList(3, 1, 2)) + ","
+                + (l.hashCode() == Arrays.asList(3, 1, 2).hashCode()));
+        fails("listOfNull", () -> List.of(1, null));
+        fails("listOfAdd", () -> l.add(4));
+        fails("listOfSet", () -> l.set(0, 4));
+        fails("listOfSort", () -> l.sort(null));
+        fails("listOfContainsNull", () -> l.contains(null));
+        fails("listOfGet", () -> l.get(3));
+        Integer[] backing = {1, 2};
+        List<Integer> copied = List.of(backing);
+        backing[0] = 9;
+        out("listOfCopies", copied);
+        List<Integer> mutable = new ArrayList<Integer>(Arrays.asList(5, 6));
+        List<Integer> copy = List.copyOf(mutable);
+        mutable.add(7);
+        out("listCopyOf", copy + "," + (List.copyOf(copy) == copy));
+        out("setOf", sorted(Set.of("b", "a", "c")) + "," + Set.of().size() + "," + Set.of(1).contains(1) + ","
+                + Set.of(1, 2).equals(new HashSet<Integer>(Arrays.asList(2, 1))) + "," + sorted(Set.copyOf(Arrays.asList(1, 1, 2))));
+        fails("setOfDuplicate", () -> Set.of(1, 1));
+        fails("setOfNull", () -> Set.of((Object) null));
+        fails("setOfRemove", () -> Set.of(1).remove(1));
+        Map<String, Integer> m = Map.of("one", 1, "two", 2);
+        out("mapOf", sorted(m) + "," + Map.of().size() + "," + m.get("two") + "," + m.containsKey("three") + ","
+                + m.getOrDefault("x", 0) + "," + sorted(Map.ofEntries(Map.entry("k", "v"), Map.entry("j", "w")))
+                + "," + Map.of(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10).size() + ","
+                + m.equals(new HashMap<String, Integer>(m)));
+        fails("mapOfDuplicate", () -> Map.of("a", 1, "a", 2));
+        fails("mapOfNullValue", () -> Map.of("a", null));
+        fails("mapOfPut", () -> m.put("x", 1));
+        fails("mapOfMerge", () -> m.merge("one", 1, Integer::sum));
+        fails("mapOfGetNull", () -> m.get(null));
+        Map<String, Integer> hm = new HashMap<String, Integer>(m);
+        Map<String, Integer> mc = Map.copyOf(hm);
+        hm.put("three", 3);
+        out("mapCopyOf", sorted(mc) + "," + (Map.copyOf(mc) == mc));
+        Map.Entry<String, Integer> e = Map.entry("k", 5);
+        out("entry", e + "," + e.getKey() + e.getValue() + "," + e.equals(new AbstractMap.SimpleEntry<String, Integer>("k", 5)));
+        fails("entrySet", () -> e.setValue(6));
+        fails("entryNull", () -> Map.entry(null, 1));
+        List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>(
+                new TreeMap<String, Integer>(Map.of("b", 1, "a", 3, "c", 2)).entrySet());
+        Collections.sort(entries, Map.Entry.comparingByValue());
+        out("byValue", entries);
+        Collections.sort(entries, Map.Entry.comparingByKey(Comparator.reverseOrder()));
+        out("byKeyDesc", entries);
+        Collections.sort(entries, Map.Entry.<String, Integer>comparingByKey());
+        out("byKey", entries);
+        Collections.sort(entries, Map.Entry.comparingByValue(Comparator.reverseOrder()));
+        out("byValueDesc", entries);
+
+        final StringBuilder rest = new StringBuilder();
+        Iterator<String> it = Arrays.asList("a", "b", "c").iterator();
+        it.next();
+        it.forEachRemaining(rest::append);
+        out("forEachRemaining", rest);
+        Iterator<String> plain = new Iterator<String>() {
+            public boolean hasNext() {
+                return false;
+            }
+
+            public String next() {
+                throw new NoSuchElementException();
+            }
+        };
+        fails("defaultRemove", plain::remove);
+        out("toArrayGen", Arrays.toString(new ArrayList<String>(Arrays.asList("x", "y")).toArray(String[]::new)));
+        Iterable<Integer> iterable = () -> Arrays.asList(4, 5, 6).iterator();
+        out("streamSupport", StreamSupport.stream(iterable.spliterator(), false).map(x -> x * 2)
+                .collect(Collectors.toList()));
+        Spliterator<String> sp = Arrays.asList("s", "t").spliterator();
+        StringBuilder sps = new StringBuilder();
+        sp.tryAdvance(sps::append);
+        sp.forEachRemaining(sps::append);
+        out("spliterator", sps + "," + Arrays.asList(1, 2, 3).spliterator().getExactSizeIfKnown() + ","
+                + iterable.spliterator().getExactSizeIfKnown() + ","
+                + Arrays.asList(1).spliterator().hasCharacteristics(Spliterator.SIZED));
+        Iterator<Integer> fromSp = Spliterators.iterator(Arrays.asList(8, 9).spliterator());
+        out("spliteratorsIterator", fromSp.next() + "," + fromSp.hasNext() + "," + fromSp.next() + "," + fromSp.hasNext());
+        out("arraysStream", Arrays.stream(new String[] {"a", "b", "c"}, 1, 3).collect(Collectors.toList()) + ","
+                + Arrays.stream(new int[] {1, 2, 3}).sum() + "," + Arrays.stream(new long[] {4, 5}, 1, 2).sum() + ","
+                + Arrays.stream(new double[] {0.5, 0.25}).sum());
+        fails("arraysStreamRange", () -> Arrays.stream(new int[2], 1, 3));
+        out("streamOfSet", new TreeSet<Integer>(Arrays.asList(3, 1, 2)).stream().map(String::valueOf)
+                .collect(Collectors.joining()));
+        Map<String, List<Integer>> grouped = new TreeMap<String, List<Integer>>();
+        for (int i = 0; i < 5; i++) {
+            grouped.computeIfAbsent(i % 2 == 0 ? "even" : "odd", k -> new ArrayList<Integer>()).add(i);
+        }
+        out("computeIfAbsent", grouped);
+        out("removeIfStream", new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4)).stream().filter(x -> x > 1)
+                .mapToInt(Integer::intValue).boxed().collect(Collectors.toCollection(LinkedList::new)));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamPipelineChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamPipelineChecks.java
new file mode 100644
index 00000000000..0be9fdc3c3e
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StreamPipelineChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// StreamPipelineApp, formerly translated and built on its own by FunctionalApiIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class StreamPipelineChecks {
+    private StreamPipelineChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("StreamPipelineApp", () -> StreamPipelineApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/StringBuilderGrowthApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringBuilderGrowthApp.java
similarity index 99%
rename from vm/tests/src/test/resources/com/codename1/tools/translator/StringBuilderGrowthApp.java
rename to vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringBuilderGrowthApp.java
index 63e78f99d19..f578c2258df 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/StringBuilderGrowthApp.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringBuilderGrowthApp.java
@@ -30,7 +30,7 @@ public class StringBuilderGrowthApp {
     private static final String TEXT = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\n";
     private static final int APPENDS = 1000;
 
-    public static void main(String[] args) throws Exception {
+    public static void fixtureMain(String[] args) throws Exception {
         if (args.length != 0 && "monitors".equals(args[0])) {
             externalMonitorCopies();
             System.out.println("BUILDER_MONITORS_OK");
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringBuilderGrowthChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringBuilderGrowthChecks.java
new file mode 100644
index 00000000000..626fd38209a
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringBuilderGrowthChecks.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// StringBuilderGrowthApp, formerly translated and built on its own by StringBuilderGrowthIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class StringBuilderGrowthChecks {
+    private StringBuilderGrowthChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        // ParparVM's StringBuilder is safe under concurrent appends (issue
+        // #5963: unsynchronized growth corrupted its native storage); the JDK's
+        // is not, so this runs on ParparVM only. It throws on any corruption.
+        Bulk.cn1Only("StringBuilderGrowthApp", () -> StringBuilderGrowthApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/StringFormatApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringFormatApp.java
similarity index 98%
rename from vm/tests/src/test/resources/com/codename1/tools/translator/StringFormatApp.java
rename to vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringFormatApp.java
index 98078646aa7..173d52a230c 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/StringFormatApp.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringFormatApp.java
@@ -432,15 +432,24 @@ private static void g(String label, String format, Object... args) {
         OUT.append("CN1ONLY|").append(label).append('|').append(rendering).append('\n');
     }
 
-    public static void main(String[] args) {
+    public static void fixtureMain(String[] args) {
         byte[] consoleSlice = "xCASE|console.slice|bulk\ny".getBytes();
         System.out.write(consoleSlice, 1, consoleSlice.length - 2);
         strings();
         integers();
         floats();
         failures();
-        unsupported();
         System.out.println(OUT.toString());
         System.out.println("DONE");
     }
+
+    /// The CN1ONLY lines of `unsupported()`, which ParparVM answers on its
+    /// own (StringFormatChecks asserts them on ParparVM only).
+    static String unsupportedCases() {
+        OUT.setLength(0);
+        unsupported();
+        String lines = OUT.toString();
+        OUT.setLength(0);
+        return lines;
+    }
 }
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringFormatChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringFormatChecks.java
new file mode 100644
index 00000000000..87e4eba070d
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/StringFormatChecks.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// StringFormatApp, formerly translated and built on its own by StringFormatIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class StringFormatChecks {
+    private StringFormatChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("StringFormatApp", () -> StringFormatApp.fixtureMain(new String[0]));
+        // The JDK formats %a and %t, which ParparVM does not implement, and its
+        // answer to %0$s moved between versions (accepted on 11, rejected from
+        // 16 on). Either way ParparVM must throw a catchable exception, since
+        // the point of issue #5482 was a formatting problem taking the whole
+        // process down.
+        Bulk.cn1Only("StringFormatApp.unsupported", () -> Bulk.expectEquals(
+                "CN1ONLY|hexFloat|EX|java.util.UnknownFormatConversionException\n"
+                        + "CN1ONLY|dateTime|EX|java.util.UnknownFormatConversionException\n"
+                        + "CN1ONLY|zeroArgumentIndex|EX|java.util.IllegalFormatArgumentIndexException\n",
+                StringFormatApp.unsupportedCases(), "unsupported specifiers throw"));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SwitchoverMembersApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SwitchoverMembersApp.java
new file mode 100644
index 00000000000..69af4f6a250
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SwitchoverMembersApp.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ServiceLoader;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/// Members an application compiled against the JDK calls, which the class
+/// library carries under their own names: the sequenced methods of `List`, `CharSequence.chars` and
+/// `codePoints`, `Throwable.printStackTrace(PrintWriter)`, the lazy `Files`
+/// streams, `BufferedReader.lines`, `ServiceLoader.findFirst` and the URL
+/// coders. Run on HotSpot (the JDK's own classes) and on ParparVM; the
+/// RESULT lines must match. A case answers a string, or the class of what it
+/// threw. Java 21 API.
+public class SwitchoverMembersApp {
+
+    static final int CASES = 40;
+
+    static Path dir;
+
+    /// Runs every case; the bulk program has installed its file system host
+    /// on the ParparVM side (the translator allows one `main` per program).
+    public static void fixtureMain(String[] args) throws Exception {
+        dir = Files.createTempDirectory("switchover");
+        Files.write(dir.resolve("a.txt"), Arrays.asList("x", "y", "z"), StandardCharsets.UTF_8);
+        Files.createDirectories(dir.resolve("sub"));
+        Files.write(dir.resolve("sub").resolve("b.txt"), Arrays.asList("one"), StandardCharsets.UTF_8);
+        Files.write(dir.resolve("sub").resolve("c.log"), Arrays.asList("two"), StandardCharsets.UTF_8);
+        StringBuilder all = new StringBuilder();
+        for (int i = 0; i < CASES; i++) {
+            String v;
+            try {
+                v = run(i);
+            } catch (Throwable t) {
+                v = "!" + t.getClass().getName();
+            }
+            if (v == null) {
+                continue;
+            }
+            System.out.println("case " + i + " = " + v);
+            all.append(i).append('=').append(v).append('|');
+        }
+        System.out.println("RESULT=" + all);
+    }
+
+    static List<String> list(String... values) {
+        return new ArrayList<String>(Arrays.asList(values));
+    }
+
+    /// A list with no overrides of its own, so the interface's defaults run.
+    static List<String> plain(String... values) {
+        final List<String> backing = list(values);
+        return new java.util.AbstractList<String>() {
+            public String get(int index) {
+                return backing.get(index);
+            }
+
+            public int size() {
+                return backing.size();
+            }
+
+            public void add(int index, String s) {
+                backing.add(index, s);
+            }
+
+            public String remove(int index) {
+                return backing.remove(index);
+            }
+
+            public String set(int index, String s) {
+                return backing.set(index, s);
+            }
+        };
+    }
+
+    /// Paths under the temporary directory, relative to it and sorted, so
+    /// neither the directory's name nor the listing order shows.
+    static String names(Stream<Path> paths) {
+        try {
+            final String root = dir.toString();
+            return paths.map(new Function<Path, String>() {
+                public String apply(Path p) {
+                    String s = p.toString();
+                    return s.length() > root.length() ? s.substring(root.length() + 1) : ".";
+                }
+            }).sorted().collect(Collectors.joining(","));
+        } finally {
+            paths.close();
+        }
+    }
+
+    static String ints(java.util.stream.IntStream s) {
+        StringBuilder sb = new StringBuilder();
+        java.util.PrimitiveIterator.OfInt it = s.iterator();
+        while (it.hasNext()) {
+            sb.append(Integer.toHexString(it.nextInt())).append(',');
+        }
+        return sb.toString();
+    }
+
+    static String run(int i) throws Exception {
+        String smile = new String(new int[] {0x1F600}, 0, 1);
+        String eAcute = String.valueOf((char) 0xe9);
+        switch (i) {
+            // ---- List, sequenced
+            case 0: {
+                List<String> l = list("b");
+                l.addFirst("a");
+                l.addLast("c");
+                return l + " " + l.getFirst() + l.getLast();
+            }
+            case 1: {
+                List<String> l = plain("b");
+                l.addFirst("a");
+                l.addLast("c");
+                return l + " " + l.getFirst() + l.getLast();
+            }
+            case 2: {
+                List<String> l = plain("a", "b", "c");
+                return l.removeFirst() + l.removeLast() + l;
+            }
+            case 3: return plain().getFirst();
+            case 4: return plain().removeLast();
+            case 5: return String.valueOf(plain("a", "b", "c").reversed());
+            case 6: {
+                List<String> l = plain("a", "b", "c");
+                List<String> r = l.reversed();
+                r.addFirst("d");
+                r.removeLast();
+                return l + " " + r + " " + r.reversed().equals(l) + " " + r.get(0) + r.size();
+            }
+            case 7: {
+                List<String> l = new LinkedList<String>(Arrays.asList("x", "y"));
+                l.addFirst("w");
+                return l.reversed() + l.getLast();
+            }
+            case 8: {
+                List<String> l = Collections.unmodifiableList(list("a"));
+                l.addFirst("z");
+                return String.valueOf(l);
+            }
+            case 9: return String.valueOf(plain("a", "b").reversed().subList(0, 1));
+            // ---- CharSequence
+            case 10: return ints("ab".chars());
+            case 11: return ints(("a" + smile + "b").chars());
+            case 12: return ints(("a" + smile + "b").codePoints());
+            case 13: return ints(new StringBuilder("x" + smile).codePoints());
+            case 14: return "" + new StringBuilder("hello").chars().filter(new java.util.function.IntPredicate() {
+                public boolean test(int c) {
+                    return c == 'l';
+                }
+            }).count();
+            case 15: {
+                // A sequence that is neither a String nor a builder: the
+                // interface's defaults, a lone surrogate included.
+                final String s = "q" + smile.charAt(0);
+                CharSequence cs = new CharSequence() {
+                    public int length() {
+                        return s.length();
+                    }
+
+                    public char charAt(int index) {
+                        return s.charAt(index);
+                    }
+
+                    public CharSequence subSequence(int start, int end) {
+                        return s.subSequence(start, end);
+                    }
+
+                    public String toString() {
+                        return s;
+                    }
+                };
+                return ints(cs.chars()) + "/" + ints(cs.codePoints());
+            }
+            // ---- Throwable.printStackTrace(PrintWriter)
+            case 16: {
+                StringWriter w = new StringWriter();
+                PrintWriter pw = new PrintWriter(w);
+                new IllegalStateException("boom").printStackTrace(pw);
+                pw.flush();
+                String text = w.toString();
+                int nl = text.indexOf('\n');
+                return (nl < 0 ? text : text.substring(0, nl)).trim();
+            }
+            case 17: {
+                StringWriter w = new StringWriter();
+                PrintWriter pw = new PrintWriter(w);
+                new RuntimeException("outer", new IOException("inner")).printStackTrace(pw);
+                pw.flush();
+                return "" + w.toString().contains("Caused by: java.io.IOException: inner");
+            }
+            // ---- Files, lazily
+            case 18: {
+                Stream<String> s = Files.lines(dir.resolve("a.txt"));
+                try {
+                    return s.collect(Collectors.joining(","));
+                } finally {
+                    s.close();
+                }
+            }
+            case 19: {
+                Stream<String> s = Files.lines(dir.resolve("a.txt"), StandardCharsets.UTF_8);
+                try {
+                    return "" + s.skip(1).findFirst().get();
+                } finally {
+                    s.close();
+                }
+            }
+            case 20: return names(Files.list(dir));
+            case 21: return names(Files.walk(dir));
+            case 22: return names(Files.walk(dir, 1));
+            case 23: return names(Files.find(dir, 10, new BiPredicate<Path, BasicFileAttributes>() {
+                public boolean test(Path p, BasicFileAttributes a) {
+                    return a.isRegularFile() && p.toString().endsWith(".txt");
+                }
+            }));
+            case 24: return names(Files.find(dir, 0, new BiPredicate<Path, BasicFileAttributes>() {
+                public boolean test(Path p, BasicFileAttributes a) {
+                    return true;
+                }
+            }));
+            case 25: return names(Files.list(dir.resolve("missing")));
+            case 26: return names(Files.list(dir.resolve("a.txt")));
+            case 27: return "" + Files.lines(dir.resolve("missing.txt")).count();
+            // ---- BufferedReader.lines
+            case 28: return new BufferedReader(new StringReader("a\nb\r\nc\rd")).lines()
+                    .collect(Collectors.joining(","));
+            case 29: {
+                BufferedReader r = new BufferedReader(new StringReader("first\nsecond\nthird"));
+                String first = r.readLine();
+                return first + ":" + r.lines().count();
+            }
+            case 30: return "" + new BufferedReader(new StringReader("")).lines().count();
+            // ---- ServiceLoader
+            case 31: return "" + ServiceLoader.load(Runnable.class).findFirst().isPresent();
+            // ---- URLEncoder and URLDecoder
+            case 32: return URLEncoder.encode("a b&c=d/e~*._-" + eAcute, "UTF-8");
+            case 33: return URLEncoder.encode("x+y " + smile, StandardCharsets.UTF_8);
+            case 34: return ints(URLDecoder.decode("a+b%26c%3Dd%2F%C3%A9", "UTF-8").codePoints());
+            case 35: return ints(URLDecoder.decode("%F0%9F%98%80+", StandardCharsets.UTF_8).codePoints());
+            case 36: return URLDecoder.decode("%zz", "UTF-8");
+            case 37: return URLDecoder.decode("50%", "UTF-8");
+            case 38: return URLEncoder.encode("x", "no-such-charset");
+            case 39: return URLDecoder.decode(URLEncoder.encode("round trip?" + eAcute, "UTF-8"), "UTF-8")
+                    .equals("round trip?" + eAcute) ? "same" : "differs";
+            default: return null;
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SwitchoverMembersChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SwitchoverMembersChecks.java
new file mode 100644
index 00000000000..ff52b758137
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SwitchoverMembersChecks.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// SwitchoverMembersApp, which used to be translated and built by a test of its own,
+/// run as one check of the bulk program. Its `fixtureMain` (the translator
+/// allows one `main` per program) prints what its `main` always
+/// printed (case lines and a RESULT line); a difference names the line.
+public final class SwitchoverMembersChecks {
+    private SwitchoverMembersChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("SwitchoverMembersApp", () -> SwitchoverMembersApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SystemMembersApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SystemMembersApp.java
new file mode 100644
index 00000000000..4c223052d79
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SystemMembersApp.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+public class SystemMembersApp {
+    private static final StringBuilder OUT = new StringBuilder();
+    private static Thread seenThread;
+    private static String seenMessage;
+    private static String seenDefault;
+
+    private static void check(String name, boolean ok) {
+        OUT.append(name).append(ok ? ":ok;" : ":FAIL;");
+    }
+
+    private static void systemMembers() {
+        check("lineSeparator", "\n".equals(System.lineSeparator()));
+        check("lineSeparatorProperty", "\n".equals(System.getProperty("line.separator")));
+        check("fileSeparator", "/".equals(System.getProperty("file.separator")));
+        check("pathSeparator", ":".equals(System.getProperty("path.separator")));
+        check("unsetIsNull", System.getProperty("cn1.members.absent") == null);
+        check("unsetDefault", "d".equals(System.getProperty("cn1.members.absent", "d")));
+        check("firstSet", System.setProperty("cn1.members.key", "a") == null);
+        check("secondSet", "a".equals(System.setProperty("cn1.members.key", "b")));
+        check("read", "b".equals(System.getProperty("cn1.members.key")));
+        check("clear", "b".equals(System.clearProperty("cn1.members.key")));
+        check("cleared", System.getProperty("cn1.members.key") == null);
+        check("getenv", System.getenv() != null);
+        boolean npe = false;
+        try {
+            System.getProperty(null);
+        } catch (NullPointerException e) {
+            npe = true;
+        }
+        check("nullKey", npe);
+        boolean iae = false;
+        try {
+            System.getProperty("");
+        } catch (IllegalArgumentException e) {
+            iae = true;
+        }
+        check("emptyKey", iae);
+    }
+
+    private static void threadMembers() throws Exception {
+        Thread a = new Thread();
+        Thread b = new Thread();
+        check("idStable", a.getId() == a.getId());
+        check("idDistinct", a.getId() != b.getId());
+        a.setName("worker");
+        check("setName", "worker".equals(a.getName()));
+        boolean npe = false;
+        try {
+            a.setName(null);
+        } catch (NullPointerException e) {
+            npe = true;
+        }
+        check("setNameNull", npe);
+
+        Thread failing = new Thread(new Runnable() {
+            public void run() {
+                throw new IllegalStateException("own");
+            }
+        });
+        final Thread[] holder = {failing};
+        Thread.UncaughtExceptionHandler own = new Thread.UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+                seenThread = t;
+                seenMessage = e.getMessage();
+            }
+        };
+        failing.setUncaughtExceptionHandler(own);
+        check("ownHandlerSet", failing.getUncaughtExceptionHandler() == own);
+        failing.start();
+        failing.join();
+        check("ownHandlerThread", seenThread == holder[0]);
+        check("ownHandlerMessage", "own".equals(seenMessage));
+
+        Thread.UncaughtExceptionHandler fallback = new Thread.UncaughtExceptionHandler() {
+            public void uncaughtException(Thread t, Throwable e) {
+                seenDefault = e.getMessage();
+            }
+        };
+        Thread.setDefaultUncaughtExceptionHandler(fallback);
+        check("defaultSet", Thread.getDefaultUncaughtExceptionHandler() == fallback);
+        Thread plain = new Thread(new Runnable() {
+            public void run() {
+                throw new IllegalStateException("default");
+            }
+        });
+        plain.start();
+        plain.join(10000, 0);
+        check("defaultHandler", "default".equals(seenDefault));
+        Thread.setDefaultUncaughtExceptionHandler(null);
+        check("defaultCleared", Thread.getDefaultUncaughtExceptionHandler() == null);
+        Thread.sleep(1, 0);
+        check("sleepNanos", true);
+    }
+
+    private static void runtimeMembers() {
+        Runtime rt = Runtime.getRuntime();
+        check("processors", rt.availableProcessors() >= 1);
+        check("maxMemory", rt.maxMemory() > 0);
+        boolean npe = false;
+        try {
+            rt.addShutdownHook(null);
+        } catch (NullPointerException e) {
+            npe = true;
+        }
+        check("hookNull", npe);
+        Thread hook = new Thread();
+        rt.addShutdownHook(hook);
+        boolean twice = false;
+        try {
+            rt.addShutdownHook(hook);
+        } catch (IllegalArgumentException e) {
+            twice = true;
+        }
+        check("hookTwice", twice);
+        check("hookRemoved", rt.removeShutdownHook(hook));
+        check("hookRemovedAgain", !rt.removeShutdownHook(hook));
+        rt.addShutdownHook(new Thread(new Runnable() {
+            public void run() {
+                OUT.append("hookRan;");
+                System.out.println("RESULT=" + OUT);
+            }
+        }));
+    }
+
+    public static void fixtureMain(String[] args) throws Exception {
+        systemMembers();
+        threadMembers();
+        runtimeMembers();
+        // The RESULT line is printed by the shutdown hook when the bulk
+        // program calls System.exit at its end, so it lands in the "(end)"
+        // section of the output, and a VM that does not run hooks on exit
+        // prints none there.
+        System.out.println("registered=" + OUT);
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SystemMembersChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SystemMembersChecks.java
new file mode 100644
index 00000000000..89a69631391
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/SystemMembersChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// SystemMembersApp, formerly translated and built on its own by SystemMembersIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class SystemMembersChecks {
+    private SystemMembersChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("SystemMembersApp", () -> SystemMembersApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeChecks.java
new file mode 100644
index 00000000000..a4c20c711a3
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeChecks.java
@@ -0,0 +1,805 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.time.Clock;
+import java.time.DateTimeException;
+import java.time.DayOfWeek;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.time.OffsetDateTime;
+import java.time.Period;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAmount;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/// java.time over a grid of dates, times, moments, zones and units. Every
+/// answer is printed as text: the value's `toString`, an enum's name, or the
+/// simple name of what was thrown (`DateTimeException` for any of its
+/// subclasses, as the JDK throws narrower ones in places).
+///
+/// Zoned values in a region are printed only from 1900 on. JavaAPI takes a
+/// region's offsets from `java.util.TimeZone`, which has no rules before 1900
+/// and answers the 1900 offset for anything earlier, where the JDK's
+/// `java.time` answers local mean time; that is a difference in the host's
+/// data, not in the arithmetic under test. Such a result prints a marker
+/// instead of its value.
+public final class TimeChecks {
+    private TimeChecks() {
+    }
+
+    /// One computation of the grid.
+    private interface Call {
+        Object call() throws Exception;
+    }
+
+    private static int compared;
+
+    private static final LocalDate[] DATES = {LocalDate.of(1600, 2, 29), LocalDate.of(1899, 12, 31),
+        LocalDate.of(1969, 12, 31), LocalDate.of(1970, 1, 1), LocalDate.of(1999, 12, 31), LocalDate.of(2000, 2, 29),
+        LocalDate.of(2000, 3, 1), LocalDate.of(2023, 1, 31), LocalDate.of(2023, 2, 28), LocalDate.of(2023, 12, 31),
+        LocalDate.of(2024, 1, 1), LocalDate.of(2024, 2, 29), LocalDate.of(2024, 3, 31), LocalDate.of(2024, 5, 15),
+        LocalDate.of(2024, 5, 16), LocalDate.of(2024, 6, 15), LocalDate.of(2025, 2, 28), LocalDate.of(2026, 10, 9),
+        LocalDate.of(2100, 2, 28), LocalDate.of(3000, 7, 4)};
+
+    private static final LocalTime[] TIMES = {LocalTime.of(0, 0), LocalTime.of(0, 0, 0, 1),
+        LocalTime.of(12, 34, 56, 789000000), LocalTime.of(23, 59, 59, 999999999)};
+
+    private static final long[] AMOUNTS = {-400, -25, -1, 0, 1, 7, 13, 1000};
+
+    private static final String[] ZONES = {"UTC", "America/New_York", "Asia/Kolkata"};
+
+    /// The first moment a region's offsets are compared at; see the class
+    /// comment.
+    private static final long REGION_RULES_FROM = LocalDate.of(1900, 1, 2).toEpochDay() * 86400L;
+
+    private static final String UNKNOWN_RULES = "(before the region's rules)";
+
+    private static List<LocalDateTime> dateTimes() {
+        List<LocalDateTime> out = new ArrayList<LocalDateTime>();
+        for (int d = 0; d < DATES.length; d += 2) {
+            for (LocalTime t : TIMES) {
+                out.add(LocalDateTime.of(DATES[d], t));
+            }
+        }
+        out.add(LocalDateTime.of(2024, 3, 10, 1, 30));
+        out.add(LocalDateTime.of(2024, 3, 10, 3, 30));
+        out.add(LocalDateTime.of(2024, 11, 3, 1, 30));
+        return out;
+    }
+
+    private static List<Instant> instants() {
+        List<Instant> out = new ArrayList<Instant>();
+        for (LocalDateTime dt : dateTimes()) {
+            out.add(dt.toInstant(ZoneOffset.UTC));
+        }
+        return out;
+    }
+
+    private static boolean regionRulesKnown(Instant i, ZoneId zone) {
+        return zone instanceof ZoneOffset || "UTC".equals(zone.getId()) || i.getEpochSecond() >= REGION_RULES_FROM;
+    }
+
+    private static String simpleName(Throwable t) {
+        String n = t.getClass().getName();
+        int dot = n.lastIndexOf('.');
+        return dot < 0 ? n : n.substring(dot + 1);
+    }
+
+    /// What `call` answers, or the marker when it answers a moment in a
+    /// region before that region's rules are known; see the class comment.
+    private static String outcome(Call call) {
+        try {
+            Object o = call.call();
+            if (o instanceof Enum) {
+                return ((Enum<?>) o).name();
+            }
+            if (o instanceof ZonedDateTime) {
+                ZonedDateTime z = (ZonedDateTime) o;
+                if (!regionRulesKnown(z.toInstant(), z.getZone())) {
+                    return UNKNOWN_RULES;
+                }
+            }
+            return String.valueOf(o);
+        } catch (DateTimeException e) {
+            return "DateTimeException";
+        } catch (Exception e) {
+            return simpleName(e);
+        }
+    }
+
+    private static void same(String what, Call call) {
+        Bulk.p(what, outcome(call));
+        compared++;
+    }
+
+    private static void begin() {
+        compared = 0;
+    }
+
+    private static void end(int atLeast) {
+        Bulk.p("compared>" + atLeast, compared > atLeast);
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("Time.datesAreTheJdks", TimeChecks::datesAreTheJdks);
+        Bulk.check("Time.datesWithTimesAreTheJdks", TimeChecks::datesWithTimesAreTheJdks);
+        Bulk.check("Time.momentsAndZonesAreTheJdks", TimeChecks::momentsAndZonesAreTheJdks);
+        Bulk.cn1Only("Time.instantUntilMillisAndMicrosAsJava17", TimeChecks::instantUntilMillisAndMicrosAsJava17);
+        Bulk.check("Time.gapsAndOverlapsAreTheJdks", TimeChecks::gapsAndOverlapsAreTheJdks);
+        Bulk.check("Time.durationsAreTheJdks", TimeChecks::durationsAreTheJdks);
+        Bulk.check("Time.periodsAreTheJdks", TimeChecks::periodsAreTheJdks);
+        Bulk.check("Time.offsetsZonesAndClocksAreTheJdks", TimeChecks::offsetsZonesAndClocksAreTheJdks);
+        Bulk.check("Time.patternsFormatAndParseAsTheJdks", TimeChecks::patternsFormatAndParseAsTheJdks);
+        Bulk.check("Time.isoFormatsAreTheJdks", TimeChecks::isoFormatsAreTheJdks);
+        Bulk.check("Time.zonesAndOffsetsAreTheJdks", TimeChecks::zonesAndOffsetsAreTheJdks);
+        Bulk.check("Time.daysAndMonthsAreTheJdks", TimeChecks::daysAndMonthsAreTheJdks);
+        Bulk.check("Time.amountsThatOverflowAreRefusedAsTheJdkRefusesThem",
+                TimeChecks::amountsThatOverflowAreRefusedAsTheJdkRefusesThem);
+    }
+
+    private static void datesAreTheJdks() {
+        begin();
+        for (final LocalDate d : DATES) {
+            same("text " + d, () -> d);
+            same("dow " + d, d::getDayOfWeek);
+            same("month " + d, d::getMonth);
+            same("doy " + d, d::getDayOfYear);
+            same("loy " + d, d::lengthOfYear);
+            same("lom " + d, d::lengthOfMonth);
+            same("leap " + d, d::isLeapYear);
+            same("epoch day " + d, d::toEpochDay);
+            same("hash " + d, d::hashCode);
+            same("start " + d, d::atStartOfDay);
+            for (final int n : new int[] {0, 1, 2, 12, 13, 28, 29, 30, 31, 32, 60, 365, 366, 367}) {
+                same("wdom " + d + n, () -> d.withDayOfMonth(n));
+                same("wm " + d + n, () -> d.withMonth(n));
+                same("wdoy " + d + n, () -> d.withDayOfYear(n));
+                same("wy " + d + n, () -> d.withYear(2000 + n));
+            }
+            for (final ChronoUnit u : ChronoUnit.values()) {
+                for (final long n : AMOUNTS) {
+                    if (u.compareTo(ChronoUnit.CENTURIES) >= 0 && (n > 100 || n < -100)) {
+                        continue;
+                    }
+                    same("plus " + d + n + u, () -> d.plus(n, u));
+                    same("minus " + d + n + u, () -> d.minus(n, u));
+                }
+                for (final LocalDate e : DATES) {
+                    same("until " + d + e + u, () -> d.until(e, u));
+                    same("between " + d + e + u, () -> u.between(d, e));
+                }
+            }
+            for (final LocalDate e : DATES) {
+                same("period " + d + e, () -> d.until(e));
+                same("compare " + d + e, () -> d.compareTo(e));
+                same("before " + d + e, () -> d.isBefore(e));
+                same("after " + d + e, () -> d.isAfter(e));
+            }
+            for (final Period p : new Period[] {Period.of(1, 2, 3), Period.of(0, 13, 31), Period.of(-1, -1, -1),
+                Period.ofDays(400)}) {
+                same("plus " + d + p, () -> d.plus(p));
+                same("minus " + d + p, () -> d.minus(p));
+            }
+            same("plus duration " + d, () -> d.plus(Duration.ofDays(1)));
+        }
+        end(15000);
+    }
+
+    private static void datesWithTimesAreTheJdks() {
+        begin();
+        final List<LocalDateTime> all = dateTimes();
+        for (final LocalDateTime d : all) {
+            same("text " + d, () -> d);
+            same("time text " + d, d::toLocalTime);
+            same("hash " + d, d::hashCode);
+            same("dow " + d, d::getDayOfWeek);
+            same("month " + d, d::getMonth);
+            same("doy " + d, d::getDayOfYear);
+            same("epoch " + d, () -> d.toEpochSecond(ZoneOffset.ofHours(2)));
+            for (final long n : new long[] {-100000, -25, -1, 0, 1, 7, 13, 59, 100000, 86400000000001L}) {
+                same("md " + d + n, () -> d.minusDays(n % 100000));
+                same("mh " + d + n, () -> d.minusHours(n));
+                same("mm " + d + n, () -> d.minusMinutes(n));
+                same("ms " + d + n, () -> d.minusSeconds(n));
+                same("pn " + d + n, () -> d.plusNanos(n));
+                same("mn " + d + n, () -> d.minusNanos(n));
+                same("tpn " + d + n, () -> d.toLocalTime().plusNanos(n));
+                same("tms " + d + n, () -> d.toLocalTime().minusSeconds(n));
+                same("tmh " + d + n, () -> d.toLocalTime().minusHours(n));
+                final long few = n % 1000;
+                same("pw " + d + n, () -> d.plusWeeks(few));
+                same("mw " + d + n, () -> d.minusWeeks(few));
+                same("pmo " + d + n, () -> d.plusMonths(few));
+                same("mmo " + d + n, () -> d.minusMonths(few));
+                same("py " + d + n, () -> d.plusYears(few));
+                same("my " + d + n, () -> d.minusYears(few));
+            }
+            for (final int n : new int[] {0, 1, 23, 24, 59, 60, 999999999}) {
+                same("wh " + d + n, () -> d.withHour(n));
+                same("wmi " + d + n, () -> d.withMinute(n));
+                same("ws " + d + n, () -> d.withSecond(n));
+                same("wn " + d + n, () -> d.withNano(n));
+            }
+            for (final TemporalAmount a : new TemporalAmount[] {Period.of(1, 2, 3), Period.ofMonths(-13),
+                Duration.ofSeconds(86399, 999999999), Duration.ofMillis(-1), Duration.ofDays(400)}) {
+                same("plus " + d + a, () -> d.plus(a));
+                same("minus " + d + a, () -> d.minus(a));
+            }
+            for (final ChronoUnit u : ChronoUnit.values()) {
+                same("trunc " + d + u, () -> d.truncatedTo(u));
+                same("time trunc " + d + u, () -> d.toLocalTime().truncatedTo(u));
+                for (final long n : AMOUNTS) {
+                    if (u.compareTo(ChronoUnit.CENTURIES) >= 0 && (n > 100 || n < -100)) {
+                        continue;
+                    }
+                    // The JDK counts 256 half days to a day here, so beyond
+                    // that many its answer is not the sum. JavaAPI follows it,
+                    // but the grid stays inside the range that means anything.
+                    if (u == ChronoUnit.HALF_DAYS && (n >= 256 || n <= -256)) {
+                        continue;
+                    }
+                    same("plus " + d + n + u, () -> d.plus(n, u));
+                    same("minus " + d + n + u, () -> d.minus(n, u));
+                    same("time plus " + d + n + u, () -> d.toLocalTime().plus(n, u));
+                }
+                for (final LocalDateTime e : all) {
+                    same("until " + d + e + u, () -> d.until(e, u));
+                }
+            }
+            for (final LocalDateTime e : all) {
+                same("before " + d + e, () -> d.isBefore(e));
+                same("after " + d + e, () -> d.isAfter(e));
+                same("equal " + d + e, () -> d.isEqual(e));
+                same("compare " + d + e, () -> Integer.signum(d.compareTo(e)));
+                same("duration " + d + e, () -> Duration.between(d, e));
+                same("time " + d + e, () -> Duration.between(d.toLocalTime(), e.toLocalTime()));
+                same("time until " + d + e, () -> d.toLocalTime().until(e.toLocalTime(), ChronoUnit.MINUTES));
+                same("time before " + d + e, () -> d.toLocalTime().isBefore(e.toLocalTime()));
+            }
+        }
+        end(50000);
+    }
+
+    private static void momentsAndZonesAreTheJdks() {
+        begin();
+        final List<Instant> all = instants();
+        final ZoneId[] zones = new ZoneId[ZONES.length];
+        for (int z = 0; z < ZONES.length; z++) {
+            zones[z] = ZoneId.of(ZONES[z]);
+        }
+        for (final Instant i : all) {
+            same("text " + i, () -> i);
+            same("hash " + i, i::hashCode);
+            same("millis " + i, i::toEpochMilli);
+            for (final long n : new long[] {-86400000000001L, -1, 0, 1, 999999999, 1000000000, 123456789012L}) {
+                same("pn " + i + n, () -> i.plusNanos(n));
+                same("mn " + i + n, () -> i.minusNanos(n));
+                final Duration d = Duration.ofSeconds(n % 100000, n);
+                same("pd " + i + n, () -> i.plus(d));
+                same("md " + i + n, () -> i.minus(d));
+            }
+            same("period " + i, () -> i.plus(Period.ofDays(1)));
+            same("months " + i, () -> i.plus(Period.ofMonths(1)));
+            for (final ChronoUnit u : ChronoUnit.values()) {
+                same("trunc " + i + u, () -> i.truncatedTo(u));
+                for (final long n : AMOUNTS) {
+                    same("plus " + i + n + u, () -> i.plus(n, u));
+                    same("minus " + i + n + u, () -> i.minus(n, u));
+                }
+                if (u == ChronoUnit.MILLIS || u == ChronoUnit.MICROS) {
+                    // Java 21 changed these; see instantUntilMillisAndMicrosAsJava17.
+                    continue;
+                }
+                for (final Instant e : all) {
+                    same("until " + i + e + u, () -> i.until(e, u));
+                }
+            }
+            for (final Instant e : all) {
+                same("before " + i + e, () -> i.isBefore(e));
+                same("after " + i + e, () -> i.isAfter(e));
+                same("duration " + i + e, () -> Duration.between(i, e));
+            }
+            for (final ZoneId zone : zones) {
+                if (!regionRulesKnown(i, zone)) {
+                    continue;
+                }
+                same("atZone " + i + zone, () -> i.atZone(zone));
+                same("atOffset " + i + zone, () -> i.atOffset(ZoneOffset.ofHoursMinutes(5, 30)));
+                final ZonedDateTime z = i.atZone(zone);
+                same("date " + z, z::toLocalDate);
+                same("time " + z, z::toLocalTime);
+                same("epoch " + z, z::toEpochSecond);
+                same("offset " + z, z::getOffset);
+                same("odt " + z, z::toOffsetDateTime);
+                same("hash " + z, z::hashCode);
+                same("fields " + z,
+                        () -> z.getYear() + "-" + z.getMonthValue() + "-" + z.getDayOfMonth() + " " + z.getHour()
+                        + ":" + z.getMinute() + ":" + z.getSecond() + "." + z.getNano() + " " + z.getDayOfYear()
+                        + z.getMonth().name() + z.getDayOfWeek().name());
+                same("same instant " + z, () -> z.withZoneSameInstant(zones[2]));
+                if (regionRulesKnown(i, zones[1])) {
+                    same("local at " + z, () -> z.toLocalDateTime().atZone(zones[1]));
+                    same("same local " + z, () -> z.withZoneSameLocal(zones[1]));
+                }
+                for (final long n : new long[] {-400, -1, 0, 1, 25, 400}) {
+                    if (!regionRulesKnown(i.minusSeconds(Math.abs(n) * 86400L * 366L), zone)) {
+                        continue;
+                    }
+                    same("pd " + z + n, () -> z.plusDays(n));
+                    same("md " + z + n, () -> z.minusDays(n));
+                    same("pw " + z + n, () -> z.plusWeeks(n));
+                    same("mw " + z + n, () -> z.minusWeeks(n));
+                    same("pmo " + z + n, () -> z.plusMonths(n));
+                    same("mmo " + z + n, () -> z.minusMonths(n));
+                    same("py " + z + n, () -> z.plusYears(n));
+                    same("my " + z + n, () -> z.minusYears(n));
+                    same("ph " + z + n, () -> z.plusHours(n));
+                    same("mh " + z + n, () -> z.minusHours(n));
+                    same("pmi " + z + n, () -> z.plusMinutes(n));
+                    same("mmi " + z + n, () -> z.minusMinutes(n));
+                    same("ps " + z + n, () -> z.plusSeconds(n));
+                    same("ms " + z + n, () -> z.minusSeconds(n));
+                }
+                for (int other = 0; other < all.size(); other += 3) {
+                    if (!regionRulesKnown(all.get(other), zones[1])) {
+                        continue;
+                    }
+                    final ZonedDateTime e = all.get(other).atZone(zones[1]);
+                    same("before " + z + e, () -> z.isBefore(e));
+                    same("after " + z + e, () -> z.isAfter(e));
+                    same("equal " + z + e, () -> z.isEqual(e));
+                    same("compare " + z + e, () -> Integer.signum(z.compareTo(e)));
+                    same("duration " + z + e, () -> Duration.between(z, e));
+                    for (final ChronoUnit u : ChronoUnit.values()) {
+                        same("until " + z + e + u, () -> z.until(e, u));
+                    }
+                }
+            }
+        }
+        end(50000);
+    }
+
+    /// `Instant.until` in milliseconds and microseconds. Through Java 17 the
+    /// JDK counts milliseconds between the two moments each cut to its
+    /// millisecond, and microseconds from a count of nanoseconds that
+    /// overflows past 292 years; Java 21 truncates the exact difference and
+    /// counts microseconds without the overflow. JavaAPI answers as Java 8
+    /// through 17 do, so the HotSpot reference cannot be compared with; this
+    /// holds the grid to that definition, and to values taken from Java 8.
+    private static void instantUntilMillisAndMicrosAsJava17() {
+        final List<Instant> all = instants();
+        for (final Instant i : all) {
+            for (final Instant e : all) {
+                String millis = outcome(() -> Math.subtractExact(e.toEpochMilli(), i.toEpochMilli()));
+                String micros = outcome(() -> Math.addExact(Math.multiplyExact(
+                        Math.subtractExact(e.getEpochSecond(), i.getEpochSecond()), 1000000000L),
+                        (long) (e.getNano() - i.getNano())) / 1000);
+                Bulk.expectEquals(millis, outcome(() -> i.until(e, ChronoUnit.MILLIS)), "millis " + i + " " + e);
+                Bulk.expectEquals(micros, outcome(() -> i.until(e, ChronoUnit.MICROS)), "micros " + i + " " + e);
+            }
+        }
+        final Instant a = Instant.parse("1600-02-29T00:00:00.000000001Z");
+        final Instant b = Instant.parse("1600-02-29T12:34:56.789Z");
+        final Instant c = Instant.parse("1969-12-31T00:00:00Z");
+        Bulk.expectEquals("45296789", outcome(() -> a.until(b, ChronoUnit.MILLIS)), "Java 8 millis, short");
+        Bulk.expectEquals("11670912000000", outcome(() -> a.until(c, ChronoUnit.MILLIS)), "Java 8 millis, long");
+        Bulk.expectEquals("ArithmeticException", outcome(() -> a.until(c, ChronoUnit.MICROS)), "Java 8 micros");
+    }
+
+    /// The wall clock times a zone skips or passes twice, resolved as the JDK
+    /// resolves them.
+    private static void gapsAndOverlapsAreTheJdks() {
+        begin();
+        final ZoneId ny = ZoneId.of("America/New_York");
+        for (final LocalDateTime local : new LocalDateTime[] {LocalDateTime.of(2024, 3, 10, 2, 0),
+            LocalDateTime.of(2024, 3, 10, 2, 30), LocalDateTime.of(2024, 3, 10, 3, 0),
+            LocalDateTime.of(2024, 11, 3, 0, 59), LocalDateTime.of(2024, 11, 3, 1, 0),
+            LocalDateTime.of(2024, 11, 3, 1, 30), LocalDateTime.of(2024, 11, 3, 2, 0)}) {
+            same("of " + local, () -> ZonedDateTime.of(local, ny));
+            for (final int off : new int[] {-4, -5, 3}) {
+                same("ofLocal " + local + off, () -> ZonedDateTime.ofLocal(local, ny, ZoneOffset.ofHours(off)));
+            }
+            final ZonedDateTime z = ZonedDateTime.of(local, ny);
+            same("earlier " + z, z::withEarlierOffsetAtOverlap);
+            same("later " + z, z::withLaterOffsetAtOverlap);
+            same("later earlier " + z, () -> z.withLaterOffsetAtOverlap().withEarlierOffsetAtOverlap());
+            for (final long n : new long[] {-2, -1, 1, 2, 24}) {
+                same("ph " + z + n, () -> z.plusHours(n));
+                same("pd " + z + n, () -> z.plusDays(n));
+                same("pmi " + z + n, () -> z.plusMinutes(n * 30));
+            }
+        }
+    }
+
+    private static void durationsAreTheJdks() {
+        begin();
+        final Duration[] all = {Duration.ZERO, Duration.ofNanos(1), Duration.ofNanos(-1), Duration.ofMillis(1500),
+            Duration.ofMillis(-1500), Duration.ofSeconds(59), Duration.ofSeconds(3600), Duration.ofSeconds(86399, 5),
+            Duration.ofSeconds(-86401, 999999999), Duration.ofDays(400), Duration.ofDays(-400),
+            Duration.ofSeconds(90061, 123456789)};
+        same("zero", () -> Duration.ZERO);
+        for (final Duration d : all) {
+            same("text " + d, () -> d);
+            same("hash " + d, d::hashCode);
+            same("days " + d, d::toDays);
+            same("hours " + d, d::toHours);
+            same("minutes " + d, d::toMinutes);
+            same("millis " + d, d::toMillis);
+            same("seconds " + d, d::getSeconds);
+            same("nanos " + d, d::toNanos);
+            same("zero " + d, d::isZero);
+            same("negative " + d, d::isNegative);
+            same("negated " + d, d::negated);
+            same("abs " + d, d::abs);
+            same("hours part " + d, d::toHoursPart);
+            same("minutes part " + d, d::toMinutesPart);
+            same("seconds part " + d, d::toSecondsPart);
+            same("millis part " + d, d::toMillisPart);
+            for (final long n : new long[] {-100000, -7, -1, 0, 1, 3, 1000, 123456789}) {
+                same("pd " + d + n, () -> d.plusDays(n));
+                same("ph " + d + n, () -> d.plusHours(n));
+                same("pmi " + d + n, () -> d.plusMinutes(n));
+                same("ps " + d + n, () -> d.plusSeconds(n));
+                same("pms " + d + n, () -> d.plusMillis(n));
+                same("pn " + d + n, () -> d.plusNanos(n));
+                same("md " + d + n, () -> d.minusDays(n));
+                same("mh " + d + n, () -> d.minusHours(n));
+                same("mmi " + d + n, () -> d.minusMinutes(n));
+                same("ms " + d + n, () -> d.minusSeconds(n));
+                same("mms " + d + n, () -> d.minusMillis(n));
+                same("mn " + d + n, () -> d.minusNanos(n));
+                same("times " + d + n, () -> d.multipliedBy(n % 1000));
+                same("over " + d + n, () -> d.dividedBy(n));
+                same("ofNanos " + n, () -> Duration.ofNanos(n * 1000003));
+            }
+            for (final Duration e : all) {
+                same("plus " + d + e, () -> d.plus(e));
+                same("minus " + d + e, () -> d.minus(e));
+                same("compare " + d + e, () -> Integer.signum(d.compareTo(e)));
+            }
+        }
+        // Past what a long counts in nanoseconds, and at its very edges:
+        // the JDK throws rather than wrapping.
+        final Duration[] extremes = {Duration.ofDays(365L * 300), Duration.ofDays(-365L * 300),
+            Duration.ofNanos(Long.MAX_VALUE), Duration.ofNanos(Long.MIN_VALUE).plusNanos(-1),
+            Duration.ofNanos(Long.MAX_VALUE).plusNanos(1), Duration.ofSeconds(-1, 999999999), Duration.ofSeconds(-1, 1)};
+        // The most negative long: later releases than Java 8 borrow a second
+        // first and answer it, as JavaAPI does.
+        same("min nanos", () -> Duration.ofNanos(Long.MIN_VALUE).toNanos());
+        for (final Duration d : new Duration[] {Duration.ZERO, Duration.ofSeconds(-5, 1), Duration.ofSeconds(5),
+            Duration.ofSeconds(Long.MIN_VALUE), Duration.ofSeconds(Long.MIN_VALUE, 1),
+            Duration.ofSeconds(Long.MAX_VALUE, 999999999)}) {
+            same("negated " + d, d::negated);
+            for (final long n : new long[] {Long.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE / 60, -1}) {
+                same("pd " + d + n, () -> d.plusDays(n));
+                same("ph " + d + n, () -> d.plusHours(n));
+                same("pmi " + d + n, () -> d.plusMinutes(n));
+                same("ps " + d + n, () -> d.plusSeconds(n));
+                same("pms " + d + n, () -> d.plusMillis(n));
+                same("pn " + d + n, () -> d.plusNanos(n));
+                same("md " + d + n, () -> d.minusDays(n));
+                same("mh " + d + n, () -> d.minusHours(n));
+                same("mmi " + d + n, () -> d.minusMinutes(n));
+                same("ms " + d + n, () -> d.minusSeconds(n));
+                same("mms " + d + n, () -> d.minusMillis(n));
+                same("mn " + d + n, () -> d.minusNanos(n));
+            }
+        }
+        for (final Duration d : extremes) {
+            same("nanos " + d, d::toNanos);
+            for (final long n : new long[] {-3, 2, 1000000007L, -999999999999L, Long.MAX_VALUE, Long.MIN_VALUE}) {
+                same("times " + d + n, () -> d.multipliedBy(n));
+            }
+        }
+        for (final ChronoUnit u : ChronoUnit.values()) {
+            same("name " + u, u::toString);
+            same("length " + u, u::getDuration);
+            same("estimated " + u, u::isDurationEstimated);
+            same("date " + u, u::isDateBased);
+            same("time " + u, u::isTimeBased);
+            for (final long n : AMOUNTS) {
+                same("of " + n + u, () -> Duration.of(n, u));
+            }
+        }
+        same("units", () -> ChronoUnit.values().length);
+        for (final String text : new String[] {"PT0S", "PT1.5S", "P2DT3H4M", "PT-0.5S", "-PT6H3M", "PT25H", "nonsense",
+            "P1Y", "P106751991167301D", "PT2562047788015216H", "PT153722867280912931M",
+            "PT9223372036854775807S", "-PT9223372036854775808S", "P106751991167300DT24H"}) {
+            same("parse " + text, () -> Duration.parse(text));
+        }
+        end(1500);
+    }
+
+    private static void periodsAreTheJdks() {
+        begin();
+        final Period[] all = {Period.ZERO, Period.of(1, 2, 3), Period.of(0, 13, 31), Period.of(-1, -1, -1),
+            Period.ofDays(400), Period.ofWeeks(3), Period.of(2, -25, 0), Period.ofYears(Integer.MAX_VALUE)};
+        for (final Period p : all) {
+            same("text " + p, () -> p);
+            same("hash " + p, p::hashCode);
+            same("zero " + p, p::isZero);
+            same("negative " + p, p::isNegative);
+            same("months " + p, p::toTotalMonths);
+            same("normalized " + p, p::normalized);
+            same("negated " + p, p::negated);
+            for (final int n : new int[] {-1, 0, 2, Integer.MAX_VALUE}) {
+                same("times " + p + n, () -> p.multipliedBy(n));
+                same("py " + p + n, () -> p.plusYears(n));
+                same("pm " + p + n, () -> p.plusMonths(n));
+                same("pd " + p + n, () -> p.plusDays(n));
+            }
+            for (final Period q : all) {
+                same("plus " + p + q, () -> p.plus(q));
+                same("minus " + p + q, () -> p.minus(q));
+                same("equals " + p + q, () -> p.equals(q));
+            }
+        }
+        for (final LocalDate a : DATES) {
+            for (final LocalDate b : DATES) {
+                same("between " + a + b, () -> Period.between(a, b));
+            }
+        }
+        for (final String text : new String[] {"P1Y2M3D", "P2W", "p1y2w3d", "-P1Y-2M", "+P-1D", "P1W-3D", "PT1S",
+            "P", "P1Y1Y", "P1M1Y", "P1", "P2147483647W", "P99999999999D", "1Y", "", "P-0D", "P+5Y"}) {
+            same("parse " + text, () -> Period.parse(text));
+        }
+        for (final TemporalAmount a : new TemporalAmount[] {Period.ofDays(3), Period.ofMonths(1),
+            Duration.ofSeconds(5, 7)}) {
+            same("duration from " + a, () -> Duration.from(a));
+            same("period from " + a, () -> Period.from(a));
+        }
+    }
+
+    private static void offsetsZonesAndClocksAreTheJdks() {
+        begin();
+        same("min", () -> OffsetDateTime.MIN);
+        same("max", () -> OffsetDateTime.MAX);
+        same("instant min", () -> Instant.MIN);
+        same("instant max", () -> Instant.MAX);
+        for (final LocalDateTime local : dateTimes()) {
+            if (local.getYear() < 1901) {
+                continue;
+            }
+            final OffsetDateTime o = local.atOffset(ZoneOffset.ofHours(3));
+            final ZonedDateTime z = local.atZone(ZoneId.of("America/New_York"));
+            same("fixed " + z, z::withFixedOffsetZone);
+            for (final int n : new int[] {0, 1, 12, 28, 29, 31, 59, 60, 365, 366}) {
+                same("y " + o + n, () -> o.withYear(2000 + n));
+                same("mo " + o + n, () -> o.withMonth(n));
+                same("dom " + o + n, () -> o.withDayOfMonth(n));
+                same("doy " + o + n, () -> o.withDayOfYear(n));
+                same("h " + o + n, () -> o.withHour(n));
+                same("mi " + o + n, () -> o.withMinute(n));
+                same("s " + o + n, () -> o.withSecond(n));
+                same("n " + o + n, () -> o.withNano(n));
+                same("zoned doy " + z + n, () -> z.withDayOfYear(n));
+            }
+        }
+        final Instant at = Instant.ofEpochSecond(1700000000L, 5);
+        final Clock fixed = Clock.fixed(at, ZoneOffset.UTC);
+        final ZoneId kolkata = ZoneId.of("Asia/Kolkata");
+        same("clock zone", () -> fixed.withZone(kolkata).getZone());
+        same("clock zoned", () -> ZonedDateTime.now(fixed.withZone(kolkata)));
+        same("clock offset", () -> Clock.offset(fixed, Duration.ofHours(-5)).instant());
+        same("clock equals", () -> fixed.equals(Clock.fixed(at, ZoneOffset.UTC)) + " "
+                + fixed.withZone(ZoneOffset.UTC).equals(fixed) + " " + fixed.equals(fixed.withZone(kolkata)));
+    }
+
+    /// Patterns over a date alone, a time alone, a date with a time, and a
+    /// zoned date and time; and what a pattern reads back.
+    private static void patternsFormatAndParseAsTheJdks() {
+        begin();
+        final String[] patterns = {"HH:mm:ss", "H:m", "hh:mm a", "dd.MM.yyyy", "yyyy-MM-dd", "d/M/yy",
+            "yyyy-MM-dd HH:mm", "'at' HH 'h'", "EEE d", "HH:mm:ss.SSS", "EEEE, MMMM d, uuuu", "MMM", "LLLLL",
+            "G yyyy", "GGGG", "D", "DDD", "QQQ QQQQ q", "K k h", "n N A", "S SSSSSS", "''yy''", "yyyy[ HH:mm]",
+            "yyyyMMdd", "HHmmss", "XXX", "xx", "Z", "ZZZZZ", "O", "OOOO", "VV", "yyyy-MM-dd'T'HH:mm:ssXXX"};
+        final LocalTime[] times = {LocalTime.of(0, 0), LocalTime.of(1, 2, 3), LocalTime.of(13, 59, 58, 123000000),
+            LocalTime.of(23, 59, 59), LocalTime.of(12, 0, 0, 1)};
+        final LocalDate[] dates = {LocalDate.of(1970, 1, 1), LocalDate.of(1999, 2, 21), LocalDate.of(2024, 2, 29),
+            LocalDate.of(2031, 12, 31), LocalDate.of(-5, 6, 7), LocalDate.of(12345, 1, 2)};
+        final ZoneId[] zones = {ZoneOffset.UTC, ZoneOffset.ofHoursMinutes(5, 30), ZoneOffset.ofHours(-8),
+            ZoneId.of("America/New_York")};
+        for (final String pattern : patterns) {
+            final DateTimeFormatter f = DateTimeFormatter.ofPattern(pattern, Locale.US);
+            for (final LocalTime t : times) {
+                same("time " + pattern + t, () -> t.format(f));
+                same("time of " + pattern + t, () -> f.format(t));
+            }
+            for (final LocalDate d : dates) {
+                same("date " + pattern + d, () -> d.format(f));
+                same("both " + pattern + d, () -> d.atTime(4, 5, 6).format(f));
+                for (final ZoneId z : zones) {
+                    final ZonedDateTime zd = d.atTime(4, 5, 6).atZone(z);
+                    if (!regionRulesKnown(zd.toInstant(), z)) {
+                        continue;
+                    }
+                    same("zoned " + pattern + zd, () -> zd.format(f));
+                    same("offset " + pattern + zd, () -> zd.toOffsetDateTime().format(f));
+                }
+            }
+            for (final LocalDate d : dates) {
+                final String text = d.atTime(4, 5, 6).atZone(ZoneOffset.ofHours(2)).format(f);
+                same("read date " + pattern + text, () -> LocalDate.parse(text, f));
+                same("read time " + pattern + text, () -> LocalTime.parse(text, f));
+                same("read both " + pattern + text, () -> LocalDateTime.parse(text, f));
+            }
+        }
+        final DateTimeFormatter day = DateTimeFormatter.ofPattern("dd.MM.yyyy");
+        final DateTimeFormatter clock = DateTimeFormatter.ofPattern("HH:mm:ss");
+        for (final String text : new String[] {"21.02.1999", "29.02.2024", "30.02.2024", "31.04.2023", "32.01.2024",
+            "31.12.2031", "1.1.2024", "nonsense", "12:13:14", "24:00:00", "21.02.1999 ", ""}) {
+            same("parse date " + text, () -> LocalDate.parse(text, day));
+            same("parse time " + text, () -> LocalTime.parse(text, clock));
+        }
+        for (final String bad : new String[] {"yyyy-MM-dd ]", "'open", "{y}", "ddd", "aa", "V", "OO", "SSSSSSSSSS",
+            "b"}) {
+            same("refused " + bad, () -> DateTimeFormatter.ofPattern(bad) == null ? "null" : "made");
+        }
+        end(1500);
+    }
+
+    private static void isoFormatsAreTheJdks() {
+        begin();
+        final List<ZonedDateTime> values = new ArrayList<ZonedDateTime>();
+        for (final LocalDateTime local : dateTimes()) {
+            values.add(local.atZone(ZoneOffset.UTC));
+            values.add(local.atZone(ZoneOffset.ofHoursMinutes(-3, -30)));
+            values.add(local.atZone(ZoneId.of("UTC")));
+            if (local.getYear() >= 1901) {
+                values.add(local.atZone(ZoneId.of("Asia/Kolkata")));
+            }
+        }
+        final DateTimeFormatter[] formats = {DateTimeFormatter.ISO_LOCAL_DATE, DateTimeFormatter.ISO_LOCAL_TIME,
+            DateTimeFormatter.ISO_LOCAL_DATE_TIME, DateTimeFormatter.ISO_OFFSET_DATE_TIME,
+            DateTimeFormatter.ISO_ZONED_DATE_TIME, DateTimeFormatter.ISO_INSTANT};
+        for (final ZonedDateTime z : values) {
+            same("zoned text " + z, () -> z);
+            same("offset text " + z, z::toOffsetDateTime);
+            same("instant text " + z, z::toInstant);
+            for (int f = 0; f < formats.length; f++) {
+                final DateTimeFormatter j = formats[f];
+                same("zoned " + f + z, () -> j.format(z));
+                same("offset " + f + z, () -> j.format(z.toOffsetDateTime()));
+                same("local " + f + z, () -> j.format(z.toLocalDateTime()));
+                same("date " + f + z, () -> j.format(z.toLocalDate()));
+                same("time " + f + z, () -> j.format(z.toLocalTime()));
+                same("instant " + f + z, () -> j.format(z.toInstant()));
+                if (regionRulesKnown(z.toInstant(), ZoneId.of("Asia/Kolkata"))) {
+                    same("in zone " + f + z, () -> j.withZone(ZoneId.of("Asia/Kolkata")).format(z.toInstant()));
+                }
+                final String text = outcome(() -> j.format(z));
+                same("reread zoned " + f + text, () -> ZonedDateTime.parse(text, j));
+                same("reread offset " + f + text, () -> OffsetDateTime.parse(text, j));
+                same("reread local " + f + text, () -> LocalDateTime.parse(text, j));
+                same("reread date " + f + text, () -> LocalDate.parse(text, j));
+                same("reread time " + f + text, () -> LocalTime.parse(text, j));
+                same("reread with zone " + f + text,
+                        () -> ZonedDateTime.parse(text, j.withZone(ZoneId.of("America/New_York"))));
+            }
+        }
+        for (final String text : new String[] {"2024-02-29", "2023-02-29", "+12345-01-02", "12345-01-02", "-0005-06-07",
+            "2024-1-01", "12:30", "12:30:45.5", "24:00", "2024-02-29T12:30", "2024-02-29t12:30:00Z",
+            "2024-02-29T12:30:00+05:30", "2024-02-29T12:30:00-03:30[America/New_York]", "2024-02-29T12:30:00Z[UTC]",
+            "2024-02-29T23:59:60Z", "2024-02-29T24:00:00Z", "2024-02-29T12:30:00.123456Z"}) {
+            same("date " + text, () -> LocalDate.parse(text));
+            same("time " + text, () -> LocalTime.parse(text));
+            same("local " + text, () -> LocalDateTime.parse(text));
+            same("offset " + text, () -> OffsetDateTime.parse(text));
+            same("zoned " + text, () -> ZonedDateTime.parse(text));
+            same("instant " + text, () -> Instant.parse(text));
+        }
+        end(5000);
+    }
+
+    private static void zonesAndOffsetsAreTheJdks() {
+        begin();
+        for (final String id : new String[] {"Z", "UTC", "GMT", "UT", "UTC+01:00", "GMT-5", "UT+0", "+05:30",
+            "-08", "+1", "+0530", "+05:30:15", "+18:00", "+18:01", "-19", "America/New_York", "Bad Zone", "",
+            "UTC+", "GMT0"}) {
+            same("zone " + id, () -> ZoneId.of(id));
+            same("zone class " + id, () -> ZoneId.of(id) instanceof ZoneOffset);
+            same("normalized " + id, () -> ZoneId.of(id).normalized());
+            same("offset " + id, () -> ZoneOffset.of(id));
+            same("utc equals " + id, () -> ZoneOffset.UTC.equals(ZoneId.of(id)));
+        }
+        for (final int seconds : new int[] {0, 1, -1, 3600, -3600, 19800, 64800, 64801, -64800, 45296}) {
+            same("total " + seconds, () -> ZoneOffset.ofTotalSeconds(seconds));
+        }
+        for (final int[] hms : new int[][] {{1, 30, 0}, {-1, -30, 0}, {1, -30, 0}, {0, 30, -1}, {0, -30, -15},
+            {18, 0, 0}, {18, 1, 0}, {5, 60, 0}}) {
+            same("hms " + hms[0] + hms[1] + hms[2], () -> ZoneOffset.ofHoursMinutesSeconds(hms[0], hms[1], hms[2]));
+        }
+    }
+
+    private static void daysAndMonthsAreTheJdks() {
+        begin();
+        for (final DayOfWeek day : DayOfWeek.values()) {
+            same("value " + day, day::getValue);
+            same("text " + day, day::toString);
+            for (final long n : new long[] {-15, -7, -1, 0, 1, 6, 7, 100, Long.MIN_VALUE, Long.MAX_VALUE}) {
+                same("plus " + day + n, () -> day.plus(n));
+                same("minus " + day + n, () -> day.minus(n));
+            }
+        }
+        for (final Month month : Month.values()) {
+            same("value " + month, month::getValue);
+            same("min " + month, month::minLength);
+            same("max " + month, month::maxLength);
+            same("quarter " + month, month::firstMonthOfQuarter);
+            for (final boolean leap : new boolean[] {false, true}) {
+                same("length " + month, () -> month.length(leap));
+                same("first " + month, () -> month.firstDayOfYear(leap));
+            }
+            for (final long n : new long[] {-25, -12, -1, 0, 1, 11, 12, 100, Long.MIN_VALUE, Long.MAX_VALUE}) {
+                same("plus " + month + n, () -> month.plus(n));
+                same("minus " + month + n, () -> month.minus(n));
+            }
+        }
+        for (final int n : new int[] {-1, 0, 1, 7, 8, 12, 13}) {
+            same("day of " + n, () -> DayOfWeek.of(n));
+            same("month of " + n, () -> Month.of(n));
+            same("date of " + n, () -> LocalDate.of(2024, Month.of(n), 5));
+        }
+        end(500);
+    }
+
+    /// Amounts too large for the seconds they stand for: the JDK refuses
+    /// every one of them rather than wrapping around.
+    private static void amountsThatOverflowAreRefusedAsTheJdkRefusesThem() {
+        begin();
+        final long[] huge = {4611686018427387904L, -4611686018427387904L, Long.MAX_VALUE, Long.MIN_VALUE,
+            Long.MAX_VALUE / 60 + 1, Long.MAX_VALUE / 3600 + 1, 153722867280912930L, 2562047788015215L,
+            31556889864403199L, -31557014167219200L, 1000000L * 365 * 24 * 3600};
+        for (final long n : huge) {
+            for (final ChronoUnit u : ChronoUnit.values()) {
+                same("of " + n + u, () -> Duration.of(n, u));
+            }
+            for (final String id : ZONES) {
+                final ZonedDateTime z = Instant.ofEpochSecond(1700000000L, 5).atZone(ZoneId.of(id));
+                same("pmi " + z + n, () -> z.plusMinutes(n));
+                same("mmi " + z + n, () -> z.minusMinutes(n));
+                same("ph " + z + n, () -> z.plusHours(n));
+                same("mh " + z + n, () -> z.minusHours(n));
+                same("ps " + z + n, () -> z.plusSeconds(n));
+                same("ms " + z + n, () -> z.minusSeconds(n));
+            }
+            final Instant i = Instant.ofEpochSecond(1700000000L, 5);
+            same("instant ps " + n, () -> i.plusSeconds(n));
+            same("instant pms " + n, () -> i.plusMillis(n));
+            same("instant of " + n, () -> Instant.ofEpochSecond(n));
+            same("instant ofMilli " + n, () -> Instant.ofEpochMilli(n));
+            same("epoch day " + n, () -> LocalDate.ofEpochDay(n));
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/TimeEdgeApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeEdgeApp.java
similarity index 59%
rename from vm/tests/src/test/resources/com/codename1/tools/translator/TimeEdgeApp.java
rename to vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeEdgeApp.java
index 4870172b425..f796c37f005 100644
--- a/vm/tests/src/test/resources/com/codename1/tools/translator/TimeEdgeApp.java
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeEdgeApp.java
@@ -20,16 +20,22 @@
  * Please contact Codename One through http://www.codenameone.com/ if you
  * need additional information or have any questions.
  */
+import java.time.DayOfWeek;
 import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.time.Month;
+import java.time.OffsetDateTime;
 import java.time.Period;
 import java.time.ZoneId;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
+import java.time.temporal.ChronoUnit;
+import java.util.Date;
 
 public class TimeEdgeApp {
     private static String two(int value) {
@@ -97,10 +103,65 @@ private static String calculate() {
         result.append(Duration.ofSeconds(-60, 1)).append('|');
         result.append(Duration.parse("P1DT2H3M4.5S").toMillis()).append('|');
         result.append(Duration.parse("-P1DT1H1M").toMillis());
+        result.append('|').append(newerApi());
         return result.toString();
     }
 
-    public static void main(String[] args) {
+    /// The enums, units, formatter and java.util.Date members, through the
+    /// translator: what a device runs, against what the JDK answers.
+    private static String newerApi() {
+        StringBuilder out = new StringBuilder();
+        out.append(DayOfWeek.MONDAY.plus(-15)).append(',').append(Month.JANUARY.minus(25)).append(',')
+                .append(Month.FEBRUARY.length(true)).append(',').append(Month.of(11).firstMonthOfQuarter())
+                .append(',').append(LocalDate.of(2024, 2, 29).getDayOfWeek()).append('|');
+        LocalDateTime a = LocalDateTime.of(2020, 1, 31, 23, 59, 59, 999999999);
+        LocalDateTime b = LocalDateTime.of(2024, 2, 29, 0, 0);
+        for (ChronoUnit u : ChronoUnit.values()) {
+            if (u == ChronoUnit.FOREVER) {
+                continue;
+            }
+            out.append(u).append('=').append(a.until(b, u)).append(',');
+        }
+        out.append(a.truncatedTo(ChronoUnit.HOURS)).append(',').append(b.plus(3, ChronoUnit.DECADES)).append('|');
+        ZoneId ny = ZoneId.of("America/New_York");
+        out.append(ZonedDateTime.of(LocalDateTime.of(2024, 3, 10, 2, 30), ny)).append(',')
+                .append(ZonedDateTime.of(LocalDateTime.of(2024, 11, 3, 1, 30), ny).withLaterOffsetAtOverlap())
+                .append(',').append(ZonedDateTime.of(LocalDateTime.of(2024, 3, 9, 2, 30), ny).plusDays(1))
+                .append(',').append(ZonedDateTime.of(LocalDateTime.of(2024, 3, 9, 2, 30), ny).plusHours(24))
+                .append('|');
+        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("EEEE, MMMM d, uuuu 'at' hh:mm:ss.SSS a");
+        out.append(LocalDateTime.of(2031, 12, 31, 13, 5, 7, 89000000).format(pattern)).append(',')
+                .append(LocalDate.parse("29.02.2024", DateTimeFormatter.ofPattern("dd.MM.yyyy"))).append(',')
+                .append(LocalTime.parse("24:00:00", DateTimeFormatter.ofPattern("HH:mm:ss"))).append(',')
+                .append(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(
+                        OffsetDateTime.of(2024, 2, 29, 12, 30, 0, 120000000, ZoneOffset.ofHoursMinutes(-3, -30))))
+                .append(',').append(ZonedDateTime.parse("2024-06-01T12:00:00+02:00[Europe/Berlin]")).append(',')
+                .append(Instant.ofEpochSecond(31556889864403199L, 999999999)).append(',')
+                .append(Period.between(LocalDate.of(2020, 1, 31), LocalDate.of(2024, 2, 29))).append(',');
+        try {
+            LocalDate.parse("31.04.2023", DateTimeFormatter.ofPattern("dd.MM.yyyy"));
+            out.append("parsed");
+        } catch (DateTimeParseException ex) {
+            out.append("refused:").append(ex.getErrorIndex());
+        }
+        out.append('|');
+        // Noon UTC in mid month: the same date in every zone the host may
+        // have, so the default zone cannot change the answer.
+        Date date = Date.from(Instant.parse("2024-02-14T12:00:00Z"));
+        Date later = new Date(date.getTime() + 1);
+        out.append(date.toInstant()).append(',').append(date.getYear()).append(',').append(date.getMonth())
+                .append(',').append(date.getDate()).append(',').append(date.getDay()).append(',')
+                .append(later.after(date)).append(',').append(later.before(date)).append(',');
+        try {
+            Date.from(Instant.MAX);
+            out.append("made");
+        } catch (IllegalArgumentException ex) {
+            out.append("refused");
+        }
+        return out.toString();
+    }
+
+    public static void fixtureMain(String[] args) {
         System.out.println("RESULT=" + calculate());
     }
 }
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeEdgeChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeEdgeChecks.java
new file mode 100644
index 00000000000..5cbdfbd03f9
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/TimeEdgeChecks.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// TimeEdgeApp, formerly translated and built on its own by TimeApiIntegrationTest, run as
+/// one check of the bulk program. Its `fixtureMain` (the translator allows one
+/// `main` per program) prints what its `main` always printed.
+public final class TimeEdgeChecks {
+    private TimeEdgeChecks() {
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("TimeEdgeApp", () -> TimeEdgeApp.fixtureMain(new String[0]));
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/URLChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/URLChecks.java
new file mode 100644
index 00000000000..f756dd1adae
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/URLChecks.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+/// java.net.URL: the same text has to come apart into the same pieces and go
+/// back together into the same text.
+///
+/// The JDK's `equals` and `hashCode` are left out of the comparison on
+/// purpose. They resolve the host name, so two names of one address are
+/// equal there; JavaAPI compares the names, as `java.net.URI` does. That,
+/// and the `cn1res:` protocol, are Codename One's own and run on ParparVM
+/// only.
+public final class URLChecks {
+    /// Java 8 accepted a host name with a space in it; later JDKs refuse it.
+    private static final String SPACED_HOST = "http://exa mple.com/";
+
+    private static final String[] SPECS = {
+        "http://example.com",
+        "http://example.com/",
+        "http://example.com/a/b/c.html",
+        "http://example.com:8080/a?x=1&y=2#frag",
+        "https://user:secret@example.com:8443/path/to?q#r",
+        "https://user@example.com/",
+        "HTTP://Example.COM/Path",
+        "http://example.com?query",
+        "http://example.com#ref",
+        "http://example.com/?",
+        "http://example.com/#",
+        "http://example.com/a?b#c?d#e",
+        "http://example.com/a%20b/c+d?e=%2F",
+        "http://example.com:80/",
+        "http://example.com:/",
+        "http://example.com:-1/",
+        "http://example.com:abc/",
+        "http://example.com:99999/",
+        "http://[::1]/",
+        "http://[::1]:8080/x",
+        "http://[2001:db8::1]/",
+        "http://[::1/",
+        "http://192.168.0.1:8080/",
+        "http:///path",
+        "http://",
+        "http:",
+        "http:/",
+        "http:relative/path",
+        "http:/absolute/path",
+        "http://example.com/a/../b/./c",
+        "http://example.com/..",
+        "http://example.com/a/b/../../../c",
+        "file:/tmp/a.txt",
+        "file:///tmp/a.txt",
+        "file://host/share/a.txt",
+        "file:a.txt",
+        "file:/C:/Users/x",
+        "file:///",
+        "file:",
+        "file:/a b",
+        "ftp://ftp.example.com/pub/file.zip",
+        "ftp://anonymous:pw@ftp.example.com:2121/pub",
+        "jar:file:/a/b.jar!/c/d.class",
+        "jar:http://example.com/a.jar!/",
+        "  http://example.com/trimmed  ",
+        "url:http://example.com/prefixed",
+        "URL:http://example.com/prefixed",
+        "",
+        "no-protocol",
+        "/just/a/path",
+        "://missing",
+        "1http://example.com",
+        "ht tp://example.com",
+        "unknown://example.com/",
+        "mailto:someone@example.com",
+        "http://example.com/a;params?q",
+        "http://example.com/a#",
+        SPACED_HOST,
+        "http://example.com/" + (char) 0xE9,
+        "http://@example.com/",
+        "http://user:@example.com/",
+        "http://:pw@example.com/",
+        "http://a@b@example.com/",
+        "http://example.com/a?b?c",
+        "http://example.com//double//slash",
+        "http:///",
+        "https://example.com:443",
+        "http://example.com:0/",
+        "http://example.com:+81/",
+        "http://example.com:-2/",
+        "http://example.com:-/",
+        "http://example.com:99999999999/",
+        "mailto:",
+        "mailto:  ",
+        "mailto:a@b.c?subject=hi#frag",
+        "jar:file:/a/b.jar",
+        "jar:nosuch:/a/b.jar!/c",
+        "jar:file:/a/b.jar!/c/../d?q#r",
+        "jar:file:/a/b.jar!/x!/y",
+    };
+
+    private static final String[] CONTEXTS = {
+        "http://example.com/a/b/c?q=1#r",
+        "http://example.com",
+        "http://example.com/",
+        "http://user@example.com:8080/dir/",
+        "file:/tmp/dir/file.txt",
+        "jar:file:/a/b.jar!/c/d.class",
+        "https://example.com/a/b/",
+        "jar:file:/a/b.jar!/",
+        "mailto:x@example.com",
+    };
+
+    private static final String[] RELATIVE = {
+        "d", "d/e", "/d", "../d", "../../d", "../../../d", "./d", ".", "..", "", "?x=1", "#top", "d?x#y",
+        "//other.com/p", "http://absolute.com/x", "http:same/scheme", "http:/same/root", "https:other", "g;x",
+        "d/./e/../f", "/..", "/./x", " spaced ", "file:/elsewhere", "ftp://f.example.com/x", "?", "#",
+        "d/", "../", "./", "/", "a b", "x:y",
+        "jar:file:/z.jar!/q", "#only", "d#r", "mailto:a@b",
+    };
+
+    private URLChecks() {
+    }
+
+    private static String describe(URL u) {
+        return "protocol=" + u.getProtocol() + " host=" + u.getHost() + " port=" + u.getPort() + " default="
+                + u.getDefaultPort() + " authority=" + u.getAuthority() + " userInfo=" + u.getUserInfo()
+                + " path=" + u.getPath() + " query=" + u.getQuery() + " ref=" + u.getRef() + " file="
+                + u.getFile() + " external=" + u.toExternalForm() + " string=" + u;
+    }
+
+    @SuppressWarnings("deprecation")
+    private static String parse(String spec) {
+        try {
+            return describe(new URL(spec));
+        } catch (MalformedURLException e) {
+            return "MalformedURLException";
+        }
+    }
+
+    private static String read(InputStream in) throws IOException {
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            int b;
+            while ((b = in.read()) >= 0) {
+                out.write(b);
+            }
+            return new String(out.toByteArray(), "UTF-8");
+        } finally {
+            in.close();
+        }
+    }
+
+    /// Runs the group.
+    @SuppressWarnings("deprecation")
+    public static void run() {
+        Bulk.check("URL.parsesLikeTheJdk", () -> {
+            for (String spec : SPECS) {
+                if (!SPACED_HOST.equals(spec)) {
+                    Bulk.p("[" + Bulk.esc(spec) + "]", parse(spec));
+                }
+            }
+        });
+        // The one spec on which Java 8, which the original comparison ran
+        // against, and later JDKs differ, held to Java 8's answer.
+        Bulk.cn1Only("URL.parsesLikeTheJdkOnJava8", () -> {
+            Bulk.expectEquals("protocol=http host=exa mple.com port=-1 default=80 authority=exa mple.com"
+                    + " userInfo=null path=/ query=null ref=null file=/ external=http://exa mple.com/"
+                    + " string=http://exa mple.com/", parse(SPACED_HOST), SPACED_HOST);
+        });
+        Bulk.check("URL.resolvesRelativeReferencesLikeTheJdk", () -> {
+            for (String context : CONTEXTS) {
+                URL base = new URL(context);
+                for (String relative : RELATIVE) {
+                    String actual;
+                    try {
+                        actual = describe(new URL(base, relative));
+                    } catch (MalformedURLException e) {
+                        actual = "MalformedURLException";
+                    }
+                    Bulk.p("[" + context + "] + [" + relative + "]", actual);
+                }
+            }
+            // No context is no context.
+            Bulk.p("nullContext", describe(new URL(null, "http://example.com/x")));
+        });
+        Bulk.check("URL.buildsFromPartsLikeTheJdk", () -> {
+            Object[][] parts = {
+                {"http", "example.com", Integer.valueOf(-1), "/a?b#c"},
+                {"http", "example.com", Integer.valueOf(8080), "/a"},
+                {"https", "example.com", Integer.valueOf(443), ""},
+                {"file", "", Integer.valueOf(-1), "/tmp/x"},
+                {"file", null, Integer.valueOf(-1), "/tmp/x"},
+                {"http", "::1", Integer.valueOf(80), "/v6"},
+                {"http", "[::1]", Integer.valueOf(80), "/v6"},
+                {"HTTP", "Example.com", Integer.valueOf(-1), "no-slash"},
+                {"ftp", "example.com", Integer.valueOf(21), "/a#ref"},
+                {"http", "example.com", Integer.valueOf(-2), "/bad"},
+                {"nosuch", "example.com", Integer.valueOf(-1), "/bad"},
+            };
+            for (Object[] p : parts) {
+                String protocol = (String) p[0];
+                String host = (String) p[1];
+                int port = ((Integer) p[2]).intValue();
+                String file = (String) p[3];
+                String actual;
+                try {
+                    actual = describe(new URL(protocol, host, port, file));
+                } catch (MalformedURLException e) {
+                    actual = "MalformedURLException";
+                }
+                Bulk.p(protocol + " " + host + " " + port + " " + file, actual);
+            }
+            Bulk.p("threeParts", describe(new URL("http", "example.com", "/three")));
+        });
+        Bulk.check("URL.convertsToUriLikeTheJdk", () -> {
+            for (String spec : new String[] {"http://example.com/a?b#c", "file:/tmp/x", "https://u@h:1/p"}) {
+                Bulk.p(spec, new URL(spec).toURI().toString());
+            }
+            Bulk.pThrown("spaced", URISyntaxException.class, () -> new URL("http://example.com/a b").toURI());
+        });
+        Bulk.cn1Only("URL.comparesByText", () -> {
+            URL a = new URL("http://example.com/a?b#c");
+            Bulk.expect(a.equals(new URL("http://example.com/a?b#c")), "equal text");
+            Bulk.expect(a.hashCode() == new URL("http://example.com/a?b#c").hashCode(), "equal hash");
+            // The default port is the port, and the host is not case sensitive.
+            Bulk.expect(new URL("http://example.com/").equals(new URL("http://EXAMPLE.com:80/")), "default port");
+            Bulk.expect(new URL("http://example.com/").hashCode() == new URL("http://EXAMPLE.com:80/").hashCode(),
+                    "default port hash");
+            Bulk.expect(!a.equals(new URL("http://example.com/a?b#d")), "another ref");
+            Bulk.expect(!a.equals(new URL("https://example.com/a?b#c")), "another protocol");
+            Bulk.expect(!a.equals(new URL("http://example.com/A?b#c")), "another path");
+            Bulk.expect(!a.equals("http://example.com/a?b#c"), "a string");
+            // sameFile ignores the fragment, as in the JDK.
+            Bulk.expect(a.sameFile(new URL("http://example.com/a?b#other")), "sameFile");
+            Bulk.expect(!a.sameFile(new URL("http://example.com/a?x#c")), "not sameFile");
+        });
+        Bulk.cn1Only("URL.readsApplicationResourcesThroughCn1res", () -> {
+            // The form the build writes in place of Class.getResource(String).
+            URL url = new URL("cn1res:/com/codename1/bulk/registered/plain.txt");
+            Bulk.expectEquals("cn1res", url.getProtocol(), "protocol");
+            Bulk.expectEquals("/com/codename1/bulk/registered/plain.txt", url.getPath(), "path");
+            Bulk.expectEquals("", url.getHost(), "host");
+            Bulk.expectEquals(Integer.valueOf(-1), Integer.valueOf(url.getPort()), "port");
+            Bulk.expectEquals("cn1res:/com/codename1/bulk/registered/plain.txt", url.toExternalForm(),
+                    "external");
+            Bulk.expectEquals("first line\nsecond line\n", read(url.openStream()), "content");
+
+            // A sibling resource, the way code resolves one file next to another.
+            URL sibling = new URL(url, "odd-name.txt");
+            Bulk.expectEquals("cn1res:/com/codename1/bulk/registered/odd-name.txt", sibling.toExternalForm(),
+                    "sibling");
+            Bulk.expectEquals("greeting=Registered\n", read(sibling.openStream()), "sibling content");
+
+            // Escapes are decoded on the way to the resource name.
+            Bulk.expectEquals("first line\nsecond line\n",
+                    read(new URL("cn1res:/com/codename1/bulk/registered/plain%2Etxt").openStream()), "escaped");
+            try {
+                new URL("cn1res:/com/codename1/bulk/registered/absent.txt").openStream();
+                Bulk.expect(false, "no such resource");
+            } catch (FileNotFoundException e) {
+                Bulk.expect(e.getMessage().indexOf("absent.txt") >= 0, "message names the resource");
+            }
+        });
+        Bulk.cn1Only("URL.refusesProtocolsItCannotRead", () -> {
+            try {
+                new URL("ftp://example.com/file").openStream();
+                Bulk.expect(false, "ftp is parsed, not read");
+            } catch (IOException e) {
+                Bulk.expect(e.getMessage().indexOf("ftp") >= 0, "message names ftp: " + e.getMessage());
+            }
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/UtilClassesChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/UtilClassesChecks.java
new file mode 100644
index 00000000000..168c445ed63
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/UtilClassesChecks.java
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.UncheckedIOException;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EventObject;
+import java.util.HashSet;
+import java.util.HexFormat;
+import java.util.List;
+import java.util.Properties;
+import java.util.Random;
+import java.util.Set;
+import java.util.StringJoiner;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.UUID;
+
+/// StringJoiner, UUID, Properties, HexFormat, EventObject and the exceptions
+/// JavaAPI provides.
+public final class UtilClassesChecks {
+    // A backslash, kept out of string literals next to a 'u': javac reads
+    // that pair as an escape wherever it appears.
+    private static final String BS = String.valueOf((char) 92);
+
+    private static final String TEXT = "# a comment\n! another\n\nplain=value\n  spaced   :   after colon  \n"
+            + "nosep value with spaces\nempty=\nlonely\ncontinued = one, " + BS + "\n     two, " + BS + "\r\n  three\n"
+            + "tab=a" + BS + "tb" + BS + "nc\nuni=" + BS + "u00e9t" + BS + "u00E9\n"
+            + "key" + BS + " with" + BS + "=odd" + BS + ":chars = v\nlatin=caf" + (char) 0xe9 + "\nplain=again\n"
+            + "back=one" + BS + BS + "two\nunknown=" + BS + "q" + BS + "z" + BS + "b\nformfeed" + (char) 12 + "value\n"
+            + "trailing=" + BS;
+
+    private UtilClassesChecks() {
+    }
+
+    private static TreeMap<String, String> table(Properties p) {
+        TreeMap<String, String> out = new TreeMap<String, String>();
+        for (String name : p.stringPropertyNames()) {
+            out.put(name, p.getProperty(name));
+        }
+        return out;
+    }
+
+    /// What `store` wrote, comparable between the two runs: the comment
+    /// lines in order, without the date line (any comment line other than the
+    /// ones of `comments`), then the entries sorted, since they come in the
+    /// table's hash order. The number of date lines is printed separately.
+    private static String stored(String text, String[] comments) {
+        List<String> commentLines = new ArrayList<String>();
+        List<String> entries = new ArrayList<String>();
+        int dates = 0;
+        int start = 0;
+        while (start < text.length()) {
+            int end = text.indexOf('\n', start);
+            if (end < 0) {
+                end = text.length();
+            }
+            String line = text.substring(start, end);
+            start = end + 1;
+            if (line.startsWith("#")) {
+                boolean known = false;
+                for (String c : comments) {
+                    known |= line.startsWith(c);
+                }
+                if (known) {
+                    commentLines.add(line);
+                } else {
+                    dates++;
+                }
+            } else {
+                entries.add(line);
+            }
+        }
+        Collections.sort(entries);
+        return "dates=" + dates + " comments=" + commentLines + " entries=" + entries;
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("UtilClasses.stringJoinerMatchesTheJdk", () -> {
+            String[][] parts = {{}, {"a"}, {"a", "b"}, {"", ""}, {"x", "", "z"}, {"null", "1"}};
+            for (int p = 0; p < parts.length; p++) {
+                for (int variant = 0; variant < 4; variant++) {
+                    String key = "p" + p + "v" + variant;
+                    StringJoiner mine = variant < 2 ? new StringJoiner(", ") : new StringJoiner("-", "[", "]");
+                    if (variant % 2 == 1) {
+                        mine.setEmptyValue("EMPTY");
+                    }
+                    StringBuilder seen = new StringBuilder();
+                    seen.append(mine).append('/').append(mine.length());
+                    for (String element : parts[p]) {
+                        mine.add(element);
+                        seen.append(" | ").append(mine).append('/').append(mine.length());
+                    }
+                    StringJoiner myOther = new StringJoiner("+", "<", ">");
+                    mine.merge(myOther);
+                    seen.append(" | ").append(mine);
+                    myOther.add("p").add("q");
+                    mine.merge(myOther);
+                    seen.append(" | ").append(mine);
+                    mine.merge(mine);
+                    seen.append(" | ").append(mine);
+                    mine.add(null);
+                    seen.append(" | ").append(mine);
+                    Bulk.p(key, seen.toString());
+                }
+            }
+            Bulk.pThrown("nullDelimiter", NullPointerException.class, () -> new StringJoiner(null));
+        });
+        Bulk.check("UtilClasses.eventObjectMatchesTheJdk", () -> {
+            Object source = "the source";
+            EventObject mine = new EventObject(source);
+            Bulk.p("sameSource", mine.getSource() == source);
+            Bulk.p("toString", mine.toString());
+            try {
+                new EventObject(null);
+                Bulk.p("nullSource", "none");
+            } catch (IllegalArgumentException e) {
+                Bulk.p("nullSource", e.getMessage());
+            }
+        });
+        Bulk.check("UtilClasses.exceptionsCarryWhatTheJdkOnesCarry", () -> {
+            IOException io = new IOException("disk");
+            Bulk.p("uncheckedMessage", new UncheckedIOException(io).getMessage());
+            Bulk.p("uncheckedCause", new UncheckedIOException("m", io).getCause() == io);
+            Bulk.p("uncheckedOwnMessage", new UncheckedIOException("m", io).getMessage());
+            Bulk.pThrown("uncheckedNullCause", NullPointerException.class, () -> new UncheckedIOException("m", null));
+
+            Throwable target = new IllegalStateException("why");
+            InvocationTargetException mine = new InvocationTargetException(target);
+            Bulk.p("targetException", mine.getTargetException() == target);
+            Bulk.p("targetCause", mine.getCause() == target);
+            Bulk.p("targetMessage", mine.getMessage());
+            Bulk.p("targetOwnMessage", new InvocationTargetException(target, "m").getMessage());
+            // java.lang.MatchException is not compared: the program is compiled
+            // for release 17, which does not have it.
+        });
+        Bulk.check("UtilClasses.loadReadsTheFormatAsTheJdkDoes", () -> {
+            Properties actual = new Properties();
+            actual.load(new ByteArrayInputStream(TEXT.getBytes(StandardCharsets.ISO_8859_1)));
+            Bulk.p("fromStream", table(actual));
+            Bulk.p("plain", actual.getProperty("plain"));
+            Bulk.p("continued", actual.getProperty("continued"));
+
+            Properties actualText = new Properties();
+            actualText.load(new StringReader(TEXT));
+            Bulk.p("fromReader", table(actualText));
+
+            // A stream is ISO 8859-1, not UTF-8: each byte is one character.
+            byte[] utf8 = ("k=" + (char) 0xe9).getBytes(StandardCharsets.UTF_8);
+            Properties ownUtf8 = new Properties();
+            ownUtf8.load(new ByteArrayInputStream(utf8));
+            Bulk.p("utf8AsLatin1", ownUtf8.getProperty("k"));
+            Bulk.p("utf8Length", ownUtf8.getProperty("k").length());
+        });
+        // The original stored with JavaAPI and read back with the JDK, and the
+        // other way around. One run has one implementation, so this compares
+        // what each one WRITES, entry by entry, and that it reads it back.
+        Bulk.check("UtilClasses.storeAndLoadRoundTripAcrossTheTwoImplementations", () -> {
+            Random random = new Random(7);
+            String alphabet = "ab =:#!" + BS + "\t\n\r\f" + (char) 0xe9 + (char) 0x4e2d + (char) 1 + "~";
+            Properties ours = new Properties();
+            for (int i = 0; i < 300; i++) {
+                StringBuilder key = new StringBuilder("k" + i);
+                StringBuilder value = new StringBuilder();
+                for (int j = random.nextInt(8); j > 0; j--) {
+                    key.append(alphabet.charAt(random.nextInt(alphabet.length())));
+                }
+                for (int j = random.nextInt(12); j > 0; j--) {
+                    value.append(alphabet.charAt(random.nextInt(alphabet.length())));
+                }
+                ours.setProperty(key.toString(), value.toString());
+            }
+            TreeMap<String, String> expected = table(ours);
+            Bulk.p("table", expected);
+
+            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+            ours.store(bytes, "a comment\nof two lines " + (char) 0x4e2d);
+            boolean printable = true;
+            for (byte b : bytes.toByteArray()) {
+                printable &= b == '\n' || (b >= 0x20 && b <= 0x7e);
+            }
+            Bulk.p("streamIsPrintableAscii", printable);
+            Bulk.p("storedStream", stored(new String(bytes.toByteArray(), StandardCharsets.ISO_8859_1),
+                    new String[] {"#a comment", "#of two lines"}));
+            Properties ownRead = new Properties();
+            ownRead.load(new ByteArrayInputStream(bytes.toByteArray()));
+            Bulk.p("streamReadsBack", expected.equals(table(ownRead)));
+
+            StringWriter text = new StringWriter();
+            ours.store(text, null);
+            Bulk.p("storedWriter", stored(text.toString(), new String[0]));
+            Properties textRead = new Properties();
+            textRead.load(new StringReader(text.toString()));
+            Bulk.p("writerReadsBack", expected.equals(table(textRead)));
+
+            Properties notAString = new Properties();
+            notAString.put("k", Integer.valueOf(1));
+            Bulk.pThrown("notAString", ClassCastException.class, () -> notAString.store(new StringWriter(), null));
+        });
+        Bulk.check("UtilClasses.defaultsStandBehindTheTable", () -> {
+            Properties defaults = new Properties();
+            defaults.setProperty("a", "default a");
+            defaults.setProperty("b", "default b");
+            Properties p = new Properties(defaults);
+            p.setProperty("a", "own a");
+            p.put("notAString", Integer.valueOf(1));
+
+            Bulk.p("a", p.getProperty("a"));
+            Bulk.p("b", p.getProperty("b"));
+            Bulk.p("c", p.getProperty("c"));
+            Bulk.p("cDefault", p.getProperty("c", "fallback"));
+            Bulk.p("notAString", p.getProperty("notAString"));
+            Bulk.p("stringPropertyNames", new TreeSet<String>(p.stringPropertyNames()));
+            List<String> names = new ArrayList<String>();
+            for (Object name : Collections.list(p.propertyNames())) {
+                names.add(String.valueOf(name));
+            }
+            Bulk.p("propertyNames", Bulk.sorted(names));
+            // The table itself holds only its own entries, and is a Hashtable as the JDK's is.
+            Bulk.p("size", p.size());
+            Bulk.p("isHashtable", p instanceof java.util.Hashtable);
+        });
+        Bulk.check("UtilClasses.uuidParsesPrintsAndComparesAsTheJdkDoes", () -> {
+            Random random = new Random(3);
+            UUID previous = null;
+            int hash = 0;
+            boolean roundTrips = true;
+            for (int i = 0; i < 500; i++) {
+                long most = random.nextLong();
+                long least = random.nextLong();
+                UUID actual = new UUID(most, least);
+                String row = actual + " " + actual.hashCode() + " " + actual.version() + " " + actual.variant()
+                        + " " + (previous == null ? 0 : Integer.signum(actual.compareTo(previous)));
+                if (i < 3) {
+                    Bulk.p("row" + i, row);
+                }
+                hash = 31 * hash + row.hashCode();
+                UUID parsed = UUID.fromString(actual.toString());
+                roundTrips &= actual.equals(parsed) && parsed.getMostSignificantBits() == most
+                        && parsed.getLeastSignificantBits() == least;
+                previous = actual;
+            }
+            Bulk.p("rows", hash);
+            Bulk.p("roundTrips", roundTrips);
+            Bulk.p("short", UUID.fromString("1-2-3-4-5").toString());
+            for (String bad : new String[] {"", "not-a-uuid", "1-2-3-4", "g-2-3-4-5"}) {
+                Bulk.pThrown("bad [" + bad + "]", IllegalArgumentException.class, () -> UUID.fromString(bad));
+            }
+        });
+        // The ParparVM run's host reads /dev/urandom, the secure source a
+        // port provides.
+        Bulk.check("UtilClasses.aRandomUuidIsVersionFourAndDistinct", () -> {
+            Set<String> seen = new HashSet<String>();
+            boolean ok = true;
+            for (int i = 0; i < 2000; i++) {
+                UUID u = UUID.randomUUID();
+                ok &= u.version() == 4 && u.variant() == 2 && u.toString().equals(UUID.fromString(u.toString())
+                        .toString()) && seen.add(u.toString());
+            }
+            Bulk.p("versionFourVariantTwoDistinct", ok);
+        });
+        Bulk.cn1Only("UtilClasses.aRandomUuidWithoutASecureSource", () -> {
+            JdkHost.install(new JdkHost() {
+            });
+            Bulk.expect("UnsupportedOperationException".equals(Bulk.thrown(UnsupportedOperationException.class,
+                    () -> JdkHost.get().randomBytes(new byte[1]))), "no secure source");
+            Set<String> seen = new HashSet<String>();
+            for (int i = 0; i < 200; i++) {
+                UUID u = UUID.randomUUID();
+                Bulk.expect(u.version() == 4, "version 4");
+                Bulk.expect(u.variant() == 2, "variant 2");
+                Bulk.expect(seen.add(u.toString()), "distinct");
+            }
+        });
+        Bulk.check("UtilClasses.aNameUuidIsTheJdks", () -> {
+            // On ParparVM the MD5 is BulkHost's, the core's own Hash.
+            for (String name : new String[] {"", "a", "codenameone.com", (char) 0 + "x"}) {
+                UUID actual = UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.UTF_8));
+                Bulk.p("[" + Bulk.esc(name) + "]", actual + " version " + actual.version());
+            }
+        });
+        Bulk.cn1Only("UtilClasses.aNameUuidWithoutADigest", () -> {
+            JdkHost.install(new JdkHost() {
+            });
+            Bulk.expectEquals("UnsupportedOperationException", Bulk.thrown(UnsupportedOperationException.class,
+                    () -> UUID.nameUUIDFromBytes(new byte[1])), "no MD5");
+        });
+        Bulk.check("UtilClasses.hexFormatFormatsAndParsesAsDocumented", () -> {
+            byte[] bytes = {0, 1, 0x7f, (byte) 0x80, (byte) 0xff, 0x2a};
+            HexFormat plain = HexFormat.of();
+            Bulk.p("format", plain.formatHex(bytes));
+            Bulk.p("parse", plain.parseHex("00017f80ff2a"));
+            Bulk.p("parseUpper", plain.parseHex("00017F80FF2A"));
+            Bulk.p("formatRange", plain.formatHex(bytes, 1, 3));
+
+            HexFormat fancy = HexFormat.ofDelimiter(", ").withPrefix("#").withSuffix(";").withUpperCase();
+            Bulk.p("fancy", fancy.formatHex(bytes));
+            Bulk.p("fancyParse", fancy.parseHex("#00;, #01;, #7F;, #80;, #FF;, #2A;"));
+            Bulk.p("delimiter", fancy.delimiter());
+            Bulk.p("prefix", fancy.prefix());
+            Bulk.p("suffix", fancy.suffix());
+            Bulk.p("isUpperCase", fancy.isUpperCase());
+            Bulk.p("lowerIsUpperCase", fancy.withLowerCase().isUpperCase());
+            Bulk.p("equals", fancy.equals(HexFormat.ofDelimiter(", ").withPrefix("#").withSuffix(";").withUpperCase()));
+
+            Bulk.pThrown("parseOdd", IllegalArgumentException.class, () -> plain.parseHex("0"));
+            Bulk.pThrown("parseBad", IllegalArgumentException.class, () -> plain.parseHex("zz"));
+            Bulk.pThrown("formatBadRange", IndexOutOfBoundsException.class, () -> plain.formatHex(bytes, 4, 2));
+
+            Bulk.p("byte", plain.toHexDigits((byte) 42));
+            Bulk.p("short", plain.toHexDigits((short) 42));
+            Bulk.p("int", plain.toHexDigits(42));
+            Bulk.p("long", plain.toHexDigits(42L));
+            Bulk.p("longDigits", plain.toHexDigits(42L, 3));
+            Bulk.p("low", plain.toLowHexDigit(0x2a));
+            Bulk.p("high", plain.toHighHexDigit(0x2a));
+            Bulk.p("isHexF", HexFormat.isHexDigit('F'));
+            Bulk.p("isHexG", HexFormat.isHexDigit('g'));
+            Bulk.p("fromDigit", HexFormat.fromHexDigit('f'));
+            Bulk.p("fromDigits", HexFormat.fromHexDigits("7fffffff"));
+            Bulk.p("fromDigitsToLong", HexFormat.fromHexDigitsToLong("ffffffffffffffff"));
+            Bulk.pThrown("fromDigitX", NumberFormatException.class, () -> HexFormat.fromHexDigit('x'));
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/WeakHashMapChecks.java b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/WeakHashMapChecks.java
new file mode 100644
index 00000000000..e09c117b06f
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/WeakHashMapChecks.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.TreeMap;
+import java.util.WeakHashMap;
+
+/// java.util.WeakHashMap while every key is strongly held, which is the
+/// only time two runs are comparable: what a collector clears, and when, is
+/// not something either promises.
+public final class WeakHashMapChecks {
+    private WeakHashMapChecks() {
+    }
+
+    /// Equal by value and colliding on purpose, so that a bucket holds several keys.
+    private static final class WeakHashMapKey implements Comparable<WeakHashMapKey> {
+        final int id;
+
+        WeakHashMapKey(int id) {
+            this.id = id;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o instanceof WeakHashMapKey && ((WeakHashMapKey) o).id == id;
+        }
+
+        @Override
+        public int hashCode() {
+            return id % 7;
+        }
+
+        @Override
+        public int compareTo(WeakHashMapKey o) {
+            return Integer.compare(id, o.id);
+        }
+
+        @Override
+        public String toString() {
+            return "k" + id;
+        }
+    }
+
+    /// Runs the group.
+    public static void run() {
+        Bulk.check("WeakHashMap.aRandomSequenceOfOperationsMatchesTheJdk", () -> {
+            Random random = new Random(20260917L);
+            // Strong references to every key ever used: nothing may be cleared.
+            List<WeakHashMapKey> held = new ArrayList<WeakHashMapKey>();
+            for (int i = 0; i < 40; i++) {
+                held.add(new WeakHashMapKey(i));
+            }
+            WeakHashMap<WeakHashMapKey, String> map = new WeakHashMap<WeakHashMapKey, String>(4);
+            StringBuilder trace = new StringBuilder();
+            for (int step = 0; step < 4000; step++) {
+                WeakHashMapKey key = held.get(random.nextInt(held.size()));
+                // An equal key that is another object: found by equals, not identity.
+                WeakHashMapKey equal = new WeakHashMapKey(key.id);
+                String value = random.nextInt(8) == 0 ? null : "v" + step;
+                switch (random.nextInt(6)) {
+                    case 0:
+                    case 1:
+                        trace.append("put:").append(map.put(key, value));
+                        break;
+                    case 2:
+                        trace.append("remove:").append(map.remove(equal));
+                        break;
+                    case 3:
+                        trace.append("get:").append(map.get(equal));
+                        trace.append(",containsKey:").append(map.containsKey(equal));
+                        break;
+                    case 4:
+                        trace.append("containsValue:").append(map.containsValue(value));
+                        break;
+                    default:
+                        if (random.nextInt(200) == 0) {
+                            map.clear();
+                            trace.append("clear");
+                        }
+                        break;
+                }
+                trace.append(" n").append(map.size()).append(map.isEmpty() ? " e" : "").append(';');
+                if (step % 200 == 199) {
+                    Bulk.p("steps" + (step - 199), trace.toString());
+                    trace.setLength(0);
+                }
+            }
+            Bulk.p("sorted", new TreeMap<WeakHashMapKey, String>(map));
+            Bulk.p("keySetSize", map.keySet().size());
+            Bulk.p("values", new ArrayList<String>(new TreeMap<WeakHashMapKey, String>(map).values()));
+            // What the key set view iterates, against the JDK's: sorted, so the
+            // two hash orders cannot differ.
+            Bulk.p("keySet", Bulk.sorted(map.keySet()));
+        });
+        Bulk.check("WeakHashMap.theNullKeyIsAKeyLikeAnyOther", () -> {
+            WeakHashMap<Object, String> map = new WeakHashMap<Object, String>();
+            Bulk.p("put1", map.put(null, "a"));
+            Bulk.p("put2", map.put(null, "b"));
+            Bulk.p("get", map.get(null));
+            Bulk.p("containsKey", map.containsKey(null));
+            Bulk.p("size", map.size());
+            Bulk.p("remove", map.remove(null));
+            Bulk.p("containsKeyAfter", map.containsKey(null));
+            Bulk.p("isEmpty", map.isEmpty());
+        });
+        Bulk.check("WeakHashMap.theConstructorsRejectWhatTheJdkRejects", () -> {
+            Bulk.pThrown("capacityNegative", IllegalArgumentException.class,
+                    () -> new WeakHashMap<Object, Object>(-1, 1));
+            Bulk.pThrown("loadFactorZero", IllegalArgumentException.class,
+                    () -> new WeakHashMap<Object, Object>(4, 0));
+            Bulk.pThrown("loadFactorNegative", IllegalArgumentException.class,
+                    () -> new WeakHashMap<Object, Object>(4, -1));
+            try {
+                new WeakHashMap<Object, Object>(4, Float.NaN);
+                Bulk.p("nan", "none");
+            } catch (IllegalArgumentException e) {
+                Bulk.p("nan", "IllegalArgumentException");
+                Bulk.p("nanCause", e.getCause());
+            }
+            Map<String, String> source = new TreeMap<String, String>();
+            source.put("a", "1");
+            source.put("b", "2");
+            Bulk.p("copy", Bulk.sortedMap(new WeakHashMap<String, String>(source)));
+            Bulk.p("copyEquals", source.equals(new WeakHashMap<String, String>(source)));
+        });
+        Bulk.check("WeakHashMap.anEntryDoesNotKeepItsKeyAlive", () -> {
+            // A collector is asked, not ordered, so the check gives it time
+            // and makes no claim about whether the dropped key went: only
+            // that what remains is consistent either way.
+            WeakHashMap<Object, String> map = new WeakHashMap<Object, String>();
+            Object kept = new Object();
+            map.put(kept, "kept");
+            map.put(new Object(), "dropped");
+            for (int i = 0; i < 50 && map.size() > 1; i++) {
+                System.gc();
+                Thread.sleep(20);
+            }
+            Bulk.p("getKept", map.get(kept));
+            int size = map.size();
+            Bulk.p("sizeInRange", size >= 1 && size <= 2);
+            boolean consistent = true;
+            if (size == 1) {
+                consistent = map.keySet().iterator().next() == kept && !map.containsValue("dropped");
+            }
+            Bulk.p("consistent", consistent);
+        });
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/META-INF/services/ServiceLoaderEmpty b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/META-INF/services/ServiceLoaderEmpty
new file mode 100644
index 00000000000..4c51096a821
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/META-INF/services/ServiceLoaderEmpty
@@ -0,0 +1,2 @@
+# No provider at all.
+
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/META-INF/services/ServiceLoaderGreeter b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/META-INF/services/ServiceLoaderGreeter
new file mode 100644
index 00000000000..26ad7002d42
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/META-INF/services/ServiceLoaderGreeter
@@ -0,0 +1,7 @@
+# The providers of the differential test, with everything a services file may hold.
+ServiceLoaderEnglish   # a comment after a name
+
+   ServiceLoaderFrench
+#ServiceLoaderCommented
+ServiceLoaderEnglish
+	ServiceLoaderGerman	
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages.properties b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages.properties
new file mode 100644
index 00000000000..22d17c6df7c
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages.properties
@@ -0,0 +1,4 @@
+# Base bundle
+greeting=Hello
+farewell = Goodbye
+only.base=base
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages_fr.properties b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages_fr.properties
new file mode 100644
index 00000000000..e42677fb9c0
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages_fr.properties
@@ -0,0 +1,3 @@
+greeting=Bonjour
+farewell=Au revoir
+only.fr=fr
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages_fr_CA.properties b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages_fr_CA.properties
new file mode 100644
index 00000000000..a0b368bc7ce
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/Messages_fr_CA.properties
@@ -0,0 +1 @@
+greeting=Allo
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/NoBase_de.properties b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/NoBase_de.properties
new file mode 100644
index 00000000000..36753206024
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/bundles/NoBase_de.properties
@@ -0,0 +1 @@
+key=nur deutsch
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/odd-name-es.txt b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/odd-name-es.txt
new file mode 100644
index 00000000000..14caaec2edb
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/odd-name-es.txt
@@ -0,0 +1 @@
+greeting=Registrado
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/odd-name.txt b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/odd-name.txt
new file mode 100644
index 00000000000..14080ff121b
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/odd-name.txt
@@ -0,0 +1 @@
+greeting=Registered
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/plain.txt b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/plain.txt
new file mode 100644
index 00000000000..06fcdd77c93
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/bulk/res/com/codename1/bulk/registered/plain.txt
@@ -0,0 +1,2 @@
+first line
+second line
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/FileTestApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/FileTestApp.java
new file mode 100644
index 00000000000..e8042b8a8b7
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/FileTestApp.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.io.File;
+public class FileTestApp {
+    static void run(String[] args) {
+        // Translated without Codename One: the program brings its file system.
+        com.codename1.impl.JdkHost.install(new com.codename1.impl.PosixJdkHost());
+        try {
+            // Construct string manually to avoid constant pool issues in test env
+            char[] pathChars = new char[]{'t','e','s','t','f','i','l','e','.','t','x','t'};
+            String path = new String(pathChars);
+            File f = new File(path);
+            if (f.exists()) {
+                f.delete();
+            }
+            boolean created = f.createNewFile();
+            if (!created) throw new RuntimeException("Create failed");
+            if (!f.exists()) throw new RuntimeException("Exists failed");
+            if (f.isDirectory()) throw new RuntimeException("IsDirectory failed");
+            if (!f.delete()) throw new RuntimeException("Delete failed");
+            if (f.exists()) throw new RuntimeException("Delete verification failed");
+            // File.list(): nothing exercised it before, so the native listing --
+            // rewritten from a racy count-then-refill pair into one enumeration --
+            // was compiled but never RUN by this suite.
+            char[] dirChars = new char[]{'l','s','d','i','r'};
+            File dir = new File(new String(dirChars));
+            dir.mkdir();
+            char[] aChars = new char[]{'l','s','d','i','r','/','a'};
+            char[] bChars = new char[]{'l','s','d','i','r','/','b'};
+            File fa = new File(new String(aChars));
+            File fb = new File(new String(bChars));
+            fa.createNewFile();
+            fb.createNewFile();
+            String[] names = dir.list();
+            if (names == null) throw new RuntimeException("list returned null");
+            if (names.length != 2) throw new RuntimeException("list length");
+            // A trailing null is what the old two-pass version produced when the
+            // second walk saw fewer entries than the first.
+            if (names[0] == null || names[1] == null) throw new RuntimeException("null entry");
+            // The result must be a String[], not a String: allocArray installs the
+            // class it is handed as the ARRAY's own class.
+            Object asObject = names;
+            if (!(asObject instanceof String[])) throw new RuntimeException("not a String[]");
+            boolean sawA = false; boolean sawB = false;
+            for (int i = 0; i < names.length; i++) {
+                if (names[i].equals(new String(new char[]{'a'}))) sawA = true;
+                if (names[i].equals(new String(new char[]{'b'}))) sawB = true;
+            }
+            if (!sawA || !sawB) throw new RuntimeException("missing entry");
+            fa.delete(); fb.delete(); dir.delete();
+            // A REGRESSION GUARD, not a proof of atomicity -- stated plainly
+            // because the difference is easy to misread. This checks the
+            // uncontended path: createNewFile on an existing file returns false
+            // and leaves it intact. The check-then-act version it replaced passes
+            // this too, since access() succeeds and it returns before ever
+            // reaching the fopen that would truncate. Verified by running it
+            // against the old code: 5/5 green.
+            //
+            // The actual defect needs a file to appear BETWEEN the check and the
+            // open, which one thread cannot produce, so no single-threaded test
+            // can demonstrate it. The correctness argument is structural instead:
+            // one O_EXCL syscall where there were two operations, with the kernel
+            // deciding who wins. What this guards is that the rewrite did not
+            // break the ordinary path.
+            char[] exChars = new char[]{'e','x','c','l','.','t','x','t'};
+            File ex = new File(new String(exChars));
+            if (ex.exists()) ex.delete();
+            if (!ex.createNewFile()) throw new RuntimeException("first create");
+            java.io.FileOutputStream os = new java.io.FileOutputStream(ex);
+            os.write(new byte[]{1,2,3,4});
+            os.close();
+            if (ex.createNewFile()) throw new RuntimeException("second create returned true");
+            if (ex.length() != 4) throw new RuntimeException("existing file was truncated");
+            ex.delete();
+            // renameTo was never exercised, which is how an implementation that
+            // renamed the destination onto itself survived. Content is checked
+            // too: the aliased version reported success while moving nothing.
+            char[] rnChars = new char[]{'r','n','-','s','r','c'};
+            char[] rdChars = new char[]{'r','n','-','d','s','t','-','l','o','n','g','e','r'};
+            File rsrc = new File(new String(rnChars));
+            File rdst = new File(new String(rdChars));
+            if (rsrc.exists()) rsrc.delete();
+            if (rdst.exists()) rdst.delete();
+            rsrc.createNewFile();
+            java.io.FileOutputStream ros = new java.io.FileOutputStream(rsrc);
+            ros.write(new byte[]{7,7,7});
+            ros.close();
+            if (!rsrc.renameTo(rdst)) throw new RuntimeException("rename returned false");
+            if (rsrc.exists()) throw new RuntimeException("source still present");
+            if (!rdst.exists()) throw new RuntimeException("destination missing");
+            if (rdst.length() != 3) throw new RuntimeException("content not moved");
+            rdst.delete();
+        } catch (Exception e) {
+            // e.printStackTrace(); // Can't print stack trace without constants
+            System.exit(1);
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/HostLocksApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/HostLocksApp.java
new file mode 100644
index 00000000000..0de8495ef4f
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/HostLocksApp.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/// The program HostLocksIntegrationTest builds once per compiler configuration.
+///
+/// PosixHostApp runs first because it checks the JdkHost DEFAULTS, which only
+/// hold while nothing has been installed; it uninstalls its host when it is
+/// done, and FileTestApp installs its own. Either exits 1 on a failure. Each
+/// part's entry point is `run`, not `main`: the translator takes the one
+/// `main(String[])` in the program as its entry point and refuses a second.
+///
+/// The three lock programs are built and never run, as they were when each had
+/// a test of its own: their run was switched off because the executable crashed
+/// on Linux runners. They must still be REACHABLE, or the dead-code pass drops
+/// them and the build covers nothing -- hence a branch no command line takes.
+public class HostLocksApp {
+    public static void main(String[] args) throws Exception {
+        PosixHostApp.run(args);
+        FileTestApp.run(args);
+        if (args != null && args.length > 99) {
+            LockTestApp.run(args);
+            ReadWriteLockTestApp.run(args);
+            StampedLockTestApp.run(args);
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/LockTestApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/LockTestApp.java
new file mode 100644
index 00000000000..2c69cd3482c
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/LockTestApp.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.concurrent.locks.*;
+import java.util.concurrent.TimeUnit;
+public class LockTestApp {
+    private static native void report(String msg);
+
+    static void run(String[] args) {
+        testBasicLock();
+        testReentrancy();
+        testTryLock();
+        testCondition();
+    }
+
+    private static void testBasicLock() {
+        ReentrantLock lock = new ReentrantLock();
+        lock.lock();
+        try {
+             report("TEST: Basic Lock OK");
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    private static void testReentrancy() {
+        ReentrantLock lock = new ReentrantLock();
+        lock.lock();
+        try {
+            lock.lock();
+            try {
+                if (lock.getHoldCount() == 2) {
+                    report("TEST: Reentrancy OK");
+                }
+            } finally {
+                lock.unlock();
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    private static void testTryLock() {
+        ReentrantLock lock = new ReentrantLock();
+        if (lock.tryLock()) {
+            try {
+                report("TEST: TryLock OK");
+            } finally {
+                lock.unlock();
+            }
+        } else {
+            report("TEST: TryLock FAILED");
+        }
+    }
+
+    private static void testCondition() {
+        final ReentrantLock lock = new ReentrantLock();
+        final Condition cond = lock.newCondition();
+        final boolean[] signalled = new boolean[1];
+
+        Thread t = new Thread(new Runnable() {
+            public void run() {
+                lock.lock();
+                try {
+                    signalled[0] = true;
+                    cond.signal();
+                } finally {
+                    lock.unlock();
+                }
+            }
+        });
+
+        lock.lock();
+        try {
+            t.start();
+            cond.await();
+            if (signalled[0]) {
+                report("TEST: Condition OK");
+            }
+        } catch (InterruptedException e) {
+            report("TEST: Condition INTERRUPTED");
+        } finally {
+            lock.unlock();
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/PosixHostApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/PosixHostApp.java
new file mode 100644
index 00000000000..04e503fe770
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/PosixHostApp.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import com.codename1.impl.JdkHost;
+import com.codename1.impl.PosixJdkHost;
+import java.io.File;
+import java.io.InputStream;
+import java.io.OutputStream;
+public class PosixHostApp {
+    static void check(boolean ok, String what) {
+        if (!ok) { System.out.println("FAIL " + what); System.exit(1); }
+    }
+    static void write(JdkHost h, String path, boolean append, byte[] data) throws Exception {
+        OutputStream o = h.fileWrite(path, append);
+        o.write(data);
+        o.close();
+    }
+    static void run(String[] args) throws Exception {
+        // Nothing installed: the plain-Java defaults, which touch no native.
+        JdkHost d = JdkHost.get();
+        check(d != null && !(d instanceof PosixJdkHost), "defaults");
+        check(d.fileStat("anything") == null, "default stat");
+        check(!d.fileMkdir("anything"), "default mkdir");
+        boolean threw = false;
+        try { d.fileRead("anything"); } catch (java.io.IOException e) { threw = true; }
+        check(threw, "default read throws");
+        d.setPreference("k", "v");
+        check("v".equals(d.preference("k")), "default preference");
+        d.deletePreference("k");
+        check(d.preference("k") == null, "default preference deleted");
+        check(d.providers("svc").length == 0, "no registry");
+
+        JdkHost.install(new PosixJdkHost());
+        JdkHost h = JdkHost.get();
+        check(h instanceof PosixJdkHost, "installed");
+        String home = h.appHome();
+        check(home != null && home.length() > 0 && !home.endsWith("."), "home " + home);
+        check(h.fileStat(home) != null && h.fileStat(home).isDirectory(), "home is a directory");
+        String dir = home + "/posix-host-dir";
+        String a = dir + "/a.txt";
+        String b = dir + "/b.txt";
+        h.fileDelete(a); h.fileDelete(b); h.fileDelete(dir);
+        check(h.fileStat(dir) == null, "clean start");
+        check(h.fileMkdir(dir), "mkdir");
+        check(!h.fileMkdir(dir), "mkdir of an existing directory");
+        write(h, a, false, new byte[] {1, 2, 3});
+        write(h, a, true, new byte[] {4});
+        JdkHost.FileStat st = h.fileStat(a);
+        check(st != null && !st.isDirectory() && st.length() == 4, "stat after append");
+        check(st.lastModified() > 0, "modified time");
+        InputStream in = h.fileRead(a);
+        byte[] buf = new byte[8];
+        int n = in.read(buf);
+        in.close();
+        check(n == 4 && buf[0] == 1 && buf[3] == 4, "read back");
+        write(h, a, false, new byte[] {9});
+        check(h.fileStat(a).length() == 1, "overwrite truncates");
+        String[] names = h.fileList(dir);
+        check(names != null && names.length == 1 && "a.txt".equals(names[0]), "list");
+        check(h.fileList(a) == null, "list of a file");
+        check(h.fileRename(a, b), "rename");
+        check(h.fileStat(a) == null && h.fileStat(b) != null, "renamed");
+        write(h, a, false, new byte[] {5});
+        check(!h.fileRename(a, b), "rename onto an existing file");
+        check(h.fileStat(b).length() == 1, "destination untouched");
+        check(!h.fileDelete(dir), "delete of a non-empty directory");
+        check(h.fileDelete(a) && h.fileDelete(b) && h.fileDelete(dir), "delete");
+        check(!h.fileDelete(dir), "delete of nothing");
+        threw = false;
+        try { h.fileRead(a); } catch (java.io.IOException e) { threw = true; }
+        check(threw, "read of a missing file throws");
+        // 0 is "unknown": the volume natives answer it unless the build
+        // defines CN1_ENABLE_FILE_SYSTEM_STATS.
+        check(h.fileTotalSpace(home) >= 0 && h.fileUsableSpace(home) >= 0, "space");
+        check(h.cachesDir() != null, "caches dir");
+        // Only where the source exists; the Windows hosts have none.
+        if (new File("/dev/urandom").exists()) {
+            byte[] r = new byte[64];
+            h.randomBytes(r);
+            boolean nonZero = false;
+            for (int i = 0; i < r.length; i++) { if (r[i] != 0) { nonZero = true; } }
+            check(nonZero, "random bytes");
+        }
+        JdkHost.install(null);
+        check(!(JdkHost.get() instanceof PosixJdkHost), "uninstalled");
+        System.out.println("POSIX-HOST-OK");
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/ReadWriteLockTestApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/ReadWriteLockTestApp.java
new file mode 100644
index 00000000000..3f48053c385
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/ReadWriteLockTestApp.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.concurrent.locks.*;
+import java.util.concurrent.TimeUnit;
+public class ReadWriteLockTestApp {
+    private static native void report(String msg);
+
+    static void run(String[] args) {
+        testBasicReadLock();
+        testWriteLockExclusion();
+        testReentrancy();
+    }
+
+    private static void testBasicReadLock() {
+        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
+        rw.readLock().lock();
+        try {
+             report("TEST: Basic Read Lock OK");
+        } finally {
+            rw.readLock().unlock();
+        }
+    }
+
+    private static void testWriteLockExclusion() {
+        final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
+        rw.writeLock().lock();
+
+        final boolean[] success = new boolean[1];
+        Thread t = new Thread(new Runnable() {
+            public void run() {
+                // This should block until writer unlocks
+                rw.readLock().lock();
+                rw.readLock().unlock();
+                success[0] = true;
+            }
+        });
+        t.start();
+
+        try { Thread.sleep(200); } catch(Exception e) {}
+        if (success[0]) {
+             report("TEST: Write Lock Exclusion FAILED (Reader acquired lock while writer held it)");
+             return;
+        }
+
+        rw.writeLock().unlock();
+        try { Thread.sleep(200); } catch(Exception e) {}
+        if (success[0]) {
+             report("TEST: Write Lock Exclusion OK");
+        } else {
+             report("TEST: Write Lock Exclusion FAILED (Reader did not acquire lock)");
+        }
+    }
+
+    private static void testReentrancy() {
+        ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
+        rw.writeLock().lock();
+        try {
+            rw.readLock().lock();
+            try {
+                if (rw.getWriteHoldCount() == 1 && rw.getReadHoldCount() == 1) {
+                    report("TEST: Reentrancy (Downgrade) OK");
+                }
+            } finally {
+                rw.readLock().unlock();
+            }
+        } finally {
+            rw.writeLock().unlock();
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/StampedLockTestApp.java b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/StampedLockTestApp.java
new file mode 100644
index 00000000000..a8e68200bb2
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/StampedLockTestApp.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+import java.util.concurrent.locks.*;
+import java.util.concurrent.TimeUnit;
+public class StampedLockTestApp {
+    private static native void report(String msg);
+
+    static void run(String[] args) {
+        testBasic();
+        testOptimisticRead();
+        testWriteLockExclusion();
+    }
+
+    private static void testBasic() {
+        StampedLock sl = new StampedLock();
+        long stamp = sl.writeLock();
+        try {
+             report("TEST: Basic Write Lock OK");
+        } finally {
+             sl.unlockWrite(stamp);
+        }
+
+        stamp = sl.readLock();
+        try {
+             report("TEST: Basic Read Lock OK");
+        } finally {
+             sl.unlockRead(stamp);
+        }
+    }
+
+    private static void testOptimisticRead() {
+        StampedLock sl = new StampedLock();
+        long stamp = sl.tryOptimisticRead();
+        if (stamp != 0 && sl.validate(stamp)) {
+            report("TEST: Optimistic Read Valid OK");
+        } else {
+            report("TEST: Optimistic Read Valid FAILED");
+        }
+
+        long ws = sl.writeLock();
+        if (sl.validate(stamp)) {
+            report("TEST: Optimistic Read Invalid (during write) FAILED");
+        } else {
+            report("TEST: Optimistic Read Invalid (during write) OK");
+        }
+        sl.unlockWrite(ws);
+
+        if (sl.validate(stamp)) {
+             report("TEST: Optimistic Read Invalid (after write) FAILED");
+        } else {
+             report("TEST: Optimistic Read Invalid (after write) OK");
+        }
+    }
+
+    private static void testWriteLockExclusion() {
+        final StampedLock sl = new StampedLock();
+        long stamp = sl.writeLock();
+
+        final boolean[] success = new boolean[1];
+        Thread t = new Thread(new Runnable() {
+            public void run() {
+                long s = sl.readLock();
+                sl.unlockRead(s);
+                success[0] = true;
+            }
+        });
+        t.start();
+
+        try { Thread.sleep(200); } catch(Exception e) {}
+        if (success[0]) {
+             report("TEST: Write Lock Exclusion FAILED (Reader acquired lock)");
+             return;
+        }
+
+        sl.unlockWrite(stamp);
+        try { Thread.sleep(200); } catch(Exception e) {}
+        if (success[0]) {
+             report("TEST: Write Lock Exclusion OK");
+        } else {
+             report("TEST: Write Lock Exclusion FAILED (Reader did not acquire lock)");
+        }
+    }
+}
diff --git a/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/native_report.c b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/native_report.c
new file mode 100644
index 00000000000..263f8ec69fc
--- /dev/null
+++ b/vm/tests/src/test/resources/com/codename1/tools/translator/hostlocks/native_report.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+
+/* The report natives of the three lock programs. Through the runtime's own
+ * conversion, not a hand-copied String struct: the layout is the VM's to
+ * change, and a fixture that mirrors it stops compiling. */
+#include "cn1_globals.h"
+#include <stdio.h>
+
+static void hostLocksReport(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {
+    if (msg != JAVA_NULL) {
+        printf("%s\n", stringToUTF8(threadStateData, msg));
+        fflush(stdout);
+    }
+}
+
+void LockTestApp_report___java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {
+    hostLocksReport(threadStateData, msg);
+}
+
+void ReadWriteLockTestApp_report___java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {
+    hostLocksReport(threadStateData, msg);
+}
+
+void StampedLockTestApp_report___java_lang_String(CODENAME_ONE_THREAD_STATE, JAVA_OBJECT msg) {
+    hostLocksReport(threadStateData, msg);
+}